16 #include "component.h"
21 #define CIR_mux2to1 -1
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;\
53 _ghs[pnode] += conductance * BP(vpnode,vnnode);\
54 _ghs[nnode] -= conductance * BP(vpnode,vnnode);\
56 _rhs[pnode] += conductance * BP(vpnode,vnnode);\
57 _rhs[nnode] -= conductance * BP(vpnode,vnnode);\
59 #define _load_static_jacobian2p(node,vpnode,vnnode,conductance)\
60 _jstat[node][vpnode] += conductance;\
61 _jstat[node][vnnode] -= conductance;\
63 _ghs[node] += conductance * BP(vpnode,vnnode);\
65 _rhs[node] += conductance * BP(vpnode,vnnode);\
67 #define _load_static_jacobian2s(pnode,nnode,node,conductance)\
68 _jstat[pnode][node] += conductance;\
69 _jstat[nnode][node] -= conductance;\
71 _ghs[pnode] += conductance * NP(node);\
72 _ghs[nnode] -= conductance * NP(node);\
74 _rhs[pnode] += conductance * NP(node);\
75 _rhs[nnode] -= conductance * NP(node);\
77 #define _load_static_jacobian1(node,vnode,conductance)\
78 _jstat[node][vnode] += conductance;\
80 _ghs[node] += conductance * NP(vnode);\
82 _rhs[node] += conductance * NP(vnode);\
84 #define _load_dynamic_residual2(pnode,nnode,charge)\
85 if (doTR) _charges[pnode][nnode] += charge;\
87 _qhs[pnode] -= charge;\
88 _qhs[nnode] += charge;\
90 #define _load_dynamic_residual1(node,charge)\
91 if (doTR) _charges[node][node] += charge;\
93 _qhs[node] -= charge;\
95 #define _load_dynamic_jacobian4(pnode,nnode,vpnode,vnnode,capacitance)\
97 _jdyna[pnode][vpnode] += capacitance;\
98 _jdyna[nnode][vnnode] += capacitance;\
99 _jdyna[pnode][vnnode] -= capacitance;\
100 _jdyna[nnode][vpnode] -= capacitance;\
103 _caps[pnode][nnode][vpnode][vnnode] += capacitance;\
106 _chs[pnode] += capacitance * BP(vpnode,vnnode);\
107 _chs[nnode] -= capacitance * BP(vpnode,vnnode);\
109 #define _load_dynamic_jacobian2s(pnode,nnode,vnode,capacitance)\
111 _jdyna[pnode][vnode] += capacitance;\
112 _jdyna[nnode][vnode] -= capacitance;\
115 _caps[pnode][nnode][vnode][vnode] += capacitance;\
118 _chs[pnode] += capacitance * NP(vnode);\
119 _chs[nnode] -= capacitance * NP(vnode);\
121 #define _load_dynamic_jacobian2p(node,vpnode,vnnode,capacitance)\
123 _jdyna[node][vpnode] += capacitance;\
124 _jdyna[node][vnnode] -= capacitance;\
127 _caps[node][node][vpnode][vnnode] += capacitance;\
130 _chs[node] += capacitance * BP(vpnode,vnnode);\
132 #define _load_dynamic_jacobian1(node,vnode,capacitance)\
134 _jdyna[node][vnode] += capacitance;\
137 _caps[node][node][vnode][vnode] += capacitance;\
140 _chs[node] += capacitance * NP(vnode);\
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;
167 #define m00_hypot(v00,x,y) v00 = xhypot(x,y);
168 #define m10_hypot(v10,v00,x,y) v10 = (x)/(v00);
169 #define m11_hypot(v11,v00,x,y) v11 = (y)/(v00);
170 #define m00_max(v00,x,y) v00 = ((x)>(y))?(x):(y);
171 #define m10_max(v10,v00,x,y) v10 = ((x)>(y))?1.0:0.0;
172 #define m11_max(v11,v00,x,y) v11 = ((x)>(y))?0.0:1.0;
173 #define m00_min(v00,x,y) v00 = ((x)<(y))?(x):(y);
174 #define m10_min(v10,v00,x,y) v10 = ((x)<(y))?1.0:0.0;
175 #define m11_min(v11,v00,x,y) v11 = ((x)<(y))?0.0:1.0;
176 #define m00_pow(v00,x,y) v00 = pow(x,y);
177 #define m10_pow(v10,v00,x,y) v10 = (x==0.0)?0.0:(v00)*(y)/(x);
178 #define m11_pow(v11,v00,x,y) v11 = (x==0.0)?0.0:(log(x)*(v00));
180 #define m00_div(v00,v10,x,y) double v10=1/(y); double v00=(x)*v10;
181 #define m10_div(v10,v00,vv,x,y)
182 #define m11_div(v11,v00,vv,x,y) double v11 = -v00*vv;
184 #define m00_mult(v00,v10,v11,x,y) double v10=(x); double v11=(y); double v00=v10*v11;
185 #define m00_add(v00,x,y) double v00=(x)+(y);
187 #define m00_cos(v00,x) v00 = cos(x);
188 #define m10_cos(v10,v00,x) v10 = (-sin(x));
189 #define m00_sin(v00,x) v00 = sin(x);
190 #define m10_sin(v10,v00,x) v10 = (cos(x));
191 #define m00_tan(v00,x) v00 = tan(x);
192 #define m10_tan(v10,v00,x) v10 = (1.0/cos(x)/cos(x));
193 #define m00_cosh(v00,x) v00 = cosh(x);
194 #define m10_cosh(v10,v00,x) v10 = (sinh(x));
195 #define m00_sinh(v00,x) v00 = sinh(x);
196 #define m10_sinh(v10,v00,x) v10 = (cosh(x));
197 #define m00_tanh(v00,x) v00 = tanh(x);
198 #define m10_tanh(v10,v00,x) v10 = (1.0/cosh(x)/cosh(x));
199 #define m00_acos(v00,x) v00 = acos(x);
200 #define m10_acos(v10,v00,x) v10 = (-1.0/sqrt(1-x*x));
201 #define m00_asin(v00,x) v00 = asin(x);
202 #define m10_asin(v10,v00,x) v10 = (+1.0/sqrt(1-x*x));
203 #define m00_atan(v00,x) v00 = atan(x);
204 #define m10_atan(v10,v00,x) v10 = (+1.0/(1+x*x));
205 #define m00_atanh(v00,x) v00 = atanh(x);
206 #define m10_atanh(v10,v00,x) v10 = (+1.0/(1-x*x));
207 #define m00_logE(v00,x) v00 = log(x);
208 #define m10_logE(v10,v00,x) v10 = (1.0/x);
209 #define m00_log10(v00,x) v00 = log10(x);
210 #define m10_log10(v10,v00,x) v10 = (1.0/x/M_LN10);
211 #define m00_sqrt(v00,x) v00 = sqrt(x);
212 #define m10_sqrt(v10,v00,x) v10 = (0.5/v00);
213 #define m00_fabs(v00,x) v00 = fabs(x);
214 #define m10_fabs(v10,v00,x) v10 = (((x)>=0)?(+1.0):(-1.0));
216 #define m00_exp(v00,x) v00 = exp(x);
217 #define m10_exp(v10,v00,x) v10 = v00;
219 #define m00_abs(v00) ((v00)<(0)?(-(v00)):(v00))
220 #define m00_floor(v00,x) v00 = floor(x);
221 #define m00_limexp(v00,x) v00 = ((x)<80.0?exp(x):exp(80.0)*(x-79.0));
222 #define m10_limexp(v10,v00,x) v10 = ((x)<80.0?(v00):exp(80.0));
224 #define m20_logE(v00) (-1.0/v00/v00)
225 #define m20_exp(v00) exp(v00)
226 #define m20_limexp(v00) ((v00)<80.0?exp(v00):0.0)
227 #define m20_sqrt(v00) (-0.25/(v00)/sqrt(v00))
228 #define m20_fabs(v00) 0.0
229 #define m20_pow(x,y) ((y)*((y)-1.0)*pow(x,y)/(x)/(x))
230 #define m00_vt(x) (kBoverQ*(x))
231 #define m10_vt(x) (kBoverQ)
234 #define _modelname "mux2to1"
235 #define _instancename getName()
236 #define _circuit_temp (getPropertyDouble("Temp")+273.15)
237 #define _param_given(p) (isPropertyGiven(p)?1:0)
241 #define _vt_nom (kBoverQ*_circuit_temp)
243 using namespace device;
252 void mux2to1::initModel (
void)
265 initializeInstance ();
286 void mux2to1::initVerilog (
void)
293 for (i1 = 0; i1 < 7; i1++) {
294 for (i2 = 0; i2 < 7; i2++) {
295 _charges[i1][i2] = 0.0;
299 for (i1 = 0; i1 < 7; i1++) {
300 for (i2 = 0; i2 < 7; i2++) {
301 for (i3 = 0; i3 < 7; i3++) {
302 for (i4 = 0; i4 < 7; i4++) {
303 _caps[i1][i2][i3][i4] = 0.0;
307 for (i1 = 0; i1 < 7; i1++) {
312 for (i2 = 0; i2 < 7; i2++) {
313 _jstat[i1][i2] = 0.0;
314 _jdyna[i1][i2] = 0.0;
320 void mux2to1::loadVariables (
void)
332 #define _DERIVATEFORDDX
335 void mux2to1::initializeModel (
void)
337 #if defined(_DYNAMIC)
341 #if defined(_DYNAMIC)
342 Ccc=((Delay*1.43)/Rd);
348 void mux2to1::initializeInstance (
void)
353 void mux2to1::initialStep (
void)
358 void mux2to1::finalStep (
void)
363 void mux2to1::calcVerilog (
void)
368 #if defined(_DERIVATE)
374 #if defined(_DERIVATE)
376 In1_VD1_GND=((1-
NP(
EN))*(
NP(
A)));
378 In1_VD0_GND=((1-
NP(
EN))*((1-
NP(
A))));
382 double m00_tanh(d00_tanh0,(TR*(In1-0.5)))
383 #if defined(_DERIVATE)
384 double m10_tanh(d10_tanh0,d00_tanh0,(TR*(In1-0.5)))
387 #if defined(_DERIVATE)
395 #if defined(_DERIVATE)
399 #if defined(_DERIVATE)
402 #if defined(_DYNAMIC)
404 #if defined(_DERIVATE)
409 #if defined(_DERIVATE)
413 #if defined(_DERIVATE)
432 for (
int i1 = 0; i1 < 7; i1++) {
434 for (
int i2 = 0; i2 < 7; i2++) {
435 setY (i1, i2, _jstat[i1][i2]);
469 matrix mux2to1::calcMatrixY (nr_double_t frequency)
475 for (
int i1 = 0; i1 < 7; i1++) {
476 for (
int i2 = 0; i2 < 7; i2++) {
477 y (i1,i2) =
rect (_jstat[i1][i2], _jdyna[i1][i2] * 2 *
M_PI * _freq);
511 int i1, i2, i3, i4, state;
514 for (i1 = 0; i1 < 7; i1++) {
515 for (i2 = 0; i2 < 7; i2++) {
516 state = 2 * (i2 + 7 * i1);
518 if (_charges[i1][i2] != 0.0)
523 for (i1 = 0; i1 < 7; i1++) {
524 state = 2 * (i1 + 7 * i1);
525 if (_charges[i1][i1] != 0.0)
530 for (i1 = 0; i1 < 7; i1++) {
531 for (i2 = 0; i2 < 7; i2++) {
533 for (i3 = 0; i3 < 7; i3++) {
534 for (i4 = 0; i4 < 7; i4++) {
536 if (_caps[i1][i2][i3][i4] != 0.0)
541 for (i1 = 0; i1 < 7; i1++) {
542 for (i2 = 0; i2 < 7; i2++) {
544 for (i3 = 0; i3 < 7; i3++) {
545 if (_caps[i1][i2][i3][i3] != 0.0)
550 for (i1 = 0; i1 < 7; i1++) {
551 for (i3 = 0; i3 < 7; i3++) {
552 for (i4 = 0; i4 < 7; i4++) {
554 if (_caps[i1][i1][i3][i4] != 0.0)
559 for (i1 = 0; i1 < 7; i1++) {
560 for (i3 = 0; i3 < 7; i3++) {
561 if (_caps[i1][i1][i3][i3] != 0.0)
567 matrix mux2to1::calcMatrixCy (nr_double_t frequency)
607 for (
int i1 = 0; i1 < 7; i1++) {
609 setCV (i1, _chs[i1]);
610 setGV (i1, _ghs[i1]);
611 for (
int i2 = 0; i2 < 7; i2++) {
612 setQV (i1, i2, _jdyna[i1][i2]);