Branch data Line data Source code
1 : : /*
2 : : * jfet.cpp - jfet class implementation
3 : : *
4 : : * Copyright (C) 2004, 2005, 2006, 2008 Stefan Jahn <stefan@lkcc.org>
5 : : *
6 : : * This is free software; you can redistribute it and/or modify
7 : : * it under the terms of the GNU General Public License as published by
8 : : * the Free Software Foundation; either version 2, or (at your option)
9 : : * any later version.
10 : : *
11 : : * This software is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : * GNU General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU General Public License
17 : : * along with this package; see the file COPYING. If not, write to
18 : : * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
19 : : * Boston, MA 02110-1301, USA.
20 : : *
21 : : * $Id$
22 : : *
23 : : */
24 : :
25 : : #if HAVE_CONFIG_H
26 : : # include <config.h>
27 : : #endif
28 : :
29 : : #include "component.h"
30 : : #include "device.h"
31 : : #include "jfet.h"
32 : :
33 : : #define NODE_G 0 /* gate node */
34 : : #define NODE_D 1 /* drain node */
35 : : #define NODE_S 2 /* source node */
36 : :
37 : : using namespace qucs;
38 : : using namespace qucs::device;
39 : :
40 : 1 : jfet::jfet () : circuit (3) {
41 : 1 : rs = rd = NULL;
42 : 1 : type = CIR_JFET;
43 : 1 : }
44 : :
45 : 0 : void jfet::calcSP (nr_double_t frequency) {
46 [ # # ][ # # ]: 0 : setMatrixS (ytos (calcMatrixY (frequency)));
[ # # ][ # # ]
[ # # ]
47 : 0 : }
48 : :
49 : 0 : matrix jfet::calcMatrixY (nr_double_t frequency) {
50 : :
51 : : // fetch computed operating points
52 [ # # ]: 0 : nr_double_t Cgd = getOperatingPoint ("Cgd");
53 [ # # ]: 0 : nr_double_t Cgs = getOperatingPoint ("Cgs");
54 [ # # ]: 0 : nr_double_t ggs = getOperatingPoint ("ggs");
55 [ # # ]: 0 : nr_double_t ggd = getOperatingPoint ("ggd");
56 [ # # ]: 0 : nr_double_t gds = getOperatingPoint ("gds");
57 [ # # ]: 0 : nr_double_t gm = getOperatingPoint ("gm");
58 : :
59 : : // compute the models admittances
60 : 0 : nr_complex_t Ygd = nr_complex_t (ggd, 2.0 * M_PI * frequency * Cgd);
61 : 0 : nr_complex_t Ygs = nr_complex_t (ggs, 2.0 * M_PI * frequency * Cgs);
62 : 0 : nr_complex_t Yds = gds;
63 : :
64 : : // build admittance matrix and convert it to S-parameter matrix
65 [ # # ]: 0 : matrix y (3);
66 [ # # ][ # # ]: 0 : y.set (NODE_G, NODE_G, Ygd + Ygs);
67 [ # # ]: 0 : y.set (NODE_G, NODE_D, -Ygd);
68 [ # # ]: 0 : y.set (NODE_G, NODE_S, -Ygs);
69 [ # # ]: 0 : y.set (NODE_D, NODE_G, gm - Ygd);
70 [ # # ][ # # ]: 0 : y.set (NODE_D, NODE_D, Ygd + Yds);
71 [ # # ]: 0 : y.set (NODE_D, NODE_S, -Yds - gm);
72 [ # # ]: 0 : y.set (NODE_S, NODE_G, -Ygs - gm);
73 [ # # ]: 0 : y.set (NODE_S, NODE_D, -Yds);
74 [ # # ][ # # ]: 0 : y.set (NODE_S, NODE_S, Ygs + Yds + gm);
75 : 0 : return y;
76 : : }
77 : :
78 : 0 : void jfet::calcNoiseSP (nr_double_t frequency) {
79 [ # # ][ # # ]: 0 : setMatrixN (cytocs (calcMatrixCy (frequency) * z0, getMatrixS ()));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
80 : 0 : }
81 : :
82 : 0 : matrix jfet::calcMatrixCy (nr_double_t frequency) {
83 : : /* get operating points and noise properties */
84 : 0 : nr_double_t Kf = getPropertyDouble ("Kf");
85 : 0 : nr_double_t Af = getPropertyDouble ("Af");
86 : 0 : nr_double_t Ffe = getPropertyDouble ("Ffe");
87 : 0 : nr_double_t gm = fabs (getOperatingPoint ("gm"));
88 : 0 : nr_double_t Ids = fabs (getOperatingPoint ("Id"));
89 : 0 : nr_double_t T = getPropertyDouble ("Temp");
90 : :
91 : : /* compute channel noise and flicker noise generated by the DC
92 : : transconductance and current flow from drain to source */
93 : : nr_double_t i = 8 * kelvin (T) / T0 * gm / 3 +
94 : 0 : Kf * qucs::pow (Ids, Af) / qucs::pow (frequency, Ffe) / kB / T0;
95 : :
96 : : /* build noise current correlation matrix and convert it to
97 : : noise-wave correlation matrix */
98 : 0 : matrix cy = matrix (3);
99 [ # # ]: 0 : cy.set (NODE_D, NODE_D, +i);
100 [ # # ]: 0 : cy.set (NODE_S, NODE_S, +i);
101 [ # # ]: 0 : cy.set (NODE_D, NODE_S, -i);
102 [ # # ]: 0 : cy.set (NODE_S, NODE_D, -i);
103 : 0 : return cy;
104 : : }
105 : :
106 : 2 : void jfet::initModel (void) {
107 : : // fetch necessary device properties
108 : 2 : nr_double_t T = getPropertyDouble ("Temp");
109 : 2 : nr_double_t Tn = getPropertyDouble ("Tnom");
110 : 2 : nr_double_t A = getPropertyDouble ("Area");
111 : :
112 : : // compute Is temperature and area dependency
113 : 2 : nr_double_t Is = getPropertyDouble ("Is");
114 : 2 : nr_double_t N = getPropertyDouble ("N");
115 : 2 : nr_double_t Xti = getPropertyDouble ("Xti");
116 : : nr_double_t T1, T2, Eg;
117 : 2 : T2 = kelvin (T);
118 : 2 : T1 = kelvin (Tn);
119 : 2 : Eg = Egap (300);
120 : 2 : Is = pnCurrent_T (T1, T2, Is, Eg, N, Xti);
121 : 2 : setScaledProperty ("Is", Is * A);
122 : :
123 : : // compute Isr temperature and area dependency
124 : 2 : nr_double_t Isr = getPropertyDouble ("Isr");
125 : 2 : nr_double_t Nr = getPropertyDouble ("Nr");
126 : 2 : Isr = pnCurrent_T (T1, T2, Isr, Eg, Nr, Xti);
127 : 2 : setScaledProperty ("Isr", Isr * A);
128 : :
129 : : // compute Pb temperature dependency
130 : 2 : nr_double_t Pb = getPropertyDouble ("Pb");
131 : : nr_double_t PbT;
132 : 2 : PbT = pnPotential_T (T1,T2, Pb);
133 : 2 : setScaledProperty ("Pb", PbT);
134 : :
135 : : // compute Cgs and Cgd temperature and area dependency
136 : 2 : nr_double_t Cgs = getPropertyDouble ("Cgs");
137 : 2 : nr_double_t Cgd = getPropertyDouble ("Cgd");
138 : 2 : nr_double_t M = getPropertyDouble ("M");
139 : : nr_double_t F;
140 : 2 : F = A * pnCapacitance_F (T1, T2, M, PbT / Pb);
141 : 2 : setScaledProperty ("Cgs", Cgs * F);
142 : 2 : setScaledProperty ("Cgd", Cgd * F);
143 : :
144 : : // compute Vth temperature dependency
145 : 2 : nr_double_t Vt0 = getPropertyDouble ("Vt0");
146 : 2 : nr_double_t Vt0tc = getPropertyDouble ("Vt0tc");
147 : 2 : nr_double_t DT = T2 - T1;
148 : 2 : Vt0 = Vt0 + Vt0tc * DT;
149 : 2 : setScaledProperty ("Vt0", Vt0);
150 : :
151 : : // compute Beta temperature and area dependency
152 : 2 : nr_double_t Beta = getPropertyDouble ("Beta");
153 : 2 : nr_double_t Betatce = getPropertyDouble ("Betatce");
154 : 2 : Beta = Beta * qucs::exp (Betatce * DT * qucs::log (1.01));
155 : 2 : setScaledProperty ("Beta", Beta * A);
156 : :
157 : : // compute Rs and Rd area dependency
158 : 2 : nr_double_t Rs = getPropertyDouble ("Rs");
159 : 2 : nr_double_t Rd = getPropertyDouble ("Rd");
160 : 2 : setScaledProperty ("Rs", Rs / A);
161 : 2 : setScaledProperty ("Rd", Rd / A);
162 : 2 : }
163 : :
164 : 300 : void jfet::restartDC (void) {
165 : : // apply starting values to previous iteration values
166 [ + - ][ + - ]: 300 : UgdPrev = real (getV (NODE_G) - getV (NODE_D));
167 [ + - ][ + - ]: 300 : UgsPrev = real (getV (NODE_G) - getV (NODE_S));
168 : 300 : }
169 : :
170 : 2 : void jfet::initDC (void) {
171 : :
172 : : // allocate MNA matrices
173 : 2 : allocMatrixMNA ();
174 : :
175 : : // initialize scalability
176 : 2 : initModel ();
177 : :
178 : : // initialize starting values
179 : 2 : restartDC ();
180 : :
181 : : // apply polarity of JFET
182 : 2 : const char * const type = getPropertyString ("Type");
183 [ - + ]: 2 : pol = !strcmp (type, "pfet") ? -1 : 1;
184 : :
185 : : // get device temperature
186 : 2 : nr_double_t T = getPropertyDouble ("Temp");
187 : :
188 : : // possibly insert series resistance at source
189 : 2 : nr_double_t Rs = getScaledProperty ("Rs");
190 [ - + ]: 2 : if (Rs != 0.0) {
191 : : // create additional circuit if necessary and reassign nodes
192 : 0 : rs = splitResistor (this, rs, "Rs", "source", NODE_S);
193 : 0 : rs->setProperty ("Temp", T);
194 : 0 : rs->setProperty ("R", Rs);
195 : 0 : rs->setProperty ("Controlled", getName ());
196 : 0 : rs->initDC ();
197 : : }
198 : : // no series resistance at source
199 : : else {
200 : 2 : disableResistor (this, rs, NODE_S);
201 : : }
202 : :
203 : : // possibly insert series resistance at drain
204 : 2 : nr_double_t Rd = getScaledProperty ("Rd");
205 [ - + ]: 2 : if (Rd != 0.0) {
206 : : // create additional circuit if necessary and reassign nodes
207 : 0 : rd = splitResistor (this, rd, "Rd", "drain", NODE_D);
208 : 0 : rd->setProperty ("Temp", T);
209 : 0 : rd->setProperty ("R", Rd);
210 : 0 : rd->setProperty ("Controlled", getName ());
211 : 0 : rd->initDC ();
212 : : }
213 : : // no series resistance at drain
214 : : else {
215 : 2 : disableResistor (this, rd, NODE_D);
216 : : }
217 : 2 : }
218 : :
219 : 2413 : void jfet::calcDC (void) {
220 : :
221 : : // fetch device model parameters
222 : 2413 : nr_double_t Is = getScaledProperty ("Is");
223 : 2413 : nr_double_t n = getPropertyDouble ("N");
224 : 2413 : nr_double_t Isr = getScaledProperty ("Isr");
225 : 2413 : nr_double_t nr = getPropertyDouble ("Nr");
226 : 2413 : nr_double_t Vt0 = getScaledProperty ("Vt0");
227 : 2413 : nr_double_t l = getPropertyDouble ("Lambda");
228 : 2413 : nr_double_t beta = getScaledProperty ("Beta");
229 : 2413 : nr_double_t T = getPropertyDouble ("Temp");
230 : :
231 : : nr_double_t Ut, IeqG, IeqD, IeqS, UgsCrit, UgdCrit;
232 : : nr_double_t Igs, Igd, gtiny;
233 : :
234 : 2413 : T = kelvin (T);
235 : 2413 : Ut = T * kBoverQ;
236 [ + - ][ + - ]: 2413 : Ugd = real (getV (NODE_G) - getV (NODE_D)) * pol;
237 [ + - ][ + - ]: 2413 : Ugs = real (getV (NODE_G) - getV (NODE_S)) * pol;
238 : :
239 : : // critical voltage necessary for bad start values
240 : 2413 : UgsCrit = pnCriticalVoltage (Is, Ut * n);
241 : 2413 : UgdCrit = pnCriticalVoltage (Is, Ut * n);
242 : 2413 : UgsPrev = Ugs = pnVoltage (Ugs, UgsPrev, Ut * n, UgsCrit);
243 : 2413 : UgdPrev = Ugd = pnVoltage (Ugd, UgdPrev, Ut * n, UgdCrit);
244 : :
245 : 2413 : Uds = Ugs - Ugd;
246 : :
247 : : // gate-source diode
248 [ + + ]: 2413 : gtiny = Ugs < - 10 * Ut * n ? (Is + Isr) : 0;
249 : 2413 : ggs = pnConductance (Ugs, Is, Ut * n) +
250 : 2413 : pnConductance (Ugs, Isr, Ut * nr) + gtiny;
251 : 2413 : Igs = pnCurrent (Ugs, Is, Ut * n) +
252 : 2413 : pnCurrent (Ugs, Isr, Ut * nr) + gtiny * Ugs;
253 : :
254 : : // gate-drain diode
255 [ + + ]: 2413 : gtiny = Ugd < - 10 * Ut * n ? (Is + Isr) : 0;
256 : 2413 : ggd = pnConductance (Ugd, Is, Ut * n) +
257 : 2413 : pnConductance (Ugd, Isr, Ut * nr) + gtiny;
258 : 2413 : Igd = pnCurrent (Ugd, Is, Ut * n) +
259 : 2413 : pnCurrent (Ugd, Isr, Ut * nr) + gtiny * Ugd;
260 : :
261 : : // normal (forward) mode of operation
262 [ + - ]: 2413 : if (Uds >= 0) {
263 : 2413 : nr_double_t Ugst = Ugs - Vt0;
264 : : // normal mode, cutoff region
265 [ + + ]: 2413 : if (Ugst <= 0) {
266 : 1 : Ids = 0;
267 : 1 : gm = 0;
268 : 1 : gds = 0;
269 : : }
270 : : else {
271 : 2412 : nr_double_t b = beta * (1 + l * Uds);
272 : : // normal mode, saturation region
273 [ + + ]: 2412 : if (Ugst <= Uds) {
274 : 2411 : Ids = b * Ugst * Ugst;
275 : 2411 : gm = b * 2 * Ugst;
276 : 2411 : gds = l * beta * Ugst * Ugst;
277 : : }
278 : : // normal mode, linear region
279 : : else {
280 : 1 : Ids = b * Uds * (2 * Ugst - Uds);
281 : 1 : gm = b * 2 * Uds;
282 : 1 : gds = b * 2 * (Ugst - Uds) + l * beta * Uds * (2 * Ugst - Uds);
283 : : }
284 : : }
285 : : }
286 : : // inverse (backward) mode of operation
287 : : else {
288 : 0 : nr_double_t Ugdt = Ugd - Vt0;
289 : : // inverse mode, cutoff region
290 [ # # ]: 0 : if (Ugdt <= 0) {
291 : 0 : Ids = 0;
292 : 0 : gm = 0;
293 : 0 : gds = 0;
294 : : }
295 : : else {
296 : 0 : nr_double_t b = beta * (1 - l * Uds);
297 : : // inverse mode, saturation region
298 [ # # ]: 0 : if (Ugdt <= -Uds) {
299 : 0 : Ids = - b * Ugdt * Ugdt;
300 : 0 : gm = - b * 2 * Ugdt;
301 : 0 : gds = beta * l * Ugdt * Ugdt + b * 2 * Ugdt;
302 : : }
303 : : // inverse mode, linear region
304 : : else {
305 : 0 : Ids = b * Uds * (2 * Ugdt + Uds);
306 : 0 : gm = b * 2 * Uds;
307 : 0 : gds = 2 * b * Ugdt - beta * l * Uds * (2 * Ugdt + Uds);
308 : : }
309 : : }
310 : : }
311 : :
312 : : // compute autonomic current sources
313 : 2413 : IeqG = Igs - ggs * Ugs;
314 : 2413 : IeqD = Igd - ggd * Ugd;
315 : 2413 : IeqS = Ids - gm * Ugs - gds * Uds;
316 [ + - ]: 2413 : setI (NODE_G, (-IeqG - IeqD) * pol);
317 [ + - ]: 2413 : setI (NODE_D, (+IeqD - IeqS) * pol);
318 [ + - ]: 2413 : setI (NODE_S, (+IeqG + IeqS) * pol);
319 : :
320 : : // apply admittance matrix elements
321 [ + - ]: 2413 : setY (NODE_G, NODE_G, ggs + ggd);
322 [ + - ]: 2413 : setY (NODE_G, NODE_D, -ggd);
323 [ + - ]: 2413 : setY (NODE_G, NODE_S, -ggs);
324 [ + - ]: 2413 : setY (NODE_D, NODE_G, -ggd + gm);
325 [ + - ]: 2413 : setY (NODE_D, NODE_D, gds + ggd);
326 [ + - ]: 2413 : setY (NODE_D, NODE_S, -gm - gds);
327 [ + - ]: 2413 : setY (NODE_S, NODE_G, -ggs - gm);
328 [ + - ]: 2413 : setY (NODE_S, NODE_D, -gds);
329 [ + - ]: 2413 : setY (NODE_S, NODE_S, ggs + gds + gm);
330 : 2413 : }
331 : :
332 : 2406 : void jfet::loadOperatingPoints (void) {
333 : 2406 : Ugs = getOperatingPoint ("Vgs");
334 : 2406 : Ugd = getOperatingPoint ("Vgd");
335 : 2406 : Uds = getOperatingPoint ("Vds");
336 : 2406 : }
337 : :
338 : 2406 : void jfet::saveOperatingPoints (void) {
339 : : nr_double_t Vgs, Vgd;
340 [ + - ][ + - ]: 2406 : Vgd = real (getV (NODE_G) - getV (NODE_D)) * pol;
341 [ + - ][ + - ]: 2406 : Vgs = real (getV (NODE_G) - getV (NODE_S)) * pol;
342 : 2406 : setOperatingPoint ("Vgs", Vgs);
343 : 2406 : setOperatingPoint ("Vgd", Vgd);
344 : 2406 : setOperatingPoint ("Vds", Vgs - Vgd);
345 : 2406 : }
346 : :
347 : 2406 : void jfet::calcOperatingPoints (void) {
348 : :
349 : : // fetch device model parameters
350 : 2406 : nr_double_t z = getPropertyDouble ("M");
351 : 2406 : nr_double_t Cgd0 = getScaledProperty ("Cgd");
352 : 2406 : nr_double_t Cgs0 = getScaledProperty ("Cgs");
353 : 2406 : nr_double_t Pb = getScaledProperty ("Pb");
354 : 2406 : nr_double_t Fc = getPropertyDouble ("Fc");
355 : :
356 : : nr_double_t Cgs, Cgd;
357 : :
358 : : // capacitance of gate-drain diode
359 : 2406 : Cgd = pnCapacitance (Ugd, Cgd0, Pb, z, Fc);
360 : 2406 : Qgd = pnCharge (Ugd, Cgd0, Pb, z, Fc);
361 : :
362 : : // capacitance of gate-source diode
363 : 2406 : Cgs = pnCapacitance (Ugs, Cgs0, Pb, z, Fc);
364 : 2406 : Qgs = pnCharge (Ugs, Cgs0, Pb, z, Fc);
365 : :
366 : : // save operating points
367 : 2406 : setOperatingPoint ("ggs", ggs);
368 : 2406 : setOperatingPoint ("ggd", ggd);
369 : 2406 : setOperatingPoint ("gds", gds);
370 : 2406 : setOperatingPoint ("gm", gm);
371 : 2406 : setOperatingPoint ("Id", Ids);
372 : 2406 : setOperatingPoint ("Cgd", Cgd);
373 : 2406 : setOperatingPoint ("Cgs", Cgs);
374 : 2406 : }
375 : :
376 : 0 : void jfet::initAC (void) {
377 : 0 : allocMatrixMNA ();
378 : 0 : clearI ();
379 : 0 : }
380 : :
381 : 0 : void jfet::calcAC (nr_double_t frequency) {
382 [ # # ]: 0 : setMatrixY (calcMatrixY (frequency));
383 : 0 : }
384 : :
385 : 0 : void jfet::calcNoiseAC (nr_double_t frequency) {
386 [ # # ]: 0 : setMatrixN (calcMatrixCy (frequency));
387 : 0 : }
388 : :
389 : : #define qgdState 0 // gate-drain charge state
390 : : #define cgdState 1 // gate-drain current state
391 : : #define qgsState 2 // gate-source charge state
392 : : #define cgsState 3 // gate-source current state
393 : :
394 : 1 : void jfet::initTR (void) {
395 : 1 : setStates (4);
396 : 1 : initDC ();
397 : 1 : }
398 : :
399 : 2406 : void jfet::calcTR (nr_double_t) {
400 : 2406 : calcDC ();
401 : 2406 : saveOperatingPoints ();
402 : 2406 : loadOperatingPoints ();
403 : 2406 : calcOperatingPoints ();
404 : :
405 : 2406 : nr_double_t Cgs = getOperatingPoint ("Cgs");
406 : 2406 : nr_double_t Cgd = getOperatingPoint ("Cgd");
407 : :
408 : 2406 : transientCapacitance (qgsState, NODE_G, NODE_S, Cgs, Ugs, Qgs);
409 : 2406 : transientCapacitance (qgdState, NODE_G, NODE_D, Cgd, Ugd, Qgd);
410 : 2406 : }
411 : :
412 : : // properties
413 : : PROP_REQ [] = {
414 : : { "Is", PROP_REAL, { 1e-14, PROP_NO_STR }, PROP_POS_RANGE },
415 : : { "N", PROP_REAL, { 1, PROP_NO_STR }, PROP_RNGII (1, 100) },
416 : : { "Vt0", PROP_REAL, { -2, PROP_NO_STR }, PROP_NEG_RANGE },
417 : : { "Lambda", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
418 : : { "Beta", PROP_REAL, { 1e-4, PROP_NO_STR }, PROP_POS_RANGE },
419 : : { "M", PROP_REAL, { 0.5, PROP_NO_STR }, PROP_RNGII (0, 1) },
420 : : { "Pb", PROP_REAL, { 1.0, PROP_NO_STR }, PROP_RNGXI (0, 10) },
421 : : { "Fc", PROP_REAL, { 0.5, PROP_NO_STR }, PROP_RNGIX (0, 1) },
422 : : { "Cgs", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
423 : : { "Cgd", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
424 : : PROP_NO_PROP };
425 : : PROP_OPT [] = {
426 : : { "Rd", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
427 : : { "Rs", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
428 : : { "Isr", PROP_REAL, { 1e-14, PROP_NO_STR }, PROP_POS_RANGE },
429 : : { "Nr", PROP_REAL, { 2, PROP_NO_STR }, PROP_RNGII (1, 100) },
430 : : { "Kf", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
431 : : { "Af", PROP_REAL, { 1, PROP_NO_STR }, PROP_POS_RANGE },
432 : : { "Ffe", PROP_REAL, { 1, PROP_NO_STR }, PROP_POS_RANGE },
433 : : { "Temp", PROP_REAL, { 26.85, PROP_NO_STR }, PROP_MIN_VAL (K) },
434 : : { "Type", PROP_STR, { PROP_NO_VAL, "nfet" }, PROP_RNG_FET },
435 : : { "Xti", PROP_REAL, { 3, PROP_NO_STR }, PROP_POS_RANGE },
436 : : { "Vt0tc", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
437 : : { "Betatce", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
438 : : { "Tnom", PROP_REAL, { 26.85, PROP_NO_STR }, PROP_MIN_VAL (K) },
439 : : { "Area", PROP_REAL, { 1, PROP_NO_STR }, PROP_POS_RANGEX },
440 : : PROP_NO_PROP };
441 : : struct define_t jfet::cirdef =
442 : : { "JFET", 3, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_NONLINEAR, PROP_DEF };
|
