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