Branch data Line data Source code
1 : : /*
2 : : * rfedd.cpp - equation defined RF device class implementation
3 : : *
4 : : * Copyright (C) 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 "equation.h"
31 : : #include "environment.h"
32 : : #include "rfedd.h"
33 : :
34 : : using namespace qucs;
35 : : using namespace qucs::eqn;
36 : :
37 : : // Constructor for the equation defined RF device.
38 : 0 : rfedd::rfedd () : circuit () {
39 : 0 : type = CIR_RFEDD;
40 : 0 : setVariableSized (true);
41 : 0 : peqn = NULL;
42 : 0 : }
43 : :
44 : : // Destructor deletes equation defined RF device object from memory.
45 : 0 : rfedd::~rfedd () {
46 [ # # ][ # # ]: 0 : if (peqn) free (peqn);
47 [ # # ][ # # ]: 0 : }
48 : :
49 : : // Callback for initializing the DC analysis.
50 : 0 : void rfedd::initDC (void) {
51 : :
52 : : // get appropriate property value
53 : 0 : const char * const dc = getPropertyString ("duringDC");
54 : :
55 : : // a short during DC
56 [ # # ]: 0 : if (!strcmp (dc, "short")) {
57 : 0 : int v, n, lastnode = getSize () - 1;
58 : 0 : setVoltageSources (lastnode);
59 : 0 : allocMatrixMNA ();
60 : : // place zero voltage sources
61 [ # # ]: 0 : for (v = VSRC_1, n = NODE_1; n < lastnode; n++, v++) {
62 : 0 : voltageSource (v, n, lastnode);
63 : : }
64 : 0 : return;
65 : : }
66 : : // an open during DC
67 [ # # ]: 0 : else if (!strcmp (dc, "open")) {
68 : 0 : setVoltageSources (0);
69 : 0 : allocMatrixMNA ();
70 : 0 : return;
71 : : }
72 : : // zero frequency evaluation
73 [ # # ]: 0 : else if (!strcmp (dc, "zerofrequency")) {
74 : 0 : prepareModel ();
75 : 0 : initMNA ();
76 : 0 : calcMNA (0);
77 : 0 : return;
78 : : }
79 : : // none specified, DC value of IDFT ?
80 : : else {
81 : 0 : setVoltageSources (0);
82 : 0 : allocMatrixMNA ();
83 : : }
84 : : }
85 : :
86 : : // Some help macros.
87 : : #define A(a) ((assignment *) (a))
88 : :
89 : : // Creates a parameter variable name from the given arguments.
90 : 0 : char * rfedd::createVariable (const char * base, int r, int c, bool pfx) {
91 : 0 : char * str = strchr (getName (), '.');
92 [ # # ]: 0 : if (str != NULL)
93 : 0 : str = strrchr (str, '.') + 1;
94 : : else
95 : 0 : str = getName ();
96 : 0 : char * txt = (char *) malloc (strlen (str) + strlen (base) + 4);
97 [ # # ]: 0 : if (pfx)
98 : 0 : sprintf (txt, "%s.%s%d%d", str, base, r, c);
99 : : else
100 : 0 : sprintf (txt, "%s%d%d", base, r, c);
101 : 0 : return txt;
102 : : }
103 : :
104 : : // Creates a variable name from the given arguments.
105 : 0 : char * rfedd::createVariable (const char * base, bool pfx) {
106 : 0 : char * str = strchr (getName (), '.');
107 [ # # ]: 0 : if (str != NULL)
108 : 0 : str = strrchr (str, '.') + 1;
109 : : else
110 : 0 : str = getName ();
111 : 0 : char * txt = (char *) malloc (strlen (str) + strlen (base) + 2);
112 [ # # ]: 0 : if (pfx)
113 : 0 : sprintf (txt, "%s.%s", str, base);
114 : : else
115 : 0 : sprintf (txt, "%s", base);
116 : 0 : return txt;
117 : : }
118 : :
119 : : // Saves the given real value into the equation result.
120 : 0 : void rfedd::setResult (void * eqn, nr_double_t val) {
121 : 0 : A(eqn)->evaluate ();
122 : 0 : constant * c = A(eqn)->getResult ();
123 : 0 : c->d = val;
124 : 0 : }
125 : :
126 : : // Saves the given complex value into the equation result.
127 : 0 : void rfedd::setResult (void * eqn, nr_complex_t val) {
128 : 0 : A(eqn)->evaluate ();
129 : 0 : constant * c = A(eqn)->getResult ();
130 : 0 : *(c->c) = val;
131 : 0 : }
132 : :
133 : : // Returns the result of the equation.
134 : 0 : nr_complex_t rfedd::getResult (void * eqn) {
135 : 0 : A(eqn)->evaluate ();
136 : 0 : return A(eqn)->getResultComplex ();
137 : : }
138 : :
139 : : // Initializes the equation defined device.
140 : 0 : void rfedd::initModel (void) {
141 : 0 : int i, j, k, ports = getSize ();
142 : : char * pn, * sn, * snold, * fn, * fnold;
143 : : const char * vr;
144 : : eqn::node * pvalue;
145 : :
146 : : // allocate space for equation pointers
147 : 0 : peqn = (void **) malloc (sizeof (assignment *) * ports * ports);
148 : :
149 : : // first create frequency variables
150 : 0 : sn = createVariable ("S");
151 : 0 : snold = createVariable ("S", false);
152 : 0 : fn = createVariable ("F");
153 : 0 : fnold = createVariable ("F", false);
154 [ # # ]: 0 : seqn = getEnv()->getChecker()->addComplex ("#laplace", sn, nr_complex_t (0, 0));
155 : 0 : feqn = getEnv()->getChecker()->addDouble ("#frequency", fn, 0);
156 : 0 : A(seqn)->evalType (); A(seqn)->skip = 1;
157 : 0 : A(feqn)->evalType (); A(feqn)->skip = 1;
158 : :
159 : : // obtain type of parameters
160 : 0 : const char * const type = getPropertyString ("Type");
161 : :
162 : : // prepare device equations
163 [ # # ]: 0 : for (k = 0, i = 0; i < ports; i++) {
164 [ # # ]: 0 : for (j = 0; j < ports; j++, k++) {
165 : : // find equation referenced in property
166 : 0 : pn = createVariable ("P", i + 1, j + 1, false);
167 : 0 : vr = getPropertyReference (pn);
168 : 0 : pvalue = getEnv()->getChecker()->findEquation (vr);
169 [ # # ]: 0 : if (!pvalue) {
170 : : logprint (LOG_ERROR, "ERROR: %s-parameter equation `%s' not found for "
171 : 0 : "RFEDD `%s'\n", type, vr, getName ());
172 : : }
173 : : else {
174 : : // replace references to S and F by local references
175 : 0 : pvalue->replace (snold, sn);
176 : 0 : pvalue->replace (fnold, fn);
177 : : // evaluate types of parameters
178 : 0 : A(pvalue)->evalType ();
179 : 0 : A(pvalue)->skip = 1;
180 : : }
181 : : // save equations for parameters
182 : 0 : peqn[k] = pvalue;
183 : 0 : free (pn);
184 : : }
185 : : }
186 : :
187 : 0 : free (sn); free (snold);
188 : 0 : free (fn); free (fnold);
189 : 0 : }
190 : :
191 : : // Prepares model equations if necessary.
192 : 0 : void rfedd::prepareModel (void) {
193 [ # # ]: 0 : if (peqn == NULL) initModel ();
194 : 0 : }
195 : :
196 : : // Update local variable equations.
197 : 0 : void rfedd::updateLocals (nr_double_t frequency) {
198 : :
199 : : // update frequency variables for equations
200 [ # # ]: 0 : setResult (seqn, nr_complex_t (0, 2 * M_PI * frequency));
201 : 0 : setResult (feqn, frequency);
202 : :
203 : : // get local subcircuit values
204 : 0 : getEnv()->passConstants ();
205 : 0 : getEnv()->equationSolver ();
206 : 0 : }
207 : :
208 : : // Callback for DC analysis.
209 : 0 : void rfedd::calcDC (void) {
210 : 0 : }
211 : :
212 : : // Initializes MNA representation depending on parameter type.
213 : 0 : void rfedd::initMNA (void) {
214 : 0 : int i, ports = getSize ();
215 : 0 : const char * const type = getPropertyString ("Type");
216 [ # # # # : 0 : switch (type[0]) {
# # # # ]
217 : : case 'Y':
218 : 0 : setVoltageSources (0);
219 : 0 : allocMatrixMNA ();
220 : 0 : break;
221 : : case 'Z':
222 : 0 : setVoltageSources (ports);
223 : 0 : allocMatrixMNA ();
224 [ # # ][ # # ]: 0 : for (i = 0; i < ports; i++) setC (i, i, -1);
225 [ # # ][ # # ]: 0 : for (i = 0; i < ports; i++) setB (i, i, +1);
226 : 0 : break;
227 : : case 'S':
228 : 0 : setVoltageSources (ports);
229 : 0 : allocMatrixMNA ();
230 [ # # ][ # # ]: 0 : for (i = 0; i < ports; i++) setB (i, i, +1);
231 : 0 : break;
232 : : case 'H':
233 : 0 : setVoltageSources (1);
234 : 0 : allocMatrixMNA ();
235 [ # # ][ # # ]: 0 : setB (0, 0, +1); setC (0, 0, -1);
236 : 0 : break;
237 : : case 'G':
238 : 0 : setVoltageSources (1);
239 : 0 : allocMatrixMNA ();
240 [ # # ][ # # ]: 0 : setB (1, 0, +1); setC (0, 1, -1);
241 : 0 : break;
242 : : case 'A':
243 : 0 : setVoltageSources (1);
244 : 0 : allocMatrixMNA ();
245 [ # # ][ # # ]: 0 : setB (1, 0, -1); setC (0, 0, -1);
246 : 0 : break;
247 : : case 'T':
248 : 0 : setVoltageSources (2);
249 : 0 : allocMatrixMNA ();
250 [ # # ][ # # ]: 0 : setB (0, 0, +1); setB (1, 1, +1);
251 [ # # ][ # # ]: 0 : setC (0, 0, -1); setC (1, 0, -1);
252 : 0 : break;
253 : : }
254 : 0 : }
255 : :
256 : : // Calculates MNA representation depending on parameter type.
257 : 0 : void rfedd::calcMNA (nr_double_t frequency) {
258 [ # # ]: 0 : const char * const type = getPropertyString ("Type");
259 : 0 : int r, c, ports = getSize ();
260 [ # # ]: 0 : matrix p = calcMatrix (frequency);
261 [ # # # # : 0 : switch (type[0]) {
# # # # ]
262 : : case 'Y':
263 [ # # ][ # # ]: 0 : setMatrixY (p);
[ # # ]
264 : 0 : break;
265 : : case 'Z':
266 [ # # ]: 0 : for (r = 0; r < ports; r++)
267 [ # # ]: 0 : for (c = 0; c < ports; c++)
268 [ # # ]: 0 : setD (r, c, p (r, c));
269 : 0 : break;
270 : : case 'S':
271 [ # # ]: 0 : for (r = 0; r < ports; r++)
272 [ # # ]: 0 : for (c = 0; c < ports; c++) {
273 [ # # ]: 0 : if (r == c) {
274 [ # # ]: 0 : setC (r, c, p (r, c) - 1.0);
275 [ # # ]: 0 : setD (r, c, z0 * (p (r, c) + 1.0));
276 : : }
277 : : else {
278 [ # # ]: 0 : setC (r, c, p (r, c));
279 [ # # ]: 0 : setD (r, c, z0 * p (r, c));
280 : : }
281 : : }
282 : 0 : break;
283 : : case 'H':
284 [ # # ][ # # ]: 0 : setY (1, 1, p (1, 1)); setB (1, 0, p (1, 0));
285 [ # # ][ # # ]: 0 : setC (0, 1, p (0, 1)); setD (0, 0, p (0, 0));
286 : 0 : break;
287 : : case 'G':
288 [ # # ][ # # ]: 0 : setY (0, 0, p (0, 0)); setB (0, 0, p (0, 1));
289 [ # # ][ # # ]: 0 : setC (0, 0, p (1, 0)); setD (0, 0, p (1, 1));
290 : 0 : break;
291 : : case 'A':
292 [ # # ][ # # ]: 0 : setY (0, 1, p (1, 0)); setB (0, 0, p (1, 1));
293 [ # # ][ # # ]: 0 : setC (0, 1, p (0, 0)); setD (0, 0, p (0, 1));
294 : 0 : break;
295 : : case 'T':
296 [ # # ][ # # ]: 0 : setC (0, 1, p (0, 1) + p (0, 0));
297 [ # # ][ # # ]: 0 : setC (1, 1, p (1, 1) + p (1, 0));
298 [ # # ]: 0 : setD (0, 0, -z0);
299 [ # # ]: 0 : setD (1, 0, +z0);
300 [ # # ][ # # ]: 0 : setD (0, 1, z0 * (p (0, 1) - p (0, 0)));
301 [ # # ][ # # ]: 0 : setD (1, 1, z0 * (p (1, 1) - p (1, 0)));
302 : 0 : break;
303 [ # # ]: 0 : }
304 : 0 : }
305 : :
306 : : // Callback for initializing the AC analysis.
307 : 0 : void rfedd::initAC (void) {
308 : 0 : initMNA ();
309 : 0 : prepareModel ();
310 : 0 : }
311 : :
312 : : // Callback for AC analysis.
313 : 0 : void rfedd::calcAC (nr_double_t frequency) {
314 : 0 : calcMNA (frequency);
315 : 0 : }
316 : :
317 : : // Computes parameter matrix.
318 : 0 : matrix rfedd::calcMatrix (nr_double_t frequency) {
319 : 0 : int i, j, k, ports = getSize ();
320 : 0 : matrix p (ports);
321 : :
322 : : // update local equations
323 [ # # ]: 0 : updateLocals (frequency);
324 : :
325 : : // calculate parameters and put into Jacobian
326 [ # # ]: 0 : for (k = 0, i = 0; i < ports; i++) {
327 [ # # ]: 0 : for (j = 0; j < ports; j++, k++) {
328 [ # # ]: 0 : p (i, j) = getResult (peqn[k]);
329 : : }
330 : : }
331 : :
332 : 0 : return p;
333 : : }
334 : :
335 : : // Callback for initializing the TR analysis.
336 : 0 : void rfedd::initTR (void) {
337 : 0 : initDC ();
338 : 0 : }
339 : :
340 : : // Callback for the TR analysis.
341 : 0 : void rfedd::calcTR (nr_double_t) {
342 : 0 : calcDC ();
343 : 0 : }
344 : :
345 : : // Callback for initializing the S-parameter analysis.
346 : 0 : void rfedd::initSP (void) {
347 : 0 : allocMatrixS ();
348 : 0 : prepareModel ();
349 : 0 : }
350 : :
351 : : // Callback for S-parameter analysis.
352 : 0 : void rfedd::calcSP (nr_double_t frequency) {
353 [ # # ]: 0 : const char * const type = getPropertyString ("Type");
354 [ # # ]: 0 : matrix p = calcMatrix (frequency);
355 [ # # # # : 0 : switch (type[0]) {
# # # # ]
356 : : case 'Y':
357 [ # # ][ # # ]: 0 : setMatrixS (ytos (p));
[ # # ][ # # ]
[ # # ]
358 : 0 : break;
359 : : case 'Z':
360 [ # # ][ # # ]: 0 : setMatrixS (ztos (p));
[ # # ][ # # ]
[ # # ]
361 : 0 : break;
362 : : case 'S':
363 [ # # ][ # # ]: 0 : setMatrixS (p);
[ # # ]
364 : 0 : break;
365 : : case 'H':
366 [ # # ][ # # ]: 0 : setMatrixS (twoport (p, 'H', 'S'));
[ # # ][ # # ]
[ # # ]
367 : 0 : break;
368 : : case 'G':
369 [ # # ][ # # ]: 0 : setMatrixS (twoport (p, 'G', 'S'));
[ # # ][ # # ]
[ # # ]
370 : 0 : break;
371 : : case 'A':
372 [ # # ][ # # ]: 0 : setMatrixS (twoport (p, 'A', 'S'));
[ # # ][ # # ]
[ # # ]
373 : 0 : break;
374 : : case 'T':
375 [ # # ][ # # ]: 0 : setMatrixS (twoport (p, 'T', 'S'));
[ # # ][ # # ]
[ # # ]
376 : 0 : break;
377 [ # # ]: 0 : }
378 : 0 : }
379 : :
380 : : // properties
381 : : PROP_REQ [] = {
382 : : { "Type", PROP_STR, { PROP_NO_VAL, "Y" },
383 : : PROP_RNG_STR7 ("Y", "Z", "S", "H", "G", "A", "T") },
384 : : { "duringDC", PROP_STR, { PROP_NO_VAL, "open" },
385 : : PROP_RNG_STR4 ("open", "short", "unspecified", "zerofrequency") },
386 : : { "P11", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
387 : : PROP_NO_PROP };
388 : : PROP_OPT [] = {
389 : : { "P12", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
390 : : { "P13", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
391 : : { "P14", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
392 : : { "P15", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
393 : : { "P16", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
394 : : { "P17", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
395 : : { "P18", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
396 : : { "P21", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
397 : : { "P22", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
398 : : { "P23", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
399 : : { "P24", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
400 : : { "P25", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
401 : : { "P26", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
402 : : { "P27", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
403 : : { "P28", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
404 : : { "P31", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
405 : : { "P32", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
406 : : { "P33", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
407 : : { "P34", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
408 : : { "P35", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
409 : : { "P36", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
410 : : { "P37", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
411 : : { "P38", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
412 : : { "P41", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
413 : : { "P42", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
414 : : { "P43", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
415 : : { "P44", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
416 : : { "P45", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
417 : : { "P46", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
418 : : { "P47", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
419 : : { "P48", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
420 : : { "P51", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
421 : : { "P52", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
422 : : { "P53", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
423 : : { "P54", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
424 : : { "P55", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
425 : : { "P56", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
426 : : { "P57", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
427 : : { "P58", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
428 : : { "P61", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
429 : : { "P62", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
430 : : { "P63", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
431 : : { "P64", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
432 : : { "P65", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
433 : : { "P66", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
434 : : { "P67", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
435 : : { "P68", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
436 : : { "P71", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
437 : : { "P72", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
438 : : { "P73", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
439 : : { "P74", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
440 : : { "P75", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
441 : : { "P76", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
442 : : { "P77", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
443 : : { "P78", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
444 : : { "P81", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
445 : : { "P82", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
446 : : { "P83", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
447 : : { "P84", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
448 : : { "P85", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
449 : : { "P86", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
450 : : { "P87", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
451 : : { "P88", PROP_REAL, { 0, PROP_NO_STR }, PROP_NO_RANGE },
452 : : PROP_NO_PROP };
453 : : struct define_t rfedd::cirdef =
454 : : { "RFEDD",
455 : : PROP_NODES, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_LINEAR, PROP_DEF };
|
