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