1 /*** B4SOI 12/16/2010 Released by Tanvir Morshed ***/
2
3
4 /**********
5 * Copyright 2010 Regents of the University of California. All rights reserved.
6 * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
7 * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soild.c
8 * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu.
9 * Authors: 2009- Wenwei Yang, Chung-Hsun Lin, Ali Niknejad, Chenming Hu.
10 * File: b4soild.c
11 * Modified by Hui Wan, Xuemei Xi 11/30/2005
12 * Modified by Wenwei Yang, Chung-Hsun Lin, Darsen Lu 03/06/2009
13 * Modified by Tanvir Morshed 09/22/2009
14 * Modified by Tanvir Morshed 12/31/2009
15 * Modified by Larry Wagner, Calvin Bittner, Geoffrey Coram, Tanvir Morshed 05/14/2010
16 * Modified by Larry Wagner, Calvin Bittner, 5 fixes. 08/04/2010
17 * Modified by Larry Wagner, Calvin Bittner, FD derivatives fixes. 08/25/2010
18 **********/
19
20 #include "ngspice/ngspice.h"
21
22 #include "ngspice/cktdefs.h"
23 #include "b4soidef.h"
24 #include "ngspice/trandefs.h"
25 #include "ngspice/const.h"
26 #include "ngspice/sperror.h"
27 #include "ngspice/devdefs.h"
28 #include "ngspice/suffix.h"
29
30 #define EPS0 8.85418e-12 /*4.1*/
31 #define EPSOX 3.453133e-11
32 #define EPSSI 1.03594e-10
33 #define Charge_q 1.60219e-19
34 #define KboQ 8.617087e-5 /* Kb / q */
35 #define Eg300 1.115 /* energy gap at 300K */
36 #define DELTA 1.0E-9 /* v4.0 */
37 #define DELTA_1 0.02
38 #define DELTA_2 0.02
39 #define DELTA_3 0.02
40 /* Original is 0.02, for matching IBM model, change to 0.08 */
41 #define DELTA_3_SOI 0.08
42 #define DELTA_4 0.02
43 #define DELT_Vbseff 0.005
44 #define DELTA_VFB 0.02
45 #define OFF_Vbsitf 0.02 /* v3.1*/
46 #define CONST_2OV3 0.6666666666
47
48 #define MAX_EXPL 2.688117142e+43
49 #define MIN_EXPL 3.720075976e-44
50 #define EXPL_THRESHOLD 100.0
51 #define DEXP(A,B,C) { \
52 if (A > EXPL_THRESHOLD) { \
53 B = MAX_EXPL*(1.0+(A)-EXPL_THRESHOLD); \
54 C = MAX_EXPL; \
55 } else if (A < -EXPL_THRESHOLD) { \
56 B = MIN_EXPL; \
57 C = 0; \
58 } else { \
59 B = exp(A); \
60 C = B; \
61 } \
62 }
63
64 #define FLOG(A) fabs(A) + 1e-14
65
66 #ifdef USE_OMP
67 int B4SOILoadOMP(B4SOIinstance *here, CKTcircuit *ckt);
68 void B4SOILoadRhsMat(GENmodel *inModel, CKTcircuit *ckt);
69 #endif
70
71 /* B4SOIlimit(vnew,vold)
72 * limits the per-iteration change of any absolute voltage value
73 */
74
75 static double
B4SOIlimit(double vnew,double vold,double limit,int * check)76 B4SOIlimit(
77 double vnew,
78 double vold,
79 double limit,
80 int *check)
81 {
82 double T0, T1;
83
84 if (isnan (vnew) || isnan (vold))
85 {
86 fprintf(stderr, "Alberto says: YOU TURKEY! The limiting function received NaN.\n");
87 fprintf(stderr, "New prediction returns to 0.0!\n");
88 vnew = 0.0;
89 *check = 1;
90 }
91 T0 = vnew - vold;
92 T1 = fabs(T0);
93 if (T1 > limit) {
94 if (T0 > 0.0)
95 vnew = vold + limit;
96 else
97 vnew = vold - limit;
98 *check = 1;
99 }
100 return vnew;
101 }
102
103
104 int
B4SOIload(GENmodel * inModel,CKTcircuit * ckt)105 B4SOIload(
106 GENmodel *inModel,
107 CKTcircuit *ckt)
108 {
109 #ifdef USE_OMP
110 int idx;
111 B4SOImodel *model = (B4SOImodel*)inModel;
112 int error = 0;
113 B4SOIinstance **InstArray;
114 InstArray = model->B4SOIInstanceArray;
115
116 #pragma omp parallel for
117 for (idx = 0; idx < model->B4SOIInstCount; idx++) {
118 B4SOIinstance *here = InstArray[idx];
119 int local_error = B4SOILoadOMP(here, ckt);
120 if (local_error)
121 error = local_error;
122 }
123
124 B4SOILoadRhsMat(inModel, ckt);
125
126 return error;
127 }
128
B4SOILoadOMP(B4SOIinstance * here,CKTcircuit * ckt)129 int B4SOILoadOMP(B4SOIinstance *here, CKTcircuit *ckt) {
130 B4SOImodel *model = B4SOImodPtr(here);
131 #else
132 register B4SOImodel *model = (B4SOImodel*)inModel;
133 register B4SOIinstance *here;
134 #endif
135
136 register int selfheat;
137
138 double Gmin;
139 double dVgstNVt_dT, dVgstNVt2_dT; /* LFW_FD */
140 double ag0, qgd, qgs, von, cbhat, VgstNVt, ExpVgst, dExpVgst_dT; /* enhanced line Wagner */
141 /* LFW_FD next 4 lines */
142 double dVgstNVt_dVg, dVgstNVt_dVd, dVgstNVt_dVb, dVgstNVt_dVe;
143 double dExpVgst_dVg, dExpVgst_dVd, dExpVgst_dVb, dExpVgst_dVe, dVgstNVt2_dVg;
144 double dVgstNVt2_dVd, dVgstNVt2_dVb, dVgstNVt2_dVe, dExpArg2_dVd, dExpArg2_dVb, dExpArg2_dVe;
145 double dExpVgst2_dVg, dExpVgst2_dVd, dExpVgst2_dVb, dExpVgst2_dVe;
146 double cdhat, cdreq, ceqbd, ceqbs, ceqqb, ceqqd, ceqqg, ceq, geq;
147 double arg;
148 double delvbd, delvbs, delvds, delvgd, delvgs;
149 double Vfbeff, dVfbeff_dVg, dVfbeff_dVd, dVfbeff_dVe, dVfbeff_dVb, V3, V4;
150 double PhiBSWG, MJSWG;
151 double gcgdb, gcggb, gcgsb, gcgeb, gcgT;
152 double gcsdb, gcsgb, gcssb, gcseb, gcsT;
153 double gcddb, gcdgb, gcdsb, gcdeb, gcdT;
154 double gcbdb, gcbgb, gcbsb, gcbeb, gcbT;
155 double gcedb, gcegb, gcesb, gceeb, gceT;
156 double gcTt, gTtg, gTtb, gTtdp, gTtt, gTtsp;
157 double vbd, vbs, vds, vgb, vgd, vgs, vgdo;
158 #ifndef PREDICTOR
159 double xfact;
160 #endif
161 double vg, vd, vs, vp, ve, vb;
162 double Vds, Vgs, Vbs, Gmbs, FwdSum, RevSum;
163
164 double Vgs_eff, Vfb, dVfb_dVb, dVfb_dVd, dVfb_dVg, dVfb_dVe, dVfb_dT;
165 double Phis, sqrtPhis, dsqrtPhis_dVd, dsqrtPhis_dVe, dsqrtPhis_dVb, dsqrtPhis_dVg;
166 double Vth, dVth_dVb, dVth_dVd, dVth_dVg, dVth_dVe, dVth_dT;
167 double Vgst, dVgst_dVg, dVgst_dVd, dVgst_dVb, dVgst_dVe, dVgst_dT, dVgs_eff_dVg, dVgs_eff_dT;
168 double n, dn_dVb, dn_dVe, dn_dVg, Vtm;
169 double ExpArg, dExpArg_dVg, dExpArg_dVd, dExpArg_dVb, dExpArg_dVe, dExpArg_dT, dExpArg2_dVg, dExpArg2_dT, V0;
170 double ueff, dueff_dVg, dueff_dVd, dueff_dVb, dueff_dVe, dueff_dT;
171 double Esat, Vdsat;
172 double EsatL, dEsatL_dVg, dEsatL_dVd, dEsatL_dVb, dEsatL_dVe, dEsatL_dT;
173 double dVdsat_dVg, dVdsat_dVb, dVdsat_dVd, dVdsat_dVe, dVdsat_dT, Vasat;
174 double dVasat_dVg, dVasat_dVb, dVasat_dVd, dVasat_dVe, dVasat_dT;
175 double Va, dVa_dVd, dVa_dVg, dVa_dVb, dVa_dVe, dVa_dT;
176 double Vbseff, dVbseff_dVb;
177 double CoxWL;
178 double T0=0.0, dT0_dVg, dT0_dVd, dT0_dVe, dT0_dVb, dT0_dT;
179
180 double T1, dT1_dVg, dT1_dVd, dT1_dVb, dT1_dT;
181 double T2, dT2_dVg, dT2_dVd, dT2_dVb, dT2_dT, dT2_dVp;
182 double T3, dT3_dVg, dT3_dVd, dT3_dVe, dT3_dVb, dT3_dT;
183 double T4, dT4_dVe, dT4_dVg, dT4_dVd, dT4_dVb, dT4_dT;
184 double T5, dT5_dVg, dT5_dVd, dT5_dVb, dT5_dT;
185 double T6, dT6_dVg, dT6_dVd, dT6_dVe, dT6_dVb, dT6_dT, dT6_dVp;
186 double T7, dT7_dVg, dT7_dVb, dT7_dVd, dT7_dVe;
187 double T8, dT8_dVd;
188 double T9, dT9_dVd;
189 double T10, dT10_dVb, dT10_dVd;
190 double T11, T12;
191 /* LFW_FD 2 new lines */
192 double dT02_dVg, dT02_dVd, dT02_dVb, dT02_dVe, dT12_dVg, dT12_dVd, dT12_dVb, dT12_dVe;
193 double dT22_dVg, dT22_dVd, dT22_dVb, dT22_dVe;
194 double dTL0_dT, TL1, dTL1_dT, TL2, dTL2_dT, TL3, dTL3_dT, TL4, dTL4_dT, dTL5_dT; /* new line Wagner */
195 /* LFW_FD 1 new line */
196 double dTL1_dVg, dTL1_dVd, dTL1_dVb, dTL1_dVe;
197 double dTL6_dT, dTL7_dT, dTL8_dT, dTL9_dT; /* new line Wagner */
198 double tmp, Abulk, dAbulk_dVb, Abulk0, dAbulk0_dVg, dAbulk0_dVb, dAbulk0_dVd, dAbulk0_dVe;
199 double dAbulk_dT, dAbulk0_dT, dAbulkCV_dT; /* new line Wagner */
200 double VACLM, dVACLM_dVg, dVACLM_dVd, dVACLM_dVb, dVACLM_dVe, dVACLM_dT;
201 double VADIBL, dVADIBL_dVg, dVADIBL_dVd, dVADIBL_dVb, dVADIBL_dVe, dVADIBL_dT;
202 double Xdep, dXdep_dVd, dXdep_dVe, dXdep_dVb, dXdep_dVg;
203 double lt1, dlt1_dVd, dlt1_dVe, dlt1_dVb, dlt1_dVg;
204 double ltw, dltw_dVd, dltw_dVe, dltw_dVb, dltw_dVg;
205 double Delt_vth, dDelt_vth_dVd, dDelt_vth_dVe, dDelt_vth_dVb, dDelt_vth_dVg, dDelt_vth_dT;
206 double Theta0, dTheta0_dVd, dTheta0_dVe, dTheta0_dVb, dTheta0_dVg;
207 double TempRatio, tmp1, tmp2, tmp3, tmp4;
208 double DIBL_Sft, dDIBL_Sft_dVd, Lambda, dLambda_dVg, dLambda_dVb, dLambda_dVd, dLambda_dVe;
209 double dLambda_dT; /* new line Wagner */
210
211 double a1;
212
213 double Vgsteff, dVgsteff_dVg, dVgsteff_dVd, dVgsteff_dVb, dVgsteff_dT;
214 double Vdseff, dVdseff_dVg, dVdseff_dVd, dVdseff_dVb, dVdseff_dVe, dVdseff_dT;
215 double VdseffCV, dVdseffCV_dVg, dVdseffCV_dVd, dVdseffCV_dVb, dVdseffCV_dVe;
216 double dVdseffCV_dT; /* new line Wagner */
217 double diffVds;
218 double dAbulk_dVg, dAbulk_dVd, dAbulk_dVe, dn_dVd ;
219 double beta, dbeta_dVg, dbeta_dVd, dbeta_dVb, dbeta_dVe, dbeta_dT;
220 double gche, dgche_dVg, dgche_dVd, dgche_dVb, dgche_dVe, dgche_dT;
221 double fgche1, dfgche1_dVg, dfgche1_dVd, dfgche1_dVb, dfgche1_dVe, dfgche1_dT;
222 double fgche2, dfgche2_dVg, dfgche2_dVd, dfgche2_dVb, dfgche2_dVe, dfgche2_dT;
223 double Idl, dIdl_dVg, dIdl_dVd, dIdl_dVb, dIdl_dVe, dIdl_dT;
224 double Ids, Gm, Gds, Gmb, dIds_dVg, dIds_dVb, dIds_dVd, dIds_dVe, dIds_dT;
225 double CoxWovL;
226 double Rds, dRds_dVg, dRds_dVb, dRds_dVd, dRds_dVe, dRds_dT, WVCox, WVCoxRds, dWVCoxRds_dT;
227 double dWVCoxRds_dVg, dWVCoxRds_dVb, dWVCoxRds_dVd, dWVCoxRds_dVe;
228 double Vgst2Vtm, dVgst2Vtm_dT, VdsatCV, dVdsatCV_dVg, dVdsatCV_dVd, dVdsatCV_dVb, dVdsatCV_dVe, dVdsatCV_dT;
229 double Leff, Weff, dWeff_dVg, dWeff_dVb, dWeff_dVd, dWeff_dVe, dWeff_dT;
230 double AbulkCV, dAbulkCV_dVg, dAbulkCV_dVb, dAbulkCV_dVd, dAbulkCV_dVe;
231 double qgdo, qgso, cgdo, cgso;
232
233 double dxpart, sxpart;
234
235 struct b4soiSizeDependParam *pParam;
236 int ByPass, Check, ChargeComputationNeeded=0, error;
237
238 double gbbsp, gbbdp, gbbg, gbbb, gbbp, gbbT;
239 double gddpsp, gddpdp, gddpg, gddpb, gddpT;
240 double gsspsp, gsspdp, gsspg, gsspb, gsspT;
241 double Gbpbs=0.0, Gbpps;
242 double ves, ved, veb, vge=0.0, delves, vedo, delved;
243 double vps, vpd, Vps, delvps;
244 double Vbd, Ves, Vesfb;
245 double DeltVthtemp, dDeltVthtemp_dVd, dDeltVthtemp_dVe, dDeltVthtemp_dVb, dDeltVthtemp_dVg, dDeltVthtemp_dT;
246 double Vbp, dVbp_dVb;
247 double DeltVthw, dDeltVthw_dVd, dDeltVthw_dVe, dDeltVthw_dVb, dDeltVthw_dVg, dDeltVthw_dT;
248 double Gm0, Gds0, Gmb0, Gme0, GmT0, GmT;
249 double dDIBL_Sft_dVg, dDIBL_Sft_dVe, dDIBL_Sft_dVb;
250 double Igidl, Ggidld=0.0, Ggidlg, Ggidlb=0.0, Ggidlt; /* enhanced line Wagner */
251 double Igisl, Ggisls=0.0, Ggislg, Ggislb=0.0, Ggislt; /* enhanced line Wagner */
252 double Gjsd, Gjsb=0.0, GjsT, Gjdd, Gjdb=0.0, GjdT;
253 double Ibp, Iii, Giid=0.0, Giig, Giib=0.0, GiiT, Gcd, Gcb, GcT, ceqbody, ceqbodcon;
254 double gppb, gppp;
255 double delTemp, deldelTemp, Temp;
256 double ceqth, ceqqth;
257 double K1;
258 double qjs=0.0, gcjsbs=0.0, gcjsT;
259 double qjd=0.0, gcjdbs=0.0, gcjdT;
260 double qge;
261 double ceqqe;
262 double ni, Eg, Cbox, CboxWL;
263 double dEg_dT; /* new line Wagner */
264 double cjsbs;
265 double dVfbeff_dVrg;
266 double qinv, qgate=0.0, qbody=0.0, qdrn=0.0, qsrc, qsub=0.0, cqgate, cqbody, cqdrn, cqsub, cqtemp;
267 double qgate1; /* new line Wagner */
268
269 double Cgg, Cgd, Cgb, Cge;
270 double Csg, Csd, Csb, Cse, Cbg, Cbd, Cbb, Cbe;
271 double Cgg1, Cgb1, Cgd1, Cge1, Cbg1, Cbb1, Cbd1, Cbe1, Csg1, Csd1, Csb1, Cse1;
272 double Vdsatii;
273 double Ibs1 ,dIbs1_dVb ,dIbs1_dT;
274 double Ibs2 ,dIbs2_dVb ,dIbs2_dT;
275 double Ibs3 ,dIbs3_dVb ,dIbs3_dVd, dIbs3_dT;
276 double Ibs4 ,dIbs4_dVb ,dIbs4_dT;
277 double Ibd1 ,dIbd1_dVb ,dIbd1_dVd ,dIbd1_dT;
278 double Ibd2 ,dIbd2_dVb ,dIbd2_dVd ,dIbd2_dT;
279 double Ibd3 ,dIbd3_dVb ,dIbd3_dVd ,dIbd3_dT;
280 double Ibd4 ,dIbd4_dVb ,dIbd4_dVd ,dIbd4_dT;
281 double WTsi, NVtm1, NVtm2;
282 double Ic ,dIc_dVb ,dIc_dVd;
283 double Ibs;
284 double Ibd;
285 double Denomi ,dDenomi_dVg, dDenomi_dVd, dDenomi_dVb, dDenomi_dVe, dDenomi_dT;
286 double Qsub0 ,dQsub0_dVg ,dQsub0_dVb ,dQsub0_dVd, dQsub0_dVe ;
287 double dqgate_dT, dqgate2_dT, dqbulk_dT, dqsrc_dT, dqdrn_dT, dqbody_dT, dqsub_dT; /* new line Wagner */
288 double Qac0 ,dQac0_dVb ,dQac0_dVd;
289 double Qe1 , dQe1_dVb, dQe1_dVe, dQe1_dT;
290 double Ce1b ,Ce1e, Ce1T;
291 double dQac0_dVrg, dQsub0_dVrg;
292
293 /* for self-heating */
294 double vbi, vfbb, phi, sqrtPhi, Xdep0, u0temp, vsattemp;
295 double jdifs, jdifd, djdifs_dT, djdifd_dT;
296 double jbjts, jbjtd, djbjts_dT, djbjtd_dT;
297 double jrecs, jrecd, djrecs_dT, djrecd_dT;
298 double jtuns, jtund, djtuns_dT, djtund_dT;
299 double rds0=0.0, ua, ub, uc;
300 double dvbi_dT, dvfbb_dT, du0temp_dT;
301 double dvsattemp_dT, drds0_dT=0.0, dua_dT, dub_dT, duc_dT, dni_dT, dVtm_dT;
302 double dVfbeff_dT, dQac0_dT, dQsub0_dT;
303 double CbT, CsT, CgT;
304 double CdT; /* new line Wagner */
305 double rho, rho_ref, ku0temp; /* v4.0 */
306 double drho_dT, drho_ref_dT, dku0temp_dT; /* v4.0 */
307
308 /* v2.0 release */
309 double Vbsh, dVbsh_dVb;
310 double sqrtPhisExt, dsqrtPhisExt_dVd, dsqrtPhisExt_dVe, dsqrtPhisExt_dVb, dsqrtPhisExt_dVg;
311 double T13, T14;
312 double dT14_dT; /* new line Wagner */
313 double dT11_dVb, dT11_dVd, dT11_dVe, dT13_dVb, dT13_dVd, dT13_dVe, dT14_dVb, dT14_dVd, dT14_dVe, dT13_dVg, dT14_dVg;
314 double Vdsatii0, dVdsatii0_dT;
315 double VgsStep, dVgsStep_dT, Ratio, dRatio_dVg, dRatio_dVb, dRatio_dVd, dRatio_dT, dTempRatio_dT;
316 double Vdiff, dVdiff_dVg, dVdiff_dVb, dVdiff_dVd, dVdiff_dT;
317 double dNVtm1_dT;
318 double NVtmf, NVtmr, dNVtmf_dT, dNVtmr_dT;
319 double TempRatioMinus1;
320 double Ahlis, dAhlis_dT, Ahlid, dAhlid_dT ;
321 double WsTsi, WdTsi;
322 double dPhiBSWG_dT, dcjsbs_dT, darg_dT, ddT3_dVb_dT;
323 double dT7_dT, dT0_dT7, dT1_dT7, dT2_dT7;
324 double CoxWLb, CoxWLcenb;
325 double ExpVbsNVtm, dExpVbsNVtm_dVb, dExpVbsNVtm_dT;
326 double ExpVbdNVtm, dExpVbdNVtm_dVb, dExpVbdNVtm_dVd, dExpVbdNVtm_dT;
327 double Ien, dIen_dT, Iendif, dIendif_dT;
328 double Ibsdif, dIbsdif_dVb, dIbsdif_dT;
329 double Ibddif, dIbddif_dVb, dIbddif_dT;
330 double Ehlis, dEhlis_dVb, dEhlis_dT;
331 double EhlisFactor, dEhlisFactor_dVb, dEhlisFactor_dT;
332 double Ehlid, dEhlid_dVb, dEhlid_dVd, dEhlid_dT;
333 double EhlidFactor, dEhlidFactor_dVb, dEhlidFactor_dT;
334 double E2ndFactor, dE2ndFactor_dVb, dE2ndFactor_dVd, dE2ndFactor_dT;
335 double dT10_dT, dT11_dT, dT13_dT, DioMax; /* LFW_FD enhance line */
336 double cjdbs, dcjdbs_dT;
337 double wdios, wdiod;
338
339 /* for capMod3 */
340 double Cox, Tox, Tcen, dTcen_dVg, dTcen_dVb, LINK, Ccen, Coxeff, dCoxeff_dVg, dCoxeff_dVb;
341 double CoxWLcen, QovCox, dQac0_dVg, dQac0_dVe, DeltaPhi, dDeltaPhi_dVg, dDeltaPhi_dT;
342 double dDeltaPhi_dVd, dDeltaPhi_dVb, dDeltaPhi_dVe;
343 double dTcen_dVd, dTcen_dVe, dTcen_dT, dCoxeff_dVd, dCoxeff_dT, dCoxWLcenb_dT, qinoi, qbulk, qbulk1;
344 double dCoxeff_dVe;
345 double T3zb, lt1zb, ltwzb, Theta0zb;
346 double Delt_vthzb, dDelt_vthzb_dT;
347 double DeltVthwzb, dDeltVthwzb_dT;
348 double DeltVthtempzb, dDeltVthtempzb_dT;
349 double Vthzb, dVthzb_dT, Vfbzb, dVfbzb_dT;
350
351 /* v3.2 */
352 double noff, dnoff_dVg, dnoff_dVd, dnoff_dVb, dnoff_dVe;
353 double dnoff_dT; /* new line Wagner */
354 double vgmb;
355
356 /* v3.1 added for RF */
357 double geltd, gcrg, gcrgg, gcrgd, gcrgs, gcrgb, ceqgcrg;
358 double vges, vgms, vgedo, vgmdo, vged, vgmd, delvged, delvgmd;
359 double delvges, delvgms, vgme;
360 double gcgmgmb=0.0, gcgmdb, gcgmsb, gcdgmb, gcsgmb;
361 double gcgmeb, gcegmb, qgme, qgmid=0.0, ceqqgmid;
362 double gcgbb;
363 double vgge, vggm;
364
365 /* v3.0 */
366 double Igc, dIgc_dVg, dIgc_dVd, dIgc_dVe, dIgc_dVb, Igs, dIgs_dVg, dIgs_dVs, Igd, dIgd_dVg, dIgd_dVd;
367 double Igcs, dIgcs_dVg, dIgcs_dVd, dIgcs_dVb, dIgcs_dVe, Igcd, dIgcd_dVg, dIgcd_dVd, dIgcd_dVb, dIgcd_dVe;
368 double dIgc_dT, dIgcs_dT, dIgcd_dT; /* new line Wagner */
369 double vgs_eff, dvgs_eff_dvg, vgd_eff, dvgd_eff_dvg;
370 double VxNVt, ExpVxNVt;
371 double dVxNVt_dT; /* new line Wagner */
372 double gIstotg, gIstotd, gIstotb, gIstots, Istoteq;
373 double gIdtotg, gIdtotd, gIdtotb, gIdtots, Idtoteq;
374 double gIgtotg, gIgtotd, gIgtotb, gIgtots, Igtoteq;
375
376 /* v3.0 */
377 double Vbsitf, dVbsitf_dVg, dVbsitf_dVd, dVbsitf_dVb, dVbsitf_dVe, dVbsitf_dT, dVbs_dVb;
378 double dVbs_dVg, dVbs_dVd, dVbs_dVe, dVbs_dT;
379 double dIgb1_dVe, Giie, dRatio_dVe, dVdiff_dVe;
380 double dT1_dVe, dT5_dVe, dIgb_dVe, dVox_dVe, dVoxdepinv_dVe, dVaux_dVe;
381 double Gme, gTte, gbbe, gddpe, gsspe;
382 double Vbs0, dVbs0_dVg, dVbs0_dVd, dVbs0_dVe, dVbs0_dT;
383 double Vbs0mos, dVbs0mos_dVe, dVbs0mos_dT;
384 double Vbsmos, dVbsmos_dVg, dVbsmos_dVd, dVbsmos_dVb, dVbsmos_dVe, dVbsmos_dT;
385 double PhiON, dPhiON_dVg, dPhiON_dVd, dPhiON_dVe, dPhiON_dT;
386 double PhiFD, dPhiFD_dVg, dPhiFD_dVd, dPhiFD_dVe, dPhiFD_dT;
387 double Vbs0t, dVbs0t_dVg, dVbs0t_dVd, dVbs0t_dVe, dVbs0t_dT;
388 double VthFD, dVthFD_dVd, dVthFD_dVb, dVthFD_dVe, dVthFD_dT;
389 double VtgsFD, ExpVtgsFD, VgstFD, ExpVgstFD;
390 double VtgseffFD, dVtgseffFD_dVd, dVtgseffFD_dVg, dVtgseffFD_dVe, dVtgseffFD_dT;
391 double VgsteffFD, dVgsteffFD_dVd, dVgsteffFD_dVg, dVgsteffFD_dVe, dVgsteffFD_dT;
392 double dT2_dVe, dVbsh_dVg, dVbsh_dVd, dVbsh_dVe, dVbsh_dT;
393 double dVgsteff_dVe, dVbseff_dVg, dVbseff_dVd, dVbseff_dVe, dVbseff_dT;
394
395 /* v2.2 release */
396 double Vgb, dVgb_dVg, dVgb_dVd, dVgb_dVe, dVgb_dVb, Vox, dVox_dVg, dVox_dVd, dVox_dVb;
397 double OxideRatio, Vaux, dVaux_dVg, dVaux_dVd, dVaux_dVb;
398 double Igb, dIgb_dVg, dIgb_dVd, dIgb_dVb;
399 double ceqgate;
400 double dT0_dVox, Voxeff, dVoxeff_dVox;
401 double dVox_dT, dVaux_dT, dIgb_dT;
402 double Voxacc, dVoxacc_dVg, dVoxacc_dVd, dVoxacc_dVe, dVoxacc_dVb, dVoxacc_dT;
403 double Voxdepinv, dVoxdepinv_dVg, dVoxdepinv_dVb, dVoxdepinv_dVd, dVoxdepinv_dT;
404 double Igb1, dIgb1_dVg, dIgb1_dVd, dIgb1_dVb, dIgb1_dT;
405 double Igb2, dIgb2_dVg, dIgb2_dVd, dIgb2_dVb, dIgb2_dVe, dIgb2_dT;
406 double gigs, gigd, gigb, gigg, gigT, gige; /* LFW_FD enhance line */
407 double gigpg, gigpp;
408
409 /* v4.0 */
410 double IdlovVdseff, dIdlovVdseff_dVg, dIdlovVdseff_dVd, dIdlovVdseff_dVb;
411 double vdbs, vsbs, vdbd=0.0, vsbd, vsbdo, vbs_jct, vbd_jct;
412 double Vsbs, Vdbd, Vdbs;
413 double delvdbd, delvsbs, delvdbs, delvbd_jct, delvbs_jct;
414 double gcdbdb, gcsbsb, gcsbb, gcdbb;
415 double ceqqjd=0.0, ceqqjs=0.0;
416 double Lpe_Vb; /* v4.0 for Vth */
417 double DITS_Sft, DITS_Sft2, dDITS_Sft_dVb, dDITS_Sft_dVd, dDITS_Sft2_dVd, dDITS_Sft_dT;
418 double FP, dFP_dT, dFP_dVg, dFP_dVb, dFP_dVd, dFP_dVe;
419 double VADITS, dVADITS_dVg, dVADITS_dVd, dVADITS_dVb, dVADITS_dVe, dVADITS_dT; /* for DITS */
420 double Iii_Igidl, Giigidl_b, Giigidl_d, Giigidl_g, Giigidl_e, Giigidl_T;
421 double gjsdb;
422 double Idbdp=0.0, Isbsp=0.0, cdbdp, csbsp, gcjdbdp, gcjsbsp, GGjdb, GGjsb;
423 double vdes, vses, vdedo, delvdes, delvses, delvded, Isestot, cseshat, Idedtot, cdedhat;
424 double PowWeffWr, rd0=0.0, rs0=0.0, rdwmin=0.0, rswmin=0.0, drs0_dT=0.0, drd0_dT=0.0, drswmin_dT=0.0,
425 drdwmin_dT=0.0, Rd, dRd_dVg, dRd_dVb, dRd_dT, Rs, dRs_dVg, dRs_dVb, dRs_dT;
426 double dgstot_dvd, dgstot_dvg, dgstot_dvs, dgstot_dvb, dgstot_dve, dgstot_dT;
427 double dgdtot_dvd, dgdtot_dvg, dgdtot_dvs, dgdtot_dvb, dgdtot_dve, dgdtot_dT;
428 double gstot, gstotd, gstotg, gstots, gstotb, ceqgstot;
429 double gdtot, gdtotd, gdtotg, gdtots, gdtotb, ceqgdtot;
430 double gdpr, gspr;
431 /*4.1*/
432 double toxe, epsrox, epssub, epsgate;
433 double Tnom, Eg0, Vtm0;
434 double Vbci, Idsmosfet, Iiibjt;
435 double dVbci_dT, dIiibjt_dVd, dIiibjt_dVb, dIiibjt_dT;
436 double VgsteffVth, dT11_dVg;
437 /* v4.1 */
438 /* Jun 09 */
439 double toxe_mob ;
440 /* Jun 09 */
441
442
443 double dTheta0_dT, dn_dT, dsqrtPhisExt_dT, dT3zb_dT, dltwzb_dT, dlt1zb_dT, dTheta0zb_dT, dvth0_dT, dDIBL_Sft_dT,dtmp2_dT; /* v4.2 temp deriv */
444 double Vgd, Vgd_eff, dVgd_eff_dVg, dVgd_eff_dT; /* enhanced line Wagner */
445 double dVbs0mos_dVd;
446 double Ig_agbcp2, dIg_agbcp2_dVg, dIg_agbcp2_dVp, dIg_agbcp2_dT;
447 double vgp_eff, vgp=0.0, dvgp_eff_dvg, dvgp_eff_dvp, dvgp_eff_dT;
448
449 /* improved body contact charge model */
450 double CoxWL2, CoxWLb2;
451 double ExpVgst2, Vgsteff2, VgstNVt2, ExpArg2;
452 double dVgsteff2_dVd, dVgsteff2_dVg, dVgsteff2_dVb, dVgsteff2_dVe, dVgsteff2_dT;
453 double T02;
454 double Qac02, dQac02_dVrg, dQac02_dVd, dQac02_dVg, dQac02_dVb, dQac02_dVe, dQac02_dT;
455 double Vgs_eff2, dVgs_eff2_dVg;
456 double Vfbzb2, dVfbzb2_dT;
457 double Vfb2, dVfb2_dVg, dVfb2_dVd, dVfb2_dVb, dVfb2_dVe, dVfb2_dT;
458 double Vfbeff2, dVfbeff2_dVd, dVfbeff2_dVrg, dVfbeff2_dVg, dVfbeff2_dVb, dVfbeff2_dVe, dVfbeff2_dT;
459 double Qsub02, dQsub02_dVg, dQsub02_dVrg, dQsub02_dVd, dQsub02_dVb, dQsub02_dVe, dQsub02_dT;
460 double VdsatCV2, dVdsatCV2_dVg, dVdsatCV2_dVb, dVdsatCV2_dVd, dVdsatCV2_dVe, dVdsatCV2_dT;
461 double VdseffCV2, dVdseffCV2_dVg, dVdseffCV2_dVd, dVdseffCV2_dVb, dVdseffCV2_dVe, dVdseffCV2_dT;
462 double Cbg12, Cbd12, Cbb12, Cbe12;
463 double Cgg12, Cgd12, Cgb12, Cge12;
464 double Csg12, Csd12, Csb12, Cse12;
465 double Tcen2, dTcen2_dVg, dTcen2_dVd, dTcen2_dVb, dTcen2_dVe, dTcen2_dT;
466 double Ccen2;
467 double Coxeff2, dCoxeff2_dVg, dCoxeff2_dVd, dCoxeff2_dVb, dCoxeff2_dVe, dCoxeff2_dT;
468 double CoxWLcenb2, dCoxWLcenb2_dT;
469 double QovCox2;
470 double DeltaPhi2, dDeltaPhi2_dVg, dDeltaPhi2_dVd, dDeltaPhi2_dVb, dDeltaPhi2_dVe;
471 double dDeltaPhi2_dT; /* new line Wagner */
472 double CoxWLcen2;
473 double T22, T52;
474 double qsrc2, qbulk2;
475 double dqsrc2_dT, dqbulk2_dT; /* new line Wagner */
476 double Csg2, Csd2, Csb2, Cse2;
477 double DELTA_3_SOI2;
478 double dphi_dT,dsqrtPhi_dT,dXdep0_dT,cdep0,theta0vb0,dtheta0vb0_dT;
479 double thetaRout,dthetaRout_dT,dcdep0_dT;
480 double dPhis_dT,dsqrtPhis_dT,dXdep_dT,dlt1_dT,dltw_dT;
481 double agidl, bgidl, cgidl, egidl, rgidl, kgidl, fgidl;
482
483 double agisl, bgisl, cgisl, egisl, rgisl, kgisl, fgisl;
484 double ucs, ud; /* Bugfix # 21 Jul09*/
485 double ndiode, ndioded; /* v4.2 bugfix */
486 double nrecf0s, nrecf0d, nrecr0s, nrecr0d, vrec0s, vrec0d, ntuns, ntund, vtun0s,vtun0d;/*bugfix for junction DC swapping */
487
488 double eggbcp2, eggdep, agb1, bgb1, agb2, bgb2, agbc2n, agbc2p, bgbc2n, bgbc2p, Vtm00; /* v4.3.1 bugfix for mtrlMod=1 -Tanvir */
489 double m;
490
491 #ifndef USE_OMP
492 for (; model != NULL; model = B4SOInextModel(model))
493 { for (here = B4SOIinstances(model); here != NULL;
494 here = B4SOInextInstance(here))
495 {
496
497 #endif
498 Check = 0;
499 ByPass = 0;
500 selfheat = (model->B4SOIshMod == 1) && (here->B4SOIrth0 != 0.0);
501 pParam = here->pParam;
502
503
504 if ((ckt->CKTmode & MODEINITSMSIG))
505 {
506 vs = *(ckt->CKTrhsOld + here->B4SOIsNodePrime);
507 if (!here->B4SOIvbsusrGiven) {
508 vbs = *(ckt->CKTstate0 + here->B4SOIvbs);
509 vb = *(ckt->CKTrhsOld + here->B4SOIbNode);
510 }
511 else {
512 vbs = here->B4SOIvbsusr;
513 vb = here->B4SOIvbsusr + vs;
514 }
515 vgs = *(ckt->CKTstate0 + here->B4SOIvgs);
516 ves = *(ckt->CKTstate0 + here->B4SOIves);
517 vps = *(ckt->CKTstate0 + here->B4SOIvps);
518 vds = *(ckt->CKTstate0 + here->B4SOIvds);
519 delTemp = *(ckt->CKTstate0 + here->B4SOIdeltemp);
520 /* v4.0 */
521 vdbs = *(ckt->CKTstate0 + here->B4SOIvdbs); /* v4.0 for rbody */
522 vdbd = *(ckt->CKTstate0 + here->B4SOIvdbd); /* v4.0 for rbody */
523 vsbs = *(ckt->CKTstate0 + here->B4SOIvsbs); /* v4.0 for rbody */
524 vses = *(ckt->CKTstate0 + here->B4SOIvses); /* v4.0 for rdsmod*/
525 vdes = *(ckt->CKTstate0 + here->B4SOIvdes); /* v4.0 for rdsmod*/
526
527 /* v4.0 end */
528
529 vg = *(ckt->CKTrhsOld + here->B4SOIgNode);
530 vd = *(ckt->CKTrhsOld + here->B4SOIdNodePrime);
531 vp = *(ckt->CKTrhsOld + here->B4SOIpNode);
532 ve = *(ckt->CKTrhsOld + here->B4SOIeNode);
533
534 /* v3.1 added for RF */
535 vgge = *(ckt->CKTrhsOld + here->B4SOIgNodeExt);
536 vggm = *(ckt->CKTrhsOld + here->B4SOIgNodeMid);
537
538 vges = *(ckt->CKTstate0 + here->B4SOIvges);
539 vgms = *(ckt->CKTstate0 + here->B4SOIvgms);
540 /* v3.1 added for RF end*/
541 }
542 else if ((ckt->CKTmode & MODEINITTRAN))
543 {
544 vs = *(ckt->CKTrhsOld + here->B4SOIsNodePrime);
545 if (!here->B4SOIvbsusrGiven) {
546 vbs = *(ckt->CKTstate1 + here->B4SOIvbs);
547 vb = *(ckt->CKTrhsOld + here->B4SOIbNode);
548 }
549 else {
550 vbs = here->B4SOIvbsusr;
551 vb = here->B4SOIvbsusr + vs;
552 }
553 vgs = *(ckt->CKTstate1 + here->B4SOIvgs);
554 ves = *(ckt->CKTstate1 + here->B4SOIves);
555 vps = *(ckt->CKTstate1 + here->B4SOIvps);
556 vds = *(ckt->CKTstate1 + here->B4SOIvds);
557 delTemp = *(ckt->CKTstate1 + here->B4SOIdeltemp);
558
559 /* v4.0 */
560 vdbs = *(ckt->CKTstate1 + here->B4SOIvdbs); /* v4.0 for rbody */
561 vsbs = *(ckt->CKTstate1 + here->B4SOIvsbs); /* v4.0 for rbody */
562 vses = *(ckt->CKTstate1 + here->B4SOIvses); /* v4.0 for rdsmod */
563 vdes = *(ckt->CKTstate1 + here->B4SOIvdes); /* v4.0 for rdsmod */
564 /* v4.0 end */
565
566 vg = *(ckt->CKTrhsOld + here->B4SOIgNode);
567 vd = *(ckt->CKTrhsOld + here->B4SOIdNodePrime);
568 vp = *(ckt->CKTrhsOld + here->B4SOIpNode);
569 ve = *(ckt->CKTrhsOld + here->B4SOIeNode);
570
571 /* v3.1 added for RF */
572 vgge = *(ckt->CKTrhsOld + here->B4SOIgNodeExt);
573 vggm = *(ckt->CKTrhsOld + here->B4SOIgNodeMid);
574 vges = *(ckt->CKTstate1 + here->B4SOIvges);
575 vgms = *(ckt->CKTstate1 + here->B4SOIvgms);
576 /* v3.1 added for RF end*/
577
578 }
579 else if ((ckt->CKTmode & MODEINITJCT) && !here->B4SOIoff)
580 { vds = model->B4SOItype * here->B4SOIicVDS;
581 vgs = model->B4SOItype * here->B4SOIicVGS;
582 ves = model->B4SOItype * here->B4SOIicVES;
583 vbs = model->B4SOItype * here->B4SOIicVBS;
584 vps = model->B4SOItype * here->B4SOIicVPS;
585 vdbs = vsbs = vbs; /* v4.0 */
586
587 vg = vd = vs = vp = ve = 0.0;
588
589 /* v3.1 added for RF */
590 vges = vgms = vgs;
591 vgge = vggm =0.0;
592 /* v3.1 added for RF end*/
593
594 if (vds > 0.0) /* v4.0 */
595 { vdes = vds + 0.01;
596 vses = -0.01;
597 }
598 else if (vds < 0.0)
599 { vdes = vds - 0.01;
600 vses = 0.01;
601 }
602 else
603 vdes = vses = 0.0;
604
605 delTemp = 0.0;
606 here->B4SOIphi = pParam->B4SOIphi;
607
608
609
610 if ((vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) &&
611 ((ckt->CKTmode & (MODETRAN | MODEAC|MODEDCOP |
612 MODEDCTRANCURVE)) || (!(ckt->CKTmode & MODEUIC))))
613 {
614 /* vgs = model->B4SOItype*0.1 + here->B4SOIvth0; */
615 vgs = model->B4SOItype * here->B4SOIvth0 + 0.1; /* v4.0 */
616 vds = 0.0;
617 ves = 0.0;
618 vps = 0.0;
619 vges = vgms = vgs; /* v3.1 */
620 vbs = vdbs = vsbs = 0.0; /* v4.0 */
621 vdes = 0.01; /* v4.0 for rdsmod */
622 vses = -0.01; /* v4.0 for rdsmod */
623 }
624 }
625 else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) &&
626 (here->B4SOIoff))
627 { delTemp = vps = vbs = vgs = vds = ves = 0.0;
628 vg = vd = vs = vp = ve = 0.0;
629 vgge = vggm = 0.0; /* v3.1 */
630 vges = vgms =0.0; /* v3.1 */
631 vdbs = vsbs = vdes = vses = 0.0; /* v4.0 */
632 }
633 else
634 {
635 #ifndef PREDICTOR
636
637 if ((ckt->CKTmode & MODEINITPRED))
638 { xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1];
639 *(ckt->CKTstate0 + here->B4SOIvbs) =
640 *(ckt->CKTstate1 + here->B4SOIvbs);
641 vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvbs))
642 - (xfact * (*(ckt->CKTstate2 + here->B4SOIvbs)));
643 *(ckt->CKTstate0 + here->B4SOIvgs) =
644 *(ckt->CKTstate1 + here->B4SOIvgs);
645 vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvgs))
646 - (xfact * (*(ckt->CKTstate2 + here->B4SOIvgs)));
647 *(ckt->CKTstate0 + here->B4SOIves) =
648 *(ckt->CKTstate1 + here->B4SOIves);
649 ves = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIves))
650 - (xfact * (*(ckt->CKTstate2 + here->B4SOIves)));
651 *(ckt->CKTstate0 + here->B4SOIvps) =
652 *(ckt->CKTstate1 + here->B4SOIvps);
653 vps = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvps))
654 - (xfact * (*(ckt->CKTstate2 + here->B4SOIvps)));
655 *(ckt->CKTstate0 + here->B4SOIvds) =
656 *(ckt->CKTstate1 + here->B4SOIvds);
657 vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvds))
658 - (xfact * (*(ckt->CKTstate2 + here->B4SOIvds)));
659 *(ckt->CKTstate0 + here->B4SOIvbd) =
660 *(ckt->CKTstate0 + here->B4SOIvbs)
661 - *(ckt->CKTstate0 + here->B4SOIvds);
662 /* v4.0 */
663 *(ckt->CKTstate0 + here->B4SOIvdbs) =
664 *(ckt->CKTstate1 + here->B4SOIvdbs);
665 vdbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvdbs))
666 - (xfact * (*(ckt->CKTstate2 + here->B4SOIvdbs)));
667 *(ckt->CKTstate0 + here->B4SOIvdbd) =
668 *(ckt->CKTstate0 + here->B4SOIvdbs)
669 - *(ckt->CKTstate0 + here->B4SOIvds);
670 *(ckt->CKTstate0 + here->B4SOIvsbs) =
671 *(ckt->CKTstate1 + here->B4SOIvsbs);
672 vsbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvsbs))
673 - (xfact * (*(ckt->CKTstate2 + here->B4SOIvsbs)));
674 *(ckt->CKTstate0 + here->B4SOIvses) =
675 *(ckt->CKTstate1 + here->B4SOIvses);
676 vses = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvses))
677 - (xfact * (*(ckt->CKTstate2 + here->B4SOIvses)));
678 *(ckt->CKTstate0 + here->B4SOIvdes) =
679 *(ckt->CKTstate1 + here->B4SOIvdes);
680 vdes = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvdes))
681 - (xfact * (*(ckt->CKTstate2 + here->B4SOIvdes)));
682 /* v4.0 end */
683
684 *(ckt->CKTstate0 + here->B4SOIvg) = *(ckt->CKTstate1 + here->B4SOIvg);
685 *(ckt->CKTstate0 + here->B4SOIvd) = *(ckt->CKTstate1 + here->B4SOIvd);
686 *(ckt->CKTstate0 + here->B4SOIvs) = *(ckt->CKTstate1 + here->B4SOIvs);
687 *(ckt->CKTstate0 + here->B4SOIvp) = *(ckt->CKTstate1 + here->B4SOIvp);
688 *(ckt->CKTstate0 + here->B4SOIve) = *(ckt->CKTstate1 + here->B4SOIve);
689
690 /* v3.1 added for RF */
691 *(ckt->CKTstate0 + here->B4SOIvgge) = *(ckt->CKTstate1 + here->B4SOIvgge);
692 *(ckt->CKTstate0 + here->B4SOIvggm) = *(ckt->CKTstate1 + here->B4SOIvggm);
693 *(ckt->CKTstate0 + here->B4SOIvges) =
694 *(ckt->CKTstate1 + here->B4SOIvges);
695 vges = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvges))
696 - (xfact * (*(ckt->CKTstate2 + here->B4SOIvges)));
697 *(ckt->CKTstate0 + here->B4SOIvgms) =
698 *(ckt->CKTstate1 + here->B4SOIvgms);
699 vgms = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvgms))
700 - (xfact * (*(ckt->CKTstate2 + here->B4SOIvgms)));
701 /* v3.1 added for RF end */
702
703 /* Only predict ve */
704 ve = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIve))
705 - (xfact * (*(ckt->CKTstate2 + here->B4SOIve)));
706 /* Then update vg, vs, vb, vd, vp base on ve */
707 vs = ve - model->B4SOItype * ves;
708 vg = model->B4SOItype * vgs + vs;
709 vd = model->B4SOItype * vds + vs;
710 vb = model->B4SOItype * vbs + vs;
711 vp = model->B4SOItype * vps + vs;
712
713 vgge = model->B4SOItype * vges + vs; /* v3.1 */
714 vggm = model->B4SOItype * vgms + vs; /* v3.1 */
715
716 delTemp = (1.0 + xfact)* (*(ckt->CKTstate1 +
717 here->B4SOIdeltemp))-(xfact * (*(ckt->CKTstate2 +
718 here->B4SOIdeltemp)));
719
720 /* v2.2.3 bug fix */
721 *(ckt->CKTstate0 + here->B4SOIdeltemp) =
722 *(ckt->CKTstate1 + here->B4SOIdeltemp);
723
724 /* if (selfheat)
725 {
726 here->B4SOIphi = 2.0 * here->B4SOIvtm
727 * log(pParam->B4SOInpeak /
728 here->B4SOIni);
729 } v4.2 bugfix never used in the code */
730
731 }
732 else
733 {
734 #endif /* PREDICTOR */
735
736 vg = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIgNode),
737 *(ckt->CKTstate0 + here->B4SOIvg), 3.0, &Check);
738 vd = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIdNodePrime),
739 *(ckt->CKTstate0 + here->B4SOIvd), 3.0, &Check);
740 vs = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIsNodePrime),
741 *(ckt->CKTstate0 + here->B4SOIvs), 3.0, &Check);
742 vp = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIpNode),
743 *(ckt->CKTstate0 + here->B4SOIvp), 3.0, &Check);
744 ve = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIeNode),
745 *(ckt->CKTstate0 + here->B4SOIve), 3.0, &Check);
746 /* v3.1 added for RF */
747 vgge = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIgNodeExt),
748 *(ckt->CKTstate0 + here->B4SOIvgge), 3.0, &Check);
749
750 vggm = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIgNodeMid),
751 *(ckt->CKTstate0 + here->B4SOIvggm), 3.0, &Check);
752 /* v3.1 added for RF end */
753
754 delTemp = *(ckt->CKTrhsOld + here->B4SOItempNode);
755
756 vbs = model->B4SOItype * (*(ckt->CKTrhsOld+here->B4SOIbNode)
757 - *(ckt->CKTrhsOld+here->B4SOIsNodePrime));
758
759 vps = model->B4SOItype * (vp - vs);
760 vgs = model->B4SOItype * (vg - vs);
761 ves = model->B4SOItype * (ve - vs);
762 vds = model->B4SOItype * (vd - vs);
763
764 vges = model->B4SOItype * (vgge - vs); /* v3.1 */
765 vgms = model->B4SOItype * (vggm - vs); /* v3.1 */
766
767 /* v4.0 */
768 vdbs = model->B4SOItype
769 * (*(ckt->CKTrhsOld + here->B4SOIdbNode)
770 - *(ckt->CKTrhsOld + here->B4SOIsNodePrime));
771 vsbs = model->B4SOItype
772 * (*(ckt->CKTrhsOld + here->B4SOIsbNode)
773 - *(ckt->CKTrhsOld + here->B4SOIsNodePrime));
774 vses = model->B4SOItype
775 * (*(ckt->CKTrhsOld + here->B4SOIsNode)
776 - *(ckt->CKTrhsOld + here->B4SOIsNodePrime));
777 vdes = model->B4SOItype
778 * (*(ckt->CKTrhsOld + here->B4SOIdNode)
779 - *(ckt->CKTrhsOld + here->B4SOIsNodePrime));
780 /* v4.0 end */
781
782 #ifndef PREDICTOR
783 }
784 #endif /* PREDICTOR */
785
786 vbd = vbs - vds;
787 vdbd = vdbs - vds; /* v4.0 */
788
789 vgd = vgs - vds;
790 ved = ves - vds;
791 vgdo = *(ckt->CKTstate0 + here->B4SOIvgs)
792 - *(ckt->CKTstate0 + here->B4SOIvds);
793 vedo = *(ckt->CKTstate0 + here->B4SOIves)
794 - *(ckt->CKTstate0 + here->B4SOIvds);
795
796 /* v3.1 for RF */
797 vgedo = *(ckt->CKTstate0 + here->B4SOIvges)
798 - *(ckt->CKTstate0 + here->B4SOIvds);
799 vgmdo = *(ckt->CKTstate0 + here->B4SOIvgms)
800 - *(ckt->CKTstate0 + here->B4SOIvds);
801 vged = vges - vds;
802 vgmd = vgms - vds;
803 delvged = vged - vgedo;
804 delvgmd = vgmd - vgmdo;
805 /* v3.1 for RF end*/
806
807 delvbs = vbs - *(ckt->CKTstate0 + here->B4SOIvbs);
808 delvbd = vbd - *(ckt->CKTstate0 + here->B4SOIvbd);
809 delvgs = vgs - *(ckt->CKTstate0 + here->B4SOIvgs);
810 delves = ves - *(ckt->CKTstate0 + here->B4SOIves);
811 delvps = vps - *(ckt->CKTstate0 + here->B4SOIvps);
812 deldelTemp = delTemp - *(ckt->CKTstate0 + here->B4SOIdeltemp);
813 delvds = vds - *(ckt->CKTstate0 + here->B4SOIvds);
814 delvgd = vgd - vgdo;
815 delved = ved - vedo;
816 delvges = vges - *(ckt->CKTstate0 + here->B4SOIvges); /* v3.1 */
817 delvgms = vgms - *(ckt->CKTstate0 + here->B4SOIvgms); /* v3.1 */
818 delvdbd = vdbd - *(ckt->CKTstate0 + here->B4SOIvdbd); /* v4.0 */
819 delvdbs = vdbs - *(ckt->CKTstate0 + here->B4SOIvdbs); /* v4.0 */
820 delvsbs = vsbs - *(ckt->CKTstate0 + here->B4SOIvsbs); /* v4.0 */
821
822 delvbd_jct = (!here->B4SOIrbodyMod) ? delvbd : delvdbd; /*v4.0*/
823 delvbs_jct = (!here->B4SOIrbodyMod) ? delvbs : delvsbs; /*v4.0*/
824
825 delvses = vses - *(ckt->CKTstate0 + here->B4SOIvses);/*v4.0*/
826 vdedo = *(ckt->CKTstate0 + here->B4SOIvdes)
827 - *(ckt->CKTstate0 + here->B4SOIvds); /* v4.0 */
828 delvdes = vdes - *(ckt->CKTstate0 + here->B4SOIvdes); /* v4.0 */
829 delvded = vdes - vds - vdedo; /* v4.0 */
830
831 if (here->B4SOImode >= 0)
832 {
833 cdhat = here->B4SOIcd
834 + (here->B4SOIgm-here->B4SOIgjdg) * delvgs
835 + (here->B4SOIgds - here->B4SOIgjdd) * delvds
836 + (here->B4SOIgmbs * delvbs
837 - here->B4SOIgjdb * delvbs_jct ) /* v4.0 */
838 + (here->B4SOIgme - here->B4SOIgjde) * delves
839 + (here->B4SOIgmT - here->B4SOIgjdT) * deldelTemp; /* v3.0 */
840 }
841 else
842 {
843 cdhat = here->B4SOIcd
844 + (here->B4SOIgm-here->B4SOIgjdg) * delvgd
845 - (here->B4SOIgds - here->B4SOIgjdd) * delvds
846 + (here->B4SOIgmbs * delvbd
847 - here->B4SOIgjdb * delvbd_jct ) /*v4.0 */
848 + (here->B4SOIgme - here->B4SOIgjde) * delved
849 + (here->B4SOIgmT - here->B4SOIgjdT) * deldelTemp; /* v3.0 */
850
851 }
852 cbhat = here->B4SOIcb + here->B4SOIgbgs * delvgs
853 + here->B4SOIgbbs * delvbs
854 + here->B4SOIgbds * delvds
855 + here->B4SOIgbes * delves
856 + here->B4SOIgbps * delvps
857 + here->B4SOIgbT * deldelTemp; /* v3.0 */
858
859 Isestot = here->B4SOIgstot * (*(ckt->CKTstate0 + here->B4SOIvses));
860 cseshat = Isestot + here->B4SOIgstot * delvses
861 + here->B4SOIgstotd * delvds + here->B4SOIgstotg * delvgs
862 + here->B4SOIgstotb * delvbs;
863
864 Idedtot = here->B4SOIgdtot * vdedo;
865 cdedhat = Idedtot + here->B4SOIgdtot * delvded
866 + here->B4SOIgdtotd * delvds + here->B4SOIgdtotg * delvgs
867 + here->B4SOIgdtotb * delvbs;
868
869 #ifndef NOBYPASS
870 /* following should be one big if connected by && all over
871 * the place, but some C compilers can't handle that, so
872 * we split it up here to let them digest it in stages
873 */
874
875 if ((!(ckt->CKTmode & MODEINITPRED)) && (ckt->CKTbypass) && Check == 0)
876 if ((here->B4SOIsoiMod == 2) || /* v3.2 */
877 (fabs(delvbs) < (ckt->CKTreltol * MAX(fabs(vbs),
878 fabs(*(ckt->CKTstate0+here->B4SOIvbs))) + ckt->CKTvoltTol)) )
879 if ((here->B4SOIsoiMod == 2) || /* v3.2 */
880 (fabs(delvbd) < (ckt->CKTreltol * MAX(fabs(vbd),
881 fabs(*(ckt->CKTstate0+here->B4SOIvbd))) + ckt->CKTvoltTol)) )
882 if ((fabs(delvgs) < (ckt->CKTreltol * MAX(fabs(vgs),
883 fabs(*(ckt->CKTstate0+here->B4SOIvgs))) + ckt->CKTvoltTol)))
884 if ((fabs(delves) < (ckt->CKTreltol * MAX(fabs(ves),
885 fabs(*(ckt->CKTstate0+here->B4SOIves))) + ckt->CKTvoltTol)))
886 if ( (here->B4SOIbodyMod == 0) || (here->B4SOIbodyMod == 2) ||
887 (fabs(delvps) < (ckt->CKTreltol * MAX(fabs(vps),
888 fabs(*(ckt->CKTstate0+here->B4SOIvps))) + ckt->CKTvoltTol)) )
889 if ( (here->B4SOItempNode == 0) ||
890 (fabs(deldelTemp) < (ckt->CKTreltol * MAX(fabs(delTemp),
891 fabs(*(ckt->CKTstate0+here->B4SOIdeltemp)))
892 + ckt->CKTvoltTol*1e4)))
893
894 /* v3.1 added for RF */
895 if ((here->B4SOIrgateMod == 0) || (here->B4SOIrgateMod == 1)
896 || (fabs(delvges) < (ckt->CKTreltol * MAX(fabs(vges),
897 fabs(*(ckt->CKTstate0 + here->B4SOIvges))) + ckt->CKTvoltTol)))
898 if ((here->B4SOIrgateMod != 3) || (fabs(delvgms) < (ckt->CKTreltol
899 * MAX(fabs(vgms), fabs(*(ckt->CKTstate0 + here->B4SOIvgms)))
900 + ckt->CKTvoltTol)))
901 /* v3.1 added for RF end */
902 /* v4.0 */
903 if ((!here->B4SOIrbodyMod) || (fabs(delvdbs) < (ckt->CKTreltol
904 * MAX(fabs(vdbs), fabs(*(ckt->CKTstate0 + here->B4SOIvdbs)))
905 + ckt->CKTvoltTol)))
906 if ((!here->B4SOIrbodyMod) || (fabs(delvdbd) < (ckt->CKTreltol
907 * MAX(fabs(vdbd), fabs(*(ckt->CKTstate0 + here->B4SOIvdbd)))
908 + ckt->CKTvoltTol)))
909 if ((!here->B4SOIrbodyMod) || (fabs(delvsbs) < (ckt->CKTreltol
910 * MAX(fabs(vsbs), fabs(*(ckt->CKTstate0 + here->B4SOIvsbs)))
911 + ckt->CKTvoltTol)))
912 if ((!model->B4SOIrdsMod) || (fabs(delvses) < (ckt->CKTreltol
913 * MAX(fabs(vses), fabs(*(ckt->CKTstate0 + here->B4SOIvses)))
914 + ckt->CKTvoltTol)))
915 if ((!model->B4SOIrdsMod) || (fabs(delvdes) < (ckt->CKTreltol
916 * MAX(fabs(vdes), fabs(*(ckt->CKTstate0 + here->B4SOIvdes)))
917 + ckt->CKTvoltTol)))
918 if ((!model->B4SOIrdsMod) || ((fabs(cseshat - Isestot) < ckt->CKTreltol
919 * MAX(fabs(cseshat), fabs(Isestot)) + ckt->CKTabstol)))
920 if ((!model->B4SOIrdsMod) || ((fabs(cdedhat - Idedtot) < ckt->CKTreltol
921 * MAX(fabs(cdedhat), fabs(Idedtot)) + ckt->CKTabstol)))
922 /* v4.0 end */
923
924 if ((fabs(delvds) < (ckt->CKTreltol * MAX(fabs(vds),
925 fabs(*(ckt->CKTstate0+here->B4SOIvds))) + ckt->CKTvoltTol)))
926 if ((fabs(cdhat - here->B4SOIcd) < ckt->CKTreltol
927 * MAX(fabs(cdhat),fabs(here->B4SOIcd)) + ckt->CKTabstol))
928 if ((here->B4SOIsoiMod == 2) || /* v3.2 */
929 (fabs(cbhat - here->B4SOIcb) < ckt->CKTreltol
930 * MAX(fabs(cbhat),fabs(here->B4SOIcb)) + ckt->CKTabstol) )
931 { /* bypass code */
932 vbs = *(ckt->CKTstate0 + here->B4SOIvbs);
933 vbd = *(ckt->CKTstate0 + here->B4SOIvbd);
934 vgs = *(ckt->CKTstate0 + here->B4SOIvgs);
935 ves = *(ckt->CKTstate0 + here->B4SOIves);
936 vps = *(ckt->CKTstate0 + here->B4SOIvps);
937 vds = *(ckt->CKTstate0 + here->B4SOIvds);
938
939 /* v3.1 added for RF */
940 vges = *(ckt->CKTstate0 + here->B4SOIvges);
941 vgms = *(ckt->CKTstate0 + here->B4SOIvgms);
942 vged = vges - vds;
943 vgmd = vgms - vds;
944 vgme = vgms - ves;
945 /* v3.1 added for RF end */
946 vgmb = vgms - vbs; /* v3.2 bug fix */
947
948 /* v4.0 */
949 vdbs = *(ckt->CKTstate0 + here->B4SOIvdbs);
950 vdbd = *(ckt->CKTstate0 + here->B4SOIvdbd);
951 vsbs = *(ckt->CKTstate0 + here->B4SOIvsbs);
952 vbs_jct = (!here->B4SOIrbodyMod) ? vbs : vsbs;
953 vbd_jct = (!here->B4SOIrbodyMod) ? vbd : vdbd;
954 vses = *(ckt->CKTstate0 + here->B4SOIvses);
955 vdes = *(ckt->CKTstate0 + here->B4SOIvdes);
956 /* v4.0 end */
957
958 delTemp = *(ckt->CKTstate0 + here->B4SOIdeltemp);
959 /* calculate Vds for temperature conductance calculation
960 in bypass (used later when filling Temp node matrix) */
961 Vds = here->B4SOImode > 0 ? vds : -vds;
962
963 vgd = vgs - vds;
964 vgb = vgs - vbs;
965 veb = ves - vbs;
966
967 if ((ckt->CKTmode & (MODETRAN | MODEAC)) ||
968 ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)))
969 { ByPass = 1;
970 goto line755;
971 }
972 else
973 { goto line850;
974 }
975 }
976
977 #endif /*NOBYPASS*/
978 von = here->B4SOIvon;
979
980
981 if (*(ckt->CKTstate0 + here->B4SOIvds) >= 0.0)
982 { T0 = *(ckt->CKTstate0 + here->B4SOIvbs);
983
984 /* v3.1 added for RF */
985 if (here->B4SOIrgateMod == 3)
986 {
987 vged = vges - vds;
988 vgmd = vgms - vds;
989 }
990 else if ((here->B4SOIrgateMod == 1) || (here->B4SOIrgateMod == 2))
991 {
992 vged = vges - vds;
993 }
994 /* v3.1 added for RF end*/
995
996 }
997 else
998 { T0 = *(ckt->CKTstate0 + here->B4SOIvbd);
999
1000 /* added for RF */
1001 if (here->B4SOIrgateMod == 3)
1002 {
1003 vges = vged + vds;
1004 vgms = vgmd + vds;
1005 }
1006 if ((here->B4SOIrgateMod == 1) || (here->B4SOIrgateMod == 2))
1007 {
1008 vges = vged + vds;
1009 }
1010 /* added for RF end*/
1011
1012 }
1013
1014 if (vds >= 0.0)
1015 {
1016 vbs = B4SOIlimit(vbs, T0, 0.2, &Check);
1017 vbd = vbs - vds;
1018 vb = model->B4SOItype * vbs + vs;
1019
1020 if (here->B4SOIrbodyMod) /* v4.0 */
1021 { vdbs = B4SOIlimit(vdbs,
1022 *(ckt->CKTstate0 + here->B4SOIvdbs), 0.2, &Check);
1023 vdbd = vdbs - vds;
1024 vsbs = B4SOIlimit(vsbs,
1025 *(ckt->CKTstate0 + here->B4SOIvsbs), 0.2, &Check);
1026 }
1027 }
1028 else
1029 {
1030 vbd = B4SOIlimit(vbd, T0, 0.2, &Check);
1031 vbs = vbd + vds;
1032 vb = model->B4SOItype * vbs + vd;
1033 /* v4.0 */
1034 if (here->B4SOIrbodyMod)
1035 { vdbd = B4SOIlimit(vdbd,
1036 *(ckt->CKTstate0 + here->B4SOIvdbd), 0.2, &Check);
1037 vdbs = vdbd + vds;
1038 vsbdo = *(ckt->CKTstate0 + here->B4SOIvsbs)
1039 - *(ckt->CKTstate0 + here->B4SOIvds);
1040 vsbd = vsbs - vds;
1041 vsbd = B4SOIlimit(vsbd, vsbdo, 0.2, &Check);
1042 vsbs = vsbd + vds;
1043 }
1044 /* v4.0 end */
1045 }
1046
1047 delTemp =B4SOIlimit(delTemp,
1048 *(ckt->CKTstate0 + here->B4SOIdeltemp),5.0,&Check);
1049
1050 }
1051
1052 if(model->B4SOImtrlMod)
1053 {
1054 epsrox = 3.9;
1055 toxe = model->B4SOIeot;
1056 epssub = EPS0 * model->B4SOIepsrsub;
1057 /* bugfix following constants should be replaced with model params -Tanvir */
1058 eggbcp2 = 1.12;
1059 eggdep = 1.12;
1060 agb1 = 3.7622e-7;
1061 bgb1 = -3.1051e10;
1062 agb2 = 4.9758e-7;
1063 bgb2 = -2.357e10;
1064 agbc2n = 3.42537e-7;
1065 agbc2p = 4.97232e-7;
1066 bgbc2n = 1.16645e12;
1067 bgbc2p = 7.45669e11;
1068 }
1069 else
1070 {
1071 epsrox = model->B4SOIepsrox;
1072 toxe = model->B4SOItox;
1073 epssub = EPSSI;
1074 /* bugfix v4.3.1 following constants are valid for mtrlMod=0 -Tanvir */
1075 eggbcp2 = 1.12;
1076 eggdep = 1.12;
1077 agb1 = 3.7622e-7;
1078 bgb1 = -3.1051e10;
1079 agb2 = 4.9758e-7;
1080 bgb2 = -2.357e10;
1081 agbc2n = 3.42537e-7;
1082 agbc2p = 4.97232e-7;
1083 bgbc2n = 1.16645e12;
1084 bgbc2p = 7.45669e11;
1085 }
1086
1087
1088 /* Calculate temperature dependent values for self-heating effect */
1089 Temp = delTemp + ckt->CKTtemp;
1090 dTempRatio_dT = 1 / model->B4SOItnom;
1091 TempRatio = Temp * dTempRatio_dT;
1092 here->B4SOITempSH = Temp; /*v4.2 added for portability of SH Temp */
1093 dEg_dT = 0.0; /* new line Wagner */
1094 Vtm00= 0.026; /* v4.3.1 Vtm00 replaces hardcoded 0.026 -Tanvir */
1095 if (selfheat) {
1096 if(model->B4SOImtrlMod==0)
1097 {
1098 Vtm = KboQ * Temp;
1099
1100 T0 = 1108.0 + Temp;
1101 T5 = Temp * Temp;
1102 Eg = 1.16 - 7.02e-4 * T5 / T0;
1103
1104 dEg_dT = T1 = ((7.02e-4 * T5) - T0 * (14.04e-4 * Temp)) / T0 / T0; /* enhanced line Wagner */
1105 /* T1 = dEg / dT */
1106
1107 T2 = 1.9230584e-4; /* T2 = 1 / 300.15^(3/2) */
1108 T5 = sqrt(Temp);
1109 T3 = 1.45e10 * Temp * T5 * T2;
1110 T4 = exp(21.5565981 - Eg / (2.0 * Vtm));
1111 ni = T3 * T4;
1112 dni_dT = 2.175e10 * T2 * T5 * T4 + T3 * T4 *
1113 (-Vtm * T1 + Eg * KboQ) / (2.0 * Vtm * Vtm);
1114
1115 T0 = log(1.0e20 * pParam->B4SOInpeak / (ni * ni));
1116 vbi = Vtm * T0;
1117 dvbi_dT = KboQ * T0 + Vtm * (-2.0 * dni_dT / ni);
1118 }
1119 else
1120 {
1121 Tnom = model->B4SOItnom;
1122 Vtm = KboQ * Temp;
1123 Vtm0= KboQ * Tnom;
1124
1125 Eg0 = model->B4SOIeg0;
1126 T0 = model->B4SOItbgbsub + Temp;
1127 T5 = Temp * Temp;
1128 Eg = model->B4SOIbg0sub - model->B4SOItbgasub * Temp * Temp
1129 / (Temp + model->B4SOItbgbsub);
1130
1131 dEg_dT = T1 = ((model->B4SOItbgasub * T5) - T0 * (2.0*model->B4SOItbgasub * Temp)) / T0 / T0; /* enhanced line Wagner */
1132 /* T1 = dEg / dT */
1133
1134 T2 = 1/sqrt(Tnom*Tnom*Tnom);
1135 T5 = sqrt(Temp);
1136 T3 = model->B4SOIni0sub * Temp * T5 * T2;
1137 T4 = exp(Eg0/(2.0*Vtm0) - Eg / (2.0 * Vtm));
1138 ni = T3 * T4;
1139 dni_dT=1.5*model->B4SOIni0sub*T5*T2*T4+
1140 T3*T4*(-Vtm * T1 + Eg * KboQ) / (2.0 * Vtm * Vtm);
1141
1142 T0 = log(1.0e20 * pParam->B4SOInpeak / (ni * ni));
1143 vbi = Vtm * T0;
1144 dvbi_dT = KboQ * T0 + Vtm * (-2.0 * dni_dT / ni);
1145
1146
1147 }
1148 if (pParam->B4SOInsub > 0) {
1149 T0 = log(pParam->B4SOInpeak / pParam->B4SOInsub);
1150 vfbb = -model->B4SOItype * Vtm * T0;
1151 dvfbb_dT = -model->B4SOItype * KboQ * T0;
1152 }
1153 else {
1154 T0 = log(-pParam->B4SOInpeak * pParam->B4SOInsub / ni / ni);
1155 vfbb = -model->B4SOItype * Vtm * T0;
1156 dvfbb_dT = -model->B4SOItype *
1157 (KboQ * T0 - Vtm * 2.0 * dni_dT / ni);
1158 }
1159
1160 /* V4.0 changed phi */
1161 phi = 2.0 * Vtm * log(pParam->B4SOInpeak / ni);
1162 /* phi = here->B4SOIphi; */
1163 sqrtPhi = sqrt(phi);
1164 Xdep0 = sqrt(2.0 * epssub / (Charge_q
1165 * pParam->B4SOInpeak * 1.0e6))
1166 * sqrtPhi;
1167 /* v4.1 SH bug fix */
1168 /* dphi_dT = phi / Vtm * KboQ; v4.2 Temp Derivative bug fix */
1169 dphi_dT = phi / Vtm * KboQ - 2.0 * Vtm * dni_dT / ni;
1170 dsqrtPhi_dT = 0.5 / sqrtPhi * dphi_dT;
1171 dXdep0_dT = Xdep0 / sqrtPhi * dsqrtPhi_dT;
1172
1173 /* cdep0 = sqrt(Charge_q * EPSSI
1174 * pParam->B4SOInpeak * 1.0e6 / 2.0) / sqrtPhi; */ /* Bug fix #2 Jun 09 Body type is generalized for mtrlMod 1*/
1175 cdep0 = sqrt(Charge_q * epssub /* Fix */
1176 * pParam->B4SOInpeak * 1.0e6 / 2.0) / sqrtPhi;
1177 /* fix LHS name - Wagner */
1178 /*dcep0_dT = cdep0 * sqrtPhi * (-1.0) / phi * dsqrtPhi_dT; */
1179 dcdep0_dT = cdep0 * sqrtPhi * (-1.0) / phi * dsqrtPhi_dT;
1180
1181 /* T1 = sqrt(EPSSI / (model->B4SOIepsrox * EPSOX / 3.9) Bug fix #3 Jun 09 Body type is generalized for mtrlMod 1*/
1182 /* * model->B4SOItox * Xdep0); */
1183 T1 = sqrt(epssub / (epsrox * EPS0) /* Fix */
1184 * toxe * Xdep0);
1185 dT1_dT = 0.5 * T1 / Xdep0 * dXdep0_dT;
1186 T0 = exp(-0.5 * pParam->B4SOIdsub * pParam->B4SOIleff / T1);
1187 dT0_dT = T0 * 0.5 * pParam->B4SOIdsub * pParam->B4SOIleff
1188 / T1 / T1 * dT1_dT;
1189 theta0vb0 = (T0 + 2.0 * T0 * T0);
1190 dtheta0vb0_dT = (1.0 + 4.0 * T0) * dT0_dT;
1191 T0 = exp(-0.5 * pParam->B4SOIdrout * pParam->B4SOIleff / T1);
1192 dT0_dT = T0 * 0.5 * pParam->B4SOIdrout * pParam->B4SOIleff
1193 / T1 / T1 * dT1_dT;
1194 T2 = (T0 + 2.0 * T0 * T0);
1195 thetaRout = pParam->B4SOIpdibl1 * T2 + pParam->B4SOIpdibl2;
1196 dthetaRout_dT = pParam->B4SOIpdibl1 * (1.0 + 4.0 * T0) * dT0_dT;
1197 /* Save the values below for phi calculation in B4SOIaccept() */
1198 here->B4SOIvtm = Vtm;
1199 /* here->B4SOIni = ni; v4.2 bugfix never used in the code */
1200
1201 T3 = TempRatio - 1.0;
1202 T8 = 1/ model->B4SOItnom;
1203 T4 = Eg300 / Vtm * T3;
1204 dT4_dT = Eg300 / Vtm / Vtm * (Vtm * T8 - T3 * KboQ);
1205
1206 T7 = pParam->B4SOIxbjt * T4 / pParam->B4SOIndiode;
1207 dT7_dT = pParam->B4SOIxbjt * dT4_dT
1208 / pParam->B4SOIndiode;
1209 DEXP(T7, T0, dT0_dT7);
1210 dT0_dT = dT0_dT7 * dT7_dT;
1211
1212 if (pParam->B4SOIxbjt == pParam->B4SOIxdif) {
1213 T1 = T0;
1214 dT1_dT = dT0_dT;
1215 }
1216 else {
1217 T7 = pParam->B4SOIxdif * T4 / pParam->B4SOIndiode;
1218 dT7_dT = pParam->B4SOIxdif * dT4_dT / pParam->B4SOIndiode;
1219 DEXP(T7, T1, dT1_dT7);
1220 dT1_dT = dT1_dT7 * dT7_dT;
1221 }
1222
1223 T7 = pParam->B4SOIxrec * T4 / pParam->B4SOInrecf0;
1224 dT7_dT = pParam->B4SOIxrec * dT4_dT
1225 / pParam->B4SOInrecf0;
1226 DEXP(T7, T2, dT2_dT7);
1227 dT2_dT = dT2_dT7 * dT7_dT;
1228
1229 /* high level injection */
1230 Ahlis = pParam->B4SOIahli * T0;
1231 dAhlis_dT = pParam->B4SOIahli * dT0_dT;
1232
1233 jbjts = pParam->B4SOIisbjt * T0;
1234 jdifs = pParam->B4SOIisdif * T1;
1235 jrecs = pParam->B4SOIisrec * T2;
1236 djbjts_dT = pParam->B4SOIisbjt * dT0_dT;
1237 djdifs_dT = pParam->B4SOIisdif * dT1_dT;
1238 djrecs_dT = pParam->B4SOIisrec * dT2_dT;
1239
1240 T7 = pParam->B4SOIxtun * T3;
1241 dT7_dT = pParam->B4SOIxtun * T8;
1242 DEXP(T7, T0, dT0_dT7);
1243 dT0_dT = dT0_dT7 * dT7_dT;
1244 jtuns = pParam->B4SOIistun * T0;
1245 djtuns_dT = pParam->B4SOIistun * dT0_dT;
1246
1247 /* drain side */
1248 T7 = pParam->B4SOIxbjt * T4 / pParam->B4SOIndioded;
1249 dT7_dT = pParam->B4SOIxbjt * dT4_dT / pParam->B4SOIndioded;
1250 DEXP(T7, T0, dT0_dT7);
1251 dT0_dT = dT0_dT7 * dT7_dT;
1252
1253 if (pParam->B4SOIxbjt == pParam->B4SOIxdifd) {
1254 T1 = T0;
1255 dT1_dT = dT0_dT;
1256 }
1257 else {
1258 T7 = pParam->B4SOIxdifd * T4 / pParam->B4SOIndioded;
1259 dT7_dT = pParam->B4SOIxdifd * dT4_dT / pParam->B4SOIndioded;
1260 DEXP(T7, T1, dT1_dT7);
1261 dT1_dT = dT1_dT7 * dT7_dT;
1262 }
1263
1264 T7 = pParam->B4SOIxrecd * T4 / pParam->B4SOInrecf0d;
1265 dT7_dT = pParam->B4SOIxrecd * dT4_dT / pParam->B4SOInrecf0d;
1266 DEXP(T7, T2, dT2_dT7);
1267 dT2_dT = dT2_dT7 * dT7_dT;
1268
1269 /* high level injection */
1270 Ahlid = pParam->B4SOIahlid * T0;
1271 dAhlid_dT = pParam->B4SOIahlid * dT0_dT;
1272
1273 jbjtd = pParam->B4SOIidbjt * T0;
1274 jdifd = pParam->B4SOIiddif * T1;
1275
1276 jrecd = pParam->B4SOIidrec * T2;
1277 djbjtd_dT = pParam->B4SOIidbjt * dT0_dT;
1278 djdifd_dT = pParam->B4SOIiddif * dT1_dT;
1279 djrecd_dT = pParam->B4SOIidrec * dT2_dT;
1280
1281 T7 = pParam->B4SOIxtund * T3;
1282 dT7_dT = pParam->B4SOIxtund * T8;
1283 DEXP(T7, T0, dT0_dT7);
1284 dT0_dT = dT0_dT7 * dT7_dT;
1285 jtund = pParam->B4SOIidtun * T0;
1286 djtund_dT = pParam->B4SOIidtun * dT0_dT;
1287
1288
1289 u0temp = pParam->B4SOIu0
1290 * pow(TempRatio, pParam->B4SOIute);
1291 du0temp_dT = pParam->B4SOIu0 * pParam->B4SOIute *
1292 pow(TempRatio, pParam->B4SOIute - 1.0) * T8;
1293 ku0temp = pParam->B4SOIku0 * (1.0
1294 /* + model->B4SOItku0 * TempRatio) + DELTA; v4.2 bugfix */
1295 + model->B4SOItku0 * T3) + DELTA;
1296 dku0temp_dT = pParam->B4SOIku0 * model->B4SOItku0 * T8;
1297 T2 = ku0temp * ku0temp;
1298 T7 = model->B4SOIku0 * pParam->B4SOIinv_od_ref;
1299 rho_ref = T7 / ku0temp;
1300 drho_ref_dT = -T7 / T2 * dku0temp_dT;
1301 T4 = model->B4SOIku0 * here->B4SOIInv_ODeff;
1302 rho = T4 / ku0temp;
1303 drho_dT = -T4 / T2 * dku0temp_dT;
1304 T2 = (1.0 + rho);
1305 T7 = (1.0 + rho_ref);
1306 T0 = T2 / T7;
1307 dT0_dT = (drho_dT * T7 - drho_ref_dT * T2 ) / T7 / T7;
1308 du0temp_dT = T0 * du0temp_dT + u0temp * dT0_dT;
1309 u0temp *= T0;
1310
1311 vsattemp = pParam->B4SOIvsat - pParam->B4SOIat * T3;
1312 dvsattemp_dT = -pParam->B4SOIat * T8;
1313 T2 = (1.0 + here->B4SOIkvsat * rho);
1314 T7 = (1.0 + here->B4SOIkvsat * rho_ref);
1315 T0 = T2 / T7;
1316 dT0_dT = (here->B4SOIkvsat * drho_dT * T7 -
1317 here->B4SOIkvsat * drho_ref_dT * T2)
1318 / T7 / T7;
1319 dvsattemp_dT = dvsattemp_dT * T0 + vsattemp * dT0_dT;
1320 vsattemp *= T0;
1321 here->B4SOIvsattemp = vsattemp;
1322
1323 if (!model->B4SOIrdsMod) {
1324 rds0 = (pParam->B4SOIrdsw + pParam->B4SOIprt * T3)
1325 / pParam->B4SOIrds0denom;
1326 drds0_dT = pParam->B4SOIprt / pParam->B4SOIrds0denom
1327 * T8;
1328 }
1329 else { /* v4.0 */
1330 PowWeffWr = pParam->B4SOIrds0denom * here->B4SOInf;
1331 T10 = pParam->B4SOIprt * T3;
1332
1333 /* External Rd(V) */
1334 T1 = pParam->B4SOIrdw + T10;
1335 T2 = model->B4SOIrdwmin + T10;
1336 rd0 = T1 / PowWeffWr;
1337 rdwmin = T2 / PowWeffWr;
1338 drd0_dT = pParam->B4SOIprt / PowWeffWr * T8;
1339 drdwmin_dT = drd0_dT;
1340
1341 /* External Rs(V) */
1342 T7 = pParam->B4SOIrsw + T10;
1343 T4 = model->B4SOIrswmin + T10;
1344 rs0 = T7 / PowWeffWr;
1345 rswmin = T4 / PowWeffWr;
1346 drs0_dT = drswmin_dT = drd0_dT;
1347 }
1348
1349 ua = pParam->B4SOIuatemp + pParam->B4SOIua1 * T3;
1350 ub = pParam->B4SOIubtemp + pParam->B4SOIub1 * T3;
1351 uc = pParam->B4SOIuctemp + pParam->B4SOIuc1 * T3;
1352 dua_dT = pParam->B4SOIua1 * T8;
1353 dub_dT = pParam->B4SOIub1 * T8;
1354 duc_dT = pParam->B4SOIuc1 * T8;
1355 }
1356 else {
1357 vbi = pParam->B4SOIvbi;
1358 vfbb = pParam->B4SOIvfbb;
1359 phi = pParam->B4SOIphi;
1360 sqrtPhi = pParam->B4SOIsqrtPhi;
1361 Xdep0 = pParam->B4SOIXdep0;
1362 /* Eg = model->B4SOIeg0; */ /* Bug fix #11 Jun 09 'Eg is evaluated at Temp, not Tnom' */
1363 Eg = model->B4SOIeg; /* 'model->B4SOIeg' computed in b4soitemp.c */
1364 /* v4.1 */ /* Since selfheat=0, using Eg from b4soitemp.c*/
1365 cdep0 = pParam->B4SOIcdep0;
1366 theta0vb0 = pParam->B4SOItheta0vb0;
1367 thetaRout = pParam->B4SOIthetaRout;
1368
1369 jbjts = pParam->B4SOIjbjts; /* v4.0 */
1370 jbjtd = pParam->B4SOIjbjtd;
1371 jdifs = pParam->B4SOIjdifs;
1372 jdifd = pParam->B4SOIjdifd;
1373 jrecs = pParam->B4SOIjrecs;
1374 jrecd = pParam->B4SOIjrecd;
1375 jtuns = pParam->B4SOIjtuns;
1376 jtund = pParam->B4SOIjtund;
1377
1378 /* v2.2.2 bug fix */
1379 Ahlis = pParam->B4SOIahli0s;
1380 Ahlid = pParam->B4SOIahli0d;
1381
1382 u0temp = here->B4SOIu0temp;
1383 vsattemp = here->B4SOIvsattemp;
1384 ua = pParam->B4SOIua;
1385 ub = pParam->B4SOIub;
1386 uc = pParam->B4SOIuc;
1387 dni_dT = dvbi_dT = dvfbb_dT = 0.0;
1388 djbjts_dT = djdifs_dT = djrecs_dT = djtuns_dT = 0.0;
1389 djbjtd_dT = djdifd_dT = djrecd_dT = djtund_dT = 0.0;
1390 du0temp_dT = dvsattemp_dT = 0.0;
1391 dua_dT = dub_dT = duc_dT = 0.0;
1392 /* v4.1 */
1393 dphi_dT = dsqrtPhi_dT = dXdep0_dT = 0.0;
1394 dcdep0_dT = dtheta0vb0_dT = dthetaRout_dT = 0.0;
1395
1396 if (!model->B4SOIrdsMod) {
1397 rds0 = pParam->B4SOIrds0;
1398 drds0_dT = 0.0;
1399 }
1400 else {
1401 rd0 = pParam->B4SOIrd0;
1402 rs0 = pParam->B4SOIrs0;
1403 rdwmin = pParam->B4SOIrdwmin;
1404 rswmin = pParam->B4SOIrswmin;
1405 drd0_dT = drs0_dT = drdwmin_dT = drswmin_dT = 0.0;
1406 }
1407 dAhlis_dT = dAhlid_dT = 0;
1408 }
1409
1410 /* TempRatio used for Vth and mobility */
1411 if (selfheat) {
1412 TempRatioMinus1 = Temp / model->B4SOItnom - 1.0;
1413 }
1414 else {
1415 TempRatioMinus1 = ckt->CKTtemp / model->B4SOItnom - 1.0;
1416 }
1417
1418 /* determine DC current and derivatives */
1419 vbd = vbs - vds;
1420 vgd = vgs - vds;
1421 vgb = vgs - vbs;
1422 ved = ves - vds;
1423 veb = ves - vbs;
1424 vge = vgs - ves;
1425 vpd = vps - vds;
1426 vgp = vgs - vps;
1427
1428 /* v3.1 added for RF */
1429 vged = vges - vds;
1430 vgmd = vgms - vds;
1431 vgme = vgms - ves;
1432 /* v3.1 added for RF end */
1433 vgmb = vgms - vbs; /* v3.2 bug fix */
1434
1435 agidl = pParam->B4SOIagidl;
1436 bgidl = pParam->B4SOIbgidl;
1437 cgidl = pParam->B4SOIcgidl;
1438 egidl = pParam->B4SOIegidl;
1439 rgidl = pParam->B4SOIrgidl;
1440 kgidl = pParam->B4SOIkgidl;
1441 fgidl = pParam->B4SOIfgidl;
1442
1443 agisl = pParam->B4SOIagisl;
1444 bgisl = pParam->B4SOIbgisl;
1445 cgisl = pParam->B4SOIcgisl;
1446 egisl = pParam->B4SOIegisl;
1447 rgisl = pParam->B4SOIrgisl;
1448 kgisl = pParam->B4SOIkgisl;
1449 fgisl = pParam->B4SOIfgisl;
1450
1451
1452 if (vds >= 0.0)
1453 { /* normal mode */
1454 here->B4SOImode = 1;
1455 Vds = vds;
1456 Vgs = vgs;
1457 Vbs = vbs;
1458 Vbd = vbd;
1459 Ves = ves;
1460 Vps = vps;
1461 Vsbs = vsbs; /* v4.0 */
1462 Vdbs = vdbs; /* v4.0 */
1463 Vdbd = Vdbs - Vds; /* v4.0 */
1464 Vgd = vgd; /* v4.1 */
1465 wdios = pParam->B4SOIwdios;
1466 wdiod = pParam->B4SOIwdiod;
1467 ndiode = pParam->B4SOIndiode; /* v4.2 bugfix*/
1468 ndioded = pParam->B4SOIndioded; /* v4.2 bugfix*/
1469
1470 nrecf0s = pParam->B4SOInrecf0; /* bugfix_snps start for junction DC part*/
1471 nrecf0d = pParam->B4SOInrecf0d;
1472 nrecr0s = pParam->B4SOInrecr0;
1473 nrecr0d = pParam->B4SOInrecr0d;
1474 vrec0s = pParam->B4SOIvrec0;
1475 vrec0d = pParam->B4SOIvrec0d;
1476 ntuns = pParam->B4SOIntun;
1477 ntund = pParam->B4SOIntund;
1478 vtun0s = pParam->B4SOIvtun0;
1479 vtun0d = pParam->B4SOIvtun0d; /* bugfix_snps end for junction DC part*/
1480 }
1481 else
1482 { /* inverse mode */
1483 here->B4SOImode = -1;
1484 Vds = -vds;
1485 Vgs = vgd;
1486 Vbs = vbd;
1487 Vbd = vbs;
1488 Ves = ved;
1489 Vps = vpd;
1490 Vsbs = vdbd; /* v4.0 */
1491 Vdbd = vsbs; /* v4.0 */
1492 Vdbs = Vdbd + Vds; /* v4.0 */
1493 Vgd = vgs; /* v4.1 */
1494 wdios = pParam->B4SOIwdiod;
1495 wdiod = pParam->B4SOIwdios;
1496 ndiode = pParam->B4SOIndioded; /* v4.2 bugfix*/
1497 ndioded = pParam->B4SOIndiode; /* v4.2 bugfix*/
1498
1499 nrecf0s = pParam->B4SOInrecf0d; /* bugfix_snps start for junction DC part*/
1500 nrecf0d = pParam->B4SOInrecf0;
1501 nrecr0s = pParam->B4SOInrecr0d;
1502 nrecr0d = pParam->B4SOInrecr0;
1503 vrec0s = pParam->B4SOIvrec0d;
1504 vrec0d = pParam->B4SOIvrec0;
1505 ntuns = pParam->B4SOIntund;
1506 ntund = pParam->B4SOIntun;
1507 vtun0s = pParam->B4SOIvtun0d;
1508 vtun0d = pParam->B4SOIvtun0; /* bugfix_snps end for junction DC part*/
1509 }
1510 if( vds < 0.0)
1511 {/*Diode current*/
1512 T0 = jbjts;
1513 T1 = djbjts_dT;
1514 jbjts = jbjtd;
1515 djbjts_dT = djbjtd_dT;
1516 jbjtd = T0;
1517 djbjtd_dT = T1;
1518
1519 T0 = jdifs;
1520 T1 = djdifs_dT;
1521 jdifs = jdifd;
1522 djdifs_dT = djdifd_dT;
1523 jdifd = T0;
1524 djdifd_dT = T1;
1525
1526 T0 = jrecs;
1527 T1 = djrecs_dT;
1528 jrecs = jrecd;
1529 djrecs_dT = djrecd_dT;
1530 jrecd = T0;
1531 djrecd_dT = T1;
1532
1533 T0 = jtuns;
1534 T1 = djtuns_dT;
1535 jtuns = jtund;
1536 djtuns_dT = djtund_dT;
1537 jtund = T0;
1538 djtund_dT = T1;
1539
1540 /*GISL/GIDL*/
1541 T0 = agidl;
1542 agidl = agisl;
1543 agisl = T0;
1544
1545 T0 = bgidl;
1546 bgidl = bgisl;
1547 bgisl = T0;
1548
1549 T0 = cgidl;
1550 cgidl = cgisl;
1551 cgisl = T0;
1552
1553 T0 = egidl;
1554 egidl = egisl;
1555 egisl = T0;
1556
1557 T0 = rgidl;
1558 rgidl = rgisl;
1559 rgisl = T0;
1560
1561 T0 = kgidl;
1562 kgidl = kgisl;
1563 kgisl = T0;
1564
1565 T0 = fgidl;
1566 fgidl = fgisl;
1567 fgisl = T0;
1568
1569 T0 = Ahlis; /* bugfix_snps */
1570 Ahlis = Ahlid; /* bugfix_snps */
1571 Ahlid = T0; /* bugfix_snps */
1572
1573 T0 = dAhlis_dT; /* bugfix_snps */
1574 dAhlis_dT = dAhlid_dT; /* bugfix_snps */
1575 dAhlid_dT = T0; /* bugfix_snps */
1576
1577 }
1578 vbs_jct = (!here->B4SOIrbodyMod) ? Vbs : Vsbs; /* v4.0 */
1579 vbd_jct = (!here->B4SOIrbodyMod) ? Vbd : Vdbd; /* v4.0 */
1580
1581 Vesfb = Ves - vfbb;
1582 Cbox = model->B4SOIcbox;
1583 K1 = pParam->B4SOIk1eff;
1584
1585 ChargeComputationNeeded =
1586 ((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) ||
1587 ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)))
1588 ? 1 : 0;
1589
1590 if (here->B4SOIdebugMod <0)
1591 ChargeComputationNeeded = 1;
1592
1593 #ifdef B4SOI_DEBUG_OUT
1594 ChargeComputationNeeded = 1;
1595 here->B4SOIdebug1 = 0.0;
1596 here->B4SOIdebug2 = 0.0;
1597 here->B4SOIdebug3 = 0.0;
1598 #endif
1599
1600 /* Poly Gate Si Depletion Effect */
1601 T0 = here->B4SOIvfb + phi;
1602 if (model->B4SOImtrlMod==0)
1603 epsgate = epssub;
1604 else
1605 epsgate = model->B4SOIepsrgate * EPS0;
1606
1607 if ((pParam->B4SOIngate > 1.e18) && (pParam->B4SOIngate < 1.e25)
1608 && (Vgs > T0)&& (epsgate!=0))
1609 /* added to avoid the problem caused by ngate */
1610 { T1 = 1.0e6 * Charge_q * epsgate * pParam->B4SOIngate
1611 / (model->B4SOIcox * model->B4SOIcox);
1612 T4 = sqrt(1.0 + 2.0 * (Vgs - T0) / T1);
1613 T2 = T1 * (T4 - 1.0);
1614 T3 = 0.5 * T2 * T2 / T1; /* T3 = Vpoly */
1615 /* T7 = 1.12 - T3 - 0.05; */
1616 T7 = eggdep - T3 - 0.05; /* bugfix: v4.3.1 -Tanvir */
1617 T6 = sqrt(T7 * T7 + 0.224);
1618 /* T5 = 1.12 - 0.5 * (T7 + T6); */
1619 T5 = eggdep - 0.5 * (T7 + T6); /* bugfix: v4.3.1 -Tanvir */
1620 Vgs_eff = Vgs - T5;
1621 dVgs_eff_dVg = 1.0 - (0.5 - 0.5 / T4) * (1.0 + T7 / T6);
1622 /* 7 new lines Wagner */
1623 if (selfheat) {
1624 dTL2_dT = - dphi_dT / T4;
1625 dTL3_dT = T2 * dTL2_dT / T1;
1626 dTL6_dT = - T7 * dTL3_dT / T6;
1627 dVgs_eff_dT = 0.5 * (dTL6_dT - dTL3_dT);
1628 }
1629 else dVgs_eff_dT = 0.0;
1630 }
1631 else
1632 { Vgs_eff = Vgs;
1633 dVgs_eff_dVg = 1.0;
1634 dVgs_eff_dT = 0.0; /* new line Wagner */
1635 }
1636
1637 if ((pParam->B4SOIngate > 1.e18) && (pParam->B4SOIngate < 1.e25)/* Bug fix # 25/26 Vgd_eff defined */
1638 && (Vgd > T0)&& (epsgate!=0))
1639 /* added to avoid the problem caused by ngate */
1640 { T1 = 1.0e6 * Charge_q * epsgate * pParam->B4SOIngate
1641 / (model->B4SOIcox * model->B4SOIcox);
1642 T4 = sqrt(1.0 + 2.0 * (Vgd - T0) / T1);
1643 T2 = T1 * (T4 - 1.0);
1644 T3 = 0.5 * T2 * T2 / T1; /* T3 = Vpoly */
1645 /* T7 = 1.12 - T3 - 0.05; */
1646 T7 = eggdep - T3 - 0.05; /* bugfix: v4.3.1 -Tanvir */
1647 T6 = sqrt(T7 * T7 + 0.224);
1648 /* T5 = 1.12 - 0.5 * (T7 + T6); */
1649 T5 = eggdep - 0.5 * (T7 + T6); /* bugfix: v4.3.1 -Tanvir */
1650 Vgd_eff = Vgd - T5;
1651 dVgd_eff_dVg = 1.0 - (0.5 - 0.5 / T4) * (1.0 + T7 / T6);
1652 /* 7 new lines Wagner */
1653 if (selfheat) {
1654 dTL2_dT = - dphi_dT / T4;
1655 dTL3_dT = T2 * dTL2_dT / T1;
1656 dTL6_dT = - T7 * dTL3_dT / T6;
1657 dVgd_eff_dT = 0.5 * (dTL6_dT - dTL3_dT);
1658 }
1659 else dVgd_eff_dT = 0.0;
1660 }
1661 else
1662 { Vgd_eff = Vgd;
1663 dVgd_eff_dVg = 1.0;
1664 dVgd_eff_dT = 0.0; /* new line Wagner */
1665 }
1666
1667 /* if( here->B4SOImode != 1){
1668 T1=Vgs_eff;
1669 Vgs_eff=Vgd_eff;
1670 Vgd_eff=T1;
1671 T2=dVgs_eff_dVg;
1672 dVgs_eff_dVg=dVgd_eff_dVg;
1673 dVgd_eff_dVg=T2;
1674 } */
1675
1676 /* v4.1 for improved BT charge model, no poly depletion */
1677
1678 Vgs_eff2 = Vgs;
1679 dVgs_eff2_dVg = 1.0;
1680
1681 /* end v4.1 for improved BT charge model */
1682 Leff = pParam->B4SOIleff;
1683
1684 if (selfheat) {
1685 Vtm = KboQ * Temp;
1686 dVtm_dT = KboQ;
1687 }
1688 else {
1689 Vtm = model->B4SOIvtm;
1690 dVtm_dT = 0.0;
1691 }
1692
1693 V0 = vbi - phi;
1694
1695
1696 /* begin of v3.0 block addition */
1697 /* B/S built-in potential lowering calculation */
1698 if (here->B4SOIsoiMod == 0) /* BSIMPD */ /* v3.2 */
1699 {
1700 Vbsmos = Vbs;
1701 dVbsmos_dVg = 0.0;
1702 dVbsmos_dVd = 0.0;
1703 dVbsmos_dVb = 1.0;
1704 dVbsmos_dVe = 0.0;
1705 /* LFW_FD 5 new lines */
1706 dVbs_dVg = 0.0;
1707 dVbs_dVd = 0.0;
1708 dVbs_dVb = 1.0;
1709 dVbs_dVe = 0.0;
1710 dVbs_dT = 0.0;
1711 dVbsmos_dT = 0.0;
1712
1713 Vbp = Vbs - Vps;
1714 dVbp_dVb = 1;
1715 }
1716 else /* soiMod = 1 or 2: adding FD module on top of BSIMPD */
1717 {
1718 /* prepare Vbs0 & Vbs0mos for VthFD calculation */
1719 if (model->B4SOIfdMod == 0) /* v4.0 */
1720 {
1721 T0 = -model->B4SOIdvbd1 * pParam->B4SOIleff / pParam->B4SOIlitl;
1722 T1 = model->B4SOIdvbd0 * (exp(0.5*T0) + 2*exp(T0));
1723 T2 = T1 * (vbi - phi);
1724 T3 = 0.5 * pParam->B4SOIqsi / model->B4SOIcsi; /* v3.2 */
1725 Vbs0t = phi - T3 + model->B4SOIvbsa + T2;
1726 dVbs0t_dVd = 0.0;
1727 dVbs0_dVd = 0.0;
1728 if (selfheat)
1729 /* dVbs0t_dT = T1 * dvbi_dT; */
1730 dVbs0t_dT = (1.0 - T1) * dphi_dT + T1 * dvbi_dT; /* LFW_FD new line */
1731 else
1732 dVbs0t_dT = 0.0;
1733
1734 T0 = 1 + model->B4SOIcsi / Cbox;
1735 T3 = -model->B4SOIdk2b * pParam->B4SOIleff / pParam->B4SOIlitl;
1736 T5 = model->B4SOIk2b * (exp(0.5*T3) + 2*exp(T3));
1737 T1 = (model->B4SOIk1b - T5) / T0;
1738 T2 = T1 * Vesfb;
1739 T4 = 1.0/(1 + Cbox / model->B4SOIcsi);
1740 Vbs0 = T4 * Vbs0t + T2;
1741 dVbs0_dVe = T1;
1742 dVbs0_dVd = 0.0; /* flexilint */
1743 if (selfheat)
1744 dVbs0_dT = T4 * dVbs0t_dT - T1 * dvfbb_dT;
1745 else
1746 dVbs0_dT = 0.0;
1747 }
1748 else
1749 {
1750 T0 = 1.0/(model->B4SOIcsi + Cbox + model->B4SOIcdsbs);
1751 T1 = -model->B4SOIdvbd1 * pParam->B4SOIleff / pParam->B4SOIlitl;
1752 T2 = model->B4SOIdvbd0 * (exp(0.5*T1) + 2*exp(T1));
1753 T3 = T2 * (Vds + model->B4SOIvsce);
1754 T4 = 0.5 * pParam->B4SOIqsi / model->B4SOIcsi;
1755 T5 = model->B4SOIcsi * T0 * (phi - T4 + model->B4SOIvbsa);
1756 T6 = model->B4SOIcdsbs * T0 * T3;
1757 Vbs0t = T5 + T6;
1758 dVbs0t_dVd = model->B4SOIcdsbs * T0 * T2;
1759 if (selfheat)
1760 /* dVbs0t_dT = 0.0; LFW_FD changed line */
1761 dVbs0t_dT = model->B4SOIcsi * T0 * dphi_dT;
1762 else
1763 dVbs0t_dT = 0.0;
1764
1765 T7 = Cbox * T0 * Vesfb;
1766 Vbs0 = Vbs0t + T7;
1767 dVbs0_dVe = Cbox * T0;
1768 dVbs0_dVd = dVbs0t_dVd;
1769 if (selfheat)
1770 dVbs0_dT = dVbs0t_dT - Cbox * T0 * dvfbb_dT;
1771 else
1772 dVbs0_dT = 0.0;
1773
1774 }
1775
1776 /* zero field body potential cal. */
1777 T1 = Vbs0t - Vbs0 - 0.005;
1778 T2 = sqrt(T1 * T1 + (2.5e-5));
1779 T3 = 0.5 * (T1 + T2);
1780 T4 = T3 * model->B4SOIcsi / pParam->B4SOIqsi; /* v3.2 */
1781 Vbs0mos = Vbs0 - 0.5 * T3 * T4;
1782 T5 = 0.5 * T4 * (1 + T1 / T2);
1783 dVbs0mos_dVe = dVbs0_dVe * (1 + T5);
1784 /* dVbs0mos_dVd = dVbs0_dVd + T5 * (dVbs0t_dVd - dVbs0_dVd); LFW_FD */
1785 dVbs0mos_dVd = dVbs0_dVd * (1 + T5) - T5 * dVbs0t_dVd;
1786 if (selfheat)
1787 dVbs0mos_dT = dVbs0_dT * (1 + T5) - T5 * dVbs0t_dT;
1788 else
1789 dVbs0mos_dT = 0.0;
1790
1791
1792 /* set the upperbound of Vbs0mos to be phi for square root calc. */
1793 T1 = phi - 0.02;
1794 T2 = T1 - Vbs0mos - 0.005;
1795 T3 = sqrt(T2 * T2 + 4.0 * 0.005);
1796 Vbs0mos = T1 - 0.5 * (T2 + T3);
1797 T4 = 0.5 * (1 + T2 / T3);
1798 dVbs0mos_dVe = T4 * dVbs0mos_dVe;
1799 dVbs0mos_dVd = T4 * dVbs0mos_dVd; /* v4.1 */
1800 if (selfheat)
1801 /* dVbs0mos_dT = T4 * dVbs0mos_dT; */
1802 dVbs0mos_dT = dphi_dT - T4 * (dphi_dT - dVbs0mos_dT); /* v4.1 */
1803 else dVbs0mos_dT = 0.0;
1804
1805
1806 /* VthFD calculation */
1807 Phis = phi - Vbs0mos;
1808 /* dPhis_dVb = -1; LFW_FD not used */
1809 sqrtPhis = sqrt(Phis);
1810 dsqrtPhis_dVb = -0.5 / sqrtPhis;
1811 Xdep = Xdep0 * sqrtPhis / sqrtPhi;
1812 dXdep_dVb = (Xdep0 / sqrtPhi) * dsqrtPhis_dVb;
1813 /* v4.2 bugfix temp deriv */
1814 if (selfheat) {
1815 dPhis_dT = dphi_dT - dVbs0mos_dT;
1816 dsqrtPhis_dT = 0.5 / sqrtPhis * dPhis_dT;
1817 dXdep_dT = dXdep0_dT * sqrtPhis / sqrtPhi
1818 + Xdep0 * (dsqrtPhis_dT * sqrtPhi - sqrtPhis * dsqrtPhi_dT) / phi;
1819 }
1820 else {
1821 dPhis_dT = 0.0;
1822 dsqrtPhis_dT = 0.0;
1823 dXdep_dT = 0.0;
1824 }/* v4.2 bugfix temp deriv */
1825
1826 T3 = sqrt(Xdep);
1827 T0 = pParam->B4SOIdvt2 * Vbs0mos;
1828 dT3_dT = 1.0 / (2.0 * T3) * dXdep_dT; /* v4.2 bugfix temp deriv */
1829 dT0_dT = pParam->B4SOIdvt2 * dVbs0mos_dT; /* v4.2 bugfix temp deriv */
1830 if (T0 >= - 0.5)
1831 { T1 = 1.0 + T0;
1832 dT1_dT = dT0_dT; /* v4.2 bugfix temp deriv */
1833 T2 = pParam->B4SOIdvt2 ;
1834 }
1835 else /* Added to avoid any discontinuity problems caused by dvt2 */
1836 { T4 = 1.0 / (3.0 + 8.0 * T0);
1837 /* T1 = (1.0 + 3.0 * T0) * T4; */ /* v4.2 bugfix temp deriv */
1838 T5 = 1.0 + 3.0 * T0; /* v4.2 bugfix temp deriv */
1839 T1 = T4 * T5; /* v4.2 bugfix temp deriv */
1840 T2 = pParam->B4SOIdvt2 * T4 * T4 ;
1841 dT1_dT = T4 * (3.0 - 8.0 * T5 * T4) * dT0_dT; /* v4.2 bugfix temp deriv */
1842 }
1843 lt1 = model->B4SOIfactor1 * T3 * T1;
1844 dlt1_dVb =model->B4SOIfactor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2);
1845 dlt1_dT = model->B4SOIfactor1 * ( dT3_dT * T1+ T3 * dT1_dT); /* v4.2 bugfix temp deriv */
1846
1847
1848 T0 = pParam->B4SOIdvt2w * Vbs0mos;
1849 dT0_dT = pParam->B4SOIdvt2w * dVbs0mos_dT; /* v4.2 bugfix temp deriv */
1850 if (T0 >= - 0.5)
1851 { T1 = 1.0 + T0;
1852 T2 = pParam->B4SOIdvt2w ;
1853 dT1_dT = dT0_dT; /* v4.2 bugfix temp deriv */
1854 }
1855 else /* Added to avoid any discontinuity problems caused by dvt2w */
1856 { T4 = 1.0 / (3.0 + 8.0 * T0);
1857 /* T1 = (1.0 + 3.0 * T0) * T4; */ /* v4.2 bugfix temp deriv */
1858 T5 = 1.0 + 3.0 * T0; /* v4.2 bugfix temp deriv */
1859 T1 = T4 * T5; /* v4.2 bugfix temp deriv */
1860 T2 = pParam->B4SOIdvt2w * T4 * T4 ;
1861 dT1_dT=T4*(3.0-8.0*T5*T4)*dT0_dT ; /* v4.2 bugfix temp deriv */
1862 }
1863 ltw= model->B4SOIfactor1 * T3 * T1;
1864 dltw_dVb=model->B4SOIfactor1*(0.5 / T3 * T1 * dXdep_dVb + T3 * T2);
1865
1866 dltw_dT=model->B4SOIfactor1 *( dT3_dT * T1+ T3 *dT1_dT);/* v4.2 bugfix temp deriv */
1867
1868 T0 = -0.5 * pParam->B4SOIdvt1 * Leff / lt1;
1869 if (T0 > -EXPL_THRESHOLD)
1870 { T1 = exp(T0);
1871 Theta0 = T1 * (1.0 + 2.0 * T1);
1872 dT1_dVb = -T0 / lt1 * T1 * dlt1_dVb;
1873 dTheta0_dVb = (1.0 + 4.0 * T1) * dT1_dVb;
1874 dT1_dT = -T0 / lt1 * T1 * dlt1_dT; /* v4.2 bugfix temp deriv */
1875 dTheta0_dT = (1.0 + 4.0 * T1) * dT1_dT; /* v4.2 bugfix temp deriv */
1876 }
1877 else
1878 { T1 = MIN_EXPL;
1879 Theta0 = T1 * (1.0 + 2.0 * T1);
1880 dTheta0_dVb = 0.0;
1881 dTheta0_dT = 0; /* v4.2 bugfix temp deriv */
1882 }
1883
1884 T2 = pParam->B4SOInfactor * epssub / Xdep;
1885 dT2_dVb = - T2 / Xdep * dXdep_dVb;
1886 dT2_dT = - T2 / Xdep * dXdep_dT; /* v4.2 bugfix temp deriv */
1887 /* T3 = pParam->B4SOIcdsc + pParam->B4SOIcdscb * Vbseff
1888 + pParam->B4SOIcdscd * Vds;*/
1889 /* v4.1 */
1890 T3 = pParam->B4SOIcdsc + pParam->B4SOIcdscb * Vbs0mos
1891 + pParam->B4SOIcdscd * Vds;
1892 dT3_dVb = pParam->B4SOIcdscb;
1893 dT3_dVd = pParam->B4SOIcdscd;
1894 T4 = (T2 + T3 * Theta0 + pParam->B4SOIcit)
1895 / model->B4SOIcox;
1896 dT4_dVb = (dT2_dVb + Theta0 * dT3_dVb
1897 + dTheta0_dVb * T3) / model->B4SOIcox;
1898 dT4_dVd = Theta0 * dT3_dVd / model->B4SOIcox;
1899 dT4_dT = (dT2_dT + T3 * dTheta0_dT + pParam->B4SOIcdscb * dVbs0mos_dT * Theta0) / model->B4SOIcox; /* v4.2 bugfix temp deriv */
1900 if (T4 >= -0.5) {
1901 n = 1.0 + T4;
1902 dn_dVb = dT4_dVb;
1903
1904 dn_dVd = dT4_dVd;
1905 dn_dT = dT4_dT; /* v4.2 bugfix temp deriv */
1906 }
1907 else { /* avoid discontinuity problems caused by T4 */
1908 T0 = 1.0 / (3.0 + 8.0 * T4);
1909 /*n = (1.0 + 3.0 * T4) * T0;*/ /* v4.2 bugfix temp deriv */
1910 T5 = 1.0 + 3.0 * T4; /* v4.2 bugfix temp deriv */
1911 n = T0 * T5;/* v4.2 bugfix temp deriv */
1912 T0 *= T0;
1913 dn_dVb = T0 * dT4_dVb;
1914 dn_dVd = T0 * dT4_dVd;
1915 dn_dT = T0 * (3.0 - 8.0 * T5 * T0) * dT4_dT; /* v4.2 bugfix temp deriv */
1916 }
1917
1918 if (pParam->B4SOIdvtp0 > 0.0) { /* v4.0 */
1919 T0 = -pParam->B4SOIdvtp1 * Vds;
1920 if (T0 < -EXPL_THRESHOLD) {
1921 T2 = MIN_EXPL;
1922 dT2_dVd = 0.0;
1923 }
1924 else {
1925 T2 = exp(T0);
1926 dT2_dVd = -pParam->B4SOIdvtp1 * T2;
1927 }
1928
1929 T3 = Leff + pParam->B4SOIdvtp0 * (1.0 + T2);
1930 dT3_dVd = pParam->B4SOIdvtp0 * dT2_dVd;
1931 T4 = Vtm * log(Leff / T3);
1932 dT4_dVd = -Vtm * dT3_dVd / T3;
1933 DITS_Sft = n * T4;
1934 dDITS_Sft_dVd = dn_dVd * T4 + n * dT4_dVd;
1935 dDITS_Sft_dVb = T4 * dn_dVb;
1936 if (selfheat) {
1937 /* dDITS_Sft_dT = n * KboQ * log(Leff / T3); *//* v4.2 bugfix temp deriv */
1938 dDITS_Sft_dT = n * KboQ * log(Leff / T3) + dn_dT * T4; /* v4.2 bugfix temp deriv */
1939 }
1940 else
1941 dDITS_Sft_dT = 0.0;
1942 }
1943 else {
1944 DITS_Sft = dDITS_Sft_dVd = dDITS_Sft_dVb = 0.0;
1945 dDITS_Sft_dT = 0.0;
1946 }
1947
1948 here->B4SOIthetavth = pParam->B4SOIdvt0 * Theta0;
1949 Delt_vth = here->B4SOIthetavth * V0;
1950 dDelt_vth_dVb = pParam->B4SOIdvt0 * dTheta0_dVb * V0;
1951 if (selfheat)
1952 /*dDelt_vth_dT = here->B4SOIthetavth * dvbi_dT;*/
1953 /*dDelt_vth_dT = here->B4SOIthetavth * (dvbi_dT - dphi_dT); */
1954 dDelt_vth_dT = pParam->B4SOIdvt0 * (dTheta0_dT * V0 + Theta0 * (dvbi_dT - dphi_dT)); /* v4.2 bugfix temp deriv */
1955 else dDelt_vth_dT = 0.0;
1956 T0 = -0.5 * pParam->B4SOIdvt1w * pParam->B4SOIweff * Leff / ltw;
1957 if (T0 > -EXPL_THRESHOLD)
1958 { T1 = exp(T0);
1959 T2 = T1 * (1.0 + 2.0 * T1);
1960 dT1_dVb = -T0 / ltw * T1 * dltw_dVb;
1961 dT2_dVb = (1.0 + 4.0 * T1) * dT1_dVb;
1962 dT2_dT = -(1.0 + 4.0 * T1) * T1 * T0/ltw * dltw_dT;
1963 }
1964 else
1965 { T1 = MIN_EXPL;
1966 T2 = T1 * (1.0 + 2.0 * T1);
1967 dT2_dVb = 0.0;
1968 dT2_dT = 0;
1969 }
1970 T0 = pParam->B4SOIdvt0w * T2;
1971 DeltVthw = T0 * V0;
1972 dDeltVthw_dVb = pParam->B4SOIdvt0w * dT2_dVb * V0;
1973 if (selfheat)
1974 /* dDeltVthw_dT = T0 * dvbi_dT; */
1975 /* dDeltVthw_dT = T0 * (dvbi_dT - dphi_dT); v4.1 */ /* v4.2 bugfix temp deriv */
1976 dDeltVthw_dT = T0 * (dvbi_dT - dphi_dT) + pParam->B4SOIdvt0w * dT2_dT * V0; /* v4.2 bugfix temp deriv */
1977 else dDeltVthw_dT = 0.0;
1978
1979 T0 = sqrt(1.0 + pParam->B4SOIlpe0 / Leff);
1980 T1 = (pParam->B4SOIkt1 + pParam->B4SOIkt1l / Leff
1981 + pParam->B4SOIkt2 * Vbs0mos);
1982
1983 /* v4.0 */
1984 /* DeltVthtemp = pParam->B4SOIk1eff * (T0 - 1.0) * sqrtPhi + T1 * TempRatioMinus1; */
1985 DeltVthtemp = pParam->B4SOIk1ox * (T0 - 1.0) * sqrtPhi
1986 + T1 * TempRatioMinus1;
1987 /* v4.0 end */
1988
1989 if (selfheat)
1990 /* dDeltVthtemp_dT = T1 / model->B4SOItnom; */
1991 /* dDeltVthtemp_dT = pParam->B4SOIk1ox * (T0 - 1.0) * dsqrtPhi_dT
1992 + T1 / model->B4SOItnom; v4.1 */ /* v4.2 bugfix temp deriv */
1993 dDeltVthtemp_dT = pParam->B4SOIk1ox * (T0 - 1.0) * dsqrtPhi_dT
1994 + T1 / model-> B4SOItnom+ pParam->B4SOIkt2 * dVbs0mos_dT* TempRatioMinus1;/* v4.2 bugfix temp deriv */
1995 else
1996 dDeltVthtemp_dT = 0.0;
1997
1998 tmp2 = toxe * phi / (pParam->B4SOIweff + pParam->B4SOIw0);
1999 dtmp2_dT = toxe * dphi_dT / (pParam->B4SOIweff + pParam->B4SOIw0); /* v4.2 bugfix temp deriv */
2000 T3 = here->B4SOIeta0 + pParam->B4SOIetab * Vbs0mos;/*v4.0*/
2001 dT3_dT = pParam->B4SOIetab * dVbs0mos_dT; /*v4.2 temp deriv*/
2002 if (T3 < 1.0e-4) /* avoid discontinuity problems caused by etab */
2003 { T9 = 1.0 / (3.0 - 2.0e4 * T3);
2004 T5 = (2.0e-4 - T3); /*v4.2 temp deriv*/
2005 T3 = T5 * T9; /*(2.0e-4 - T3) * T9;*/ /*v4.2 temp deriv*/
2006 T4 = T9 * T9 * pParam->B4SOIetab;
2007 dT3_dVb = T4 ;
2008 dT3_dT = (2.0e4 * T5 * T9 * T9 - T9) * dT3_dT; /*v4.2 temp deriv*/
2009 }
2010 else
2011 {
2012 dT3_dVb = pParam->B4SOIetab ;
2013 }
2014 /* DIBL_Sft = T3 * pParam->B4SOItheta0vb0 * Vds;
2015 dDIBL_Sft_dVd = pParam->B4SOItheta0vb0 * T3;
2016 dDIBL_Sft_dVb = pParam->B4SOItheta0vb0 * Vds * dT3_dVb; */ /* v4.2 bug fix */
2017 DIBL_Sft = T3 * theta0vb0 * Vds;
2018 dDIBL_Sft_dVd = theta0vb0 * T3;
2019 dDIBL_Sft_dVb = theta0vb0 * Vds * dT3_dVb;
2020 dDIBL_Sft_dT = Vds * (dT3_dT * theta0vb0 + T3 * dtheta0vb0_dT); /* v4.2 bug fix */
2021 Lpe_Vb = sqrt(1.0 + pParam->B4SOIlpeb / Leff);
2022
2023 /* 4.1 */
2024 T0 = exp(2.0 * pParam->B4SOIdvtp4 * Vds);
2025 DITS_Sft2 = pParam->B4SOIdvtp2factor * (T0-1) / (T0+1);
2026 dDITS_Sft2_dVd = pParam->B4SOIdvtp2factor * pParam->B4SOIdvtp4 * 4.0 * T0 / ((T0+1) * (T0+1));
2027
2028 VthFD = model->B4SOItype * here->B4SOIvth0
2029 + (pParam->B4SOIk1ox * sqrtPhis
2030 - pParam->B4SOIk1eff * sqrtPhi) * Lpe_Vb
2031 - here->B4SOIk2ox * Vbs0mos- Delt_vth - DeltVthw
2032 + (pParam->B4SOIk3 + pParam->B4SOIk3b * Vbs0mos)
2033 * tmp2 + DeltVthtemp - DIBL_Sft - DITS_Sft - DITS_Sft2;
2034
2035
2036 T6 = pParam->B4SOIk3b * tmp2 - here->B4SOIk2ox
2037 + pParam->B4SOIkt2 * TempRatioMinus1;
2038 dVthFD_dVb = Lpe_Vb * pParam->B4SOIk1ox * dsqrtPhis_dVb
2039 - dDelt_vth_dVb - dDeltVthw_dVb
2040 + T6 - dDIBL_Sft_dVb - dDITS_Sft_dVb; /* v4.0 */
2041 /* this is actually dVth_dVbs0mos */
2042
2043 dVthFD_dVe = dVthFD_dVb * dVbs0mos_dVe;
2044 /* dVthFD_dVd = -dDIBL_Sft_dVd -dDITS_Sft_dVd; */ /* v4.0 */
2045 dVthFD_dVd = dVthFD_dVb * dVbs0mos_dVd - dDIBL_Sft_dVd - dDITS_Sft_dVd - dDITS_Sft2_dVd; /* v4.1 */
2046
2047 if (selfheat)
2048 /* dVthFD_dT = dDeltVthtemp_dT - dDelt_vth_dT
2049 - dDeltVthw_dT + dVthFD_dVb * dVbs0mos_dT
2050 - dDITS_Sft_dT ; */
2051 /* dVthFD_dT = dDeltVthtemp_dT - dDelt_vth_dT
2052 - dDeltVthw_dT + dVthFD_dVb * dVbs0mos_dT
2053 - dDITS_Sft_dT
2054 + Lpe_Vb * ( pParam->B4SOIk1ox * 0.5 / sqrtPhis * dphi_dT
2055 - pParam->B4SOIk1eff * dsqrtPhi_dT); v4.1 */
2056 /* LFW_FD fixed expression */
2057 dVthFD_dT = (pParam->B4SOIk1ox * dsqrtPhis_dT - pParam->B4SOIk1eff * dsqrtPhi_dT) * Lpe_Vb
2058 - here->B4SOIk2ox * dVbs0mos_dT - dDelt_vth_dT - dDeltVthw_dT
2059 + pParam->B4SOIk3b * dVbs0mos_dT * tmp2
2060 + (pParam->B4SOIk3 + pParam->B4SOIk3b * Vbs0mos) * dtmp2_dT
2061 + dDeltVthtemp_dT - dDIBL_Sft_dT - dDITS_Sft_dT;
2062
2063 else dVthFD_dT = 0.0;
2064
2065
2066 /* VtgseffFD calculation for PhiFD */
2067 VtgsFD = VthFD - Vgs_eff;
2068 T10 = model->B4SOInofffd * Vtm;
2069 DEXP( ((VtgsFD - model->B4SOIvofffd)/ T10), ExpVtgsFD, T0);
2070 VtgseffFD = T10 * log(1.0 + ExpVtgsFD);
2071 T0 /= (1.0 + ExpVtgsFD);
2072 dVtgseffFD_dVd = T0 * dVthFD_dVd;
2073 dVtgseffFD_dVg = -T0 * dVgs_eff_dVg;
2074 dVtgseffFD_dVe = T0 * dVthFD_dVe;
2075 if (selfheat)
2076 /* fix below 1st line of expression - Wagner */
2077 /*dVtgseffFD_dT = T0 * (dVthFD_dT - (VtgsFD - model->B4SOIvofffd)/Temp) */
2078 dVtgseffFD_dT = T0 * (dVthFD_dT - dVgs_eff_dT - (VtgsFD - model->B4SOIvofffd)/Temp)
2079 + VtgseffFD/Temp;
2080 else dVtgseffFD_dT = 0.0;
2081
2082
2083 /* surface potential modeling at strong inversion: PhiON */
2084 VgstFD = Vgs_eff - VthFD;
2085 DEXP( ((VgstFD - model->B4SOIvofffd)/ T10), ExpVgstFD, T0);
2086 VgsteffFD = T10 * log(1.0 + ExpVgstFD);
2087 T0 /= (1.0 + ExpVgstFD);
2088 dVgsteffFD_dVd = -T0 * dVthFD_dVd;
2089 dVgsteffFD_dVg = T0 * dVgs_eff_dVg;
2090 dVgsteffFD_dVe = -T0 * dVthFD_dVe;
2091 if (selfheat)
2092 /* fix below 1st line of expression - Wagner */
2093 /*dVgsteffFD_dT = T0 * (-dVthFD_dT */
2094 dVgsteffFD_dT = T0 * (dVgs_eff_dT - dVthFD_dT
2095 - (VgstFD - model->B4SOIvofffd)/Temp)
2096 + VgsteffFD/Temp;
2097 else dVgsteffFD_dT = 0.0;
2098
2099
2100 /* T1 = model->B4SOImoinFD*pParam->B4SOIk1eff*Vtm*Vtm; */
2101 T1 = model->B4SOImoinFD*pParam->B4SOIk1ox*Vtm*Vtm;
2102 if (selfheat) dT1_dT = 2*T1/Temp;
2103 else dT1_dT=0.0;
2104
2105 T2 = VgsteffFD+ 2*pParam->B4SOIk1eff*sqrt(phi);
2106 dT2_dVg = dVgsteffFD_dVg;
2107 dT2_dVd = dVgsteffFD_dVd;
2108 dT2_dVe = dVgsteffFD_dVe;
2109 /* if (selfheat) dT2_dT = dVgsteffFD_dT; */
2110 if (selfheat) dT2_dT = dVgsteffFD_dT + 2*pParam->B4SOIk1eff*dsqrtPhi_dT; /* v4.1 */
2111 else dT2_dT = 0.0;
2112
2113 T0 = 1+ VgsteffFD * T2 / T1;
2114 dT0_dVg = (VgsteffFD * dT2_dVg + T2 * dVgsteffFD_dVg) / T1;
2115 dT0_dVd = (VgsteffFD * dT2_dVd + T2 * dVgsteffFD_dVd) / T1;
2116 dT0_dVe = (VgsteffFD * dT2_dVe + T2 * dVgsteffFD_dVe) / T1;
2117 if (selfheat)
2118 dT0_dT = (VgsteffFD * (dT2_dT - T2/T1 * dT1_dT) + T2 * dVgsteffFD_dT) / T1;
2119 else dT0_dT = 0.0;
2120
2121
2122 PhiON = phi + Vtm* log(T0) ;
2123 dPhiON_dVg = Vtm* dT0_dVg/T0 ;
2124 dPhiON_dVd = Vtm* dT0_dVd/T0 ;
2125 dPhiON_dVe = Vtm* dT0_dVe/T0 ;
2126 if (selfheat)
2127 dPhiON_dT = dphi_dT + Vtm* dT0_dT/T0 + (PhiON-phi)/Temp ; /* v4.1 */
2128 else dPhiON_dT = 0.0;
2129
2130
2131 /* surface potential from subthreshold to inversion: PhiFD */
2132 T0 = model->B4SOIcox / (model->B4SOIcox + 1.0/(1.0/model->B4SOIcsi + 1.0/Cbox));
2133 PhiFD = PhiON - T0 * VtgseffFD;
2134 dPhiFD_dVg = dPhiON_dVg - T0 * dVtgseffFD_dVg;
2135 dPhiFD_dVd = dPhiON_dVd - T0 * dVtgseffFD_dVd;
2136 dPhiFD_dVe = dPhiON_dVe - T0 * dVtgseffFD_dVe;
2137 if (selfheat)
2138 dPhiFD_dT = dPhiON_dT - T0 * dVtgseffFD_dT;
2139 else dPhiFD_dT = 0;
2140
2141
2142 /* built-in potential lowering: Vbs0 */
2143 if (model->B4SOIfdMod == 0) /* v4.0 */
2144 {
2145 T0 = -model->B4SOIdvbd1 * pParam->B4SOIleff / pParam->B4SOIlitl;
2146 T1 = model->B4SOIdvbd0 * (exp(0.5*T0) + 2*exp(T0));
2147 T2 = T1 * (vbi - phi);
2148 T3 = 0.5 * pParam->B4SOIqsi / model->B4SOIcsi; /* v3.2 */
2149 Vbs0t = PhiFD - T3 + model->B4SOIvbsa + T2;
2150 dVbs0t_dVg = dPhiFD_dVg;
2151 dVbs0t_dVd = dPhiFD_dVd;
2152 dVbs0t_dVe = dPhiFD_dVe;
2153 if (selfheat)
2154 dVbs0t_dT = dPhiFD_dT + T1 * (dvbi_dT - dphi_dT); /* v4.1 */
2155 else dVbs0t_dT = 0;
2156
2157
2158 T0 = 1 + model->B4SOIcsi / Cbox;
2159 T3 = -model->B4SOIdk2b * pParam->B4SOIleff / pParam->B4SOIlitl;
2160 T5 = model->B4SOIk2b * (exp(0.5*T3) + 2*exp(T3));
2161 T1 = (model->B4SOIk1b - T5) / T0;
2162 T2 = T1 * Vesfb;
2163 T0 = 1.0/(1 + Cbox / model->B4SOIcsi);
2164 Vbs0 = T0 * Vbs0t + T2;
2165 dVbs0_dVg = T0 * dVbs0t_dVg;
2166 dVbs0_dVd = T0 * dVbs0t_dVd;
2167 dVbs0_dVe = T0 * dVbs0t_dVe + T1;
2168 if (selfheat)
2169 dVbs0_dT = T0 * dVbs0t_dT - T1 * dvfbb_dT;
2170 else
2171 dVbs0_dT = 0.0;
2172 }
2173 else /* v4.1 */
2174 {
2175 T0 = 1.0/(model->B4SOIcsi + Cbox + model->B4SOIcdsbs);
2176 T1 = -model->B4SOIdvbd1 * pParam->B4SOIleff / pParam->B4SOIlitl;
2177 T2 = model->B4SOIdvbd0 * (exp(0.5*T1) + 2*exp(T1));
2178 T3 = T2 * (Vds + model->B4SOIvsce);
2179 T4 = 0.5 * pParam->B4SOIqsi / model->B4SOIcsi;
2180 T5 = model->B4SOIcsi * T0 * (PhiFD - T4 + model->B4SOIvbsa);
2181 T6 = model->B4SOIcdsbs * T0 * T3;
2182 Vbs0t = T5 + T6;
2183 T8 = model->B4SOIcsi * T0;
2184 dVbs0t_dVg = T8 * dPhiFD_dVg;
2185 dVbs0t_dVd = T8 * dPhiFD_dVd + model->B4SOIcdsbs * T0 * T2;
2186 dVbs0t_dVe = T8 * dPhiFD_dVe;
2187 if (selfheat)
2188 dVbs0t_dT = T8 * dPhiFD_dT;
2189 else
2190 dVbs0t_dT = 0.0;
2191
2192 T7 = Cbox * T0 * Vesfb;
2193 Vbs0 = Vbs0t + T7;
2194 dVbs0_dVg = dVbs0t_dVg;
2195 dVbs0_dVe = dVbs0t_dVe + Cbox * T0;
2196 dVbs0_dVd = dVbs0t_dVd;
2197 if (selfheat)
2198 dVbs0_dT = dVbs0t_dT - Cbox * T0 * dvfbb_dT;
2199 else
2200 dVbs0_dT = 0.0;
2201
2202 }
2203
2204 /* set lowerbound of Vbs (from SPICE) to Vbs0: Vbsitf (Vbs at back interface) */
2205 if (here->B4SOIsoiMod == 2) /* v3.2 */ /* v3.1 ideal FD: Vbsitf is pinned at Vbs0 */
2206 {
2207 Vbs = Vbsitf = Vbs0 + OFF_Vbsitf;
2208 dVbsitf_dVg = dVbs0_dVg;
2209 dVbsitf_dVd = dVbs0_dVd;
2210 dVbsitf_dVe = dVbs0_dVe;
2211 /*dVbsitf_dVb = 0.0; */
2212 /*if (selfheat) dVbsitf_dT = dVbs0_dT; */
2213 /*else dVbsitf_dT = 0; */
2214 /* LFW_FD fix */
2215 dVbs_dVg = dVbsitf_dVg;
2216 dVbs_dVd = dVbsitf_dVd;
2217 dVbs_dVb = dVbsitf_dVb = 0.0;
2218 dVbs_dVe = dVbsitf_dVe;
2219 if (selfheat) {dVbsitf_dT = dVbs0_dT; dVbs_dT = dVbsitf_dT;}
2220 else {dVbsitf_dT = 0; dVbs_dT = 0;}
2221 }
2222 else /* soiMod = 1 */
2223 {
2224 T1 = Vbs - (Vbs0 + OFF_Vbsitf) - 0.01;
2225 T2 = sqrt(T1*T1 + 0.0001);
2226 T3 = 0.5 * (1 + T1/T2);
2227 Vbsitf = (Vbs0 + OFF_Vbsitf) + 0.5 * (T1 + T2);
2228 dVbsitf_dVg = (1 - T3) * dVbs0_dVg;
2229 dVbsitf_dVd = (1 - T3) * dVbs0_dVd;
2230 dVbsitf_dVe = (1 - T3) * dVbs0_dVe;
2231 dVbsitf_dVb = T3 ;
2232 /* LFW_FD 7 new lines */
2233 /* Note that Vbs has not been redefined */
2234 /* dVbs_dVb = dVbsitf_dVb; */
2235 dVbs_dVg = 0.0;
2236 dVbs_dVd = 0.0;
2237 dVbs_dVb = 1.0;
2238 dVbs_dVe = 0.0;
2239 dVbs_dT = 0.0;
2240 if (selfheat) dVbsitf_dT = (1 - T3) * dVbs0_dT;
2241 else dVbsitf_dT = 0.0;
2242 }
2243
2244 /* Based on Vbsitf, calculate zero-field body potential for MOS: Vbsmos */
2245 T1 = Vbs0t - Vbsitf - 0.005;
2246 T2 = sqrt(T1 * T1 + (2.5e-5));
2247 T3 = 0.5 * (T1 + T2);
2248 T4 = T3 * model->B4SOIcsi / pParam->B4SOIqsi; /* v3.2 */
2249 Vbsmos = Vbsitf - 0.5 * T3 * T4;
2250 T5 = 0.5 * T4 * (1 + T1 / T2);
2251 dVbsmos_dVg = dVbsitf_dVg * (1 + T5) - T5 * dVbs0t_dVg;
2252 dVbsmos_dVd = dVbsitf_dVd * (1 + T5) - T5 * dVbs0t_dVd;
2253 dVbsmos_dVb = dVbsitf_dVb * (1 + T5);
2254 dVbsmos_dVe = dVbsitf_dVe * (1 + T5) - T5 * dVbs0t_dVe;
2255 if (selfheat)
2256 dVbsmos_dT = dVbsitf_dT * (1 + T5) - T5 * dVbs0t_dT;
2257 else
2258 dVbsmos_dT = 0.0;
2259 /* Vbsmos should be used in MOS after some limiting (Vbseff) */
2260
2261
2262 Vbp = Vbs - Vps;
2263 dVbp_dVb = 1;
2264 }
2265 /* end of v3.0 block edition */
2266
2267
2268 /* v3.0 modification */
2269 /* T2 is Vbsmos limited above Vbsc=-5 */
2270 T0 = Vbsmos + 5 - 0.001;
2271 T1 = sqrt(T0 * T0 - 0.004 * (-5));
2272 T2 = (-5) + 0.5 * (T0 + T1);
2273 dT2_dVb = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVb;
2274 dT2_dVg = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVg;
2275 dT2_dVd = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVd;
2276 dT2_dVe = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVe;
2277 if (selfheat) dT2_dT = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dT;
2278 else dT2_dT = 0.0;
2279
2280 /* Vbsh is T2 limited below 1.5 */
2281 T0 = 1.5;
2282 T1 = T0 - T2 - 0.002;
2283 T3 = sqrt(T1 * T1 + 0.008 * T0);
2284 Vbsh = T0 - 0.5 * (T1 + T3);
2285 dVbsh_dVb = 0.5 * (1.0 + T1 / T3) * dT2_dVb;
2286 dVbsh_dVg = 0.5 * (1.0 + T1 / T3) * dT2_dVg;
2287 dVbsh_dVd = 0.5 * (1.0 + T1 / T3) * dT2_dVd;
2288 dVbsh_dVe = 0.5 * (1.0 + T1 / T3) * dT2_dVe;
2289 if (selfheat) dVbsh_dT = 0.5 * (1.0 + T1 / T3) * dT2_dT;
2290 else dVbsh_dT = 0.0;
2291
2292
2293 /* Vbseff is Vbsh limited to 0.95*phi */
2294 T0 = 0.95 * phi;
2295 T1 = T0 - Vbsh - 0.002;
2296 T2 = sqrt(T1 * T1 + 0.008 * T0);
2297 Vbseff = T0 - 0.5 * (T1 + T2);
2298 dVbseff_dVb = 0.5 * (1.0 + T1 / T2) * dVbsh_dVb;
2299 dVbseff_dVg = 0.5 * (1.0 + T1 / T2) * dVbsh_dVg;
2300 dVbseff_dVd = 0.5 * (1.0 + T1 / T2) * dVbsh_dVd;
2301 dVbseff_dVe = 0.5 * (1.0 + T1 / T2) * dVbsh_dVe;
2302 /* if (selfheat) dVbseff_dT = 0.5 * (1.0 + T1 / T2) * dVbsh_dT; */
2303 if (selfheat) {
2304 dT0_dT = 0.95 * dphi_dT;
2305 dT1_dT = dT0_dT - dVbsh_dT;
2306 dVbseff_dT = dT0_dT - 0.5 * (1.0 + T1 / T2) * dT1_dT
2307 - 0.002 * dT0_dT / T2;
2308 } /* v4.1 */
2309 else dVbseff_dT = 0.0;
2310 here->B4SOIvbseff = Vbseff; /* SPICE sol. */
2311 /* end of v3.0 modification */
2312
2313
2314 /* Below all the variables refer to Vbseff */
2315 /* LFW_FD comment out next 6 lines */
2316 /*if (dVbseff_dVb < 1e-20) { */
2317 /* dVbseff_dVb = 1e-20; */
2318 /* dVbsh_dVb *= 1e20; */
2319 /*} */
2320 /*else */
2321 /* dVbsh_dVb /= dVbseff_dVb; */
2322 /*=======================================================================*/
2323 /* Some derivatives were originally taken w.r.t. Vbseff, and named *_dVb */
2324 /* Later in the code, they were corrected by multiplying or dividing */
2325 /* by dVbseff_dVb. */
2326 /* Now, all derivatives labeled *_dVb are taken w.r.t. Vbs */
2327 /* The correction factor "dVbseff_dVb" has been removed where it is */
2328 /* no longer needed. */
2329 /*=======================================================================*/
2330
2331 Phis = phi - Vbseff;
2332 /* dPhis_dVb = -1; LFW_FD not uesed */
2333 sqrtPhis = sqrt(Phis);
2334 /*dsqrtPhis_dVb = -0.5 / sqrtPhis; */
2335 /* LFW_FD fix/add 4 lines */
2336 dsqrtPhis_dVg = -0.5 * dVbseff_dVg / sqrtPhis;
2337 dsqrtPhis_dVd = -0.5 * dVbseff_dVd / sqrtPhis;
2338 dsqrtPhis_dVb = -0.5 * dVbseff_dVb / sqrtPhis;
2339 dsqrtPhis_dVe = -0.5 * dVbseff_dVe / sqrtPhis;
2340
2341 Xdep = Xdep0 * sqrtPhis / sqrtPhi;
2342 /*dXdep_dVb = (Xdep0 / sqrtPhi) * dsqrtPhis_dVb; */
2343 /* LFW_FD fix/add 4 lines */
2344 dXdep_dVg = Xdep0 * dsqrtPhis_dVg / sqrtPhi;
2345 dXdep_dVd = Xdep0 * dsqrtPhis_dVd / sqrtPhi;
2346 dXdep_dVb = Xdep0 * dsqrtPhis_dVb / sqrtPhi;
2347 dXdep_dVe = Xdep0 * dsqrtPhis_dVe / sqrtPhi;
2348 /* v4.1 */
2349 if (selfheat) {
2350 dPhis_dT = dphi_dT - dVbseff_dT;
2351 dsqrtPhis_dT = 0.5 / sqrtPhis * dPhis_dT;
2352 /* dXdep_dT = dXdep0_dT * sqrtPhis / sqrtPhi
2353 + (dsqrtPhis_dT * sqrtPhi - sqrtPhis * dsqrtPhi_dT) / phi; v4.2 Temp Deriv bugfix */
2354 dXdep_dT = dXdep0_dT * sqrtPhis / sqrtPhi
2355 + Xdep0 * (dsqrtPhis_dT * sqrtPhi - sqrtPhis * dsqrtPhi_dT) / phi;
2356 }
2357 else {
2358 dPhis_dT = 0.0;
2359 dsqrtPhis_dT = 0.0;
2360 dXdep_dT = 0.0;
2361 } /* end v4.1 */
2362
2363 /* Calculate nstar v3.2 */
2364 /* here->B4SOInstar = model->B4SOIvtm / Charge_q * */
2365 here->B4SOInstar = Vtm / Charge_q *
2366 (model->B4SOIcox + epssub / Xdep + pParam->B4SOIcit);
2367
2368 /* Vth Calculation */
2369 T3 = sqrt(Xdep);
2370
2371 T0 = pParam->B4SOIdvt2 * Vbseff;
2372 if (T0 >= - 0.5)
2373 { T1 = 1.0 + T0;
2374 T2 = pParam->B4SOIdvt2 ;
2375 }
2376 else /* Added to avoid any discontinuity problems caused by dvt2 */
2377 { T4 = 1.0 / (3.0 + 8.0 * T0);
2378 T1 = (1.0 + 3.0 * T0) * T4;
2379 T2 = pParam->B4SOIdvt2 * T4 * T4 ;
2380 }
2381 lt1 = model->B4SOIfactor1 * T3 * T1;
2382 /* dlt1_dVb =model->B4SOIfactor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); */
2383 /* LFW_FD fix/add 4 lines */
2384 dlt1_dVg = model->B4SOIfactor1 * (T3 * T2 * dVbseff_dVg + 0.5 * T1 * dXdep_dVg / T3);
2385 dlt1_dVd = model->B4SOIfactor1 * (T3 * T2 * dVbseff_dVd + 0.5 * T1 * dXdep_dVd / T3);
2386 dlt1_dVb = model->B4SOIfactor1 * (T3 * T2 * dVbseff_dVb + 0.5 * T1 * dXdep_dVb / T3);
2387 dlt1_dVe = model->B4SOIfactor1 * (T3 * T2 * dVbseff_dVe + 0.5 * T1 * dXdep_dVe / T3);
2388 /* fix below expression Wagner */
2389 /*if (selfheat) dlt1_dT = model->B4SOIfactor1 * T1 * 0.5 / T3 * dXdep_dT;*/
2390 if (selfheat) dlt1_dT = model->B4SOIfactor1 * (T1 * 0.5 / T3 * dXdep_dT
2391 + T3 * pParam->B4SOIdvt2 * dVbseff_dT);
2392 else dlt1_dT = 0.0; /* v4.1 */
2393
2394 T0 = pParam->B4SOIdvt2w * Vbseff;
2395 if (T0 >= - 0.5)
2396 { T1 = 1.0 + T0;
2397 T2 = pParam->B4SOIdvt2w ;
2398 }
2399 else /* Added to avoid any discontinuity problems caused by dvt2w */
2400 { T4 = 1.0 / (3.0 + 8.0 * T0);
2401 T1 = (1.0 + 3.0 * T0) * T4;
2402 T2 = pParam->B4SOIdvt2w * T4 * T4 ;
2403 }
2404 ltw= model->B4SOIfactor1 * T3 * T1;
2405 /* dltw_dVb=model->B4SOIfactor1*(0.5 / T3 * T1 * dXdep_dVb + T3 * T2); */
2406 /* LFW_FD fix/add 4 lines */
2407 dltw_dVg = model->B4SOIfactor1 * (T3 * T2 * dVbseff_dVg + 0.5 * T1 * dXdep_dVg / T3);
2408 dltw_dVd = model->B4SOIfactor1 * (T3 * T2 * dVbseff_dVd + 0.5 * T1 * dXdep_dVd / T3);
2409 dltw_dVb = model->B4SOIfactor1 * (T3 * T2 * dVbseff_dVb + 0.5 * T1 * dXdep_dVb / T3);
2410 dltw_dVe = model->B4SOIfactor1 * (T3 * T2 * dVbseff_dVe + 0.5 * T1 * dXdep_dVe / T3);
2411 /* fix next expression Wagner */
2412 /*if (selfheat) dltw_dT = model->B4SOIfactor1 * T1 * 0.5 / T3 * dXdep_dT; */
2413 if (selfheat) dltw_dT = model->B4SOIfactor1 * (T1 * 0.5 / T3 * dXdep_dT
2414 + T3 * pParam->B4SOIdvt2w * dVbseff_dT);
2415 else dltw_dT = 0.0; /* v4.1 */
2416 T0 = -0.5 * pParam->B4SOIdvt1 * Leff / lt1;
2417 if (T0 > -EXPL_THRESHOLD)
2418 { T1 = exp(T0);
2419 Theta0 = T1 * (1.0 + 2.0 * T1);
2420 /*dT1_dVb = -T0 / lt1 * T1 * dlt1_dVb; */
2421 /*dTheta0_dVb = (1.0 + 4.0 * T1) * dT1_dVb; */
2422 /*dT1_dT = -T0 / lt1 * T1 * dlt1_dT; v4.2 bugfix temp deriv */
2423 /*dTheta0_dT = (1.0 + 4.0 * T1) * dT1_dT; v4.2 bugfix temp deriv */
2424 /* LFW_FD fix 5 derivatives */
2425 dTheta0_dVg = -(1.0 + 4.0 * T1) * T1 * T0 * dlt1_dVg / lt1;
2426 dTheta0_dVd = -(1.0 + 4.0 * T1) * T1 * T0 * dlt1_dVd / lt1;
2427 dTheta0_dVb = -(1.0 + 4.0 * T1) * T1 * T0 * dlt1_dVb / lt1;
2428 dTheta0_dVe = -(1.0 + 4.0 * T1) * T1 * T0 * dlt1_dVe / lt1;
2429 dTheta0_dT = -(1.0 + 4.0 * T1) * T1 * T0 * dlt1_dT / lt1;
2430 }
2431 else
2432 { T1 = MIN_EXPL;
2433 Theta0 = T1 * (1.0 + 2.0 * T1);
2434 /* LFW_FD fix 5 derivatives */
2435 dTheta0_dVg = 0.0;
2436 dTheta0_dVd = 0.0;
2437 dTheta0_dVb = 0.0;
2438 dTheta0_dVe = 0.0;
2439 dTheta0_dT = 0; /* v4.2 bugfix temp deriv */
2440 }
2441
2442 /* Calculate n */
2443 T2 = pParam->B4SOInfactor * epssub / Xdep;
2444 /* LFW_FD add 3 derivatives */
2445 dT2_dVg = - T2 / Xdep * dXdep_dVg;
2446 dT2_dVd = - T2 / Xdep * dXdep_dVd;
2447 dT2_dVb = - T2 / Xdep * dXdep_dVb;
2448 dT2_dVe = - T2 / Xdep * dXdep_dVe;
2449 dT2_dT = - T2 / Xdep * dXdep_dT; /* v4.2 bugfix temp deriv */
2450 T3 = pParam->B4SOIcdsc + pParam->B4SOIcdscb * Vbseff
2451 + pParam->B4SOIcdscd * Vds;
2452 /* LFW_FD add/fix 5 derivatives */
2453 dT3_dVg = pParam->B4SOIcdscb * dVbseff_dVg;
2454 dT3_dVd = pParam->B4SOIcdscb * dVbseff_dVd + pParam->B4SOIcdscd;
2455 dT3_dVb = pParam->B4SOIcdscb * dVbseff_dVb;
2456 dT3_dVe = pParam->B4SOIcdscb * dVbseff_dVe;
2457 dT3_dT = pParam->B4SOIcdscb * dVbseff_dT; /* LFW */
2458
2459 T4 = (T2 + T3 * Theta0 + pParam->B4SOIcit) / model->B4SOIcox;
2460 /* LFW_FD add/fix 5 derivatives */
2461 dT4_dVg = (dT2_dVg + T3 * dTheta0_dVg + Theta0 * dT3_dVg) / model->B4SOIcox;
2462 dT4_dVd = (dT2_dVd + T3 * dTheta0_dVd + Theta0 * dT3_dVd) / model->B4SOIcox;
2463 dT4_dVb = (dT2_dVb + T3 * dTheta0_dVb + Theta0 * dT3_dVb) / model->B4SOIcox;
2464 dT4_dVe = (dT2_dVe + T3 * dTheta0_dVe + Theta0 * dT3_dVe) / model->B4SOIcox;
2465 dT4_dT = (dT2_dT + dTheta0_dT* T3 + Theta0*dT3_dT)/ model->B4SOIcox; /* LFW */
2466
2467 if (T4 >= -0.5)
2468 { n = 1.0 + T4;
2469 dn_dVg = dT4_dVg;
2470 dn_dVb = dT4_dVb;
2471 dn_dVd = dT4_dVd;
2472 dn_dVe = dT4_dVe;
2473 dn_dT = dT4_dT; /* v4.2 bugfix temp deriv */
2474 }
2475 else
2476 /* avoid discontinuity problems caused by T4 */
2477 { T0 = 1.0 / (3.0 + 8.0 * T4);
2478 /* n = (1.0 + 3.0 * T4) * T0; */ /* v4.2 bugfix temp deriv */
2479 T5 = 1.0 + 3.0 * T4; /* v4.2 bugfix temp deriv */
2480 n = T0 * T5; /* v4.2 bugfix temp deriv */
2481 dn_dT = T0 * (3.0 - 8.0 * T5 * T0) * dT4_dT; /* Wagner - moved line up from 3 lines below */
2482 T0 *= T0;
2483 dn_dVg = T0 * dT4_dVg;
2484 dn_dVb = T0 * dT4_dVb;
2485 dn_dVd = T0 * dT4_dVd;
2486 dn_dVe = T0 * dT4_dVe;
2487 }
2488
2489 /* v4.0 DITS */
2490 if (pParam->B4SOIdvtp0 > 0.0) {
2491 T0 = -pParam->B4SOIdvtp1 * Vds;
2492 if (T0 < -EXPL_THRESHOLD) {
2493 T2 = MIN_EXPL;
2494 dT2_dVd = 0.0;
2495 }
2496 else {
2497 T2 = exp(T0);
2498 dT2_dVd = -pParam->B4SOIdvtp1 * T2;
2499 }
2500
2501 T3 = Leff + pParam->B4SOIdvtp0 * (1.0 + T2);
2502 dT3_dVd = pParam->B4SOIdvtp0 * dT2_dVd;
2503 T4 = Vtm * log(Leff / T3);
2504 dT4_dVd = -Vtm * dT3_dVd / T3;
2505 DITS_Sft = n * T4;
2506 dDITS_Sft_dVd = dn_dVd * T4 + n * dT4_dVd;
2507 dDITS_Sft_dVb = T4 * dn_dVb;
2508 if (selfheat) {
2509 /* dDITS_Sft_dT = n * KboQ * log(Leff / T3); */ /* v4.2 bugfix temp deriv */
2510 dDITS_Sft_dT = n * KboQ * log(Leff / T3) + dn_dT * T4; /* v4.2 bugfix temp deriv */
2511 }
2512 else
2513 dDITS_Sft_dT = 0.0;
2514 }
2515 else {
2516 DITS_Sft = dDITS_Sft_dVd = dDITS_Sft_dVb = 0.0;
2517 dDITS_Sft_dT = 0.0;
2518 }
2519
2520 here->B4SOIthetavth = pParam->B4SOIdvt0 * Theta0;
2521 Delt_vth = here->B4SOIthetavth * V0;
2522 /* LFW_FD add/fix 4 derivatives */
2523 dDelt_vth_dVg = pParam->B4SOIdvt0 * dTheta0_dVg * V0;
2524 dDelt_vth_dVd = pParam->B4SOIdvt0 * dTheta0_dVd * V0;
2525 dDelt_vth_dVb = pParam->B4SOIdvt0 * dTheta0_dVb * V0;
2526 dDelt_vth_dVe = pParam->B4SOIdvt0 * dTheta0_dVe * V0;
2527 if (selfheat) /* dDelt_vth_dT = here->B4SOIthetavth * dvbi_dT; */ /* v4.2 bugfix temp deriv */
2528 dDelt_vth_dT = pParam->B4SOIdvt0 * (dTheta0_dT * V0 + Theta0 * (dvbi_dT - dphi_dT)); /* v4.2 bugfix temp deriv */
2529 else dDelt_vth_dT = 0.0;
2530
2531 T0 = -0.5 * pParam->B4SOIdvt1w * pParam->B4SOIweff
2532 * Leff / ltw;
2533 if (T0 > -EXPL_THRESHOLD)
2534 { T1 = exp(T0);
2535 T2 = T1 * (1.0 + 2.0 * T1);
2536 /*dT1_dVb = -T0 / ltw * T1 * dltw_dVb; */
2537 /*dT2_dVb = (1.0 + 4.0 * T1) * dT1_dVb; */
2538 /*dT1_dT = -T0 / ltw * T1 * dltw_dT; v4.2 bugfix temp deriv */
2539 /*dT2_dT = (1.0 + 4.0 * T1) * dT1_dT; v4.2 bugfix temp deriv */
2540 /* LFW_FD add/fix 5 derivatives */
2541 dT2_dVg = -(1.0 + 4.0 * T1) * T1 * T0 * dltw_dVg / ltw;
2542 dT2_dVd = -(1.0 + 4.0 * T1) * T1 * T0 * dltw_dVd / ltw;
2543 dT2_dVb = -(1.0 + 4.0 * T1) * T1 * T0 * dltw_dVb / ltw;
2544 dT2_dVe = -(1.0 + 4.0 * T1) * T1 * T0 * dltw_dVe / ltw;
2545 dT2_dT = -(1.0 + 4.0 * T1) * T1 * T0 * dltw_dT / ltw;
2546 }
2547 else
2548 { T1 = MIN_EXPL;
2549 T2 = T1 * (1.0 + 2.0 * T1);
2550 /* LFW_FD add/fix 5 derivatives */
2551 dT2_dVg = 0.0;
2552 dT2_dVd = 0.0;
2553 dT2_dVb = 0.0;
2554 dT2_dVe = 0.0;
2555 dT2_dT = 0.0;
2556 }
2557
2558 T0 = pParam->B4SOIdvt0w * T2;
2559 DeltVthw = T0 * V0;
2560 /* LFW_FD add/fix 5 derivatives */
2561 dDeltVthw_dVg = pParam->B4SOIdvt0w * dT2_dVg * V0;
2562 dDeltVthw_dVd = pParam->B4SOIdvt0w * dT2_dVd * V0;
2563 dDeltVthw_dVb = pParam->B4SOIdvt0w * dT2_dVb * V0;
2564 dDeltVthw_dVe = pParam->B4SOIdvt0w * dT2_dVe * V0;
2565 if (selfheat)
2566 dDeltVthw_dT = T0 * (dvbi_dT - dphi_dT) + pParam->B4SOIdvt0w * dT2_dT * V0;
2567 else dDeltVthw_dT = 0.0;
2568
2569 T0 = sqrt(1.0 + pParam->B4SOIlpe0 / Leff);
2570 T1 = (pParam->B4SOIkt1 + pParam->B4SOIkt1l / Leff
2571 + pParam->B4SOIkt2 * Vbseff);
2572 DeltVthtemp = pParam->B4SOIk1ox * (T0 - 1.0) * sqrtPhi
2573 + T1 * TempRatioMinus1; /* v4.0 */
2574 /* LFW_FD add/fix 5 derivatives */
2575 dDeltVthtemp_dVg = TempRatioMinus1 * pParam->B4SOIkt2 * dVbseff_dVg;
2576 dDeltVthtemp_dVd = TempRatioMinus1 * pParam->B4SOIkt2 * dVbseff_dVd;
2577 dDeltVthtemp_dVb = TempRatioMinus1 * pParam->B4SOIkt2 * dVbseff_dVb;
2578 dDeltVthtemp_dVe = TempRatioMinus1 * pParam->B4SOIkt2 * dVbseff_dVe;
2579 if (selfheat)
2580 dDeltVthtemp_dT = pParam->B4SOIk1ox * (T0 - 1.0) * dsqrtPhi_dT + T1 / model-> B4SOItnom
2581 + pParam->B4SOIkt2 * TempRatioMinus1 * dVbseff_dT;
2582 else
2583 dDeltVthtemp_dT = 0.0;
2584
2585 tmp2 = toxe * phi / (pParam->B4SOIweff + pParam->B4SOIw0);
2586 dtmp2_dT = toxe * dphi_dT / (pParam->B4SOIweff + pParam->B4SOIw0); /* v4.2 bugfix temp deriv */
2587 T3 = here->B4SOIeta0 + pParam->B4SOIetab * Vbseff;
2588 if (T3 < 1.0e-4) /* avoid discontinuity problems caused by etab */
2589 { T9 = 1.0 / (3.0 - 2.0e4 * T3);
2590 T3 = (2.0e-4 - T3) * T9;
2591 T4 = T9 * T9 * pParam->B4SOIetab;
2592 /* LFW_FD add/fix 4 derivatives */
2593 dT3_dVg = T4 * dVbseff_dVg;
2594 dT3_dVd = T4 * dVbseff_dVd;
2595 dT3_dVb = T4 * dVbseff_dVb;
2596 dT3_dVe = T4 * dVbseff_dVe;
2597 }
2598 else
2599 {
2600 /* LFW_FD add/fix 4 derivatives */
2601 dT3_dVg = pParam->B4SOIetab * dVbseff_dVg;
2602 dT3_dVd = pParam->B4SOIetab * dVbseff_dVd;
2603 dT3_dVb = pParam->B4SOIetab * dVbseff_dVb;
2604 dT3_dVe = pParam->B4SOIetab * dVbseff_dVe;
2605 }
2606 /* DIBL_Sft = T3 * pParam->B4SOItheta0vb0 * Vds;
2607 dDIBL_Sft_dVd = pParam->B4SOItheta0vb0 * T3;
2608 dDIBL_Sft_dVb = pParam->B4SOItheta0vb0 * Vds * dT3_dVb; v4.2 bugfix */
2609 DIBL_Sft = T3 * theta0vb0 * Vds;
2610 /* LFW_FD add/fix 4 derivatives */
2611 dDIBL_Sft_dVg = theta0vb0 * Vds * dT3_dVg;
2612 dDIBL_Sft_dVd = theta0vb0 * (Vds * dT3_dVd + T3) ;
2613 dDIBL_Sft_dVb = theta0vb0 * Vds * dT3_dVb;
2614 dDIBL_Sft_dVe = theta0vb0 * Vds * dT3_dVe;
2615 dDIBL_Sft_dT = T3 * Vds * dtheta0vb0_dT + pParam->B4SOIetab * dVbseff_dT * theta0vb0 * Vds;
2616
2617 Lpe_Vb = sqrt(1.0 + pParam->B4SOIlpeb / Leff);
2618
2619 T9 = 2.2361 / sqrtPhi;
2620 sqrtPhisExt = sqrtPhis - T9 * (Vbsh - Vbseff);
2621 /* LFW_FD add/fix 4 derivatives */
2622 dsqrtPhisExt_dVg = dsqrtPhis_dVg - T9 * (dVbsh_dVg - dVbseff_dVg);
2623 dsqrtPhisExt_dVd = dsqrtPhis_dVd - T9 * (dVbsh_dVd - dVbseff_dVd);
2624 dsqrtPhisExt_dVb = dsqrtPhis_dVb - T9 * (dVbsh_dVb - dVbseff_dVb);
2625 dsqrtPhisExt_dVe = dsqrtPhis_dVe - T9 * (dVbsh_dVe - dVbseff_dVe);
2626 dsqrtPhisExt_dT = dsqrtPhis_dT - T9 * (dVbsh_dT - dVbseff_dT)
2627 + 2.2361 * dsqrtPhi_dT * (Vbsh - Vbseff) / phi; /* v4.2 bugfix temp deriv */
2628 /* 4.1 */
2629 T0 = exp(2.0 * pParam->B4SOIdvtp4 * Vds);
2630 DITS_Sft2 = pParam->B4SOIdvtp2factor * (T0-1) / (T0+1);
2631 dDITS_Sft2_dVd = pParam->B4SOIdvtp2factor * pParam->B4SOIdvtp4 * 4.0 * T0 / ((T0+1) * (T0+1));
2632
2633 Vth = model->B4SOItype * here->B4SOIvth0
2634 + (pParam->B4SOIk1ox * sqrtPhisExt
2635 - pParam->B4SOIk1eff * sqrtPhi) * Lpe_Vb
2636 - here->B4SOIk2ox * Vbseff- Delt_vth - DeltVthw
2637 +(pParam->B4SOIk3 + pParam->B4SOIk3b * Vbseff) * tmp2
2638 + DeltVthtemp - DIBL_Sft - DITS_Sft - DITS_Sft2;
2639
2640 /* LFW_FD add/fix 2 derivatives */
2641 dVth_dVg = pParam->B4SOIk1ox * dsqrtPhisExt_dVg * Lpe_Vb
2642 - here->B4SOIk2ox * dVbseff_dVg - dDelt_vth_dVg - dDeltVthw_dVg
2643 + pParam->B4SOIk3b * dVbseff_dVg * tmp2
2644 + dDeltVthtemp_dVg - dDIBL_Sft_dVg; /* LFW_FD fix line */
2645 dvth0_dT=0;
2646
2647
2648
2649 here->B4SOIvon = Vth;
2650
2651 T6 = pParam->B4SOIk3b * tmp2 - here->B4SOIk2ox
2652 + pParam->B4SOIkt2 * TempRatioMinus1;
2653
2654 /* LFW_FD add/fix 4 derivatives */
2655 /* this is actually dVth_dVbseff */
2656 dVth_dVb = pParam->B4SOIk1ox * dsqrtPhisExt_dVb * Lpe_Vb
2657 - here->B4SOIk2ox * dVbseff_dVb - dDelt_vth_dVb - dDeltVthw_dVb
2658 + pParam->B4SOIk3b * dVbseff_dVb * tmp2
2659 + dDeltVthtemp_dVb - dDIBL_Sft_dVb - dDITS_Sft_dVb;
2660
2661 dVth_dVd = pParam->B4SOIk1ox * dsqrtPhisExt_dVd * Lpe_Vb
2662 - here->B4SOIk2ox * dVbseff_dVd - dDelt_vth_dVd - dDeltVthw_dVd
2663 + pParam->B4SOIk3b * dVbseff_dVd * tmp2
2664 + dDeltVthtemp_dVd - dDIBL_Sft_dVd - dDITS_Sft_dVd - dDITS_Sft2_dVd;
2665
2666 dVth_dVe = pParam->B4SOIk1ox * dsqrtPhisExt_dVe * Lpe_Vb
2667 - here->B4SOIk2ox * dVbseff_dVe - dDelt_vth_dVe - dDeltVthw_dVe
2668 + pParam->B4SOIk3b * dVbseff_dVe * tmp2
2669 + dDeltVthtemp_dVe - dDIBL_Sft_dVe; /* LFW_FD fix line */
2670
2671 if (selfheat)
2672 /* dVth_dT = dDeltVthtemp_dT - dDelt_vth_dT - dDeltVthw_dT
2673 - dDITS_Sft_dT; */
2674 dVth_dT = dDeltVthtemp_dT - dDelt_vth_dT - dDeltVthw_dT
2675 +(pParam->B4SOIk1ox * dsqrtPhisExt_dT- pParam->B4SOIk1eff * dsqrtPhi_dT) * Lpe_Vb
2676 - here->B4SOIk2ox*dVbseff_dT + pParam->B4SOIk3b*tmp2*dVbseff_dT
2677 + (pParam->B4SOIk3 + pParam->B4SOIk3b * Vbseff)*dtmp2_dT
2678 + model->B4SOItype * dvth0_dT - dDIBL_Sft_dT - dDITS_Sft_dT; /* v4.2 temp deriv */
2679 else dVth_dT = 0.0;
2680
2681
2682 /* dVthzb_dT calculation */
2683 if ((model->B4SOIcapMod == 3) && (selfheat == 1)) {
2684 T3zb = sqrt(Xdep0);
2685 ltwzb = lt1zb = model->B4SOIfactor1 * T3zb;
2686 dT3zb_dT = 1.0 / (2.0 * T3zb) * dXdep0_dT; /* v4.2 bugfix temp deriv */
2687 dltwzb_dT = dlt1zb_dT = model->B4SOIfactor1 * dT3zb_dT; /* v4.2 bugfix temp deriv */
2688 T0 = -0.5 * pParam->B4SOIdvt1 * Leff / lt1zb;
2689 if (T0 > -EXPL_THRESHOLD)
2690 { T1 = exp(T0);
2691
2692 Theta0zb = T1 * (1.0 + 2.0 * T1);
2693 dT0_dT = -(T0 / lt1zb) * dlt1zb_dT; /* v4.2 bugfix temp deriv */
2694 dT1_dT = T1 * dT0_dT; /* v4.2 bugfix temp deriv */
2695 dTheta0zb_dT = (1.0 + 4.0 * T1) * dT1_dT; /* v4.2 bugfix temp deriv */
2696 }
2697 else
2698 { T1 = MIN_EXPL;
2699 Theta0zb = T1 * (1.0 + 2.0 * T1);
2700 dTheta0zb_dT=0; /* v4.2 bugfix temp deriv */
2701 }
2702 Delt_vthzb = pParam->B4SOIdvt0 * Theta0zb * V0;
2703 /* dDelt_vthzb_dT = pParam->B4SOIdvt0 * Theta0zb * dvbi_dT; */ /* v4.2 bugfix temp deriv */
2704 dDelt_vthzb_dT = pParam->B4SOIdvt0 *( Theta0zb * (dvbi_dT - dphi_dT)
2705 + dTheta0zb_dT *V0); /* v4.2 bugfix temp deriv */
2706
2707 T0 = -0.5 * pParam->B4SOIdvt1w * pParam->B4SOIweff * Leff / ltwzb;
2708 if (T0 > -EXPL_THRESHOLD)
2709 { T1 = exp(T0);
2710 T2 = T1 * (1.0 + 2.0 * T1);
2711 dT0_dT = -(T0 / ltwzb) * dltwzb_dT; /* v4.2 bugfix temp deriv */
2712 dT1_dT = T1 * dT0_dT; /* v4.2 bugfix temp deriv */
2713 dT2_dT = (1.0 + 4.0 * T1) * dT1_dT; /* v4.2 bugfix temp deriv */
2714 }
2715 else
2716 { T1 = MIN_EXPL;
2717 T2 = T1 * (1.0 + 2.0 * T1);
2718 dT2_dT=0; /* v4.2 bugfix temp deriv */
2719 }
2720 T0 = pParam->B4SOIdvt0w * T2;
2721 dT0_dT= pParam->B4SOIdvt0w * dT2_dT; /* v4.2 bugfix temp deriv */
2722 DeltVthwzb = T0 * V0;
2723 /* dDeltVthwzb_dT = T0 * dvbi_dT; *//* v4.2 bugfix temp deriv */
2724 dDeltVthwzb_dT = ( T0 * (dvbi_dT - dphi_dT)+ dT0_dT *V0); /* v4.2 bugfix temp deriv */
2725
2726 T0 = sqrt(1.0 + pParam->B4SOIlpe0 / Leff);
2727 T1 = (pParam->B4SOIkt1 + pParam->B4SOIkt1l / Leff);
2728 DeltVthtempzb = pParam->B4SOIk1ox * (T0 - 1.0) * sqrtPhi
2729 + T1 * TempRatioMinus1;
2730 dDeltVthtempzb_dT = pParam->B4SOIk1ox * (T0 - 1.0) * dsqrtPhi_dT + T1 / model->B4SOItnom; /* v4.2 bugfix temp deriv */
2731
2732 Vthzb = model->B4SOItype * here->B4SOIvth0
2733 - Delt_vthzb - DeltVthwzb + pParam->B4SOIk3 * tmp2
2734 + DeltVthtempzb;
2735 dVthzb_dT = model->B4SOItype * dvth0_dT - dDelt_vthzb_dT - dDeltVthwzb_dT + pParam->B4SOIk3 * dtmp2_dT + dDeltVthtempzb_dT; /* v4.2 bugfix temp deriv */
2736 /* Vthzb2 = Vthzb + 1.12; v4.1 */ /* v4.2 never used */
2737 } else /* LFW_FD */
2738 Vthzb = dVthzb_dT = 0.0; /* LFW_FD flexilint */
2739
2740 /* Effective Vgst (Vgsteff) Calculation */
2741
2742 Vgst = Vgs_eff - Vth;
2743 dVgst_dVg = dVgs_eff_dVg - dVth_dVg; /* LFW_FD fix derivative */
2744 dVgst_dVd = -dVth_dVd;
2745 dVgst_dVb = -dVth_dVb;
2746 dVgst_dVe = -dVth_dVe; /* LFW_FD new line */
2747 if (selfheat) {
2748 dVgst_dT = dVgs_eff_dT - dVth_dT;
2749 }
2750 else dVgst_dT = 0.0;
2751
2752 T10 = n * Vtm; /* v4.0 */
2753 VgstNVt = pParam->B4SOImstar * Vgst / T10; /* v4.0 */
2754 /* LFW_FD add/fix 4 derivatives */
2755 dVgstNVt_dVg = (pParam->B4SOImstar * dVgst_dVg - VgstNVt * dn_dVg * Vtm) / T10;
2756 dVgstNVt_dVd = (pParam->B4SOImstar * dVgst_dVd - VgstNVt * dn_dVd * Vtm) / T10;
2757 dVgstNVt_dVb = (pParam->B4SOImstar * dVgst_dVb - VgstNVt * dn_dVb * Vtm) / T10;
2758 dVgstNVt_dVe = (pParam->B4SOImstar * dVgst_dVe - VgstNVt * dn_dVe * Vtm) / T10;
2759 ExpArg = (pParam->B4SOIvoff - (1- pParam->B4SOImstar) * Vgst)/T10; /* LFW_FD */
2760 /* LFW_FD add/fix 4 derivatives */
2761 dExpArg_dVg = (-(1- pParam->B4SOImstar) * dVgst_dVg - ExpArg * dn_dVg * Vtm) / T10;
2762 dExpArg_dVd = (-(1- pParam->B4SOImstar) * dVgst_dVd - ExpArg * dn_dVd * Vtm) / T10;
2763 dExpArg_dVb = (-(1- pParam->B4SOImstar) * dVgst_dVb - ExpArg * dn_dVb * Vtm) / T10;
2764 dExpArg_dVe = (-(1- pParam->B4SOImstar) * dVgst_dVe - ExpArg * dn_dVe * Vtm) / T10;
2765 if (selfheat) {
2766 dT10_dT = n * dVtm_dT + dn_dT * Vtm;
2767 dVgstNVt_dT = -(-pParam->B4SOImstar*dVgst_dT + VgstNVt*dT10_dT)/T10;
2768 dExpArg_dT = -(1- pParam->B4SOImstar)*dVgst_dT/T10
2769 -ExpArg*dT10_dT/T10;
2770 }
2771 else {
2772 dT10_dT = 0.0;
2773 dVgstNVt_dT = 0.0;
2774 dExpArg_dT = 0.0;
2775 }
2776
2777 /* LFW_FD new line */
2778 dExpVgst_dVg = dExpVgst_dVd = dExpVgst_dVb = dExpVgst_dVe = dExpVgst_dT = 0.0;
2779 /* MCJ: Very small Vgst */
2780 if (VgstNVt > EXPL_THRESHOLD)
2781 { ExpVgst = 1.0; /* LFW_FD flexilint */
2782 Vgsteff = Vgst;
2783 /* T0 is dVgsteff_dVbseff */
2784 T0 = -dVth_dVb;
2785 /* LFW_FD add/fix 5 derivatives */
2786 dVgsteff_dVg = dVgst_dVg;
2787 dVgsteff_dVd = dVgst_dVd;
2788 dVgsteff_dVb = dVgst_dVb;
2789 dVgsteff_dVe = dVgst_dVe;
2790 if (selfheat)
2791 dVgsteff_dT = dVgst_dT ; /* LFW */
2792 else
2793 dVgsteff_dT = 0.0;
2794 }
2795 else if (ExpArg > EXPL_THRESHOLD)
2796 { T0 = (Vgst - pParam->B4SOIvoff) / (n * Vtm);
2797 ExpVgst = exp(T0);
2798 /* LFW_FD add/fix 4 derivatives */
2799 dExpVgst_dVg = (dVgst_dVg - T0 * dn_dVg * Vtm) /(n * Vtm);
2800 dExpVgst_dVd = (dVgst_dVd - T0 * dn_dVd * Vtm) /(n * Vtm);
2801 dExpVgst_dVb = (dVgst_dVb - T0 * dn_dVb * Vtm) /(n * Vtm);
2802 dExpVgst_dVe = (dVgst_dVe - T0 * dn_dVe * Vtm) /(n * Vtm);
2803 /*Vgsteff = Vtm * pParam->B4SOIcdep0 / model->B4SOIcox * ExpVgst; *//*v4.2 bug fix */
2804 Vgsteff = Vtm * cdep0 / model->B4SOIcox * ExpVgst; /* v4.2 bug fix */
2805 T3 = Vgsteff / (n * Vtm) ;
2806 /* T1 is dVgsteff_dVbseff */
2807 /*T1 = -T3 * (dVth_dVb + T0 * Vtm * dn_dVb);*/
2808 /* LFW_FD fix T1 and 4 derivatives */
2809 T1 = -T3 * ( T0 * Vtm * dn_dVb);
2810 dVgsteff_dVg = Vtm * cdep0 / model->B4SOIcox * dExpVgst_dVg;
2811 dVgsteff_dVd = Vtm * cdep0 / model->B4SOIcox * dExpVgst_dVd;
2812 dVgsteff_dVb = Vtm * cdep0 / model->B4SOIcox * dExpVgst_dVb;
2813 dVgsteff_dVe = Vtm * cdep0 / model->B4SOIcox * dExpVgst_dVe;
2814 /* enhance next if-then-else block - Wagner*/
2815 if (selfheat) {
2816 /* dVgsteff_dT = -T3 * (dVth_dT + T0 * dVtm_dT * n)
2817 + Vgsteff / Temp+ T1 * dVbseff_dT; v3.0 */ /* v4.2 temp deriv*/
2818 dVgsteff_dT = -T3 * (-dVgst_dT + T0 * dVtm_dT * n + Vtm * dn_dT)
2819 + Vgsteff / Temp+ T1 * dVbseff_dT; /*v4.2 temp deriv*/
2820 dTL0_dT = (dVgst_dT - T0 * (dn_dT * Vtm + n * dVtm_dT)) / (n * Vtm);
2821 dExpVgst_dT = ExpVgst * dTL0_dT;
2822 dVgsteff_dT = Vgsteff * (dVtm_dT/Vtm + dcdep0_dT/cdep0 + dExpVgst_dT/ExpVgst);
2823 }
2824 else {
2825 dExpVgst_dT = 0.0;
2826 dVgsteff_dT = 0.0;
2827 }
2828 }
2829 else
2830 { ExpVgst = exp(VgstNVt);
2831 /* LFW_FD add/fix 4 derivatives */
2832 dExpVgst_dVg = ExpVgst * dVgstNVt_dVg;
2833 dExpVgst_dVd = ExpVgst * dVgstNVt_dVd;
2834 dExpVgst_dVb = ExpVgst * dVgstNVt_dVb;
2835 dExpVgst_dVe = ExpVgst * dVgstNVt_dVe;
2836 /* 4 new lines Wagner */
2837 if (selfheat)
2838 dExpVgst_dT = ExpVgst * dVgstNVt_dT;
2839 else
2840 dExpVgst_dT = 0.0;
2841 T1 = T10 * log(1.0 + ExpVgst);
2842 /* LFW_FD add/fix 4 derivatives */
2843 dT1_dVg = T10 * dExpVgst_dVg / (1.0 + ExpVgst) + T1 * dn_dVg / n;
2844 dT1_dVd = T10 * dExpVgst_dVd / (1.0 + ExpVgst) + T1 * dn_dVd / n;
2845 dT1_dVb = T10 * dExpVgst_dVb / (1.0 + ExpVgst) + T1 * dn_dVb / n;
2846 dT1_dVe = T10 * dExpVgst_dVe / (1.0 + ExpVgst) + T1 * dn_dVe / n;
2847 /*T3 = (1.0 / Temp); */
2848 T3 = (1.0 / Temp + dn_dT / n); /* v4.2 temp deriv */
2849 if (selfheat)
2850 /* fix below expression Wagner */
2851 /*dT1_dT = -dT1_dVg * (dVth_dT + Vgst * T3) + T1 * T3;*/
2852 dT1_dT = dT10_dT*log(1.0 + ExpVgst)
2853 + T10 * dExpVgst_dT / (1.0 + ExpVgst);
2854 else
2855 dT1_dT = 0.0;
2856
2857 /*dT2_dVg = -model->B4SOIcox / (Vtm * pParam->B4SOIcdep0)
2858 * exp(ExpArg) * (1 - pParam->B4SOImstar);*/ /*v4.2 bug fix*/
2859 dT2_dVg = -model->B4SOIcox / (Vtm * cdep0)
2860 * exp(ExpArg) * (1 - pParam->B4SOImstar); /*v4.2 bug fix*/
2861 T2 = pParam->B4SOImstar - T10 * dT2_dVg
2862 / (1.0 - pParam->B4SOImstar);
2863 /* LFW_FD fix all 5 T2 derivatives */
2864 TL1 = dT2_dVg;
2865 dTL1_dVg = TL1 * dExpArg_dVg;
2866 dTL1_dVd = TL1 * dExpArg_dVd;
2867 dTL1_dVb = TL1 * dExpArg_dVb;
2868 dTL1_dVe = TL1 * dExpArg_dVe;
2869 dT2_dVg = -(dn_dVg * Vtm * TL1 + T10 * dTL1_dVg) / (1.0 - pParam->B4SOImstar);
2870 dT2_dVd = -(dn_dVd * Vtm * TL1 + T10 * dTL1_dVd) / (1.0 - pParam->B4SOImstar);
2871 dT2_dVb = -(dn_dVb * Vtm * TL1 + T10 * dTL1_dVb) / (1.0 - pParam->B4SOImstar);
2872 dT2_dVe = -(dn_dVe * Vtm * TL1 + T10 * dTL1_dVe) / (1.0 - pParam->B4SOImstar);
2873 if (selfheat)
2874 dT2_dT = -(dT10_dT * TL1
2875 +T10*TL1*(-dVtm_dT/Vtm-dcdep0_dT/cdep0+dExpArg_dT)
2876 )/(1.0 - pParam->B4SOImstar);
2877 else
2878 dT2_dT = 0.0;
2879
2880 Vgsteff = T1 / T2;
2881 T3 = T2 * T2;
2882 /* T4 is dVgsteff_dVbseff */
2883 T4 = (T2 * dT1_dVb - T1 * dT2_dVb) / T3;
2884 /* LFW_FD fix 4 derivatives */
2885 dVgsteff_dVg = (T2 * dT1_dVg - T1 * dT2_dVg) / T3;
2886 dVgsteff_dVd = (T2 * dT1_dVd - T1 * dT2_dVd) / T3;
2887 dVgsteff_dVb = (T2 * dT1_dVb - T1 * dT2_dVb) / T3;
2888 dVgsteff_dVe = (T2 * dT1_dVe - T1 * dT2_dVe) / T3;
2889 if (selfheat)
2890 dVgsteff_dT = (T2 * dT1_dT - T1 * dT2_dT) / T3;
2891 else
2892 dVgsteff_dT = 0.0;
2893 }
2894 Vgst2Vtm = Vgsteff + 2.0 * Vtm;
2895 if (selfheat) dVgst2Vtm_dT = dVgsteff_dT + 2.0 * dVtm_dT; /* v3.1.1 bug fix */
2896 else dVgst2Vtm_dT = 0.0;
2897 here->B4SOIVgsteff = Vgsteff; /* v2.2.3 bug fix */
2898
2899 /* v4.0 F-factor (degradation factor due to pocket implant) */
2900 if (pParam->B4SOIfprout <= 0.0)
2901 { FP = 1.0;
2902 /* LFW_FD enhance line */
2903 dFP_dVg = dFP_dVb = dFP_dVd = dFP_dVe = dFP_dT = 0.0;
2904 }
2905 else
2906 { T9 = pParam->B4SOIfprout * sqrt(Leff) / Vgst2Vtm;
2907 FP = 1.0 / (1.0 + T9);
2908 /* LFW_FD fix/add 5 derivatives */
2909 dFP_dVg = FP * FP * T9 / Vgst2Vtm * dVgsteff_dVg;
2910 dFP_dVb = FP * FP * T9 / Vgst2Vtm * dVgsteff_dVb;
2911 dFP_dVd = FP * FP * T9 / Vgst2Vtm * dVgsteff_dVd;
2912 dFP_dVe = FP * FP * T9 / Vgst2Vtm * dVgsteff_dVe;
2913 if (selfheat)
2914 dFP_dT = FP * T9 * dVgst2Vtm_dT / (1.0 + T9) / Vgst2Vtm;
2915 else dFP_dT = 0.0;
2916 }
2917
2918 /* Calculate Effective Channel Geometry */
2919 T9 = sqrtPhis - sqrtPhi;
2920 Weff = pParam->B4SOIweff - (2.0 - here->B4SOInbc)
2921 * (pParam->B4SOIdwg * Vgsteff + pParam->B4SOIdwb * T9);
2922 /* LFW_FD fix/add 4 derivatives */
2923 dWeff_dVg = -(2.0 - here->B4SOInbc) *
2924 (pParam->B4SOIdwg * dVgsteff_dVg + pParam->B4SOIdwb * dsqrtPhis_dVg);
2925 dWeff_dVb = -(2.0 - here->B4SOInbc) *
2926 (pParam->B4SOIdwg * dVgsteff_dVb + pParam->B4SOIdwb * dsqrtPhis_dVb);
2927 dWeff_dVd = -(2.0 - here->B4SOInbc) *
2928 (pParam->B4SOIdwg * dVgsteff_dVd + pParam->B4SOIdwb * dsqrtPhis_dVd);
2929 dWeff_dVe = -(2.0 - here->B4SOInbc) *
2930 (pParam->B4SOIdwg * dVgsteff_dVe + pParam->B4SOIdwb * dsqrtPhis_dVe);
2931 /* New - next 5 lines - Wagner */
2932 if (selfheat)
2933 dWeff_dT = -(2.0 - here->B4SOInbc) *
2934 (pParam->B4SOIdwg * dVgsteff_dT
2935 + pParam->B4SOIdwb*(dsqrtPhis_dT - dsqrtPhi_dT));
2936 else dWeff_dT = 0.0;
2937
2938 if (Weff < 2.0e-8) /* to avoid the discontinuity problem due to Weff*/
2939 { T0 = 1.0 / (6.0e-8 - 2.0 * Weff);
2940 Weff = 2.0e-8 * (4.0e-8 - Weff) * T0;
2941 T0 *= T0 * 4.0e-16;
2942 dWeff_dVg *= T0;
2943 dWeff_dVb *= T0;
2944 /* LFW_FD add 2 derivatives */
2945 dWeff_dVd *= T0;
2946 dWeff_dVe *= T0;
2947 dWeff_dT *= T0; /* new line - Wagner */
2948 }
2949
2950 if (model->B4SOIrdsMod == 1) /* v4.0 */
2951 /* LFW_FD enhance line */
2952 Rds = dRds_dVg = dRds_dVb = dRds_dVd = dRds_dVe = dRds_dT = 0.0;
2953 else {
2954 T0 = pParam->B4SOIprwg * Vgsteff
2955 + pParam->B4SOIprwb * T9;
2956 /* LFW_FD add 4 derivatives */
2957 dT0_dVg = pParam->B4SOIprwg * dVgsteff_dVg + pParam->B4SOIprwb * dsqrtPhis_dVg;
2958 dT0_dVb = pParam->B4SOIprwg * dVgsteff_dVb + pParam->B4SOIprwb * dsqrtPhis_dVb;
2959 dT0_dVd = pParam->B4SOIprwg * dVgsteff_dVd + pParam->B4SOIprwb * dsqrtPhis_dVd;
2960 dT0_dVe = pParam->B4SOIprwg * dVgsteff_dVe + pParam->B4SOIprwb * dsqrtPhis_dVe;
2961 dT0_dT = pParam->B4SOIprwg*dVgsteff_dT
2962 + pParam->B4SOIprwb*(dsqrtPhis_dT - dsqrtPhi_dT); /* new expression Wagner */
2963 if (T0 >= -0.9)
2964 { Rds = rds0 * (1.0 + T0);
2965 /* LFW_FD add/fix 4 derivatives */
2966 dRds_dVg = rds0 * dT0_dVg;
2967 dRds_dVb = rds0 * dT0_dVb;
2968 dRds_dVd = rds0 * dT0_dVd;
2969 dRds_dVe = rds0 * dT0_dVe;
2970
2971 if (selfheat && (Rds!=0.0))
2972 /*fix below expression Wagner */
2973 /*dRds_dT = (1.0 + T0) * drds0_dT;*/
2974 dRds_dT = (1.0 + T0) * drds0_dT + rds0 * dT0_dT;
2975 else dRds_dT = 0.0;
2976
2977 }
2978 else
2979 /* to avoid the discontinuity problem due to prwg and prwb*/
2980 { T1 = 1.0 / (17.0 + 20.0 * T0);
2981 Rds = rds0 * (0.8 + T0) * T1;
2982 /* LFW_FD add/fix 4 derivatives */
2983 dRds_dVg = (rds0*T1- 20*Rds*T1) * dT0_dVg;
2984 dRds_dVb = (rds0*T1- 20*Rds*T1) * dT0_dVb;
2985 dRds_dVd = (rds0*T1- 20*Rds*T1) * dT0_dVd;
2986 dRds_dVe = (rds0*T1- 20*Rds*T1) * dT0_dVe;
2987
2988 if (selfheat && (Rds!=0.0))
2989 /*fix below expression Wagner */
2990 /*dRds_dT = (0.8 + T0) * T1 * drds0_dT;*/
2991 dRds_dT = (0.8 + T0) * T1 * drds0_dT
2992 + (rds0*T1- 20*Rds*T1) * dT0_dT;
2993 else dRds_dT = 0.0;
2994
2995 }
2996 /* here->B4SOIrds = Rds; v2.2.3 bug fix */ /* v4.2 bugfix # 39 */
2997 }
2998 here->B4SOIrds = Rds / here->B4SOInf; /* LFW_FD fix */
2999 /* Calculate Abulk */
3000 if (pParam->B4SOIa0 == 0.0) {
3001
3002 Abulk0 = Abulk = 1.0;
3003
3004 /* LFW_FD expand next 3 lines */
3005 dAbulk_dVg = dAbulk_dVb = dAbulk_dVd = dAbulk_dVe = 0.0;
3006 dAbulk0_dVg = dAbulk0_dVb = dAbulk0_dVd = dAbulk0_dVe = 0.0;
3007 dAbulk0_dT = dAbulk_dT = 0.0;
3008 }
3009 else {
3010 T10 = pParam->B4SOIketa * Vbsh;
3011 if (T10 >= -0.9) {
3012 T11 = 1.0 / (1.0 + T10);
3013 /* LFW_FD add/fix 5 derivatives */
3014 dT11_dVg = -pParam->B4SOIketa * T11 * T11 * dVbsh_dVg;
3015 dT11_dVb = -pParam->B4SOIketa * T11 * T11 * dVbsh_dVb;
3016 dT11_dVd = -pParam->B4SOIketa * T11 * T11 * dVbsh_dVd;
3017 dT11_dVe = -pParam->B4SOIketa * T11 * T11 * dVbsh_dVe;
3018 dT11_dT = -pParam->B4SOIketa * T11 * T11 * dVbsh_dT;
3019 }
3020 else { /* added to avoid the problems caused by Keta */
3021 T12 = 1.0 / (0.8 + T10);
3022 T11 = (17.0 + 20.0 * T10) * T12;
3023 /* LFW_FD add/fix 5 derivatives */
3024 dT11_dVg = (20.0-T11) * T12 * pParam->B4SOIketa * dVbsh_dVg;
3025 dT11_dVb = (20.0-T11) * T12 * pParam->B4SOIketa * dVbsh_dVb;
3026 dT11_dVd = (20.0-T11) * T12 * pParam->B4SOIketa * dVbsh_dVd;
3027 dT11_dVe = (20.0-T11) * T12 * pParam->B4SOIketa * dVbsh_dVe;
3028 dT11_dT = (20.0-T11) * T12 * pParam->B4SOIketa * dVbsh_dT;
3029 }
3030
3031 /* v3.0 bug fix */
3032 T10 = phi + pParam->B4SOIketas;
3033
3034 T13 = (Vbsh * T11) / T10;
3035 /* LFW_FD add/fix 5 derivatives */
3036 dT13_dVg = (Vbsh * dT11_dVg + T11 * dVbsh_dVg) / T10;
3037 dT13_dVb = (Vbsh * dT11_dVb + T11 * dVbsh_dVb) / T10;
3038 dT13_dVd = (Vbsh * dT11_dVd + T11 * dVbsh_dVd) / T10;
3039 dT13_dVe = (Vbsh * dT11_dVe + T11 * dVbsh_dVe) / T10;
3040 dT13_dT = (dVbsh_dT * T11 + Vbsh * dT11_dT - T13 * dphi_dT) / T10;
3041
3042 /* limit 1/sqrt(1-T13) to 6, starting at T13=0.96 */
3043 if (T13 < 0.96) {
3044 T14 = 1 / sqrt(1-T13);
3045 T10 = 0.5 * T14 / (1-T13);
3046 /* LFW_FD add/fix 5 derivatives */
3047 dT14_dVg = T10 * dT13_dVg;
3048 dT14_dVb = T10 * dT13_dVb;
3049 dT14_dVd = T10 * dT13_dVd;
3050 dT14_dVe = T10 * dT13_dVe;
3051 dT14_dT = T10 * dT13_dT;
3052 }
3053 else {
3054 /* IBM tweak */
3055 T11 = 1.0 / (1.0 - 1.0593220339*T13);
3056 T14 = (6.0169491525 - 6.3559322034 * T13) * T11;
3057 /* T10 = 0.0179546 * T11 * T11; never used - Wagner */
3058 /* LFW_FD add/fix 5 derivatives */
3059 dT14_dVg = (T14 * 1.0593220339 - 6.3559322034) * T11 * dT13_dVg;
3060 dT14_dVb = (T14 * 1.0593220339 - 6.3559322034) * T11 * dT13_dVb;
3061 dT14_dVd = (T14 * 1.0593220339 - 6.3559322034) * T11 * dT13_dVd;
3062 dT14_dVe = (T14 * 1.0593220339 - 6.3559322034) * T11 * dT13_dVe;
3063 dT14_dT = (T14 * 1.0593220339 - 6.3559322034) * T11 * dT13_dT;
3064 }
3065
3066 /* v3.0 bug fix */
3067 /* T10 = 0.5 * pParam->B4SOIk1eff
3068 / sqrt(phi + pParam->B4SOIketas); */
3069 T10 = 0.5 * pParam->B4SOIk1ox * Lpe_Vb
3070 / sqrt(phi + pParam->B4SOIketas); /* v4.0 */
3071
3072 T1 = T10 * T14;
3073 /* LFW_FD add/fix 4 derivatives */
3074 dT1_dVg = T10 * dT14_dVg;
3075 dT1_dVb = T10 * dT14_dVb;
3076 dT1_dVd = T10 * dT14_dVd;
3077 dT1_dVe = T10 * dT14_dVe;
3078
3079 T9 = sqrt(pParam->B4SOIxj * Xdep);
3080 tmp1 = Leff + 2.0 * T9;
3081 T5 = Leff / tmp1;
3082 tmp2 = pParam->B4SOIa0 * T5;
3083 tmp3 = pParam->B4SOIweff + pParam->B4SOIb1;
3084 tmp4 = pParam->B4SOIb0 / tmp3;
3085 T2 = tmp2 + tmp4;
3086 /* LFW_FD add/fix 4 derivatives */
3087 dT2_dVg = -tmp2 / tmp1 * pParam->B4SOIxj * dXdep_dVg / T9;
3088 dT2_dVb = -tmp2 / tmp1 * pParam->B4SOIxj * dXdep_dVb / T9;
3089 dT2_dVd = -tmp2 / tmp1 * pParam->B4SOIxj * dXdep_dVd / T9;
3090 dT2_dVe = -tmp2 / tmp1 * pParam->B4SOIxj * dXdep_dVe / T9;
3091 T6 = T5 * T5;
3092 T7 = T5 * T6;
3093 /* LFW_FD add 4 derivatives */
3094 dT7_dVg = -3.0 * T7 / tmp1 * pParam->B4SOIxj * dXdep_dVg / T9;
3095 dT7_dVb = -3.0 * T7 / tmp1 * pParam->B4SOIxj * dXdep_dVb / T9;
3096 dT7_dVd = -3.0 * T7 / tmp1 * pParam->B4SOIxj * dXdep_dVd / T9;
3097 dT7_dVe = -3.0 * T7 / tmp1 * pParam->B4SOIxj * dXdep_dVe / T9;
3098
3099 Abulk0 = 1 + T1 * T2;
3100 /* LFW_FD add/fix 4 derivatives */
3101 dAbulk0_dVg = T1 * dT2_dVg + T2 * dT1_dVg;
3102 dAbulk0_dVb = T1 * dT2_dVb + T2 * dT1_dVb;
3103 dAbulk0_dVd = T1 * dT2_dVd + T2 * dT1_dVd;
3104 dAbulk0_dVe = T1 * dT2_dVe + T2 * dT1_dVe;
3105
3106 T8 = pParam->B4SOIags * pParam->B4SOIa0 * T7;
3107 dAbulk_dVg = -T1 * T8;
3108 Abulk = Abulk0 + dAbulk_dVg * Vgsteff;
3109
3110 /* LFW_FD add/fix 4 derivatives */
3111 dAbulk_dVg = dAbulk0_dVg + dAbulk_dVg * dVgsteff_dVg
3112 - (T1 * pParam->B4SOIags * pParam->B4SOIa0 * dT7_dVg + T8 * dT1_dVg) * Vgsteff;
3113 dAbulk_dVb = dAbulk0_dVb - T1 * T8 * dVgsteff_dVb
3114 - (T1 * pParam->B4SOIags * pParam->B4SOIa0 * dT7_dVb + T8 * dT1_dVb) * Vgsteff;
3115 dAbulk_dVd = dAbulk0_dVd - T1 * T8 * dVgsteff_dVd
3116 - (T1 * pParam->B4SOIags * pParam->B4SOIa0 * dT7_dVd + T8 * dT1_dVd) * Vgsteff;
3117 dAbulk_dVe = dAbulk0_dVe - T1 * T8 * dVgsteff_dVe
3118 - (T1 * pParam->B4SOIags * pParam->B4SOIa0 * dT7_dVe + T8 * dT1_dVe) * Vgsteff;
3119 /* 21 new lines Wagner */
3120 /* need temperature derivs of Abulk & Abulk0 */
3121 TL2 = phi + pParam->B4SOIketas;
3122 dTL1_dT = -0.5*T10/TL2*dphi_dT;
3123 /* TL2 = T14; not used - Wagner */
3124 dTL3_dT = (0.5*pParam->B4SOIxj/T9)*dXdep_dT;
3125 dTL4_dT = -2*tmp2*dTL3_dT/tmp1;
3126 /* dTL5_dT = -T13*dphi_dT/(phi + pParam->B4SOIketas); not used - Wagner */
3127 /* dTL6_dT = 0.5*T14*dTL5_dT/(1-T13); not used - Wagner */
3128 /* fix line below - Wagner */
3129 /* dTL7_dT = T10*dTL6_dT + T14*dTL1_dT; */
3130 dTL7_dT = T10*dT14_dT + T14*dTL1_dT;
3131 dTL8_dT = -pParam->B4SOIags*pParam->B4SOIa0*6*T7*dTL3_dT/tmp1;
3132 dTL9_dT = -dTL7_dT*T8 - T1*dTL8_dT;
3133
3134 if (selfheat) {
3135 dAbulk0_dT = T1*dTL4_dT + T2*dTL7_dT;
3136 dAbulk_dT = dAbulk0_dT + dTL9_dT*Vgsteff + dAbulk_dVg*dVgsteff_dT;
3137 }
3138 else {
3139 dAbulk0_dT = 0.0;
3140 dAbulk_dT = 0.0;
3141 }
3142 }
3143
3144 if (Abulk0 < 0.01)
3145 {
3146 T9 = 1.0 / (3.0 - 200.0 * Abulk0);
3147 Abulk0 = (0.02 - Abulk0) * T9;
3148 /* fix line below - Wagner */
3149 /* dAbulk0_dVb *= T9 * T9; */
3150 T10 = (200.0 * Abulk0 - 1.0) * T9;
3151 /* LFW_FD add/fix 5 derivatives */
3152 dAbulk0_dVg *= T10;
3153 dAbulk0_dVb *= T10;
3154 dAbulk0_dVd *= T10;
3155 dAbulk0_dVe *= T10;
3156 dAbulk0_dT *= T10;
3157 }
3158
3159 if (Abulk < 0.01)
3160 {
3161 T9 = 1.0 / (3.0 - 200.0 * Abulk);
3162 Abulk = (0.02 - Abulk) * T9;
3163 /* fix line below - Wagner */
3164 /* dAbulk_dVb *= T9 * T9; */
3165 /* T10 = T9 * T9; 3.2 bug fix */
3166 T10 = (200.0 * Abulk - 1.0) * T9;
3167 /* LFW_FD add/fix 5 derivatives */
3168 dAbulk_dVg *= T10; /* 3.2 bug fix */
3169 dAbulk_dVb *= T10; /* 3.2 bug fix */
3170 dAbulk_dVd *= T10; /* 3.2 bug fix */
3171 dAbulk_dVe *= T10;
3172 dAbulk_dT *= T10;
3173 }
3174
3175 here->B4SOIAbulk = Abulk; /*v3.2 for noise */
3176
3177 /* Mobility calculation */
3178 if (model->B4SOImtrlMod) {
3179 /* extend "then" block Wagner */
3180 /*T14 = 2.0 * model->B4SOItype *(model->B4SOIphig - model->B4SOIeasub - 0.5 * Eg + 0.45);
3181 toxe_mob = model->B4SOIeot * model->B4SOIepsrsub / 3.9;} Bug fix #4 Jun 09 implementing Eeff correctly*/
3182 T14 = 2.0 * model->B4SOItype *(model->B4SOIphig - model->B4SOIeasub - 0.5 * Eg + 0.45);
3183 toxe_mob = model->B4SOIeot * model->B4SOIepsrsub / 3.9; /* Bug fix #4 Jun 09 implementing Eeff correctly*/
3184 /* 3 new lines Wagner */
3185 if (selfheat)
3186 dT14_dT = - model->B4SOItype * dEg_dT;
3187 else dT14_dT = 0.0;}
3188 else {
3189 T14 = 0.0;
3190 /* extend "else" block Wagner */
3191 /*toxe_mob = model->B4SOItox;}*/
3192 toxe_mob = model->B4SOItox;
3193 dT14_dT = 0.0;} /* new line Wagner */
3194 if (model->B4SOImobMod == 1)
3195 { T0 = Vgsteff + Vth + Vth - T14;
3196 T2 = ua + uc * Vbseff;
3197 T3 = T0 / toxe_mob; /* Bug fix #4 Jun 09 implementing Eeff correctly*/
3198 T5 = T3 * (T2 + ub * T3);
3199 /* LFW_FD fix 5 derivatives */
3200 dDenomi_dVg = (T2 + 2.0 * ub * T3) / toxe_mob * (dVgsteff_dVg + 2 * dVth_dVg)
3201 + T3 * uc * dVbseff_dVg;
3202 dDenomi_dVb = (T2 + 2.0 * ub * T3) / toxe_mob * (dVgsteff_dVb + 2 * dVth_dVb)
3203 + T3 * uc * dVbseff_dVb;
3204 dDenomi_dVd = (T2 + 2.0 * ub * T3) / toxe_mob * (dVgsteff_dVd + 2 * dVth_dVd)
3205 + T3 * uc * dVbseff_dVd;
3206 dDenomi_dVe = (T2 + 2.0 * ub * T3) / toxe_mob * (dVgsteff_dVe + 2 * dVth_dVe)
3207 + T3 * uc * dVbseff_dVe;
3208
3209 if (selfheat)
3210 dDenomi_dT = (T2 + 2.0 * ub * T3) / toxe_mob * (2 * dVth_dT + dVgsteff_dT - dT14_dT)
3211 + (dua_dT + Vbseff * duc_dT + uc * dVbseff_dT
3212 + dub_dT * T3 ) * T3;
3213 else
3214 dDenomi_dT = 0.0;
3215 }
3216 else if (model->B4SOImobMod == 2) /* Bug fix #5 Jun 09 implementing Eeff correctly*/
3217 { T5 = (Vgsteff -T14)/ toxe * (ua /* MobMod=2 does not use Eeff */
3218 + uc * Vbseff + ub * (Vgsteff -T14) /* 'toxe' keeps code consistent with BSIMSOI4.1 Manual*/
3219 / toxe);
3220 /* LFW_FD fix 5 derivatives */
3221 dDenomi_dVg = (ua + uc * Vbseff + 2.0 * ub * (Vgsteff -T14) / toxe) / toxe * dVgsteff_dVg
3222 + (Vgsteff -T14) /toxe * uc * dVbseff_dVg;
3223 dDenomi_dVb = (ua + uc * Vbseff + 2.0 * ub * (Vgsteff -T14) / toxe) / toxe * dVgsteff_dVb
3224 + (Vgsteff -T14) /toxe * uc * dVbseff_dVb;
3225 dDenomi_dVd = (ua + uc * Vbseff + 2.0 * ub * (Vgsteff -T14) / toxe) / toxe * dVgsteff_dVd
3226 + (Vgsteff -T14) /toxe * uc * dVbseff_dVd;
3227 dDenomi_dVe = (ua + uc * Vbseff + 2.0 * ub * (Vgsteff -T14) / toxe) / toxe * dVgsteff_dVe
3228 + (Vgsteff -T14) / toxe * uc * dVbseff_dVe;
3229 if (selfheat)
3230 dDenomi_dT = (ua + uc * Vbseff + 2.0 * ub * (Vgsteff -T14) / toxe) / toxe * (dVgsteff_dT-dT14_dT)
3231 + (Vgsteff -T14)/ toxe
3232 * (dua_dT + Vbseff * duc_dT + uc * dVbseff_dT + dub_dT
3233 * (Vgsteff -T14)/ toxe);
3234 else
3235 dDenomi_dT = 0.0;
3236 }
3237 else if (model->B4SOImobMod == 3) /* mobMod == 3 */
3238 { T0 = Vgsteff + Vth + Vth - T14;
3239 T2 = 1.0 + uc * Vbseff;
3240 T3 = T0 / toxe_mob; /* Bug fix #4 Jun 09 implementing Eeff correctly*/
3241 T4 = T3 * (ua + ub * T3);
3242 T5 = T4 * T2;
3243 /* LFW_FD fix 5 derivatives */
3244 dDenomi_dVg = (ua + 2.0 * ub * T3) * T2 * (dVgsteff_dVg + 2 * dVth_dVg) / toxe_mob
3245 + T4 * uc * dVbseff_dVg;
3246 dDenomi_dVb = (ua + 2.0 * ub * T3) * T2 * (dVgsteff_dVb + 2 * dVth_dVb) / toxe_mob
3247 + T4 * uc * dVbseff_dVb;
3248 dDenomi_dVd = (ua + 2.0 * ub * T3) * T2 * (dVgsteff_dVd + 2 * dVth_dVd) / toxe_mob
3249 + T4 * uc * dVbseff_dVd;
3250 dDenomi_dVe = (ua + 2.0 * ub * T3) * T2 * (dVgsteff_dVe + 2 * dVth_dVe) / toxe_mob
3251 + T4 * uc * dVbseff_dVe;
3252 if (selfheat)
3253 dDenomi_dT = (ua + 2.0 * ub * T3) * T2 * (dVgsteff_dT + 2 * dVth_dT) / toxe_mob
3254 + (dua_dT + dub_dT * T3) * T3 * T2
3255 + T4 * (Vbseff * duc_dT + uc * dVbseff_dT);
3256 else
3257 dDenomi_dT = 0.0;
3258 }
3259 else /* mobMod == 4 */
3260 {
3261 /*universal mobility*/
3262 T0 = (Vgsteff + here->B4SOIvtfbphi1)* 1.0e-8 / toxe/6.0;
3263 T1 = exp(pParam->B4SOIeu * log(T0)); /* MobMod=4 does not use Eeff */
3264 /* using 'toxe' keeps code consistent with BSIM4 formulation */
3265 /* LFW_FD add/fix 5 derivatives */
3266 dT1_dVg = T1 * pParam->B4SOIeu * 1.0e-8/ T0 / toxe/6.0 * dVgsteff_dVg;
3267 dT1_dVb = T1 * pParam->B4SOIeu * 1.0e-8/ T0 / toxe/6.0 * dVgsteff_dVb;
3268 dT1_dVd = T1 * pParam->B4SOIeu * 1.0e-8/ T0 / toxe/6.0 * dVgsteff_dVd;
3269 dT1_dVe = T1 * pParam->B4SOIeu * 1.0e-8/ T0 / toxe/6.0 * dVgsteff_dVe;
3270 dT1_dT = T1 * pParam->B4SOIeu * 1.0e-8/ T0 / toxe/6.0 * dVgsteff_dT;
3271
3272 /*T2 = pParam->B4SOIua + pParam->B4SOIuc * Vbseff; */ /* v4.2 bugfix # 35 */
3273 T2 = ua + uc * Vbseff;
3274 /*Coulombic*/
3275 /* pParam->B4SOIucs = pParam->B4SOIucs * pow(TempRatio, pParam->B4SOIucste); Bug# 21 Jul09*/
3276 /* pParam->B4SOIud = pParam->B4SOIud * pow(TempRatio, pParam->B4SOIud1) ; Bug# 21 Jul09 */
3277 ucs = pParam->B4SOIucs * pow(TempRatio, pParam->B4SOIucste);
3278 ud = pParam->B4SOIud * pow(TempRatio, pParam->B4SOIud1) ;
3279 VgsteffVth = here->B4SOIvgsteffvth;
3280
3281 /*T10 = exp(pParam->B4SOIucs * log(0.5 + 0.5 * Vgsteff/VgsteffVth));*/
3282 /* T10 = exp(pParam->B4SOIucs * log(1.0 + Vgsteff/VgsteffVth)); Bug# 21 Jul09 */
3283 /* T11 = pParam->B4SOIud/T10; Bug# 21 Jul09 */
3284 T10 = exp(ucs * log(1.0 + Vgsteff/VgsteffVth)); /* Bug Fix # 21 Jul09*/
3285 T11 = ud/T10; /* Bug Fix # 21 Jul09*/
3286 /*dT11_dVg = - 0.5 * pParam->B4SOIucs * T11 /(0.5 + 0.5*Vgsteff/VgsteffVth)/VgsteffVth;*/
3287 /* dT11_dVg = (pParam->B4SOIucs - 1.0)*pParam->B4SOIud/(VgsteffVth* exp((pParam->B4SOIucs-1.0) * log(1.0 + Vgsteff/VgsteffVth))); Bug# 21 Jul09*/
3288
3289 /* LFW_FD add/fix 5 derivatives */
3290 dT11_dVg = - ud * ucs * exp(-(ucs+1.0) * log(1.0 + Vgsteff/VgsteffVth)) * dVgsteff_dVg / VgsteffVth;
3291 dT11_dVb = - ud * ucs * exp(-(ucs+1.0) * log(1.0 + Vgsteff/VgsteffVth)) * dVgsteff_dVb / VgsteffVth;
3292 dT11_dVd = - ud * ucs * exp(-(ucs+1.0) * log(1.0 + Vgsteff/VgsteffVth)) * dVgsteff_dVd / VgsteffVth;
3293 dT11_dVe = - ud * ucs * exp(-(ucs+1.0) * log(1.0 + Vgsteff/VgsteffVth)) * dVgsteff_dVe / VgsteffVth;
3294 dT11_dT = - ud * ucs * exp(-(ucs+1.0) * log(1.0 + Vgsteff/VgsteffVth)) * dVgsteff_dT / VgsteffVth;
3295
3296 T5 = T1 * T2 + T11;
3297 /* LFW_FD add/fix 5 derivatives */
3298 dDenomi_dVg = T2 * dT1_dVg + T1 * uc * dVbseff_dVg + dT11_dVg;
3299 dDenomi_dVb = T2 * dT1_dVb + T1 * uc * dVbseff_dVb + dT11_dVb;
3300 dDenomi_dVd = T2 * dT1_dVd + T1 * uc * dVbseff_dVd + dT11_dVd;
3301 dDenomi_dVe = T2 * dT1_dVe + T1 * uc * dVbseff_dVe + dT11_dVe;
3302
3303 if (selfheat)
3304 dDenomi_dT = T2 * dT1_dT + T1 * (dua_dT + Vbseff * duc_dT + uc * dVbseff_dT) + dT11_dT;
3305
3306 else
3307 dDenomi_dT = 0.0;
3308
3309
3310 }
3311 if (T5 >= -0.8)
3312 { Denomi = 1.0 + T5;
3313 }
3314 else /* Added to avoid the discontinuity problem caused by ua and ub*/
3315 { T9 = 1.0 / (7.0 + 10.0 * T5);
3316 Denomi = (0.6 + T5) * T9;
3317 T9 *= T9;
3318 dDenomi_dVg *= T9;
3319 dDenomi_dVd *= T9;
3320 dDenomi_dVb *= T9;
3321 dDenomi_dVe *= T9; /* LFW_FD new line */
3322 if (selfheat) dDenomi_dT *= T9;
3323 else dDenomi_dT = 0.0;
3324 }
3325
3326 here->B4SOIueff = ueff = u0temp / Denomi;
3327 T9 = -ueff / Denomi;
3328 dueff_dVg = T9 * dDenomi_dVg;
3329 dueff_dVd = T9 * dDenomi_dVd;
3330 dueff_dVb = T9 * dDenomi_dVb;
3331 dueff_dVe = T9 * dDenomi_dVe; /* LFW_FD new line */
3332 if (selfheat) dueff_dT = T9 * dDenomi_dT + du0temp_dT / Denomi;
3333 else dueff_dT = 0.0;
3334
3335 /* Saturation Drain Voltage Vdsat */
3336 WVCox = Weff * vsattemp * model->B4SOIcox;
3337 WVCoxRds = WVCox * Rds;
3338 /* LFW_FD add 4 derivatives */
3339 dWVCoxRds_dVg = WVCox * dRds_dVg + Rds * vsattemp * model->B4SOIcox * dWeff_dVg;
3340 dWVCoxRds_dVb = WVCox * dRds_dVb + Rds * vsattemp * model->B4SOIcox * dWeff_dVb;
3341 dWVCoxRds_dVd = WVCox * dRds_dVd + Rds * vsattemp * model->B4SOIcox * dWeff_dVd;
3342 dWVCoxRds_dVe = WVCox * dRds_dVe + Rds * vsattemp * model->B4SOIcox * dWeff_dVe;
3343 /* 5 lines new - Wagner */
3344 if (selfheat)
3345 dWVCoxRds_dT = model->B4SOIcox * Rds *
3346 (vsattemp * dWeff_dT + Weff * dvsattemp_dT)
3347 + WVCox * dRds_dT;
3348 else dWVCoxRds_dT = 0;
3349
3350 /* dWVCoxRds_dT = WVCox * dRds_dT
3351 + Weff * model->B4SOIcox * Rds * dvsattemp_dT; */
3352
3353 Esat = 2.0 * vsattemp / ueff;
3354 EsatL = Esat * Leff;
3355 T0 = -EsatL /ueff;
3356 dEsatL_dVg = T0 * dueff_dVg;
3357 dEsatL_dVd = T0 * dueff_dVd;
3358 dEsatL_dVb = T0 * dueff_dVb;
3359 dEsatL_dVe = T0 * dueff_dVe; /* LFW_FD new line */
3360 if (selfheat)
3361 dEsatL_dT = T0 * dueff_dT + EsatL / vsattemp * dvsattemp_dT;
3362 else
3363 dEsatL_dT = 0.0;
3364
3365 /* Sqrt() */
3366 a1 = pParam->B4SOIa1;
3367 if (a1 == 0.0)
3368 { Lambda = pParam->B4SOIa2;
3369 /* LFW_FD add/fix 5 derivatives */
3370 dLambda_dVg = 0.0;
3371 dLambda_dVb = 0.0;
3372 dLambda_dVd = 0.0;
3373 dLambda_dVe = 0.0;
3374 dLambda_dT = 0.0;
3375 }
3376 else if (a1 > 0.0)
3377 /* Added to avoid the discontinuity problem caused by a1 and a2 (Lambda) */
3378 { T0 = 1.0 - pParam->B4SOIa2;
3379 T1 = T0 - pParam->B4SOIa1 * Vgsteff - 0.0001;
3380 T2 = sqrt(T1 * T1 + 0.0004 * T0);
3381 Lambda = pParam->B4SOIa2 + T0 - 0.5 * (T1 + T2);
3382 /* LFW_FD add/fix 5 derivatives */
3383 dLambda_dVg = 0.5 * pParam->B4SOIa1 * (1.0 + T1 / T2) * dVgsteff_dVg;
3384 dLambda_dVb = 0.5 * pParam->B4SOIa1 * (1.0 + T1 / T2) * dVgsteff_dVb;
3385 dLambda_dVd = 0.5 * pParam->B4SOIa1 * (1.0 + T1 / T2) * dVgsteff_dVd;
3386 dLambda_dVe = 0.5 * pParam->B4SOIa1 * (1.0 + T1 / T2) * dVgsteff_dVe;
3387 if (selfheat) {
3388 dT1_dT = - pParam->B4SOIa1 * dVgsteff_dT;
3389 dT2_dT = T1 * dT1_dT / T2;
3390 dLambda_dT = -0.5 * (dT1_dT + dT2_dT); }
3391 else dLambda_dT = 0.0;
3392 }
3393 else
3394 { T1 = pParam->B4SOIa2 + pParam->B4SOIa1 * Vgsteff - 0.0001;
3395 T2 = sqrt(T1 * T1 + 0.0004 * pParam->B4SOIa2);
3396 Lambda = 0.5 * (T1 + T2);
3397 /* LFW_FD add/fix 5 derivatives */
3398 dLambda_dVg = 0.5 * pParam->B4SOIa1 * (1.0 + T1 / T2) * dVgsteff_dVg;
3399 dLambda_dVb = 0.5 * pParam->B4SOIa1 * (1.0 + T1 / T2) * dVgsteff_dVb;
3400 dLambda_dVd = 0.5 * pParam->B4SOIa1 * (1.0 + T1 / T2) * dVgsteff_dVd;
3401 dLambda_dVe = 0.5 * pParam->B4SOIa1 * (1.0 + T1 / T2) * dVgsteff_dVe;
3402 if (selfheat) {
3403 dT1_dT = pParam->B4SOIa1 * dVgsteff_dT;
3404 dT2_dT = T1 * dT1_dT / T2;
3405 dLambda_dT = 0.5 * (dT1_dT + dT2_dT); }
3406 else dLambda_dT = 0.0;
3407 }
3408
3409 here->B4SOIAbovVgst2Vtm = Abulk /Vgst2Vtm; /* v2.2.3 bug fix */
3410
3411 if (Rds > 0)
3412 { tmp2 = dRds_dVg / Rds + dWeff_dVg / Weff;
3413 tmp3 = dRds_dVb / Rds + dWeff_dVb / Weff;
3414 }
3415 else
3416 { tmp2 = dWeff_dVg / Weff;
3417 tmp3 = dWeff_dVb / Weff;
3418 }
3419 if ((Rds == 0.0) && (Lambda == 1.0))
3420 { T0 = 1.0 / (Abulk * EsatL + Vgst2Vtm);
3421 tmp1 = 0.0;
3422 T1 = T0 * T0;
3423 T2 = Vgst2Vtm * T0;
3424 T3 = EsatL * Vgst2Vtm;
3425 Vdsat = T3 * T0;
3426
3427 /* LFW_FD add/fix 5 derivatives */
3428 dT0_dVg = -(Abulk * dEsatL_dVg + EsatL * dAbulk_dVg + dVgsteff_dVg) * T1;
3429 dT0_dVd = -(Abulk * dEsatL_dVd + EsatL * dAbulk_dVd + dVgsteff_dVd) * T1;
3430 dT0_dVb = -(Abulk * dEsatL_dVb + EsatL * dAbulk_dVb + dVgsteff_dVb) * T1;
3431 dT0_dVe = -(Abulk * dEsatL_dVe + EsatL * dAbulk_dVe + dVgsteff_dVe) * T1;
3432 if (selfheat)
3433 dT0_dT = -(Abulk * dEsatL_dT + dVgst2Vtm_dT) * T1;
3434 else dT0_dT = 0.0;
3435
3436 /* LFW_FD add/fix 5 derivatives */
3437 dVdsat_dVg = T3 * dT0_dVg + T2 * dEsatL_dVg + EsatL * T0 *dVgsteff_dVg;
3438 dVdsat_dVb = T3 * dT0_dVb + T2 * dEsatL_dVb + EsatL * T0 *dVgsteff_dVb;
3439 dVdsat_dVd = T3 * dT0_dVd + T2 * dEsatL_dVd + EsatL * T0 *dVgsteff_dVd;
3440 dVdsat_dVe = T3 * dT0_dVe + T2 * dEsatL_dVe + EsatL * T0 *dVgsteff_dVe;
3441 if (selfheat)
3442 dVdsat_dT = T3 * dT0_dT + T2 * dEsatL_dT
3443 + EsatL * T0 * dVgst2Vtm_dT;
3444 else dVdsat_dT = 0.0;
3445 }
3446 else
3447 { tmp1 = dLambda_dVg / (Lambda * Lambda);
3448 T9 = Abulk * WVCoxRds;
3449 T8 = Abulk * T9;
3450 T7 = Vgst2Vtm * T9;
3451 T6 = Vgst2Vtm * WVCoxRds;
3452 T0 = 2.0 * Abulk * (T9 - 1.0 + 1.0 / Lambda);
3453 /* LFW_FD add/fix 4 derivatives */
3454 dT0_dVg = 2.0 * ((2.0 * Abulk * WVCoxRds - 1.0 + 1.0 / Lambda) * dAbulk_dVg
3455 + Abulk * Abulk * dWVCoxRds_dVg - Abulk * dLambda_dVg / (Lambda * Lambda));
3456 dT0_dVb = 2.0 * ((2.0 * Abulk * WVCoxRds - 1.0 + 1.0 / Lambda) * dAbulk_dVb
3457 + Abulk * Abulk * dWVCoxRds_dVb - Abulk * dLambda_dVb / (Lambda * Lambda));
3458 dT0_dVd = 2.0 * ((2.0 * Abulk * WVCoxRds - 1.0 + 1.0 / Lambda) * dAbulk_dVd
3459 + Abulk * Abulk * dWVCoxRds_dVd - Abulk * dLambda_dVd / (Lambda * Lambda));
3460 dT0_dVe = 2.0 * ((2.0 * Abulk * WVCoxRds - 1.0 + 1.0 / Lambda) * dAbulk_dVe
3461 + Abulk * Abulk * dWVCoxRds_dVe - Abulk * dLambda_dVe / (Lambda * Lambda));
3462
3463 if (selfheat)
3464 {
3465
3466 if (Rds!=0.0)
3467 tmp4 = dRds_dT / Rds + dvsattemp_dT / vsattemp;
3468 else
3469 tmp4 = dvsattemp_dT / vsattemp;
3470
3471 /*fix below expression Wagner */
3472 /*dT0_dT = 2.0 * T8 * tmp4; */
3473 /*dT0_dT = 2.0 * T8 * tmp4 */
3474 /* + 2.0 * dAbulk_dT * (T9-1.0+1.0/Lambda) */
3475 /* + 2.0 * Abulk * (WVCoxRds*dAbulk_dT-dLambda_dT/(Lambda*Lambda)); */
3476 /*fix again below expression Wagner */
3477 dT0_dT = 2.0 * dAbulk_dT * (T9-1.0+1.0/Lambda)
3478 + 2.0 * Abulk
3479 * (WVCoxRds*dAbulk_dT+Abulk*dWVCoxRds_dT-dLambda_dT/(Lambda*Lambda));
3480 } else tmp4 = dT0_dT = 0.0;
3481
3482 T1 = Vgst2Vtm * (2.0 / Lambda - 1.0) + Abulk * EsatL
3483 + 3.0 * T7;
3484
3485 /* LFW_FD add/fix 4 derivatives */
3486 dT1_dVg = (2.0 / Lambda - 1.0) * dVgsteff_dVg - 2.0 * Vgst2Vtm * dLambda_dVg / (Lambda * Lambda)
3487 + EsatL * dAbulk_dVg + Abulk * dEsatL_dVg
3488 + 3.0 * (dVgsteff_dVg * Abulk * WVCoxRds + Vgst2Vtm * dAbulk_dVg * WVCoxRds + Vgst2Vtm * Abulk * dWVCoxRds_dVg);
3489 dT1_dVb = (2.0 / Lambda - 1.0) * dVgsteff_dVb - 2.0 * Vgst2Vtm * dLambda_dVb / (Lambda * Lambda)
3490 + EsatL * dAbulk_dVb + Abulk * dEsatL_dVb
3491 + 3.0 * (dVgsteff_dVb * Abulk * WVCoxRds + Vgst2Vtm * dAbulk_dVb * WVCoxRds + Vgst2Vtm * Abulk * dWVCoxRds_dVb);
3492 dT1_dVd = (2.0 / Lambda - 1.0) * dVgsteff_dVd - 2.0 * Vgst2Vtm * dLambda_dVd / (Lambda * Lambda)
3493 + EsatL * dAbulk_dVd + Abulk * dEsatL_dVd
3494 + 3.0 * (dVgsteff_dVd * Abulk * WVCoxRds + Vgst2Vtm * dAbulk_dVd * WVCoxRds + Vgst2Vtm * Abulk * dWVCoxRds_dVd);
3495 dT1_dVe = (2.0 / Lambda - 1.0) * dVgsteff_dVe - 2.0 * Vgst2Vtm * dLambda_dVe / (Lambda * Lambda)
3496 + EsatL * dAbulk_dVe + Abulk * dEsatL_dVe
3497 + 3.0 * (dVgsteff_dVe * Abulk * WVCoxRds + Vgst2Vtm * dAbulk_dVe * WVCoxRds + Vgst2Vtm * Abulk * dWVCoxRds_dVe);
3498
3499 /* fix below "if" expresssion - Wagner */
3500 /*if (selfheat)
3501 {
3502 tmp4 += dVgst2Vtm_dT / Vgst2Vtm;
3503 dT1_dT = (2.0 / Lambda - 1.0) * dVgst2Vtm_dT
3504 + Abulk * dEsatL_dT + 3.0 * T7 * tmp4;
3505 } else dT1_dT = 0.0; */
3506 if (selfheat)
3507 dT1_dT = (2.0 / Lambda - 1.0) * dVgst2Vtm_dT
3508 - Vgst2Vtm * 2 * dLambda_dT / (Lambda*Lambda)
3509 + dAbulk_dT * EsatL
3510 + Abulk * dEsatL_dT
3511 + 3.0 * Vgst2Vtm * dAbulk_dT * WVCoxRds
3512 + 3.0 * dVgst2Vtm_dT * Abulk * WVCoxRds
3513 + 3.0 * T7 * tmp4;
3514 else dT1_dT = 0.0;
3515
3516 T2 = Vgst2Vtm * (EsatL + 2.0 * T6);
3517 /* LFW_FD add/fix 4 derivatives */
3518 dT2_dVg = dVgsteff_dVg * (EsatL + 4.0 * T6)
3519 + Vgst2Vtm * (dEsatL_dVg + 2 * Vgst2Vtm * dWVCoxRds_dVg);
3520 dT2_dVb = dVgsteff_dVb * (EsatL + 4.0 * T6)
3521 + Vgst2Vtm * (dEsatL_dVb + 2 * Vgst2Vtm * dWVCoxRds_dVb);
3522 dT2_dVd = dVgsteff_dVd * (EsatL + 4.0 * T6)
3523 + Vgst2Vtm * (dEsatL_dVd + 2 * Vgst2Vtm * dWVCoxRds_dVd);
3524 dT2_dVe = dVgsteff_dVe * (EsatL + 4.0 * T6)
3525 + Vgst2Vtm * (dEsatL_dVe + 2 * Vgst2Vtm * dWVCoxRds_dVe);
3526 if (selfheat)
3527 /* fix below expression - Wagner */
3528 /*dT2_dT = Vgst2Vtm * dEsatL_dT + EsatL * dVgst2Vtm_dT
3529 + 2.0 * T6 * (dVgst2Vtm_dT + Vgst2Vtm * tmp4); */
3530 dT2_dT = dVgst2Vtm_dT * (EsatL + 2.0 * T6)
3531 + Vgst2Vtm * (dEsatL_dT + 2.0 * T6 * tmp4 + 2.0 * dVgst2Vtm_dT * WVCoxRds);
3532 else
3533 dT2_dT = 0.0;
3534
3535 T3 = sqrt(T1 * T1 - 2.0 * T0 * T2);
3536 Vdsat = (T1 - T3) / T0;
3537
3538 dVdsat_dVg = (dT1_dVg - (T1 * dT1_dVg - dT0_dVg * T2
3539 - T0 * dT2_dVg) / T3 - Vdsat * dT0_dVg) / T0;
3540 dVdsat_dVb = (dT1_dVb - (T1 * dT1_dVb - dT0_dVb * T2
3541 - T0 * dT2_dVb) / T3 - Vdsat * dT0_dVb) / T0;
3542 /* LFW_FD add/fix 2 derivatives */
3543 dVdsat_dVd = (dT1_dVd - (T1 * dT1_dVd - dT0_dVd * T2
3544 - T0 * dT2_dVd) / T3 - Vdsat * dT0_dVd) / T0;
3545 dVdsat_dVe = (dT1_dVe - (T1 * dT1_dVe - dT0_dVe * T2
3546 - T0 * dT2_dVe) / T3 - Vdsat * dT0_dVe) / T0;
3547 if (selfheat)
3548 dVdsat_dT = (dT1_dT - (T1 * dT1_dT - dT0_dT * T2
3549 - T0 * dT2_dT) / T3 - Vdsat * dT0_dT) / T0;
3550 else dVdsat_dT = 0.0;
3551 }
3552 here->B4SOIvdsat = Vdsat;
3553
3554
3555 /* Effective Vds (Vdseff) Calculation */
3556 T1 = Vdsat - Vds - pParam->B4SOIdelta;
3557 dT1_dVg = dVdsat_dVg;
3558 dT1_dVd = dVdsat_dVd - 1.0;
3559 dT1_dVb = dVdsat_dVb;
3560 dT1_dVe = dVdsat_dVe; /* LFW_FD new line */
3561 dT1_dT = dVdsat_dT;
3562
3563 T2 = sqrt(T1 * T1 + 4.0 * pParam->B4SOIdelta * Vdsat);
3564 T0 = T1 / T2;
3565 T3 = 2.0 * pParam->B4SOIdelta / T2;
3566 dT2_dVg = T0 * dT1_dVg + T3 * dVdsat_dVg;
3567 dT2_dVd = T0 * dT1_dVd + T3 * dVdsat_dVd;
3568 dT2_dVb = T0 * dT1_dVb + T3 * dVdsat_dVb;
3569 dT2_dVe = T0 * dT1_dVe + T3 * dVdsat_dVe; /* LFW_FD new line */
3570 if (selfheat)
3571 dT2_dT = T0 * dT1_dT + T3 * dVdsat_dT;
3572 else dT2_dT = 0.0;
3573
3574 Vdseff = Vdsat - 0.5 * (T1 + T2);
3575 dVdseff_dVg = dVdsat_dVg - 0.5 * (dT1_dVg + dT2_dVg);
3576 dVdseff_dVd = dVdsat_dVd - 0.5 * (dT1_dVd + dT2_dVd);
3577 dVdseff_dVb = dVdsat_dVb - 0.5 * (dT1_dVb + dT2_dVb);
3578 dVdseff_dVe = dVdsat_dVe - 0.5 * (dT1_dVe + dT2_dVe); /* LFW_FD new line */
3579 if (selfheat)
3580 dVdseff_dT = dVdsat_dT - 0.5 * (dT1_dT + dT2_dT);
3581 else dVdseff_dT = 0.0;
3582
3583 if (Vdseff > Vds)
3584 Vdseff = Vds; /* This code is added to fixed the problem
3585 caused by computer precision when
3586 Vds is very close to Vdseff. */
3587 diffVds = Vds - Vdseff;
3588 here->B4SOIVdseff = Vdseff; /* v2.2.3 bug fix */
3589
3590 /* Calculate VAsat */
3591 tmp4 = 1.0 - 0.5 * Abulk * Vdsat / Vgst2Vtm;
3592 T9 = WVCoxRds * Vgsteff;
3593 T8 = T9 / Vgst2Vtm;
3594 T0 = EsatL + Vdsat + 2.0 * T9 * tmp4;
3595
3596 T7 = 2.0 * WVCoxRds * tmp4;
3597 /* LFW_FD fix/add 4 derivatives */
3598 dT0_dVg = dEsatL_dVg + dVdsat_dVg
3599 + 2.0 * (tmp4 * (WVCoxRds * dVgsteff_dVg + dWVCoxRds_dVg * Vgsteff)
3600 - T9 * (0.5 * (Abulk * dVdsat_dVg + dAbulk_dVg * Vdsat
3601 - Abulk * Vdsat * dVgsteff_dVg / Vgst2Vtm) / Vgst2Vtm));
3602 dT0_dVb = dEsatL_dVb + dVdsat_dVb
3603 + 2.0 * (tmp4 * (WVCoxRds * dVgsteff_dVb + dWVCoxRds_dVb * Vgsteff)
3604 - T9 * (0.5 * (Abulk * dVdsat_dVb + dAbulk_dVb * Vdsat
3605 - Abulk * Vdsat * dVgsteff_dVb / Vgst2Vtm) / Vgst2Vtm));
3606 dT0_dVd = dEsatL_dVd + dVdsat_dVd
3607 + 2.0 * (tmp4 * (WVCoxRds * dVgsteff_dVd + dWVCoxRds_dVd * Vgsteff)
3608 - T9 * (0.5 * (Abulk * dVdsat_dVd + dAbulk_dVd * Vdsat
3609 - Abulk * Vdsat * dVgsteff_dVd / Vgst2Vtm) / Vgst2Vtm));
3610 dT0_dVe = dEsatL_dVe + dVdsat_dVe
3611 + 2.0 * (tmp4 * (WVCoxRds * dVgsteff_dVe + dWVCoxRds_dVe * Vgsteff)
3612 - T9 * (0.5 * (Abulk * dVdsat_dVe + dAbulk_dVe * Vdsat
3613 - Abulk * Vdsat * dVgsteff_dVe / Vgst2Vtm) / Vgst2Vtm));
3614
3615 if (selfheat)
3616 {
3617
3618 if (Rds!=0.0)
3619 tmp4 = dRds_dT / Rds + dvsattemp_dT / vsattemp;
3620 else tmp4 = dvsattemp_dT / vsattemp;
3621
3622 /* fix below expression - Wagner */
3623 /*dT0_dT = dEsatL_dT + dVdsat_dT + T7 * tmp4 * Vgsteff
3624 - T8 * (Abulk * dVdsat_dT - Abulk * Vdsat * dVgst2Vtm_dT
3625 / Vgst2Vtm); */
3626 dT0_dT = dEsatL_dT + dVdsat_dT
3627 + T7 * (dVgsteff_dT + Vgsteff * tmp4)
3628 - T9 * (dAbulk_dT * Vdsat + Abulk * dVdsat_dT
3629 - Abulk * Vdsat * dVgst2Vtm_dT / Vgst2Vtm) / Vgst2Vtm;
3630 } else
3631 dT0_dT = 0.0;
3632
3633 T9 = WVCoxRds * Abulk;
3634 T1 = 2.0 / Lambda - 1.0 + T9;
3635 /* LFW_FD fix/add 4 derivatives */
3636 dT1_dVg = -2.0 * dLambda_dVg / (Lambda * Lambda) + WVCoxRds * dAbulk_dVg + dWVCoxRds_dVg * Abulk;
3637 dT1_dVb = -2.0 * dLambda_dVb / (Lambda * Lambda) + WVCoxRds * dAbulk_dVb + dWVCoxRds_dVb * Abulk;
3638 dT1_dVd = -2.0 * dLambda_dVd / (Lambda * Lambda) + WVCoxRds * dAbulk_dVd + dWVCoxRds_dVd * Abulk;
3639 dT1_dVe = -2.0 * dLambda_dVe / (Lambda * Lambda) + WVCoxRds * dAbulk_dVe + dWVCoxRds_dVe * Abulk;
3640 if (selfheat)
3641 /* fix below expression - Wagner */
3642 /*dT1_dT = T9 * tmp4;*/
3643 dT1_dT = - 2.0 * dLambda_dT / (Lambda*Lambda)
3644 /* + T9 * tmp4 + WVCoxRds * dAbulk_dT; fix again */
3645 + WVCoxRds * dAbulk_dT + dWVCoxRds_dT * Abulk;
3646 else
3647 dT1_dT = 0.0;
3648
3649 Vasat = T0 / T1;
3650 dVasat_dVg = (dT0_dVg - Vasat * dT1_dVg) / T1;
3651 dVasat_dVb = (dT0_dVb - Vasat * dT1_dVb) / T1;
3652 /* LFW_FD fix/add 2 derivatives */
3653 dVasat_dVd = (dT0_dVd - Vasat * dT1_dVd) / T1;
3654 dVasat_dVe = (dT0_dVe - Vasat * dT1_dVe) / T1;
3655 if (selfheat) dVasat_dT = (dT0_dT - Vasat * dT1_dT) / T1;
3656 else dVasat_dT = 0.0;
3657
3658 /* Calculate VACLM */
3659 if ((pParam->B4SOIpclm > 0.0) && (diffVds > 1.0e-10))
3660 { T0 = 1.0 / (pParam->B4SOIpclm * Abulk * pParam->B4SOIlitl);
3661 dT0_dVb = -T0 / Abulk * dAbulk_dVb;
3662 dT0_dVg = -T0 / Abulk * dAbulk_dVg;
3663 /* LFW_FD add 2 derivatives */
3664 dT0_dVd = -T0 / Abulk * dAbulk_dVd;
3665 dT0_dVe = -T0 / Abulk * dAbulk_dVe;
3666
3667 T2 = Vgsteff / EsatL;
3668 T1 = Leff * (Abulk + T2);
3669 /* LFW_FD add/fix 4 derivatives */
3670 dT1_dVg = Leff * (dAbulk_dVg + (dVgsteff_dVg - T2 * dEsatL_dVg) / EsatL);
3671 dT1_dVb = Leff * (dAbulk_dVb + (dVgsteff_dVb - T2 * dEsatL_dVb) / EsatL);
3672 dT1_dVd = Leff * (dAbulk_dVd + (dVgsteff_dVd - T2 * dEsatL_dVd) / EsatL);
3673 dT1_dVe = Leff * (dAbulk_dVe + (dVgsteff_dVe - T2 * dEsatL_dVe) / EsatL);
3674 /* fix below expression - Wagner */
3675 /*if (selfheat) dT1_dT = -T2 * dEsatL_dT / Esat; */
3676 if (selfheat) dT1_dT = Leff * (dAbulk_dT
3677 + (dVgsteff_dT - T2 * dEsatL_dT) / EsatL);
3678 else dT1_dT = 0.0;
3679
3680 T9 = T0 * T1;
3681 VACLM = T9 * diffVds;
3682 dVACLM_dVg = T0 * dT1_dVg * diffVds - T9 * dVdseff_dVg
3683 + T1 * diffVds * dT0_dVg;
3684 dVACLM_dVb = (dT0_dVb * T1 + T0 * dT1_dVb) * diffVds
3685 - T9 * dVdseff_dVb;
3686 /* LFW_FD add/fix 2 derivatives */
3687 dVACLM_dVd = (dT0_dVd * T1 + T0 * dT1_dVd) * diffVds + T9 * (1.0 - dVdseff_dVd);
3688 dVACLM_dVe = (dT0_dVe * T1 + T0 * dT1_dVe) * diffVds - T9 * dVdseff_dVe;
3689 if (selfheat)
3690 /* fix below expression - Wagner */
3691 /*dVACLM_dT = T0 * dT1_dT * diffVds - T9 * dVdseff_dT;*/
3692 dVACLM_dT = - T9 * dVdseff_dT
3693 + diffVds * (T0 * dT1_dT - T1 * T0 * dAbulk_dT / Abulk);
3694 else dVACLM_dT = 0.0;
3695
3696 }
3697 else
3698 { VACLM = MAX_EXPL;
3699 dVACLM_dVd = dVACLM_dVg = dVACLM_dVb = dVACLM_dVe = dVACLM_dT = 0.0; /* LFW_FD expand line */
3700 }
3701
3702
3703 /* Calculate VADIBL */
3704 /* if (pParam->B4SOIthetaRout > 0.0) */ /* v4.2 bugfix # 36 */
3705 if (thetaRout > 0.0)
3706 { T8 = Abulk * Vdsat;
3707 T0 = Vgst2Vtm * T8;
3708 T1 = Vgst2Vtm + T8;
3709 /* LFW_FD fix/add 4 derivatives */
3710 dT0_dVg = T8 * dVgsteff_dVg + Vgst2Vtm * (Abulk * dVdsat_dVg + dAbulk_dVg * Vdsat);
3711 dT0_dVb = T8 * dVgsteff_dVb + Vgst2Vtm * (Abulk * dVdsat_dVb + dAbulk_dVb * Vdsat);
3712 dT0_dVd = T8 * dVgsteff_dVd + Vgst2Vtm * (Abulk * dVdsat_dVd + dAbulk_dVd * Vdsat);
3713 dT0_dVe = T8 * dVgsteff_dVe + Vgst2Vtm * (Abulk * dVdsat_dVe + dAbulk_dVe * Vdsat);
3714
3715 /* LFW_FD fix/add 4 derivatives */
3716 dT1_dVg = dVgsteff_dVg + Abulk * dVdsat_dVg + dAbulk_dVg * Vdsat;
3717 dT1_dVb = dVgsteff_dVb + Abulk * dVdsat_dVb + dAbulk_dVb * Vdsat;
3718 dT1_dVd = dVgsteff_dVd + Abulk * dVdsat_dVd + dAbulk_dVd * Vdsat;
3719 dT1_dVe = dVgsteff_dVe + Abulk * dVdsat_dVe + dAbulk_dVe * Vdsat;
3720 if (selfheat)
3721 {
3722 /* fix below expression - Wagner */
3723 /*dT0_dT = dVgst2Vtm_dT * T8 + Abulk * Vgst2Vtm * dVdsat_dT;*/
3724 dT0_dT = dVgst2Vtm_dT * T8
3725 + Vgst2Vtm * dAbulk_dT * Vdsat
3726 + Vgst2Vtm * Abulk * dVdsat_dT;
3727 /* fix below expression - Wagner */
3728 /*dT1_dT = dVgst2Vtm_dT + Abulk * dVdsat_dT;*/
3729 dT1_dT = dVgst2Vtm_dT + dAbulk_dT * Vdsat + Abulk * dVdsat_dT;
3730 } else
3731 dT0_dT = dT1_dT = 0.0;
3732
3733 T9 = T1 * T1;
3734 /*T2 = pParam->B4SOIthetaRout; */ /* v4.2 bugfix # 36 */
3735 T2 = thetaRout;
3736 VADIBL = (Vgst2Vtm - T0 / T1) / T2;
3737 /* LFW_FD fix/add 4 derivatives */
3738 dVADIBL_dVg = (dVgsteff_dVg - (dT0_dVg - T0 * dT1_dVg /T1 )/T1) / T2;
3739 dVADIBL_dVb = (dVgsteff_dVb - (dT0_dVb - T0 * dT1_dVb /T1 )/T1) / T2;
3740 dVADIBL_dVd = (dVgsteff_dVd - (dT0_dVd - T0 * dT1_dVd /T1 )/T1) / T2;
3741 dVADIBL_dVe = (dVgsteff_dVe - (dT0_dVe - T0 * dT1_dVe /T1 )/T1) / T2;
3742
3743 if (selfheat)
3744 /*fix below expression Wagner */
3745 /*dVADIBL_dT = (dVgst2Vtm_dT - dT0_dT/T1 + T0*dT1_dT/T9) / T2;*/
3746 dVADIBL_dT = (dVgst2Vtm_dT - dT0_dT/T1 + T0*dT1_dT/T9) / T2
3747 - VADIBL * dthetaRout_dT / T2;
3748 else dVADIBL_dT = 0.0;
3749
3750 T7 = pParam->B4SOIpdiblb * Vbseff;
3751 if (T7 >= -0.9)
3752 { T3 = 1.0 / (1.0 + T7);
3753 VADIBL *= T3;
3754 /* LFW_FD fix/add 4 derivatives */
3755 dVADIBL_dVg = (dVADIBL_dVg - VADIBL * pParam->B4SOIpdiblb * dVbseff_dVg) * T3;
3756 dVADIBL_dVb = (dVADIBL_dVb - VADIBL * pParam->B4SOIpdiblb * dVbseff_dVb) * T3;
3757 dVADIBL_dVd = (dVADIBL_dVd - VADIBL * pParam->B4SOIpdiblb * dVbseff_dVd) * T3;
3758 dVADIBL_dVe = (dVADIBL_dVe - VADIBL * pParam->B4SOIpdiblb * dVbseff_dVe) * T3;
3759 /*fix below expression Wagner */
3760 /*if (selfheat) dVADIBL_dT *= T3;*/
3761 if (selfheat)
3762 dVADIBL_dT = T3 * dVADIBL_dT
3763 - VADIBL*pParam->B4SOIpdiblb*dVbseff_dT/(1.0+T7);
3764 else dVADIBL_dT = 0.0;
3765 }
3766 else
3767 /* Added to avoid the discontinuity problem caused by pdiblcb */
3768 { T4 = 1.0 / (0.8 + T7);
3769 T3 = (17.0 + 20.0 * T7) * T4;
3770 /* LFW_FD fix/add 4 derivatives */
3771 dVADIBL_dVg = dVADIBL_dVg * T3 + VADIBL * (20.0 - T3) * T4 * pParam->B4SOIpdiblb * dVbseff_dVg;
3772 dVADIBL_dVb = dVADIBL_dVb * T3 + VADIBL * (20.0 - T3) * T4 * pParam->B4SOIpdiblb * dVbseff_dVb;
3773 dVADIBL_dVd = dVADIBL_dVd * T3 + VADIBL * (20.0 - T3) * T4 * pParam->B4SOIpdiblb * dVbseff_dVd;
3774 dVADIBL_dVe = dVADIBL_dVe * T3 + VADIBL * (20.0 - T3) * T4 * pParam->B4SOIpdiblb * dVbseff_dVe;
3775 /*fix below expression Wagner */
3776 /*if (selfheat) dVADIBL_dT *= T3;*/
3777 if (selfheat)
3778 dVADIBL_dT = T3 * dVADIBL_dT
3779 + VADIBL * (20.0*T4 - T3/(0.8 + T7))
3780 * pParam->B4SOIpdiblb*dVbseff_dT;
3781 else dVADIBL_dT = 0.0;
3782 VADIBL *= T3;
3783 }
3784 }
3785 else
3786 { VADIBL = MAX_EXPL;
3787 dVADIBL_dVd = dVADIBL_dVg = dVADIBL_dVb = dVADIBL_dVe = dVADIBL_dT = 0.0; /* LFW_FD enhance line */
3788 }
3789
3790 /* v4.0 DITS */
3791 T0 = pParam->B4SOIpditsd * Vds;
3792 if (T0 > EXPL_THRESHOLD)
3793 { T1 = MAX_EXPL;
3794 dT1_dVd = 0;
3795 }
3796 else
3797 { T1 = exp(T0);
3798 dT1_dVd = T1 * pParam->B4SOIpditsd;
3799 }
3800 if (pParam->B4SOIpdits > MIN_EXPL)
3801 { T2 = 1.0 + model->B4SOIpditsl * Leff;
3802 VADITS = (1.0 + T2 * T1) / pParam->B4SOIpdits;
3803 dVADITS_dVg = VADITS * dFP_dVg;
3804 /* LFW_FD fix/add 3 derivatives */
3805 dVADITS_dVd = VADITS * dFP_dVd + FP * T2 * dT1_dVd / pParam->B4SOIpdits;
3806 dVADITS_dVb = VADITS * dFP_dVb;
3807 dVADITS_dVe = VADITS * dFP_dVe;
3808 VADITS *= FP;
3809 if (selfheat) dVADITS_dT = VADITS * dFP_dT / FP;
3810 else dVADITS_dT = 0.0;
3811 }
3812 else
3813 { VADITS = MAX_EXPL;
3814 dVADITS_dVg = dVADITS_dVd = dVADITS_dVb = dVADITS_dVe = dVADITS_dT = 0; /* LFW_FD enhance line */
3815 }
3816
3817 /* Calculate VA */
3818
3819 T8 = pParam->B4SOIpvag / EsatL;
3820 T9 = T8 * Vgsteff;
3821 if (T9 > -0.9)
3822 { T0 = 1.0 + T9;
3823 /* LFW_FD fix/add 4 derivatives */
3824 dT0_dVg = T8 * dVgsteff_dVg - T9 * dEsatL_dVg / EsatL;
3825 dT0_dVb = T8 * dVgsteff_dVb - T9 * dEsatL_dVb / EsatL;
3826 dT0_dVd = T8 * dVgsteff_dVd - T9 * dEsatL_dVd / EsatL;
3827 dT0_dVe = T8 * dVgsteff_dVe - T9 * dEsatL_dVe / EsatL;
3828 if (selfheat)
3829 /* fix below expression - Wagner */
3830 /*dT0_dT = -T9 * dEsatL_dT / EsatL;*/
3831 dT0_dT = T8 * dVgsteff_dT - T9 * dEsatL_dT / EsatL;
3832 else
3833 dT0_dT = 0.0;
3834 }
3835 else /* Added to avoid the discontinuity problems caused by pvag */
3836 { TL1 = T1 = 1.0 / (17.0 + 20.0 * T9); /* change LHS name - Wagner */
3837 T0 = (0.8 + T9) * T1;
3838 T1 *= T1;
3839 T9 *= T1 / EsatL;
3840 /* LFW_FD fix/add 4 derivatives */
3841 dT0_dVg = (1.0 - 20.0 * T0) * TL1 * (T8 * dVgsteff_dVg - T9 * dEsatL_dVg / EsatL);
3842 dT0_dVb = (1.0 - 20.0 * T0) * TL1 * (T8 * dVgsteff_dVb - T9 * dEsatL_dVb / EsatL);
3843 dT0_dVd = (1.0 - 20.0 * T0) * TL1 * (T8 * dVgsteff_dVd - T9 * dEsatL_dVd / EsatL);
3844 dT0_dVe = (1.0 - 20.0 * T0) * TL1 * (T8 * dVgsteff_dVe - T9 * dEsatL_dVe / EsatL);
3845 if (selfheat)
3846 /* fix below expression - Wagner */
3847 /*dT0_dT = -T9 * dEsatL_dT;*/
3848 dT0_dT = TL1 * (1.0 - 20.0 * T0)
3849 * (T8 * dVgsteff_dT - T8 * Vgsteff * dEsatL_dT / EsatL);
3850 else
3851 dT0_dT = 0.0;
3852 }
3853
3854 tmp1 = VACLM * VACLM;
3855 tmp2 = VADIBL * VADIBL;
3856 tmp3 = VACLM + VADIBL;
3857
3858 T1 = VACLM * VADIBL / tmp3;
3859 tmp3 *= tmp3;
3860 dT1_dVg = (tmp1 * dVADIBL_dVg + tmp2 * dVACLM_dVg) / tmp3;
3861 dT1_dVd = (tmp1 * dVADIBL_dVd + tmp2 * dVACLM_dVd) / tmp3;
3862 dT1_dVb = (tmp1 * dVADIBL_dVb + tmp2 * dVACLM_dVb) / tmp3;
3863 dT1_dVe = (tmp1 * dVADIBL_dVe + tmp2 * dVACLM_dVe) / tmp3; /* LFW_FD new line */
3864 if (selfheat)
3865 /*fix below expression - Wagner */
3866 /*dT1_dT = (tmp1 * dVADIBL_dT + tmp2 * dVACLM_dT ) / tmp3;*/
3867 dT1_dT = (dVACLM_dT * VADIBL + VACLM * dVADIBL_dT
3868 - T1 * (dVACLM_dT + dVADIBL_dT))/ (VACLM + VADIBL);
3869 else dT1_dT = 0.0;
3870
3871 /* v4.0 adding DITS */
3872 tmp1 = T1 * T1;
3873 tmp2 = VADITS * VADITS;
3874 tmp3 = T1 + VADITS;
3875 T2 = T1 * VADITS / tmp3;
3876 tmp3 *= tmp3;
3877 dT2_dVg = (tmp1 * dVADITS_dVg + tmp2 * dT1_dVg) / tmp3;
3878 dT2_dVd = (tmp1 * dVADITS_dVd + tmp2 * dT1_dVd) / tmp3;
3879 /* LFW_FD fix/add 2 derivatives */
3880 dT2_dVb = (tmp1 * dVADITS_dVb + tmp2 * dT1_dVb) / tmp3;
3881 dT2_dVe = (tmp1 * dVADITS_dVe + tmp2 * dT1_dVe) / tmp3;
3882 if (selfheat)
3883 /*fix below expression - Wagner */
3884 /*dT2_dT = (tmp1 * dVADITS_dT + tmp2 * dT1_dT ) / tmp3;*/
3885 dT2_dT = (dT1_dT * VADITS + T1 * dVADITS_dT
3886 - T2 * (dT1_dT + dVADITS_dT))/(T1 + VADITS);
3887 else dT2_dT = 0.0;
3888
3889 /*
3890 Va = Vasat + T0 * T1;
3891 dVa_dVg = dVasat_dVg + T1 * dT0_dVg + T0 * dT1_dVg;
3892 dVa_dVd = dVasat_dVd + T1 * dT0_dVd + T0 * dT1_dVd;
3893 dVa_dVb = dVasat_dVb + T1 * dT0_dVb + T0 * dT1_dVb;
3894 if (selfheat)
3895 dVa_dT = dVasat_dT + T1 * dT0_dT + T0 * dT1_dT;
3896 else dVa_dT = 0.0;
3897 */
3898 /* v4.0 */
3899 Va = Vasat + T0 * T2;
3900 dVa_dVg = dVasat_dVg + T2 * dT0_dVg + T0 * dT2_dVg;
3901 dVa_dVd = dVasat_dVd + T2 * dT0_dVd + T0 * dT2_dVd;
3902 dVa_dVb = dVasat_dVb + T2 * dT0_dVb + T0 * dT2_dVb;
3903 dVa_dVe = dVasat_dVe + T2 * dT0_dVe + T0 * dT2_dVe; /* LFW_FD new line */
3904 if (selfheat)
3905 dVa_dT = dVasat_dT + T2 * dT0_dT + T0 * dT2_dT;
3906 else dVa_dT = 0.0;
3907
3908 /* Calculate Ids */
3909 CoxWovL = model->B4SOIcox * Weff / Leff;
3910 beta = ueff * CoxWovL;
3911 dbeta_dVg = CoxWovL * dueff_dVg + beta * dWeff_dVg / Weff ;
3912 /* LFW_FD fix/add 3 derivatives */
3913 dbeta_dVd = CoxWovL * dueff_dVd + beta * dWeff_dVd / Weff ;
3914 dbeta_dVb = CoxWovL * dueff_dVb + beta * dWeff_dVb / Weff ;
3915 dbeta_dVe = CoxWovL * dueff_dVe + beta * dWeff_dVe / Weff ;
3916 /* fix below if expresssion - Wagner */
3917 /*if (selfheat) dbeta_dT = CoxWovL * dueff_dT; */
3918 if (selfheat) dbeta_dT = CoxWovL * dueff_dT + beta * dWeff_dT / Weff ;
3919 else dbeta_dT = 0.0;
3920
3921 T0 = 1.0 - 0.5 * Abulk * Vdseff / Vgst2Vtm;
3922 /* LFW_FD fix/add 4 derivatives */
3923 dT0_dVg = -0.5 * (Abulk * dVdseff_dVg + dAbulk_dVg * Vdseff
3924 -Abulk * Vdseff * dVgsteff_dVg / Vgst2Vtm) / Vgst2Vtm;
3925 dT0_dVb = -0.5 * (Abulk * dVdseff_dVb + dAbulk_dVb * Vdseff
3926 -Abulk * Vdseff * dVgsteff_dVb / Vgst2Vtm) / Vgst2Vtm;
3927 dT0_dVd = -0.5 * (Abulk * dVdseff_dVd + dAbulk_dVd * Vdseff
3928 -Abulk * Vdseff * dVgsteff_dVd / Vgst2Vtm) / Vgst2Vtm;
3929 dT0_dVe = -0.5 * (Abulk * dVdseff_dVe + dAbulk_dVe * Vdseff
3930 -Abulk * Vdseff * dVgsteff_dVe / Vgst2Vtm) / Vgst2Vtm;
3931 if (selfheat)
3932 /* fix first line of below expression - Wagner */
3933 /*dT0_dT = -0.5 * (Abulk * dVdseff_dT */
3934 dT0_dT = -0.5 * (Abulk * dVdseff_dT + dAbulk_dT * Vdseff
3935 - Abulk * Vdseff / Vgst2Vtm * dVgst2Vtm_dT)
3936 / Vgst2Vtm;
3937 else dT0_dT = 0.0;
3938
3939 fgche1 = Vgsteff * T0;
3940 /* LFW_FD fix/add 4 derivatives */
3941 dfgche1_dVg = Vgsteff * dT0_dVg + dVgsteff_dVg * T0;
3942 dfgche1_dVb = Vgsteff * dT0_dVb + dVgsteff_dVb * T0;
3943 dfgche1_dVd = Vgsteff * dT0_dVd + dVgsteff_dVd * T0;
3944 dfgche1_dVe = Vgsteff * dT0_dVe + dVgsteff_dVe * T0;
3945 /* fix below expression - Wagner */
3946 /*if (selfheat) dfgche1_dT = Vgsteff * dT0_dT;*/
3947 if (selfheat) dfgche1_dT = Vgsteff * dT0_dT + T0 * dVgsteff_dT;
3948 else dfgche1_dT = 0.0;
3949
3950 T9 = Vdseff / EsatL;
3951 fgche2 = 1.0 + T9;
3952 dfgche2_dVg = (dVdseff_dVg - T9 * dEsatL_dVg) / EsatL;
3953 dfgche2_dVd = (dVdseff_dVd - T9 * dEsatL_dVd) / EsatL;
3954 dfgche2_dVb = (dVdseff_dVb - T9 * dEsatL_dVb) / EsatL;
3955 dfgche2_dVe = (dVdseff_dVe - T9 * dEsatL_dVe) / EsatL; /* LFW_FD new line */
3956 if (selfheat) dfgche2_dT = (dVdseff_dT - T9 * dEsatL_dT) / EsatL;
3957 else dfgche2_dT = 0.0;
3958
3959 gche = beta * fgche1 / fgche2;
3960 dgche_dVg = (beta * dfgche1_dVg + fgche1 * dbeta_dVg
3961 - gche * dfgche2_dVg) / fgche2;
3962 dgche_dVd = (beta * dfgche1_dVd + fgche1 * dbeta_dVd
3963 - gche * dfgche2_dVd) / fgche2;
3964 dgche_dVb = (beta * dfgche1_dVb + fgche1 * dbeta_dVb
3965 - gche * dfgche2_dVb) / fgche2;
3966 /* LFW_FD add 1 derivative */
3967 dgche_dVe = (beta * dfgche1_dVe + fgche1 * dbeta_dVe
3968 - gche * dfgche2_dVe) / fgche2;
3969 if (selfheat)
3970 dgche_dT = (beta * dfgche1_dT + fgche1 * dbeta_dT
3971 - gche * dfgche2_dT) / fgche2;
3972 else dgche_dT = 0.0;
3973
3974 T0 = 1.0 + gche * Rds;
3975 T9 = Vdseff / T0;
3976 Idl = gche * T9;
3977 IdlovVdseff = gche / T0;
3978
3979 /* Whoa, these formulas for the derivatives of Idl are convoluted, but I
3980 verified them to be correct */
3981
3982 dIdl_dVg = (gche * dVdseff_dVg + T9 * dgche_dVg) / T0
3983 - Idl * gche / T0 * dRds_dVg ;
3984 /* LFW_FD fix/add 3 derivatives */
3985 dIdl_dVd = (gche * dVdseff_dVd + T9 * dgche_dVd - Idl * dRds_dVd * gche) / T0;
3986 dIdl_dVb = (gche * dVdseff_dVb + T9 * dgche_dVb
3987 - Idl * dRds_dVb * gche) / T0;
3988 dIdl_dVe = (gche * dVdseff_dVe + T9 * dgche_dVe - Idl * dRds_dVe * gche) / T0;
3989 if (selfheat)
3990 dIdl_dT = (gche * dVdseff_dT + T9 * dgche_dT
3991 - Idl * dRds_dT * gche) / T0;
3992 else dIdl_dT = 0.0;
3993
3994 T9 = diffVds / Va;
3995 T0 = 1.0 + T9;
3996 here->B4SOIids = Ids = Idl * T0 / here->B4SOInseg;
3997 /* LFW_FD add 4 derivatives */
3998 dIds_dVg = (dIdl_dVg * T0 - Idl * (dVdseff_dVg + T9 * dVa_dVg) / Va)/ here->B4SOInseg;
3999 dIds_dVb = (dIdl_dVb * T0 - Idl * (dVdseff_dVb + T9 * dVa_dVb) / Va)/ here->B4SOInseg;
4000 dIds_dVd = (dIdl_dVd * T0 + Idl * (1.0 - dVdseff_dVd - T9 * dVa_dVd) / Va)/ here->B4SOInseg;
4001 dIds_dVe = (dIdl_dVe * T0 - Idl * (dVdseff_dVe + T9 * dVa_dVe) / Va)/ here->B4SOInseg;
4002 /* 5 new lines Wagner */
4003 if (selfheat)
4004 dIds_dT = dIdl_dT * T0 / here->B4SOInseg
4005 + Idl * (-dVdseff_dT/Va -diffVds/Va/Va*dVa_dT)
4006 / here->B4SOInseg;
4007 else dIds_dT = 0.0;
4008
4009 here->B4SOIidovVds = IdlovVdseff * T0 / here->B4SOInseg;
4010 /* v4.0 bug fix */
4011 /* IdovVds = IdlovVdseff * T0 / here->B4SOInseg; LFW_FD not needed */
4012
4013 Gm0 = T0 * dIdl_dVg - Idl * (dVdseff_dVg + T9 * dVa_dVg) / Va;
4014 Gds0 = T0 * dIdl_dVd + Idl * (1.0 - dVdseff_dVd
4015 - T9 * dVa_dVd) / Va;
4016 Gmb0 = T0 * dIdl_dVb - Idl * (dVdseff_dVb + T9 * dVa_dVb) / Va;
4017 Gme0 = dIdl_dVe * T0 - Idl * (dVdseff_dVe + T9 * dVa_dVe) / Va; /* LFW_FD new line */
4018 /*Gmc = 0.0; LFW_FD not used */
4019
4020 if (selfheat)
4021 GmT0 = T0 * dIdl_dT - Idl * (dVdseff_dT + T9 * dVa_dT) / Va;
4022 else GmT0 = 0.0;
4023
4024 /* This includes all dependencies from Vgsteff, Vbseff */
4025
4026 /*Gm = (Gm0 * dVgsteff_dVg+ Gmb0 * dVbseff_dVg) / here->B4SOInseg; v3.0 */
4027 /*Gmb = (Gm0 * dVgsteff_dVb + Gmb0 * dVbseff_dVb) / here->B4SOInseg; */
4028 /*Gds = (Gm0 * dVgsteff_dVd+ Gmb0 * dVbseff_dVd + Gds0) / here->B4SOInseg; v3.0 */
4029 /*Gme = (Gm0 * dVgsteff_dVe + Gmb0 * dVbseff_dVe) / here->B4SOInseg; v3.0 */
4030 /* LFW_FD fix 4 derivatives */
4031 Gm = dIds_dVg;
4032 Gmb = dIds_dVb;
4033 Gds = dIds_dVd;
4034 Gme = dIds_dVe;
4035 if (selfheat)
4036 /* fix below expression Wagner */
4037 /* GmT = (Gm0 * dVgsteff_dT + Gmb0 * dVbseff_dT + GmT0) / here->B4SOInseg; v3.0 */
4038 GmT = dIds_dT;
4039 else GmT = 0.0;
4040
4041 /* LFW_FD flexilint inits */
4042 Ibsdif = dIbsdif_dVb = dIbsdif_dT = 0;
4043 Ibddif = dIbddif_dVb = dIbddif_dT = 0;
4044 Ibs1 = dIbs1_dVb = dIbs1_dT = Ibd1 = dIbd1_dVb = dIbd1_dVd = dIbd1_dT = 0;
4045 Ibs2 = dIbs2_dVb = dIbs2_dT = Ibd2 = dIbd2_dVb = dIbd2_dVd = dIbd2_dT = 0;
4046 Ibs3 = dIbs3_dVb = dIbs3_dT = Ibd3 = dIbd3_dVb = dIbd3_dVd = dIbd3_dT = 0;
4047 Ibs4 = dIbs4_dVb = dIbs4_dT = Ibd4 = dIbd4_dVb = dIbd4_dVd = dIbd4_dT = 0;
4048 Igisl = Ggisls = Ggislg = Ggislb = 0.0;
4049 dIc_dVd = dIc_dVb = 0.0;
4050
4051 /* v3.1 */
4052 if (here->B4SOIsoiMod != 2) /* v3.2 */
4053 {
4054 /* calculate GISL/GIDL current */
4055 /*4.1*/
4056 if(model->B4SOImtrlMod == 0)
4057 T0 = 3.0 * 3.9 / epsrox * toxe;
4058 else
4059 T0 = model->B4SOIepsrsub * toxe / epsrox;
4060
4061
4062 if (model->B4SOIgidlMod==0)
4063 {
4064 /*fix next if-then-else block Wagner */
4065 if (model->B4SOImtrlMod==0) {
4066 /* T1 = (- Vds - Vgs_eff - egisl) / T0; *//* Bug # 25 Jul09*/
4067 T1 = (- Vds - Vgd_eff - egisl) / T0;
4068 dTL1_dT = -dVgd_eff_dT / T0;
4069 }
4070 else {
4071 /* T1 = (- Vds - Vgs_eff - egisl+pParam->B4SOIvfbsd) / T0; */
4072 T1 = (- Vds - Vgd_eff - egisl + pParam->B4SOIvfbsd) / T0;
4073 dTL1_dT = -dVgd_eff_dT / T0;
4074 }
4075 /* GISL */
4076 if ((agisl <= 0.0) ||
4077 (bgisl <= 0.0) || (T1 <= 0.0) ||
4078 /*(cgisl < 0.0) || (Vbd > 0.0) ) */ /* v4.2 Bug # 24 Jul09*/
4079 (cgisl < 0.0) || (Vbs > 0.0) )
4080 Igisl = Ggisls = Ggislg = Ggislb = Ggislt = 0.0; /* enhanced line Wagner */
4081
4082 else {
4083 dT1_dVd = 1 / T0;
4084 /* dT1_dVg = - dT1_dVd * dVgs_eff_dVg; *//* Bug fix # 25 Jul09 */
4085 dT1_dVg = - dT1_dVd * dVgd_eff_dVg;
4086 T2 = bgisl / T1;
4087 if (T2 < EXPL_THRESHOLD)
4088 {
4089 Igisl = wdios * agisl * T1 * exp(-T2);
4090 T3 = Igisl / T1 * (T2 + 1);
4091 Ggisls = T3 * dT1_dVd;
4092 /* Ggisls = T3 * dT1_dVg; */ /* Bug # 28 Jul09*/
4093 Ggislg = T3 * dT1_dVg;
4094 /* 3 new lines Wagner */
4095 if (selfheat)
4096 Ggislt = T3 * dTL1_dT;
4097 else Ggislt = 0.0;
4098 } else
4099 {
4100 T3 = wdios * agisl * MIN_EXPL;
4101 Igisl = T3 * T1 ;
4102 Ggisls = T3 * dT1_dVd;
4103 Ggislg = T3 * dT1_dVg;
4104 /* 3 new lines Wagner */
4105 if (selfheat)
4106 Ggislt = T3 * dTL1_dT;
4107 else Ggislt = 0.0;
4108 }
4109 if(cgisl >= MIN_EXPL) {
4110 T4 = Vbs * Vbs;
4111 T5 = -Vbs * T4;
4112 T6 = cgisl + T5;
4113 T7 = T5 / T6;
4114 T8 = 3.0 * cgisl * T4 / T6 / T6;
4115 Ggisls = Ggisls * T7 + Igisl * T8;
4116 Ggislg = Ggislg * T7;
4117 Ggislb = -Igisl * T8;
4118 /* 3 new lines Wagner */
4119 if (selfheat)
4120 Ggislt = Ggislt * T7;
4121 else Ggislt = 0.0;
4122 Igisl *= T7;
4123 } else
4124 Ggislb = 0.0;
4125 }
4126 here->B4SOIigisl = Igisl;
4127 /* End of GISL */
4128
4129 /* enhance next if-then-else block Wagner */
4130 if (model->B4SOImtrlMod==0) {
4131 T1 = (Vds - Vgs_eff - egidl) / T0;
4132 dTL1_dT = -dVgs_eff_dT / T0;
4133 }
4134 else {
4135 T1 = (Vds - Vgs_eff - egidl+pParam->B4SOIvfbsd) / T0;
4136 dTL1_dT = -dVgs_eff_dT / T0;
4137 }
4138
4139 /* GIDL */
4140 if ((agidl <= 0.0) ||
4141 (bgidl <= 0.0) || (T1 <= 0.0) ||
4142 (cgidl < 0.0) || (Vbd > 0.0) )
4143 Igidl = Ggidld = Ggidlg = Ggidlb = Ggidlt = 0.0; /* enhanced line Wagner */
4144
4145 else {
4146 dT1_dVd = 1 / T0;
4147 dT1_dVg = - dT1_dVd * dVgs_eff_dVg;
4148 T2 = bgidl / T1;
4149 if (T2 < EXPL_THRESHOLD)
4150 {
4151 Igidl = wdiod * agidl * T1 * exp(-T2);
4152 T3 = Igidl / T1 * (T2 + 1);
4153 Ggidld = T3 * dT1_dVd;
4154 Ggidlg = T3 * dT1_dVg;
4155 /* 3 new lines Wagner */
4156 if (selfheat)
4157 Ggidlt = T3 * dTL1_dT;
4158 else Ggidlt = 0.0;
4159 } else
4160 {
4161 T3 = wdiod * agidl * MIN_EXPL;
4162 Igidl = T3 * T1 ;
4163 Ggidld = T3 * dT1_dVd;
4164 Ggidlg = T3 * dT1_dVg;
4165 /* 3 new lines Wagner */
4166 if (selfheat)
4167 Ggidlt = T3 * dTL1_dT;
4168 else Ggidlt = 0.0;
4169 }
4170 if(cgidl >= MIN_EXPL) {
4171 T4 = Vbd * Vbd;
4172 T5 = -Vbd * T4;
4173 T6 = cgidl + T5;
4174 T7 = T5 / T6;
4175 T8 = 3.0 * cgidl * T4 / T6 / T6;
4176 Ggidld = Ggidld * T7 + Igidl * T8;
4177 Ggidlg = Ggidlg * T7;
4178 Ggidlb = -Igidl * T8;
4179 /* 3 new lines Wagner */
4180 if (selfheat)
4181 Ggidlt = Ggidlt * T7;
4182 else Ggidlt = 0.0;
4183 Igidl *= T7;
4184 } else
4185 Ggidlb = 0.0;
4186 }
4187 here->B4SOIigidl = Igidl;
4188 /* End of GIDL*/
4189 }
4190 else
4191 {
4192 /* enhance next if-then-else block Wagner */
4193 if (model->B4SOImtrlMod==0) {
4194 /* T1 = (-Vds - rgisl*Vgs_eff - pParam->B4SOIegisl) / T0;*/
4195 T1 = (-Vds - rgisl*Vgd_eff - egisl) / T0; /* Bug # 26 Jul09*/
4196 dTL1_dT = -rgisl * dVgd_eff_dT / T0;
4197 }
4198 else {
4199 /* T1 = (-Vds - rgisl*Vgs_eff - pParam->B4SOIegisl+pParam->B4SOIvfbsd) / T0; */
4200 T1 = (-Vds - rgisl*Vgd_eff - egisl + pParam->B4SOIvfbsd) / T0; /* Bug # 26 Jul09*/
4201 dTL1_dT = -rgisl * dVgd_eff_dT / T0;
4202 }
4203
4204 /* GISL */
4205
4206 if ((agisl <= 0.0) ||
4207 (bgisl <= 0.0) || (T1 <= 0.0) ||
4208 (cgisl < 0.0) )
4209 Igisl = Ggisls = Ggislg = Ggislb = Ggislt = 0.0; /* enhanced line Wagner */
4210 else
4211 {
4212 dT1_dVd = 1 / T0;
4213 /* dT1_dVg = - rgisl*dT1_dVd * dVgs_eff_dVg;*//*Bug fix #26*/
4214 dT1_dVg = - rgisl*dT1_dVd * dVgd_eff_dVg;
4215 T2 = bgisl / T1;
4216 if (T2 < EXPL_THRESHOLD)
4217 {
4218 Igisl = wdios * agisl * T1 * exp(-T2);
4219 T3 = Igisl / T1 * (T2 + 1);
4220 Ggisls = T3 * dT1_dVd;
4221 Ggislg = T3 * dT1_dVg;
4222 /* 3 new lines Wagner */
4223 if (selfheat)
4224 Ggislt = T3 * dTL1_dT;
4225 else Ggislt = 0.0;
4226 } else
4227 {
4228 T3 = wdios * agisl * MIN_EXPL;
4229 Igisl = T3 * T1 ;
4230 Ggisls = T3 * dT1_dVd;
4231 Ggislg = T3 * dT1_dVg;
4232 /* 3 new lines Wagner */
4233 if (selfheat)
4234 Ggislt = T3 * dTL1_dT;
4235 else Ggislt = 0.0;
4236 }
4237 T4 = Vbs - fgisl;
4238 /*if (T4==0)
4239 T5 =1;
4240 else
4241 T5 = kgisl/T4;
4242 T6 = exp(T5);
4243 if (T6<EXPL_THRESHOLD)
4244 {Ggisls*=exp(T5);
4245 Ggislg*=exp(T5);
4246 Ggislb = -Igisl*exp(T5)*T5/T4;
4247 Igisl*=exp(T5);
4248 }
4249 else
4250 Ggislb=0.0; v4.3 bug fix */
4251 if (T4==0)
4252 T5 = EXPL_THRESHOLD;
4253 else
4254 T5 = kgisl/T4;
4255 if (T5<EXPL_THRESHOLD)
4256 {T6 = exp(T5);
4257 Ggislb = -Igisl*T6*T5/T4;
4258 }
4259 else
4260 {T6 = MAX_EXPL;
4261 Ggislb=0.0;
4262 }
4263 Ggisls*=T6;
4264 Ggislg*=T6;
4265 /* 3 new lines Wagner */
4266 if (selfheat)
4267 Ggislt *= T6;
4268 else Ggislt = 0.0;
4269 Igisl*=T6;
4270 }
4271 here->B4SOIigisl = Igisl;
4272 /* End of GISL */
4273
4274 /* enhance next if-then-else block Wagner */
4275 if (model->B4SOImtrlMod==0) {
4276 /*T1 = (Vds - rgidl*Vgs_eff - pParam->B4SOIegidl) / T0; *//* v4.2 bugfix #26 */
4277 T1 = (Vds - rgidl*Vgs_eff - egidl) / T0;
4278 dTL1_dT = -rgidl * dVgs_eff_dT / T0;
4279 }
4280 else {
4281 /*T1 = (Vds - rgidl*Vgs_eff - pParam->B4SOIegidl+pParam->B4SOIvfbsd) / T0;*/ /* v4.2 bugfix #26 */
4282 T1 = (Vds - rgidl * Vgs_eff - egidl + pParam->B4SOIvfbsd) / T0;
4283 dTL1_dT = -rgidl * dVgs_eff_dT / T0;
4284 }
4285 /* GIDL */
4286 if ((agidl <= 0.0) ||
4287 (bgidl <= 0.0) || (T1 <= 0.0) ||
4288 (cgidl < 0.0) )
4289 Igidl = Ggidld = Ggidlg = Ggidlb = Ggidlt = 0.0; /* enhanced line Wagner */
4290 else
4291 {
4292 dT1_dVd = 1 / T0;
4293 dT1_dVg = - rgidl*dT1_dVd * dVgs_eff_dVg;
4294 T2 = bgidl / T1;
4295 if (T2 < EXPL_THRESHOLD)
4296 {
4297 Igidl = wdiod * agidl * T1 * exp(-T2);
4298 T3 = Igidl / T1 * (T2 + 1);
4299 Ggidld = T3 * dT1_dVd;
4300 Ggidlg = T3 * dT1_dVg;
4301 /* 3 new lines Wagner */
4302 if (selfheat)
4303 Ggidlt = T3 * dTL1_dT;
4304 else Ggidlt = 0.0;
4305 } else
4306 {
4307 T3 = wdiod * agidl * MIN_EXPL;
4308 Igidl = T3 * T1 ;
4309 Ggidld = T3 * dT1_dVd;
4310 Ggidlg = T3 * dT1_dVg;
4311 /* 3 new lines Wagner */
4312 if (selfheat)
4313 Ggidlt = T3 * dTL1_dT;
4314 else Ggidlt = 0.0;
4315 }
4316 T4 = Vbd - fgidl;
4317 /*if (T4==0)
4318 T5 =1;
4319 else
4320 T5 = kgidl/T4;
4321 T6 = exp(T5);
4322 if (T6<EXPL_THRESHOLD)
4323 {Ggidld*=exp(T5);
4324 Ggidlg*=exp(T5);
4325 Ggidlb = -Igidl*exp(T5)*T5/T4;
4326 Igidl*=exp(T5);
4327 }
4328 else
4329 Ggidlb=0.0; v4.3 bug fix */
4330 if (T4==0)
4331 T5 = EXPL_THRESHOLD;
4332 else
4333 T5 = kgidl/T4;
4334 if (T5<EXPL_THRESHOLD)
4335 {T6 = exp(T5);
4336 Ggidlb = -Igidl*T6*T5/T4;
4337 }
4338 else
4339 {T6 = MAX_EXPL;
4340 Ggidlb=0.0;
4341 }
4342 Ggidld*=T6;
4343 Ggidlg*=T6;
4344 /* 3 new lines Wagner */
4345 if (selfheat)
4346 Ggidlt *= T6;
4347 else Ggidlt = 0.0;
4348 Igidl*=T6;
4349 }
4350 here->B4SOIigidl = Igidl;
4351 /* End of GIDL */
4352
4353 }
4354
4355
4356
4357
4358
4359 /* calculate diode and BJT current */
4360 WsTsi = wdios * model->B4SOItsi;
4361 WdTsi = wdiod * model->B4SOItsi;
4362 /* NVtm1 = Vtm * pParam->B4SOIndiode; v4.2 bugfix */
4363 NVtm1 = Vtm * ndiode;
4364 if (selfheat)
4365 /*dNVtm1_dT = pParam->B4SOIndiode * dVtm_dT; v4.2 bugfix */
4366 dNVtm1_dT = ndiode * dVtm_dT;
4367 else
4368 dNVtm1_dT = 0;
4369 T0 = vbs_jct / NVtm1; /* v4.0 */
4370 dT0_dVb = 1.0 / NVtm1;
4371 if (selfheat)
4372 dT0_dT = -vbs_jct / NVtm1 / NVtm1 * dNVtm1_dT;
4373 else
4374 dT0_dT = 0;
4375 DEXP(T0, ExpVbsNVtm, T1);
4376 dExpVbsNVtm_dVb = T1 * dT0_dVb;
4377 if (selfheat)
4378 dExpVbsNVtm_dT = T1 * dT0_dT;
4379 else
4380 dExpVbsNVtm_dT = 0;
4381 /* NVtm1 = Vtm * pParam->B4SOIndioded; v4.2 bugfix */
4382 NVtm1 = Vtm * ndioded; /* v4.0 drain side */
4383 if (selfheat)
4384 /*dNVtm1_dT = pParam->B4SOIndioded* dVtm_dT; v4.2 bugfix */
4385 dNVtm1_dT = ndioded * dVtm_dT;
4386 else
4387 dNVtm1_dT = 0;
4388 T0 = vbd_jct / NVtm1; /* v4.0 */
4389 dT0_dVb = 1.0 / NVtm1;
4390 dT0_dVd = -dT0_dVb;
4391 if (selfheat)
4392 dT0_dT = -vbd_jct / NVtm1 / NVtm1 * dNVtm1_dT;
4393 else
4394 dT0_dT = 0;
4395 DEXP(T0, ExpVbdNVtm, T1);
4396 dExpVbdNVtm_dVb = T1 * dT0_dVb;
4397 dExpVbdNVtm_dVd = -dExpVbdNVtm_dVb;
4398 if (selfheat)
4399 dExpVbdNVtm_dT = T1 * dT0_dT;
4400 else
4401 dExpVbdNVtm_dT = 0;
4402
4403 /* Ibs1: diffusion current */
4404 if (jdifs == 0) {
4405 Ibs1 = dIbs1_dVb = dIbs1_dT = 0;
4406 }
4407 else {
4408 T0 = WsTsi * jdifs;
4409 if (selfheat)
4410 dT0_dT = WsTsi * djdifs_dT;
4411 else
4412 dT0_dT = 0;
4413 Ibs1 = T0 * (ExpVbsNVtm - 1);
4414 dIbs1_dVb = T0 * dExpVbsNVtm_dVb;
4415 if (selfheat)
4416 dIbs1_dT = T0 * dExpVbsNVtm_dT + (ExpVbsNVtm - 1) * dT0_dT;
4417 else
4418 dIbs1_dT = 0;
4419 }
4420
4421 /* Ibd1: diffusion current */
4422 if (jdifd == 0) {
4423 Ibd1 = dIbd1_dVb = dIbd1_dVd = dIbd1_dT = 0;
4424 }
4425 else {
4426 T0 = WdTsi * jdifd;
4427
4428 if (selfheat)
4429 dT0_dT = WdTsi * djdifd_dT;
4430 else
4431 dT0_dT = 0;
4432 Ibd1 = T0 * (ExpVbdNVtm - 1);
4433 dIbd1_dVb = T0 * dExpVbdNVtm_dVb;
4434 dIbd1_dVd = -dIbd1_dVb;
4435 if (selfheat)
4436 dIbd1_dT = T0 * dExpVbdNVtm_dT + (ExpVbdNVtm -1)
4437 * dT0_dT;
4438 else
4439 dIbd1_dT = 0;
4440 }
4441
4442
4443 /* Ibs2:recombination/trap-assisted tunneling current */
4444
4445 if (jrecs == 0) {
4446 Ibs2 = dIbs2_dVb = dIbs2_dT = 0;
4447 }
4448 else {
4449 /* forward bias */
4450 /* NVtmf = 0.026 * nrecf0s bugfix_snps for DC swapping
4451 * (1 + pParam->B4SOIntrecf * (TempRatio - 1));
4452 NVtmr = 0.026 * nrecr0s bugfix_snps for DC swapping
4453 * (1 + pParam->B4SOIntrecr * (TempRatio - 1)); */
4454 NVtmf = Vtm00 * nrecf0s /* bugfix_snps for DC swapping*/
4455 * (1 + pParam->B4SOIntrecf * (TempRatio - 1)); /* v4.3.1 -Tanvir */
4456 NVtmr = Vtm00 * nrecr0s /* bugfix_snps for DC swapping*/
4457 * (1 + pParam->B4SOIntrecr * (TempRatio - 1)); /* v4.3.1 -Tanvir */
4458 if (selfheat) {
4459 /* dNVtmf_dT = nrecf0s * 0.026 bugfix_snps for DC swapping
4460 * pParam->B4SOIntrecf * dTempRatio_dT;
4461 dNVtmr_dT = nrecr0s * 0.026 bugfix_snps for DC swapping
4462 * pParam->B4SOIntrecr * dTempRatio_dT; */
4463 dNVtmf_dT = nrecf0s * Vtm00 /* bugfix_snps for DC swapping*/
4464 * pParam->B4SOIntrecf * dTempRatio_dT; /* v4.3.1 -Tanvir */
4465 dNVtmr_dT = nrecr0s * Vtm00 /* bugfix_snps for DC swapping*/
4466 * pParam->B4SOIntrecr * dTempRatio_dT; /* v4.3.1 -Tanvir */
4467 }
4468 else
4469 dNVtmf_dT = dNVtmr_dT = 0;
4470
4471 T0 = vbs_jct / NVtmf; /* v4.0 */
4472 DEXP(T0,T10,T2);
4473 T4 = 1 / NVtmf;
4474 dT10_dVb = T4 * T2;
4475 if (selfheat)
4476 dT10_dT = - T4 * T2 * vbs_jct / NVtmf * dNVtmf_dT ;
4477 else dT10_dT = 0.0;
4478
4479 /* reverse bias */
4480 if ((vrec0s- vbs_jct) < 1e-3) { /* bugfix_snps for DC swapping*/
4481
4482 /* v2.2.3 bug fix */
4483 T1 = 1e3;
4484 T0 = -vbs_jct / NVtmr * vrec0s * T1; /* bugfix_snps for DC swapping*/
4485 T11 = -exp(T0);
4486
4487 dT11_dVb = dT11_dT = 0;
4488 }
4489 else {
4490 T1 = 1 / (vrec0s - vbs_jct); /* bugfix_snps for DC swapping*/
4491 T0 = -vbs_jct / NVtmr * vrec0s * T1; /* bugfix_snps for DC swapping*/
4492 dT0_dVb = -vrec0s / NVtmr * /* bugfix_snps for DC swapping*/
4493 (T1 + vbs_jct * T1 * T1) ;
4494 if (selfheat)
4495 dT0_dT = -T0 / NVtmr * dNVtmr_dT;
4496 else dT0_dT = 0;
4497
4498 DEXP(T0, T11, T2);
4499 T11 = -T11;
4500 dT11_dVb = -T2 * dT0_dVb;
4501 if (selfheat)
4502 dT11_dT = -T2 * dT0_dT;
4503 else dT11_dT = 0;
4504 }
4505 T3 = WsTsi * jrecs;
4506 Ibs2 = T3 * (T10 + T11);
4507 dIbs2_dVb = T3 * (dT10_dVb + dT11_dVb);
4508 if (selfheat)
4509 dIbs2_dT = T3 * (dT10_dT + dT11_dT)
4510 + WsTsi * (T10 + T11) * djrecs_dT;
4511 else dIbs2_dT = 0;
4512
4513 }
4514
4515 if (jrecd == 0) {
4516 Ibd2 = dIbd2_dVb = dIbd2_dVd = dIbd2_dT = 0;
4517 }
4518 else {
4519 /*NVtmf = 0.026 * nrecf0d bugfix_snps for DC swapping
4520 * (1 + pParam->B4SOIntrecf * (TempRatio - 1));
4521 NVtmr = 0.026 * nrecr0d bugfix_snps for DC swapping
4522 * (1 + pParam->B4SOIntrecr * (TempRatio - 1)); */
4523 NVtmf = Vtm00 * nrecf0d /* bugfix_snps for DC swapping*/
4524 * (1 + pParam->B4SOIntrecf * (TempRatio - 1)); /* v4.3.1 -Tanvir */
4525 NVtmr = Vtm00 * nrecr0d /* bugfix_snps for DC swapping*/
4526 * (1 + pParam->B4SOIntrecr * (TempRatio - 1)); /* v4.3.1 -Tanvir */
4527 if (selfheat) {
4528 /* dNVtmf_dT = nrecf0d * 0.026 bugfix_snps for DC swapping
4529 * pParam->B4SOIntrecf * dTempRatio_dT;
4530 dNVtmr_dT = nrecr0d * 0.026
4531 * pParam->B4SOIntrecr * dTempRatio_dT; bugfix_snps for DC swapping */
4532 dNVtmf_dT = nrecf0d * Vtm00 /*bugfix_snps for DC swapping*/
4533 * pParam->B4SOIntrecf * dTempRatio_dT; /* v4.3.1 -Tanvir */
4534 dNVtmr_dT = nrecr0d * Vtm00 /* v4.3.1 -Tanvir */
4535 * pParam->B4SOIntrecr * dTempRatio_dT; /* bugfix_snps for DC swapping*/
4536 }
4537 else
4538 dNVtmf_dT = dNVtmr_dT = 0;
4539
4540 T0 = vbd_jct / NVtmf;
4541 DEXP(T0,T10,T2);
4542 T4 = 1 / NVtmf;
4543 dT10_dVb = T4 * T2;
4544 if (selfheat)
4545 dT10_dT = - T4 * T2 * vbd_jct / NVtmf * dNVtmf_dT ;
4546 else dT10_dT = 0.0;
4547
4548 if ((vrec0d - vbd_jct) < 1e-3) { /* bugfix_snps for DC swapping*/
4549
4550 /* v2.2.3 bug fix */
4551 T1 = 1e3;
4552 T0 = -vbd_jct / NVtmr * vrec0d * T1; /* bugfix_snps for DC swapping*/
4553 T11 = -exp(T0);
4554
4555 dT11_dVb = dT11_dT = 0;
4556 }
4557 else {
4558 T1 = 1 / (vrec0d - vbd_jct); /* bugfix_snps for DC swapping*/
4559 T0 = -vbd_jct / NVtmr * vrec0d * T1; /* bugfix_snps for DC swapping*/
4560 dT0_dVb = -vrec0d / NVtmr /* bugfix_snps for DC swapping*/
4561 * (T1 + vbd_jct * T1 * T1) ;
4562 if (selfheat)
4563 dT0_dT = -T0 / NVtmr * dNVtmr_dT;
4564 else
4565 dT0_dT = 0;
4566 DEXP(T0, T11, T2);
4567 T11 = - T11;
4568 dT11_dVb = -T2 * dT0_dVb;
4569 if (selfheat)
4570 dT11_dT = -T2 * dT0_dT;
4571 else
4572 dT11_dT = 0;
4573 }
4574 T3 = WdTsi * jrecd;
4575 Ibd2 = T3 * (T10 + T11);
4576 dIbd2_dVb = T3 * (dT10_dVb + dT11_dVb);
4577 dIbd2_dVd = -dIbd2_dVb;
4578 if (selfheat)
4579 dIbd2_dT = T3 * (dT10_dT + dT11_dT)
4580 + WdTsi * (T10 + T11) * djrecd_dT;
4581 else
4582 dIbd2_dT = 0;
4583 }
4584
4585 /* Ibs3/Ibd3: recombination current in neutral body */
4586 WTsi = pParam->B4SOIweff / here->B4SOInseg * model->B4SOItsi;
4587 if (jbjts == 0.0 && jbjtd == 0.0)
4588 {
4589 Ibs3 = dIbs3_dVb = dIbs3_dVd = dIbs3_dT = 0.0;
4590 Ibd3 = dIbd3_dVb = dIbd3_dVd = dIbd3_dT = 0.0;
4591 Ibsdif = dIbsdif_dVb = dIbsdif_dT = 0;
4592 /*Ibddif = dIbddif_dVb = dIbddif_dT = 0; v4.2 */
4593 Ibddif = dIbddif_dVb = dIbddif_dT = 0;
4594 here->B4SOIic = Ic = Gcd = Gcb = GcT = 0.0;
4595 }
4596 else {
4597 Ien = WTsi * jbjts * pParam->B4SOIlratio;
4598 if (selfheat)
4599 dIen_dT = WTsi * djbjts_dT * pParam->B4SOIlratio;
4600 else
4601 dIen_dT = 0;
4602
4603 /* high level injection of source side */
4604 if ((Ehlis = Ahlis * (ExpVbsNVtm - 1)) < 1e-5) {
4605 Ehlis = dEhlis_dVb = dEhlis_dT = 0;
4606 EhlisFactor = 1;
4607 dEhlisFactor_dVb = dEhlisFactor_dT = 0;
4608 }
4609 else {
4610 dEhlis_dVb = Ahlis * dExpVbsNVtm_dVb;
4611 if (selfheat)
4612 dEhlis_dT = Ahlis * dExpVbsNVtm_dT + (ExpVbsNVtm - 1) * dAhlis_dT;
4613 else
4614 dEhlis_dT = 0;
4615 EhlisFactor = 1.0 / sqrt(1 + Ehlis);
4616 T0 = -0.5 * EhlisFactor / (1 + Ehlis);
4617 dEhlisFactor_dVb = T0 * dEhlis_dVb;
4618 if (selfheat)
4619 dEhlisFactor_dT = T0 * dEhlis_dT;
4620 else
4621 dEhlisFactor_dT = 0;
4622 }
4623
4624 /* high level injection of drain side */
4625 if ((Ehlid = Ahlid * (ExpVbdNVtm - 1)) < 1e-5) {
4626 Ehlid = dEhlid_dVb = dEhlid_dVd = dEhlid_dT = 0;
4627 EhlidFactor = 1;
4628 dEhlidFactor_dVb = dEhlidFactor_dT = 0; /* LFW_FD flexilint */
4629 }
4630 else {
4631 dEhlid_dVb = Ahlid * dExpVbdNVtm_dVb;
4632 dEhlid_dVd = -dEhlid_dVb;
4633 if (selfheat)
4634 dEhlid_dT = Ahlid * dExpVbdNVtm_dT + (ExpVbdNVtm - 1) * dAhlid_dT;
4635 else
4636 dEhlid_dT = 0;
4637 EhlidFactor = 1.0 / sqrt(1 + Ehlid);
4638 T0 = -0.5 * EhlidFactor / (1 + Ehlid);
4639 dEhlidFactor_dVb = T0 * dEhlid_dVb;
4640 if (selfheat)
4641 dEhlidFactor_dT = T0 * dEhlid_dT;
4642 else
4643 dEhlidFactor_dT = 0;
4644 }
4645
4646
4647 /* v3.1.1 bug fix for Ibjt(L) discontinuity */
4648 T0 = 1 - pParam->B4SOIarfabjt;
4649 T1 = T0 * Ien;
4650 if (selfheat)
4651 dT1_dT = T0 * dIen_dT;
4652 else
4653 dT1_dT = 0;
4654
4655 Ibs3 = T1 * (ExpVbsNVtm - 1) * EhlisFactor;
4656 dIbs3_dVb = T1 * (dExpVbsNVtm_dVb * EhlisFactor
4657 + (ExpVbsNVtm - 1) * dEhlisFactor_dVb);
4658 dIbs3_dVd = 0;
4659 if (selfheat)
4660 dIbs3_dT = dT1_dT * (ExpVbsNVtm - 1) * EhlisFactor
4661 + T1 * (dExpVbsNVtm_dT * EhlisFactor
4662 + (ExpVbsNVtm - 1) * dEhlisFactor_dT);
4663 else
4664 dIbs3_dT = 0.0;
4665
4666 Ien = WTsi * jbjtd * pParam->B4SOIlratio;
4667 if (selfheat)
4668 dIen_dT = WTsi * djbjtd_dT * pParam->B4SOIlratio;
4669 else
4670 dIen_dT = 0;
4671
4672 T1 = T0 * Ien;
4673 if (selfheat)
4674 dT1_dT = T0 * dIen_dT;
4675 else
4676 dT1_dT = 0;
4677
4678 Ibd3 = T1 * (ExpVbdNVtm - 1) * EhlidFactor;
4679 dIbd3_dVb = T1 * (dExpVbdNVtm_dVb * EhlidFactor
4680 + (ExpVbdNVtm - 1) * dEhlidFactor_dVb);
4681 dIbd3_dVd = -dIbd3_dVb;
4682 if (selfheat)
4683 dIbd3_dT = dT1_dT * (ExpVbdNVtm - 1) * EhlidFactor
4684 + T1 * (dExpVbdNVtm_dT * EhlidFactor
4685 + (ExpVbdNVtm - 1) * dEhlidFactor_dT);
4686 else
4687 dIbd3_dT = 0.0;
4688
4689
4690 /* effective diffusion current for capacitance calcu. */
4691 Iendif = WTsi * jbjts * pParam->B4SOIlratiodif;
4692 if (selfheat)
4693 dIendif_dT = WTsi * djbjts_dT * pParam->B4SOIlratiodif;
4694 else
4695 dIendif_dT = 0;
4696
4697 Ibsdif = Iendif * (ExpVbsNVtm - 1) * EhlisFactor;
4698 dIbsdif_dVb = Iendif * (dExpVbsNVtm_dVb * EhlisFactor
4699 + (ExpVbsNVtm - 1) * dEhlisFactor_dVb);
4700 if (selfheat)
4701 dIbsdif_dT = dIendif_dT * (ExpVbsNVtm - 1) * EhlisFactor
4702 + Iendif * (dExpVbsNVtm_dT * EhlisFactor
4703 + (ExpVbsNVtm - 1) * dEhlisFactor_dT);
4704 else
4705 dIbsdif_dT = 0;
4706
4707 Iendif = WTsi * jbjtd * pParam->B4SOIlratiodif;
4708 if (selfheat)
4709 dIendif_dT = WTsi * djbjtd_dT * pParam->B4SOIlratiodif;
4710 else
4711 dIendif_dT = 0;
4712
4713 Ibddif = Iendif * (ExpVbdNVtm - 1) * EhlidFactor;
4714 dIbddif_dVb = Iendif * (dExpVbdNVtm_dVb * EhlidFactor
4715 + (ExpVbdNVtm - 1) * dEhlidFactor_dVb);
4716 /*dIbddif_dVd = -dIbddif_dVb; v4.2 */
4717 if (selfheat)
4718 dIbddif_dT = dIendif_dT * (ExpVbdNVtm - 1) * EhlidFactor
4719 + Iendif * (dExpVbdNVtm_dT * EhlidFactor
4720 + (ExpVbdNVtm - 1) * dEhlidFactor_dT);
4721 else
4722 dIbddif_dT = 0;
4723
4724 /* Ic: Bjt collector current */
4725 if ((here->B4SOIbjtoff == 1) || (Vds == 0.0)) {
4726 here->B4SOIic = Ic = Gcd = Gcb = GcT = 0.0;
4727 dIc_dVb = dIc_dVd = 0.0; /*bugfix_snps for setting zero */
4728 }
4729 else {
4730 /* second order effects */
4731 /* T0 = 1 + (Vbs + Vbd) / pParam->B4SOIvearly; v4.3 bugfix */
4732 T0 = 1 + (vbs_jct + vbd_jct) / pParam->B4SOIvearly;
4733 dT0_dVb = 2.0 / pParam->B4SOIvearly;
4734 dT0_dVd = -1.0 / pParam->B4SOIvearly;
4735 T1 = Ehlis + Ehlid;
4736 dT1_dVb = dEhlis_dVb + dEhlid_dVb;
4737 dT1_dVd = dEhlid_dVd;
4738 if (selfheat)
4739 dT1_dT = dEhlis_dT + dEhlid_dT;
4740 else
4741 dT1_dT = 0;
4742
4743 T3 = sqrt(T0 * T0 + 4 * T1);
4744 dT3_dVb = 0.5 / T3 * (2 * T0 * dT0_dVb + 4 * dT1_dVb);
4745 dT3_dVd = 0.5 / T3 * (2 * T0 * dT0_dVd + 4 * dT1_dVd);
4746 if (selfheat)
4747 dT3_dT = 2 * dT1_dT / T3;
4748 else
4749 dT3_dT = 0;
4750
4751 T2 = (T0 + T3) / 2.0;
4752 dT2_dVb = (dT0_dVb + dT3_dVb) / 2.0;
4753 dT2_dVd = (dT0_dVd + dT3_dVd) / 2.0;
4754 if (selfheat)
4755 dT2_dT = dT3_dT /2.0;
4756 else
4757 dT2_dT = 0;
4758
4759 if (T2 < .1)
4760 {
4761 E2ndFactor = 10.0;
4762 dE2ndFactor_dVb = dE2ndFactor_dVd = dE2ndFactor_dT = 0;
4763 }
4764
4765 else {
4766 E2ndFactor = 1.0 / T2;
4767 dE2ndFactor_dVb = -E2ndFactor / T2 * dT2_dVb;
4768 dE2ndFactor_dVd = -E2ndFactor / T2 * dT2_dVd;
4769 if (selfheat)
4770 dE2ndFactor_dT = -E2ndFactor / T2 * dT2_dT;
4771 else
4772 dE2ndFactor_dT = 0;
4773 }
4774
4775 T0 = pParam->B4SOIarfabjt * Ien; /* here Ien refers to the drain side to simplify the code */
4776 if (selfheat)
4777 dT0_dT = pParam->B4SOIarfabjt * dIen_dT;
4778 else
4779 dT0_dT = 0;
4780 here->B4SOIic = Ic
4781 = T0 * (ExpVbsNVtm - ExpVbdNVtm) * E2ndFactor;
4782 Gcb = dIc_dVb
4783 = T0 * ((dExpVbsNVtm_dVb - dExpVbdNVtm_dVb) * E2ndFactor
4784 + (ExpVbsNVtm - ExpVbdNVtm) * dE2ndFactor_dVb);
4785 Gcd = dIc_dVd
4786 = T0 * (-dExpVbdNVtm_dVd * E2ndFactor
4787 + (ExpVbsNVtm - ExpVbdNVtm) * dE2ndFactor_dVd);
4788 if (selfheat)
4789 GcT = T0 * (dExpVbsNVtm_dT - dExpVbdNVtm_dT) * E2ndFactor
4790 + dT0_dT * (ExpVbsNVtm - ExpVbdNVtm) * E2ndFactor
4791 + T0 * (ExpVbsNVtm - ExpVbdNVtm) * dE2ndFactor_dT;
4792 else
4793 GcT = 0;
4794 }
4795 }
4796
4797 /* Ibs4/Ibd4 : tunneling */
4798 if (jtuns == 0 && jtund == 0)
4799 { Ibs4 = Ibd4 = dIbs4_dVb = dIbs4_dT = dIbd4_dVb = dIbd4_dVd = dIbd4_dT = 0;
4800 } else
4801 {
4802 /* NVtm2 = 0.026 * ntuns; */ /* bugfix_snps for junction DC swapping*/
4803 NVtm2 = Vtm00 * ntuns; /* bugfix_snps for junction DC swapping*/ /* v4.3.1 -Tanvir */
4804 if ((vtun0s - vbs_jct) < 1e-3) /* bugfix_snps for junction DC swapping*/
4805 {
4806 /* v2.2.3 bug fix */
4807 T1=1e3;
4808 T0 = -vbs_jct / NVtm2 * vtun0s * T1; /* bugfix_snps for junction DC swapping*/
4809 T1 = exp(T0);
4810 T3 = WsTsi * jtuns;
4811 Ibs4 = T3 * (1- T1);
4812
4813 /*dIbs4_dVb = dIbs4_dT = 0; */
4814 dIbs4_dVb = 0.0;
4815 if (selfheat)
4816 dIbs4_dT = (1 - T1) * WsTsi * djtuns_dT;
4817 else
4818 dIbs4_dT = 0;
4819
4820 }
4821 else {
4822 T1 = 1 / (vtun0s - vbs_jct); /*bugfix for junction DC swapping*/
4823 T0 = -vbs_jct / NVtm2 * vtun0s * T1; /*bugfix for junction DC swapping*/
4824 dT0_dVb = -vtun0s / NVtm2 * (T1 + vbs_jct * T1 * T1) ; /*bugfix for junction DC swapping*/
4825
4826 DEXP(T0, T1, T2);
4827 T3 = WsTsi * jtuns;
4828 Ibs4 = T3 * (1- T1);
4829 dIbs4_dVb = -T3 * T2 * dT0_dVb;
4830 if (selfheat)
4831 dIbs4_dT = (1 - T1) * WsTsi * djtuns_dT;
4832 else dIbs4_dT = 0;
4833 }
4834
4835 /*NVtm2 = 0.026 * ntund;*/ /* bugfix_snps for junction DC swapping*/
4836 NVtm2 = Vtm00 * ntund; /* v4.3.1 -Tanvir */
4837 if ((vtun0d - vbd_jct) < 1e-3) { /* bugfix_snps for junction DC swapping*/
4838
4839 /* v2.2.3 bug fix */
4840 T1=1e3;
4841 T0 = -vbd_jct / NVtm2 * vtun0d * T1; /* bugfix_snps for junction DC swapping*/
4842 T1 = exp(T0);
4843 T3 = WdTsi * jtund;
4844 Ibd4 = T3 * (1- T1);
4845
4846 /*dIbd4_dVb = dIbd4_dT = 0;*/
4847 dIbd4_dVb = 0;
4848 dIbd4_dVd = 0;
4849 if (selfheat)
4850 /* dIbs4_dT = (1 - T1) * WsTsi * djtuns_dT; Bug fix #8 Jun 09 'typo's corrected for Drain side */
4851 /* else dIbs4_dT = 0; */
4852 dIbd4_dT = (1 - T1) * WdTsi * djtund_dT; /* Fix */
4853 else dIbd4_dT = 0;
4854 }
4855 else {
4856 T1 = 1 / (vtun0d - vbd_jct); /* bugfix_snps for junction DC swapping*/
4857 T0 = -vbd_jct / NVtm2 * vtun0d * T1; /* bugfix_snps for junction DC swapping*/
4858 dT0_dVb = -vtun0d / NVtm2 * (T1 + vbd_jct * T1 * T1) ; /* bugfix_snps for junction DC swapping*/
4859
4860 DEXP(T0, T1, T2);
4861 T3 = WdTsi * jtund;
4862 Ibd4 = T3 * (1- T1);
4863 dIbd4_dVb = -T3 * T2 * dT0_dVb;
4864
4865 dIbd4_dVd = -dIbd4_dVb;
4866
4867 if (selfheat)
4868 dIbd4_dT = (1 - T1) * WdTsi * djtund_dT;
4869 else dIbd4_dT = 0;
4870 }
4871 }
4872
4873 here->B4SOIitun = - Ibd3 - Ibd4;
4874 Ibs = Ibs1 + Ibs2 + Ibs3 + Ibs4;
4875 Ibd = Ibd1 + Ibd2 + Ibd3 + Ibd4;
4876
4877 Gjsb = dIbs1_dVb + dIbs2_dVb + dIbs3_dVb + dIbs4_dVb;
4878 Gjsd = dIbs3_dVd;
4879 if (selfheat) GjsT = dIbs1_dT + dIbs2_dT + dIbs3_dT + dIbs4_dT;
4880 else GjsT = 0.0;
4881
4882 Gjdb = dIbd1_dVb + dIbd2_dVb + dIbd3_dVb + dIbd4_dVb;
4883 Gjdd = dIbd1_dVd + dIbd2_dVd + dIbd3_dVd + dIbd4_dVd;
4884 if (selfheat) GjdT = dIbd1_dT + dIbd2_dT + dIbd3_dT + dIbd4_dT;
4885 else GjdT = 0.0;
4886 }
4887 else /* v3.1 soiMod=2: ideal FD */
4888 {
4889 here->B4SOIigidl= Igidl
4890 = Ggidld = Ggidlg = Ggidlb = Ggidlt = 0.0; /* LFW_FD inits */
4891 here->B4SOIigisl= Igisl /* Bug fix #9 Jun 09 Code added to set Igisl components to zero */
4892 = Ggisls = Ggislg = Ggislb = Ggislt = 0.0; /* This is an appx solution */
4893
4894 here->B4SOIitun = 0;
4895 Ibs = 0;
4896 Ibd = 0;
4897 Gjsb = 0.0;
4898 Gjdb = 0.0;
4899 Gjsd = 0.0;
4900 Gjdd = 0.0;
4901
4902 /* here->B4SOIigidl= Igidl */
4903 /* = Ggidld = Ggidlg = Ggidlb = Ggidlt = 0.0; LFW_FD enhance line */
4904 /* here->B4SOIigisl= Igisl Bug fix #9 Jun 09 Code added to set Igisl components to zero */
4905 /* = Ggisls = Ggislg = Ggislb = Ggislt = 0.0; This is an appx solution - LFW_FD enhance line */
4906 /* Final code will comply with BSIM MG in future releases */
4907 /* here->B4SOIitun = 0; */
4908 /* LFW_FD next 21 lines; fix Ibs, Ibd, and derivatives Gjs* and Gjd* */
4909 /* Ibs = 0; */
4910 /* Ibd = 0; */
4911 /* Add Gmin since body node is floating - LFW - DIDN'T Converge */
4912 /* Connect to electrical source, since source is BSIM reference */
4913 /* Also option to connect to both source and drain */
4914 /* if (here->B4SOImode == 1) */
4915 /* { */
4916 /* Ibs = 1.0e-18 * vbs; */
4917 /* Ibd = 1.0e-18 * vbd; */
4918 /* } */
4919 /* else */
4920 /* { */
4921 /* Ibs = 1.0e-18 * vbd; */
4922 /* Ibd = 1.0e-18 * vbs; */
4923 /* } */
4924 /* Gjsb = 1.0e-18; */
4925 /* Gjdb = 1.0e-18; */
4926 /* Gjsd = 0.0; */
4927 /* Gjdd = -1.0e-18; */
4928 GjsT = 0;
4929 GjdT = 0;
4930
4931 here->B4SOIic = Ic = Gcd = Gcb = GcT = 0.0;
4932 }
4933 if (here->B4SOImode > 0)
4934 {
4935 here->B4SOIibs = Ibs;
4936 here->B4SOIibd = Ibd;
4937 }
4938 else
4939 {
4940 here->B4SOIibd = Ibs;
4941 here->B4SOIibs = Ibd;
4942 }
4943 /* LFW_FD 12 new lines per flexilint */
4944 Vfb = 0.0;
4945 Voxacc = dVoxacc_dVg = dVoxacc_dVd = dVoxacc_dVb = dVoxacc_dVe = 0.0;
4946 Voxdepinv = dVoxdepinv_dVg = dVoxdepinv_dVd = dVoxdepinv_dVb
4947 = dVoxdepinv_dT= dVoxdepinv_dVe = 0.0;
4948
4949 Vgb = Vgs_eff - Vbs; /* flexilint - moved from below if stmt */
4950 dVgb_dVg = dVgs_eff_dVg - dVbs_dVg;
4951 dVgb_dVd = - dVbs_dVd;
4952 dVgb_dVe = - dVbs_dVe;
4953 dVgb_dVb = - dVbs_dVb;
4954 dVoxacc_dT = 0.0;
4955 dVfb_dT = 0.0;
4956 /* v3.0: gate-tunneling */
4957 if ((model->B4SOIigbMod != 0) || (model->B4SOIigcMod != 0)) {
4958
4959 /* Calculate Vox first */
4960 Vfb = model->B4SOItype * here->B4SOIvth0 /* v4.0 */
4961 - phi - pParam->B4SOIk1eff * sqrtPhi;
4962 dVfb_dT = - dphi_dT - pParam->B4SOIk1eff*dsqrtPhi_dT; /* new line Wagner */
4963
4964 T3 = Vfb - Vgs_eff + Vbs - DELTA_3;
4965 /* LFW_FD add/fix 5 derivatives */
4966 dT3_dVg = -dVgs_eff_dVg + dVbs_dVg;
4967 dT3_dVd = dVbs_dVd;
4968 dT3_dVe = dVbs_dVe;
4969 dT3_dVb = dVbs_dVb;
4970 dTL3_dT = dVfb_dT - dVgs_eff_dT + dVbs_dT;
4971
4972 if (Vfb <= 0.0) {
4973 T0 = sqrt(T3 * T3 - 4.0 * DELTA_3 * Vfb);
4974 dT0_dVg = 1.0/(2.0 * T0) * 2.0*T3 * dT3_dVg;
4975 dT0_dVb = 0.5*(1.0/T0) * 2.0*T3 * dT3_dVb;
4976 /* LFW_FD add 2 derivatives */
4977 dT0_dVd = T3 * dT3_dVd / T0;
4978 dT0_dVe = T3 * dT3_dVe / T0;
4979 dTL0_dT = (T3 * dTL3_dT - 2.0 * DELTA_3 * dVfb_dT) / T0; /* new line Wagner */
4980 TL1 = -1.0; /* new line Wagner */
4981 }
4982 else {
4983 T0 = sqrt(T3 * T3 + 4.0 * DELTA_3 * Vfb);
4984 dT0_dVg = 1.0/(2.0 * T0) * 2.0*T3 * dT3_dVg;
4985 dT0_dVb = 0.5*(1.0/T0) * 2.0*T3 * dT3_dVb;
4986 /* LFW_FD add 2 derivatives */
4987 dT0_dVd = T3 * dT3_dVd / T0;
4988 dT0_dVe = T3 * dT3_dVe / T0;
4989 dTL0_dT = (T3 * dTL3_dT + 2.0 * DELTA_3 * dVfb_dT) / T0; /* new line Wagner */
4990 TL1 = 1.0; /* new line Wagner */
4991 }
4992
4993 Vfbeff = Vfb - 0.5 * (T3 + T0);
4994 dVfbeff_dVg = -0.5 * (dT3_dVg + dT0_dVg);
4995 dVfbeff_dVb = -0.5 * (dT3_dVb + dT0_dVb);
4996 /* LFW_FD add 2 derivatives */
4997 dVfbeff_dVd = -0.5 * (dT3_dVd + dT0_dVd);
4998 dVfbeff_dVe = -0.5 * (dT3_dVe + dT0_dVe);
4999 /* 2 new lines - Wagner */
5000 if (selfheat) dVfbeff_dT = dVfb_dT - 0.5 * (dTL3_dT + dTL0_dT);
5001 else dVfbeff_dT = 0.0;
5002
5003 Voxacc = Vfb - Vfbeff;
5004 dVoxacc_dVg = -dVfbeff_dVg;
5005 /* LFW_FD add/fix 2 derivatives */
5006 dVoxacc_dVd = -dVfbeff_dVd;
5007 dVoxacc_dVe = -dVfbeff_dVe;
5008 dVoxacc_dVb = -dVfbeff_dVb;
5009 if (Voxacc < 0.0)
5010 Voxacc = dVoxacc_dVg = dVoxacc_dVb = dVoxacc_dVd = dVoxacc_dVe = 0.0; /* LFW_FD enhance line */
5011 /* 2 new lines Wagner */
5012 if (selfheat) dVoxacc_dT = dVfb_dT - dVfbeff_dT;
5013 else dVoxacc_dT = 0.0;
5014
5015
5016 T0 = Vgs_eff - Vgsteff - Vfbeff - Vbseff;
5017 /* LFW_FD add/fix 4 derivatives */
5018 dT0_dVg = dVgs_eff_dVg - dVgsteff_dVg - dVfbeff_dVg - dVbseff_dVg; /* v3.0 */
5019 dT0_dVd = -dVgsteff_dVd - dVbseff_dVd - dVfbeff_dVd;
5020 dT0_dVb = -dVgsteff_dVb - dVbseff_dVb - dVfbeff_dVb;
5021 dT0_dVe = -dVgsteff_dVe - dVbseff_dVe - dVfbeff_dVe;
5022
5023 dVoxdepinv_dT = 0.0; /* flexilint */
5024
5025 if (selfheat)
5026 /* fix below expression Wagner */
5027 /*dT0_dT = -dVgsteff_dT - dVbseff_dT; v3.0 */
5028 dT0_dT = dVgs_eff_dT - dVgsteff_dT - dVfbeff_dT - dVbseff_dT; /* v3.0 */
5029
5030
5031 if (pParam->B4SOIk1ox == 0.0) /* v4.0 */ {
5032 Voxdepinv = dVoxdepinv_dVg = dVoxdepinv_dVd = dVoxdepinv_dVb
5033 = dVoxdepinv_dT = 0.0;
5034 } else {
5035 if (T0 < 0.0) {
5036 T1 = T0/pParam->B4SOIk1ox;
5037 dT1_dVg = dT0_dVg/pParam->B4SOIk1ox;
5038 dT1_dVd = dT0_dVd/pParam->B4SOIk1ox;
5039 dT1_dVb = dT0_dVb/pParam->B4SOIk1ox;
5040 dT1_dVe = dT0_dVe/pParam->B4SOIk1ox; /* v3.0 */
5041 if (selfheat) dT1_dT = dT0_dT/pParam->B4SOIk1ox;
5042 else dT1_dT = 0.0; /* new line Wagner */
5043 }
5044 else {
5045 T1 = pParam->B4SOIk1ox/2*(-1 + sqrt(1 +
5046 4*T0/pParam->B4SOIk1ox/pParam->B4SOIk1ox));
5047 T2 = pParam->B4SOIk1ox/2 *
5048 0.5/sqrt(1 + 4*T0/pParam->B4SOIk1ox/pParam->B4SOIk1ox) *
5049 4/pParam->B4SOIk1ox/pParam->B4SOIk1ox;
5050 dT1_dVg = T2 * dT0_dVg;
5051 dT1_dVd = T2 * dT0_dVd;
5052 dT1_dVb = T2 * dT0_dVb;
5053 dT1_dVe = T2 * dT0_dVe; /* v3.0 */
5054 if (selfheat)
5055 dT1_dT = T2 * dT0_dT;
5056 else dT1_dT = 0.0; /* new line Wagner */
5057 }
5058
5059 Voxdepinv = Vgs_eff - (T1*T1 + Vbs) - Vfb;
5060 /* LFW_FD add/fix 5 derivatives */
5061 dVoxdepinv_dVg = dVgs_eff_dVg - (2.0*T1*dT1_dVg) - dVbs_dVg;
5062 dVoxdepinv_dVd = -(2.0*T1*dT1_dVd) - dVbs_dVd;
5063 dVoxdepinv_dVb = -(2.0*T1*dT1_dVb) - dVbs_dVb;
5064 dVoxdepinv_dVe = -(2.0*T1*dT1_dVe) - dVbs_dVe;
5065 if (selfheat)
5066 dVoxdepinv_dT = dVgs_eff_dT -(2.0*T1*dT1_dT) - dVbs_dT - dVfb_dT;
5067 else dVoxdepinv_dT = 0.0;
5068 }
5069 }
5070
5071
5072 /* gate-channel tunneling component */
5073
5074 /* LFW_FD next 6 lines - flexilint inits */
5075 Igd = dIgd_dVg = dIgd_dVd = 0.0;
5076 Igcd = dIgcd_dVg = dIgcd_dVd = dIgcd_dVb = dIgcd_dVe = 0.0;
5077 Igs = dIgs_dVg = dIgs_dVs = 0.0;
5078 Igcs = dIgcs_dVg = dIgcs_dVd = dIgcs_dVb = dIgcs_dVe = 0.0;
5079 ExpVxNVt = 0.0;
5080 dIgcd_dT = dIgcs_dT = 0.0;
5081
5082 if (model->B4SOIigcMod)
5083 { T0 = Vtm * pParam->B4SOInigc;
5084 /* 2 new lines Wagner */
5085 if (selfheat) dT0_dT = pParam->B4SOInigc * dVtm_dT;
5086 else dT0_dT = 0.0;
5087 VxNVt = (Vgs_eff - model->B4SOItype * here->B4SOIvth0)
5088 / T0; /* Vth instead of Vth0 may be used */
5089 /* 2 new lines Wagner */
5090 if (selfheat) dVxNVt_dT = (dVgs_eff_dT - VxNVt * dT0_dT) /T0;
5091 else dVxNVt_dT = 0.0;
5092 if (VxNVt > EXPL_THRESHOLD)
5093 { Vaux = Vgs_eff - model->B4SOItype * here->B4SOIvth0;
5094 dVaux_dVg = dVgs_eff_dVg;
5095 dVaux_dVd = 0.0;
5096 dVaux_dVb = 0.0;
5097 /* 3 new lines Wagner */
5098 if (selfheat)
5099 dVaux_dT = dVgs_eff_dT;
5100 else dVaux_dT = 0.0;
5101 }
5102 else if (VxNVt < -EXPL_THRESHOLD)
5103 { Vaux = T0 * log(1.0 + MIN_EXPL);
5104 dVaux_dVg = dVaux_dVd = dVaux_dVb = 0.0;
5105 /* 3 new lines Wagner */
5106 if (selfheat)
5107 dVaux_dT = dT0_dT * log(1.0 + MIN_EXPL);
5108 else dVaux_dT = 0.0;
5109 }
5110 else
5111 { ExpVxNVt = exp(VxNVt);
5112 Vaux = T0 * log(1.0 + ExpVxNVt);
5113 dVaux_dVg = ExpVxNVt / (1.0 + ExpVxNVt);
5114 dVaux_dVd = -dVaux_dVg * 0.0;
5115 dVaux_dVb = -dVaux_dVg * 0.0;
5116 dVaux_dVg *= dVgs_eff_dVg;
5117 /* Wagner New fix (moved from below into else block */
5118 if (selfheat)
5119 dVaux_dT = dT0_dT*log(1.0+ExpVxNVt) + T0*ExpVxNVt*dVxNVt_dT/(1.0+ExpVxNVt);
5120 else dVaux_dT = 0.0;
5121 }
5122
5123 T2 = Vgs_eff * Vaux;
5124 dT2_dVg = dVgs_eff_dVg * Vaux + Vgs_eff * dVaux_dVg;
5125 dT2_dVd = Vgs_eff * dVaux_dVd;
5126 dT2_dVb = Vgs_eff * dVaux_dVb;
5127
5128 /* 2 new lines Wagner */
5129 if (selfheat) dT2_dT = dVgs_eff_dT * Vaux + Vgs_eff * dVaux_dT;
5130 else dT2_dT = 0.0;
5131
5132 T11 = pParam->B4SOIAechvb;
5133 T12 = pParam->B4SOIBechvb;
5134 T3 = pParam->B4SOIaigc * pParam->B4SOIcigc
5135 - pParam->B4SOIbigc;
5136 T4 = pParam->B4SOIbigc * pParam->B4SOIcigc;
5137 T5 = T12 * (pParam->B4SOIaigc + T3 * Voxdepinv
5138 - T4 * Voxdepinv * Voxdepinv);
5139
5140 /* LFW_FD fix derivative */
5141 if (selfheat) dT5_dT = T12 * (T3 - 2 * T4 * Voxdepinv) * dVoxdepinv_dT;
5142 else dT5_dT = 0.0;
5143
5144 if (T5 > EXPL_THRESHOLD)
5145 { T6 = MAX_EXPL;
5146 dT6_dVg = dT6_dVd = dT6_dVb = dT6_dVe = dT6_dT = 0.0; /* LFW_FD enhance line */
5147 }
5148 else if (T5 < -EXPL_THRESHOLD)
5149 { T6 = MIN_EXPL;
5150 dT6_dVg = dT6_dVd = dT6_dVb = dT6_dVe = dT6_dT = 0.0; /* LFW_FD enhance line */
5151 }
5152 else
5153 { T6 = exp(T5);
5154 dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * Voxdepinv);
5155 dT6_dVd = dT6_dVg * dVoxdepinv_dVd;
5156 dT6_dVe = dT6_dVg * dVoxdepinv_dVe; /* LFW_FD new line */
5157 dT6_dVb = dT6_dVg * dVoxdepinv_dVb;
5158 dT6_dVg *= dVoxdepinv_dVg;
5159 /* LFW_FD fix - move from below into this else block */
5160 if (selfheat) dT6_dT = T6 * dT5_dT;
5161 else dT6_dT = 0.0;
5162 }
5163
5164
5165 Igc = T11 * T2 * T6;
5166 dIgc_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg);
5167 dIgc_dVd = T11 * (T2 * dT6_dVd + T6 * dT2_dVd);
5168 dIgc_dVe = T11 * (T2 * dT6_dVe); /* LFW_FD new line */
5169 dIgc_dVb = T11 * (T2 * dT6_dVb + T6 * dT2_dVb);
5170
5171 /* 3 new lines Wagner */
5172 if (selfheat)
5173 dIgc_dT = T11 * T2 * dT6_dT + T11 * dT2_dT * T6;
5174 else dIgc_dT = 0.0;
5175
5176 T7 = -pParam->B4SOIpigcd * Vds;
5177 T8 = T7 * T7 + 2.0e-4;
5178 dT8_dVd = -2.0 * pParam->B4SOIpigcd * T7;
5179 if (T7 > EXPL_THRESHOLD)
5180 { T9 = MAX_EXPL;
5181 dT9_dVd = 0.0;
5182 }
5183 else if (T7 < -EXPL_THRESHOLD)
5184 { T9 = MIN_EXPL;
5185 dT9_dVd = 0.0;
5186 }
5187 else
5188 { T9 = exp(T7);
5189 dT9_dVd = -T9 * pParam->B4SOIpigcd;
5190 }
5191
5192 T0 = T8 * T8;
5193 T1 = T9 - 1.0 + 1.0e-4;
5194 T10 = (T1 - T7) / T8;
5195 dT10_dVd = ((pParam->B4SOIpigcd + dT9_dVd) * T8
5196 - (T1 - T7) * dT8_dVd) / T0;
5197 Igcs = Igc * T10;
5198 dIgcs_dVg = dIgc_dVg * T10;
5199 dIgcs_dVd = dIgc_dVd * T10 + Igc * dT10_dVd;
5200 dIgcs_dVb = dIgc_dVb * T10;
5201 dIgcs_dVe = dIgc_dVe * T10; /* LFW_FD new line */
5202
5203 /* 3 new lines Wagner */
5204 if (selfheat)
5205 dIgcs_dT = dIgc_dT * T10;
5206 else dIgcs_dT = 0.0;
5207
5208 T1 = T9 - 1.0 - 1.0e-4;
5209 T10 = (T7 * T9 - T1) / T8;
5210 dT10_dVd = (-pParam->B4SOIpigcd * T9 + (T7 - 1.0)
5211 * dT9_dVd - T10 * dT8_dVd) / T8;
5212 Igcd = Igc * T10;
5213 dIgcd_dVg = dIgc_dVg * T10;
5214 dIgcd_dVd = dIgc_dVd * T10 + Igc * dT10_dVd;
5215 dIgcd_dVb = dIgc_dVb * T10;
5216 dIgcd_dVe = dIgc_dVe * T10; /* LFW_FD new line */
5217
5218 /* 3 new lines Wagner */
5219 if (selfheat)
5220 dIgcd_dT = dIgc_dT * T10;
5221 else dIgcd_dT = 0.0;
5222
5223 here->B4SOIIgcs = Igcs;
5224 here->B4SOIgIgcsg = dIgcs_dVg;
5225 here->B4SOIgIgcsd = dIgcs_dVd;
5226 /* fix below expression Wagner */
5227 /*here->B4SOIgIgcsb = dIgcs_dVb * dVbseff_dVb;*/
5228 here->B4SOIgIgcsb = dIgcs_dVb;
5229 here->B4SOIgIgcse = dIgcs_dVe; /* LFW_FD new line */
5230 here->B4SOIIgcd = Igcd;
5231 here->B4SOIgIgcdg = dIgcd_dVg;
5232 here->B4SOIgIgcdd = dIgcd_dVd;
5233 /* fix below expression Wagner */
5234 /*here->B4SOIgIgcdb = dIgcd_dVb * dVbseff_dVb;*/
5235 here->B4SOIgIgcdb = dIgcd_dVb;
5236 here->B4SOIgIgcde = dIgcd_dVe; /* LFW_FD new line */
5237
5238
5239 T0 = vgs - pParam->B4SOIvfbsd;
5240 vgs_eff = sqrt(T0 * T0 + 1.0e-4);
5241 dvgs_eff_dvg = T0 / vgs_eff;
5242
5243 T2 = vgs * vgs_eff;
5244 dT2_dVg = vgs * dvgs_eff_dvg + vgs_eff;
5245 /* T11 = pParam->B4SOIAechvbEdge; */
5246 T13 = pParam->B4SOIAechvbEdges;
5247 T14 = pParam->B4SOIAechvbEdged;
5248 T12 = pParam->B4SOIBechvbEdge;
5249 T3 = pParam->B4SOIaigsd * pParam->B4SOIcigsd
5250 - pParam->B4SOIbigsd;
5251 T4 = pParam->B4SOIbigsd * pParam->B4SOIcigsd;
5252 T5 = T12 * (pParam->B4SOIaigsd + T3 * vgs_eff
5253 - T4 * vgs_eff * vgs_eff);
5254 if (T5 > EXPL_THRESHOLD)
5255 { T6 = MAX_EXPL;
5256 dT6_dVg = 0.0;
5257 }
5258 else if (T5 < -EXPL_THRESHOLD)
5259 { T6 = MIN_EXPL;
5260 dT6_dVg = 0.0;
5261 }
5262 else
5263 { T6 = exp(T5);
5264 dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * vgs_eff)
5265 * dvgs_eff_dvg;
5266 }
5267 /* Igs = T11 * T2 * T6; */
5268 Igs = T13 * T2 * T6;
5269 dIgs_dVg = T13 * (T2 * dT6_dVg + T6 * dT2_dVg);
5270 dIgs_dVs = -dIgs_dVg;
5271
5272 T0 = vgd - pParam->B4SOIvfbsd;
5273 vgd_eff = sqrt(T0 * T0 + 1.0e-4);
5274 dvgd_eff_dvg = T0 / vgd_eff;
5275
5276 T2 = vgd * vgd_eff;
5277 dT2_dVg = vgd * dvgd_eff_dvg + vgd_eff;
5278 T5 = T12 * (pParam->B4SOIaigsd + T3 * vgd_eff
5279 - T4 * vgd_eff * vgd_eff);
5280 if (T5 > EXPL_THRESHOLD)
5281 { T6 = MAX_EXPL;
5282 dT6_dVg = 0.0;
5283 }
5284 else if (T5 < -EXPL_THRESHOLD)
5285 { T6 = MIN_EXPL;
5286 dT6_dVg = 0.0;
5287 }
5288 else
5289 { T6 = exp(T5);
5290 dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * vgd_eff)
5291 * dvgd_eff_dvg;
5292 }
5293 /* Igd = T11 * T2 * T6; */
5294 Igd = T14 * T2 * T6;
5295 dIgd_dVg = T14 * (T2 * dT6_dVg + T6 * dT2_dVg);
5296 dIgd_dVd = -dIgd_dVg;
5297
5298 here->B4SOIIgs = Igs;
5299 here->B4SOIgIgsg = dIgs_dVg;
5300 here->B4SOIgIgss = dIgs_dVs;
5301 here->B4SOIIgd = Igd;
5302 here->B4SOIgIgdg = dIgd_dVg;
5303 here->B4SOIgIgdd = dIgd_dVd;
5304 }
5305 else
5306 { here->B4SOIIgcs = here->B4SOIgIgcsg = here->B4SOIgIgcsd
5307 = here->B4SOIgIgcsb = 0.0;
5308 here->B4SOIIgcd = here->B4SOIgIgcdg = here->B4SOIgIgcdd
5309 = here->B4SOIgIgcdb = 0.0;
5310 here->B4SOIIgs = here->B4SOIgIgsg = here->B4SOIgIgss = 0.0;
5311 here->B4SOIIgd = here->B4SOIgIgdg = here->B4SOIgIgdd = 0.0;
5312 }
5313
5314 here->B4SOIgIgcss = -(here->B4SOIgIgcsg + here->B4SOIgIgcsd
5315 + here->B4SOIgIgcsb + here->B4SOIgIgcse); /* LFW_FD fix line */
5316 here->B4SOIgIgcds = -(here->B4SOIgIgcdg + here->B4SOIgIgcdd
5317 + here->B4SOIgIgcdb + here->B4SOIgIgcde); /* LFW_FD fix line */
5318
5319
5320 Vfb2 = dVox_dT = 0.0;
5321 /* gate-body tunneling component */
5322 if ((model->B4SOIigbMod!= 0) && (here->B4SOIsoiMod != 2)) /* v3.2 */
5323 /* v3.1: the Igb calculation is skipped for the ideal FD mode */
5324 {
5325 OxideRatio = pParam->B4SOIoxideRatio;
5326
5327 Vox = Voxdepinv;
5328 /* Voxeff is Vox limited below Voxh */
5329 T0 = model->B4SOIvoxh;
5330 T1 = T0 - Vox - model->B4SOIdeltavox;
5331 T3 = sqrt(T1 * T1 + 4*model->B4SOIdeltavox * T0);
5332 Voxeff = T0 - 0.5 * (T1 + T3);
5333 dVoxeff_dVox = 0.5 * (1.0 + T1 / T3);
5334
5335 Vox = Voxeff;
5336 dVox_dVg = dVoxdepinv_dVg * dVoxeff_dVox;
5337 dVox_dVd = dVoxdepinv_dVd * dVoxeff_dVox;
5338 dVox_dVb = dVoxdepinv_dVb * dVoxeff_dVox;
5339 dVox_dVe = dVoxdepinv_dVe * dVoxeff_dVox; /* v3.0 */
5340 if (selfheat) /* v4.2 Bug # 23 Jul09 */
5341 dVox_dT = dVoxdepinv_dT * dVoxeff_dVox;
5342
5343
5344 T0 = (Vox - model->B4SOIebg)/model->B4SOIvevb;
5345 if (selfheat)
5346 dT0_dT = dVox_dT /model->B4SOIvevb;
5347
5348 DEXP(T0, T1, T2); /* T1=exp(T0), T2=dT1_dT0 */
5349 if (selfheat)
5350 dT1_dT = T2 * dT0_dT;
5351
5352 Vaux = model->B4SOIvevb * log(1 + T1);
5353 dVaux_dVg = T2 / (1 + T1) * dVox_dVg;
5354 dVaux_dVd = T2 / (1 + T1) * dVox_dVd;
5355 dVaux_dVb = T2 / (1 + T1) * dVox_dVb;
5356 dVaux_dVe = T2 / (1 + T1) * dVox_dVe; /* v3.0 */
5357 if (selfheat)
5358 dVaux_dT = T2 / (1 + T1) * dVox_dT; /* LFW_FD fix line */
5359 else
5360 dVaux_dT = 0.0;
5361
5362 if (model->B4SOIvgb1 != 0) {
5363 T0 = 1 - Vox / model->B4SOIvgb1;
5364 dT0_dVox = -1.0/model->B4SOIvgb1;
5365 if (selfheat)
5366 dT0_dT = -dVox_dT / model->B4SOIvgb1;
5367 } else {
5368 T0 = 1;
5369 dT0_dVox = dT0_dT = 0.0;
5370 }
5371
5372 if (T0 < 0.01) {
5373 T0 = 0.01;
5374 dT0_dVox = dT0_dT = 0.0;
5375 }
5376
5377 /* v2.2.3 bug fix */
5378 /* T1 = (Leff * Weff / here->B4SOInseg + here->B4SOIagbcpd/here->B4SOInf) * 3.7622e-7 * OxideRatio;
5379
5380 T2 = -3.1051e10 * model->B4SOItoxqm; */
5381 T1 = (Leff * Weff / here->B4SOInseg + here->B4SOIagbcpd/here->B4SOInf) * agb1 * OxideRatio; /* bugfix v4.3.1 -Tanvir */
5382
5383 T2 = bgb1 * model->B4SOItoxqm; /* bugfix v4.3.1 -Tanvir */
5384 T3 = pParam->B4SOIalphaGB1;
5385 T4 = pParam->B4SOIbetaGB1;
5386
5387 T6 = T2*(T3 - T4 * Vox) / T0;
5388 if (selfheat) dT6_dT = -T2 * T4 * dVox_dT / T0 - T6/T0 * dT0_dT;
5389 else dT6_dT = 0.0; /* flexilint */
5390
5391 DEXP(T6, T5, T7); /* T5=exp(T6), T7=dT5_dT6 */
5392 dT5_dVg = -T7 * dVox_dVg * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox);
5393 dT5_dVd = -T7 * dVox_dVd * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox);
5394 dT5_dVb = -T7 * dVox_dVb * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox);
5395 dT5_dVe = -T7 * dVox_dVe * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox); /* v3.0 */
5396 if (selfheat)
5397 dT5_dT = T7 * dT6_dT;
5398 else
5399 dT5_dT = 0.0; /* flexilint */
5400
5401 Igb1 = T1 * Vgb * Vaux * T5;
5402 /* LFW_FD fix 5 derivatives */
5403 dIgb1_dVg = T1 * (Vgb*Vaux*dT5_dVg + dVgb_dVg*Vaux*T5 +
5404 Vgb*T5*dVaux_dVg)
5405 + Vgb * Vaux * T5 * Leff * dWeff_dVg * agb1 * OxideRatio / here->B4SOInseg;
5406 dIgb1_dVd = T1 * (Vgb*Vaux*dT5_dVd + Vgb*T5*dVaux_dVd + dVgb_dVd*Vaux*T5);
5407 dIgb1_dVb = T1 * (Vgb*Vaux*dT5_dVb + dVgb_dVb*Vaux*T5 +
5408 Vgb*T5*dVaux_dVb)
5409 + Vgb * Vaux * T5 * Leff * dWeff_dVb * agb1 * OxideRatio / here->B4SOInseg;
5410 dIgb1_dVe = T1 * (Vgb*Vaux*dT5_dVe + Vgb*T5*dVaux_dVe + dVgb_dVe*Vaux*T5);
5411 if (selfheat)
5412 dIgb1_dT = T1 * Vgb * (Vaux*dT5_dT + T5*dVaux_dT)
5413 + Vgb * Vaux * T5 * Leff * dWeff_dT * agb1 * OxideRatio / here->B4SOInseg
5414 + T1 * dVgs_eff_dT * Vaux * T5;
5415 else dIgb1_dT = 0.0;
5416
5417
5418 Vox = Voxacc;
5419 /* Voxeff is Vox limited below Voxh */
5420 T0 = model->B4SOIvoxh;
5421 T1 = T0 - Vox - model->B4SOIdeltavox;
5422 T3 = sqrt(T1 * T1 + 4*model->B4SOIdeltavox * T0);
5423 Voxeff = T0 - 0.5 * (T1 + T3);
5424 dVoxeff_dVox = 0.5 * (1.0 + T1 / T3);
5425
5426 Vox = Voxeff;
5427 dVox_dVg = dVoxacc_dVg * dVoxeff_dVox;
5428 dVox_dVd = dVoxacc_dVd * dVoxeff_dVox;
5429 dVox_dVe = dVoxacc_dVe * dVoxeff_dVox; /* LFW_FD new line */
5430 dVox_dVb = dVoxacc_dVb * dVoxeff_dVox;
5431 /* fix below expression Wagner */
5432 /*dVox_dT = 0;*/
5433 dVox_dT = dVoxeff_dVox * dVoxacc_dT;
5434
5435 T0 = (-Vgb+(Vfb))/model->B4SOIvecb;
5436 /* fix below expression Wagner */
5437 /*if (selfheat)
5438 dT0_dT = 0;*/
5439 if (selfheat)
5440 dT0_dT = dVfb_dT/model->B4SOIvecb;
5441 else dT0_dT = 0;
5442
5443 DEXP(T0, T1, T2); /* T1=exp(T0), T2=dT1_dT0 */
5444 /* fix below expression - Wagner */
5445 /*if (selfheat)
5446 dT1_dT = 0;*/
5447 if (selfheat)
5448 dT1_dT = T2 * dT0_dT;
5449 else dT1_dT = 0;
5450
5451 Vaux = model->B4SOIvecb* log(1 + T1);
5452 /* LFW_FD fix/add 4 derivatives */
5453 dVaux_dVg = - T2 / (1 + T1) * dVgb_dVg;
5454 dVaux_dVd = - T2 / (1 + T1) * dVgb_dVd;
5455 dVaux_dVe = - T2 / (1 + T1) * dVgb_dVe;
5456 dVaux_dVb = - T2 / (1 + T1) * dVgb_dVb;
5457 /* fix below expression - Wagner */
5458 /*if (selfheat)
5459 dVaux_dT = 0;*/
5460 if (selfheat)
5461 dVaux_dT = model->B4SOIvecb * dT1_dT / (1 + T1);
5462 else
5463 dVaux_dT = 0.0;
5464
5465 if (model->B4SOIvgb2 != 0) {
5466 T0 = 1 - Vox / model->B4SOIvgb2;
5467 dT0_dVox = -1.0/model->B4SOIvgb2;
5468 if (selfheat) dT0_dT = -dVox_dT / model->B4SOIvgb2;
5469 } else {
5470 T0 = 1;
5471 dT0_dVox = dT0_dT =0.0;
5472 }
5473
5474 if (T0 < 0.01) {
5475 T0 = 0.01;
5476 dT0_dVox = dT0_dT =0.0;
5477 }
5478
5479 /* v2.2.3 bug fix */
5480 /* T1 = (Leff * Weff / here->B4SOInseg + here->B4SOIagbcpd/here->B4SOInf) * 4.9758e-7 * OxideRatio;
5481
5482 T2 = -2.357e10 * model->B4SOItoxqm; */
5483 T1 = (Leff * Weff / here->B4SOInseg + here->B4SOIagbcpd/here->B4SOInf) * agb2 * OxideRatio; /* bugfix v4.3.1 -Tanvir */
5484
5485 T2 = bgb2 * model->B4SOItoxqm; /* bugfix v4.3.1 -Tanvir */
5486 T3 = pParam->B4SOIalphaGB2;
5487 T4 = pParam->B4SOIbetaGB2;
5488
5489 T6 = T2*(T3 - T4 * Vox) / T0;
5490 if (selfheat) dT6_dT = -T2 * T4 * dVox_dT / T0 - T6/T0 * dT0_dT;
5491 else dT6_dT = 0.0; /* flexilint */
5492
5493 DEXP(T6, T5, T7); /* T5=exp(T6), T7=dT5_dT6 */
5494 dT5_dVg = -T7 * dVox_dVg * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox);
5495 dT5_dVd = -T7 * dVox_dVd * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox);
5496 dT5_dVb = -T7 * dVox_dVb * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox);
5497 dT5_dVe = -T7 * dVox_dVe * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox); /* LFW_FD new line */
5498 if (selfheat)
5499 dT5_dT = T7 * dT6_dT;
5500 else
5501 dT5_dT = 0.0; /* flexilint */
5502
5503 Igb2 = T1 * Vgb * Vaux * T5;
5504 /* LFW_FD fix 5 derivatives */
5505 dIgb2_dVg = T1 * (Vgb*Vaux*dT5_dVg + dVgb_dVg*Vaux*T5 + Vgb*T5*dVaux_dVg)
5506 + Vgb * Vaux * T5 * Leff * dWeff_dVg *agb2 * OxideRatio / here->B4SOInseg;
5507 dIgb2_dVd = T1 * (Vgb*Vaux*dT5_dVd + dVgb_dVd*Vaux*T5 + Vgb*T5*dVaux_dVd);
5508 dIgb2_dVb = T1 * (Vgb*Vaux*dT5_dVb + dVgb_dVb*Vaux*T5 + Vgb*T5*dVaux_dVb)
5509 + Vgb * Vaux * T5 * Leff * dWeff_dVb * agb2 * OxideRatio / here->B4SOInseg;
5510 dIgb2_dVe = T1 * (Vgb*Vaux*dT5_dVe + dVgb_dVe*Vaux*T5 + Vgb*T5*dVaux_dVe);
5511 if (selfheat)
5512 dIgb2_dT = T1 * Vgb * (Vaux*dT5_dT + T5*dVaux_dT)
5513 + Vgb * Vaux * T5 * Leff * dWeff_dT * agb2 * OxideRatio / here->B4SOInseg
5514 + T1 * dVgs_eff_dT * Vaux * T5;
5515 else dIgb2_dT = 0.0;
5516
5517
5518 /* Igb1 dominates in inversion region, while Igb2 dominates in accumulation */
5519 /* v2.2.3 bug fix for residue at low Vgb */
5520 if (Vgb >= 0)
5521 {
5522 Igb = Igb1;
5523 dIgb_dVg = dIgb1_dVg;
5524 dIgb_dVd = dIgb1_dVd;
5525 dIgb_dVb = dIgb1_dVb;
5526 dIgb_dVe = dIgb1_dVe; /* v3.0 */
5527 dIgb_dT = dIgb1_dT;
5528 }
5529 else
5530 {
5531 Igb = Igb2;
5532 dIgb_dVg = dIgb2_dVg;
5533 dIgb_dVd = dIgb2_dVd;
5534 dIgb_dVb = dIgb2_dVb;
5535 dIgb_dVe = dIgb2_dVe; /* LFW_FD fix line */
5536 dIgb_dT = dIgb2_dT;
5537 }
5538 /*Vfb2 = Vfb + 1.12; Bug fix #18 Jul09*/
5539 Vfb2 = Vfb + eggbcp2; /* bugfix 4.3.1 -Tanvir */
5540 }
5541 else {
5542 Igb = 0.0;
5543 dIgb_dVg = 0.0;
5544 dIgb_dVd = 0.0;
5545 dIgb_dVb = 0.0;
5546 dIgb_dVe = 0.0; /* v3.0 */
5547 dIgb_dT = 0.0;
5548 }
5549 here->B4SOIig = Igb;
5550 here->B4SOIgigg = dIgb_dVg;
5551 here->B4SOIgigd = dIgb_dVd;
5552 here->B4SOIgigb = dIgb_dVb;
5553 here->B4SOIgige = dIgb_dVe; /* v3.0 */
5554 here->B4SOIgigs = -(dIgb_dVg + dIgb_dVd + dIgb_dVb + dIgb_dVe); /* v3.0 */
5555 here->B4SOIgigT = dIgb_dT;
5556
5557 /* v4.1 */
5558 /* gate tunneling component in the AGBCP2 region */
5559 /* Vfb2 = Vfb + 1.12; Bug fix #18 Jul09 Code moved to 4370 where Vfb definition is valid*/
5560
5561 if ((model->B4SOIigbMod!= 0) && (here->B4SOIsoiMod != 2) &&
5562 (here->B4SOIbodyMod != 0) && (here->B4SOIagbcp2 > 0) &&
5563 (vgp < Vfb2))
5564 /* v4.1: the Igb2_agbcp2 calculation is skipped for the ideal FD mode or if there is no "p" node */
5565 {
5566 /* Vfb, Vfb2 are taken as constants in derivative calculation for simplicity */
5567 T0 = vgp - Vfb2;
5568
5569 T1 = sqrt(T0 * T0 + 1.0e-4);
5570 vgp_eff = 0.5 * (-T0 + T1 - 1.0e-2);
5571 dvgp_eff_dvg = 0.5 * (-1.0 + T0 / T1);
5572 dvgp_eff_dvp = -dvgp_eff_dvg;
5573 dvgp_eff_dT = 0.5 * (1.0 - T0 / T1) * dVfb_dT; /* LFW_FD new line */
5574
5575 /* T11=A* T12=B* */
5576 /*T11 = (model->B4SOItype == NMOS) ? 3.42537e-7 : 4.97232e-7;
5577 T12 = (model->B4SOItype == NMOS) ? 1.16645e12 : 7.45669e11; */
5578
5579 T11 = (model->B4SOItype == NMOS) ? agbc2n : agbc2p; /* bugfix 4.3.1 -Tanvir */
5580 T12 = (model->B4SOItype == NMOS) ? bgbc2n : bgbc2p; /* bugfix 4.3.1 -Tanvir */
5581
5582 T2 = vgp * vgp_eff;
5583 dT2_dVg = vgp * dvgp_eff_dvg + vgp_eff;
5584 dT2_dVp = vgp * dvgp_eff_dvp - vgp_eff;
5585 dT2_dT = vgp * dvgp_eff_dT; /* LFW_FD new line */
5586
5587 T3 = pParam->B4SOIaigbcp2 * pParam->B4SOIcigbcp2
5588 - pParam->B4SOIbigbcp2;
5589 T4 = pParam->B4SOIbigbcp2 * pParam->B4SOIcigbcp2;
5590 T5 = (-T12) * model->B4SOItoxqm * (pParam->B4SOIaigbcp2
5591 + T3 * vgp_eff - T4 * vgp_eff * vgp_eff);
5592 if (T5 > EXPL_THRESHOLD)
5593 {
5594 T6 = MAX_EXPL;
5595 dT6_dVg = 0.0;
5596 dT6_dVp = 0.0;
5597 dT6_dT = 0.0; /* LFW_FD new line */
5598 }
5599 else if (T5 < -EXPL_THRESHOLD)
5600 {
5601 T6 = MIN_EXPL;
5602 dT6_dVg = 0.0;
5603 dT6_dVp = 0.0;
5604 dT6_dT = 0.0; /* LFW_FD new line */
5605 }
5606 else
5607 {
5608 T6 = exp(T5);
5609 T7 = T6 * (-T12) * model->B4SOItoxqm *
5610 (T3 - 2.0 * T4 * vgp_eff);
5611 dT6_dVg = T7 * dvgp_eff_dvg;
5612 dT6_dVp = T7 * dvgp_eff_dvg;
5613 dT6_dT = T7 * dvgp_eff_dT; /* LFW_FD new line */
5614 }
5615 T11 = T11 * here->B4SOIagbcp2 * pParam->B4SOIoxideRatio;
5616 Ig_agbcp2 = T11 * T2 * T6;
5617 dIg_agbcp2_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg);
5618 dIg_agbcp2_dVp = -dIg_agbcp2_dVg;
5619 dIg_agbcp2_dT = T11 * (T2 * dT6_dT + T6 * dT2_dT); /* LFW_FD new line */
5620 }
5621 else {
5622 Ig_agbcp2 = 0.0;
5623 dIg_agbcp2_dVg = 0.0;
5624 dIg_agbcp2_dVp = 0.0;
5625 dIg_agbcp2_dT = 0.0; /* LFW_FD new line */
5626 }
5627 here->B4SOIigp = Ig_agbcp2;
5628 here->B4SOIgigpg = dIg_agbcp2_dVg;
5629 here->B4SOIgigpp = dIg_agbcp2_dVp;
5630
5631 /* end of gate-body tunneling */
5632 /* end of v3.0 gate-tunneling */
5633
5634 /* v3.1 */
5635 if (here->B4SOIsoiMod != 2) /* v3.2 */
5636 {
5637 Idsmosfet = 0.0;
5638 Ratio = dRatio_dVg = dRatio_dVd = dRatio_dVb = dRatio_dVe = dRatio_dT = 0.0;
5639 if (model->B4SOIiiiMod == 0 )
5640 {
5641 /* calculate substrate current Iii */
5642 if (pParam->B4SOIalpha0 <= 0.0) {
5643 Giig = Giib = Giid = GiiT = 0.0;
5644 Giie = 0; /* v3.0 */
5645 here->B4SOIiii = Iii = Idsmosfet = dIiibjt_dVb = dIiibjt_dVd = dIiibjt_dT = 0.0;
5646 }
5647 else {
5648 Vdsatii0 = pParam->B4SOIvdsatii0 * (1 + model->B4SOItii * (TempRatio-1.0))
5649 - pParam->B4SOIlii / Leff;
5650 if (selfheat)
5651 dVdsatii0_dT = pParam->B4SOIvdsatii0 * model->B4SOItii * dTempRatio_dT;
5652 else
5653 dVdsatii0_dT = 0;
5654
5655 /* Calculate VgsStep */
5656 T0 = pParam->B4SOIesatii * Leff; /* v3.0 bug fix: T0 is dimentionless (i.e., scaled by 1V) */
5657 T1 = pParam->B4SOIsii0 * T0 / (1.0 + T0);
5658
5659 T0 = 1 / (1 + pParam->B4SOIsii1 * Vgsteff);
5660 if (selfheat)
5661 dT0_dT = - pParam->B4SOIsii1 * T0 * T0 *dVgsteff_dT;
5662 else
5663 dT0_dT = 0;
5664 T3 = T0 + pParam->B4SOIsii2;
5665 T4 = Vgst * pParam->B4SOIsii1 * T0 * T0;
5666 T2 = Vgst * T3;
5667 dT2_dVg = T3 * (dVgst_dVg - dVth_dVb * dVbseff_dVg) - T4 * dVgsteff_dVg; /* v3.0 */
5668 dT2_dVb = T3 * dVgst_dVb * dVbseff_dVb - T4 * dVgsteff_dVb;
5669 dT2_dVe = T3 * dVgst_dVb * dVbseff_dVe - T4 * dVgsteff_dVe; /* v3.0 */
5670 dT2_dVd = T3 * (dVgst_dVd - dVth_dVb * dVbseff_dVd) - T4 * dVgsteff_dVd; /* v3.0 */
5671 if (selfheat)
5672 /* fix below expression Wagner */
5673 /*dT2_dT = -(dVth_dT + dVth_dVb * dVbseff_dT) * T3 + Vgst * dT0_dT; v3.0 */
5674 dT2_dT = (dVgst_dT ) * T3 + Vgst * dT0_dT; /* v3.0 */
5675 else dT2_dT = 0;
5676
5677
5678 T3 = 1 / (1 + pParam->B4SOIsiid * Vds);
5679 dT3_dVd = - pParam->B4SOIsiid * T3 * T3;
5680
5681 VgsStep = T1 * T2 * T3;
5682 if (selfheat)
5683 dVgsStep_dT = T1 * T3 * dT2_dT;
5684 else dVgsStep_dT = 0;
5685 Vdsatii = Vdsatii0 + VgsStep;
5686 Vdiff = Vds - Vdsatii;
5687 dVdiff_dVg = - T1 * T3 * dT2_dVg;
5688 dVdiff_dVb = - T1 * T3 * dT2_dVb;
5689 dVdiff_dVe = - T1 * T3 * dT2_dVe; /* v3.0 */
5690 dVdiff_dVd = 1.0 - T1 * (T3 * dT2_dVd + T2 * dT3_dVd);
5691 if (selfheat)
5692 dVdiff_dT = -(dVdsatii0_dT + dVgsStep_dT);
5693 else dVdiff_dT = 0;
5694
5695 T0 = pParam->B4SOIbeta2 + pParam->B4SOIbeta1 * Vdiff
5696 + pParam->B4SOIbeta0 * Vdiff * Vdiff;
5697 if (T0 < 1e-5)
5698 {
5699 T0 = 1e-5;
5700 dT0_dVg = dT0_dVd = dT0_dVb = dT0_dT = 0.0;
5701 dT0_dVe = 0; /* v3.0 */
5702 }
5703 else
5704 {
5705 T1 = pParam->B4SOIbeta1 + 2 * pParam->B4SOIbeta0 * Vdiff;
5706 dT0_dVg = T1 * dVdiff_dVg;
5707 dT0_dVb = T1 * dVdiff_dVb;
5708 dT0_dVd = T1 * dVdiff_dVd;
5709 dT0_dVe = T1 * dVdiff_dVe; /* v3.0 */
5710 if (selfheat)
5711 dT0_dT = T1 * dVdiff_dT;
5712 else
5713 dT0_dT = 0;
5714 }
5715
5716 if ((T0 < Vdiff / EXPL_THRESHOLD) && (Vdiff > 0.0)) {
5717 Ratio = pParam->B4SOIalpha0 * MAX_EXPL;
5718 dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0;
5719 dRatio_dVe = 0; /* v3.0 */
5720 }
5721 else if ((T0 < -Vdiff / EXPL_THRESHOLD) && (Vdiff < 0.0)) {
5722 Ratio = pParam->B4SOIalpha0 * MIN_EXPL;
5723 dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0;
5724 dRatio_dVe = 0; /* v3.0 */
5725 }
5726 else {
5727 Ratio = pParam->B4SOIalpha0 * exp(Vdiff / T0);
5728 T1 = Ratio / T0 / T0;
5729 dRatio_dVg = T1 * (T0 * dVdiff_dVg - Vdiff * dT0_dVg);
5730 dRatio_dVb = T1 * (T0 * dVdiff_dVb - Vdiff * dT0_dVb);
5731 dRatio_dVd = T1 * (T0 * dVdiff_dVd - Vdiff * dT0_dVd);
5732 /* v3.0 */
5733 dRatio_dVe = T1 * (T0 * dVdiff_dVe - Vdiff * dT0_dVe);
5734
5735 if (selfheat)
5736 dRatio_dT = T1 * (T0 * dVdiff_dT - Vdiff * dT0_dT);
5737 else
5738 dRatio_dT = 0;
5739 }
5740
5741 /* Avoid too high ratio */
5742 if (Ratio > 10.0) {
5743 Ratio = 10.0;
5744 dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0;
5745 dRatio_dVe = 0; /* v3.0 */
5746 }
5747
5748 T0 = Ids + pParam->B4SOIfbjtii * Ic;
5749 here->B4SOIiii = Iii = Ratio * T0;
5750 Giig = Ratio * Gm + T0 * dRatio_dVg;
5751 Giib = Ratio * (Gmb + pParam->B4SOIfbjtii * Gcb)
5752 + T0 * dRatio_dVb;
5753 Giid = Ratio * (Gds + pParam->B4SOIfbjtii * Gcd)
5754 + T0 * dRatio_dVd;
5755 /* v3.0 */
5756 Giie = Ratio * Gme + T0 * dRatio_dVe;
5757
5758 if (selfheat)
5759 GiiT = Ratio * (GmT + pParam->B4SOIfbjtii * GcT)
5760 + T0 * dRatio_dT;
5761 else
5762 GiiT = 0.0;
5763
5764 }
5765 }
5766 else /*new Iii model*/
5767 {
5768 /*Idsmosfet part*/
5769 if (pParam->B4SOIalpha0 <= 0.0) {
5770 /* Giig = Giib = Giid = GiiT = 0.0; */
5771 Giie = 0; /* v3.0 */
5772 /* here->B4SOIiii = Iii = 0.0; v4.2 bugfix #38 */
5773 /* Idsmosfet = 0.0; v4.2 bugfix #38 */
5774 /*dIiibjt_dVb = 0.0; v4.2 bugfix #38 */
5775 /*dIiibjt_dVd = 0.0; */
5776 /*dIiibjt_dT = 0.0; */
5777 Ratio = 0; /* v4.2 bugfix # 38 */
5778 }
5779 else {
5780 Vdsatii0 = pParam->B4SOIvdsatii0 * (1 + model->B4SOItii * (TempRatio-1.0))
5781 - pParam->B4SOIlii / Leff;
5782 if (selfheat)
5783 dVdsatii0_dT = pParam->B4SOIvdsatii0 * model->B4SOItii * dTempRatio_dT;
5784 else
5785 dVdsatii0_dT = 0;
5786
5787 /* Calculate VgsStep */
5788 T0 = pParam->B4SOIesatii * Leff; /* v3.0 bug fix: T0 is dimensionless (i.e., scaled by 1V) */
5789 T1 = pParam->B4SOIsii0 * T0 / (1.0 + T0);
5790
5791 T0 = 1 / (1 + pParam->B4SOIsii1 * Vgsteff);
5792 if (selfheat)
5793 dT0_dT = - pParam->B4SOIsii1 * T0 * T0 *dVgsteff_dT;
5794 else
5795 dT0_dT = 0;
5796 T3 = T0 + pParam->B4SOIsii2;
5797 T4 = Vgst * pParam->B4SOIsii1 * T0 * T0;
5798 T2 = Vgst * T3;
5799 dT2_dVg = T3 * (dVgst_dVg - dVth_dVb * dVbseff_dVg) - T4 * dVgsteff_dVg; /* v3.0 */
5800 dT2_dVb = T3 * dVgst_dVb * dVbseff_dVb - T4 * dVgsteff_dVb;
5801 dT2_dVe = T3 * dVgst_dVb * dVbseff_dVe - T4 * dVgsteff_dVe; /* v3.0 */
5802 dT2_dVd = T3 * (dVgst_dVd - dVth_dVb * dVbseff_dVd) - T4 * dVgsteff_dVd; /* v3.0 */
5803 if (selfheat)
5804 /* fix below expression Wagner */
5805 /*dT2_dT = -(dVth_dT + dVth_dVb * dVbseff_dT) * T3 + Vgst * dT0_dT; v3.0 */
5806 dT2_dT = (dVgst_dT ) * T3 + Vgst * dT0_dT; /* v3.0 */
5807 else dT2_dT = 0;
5808
5809
5810 T3 = 1 / (1 + pParam->B4SOIsiid * Vds);
5811 dT3_dVd = - pParam->B4SOIsiid * T3 * T3;
5812
5813 VgsStep = T1 * T2 * T3;
5814 if (selfheat)
5815 dVgsStep_dT = T1 * T3 * dT2_dT;
5816 else dVgsStep_dT = 0;
5817 Vdsatii = Vdsatii0 + VgsStep;
5818 Vdiff = Vds - Vdsatii;
5819 dVdiff_dVg = - T1 * T3 * dT2_dVg;
5820 dVdiff_dVb = - T1 * T3 * dT2_dVb;
5821 dVdiff_dVe = - T1 * T3 * dT2_dVe; /* v3.0 */
5822 dVdiff_dVd = 1.0 - T1 * (T3 * dT2_dVd + T2 * dT3_dVd);
5823 if (selfheat)
5824 dVdiff_dT = -(dVdsatii0_dT + dVgsStep_dT);
5825 else dVdiff_dT = 0;
5826
5827 T0 = pParam->B4SOIbeta2 + pParam->B4SOIbeta1 * Vdiff
5828 + pParam->B4SOIbeta0 * Vdiff * Vdiff;
5829 if (T0 < 1e-5)
5830 {
5831 T0 = 1e-5;
5832 dT0_dVg = dT0_dVd = dT0_dVb = dT0_dT = 0.0;
5833 dT0_dVe = 0; /* v3.0 */
5834 }
5835 else
5836 {
5837 T1 = pParam->B4SOIbeta1 + 2 * pParam->B4SOIbeta0 * Vdiff;
5838 dT0_dVg = T1 * dVdiff_dVg;
5839 dT0_dVb = T1 * dVdiff_dVb;
5840 dT0_dVd = T1 * dVdiff_dVd;
5841 dT0_dVe = T1 * dVdiff_dVe; /* v3.0 */
5842 if (selfheat)
5843 dT0_dT = T1 * dVdiff_dT;
5844 else
5845 dT0_dT = 0;
5846 }
5847
5848 if ((T0 < Vdiff / EXPL_THRESHOLD) && (Vdiff > 0.0)) {
5849 Ratio = pParam->B4SOIalpha0 * MAX_EXPL;
5850 dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0;
5851 dRatio_dVe = 0; /* v3.0 */
5852 }
5853 else if ((T0 < -Vdiff / EXPL_THRESHOLD) && (Vdiff < 0.0)) {
5854 Ratio = pParam->B4SOIalpha0 * MIN_EXPL;
5855 dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0;
5856 dRatio_dVe = 0; /* v3.0 */
5857 }
5858 else {
5859 Ratio = pParam->B4SOIalpha0 * exp(Vdiff / T0);
5860 T1 = Ratio / T0 / T0;
5861 dRatio_dVg = T1 * (T0 * dVdiff_dVg - Vdiff * dT0_dVg);
5862 dRatio_dVb = T1 * (T0 * dVdiff_dVb - Vdiff * dT0_dVb);
5863 dRatio_dVd = T1 * (T0 * dVdiff_dVd - Vdiff * dT0_dVd);
5864 /* v3.0 */
5865 dRatio_dVe = T1 * (T0 * dVdiff_dVe - Vdiff * dT0_dVe);
5866
5867 if (selfheat)
5868 dRatio_dT = T1 * (T0 * dVdiff_dT - Vdiff * dT0_dT);
5869 else
5870 dRatio_dT = 0;
5871 }
5872
5873 /* Avoid too high ratio */
5874 if (Ratio > 10.0) {
5875 Ratio = 10.0;
5876 dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0;
5877 dRatio_dVe = 0; /* v3.0 */
5878 }
5879
5880 T0 = Ids;
5881 Idsmosfet = Ratio * T0;
5882 }
5883 /*New BJT part*/
5884
5885 T0 = (pParam->B4SOIcbjtii + pParam->B4SOIebjtii * Leff)/Leff;
5886
5887 Vbci= pParam->B4SOIvbci*(1.0+model->B4SOItvbci*(TempRatio-1.0));
5888 /*T1 = Vbci - (Vbs - Vds); v4.3 bugfix*/
5889 T1 = Vbci - (vbs_jct - Vds);
5890
5891 T2 = pParam->B4SOImbjtii -1.0;
5892
5893 /*
5894 if(T1 == 0.0)
5895 T3 =1.0;
5896 else
5897 T3 = -pParam->B4SOIabjtii * pow(T1,T2);
5898 */
5899
5900 if(T1<=0.0)
5901 T3 = 0.0;
5902 else
5903 T3 = -pParam->B4SOIabjtii * pow(T1,T2);
5904
5905
5906
5907
5908
5909 if (T3> EXPL_THRESHOLD)
5910 T4 = MAX_EXPL;
5911 else if (T3 < -EXPL_THRESHOLD)
5912 T4 = MIN_EXPL;
5913 else
5914 T4 = exp(T3);
5915
5916
5917 if (T1==0.0)
5918 {if(T3> EXPL_THRESHOLD)
5919 {
5920 dT4_dVd = 0.0;
5921 dT4_dVb = 0.0;
5922 }
5923 else if (T3 < -EXPL_THRESHOLD)
5924 {
5925 dT4_dVd = 0.0;
5926 dT4_dVb = 0.0;
5927 }
5928 else
5929 {
5930 dT4_dVd = - T4 * pParam->B4SOIabjtii* T2 ;
5931 dT4_dVb = T4 * pParam->B4SOIabjtii* T2 ;
5932 }
5933 }
5934 else
5935 {
5936 if(T3> EXPL_THRESHOLD)
5937 {
5938 dT4_dVd = 0.0;
5939 dT4_dVb = 0.0;
5940 }
5941 else if (T3 < -EXPL_THRESHOLD)
5942 {
5943 dT4_dVd = 0.0;
5944 dT4_dVb = 0.0;
5945 }
5946 else
5947 {T5 = T2-1.0;
5948 if (T1<=0.0)
5949 { dT4_dVd = 0.0;
5950 dT4_dVb = 0.0;
5951 }
5952 else
5953 {
5954 dT4_dVd = - T4 * pParam->B4SOIabjtii* T2 * pow(T1,T5);
5955 dT4_dVb = T4 * pParam->B4SOIabjtii* T2 * pow(T1,T5);
5956 }
5957 }
5958
5959 }
5960
5961 Iiibjt = T0 * Ic * T1 * T4;
5962
5963 if (selfheat)
5964 {T5= T2-1.0;
5965 dVbci_dT = pParam->B4SOIvbci * model->B4SOItvbci *model->B4SOItnom;
5966 if(T1<=0.0)
5967 dT4_dT = 0.0;
5968 else
5969 dT4_dT = -T4 * pParam->B4SOIabjtii* T2 * pow(T1,T5)*dVbci_dT;
5970
5971 dIiibjt_dT = T0 * Ic * T4 * dVbci_dT
5972 + T0 *Ic *T1 * dT4_dT + T0 * GcT *T1 * T4; /* Samuel Mertens */
5973
5974 }
5975 else
5976 {
5977 dVbci_dT = 0.0;
5978 dT4_dT =0.0;
5979 dIiibjt_dT = 0.0;
5980 }
5981
5982 /* Xue fix 10/29/2009 */
5983 dIiibjt_dVd = T0 * Ic *T4
5984 + T0 *Ic *T1*dT4_dVd + T0 * dIc_dVd * T1 * T4;
5985 dIiibjt_dVb = -T0 * Ic *T4 + T0*Ic*T1*dT4_dVb + T0 * dIc_dVb * T1 * T4;
5986
5987
5988
5989
5990 /*Total Iii*/
5991 T0 = Ids;
5992 here->B4SOIiii = Iii = Idsmosfet + Iiibjt;
5993
5994
5995 Giig = Ratio * Gm + T0 * dRatio_dVg;
5996 Giib = Ratio * Gmb + T0 * dRatio_dVb + dIiibjt_dVb;
5997 Giid = Ratio * Gds + T0 * dRatio_dVd + dIiibjt_dVd;
5998 Giie = Ratio * Gme + T0 * dRatio_dVe;
5999
6000 if (selfheat)
6001 GiiT = Ratio * GmT + T0 * dRatio_dT
6002 + dIiibjt_dT ;
6003 else
6004 GiiT = 0.0;
6005
6006 }
6007
6008 /* Current through body resistor */
6009 /* Current going out is +ve */
6010 if ((here->B4SOIbodyMod == 0) || (here->B4SOIbodyMod == 2))
6011 {
6012 Ibp = Gbpbs = Gbpps = 0.0;
6013 }
6014 else { /* here->B4SOIbodyMod == 1 */
6015 if (pParam->B4SOIrbody < 1e-3) /* 3.2 bug fix */
6016 {
6017 if (here->B4SOIrbodyext <= 1e-3) /* 3.2 bug fix */
6018 T0 = 1.0 / 1e-3; /* 3.2 bug fix */
6019 else
6020 T0 = 1.0 / here->B4SOIrbodyext;
6021 Ibp = Vbp * T0;
6022 Gbpbs = T0 * dVbp_dVb;
6023 Gbpps = -T0 * dVbp_dVb;
6024 } else
6025 {
6026 Gbpbs = 1.0 / (pParam->B4SOIrbody + here->B4SOIrbodyext);
6027 Ibp = Vbp * Gbpbs;
6028 Gbpps = - Gbpbs;
6029 }
6030 }
6031
6032 here->B4SOIibp = Ibp;
6033 here->B4SOIgbpbs = Gbpbs;
6034 here->B4SOIgbpps = Gbpps;
6035 here->B4SOIgbpT = 0.0;
6036 here->B4SOIcbodcon = (Ibp - (Gbpbs * Vbs + Gbpps * Vps));
6037
6038 }
6039
6040 else /* v3.1 soiMod=2: ideal FD */
6041 {
6042 Giig = Giib = Giid = Giie = GiiT = 0.0;
6043 here->B4SOIiii = Iii = 0.0;
6044
6045 here->B4SOIibp = Ibp = 0.0;
6046 here->B4SOIgbpbs = 0.0;
6047 here->B4SOIgbpps = here->B4SOIgbpT = here->B4SOIcbodcon = 0.0;
6048 Gbpbs = Gbpps = 0.0;
6049 }
6050 /* v3.1 */
6051
6052
6053
6054 /* Current going out of drainprime node into the drain of device */
6055 /* "node" means the SPICE circuit node */
6056
6057 here->B4SOIcdrain = Ids + Ic;
6058 here->B4SOIcd = Ids + Ic - Ibd + Iii + Igidl;
6059 here->B4SOIcb = Ibs + Ibd + Ibp / here->B4SOInf - Iii - Igidl - Igisl - Igb; /* v4.2 bug fix # 27*/
6060 here->B4SOIgds = Gds + Gcd;
6061 here->B4SOIgm = Gm;
6062 here->B4SOIgmbs = Gmb + Gcb;
6063 /* v3.0 */
6064 here->B4SOIgme = Gme;
6065
6066
6067 /* v3.1 for RF */
6068 /* Calculate Rg */
6069 if (here->B4SOIrgateMod >1)
6070 { T9 = pParam->B4SOIxrcrg2 * model->B4SOIvtm;
6071 T0 = T9 *beta;
6072 dT0_dVd = (dbeta_dVd + dbeta_dVg * dVgsteff_dVd) * T9;
6073 dT0_dVb = (dbeta_dVb + dbeta_dVg * dVgsteff_dVb) * T9;
6074 dT0_dVg = dbeta_dVg * T9;
6075 T1 = 1 + gche * Rds;
6076 T2 = 1 / T1;
6077
6078 here->B4SOIgcrg = pParam->B4SOIxrcrg1
6079 * (T0 + here->B4SOIidovVds);
6080 dIdlovVdseff_dVg = (T2 * dgche_dVg
6081 - IdlovVdseff * gche * dRds_dVg) / T1;
6082 dIdlovVdseff_dVd = T2 * dgche_dVd / T1;
6083 dIdlovVdseff_dVb = (T2 * dgche_dVb
6084 - IdlovVdseff * gche * dRds_dVb) / T1;
6085
6086 T9 = diffVds / Va;
6087 T3 = 1.0 + T9;
6088
6089 T4 = T3 * dIdlovVdseff_dVg
6090 - IdlovVdseff * (dVdseff_dVg + T9 * dVa_dVg) / Va;
6091 T5 = T3 * dIdlovVdseff_dVd + IdlovVdseff
6092 * (1.0 - dVdseff_dVd - T9 * dVa_dVd) / Va;
6093 T6 = T3 * dIdlovVdseff_dVb
6094 - IdlovVdseff * (dVdseff_dVb + T9 * dVa_dVb) / Va;
6095
6096 tmp1 = (T4 * dVgsteff_dVd + T6 * dVbseff_dVd + T5)
6097 / here->B4SOInseg;
6098 tmp2 = (T4 * dVgsteff_dVg + T6 * dVbseff_dVg)
6099 / here->B4SOInseg;
6100 tmp3 = (T4 * dVgsteff_dVb + T6 * dVbseff_dVb)
6101 / here->B4SOInseg;
6102
6103 here->B4SOIgcrgd = pParam->B4SOIxrcrg1 * (dT0_dVd +tmp1);
6104 here->B4SOIgcrgg = pParam->B4SOIxrcrg1
6105 * (dT0_dVg * dVgsteff_dVg + tmp2);
6106 here->B4SOIgcrgb = pParam->B4SOIxrcrg1
6107 * (dT0_dVb * dVbseff_dVb + tmp3);
6108
6109 if (here->B4SOInf != 1.0)
6110 { here->B4SOIgcrg *= here->B4SOInf;
6111 here->B4SOIgcrgg *= here->B4SOInf;
6112 here->B4SOIgcrgd *= here->B4SOInf;
6113 here->B4SOIgcrgb *= here->B4SOInf;
6114 }
6115
6116 if (here->B4SOIrgateMod == 2)
6117 { T10 = here->B4SOIgrgeltd * here->B4SOIgrgeltd;
6118 T11 = here->B4SOIgrgeltd + here->B4SOIgcrg;
6119 here->B4SOIgcrg = here->B4SOIgrgeltd
6120 * here->B4SOIgcrg / T11;
6121 T12 = T10 / T11 /T11;
6122 here->B4SOIgcrgg *= T12;
6123 here->B4SOIgcrgd *= T12;
6124 here->B4SOIgcrgb *= T12;
6125 }
6126
6127 here->B4SOIgcrgs = -(here->B4SOIgcrgg + here->B4SOIgcrgd
6128 + here->B4SOIgcrgb);
6129 } /* v3.1 added Rg for RF end */
6130
6131 /* v4.0 Calculate bias-dependent external S/D resistance */
6132 Rs = Rd = 0.0; /* flexilint */
6133 if (model->B4SOIrdsMod)
6134 { /* Rs(V) */
6135 T0 = vgs - pParam->B4SOIvfbsd;
6136 T1 = sqrt(T0 * T0 + 1.0e-4);
6137 vgs_eff = 0.5 * (T0 + T1);
6138 dvgs_eff_dvg = vgs_eff / T1;
6139
6140 T0 = 1.0 + pParam->B4SOIprwg * vgs_eff;
6141 dT0_dVg = -pParam->B4SOIprwg / T0 / T0 * dvgs_eff_dvg;
6142 T1 = -pParam->B4SOIprwb * vbs;
6143 dT1_dVb = -pParam->B4SOIprwb;
6144
6145 T2 = 1.0 / T0 + T1;
6146 T3 = T2 + sqrt(T2 * T2 + 0.01);
6147 dT3_dVg = T3 / (T3 - T2);
6148 dT3_dVb = dT3_dVg * dT1_dVb;
6149 dT3_dVg *= dT0_dVg;
6150
6151 T4 = rs0 * 0.5;
6152 Rs = rswmin + T3 * T4;
6153 dRs_dVg = T4 * dT3_dVg;
6154 dRs_dVb = T4 * dT3_dVb;
6155
6156 T0 = 1.0 + here->B4SOIsourceConductance * Rs;
6157 here->B4SOIgstot = here->B4SOIsourceConductance / T0;
6158 T0 = -here->B4SOIgstot * here->B4SOIgstot;
6159 dgstot_dvd = 0.0; /* place holder */
6160 dgstot_dve = 0.0; /* place holder */
6161 dgstot_dvg = T0 * dRs_dVg;
6162 dgstot_dvb = T0 * dRs_dVb;
6163 dgstot_dvs = -(dgstot_dvg + dgstot_dvb + dgstot_dvd
6164 + dgstot_dve);
6165 if (selfheat) {
6166 dRs_dT = drswmin_dT + T3 * 0.5 * drs0_dT;
6167 dgstot_dT = T0 * dRs_dT;
6168 }
6169 else dRs_dT = dgstot_dT = 0.0;
6170
6171 /* Rd(V) */
6172 T0 = vgd - pParam->B4SOIvfbsd;
6173 T1 = sqrt(T0 * T0 + 1.0e-4);
6174 vgd_eff = 0.5 * (T0 + T1);
6175 dvgd_eff_dvg = vgd_eff / T1;
6176
6177 T0 = 1.0 + pParam->B4SOIprwg * vgd_eff;
6178 dT0_dVg = -pParam->B4SOIprwg / T0 / T0 * dvgd_eff_dvg;
6179 T1 = -pParam->B4SOIprwb * vbd;
6180 dT1_dVb = -pParam->B4SOIprwb;
6181
6182 T2 = 1.0 / T0 + T1;
6183 T3 = T2 + sqrt(T2 * T2 + 0.01);
6184 dT3_dVg = T3 / (T3 - T2);
6185 dT3_dVb = dT3_dVg * dT1_dVb;
6186 dT3_dVg *= dT0_dVg;
6187
6188 /*T4 = pParam->B4SOIrd0 * 0.5;*/ /* v4.2 bugfix # 37 */
6189 /*Rd = pParam->B4SOIrdwmin + T3 * T4;*/ /* v4.2 bugfix # 37 */
6190 T4 = rd0 * 0.5;
6191 Rd = rdwmin + T3 * T4;
6192 dRd_dVg = T4 * dT3_dVg;
6193 dRd_dVb = T4 * dT3_dVb;
6194 T0 = 1.0 + here->B4SOIdrainConductance * Rd;
6195 here->B4SOIgdtot = here->B4SOIdrainConductance / T0;
6196 T0 = -here->B4SOIgdtot * here->B4SOIgdtot;
6197 dgdtot_dvs = 0.0;
6198 dgdtot_dve = 0.0;
6199 dgdtot_dvg = T0 * dRd_dVg;
6200 dgdtot_dvb = T0 * dRd_dVb;
6201 dgdtot_dvd = -(dgdtot_dvg + dgdtot_dvb + dgdtot_dvs
6202 + dgdtot_dve);
6203 if (selfheat) {
6204 dRd_dT = drdwmin_dT + T3 * 0.5 * drd0_dT;
6205 dgdtot_dT = T0 * dRd_dT;
6206 }
6207 else dRd_dT = dgdtot_dT = 0.0;
6208
6209 here->B4SOIgstotd = vses * dgstot_dvd;
6210 here->B4SOIgstotg = vses * dgstot_dvg;
6211 here->B4SOIgstots = vses * dgstot_dvs;
6212 here->B4SOIgstotb = vses * dgstot_dvb;
6213
6214 T2 = vdes - vds;
6215 here->B4SOIgdtotd = T2 * dgdtot_dvd;
6216 here->B4SOIgdtotg = T2 * dgdtot_dvg;
6217 here->B4SOIgdtots = T2 * dgdtot_dvs;
6218 here->B4SOIgdtotb = T2 * dgdtot_dvb;
6219 }
6220 else
6221 { here->B4SOIgstot = here->B4SOIgstotd = here->B4SOIgstotg
6222 = here->B4SOIgstots = here->B4SOIgstotb
6223 = 0.0;
6224 here->B4SOIgdtot = here->B4SOIgdtotd = here->B4SOIgdtotg
6225 = here->B4SOIgdtots = here->B4SOIgdtotb
6226 = 0.0;
6227 }
6228
6229 if (selfheat)
6230 here->B4SOIgmT = GmT + GcT;
6231 else
6232 here->B4SOIgmT = 0.0;
6233
6234 /* note that sign is switched because power flows out
6235 of device into the temperature node.
6236 Currently omit self-heating due to bipolar current
6237 because it can cause convergence problem*/
6238
6239 here->B4SOIgtempg = -model->B4SOItype*Gm * Vds;
6240 here->B4SOIgtempb = -model->B4SOItype*Gmb * Vds;
6241 /* v3.0 */
6242 here->B4SOIgtempe = -model->B4SOItype*Gme * Vds;
6243
6244 here->B4SOIgtempT = -GmT * Vds;
6245 here->B4SOIgtempd = -model->B4SOItype* (Gds * Vds + Ids);
6246 here->B4SOIcth = - Ids * Vds - model->B4SOItype *
6247 (here->B4SOIgtempg * Vgs + here->B4SOIgtempb * Vbs
6248 + here->B4SOIgtempe * Ves
6249 + here->B4SOIgtempd * Vds)
6250 - here->B4SOIgtempT * delTemp; /* v3.0 */
6251
6252
6253 /* Body current which flows into drainprime node from the drain of device */
6254
6255 here->B4SOIgjdb = Gjdb - Giib -Ggidlb - Ggislb; /* v4.0 */
6256 here->B4SOIgjdd = Gjdd - (Giid + Ggidld);
6257 here->B4SOIgjdg = - (Giig + Ggidlg + Ggislg);
6258 here->B4SOIgjde = - Giie;
6259 if (selfheat) here->B4SOIgjdT = GjdT - GiiT;
6260 else here->B4SOIgjdT = 0.0;
6261 here->B4SOIcjd = Ibd - Iii - Igidl
6262 - (here->B4SOIgjdb * Vbs
6263 + here->B4SOIgjdd * Vds
6264 + here->B4SOIgjdg * Vgs
6265 + here->B4SOIgjde * Ves
6266 + here->B4SOIgjdT * delTemp); /* v3.0 */
6267
6268 if (!here->B4SOIrbodyMod)
6269 {
6270 Giigidl_b = Giigidl_d = Giigidl_g = Giigidl_e
6271 = Giigidl_T = Iii_Igidl = 0.0;
6272 }
6273 else
6274 {
6275 here->B4SOIgiigidlb = Giib + Ggidlb + Ggislb;
6276 here->B4SOIgiigidld = Giid + Ggidld;
6277 Giigidl_b = - Giib -Ggidlb - Ggislb;
6278 Giigidl_d = - Giid -Ggidld;
6279 Giigidl_g = - Giig -Ggidlg - Ggislg;
6280 Giigidl_e = - Giie;
6281 if (selfheat) Giigidl_T = -GiiT;
6282 else GiiT = Giigidl_T = 0.0;
6283
6284 /*Idbdp = Ibd - ( Gjdb * vbs_jct + Gjdd * Vds
6285 + GjdT * delTemp); v4.2 bugfix */
6286 Idbdp = Ibd - ( Gjdb * vbd_jct + Gjdd * Vds + GjdT * delTemp);
6287 /* Iii_Igidl = - Iii - Igidl
6288 + Giigidl_b * Vbs + Giigidl_d * Vds
6289 + Giigidl_g * Vgs + Giigidl_e * Ves
6290 + Giigidl_T * delTemp ; */
6291 }
6292
6293 /* Body current which flows into sourceprime node from the source of device */
6294
6295 here->B4SOIgjsg = 0.0;
6296 here->B4SOIgjsd = Gjsd;
6297 here->B4SOIgjsb = Gjsb; /* v4.0 */
6298 if (selfheat) here->B4SOIgjsT = GjsT;
6299 else here->B4SOIgjsT = 0.0;
6300 here->B4SOIcjs = Ibs - Igisl
6301 -( here->B4SOIgjsb * Vbs
6302 + here->B4SOIgjsd * Vds
6303 + here->B4SOIgjsg * Vgs
6304 + here->B4SOIgjsT * delTemp);
6305
6306 if (here->B4SOIrbodyMod) {
6307 Isbsp = Ibs - ( Gjsb * vbs_jct + Gjsd * Vds
6308 + GjsT * delTemp );
6309 }
6310
6311 /* Current flowing into body node */
6312
6313 here->B4SOIgbbs = Giib - Gjsb - Gjdb - Gbpbs / here->B4SOInf; /* v4.2 bug fix #27 */
6314 here->B4SOIgbgs = Giig + Ggidlg + Ggislg;
6315 here->B4SOIgbds = Giid + Ggidld + Ggisls - Gjsd - Gjdd;
6316 here->B4SOIgbes = Giie;
6317 here->B4SOIgbps = - Gbpps / here->B4SOInf; /* v4.2 bug fix #27 */
6318 if (selfheat) here->B4SOIgbT = GiiT - GjsT - GjdT;
6319 else here->B4SOIgbT = 0.0;
6320
6321 if (!here->B4SOIrbodyMod)
6322 {
6323 here->B4SOIcbody = Iii + Igidl + Igisl - Ibs - Ibd
6324 - Ibp / here->B4SOInf + Igb /* v4.2 bug fix #27 */
6325 - ( (here->B4SOIgbbs + dIgb_dVb) * Vbs
6326 + (here->B4SOIgbgs + dIgb_dVg) * Vgs
6327 + (here->B4SOIgbds + dIgb_dVd) * Vds
6328 + here->B4SOIgbps * Vps
6329 + (here->B4SOIgbes + dIgb_dVe) * Ves
6330 + (here->B4SOIgbT + dIgb_dT) * delTemp);
6331 }
6332
6333 if (here->B4SOIrbodyMod)
6334 {
6335 here->B4SOIgbgiigbpb = Giib - Gbpbs / here->B4SOInf; /* v4.3 bug fix */
6336 here->B4SOIcbody = Iii + Igidl + Igisl - Ibp / here->B4SOInf + Igb /* v4.2 bug fix #27 */
6337 - ( (Giib - Gbpbs / here->B4SOInf + dIgb_dVb) * Vbs /* v4.2 bug fix #27 */
6338 + (here->B4SOIgbgs + dIgb_dVg) * Vgs
6339 + (Giid + Ggidld + dIgb_dVd) * Vds
6340 + here->B4SOIgbps * Vps
6341 + (here->B4SOIgbes + dIgb_dVe) * Ves
6342 + (GiiT + dIgb_dT) * delTemp );
6343 }
6344
6345 here->B4SOIcgate = Igb
6346 - (dIgb_dVb * Vbs + dIgb_dVe * Ves + dIgb_dVg * Vgs
6347 + dIgb_dVd * Vds + dIgb_dT * delTemp); /* v3.0 */
6348
6349 /* Calculate Qinv for Noise analysis */
6350
6351 T1 = Vgsteff * (1.0 - 0.5 * Abulk * Vdseff / Vgst2Vtm);
6352 here->B4SOIqinv = -model->B4SOIcox * pParam->B4SOIweff
6353 * here->B4SOInf * Leff * T1; /* v4.0 */
6354
6355 if (here->B4SOInf != 1) {
6356 here->B4SOIcdrain *= here->B4SOInf;
6357 here->B4SOIcd *= here->B4SOInf;
6358 here->B4SOIcb *= here->B4SOInf;
6359
6360 /* Fix NF problem with tnoimod=1 - LFW */
6361 here->B4SOIidovVds *= here->B4SOInf;
6362
6363 here->B4SOIgds *= here->B4SOInf;
6364 here->B4SOIgm *= here->B4SOInf;
6365 here->B4SOIgmbs *= here->B4SOInf;
6366 here->B4SOIgme *= here->B4SOInf;
6367 /* Xue fix 10/29/2009 */
6368 /* here->B4SOIgmT *= here->B4SOInf; *added in line 5424 */
6369 here->B4SOIcbody *= here->B4SOInf;
6370
6371 here->B4SOIcgate *= here->B4SOInf;
6372
6373 here->B4SOIIgcs *= here->B4SOInf;
6374 here->B4SOIgIgcsg *= here->B4SOInf;
6375 here->B4SOIgIgcsd *= here->B4SOInf;
6376 here->B4SOIgIgcsb *= here->B4SOInf;
6377 here->B4SOIgIgcse *= here->B4SOInf; /* LFW_FD new line */
6378 here->B4SOIIgcd *= here->B4SOInf;
6379 here->B4SOIgIgcdg *= here->B4SOInf;
6380 here->B4SOIgIgcdd *= here->B4SOInf;
6381 here->B4SOIgIgcdb *= here->B4SOInf;
6382 here->B4SOIgIgcde *= here->B4SOInf; /* LFW_FD new line */
6383
6384 here->B4SOIIgs *= here->B4SOInf;
6385 here->B4SOIgIgsg *= here->B4SOInf;
6386 here->B4SOIgIgss *= here->B4SOInf;
6387 here->B4SOIIgd *= here->B4SOInf;
6388 here->B4SOIgIgdg *= here->B4SOInf;
6389 here->B4SOIgIgdd *= here->B4SOInf;
6390
6391 here->B4SOIig *= here->B4SOInf;
6392 here->B4SOIgigg *= here->B4SOInf;
6393 here->B4SOIgigd *= here->B4SOInf;
6394 here->B4SOIgigb *= here->B4SOInf;
6395 here->B4SOIgige *= here->B4SOInf;
6396 here->B4SOIgigT *= here->B4SOInf;
6397
6398 here->B4SOIcjs *= here->B4SOInf;
6399 here->B4SOIcjd *= here->B4SOInf;
6400 here->B4SOIibs *= here->B4SOInf;
6401 here->B4SOIibd *= here->B4SOInf;
6402 Idbdp *= here->B4SOInf; /*v4.2 bug fix Idbdp needs update as Ibd for nf!=1*/
6403 Isbsp *= here->B4SOInf; /*v4.2 bug fix Isbsp needs update as Ibd for nf!=1*/
6404 here->B4SOIgbbs *= here->B4SOInf;
6405 here->B4SOIgbgs *= here->B4SOInf;
6406 here->B4SOIgbds *= here->B4SOInf;
6407 here->B4SOIgbes *= here->B4SOInf;
6408 here->B4SOIgbps *= here->B4SOInf;
6409 here->B4SOIgbT *= here->B4SOInf;
6410 here->B4SOIigidl *= here->B4SOInf;
6411 here->B4SOIigisl *= here->B4SOInf;
6412
6413 /* bugfix_snps NF*/
6414 here->B4SOIgjdb *= here->B4SOInf;
6415 here->B4SOIgjdd *= here->B4SOInf;
6416 here->B4SOIgjdg *= here->B4SOInf;
6417 here->B4SOIgjde *= here->B4SOInf;
6418 here->B4SOIgjdT *= here->B4SOInf;
6419 here->B4SOIgjsb *= here->B4SOInf;
6420 here->B4SOIgjsd *= here->B4SOInf;
6421 here->B4SOIgjsg *= here->B4SOInf;
6422 here->B4SOIgjsT *= here->B4SOInf;
6423
6424 here->B4SOIcth *= here->B4SOInf;
6425 here->B4SOIgmT *= here->B4SOInf;
6426 here->B4SOIgtempg *= here->B4SOInf;
6427 here->B4SOIgtempb *= here->B4SOInf;
6428 here->B4SOIgtempe *= here->B4SOInf;
6429 here->B4SOIgtempT *= here->B4SOInf;
6430 here->B4SOIgtempd *= here->B4SOInf;
6431 here->B4SOIiii *= here->B4SOInf;
6432 /* bugfix NF ends */
6433 }
6434 here->B4SOIgigs = -(here->B4SOIgigg + here->B4SOIgigd
6435 + here->B4SOIgigb + here->B4SOIgige);
6436 /* LFW_FD fix 2 derivatives */
6437 here->B4SOIgIgcss = -(here->B4SOIgIgcsg + here->B4SOIgIgcsd
6438 + here->B4SOIgIgcsb + here->B4SOIgIgcse);
6439 here->B4SOIgIgcds = -(here->B4SOIgIgcdg + here->B4SOIgIgcdd
6440 + here->B4SOIgIgcdb + here->B4SOIgIgcde);
6441
6442 /* Begin CV (charge) model */
6443
6444 /* LFW_FD 9 new lines - flexilint */
6445 Cbb = Cbd = Cbg = 0.0;
6446 Qsub0 = Qac0 = 0.0;
6447 qjs = qjd = 0.0;
6448 CboxWL = 0.0;
6449 Qe1 = dQe1_dVb = dQe1_dVe = dQe1_dT = 0;
6450 Vfbeff2=dVfbeff2_dVd=dVfbeff2_dVrg=dVfbeff2_dVg=dVfbeff2_dVb=dVfbeff2_dVe=dVfbeff2_dT=0.0;
6451 VdseffCV2 = dVdseffCV2_dVg = dVdseffCV2_dVd = dVdseffCV2_dVb = dVdseffCV2_dVe = 0.0;
6452 Vgsteff2 = 0.0;
6453 dVgsteff2_dVd=dVgsteff2_dVg=dVgsteff2_dVb=dVgsteff2_dVe=dVgsteff2_dT=0.0;
6454
6455 if ((model->B4SOIxpart < 0) || (!ChargeComputationNeeded))
6456 { qgate = qdrn = qsrc = qbody = qsub = 0.0; /* v2.2.3 bug fix */
6457 Qsub0=Qac0=Cbb=Cbg=Cbd=0; /* Bugfix #19 Jul09*/
6458 here->B4SOIcggb = here->B4SOIcgsb = here->B4SOIcgdb = 0.0;
6459 here->B4SOIcdgb = here->B4SOIcdsb = here->B4SOIcddb = 0.0;
6460 here->B4SOIcbgb = here->B4SOIcbsb = here->B4SOIcbdb = 0.0;
6461 goto finished;
6462 }
6463 else
6464 {
6465 qgate = qdrn = qsrc = qbody = qsub = 0.0; /* flexilint */
6466 CoxWL = model->B4SOIcox * (pParam->B4SOIweffCV
6467 / here->B4SOInseg * here->B4SOInf /* v4.0 */
6468 * pParam->B4SOIleffCV + here->B4SOIagbcp);
6469 CoxWLb = model->B4SOIfbody * model->B4SOIcox
6470 * (pParam->B4SOIweffCV / here->B4SOInseg
6471 * here->B4SOInf /* v4.0 */
6472 * pParam->B4SOIleffCVb + here->B4SOIagbcp);
6473 /* v4.1 for improved BT charge model */
6474
6475 CoxWL2 = model->B4SOIcox * here->B4SOIagbcp2;
6476 CoxWLb2 = model->B4SOIfbody * model->B4SOIcox * here->B4SOIagbcp2;
6477 /* end v4.1 */
6478
6479
6480 /* v3.2 Seperate VgsteffCV with noff */
6481 noff = n * pParam->B4SOInoff;
6482 dnoff_dVg = pParam->B4SOInoff * dn_dVg; /* LFW_FD new line */
6483 dnoff_dVd = pParam->B4SOInoff * dn_dVd;
6484 dnoff_dVb = pParam->B4SOInoff * dn_dVb;
6485 dnoff_dVe = pParam->B4SOInoff * dn_dVe; /* LFW_FD new line */
6486 dnoff_dT = pParam->B4SOInoff * dn_dT; /* new line Wagner */
6487 if (model->B4SOIvgstcvMod == 0)
6488 {
6489 if ((VgstNVt > -EXPL_THRESHOLD) && (VgstNVt < EXPL_THRESHOLD))
6490 {
6491 TL1 = ExpVgst; /* LFW_FD new line */
6492 ExpVgst *= ExpVgst;
6493 ExpVgst *= exp( -(pParam->B4SOIdelvt / (noff * Vtm)));
6494 /* LFW_FD 4 new derivatives */
6495 dExpVgst_dVg = 2.0 * TL1 * dExpVgst_dVg * exp( -pParam->B4SOIdelvt / (noff * Vtm))
6496 + ExpVgst * pParam->B4SOIdelvt * dnoff_dVg / (noff * noff * Vtm);
6497 dExpVgst_dVd = 2.0 * TL1 * dExpVgst_dVd * exp( -pParam->B4SOIdelvt / (noff * Vtm))
6498 + ExpVgst * pParam->B4SOIdelvt * dnoff_dVd / (noff * noff * Vtm);
6499 dExpVgst_dVb = 2.0 * TL1 * dExpVgst_dVb * exp( -pParam->B4SOIdelvt / (noff * Vtm))
6500 + ExpVgst * pParam->B4SOIdelvt * dnoff_dVb / (noff * noff * Vtm);
6501 dExpVgst_dVe = 2.0 * TL1 * dExpVgst_dVe * exp( -pParam->B4SOIdelvt / (noff * Vtm))
6502 + ExpVgst * pParam->B4SOIdelvt * dnoff_dVe / (noff * noff * Vtm);
6503
6504 Vgsteff = noff * Vtm * log(1.0 + ExpVgst);
6505 /* LFW_FD 4 fix derivatives */
6506 dVgsteff_dVg = Vgsteff * dnoff_dVg / noff + noff * Vtm * dExpVgst_dVg / (1.0 + ExpVgst);
6507 dVgsteff_dVd = Vgsteff * dnoff_dVd / noff + noff * Vtm * dExpVgst_dVd / (1.0 + ExpVgst);
6508 dVgsteff_dVb = Vgsteff * dnoff_dVb / noff + noff * Vtm * dExpVgst_dVb / (1.0 + ExpVgst);
6509 dVgsteff_dVe = Vgsteff * dnoff_dVe / noff + noff * Vtm * dExpVgst_dVe / (1.0 + ExpVgst);
6510
6511 T0 = ExpVgst / (1.0 + ExpVgst);
6512 T2 = 2.0 * pParam->B4SOImstar * pParam->B4SOInoff; /* LFW_FD new line */
6513 T1 = -T0 * (T2*dVth_dVb + (T2*Vgst-pParam->B4SOIdelvt) / noff * dnoff_dVb)
6514 + Vgsteff / noff * dnoff_dVb; /* LFW_FD fix line */
6515 /* LFW_FD fix _dT derivatives */
6516 if (selfheat) {
6517 dExpVgst_dT = 2.0 * TL1 * dExpVgst_dT * exp( -pParam->B4SOIdelvt / (noff * Vtm))
6518 + ExpVgst * pParam->B4SOIdelvt * (dVtm_dT / Vtm + dnoff_dT / noff) / (noff * Vtm);
6519 dVgsteff_dT = Vgsteff * (dnoff_dT / noff + dVtm_dT / Vtm) + noff * Vtm * dExpVgst_dT / (1.0 + ExpVgst);
6520 }
6521 else dVgsteff_dT = 0.0;
6522
6523 /* v4.1 */
6524 if (here->B4SOIagbcp2 > 0) {
6525 /* ExpVgst2 = ExpVgst * exp(-1.12 / noff / Vtm); */
6526 ExpVgst2 = ExpVgst * exp(-eggbcp2 / noff / Vtm); /* bugfix 4.3.1 -Tanvir */
6527 /* LFW_FD add 4 derivatives */
6528 dExpVgst2_dVg = dExpVgst_dVg * exp(-eggbcp2 / noff / Vtm) + ExpVgst2 * eggbcp2 * dnoff_dVg / (noff * noff * Vtm);
6529 dExpVgst2_dVd = dExpVgst_dVd * exp(-eggbcp2 / noff / Vtm) + ExpVgst2 * eggbcp2 * dnoff_dVd / (noff * noff * Vtm);
6530 dExpVgst2_dVb = dExpVgst_dVb * exp(-eggbcp2 / noff / Vtm) + ExpVgst2 * eggbcp2 * dnoff_dVb / (noff * noff * Vtm);
6531 dExpVgst2_dVe = dExpVgst_dVe * exp(-eggbcp2 / noff / Vtm) + ExpVgst2 * eggbcp2 * dnoff_dVe / (noff * noff * Vtm);
6532
6533 Vgsteff2 = noff * Vtm * log(1.0 + ExpVgst2);
6534 /* LFW_FD fix 4 derivatives */
6535 dVgsteff2_dVg = Vgsteff2 * dnoff_dVg / noff + noff * Vtm * dExpVgst2_dVg / (1.0 + ExpVgst2);
6536 dVgsteff2_dVd = Vgsteff2 * dnoff_dVd / noff + noff * Vtm * dExpVgst2_dVd / (1.0 + ExpVgst2);
6537 dVgsteff2_dVb = Vgsteff2 * dnoff_dVb / noff + noff * Vtm * dExpVgst2_dVb / (1.0 + ExpVgst2);
6538 dVgsteff2_dVe = Vgsteff2 * dnoff_dVe / noff + noff * Vtm * dExpVgst2_dVe / (1.0 + ExpVgst2);
6539
6540 T02 = ExpVgst2 / (1.0 + ExpVgst2);
6541 /* T12 = -T02 * (dVth_dVb + (Vgst-1.12-pParam->B4SOIdelvt) / noff * dnoff_dVb)
6542 + Vgsteff2 / noff * dnoff_dVb; */
6543 T12 = -T02 * (dVth_dVb + (Vgst-eggbcp2-pParam->B4SOIdelvt) / noff * dnoff_dVb)
6544 + Vgsteff2 / noff * dnoff_dVb; /* bugfix 4.3.1 -Tanvir */
6545 if (selfheat)
6546 /*fix below expression Wagner */
6547 /*dVgsteff2_dT = -T02 * (dVth_dT+dVth_dVb*dVbseff_dT */
6548 /* dVgsteff2_dT = -T02 * (-dVgst_dT
6549 + (Vgst - 1.12 - pParam->B4SOIdelvt) / Temp)
6550 + Vgsteff2 / Temp; */ /* bugfix 4.3.1 -Tanvir */
6551 dVgsteff2_dT = -T02 * (-dVgst_dT
6552 + (Vgst - eggbcp2 - pParam->B4SOIdelvt) / Temp)
6553 + Vgsteff2 / Temp;
6554 else dVgsteff2_dT = 0.0;
6555 }
6556 }
6557 }
6558 else if (model->B4SOIvgstcvMod == 1)
6559 { ExpVgst = exp(VgstNVt/(pParam->B4SOImstar * pParam->B4SOInoff));
6560 ExpVgst *= exp( -(pParam->B4SOIdelvt / (noff * Vtm)));
6561 /* LFW_FD add 4 derivatives */
6562 dExpVgst_dVg = ExpVgst * (dVgstNVt_dVg/(pParam->B4SOImstar * pParam->B4SOInoff)
6563 + pParam->B4SOIdelvt * dnoff_dVg / (noff * noff * Vtm));
6564 dExpVgst_dVd = ExpVgst * (dVgstNVt_dVd/(pParam->B4SOImstar * pParam->B4SOInoff)
6565 + pParam->B4SOIdelvt * dnoff_dVd / (noff * noff * Vtm));
6566 dExpVgst_dVb = ExpVgst * (dVgstNVt_dVb/(pParam->B4SOImstar * pParam->B4SOInoff)
6567 + pParam->B4SOIdelvt * dnoff_dVb / (noff * noff * Vtm));
6568 dExpVgst_dVe = ExpVgst * (dVgstNVt_dVe/(pParam->B4SOImstar * pParam->B4SOInoff)
6569 + pParam->B4SOIdelvt * dnoff_dVe / (noff * noff * Vtm));
6570
6571 Vgsteff = noff * Vtm * log(1.0 + ExpVgst);
6572 /* LFW_FD fix 4 derivatives */
6573 dVgsteff_dVg = Vgsteff * dnoff_dVg / noff + noff * Vtm * dExpVgst_dVg / (1.0 + ExpVgst);
6574 dVgsteff_dVd = Vgsteff * dnoff_dVd / noff + noff * Vtm * dExpVgst_dVd / (1.0 + ExpVgst);
6575 dVgsteff_dVb = Vgsteff * dnoff_dVb / noff + noff * Vtm * dExpVgst_dVb / (1.0 + ExpVgst);
6576 dVgsteff_dVe = Vgsteff * dnoff_dVe / noff + noff * Vtm * dExpVgst_dVe / (1.0 + ExpVgst);
6577
6578 T0 = ExpVgst / (1.0 + ExpVgst);
6579 T1 = -T0 * (dVth_dVb + (Vgst-pParam->B4SOIdelvt) / noff * dnoff_dVb)
6580 + Vgsteff / noff * dnoff_dVb;
6581
6582 if (selfheat)
6583 /*fix below expression Wagner */
6584 /*dVgsteff_dT = -T0 * (dVth_dT+dVth_dVb*dVbseff_dT */
6585 dVgsteff_dT = -T0 * (-dVgst_dT
6586 + (Vgst - pParam->B4SOIdelvt) / Temp)
6587 + Vgsteff / Temp;
6588 else dVgsteff_dT = 0.0;
6589 /* v4.1 */
6590 if (here->B4SOIagbcp2 > 0) {
6591 /* ExpVgst2 = ExpVgst * exp(-1.12 / noff / Vtm); */
6592 ExpVgst2 = ExpVgst * exp(-eggbcp2 / noff / Vtm); /* bugfix 4.3.1 -Tanvir */
6593 /* LFW_FD add 4 derivatives */
6594 dExpVgst2_dVg = dExpVgst_dVg * exp(-eggbcp2 / noff / Vtm) + ExpVgst2 * eggbcp2 * dnoff_dVg / (noff * noff * Vtm);
6595 dExpVgst2_dVd = dExpVgst_dVd * exp(-eggbcp2 / noff / Vtm) + ExpVgst2 * eggbcp2 * dnoff_dVd / (noff * noff * Vtm);
6596 dExpVgst2_dVb = dExpVgst_dVb * exp(-eggbcp2 / noff / Vtm) + ExpVgst2 * eggbcp2 * dnoff_dVb / (noff * noff * Vtm);
6597 dExpVgst2_dVe = dExpVgst_dVe * exp(-eggbcp2 / noff / Vtm) + ExpVgst2 * eggbcp2 * dnoff_dVe / (noff * noff * Vtm);
6598
6599 Vgsteff2 = noff * Vtm * log(1.0 + ExpVgst2);
6600 /* LFW_FD fix 4 derivatives */
6601 dVgsteff2_dVg = Vgsteff2 * dnoff_dVg / noff + noff * Vtm * dExpVgst2_dVg / (1.0 + ExpVgst2);
6602 dVgsteff2_dVd = Vgsteff2 * dnoff_dVd / noff + noff * Vtm * dExpVgst2_dVd / (1.0 + ExpVgst2);
6603 dVgsteff2_dVb = Vgsteff2 * dnoff_dVb / noff + noff * Vtm * dExpVgst2_dVb / (1.0 + ExpVgst2);
6604 dVgsteff2_dVe = Vgsteff2 * dnoff_dVe / noff + noff * Vtm * dExpVgst2_dVe / (1.0 + ExpVgst2);
6605
6606 T02 = ExpVgst2 / (1.0 + ExpVgst2);
6607 /* T12 = -T02 * (dVth_dVb + (Vgst-1.12-pParam->B4SOIdelvt) / noff * dnoff_dVb)
6608 + Vgsteff2 / noff * dnoff_dVb; */
6609 T12 = -T02 * (dVth_dVb + (Vgst-eggbcp2-pParam->B4SOIdelvt) / noff * dnoff_dVb)
6610 + Vgsteff2 / noff * dnoff_dVb; /* bugfix 4.3.1 -Tanvir */
6611 dVgsteff2_dVb = T12 * dVbseff_dVb;
6612 dVgsteff2_dVe = T12 * dVbseff_dVe;
6613 if (selfheat)
6614 /*fix below expression Wagner */
6615 /*dVgsteff2_dT = -T02 * (dVth_dT+dVth_dVb*dVbseff_dT */
6616 /* dVgsteff2_dT = -T02 * (-dVgst_dT
6617 + (Vgst - 1.12 - pParam->B4SOIdelvt) / Temp)
6618 + Vgsteff2 / Temp; */
6619 dVgsteff2_dT = -T02 * (-dVgst_dT
6620 + (Vgst - eggbcp2 - pParam->B4SOIdelvt) / Temp)
6621 + Vgsteff2 / Temp; /* bugfix 4.3.1 -Tanvir */
6622 else dVgsteff2_dT = 0.0;
6623 }
6624
6625
6626 }
6627 else
6628 {
6629 T10 = noff * Vtm;
6630 VgstNVt = pParam->B4SOImstarcv * (Vgst - pParam->B4SOIdelvt) / T10;
6631 /* LFW_FD add 4 derivatives */
6632 dVgstNVt_dVg = (pParam->B4SOImstarcv * dVgst_dVg - VgstNVt * dnoff_dVg * Vtm) / T10;
6633 dVgstNVt_dVd = (pParam->B4SOImstarcv * dVgst_dVd - VgstNVt * dnoff_dVd * Vtm) / T10;
6634 dVgstNVt_dVb = (pParam->B4SOImstarcv * dVgst_dVb - VgstNVt * dnoff_dVb * Vtm) / T10;
6635 dVgstNVt_dVe = (pParam->B4SOImstarcv * dVgst_dVe - VgstNVt * dnoff_dVe * Vtm) / T10;
6636
6637 ExpArg = (pParam->B4SOIvoffcv -
6638 (1- pParam->B4SOImstarcv) * (Vgst - pParam->B4SOIdelvt))/ T10;
6639 /* LFW_FD add 4 derivatives */
6640 dExpArg_dVg = (-(1- pParam->B4SOImstarcv) * dVgst_dVg - ExpArg * dnoff_dVg * Vtm) / T10;
6641 dExpArg_dVd = (-(1- pParam->B4SOImstarcv) * dVgst_dVd - ExpArg * dnoff_dVd * Vtm) / T10;
6642 dExpArg_dVb = (-(1- pParam->B4SOImstarcv) * dVgst_dVb - ExpArg * dnoff_dVb * Vtm) / T10;
6643 dExpArg_dVe = (-(1- pParam->B4SOImstarcv) * dVgst_dVe - ExpArg * dnoff_dVe * Vtm) / T10;
6644
6645 /* 11 lines new Wagner */
6646 if (selfheat) {
6647 dT10_dT = noff * dVtm_dT + dnoff_dT * Vtm;
6648 /* fix below expression Wagner */
6649 /*dVgstNVt_dT = -(pParam->B4SOImstarcv*dVth_dT + VgstNVt*dT10_dT)/T10; */
6650 dVgstNVt_dT = -(-pParam->B4SOImstarcv*dVgst_dT + VgstNVt*dT10_dT)/T10;
6651 /* fix below expression Wagner */
6652 dExpArg_dT = -(1- pParam->B4SOImstarcv)*dVgst_dT/T10
6653 -ExpArg*dT10_dT/T10;
6654 }
6655 else {
6656 dT10_dT = 0.0;
6657 dVgstNVt_dT = 0.0;
6658 dExpArg_dT = 0.0;
6659 }
6660
6661 /* MCJ: Very small Vgst */
6662 if (VgstNVt > EXPL_THRESHOLD)
6663 { Vgsteff = Vgst - pParam->B4SOIdelvt;
6664 /* T0 is dVgsteff_dVbseff */
6665 T0 = -dVth_dVb;
6666 /* LFW_FD fix 4 derivatives */
6667 dVgsteff_dVg = dVgst_dVg;
6668 dVgsteff_dVd = dVgst_dVd;
6669 dVgsteff_dVb = dVgst_dVb;
6670 dVgsteff_dVe = dVgst_dVe;
6671 if (selfheat)
6672 /*fix below expression Wagner */
6673 /*dVgsteff_dT = -dVth_dT + T0 * dVbseff_dT; */
6674 dVgsteff_dT = dVgst_dT;
6675 else
6676 dVgsteff_dT = 0.0;
6677 }
6678 else if (ExpArg > EXPL_THRESHOLD)
6679 { T0 = (Vgst - pParam->B4SOIdelvt - pParam->B4SOIvoffcv) / (noff * Vtm);
6680 ExpVgst = exp(T0);
6681 /* LFW_FD add 4 derivatives */
6682 dExpVgst_dVg = (dVgst_dVg - T0 * dnoff_dVg * Vtm) /(noff * Vtm);
6683 dExpVgst_dVd = (dVgst_dVd - T0 * dnoff_dVd * Vtm) /(noff * Vtm);
6684 dExpVgst_dVb = (dVgst_dVb - T0 * dnoff_dVb * Vtm) /(noff * Vtm);
6685 dExpVgst_dVe = (dVgst_dVe - T0 * dnoff_dVe * Vtm) /(noff * Vtm);
6686
6687 /*Vgsteff = Vtm * pParam->B4SOIcdep0 / model->B4SOIcox * ExpVgst;*/ /*v4.2 bug fix*/
6688 Vgsteff = Vtm * cdep0 / model->B4SOIcox * ExpVgst; /* v4.2 bug fix */
6689 T3 = Vgsteff / (noff * Vtm) ;
6690 /* T1 is dVgsteff_dVbseff */
6691 /* T1 = -T3 * (dVth_dVb + T0 * Vtm * dnoff_dVb); */
6692 T1 = -T3 * ( T0 * Vtm * dnoff_dVb); /* LFW_FD fixed line */
6693 /* LFW_FD fix 4 derivatives */
6694 dVgsteff_dVg = Vtm * cdep0 / model->B4SOIcox * dExpVgst_dVg;
6695 dVgsteff_dVd = Vtm * cdep0 / model->B4SOIcox * dExpVgst_dVd;
6696 dVgsteff_dVb = Vtm * cdep0 / model->B4SOIcox * dExpVgst_dVb;
6697 dVgsteff_dVe = Vtm * cdep0 / model->B4SOIcox * dExpVgst_dVe;
6698 if (selfheat)
6699 /*fix below expression Wagner */
6700 /*dVgsteff_dT = -T3 * (dVth_dT + T0 * dVtm_dT * noff)
6701 + Vgsteff / Temp+ T1 * dVbseff_dT;*/
6702 dVgsteff_dT = -T3 * (-dVgst_dT + T0 * dVtm_dT * noff + Vtm * dnoff_dT)
6703 + Vgsteff / Temp;
6704 else
6705 dVgsteff_dT = 0.0;
6706 }
6707 else
6708 {
6709 ExpVgst = exp(VgstNVt);
6710 /* LFW_FD add 4 derivatives */
6711 dExpVgst_dVg = ExpVgst * dVgstNVt_dVg;
6712 dExpVgst_dVd = ExpVgst * dVgstNVt_dVd;
6713 dExpVgst_dVb = ExpVgst * dVgstNVt_dVb;
6714 dExpVgst_dVe = ExpVgst * dVgstNVt_dVe;
6715
6716 T1 = T10 * log(1.0 + ExpVgst);
6717 /* LFW_FD fix 4 derivatives */
6718 dT1_dVg = T10 * dExpVgst_dVg / (1.0 + ExpVgst) + T1 * dnoff_dVg / noff;
6719 dT1_dVd = T10 * dExpVgst_dVd / (1.0 + ExpVgst) + T1 * dnoff_dVd / noff;
6720 dT1_dVb = T10 * dExpVgst_dVb / (1.0 + ExpVgst) + T1 * dnoff_dVb / noff;
6721 dT1_dVe = T10 * dExpVgst_dVe / (1.0 + ExpVgst) + T1 * dnoff_dVe / noff;
6722
6723 /*fix below expression Wagner */
6724 /*T3 = (1.0 / Temp); */
6725 T3 = (1.0 / Temp + dnoff_dT / noff);
6726 if (selfheat)
6727 /*fix below expression Wagner */
6728 /*dT1_dT = -dT1_dVg * (dVth_dT + (Vgst-pParam->B4SOIdelvt) * T3) + T1 * T3;*/
6729 dT1_dT = dT10_dT * log(1.0 + ExpVgst) + T10 * ExpVgst / (1.0 + ExpVgst) * dVgstNVt_dT;
6730 else
6731 dT1_dT = 0.0;
6732
6733 /* dT2_dVg = -model->B4SOIcox / (Vtm * pParam->B4SOIcdep0) */
6734 /* * exp(ExpArg) * (1 - pParam->B4SOImstarcv); v4.2 bug fix */
6735 dT2_dVg = -model->B4SOIcox / (Vtm * cdep0)
6736 * exp(ExpArg) * (1 - pParam->B4SOImstarcv); /* v4.2 bug fix */
6737 T2 = pParam->B4SOImstarcv - T10 * dT2_dVg
6738 / (1.0 - pParam->B4SOImstarcv);
6739
6740 /* LFW_FD 5 new lines */
6741 TL1 = dT2_dVg;
6742 dTL1_dVg = TL1 * dExpArg_dVg;
6743 dTL1_dVd = TL1 * dExpArg_dVd;
6744 dTL1_dVb = TL1 * dExpArg_dVb;
6745 dTL1_dVe = TL1 * dExpArg_dVe;
6746
6747 /* LFW_FD fix/add 5 derivatives */
6748 dT2_dVg = -(dnoff_dVg * Vtm * TL1 + T10 * dTL1_dVg) / (1.0 - pParam->B4SOImstarcv);
6749 dT2_dVd = -(dnoff_dVd * Vtm * TL1 + T10 * dTL1_dVd) / (1.0 - pParam->B4SOImstarcv);
6750 dT2_dVb = -(dnoff_dVb * Vtm * TL1 + T10 * dTL1_dVb) / (1.0 - pParam->B4SOImstarcv);
6751 dT2_dVe = -(dnoff_dVe * Vtm * TL1 + T10 * dTL1_dVe) / (1.0 - pParam->B4SOImstarcv);
6752 if (selfheat)
6753 dT2_dT = -(dT10_dT*TL1
6754 +T10*TL1*(-dVtm_dT/Vtm-dcdep0_dT/cdep0+dExpArg_dT)
6755 )/(1.0 - pParam->B4SOImstarcv);
6756 else
6757 dT2_dT = 0.0;
6758
6759 Vgsteff = T1 / T2;
6760
6761 T3 = T2 * T2;
6762 /* T4 is dVgsteff_dVbseff */
6763 T4 = (T2 * dT1_dVb - T1 * dT2_dVb) / T3;
6764 /* LFW_FD fix 4 derivatives */
6765 dVgsteff_dVg = (T2 * dT1_dVg - T1 * dT2_dVg) / T3;
6766 dVgsteff_dVd = (T2 * dT1_dVd - T1 * dT2_dVd) / T3;
6767 dVgsteff_dVb = (T2 * dT1_dVb - T1 * dT2_dVb) / T3;
6768 dVgsteff_dVe = (T2 * dT1_dVe - T1 * dT2_dVe) / T3;
6769 if (selfheat)
6770 /*fix below expression Wagner */
6771 /*dVgsteff_dT = (T2 * dT1_dT - T1 * dT2_dT)
6772 / T3+ T4 * dVbseff_dT; */
6773 dVgsteff_dT = (T2 * dT1_dT - T1 * dT2_dT) / T3;
6774 else
6775 dVgsteff_dT = 0.0;
6776 }
6777
6778
6779
6780 if (here->B4SOIagbcp2 > 0)
6781 {
6782 /* VgstNVt2 = pParam->B4SOImstarcv * (Vgst - pParam->B4SOIdelvt - 1.12) / T10; */
6783 VgstNVt2 = pParam->B4SOImstarcv * (Vgst - pParam->B4SOIdelvt - eggbcp2) / T10; /* bugfix 4.3.1 -Tanvir */
6784 /* LFW_FD add 4 derivatives */
6785 dVgstNVt2_dVg = (pParam->B4SOImstarcv * dVgst_dVg - VgstNVt2 * dnoff_dVg * Vtm) / T10;
6786 dVgstNVt2_dVd = (pParam->B4SOImstarcv * dVgst_dVd - VgstNVt2 * dnoff_dVd * Vtm) / T10;
6787 dVgstNVt2_dVb = (pParam->B4SOImstarcv * dVgst_dVb - VgstNVt2 * dnoff_dVb * Vtm) / T10;
6788 dVgstNVt2_dVe = (pParam->B4SOImstarcv * dVgst_dVe - VgstNVt2 * dnoff_dVe * Vtm) / T10;
6789
6790 /* ExpArg2 = (pParam->B4SOIvoffcv -
6791 (1- pParam->B4SOImstarcv) * (Vgst - pParam->B4SOIdelvt - 1.12))/ T10; */
6792 ExpArg2 = (pParam->B4SOIvoffcv -
6793 (1- pParam->B4SOImstarcv) * (Vgst - pParam->B4SOIdelvt - eggbcp2))/ T10; /* bugfix 4.3.1 -Tanvir */
6794 /* LFW_FD add 4 derivatives */
6795 dExpArg2_dVg = (-(1- pParam->B4SOImstarcv) * dVgst_dVg - ExpArg2 * dnoff_dVg * Vtm) / T10;
6796 dExpArg2_dVd = (-(1- pParam->B4SOImstarcv) * dVgst_dVd - ExpArg2 * dnoff_dVd * Vtm) / T10;
6797 dExpArg2_dVb = (-(1- pParam->B4SOImstarcv) * dVgst_dVb - ExpArg2 * dnoff_dVb * Vtm) / T10;
6798 dExpArg2_dVe = (-(1- pParam->B4SOImstarcv) * dVgst_dVe - ExpArg2 * dnoff_dVe * Vtm) / T10;
6799
6800 /* 11 new lines Wagner */
6801 if (selfheat) {
6802 /*fix below expression Wagner */
6803 /*dVgstNVt2_dT = -(pParam->B4SOImstarcv*dVth_dT + VgstNVt2*dT10_dT)/T10;*/
6804 dVgstNVt2_dT = -(-pParam->B4SOImstarcv*dVgst_dT + VgstNVt2*dT10_dT)/T10;
6805 /*fix 1st line of below expression Wagner */
6806 /*dExpArg2_dT = (1- pParam->B4SOImstarcv)*dVth_dT/T10 */
6807 dExpArg2_dT = -(1- pParam->B4SOImstarcv)*dVgst_dT/T10
6808 -ExpArg2*dT10_dT/T10;
6809 }
6810 else {
6811 dT10_dT = 0.0;
6812 dVgstNVt_dT = 0.0;
6813 dExpArg_dT = 0.0;
6814 dExpArg2_dT = 0.0;
6815 }
6816
6817 /* MCJ: Very small Vgst */
6818 if (VgstNVt2 > EXPL_THRESHOLD)
6819 { /* Vgsteff2 = Vgst - pParam->B4SOIdelvt - 1.12; */
6820 Vgsteff2 = Vgst - pParam->B4SOIdelvt - eggbcp2; /* bugfix 4.3.1 -Tanvir */
6821 T0 = -dVth_dVb;
6822 /* LFW_FD fix 4 derivatives */
6823 dVgsteff2_dVg = dVgst_dVg;
6824 dVgsteff2_dVd = dVgst_dVd;
6825 dVgsteff2_dVb = dVgst_dVb;
6826 dVgsteff2_dVe = dVgst_dVe;
6827
6828 if (selfheat)
6829 /*fix below expression Wagner */
6830 /*dVgsteff2_dT = -dVth_dT + T0 * dVbseff_dT;*/
6831 dVgsteff2_dT = dVgst_dT;
6832 else
6833 dVgsteff2_dT = 0.0;
6834 }
6835 else if (ExpArg2 > EXPL_THRESHOLD)
6836 { /* T0 = (Vgst - pParam->B4SOIdelvt - pParam->B4SOIvoffcv - 1.12) / (noff * Vtm);
6837 ExpVgst2 = exp(T0); */
6838 T0 = (Vgst - pParam->B4SOIdelvt - pParam->B4SOIvoffcv - eggbcp2) / (noff * Vtm);
6839 ExpVgst2 = exp(T0); /* bugfix 4.3.1 -Tanvir */
6840 /*Vgsteff2 = Vtm * pParam->B4SOIcdep0 / model->B4SOIcox * ExpVgst*/
6841 Vgsteff2 = Vtm * cdep0 / model->B4SOIcox * ExpVgst2; /*v4.2 bug fix */
6842 T3 = Vgsteff2 / (noff * Vtm) ;
6843 /* T1 is dVgsteff2_dVbseff */
6844 T1 = -T3 * (dVth_dVb + T0 * Vtm * dnoff_dVb);
6845 /* LFW_FD fix 4 derivatives */
6846 dVgsteff2_dVg = Vgsteff2 * (dVgst_dVg / Vtm - T0 * dnoff_dVg) / noff;
6847 dVgsteff2_dVd = Vgsteff2 * (dVgst_dVd / Vtm - T0 * dnoff_dVd) / noff;
6848 dVgsteff2_dVb = Vgsteff2 * (dVgst_dVb / Vtm - T0 * dnoff_dVb) / noff;
6849 dVgsteff2_dVe = Vgsteff2 * (dVgst_dVe / Vtm - T0 * dnoff_dVe) / noff;
6850
6851 if (selfheat)
6852 /* fix 1st line in below expression Wagner */
6853 /*dVgsteff2_dT = -T3 * (dVth_dT + T0 * dVtm_dT * noff) */
6854 dVgsteff2_dT = -T3 * (-dVgst_dT + T0 * dVtm_dT * noff)
6855 + Vgsteff2 / Temp+ T1 * dVbseff_dT;
6856 else
6857 dVgsteff2_dT = 0.0;
6858 }
6859 else
6860 { ExpVgst2 = exp(VgstNVt2);
6861 T1 = T10 * log(1.0 + ExpVgst2);
6862 /* LFW_FD fix 4 derivatives */
6863 dT1_dVg = dnoff_dVg * T1 / noff + T10 * ExpVgst2 * dVgstNVt2_dVg / (1.0 + ExpVgst2);
6864 dT1_dVd = dnoff_dVg * T1 / noff + T10 * ExpVgst2 * dVgstNVt2_dVd / (1.0 + ExpVgst2);
6865 dT1_dVb = dnoff_dVg * T1 / noff + T10 * ExpVgst2 * dVgstNVt2_dVb / (1.0 + ExpVgst2);
6866 dT1_dVe = dnoff_dVg * T1 / noff + T10 * ExpVgst2 * dVgstNVt2_dVe / (1.0 + ExpVgst2);
6867 /*fix below expression Wagner */
6868 /*T3 = (1.0 / Temp); */
6869 T3 = (1.0 / Temp + dnoff_dT / noff);
6870 if (selfheat)
6871 /*fix below expression */
6872 /*dT1_dT = -dT1_dVg * (dVth_dT + (Vgst - pParam->B4SOIdelvt - 1.12) * T3) + T1 * T3;*/
6873 /* dT1_dT = -dT1_dVg * (-dVgst_dT + (Vgst-pParam->B4SOIdelvt-1.12) * T3) + T1 * T3; */
6874 dT1_dT = -dT1_dVg * (-dVgst_dT + (Vgst-pParam->B4SOIdelvt-eggbcp2) * T3) + T1 * T3; /* bugfix 4.3.1 -Tanvir */
6875 else
6876 dT1_dT = 0.0;
6877
6878 /* dT2_dVg = -model->B4SOIcox / (Vtm * pParam->B4SOIcdep0)
6879 * exp(ExpArg2) * (1 - pParam->B4SOImstarcv);*/
6880 dT2_dVg = -model->B4SOIcox / (Vtm * cdep0)
6881 * exp(ExpArg2) * (1 - pParam->B4SOImstarcv); /*v4.2 bug fix */
6882 T2 = pParam->B4SOImstarcv - T10 * dT2_dVg
6883 / (1.0 - pParam->B4SOImstarcv);
6884 /* LFW_FD next 5 lines new */
6885 TL1 = dT2_dVg;
6886 dTL1_dVg = TL1 * dExpArg2_dVg;
6887 dTL1_dVd = TL1 * dExpArg2_dVd;
6888 dTL1_dVb = TL1 * dExpArg2_dVb;
6889 dTL1_dVe = TL1 * dExpArg2_dVe;
6890
6891 /* LFW_FD fix next 5 derivatives */
6892 dT2_dVg = -(dnoff_dVg * Vtm * TL1 + T10 * dTL1_dVg) / (1.0 - pParam->B4SOImstarcv);
6893 dT2_dVd = -(dnoff_dVg * Vtm * TL1 + T10 * dTL1_dVd) / (1.0 - pParam->B4SOImstarcv);
6894 dT2_dVb = -(dnoff_dVg * Vtm * TL1 + T10 * dTL1_dVb) / (1.0 - pParam->B4SOImstarcv);
6895 dT2_dVe = -(dnoff_dVg * Vtm * TL1 + T10 * dTL1_dVe) / (1.0 - pParam->B4SOImstarcv);
6896 if (selfheat)
6897 dT2_dT = -(dT10_dT*TL1
6898 +T10*TL1*(-dVtm_dT/Vtm-dcdep0_dT/cdep0+dExpArg2_dT)
6899 )/(1.0 - pParam->B4SOImstarcv);
6900 else
6901 dT2_dT = 0.0;
6902
6903 Vgsteff2 = T1 / T2;
6904 T3 = T2 * T2;
6905 /* T4 is dVgsteff2_dVbseff */
6906 T4 = (T2 * dT1_dVb - T1 * dT2_dVb) / T3;
6907 /* LFW_FD fix next 4 derivatives */
6908 dVgsteff2_dVg = (T2 * dT1_dVg - T1 * dT2_dVg) / T3;
6909 dVgsteff2_dVd = (T2 * dT1_dVd - T1 * dT2_dVd) / T3;
6910 dVgsteff2_dVb = (T2 * dT1_dVb - T1 * dT2_dVb) / T3;
6911 dVgsteff2_dVe = (T2 * dT1_dVe - T1 * dT2_dVe) / T3;
6912 if (selfheat)
6913 /*fix below expression Wagner */
6914 /*dVgsteff2_dT = (T2 * dT1_dT - T1 * dT2_dT)
6915 / T3+ T4 * dVbseff_dT; */
6916 dVgsteff2_dT = (T2 * dT1_dT - T1 * dT2_dT) / T3;
6917 else
6918 dVgsteff2_dT = 0.0;
6919 }
6920 }
6921 }
6922 /* v3.2 */
6923 /* v3.2 */
6924
6925 /* LFW_FD flexilint initializations next 9 lines */
6926 Qsub02 = dQsub02_dVrg = dQsub02_dVg = dQsub02_dVd = dQsub02_dVb = dQsub02_dVe = dQsub02_dT = 0.0;
6927 Qac02 = dQac02_dVrg = dQac02_dVg = dQac02_dVd = dQac02_dVb = dQac02_dVe = dQac02_dT = 0.0;
6928 dqsrc_dT = 0.0;
6929 dVdseffCV2_dT = 0;
6930 T02 = dT02_dVg = dT02_dVd = dT02_dVb = dT02_dVe = 0.0;
6931 T12 = dT12_dVg = dT12_dVd = dT12_dVb = dT12_dVe = 0.0;
6932 T22 = dT22_dVg = dT22_dVd = dT22_dVb = dT22_dVe = 0.0;
6933
6934 if (model->B4SOIcapMod == 2)
6935 {
6936
6937 /* v3.1 */
6938 if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */
6939 {
6940 /* LFW_FD flexilint initializations next 4 lines */
6941 Qac0 = dQac0_dVrg = dQac0_dVg = dQac0_dVd = dQac0_dVb = dQac0_dVe = dQac0_dT = 0.0;
6942 dQac02_dVrg = dQac02_dVg = dQac02_dVd = dQac02_dVb = dQac02_dVe = dQac02_dT = 0.0;
6943 Qsub0 = dQsub0_dVrg = dQsub0_dVg = dQsub0_dVd = dQsub0_dVb = dQsub0_dVe = dQsub0_dT = 0.0;
6944 dQsub02_dVrg = dQsub02_dVg = dQsub02_dVd = dQsub02_dVb = dQsub02_dVe = dQsub02_dT = 0.0;
6945 }
6946 else /* soiMod = 0 or 1 */
6947 {
6948 Vfb = Vth - phi - pParam->B4SOIk1eff * sqrtPhis + pParam->B4SOIdelvt;
6949 dVfb_dVb = dVth_dVb - pParam->B4SOIk1eff * dsqrtPhis_dVb;
6950 /* LFW_FD fix/add next 3 derivatives */
6951 dVfb_dVd = dVth_dVd - pParam->B4SOIk1eff * dsqrtPhis_dVd;
6952 dVfb_dVg = dVth_dVg - pParam->B4SOIk1eff * dsqrtPhis_dVg;
6953 dVfb_dVe = dVth_dVe - pParam->B4SOIk1eff * dsqrtPhis_dVe;
6954 /*fix below expression Wagner */
6955 /*dVfb_dT = dVth_dT; */
6956 dVfb_dT = dVth_dT - dphi_dT - pParam->B4SOIk1eff*dsqrtPhis_dT;
6957
6958 V3 = Vfb - Vgs_eff + Vbseff - DELTA_3_SOI;
6959 if (Vfb <= 0.0)
6960 { T0 = sqrt(V3 * V3 - 4.0 * DELTA_3_SOI * Vfb);
6961 T2 = -DELTA_3_SOI / T0;
6962 }
6963 else
6964 { T0 = sqrt(V3 * V3 + 4.0 * DELTA_3_SOI * Vfb);
6965 T2 = DELTA_3_SOI / T0;
6966 }
6967
6968 T1 = 0.5 * (1.0 + V3 / T0);
6969 Vfbeff = Vfb - 0.5 * (V3 + T0);
6970 /* LFW_FD fix/add next 4 derivatives */
6971 dVfbeff_dVd = (1.0 - T1 - T2) * dVfb_dVd - T1 * dVbseff_dVd;
6972 dVfbeff_dVb = (1.0 - T1 - T2) * dVfb_dVb - T1 * dVbseff_dVb;
6973 dVfbeff_dVg = (1.0 - T1 - T2) * dVfb_dVg - T1 * (dVbseff_dVg - dVgs_eff_dVg);
6974 dVfbeff_dVe = (1.0 - T1 - T2) * dVfb_dVe - T1 * dVbseff_dVe;
6975 dVfbeff_dVrg = T1 * dVgs_eff_dVg;
6976 /*fix below expression Wagner */
6977 /*if (selfheat) dVfbeff_dT = (1.0 - T1 - T2) * dVfb_dT;
6978 - T1*dVbseff_dT; */
6979 if (selfheat) dVfbeff_dT = (1.0 - T1 - T2) * dVfb_dT
6980 + T1*(dVgs_eff_dT-dVbseff_dT);
6981 else dVfbeff_dT = 0.0;
6982
6983 Qac0 = CoxWLb * (Vfbeff - Vfb);
6984 dQac0_dVrg = CoxWLb * dVfbeff_dVrg;
6985 dQac0_dVd = CoxWLb * (dVfbeff_dVd - dVfb_dVd);
6986 dQac0_dVb = CoxWLb * (dVfbeff_dVb - dVfb_dVb);
6987 /* LFW_FD add next 2 derivatives */
6988 dQac0_dVg = CoxWLb * (dVfbeff_dVg - dVfb_dVg);
6989 dQac0_dVe = CoxWLb * (dVfbeff_dVe - dVfb_dVe);
6990 if (selfheat) dQac0_dT = CoxWLb * (dVfbeff_dT - dVfb_dT);
6991 else dQac0_dT = 0.0;
6992 /* v4.1 */
6993 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' Jun 09 */
6994 ( here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0)
6995 {
6996 /* Vfb2 = Vfb + 1.12; */
6997 Vfb2 = Vfb + eggbcp2; /* bugfix 4.3.1 -Tanvir */
6998 dVfb2_dVb = dVfb_dVb;
6999 dVfb2_dVd = dVfb_dVd;
7000 /* LFW_FD add next 2 derivatives */
7001 dVfb2_dVg = dVfb_dVg;
7002 dVfb2_dVe = dVfb_dVe;
7003 dVfb2_dT = dVfb_dT;
7004 DELTA_3_SOI2 = DELTA_3_SOI;
7005 V3 = Vfb2 - Vgs_eff2 + Vbseff - DELTA_3_SOI2;
7006 if (Vfb2 <= 0.0)
7007 { T0 = sqrt(V3 * V3 - 100.0 * DELTA_3_SOI2 * Vfb2);
7008 T2 = -25.0 * DELTA_3_SOI2 / T0;
7009 }
7010 else
7011 { T0 = sqrt(V3 * V3 + 100.0 * DELTA_3_SOI2 * Vfb2);
7012 T2 = 25.0 * DELTA_3_SOI2 / T0;
7013 }
7014 T1 = 0.5 * (1.0 + V3 / T0);
7015 Vfbeff2 = Vfb2 - 0.5 * (V3 + T0);
7016 /* LFW_FD fix/add next 4 derivatives */
7017 dVfbeff2_dVg = (1.0 - T2) * dVfb2_dVg - T1 * (dVfb2_dVg - dVgs_eff2_dVg + dVbseff_dVg);
7018 dVfbeff2_dVd = (1.0 - T2) * dVfb2_dVd - T1 * (dVfb2_dVd + dVbseff_dVd);
7019 dVfbeff2_dVb = (1.0 - T2) * dVfb2_dVb - T1 * (dVfb2_dVb + dVbseff_dVb);
7020 dVfbeff2_dVe = (1.0 - T2) * dVfb2_dVe - T1 * (dVfb2_dVe + dVbseff_dVe);
7021 dVfbeff2_dVrg = T1 * dVgs_eff2_dVg;
7022 /*fix below expression Wagner */
7023 /*if (selfheat) dVfbeff2_dT = (1.0 - T1 - T2) * dVfb2_dT; */
7024 if (selfheat) dVfbeff2_dT = (1.0 - T1 - T2) * dVfb2_dT
7025 - T1*dVfbeff2_dT;
7026 else dVfbeff2_dT = 0.0;
7027
7028 Qac0 += CoxWLb2 * (Vfbeff2 - Vfb2);
7029 dQac02_dVrg = CoxWLb2 * dVfbeff2_dVrg;
7030 dQac02_dVd = CoxWLb2 * (dVfbeff2_dVd - dVfb2_dVd);
7031 dQac02_dVb = CoxWLb2 * (dVfbeff2_dVb - dVfb2_dVb);
7032 /* LFW_FD add next 2 derivatives */
7033 dQac02_dVg = CoxWLb2 * (dVfbeff2_dVg - dVfb2_dVg);
7034 dQac02_dVe = CoxWLb2 * (dVfbeff2_dVe - dVfb2_dVe);
7035 if (selfheat)
7036 dQac02_dT = CoxWLb2 * (dVfbeff2_dT - dVfb2_dT);
7037 else dQac02_dT = 0.0;
7038 dQac0_dT += dQac02_dT; /* new line Wagner */
7039 }
7040 /* end v4.1 */
7041 T0 = 0.5 * pParam->B4SOIk1ox;
7042 T3 = Vgs_eff - Vfbeff - Vbseff - Vgsteff;
7043 if (pParam->B4SOIk1ox == 0.0)
7044 { T1 = 0.0;
7045 T2 = 0.0;
7046 }
7047 else if (T3 < 0.0)
7048 { T1 = T0 + T3 / pParam->B4SOIk1ox;
7049 T2 = CoxWLb;
7050 }
7051 else
7052 { T1 = sqrt(T0 * T0 + T3);
7053 T2 = CoxWLb * T0 / T1;
7054 }
7055
7056 Qsub0 = CoxWLb * pParam->B4SOIk1ox * (T1 - T0); /* 4.1 bug fix */
7057 dQsub0_dVrg = T2 * (dVgs_eff_dVg - dVfbeff_dVrg);
7058 /* LFW_FD fix/add next 4 derivatives */
7059 dQsub0_dVd = -T2 * (dVfbeff_dVd + dVbseff_dVd + dVgsteff_dVd);
7060 dQsub0_dVg = T2 * (dVgs_eff_dVg - dVfbeff_dVg - dVbseff_dVg - dVgsteff_dVg);
7061 dQsub0_dVb = -T2 * (dVfbeff_dVb + dVbseff_dVb + dVgsteff_dVb);
7062 dQsub0_dVe = -T2 * (dVfbeff_dVe + dVbseff_dVe + dVgsteff_dVe);
7063 /*fix below expression Wagner */
7064 /*if (selfheat) dQsub0_dT = -T2 * dVfbeff_dT; */
7065 if (selfheat) dQsub0_dT = -T2 * (-dVgs_eff_dT + dVfbeff_dT + dVbseff_dT + dVgsteff_dT);
7066 else dQsub0_dT = 0.0;
7067 /* v4.1 */
7068 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
7069 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0)
7070 { T3 = Vgs_eff2- Vfbeff2 - Vbseff - Vgsteff2;
7071 if (T3 < 0.0)
7072 { T1 = T0 + T3 / pParam->B4SOIk1ox;
7073 T2 = CoxWLb2;
7074 }
7075 else
7076 { T1 = sqrt(T0 * T0 + T3);
7077 T2 = CoxWLb2 * T0 / T1;
7078 }
7079 Qsub0 += CoxWLb2 * pParam->B4SOIk1ox * (T1 - T0);
7080 dQsub02_dVrg = T2 * (dVgs_eff2_dVg - dVfbeff2_dVrg);
7081 /* LFW_FD fix/add next 4 derivatives */
7082 dQsub02_dVg = T2 * (dVgs_eff2_dVg - dVfbeff2_dVg - dVbseff_dVg - dVgsteff2_dVg);
7083 dQsub02_dVd = -T2 * ( dVfbeff2_dVd + dVbseff_dVd + dVgsteff2_dVd);
7084 dQsub02_dVb = -T2 * ( dVfbeff2_dVb + dVbseff_dVb + dVgsteff2_dVb);
7085 dQsub02_dVe = -T2 * ( dVfbeff2_dVe + dVbseff_dVe + dVgsteff2_dVe);
7086 /*fix below expression Wagner */
7087 /*if (selfheat) dQsub02_dT = -T2 * dVfbeff2_dT; */
7088 if (selfheat) dQsub02_dT = -T2 * (dVfbeff2_dT + dVbseff_dT + dVgsteff2_dT);
7089 else dQsub02_dT = 0.0;
7090 dQsub0_dT += dQsub02_dT; /* new line Wagner */
7091 }
7092 }
7093 /* v3.1 */
7094
7095
7096
7097 AbulkCV = Abulk0 * pParam->B4SOIabulkCVfactor;
7098 /* LFW_FD add next 3 derivatives */
7099 dAbulkCV_dVg = pParam->B4SOIabulkCVfactor * dAbulk0_dVg;
7100 dAbulkCV_dVd = pParam->B4SOIabulkCVfactor * dAbulk0_dVd;
7101 dAbulkCV_dVe = pParam->B4SOIabulkCVfactor * dAbulk0_dVe;
7102 dAbulkCV_dVb = pParam->B4SOIabulkCVfactor * dAbulk0_dVb;
7103 dAbulkCV_dT = dAbulk0_dT * pParam->B4SOIabulkCVfactor; /* new line Wagner */
7104
7105 VdsatCV = Vgsteff / AbulkCV;
7106 /* LFW_FD fix/add next 4 derivatives */
7107 dVdsatCV_dVg = (dVgsteff_dVg -VdsatCV * dAbulkCV_dVg) / AbulkCV;
7108 dVdsatCV_dVd = (dVgsteff_dVd -VdsatCV * dAbulkCV_dVd) / AbulkCV;
7109 dVdsatCV_dVb = (dVgsteff_dVb -VdsatCV * dAbulkCV_dVb) / AbulkCV;
7110 dVdsatCV_dVe = (dVgsteff_dVe -VdsatCV * dAbulkCV_dVe) / AbulkCV;
7111
7112 V4 = VdsatCV - Vds - DELTA_4;
7113 T0 = sqrt(V4 * V4 + 4.0 * DELTA_4 * VdsatCV);
7114 VdseffCV = VdsatCV - 0.5 * (V4 + T0);
7115 T1 = 0.5 * (1.0 + V4 / T0);
7116 T2 = DELTA_4 / T0;
7117 T3 = (1.0 - T1 - T2) / AbulkCV;
7118 /* LFW_FD fix/add next 4 derivatives */
7119 dVdseffCV_dVg = ( 1.0 - T1 - T2) * dVdsatCV_dVg;
7120 dVdseffCV_dVd = ( 1.0 - T1 - T2) * dVdsatCV_dVd + T1;
7121 dVdseffCV_dVb = ( 1.0 - T1 - T2) * dVdsatCV_dVb;
7122 dVdseffCV_dVe = ( 1.0 - T1 - T2) * dVdsatCV_dVe;
7123 /* 10 new lines Wagner */
7124 if (selfheat) {
7125 dVdsatCV_dT = dVgsteff_dT/AbulkCV
7126 -VdsatCV*dAbulkCV_dT/AbulkCV;
7127 dTL1_dT = (V4 + 2.0 * DELTA_4) * dVdsatCV_dT / T0;
7128 dVdseffCV_dT = 0.5*dVdsatCV_dT - 0.5*dTL1_dT;
7129 }
7130 else {
7131 dVdsatCV_dT = 0;
7132 dVdseffCV_dT = 0;
7133 }
7134
7135 /* v4.1 */
7136 if (here->B4SOIagbcp2 > 0)
7137 { VdsatCV2 = Vgsteff2 / AbulkCV;
7138 /* LFW_FD fix/add next 4 derivatives */
7139 dVdsatCV2_dVg = (dVgsteff2_dVg - VdsatCV2 * dAbulkCV_dVg) / AbulkCV;
7140 dVdsatCV2_dVd = (dVgsteff2_dVd - VdsatCV2 * dAbulkCV_dVd) / AbulkCV;
7141 dVdsatCV2_dVb = (dVgsteff2_dVb - VdsatCV2 * dAbulkCV_dVb) / AbulkCV;
7142 dVdsatCV2_dVe = (dVgsteff2_dVe - VdsatCV2 * dAbulkCV_dVe) / AbulkCV;
7143 V4 = VdsatCV2 - Vds - DELTA_4;
7144 T0 = sqrt(V4 * V4 + 4.0 * DELTA_4 * VdsatCV2);
7145 VdseffCV2 = VdsatCV2 - 0.5 * (V4 + T0);
7146 T1 = 0.5 * (1.0 + V4 / T0);
7147 T2 = DELTA_4 / T0;
7148 T3 = (1.0 - T1 - T2) / AbulkCV;
7149 /* LFW_FD fix/add next 4 derivatives */
7150 dVdseffCV2_dVg = (1.0 - T1 - T2 ) * dVdsatCV2_dVg;
7151 dVdseffCV2_dVd = (1.0 - T1 - T2 ) * dVdsatCV2_dVd + T1;
7152 dVdseffCV2_dVb = (1.0 - T1 - T2 ) * dVdsatCV2_dVb;
7153 dVdseffCV2_dVe = (1.0 - T1 - T2 ) * dVdsatCV2_dVe;
7154 /* 10 new lines Wagner */
7155 if (selfheat) {
7156 dVdsatCV2_dT = dVgsteff2_dT/AbulkCV
7157 -VdsatCV2*dAbulkCV_dT/AbulkCV;
7158 dTL1_dT = (V4 + 2.0 * DELTA_4) * dVdsatCV2_dT / T0;
7159 dVdseffCV2_dT = 0.5*dVdsatCV2_dT - 0.5*dTL1_dT;
7160 }
7161 else {
7162 dVdsatCV2_dT = 0;
7163 dVdseffCV2_dT = 0;
7164 }
7165 }
7166 /* end v4.1 */
7167
7168 /* v3.1 */
7169 Cbg12 = Cbd12 = Cbb12 = Cbe12 = 0; /* LFW_FD flexilint */
7170 dqbulk_dT = 0; /* new line Wagner */
7171 if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */
7172 {
7173 qbulk = Cbg1 = Cbd1 = Cbb1 = Cbe1 = 0; /* LFW_FD enhance 2 lines */
7174 Cbg12 = Cbd12 = Cbb12 = Cbe12 = 0; /* v4.1 */
7175 }
7176 else
7177 {
7178 T0 = AbulkCV * VdseffCV;
7179 T1 = 12.0 * (Vgsteff - 0.5 * T0 + 1e-20);
7180 T2 = VdseffCV / T1;
7181 T3 = T0 * T2;
7182 T4 = (1.0 - 12.0 * T2 * T2 * AbulkCV);
7183 T5 = (6.0 * T0 * (4.0 * Vgsteff- T0) / (T1 * T1) - 0.5);
7184 T6 = 12.0 * T2 * T2 * Vgsteff;
7185
7186 T7 = 1.0 - AbulkCV;
7187 qbulk = CoxWLb * T7 * (0.5 * VdseffCV - T3);
7188 T4 = -T7 * (T4 - 1.0);
7189 T5 = -T7 * T5;
7190 T6 = -(T7 * T6 + (0.5 * VdseffCV - T3));
7191
7192 /* LFW_FD fix next 3 lines with next 20 lines */
7193 /* Cbg1 = CoxWLb * (T4 + T5 * dVdseffCV_dVg); */
7194 /* Cbd1 = CoxWLb * T5 * dVdseffCV_dVd ; */
7195 /* Cbb1 = CoxWLb * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb);*/
7196
7197 dT0_dVg = AbulkCV * dVdseffCV_dVg + dAbulkCV_dVg * VdseffCV;
7198 dT0_dVd = AbulkCV * dVdseffCV_dVd + dAbulkCV_dVd * VdseffCV;
7199 dT0_dVb = AbulkCV * dVdseffCV_dVb + dAbulkCV_dVb * VdseffCV;
7200 dT0_dVe = AbulkCV * dVdseffCV_dVe + dAbulkCV_dVe * VdseffCV;
7201
7202 dT1_dVg = 12.0 * (dVgsteff_dVg - 0.5 * dT0_dVg);
7203 dT1_dVd = 12.0 * (dVgsteff_dVd - 0.5 * dT0_dVd);
7204 dT1_dVb = 12.0 * (dVgsteff_dVb - 0.5 * dT0_dVb);
7205 dT1_dVe = 12.0 * (dVgsteff_dVe - 0.5 * dT0_dVe);
7206
7207 Cbg1 = CoxWLb * (T7 * (0.5 - T0 / T1) * dVdseffCV_dVg
7208 - T7 * VdseffCV * ((dT0_dVg - T0 * dT1_dVg / T1) / T1)
7209 - dAbulkCV_dVg * (0.5 * VdseffCV - T3) );
7210 Cbd1 = CoxWLb * (T7 * (0.5 - T0 / T1) * dVdseffCV_dVd
7211 - T7 * VdseffCV * ((dT0_dVd - T0 * dT1_dVd / T1) / T1)
7212 - dAbulkCV_dVd * (0.5 * VdseffCV - T3) );
7213 Cbb1 = CoxWLb * (T7 * (0.5 - T0 / T1) * dVdseffCV_dVb
7214 - T7 * VdseffCV * ((dT0_dVb - T0 * dT1_dVb / T1) / T1)
7215 - dAbulkCV_dVb * (0.5 * VdseffCV - T3) );
7216 Cbe1 = CoxWLb * (T7 * (0.5 - T0 / T1) * dVdseffCV_dVe
7217 - T7 * VdseffCV * ((dT0_dVe - T0 * dT1_dVe / T1) / T1)
7218 - dAbulkCV_dVe * (0.5 * VdseffCV - T3) );
7219
7220 /* 10 new lines Wagner */
7221 if (selfheat) {
7222 dTL1_dT = AbulkCV * dVdseffCV_dT + dAbulkCV_dT * VdseffCV;
7223 dTL2_dT = 12.0 * (dVgsteff_dT -0.5 * dTL1_dT);
7224 dTL3_dT = (dVdseffCV_dT - T2 * dTL2_dT) / T1;
7225 dTL4_dT = T0 * dTL3_dT + dTL1_dT * T2;
7226 dqbulk_dT = CoxWLb *
7227 (-dAbulk_dT * (0.5 * VdseffCV - T3)
7228 + T7 * (0.5 * dVdseffCV_dT - dTL4_dT));
7229 }
7230 else dqbulk_dT = 0;
7231
7232 /* v4.1 */
7233 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
7234 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0)
7235 { T0 = AbulkCV * VdseffCV2;
7236 T1 = 12.0 * (Vgsteff2 - 0.5 * T0 + 1e-20);
7237 T2 = VdseffCV2 / T1;
7238 T3 = T0 * T2;
7239 T4 = (1.0 - 12.0 * T2 * T2 * AbulkCV);
7240 T5 = (6.0 * T0 * (4.0 * Vgsteff2 - T0) / (T1 * T1) - 0.5);
7241 T6 = 12.0 * T2 * T2 * Vgsteff2;
7242 T7 = 1.0 - AbulkCV;
7243 qbulk += CoxWLb2 * T7 * (0.5 * VdseffCV2 - T3);
7244 T4 = -T7 * (T4 - 1.0);
7245 T5 = -T7 * T5;
7246 T6 = -(T7 * T6 + (0.5 * VdseffCV2 - T3));
7247 /* LFW_FD fix next 3 lines with next 20 lines */
7248 /* Cbg12 = CoxWLb2 * (T4 + T5 * dVdseffCV2_dVg);*/
7249 /* Cbd12 = CoxWLb2 * T5 * dVdseffCV2_dVd ; */
7250 /* Cbb12 = CoxWLb2 * (T5 * dVdseffCV2_dVb + T6 * dAbulkCV_dVb);*/
7251
7252 dT0_dVg = AbulkCV * dVdseffCV2_dVg + dAbulkCV_dVg * VdseffCV2;
7253 dT0_dVd = AbulkCV * dVdseffCV2_dVd + dAbulkCV_dVd * VdseffCV2;
7254 dT0_dVb = AbulkCV * dVdseffCV2_dVb + dAbulkCV_dVb * VdseffCV2;
7255 dT0_dVe = AbulkCV * dVdseffCV2_dVe + dAbulkCV_dVe * VdseffCV2;
7256
7257 dT1_dVg = 12.0 * (dVgsteff2_dVg - 0.5 * dT0_dVg);
7258 dT1_dVd = 12.0 * (dVgsteff2_dVd - 0.5 * dT0_dVd);
7259 dT1_dVb = 12.0 * (dVgsteff2_dVb - 0.5 * dT0_dVb);
7260 dT1_dVe = 12.0 * (dVgsteff2_dVe - 0.5 * dT0_dVe);
7261
7262 Cbg12 = CoxWLb2 * (T7 * (0.5 - T0 / T1) * dVdseffCV2_dVg
7263 - T7 * VdseffCV2 * ((dT0_dVg - T0 * dT1_dVg / T1) / T1)
7264 - dAbulkCV_dVg * (0.5 * VdseffCV2 - T3) );
7265 Cbd12 = CoxWLb2 * (T7 * (0.5 - T0 / T1) * dVdseffCV2_dVd
7266 - T7 * VdseffCV2 * ((dT0_dVd - T0 * dT1_dVd / T1) / T1)
7267 - dAbulkCV_dVd * (0.5 * VdseffCV2 - T3) );
7268 Cbb12 = CoxWLb2 * (T7 * (0.5 - T0 / T1) * dVdseffCV2_dVb
7269 - T7 * VdseffCV2 * ((dT0_dVb - T0 * dT1_dVb / T1) / T1)
7270 - dAbulkCV_dVb * (0.5 * VdseffCV2 - T3) );
7271 Cbe12 = CoxWLb2 * (T7 * (0.5 - T0 / T1) * dVdseffCV2_dVe
7272 - T7 * VdseffCV2 * ((dT0_dVe - T0 * dT1_dVe / T1) / T1)
7273 - dAbulkCV_dVe * (0.5 * VdseffCV2 - T3) );
7274
7275 /* 10 new lines Wagner */
7276 if (selfheat) {
7277 dTL1_dT = AbulkCV * dVdseffCV2_dT + dAbulkCV_dT * VdseffCV2;
7278 dTL2_dT = 12.0 * (dVgsteff2_dT -0.5 * dTL1_dT);
7279 dTL3_dT = (dVdseffCV2_dT - T2 * dTL2_dT) / T1;
7280 dTL4_dT = T0 * dTL3_dT + dTL1_dT * T2;
7281 dqbulk_dT += CoxWLb2 *
7282 (-dAbulk_dT * (0.5 * VdseffCV2 - T3)
7283 + T7 * (0.5 * dVdseffCV2_dT - dTL4_dT));
7284 }
7285 else dqbulk_dT += 0;
7286 }
7287 /* end v4.1 */
7288 }
7289 /* v3.1 */
7290
7291
7292
7293 /* Total inversion charge */
7294 T0 = AbulkCV * VdseffCV;
7295 T1 = 12.0 * (Vgsteff - 0.5 * T0 + 1e-20);
7296 /* T2 = VdseffCV / T1;
7297 */
7298 T2 = T0 / T1;
7299 T3 = T0 * T2;
7300
7301 /* T4 = (1.0 - 12.0 * T2 * T2 * AbulkCV);
7302 T5 = (6.0 * T0 * (4.0 * Vgsteff - T0) / (T1 * T1) - 0.5);
7303 T6 = 12.0 * T2 * T2 * Vgsteff;
7304 */
7305 T4 = (1.0 - 12.0 * T2 * T2);/*bug fix */
7306 T7 = T2 * (2.0 + 6.0 * T2) - 0.5; /*bug fix */
7307
7308 T5 = T7 * AbulkCV;
7309 T6 = T7 * VdseffCV;
7310
7311 /* qinv = CoxWL * (Vgsteff - 0.5 * VdseffCV + T3);
7312 */
7313 qgate = qinv = CoxWL * (Vgsteff - 0.5 * T0 + T3); /* enhanced line Wagner */
7314
7315 here->B4SOIqinv = -qinv; /* for noise v3.2 */
7316
7317 /* LFW_FD fix next 3 lines with next 20 lines */
7318 /* Cgg1 = CoxWL * (T4 + T5 * dVdseffCV_dVg); */
7319 /* Cgd1 = CoxWL * T5 * dVdseffCV_dVd; */
7320 /* Cgb1 = CoxWL * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb);*/
7321 dT0_dVg = dAbulkCV_dVg * VdseffCV + AbulkCV * dVdseffCV_dVg;
7322 dT0_dVd = dAbulkCV_dVd * VdseffCV + AbulkCV * dVdseffCV_dVd;
7323 dT0_dVb = dAbulkCV_dVb * VdseffCV + AbulkCV * dVdseffCV_dVb;
7324 dT0_dVe = dAbulkCV_dVe * VdseffCV + AbulkCV * dVdseffCV_dVe;
7325
7326 dT1_dVg = 12.0 * (dVgsteff_dVg - 0.5 * dT0_dVg);
7327 dT1_dVd = 12.0 * (dVgsteff_dVd - 0.5 * dT0_dVd);
7328 dT1_dVb = 12.0 * (dVgsteff_dVb - 0.5 * dT0_dVb);
7329 dT1_dVe = 12.0 * (dVgsteff_dVe - 0.5 * dT0_dVe);
7330
7331 dT2_dVg = (dT0_dVg - T2 * dT1_dVg) / T1;
7332 dT2_dVd = (dT0_dVd - T2 * dT1_dVd) / T1;
7333 dT2_dVb = (dT0_dVb - T2 * dT1_dVb) / T1;
7334 dT2_dVe = (dT0_dVe - T2 * dT1_dVe) / T1;
7335
7336 dT3_dVg = dT0_dVg * T2 + T0 * dT2_dVg;
7337 dT3_dVd = dT0_dVd * T2 + T0 * dT2_dVd;
7338 dT3_dVb = dT0_dVb * T2 + T0 * dT2_dVb;
7339 dT3_dVe = dT0_dVe * T2 + T0 * dT2_dVe;
7340
7341 Cgg1 = CoxWL * (dVgsteff_dVg - 0.5 * dT0_dVg + dT3_dVg);
7342 Cgd1 = CoxWL * (dVgsteff_dVd - 0.5 * dT0_dVd + dT3_dVd);
7343 Cgb1 = CoxWL * (dVgsteff_dVb - 0.5 * dT0_dVb + dT3_dVb);
7344 Cge1 = CoxWL * (dVgsteff_dVe - 0.5 * dT0_dVe + dT3_dVe);
7345
7346 /* 7 new lines Wagner */
7347 if (selfheat) {
7348 dTL1_dT = AbulkCV * dVdseffCV_dT + dAbulkCV_dT * VdseffCV;
7349 dTL2_dT = 12 * (dVgsteff_dT - 0.5*dTL1_dT);
7350 dTL3_dT = (2 * T0 * dTL1_dT - T3 * dTL2_dT) / T1;
7351 dqgate_dT = CoxWL * (dVgsteff_dT - 0.5* dTL1_dT + dTL3_dT);
7352 }
7353 else dqgate_dT = 0;
7354
7355 /* v4.1 */
7356 /* LFW_FD 2 new lines per flexilint */
7357 T12 = T02 = Cgg12 = Cgd12 = Cgb12 = Cge12 = 0.0;
7358 Csg12 = Csd12 = Csb12 = Cse12 = 0.0;
7359 dqsrc2_dT = 0; /* new line Wagner */
7360 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
7361 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0)
7362 {
7363 T02 = AbulkCV * VdseffCV2;
7364 T12 = 12.0 * (Vgsteff2 - 0.5 * T02 + 1e-20);
7365 T2 = T02 / T12;
7366 T3 = T02 * T2;
7367 T4 = (1.0 - 12.0 * T2 * T2);
7368 T7 = T2 * (2.0 + 6.0 * T2) - 0.5;
7369
7370 T5 = T7 * AbulkCV;
7371 T6 = T7 * VdseffCV2;
7372
7373 qinv += CoxWL2 * (Vgsteff2 - 0.5 * T02 + T3);
7374 qgate = qinv; /* new line Wagner */
7375 here->B4SOIqinv = -qinv;
7376
7377 /* LFW_FD fix next 3 lines with next 20 lines */
7378 /* Cgg12 = CoxWL2 * (T4 + T5 * dVdseffCV2_dVg); */
7379 /* Cgd12 = CoxWL2 * T5 * dVdseffCV2_dVd; */
7380 /* Cgb12 = CoxWL2 * (T5 * dVdseffCV2_dVb + T6 * dAbulkCV_dVb);*/
7381
7382 dT02_dVg = dAbulkCV_dVg * VdseffCV2 + AbulkCV * dVdseffCV2_dVg;
7383 dT02_dVd = dAbulkCV_dVd * VdseffCV2 + AbulkCV * dVdseffCV2_dVd;
7384 dT02_dVb = dAbulkCV_dVb * VdseffCV2 + AbulkCV * dVdseffCV2_dVb;
7385 dT02_dVe = dAbulkCV_dVe * VdseffCV2 + AbulkCV * dVdseffCV2_dVe;
7386
7387 dT12_dVg = 12.0 * (dVgsteff2_dVg - 0.5 * dT02_dVg);
7388 dT12_dVd = 12.0 * (dVgsteff2_dVd - 0.5 * dT02_dVd);
7389 dT12_dVb = 12.0 * (dVgsteff2_dVb - 0.5 * dT02_dVb);
7390 dT12_dVe = 12.0 * (dVgsteff2_dVe - 0.5 * dT02_dVe);
7391
7392 dT2_dVg = (dT02_dVg - T2 * dT12_dVg) / T12;
7393 dT2_dVd = (dT02_dVd - T2 * dT12_dVd) / T12;
7394 dT2_dVb = (dT02_dVb - T2 * dT12_dVb) / T12;
7395 dT2_dVe = (dT02_dVe - T2 * dT12_dVe) / T12;
7396
7397 dT3_dVg = dT02_dVg * T2 + T02 * dT2_dVg;
7398 dT3_dVd = dT02_dVd * T2 + T02 * dT2_dVd;
7399 dT3_dVb = dT02_dVb * T2 + T02 * dT2_dVb;
7400 dT3_dVe = dT02_dVe * T2 + T02 * dT2_dVe;
7401
7402 Cgg12 = CoxWL2 * (dVgsteff2_dVg - 0.5 * dT02_dVg + dT3_dVg);
7403 Cgd12 = CoxWL2 * (dVgsteff2_dVd - 0.5 * dT02_dVd + dT3_dVd);
7404 Cgb12 = CoxWL2 * (dVgsteff2_dVb - 0.5 * dT02_dVb + dT3_dVb);
7405 Cge12 = CoxWL2 * (dVgsteff2_dVe - 0.5 * dT02_dVe + dT3_dVe);
7406
7407 /* 8 new lines Wagner */
7408 if (selfheat) {
7409 dTL1_dT = AbulkCV * dVdseffCV2_dT + dAbulkCV_dT * VdseffCV2;
7410 dTL2_dT = 12 * (dVgsteff2_dT - 0.5*dTL1_dT);
7411 dTL3_dT = (2 * T02 * dTL1_dT - T3 * dTL2_dT) / T12;
7412 dqgate2_dT = CoxWL2 * (dVgsteff2_dT - 0.5* dTL1_dT + dTL3_dT);
7413 dqgate_dT += dqgate2_dT;
7414 }
7415 else dqgate_dT = 0;
7416 }
7417 /* end v4.1 */
7418 /* Inversion charge partitioning into S / D */
7419 if (model->B4SOIxpart > 0.5)
7420 { /* 0/100 Charge partition model */
7421 T1 = T1 + T1;
7422 qsrc = -CoxWL * (0.5 * Vgsteff + 0.25 * T0
7423 - T0 * T0 / T1);
7424 T7 = (4.0 * Vgsteff - T0) / (T1 * T1);
7425 T4 = -(0.5 + 24.0 * T0 * T0 / (T1 * T1));
7426 T5 = -(0.25 * AbulkCV - 12.0 * AbulkCV * T0 * T7);
7427 T6 = -(0.25 * VdseffCV - 12.0 * T0 * VdseffCV * T7);
7428 /* LFW_FD fix next 3 lines with next 12 lines */
7429 /* Csg1 = CoxWL * (T4 + T5 * dVdseffCV_dVg); */
7430 /* Csd1 = CoxWL * T5 * dVdseffCV_dVd; */
7431 /* Csb1 = CoxWL * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb);*/
7432 dT1_dVg = 2.0 * dT1_dVg;
7433 dT1_dVd = 2.0 * dT1_dVd;
7434 dT1_dVb = 2.0 * dT1_dVb;
7435 dT1_dVe = 2.0 * dT1_dVe;
7436
7437 Csg1 = -CoxWL * (0.5 * dVgsteff_dVg + 0.25 * dT0_dVg
7438 - 2.0 * T0 * dT0_dVg / T1 + T0 * T0 * dT1_dVg / (T1 * T1));
7439 Csd1 = -CoxWL * (0.5 * dVgsteff_dVd + 0.25 * dT0_dVd
7440 - 2.0 * T0 * dT0_dVd / T1 + T0 * T0 * dT1_dVd / (T1 * T1));
7441 Csb1 = -CoxWL * (0.5 * dVgsteff_dVb + 0.25 * dT0_dVb
7442 - 2.0 * T0 * dT0_dVb / T1 + T0 * T0 * dT1_dVb / (T1 * T1));
7443 Cse1 = -CoxWL * (0.5 * dVgsteff_dVe + 0.25 * dT0_dVe
7444 - 2.0 * T0 * dT0_dVe / T1 + T0 * T0 * dT1_dVe / (T1 * T1));
7445
7446 /* 8 new lines Wagner */
7447 if (selfheat) {
7448 dTL1_dT = AbulkCV * dVdseffCV_dT + dAbulkCV_dT * VdseffCV;
7449 dTL2_dT = 24 * (dVgsteff_dT - 0.5*dTL1_dT);
7450 dqsrc_dT = -CoxWL*(0.5*dVgsteff_dT + 0.25*dTL1_dT
7451 - 2*T0*dTL1_dT/T1 +
7452 + T0*T0*dTL2_dT/(T1*T1) );
7453 }
7454 else dqsrc_dT = 0;
7455
7456 /* v4.1 */
7457 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
7458 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0)
7459 {
7460 T12 = T12 + T12;
7461 /*fix below expression Wagner */
7462 /*qsrc += -CoxWL2 * (0.5 * Vgsteff2 + 0.25 * T02
7463 - T02 * T02 / T12); */
7464 qsrc2 = -CoxWL2 * (0.5 * Vgsteff2 + 0.25 * T02
7465 - T02 * T02 / T12);
7466 T7 = (4.0 * Vgsteff2 - T02) / (T12 * T12);
7467 T4 = -(0.5 + 24.0 * T02 * T02 / (T12 * T12));
7468 T5 = -(0.25 * AbulkCV - 12.0 * AbulkCV * T02 * T7);
7469 T6 = -(0.25 * VdseffCV2 - 12.0 * T02 * VdseffCV2 * T7);
7470 /* LFW_FD fix next 3 lines with next 12 lines */
7471 /* Csg12 = CoxWL2 * (T4 + T5 * dVdseffCV2_dVg); */
7472 /* Csd12 = CoxWL2 * T5 * dVdseffCV2_dVd; */
7473 /* Csb12 = CoxWL2 * (T5 * dVdseffCV2_dVb + T6 * dAbulkCV_dVb);*/
7474 dT12_dVg = 2.0 * dT12_dVg;
7475 dT12_dVd = 2.0 * dT12_dVd;
7476 dT12_dVb = 2.0 * dT12_dVb;
7477 dT12_dVe = 2.0 * dT12_dVe;
7478
7479 Csg12 = -CoxWL2 * (0.5 * dVgsteff2_dVg + 0.25 * dT02_dVg
7480 - 2.0 * T02 * dT02_dVg / T12 + T02 * T02 * dT12_dVg / (T12 * T12));
7481 Csd12 = -CoxWL2 * (0.5 * dVgsteff2_dVd + 0.25 * dT02_dVd
7482 - 2.0 * T02 * dT02_dVd / T12 + T02 * T02 * dT12_dVd / (T12 * T12));
7483 Csb12 = -CoxWL2 * (0.5 * dVgsteff2_dVb + 0.25 * dT02_dVb
7484 - 2.0 * T02 * dT02_dVb / T12 + T02 * T02 * dT12_dVb / (T12 * T12));
7485 Cse12 = -CoxWL2 * (0.5 * dVgsteff2_dVe + 0.25 * dT02_dVe
7486 - 2.0 * T02 * dT02_dVe / T12 + T02 * T02 * dT12_dVe / (T12 * T12));
7487 /* 11 new lines Wagner */
7488 if (selfheat) {
7489 dTL1_dT = AbulkCV * dVdseffCV2_dT + dAbulkCV_dT * VdseffCV2;
7490 dTL2_dT = 24 * (dVgsteff2_dT - 0.5*dTL1_dT);
7491 dqsrc2_dT = -CoxWL2*(0.5*dVgsteff2_dT + 0.25*dTL1_dT
7492 - 2*T02*dTL1_dT/T12 +
7493 + T02*T02*dTL2_dT/(T12*T12) );
7494 }
7495 else dqsrc2_dT = 0;
7496
7497 qsrc += qsrc2;
7498 dqsrc_dT += dqsrc2_dT;
7499 }
7500 /* end v4.1 */
7501
7502 }
7503 else if (model->B4SOIxpart < 0.5)
7504 { /* 40/60 Charge partition model */
7505 T1 = T1 / 12.0;
7506 T2 = 0.5 * CoxWL / (T1 * T1);
7507 T3 = Vgsteff * (2.0 * T0 * T0 / 3.0 + Vgsteff
7508 * (Vgsteff - 4.0 * T0 / 3.0))
7509 - 2.0 * T0 * T0 * T0 / 15.0;
7510 qsrc = -T2 * T3;
7511
7512 /* LFW_FD add next 28 lines of code */
7513 dT1_dVg = dVgsteff_dVg - 0.5 * dT0_dVg;
7514 dT1_dVd = dVgsteff_dVd - 0.5 * dT0_dVd;
7515 dT1_dVb = dVgsteff_dVb - 0.5 * dT0_dVb;
7516 dT1_dVe = dVgsteff_dVe - 0.5 * dT0_dVe;
7517
7518 dT2_dVg = - 2.0 * T2 * dT1_dVg / T1;
7519 dT2_dVd = - 2.0 * T2 * dT1_dVd / T1;
7520 dT2_dVb = - 2.0 * T2 * dT1_dVb / T1;
7521 dT2_dVe = - 2.0 * T2 * dT1_dVe / T1;
7522
7523 dT3_dVg = dVgsteff_dVg * (2.0 * T0 * T0 / 3.0 + Vgsteff * (Vgsteff - 4.0 * T0 / 3.0))
7524 + Vgsteff * (4.0 * T0 *dT0_dVg /3 + dVgsteff_dVg * (Vgsteff - 4.0 * T0 / 3.0)
7525 + Vgsteff * (dVgsteff_dVg -4.0 * dT0_dVg / 3.0))
7526 - 2.0 * T0 * T0 * dT0_dVg / 5.0;
7527 dT3_dVd = dVgsteff_dVd * (2.0 * T0 * T0 / 3.0 + Vgsteff * (Vgsteff - 4.0 * T0 / 3.0))
7528 + Vgsteff * (4.0 * T0 *dT0_dVd /3 + dVgsteff_dVd * (Vgsteff - 4.0 * T0 / 3.0)
7529 + Vgsteff * (dVgsteff_dVd -4.0 * dT0_dVd / 3.0))
7530 - 2.0 * T0 * T0 * dT0_dVd / 5.0;
7531 dT3_dVb = dVgsteff_dVb * (2.0 * T0 * T0 / 3.0 + Vgsteff * (Vgsteff - 4.0 * T0 / 3.0))
7532 + Vgsteff * (4.0 * T0 *dT0_dVb /3 + dVgsteff_dVb * (Vgsteff - 4.0 * T0 / 3.0)
7533 + Vgsteff * (dVgsteff_dVb -4.0 * dT0_dVb / 3.0))
7534 - 2.0 * T0 * T0 * dT0_dVb / 5.0;
7535 dT3_dVe = dVgsteff_dVe * (2.0 * T0 * T0 / 3.0 + Vgsteff * (Vgsteff - 4.0 * T0 / 3.0))
7536 + Vgsteff * (4.0 * T0 *dT0_dVe /3 + dVgsteff_dVe * (Vgsteff - 4.0 * T0 / 3.0)
7537 + Vgsteff * (dVgsteff_dVe -4.0 * dT0_dVe / 3.0))
7538 - 2.0 * T0 * T0 * dT0_dVe / 5.0;
7539
7540 Csg1 = - T2 * dT3_dVg - dT2_dVg * T3;
7541 Csd1 = - T2 * dT3_dVd - dT2_dVd * T3;
7542 Csb1 = - T2 * dT3_dVb - dT2_dVb * T3;
7543 Cse1 = - T2 * dT3_dVe - dT2_dVe * T3;
7544
7545 /* 13 new lines Wagner */
7546 if (selfheat) {
7547 dTL1_dT = AbulkCV * dVdseffCV_dT + dAbulkCV_dT * VdseffCV;
7548 dTL2_dT = (dVgsteff_dT - 0.5*dTL1_dT);
7549 dTL3_dT = - CoxWL * dTL2_dT / (T1 * T1 * T1);
7550 dTL4_dT = dVgsteff_dT * (2.0 * T0 * T0 / 3.0
7551 + Vgsteff * (Vgsteff - 4.0 * T0 / 3.0) )
7552 + Vgsteff * (4.0 * T0 * dTL1_dT /3.0
7553 + dVgsteff_dT * (Vgsteff - 4.0 * T0 / 3.0)
7554 + Vgsteff * (dVgsteff_dT -4.0 * dTL1_dT / 3.0) )
7555 - 2.0 * T0 * T0 * dTL1_dT / 5.0;
7556 dqsrc_dT = -T2*dTL4_dT - dTL3_dT*T3;
7557 }
7558 else dqsrc_dT = 0;
7559
7560 /* LFW_FD delete next 10 lines of code */
7561 /* T7 = 4.0 / 3.0 * Vgsteff * (Vgsteff - T0) */
7562 /* + 0.4 * T0 * T0; */
7563 /* T4 = -2.0 * qsrc / T1 - T2 * (Vgsteff * (3.0 */
7564 /* * Vgsteff - 8.0 * T0 / 3.0) */
7565 /* + 2.0 * T0 * T0 / 3.0); */
7566 /* T5 = (qsrc / T1 + T2 * T7) * AbulkCV; */
7567 /* T6 = (qsrc / T1 * VdseffCV + T2 * T7 * VdseffCV);*/
7568 /* Csg1 = T4 + T5 * dVdseffCV_dVg; */
7569 /* Csd1 = T5 * dVdseffCV_dVd; */
7570 /* Csb1 = T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb; */
7571 /* v4.1 */
7572 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
7573 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 >0)
7574 {
7575 T12 = T12 /12.0;
7576 T2 = 0.5 * CoxWL2 / (T12 * T12);
7577 T3 = Vgsteff2 * (2.0 * T02 * T02 / 3.0 + Vgsteff2
7578 * (Vgsteff2 - 4.0 * T02 / 3.0))
7579 - 2.0 * T02 * T02 * T02 / 15.0;
7580 qsrc2 = -T2 * T3;
7581
7582 T7 = 4.0 / 3.0 * Vgsteff2 * (Vgsteff2 - T02)
7583 + 0.4 * T02 * T02;
7584 T4 = -2.0 * qsrc2 / T12 - T2 * (Vgsteff2 * (3.0
7585 * Vgsteff2 - 8.0 * T02 / 3.0)
7586 + 2.0 * T02 * T02 / 3.0);
7587 T5 = (qsrc2 / T12 + T2 * T7) * AbulkCV;
7588 T6 = (qsrc2 / T12 * VdseffCV2 + T2 * T7 * VdseffCV2);
7589 /* LFW_FD fix next 3 lines with next 28 lines */
7590 /* Csg12 = T4 + T5 * dVdseffCV2_dVg; */
7591 /* Csd12 = T5 * dVdseffCV2_dVd; */
7592 /* Csb12 = T5 * dVdseffCV2_dVb + T6 * dAbulkCV_dVb;*/
7593
7594 dT12_dVg = dVgsteff2_dVg - 0.5 * dT02_dVg;
7595 dT12_dVd = dVgsteff2_dVd - 0.5 * dT02_dVd;
7596 dT12_dVb = dVgsteff2_dVb - 0.5 * dT02_dVb;
7597 dT12_dVe = dVgsteff2_dVe - 0.5 * dT02_dVe;
7598
7599 dT2_dVg = - 2.0 * T2 * dT12_dVg / T12;
7600 dT2_dVd = - 2.0 * T2 * dT12_dVd / T12;
7601 dT2_dVb = - 2.0 * T2 * dT12_dVb / T12;
7602 dT2_dVe = - 2.0 * T2 * dT12_dVe / T12;
7603
7604 dT3_dVg = dVgsteff2_dVg * (2.0 * T02 * T02 / 3.0 + Vgsteff2 * (Vgsteff2 - 4.0 * T02 / 3.0))
7605 + Vgsteff2 * (4.0 * T02 *dT02_dVg /3 + dVgsteff2_dVg * (Vgsteff2 - 4.0 * T02 / 3.0)
7606 + Vgsteff2 * (dVgsteff2_dVg -4.0 * dT02_dVg / 3.0))
7607 - 2.0 * T02 * T02 * dT02_dVg / 5.0;
7608 dT3_dVd = dVgsteff2_dVd * (2.0 * T02 * T02 / 3.0 + Vgsteff2 * (Vgsteff2 - 4.0 * T02 / 3.0))
7609 + Vgsteff2 * (4.0 * T02 *dT02_dVd /3 + dVgsteff2_dVd * (Vgsteff2 - 4.0 * T02 / 3.0)
7610 + Vgsteff2 * (dVgsteff2_dVd -4.0 * dT02_dVd / 3.0))
7611 - 2.0 * T02 * T02 * dT02_dVd / 5.0;
7612 dT3_dVb = dVgsteff2_dVb * (2.0 * T02 * T02 / 3.0 + Vgsteff2 * (Vgsteff2 - 4.0 * T02 / 3.0))
7613 + Vgsteff2 * (4.0 * T02 *dT02_dVb /3 + dVgsteff2_dVb * (Vgsteff2 - 4.0 * T02 / 3.0)
7614 + Vgsteff2 * (dVgsteff2_dVb -4.0 * dT02_dVb / 3.0))
7615 - 2.0 * T02 * T02 * dT02_dVb / 5.0;
7616 dT3_dVe = dVgsteff2_dVe * (2.0 * T02 * T02 / 3.0 + Vgsteff2 * (Vgsteff2 - 4.0 * T02 / 3.0))
7617 + Vgsteff2 * (4.0 * T02 *dT02_dVe /3 + dVgsteff2_dVe * (Vgsteff2 - 4.0 * T02 / 3.0)
7618 + Vgsteff2 * (dVgsteff2_dVe -4.0 * dT02_dVe / 3.0))
7619 - 2.0 * T02 * T02 * dT02_dVe / 5.0;
7620
7621 Csg12 = - T2 * dT3_dVg - dT2_dVg * T3;
7622 Csd12 = - T2 * dT3_dVd - dT2_dVd * T3;
7623 Csb12 = - T2 * dT3_dVb - dT2_dVb * T3;
7624 Cse12 = - T2 * dT3_dVe - dT2_dVe * T3;
7625
7626 /* 13 new lines Wagner */
7627 if (selfheat) {
7628 dTL1_dT = AbulkCV * dVdseffCV2_dT + dAbulkCV_dT * VdseffCV2;
7629 dTL2_dT = (dVgsteff2_dT - 0.5*dTL1_dT);
7630 dTL3_dT = - CoxWL2 * dTL2_dT / (T12 * T12 * T12);
7631 dTL4_dT = dVgsteff2_dT * (2.0 * T02 * T02 / 3.0
7632 + Vgsteff2 * (Vgsteff2 - 4.0 * T02 / 3.0) )
7633 + Vgsteff2 * (4.0 * T02 * dTL1_dT /3.0
7634 + dVgsteff2_dT * (Vgsteff2 - 4.0 * T02 / 3.0)
7635 + Vgsteff2 * (dVgsteff2_dT -4.0 * dTL1_dT / 3.0) )
7636 - 2.0 * T02 * T02 * dTL1_dT /5.0;
7637 dqsrc2_dT = -T2*dTL4_dT - dTL3_dT*T3;
7638 }
7639 else dqsrc2_dT = 0;
7640
7641 qsrc += qsrc2;
7642 dqsrc_dT += dqsrc2_dT; /* new line Wagner */
7643 }
7644
7645 /* end v4.1 */
7646 }
7647 else
7648 { /* 50/50 Charge partition model */
7649 qsrc = - 0.5 * (qinv + qbulk);
7650 Csg1 = - 0.5 * (Cgg1 + Cbg1);
7651 Csb1 = - 0.5 * (Cgb1 + Cbb1);
7652 Csd1 = - 0.5 * (Cgd1 + Cbd1);
7653 Cse1 = - 0.5 * (Cge1 + Cbe1); /* LFW_FD new line */
7654 /* v4.1 */
7655 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
7656 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 >0)
7657 {
7658 Csg12 = -0.5 * (Cgg12 + Cbg12);
7659 Csb12 = -0.5 * (Cgb12 + Cbb12);
7660 Csd12 = -0.5 * (Cgd12 + Cbd12);
7661 Cse12 = -0.5 * (Cge12 + Cbe12); /* LFW_FD new line */
7662 }
7663 dqsrc_dT = -0.5 * (dqgate_dT + dqbulk_dT); /* new line Wagner */
7664 /* end v4.1 */
7665 }
7666
7667
7668
7669 /* Backgate charge */
7670 /* v3.1 */
7671 if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */
7672 {
7673 Qe1 = dQe1_dVb = dQe1_dVe = Ce1T = dQe1_dT = 0; /* enhanced line Wagner */
7674 }
7675 else /* soiMod = 0 or 1 */
7676 {
7677 CboxWL = pParam->B4SOIkb1 * model->B4SOIfbody * Cbox
7678 * (pParam->B4SOIweffCV / here->B4SOInseg
7679 * here->B4SOInf /* bugfix_snps nf*/
7680 * pParam->B4SOIleffCVbg + here->B4SOIaebcp);
7681 Qe1 = CboxWL * (Vesfb - Vbs);
7682 dQe1_dVb = -CboxWL;
7683 dQe1_dVe = CboxWL;
7684 if (selfheat) Ce1T = dQe1_dT = -CboxWL * dvfbb_dT; /* enhanced line Wagner */
7685 else dQe1_dT = 0;
7686 }
7687 /* v3.1 */
7688
7689
7690 qgate = qinv + Qac0 + Qsub0;
7691 /* LFW_FD commentary only; next 2 lines */
7692 /* Correct definition of qgate below. Not used because it changes CMC defined model.*/
7693 /* qgate = qinv + Qac0 + Qsub0 - qbulk;*/
7694
7695 qbody = (qbulk - Qac0 - Qsub0 - Qe1);
7696 qsub = Qe1;
7697 qdrn = -(qgate + qsrc + qbody + qsub);
7698
7699 /* 4 new lines Wagner */
7700 dqgate_dT = dqgate_dT + dQac0_dT + dQsub0_dT;
7701 dqbody_dT = (dqbulk_dT - dQac0_dT - dQsub0_dT - dQe1_dT);
7702 dqsub_dT = dQe1_dT;
7703 dqdrn_dT = -(dqgate_dT + dqsrc_dT + dqbody_dT + dqsub_dT);
7704
7705 /* This transform all the dependency on Vgsteff, Vbseff
7706 into real ones */
7707 Ce1b = dQe1_dVb;
7708 Ce1e = dQe1_dVe;
7709
7710 /* LFW_FD fix/add next 4 lines */
7711 Csg = Csg1;
7712 Csd = Csd1;
7713 Csb = Csb1;
7714 Cse = Cse1;
7715
7716 /*fix expression below Wagner */
7717 /*if (selfheat) CsT = Csg1 * dVgsteff_dT;*/
7718 if (selfheat) CsT = dqsrc_dT;
7719 else CsT = 0.0;
7720
7721 /* LFW_FD fix/add next 4 lines */
7722 Cgg = Cgg1 + dQsub0_dVg + dQac0_dVg;
7723 Cgd = Cgd1 + dQsub0_dVd + dQac0_dVd;
7724 Cgb = Cgb1 + dQsub0_dVb + dQac0_dVb;
7725 Cge = Cge1 + dQsub0_dVe + dQac0_dVe;
7726
7727 /* LFW_FD commentary only; next 5 lines */
7728 /* Use these with correct definition of qgate above */
7729 /* Cgg = Cgg1 + dQsub0_dVg + dQac0_dVg - Cbg1; */
7730 /* Cgd = Cgd1 + dQsub0_dVd + dQac0_dVd - Cbd1; */
7731 /* Cgb = Cgb1 + dQsub0_dVb + dQac0_dVb - Cbb1; */
7732 /* Cge = Cge1 + dQsub0_dVe + dQac0_dVe - Cbe1; */
7733
7734 if (selfheat)
7735 /*fix expression below Wagner */
7736 /*CgT = (Cgg1 + dQsub0_dVg) * dVgsteff_dT
7737 + dQac0_dT + dQsub0_dT;*/
7738 CgT = dqgate_dT;
7739 else CgT = 0.0;
7740
7741 /* LFW_FD fix/add next 4 lines */
7742 Cbg = Cbg1 - dQac0_dVg - dQsub0_dVg;
7743 Cbd = Cbd1 - dQac0_dVd - dQsub0_dVd;
7744 Cbb = Cbb1 - dQac0_dVb - dQsub0_dVb - Ce1b;
7745 Cbe = Cbe1 - dQac0_dVe - dQsub0_dVe - Ce1e;
7746
7747 if (selfheat)
7748 /*fix expression below Wagner */
7749 /*CbT = (Cbg1 - dQsub0_dVg) * dVgsteff_dT
7750 - dQac0_dT - dQsub0_dT - dQe1_dT;*/
7751 CbT = dqbody_dT;
7752 else CbT = 0.0;
7753 /* v4.1 */
7754 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
7755 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 >0) {
7756 /* LFW_FD fixed next 12 lines */
7757 Csg += Csg12;
7758 Csd += Csd12;
7759 Csb += Csb12;
7760 Cse += Cse12;
7761
7762 Cgg += Cgg12 + dQsub02_dVg + dQac02_dVg;
7763 Cgd += Cgd12 + dQsub02_dVd + dQac02_dVd;
7764 Cgb += Cgb12 + dQsub02_dVb + dQac02_dVb;
7765 Cge += Cge12 + dQsub02_dVe + dQac02_dVe;
7766
7767 Cbg += Cbg12 - dQac02_dVg - dQsub02_dVg;
7768 Cbd += Cbd12 - dQac02_dVd - dQsub02_dVd;
7769 Cbb += Cbb12 - dQac02_dVb - dQsub02_dVb;
7770 Cbe += Cbe12 - dQac02_dVe - dQsub02_dVe;
7771 }
7772 /* end v4.1 */
7773
7774 here->B4SOIcggb = Cgg ;
7775 here->B4SOIcgsb = - (Cgg + Cgd + Cgb + Cge); /* LFW_FD fixed line */
7776 here->B4SOIcgdb = Cgd;
7777 here->B4SOIcgeb = Cge; /* LFW_FD new line */
7778 here->B4SOIcgT = CgT;
7779
7780 here->B4SOIcbgb = Cbg;
7781 here->B4SOIcbsb = -(Cbg + Cbd + Cbb + Cbe); /* LFW_FD fixed line */
7782 here->B4SOIcbdb = Cbd;
7783 here->B4SOIcbeb = Cbe; /* LFW_FD fixed line */
7784 here->B4SOIcbT = CbT;
7785
7786 here->B4SOIceeb = Ce1e ;
7787 here->B4SOIceT = dQe1_dT;
7788
7789 here->B4SOIcdgb = -(Cgg + Cbg + Csg);
7790 here->B4SOIcddb = -(Cgd + Cbd + Csd);
7791 here->B4SOIcdeb = -(Cge + Cse + Cbe) - Ce1e; /* LFW_FD fixed line */
7792 here->B4SOIcdT = -(CgT + CbT + CsT) - dQe1_dT;
7793 here->B4SOIcdsb = Cgg + Cgd + Cgb + Cge /* LFW_FD fixed expression */
7794 + Cbg + Cbd + Cbb + Cbe + Ce1e
7795 + Csg + Csd + Csb + Cse + Ce1b;
7796
7797 } /* End of if capMod == 2 */
7798
7799 else if (model->B4SOIcapMod == 3)
7800 {
7801
7802 /* dVgsteff_dVb /= dVbseff_dVb; LFW_FD comment out line */
7803 if(model->B4SOImtrlMod == 0)
7804 Cox = 3.453133e-11 / model->B4SOItoxp;
7805 else
7806 Cox = epsrox * EPS0 / model->B4SOItoxp;
7807 CoxWL *= toxe/ model->B4SOItoxp;
7808 CoxWLb *= model->B4SOItox/ model->B4SOItoxp;
7809 Tox=1.0e8*model->B4SOItoxp;
7810
7811
7812 /* v4.1 */
7813 if (here->B4SOIagbcp2 > 0) {
7814 /* dVgsteff2_dVb /= dVbseff_dVb; LFW_FD comment out line */
7815 CoxWL2 *= model->B4SOItox /
7816 model->B4SOItoxp;
7817 CoxWLb2 *= model->B4SOItox/
7818 model->B4SOItoxp;
7819 }
7820 /* end v4.1 */
7821
7822 /* v3.1 */
7823 /* LFW_FD flexilint inits next 7 lines */
7824 Vfbzb = pParam->B4SOIvfbzb + pParam->B4SOIdelvt;
7825 dVfbzb_dT = 0.0;
7826 Vfbzb2 = dVfbzb2_dT = 0.0;
7827 Tcen2 = dTcen2_dVg = dTcen2_dVd = dTcen2_dVb = dTcen2_dVe = dTcen2_dT = 0.0;
7828 Coxeff2 = dCoxeff2_dVg = dCoxeff2_dVd = dCoxeff2_dVb = dCoxeff2_dVe = dCoxeff2_dT = 0.0;
7829 CoxWLcenb2= dCoxWLcenb2_dT= 0.0;
7830 dDeltaPhi2_dT = 0.0;
7831 if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */
7832 {
7833 /* LFW_FD enhance next 4 lines */
7834 Qac0 = dQac0_dVg = dQac0_dVb = dQac0_dVd = dQac0_dVe = dQac0_dT = 0.0;
7835 dQac02_dVg = dQac02_dVb = dQac02_dVd = dQac02_dVe = dQac02_dT = 0.0;
7836 Qsub0 = dQsub0_dVg = dQsub0_dVd = dQsub0_dVb = dQsub0_dVe = dQsub0_dT = 0.0;
7837 dQsub02_dVg = dQsub02_dVd = dQsub02_dVb = dQsub02_dVe = dQsub02_dT = 0.0;
7838 Vfbzb = dVfbzb_dT = 0; /* v4.2 bug fix # 20 */
7839 }
7840 else /* soiMod = 0 or 1 */
7841 {
7842 if (selfheat) {
7843 Vfbzb = Vthzb - phi - pParam->B4SOIk1eff * sqrtPhi
7844 + pParam->B4SOIdelvt;
7845 /*fix expression below Wagner */
7846 /*dVfbzb_dT = dVthzb_dT;*/
7847 dVfbzb_dT = dVthzb_dT - dphi_dT - pParam->B4SOIk1eff*dsqrtPhi_dT;
7848 }
7849 else {
7850 Vfbzb = here->B4SOIvfbzb + pParam->B4SOIdelvt;
7851 dVfbzb_dT = 0;
7852 }
7853
7854 V3 = Vfbzb - Vgs_eff + Vbseff - DELTA_3;
7855 if (Vfbzb <= 0.0)
7856 { T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * Vfbzb);
7857 T2 = -DELTA_3 / T0;
7858 /* dTL0_dT = (V3 * dTL3_dT - 2.0 * DELTA_3 * dVfbzb_dT) / T0; LFW_FD delete line */
7859 }
7860 else
7861 { T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * Vfbzb);
7862 T2 = DELTA_3 / T0;
7863 }
7864
7865 T1 = 0.5 * (1.0 + V3 / T0);
7866 Vfbeff = Vfbzb - 0.5 * (V3 + T0);
7867 /* LFW_FD fix/add next 4 lines */
7868 dVfbeff_dVg = T1 * (dVgs_eff_dVg - dVbseff_dVg);
7869 dVfbeff_dVd = T1 * ( - dVbseff_dVd);
7870 dVfbeff_dVb = T1 * ( - dVbseff_dVb);
7871 dVfbeff_dVe = T1 * ( - dVbseff_dVe);
7872 /*fix expression below Wagner */
7873 /*if (selfheat) dVfbeff_dT = (1.0 - T1 - T2) * dVfbzb_dT;
7874 - T1*dVbseff_dT; */
7875 if (selfheat) dVfbeff_dT = (1.0 - T1 - T2) * dVfbzb_dT
7876 + T1*(dVgs_eff_dT - dVbseff_dT);
7877 else dVfbeff_dT = 0.0;
7878 /* v4.1 */
7879 if (here->B4SOIagbcp2 >0) {
7880 /* Vfbzb2 = Vfbzb + 1.12; */
7881 Vfbzb2 = Vfbzb + eggbcp2; /* bugfix v4.3.1 -Tanvir */
7882 if (selfheat) dVfbzb2_dT = dVfbzb_dT;
7883 else dVfbzb2_dT = 0;
7884 V3 = Vfbzb2 - Vgs_eff2 + Vbseff - DELTA_3;
7885 if (Vfbzb2 <= 0.0) /* Bug fix #12 Jun 09 Vfbzb changed to Vfbzb2 */
7886 { T0 = sqrt(V3 * V3 - 100.0 * DELTA_3 * Vfbzb2); /* Value of 100 instead of 4 is used to make transition smooth*/
7887 T2 = -25.0 * DELTA_3 / T0; /* p+/p has same smoothness as n+/p with 100, 4 makes it too steep*/
7888 }
7889 else
7890 { T0 = sqrt(V3 * V3 + 100.0 * DELTA_3 * Vfbzb2);
7891 T2 = 25.0 * DELTA_3 / T0;
7892 }
7893 T1 = 0.5 * (1.0 + V3 / T0);
7894 Vfbeff2 = Vfbzb2 - 0.5 * (V3 + T0);
7895 /* LFW_FD fix/add next 4 lines */
7896 dVfbeff2_dVg = T1 * (dVgs_eff2_dVg - dVbseff_dVg);
7897 dVfbeff2_dVd = T1 * ( - dVbseff_dVd);
7898 dVfbeff2_dVb = T1 * ( - dVbseff_dVb);
7899 dVfbeff2_dVe = T1 * ( - dVbseff_dVe);
7900 /*fix expression below Wagner */
7901 /*if (selfheat) dVfbeff2_dT = (1.0 - T1 - T2) * dVfbzb2_dT;*/
7902 if (selfheat) dVfbeff2_dT = (1.0 - T1 - T2) * dVfbzb2_dT
7903 - T1*dVbseff_dT;
7904 else dVfbeff2_dT = 0.0;
7905 }
7906 /* end v4.1 */
7907
7908 T0 = (Vgs_eff - Vbseff - Vfbzb) / Tox;
7909 /* LFW_FD fix/add next 4 lines */
7910 dT0_dVg = (dVgs_eff_dVg - dVbseff_dVg) /Tox;
7911 dT0_dVd = - dVbseff_dVd /Tox;
7912 dT0_dVb = - dVbseff_dVb /Tox;
7913 dT0_dVe = - dVbseff_dVe /Tox;
7914
7915 tmp = T0 * pParam->B4SOIacde;
7916 if ((-EXPL_THRESHOLD < tmp) && (tmp < EXPL_THRESHOLD))
7917 { Tcen = pParam->B4SOIldeb * exp(tmp);
7918 /* LFW_FD fix/add next 5 lines */
7919 TL1 = pParam->B4SOIacde * Tcen;
7920 dTcen_dVg = TL1 * dT0_dVg;
7921 dTcen_dVd = TL1 * dT0_dVd;
7922 dTcen_dVb = TL1 * dT0_dVb;
7923 dTcen_dVe = TL1 * dT0_dVe;
7924 if (selfheat)
7925 /* fix below expression Wagner */
7926 /*dTcen_dT = -Tcen * pParam->B4SOIacde * dVfbzb_dT / Tox; */
7927 dTcen_dT = Tcen * pParam->B4SOIacde * (dVgs_eff_dT-dVbseff_dT-dVfbzb_dT) / Tox;
7928 else dTcen_dT = 0;
7929 }
7930 else if (tmp <= -EXPL_THRESHOLD)
7931 { Tcen = pParam->B4SOIldeb * MIN_EXPL;
7932 dTcen_dVg = dTcen_dVb = dTcen_dVd = dTcen_dVe = dTcen_dT = 0.0; /* LFW_FD enhance line */
7933 }
7934 else
7935 { Tcen = pParam->B4SOIldeb * MAX_EXPL;
7936 dTcen_dVg = dTcen_dVb = dTcen_dVd = dTcen_dVe = dTcen_dT = 0.0; /* LFW_FD enhance line */
7937 }
7938
7939 /*LINK = 1.0e-3 * (toxe - model->B4SOIdtoxcv); v2.2.3 */
7940 LINK = 1.0e-3 * model->B4SOItoxp;
7941 V3 = pParam->B4SOIldeb - Tcen - LINK;
7942 V4 = sqrt(V3 * V3 + 4.0 * LINK * pParam->B4SOIldeb);
7943 Tcen = pParam->B4SOIldeb - 0.5 * (V3 + V4);
7944 T1 = 0.5 * (1.0 + V3 / V4);
7945 /* v4.1 small Tcen can introduce numerical issue */
7946 if (Tcen < 1e-15)
7947 { Tcen = 1e-15;
7948 T1 = 0;
7949 } /* end */
7950
7951 dTcen_dVg *= T1;
7952 dTcen_dVb *= T1;
7953 dTcen_dVd *= T1; /* LFW_FD new line */
7954 dTcen_dVe *= T1; /* LFW_FD new line */
7955 if (selfheat)
7956 dTcen_dT *= T1;
7957 else dTcen_dT = 0;
7958 /* v4.1 */
7959 if (here->B4SOIagbcp2 > 0) {
7960 T0 = (Vgs_eff2 - Vbseff - Vfbzb2) / Tox;
7961 /* LFW_FD fix/add next 4 lines */
7962 dT0_dVg = (dVgs_eff2_dVg - dVbseff_dVg) / Tox;
7963 dT0_dVd = -dVbseff_dVd / Tox;
7964 dT0_dVb = -dVbseff_dVb / Tox;
7965 dT0_dVe = -dVbseff_dVe / Tox;
7966
7967 tmp = T0 * pParam->B4SOIacde;
7968 if ((-EXPL_THRESHOLD < tmp) && (tmp < EXPL_THRESHOLD))
7969 { Tcen2 = pParam->B4SOIldeb * exp(tmp);
7970 /* LFW_FD fix/add next 4 lines */
7971 dTcen2_dVg = pParam->B4SOIacde * Tcen2 * dT0_dVg;
7972 dTcen2_dVd = pParam->B4SOIacde * Tcen2 * dT0_dVd;
7973 dTcen2_dVb = pParam->B4SOIacde * Tcen2 * dT0_dVb;
7974 dTcen2_dVe = pParam->B4SOIacde * Tcen2 * dT0_dVe;
7975 if (selfheat)
7976 dTcen2_dT = -Tcen2 * pParam->B4SOIacde * dVfbzb2_dT / Tox;
7977 else dTcen2_dT = 0;
7978 }
7979 else if (tmp <= -EXPL_THRESHOLD)
7980 { Tcen2 = pParam->B4SOIldeb * MIN_EXPL;
7981 dTcen2_dVg = dTcen2_dVd = dTcen2_dVb = dTcen2_dVe = dTcen2_dT = 0.0; /* LFW_FD enhance line */
7982 }
7983 else
7984 { Tcen2 = pParam->B4SOIldeb * MAX_EXPL;
7985 dTcen2_dVg = dTcen2_dVd = dTcen2_dVb = dTcen2_dVe = dTcen2_dT = 0.0; /* LFW_FD enhance line */
7986 }
7987
7988 V3 = pParam->B4SOIldeb - Tcen2 - LINK;
7989 V4 = sqrt(V3 * V3 + 4.0 * LINK * pParam->B4SOIldeb);
7990 Tcen2 = pParam->B4SOIldeb - 0.5 * (V3 + V4);
7991 T1 = 0.5 * (1.0 + V3 / V4);
7992
7993 if (Tcen2 < 1e-15)
7994 { Tcen2 = 1e-15;
7995 T1 = 0;
7996 }
7997 dTcen2_dVg *= T1;
7998 dTcen2_dVb *= T1;
7999 dTcen2_dVd *= T1; /* LFW_FD new line */
8000 dTcen2_dVe *= T1; /* LFW_FD new line */
8001 if (selfheat)
8002 dTcen2_dT *= T1;
8003 else dTcen2_dT = 0;
8004 }
8005 /* end v4.1 */
8006
8007 Ccen = epssub / Tcen;
8008 T2 = Cox / (Cox + Ccen);
8009 Coxeff = T2 * Ccen;
8010 T3 = -Ccen / Tcen;
8011 /* LFW_FD fix/add next 5 lines */
8012 TL1 = T2 * T2 * T3;
8013 dCoxeff_dVg = TL1 * dTcen_dVg;
8014 dCoxeff_dVd = TL1 * dTcen_dVd;
8015 dCoxeff_dVb = TL1 * dTcen_dVb;
8016 dCoxeff_dVe = TL1 * dTcen_dVe;
8017 if (selfheat)
8018 /*fix expression below Wagner */
8019 /*dCoxeff_dT = T3 * dTcen_dT * (T2 - Coxeff / (Cox + Ccen));*/
8020 dCoxeff_dT = - Coxeff * T2 * dTcen_dT / Tcen;
8021 else dCoxeff_dT = 0;
8022 /* v4.1 */
8023 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
8024 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0) {
8025 /* Ccen2 = EPSSI / Tcen2; */ /* Bug Fix # 30 Jul09 EPSSI changed to epssub */
8026 Ccen2 = epssub / Tcen2;
8027 T2 = Cox / (Cox + Ccen2);
8028 Coxeff2 = T2 * Ccen2;
8029 T3 = -Ccen2 / Tcen2;
8030 /* LFW_FD fix/add next 5 lines */
8031 TL1 = T2 * T2 * T3;
8032 dCoxeff2_dVg = TL1 * dTcen2_dVg;
8033 dCoxeff2_dVd = TL1 * dTcen2_dVd;
8034 dCoxeff2_dVb = TL1 * dTcen2_dVb;
8035 dCoxeff2_dVe = TL1 * dTcen2_dVe;
8036 if (selfheat)
8037 /*fix expression below Wagner */
8038 /*dCoxeff2_dT = T3 * dTcen2_dT * (T2 - Coxeff2 / (Cox + Ccen2));*/
8039 dCoxeff2_dT = - Coxeff2 * T2 * dTcen2_dT / Tcen2;
8040 else dCoxeff2_dT = 0;
8041 }
8042 /* end v4.1 */
8043 CoxWLcenb = CoxWLb * Coxeff / Cox;
8044 if (selfheat)
8045 dCoxWLcenb_dT = CoxWLb * dCoxeff_dT / Cox;
8046 else dCoxWLcenb_dT = 0;
8047 /* v4.1 */
8048 if (here->B4SOIagbcp2 > 0) {
8049 CoxWLcenb2 = CoxWLb2 * Coxeff2 / Cox;
8050 if (selfheat)
8051 dCoxWLcenb2_dT = CoxWLb2 * dCoxeff2_dT / Cox;
8052 else dCoxWLcenb2_dT = 0;
8053 }
8054 /* end v4.1 */
8055 Qac0 = CoxWLcenb * (Vfbeff - Vfbzb);
8056 QovCox = Qac0 / Coxeff;
8057 /* LFW_FD fix/add next 4 lines */
8058 dQac0_dVg = CoxWLcenb * dVfbeff_dVg + QovCox * dCoxeff_dVg;
8059 dQac0_dVb = CoxWLcenb * dVfbeff_dVb + QovCox * dCoxeff_dVb;
8060 dQac0_dVd = CoxWLcenb * dVfbeff_dVd + QovCox * dCoxeff_dVd;
8061 dQac0_dVe = CoxWLcenb * dVfbeff_dVe + QovCox * dCoxeff_dVe;
8062 if (selfheat) dQac0_dT = CoxWLcenb * (dVfbeff_dT - dVfbzb_dT)
8063 + dCoxWLcenb_dT * (Vfbeff - Vfbzb);
8064 else dQac0_dT = 0.0;
8065 /* v4.1 */
8066 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
8067 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0) {
8068 Qac02 = CoxWLcenb2 * (Vfbeff2 - Vfbzb2);
8069 QovCox2 = Qac02 / Coxeff2;
8070 /* LFW_FD fix/add next 4 lines */
8071 dQac02_dVg = CoxWLcenb2 * dVfbeff2_dVg + QovCox2 * dCoxeff2_dVg;
8072 dQac02_dVd = CoxWLcenb2 * dVfbeff2_dVd + QovCox2 * dCoxeff2_dVd;
8073 dQac02_dVb = CoxWLcenb2 * dVfbeff2_dVb + QovCox2 * dCoxeff2_dVb;
8074 dQac02_dVe = CoxWLcenb2 * dVfbeff2_dVe + QovCox2 * dCoxeff2_dVe;
8075 if (selfheat) dQac02_dT = CoxWLcenb2 * (dVfbeff2_dT - dVfbzb2_dT)
8076 + dCoxWLcenb2_dT * (Vfbeff2 - Vfbzb2);
8077 else dQac02_dT = 0.0;
8078
8079 Qac0 += Qac02;
8080 dQac0_dT += dQac02_dT; /* new line Wagner */
8081 }
8082 /* end v4.1 */
8083
8084 T0 = 0.5 * pParam->B4SOIk1ox;
8085 T3 = Vgs_eff - Vfbeff - Vbseff - Vgsteff;
8086 if (pParam->B4SOIk1ox == 0.0)
8087 { T1 = 0.0;
8088 T2 = 0.0;
8089 }
8090 else if (T3 < 0.0)
8091 { T1 = T0 + T3 / pParam->B4SOIk1ox;
8092 T2 = CoxWLcenb;
8093 }
8094 else
8095 { T1 = sqrt(T0 * T0 + T3);
8096 T2 = CoxWLcenb * T0 / T1;
8097 }
8098
8099 Qsub0 = CoxWLcenb * pParam->B4SOIk1ox * (T1 - T0);
8100 QovCox = Qsub0 / Coxeff;
8101 /* LFW_FD fix/add next 4 lines */
8102 dQsub0_dVg = T2 * (dVgs_eff_dVg - dVfbeff_dVg - dVbseff_dVg - dVgsteff_dVg) + QovCox * dCoxeff_dVg;
8103 dQsub0_dVd = -T2 * (dVfbeff_dVd + dVbseff_dVd + dVgsteff_dVd) + QovCox * dCoxeff_dVd;
8104 dQsub0_dVb = -T2 * (dVfbeff_dVb + dVbseff_dVb + dVgsteff_dVb) + QovCox * dCoxeff_dVb;
8105 dQsub0_dVe = -T2 * (dVfbeff_dVe + dVbseff_dVe + dVgsteff_dVe) + QovCox * dCoxeff_dVe;
8106
8107 if (selfheat)
8108 /*fix 1st line of expression below Wagner */
8109 /*dQsub0_dT = -T2 * (dVfbeff_dT + dVgsteff_dT)*/
8110 dQsub0_dT = T2 * (dVgs_eff_dT - dVfbeff_dT - dVbseff_dT - dVgsteff_dT)
8111 + dCoxWLcenb_dT * pParam->B4SOIk1ox * (T1 - T0);
8112 else dQsub0_dT = 0.0;
8113
8114 /* v4.1 */
8115 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
8116 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0) {
8117 T3 = Vgs_eff2 - Vfbeff2 - Vbseff - Vgsteff2;
8118 if (pParam->B4SOIk1ox == 0.0)
8119 { T1 = 0.0;
8120 T2 = 0.0;
8121 }
8122 else if (T3 < 0.0)
8123 { T1 = T0 + T3 / pParam->B4SOIk1ox;
8124 T2 = CoxWLcenb2;
8125 }
8126 else
8127 { T1 = sqrt(T0 * T0 + T3);
8128 T2 = CoxWLcenb2 * T0 / T1;
8129 }
8130
8131 Qsub02 = CoxWLcenb2 * pParam->B4SOIk1ox * (T1 - T0);
8132 QovCox2 = Qsub02 / Coxeff2;
8133 /* LFW_FD fix/add next 4 lines */
8134 dQsub02_dVg = T2 * (dVgs_eff2_dVg - dVfbeff2_dVg - dVbseff_dVg - dVgsteff2_dVg) + QovCox2 * dCoxeff2_dVg;
8135 dQsub02_dVd = -T2 * (dVfbeff2_dVd + dVbseff_dVd + dVgsteff2_dVd) + QovCox2 * dCoxeff2_dVd;
8136 dQsub02_dVb = -T2 * (dVfbeff2_dVb + dVbseff_dVb + dVgsteff2_dVb) + QovCox2 * dCoxeff2_dVb;
8137 dQsub02_dVe = -T2 * (dVfbeff2_dVe + dVbseff_dVe + dVgsteff2_dVe) + QovCox2 * dCoxeff2_dVe;
8138
8139 if (selfheat)
8140 dQsub02_dT = -T2 * (dVfbeff2_dT + dVgsteff2_dT)
8141 + dCoxWLcenb2_dT * pParam->B4SOIk1ox * (T1 - T0);
8142 else dQsub02_dT = 0.0;
8143
8144 Qsub0 += Qsub02;
8145 dQsub0_dT += dQsub02_dT; /* new line Wagner */
8146 }
8147 /* end v4.1 */
8148
8149 }
8150 /* v3.1 */
8151
8152
8153 /* Gate-bias dependent delta Phis begins */
8154 if (pParam->B4SOIk1ox <= 0.0)
8155 { Denomi = 0.25 * pParam->B4SOImoin * Vtm;
8156 T0 = 0.5 * pParam->B4SOIsqrtPhi;
8157 }
8158 else
8159 { Denomi = pParam->B4SOImoin * Vtm
8160 * pParam->B4SOIk1ox * pParam->B4SOIk1ox;
8161 T0 = pParam->B4SOIk1ox * pParam->B4SOIsqrtPhi;
8162 }
8163 T1 = 2.0 * T0 + Vgsteff;
8164
8165 DeltaPhi = Vtm * log(1.0 + T1 * Vgsteff / Denomi);
8166 /* LFW_FD fix/add next 5 lines */
8167 dDeltaPhi_dVg = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff) * dVgsteff_dVg;
8168 dDeltaPhi_dVd = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff) * dVgsteff_dVd;
8169 dDeltaPhi_dVb = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff) * dVgsteff_dVb;
8170 dDeltaPhi_dVe = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff) * dVgsteff_dVe;
8171
8172 DeltaPhi2 = dDeltaPhi2_dVg = dDeltaPhi2_dVd = dDeltaPhi2_dVb = dDeltaPhi2_dVe = 0.0; /* flexilint */
8173
8174 /* 7 new lines Wagner */
8175 if (selfheat) {
8176 TL1 = 1.0 + T1 * Vgsteff / Denomi;
8177 dTL1_dT = (2*(T0+Vgsteff)*dVgsteff_dT/Denomi)
8178 - (T1 * Vgsteff / (Denomi*Vtm))*dVtm_dT;
8179 dDeltaPhi_dT = dVtm_dT * log(TL1) + (Vtm/TL1)*dTL1_dT;
8180 }
8181 else dDeltaPhi_dT = 0.0;
8182
8183 /* v4.1 */
8184 if (here->B4SOIagbcp2 > 0) {
8185 T1 = 2.0 * T0 + Vgsteff2;
8186 DeltaPhi2 = Vtm * log(1.0 + T1 * Vgsteff2 / Denomi);
8187 /* LFW_FD fix/add next 4 lines */
8188 dDeltaPhi2_dVg = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff2) * dVgsteff2_dVg;
8189 dDeltaPhi2_dVd = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff2) * dVgsteff2_dVd;
8190 dDeltaPhi2_dVb = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff2) * dVgsteff2_dVb;
8191 dDeltaPhi2_dVe = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff2) * dVgsteff2_dVe;
8192
8193 /* 7 new lines Wagner */
8194 if (selfheat) {
8195 TL1 = 1.0 + T1 * Vgsteff2 / Denomi;
8196 dTL1_dT = (2*(T0+Vgsteff2)*dVgsteff2_dT/Denomi)
8197 - (T1 * Vgsteff2 / (Denomi*Vtm))*dVtm_dT;
8198 dDeltaPhi2_dT = dVtm_dT * log(TL1) + (Vtm/TL1)*dTL1_dT;
8199 }
8200 else dDeltaPhi2_dT = 0.0;
8201 }
8202 /* end v4.1 */
8203 /* End of delta Phis */
8204
8205
8206 /* v3.1.1 bug fix for discontinuity */
8207 T3 = 4.0 * (Vth - Vfbzb - phi);
8208 T2 = sqrt(T3*T3 + 0.0001);
8209 T5 = 0.5 * (1 + T3/T2);
8210 T4 = 0.5 * (T3 + T2);
8211
8212 Tox += Tox;
8213 T0 = (Vgsteff + T4) / Tox;
8214 tmp = exp(0.7 * log(T0));
8215 T1 = 1.0 + tmp;
8216 T2 = 0.7 * tmp / (T0 * Tox);
8217 Tcen = 1.9e-9 / T1;
8218 /* LFW_FD fix/add next 5 lines */
8219 TL1 = dTcen_dVg = -Tcen * T2 / T1;
8220 dTcen_dVg = TL1 * (T5 * 4.0 * dVth_dVg + dVgsteff_dVg);
8221 dTcen_dVd = TL1 * (T5 * 4.0 * dVth_dVd + dVgsteff_dVd);
8222 dTcen_dVb = TL1 * (T5 * 4.0 * dVth_dVb + dVgsteff_dVb);
8223 dTcen_dVe = TL1 * (T5 * 4.0 * dVth_dVe + dVgsteff_dVe);
8224
8225 if (selfheat)
8226 /*fix below expression Wagner */
8227 /*dTcen_dT = -Tcen * T2 / T1
8228 * (T5 * 4.0 * (dVth_dT - dVfbzb_dT) + dVgsteff_dT);*/
8229 dTcen_dT = -Tcen * T2 / T1
8230 * (T5 * 4.0 * (dVth_dT - dVfbzb_dT - dphi_dT) + dVgsteff_dT);
8231 else dTcen_dT = 0;
8232
8233
8234 Ccen = epssub / Tcen;
8235 T0 = Cox / (Cox + Ccen);
8236 Coxeff = T0 * Ccen;
8237 T1 = -Ccen / Tcen;
8238 /* LFW_FD fix/add next 5 lines */
8239 TL1 = dCoxeff_dVg = T0 * T0 * T1;
8240 dCoxeff_dVg = TL1 * dTcen_dVg;
8241 dCoxeff_dVd = TL1 * dTcen_dVd;
8242 dCoxeff_dVb = TL1 * dTcen_dVb;
8243 dCoxeff_dVe = TL1 * dTcen_dVe;
8244
8245 if (selfheat)
8246 /*dCoxeff_dT = T1 * dTcen_dT * (T0 - Coxeff / (Cox + Ccen));*/
8247 dCoxeff_dT = TL1 * dTcen_dT; /* LFW_FD fix line */
8248 else dCoxeff_dT = 0;
8249 CoxWLcen = CoxWL * Coxeff / Cox;
8250 CoxWLcenb = CoxWLb * Coxeff / Cox;
8251 /* 3 new lines Wagner*/
8252 if (selfheat)
8253 dCoxWLcenb_dT = CoxWLb * dCoxeff_dT / Cox;
8254 else dCoxWLcenb_dT = 0;
8255 /* v4.1 */
8256 CoxWLcen2 = 0.0; /* flexilint */
8257 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
8258 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0) {
8259 /* T3 = 4.0 * (Vth + 1.12 - Vfbzb2 - phi); */
8260 T3 = 4.0 * (Vth + eggbcp2 - Vfbzb2 - phi); /* bugfix v4.3.1 -Tanvir */
8261 T2 = sqrt(T3*T3 + 0.0001);
8262 T5 = 0.5 * (1 + T3/T2);
8263 T4 = 0.5 * (T3 + T2);
8264 /* Tox += Tox; */
8265 T0 = (Vgsteff2 + T4) / Tox;
8266 tmp = exp(0.7 * log(T0));
8267 T1 = 1.0 + tmp;
8268 T2 = 0.7 * tmp / (T0 * Tox);
8269 Tcen2 = 1.9e-9 / T1;
8270 /* LFW_FD fix/add next 5 lines */
8271 TL1 = dTcen2_dVg = -Tcen2 * T2 / T1;
8272 dTcen2_dVg = TL1 * (T5 * 4.0 * dVth_dVg + dVgsteff2_dVg);
8273 dTcen2_dVd = TL1 * (T5 * 4.0 * dVth_dVd + dVgsteff2_dVd);
8274 dTcen2_dVb = TL1 * (T5 * 4.0 * dVth_dVb + dVgsteff2_dVb);
8275 dTcen2_dVe = TL1 * (T5 * 4.0 * dVth_dVe + dVgsteff2_dVe);
8276
8277 if (selfheat)
8278 /*fix below expression Wagner */
8279 /*dTcen2_dT = -Tcen2 * T2 / T1
8280 * (T5 * 4.0 * (dVth_dT - dVfbzb2_dT) + dVgsteff2_dT); */
8281 dTcen2_dT = -Tcen2 * T2 / T1
8282 * (T5 * 4.0 * (dVth_dT - dVfbzb2_dT - dphi_dT) + dVgsteff2_dT);
8283 else dTcen2_dT = 0;
8284 /*Ccen2 = EPSSI / Tcen2;*//*Bug Fix # 30 Jul09*/
8285 Ccen2 = epssub/ Tcen2;
8286 T0 = Cox / (Cox + Ccen2);
8287 Coxeff2 = T0 * Ccen2;
8288 T1 = -Ccen2 / Tcen2;
8289 /* LFW_FD fix/add next 5 lines */
8290 TL1 = dCoxeff2_dVg = T0 * T0 * T1;
8291 dCoxeff2_dVg = TL1 * dTcen2_dVg;
8292 dCoxeff2_dVd = TL1 * dTcen2_dVd;
8293 dCoxeff2_dVb = TL1 * dTcen2_dVb;
8294 dCoxeff2_dVe = TL1 * dTcen2_dVe;
8295
8296 if (selfheat)
8297 dCoxeff2_dT = T1 * dTcen2_dT * (T0 - Coxeff2 / (Cox + Ccen2));
8298 else dCoxeff2_dT = 0;
8299 CoxWLcen2 = CoxWL2 * Coxeff2 / Cox;
8300 CoxWLcenb2 = CoxWLb2 * Coxeff2 / Cox;
8301 /* 3 new lines Wagner */
8302 if (selfheat)
8303 dCoxWLcenb2_dT = CoxWLb2 * dCoxeff2_dT / Cox;
8304 else dCoxWLcenb2_dT = 0;
8305 }
8306 /* end v4.1 */
8307
8308 AbulkCV = Abulk0 * pParam->B4SOIabulkCVfactor;
8309 /* LFW_FD fix/add next 4 lines */
8310 dAbulkCV_dVg = pParam->B4SOIabulkCVfactor * dAbulk0_dVg;
8311 dAbulkCV_dVb = pParam->B4SOIabulkCVfactor * dAbulk0_dVb;
8312 dAbulkCV_dVd = pParam->B4SOIabulkCVfactor * dAbulk0_dVd;
8313 dAbulkCV_dVe = pParam->B4SOIabulkCVfactor * dAbulk0_dVe;
8314 /* 3 new lines Wagner */
8315 if (selfheat)
8316 dAbulkCV_dT = dAbulk0_dT * pParam->B4SOIabulkCVfactor;
8317 else dAbulkCV_dT = 0;
8318
8319 VdsatCV = (Vgsteff - DeltaPhi) / AbulkCV;
8320 /* LFW_FD add next 4 lines */
8321 dVdsatCV_dVg = (dVgsteff_dVg - dDeltaPhi_dVg - VdsatCV * dAbulkCV_dVg) / AbulkCV;
8322 dVdsatCV_dVd = (dVgsteff_dVd - dDeltaPhi_dVd - VdsatCV * dAbulkCV_dVd) / AbulkCV;
8323 dVdsatCV_dVb = (dVgsteff_dVb - dDeltaPhi_dVb - VdsatCV * dAbulkCV_dVb) / AbulkCV;
8324 dVdsatCV_dVe = (dVgsteff_dVe - dDeltaPhi_dVe - VdsatCV * dAbulkCV_dVe) / AbulkCV;
8325
8326 V4 = VdsatCV - Vds - DELTA_4;
8327 T0 = sqrt(V4 * V4 + 4.0 * DELTA_4 * VdsatCV);
8328 VdseffCV = VdsatCV - 0.5 * (V4 + T0);
8329 T1 = 0.5 * (1.0 + V4 / T0);
8330 T2 = DELTA_4 / T0;
8331 T3 = (1.0 - T1 - T2) / AbulkCV;
8332 T4 = T3 * ( 1.0 - dDeltaPhi_dVg);
8333 /* LFW_FD fix/add next 4 lines */
8334 dVdseffCV_dVg = (1.0 - T1 - T2) * dVdsatCV_dVg;
8335 dVdseffCV_dVd = (1.0 - T1 - T2) * dVdsatCV_dVd + T1;
8336 dVdseffCV_dVb = (1.0 - T1 - T2) * dVdsatCV_dVb;
8337 dVdseffCV_dVe = (1.0 - T1 - T2) * dVdsatCV_dVe;
8338 /* 10 new lines Wagner */
8339 if (selfheat) {
8340 dVdsatCV_dT = (dVgsteff_dT-dDeltaPhi_dT)/AbulkCV
8341 -VdsatCV*dAbulkCV_dT/AbulkCV;
8342 dTL1_dT = (V4 + 2.0 * DELTA_4) * dVdsatCV_dT / T0;
8343 dVdseffCV_dT = 0.5*dVdsatCV_dT - 0.5*dTL1_dT;
8344 }
8345 else {
8346 dVdsatCV_dT = 0;
8347 dVdseffCV_dT = 0;
8348 }
8349
8350 T0 = AbulkCV * VdseffCV;
8351 T1 = Vgsteff - DeltaPhi;
8352 T2 = 12.0 * (T1 - 0.5 * T0 + 1.0e-20);
8353 T3 = T0 / T2;
8354 T4 = 1.0 - 12.0 * T3 * T3;
8355 T5 = AbulkCV * (6.0 * T0 * (4.0 * T1 - T0) / (T2 * T2) - 0.5);
8356 T6 = T5 * VdseffCV / AbulkCV;
8357
8358 /* LFW_FD add next 16 lines */
8359 dT0_dVg = dAbulkCV_dVg * VdseffCV + AbulkCV * dVdseffCV_dVg;
8360 dT0_dVd = dAbulkCV_dVd * VdseffCV + AbulkCV * dVdseffCV_dVd;
8361 dT0_dVb = dAbulkCV_dVb * VdseffCV + AbulkCV * dVdseffCV_dVb;
8362 dT0_dVe = dAbulkCV_dVe * VdseffCV + AbulkCV * dVdseffCV_dVe;
8363
8364 dT1_dVg = dVgsteff_dVg - dDeltaPhi_dVg;
8365 dT1_dVd = dVgsteff_dVd - dDeltaPhi_dVd;
8366 dT1_dVb = dVgsteff_dVb - dDeltaPhi_dVb;
8367 dT1_dVe = dVgsteff_dVe - dDeltaPhi_dVe;
8368
8369 dT2_dVg = 12.0 * (dT1_dVg - 0.5 * dT0_dVg);
8370 dT2_dVd = 12.0 * (dT1_dVd - 0.5 * dT0_dVd);
8371 dT2_dVb = 12.0 * (dT1_dVb - 0.5 * dT0_dVb);
8372 dT2_dVe = 12.0 * (dT1_dVe - 0.5 * dT0_dVe);
8373
8374 dT3_dVg = (dT0_dVg - T3 * dT2_dVg) / T2;
8375 dT3_dVd = (dT0_dVd - T3 * dT2_dVd) / T2;
8376 dT3_dVb = (dT0_dVb - T3 * dT2_dVb) / T2;
8377 dT3_dVe = (dT0_dVe - T3 * dT2_dVe) / T2;
8378
8379 qgate1 = qinv = qgate = qinoi = CoxWLcen * (T1 - T0 * (0.5 - T3)); /* enhanced line Wagner */
8380 QovCox = qgate / Coxeff;
8381 /* LFW_FD fix/add next 4 lines */
8382 Cgg1 = CoxWLcen * (dT1_dVg - dT0_dVg * (0.5 - T3) + T0 * dT3_dVg) + QovCox * dCoxeff_dVg;
8383 Cgd1 = CoxWLcen * (dT1_dVd - dT0_dVd * (0.5 - T3) + T0 * dT3_dVd) + QovCox * dCoxeff_dVd;
8384 Cgb1 = CoxWLcen * (dT1_dVb - dT0_dVb * (0.5 - T3) + T0 * dT3_dVb) + QovCox * dCoxeff_dVb;
8385 Cge1 = CoxWLcen * (dT1_dVe - dT0_dVe * (0.5 - T3) + T0 * dT3_dVe) + QovCox * dCoxeff_dVe;
8386 /* 10 new lines Wagner */
8387 if (selfheat) {
8388 dTL1_dT = AbulkCV * dVdseffCV_dT + dAbulkCV_dT * VdseffCV;
8389 dTL2_dT = 12 * (dVgsteff_dT - dDeltaPhi_dT - 0.5*dTL1_dT);
8390 dTL3_dT = dTL1_dT/T2 - (T3/T2)*dTL2_dT;
8391 dqgate_dT = (qgate * dCoxeff_dT / Coxeff)
8392 + CoxWLcen * (dVgsteff_dT - dDeltaPhi_dT
8393 - dTL1_dT*(0.5-T3)
8394 + T0*dTL3_dT);
8395 }
8396 else dqgate_dT = 0;
8397
8398 /* LFW_FD 2 new lines per flexilint */
8399 T02 = T12 = T22 = T52 = 0.0; /* flexilint */
8400 Cgg12 = Cgd12 = Cgb12 = Cge12 = 0.0;
8401 /* v4.1 */
8402 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
8403 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0) {
8404 VdsatCV2 = (Vgsteff2 - DeltaPhi2) / AbulkCV;
8405 /* LFW_FD add next 4 lines */
8406 dVdsatCV2_dVg = (dVgsteff2_dVg - dDeltaPhi2_dVg - VdsatCV2 * dAbulkCV_dVg) / AbulkCV;
8407 dVdsatCV2_dVd = (dVgsteff2_dVd - dDeltaPhi2_dVd - VdsatCV2 * dAbulkCV_dVd) / AbulkCV;
8408 dVdsatCV2_dVb = (dVgsteff2_dVb - dDeltaPhi2_dVb - VdsatCV2 * dAbulkCV_dVb) / AbulkCV;
8409 dVdsatCV2_dVe = (dVgsteff2_dVe - dDeltaPhi2_dVe - VdsatCV2 * dAbulkCV_dVe) / AbulkCV;
8410
8411 V4 = VdsatCV2 - Vds - DELTA_4;
8412 T02 = sqrt(V4 * V4 + 4.0 * DELTA_4 * VdsatCV2);
8413 VdseffCV2 = VdsatCV2 - 0.5 * (V4 + T02);
8414 T12 = 0.5 * (1.0 + V4 / T02);
8415 T22 = DELTA_4 / T02;
8416 T3 = (1.0 - T12 - T22) / AbulkCV;
8417 T4 = T3 * ( 1.0 - dDeltaPhi2_dVg);
8418 /* LFW_FD fix/add next 4 lines */
8419 dVdseffCV2_dVg = (1.0 - T12 - T22) * dVdsatCV2_dVg;
8420 dVdseffCV2_dVd = (1.0 - T12 - T22) * dVdsatCV2_dVd + T12;
8421 dVdseffCV2_dVb = (1.0 - T12 - T22) * dVdsatCV2_dVb;
8422 dVdseffCV2_dVe = (1.0 - T12 - T22) * dVdsatCV2_dVe;
8423
8424 /* 10 new lines Wagner */
8425 if (selfheat) {
8426 dVdsatCV2_dT = (dVgsteff2_dT-dDeltaPhi2_dT)/AbulkCV
8427 -VdsatCV2*dAbulkCV_dT/AbulkCV;
8428 dTL1_dT = (V4 + 2.0 * DELTA_4) * dVdsatCV2_dT / T02;
8429 dVdseffCV2_dT = 0.5*dVdsatCV2_dT - 0.5*dTL1_dT;
8430 }
8431 else {
8432 dVdsatCV2_dT = 0;
8433 dVdseffCV2_dT = 0;
8434 }
8435
8436 T02 = AbulkCV * VdseffCV2;
8437 T12 = Vgsteff2 - DeltaPhi2;
8438 T22 = 12.0 * (T12 - 0.5 * T02 + 1.0e-20);
8439 T3 = T02 / T22;
8440 T4 = 1.0 - 12.0 * T3 * T3;
8441 T52 = AbulkCV * (6.0 * T02 * (4.0 * T12 - T02) / (T22 * T22) - 0.5);
8442 T6 = T52 * VdseffCV2 / AbulkCV;
8443 /* LFW_FD add next 16 lines */
8444 dT02_dVg = dAbulkCV_dVg * VdseffCV2 + AbulkCV * dVdseffCV2_dVg;
8445 dT02_dVd = dAbulkCV_dVd * VdseffCV2 + AbulkCV * dVdseffCV2_dVd;
8446 dT02_dVb = dAbulkCV_dVb * VdseffCV2 + AbulkCV * dVdseffCV2_dVb;
8447 dT02_dVe = dAbulkCV_dVe * VdseffCV2 + AbulkCV * dVdseffCV2_dVe;
8448
8449 dT12_dVg = dVgsteff2_dVg - dDeltaPhi2_dVg;
8450 dT12_dVd = dVgsteff2_dVd - dDeltaPhi2_dVd;
8451 dT12_dVb = dVgsteff2_dVb - dDeltaPhi2_dVb;
8452 dT12_dVe = dVgsteff2_dVe - dDeltaPhi2_dVe;
8453
8454 dT22_dVg = 12.0 * (dT12_dVg - 0.5 * dT02_dVg);
8455 dT22_dVd = 12.0 * (dT12_dVd - 0.5 * dT02_dVd);
8456 dT22_dVb = 12.0 * (dT12_dVb - 0.5 * dT02_dVb);
8457 dT22_dVe = 12.0 * (dT12_dVe - 0.5 * dT02_dVe);
8458
8459 dT3_dVg = (dT02_dVg - T3 * dT22_dVg) / T22;
8460 dT3_dVd = (dT02_dVd - T3 * dT22_dVd) / T22;
8461 dT3_dVb = (dT02_dVb - T3 * dT22_dVb) / T22;
8462 dT3_dVe = (dT02_dVe - T3 * dT22_dVe) / T22;
8463
8464 T7 = CoxWLcen2 * (T12 - T02 * (0.5 - T3));
8465 qinv += T7;
8466 qgate = qinoi = qinv;
8467 QovCox2 = T7 / Coxeff2;
8468 /* LFW_FD fix/add next 4 lines */
8469 Cgg12 = CoxWLcen2 * (dT12_dVg - dT02_dVg * (0.5 - T3) + T02 * dT3_dVg) + QovCox2 * dCoxeff2_dVg;
8470 Cgd12 = CoxWLcen2 * (dT12_dVd - dT02_dVd * (0.5 - T3) + T02 * dT3_dVd) + QovCox2 * dCoxeff2_dVd;
8471 Cgb12 = CoxWLcen2 * (dT12_dVb - dT02_dVb * (0.5 - T3) + T02 * dT3_dVb) + QovCox2 * dCoxeff2_dVb;
8472 Cge12 = CoxWLcen2 * (dT12_dVe - dT02_dVe * (0.5 - T3) + T02 * dT3_dVe) + QovCox2 * dCoxeff2_dVe;
8473
8474 /* 11 new lines Wagner */
8475 if (selfheat) {
8476 dTL1_dT = AbulkCV * dVdseffCV2_dT + dAbulkCV_dT * VdseffCV2;
8477 dTL2_dT = 12 * (dVgsteff2_dT - dDeltaPhi2_dT - 0.5*dTL1_dT);
8478 dTL3_dT = dTL1_dT/T22 - (T3/T22)*dTL2_dT;
8479 dqgate2_dT = (T7 * dCoxeff2_dT / Coxeff2)
8480 + CoxWLcen2 * (dVgsteff2_dT - dDeltaPhi2_dT
8481 - dTL1_dT*(0.5-T3)
8482 + T02*dTL3_dT);
8483 dqgate_dT += dqgate2_dT;
8484 }
8485 else dqgate_dT += 0;
8486 }
8487
8488 /* end v4.1 */
8489
8490
8491 /* v3.1 */
8492 /* LFW_FD 2 new lines - flexilint */
8493 Csg2 = Cbg12 = Cbd12 = Cbb12 = Cbe12 = 0;
8494 dqbulk_dT = 0;
8495 if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */
8496 {
8497 qbulk = Cbg1 = Cbd1 = Cbb1 = Cbe1 = dqbulk_dT = 0; /* LFW_FD enhance line */
8498 }
8499 else /* soiMod = 0 or 1 */
8500 {
8501 T7 = 1.0 - AbulkCV;
8502 T8 = T2 * T2;
8503 T9 = 12.0 * T7 * T0 * T0 / (T8 * AbulkCV);
8504 T10 = T9 * (1.0 - dDeltaPhi_dVg);
8505 T11 = -T7 * T5 / AbulkCV;
8506 T12 = -(T9 * T1 / AbulkCV + VdseffCV * (0.5 - T0 / T2));
8507
8508 qbulk1 = qbulk = CoxWLcenb * T7 * (0.5 * VdseffCV - T0 * VdseffCV / T2); /* enhanced line Wagner */
8509 QovCox = qbulk / Coxeff;
8510 /* LFW_FD fix/add next 4 derivatives */
8511 Cbg1 = CoxWLcenb * T7 * (0.5 - T0 / T2) * dVdseffCV_dVg
8512 - CoxWLcenb * T7 * VdseffCV * ((dT0_dVg -T0 * dT2_dVg / T2) /T2)
8513 - CoxWLcenb * VdseffCV * (0.5 - T0 / T2) * dAbulkCV_dVg
8514 + QovCox * dCoxeff_dVg;
8515 Cbb1 = CoxWLcenb * T7 * (0.5 - T0 / T2) * dVdseffCV_dVb
8516 - CoxWLcenb * T7 * VdseffCV * ((dT0_dVb -T0 * dT2_dVb / T2) /T2)
8517 - CoxWLcenb * VdseffCV * (0.5 - T0 / T2) * dAbulkCV_dVb
8518 + QovCox * dCoxeff_dVb;
8519 Cbd1 = CoxWLcenb * T7 * (0.5 - T0 / T2) * dVdseffCV_dVd
8520 - CoxWLcenb * T7 * VdseffCV * ((dT0_dVd -T0 * dT2_dVd / T2) /T2)
8521 - CoxWLcenb * VdseffCV * (0.5 - T0 / T2) * dAbulkCV_dVd
8522 + QovCox * dCoxeff_dVd;
8523 Cbe1 = CoxWLcenb * T7 * (0.5 - T0 / T2) * dVdseffCV_dVe
8524 - CoxWLcenb * T7 * VdseffCV * ((dT0_dVe -T0 * dT2_dVe / T2) /T2)
8525 - CoxWLcenb * VdseffCV * (0.5 - T0 / T2) * dAbulkCV_dVe
8526 + QovCox * dCoxeff_dVe;
8527
8528 /* 12 new lines Wagner */
8529 if (selfheat) {
8530 dTL1_dT = AbulkCV * dVdseffCV_dT + dAbulkCV_dT * VdseffCV;
8531 dTL2_dT = 12 * (dVgsteff_dT - dDeltaPhi_dT - 0.5*dTL1_dT);
8532 TL3 = T0/T2;
8533 dTL3_dT = dTL1_dT/T2 - (TL3/T2)*dTL2_dT;
8534 TL4 = (0.5 * VdseffCV - T0 * VdseffCV / T2);
8535 dTL4_dT = (0.5 - T0/T2)*dVdseffCV_dT - VdseffCV*dTL3_dT;
8536 dqbulk_dT = dCoxWLcenb_dT * T7 * TL4
8537 - CoxWLcenb * dAbulkCV_dT * TL4
8538 + CoxWLcenb * T7 * dTL4_dT;
8539 }
8540 else dqbulk_dT = 0;
8541 /* v4.1 */
8542 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
8543 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0) {
8544 T8 = T22 * T22;
8545 T9 = 12.0 * T7 * T02 * T02 / (T8 * AbulkCV);
8546 T10 = T9 * (1.0 - dDeltaPhi2_dVg);
8547 T11 = -T7 * T52 / AbulkCV;
8548 T12 = -(T9 * (Vgsteff2 - DeltaPhi2) / AbulkCV + VdseffCV2 * (0.5 - T02 / T22));
8549
8550 qbulk2 = CoxWLcenb2 * T7 * (0.5 * VdseffCV2 - T02 * VdseffCV2 / T22);
8551 QovCox2 = qbulk2 / Coxeff2;
8552 /* LFW_FD fix/add next 4 derivatives */
8553 Cbg12 = CoxWLcenb2 * T7 * (0.5 - T02 / T22) * dVdseffCV2_dVg
8554 - CoxWLcenb2 * T7 * VdseffCV2 * ((dT02_dVg -T02 * dT22_dVg / T22) /T22)
8555 - CoxWLcenb2 * VdseffCV2 * (0.5 - T02 / T22) * dAbulkCV_dVg
8556 + QovCox2 * dCoxeff2_dVg;
8557 Cbb12 = CoxWLcenb2 * T7 * (0.5 - T02 / T22) * dVdseffCV2_dVb
8558 - CoxWLcenb2 * T7 * VdseffCV2 * ((dT02_dVb -T02 * dT22_dVb / T22) /T22)
8559 - CoxWLcenb2 * VdseffCV2 * (0.5 - T02 / T22) * dAbulkCV_dVb
8560 + QovCox2 * dCoxeff2_dVb;
8561 Cbd12 = CoxWLcenb2 * T7 * (0.5 - T02 / T22) * dVdseffCV2_dVd
8562 - CoxWLcenb2 * T7 * VdseffCV2 * ((dT02_dVd -T02 * dT22_dVd / T22) /T22)
8563 - CoxWLcenb2 * VdseffCV2 * (0.5 - T02 / T22) * dAbulkCV_dVd
8564 + QovCox2 * dCoxeff2_dVd;
8565 Cbe12 = CoxWLcenb2 * T7 * (0.5 - T02 / T22) * dVdseffCV2_dVe
8566 - CoxWLcenb2 * T7 * VdseffCV2 * ((dT02_dVe -T02 * dT22_dVe / T22) /T22)
8567 - CoxWLcenb2 * VdseffCV2 * (0.5 - T02 / T22) * dAbulkCV_dVe
8568 + QovCox2 * dCoxeff2_dVe;
8569
8570 /* 12 new lines Wagner */
8571 if (selfheat) {
8572 dTL1_dT = AbulkCV * dVdseffCV2_dT + dAbulkCV_dT * VdseffCV2;
8573 dTL2_dT = 12 * (dVgsteff2_dT - dDeltaPhi2_dT - 0.5*dTL1_dT);
8574 TL3 = T02/T22;
8575 dTL3_dT = dTL1_dT/T22 - (TL3/T22)*dTL2_dT;
8576 TL4 = (0.5 * VdseffCV2 - T02 * VdseffCV2 / T22);
8577 dTL4_dT = (0.5 - T02/T22)*dVdseffCV2_dT - VdseffCV2*dTL3_dT;
8578 dqbulk2_dT = dCoxWLcenb2_dT * T7 * TL4
8579 - CoxWLcenb2 * dAbulkCV_dT * TL4
8580 + CoxWLcenb2 * T7 * dTL4_dT;
8581 }
8582 else dqbulk2_dT = 0;
8583
8584 qbulk += qbulk2;
8585 dqbulk_dT += dqbulk2_dT; /* new line Wagner */
8586 }
8587
8588 /* end v4.1 */
8589
8590 }
8591 /* v3.1 */
8592
8593 Csg2 = Csd2 = Csb2 = Cse2 = 0.0; /* LFW_FD enhance line */
8594 dqsrc2_dT = 0; /* new line Wagner */
8595 if (model->B4SOIxpart > 0.5)
8596 { /* 0/100 partition */
8597 qsrc = -CoxWLcen * (T1 / 2.0 + T0 / 4.0
8598 - 0.5 * T0 * T0 / T2);
8599 /* 9 new lines Wagner */
8600 if (selfheat) {
8601 dTL1_dT = AbulkCV * dVdseffCV_dT + dAbulkCV_dT * VdseffCV;
8602 dTL5_dT = dVgsteff_dT - dDeltaPhi_dT;
8603 dTL2_dT = 12 * (dVgsteff_dT - dDeltaPhi_dT - 0.5*dTL1_dT);
8604 dqsrc_dT = qsrc*dCoxeff_dT/Coxeff
8605 -CoxWLcen*(dTL5_dT/2.0 + dTL1_dT/4.0 - T0*dTL1_dT/T2
8606 + 0.5*T0*T0*dTL2_dT/(T2*T2) );
8607 }
8608 else dqsrc_dT = 0;
8609
8610 QovCox = qsrc / Coxeff;
8611 T2 += T2;
8612 T3 = T2 * T2;
8613 T7 = -(0.25 - 12.0 * T0 * (4.0 * T1 - T0) / T3);
8614 T4 = -(0.5 + 24.0 * T0 * T0 / T3) * (1.0 - dDeltaPhi_dVg);
8615 T5 = T7 * AbulkCV;
8616 T6 = T7 * VdseffCV;
8617
8618 /* LFW_FD fix/add next 4 derivatives */
8619 Csg = QovCox * dCoxeff_dVg
8620 - CoxWLcen * (dT1_dVg / 2.0 + dT0_dVg / 4.0
8621 - 2.0 * T0 * dT0_dVg / T2 + 2.0 * T0 * T0 * dT2_dVg / (T2 * T2));
8622 Csd = QovCox * dCoxeff_dVd
8623 - CoxWLcen * (dT1_dVd / 2.0 + dT0_dVd / 4.0
8624 - 2.0 * T0 * dT0_dVd / T2 + 2.0 * T0 * T0 * dT2_dVd / (T2 * T2));
8625 Csb = QovCox * dCoxeff_dVb
8626 - CoxWLcen * (dT1_dVb / 2.0 + dT0_dVb / 4.0
8627 - 2.0 * T0 * dT0_dVb / T2 + 2.0 * T0 * T0 * dT2_dVb / (T2 * T2));
8628 Cse = QovCox * dCoxeff_dVe
8629 - CoxWLcen * (dT1_dVe / 2.0 + dT0_dVe / 4.0
8630 - 2.0 * T0 * dT0_dVe / T2 + 2.0 * T0 * T0 * dT2_dVe / (T2 * T2));
8631
8632 /* v4.1 */
8633 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
8634 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0) {
8635 T12 = Vgsteff2 - DeltaPhi2; /* must restore for derivatives below*/
8636 qsrc2 = -CoxWLcen2 * ( (Vgsteff2 - DeltaPhi2) / 2.0 + T02 / 4.0
8637 - 0.5 * T02 * T02 / T22); /* CJB LFW */
8638 /* 9 new lines Wagner */
8639 if (selfheat) {
8640 dTL1_dT = AbulkCV * dVdseffCV2_dT + dAbulkCV_dT * VdseffCV2;
8641 dTL5_dT = dVgsteff2_dT - dDeltaPhi2_dT;
8642 dTL2_dT = 12 * (dVgsteff2_dT - dDeltaPhi2_dT - 0.5*dTL1_dT);
8643 dqsrc2_dT = qsrc2*dCoxeff2_dT/Coxeff2
8644 -CoxWLcen2*(dTL5_dT/2.0 + dTL1_dT/4.0 - T02*dTL1_dT/T22
8645 + 0.5*T02*T02*dTL2_dT/(T22*T22) );
8646 }
8647 else dqsrc2_dT = 0;
8648
8649 QovCox2 = qsrc2 / Coxeff2;
8650 T22 += T22;
8651 T3 = T22 * T22;
8652 T7 = -(0.25 - 12.0 * T02 * (4.0 * T12 - T02) / T3);
8653 T4 = -(0.5 + 24.0 * T02 * T02 / T3) * (1.0 - dDeltaPhi2_dVg);
8654 T5 = T7 * AbulkCV;
8655 T6 = T7 * VdseffCV2;
8656 /* LFW_FD fix/add next 4 derivatives */
8657 Csg2 = QovCox2 * dCoxeff2_dVg
8658 - CoxWLcen2 * (dT12_dVg / 2.0 + dT02_dVg / 4.0
8659 - 2.0 * T02 * dT02_dVg / T22 + 2.0 * T02 * T02 * dT22_dVg / (T22 * T22));
8660 Csd2 = QovCox2 * dCoxeff2_dVd
8661 - CoxWLcen2 * (dT12_dVd / 2.0 + dT02_dVd / 4.0
8662 - 2.0 * T02 * dT02_dVd / T22 + 2.0 * T02 * T02 * dT22_dVd / (T22 * T22));
8663 Csb2 = QovCox2 * dCoxeff2_dVb
8664 - CoxWLcen2 * (dT12_dVb / 2.0 + dT02_dVb / 4.0
8665 - 2.0 * T02 * dT02_dVb / T22 + 2.0 * T02 * T02 * dT22_dVb / (T22 * T22));
8666 Cse2 = QovCox2 * dCoxeff2_dVe
8667 - CoxWLcen2 * (dT12_dVe / 2.0 + dT02_dVe / 4.0
8668 - 2.0 * T02 * dT02_dVe / T22 + 2.0 * T02 * T02 * dT22_dVe / (T22 * T22));
8669
8670 qsrc += qsrc2;
8671 dqsrc_dT += dqsrc2_dT; /* new line Wagner */
8672 }
8673 /* end v4.1 */
8674
8675 }
8676 else if (model->B4SOIxpart < 0.5)
8677 { /* 40/60 partition */
8678 T2 = T2 / 12.0;
8679 T3 = 0.5 * CoxWLcen / (T2 * T2);
8680 T4 = T1 * (2.0 * T0 * T0 / 3.0 + T1 * (T1 - 4.0
8681 * T0 / 3.0)) - 2.0 * T0 * T0 * T0 / 15.0;
8682 qsrc = -T3 * T4;
8683 QovCox = qsrc / Coxeff;
8684 T8 = 4.0 / 3.0 * T1 * (T1 - T0) + 0.4 * T0 * T0;
8685 T5 = -2.0 * qsrc / T2 - T3 * (T1 * (3.0 * T1 - 8.0
8686 * T0 / 3.0) + 2.0 * T0 * T0 / 3.0);
8687 T6 = AbulkCV * (qsrc / T2 + T3 * T8);
8688 T7 = T6 * VdseffCV / AbulkCV;
8689
8690 /* LFW_FD add next 32 lines */
8691 dT2_dVg = dT2_dVg / 12.0;
8692 dT2_dVd = dT2_dVd / 12.0;
8693 dT2_dVb = dT2_dVb / 12.0;
8694 dT2_dVe = dT2_dVe / 12.0;
8695
8696 dT3_dVg = T3 * dCoxeff_dVg / Coxeff
8697 - 2.0 * T3 * T2 * dT2_dVg / (T2 * T2);
8698 dT3_dVd = T3 * dCoxeff_dVd / Coxeff
8699 - 2.0 * T3 * T2 * dT2_dVd / (T2 * T2);
8700 dT3_dVb = T3 * dCoxeff_dVb / Coxeff
8701 - 2.0 * T3 * T2 * dT2_dVb / (T2 * T2);
8702 dT3_dVe = T3 * dCoxeff_dVe / Coxeff
8703 - 2.0 * T3 * T2 * dT2_dVe / (T2 * T2);
8704
8705 dT4_dVg = dT1_dVg * (2.0 * T0 * T0 / 3.0 + T1 * (T1 - 4.0 * T0 / 3.0))
8706 + T1 * (4.0 * T0 * dT0_dVg / 3.0
8707 + dT1_dVg * (T1 - 4.0 * T0 / 3.0)
8708 + T1 * (dT1_dVg - 4.0 * dT0_dVg /3.0))
8709 - 2.0 * T0 * T0 * dT0_dVg / 5.0;
8710 dT4_dVd = dT1_dVd * (2.0 * T0 * T0 / 3.0 + T1 * (T1 - 4.0 * T0 / 3.0))
8711 + T1 * (4.0 * T0 * dT0_dVd / 3.0
8712 + dT1_dVd * (T1 - 4.0 * T0 / 3.0)
8713 + T1 * (dT1_dVd - 4.0 * dT0_dVd /3.0))
8714 - 2.0 * T0 * T0 * dT0_dVd / 5.0;
8715 dT4_dVb = dT1_dVb * (2.0 * T0 * T0 / 3.0 + T1 * (T1 - 4.0 * T0 / 3.0))
8716 + T1 * (4.0 * T0 * dT0_dVb / 3.0
8717 + dT1_dVb * (T1 - 4.0 * T0 / 3.0)
8718 + T1 * (dT1_dVb - 4.0 * dT0_dVb /3.0))
8719 - 2.0 * T0 * T0 * dT0_dVb / 5.0;
8720 dT4_dVe = dT1_dVe * (2.0 * T0 * T0 / 3.0 + T1 * (T1 - 4.0 * T0 / 3.0))
8721 + T1 * (4.0 * T0 * dT0_dVe / 3.0
8722 + dT1_dVe * (T1 - 4.0 * T0 / 3.0)
8723 + T1 * (dT1_dVe - 4.0 * dT0_dVe /3.0))
8724 - 2.0 * T0 * T0 * dT0_dVe / 5.0;
8725
8726 /* LFW_FD fix/add next 4 derivatives */
8727 Csg = -(dT3_dVg * T4 + T3 * dT4_dVg);
8728 Csd = -(dT3_dVd * T4 + T3 * dT4_dVd);
8729 Csb = -(dT3_dVb * T4 + T3 * dT4_dVb);
8730 Cse = -(dT3_dVe * T4 + T3 * dT4_dVe);
8731
8732 /* 13 new lines Wagner */
8733 if (selfheat) {
8734 dTL1_dT = AbulkCV * dVdseffCV_dT + dAbulkCV_dT * VdseffCV;
8735 dTL5_dT = dVgsteff_dT - dDeltaPhi_dT;
8736 dTL2_dT = (dVgsteff_dT - dDeltaPhi_dT - 0.5*dTL1_dT);
8737 dTL3_dT = - 2*T3*dTL2_dT/T2 + T3*dCoxeff_dT/Coxeff;
8738 dTL4_dT = dTL5_dT * (2.0*T0*T0/3.0 + T1*(T1-4.0*T0/3.0))
8739 + T1 * (4.0*T0*dTL1_dT/3.0
8740 + dTL5_dT*(T1-4.0*T0/3.0)
8741 + T1*(dTL5_dT-4.0*dTL1_dT/3.0) )
8742 - 2.0*T0*T0*dTL1_dT/5.0;
8743 dqsrc_dT = -T3*dTL4_dT - dTL3_dT*T4;
8744 }
8745 else dqsrc_dT += 0;
8746
8747 /* v4.1 */
8748 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
8749 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0) {
8750 T12 = Vgsteff2 - DeltaPhi2; /* must restore for derivatives below*/
8751 T22 = T22 / 12.0;
8752 T3 = 0.5 * CoxWLcen2 / (T22 * T22);
8753 T4 = T12 * (2.0 * T02 * T02 / 3.0 + T12 * (T12 - 4.0
8754 * T02 / 3.0)) - 2.0 * T02 * T02 * T02 / 15.0;
8755 qsrc2 = -T3 * T4;
8756 QovCox2 = qsrc2 / Coxeff2;
8757 T8 = 4.0 / 3.0 * T12 * (T12 - T02) + 0.4 * T02 * T02;
8758 T5 = -2.0 * qsrc2 / T22 - T3 * (T12 * (3.0 * T12 - 8.0
8759 * T02 / 3.0) + 2.0 * T02 * T02 / 3.0);
8760 T6 = AbulkCV * (qsrc2 / T22 + T3 * T8);
8761 T7 = T6 * VdseffCV2 / AbulkCV;
8762
8763 /* LFW_FD add next 32 lines */
8764 dT22_dVg = dT22_dVg / 12.0;
8765 dT22_dVd = dT22_dVd / 12.0;
8766 dT22_dVb = dT22_dVb / 12.0;
8767 dT22_dVe = dT22_dVe / 12.0;
8768
8769 dT3_dVg = T3 * dCoxeff2_dVg / Coxeff2
8770 - 2.0 * T3 * T22 * dT22_dVg / (T22 * T22);
8771 dT3_dVd = T3 * dCoxeff2_dVd / Coxeff2
8772 - 2.0 * T3 * T22 * dT22_dVd / (T22 * T22);
8773 dT3_dVb = T3 * dCoxeff2_dVb / Coxeff2
8774 - 2.0 * T3 * T22 * dT22_dVb / (T22 * T22);
8775 dT3_dVe = T3 * dCoxeff2_dVe / Coxeff2
8776 - 2.0 * T3 * T22 * dT22_dVe / (T22 * T22);
8777
8778 dT4_dVg = dT12_dVg * (2.0 * T02 * T02 / 3.0 + T12 * (T12 - 4.0 * T02 / 3.0))
8779 + T12 * (4.0 * T02 * dT02_dVg / 3.0
8780 + dT12_dVg * (T12 - 4.0 * T02 / 3.0)
8781 + T12 * (dT12_dVg - 4.0 * dT02_dVg /3.0))
8782 - 2.0 * T02 * T02 * dT02_dVg / 5.0;
8783 dT4_dVd = dT12_dVd * (2.0 * T02 * T02 / 3.0 + T12 * (T12 - 4.0 * T02 / 3.0))
8784 + T12 * (4.0 * T02 * dT02_dVd / 3.0
8785 + dT12_dVd * (T12 - 4.0 * T02 / 3.0)
8786 + T12 * (dT12_dVd - 4.0 * dT02_dVd /3.0))
8787 - 2.0 * T02 * T02 * dT02_dVd / 5.0;
8788 dT4_dVb = dT12_dVb * (2.0 * T02 * T02 / 3.0 + T12 * (T12 - 4.0 * T02 / 3.0))
8789 + T12 * (4.0 * T02 * dT02_dVb / 3.0
8790 + dT12_dVb * (T12 - 4.0 * T02 / 3.0)
8791 + T12 * (dT12_dVb - 4.0 * dT02_dVb /3.0))
8792 - 2.0 * T02 * T02 * dT02_dVb / 5.0;
8793 dT4_dVe = dT12_dVe * (2.0 * T02 * T02 / 3.0 + T12 * (T12 - 4.0 * T02 / 3.0))
8794 + T12 * (4.0 * T02 * dT02_dVe / 3.0
8795 + dT12_dVe * (T12 - 4.0 * T02 / 3.0)
8796 + T12 * (dT12_dVe - 4.0 * dT02_dVe /3.0))
8797 - 2.0 * T02 * T02 * dT02_dVe / 5.0;
8798 /* LFW_FD fix/add next 4 derivatives */
8799 Csg2 = -(dT3_dVg * T4 + T3 * dT4_dVg);
8800 Csd2 = -(dT3_dVd * T4 + T3 * dT4_dVd);
8801 Csb2 = -(dT3_dVb * T4 + T3 * dT4_dVb);
8802 Cse2 = -(dT3_dVe * T4 + T3 * dT4_dVe);
8803
8804 /* 14 new lines Wagner */
8805 if (selfheat) {
8806 dTL1_dT = AbulkCV * dVdseffCV2_dT + dAbulkCV_dT * VdseffCV2;
8807 dTL5_dT = dVgsteff2_dT - dDeltaPhi2_dT;
8808 dTL2_dT = (dVgsteff2_dT - dDeltaPhi2_dT - 0.5*dTL1_dT);
8809 dTL3_dT = - 2*T3*dTL2_dT/T22 + T3*dCoxeff2_dT/Coxeff2;
8810 dTL4_dT = dTL5_dT * (2.0*T02*T02/3.0 + T12*(T12-4.0*T02/3.0))
8811 + T12 * (4.0*T02*dTL1_dT/3.0
8812 + dTL5_dT*(T12-4.0*T02/3.0)
8813 + T12*(dTL5_dT-4.0*dTL1_dT/3.0) )
8814 - 2.0*T02*T02*dTL1_dT/5.0;
8815 dqsrc2_dT = -T3*dTL4_dT - dTL3_dT*T4;
8816 }
8817 else dqsrc_dT += 0;
8818
8819 qsrc += qsrc2;
8820 dqsrc_dT += dqsrc2_dT; /* new line Wagner */
8821 }
8822 /* end v4.1 */
8823 }
8824 else
8825 { /* 50/50 partition */
8826 qsrc = -0.5 * qgate;
8827 Csg = -0.5 * Cgg1;
8828 Csd = -0.5 * Cgd1;
8829 Csb = -0.5 * Cgb1;
8830 Cse = -0.5 * Cge1; /* LFW_FD new line */
8831 /* v4.1 */
8832 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
8833 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0) {
8834 /* LFW_FD fix/add next 4 lines */
8835 Csg2 = -0.5 * Cgg12;
8836 Csd2 = -0.5 * Cgd12;
8837 Csb2 = -0.5 * Cgb12;
8838 Cse2 = -0.5 * Cge12;
8839 }
8840 dqsrc_dT = -0.5 * dqgate_dT; /* new line Wagner */
8841 /* end v4.1 */
8842 }
8843
8844
8845 /* Backgate charge */
8846 /* v3.1 */
8847 if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */
8848 {
8849 Qe1 = Ce1b = Ce1e = Ce1T = dQe1_dT = 0;
8850 }
8851 else /* soiMod = 0 or 1 */
8852 {
8853 CboxWL = pParam->B4SOIkb1 * model->B4SOIfbody * Cbox
8854 * (pParam->B4SOIweffCV / here->B4SOInseg
8855 * here->B4SOInf /* bugfix_snps nf*/
8856 * pParam->B4SOIleffCVbg + here->B4SOIaebcp);
8857 Qe1 = CboxWL * (Vesfb - Vbs);
8858 Ce1b = dQe1_dVb = -CboxWL;
8859 Ce1e = dQe1_dVe = CboxWL;
8860 if (selfheat) Ce1T = dQe1_dT = -CboxWL * dvfbb_dT;
8861 else Ce1T = dQe1_dT = 0.0;
8862 }
8863 /* v3.1 */
8864
8865
8866 qgate += Qac0 + Qsub0 - qbulk;
8867 qbody = qbulk - Qac0 - Qsub0 - Qe1;
8868 qsub = Qe1;
8869 qdrn = -(qgate + qbody + qsub + qsrc);
8870
8871 /* 8 new lines Wagner */
8872 dqgate_dT += dQac0_dT + dQsub0_dT - dqbulk_dT;
8873 dqbody_dT = dqbulk_dT - dQac0_dT - dQsub0_dT - dQe1_dT;
8874 dqsub_dT = dQe1_dT;
8875 dqdrn_dT = -(dqgate_dT + dqbody_dT + dqsub_dT + dqsrc_dT);
8876 CgT = dqgate_dT;
8877 CbT = dqbody_dT;
8878 CsT = dqsrc_dT;
8879 CdT = dqdrn_dT;
8880
8881 Cbg = Cbg1 - dQac0_dVg - dQsub0_dVg;
8882 /* LFW_FD fix/add next 3 lines */
8883 Cbd = Cbd1 - dQac0_dVd - dQsub0_dVd;
8884 Cbb = Cbb1 - dQac0_dVb - dQsub0_dVb - Ce1b;
8885 Cbe = Cbe1 - dQac0_dVe - dQsub0_dVe - Ce1e;
8886
8887 Cgg = Cgg1 - Cbg;
8888 Cgd = Cgd1 - Cbd;
8889 /* LFW_FD fix/add next 2 lines */
8890 Cgb = Cgb1 - Cbb - Ce1b;
8891 Cge = Cge1 - Cbe - Ce1e;
8892 /* comment out next 4 lines Wagner */
8893 /*if (selfheat)
8894 CgT = Cgg1 * dVgsteff_dT + dQac0_dT
8895 + dQsub0_dT;
8896 else CgT = 0.0;*/
8897
8898 /*Cgb *= dVbseff_dVb; */
8899 /*Cbb *= dVbseff_dVb; */
8900 /*Csb *= dVbseff_dVb; */
8901 /* comment out next 2 lines Wagner */
8902 /*if (selfheat) CsT = Csg * dVgsteff_dT;
8903 else CsT = 0.0;*/
8904 /* v4.1 */
8905 if ((here->B4SOIsoiMod != 2) && /* Bug fix #10 Jun 09 'opposite type Q/C evaluated only if bodymod=1' */
8906 (here->B4SOIbodyMod != 0) && here->B4SOIagbcp2 > 0) {
8907 /* LFW_FD fix next 12 lines */
8908 Cbg += Cbg12 - dQac02_dVg - dQsub02_dVg;
8909 Cbd += Cbd12 - dQac02_dVd - dQsub02_dVd;
8910 Cbb += Cbb12 - dQac02_dVb - dQsub02_dVb;
8911 Cbe += Cbe12 - dQac02_dVe - dQsub02_dVe;
8912
8913 Cgg = Cgg1 + Cgg12 - Cbg;
8914 Cgd = Cgd1 + Cgd12 - Cbd;
8915 Cgb = Cgb1 + Cgb12 - Cbb - Ce1b;
8916 Cge = Cge1 + Cge12 - Cbe - Ce1e;
8917
8918 Csg += Csg2;
8919 Csd += Csd2;
8920 Csb += Csb2;
8921 Cse += Cse2;
8922 }
8923
8924 /* end v4.1 */
8925 here->B4SOIcggb = Cgg;
8926 here->B4SOIcgsb = -(Cgg + Cgd + Cgb + Cge); /* LFW_FD fix line */
8927 here->B4SOIcgdb = Cgd;
8928 here->B4SOIcgeb = Cge; /* LFW_FD fix line */
8929 here->B4SOIcgT = CgT;
8930
8931 here->B4SOIcbgb = Cbg;
8932 here->B4SOIcbsb = -(Cbg + Cbd + Cbb + Cbe); /* LFW_FD fix line */
8933 here->B4SOIcbdb = Cbd;
8934 here->B4SOIcbeb = Cbe; /* LFW_FD fix line */
8935 here->B4SOIcbT = CbT;
8936
8937 here->B4SOIceT = Ce1T;
8938 here->B4SOIceeb = Ce1e ;
8939
8940 here->B4SOIcdgb = -(Cgg + Cbg + Csg);
8941 here->B4SOIcddb = -(Cgd + Cbd + Csd);
8942 here->B4SOIcdeb = -(Cge + Cse + Cbe) - Ce1e; /* LFW_FD fix line */
8943 here->B4SOIcdT = -(CgT+CbT+CsT) - Ce1T;
8944 here->B4SOIcdsb = Cgg + Cgd + Cgb + Cge /* LFW_FD fix expression */
8945 + Cbg + Cbd + Cbb + Cbe + Ce1e
8946 + Csg + Csd + Csb + Cse + Ce1b;
8947 here->B4SOIqinv = -qinoi;
8948
8949 } /* End of if capMod ==3 */
8950 else { /* v4.0 */
8951 Qsub0 = Qac0 = 0.0;
8952 qgate = qdrn = qsrc = qbody = qsub = 0.0;
8953 Cbg = Cbd = Cbb = 0.0;
8954 here->B4SOIcggb = here->B4SOIcgsb
8955 = here->B4SOIcgdb = 0.0;
8956 here->B4SOIcdgb = here->B4SOIcdsb
8957 = here->B4SOIcddb = 0.0;
8958 here->B4SOIcbgb = here->B4SOIcbsb
8959 = here->B4SOIcbdb = 0.0;
8960 }
8961 }
8962 here->B4SOIqgate = qgate;
8963 here->B4SOIqdrn = qdrn;
8964 here->B4SOIqbulk = qbody;
8965 here->B4SOIqsrc = qsrc;
8966
8967
8968
8969 finished: /* returning Values to Calling Routine */
8970 /*
8971 * COMPUTE EQUIVALENT DRAIN CURRENT SOURCE
8972 */
8973
8974 /* flexilint inits */
8975 gcjdbs = gcjdT = 0.0;
8976 gcjsbs = gcjsT = 0.0;
8977
8978 if (ChargeComputationNeeded)
8979 {
8980 /* Intrinsic S/D junction charge */
8981
8982 /* v3.1 */
8983 if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */
8984 {
8985 qjs = qjd = 0.0;
8986 /*gcjdds = gcjdbs = gcjdT = 0.0; v4.2 */
8987 gcjdbs = gcjdT = 0.0;
8988 gcjsbs = gcjsT = 0.0;
8989 here->B4SOIcjsb = here->B4SOIcjdb = 0.0 /*v4.0*/;
8990
8991 }
8992 else /* soiMod = 0 or 1 */
8993 {
8994 PhiBSWG = model->B4SOIGatesidewallJctSPotential;
8995 dPhiBSWG_dT = -model->B4SOItpbswg;
8996 PhiBSWG += dPhiBSWG_dT * (Temp - model->B4SOItnom);
8997 MJSWG = model->B4SOIbodyJctGateSideSGradingCoeff;
8998
8999 cjsbs = model->B4SOIunitLengthGateSidewallJctCapS
9000 * pParam->B4SOIwdiosCV * model->B4SOItsi * here->B4SOInf / 1e-7; /* bugfix_snps nf*/
9001 dcjsbs_dT = cjsbs * model->B4SOItcjswg;
9002 cjsbs += dcjsbs_dT * (Temp - model->B4SOItnom);
9003
9004 cjdbs = model->B4SOIunitLengthGateSidewallJctCapD
9005 * pParam->B4SOIwdiodCV * model->B4SOItsi * here->B4SOInf / 1e-7; /* bugfix_snps nf*/
9006 dcjdbs_dT = cjdbs * model->B4SOItcjswgd;
9007 cjdbs += dcjdbs_dT * (Temp - model->B4SOItnom);
9008
9009 DioMax = 0.9 * (PhiBSWG);
9010
9011 /* arg = 1.0 - (Vbs > DioMax ? DioMax : Vbs) / PhiBSWG; */ /* Bug fix #6 Vbs evaluated taking consideration of Rbody Mode*/
9012 if (here->B4SOIrbodyMod)
9013 arg = 1.0 - (vsbs > DioMax ? DioMax : vsbs) / PhiBSWG; /* Bug fix #6 */
9014 else
9015 arg = 1.0 - (vbs > DioMax ? DioMax : vbs) / PhiBSWG; /* Bug fix #6 */
9016 if (selfheat)
9017 darg_dT = (1 - arg) / PhiBSWG * dPhiBSWG_dT;
9018 else
9019 darg_dT = 1.0; /* flexilint */
9020
9021 if (MJSWG == 0.5) {
9022 dT3_dVb = 1.0 / sqrt(arg);
9023
9024 if (selfheat) ddT3_dVb_dT = -0.5 * dT3_dVb / arg * darg_dT;
9025 else ddT3_dVb_dT = 1.0; /* flexilint */
9026 }
9027 else {
9028 dT3_dVb = exp(-MJSWG * log(arg));
9029
9030 if (selfheat) ddT3_dVb_dT = -MJSWG * dT3_dVb / arg * darg_dT;
9031 else ddT3_dVb_dT = 1.0; /* flexilint */
9032 }
9033 T3 = (1.0 - arg * dT3_dVb) * PhiBSWG / (1.0 - MJSWG);
9034
9035 if (selfheat)
9036 dT3_dT = (1.0 - arg * dT3_dVb) * dPhiBSWG_dT / (1.0 - MJSWG)
9037 - (arg * ddT3_dVb_dT + darg_dT * dT3_dVb) * PhiBSWG / (1.0 - MJSWG);
9038 else
9039 dT3_dT = 1.0; /* flexilint */
9040
9041 /* if (vbs > DioMax)
9042 T3 += dT3_dVb * (vbs - DioMax); */ /* Bug fix #6 Vbs evaluated taking consideration of Rbody Mode*/
9043
9044 if (here->B4SOIrbodyMod)
9045 {
9046 if (vsbs > DioMax) /* Bug fix #6 */
9047 T3 += dT3_dVb * (vsbs - DioMax);
9048 }
9049 else
9050 {
9051 if (vbs > DioMax) /* Bug fix #6 */
9052 T3 += dT3_dVb * (vbs - DioMax);
9053 }
9054
9055 if (here->B4SOImode > 0)
9056 {
9057 qjs = cjsbs * T3 + model->B4SOItt * Ibsdif * here->B4SOInf;
9058 gcjsbs = cjsbs * dT3_dVb + model->B4SOItt * dIbsdif_dVb * here->B4SOInf;
9059 /* 3 new lines */
9060 if (selfheat)
9061 gcjsT = model->B4SOItt * dIbsdif_dT * here->B4SOInf + dcjsbs_dT * T3 + dT3_dT * cjsbs;
9062 else gcjsT = 0.0;
9063 }
9064 else
9065 {
9066 qjs = cjsbs * T3 + model->B4SOItt * Ibddif * here->B4SOInf;
9067 gcjsbs = cjsbs * dT3_dVb + model->B4SOItt * dIbddif_dVb * here->B4SOInf;
9068 /* 3 new lines */
9069 if (selfheat)
9070 gcjsT = model->B4SOItt * dIbddif_dT * here->B4SOInf + dcjsbs_dT * T3 + dT3_dT * cjsbs;
9071 else gcjsT = 0.0;
9072 }
9073 /* comment out next 3 lines Wagner */
9074 /*if (selfheat)
9075 gcjsT = model->B4SOItt * dIbsdif_dT * here->B4SOInf + dcjsbs_dT * T3 + dT3_dT * cjsbs;
9076 else gcjsT = 0.0; */
9077
9078 PhiBSWG = model->B4SOIGatesidewallJctDPotential;
9079 dPhiBSWG_dT = -model->B4SOItpbswgd;
9080 PhiBSWG += dPhiBSWG_dT * (Temp - model->B4SOItnom);
9081 MJSWG = model->B4SOIbodyJctGateSideDGradingCoeff;
9082
9083 DioMax = 0.9 * (PhiBSWG);
9084 /* arg = 1.0 - (vbd > DioMax ? DioMax : vbd) / PhiBSWG; */ /* Bug fix #6 Vbd evaluated taking consideration of Rbody Mode*/
9085 if (here->B4SOIrbodyMod)
9086 arg = 1.0 - (vdbd > DioMax ? DioMax : vdbd) / PhiBSWG; /* Bug Fix #6 */
9087 else
9088 arg = 1.0 - (vbd > DioMax ? DioMax : vbd) / PhiBSWG; /* Bug Fix #6 */
9089
9090 if (selfheat)
9091 darg_dT = (1 - arg) / PhiBSWG * dPhiBSWG_dT;
9092 else
9093 darg_dT = 1.0; /* flexilint */
9094
9095 if (MJSWG == 0.5) {
9096 dT3_dVb = 1.0 / sqrt(arg);
9097
9098 if (selfheat) ddT3_dVb_dT = -0.5 * dT3_dVb / arg * darg_dT;
9099 else ddT3_dVb_dT = 1.0; /* flexilint */
9100 }
9101 else {
9102 dT3_dVb = exp(-MJSWG * log(arg));
9103
9104 if (selfheat) ddT3_dVb_dT = -MJSWG * dT3_dVb / arg * darg_dT;
9105 else ddT3_dVb_dT = 1.0; /* flexilint */
9106 }
9107 T3 = (1.0 - arg * dT3_dVb) * PhiBSWG / (1.0 - MJSWG);
9108
9109 if (selfheat)
9110 dT3_dT = (1.0 - arg * dT3_dVb) * dPhiBSWG_dT / (1.0 - MJSWG)
9111 - (arg * ddT3_dVb_dT + darg_dT * dT3_dVb) * PhiBSWG / (1.0 - MJSWG);
9112 else
9113 dT3_dT = 1.0; /* flexilint */
9114
9115 /* if (vbd > DioMax)
9116 T3 += dT3_dVb * (vbd - DioMax); */ /* Bug fix #6 Vbd evaluated taking consideration of Rbody Mode*/
9117 if (here->B4SOIrbodyMod)
9118 {
9119 if (vdbd > DioMax) /* Bug fix #6 */
9120 T3 += dT3_dVb * (vdbd - DioMax);
9121 }
9122 else
9123 {
9124 if (vbd > DioMax) /* Bug fix #6 */
9125 T3 += dT3_dVb * (vbd - DioMax);
9126 }
9127 dT3_dVd = -dT3_dVb;
9128
9129 if (here->B4SOImode > 0)
9130 {
9131 qjd = cjdbs * T3 + model->B4SOItt * Ibddif * here->B4SOInf;
9132 gcjdbs = cjdbs * dT3_dVb + model->B4SOItt * dIbddif_dVb * here->B4SOInf;
9133 /* 3 new lines Wagner */
9134 if (selfheat)
9135 gcjdT = model->B4SOItt * dIbddif_dT * here->B4SOInf + dcjdbs_dT * T3 + dT3_dT * cjdbs;
9136 else gcjdT = 0.0;
9137 }
9138 else
9139 {
9140 qjd = cjdbs * T3 + model->B4SOItt * Ibsdif * here->B4SOInf;
9141 gcjdbs = cjdbs * dT3_dVb + model->B4SOItt * dIbsdif_dVb * here->B4SOInf;
9142 /* 3 new lines Wagner */
9143 if (selfheat)
9144 gcjdT = model->B4SOItt * dIbsdif_dT * here->B4SOInf + dcjdbs_dT * T3 + dT3_dT * cjdbs;
9145 else gcjdT = 0.0;
9146 }
9147 /*gcjdds = cjdbs * dT3_dVd + model->B4SOItt * dIbddif_dVd; v4.2 */
9148 /* comment out next 3 lines Wagner */
9149 /*if (selfheat)
9150 gcjdT = model->B4SOItt * dIbddif_dT * here->B4SOInf + dcjdbs_dT * T3 + dT3_dT * cjdbs;
9151 else gcjdT = 0.0;*/
9152 }
9153 /* v3.1 */
9154
9155 /* v4.0 */
9156 /* qdrn -= qjd;
9157 qbody += (qjs + qjd);
9158 qsrc = -(qgate + qbody + qdrn + qsub);
9159 */
9160
9161 /* Update the conductance */
9162 /* v4.2 bugfix: qjs/qjd computed using unswapped voltages; however, total capacitances are swapped below
9163 note that gcjdds = -gcjdbs always, so (gcjdds + gcjdbs) == 0
9164 here->B4SOIcddb -= gcjdds;
9165 here->B4SOIcdT -= gcjdT;
9166 here->B4SOIcdsb += gcjdds + gcjdbs;
9167
9168
9169 here->B4SOIcbdb += (gcjdds);
9170 here->B4SOIcbT += (gcjdT + gcjsT);
9171 here->B4SOIcbsb -= (gcjdds + gcjdbs + gcjsbs);
9172
9173 here->B4SOIcjsb = (gcjdds + gcjdbs + gcjsbs);
9174 here->B4SOIcjdb = -gcjdds;
9175 */
9176 here->B4SOIcbT += (gcjdT + gcjsT);
9177 if (here->B4SOImode > 0)
9178 {
9179 here->B4SOIcddb += gcjdbs;
9180 here->B4SOIcdT -= gcjdT;
9181
9182 here->B4SOIcbdb -= (gcjdbs);
9183 here->B4SOIcbsb -= (gcjsbs);
9184
9185 here->B4SOIcjsb = gcjsbs;
9186 here->B4SOIcjdb = gcjdbs;
9187 } else {
9188 here->B4SOIcddb += gcjsbs;
9189 here->B4SOIcdT -= gcjsT;
9190
9191 here->B4SOIcbdb -= (gcjsbs);
9192 here->B4SOIcbsb -= (gcjdbs);
9193
9194 here->B4SOIcjsb = gcjdbs;
9195 here->B4SOIcjdb = gcjsbs;
9196 }
9197
9198 /* Extrinsic Bottom S/D to substrate charge */
9199 T10 = -model->B4SOItype * ves;
9200 /* T10 is vse without type conversion */
9201 T11 = model->B4SOItype * (vds - ves);
9202 /* T11 is vde without type conversion */
9203
9204 if (model->B4SOIcsdmin != 0.0)
9205 {
9206 if ( ((pParam->B4SOInsub > 0) && (model->B4SOItype > 0)) ||
9207 ((pParam->B4SOInsub < 0) && (model->B4SOItype < 0)) )
9208 {
9209 if (T10 < pParam->B4SOIvsdfb)
9210 { here->B4SOIqse = here->B4SOIcsbox * (T10 - pParam->B4SOIvsdfb);
9211 here->B4SOIgcse = here->B4SOIcsbox;
9212 }
9213 else if (T10 < pParam->B4SOIsdt1)
9214 { T0 = T10 - pParam->B4SOIvsdfb;
9215 T1 = T0 * T0;
9216 here->B4SOIqse = T0 * (here->B4SOIcsbox -
9217 pParam->B4SOIst2 / 3 * T1) ;
9218 here->B4SOIgcse = here->B4SOIcsbox - pParam->B4SOIst2 * T1;
9219 }
9220 else if (T10 < pParam->B4SOIvsdth)
9221 { T0 = T10 - pParam->B4SOIvsdth;
9222 T1 = T0 * T0;
9223 here->B4SOIqse = here->B4SOIcsmin * T10 + here->B4SOIst4 +
9224 pParam->B4SOIst3 / 3 * T0 * T1;
9225 here->B4SOIgcse = here->B4SOIcsmin + pParam->B4SOIst3 * T1;
9226 }
9227 else
9228 { here->B4SOIqse = here->B4SOIcsmin * T10 + here->B4SOIst4;
9229 here->B4SOIgcse = here->B4SOIcsmin;
9230 }
9231 } else
9232 {
9233 if (T10 < pParam->B4SOIvsdth)
9234 { here->B4SOIqse = here->B4SOIcsmin * (T10 - pParam->B4SOIvsdth);
9235 here->B4SOIgcse = here->B4SOIcsmin;
9236 }
9237 else if (T10 < pParam->B4SOIsdt1)
9238 { T0 = T10 - pParam->B4SOIvsdth;
9239 T1 = T0 * T0;
9240 here->B4SOIqse = T0 * (here->B4SOIcsmin - pParam->B4SOIst2 / 3 * T1) ;
9241 here->B4SOIgcse = here->B4SOIcsmin - pParam->B4SOIst2 * T1;
9242 }
9243 else if (T10 < pParam->B4SOIvsdfb)
9244 { T0 = T10 - pParam->B4SOIvsdfb;
9245 T1 = T0 * T0;
9246 here->B4SOIqse = here->B4SOIcsbox * T10 + here->B4SOIst4 +
9247 pParam->B4SOIst3 / 3 * T0 * T1;
9248 here->B4SOIgcse = here->B4SOIcsbox + pParam->B4SOIst3 * T1;
9249 }
9250 else
9251 { here->B4SOIqse = here->B4SOIcsbox * T10 + here->B4SOIst4;
9252 here->B4SOIgcse = here->B4SOIcsbox;
9253 }
9254 }
9255
9256 if ( ((pParam->B4SOInsub > 0) && (model->B4SOItype > 0)) ||
9257 ((pParam->B4SOInsub < 0) && (model->B4SOItype < 0)) )
9258 {
9259 if (T11 < pParam->B4SOIvsdfb)
9260 { here->B4SOIqde = here->B4SOIcdbox * (T11 - pParam->B4SOIvsdfb);
9261 here->B4SOIgcde = here->B4SOIcdbox;
9262 }
9263 else if (T11 < pParam->B4SOIsdt1)
9264 { T0 = T11 - pParam->B4SOIvsdfb;
9265 T1 = T0 * T0;
9266 here->B4SOIqde = T0 * (here->B4SOIcdbox - pParam->B4SOIdt2 / 3 * T1) ;
9267 here->B4SOIgcde = here->B4SOIcdbox - pParam->B4SOIdt2 * T1;
9268 }
9269 else if (T11 < pParam->B4SOIvsdth)
9270 { T0 = T11 - pParam->B4SOIvsdth;
9271 T1 = T0 * T0;
9272 here->B4SOIqde = here->B4SOIcdmin * T11 + here->B4SOIdt4 +
9273 pParam->B4SOIdt3 / 3 * T0 * T1;
9274 here->B4SOIgcde = here->B4SOIcdmin + pParam->B4SOIdt3 * T1;
9275 }
9276 else
9277 { here->B4SOIqde = here->B4SOIcdmin * T11 + here->B4SOIdt4;
9278 here->B4SOIgcde = here->B4SOIcdmin;
9279 }
9280 } else
9281 {
9282 if (T11 < pParam->B4SOIvsdth)
9283 { here->B4SOIqde = here->B4SOIcdmin * (T11 - pParam->B4SOIvsdth);
9284 here->B4SOIgcde = here->B4SOIcdmin;
9285 }
9286 else if (T11 < pParam->B4SOIsdt1)
9287 { T0 = T11 - pParam->B4SOIvsdth;
9288 T1 = T0 * T0;
9289 here->B4SOIqde = T0 * (here->B4SOIcdmin - pParam->B4SOIdt2 / 3 * T1) ;
9290 here->B4SOIgcde = here->B4SOIcdmin - pParam->B4SOIdt2 * T1;
9291 }
9292 else if (T11 < pParam->B4SOIvsdfb)
9293 { T0 = T11 - pParam->B4SOIvsdfb;
9294 T1 = T0 * T0;
9295 here->B4SOIqde = here->B4SOIcdbox * T11 + here->B4SOIdt4 +
9296 pParam->B4SOIdt3 / 3 * T0 * T1;
9297 here->B4SOIgcde = here->B4SOIcdbox + pParam->B4SOIdt3 * T1;
9298 }
9299 else
9300 { here->B4SOIqde = here->B4SOIcdbox * T11 + here->B4SOIdt4;
9301 here->B4SOIgcde = here->B4SOIcdbox;
9302 }
9303 }
9304 }
9305 else {
9306 here->B4SOIqse = here->B4SOIcsbox * T10;
9307 here->B4SOIgcse = here->B4SOIcsbox;
9308 here->B4SOIqde = here->B4SOIcdbox * T11;
9309 here->B4SOIgcde = here->B4SOIcdbox;
9310 }
9311
9312 /* Extrinsic : Sidewall fringing S/D charge */
9313 here->B4SOIqse += here->B4SOIcsesw * T10;
9314 here->B4SOIgcse += here->B4SOIcsesw;
9315 here->B4SOIqde += here->B4SOIcdesw * T11;
9316 here->B4SOIgcde += here->B4SOIcdesw;
9317
9318 /* All charge are multiplied with type at the end, but qse and qde
9319 have true polarity => so pre-multiplied with type */
9320 here->B4SOIqse *= model->B4SOItype;
9321 here->B4SOIqde *= model->B4SOItype;
9322 }
9323 else { /* v4.0 */
9324 qjs = qjd = 0.0;
9325 here->B4SOIqse = here->B4SOIqde = 0.0;
9326 here->B4SOIgcse = here->B4SOIgcde = 0.0;
9327 }
9328
9329 here->B4SOIcbb = Cbb;
9330 here->B4SOIcbd = Cbd;
9331 here->B4SOIcbg = Cbg;
9332 here->B4SOIqbf = -Qsub0 - Qac0;
9333 here->B4SOIqjs = qjs;
9334 here->B4SOIqjd = qjd;
9335 *(ckt->CKTstate0 + here->B4SOIqbs) = qjs; /* v4.0 */
9336 *(ckt->CKTstate0 + here->B4SOIqbd) = qjd; /* v4.0 */
9337
9338 /*
9339 * check convergence
9340 */
9341 if ((here->B4SOIoff == 0) || (!(ckt->CKTmode & MODEINITFIX)))
9342 { if (Check == 1)
9343 { ckt->CKTnoncon++;
9344 #ifndef NEWCONV
9345 }
9346 else
9347 { tol = ckt->CKTreltol * MAX(fabs(cdhat), fabs(here->B4SOIcd))
9348 + ckt->CKTabstol;
9349 if (fabs(cdhat - here->B4SOIcd) >= tol)
9350 { ckt->CKTnoncon++;
9351 }
9352 else
9353 { tol = ckt->CKTreltol * MAX(fabs(cbhat),
9354 fabs(here->B4SOIcbs + here->B4SOIcbd))
9355 + ckt->CKTabstol;
9356 if (fabs(cbhat - (here->B4SOIcbs + here->B4SOIcbd))
9357 > tol)
9358 { ckt->CKTnoncon++;
9359 }
9360 }
9361 #endif /* NEWCONV */
9362 }
9363 }
9364
9365 *(ckt->CKTstate0 + here->B4SOIvg) = vg;
9366 *(ckt->CKTstate0 + here->B4SOIvd) = vd;
9367 *(ckt->CKTstate0 + here->B4SOIvs) = vs;
9368 *(ckt->CKTstate0 + here->B4SOIvp) = vp;
9369 *(ckt->CKTstate0 + here->B4SOIve) = ve;
9370
9371 *(ckt->CKTstate0 + here->B4SOIvbs) = vbs;
9372 *(ckt->CKTstate0 + here->B4SOIvbd) = vbd;
9373 *(ckt->CKTstate0 + here->B4SOIvgs) = vgs;
9374 *(ckt->CKTstate0 + here->B4SOIvds) = vds;
9375 *(ckt->CKTstate0 + here->B4SOIves) = ves;
9376 *(ckt->CKTstate0 + here->B4SOIvps) = vps;
9377 *(ckt->CKTstate0 + here->B4SOIdeltemp) = delTemp;
9378
9379 /* v3.1 added for RF */
9380 *(ckt->CKTstate0 + here->B4SOIvgge) = vgge;
9381 *(ckt->CKTstate0 + here->B4SOIvggm) = vggm;
9382 *(ckt->CKTstate0 + here->B4SOIvges) = vges;
9383 *(ckt->CKTstate0 + here->B4SOIvgms) = vgms;
9384 /* v3.1 added for RF end*/
9385 *(ckt->CKTstate0 + here->B4SOIvdbs) = vdbs; /* v4.0 */
9386 *(ckt->CKTstate0 + here->B4SOIvdbd) = vdbd; /* v4.0 */
9387 *(ckt->CKTstate0 + here->B4SOIvsbs) = vsbs; /* v4.0 */
9388 *(ckt->CKTstate0 + here->B4SOIvses) = vses;
9389 *(ckt->CKTstate0 + here->B4SOIvdes) = vdes;
9390
9391 /* bulk and channel charge plus overlaps */
9392
9393 if (!ChargeComputationNeeded)
9394 goto line850;
9395
9396 #ifndef NOBYPASS
9397 line755:
9398 #endif
9399 ag0 = ckt->CKTag[0];
9400
9401 T0 = vgd + DELTA_1;
9402 if (here->B4SOIrgateMod == 3) T0 = vgmd + DELTA_1; /* v3.2 bug fix */
9403 T1 = sqrt(T0 * T0 + 4.0 * DELTA_1);
9404 T2 = 0.5 * (T0 - T1);
9405
9406 /* v2.2.3 bug fix */
9407 T3 = pParam->B4SOIwdiodCV * pParam->B4SOIcgdl; /* v3.1 bug fix */
9408
9409 T4 = sqrt(1.0 - 4.0 * T2 / pParam->B4SOIckappa);
9410 cgdo = pParam->B4SOIcgdo + T3 - T3 * (1.0 - 1.0 / T4)
9411 * (0.5 - 0.5 * T0 / T1);
9412 qgdo = (pParam->B4SOIcgdo + T3) * vgd - T3 * (T2
9413 + 0.5 * pParam->B4SOIckappa * (T4 - 1.0));
9414
9415 if (here->B4SOIrgateMod == 3) {
9416 qgdo = (pParam->B4SOIcgdo + T3) * vgmd - T3 * (T2
9417 + 0.5 * pParam->B4SOIckappa * (T4 - 1.0));
9418 } /* v3.2 bug fix */
9419
9420 T0 = vgs + DELTA_1;
9421 if (here->B4SOIrgateMod == 3) T0 = vgms + DELTA_1; /* v3.2 bug fix */
9422 T1 = sqrt(T0 * T0 + 4.0 * DELTA_1);
9423 T2 = 0.5 * (T0 - T1);
9424
9425 /* v2.2.3 bug fix */
9426 T3 = pParam->B4SOIwdiosCV * pParam->B4SOIcgsl; /* v3.1 bug fix */
9427
9428 T4 = sqrt(1.0 - 4.0 * T2 / pParam->B4SOIckappa);
9429 cgso = pParam->B4SOIcgso + T3 - T3 * (1.0 - 1.0 / T4)
9430 * (0.5 - 0.5 * T0 / T1);
9431 qgso = (pParam->B4SOIcgso + T3) * vgs - T3 * (T2
9432 + 0.5 * pParam->B4SOIckappa * (T4 - 1.0));
9433
9434 if (here->B4SOIrgateMod == 3) {
9435 qgso = (pParam->B4SOIcgso + T3) * vgms - T3 * (T2
9436 + 0.5 * pParam->B4SOIckappa * (T4 - 1.0));
9437 } /* v3.2 bug fix */
9438
9439 if (here->B4SOInf != 1.0)
9440 { cgdo *= here->B4SOInf;
9441 cgso *= here->B4SOInf;
9442 qgdo *= here->B4SOInf;
9443 qgso *= here->B4SOInf;
9444 }
9445 /* here->B4SOIcgdo = cgdo;
9446 here->B4SOIcgso = cgso;
9447 */
9448 if (here->B4SOIdebugMod < 0)
9449 goto line850;
9450
9451
9452 if (here->B4SOImode > 0)
9453 {
9454
9455 /* v3.1 added for RF */
9456 if (here->B4SOIrgateMod == 3)
9457 {
9458 gcgmgmb = (cgdo + cgso + pParam->B4SOIcgeo) * ag0;
9459
9460 gcgmdb = -cgdo * ag0;
9461 gcgmsb = -cgso * ag0;
9462 gcgmeb = -pParam->B4SOIcgeo * ag0;
9463 gcdgmb = gcgmdb;
9464 gcsgmb = gcgmsb;
9465 gcegmb = gcgmeb;
9466
9467 gcggb = here->B4SOIcggb * ag0;
9468 gcgdb = here->B4SOIcgdb * ag0;
9469 gcgsb = here->B4SOIcgsb * ag0;
9470 gcgeb = here->B4SOIcgeb * ag0; /* fix line */
9471 gcgbb = -(gcggb + gcgdb + gcgsb + gcgeb);
9472
9473 gcdgb = here->B4SOIcdgb * ag0;
9474 gcegb = gcgeb; /*v3.1 added*/
9475 gcsgb = -(here->B4SOIcggb + here->B4SOIcbgb
9476 + here->B4SOIcdgb) * ag0 - gcegb;
9477 gcbgb = here->B4SOIcbgb * ag0;
9478
9479 qgd = qgdo;
9480 qgs = qgso;
9481 qge = 0; /* v3.1 change */
9482
9483 qgme = pParam->B4SOIcgeo * vgme;
9484 qgmid = qgdo + qgso + qgme;
9485 qdrn += here->B4SOIqde - qgd;
9486 qsub -= qgme + here->B4SOIqse + here->B4SOIqde;
9487 qsrc = -(qgate + qgmid + qbody + qdrn + qsub) - qjs;
9488 qdrn -= qjd;
9489 if (!here->B4SOIrbodyMod) qbody += qjd + qjs;
9490
9491 }
9492 else
9493 {
9494 gcggb = (here->B4SOIcggb + cgdo + cgso
9495 + pParam->B4SOIcgeo) * ag0;
9496 gcgdb = (here->B4SOIcgdb - cgdo) * ag0;
9497 gcgsb = (here->B4SOIcgsb - cgso) * ag0;
9498 gcgeb = (here->B4SOIcgeb - pParam->B4SOIcgeo) *ag0; /* LFW_FD fix line */
9499 gcgbb = -(gcggb + gcgdb + gcgsb + gcgeb);
9500
9501 gcegb = (- pParam->B4SOIcgeo) * ag0;
9502 gcdgb = (here->B4SOIcdgb - cgdo) * ag0;
9503 gcsgb = -(here->B4SOIcggb + here->B4SOIcbgb
9504 + here->B4SOIcdgb + cgso) * ag0;
9505 gcbgb = here->B4SOIcbgb * ag0;
9506
9507 gcdgmb = gcsgmb = gcegmb = 0.0;
9508 gcgmdb = gcgmsb = gcgmeb = 0.0;
9509
9510 /* Lump the overlap capacitance and S/D parasitics */
9511 qgd = qgdo;
9512 qgs = qgso;
9513 qge = pParam->B4SOIcgeo * vge;
9514 qgate += qgd + qgs + qge;
9515 qdrn += here->B4SOIqde - qgd;
9516 qsub -= qge + here->B4SOIqse + here->B4SOIqde;
9517 qsrc = -(qgate + qbody + qdrn + qsub) - qjs;
9518 qdrn -= qjd;
9519 if (!here->B4SOIrbodyMod) qbody += qjd + qjs;
9520 }
9521
9522 gcddb = (here->B4SOIcddb + cgdo + here->B4SOIgcde) * ag0;
9523 gcdsb = here->B4SOIcdsb * ag0;
9524 gcdeb = (here->B4SOIcdeb - here->B4SOIgcde) * ag0;
9525 /*fix below expression Wagner */
9526 /*gcdT = model->B4SOItype * here->B4SOIcdT * ag0;*/
9527 gcdT = here->B4SOIcdT * ag0;
9528
9529 gcsdb = -(here->B4SOIcgdb + here->B4SOIcbdb
9530 + here->B4SOIcddb) * ag0;
9531 gcssb = (cgso + here->B4SOIgcse - (here->B4SOIcgsb
9532 + here->B4SOIcbsb + here->B4SOIcdsb)) * ag0;
9533 gcseb = -(here->B4SOIgcse + here->B4SOIcbeb
9534 + here->B4SOIcdeb + here->B4SOIcgeb + here->B4SOIceeb) * ag0; /* LFW_FD fix line */
9535 /*fix below expression Wagner */
9536 /*gcsT = - model->B4SOItype * (here->B4SOIcgT */
9537 gcsT = - (here->B4SOIcgT
9538 + here->B4SOIcbT + here->B4SOIcdT + here->B4SOIceT)
9539 * ag0;
9540
9541 /*fix below expression Wagner */
9542 /*gcgT = model->B4SOItype * here->B4SOIcgT * ag0;*/
9543 gcgT = here->B4SOIcgT * ag0;
9544
9545 /* gcbdb = here->B4SOIcbdb * ag0;
9546 gcbsb = here->B4SOIcbsb * ag0;
9547 */
9548 gcbeb = here->B4SOIcbeb * ag0;
9549 gcbT = model->B4SOItype * here->B4SOIcbT * ag0;
9550
9551 /* v4.0 */
9552 if (!here->B4SOIrbodyMod)
9553 {
9554 gcjdbdp = gcjsbsp = 0.0;
9555 gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb + gcdeb);
9556 gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb + gcseb);
9557 gcdbdb = gcsbsb = 0.0;
9558 gcbdb = here->B4SOIcbdb * ag0;
9559 gcbsb = here->B4SOIcbsb * ag0;
9560 here->B4SOIGGjdb = GGjdb = 0.0;
9561 here->B4SOIGGjsb = GGjsb = 0.0;
9562 }
9563 else
9564 {
9565 gcjdbdp = gcjdbs * ag0;
9566 gcjsbsp = gcjsbs * ag0;
9567 gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb + gcdeb)
9568 + gcjdbdp;
9569 gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb + gcseb)
9570 + gcjsbsp;
9571 /* v4.2 optimization: gcjdds + gcjdbs = 0
9572 gcdbdb = gcjdds * ag0;
9573 gcsbsb = -(gcjdds + gcjdbs + gcjsbs) * ag0;
9574 */
9575 gcdbdb = -gcjdbs * ag0;
9576 gcsbsb = -gcjsbs * ag0;
9577 gcbdb = here->B4SOIcbdb * ag0 - gcdbdb;
9578 gcbsb = here->B4SOIcbsb * ag0 - gcsbsb;
9579 here->B4SOIGGjdb = GGjdb = Gjdb;
9580 here->B4SOIGGjsb = GGjsb = Gjsb;
9581 }
9582 /* v4.0 end */
9583
9584 gcedb = (- here->B4SOIgcde) * ag0;
9585 gcesb = (- here->B4SOIgcse) * ag0;
9586 gceeb = (here->B4SOIgcse + here->B4SOIgcde +
9587 here->B4SOIceeb + pParam->B4SOIcgeo) * ag0;
9588
9589 gceT = model->B4SOItype * here->B4SOIceT * ag0;
9590
9591 gcTt = pParam->B4SOIcth * ag0;
9592
9593 sxpart = 0.6;
9594 dxpart = 0.4;
9595
9596
9597 /* v3.1 moved the following original code ahead */
9598 /* Lump the overlap capacitance and S/D parasitics */
9599 /* qgd = qgdo;
9600 qgs = qgso;
9601 qge = pParam->B4SOIcgeo * vge;
9602 qgate += qgd + qgs + qge;
9603 qdrn += here->B4SOIqde - qgd;
9604 qsub -= qge + here->B4SOIqse + here->B4SOIqde;
9605 qsrc = -(qgate + qbody + qdrn + qsub);
9606 */
9607 /* v3.1 end */
9608
9609 }
9610
9611 else
9612 {
9613 if (here->B4SOIrgateMod == 3)
9614 {
9615 gcgmgmb = (cgdo + cgso + pParam->B4SOIcgeo) * ag0;
9616 gcgmdb = -cgdo * ag0;
9617 gcgmsb = -cgso * ag0;
9618 gcgmeb = -pParam->B4SOIcgeo * ag0;
9619 gcdgmb = gcgmdb;
9620 gcsgmb = gcgmsb;
9621 gcegmb = gcgmeb;
9622
9623 gcggb = here->B4SOIcggb * ag0;
9624 gcgsb = here->B4SOIcgdb * ag0;
9625 gcgdb = here->B4SOIcgsb * ag0;
9626 gcgeb = here->B4SOIcgeb * ag0; /* LFW_FD fix line */
9627 gcgbb = -(gcggb + gcgdb + gcgsb + gcgeb); /* v3.1 added gcgeb */
9628
9629 gcsgb = here->B4SOIcdgb * ag0;
9630 gcegb = gcgeb; /* v3.1 added */
9631 gcdgb = -(here->B4SOIcggb + here->B4SOIcbgb
9632 + here->B4SOIcdgb) * ag0 - gcegb; /*v3.1 added gcegb*/
9633 gcbgb = here->B4SOIcbgb * ag0;
9634
9635 qgd = qgdo;
9636 qgs = qgso;
9637 qge = 0; /* v3.1 */
9638 qgme = pParam->B4SOIcgeo * vgme;
9639 qgmid = qgdo + qgso + qgme;
9640 qgate += qge;
9641 qbody -= 0;
9642 qsrc = qdrn - qgs + here->B4SOIqse;
9643 qsub -= qgme + here->B4SOIqse + here->B4SOIqde;
9644 qdrn = -(qgate + qgmid + qbody + qsrc + qsub) -qjd;
9645 qsrc -= qjs;
9646 if (!here->B4SOIrbodyMod) qbody += qjs + qjd;
9647 }
9648 else
9649 {
9650 gcggb = (here->B4SOIcggb + cgdo + cgso + pParam->B4SOIcgeo) * ag0;
9651 gcgdb = (here->B4SOIcgsb - cgdo) * ag0;
9652 gcgsb = (here->B4SOIcgdb - cgso) * ag0;
9653 gcgeb = (here->B4SOIcgeb - pParam->B4SOIcgeo) * ag0; /* LFW_FD fix line */
9654 gcgbb = -(gcggb + gcgdb + gcgsb + gcgeb); /*added gcgbb*/
9655
9656 gcegb = (- pParam->B4SOIcgeo) * ag0; /* LFW_FD fix line */
9657 gcsgb = (here->B4SOIcdgb - cgso) * ag0;
9658 gcdgb = -(here->B4SOIcggb + here->B4SOIcbgb + here->B4SOIcdgb + cgdo) * ag0;
9659 gcbgb = here->B4SOIcbgb * ag0;
9660
9661 gcdgmb = gcsgmb = gcegmb = 0.0;
9662 gcgmdb = gcgmsb = gcgmeb = 0.0;
9663
9664 /* Lump the overlap capacitance and S/D parasitics */
9665 qgd = qgdo;
9666 qgs = qgso;
9667 qge = pParam->B4SOIcgeo * vge;
9668 qgate += qgd + qgs + qge;
9669 qsrc = qdrn - qgs + here->B4SOIqse;
9670 qsub -= qge + here->B4SOIqse + here->B4SOIqde;
9671 qdrn = -(qgate + qbody + qsrc + qsub) - qjd;
9672 qsrc -= qjs;
9673 if (!here->B4SOIrbodyMod) qbody += qjs + qjd;
9674 }
9675
9676 gcssb = (here->B4SOIcddb + cgso + here->B4SOIgcse) * ag0;
9677 gcsdb = here->B4SOIcdsb * ag0;
9678 gcseb = (here->B4SOIcdeb - here->B4SOIgcse) * ag0;
9679 /*fix below expression Wagner */
9680 /*gcsT = model->B4SOItype * here->B4SOIcdT * ag0;*/
9681 gcsT = here->B4SOIcdT * ag0;
9682
9683 gcdsb = -(here->B4SOIcgdb + here->B4SOIcbdb
9684 + here->B4SOIcddb) * ag0;
9685 gcddb = (cgdo + here->B4SOIgcde - (here->B4SOIcgsb
9686 + here->B4SOIcbsb + here->B4SOIcdsb)) * ag0;
9687 gcdeb = -(here->B4SOIgcde + here->B4SOIcbeb
9688 + here->B4SOIcdeb + here->B4SOIcgeb + here->B4SOIceeb) * ag0; /* LFW_FD fix line */
9689 /*fix below expression Wagner */
9690 /*gcdT = - model->B4SOItype * (here->B4SOIcgT */
9691 gcdT = - (here->B4SOIcgT
9692 + here->B4SOIcbT + here->B4SOIcdT + here->B4SOIceT)
9693 * ag0;
9694
9695 /*fix below expression Wagner */
9696 /*gcgT = model->B4SOItype * here->B4SOIcgT * ag0;*/
9697 gcgT = here->B4SOIcgT * ag0;
9698
9699 gcbeb = here->B4SOIcbeb * ag0;
9700 gcbT = model->B4SOItype * here->B4SOIcbT * ag0;
9701 /* v4.0 gcbsb = here->B4SOIcbdb * ag0;
9702 gcbdb = here->B4SOIcbsb * ag0;
9703 */
9704
9705 /* v4.0 */
9706 if (!here->B4SOIrbodyMod)
9707 {
9708 gcjdbdp = gcjsbsp = 0.0;
9709 gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb + gcdeb);
9710 gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb + gcseb);
9711 gcdbdb = gcsbsb = 0.0;
9712 gcbdb = here->B4SOIcbsb * ag0;
9713 gcbsb = here->B4SOIcbdb * ag0;
9714 here->B4SOIGGjdb = GGjdb = 0.0;
9715 here->B4SOIGGjsb = GGjsb = 0.0;
9716 }
9717 else
9718 {
9719 /* v4.2 bugfix; qjd/qjs are not swapped
9720 gcjdbdp = gcjsbs * ag0;
9721 gcjsbsp = gcjdbs * ag0;
9722 */
9723 gcjdbdp = gcjdbs * ag0;
9724 gcjsbsp = gcjsbs * ag0;
9725 gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb + gcdeb)
9726 + gcjdbdp;
9727 gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb + gcseb)
9728 + gcjsbsp;
9729 /* v4.2 bugfix; qjd/qjs are not swapped
9730 gcsbsb = gcjdds * ag0;
9731 gcdbdb = -(gcjdds + gcjdbs + gcjsbs) * ag0;
9732 */
9733 gcsbsb = -gcjdbs * ag0;
9734 gcdbdb = -gcjsbs * ag0;
9735 gcbdb = here->B4SOIcbsb * ag0 - gcdbdb;
9736 gcbsb = here->B4SOIcbdb * ag0 - gcsbsb;
9737 here->B4SOIGGjdb = GGjdb = Gjsb;
9738 here->B4SOIGGjsb = GGjsb = Gjdb;
9739 }
9740 /* v4.0 end */
9741
9742 /* gcegb = (-pParam->B4SOIcgeo) * ag0; V3.2 bug fix */
9743 gcesb = (- here->B4SOIgcse) * ag0;
9744 gcedb = (- here->B4SOIgcde) * ag0;
9745 gceeb = (here->B4SOIceeb + pParam->B4SOIcgeo +
9746 here->B4SOIgcse + here->B4SOIgcde) * ag0;
9747 gceT = model->B4SOItype * here->B4SOIceT * ag0;
9748
9749 gcTt = pParam->B4SOIcth * ag0;
9750
9751 dxpart = 0.6;
9752 sxpart = 0.4;
9753
9754
9755 /* v3.1 moved the following code ahead */
9756 /* Lump the overlap capacitance */
9757 /*
9758 qgd = qgdo;
9759 qgs = qgso;
9760 qge = pParam->B4SOIcgeo * vge;
9761 qgate += qgd + qgs + qge;
9762 qsrc = qdrn - qgs + here->B4SOIqse;
9763 qsub -= qge + here->B4SOIqse + here->B4SOIqde;
9764 qdrn = -(qgate + qbody + qsrc + qsub);
9765 */
9766 /* v3.1 end */
9767
9768
9769 }
9770
9771 here->B4SOIcgdo = cgdo;
9772 here->B4SOIcgso = cgso;
9773
9774 if (ByPass) goto line860;
9775
9776 *(ckt->CKTstate0 + here->B4SOIqe) = qsub;
9777 *(ckt->CKTstate0 + here->B4SOIqg) = qgate;
9778 *(ckt->CKTstate0 + here->B4SOIqd) = qdrn;
9779 *(ckt->CKTstate0 + here->B4SOIqb) = qbody;
9780 if ((model->B4SOIshMod == 1) && (here->B4SOIrth0!=0.0))
9781 *(ckt->CKTstate0 + here->B4SOIqth) = pParam->B4SOIcth * delTemp;
9782 if (here->B4SOIrgateMod == 3) /* 3.1 bug fix */
9783 *(ckt->CKTstate0 + here->B4SOIqgmid) = qgmid;
9784
9785
9786 /* store small signal parameters */
9787 if (ckt->CKTmode & MODEINITSMSIG)
9788 { goto line1000;
9789 }
9790 if (!ChargeComputationNeeded)
9791 goto line850;
9792
9793
9794 if (ckt->CKTmode & MODEINITTRAN)
9795 { *(ckt->CKTstate1 + here->B4SOIqb) =
9796 *(ckt->CKTstate0 + here->B4SOIqb);
9797 *(ckt->CKTstate1 + here->B4SOIqg) =
9798 *(ckt->CKTstate0 + here->B4SOIqg);
9799 *(ckt->CKTstate1 + here->B4SOIqd) =
9800 *(ckt->CKTstate0 + here->B4SOIqd);
9801 *(ckt->CKTstate1 + here->B4SOIqe) =
9802 *(ckt->CKTstate0 + here->B4SOIqe);
9803 *(ckt->CKTstate1 + here->B4SOIqth) =
9804 *(ckt->CKTstate0 + here->B4SOIqth);
9805 if (here->B4SOIrgateMod == 3)
9806 *(ckt->CKTstate1 + here->B4SOIqgmid) =
9807 *(ckt->CKTstate0 + here->B4SOIqgmid);
9808 if (here->B4SOIrbodyMod) /* v4.0 */
9809 { *(ckt->CKTstate1 + here->B4SOIqbs) =
9810 *(ckt->CKTstate0 + here->B4SOIqbs);
9811 *(ckt->CKTstate1 + here->B4SOIqbd) =
9812 *(ckt->CKTstate0 + here->B4SOIqbd);
9813 }
9814
9815 }
9816
9817 error = NIintegrate(ckt, &geq, &ceq,0.0,here->B4SOIqb);
9818 if (error) return(error);
9819 error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B4SOIqg);
9820 if (error) return(error);
9821 error = NIintegrate(ckt,&geq, &ceq, 0.0, here->B4SOIqd);
9822 if (error) return(error);
9823 error = NIintegrate(ckt,&geq, &ceq, 0.0, here->B4SOIqe);
9824 if (error) return(error);
9825 if ((model->B4SOIshMod == 1) && (here->B4SOIrth0!=0.0))
9826 {
9827 error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B4SOIqth);
9828 if (error) return (error);
9829 }
9830
9831 if (here->B4SOIrgateMod == 3)
9832 { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B4SOIqgmid);
9833 if (error) return(error);
9834 } /*3.1 bug fix*/
9835
9836 if (here->B4SOIrbodyMod) /* v4.0 */
9837 { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B4SOIqbs);
9838 if (error) return(error);
9839 error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B4SOIqbd);
9840 if (error) return(error);
9841 }
9842
9843 goto line860;
9844
9845 line850:
9846 /* initialize to zero charge conductance and current */
9847 ceqqe = ceqqg = ceqqb = ceqqd = ceqqth= 0.0;
9848
9849 gcdgb = gcddb = gcdsb = gcdeb = gcdT = 0.0;
9850 gcsgb = gcsdb = gcssb = gcseb = gcsT = 0.0;
9851 gcggb = gcgdb = gcgsb = gcgeb = gcgT = 0.0;
9852 gcbgb = gcbdb = gcbsb = gcbeb = gcbT = 0.0;
9853 gcegb = gcedb = gceeb = gcesb = gceT = 0.0;
9854 gcTt = 0.0;
9855
9856 /* v3.1 added for RF */
9857 gcgmgmb = gcgmdb = gcgmsb = gcgmeb = 0.0;
9858 gcdgmb = gcsgmb = gcegmb = ceqqgmid = 0.0;
9859 gcgbb = gcsbb = gcdbb = 0.0;
9860 /* v3.1 added for RF end */
9861
9862 gcdbdb = gcsbsb = gcjdbdp = gcjsbsp = 0.0; /* v4.0 */
9863 ceqqjd = ceqqjs = 0.0; /* v4.0 */
9864 GGjdb = GGjsb = 0.0; /* v4.0 */
9865
9866 sxpart = (1.0 - (dxpart = (here->B4SOImode > 0) ? 0.4 : 0.6));
9867
9868 goto line900;
9869
9870 line860:
9871 /* evaluate equivalent charge current */
9872
9873 cqgate = *(ckt->CKTstate0 + here->B4SOIcqg);
9874 cqbody = *(ckt->CKTstate0 + here->B4SOIcqb);
9875 cqdrn = *(ckt->CKTstate0 + here->B4SOIcqd);
9876 cqsub = *(ckt->CKTstate0 + here->B4SOIcqe);
9877 cqtemp = *(ckt->CKTstate0 + here->B4SOIcqth);
9878
9879 here->B4SOIcb += cqbody;
9880 here->B4SOIcd += cqdrn;
9881
9882 ceqqg = cqgate - gcggb * vgb + gcgdb * vbd + gcgsb * vbs
9883 - gcgeb * veb - gcgT * delTemp;
9884
9885 ceqqb = cqbody - gcbgb * vgb + gcbdb * vbd + gcbsb * vbs
9886 - gcbeb * veb - gcbT * delTemp; /* v3.2 bug fix */
9887 ceqqd = cqdrn - gcdgb * vgb + (gcddb + gcdbdb) * vbd
9888 + gcdsb * vbs - gcdeb * veb - gcdT * delTemp
9889 - gcdbdb * vbd_jct - gcdgmb * vgmb;/* v4.0 */
9890
9891 ceqqe = cqsub - gcegb * vgb + gcedb * vbd + gcesb * vbs
9892 - gceeb * veb - gceT * delTemp - gcegmb * vgmb; /* 3.2 bug fix */
9893 ceqqth = cqtemp - gcTt * delTemp;
9894
9895 /* v3.1 added for RF */
9896 if (here->B4SOIrgateMod == 3)
9897 ceqqgmid = *(ckt->CKTstate0 + here->B4SOIcqgmid)
9898 + gcgmdb * vbd + gcgmsb * vbs - gcgmgmb * vgmb;/* 3.2 bug fix */
9899 else
9900 ceqqgmid = 0.0;
9901 /* v3.1 added for RF end */
9902
9903 if (here->B4SOIrbodyMod) /* v4.0 */
9904 { ceqqjs = *(ckt->CKTstate0 + here->B4SOIcqbs)
9905 + gcsbsb * vbs_jct;
9906 ceqqjd = *(ckt->CKTstate0 + here->B4SOIcqbd)
9907 + gcdbdb * vbd_jct;
9908 }
9909
9910 if (ckt->CKTmode & MODEINITTRAN)
9911 { *(ckt->CKTstate1 + here->B4SOIcqe) =
9912 *(ckt->CKTstate0 + here->B4SOIcqe);
9913 *(ckt->CKTstate1 + here->B4SOIcqb) =
9914 *(ckt->CKTstate0 + here->B4SOIcqb);
9915 *(ckt->CKTstate1 + here->B4SOIcqg) =
9916 *(ckt->CKTstate0 + here->B4SOIcqg);
9917 *(ckt->CKTstate1 + here->B4SOIcqd) =
9918 *(ckt->CKTstate0 + here->B4SOIcqd);
9919 *(ckt->CKTstate1 + here->B4SOIcqth) =
9920 *(ckt->CKTstate0 + here->B4SOIcqth);
9921
9922 if (here->B4SOIrgateMod == 3) /* v3.1 */
9923 *(ckt->CKTstate1 + here->B4SOIcqgmid) =
9924 *(ckt->CKTstate0 + here->B4SOIcqgmid);
9925
9926 if (here->B4SOIrbodyMod) /* v4.0 */
9927 { *(ckt->CKTstate1 + here->B4SOIcqbs) =
9928 *(ckt->CKTstate0 + here->B4SOIcqbs);
9929 *(ckt->CKTstate1 + here->B4SOIcqbd) =
9930 *(ckt->CKTstate0 + here->B4SOIcqbd);
9931 }
9932
9933 }
9934
9935 /*
9936 * load current vector
9937 */
9938 line900:
9939
9940 if (here->B4SOImode >= 0)
9941 { Gm = here->B4SOIgm;
9942 Gmbs = here->B4SOIgmbs;
9943 /* v3.0 */
9944 Gme = here->B4SOIgme;
9945
9946 GmT = model->B4SOItype * here->B4SOIgmT;
9947 FwdSum = Gm + Gmbs + Gme; /* v3.0 */
9948 RevSum = 0.0;
9949
9950 /* v2.2.2 bug fix */
9951 cdreq = model->B4SOItype * (here->B4SOIcdrain
9952 - here->B4SOIgds * vds - Gm * vgs - Gmbs * vbs
9953 - Gme * ves) - GmT * delTemp; /* v3.0 */
9954
9955 /* ceqbs now is compatible with cdreq, ie. going in is +ve */
9956 /* Equivalent current source from the diode */
9957 ceqbs = here->B4SOIcjs;
9958 ceqbd = here->B4SOIcjd;
9959 cdbdp = Idbdp;
9960 csbsp = Isbsp;
9961
9962 /* Current going in is +ve */
9963 ceqbody = -here->B4SOIcbody;
9964
9965 ceqgate = here->B4SOIcgate;
9966 gigg = here->B4SOIgigg;
9967 gigb = here->B4SOIgigb;
9968 gige = here->B4SOIgige; /* v3.0 */
9969 gigs = here->B4SOIgigs;
9970 gigd = here->B4SOIgigd;
9971 gigT = model->B4SOItype * here->B4SOIgigT;
9972
9973 ceqth = here->B4SOIcth;
9974 ceqbodcon = here->B4SOIcbodcon;
9975
9976 /* v4.1 */
9977 gigpg = here->B4SOIgigpg;
9978 gigpp = here->B4SOIgigpp;
9979 ceqgate += (here->B4SOIigp - gigpg * vgp);
9980 if(here->B4SOIbodyMod == 1)
9981 ceqbodcon += (here->B4SOIigp - gigpg * vgp);
9982 else if(here->B4SOIbodyMod == 2)
9983 ceqbody -= (here->B4SOIigp - gigpg * vgp);
9984
9985 gbbg = -here->B4SOIgbgs;
9986 gbbdp = -here->B4SOIgbds;
9987 gbbb = -here->B4SOIgbbs;
9988 gbbp = -here->B4SOIgbps;
9989 gbbT = -model->B4SOItype * here->B4SOIgbT;
9990 /* v3.0 */
9991 gbbe = -here->B4SOIgbes;
9992
9993 if (here->B4SOIrbodyMod) { /* v4.0 */
9994 gbbdp = -Giid - Ggidld - Ggisls;
9995 gbbb = -Giib + Gbpbs;
9996 gjsdb = Gjsb + Gjdb;
9997 }
9998
9999 gbbsp = - ( gbbg + gbbdp + gbbb + gbbp + gbbe);
10000
10001 gddpg = -here->B4SOIgjdg;
10002 gddpdp = -here->B4SOIgjdd;
10003 if (!here->B4SOIrbodyMod) /* v4.0 */
10004 gddpb = -here->B4SOIgjdb;
10005 else
10006 gddpb = Giib + Ggidlb + Ggislb;
10007 gddpT = -model->B4SOItype * here->B4SOIgjdT;
10008 /* v3.0 */
10009 gddpe = -here->B4SOIgjde;
10010 gddpsp = - ( gddpg + gddpdp + gddpb + gddpe);
10011
10012 gsspg = -here->B4SOIgjsg;
10013 gsspdp = -here->B4SOIgjsd;
10014 if (!here->B4SOIrbodyMod)
10015 gsspb = -here->B4SOIgjsb;
10016 else
10017 gsspb = 0.0;
10018 gsspT = -model->B4SOItype * here->B4SOIgjsT;
10019 /* v3.0 */
10020 gsspe = 0.0;
10021 gsspsp = - (gsspg + gsspdp + gsspb + gsspe);
10022
10023 gppb = -here->B4SOIgbpbs;
10024 gppp = -here->B4SOIgbpps;
10025
10026 gTtg = here->B4SOIgtempg;
10027 gTtb = here->B4SOIgtempb;
10028 gTtdp = here->B4SOIgtempd;
10029 gTtt = here->B4SOIgtempT;
10030
10031 /* v3.0 */
10032 gTte = here->B4SOIgtempe;
10033 gTtsp = - (gTtg + gTtb + gTtdp + gTte);
10034
10035
10036 /* v3.0 */
10037 if (model->B4SOIigcMod)
10038 { gIstotg = here->B4SOIgIgsg + here->B4SOIgIgcsg;
10039 gIstotd = here->B4SOIgIgcsd;
10040 gIstots = here->B4SOIgIgss + here->B4SOIgIgcss;
10041 gIstotb = here->B4SOIgIgcsb;
10042 Istoteq = model->B4SOItype * (here->B4SOIIgs + here->B4SOIIgcs
10043 - gIstotg * vgs - here->B4SOIgIgcsd * vds
10044 - here->B4SOIgIgcsb * vbs);
10045
10046 gIdtotg = here->B4SOIgIgdg + here->B4SOIgIgcdg;
10047 gIdtotd = here->B4SOIgIgdd + here->B4SOIgIgcdd;
10048 gIdtots = here->B4SOIgIgcds;
10049 gIdtotb = here->B4SOIgIgcdb;
10050 Idtoteq = model->B4SOItype * (here->B4SOIIgd + here->B4SOIIgcd
10051 - here->B4SOIgIgdg * vgd - here->B4SOIgIgcdg * vgs
10052 - here->B4SOIgIgcdd * vds - here->B4SOIgIgcdb * vbs);
10053
10054 gIgtotg = gIstotg + gIdtotg;
10055 gIgtotd = gIstotd + gIdtotd;
10056 gIgtots = gIstots + gIdtots;
10057 gIgtotb = gIstotb + gIdtotb;
10058 Igtoteq = Istoteq + Idtoteq;
10059 }
10060 else
10061 { gIstotg = gIstotd = gIstots = gIstotb = Istoteq = 0.0;
10062 gIdtotg = gIdtotd = gIdtots = gIdtotb = Idtoteq = 0.0;
10063
10064 gIgtotg = gIgtotd = gIgtots = gIgtotb = Igtoteq = 0.0;
10065 }
10066
10067 /* v3.1 added for RF */
10068 if (here->B4SOIrgateMod == 2)
10069 T0 = vges - vgs;
10070 else if (here->B4SOIrgateMod == 3)
10071 T0 = vgms - vgs;
10072 if (here->B4SOIrgateMod > 1)
10073 {
10074 gcrgd = here->B4SOIgcrgd * T0;
10075 gcrgg = here->B4SOIgcrgg * T0;
10076 gcrgs = here->B4SOIgcrgs * T0;
10077 gcrgb = here->B4SOIgcrgb * T0;
10078
10079 ceqgcrg = -(gcrgd * vds + gcrgg * vgs
10080 + gcrgb * vbs);
10081 gcrgg -= here->B4SOIgcrg;
10082 gcrg = here->B4SOIgcrg;
10083 }
10084 else
10085 ceqgcrg = gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0;
10086 /* v3.1 added for RF end */
10087
10088 } /* end of soimode>=0 */
10089
10090 else
10091 { Gm = -here->B4SOIgm;
10092 Gmbs = -here->B4SOIgmbs;
10093 /* v3.0 */
10094 Gme = -here->B4SOIgme;
10095
10096 GmT = -model->B4SOItype * here->B4SOIgmT;
10097 FwdSum = 0.0;
10098 RevSum = -(Gm + Gmbs + Gme); /* v3.0 */
10099
10100
10101 /* v3.1 bug fix */
10102 cdreq = -model->B4SOItype * (here->B4SOIcdrain + here->B4SOIgds*vds
10103 + Gm * vgd + Gmbs * vbd + Gme * (ves - vds))
10104 - GmT * delTemp;
10105
10106
10107 ceqbs = here->B4SOIcjd;
10108 ceqbd = here->B4SOIcjs;
10109 csbsp = Idbdp;
10110 cdbdp = Isbsp;
10111
10112 /* Current going in is +ve */
10113 ceqbody = -here->B4SOIcbody;
10114
10115
10116 ceqgate = here->B4SOIcgate;
10117 gigg = here->B4SOIgigg;
10118 gigb = here->B4SOIgigb;
10119 gige = here->B4SOIgige; /* v3.0 */
10120 gigs = here->B4SOIgigd;
10121 gigd = here->B4SOIgigs;
10122 gigT = model->B4SOItype * here->B4SOIgigT;
10123
10124 ceqth = here->B4SOIcth;
10125 ceqbodcon = here->B4SOIcbodcon;
10126
10127 /* v4.1 */
10128 gigpg = here->B4SOIgigpg;
10129 gigpp = here->B4SOIgigpp;
10130 ceqgate += (here->B4SOIigp - gigpg * vgp);
10131 if(here->B4SOIbodyMod == 1)
10132 ceqbodcon += (here->B4SOIigp - gigpg * vgp);
10133 else if(here->B4SOIbodyMod == 2)
10134 ceqbody -= (here->B4SOIigp - gigpg * vgp);
10135
10136 gbbg = -here->B4SOIgbgs;
10137 gbbb = -here->B4SOIgbbs;
10138 gbbp = -here->B4SOIgbps;
10139 gbbsp = -here->B4SOIgbds;
10140 gbbT = -model->B4SOItype * here->B4SOIgbT;
10141 /* v3.0 */
10142 gbbe = -here->B4SOIgbes;
10143
10144 if (here->B4SOIrbodyMod) { /* v4.0 */
10145 gbbsp = -Giid - Ggidld - Ggisls;
10146 gbbb = -Giib + Gbpbs;
10147 gjsdb = Gjsb + Gjdb;
10148 }
10149 gbbdp = - ( gbbg + gbbsp + gbbb + gbbp + gbbe);
10150
10151 gddpg = -here->B4SOIgjsg;
10152 gddpsp = -here->B4SOIgjsd;
10153 if (!here->B4SOIrbodyMod)
10154 gddpb = -here->B4SOIgjsb;
10155 else
10156 gddpb = 0.0;
10157 gddpT = -model->B4SOItype * here->B4SOIgjsT;
10158 /* v3.0 */
10159 gddpe = 0.0;
10160 gddpdp = - (gddpg + gddpsp + gddpb + gddpe);
10161
10162 gsspg = -here->B4SOIgjdg;
10163 gsspsp = -here->B4SOIgjdd;
10164 if (!here->B4SOIrbodyMod)
10165 gsspb = -here->B4SOIgjdb;
10166 else
10167 gsspb = Giib + Ggidlb + Ggislb;
10168 gsspT = -model->B4SOItype * here->B4SOIgjdT;
10169 /* v3.0 */
10170 gsspe = -here->B4SOIgjde;
10171 gsspdp = - ( gsspg + gsspsp + gsspb + gsspe);
10172
10173 gppb = -here->B4SOIgbpbs;
10174 gppp = -here->B4SOIgbpps;
10175
10176 gTtg = here->B4SOIgtempg;
10177 gTtb = here->B4SOIgtempb;
10178 gTtsp = here->B4SOIgtempd;
10179 gTtt = here->B4SOIgtempT;
10180
10181 /* v3.0 */
10182 gTte = here->B4SOIgtempe;
10183 gTtdp = - (gTtg + gTtb + gTtsp + gTte);
10184
10185 /* v3.0 */
10186 if (model->B4SOIigcMod)
10187 { gIstotg = here->B4SOIgIgsg + here->B4SOIgIgcdg;
10188 gIstotd = here->B4SOIgIgcds;
10189 gIstots = here->B4SOIgIgss + here->B4SOIgIgcdd;
10190 gIstotb = here->B4SOIgIgcdb;
10191 Istoteq = model->B4SOItype * (here->B4SOIIgs + here->B4SOIIgcd
10192 - here->B4SOIgIgsg * vgs - here->B4SOIgIgcdg * vgd
10193 + here->B4SOIgIgcdd * vds - here->B4SOIgIgcdb * vbd);
10194
10195 gIdtotg = here->B4SOIgIgdg + here->B4SOIgIgcsg;
10196 gIdtotd = here->B4SOIgIgdd + here->B4SOIgIgcss;
10197 gIdtots = here->B4SOIgIgcsd;
10198 gIdtotb = here->B4SOIgIgcsb;
10199 Idtoteq = model->B4SOItype * (here->B4SOIIgd + here->B4SOIIgcs
10200 - (here->B4SOIgIgdg + here->B4SOIgIgcsg) * vgd
10201 + here->B4SOIgIgcsd * vds - here->B4SOIgIgcsb * vbd);
10202
10203 gIgtotg = gIstotg + gIdtotg;
10204 gIgtotd = gIstotd + gIdtotd;
10205 gIgtots = gIstots + gIdtots;
10206 gIgtotb = gIstotb + gIdtotb;
10207 Igtoteq = Istoteq + Idtoteq;
10208
10209 }
10210 else
10211 { gIstotg = gIstotd = gIstots = gIstotb = Istoteq = 0.0;
10212 gIdtotg = gIdtotd = gIdtots = gIdtotb = Idtoteq = 0.0;
10213
10214 gIgtotg = gIgtotd = gIgtots = gIgtotb = Igtoteq = 0.0;
10215 }
10216
10217 /* v3.1 added for RF */
10218 if (here->B4SOIrgateMod == 2)
10219 T0 = vges - vgs;
10220 else if (here->B4SOIrgateMod == 3)
10221 T0 = vgms - vgs;
10222 if (here->B4SOIrgateMod > 1)
10223 {
10224 gcrgd = here->B4SOIgcrgs * T0;
10225 gcrgg = here->B4SOIgcrgg * T0;
10226 gcrgs = here->B4SOIgcrgd * T0;
10227 gcrgb = here->B4SOIgcrgb * T0;
10228 ceqgcrg = -(gcrgg * vgd - gcrgs * vds
10229 + gcrgb * vbd);
10230 gcrgg -= here->B4SOIgcrg;
10231 gcrg = here->B4SOIgcrg;
10232 }
10233 else
10234 ceqgcrg = gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0;
10235 /* v3.1 added for RF end */
10236
10237 } /* end of soimod<0 */
10238
10239
10240 if (model->B4SOIrdsMod == 1)
10241 { ceqgstot = model->B4SOItype * (here->B4SOIgstotd * vds
10242 + here->B4SOIgstotg * vgs + here->B4SOIgstotb * vbs);
10243 /* ceqgstot flowing away from sNodePrime */
10244 gstot = here->B4SOIgstot;
10245 gstotd = here->B4SOIgstotd;
10246 gstotg = here->B4SOIgstotg;
10247 gstots = here->B4SOIgstots - gstot;
10248 gstotb = here->B4SOIgstotb;
10249
10250 ceqgdtot = -model->B4SOItype * (here->B4SOIgdtotd * vds
10251 + here->B4SOIgdtotg * vgs + here->B4SOIgdtotb * vbs);
10252 /* ceqgdtot defined as flowing into dNodePrime */
10253 gdtot = here->B4SOIgdtot;
10254 gdtotd = here->B4SOIgdtotd - gdtot;
10255 gdtotg = here->B4SOIgdtotg;
10256 gdtots = here->B4SOIgdtots;
10257 gdtotb = here->B4SOIgdtotb;
10258 }
10259 else
10260 { gstot = gstotd = gstotg = gstots
10261 = gstotb = ceqgstot = 0.0;
10262 gdtot = gdtotd = gdtotg = gdtots
10263 = gdtotb = ceqgdtot = 0.0;
10264 }
10265
10266 if (model->B4SOItype < 0)
10267 {
10268 ceqbodcon = -ceqbodcon;
10269 ceqbody = -ceqbody;
10270 ceqgate = -ceqgate;
10271 ceqbs = -ceqbs;
10272 ceqbd = -ceqbd;
10273 ceqqg = -ceqqg;
10274 ceqqb = -ceqqb;
10275 ceqqd = -ceqqd;
10276 ceqqe = -ceqqe;
10277 cdbdp = - cdbdp; /* v4.0 */
10278 csbsp = - csbsp; /* v4.0 */
10279
10280
10281 ceqgcrg = -ceqgcrg; /* v3.1 */
10282 if (here->B4SOIrgateMod == 3)
10283 ceqqgmid = -ceqqgmid;
10284
10285 if (here->B4SOIrbodyMod) /* v4.0 */
10286 { ceqqjs = -ceqqjs;
10287 ceqqjd = -ceqqjd;
10288 }
10289
10290 }
10291
10292 m = here->B4SOIm;
10293
10294 /* v3.1 */
10295
10296 #ifndef USE_OMP
10297 /* v3.1 added ceqgcrg for RF */
10298 (*(ckt->CKTrhs + here->B4SOIgNode) -= m * ((ceqgate + ceqqg)
10299 + Igtoteq - ceqgcrg));
10300 /* v3.1 added ceqgcrg for RF end */
10301
10302 (*(ckt->CKTrhs + here->B4SOIdNodePrime) += m * ((ceqbd - cdreq
10303 - ceqqd) + Idtoteq
10304 /* v4.0 */ + ceqgdtot));
10305 if (!here->B4SOIrbodyMod) {
10306 (*(ckt->CKTrhs + here->B4SOIsNodePrime) += m * ((cdreq + ceqbs
10307 + ceqqg + ceqqb + ceqqd + ceqqe) + Istoteq
10308 + ceqqgmid - ceqgstot)); /* v4.0 */
10309 }
10310 else { /* v4.0 */
10311 (*(ckt->CKTrhs + here->B4SOIsNodePrime) += m * ((cdreq + ceqbs
10312 + ceqqg + ceqqb + ceqqd + ceqqe) + Istoteq
10313 + ceqqgmid + ceqqjd + ceqqjs - ceqgstot));
10314 }
10315
10316 (*(ckt->CKTrhs + here->B4SOIeNode) -= m * ceqqe);
10317
10318 if (here->B4SOIrgateMod == 2)
10319 (*(ckt->CKTrhs + here->B4SOIgNodeExt) -= m * ceqgcrg);
10320 else if (here->B4SOIrgateMod == 3)
10321 (*(ckt->CKTrhs + here->B4SOIgNodeMid) -= m * (ceqqgmid
10322 + ceqgcrg));
10323
10324 if (here->B4SOIbodyMod == 1) {
10325 (*(ckt->CKTrhs + here->B4SOIpNode) += m * ceqbodcon);
10326 }
10327
10328 if ( here->B4SOIsoiMod != 2 )
10329 {if (!here->B4SOIrbodyMod)
10330 (*(ckt->CKTrhs + here->B4SOIbNode) -= m * (ceqbody + ceqqb));
10331 else /* v4.0 */
10332 { (*(ckt->CKTrhs + here->B4SOIdbNode) -= m * (cdbdp + ceqqjd));
10333 (*(ckt->CKTrhs + here->B4SOIbNode) -= m * (ceqbody + ceqqb));
10334 (*(ckt->CKTrhs + here->B4SOIsbNode) -= m * (csbsp + ceqqjs));
10335 }
10336 }
10337
10338 if (selfheat) {
10339 (*(ckt->CKTrhs + here->B4SOItempNode) -= m * (ceqth + ceqqth));
10340 }
10341
10342 if (model->B4SOIrdsMod)
10343 { (*(ckt->CKTrhs + here->B4SOIdNode) -= m * ceqgdtot);
10344 (*(ckt->CKTrhs + here->B4SOIsNode) += m * ceqgstot);
10345 }
10346
10347 #else
10348 /* OpenMP parallelization:
10349 Temporary storage of right hand side values into instance storage space.
10350 Update to matrix will be done by function B4SOILoadRhsMat() only when all
10351 instances have their values stored. */
10352
10353 /* v3.1 added ceqgcrg for RF */
10354 here->B4SOINode_1 = m * ((ceqgate + ceqqg)
10355 + Igtoteq - ceqgcrg);
10356 /* v3.1 added ceqgcrg for RF end */
10357
10358 here->B4SOINode_2 = m * ((ceqbd - cdreq
10359 - ceqqd) + Idtoteq
10360 /* v4.0 */ + ceqgdtot);
10361 if (!here->B4SOIrbodyMod) {
10362 here->B4SOINode_3 = m * ((cdreq + ceqbs
10363 + ceqqg + ceqqb + ceqqd + ceqqe) + Istoteq
10364 + ceqqgmid - ceqgstot); /* v4.0 */
10365 }
10366 else { /* v4.0 */
10367 here->B4SOINode_4 = m * ((cdreq + ceqbs
10368 + ceqqg + ceqqb + ceqqd + ceqqe) + Istoteq
10369 + ceqqgmid + ceqqjd + ceqqjs - ceqgstot);
10370 }
10371
10372 here->B4SOINode_5 = m * ceqqe;
10373
10374 if (here->B4SOIrgateMod == 2)
10375 here->B4SOINode_6 = m * ceqgcrg;
10376 else if (here->B4SOIrgateMod == 3)
10377 here->B4SOINode_7 = m * (ceqqgmid
10378 + ceqgcrg);
10379
10380 if (here->B4SOIbodyMod == 1) {
10381 here->B4SOINode_8 = m * ceqbodcon;
10382 }
10383
10384 if ( here->B4SOIsoiMod != 2 )
10385 {if (!here->B4SOIrbodyMod)
10386 here->B4SOINode_9 = m * (ceqbody + ceqqb);
10387 else /* v4.0 */ {
10388 here->B4SOINode_10 = m * (cdbdp + ceqqjd);
10389 here->B4SOINode_11 = m * (ceqbody + ceqqb);
10390 here->B4SOINode_12 = m * (csbsp + ceqqjs);
10391 }
10392 }
10393 here->B4SOINode_sh = selfheat;
10394
10395 if (selfheat) {
10396 here->B4SOINode_13 = m * (ceqth + ceqqth);
10397 }
10398
10399 if (model->B4SOIrdsMod)
10400 { here->B4SOINode_14 = m * ceqgdtot;
10401 here->B4SOINode_15 = m * ceqgstot;
10402 }
10403
10404 #endif
10405 if (here->B4SOIdebugMod != 0)
10406 {
10407 *(ckt->CKTrhs + here->B4SOIvbsNode) = here->B4SOIvbseff;
10408 *(ckt->CKTrhs + here->B4SOIidsNode) = FLOG(here->B4SOIids);
10409 *(ckt->CKTrhs + here->B4SOIicNode) = FLOG(here->B4SOIic);
10410 *(ckt->CKTrhs + here->B4SOIibsNode) = FLOG(here->B4SOIibs);
10411 *(ckt->CKTrhs + here->B4SOIibdNode) = FLOG(here->B4SOIibd);
10412 *(ckt->CKTrhs + here->B4SOIiiiNode) = FLOG(here->B4SOIiii);
10413 *(ckt->CKTrhs + here->B4SOIigNode) = here->B4SOIig;
10414 *(ckt->CKTrhs + here->B4SOIgiggNode) = here->B4SOIgigg;
10415 *(ckt->CKTrhs + here->B4SOIgigdNode) = here->B4SOIgigd;
10416 *(ckt->CKTrhs + here->B4SOIgigbNode) = here->B4SOIgigb;
10417 *(ckt->CKTrhs + here->B4SOIigidlNode) = here->B4SOIigidl;
10418 *(ckt->CKTrhs + here->B4SOIitunNode) = here->B4SOIitun;
10419 *(ckt->CKTrhs + here->B4SOIibpNode) = here->B4SOIibp;
10420 *(ckt->CKTrhs + here->B4SOIcbbNode) = here->B4SOIcbb;
10421 *(ckt->CKTrhs + here->B4SOIcbdNode) = here->B4SOIcbd;
10422 *(ckt->CKTrhs + here->B4SOIcbgNode) = here->B4SOIcbg;
10423 *(ckt->CKTrhs + here->B4SOIqbfNode) = here->B4SOIqbf;
10424 *(ckt->CKTrhs + here->B4SOIqjsNode) = here->B4SOIqjs;
10425 *(ckt->CKTrhs + here->B4SOIqjdNode) = here->B4SOIqjd;
10426
10427 }
10428
10429 if (!model->B4SOIrdsMod)
10430 { gdpr = here->B4SOIdrainConductance;
10431 gspr = here->B4SOIsourceConductance;
10432 }
10433 else
10434 gdpr = gspr = 0.0; /* v4.0 */
10435
10436 /*
10437 * load y matrix
10438 */
10439 Gmin = ckt->CKTgmin * 1e-6;
10440
10441 /* v3.1 added for RF */
10442 geltd = here->B4SOIgrgeltd;
10443
10444 #ifndef USE_OMP
10445 if (here->B4SOIrgateMod == 1)
10446 {
10447 *(here->B4SOIGEgePtr) += m * geltd;
10448 *(here->B4SOIGgePtr) -= m * geltd;
10449 *(here->B4SOIGEgPtr) -= m * geltd;
10450 }
10451 else if (here->B4SOIrgateMod == 2)
10452 {
10453 *(here->B4SOIGEgePtr) += m * gcrg;
10454 *(here->B4SOIGEgPtr) += m * gcrgg;
10455 *(here->B4SOIGEdpPtr) += m * gcrgd;
10456 *(here->B4SOIGEspPtr) += m * gcrgs;
10457 *(here->B4SOIGgePtr) -= m * gcrg;
10458 if (here->B4SOIsoiMod !=2) /* v3.2 */
10459 *(here->B4SOIGEbPtr) += m * gcrgb;
10460 }
10461 else if (here->B4SOIrgateMod == 3)
10462 {
10463 *(here->B4SOIGEgePtr) += m * geltd;
10464 *(here->B4SOIGEgmPtr) -= m * geltd;
10465 *(here->B4SOIGMgePtr) -= m * geltd;
10466 *(here->B4SOIGMgmPtr) += m * (geltd + gcrg + gcgmgmb);
10467
10468 *(here->B4SOIGMdpPtr) += m * (gcrgd + gcgmdb);
10469 *(here->B4SOIGMgPtr) += m * gcrgg;
10470 *(here->B4SOIGMspPtr) += m * (gcrgs + gcgmsb);
10471 *(here->B4SOIGMePtr) += m * gcgmeb;
10472 if (here->B4SOIsoiMod !=2) /* v3.2 */
10473 *(here->B4SOIGMbPtr) += m * gcrgb;
10474
10475 *(here->B4SOIDPgmPtr) += m * gcdgmb;
10476 *(here->B4SOIGgmPtr) -= m * gcrg;
10477 *(here->B4SOISPgmPtr) += m * gcsgmb;
10478 *(here->B4SOIEgmPtr) += m * gcegmb;
10479 }
10480 /* v3.1 added for RF end*/
10481
10482
10483 /* v3.0 */
10484 if (here->B4SOIsoiMod != 0) /* v3.2 */
10485 {
10486 (*(here->B4SOIDPePtr) += m * (Gme + gddpe));
10487 (*(here->B4SOISPePtr) += m * (gsspe - Gme));
10488
10489 if (here->B4SOIsoiMod != 2) /* v3.2 */
10490 {
10491 *(here->B4SOIGePtr) += m * gige;
10492 *(here->B4SOIBePtr) -= m * gige;
10493 }
10494 }
10495
10496 *(here->B4SOIEdpPtr) += m * gcedb;
10497 *(here->B4SOIEspPtr) += m * gcesb;
10498 *(here->B4SOIDPePtr) += m * gcdeb;
10499 *(here->B4SOISPePtr) += m * gcseb;
10500 *(here->B4SOIEgPtr) += m * gcegb;
10501 *(here->B4SOIGePtr) += m * gcgeb;
10502
10503 /* v3.1 */
10504 if (here->B4SOIsoiMod != 2) /* v3.2 */
10505 {
10506 (*(here->B4SOIEbPtr) -= m * (gcegb + gcedb + gcesb + gceeb + gcegmb)); /* 3.2 bug fix */
10507
10508 /* v3.1 changed GbPtr for RF */
10509 if ((here->B4SOIrgateMod == 0) || (here->B4SOIrgateMod == 1))
10510 (*(here->B4SOIGbPtr) -= m * (-gigb + gcggb + gcgdb + gcgsb
10511 + gcgeb - gIgtotb));
10512 else /* v3.1 for rgateMod = 2 or 3 */
10513 *(here->B4SOIGbPtr) += m * (gigb + gcgbb +gIgtotb - gcrgb);
10514
10515
10516 (*(here->B4SOIDPbPtr) -= m * (-gddpb - Gmbs - gcdbb + gdtotb
10517 + gIdtotb )); /* v4.0 */
10518
10519 /* (*(here->B4SOIDPbPtr) -= (-gddpb - Gmbs + gcdgb + gcddb
10520 + gcdeb + gcdsb) + gcdgmb
10521 + gIdtotb );
10522 */
10523
10524 (*(here->B4SOISPbPtr) -= m * (-gsspb + Gmbs - gcsbb + gstotb
10525 + Gmin + gIstotb)); /* v4.0 */
10526
10527 /* (*(here->B4SOISPbPtr) -= (-gsspb + Gmbs + gcsgb + gcsdb
10528 + gcseb + gcssb) + gcsgmb
10529 + Gmin + gIstotb);
10530 */
10531 (*(here->B4SOIBePtr) += m * (gbbe + gcbeb)); /* v3.0 */
10532 (*(here->B4SOIBgPtr) += m * (-gigg + gcbgb + gbbg));
10533 (*(here->B4SOIBdpPtr) += m * (-gigd + gcbdb + gbbdp ));
10534
10535 (*(here->B4SOIBspPtr) += m * (gcbsb + gbbsp - Gmin
10536 - gigs));
10537 /* if (!here->B4SOIrbodyMod)
10538 */
10539 (*(here->B4SOIBbPtr) += m * (-gigb + gbbb - gcbgb - gcbdb
10540 - gcbsb - gcbeb + Gmin)) ;
10541 /* else
10542 (*(here->B4SOIBbPtr) += -gigb - (Giib - Gbpbs) - gcbgb
10543 - gcbdb - gcbsb - gcbeb + Gmin) ;
10544 */
10545 /* v4.0 */
10546 if (here->B4SOIrbodyMod) {
10547 (*(here->B4SOIDPdbPtr) += m * (-gcjdbdp - GGjdb));
10548 (*(here->B4SOISPsbPtr) += m * (-gcjsbsp - GGjsb));
10549 (*(here->B4SOIDBdpPtr) += m * (-gcjdbdp - GGjdb));
10550 (*(here->B4SOIDBdbPtr) += m * (gcjdbdp + GGjdb
10551 + here->B4SOIgrbdb));
10552 (*(here->B4SOIDBbPtr) -= m * here->B4SOIgrbdb);
10553 (*(here->B4SOISBspPtr) += m * (-gcjsbsp - GGjsb));
10554 (*(here->B4SOISBbPtr) -= m * here->B4SOIgrbsb);
10555 (*(here->B4SOISBsbPtr) += m * (gcjsbsp + GGjsb
10556 + here->B4SOIgrbsb));
10557 (*(here->B4SOIBdbPtr) -= m * here->B4SOIgrbdb);
10558 (*(here->B4SOIBsbPtr) -= m * here->B4SOIgrbsb);
10559 (*(here->B4SOIBbPtr) += m * (here->B4SOIgrbsb
10560 + here->B4SOIgrbdb));
10561 }
10562 if (model->B4SOIrdsMod)
10563 {
10564 (*(here->B4SOIDbPtr) += m * gdtotb);
10565 (*(here->B4SOISbPtr) += m * gstotb);
10566 }
10567
10568 }
10569 /* v3.1 */
10570 if (model->B4SOIrdsMod)
10571 { (*(here->B4SOIDgPtr) += m * gdtotg);
10572 (*(here->B4SOIDspPtr) += m * gdtots);
10573 (*(here->B4SOISdpPtr) += m * gstotd);
10574 (*(here->B4SOISgPtr) += m * gstotg);
10575 }
10576
10577 (*(here->B4SOIEePtr) += m * gceeb);
10578
10579 if (here->B4SOIrgateMod == 0)
10580 {
10581 (*(here->B4SOIGgPtr) += m * (gigg + gcggb + Gmin
10582 + gIgtotg));
10583 (*(here->B4SOIGdpPtr) += m * (gigd + gcgdb - Gmin
10584 + gIgtotd));
10585 (*(here->B4SOIGspPtr) += m * (gcgsb + gigs + gIgtots));
10586 }
10587 else if (here->B4SOIrgateMod == 1) /* v3.1 for RF */
10588 {
10589 *(here->B4SOIGgPtr) += m * (gigg + gcggb + Gmin
10590 + gIgtotg + geltd);
10591 *(here->B4SOIGdpPtr) += m * (gigd + gcgdb - Gmin
10592 + gIgtotd);
10593 *(here->B4SOIGspPtr) += m * (gcgsb + gigs + gIgtots);
10594 }
10595 else /* v3.1 for RF rgateMod == 2 or 3 */
10596 {
10597 *(here->B4SOIGgPtr) += m * (gigg + gcggb + Gmin
10598 + gIgtotg - gcrgg);
10599 *(here->B4SOIGdpPtr) += m * (gigd + gcgdb - Gmin
10600 + gIgtotd - gcrgd);
10601 *(here->B4SOIGspPtr) += m * (gcgsb + gigs + gIgtots - gcrgs);
10602 }
10603
10604
10605 (*(here->B4SOIDPgPtr) += m * ((Gm + gcdgb) + gddpg - Gmin
10606 - gIdtotg - gdtotg)); /* v4.0 */
10607 (*(here->B4SOIDPdpPtr) += m * ((gdpr + here->B4SOIgds + gddpdp
10608 + RevSum + gcddb) + Gmin
10609 - gIdtotd - gdtotd)); /* v4.0 */
10610 (*(here->B4SOIDPspPtr) -= m * ((-gddpsp + here->B4SOIgds + FwdSum
10611 - gcdsb) + gIdtots + gdtots));
10612
10613 (*(here->B4SOIDPdPtr) -= m * (gdpr + gdtot));
10614
10615 (*(here->B4SOISPgPtr) += m * (gcsgb - Gm + gsspg - gIstotg
10616 - gstotg)); /* v4.0 */
10617 (*(here->B4SOISPdpPtr) -= m * ((here->B4SOIgds - gsspdp + RevSum
10618 - gcsdb + gIstotd) + gstotd)); /* v4.0 */
10619
10620 (*(here->B4SOISPspPtr) += m * ((gspr - gstots
10621 + here->B4SOIgds + gsspsp
10622 + FwdSum + gcssb)
10623 + Gmin - gIstots)); /* v4.0 */
10624
10625 (*(here->B4SOISPsPtr) -= m * (gspr + gstot));
10626
10627
10628 (*(here->B4SOIDdPtr) += m * (gdpr + gdtot));
10629 (*(here->B4SOIDdpPtr) -= m * (gdpr - gdtotd));
10630
10631
10632 (*(here->B4SOISsPtr) += m * (gspr + gstot));
10633 (*(here->B4SOISspPtr) -= m * (gspr - gstots));
10634
10635
10636 if (here->B4SOIbodyMod == 1) {
10637 (*(here->B4SOIBpPtr) -= m * gppp);
10638 (*(here->B4SOIPbPtr) += m * gppb);
10639 (*(here->B4SOIPpPtr) += m * gppp);
10640 }
10641
10642 /* v4.1 Ig_agbcp2 stamping */
10643 (*(here->B4SOIGgPtr) += m * gigpg);
10644 if (here->B4SOIbodyMod == 1) {
10645 (*(here->B4SOIPpPtr) -= m * gigpp);
10646 (*(here->B4SOIPgPtr) -= m * gigpg);
10647 (*(here->B4SOIGpPtr) += m * gigpp);
10648 }
10649 else if(here->B4SOIbodyMod == 2)
10650 {
10651 (*(here->B4SOIBbPtr) -= m * gigpp);
10652 (*(here->B4SOIBgPtr) -= m * gigpg);
10653 (*(here->B4SOIGbPtr) += m * gigpp);
10654 }
10655
10656
10657 if (selfheat)
10658 {
10659 (*(here->B4SOIDPtempPtr) += m * (GmT + gddpT + gcdT));
10660 (*(here->B4SOISPtempPtr) += m * (-GmT + gsspT + gcsT));
10661 (*(here->B4SOIBtempPtr) += m * (gbbT + gcbT - gigT));
10662 (*(here->B4SOIEtempPtr) += m * gceT);
10663 (*(here->B4SOIGtempPtr) += m * (gcgT + gigT));
10664 (*(here->B4SOITemptempPtr) += m * (gTtt + 1/pParam->B4SOIrth + gcTt));
10665 (*(here->B4SOITempgPtr) += m * gTtg);
10666 (*(here->B4SOITempbPtr) += m * gTtb);
10667 (*(here->B4SOITempdpPtr) += m * gTtdp);
10668 (*(here->B4SOITempspPtr) += m * gTtsp);
10669
10670 /* v3.0 */
10671 if (here->B4SOIsoiMod != 0) /* v3.2 */
10672 (*(here->B4SOITempePtr) += m * gTte);
10673
10674 }
10675 #else
10676 /* OpenMP parallelization:
10677 Temporary storage of matrix values into instance storage space.
10678 Update to matrix will be done by function B4SOILoadRhsMat() only when all
10679 instances have their values stored. */
10680
10681 if (here->B4SOIrgateMod == 1)
10682 {
10683 here->B4SOI_1 = m * geltd;
10684 here->B4SOI_2 = m * geltd;
10685 here->B4SOI_3 = m * geltd;
10686 }
10687 else if (here->B4SOIrgateMod == 2)
10688 {
10689 here->B4SOI_4 = m * gcrg;
10690 here->B4SOI_5 = m * gcrgg;
10691 here->B4SOI_6 = m * gcrgd;
10692 here->B4SOI_7 = m * gcrgs;
10693 here->B4SOI_8 = m * gcrg;
10694 if (here->B4SOIsoiMod !=2) /* v3.2 */
10695 here->B4SOI_9 = m * gcrgb;
10696 }
10697 else if (here->B4SOIrgateMod == 3)
10698 {
10699 here->B4SOI_10 = m * geltd;
10700 here->B4SOI_11 = m * geltd;
10701 here->B4SOI_12 = m * geltd;
10702 here->B4SOI_13 = m * (geltd + gcrg + gcgmgmb);
10703
10704 here->B4SOI_14 = m * (gcrgd + gcgmdb);
10705 here->B4SOI_15 = m * gcrgg;
10706 here->B4SOI_16 = m * (gcrgs + gcgmsb);
10707 here->B4SOI_17 = m * gcgmeb;
10708 if (here->B4SOIsoiMod !=2) /* v3.2 */
10709 here->B4SOI_18 = m * gcrgb;
10710
10711 here->B4SOI_19 = m * gcdgmb;
10712 here->B4SOI_20 = m * gcrg;
10713 here->B4SOI_21 = m * gcsgmb;
10714 here->B4SOI_22 = m * gcegmb;
10715 }
10716 /* v3.1 added for RF end*/
10717
10718
10719 /* v3.0 */
10720 if (here->B4SOIsoiMod != 0) /* v3.2 */
10721 {
10722 here->B4SOI_23 = m * (Gme + gddpe);
10723 here->B4SOI_24 = m * (gsspe - Gme);
10724
10725 if (here->B4SOIsoiMod != 2) /* v3.2 */
10726 {
10727 here->B4SOI_25 = m * gige;
10728 here->B4SOI_26 = m * gige;
10729 }
10730 }
10731
10732 here->B4SOI_27 = m * gcedb;
10733 here->B4SOI_28 = m * gcesb;
10734 here->B4SOI_29 = m * gcdeb;
10735 here->B4SOI_30 = m * gcseb;
10736 here->B4SOI_31 = m * gcegb;
10737 here->B4SOI_32 = m * gcgeb;
10738
10739 /* v3.1 */
10740 if (here->B4SOIsoiMod != 2) /* v3.2 */
10741 {
10742 here->B4SOI_33 = m * (gcegb + gcedb + gcesb + gceeb + gcegmb); /* 3.2 bug fix */
10743
10744 /* v3.1 changed GbPtr for RF */
10745 if ((here->B4SOIrgateMod == 0) || (here->B4SOIrgateMod == 1))
10746 (here->B4SOI_34 = m * (-gigb + gcggb + gcgdb + gcgsb
10747 + gcgeb - gIgtotb));
10748 else /* v3.1 for rgateMod = 2 or 3 */
10749 here->B4SOI_35 = m * (gigb + gcgbb +gIgtotb - gcrgb);
10750
10751
10752 here->B4SOI_36 = m * (-gddpb - Gmbs - gcdbb + gdtotb
10753 + gIdtotb ); /* v4.0 */
10754
10755 /* (*(here->B4SOIDPbPtr) -= (-gddpb - Gmbs + gcdgb + gcddb
10756 + gcdeb + gcdsb) + gcdgmb
10757 + gIdtotb );
10758 */
10759
10760 (here->B4SOI_37 = m * (-gsspb + Gmbs - gcsbb + gstotb
10761 + Gmin + gIstotb)); /* v4.0 */
10762
10763 /* (*(here->B4SOISPbPtr) -= (-gsspb + Gmbs + gcsgb + gcsdb
10764 + gcseb + gcssb) + gcsgmb
10765 + Gmin + gIstotb);
10766 */
10767 (here->B4SOI_38 = m * (gbbe + gcbeb)); /* v3.0 */
10768 (here->B4SOI_39 = m * (-gigg + gcbgb + gbbg));
10769 (here->B4SOI_40 = m * (-gigd + gcbdb + gbbdp));
10770
10771 (here->B4SOI_41 = m * (gcbsb + gbbsp - Gmin
10772 - gigs));
10773 /* if (!here->B4SOIrbodyMod)
10774 */
10775 (here->B4SOI_42 = m * (-gigb + gbbb - gcbgb - gcbdb
10776 - gcbsb - gcbeb + Gmin));
10777 /* else
10778 (*(here->B4SOIBbPtr) += -gigb - (Giib - Gbpbs) - gcbgb
10779 - gcbdb - gcbsb - gcbeb + Gmin) ;
10780 */
10781 /* v4.0 */
10782 if (here->B4SOIrbodyMod) {
10783 (here->B4SOI_43 = m * (-gcjdbdp - GGjdb));
10784 (here->B4SOI_44 = m * (-gcjsbsp - GGjsb));
10785 (here->B4SOI_45 = m * (-gcjdbdp - GGjdb));
10786 (here->B4SOI_46 = m * (gcjdbdp + GGjdb
10787 + here->B4SOIgrbdb));
10788 (here->B4SOI_47 = m * here->B4SOIgrbdb);
10789 (here->B4SOI_48 = m * (-gcjsbsp - GGjsb));
10790 (here->B4SOI_49 = m * here->B4SOIgrbsb);
10791 (here->B4SOI_50 = m * (gcjsbsp + GGjsb
10792 + here->B4SOIgrbsb));
10793 (here->B4SOI_51 = m * here->B4SOIgrbdb);
10794 (here->B4SOI_52 = m * here->B4SOIgrbsb);
10795 (here->B4SOI_53 = m * (here->B4SOIgrbsb
10796 + here->B4SOIgrbdb));
10797 }
10798 if (model->B4SOIrdsMod)
10799 {
10800 (here->B4SOI_54 = m * gdtotb);
10801 (here->B4SOI_55 = m * gstotb);
10802 }
10803
10804 }
10805 /* v3.1 */
10806 if (model->B4SOIrdsMod)
10807 { (here->B4SOI_56 = m * gdtotg);
10808 (here->B4SOI_57 = m * gdtots);
10809 (here->B4SOI_58 = m * gstotd);
10810 (here->B4SOI_59 = m * gstotg);
10811 }
10812
10813 (here->B4SOI_60 = m * gceeb);
10814
10815 if (here->B4SOIrgateMod == 0)
10816 {
10817 (here->B4SOI_61 = m * (gigg + gcggb + Gmin
10818 + gIgtotg));
10819 (here->B4SOI_62 =m * ( gigd + gcgdb - Gmin
10820 + gIgtotd));
10821 (here->B4SOI_63 = m * (gcgsb + gigs + gIgtots));
10822 }
10823 else if (here->B4SOIrgateMod == 1) /* v3.1 for RF */
10824 {
10825 here->B4SOI_64 = m * (gigg + gcggb + Gmin
10826 + gIgtotg + geltd);
10827 here->B4SOI_65 = m * (gigd + gcgdb - Gmin
10828 + gIgtotd);
10829 here->B4SOI_66 = m * (gcgsb + gigs + gIgtots);
10830 }
10831 else /* v3.1 for RF rgateMod == 2 or 3 */
10832 {
10833 here->B4SOI_67 = m * (gigg + gcggb + Gmin
10834 + gIgtotg - gcrgg);
10835 here->B4SOI_68 = m * (gigd + gcgdb - Gmin
10836 + gIgtotd - gcrgd);
10837 here->B4SOI_69 = m * (gcgsb + gigs + gIgtots - gcrgs);
10838 }
10839
10840
10841 (here->B4SOI_70 = m * ((Gm + gcdgb) + gddpg - Gmin
10842 - gIdtotg - gdtotg)); /* v4.0 */
10843 (here->B4SOI_71 = m * ((gdpr + here->B4SOIgds + gddpdp
10844 + RevSum + gcddb) + Gmin
10845 - gIdtotd - gdtotd)); /* v4.0 */
10846 (here->B4SOI_72 = m * ((-gddpsp + here->B4SOIgds + FwdSum
10847 - gcdsb) + gIdtots + gdtots));
10848
10849 (here->B4SOI_73 = m * (gdpr + gdtot));
10850
10851 (here->B4SOI_74 = m * (gcsgb - Gm + gsspg - gIstotg
10852 - gstotg)); /* v4.0 */
10853 (here->B4SOI_75 = m * ((here->B4SOIgds - gsspdp + RevSum
10854 - gcsdb + gIstotd) + gstotd)); /* v4.0 */
10855
10856 (here->B4SOI_76 = m * ((gspr - gstots
10857 + here->B4SOIgds + gsspsp
10858 + FwdSum + gcssb)
10859 + Gmin - gIstots)); /* v4.0 */
10860
10861 (here->B4SOI_77 = m * (gspr + gstot));
10862
10863
10864 (here->B4SOI_78 = m * (gdpr + gdtot));
10865 (here->B4SOI_79 = m * (gdpr - gdtotd));
10866
10867
10868 (here->B4SOI_80 = m * (gspr + gstot));
10869 (here->B4SOI_81 = m * (gspr - gstots));
10870
10871
10872 if (here->B4SOIbodyMod == 1) {
10873 (here->B4SOI_82 = m * gppp);
10874 (here->B4SOI_83 = m * gppb);
10875 (here->B4SOI_84 = m * gppp);
10876 }
10877
10878 /* v4.1 Ig_agbcp2 stamping */
10879 (here->B4SOI_85 = m * gigpg); /* FIXME m or not m ?? h_vogt */
10880 if (here->B4SOIbodyMod == 1) {
10881 (here->B4SOI_86 = m * gigpp);
10882 (here->B4SOI_87 = m * gigpg);
10883 (here->B4SOI_88 = m * gigpp);
10884 }
10885 else if(here->B4SOIbodyMod == 2)
10886 {
10887 (here->B4SOI_89 = m * gigpp);
10888 (here->B4SOI_90 = m * gigpg);
10889 (here->B4SOI_91 = m * gigpp);
10890 }
10891
10892
10893 if (selfheat)
10894 {
10895 (here->B4SOI_92 = m * (GmT + gddpT + gcdT));
10896 (here->B4SOI_93 = m * (-GmT + gsspT + gcsT));
10897 (here->B4SOI_94 = m * (gbbT + gcbT - gigT));
10898 (here->B4SOI_95 = m * gceT);
10899 (here->B4SOI_96 = m * (gcgT + gigT));
10900 (here->B4SOI_97 = m * (gTtt + 1/pParam->B4SOIrth + gcTt));
10901 (here->B4SOI_98 = m * gTtg);
10902 (here->B4SOI_99 = m * gTtb);
10903 (here->B4SOI_100 = m * gTtdp);
10904 (here->B4SOI_101 = m * gTtsp);
10905
10906 /* v3.0 */
10907 if (here->B4SOIsoiMod != 0) /* v3.2 */
10908 (here->B4SOI_102 = m * gTte);
10909
10910 }
10911 #endif
10912 if (here->B4SOIdebugMod != 0)
10913 {
10914 *(here->B4SOIVbsPtr) += 1;
10915 *(here->B4SOIIdsPtr) += 1;
10916 *(here->B4SOIIcPtr) += 1;
10917 *(here->B4SOIIbsPtr) += 1;
10918 *(here->B4SOIIbdPtr) += 1;
10919 *(here->B4SOIIiiPtr) += 1;
10920 *(here->B4SOIIgPtr) += 1;
10921 *(here->B4SOIGiggPtr) += 1;
10922 *(here->B4SOIGigdPtr) += 1;
10923 *(here->B4SOIGigbPtr) += 1;
10924 *(here->B4SOIIgidlPtr) += 1;
10925 *(here->B4SOIItunPtr) += 1;
10926 *(here->B4SOIIbpPtr) += 1;
10927 *(here->B4SOICbgPtr) += 1;
10928 *(here->B4SOICbbPtr) += 1;
10929 *(here->B4SOICbdPtr) += 1;
10930 *(here->B4SOIQbfPtr) += 1;
10931 *(here->B4SOIQjsPtr) += 1;
10932 *(here->B4SOIQjdPtr) += 1;
10933 }
10934
10935 line1000: ;
10936
10937 #ifndef USE_OMP
10938 } /* End of Mosfet Instance */
10939 } /* End of Model Instance */
10940 #endif
10941
10942 return(OK);
10943 }
10944
10945
10946 #ifdef USE_OMP
10947
10948 /* OpenMP parallelization:
10949 Update of right hand side and matrix values from instance temporary storage.
10950 Update to matrix will be done only when all instances of this model
10951 have their values calculated and stored. Thus there is no further
10952 synchronisation required.*/
10953
B4SOILoadRhsMat(GENmodel * inModel,CKTcircuit * ckt)10954 void B4SOILoadRhsMat(GENmodel *inModel, CKTcircuit *ckt)
10955 {
10956 int InstCount, idx;
10957 B4SOIinstance **InstArray;
10958 B4SOIinstance *here;
10959 B4SOImodel *model = (B4SOImodel*)inModel;
10960
10961 InstArray = model->B4SOIInstanceArray;
10962 InstCount = model->B4SOIInstCount;
10963
10964 for(idx = 0; idx < InstCount; idx++) {
10965 here = InstArray[idx];
10966 model = B4SOImodPtr(here);
10967 /* Update b for Ax = b */
10968
10969 /* v3.1 */
10970
10971 /* v3.1 added ceqgcrg for RF */
10972 (*(ckt->CKTrhs + here->B4SOIgNode) -= here->B4SOINode_1);
10973 /* v3.1 added ceqgcrg for RF end */
10974
10975 (*(ckt->CKTrhs + here->B4SOIdNodePrime) += here->B4SOINode_2);
10976 if (!here->B4SOIrbodyMod) {
10977 (*(ckt->CKTrhs + here->B4SOIsNodePrime) += here->B4SOINode_3); /* v4.0 */
10978 }
10979 else { /* v4.0 */
10980 (*(ckt->CKTrhs + here->B4SOIsNodePrime) += here->B4SOINode_4);
10981 }
10982
10983 (*(ckt->CKTrhs + here->B4SOIeNode) -= here->B4SOINode_5);
10984
10985 if (here->B4SOIrgateMod == 2)
10986 (*(ckt->CKTrhs + here->B4SOIgNodeExt) -= here->B4SOINode_6);
10987 else if (here->B4SOIrgateMod == 3)
10988 (*(ckt->CKTrhs + here->B4SOIgNodeMid) -= here->B4SOINode_7);
10989
10990 if (here->B4SOIbodyMod == 1) {
10991 (*(ckt->CKTrhs + here->B4SOIpNode) += here->B4SOINode_8);
10992 }
10993
10994 if ( here->B4SOIsoiMod != 2 )
10995 {if (!here->B4SOIrbodyMod)
10996 (*(ckt->CKTrhs + here->B4SOIbNode) -= here->B4SOINode_9);
10997 else /* v4.0 */
10998 { (*(ckt->CKTrhs + here->B4SOIdbNode) -= here->B4SOINode_10);
10999 (*(ckt->CKTrhs + here->B4SOIbNode) -= here->B4SOINode_11);
11000 (*(ckt->CKTrhs + here->B4SOIsbNode) -= here->B4SOINode_12);
11001 }
11002 }
11003
11004 if (here->B4SOINode_sh) {
11005 (*(ckt->CKTrhs + here->B4SOItempNode) -= here->B4SOINode_13);
11006 }
11007
11008 if (model->B4SOIrdsMod)
11009 { (*(ckt->CKTrhs + here->B4SOIdNode) -= here->B4SOINode_14);
11010 (*(ckt->CKTrhs + here->B4SOIsNode) += here->B4SOINode_15);
11011 }
11012
11013
11014 if (here->B4SOIdebugMod != 0)
11015 {
11016 *(ckt->CKTrhs + here->B4SOIvbsNode) = here->B4SOIvbseff;
11017 *(ckt->CKTrhs + here->B4SOIidsNode) = FLOG(here->B4SOIids);
11018 *(ckt->CKTrhs + here->B4SOIicNode) = FLOG(here->B4SOIic);
11019 *(ckt->CKTrhs + here->B4SOIibsNode) = FLOG(here->B4SOIibs);
11020 *(ckt->CKTrhs + here->B4SOIibdNode) = FLOG(here->B4SOIibd);
11021 *(ckt->CKTrhs + here->B4SOIiiiNode) = FLOG(here->B4SOIiii);
11022 *(ckt->CKTrhs + here->B4SOIigNode) = here->B4SOIig;
11023 *(ckt->CKTrhs + here->B4SOIgiggNode) = here->B4SOIgigg;
11024 *(ckt->CKTrhs + here->B4SOIgigdNode) = here->B4SOIgigd;
11025 *(ckt->CKTrhs + here->B4SOIgigbNode) = here->B4SOIgigb;
11026 *(ckt->CKTrhs + here->B4SOIigidlNode) = here->B4SOIigidl;
11027 *(ckt->CKTrhs + here->B4SOIitunNode) = here->B4SOIitun;
11028 *(ckt->CKTrhs + here->B4SOIibpNode) = here->B4SOIibp;
11029 *(ckt->CKTrhs + here->B4SOIcbbNode) = here->B4SOIcbb;
11030 *(ckt->CKTrhs + here->B4SOIcbdNode) = here->B4SOIcbd;
11031 *(ckt->CKTrhs + here->B4SOIcbgNode) = here->B4SOIcbg;
11032 *(ckt->CKTrhs + here->B4SOIqbfNode) = here->B4SOIqbf;
11033 *(ckt->CKTrhs + here->B4SOIqjsNode) = here->B4SOIqjs;
11034 *(ckt->CKTrhs + here->B4SOIqjdNode) = here->B4SOIqjd;
11035
11036 }
11037
11038
11039 if (here->B4SOIrgateMod == 1)
11040 {
11041 *(here->B4SOIGEgePtr) += here->B4SOI_1;
11042 *(here->B4SOIGgePtr) -= here->B4SOI_2;
11043 *(here->B4SOIGEgPtr) -= here->B4SOI_3;
11044 }
11045 else if (here->B4SOIrgateMod == 2)
11046 {
11047 *(here->B4SOIGEgePtr) += here->B4SOI_4;
11048 *(here->B4SOIGEgPtr) += here->B4SOI_5;
11049 *(here->B4SOIGEdpPtr) += here->B4SOI_6;
11050 *(here->B4SOIGEspPtr) += here->B4SOI_7;
11051 *(here->B4SOIGgePtr) -= here->B4SOI_8;
11052 if (here->B4SOIsoiMod !=2) /* v3.2 */
11053 *(here->B4SOIGEbPtr) += here->B4SOI_9;
11054 }
11055 else if (here->B4SOIrgateMod == 3)
11056 {
11057 *(here->B4SOIGEgePtr) += here->B4SOI_10;
11058 *(here->B4SOIGEgmPtr) -= here->B4SOI_11;
11059 *(here->B4SOIGMgePtr) -= here->B4SOI_12;
11060 *(here->B4SOIGMgmPtr) += here->B4SOI_13;
11061
11062 *(here->B4SOIGMdpPtr) += here->B4SOI_14;
11063 *(here->B4SOIGMgPtr) += here->B4SOI_15;
11064 *(here->B4SOIGMspPtr) += here->B4SOI_16;
11065 *(here->B4SOIGMePtr) += here->B4SOI_17;
11066 if (here->B4SOIsoiMod !=2) /* v3.2 */
11067 *(here->B4SOIGMbPtr) += here->B4SOI_18;
11068
11069 *(here->B4SOIDPgmPtr) += here->B4SOI_19;
11070 *(here->B4SOIGgmPtr) -= here->B4SOI_20;
11071 *(here->B4SOISPgmPtr) += here->B4SOI_21;
11072 *(here->B4SOIEgmPtr) += here->B4SOI_22;
11073 }
11074 /* v3.1 added for RF end*/
11075
11076
11077 /* v3.0 */
11078 if (here->B4SOIsoiMod != 0) /* v3.2 */
11079 {
11080 (*(here->B4SOIDPePtr) += here->B4SOI_23);
11081 (*(here->B4SOISPePtr) += here->B4SOI_24);
11082
11083 if (here->B4SOIsoiMod != 2) /* v3.2 */
11084 {
11085 *(here->B4SOIGePtr) += here->B4SOI_25;
11086 *(here->B4SOIBePtr) -= here->B4SOI_26;
11087 }
11088 }
11089
11090 *(here->B4SOIEdpPtr) += here->B4SOI_27;
11091 *(here->B4SOIEspPtr) += here->B4SOI_28;
11092 *(here->B4SOIDPePtr) += here->B4SOI_29;
11093 *(here->B4SOISPePtr) += here->B4SOI_30;
11094 *(here->B4SOIEgPtr) += here->B4SOI_31;
11095 *(here->B4SOIGePtr) += here->B4SOI_32;
11096
11097 /* v3.1 */
11098 if (here->B4SOIsoiMod != 2) /* v3.2 */
11099 {
11100 (*(here->B4SOIEbPtr) -= here->B4SOI_33); /* 3.2 bug fix */
11101
11102 /* v3.1 changed GbPtr for RF */
11103 if ((here->B4SOIrgateMod == 0) || (here->B4SOIrgateMod == 1))
11104 (*(here->B4SOIGbPtr) -= here->B4SOI_34);
11105 else /* v3.1 for rgateMod = 2 or 3 */
11106 *(here->B4SOIGbPtr) += here->B4SOI_35;
11107
11108
11109 (*(here->B4SOIDPbPtr) -= here->B4SOI_36); /* v4.0 */
11110
11111 /* (*(here->B4SOIDPbPtr) -= (-gddpb - Gmbs + gcdgb + gcddb
11112 + gcdeb + gcdsb) + gcdgmb
11113 + gIdtotb );
11114 */
11115
11116 (*(here->B4SOISPbPtr) -= here->B4SOI_37); /* v4.0 */
11117
11118 /* (*(here->B4SOISPbPtr) -= (-gsspb + Gmbs + gcsgb + gcsdb
11119 + gcseb + gcssb) + gcsgmb
11120 + Gmin + gIstotb);
11121 */
11122 (*(here->B4SOIBePtr) += here->B4SOI_38); /* v3.0 */
11123 (*(here->B4SOIBgPtr) += here->B4SOI_39);
11124 (*(here->B4SOIBdpPtr) += here->B4SOI_40);
11125
11126 (*(here->B4SOIBspPtr) += here->B4SOI_41);
11127 /* if (!here->B4SOIrbodyMod)
11128 */
11129 (*(here->B4SOIBbPtr) += here->B4SOI_42);
11130 /* else
11131 (*(here->B4SOIBbPtr) += -gigb - (Giib - Gbpbs) - gcbgb
11132 - gcbdb - gcbsb - gcbeb + Gmin) ;
11133 */
11134 /* v4.0 */
11135 if (here->B4SOIrbodyMod) {
11136 (*(here->B4SOIDPdbPtr) += here->B4SOI_43);
11137 (*(here->B4SOISPsbPtr) += here->B4SOI_44);
11138 (*(here->B4SOIDBdpPtr) += here->B4SOI_45);
11139 (*(here->B4SOIDBdbPtr) += here->B4SOI_46);
11140 (*(here->B4SOIDBbPtr) -= here->B4SOI_47);
11141 (*(here->B4SOISBspPtr) += here->B4SOI_48);
11142 (*(here->B4SOISBbPtr) -= here->B4SOI_49);
11143 (*(here->B4SOISBsbPtr) += here->B4SOI_50);
11144 (*(here->B4SOIBdbPtr) -= here->B4SOI_51);
11145 (*(here->B4SOIBsbPtr) -= here->B4SOI_52);
11146 (*(here->B4SOIBbPtr) += here->B4SOI_53);
11147 }
11148 if (model->B4SOIrdsMod)
11149 {
11150 (*(here->B4SOIDbPtr) += here->B4SOI_54);
11151 (*(here->B4SOISbPtr) += here->B4SOI_55);
11152 }
11153
11154 }
11155 /* v3.1 */
11156 if (model->B4SOIrdsMod)
11157 { (*(here->B4SOIDgPtr) += here->B4SOI_56);
11158 (*(here->B4SOIDspPtr) += here->B4SOI_57);
11159 (*(here->B4SOISdpPtr) += here->B4SOI_58);
11160 (*(here->B4SOISgPtr) += here->B4SOI_59);
11161 }
11162
11163 (*(here->B4SOIEePtr) += here->B4SOI_60);
11164
11165 if (here->B4SOIrgateMod == 0)
11166 {
11167 (*(here->B4SOIGgPtr) += here->B4SOI_61);
11168 (*(here->B4SOIGdpPtr) += here->B4SOI_62);
11169 (*(here->B4SOIGspPtr) += here->B4SOI_63);
11170 }
11171 else if (here->B4SOIrgateMod == 1) /* v3.1 for RF */
11172 {
11173 *(here->B4SOIGgPtr) += here->B4SOI_64;
11174 *(here->B4SOIGdpPtr) += here->B4SOI_65;
11175 *(here->B4SOIGspPtr) += here->B4SOI_66;
11176 }
11177 else /* v3.1 for RF rgateMod == 2 or 3 */
11178 {
11179 *(here->B4SOIGgPtr) += here->B4SOI_67;
11180 *(here->B4SOIGdpPtr) += here->B4SOI_68;
11181 *(here->B4SOIGspPtr) += here->B4SOI_69;
11182 }
11183
11184
11185 (*(here->B4SOIDPgPtr) += here->B4SOI_70); /* v4.0 */
11186 (*(here->B4SOIDPdpPtr) += here->B4SOI_71); /* v4.0 */
11187 (*(here->B4SOIDPspPtr) -= here->B4SOI_72);
11188
11189 (*(here->B4SOIDPdPtr) -= here->B4SOI_73);
11190
11191 (*(here->B4SOISPgPtr) += here->B4SOI_74); /* v4.0 */
11192 (*(here->B4SOISPdpPtr) -= here->B4SOI_75); /* v4.0 */
11193
11194 (*(here->B4SOISPspPtr) += here->B4SOI_76); /* v4.0 */
11195
11196 (*(here->B4SOISPsPtr) -= here->B4SOI_77);
11197
11198
11199 (*(here->B4SOIDdPtr) += here->B4SOI_78);
11200 (*(here->B4SOIDdpPtr) -= here->B4SOI_79);
11201
11202
11203 (*(here->B4SOISsPtr) += here->B4SOI_80);
11204 (*(here->B4SOISspPtr) -= here->B4SOI_81);
11205
11206
11207 if (here->B4SOIbodyMod == 1) {
11208 (*(here->B4SOIBpPtr) -= here->B4SOI_82);
11209 (*(here->B4SOIPbPtr) += here->B4SOI_83);
11210 (*(here->B4SOIPpPtr) += here->B4SOI_84);
11211 }
11212
11213 /* v4.1 Ig_agbcp2 stamping */
11214 (*(here->B4SOIGgPtr) += here->B4SOI_85); /* FIXME m or not m ?? h_vogt */
11215 if (here->B4SOIbodyMod == 1) {
11216 (*(here->B4SOIPpPtr) -= here->B4SOI_86);
11217 (*(here->B4SOIPgPtr) -= here->B4SOI_87);
11218 (*(here->B4SOIGpPtr) += here->B4SOI_88);
11219 }
11220 else if(here->B4SOIbodyMod == 2)
11221 {
11222 (*(here->B4SOIBbPtr) -= here->B4SOI_89);
11223 (*(here->B4SOIBgPtr) -= here->B4SOI_90);
11224 (*(here->B4SOIGbPtr) += here->B4SOI_91);
11225 }
11226
11227
11228 if (here->B4SOINode_sh) /* selfheat */
11229 {
11230 (*(here->B4SOIDPtempPtr) += here->B4SOI_92);
11231 (*(here->B4SOISPtempPtr) += here->B4SOI_93);
11232 (*(here->B4SOIBtempPtr) += here->B4SOI_94);
11233 (*(here->B4SOIEtempPtr) +=here->B4SOI_95);
11234 (*(here->B4SOIGtempPtr) += here->B4SOI_96);
11235 (*(here->B4SOITemptempPtr) += here->B4SOI_97);
11236 (*(here->B4SOITempgPtr) += here->B4SOI_98);
11237 (*(here->B4SOITempbPtr) += here->B4SOI_99);
11238 (*(here->B4SOITempdpPtr) += here->B4SOI_100);
11239 (*(here->B4SOITempspPtr) += here->B4SOI_101);
11240
11241 /* v3.0 */
11242 if (here->B4SOIsoiMod != 0) /* v3.2 */
11243 (*(here->B4SOITempePtr) += here->B4SOI_102);
11244
11245 }
11246
11247
11248
11249 if (here->B4SOIdebugMod != 0)
11250 {
11251 *(here->B4SOIVbsPtr) += 1;
11252 *(here->B4SOIIdsPtr) += 1;
11253 *(here->B4SOIIcPtr) += 1;
11254 *(here->B4SOIIbsPtr) += 1;
11255 *(here->B4SOIIbdPtr) += 1;
11256 *(here->B4SOIIiiPtr) += 1;
11257 *(here->B4SOIIgPtr) += 1;
11258 *(here->B4SOIGiggPtr) += 1;
11259 *(here->B4SOIGigdPtr) += 1;
11260 *(here->B4SOIGigbPtr) += 1;
11261 *(here->B4SOIIgidlPtr) += 1;
11262 *(here->B4SOIItunPtr) += 1;
11263 *(here->B4SOIIbpPtr) += 1;
11264 *(here->B4SOICbgPtr) += 1;
11265 *(here->B4SOICbbPtr) += 1;
11266 *(here->B4SOICbdPtr) += 1;
11267 *(here->B4SOIQbfPtr) += 1;
11268 *(here->B4SOIQjsPtr) += 1;
11269 *(here->B4SOIQjdPtr) += 1;
11270 }
11271 }
11272 }
11273
11274 #endif
11275