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