/*** B4SOI 12/16/2010 Released by Tanvir Morshed ***/ /********** * Copyright 2010 Regents of the University of California. All rights reserved. * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soitemp.c * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. * Authors: 2009- Wenwei Yang, Chung-Hsun Lin, Ali Niknejad, Chenming Hu. * File: b4soitemp.c * Modified by Hui Wan, Xuemei Xi 11/30/2005 * Modified by Wenwei Yang, Chung-Hsun Lin, Darsen Lu 03/06/2009 * Modified by Tanvir Morshed 09/22/2009 * Modified by Tanvir Morshed 12/31/2009 * Modified by Tanvir Morshed 05/14/2010 * Modified by Tanvir Morshed 12/16/2010 **********/ /* Lmin, Lmax, Wmin, Wmax */ #include "ngspice/ngspice.h" #include "ngspice/smpdefs.h" #include "ngspice/cktdefs.h" #include "b4soidef.h" #include "ngspice/const.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" #define Kb 1.3806226e-23 #define KboQ 8.617087e-5 /* Kb / q where q = 1.60219e-19 */ #define EPSOX 3.453133e-11 #define EPSSI 1.03594e-10 #define EPS0 8.85418e-12 #define PI 3.141592654 #define Charge_q 1.60219e-19 #define Eg300 1.115 /* energy gap at 300K */ #define MAX_EXPL 2.688117142e+43 #define MIN_EXPL 3.720075976e-44 #define EXPL_THRESHOLD 100.0 #define DELTA 1.0E-9 #define DEXP(A,B) { \ if (A > EXPL_THRESHOLD) { \ B = MAX_EXPL*(1.0+(A)-EXPL_THRESHOLD); \ } else if (A < -EXPL_THRESHOLD) { \ B = MIN_EXPL; \ } else { \ B = exp(A); \ } \ } int B4SOItemp( GENmodel *inModel, CKTcircuit *ckt) { register B4SOImodel *model = (B4SOImodel*) inModel; register B4SOIinstance *here; struct b4soiSizeDependParam *pSizeDependParamKnot, *pLastKnot, *pParam=NULL; double tmp, tmp1, tmp2, Eg, Eg0, ni, T0, T1, T2, T3, T4, T5, T6; double Ldrn=0.0, Wdrn; double Temp, TempRatio, Inv_L, Inv_W, Inv_LW, Vtm0, Tnom; double SDphi, SDgamma; double Inv_saref, Inv_sbref, Inv_sa, Inv_sb, rho, dvth0_lod; double W_tmp, Inv_ODeff, OD_offset, dk2_lod, deta0_lod, kvsat; int Size_Not_Found, i; double PowWeffWr, T10; /*v4.0 */ double Vtm0eot, Vtmeot,vbieot,phieot,sqrtphieot,vddeot; double Vgs_eff,Vgsteff, V0, Vth,Vgst; double lt1,ltw; double TempRatioMinus1; double n, VgstNVt, ExpArg, sqrtPhisExt,ExpVgst,Vgst2Vtm,vtfbphi2eot; double DIBL_Sft,Lpe_Vb,DITS_Sft,DeltVthtemp, DITS_Sft2; double Theta0,Delt_vth,DeltVthw; double niter,toxpf,toxpi, Tcen; double n0; double eggdep, agbc2n, agbc2p, bgbc2n, bgbc2p, sqrt2qeps; /* v4.3.1 bugfix for mtrlMod=1 -Tanvir */ /* v2.0 release */ double tmp3, T7; /*4.1*/ double epsrox, toxe, epssub; /* loop through all the B4SOI device models */ for (; model != NULL; model = model->B4SOInextModel) { Temp = ckt->CKTtemp; if (model->B4SOIGatesidewallJctSPotential < 0.1) /* v4.0 */ model->B4SOIGatesidewallJctSPotential = 0.1; if (model->B4SOIGatesidewallJctDPotential < 0.1) /* v4.0 */ model->B4SOIGatesidewallJctDPotential = 0.1; model->pSizeDependParamKnot = NULL; pLastKnot = NULL; Tnom = model->B4SOItnom; TempRatio = Temp / Tnom; if(model->B4SOImtrlMod) { epsrox = 3.9; toxe = model->B4SOIeot; epssub = EPS0 * model->B4SOIepsrsub; sqrt2qeps = sqrt(2.0 * 1.0e6 * Charge_q * epssub); /* bugfix 4.3.1 */ /* bugfix v4.3.1 following constants should be replaced with model params -Tanvir */ agbc2n = 3.42537e-7; agbc2p = 4.97232e-7; bgbc2n = 1.16645e12; bgbc2p = 7.45669e11; eggdep = 1.12; } else { epsrox = model->B4SOIepsrox; toxe = model->B4SOItox; epssub = EPSSI; sqrt2qeps = 5.753e-12; /* constant from v4.3.0 and earlier */ /* bugfix v4.3.1 following constants are valid for mtrlMod=0 -Tanvir */ agbc2n = 3.42537e-7; agbc2p = 4.97232e-7; bgbc2n = 1.16645e12; bgbc2p = 7.45669e11; eggdep = 1.12; } /*model->B4SOIcox = epsrox * EPS0 / toxe;*/ model->B4SOIvcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14)); if(model->B4SOImtrlMod == 0) model->B4SOIfactor1 = sqrt(EPSSI / EPSOX * model->B4SOItox); else model->B4SOIfactor1 = sqrt(epssub / (epsrox*EPS0) * toxe);/*4.1*/ if (model->B4SOImtrlMod==0) { Vtm0 = KboQ * Tnom; Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0); model->B4SOIeg0 = Eg0; model->B4SOIvtm = KboQ * Temp; Eg = 1.16 - 7.02e-4 * Temp * Temp / (Temp + 1108.0); model->B4SOIeg = Eg; /* Bug fix #11 Jun 09 Eg is evaluated at Temp, not Tnom. To be used if no selfheat */ /* ni is in cm^-3 */ ni = 1.45e10 * (Temp / 300.15) * sqrt(Temp / 300.15) * exp(21.5565981 - Eg / (2.0 * model->B4SOIvtm)); } else { Vtm0 = KboQ * Tnom; Eg0 = model->B4SOIbg0sub - model->B4SOItbgasub * Tnom * Tnom / (Tnom + model->B4SOItbgbsub); model->B4SOIeg0 = Eg0; model->B4SOIvtm = KboQ * Temp; Eg = model->B4SOIbg0sub - model->B4SOItbgasub * Temp * Temp / (Temp + model->B4SOItbgbsub); model->B4SOIeg = Eg; /* Bug fix #11 Jun 09 Eg is evaluated at Temp, not Tnom. To be used if no selfheat */ ni = model->B4SOIni0sub * (Temp / Tnom) * sqrt(Temp / Tnom) * exp(Eg0/(2.0*Vtm0) - Eg / (2.0 * model->B4SOIvtm)); } /* loop through all the instances of the model */ /* MCJ: Length and Width not initialized */ for (here = model->B4SOIinstances; here != NULL; here = here->B4SOInextInstance) { here->B4SOIrbodyext = here->B4SOIbodySquares * model->B4SOIrbsh; pSizeDependParamKnot = model->pSizeDependParamKnot; Size_Not_Found = 1; while ((pSizeDependParamKnot != NULL) && Size_Not_Found) { if ((here->B4SOIl == pSizeDependParamKnot->Length) && (here->B4SOIw == pSizeDependParamKnot->Width) && (here->B4SOIrth0 == pSizeDependParamKnot->Rth0) && (here->B4SOIcth0 == pSizeDependParamKnot->Cth0) && (here->B4SOInf == pSizeDependParamKnot->NFinger)) /*4.0*/ { Size_Not_Found = 0; here->pParam = pSizeDependParamKnot; pParam = here->pParam; /* v2.2.3 bug fix */ } else { pLastKnot = pSizeDependParamKnot; pSizeDependParamKnot = pSizeDependParamKnot->pNext; } } if (Size_Not_Found) { pParam = (struct b4soiSizeDependParam *)malloc( sizeof(struct b4soiSizeDependParam)); if (pLastKnot == NULL) model->pSizeDependParamKnot = pParam; else pLastKnot->pNext = pParam; pParam->pNext = NULL; here->pParam = pParam; Ldrn = here->B4SOIl; Wdrn = here->B4SOIw / here->B4SOInf; /* v4.0 */ pParam->Length = here->B4SOIl; pParam->Width = here->B4SOIw; pParam->NFinger = here->B4SOInf; /* v4.0 */ pParam->Rth0 = here->B4SOIrth0; pParam->Cth0 = here->B4SOIcth0; T0 = pow(Ldrn, model->B4SOILln); T1 = pow(Wdrn, model->B4SOILwn); tmp1 = model->B4SOILl / T0 + model->B4SOILw / T1 + model->B4SOILwl / (T0 * T1); pParam->B4SOIdl = model->B4SOILint + tmp1; /* v2.2.3 */ tmp1 = model->B4SOILlc / T0 + model->B4SOILwc / T1 + model->B4SOILwlc / (T0 * T1); pParam->B4SOIdlc = model->B4SOIdlc + tmp1; /* v3.0 */ pParam->B4SOIdlcig = model->B4SOIdlcig + tmp1; T2 = pow(Ldrn, model->B4SOIWln); T3 = pow(Wdrn, model->B4SOIWwn); tmp2 = model->B4SOIWl / T2 + model->B4SOIWw / T3 + model->B4SOIWwl / (T2 * T3); pParam->B4SOIdw = model->B4SOIWint + tmp2; /* v2.2.3 */ tmp2 = model->B4SOIWlc / T2 + model->B4SOIWwc / T3 + model->B4SOIWwlc / (T2 * T3); pParam->B4SOIdwc = model->B4SOIdwc + tmp2; pParam->B4SOIleff = here->B4SOIl - 2.0 * pParam->B4SOIdl; if (pParam->B4SOIleff <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, "B4SOI: mosfet %s, model %s: Effective channel length <= 0", model->B4SOImodName, here->B4SOIname); return(E_BADPARM); } pParam->B4SOIweff = here->B4SOIw / here->B4SOInf /* v4.0 */ - here->B4SOInbc * model->B4SOIdwbc - (2.0 - here->B4SOInbc) * pParam->B4SOIdw; if (pParam->B4SOIweff <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, "B4SOI: mosfet %s, model %s: Effective channel width <= 0", model->B4SOImodName, here->B4SOIname); return(E_BADPARM); } pParam->B4SOIwdiod = pParam->B4SOIweff / here->B4SOInseg + here->B4SOIpdbcp; pParam->B4SOIwdios = pParam->B4SOIweff / here->B4SOInseg + here->B4SOIpsbcp; pParam->B4SOIleffCV = here->B4SOIl - 2.0 * pParam->B4SOIdlc; if (pParam->B4SOIleffCV <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, "B4SOI: mosfet %s, model %s: Effective channel length for C-V <= 0", model->B4SOImodName, here->B4SOIname); return(E_BADPARM); } pParam->B4SOIweffCV = here->B4SOIw /here->B4SOInf /* v4.0 */ - here->B4SOInbc * model->B4SOIdwbc - (2.0 - here->B4SOInbc) * pParam->B4SOIdwc; if (pParam->B4SOIweffCV <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, "B4SOI: mosfet %s, model %s: Effective channel width for C-V <= 0", model->B4SOImodName, here->B4SOIname); return(E_BADPARM); } pParam->B4SOIwdiodCV = pParam->B4SOIweffCV / here->B4SOInseg + here->B4SOIpdbcp; pParam->B4SOIwdiosCV = pParam->B4SOIweffCV / here->B4SOInseg + here->B4SOIpsbcp; pParam->B4SOIleffCVb = here->B4SOIl - 2.0 * pParam->B4SOIdlc - model->B4SOIdlcb; if (pParam->B4SOIleffCVb <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, "B4SOI: mosfet %s, model %s: Effective channel length for C-V (body) <= 0", model->B4SOImodName, here->B4SOIname); return(E_BADPARM); } pParam->B4SOIleffCVbg = pParam->B4SOIleffCVb + 2 * model->B4SOIdlbg; if (pParam->B4SOIleffCVbg <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, "B4SOI: mosfet %s, model %s: Effective channel length for C-V (backgate) <= 0", model->B4SOImodName, here->B4SOIname); return(E_BADPARM); } /* Not binned - START */ pParam->B4SOIgamma1 = model->B4SOIgamma1; pParam->B4SOIgamma2 = model->B4SOIgamma2; pParam->B4SOIvbx = model->B4SOIvbx; pParam->B4SOIvbm = model->B4SOIvbm; pParam->B4SOIxt = model->B4SOIxt; /* Not binned - END */ /* CV model */ pParam->B4SOIcf = model->B4SOIcf; pParam->B4SOIclc = model->B4SOIclc; pParam->B4SOIcle = model->B4SOIcle; pParam->B4SOIabulkCVfactor = 1.0 + pow((pParam->B4SOIclc / pParam->B4SOIleff), pParam->B4SOIcle); /* Added for binning - START */ if (model->B4SOIbinUnit == 1) { Inv_L = 1.0e-6 / pParam->B4SOIleff; Inv_W = 1.0e-6 / pParam->B4SOIweff; Inv_LW = 1.0e-12 / (pParam->B4SOIleff * pParam->B4SOIweff); } else { Inv_L = 1.0 / pParam->B4SOIleff; Inv_W = 1.0 / pParam->B4SOIweff; Inv_LW = 1.0 / (pParam->B4SOIleff * pParam->B4SOIweff); } pParam->B4SOInpeak = model->B4SOInpeak + model->B4SOIlnpeak * Inv_L + model->B4SOIwnpeak * Inv_W + model->B4SOIpnpeak * Inv_LW; pParam->B4SOInsub = model->B4SOInsub + model->B4SOIlnsub * Inv_L + model->B4SOIwnsub * Inv_W + model->B4SOIpnsub * Inv_LW; pParam->B4SOIngate = model->B4SOIngate + model->B4SOIlngate * Inv_L + model->B4SOIwngate * Inv_W + model->B4SOIpngate * Inv_LW; /*4.1*/ pParam->B4SOInsd = model->B4SOInsd + model->B4SOIlnsd * Inv_L + model->B4SOIwnsd * Inv_W + model->B4SOIpnsd * Inv_LW; pParam->B4SOIvth0 = model->B4SOIvth0 + model->B4SOIlvth0 * Inv_L + model->B4SOIwvth0 * Inv_W + model->B4SOIpvth0 * Inv_LW; pParam->B4SOIvfb = model->B4SOIvfb + model->B4SOIlvfb * Inv_L + model->B4SOIwvfb * Inv_W + model->B4SOIpvfb * Inv_LW; /* v4.1 */ pParam->B4SOIk1 = model->B4SOIk1 + model->B4SOIlk1 * Inv_L + model->B4SOIwk1 * Inv_W + model->B4SOIpk1 * Inv_LW; pParam->B4SOIk2 = model->B4SOIk2 + model->B4SOIlk2 * Inv_L + model->B4SOIwk2 * Inv_W + model->B4SOIpk2 * Inv_LW; pParam->B4SOIk1w1 = model->B4SOIk1w1 + model->B4SOIlk1w1 * Inv_L + model->B4SOIwk1w1 * Inv_W + model->B4SOIpk1w1 * Inv_LW; pParam->B4SOIk1w2 = model->B4SOIk1w2 + model->B4SOIlk1w2 * Inv_L + model->B4SOIwk1w2 * Inv_W + model->B4SOIpk1w2 * Inv_LW; pParam->B4SOIk3 = model->B4SOIk3 + model->B4SOIlk3 * Inv_L + model->B4SOIwk3 * Inv_W + model->B4SOIpk3 * Inv_LW; pParam->B4SOIk3b = model->B4SOIk3b + model->B4SOIlk3b * Inv_L + model->B4SOIwk3b * Inv_W + model->B4SOIpk3b * Inv_LW; pParam->B4SOIkb1 = model->B4SOIkb1 + model->B4SOIlkb1 * Inv_L + model->B4SOIwkb1 * Inv_W + model->B4SOIpkb1 * Inv_LW; pParam->B4SOIw0 = model->B4SOIw0 + model->B4SOIlw0 * Inv_L + model->B4SOIww0 * Inv_W + model->B4SOIpw0 * Inv_LW; pParam->B4SOIlpe0 = model->B4SOIlpe0 + model->B4SOIllpe0 * Inv_L + model->B4SOIwlpe0 * Inv_W + model->B4SOIplpe0 * Inv_LW; pParam->B4SOIlpeb = model->B4SOIlpeb + model->B4SOIllpeb * Inv_L + model->B4SOIwlpeb * Inv_W + model->B4SOIplpeb * Inv_LW; /* v4.0 */ pParam->B4SOIdvt0 = model->B4SOIdvt0 + model->B4SOIldvt0 * Inv_L + model->B4SOIwdvt0 * Inv_W + model->B4SOIpdvt0 * Inv_LW; pParam->B4SOIdvt1 = model->B4SOIdvt1 + model->B4SOIldvt1 * Inv_L + model->B4SOIwdvt1 * Inv_W + model->B4SOIpdvt1 * Inv_LW; pParam->B4SOIdvt2 = model->B4SOIdvt2 + model->B4SOIldvt2 * Inv_L + model->B4SOIwdvt2 * Inv_W + model->B4SOIpdvt2 * Inv_LW; pParam->B4SOIdvt0w = model->B4SOIdvt0w + model->B4SOIldvt0w * Inv_L + model->B4SOIwdvt0w * Inv_W + model->B4SOIpdvt0w * Inv_LW; pParam->B4SOIdvt1w = model->B4SOIdvt1w + model->B4SOIldvt1w * Inv_L + model->B4SOIwdvt1w * Inv_W + model->B4SOIpdvt1w * Inv_LW; pParam->B4SOIdvt2w = model->B4SOIdvt2w + model->B4SOIldvt2w * Inv_L + model->B4SOIwdvt2w * Inv_W + model->B4SOIpdvt2w * Inv_LW; pParam->B4SOIu0 = model->B4SOIu0 + model->B4SOIlu0 * Inv_L + model->B4SOIwu0 * Inv_W + model->B4SOIpu0 * Inv_LW; pParam->B4SOIua = model->B4SOIua + model->B4SOIlua * Inv_L + model->B4SOIwua * Inv_W + model->B4SOIpua * Inv_LW; pParam->B4SOIub = model->B4SOIub + model->B4SOIlub * Inv_L + model->B4SOIwub * Inv_W + model->B4SOIpub * Inv_LW; pParam->B4SOIuc = model->B4SOIuc + model->B4SOIluc * Inv_L + model->B4SOIwuc * Inv_W + model->B4SOIpuc * Inv_LW; pParam->B4SOIvsat = model->B4SOIvsat + model->B4SOIlvsat * Inv_L + model->B4SOIwvsat * Inv_W + model->B4SOIpvsat * Inv_LW; pParam->B4SOIa0 = model->B4SOIa0 + model->B4SOIla0 * Inv_L + model->B4SOIwa0 * Inv_W + model->B4SOIpa0 * Inv_LW; pParam->B4SOIags = model->B4SOIags + model->B4SOIlags * Inv_L + model->B4SOIwags * Inv_W + model->B4SOIpags * Inv_LW; pParam->B4SOIb0 = model->B4SOIb0 + model->B4SOIlb0 * Inv_L + model->B4SOIwb0 * Inv_W + model->B4SOIpb0 * Inv_LW; pParam->B4SOIb1 = model->B4SOIb1 + model->B4SOIlb1 * Inv_L + model->B4SOIwb1 * Inv_W + model->B4SOIpb1 * Inv_LW; pParam->B4SOIketa = model->B4SOIketa + model->B4SOIlketa * Inv_L + model->B4SOIwketa * Inv_W + model->B4SOIpketa * Inv_LW; pParam->B4SOIketas = model->B4SOIketas + model->B4SOIlketas * Inv_L + model->B4SOIwketas * Inv_W + model->B4SOIpketas * Inv_LW; pParam->B4SOIa1 = model->B4SOIa1 + model->B4SOIla1 * Inv_L + model->B4SOIwa1 * Inv_W + model->B4SOIpa1 * Inv_LW; pParam->B4SOIa2 = model->B4SOIa2 + model->B4SOIla2 * Inv_L + model->B4SOIwa2 * Inv_W + model->B4SOIpa2 * Inv_LW; pParam->B4SOIrdsw = model->B4SOIrdsw + model->B4SOIlrdsw * Inv_L + model->B4SOIwrdsw * Inv_W + model->B4SOIprdsw * Inv_LW; pParam->B4SOIrsw = model->B4SOIrsw /* v4.0 */ + model->B4SOIlrsw * Inv_L + model->B4SOIwrsw * Inv_W + model->B4SOIprsw * Inv_LW; pParam->B4SOIrdw = model->B4SOIrdw /* v4.0 */ + model->B4SOIlrdw * Inv_L + model->B4SOIwrdw * Inv_W + model->B4SOIprdw * Inv_LW; pParam->B4SOIprwb = model->B4SOIprwb + model->B4SOIlprwb * Inv_L + model->B4SOIwprwb * Inv_W + model->B4SOIpprwb * Inv_LW; pParam->B4SOIprwg = model->B4SOIprwg + model->B4SOIlprwg * Inv_L + model->B4SOIwprwg * Inv_W + model->B4SOIpprwg * Inv_LW; pParam->B4SOIwr = model->B4SOIwr + model->B4SOIlwr * Inv_L + model->B4SOIwwr * Inv_W + model->B4SOIpwr * Inv_LW; pParam->B4SOInfactor = model->B4SOInfactor + model->B4SOIlnfactor * Inv_L + model->B4SOIwnfactor * Inv_W + model->B4SOIpnfactor * Inv_LW; pParam->B4SOIdwg = model->B4SOIdwg + model->B4SOIldwg * Inv_L + model->B4SOIwdwg * Inv_W + model->B4SOIpdwg * Inv_LW; pParam->B4SOIdwb = model->B4SOIdwb + model->B4SOIldwb * Inv_L + model->B4SOIwdwb * Inv_W + model->B4SOIpdwb * Inv_LW; pParam->B4SOIvoff = model->B4SOIvoff + model->B4SOIlvoff * Inv_L + model->B4SOIwvoff * Inv_W + model->B4SOIpvoff * Inv_LW; pParam->B4SOIeta0 = model->B4SOIeta0 + model->B4SOIleta0 * Inv_L + model->B4SOIweta0 * Inv_W + model->B4SOIpeta0 * Inv_LW; pParam->B4SOIetab = model->B4SOIetab + model->B4SOIletab * Inv_L + model->B4SOIwetab * Inv_W + model->B4SOIpetab * Inv_LW; pParam->B4SOIdsub = model->B4SOIdsub + model->B4SOIldsub * Inv_L + model->B4SOIwdsub * Inv_W + model->B4SOIpdsub * Inv_LW; pParam->B4SOIcit = model->B4SOIcit + model->B4SOIlcit * Inv_L + model->B4SOIwcit * Inv_W + model->B4SOIpcit * Inv_LW; pParam->B4SOIcdsc = model->B4SOIcdsc + model->B4SOIlcdsc * Inv_L + model->B4SOIwcdsc * Inv_W + model->B4SOIpcdsc * Inv_LW; pParam->B4SOIcdscb = model->B4SOIcdscb + model->B4SOIlcdscb * Inv_L + model->B4SOIwcdscb * Inv_W + model->B4SOIpcdscb * Inv_LW; pParam->B4SOIcdscd = model->B4SOIcdscd + model->B4SOIlcdscd * Inv_L + model->B4SOIwcdscd * Inv_W + model->B4SOIpcdscd * Inv_LW; pParam->B4SOIpclm = model->B4SOIpclm + model->B4SOIlpclm * Inv_L + model->B4SOIwpclm * Inv_W + model->B4SOIppclm * Inv_LW; pParam->B4SOIpdibl1 = model->B4SOIpdibl1 + model->B4SOIlpdibl1 * Inv_L + model->B4SOIwpdibl1 * Inv_W + model->B4SOIppdibl1 * Inv_LW; pParam->B4SOIpdibl2 = model->B4SOIpdibl2 + model->B4SOIlpdibl2 * Inv_L + model->B4SOIwpdibl2 * Inv_W + model->B4SOIppdibl2 * Inv_LW; pParam->B4SOIpdiblb = model->B4SOIpdiblb + model->B4SOIlpdiblb * Inv_L + model->B4SOIwpdiblb * Inv_W + model->B4SOIppdiblb * Inv_LW; pParam->B4SOIdrout = model->B4SOIdrout + model->B4SOIldrout * Inv_L + model->B4SOIwdrout * Inv_W + model->B4SOIpdrout * Inv_LW; pParam->B4SOIpvag = model->B4SOIpvag + model->B4SOIlpvag * Inv_L + model->B4SOIwpvag * Inv_W + model->B4SOIppvag * Inv_LW; pParam->B4SOIdelta = model->B4SOIdelta + model->B4SOIldelta * Inv_L + model->B4SOIwdelta * Inv_W + model->B4SOIpdelta * Inv_LW; pParam->B4SOIalpha0 = model->B4SOIalpha0 + model->B4SOIlalpha0 * Inv_L + model->B4SOIwalpha0 * Inv_W + model->B4SOIpalpha0 * Inv_LW; pParam->B4SOIfbjtii = model->B4SOIfbjtii + model->B4SOIlfbjtii * Inv_L + model->B4SOIwfbjtii * Inv_W + model->B4SOIpfbjtii * Inv_LW; /*4.1 Iii model*/ pParam->B4SOIebjtii = model->B4SOIebjtii + model->B4SOIlebjtii * Inv_L + model->B4SOIwebjtii * Inv_W + model->B4SOIpebjtii * Inv_LW; pParam->B4SOIcbjtii = model->B4SOIcbjtii + model->B4SOIlcbjtii * Inv_L + model->B4SOIwcbjtii * Inv_W + model->B4SOIpcbjtii * Inv_LW; pParam->B4SOIvbci = model->B4SOIvbci + model->B4SOIlvbci * Inv_L + model->B4SOIwvbci * Inv_W + model->B4SOIpvbci * Inv_LW; pParam->B4SOIabjtii = model->B4SOIabjtii + model->B4SOIlabjtii * Inv_L + model->B4SOIwabjtii * Inv_W + model->B4SOIpabjtii * Inv_LW; pParam->B4SOImbjtii = model->B4SOImbjtii + model->B4SOIlmbjtii * Inv_L + model->B4SOIwmbjtii * Inv_W + model->B4SOIpmbjtii * Inv_LW; pParam->B4SOIbeta0 = model->B4SOIbeta0 + model->B4SOIlbeta0 * Inv_L + model->B4SOIwbeta0 * Inv_W + model->B4SOIpbeta0 * Inv_LW; pParam->B4SOIbeta1 = model->B4SOIbeta1 + model->B4SOIlbeta1 * Inv_L + model->B4SOIwbeta1 * Inv_W + model->B4SOIpbeta1 * Inv_LW; pParam->B4SOIbeta2 = model->B4SOIbeta2 + model->B4SOIlbeta2 * Inv_L + model->B4SOIwbeta2 * Inv_W + model->B4SOIpbeta2 * Inv_LW; pParam->B4SOIvdsatii0 = model->B4SOIvdsatii0 + model->B4SOIlvdsatii0 * Inv_L + model->B4SOIwvdsatii0 * Inv_W + model->B4SOIpvdsatii0 * Inv_LW; pParam->B4SOIlii = model->B4SOIlii + model->B4SOIllii * Inv_L + model->B4SOIwlii * Inv_W + model->B4SOIplii * Inv_LW; pParam->B4SOIesatii = model->B4SOIesatii + model->B4SOIlesatii * Inv_L + model->B4SOIwesatii * Inv_W + model->B4SOIpesatii * Inv_LW; pParam->B4SOIsii0 = model->B4SOIsii0 + model->B4SOIlsii0 * Inv_L + model->B4SOIwsii0 * Inv_W + model->B4SOIpsii0 * Inv_LW; pParam->B4SOIsii1 = model->B4SOIsii1 + model->B4SOIlsii1 * Inv_L + model->B4SOIwsii1 * Inv_W + model->B4SOIpsii1 * Inv_LW; pParam->B4SOIsii2 = model->B4SOIsii2 + model->B4SOIlsii2 * Inv_L + model->B4SOIwsii2 * Inv_W + model->B4SOIpsii2 * Inv_LW; pParam->B4SOIsiid = model->B4SOIsiid + model->B4SOIlsiid * Inv_L + model->B4SOIwsiid * Inv_W + model->B4SOIpsiid * Inv_LW; pParam->B4SOIagidl = model->B4SOIagidl + model->B4SOIlagidl * Inv_L + model->B4SOIwagidl * Inv_W + model->B4SOIpagidl * Inv_LW; pParam->B4SOIbgidl = model->B4SOIbgidl + model->B4SOIlbgidl * Inv_L + model->B4SOIwbgidl * Inv_W + model->B4SOIpbgidl * Inv_LW; pParam->B4SOIcgidl = model->B4SOIcgidl + model->B4SOIlcgidl * Inv_L + model->B4SOIwcgidl * Inv_W + model->B4SOIpcgidl * Inv_LW; pParam->B4SOIegidl = model->B4SOIegidl + model->B4SOIlegidl * Inv_L + model->B4SOIwegidl * Inv_W + model->B4SOIpegidl * Inv_LW; pParam->B4SOIrgidl = model->B4SOIrgidl + model->B4SOIlrgidl * Inv_L + model->B4SOIwrgidl * Inv_W + model->B4SOIprgidl * Inv_LW; pParam->B4SOIkgidl = model->B4SOIkgidl + model->B4SOIlkgidl * Inv_L + model->B4SOIwkgidl * Inv_W + model->B4SOIpkgidl * Inv_LW; pParam->B4SOIfgidl = model->B4SOIfgidl + model->B4SOIlfgidl * Inv_L + model->B4SOIwfgidl * Inv_W + model->B4SOIpfgidl * Inv_LW; pParam->B4SOIagisl = model->B4SOIagisl + model->B4SOIlagisl * Inv_L + model->B4SOIwagisl * Inv_W + model->B4SOIpagisl * Inv_LW; pParam->B4SOIbgisl = model->B4SOIbgisl + model->B4SOIlbgisl * Inv_L + model->B4SOIwbgisl * Inv_W + model->B4SOIpbgisl * Inv_LW; pParam->B4SOIcgisl = model->B4SOIcgisl + model->B4SOIlcgisl * Inv_L + model->B4SOIwcgisl * Inv_W + model->B4SOIpcgisl * Inv_LW; pParam->B4SOIegisl = model->B4SOIegisl + model->B4SOIlegisl * Inv_L + model->B4SOIwegisl * Inv_W + model->B4SOIpegisl * Inv_LW; pParam->B4SOIrgisl = model->B4SOIrgisl + model->B4SOIlrgisl * Inv_L + model->B4SOIwrgisl * Inv_W + model->B4SOIprgisl * Inv_LW; pParam->B4SOIkgisl = model->B4SOIkgisl + model->B4SOIlkgisl * Inv_L + model->B4SOIwkgisl * Inv_W + model->B4SOIpkgisl * Inv_LW; pParam->B4SOIfgisl = model->B4SOIfgisl + model->B4SOIlfgisl * Inv_L + model->B4SOIwfgisl * Inv_W + model->B4SOIpfgisl * Inv_LW; pParam->B4SOIntun = model->B4SOIntun /* v4.0 */ + model->B4SOIlntun * Inv_L + model->B4SOIwntun * Inv_W + model->B4SOIpntun * Inv_LW; pParam->B4SOIntund = model->B4SOIntund /* v4.0 */ + model->B4SOIlntund * Inv_L + model->B4SOIwntund * Inv_W + model->B4SOIpntund * Inv_LW; pParam->B4SOIndiode = model->B4SOIndiode /* v4.0 */ + model->B4SOIlndiode * Inv_L + model->B4SOIwndiode * Inv_W + model->B4SOIpndiode * Inv_LW; pParam->B4SOIndioded = model->B4SOIndioded /* v4.0 */ + model->B4SOIlndioded * Inv_L + model->B4SOIwndioded * Inv_W + model->B4SOIpndioded * Inv_LW; pParam->B4SOInrecf0 = model->B4SOInrecf0 /* v4.0 */ + model->B4SOIlnrecf0 * Inv_L + model->B4SOIwnrecf0 * Inv_W + model->B4SOIpnrecf0 * Inv_LW; pParam->B4SOInrecf0d = model->B4SOInrecf0d /* v4.0 */ + model->B4SOIlnrecf0d * Inv_L + model->B4SOIwnrecf0d * Inv_W + model->B4SOIpnrecf0d * Inv_LW; pParam->B4SOInrecr0 = model->B4SOInrecr0 /* v4.0 */ + model->B4SOIlnrecr0 * Inv_L + model->B4SOIwnrecr0 * Inv_W + model->B4SOIpnrecr0 * Inv_LW; pParam->B4SOInrecr0d = model->B4SOInrecr0d /* v4.0 */ + model->B4SOIlnrecr0d * Inv_L + model->B4SOIwnrecr0d * Inv_W + model->B4SOIpnrecr0d * Inv_LW; pParam->B4SOIisbjt = model->B4SOIisbjt + model->B4SOIlisbjt * Inv_L + model->B4SOIwisbjt * Inv_W + model->B4SOIpisbjt * Inv_LW; pParam->B4SOIidbjt = model->B4SOIidbjt + model->B4SOIlidbjt * Inv_L + model->B4SOIwidbjt * Inv_W + model->B4SOIpidbjt * Inv_LW; pParam->B4SOIisdif = model->B4SOIisdif + model->B4SOIlisdif * Inv_L + model->B4SOIwisdif * Inv_W + model->B4SOIpisdif * Inv_LW; pParam->B4SOIiddif = model->B4SOIiddif + model->B4SOIliddif * Inv_L + model->B4SOIwiddif * Inv_W + model->B4SOIpiddif * Inv_LW; pParam->B4SOIisrec = model->B4SOIisrec + model->B4SOIlisrec * Inv_L + model->B4SOIwisrec * Inv_W + model->B4SOIpisrec * Inv_LW; pParam->B4SOIistun = model->B4SOIistun + model->B4SOIlistun * Inv_L + model->B4SOIwistun * Inv_W + model->B4SOIpistun * Inv_LW; pParam->B4SOIidrec = model->B4SOIidrec + model->B4SOIlidrec * Inv_L + model->B4SOIwidrec * Inv_W + model->B4SOIpidrec * Inv_LW; pParam->B4SOIidtun = model->B4SOIidtun + model->B4SOIlidtun * Inv_L + model->B4SOIwidtun * Inv_W + model->B4SOIpidtun * Inv_LW; pParam->B4SOIvrec0 = model->B4SOIvrec0 /* v4.0 */ + model->B4SOIlvrec0 * Inv_L + model->B4SOIwvrec0 * Inv_W + model->B4SOIpvrec0 * Inv_LW; pParam->B4SOIvrec0d = model->B4SOIvrec0d /* v4.0 */ + model->B4SOIlvrec0d * Inv_L + model->B4SOIwvrec0d * Inv_W + model->B4SOIpvrec0d * Inv_LW; pParam->B4SOIvtun0 = model->B4SOIvtun0 /* v4.0 */ + model->B4SOIlvtun0 * Inv_L + model->B4SOIwvtun0 * Inv_W + model->B4SOIpvtun0 * Inv_LW; pParam->B4SOIvtun0d = model->B4SOIvtun0d /* v4.0 */ + model->B4SOIlvtun0d * Inv_L + model->B4SOIwvtun0d * Inv_W + model->B4SOIpvtun0d * Inv_LW; pParam->B4SOInbjt = model->B4SOInbjt + model->B4SOIlnbjt * Inv_L + model->B4SOIwnbjt * Inv_W + model->B4SOIpnbjt * Inv_LW; pParam->B4SOIlbjt0 = model->B4SOIlbjt0 + model->B4SOIllbjt0 * Inv_L + model->B4SOIwlbjt0 * Inv_W + model->B4SOIplbjt0 * Inv_LW; pParam->B4SOIvabjt = model->B4SOIvabjt + model->B4SOIlvabjt * Inv_L + model->B4SOIwvabjt * Inv_W + model->B4SOIpvabjt * Inv_LW; pParam->B4SOIaely = model->B4SOIaely + model->B4SOIlaely * Inv_L + model->B4SOIwaely * Inv_W + model->B4SOIpaely * Inv_LW; pParam->B4SOIahli = model->B4SOIahli /* v4.0 */ + model->B4SOIlahli * Inv_L + model->B4SOIwahli * Inv_W + model->B4SOIpahli * Inv_LW; pParam->B4SOIahlid = model->B4SOIahlid /* v4.0 */ + model->B4SOIlahlid * Inv_L + model->B4SOIwahlid * Inv_W + model->B4SOIpahlid * Inv_LW; /* v3.1 */ pParam->B4SOIxj = model->B4SOIxj + model->B4SOIlxj * Inv_L + model->B4SOIwxj * Inv_W + model->B4SOIpxj * Inv_LW; pParam->B4SOIalphaGB1 = model->B4SOIalphaGB1 + model->B4SOIlalphaGB1 * Inv_L + model->B4SOIwalphaGB1 * Inv_W + model->B4SOIpalphaGB1 * Inv_LW; pParam->B4SOIalphaGB2 = model->B4SOIalphaGB2 + model->B4SOIlalphaGB2 * Inv_L + model->B4SOIwalphaGB2 * Inv_W + model->B4SOIpalphaGB2 * Inv_LW; pParam->B4SOIbetaGB1 = model->B4SOIbetaGB1 + model->B4SOIlbetaGB1* Inv_L + model->B4SOIwbetaGB1 * Inv_W + model->B4SOIpbetaGB1 * Inv_LW; pParam->B4SOIbetaGB2 = model->B4SOIbetaGB2 + model->B4SOIlbetaGB2 * Inv_L + model->B4SOIwbetaGB2 * Inv_W + model->B4SOIpbetaGB2 * Inv_LW; pParam->B4SOIndif = model->B4SOIndif + model->B4SOIlndif * Inv_L + model->B4SOIwndif * Inv_W + model->B4SOIpndif * Inv_LW; pParam->B4SOIntrecf = model->B4SOIntrecf + model->B4SOIlntrecf* Inv_L + model->B4SOIwntrecf * Inv_W + model->B4SOIpntrecf * Inv_LW; pParam->B4SOIntrecr = model->B4SOIntrecr + model->B4SOIlntrecr * Inv_L + model->B4SOIwntrecr * Inv_W + model->B4SOIpntrecr * Inv_LW; pParam->B4SOIxbjt = model->B4SOIxbjt + model->B4SOIlxbjt * Inv_L + model->B4SOIwxbjt * Inv_W + model->B4SOIpxbjt * Inv_LW; pParam->B4SOIxdif = model->B4SOIxdif + model->B4SOIlxdif* Inv_L + model->B4SOIwxdif * Inv_W + model->B4SOIpxdif * Inv_LW; pParam->B4SOIxrec = model->B4SOIxrec + model->B4SOIlxrec * Inv_L + model->B4SOIwxrec * Inv_W + model->B4SOIpxrec * Inv_LW; pParam->B4SOIxtun = model->B4SOIxtun + model->B4SOIlxtun * Inv_L + model->B4SOIwxtun * Inv_W + model->B4SOIpxtun * Inv_LW; pParam->B4SOIxdifd = model->B4SOIxdifd + model->B4SOIlxdifd* Inv_L + model->B4SOIwxdifd * Inv_W + model->B4SOIpxdifd * Inv_LW; pParam->B4SOIxrecd = model->B4SOIxrecd + model->B4SOIlxrecd * Inv_L + model->B4SOIwxrecd * Inv_W + model->B4SOIpxrecd * Inv_LW; pParam->B4SOIxtund = model->B4SOIxtund + model->B4SOIlxtund * Inv_L + model->B4SOIwxtund * Inv_W + model->B4SOIpxtund * Inv_LW; pParam->B4SOIcgdl = model->B4SOIcgdl + model->B4SOIlcgdl * Inv_L + model->B4SOIwcgdl * Inv_W + model->B4SOIpcgdl * Inv_LW; pParam->B4SOIcgsl = model->B4SOIcgsl + model->B4SOIlcgsl * Inv_L + model->B4SOIwcgsl * Inv_W + model->B4SOIpcgsl * Inv_LW; pParam->B4SOIckappa = model->B4SOIckappa + model->B4SOIlckappa * Inv_L + model->B4SOIwckappa * Inv_W + model->B4SOIpckappa * Inv_LW; pParam->B4SOIute = model->B4SOIute + model->B4SOIlute * Inv_L + model->B4SOIwute * Inv_W + model->B4SOIpute * Inv_LW; /*4.1 mobmod=4*/ pParam->B4SOIud = model->B4SOIud /* + model->B4SOIud * Inv_L*//*Bug #15 Jun 09*/ + model->B4SOIlud * Inv_L /*Fix*/ + model->B4SOIwud * Inv_W + model->B4SOIpud * Inv_LW; pParam->B4SOIud1 = model->B4SOIud1 + model->B4SOIlud1 * Inv_L + model->B4SOIwud1 * Inv_W + model->B4SOIpud1 * Inv_LW; pParam->B4SOIeu = model->B4SOIeu + model->B4SOIleu * Inv_L + model->B4SOIweu * Inv_W + model->B4SOIpeu * Inv_LW; pParam->B4SOIucs = model->B4SOIucs + model->B4SOIlucs * Inv_L + model->B4SOIwucs * Inv_W + model->B4SOIpucs * Inv_LW; pParam->B4SOIucste = model->B4SOIucste + model->B4SOIlucste * Inv_L + model->B4SOIwucste * Inv_W + model->B4SOIpucste * Inv_LW; pParam->B4SOIkt1 = model->B4SOIkt1 + model->B4SOIlkt1 * Inv_L + model->B4SOIwkt1 * Inv_W + model->B4SOIpkt1 * Inv_LW; pParam->B4SOIkt2 = model->B4SOIkt2 + model->B4SOIlkt2 * Inv_L + model->B4SOIwkt2 * Inv_W + model->B4SOIpkt2 * Inv_LW; pParam->B4SOIkt1l = model->B4SOIkt1l + model->B4SOIlkt1l * Inv_L + model->B4SOIwkt1l * Inv_W + model->B4SOIpkt1l * Inv_LW; pParam->B4SOIua1 = model->B4SOIua1 + model->B4SOIlua1 * Inv_L + model->B4SOIwua1 * Inv_W + model->B4SOIpua1 * Inv_LW; pParam->B4SOIub1 = model->B4SOIub1 + model->B4SOIlub1* Inv_L + model->B4SOIwub1 * Inv_W + model->B4SOIpub1 * Inv_LW; pParam->B4SOIuc1 = model->B4SOIuc1 + model->B4SOIluc1 * Inv_L + model->B4SOIwuc1 * Inv_W + model->B4SOIpuc1 * Inv_LW; pParam->B4SOIat = model->B4SOIat + model->B4SOIlat * Inv_L + model->B4SOIwat * Inv_W + model->B4SOIpat * Inv_LW; pParam->B4SOIprt = model->B4SOIprt + model->B4SOIlprt * Inv_L + model->B4SOIwprt * Inv_W + model->B4SOIpprt * Inv_LW; /* v3.0 */ pParam->B4SOInigc = model->B4SOInigc + model->B4SOIlnigc * Inv_L + model->B4SOIwnigc * Inv_W + model->B4SOIpnigc * Inv_LW; pParam->B4SOIaigc = model->B4SOIaigc + model->B4SOIlaigc * Inv_L + model->B4SOIwaigc * Inv_W + model->B4SOIpaigc * Inv_LW; pParam->B4SOIbigc = model->B4SOIbigc + model->B4SOIlbigc * Inv_L + model->B4SOIwbigc * Inv_W + model->B4SOIpbigc * Inv_LW; pParam->B4SOIcigc = model->B4SOIcigc + model->B4SOIlcigc * Inv_L + model->B4SOIwcigc * Inv_W + model->B4SOIpcigc * Inv_LW; pParam->B4SOIaigsd = model->B4SOIaigsd + model->B4SOIlaigsd * Inv_L + model->B4SOIwaigsd * Inv_W + model->B4SOIpaigsd * Inv_LW; pParam->B4SOIbigsd = model->B4SOIbigsd + model->B4SOIlbigsd * Inv_L + model->B4SOIwbigsd * Inv_W + model->B4SOIpbigsd * Inv_LW; pParam->B4SOIcigsd = model->B4SOIcigsd + model->B4SOIlcigsd * Inv_L + model->B4SOIwcigsd * Inv_W + model->B4SOIpcigsd * Inv_LW; pParam->B4SOIpigcd = model->B4SOIpigcd + model->B4SOIlpigcd * Inv_L + model->B4SOIwpigcd * Inv_W + model->B4SOIppigcd * Inv_LW; pParam->B4SOIpoxedge = model->B4SOIpoxedge + model->B4SOIlpoxedge * Inv_L + model->B4SOIwpoxedge * Inv_W + model->B4SOIppoxedge * Inv_LW; /* v3.0 */ /* v3.1 added for RF */ pParam->B4SOIxrcrg1 = model->B4SOIxrcrg1 + model->B4SOIlxrcrg1 * Inv_L + model->B4SOIwxrcrg1 * Inv_W + model->B4SOIpxrcrg1 * Inv_LW; pParam->B4SOIxrcrg2 = model->B4SOIxrcrg2 + model->B4SOIlxrcrg2 * Inv_L + model->B4SOIwxrcrg2 * Inv_W + model->B4SOIpxrcrg2 * Inv_LW; /* v3.1 added for RF end */ /* CV model */ pParam->B4SOIvsdfb = model->B4SOIvsdfb + model->B4SOIlvsdfb * Inv_L + model->B4SOIwvsdfb * Inv_W + model->B4SOIpvsdfb * Inv_LW; pParam->B4SOIvsdth = model->B4SOIvsdth + model->B4SOIlvsdth * Inv_L + model->B4SOIwvsdth * Inv_W + model->B4SOIpvsdth * Inv_LW; pParam->B4SOIdelvt = model->B4SOIdelvt + model->B4SOIldelvt * Inv_L + model->B4SOIwdelvt * Inv_W + model->B4SOIpdelvt * Inv_LW; pParam->B4SOIacde = model->B4SOIacde + model->B4SOIlacde * Inv_L + model->B4SOIwacde * Inv_W + model->B4SOIpacde * Inv_LW; pParam->B4SOIacde = pParam->B4SOIacde * pow((pParam->B4SOInpeak / 2.0e16), -0.25); /* v3.2 bug fix */ pParam->B4SOImoin = model->B4SOImoin + model->B4SOIlmoin * Inv_L + model->B4SOIwmoin * Inv_W + model->B4SOIpmoin * Inv_LW; pParam->B4SOInoff = model->B4SOInoff + model->B4SOIlnoff * Inv_L + model->B4SOIwnoff * Inv_W + model->B4SOIpnoff * Inv_LW; /* v3.2 */ pParam->B4SOIdvtp0 = model->B4SOIdvtp0 + model->B4SOIldvtp0 * Inv_L + model->B4SOIwdvtp0 * Inv_W + model->B4SOIpdvtp0 * Inv_LW; /* v4.0 */ pParam->B4SOIdvtp1 = model->B4SOIdvtp1 + model->B4SOIldvtp1 * Inv_L + model->B4SOIwdvtp1 * Inv_W + model->B4SOIpdvtp1 * Inv_LW; /* v4.0 */ pParam->B4SOIdvtp2 = model->B4SOIdvtp2 + model->B4SOIldvtp2 * Inv_L + model->B4SOIwdvtp2 * Inv_W + model->B4SOIpdvtp2 * Inv_LW; /* v4.1 */ pParam->B4SOIdvtp3 = model->B4SOIdvtp3 + model->B4SOIldvtp3 * Inv_L + model->B4SOIwdvtp3 * Inv_W + model->B4SOIpdvtp3 * Inv_LW; /* v4.1 */ pParam->B4SOIdvtp4 = model->B4SOIdvtp4 + model->B4SOIldvtp4 * Inv_L + model->B4SOIwdvtp4 * Inv_W + model->B4SOIpdvtp4 * Inv_LW; /* v4.1 */ pParam->B4SOIminv = model->B4SOIminv + model->B4SOIlminv * Inv_L + model->B4SOIwminv * Inv_W + model->B4SOIpminv * Inv_LW; /* v4.0 */ pParam->B4SOIminvcv = model->B4SOIminvcv + model->B4SOIlminvcv * Inv_L + model->B4SOIwminvcv * Inv_W + model->B4SOIpminvcv * Inv_LW; /* v4.1 */ pParam->B4SOIvoffcv = model->B4SOIvoffcv /*Bug fix # 16 Jun09*/ + model->B4SOIlvoffcv * Inv_L + model->B4SOIwvoffcv * Inv_W + model->B4SOIpvoffcv * Inv_LW; pParam->B4SOIfprout = model->B4SOIfprout + model->B4SOIlfprout * Inv_L + model->B4SOIwfprout * Inv_W + model->B4SOIpfprout * Inv_LW; /* v4.0 */ pParam->B4SOIpdits = model->B4SOIpdits + model->B4SOIlpdits * Inv_L + model->B4SOIwpdits * Inv_W + model->B4SOIppdits * Inv_LW; /* v4.0 */ pParam->B4SOIpditsd = model->B4SOIpditsd + model->B4SOIlpditsd * Inv_L + model->B4SOIwpditsd * Inv_W + model->B4SOIppditsd * Inv_LW; /* v4.0 */ pParam->B4SOIaigbcp2 = model->B4SOIaigbcp2 + model->B4SOIlaigbcp2 * Inv_L + model->B4SOIwaigbcp2 * Inv_W + model->B4SOIpaigbcp2 * Inv_LW; /* v4.0 */ pParam->B4SOIbigbcp2 = model->B4SOIbigbcp2 + model->B4SOIlbigbcp2 * Inv_L + model->B4SOIwbigbcp2 * Inv_W + model->B4SOIpbigbcp2 * Inv_LW; /* v4.0 */ pParam->B4SOIcigbcp2 = model->B4SOIcigbcp2 + model->B4SOIlcigbcp2 * Inv_L + model->B4SOIwcigbcp2 * Inv_W + model->B4SOIpcigbcp2 * Inv_LW; /* v4.0 */ /* Added for binning - END */ /* v4.0 add mstar for Vgsteff */ pParam->B4SOImstar = 0.5 + atan(pParam->B4SOIminv) / PI; if (model->B4SOIvgstcvMod == 0) printf("vgstcvMod = 0, users are suggested to use vgstcvMod = 1 or 2.\n"); /* v4.1 add mstarcv for Vgsteffcv */ pParam->B4SOImstarcv = 0.5 + atan(pParam->B4SOIminvcv) / PI; T0 = (TempRatio - 1.0); pParam->B4SOIuatemp = pParam->B4SOIua; /* save ua, ub, and uc for b4soild.c */ pParam->B4SOIubtemp = pParam->B4SOIub; pParam->B4SOIuctemp = pParam->B4SOIuc; pParam->B4SOIrds0denom = pow(pParam->B4SOIweff * 1E6, pParam->B4SOIwr); /* v2.2 release */ pParam->B4SOIrth = here->B4SOIrth0 / (pParam->B4SOIweff + model->B4SOIwth0) * here->B4SOInseg / here->B4SOInf; /* bugfix_snps nf*/ pParam->B4SOIcth = here->B4SOIcth0 * (pParam->B4SOIweff + model->B4SOIwth0) / here->B4SOInseg * here->B4SOInf; /* bugfix_snps nf*/ /* v2.2.2 adding layout-dependent Frbody multiplier */ /* pParam->B4SOIrbody = here->B4SOIfrbody *model->B4SOIrbody * model->B4SOIrhalo / (2 * model->B4SOIrbody + model->B4SOIrhalo * pParam->B4SOIleff) * pParam->B4SOIweff / here->B4SOInseg / here->B4SOInf */ /* v4.0 *//*;*/ if (model->B4SOIrbody == 0) /* Bug Fix # 27 added to avoid NaN (0/0) in QA*/ pParam->B4SOIrbody = 0; else pParam->B4SOIrbody = here->B4SOIfrbody *model->B4SOIrbody * model->B4SOIrhalo / (2 * model->B4SOIrbody + model->B4SOIrhalo * pParam->B4SOIleff) * pParam->B4SOIweff / here->B4SOInseg/ here->B4SOInf; /* v4.0 */ pParam->B4SOIoxideRatio = pow(model->B4SOItoxref /model->B4SOItoxqm, model->B4SOIntox) /model->B4SOItoxqm/model->B4SOItoxqm; /* v2.2 release */ pParam->B4SOIua = pParam->B4SOIua + pParam->B4SOIua1 * T0; pParam->B4SOIub = pParam->B4SOIub + pParam->B4SOIub1 * T0; pParam->B4SOIuc = pParam->B4SOIuc + pParam->B4SOIuc1 * T0; if (pParam->B4SOIu0 > 1.0) pParam->B4SOIu0 = pParam->B4SOIu0 / 1.0e4; pParam->B4SOIu0temp = pParam->B4SOIu0 * pow(TempRatio, pParam->B4SOIute); pParam->B4SOIvsattemp = pParam->B4SOIvsat - pParam->B4SOIat * T0; pParam->B4SOIrds0 = (pParam->B4SOIrdsw + pParam->B4SOIprt * T0) / pow(pParam->B4SOIweff * 1E6, pParam->B4SOIwr); if(model->B4SOIrdsMod) { /* v4.0 */ PowWeffWr = pParam->B4SOIrds0denom * here->B4SOInf; T10 = pParam->B4SOIprt * T0; /* External Rd(V) */ T1 = pParam->B4SOIrdw + T10; T2 = model->B4SOIrdwmin + T10; if (T1 < 0.0) { T1 = 0.0; printf("Warning: Rdw at current temperature is negative; set to 0.\n"); } if (T2 < 0.0) { T2 = 0.0; printf("Warning: Rdwmin at current temperature is negative; set to 0.\n"); } pParam->B4SOIrd0 = T1 / PowWeffWr; pParam->B4SOIrdwmin = T2 / PowWeffWr; /* External Rs(V) */ T3 = pParam->B4SOIrsw + T10; T4 = model->B4SOIrswmin + T10; if (T3 < 0.0) { T3 = 0.0; printf("Warning: Rsw at current temperature is negative; set to 0.\n"); } if (T4 < 0.0) { T4 = 0.0; printf("Warning: Rswmin at current temperature is negative; set to 0.\n"); } pParam->B4SOIrs0 = T3 / PowWeffWr; pParam->B4SOIrswmin = T4 / PowWeffWr; } if (B4SOIcheckModel(model, here, ckt)) { SPfrontEnd->IFerrorf (ERR_FATAL, "Fatal error(s) detected during B4SOIV3 parameter checking for %s in model %s", model->B4SOImodName, here->B4SOIname); return(E_BADPARM); } pParam->B4SOIcgdo = (model->B4SOIcgdo + pParam->B4SOIcf) * pParam->B4SOIwdiodCV; pParam->B4SOIcgso = (model->B4SOIcgso + pParam->B4SOIcf) * pParam->B4SOIwdiosCV; pParam->B4SOIcgeo = model->B4SOIcgeo * pParam->B4SOIleffCV * here->B4SOInf; /* v4.0 */ if (!model->B4SOInpeakGiven && model->B4SOIgamma1Given) { T0 = pParam->B4SOIgamma1 * model->B4SOIcox; pParam->B4SOInpeak = 3.021E22 * T0 * T0; } T4 = Eg300 / model->B4SOIvtm * (TempRatio - 1.0); /* source side */ T7 = pParam->B4SOIxbjt * T4 / pParam->B4SOIndiode; DEXP(T7, T0); T7 = pParam->B4SOIxdif * T4 / pParam->B4SOIndiode; DEXP(T7, T1); T7 = pParam->B4SOIxrec * T4 / pParam->B4SOInrecf0; DEXP(T7, T2); pParam->B4SOIahli0s = pParam->B4SOIahli * T0; pParam->B4SOIjbjts = pParam->B4SOIisbjt * T0; pParam->B4SOIjdifs = pParam->B4SOIisdif * T1; pParam->B4SOIjrecs = pParam->B4SOIisrec * T2; T7 = pParam->B4SOIxtun * (TempRatio - 1); DEXP(T7, T0); pParam->B4SOIjtuns = pParam->B4SOIistun * T0; /* drain side */ /* pParam->B4SOIjtund = pParam->B4SOIidtun * T0; */ /*v4.2 redundant */ T7 = pParam->B4SOIxbjt * T4 / pParam->B4SOIndioded; DEXP(T7, T0); T7 = pParam->B4SOIxdifd * T4 / pParam->B4SOIndioded; DEXP(T7, T1); T7 = pParam->B4SOIxrecd * T4 / pParam->B4SOInrecf0d; DEXP(T7, T2); pParam->B4SOIahli0d = pParam->B4SOIahlid * T0; pParam->B4SOIjbjtd = pParam->B4SOIidbjt * T0; pParam->B4SOIjdifd = pParam->B4SOIiddif * T1; pParam->B4SOIjrecd = pParam->B4SOIidrec * T2; T7 = pParam->B4SOIxtund * (TempRatio - 1); DEXP(T7, T0); pParam->B4SOIjtund = pParam->B4SOIidtun * T0; if (pParam->B4SOInsub > 0) pParam->B4SOIvfbb = -model->B4SOItype * model->B4SOIvtm * log(pParam->B4SOInpeak/ pParam->B4SOInsub); else pParam->B4SOIvfbb = -model->B4SOItype * model->B4SOIvtm * log(-pParam->B4SOInpeak* pParam->B4SOInsub/ni/ni); if (!model->B4SOIvsdfbGiven) { if (pParam->B4SOInsub > 0) pParam->B4SOIvsdfb = -model->B4SOItype * (model->B4SOIvtm*log(1e20 * pParam->B4SOInsub / ni /ni) - 0.3); else if (pParam->B4SOInsub < 0) pParam->B4SOIvsdfb = -model->B4SOItype * (model->B4SOIvtm*log(-1e20 / pParam->B4SOInsub) + 0.3); } /* Phi & Gamma */ SDphi = 2.0*model->B4SOIvtm*log(fabs(pParam->B4SOInsub) / ni); SDgamma = sqrt2qeps * sqrt(fabs(pParam->B4SOInsub)) / model->B4SOIcbox; /* bugfix v4.3.1*/ if (!model->B4SOIvsdthGiven) { if ( ((pParam->B4SOInsub > 0) && (model->B4SOItype > 0)) || ((pParam->B4SOInsub < 0) && (model->B4SOItype < 0)) ) pParam->B4SOIvsdth = pParam->B4SOIvsdfb + SDphi + SDgamma * sqrt(SDphi); else pParam->B4SOIvsdth = pParam->B4SOIvsdfb - SDphi - SDgamma * sqrt(SDphi); } if (!model->B4SOIcsdminGiven) { /* Cdmin */ tmp = sqrt(2.0 * epssub * SDphi / (Charge_q * fabs(pParam->B4SOInsub) * 1.0e6)); tmp1 = epssub / tmp; model->B4SOIcsdmin = tmp1 * model->B4SOIcbox / (tmp1 + model->B4SOIcbox); } pParam->B4SOIphi = 2.0 * model->B4SOIvtm * log(pParam->B4SOInpeak / ni); pParam->B4SOIsqrtPhi = sqrt(pParam->B4SOIphi); pParam->B4SOIphis3 = pParam->B4SOIsqrtPhi * pParam->B4SOIphi; pParam->B4SOIXdep0 = sqrt(2.0 * epssub / (Charge_q * pParam->B4SOInpeak * 1.0e6)) * pParam->B4SOIsqrtPhi; pParam->B4SOIsqrtXdep0 = sqrt(pParam->B4SOIXdep0); /*4.1*/ if (model->B4SOImtrlMod==0) pParam->B4SOIlitl = sqrt(3.0 *3.9/epsrox* pParam->B4SOIxj * model->B4SOItox); else /* pParam->B4SOIlitl = sqrt(epssub * pParam->B4SOIxj * model->B4SOItox/(epsrox*EPS0)); */ /* Bug fix # 13 Jun 09 'not reported by vendors'*/ pParam->B4SOIlitl = sqrt(epssub * pParam->B4SOIxj * toxe/(epsrox*EPS0)); /* fix */ pParam->B4SOIvbi = model->B4SOIvtm * log(1.0e20 * pParam->B4SOInpeak / (ni * ni)); pParam->B4SOIcdep0 = sqrt(Charge_q * epssub * pParam->B4SOInpeak * 1.0e6 / 2.0 / pParam->B4SOIphi); /* v3.0 */ /*4.1 */ if (model->B4SOImtrlMod ==0) { if (pParam->B4SOIngate > 0.0) { pParam->B4SOIvfbsd = Vtm0 * log(pParam->B4SOIngate / 1.0e20); } else pParam->B4SOIvfbsd = 0.0; } else { T0 = Vtm0 * log(pParam->B4SOInsd/ni); T1 = 0.5 * Eg0; if(T0 > T1) T0 = T1; T2 = model->B4SOIeasub + T1 - model->B4SOItype * T0; pParam->B4SOIvfbsd = model->B4SOIphig - T2; } pParam->B4SOIToxRatio = exp(model->B4SOIntox * log(model->B4SOItoxref /model->B4SOItoxqm)) /model->B4SOItoxqm /model->B4SOItoxqm; pParam->B4SOIToxRatioEdge = exp(model->B4SOIntox * log(model->B4SOItoxref / (model->B4SOItoxqm * pParam->B4SOIpoxedge))) / model->B4SOItoxqm / model->B4SOItoxqm / pParam->B4SOIpoxedge / pParam->B4SOIpoxedge; /* pParam->B4SOIAechvb = (model->B4SOItype == NMOS) ? 4.97232e-7 : 3.42537e-7; pParam->B4SOIBechvb = (model->B4SOItype == NMOS) ? 7.45669e11 : 1.16645e12; */ pParam->B4SOIAechvb = (model->B4SOItype == NMOS) ? agbc2p : agbc2n; /* bugfix 4.3.1 -Tanvir */ pParam->B4SOIBechvb = (model->B4SOItype == NMOS) ? bgbc2p : bgbc2n; /* bugfix v4.3.1 -Tanvir */ // The edge should have a contribution from psbcp & pdbcp. Need s & d terms. // There is no NF correction because psbcp & pdbcp are "per finger" in manual. pParam->B4SOIAechvbEdges = pParam->B4SOIAechvb * (pParam->B4SOIweff/here->B4SOInseg + here->B4SOIpsbcp) * pParam->B4SOIdlcig * pParam->B4SOIToxRatioEdge; /* v3.1 bug fix */ pParam->B4SOIAechvbEdged = pParam->B4SOIAechvb * (pParam->B4SOIweff/here->B4SOInseg + here->B4SOIpdbcp) * pParam->B4SOIdlcig * pParam->B4SOIToxRatioEdge; /* v3.1 bug fix */ pParam->B4SOIBechvbEdge = -pParam->B4SOIBechvb * model->B4SOItoxqm * pParam->B4SOIpoxedge; /* pParam->B4SOIAechvb *= pParam->B4SOIweff/here->B4SOInseg */ /* * pParam->B4SOIleff */ /* * pParam->B4SOIToxRatio */ /* + here->B4SOIagbcpd; v4.0 */ pParam->B4SOIAechvb *= (pParam->B4SOIweff/here->B4SOInseg * pParam->B4SOIleff + here->B4SOIagbcpd/here->B4SOInf) /* LFW */ * pParam->B4SOIToxRatio; /* From Geoffrey Coram 10/22/09 */ pParam->B4SOIBechvb *= -model->B4SOItoxqm; /* v3.0 */ if (model->B4SOIk1Given || model->B4SOIk2Given) { if (!model->B4SOIk1Given) { fprintf(stdout, "Warning: k1 should be specified with k2.\n"); pParam->B4SOIk1 = 0.53; } if (!model->B4SOIk2Given) { fprintf(stdout, "Warning: k2 should be specified with k1.\n"); pParam->B4SOIk2 = -0.0186; } if (model->B4SOIxtGiven) fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n"); if (model->B4SOIvbxGiven) fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n"); if (model->B4SOIvbmGiven) fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n"); if (model->B4SOIgamma1Given) fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n"); if (model->B4SOIgamma2Given) fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n"); } else { if (!model->B4SOIvbxGiven){ if (model->B4SOImtrlMod) T0 = Charge_q / 2.0 / epssub * 1.0e6; else T0 = 7.7348e-4; pParam->B4SOIvbx = pParam->B4SOIphi - T0 * pParam->B4SOInpeak * pParam->B4SOIxt * pParam->B4SOIxt;} /* bugfix 4.3.1 */ if (pParam->B4SOIvbx > 0.0) pParam->B4SOIvbx = -pParam->B4SOIvbx; if (pParam->B4SOIvbm > 0.0) pParam->B4SOIvbm = -pParam->B4SOIvbm; if (!model->B4SOIgamma1Given) pParam->B4SOIgamma1 = sqrt2qeps * sqrt(pParam->B4SOInpeak) / model->B4SOIcox; /* bugfix 4.3.1 */ if (!model->B4SOIgamma2Given) pParam->B4SOIgamma2 = sqrt2qeps * sqrt(pParam->B4SOInsub) / model->B4SOIcox; /* bugfix 4.3.1 */ T0 = pParam->B4SOIgamma1 - pParam->B4SOIgamma2; T1 = sqrt(pParam->B4SOIphi - pParam->B4SOIvbx) - pParam->B4SOIsqrtPhi; T2 = sqrt(pParam->B4SOIphi * (pParam->B4SOIphi - pParam->B4SOIvbm)) - pParam->B4SOIphi; pParam->B4SOIk2 = T0 * T1 / (2.0 * T2 + pParam->B4SOIvbm); pParam->B4SOIk1 = pParam->B4SOIgamma2 - 2.0 * pParam->B4SOIk2 * sqrt(pParam->B4SOIphi - pParam->B4SOIvbm); } /*if (pParam->B4SOIk2 < 0.0) { T0 = 0.5 * pParam->B4SOIk1 / pParam->B4SOIk2; pParam->B4SOIvbsc = 0.9 * (pParam->B4SOIphi - T0 * T0); if (pParam->B4SOIvbsc > -3.0) pParam->B4SOIvbsc = -3.0; else if (pParam->B4SOIvbsc < -30.0) pParam->B4SOIvbsc = -30.0; } else { pParam->B4SOIvbsc = -30.0; } if (pParam->B4SOIvbsc > pParam->B4SOIvbm) pParam->B4SOIvbsc = pParam->B4SOIvbm; */ /* v4.2 never used in code */ if ((T0 = pParam->B4SOIweff + pParam->B4SOIk1w2) < 1e-8) T0 = 1e-8; pParam->B4SOIk1eff = pParam->B4SOIk1 * (1 + pParam->B4SOIk1w1/T0); /*4.0 if (model->B4SOIvth0Given) { pParam->B4SOIvfb = model->B4SOItype * pParam->B4SOIvth0 - pParam->B4SOIphi - pParam->B4SOIk1eff * pParam->B4SOIsqrtPhi; } else { pParam->B4SOIvfb = -1.0; pParam->B4SOIvth0 = model->B4SOItype * (pParam->B4SOIvfb + pParam->B4SOIphi + pParam->B4SOIk1eff * pParam->B4SOIsqrtPhi); } */ /* v4.1 */ if (!model->B4SOIvfbGiven) { if (model->B4SOIvth0Given) { pParam->B4SOIvfb = model->B4SOItype * pParam->B4SOIvth0 - pParam->B4SOIphi - pParam->B4SOIk1eff * pParam->B4SOIsqrtPhi; } else { pParam->B4SOIvfb = -1.0; } } if (!model->B4SOIvth0Given) { pParam->B4SOIvth0 = model->B4SOItype * (pParam->B4SOIvfb + pParam->B4SOIphi + pParam->B4SOIk1eff * pParam->B4SOIsqrtPhi); } /* v4.0 */ pParam->B4SOIk1ox = pParam->B4SOIk1eff * model->B4SOItox / model->B4SOItoxm; if(model->B4SOImtrlMod == 0) T1 = sqrt(EPSSI / EPSOX * model->B4SOItox * pParam->B4SOIXdep0); else T1 = sqrt(epssub / (epsrox*EPS0) * model->B4SOItox * pParam->B4SOIXdep0); T0 = exp(-0.5 * pParam->B4SOIdsub * pParam->B4SOIleff / T1); pParam->B4SOItheta0vb0 = (T0 + 2.0 * T0 * T0); T0 = exp(-0.5 * pParam->B4SOIdrout * pParam->B4SOIleff / T1); T2 = (T0 + 2.0 * T0 * T0); pParam->B4SOIthetaRout = pParam->B4SOIpdibl1 * T2 + pParam->B4SOIpdibl2; /* New DITS term (added in 4.1) */ pParam->B4SOIdvtp2factor = pParam->B4SOIdvtp2 / exp(pParam->B4SOIdvtp3 * log(pParam->B4SOIleff)); /* stress effect */ if (model->B4SOIwlod < 0.0) { fprintf(stderr, "Warning: WLOD = %g is less than 0. Set to 0.0\n",model->B4SOIwlod); model->B4SOIwlod = 0.0; } T0 = pow(Ldrn, model->B4SOIllodku0); W_tmp = Wdrn + model->B4SOIwlod; T1 = pow(W_tmp, model->B4SOIwlodku0); tmp1 = model->B4SOIlku0 / T0 + model->B4SOIwku0 / T1 + model->B4SOIpku0 / (T0 * T1); pParam->B4SOIku0 = 1.0 + tmp1; T0 = pow(Ldrn, model->B4SOIllodvth); T1 = pow(W_tmp, model->B4SOIwlodvth); tmp1 = model->B4SOIlkvth0 / T0 + model->B4SOIwkvth0 / T1 + model->B4SOIpkvth0 / (T0 * T1); pParam->B4SOIkvth0 = 1.0 + tmp1; pParam->B4SOIkvth0 = sqrt( pParam->B4SOIkvth0 * pParam->B4SOIkvth0 + DELTA); /*T0 = (TRatio - 1.0);*/ T0 = (TempRatio - 1.0); /* bug fix v4.1 */ pParam->B4SOIku0temp = pParam->B4SOIku0 * (1.0 + model->B4SOItku0 * T0) + DELTA; Inv_saref = 1.0 / (model->B4SOIsaref + 0.5 * Ldrn); Inv_sbref = 1.0 / (model->B4SOIsbref + 0.5 * Ldrn); pParam->B4SOIinv_od_ref = Inv_saref + Inv_sbref; pParam->B4SOIrho_ref = model->B4SOIku0 / pParam->B4SOIku0temp * pParam->B4SOIinv_od_ref; /* stress effect end */ } /* v4.0 stress effect */ /* Bug Fix # 17 Jul09 Code 1484-1560 is moved up from lines 1884-1958 of old version*/ /* v4.0 stress effect */ if( (here->B4SOIsa > 0.0) && (here->B4SOIsb > 0.0) && ( (here->B4SOInf == 1.0) || ((here->B4SOInf > 1.0) && (here->B4SOIsd > 0.0)) ) ) { Inv_sa = 0; Inv_sb = 0; if (model->B4SOIkvsat < -1.0 ) { fprintf(stderr, "Warning: KVSAT = %g is too small; Reset to -1.0.\n",model->B4SOIkvsat); here->B4SOIkvsat = kvsat = -1.0; } else if (model->B4SOIkvsat > 1.0) { fprintf(stderr, "Warning: KVSAT = %g is too big; Reset to 1.0.\n",model->B4SOIkvsat); here->B4SOIkvsat = kvsat = 1.0; } else here->B4SOIkvsat = model->B4SOIkvsat; for(i = 0; i < here->B4SOInf; i++) { T0 = 1.0 / here->B4SOInf / (here->B4SOIsa + 0.5*Ldrn + i * (here->B4SOIsd +Ldrn)); T1 = 1.0 / here->B4SOInf / (here->B4SOIsb + 0.5*Ldrn + i * (here->B4SOIsd +Ldrn)); Inv_sa += T0; Inv_sb += T1; } Inv_ODeff = Inv_sa + Inv_sb; here->B4SOIInv_ODeff = Inv_ODeff; rho = model->B4SOIku0 / pParam->B4SOIku0temp * Inv_ODeff; T0 = (1.0 + rho)/(1.0 + pParam->B4SOIrho_ref); here->B4SOIu0temp = pParam->B4SOIu0temp * T0; T1 = (1.0 + here->B4SOIkvsat * rho)/(1.0 + here->B4SOIkvsat * pParam->B4SOIrho_ref);/*self-heating bug fix*/ here->B4SOIvsattemp = pParam->B4SOIvsattemp * T1; OD_offset = Inv_ODeff - pParam->B4SOIinv_od_ref; dvth0_lod = model->B4SOIkvth0 / pParam->B4SOIkvth0 * OD_offset; dk2_lod = model->B4SOIstk2 / pow(pParam->B4SOIkvth0, model->B4SOIlodk2) * OD_offset; deta0_lod = model->B4SOIsteta0 / pow(pParam->B4SOIkvth0, model->B4SOIlodeta0) * OD_offset; here->B4SOIvth0 = pParam->B4SOIvth0 + dvth0_lod; here->B4SOIk2 = pParam->B4SOIk2 + dk2_lod; here->B4SOIeta0 = pParam->B4SOIeta0 + deta0_lod; } else { here->B4SOIu0temp = pParam->B4SOIu0temp; here->B4SOIvth0 = pParam->B4SOIvth0; here->B4SOIvsattemp = pParam->B4SOIvsattemp; here->B4SOIk2 = pParam->B4SOIk2; here->B4SOIeta0 = pParam->B4SOIeta0; here->B4SOIInv_ODeff = 0; pParam->B4SOIinv_od_ref = 0; /*Stress bug fix*/ here->B4SOIkvsat = 0; /*Stress bug fix*/ } /* v4.0 stress effect end */ here->B4SOIk2ox = here->B4SOIk2 * model->B4SOItox / model->B4SOItoxm; /* v4.0 */ here->B4SOIvth0 += here->B4SOIdelvto; /* v4.0 */ here->B4SOIvfb = pParam->B4SOIvfb + model->B4SOItype * here->B4SOIdelvto; /* Bug Fix # 17 Jul09 Code 1479-1545 is moved up from lines 1884-1950 of old version, 1954-2035 in this version*/ here->B4SOIcsbox = model->B4SOIcbox*here->B4SOIsourceArea; here->B4SOIcsmin = model->B4SOIcsdmin*here->B4SOIsourceArea; here->B4SOIcdbox = model->B4SOIcbox*here->B4SOIdrainArea; here->B4SOIcdmin = model->B4SOIcsdmin*here->B4SOIdrainArea; if ( ((pParam->B4SOInsub > 0) && (model->B4SOItype > 0)) || ((pParam->B4SOInsub < 0) && (model->B4SOItype < 0)) ) { T0 = pParam->B4SOIvsdth - pParam->B4SOIvsdfb; pParam->B4SOIsdt1 = pParam->B4SOIvsdfb + model->B4SOIasd * T0; T1 = here->B4SOIcsbox - here->B4SOIcsmin; T2 = T1 / T0 / T0; pParam->B4SOIst2 = T2 / model->B4SOIasd; pParam->B4SOIst3 = T2 /( 1 - model->B4SOIasd); here->B4SOIst4 = T0 * T1 * (1 + model->B4SOIasd) / 3 - here->B4SOIcsmin * pParam->B4SOIvsdfb; T1 = here->B4SOIcdbox - here->B4SOIcdmin; T2 = T1 / T0 / T0; pParam->B4SOIdt2 = T2 / model->B4SOIasd; pParam->B4SOIdt3 = T2 /( 1 - model->B4SOIasd); here->B4SOIdt4 = T0 * T1 * (1 + model->B4SOIasd) / 3 - here->B4SOIcdmin * pParam->B4SOIvsdfb; } else { T0 = pParam->B4SOIvsdfb - pParam->B4SOIvsdth; pParam->B4SOIsdt1 = pParam->B4SOIvsdth + model->B4SOIasd * T0; T1 = here->B4SOIcsmin - here->B4SOIcsbox; T2 = T1 / T0 / T0; pParam->B4SOIst2 = T2 / model->B4SOIasd; pParam->B4SOIst3 = T2 /( 1 - model->B4SOIasd); here->B4SOIst4 = T0 * T1 * (1 + model->B4SOIasd) / 3 - here->B4SOIcsbox * pParam->B4SOIvsdth; T1 = here->B4SOIcdmin - here->B4SOIcdbox; T2 = T1 / T0 / T0; pParam->B4SOIdt2 = T2 / model->B4SOIasd; pParam->B4SOIdt3 = T2 /( 1 - model->B4SOIasd); here->B4SOIdt4 = T0 * T1 * (1 + model->B4SOIasd) / 3 - here->B4SOIcdbox * pParam->B4SOIvsdth; } /* v2.2.2 bug fix */ T0 = model->B4SOIcsdesw * log(model->B4SOIcfrcoeff * (1 + model->B4SOItsi / model->B4SOItbox)); /* v4.4 */ T1 = here->B4SOIsourcePerimeter - here->B4SOIw; if (T1 > 0.0) here->B4SOIcsesw = T0 * T1; else here->B4SOIcsesw = 0.0; T1 = here->B4SOIdrainPerimeter - here->B4SOIw; if (T1 > 0.0) here->B4SOIcdesw = T0 * T1; else here->B4SOIcdesw = 0.0; here->B4SOIphi = pParam->B4SOIphi; /* process source/drain series resistance */ here->B4SOIdrainConductance = model->B4SOIsheetResistance * here->B4SOIdrainSquares; if (here->B4SOIdrainConductance > 0.0) here->B4SOIdrainConductance = 1.0 / here->B4SOIdrainConductance; else here->B4SOIdrainConductance = 0.0; here->B4SOIsourceConductance = model->B4SOIsheetResistance * here->B4SOIsourceSquares; if (here->B4SOIsourceConductance > 0.0) here->B4SOIsourceConductance = 1.0 / here->B4SOIsourceConductance; else here->B4SOIsourceConductance = 0.0; here->B4SOIcgso = pParam->B4SOIcgso; here->B4SOIcgdo = pParam->B4SOIcgdo; /* v2.0 release */ if (model->B4SOIln < 1e-15) model->B4SOIln = 1e-15; T0 = -0.5 * pParam->B4SOIleff * pParam->B4SOIleff / model->B4SOIln / model->B4SOIln; DEXP(T0,T1); pParam->B4SOIarfabjt = T1; T0 = pParam->B4SOIlbjt0 * (1.0 / pParam->B4SOIleff + 1.0 / model->B4SOIln); pParam->B4SOIlratio = pow(T0,pParam->B4SOInbjt); pParam->B4SOIlratiodif = 1.0 + model->B4SOIldif0 * pow(T0,pParam->B4SOIndif); if ((pParam->B4SOIvearly = pParam->B4SOIvabjt + pParam->B4SOIaely * pParam->B4SOIleff) < 1) pParam->B4SOIvearly = 1; /*4.1 toxp calculation*/ if(model->B4SOImtrlMod==0) { model->B4SOItoxp = model->B4SOItox - model->B4SOIdtoxcv; } else { /* Calculate TOXP from EOT */ /* Calculate Vgs_eff @ Vgs = VDD with Poly Depletion Effect */ Vtm0eot = KboQ * model->B4SOItempeot; Vtmeot = Vtm0eot; vbieot = Vtm0eot * log(1.0e20 * pParam->B4SOInpeak / (ni * ni)); phieot = 2.0 * Vtm0eot * log(pParam->B4SOInpeak / ni); sqrtphieot = sqrt(phieot); tmp2 = here->B4SOIvfb + phieot; vddeot = model->B4SOItype * model->B4SOIvddeot; T0 = model->B4SOIepsrgate * EPS0; if ((pParam->B4SOIngate > 1.0e18) && (pParam->B4SOIngate < 1.0e25) && (vddeot > tmp2) && (T0!=0)) { T1 = 1.0e6 * Charge_q * epssub * pParam->B4SOIngate / (model->B4SOIcox * model->B4SOIcox); T4 = sqrt(1.0 + 2.0 * (vddeot - T0) / T1); T2 = T1 * (T4 - 1.0); T3 = 0.5 * T2 * T2 / T1; /* T3 = Vpoly */ /* T7 = 1.12 - T3 - 0.05; */ T7 = eggdep - T3 - 0.05; /* bugfix v4.3.1 -Tanvir */ T6 = sqrt(T7 * T7 + 0.224); /* T5 = 1.12 - 0.5 * (T7 + T6); */ T5 = eggdep - 0.5 * (T7 + T6); /* bugfix v4.3.1 -Tanvir */ Vgs_eff = vddeot - T5; } else { Vgs_eff = vddeot; } /* Calculate Vth @ Vds=Vbs=0 */ V0 = vbieot - phieot; T3 = sqrt(pParam->B4SOIXdep0); lt1 = model->B4SOIfactor1 * T3; ltw= model->B4SOIfactor1 * T3 ; T0 = -0.5 * pParam->B4SOIdvt1 * model->B4SOIleffeot / lt1; if (T0 > -EXPL_THRESHOLD) { T1 = exp(T0); Theta0 = T1 * (1.0 + 2.0 * T1); } else { T1 = MIN_EXPL; Theta0 = T1 * (1.0 + 2.0 * T1); } /* Calculate n */ T2 = pParam->B4SOInfactor * epssub / pParam->B4SOIXdep0; T3 = pParam->B4SOIcdsc ; T4 = (T2 + T3 * Theta0 + pParam->B4SOIcit) / model->B4SOIcox; if (T4 >= -0.5) { n = 1.0 + T4; } else /* avoid discontinuity problems caused by T4 */ { T0 = 1.0 / (3.0 + 8.0 * T4); n = (1.0 + 3.0 * T4) * T0; } /* v4.0 DITS */ if (pParam->B4SOIdvtp0 > 0.0) { T2 = 1; /* Bug fix #1 Jun 09 Shorter implementation of same code */ /* T0 = 0.0; T2 = exp(T0); if (T0 < -EXPL_THRESHOLD) { T2 = MIN_EXPL; } else { T2 = exp(T0); } end */ T3 = model->B4SOIleffeot + pParam->B4SOIdvtp0 * (1.0 + T2); T4 = Vtmeot * log(model->B4SOIleffeot / T3); DITS_Sft = n * T4; } else { DITS_Sft=0.0; } here->B4SOIthetavth = pParam->B4SOIdvt0 * Theta0; Delt_vth = here->B4SOIthetavth * V0; T0 = -0.5 * pParam->B4SOIdvt1w * model->B4SOIweffeot * model->B4SOIleffeot / ltw; if (T0 > -EXPL_THRESHOLD) { T1 = exp(T0); T2 = T1 * (1.0 + 2.0 * T1); } else { T1 = MIN_EXPL; T2 = T1 * (1.0 + 2.0 * T1); } T0 = pParam->B4SOIdvt0w * T2; DeltVthw = T0 * V0; TempRatioMinus1 = model->B4SOItempeot / model->B4SOItnom - 1.0; T0 = sqrt(1.0 + pParam->B4SOIlpe0 / model->B4SOIleffeot); T1 = (pParam->B4SOIkt1 + pParam->B4SOIkt1l / model->B4SOIleffeot); DeltVthtemp = pParam->B4SOIk1ox * (T0 - 1.0) * sqrtphieot + T1 * TempRatioMinus1; /* v4.0 */ tmp2 = toxe * phieot / (model->B4SOIweffeot + pParam->B4SOIw0); DIBL_Sft = 0.0; DITS_Sft2 = 0.0; Lpe_Vb = sqrt(1.0 + pParam->B4SOIlpeb / model->B4SOIleffeot); sqrtPhisExt = sqrtphieot; Vth = model->B4SOItype * here->B4SOIvth0 + (pParam->B4SOIk1ox * sqrtPhisExt - pParam->B4SOIk1eff * sqrtphieot) * Lpe_Vb - Delt_vth - DeltVthw +pParam->B4SOIk3 * tmp2 + DeltVthtemp - DIBL_Sft -DITS_Sft - DITS_Sft2; Vgst = Vgs_eff - Vth; T10 = n * Vtmeot; /* v4.0 */ VgstNVt = pParam->B4SOImstar * Vgst / T10; /* v4.0 */ ExpArg = (pParam->B4SOIvoff - (1- pParam->B4SOImstar) * Vgst) / T10; /* v4.0 */ /* MCJ: Very small Vgst */ if (VgstNVt > EXPL_THRESHOLD) { Vgsteff = Vgst; /* T0 is dVgsteff_dVbseff */ } else if (ExpArg > EXPL_THRESHOLD) { T0 = (Vgst - pParam->B4SOIvoff) / (n * Vtmeot); ExpVgst = exp(T0); Vgsteff = Vtmeot * pParam->B4SOIcdep0 / model->B4SOIcox * ExpVgst; } else { ExpVgst = exp(VgstNVt); T1 = T10 * log(1.0 + ExpVgst); T3 = (1.0 / model->B4SOItempeot); T4 = -model->B4SOIcox / (Vtm0eot * pParam->B4SOIcdep0) * exp(ExpArg) * (1 - pParam->B4SOImstar); T2 = pParam->B4SOImstar - T10 * T4 / (1.0 - pParam->B4SOImstar); Vgsteff = T1 / T2; } Vgst2Vtm = Vgsteff + 2.0 * Vtmeot; /* calculating Toxp */ T3 = model->B4SOItype * here->B4SOIvth0 - here->B4SOIvfb - phieot; vtfbphi2eot = 4.0 * T3; if (vtfbphi2eot < 0.0) vtfbphi2eot = 0.0; niter = 0; toxpf = toxe; do { toxpi = toxpf; tmp2 = 2.0e8 * toxpf; T0 = (Vgsteff + vtfbphi2eot) / tmp2; T1 = 1.0 + exp(model->B4SOIbdos * 0.7 * log(T0)); Tcen = model->B4SOIados * 1.9e-9 / T1; toxpf = toxe - epsrox/model->B4SOIepsrsub * Tcen; niter++; } while ((niter<=4)&&(ABS(toxpf-toxpi)>1e-12)); model->B4SOItoxp = toxpf; /*model->B4SOIcoxp = epsrox * EPS0 / model->B4SOItoxp;*/ }/*End of Toxp*/ /* vfbzb calculation for capMod 3 */ tmp = sqrt(pParam->B4SOIXdep0); tmp1 = pParam->B4SOIvbi - pParam->B4SOIphi; tmp2 = model->B4SOIfactor1 * tmp; T0 = -0.5 * pParam->B4SOIdvt1w * pParam->B4SOIweff * pParam->B4SOIleff / tmp2; if (T0 > -EXPL_THRESHOLD) { T1 = exp(T0); T2 = T1 * (1.0 + 2.0 * T1); } else { T1 = MIN_EXPL; T2 = T1 * (1.0 + 2.0 * T1); } T0 = pParam->B4SOIdvt0w * T2; T2 = T0 * tmp1; T0 = -0.5 * pParam->B4SOIdvt1 * pParam->B4SOIleff / tmp2; if (T0 > -EXPL_THRESHOLD) { T1 = exp(T0); T3 = T1 * (1.0 + 2.0 * T1); } else { T1 = MIN_EXPL; T3 = T1 * (1.0 + 2.0 * T1); } T3 = pParam->B4SOIdvt0 * T3 * tmp1; /* v2.2.3 */ /*4.1*/ /* T4 = (model->B4SOItox - model->B4SOIdtoxcv) * pParam->B4SOIphi / (pParam->B4SOIweff + pParam->B4SOIw0); */ T4 = model->B4SOItoxp * pParam->B4SOIphi / (pParam->B4SOIweff + pParam->B4SOIw0); T0 = sqrt(1.0 + pParam->B4SOIlpe0 / pParam->B4SOIleff); /*v4.0*/ T5 = pParam->B4SOIk1ox * (T0 - 1.0) * pParam->B4SOIsqrtPhi + (pParam->B4SOIkt1 + pParam->B4SOIkt1l / pParam->B4SOIleff) * (TempRatio - 1.0); /* v4.0 */ tmp3 = model->B4SOItype * pParam->B4SOIvth0 - T2 - T3 + pParam->B4SOIk3 * T4 + T5; pParam->B4SOIvfbzb = tmp3 - pParam->B4SOIphi - pParam->B4SOIk1 * pParam->B4SOIsqrtPhi; /* End of vfbzb */ /* v3.2 */ pParam->B4SOIqsi = Charge_q * model->B4SOInpeak * (1.0 + pParam->B4SOIlpe0 / pParam->B4SOIleff) * 1e6 * model->B4SOItsi; /* v3.1 added for RF */ here->B4SOIgrgeltd = model->B4SOIrshg * (model->B4SOIxgw + pParam->B4SOIweff / here->B4SOInseg / 3.0 / model->B4SOIngcon) / (model->B4SOIngcon * here->B4SOInf * (here->B4SOIl - model->B4SOIxgl)); if (here->B4SOIgrgeltd > 0.0) here->B4SOIgrgeltd = 1.0 / here->B4SOIgrgeltd; else { here->B4SOIgrgeltd = 1.0e3; /* mho */ if (here->B4SOIrgateMod !=0) printf("Warning: The gate conductance reset to 1.0e3 mho.\n"); } /* v3.1 added for RF end */ /* v4.0 rbodyMod */ if (here->B4SOIrbodyMod) { if (here->B4SOIrbdb < 1.0e-3) here->B4SOIgrbdb = 1.0e3; /* in mho */ else here->B4SOIgrbdb = model->B4SOIgbmin + 1.0 / here->B4SOIrbdb; if (here->B4SOIrbsb < 1.0e-3) here->B4SOIgrbsb = 1.0e3; else here->B4SOIgrbsb = model->B4SOIgbmin + 1.0 / here->B4SOIrbsb; } /* v4.0 rbodyMod end */ /* Bug Fix # 17 Jul09 Stress effect code (lines: 1954-2020) is moved up to lines 1479-1545*/ here->B4SOIvfbzb = pParam->B4SOIvfbzb + model->B4SOItype * here->B4SOIdelvto; pParam->B4SOIldeb = sqrt(epssub * Vtm0 / (Charge_q * pParam->B4SOInpeak * 1.0e6)) / 3.0; /*For high k mobility*/ T1 = model->B4SOItype * here->B4SOIvth0 - here->B4SOIvfb - pParam->B4SOIphi; T2 = T1 + T1; T3 = 2.5 * T1; here->B4SOIvtfbphi1 = (model->B4SOItype == NMOS) ? T2 : T3; if (here->B4SOIvtfbphi1 < 0.0) here->B4SOIvtfbphi1 = 0.0; /*Calculate VgsteffVth for mobMod=4*/ if(model->B4SOImobMod == 4) { /*Calculate n @ Vbs=Vds=0*/ /*V0 = pParam->B4SOIvbi - pParam->B4SOIphi; */ /* v4.2 never used in code */ lt1 = model->B4SOIfactor1* pParam->B4SOIsqrtXdep0; /* ltw = lt1; */ /* v4.2 never used in code */ T0 = pParam->B4SOIdvt1 * pParam->B4SOIleff / lt1; if (T0 < EXPL_THRESHOLD) { T1 = exp(T0); T2 = T1 - 1.0; T3 = T2 * T2; T4 = T3 + 2.0 * T1 * MIN_EXPL; Theta0 = T1 / T4; } else Theta0 = 1.0 / (MAX_EXPL - 2.0); tmp1 = epssub / pParam->B4SOIXdep0; /*here->B4SOInstar = model->B4SOIvtm / Charge_q * (model->B4SOIcox + tmp1 + pParam->B4SOIcit); */ /* v4.2 never used in code */ tmp2 = pParam->B4SOInfactor * tmp1; tmp3 = (tmp2 + pParam->B4SOIcdsc * Theta0 + pParam->B4SOIcit) / model->B4SOIcox; if (tmp3 >= -0.5) n0 = 1.0 + tmp3; else { T0 = 1.0 / (3.0 + 8.0 * tmp3); n0 = (1.0 + 3.0 * tmp3) * T0; } T0 = n0 * Vtm0; T1 = pParam->B4SOIvoff; T2 = T1/T0; if (T2 < -EXPL_THRESHOLD) { T3 = model->B4SOIcox * MIN_EXPL / pParam->B4SOIcdep0; T4 = pParam->B4SOImstar + T3 * n0; } else if (T2 > EXPL_THRESHOLD) { T3 = model->B4SOIcox * MAX_EXPL / pParam->B4SOIcdep0; T4 = pParam->B4SOImstar + T3 * n0; } else { T3 = exp(T2)* model->B4SOIcox / pParam->B4SOIcdep0; T4 = pParam->B4SOImstar + T3 * n0; } here->B4SOIvgsteffvth = T0 * log(2.0)/T4; } } } return(OK); }