Branch data Line data Source code
1 : : /*
2 : : * dmux4to16.core.cpp - device implementations for dmux4to16 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 "dmux4to16.analogfunction.h"
16 : : #include "component.h"
17 : : #include "device.h"
18 : : #include "dmux4to16.core.h"
19 : :
20 : : #ifndef CIR_dmux4to16
21 : : #define CIR_dmux4to16 -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 D 4
30 : : #define Y15 5
31 : : #define Y14 6
32 : : #define Y13 7
33 : : #define Y12 8
34 : : #define Y11 9
35 : : #define Y10 10
36 : : #define Y9 11
37 : : #define Y8 12
38 : : #define Y7 13
39 : : #define Y6 14
40 : : #define Y5 15
41 : : #define Y4 16
42 : : #define Y3 17
43 : : #define Y2 18
44 : : #define Y1 19
45 : : #define Y0 20
46 : : // internal nodes
47 : : #define Y0n1 21
48 : : #define Y0n2 22
49 : : #define Y1n1 23
50 : : #define Y1n2 24
51 : : #define Y2n1 25
52 : : #define Y2n2 26
53 : : #define Y3n1 27
54 : : #define Y3n2 28
55 : : #define Y4n1 29
56 : : #define Y4n2 30
57 : : #define Y5n1 31
58 : : #define Y5n2 32
59 : : #define Y6n1 33
60 : : #define Y6n2 34
61 : : #define Y7n1 35
62 : : #define Y7n2 36
63 : : #define Y8n1 37
64 : : #define Y8n2 38
65 : : #define Y9n1 39
66 : : #define Y9n2 40
67 : : #define Y10n1 41
68 : : #define Y10n2 42
69 : : #define Y11n1 43
70 : : #define Y11n2 44
71 : : #define Y12n1 45
72 : : #define Y12n2 46
73 : : #define Y13n1 47
74 : : #define Y13n2 48
75 : : #define Y14n1 49
76 : : #define Y14n2 50
77 : : #define Y15n1 51
78 : : #define Y15n2 52
79 : :
80 : : // useful macro definitions
81 : : #define NP(node) real (getV (node))
82 : : #define BP(pnode,nnode) (NP(pnode) - NP(nnode))
83 : : #define _load_static_residual2(pnode,nnode,current)\
84 : : _rhs[pnode] -= current;\
85 : : _rhs[nnode] += current;
86 : : #define _load_static_augmented_residual2(pnode,nnode,current)\
87 : : _rhs[pnode] -= current;\
88 : : _rhs[nnode] += current;
89 : : #define _load_static_residual1(node,current)\
90 : : _rhs[node] -= current;
91 : : #define _load_static_augmented_residual1(node,current)\
92 : : _rhs[node] -= current;
93 : : #define _load_static_jacobian4(pnode,nnode,vpnode,vnnode,conductance)\
94 : : _jstat[pnode][vpnode] += conductance;\
95 : : _jstat[nnode][vnnode] += conductance;\
96 : : _jstat[pnode][vnnode] -= conductance;\
97 : : _jstat[nnode][vpnode] -= conductance;\
98 : : if (doHB) {\
99 : : _ghs[pnode] += conductance * BP(vpnode,vnnode);\
100 : : _ghs[nnode] -= conductance * BP(vpnode,vnnode);\
101 : : } else {\
102 : : _rhs[pnode] += conductance * BP(vpnode,vnnode);\
103 : : _rhs[nnode] -= conductance * BP(vpnode,vnnode);\
104 : : }
105 : : #define _load_static_jacobian2p(node,vpnode,vnnode,conductance)\
106 : : _jstat[node][vpnode] += conductance;\
107 : : _jstat[node][vnnode] -= conductance;\
108 : : if (doHB) {\
109 : : _ghs[node] += conductance * BP(vpnode,vnnode);\
110 : : } else {\
111 : : _rhs[node] += conductance * BP(vpnode,vnnode);\
112 : : }
113 : : #define _load_static_jacobian2s(pnode,nnode,node,conductance)\
114 : : _jstat[pnode][node] += conductance;\
115 : : _jstat[nnode][node] -= conductance;\
116 : : if (doHB) {\
117 : : _ghs[pnode] += conductance * NP(node);\
118 : : _ghs[nnode] -= conductance * NP(node);\
119 : : } else {\
120 : : _rhs[pnode] += conductance * NP(node);\
121 : : _rhs[nnode] -= conductance * NP(node);\
122 : : }
123 : : #define _load_static_jacobian1(node,vnode,conductance)\
124 : : _jstat[node][vnode] += conductance;\
125 : : if (doHB) {\
126 : : _ghs[node] += conductance * NP(vnode);\
127 : : } else {\
128 : : _rhs[node] += conductance * NP(vnode);\
129 : : }
130 : : #define _load_dynamic_residual2(pnode,nnode,charge)\
131 : : if (doTR) _charges[pnode][nnode] += charge;\
132 : : if (doHB) {\
133 : : _qhs[pnode] -= charge;\
134 : : _qhs[nnode] += charge;\
135 : : }
136 : : #define _load_dynamic_residual1(node,charge)\
137 : : if (doTR) _charges[node][node] += charge;\
138 : : if (doHB) {\
139 : : _qhs[node] -= charge;\
140 : : }
141 : : #define _load_dynamic_jacobian4(pnode,nnode,vpnode,vnnode,capacitance)\
142 : : if (doAC) {\
143 : : _jdyna[pnode][vpnode] += capacitance;\
144 : : _jdyna[nnode][vnnode] += capacitance;\
145 : : _jdyna[pnode][vnnode] -= capacitance;\
146 : : _jdyna[nnode][vpnode] -= capacitance;\
147 : : }\
148 : : if (doTR) {\
149 : : _caps[pnode][nnode][vpnode][vnnode] += capacitance;\
150 : : }\
151 : : if (doHB) {\
152 : : _chs[pnode] += capacitance * BP(vpnode,vnnode);\
153 : : _chs[nnode] -= capacitance * BP(vpnode,vnnode);\
154 : : }
155 : : #define _load_dynamic_jacobian2s(pnode,nnode,vnode,capacitance)\
156 : : if (doAC) {\
157 : : _jdyna[pnode][vnode] += capacitance;\
158 : : _jdyna[nnode][vnode] -= capacitance;\
159 : : }\
160 : : if (doTR) {\
161 : : _caps[pnode][nnode][vnode][vnode] += capacitance;\
162 : : }\
163 : : if (doHB) {\
164 : : _chs[pnode] += capacitance * NP(vnode);\
165 : : _chs[nnode] -= capacitance * NP(vnode);\
166 : : }
167 : : #define _load_dynamic_jacobian2p(node,vpnode,vnnode,capacitance)\
168 : : if (doAC) {\
169 : : _jdyna[node][vpnode] += capacitance;\
170 : : _jdyna[node][vnnode] -= capacitance;\
171 : : }\
172 : : if (doTR) {\
173 : : _caps[node][node][vpnode][vnnode] += capacitance;\
174 : : }\
175 : : if (doHB) {\
176 : : _chs[node] += capacitance * BP(vpnode,vnnode);\
177 : : }
178 : : #define _load_dynamic_jacobian1(node,vnode,capacitance)\
179 : : if (doAC) {\
180 : : _jdyna[node][vnode] += capacitance;\
181 : : }\
182 : : if (doTR) {\
183 : : _caps[node][node][vnode][vnode] += capacitance;\
184 : : }\
185 : : if (doHB) {\
186 : : _chs[node] += capacitance * NP(vnode);\
187 : : }
188 : :
189 : : #define _save_whitenoise1(n1,pwr,type)\
190 : : _white_pwr[n1][n1] += pwr;
191 : : #define _save_whitenoise2(n1,n2,pwr,type)\
192 : : _white_pwr[n1][n2] += pwr;
193 : : #define _save_flickernoise1(n1,pwr,exp,type)\
194 : : _flicker_pwr[n1][n1] += pwr;\
195 : : _flicker_exp[n1][n1] += exp;
196 : : #define _save_flickernoise2(n1,n2,pwr,exp,type)\
197 : : _flicker_pwr[n1][n2] += pwr;\
198 : : _flicker_exp[n1][n2] += exp;
199 : : #define _load_whitenoise2(n1,n2,pwr)\
200 : : cy (n1,n2) -= pwr/kB/T0; cy (n2,n1) -= pwr/kB/T0;\
201 : : cy (n1,n1) += pwr/kB/T0; cy (n2,n2) += pwr/kB/T0;
202 : : #define _load_whitenoise1(n1,pwr)\
203 : : cy (n1,n1) += pwr/kB/T0;
204 : : #define _load_flickernoise2(n1,n2,pwr,exp)\
205 : : cy (n1,n2) -= pwr*pow(_freq,-exp)/kB/T0;\
206 : : cy (n2,n1) -= pwr*pow(_freq,-exp)/kB/T0;\
207 : : cy (n1,n1) += pwr*pow(_freq,-exp)/kB/T0;\
208 : : cy (n2,n2) += pwr*pow(_freq,-exp)/kB/T0;
209 : : #define _load_flickernoise1(n1,pwr,exp)\
210 : : cy (n1,n1) += pwr*pow(_freq,-exp)/kB/T0;
211 : :
212 : : // derivative helper macros
213 : : // transcendental LRM p. 59
214 : : #define m00_cos(v00,x) v00 = cos(x);
215 : : #define m10_cos(v10,v00,x) v10 = (-sin(x));
216 : : #define m00_sin(v00,x) v00 = sin(x);
217 : : #define m10_sin(v10,v00,x) v10 = (cos(x));
218 : : #define m00_tan(v00,x) v00 = tan(x);
219 : : #define m10_tan(v10,v00,x) v10 = (1.0/cos(x)/cos(x));
220 : : #define m00_cosh(v00,x) v00 = cosh(x);
221 : : #define m10_cosh(v10,v00,x) v10 = (sinh(x));
222 : : #define m00_sinh(v00,x) v00 = sinh(x);
223 : : #define m10_sinh(v10,v00,x) v10 = (cosh(x));
224 : : #define m00_tanh(v00,x) v00 = tanh(x);
225 : : #define m10_tanh(v10,v00,x) v10 = (1.0/cosh(x)/cosh(x));
226 : : #define m00_acos(v00,x) v00 = acos(x);
227 : : #define m10_acos(v10,v00,x) v10 = (-1.0/sqrt(1-x*x));
228 : : #define m00_asin(v00,x) v00 = asin(x);
229 : : #define m10_asin(v10,v00,x) v10 = (+1.0/sqrt(1-x*x));
230 : : #define m00_atan(v00,x) v00 = atan(x);
231 : : #define m10_atan(v10,v00,x) v10 = (+1.0/(1+x*x));
232 : : #define m00_hypot(v00,x,y) v00 = sqrt((x)*(x)+(y)*(y));
233 : : #define m10_hypot(v10,v00,x,y) v10 = (x)/(v00);
234 : : #define m11_hypot(v11,v00,x,y) v11 = (y)/(v00);
235 : : #define m00_atan2(v00,x,y) v00 = atan2(x,y);
236 : : // TODO atan2 derivatives ?
237 : : #define m00_acosh(v00,x) v00 = acosh(x);
238 : : #define m10_acosh(v10,v00,x) v10 = (1.0/(sqrt(x-1)*sqrt(x+1)));
239 : : #define m00_asinh(v00,x) v00 = asinh(x);
240 : : #define m10_asinh(v10,v00,x) v10 = (1.0/(sqrt(x*x+1)));
241 : : #define m00_atanh(v00,x) v00 = atanh(x);
242 : : #define m10_atanh(v10,v00,x) v10 = (1.0/(1-x*x));
243 : :
244 : :
245 : : // standard functions LRM p.58
246 : : #define m00_logE(v00,x) v00 = log(x);
247 : : #define m10_logE(v10,v00,x) v10 = (1.0/x);
248 : : #define m00_log10(v00,x) v00 = log10(x);
249 : : #define m10_log10(v10,v00,x) v10 = (1.0/x/M_LN10);
250 : : #define m00_exp(v00,x) v00 = exp(x);
251 : : #define m10_exp(v10,v00,x) v10 = v00;
252 : : #define m00_sqrt(v00,x) v00 = sqrt(x);
253 : : #define m10_sqrt(v10,v00,x) v10 = (0.5/v00);
254 : : #define m00_min(v00,x,y) v00 = ((x)<(y))?(x):(y);
255 : : #define m10_min(v10,v00,x,y) v10 = ((x)<(y))?1.0:0.0;
256 : : #define m11_min(v11,v00,x,y) v11 = ((x)<(y))?0.0:1.0;
257 : : #define m00_max(v00,x,y) v00 = ((x)>(y))?(x):(y);
258 : : #define m10_max(v10,v00,x,y) v10 = ((x)>(y))?1.0:0.0;
259 : : #define m11_max(v11,v00,x,y) v11 = ((x)>(y))?0.0:1.0;
260 : : #define m00_pow(v00,x,y) v00 = pow(x,y);
261 : : #define m10_pow(v10,v00,x,y) v10 = (x==0.0)?0.0:(v00)*(y)/(x);
262 : : #define m11_pow(v11,v00,x,y) v11 = (x==0.0)?0.0:(log(x)*(v00));
263 : : #define m00_abs(v00,x) v00 = ((x)<(0)?(-(x)):(x));
264 : : #define m10_abs(v10,v00,x) v10 = (((x)>=0)?(+1.0):(-1.0));
265 : : #define m00_floor(v00,x) v00 = floor(x);
266 : : #define m10_floor(v10,v00,x) v10 = 1.0;
267 : :
268 : : #define m00_ceil(v00,x) v00 = ceil(x);
269 : : // TODO ceil derivative, needed?
270 : :
271 : : // analog operator, LRM p.61
272 : : #define m00_limexp(v00,x) v00 = ((x)<80.0?exp(x):exp(80.0)*(x-79.0));
273 : : #define m10_limexp(v10,v00,x) v10 = ((x)<80.0?(v00):exp(80.0));
274 : :
275 : : // analog kernel parameter system functions, LRM p.215
276 : : #define m00_vt(x) (kBoverQ*(x))
277 : : #define m10_vt(x) (kBoverQ)
278 : :
279 : : // extra functions (?)
280 : : #define m00_div(v00,v10,x,y) double v10=1/(y); double v00=(x)*v10;
281 : : #define m10_div(v10,v00,vv,x,y)
282 : : #define m11_div(v11,v00,vv,x,y) double v11 = -v00*vv;
283 : : #define m00_mult(v00,v10,v11,x,y) double v10=(x); double v11=(y); double v00=v10*v11;
284 : : #define m00_add(v00,x,y) double v00=(x)+(y);
285 : :
286 : : // second derivatives
287 : : #define m20_logE(v00) (-1.0/v00/v00)
288 : : #define m20_exp(v00) exp(v00)
289 : : #define m20_limexp(v00) ((v00)<80.0?exp(v00):0.0)
290 : : #define m20_sqrt(v00) (-0.25/(v00)/sqrt(v00))
291 : : #define m20_abs(v00) 0.0
292 : : #define m20_pow(x,y) ((y)*((y)-1.0)*pow(x,y)/(x)/(x))
293 : :
294 : :
295 : : // simulator specific definitions
296 : : #define _modelname "dmux4to16"
297 : : #define _instancename getName()
298 : : #define _circuit_temp (getPropertyDouble("Temp")+273.15)
299 : : #define _param_given(p) (isPropertyGiven(p)?1:0)
300 : :
301 : :
302 : : // $vt and $vt() functions
303 : : #define _vt_nom (kBoverQ*_circuit_temp)
304 : :
305 : : using namespace qucs::device;
306 : : using qucs::matrix;
307 : :
308 : : /* Device constructor. */
309 : 0 : dmux4to16::dmux4to16() : circuit (53)
310 : : {
311 : 0 : type = CIR_dmux4to16;
312 : 0 : }
313 : :
314 : : /* Initialization of model. */
315 : 0 : void dmux4to16::initModel (void)
316 : : {
317 : : // create internal nodes
318 : 0 : setInternalNode (Y0n1, "Y0n1");
319 : 0 : setInternalNode (Y0n2, "Y0n2");
320 : 0 : setInternalNode (Y1n1, "Y1n1");
321 : 0 : setInternalNode (Y1n2, "Y1n2");
322 : 0 : setInternalNode (Y2n1, "Y2n1");
323 : 0 : setInternalNode (Y2n2, "Y2n2");
324 : 0 : setInternalNode (Y3n1, "Y3n1");
325 : 0 : setInternalNode (Y3n2, "Y3n2");
326 : 0 : setInternalNode (Y4n1, "Y4n1");
327 : 0 : setInternalNode (Y4n2, "Y4n2");
328 : 0 : setInternalNode (Y5n1, "Y5n1");
329 : 0 : setInternalNode (Y5n2, "Y5n2");
330 : 0 : setInternalNode (Y6n1, "Y6n1");
331 : 0 : setInternalNode (Y6n2, "Y6n2");
332 : 0 : setInternalNode (Y7n1, "Y7n1");
333 : 0 : setInternalNode (Y7n2, "Y7n2");
334 : 0 : setInternalNode (Y8n1, "Y8n1");
335 : 0 : setInternalNode (Y8n2, "Y8n2");
336 : 0 : setInternalNode (Y9n1, "Y9n1");
337 : 0 : setInternalNode (Y9n2, "Y9n2");
338 : 0 : setInternalNode (Y10n1, "Y10n1");
339 : 0 : setInternalNode (Y10n2, "Y10n2");
340 : 0 : setInternalNode (Y11n1, "Y11n1");
341 : 0 : setInternalNode (Y11n2, "Y11n2");
342 : 0 : setInternalNode (Y12n1, "Y12n1");
343 : 0 : setInternalNode (Y12n2, "Y12n2");
344 : 0 : setInternalNode (Y13n1, "Y13n1");
345 : 0 : setInternalNode (Y13n2, "Y13n2");
346 : 0 : setInternalNode (Y14n1, "Y14n1");
347 : 0 : setInternalNode (Y14n2, "Y14n2");
348 : 0 : setInternalNode (Y15n1, "Y15n1");
349 : 0 : setInternalNode (Y15n2, "Y15n2");
350 : :
351 : : // get device model parameters
352 : 0 : loadVariables ();
353 : : // evaluate global model equations
354 : 0 : initializeModel ();
355 : : // evaluate initial step equations
356 : 0 : initialStep ();
357 : : // evaluate global instance equations
358 : 0 : initializeInstance ();
359 : 0 : }
360 : :
361 : : /* Initialization of DC analysis. */
362 : 0 : void dmux4to16::initDC (void)
363 : : {
364 : 0 : allocMatrixMNA ();
365 : 0 : initModel ();
366 : 0 : pol = 1;
367 : 0 : restartDC ();
368 : 0 : doAC = 1;
369 : 0 : doTR = 0;
370 : 0 : doHB = 0;
371 : 0 : }
372 : :
373 : : /* Run when DC is restarted (fallback algorithms). */
374 : 0 : void dmux4to16::restartDC (void)
375 : : {
376 : 0 : }
377 : :
378 : : /* Initialize Verilog-AMS code. */
379 : 0 : void dmux4to16::initVerilog (void)
380 : : {
381 : : // initialization of noise variables
382 : :
383 : : int i1, i2, i3, i4;
384 : :
385 : : // zero charges
386 [ # # ]: 0 : for (i1 = 0; i1 < 53; i1++) {
387 [ # # ]: 0 : for (i2 = 0; i2 < 53; i2++) {
388 : 0 : _charges[i1][i2] = 0.0;
389 : : } }
390 : :
391 : : // zero capacitances
392 [ # # ]: 0 : for (i1 = 0; i1 < 53; i1++) {
393 [ # # ]: 0 : for (i2 = 0; i2 < 53; i2++) {
394 [ # # ]: 0 : for (i3 = 0; i3 < 53; i3++) {
395 [ # # ]: 0 : for (i4 = 0; i4 < 53; i4++) {
396 : 0 : _caps[i1][i2][i3][i4] = 0.0;
397 : : } } } }
398 : :
399 : : // zero right hand side, static and dynamic jacobian
400 [ # # ]: 0 : for (i1 = 0; i1 < 53; i1++) {
401 : 0 : _rhs[i1] = 0.0;
402 : 0 : _qhs[i1] = 0.0;
403 : 0 : _chs[i1] = 0.0;
404 : 0 : _ghs[i1] = 0.0;
405 [ # # ]: 0 : for (i2 = 0; i2 < 53; i2++) {
406 : 0 : _jstat[i1][i2] = 0.0;
407 : 0 : _jdyna[i1][i2] = 0.0;
408 : : }
409 : : }
410 : 0 : }
411 : :
412 : : /* Load device model input parameters. */
413 : 0 : void dmux4to16::loadVariables (void)
414 : : {
415 : 0 : TR = getPropertyDouble ("TR");
416 : 0 : Delay = getPropertyDouble ("Delay");
417 : 0 : }
418 : :
419 : : /* #define's for translated code */
420 : : #undef _DDT
421 : : #define _DDT(q) q
422 : : #define _DYNAMIC
423 : : #define _DERIVATE
424 : : #define _DDX
425 : : #define _DERIVATEFORDDX
426 : :
427 : : /* Evaluate Verilog-AMS equations in model initialization. */
428 : 0 : void dmux4to16::initializeModel (void)
429 : : {
430 : : #if defined(_DYNAMIC)
431 : : #endif
432 : : {
433 : 0 : Rd=1e3;
434 : : #if defined(_DYNAMIC)
435 : 0 : Cd=((Delay*1.43)/Rd);
436 : : #endif
437 : : }
438 : 0 : }
439 : :
440 : : /* Evaluate Verilog-AMS equations in instance initialization. */
441 : 0 : void dmux4to16::initializeInstance (void)
442 : : {
443 : 0 : }
444 : :
445 : : /* Evaluate Verilog-AMS equations in initial step. */
446 : 0 : void dmux4to16::initialStep (void)
447 : : {
448 : 0 : }
449 : :
450 : : /* Evaluate Verilog-AMS equations in final step. */
451 : 0 : void dmux4to16::finalStep (void)
452 : : {
453 : 0 : }
454 : :
455 : : /* Evaluate Verilog-AMS equations in analog block. */
456 : 0 : void dmux4to16::calcVerilog (void)
457 : : {
458 : :
459 : : /* ----------------- evaluate verilog analog equations -------------------- */
460 : : double IY15;
461 : : #if defined(_DERIVATE)
462 : : double IY15_VEN_GND;
463 : : double IY15_VD_GND;
464 : : double IY15_VC_GND;
465 : : double IY15_VB_GND;
466 : : double IY15_VA_GND;
467 : : #endif
468 : : double IY14;
469 : : #if defined(_DERIVATE)
470 : : double IY14_VEN_GND;
471 : : double IY14_VD_GND;
472 : : double IY14_VC_GND;
473 : : double IY14_VB_GND;
474 : : double IY14_VA_GND;
475 : : #endif
476 : : double IY13;
477 : : #if defined(_DERIVATE)
478 : : double IY13_VEN_GND;
479 : : double IY13_VD_GND;
480 : : double IY13_VC_GND;
481 : : double IY13_VB_GND;
482 : : double IY13_VA_GND;
483 : : #endif
484 : : double IY12;
485 : : #if defined(_DERIVATE)
486 : : double IY12_VEN_GND;
487 : : double IY12_VD_GND;
488 : : double IY12_VC_GND;
489 : : double IY12_VB_GND;
490 : : double IY12_VA_GND;
491 : : #endif
492 : : double IY11;
493 : : #if defined(_DERIVATE)
494 : : double IY11_VEN_GND;
495 : : double IY11_VD_GND;
496 : : double IY11_VC_GND;
497 : : double IY11_VB_GND;
498 : : double IY11_VA_GND;
499 : : #endif
500 : : double IY10;
501 : : #if defined(_DERIVATE)
502 : : double IY10_VEN_GND;
503 : : double IY10_VD_GND;
504 : : double IY10_VC_GND;
505 : : double IY10_VB_GND;
506 : : double IY10_VA_GND;
507 : : #endif
508 : : double IY9;
509 : : #if defined(_DERIVATE)
510 : : double IY9_VEN_GND;
511 : : double IY9_VD_GND;
512 : : double IY9_VC_GND;
513 : : double IY9_VB_GND;
514 : : double IY9_VA_GND;
515 : : #endif
516 : : double IY8;
517 : : #if defined(_DERIVATE)
518 : : double IY8_VEN_GND;
519 : : double IY8_VD_GND;
520 : : double IY8_VC_GND;
521 : : double IY8_VB_GND;
522 : : double IY8_VA_GND;
523 : : #endif
524 : : double IY7;
525 : : #if defined(_DERIVATE)
526 : : double IY7_VEN_GND;
527 : : double IY7_VD_GND;
528 : : double IY7_VC_GND;
529 : : double IY7_VB_GND;
530 : : double IY7_VA_GND;
531 : : #endif
532 : : double IY6;
533 : : #if defined(_DERIVATE)
534 : : double IY6_VEN_GND;
535 : : double IY6_VD_GND;
536 : : double IY6_VC_GND;
537 : : double IY6_VB_GND;
538 : : double IY6_VA_GND;
539 : : #endif
540 : : double IY5;
541 : : #if defined(_DERIVATE)
542 : : double IY5_VEN_GND;
543 : : double IY5_VD_GND;
544 : : double IY5_VC_GND;
545 : : double IY5_VB_GND;
546 : : double IY5_VA_GND;
547 : : #endif
548 : : double IY4;
549 : : #if defined(_DERIVATE)
550 : : double IY4_VEN_GND;
551 : : double IY4_VD_GND;
552 : : double IY4_VC_GND;
553 : : double IY4_VB_GND;
554 : : double IY4_VA_GND;
555 : : #endif
556 : : double IY3;
557 : : #if defined(_DERIVATE)
558 : : double IY3_VEN_GND;
559 : : double IY3_VD_GND;
560 : : double IY3_VC_GND;
561 : : double IY3_VB_GND;
562 : : double IY3_VA_GND;
563 : : #endif
564 : : double IY2;
565 : : #if defined(_DERIVATE)
566 : : double IY2_VEN_GND;
567 : : double IY2_VD_GND;
568 : : double IY2_VC_GND;
569 : : double IY2_VB_GND;
570 : : double IY2_VA_GND;
571 : : #endif
572 : : double IY1;
573 : : #if defined(_DERIVATE)
574 : : double IY1_VEN_GND;
575 : : double IY1_VD_GND;
576 : : double IY1_VC_GND;
577 : : double IY1_VB_GND;
578 : : double IY1_VA_GND;
579 : : #endif
580 : : double IY0;
581 : : #if defined(_DERIVATE)
582 : : double IY0_VEN_GND;
583 : : double IY0_VD_GND;
584 : : double IY0_VC_GND;
585 : : double IY0_VB_GND;
586 : : double IY0_VA_GND;
587 : : #endif
588 : : double VDI;
589 : : #if defined(_DERIVATE)
590 : : double VDI_VD_GND;
591 : : #endif
592 : : double VCI;
593 : : #if defined(_DERIVATE)
594 : : double VCI_VC_GND;
595 : : #endif
596 : : double VBI;
597 : : #if defined(_DERIVATE)
598 : : double VBI_VB_GND;
599 : : #endif
600 : : double VAI;
601 : : #if defined(_DERIVATE)
602 : : double VAI_VA_GND;
603 : : #endif
604 : : double VENI;
605 : : #if defined(_DERIVATE)
606 : : double VENI_VEN_GND;
607 : : #endif
608 : : #if defined(_DERIVATE)
609 : 0 : VENI_VEN_GND=(-1.0);
610 : : #endif
611 : 0 : VENI=(1-NP(EN));
612 : : #if defined(_DERIVATE)
613 : 0 : VAI_VA_GND=(-1.0);
614 : : #endif
615 : 0 : VAI=(1-NP(A));
616 : : #if defined(_DERIVATE)
617 : 0 : VBI_VB_GND=(-1.0);
618 : : #endif
619 : 0 : VBI=(1-NP(B));
620 : : #if defined(_DERIVATE)
621 : 0 : VCI_VC_GND=(-1.0);
622 : : #endif
623 : 0 : VCI=(1-NP(C));
624 : : #if defined(_DERIVATE)
625 : 0 : VDI_VD_GND=(-1.0);
626 : : #endif
627 : 0 : VDI=(1-NP(D));
628 : : #if defined(_DERIVATE)
629 : 0 : IY0_VEN_GND=VENI_VEN_GND*VDI*VCI*VBI*VAI;
630 : 0 : IY0_VD_GND=(VENI*VDI_VD_GND)*VCI*VBI*VAI;
631 : 0 : IY0_VC_GND=((VENI*VDI)*VCI_VC_GND)*VBI*VAI;
632 : 0 : IY0_VB_GND=(((VENI*VDI)*VCI)*VBI_VB_GND)*VAI;
633 : 0 : IY0_VA_GND=((((VENI*VDI)*VCI)*VBI)*VAI_VA_GND);
634 : : #endif
635 : 0 : IY0=((((VENI*VDI)*VCI)*VBI)*VAI);
636 : : {
637 : 0 : double m00_tanh(d00_tanh0,(TR*(IY0-0.5)))
638 : : #if defined(_DERIVATE)
639 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY0-0.5)))
640 : : #endif
641 : 0 : _load_static_residual1(Y0n1,((-0.5)*(1+d00_tanh0)));
642 : : #if defined(_DERIVATE)
643 [ # # ]: 0 : _load_static_jacobian1(Y0n1,A,((-0.5)*(TR*IY0_VA_GND)*d10_tanh0));
644 [ # # ]: 0 : _load_static_jacobian1(Y0n1,B,((-0.5)*(TR*IY0_VB_GND)*d10_tanh0));
645 [ # # ]: 0 : _load_static_jacobian1(Y0n1,C,((-0.5)*(TR*IY0_VC_GND)*d10_tanh0));
646 [ # # ]: 0 : _load_static_jacobian1(Y0n1,D,((-0.5)*(TR*IY0_VD_GND)*d10_tanh0));
647 [ # # ]: 0 : _load_static_jacobian1(Y0n1,EN,((-0.5)*(TR*IY0_VEN_GND)*d10_tanh0));
648 : : #endif
649 : : }
650 : 0 : _load_static_residual1(Y0n1,NP(Y0n1));
651 : : #if defined(_DERIVATE)
652 [ # # ]: 0 : _load_static_jacobian1(Y0n1,Y0n1,1.0);
653 : : #endif
654 [ # # ][ # # ]: 0 : _load_static_residual2(Y0n1,Y0n2,(BP(Y0n1,Y0n2)/Rd));
655 : : #if defined(_DERIVATE)
656 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y0n1,Y0n2,Y0n1,Y0n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
657 : : #endif
658 : : #if defined(_DYNAMIC)
659 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y0n2,_DDT((Cd*NP(Y0n2))));
660 : : #if defined(_DERIVATE)
661 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y0n2,Y0n2,(Cd));
[ # # ]
662 : : #endif
663 : : #endif
664 : 0 : _load_static_residual1(Y0,(-NP(Y0n2)));
665 : : #if defined(_DERIVATE)
666 [ # # ]: 0 : _load_static_jacobian1(Y0,Y0n2,(-1.0));
667 : : #endif
668 : 0 : _load_static_residual1(Y0,NP(Y0));
669 : : #if defined(_DERIVATE)
670 [ # # ]: 0 : _load_static_jacobian1(Y0,Y0,1.0);
671 : : #endif
672 : : #if defined(_DERIVATE)
673 : 0 : IY1_VEN_GND=VENI_VEN_GND*VDI*VCI*VBI*NP(A);
674 : 0 : IY1_VD_GND=(VENI*VDI_VD_GND)*VCI*VBI*NP(A);
675 : 0 : IY1_VC_GND=((VENI*VDI)*VCI_VC_GND)*VBI*NP(A);
676 : 0 : IY1_VB_GND=(((VENI*VDI)*VCI)*VBI_VB_GND)*NP(A);
677 : 0 : IY1_VA_GND=((((VENI*VDI)*VCI)*VBI));
678 : : #endif
679 : 0 : IY1=((((VENI*VDI)*VCI)*VBI)*NP(A));
680 : : {
681 : 0 : double m00_tanh(d00_tanh0,(TR*(IY1-0.5)))
682 : : #if defined(_DERIVATE)
683 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY1-0.5)))
684 : : #endif
685 : 0 : _load_static_residual1(Y1n1,((-0.5)*(1+d00_tanh0)));
686 : : #if defined(_DERIVATE)
687 [ # # ]: 0 : _load_static_jacobian1(Y1n1,A,((-0.5)*(TR*IY1_VA_GND)*d10_tanh0));
688 [ # # ]: 0 : _load_static_jacobian1(Y1n1,B,((-0.5)*(TR*IY1_VB_GND)*d10_tanh0));
689 [ # # ]: 0 : _load_static_jacobian1(Y1n1,C,((-0.5)*(TR*IY1_VC_GND)*d10_tanh0));
690 [ # # ]: 0 : _load_static_jacobian1(Y1n1,D,((-0.5)*(TR*IY1_VD_GND)*d10_tanh0));
691 [ # # ]: 0 : _load_static_jacobian1(Y1n1,EN,((-0.5)*(TR*IY1_VEN_GND)*d10_tanh0));
692 : : #endif
693 : : }
694 : 0 : _load_static_residual1(Y1n1,NP(Y1n1));
695 : : #if defined(_DERIVATE)
696 [ # # ]: 0 : _load_static_jacobian1(Y1n1,Y1n1,1.0);
697 : : #endif
698 [ # # ][ # # ]: 0 : _load_static_residual2(Y1n1,Y1n2,(BP(Y1n1,Y1n2)/Rd));
699 : : #if defined(_DERIVATE)
700 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y1n1,Y1n2,Y1n1,Y1n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
701 : : #endif
702 : : #if defined(_DYNAMIC)
703 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y1n2,_DDT((Cd*NP(Y1n2))));
704 : : #if defined(_DERIVATE)
705 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y1n2,Y1n2,(Cd));
[ # # ]
706 : : #endif
707 : : #endif
708 : 0 : _load_static_residual1(Y1,(-NP(Y1n2)));
709 : : #if defined(_DERIVATE)
710 [ # # ]: 0 : _load_static_jacobian1(Y1,Y1n2,(-1.0));
711 : : #endif
712 : 0 : _load_static_residual1(Y1,NP(Y1));
713 : : #if defined(_DERIVATE)
714 [ # # ]: 0 : _load_static_jacobian1(Y1,Y1,1.0);
715 : : #endif
716 : : #if defined(_DERIVATE)
717 : 0 : IY2_VEN_GND=VENI_VEN_GND*VDI*VCI*NP(B)*VAI;
718 : 0 : IY2_VD_GND=(VENI*VDI_VD_GND)*VCI*NP(B)*VAI;
719 : 0 : IY2_VC_GND=((VENI*VDI)*VCI_VC_GND)*NP(B)*VAI;
720 : 0 : IY2_VB_GND=(((VENI*VDI)*VCI))*VAI;
721 : 0 : IY2_VA_GND=((((VENI*VDI)*VCI)*NP(B))*VAI_VA_GND);
722 : : #endif
723 : 0 : IY2=((((VENI*VDI)*VCI)*NP(B))*VAI);
724 : : {
725 : 0 : double m00_tanh(d00_tanh0,(TR*(IY2-0.5)))
726 : : #if defined(_DERIVATE)
727 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY2-0.5)))
728 : : #endif
729 : 0 : _load_static_residual1(Y2n1,((-0.5)*(1+d00_tanh0)));
730 : : #if defined(_DERIVATE)
731 [ # # ]: 0 : _load_static_jacobian1(Y2n1,A,((-0.5)*(TR*IY2_VA_GND)*d10_tanh0));
732 [ # # ]: 0 : _load_static_jacobian1(Y2n1,B,((-0.5)*(TR*IY2_VB_GND)*d10_tanh0));
733 [ # # ]: 0 : _load_static_jacobian1(Y2n1,C,((-0.5)*(TR*IY2_VC_GND)*d10_tanh0));
734 [ # # ]: 0 : _load_static_jacobian1(Y2n1,D,((-0.5)*(TR*IY2_VD_GND)*d10_tanh0));
735 [ # # ]: 0 : _load_static_jacobian1(Y2n1,EN,((-0.5)*(TR*IY2_VEN_GND)*d10_tanh0));
736 : : #endif
737 : : }
738 : 0 : _load_static_residual1(Y2n1,NP(Y2n1));
739 : : #if defined(_DERIVATE)
740 [ # # ]: 0 : _load_static_jacobian1(Y2n1,Y2n1,1.0);
741 : : #endif
742 [ # # ][ # # ]: 0 : _load_static_residual2(Y2n1,Y2n2,(BP(Y2n1,Y2n2)/Rd));
743 : : #if defined(_DERIVATE)
744 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y2n1,Y2n2,Y2n1,Y2n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
745 : : #endif
746 : : #if defined(_DYNAMIC)
747 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y2n2,_DDT((Cd*NP(Y2n2))));
748 : : #if defined(_DERIVATE)
749 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y2n2,Y2n2,(Cd));
[ # # ]
750 : : #endif
751 : : #endif
752 : 0 : _load_static_residual1(Y2,(-NP(Y2n2)));
753 : : #if defined(_DERIVATE)
754 [ # # ]: 0 : _load_static_jacobian1(Y2,Y2n2,(-1.0));
755 : : #endif
756 : 0 : _load_static_residual1(Y2,NP(Y2));
757 : : #if defined(_DERIVATE)
758 [ # # ]: 0 : _load_static_jacobian1(Y2,Y2,1.0);
759 : : #endif
760 : : #if defined(_DERIVATE)
761 [ # # ]: 0 : IY3_VEN_GND=VENI_VEN_GND*VDI*VCI*NP(B)*NP(A);
762 [ # # ]: 0 : IY3_VD_GND=(VENI*VDI_VD_GND)*VCI*NP(B)*NP(A);
763 [ # # ]: 0 : IY3_VC_GND=((VENI*VDI)*VCI_VC_GND)*NP(B)*NP(A);
764 : 0 : IY3_VB_GND=(((VENI*VDI)*VCI))*NP(A);
765 : 0 : IY3_VA_GND=((((VENI*VDI)*VCI)*NP(B)));
766 : : #endif
767 [ # # ]: 0 : IY3=((((VENI*VDI)*VCI)*NP(B))*NP(A));
768 : : {
769 : 0 : double m00_tanh(d00_tanh0,(TR*(IY3-0.5)))
770 : : #if defined(_DERIVATE)
771 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY3-0.5)))
772 : : #endif
773 : 0 : _load_static_residual1(Y3n1,((-0.5)*(1+d00_tanh0)));
774 : : #if defined(_DERIVATE)
775 [ # # ]: 0 : _load_static_jacobian1(Y3n1,A,((-0.5)*(TR*IY3_VA_GND)*d10_tanh0));
776 [ # # ]: 0 : _load_static_jacobian1(Y3n1,B,((-0.5)*(TR*IY3_VB_GND)*d10_tanh0));
777 [ # # ]: 0 : _load_static_jacobian1(Y3n1,C,((-0.5)*(TR*IY3_VC_GND)*d10_tanh0));
778 [ # # ]: 0 : _load_static_jacobian1(Y3n1,D,((-0.5)*(TR*IY3_VD_GND)*d10_tanh0));
779 [ # # ]: 0 : _load_static_jacobian1(Y3n1,EN,((-0.5)*(TR*IY3_VEN_GND)*d10_tanh0));
780 : : #endif
781 : : }
782 : 0 : _load_static_residual1(Y3n1,NP(Y3n1));
783 : : #if defined(_DERIVATE)
784 [ # # ]: 0 : _load_static_jacobian1(Y3n1,Y3n1,1.0);
785 : : #endif
786 [ # # ][ # # ]: 0 : _load_static_residual2(Y3n1,Y3n2,(BP(Y3n1,Y3n2)/Rd));
787 : : #if defined(_DERIVATE)
788 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y3n1,Y3n2,Y3n1,Y3n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
789 : : #endif
790 : : #if defined(_DYNAMIC)
791 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y3n2,_DDT((Cd*NP(Y3n2))));
792 : : #if defined(_DERIVATE)
793 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y3n2,Y3n2,(Cd));
[ # # ]
794 : : #endif
795 : : #endif
796 : 0 : _load_static_residual1(Y3,(-NP(Y3n2)));
797 : : #if defined(_DERIVATE)
798 [ # # ]: 0 : _load_static_jacobian1(Y3,Y3n2,(-1.0));
799 : : #endif
800 : 0 : _load_static_residual1(Y3,NP(Y3));
801 : : #if defined(_DERIVATE)
802 [ # # ]: 0 : _load_static_jacobian1(Y3,Y3,1.0);
803 : : #endif
804 : : #if defined(_DERIVATE)
805 : 0 : IY4_VEN_GND=VENI_VEN_GND*VDI*NP(C)*VBI*VAI;
806 : 0 : IY4_VD_GND=(VENI*VDI_VD_GND)*NP(C)*VBI*VAI;
807 : 0 : IY4_VC_GND=((VENI*VDI))*VBI*VAI;
808 : 0 : IY4_VB_GND=(((VENI*VDI)*NP(C))*VBI_VB_GND)*VAI;
809 : 0 : IY4_VA_GND=((((VENI*VDI)*NP(C))*VBI)*VAI_VA_GND);
810 : : #endif
811 : 0 : IY4=((((VENI*VDI)*NP(C))*VBI)*VAI);
812 : : {
813 : 0 : double m00_tanh(d00_tanh0,(TR*(IY4-0.5)))
814 : : #if defined(_DERIVATE)
815 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY4-0.5)))
816 : : #endif
817 : 0 : _load_static_residual1(Y4n1,((-0.5)*(1+d00_tanh0)));
818 : : #if defined(_DERIVATE)
819 [ # # ]: 0 : _load_static_jacobian1(Y4n1,A,((-0.5)*(TR*IY4_VA_GND)*d10_tanh0));
820 [ # # ]: 0 : _load_static_jacobian1(Y4n1,B,((-0.5)*(TR*IY4_VB_GND)*d10_tanh0));
821 [ # # ]: 0 : _load_static_jacobian1(Y4n1,C,((-0.5)*(TR*IY4_VC_GND)*d10_tanh0));
822 [ # # ]: 0 : _load_static_jacobian1(Y4n1,D,((-0.5)*(TR*IY4_VD_GND)*d10_tanh0));
823 [ # # ]: 0 : _load_static_jacobian1(Y4n1,EN,((-0.5)*(TR*IY4_VEN_GND)*d10_tanh0));
824 : : #endif
825 : : }
826 : 0 : _load_static_residual1(Y4n1,NP(Y4n1));
827 : : #if defined(_DERIVATE)
828 [ # # ]: 0 : _load_static_jacobian1(Y4n1,Y4n1,1.0);
829 : : #endif
830 [ # # ][ # # ]: 0 : _load_static_residual2(Y4n1,Y4n2,(BP(Y4n1,Y4n2)/Rd));
831 : : #if defined(_DERIVATE)
832 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y4n1,Y4n2,Y4n1,Y4n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
833 : : #endif
834 : : #if defined(_DYNAMIC)
835 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y4n2,_DDT((Cd*NP(Y4n2))));
836 : : #if defined(_DERIVATE)
837 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y4n2,Y4n2,(Cd));
[ # # ]
838 : : #endif
839 : : #endif
840 : 0 : _load_static_residual1(Y4,(-NP(Y4n2)));
841 : : #if defined(_DERIVATE)
842 [ # # ]: 0 : _load_static_jacobian1(Y4,Y4n2,(-1.0));
843 : : #endif
844 : 0 : _load_static_residual1(Y4,NP(Y4));
845 : : #if defined(_DERIVATE)
846 [ # # ]: 0 : _load_static_jacobian1(Y4,Y4,1.0);
847 : : #endif
848 : : #if defined(_DERIVATE)
849 [ # # ]: 0 : IY5_VEN_GND=VENI_VEN_GND*VDI*NP(C)*VBI*NP(A);
850 [ # # ]: 0 : IY5_VD_GND=(VENI*VDI_VD_GND)*NP(C)*VBI*NP(A);
851 : 0 : IY5_VC_GND=((VENI*VDI))*VBI*NP(A);
852 [ # # ]: 0 : IY5_VB_GND=(((VENI*VDI)*NP(C))*VBI_VB_GND)*NP(A);
853 : 0 : IY5_VA_GND=((((VENI*VDI)*NP(C))*VBI));
854 : : #endif
855 [ # # ]: 0 : IY5=((((VENI*VDI)*NP(C))*VBI)*NP(A));
856 : : {
857 : 0 : double m00_tanh(d00_tanh0,(TR*(IY5-0.5)))
858 : : #if defined(_DERIVATE)
859 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY5-0.5)))
860 : : #endif
861 : 0 : _load_static_residual1(Y5n1,((-0.5)*(1+d00_tanh0)));
862 : : #if defined(_DERIVATE)
863 [ # # ]: 0 : _load_static_jacobian1(Y5n1,A,((-0.5)*(TR*IY5_VA_GND)*d10_tanh0));
864 [ # # ]: 0 : _load_static_jacobian1(Y5n1,B,((-0.5)*(TR*IY5_VB_GND)*d10_tanh0));
865 [ # # ]: 0 : _load_static_jacobian1(Y5n1,C,((-0.5)*(TR*IY5_VC_GND)*d10_tanh0));
866 [ # # ]: 0 : _load_static_jacobian1(Y5n1,D,((-0.5)*(TR*IY5_VD_GND)*d10_tanh0));
867 [ # # ]: 0 : _load_static_jacobian1(Y5n1,EN,((-0.5)*(TR*IY5_VEN_GND)*d10_tanh0));
868 : : #endif
869 : : }
870 : 0 : _load_static_residual1(Y5n1,NP(Y5n1));
871 : : #if defined(_DERIVATE)
872 [ # # ]: 0 : _load_static_jacobian1(Y5n1,Y5n1,1.0);
873 : : #endif
874 [ # # ][ # # ]: 0 : _load_static_residual2(Y5n1,Y5n2,(BP(Y5n1,Y5n2)/Rd));
875 : : #if defined(_DERIVATE)
876 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y5n1,Y5n2,Y5n1,Y5n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
877 : : #endif
878 : : #if defined(_DYNAMIC)
879 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y5n2,_DDT((Cd*NP(Y5n2))));
880 : : #if defined(_DERIVATE)
881 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y5n2,Y5n2,(Cd));
[ # # ]
882 : : #endif
883 : : #endif
884 : 0 : _load_static_residual1(Y5,(-NP(Y5n2)));
885 : : #if defined(_DERIVATE)
886 [ # # ]: 0 : _load_static_jacobian1(Y5,Y5n2,(-1.0));
887 : : #endif
888 : 0 : _load_static_residual1(Y5,NP(Y5));
889 : : #if defined(_DERIVATE)
890 [ # # ]: 0 : _load_static_jacobian1(Y5,Y5,1.0);
891 : : #endif
892 : : #if defined(_DERIVATE)
893 [ # # ]: 0 : IY6_VEN_GND=VENI_VEN_GND*VDI*NP(C)*NP(B)*VAI;
894 [ # # ]: 0 : IY6_VD_GND=(VENI*VDI_VD_GND)*NP(C)*NP(B)*VAI;
895 : 0 : IY6_VC_GND=((VENI*VDI))*NP(B)*VAI;
896 : 0 : IY6_VB_GND=(((VENI*VDI)*NP(C)))*VAI;
897 [ # # ]: 0 : IY6_VA_GND=((((VENI*VDI)*NP(C))*NP(B))*VAI_VA_GND);
898 : : #endif
899 [ # # ]: 0 : IY6=((((VENI*VDI)*NP(C))*NP(B))*VAI);
900 : : {
901 : 0 : double m00_tanh(d00_tanh0,(TR*(IY6-0.5)))
902 : : #if defined(_DERIVATE)
903 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY6-0.5)))
904 : : #endif
905 : 0 : _load_static_residual1(Y6n1,((-0.5)*(1+d00_tanh0)));
906 : : #if defined(_DERIVATE)
907 [ # # ]: 0 : _load_static_jacobian1(Y6n1,A,((-0.5)*(TR*IY6_VA_GND)*d10_tanh0));
908 [ # # ]: 0 : _load_static_jacobian1(Y6n1,B,((-0.5)*(TR*IY6_VB_GND)*d10_tanh0));
909 [ # # ]: 0 : _load_static_jacobian1(Y6n1,C,((-0.5)*(TR*IY6_VC_GND)*d10_tanh0));
910 [ # # ]: 0 : _load_static_jacobian1(Y6n1,D,((-0.5)*(TR*IY6_VD_GND)*d10_tanh0));
911 [ # # ]: 0 : _load_static_jacobian1(Y6n1,EN,((-0.5)*(TR*IY6_VEN_GND)*d10_tanh0));
912 : : #endif
913 : : }
914 : 0 : _load_static_residual1(Y6n1,NP(Y6n1));
915 : : #if defined(_DERIVATE)
916 [ # # ]: 0 : _load_static_jacobian1(Y6n1,Y6n1,1.0);
917 : : #endif
918 [ # # ][ # # ]: 0 : _load_static_residual2(Y6n1,Y6n2,(BP(Y6n1,Y6n2)/Rd));
919 : : #if defined(_DERIVATE)
920 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y6n1,Y6n2,Y6n1,Y6n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
921 : : #endif
922 : : #if defined(_DYNAMIC)
923 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y6n2,_DDT((Cd*NP(Y6n2))));
924 : : #if defined(_DERIVATE)
925 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y6n2,Y6n2,(Cd));
[ # # ]
926 : : #endif
927 : : #endif
928 : 0 : _load_static_residual1(Y6,(-NP(Y6n2)));
929 : : #if defined(_DERIVATE)
930 [ # # ]: 0 : _load_static_jacobian1(Y6,Y6n2,(-1.0));
931 : : #endif
932 : 0 : _load_static_residual1(Y6,NP(Y6));
933 : : #if defined(_DERIVATE)
934 [ # # ]: 0 : _load_static_jacobian1(Y6,Y6,1.0);
935 : : #endif
936 : : #if defined(_DERIVATE)
937 [ # # ][ # # ]: 0 : IY7_VEN_GND=VENI_VEN_GND*VDI*NP(C)*NP(B)*NP(A);
938 [ # # ][ # # ]: 0 : IY7_VD_GND=(VENI*VDI_VD_GND)*NP(C)*NP(B)*NP(A);
939 [ # # ]: 0 : IY7_VC_GND=((VENI*VDI))*NP(B)*NP(A);
940 [ # # ]: 0 : IY7_VB_GND=(((VENI*VDI)*NP(C)))*NP(A);
941 [ # # ]: 0 : IY7_VA_GND=((((VENI*VDI)*NP(C))*NP(B)));
942 : : #endif
943 [ # # ][ # # ]: 0 : IY7=((((VENI*VDI)*NP(C))*NP(B))*NP(A));
944 : : {
945 : 0 : double m00_tanh(d00_tanh0,(TR*(IY7-0.5)))
946 : : #if defined(_DERIVATE)
947 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY7-0.5)))
948 : : #endif
949 : 0 : _load_static_residual1(Y7n1,((-0.5)*(1+d00_tanh0)));
950 : : #if defined(_DERIVATE)
951 [ # # ]: 0 : _load_static_jacobian1(Y7n1,A,((-0.5)*(TR*IY7_VA_GND)*d10_tanh0));
952 [ # # ]: 0 : _load_static_jacobian1(Y7n1,B,((-0.5)*(TR*IY7_VB_GND)*d10_tanh0));
953 [ # # ]: 0 : _load_static_jacobian1(Y7n1,C,((-0.5)*(TR*IY7_VC_GND)*d10_tanh0));
954 [ # # ]: 0 : _load_static_jacobian1(Y7n1,D,((-0.5)*(TR*IY7_VD_GND)*d10_tanh0));
955 [ # # ]: 0 : _load_static_jacobian1(Y7n1,EN,((-0.5)*(TR*IY7_VEN_GND)*d10_tanh0));
956 : : #endif
957 : : }
958 : 0 : _load_static_residual1(Y7n1,NP(Y7n1));
959 : : #if defined(_DERIVATE)
960 [ # # ]: 0 : _load_static_jacobian1(Y7n1,Y7n1,1.0);
961 : : #endif
962 [ # # ][ # # ]: 0 : _load_static_residual2(Y7n1,Y7n2,(BP(Y7n1,Y7n2)/Rd));
963 : : #if defined(_DERIVATE)
964 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y7n1,Y7n2,Y7n1,Y7n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
965 : : #endif
966 : : #if defined(_DYNAMIC)
967 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y7n2,_DDT((Cd*NP(Y7n2))));
968 : : #if defined(_DERIVATE)
969 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y7n2,Y7n2,(Cd));
[ # # ]
970 : : #endif
971 : : #endif
972 : 0 : _load_static_residual1(Y7,(-NP(Y7n2)));
973 : : #if defined(_DERIVATE)
974 [ # # ]: 0 : _load_static_jacobian1(Y7,Y7n2,(-1.0));
975 : : #endif
976 : 0 : _load_static_residual1(Y7,NP(Y7));
977 : : #if defined(_DERIVATE)
978 [ # # ]: 0 : _load_static_jacobian1(Y7,Y7,1.0);
979 : : #endif
980 : : #if defined(_DERIVATE)
981 : 0 : IY8_VEN_GND=VENI_VEN_GND*NP(D)*VCI*VBI*VAI;
982 : 0 : IY8_VD_GND=(VENI)*VCI*VBI*VAI;
983 : 0 : IY8_VC_GND=((VENI*NP(D))*VCI_VC_GND)*VBI*VAI;
984 : 0 : IY8_VB_GND=(((VENI*NP(D))*VCI)*VBI_VB_GND)*VAI;
985 : 0 : IY8_VA_GND=((((VENI*NP(D))*VCI)*VBI)*VAI_VA_GND);
986 : : #endif
987 : 0 : IY8=((((VENI*NP(D))*VCI)*VBI)*VAI);
988 : : {
989 : 0 : double m00_tanh(d00_tanh0,(TR*(IY8-0.5)))
990 : : #if defined(_DERIVATE)
991 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY8-0.5)))
992 : : #endif
993 : 0 : _load_static_residual1(Y8n1,((-0.5)*(1+d00_tanh0)));
994 : : #if defined(_DERIVATE)
995 [ # # ]: 0 : _load_static_jacobian1(Y8n1,A,((-0.5)*(TR*IY8_VA_GND)*d10_tanh0));
996 [ # # ]: 0 : _load_static_jacobian1(Y8n1,B,((-0.5)*(TR*IY8_VB_GND)*d10_tanh0));
997 [ # # ]: 0 : _load_static_jacobian1(Y8n1,C,((-0.5)*(TR*IY8_VC_GND)*d10_tanh0));
998 [ # # ]: 0 : _load_static_jacobian1(Y8n1,D,((-0.5)*(TR*IY8_VD_GND)*d10_tanh0));
999 [ # # ]: 0 : _load_static_jacobian1(Y8n1,EN,((-0.5)*(TR*IY8_VEN_GND)*d10_tanh0));
1000 : : #endif
1001 : : }
1002 : 0 : _load_static_residual1(Y8n1,NP(Y8n1));
1003 : : #if defined(_DERIVATE)
1004 [ # # ]: 0 : _load_static_jacobian1(Y8n1,Y8n1,1.0);
1005 : : #endif
1006 [ # # ][ # # ]: 0 : _load_static_residual2(Y8n1,Y8n2,(BP(Y8n1,Y8n2)/Rd));
1007 : : #if defined(_DERIVATE)
1008 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y8n1,Y8n2,Y8n1,Y8n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
1009 : : #endif
1010 : : #if defined(_DYNAMIC)
1011 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y8n2,_DDT((Cd*NP(Y8n2))));
1012 : : #if defined(_DERIVATE)
1013 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y8n2,Y8n2,(Cd));
[ # # ]
1014 : : #endif
1015 : : #endif
1016 : 0 : _load_static_residual1(Y8,(-NP(Y8n2)));
1017 : : #if defined(_DERIVATE)
1018 [ # # ]: 0 : _load_static_jacobian1(Y8,Y8n2,(-1.0));
1019 : : #endif
1020 : 0 : _load_static_residual1(Y8,NP(Y8));
1021 : : #if defined(_DERIVATE)
1022 [ # # ]: 0 : _load_static_jacobian1(Y8,Y8,1.0);
1023 : : #endif
1024 : : #if defined(_DERIVATE)
1025 [ # # ]: 0 : IY9_VEN_GND=VENI_VEN_GND*NP(D)*VCI*VBI*NP(A);
1026 : 0 : IY9_VD_GND=(VENI)*VCI*VBI*NP(A);
1027 [ # # ]: 0 : IY9_VC_GND=((VENI*NP(D))*VCI_VC_GND)*VBI*NP(A);
1028 [ # # ]: 0 : IY9_VB_GND=(((VENI*NP(D))*VCI)*VBI_VB_GND)*NP(A);
1029 : 0 : IY9_VA_GND=((((VENI*NP(D))*VCI)*VBI));
1030 : : #endif
1031 [ # # ]: 0 : IY9=((((VENI*NP(D))*VCI)*VBI)*NP(A));
1032 : : {
1033 : 0 : double m00_tanh(d00_tanh0,(TR*(IY9-0.5)))
1034 : : #if defined(_DERIVATE)
1035 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY9-0.5)))
1036 : : #endif
1037 : 0 : _load_static_residual1(Y9n1,((-0.5)*(1+d00_tanh0)));
1038 : : #if defined(_DERIVATE)
1039 [ # # ]: 0 : _load_static_jacobian1(Y9n1,A,((-0.5)*(TR*IY9_VA_GND)*d10_tanh0));
1040 [ # # ]: 0 : _load_static_jacobian1(Y9n1,B,((-0.5)*(TR*IY9_VB_GND)*d10_tanh0));
1041 [ # # ]: 0 : _load_static_jacobian1(Y9n1,C,((-0.5)*(TR*IY9_VC_GND)*d10_tanh0));
1042 [ # # ]: 0 : _load_static_jacobian1(Y9n1,D,((-0.5)*(TR*IY9_VD_GND)*d10_tanh0));
1043 [ # # ]: 0 : _load_static_jacobian1(Y9n1,EN,((-0.5)*(TR*IY9_VEN_GND)*d10_tanh0));
1044 : : #endif
1045 : : }
1046 : 0 : _load_static_residual1(Y9n1,NP(Y9n1));
1047 : : #if defined(_DERIVATE)
1048 [ # # ]: 0 : _load_static_jacobian1(Y9n1,Y9n1,1.0);
1049 : : #endif
1050 [ # # ][ # # ]: 0 : _load_static_residual2(Y9n1,Y9n2,(BP(Y9n1,Y9n2)/Rd));
1051 : : #if defined(_DERIVATE)
1052 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y9n1,Y9n2,Y9n1,Y9n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
1053 : : #endif
1054 : : #if defined(_DYNAMIC)
1055 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y9n2,_DDT((Cd*NP(Y9n2))));
1056 : : #if defined(_DERIVATE)
1057 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y9n2,Y9n2,(Cd));
[ # # ]
1058 : : #endif
1059 : : #endif
1060 : 0 : _load_static_residual1(Y9,(-NP(Y9n2)));
1061 : : #if defined(_DERIVATE)
1062 [ # # ]: 0 : _load_static_jacobian1(Y9,Y9n2,(-1.0));
1063 : : #endif
1064 : 0 : _load_static_residual1(Y9,NP(Y9));
1065 : : #if defined(_DERIVATE)
1066 [ # # ]: 0 : _load_static_jacobian1(Y9,Y9,1.0);
1067 : : #endif
1068 : : #if defined(_DERIVATE)
1069 [ # # ]: 0 : IY10_VEN_GND=VENI_VEN_GND*NP(D)*VCI*NP(B)*VAI;
1070 : 0 : IY10_VD_GND=(VENI)*VCI*NP(B)*VAI;
1071 [ # # ]: 0 : IY10_VC_GND=((VENI*NP(D))*VCI_VC_GND)*NP(B)*VAI;
1072 : 0 : IY10_VB_GND=(((VENI*NP(D))*VCI))*VAI;
1073 [ # # ]: 0 : IY10_VA_GND=((((VENI*NP(D))*VCI)*NP(B))*VAI_VA_GND);
1074 : : #endif
1075 [ # # ]: 0 : IY10=((((VENI*NP(D))*VCI)*NP(B))*VAI);
1076 : : {
1077 : 0 : double m00_tanh(d00_tanh0,(TR*(IY10-0.5)))
1078 : : #if defined(_DERIVATE)
1079 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY10-0.5)))
1080 : : #endif
1081 : 0 : _load_static_residual1(Y10n1,((-0.5)*(1+d00_tanh0)));
1082 : : #if defined(_DERIVATE)
1083 [ # # ]: 0 : _load_static_jacobian1(Y10n1,A,((-0.5)*(TR*IY10_VA_GND)*d10_tanh0));
1084 [ # # ]: 0 : _load_static_jacobian1(Y10n1,B,((-0.5)*(TR*IY10_VB_GND)*d10_tanh0));
1085 [ # # ]: 0 : _load_static_jacobian1(Y10n1,C,((-0.5)*(TR*IY10_VC_GND)*d10_tanh0));
1086 [ # # ]: 0 : _load_static_jacobian1(Y10n1,D,((-0.5)*(TR*IY10_VD_GND)*d10_tanh0));
1087 [ # # ]: 0 : _load_static_jacobian1(Y10n1,EN,((-0.5)*(TR*IY10_VEN_GND)*d10_tanh0));
1088 : : #endif
1089 : : }
1090 : 0 : _load_static_residual1(Y10n1,NP(Y10n1));
1091 : : #if defined(_DERIVATE)
1092 [ # # ]: 0 : _load_static_jacobian1(Y10n1,Y10n1,1.0);
1093 : : #endif
1094 [ # # ][ # # ]: 0 : _load_static_residual2(Y10n1,Y10n2,(BP(Y10n1,Y10n2)/Rd));
1095 : : #if defined(_DERIVATE)
1096 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y10n1,Y10n2,Y10n1,Y10n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
1097 : : #endif
1098 : : #if defined(_DYNAMIC)
1099 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y10n2,_DDT((Cd*NP(Y10n2))));
1100 : : #if defined(_DERIVATE)
1101 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y10n2,Y10n2,(Cd));
[ # # ]
1102 : : #endif
1103 : : #endif
1104 : 0 : _load_static_residual1(Y10,(-NP(Y10n2)));
1105 : : #if defined(_DERIVATE)
1106 [ # # ]: 0 : _load_static_jacobian1(Y10,Y10n2,(-1.0));
1107 : : #endif
1108 : 0 : _load_static_residual1(Y10,NP(Y10));
1109 : : #if defined(_DERIVATE)
1110 [ # # ]: 0 : _load_static_jacobian1(Y10,Y10,1.0);
1111 : : #endif
1112 : : #if defined(_DERIVATE)
1113 [ # # ][ # # ]: 0 : IY11_VEN_GND=VENI_VEN_GND*NP(D)*VCI*NP(B)*NP(A);
1114 [ # # ]: 0 : IY11_VD_GND=(VENI)*VCI*NP(B)*NP(A);
1115 [ # # ][ # # ]: 0 : IY11_VC_GND=((VENI*NP(D))*VCI_VC_GND)*NP(B)*NP(A);
1116 [ # # ]: 0 : IY11_VB_GND=(((VENI*NP(D))*VCI))*NP(A);
1117 [ # # ]: 0 : IY11_VA_GND=((((VENI*NP(D))*VCI)*NP(B)));
1118 : : #endif
1119 [ # # ][ # # ]: 0 : IY11=((((VENI*NP(D))*VCI)*NP(B))*NP(A));
1120 : : {
1121 : 0 : double m00_tanh(d00_tanh0,(TR*(IY11-0.5)))
1122 : : #if defined(_DERIVATE)
1123 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY11-0.5)))
1124 : : #endif
1125 : 0 : _load_static_residual1(Y11n1,((-0.5)*(1+d00_tanh0)));
1126 : : #if defined(_DERIVATE)
1127 [ # # ]: 0 : _load_static_jacobian1(Y11n1,A,((-0.5)*(TR*IY11_VA_GND)*d10_tanh0));
1128 [ # # ]: 0 : _load_static_jacobian1(Y11n1,B,((-0.5)*(TR*IY11_VB_GND)*d10_tanh0));
1129 [ # # ]: 0 : _load_static_jacobian1(Y11n1,C,((-0.5)*(TR*IY11_VC_GND)*d10_tanh0));
1130 [ # # ]: 0 : _load_static_jacobian1(Y11n1,D,((-0.5)*(TR*IY11_VD_GND)*d10_tanh0));
1131 [ # # ]: 0 : _load_static_jacobian1(Y11n1,EN,((-0.5)*(TR*IY11_VEN_GND)*d10_tanh0));
1132 : : #endif
1133 : : }
1134 : 0 : _load_static_residual1(Y11n1,NP(Y11n1));
1135 : : #if defined(_DERIVATE)
1136 [ # # ]: 0 : _load_static_jacobian1(Y11n1,Y11n1,1.0);
1137 : : #endif
1138 [ # # ][ # # ]: 0 : _load_static_residual2(Y11n1,Y11n2,(BP(Y11n1,Y11n2)/Rd));
1139 : : #if defined(_DERIVATE)
1140 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y11n1,Y11n2,Y11n1,Y11n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
1141 : : #endif
1142 : : #if defined(_DYNAMIC)
1143 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y11n2,_DDT((Cd*NP(Y11n2))));
1144 : : #if defined(_DERIVATE)
1145 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y11n2,Y11n2,(Cd));
[ # # ]
1146 : : #endif
1147 : : #endif
1148 : 0 : _load_static_residual1(Y11,(-NP(Y11n2)));
1149 : : #if defined(_DERIVATE)
1150 [ # # ]: 0 : _load_static_jacobian1(Y11,Y11n2,(-1.0));
1151 : : #endif
1152 : 0 : _load_static_residual1(Y11,NP(Y11));
1153 : : #if defined(_DERIVATE)
1154 [ # # ]: 0 : _load_static_jacobian1(Y11,Y11,1.0);
1155 : : #endif
1156 : : #if defined(_DERIVATE)
1157 [ # # ]: 0 : IY12_VEN_GND=VENI_VEN_GND*NP(D)*NP(C)*VBI*VAI;
1158 : 0 : IY12_VD_GND=(VENI)*NP(C)*VBI*VAI;
1159 : 0 : IY12_VC_GND=((VENI*NP(D)))*VBI*VAI;
1160 [ # # ]: 0 : IY12_VB_GND=(((VENI*NP(D))*NP(C))*VBI_VB_GND)*VAI;
1161 [ # # ]: 0 : IY12_VA_GND=((((VENI*NP(D))*NP(C))*VBI)*VAI_VA_GND);
1162 : : #endif
1163 [ # # ]: 0 : IY12=((((VENI*NP(D))*NP(C))*VBI)*VAI);
1164 : : {
1165 : 0 : double m00_tanh(d00_tanh0,(TR*(IY12-0.5)))
1166 : : #if defined(_DERIVATE)
1167 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY12-0.5)))
1168 : : #endif
1169 : 0 : _load_static_residual1(Y12n1,((-0.5)*(1+d00_tanh0)));
1170 : : #if defined(_DERIVATE)
1171 [ # # ]: 0 : _load_static_jacobian1(Y12n1,A,((-0.5)*(TR*IY12_VA_GND)*d10_tanh0));
1172 [ # # ]: 0 : _load_static_jacobian1(Y12n1,B,((-0.5)*(TR*IY12_VB_GND)*d10_tanh0));
1173 [ # # ]: 0 : _load_static_jacobian1(Y12n1,C,((-0.5)*(TR*IY12_VC_GND)*d10_tanh0));
1174 [ # # ]: 0 : _load_static_jacobian1(Y12n1,D,((-0.5)*(TR*IY12_VD_GND)*d10_tanh0));
1175 [ # # ]: 0 : _load_static_jacobian1(Y12n1,EN,((-0.5)*(TR*IY12_VEN_GND)*d10_tanh0));
1176 : : #endif
1177 : : }
1178 : 0 : _load_static_residual1(Y12n1,NP(Y12n1));
1179 : : #if defined(_DERIVATE)
1180 [ # # ]: 0 : _load_static_jacobian1(Y12n1,Y12n1,1.0);
1181 : : #endif
1182 [ # # ][ # # ]: 0 : _load_static_residual2(Y12n1,Y12n2,(BP(Y12n1,Y12n2)/Rd));
1183 : : #if defined(_DERIVATE)
1184 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y12n1,Y12n2,Y12n1,Y12n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
1185 : : #endif
1186 : : #if defined(_DYNAMIC)
1187 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y12n2,_DDT((Cd*NP(Y12n2))));
1188 : : #if defined(_DERIVATE)
1189 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y12n2,Y12n2,(Cd));
[ # # ]
1190 : : #endif
1191 : : #endif
1192 : 0 : _load_static_residual1(Y12,(-NP(Y12n2)));
1193 : : #if defined(_DERIVATE)
1194 [ # # ]: 0 : _load_static_jacobian1(Y12,Y12n2,(-1.0));
1195 : : #endif
1196 : 0 : _load_static_residual1(Y12,NP(Y12));
1197 : : #if defined(_DERIVATE)
1198 [ # # ]: 0 : _load_static_jacobian1(Y12,Y12,1.0);
1199 : : #endif
1200 : : #if defined(_DERIVATE)
1201 [ # # ][ # # ]: 0 : IY13_VEN_GND=VENI_VEN_GND*NP(D)*NP(C)*VBI*NP(A);
1202 [ # # ]: 0 : IY13_VD_GND=(VENI)*NP(C)*VBI*NP(A);
1203 [ # # ]: 0 : IY13_VC_GND=((VENI*NP(D)))*VBI*NP(A);
1204 [ # # ][ # # ]: 0 : IY13_VB_GND=(((VENI*NP(D))*NP(C))*VBI_VB_GND)*NP(A);
1205 [ # # ]: 0 : IY13_VA_GND=((((VENI*NP(D))*NP(C))*VBI));
1206 : : #endif
1207 [ # # ][ # # ]: 0 : IY13=((((VENI*NP(D))*NP(C))*VBI)*NP(A));
1208 : : {
1209 : 0 : double m00_tanh(d00_tanh0,(TR*(IY13-0.5)))
1210 : : #if defined(_DERIVATE)
1211 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY13-0.5)))
1212 : : #endif
1213 : 0 : _load_static_residual1(Y13n1,((-0.5)*(1+d00_tanh0)));
1214 : : #if defined(_DERIVATE)
1215 [ # # ]: 0 : _load_static_jacobian1(Y13n1,A,((-0.5)*(TR*IY13_VA_GND)*d10_tanh0));
1216 [ # # ]: 0 : _load_static_jacobian1(Y13n1,B,((-0.5)*(TR*IY13_VB_GND)*d10_tanh0));
1217 [ # # ]: 0 : _load_static_jacobian1(Y13n1,C,((-0.5)*(TR*IY13_VC_GND)*d10_tanh0));
1218 [ # # ]: 0 : _load_static_jacobian1(Y13n1,D,((-0.5)*(TR*IY13_VD_GND)*d10_tanh0));
1219 [ # # ]: 0 : _load_static_jacobian1(Y13n1,EN,((-0.5)*(TR*IY13_VEN_GND)*d10_tanh0));
1220 : : #endif
1221 : : }
1222 : 0 : _load_static_residual1(Y13n1,NP(Y13n1));
1223 : : #if defined(_DERIVATE)
1224 [ # # ]: 0 : _load_static_jacobian1(Y13n1,Y13n1,1.0);
1225 : : #endif
1226 [ # # ][ # # ]: 0 : _load_static_residual2(Y13n1,Y13n2,(BP(Y13n1,Y13n2)/Rd));
1227 : : #if defined(_DERIVATE)
1228 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y13n1,Y13n2,Y13n1,Y13n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
1229 : : #endif
1230 : : #if defined(_DYNAMIC)
1231 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y13n2,_DDT((Cd*NP(Y13n2))));
1232 : : #if defined(_DERIVATE)
1233 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y13n2,Y13n2,(Cd));
[ # # ]
1234 : : #endif
1235 : : #endif
1236 : 0 : _load_static_residual1(Y13,(-NP(Y13n2)));
1237 : : #if defined(_DERIVATE)
1238 [ # # ]: 0 : _load_static_jacobian1(Y13,Y13n2,(-1.0));
1239 : : #endif
1240 : 0 : _load_static_residual1(Y13,NP(Y13));
1241 : : #if defined(_DERIVATE)
1242 [ # # ]: 0 : _load_static_jacobian1(Y13,Y13,1.0);
1243 : : #endif
1244 : : #if defined(_DERIVATE)
1245 [ # # ][ # # ]: 0 : IY14_VEN_GND=VENI_VEN_GND*NP(D)*NP(C)*NP(B)*VAI;
1246 [ # # ]: 0 : IY14_VD_GND=(VENI)*NP(C)*NP(B)*VAI;
1247 [ # # ]: 0 : IY14_VC_GND=((VENI*NP(D)))*NP(B)*VAI;
1248 [ # # ]: 0 : IY14_VB_GND=(((VENI*NP(D))*NP(C)))*VAI;
1249 [ # # ][ # # ]: 0 : IY14_VA_GND=((((VENI*NP(D))*NP(C))*NP(B))*VAI_VA_GND);
1250 : : #endif
1251 [ # # ][ # # ]: 0 : IY14=((((VENI*NP(D))*NP(C))*NP(B))*VAI);
1252 : : {
1253 : 0 : double m00_tanh(d00_tanh0,(TR*(IY14-0.5)))
1254 : : #if defined(_DERIVATE)
1255 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY14-0.5)))
1256 : : #endif
1257 : 0 : _load_static_residual1(Y14n1,((-0.5)*(1+d00_tanh0)));
1258 : : #if defined(_DERIVATE)
1259 [ # # ]: 0 : _load_static_jacobian1(Y14n1,A,((-0.5)*(TR*IY14_VA_GND)*d10_tanh0));
1260 [ # # ]: 0 : _load_static_jacobian1(Y14n1,B,((-0.5)*(TR*IY14_VB_GND)*d10_tanh0));
1261 [ # # ]: 0 : _load_static_jacobian1(Y14n1,C,((-0.5)*(TR*IY14_VC_GND)*d10_tanh0));
1262 [ # # ]: 0 : _load_static_jacobian1(Y14n1,D,((-0.5)*(TR*IY14_VD_GND)*d10_tanh0));
1263 [ # # ]: 0 : _load_static_jacobian1(Y14n1,EN,((-0.5)*(TR*IY14_VEN_GND)*d10_tanh0));
1264 : : #endif
1265 : : }
1266 : 0 : _load_static_residual1(Y14n1,NP(Y14n1));
1267 : : #if defined(_DERIVATE)
1268 [ # # ]: 0 : _load_static_jacobian1(Y14n1,Y14n1,1.0);
1269 : : #endif
1270 [ # # ][ # # ]: 0 : _load_static_residual2(Y14n1,Y14n2,(BP(Y14n1,Y14n2)/Rd));
1271 : : #if defined(_DERIVATE)
1272 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y14n1,Y14n2,Y14n1,Y14n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
1273 : : #endif
1274 : : #if defined(_DYNAMIC)
1275 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y14n2,_DDT((Cd*NP(Y14n2))));
1276 : : #if defined(_DERIVATE)
1277 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y14n2,Y14n2,(Cd));
[ # # ]
1278 : : #endif
1279 : : #endif
1280 : 0 : _load_static_residual1(Y14,(-NP(Y14n2)));
1281 : : #if defined(_DERIVATE)
1282 [ # # ]: 0 : _load_static_jacobian1(Y14,Y14n2,(-1.0));
1283 : : #endif
1284 : 0 : _load_static_residual1(Y14,NP(Y14));
1285 : : #if defined(_DERIVATE)
1286 [ # # ]: 0 : _load_static_jacobian1(Y14,Y14,1.0);
1287 : : #endif
1288 : : #if defined(_DERIVATE)
1289 [ # # ][ # # ]: 0 : IY15_VEN_GND=VENI_VEN_GND*NP(D)*NP(C)*NP(B)*NP(A);
[ # # ]
1290 [ # # ][ # # ]: 0 : IY15_VD_GND=(VENI)*NP(C)*NP(B)*NP(A);
1291 [ # # ][ # # ]: 0 : IY15_VC_GND=((VENI*NP(D)))*NP(B)*NP(A);
1292 [ # # ][ # # ]: 0 : IY15_VB_GND=(((VENI*NP(D))*NP(C)))*NP(A);
1293 [ # # ][ # # ]: 0 : IY15_VA_GND=((((VENI*NP(D))*NP(C))*NP(B)));
1294 : : #endif
1295 [ # # ][ # # ]: 0 : IY15=((((VENI*NP(D))*NP(C))*NP(B))*NP(A));
[ # # ]
1296 : : {
1297 : 0 : double m00_tanh(d00_tanh0,(TR*(IY15-0.5)))
1298 : : #if defined(_DERIVATE)
1299 : 0 : double m10_tanh(d10_tanh0,d00_tanh0,(TR*(IY15-0.5)))
1300 : : #endif
1301 : 0 : _load_static_residual1(Y15n1,((-0.5)*(1+d00_tanh0)));
1302 : : #if defined(_DERIVATE)
1303 [ # # ]: 0 : _load_static_jacobian1(Y15n1,A,((-0.5)*(TR*IY15_VA_GND)*d10_tanh0));
1304 [ # # ]: 0 : _load_static_jacobian1(Y15n1,B,((-0.5)*(TR*IY15_VB_GND)*d10_tanh0));
1305 [ # # ]: 0 : _load_static_jacobian1(Y15n1,C,((-0.5)*(TR*IY15_VC_GND)*d10_tanh0));
1306 [ # # ]: 0 : _load_static_jacobian1(Y15n1,D,((-0.5)*(TR*IY15_VD_GND)*d10_tanh0));
1307 [ # # ]: 0 : _load_static_jacobian1(Y15n1,EN,((-0.5)*(TR*IY15_VEN_GND)*d10_tanh0));
1308 : : #endif
1309 : : }
1310 : 0 : _load_static_residual1(Y15n1,NP(Y15n1));
1311 : : #if defined(_DERIVATE)
1312 [ # # ]: 0 : _load_static_jacobian1(Y15n1,Y15n1,1.0);
1313 : : #endif
1314 [ # # ][ # # ]: 0 : _load_static_residual2(Y15n1,Y15n2,(BP(Y15n1,Y15n2)/Rd));
1315 : : #if defined(_DERIVATE)
1316 [ # # ][ # # ]: 0 : _load_static_jacobian4(Y15n1,Y15n2,Y15n1,Y15n2,(1/Rd));
[ # # ][ # # ]
[ # # ]
1317 : : #endif
1318 : : #if defined(_DYNAMIC)
1319 [ # # ][ # # ]: 0 : _load_dynamic_residual1(Y15n2,_DDT((Cd*NP(Y15n2))));
1320 : : #if defined(_DERIVATE)
1321 [ # # ][ # # ]: 0 : _load_dynamic_jacobian1(Y15n2,Y15n2,(Cd));
[ # # ]
1322 : : #endif
1323 : : #endif
1324 : 0 : _load_static_residual1(Y15,(-NP(Y15n2)));
1325 : : #if defined(_DERIVATE)
1326 [ # # ]: 0 : _load_static_jacobian1(Y15,Y15n2,(-1.0));
1327 : : #endif
1328 : 0 : _load_static_residual1(Y15,NP(Y15));
1329 : : #if defined(_DERIVATE)
1330 [ # # ]: 0 : _load_static_jacobian1(Y15,Y15,1.0);
1331 : : #endif
1332 : :
1333 : : /* ------------------ end of verilog analog equations --------------------- */
1334 : :
1335 : : /* ------------------ evaluate verilog noise equations -------------------- */
1336 : :
1337 : : /* ------------------- end of verilog noise equations --------------------- */
1338 : 0 : }
1339 : :
1340 : : /* Perform DC iteration. */
1341 : 0 : void dmux4to16::calcDC (void)
1342 : : {
1343 : : // evaluate Verilog code
1344 : 0 : initVerilog ();
1345 : 0 : calcVerilog ();
1346 : :
1347 : : // fill right hand side and static jacobian
1348 [ # # ]: 0 : for (int i1 = 0; i1 < 53; i1++) {
1349 [ # # ]: 0 : setI (i1, _rhs[i1]);
1350 [ # # ]: 0 : for (int i2 = 0; i2 < 53; i2++) {
1351 [ # # ]: 0 : setY (i1, i2, _jstat[i1][i2]);
1352 : : }
1353 : : }
1354 : 0 : }
1355 : :
1356 : : /* Save operating points. */
1357 : 0 : void dmux4to16::saveOperatingPoints (void)
1358 : : {
1359 : : // save global instance operating points
1360 : 0 : }
1361 : :
1362 : : /* Load operating points. */
1363 : 0 : void dmux4to16::loadOperatingPoints (void)
1364 : : {
1365 : 0 : }
1366 : :
1367 : : /* Calculate operating points. */
1368 : 0 : void dmux4to16::calcOperatingPoints (void)
1369 : : {
1370 : 0 : }
1371 : :
1372 : : /* Initialization of AC analysis. */
1373 : 0 : void dmux4to16::initAC (void)
1374 : : {
1375 : 0 : allocMatrixMNA ();
1376 : 0 : }
1377 : :
1378 : : /* Perform AC calculations. */
1379 : 0 : void dmux4to16::calcAC (nr_double_t frequency)
1380 : : {
1381 [ # # ]: 0 : setMatrixY (calcMatrixY (frequency));
1382 : 0 : }
1383 : :
1384 : : /* Compute Y-matrix for AC analysis. */
1385 : 0 : matrix dmux4to16::calcMatrixY (nr_double_t frequency)
1386 : : {
1387 : 0 : _freq = frequency;
1388 : 0 : saveOperatingPoints ();
1389 : 0 : matrix y (53);
1390 : :
1391 [ # # ]: 0 : for (int i1 = 0; i1 < 53; i1++) {
1392 [ # # ]: 0 : for (int i2 = 0; i2 < 53; i2++) {
1393 : 0 : y (i1,i2) = nr_complex_t (_jstat[i1][i2], _jdyna[i1][i2] * 2 * M_PI * _freq);
1394 : : }
1395 : : }
1396 : :
1397 : 0 : return y;
1398 : : }
1399 : :
1400 : : /* Initialization of S-parameter analysis. */
1401 : 0 : void dmux4to16::initSP (void)
1402 : : {
1403 : 0 : allocMatrixS ();
1404 : 0 : }
1405 : :
1406 : : /* Perform S-parameter calculations. */
1407 : 0 : void dmux4to16::calcSP (nr_double_t frequency)
1408 : : {
1409 [ # # ][ # # ]: 0 : setMatrixS (ytos (calcMatrixY (frequency)));
[ # # ][ # # ]
[ # # ]
1410 : 0 : }
1411 : :
1412 : : /* Initialization of transient analysis. */
1413 : 0 : void dmux4to16::initTR (void)
1414 : : {
1415 : 0 : setStates (2 * 53 * 53);
1416 : 0 : initDC ();
1417 : 0 : }
1418 : :
1419 : : /* Perform transient analysis iteration step. */
1420 : 0 : void dmux4to16::calcTR (nr_double_t)
1421 : : {
1422 : 0 : doHB = 0;
1423 : 0 : doAC = 1;
1424 : 0 : doTR = 1;
1425 : 0 : calcDC ();
1426 : :
1427 : : int i1, i2, i3, i4, state;
1428 : :
1429 : : // 2-node charge integrations
1430 [ # # ]: 0 : for (i1 = 0; i1 < 53; i1++) {
1431 [ # # ]: 0 : for (i2 = 0; i2 < 53; i2++) {
1432 : 0 : state = 2 * (i2 + 53 * i1);
1433 [ # # ]: 0 : if (i1 != i2)
1434 [ # # ]: 0 : if (_charges[i1][i2] != 0.0)
1435 : 0 : transientCapacitanceQ (state, i1, i2, _charges[i1][i2]);
1436 : : } }
1437 : :
1438 : : // 1-node charge integrations
1439 [ # # ]: 0 : for (i1 = 0; i1 < 53; i1++) {
1440 : 0 : state = 2 * (i1 + 53 * i1);
1441 [ # # ]: 0 : if (_charges[i1][i1] != 0.0)
1442 : 0 : transientCapacitanceQ (state, i1, _charges[i1][i1]);
1443 : : }
1444 : :
1445 : : // charge: 2-node, voltage: 2-node
1446 [ # # ]: 0 : for (i1 = 0; i1 < 53; i1++) {
1447 [ # # ]: 0 : for (i2 = 0; i2 < 53; i2++) {
1448 [ # # ]: 0 : if (i1 != i2)
1449 [ # # ]: 0 : for (i3 = 0; i3 < 53; i3++) {
1450 [ # # ]: 0 : for (i4 = 0; i4 < 53; i4++) {
1451 [ # # ]: 0 : if (i3 != i4)
1452 [ # # ]: 0 : if (_caps[i1][i2][i3][i4] != 0.0)
1453 [ # # ][ # # ]: 0 : transientCapacitanceC (i1, i2, i3, i4, _caps[i1][i2][i3][i4], BP(i3,i4));
1454 : : } } } }
1455 : :
1456 : : // charge: 2-node, voltage: 1-node
1457 [ # # ]: 0 : for (i1 = 0; i1 < 53; i1++) {
1458 [ # # ]: 0 : for (i2 = 0; i2 < 53; i2++) {
1459 [ # # ]: 0 : if (i1 != i2)
1460 [ # # ]: 0 : for (i3 = 0; i3 < 53; i3++) {
1461 [ # # ]: 0 : if (_caps[i1][i2][i3][i3] != 0.0)
1462 [ # # ]: 0 : transientCapacitanceC2Q (i1, i2, i3, _caps[i1][i2][i3][i3], NP(i3));
1463 : : } } }
1464 : :
1465 : : // charge: 1-node, voltage: 2-node
1466 [ # # ]: 0 : for (i1 = 0; i1 < 53; i1++) {
1467 [ # # ]: 0 : for (i3 = 0; i3 < 53; i3++) {
1468 [ # # ]: 0 : for (i4 = 0; i4 < 53; i4++) {
1469 [ # # ]: 0 : if (i3 != i4)
1470 [ # # ]: 0 : if (_caps[i1][i1][i3][i4] != 0.0)
1471 [ # # ][ # # ]: 0 : transientCapacitanceC2V (i1, i3, i4, _caps[i1][i1][i3][i4], BP(i3,i4));
1472 : : } } }
1473 : :
1474 : : // charge: 1-node, voltage: 1-node
1475 [ # # ]: 0 : for (i1 = 0; i1 < 53; i1++) {
1476 [ # # ]: 0 : for (i3 = 0; i3 < 53; i3++) {
1477 [ # # ]: 0 : if (_caps[i1][i1][i3][i3] != 0.0)
1478 [ # # ]: 0 : transientCapacitanceC (i1, i3, _caps[i1][i1][i3][i3], NP(i3));
1479 : : } }
1480 : 0 : }
1481 : :
1482 : : /* Compute Cy-matrix for AC noise analysis. */
1483 : 0 : matrix dmux4to16::calcMatrixCy (nr_double_t frequency)
1484 : : {
1485 : 0 : _freq = frequency;
1486 : 0 : matrix cy (53);
1487 : :
1488 : :
1489 : 0 : return cy;
1490 : : }
1491 : :
1492 : : /* Perform AC noise computations. */
1493 : 0 : void dmux4to16::calcNoiseAC (nr_double_t frequency)
1494 : : {
1495 [ # # ]: 0 : setMatrixN (calcMatrixCy (frequency));
1496 : 0 : }
1497 : :
1498 : : /* Perform S-parameter noise computations. */
1499 : 0 : void dmux4to16::calcNoiseSP (nr_double_t frequency)
1500 : : {
1501 [ # # ][ # # ]: 0 : setMatrixN (cytocs (calcMatrixCy (frequency) * z0, getMatrixS ()));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1502 : 0 : }
1503 : :
1504 : : /* Initialization of HB analysis. */
1505 : 0 : void dmux4to16::initHB (int)
1506 : : {
1507 : 0 : initDC ();
1508 : 0 : allocMatrixHB ();
1509 : 0 : }
1510 : :
1511 : : /* Perform HB analysis. */
1512 : 0 : void dmux4to16::calcHB (int)
1513 : : {
1514 : 0 : doHB = 1;
1515 : 0 : doAC = 1;
1516 : 0 : doTR = 0;
1517 : :
1518 : : // jacobian dI/dV and currents get filled
1519 : 0 : calcDC ();
1520 : 0 : saveOperatingPoints ();
1521 : :
1522 : : // fill in HB matrices
1523 [ # # ]: 0 : for (int i1 = 0; i1 < 53; i1++) {
1524 [ # # ]: 0 : setQ (i1, _qhs[i1]); // charges
1525 [ # # ]: 0 : setCV (i1, _chs[i1]); // jacobian dQ/dV * V
1526 [ # # ]: 0 : setGV (i1, _ghs[i1]); // jacobian dI/dV * V
1527 [ # # ]: 0 : for (int i2 = 0; i2 < 53; i2++) {
1528 [ # # ]: 0 : setQV (i1, i2, _jdyna[i1][i2]); // jacobian dQ/dV
1529 : : }
1530 : : }
1531 : 0 : }
1532 : :
1533 : : #include "dmux4to16.defs.h"
1534 : :
|
