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