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