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