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