1 /* ******************************************************************************
2 * BSIM4 4.8.1 released by Chetan Kumar Dabhi 2/15/2017 *
3 * BSIM4 Model Equations *
4 ******************************************************************************
5
6 ******************************************************************************
7 * Copyright 2017 Regents of the University of California. *
8 * All rights reserved. *
9 * *
10 * Project Director: Prof. Chenming Hu. *
11 * Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
12 * Ali Niknejad, Shivendra Singh Parihar, Chetan Kumar Dabhi *
13 * Yogesh Singh Chauhan, Sayeef Salahuddin, Chenming Hu *
14 ******************************************************************************
15
16 ******************************************************************************
17 * CMC In-Code Statement *
18 * *
19 * The Developer agrees that the following statement will appear in the *
20 * model code that has been adopted as a CMC Standard. *
21 * *
22 * Software is distributed as is, completely without warranty or service *
23 * support. The University of California and its employees are not liable *
24 * for the condition or performance of the software. *
25 * *
26 * The University of California owns the copyright and grants users a *
27 * perpetual, irrevocable, worldwide, non-exclusive, royalty-free license *
28 * with respect to the software as set forth below. *
29 * *
30 * The University of California hereby disclaims all implied warranties. *
31 * *
32 * The University of California grants the users the right to modify, *
33 * copy, and redistribute the software and documentation, both within *
34 * the user's organization and externally, subject to the following *
35 * restrictions: *
36 * *
37 * 1. The users agree not to charge for the University of California code *
38 * itself but may charge for additions, extensions, or support. *
39 * *
40 * 2. In any product based on the software, the users agree to *
41 * acknowledge the University of California that developed the *
42 * software. This acknowledgment shall appear in the product *
43 * documentation. *
44 * *
45 * 3. Redistributions to others of source code and documentation must *
46 * retain the copyright notice, disclaimer, and list of conditions. *
47 * *
48 * 4. Redistributions to others in binary form must reproduce the *
49 * copyright notice, disclaimer, and list of conditions in the *
50 * documentation and/or other materials provided with the *
51 * distribution. *
52 * *
53 * Agreed to on ______Feb. 15, 2017______________ *
54 * *
55 * By: ____University of California, Berkeley___ *
56 * ____Chenming Hu__________________________ *
57 * ____Professor in Graduate School ________ *
58 * *
59 ****************************************************************************** */
60
61 /**** OpenMP support ngspice 06/28/2010 ****/
62
63 #include "ngspice/ngspice.h"
64 #include "ngspice/cktdefs.h"
65 #include "bsim4def.h"
66 #include "ngspice/trandefs.h"
67 #include "ngspice/const.h"
68 #include "ngspice/sperror.h"
69 #include "ngspice/devdefs.h"
70 #include "ngspice/suffix.h"
71
72 #define MAX_EXPL 2.688117142e+43
73 #define MIN_EXPL 3.720075976e-44
74 #define EXPL_THRESHOLD 100.0
75
76 #define MAX_EXP 5.834617425e14
77 #define MIN_EXP 1.713908431e-15
78 #define EXP_THRESHOLD 34.0
79 #define EPS0 8.85418e-12
80 #define EPSSI 1.03594e-10
81 #define Charge_q 1.60219e-19
82 #define DELTA_1 0.02
83 #define DELTA_2 0.02
84 #define DELTA_3 0.02
85 #define DELTA_4 0.02
86 #define MM 3 /* smooth coeff */
87 #define DEXP(A,B,C) { \
88 if (A > EXP_THRESHOLD) { \
89 B = MAX_EXP*(1.0+(A)-EXP_THRESHOLD); \
90 C = MAX_EXP; \
91 } else if (A < -EXP_THRESHOLD) { \
92 B = MIN_EXP; \
93 C = 0; \
94 } else { \
95 B = exp(A); \
96 C = B; \
97 } \
98 }
99
100 #ifdef USE_OMP
101 int BSIM4LoadOMP(BSIM4instance *here, CKTcircuit *ckt);
102 void BSIM4LoadRhsMat(GENmodel *inModel, CKTcircuit *ckt);
103 #endif
104
105 int BSIM4polyDepletion(double phi, double ngate,double epsgate, double coxe, double Vgs, double *Vgs_eff, double *dVgs_eff_dVg);
106
107 int
BSIM4load(GENmodel * inModel,CKTcircuit * ckt)108 BSIM4load(
109 GENmodel *inModel,
110 CKTcircuit *ckt)
111 {
112 #ifdef USE_OMP
113 int idx;
114 BSIM4model *model = (BSIM4model*)inModel;
115 int error = 0;
116 BSIM4instance **InstArray;
117 InstArray = model->BSIM4InstanceArray;
118
119 #pragma omp parallel for
120 for (idx = 0; idx < model->BSIM4InstCount; idx++) {
121 BSIM4instance *here = InstArray[idx];
122 int local_error = BSIM4LoadOMP(here, ckt);
123 if (local_error)
124 error = local_error;
125 }
126
127 BSIM4LoadRhsMat(inModel, ckt);
128
129 return error;
130 }
131
132
BSIM4LoadOMP(BSIM4instance * here,CKTcircuit * ckt)133 int BSIM4LoadOMP(BSIM4instance *here, CKTcircuit *ckt) {
134 BSIM4model *model = BSIM4modPtr(here);
135 #else
136 BSIM4model *model = (BSIM4model*)inModel;
137 BSIM4instance *here;
138 #endif
139 double ceqgstot, dgstot_dvd, dgstot_dvg, dgstot_dvs, dgstot_dvb;
140 double ceqgdtot, dgdtot_dvd, dgdtot_dvg, dgdtot_dvs, dgdtot_dvb;
141 double gstot, gstotd, gstotg, gstots, gstotb, gspr, Rs, Rd;
142 double gdtot, gdtotd, gdtotg, gdtots, gdtotb, gdpr;
143 double vgs_eff, vgd_eff, dvgs_eff_dvg, dvgd_eff_dvg;
144 double dRs_dvg, dRd_dvg, dRs_dvb, dRd_dvb;
145 double dT0_dvg, dT1_dvb, dT3_dvg, dT3_dvb;
146 double vses, vdes, vdedo, delvses, delvded, delvdes;
147 double Isestot, cseshat, Idedtot, cdedhat;
148 #ifndef NEWCONV
149 double tol0, tol1, tol2, tol3, tol4, tol5, tol6;
150 #endif
151
152 double geltd, gcrg, gcrgg, gcrgd, gcrgs, gcrgb, ceqgcrg;
153 double vges, vgms, vgedo, vgmdo, vged, vgmd, delvged, delvgmd;
154 double delvges, delvgms, vgmb;
155 double gcgmgmb=0.0, gcgmdb=0.0, gcgmsb=0.0, gcdgmb, gcsgmb;
156 double gcgmbb=0.0, gcbgmb, qgmb, qgmid=0.0, ceqqgmid;
157
158 double vbd, vbs, vds, vgb, vgd, vgs, vgdo;
159 #ifndef PREDICTOR
160 double xfact;
161 #endif
162 double vdbs, vdbd, vsbs, vsbdo, vsbd;
163 double delvdbs, delvdbd, delvsbs;
164 double delvbd_jct, delvbs_jct, vbs_jct, vbd_jct;
165
166 double SourceSatCurrent, DrainSatCurrent;
167 double ag0, qgb, von, cbhat, VgstNVt, ExpVgst;
168 double ceqqb, ceqqd, ceqqg, ceqqjd=0.0, ceqqjs=0.0, ceq, geq;
169 double cdrain, cdhat, ceqdrn, ceqbd, ceqbs, ceqjd, ceqjs, gjbd, gjbs;
170 double czbd, czbdsw, czbdswg, czbs, czbssw, czbsswg, evbd, evbs, arg, sarg;
171 double delvbd, delvbs, delvds, delvgd, delvgs;
172 double Vfbeff, dVfbeff_dVg, dVfbeff_dVb, V3, V4;
173 double gcbdb, gcbgb, gcbsb, gcddb, gcdgb, gcdsb, gcgdb, gcggb, gcgsb, gcsdb;
174 double gcgbb, gcdbb, gcsbb, gcbbb;
175 double gcdbdb, gcsbsb;
176 double gcsgb, gcssb, MJD, MJSWD, MJSWGD, MJS, MJSWS, MJSWGS;
177 double qgate=0.0, qbulk=0.0, qdrn=0.0, qsrc, cqgate, cqbody, cqdrn;
178 double Vdb, Vds, Vgs, Vbs, Gmbs, FwdSum, RevSum;
179 double Igidl, Ggidld, Ggidlg, Ggidlb;
180 double Voxacc=0.0, dVoxacc_dVg=0.0, dVoxacc_dVb=0.0;
181 double Voxdepinv=0.0, dVoxdepinv_dVg=0.0, dVoxdepinv_dVd=0.0, dVoxdepinv_dVb=0.0;
182 double VxNVt=0.0, ExpVxNVt, Vaux=0.0, dVaux_dVg=0.0, dVaux_dVd=0.0, dVaux_dVb=0.0;
183 double Igc, dIgc_dVg, dIgc_dVd, dIgc_dVb;
184 double Igcs, dIgcs_dVg, dIgcs_dVd, dIgcs_dVb;
185 double Igcd, dIgcd_dVg, dIgcd_dVd, dIgcd_dVb;
186 double Igs, dIgs_dVg, dIgs_dVs, Igd, dIgd_dVg, dIgd_dVd;
187 double Igbacc, dIgbacc_dVg, dIgbacc_dVb;
188 double Igbinv, dIgbinv_dVg, dIgbinv_dVd, dIgbinv_dVb;
189 double Pigcd, dPigcd_dVg, dPigcd_dVd, dPigcd_dVb;
190 double Istoteq, gIstotg, gIstotd, gIstots, gIstotb;
191 double Idtoteq, gIdtotg, gIdtotd, gIdtots, gIdtotb;
192 double Ibtoteq, gIbtotg, gIbtotd, gIbtots, gIbtotb;
193 double Igtoteq, gIgtotg, gIgtotd, gIgtots, gIgtotb;
194 double Igstot, cgshat, Igdtot, cgdhat, Igbtot, cgbhat;
195 double Vgs_eff, Vfb=0.0, Vth_NarrowW;
196 /* double Vgd_eff, dVgd_eff_dVg; v4.7.0 */
197 double Phis, dPhis_dVb, sqrtPhis, dsqrtPhis_dVb, Vth, dVth_dVb, dVth_dVd;
198 double Vgst, dVgst_dVg, dVgst_dVb, dVgs_eff_dVg, Nvtms, Nvtmd;
199 double Vtm, Vtm0;
200 double n, dn_dVb, dn_dVd, voffcv, noff, dnoff_dVd, dnoff_dVb;
201 double V0, CoxWLcen, QovCox, LINK;
202 double DeltaPhi, dDeltaPhi_dVg, VgDP, dVgDP_dVg;
203 double Cox, Tox, Tcen, dTcen_dVg, dTcen_dVd, dTcen_dVb;
204 double Ccen, Coxeff, dCoxeff_dVd, dCoxeff_dVg, dCoxeff_dVb;
205 double Denomi, dDenomi_dVg, dDenomi_dVd, dDenomi_dVb;
206 double ueff, dueff_dVg, dueff_dVd, dueff_dVb;
207 double Esat, Vdsat;
208 double EsatL, dEsatL_dVg, dEsatL_dVd, dEsatL_dVb;
209 double dVdsat_dVg, dVdsat_dVb, dVdsat_dVd, Vasat, dAlphaz_dVg, dAlphaz_dVb;
210 double dVasat_dVg, dVasat_dVb, dVasat_dVd, Va, dVa_dVd, dVa_dVg, dVa_dVb;
211 double Vbseff, dVbseff_dVb, VbseffCV, dVbseffCV_dVb;
212 double VgsteffVth, dT11_dVg;
213 double Arg1, One_Third_CoxWL, Two_Third_CoxWL, Alphaz, CoxWL;
214 double T0=0.0, dT0_dVg, dT0_dVd, dT0_dVb;
215 double T1, dT1_dVg, dT1_dVd, dT1_dVb;
216 double T2, dT2_dVg, dT2_dVd, dT2_dVb;
217 double T3, dT3_dVg, dT3_dVd, dT3_dVb;
218 double T4, dT4_dVd, dT4_dVb;
219 double T5, dT5_dVg, dT5_dVd, dT5_dVb;
220 double T6, dT6_dVg, dT6_dVd, dT6_dVb;
221 double T7, dT7_dVg, dT7_dVd, dT7_dVb;
222 double T8, dT8_dVg, dT8_dVd, dT8_dVb;
223 double T9, dT9_dVg, dT9_dVd, dT9_dVb;
224 double T10, dT10_dVg, dT10_dVb, dT10_dVd;
225 double T11, T12, T13, T14;
226 double tmp, Abulk, dAbulk_dVb, Abulk0, dAbulk0_dVb;
227 double Cclm, dCclm_dVg, dCclm_dVd, dCclm_dVb;
228 double FP, dFP_dVg, PvagTerm, dPvagTerm_dVg, dPvagTerm_dVd, dPvagTerm_dVb;
229 double VADITS, dVADITS_dVg, dVADITS_dVd;
230 double Lpe_Vb, dDITS_Sft_dVb, dDITS_Sft_dVd;
231 double DITS_Sft2, dDITS_Sft2_dVd; /* v4.7 New DITS */
232 double VACLM, dVACLM_dVg, dVACLM_dVd, dVACLM_dVb;
233 double VADIBL, dVADIBL_dVg, dVADIBL_dVd, dVADIBL_dVb;
234 double Xdep, dXdep_dVb, lt1, dlt1_dVb, ltw, dltw_dVb, Delt_vth, dDelt_vth_dVb;
235 double Theta0, dTheta0_dVb;
236 double TempRatio, tmp1, tmp2, tmp3, tmp4;
237 double DIBL_Sft, dDIBL_Sft_dVd, Lambda, dLambda_dVg;
238 double Idtot, Ibtot, a1, ScalingFactor;
239
240 double Vgsteff, dVgsteff_dVg, dVgsteff_dVd, dVgsteff_dVb;
241 double Vdseff, dVdseff_dVg, dVdseff_dVd, dVdseff_dVb;
242 double VdseffCV, dVdseffCV_dVg, dVdseffCV_dVd, dVdseffCV_dVb;
243 double diffVds, dAbulk_dVg;
244 double beta, dbeta_dVg, dbeta_dVd, dbeta_dVb;
245 double gche, dgche_dVg, dgche_dVd, dgche_dVb;
246 double fgche1, dfgche1_dVg, dfgche1_dVd, dfgche1_dVb;
247 double fgche2, dfgche2_dVg, dfgche2_dVd, dfgche2_dVb;
248 double Idl, dIdl_dVg, dIdl_dVd, dIdl_dVb;
249 double Idsa, dIdsa_dVg, dIdsa_dVd, dIdsa_dVb;
250 double Ids, Gm, Gds, Gmb, devbs_dvb, devbd_dvb;
251 double Isub, Gbd, Gbg, Gbb;
252 double VASCBE, dVASCBE_dVg, dVASCBE_dVd, dVASCBE_dVb;
253 double CoxeffWovL;
254 double Rds, dRds_dVg, dRds_dVb, WVCox, WVCoxRds;
255 double Vgst2Vtm, VdsatCV;
256 double Leff, Weff, dWeff_dVg, dWeff_dVb;
257 double AbulkCV, dAbulkCV_dVb;
258 double qcheq, qdef, gqdef=0.0, cqdef=0.0, cqcheq=0.0;
259 double gcqdb=0.0, gcqsb=0.0, gcqgb=0.0, gcqbb=0.0;
260 double dxpart, sxpart, ggtg, ggtd, ggts, ggtb;
261 double ddxpart_dVd, ddxpart_dVg, ddxpart_dVb, ddxpart_dVs;
262 double dsxpart_dVd, dsxpart_dVg, dsxpart_dVb, dsxpart_dVs;
263 double gbspsp, gbbdp, gbbsp, gbspg, gbspb, gbspdp;
264 double gbdpdp, gbdpg, gbdpb, gbdpsp;
265 double qgdo, qgso, cgdo, cgso;
266 double Cgg, Cgd, Cgb, Cdg, Cdd, Cds;
267 double Csg, Csd, Css, Csb, Cbg, Cbd, Cbb;
268 double Cgg1, Cgd1, Cgb1, Cbg1, Cbb1, Cbd1, Qac0, Qsub0;
269 double dQac0_dVg, dQac0_dVb, dQsub0_dVg, dQsub0_dVd, dQsub0_dVb;
270 double ggidld, ggidlg, ggidlb, ggislg, ggislb, ggisls;
271 double Igisl, Ggislg, Ggislb, Ggisls;
272 double Nvtmrss, Nvtmrssws, Nvtmrsswgs;
273 double Nvtmrsd, Nvtmrsswd, Nvtmrsswgd;
274
275 double vs, Fsevl, dvs_dVg, dvs_dVd, dvs_dVb, dFsevl_dVg, dFsevl_dVd, dFsevl_dVb;
276 double vgdx, vgsx, epssub, toxe, epsrox;
277 struct bsim4SizeDependParam *pParam;
278 int ByPass, ChargeComputationNeeded, error, Check, Check1, Check2;
279
280 double m;
281
282 ScalingFactor = 1.0e-9;
283 ChargeComputationNeeded =
284 ((ckt->CKTmode & (MODEDCTRANCURVE | MODEAC | MODETRAN | MODEINITSMSIG)) ||
285 ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)))
286 ? 1 : 0;
287
288 #ifndef USE_OMP
289 for (; model != NULL; model = BSIM4nextModel(model))
290 { for (here = BSIM4instances(model); here != NULL;
291 here = BSIM4nextInstance(here))
292 {
293 #endif
294
295 Check = Check1 = Check2 = 1;
296 ByPass = 0;
297 pParam = here->pParam;
298
299 if ((ckt->CKTmode & MODEINITSMSIG))
300 { vds = *(ckt->CKTstate0 + here->BSIM4vds);
301 vgs = *(ckt->CKTstate0 + here->BSIM4vgs);
302 vbs = *(ckt->CKTstate0 + here->BSIM4vbs);
303 vges = *(ckt->CKTstate0 + here->BSIM4vges);
304 vgms = *(ckt->CKTstate0 + here->BSIM4vgms);
305 vdbs = *(ckt->CKTstate0 + here->BSIM4vdbs);
306 vsbs = *(ckt->CKTstate0 + here->BSIM4vsbs);
307 vses = *(ckt->CKTstate0 + here->BSIM4vses);
308 vdes = *(ckt->CKTstate0 + here->BSIM4vdes);
309
310 qdef = *(ckt->CKTstate0 + here->BSIM4qdef);
311 }
312 else if ((ckt->CKTmode & MODEINITTRAN))
313 { vds = *(ckt->CKTstate1 + here->BSIM4vds);
314 vgs = *(ckt->CKTstate1 + here->BSIM4vgs);
315 vbs = *(ckt->CKTstate1 + here->BSIM4vbs);
316 vges = *(ckt->CKTstate1 + here->BSIM4vges);
317 vgms = *(ckt->CKTstate1 + here->BSIM4vgms);
318 vdbs = *(ckt->CKTstate1 + here->BSIM4vdbs);
319 vsbs = *(ckt->CKTstate1 + here->BSIM4vsbs);
320 vses = *(ckt->CKTstate1 + here->BSIM4vses);
321 vdes = *(ckt->CKTstate1 + here->BSIM4vdes);
322
323 qdef = *(ckt->CKTstate1 + here->BSIM4qdef);
324 }
325 else if ((ckt->CKTmode & MODEINITJCT) && !here->BSIM4off)
326 { vds = model->BSIM4type * here->BSIM4icVDS;
327 vgs = vges = vgms = model->BSIM4type * here->BSIM4icVGS;
328 vbs = vdbs = vsbs = model->BSIM4type * here->BSIM4icVBS;
329 if (vds > 0.0)
330 { vdes = vds + 0.01;
331 vses = -0.01;
332 }
333 else if (vds < 0.0)
334 { vdes = vds - 0.01;
335 vses = 0.01;
336 }
337 else
338 vdes = vses = 0.0;
339
340 qdef = 0.0;
341
342 if ((vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) &&
343 ((ckt->CKTmode & (MODETRAN | MODEAC|MODEDCOP |
344 MODEDCTRANCURVE)) || (!(ckt->CKTmode & MODEUIC))))
345 { vds = 0.1;
346 vdes = 0.11;
347 vses = -0.01;
348 vgs = vges = vgms = model->BSIM4type
349 * here->BSIM4vth0 + 0.1;
350 vbs = vdbs = vsbs = 0.0;
351 }
352 }
353 else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) &&
354 (here->BSIM4off))
355 { vds = vgs = vbs = vges = vgms = 0.0;
356 vdbs = vsbs = vdes = vses = qdef = 0.0;
357 }
358 else
359 {
360 #ifndef PREDICTOR
361 if ((ckt->CKTmode & MODEINITPRED))
362 { xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1];
363 *(ckt->CKTstate0 + here->BSIM4vds) =
364 *(ckt->CKTstate1 + here->BSIM4vds);
365 vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vds))
366 - (xfact * (*(ckt->CKTstate2 + here->BSIM4vds)));
367 *(ckt->CKTstate0 + here->BSIM4vgs) =
368 *(ckt->CKTstate1 + here->BSIM4vgs);
369 vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vgs))
370 - (xfact * (*(ckt->CKTstate2 + here->BSIM4vgs)));
371 *(ckt->CKTstate0 + here->BSIM4vges) =
372 *(ckt->CKTstate1 + here->BSIM4vges);
373 vges = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vges))
374 - (xfact * (*(ckt->CKTstate2 + here->BSIM4vges)));
375 *(ckt->CKTstate0 + here->BSIM4vgms) =
376 *(ckt->CKTstate1 + here->BSIM4vgms);
377 vgms = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vgms))
378 - (xfact * (*(ckt->CKTstate2 + here->BSIM4vgms)));
379 *(ckt->CKTstate0 + here->BSIM4vbs) =
380 *(ckt->CKTstate1 + here->BSIM4vbs);
381 vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vbs))
382 - (xfact * (*(ckt->CKTstate2 + here->BSIM4vbs)));
383 *(ckt->CKTstate0 + here->BSIM4vbd) =
384 *(ckt->CKTstate0 + here->BSIM4vbs)
385 - *(ckt->CKTstate0 + here->BSIM4vds);
386 *(ckt->CKTstate0 + here->BSIM4vdbs) =
387 *(ckt->CKTstate1 + here->BSIM4vdbs);
388 vdbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vdbs))
389 - (xfact * (*(ckt->CKTstate2 + here->BSIM4vdbs)));
390 *(ckt->CKTstate0 + here->BSIM4vdbd) =
391 *(ckt->CKTstate0 + here->BSIM4vdbs)
392 - *(ckt->CKTstate0 + here->BSIM4vds);
393 *(ckt->CKTstate0 + here->BSIM4vsbs) =
394 *(ckt->CKTstate1 + here->BSIM4vsbs);
395 vsbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vsbs))
396 - (xfact * (*(ckt->CKTstate2 + here->BSIM4vsbs)));
397 *(ckt->CKTstate0 + here->BSIM4vses) =
398 *(ckt->CKTstate1 + here->BSIM4vses);
399 vses = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vses))
400 - (xfact * (*(ckt->CKTstate2 + here->BSIM4vses)));
401 *(ckt->CKTstate0 + here->BSIM4vdes) =
402 *(ckt->CKTstate1 + here->BSIM4vdes);
403 vdes = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vdes))
404 - (xfact * (*(ckt->CKTstate2 + here->BSIM4vdes)));
405
406 *(ckt->CKTstate0 + here->BSIM4qdef) =
407 *(ckt->CKTstate1 + here->BSIM4qdef);
408 qdef = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4qdef))
409 -(xfact * (*(ckt->CKTstate2 + here->BSIM4qdef)));
410 }
411 else
412 {
413 #endif /* PREDICTOR */
414 vds = model->BSIM4type
415 * (*(ckt->CKTrhsOld + here->BSIM4dNodePrime)
416 - *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
417 vgs = model->BSIM4type
418 * (*(ckt->CKTrhsOld + here->BSIM4gNodePrime)
419 - *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
420 vbs = model->BSIM4type
421 * (*(ckt->CKTrhsOld + here->BSIM4bNodePrime)
422 - *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
423 vges = model->BSIM4type
424 * (*(ckt->CKTrhsOld + here->BSIM4gNodeExt)
425 - *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
426 vgms = model->BSIM4type
427 * (*(ckt->CKTrhsOld + here->BSIM4gNodeMid)
428 - *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
429 vdbs = model->BSIM4type
430 * (*(ckt->CKTrhsOld + here->BSIM4dbNode)
431 - *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
432 vsbs = model->BSIM4type
433 * (*(ckt->CKTrhsOld + here->BSIM4sbNode)
434 - *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
435 vses = model->BSIM4type
436 * (*(ckt->CKTrhsOld + here->BSIM4sNode)
437 - *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
438 vdes = model->BSIM4type
439 * (*(ckt->CKTrhsOld + here->BSIM4dNode)
440 - *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
441 qdef = model->BSIM4type
442 * (*(ckt->CKTrhsOld + here->BSIM4qNode));
443 #ifndef PREDICTOR
444 }
445 #endif /* PREDICTOR */
446
447 vgdo = *(ckt->CKTstate0 + here->BSIM4vgs)
448 - *(ckt->CKTstate0 + here->BSIM4vds);
449 vgedo = *(ckt->CKTstate0 + here->BSIM4vges)
450 - *(ckt->CKTstate0 + here->BSIM4vds);
451 vgmdo = *(ckt->CKTstate0 + here->BSIM4vgms)
452 - *(ckt->CKTstate0 + here->BSIM4vds);
453
454 vbd = vbs - vds;
455 vdbd = vdbs - vds;
456 vgd = vgs - vds;
457 vged = vges - vds;
458 vgmd = vgms - vds;
459
460 delvbd = vbd - *(ckt->CKTstate0 + here->BSIM4vbd);
461 delvdbd = vdbd - *(ckt->CKTstate0 + here->BSIM4vdbd);
462 delvgd = vgd - vgdo;
463 delvged = vged - vgedo;
464 delvgmd = vgmd - vgmdo;
465
466 delvds = vds - *(ckt->CKTstate0 + here->BSIM4vds);
467 delvgs = vgs - *(ckt->CKTstate0 + here->BSIM4vgs);
468 delvges = vges - *(ckt->CKTstate0 + here->BSIM4vges);
469 delvgms = vgms - *(ckt->CKTstate0 + here->BSIM4vgms);
470 delvbs = vbs - *(ckt->CKTstate0 + here->BSIM4vbs);
471 delvdbs = vdbs - *(ckt->CKTstate0 + here->BSIM4vdbs);
472 delvsbs = vsbs - *(ckt->CKTstate0 + here->BSIM4vsbs);
473
474 delvses = vses - (*(ckt->CKTstate0 + here->BSIM4vses));
475 vdedo = *(ckt->CKTstate0 + here->BSIM4vdes)
476 - *(ckt->CKTstate0 + here->BSIM4vds);
477 delvdes = vdes - *(ckt->CKTstate0 + here->BSIM4vdes);
478 delvded = vdes - vds - vdedo;
479
480 delvbd_jct = (!here->BSIM4rbodyMod) ? delvbd : delvdbd;
481 delvbs_jct = (!here->BSIM4rbodyMod) ? delvbs : delvsbs;
482 if (here->BSIM4mode >= 0)
483 { Idtot = here->BSIM4cd + here->BSIM4csub - here->BSIM4cbd
484 + here->BSIM4Igidl;
485 cdhat = Idtot - here->BSIM4gbd * delvbd_jct
486 + (here->BSIM4gmbs + here->BSIM4gbbs + here->BSIM4ggidlb) * delvbs
487 + (here->BSIM4gm + here->BSIM4gbgs + here->BSIM4ggidlg) * delvgs
488 + (here->BSIM4gds + here->BSIM4gbds + here->BSIM4ggidld) * delvds;
489 Ibtot = here->BSIM4cbs + here->BSIM4cbd
490 - here->BSIM4Igidl - here->BSIM4Igisl - here->BSIM4csub;
491 cbhat = Ibtot + here->BSIM4gbd * delvbd_jct
492 + here->BSIM4gbs * delvbs_jct - (here->BSIM4gbbs + here->BSIM4ggidlb)
493 * delvbs - (here->BSIM4gbgs + here->BSIM4ggidlg) * delvgs
494 - (here->BSIM4gbds + here->BSIM4ggidld - here->BSIM4ggisls) * delvds
495 - here->BSIM4ggislg * delvgd - here->BSIM4ggislb* delvbd;
496
497 Igstot = here->BSIM4Igs + here->BSIM4Igcs;
498 cgshat = Igstot + (here->BSIM4gIgsg + here->BSIM4gIgcsg) * delvgs
499 + here->BSIM4gIgcsd * delvds + here->BSIM4gIgcsb * delvbs;
500
501 Igdtot = here->BSIM4Igd + here->BSIM4Igcd;
502 cgdhat = Igdtot + here->BSIM4gIgdg * delvgd + here->BSIM4gIgcdg * delvgs
503 + here->BSIM4gIgcdd * delvds + here->BSIM4gIgcdb * delvbs;
504
505 Igbtot = here->BSIM4Igb;
506 cgbhat = here->BSIM4Igb + here->BSIM4gIgbg * delvgs + here->BSIM4gIgbd
507 * delvds + here->BSIM4gIgbb * delvbs;
508 }
509 else
510 { Idtot = here->BSIM4cd + here->BSIM4cbd - here->BSIM4Igidl; /* bugfix */
511 cdhat = Idtot + here->BSIM4gbd * delvbd_jct + here->BSIM4gmbs
512 * delvbd + here->BSIM4gm * delvgd
513 - (here->BSIM4gds + here->BSIM4ggidls) * delvds
514 - here->BSIM4ggidlg * delvgs - here->BSIM4ggidlb * delvbs;
515 Ibtot = here->BSIM4cbs + here->BSIM4cbd
516 - here->BSIM4Igidl - here->BSIM4Igisl - here->BSIM4csub;
517 cbhat = Ibtot + here->BSIM4gbs * delvbs_jct + here->BSIM4gbd
518 * delvbd_jct - (here->BSIM4gbbs + here->BSIM4ggislb) * delvbd
519 - (here->BSIM4gbgs + here->BSIM4ggislg) * delvgd
520 + (here->BSIM4gbds + here->BSIM4ggisld - here->BSIM4ggidls) * delvds
521 - here->BSIM4ggidlg * delvgs - here->BSIM4ggidlb * delvbs;
522
523 Igstot = here->BSIM4Igs + here->BSIM4Igcd;
524 cgshat = Igstot + here->BSIM4gIgsg * delvgs + here->BSIM4gIgcdg * delvgd
525 - here->BSIM4gIgcdd * delvds + here->BSIM4gIgcdb * delvbd;
526
527 Igdtot = here->BSIM4Igd + here->BSIM4Igcs;
528 cgdhat = Igdtot + (here->BSIM4gIgdg + here->BSIM4gIgcsg) * delvgd
529 - here->BSIM4gIgcsd * delvds + here->BSIM4gIgcsb * delvbd;
530
531 Igbtot = here->BSIM4Igb;
532 cgbhat = here->BSIM4Igb + here->BSIM4gIgbg * delvgd - here->BSIM4gIgbd
533 * delvds + here->BSIM4gIgbb * delvbd;
534 }
535
536 Isestot = here->BSIM4gstot * (*(ckt->CKTstate0 + here->BSIM4vses));
537 cseshat = Isestot + here->BSIM4gstot * delvses
538 + here->BSIM4gstotd * delvds + here->BSIM4gstotg * delvgs
539 + here->BSIM4gstotb * delvbs;
540
541 Idedtot = here->BSIM4gdtot * vdedo;
542 cdedhat = Idedtot + here->BSIM4gdtot * delvded
543 + here->BSIM4gdtotd * delvds + here->BSIM4gdtotg * delvgs
544 + here->BSIM4gdtotb * delvbs;
545
546
547 #ifndef NOBYPASS
548 /* Following should be one IF statement, but some C compilers
549 * can't handle that all at once, so we split it into several
550 * successive IF's */
551
552 if ((!(ckt->CKTmode & MODEINITPRED)) && (ckt->CKTbypass))
553 if ((fabs(delvds) < (ckt->CKTreltol * MAX(fabs(vds),
554 fabs(*(ckt->CKTstate0 + here->BSIM4vds))) + ckt->CKTvoltTol)))
555 if ((fabs(delvgs) < (ckt->CKTreltol * MAX(fabs(vgs),
556 fabs(*(ckt->CKTstate0 + here->BSIM4vgs))) + ckt->CKTvoltTol)))
557 if ((fabs(delvbs) < (ckt->CKTreltol * MAX(fabs(vbs),
558 fabs(*(ckt->CKTstate0 + here->BSIM4vbs))) + ckt->CKTvoltTol)))
559 if ((fabs(delvbd) < (ckt->CKTreltol * MAX(fabs(vbd),
560 fabs(*(ckt->CKTstate0 + here->BSIM4vbd))) + ckt->CKTvoltTol)))
561 if ((here->BSIM4rgateMod == 0) || (here->BSIM4rgateMod == 1)
562 || (fabs(delvges) < (ckt->CKTreltol * MAX(fabs(vges),
563 fabs(*(ckt->CKTstate0 + here->BSIM4vges))) + ckt->CKTvoltTol)))
564 if ((here->BSIM4rgateMod != 3) || (fabs(delvgms) < (ckt->CKTreltol
565 * MAX(fabs(vgms), fabs(*(ckt->CKTstate0 + here->BSIM4vgms)))
566 + ckt->CKTvoltTol)))
567 if ((!here->BSIM4rbodyMod) || (fabs(delvdbs) < (ckt->CKTreltol
568 * MAX(fabs(vdbs), fabs(*(ckt->CKTstate0 + here->BSIM4vdbs)))
569 + ckt->CKTvoltTol)))
570 if ((!here->BSIM4rbodyMod) || (fabs(delvdbd) < (ckt->CKTreltol
571 * MAX(fabs(vdbd), fabs(*(ckt->CKTstate0 + here->BSIM4vdbd)))
572 + ckt->CKTvoltTol)))
573 if ((!here->BSIM4rbodyMod) || (fabs(delvsbs) < (ckt->CKTreltol
574 * MAX(fabs(vsbs), fabs(*(ckt->CKTstate0 + here->BSIM4vsbs)))
575 + ckt->CKTvoltTol)))
576 if ((!model->BSIM4rdsMod) || (fabs(delvses) < (ckt->CKTreltol
577 * MAX(fabs(vses), fabs(*(ckt->CKTstate0 + here->BSIM4vses)))
578 + ckt->CKTvoltTol)))
579 if ((!model->BSIM4rdsMod) || (fabs(delvdes) < (ckt->CKTreltol
580 * MAX(fabs(vdes), fabs(*(ckt->CKTstate0 + here->BSIM4vdes)))
581 + ckt->CKTvoltTol)))
582 if ((fabs(cdhat - Idtot) < ckt->CKTreltol
583 * MAX(fabs(cdhat), fabs(Idtot)) + ckt->CKTabstol))
584 if ((fabs(cbhat - Ibtot) < ckt->CKTreltol
585 * MAX(fabs(cbhat), fabs(Ibtot)) + ckt->CKTabstol))
586 if ((!model->BSIM4igcMod) || ((fabs(cgshat - Igstot) < ckt->CKTreltol
587 * MAX(fabs(cgshat), fabs(Igstot)) + ckt->CKTabstol)))
588 if ((!model->BSIM4igcMod) || ((fabs(cgdhat - Igdtot) < ckt->CKTreltol
589 * MAX(fabs(cgdhat), fabs(Igdtot)) + ckt->CKTabstol)))
590 if ((!model->BSIM4igbMod) || ((fabs(cgbhat - Igbtot) < ckt->CKTreltol
591 * MAX(fabs(cgbhat), fabs(Igbtot)) + ckt->CKTabstol)))
592 if ((!model->BSIM4rdsMod) || ((fabs(cseshat - Isestot) < ckt->CKTreltol
593 * MAX(fabs(cseshat), fabs(Isestot)) + ckt->CKTabstol)))
594 if ((!model->BSIM4rdsMod) || ((fabs(cdedhat - Idedtot) < ckt->CKTreltol
595 * MAX(fabs(cdedhat), fabs(Idedtot)) + ckt->CKTabstol)))
596 { vds = *(ckt->CKTstate0 + here->BSIM4vds);
597 vgs = *(ckt->CKTstate0 + here->BSIM4vgs);
598 vbs = *(ckt->CKTstate0 + here->BSIM4vbs);
599 vges = *(ckt->CKTstate0 + here->BSIM4vges);
600 vgms = *(ckt->CKTstate0 + here->BSIM4vgms);
601
602 vbd = *(ckt->CKTstate0 + here->BSIM4vbd);
603 vdbs = *(ckt->CKTstate0 + here->BSIM4vdbs);
604 vdbd = *(ckt->CKTstate0 + here->BSIM4vdbd);
605 vsbs = *(ckt->CKTstate0 + here->BSIM4vsbs);
606 vses = *(ckt->CKTstate0 + here->BSIM4vses);
607 vdes = *(ckt->CKTstate0 + here->BSIM4vdes);
608
609 vgd = vgs - vds;
610 vgb = vgs - vbs;
611 vged = vges - vds;
612 vgmd = vgms - vds;
613 vgmb = vgms - vbs;
614
615 vbs_jct = (!here->BSIM4rbodyMod) ? vbs : vsbs;
616 vbd_jct = (!here->BSIM4rbodyMod) ? vbd : vdbd;
617
618 /*** qdef should not be kept fixed even if vgs, vds & vbs has converged
619 **** qdef = *(ckt->CKTstate0 + here->BSIM4qdef);
620 ***/
621 cdrain = here->BSIM4cd;
622
623 if ((ckt->CKTmode & (MODETRAN | MODEAC)) ||
624 ((ckt->CKTmode & MODETRANOP) &&
625 (ckt->CKTmode & MODEUIC)))
626 { ByPass = 1;
627
628 qgate = here->BSIM4qgate;
629 qbulk = here->BSIM4qbulk;
630 qdrn = here->BSIM4qdrn;
631 cgdo = here->BSIM4cgdo;
632 qgdo = here->BSIM4qgdo;
633 cgso = here->BSIM4cgso;
634 qgso = here->BSIM4qgso;
635
636 goto line755;
637 }
638 else
639 goto line850;
640 }
641 #endif /*NOBYPASS*/
642
643 von = here->BSIM4von;
644 if (*(ckt->CKTstate0 + here->BSIM4vds) >= 0.0)
645 { vgs = DEVfetlim(vgs, *(ckt->CKTstate0 + here->BSIM4vgs), von);
646 vds = vgs - vgd;
647 vds = DEVlimvds(vds, *(ckt->CKTstate0 + here->BSIM4vds));
648 vgd = vgs - vds;
649 if (here->BSIM4rgateMod == 3)
650 { vges = DEVfetlim(vges, *(ckt->CKTstate0 + here->BSIM4vges), von);
651 vgms = DEVfetlim(vgms, *(ckt->CKTstate0 + here->BSIM4vgms), von);
652 vged = vges - vds;
653 vgmd = vgms - vds;
654 }
655 else if ((here->BSIM4rgateMod == 1) || (here->BSIM4rgateMod == 2))
656 { vges = DEVfetlim(vges, *(ckt->CKTstate0 + here->BSIM4vges), von);
657 vged = vges - vds;
658 }
659
660 if (model->BSIM4rdsMod)
661 { vdes = DEVlimvds(vdes, *(ckt->CKTstate0 + here->BSIM4vdes));
662 vses = -DEVlimvds(-vses, -(*(ckt->CKTstate0 + here->BSIM4vses)));
663 }
664
665 }
666 else
667 { vgd = DEVfetlim(vgd, vgdo, von);
668 vds = vgs - vgd;
669 vds = -DEVlimvds(-vds, -(*(ckt->CKTstate0 + here->BSIM4vds)));
670 vgs = vgd + vds;
671
672 if (here->BSIM4rgateMod == 3)
673 { vged = DEVfetlim(vged, vgedo, von);
674 vges = vged + vds;
675 vgmd = DEVfetlim(vgmd, vgmdo, von);
676 vgms = vgmd + vds;
677 }
678 if ((here->BSIM4rgateMod == 1) || (here->BSIM4rgateMod == 2))
679 { vged = DEVfetlim(vged, vgedo, von);
680 vges = vged + vds;
681 }
682
683 if (model->BSIM4rdsMod)
684 { vdes = -DEVlimvds(-vdes, -(*(ckt->CKTstate0 + here->BSIM4vdes)));
685 vses = DEVlimvds(vses, *(ckt->CKTstate0 + here->BSIM4vses));
686 }
687 }
688
689 if (vds >= 0.0)
690 { vbs = DEVpnjlim(vbs, *(ckt->CKTstate0 + here->BSIM4vbs),
691 CONSTvt0, model->BSIM4vcrit, &Check);
692 vbd = vbs - vds;
693 if (here->BSIM4rbodyMod)
694 { vdbs = DEVpnjlim(vdbs, *(ckt->CKTstate0 + here->BSIM4vdbs),
695 CONSTvt0, model->BSIM4vcrit, &Check1);
696 vdbd = vdbs - vds;
697 vsbs = DEVpnjlim(vsbs, *(ckt->CKTstate0 + here->BSIM4vsbs),
698 CONSTvt0, model->BSIM4vcrit, &Check2);
699 if ((Check1 == 0) && (Check2 == 0))
700 Check = 0;
701 else
702 Check = 1;
703 }
704 }
705 else
706 { vbd = DEVpnjlim(vbd, *(ckt->CKTstate0 + here->BSIM4vbd),
707 CONSTvt0, model->BSIM4vcrit, &Check);
708 vbs = vbd + vds;
709 if (here->BSIM4rbodyMod)
710 { vdbd = DEVpnjlim(vdbd, *(ckt->CKTstate0 + here->BSIM4vdbd),
711 CONSTvt0, model->BSIM4vcrit, &Check1);
712 vdbs = vdbd + vds;
713 vsbdo = *(ckt->CKTstate0 + here->BSIM4vsbs)
714 - *(ckt->CKTstate0 + here->BSIM4vds);
715 vsbd = vsbs - vds;
716 vsbd = DEVpnjlim(vsbd, vsbdo, CONSTvt0, model->BSIM4vcrit, &Check2);
717 vsbs = vsbd + vds;
718 if ((Check1 == 0) && (Check2 == 0))
719 Check = 0;
720 else
721 Check = 1;
722 }
723 }
724 }
725
726 /* Calculate DC currents and their derivatives */
727 vbd = vbs - vds;
728 vgd = vgs - vds;
729 vgb = vgs - vbs;
730 vged = vges - vds;
731 vgmd = vgms - vds;
732 vgmb = vgms - vbs;
733 vdbd = vdbs - vds;
734
735 vbs_jct = (!here->BSIM4rbodyMod) ? vbs : vsbs;
736 vbd_jct = (!here->BSIM4rbodyMod) ? vbd : vdbd;
737
738 /* Source/drain junction diode DC model begins */
739 Nvtms = model->BSIM4vtm * model->BSIM4SjctEmissionCoeff;
740 /* if ((here->BSIM4Aseff <= 0.0) && (here->BSIM4Pseff <= 0.0))
741 { SourceSatCurrent = 1.0e-14;
742 } v4.7 */
743 if ((here->BSIM4Aseff <= 0.0) && (here->BSIM4Pseff <= 0.0))
744 { SourceSatCurrent = 0.0;
745 }
746 else
747 { SourceSatCurrent = here->BSIM4Aseff * model->BSIM4SjctTempSatCurDensity
748 + here->BSIM4Pseff * model->BSIM4SjctSidewallTempSatCurDensity
749 + pParam->BSIM4weffCJ * here->BSIM4nf
750 * model->BSIM4SjctGateSidewallTempSatCurDensity;
751 }
752
753 if (SourceSatCurrent <= 0.0)
754 { here->BSIM4gbs = ckt->CKTgmin;
755 here->BSIM4cbs = here->BSIM4gbs * vbs_jct;
756 }
757 else
758 { switch(model->BSIM4dioMod)
759 { case 0:
760 evbs = exp(vbs_jct / Nvtms);
761 T1 = model->BSIM4xjbvs * exp(-(model->BSIM4bvs + vbs_jct) / Nvtms);
762 /* WDLiu: Magic T1 in this form; different from BSIM4 beta. */
763 here->BSIM4gbs = SourceSatCurrent * (evbs + T1) / Nvtms + ckt->CKTgmin;
764 here->BSIM4cbs = SourceSatCurrent * (evbs + here->BSIM4XExpBVS
765 - T1 - 1.0) + ckt->CKTgmin * vbs_jct;
766 break;
767 case 1:
768 T2 = vbs_jct / Nvtms;
769 if (T2 < -EXP_THRESHOLD)
770 { here->BSIM4gbs = ckt->CKTgmin;
771 here->BSIM4cbs = SourceSatCurrent * (MIN_EXP - 1.0)
772 + ckt->CKTgmin * vbs_jct;
773 }
774 else if (vbs_jct <= here->BSIM4vjsmFwd)
775 { evbs = exp(T2);
776 here->BSIM4gbs = SourceSatCurrent * evbs / Nvtms + ckt->CKTgmin;
777 here->BSIM4cbs = SourceSatCurrent * (evbs - 1.0)
778 + ckt->CKTgmin * vbs_jct;
779 }
780 else
781 { T0 = here->BSIM4IVjsmFwd / Nvtms;
782 here->BSIM4gbs = T0 + ckt->CKTgmin;
783 here->BSIM4cbs = here->BSIM4IVjsmFwd - SourceSatCurrent + T0
784 * (vbs_jct - here->BSIM4vjsmFwd) + ckt->CKTgmin * vbs_jct;
785 }
786 break;
787 case 2:
788 if (vbs_jct < here->BSIM4vjsmRev)
789 { T0 = vbs_jct / Nvtms;
790 if (T0 < -EXP_THRESHOLD)
791 { evbs = MIN_EXP;
792 devbs_dvb = 0.0;
793 }
794 else
795 { evbs = exp(T0);
796 devbs_dvb = evbs / Nvtms;
797 }
798
799 T1 = evbs - 1.0;
800 T2 = here->BSIM4IVjsmRev + here->BSIM4SslpRev
801 * (vbs_jct - here->BSIM4vjsmRev);
802 here->BSIM4gbs = devbs_dvb * T2 + T1 * here->BSIM4SslpRev + ckt->CKTgmin;
803 here->BSIM4cbs = T1 * T2 + ckt->CKTgmin * vbs_jct;
804 }
805 else if (vbs_jct <= here->BSIM4vjsmFwd)
806 { T0 = vbs_jct / Nvtms;
807 if (T0 < -EXP_THRESHOLD)
808 { evbs = MIN_EXP;
809 devbs_dvb = 0.0;
810 }
811 else
812 { evbs = exp(T0);
813 devbs_dvb = evbs / Nvtms;
814 }
815
816 T1 = (model->BSIM4bvs + vbs_jct) / Nvtms;
817 if (T1 > EXP_THRESHOLD)
818 { T2 = MIN_EXP;
819 T3 = 0.0;
820 }
821 else
822 { T2 = exp(-T1);
823 T3 = -T2 /Nvtms;
824 }
825 here->BSIM4gbs = SourceSatCurrent * (devbs_dvb - model->BSIM4xjbvs * T3)
826 + ckt->CKTgmin;
827 here->BSIM4cbs = SourceSatCurrent * (evbs + here->BSIM4XExpBVS - 1.0
828 - model->BSIM4xjbvs * T2) + ckt->CKTgmin * vbs_jct;
829 }
830 else
831 { here->BSIM4gbs = here->BSIM4SslpFwd + ckt->CKTgmin;
832 here->BSIM4cbs = here->BSIM4IVjsmFwd + here->BSIM4SslpFwd * (vbs_jct
833 - here->BSIM4vjsmFwd) + ckt->CKTgmin * vbs_jct;
834 }
835 break;
836 default: break;
837 }
838 }
839
840 Nvtmd = model->BSIM4vtm * model->BSIM4DjctEmissionCoeff;
841 /* if ((here->BSIM4Adeff <= 0.0) && (here->BSIM4Pdeff <= 0.0))
842 { DrainSatCurrent = 1.0e-14;
843 } v4.7 */
844 if ((here->BSIM4Adeff <= 0.0) && (here->BSIM4Pdeff <= 0.0))
845 { DrainSatCurrent = 0.0;
846 }
847 else
848 { DrainSatCurrent = here->BSIM4Adeff * model->BSIM4DjctTempSatCurDensity
849 + here->BSIM4Pdeff * model->BSIM4DjctSidewallTempSatCurDensity
850 + pParam->BSIM4weffCJ * here->BSIM4nf
851 * model->BSIM4DjctGateSidewallTempSatCurDensity;
852 }
853
854 if (DrainSatCurrent <= 0.0)
855 { here->BSIM4gbd = ckt->CKTgmin;
856 here->BSIM4cbd = here->BSIM4gbd * vbd_jct;
857 }
858 else
859 { switch(model->BSIM4dioMod)
860 { case 0:
861 evbd = exp(vbd_jct / Nvtmd);
862 T1 = model->BSIM4xjbvd * exp(-(model->BSIM4bvd + vbd_jct) / Nvtmd);
863 /* WDLiu: Magic T1 in this form; different from BSIM4 beta. */
864 here->BSIM4gbd = DrainSatCurrent * (evbd + T1) / Nvtmd + ckt->CKTgmin;
865 here->BSIM4cbd = DrainSatCurrent * (evbd + here->BSIM4XExpBVD
866 - T1 - 1.0) + ckt->CKTgmin * vbd_jct;
867 break;
868 case 1:
869 T2 = vbd_jct / Nvtmd;
870 if (T2 < -EXP_THRESHOLD)
871 { here->BSIM4gbd = ckt->CKTgmin;
872 here->BSIM4cbd = DrainSatCurrent * (MIN_EXP - 1.0)
873 + ckt->CKTgmin * vbd_jct;
874 }
875 else if (vbd_jct <= here->BSIM4vjdmFwd)
876 { evbd = exp(T2);
877 here->BSIM4gbd = DrainSatCurrent * evbd / Nvtmd + ckt->CKTgmin;
878 here->BSIM4cbd = DrainSatCurrent * (evbd - 1.0)
879 + ckt->CKTgmin * vbd_jct;
880 }
881 else
882 { T0 = here->BSIM4IVjdmFwd / Nvtmd;
883 here->BSIM4gbd = T0 + ckt->CKTgmin;
884 here->BSIM4cbd = here->BSIM4IVjdmFwd - DrainSatCurrent + T0
885 * (vbd_jct - here->BSIM4vjdmFwd) + ckt->CKTgmin * vbd_jct;
886 }
887 break;
888 case 2:
889 if (vbd_jct < here->BSIM4vjdmRev)
890 { T0 = vbd_jct / Nvtmd;
891 if (T0 < -EXP_THRESHOLD)
892 { evbd = MIN_EXP;
893 devbd_dvb = 0.0;
894 }
895 else
896 { evbd = exp(T0);
897 devbd_dvb = evbd / Nvtmd;
898 }
899
900 T1 = evbd - 1.0;
901 T2 = here->BSIM4IVjdmRev + here->BSIM4DslpRev
902 * (vbd_jct - here->BSIM4vjdmRev);
903 here->BSIM4gbd = devbd_dvb * T2 + T1 * here->BSIM4DslpRev + ckt->CKTgmin;
904 here->BSIM4cbd = T1 * T2 + ckt->CKTgmin * vbd_jct;
905 }
906 else if (vbd_jct <= here->BSIM4vjdmFwd)
907 { T0 = vbd_jct / Nvtmd;
908 if (T0 < -EXP_THRESHOLD)
909 { evbd = MIN_EXP;
910 devbd_dvb = 0.0;
911 }
912 else
913 { evbd = exp(T0);
914 devbd_dvb = evbd / Nvtmd;
915 }
916
917 T1 = (model->BSIM4bvd + vbd_jct) / Nvtmd;
918 if (T1 > EXP_THRESHOLD)
919 { T2 = MIN_EXP;
920 T3 = 0.0;
921 }
922 else
923 { T2 = exp(-T1);
924 T3 = -T2 /Nvtmd;
925 }
926 here->BSIM4gbd = DrainSatCurrent * (devbd_dvb - model->BSIM4xjbvd * T3)
927 + ckt->CKTgmin;
928 here->BSIM4cbd = DrainSatCurrent * (evbd + here->BSIM4XExpBVD - 1.0
929 - model->BSIM4xjbvd * T2) + ckt->CKTgmin * vbd_jct;
930 }
931 else
932 { here->BSIM4gbd = here->BSIM4DslpFwd + ckt->CKTgmin;
933 here->BSIM4cbd = here->BSIM4IVjdmFwd + here->BSIM4DslpFwd * (vbd_jct
934 - here->BSIM4vjdmFwd) + ckt->CKTgmin * vbd_jct;
935 }
936 break;
937 default: break;
938 }
939 }
940
941 /* trap-assisted tunneling and recombination current for reverse bias */
942 Nvtmrssws = model->BSIM4vtm0 * model->BSIM4njtsswstemp;
943 Nvtmrsswgs = model->BSIM4vtm0 * model->BSIM4njtsswgstemp;
944 Nvtmrss = model->BSIM4vtm0 * model->BSIM4njtsstemp;
945 Nvtmrsswd = model->BSIM4vtm0 * model->BSIM4njtsswdtemp;
946 Nvtmrsswgd = model->BSIM4vtm0 * model->BSIM4njtsswgdtemp;
947 Nvtmrsd = model->BSIM4vtm0 * model->BSIM4njtsdtemp;
948
949 if ((model->BSIM4vtss - vbs_jct) < (model->BSIM4vtss * 1e-3))
950 { T9 = 1.0e3;
951 T0 = - vbs_jct / Nvtmrss * T9;
952 DEXP(T0, T1, T10);
953 dT1_dVb = T10 / Nvtmrss * T9;
954 } else {
955 T9 = 1.0 / (model->BSIM4vtss - vbs_jct);
956 T0 = -vbs_jct / Nvtmrss * model->BSIM4vtss * T9;
957 dT0_dVb = model->BSIM4vtss / Nvtmrss * (T9 + vbs_jct * T9 * T9) ;
958 DEXP(T0, T1, T10);
959 dT1_dVb = T10 * dT0_dVb;
960 }
961
962 if ((model->BSIM4vtsd - vbd_jct) < (model->BSIM4vtsd * 1e-3) )
963 { T9 = 1.0e3;
964 T0 = -vbd_jct / Nvtmrsd * T9;
965 DEXP(T0, T2, T10);
966 dT2_dVb = T10 / Nvtmrsd * T9;
967 } else {
968 T9 = 1.0 / (model->BSIM4vtsd - vbd_jct);
969 T0 = -vbd_jct / Nvtmrsd * model->BSIM4vtsd * T9;
970 dT0_dVb = model->BSIM4vtsd / Nvtmrsd * (T9 + vbd_jct * T9 * T9) ;
971 DEXP(T0, T2, T10);
972 dT2_dVb = T10 * dT0_dVb;
973 }
974
975 if ((model->BSIM4vtssws - vbs_jct) < (model->BSIM4vtssws * 1e-3) )
976 { T9 = 1.0e3;
977 T0 = -vbs_jct / Nvtmrssws * T9;
978 DEXP(T0, T3, T10);
979 dT3_dVb = T10 / Nvtmrssws * T9;
980 } else {
981 T9 = 1.0 / (model->BSIM4vtssws - vbs_jct);
982 T0 = -vbs_jct / Nvtmrssws * model->BSIM4vtssws * T9;
983 dT0_dVb = model->BSIM4vtssws / Nvtmrssws * (T9 + vbs_jct * T9 * T9) ;
984 DEXP(T0, T3, T10);
985 dT3_dVb = T10 * dT0_dVb;
986 }
987
988 if ((model->BSIM4vtsswd - vbd_jct) < (model->BSIM4vtsswd * 1e-3) )
989 { T9 = 1.0e3;
990 T0 = -vbd_jct / Nvtmrsswd * T9;
991 DEXP(T0, T4, T10);
992 dT4_dVb = T10 / Nvtmrsswd * T9;
993 } else {
994 T9 = 1.0 / (model->BSIM4vtsswd - vbd_jct);
995 T0 = -vbd_jct / Nvtmrsswd * model->BSIM4vtsswd * T9;
996 dT0_dVb = model->BSIM4vtsswd / Nvtmrsswd * (T9 + vbd_jct * T9 * T9) ;
997 DEXP(T0, T4, T10);
998 dT4_dVb = T10 * dT0_dVb;
999 }
1000
1001 if ((model->BSIM4vtsswgs - vbs_jct) < (model->BSIM4vtsswgs * 1e-3) )
1002 { T9 = 1.0e3;
1003 T0 = -vbs_jct / Nvtmrsswgs * T9;
1004 DEXP(T0, T5, T10);
1005 dT5_dVb = T10 / Nvtmrsswgs * T9;
1006 } else {
1007 T9 = 1.0 / (model->BSIM4vtsswgs - vbs_jct);
1008 T0 = -vbs_jct / Nvtmrsswgs * model->BSIM4vtsswgs * T9;
1009 dT0_dVb = model->BSIM4vtsswgs / Nvtmrsswgs * (T9 + vbs_jct * T9 * T9) ;
1010 DEXP(T0, T5, T10);
1011 dT5_dVb = T10 * dT0_dVb;
1012 }
1013
1014 if ((model->BSIM4vtsswgd - vbd_jct) < (model->BSIM4vtsswgd * 1e-3) )
1015 { T9 = 1.0e3;
1016 T0 = -vbd_jct / Nvtmrsswgd * T9;
1017 DEXP(T0, T6, T10);
1018 dT6_dVb = T10 / Nvtmrsswgd * T9;
1019 } else {
1020 T9 = 1.0 / (model->BSIM4vtsswgd - vbd_jct);
1021 T0 = -vbd_jct / Nvtmrsswgd * model->BSIM4vtsswgd * T9;
1022 dT0_dVb = model->BSIM4vtsswgd / Nvtmrsswgd * (T9 + vbd_jct * T9 * T9) ;
1023 DEXP(T0, T6, T10);
1024 dT6_dVb = T10 * dT0_dVb;
1025 }
1026
1027 here->BSIM4gbs += here->BSIM4SjctTempRevSatCur * dT1_dVb
1028 + here->BSIM4SswTempRevSatCur * dT3_dVb
1029 + here->BSIM4SswgTempRevSatCur * dT5_dVb;
1030 here->BSIM4cbs -= here->BSIM4SjctTempRevSatCur * (T1 - 1.0)
1031 + here->BSIM4SswTempRevSatCur * (T3 - 1.0)
1032 + here->BSIM4SswgTempRevSatCur * (T5 - 1.0);
1033 here->BSIM4gbd += here->BSIM4DjctTempRevSatCur * dT2_dVb
1034 + here->BSIM4DswTempRevSatCur * dT4_dVb
1035 + here->BSIM4DswgTempRevSatCur * dT6_dVb;
1036 here->BSIM4cbd -= here->BSIM4DjctTempRevSatCur * (T2 - 1.0)
1037 + here->BSIM4DswTempRevSatCur * (T4 - 1.0)
1038 + here->BSIM4DswgTempRevSatCur * (T6 - 1.0);
1039
1040 /* End of diode DC model */
1041
1042 if (vds >= 0.0)
1043 { here->BSIM4mode = 1;
1044 Vds = vds;
1045 Vgs = vgs;
1046 Vbs = vbs;
1047 Vdb = vds - vbs; /* WDLiu: for GIDL */
1048
1049 }
1050 else
1051 { here->BSIM4mode = -1;
1052 Vds = -vds;
1053 Vgs = vgd;
1054 Vbs = vbd;
1055 Vdb = -vbs;
1056 }
1057
1058
1059 /* dunga */
1060 if(model->BSIM4mtrlMod)
1061 {
1062 epsrox = 3.9;
1063 toxe = model->BSIM4eot;
1064 epssub = EPS0 * model->BSIM4epsrsub;
1065 }
1066 else
1067 {
1068 epsrox = model->BSIM4epsrox;
1069 toxe = model->BSIM4toxe;
1070 epssub = EPSSI;
1071 }
1072
1073
1074 T0 = Vbs - here->BSIM4vbsc - 0.001;
1075 T1 = sqrt(T0 * T0 - 0.004 * here->BSIM4vbsc);
1076 if (T0 >= 0.0)
1077 { Vbseff = here->BSIM4vbsc + 0.5 * (T0 + T1);
1078 dVbseff_dVb = 0.5 * (1.0 + T0 / T1);
1079 }
1080 else
1081 { T2 = -0.002 / (T1 - T0);
1082 Vbseff = here->BSIM4vbsc * (1.0 + T2);
1083 dVbseff_dVb = T2 * here->BSIM4vbsc / T1;
1084 }
1085
1086 /* JX: Correction to forward body bias */
1087 T9 = 0.95 * pParam->BSIM4phi;
1088 T0 = T9 - Vbseff - 0.001;
1089 T1 = sqrt(T0 * T0 + 0.004 * T9);
1090 Vbseff = T9 - 0.5 * (T0 + T1);
1091 dVbseff_dVb *= 0.5 * (1.0 + T0 / T1);
1092 Phis = pParam->BSIM4phi - Vbseff;
1093 dPhis_dVb = -1.0;
1094 sqrtPhis = sqrt(Phis);
1095 dsqrtPhis_dVb = -0.5 / sqrtPhis;
1096
1097 Xdep = pParam->BSIM4Xdep0 * sqrtPhis / pParam->BSIM4sqrtPhi;
1098 dXdep_dVb = (pParam->BSIM4Xdep0 / pParam->BSIM4sqrtPhi)
1099 * dsqrtPhis_dVb;
1100
1101 Leff = pParam->BSIM4leff;
1102 Vtm = model->BSIM4vtm;
1103 Vtm0 = model->BSIM4vtm0;
1104
1105 /* Vth Calculation */
1106 T3 = sqrt(Xdep);
1107 V0 = pParam->BSIM4vbi - pParam->BSIM4phi;
1108
1109 T0 = pParam->BSIM4dvt2 * Vbseff;
1110 if (T0 >= - 0.5)
1111 { T1 = 1.0 + T0;
1112 T2 = pParam->BSIM4dvt2;
1113 }
1114 else
1115 { T4 = 1.0 / (3.0 + 8.0 * T0);
1116 T1 = (1.0 + 3.0 * T0) * T4;
1117 T2 = pParam->BSIM4dvt2 * T4 * T4;
1118 }
1119 lt1 = model->BSIM4factor1 * T3 * T1;
1120 dlt1_dVb = model->BSIM4factor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2);
1121
1122 T0 = pParam->BSIM4dvt2w * Vbseff;
1123 if (T0 >= - 0.5)
1124 { T1 = 1.0 + T0;
1125 T2 = pParam->BSIM4dvt2w;
1126 }
1127 else
1128 { T4 = 1.0 / (3.0 + 8.0 * T0);
1129 T1 = (1.0 + 3.0 * T0) * T4;
1130 T2 = pParam->BSIM4dvt2w * T4 * T4;
1131 }
1132 ltw = model->BSIM4factor1 * T3 * T1;
1133 dltw_dVb = model->BSIM4factor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2);
1134
1135 T0 = pParam->BSIM4dvt1 * Leff / lt1;
1136 if (T0 < EXP_THRESHOLD)
1137 { T1 = exp(T0);
1138 T2 = T1 - 1.0;
1139 T3 = T2 * T2;
1140 T4 = T3 + 2.0 * T1 * MIN_EXP;
1141 Theta0 = T1 / T4;
1142 dT1_dVb = -T0 * T1 * dlt1_dVb / lt1;
1143 dTheta0_dVb = dT1_dVb * (T4 - 2.0 * T1 * (T2 + MIN_EXP)) / T4 / T4;
1144 }
1145 else
1146 { Theta0 = 1.0 / (MAX_EXP - 2.0); /* 3.0 * MIN_EXP omitted */
1147 dTheta0_dVb = 0.0;
1148 }
1149 here->BSIM4thetavth = pParam->BSIM4dvt0 * Theta0;
1150 Delt_vth = here->BSIM4thetavth * V0;
1151 dDelt_vth_dVb = pParam->BSIM4dvt0 * dTheta0_dVb * V0;
1152
1153 T0 = pParam->BSIM4dvt1w * pParam->BSIM4weff * Leff / ltw;
1154 if (T0 < EXP_THRESHOLD)
1155 { T1 = exp(T0);
1156 T2 = T1 - 1.0;
1157 T3 = T2 * T2;
1158 T4 = T3 + 2.0 * T1 * MIN_EXP;
1159 T5 = T1 / T4;
1160 dT1_dVb = -T0 * T1 * dltw_dVb / ltw;
1161 dT5_dVb = dT1_dVb * (T4 - 2.0 * T1 * (T2 + MIN_EXP)) / T4 / T4;
1162 }
1163 else
1164 { T5 = 1.0 / (MAX_EXP - 2.0); /* 3.0 * MIN_EXP omitted */
1165 dT5_dVb = 0.0;
1166 }
1167 T0 = pParam->BSIM4dvt0w * T5;
1168 T2 = T0 * V0;
1169 dT2_dVb = pParam->BSIM4dvt0w * dT5_dVb * V0;
1170
1171 TempRatio = ckt->CKTtemp / model->BSIM4tnom - 1.0;
1172 T0 = sqrt(1.0 + pParam->BSIM4lpe0 / Leff);
1173 T1 = pParam->BSIM4k1ox * (T0 - 1.0) * pParam->BSIM4sqrtPhi
1174 + (pParam->BSIM4kt1 + pParam->BSIM4kt1l / Leff
1175 + pParam->BSIM4kt2 * Vbseff) * TempRatio;
1176 Vth_NarrowW = toxe * pParam->BSIM4phi
1177 / (pParam->BSIM4weff + pParam->BSIM4w0);
1178
1179 T3 = here->BSIM4eta0 + pParam->BSIM4etab * Vbseff;
1180 if (T3 < 1.0e-4)
1181 { T9 = 1.0 / (3.0 - 2.0e4 * T3);
1182 T3 = (2.0e-4 - T3) * T9;
1183 T4 = T9 * T9;
1184 }
1185 else
1186 { T4 = 1.0;
1187 }
1188 dDIBL_Sft_dVd = T3 * pParam->BSIM4theta0vb0;
1189 DIBL_Sft = dDIBL_Sft_dVd * Vds;
1190
1191 Lpe_Vb = sqrt(1.0 + pParam->BSIM4lpeb / Leff);
1192
1193 Vth = model->BSIM4type * here->BSIM4vth0 + (pParam->BSIM4k1ox * sqrtPhis
1194 - pParam->BSIM4k1 * pParam->BSIM4sqrtPhi) * Lpe_Vb
1195 - here->BSIM4k2ox * Vbseff - Delt_vth - T2 + (pParam->BSIM4k3
1196 + pParam->BSIM4k3b * Vbseff) * Vth_NarrowW + T1 - DIBL_Sft;
1197
1198 dVth_dVb = Lpe_Vb * pParam->BSIM4k1ox * dsqrtPhis_dVb - here->BSIM4k2ox
1199 - dDelt_vth_dVb - dT2_dVb + pParam->BSIM4k3b * Vth_NarrowW
1200 - pParam->BSIM4etab * Vds * pParam->BSIM4theta0vb0 * T4
1201 + pParam->BSIM4kt2 * TempRatio;
1202 dVth_dVd = -dDIBL_Sft_dVd;
1203
1204
1205 /* Calculate n */
1206 tmp1 = epssub / Xdep;
1207 here->BSIM4nstar = model->BSIM4vtm / Charge_q * (model->BSIM4coxe
1208 + tmp1 + pParam->BSIM4cit);
1209 tmp2 = pParam->BSIM4nfactor * tmp1;
1210 tmp3 = pParam->BSIM4cdsc + pParam->BSIM4cdscb * Vbseff
1211 + pParam->BSIM4cdscd * Vds;
1212 tmp4 = (tmp2 + tmp3 * Theta0 + pParam->BSIM4cit) / model->BSIM4coxe;
1213 if (tmp4 >= -0.5)
1214 { n = 1.0 + tmp4;
1215 dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb
1216 + pParam->BSIM4cdscb * Theta0) / model->BSIM4coxe;
1217 dn_dVd = pParam->BSIM4cdscd * Theta0 / model->BSIM4coxe;
1218 }
1219 else
1220 { T0 = 1.0 / (3.0 + 8.0 * tmp4);
1221 n = (1.0 + 3.0 * tmp4) * T0;
1222 T0 *= T0;
1223 dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb
1224 + pParam->BSIM4cdscb * Theta0) / model->BSIM4coxe * T0;
1225 dn_dVd = pParam->BSIM4cdscd * Theta0 / model->BSIM4coxe * T0;
1226 }
1227
1228
1229 /* Vth correction for Pocket implant */
1230 if (pParam->BSIM4dvtp0 > 0.0)
1231 { T0 = -pParam->BSIM4dvtp1 * Vds;
1232 if (T0 < -EXP_THRESHOLD)
1233 { T2 = MIN_EXP;
1234 dT2_dVd = 0.0;
1235 }
1236 else
1237 { T2 = exp(T0);
1238 dT2_dVd = -pParam->BSIM4dvtp1 * T2;
1239 }
1240
1241 T3 = Leff + pParam->BSIM4dvtp0 * (1.0 + T2);
1242 dT3_dVd = pParam->BSIM4dvtp0 * dT2_dVd;
1243 if (model->BSIM4tempMod < 2)
1244 {
1245 T4 = Vtm * log(Leff / T3);
1246 dT4_dVd = -Vtm * dT3_dVd / T3;
1247 }
1248 else
1249 {
1250 T4 = model->BSIM4vtm0 * log(Leff / T3);
1251 dT4_dVd = -model->BSIM4vtm0 * dT3_dVd / T3;
1252 }
1253 dDITS_Sft_dVd = dn_dVd * T4 + n * dT4_dVd;
1254 dDITS_Sft_dVb = T4 * dn_dVb;
1255
1256 Vth -= n * T4;
1257 dVth_dVd -= dDITS_Sft_dVd;
1258 dVth_dVb -= dDITS_Sft_dVb;
1259 }
1260
1261 /* v4.7 DITS_SFT2 */
1262 if ((pParam->BSIM4dvtp4 == 0.0) || (pParam->BSIM4dvtp2factor == 0.0)) {
1263 T0 = 0.0;
1264 DITS_Sft2 = 0.0;
1265 }
1266 else
1267 {
1268 //T0 = exp(2.0 * pParam->BSIM4dvtp4 * Vds); /* beta code */
1269 T1 = 2.0 * pParam->BSIM4dvtp4 * Vds;
1270 DEXP(T1, T0, T10);
1271 DITS_Sft2 = pParam->BSIM4dvtp2factor * (T0-1) / (T0+1);
1272 //dDITS_Sft2_dVd = pParam->BSIM4dvtp2factor * pParam->BSIM4dvtp4 * 4.0 * T0 / ((T0+1) * (T0+1)); /* beta code */
1273 dDITS_Sft2_dVd = pParam->BSIM4dvtp2factor * pParam->BSIM4dvtp4 * 4.0 * T10 / ((T0+1) * (T0+1));
1274 Vth -= DITS_Sft2;
1275 dVth_dVd -= dDITS_Sft2_dVd;
1276 }
1277
1278
1279
1280 here->BSIM4von = Vth;
1281
1282
1283 /* Poly Gate Si Depletion Effect */
1284 T0 = here->BSIM4vfb + pParam->BSIM4phi;
1285 if(model->BSIM4mtrlMod == 0)
1286 T1 = EPSSI;
1287 else
1288 T1 = model->BSIM4epsrgate * EPS0;
1289
1290
1291 BSIM4polyDepletion(T0, pParam->BSIM4ngate, T1, model->BSIM4coxe, vgs, &vgs_eff, &dvgs_eff_dvg);
1292
1293 BSIM4polyDepletion(T0, pParam->BSIM4ngate, T1, model->BSIM4coxe, vgd, &vgd_eff, &dvgd_eff_dvg);
1294
1295 if(here->BSIM4mode>0) {
1296 Vgs_eff = vgs_eff;
1297 dVgs_eff_dVg = dvgs_eff_dvg;
1298 } else {
1299 Vgs_eff = vgd_eff;
1300 dVgs_eff_dVg = dvgd_eff_dvg;
1301 }
1302 here->BSIM4vgs_eff = vgs_eff;
1303 here->BSIM4vgd_eff = vgd_eff;
1304 here->BSIM4dvgs_eff_dvg = dvgs_eff_dvg;
1305 here->BSIM4dvgd_eff_dvg = dvgd_eff_dvg;
1306
1307
1308 Vgst = Vgs_eff - Vth;
1309
1310 /* Calculate Vgsteff */
1311 T0 = n * Vtm;
1312 T1 = pParam->BSIM4mstar * Vgst;
1313 T2 = T1 / T0;
1314 if (T2 > EXP_THRESHOLD)
1315 { T10 = T1;
1316 dT10_dVg = pParam->BSIM4mstar * dVgs_eff_dVg;
1317 dT10_dVd = -dVth_dVd * pParam->BSIM4mstar;
1318 dT10_dVb = -dVth_dVb * pParam->BSIM4mstar;
1319 }
1320 else if (T2 < -EXP_THRESHOLD)
1321 { T10 = Vtm * log(1.0 + MIN_EXP);
1322 dT10_dVg = 0.0;
1323 dT10_dVd = T10 * dn_dVd;
1324 dT10_dVb = T10 * dn_dVb;
1325 T10 *= n;
1326 }
1327 else
1328 { ExpVgst = exp(T2);
1329 T3 = Vtm * log(1.0 + ExpVgst);
1330 T10 = n * T3;
1331 dT10_dVg = pParam->BSIM4mstar * ExpVgst / (1.0 + ExpVgst);
1332 dT10_dVb = T3 * dn_dVb - dT10_dVg * (dVth_dVb + Vgst * dn_dVb / n);
1333 dT10_dVd = T3 * dn_dVd - dT10_dVg * (dVth_dVd + Vgst * dn_dVd / n);
1334 dT10_dVg *= dVgs_eff_dVg;
1335 }
1336
1337 T1 = pParam->BSIM4voffcbn - (1.0 - pParam->BSIM4mstar) * Vgst;
1338 T2 = T1 / T0;
1339 if (T2 < -EXP_THRESHOLD)
1340 { T3 = model->BSIM4coxe * MIN_EXP / pParam->BSIM4cdep0;
1341 T9 = pParam->BSIM4mstar + T3 * n;
1342 dT9_dVg = 0.0;
1343 dT9_dVd = dn_dVd * T3;
1344 dT9_dVb = dn_dVb * T3;
1345 }
1346 else if (T2 > EXP_THRESHOLD)
1347 { T3 = model->BSIM4coxe * MAX_EXP / pParam->BSIM4cdep0;
1348 T9 = pParam->BSIM4mstar + T3 * n;
1349 dT9_dVg = 0.0;
1350 dT9_dVd = dn_dVd * T3;
1351 dT9_dVb = dn_dVb * T3;
1352 }
1353 else
1354 { ExpVgst = exp(T2);
1355 T3 = model->BSIM4coxe / pParam->BSIM4cdep0;
1356 T4 = T3 * ExpVgst;
1357 T5 = T1 * T4 / T0;
1358 T9 = pParam->BSIM4mstar + n * T4;
1359 dT9_dVg = T3 * (pParam->BSIM4mstar - 1.0) * ExpVgst / Vtm;
1360 dT9_dVb = T4 * dn_dVb - dT9_dVg * dVth_dVb - T5 * dn_dVb;
1361 dT9_dVd = T4 * dn_dVd - dT9_dVg * dVth_dVd - T5 * dn_dVd;
1362 dT9_dVg *= dVgs_eff_dVg;
1363 }
1364 here->BSIM4Vgsteff = Vgsteff = T10 / T9;
1365 T11 = T9 * T9;
1366 dVgsteff_dVg = (T9 * dT10_dVg - T10 * dT9_dVg) / T11;
1367 dVgsteff_dVd = (T9 * dT10_dVd - T10 * dT9_dVd) / T11;
1368 dVgsteff_dVb = (T9 * dT10_dVb - T10 * dT9_dVb) / T11;
1369
1370 /* Calculate Effective Channel Geometry */
1371 T9 = sqrtPhis - pParam->BSIM4sqrtPhi;
1372 Weff = pParam->BSIM4weff - 2.0 * (pParam->BSIM4dwg * Vgsteff
1373 + pParam->BSIM4dwb * T9);
1374 dWeff_dVg = -2.0 * pParam->BSIM4dwg;
1375 dWeff_dVb = -2.0 * pParam->BSIM4dwb * dsqrtPhis_dVb;
1376
1377 if (Weff < 2.0e-8) /* to avoid the discontinuity problem due to Weff*/
1378 { T0 = 1.0 / (6.0e-8 - 2.0 * Weff);
1379 Weff = 2.0e-8 * (4.0e-8 - Weff) * T0;
1380 T0 *= T0 * 4.0e-16;
1381 dWeff_dVg *= T0;
1382 dWeff_dVb *= T0;
1383 }
1384
1385 if (model->BSIM4rdsMod == 1)
1386 Rds = dRds_dVg = dRds_dVb = 0.0;
1387 else
1388 { T0 = 1.0 + pParam->BSIM4prwg * Vgsteff;
1389 dT0_dVg = -pParam->BSIM4prwg / T0 / T0;
1390 T1 = pParam->BSIM4prwb * T9;
1391 dT1_dVb = pParam->BSIM4prwb * dsqrtPhis_dVb;
1392
1393 T2 = 1.0 / T0 + T1;
1394 T3 = T2 + sqrt(T2 * T2 + 0.01); /* 0.01 = 4.0 * 0.05 * 0.05 */
1395 dT3_dVg = 1.0 + T2 / (T3 - T2);
1396 dT3_dVb = dT3_dVg * dT1_dVb;
1397 dT3_dVg *= dT0_dVg;
1398
1399 T4 = pParam->BSIM4rds0 * 0.5;
1400 Rds = pParam->BSIM4rdswmin + T3 * T4;
1401 dRds_dVg = T4 * dT3_dVg;
1402 dRds_dVb = T4 * dT3_dVb;
1403
1404 if (Rds > 0.0)
1405 here->BSIM4grdsw = 1.0 / Rds* here->BSIM4nf; /*4.6.2*/
1406 else
1407 here->BSIM4grdsw = 0.0;
1408 }
1409
1410 /* Calculate Abulk */
1411 T9 = 0.5 * pParam->BSIM4k1ox * Lpe_Vb / sqrtPhis;
1412 T1 = T9 + here->BSIM4k2ox - pParam->BSIM4k3b * Vth_NarrowW;
1413 dT1_dVb = -T9 / sqrtPhis * dsqrtPhis_dVb;
1414
1415 T9 = sqrt(pParam->BSIM4xj * Xdep);
1416 tmp1 = Leff + 2.0 * T9;
1417 T5 = Leff / tmp1;
1418 tmp2 = pParam->BSIM4a0 * T5;
1419 tmp3 = pParam->BSIM4weff + pParam->BSIM4b1;
1420 tmp4 = pParam->BSIM4b0 / tmp3;
1421 T2 = tmp2 + tmp4;
1422 dT2_dVb = -T9 / tmp1 / Xdep * dXdep_dVb;
1423 T6 = T5 * T5;
1424 T7 = T5 * T6;
1425
1426 Abulk0 = 1.0 + T1 * T2;
1427 dAbulk0_dVb = T1 * tmp2 * dT2_dVb + T2 * dT1_dVb;
1428
1429 T8 = pParam->BSIM4ags * pParam->BSIM4a0 * T7;
1430 dAbulk_dVg = -T1 * T8;
1431 Abulk = Abulk0 + dAbulk_dVg * Vgsteff;
1432 dAbulk_dVb = dAbulk0_dVb - T8 * Vgsteff * (dT1_dVb
1433 + 3.0 * T1 * dT2_dVb);
1434
1435 if (Abulk0 < 0.1) /* added to avoid the problems caused by Abulk0 */
1436 { T9 = 1.0 / (3.0 - 20.0 * Abulk0);
1437 Abulk0 = (0.2 - Abulk0) * T9;
1438 dAbulk0_dVb *= T9 * T9;
1439 }
1440
1441 if (Abulk < 0.1)
1442 { T9 = 1.0 / (3.0 - 20.0 * Abulk);
1443 Abulk = (0.2 - Abulk) * T9;
1444 T10 = T9 * T9;
1445 dAbulk_dVb *= T10;
1446 dAbulk_dVg *= T10;
1447 }
1448 here->BSIM4Abulk = Abulk;
1449
1450 T2 = pParam->BSIM4keta * Vbseff;
1451 if (T2 >= -0.9)
1452 { T0 = 1.0 / (1.0 + T2);
1453 dT0_dVb = -pParam->BSIM4keta * T0 * T0;
1454 }
1455 else
1456 { T1 = 1.0 / (0.8 + T2);
1457 T0 = (17.0 + 20.0 * T2) * T1;
1458 dT0_dVb = -pParam->BSIM4keta * T1 * T1;
1459 }
1460 dAbulk_dVg *= T0;
1461 dAbulk_dVb = dAbulk_dVb * T0 + Abulk * dT0_dVb;
1462 dAbulk0_dVb = dAbulk0_dVb * T0 + Abulk0 * dT0_dVb;
1463 Abulk *= T0;
1464 Abulk0 *= T0;
1465
1466 /* Mobility calculation */
1467 if (model->BSIM4mtrlMod && model->BSIM4mtrlCompatMod == 0)
1468 T14 = 2.0 * model->BSIM4type *(model->BSIM4phig - model->BSIM4easub - 0.5*model->BSIM4Eg0 + 0.45);
1469 else
1470 T14 = 0.0;
1471
1472 if (model->BSIM4mobMod == 0)
1473 { T0 = Vgsteff + Vth + Vth - T14;
1474 T2 = pParam->BSIM4ua + pParam->BSIM4uc * Vbseff;
1475 T3 = T0 / toxe;
1476 T12 = sqrt(Vth * Vth + 0.0001);
1477 T9 = 1.0/(Vgsteff + 2*T12);
1478 T10 = T9*toxe;
1479 T8 = pParam->BSIM4ud * T10 * T10 * Vth;
1480 T6 = T8 * Vth;
1481 T5 = T3 * (T2 + pParam->BSIM4ub * T3) + T6;
1482 T7 = - 2.0 * T6 * T9;
1483 T11 = T7 * Vth/T12;
1484 dDenomi_dVg = (T2 + 2.0 * pParam->BSIM4ub * T3) / toxe;
1485 T13 = 2.0 * (dDenomi_dVg + T11 + T8);
1486 dDenomi_dVd = T13 * dVth_dVd;
1487 dDenomi_dVb = T13 * dVth_dVb + pParam->BSIM4uc * T3;
1488 dDenomi_dVg+= T7;
1489 }
1490 else if (model->BSIM4mobMod == 1)
1491 { T0 = Vgsteff + Vth + Vth - T14;
1492 T2 = 1.0 + pParam->BSIM4uc * Vbseff;
1493 T3 = T0 / toxe;
1494 T4 = T3 * (pParam->BSIM4ua + pParam->BSIM4ub * T3);
1495 T12 = sqrt(Vth * Vth + 0.0001);
1496 T9 = 1.0/(Vgsteff + 2*T12);
1497 T10 = T9*toxe;
1498 T8 = pParam->BSIM4ud * T10 * T10 * Vth;
1499 T6 = T8 * Vth;
1500 T5 = T4 * T2 + T6;
1501 T7 = - 2.0 * T6 * T9;
1502 T11 = T7 * Vth/T12;
1503 dDenomi_dVg = (pParam->BSIM4ua + 2.0 * pParam->BSIM4ub * T3) * T2 / toxe;
1504 T13 = 2.0 * (dDenomi_dVg + T11 + T8);
1505 dDenomi_dVd = T13 * dVth_dVd;
1506 dDenomi_dVb = T13 * dVth_dVb + pParam->BSIM4uc * T4;
1507 dDenomi_dVg+= T7;
1508 }
1509 else if (model->BSIM4mobMod == 2)
1510 { T0 = (Vgsteff + here->BSIM4vtfbphi1) / toxe;
1511 T1 = exp(pParam->BSIM4eu * log(T0));
1512 dT1_dVg = T1 * pParam->BSIM4eu / T0 / toxe;
1513 T2 = pParam->BSIM4ua + pParam->BSIM4uc * Vbseff;
1514
1515 T12 = sqrt(Vth * Vth + 0.0001);
1516 T9 = 1.0/(Vgsteff + 2*T12);
1517 T10 = T9*toxe;
1518 T8 = pParam->BSIM4ud * T10 * T10 * Vth;
1519 T6 = T8 * Vth;
1520 T5 = T1 * T2 + T6;
1521 T7 = - 2.0 * T6 * T9;
1522 T11 = T7 * Vth/T12;
1523 dDenomi_dVg = T2 * dT1_dVg + T7;
1524 T13 = 2.0 * (T11 + T8);
1525 dDenomi_dVd = T13 * dVth_dVd;
1526 dDenomi_dVb = T13 * dVth_dVb + T1 * pParam->BSIM4uc;
1527 }
1528 else if (model->BSIM4mobMod == 4) /* Synopsys 08/30/2013 add */
1529 {
1530 T0 = Vgsteff + here->BSIM4vtfbphi1 - T14;
1531 T2 = pParam->BSIM4ua + pParam->BSIM4uc * Vbseff;
1532 T3 = T0 / toxe;
1533 T12 = sqrt(here->BSIM4vtfbphi1*here->BSIM4vtfbphi1 + 0.0001);
1534 T9 = 1.0/(Vgsteff + 2*T12);
1535 T10 = T9*toxe;
1536 T8 = pParam->BSIM4ud * T10 * T10 * here->BSIM4vtfbphi1;
1537 T6 = T8 * here->BSIM4vtfbphi1;
1538 T5 = T3 * (T2 + pParam->BSIM4ub * T3) + T6;
1539 T7 = - 2.0 * T6 * T9;
1540 dDenomi_dVg = (T2 + 2.0 * pParam->BSIM4ub * T3) / toxe;
1541 dDenomi_dVd = 0.0;
1542 dDenomi_dVb = pParam->BSIM4uc * T3;
1543 dDenomi_dVg+= T7;
1544 }
1545 else if (model->BSIM4mobMod == 5) /* Synopsys 08/30/2013 add */
1546 {
1547 T0 = Vgsteff + here->BSIM4vtfbphi1 - T14;
1548 T2 = 1.0 + pParam->BSIM4uc * Vbseff;
1549 T3 = T0 / toxe;
1550 T4 = T3 * (pParam->BSIM4ua + pParam->BSIM4ub * T3);
1551 T12 = sqrt(here->BSIM4vtfbphi1 * here->BSIM4vtfbphi1 + 0.0001);
1552 T9 = 1.0/(Vgsteff + 2*T12);
1553 T10 = T9*toxe;
1554 T8 = pParam->BSIM4ud * T10 * T10 * here->BSIM4vtfbphi1;
1555 T6 = T8 * here->BSIM4vtfbphi1;
1556 T5 = T4 * T2 + T6;
1557 T7 = - 2.0 * T6 * T9;
1558 dDenomi_dVg = (pParam->BSIM4ua + 2.0 * pParam->BSIM4ub * T3) * T2
1559 / toxe;
1560 dDenomi_dVd = 0.0;
1561 dDenomi_dVb = pParam->BSIM4uc * T4;
1562 dDenomi_dVg+= T7;
1563 }
1564 else if (model->BSIM4mobMod == 6) /* Synopsys 08/30/2013 modify */
1565 { T0 = (Vgsteff + here->BSIM4vtfbphi1) / toxe;
1566 T1 = exp(pParam->BSIM4eu * log(T0));
1567 dT1_dVg = T1 * pParam->BSIM4eu / T0 / toxe;
1568 T2 = pParam->BSIM4ua + pParam->BSIM4uc * Vbseff;
1569
1570 T12 = sqrt(here->BSIM4vtfbphi1 * here->BSIM4vtfbphi1 + 0.0001);
1571 T9 = 1.0/(Vgsteff + 2*T12);
1572 T10 = T9*toxe;
1573 T8 = pParam->BSIM4ud * T10 * T10 * here->BSIM4vtfbphi1;
1574 T6 = T8 * here->BSIM4vtfbphi1;
1575 T5 = T1 * T2 + T6;
1576 T7 = - 2.0 * T6 * T9;
1577 dDenomi_dVg = T2 * dT1_dVg + T7;
1578 dDenomi_dVd = 0;
1579 dDenomi_dVb = T1 * pParam->BSIM4uc;
1580 }
1581
1582 /*high K mobility*/
1583 else
1584 {
1585
1586
1587 /*univsersal mobility*/
1588 T0 = (Vgsteff + here->BSIM4vtfbphi1)* 1.0e-8 / toxe/6.0;
1589 T1 = exp(pParam->BSIM4eu * log(T0));
1590 dT1_dVg = T1 * pParam->BSIM4eu * 1.0e-8/ T0 / toxe/6.0;
1591 T2 = pParam->BSIM4ua + pParam->BSIM4uc * Vbseff;
1592
1593 /*Coulombic*/
1594 VgsteffVth = pParam->BSIM4VgsteffVth;
1595
1596 T10 = exp(pParam->BSIM4ucs * log(0.5 + 0.5 * Vgsteff/VgsteffVth));
1597 T11 = pParam->BSIM4ud/T10;
1598 dT11_dVg = - 0.5 * pParam->BSIM4ucs * T11 /(0.5 + 0.5*Vgsteff/VgsteffVth)/VgsteffVth;
1599
1600 dDenomi_dVg = T2 * dT1_dVg + dT11_dVg;
1601 dDenomi_dVd = 0.0;
1602 dDenomi_dVb = T1 * pParam->BSIM4uc;
1603
1604 T5 = T1 * T2 + T11;
1605 }
1606
1607
1608
1609
1610
1611 if (T5 >= -0.8)
1612 { Denomi = 1.0 + T5;
1613 }
1614 else
1615 { T9 = 1.0 / (7.0 + 10.0 * T5);
1616 Denomi = (0.6 + T5) * T9;
1617 T9 *= T9;
1618 dDenomi_dVg *= T9;
1619 dDenomi_dVd *= T9;
1620 dDenomi_dVb *= T9;
1621 }
1622
1623
1624 here->BSIM4ueff = ueff = here->BSIM4u0temp / Denomi;
1625 T9 = -ueff / Denomi;
1626 dueff_dVg = T9 * dDenomi_dVg;
1627 dueff_dVd = T9 * dDenomi_dVd;
1628 dueff_dVb = T9 * dDenomi_dVb;
1629
1630 /* Saturation Drain Voltage Vdsat */
1631 WVCox = Weff * here->BSIM4vsattemp * model->BSIM4coxe;
1632 WVCoxRds = WVCox * Rds;
1633
1634 Esat = 2.0 * here->BSIM4vsattemp / ueff;
1635 here->BSIM4EsatL = EsatL = Esat * Leff;
1636 T0 = -EsatL /ueff;
1637 dEsatL_dVg = T0 * dueff_dVg;
1638 dEsatL_dVd = T0 * dueff_dVd;
1639 dEsatL_dVb = T0 * dueff_dVb;
1640
1641 /* Sqrt() */
1642 a1 = pParam->BSIM4a1;
1643 if (a1 == 0.0)
1644 { Lambda = pParam->BSIM4a2;
1645 dLambda_dVg = 0.0;
1646 }
1647 else if (a1 > 0.0)
1648 { T0 = 1.0 - pParam->BSIM4a2;
1649 T1 = T0 - pParam->BSIM4a1 * Vgsteff - 0.0001;
1650 T2 = sqrt(T1 * T1 + 0.0004 * T0);
1651 Lambda = pParam->BSIM4a2 + T0 - 0.5 * (T1 + T2);
1652 dLambda_dVg = 0.5 * pParam->BSIM4a1 * (1.0 + T1 / T2);
1653 }
1654 else
1655 { T1 = pParam->BSIM4a2 + pParam->BSIM4a1 * Vgsteff - 0.0001;
1656 T2 = sqrt(T1 * T1 + 0.0004 * pParam->BSIM4a2);
1657 Lambda = 0.5 * (T1 + T2);
1658 dLambda_dVg = 0.5 * pParam->BSIM4a1 * (1.0 + T1 / T2);
1659 }
1660
1661 Vgst2Vtm = Vgsteff + 2.0 * Vtm;
1662 if (Rds > 0)
1663 { tmp2 = dRds_dVg / Rds + dWeff_dVg / Weff;
1664 tmp3 = dRds_dVb / Rds + dWeff_dVb / Weff;
1665 }
1666 else
1667 { tmp2 = dWeff_dVg / Weff;
1668 tmp3 = dWeff_dVb / Weff;
1669 }
1670 if ((Rds == 0.0) && (Lambda == 1.0))
1671 { T0 = 1.0 / (Abulk * EsatL + Vgst2Vtm);
1672 tmp1 = 0.0;
1673 T1 = T0 * T0;
1674 T2 = Vgst2Vtm * T0;
1675 T3 = EsatL * Vgst2Vtm;
1676 Vdsat = T3 * T0;
1677
1678 dT0_dVg = -(Abulk * dEsatL_dVg + EsatL * dAbulk_dVg + 1.0) * T1;
1679 dT0_dVd = -(Abulk * dEsatL_dVd) * T1;
1680 dT0_dVb = -(Abulk * dEsatL_dVb + dAbulk_dVb * EsatL) * T1;
1681
1682 dVdsat_dVg = T3 * dT0_dVg + T2 * dEsatL_dVg + EsatL * T0;
1683 dVdsat_dVd = T3 * dT0_dVd + T2 * dEsatL_dVd;
1684 dVdsat_dVb = T3 * dT0_dVb + T2 * dEsatL_dVb;
1685 }
1686 else
1687 { tmp1 = dLambda_dVg / (Lambda * Lambda);
1688 T9 = Abulk * WVCoxRds;
1689 T8 = Abulk * T9;
1690 T7 = Vgst2Vtm * T9;
1691 T6 = Vgst2Vtm * WVCoxRds;
1692 T0 = 2.0 * Abulk * (T9 - 1.0 + 1.0 / Lambda);
1693 dT0_dVg = 2.0 * (T8 * tmp2 - Abulk * tmp1
1694 + (2.0 * T9 + 1.0 / Lambda - 1.0) * dAbulk_dVg);
1695
1696 dT0_dVb = 2.0 * (T8 * (2.0 / Abulk * dAbulk_dVb + tmp3)
1697 + (1.0 / Lambda - 1.0) * dAbulk_dVb);
1698 dT0_dVd = 0.0;
1699 T1 = Vgst2Vtm * (2.0 / Lambda - 1.0) + Abulk * EsatL + 3.0 * T7;
1700
1701 dT1_dVg = (2.0 / Lambda - 1.0) - 2.0 * Vgst2Vtm * tmp1
1702 + Abulk * dEsatL_dVg + EsatL * dAbulk_dVg + 3.0 * (T9
1703 + T7 * tmp2 + T6 * dAbulk_dVg);
1704 dT1_dVb = Abulk * dEsatL_dVb + EsatL * dAbulk_dVb
1705 + 3.0 * (T6 * dAbulk_dVb + T7 * tmp3);
1706 dT1_dVd = Abulk * dEsatL_dVd;
1707
1708 T2 = Vgst2Vtm * (EsatL + 2.0 * T6);
1709 dT2_dVg = EsatL + Vgst2Vtm * dEsatL_dVg
1710 + T6 * (4.0 + 2.0 * Vgst2Vtm * tmp2);
1711 dT2_dVb = Vgst2Vtm * (dEsatL_dVb + 2.0 * T6 * tmp3);
1712 dT2_dVd = Vgst2Vtm * dEsatL_dVd;
1713
1714 T3 = sqrt(T1 * T1 - 2.0 * T0 * T2);
1715 Vdsat = (T1 - T3) / T0;
1716
1717 dT3_dVg = (T1 * dT1_dVg - 2.0 * (T0 * dT2_dVg + T2 * dT0_dVg))
1718 / T3;
1719 dT3_dVd = (T1 * dT1_dVd - 2.0 * (T0 * dT2_dVd + T2 * dT0_dVd))
1720 / T3;
1721 dT3_dVb = (T1 * dT1_dVb - 2.0 * (T0 * dT2_dVb + T2 * dT0_dVb))
1722 / T3;
1723
1724 dVdsat_dVg = (dT1_dVg - (T1 * dT1_dVg - dT0_dVg * T2
1725 - T0 * dT2_dVg) / T3 - Vdsat * dT0_dVg) / T0;
1726 dVdsat_dVb = (dT1_dVb - (T1 * dT1_dVb - dT0_dVb * T2
1727 - T0 * dT2_dVb) / T3 - Vdsat * dT0_dVb) / T0;
1728 dVdsat_dVd = (dT1_dVd - (T1 * dT1_dVd - T0 * dT2_dVd) / T3) / T0;
1729 }
1730 here->BSIM4vdsat = Vdsat;
1731
1732 /* Calculate Vdseff */
1733 T1 = Vdsat - Vds - pParam->BSIM4delta;
1734 dT1_dVg = dVdsat_dVg;
1735 dT1_dVd = dVdsat_dVd - 1.0;
1736 dT1_dVb = dVdsat_dVb;
1737
1738 T2 = sqrt(T1 * T1 + 4.0 * pParam->BSIM4delta * Vdsat);
1739 T0 = T1 / T2;
1740 T9 = 2.0 * pParam->BSIM4delta;
1741 T3 = T9 / T2;
1742 dT2_dVg = T0 * dT1_dVg + T3 * dVdsat_dVg;
1743 dT2_dVd = T0 * dT1_dVd + T3 * dVdsat_dVd;
1744 dT2_dVb = T0 * dT1_dVb + T3 * dVdsat_dVb;
1745
1746 if (T1 >= 0.0)
1747 { Vdseff = Vdsat - 0.5 * (T1 + T2);
1748 dVdseff_dVg = dVdsat_dVg - 0.5 * (dT1_dVg + dT2_dVg);
1749 dVdseff_dVd = dVdsat_dVd - 0.5 * (dT1_dVd + dT2_dVd);
1750 dVdseff_dVb = dVdsat_dVb - 0.5 * (dT1_dVb + dT2_dVb);
1751 }
1752 else
1753 { T4 = T9 / (T2 - T1);
1754 T5 = 1.0 - T4;
1755 T6 = Vdsat * T4 / (T2 - T1);
1756 Vdseff = Vdsat * T5;
1757 dVdseff_dVg = dVdsat_dVg * T5 + T6 * (dT2_dVg - dT1_dVg);
1758 dVdseff_dVd = dVdsat_dVd * T5 + T6 * (dT2_dVd - dT1_dVd);
1759 dVdseff_dVb = dVdsat_dVb * T5 + T6 * (dT2_dVb - dT1_dVb);
1760 }
1761
1762 if (Vds == 0.0)
1763 { Vdseff = 0.0;
1764 dVdseff_dVg = 0.0;
1765 dVdseff_dVb = 0.0;
1766 }
1767
1768 if (Vdseff > Vds)
1769 Vdseff = Vds;
1770 diffVds = Vds - Vdseff;
1771 here->BSIM4Vdseff = Vdseff;
1772
1773 /* Velocity Overshoot */
1774 if((model->BSIM4lambdaGiven) && (model->BSIM4lambda > 0.0) )
1775 {
1776 T1 = Leff * ueff;
1777 T2 = pParam->BSIM4lambda / T1;
1778 T3 = -T2 / T1 * Leff;
1779 dT2_dVd = T3 * dueff_dVd;
1780 dT2_dVg = T3 * dueff_dVg;
1781 dT2_dVb = T3 * dueff_dVb;
1782 T5 = 1.0 / (Esat * pParam->BSIM4litl);
1783 T4 = -T5 / EsatL;
1784 dT5_dVg = dEsatL_dVg * T4;
1785 dT5_dVd = dEsatL_dVd * T4;
1786 dT5_dVb = dEsatL_dVb * T4;
1787 T6 = 1.0 + diffVds * T5;
1788 dT6_dVg = dT5_dVg * diffVds - dVdseff_dVg * T5;
1789 dT6_dVd = dT5_dVd * diffVds + (1.0 - dVdseff_dVd) * T5;
1790 dT6_dVb = dT5_dVb * diffVds - dVdseff_dVb * T5;
1791 T7 = 2.0 / (T6 * T6 + 1.0);
1792 T8 = 1.0 - T7;
1793 T9 = T6 * T7 * T7;
1794 dT8_dVg = T9 * dT6_dVg;
1795 dT8_dVd = T9 * dT6_dVd;
1796 dT8_dVb = T9 * dT6_dVb;
1797 T10 = 1.0 + T2 * T8;
1798 dT10_dVg = dT2_dVg * T8 + T2 * dT8_dVg;
1799 dT10_dVd = dT2_dVd * T8 + T2 * dT8_dVd;
1800 dT10_dVb = dT2_dVb * T8 + T2 * dT8_dVb;
1801 if(T10 == 1.0)
1802 dT10_dVg = dT10_dVd = dT10_dVb = 0.0;
1803
1804 dEsatL_dVg *= T10;
1805 dEsatL_dVg += EsatL * dT10_dVg;
1806 dEsatL_dVd *= T10;
1807 dEsatL_dVd += EsatL * dT10_dVd;
1808 dEsatL_dVb *= T10;
1809 dEsatL_dVb += EsatL * dT10_dVb;
1810 EsatL *= T10;
1811 Esat = EsatL / Leff; /* bugfix by Wenwei Yang (4.6.4) */
1812 here->BSIM4EsatL = EsatL;
1813 }
1814
1815 /* Calculate Vasat */
1816 tmp4 = 1.0 - 0.5 * Abulk * Vdsat / Vgst2Vtm;
1817 T9 = WVCoxRds * Vgsteff;
1818 T8 = T9 / Vgst2Vtm;
1819 T0 = EsatL + Vdsat + 2.0 * T9 * tmp4;
1820
1821 T7 = 2.0 * WVCoxRds * tmp4;
1822 dT0_dVg = dEsatL_dVg + dVdsat_dVg + T7 * (1.0 + tmp2 * Vgsteff)
1823 - T8 * (Abulk * dVdsat_dVg - Abulk * Vdsat / Vgst2Vtm
1824 + Vdsat * dAbulk_dVg);
1825
1826 dT0_dVb = dEsatL_dVb + dVdsat_dVb + T7 * tmp3 * Vgsteff
1827 - T8 * (dAbulk_dVb * Vdsat + Abulk * dVdsat_dVb);
1828 dT0_dVd = dEsatL_dVd + dVdsat_dVd - T8 * Abulk * dVdsat_dVd;
1829
1830 T9 = WVCoxRds * Abulk;
1831 T1 = 2.0 / Lambda - 1.0 + T9;
1832 dT1_dVg = -2.0 * tmp1 + WVCoxRds * (Abulk * tmp2 + dAbulk_dVg);
1833 dT1_dVb = dAbulk_dVb * WVCoxRds + T9 * tmp3;
1834
1835 Vasat = T0 / T1;
1836 dVasat_dVg = (dT0_dVg - Vasat * dT1_dVg) / T1;
1837 dVasat_dVb = (dT0_dVb - Vasat * dT1_dVb) / T1;
1838 dVasat_dVd = dT0_dVd / T1;
1839
1840 /* Calculate Idl first */
1841
1842 tmp1 = here->BSIM4vtfbphi2;
1843 tmp2 = 2.0e8 * here->BSIM4toxp;
1844 dT0_dVg = 1.0 / tmp2;
1845 T0 = (Vgsteff + tmp1) * dT0_dVg;
1846
1847 tmp3 = exp(model->BSIM4bdos * 0.7 * log(T0));
1848 T1 = 1.0 + tmp3;
1849 T2 = model->BSIM4bdos * 0.7 * tmp3 / T0;
1850 Tcen = model->BSIM4ados * 1.9e-9 / T1;
1851 dTcen_dVg = -Tcen * T2 * dT0_dVg / T1;
1852
1853 Coxeff = epssub * here->BSIM4coxp
1854 / (epssub + here->BSIM4coxp * Tcen);
1855 here->BSIM4Coxeff = Coxeff;
1856 dCoxeff_dVg = -Coxeff * Coxeff * dTcen_dVg / epssub;
1857
1858 CoxeffWovL = Coxeff * Weff / Leff;
1859 beta = ueff * CoxeffWovL;
1860 T3 = ueff / Leff;
1861 dbeta_dVg = CoxeffWovL * dueff_dVg + T3
1862 * (Weff * dCoxeff_dVg + Coxeff * dWeff_dVg);
1863 dbeta_dVd = CoxeffWovL * dueff_dVd;
1864 dbeta_dVb = CoxeffWovL * dueff_dVb + T3 * Coxeff * dWeff_dVb;
1865
1866 here->BSIM4AbovVgst2Vtm = Abulk / Vgst2Vtm;
1867 T0 = 1.0 - 0.5 * Vdseff * here->BSIM4AbovVgst2Vtm;
1868 dT0_dVg = -0.5 * (Abulk * dVdseff_dVg
1869 - Abulk * Vdseff / Vgst2Vtm + Vdseff * dAbulk_dVg) / Vgst2Vtm;
1870 dT0_dVd = -0.5 * Abulk * dVdseff_dVd / Vgst2Vtm;
1871 dT0_dVb = -0.5 * (Abulk * dVdseff_dVb + dAbulk_dVb * Vdseff)
1872 / Vgst2Vtm;
1873
1874 fgche1 = Vgsteff * T0;
1875 dfgche1_dVg = Vgsteff * dT0_dVg + T0;
1876 dfgche1_dVd = Vgsteff * dT0_dVd;
1877 dfgche1_dVb = Vgsteff * dT0_dVb;
1878
1879 T9 = Vdseff / EsatL;
1880 fgche2 = 1.0 + T9;
1881 dfgche2_dVg = (dVdseff_dVg - T9 * dEsatL_dVg) / EsatL;
1882 dfgche2_dVd = (dVdseff_dVd - T9 * dEsatL_dVd) / EsatL;
1883 dfgche2_dVb = (dVdseff_dVb - T9 * dEsatL_dVb) / EsatL;
1884
1885 gche = beta * fgche1 / fgche2;
1886 dgche_dVg = (beta * dfgche1_dVg + fgche1 * dbeta_dVg
1887 - gche * dfgche2_dVg) / fgche2;
1888 dgche_dVd = (beta * dfgche1_dVd + fgche1 * dbeta_dVd
1889 - gche * dfgche2_dVd) / fgche2;
1890 dgche_dVb = (beta * dfgche1_dVb + fgche1 * dbeta_dVb
1891 - gche * dfgche2_dVb) / fgche2;
1892
1893 T0 = 1.0 + gche * Rds;
1894 Idl = gche / T0;
1895 T1 = (1.0 - Idl * Rds) / T0;
1896 T2 = Idl * Idl;
1897 dIdl_dVg = T1 * dgche_dVg - T2 * dRds_dVg;
1898 dIdl_dVd = T1 * dgche_dVd;
1899 dIdl_dVb = T1 * dgche_dVb - T2 * dRds_dVb;
1900
1901 /* Calculate degradation factor due to pocket implant */
1902
1903 if (pParam->BSIM4fprout <= 0.0)
1904 { FP = 1.0;
1905 dFP_dVg = 0.0;
1906 }
1907 else
1908 { T9 = pParam->BSIM4fprout * sqrt(Leff) / Vgst2Vtm;
1909 FP = 1.0 / (1.0 + T9);
1910 dFP_dVg = FP * FP * T9 / Vgst2Vtm;
1911 }
1912
1913 /* Calculate VACLM */
1914 T8 = pParam->BSIM4pvag / EsatL;
1915 T9 = T8 * Vgsteff;
1916 if (T9 > -0.9)
1917 { PvagTerm = 1.0 + T9;
1918 dPvagTerm_dVg = T8 * (1.0 - Vgsteff * dEsatL_dVg / EsatL);
1919 dPvagTerm_dVb = -T9 * dEsatL_dVb / EsatL;
1920 dPvagTerm_dVd = -T9 * dEsatL_dVd / EsatL;
1921 }
1922 else
1923 { T4 = 1.0 / (17.0 + 20.0 * T9);
1924 PvagTerm = (0.8 + T9) * T4;
1925 T4 *= T4;
1926 dPvagTerm_dVg = T8 * (1.0 - Vgsteff * dEsatL_dVg / EsatL) * T4;
1927 T9 *= T4 / EsatL;
1928 dPvagTerm_dVb = -T9 * dEsatL_dVb;
1929 dPvagTerm_dVd = -T9 * dEsatL_dVd;
1930 }
1931
1932 if ((pParam->BSIM4pclm > MIN_EXP) && (diffVds > 1.0e-10))
1933 { T0 = 1.0 + Rds * Idl;
1934 dT0_dVg = dRds_dVg * Idl + Rds * dIdl_dVg;
1935 dT0_dVd = Rds * dIdl_dVd;
1936 dT0_dVb = dRds_dVb * Idl + Rds * dIdl_dVb;
1937
1938 T2 = Vdsat / Esat;
1939 T1 = Leff + T2;
1940 dT1_dVg = (dVdsat_dVg - T2 * dEsatL_dVg / Leff) / Esat;
1941 dT1_dVd = (dVdsat_dVd - T2 * dEsatL_dVd / Leff) / Esat;
1942 dT1_dVb = (dVdsat_dVb - T2 * dEsatL_dVb / Leff) / Esat;
1943
1944 Cclm = FP * PvagTerm * T0 * T1 / (pParam->BSIM4pclm * pParam->BSIM4litl);
1945 dCclm_dVg = Cclm * (dFP_dVg / FP + dPvagTerm_dVg / PvagTerm
1946 + dT0_dVg / T0 + dT1_dVg / T1);
1947 dCclm_dVb = Cclm * (dPvagTerm_dVb / PvagTerm + dT0_dVb / T0
1948 + dT1_dVb / T1);
1949 dCclm_dVd = Cclm * (dPvagTerm_dVd / PvagTerm + dT0_dVd / T0
1950 + dT1_dVd / T1);
1951 VACLM = Cclm * diffVds;
1952
1953 dVACLM_dVg = dCclm_dVg * diffVds - dVdseff_dVg * Cclm;
1954 dVACLM_dVb = dCclm_dVb * diffVds - dVdseff_dVb * Cclm;
1955 dVACLM_dVd = dCclm_dVd * diffVds + (1.0 - dVdseff_dVd) * Cclm;
1956 }
1957 else
1958 { VACLM = Cclm = MAX_EXP;
1959 dVACLM_dVd = dVACLM_dVg = dVACLM_dVb = 0.0;
1960 dCclm_dVd = dCclm_dVg = dCclm_dVb = 0.0;
1961 }
1962
1963 /* Calculate VADIBL */
1964 if (pParam->BSIM4thetaRout > MIN_EXP)
1965 { T8 = Abulk * Vdsat;
1966 T0 = Vgst2Vtm * T8;
1967 dT0_dVg = Vgst2Vtm * Abulk * dVdsat_dVg + T8
1968 + Vgst2Vtm * Vdsat * dAbulk_dVg;
1969 dT0_dVb = Vgst2Vtm * (dAbulk_dVb * Vdsat + Abulk * dVdsat_dVb);
1970 dT0_dVd = Vgst2Vtm * Abulk * dVdsat_dVd;
1971
1972 T1 = Vgst2Vtm + T8;
1973 dT1_dVg = 1.0 + Abulk * dVdsat_dVg + Vdsat * dAbulk_dVg;
1974 dT1_dVb = Abulk * dVdsat_dVb + dAbulk_dVb * Vdsat;
1975 dT1_dVd = Abulk * dVdsat_dVd;
1976
1977 T9 = T1 * T1;
1978 T2 = pParam->BSIM4thetaRout;
1979 VADIBL = (Vgst2Vtm - T0 / T1) / T2;
1980 dVADIBL_dVg = (1.0 - dT0_dVg / T1 + T0 * dT1_dVg / T9) / T2;
1981 dVADIBL_dVb = (-dT0_dVb / T1 + T0 * dT1_dVb / T9) / T2;
1982 dVADIBL_dVd = (-dT0_dVd / T1 + T0 * dT1_dVd / T9) / T2;
1983
1984 T7 = pParam->BSIM4pdiblb * Vbseff;
1985 if (T7 >= -0.9)
1986 { T3 = 1.0 / (1.0 + T7);
1987 VADIBL *= T3;
1988 dVADIBL_dVg *= T3;
1989 dVADIBL_dVb = (dVADIBL_dVb - VADIBL * pParam->BSIM4pdiblb)
1990 * T3;
1991 dVADIBL_dVd *= T3;
1992 }
1993 else
1994 { T4 = 1.0 / (0.8 + T7);
1995 T3 = (17.0 + 20.0 * T7) * T4;
1996 dVADIBL_dVg *= T3;
1997 dVADIBL_dVb = dVADIBL_dVb * T3
1998 - VADIBL * pParam->BSIM4pdiblb * T4 * T4;
1999 dVADIBL_dVd *= T3;
2000 VADIBL *= T3;
2001 }
2002
2003 dVADIBL_dVg = dVADIBL_dVg * PvagTerm + VADIBL * dPvagTerm_dVg;
2004 dVADIBL_dVb = dVADIBL_dVb * PvagTerm + VADIBL * dPvagTerm_dVb;
2005 dVADIBL_dVd = dVADIBL_dVd * PvagTerm + VADIBL * dPvagTerm_dVd;
2006 VADIBL *= PvagTerm;
2007 }
2008 else
2009 { VADIBL = MAX_EXP;
2010 dVADIBL_dVd = dVADIBL_dVg = dVADIBL_dVb = 0.0;
2011 }
2012
2013 /* Calculate Va */
2014 Va = Vasat + VACLM;
2015 dVa_dVg = dVasat_dVg + dVACLM_dVg;
2016 dVa_dVb = dVasat_dVb + dVACLM_dVb;
2017 dVa_dVd = dVasat_dVd + dVACLM_dVd;
2018
2019 /* Calculate VADITS */
2020 T0 = pParam->BSIM4pditsd * Vds;
2021 if (T0 > EXP_THRESHOLD)
2022 { T1 = MAX_EXP;
2023 dT1_dVd = 0;
2024 }
2025 else
2026 { T1 = exp(T0);
2027 dT1_dVd = T1 * pParam->BSIM4pditsd;
2028 }
2029
2030 if (pParam->BSIM4pdits > MIN_EXP)
2031 { T2 = 1.0 + model->BSIM4pditsl * Leff;
2032 VADITS = (1.0 + T2 * T1) / pParam->BSIM4pdits;
2033 dVADITS_dVg = VADITS * dFP_dVg;
2034 dVADITS_dVd = FP * T2 * dT1_dVd / pParam->BSIM4pdits;
2035 VADITS *= FP;
2036 }
2037 else
2038 { VADITS = MAX_EXP;
2039 dVADITS_dVg = dVADITS_dVd = 0;
2040 }
2041
2042 /* Calculate VASCBE */
2043 if ((pParam->BSIM4pscbe2 > 0.0)&&(pParam->BSIM4pscbe1>=0.0)) /*4.6.2*/
2044 { if (diffVds > pParam->BSIM4pscbe1 * pParam->BSIM4litl
2045 / EXP_THRESHOLD)
2046 { T0 = pParam->BSIM4pscbe1 * pParam->BSIM4litl / diffVds;
2047 VASCBE = Leff * exp(T0) / pParam->BSIM4pscbe2;
2048 T1 = T0 * VASCBE / diffVds;
2049 dVASCBE_dVg = T1 * dVdseff_dVg;
2050 dVASCBE_dVd = -T1 * (1.0 - dVdseff_dVd);
2051 dVASCBE_dVb = T1 * dVdseff_dVb;
2052 }
2053 else
2054 { VASCBE = MAX_EXP * Leff/pParam->BSIM4pscbe2;
2055 dVASCBE_dVg = dVASCBE_dVd = dVASCBE_dVb = 0.0;
2056 }
2057 }
2058 else
2059 { VASCBE = MAX_EXP;
2060 dVASCBE_dVg = dVASCBE_dVd = dVASCBE_dVb = 0.0;
2061 }
2062
2063 /* Add DIBL to Ids */
2064 T9 = diffVds / VADIBL;
2065 T0 = 1.0 + T9;
2066 Idsa = Idl * T0;
2067 dIdsa_dVg = T0 * dIdl_dVg - Idl * (dVdseff_dVg + T9 * dVADIBL_dVg) / VADIBL;
2068 dIdsa_dVd = T0 * dIdl_dVd + Idl
2069 * (1.0 - dVdseff_dVd - T9 * dVADIBL_dVd) / VADIBL;
2070 dIdsa_dVb = T0 * dIdl_dVb - Idl * (dVdseff_dVb + T9 * dVADIBL_dVb) / VADIBL;
2071
2072 /* Add DITS to Ids */
2073 T9 = diffVds / VADITS;
2074 T0 = 1.0 + T9;
2075 dIdsa_dVg = T0 * dIdsa_dVg - Idsa * (dVdseff_dVg + T9 * dVADITS_dVg) / VADITS;
2076 dIdsa_dVd = T0 * dIdsa_dVd + Idsa
2077 * (1.0 - dVdseff_dVd - T9 * dVADITS_dVd) / VADITS;
2078 dIdsa_dVb = T0 * dIdsa_dVb - Idsa * dVdseff_dVb / VADITS;
2079 Idsa *= T0;
2080
2081 /* Add CLM to Ids */
2082 T0 = log(Va / Vasat);
2083 dT0_dVg = dVa_dVg / Va - dVasat_dVg / Vasat;
2084 dT0_dVb = dVa_dVb / Va - dVasat_dVb / Vasat;
2085 dT0_dVd = dVa_dVd / Va - dVasat_dVd / Vasat;
2086 T1 = T0 / Cclm;
2087 T9 = 1.0 + T1;
2088 dT9_dVg = (dT0_dVg - T1 * dCclm_dVg) / Cclm;
2089 dT9_dVb = (dT0_dVb - T1 * dCclm_dVb) / Cclm;
2090 dT9_dVd = (dT0_dVd - T1 * dCclm_dVd) / Cclm;
2091
2092 dIdsa_dVg = dIdsa_dVg * T9 + Idsa * dT9_dVg;
2093 dIdsa_dVb = dIdsa_dVb * T9 + Idsa * dT9_dVb;
2094 dIdsa_dVd = dIdsa_dVd * T9 + Idsa * dT9_dVd;
2095 Idsa *= T9;
2096
2097 /* Substrate current begins */
2098 tmp = pParam->BSIM4alpha0 + pParam->BSIM4alpha1 * Leff;
2099 if ((tmp <= 0.0) || (pParam->BSIM4beta0 <= 0.0))
2100 { Isub = Gbd = Gbb = Gbg = 0.0;
2101 }
2102 else
2103 { T2 = tmp / Leff;
2104 if (diffVds > pParam->BSIM4beta0 / EXP_THRESHOLD)
2105 { T0 = -pParam->BSIM4beta0 / diffVds;
2106 T1 = T2 * diffVds * exp(T0);
2107 T3 = T1 / diffVds * (T0 - 1.0);
2108 dT1_dVg = T3 * dVdseff_dVg;
2109 dT1_dVd = T3 * (dVdseff_dVd - 1.0);
2110 dT1_dVb = T3 * dVdseff_dVb;
2111 }
2112 else
2113 { T3 = T2 * MIN_EXP;
2114 T1 = T3 * diffVds;
2115 dT1_dVg = -T3 * dVdseff_dVg;
2116 dT1_dVd = T3 * (1.0 - dVdseff_dVd);
2117 dT1_dVb = -T3 * dVdseff_dVb;
2118 }
2119 T4 = Idsa * Vdseff;
2120 Isub = T1 * T4;
2121 Gbg = T1 * (dIdsa_dVg * Vdseff + Idsa * dVdseff_dVg)
2122 + T4 * dT1_dVg;
2123 Gbd = T1 * (dIdsa_dVd * Vdseff + Idsa * dVdseff_dVd)
2124 + T4 * dT1_dVd;
2125 Gbb = T1 * (dIdsa_dVb * Vdseff + Idsa * dVdseff_dVb)
2126 + T4 * dT1_dVb;
2127
2128 Gbd += Gbg * dVgsteff_dVd;
2129 Gbb += Gbg * dVgsteff_dVb;
2130 Gbg *= dVgsteff_dVg;
2131 Gbb *= dVbseff_dVb;
2132 }
2133 here->BSIM4csub = Isub;
2134 here->BSIM4gbbs = Gbb;
2135 here->BSIM4gbgs = Gbg;
2136 here->BSIM4gbds = Gbd;
2137
2138 /* Add SCBE to Ids */
2139 T9 = diffVds / VASCBE;
2140 T0 = 1.0 + T9;
2141 Ids = Idsa * T0;
2142
2143 Gm = T0 * dIdsa_dVg - Idsa
2144 * (dVdseff_dVg + T9 * dVASCBE_dVg) / VASCBE;
2145 Gds = T0 * dIdsa_dVd + Idsa
2146 * (1.0 - dVdseff_dVd - T9 * dVASCBE_dVd) / VASCBE;
2147 Gmb = T0 * dIdsa_dVb - Idsa
2148 * (dVdseff_dVb + T9 * dVASCBE_dVb) / VASCBE;
2149
2150
2151 tmp1 = Gds + Gm * dVgsteff_dVd;
2152 tmp2 = Gmb + Gm * dVgsteff_dVb;
2153 tmp3 = Gm;
2154
2155 Gm = (Ids * dVdseff_dVg + Vdseff * tmp3) * dVgsteff_dVg;
2156 Gds = Ids * (dVdseff_dVd + dVdseff_dVg * dVgsteff_dVd)
2157 + Vdseff * tmp1;
2158 Gmb = (Ids * (dVdseff_dVb + dVdseff_dVg * dVgsteff_dVb)
2159 + Vdseff * tmp2) * dVbseff_dVb;
2160
2161 cdrain = Ids * Vdseff;
2162
2163 /* Source End Velocity Limit */
2164 if((model->BSIM4vtlGiven) && (model->BSIM4vtl > 0.0) ) {
2165 T12 = 1.0 / Leff / CoxeffWovL;
2166 T11 = T12 / Vgsteff;
2167 T10 = -T11 / Vgsteff;
2168 vs = cdrain * T11; /* vs */
2169 dvs_dVg = Gm * T11 + cdrain * T10 * dVgsteff_dVg;
2170 dvs_dVd = Gds * T11 + cdrain * T10 * dVgsteff_dVd;
2171 dvs_dVb = Gmb * T11 + cdrain * T10 * dVgsteff_dVb;
2172 T0 = 2 * MM;
2173 T1 = vs / (pParam->BSIM4vtl * pParam->BSIM4tfactor);
2174 if(T1 > 0.0)
2175 { T2 = 1.0 + exp(T0 * log(T1));
2176 T3 = (T2 - 1.0) * T0 / vs;
2177 Fsevl = 1.0 / exp(log(T2)/ T0);
2178 dT2_dVg = T3 * dvs_dVg;
2179 dT2_dVd = T3 * dvs_dVd;
2180 dT2_dVb = T3 * dvs_dVb;
2181 T4 = -1.0 / T0 * Fsevl / T2;
2182 dFsevl_dVg = T4 * dT2_dVg;
2183 dFsevl_dVd = T4 * dT2_dVd;
2184 dFsevl_dVb = T4 * dT2_dVb;
2185 } else {
2186 Fsevl = 1.0;
2187 dFsevl_dVg = 0.0;
2188 dFsevl_dVd = 0.0;
2189 dFsevl_dVb = 0.0;
2190 }
2191 Gm *=Fsevl;
2192 Gm += cdrain * dFsevl_dVg;
2193 Gmb *=Fsevl;
2194 Gmb += cdrain * dFsevl_dVb;
2195 Gds *=Fsevl;
2196 Gds += cdrain * dFsevl_dVd;
2197
2198 cdrain *= Fsevl;
2199 }
2200
2201 here->BSIM4gds = Gds;
2202 here->BSIM4gm = Gm;
2203 here->BSIM4gmbs = Gmb;
2204 here->BSIM4IdovVds = Ids;
2205 if( here->BSIM4IdovVds <= 1.0e-9) here->BSIM4IdovVds = 1.0e-9;
2206
2207 /* Calculate Rg */
2208 if ((here->BSIM4rgateMod > 1) ||
2209 (here->BSIM4trnqsMod != 0) || (here->BSIM4acnqsMod != 0))
2210 { T9 = pParam->BSIM4xrcrg2 * model->BSIM4vtm;
2211 T0 = T9 * beta;
2212 dT0_dVd = (dbeta_dVd + dbeta_dVg * dVgsteff_dVd) * T9;
2213 dT0_dVb = (dbeta_dVb + dbeta_dVg * dVgsteff_dVb) * T9;
2214 dT0_dVg = dbeta_dVg * T9;
2215
2216 here->BSIM4gcrg = pParam->BSIM4xrcrg1 * ( T0 + Ids);
2217 here->BSIM4gcrgd = pParam->BSIM4xrcrg1 * (dT0_dVd + tmp1);
2218 here->BSIM4gcrgb = pParam->BSIM4xrcrg1 * (dT0_dVb + tmp2)
2219 * dVbseff_dVb;
2220 here->BSIM4gcrgg = pParam->BSIM4xrcrg1 * (dT0_dVg + tmp3)
2221 * dVgsteff_dVg;
2222
2223 if (here->BSIM4nf != 1.0)
2224 { here->BSIM4gcrg *= here->BSIM4nf;
2225 here->BSIM4gcrgg *= here->BSIM4nf;
2226 here->BSIM4gcrgd *= here->BSIM4nf;
2227 here->BSIM4gcrgb *= here->BSIM4nf;
2228 }
2229
2230 if (here->BSIM4rgateMod == 2)
2231 { T10 = here->BSIM4grgeltd * here->BSIM4grgeltd;
2232 T11 = here->BSIM4grgeltd + here->BSIM4gcrg;
2233 here->BSIM4gcrg = here->BSIM4grgeltd * here->BSIM4gcrg / T11;
2234 T12 = T10 / T11 / T11;
2235 here->BSIM4gcrgg *= T12;
2236 here->BSIM4gcrgd *= T12;
2237 here->BSIM4gcrgb *= T12;
2238 }
2239 here->BSIM4gcrgs = -(here->BSIM4gcrgg + here->BSIM4gcrgd
2240 + here->BSIM4gcrgb);
2241 }
2242
2243
2244 /* Calculate bias-dependent external S/D resistance */
2245 if (model->BSIM4rdsMod)
2246 { /* Rs(V) */
2247 T0 = vgs - pParam->BSIM4vfbsd;
2248 T1 = sqrt(T0 * T0 + 1.0e-4);
2249 vgs_eff = 0.5 * (T0 + T1);
2250 dvgs_eff_dvg = vgs_eff / T1;
2251
2252 T0 = 1.0 + pParam->BSIM4prwg * vgs_eff;
2253 dT0_dvg = -pParam->BSIM4prwg / T0 / T0 * dvgs_eff_dvg;
2254 T1 = -pParam->BSIM4prwb * vbs;
2255 dT1_dvb = -pParam->BSIM4prwb;
2256
2257 T2 = 1.0 / T0 + T1;
2258 T3 = T2 + sqrt(T2 * T2 + 0.01);
2259 dT3_dvg = T3 / (T3 - T2);
2260 dT3_dvb = dT3_dvg * dT1_dvb;
2261 dT3_dvg *= dT0_dvg;
2262
2263 T4 = pParam->BSIM4rs0 * 0.5;
2264 Rs = pParam->BSIM4rswmin + T3 * T4;
2265 dRs_dvg = T4 * dT3_dvg;
2266 dRs_dvb = T4 * dT3_dvb;
2267
2268 T0 = 1.0 + here->BSIM4sourceConductance * Rs;
2269 here->BSIM4gstot = here->BSIM4sourceConductance / T0;
2270 T0 = -here->BSIM4gstot * here->BSIM4gstot;
2271 dgstot_dvd = 0.0; /* place holder */
2272 dgstot_dvg = T0 * dRs_dvg;
2273 dgstot_dvb = T0 * dRs_dvb;
2274 dgstot_dvs = -(dgstot_dvg + dgstot_dvb + dgstot_dvd);
2275
2276 /* Rd(V) */
2277 T0 = vgd - pParam->BSIM4vfbsd;
2278 T1 = sqrt(T0 * T0 + 1.0e-4);
2279 vgd_eff = 0.5 * (T0 + T1);
2280 dvgd_eff_dvg = vgd_eff / T1;
2281
2282 T0 = 1.0 + pParam->BSIM4prwg * vgd_eff;
2283 dT0_dvg = -pParam->BSIM4prwg / T0 / T0 * dvgd_eff_dvg;
2284 T1 = -pParam->BSIM4prwb * vbd;
2285 dT1_dvb = -pParam->BSIM4prwb;
2286
2287 T2 = 1.0 / T0 + T1;
2288 T3 = T2 + sqrt(T2 * T2 + 0.01);
2289 dT3_dvg = T3 / (T3 - T2);
2290 dT3_dvb = dT3_dvg * dT1_dvb;
2291 dT3_dvg *= dT0_dvg;
2292
2293 T4 = pParam->BSIM4rd0 * 0.5;
2294 Rd = pParam->BSIM4rdwmin + T3 * T4;
2295 dRd_dvg = T4 * dT3_dvg;
2296 dRd_dvb = T4 * dT3_dvb;
2297
2298 T0 = 1.0 + here->BSIM4drainConductance * Rd;
2299 here->BSIM4gdtot = here->BSIM4drainConductance / T0;
2300 T0 = -here->BSIM4gdtot * here->BSIM4gdtot;
2301 dgdtot_dvs = 0.0;
2302 dgdtot_dvg = T0 * dRd_dvg;
2303 dgdtot_dvb = T0 * dRd_dvb;
2304 dgdtot_dvd = -(dgdtot_dvg + dgdtot_dvb + dgdtot_dvs);
2305
2306 here->BSIM4gstotd = vses * dgstot_dvd;
2307 here->BSIM4gstotg = vses * dgstot_dvg;
2308 here->BSIM4gstots = vses * dgstot_dvs;
2309 here->BSIM4gstotb = vses * dgstot_dvb;
2310
2311 T2 = vdes - vds;
2312 here->BSIM4gdtotd = T2 * dgdtot_dvd;
2313 here->BSIM4gdtotg = T2 * dgdtot_dvg;
2314 here->BSIM4gdtots = T2 * dgdtot_dvs;
2315 here->BSIM4gdtotb = T2 * dgdtot_dvb;
2316 }
2317 else /* WDLiu: for bypass */
2318 { here->BSIM4gstot = here->BSIM4gstotd = here->BSIM4gstotg = 0.0;
2319 here->BSIM4gstots = here->BSIM4gstotb = 0.0;
2320 here->BSIM4gdtot = here->BSIM4gdtotd = here->BSIM4gdtotg = 0.0;
2321 here->BSIM4gdtots = here->BSIM4gdtotb = 0.0;
2322 }
2323
2324 /* GIDL/GISL Models */
2325
2326 if(model->BSIM4mtrlMod == 0)
2327 T0 = 3.0 * toxe;
2328 else
2329 T0 = model->BSIM4epsrsub * toxe / epsrox;
2330
2331 /* Calculate GIDL current */
2332
2333 vgs_eff = here->BSIM4vgs_eff;
2334 dvgs_eff_dvg = here->BSIM4dvgs_eff_dvg;
2335 vgd_eff = here->BSIM4vgd_eff;
2336 dvgd_eff_dvg = here->BSIM4dvgd_eff_dvg;
2337
2338 if (model->BSIM4gidlMod==0){
2339
2340 if(model->BSIM4mtrlMod ==0)
2341 T1 = (vds - vgs_eff - pParam->BSIM4egidl ) / T0;
2342 else
2343 T1 = (vds - vgs_eff - pParam->BSIM4egidl + pParam->BSIM4vfbsd) / T0;
2344
2345 if ((pParam->BSIM4agidl <= 0.0) || (pParam->BSIM4bgidl <= 0.0)
2346 || (T1 <= 0.0) || (pParam->BSIM4cgidl <= 0.0) || (vbd > 0.0))
2347 Igidl = Ggidld = Ggidlg = Ggidlb = 0.0;
2348 else {
2349 dT1_dVd = 1.0 / T0;
2350 dT1_dVg = -dvgs_eff_dvg * dT1_dVd;
2351 T2 = pParam->BSIM4bgidl / T1;
2352 if (T2 < 100.0)
2353 { Igidl = pParam->BSIM4agidl * pParam->BSIM4weffCJ * T1 * exp(-T2);
2354 T3 = Igidl * (1.0 + T2) / T1;
2355 Ggidld = T3 * dT1_dVd;
2356 Ggidlg = T3 * dT1_dVg;
2357 }
2358 else
2359 { Igidl = pParam->BSIM4agidl * pParam->BSIM4weffCJ * 3.720075976e-44;
2360 Ggidld = Igidl * dT1_dVd;
2361 Ggidlg = Igidl * dT1_dVg;
2362 Igidl *= T1;
2363 }
2364
2365 T4 = vbd * vbd;
2366 T5 = -vbd * T4;
2367 T6 = pParam->BSIM4cgidl + T5;
2368 T7 = T5 / T6;
2369 T8 = 3.0 * pParam->BSIM4cgidl * T4 / T6 / T6;
2370 Ggidld = Ggidld * T7 + Igidl * T8;
2371 Ggidlg = Ggidlg * T7;
2372 Ggidlb = -Igidl * T8;
2373 Igidl *= T7;
2374 }
2375 here->BSIM4Igidl = Igidl;
2376 here->BSIM4ggidld = Ggidld;
2377 here->BSIM4ggidlg = Ggidlg;
2378 here->BSIM4ggidlb = Ggidlb;
2379 /* Calculate GISL current */
2380
2381 if(model->BSIM4mtrlMod ==0)
2382 T1 = (-vds - vgd_eff - pParam->BSIM4egisl ) / T0;
2383 else
2384 T1 = (-vds - vgd_eff - pParam->BSIM4egisl + pParam->BSIM4vfbsd ) / T0;
2385
2386 if ((pParam->BSIM4agisl <= 0.0) || (pParam->BSIM4bgisl <= 0.0)
2387 || (T1 <= 0.0) || (pParam->BSIM4cgisl <= 0.0) || (vbs > 0.0))
2388 Igisl = Ggisls = Ggislg = Ggislb = 0.0;
2389 else {
2390 dT1_dVd = 1.0 / T0;
2391 dT1_dVg = -dvgd_eff_dvg * dT1_dVd;
2392 T2 = pParam->BSIM4bgisl / T1;
2393 if (T2 < 100.0)
2394 { Igisl = pParam->BSIM4agisl * pParam->BSIM4weffCJ * T1 * exp(-T2);
2395 T3 = Igisl * (1.0 + T2) / T1;
2396 Ggisls = T3 * dT1_dVd;
2397 Ggislg = T3 * dT1_dVg;
2398 }
2399 else
2400 { Igisl = pParam->BSIM4agisl * pParam->BSIM4weffCJ * 3.720075976e-44;
2401 Ggisls = Igisl * dT1_dVd;
2402 Ggislg = Igisl * dT1_dVg;
2403 Igisl *= T1;
2404 }
2405
2406 T4 = vbs * vbs;
2407 T5 = -vbs * T4;
2408 T6 = pParam->BSIM4cgisl + T5;
2409 T7 = T5 / T6;
2410 T8 = 3.0 * pParam->BSIM4cgisl * T4 / T6 / T6;
2411 Ggisls = Ggisls * T7 + Igisl * T8;
2412 Ggislg = Ggislg * T7;
2413 Ggislb = -Igisl * T8;
2414 Igisl *= T7;
2415 }
2416 here->BSIM4Igisl = Igisl;
2417 here->BSIM4ggisls = Ggisls;
2418 here->BSIM4ggislg = Ggislg;
2419 here->BSIM4ggislb = Ggislb;
2420 }
2421 else{
2422 /* v4.7 New Gidl/GISL model */
2423
2424 /* GISL */
2425 if (model->BSIM4mtrlMod==0)
2426 T1 = (-vds - pParam->BSIM4rgisl * vgd_eff - pParam->BSIM4egisl) / T0;
2427 else
2428 T1 = (-vds - pParam->BSIM4rgisl * vgd_eff - pParam->BSIM4egisl + pParam->BSIM4vfbsd) / T0;
2429
2430 if ((pParam->BSIM4agisl <= 0.0) ||
2431 (pParam->BSIM4bgisl <= 0.0) || (T1 <= 0.0) ||
2432 (pParam->BSIM4cgisl < 0.0) )
2433 Igisl = Ggisls = Ggislg = Ggislb = 0.0;
2434 else
2435 {
2436 dT1_dVd = 1 / T0;
2437 dT1_dVg = - pParam->BSIM4rgisl * dT1_dVd * dvgd_eff_dvg;
2438 T2 = pParam->BSIM4bgisl / T1;
2439 if (T2 < EXPL_THRESHOLD)
2440 {
2441 Igisl = pParam->BSIM4weffCJ * pParam->BSIM4agisl * T1 * exp(-T2);
2442 T3 = Igisl / T1 * (T2 + 1);
2443 Ggisls = T3 * dT1_dVd;
2444 Ggislg = T3 * dT1_dVg;
2445 }
2446 else
2447 {
2448 T3 = pParam->BSIM4weffCJ * pParam->BSIM4agisl * MIN_EXPL;
2449 Igisl = T3 * T1 ;
2450 Ggisls = T3 * dT1_dVd;
2451 Ggislg = T3 * dT1_dVg;
2452
2453 }
2454 T4 = vbs - pParam->BSIM4fgisl;
2455
2456 if (T4==0)
2457 T5 = EXPL_THRESHOLD;
2458 else
2459 T5 = pParam->BSIM4kgisl / T4;
2460 if (T5<EXPL_THRESHOLD)
2461 {T6 = exp(T5);
2462 Ggislb = -Igisl * T6 * T5 / T4;
2463 }
2464 else
2465 {T6 = MAX_EXPL;
2466 Ggislb=0.0;
2467 }
2468 Ggisls*=T6;
2469 Ggislg*=T6;
2470 Igisl*=T6;
2471
2472 }
2473 here->BSIM4Igisl = Igisl;
2474 here->BSIM4ggisls = Ggisls;
2475 here->BSIM4ggislg = Ggislg;
2476 here->BSIM4ggislb = Ggislb;
2477 /* End of GISL */
2478
2479 /* GIDL */
2480 if (model->BSIM4mtrlMod==0)
2481 T1 = (vds - pParam->BSIM4rgidl * vgs_eff - pParam->BSIM4egidl) / T0;
2482 else
2483 T1 = (vds - pParam->BSIM4rgidl * vgs_eff - pParam->BSIM4egidl + pParam->BSIM4vfbsd) / T0;
2484
2485
2486
2487 if ((pParam->BSIM4agidl <= 0.0) ||
2488 (pParam->BSIM4bgidl <= 0.0) || (T1 <= 0.0) ||
2489 (pParam->BSIM4cgidl < 0.0) )
2490 Igidl = Ggidld = Ggidlg = Ggidlb = 0.0;
2491 else
2492 {
2493 dT1_dVd = 1 / T0;
2494 dT1_dVg = - pParam->BSIM4rgidl * dT1_dVd * dvgs_eff_dvg;
2495 T2 = pParam->BSIM4bgidl / T1;
2496 if (T2 < EXPL_THRESHOLD)
2497 {
2498 Igidl = pParam->BSIM4weffCJ * pParam->BSIM4agidl * T1 * exp(-T2);
2499 T3 = Igidl / T1 * (T2 + 1);
2500 Ggidld = T3 * dT1_dVd;
2501 Ggidlg = T3 * dT1_dVg;
2502
2503 } else
2504 {
2505 T3 = pParam->BSIM4weffCJ * pParam->BSIM4agidl * MIN_EXPL;
2506 Igidl = T3 * T1 ;
2507 Ggidld = T3 * dT1_dVd;
2508 Ggidlg = T3 * dT1_dVg;
2509 }
2510 T4 = vbd - pParam->BSIM4fgidl;
2511 if (T4==0)
2512 T5 = EXPL_THRESHOLD;
2513 else
2514 T5 = pParam->BSIM4kgidl / T4;
2515 if (T5<EXPL_THRESHOLD)
2516 {T6 = exp(T5);
2517 Ggidlb = -Igidl * T6 * T5 / T4;
2518 }
2519 else
2520 {T6 = MAX_EXPL;
2521 Ggidlb=0.0;
2522 }
2523 Ggidld *= T6;
2524 Ggidlg *= T6;
2525 Igidl *= T6;
2526 }
2527 here->BSIM4Igidl = Igidl;
2528 here->BSIM4ggidld = Ggidld;
2529 here->BSIM4ggidlg = Ggidlg;
2530 here->BSIM4ggidlb = Ggidlb;
2531 /* End of New GIDL */
2532 }
2533 /*End of Gidl*/
2534
2535
2536
2537 /* Calculate gate tunneling current */
2538 if ((model->BSIM4igcMod != 0) || (model->BSIM4igbMod != 0))
2539 { Vfb = here->BSIM4vfbzb;
2540 V3 = Vfb - Vgs_eff + Vbseff - DELTA_3;
2541 if (Vfb <= 0.0)
2542 T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * Vfb);
2543 else
2544 T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * Vfb);
2545 T1 = 0.5 * (1.0 + V3 / T0);
2546 Vfbeff = Vfb - 0.5 * (V3 + T0);
2547 dVfbeff_dVg = T1 * dVgs_eff_dVg;
2548 dVfbeff_dVb = -T1; /* WDLiu: -No surprise? No. -Good! */
2549
2550 Voxacc = Vfb - Vfbeff;
2551 dVoxacc_dVg = -dVfbeff_dVg;
2552 dVoxacc_dVb = -dVfbeff_dVb;
2553 if (Voxacc < 0.0) /* WDLiu: Avoiding numerical instability. */
2554 Voxacc = dVoxacc_dVg = dVoxacc_dVb = 0.0;
2555
2556 T0 = 0.5 * pParam->BSIM4k1ox;
2557 T3 = Vgs_eff - Vfbeff - Vbseff - Vgsteff;
2558 if (pParam->BSIM4k1ox == 0.0)
2559 Voxdepinv = dVoxdepinv_dVg = dVoxdepinv_dVd
2560 = dVoxdepinv_dVb = 0.0;
2561 else if (T3 < 0.0)
2562 { Voxdepinv = -T3;
2563 dVoxdepinv_dVg = -dVgs_eff_dVg + dVfbeff_dVg
2564 + dVgsteff_dVg;
2565 dVoxdepinv_dVd = dVgsteff_dVd;
2566 dVoxdepinv_dVb = dVfbeff_dVb + 1.0 + dVgsteff_dVb;
2567 }
2568 else
2569 { T1 = sqrt(T0 * T0 + T3);
2570 T2 = T0 / T1;
2571 Voxdepinv = pParam->BSIM4k1ox * (T1 - T0);
2572 dVoxdepinv_dVg = T2 * (dVgs_eff_dVg - dVfbeff_dVg
2573 - dVgsteff_dVg);
2574 dVoxdepinv_dVd = -T2 * dVgsteff_dVd;
2575 dVoxdepinv_dVb = -T2 * (dVfbeff_dVb + 1.0 + dVgsteff_dVb);
2576 }
2577
2578 Voxdepinv += Vgsteff;
2579 dVoxdepinv_dVg += dVgsteff_dVg;
2580 dVoxdepinv_dVd += dVgsteff_dVd;
2581 dVoxdepinv_dVb += dVgsteff_dVb;
2582 }
2583
2584 if(model->BSIM4tempMod < 2)
2585 tmp = Vtm;
2586 else /* model->BSIM4tempMod = 2 , 3*/
2587 tmp = Vtm0;
2588 if (model->BSIM4igcMod)
2589 { T0 = tmp * pParam->BSIM4nigc;
2590 if(model->BSIM4igcMod == 1) {
2591 VxNVt = (Vgs_eff - model->BSIM4type * here->BSIM4vth0) / T0;
2592 if (VxNVt > EXP_THRESHOLD)
2593 { Vaux = Vgs_eff - model->BSIM4type * here->BSIM4vth0;
2594 dVaux_dVg = dVgs_eff_dVg;
2595 dVaux_dVd = 0.0;
2596 dVaux_dVb = 0.0;
2597 }
2598 } else if (model->BSIM4igcMod == 2) {
2599 VxNVt = (Vgs_eff - here->BSIM4von) / T0;
2600 if (VxNVt > EXP_THRESHOLD)
2601 { Vaux = Vgs_eff - here->BSIM4von;
2602 dVaux_dVg = dVgs_eff_dVg;
2603 dVaux_dVd = -dVth_dVd;
2604 dVaux_dVb = -dVth_dVb;
2605 }
2606 }
2607 if (VxNVt < -EXP_THRESHOLD)
2608 { Vaux = T0 * log(1.0 + MIN_EXP);
2609 dVaux_dVg = dVaux_dVd = dVaux_dVb = 0.0;
2610 }
2611 else if ((VxNVt >= -EXP_THRESHOLD) && (VxNVt <= EXP_THRESHOLD))
2612 { ExpVxNVt = exp(VxNVt);
2613 Vaux = T0 * log(1.0 + ExpVxNVt);
2614 dVaux_dVg = ExpVxNVt / (1.0 + ExpVxNVt);
2615 if(model->BSIM4igcMod == 1) {
2616 dVaux_dVd = 0.0;
2617 dVaux_dVb = 0.0;
2618 } else if (model->BSIM4igcMod == 2) {
2619 dVaux_dVd = -dVaux_dVg* dVth_dVd; /* Synopsys 08/30/2013 modify */
2620 dVaux_dVb = -dVaux_dVg* dVth_dVb; /* Synopsys 08/30/2013 modify */
2621 }
2622 dVaux_dVg *= dVgs_eff_dVg;
2623 }
2624
2625 T2 = Vgs_eff * Vaux;
2626 dT2_dVg = dVgs_eff_dVg * Vaux + Vgs_eff * dVaux_dVg;
2627 dT2_dVd = Vgs_eff * dVaux_dVd;
2628 dT2_dVb = Vgs_eff * dVaux_dVb;
2629
2630 T11 = pParam->BSIM4Aechvb;
2631 T12 = pParam->BSIM4Bechvb;
2632 T3 = pParam->BSIM4aigc * pParam->BSIM4cigc
2633 - pParam->BSIM4bigc;
2634 T4 = pParam->BSIM4bigc * pParam->BSIM4cigc;
2635 T5 = T12 * (pParam->BSIM4aigc + T3 * Voxdepinv
2636 - T4 * Voxdepinv * Voxdepinv);
2637
2638 if (T5 > EXP_THRESHOLD)
2639 { T6 = MAX_EXP;
2640 dT6_dVg = dT6_dVd = dT6_dVb = 0.0;
2641 }
2642 else if (T5 < -EXP_THRESHOLD)
2643 { T6 = MIN_EXP;
2644 dT6_dVg = dT6_dVd = dT6_dVb = 0.0;
2645 }
2646 else
2647 { T6 = exp(T5);
2648 dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * Voxdepinv);
2649 dT6_dVd = dT6_dVg * dVoxdepinv_dVd;
2650 dT6_dVb = dT6_dVg * dVoxdepinv_dVb;
2651 dT6_dVg *= dVoxdepinv_dVg;
2652 }
2653
2654 Igc = T11 * T2 * T6;
2655 dIgc_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg);
2656 dIgc_dVd = T11 * (T2 * dT6_dVd + T6 * dT2_dVd);
2657 dIgc_dVb = T11 * (T2 * dT6_dVb + T6 * dT2_dVb);
2658
2659 if (model->BSIM4pigcdGiven)
2660 { Pigcd = pParam->BSIM4pigcd;
2661 dPigcd_dVg = dPigcd_dVd = dPigcd_dVb = 0.0;
2662 }
2663 else
2664 { /* T11 = pParam->BSIM4Bechvb * toxe; v4.7 */
2665 T11 = -pParam->BSIM4Bechvb;
2666 T12 = Vgsteff + 1.0e-20;
2667 T13 = T11 / T12 / T12;
2668 T14 = -T13 / T12;
2669 Pigcd = T13 * (1.0 - 0.5 * Vdseff / T12);
2670 dPigcd_dVg = T14 * (2.0 + 0.5 * (dVdseff_dVg
2671 - 3.0 * Vdseff / T12));
2672 dPigcd_dVd = 0.5 * T14 * dVdseff_dVd;
2673 dPigcd_dVb = 0.5 * T14 * dVdseff_dVb;
2674 }
2675
2676 T7 = -Pigcd * Vdseff; /* bugfix */
2677 dT7_dVg = -Vdseff * dPigcd_dVg - Pigcd * dVdseff_dVg;
2678 dT7_dVd = -Vdseff * dPigcd_dVd - Pigcd * dVdseff_dVd + dT7_dVg * dVgsteff_dVd;
2679 dT7_dVb = -Vdseff * dPigcd_dVb - Pigcd * dVdseff_dVb + dT7_dVg * dVgsteff_dVb;
2680 dT7_dVg *= dVgsteff_dVg;
2681 /*dT7_dVb *= dVbseff_dVb;*/ /* Synopsys, 2013/08/30 */
2682 T8 = T7 * T7 + 2.0e-4;
2683 dT8_dVg = 2.0 * T7;
2684 dT8_dVd = dT8_dVg * dT7_dVd;
2685 dT8_dVb = dT8_dVg * dT7_dVb;
2686 dT8_dVg *= dT7_dVg;
2687
2688 if (T7 > EXP_THRESHOLD)
2689 { T9 = MAX_EXP;
2690 dT9_dVg = dT9_dVd = dT9_dVb = 0.0;
2691 }
2692 else if (T7 < -EXP_THRESHOLD)
2693 { T9 = MIN_EXP;
2694 dT9_dVg = dT9_dVd = dT9_dVb = 0.0;
2695 }
2696 else
2697 { T9 = exp(T7);
2698 dT9_dVg = T9 * dT7_dVg;
2699 dT9_dVd = T9 * dT7_dVd;
2700 dT9_dVb = T9 * dT7_dVb;
2701 }
2702
2703 T0 = T8 * T8;
2704 T1 = T9 - 1.0 + 1.0e-4;
2705 T10 = (T1 - T7) / T8;
2706 dT10_dVg = (dT9_dVg - dT7_dVg - T10 * dT8_dVg) / T8;
2707 dT10_dVd = (dT9_dVd - dT7_dVd - T10 * dT8_dVd) / T8;
2708 dT10_dVb = (dT9_dVb - dT7_dVb - T10 * dT8_dVb) / T8;
2709
2710 Igcs = Igc * T10;
2711 dIgcs_dVg = dIgc_dVg * T10 + Igc * dT10_dVg;
2712 dIgcs_dVd = dIgc_dVd * T10 + Igc * dT10_dVd;
2713 dIgcs_dVb = dIgc_dVb * T10 + Igc * dT10_dVb;
2714
2715 T1 = T9 - 1.0 - 1.0e-4;
2716 T10 = (T7 * T9 - T1) / T8;
2717 dT10_dVg = (dT7_dVg * T9 + (T7 - 1.0) * dT9_dVg
2718 - T10 * dT8_dVg) / T8;
2719 dT10_dVd = (dT7_dVd * T9 + (T7 - 1.0) * dT9_dVd
2720 - T10 * dT8_dVd) / T8;
2721 dT10_dVb = (dT7_dVb * T9 + (T7 - 1.0) * dT9_dVb
2722 - T10 * dT8_dVb) / T8;
2723 Igcd = Igc * T10;
2724 dIgcd_dVg = dIgc_dVg * T10 + Igc * dT10_dVg;
2725 dIgcd_dVd = dIgc_dVd * T10 + Igc * dT10_dVd;
2726 dIgcd_dVb = dIgc_dVb * T10 + Igc * dT10_dVb;
2727
2728 here->BSIM4Igcs = Igcs;
2729 here->BSIM4gIgcsg = dIgcs_dVg;
2730 here->BSIM4gIgcsd = dIgcs_dVd;
2731 here->BSIM4gIgcsb = dIgcs_dVb * dVbseff_dVb;
2732 here->BSIM4Igcd = Igcd;
2733 here->BSIM4gIgcdg = dIgcd_dVg;
2734 here->BSIM4gIgcdd = dIgcd_dVd;
2735 here->BSIM4gIgcdb = dIgcd_dVb * dVbseff_dVb;
2736
2737 T0 = vgs - (pParam->BSIM4vfbsd + pParam->BSIM4vfbsdoff);
2738 vgs_eff = sqrt(T0 * T0 + 1.0e-4);
2739 dvgs_eff_dvg = T0 / vgs_eff;
2740
2741 T2 = vgs * vgs_eff;
2742 dT2_dVg = vgs * dvgs_eff_dvg + vgs_eff;
2743 T11 = pParam->BSIM4AechvbEdgeS;
2744 T12 = pParam->BSIM4BechvbEdge;
2745 T3 = pParam->BSIM4aigs * pParam->BSIM4cigs
2746 - pParam->BSIM4bigs;
2747 T4 = pParam->BSIM4bigs * pParam->BSIM4cigs;
2748 T5 = T12 * (pParam->BSIM4aigs + T3 * vgs_eff
2749 - T4 * vgs_eff * vgs_eff);
2750 if (T5 > EXP_THRESHOLD)
2751 { T6 = MAX_EXP;
2752 dT6_dVg = 0.0;
2753 }
2754 else if (T5 < -EXP_THRESHOLD)
2755 { T6 = MIN_EXP;
2756 dT6_dVg = 0.0;
2757 }
2758 else
2759 { T6 = exp(T5);
2760 dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * vgs_eff)
2761 * dvgs_eff_dvg;
2762 }
2763 Igs = T11 * T2 * T6;
2764 dIgs_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg);
2765 dIgs_dVs = -dIgs_dVg;
2766
2767
2768 T0 = vgd - (pParam->BSIM4vfbsd + pParam->BSIM4vfbsdoff);
2769 vgd_eff = sqrt(T0 * T0 + 1.0e-4);
2770 dvgd_eff_dvg = T0 / vgd_eff;
2771
2772 T2 = vgd * vgd_eff;
2773 dT2_dVg = vgd * dvgd_eff_dvg + vgd_eff;
2774 T11 = pParam->BSIM4AechvbEdgeD;
2775 T3 = pParam->BSIM4aigd * pParam->BSIM4cigd
2776 - pParam->BSIM4bigd;
2777 T4 = pParam->BSIM4bigd * pParam->BSIM4cigd;
2778 T5 = T12 * (pParam->BSIM4aigd + T3 * vgd_eff
2779 - T4 * vgd_eff * vgd_eff);
2780 if (T5 > EXP_THRESHOLD)
2781 { T6 = MAX_EXP;
2782 dT6_dVg = 0.0;
2783 }
2784 else if (T5 < -EXP_THRESHOLD)
2785 { T6 = MIN_EXP;
2786 dT6_dVg = 0.0;
2787 }
2788 else
2789 { T6 = exp(T5);
2790 dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * vgd_eff)
2791 * dvgd_eff_dvg;
2792 }
2793 Igd = T11 * T2 * T6;
2794 dIgd_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg);
2795 dIgd_dVd = -dIgd_dVg;
2796
2797 here->BSIM4Igs = Igs;
2798 here->BSIM4gIgsg = dIgs_dVg;
2799 here->BSIM4gIgss = dIgs_dVs;
2800 here->BSIM4Igd = Igd;
2801 here->BSIM4gIgdg = dIgd_dVg;
2802 here->BSIM4gIgdd = dIgd_dVd;
2803 }
2804 else
2805 { here->BSIM4Igcs = here->BSIM4gIgcsg = here->BSIM4gIgcsd
2806 = here->BSIM4gIgcsb = 0.0;
2807 here->BSIM4Igcd = here->BSIM4gIgcdg = here->BSIM4gIgcdd
2808 = here->BSIM4gIgcdb = 0.0;
2809 here->BSIM4Igs = here->BSIM4gIgsg = here->BSIM4gIgss = 0.0;
2810 here->BSIM4Igd = here->BSIM4gIgdg = here->BSIM4gIgdd = 0.0;
2811 }
2812
2813 if (model->BSIM4igbMod)
2814 { T0 = tmp * pParam->BSIM4nigbacc;
2815 T1 = -Vgs_eff + Vbseff + Vfb;
2816 VxNVt = T1 / T0;
2817 if (VxNVt > EXP_THRESHOLD)
2818 { Vaux = T1;
2819 dVaux_dVg = -dVgs_eff_dVg;
2820 dVaux_dVb = 1.0;
2821 }
2822 else if (VxNVt < -EXP_THRESHOLD)
2823 { Vaux = T0 * log(1.0 + MIN_EXP);
2824 dVaux_dVg = dVaux_dVb = 0.0;
2825 }
2826 else
2827 { ExpVxNVt = exp(VxNVt);
2828 Vaux = T0 * log(1.0 + ExpVxNVt);
2829 dVaux_dVb = ExpVxNVt / (1.0 + ExpVxNVt);
2830 dVaux_dVg = -dVaux_dVb * dVgs_eff_dVg;
2831 }
2832
2833 T2 = (Vgs_eff - Vbseff) * Vaux;
2834 dT2_dVg = dVgs_eff_dVg * Vaux + (Vgs_eff - Vbseff) * dVaux_dVg;
2835 dT2_dVb = -Vaux + (Vgs_eff - Vbseff) * dVaux_dVb;
2836
2837 T11 = 4.97232e-7 * pParam->BSIM4weff
2838 * pParam->BSIM4leff * pParam->BSIM4ToxRatio;
2839 T12 = -7.45669e11 * toxe;
2840 T3 = pParam->BSIM4aigbacc * pParam->BSIM4cigbacc
2841 - pParam->BSIM4bigbacc;
2842 T4 = pParam->BSIM4bigbacc * pParam->BSIM4cigbacc;
2843 T5 = T12 * (pParam->BSIM4aigbacc + T3 * Voxacc
2844 - T4 * Voxacc * Voxacc);
2845
2846 if (T5 > EXP_THRESHOLD)
2847 { T6 = MAX_EXP;
2848 dT6_dVg = dT6_dVb = 0.0;
2849 }
2850 else if (T5 < -EXP_THRESHOLD)
2851 { T6 = MIN_EXP;
2852 dT6_dVg = dT6_dVb = 0.0;
2853 }
2854 else
2855 { T6 = exp(T5);
2856 dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * Voxacc);
2857 dT6_dVb = dT6_dVg * dVoxacc_dVb;
2858 dT6_dVg *= dVoxacc_dVg;
2859 }
2860
2861 Igbacc = T11 * T2 * T6;
2862 dIgbacc_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg);
2863 dIgbacc_dVb = T11 * (T2 * dT6_dVb + T6 * dT2_dVb);
2864
2865
2866 T0 = tmp * pParam->BSIM4nigbinv;
2867 T1 = Voxdepinv - pParam->BSIM4eigbinv;
2868 VxNVt = T1 / T0;
2869 if (VxNVt > EXP_THRESHOLD)
2870 { Vaux = T1;
2871 dVaux_dVg = dVoxdepinv_dVg;
2872 dVaux_dVd = dVoxdepinv_dVd;
2873 dVaux_dVb = dVoxdepinv_dVb;
2874 }
2875 else if (VxNVt < -EXP_THRESHOLD)
2876 { Vaux = T0 * log(1.0 + MIN_EXP);
2877 dVaux_dVg = dVaux_dVd = dVaux_dVb = 0.0;
2878 }
2879 else
2880 { ExpVxNVt = exp(VxNVt);
2881 Vaux = T0 * log(1.0 + ExpVxNVt);
2882 dVaux_dVg = ExpVxNVt / (1.0 + ExpVxNVt);
2883 dVaux_dVd = dVaux_dVg * dVoxdepinv_dVd;
2884 dVaux_dVb = dVaux_dVg * dVoxdepinv_dVb;
2885 dVaux_dVg *= dVoxdepinv_dVg;
2886 }
2887
2888 T2 = (Vgs_eff - Vbseff) * Vaux;
2889 dT2_dVg = dVgs_eff_dVg * Vaux + (Vgs_eff - Vbseff) * dVaux_dVg;
2890 dT2_dVd = (Vgs_eff - Vbseff) * dVaux_dVd;
2891 dT2_dVb = -Vaux + (Vgs_eff - Vbseff) * dVaux_dVb;
2892
2893 T11 *= 0.75610;
2894 T12 *= 1.31724;
2895 T3 = pParam->BSIM4aigbinv * pParam->BSIM4cigbinv
2896 - pParam->BSIM4bigbinv;
2897 T4 = pParam->BSIM4bigbinv * pParam->BSIM4cigbinv;
2898 T5 = T12 * (pParam->BSIM4aigbinv + T3 * Voxdepinv
2899 - T4 * Voxdepinv * Voxdepinv);
2900
2901 if (T5 > EXP_THRESHOLD)
2902 { T6 = MAX_EXP;
2903 dT6_dVg = dT6_dVd = dT6_dVb = 0.0;
2904 }
2905 else if (T5 < -EXP_THRESHOLD)
2906 { T6 = MIN_EXP;
2907 dT6_dVg = dT6_dVd = dT6_dVb = 0.0;
2908 }
2909 else
2910 { T6 = exp(T5);
2911 dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * Voxdepinv);
2912 dT6_dVd = dT6_dVg * dVoxdepinv_dVd;
2913 dT6_dVb = dT6_dVg * dVoxdepinv_dVb;
2914 dT6_dVg *= dVoxdepinv_dVg;
2915 }
2916
2917 Igbinv = T11 * T2 * T6;
2918 dIgbinv_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg);
2919 dIgbinv_dVd = T11 * (T2 * dT6_dVd + T6 * dT2_dVd);
2920 dIgbinv_dVb = T11 * (T2 * dT6_dVb + T6 * dT2_dVb);
2921
2922 here->BSIM4Igb = Igbinv + Igbacc;
2923 here->BSIM4gIgbg = dIgbinv_dVg + dIgbacc_dVg;
2924 here->BSIM4gIgbd = dIgbinv_dVd;
2925 here->BSIM4gIgbb = (dIgbinv_dVb + dIgbacc_dVb) * dVbseff_dVb;
2926 }
2927 else
2928 { here->BSIM4Igb = here->BSIM4gIgbg = here->BSIM4gIgbd
2929 = here->BSIM4gIgbs = here->BSIM4gIgbb = 0.0;
2930 } /* End of Gate current */
2931
2932 if (here->BSIM4nf != 1.0)
2933 { cdrain *= here->BSIM4nf;
2934 here->BSIM4gds *= here->BSIM4nf;
2935 here->BSIM4gm *= here->BSIM4nf;
2936 here->BSIM4gmbs *= here->BSIM4nf;
2937 here->BSIM4IdovVds *= here->BSIM4nf;
2938
2939 here->BSIM4gbbs *= here->BSIM4nf;
2940 here->BSIM4gbgs *= here->BSIM4nf;
2941 here->BSIM4gbds *= here->BSIM4nf;
2942 here->BSIM4csub *= here->BSIM4nf;
2943
2944 here->BSIM4Igidl *= here->BSIM4nf;
2945 here->BSIM4ggidld *= here->BSIM4nf;
2946 here->BSIM4ggidlg *= here->BSIM4nf;
2947 here->BSIM4ggidlb *= here->BSIM4nf;
2948
2949 here->BSIM4Igisl *= here->BSIM4nf;
2950 here->BSIM4ggisls *= here->BSIM4nf;
2951 here->BSIM4ggislg *= here->BSIM4nf;
2952 here->BSIM4ggislb *= here->BSIM4nf;
2953
2954 here->BSIM4Igcs *= here->BSIM4nf;
2955 here->BSIM4gIgcsg *= here->BSIM4nf;
2956 here->BSIM4gIgcsd *= here->BSIM4nf;
2957 here->BSIM4gIgcsb *= here->BSIM4nf;
2958 here->BSIM4Igcd *= here->BSIM4nf;
2959 here->BSIM4gIgcdg *= here->BSIM4nf;
2960 here->BSIM4gIgcdd *= here->BSIM4nf;
2961 here->BSIM4gIgcdb *= here->BSIM4nf;
2962
2963 here->BSIM4Igs *= here->BSIM4nf;
2964 here->BSIM4gIgsg *= here->BSIM4nf;
2965 here->BSIM4gIgss *= here->BSIM4nf;
2966 here->BSIM4Igd *= here->BSIM4nf;
2967 here->BSIM4gIgdg *= here->BSIM4nf;
2968 here->BSIM4gIgdd *= here->BSIM4nf;
2969
2970 here->BSIM4Igb *= here->BSIM4nf;
2971 here->BSIM4gIgbg *= here->BSIM4nf;
2972 here->BSIM4gIgbd *= here->BSIM4nf;
2973 here->BSIM4gIgbb *= here->BSIM4nf;
2974 }
2975
2976 here->BSIM4ggidls = -(here->BSIM4ggidld + here->BSIM4ggidlg
2977 + here->BSIM4ggidlb);
2978 here->BSIM4ggisld = -(here->BSIM4ggisls + here->BSIM4ggislg
2979 + here->BSIM4ggislb);
2980 here->BSIM4gIgbs = -(here->BSIM4gIgbg + here->BSIM4gIgbd
2981 + here->BSIM4gIgbb);
2982 here->BSIM4gIgcss = -(here->BSIM4gIgcsg + here->BSIM4gIgcsd
2983 + here->BSIM4gIgcsb);
2984 here->BSIM4gIgcds = -(here->BSIM4gIgcdg + here->BSIM4gIgcdd
2985 + here->BSIM4gIgcdb);
2986 here->BSIM4cd = cdrain;
2987
2988
2989 /* Calculations for noise analysis */
2990
2991 if (model->BSIM4tnoiMod == 0)
2992 { Abulk = Abulk0 * pParam->BSIM4abulkCVfactor;
2993 Vdsat = Vgsteff / Abulk;
2994 T0 = Vdsat - Vds - DELTA_4;
2995 T1 = sqrt(T0 * T0 + 4.0 * DELTA_4 * Vdsat);
2996 if (T0 >= 0.0)
2997 Vdseff = Vdsat - 0.5 * (T0 + T1);
2998 else
2999 { T3 = (DELTA_4 + DELTA_4) / (T1 - T0);
3000 T4 = 1.0 - T3;
3001 T5 = Vdsat * T3 / (T1 - T0);
3002 Vdseff = Vdsat * T4;
3003 }
3004 if (Vds == 0.0)
3005 Vdseff = 0.0;
3006
3007 T0 = Abulk * Vdseff;
3008 T1 = 12.0 * (Vgsteff - 0.5 * T0 + 1.0e-20);
3009 T2 = Vdseff / T1;
3010 T3 = T0 * T2;
3011 here->BSIM4qinv = Coxeff * pParam->BSIM4weffCV * here->BSIM4nf
3012 * pParam->BSIM4leffCV
3013 * (Vgsteff - 0.5 * T0 + Abulk * T3);
3014 }
3015 else if(model->BSIM4tnoiMod == 2)
3016 {
3017 here->BSIM4noiGd0 = here->BSIM4nf * beta * Vgsteff / (1.0 + gche * Rds);
3018 }
3019
3020 /*
3021 * BSIM4 C-V begins
3022 */
3023
3024 if ((model->BSIM4xpart < 0) || (!ChargeComputationNeeded))
3025 { qgate = qdrn = qsrc = qbulk = 0.0;
3026 here->BSIM4cggb = here->BSIM4cgsb = here->BSIM4cgdb = 0.0;
3027 here->BSIM4cdgb = here->BSIM4cdsb = here->BSIM4cddb = 0.0;
3028 here->BSIM4cbgb = here->BSIM4cbsb = here->BSIM4cbdb = 0.0;
3029 here->BSIM4csgb = here->BSIM4cssb = here->BSIM4csdb = 0.0;
3030 here->BSIM4cgbb = here->BSIM4csbb = here->BSIM4cdbb = here->BSIM4cbbb = 0.0;
3031 here->BSIM4cqdb = here->BSIM4cqsb = here->BSIM4cqgb
3032 = here->BSIM4cqbb = 0.0;
3033 here->BSIM4gtau = 0.0;
3034 goto finished;
3035 }
3036 else if (model->BSIM4capMod == 0)
3037 {
3038 if (Vbseff < 0.0)
3039 { VbseffCV = Vbs; /*4.6.2*/
3040 dVbseffCV_dVb = 1.0;
3041 }
3042 else
3043 { VbseffCV = pParam->BSIM4phi - Phis;
3044 dVbseffCV_dVb = -dPhis_dVb * dVbseff_dVb; /*4.6.2*/
3045 }
3046
3047 Vfb = pParam->BSIM4vfbcv;
3048 Vth = Vfb + pParam->BSIM4phi + pParam->BSIM4k1ox * sqrtPhis;
3049 Vgst = Vgs_eff - Vth;
3050 dVth_dVb = pParam->BSIM4k1ox * dsqrtPhis_dVb *dVbseff_dVb; /*4.6.2*/
3051 dVgst_dVb = -dVth_dVb;
3052 dVgst_dVg = dVgs_eff_dVg;
3053
3054 CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV
3055 * pParam->BSIM4leffCV * here->BSIM4nf;
3056 Arg1 = Vgs_eff - VbseffCV - Vfb;
3057
3058 if (Arg1 <= 0.0)
3059 { qgate = CoxWL * Arg1;
3060 qbulk = -qgate;
3061 qdrn = 0.0;
3062
3063 here->BSIM4cggb = CoxWL * dVgs_eff_dVg;
3064 here->BSIM4cgdb = 0.0;
3065 here->BSIM4cgsb = CoxWL * (dVbseffCV_dVb - dVgs_eff_dVg);
3066
3067 here->BSIM4cdgb = 0.0;
3068 here->BSIM4cddb = 0.0;
3069 here->BSIM4cdsb = 0.0;
3070
3071 here->BSIM4cbgb = -CoxWL * dVgs_eff_dVg;
3072 here->BSIM4cbdb = 0.0;
3073 here->BSIM4cbsb = -here->BSIM4cgsb;
3074 } /* Arg1 <= 0.0, end of accumulation */
3075 else if (Vgst <= 0.0)
3076 { T1 = 0.5 * pParam->BSIM4k1ox;
3077 T2 = sqrt(T1 * T1 + Arg1);
3078 qgate = CoxWL * pParam->BSIM4k1ox * (T2 - T1);
3079 qbulk = -qgate;
3080 qdrn = 0.0;
3081
3082 T0 = CoxWL * T1 / T2;
3083 here->BSIM4cggb = T0 * dVgs_eff_dVg;
3084 here->BSIM4cgdb = 0.0;
3085 here->BSIM4cgsb = T0 * (dVbseffCV_dVb - dVgs_eff_dVg);
3086
3087 here->BSIM4cdgb = 0.0;
3088 here->BSIM4cddb = 0.0;
3089 here->BSIM4cdsb = 0.0;
3090
3091 here->BSIM4cbgb = -here->BSIM4cggb;
3092 here->BSIM4cbdb = 0.0;
3093 here->BSIM4cbsb = -here->BSIM4cgsb;
3094 } /* Vgst <= 0.0, end of depletion */
3095 else
3096 { One_Third_CoxWL = CoxWL / 3.0;
3097 Two_Third_CoxWL = 2.0 * One_Third_CoxWL;
3098
3099 AbulkCV = Abulk0 * pParam->BSIM4abulkCVfactor;
3100 dAbulkCV_dVb = pParam->BSIM4abulkCVfactor * dAbulk0_dVb*dVbseff_dVb;
3101
3102 dVdsat_dVg = 1.0 / AbulkCV; /*4.6.2*/
3103 Vdsat = Vgst * dVdsat_dVg;
3104 dVdsat_dVb = - (Vdsat * dAbulkCV_dVb + dVth_dVb)* dVdsat_dVg;
3105
3106 if (model->BSIM4xpart > 0.5)
3107 { /* 0/100 Charge partition model */
3108 if (Vdsat <= Vds)
3109 { /* saturation region */
3110 T1 = Vdsat / 3.0;
3111 qgate = CoxWL * (Vgs_eff - Vfb
3112 - pParam->BSIM4phi - T1);
3113 T2 = -Two_Third_CoxWL * Vgst;
3114 qbulk = -(qgate + T2);
3115 qdrn = 0.0;
3116
3117 here->BSIM4cggb = One_Third_CoxWL * (3.0
3118 - dVdsat_dVg) * dVgs_eff_dVg;
3119 T2 = -One_Third_CoxWL * dVdsat_dVb;
3120 here->BSIM4cgsb = -(here->BSIM4cggb + T2);
3121 here->BSIM4cgdb = 0.0;
3122
3123 here->BSIM4cdgb = 0.0;
3124 here->BSIM4cddb = 0.0;
3125 here->BSIM4cdsb = 0.0;
3126
3127 here->BSIM4cbgb = -(here->BSIM4cggb
3128 - Two_Third_CoxWL * dVgs_eff_dVg);
3129 T3 = -(T2 + Two_Third_CoxWL * dVth_dVb);
3130 here->BSIM4cbsb = -(here->BSIM4cbgb + T3);
3131 here->BSIM4cbdb = 0.0;
3132 }
3133 else
3134 { /* linear region */
3135 Alphaz = Vgst / Vdsat;
3136 T1 = 2.0 * Vdsat - Vds;
3137 T2 = Vds / (3.0 * T1);
3138 T3 = T2 * Vds;
3139 T9 = 0.25 * CoxWL;
3140 T4 = T9 * Alphaz;
3141 T7 = 2.0 * Vds - T1 - 3.0 * T3;
3142 T8 = T3 - T1 - 2.0 * Vds;
3143 qgate = CoxWL * (Vgs_eff - Vfb
3144 - pParam->BSIM4phi - 0.5 * (Vds - T3));
3145 T10 = T4 * T8;
3146 qdrn = T4 * T7;
3147 qbulk = -(qgate + qdrn + T10);
3148
3149 T5 = T3 / T1;
3150 here->BSIM4cggb = CoxWL * (1.0 - T5 * dVdsat_dVg)
3151 * dVgs_eff_dVg;
3152 T11 = -CoxWL * T5 * dVdsat_dVb;
3153 here->BSIM4cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5);
3154 here->BSIM4cgsb = -(here->BSIM4cggb + T11
3155 + here->BSIM4cgdb);
3156 T6 = 1.0 / Vdsat;
3157 dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg);
3158 dAlphaz_dVb = -T6 * (dVth_dVb + Alphaz * dVdsat_dVb);
3159 T7 = T9 * T7;
3160 T8 = T9 * T8;
3161 T9 = 2.0 * T4 * (1.0 - 3.0 * T5);
3162 here->BSIM4cdgb = (T7 * dAlphaz_dVg - T9
3163 * dVdsat_dVg) * dVgs_eff_dVg;
3164 T12 = T7 * dAlphaz_dVb - T9 * dVdsat_dVb;
3165 here->BSIM4cddb = T4 * (3.0 - 6.0 * T2 - 3.0 * T5);
3166 here->BSIM4cdsb = -(here->BSIM4cdgb + T12
3167 + here->BSIM4cddb);
3168
3169 T9 = 2.0 * T4 * (1.0 + T5);
3170 T10 = (T8 * dAlphaz_dVg - T9 * dVdsat_dVg)
3171 * dVgs_eff_dVg;
3172 T11 = T8 * dAlphaz_dVb - T9 * dVdsat_dVb;
3173 T12 = T4 * (2.0 * T2 + T5 - 1.0);
3174 T0 = -(T10 + T11 + T12);
3175
3176 here->BSIM4cbgb = -(here->BSIM4cggb
3177 + here->BSIM4cdgb + T10);
3178 here->BSIM4cbdb = -(here->BSIM4cgdb
3179 + here->BSIM4cddb + T12);
3180 here->BSIM4cbsb = -(here->BSIM4cgsb
3181 + here->BSIM4cdsb + T0);
3182 }
3183 }
3184 else if (model->BSIM4xpart < 0.5)
3185 { /* 40/60 Charge partition model */
3186 if (Vds >= Vdsat)
3187 { /* saturation region */
3188 T1 = Vdsat / 3.0;
3189 qgate = CoxWL * (Vgs_eff - Vfb
3190 - pParam->BSIM4phi - T1);
3191 T2 = -Two_Third_CoxWL * Vgst;
3192 qbulk = -(qgate + T2);
3193 qdrn = 0.4 * T2;
3194
3195 here->BSIM4cggb = One_Third_CoxWL * (3.0
3196 - dVdsat_dVg) * dVgs_eff_dVg;
3197 T2 = -One_Third_CoxWL * dVdsat_dVb;
3198 here->BSIM4cgsb = -(here->BSIM4cggb + T2);
3199 here->BSIM4cgdb = 0.0;
3200
3201 T3 = 0.4 * Two_Third_CoxWL;
3202 here->BSIM4cdgb = -T3 * dVgs_eff_dVg;
3203 here->BSIM4cddb = 0.0;
3204 T4 = T3 * dVth_dVb;
3205 here->BSIM4cdsb = -(T4 + here->BSIM4cdgb);
3206
3207 here->BSIM4cbgb = -(here->BSIM4cggb
3208 - Two_Third_CoxWL * dVgs_eff_dVg);
3209 T3 = -(T2 + Two_Third_CoxWL * dVth_dVb);
3210 here->BSIM4cbsb = -(here->BSIM4cbgb + T3);
3211 here->BSIM4cbdb = 0.0;
3212 }
3213 else
3214 { /* linear region */
3215 Alphaz = Vgst / Vdsat;
3216 T1 = 2.0 * Vdsat - Vds;
3217 T2 = Vds / (3.0 * T1);
3218 T3 = T2 * Vds;
3219 T9 = 0.25 * CoxWL;
3220 T4 = T9 * Alphaz;
3221 qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM4phi
3222 - 0.5 * (Vds - T3));
3223
3224 T5 = T3 / T1;
3225 here->BSIM4cggb = CoxWL * (1.0 - T5 * dVdsat_dVg)
3226 * dVgs_eff_dVg;
3227 tmp = -CoxWL * T5 * dVdsat_dVb;
3228 here->BSIM4cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5);
3229 here->BSIM4cgsb = -(here->BSIM4cggb
3230 + here->BSIM4cgdb + tmp);
3231
3232 T6 = 1.0 / Vdsat;
3233 dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg);
3234 dAlphaz_dVb = -T6 * (dVth_dVb + Alphaz * dVdsat_dVb);
3235
3236 T6 = 8.0 * Vdsat * Vdsat - 6.0 * Vdsat * Vds
3237 + 1.2 * Vds * Vds;
3238 T8 = T2 / T1;
3239 T7 = Vds - T1 - T8 * T6;
3240 qdrn = T4 * T7;
3241 T7 *= T9;
3242 tmp = T8 / T1;
3243 tmp1 = T4 * (2.0 - 4.0 * tmp * T6
3244 + T8 * (16.0 * Vdsat - 6.0 * Vds));
3245
3246 here->BSIM4cdgb = (T7 * dAlphaz_dVg - tmp1
3247 * dVdsat_dVg) * dVgs_eff_dVg;
3248 T10 = T7 * dAlphaz_dVb - tmp1 * dVdsat_dVb;
3249 here->BSIM4cddb = T4 * (2.0 - (1.0 / (3.0 * T1
3250 * T1) + 2.0 * tmp) * T6 + T8
3251 * (6.0 * Vdsat - 2.4 * Vds));
3252 here->BSIM4cdsb = -(here->BSIM4cdgb
3253 + T10 + here->BSIM4cddb);
3254
3255 T7 = 2.0 * (T1 + T3);
3256 qbulk = -(qgate - T4 * T7);
3257 T7 *= T9;
3258 T0 = 4.0 * T4 * (1.0 - T5);
3259 T12 = (-T7 * dAlphaz_dVg - T0 * dVdsat_dVg) * dVgs_eff_dVg
3260 - here->BSIM4cdgb; /*4.6.2*/
3261 T11 = -T7 * dAlphaz_dVb - T10 - T0 * dVdsat_dVb;
3262 T10 = -4.0 * T4 * (T2 - 0.5 + 0.5 * T5)
3263 - here->BSIM4cddb;
3264 tmp = -(T10 + T11 + T12);
3265
3266 here->BSIM4cbgb = -(here->BSIM4cggb
3267 + here->BSIM4cdgb + T12);
3268 here->BSIM4cbdb = -(here->BSIM4cgdb
3269 + here->BSIM4cddb + T10);
3270 here->BSIM4cbsb = -(here->BSIM4cgsb
3271 + here->BSIM4cdsb + tmp);
3272 }
3273 }
3274 else
3275 { /* 50/50 partitioning */
3276 if (Vds >= Vdsat)
3277 { /* saturation region */
3278 T1 = Vdsat / 3.0;
3279 qgate = CoxWL * (Vgs_eff - Vfb
3280 - pParam->BSIM4phi - T1);
3281 T2 = -Two_Third_CoxWL * Vgst;
3282 qbulk = -(qgate + T2);
3283 qdrn = 0.5 * T2;
3284
3285 here->BSIM4cggb = One_Third_CoxWL * (3.0
3286 - dVdsat_dVg) * dVgs_eff_dVg;
3287 T2 = -One_Third_CoxWL * dVdsat_dVb;
3288 here->BSIM4cgsb = -(here->BSIM4cggb + T2);
3289 here->BSIM4cgdb = 0.0;
3290
3291 here->BSIM4cdgb = -One_Third_CoxWL * dVgs_eff_dVg;
3292 here->BSIM4cddb = 0.0;
3293 T4 = One_Third_CoxWL * dVth_dVb;
3294 here->BSIM4cdsb = -(T4 + here->BSIM4cdgb);
3295
3296 here->BSIM4cbgb = -(here->BSIM4cggb
3297 - Two_Third_CoxWL * dVgs_eff_dVg);
3298 T3 = -(T2 + Two_Third_CoxWL * dVth_dVb);
3299 here->BSIM4cbsb = -(here->BSIM4cbgb + T3);
3300 here->BSIM4cbdb = 0.0;
3301 }
3302 else
3303 { /* linear region */
3304 Alphaz = Vgst / Vdsat;
3305 T1 = 2.0 * Vdsat - Vds;
3306 T2 = Vds / (3.0 * T1);
3307 T3 = T2 * Vds;
3308 T9 = 0.25 * CoxWL;
3309 T4 = T9 * Alphaz;
3310 qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM4phi
3311 - 0.5 * (Vds - T3));
3312
3313 T5 = T3 / T1;
3314 here->BSIM4cggb = CoxWL * (1.0 - T5 * dVdsat_dVg)
3315 * dVgs_eff_dVg;
3316 tmp = -CoxWL * T5 * dVdsat_dVb;
3317 here->BSIM4cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5);
3318 here->BSIM4cgsb = -(here->BSIM4cggb
3319 + here->BSIM4cgdb + tmp);
3320
3321 T6 = 1.0 / Vdsat;
3322 dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg);
3323 dAlphaz_dVb = -T6 * (dVth_dVb + Alphaz * dVdsat_dVb);
3324
3325 T7 = T1 + T3;
3326 qdrn = -T4 * T7;
3327 qbulk = - (qgate + qdrn + qdrn);
3328 T7 *= T9;
3329 T0 = T4 * (2.0 * T5 - 2.0);
3330
3331 here->BSIM4cdgb = (T0 * dVdsat_dVg - T7
3332 * dAlphaz_dVg) * dVgs_eff_dVg;
3333 T12 = T0 * dVdsat_dVb - T7 * dAlphaz_dVb;
3334 here->BSIM4cddb = T4 * (1.0 - 2.0 * T2 - T5);
3335 here->BSIM4cdsb = -(here->BSIM4cdgb + T12
3336 + here->BSIM4cddb);
3337
3338 here->BSIM4cbgb = -(here->BSIM4cggb
3339 + 2.0 * here->BSIM4cdgb);
3340 here->BSIM4cbdb = -(here->BSIM4cgdb
3341 + 2.0 * here->BSIM4cddb);
3342 here->BSIM4cbsb = -(here->BSIM4cgsb
3343 + 2.0 * here->BSIM4cdsb);
3344 } /* end of linear region */
3345 } /* end of 50/50 partition */
3346 } /* end of inversion */
3347 } /* end of capMod=0 */
3348 else
3349 { if (Vbseff < 0.0)
3350 { VbseffCV = Vbseff;
3351 dVbseffCV_dVb = 1.0;
3352 }
3353 else
3354 { VbseffCV = pParam->BSIM4phi - Phis;
3355 dVbseffCV_dVb = -dPhis_dVb;
3356 }
3357
3358 CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV
3359 * pParam->BSIM4leffCV * here->BSIM4nf;
3360
3361 if(model->BSIM4cvchargeMod == 0)
3362 {
3363 /* Seperate VgsteffCV with noff and voffcv */
3364 noff = n * pParam->BSIM4noff;
3365 dnoff_dVd = pParam->BSIM4noff * dn_dVd;
3366 dnoff_dVb = pParam->BSIM4noff * dn_dVb;
3367 T0 = Vtm * noff;
3368 voffcv = pParam->BSIM4voffcv;
3369 VgstNVt = (Vgst - voffcv) / T0;
3370
3371 if (VgstNVt > EXP_THRESHOLD)
3372 {
3373 Vgsteff = Vgst - voffcv;
3374 dVgsteff_dVg = dVgs_eff_dVg;
3375 dVgsteff_dVd = -dVth_dVd;
3376 dVgsteff_dVb = -dVth_dVb;
3377 }
3378 else if (VgstNVt < -EXP_THRESHOLD)
3379 {
3380 Vgsteff = T0 * log(1.0 + MIN_EXP);
3381 dVgsteff_dVg = 0.0;
3382 dVgsteff_dVd = Vgsteff / noff;
3383 dVgsteff_dVb = dVgsteff_dVd * dnoff_dVb;
3384 dVgsteff_dVd *= dnoff_dVd;
3385 }
3386 else
3387 {
3388 ExpVgst = exp(VgstNVt);
3389 Vgsteff = T0 * log(1.0 + ExpVgst);
3390 dVgsteff_dVg = ExpVgst / (1.0 + ExpVgst);
3391 dVgsteff_dVd = -dVgsteff_dVg * (dVth_dVd + (Vgst - voffcv)
3392 / noff * dnoff_dVd) + Vgsteff / noff * dnoff_dVd;
3393 dVgsteff_dVb = -dVgsteff_dVg * (dVth_dVb + (Vgst - voffcv)
3394 / noff * dnoff_dVb) + Vgsteff / noff * dnoff_dVb;
3395 dVgsteff_dVg *= dVgs_eff_dVg;
3396 }
3397 /* End of VgsteffCV for cvchargeMod = 0 */
3398 }
3399 else
3400 {
3401 T0 = n * Vtm;
3402 T1 = pParam->BSIM4mstarcv * Vgst;
3403 T2 = T1 / T0;
3404 if (T2 > EXP_THRESHOLD)
3405 {
3406 T10 = T1;
3407 dT10_dVg = pParam->BSIM4mstarcv * dVgs_eff_dVg;
3408 dT10_dVd = -dVth_dVd * pParam->BSIM4mstarcv;
3409 dT10_dVb = -dVth_dVb * pParam->BSIM4mstarcv;
3410 }
3411 else if (T2 < -EXP_THRESHOLD)
3412 {
3413 T10 = Vtm * log(1.0 + MIN_EXP);
3414 dT10_dVg = 0.0;
3415 dT10_dVd = T10 * dn_dVd;
3416 dT10_dVb = T10 * dn_dVb;
3417 T10 *= n;
3418 }
3419 else
3420 {
3421 ExpVgst = exp(T2);
3422 T3 = Vtm * log(1.0 + ExpVgst);
3423 T10 = n * T3;
3424 dT10_dVg = pParam->BSIM4mstarcv * ExpVgst / (1.0 + ExpVgst);
3425 dT10_dVb = T3 * dn_dVb - dT10_dVg * (dVth_dVb + Vgst * dn_dVb / n);
3426 dT10_dVd = T3 * dn_dVd - dT10_dVg * (dVth_dVd + Vgst * dn_dVd / n);
3427 dT10_dVg *= dVgs_eff_dVg;
3428 }
3429
3430 T1 = pParam->BSIM4voffcbncv - (1.0 - pParam->BSIM4mstarcv) * Vgst;
3431 T2 = T1 / T0;
3432 if (T2 < -EXP_THRESHOLD)
3433 {
3434 T3 = model->BSIM4coxe * MIN_EXP / pParam->BSIM4cdep0;
3435 T9 = pParam->BSIM4mstarcv + T3 * n;
3436 dT9_dVg = 0.0;
3437 dT9_dVd = dn_dVd * T3;
3438 dT9_dVb = dn_dVb * T3;
3439 }
3440 else if (T2 > EXP_THRESHOLD)
3441 {
3442 T3 = model->BSIM4coxe * MAX_EXP / pParam->BSIM4cdep0;
3443 T9 = pParam->BSIM4mstarcv + T3 * n;
3444 dT9_dVg = 0.0;
3445 dT9_dVd = dn_dVd * T3;
3446 dT9_dVb = dn_dVb * T3;
3447 }
3448 else
3449 {
3450 ExpVgst = exp(T2);
3451 T3 = model->BSIM4coxe / pParam->BSIM4cdep0;
3452 T4 = T3 * ExpVgst;
3453 T5 = T1 * T4 / T0;
3454 T9 = pParam->BSIM4mstarcv + n * T4;
3455 dT9_dVg = T3 * (pParam->BSIM4mstarcv - 1.0) * ExpVgst / Vtm;
3456 dT9_dVb = T4 * dn_dVb - dT9_dVg * dVth_dVb - T5 * dn_dVb;
3457 dT9_dVd = T4 * dn_dVd - dT9_dVg * dVth_dVd - T5 * dn_dVd;
3458 dT9_dVg *= dVgs_eff_dVg;
3459 }
3460
3461 Vgsteff = T10 / T9;
3462 T11 = T9 * T9;
3463 dVgsteff_dVg = (T9 * dT10_dVg - T10 * dT9_dVg) / T11;
3464 dVgsteff_dVd = (T9 * dT10_dVd - T10 * dT9_dVd) / T11;
3465 dVgsteff_dVb = (T9 * dT10_dVb - T10 * dT9_dVb) / T11;
3466 /* End of VgsteffCV for cvchargeMod = 1 */
3467 }
3468
3469
3470 if (model->BSIM4capMod == 1)
3471 { Vfb = here->BSIM4vfbzb;
3472 V3 = Vfb - Vgs_eff + VbseffCV - DELTA_3;
3473 if (Vfb <= 0.0)
3474 T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * Vfb);
3475 else
3476 T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * Vfb);
3477
3478 T1 = 0.5 * (1.0 + V3 / T0);
3479 Vfbeff = Vfb - 0.5 * (V3 + T0);
3480 dVfbeff_dVg = T1 * dVgs_eff_dVg;
3481 dVfbeff_dVb = -T1 * dVbseffCV_dVb;
3482 Qac0 = CoxWL * (Vfbeff - Vfb);
3483 dQac0_dVg = CoxWL * dVfbeff_dVg;
3484 dQac0_dVb = CoxWL * dVfbeff_dVb;
3485
3486 T0 = 0.5 * pParam->BSIM4k1ox;
3487 T3 = Vgs_eff - Vfbeff - VbseffCV - Vgsteff;
3488 if (pParam->BSIM4k1ox == 0.0)
3489 { T1 = 0.0;
3490 T2 = 0.0;
3491 }
3492 else if (T3 < 0.0)
3493 { T1 = T0 + T3 / pParam->BSIM4k1ox;
3494 T2 = CoxWL;
3495 }
3496 else
3497 { T1 = sqrt(T0 * T0 + T3);
3498 T2 = CoxWL * T0 / T1;
3499 }
3500
3501 Qsub0 = CoxWL * pParam->BSIM4k1ox * (T1 - T0);
3502
3503 dQsub0_dVg = T2 * (dVgs_eff_dVg - dVfbeff_dVg - dVgsteff_dVg);
3504 dQsub0_dVd = -T2 * dVgsteff_dVd;
3505 dQsub0_dVb = -T2 * (dVfbeff_dVb + dVbseffCV_dVb
3506 + dVgsteff_dVb);
3507
3508 AbulkCV = Abulk0 * pParam->BSIM4abulkCVfactor;
3509 dAbulkCV_dVb = pParam->BSIM4abulkCVfactor * dAbulk0_dVb;
3510 VdsatCV = Vgsteff / AbulkCV;
3511
3512 T0 = VdsatCV - Vds - DELTA_4;
3513 dT0_dVg = 1.0 / AbulkCV;
3514 dT0_dVb = -VdsatCV * dAbulkCV_dVb / AbulkCV;
3515 T1 = sqrt(T0 * T0 + 4.0 * DELTA_4 * VdsatCV);
3516 dT1_dVg = (T0 + DELTA_4 + DELTA_4) / T1;
3517 dT1_dVd = -T0 / T1;
3518 dT1_dVb = dT1_dVg * dT0_dVb;
3519 dT1_dVg *= dT0_dVg;
3520 if (T0 >= 0.0)
3521 { VdseffCV = VdsatCV - 0.5 * (T0 + T1);
3522 dVdseffCV_dVg = 0.5 * (dT0_dVg - dT1_dVg);
3523 dVdseffCV_dVd = 0.5 * (1.0 - dT1_dVd);
3524 dVdseffCV_dVb = 0.5 * (dT0_dVb - dT1_dVb);
3525 }
3526 else
3527 { T3 = (DELTA_4 + DELTA_4) / (T1 - T0);
3528 T4 = 1.0 - T3;
3529 T5 = VdsatCV * T3 / (T1 - T0);
3530 VdseffCV = VdsatCV * T4;
3531 dVdseffCV_dVg = dT0_dVg * T4 + T5 * (dT1_dVg - dT0_dVg);
3532 dVdseffCV_dVd = T5 * (dT1_dVd + 1.0);
3533 dVdseffCV_dVb = dT0_dVb * (T4 - T5) + T5 * dT1_dVb;
3534 }
3535
3536 if (Vds == 0.0)
3537 { VdseffCV = 0.0;
3538 dVdseffCV_dVg = 0.0;
3539 dVdseffCV_dVb = 0.0;
3540 }
3541
3542 T0 = AbulkCV * VdseffCV;
3543 T1 = 12.0 * (Vgsteff - 0.5 * T0 + 1.0e-20);
3544 T2 = VdseffCV / T1;
3545 T3 = T0 * T2;
3546
3547 T4 = (1.0 - 12.0 * T2 * T2 * AbulkCV);
3548 T5 = (6.0 * T0 * (4.0 * Vgsteff - T0) / (T1 * T1) - 0.5);
3549 T6 = 12.0 * T2 * T2 * Vgsteff;
3550
3551 qgate = CoxWL * (Vgsteff - 0.5 * VdseffCV + T3);
3552 Cgg1 = CoxWL * (T4 + T5 * dVdseffCV_dVg);
3553 Cgd1 = CoxWL * T5 * dVdseffCV_dVd + Cgg1 * dVgsteff_dVd;
3554 Cgb1 = CoxWL * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb)
3555 + Cgg1 * dVgsteff_dVb;
3556 Cgg1 *= dVgsteff_dVg;
3557
3558 T7 = 1.0 - AbulkCV;
3559 qbulk = CoxWL * T7 * (0.5 * VdseffCV - T3);
3560 T4 = -T7 * (T4 - 1.0);
3561 T5 = -T7 * T5;
3562 T6 = -(T7 * T6 + (0.5 * VdseffCV - T3));
3563 Cbg1 = CoxWL * (T4 + T5 * dVdseffCV_dVg);
3564 Cbd1 = CoxWL * T5 * dVdseffCV_dVd + Cbg1 * dVgsteff_dVd;
3565 Cbb1 = CoxWL * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb)
3566 + Cbg1 * dVgsteff_dVb;
3567 Cbg1 *= dVgsteff_dVg;
3568
3569 if (model->BSIM4xpart > 0.5)
3570 { /* 0/100 Charge petition model */
3571 T1 = T1 + T1;
3572 qsrc = -CoxWL * (0.5 * Vgsteff + 0.25 * T0
3573 - T0 * T0 / T1);
3574 T7 = (4.0 * Vgsteff - T0) / (T1 * T1);
3575 T4 = -(0.5 + 24.0 * T0 * T0 / (T1 * T1));
3576 T5 = -(0.25 * AbulkCV - 12.0 * AbulkCV * T0 * T7);
3577 T6 = -(0.25 * VdseffCV - 12.0 * T0 * VdseffCV * T7);
3578 Csg = CoxWL * (T4 + T5 * dVdseffCV_dVg);
3579 Csd = CoxWL * T5 * dVdseffCV_dVd + Csg * dVgsteff_dVd;
3580 Csb = CoxWL * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb)
3581 + Csg * dVgsteff_dVb;
3582 Csg *= dVgsteff_dVg;
3583 }
3584 else if (model->BSIM4xpart < 0.5)
3585 { /* 40/60 Charge petition model */
3586 T1 = T1 / 12.0;
3587 T2 = 0.5 * CoxWL / (T1 * T1);
3588 T3 = Vgsteff * (2.0 * T0 * T0 / 3.0 + Vgsteff
3589 * (Vgsteff - 4.0 * T0 / 3.0))
3590 - 2.0 * T0 * T0 * T0 / 15.0;
3591 qsrc = -T2 * T3;
3592 T7 = 4.0 / 3.0 * Vgsteff * (Vgsteff - T0)
3593 + 0.4 * T0 * T0;
3594 T4 = -2.0 * qsrc / T1 - T2 * (Vgsteff * (3.0
3595 * Vgsteff - 8.0 * T0 / 3.0)
3596 + 2.0 * T0 * T0 / 3.0);
3597 T5 = (qsrc / T1 + T2 * T7) * AbulkCV;
3598 T6 = (qsrc / T1 * VdseffCV + T2 * T7 * VdseffCV);
3599 Csg = (T4 + T5 * dVdseffCV_dVg);
3600 Csd = T5 * dVdseffCV_dVd + Csg * dVgsteff_dVd;
3601 Csb = (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb)
3602 + Csg * dVgsteff_dVb;
3603 Csg *= dVgsteff_dVg;
3604 }
3605 else
3606 { /* 50/50 Charge petition model */
3607 qsrc = -0.5 * (qgate + qbulk);
3608 Csg = -0.5 * (Cgg1 + Cbg1);
3609 Csb = -0.5 * (Cgb1 + Cbb1);
3610 Csd = -0.5 * (Cgd1 + Cbd1);
3611 }
3612
3613 qgate += Qac0 + Qsub0;
3614 qbulk -= (Qac0 + Qsub0);
3615 qdrn = -(qgate + qbulk + qsrc);
3616
3617 Cgg = dQac0_dVg + dQsub0_dVg + Cgg1;
3618 Cgd = dQsub0_dVd + Cgd1;
3619 Cgb = dQac0_dVb + dQsub0_dVb + Cgb1;
3620
3621 Cbg = Cbg1 - dQac0_dVg - dQsub0_dVg;
3622 Cbd = Cbd1 - dQsub0_dVd;
3623 Cbb = Cbb1 - dQac0_dVb - dQsub0_dVb;
3624
3625 Cgb *= dVbseff_dVb;
3626 Cbb *= dVbseff_dVb;
3627 Csb *= dVbseff_dVb;
3628
3629 here->BSIM4cggb = Cgg;
3630 here->BSIM4cgsb = -(Cgg + Cgd + Cgb);
3631 here->BSIM4cgdb = Cgd;
3632 here->BSIM4cdgb = -(Cgg + Cbg + Csg);
3633 here->BSIM4cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb
3634 + Csg + Csd + Csb);
3635 here->BSIM4cddb = -(Cgd + Cbd + Csd);
3636 here->BSIM4cbgb = Cbg;
3637 here->BSIM4cbsb = -(Cbg + Cbd + Cbb);
3638 here->BSIM4cbdb = Cbd;
3639 }
3640
3641 /* Charge-Thickness capMod (CTM) begins */
3642 else if (model->BSIM4capMod == 2)
3643 { V3 = here->BSIM4vfbzb - Vgs_eff + VbseffCV - DELTA_3;
3644 if (here->BSIM4vfbzb <= 0.0)
3645 T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * here->BSIM4vfbzb);
3646 else
3647 T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * here->BSIM4vfbzb);
3648
3649 T1 = 0.5 * (1.0 + V3 / T0);
3650 Vfbeff = here->BSIM4vfbzb - 0.5 * (V3 + T0);
3651 dVfbeff_dVg = T1 * dVgs_eff_dVg;
3652 dVfbeff_dVb = -T1 * dVbseffCV_dVb;
3653
3654 Cox = here->BSIM4coxp;
3655 Tox = 1.0e8 * here->BSIM4toxp;
3656 T0 = (Vgs_eff - VbseffCV - here->BSIM4vfbzb) / Tox;
3657 dT0_dVg = dVgs_eff_dVg / Tox;
3658 dT0_dVb = -dVbseffCV_dVb / Tox;
3659
3660 tmp = T0 * pParam->BSIM4acde;
3661 if ((-EXP_THRESHOLD < tmp) && (tmp < EXP_THRESHOLD))
3662 { Tcen = pParam->BSIM4ldeb * exp(tmp);
3663 dTcen_dVg = pParam->BSIM4acde * Tcen;
3664 dTcen_dVb = dTcen_dVg * dT0_dVb;
3665 dTcen_dVg *= dT0_dVg;
3666 }
3667 else if (tmp <= -EXP_THRESHOLD)
3668 { Tcen = pParam->BSIM4ldeb * MIN_EXP;
3669 dTcen_dVg = dTcen_dVb = 0.0;
3670 }
3671 else
3672 { Tcen = pParam->BSIM4ldeb * MAX_EXP;
3673 dTcen_dVg = dTcen_dVb = 0.0;
3674 }
3675
3676 LINK = 1.0e-3 * here->BSIM4toxp;
3677 V3 = pParam->BSIM4ldeb - Tcen - LINK;
3678 V4 = sqrt(V3 * V3 + 4.0 * LINK * pParam->BSIM4ldeb);
3679 Tcen = pParam->BSIM4ldeb - 0.5 * (V3 + V4);
3680 T1 = 0.5 * (1.0 + V3 / V4);
3681 dTcen_dVg *= T1;
3682 dTcen_dVb *= T1;
3683
3684 Ccen = epssub / Tcen;
3685 T2 = Cox / (Cox + Ccen);
3686 Coxeff = T2 * Ccen;
3687 T3 = -Ccen / Tcen;
3688 dCoxeff_dVg = T2 * T2 * T3;
3689 dCoxeff_dVb = dCoxeff_dVg * dTcen_dVb;
3690 dCoxeff_dVg *= dTcen_dVg;
3691 CoxWLcen = CoxWL * Coxeff / model->BSIM4coxe;
3692
3693 Qac0 = CoxWLcen * (Vfbeff - here->BSIM4vfbzb);
3694 QovCox = Qac0 / Coxeff;
3695 dQac0_dVg = CoxWLcen * dVfbeff_dVg
3696 + QovCox * dCoxeff_dVg;
3697 dQac0_dVb = CoxWLcen * dVfbeff_dVb
3698 + QovCox * dCoxeff_dVb;
3699
3700 T0 = 0.5 * pParam->BSIM4k1ox;
3701 T3 = Vgs_eff - Vfbeff - VbseffCV - Vgsteff;
3702 if (pParam->BSIM4k1ox == 0.0)
3703 { T1 = 0.0;
3704 T2 = 0.0;
3705 }
3706 else if (T3 < 0.0)
3707 { T1 = T0 + T3 / pParam->BSIM4k1ox;
3708 T2 = CoxWLcen;
3709 }
3710 else
3711 { T1 = sqrt(T0 * T0 + T3);
3712 T2 = CoxWLcen * T0 / T1;
3713 }
3714
3715 Qsub0 = CoxWLcen * pParam->BSIM4k1ox * (T1 - T0);
3716 QovCox = Qsub0 / Coxeff;
3717 dQsub0_dVg = T2 * (dVgs_eff_dVg - dVfbeff_dVg - dVgsteff_dVg)
3718 + QovCox * dCoxeff_dVg;
3719 dQsub0_dVd = -T2 * dVgsteff_dVd;
3720 dQsub0_dVb = -T2 * (dVfbeff_dVb + dVbseffCV_dVb + dVgsteff_dVb)
3721 + QovCox * dCoxeff_dVb;
3722
3723 /* Gate-bias dependent delta Phis begins */
3724 if (pParam->BSIM4k1ox <= 0.0)
3725 { Denomi = 0.25 * pParam->BSIM4moin * Vtm;
3726 T0 = 0.5 * pParam->BSIM4sqrtPhi;
3727 }
3728 else
3729 { Denomi = pParam->BSIM4moin * Vtm
3730 * pParam->BSIM4k1ox * pParam->BSIM4k1ox;
3731 T0 = pParam->BSIM4k1ox * pParam->BSIM4sqrtPhi;
3732 }
3733 T1 = 2.0 * T0 + Vgsteff;
3734
3735 DeltaPhi = Vtm * log(1.0 + T1 * Vgsteff / Denomi);
3736 dDeltaPhi_dVg = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff);
3737 /* End of delta Phis */
3738
3739 /* VgDP = Vgsteff - DeltaPhi */
3740 T0 = Vgsteff - DeltaPhi - 0.001;
3741 dT0_dVg = 1.0 - dDeltaPhi_dVg;
3742 T1 = sqrt(T0 * T0 + Vgsteff * 0.004);
3743 VgDP = 0.5 * (T0 + T1);
3744 dVgDP_dVg = 0.5 * (dT0_dVg + (T0 * dT0_dVg + 0.002) / T1);
3745
3746 Tox += Tox; /* WDLiu: Tcen reevaluated below due to different Vgsteff */
3747 T0 = (Vgsteff + here->BSIM4vtfbphi2) / Tox;
3748 tmp = exp(model->BSIM4bdos * 0.7 * log(T0));
3749 T1 = 1.0 + tmp;
3750 T2 = model->BSIM4bdos * 0.7 * tmp / (T0 * Tox);
3751 Tcen = model->BSIM4ados * 1.9e-9 / T1;
3752 dTcen_dVg = -Tcen * T2 / T1;
3753 dTcen_dVd = dTcen_dVg * dVgsteff_dVd;
3754 dTcen_dVb = dTcen_dVg * dVgsteff_dVb;
3755 dTcen_dVg *= dVgsteff_dVg;
3756
3757 Ccen = epssub / Tcen;
3758 T0 = Cox / (Cox + Ccen);
3759 Coxeff = T0 * Ccen;
3760 T1 = -Ccen / Tcen;
3761 dCoxeff_dVg = T0 * T0 * T1;
3762 dCoxeff_dVd = dCoxeff_dVg * dTcen_dVd;
3763 dCoxeff_dVb = dCoxeff_dVg * dTcen_dVb;
3764 dCoxeff_dVg *= dTcen_dVg;
3765 CoxWLcen = CoxWL * Coxeff / model->BSIM4coxe;
3766
3767 AbulkCV = Abulk0 * pParam->BSIM4abulkCVfactor;
3768 dAbulkCV_dVb = pParam->BSIM4abulkCVfactor * dAbulk0_dVb;
3769 VdsatCV = VgDP / AbulkCV;
3770
3771 T0 = VdsatCV - Vds - DELTA_4;
3772 dT0_dVg = dVgDP_dVg / AbulkCV;
3773 dT0_dVb = -VdsatCV * dAbulkCV_dVb / AbulkCV;
3774 T1 = sqrt(T0 * T0 + 4.0 * DELTA_4 * VdsatCV);
3775 dT1_dVg = (T0 + DELTA_4 + DELTA_4) / T1;
3776 dT1_dVd = -T0 / T1;
3777 dT1_dVb = dT1_dVg * dT0_dVb;
3778 dT1_dVg *= dT0_dVg;
3779 if (T0 >= 0.0)
3780 { VdseffCV = VdsatCV - 0.5 * (T0 + T1);
3781 dVdseffCV_dVg = 0.5 * (dT0_dVg - dT1_dVg);
3782 dVdseffCV_dVd = 0.5 * (1.0 - dT1_dVd);
3783 dVdseffCV_dVb = 0.5 * (dT0_dVb - dT1_dVb);
3784 }
3785 else
3786 { T3 = (DELTA_4 + DELTA_4) / (T1 - T0);
3787 T4 = 1.0 - T3;
3788 T5 = VdsatCV * T3 / (T1 - T0);
3789 VdseffCV = VdsatCV * T4;
3790 dVdseffCV_dVg = dT0_dVg * T4 + T5 * (dT1_dVg - dT0_dVg);
3791 dVdseffCV_dVd = T5 * (dT1_dVd + 1.0);
3792 dVdseffCV_dVb = dT0_dVb * (T4 - T5) + T5 * dT1_dVb;
3793 }
3794
3795 if (Vds == 0.0)
3796 { VdseffCV = 0.0;
3797 dVdseffCV_dVg = 0.0;
3798 dVdseffCV_dVb = 0.0;
3799 }
3800
3801 T0 = AbulkCV * VdseffCV;
3802 T1 = VgDP;
3803 T2 = 12.0 * (T1 - 0.5 * T0 + 1.0e-20);
3804 T3 = T0 / T2;
3805 T4 = 1.0 - 12.0 * T3 * T3;
3806 T5 = AbulkCV * (6.0 * T0 * (4.0 * T1 - T0) / (T2 * T2) - 0.5);
3807 T6 = T5 * VdseffCV / AbulkCV;
3808
3809 qgate = CoxWLcen * (T1 - T0 * (0.5 - T3));
3810 QovCox = qgate / Coxeff;
3811 Cgg1 = CoxWLcen * (T4 * dVgDP_dVg
3812 + T5 * dVdseffCV_dVg);
3813 Cgd1 = CoxWLcen * T5 * dVdseffCV_dVd + Cgg1
3814 * dVgsteff_dVd + QovCox * dCoxeff_dVd;
3815 Cgb1 = CoxWLcen * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb)
3816 + Cgg1 * dVgsteff_dVb + QovCox * dCoxeff_dVb;
3817 Cgg1 = Cgg1 * dVgsteff_dVg + QovCox * dCoxeff_dVg;
3818
3819
3820 T7 = 1.0 - AbulkCV;
3821 T8 = T2 * T2;
3822 T9 = 12.0 * T7 * T0 * T0 / (T8 * AbulkCV);
3823 T10 = T9 * dVgDP_dVg;
3824 T11 = -T7 * T5 / AbulkCV;
3825 T12 = -(T9 * T1 / AbulkCV + VdseffCV * (0.5 - T0 / T2));
3826
3827 qbulk = CoxWLcen * T7 * (0.5 * VdseffCV - T0 * VdseffCV / T2);
3828 QovCox = qbulk / Coxeff;
3829 Cbg1 = CoxWLcen * (T10 + T11 * dVdseffCV_dVg);
3830 Cbd1 = CoxWLcen * T11 * dVdseffCV_dVd + Cbg1
3831 * dVgsteff_dVd + QovCox * dCoxeff_dVd;
3832 Cbb1 = CoxWLcen * (T11 * dVdseffCV_dVb + T12 * dAbulkCV_dVb)
3833 + Cbg1 * dVgsteff_dVb + QovCox * dCoxeff_dVb;
3834 Cbg1 = Cbg1 * dVgsteff_dVg + QovCox * dCoxeff_dVg;
3835
3836 if (model->BSIM4xpart > 0.5)
3837 { /* 0/100 partition */
3838 qsrc = -CoxWLcen * (T1 / 2.0 + T0 / 4.0
3839 - 0.5 * T0 * T0 / T2);
3840 QovCox = qsrc / Coxeff;
3841 T2 += T2;
3842 T3 = T2 * T2;
3843 T7 = -(0.25 - 12.0 * T0 * (4.0 * T1 - T0) / T3);
3844 T4 = -(0.5 + 24.0 * T0 * T0 / T3) * dVgDP_dVg;
3845 T5 = T7 * AbulkCV;
3846 T6 = T7 * VdseffCV;
3847
3848 Csg = CoxWLcen * (T4 + T5 * dVdseffCV_dVg);
3849 Csd = CoxWLcen * T5 * dVdseffCV_dVd + Csg * dVgsteff_dVd
3850 + QovCox * dCoxeff_dVd;
3851 Csb = CoxWLcen * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb)
3852 + Csg * dVgsteff_dVb + QovCox * dCoxeff_dVb;
3853 Csg = Csg * dVgsteff_dVg + QovCox * dCoxeff_dVg;
3854 }
3855 else if (model->BSIM4xpart < 0.5)
3856 { /* 40/60 partition */
3857 T2 = T2 / 12.0;
3858 T3 = 0.5 * CoxWLcen / (T2 * T2);
3859 T4 = T1 * (2.0 * T0 * T0 / 3.0 + T1 * (T1 - 4.0
3860 * T0 / 3.0)) - 2.0 * T0 * T0 * T0 / 15.0;
3861 qsrc = -T3 * T4;
3862 QovCox = qsrc / Coxeff;
3863 T8 = 4.0 / 3.0 * T1 * (T1 - T0) + 0.4 * T0 * T0;
3864 T5 = -2.0 * qsrc / T2 - T3 * (T1 * (3.0 * T1 - 8.0
3865 * T0 / 3.0) + 2.0 * T0 * T0 / 3.0);
3866 T6 = AbulkCV * (qsrc / T2 + T3 * T8);
3867 T7 = T6 * VdseffCV / AbulkCV;
3868
3869 Csg = T5 * dVgDP_dVg + T6 * dVdseffCV_dVg;
3870 Csd = Csg * dVgsteff_dVd + T6 * dVdseffCV_dVd
3871 + QovCox * dCoxeff_dVd;
3872 Csb = Csg * dVgsteff_dVb + T6 * dVdseffCV_dVb
3873 + T7 * dAbulkCV_dVb + QovCox * dCoxeff_dVb;
3874 Csg = Csg * dVgsteff_dVg + QovCox * dCoxeff_dVg;
3875 }
3876 else
3877 { /* 50/50 partition */
3878 qsrc = -0.5 * qgate;
3879 Csg = -0.5 * Cgg1;
3880 Csd = -0.5 * Cgd1;
3881 Csb = -0.5 * Cgb1;
3882 }
3883
3884 qgate += Qac0 + Qsub0 - qbulk;
3885 qbulk -= (Qac0 + Qsub0);
3886 qdrn = -(qgate + qbulk + qsrc);
3887
3888 Cbg = Cbg1 - dQac0_dVg - dQsub0_dVg;
3889 Cbd = Cbd1 - dQsub0_dVd;
3890 Cbb = Cbb1 - dQac0_dVb - dQsub0_dVb;
3891
3892 Cgg = Cgg1 - Cbg;
3893 Cgd = Cgd1 - Cbd;
3894 Cgb = Cgb1 - Cbb;
3895
3896 Cgb *= dVbseff_dVb;
3897 Cbb *= dVbseff_dVb;
3898 Csb *= dVbseff_dVb;
3899
3900 here->BSIM4cggb = Cgg;
3901 here->BSIM4cgsb = -(Cgg + Cgd + Cgb);
3902 here->BSIM4cgdb = Cgd;
3903 here->BSIM4cdgb = -(Cgg + Cbg + Csg);
3904 here->BSIM4cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb
3905 + Csg + Csd + Csb);
3906 here->BSIM4cddb = -(Cgd + Cbd + Csd);
3907 here->BSIM4cbgb = Cbg;
3908 here->BSIM4cbsb = -(Cbg + Cbd + Cbb);
3909 here->BSIM4cbdb = Cbd;
3910 } /* End of CTM */
3911 }
3912
3913 here->BSIM4csgb = - here->BSIM4cggb - here->BSIM4cdgb - here->BSIM4cbgb;
3914 here->BSIM4csdb = - here->BSIM4cgdb - here->BSIM4cddb - here->BSIM4cbdb;
3915 here->BSIM4cssb = - here->BSIM4cgsb - here->BSIM4cdsb - here->BSIM4cbsb;
3916 here->BSIM4cgbb = - here->BSIM4cgdb - here->BSIM4cggb - here->BSIM4cgsb;
3917 here->BSIM4cdbb = - here->BSIM4cddb - here->BSIM4cdgb - here->BSIM4cdsb;
3918 here->BSIM4cbbb = - here->BSIM4cbgb - here->BSIM4cbdb - here->BSIM4cbsb;
3919 here->BSIM4csbb = - here->BSIM4cgbb - here->BSIM4cdbb - here->BSIM4cbbb;
3920 here->BSIM4qgate = qgate;
3921 here->BSIM4qbulk = qbulk;
3922 here->BSIM4qdrn = qdrn;
3923 here->BSIM4qsrc = -(qgate + qbulk + qdrn);
3924
3925 /* NQS begins */
3926 if ((here->BSIM4trnqsMod) || (here->BSIM4acnqsMod))
3927 { here->BSIM4qchqs = qcheq = -(qbulk + qgate);
3928 here->BSIM4cqgb = -(here->BSIM4cggb + here->BSIM4cbgb);
3929 here->BSIM4cqdb = -(here->BSIM4cgdb + here->BSIM4cbdb);
3930 here->BSIM4cqsb = -(here->BSIM4cgsb + here->BSIM4cbsb);
3931 here->BSIM4cqbb = -(here->BSIM4cqgb + here->BSIM4cqdb
3932 + here->BSIM4cqsb);
3933
3934 CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV * here->BSIM4nf
3935 * pParam->BSIM4leffCV;
3936 T1 = here->BSIM4gcrg / CoxWL; /* 1 / tau */
3937 here->BSIM4gtau = T1 * ScalingFactor;
3938
3939 if (here->BSIM4acnqsMod)
3940 here->BSIM4taunet = 1.0 / T1;
3941
3942 *(ckt->CKTstate0 + here->BSIM4qcheq) = qcheq;
3943 if (ckt->CKTmode & MODEINITTRAN)
3944 *(ckt->CKTstate1 + here->BSIM4qcheq) =
3945 *(ckt->CKTstate0 + here->BSIM4qcheq);
3946 if (here->BSIM4trnqsMod)
3947 { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qcheq);
3948 if (error)
3949 return(error);
3950 }
3951 }
3952
3953
3954 finished:
3955
3956 /* Calculate junction C-V */
3957 if (ChargeComputationNeeded)
3958 { czbd = model->BSIM4DunitAreaTempJctCap * here->BSIM4Adeff; /* bug fix */
3959 czbs = model->BSIM4SunitAreaTempJctCap * here->BSIM4Aseff;
3960 czbdsw = model->BSIM4DunitLengthSidewallTempJctCap * here->BSIM4Pdeff;
3961 czbdswg = model->BSIM4DunitLengthGateSidewallTempJctCap
3962 * pParam->BSIM4weffCJ * here->BSIM4nf;
3963 czbssw = model->BSIM4SunitLengthSidewallTempJctCap * here->BSIM4Pseff;
3964 czbsswg = model->BSIM4SunitLengthGateSidewallTempJctCap
3965 * pParam->BSIM4weffCJ * here->BSIM4nf;
3966
3967 MJS = model->BSIM4SbulkJctBotGradingCoeff;
3968 MJSWS = model->BSIM4SbulkJctSideGradingCoeff;
3969 MJSWGS = model->BSIM4SbulkJctGateSideGradingCoeff;
3970
3971 MJD = model->BSIM4DbulkJctBotGradingCoeff;
3972 MJSWD = model->BSIM4DbulkJctSideGradingCoeff;
3973 MJSWGD = model->BSIM4DbulkJctGateSideGradingCoeff;
3974
3975 /* Source Bulk Junction */
3976 if (vbs_jct == 0.0)
3977 { *(ckt->CKTstate0 + here->BSIM4qbs) = 0.0;
3978 here->BSIM4capbs = czbs + czbssw + czbsswg;
3979 }
3980 else if (vbs_jct < 0.0)
3981 { if (czbs > 0.0)
3982 { arg = 1.0 - vbs_jct / model->BSIM4PhiBS;
3983 if (MJS == 0.5)
3984 sarg = 1.0 / sqrt(arg);
3985 else
3986 sarg = exp(-MJS * log(arg));
3987 *(ckt->CKTstate0 + here->BSIM4qbs) = model->BSIM4PhiBS * czbs
3988 * (1.0 - arg * sarg) / (1.0 - MJS);
3989 here->BSIM4capbs = czbs * sarg;
3990 }
3991 else
3992 { *(ckt->CKTstate0 + here->BSIM4qbs) = 0.0;
3993 here->BSIM4capbs = 0.0;
3994 }
3995 if (czbssw > 0.0)
3996 { arg = 1.0 - vbs_jct / model->BSIM4PhiBSWS;
3997 if (MJSWS == 0.5)
3998 sarg = 1.0 / sqrt(arg);
3999 else
4000 sarg = exp(-MJSWS * log(arg));
4001 *(ckt->CKTstate0 + here->BSIM4qbs) += model->BSIM4PhiBSWS * czbssw
4002 * (1.0 - arg * sarg) / (1.0 - MJSWS);
4003 here->BSIM4capbs += czbssw * sarg;
4004 }
4005 if (czbsswg > 0.0)
4006 { arg = 1.0 - vbs_jct / model->BSIM4PhiBSWGS;
4007 if (MJSWGS == 0.5)
4008 sarg = 1.0 / sqrt(arg);
4009 else
4010 sarg = exp(-MJSWGS * log(arg));
4011 *(ckt->CKTstate0 + here->BSIM4qbs) += model->BSIM4PhiBSWGS * czbsswg
4012 * (1.0 - arg * sarg) / (1.0 - MJSWGS);
4013 here->BSIM4capbs += czbsswg * sarg;
4014 }
4015
4016 }
4017 else
4018 { T0 = czbs + czbssw + czbsswg;
4019 T1 = vbs_jct * (czbs * MJS / model->BSIM4PhiBS + czbssw * MJSWS
4020 / model->BSIM4PhiBSWS + czbsswg * MJSWGS / model->BSIM4PhiBSWGS);
4021 *(ckt->CKTstate0 + here->BSIM4qbs) = vbs_jct * (T0 + 0.5 * T1);
4022 here->BSIM4capbs = T0 + T1;
4023 }
4024
4025 /* Drain Bulk Junction */
4026 if (vbd_jct == 0.0)
4027 { *(ckt->CKTstate0 + here->BSIM4qbd) = 0.0;
4028 here->BSIM4capbd = czbd + czbdsw + czbdswg;
4029 }
4030 else if (vbd_jct < 0.0)
4031 { if (czbd > 0.0)
4032 { arg = 1.0 - vbd_jct / model->BSIM4PhiBD;
4033 if (MJD == 0.5)
4034 sarg = 1.0 / sqrt(arg);
4035 else
4036 sarg = exp(-MJD * log(arg));
4037 *(ckt->CKTstate0 + here->BSIM4qbd) = model->BSIM4PhiBD* czbd
4038 * (1.0 - arg * sarg) / (1.0 - MJD);
4039 here->BSIM4capbd = czbd * sarg;
4040 }
4041 else
4042 { *(ckt->CKTstate0 + here->BSIM4qbd) = 0.0;
4043 here->BSIM4capbd = 0.0;
4044 }
4045 if (czbdsw > 0.0)
4046 { arg = 1.0 - vbd_jct / model->BSIM4PhiBSWD;
4047 if (MJSWD == 0.5)
4048 sarg = 1.0 / sqrt(arg);
4049 else
4050 sarg = exp(-MJSWD * log(arg));
4051 *(ckt->CKTstate0 + here->BSIM4qbd) += model->BSIM4PhiBSWD * czbdsw
4052 * (1.0 - arg * sarg) / (1.0 - MJSWD);
4053 here->BSIM4capbd += czbdsw * sarg;
4054 }
4055 if (czbdswg > 0.0)
4056 { arg = 1.0 - vbd_jct / model->BSIM4PhiBSWGD;
4057 if (MJSWGD == 0.5)
4058 sarg = 1.0 / sqrt(arg);
4059 else
4060 sarg = exp(-MJSWGD * log(arg));
4061 *(ckt->CKTstate0 + here->BSIM4qbd) += model->BSIM4PhiBSWGD * czbdswg
4062 * (1.0 - arg * sarg) / (1.0 - MJSWGD);
4063 here->BSIM4capbd += czbdswg * sarg;
4064 }
4065 }
4066 else
4067 { T0 = czbd + czbdsw + czbdswg;
4068 T1 = vbd_jct * (czbd * MJD / model->BSIM4PhiBD + czbdsw * MJSWD
4069 / model->BSIM4PhiBSWD + czbdswg * MJSWGD / model->BSIM4PhiBSWGD);
4070 *(ckt->CKTstate0 + here->BSIM4qbd) = vbd_jct * (T0 + 0.5 * T1);
4071 here->BSIM4capbd = T0 + T1;
4072 }
4073 }
4074
4075
4076 /*
4077 * check convergence
4078 */
4079
4080 if ((here->BSIM4off == 0) || (!(ckt->CKTmode & MODEINITFIX)))
4081 { if (Check == 1)
4082 { ckt->CKTnoncon++;
4083 #ifndef NEWCONV
4084 }
4085 else
4086 { if (here->BSIM4mode >= 0)
4087 { Idtot = here->BSIM4cd + here->BSIM4csub
4088 + here->BSIM4Igidl - here->BSIM4cbd;
4089 }
4090 else
4091 { Idtot = here->BSIM4cd + here->BSIM4cbd - here->BSIM4Igidl; /* bugfix */
4092 }
4093 tol0 = ckt->CKTreltol * MAX(fabs(cdhat), fabs(Idtot))
4094 + ckt->CKTabstol;
4095 tol1 = ckt->CKTreltol * MAX(fabs(cseshat), fabs(Isestot))
4096 + ckt->CKTabstol;
4097 tol2 = ckt->CKTreltol * MAX(fabs(cdedhat), fabs(Idedtot))
4098 + ckt->CKTabstol;
4099 tol3 = ckt->CKTreltol * MAX(fabs(cgshat), fabs(Igstot))
4100 + ckt->CKTabstol;
4101 tol4 = ckt->CKTreltol * MAX(fabs(cgdhat), fabs(Igdtot))
4102 + ckt->CKTabstol;
4103 tol5 = ckt->CKTreltol * MAX(fabs(cgbhat), fabs(Igbtot))
4104 + ckt->CKTabstol;
4105 if ((fabs(cdhat - Idtot) >= tol0) || (fabs(cseshat - Isestot) >= tol1)
4106 || (fabs(cdedhat - Idedtot) >= tol2))
4107 { ckt->CKTnoncon++;
4108 }
4109 else if ((fabs(cgshat - Igstot) >= tol3) || (fabs(cgdhat - Igdtot) >= tol4)
4110 || (fabs(cgbhat - Igbtot) >= tol5))
4111 { ckt->CKTnoncon++;
4112 }
4113 else
4114 { Ibtot = here->BSIM4cbs + here->BSIM4cbd
4115 - here->BSIM4Igidl - here->BSIM4Igisl - here->BSIM4csub;
4116 tol6 = ckt->CKTreltol * MAX(fabs(cbhat), fabs(Ibtot))
4117 + ckt->CKTabstol;
4118 if (fabs(cbhat - Ibtot) > tol6)
4119 { ckt->CKTnoncon++;
4120 }
4121 }
4122 #endif /* NEWCONV */
4123 }
4124 }
4125 *(ckt->CKTstate0 + here->BSIM4vds) = vds;
4126 *(ckt->CKTstate0 + here->BSIM4vgs) = vgs;
4127 *(ckt->CKTstate0 + here->BSIM4vbs) = vbs;
4128 *(ckt->CKTstate0 + here->BSIM4vbd) = vbd;
4129 *(ckt->CKTstate0 + here->BSIM4vges) = vges;
4130 *(ckt->CKTstate0 + here->BSIM4vgms) = vgms;
4131 *(ckt->CKTstate0 + here->BSIM4vdbs) = vdbs;
4132 *(ckt->CKTstate0 + here->BSIM4vdbd) = vdbd;
4133 *(ckt->CKTstate0 + here->BSIM4vsbs) = vsbs;
4134 *(ckt->CKTstate0 + here->BSIM4vses) = vses;
4135 *(ckt->CKTstate0 + here->BSIM4vdes) = vdes;
4136 *(ckt->CKTstate0 + here->BSIM4qdef) = qdef;
4137
4138
4139 if (!ChargeComputationNeeded)
4140 goto line850;
4141
4142 if (here->BSIM4rgateMod == 3)
4143 {
4144 vgdx = vgmd;
4145 vgsx = vgms;
4146 }
4147 else /* For rgateMod == 0, 1 and 2 */
4148 {
4149 vgdx = vgd;
4150 vgsx = vgs;
4151 }
4152 if (model->BSIM4capMod == 0)
4153 {
4154 cgdo = pParam->BSIM4cgdo;
4155 qgdo = pParam->BSIM4cgdo * vgdx;
4156 cgso = pParam->BSIM4cgso;
4157 qgso = pParam->BSIM4cgso * vgsx;
4158 }
4159 else /* For both capMod == 1 and 2 */
4160 { T0 = vgdx + DELTA_1;
4161 T1 = sqrt(T0 * T0 + 4.0 * DELTA_1);
4162 T2 = 0.5 * (T0 - T1);
4163
4164 T3 = pParam->BSIM4weffCV * pParam->BSIM4cgdl;
4165 T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM4ckappad);
4166 cgdo = pParam->BSIM4cgdo + T3 - T3 * (1.0 - 1.0 / T4)
4167 * (0.5 - 0.5 * T0 / T1);
4168 qgdo = (pParam->BSIM4cgdo + T3) * vgdx - T3 * (T2
4169 + 0.5 * pParam->BSIM4ckappad * (T4 - 1.0));
4170
4171 T0 = vgsx + DELTA_1;
4172 T1 = sqrt(T0 * T0 + 4.0 * DELTA_1);
4173 T2 = 0.5 * (T0 - T1);
4174 T3 = pParam->BSIM4weffCV * pParam->BSIM4cgsl;
4175 T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM4ckappas);
4176 cgso = pParam->BSIM4cgso + T3 - T3 * (1.0 - 1.0 / T4)
4177 * (0.5 - 0.5 * T0 / T1);
4178 qgso = (pParam->BSIM4cgso + T3) * vgsx - T3 * (T2
4179 + 0.5 * pParam->BSIM4ckappas * (T4 - 1.0));
4180 }
4181
4182 if (here->BSIM4nf != 1.0)
4183 { cgdo *= here->BSIM4nf;
4184 cgso *= here->BSIM4nf;
4185 qgdo *= here->BSIM4nf;
4186 qgso *= here->BSIM4nf;
4187 }
4188 here->BSIM4cgdo = cgdo;
4189 here->BSIM4qgdo = qgdo;
4190 here->BSIM4cgso = cgso;
4191 here->BSIM4qgso = qgso;
4192
4193 #ifndef NOBYPASS
4194 line755:
4195 #endif
4196 ag0 = ckt->CKTag[0];
4197 if (here->BSIM4mode > 0)
4198 { if (here->BSIM4trnqsMod == 0)
4199 { qdrn -= qgdo;
4200 if (here->BSIM4rgateMod == 3)
4201 { gcgmgmb = (cgdo + cgso + pParam->BSIM4cgbo) * ag0;
4202 gcgmdb = -cgdo * ag0;
4203 gcgmsb = -cgso * ag0;
4204 gcgmbb = -pParam->BSIM4cgbo * ag0;
4205
4206 gcdgmb = gcgmdb;
4207 gcsgmb = gcgmsb;
4208 gcbgmb = gcgmbb;
4209
4210 gcggb = here->BSIM4cggb * ag0;
4211 gcgdb = here->BSIM4cgdb * ag0;
4212 gcgsb = here->BSIM4cgsb * ag0;
4213 gcgbb = -(gcggb + gcgdb + gcgsb);
4214
4215 gcdgb = here->BSIM4cdgb * ag0;
4216 gcsgb = -(here->BSIM4cggb + here->BSIM4cbgb
4217 + here->BSIM4cdgb) * ag0;
4218 gcbgb = here->BSIM4cbgb * ag0;
4219
4220 qgmb = pParam->BSIM4cgbo * vgmb;
4221 qgmid = qgdo + qgso + qgmb;
4222 qbulk -= qgmb;
4223 qsrc = -(qgate + qgmid + qbulk + qdrn);
4224 }
4225 else
4226 { gcggb = (here->BSIM4cggb + cgdo + cgso
4227 + pParam->BSIM4cgbo ) * ag0;
4228 gcgdb = (here->BSIM4cgdb - cgdo) * ag0;
4229 gcgsb = (here->BSIM4cgsb - cgso) * ag0;
4230 gcgbb = -(gcggb + gcgdb + gcgsb);
4231
4232 gcdgb = (here->BSIM4cdgb - cgdo) * ag0;
4233 gcsgb = -(here->BSIM4cggb + here->BSIM4cbgb
4234 + here->BSIM4cdgb + cgso) * ag0;
4235 gcbgb = (here->BSIM4cbgb - pParam->BSIM4cgbo) * ag0;
4236
4237 gcdgmb = gcsgmb = gcbgmb = 0.0;
4238
4239 qgb = pParam->BSIM4cgbo * vgb;
4240 qgate += qgdo + qgso + qgb;
4241 qbulk -= qgb;
4242 qsrc = -(qgate + qbulk + qdrn);
4243 }
4244 gcddb = (here->BSIM4cddb + here->BSIM4capbd + cgdo) * ag0;
4245 gcdsb = here->BSIM4cdsb * ag0;
4246
4247 gcsdb = -(here->BSIM4cgdb + here->BSIM4cbdb
4248 + here->BSIM4cddb) * ag0;
4249 gcssb = (here->BSIM4capbs + cgso - (here->BSIM4cgsb
4250 + here->BSIM4cbsb + here->BSIM4cdsb)) * ag0;
4251
4252 if (!here->BSIM4rbodyMod)
4253 { gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb);
4254 gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb);
4255 gcbdb = (here->BSIM4cbdb - here->BSIM4capbd) * ag0;
4256 gcbsb = (here->BSIM4cbsb - here->BSIM4capbs) * ag0;
4257 gcdbdb = 0.0; gcsbsb = 0.0;
4258 }
4259 else
4260 { gcdbb = -(here->BSIM4cddb + here->BSIM4cdgb
4261 + here->BSIM4cdsb) * ag0;
4262 gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb)
4263 + here->BSIM4capbs * ag0;
4264 gcbdb = here->BSIM4cbdb * ag0;
4265 gcbsb = here->BSIM4cbsb * ag0;
4266
4267 gcdbdb = -here->BSIM4capbd * ag0;
4268 gcsbsb = -here->BSIM4capbs * ag0;
4269 }
4270 gcbbb = -(gcbdb + gcbgb + gcbsb + gcbgmb);
4271
4272 ggtg = ggtd = ggtb = ggts = 0.0;
4273 sxpart = 0.6;
4274 dxpart = 0.4;
4275 ddxpart_dVd = ddxpart_dVg = ddxpart_dVb = ddxpart_dVs = 0.0;
4276 dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0;
4277 }
4278 else
4279 { qcheq = here->BSIM4qchqs;
4280 CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV * here->BSIM4nf
4281 * pParam->BSIM4leffCV;
4282 T0 = qdef * ScalingFactor / CoxWL;
4283
4284 ggtg = here->BSIM4gtg = T0 * here->BSIM4gcrgg;
4285 ggtd = here->BSIM4gtd = T0 * here->BSIM4gcrgd;
4286 ggts = here->BSIM4gts = T0 * here->BSIM4gcrgs;
4287 ggtb = here->BSIM4gtb = T0 * here->BSIM4gcrgb;
4288 gqdef = ScalingFactor * ag0;
4289
4290 gcqgb = here->BSIM4cqgb * ag0;
4291 gcqdb = here->BSIM4cqdb * ag0;
4292 gcqsb = here->BSIM4cqsb * ag0;
4293 gcqbb = here->BSIM4cqbb * ag0;
4294
4295 if (fabs(qcheq) <= 1.0e-5 * CoxWL)
4296 { if (model->BSIM4xpart < 0.5)
4297 { dxpart = 0.4;
4298 }
4299 else if (model->BSIM4xpart > 0.5)
4300 { dxpart = 0.0;
4301 }
4302 else
4303 { dxpart = 0.5;
4304 }
4305 ddxpart_dVd = ddxpart_dVg = ddxpart_dVb
4306 = ddxpart_dVs = 0.0;
4307 }
4308 else
4309 { dxpart = qdrn / qcheq;
4310 Cdd = here->BSIM4cddb;
4311 Csd = -(here->BSIM4cgdb + here->BSIM4cddb
4312 + here->BSIM4cbdb);
4313 ddxpart_dVd = (Cdd - dxpart * (Cdd + Csd)) / qcheq;
4314 Cdg = here->BSIM4cdgb;
4315 Csg = -(here->BSIM4cggb + here->BSIM4cdgb
4316 + here->BSIM4cbgb);
4317 ddxpart_dVg = (Cdg - dxpart * (Cdg + Csg)) / qcheq;
4318
4319 Cds = here->BSIM4cdsb;
4320 Css = -(here->BSIM4cgsb + here->BSIM4cdsb
4321 + here->BSIM4cbsb);
4322 ddxpart_dVs = (Cds - dxpart * (Cds + Css)) / qcheq;
4323
4324 ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs);
4325 }
4326 sxpart = 1.0 - dxpart;
4327 dsxpart_dVd = -ddxpart_dVd;
4328 dsxpart_dVg = -ddxpart_dVg;
4329 dsxpart_dVs = -ddxpart_dVs;
4330 dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg + dsxpart_dVs);
4331
4332 if (here->BSIM4rgateMod == 3)
4333 { gcgmgmb = (cgdo + cgso + pParam->BSIM4cgbo) * ag0;
4334 gcgmdb = -cgdo * ag0;
4335 gcgmsb = -cgso * ag0;
4336 gcgmbb = -pParam->BSIM4cgbo * ag0;
4337
4338 gcdgmb = gcgmdb;
4339 gcsgmb = gcgmsb;
4340 gcbgmb = gcgmbb;
4341
4342 gcdgb = gcsgb = gcbgb = 0.0;
4343 gcggb = gcgdb = gcgsb = gcgbb = 0.0;
4344
4345 qgmb = pParam->BSIM4cgbo * vgmb;
4346 qgmid = qgdo + qgso + qgmb;
4347 qgate = 0.0;
4348 qbulk = -qgmb;
4349 qdrn = -qgdo;
4350 qsrc = -(qgmid + qbulk + qdrn);
4351 }
4352 else
4353 { gcggb = (cgdo + cgso + pParam->BSIM4cgbo ) * ag0;
4354 gcgdb = -cgdo * ag0;
4355 gcgsb = -cgso * ag0;
4356 gcgbb = -pParam->BSIM4cgbo * ag0;
4357
4358 gcdgb = gcgdb;
4359 gcsgb = gcgsb;
4360 gcbgb = gcgbb;
4361 gcdgmb = gcsgmb = gcbgmb = 0.0;
4362
4363 qgb = pParam->BSIM4cgbo * vgb;
4364 qgate = qgdo + qgso + qgb;
4365 qbulk = -qgb;
4366 qdrn = -qgdo;
4367 qsrc = -(qgate + qbulk + qdrn);
4368 }
4369
4370 gcddb = (here->BSIM4capbd + cgdo) * ag0;
4371 gcdsb = gcsdb = 0.0;
4372 gcssb = (here->BSIM4capbs + cgso) * ag0;
4373
4374 if (!here->BSIM4rbodyMod)
4375 { gcdbb = -(gcdgb + gcddb + gcdgmb);
4376 gcsbb = -(gcsgb + gcssb + gcsgmb);
4377 gcbdb = -here->BSIM4capbd * ag0;
4378 gcbsb = -here->BSIM4capbs * ag0;
4379 gcdbdb = 0.0; gcsbsb = 0.0;
4380 }
4381 else
4382 { gcdbb = gcsbb = gcbdb = gcbsb = 0.0;
4383 gcdbdb = -here->BSIM4capbd * ag0;
4384 gcsbsb = -here->BSIM4capbs * ag0;
4385 }
4386 gcbbb = -(gcbdb + gcbgb + gcbsb + gcbgmb);
4387 }
4388 }
4389 else
4390 { if (here->BSIM4trnqsMod == 0)
4391 { qsrc = qdrn - qgso;
4392 if (here->BSIM4rgateMod == 3)
4393 { gcgmgmb = (cgdo + cgso + pParam->BSIM4cgbo) * ag0;
4394 gcgmdb = -cgdo * ag0;
4395 gcgmsb = -cgso * ag0;
4396 gcgmbb = -pParam->BSIM4cgbo * ag0;
4397
4398 gcdgmb = gcgmdb;
4399 gcsgmb = gcgmsb;
4400 gcbgmb = gcgmbb;
4401
4402 gcggb = here->BSIM4cggb * ag0;
4403 gcgdb = here->BSIM4cgsb * ag0;
4404 gcgsb = here->BSIM4cgdb * ag0;
4405 gcgbb = -(gcggb + gcgdb + gcgsb);
4406
4407 gcdgb = -(here->BSIM4cggb + here->BSIM4cbgb
4408 + here->BSIM4cdgb) * ag0;
4409 gcsgb = here->BSIM4cdgb * ag0;
4410 gcbgb = here->BSIM4cbgb * ag0;
4411
4412 qgmb = pParam->BSIM4cgbo * vgmb;
4413 qgmid = qgdo + qgso + qgmb;
4414 qbulk -= qgmb;
4415 qdrn = -(qgate + qgmid + qbulk + qsrc);
4416 }
4417 else
4418 { gcggb = (here->BSIM4cggb + cgdo + cgso
4419 + pParam->BSIM4cgbo ) * ag0;
4420 gcgdb = (here->BSIM4cgsb - cgdo) * ag0;
4421 gcgsb = (here->BSIM4cgdb - cgso) * ag0;
4422 gcgbb = -(gcggb + gcgdb + gcgsb);
4423
4424 gcdgb = -(here->BSIM4cggb + here->BSIM4cbgb
4425 + here->BSIM4cdgb + cgdo) * ag0;
4426 gcsgb = (here->BSIM4cdgb - cgso) * ag0;
4427 gcbgb = (here->BSIM4cbgb - pParam->BSIM4cgbo) * ag0;
4428
4429 gcdgmb = gcsgmb = gcbgmb = 0.0;
4430
4431 qgb = pParam->BSIM4cgbo * vgb;
4432 qgate += qgdo + qgso + qgb;
4433 qbulk -= qgb;
4434 qdrn = -(qgate + qbulk + qsrc);
4435 }
4436 gcddb = (here->BSIM4capbd + cgdo - (here->BSIM4cgsb
4437 + here->BSIM4cbsb + here->BSIM4cdsb)) * ag0;
4438 gcdsb = -(here->BSIM4cgdb + here->BSIM4cbdb
4439 + here->BSIM4cddb) * ag0;
4440
4441 gcsdb = here->BSIM4cdsb * ag0;
4442 gcssb = (here->BSIM4cddb + here->BSIM4capbs + cgso) * ag0;
4443
4444 if (!here->BSIM4rbodyMod)
4445 { gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb);
4446 gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb);
4447 gcbdb = (here->BSIM4cbsb - here->BSIM4capbd) * ag0;
4448 gcbsb = (here->BSIM4cbdb - here->BSIM4capbs) * ag0;
4449 gcdbdb = 0.0; gcsbsb = 0.0;
4450 }
4451 else
4452 { gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb)
4453 + here->BSIM4capbd * ag0;
4454 gcsbb = -(here->BSIM4cddb + here->BSIM4cdgb
4455 + here->BSIM4cdsb) * ag0;
4456 gcbdb = here->BSIM4cbsb * ag0;
4457 gcbsb = here->BSIM4cbdb * ag0;
4458 gcdbdb = -here->BSIM4capbd * ag0;
4459 gcsbsb = -here->BSIM4capbs * ag0;
4460 }
4461 gcbbb = -(gcbgb + gcbdb + gcbsb + gcbgmb);
4462
4463 ggtg = ggtd = ggtb = ggts = 0.0;
4464 sxpart = 0.4;
4465 dxpart = 0.6;
4466 ddxpart_dVd = ddxpart_dVg = ddxpart_dVb = ddxpart_dVs = 0.0;
4467 dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0;
4468 }
4469 else
4470 { qcheq = here->BSIM4qchqs;
4471 CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV * here->BSIM4nf
4472 * pParam->BSIM4leffCV;
4473 T0 = qdef * ScalingFactor / CoxWL;
4474 ggtg = here->BSIM4gtg = T0 * here->BSIM4gcrgg;
4475 ggts = here->BSIM4gts = T0 * here->BSIM4gcrgd;
4476 ggtd = here->BSIM4gtd = T0 * here->BSIM4gcrgs;
4477 ggtb = here->BSIM4gtb = T0 * here->BSIM4gcrgb;
4478 gqdef = ScalingFactor * ag0;
4479
4480 gcqgb = here->BSIM4cqgb * ag0;
4481 gcqdb = here->BSIM4cqsb * ag0;
4482 gcqsb = here->BSIM4cqdb * ag0;
4483 gcqbb = here->BSIM4cqbb * ag0;
4484
4485 if (fabs(qcheq) <= 1.0e-5 * CoxWL)
4486 { if (model->BSIM4xpart < 0.5)
4487 { sxpart = 0.4;
4488 }
4489 else if (model->BSIM4xpart > 0.5)
4490 { sxpart = 0.0;
4491 }
4492 else
4493 { sxpart = 0.5;
4494 }
4495 dsxpart_dVd = dsxpart_dVg = dsxpart_dVb
4496 = dsxpart_dVs = 0.0;
4497 }
4498 else
4499 { sxpart = qdrn / qcheq;
4500 Css = here->BSIM4cddb;
4501 Cds = -(here->BSIM4cgdb + here->BSIM4cddb
4502 + here->BSIM4cbdb);
4503 dsxpart_dVs = (Css - sxpart * (Css + Cds)) / qcheq;
4504 Csg = here->BSIM4cdgb;
4505 Cdg = -(here->BSIM4cggb + here->BSIM4cdgb
4506 + here->BSIM4cbgb);
4507 dsxpart_dVg = (Csg - sxpart * (Csg + Cdg)) / qcheq;
4508
4509 Csd = here->BSIM4cdsb;
4510 Cdd = -(here->BSIM4cgsb + here->BSIM4cdsb
4511 + here->BSIM4cbsb);
4512 dsxpart_dVd = (Csd - sxpart * (Csd + Cdd)) / qcheq;
4513
4514 dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg + dsxpart_dVs);
4515 }
4516 dxpart = 1.0 - sxpart;
4517 ddxpart_dVd = -dsxpart_dVd;
4518 ddxpart_dVg = -dsxpart_dVg;
4519 ddxpart_dVs = -dsxpart_dVs;
4520 ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs);
4521
4522 if (here->BSIM4rgateMod == 3)
4523 { gcgmgmb = (cgdo + cgso + pParam->BSIM4cgbo) * ag0;
4524 gcgmdb = -cgdo * ag0;
4525 gcgmsb = -cgso * ag0;
4526 gcgmbb = -pParam->BSIM4cgbo * ag0;
4527
4528 gcdgmb = gcgmdb;
4529 gcsgmb = gcgmsb;
4530 gcbgmb = gcgmbb;
4531
4532 gcdgb = gcsgb = gcbgb = 0.0;
4533 gcggb = gcgdb = gcgsb = gcgbb = 0.0;
4534
4535 qgmb = pParam->BSIM4cgbo * vgmb;
4536 qgmid = qgdo + qgso + qgmb;
4537 qgate = 0.0;
4538 qbulk = -qgmb;
4539 qdrn = -qgdo;
4540 qsrc = -qgso;
4541 }
4542 else
4543 { gcggb = (cgdo + cgso + pParam->BSIM4cgbo ) * ag0;
4544 gcgdb = -cgdo * ag0;
4545 gcgsb = -cgso * ag0;
4546 gcgbb = -pParam->BSIM4cgbo * ag0;
4547
4548 gcdgb = gcgdb;
4549 gcsgb = gcgsb;
4550 gcbgb = gcgbb;
4551 gcdgmb = gcsgmb = gcbgmb = 0.0;
4552
4553 qgb = pParam->BSIM4cgbo * vgb;
4554 qgate = qgdo + qgso + qgb;
4555 qbulk = -qgb;
4556 qdrn = -qgdo;
4557 qsrc = -qgso;
4558 }
4559
4560 gcddb = (here->BSIM4capbd + cgdo) * ag0;
4561 gcdsb = gcsdb = 0.0;
4562 gcssb = (here->BSIM4capbs + cgso) * ag0;
4563 if (!here->BSIM4rbodyMod)
4564 { gcdbb = -(gcdgb + gcddb + gcdgmb);
4565 gcsbb = -(gcsgb + gcssb + gcsgmb);
4566 gcbdb = -here->BSIM4capbd * ag0;
4567 gcbsb = -here->BSIM4capbs * ag0;
4568 gcdbdb = 0.0; gcsbsb = 0.0;
4569 }
4570 else
4571 { gcdbb = gcsbb = gcbdb = gcbsb = 0.0;
4572 gcdbdb = -here->BSIM4capbd * ag0;
4573 gcsbsb = -here->BSIM4capbs * ag0;
4574 }
4575 gcbbb = -(gcbdb + gcbgb + gcbsb + gcbgmb);
4576 }
4577 }
4578
4579
4580 if (here->BSIM4trnqsMod)
4581 { *(ckt->CKTstate0 + here->BSIM4qcdump) = qdef * ScalingFactor;
4582 if (ckt->CKTmode & MODEINITTRAN)
4583 *(ckt->CKTstate1 + here->BSIM4qcdump) =
4584 *(ckt->CKTstate0 + here->BSIM4qcdump);
4585 error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qcdump);
4586 if (error)
4587 return(error);
4588 }
4589
4590 if (ByPass) goto line860;
4591
4592 *(ckt->CKTstate0 + here->BSIM4qg) = qgate;
4593 *(ckt->CKTstate0 + here->BSIM4qd) = qdrn
4594 - *(ckt->CKTstate0 + here->BSIM4qbd);
4595 *(ckt->CKTstate0 + here->BSIM4qs) = qsrc
4596 - *(ckt->CKTstate0 + here->BSIM4qbs);
4597 if (here->BSIM4rgateMod == 3)
4598 *(ckt->CKTstate0 + here->BSIM4qgmid) = qgmid;
4599
4600 if (!here->BSIM4rbodyMod)
4601 { *(ckt->CKTstate0 + here->BSIM4qb) = qbulk
4602 + *(ckt->CKTstate0 + here->BSIM4qbd)
4603 + *(ckt->CKTstate0 + here->BSIM4qbs);
4604 }
4605 else
4606 *(ckt->CKTstate0 + here->BSIM4qb) = qbulk;
4607
4608
4609 /* Store small signal parameters */
4610 if (ckt->CKTmode & MODEINITSMSIG)
4611 { goto line1000;
4612 }
4613
4614 if (!ChargeComputationNeeded)
4615 goto line850;
4616
4617 if (ckt->CKTmode & MODEINITTRAN)
4618 { *(ckt->CKTstate1 + here->BSIM4qb) =
4619 *(ckt->CKTstate0 + here->BSIM4qb);
4620 *(ckt->CKTstate1 + here->BSIM4qg) =
4621 *(ckt->CKTstate0 + here->BSIM4qg);
4622 *(ckt->CKTstate1 + here->BSIM4qd) =
4623 *(ckt->CKTstate0 + here->BSIM4qd);
4624 if (here->BSIM4rgateMod == 3)
4625 *(ckt->CKTstate1 + here->BSIM4qgmid) =
4626 *(ckt->CKTstate0 + here->BSIM4qgmid);
4627 if (here->BSIM4rbodyMod)
4628 { *(ckt->CKTstate1 + here->BSIM4qbs) =
4629 *(ckt->CKTstate0 + here->BSIM4qbs);
4630 *(ckt->CKTstate1 + here->BSIM4qbd) =
4631 *(ckt->CKTstate0 + here->BSIM4qbd);
4632 }
4633 }
4634
4635 error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qb);
4636 if (error)
4637 return(error);
4638 error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qg);
4639 if (error)
4640 return(error);
4641 error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qd);
4642 if (error)
4643 return(error);
4644
4645 if (here->BSIM4rgateMod == 3)
4646 { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qgmid);
4647 if (error) return(error);
4648 }
4649
4650 if (here->BSIM4rbodyMod)
4651 { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qbs);
4652 if (error)
4653 return(error);
4654 error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qbd);
4655 if (error)
4656 return(error);
4657 }
4658
4659 goto line860;
4660
4661
4662 line850:
4663 /* Zero gcap and ceqcap if (!ChargeComputationNeeded) */
4664 ceqqg = ceqqb = ceqqd = 0.0;
4665 ceqqjd = ceqqjs = 0.0;
4666 cqcheq = cqdef = 0.0;
4667
4668 gcdgb = gcddb = gcdsb = gcdbb = 0.0;
4669 gcsgb = gcsdb = gcssb = gcsbb = 0.0;
4670 gcggb = gcgdb = gcgsb = gcgbb = 0.0;
4671 gcbdb = gcbgb = gcbsb = gcbbb = 0.0;
4672
4673 gcgmgmb = gcgmdb = gcgmsb = gcgmbb = 0.0;
4674 gcdgmb = gcsgmb = gcbgmb = ceqqgmid = 0.0;
4675 gcdbdb = gcsbsb = 0.0;
4676
4677 gqdef = gcqgb = gcqdb = gcqsb = gcqbb = 0.0;
4678 ggtg = ggtd = ggtb = ggts = 0.0;
4679 sxpart = (1.0 - (dxpart = (here->BSIM4mode > 0) ? 0.4 : 0.6));
4680 ddxpart_dVd = ddxpart_dVg = ddxpart_dVb = ddxpart_dVs = 0.0;
4681 dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0;
4682
4683 if (here->BSIM4trnqsMod)
4684 { CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV * here->BSIM4nf
4685 * pParam->BSIM4leffCV;
4686 T1 = here->BSIM4gcrg / CoxWL;
4687 here->BSIM4gtau = T1 * ScalingFactor;
4688 }
4689 else
4690 here->BSIM4gtau = 0.0;
4691
4692 goto line900;
4693
4694
4695 line860:
4696 /* Calculate equivalent charge current */
4697
4698 cqgate = *(ckt->CKTstate0 + here->BSIM4cqg);
4699 cqbody = *(ckt->CKTstate0 + here->BSIM4cqb);
4700 cqdrn = *(ckt->CKTstate0 + here->BSIM4cqd);
4701
4702 ceqqg = cqgate - gcggb * vgb + gcgdb * vbd + gcgsb * vbs;
4703 ceqqd = cqdrn - gcdgb * vgb - gcdgmb * vgmb + (gcddb + gcdbdb)
4704 * vbd - gcdbdb * vbd_jct + gcdsb * vbs;
4705 ceqqb = cqbody - gcbgb * vgb - gcbgmb * vgmb
4706 + gcbdb * vbd + gcbsb * vbs;
4707
4708
4709 if (here->BSIM4rgateMod == 3)
4710 ceqqgmid = *(ckt->CKTstate0 + here->BSIM4cqgmid)
4711 + gcgmdb * vbd + gcgmsb * vbs - gcgmgmb * vgmb;
4712 else
4713 ceqqgmid = 0.0;
4714
4715 if (here->BSIM4rbodyMod)
4716 { ceqqjs = *(ckt->CKTstate0 + here->BSIM4cqbs) + gcsbsb * vbs_jct;
4717 ceqqjd = *(ckt->CKTstate0 + here->BSIM4cqbd) + gcdbdb * vbd_jct;
4718 }
4719
4720 if (here->BSIM4trnqsMod)
4721 { T0 = ggtg * vgb - ggtd * vbd - ggts * vbs;
4722 ceqqg += T0;
4723 T1 = qdef * here->BSIM4gtau;
4724 ceqqd -= dxpart * T0 + T1 * (ddxpart_dVg * vgb - ddxpart_dVd
4725 * vbd - ddxpart_dVs * vbs);
4726 cqdef = *(ckt->CKTstate0 + here->BSIM4cqcdump) - gqdef * qdef;
4727 cqcheq = *(ckt->CKTstate0 + here->BSIM4cqcheq)
4728 - (gcqgb * vgb - gcqdb * vbd - gcqsb * vbs) + T0;
4729 }
4730
4731 if (ckt->CKTmode & MODEINITTRAN)
4732 { *(ckt->CKTstate1 + here->BSIM4cqb) =
4733 *(ckt->CKTstate0 + here->BSIM4cqb);
4734 *(ckt->CKTstate1 + here->BSIM4cqg) =
4735 *(ckt->CKTstate0 + here->BSIM4cqg);
4736 *(ckt->CKTstate1 + here->BSIM4cqd) =
4737 *(ckt->CKTstate0 + here->BSIM4cqd);
4738
4739 if (here->BSIM4rgateMod == 3)
4740 *(ckt->CKTstate1 + here->BSIM4cqgmid) =
4741 *(ckt->CKTstate0 + here->BSIM4cqgmid);
4742
4743 if (here->BSIM4rbodyMod)
4744 { *(ckt->CKTstate1 + here->BSIM4cqbs) =
4745 *(ckt->CKTstate0 + here->BSIM4cqbs);
4746 *(ckt->CKTstate1 + here->BSIM4cqbd) =
4747 *(ckt->CKTstate0 + here->BSIM4cqbd);
4748 }
4749 }
4750
4751
4752 /*
4753 * Load current vector
4754 */
4755
4756 line900:
4757 if (here->BSIM4mode >= 0)
4758 { Gm = here->BSIM4gm;
4759 Gmbs = here->BSIM4gmbs;
4760 FwdSum = Gm + Gmbs;
4761 RevSum = 0.0;
4762
4763 ceqdrn = model->BSIM4type * (cdrain - here->BSIM4gds * vds
4764 - Gm * vgs - Gmbs * vbs);
4765 ceqbd = model->BSIM4type * (here->BSIM4csub + here->BSIM4Igidl
4766 - (here->BSIM4gbds + here->BSIM4ggidld) * vds
4767 - (here->BSIM4gbgs + here->BSIM4ggidlg) * vgs
4768 - (here->BSIM4gbbs + here->BSIM4ggidlb) * vbs);
4769 ceqbs = model->BSIM4type * (here->BSIM4Igisl + here->BSIM4ggisls * vds
4770 - here->BSIM4ggislg * vgd - here->BSIM4ggislb * vbd);
4771
4772 gbbdp = -(here->BSIM4gbds);
4773 gbbsp = here->BSIM4gbds + here->BSIM4gbgs + here->BSIM4gbbs;
4774
4775 gbdpg = here->BSIM4gbgs;
4776 gbdpdp = here->BSIM4gbds;
4777 gbdpb = here->BSIM4gbbs;
4778 gbdpsp = -(gbdpg + gbdpdp + gbdpb);
4779
4780 gbspg = 0.0;
4781 gbspdp = 0.0;
4782 gbspb = 0.0;
4783 gbspsp = 0.0;
4784
4785 if (model->BSIM4igcMod)
4786 { gIstotg = here->BSIM4gIgsg + here->BSIM4gIgcsg;
4787 gIstotd = here->BSIM4gIgcsd;
4788 gIstots = here->BSIM4gIgss + here->BSIM4gIgcss;
4789 gIstotb = here->BSIM4gIgcsb;
4790 Istoteq = model->BSIM4type * (here->BSIM4Igs + here->BSIM4Igcs
4791 - gIstotg * vgs - here->BSIM4gIgcsd * vds
4792 - here->BSIM4gIgcsb * vbs);
4793
4794 gIdtotg = here->BSIM4gIgdg + here->BSIM4gIgcdg;
4795 gIdtotd = here->BSIM4gIgdd + here->BSIM4gIgcdd;
4796 gIdtots = here->BSIM4gIgcds;
4797 gIdtotb = here->BSIM4gIgcdb;
4798 Idtoteq = model->BSIM4type * (here->BSIM4Igd + here->BSIM4Igcd
4799 - here->BSIM4gIgdg * vgd - here->BSIM4gIgcdg * vgs
4800 - here->BSIM4gIgcdd * vds - here->BSIM4gIgcdb * vbs);
4801 }
4802 else
4803 { gIstotg = gIstotd = gIstots = gIstotb = Istoteq = 0.0;
4804 gIdtotg = gIdtotd = gIdtots = gIdtotb = Idtoteq = 0.0;
4805 }
4806
4807 if (model->BSIM4igbMod)
4808 { gIbtotg = here->BSIM4gIgbg;
4809 gIbtotd = here->BSIM4gIgbd;
4810 gIbtots = here->BSIM4gIgbs;
4811 gIbtotb = here->BSIM4gIgbb;
4812 Ibtoteq = model->BSIM4type * (here->BSIM4Igb
4813 - here->BSIM4gIgbg * vgs - here->BSIM4gIgbd * vds
4814 - here->BSIM4gIgbb * vbs);
4815 }
4816 else
4817 gIbtotg = gIbtotd = gIbtots = gIbtotb = Ibtoteq = 0.0;
4818
4819 if ((model->BSIM4igcMod != 0) || (model->BSIM4igbMod != 0))
4820 { gIgtotg = gIstotg + gIdtotg + gIbtotg;
4821 gIgtotd = gIstotd + gIdtotd + gIbtotd ;
4822 gIgtots = gIstots + gIdtots + gIbtots;
4823 gIgtotb = gIstotb + gIdtotb + gIbtotb;
4824 Igtoteq = Istoteq + Idtoteq + Ibtoteq;
4825 }
4826 else
4827 gIgtotg = gIgtotd = gIgtots = gIgtotb = Igtoteq = 0.0;
4828
4829
4830 if (here->BSIM4rgateMod == 2)
4831 T0 = vges - vgs;
4832 else if (here->BSIM4rgateMod == 3)
4833 T0 = vgms - vgs;
4834 if (here->BSIM4rgateMod > 1)
4835 { gcrgd = here->BSIM4gcrgd * T0;
4836 gcrgg = here->BSIM4gcrgg * T0;
4837 gcrgs = here->BSIM4gcrgs * T0;
4838 gcrgb = here->BSIM4gcrgb * T0;
4839 ceqgcrg = -(gcrgd * vds + gcrgg * vgs
4840 + gcrgb * vbs);
4841 gcrgg -= here->BSIM4gcrg;
4842 gcrg = here->BSIM4gcrg;
4843 }
4844 else
4845 ceqgcrg = gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0;
4846 }
4847 else
4848 { Gm = -here->BSIM4gm;
4849 Gmbs = -here->BSIM4gmbs;
4850 FwdSum = 0.0;
4851 RevSum = -(Gm + Gmbs);
4852
4853 ceqdrn = -model->BSIM4type * (cdrain + here->BSIM4gds * vds
4854 + Gm * vgd + Gmbs * vbd);
4855
4856 ceqbs = model->BSIM4type * (here->BSIM4csub + here->BSIM4Igisl
4857 + (here->BSIM4gbds + here->BSIM4ggisls) * vds
4858 - (here->BSIM4gbgs + here->BSIM4ggislg) * vgd
4859 - (here->BSIM4gbbs + here->BSIM4ggislb) * vbd);
4860 ceqbd = model->BSIM4type * (here->BSIM4Igidl - here->BSIM4ggidld * vds
4861 - here->BSIM4ggidlg * vgs - here->BSIM4ggidlb * vbs);
4862
4863 gbbsp = -(here->BSIM4gbds);
4864 gbbdp = here->BSIM4gbds + here->BSIM4gbgs + here->BSIM4gbbs;
4865
4866 gbdpg = 0.0;
4867 gbdpsp = 0.0;
4868 gbdpb = 0.0;
4869 gbdpdp = 0.0;
4870
4871 gbspg = here->BSIM4gbgs;
4872 gbspsp = here->BSIM4gbds;
4873 gbspb = here->BSIM4gbbs;
4874 gbspdp = -(gbspg + gbspsp + gbspb);
4875
4876 if (model->BSIM4igcMod)
4877 { gIstotg = here->BSIM4gIgsg + here->BSIM4gIgcdg;
4878 gIstotd = here->BSIM4gIgcds;
4879 gIstots = here->BSIM4gIgss + here->BSIM4gIgcdd;
4880 gIstotb = here->BSIM4gIgcdb;
4881 Istoteq = model->BSIM4type * (here->BSIM4Igs + here->BSIM4Igcd
4882 - here->BSIM4gIgsg * vgs - here->BSIM4gIgcdg * vgd
4883 + here->BSIM4gIgcdd * vds - here->BSIM4gIgcdb * vbd);
4884
4885 gIdtotg = here->BSIM4gIgdg + here->BSIM4gIgcsg;
4886 gIdtotd = here->BSIM4gIgdd + here->BSIM4gIgcss;
4887 gIdtots = here->BSIM4gIgcsd;
4888 gIdtotb = here->BSIM4gIgcsb;
4889 Idtoteq = model->BSIM4type * (here->BSIM4Igd + here->BSIM4Igcs
4890 - (here->BSIM4gIgdg + here->BSIM4gIgcsg) * vgd
4891 + here->BSIM4gIgcsd * vds - here->BSIM4gIgcsb * vbd);
4892 }
4893 else
4894 { gIstotg = gIstotd = gIstots = gIstotb = Istoteq = 0.0;
4895 gIdtotg = gIdtotd = gIdtots = gIdtotb = Idtoteq = 0.0;
4896 }
4897
4898 if (model->BSIM4igbMod)
4899 { gIbtotg = here->BSIM4gIgbg;
4900 gIbtotd = here->BSIM4gIgbs;
4901 gIbtots = here->BSIM4gIgbd;
4902 gIbtotb = here->BSIM4gIgbb;
4903 Ibtoteq = model->BSIM4type * (here->BSIM4Igb
4904 - here->BSIM4gIgbg * vgd + here->BSIM4gIgbd * vds
4905 - here->BSIM4gIgbb * vbd);
4906 }
4907 else
4908 gIbtotg = gIbtotd = gIbtots = gIbtotb = Ibtoteq = 0.0;
4909
4910 if ((model->BSIM4igcMod != 0) || (model->BSIM4igbMod != 0))
4911 { gIgtotg = gIstotg + gIdtotg + gIbtotg;
4912 gIgtotd = gIstotd + gIdtotd + gIbtotd ;
4913 gIgtots = gIstots + gIdtots + gIbtots;
4914 gIgtotb = gIstotb + gIdtotb + gIbtotb;
4915 Igtoteq = Istoteq + Idtoteq + Ibtoteq;
4916 }
4917 else
4918 gIgtotg = gIgtotd = gIgtots = gIgtotb = Igtoteq = 0.0;
4919
4920
4921 if (here->BSIM4rgateMod == 2)
4922 T0 = vges - vgs;
4923 else if (here->BSIM4rgateMod == 3)
4924 T0 = vgms - vgs;
4925 if (here->BSIM4rgateMod > 1)
4926 { gcrgd = here->BSIM4gcrgs * T0;
4927 gcrgg = here->BSIM4gcrgg * T0;
4928 gcrgs = here->BSIM4gcrgd * T0;
4929 gcrgb = here->BSIM4gcrgb * T0;
4930 ceqgcrg = -(gcrgg * vgd - gcrgs * vds
4931 + gcrgb * vbd);
4932 gcrgg -= here->BSIM4gcrg;
4933 gcrg = here->BSIM4gcrg;
4934 }
4935 else
4936 ceqgcrg = gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0;
4937 }
4938
4939 if (model->BSIM4rdsMod == 1)
4940 { ceqgstot = model->BSIM4type * (here->BSIM4gstotd * vds
4941 + here->BSIM4gstotg * vgs + here->BSIM4gstotb * vbs);
4942 /* WDLiu: ceqgstot flowing away from sNodePrime */
4943 gstot = here->BSIM4gstot;
4944 gstotd = here->BSIM4gstotd;
4945 gstotg = here->BSIM4gstotg;
4946 gstots = here->BSIM4gstots - gstot;
4947 gstotb = here->BSIM4gstotb;
4948
4949 ceqgdtot = -model->BSIM4type * (here->BSIM4gdtotd * vds
4950 + here->BSIM4gdtotg * vgs + here->BSIM4gdtotb * vbs);
4951 /* WDLiu: ceqgdtot defined as flowing into dNodePrime */
4952 gdtot = here->BSIM4gdtot;
4953 gdtotd = here->BSIM4gdtotd - gdtot;
4954 gdtotg = here->BSIM4gdtotg;
4955 gdtots = here->BSIM4gdtots;
4956 gdtotb = here->BSIM4gdtotb;
4957 }
4958 else
4959 { gstot = gstotd = gstotg = gstots = gstotb = ceqgstot = 0.0;
4960 gdtot = gdtotd = gdtotg = gdtots = gdtotb = ceqgdtot = 0.0;
4961 }
4962
4963 if (model->BSIM4type > 0)
4964 { ceqjs = (here->BSIM4cbs - here->BSIM4gbs * vbs_jct);
4965 ceqjd = (here->BSIM4cbd - here->BSIM4gbd * vbd_jct);
4966 }
4967 else
4968 { ceqjs = -(here->BSIM4cbs - here->BSIM4gbs * vbs_jct);
4969 ceqjd = -(here->BSIM4cbd - here->BSIM4gbd * vbd_jct);
4970 ceqqg = -ceqqg;
4971 ceqqd = -ceqqd;
4972 ceqqb = -ceqqb;
4973 ceqgcrg = -ceqgcrg;
4974
4975 if (here->BSIM4trnqsMod)
4976 { cqdef = -cqdef;
4977 cqcheq = -cqcheq;
4978 }
4979
4980 if (here->BSIM4rbodyMod)
4981 { ceqqjs = -ceqqjs;
4982 ceqqjd = -ceqqjd;
4983 }
4984
4985 if (here->BSIM4rgateMod == 3)
4986 ceqqgmid = -ceqqgmid;
4987 }
4988
4989
4990 /*
4991 * Loading RHS
4992 */
4993
4994 m = here->BSIM4m;
4995
4996 #ifdef USE_OMP
4997 here->BSIM4rhsdPrime = m * (ceqjd - ceqbd + ceqgdtot
4998 - ceqdrn - ceqqd + Idtoteq);
4999 here->BSIM4rhsgPrime = m * (ceqqg - ceqgcrg + Igtoteq);
5000
5001 if (here->BSIM4rgateMod == 2)
5002 here->BSIM4rhsgExt = m * ceqgcrg;
5003 else if (here->BSIM4rgateMod == 3)
5004 here->BSIM4grhsMid = m * (ceqqgmid + ceqgcrg);
5005
5006 if (!here->BSIM4rbodyMod)
5007 { here->BSIM4rhsbPrime = m * (ceqbd + ceqbs - ceqjd
5008 - ceqjs - ceqqb + Ibtoteq);
5009 here->BSIM4rhssPrime = m * (ceqdrn - ceqbs + ceqjs
5010 + ceqqg + ceqqb + ceqqd + ceqqgmid - ceqgstot + Istoteq);
5011 }
5012 else
5013 { here->BSIM4rhsdb = m * (ceqjd + ceqqjd);
5014 here->BSIM4rhsbPrime = m * (ceqbd + ceqbs - ceqqb + Ibtoteq);
5015 here->BSIM4rhssb = m * (ceqjs + ceqqjs);
5016 here->BSIM4rhssPrime = m * (ceqdrn - ceqbs + ceqjs + ceqqd
5017 + ceqqg + ceqqb + ceqqjd + ceqqjs + ceqqgmid - ceqgstot + Istoteq);
5018 }
5019
5020 if (model->BSIM4rdsMod)
5021 { here->BSIM4rhsd = m * ceqgdtot;
5022 here->BSIM4rhss = m * ceqgstot;
5023 }
5024
5025 if (here->BSIM4trnqsMod)
5026 here->BSIM4rhsq = m * (cqcheq - cqdef);
5027 #else
5028 (*(ckt->CKTrhs + here->BSIM4dNodePrime) += m * (ceqjd - ceqbd + ceqgdtot
5029 - ceqdrn - ceqqd + Idtoteq));
5030 (*(ckt->CKTrhs + here->BSIM4gNodePrime) -= m * (ceqqg - ceqgcrg + Igtoteq));
5031
5032 if (here->BSIM4rgateMod == 2)
5033 (*(ckt->CKTrhs + here->BSIM4gNodeExt) -= m * ceqgcrg);
5034 else if (here->BSIM4rgateMod == 3)
5035 (*(ckt->CKTrhs + here->BSIM4gNodeMid) -= m * (ceqqgmid + ceqgcrg));
5036
5037 if (!here->BSIM4rbodyMod)
5038 { (*(ckt->CKTrhs + here->BSIM4bNodePrime) += m * (ceqbd + ceqbs - ceqjd
5039 - ceqjs - ceqqb + Ibtoteq));
5040 (*(ckt->CKTrhs + here->BSIM4sNodePrime) += m * (ceqdrn - ceqbs + ceqjs
5041 + ceqqg + ceqqb + ceqqd + ceqqgmid - ceqgstot + Istoteq));
5042 }
5043
5044 else
5045 { (*(ckt->CKTrhs + here->BSIM4dbNode) -= m * (ceqjd + ceqqjd));
5046 (*(ckt->CKTrhs + here->BSIM4bNodePrime) += m * (ceqbd + ceqbs - ceqqb + Ibtoteq));
5047 (*(ckt->CKTrhs + here->BSIM4sbNode) -= m * (ceqjs + ceqqjs));
5048 (*(ckt->CKTrhs + here->BSIM4sNodePrime) += m * (ceqdrn - ceqbs + ceqjs + ceqqd
5049 + ceqqg + ceqqb + ceqqjd + ceqqjs + ceqqgmid - ceqgstot + Istoteq));
5050 }
5051
5052 if (model->BSIM4rdsMod)
5053 { (*(ckt->CKTrhs + here->BSIM4dNode) -= m * ceqgdtot);
5054 (*(ckt->CKTrhs + here->BSIM4sNode) += m * ceqgstot);
5055 }
5056
5057 if (here->BSIM4trnqsMod)
5058 *(ckt->CKTrhs + here->BSIM4qNode) += m * (cqcheq - cqdef);
5059 #endif
5060
5061 /*
5062 * Loading matrix
5063 */
5064
5065 if (!here->BSIM4rbodyMod)
5066 { gjbd = here->BSIM4gbd;
5067 gjbs = here->BSIM4gbs;
5068 }
5069 else
5070 gjbd = gjbs = 0.0;
5071
5072 if (!model->BSIM4rdsMod)
5073 { gdpr = here->BSIM4drainConductance;
5074 gspr = here->BSIM4sourceConductance;
5075 }
5076 else
5077 gdpr = gspr = 0.0;
5078
5079 geltd = here->BSIM4grgeltd;
5080
5081 T1 = qdef * here->BSIM4gtau;
5082 #ifdef USE_OMP
5083 if (here->BSIM4rgateMod == 1)
5084 { here->BSIM4_1 = m * geltd;
5085 here->BSIM4_2 = m * geltd;
5086 here->BSIM4_3 = m * geltd;
5087 here->BSIM4_4 = m * (gcggb + geltd - ggtg + gIgtotg);
5088 here->BSIM4_5 = m * (gcgdb - ggtd + gIgtotd);
5089 here->BSIM4_6 = m * (gcgsb - ggts + gIgtots);
5090 here->BSIM4_7 = m * (gcgbb - ggtb + gIgtotb);
5091 } /* WDLiu: gcrg already subtracted from all gcrgg below */
5092 else if (here->BSIM4rgateMod == 2)
5093 { here->BSIM4_8 = m * gcrg;
5094 here->BSIM4_9 = m * gcrgg;
5095 here->BSIM4_10 = m * gcrgd;
5096 here->BSIM4_11 = m * gcrgs;
5097 here->BSIM4_12 = m * gcrgb;
5098
5099 here->BSIM4_13 = m * gcrg;
5100 here->BSIM4_14 = m * (gcggb - gcrgg - ggtg + gIgtotg);
5101 here->BSIM4_15 = m * (gcgdb - gcrgd - ggtd + gIgtotd);
5102 here->BSIM4_16 = m * (gcgsb - gcrgs - ggts + gIgtots);
5103 here->BSIM4_17 = m * (gcgbb - gcrgb - ggtb + gIgtotb);
5104 }
5105 else if (here->BSIM4rgateMod == 3)
5106 { here->BSIM4_18 = m * geltd;
5107 here->BSIM4_19 = m * geltd;
5108 here->BSIM4_20 = m * geltd;
5109 here->BSIM4_21 = m * (geltd + gcrg + gcgmgmb);
5110
5111 here->BSIM4_22 = m * (gcrgd + gcgmdb);
5112 here->BSIM4_23 = m * gcrgg;
5113 here->BSIM4_24 = m * (gcrgs + gcgmsb);
5114 here->BSIM4_25 = m * (gcrgb + gcgmbb);
5115
5116 here->BSIM4_26 = m * gcdgmb;
5117 here->BSIM4_27 = m * gcrg;
5118 here->BSIM4_28 = m * gcsgmb;
5119 here->BSIM4_29 = m * gcbgmb;
5120
5121 here->BSIM4_30 = m * (gcggb - gcrgg - ggtg + gIgtotg);
5122 here->BSIM4_31 = m * (gcgdb - gcrgd - ggtd + gIgtotd);
5123 here->BSIM4_32 = m * (gcgsb - gcrgs - ggts + gIgtots);
5124 here->BSIM4_33 = m * (gcgbb - gcrgb - ggtb + gIgtotb);
5125 }
5126 else
5127 { here->BSIM4_34 = m * (gcggb - ggtg + gIgtotg);
5128 here->BSIM4_35 = m * (gcgdb - ggtd + gIgtotd);
5129 here->BSIM4_36 = m * (gcgsb - ggts + gIgtots);
5130 here->BSIM4_37 = m * (gcgbb - ggtb + gIgtotb);
5131 }
5132
5133 if (model->BSIM4rdsMod)
5134 { here->BSIM4_38 = m * gdtotg;
5135 here->BSIM4_39 = m * gdtots;
5136 here->BSIM4_40 = m * gdtotb;
5137 here->BSIM4_41 = m * gstotd;
5138 here->BSIM4_42 = m * gstotg;
5139 here->BSIM4_43 = m * gstotb;
5140 }
5141
5142 here->BSIM4_44 = m * (gdpr + here->BSIM4gds + here->BSIM4gbd + T1 * ddxpart_dVd
5143 - gdtotd + RevSum + gcddb + gbdpdp + dxpart * ggtd - gIdtotd);
5144 here->BSIM4_45 = m * (gdpr + gdtot);
5145 here->BSIM4_46 = m * (Gm + gcdgb - gdtotg + gbdpg - gIdtotg
5146 + dxpart * ggtg + T1 * ddxpart_dVg);
5147 here->BSIM4_47 = m * (here->BSIM4gds + gdtots - dxpart * ggts + gIdtots
5148 - T1 * ddxpart_dVs + FwdSum - gcdsb - gbdpsp);
5149 here->BSIM4_48 = m * (gjbd + gdtotb - Gmbs - gcdbb - gbdpb + gIdtotb
5150 - T1 * ddxpart_dVb - dxpart * ggtb);
5151
5152 here->BSIM4_49 = m * (gdpr - gdtotd);
5153 here->BSIM4_50 = m * (gdpr + gdtot);
5154
5155 here->BSIM4_51 = m * (here->BSIM4gds + gstotd + RevSum - gcsdb - gbspdp
5156 - T1 * dsxpart_dVd - sxpart * ggtd + gIstotd);
5157 here->BSIM4_52 = m * (gcsgb - Gm - gstotg + gbspg + sxpart * ggtg
5158 + T1 * dsxpart_dVg - gIstotg);
5159 here->BSIM4_53 = m * (gspr + here->BSIM4gds + here->BSIM4gbs + T1 * dsxpart_dVs
5160 - gstots + FwdSum + gcssb + gbspsp + sxpart * ggts - gIstots);
5161 here->BSIM4_54 = m * (gspr + gstot);
5162 here->BSIM4_55 = m * (gjbs + gstotb + Gmbs - gcsbb - gbspb - sxpart * ggtb
5163 - T1 * dsxpart_dVb + gIstotb);
5164
5165 here->BSIM4_56 = m * (gspr - gstots);
5166 here->BSIM4_57 = m * (gspr + gstot);
5167
5168 here->BSIM4_58 = m * (gcbdb - gjbd + gbbdp - gIbtotd);
5169 here->BSIM4_59 = m * (gcbgb - here->BSIM4gbgs - gIbtotg);
5170 here->BSIM4_60 = m * (gcbsb - gjbs + gbbsp - gIbtots);
5171 here->BSIM4_61 = m * (gjbd + gjbs + gcbbb - here->BSIM4gbbs - gIbtotb);
5172
5173 ggidld = here->BSIM4ggidld;
5174 ggidlg = here->BSIM4ggidlg;
5175 ggidlb = here->BSIM4ggidlb;
5176 ggislg = here->BSIM4ggislg;
5177 ggisls = here->BSIM4ggisls;
5178 ggislb = here->BSIM4ggislb;
5179
5180 /* stamp gidl */
5181 here->BSIM4_62 = m * ggidld;
5182 here->BSIM4_63 = m * ggidlg;
5183 here->BSIM4_64 = m * (ggidlg + ggidld + ggidlb);
5184 here->BSIM4_65 = m * ggidlb;
5185 here->BSIM4_66 = m * ggidld;
5186 here->BSIM4_67 = m * ggidlg;
5187 here->BSIM4_68 = m * (ggidlg + ggidld + ggidlb);
5188 here->BSIM4_69 = m * ggidlb;
5189 /* stamp gisl */
5190 here->BSIM4_70 = m * (ggisls + ggislg + ggislb);
5191 here->BSIM4_71 = m * ggislg;
5192 here->BSIM4_72 = m * ggisls;
5193 here->BSIM4_73 = m * ggislb;
5194 here->BSIM4_74 = m * (ggislg + ggisls + ggislb);
5195 here->BSIM4_75 = m * ggislg;
5196 here->BSIM4_76 = m * ggisls;
5197 here->BSIM4_77 = m * ggislb;
5198
5199 if (here->BSIM4rbodyMod)
5200 { here->BSIM4_78 = m * (gcdbdb - here->BSIM4gbd);
5201 here->BSIM4_79 = m * (here->BSIM4gbs - gcsbsb);
5202
5203 here->BSIM4_80 = m * (gcdbdb - here->BSIM4gbd);
5204 here->BSIM4_81 = m * (here->BSIM4gbd - gcdbdb
5205 + here->BSIM4grbpd + here->BSIM4grbdb);
5206 here->BSIM4_82 = m * here->BSIM4grbpd;
5207 here->BSIM4_83 = m * here->BSIM4grbdb;
5208
5209 here->BSIM4_84 = m * here->BSIM4grbpd;
5210 here->BSIM4_85 = m * here->BSIM4grbpb;
5211 here->BSIM4_86 = m * here->BSIM4grbps;
5212 here->BSIM4_87 = m * (here->BSIM4grbpd + here->BSIM4grbps
5213 + here->BSIM4grbpb);
5214 /* WDLiu: (gcbbb - here->BSIM4gbbs) already added to BPbpPtr */
5215
5216 here->BSIM4_88 = m * (gcsbsb - here->BSIM4gbs);
5217 here->BSIM4_89 = m * here->BSIM4grbps;
5218 here->BSIM4_90 = m * here->BSIM4grbsb;
5219 here->BSIM4_91 = m * (here->BSIM4gbs - gcsbsb
5220 + here->BSIM4grbps + here->BSIM4grbsb);
5221
5222 here->BSIM4_92 = m * here->BSIM4grbdb;
5223 here->BSIM4_93 = m * here->BSIM4grbpb;
5224 here->BSIM4_94 = m * here->BSIM4grbsb;
5225 here->BSIM4_95 = m * (here->BSIM4grbsb + here->BSIM4grbdb
5226 + here->BSIM4grbpb);
5227 }
5228
5229 if (here->BSIM4trnqsMod)
5230 { here->BSIM4_96 = m * (gqdef + here->BSIM4gtau);
5231 here->BSIM4_97 = m * (ggtg - gcqgb);
5232 here->BSIM4_98 = m * (ggtd - gcqdb);
5233 here->BSIM4_99 = m * (ggts - gcqsb);
5234 here->BSIM4_100 = m * (ggtb - gcqbb);
5235
5236 here->BSIM4_101 = m * dxpart * here->BSIM4gtau;
5237 here->BSIM4_102 = m * sxpart * here->BSIM4gtau;
5238 here->BSIM4_103 = m * here->BSIM4gtau;
5239 }
5240 #else
5241 if (here->BSIM4rgateMod == 1)
5242 { (*(here->BSIM4GEgePtr) += m * geltd);
5243 (*(here->BSIM4GPgePtr) -= m * geltd);
5244 (*(here->BSIM4GEgpPtr) -= m * geltd);
5245 (*(here->BSIM4GPgpPtr) += m * (gcggb + geltd - ggtg + gIgtotg));
5246 (*(here->BSIM4GPdpPtr) += m * (gcgdb - ggtd + gIgtotd));
5247 (*(here->BSIM4GPspPtr) += m * (gcgsb - ggts + gIgtots));
5248 (*(here->BSIM4GPbpPtr) += m * (gcgbb - ggtb + gIgtotb));
5249 } /* WDLiu: gcrg already subtracted from all gcrgg below */
5250 else if (here->BSIM4rgateMod == 2)
5251 { (*(here->BSIM4GEgePtr) += m * gcrg);
5252 (*(here->BSIM4GEgpPtr) += m * gcrgg);
5253 (*(here->BSIM4GEdpPtr) += m * gcrgd);
5254 (*(here->BSIM4GEspPtr) += m * gcrgs);
5255 (*(here->BSIM4GEbpPtr) += m * gcrgb);
5256
5257 (*(here->BSIM4GPgePtr) -= m * gcrg);
5258 (*(here->BSIM4GPgpPtr) += m * (gcggb - gcrgg - ggtg + gIgtotg));
5259 (*(here->BSIM4GPdpPtr) += m * (gcgdb - gcrgd - ggtd + gIgtotd));
5260 (*(here->BSIM4GPspPtr) += m * (gcgsb - gcrgs - ggts + gIgtots));
5261 (*(here->BSIM4GPbpPtr) += m * (gcgbb - gcrgb - ggtb + gIgtotb));
5262 }
5263 else if (here->BSIM4rgateMod == 3)
5264 { (*(here->BSIM4GEgePtr) += m * geltd);
5265 (*(here->BSIM4GEgmPtr) -= m * geltd);
5266 (*(here->BSIM4GMgePtr) -= m * geltd);
5267 (*(here->BSIM4GMgmPtr) += m * (geltd + gcrg + gcgmgmb));
5268
5269 (*(here->BSIM4GMdpPtr) += m * (gcrgd + gcgmdb));
5270 (*(here->BSIM4GMgpPtr) += m * gcrgg);
5271 (*(here->BSIM4GMspPtr) += m * (gcrgs + gcgmsb));
5272 (*(here->BSIM4GMbpPtr) += m * (gcrgb + gcgmbb));
5273
5274 (*(here->BSIM4DPgmPtr) += m * gcdgmb);
5275 (*(here->BSIM4GPgmPtr) -= m * gcrg);
5276 (*(here->BSIM4SPgmPtr) += m * gcsgmb);
5277 (*(here->BSIM4BPgmPtr) += m * gcbgmb);
5278
5279 (*(here->BSIM4GPgpPtr) += m * (gcggb - gcrgg - ggtg + gIgtotg));
5280 (*(here->BSIM4GPdpPtr) += m * (gcgdb - gcrgd - ggtd + gIgtotd));
5281 (*(here->BSIM4GPspPtr) += m * (gcgsb - gcrgs - ggts + gIgtots));
5282 (*(here->BSIM4GPbpPtr) += m * (gcgbb - gcrgb - ggtb + gIgtotb));
5283 }
5284 else
5285 { (*(here->BSIM4GPgpPtr) += m * (gcggb - ggtg + gIgtotg));
5286 (*(here->BSIM4GPdpPtr) += m * (gcgdb - ggtd + gIgtotd));
5287 (*(here->BSIM4GPspPtr) += m * (gcgsb - ggts + gIgtots));
5288 (*(here->BSIM4GPbpPtr) += m * (gcgbb - ggtb + gIgtotb));
5289 }
5290
5291 if (model->BSIM4rdsMod)
5292 { (*(here->BSIM4DgpPtr) += m * gdtotg);
5293 (*(here->BSIM4DspPtr) += m * gdtots);
5294 (*(here->BSIM4DbpPtr) += m * gdtotb);
5295 (*(here->BSIM4SdpPtr) += m * gstotd);
5296 (*(here->BSIM4SgpPtr) += m * gstotg);
5297 (*(here->BSIM4SbpPtr) += m * gstotb);
5298 }
5299
5300 (*(here->BSIM4DPdpPtr) += m * (gdpr + here->BSIM4gds + here->BSIM4gbd + T1 * ddxpart_dVd
5301 - gdtotd + RevSum + gcddb + gbdpdp + dxpart * ggtd - gIdtotd));
5302 (*(here->BSIM4DPdPtr) -= m * (gdpr + gdtot));
5303 (*(here->BSIM4DPgpPtr) += m * (Gm + gcdgb - gdtotg + gbdpg - gIdtotg
5304 + dxpart * ggtg + T1 * ddxpart_dVg));
5305 (*(here->BSIM4DPspPtr) -= m * (here->BSIM4gds + gdtots - dxpart * ggts + gIdtots
5306 - T1 * ddxpart_dVs + FwdSum - gcdsb - gbdpsp));
5307 (*(here->BSIM4DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gcdbb - gbdpb + gIdtotb
5308 - T1 * ddxpart_dVb - dxpart * ggtb));
5309
5310 (*(here->BSIM4DdpPtr) -= m * (gdpr - gdtotd));
5311 (*(here->BSIM4DdPtr) += m * (gdpr + gdtot));
5312
5313 (*(here->BSIM4SPdpPtr) -= m * (here->BSIM4gds + gstotd + RevSum - gcsdb - gbspdp
5314 - T1 * dsxpart_dVd - sxpart * ggtd + gIstotd));
5315 (*(here->BSIM4SPgpPtr) += m * (gcsgb - Gm - gstotg + gbspg + sxpart * ggtg
5316 + T1 * dsxpart_dVg - gIstotg));
5317 (*(here->BSIM4SPspPtr) += m * (gspr + here->BSIM4gds + here->BSIM4gbs + T1 * dsxpart_dVs
5318 - gstots + FwdSum + gcssb + gbspsp + sxpart * ggts - gIstots));
5319 (*(here->BSIM4SPsPtr) -= m * (gspr + gstot));
5320 (*(here->BSIM4SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gcsbb - gbspb - sxpart * ggtb
5321 - T1 * dsxpart_dVb + gIstotb));
5322
5323 (*(here->BSIM4SspPtr) -= m * (gspr - gstots));
5324 (*(here->BSIM4SsPtr) += m * (gspr + gstot));
5325
5326 (*(here->BSIM4BPdpPtr) += m * (gcbdb - gjbd + gbbdp - gIbtotd));
5327 (*(here->BSIM4BPgpPtr) += m * (gcbgb - here->BSIM4gbgs - gIbtotg));
5328 (*(here->BSIM4BPspPtr) += m * (gcbsb - gjbs + gbbsp - gIbtots));
5329 (*(here->BSIM4BPbpPtr) += m * (gjbd + gjbs + gcbbb - here->BSIM4gbbs
5330 - gIbtotb));
5331
5332 ggidld = here->BSIM4ggidld;
5333 ggidlg = here->BSIM4ggidlg;
5334 ggidlb = here->BSIM4ggidlb;
5335 ggislg = here->BSIM4ggislg;
5336 ggisls = here->BSIM4ggisls;
5337 ggislb = here->BSIM4ggislb;
5338
5339 /* stamp gidl */
5340 (*(here->BSIM4DPdpPtr) += m * ggidld);
5341 (*(here->BSIM4DPgpPtr) += m * ggidlg);
5342 (*(here->BSIM4DPspPtr) -= m * (ggidlg + ggidld + ggidlb));
5343 (*(here->BSIM4DPbpPtr) += m * ggidlb);
5344 (*(here->BSIM4BPdpPtr) -= m * ggidld);
5345 (*(here->BSIM4BPgpPtr) -= m * ggidlg);
5346 (*(here->BSIM4BPspPtr) += m * (ggidlg + ggidld + ggidlb));
5347 (*(here->BSIM4BPbpPtr) -= m * ggidlb);
5348 /* stamp gisl */
5349 (*(here->BSIM4SPdpPtr) -= m * (ggisls + ggislg + ggislb));
5350 (*(here->BSIM4SPgpPtr) += m * ggislg);
5351 (*(here->BSIM4SPspPtr) += m * ggisls);
5352 (*(here->BSIM4SPbpPtr) += m * ggislb);
5353 (*(here->BSIM4BPdpPtr) += m * (ggislg + ggisls + ggislb));
5354 (*(here->BSIM4BPgpPtr) -= m * ggislg);
5355 (*(here->BSIM4BPspPtr) -= m * ggisls);
5356 (*(here->BSIM4BPbpPtr) -= m * ggislb);
5357
5358
5359 if (here->BSIM4rbodyMod)
5360 { (*(here->BSIM4DPdbPtr) += m * (gcdbdb - here->BSIM4gbd));
5361 (*(here->BSIM4SPsbPtr) -= m * (here->BSIM4gbs - gcsbsb));
5362
5363 (*(here->BSIM4DBdpPtr) += m * (gcdbdb - here->BSIM4gbd));
5364 (*(here->BSIM4DBdbPtr) += m * (here->BSIM4gbd - gcdbdb
5365 + here->BSIM4grbpd + here->BSIM4grbdb));
5366 (*(here->BSIM4DBbpPtr) -= m * here->BSIM4grbpd);
5367 (*(here->BSIM4DBbPtr) -= m * here->BSIM4grbdb);
5368
5369 (*(here->BSIM4BPdbPtr) -= m * here->BSIM4grbpd);
5370 (*(here->BSIM4BPbPtr) -= m * here->BSIM4grbpb);
5371 (*(here->BSIM4BPsbPtr) -= m * here->BSIM4grbps);
5372 (*(here->BSIM4BPbpPtr) += m * (here->BSIM4grbpd + here->BSIM4grbps
5373 + here->BSIM4grbpb));
5374 /* WDLiu: (gcbbb - here->BSIM4gbbs) already added to BPbpPtr */
5375
5376 (*(here->BSIM4SBspPtr) += m * (gcsbsb - here->BSIM4gbs));
5377 (*(here->BSIM4SBbpPtr) -= m * here->BSIM4grbps);
5378 (*(here->BSIM4SBbPtr) -= m * here->BSIM4grbsb);
5379 (*(here->BSIM4SBsbPtr) += m * (here->BSIM4gbs - gcsbsb
5380 + here->BSIM4grbps + here->BSIM4grbsb));
5381
5382 (*(here->BSIM4BdbPtr) -= m * here->BSIM4grbdb);
5383 (*(here->BSIM4BbpPtr) -= m * here->BSIM4grbpb);
5384 (*(here->BSIM4BsbPtr) -= m * here->BSIM4grbsb);
5385 (*(here->BSIM4BbPtr) += m * (here->BSIM4grbsb + here->BSIM4grbdb
5386 + here->BSIM4grbpb));
5387 }
5388
5389 if (here->BSIM4trnqsMod)
5390 { (*(here->BSIM4QqPtr) += m * (gqdef + here->BSIM4gtau));
5391 (*(here->BSIM4QgpPtr) += m * (ggtg - gcqgb));
5392 (*(here->BSIM4QdpPtr) += m * (ggtd - gcqdb));
5393 (*(here->BSIM4QspPtr) += m * (ggts - gcqsb));
5394 (*(here->BSIM4QbpPtr) += m * (ggtb - gcqbb));
5395
5396 (*(here->BSIM4DPqPtr) += m * dxpart * here->BSIM4gtau);
5397 (*(here->BSIM4SPqPtr) += m * sxpart * here->BSIM4gtau);
5398 (*(here->BSIM4GPqPtr) -= m * here->BSIM4gtau);
5399 }
5400 #endif
5401
5402 line1000: ;
5403
5404 #ifndef USE_OMP
5405 } /* End of MOSFET Instance */
5406 } /* End of Model Instance */
5407 #endif
5408
5409 return(OK);
5410 }
5411
5412 /* function to compute poly depletion effect */
BSIM4polyDepletion(double phi,double ngate,double epsgate,double coxe,double Vgs,double * Vgs_eff,double * dVgs_eff_dVg)5413 int BSIM4polyDepletion(
5414 double phi,
5415 double ngate,
5416 double epsgate,
5417 double coxe,
5418 double Vgs,
5419 double *Vgs_eff,
5420 double *dVgs_eff_dVg)
5421 {
5422 double T1, T2, T3, T4, T5, T6, T7, T8;
5423
5424 /* Poly Gate Si Depletion Effect */
5425 if ((ngate > 1.0e18) &&
5426 (ngate < 1.0e25) && (Vgs > phi) && (epsgate!=0)
5427 ){
5428 T1 = 1.0e6 * CHARGE * epsgate * ngate / (coxe * coxe);
5429 T8 = Vgs - phi;
5430 T4 = sqrt(1.0 + 2.0 * T8 / T1);
5431 T2 = 2.0 * T8 / (T4 + 1.0);
5432 T3 = 0.5 * T2 * T2 / T1; /* T3 = Vpoly */
5433 T7 = 1.12 - T3 - 0.05;
5434 T6 = sqrt(T7 * T7 + 0.224);
5435 T5 = 1.12 - 0.5 * (T7 + T6);
5436 *Vgs_eff = Vgs - T5;
5437 *dVgs_eff_dVg = 1.0 - (0.5 - 0.5 / T4) * (1.0 + T7 / T6);
5438 }
5439 else {
5440 *Vgs_eff = Vgs;
5441 *dVgs_eff_dVg = 1.0;
5442 }
5443 return(0);
5444 }
5445
5446 #ifdef USE_OMP
BSIM4LoadRhsMat(GENmodel * inModel,CKTcircuit * ckt)5447 void BSIM4LoadRhsMat(GENmodel *inModel, CKTcircuit *ckt)
5448 {
5449 int InstCount, idx;
5450 BSIM4instance **InstArray;
5451 BSIM4instance *here;
5452 BSIM4model *model = (BSIM4model*)inModel;
5453
5454 InstArray = model->BSIM4InstanceArray;
5455 InstCount = model->BSIM4InstCount;
5456
5457 for(idx = 0; idx < InstCount; idx++) {
5458 here = InstArray[idx];
5459 model = BSIM4modPtr(here);
5460 /* Update b for Ax = b */
5461 (*(ckt->CKTrhs + here->BSIM4dNodePrime) += here->BSIM4rhsdPrime);
5462 (*(ckt->CKTrhs + here->BSIM4gNodePrime) -= here->BSIM4rhsgPrime);
5463
5464 if (here->BSIM4rgateMod == 2)
5465 (*(ckt->CKTrhs + here->BSIM4gNodeExt) -= here->BSIM4rhsgExt);
5466 else if (here->BSIM4rgateMod == 3)
5467 (*(ckt->CKTrhs + here->BSIM4gNodeMid) -= here->BSIM4grhsMid);
5468
5469 if (!here->BSIM4rbodyMod)
5470 { (*(ckt->CKTrhs + here->BSIM4bNodePrime) += here->BSIM4rhsbPrime);
5471 (*(ckt->CKTrhs + here->BSIM4sNodePrime) += here->BSIM4rhssPrime);
5472 }
5473 else
5474 { (*(ckt->CKTrhs + here->BSIM4dbNode) -= here->BSIM4rhsdb);
5475 (*(ckt->CKTrhs + here->BSIM4bNodePrime) += here->BSIM4rhsbPrime);
5476 (*(ckt->CKTrhs + here->BSIM4sbNode) -= here->BSIM4rhssb);
5477 (*(ckt->CKTrhs + here->BSIM4sNodePrime) += here->BSIM4rhssPrime);
5478 }
5479
5480 if (model->BSIM4rdsMod)
5481 { (*(ckt->CKTrhs + here->BSIM4dNode) -= here->BSIM4rhsd);
5482 (*(ckt->CKTrhs + here->BSIM4sNode) += here->BSIM4rhss);
5483 }
5484
5485 if (here->BSIM4trnqsMod)
5486 *(ckt->CKTrhs + here->BSIM4qNode) += here->BSIM4rhsq;
5487
5488
5489 /* Update A for Ax = b */
5490 if (here->BSIM4rgateMod == 1)
5491 { (*(here->BSIM4GEgePtr) += here->BSIM4_1);
5492 (*(here->BSIM4GPgePtr) -= here->BSIM4_2);
5493 (*(here->BSIM4GEgpPtr) -= here->BSIM4_3);
5494 (*(here->BSIM4GPgpPtr) += here->BSIM4_4);
5495 (*(here->BSIM4GPdpPtr) += here->BSIM4_5);
5496 (*(here->BSIM4GPspPtr) += here->BSIM4_6);
5497 (*(here->BSIM4GPbpPtr) += here->BSIM4_7);
5498 }
5499 else if (here->BSIM4rgateMod == 2)
5500 { (*(here->BSIM4GEgePtr) += here->BSIM4_8);
5501 (*(here->BSIM4GEgpPtr) += here->BSIM4_9);
5502 (*(here->BSIM4GEdpPtr) += here->BSIM4_10);
5503 (*(here->BSIM4GEspPtr) += here->BSIM4_11);
5504 (*(here->BSIM4GEbpPtr) += here->BSIM4_12);
5505
5506 (*(here->BSIM4GPgePtr) -= here->BSIM4_13);
5507 (*(here->BSIM4GPgpPtr) += here->BSIM4_14);
5508 (*(here->BSIM4GPdpPtr) += here->BSIM4_15);
5509 (*(here->BSIM4GPspPtr) += here->BSIM4_16);
5510 (*(here->BSIM4GPbpPtr) += here->BSIM4_17);
5511 }
5512 else if (here->BSIM4rgateMod == 3)
5513 { (*(here->BSIM4GEgePtr) += here->BSIM4_18);
5514 (*(here->BSIM4GEgmPtr) -= here->BSIM4_19);
5515 (*(here->BSIM4GMgePtr) -= here->BSIM4_20);
5516 (*(here->BSIM4GMgmPtr) += here->BSIM4_21);
5517
5518 (*(here->BSIM4GMdpPtr) += here->BSIM4_22);
5519 (*(here->BSIM4GMgpPtr) += here->BSIM4_23);
5520 (*(here->BSIM4GMspPtr) += here->BSIM4_24);
5521 (*(here->BSIM4GMbpPtr) += here->BSIM4_25);
5522
5523 (*(here->BSIM4DPgmPtr) += here->BSIM4_26);
5524 (*(here->BSIM4GPgmPtr) -= here->BSIM4_27);
5525 (*(here->BSIM4SPgmPtr) += here->BSIM4_28);
5526 (*(here->BSIM4BPgmPtr) += here->BSIM4_29);
5527
5528 (*(here->BSIM4GPgpPtr) += here->BSIM4_30);
5529 (*(here->BSIM4GPdpPtr) += here->BSIM4_31);
5530 (*(here->BSIM4GPspPtr) += here->BSIM4_32);
5531 (*(here->BSIM4GPbpPtr) += here->BSIM4_33);
5532 }
5533
5534
5535 else
5536 { (*(here->BSIM4GPgpPtr) += here->BSIM4_34);
5537 (*(here->BSIM4GPdpPtr) += here->BSIM4_35);
5538 (*(here->BSIM4GPspPtr) += here->BSIM4_36);
5539 (*(here->BSIM4GPbpPtr) += here->BSIM4_37);
5540 }
5541
5542
5543 if (model->BSIM4rdsMod)
5544 { (*(here->BSIM4DgpPtr) += here->BSIM4_38);
5545 (*(here->BSIM4DspPtr) += here->BSIM4_39);
5546 (*(here->BSIM4DbpPtr) += here->BSIM4_40);
5547 (*(here->BSIM4SdpPtr) += here->BSIM4_41);
5548 (*(here->BSIM4SgpPtr) += here->BSIM4_42);
5549 (*(here->BSIM4SbpPtr) += here->BSIM4_43);
5550 }
5551
5552 (*(here->BSIM4DPdpPtr) += here->BSIM4_44);
5553 (*(here->BSIM4DPdPtr) -= here->BSIM4_45);
5554 (*(here->BSIM4DPgpPtr) += here->BSIM4_46);
5555 (*(here->BSIM4DPspPtr) -= here->BSIM4_47);
5556 (*(here->BSIM4DPbpPtr) -= here->BSIM4_48);
5557
5558 (*(here->BSIM4DdpPtr) -= here->BSIM4_49);
5559 (*(here->BSIM4DdPtr) += here->BSIM4_50);
5560
5561 (*(here->BSIM4SPdpPtr) -= here->BSIM4_51);
5562 (*(here->BSIM4SPgpPtr) += here->BSIM4_52);
5563 (*(here->BSIM4SPspPtr) += here->BSIM4_53);
5564 (*(here->BSIM4SPsPtr) -= here->BSIM4_54);
5565 (*(here->BSIM4SPbpPtr) -= here->BSIM4_55);
5566
5567 (*(here->BSIM4SspPtr) -= here->BSIM4_56);
5568 (*(here->BSIM4SsPtr) += here->BSIM4_57);
5569
5570 (*(here->BSIM4BPdpPtr) += here->BSIM4_58);
5571 (*(here->BSIM4BPgpPtr) += here->BSIM4_59);
5572 (*(here->BSIM4BPspPtr) += here->BSIM4_60);
5573 (*(here->BSIM4BPbpPtr) += here->BSIM4_61);
5574
5575 /* stamp gidl */
5576 (*(here->BSIM4DPdpPtr) += here->BSIM4_62);
5577 (*(here->BSIM4DPgpPtr) += here->BSIM4_63);
5578 (*(here->BSIM4DPspPtr) -= here->BSIM4_64);
5579 (*(here->BSIM4DPbpPtr) += here->BSIM4_65);
5580 (*(here->BSIM4BPdpPtr) -= here->BSIM4_66);
5581 (*(here->BSIM4BPgpPtr) -= here->BSIM4_67);
5582 (*(here->BSIM4BPspPtr) += here->BSIM4_68);
5583 (*(here->BSIM4BPbpPtr) -= here->BSIM4_69);
5584 /* stamp gisl */
5585 (*(here->BSIM4SPdpPtr) -= here->BSIM4_70);
5586 (*(here->BSIM4SPgpPtr) += here->BSIM4_71);
5587 (*(here->BSIM4SPspPtr) += here->BSIM4_72);
5588 (*(here->BSIM4SPbpPtr) += here->BSIM4_73);
5589 (*(here->BSIM4BPdpPtr) += here->BSIM4_74);
5590 (*(here->BSIM4BPgpPtr) -= here->BSIM4_75);
5591 (*(here->BSIM4BPspPtr) -= here->BSIM4_76);
5592 (*(here->BSIM4BPbpPtr) -= here->BSIM4_77);
5593
5594
5595 if (here->BSIM4rbodyMod)
5596 { (*(here->BSIM4DPdbPtr) += here->BSIM4_78);
5597 (*(here->BSIM4SPsbPtr) -= here->BSIM4_79);
5598
5599 (*(here->BSIM4DBdpPtr) += here->BSIM4_80);
5600 (*(here->BSIM4DBdbPtr) += here->BSIM4_81);
5601 (*(here->BSIM4DBbpPtr) -= here->BSIM4_82);
5602 (*(here->BSIM4DBbPtr) -= here->BSIM4_83);
5603
5604 (*(here->BSIM4BPdbPtr) -= here->BSIM4_84);
5605 (*(here->BSIM4BPbPtr) -= here->BSIM4_85);
5606 (*(here->BSIM4BPsbPtr) -= here->BSIM4_86);
5607 (*(here->BSIM4BPbpPtr) += here->BSIM4_87);
5608
5609 (*(here->BSIM4SBspPtr) += here->BSIM4_88);
5610 (*(here->BSIM4SBbpPtr) -= here->BSIM4_89);
5611 (*(here->BSIM4SBbPtr) -= here->BSIM4_90);
5612 (*(here->BSIM4SBsbPtr) += here->BSIM4_91);
5613
5614 (*(here->BSIM4BdbPtr) -= here->BSIM4_92);
5615 (*(here->BSIM4BbpPtr) -= here->BSIM4_93);
5616 (*(here->BSIM4BsbPtr) -= here->BSIM4_94);
5617 (*(here->BSIM4BbPtr) += here->BSIM4_95);
5618 }
5619
5620 if (here->BSIM4trnqsMod)
5621 { (*(here->BSIM4QqPtr) += here->BSIM4_96);
5622 (*(here->BSIM4QgpPtr) += here->BSIM4_97);
5623 (*(here->BSIM4QdpPtr) += here->BSIM4_98);
5624 (*(here->BSIM4QspPtr) += here->BSIM4_99);
5625 (*(here->BSIM4QbpPtr) += here->BSIM4_100);
5626
5627 (*(here->BSIM4DPqPtr) += here->BSIM4_101);
5628 (*(here->BSIM4SPqPtr) += here->BSIM4_102);
5629 (*(here->BSIM4GPqPtr) -= here->BSIM4_103);
5630 }
5631 }
5632 }
5633
5634 #endif
5635