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