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