Jspice3
bjtdset.c
Go to the documentation of this file.
1 /***************************************************************************
2 JSPICE3 adaptation of Spice3f2 - Copyright (c) Stephen R. Whiteley 1992
3 Copyright 1990 Regents of the University of California. All rights reserved.
4 Authors: 1988 Jaijeet S Roychowdhury
5  1992 Stephen R. Whiteley
6 ****************************************************************************/
7 
8 /* Ugh! */
9 
10 #include "spice.h"
11 #include <stdio.h>
12 #include <math.h>
13 #include "bjtdefs.h"
14 #include "distodef.h"
15 #include "const.h"
16 #include "sperror.h"
17 #include "util.h"
18 #include "distoext.h"
19 
20 /*
21  * This function initialises the Taylor coeffs for the
22  * BJT's in the circuit
23  */
24 
25 int
26 BJTdSetup(inModel,ckt)
27 
28 GENmodel *inModel;
29 CKTcircuit *ckt;
30 /* actually load the current resistance value into the
31  * sparse matrix previously provided
32  */
33 {
34  register BJTmodel *model = (BJTmodel*)inModel;
35  register BJTinstance *here;
36  double arg;
37  double c2;
38  double c4;
39  double lcapbe1,lcapbe2,lcapbe3;
40  double lcapbx1,lcapbx2,lcapbx3;
41  double cb;
42  double cbc;
43  double cbcn;
44  double cbe;
45  double cben;
46  double cdis;
47  double csat;
48  double ctot;
49  double czbc;
50  double czbcf2;
51  double czbe;
52  double czbef2;
53  double czbx;
54  double czbxf2;
55  double czcs;
56  double evbc;
57  double evbcn;
58  double evbe;
59  double evben;
60  double f1;
61  double f2;
62  double f3;
63  double fcpc;
64  double fcpe;
65  double gbb1;
66  double gbc;
67  double gbcn;
68  double gbe;
69  double gbe2,gbe3;
70  double gbc2,gbc3;
71  double gben2,gben3;
72  double gbcn2,gbcn3;
73  double gben;
74  double gbb2, gbb3;
75  double oik;
76  double oikr;
77  double ovtf;
78  double pc;
79  double pe;
80  double ps;
81  double q1;
82  double q2;
83  double qb;
84  double rbpi;
85  double rbpr;
86  double sarg;
87  double sqarg;
88  double tf;
89  double tr;
90  double vbc;
91  double vbe;
92  double vbx;
93  double vsc;
94  double vt;
95  double vtc;
96  double vte;
97  double vtn;
98  double xjrb;
99  double xjtf;
100  double xmc;
101  double xme;
102  double xms;
103  double xtf;
104  double vbed;
105  double vbb;
106 
107 double lcapbc1 = 0.0;
108 double lcapbc2 = 0.0;
109 double lcapbc3 = 0.0;
110 
111 double lcapsc1 = 0.0;
112 double lcapsc2 = 0.0;
113 double lcapsc3 = 0.0;
114 double ic;
115 double dummy;
116 Dderivs d_p, d_q, d_r;
117 Dderivs d_dummy, d_q1, d_qb, d_dummy2;
118 Dderivs d_arg, d_sqarg, d_ic, d_q2;
119 Dderivs d_z, d_tanz, d_vbb, d_ibb, d_rbb;
120 Dderivs d_ib, d_cbe, d_tff, d_qbe;
121 
122 d_p.value = 0.0;
123 d_p.d1_p = 1.0;
124 d_p.d1_q = 0.0;
125 d_p.d1_r = 0.0;
126 d_p.d2_p2 = 0.0;
127 d_p.d2_q2 = 0.0;
128 d_p.d2_r2 = 0.0;
129 d_p.d2_pq = 0.0;
130 d_p.d2_qr = 0.0;
131 d_p.d2_pr = 0.0;
132 d_p.d3_p3 = 0.0;
133 d_p.d3_q3 = 0.0;
134 d_p.d3_r3 = 0.0;
135 d_p.d3_p2q = 0.0;
136 d_p.d3_p2r = 0.0;
137 d_p.d3_pq2 = 0.0;
138 d_p.d3_q2r = 0.0;
139 d_p.d3_pr2 = 0.0;
140 d_p.d3_qr2 = 0.0;
141 d_p.d3_pqr = 0.0;
142 
143 EqualDeriv(&d_q, &d_p);
144 d_q.d1_q = 1.0;
145 d_q.d1_p = 0.0;
146 
147 EqualDeriv(&d_r, &d_p);
148 d_r.d1_r = 1.0;
149 d_r.d1_p = 0.0;
150 
151 
152 /* loop through all the models */
153 for( ; model != NULL; model = model->BJTnextModel ) {
154 
155  /* loop through all the instances of the model */
156  for (here = model->BJTinstances; here != NULL ;
157  here=here->BJTnextInstance) {
158 
159  vt = here->BJTtemp * CONSTKoverQ;
160 
161 
162  /*
163  * dc model paramters
164  */
165  csat=here->BJTtSatCur*here->BJTarea;
166  rbpr=model->BJTminBaseResist/here->BJTarea;
167  rbpi=model->BJTbaseResist/here->BJTarea-rbpr;
168  oik=model->BJTinvRollOffF/here->BJTarea;
169  c2=here->BJTtBEleakCur*here->BJTarea;
170  vte=model->BJTleakBEemissionCoeff*vt;
171  oikr=model->BJTinvRollOffR/here->BJTarea;
172  c4=here->BJTtBCleakCur*here->BJTarea;
173  vtc=model->BJTleakBCemissionCoeff*vt;
174  xjrb=model->BJTbaseCurrentHalfResist*here->BJTarea;
175 
176 
177  /*
178  * initialization
179  */
180  vbe= model->BJTtype*(*(ckt->CKTrhsOld + here->BJTbasePrimeNode) -
181  *(ckt->CKTrhsOld + here->BJTemitPrimeNode));
182  vbc= model->BJTtype*(*(ckt->CKTrhsOld + here->BJTbaseNode) -
183  *(ckt->CKTrhsOld + here->BJTcolPrimeNode));
184  vbx=model->BJTtype*(
185  *(ckt->CKTrhsOld+here->BJTbaseNode)-
186  *(ckt->CKTrhsOld+here->BJTcolPrimeNode));
187  vsc=model->BJTtype*(
188  *(ckt->CKTrhsOld+here->BJTsubstNode)-
189  *(ckt->CKTrhsOld+here->BJTcolPrimeNode));
190 
191  vbb=model->BJTtype*(
192  *(ckt->CKTrhsOld+here->BJTbaseNode) -
193  *(ckt->CKTrhsOld+here->BJTbasePrimeNode));
194 
195 
196  vbed = vbe; /* this is just a dummy variable
197  * it is the delayed vbe to be
198  * used in the delayed gm generator
199  */
200 
201 
202  /* ic = f1(vbe,vbc,vbed) + f2(vbc) + f3(vbc)
203  *
204  * we shall calculate the taylor coeffs of
205  * ic wrt vbe, vbed, and vbc and store them away.
206  * the equations f1 f2 and f3 are given elsewhere;
207  * we shall start off with f1, compute
208  * derivs. upto third order and then do f2 and
209  * f3 and add their derivatives.
210  *
211  * Since f1 above is a function of three variables, it
212  * will be convenient to use derivative structures
213  * to compute the derivatives of f1. For this
214  * computation, p=vbe, q=vbc, r=vbed.
215  *
216  * ib = f1(vbe) + f2(vbc) (not the same f's as
217  * above, in case you are
218  * wondering!)
219  * the gbe's gbc's gben's and gbcn's are
220  * convenient subsidiary variables.
221  *
222  * irb = f(vbe, vbc, vbb) - the vbe & vbc
223  * dependencies arise from the
224  * qb term.
225  * qbe = f1(vbe,vbc) + f2(vbe)
226  *
227  * derivative structures will be used again in the
228  * above two equations. p=vbe, q=vbc, r=vbb.
229  *
230  * qbc = f(vbc) ; qbx = f(vbx)
231  *
232  * qss = f(vsc)
233  */
234  /*
235  * determine dc current and derivitives
236  */
237 next1: vtn=vt*model->BJTemissionCoeffF;
238  if(vbe > -5*vtn){
239  evbe=exp(vbe/vtn);
240  cbe=csat*(evbe-1)+ckt->CKTgmin*vbe;
241  gbe=csat*evbe/vtn+ckt->CKTgmin;
242  gbe2 = csat*evbe/vtn/vtn;
243  gbe3 = gbe2/vtn;
244 
245  /* note - these are actually derivs, not Taylor
246  * coeffs. - not divided by 2! and 3!
247  */
248  if (c2 == 0) {
249  cben=0;
250  gben=gben2=gben3=0;
251  } else {
252  evben=exp(vbe/vte);
253  cben=c2*(evben-1);
254  gben=c2*evben/vte;
255  gben2=gben/vte;
256  gben3=gben2/vte;
257  }
258  } else {
259  gbe = -csat/vbe+ckt->CKTgmin;
260  gbe2=gbe3=gben2=gben3=0;
261  cbe=gbe*vbe;
262  gben = -c2/vbe;
263  cben=gben*vbe;
264  }
265  vtn=vt*model->BJTemissionCoeffR;
266  if(vbc > -5*vtn) {
267  evbc=exp(vbc/vtn);
268  cbc=csat*(evbc-1)+ckt->CKTgmin*vbc;
269  gbc=csat*evbc/vtn+ckt->CKTgmin;
270  gbc2=csat*evbc/vtn/vtn;
271  gbc3=gbc2/vtn;
272  if (c4 == 0) {
273  cbcn=0;
274  gbcn=0;
275  gbcn2=gbcn3=0;
276  } else {
277  evbcn=exp(vbc/vtc);
278  cbcn=c4*(evbcn-1);
279  gbcn=c4*evbcn/vtc;
280  gbcn2=gbcn/vtc;
281  gbcn3=gbcn2/vtc;
282  }
283  } else {
284  gbc = -csat/vbc+ckt->CKTgmin;
285  gbc2=gbc3=0;
286  cbc = gbc*vbc;
287  gbcn = -c4/vbc;
288  gbcn2=gbcn3=0;
289  cbcn=gbcn*vbc;
290  }
291  /*
292  * determine base charge terms
293  */
294  /* q1 is a function of 2 variables p=vbe and q=vbc. r=
295  * anything
296  */
297  q1=1/(1-model->BJTinvEarlyVoltF*vbc-model->BJTinvEarlyVoltR*vbe);
298  dummy = (1-model->BJTinvEarlyVoltF*vbc-
299  model->BJTinvEarlyVoltR*vbe);
300  EqualDeriv(&d_dummy, &d_p);
301  d_dummy.value = dummy;
302  d_dummy.d1_p = - model->BJTinvEarlyVoltR;
303  d_dummy.d1_q = - model->BJTinvEarlyVoltF;
304  /* q1 = 1/dummy */
305  InvDeriv(&d_q1, &d_dummy); /* now q1 and its derivatives are
306  set up */
307  if(oik == 0 && oikr == 0) {
308  qb=q1;
309  EqualDeriv(&d_qb, &d_q1);
310  } else {
311  q2=oik*cbe+oikr*cbc;
312  EqualDeriv(&d_q2, &d_p);
313  d_q2.value = q2;
314  d_q2.d1_p = oik*gbe;
315  d_q2.d1_q = oikr*gbc;
316  d_q2.d2_p2 = oik*gbe2;
317  d_q2.d2_q2 = oikr*gbc2;
318  d_q2.d3_p3 = oik*gbe3;
319  d_q2.d3_q3 = oikr*gbc3;
320  arg=MAX(0,1+4*q2);
321  if (arg == 0.)
322  {
323  EqualDeriv(&d_arg,&d_p);
324  d_arg.d1_p = 0.0;
325  }
326  else
327  {
328  TimesDeriv(&d_arg,&d_q2,4.0);
329  d_arg.value += 1.;
330  }
331  sqarg=1;
332  EqualDeriv(&d_sqarg,&d_p);
333  d_sqarg.value = 1.0;
334  d_sqarg.d1_p = 0.0;
335  if(arg != 0){
336  sqarg=sqrt(arg);
337  SqrtDeriv(&d_sqarg, &d_arg);
338  }
339 
340  qb=q1*(1+sqarg)/2;
341  dummy = 1 + sqarg;
342  EqualDeriv(&d_dummy, &d_sqarg);
343  d_dummy.value += 1.0;
344  MultDeriv(&d_qb, &d_q1, &d_dummy);
345  TimesDeriv(&d_qb, &d_qb, 0.5);
346  }
347 
348 ic = (cbe - cbc)/qb;
349 /* cbe is a fn of vbed only; cbc of vbc; and qb of vbe and vbc */
350 /* p=vbe, q=vbc, r=vbed; now dummy = cbe - cbc */
351 EqualDeriv(&d_dummy, &d_p);
352 d_dummy.d1_p = 0.0;
353 d_dummy.value = cbe-cbc;
354 d_dummy.d1_r = gbe;
355 d_dummy.d2_r2 = gbe2;
356 d_dummy.d3_r3 = gbe3;
357 d_dummy.d1_q = -gbc;
358 d_dummy.d2_q2 = -gbc2;
359 d_dummy.d3_q3 = -gbc3;
360 
361 DivDeriv(&d_ic, &d_dummy, &d_qb);
362 
363 
364 d_ic.value -= cbc/here->BJTtBetaR + cbcn;
365 d_ic.d1_q -= gbc/here->BJTtBetaR + gbcn;
366 d_ic.d2_q2 -= gbc2/here->BJTtBetaR + gbcn2;
367 d_ic.d3_q3 -= gbc3/here->BJTtBetaR + gbcn3;
368 
369 /* check this point: where is the f2(vbe) contribution to ic ? */
370 
371  /* ic derivatives all set up now */
372  /* base spread resistance */
373 
374  if ( !((rbpr == 0.0) && (rbpi == 0.0)))
375  {
376  cb=cbe/here->BJTtBetaF+cben+cbc/here->BJTtBetaR+cbcn;
377  /* we are calculating derivatives w.r.t cb itself */
378  /*
379  gx=rbpr+rbpi/qb;
380  */
381 
382  if (cb != 0.0) {
383  if((xjrb != 0.0) && (rbpi != 0.0)) {
384  /* p = ib, q, r = anything */
385  dummy=MAX(cb/xjrb,1e-9);
386  EqualDeriv(&d_dummy, &d_p);
387  d_dummy.value = dummy;
388  d_dummy.d1_p = 1/xjrb;
389  SqrtDeriv(&d_dummy, &d_dummy);
390  TimesDeriv(&d_dummy, &d_dummy, 2.4317);
391 
392  /*
393  dummy2=(-1+sqrt(1+14.59025*MAX(cb/xjrb,1e-9)));
394  */
395  EqualDeriv(&d_dummy2, &d_p);
396  d_dummy2.value = 1+14.59025*MAX(cb/xjrb,1e-9);
397  d_dummy2.d1_p = 14.59025/xjrb;
398  SqrtDeriv(&d_dummy2, &d_dummy2);
399  d_dummy2.value -= 1.0;
400 
401  DivDeriv(&d_z, &d_dummy2, &d_dummy);
402  TanDeriv(&d_tanz, &d_z);
403 
404  /*now using dummy = tanz - z and dummy2 = z*tanz*tanz */
405  TimesDeriv(&d_dummy, &d_z, -1.0);
406  PlusDeriv(&d_dummy, &d_dummy, &d_tanz);
407 
408  MultDeriv(&d_dummy2, &d_tanz, &d_tanz);
409  MultDeriv(&d_dummy2, &d_dummy2, &d_z);
410 
411  DivDeriv(&d_rbb , &d_dummy, &d_dummy2);
412  TimesDeriv(&d_rbb,&d_rbb, 3.0*rbpi);
413  d_rbb.value += rbpr;
414 
415  MultDeriv(&d_vbb, &d_rbb, &d_p);
416 
417  /* power series inversion to get the conductance derivatives */
418 
419  if (d_vbb.d1_p != 0) {
420  gbb1 = 1/d_vbb.d1_p;
421  gbb2 = -(d_vbb.d2_p2*0.5)*gbb1*gbb1;
422  gbb3 = gbb1*gbb1*gbb1*gbb1*(-(d_vbb.d3_p3/6.0)
423  + 2*(d_vbb.d2_p2*0.5)*(d_vbb.d2_p2*0.5)*gbb1);
424  }
425  else
426  printf("\nd_vbb.d1_p = 0 in base spread resistance calculations\n");
427 
428 
429 /* r = vbb */
430 EqualDeriv(&d_ibb, &d_r);
431 d_ibb.value = cb;
432 d_ibb.d1_r = gbb1;
433 d_ibb.d2_r2 = 2*gbb2;
434 d_ibb.d3_r3 = 6.0*gbb3;
435  }
436  else
437  {
438  /*
439  rbb = rbpr + rbpi/qb;
440  ibb = vbb /rbb; = f(vbe, vbc, vbb)
441  */
442 
443  EqualDeriv(&d_rbb,&d_p);
444  d_rbb.d1_p = 0.0;
445  if (rbpi != 0.0) {
446  InvDeriv(&d_rbb, &d_qb);
447  TimesDeriv(&d_rbb, &d_rbb,rbpi);
448  }
449  d_rbb.value += rbpr;
450 
451  EqualDeriv(&d_ibb,&d_r);
452  d_ibb.value = vbb;
453  DivDeriv(&d_ibb,&d_ibb,&d_rbb);
454 
455  }
456  }
457  else
458  {
459  EqualDeriv(&d_ibb,&d_r);
460  if (rbpr != 0.0)
461  d_ibb.d1_r = 1/rbpr;
462  }
463  }
464  else
465  {
466  EqualDeriv(&d_ibb,&d_p);
467  d_ibb.d1_p = 0.0;
468  }
469 
470  /* formulae for base spread resistance over! */
471 
472  /* ib term */
473 
474  EqualDeriv(&d_ib, &d_p);
475  d_ib.d1_p = 0.0;
476  d_ib.value = cb;
477  d_ib.d1_p = gbe/here->BJTtBetaF + gben;
478  d_ib.d2_p2 = gbe2/here->BJTtBetaF + gben2;
479  d_ib.d3_p3 = gbe3/here->BJTtBetaF + gben3;
480 
481  d_ib.d1_q = gbc/here->BJTtBetaR + gbcn;
482  d_ib.d2_q2 = gbc2/here->BJTtBetaR + gbcn2;
483  d_ib.d3_q3 = gbc3/here->BJTtBetaR + gbcn3;
484 
485  /* ib term over */
486  /*
487  * charge storage elements
488  */
489  tf=model->BJTtransitTimeF;
490  tr=model->BJTtransitTimeR;
491  czbe=here->BJTtBEcap*here->BJTarea;
492  pe=here->BJTtBEpot;
493  xme=model->BJTjunctionExpBE;
494  cdis=model->BJTbaseFractionBCcap;
495  ctot=here->BJTtBCcap*here->BJTarea;
496  czbc=ctot*cdis;
497  czbx=ctot-czbc;
498  pc=here->BJTtBCpot;
499  xmc=model->BJTjunctionExpBC;
500  fcpe=here->BJTtDepCap;
501  czcs=model->BJTcapCS*here->BJTarea;
502  ps=model->BJTpotentialSubstrate;
503  xms=model->BJTexponentialSubstrate;
504  xtf=model->BJTtransitTimeBiasCoeffF;
505  ovtf=model->BJTtransitTimeVBCFactor;
506  xjtf=model->BJTtransitTimeHighCurrentF*here->BJTarea;
507  if(tf != 0 && vbe >0) {
508  EqualDeriv(&d_cbe, &d_p);
509  d_cbe.value = cbe;
510  d_cbe.d1_p = gbe;
511  d_cbe.d2_p2 = gbe2;
512  d_cbe.d3_p3 = gbe3;
513  if(xtf != 0){
514  if(ovtf != 0) {
515  /* dummy = exp ( vbc*ovtf) */
516  EqualDeriv(&d_dummy, &d_q);
517  d_dummy.value = vbc*ovtf;
518  d_dummy.d1_q = ovtf;
519  ExpDeriv(&d_dummy, &d_dummy);
520  }
521  else
522  {
523  EqualDeriv(&d_dummy,&d_p);
524  d_dummy.value = 1.0;
525  d_dummy.d1_p = 0.0;
526  }
527  if(xjtf != 0) {
528  EqualDeriv(&d_dummy2, &d_cbe);
529  d_dummy2.value += xjtf;
530  DivDeriv(&d_dummy2, &d_cbe, &d_dummy2);
531  MultDeriv (&d_dummy2, &d_dummy2, &d_dummy2);
532  }
533  else
534  {
535  EqualDeriv(&d_dummy2,&d_p);
536  d_dummy2.value = 1.0;
537  d_dummy2.d1_p = 0.0;
538  }
539 
540  MultDeriv(&d_tff, &d_dummy, &d_dummy2);
541  TimesDeriv(&d_tff, &d_tff, tf*xtf);
542  d_tff.value += tf;
543  }
544  else
545  {
546  EqualDeriv(&d_tff,&d_p);
547  d_tff.value = tf;
548  d_tff.d1_p = 0.0;
549  }
550 
551 
552 
553 
554  /* qbe = tff/qb*cbe */
555 
556 /*
557  dummy = tff/qb;
558  */
559  /* these are the cbe coeffs */
560 DivDeriv(&d_dummy, &d_tff, &d_qb);
561 MultDeriv(&d_qbe, &d_dummy, &d_cbe);
562 
563  }
564  else
565  {
566  EqualDeriv(&d_qbe, &d_p);
567  d_qbe.value = 0.0;
568  d_qbe.d1_p = 0.0;
569  }
570  if (vbe < fcpe) {
571  arg=1-vbe/pe;
572  sarg=exp(-xme*log(arg));
573  lcapbe1 = czbe*sarg;
574  lcapbe2 =
575  0.5*czbe*xme*sarg/(arg*pe);
576  lcapbe3 =
577  czbe*xme*(xme+1)*sarg/(arg*arg*pe*pe*6);
578  } else {
579  f1=here->BJTtf1;
580  f2=model->BJTf2;
581  f3=model->BJTf3;
582  czbef2=czbe/f2;
583  lcapbe1 = czbef2*(f3+xme*vbe/pe);
584  lcapbe2 = 0.5*xme*czbef2/pe;
585  lcapbe3 = 0.0;
586  }
587  d_qbe.d1_p += lcapbe1;
588  d_qbe.d2_p2 += lcapbe2*2.;
589  d_qbe.d3_p3 += lcapbe3*6.;
590 
591 
592  fcpc=here->BJTtf4;
593  f1=here->BJTtf5;
594  f2=model->BJTf6;
595  f3=model->BJTf7;
596  if (vbc < fcpc) {
597  arg=1-vbc/pc;
598  sarg=exp(-xmc*log(arg));
599  lcapbc1 = czbc*sarg;
600  lcapbc2 =
601  0.5*czbc*xmc*sarg/(arg*pc);
602  lcapbc3 =
603  czbc*xmc*(xmc+1)*sarg/(arg*arg*pc*pc*6);
604  } else {
605  czbcf2=czbc/f2;
606  lcapbc1 = czbcf2*(f3+xmc*vbc/pc);
607  lcapbc2 = 0.5*xmc*czbcf2/pc;
608  lcapbc3 = 0;
609  }
610  if(vbx < fcpc) {
611  arg=1-vbx/pc;
612  sarg=exp(-xmc*log(arg));
613  lcapbx1 = czbx*sarg;
614  lcapbx2 =
615  0.5*czbx*xmc*sarg/(arg*pc);
616  lcapbx3 =
617  czbx*xmc*(xmc+1)*sarg/(arg*arg*pc*pc*6);
618  } else {
619  czbxf2=czbx/f2;
620  lcapbx1 = czbxf2*(f3+xmc*vbx/pc);
621  lcapbx2 = 0.5*xmc*czbxf2/pc;
622  lcapbx3 = 0;
623  }
624  if(vsc < 0){
625  arg=1-vsc/ps;
626  sarg=exp(-xms*log(arg));
627  lcapsc1 = czcs*sarg;
628  lcapsc2 =
629  0.5*czcs*xms*sarg/(arg*ps);
630  lcapsc3 =
631  czcs*xms*(xms+1)*sarg/(arg*arg*ps*ps*6);
632  } else {
633  lcapsc1 = czcs*(1+xms*vsc/ps);
634  lcapsc2 = czcs*0.5*xms/ps;
635  lcapsc3 = 0;
636  }
637 
638  /*
639  * store small-signal parameters
640  */
641 here->ic_x = d_ic.d1_p;
642 here->ic_y = d_ic.d1_q;
643 here->ic_xd = d_ic.d1_r;
644 here->ic_x2 = 0.5*model->BJTtype*d_ic.d2_p2;
645 here->ic_y2 = 0.5*model->BJTtype*d_ic.d2_q2;
646 here->ic_w2 = 0.5*model->BJTtype*d_ic.d2_r2;
647 here->ic_xy = model->BJTtype*d_ic.d2_pq;
648 here->ic_yw = model->BJTtype*d_ic.d2_qr;
649 here->ic_xw = model->BJTtype*d_ic.d2_pr;
650 here->ic_x3 = d_ic.d3_p3/6.;
651 here->ic_y3 = d_ic.d3_q3/6.;
652 here->ic_w3 = d_ic.d3_r3/6.;
653 here->ic_x2w = 0.5*d_ic.d3_p2r;
654 here->ic_x2y = 0.5*d_ic.d3_p2q;
655 here->ic_y2w = 0.5*d_ic.d3_q2r;
656 here->ic_xy2 = 0.5*d_ic.d3_pq2;
657 here->ic_xw2 = 0.5*d_ic.d3_pr2;
658 here->ic_yw2 = 0.5*d_ic.d3_qr2;
659 here->ic_xyw = d_ic.d3_pqr;
660 
661 here->ib_x = d_ib.d1_p;
662 here->ib_y = d_ib.d1_q;
663 here->ib_x2 = 0.5*model->BJTtype*d_ib.d2_p2;
664 here->ib_y2 = 0.5*model->BJTtype*d_ib.d2_q2;
665 here->ib_xy = model->BJTtype*d_ib.d2_pq;
666 here->ib_x3 = d_ib.d3_p3/6.;
667 here->ib_y3 = d_ib.d3_q3/6.;
668 here->ib_x2y = 0.5*d_ib.d3_p2q;
669 here->ib_xy2 = 0.5*d_ib.d3_pq2;
670 
671 here->ibb_x = d_ibb.d1_p;
672 here->ibb_y = d_ibb.d1_q;
673 here->ibb_z = d_ibb.d1_r;
674 here->ibb_x2 = 0.5*model->BJTtype*d_ibb.d2_p2;
675 here->ibb_y2 = 0.5*model->BJTtype*d_ibb.d2_q2;
676 here->ibb_z2 = 0.5*model->BJTtype*d_ibb.d2_r2;
677 here->ibb_xy = model->BJTtype*d_ibb.d2_pq;
678 here->ibb_yz = model->BJTtype*d_ibb.d2_qr;
679 here->ibb_xz = model->BJTtype*d_ibb.d2_pr;
680 here->ibb_x3 = d_ibb.d3_p3/6.;
681 here->ibb_y3 = d_ibb.d3_q3/6.;
682 here->ibb_z3 = d_ibb.d3_r3/6.;
683 here->ibb_x2z = 0.5*d_ibb.d3_p2r;
684 here->ibb_x2y = 0.5*d_ibb.d3_p2q;
685 here->ibb_y2z = 0.5*d_ibb.d3_q2r;
686 here->ibb_xy2 = 0.5*d_ibb.d3_pq2;
687 here->ibb_xz2 = 0.5*d_ibb.d3_pr2;
688 here->ibb_yz2 = 0.5*d_ibb.d3_qr2;
689 here->ibb_xyz = d_ibb.d3_pqr;
690 
691 here->qbe_x = d_qbe.d1_p;
692 here->qbe_y = d_qbe.d1_q;
693 here->qbe_x2 = 0.5*model->BJTtype*d_qbe.d2_p2;
694 here->qbe_y2 = 0.5*model->BJTtype*d_qbe.d2_q2;
695 here->qbe_xy = model->BJTtype*d_qbe.d2_pq;
696 here->qbe_x3 = d_qbe.d3_p3/6.;
697 here->qbe_y3 = d_qbe.d3_q3/6.;
698 here->qbe_x2y = 0.5*d_qbe.d3_p2q;
699 here->qbe_xy2 = 0.5*d_qbe.d3_pq2;
700 
701 here->capbc1 = lcapbc1;
702 here->capbc2 = lcapbc2;
703 here->capbc3 = lcapbc3;
704 
705 here->capbx1 = lcapbx1;
706 here->capbx2 = lcapbx2;
707 here->capbx3 = lcapbx3;
708 
709 here->capsc1 = lcapsc1;
710 here->capsc2 = lcapsc2;
711 here->capsc3 = lcapsc3;
712  }
713  }
714  return(OK);
715  }
double d2_pr
Definition: distodef.h:75
double d3_pr2
Definition: distodef.h:83
int BJTdSetup(GENmodel *inModel, CKTcircuit *ckt)
Definition: bjtdset.c:26
BJTinstance * BJTinstances
Definition: bjtdefs.h:259
int BJTemitPrimeNode
Definition: bjtdefs.h:30
double BJTjunctionExpBC
Definition: bjtdefs.h:293
double BJTtBCleakCur
Definition: bjtdefs.h:40
double d3_pq2
Definition: distodef.h:81
double BJTbaseCurrentHalfResist
Definition: bjtdefs.h:279
double d3_p3
Definition: distodef.h:76
int BJTtype
Definition: bjtdefs.h:262
struct sBJTmodel * BJTnextModel
Definition: bjtdefs.h:257
#define MAX(a, b)
Definition: spdefs.h:135
double d1_q
Definition: distodef.h:68
double BJTtransitTimeR
Definition: bjtdefs.h:295
double d2_pq
Definition: distodef.h:73
double BJTtransitTimeHighCurrentF
Definition: bjtdefs.h:289
double BJTtBCcap
Definition: bjtdefs.h:43
if(TDesc==NULL)
Definition: cd.c:1326
static void dummy()
Definition: mfbcursr.c:550
double BJTemissionCoeffF
Definition: bjtdefs.h:267
double BJTf6
Definition: bjtdefs.h:316
void TanDeriv(Dderivs *new, Dderivs *old)
Definition: tanderiv.c:18
double BJTarea
Definition: bjtdefs.h:32
void PlusDeriv(Dderivs *new, Dderivs *old1, Dderivs *old2)
Definition: plusder.c:19
double BJTtf4
Definition: bjtdefs.h:47
double BJTemissionCoeffR
Definition: bjtdefs.h:273
static double e
Definition: vectors.c:17
double BJTjunctionExpBE
Definition: bjtdefs.h:285
double BJTtemp
Definition: bjtdefs.h:35
double d3_pqr
Definition: distodef.h:85
double BJTtSatCur
Definition: bjtdefs.h:36
double CONSTKoverQ
Definition: main.c:915
int BJTbasePrimeNode
Definition: bjtdefs.h:29
double d2_r2
Definition: distodef.h:72
double BJTtBEleakCur
Definition: bjtdefs.h:39
double BJTexponentialSubstrate
Definition: bjtdefs.h:298
void SqrtDeriv(Dderivs *new, Dderivs *old)
Definition: sqrtder.c:19
void MultDeriv(Dderivs *new, Dderivs *old1, Dderivs *old2)
Definition: multder.c:19
struct sBJTinstance * BJTnextInstance
Definition: bjtdefs.h:20
#define OK
Definition: iferrmsg.h:17
double * CKTrhsOld
Definition: cktdefs.h:98
void ExpDeriv(Dderivs *new, Dderivs *old)
Definition: expderiv.c:19
double BJTtBetaR
Definition: bjtdefs.h:38
double BJTpotentialSubstrate
Definition: bjtdefs.h:297
double d3_p2r
Definition: distodef.h:80
int BJTcolPrimeNode
Definition: bjtdefs.h:28
double BJTtf1
Definition: bjtdefs.h:46
double d2_qr
Definition: distodef.h:74
#define NULL
Definition: spdefs.h:121
double BJTtransitTimeVBCFactor
Definition: bjtdefs.h:312
double BJTleakBEemissionCoeff
Definition: bjtdefs.h:271
double d1_r
Definition: distodef.h:69
double BJTtransitTimeF
Definition: bjtdefs.h:286
double d1_p
Definition: distodef.h:67
double d3_qr2
Definition: distodef.h:84
double d3_q3
Definition: distodef.h:77
double BJTinvEarlyVoltR
Definition: bjtdefs.h:307
double BJTtBEcap
Definition: bjtdefs.h:41
double BJTtransitTimeBiasCoeffF
Definition: bjtdefs.h:287
void DivDeriv(Dderivs *new, Dderivs *old1, Dderivs *old2)
Definition: divderiv.c:19
int BJTbaseNode
Definition: bjtdefs.h:25
double BJTinvEarlyVoltF
Definition: bjtdefs.h:306
double BJTtBCpot
Definition: bjtdefs.h:44
double BJTtDepCap
Definition: bjtdefs.h:45
int BJTsubstNode
Definition: bjtdefs.h:27
void TimesDeriv(Dderivs *new, Dderivs *old, double k)
Definition: timesder.c:19
static char model[32]
Definition: subckt.c:76
double BJTbaseResist
Definition: bjtdefs.h:278
double BJTtBEpot
Definition: bjtdefs.h:42
double BJTf7
Definition: bjtdefs.h:317
double d3_q2r
Definition: distodef.h:82
double BJTtBetaF
Definition: bjtdefs.h:37
double value
Definition: distodef.h:66
double CKTgmin
Definition: cktdefs.h:190
double d3_r3
Definition: distodef.h:78
double BJTf3
Definition: bjtdefs.h:315
struct mfbpc pc
Definition: mfbopen.c:14
double BJTleakBCemissionCoeff
Definition: bjtdefs.h:277
double d3_p2q
Definition: distodef.h:79
double d2_q2
Definition: distodef.h:71
double BJTf2
Definition: bjtdefs.h:314
double BJTtf5
Definition: bjtdefs.h:48
double BJTinvRollOffF
Definition: bjtdefs.h:308
void InvDeriv(Dderivs *new, Dderivs *old)
Definition: invderiv.c:19
double BJTminBaseResist
Definition: bjtdefs.h:280
double BJTinvRollOffR
Definition: bjtdefs.h:309
double d2_p2
Definition: distodef.h:70
double BJTbaseFractionBCcap
Definition: bjtdefs.h:294
void EqualDeriv(Dderivs *new, Dderivs *old)
Definition: equalder.c:17
double BJTcapCS
Definition: bjtdefs.h:296