Branch data Line data Source code
1 : : /*
2 : : * logic_1.core.cpp - device implementations for logic_1 module
3 : : *
4 : : * This is free software; you can redistribute it and/or modify
5 : : * it under the terms of the GNU General Public License as published by
6 : : * the Free Software Foundation; either version 2, or (at your option)
7 : : * any later version.
8 : : *
9 : : */
10 : :
11 : : #if HAVE_CONFIG_H
12 : : #include <config.h>
13 : : #endif
14 : :
15 : : #include "logic_1.analogfunction.h"
16 : : #include "component.h"
17 : : #include "device.h"
18 : : #include "logic_1.core.h"
19 : :
20 : : #ifndef CIR_logic_1
21 : : #define CIR_logic_1 -1
22 : : #endif
23 : :
24 : : // external nodes
25 : : #define L1 0
26 : : // internal nodes
27 : :
28 : : // useful macro definitions
29 : : #define NP(node) real (getV (node))
30 : : #define BP(pnode,nnode) (NP(pnode) - NP(nnode))
31 : : #define _load_static_residual2(pnode,nnode,current)\
32 : : _rhs[pnode] -= current;\
33 : : _rhs[nnode] += current;
34 : : #define _load_static_augmented_residual2(pnode,nnode,current)\
35 : : _rhs[pnode] -= current;\
36 : : _rhs[nnode] += current;
37 : : #define _load_static_residual1(node,current)\
38 : : _rhs[node] -= current;
39 : : #define _load_static_augmented_residual1(node,current)\
40 : : _rhs[node] -= current;
41 : : #define _load_static_jacobian4(pnode,nnode,vpnode,vnnode,conductance)\
42 : : _jstat[pnode][vpnode] += conductance;\
43 : : _jstat[nnode][vnnode] += conductance;\
44 : : _jstat[pnode][vnnode] -= conductance;\
45 : : _jstat[nnode][vpnode] -= conductance;\
46 : : if (doHB) {\
47 : : _ghs[pnode] += conductance * BP(vpnode,vnnode);\
48 : : _ghs[nnode] -= conductance * BP(vpnode,vnnode);\
49 : : } else {\
50 : : _rhs[pnode] += conductance * BP(vpnode,vnnode);\
51 : : _rhs[nnode] -= conductance * BP(vpnode,vnnode);\
52 : : }
53 : : #define _load_static_jacobian2p(node,vpnode,vnnode,conductance)\
54 : : _jstat[node][vpnode] += conductance;\
55 : : _jstat[node][vnnode] -= conductance;\
56 : : if (doHB) {\
57 : : _ghs[node] += conductance * BP(vpnode,vnnode);\
58 : : } else {\
59 : : _rhs[node] += conductance * BP(vpnode,vnnode);\
60 : : }
61 : : #define _load_static_jacobian2s(pnode,nnode,node,conductance)\
62 : : _jstat[pnode][node] += conductance;\
63 : : _jstat[nnode][node] -= conductance;\
64 : : if (doHB) {\
65 : : _ghs[pnode] += conductance * NP(node);\
66 : : _ghs[nnode] -= conductance * NP(node);\
67 : : } else {\
68 : : _rhs[pnode] += conductance * NP(node);\
69 : : _rhs[nnode] -= conductance * NP(node);\
70 : : }
71 : : #define _load_static_jacobian1(node,vnode,conductance)\
72 : : _jstat[node][vnode] += conductance;\
73 : : if (doHB) {\
74 : : _ghs[node] += conductance * NP(vnode);\
75 : : } else {\
76 : : _rhs[node] += conductance * NP(vnode);\
77 : : }
78 : : #define _load_dynamic_residual2(pnode,nnode,charge)\
79 : : if (doTR) _charges[pnode][nnode] += charge;\
80 : : if (doHB) {\
81 : : _qhs[pnode] -= charge;\
82 : : _qhs[nnode] += charge;\
83 : : }
84 : : #define _load_dynamic_residual1(node,charge)\
85 : : if (doTR) _charges[node][node] += charge;\
86 : : if (doHB) {\
87 : : _qhs[node] -= charge;\
88 : : }
89 : : #define _load_dynamic_jacobian4(pnode,nnode,vpnode,vnnode,capacitance)\
90 : : if (doAC) {\
91 : : _jdyna[pnode][vpnode] += capacitance;\
92 : : _jdyna[nnode][vnnode] += capacitance;\
93 : : _jdyna[pnode][vnnode] -= capacitance;\
94 : : _jdyna[nnode][vpnode] -= capacitance;\
95 : : }\
96 : : if (doTR) {\
97 : : _caps[pnode][nnode][vpnode][vnnode] += capacitance;\
98 : : }\
99 : : if (doHB) {\
100 : : _chs[pnode] += capacitance * BP(vpnode,vnnode);\
101 : : _chs[nnode] -= capacitance * BP(vpnode,vnnode);\
102 : : }
103 : : #define _load_dynamic_jacobian2s(pnode,nnode,vnode,capacitance)\
104 : : if (doAC) {\
105 : : _jdyna[pnode][vnode] += capacitance;\
106 : : _jdyna[nnode][vnode] -= capacitance;\
107 : : }\
108 : : if (doTR) {\
109 : : _caps[pnode][nnode][vnode][vnode] += capacitance;\
110 : : }\
111 : : if (doHB) {\
112 : : _chs[pnode] += capacitance * NP(vnode);\
113 : : _chs[nnode] -= capacitance * NP(vnode);\
114 : : }
115 : : #define _load_dynamic_jacobian2p(node,vpnode,vnnode,capacitance)\
116 : : if (doAC) {\
117 : : _jdyna[node][vpnode] += capacitance;\
118 : : _jdyna[node][vnnode] -= capacitance;\
119 : : }\
120 : : if (doTR) {\
121 : : _caps[node][node][vpnode][vnnode] += capacitance;\
122 : : }\
123 : : if (doHB) {\
124 : : _chs[node] += capacitance * BP(vpnode,vnnode);\
125 : : }
126 : : #define _load_dynamic_jacobian1(node,vnode,capacitance)\
127 : : if (doAC) {\
128 : : _jdyna[node][vnode] += capacitance;\
129 : : }\
130 : : if (doTR) {\
131 : : _caps[node][node][vnode][vnode] += capacitance;\
132 : : }\
133 : : if (doHB) {\
134 : : _chs[node] += capacitance * NP(vnode);\
135 : : }
136 : :
137 : : #define _save_whitenoise1(n1,pwr,type)\
138 : : _white_pwr[n1][n1] += pwr;
139 : : #define _save_whitenoise2(n1,n2,pwr,type)\
140 : : _white_pwr[n1][n2] += pwr;
141 : : #define _save_flickernoise1(n1,pwr,exp,type)\
142 : : _flicker_pwr[n1][n1] += pwr;\
143 : : _flicker_exp[n1][n1] += exp;
144 : : #define _save_flickernoise2(n1,n2,pwr,exp,type)\
145 : : _flicker_pwr[n1][n2] += pwr;\
146 : : _flicker_exp[n1][n2] += exp;
147 : : #define _load_whitenoise2(n1,n2,pwr)\
148 : : cy (n1,n2) -= pwr/kB/T0; cy (n2,n1) -= pwr/kB/T0;\
149 : : cy (n1,n1) += pwr/kB/T0; cy (n2,n2) += pwr/kB/T0;
150 : : #define _load_whitenoise1(n1,pwr)\
151 : : cy (n1,n1) += pwr/kB/T0;
152 : : #define _load_flickernoise2(n1,n2,pwr,exp)\
153 : : cy (n1,n2) -= pwr*pow(_freq,-exp)/kB/T0;\
154 : : cy (n2,n1) -= pwr*pow(_freq,-exp)/kB/T0;\
155 : : cy (n1,n1) += pwr*pow(_freq,-exp)/kB/T0;\
156 : : cy (n2,n2) += pwr*pow(_freq,-exp)/kB/T0;
157 : : #define _load_flickernoise1(n1,pwr,exp)\
158 : : cy (n1,n1) += pwr*pow(_freq,-exp)/kB/T0;
159 : :
160 : : // derivative helper macros
161 : : // transcendental LRM p. 59
162 : : #define m00_cos(v00,x) v00 = cos(x);
163 : : #define m10_cos(v10,v00,x) v10 = (-sin(x));
164 : : #define m00_sin(v00,x) v00 = sin(x);
165 : : #define m10_sin(v10,v00,x) v10 = (cos(x));
166 : : #define m00_tan(v00,x) v00 = tan(x);
167 : : #define m10_tan(v10,v00,x) v10 = (1.0/cos(x)/cos(x));
168 : : #define m00_cosh(v00,x) v00 = cosh(x);
169 : : #define m10_cosh(v10,v00,x) v10 = (sinh(x));
170 : : #define m00_sinh(v00,x) v00 = sinh(x);
171 : : #define m10_sinh(v10,v00,x) v10 = (cosh(x));
172 : : #define m00_tanh(v00,x) v00 = tanh(x);
173 : : #define m10_tanh(v10,v00,x) v10 = (1.0/cosh(x)/cosh(x));
174 : : #define m00_acos(v00,x) v00 = acos(x);
175 : : #define m10_acos(v10,v00,x) v10 = (-1.0/sqrt(1-x*x));
176 : : #define m00_asin(v00,x) v00 = asin(x);
177 : : #define m10_asin(v10,v00,x) v10 = (+1.0/sqrt(1-x*x));
178 : : #define m00_atan(v00,x) v00 = atan(x);
179 : : #define m10_atan(v10,v00,x) v10 = (+1.0/(1+x*x));
180 : : #define m00_hypot(v00,x,y) v00 = sqrt((x)*(x)+(y)*(y));
181 : : #define m10_hypot(v10,v00,x,y) v10 = (x)/(v00);
182 : : #define m11_hypot(v11,v00,x,y) v11 = (y)/(v00);
183 : : #define m00_atan2(v00,x,y) v00 = atan2(x,y);
184 : : // TODO atan2 derivatives ?
185 : : #define m00_acosh(v00,x) v00 = acosh(x);
186 : : #define m10_acosh(v10,v00,x) v10 = (1.0/(sqrt(x-1)*sqrt(x+1)));
187 : : #define m00_asinh(v00,x) v00 = asinh(x);
188 : : #define m10_asinh(v10,v00,x) v10 = (1.0/(sqrt(x*x+1)));
189 : : #define m00_atanh(v00,x) v00 = atanh(x);
190 : : #define m10_atanh(v10,v00,x) v10 = (1.0/(1-x*x));
191 : :
192 : :
193 : : // standard functions LRM p.58
194 : : #define m00_logE(v00,x) v00 = log(x);
195 : : #define m10_logE(v10,v00,x) v10 = (1.0/x);
196 : : #define m00_log10(v00,x) v00 = log10(x);
197 : : #define m10_log10(v10,v00,x) v10 = (1.0/x/M_LN10);
198 : : #define m00_exp(v00,x) v00 = exp(x);
199 : : #define m10_exp(v10,v00,x) v10 = v00;
200 : : #define m00_sqrt(v00,x) v00 = sqrt(x);
201 : : #define m10_sqrt(v10,v00,x) v10 = (0.5/v00);
202 : : #define m00_min(v00,x,y) v00 = ((x)<(y))?(x):(y);
203 : : #define m10_min(v10,v00,x,y) v10 = ((x)<(y))?1.0:0.0;
204 : : #define m11_min(v11,v00,x,y) v11 = ((x)<(y))?0.0:1.0;
205 : : #define m00_max(v00,x,y) v00 = ((x)>(y))?(x):(y);
206 : : #define m10_max(v10,v00,x,y) v10 = ((x)>(y))?1.0:0.0;
207 : : #define m11_max(v11,v00,x,y) v11 = ((x)>(y))?0.0:1.0;
208 : : #define m00_pow(v00,x,y) v00 = pow(x,y);
209 : : #define m10_pow(v10,v00,x,y) v10 = (x==0.0)?0.0:(v00)*(y)/(x);
210 : : #define m11_pow(v11,v00,x,y) v11 = (x==0.0)?0.0:(log(x)*(v00));
211 : : #define m00_abs(v00,x) v00 = ((x)<(0)?(-(x)):(x));
212 : : #define m10_abs(v10,v00,x) v10 = (((x)>=0)?(+1.0):(-1.0));
213 : : #define m00_floor(v00,x) v00 = floor(x);
214 : : #define m10_floor(v10,v00,x) v10 = 1.0;
215 : :
216 : : #define m00_ceil(v00,x) v00 = ceil(x);
217 : : // TODO ceil derivative, needed?
218 : :
219 : : // analog operator, LRM p.61
220 : : #define m00_limexp(v00,x) v00 = ((x)<80.0?exp(x):exp(80.0)*(x-79.0));
221 : : #define m10_limexp(v10,v00,x) v10 = ((x)<80.0?(v00):exp(80.0));
222 : :
223 : : // analog kernel parameter system functions, LRM p.215
224 : : #define m00_vt(x) (kBoverQ*(x))
225 : : #define m10_vt(x) (kBoverQ)
226 : :
227 : : // extra functions (?)
228 : : #define m00_div(v00,v10,x,y) double v10=1/(y); double v00=(x)*v10;
229 : : #define m10_div(v10,v00,vv,x,y)
230 : : #define m11_div(v11,v00,vv,x,y) double v11 = -v00*vv;
231 : : #define m00_mult(v00,v10,v11,x,y) double v10=(x); double v11=(y); double v00=v10*v11;
232 : : #define m00_add(v00,x,y) double v00=(x)+(y);
233 : :
234 : : // second derivatives
235 : : #define m20_logE(v00) (-1.0/v00/v00)
236 : : #define m20_exp(v00) exp(v00)
237 : : #define m20_limexp(v00) ((v00)<80.0?exp(v00):0.0)
238 : : #define m20_sqrt(v00) (-0.25/(v00)/sqrt(v00))
239 : : #define m20_abs(v00) 0.0
240 : : #define m20_pow(x,y) ((y)*((y)-1.0)*pow(x,y)/(x)/(x))
241 : :
242 : :
243 : : // simulator specific definitions
244 : : #define _modelname "logic_1"
245 : : #define _instancename getName()
246 : : #define _circuit_temp (getPropertyDouble("Temp")+273.15)
247 : : #define _param_given(p) (isPropertyGiven(p)?1:0)
248 : :
249 : :
250 : : // $vt and $vt() functions
251 : : #define _vt_nom (kBoverQ*_circuit_temp)
252 : :
253 : : using namespace qucs::device;
254 : : using qucs::matrix;
255 : :
256 : : /* Device constructor. */
257 : 0 : logic_1::logic_1() : circuit (1)
258 : : {
259 : 0 : type = CIR_logic_1;
260 : 0 : }
261 : :
262 : : /* Initialization of model. */
263 : 0 : void logic_1::initModel (void)
264 : : {
265 : : // create internal nodes
266 : :
267 : : // get device model parameters
268 : 0 : loadVariables ();
269 : : // evaluate global model equations
270 : 0 : initializeModel ();
271 : : // evaluate initial step equations
272 : 0 : initialStep ();
273 : : // evaluate global instance equations
274 : 0 : initializeInstance ();
275 : 0 : }
276 : :
277 : : /* Initialization of DC analysis. */
278 : 0 : void logic_1::initDC (void)
279 : : {
280 : 0 : allocMatrixMNA ();
281 : 0 : initModel ();
282 : 0 : pol = 1;
283 : 0 : restartDC ();
284 : 0 : doAC = 1;
285 : 0 : doTR = 0;
286 : 0 : doHB = 0;
287 : 0 : }
288 : :
289 : : /* Run when DC is restarted (fallback algorithms). */
290 : 0 : void logic_1::restartDC (void)
291 : : {
292 : 0 : }
293 : :
294 : : /* Initialize Verilog-AMS code. */
295 : 0 : void logic_1::initVerilog (void)
296 : : {
297 : : // initialization of noise variables
298 : :
299 : : int i1, i2, i3, i4;
300 : :
301 : : // zero charges
302 [ # # ]: 0 : for (i1 = 0; i1 < 1; i1++) {
303 [ # # ]: 0 : for (i2 = 0; i2 < 1; i2++) {
304 : 0 : _charges[i1][i2] = 0.0;
305 : : } }
306 : :
307 : : // zero capacitances
308 [ # # ]: 0 : for (i1 = 0; i1 < 1; i1++) {
309 [ # # ]: 0 : for (i2 = 0; i2 < 1; i2++) {
310 [ # # ]: 0 : for (i3 = 0; i3 < 1; i3++) {
311 [ # # ]: 0 : for (i4 = 0; i4 < 1; i4++) {
312 : 0 : _caps[i1][i2][i3][i4] = 0.0;
313 : : } } } }
314 : :
315 : : // zero right hand side, static and dynamic jacobian
316 [ # # ]: 0 : for (i1 = 0; i1 < 1; i1++) {
317 : 0 : _rhs[i1] = 0.0;
318 : 0 : _qhs[i1] = 0.0;
319 : 0 : _chs[i1] = 0.0;
320 : 0 : _ghs[i1] = 0.0;
321 [ # # ]: 0 : for (i2 = 0; i2 < 1; i2++) {
322 : 0 : _jstat[i1][i2] = 0.0;
323 : 0 : _jdyna[i1][i2] = 0.0;
324 : : }
325 : : }
326 : 0 : }
327 : :
328 : : /* Load device model input parameters. */
329 : 0 : void logic_1::loadVariables (void)
330 : : {
331 : 0 : LEVEL = getPropertyDouble ("LEVEL");
332 : 0 : }
333 : :
334 : : /* #define's for translated code */
335 : : #undef _DDT
336 : : #define _DDT(q) q
337 : : #define _DYNAMIC
338 : : #define _DERIVATE
339 : : #define _DDX
340 : : #define _DERIVATEFORDDX
341 : :
342 : : /* Evaluate Verilog-AMS equations in model initialization. */
343 : 0 : void logic_1::initializeModel (void)
344 : : {
345 : 0 : }
346 : :
347 : : /* Evaluate Verilog-AMS equations in instance initialization. */
348 : 0 : void logic_1::initializeInstance (void)
349 : : {
350 : 0 : }
351 : :
352 : : /* Evaluate Verilog-AMS equations in initial step. */
353 : 0 : void logic_1::initialStep (void)
354 : : {
355 : 0 : }
356 : :
357 : : /* Evaluate Verilog-AMS equations in final step. */
358 : 0 : void logic_1::finalStep (void)
359 : : {
360 : 0 : }
361 : :
362 : : /* Evaluate Verilog-AMS equations in analog block. */
363 : 0 : void logic_1::calcVerilog (void)
364 : : {
365 : :
366 : : /* ----------------- evaluate verilog analog equations -------------------- */
367 : 0 : _load_static_residual1(L1,(-LEVEL));
368 : : #if defined(_DERIVATE)
369 : : #endif
370 : 0 : _load_static_residual1(L1,NP(L1));
371 : : #if defined(_DERIVATE)
372 [ # # ]: 0 : _load_static_jacobian1(L1,L1,1.0);
373 : : #endif
374 : :
375 : : /* ------------------ end of verilog analog equations --------------------- */
376 : :
377 : : /* ------------------ evaluate verilog noise equations -------------------- */
378 : :
379 : : /* ------------------- end of verilog noise equations --------------------- */
380 : 0 : }
381 : :
382 : : /* Perform DC iteration. */
383 : 0 : void logic_1::calcDC (void)
384 : : {
385 : : // evaluate Verilog code
386 : 0 : initVerilog ();
387 : 0 : calcVerilog ();
388 : :
389 : : // fill right hand side and static jacobian
390 [ # # ]: 0 : for (int i1 = 0; i1 < 1; i1++) {
391 [ # # ]: 0 : setI (i1, _rhs[i1]);
392 [ # # ]: 0 : for (int i2 = 0; i2 < 1; i2++) {
393 [ # # ]: 0 : setY (i1, i2, _jstat[i1][i2]);
394 : : }
395 : : }
396 : 0 : }
397 : :
398 : : /* Save operating points. */
399 : 0 : void logic_1::saveOperatingPoints (void)
400 : : {
401 : : // save global instance operating points
402 : 0 : }
403 : :
404 : : /* Load operating points. */
405 : 0 : void logic_1::loadOperatingPoints (void)
406 : : {
407 : 0 : }
408 : :
409 : : /* Calculate operating points. */
410 : 0 : void logic_1::calcOperatingPoints (void)
411 : : {
412 : 0 : }
413 : :
414 : : /* Initialization of AC analysis. */
415 : 0 : void logic_1::initAC (void)
416 : : {
417 : 0 : allocMatrixMNA ();
418 : 0 : }
419 : :
420 : : /* Perform AC calculations. */
421 : 0 : void logic_1::calcAC (nr_double_t frequency)
422 : : {
423 [ # # ]: 0 : setMatrixY (calcMatrixY (frequency));
424 : 0 : }
425 : :
426 : : /* Compute Y-matrix for AC analysis. */
427 : 0 : matrix logic_1::calcMatrixY (nr_double_t frequency)
428 : : {
429 : 0 : _freq = frequency;
430 : 0 : saveOperatingPoints ();
431 : 0 : matrix y (1);
432 : :
433 [ # # ]: 0 : for (int i1 = 0; i1 < 1; i1++) {
434 [ # # ]: 0 : for (int i2 = 0; i2 < 1; i2++) {
435 : 0 : y (i1,i2) = nr_complex_t (_jstat[i1][i2], _jdyna[i1][i2] * 2 * M_PI * _freq);
436 : : }
437 : : }
438 : :
439 : 0 : return y;
440 : : }
441 : :
442 : : /* Initialization of S-parameter analysis. */
443 : 0 : void logic_1::initSP (void)
444 : : {
445 : 0 : allocMatrixS ();
446 : 0 : }
447 : :
448 : : /* Perform S-parameter calculations. */
449 : 0 : void logic_1::calcSP (nr_double_t frequency)
450 : : {
451 [ # # ][ # # ]: 0 : setMatrixS (ytos (calcMatrixY (frequency)));
[ # # ][ # # ]
[ # # ]
452 : 0 : }
453 : :
454 : : /* Initialization of transient analysis. */
455 : 0 : void logic_1::initTR (void)
456 : : {
457 : 0 : setStates (2 * 1 * 1);
458 : 0 : initDC ();
459 : 0 : }
460 : :
461 : : /* Perform transient analysis iteration step. */
462 : 0 : void logic_1::calcTR (nr_double_t)
463 : : {
464 : 0 : doHB = 0;
465 : 0 : doAC = 1;
466 : 0 : doTR = 1;
467 : 0 : calcDC ();
468 : :
469 : : int i1, i2, i3, i4, state;
470 : :
471 : : // 2-node charge integrations
472 [ # # ]: 0 : for (i1 = 0; i1 < 1; i1++) {
473 [ # # ]: 0 : for (i2 = 0; i2 < 1; i2++) {
474 : 0 : state = 2 * (i2 + 1 * i1);
475 [ # # ]: 0 : if (i1 != i2)
476 [ # # ]: 0 : if (_charges[i1][i2] != 0.0)
477 : 0 : transientCapacitanceQ (state, i1, i2, _charges[i1][i2]);
478 : : } }
479 : :
480 : : // 1-node charge integrations
481 [ # # ]: 0 : for (i1 = 0; i1 < 1; i1++) {
482 : 0 : state = 2 * (i1 + 1 * i1);
483 [ # # ]: 0 : if (_charges[i1][i1] != 0.0)
484 : 0 : transientCapacitanceQ (state, i1, _charges[i1][i1]);
485 : : }
486 : :
487 : : // charge: 2-node, voltage: 2-node
488 [ # # ]: 0 : for (i1 = 0; i1 < 1; i1++) {
489 [ # # ]: 0 : for (i2 = 0; i2 < 1; i2++) {
490 [ # # ]: 0 : if (i1 != i2)
491 [ # # ]: 0 : for (i3 = 0; i3 < 1; i3++) {
492 [ # # ]: 0 : for (i4 = 0; i4 < 1; i4++) {
493 [ # # ]: 0 : if (i3 != i4)
494 [ # # ]: 0 : if (_caps[i1][i2][i3][i4] != 0.0)
495 [ # # ][ # # ]: 0 : transientCapacitanceC (i1, i2, i3, i4, _caps[i1][i2][i3][i4], BP(i3,i4));
496 : : } } } }
497 : :
498 : : // charge: 2-node, voltage: 1-node
499 [ # # ]: 0 : for (i1 = 0; i1 < 1; i1++) {
500 [ # # ]: 0 : for (i2 = 0; i2 < 1; i2++) {
501 [ # # ]: 0 : if (i1 != i2)
502 [ # # ]: 0 : for (i3 = 0; i3 < 1; i3++) {
503 [ # # ]: 0 : if (_caps[i1][i2][i3][i3] != 0.0)
504 [ # # ]: 0 : transientCapacitanceC2Q (i1, i2, i3, _caps[i1][i2][i3][i3], NP(i3));
505 : : } } }
506 : :
507 : : // charge: 1-node, voltage: 2-node
508 [ # # ]: 0 : for (i1 = 0; i1 < 1; i1++) {
509 [ # # ]: 0 : for (i3 = 0; i3 < 1; i3++) {
510 [ # # ]: 0 : for (i4 = 0; i4 < 1; i4++) {
511 [ # # ]: 0 : if (i3 != i4)
512 [ # # ]: 0 : if (_caps[i1][i1][i3][i4] != 0.0)
513 [ # # ][ # # ]: 0 : transientCapacitanceC2V (i1, i3, i4, _caps[i1][i1][i3][i4], BP(i3,i4));
514 : : } } }
515 : :
516 : : // charge: 1-node, voltage: 1-node
517 [ # # ]: 0 : for (i1 = 0; i1 < 1; i1++) {
518 [ # # ]: 0 : for (i3 = 0; i3 < 1; i3++) {
519 [ # # ]: 0 : if (_caps[i1][i1][i3][i3] != 0.0)
520 [ # # ]: 0 : transientCapacitanceC (i1, i3, _caps[i1][i1][i3][i3], NP(i3));
521 : : } }
522 : 0 : }
523 : :
524 : : /* Compute Cy-matrix for AC noise analysis. */
525 : 0 : matrix logic_1::calcMatrixCy (nr_double_t frequency)
526 : : {
527 : 0 : _freq = frequency;
528 : 0 : matrix cy (1);
529 : :
530 : :
531 : 0 : return cy;
532 : : }
533 : :
534 : : /* Perform AC noise computations. */
535 : 0 : void logic_1::calcNoiseAC (nr_double_t frequency)
536 : : {
537 [ # # ]: 0 : setMatrixN (calcMatrixCy (frequency));
538 : 0 : }
539 : :
540 : : /* Perform S-parameter noise computations. */
541 : 0 : void logic_1::calcNoiseSP (nr_double_t frequency)
542 : : {
543 [ # # ][ # # ]: 0 : setMatrixN (cytocs (calcMatrixCy (frequency) * z0, getMatrixS ()));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
544 : 0 : }
545 : :
546 : : /* Initialization of HB analysis. */
547 : 0 : void logic_1::initHB (int)
548 : : {
549 : 0 : initDC ();
550 : 0 : allocMatrixHB ();
551 : 0 : }
552 : :
553 : : /* Perform HB analysis. */
554 : 0 : void logic_1::calcHB (int)
555 : : {
556 : 0 : doHB = 1;
557 : 0 : doAC = 1;
558 : 0 : doTR = 0;
559 : :
560 : : // jacobian dI/dV and currents get filled
561 : 0 : calcDC ();
562 : 0 : saveOperatingPoints ();
563 : :
564 : : // fill in HB matrices
565 [ # # ]: 0 : for (int i1 = 0; i1 < 1; i1++) {
566 [ # # ]: 0 : setQ (i1, _qhs[i1]); // charges
567 [ # # ]: 0 : setCV (i1, _chs[i1]); // jacobian dQ/dV * V
568 [ # # ]: 0 : setGV (i1, _ghs[i1]); // jacobian dI/dV * V
569 [ # # ]: 0 : for (int i2 = 0; i2 < 1; i2++) {
570 [ # # ]: 0 : setQV (i1, i2, _jdyna[i1][i2]); // jacobian dQ/dV
571 : : }
572 : : }
573 : 0 : }
574 : :
575 : : #include "logic_1.defs.h"
576 : :
|
