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