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