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