Branch data Line data Source code
1 : : /*
2 : : * dmux3to8.core.cpp - device implementations for dmux3to8 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 "dmux3to8.analogfunction.h"
16 : : #include "component.h"
17 : : #include "device.h"
18 : : #include "dmux3to8.core.h"
19 : :
20 : : #ifndef CIR_dmux3to8
21 : : #define CIR_dmux3to8 -1
22 : : #endif
23 : :
24 : : // external nodes
25 : : #define EN 0
26 : : #define A 1
27 : : #define B 2
28 : : #define C 3
29 : : #define Y7 4
30 : : #define Y6 5
31 : : #define Y5 6
32 : : #define Y4 7
33 : : #define Y3 8
34 : : #define Y2 9
35 : : #define Y1 10
36 : : #define Y0 11
37 : : // internal nodes
38 : : #define Y0n1 12
39 : : #define Y0n2 13
40 : : #define Y1n1 14
41 : : #define Y1n2 15
42 : : #define Y2n1 16
43 : : #define Y2n2 17
44 : : #define Y3n1 18
45 : : #define Y3n2 19
46 : : #define Y4n1 20
47 : : #define Y4n2 21
48 : : #define Y5n1 22
49 : : #define Y5n2 23
50 : : #define Y6n1 24
51 : : #define Y6n2 25
52 : : #define Y7n1 26
53 : : #define Y7n2 27
54 : :
55 : : // useful macro definitions
56 : : #define NP(node) real (getV (node))
57 : : #define BP(pnode,nnode) (NP(pnode) - NP(nnode))
58 : : #define _load_static_residual2(pnode,nnode,current)\
59 : : _rhs[pnode] -= current;\
60 : : _rhs[nnode] += current;
61 : : #define _load_static_augmented_residual2(pnode,nnode,current)\
62 : : _rhs[pnode] -= current;\
63 : : _rhs[nnode] += current;
64 : : #define _load_static_residual1(node,current)\
65 : : _rhs[node] -= current;
66 : : #define _load_static_augmented_residual1(node,current)\
67 : : _rhs[node] -= current;
68 : : #define _load_static_jacobian4(pnode,nnode,vpnode,vnnode,conductance)\
69 : : _jstat[pnode][vpnode] += conductance;\
70 : : _jstat[nnode][vnnode] += conductance;\
71 : : _jstat[pnode][vnnode] -= conductance;\
72 : : _jstat[nnode][vpnode] -= conductance;\
73 : : if (doHB) {\
74 : : _ghs[pnode] += conductance * BP(vpnode,vnnode);\
75 : : _ghs[nnode] -= conductance * BP(vpnode,vnnode);\
76 : : } else {\
77 : : _rhs[pnode] += conductance * BP(vpnode,vnnode);\
78 : : _rhs[nnode] -= conductance * BP(vpnode,vnnode);\
79 : : }
80 : : #define _load_static_jacobian2p(node,vpnode,vnnode,conductance)\
81 : : _jstat[node][vpnode] += conductance;\
82 : : _jstat[node][vnnode] -= conductance;\
83 : : if (doHB) {\
84 : : _ghs[node] += conductance * BP(vpnode,vnnode);\
85 : : } else {\
86 : : _rhs[node] += conductance * BP(vpnode,vnnode);\
87 : : }
88 : : #define _load_static_jacobian2s(pnode,nnode,node,conductance)\
89 : : _jstat[pnode][node] += conductance;\
90 : : _jstat[nnode][node] -= conductance;\
91 : : if (doHB) {\
92 : : _ghs[pnode] += conductance * NP(node);\
93 : : _ghs[nnode] -= conductance * NP(node);\
94 : : } else {\
95 : : _rhs[pnode] += conductance * NP(node);\
96 : : _rhs[nnode] -= conductance * NP(node);\
97 : : }
98 : : #define _load_static_jacobian1(node,vnode,conductance)\
99 : : _jstat[node][vnode] += conductance;\
100 : : if (doHB) {\
101 : : _ghs[node] += conductance * NP(vnode);\
102 : : } else {\
103 : : _rhs[node] += conductance * NP(vnode);\
104 : : }
105 : : #define _load_dynamic_residual2(pnode,nnode,charge)\
106 : : if (doTR) _charges[pnode][nnode] += charge;\
107 : : if (doHB) {\
108 : : _qhs[pnode] -= charge;\
109 : : _qhs[nnode] += charge;\
110 : : }
111 : : #define _load_dynamic_residual1(node,charge)\
112 : : if (doTR) _charges[node][node] += charge;\
113 : : if (doHB) {\
114 : : _qhs[node] -= charge;\
115 : : }
116 : : #define _load_dynamic_jacobian4(pnode,nnode,vpnode,vnnode,capacitance)\
117 : : if (doAC) {\
118 : : _jdyna[pnode][vpnode] += capacitance;\
119 : : _jdyna[nnode][vnnode] += capacitance;\
120 : : _jdyna[pnode][vnnode] -= capacitance;\
121 : : _jdyna[nnode][vpnode] -= capacitance;\
122 : : }\
123 : : if (doTR) {\
124 : : _caps[pnode][nnode][vpnode][vnnode] += capacitance;\
125 : : }\
126 : : if (doHB) {\
127 : : _chs[pnode] += capacitance * BP(vpnode,vnnode);\
128 : : _chs[nnode] -= capacitance * BP(vpnode,vnnode);\
129 : : }
130 : : #define _load_dynamic_jacobian2s(pnode,nnode,vnode,capacitance)\
131 : : if (doAC) {\
132 : : _jdyna[pnode][vnode] += capacitance;\
133 : : _jdyna[nnode][vnode] -= capacitance;\
134 : : }\
135 : : if (doTR) {\
136 : : _caps[pnode][nnode][vnode][vnode] += capacitance;\
137 : : }\
138 : : if (doHB) {\
139 : : _chs[pnode] += capacitance * NP(vnode);\
140 : : _chs[nnode] -= capacitance * NP(vnode);\
141 : : }
142 : : #define _load_dynamic_jacobian2p(node,vpnode,vnnode,capacitance)\
143 : : if (doAC) {\
144 : : _jdyna[node][vpnode] += capacitance;\
145 : : _jdyna[node][vnnode] -= capacitance;\
146 : : }\
147 : : if (doTR) {\
148 : : _caps[node][node][vpnode][vnnode] += capacitance;\
149 : : }\
150 : : if (doHB) {\
151 : : _chs[node] += capacitance * BP(vpnode,vnnode);\
152 : : }
153 : : #define _load_dynamic_jacobian1(node,vnode,capacitance)\
154 : : if (doAC) {\
155 : : _jdyna[node][vnode] += capacitance;\
156 : : }\
157 : : if (doTR) {\
158 : : _caps[node][node][vnode][vnode] += capacitance;\
159 : : }\
160 : : if (doHB) {\
161 : : _chs[node] += capacitance * NP(vnode);\
162 : : }
163 : :
164 : : #define _save_whitenoise1(n1,pwr,type)\
165 : : _white_pwr[n1][n1] += pwr;
166 : : #define _save_whitenoise2(n1,n2,pwr,type)\
167 : : _white_pwr[n1][n2] += pwr;
168 : : #define _save_flickernoise1(n1,pwr,exp,type)\
169 : : _flicker_pwr[n1][n1] += pwr;\
170 : : _flicker_exp[n1][n1] += exp;
171 : : #define _save_flickernoise2(n1,n2,pwr,exp,type)\
172 : : _flicker_pwr[n1][n2] += pwr;\
173 : : _flicker_exp[n1][n2] += exp;
174 : : #define _load_whitenoise2(n1,n2,pwr)\
175 : : cy (n1,n2) -= pwr/kB/T0; cy (n2,n1) -= pwr/kB/T0;\
176 : : cy (n1,n1) += pwr/kB/T0; cy (n2,n2) += pwr/kB/T0;
177 : : #define _load_whitenoise1(n1,pwr)\
178 : : cy (n1,n1) += pwr/kB/T0;
179 : : #define _load_flickernoise2(n1,n2,pwr,exp)\
180 : : cy (n1,n2) -= pwr*pow(_freq,-exp)/kB/T0;\
181 : : cy (n2,n1) -= pwr*pow(_freq,-exp)/kB/T0;\
182 : : cy (n1,n1) += pwr*pow(_freq,-exp)/kB/T0;\
183 : : cy (n2,n2) += pwr*pow(_freq,-exp)/kB/T0;
184 : : #define _load_flickernoise1(n1,pwr,exp)\
185 : : cy (n1,n1) += pwr*pow(_freq,-exp)/kB/T0;
186 : :
187 : : // derivative helper macros
188 : : // transcendental LRM p. 59
189 : : #define m00_cos(v00,x) v00 = cos(x);
190 : : #define m10_cos(v10,v00,x) v10 = (-sin(x));
191 : : #define m00_sin(v00,x) v00 = sin(x);
192 : : #define m10_sin(v10,v00,x) v10 = (cos(x));
193 : : #define m00_tan(v00,x) v00 = tan(x);
194 : : #define m10_tan(v10,v00,x) v10 = (1.0/cos(x)/cos(x));
195 : : #define m00_cosh(v00,x) v00 = cosh(x);
196 : : #define m10_cosh(v10,v00,x) v10 = (sinh(x));
197 : : #define m00_sinh(v00,x) v00 = sinh(x);
198 : : #define m10_sinh(v10,v00,x) v10 = (cosh(x));
199 : : #define m00_tanh(v00,x) v00 = tanh(x);
200 : : #define m10_tanh(v10,v00,x) v10 = (1.0/cosh(x)/cosh(x));
201 : : #define m00_acos(v00,x) v00 = acos(x);
202 : : #define m10_acos(v10,v00,x) v10 = (-1.0/sqrt(1-x*x));
203 : : #define m00_asin(v00,x) v00 = asin(x);
204 : : #define m10_asin(v10,v00,x) v10 = (+1.0/sqrt(1-x*x));
205 : : #define m00_atan(v00,x) v00 = atan(x);
206 : : #define m10_atan(v10,v00,x) v10 = (+1.0/(1+x*x));
207 : : #define m00_hypot(v00,x,y) v00 = sqrt((x)*(x)+(y)*(y));
208 : : #define m10_hypot(v10,v00,x,y) v10 = (x)/(v00);
209 : : #define m11_hypot(v11,v00,x,y) v11 = (y)/(v00);
210 : : #define m00_atan2(v00,x,y) v00 = atan2(x,y);
211 : : // TODO atan2 derivatives ?
212 : : #define m00_acosh(v00,x) v00 = acosh(x);
213 : : #define m10_acosh(v10,v00,x) v10 = (1.0/(sqrt(x-1)*sqrt(x+1)));
214 : : #define m00_asinh(v00,x) v00 = asinh(x);
215 : : #define m10_asinh(v10,v00,x) v10 = (1.0/(sqrt(x*x+1)));
216 : : #define m00_atanh(v00,x) v00 = atanh(x);
217 : : #define m10_atanh(v10,v00,x) v10 = (1.0/(1-x*x));
218 : :
219 : :
220 : : // standard functions LRM p.58
221 : : #define m00_logE(v00,x) v00 = log(x);
222 : : #define m10_logE(v10,v00,x) v10 = (1.0/x);
223 : : #define m00_log10(v00,x) v00 = log10(x);
224 : : #define m10_log10(v10,v00,x) v10 = (1.0/x/M_LN10);
225 : : #define m00_exp(v00,x) v00 = exp(x);
226 : : #define m10_exp(v10,v00,x) v10 = v00;
227 : : #define m00_sqrt(v00,x) v00 = sqrt(x);
228 : : #define m10_sqrt(v10,v00,x) v10 = (0.5/v00);
229 : : #define m00_min(v00,x,y) v00 = ((x)<(y))?(x):(y);
230 : : #define m10_min(v10,v00,x,y) v10 = ((x)<(y))?1.0:0.0;
231 : : #define m11_min(v11,v00,x,y) v11 = ((x)<(y))?0.0:1.0;
232 : : #define m00_max(v00,x,y) v00 = ((x)>(y))?(x):(y);
233 : : #define m10_max(v10,v00,x,y) v10 = ((x)>(y))?1.0:0.0;
234 : : #define m11_max(v11,v00,x,y) v11 = ((x)>(y))?0.0:1.0;
235 : : #define m00_pow(v00,x,y) v00 = pow(x,y);
236 : : #define m10_pow(v10,v00,x,y) v10 = (x==0.0)?0.0:(v00)*(y)/(x);
237 : : #define m11_pow(v11,v00,x,y) v11 = (x==0.0)?0.0:(log(x)*(v00));
238 : : #define m00_abs(v00,x) v00 = ((x)<(0)?(-(x)):(x));
239 : : #define m10_abs(v10,v00,x) v10 = (((x)>=0)?(+1.0):(-1.0));
240 : : #define m00_floor(v00,x) v00 = floor(x);
241 : : #define m10_floor(v10,v00,x) v10 = 1.0;
242 : :
243 : : #define m00_ceil(v00,x) v00 = ceil(x);
244 : : // TODO ceil derivative, needed?
245 : :
246 : : // analog operator, LRM p.61
247 : : #define m00_limexp(v00,x) v00 = ((x)<80.0?exp(x):exp(80.0)*(x-79.0));
248 : : #define m10_limexp(v10,v00,x) v10 = ((x)<80.0?(v00):exp(80.0));
249 : :
250 : : // analog kernel parameter system functions, LRM p.215
251 : : #define m00_vt(x) (kBoverQ*(x))
252 : : #define m10_vt(x) (kBoverQ)
253 : :
254 : : // extra functions (?)
255 : : #define m00_div(v00,v10,x,y) double v10=1/(y); double v00=(x)*v10;
256 : : #define m10_div(v10,v00,vv,x,y)
257 : : #define m11_div(v11,v00,vv,x,y) double v11 = -v00*vv;
258 : : #define m00_mult(v00,v10,v11,x,y) double v10=(x); double v11=(y); double v00=v10*v11;
259 : : #define m00_add(v00,x,y) double v00=(x)+(y);
260 : :
261 : : // second derivatives
262 : : #define m20_logE(v00) (-1.0/v00/v00)
263 : : #define m20_exp(v00) exp(v00)
264 : : #define m20_limexp(v00) ((v00)<80.0?exp(v00):0.0)
265 : : #define m20_sqrt(v00) (-0.25/(v00)/sqrt(v00))
266 : : #define m20_abs(v00) 0.0
267 : : #define m20_pow(x,y) ((y)*((y)-1.0)*pow(x,y)/(x)/(x))
268 : :
269 : :
270 : : // simulator specific definitions
271 : : #define _modelname "dmux3to8"
272 : : #define _instancename getName()
273 : : #define _circuit_temp (getPropertyDouble("Temp")+273.15)
274 : : #define _param_given(p) (isPropertyGiven(p)?1:0)
275 : :
276 : :
277 : : // $vt and $vt() functions
278 : : #define _vt_nom (kBoverQ*_circuit_temp)
279 : :
280 : : using namespace qucs::device;
281 : : using qucs::matrix;
282 : :
283 : : /* Device constructor. */
284 : 0 : dmux3to8::dmux3to8() : circuit (28)
285 : : {
286 : 0 : type = CIR_dmux3to8;
287 : 0 : }
288 : :
289 : : /* Initialization of model. */
290 : 0 : void dmux3to8::initModel (void)
291 : : {
292 : : // create internal nodes
293 : 0 : setInternalNode (Y0n1, "Y0n1");
294 : 0 : setInternalNode (Y0n2, "Y0n2");
295 : 0 : setInternalNode (Y1n1, "Y1n1");
296 : 0 : setInternalNode (Y1n2, "Y1n2");
297 : 0 : setInternalNode (Y2n1, "Y2n1");
298 : 0 : setInternalNode (Y2n2, "Y2n2");
299 : 0 : setInternalNode (Y3n1, "Y3n1");
300 : 0 : setInternalNode (Y3n2, "Y3n2");
301 : 0 : setInternalNode (Y4n1, "Y4n1");
302 : 0 : setInternalNode (Y4n2, "Y4n2");
303 : 0 : setInternalNode (Y5n1, "Y5n1");
304 : 0 : setInternalNode (Y5n2, "Y5n2");
305 : 0 : setInternalNode (Y6n1, "Y6n1");
306 : 0 : setInternalNode (Y6n2, "Y6n2");
307 : 0 : setInternalNode (Y7n1, "Y7n1");
308 : 0 : setInternalNode (Y7n2, "Y7n2");
309 : :
310 : : // get device model parameters
311 : 0 : loadVariables ();
312 : : // evaluate global model equations
313 : 0 : initializeModel ();
314 : : // evaluate initial step equations
315 : 0 : initialStep ();
316 : : // evaluate global instance equations
317 : 0 : initializeInstance ();
318 : 0 : }
319 : :
320 : : /* Initialization of DC analysis. */
321 : 0 : void dmux3to8::initDC (void)
322 : : {
323 : 0 : allocMatrixMNA ();
324 : 0 : initModel ();
325 : 0 : pol = 1;
326 : 0 : restartDC ();
327 : 0 : doAC = 1;
328 : 0 : doTR = 0;
329 : 0 : doHB = 0;
330 : 0 : }
331 : :
332 : : /* Run when DC is restarted (fallback algorithms). */
333 : 0 : void dmux3to8::restartDC (void)
334 : : {
335 : 0 : }
336 : :
337 : : /* Initialize Verilog-AMS code. */
338 : 0 : void dmux3to8::initVerilog (void)
339 : : {
340 : : // initialization of noise variables
341 : :
342 : : int i1, i2, i3, i4;
343 : :
344 : : // zero charges
345 [ # # ]: 0 : for (i1 = 0; i1 < 28; i1++) {
346 [ # # ]: 0 : for (i2 = 0; i2 < 28; i2++) {
347 : 0 : _charges[i1][i2] = 0.0;
348 : : } }
349 : :
350 : : // zero capacitances
351 [ # # ]: 0 : for (i1 = 0; i1 < 28; i1++) {
352 [ # # ]: 0 : for (i2 = 0; i2 < 28; i2++) {
353 [ # # ]: 0 : for (i3 = 0; i3 < 28; i3++) {
354 [ # # ]: 0 : for (i4 = 0; i4 < 28; i4++) {
355 : 0 : _caps[i1][i2][i3][i4] = 0.0;
356 : : } } } }
357 : :
358 : : // zero right hand side, static and dynamic jacobian
359 [ # # ]: 0 : for (i1 = 0; i1 < 28; i1++) {
360 : 0 : _rhs[i1] = 0.0;
361 : 0 : _qhs[i1] = 0.0;
362 : 0 : _chs[i1] = 0.0;
363 : 0 : _ghs[i1] = 0.0;
364 [ # # ]: 0 : for (i2 = 0; i2 < 28; i2++) {
365 : 0 : _jstat[i1][i2] = 0.0;
366 : 0 : _jdyna[i1][i2] = 0.0;
367 : : }
368 : : }
369 : 0 : }
370 : :
371 : : /* Load device model input parameters. */
372 : 0 : void dmux3to8::loadVariables (void)
373 : : {
374 : 0 : TR = getPropertyDouble ("TR");
375 : 0 : Delay = getPropertyDouble ("Delay");
376 : 0 : }
377 : :
378 : : /* #define's for translated code */
379 : : #undef _DDT
380 : : #define _DDT(q) q
381 : : #define _DYNAMIC
382 : : #define _DERIVATE
383 : : #define _DDX
384 : : #define _DERIVATEFORDDX
385 : :
386 : : /* Evaluate Verilog-AMS equations in model initialization. */
387 : 0 : void dmux3to8::initializeModel (void)
388 : : {
389 : : #if defined(_DYNAMIC)
390 : : #endif
391 : : {
392 : 0 : Rd=1e3;
393 : : #if defined(_DYNAMIC)
394 : 0 : Cd=((Delay*1.43)/Rd);
395 : : #endif
396 : : }
397 : 0 : }
398 : :
399 : : /* Evaluate Verilog-AMS equations in instance initialization. */
400 : 0 : void dmux3to8::initializeInstance (void)
401 : : {
402 : 0 : }
403 : :
404 : : /* Evaluate Verilog-AMS equations in initial step. */
405 : 0 : void dmux3to8::initialStep (void)
406 : : {
407 : 0 : }
408 : :
409 : : /* Evaluate Verilog-AMS equations in final step. */
410 : 0 : void dmux3to8::finalStep (void)
411 : : {
412 : 0 : }
413 : :
414 : : /* Evaluate Verilog-AMS equations in analog block. */
415 : 0 : void dmux3to8::calcVerilog (void)
416 : : {
417 : :
418 : : /* ----------------- evaluate verilog analog equations -------------------- */
419 : : double IY7;
420 : : #if defined(_DERIVATE)
421 : : double IY7_VEN_GND;
422 : : double IY7_VC_GND;
423 : : double IY7_VB_GND;
424 : : double IY7_VA_GND;
425 : : #endif
426 : : double IY6;
427 : : #if defined(_DERIVATE)
428 : : double IY6_VEN_GND;
429 : : double IY6_VC_GND;
430 : : double IY6_VB_GND;
431 : : double IY6_VA_GND;
432 : : #endif
433 : : double IY5;
434 : : #if defined(_DERIVATE)
435 : : double IY5_VEN_GND;
436 : : double IY5_VC_GND;
437 : : double IY5_VB_GND;
438 : : double IY5_VA_GND;
439 : : #endif
440 : : double IY4;
441 : : #if defined(_DERIVATE)
442 : : double IY4_VEN_GND;
443 : : double IY4_VC_GND;
444 : : double IY4_VB_GND;
445 : : double IY4_VA_GND;
446 : : #endif
447 : : double IY3;
448 : : #if defined(_DERIVATE)
449 : : double IY3_VEN_GND;
450 : : double IY3_VC_GND;
451 : : double IY3_VB_GND;
452 : : double IY3_VA_GND;
453 : : #endif
454 : : double IY2;
455 : : #if defined(_DERIVATE)
456 : : double IY2_VEN_GND;
457 : : double IY2_VC_GND;
458 : : double IY2_VB_GND;
459 : : double IY2_VA_GND;
460 : : #endif
461 : : double IY1;
462 : : #if defined(_DERIVATE)
463 : : double IY1_VEN_GND;
464 : : double IY1_VC_GND;
465 : : double IY1_VB_GND;
466 : : double IY1_VA_GND;
467 : : #endif
468 : : double IY0;
469 : : #if defined(_DERIVATE)
470 : : double IY0_VEN_GND;
471 : : double IY0_VC_GND;
472 : : double IY0_VB_GND;
473 : : double IY0_VA_GND;
474 : : #endif
475 : : double VCI;
476 : : #if defined(_DERIVATE)
477 : : double VCI_VC_GND;
478 : : #endif
479 : : double VBI;
480 : : #if defined(_DERIVATE)
481 : : double VBI_VB_GND;
482 : : #endif
483 : : double VAI;
484 : : #if defined(_DERIVATE)
485 : : double VAI_VA_GND;
486 : : #endif
487 : : double VENI;
488 : : #if defined(_DERIVATE)
489 : : double VENI_VEN_GND;
490 : : #endif
491 : : #if defined(_DERIVATE)
492 : 0 : VENI_VEN_GND=(-1.0);
493 : : #endif
494 : 0 : VENI=(1-NP(EN));
495 : : #if defined(_DERIVATE)
496 : 0 : VAI_VA_GND=(-1.0);
497 : : #endif
498 : 0 : VAI=(1-NP(A));
499 : : #if defined(_DERIVATE)
500 : 0 : VBI_VB_GND=(-1.0);
501 : : #endif
502 : 0 : VBI=(1-NP(B));
503 : : #if defined(_DERIVATE)
504 : 0 : VCI_VC_GND=(-1.0);
505 : : #endif
506 : 0 : VCI=(1-NP(C));
507 : : #if defined(_DERIVATE)
508 : 0 : IY0_VEN_GND=VENI_VEN_GND*VCI*VBI*VAI;
509 : 0 : IY0_VC_GND=(VENI*VCI_VC_GND)*VBI*VAI;
510 : 0 : IY0_VB_GND=((VENI*VCI)*VBI_VB_GND)*VAI;
511 : 0 : IY0_VA_GND=(((VENI*VCI)*VBI)*VAI_VA_GND);
512 : : #endif
513 : 0 : IY0=(((VENI*VCI)*VBI)*VAI);
514 : : {
515 : 0 : double m00_tanh(d00_tanh0,(TR*(IY0-0.5)))
516 : : #if defined(_DERIVATE)
517 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY0-0.5)))
518 : : #endif
519 : 0 : _load_static_residual1(Y0n1,((-0.5)*(1+d00_tanh0)));
520 : : #if defined(_DERIVATE)
521 [ # # ]: 0 : _load_static_jacobian1(Y0n1,A,((-0.5)*(TR*IY0_VA_GND)*d10_tanh0));
522 [ # # ]: 0 : _load_static_jacobian1(Y0n1,B,((-0.5)*(TR*IY0_VB_GND)*d10_tanh0));
523 [ # # ]: 0 : _load_static_jacobian1(Y0n1,C,((-0.5)*(TR*IY0_VC_GND)*d10_tanh0));
524 [ # # ]: 0 : _load_static_jacobian1(Y0n1,EN,((-0.5)*(TR*IY0_VEN_GND)*d10_tanh0));
525 : : #endif
526 : : }
527 : 0 : _load_static_residual1(Y0n1,NP(Y0n1));
528 : : #if defined(_DERIVATE)
529 [ # # ]: 0 : _load_static_jacobian1(Y0n1,Y0n1,1.0);
530 : : #endif
531 [ # # ][ # # ]: 0 : _load_static_residual2(Y0n1,Y0n2,(BP(Y0n1,Y0n2)/Rd));
532 : : #if defined(_DERIVATE)
533 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y0n1,Y0n2,Y0n1,Y0n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
534 : : #endif
535 : : #if defined(_DYNAMIC)
536 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y0n2,_DDT((Cd*NP(Y0n2))));
537 : : #if defined(_DERIVATE)
538 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y0n2,Y0n2,(Cd));
[ # # ]
539 : : #endif
540 : : #endif
541 : 0 : _load_static_residual1(Y0,(-NP(Y0n2)));
542 : : #if defined(_DERIVATE)
543 [ # # ]: 0 : _load_static_jacobian1(Y0,Y0n2,(-1.0));
544 : : #endif
545 : 0 : _load_static_residual1(Y0,NP(Y0));
546 : : #if defined(_DERIVATE)
547 [ # # ]: 0 : _load_static_jacobian1(Y0,Y0,1.0);
548 : : #endif
549 : : #if defined(_DERIVATE)
550 : 0 : IY1_VEN_GND=VENI_VEN_GND*VCI*VBI*NP(A);
551 : 0 : IY1_VC_GND=(VENI*VCI_VC_GND)*VBI*NP(A);
552 : 0 : IY1_VB_GND=((VENI*VCI)*VBI_VB_GND)*NP(A);
553 : 0 : IY1_VA_GND=(((VENI*VCI)*VBI));
554 : : #endif
555 : 0 : IY1=(((VENI*VCI)*VBI)*NP(A));
556 : : {
557 : 0 : double m00_tanh(d00_tanh0,(TR*(IY1-0.5)))
558 : : #if defined(_DERIVATE)
559 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY1-0.5)))
560 : : #endif
561 : 0 : _load_static_residual1(Y1n1,((-0.5)*(1+d00_tanh0)));
562 : : #if defined(_DERIVATE)
563 [ # # ]: 0 : _load_static_jacobian1(Y1n1,A,((-0.5)*(TR*IY1_VA_GND)*d10_tanh0));
564 [ # # ]: 0 : _load_static_jacobian1(Y1n1,B,((-0.5)*(TR*IY1_VB_GND)*d10_tanh0));
565 [ # # ]: 0 : _load_static_jacobian1(Y1n1,C,((-0.5)*(TR*IY1_VC_GND)*d10_tanh0));
566 [ # # ]: 0 : _load_static_jacobian1(Y1n1,EN,((-0.5)*(TR*IY1_VEN_GND)*d10_tanh0));
567 : : #endif
568 : : }
569 : 0 : _load_static_residual1(Y1n1,NP(Y1n1));
570 : : #if defined(_DERIVATE)
571 [ # # ]: 0 : _load_static_jacobian1(Y1n1,Y1n1,1.0);
572 : : #endif
573 [ # # ][ # # ]: 0 : _load_static_residual2(Y1n1,Y1n2,(BP(Y1n1,Y1n2)/Rd));
574 : : #if defined(_DERIVATE)
575 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y1n1,Y1n2,Y1n1,Y1n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
576 : : #endif
577 : : #if defined(_DYNAMIC)
578 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y1n2,_DDT((Cd*NP(Y1n2))));
579 : : #if defined(_DERIVATE)
580 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y1n2,Y1n2,(Cd));
[ # # ]
581 : : #endif
582 : : #endif
583 : 0 : _load_static_residual1(Y1,(-NP(Y1n2)));
584 : : #if defined(_DERIVATE)
585 [ # # ]: 0 : _load_static_jacobian1(Y1,Y1n2,(-1.0));
586 : : #endif
587 : 0 : _load_static_residual1(Y1,NP(Y1));
588 : : #if defined(_DERIVATE)
589 [ # # ]: 0 : _load_static_jacobian1(Y1,Y1,1.0);
590 : : #endif
591 : : #if defined(_DERIVATE)
592 : 0 : IY2_VEN_GND=VENI_VEN_GND*VCI*NP(B)*VAI;
593 : 0 : IY2_VC_GND=(VENI*VCI_VC_GND)*NP(B)*VAI;
594 : 0 : IY2_VB_GND=((VENI*VCI))*VAI;
595 : 0 : IY2_VA_GND=(((VENI*VCI)*NP(B))*VAI_VA_GND);
596 : : #endif
597 : 0 : IY2=(((VENI*VCI)*NP(B))*VAI);
598 : : {
599 : 0 : double m00_tanh(d00_tanh0,(TR*(IY2-0.5)))
600 : : #if defined(_DERIVATE)
601 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY2-0.5)))
602 : : #endif
603 : 0 : _load_static_residual1(Y2n1,((-0.5)*(1+d00_tanh0)));
604 : : #if defined(_DERIVATE)
605 [ # # ]: 0 : _load_static_jacobian1(Y2n1,A,((-0.5)*(TR*IY2_VA_GND)*d10_tanh0));
606 [ # # ]: 0 : _load_static_jacobian1(Y2n1,B,((-0.5)*(TR*IY2_VB_GND)*d10_tanh0));
607 [ # # ]: 0 : _load_static_jacobian1(Y2n1,C,((-0.5)*(TR*IY2_VC_GND)*d10_tanh0));
608 [ # # ]: 0 : _load_static_jacobian1(Y2n1,EN,((-0.5)*(TR*IY2_VEN_GND)*d10_tanh0));
609 : : #endif
610 : : }
611 : 0 : _load_static_residual1(Y2n1,NP(Y2n1));
612 : : #if defined(_DERIVATE)
613 [ # # ]: 0 : _load_static_jacobian1(Y2n1,Y2n1,1.0);
614 : : #endif
615 [ # # ][ # # ]: 0 : _load_static_residual2(Y2n1,Y2n2,(BP(Y2n1,Y2n2)/Rd));
616 : : #if defined(_DERIVATE)
617 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y2n1,Y2n2,Y2n1,Y2n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
618 : : #endif
619 : : #if defined(_DYNAMIC)
620 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y2n2,_DDT((Cd*NP(Y2n2))));
621 : : #if defined(_DERIVATE)
622 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y2n2,Y2n2,(Cd));
[ # # ]
623 : : #endif
624 : : #endif
625 : 0 : _load_static_residual1(Y2,(-NP(Y2n2)));
626 : : #if defined(_DERIVATE)
627 [ # # ]: 0 : _load_static_jacobian1(Y2,Y2n2,(-1.0));
628 : : #endif
629 : 0 : _load_static_residual1(Y2,NP(Y2));
630 : : #if defined(_DERIVATE)
631 [ # # ]: 0 : _load_static_jacobian1(Y2,Y2,1.0);
632 : : #endif
633 : : #if defined(_DERIVATE)
634 [ # # ]: 0 : IY3_VEN_GND=VENI_VEN_GND*VCI*NP(B)*NP(A);
635 [ # # ]: 0 : IY3_VC_GND=(VENI*VCI_VC_GND)*NP(B)*NP(A);
636 : 0 : IY3_VB_GND=((VENI*VCI))*NP(A);
637 : 0 : IY3_VA_GND=(((VENI*VCI)*NP(B)));
638 : : #endif
639 [ # # ]: 0 : IY3=(((VENI*VCI)*NP(B))*NP(A));
640 : : {
641 : 0 : double m00_tanh(d00_tanh0,(TR*(IY3-0.5)))
642 : : #if defined(_DERIVATE)
643 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY3-0.5)))
644 : : #endif
645 : 0 : _load_static_residual1(Y3n1,((-0.5)*(1+d00_tanh0)));
646 : : #if defined(_DERIVATE)
647 [ # # ]: 0 : _load_static_jacobian1(Y3n1,A,((-0.5)*(TR*IY3_VA_GND)*d10_tanh0));
648 [ # # ]: 0 : _load_static_jacobian1(Y3n1,B,((-0.5)*(TR*IY3_VB_GND)*d10_tanh0));
649 [ # # ]: 0 : _load_static_jacobian1(Y3n1,C,((-0.5)*(TR*IY3_VC_GND)*d10_tanh0));
650 [ # # ]: 0 : _load_static_jacobian1(Y3n1,EN,((-0.5)*(TR*IY3_VEN_GND)*d10_tanh0));
651 : : #endif
652 : : }
653 : 0 : _load_static_residual1(Y3n1,NP(Y3n1));
654 : : #if defined(_DERIVATE)
655 [ # # ]: 0 : _load_static_jacobian1(Y3n1,Y3n1,1.0);
656 : : #endif
657 [ # # ][ # # ]: 0 : _load_static_residual2(Y3n1,Y3n2,(BP(Y3n1,Y3n2)/Rd));
658 : : #if defined(_DERIVATE)
659 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y3n1,Y3n2,Y3n1,Y3n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
660 : : #endif
661 : : #if defined(_DYNAMIC)
662 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y3n2,_DDT((Cd*NP(Y3n2))));
663 : : #if defined(_DERIVATE)
664 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y3n2,Y3n2,(Cd));
[ # # ]
665 : : #endif
666 : : #endif
667 : 0 : _load_static_residual1(Y3,(-NP(Y3n2)));
668 : : #if defined(_DERIVATE)
669 [ # # ]: 0 : _load_static_jacobian1(Y3,Y3n2,(-1.0));
670 : : #endif
671 : 0 : _load_static_residual1(Y3,NP(Y3));
672 : : #if defined(_DERIVATE)
673 [ # # ]: 0 : _load_static_jacobian1(Y3,Y3,1.0);
674 : : #endif
675 : : #if defined(_DERIVATE)
676 : 0 : IY4_VEN_GND=VENI_VEN_GND*NP(C)*VBI*VAI;
677 : 0 : IY4_VC_GND=(VENI)*VBI*VAI;
678 : 0 : IY4_VB_GND=((VENI*NP(C))*VBI_VB_GND)*VAI;
679 : 0 : IY4_VA_GND=(((VENI*NP(C))*VBI)*VAI_VA_GND);
680 : : #endif
681 : 0 : IY4=(((VENI*NP(C))*VBI)*VAI);
682 : : {
683 : 0 : double m00_tanh(d00_tanh0,(TR*(IY4-0.5)))
684 : : #if defined(_DERIVATE)
685 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY4-0.5)))
686 : : #endif
687 : 0 : _load_static_residual1(Y4n1,((-0.5)*(1+d00_tanh0)));
688 : : #if defined(_DERIVATE)
689 [ # # ]: 0 : _load_static_jacobian1(Y4n1,A,((-0.5)*(TR*IY4_VA_GND)*d10_tanh0));
690 [ # # ]: 0 : _load_static_jacobian1(Y4n1,B,((-0.5)*(TR*IY4_VB_GND)*d10_tanh0));
691 [ # # ]: 0 : _load_static_jacobian1(Y4n1,C,((-0.5)*(TR*IY4_VC_GND)*d10_tanh0));
692 [ # # ]: 0 : _load_static_jacobian1(Y4n1,EN,((-0.5)*(TR*IY4_VEN_GND)*d10_tanh0));
693 : : #endif
694 : : }
695 : 0 : _load_static_residual1(Y4n1,NP(Y4n1));
696 : : #if defined(_DERIVATE)
697 [ # # ]: 0 : _load_static_jacobian1(Y4n1,Y4n1,1.0);
698 : : #endif
699 [ # # ][ # # ]: 0 : _load_static_residual2(Y4n1,Y4n2,(BP(Y4n1,Y4n2)/Rd));
700 : : #if defined(_DERIVATE)
701 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y4n1,Y4n2,Y4n1,Y4n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
702 : : #endif
703 : : #if defined(_DYNAMIC)
704 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y4n2,_DDT((Cd*NP(Y4n2))));
705 : : #if defined(_DERIVATE)
706 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y4n2,Y4n2,(Cd));
[ # # ]
707 : : #endif
708 : : #endif
709 : 0 : _load_static_residual1(Y4,(-NP(Y4n2)));
710 : : #if defined(_DERIVATE)
711 [ # # ]: 0 : _load_static_jacobian1(Y4,Y4n2,(-1.0));
712 : : #endif
713 : 0 : _load_static_residual1(Y4,NP(Y4));
714 : : #if defined(_DERIVATE)
715 [ # # ]: 0 : _load_static_jacobian1(Y4,Y4,1.0);
716 : : #endif
717 : : #if defined(_DERIVATE)
718 [ # # ]: 0 : IY5_VEN_GND=VENI_VEN_GND*NP(C)*VBI*NP(A);
719 : 0 : IY5_VC_GND=(VENI)*VBI*NP(A);
720 [ # # ]: 0 : IY5_VB_GND=((VENI*NP(C))*VBI_VB_GND)*NP(A);
721 : 0 : IY5_VA_GND=(((VENI*NP(C))*VBI));
722 : : #endif
723 [ # # ]: 0 : IY5=(((VENI*NP(C))*VBI)*NP(A));
724 : : {
725 : 0 : double m00_tanh(d00_tanh0,(TR*(IY5-0.5)))
726 : : #if defined(_DERIVATE)
727 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY5-0.5)))
728 : : #endif
729 : 0 : _load_static_residual1(Y5n1,((-0.5)*(1+d00_tanh0)));
730 : : #if defined(_DERIVATE)
731 [ # # ]: 0 : _load_static_jacobian1(Y5n1,A,((-0.5)*(TR*IY5_VA_GND)*d10_tanh0));
732 [ # # ]: 0 : _load_static_jacobian1(Y5n1,B,((-0.5)*(TR*IY5_VB_GND)*d10_tanh0));
733 [ # # ]: 0 : _load_static_jacobian1(Y5n1,C,((-0.5)*(TR*IY5_VC_GND)*d10_tanh0));
734 [ # # ]: 0 : _load_static_jacobian1(Y5n1,EN,((-0.5)*(TR*IY5_VEN_GND)*d10_tanh0));
735 : : #endif
736 : : }
737 : 0 : _load_static_residual1(Y5n1,NP(Y5n1));
738 : : #if defined(_DERIVATE)
739 [ # # ]: 0 : _load_static_jacobian1(Y5n1,Y5n1,1.0);
740 : : #endif
741 [ # # ][ # # ]: 0 : _load_static_residual2(Y5n1,Y5n2,(BP(Y5n1,Y5n2)/Rd));
742 : : #if defined(_DERIVATE)
743 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y5n1,Y5n2,Y5n1,Y5n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
744 : : #endif
745 : : #if defined(_DYNAMIC)
746 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y5n2,_DDT((Cd*NP(Y5n2))));
747 : : #if defined(_DERIVATE)
748 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y5n2,Y5n2,(Cd));
[ # # ]
749 : : #endif
750 : : #endif
751 : 0 : _load_static_residual1(Y5,(-NP(Y5n2)));
752 : : #if defined(_DERIVATE)
753 [ # # ]: 0 : _load_static_jacobian1(Y5,Y5n2,(-1.0));
754 : : #endif
755 : 0 : _load_static_residual1(Y5,NP(Y5));
756 : : #if defined(_DERIVATE)
757 [ # # ]: 0 : _load_static_jacobian1(Y5,Y5,1.0);
758 : : #endif
759 : : #if defined(_DERIVATE)
760 [ # # ]: 0 : IY6_VEN_GND=VENI_VEN_GND*NP(C)*NP(B)*VAI;
761 : 0 : IY6_VC_GND=(VENI)*NP(B)*VAI;
762 : 0 : IY6_VB_GND=((VENI*NP(C)))*VAI;
763 [ # # ]: 0 : IY6_VA_GND=(((VENI*NP(C))*NP(B))*VAI_VA_GND);
764 : : #endif
765 [ # # ]: 0 : IY6=(((VENI*NP(C))*NP(B))*VAI);
766 : : {
767 : 0 : double m00_tanh(d00_tanh0,(TR*(IY6-0.5)))
768 : : #if defined(_DERIVATE)
769 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY6-0.5)))
770 : : #endif
771 : 0 : _load_static_residual1(Y6n1,((-0.5)*(1+d00_tanh0)));
772 : : #if defined(_DERIVATE)
773 [ # # ]: 0 : _load_static_jacobian1(Y6n1,A,((-0.5)*(TR*IY6_VA_GND)*d10_tanh0));
774 [ # # ]: 0 : _load_static_jacobian1(Y6n1,B,((-0.5)*(TR*IY6_VB_GND)*d10_tanh0));
775 [ # # ]: 0 : _load_static_jacobian1(Y6n1,C,((-0.5)*(TR*IY6_VC_GND)*d10_tanh0));
776 [ # # ]: 0 : _load_static_jacobian1(Y6n1,EN,((-0.5)*(TR*IY6_VEN_GND)*d10_tanh0));
777 : : #endif
778 : : }
779 : 0 : _load_static_residual1(Y6n1,NP(Y6n1));
780 : : #if defined(_DERIVATE)
781 [ # # ]: 0 : _load_static_jacobian1(Y6n1,Y6n1,1.0);
782 : : #endif
783 [ # # ][ # # ]: 0 : _load_static_residual2(Y6n1,Y6n2,(BP(Y6n1,Y6n2)/Rd));
784 : : #if defined(_DERIVATE)
785 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y6n1,Y6n2,Y6n1,Y6n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
786 : : #endif
787 : : #if defined(_DYNAMIC)
788 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y6n2,_DDT((Cd*NP(Y6n2))));
789 : : #if defined(_DERIVATE)
790 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y6n2,Y6n2,(Cd));
[ # # ]
791 : : #endif
792 : : #endif
793 : 0 : _load_static_residual1(Y6,(-NP(Y6n2)));
794 : : #if defined(_DERIVATE)
795 [ # # ]: 0 : _load_static_jacobian1(Y6,Y6n2,(-1.0));
796 : : #endif
797 : 0 : _load_static_residual1(Y6,NP(Y6));
798 : : #if defined(_DERIVATE)
799 [ # # ]: 0 : _load_static_jacobian1(Y6,Y6,1.0);
800 : : #endif
801 : : #if defined(_DERIVATE)
802 [ # # ][ # # ]: 0 : IY7_VEN_GND=VENI_VEN_GND*NP(C)*NP(B)*NP(A);
803 [ # # ]: 0 : IY7_VC_GND=(VENI)*NP(B)*NP(A);
804 [ # # ]: 0 : IY7_VB_GND=((VENI*NP(C)))*NP(A);
805 [ # # ]: 0 : IY7_VA_GND=(((VENI*NP(C))*NP(B)));
806 : : #endif
807 [ # # ][ # # ]: 0 : IY7=(((VENI*NP(C))*NP(B))*NP(A));
808 : : {
809 : 0 : double m00_tanh(d00_tanh0,(TR*(IY7-0.5)))
810 : : #if defined(_DERIVATE)
811 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY7-0.5)))
812 : : #endif
813 : 0 : _load_static_residual1(Y7n1,((-0.5)*(1+d00_tanh0)));
814 : : #if defined(_DERIVATE)
815 [ # # ]: 0 : _load_static_jacobian1(Y7n1,A,((-0.5)*(TR*IY7_VA_GND)*d10_tanh0));
816 [ # # ]: 0 : _load_static_jacobian1(Y7n1,B,((-0.5)*(TR*IY7_VB_GND)*d10_tanh0));
817 [ # # ]: 0 : _load_static_jacobian1(Y7n1,C,((-0.5)*(TR*IY7_VC_GND)*d10_tanh0));
818 [ # # ]: 0 : _load_static_jacobian1(Y7n1,EN,((-0.5)*(TR*IY7_VEN_GND)*d10_tanh0));
819 : : #endif
820 : : }
821 : 0 : _load_static_residual1(Y7n1,NP(Y7n1));
822 : : #if defined(_DERIVATE)
823 [ # # ]: 0 : _load_static_jacobian1(Y7n1,Y7n1,1.0);
824 : : #endif
825 [ # # ][ # # ]: 0 : _load_static_residual2(Y7n1,Y7n2,(BP(Y7n1,Y7n2)/Rd));
826 : : #if defined(_DERIVATE)
827 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y7n1,Y7n2,Y7n1,Y7n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
828 : : #endif
829 : : #if defined(_DYNAMIC)
830 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y7n2,_DDT((Cd*NP(Y7n2))));
831 : : #if defined(_DERIVATE)
832 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y7n2,Y7n2,(Cd));
[ # # ]
833 : : #endif
834 : : #endif
835 : 0 : _load_static_residual1(Y7,(-NP(Y7n2)));
836 : : #if defined(_DERIVATE)
837 [ # # ]: 0 : _load_static_jacobian1(Y7,Y7n2,(-1.0));
838 : : #endif
839 : 0 : _load_static_residual1(Y7,NP(Y7));
840 : : #if defined(_DERIVATE)
841 [ # # ]: 0 : _load_static_jacobian1(Y7,Y7,1.0);
842 : : #endif
843 : :
844 : : /* ------------------ end of verilog analog equations --------------------- */
845 : :
846 : : /* ------------------ evaluate verilog noise equations -------------------- */
847 : :
848 : : /* ------------------- end of verilog noise equations --------------------- */
849 : 0 : }
850 : :
851 : : /* Perform DC iteration. */
852 : 0 : void dmux3to8::calcDC (void)
853 : : {
854 : : // evaluate Verilog code
855 : 0 : initVerilog ();
856 : 0 : calcVerilog ();
857 : :
858 : : // fill right hand side and static jacobian
859 [ # # ]: 0 : for (int i1 = 0; i1 < 28; i1++) {
860 [ # # ]: 0 : setI (i1, _rhs[i1]);
861 [ # # ]: 0 : for (int i2 = 0; i2 < 28; i2++) {
862 [ # # ]: 0 : setY (i1, i2, _jstat[i1][i2]);
863 : : }
864 : : }
865 : 0 : }
866 : :
867 : : /* Save operating points. */
868 : 0 : void dmux3to8::saveOperatingPoints (void)
869 : : {
870 : : // save global instance operating points
871 : 0 : }
872 : :
873 : : /* Load operating points. */
874 : 0 : void dmux3to8::loadOperatingPoints (void)
875 : : {
876 : 0 : }
877 : :
878 : : /* Calculate operating points. */
879 : 0 : void dmux3to8::calcOperatingPoints (void)
880 : : {
881 : 0 : }
882 : :
883 : : /* Initialization of AC analysis. */
884 : 0 : void dmux3to8::initAC (void)
885 : : {
886 : 0 : allocMatrixMNA ();
887 : 0 : }
888 : :
889 : : /* Perform AC calculations. */
890 : 0 : void dmux3to8::calcAC (nr_double_t frequency)
891 : : {
892 [ # # ]: 0 : setMatrixY (calcMatrixY (frequency));
893 : 0 : }
894 : :
895 : : /* Compute Y-matrix for AC analysis. */
896 : 0 : matrix dmux3to8::calcMatrixY (nr_double_t frequency)
897 : : {
898 : 0 : _freq = frequency;
899 : 0 : saveOperatingPoints ();
900 : 0 : matrix y (28);
901 : :
902 [ # # ]: 0 : for (int i1 = 0; i1 < 28; i1++) {
903 [ # # ]: 0 : for (int i2 = 0; i2 < 28; i2++) {
904 : 0 : y (i1,i2) = nr_complex_t (_jstat[i1][i2], _jdyna[i1][i2] * 2 * M_PI * _freq);
905 : : }
906 : : }
907 : :
908 : 0 : return y;
909 : : }
910 : :
911 : : /* Initialization of S-parameter analysis. */
912 : 0 : void dmux3to8::initSP (void)
913 : : {
914 : 0 : allocMatrixS ();
915 : 0 : }
916 : :
917 : : /* Perform S-parameter calculations. */
918 : 0 : void dmux3to8::calcSP (nr_double_t frequency)
919 : : {
920 [ # # ][ # # ]: 0 : setMatrixS (ytos (calcMatrixY (frequency)));
[ # # ][ # # ]
[ # # ]
921 : 0 : }
922 : :
923 : : /* Initialization of transient analysis. */
924 : 0 : void dmux3to8::initTR (void)
925 : : {
926 : 0 : setStates (2 * 28 * 28);
927 : 0 : initDC ();
928 : 0 : }
929 : :
930 : : /* Perform transient analysis iteration step. */
931 : 0 : void dmux3to8::calcTR (nr_double_t)
932 : : {
933 : 0 : doHB = 0;
934 : 0 : doAC = 1;
935 : 0 : doTR = 1;
936 : 0 : calcDC ();
937 : :
938 : : int i1, i2, i3, i4, state;
939 : :
940 : : // 2-node charge integrations
941 [ # # ]: 0 : for (i1 = 0; i1 < 28; i1++) {
942 [ # # ]: 0 : for (i2 = 0; i2 < 28; i2++) {
943 : 0 : state = 2 * (i2 + 28 * i1);
944 [ # # ]: 0 : if (i1 != i2)
945 [ # # ]: 0 : if (_charges[i1][i2] != 0.0)
946 : 0 : transientCapacitanceQ (state, i1, i2, _charges[i1][i2]);
947 : : } }
948 : :
949 : : // 1-node charge integrations
950 [ # # ]: 0 : for (i1 = 0; i1 < 28; i1++) {
951 : 0 : state = 2 * (i1 + 28 * i1);
952 [ # # ]: 0 : if (_charges[i1][i1] != 0.0)
953 : 0 : transientCapacitanceQ (state, i1, _charges[i1][i1]);
954 : : }
955 : :
956 : : // charge: 2-node, voltage: 2-node
957 [ # # ]: 0 : for (i1 = 0; i1 < 28; i1++) {
958 [ # # ]: 0 : for (i2 = 0; i2 < 28; i2++) {
959 [ # # ]: 0 : if (i1 != i2)
960 [ # # ]: 0 : for (i3 = 0; i3 < 28; i3++) {
961 [ # # ]: 0 : for (i4 = 0; i4 < 28; i4++) {
962 [ # # ]: 0 : if (i3 != i4)
963 [ # # ]: 0 : if (_caps[i1][i2][i3][i4] != 0.0)
964 [ # # ][ # # ]: 0 : transientCapacitanceC (i1, i2, i3, i4, _caps[i1][i2][i3][i4], BP(i3,i4));
965 : : } } } }
966 : :
967 : : // charge: 2-node, voltage: 1-node
968 [ # # ]: 0 : for (i1 = 0; i1 < 28; i1++) {
969 [ # # ]: 0 : for (i2 = 0; i2 < 28; i2++) {
970 [ # # ]: 0 : if (i1 != i2)
971 [ # # ]: 0 : for (i3 = 0; i3 < 28; i3++) {
972 [ # # ]: 0 : if (_caps[i1][i2][i3][i3] != 0.0)
973 [ # # ]: 0 : transientCapacitanceC2Q (i1, i2, i3, _caps[i1][i2][i3][i3], NP(i3));
974 : : } } }
975 : :
976 : : // charge: 1-node, voltage: 2-node
977 [ # # ]: 0 : for (i1 = 0; i1 < 28; i1++) {
978 [ # # ]: 0 : for (i3 = 0; i3 < 28; i3++) {
979 [ # # ]: 0 : for (i4 = 0; i4 < 28; i4++) {
980 [ # # ]: 0 : if (i3 != i4)
981 [ # # ]: 0 : if (_caps[i1][i1][i3][i4] != 0.0)
982 [ # # ][ # # ]: 0 : transientCapacitanceC2V (i1, i3, i4, _caps[i1][i1][i3][i4], BP(i3,i4));
983 : : } } }
984 : :
985 : : // charge: 1-node, voltage: 1-node
986 [ # # ]: 0 : for (i1 = 0; i1 < 28; i1++) {
987 [ # # ]: 0 : for (i3 = 0; i3 < 28; i3++) {
988 [ # # ]: 0 : if (_caps[i1][i1][i3][i3] != 0.0)
989 [ # # ]: 0 : transientCapacitanceC (i1, i3, _caps[i1][i1][i3][i3], NP(i3));
990 : : } }
991 : 0 : }
992 : :
993 : : /* Compute Cy-matrix for AC noise analysis. */
994 : 0 : matrix dmux3to8::calcMatrixCy (nr_double_t frequency)
995 : : {
996 : 0 : _freq = frequency;
997 : 0 : matrix cy (28);
998 : :
999 : :
1000 : 0 : return cy;
1001 : : }
1002 : :
1003 : : /* Perform AC noise computations. */
1004 : 0 : void dmux3to8::calcNoiseAC (nr_double_t frequency)
1005 : : {
1006 [ # # ]: 0 : setMatrixN (calcMatrixCy (frequency));
1007 : 0 : }
1008 : :
1009 : : /* Perform S-parameter noise computations. */
1010 : 0 : void dmux3to8::calcNoiseSP (nr_double_t frequency)
1011 : : {
1012 [ # # ][ # # ]: 0 : setMatrixN (cytocs (calcMatrixCy (frequency) * z0, getMatrixS ()));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1013 : 0 : }
1014 : :
1015 : : /* Initialization of HB analysis. */
1016 : 0 : void dmux3to8::initHB (int)
1017 : : {
1018 : 0 : initDC ();
1019 : 0 : allocMatrixHB ();
1020 : 0 : }
1021 : :
1022 : : /* Perform HB analysis. */
1023 : 0 : void dmux3to8::calcHB (int)
1024 : : {
1025 : 0 : doHB = 1;
1026 : 0 : doAC = 1;
1027 : 0 : doTR = 0;
1028 : :
1029 : : // jacobian dI/dV and currents get filled
1030 : 0 : calcDC ();
1031 : 0 : saveOperatingPoints ();
1032 : :
1033 : : // fill in HB matrices
1034 [ # # ]: 0 : for (int i1 = 0; i1 < 28; i1++) {
1035 [ # # ]: 0 : setQ (i1, _qhs[i1]); // charges
1036 [ # # ]: 0 : setCV (i1, _chs[i1]); // jacobian dQ/dV * V
1037 [ # # ]: 0 : setGV (i1, _ghs[i1]); // jacobian dI/dV * V
1038 [ # # ]: 0 : for (int i2 = 0; i2 < 28; i2++) {
1039 [ # # ]: 0 : setQV (i1, i2, _jdyna[i1][i2]); // jacobian dQ/dV
1040 : : }
1041 : : }
1042 : 0 : }
1043 : :
1044 : : #include "dmux3to8.defs.h"
1045 : :
|
