My Project  0.0.16
QUCS Mapping
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
dmux2to4.core.cpp
Go to the documentation of this file.
1 /*
2  * dmux2to4.core.cpp - device implementations for dmux2to4 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 "dmux2to4.analogfunction.h"
16 #include "component.h"
17 #include "device.h"
18 #include "dmux2to4.core.h"
19 
20 #ifndef CIR_dmux2to4
21 #define CIR_dmux2to4 -1
22 #endif
23 
24 // external nodes
25 #define EN 0
26 #define A 1
27 #define B 2
28 #define Y3 3
29 #define Y2 4
30 #define Y1 5
31 #define Y0 6
32 // internal nodes
33 #define Y0n1 7
34 #define Y0n2 8
35 #define Y1n1 9
36 #define Y1n2 10
37 #define Y2n1 11
38 #define Y2n2 12
39 #define Y3n1 13
40 #define Y3n2 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 #define m00_hypot(v00,x,y) v00 = xhypot(x,y);
176 #define m10_hypot(v10,v00,x,y) v10 = (x)/(v00);
177 #define m11_hypot(v11,v00,x,y) v11 = (y)/(v00);
178 #define m00_max(v00,x,y) v00 = ((x)>(y))?(x):(y);
179 #define m10_max(v10,v00,x,y) v10 = ((x)>(y))?1.0:0.0;
180 #define m11_max(v11,v00,x,y) v11 = ((x)>(y))?0.0:1.0;
181 #define m00_min(v00,x,y) v00 = ((x)<(y))?(x):(y);
182 #define m10_min(v10,v00,x,y) v10 = ((x)<(y))?1.0:0.0;
183 #define m11_min(v11,v00,x,y) v11 = ((x)<(y))?0.0:1.0;
184 #define m00_pow(v00,x,y) v00 = pow(x,y);
185 #define m10_pow(v10,v00,x,y) v10 = (x==0.0)?0.0:(v00)*(y)/(x);
186 #define m11_pow(v11,v00,x,y) v11 = (x==0.0)?0.0:(log(x)*(v00));
187 
188 #define m00_div(v00,v10,x,y) double v10=1/(y); double v00=(x)*v10;
189 #define m10_div(v10,v00,vv,x,y)
190 #define m11_div(v11,v00,vv,x,y) double v11 = -v00*vv;
191 
192 #define m00_mult(v00,v10,v11,x,y) double v10=(x); double v11=(y); double v00=v10*v11;
193 #define m00_add(v00,x,y) double v00=(x)+(y);
194 
195 #define m00_cos(v00,x) v00 = cos(x);
196 #define m10_cos(v10,v00,x) v10 = (-sin(x));
197 #define m00_sin(v00,x) v00 = sin(x);
198 #define m10_sin(v10,v00,x) v10 = (cos(x));
199 #define m00_tan(v00,x) v00 = tan(x);
200 #define m10_tan(v10,v00,x) v10 = (1.0/cos(x)/cos(x));
201 #define m00_cosh(v00,x) v00 = cosh(x);
202 #define m10_cosh(v10,v00,x) v10 = (sinh(x));
203 #define m00_sinh(v00,x) v00 = sinh(x);
204 #define m10_sinh(v10,v00,x) v10 = (cosh(x));
205 #define m00_tanh(v00,x) v00 = tanh(x);
206 #define m10_tanh(v10,v00,x) v10 = (1.0/cosh(x)/cosh(x));
207 #define m00_acos(v00,x) v00 = acos(x);
208 #define m10_acos(v10,v00,x) v10 = (-1.0/sqrt(1-x*x));
209 #define m00_asin(v00,x) v00 = asin(x);
210 #define m10_asin(v10,v00,x) v10 = (+1.0/sqrt(1-x*x));
211 #define m00_atan(v00,x) v00 = atan(x);
212 #define m10_atan(v10,v00,x) v10 = (+1.0/(1+x*x));
213 #define m00_atanh(v00,x) v00 = atanh(x);
214 #define m10_atanh(v10,v00,x) v10 = (+1.0/(1-x*x));
215 #define m00_logE(v00,x) v00 = log(x);
216 #define m10_logE(v10,v00,x) v10 = (1.0/x);
217 #define m00_log10(v00,x) v00 = log10(x);
218 #define m10_log10(v10,v00,x) v10 = (1.0/x/M_LN10);
219 #define m00_sqrt(v00,x) v00 = sqrt(x);
220 #define m10_sqrt(v10,v00,x) v10 = (0.5/v00);
221 #define m00_fabs(v00,x) v00 = fabs(x);
222 #define m10_fabs(v10,v00,x) v10 = (((x)>=0)?(+1.0):(-1.0));
223 
224 #define m00_exp(v00,x) v00 = exp(x);
225 #define m10_exp(v10,v00,x) v10 = v00;
226 
227 #define m00_abs(v00) ((v00)<(0)?(-(v00)):(v00))
228 #define m00_floor(v00,x) v00 = floor(x);
229 #define m00_limexp(v00,x) v00 = ((x)<80.0?exp(x):exp(80.0)*(x-79.0));
230 #define m10_limexp(v10,v00,x) v10 = ((x)<80.0?(v00):exp(80.0));
231 
232 #define m20_logE(v00) (-1.0/v00/v00)
233 #define m20_exp(v00) exp(v00)
234 #define m20_limexp(v00) ((v00)<80.0?exp(v00):0.0)
235 #define m20_sqrt(v00) (-0.25/(v00)/sqrt(v00))
236 #define m20_fabs(v00) 0.0
237 #define m20_pow(x,y) ((y)*((y)-1.0)*pow(x,y)/(x)/(x))
238 #define m00_vt(x) (kBoverQ*(x))
239 #define m10_vt(x) (kBoverQ)
240 
241 // simulator specific definitions
242 #define _modelname "dmux2to4"
243 #define _instancename getName()
244 #define _circuit_temp (getPropertyDouble("Temp")+273.15)
245 #define _param_given(p) (isPropertyGiven(p)?1:0)
246 
247 
248 // $vt and $vt() functions
249 #define _vt_nom (kBoverQ*_circuit_temp)
250 
251 using namespace device;
252 
253 /* Device constructor. */
254 dmux2to4::dmux2to4() : circuit (15)
255 {
256  type = CIR_dmux2to4;
257 }
258 
259 /* Initialization of model. */
260 void dmux2to4::initModel (void)
261 {
262  // create internal nodes
263  setInternalNode (Y0n1, "Y0n1");
264  setInternalNode (Y0n2, "Y0n2");
265  setInternalNode (Y1n1, "Y1n1");
266  setInternalNode (Y1n2, "Y1n2");
267  setInternalNode (Y2n1, "Y2n1");
268  setInternalNode (Y2n2, "Y2n2");
269  setInternalNode (Y3n1, "Y3n1");
270  setInternalNode (Y3n2, "Y3n2");
271 
272  // get device model parameters
273  loadVariables ();
274  // evaluate global model equations
275  initializeModel ();
276  // evaluate initial step equations
277  initialStep ();
278  // evaluate global instance equations
279  initializeInstance ();
280 }
281 
282 /* Initialization of DC analysis. */
283 void dmux2to4::initDC (void)
284 {
285  allocMatrixMNA ();
286  initModel ();
287  pol = 1;
288  restartDC ();
289  doAC = 1;
290  doTR = 0;
291  doHB = 0;
292 }
293 
294 /* Run when DC is restarted (fallback algorithms). */
295 void dmux2to4::restartDC (void)
296 {
297 }
298 
299 /* Initialize Verilog-AMS code. */
300 void dmux2to4::initVerilog (void)
301 {
302  // initialization of noise variables
303 
304  int i1, i2, i3, i4;
305 
306  // zero charges
307  for (i1 = 0; i1 < 15; i1++) {
308  for (i2 = 0; i2 < 15; i2++) {
309  _charges[i1][i2] = 0.0;
310  } }
311 
312  // zero capacitances
313  for (i1 = 0; i1 < 15; i1++) {
314  for (i2 = 0; i2 < 15; i2++) {
315  for (i3 = 0; i3 < 15; i3++) {
316  for (i4 = 0; i4 < 15; i4++) {
317  _caps[i1][i2][i3][i4] = 0.0;
318  } } } }
319 
320  // zero right hand side, static and dynamic jacobian
321  for (i1 = 0; i1 < 15; i1++) {
322  _rhs[i1] = 0.0;
323  _qhs[i1] = 0.0;
324  _chs[i1] = 0.0;
325  _ghs[i1] = 0.0;
326  for (i2 = 0; i2 < 15; i2++) {
327  _jstat[i1][i2] = 0.0;
328  _jdyna[i1][i2] = 0.0;
329  }
330  }
331 }
332 
333 /* Load device model input parameters. */
334 void dmux2to4::loadVariables (void)
335 {
336  TR = getPropertyDouble ("TR");
337  Delay = getPropertyDouble ("Delay");
338 }
339 
340 /* #define's for translated code */
341 #undef _DDT
342 #define _DDT(q) q
343 #define _DYNAMIC
344 #define _DERIVATE
345 #define _DDX
346 #define _DERIVATEFORDDX
347 
348 /* Evaluate Verilog-AMS equations in model initialization. */
349 void dmux2to4::initializeModel (void)
350 {
351 #if defined(_DYNAMIC)
352 #endif
353 {
354 Rd=1e3;
355 #if defined(_DYNAMIC)
356 Cd=((Delay*1.43)/Rd);
357 #endif
358 }
359 }
360 
361 /* Evaluate Verilog-AMS equations in instance initialization. */
362 void dmux2to4::initializeInstance (void)
363 {
364 }
365 
366 /* Evaluate Verilog-AMS equations in initial step. */
367 void dmux2to4::initialStep (void)
368 {
369 }
370 
371 /* Evaluate Verilog-AMS equations in final step. */
372 void dmux2to4::finalStep (void)
373 {
374 }
375 
376 /* Evaluate Verilog-AMS equations in analog block. */
377 void dmux2to4::calcVerilog (void)
378 {
379 
380 /* ----------------- evaluate verilog analog equations -------------------- */
381 double IY3;
382 #if defined(_DERIVATE)
383 double IY3_VEN_GND;
384 double IY3_VB_GND;
385 double IY3_VA_GND;
386 #endif
387 double IY2;
388 #if defined(_DERIVATE)
389 double IY2_VEN_GND;
390 double IY2_VB_GND;
391 double IY2_VA_GND;
392 #endif
393 double IY1;
394 #if defined(_DERIVATE)
395 double IY1_VEN_GND;
396 double IY1_VB_GND;
397 double IY1_VA_GND;
398 #endif
399 double IY0;
400 #if defined(_DERIVATE)
401 double IY0_VEN_GND;
402 double IY0_VB_GND;
403 double IY0_VA_GND;
404 #endif
405 double VBI;
406 #if defined(_DERIVATE)
407 double VBI_VB_GND;
408 #endif
409 double VAI;
410 #if defined(_DERIVATE)
411 double VAI_VA_GND;
412 #endif
413 double VENI;
414 #if defined(_DERIVATE)
415 double VENI_VEN_GND;
416 #endif
417 #if defined(_DERIVATE)
418 VENI_VEN_GND=(-1.0);
419 #endif
420 VENI=(1-NP(EN));
421 #if defined(_DERIVATE)
422 VAI_VA_GND=(-1.0);
423 #endif
424 VAI=(1-NP(A));
425 #if defined(_DERIVATE)
426 VBI_VB_GND=(-1.0);
427 #endif
428 VBI=(1-NP(B));
429 #if defined(_DERIVATE)
430 IY0_VEN_GND=VENI_VEN_GND*VBI*VAI;
431 IY0_VB_GND=(VENI*VBI_VB_GND)*VAI;
432 IY0_VA_GND=((VENI*VBI)*VAI_VA_GND);
433 #endif
434 IY0=((VENI*VBI)*VAI);
435 {
436 double m00_tanh(d00_tanh0,(TR*(IY0-0.5)))
437 #if defined(_DERIVATE)
438 double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY0-0.5)))
439 #endif
440 _load_static_residual1(Y0n1,((-0.5)*(1+d00_tanh0)));
441 #if defined(_DERIVATE)
442 _load_static_jacobian1(Y0n1,A,((-0.5)*(TR*IY0_VA_GND)*d10_tanh0));
443 _load_static_jacobian1(Y0n1,B,((-0.5)*(TR*IY0_VB_GND)*d10_tanh0));
444 _load_static_jacobian1(Y0n1,EN,((-0.5)*(TR*IY0_VEN_GND)*d10_tanh0));
445 #endif
446 }
447 _load_static_residual1(Y0n1,NP(Y0n1));
448 #if defined(_DERIVATE)
449 _load_static_jacobian1(Y0n1,Y0n1,1.0);
450 #endif
451 _load_static_residual2(Y0n1,Y0n2,(BP(Y0n1,Y0n2)/Rd));
452 #if defined(_DERIVATE)
453 _load_static_jacobian4(Y0n1,Y0n2,Y0n1,Y0n2,(1/Rd));
454 #endif
455 #if defined(_DYNAMIC)
456 _load_dynamic_residual1(Y0n2,_DDT((Cd*NP(Y0n2))));
457 #if defined(_DERIVATE)
458 _load_dynamic_jacobian1(Y0n2,Y0n2,(Cd));
459 #endif
460 #endif
461 _load_static_residual1(Y0,(-NP(Y0n2)));
462 #if defined(_DERIVATE)
463 _load_static_jacobian1(Y0,Y0n2,(-1.0));
464 #endif
465 _load_static_residual1(Y0,NP(Y0));
466 #if defined(_DERIVATE)
467 _load_static_jacobian1(Y0,Y0,1.0);
468 #endif
469 #if defined(_DERIVATE)
470 IY1_VEN_GND=VENI_VEN_GND*VBI*NP(A);
471 IY1_VB_GND=(VENI*VBI_VB_GND)*NP(A);
472 IY1_VA_GND=((VENI*VBI));
473 #endif
474 IY1=((VENI*VBI)*NP(A));
475 {
476 double m00_tanh(d00_tanh0,(TR*(IY1-0.5)))
477 #if defined(_DERIVATE)
478 double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY1-0.5)))
479 #endif
480 _load_static_residual1(Y1n1,((-0.5)*(1+d00_tanh0)));
481 #if defined(_DERIVATE)
482 _load_static_jacobian1(Y1n1,A,((-0.5)*(TR*IY1_VA_GND)*d10_tanh0));
483 _load_static_jacobian1(Y1n1,B,((-0.5)*(TR*IY1_VB_GND)*d10_tanh0));
484 _load_static_jacobian1(Y1n1,EN,((-0.5)*(TR*IY1_VEN_GND)*d10_tanh0));
485 #endif
486 }
487 _load_static_residual1(Y1n1,NP(Y1n1));
488 #if defined(_DERIVATE)
489 _load_static_jacobian1(Y1n1,Y1n1,1.0);
490 #endif
491 _load_static_residual2(Y1n1,Y1n2,(BP(Y1n1,Y1n2)/Rd));
492 #if defined(_DERIVATE)
493 _load_static_jacobian4(Y1n1,Y1n2,Y1n1,Y1n2,(1/Rd));
494 #endif
495 #if defined(_DYNAMIC)
496 _load_dynamic_residual1(Y1n2,_DDT((Cd*NP(Y1n2))));
497 #if defined(_DERIVATE)
498 _load_dynamic_jacobian1(Y1n2,Y1n2,(Cd));
499 #endif
500 #endif
501 _load_static_residual1(Y1,(-NP(Y1n2)));
502 #if defined(_DERIVATE)
503 _load_static_jacobian1(Y1,Y1n2,(-1.0));
504 #endif
505 _load_static_residual1(Y1,NP(Y1));
506 #if defined(_DERIVATE)
507 _load_static_jacobian1(Y1,Y1,1.0);
508 #endif
509 #if defined(_DERIVATE)
510 IY2_VEN_GND=VENI_VEN_GND*NP(B)*VAI;
511 IY2_VB_GND=(VENI)*VAI;
512 IY2_VA_GND=((VENI*NP(B))*VAI_VA_GND);
513 #endif
514 IY2=((VENI*NP(B))*VAI);
515 {
516 double m00_tanh(d00_tanh0,(TR*(IY2-0.5)))
517 #if defined(_DERIVATE)
518 double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY2-0.5)))
519 #endif
520 _load_static_residual1(Y2n1,((-0.5)*(1+d00_tanh0)));
521 #if defined(_DERIVATE)
522 _load_static_jacobian1(Y2n1,A,((-0.5)*(TR*IY2_VA_GND)*d10_tanh0));
523 _load_static_jacobian1(Y2n1,B,((-0.5)*(TR*IY2_VB_GND)*d10_tanh0));
524 _load_static_jacobian1(Y2n1,EN,((-0.5)*(TR*IY2_VEN_GND)*d10_tanh0));
525 #endif
526 }
527 _load_static_residual1(Y2n1,NP(Y2n1));
528 #if defined(_DERIVATE)
529 _load_static_jacobian1(Y2n1,Y2n1,1.0);
530 #endif
531 _load_static_residual2(Y2n1,Y2n2,(BP(Y2n1,Y2n2)/Rd));
532 #if defined(_DERIVATE)
533 _load_static_jacobian4(Y2n1,Y2n2,Y2n1,Y2n2,(1/Rd));
534 #endif
535 #if defined(_DYNAMIC)
536 _load_dynamic_residual1(Y2n2,_DDT((Cd*NP(Y2n2))));
537 #if defined(_DERIVATE)
538 _load_dynamic_jacobian1(Y2n2,Y2n2,(Cd));
539 #endif
540 #endif
541 _load_static_residual1(Y2,(-NP(Y2n2)));
542 #if defined(_DERIVATE)
543 _load_static_jacobian1(Y2,Y2n2,(-1.0));
544 #endif
545 _load_static_residual1(Y2,NP(Y2));
546 #if defined(_DERIVATE)
547 _load_static_jacobian1(Y2,Y2,1.0);
548 #endif
549 #if defined(_DERIVATE)
550 IY3_VEN_GND=VENI_VEN_GND*NP(B)*NP(A);
551 IY3_VB_GND=(VENI)*NP(A);
552 IY3_VA_GND=((VENI*NP(B)));
553 #endif
554 IY3=((VENI*NP(B))*NP(A));
555 {
556 double m00_tanh(d00_tanh0,(TR*(IY3-0.5)))
557 #if defined(_DERIVATE)
558 double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY3-0.5)))
559 #endif
560 _load_static_residual1(Y3n1,((-0.5)*(1+d00_tanh0)));
561 #if defined(_DERIVATE)
562 _load_static_jacobian1(Y3n1,A,((-0.5)*(TR*IY3_VA_GND)*d10_tanh0));
563 _load_static_jacobian1(Y3n1,B,((-0.5)*(TR*IY3_VB_GND)*d10_tanh0));
564 _load_static_jacobian1(Y3n1,EN,((-0.5)*(TR*IY3_VEN_GND)*d10_tanh0));
565 #endif
566 }
567 _load_static_residual1(Y3n1,NP(Y3n1));
568 #if defined(_DERIVATE)
569 _load_static_jacobian1(Y3n1,Y3n1,1.0);
570 #endif
571 _load_static_residual2(Y3n1,Y3n2,(BP(Y3n1,Y3n2)/Rd));
572 #if defined(_DERIVATE)
573 _load_static_jacobian4(Y3n1,Y3n2,Y3n1,Y3n2,(1/Rd));
574 #endif
575 #if defined(_DYNAMIC)
576 _load_dynamic_residual1(Y3n2,_DDT((Cd*NP(Y3n2))));
577 #if defined(_DERIVATE)
578 _load_dynamic_jacobian1(Y3n2,Y3n2,(Cd));
579 #endif
580 #endif
581 _load_static_residual1(Y3,(-NP(Y3n2)));
582 #if defined(_DERIVATE)
583 _load_static_jacobian1(Y3,Y3n2,(-1.0));
584 #endif
585 _load_static_residual1(Y3,NP(Y3));
586 #if defined(_DERIVATE)
587 _load_static_jacobian1(Y3,Y3,1.0);
588 #endif
589 
590 /* ------------------ end of verilog analog equations --------------------- */
591 
592 /* ------------------ evaluate verilog noise equations -------------------- */
593 
594 /* ------------------- end of verilog noise equations --------------------- */
595 }
596 
597 /* Perform DC iteration. */
598 void dmux2to4::calcDC (void)
599 {
600  // evaluate Verilog code
601  initVerilog ();
602  calcVerilog ();
603 
604  // fill right hand side and static jacobian
605  for (int i1 = 0; i1 < 15; i1++) {
606  setI (i1, _rhs[i1]);
607  for (int i2 = 0; i2 < 15; i2++) {
608  setY (i1, i2, _jstat[i1][i2]);
609  }
610  }
611 }
612 
613 /* Save operating points. */
614 void dmux2to4::saveOperatingPoints (void)
615 {
616  // save global instance operating points
617 }
618 
619 /* Load operating points. */
620 void dmux2to4::loadOperatingPoints (void)
621 {
622 }
623 
624 /* Calculate operating points. */
625 void dmux2to4::calcOperatingPoints (void)
626 {
627 }
628 
629 /* Initialization of AC analysis. */
630 void dmux2to4::initAC (void)
631 {
632  allocMatrixMNA ();
633 }
634 
635 /* Perform AC calculations. */
636 void dmux2to4::calcAC (nr_double_t frequency)
637 {
638  setMatrixY (calcMatrixY (frequency));
639 }
640 
641 /* Compute Y-matrix for AC analysis. */
642 matrix dmux2to4::calcMatrixY (nr_double_t frequency)
643 {
644  _freq = frequency;
645  saveOperatingPoints ();
646  matrix y (15);
647 
648  for (int i1 = 0; i1 < 15; i1++) {
649  for (int i2 = 0; i2 < 15; i2++) {
650  y (i1,i2) = rect (_jstat[i1][i2], _jdyna[i1][i2] * 2 * M_PI * _freq);
651  }
652  }
653 
654  return y;
655 }
656 
657 /* Initialization of S-parameter analysis. */
658 void dmux2to4::initSP (void)
659 {
660  allocMatrixS ();
661 }
662 
663 /* Perform S-parameter calculations. */
664 void dmux2to4::calcSP (nr_double_t frequency)
665 {
666  setMatrixS (ytos (calcMatrixY (frequency)));
667 }
668 
669 /* Initialization of transient analysis. */
670 void dmux2to4::initTR (void)
671 {
672  setStates (2 * 15 * 15);
673  initDC ();
674 }
675 
676 /* Perform transient analysis iteration step. */
677 void dmux2to4::calcTR (nr_double_t)
678 {
679  doHB = 0;
680  doAC = 1;
681  doTR = 1;
682  calcDC ();
683 
684  int i1, i2, i3, i4, state;
685 
686  // 2-node charge integrations
687  for (i1 = 0; i1 < 15; i1++) {
688  for (i2 = 0; i2 < 15; i2++) {
689  state = 2 * (i2 + 15 * i1);
690  if (i1 != i2)
691  if (_charges[i1][i2] != 0.0)
692  transientCapacitanceQ (state, i1, i2, _charges[i1][i2]);
693  } }
694 
695  // 1-node charge integrations
696  for (i1 = 0; i1 < 15; i1++) {
697  state = 2 * (i1 + 15 * i1);
698  if (_charges[i1][i1] != 0.0)
699  transientCapacitanceQ (state, i1, _charges[i1][i1]);
700  }
701 
702  // charge: 2-node, voltage: 2-node
703  for (i1 = 0; i1 < 15; i1++) {
704  for (i2 = 0; i2 < 15; i2++) {
705  if (i1 != i2)
706  for (i3 = 0; i3 < 15; i3++) {
707  for (i4 = 0; i4 < 15; i4++) {
708  if (i3 != i4)
709  if (_caps[i1][i2][i3][i4] != 0.0)
710  transientCapacitanceC (i1, i2, i3, i4, _caps[i1][i2][i3][i4], BP(i3,i4));
711  } } } }
712 
713  // charge: 2-node, voltage: 1-node
714  for (i1 = 0; i1 < 15; i1++) {
715  for (i2 = 0; i2 < 15; i2++) {
716  if (i1 != i2)
717  for (i3 = 0; i3 < 15; i3++) {
718  if (_caps[i1][i2][i3][i3] != 0.0)
719  transientCapacitanceC2Q (i1, i2, i3, _caps[i1][i2][i3][i3], NP(i3));
720  } } }
721 
722  // charge: 1-node, voltage: 2-node
723  for (i1 = 0; i1 < 15; i1++) {
724  for (i3 = 0; i3 < 15; i3++) {
725  for (i4 = 0; i4 < 15; i4++) {
726  if (i3 != i4)
727  if (_caps[i1][i1][i3][i4] != 0.0)
728  transientCapacitanceC2V (i1, i3, i4, _caps[i1][i1][i3][i4], BP(i3,i4));
729  } } }
730 
731  // charge: 1-node, voltage: 1-node
732  for (i1 = 0; i1 < 15; i1++) {
733  for (i3 = 0; i3 < 15; i3++) {
734  if (_caps[i1][i1][i3][i3] != 0.0)
735  transientCapacitanceC (i1, i3, _caps[i1][i1][i3][i3], NP(i3));
736  } }
737 }
738 
739 /* Compute Cy-matrix for AC noise analysis. */
740 matrix dmux2to4::calcMatrixCy (nr_double_t frequency)
741 {
742  _freq = frequency;
743  matrix cy (15);
744 
745 
746  return cy;
747 }
748 
749 /* Perform AC noise computations. */
750 void dmux2to4::calcNoiseAC (nr_double_t frequency)
751 {
752  setMatrixN (calcMatrixCy (frequency));
753 }
754 
755 /* Perform S-parameter noise computations. */
756 void dmux2to4::calcNoiseSP (nr_double_t frequency)
757 {
758  setMatrixN (cytocs (calcMatrixCy (frequency) * z0, getMatrixS ()));
759 }
760 
761 /* Initialization of HB analysis. */
762 void dmux2to4::initHB (int)
763 {
764  initDC ();
765  allocMatrixHB ();
766 }
767 
768 /* Perform HB analysis. */
769 void dmux2to4::calcHB (int)
770 {
771  doHB = 1;
772  doAC = 1;
773  doTR = 0;
774 
775  // jacobian dI/dV and currents get filled
776  calcDC ();
777  saveOperatingPoints ();
778 
779  // fill in HB matrices
780  for (int i1 = 0; i1 < 15; i1++) {
781  setQ (i1, _qhs[i1]); // charges
782  setCV (i1, _chs[i1]); // jacobian dQ/dV * V
783  setGV (i1, _ghs[i1]); // jacobian dI/dV * V
784  for (int i2 = 0; i2 < 15; i2++) {
785  setQV (i1, i2, _jdyna[i1][i2]); // jacobian dQ/dV
786  }
787  }
788 }
789 
790 #include "dmux2to4.defs.h"
Generated on Tue Dec 25 2012 14:28:07 for My Project by   doxygen 1.8.2