epilectrik
/
pyNgSpice
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
165 Commits
1 Branch
0 Tags
36 MiB
 
 
 
 
 
 
Tree: 9606b353db
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '9606b353db'
${ noResults }
pyNgSpice/src/spicelib/devices/bsim3soi_pd/b3soipdtemp.c

1037 lines
36 KiB
Raw Blame History

/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soipdtemp.c 98/5/01
Modified by Pin Su 99/2/15
Modified by Pin Su 99/4/30
Modified by Pin Su, Wei Jin 99/9/27
Modified by Pin Su 00/3/1
**********/
/* Lmin, Lmax, Wmin, Wmax */
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "smpdefs.h"
#include "cktdefs.h"
#include "b3soipddef.h"
#include "const.h"
#include "sperror.h"
#include "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 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 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); \
} \
}
/* ARGSUSED */
int
B3SOIPDtemp (inModel, ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
register B3SOIPDmodel *model = (B3SOIPDmodel *) inModel;
register B3SOIPDinstance *here;
struct b3soipdSizeDependParam *pSizeDependParamKnot, *pLastKnot, *pParam;
double tmp, tmp1, tmp2, Eg, Eg0, ni, T0, T1, T2, T3, T4, T5, T6, Ldrn, Wdrn;
double Temp, TempRatio, Inv_L, Inv_W, Inv_LW, Dw, Dl, Vtm0, Tnom;
double SDphi, SDgamma;
int Size_Not_Found;
/* v2.0 release */
double tmp3, T7, T8, T9;
/* loop through all the B3SOIPD device models */
for (; model != NULL; model = model->B3SOIPDnextModel)
{
Temp = ckt->CKTtemp;
if (model->B3SOIPDGatesidewallJctPotential < 0.1)
model->B3SOIPDGatesidewallJctPotential = 0.1;
model->pSizeDependParamKnot = NULL;
pLastKnot = NULL;
Tnom = model->B3SOIPDtnom;
TempRatio = Temp / Tnom;
model->B3SOIPDvcrit =
CONSTvt0 * log (CONSTvt0 / (CONSTroot2 * 1.0e-14));
model->B3SOIPDfactor1 = sqrt (EPSSI / EPSOX * model->B3SOIPDtox);
Vtm0 = KboQ * Tnom;
Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0);
model->B3SOIPDeg0 = Eg0;
model->B3SOIPDvtm = KboQ * Temp;
Eg = 1.16 - 7.02e-4 * Temp * Temp / (Temp + 1108.0);
/* ni is in cm^-3 */
ni = 1.45e10 * (Temp / 300.15) * sqrt (Temp / 300.15)
* exp (21.5565981 - Eg / (2.0 * model->B3SOIPDvtm));
/* loop through all the instances of the model */
/* MCJ: Length and Width not initialized */
for (here = model->B3SOIPDinstances; here != NULL;
here = here->B3SOIPDnextInstance)
{
here->B3SOIPDrbodyext = here->B3SOIPDbodySquares *
model->B3SOIPDrbsh;
pSizeDependParamKnot = model->pSizeDependParamKnot;
Size_Not_Found = 1;
while ((pSizeDependParamKnot != NULL) && Size_Not_Found)
{
if ((here->B3SOIPDl == pSizeDependParamKnot->Length)
&& (here->B3SOIPDw == pSizeDependParamKnot->Width)
&& (here->B3SOIPDrth0 == pSizeDependParamKnot->Rth0)
&& (here->B3SOIPDcth0 == pSizeDependParamKnot->Cth0))
{
Size_Not_Found = 0;
here->pParam = pSizeDependParamKnot;
}
else
{
pLastKnot = pSizeDependParamKnot;
pSizeDependParamKnot = pSizeDependParamKnot->pNext;
}
}
if (Size_Not_Found)
{
pParam =
(struct b3soipdSizeDependParam *)
malloc (sizeof (struct b3soipdSizeDependParam));
if (pLastKnot == NULL)
model->pSizeDependParamKnot = pParam;
else
pLastKnot->pNext = pParam;
pParam->pNext = NULL;
here->pParam = pParam;
Ldrn = here->B3SOIPDl;
Wdrn = here->B3SOIPDw;
pParam->Length = Ldrn;
pParam->Width = Wdrn;
pParam->Rth0 = here->B3SOIPDrth0;
pParam->Cth0 = here->B3SOIPDcth0;
T0 = pow (Ldrn, model->B3SOIPDLln);
T1 = pow (Wdrn, model->B3SOIPDLwn);
tmp1 = model->B3SOIPDLl / T0 + model->B3SOIPDLw / T1
+ model->B3SOIPDLwl / (T0 * T1);
pParam->B3SOIPDdl = model->B3SOIPDLint + tmp1;
pParam->B3SOIPDdlc = model->B3SOIPDdlc + tmp1;
T2 = pow (Ldrn, model->B3SOIPDWln);
T3 = pow (Wdrn, model->B3SOIPDWwn);
tmp2 = model->B3SOIPDWl / T2 + model->B3SOIPDWw / T3
+ model->B3SOIPDWwl / (T2 * T3);
pParam->B3SOIPDdw = model->B3SOIPDWint + tmp2;
pParam->B3SOIPDdwc = model->B3SOIPDdwc + tmp2;
pParam->B3SOIPDleff = here->B3SOIPDl - 2.0 * pParam->B3SOIPDdl;
if (pParam->B3SOIPDleff <= 0.0)
{
IFuid namarray[2];
namarray[0] = model->B3SOIPDmodName;
namarray[1] = here->B3SOIPDname;
(*(SPfrontEnd->IFerror)) (ERR_FATAL,
"B3SOIPD: mosfet %s, model %s: Effective channel length <= 0",
namarray);
return (E_BADPARM);
}
pParam->B3SOIPDweff =
here->B3SOIPDw - here->B3SOIPDnbc * model->B3SOIPDdwbc -
(2.0 - here->B3SOIPDnbc) * pParam->B3SOIPDdw;
if (pParam->B3SOIPDweff <= 0.0)
{
IFuid namarray[2];
namarray[0] = model->B3SOIPDmodName;
namarray[1] = here->B3SOIPDname;
(*(SPfrontEnd->IFerror)) (ERR_FATAL,
"B3SOIPD: mosfet %s, model %s: Effective channel width <= 0",
namarray);
return (E_BADPARM);
}
pParam->B3SOIPDwdiod =
pParam->B3SOIPDweff / here->B3SOIPDnseg + here->B3SOIPDpdbcp;
pParam->B3SOIPDwdios =
pParam->B3SOIPDweff / here->B3SOIPDnseg + here->B3SOIPDpsbcp;
pParam->B3SOIPDleffCV =
here->B3SOIPDl - 2.0 * pParam->B3SOIPDdlc;
if (pParam->B3SOIPDleffCV <= 0.0)
{
IFuid namarray[2];
namarray[0] = model->B3SOIPDmodName;
namarray[1] = here->B3SOIPDname;
(*(SPfrontEnd->IFerror)) (ERR_FATAL,
"B3SOIPD: mosfet %s, model %s: Effective channel length for C-V <= 0",
namarray);
return (E_BADPARM);
}
pParam->B3SOIPDweffCV =
here->B3SOIPDw - here->B3SOIPDnbc * model->B3SOIPDdwbc -
(2.0 - here->B3SOIPDnbc) * pParam->B3SOIPDdwc;
if (pParam->B3SOIPDweffCV <= 0.0)
{
IFuid namarray[2];
namarray[0] = model->B3SOIPDmodName;
namarray[1] = here->B3SOIPDname;
(*(SPfrontEnd->IFerror)) (ERR_FATAL,
"B3SOIPD: mosfet %s, model %s: Effective channel width for C-V <= 0",
namarray);
return (E_BADPARM);
}
pParam->B3SOIPDwdiodCV =
pParam->B3SOIPDweffCV / here->B3SOIPDnseg +
here->B3SOIPDpdbcp;
pParam->B3SOIPDwdiosCV =
pParam->B3SOIPDweffCV / here->B3SOIPDnseg +
here->B3SOIPDpsbcp;
pParam->B3SOIPDleffCVb =
here->B3SOIPDl - 2.0 * pParam->B3SOIPDdlc -
model->B3SOIPDdlcb;
if (pParam->B3SOIPDleffCVb <= 0.0)
{
IFuid namarray[2];
namarray[0] = model->B3SOIPDmodName;
namarray[1] = here->B3SOIPDname;
(*(SPfrontEnd->IFerror)) (ERR_FATAL,
"B3SOIPD: mosfet %s, model %s: Effective channel length for C-V (body) <= 0",
namarray);
return (E_BADPARM);
}
pParam->B3SOIPDleffCVbg =
pParam->B3SOIPDleffCVb + 2 * model->B3SOIPDdlbg;
if (pParam->B3SOIPDleffCVbg <= 0.0)
{
IFuid namarray[2];
namarray[0] = model->B3SOIPDmodName;
namarray[1] = here->B3SOIPDname;
(*(SPfrontEnd->IFerror)) (ERR_FATAL,
"B3SOIPD: mosfet %s, model %s: Effective channel length for C-V (backgate) <= 0",
namarray);
return (E_BADPARM);
}
/* Not binned - START */
pParam->B3SOIPDat = model->B3SOIPDat;
pParam->B3SOIPDgamma1 = model->B3SOIPDgamma1;
pParam->B3SOIPDgamma2 = model->B3SOIPDgamma2;
pParam->B3SOIPDvbx = model->B3SOIPDvbx;
pParam->B3SOIPDvbm = model->B3SOIPDvbm;
pParam->B3SOIPDxt = model->B3SOIPDxt;
pParam->B3SOIPDkt1 = model->B3SOIPDkt1;
pParam->B3SOIPDkt1l = model->B3SOIPDkt1l;
pParam->B3SOIPDkt2 = model->B3SOIPDkt2;
pParam->B3SOIPDua1 = model->B3SOIPDua1;
pParam->B3SOIPDub1 = model->B3SOIPDub1;
pParam->B3SOIPDuc1 = model->B3SOIPDuc1;
pParam->B3SOIPDute = model->B3SOIPDute;
pParam->B3SOIPDprt = model->B3SOIPDprt;
/* Not binned - END */
/* CV model */
pParam->B3SOIPDcgsl = model->B3SOIPDcgsl;
pParam->B3SOIPDcgdl = model->B3SOIPDcgdl;
pParam->B3SOIPDckappa = model->B3SOIPDckappa;
pParam->B3SOIPDcf = model->B3SOIPDcf;
pParam->B3SOIPDclc = model->B3SOIPDclc;
pParam->B3SOIPDcle = model->B3SOIPDcle;
pParam->B3SOIPDabulkCVfactor =
1.0 + pow ((pParam->B3SOIPDclc / pParam->B3SOIPDleff),
pParam->B3SOIPDcle);
/* Added for binning - START */
if (model->B3SOIPDbinUnit == 1)
{
Inv_L = 1.0e-6 / pParam->B3SOIPDleff;
Inv_W = 1.0e-6 / pParam->B3SOIPDweff;
Inv_LW = 1.0e-12 / (pParam->B3SOIPDleff
* pParam->B3SOIPDweff);
}
else
{
Inv_L = 1.0 / pParam->B3SOIPDleff;
Inv_W = 1.0 / pParam->B3SOIPDweff;
Inv_LW = 1.0 / (pParam->B3SOIPDleff * pParam->B3SOIPDweff);
}
pParam->B3SOIPDnpeak = model->B3SOIPDnpeak
+ model->B3SOIPDlnpeak * Inv_L
+ model->B3SOIPDwnpeak * Inv_W
+ model->B3SOIPDpnpeak * Inv_LW;
pParam->B3SOIPDnsub = model->B3SOIPDnsub
+ model->B3SOIPDlnsub * Inv_L
+ model->B3SOIPDwnsub * Inv_W + model->B3SOIPDpnsub * Inv_LW;
pParam->B3SOIPDngate = model->B3SOIPDngate
+ model->B3SOIPDlngate * Inv_L
+ model->B3SOIPDwngate * Inv_W
+ model->B3SOIPDpngate * Inv_LW;
pParam->B3SOIPDvth0 = model->B3SOIPDvth0
+ model->B3SOIPDlvth0 * Inv_L
+ model->B3SOIPDwvth0 * Inv_W + model->B3SOIPDpvth0 * Inv_LW;
pParam->B3SOIPDk1 = model->B3SOIPDk1
+ model->B3SOIPDlk1 * Inv_L
+ model->B3SOIPDwk1 * Inv_W + model->B3SOIPDpk1 * Inv_LW;
pParam->B3SOIPDk2 = model->B3SOIPDk2
+ model->B3SOIPDlk2 * Inv_L
+ model->B3SOIPDwk2 * Inv_W + model->B3SOIPDpk2 * Inv_LW;
pParam->B3SOIPDk1w1 = model->B3SOIPDk1w1
+ model->B3SOIPDlk1w1 * Inv_L
+ model->B3SOIPDwk1w1 * Inv_W + model->B3SOIPDpk1w1 * Inv_LW;
pParam->B3SOIPDk1w2 = model->B3SOIPDk1w2
+ model->B3SOIPDlk1w2 * Inv_L
+ model->B3SOIPDwk1w2 * Inv_W + model->B3SOIPDpk1w2 * Inv_LW;
pParam->B3SOIPDk3 = model->B3SOIPDk3
+ model->B3SOIPDlk3 * Inv_L
+ model->B3SOIPDwk3 * Inv_W + model->B3SOIPDpk3 * Inv_LW;
pParam->B3SOIPDk3b = model->B3SOIPDk3b
+ model->B3SOIPDlk3b * Inv_L
+ model->B3SOIPDwk3b * Inv_W + model->B3SOIPDpk3b * Inv_LW;
pParam->B3SOIPDkb1 = model->B3SOIPDkb1
+ model->B3SOIPDlkb1 * Inv_L
+ model->B3SOIPDwkb1 * Inv_W + model->B3SOIPDpkb1 * Inv_LW;
pParam->B3SOIPDw0 = model->B3SOIPDw0
+ model->B3SOIPDlw0 * Inv_L
+ model->B3SOIPDww0 * Inv_W + model->B3SOIPDpw0 * Inv_LW;
pParam->B3SOIPDnlx = model->B3SOIPDnlx
+ model->B3SOIPDlnlx * Inv_L
+ model->B3SOIPDwnlx * Inv_W + model->B3SOIPDpnlx * Inv_LW;
pParam->B3SOIPDdvt0 = model->B3SOIPDdvt0
+ model->B3SOIPDldvt0 * Inv_L
+ model->B3SOIPDwdvt0 * Inv_W + model->B3SOIPDpdvt0 * Inv_LW;
pParam->B3SOIPDdvt1 = model->B3SOIPDdvt1
+ model->B3SOIPDldvt1 * Inv_L
+ model->B3SOIPDwdvt1 * Inv_W + model->B3SOIPDpdvt1 * Inv_LW;
pParam->B3SOIPDdvt2 = model->B3SOIPDdvt2
+ model->B3SOIPDldvt2 * Inv_L
+ model->B3SOIPDwdvt2 * Inv_W + model->B3SOIPDpdvt2 * Inv_LW;
pParam->B3SOIPDdvt0w = model->B3SOIPDdvt0w
+ model->B3SOIPDldvt0w * Inv_L
+ model->B3SOIPDwdvt0w * Inv_W
+ model->B3SOIPDpdvt0w * Inv_LW;
pParam->B3SOIPDdvt1w = model->B3SOIPDdvt1w
+ model->B3SOIPDldvt1w * Inv_L
+ model->B3SOIPDwdvt1w * Inv_W
+ model->B3SOIPDpdvt1w * Inv_LW;
pParam->B3SOIPDdvt2w = model->B3SOIPDdvt2w
+ model->B3SOIPDldvt2w * Inv_L
+ model->B3SOIPDwdvt2w * Inv_W
+ model->B3SOIPDpdvt2w * Inv_LW;
pParam->B3SOIPDu0 = model->B3SOIPDu0
+ model->B3SOIPDlu0 * Inv_L
+ model->B3SOIPDwu0 * Inv_W + model->B3SOIPDpu0 * Inv_LW;
pParam->B3SOIPDua = model->B3SOIPDua
+ model->B3SOIPDlua * Inv_L
+ model->B3SOIPDwua * Inv_W + model->B3SOIPDpua * Inv_LW;
pParam->B3SOIPDub = model->B3SOIPDub
+ model->B3SOIPDlub * Inv_L
+ model->B3SOIPDwub * Inv_W + model->B3SOIPDpub * Inv_LW;
pParam->B3SOIPDuc = model->B3SOIPDuc
+ model->B3SOIPDluc * Inv_L
+ model->B3SOIPDwuc * Inv_W + model->B3SOIPDpuc * Inv_LW;
pParam->B3SOIPDvsat = model->B3SOIPDvsat
+ model->B3SOIPDlvsat * Inv_L
+ model->B3SOIPDwvsat * Inv_W + model->B3SOIPDpvsat * Inv_LW;
pParam->B3SOIPDa0 = model->B3SOIPDa0
+ model->B3SOIPDla0 * Inv_L
+ model->B3SOIPDwa0 * Inv_W + model->B3SOIPDpa0 * Inv_LW;
pParam->B3SOIPDags = model->B3SOIPDags
+ model->B3SOIPDlags * Inv_L
+ model->B3SOIPDwags * Inv_W + model->B3SOIPDpags * Inv_LW;
pParam->B3SOIPDb0 = model->B3SOIPDb0
+ model->B3SOIPDlb0 * Inv_L
+ model->B3SOIPDwb0 * Inv_W + model->B3SOIPDpb0 * Inv_LW;
pParam->B3SOIPDb1 = model->B3SOIPDb1
+ model->B3SOIPDlb1 * Inv_L
+ model->B3SOIPDwb1 * Inv_W + model->B3SOIPDpb1 * Inv_LW;
pParam->B3SOIPDketa = model->B3SOIPDketa
+ model->B3SOIPDlketa * Inv_L
+ model->B3SOIPDwketa * Inv_W + model->B3SOIPDpketa * Inv_LW;
pParam->B3SOIPDketas = model->B3SOIPDketas
+ model->B3SOIPDlketas * Inv_L
+ model->B3SOIPDwketas * Inv_W
+ model->B3SOIPDpketas * Inv_LW;
pParam->B3SOIPDa1 = model->B3SOIPDa1
+ model->B3SOIPDla1 * Inv_L
+ model->B3SOIPDwa1 * Inv_W + model->B3SOIPDpa1 * Inv_LW;
pParam->B3SOIPDa2 = model->B3SOIPDa2
+ model->B3SOIPDla2 * Inv_L
+ model->B3SOIPDwa2 * Inv_W + model->B3SOIPDpa2 * Inv_LW;
pParam->B3SOIPDrdsw = model->B3SOIPDrdsw
+ model->B3SOIPDlrdsw * Inv_L
+ model->B3SOIPDwrdsw * Inv_W + model->B3SOIPDprdsw * Inv_LW;
pParam->B3SOIPDprwb = model->B3SOIPDprwb
+ model->B3SOIPDlprwb * Inv_L
+ model->B3SOIPDwprwb * Inv_W + model->B3SOIPDpprwb * Inv_LW;
pParam->B3SOIPDprwg = model->B3SOIPDprwg
+ model->B3SOIPDlprwg * Inv_L
+ model->B3SOIPDwprwg * Inv_W + model->B3SOIPDpprwg * Inv_LW;
pParam->B3SOIPDwr = model->B3SOIPDwr
+ model->B3SOIPDlwr * Inv_L
+ model->B3SOIPDwwr * Inv_W + model->B3SOIPDpwr * Inv_LW;
pParam->B3SOIPDnfactor = model->B3SOIPDnfactor
+ model->B3SOIPDlnfactor * Inv_L
+ model->B3SOIPDwnfactor * Inv_W
+ model->B3SOIPDpnfactor * Inv_LW;
pParam->B3SOIPDdwg = model->B3SOIPDdwg
+ model->B3SOIPDldwg * Inv_L
+ model->B3SOIPDwdwg * Inv_W + model->B3SOIPDpdwg * Inv_LW;
pParam->B3SOIPDdwb = model->B3SOIPDdwb
+ model->B3SOIPDldwb * Inv_L
+ model->B3SOIPDwdwb * Inv_W + model->B3SOIPDpdwb * Inv_LW;
pParam->B3SOIPDvoff = model->B3SOIPDvoff
+ model->B3SOIPDlvoff * Inv_L
+ model->B3SOIPDwvoff * Inv_W + model->B3SOIPDpvoff * Inv_LW;
pParam->B3SOIPDeta0 = model->B3SOIPDeta0
+ model->B3SOIPDleta0 * Inv_L
+ model->B3SOIPDweta0 * Inv_W + model->B3SOIPDpeta0 * Inv_LW;
pParam->B3SOIPDetab = model->B3SOIPDetab
+ model->B3SOIPDletab * Inv_L
+ model->B3SOIPDwetab * Inv_W + model->B3SOIPDpetab * Inv_LW;
pParam->B3SOIPDdsub = model->B3SOIPDdsub
+ model->B3SOIPDldsub * Inv_L
+ model->B3SOIPDwdsub * Inv_W + model->B3SOIPDpdsub * Inv_LW;
pParam->B3SOIPDcit = model->B3SOIPDcit
+ model->B3SOIPDlcit * Inv_L
+ model->B3SOIPDwcit * Inv_W + model->B3SOIPDpcit * Inv_LW;
pParam->B3SOIPDcdsc = model->B3SOIPDcdsc
+ model->B3SOIPDlcdsc * Inv_L
+ model->B3SOIPDwcdsc * Inv_W + model->B3SOIPDpcdsc * Inv_LW;
pParam->B3SOIPDcdscb = model->B3SOIPDcdscb
+ model->B3SOIPDlcdscb * Inv_L
+ model->B3SOIPDwcdscb * Inv_W
+ model->B3SOIPDpcdscb * Inv_LW;
pParam->B3SOIPDcdscd = model->B3SOIPDcdscd
+ model->B3SOIPDlcdscd * Inv_L
+ model->B3SOIPDwcdscd * Inv_W
+ model->B3SOIPDpcdscd * Inv_LW;
pParam->B3SOIPDpclm = model->B3SOIPDpclm
+ model->B3SOIPDlpclm * Inv_L
+ model->B3SOIPDwpclm * Inv_W + model->B3SOIPDppclm * Inv_LW;
pParam->B3SOIPDpdibl1 = model->B3SOIPDpdibl1
+ model->B3SOIPDlpdibl1 * Inv_L
+ model->B3SOIPDwpdibl1 * Inv_W
+ model->B3SOIPDppdibl1 * Inv_LW;
pParam->B3SOIPDpdibl2 = model->B3SOIPDpdibl2
+ model->B3SOIPDlpdibl2 * Inv_L
+ model->B3SOIPDwpdibl2 * Inv_W
+ model->B3SOIPDppdibl2 * Inv_LW;
pParam->B3SOIPDpdiblb = model->B3SOIPDpdiblb
+ model->B3SOIPDlpdiblb * Inv_L
+ model->B3SOIPDwpdiblb * Inv_W
+ model->B3SOIPDppdiblb * Inv_LW;
pParam->B3SOIPDdrout = model->B3SOIPDdrout
+ model->B3SOIPDldrout * Inv_L
+ model->B3SOIPDwdrout * Inv_W
+ model->B3SOIPDpdrout * Inv_LW;
pParam->B3SOIPDpvag = model->B3SOIPDpvag
+ model->B3SOIPDlpvag * Inv_L
+ model->B3SOIPDwpvag * Inv_W + model->B3SOIPDppvag * Inv_LW;
pParam->B3SOIPDdelta = model->B3SOIPDdelta
+ model->B3SOIPDldelta * Inv_L
+ model->B3SOIPDwdelta * Inv_W
+ model->B3SOIPDpdelta * Inv_LW;
pParam->B3SOIPDalpha0 = model->B3SOIPDalpha0
+ model->B3SOIPDlalpha0 * Inv_L
+ model->B3SOIPDwalpha0 * Inv_W
+ model->B3SOIPDpalpha0 * Inv_LW;
pParam->B3SOIPDfbjtii = model->B3SOIPDfbjtii
+ model->B3SOIPDlfbjtii * Inv_L
+ model->B3SOIPDwfbjtii * Inv_W
+ model->B3SOIPDpfbjtii * Inv_LW;
pParam->B3SOIPDbeta0 = model->B3SOIPDbeta0
+ model->B3SOIPDlbeta0 * Inv_L
+ model->B3SOIPDwbeta0 * Inv_W
+ model->B3SOIPDpbeta0 * Inv_LW;
pParam->B3SOIPDbeta1 = model->B3SOIPDbeta1
+ model->B3SOIPDlbeta1 * Inv_L
+ model->B3SOIPDwbeta1 * Inv_W
+ model->B3SOIPDpbeta1 * Inv_LW;
pParam->B3SOIPDbeta2 = model->B3SOIPDbeta2
+ model->B3SOIPDlbeta2 * Inv_L
+ model->B3SOIPDwbeta2 * Inv_W
+ model->B3SOIPDpbeta2 * Inv_LW;
pParam->B3SOIPDvdsatii0 = model->B3SOIPDvdsatii0
+ model->B3SOIPDlvdsatii0 * Inv_L
+ model->B3SOIPDwvdsatii0 * Inv_W
+ model->B3SOIPDpvdsatii0 * Inv_LW;
pParam->B3SOIPDlii = model->B3SOIPDlii
+ model->B3SOIPDllii * Inv_L
+ model->B3SOIPDwlii * Inv_W + model->B3SOIPDplii * Inv_LW;
pParam->B3SOIPDesatii = model->B3SOIPDesatii
+ model->B3SOIPDlesatii * Inv_L
+ model->B3SOIPDwesatii * Inv_W
+ model->B3SOIPDpesatii * Inv_LW;
pParam->B3SOIPDsii0 = model->B3SOIPDsii0
+ model->B3SOIPDlsii0 * Inv_L
+ model->B3SOIPDwsii0 * Inv_W + model->B3SOIPDpsii0 * Inv_LW;
pParam->B3SOIPDsii1 = model->B3SOIPDsii1
+ model->B3SOIPDlsii1 * Inv_L
+ model->B3SOIPDwsii1 * Inv_W + model->B3SOIPDpsii1 * Inv_LW;
pParam->B3SOIPDsii2 = model->B3SOIPDsii2
+ model->B3SOIPDlsii2 * Inv_L
+ model->B3SOIPDwsii2 * Inv_W + model->B3SOIPDpsii2 * Inv_LW;
pParam->B3SOIPDsiid = model->B3SOIPDsiid
+ model->B3SOIPDlsiid * Inv_L
+ model->B3SOIPDwsiid * Inv_W + model->B3SOIPDpsiid * Inv_LW;
pParam->B3SOIPDagidl = model->B3SOIPDagidl
+ model->B3SOIPDlagidl * Inv_L
+ model->B3SOIPDwagidl * Inv_W
+ model->B3SOIPDpagidl * Inv_LW;
pParam->B3SOIPDbgidl = model->B3SOIPDbgidl
+ model->B3SOIPDlbgidl * Inv_L
+ model->B3SOIPDwbgidl * Inv_W
+ model->B3SOIPDpbgidl * Inv_LW;
pParam->B3SOIPDngidl = model->B3SOIPDngidl
+ model->B3SOIPDlngidl * Inv_L
+ model->B3SOIPDwngidl * Inv_W
+ model->B3SOIPDpngidl * Inv_LW;
pParam->B3SOIPDntun = model->B3SOIPDntun
+ model->B3SOIPDlntun * Inv_L
+ model->B3SOIPDwntun * Inv_W + model->B3SOIPDpntun * Inv_LW;
pParam->B3SOIPDndiode = model->B3SOIPDndiode
+ model->B3SOIPDlndiode * Inv_L
+ model->B3SOIPDwndiode * Inv_W
+ model->B3SOIPDpndiode * Inv_LW;
pParam->B3SOIPDnrecf0 = model->B3SOIPDnrecf0
+ model->B3SOIPDlnrecf0 * Inv_L
+ model->B3SOIPDwnrecf0 * Inv_W
+ model->B3SOIPDpnrecf0 * Inv_LW;
pParam->B3SOIPDnrecr0 = model->B3SOIPDnrecr0
+ model->B3SOIPDlnrecr0 * Inv_L
+ model->B3SOIPDwnrecr0 * Inv_W
+ model->B3SOIPDpnrecr0 * Inv_LW;
pParam->B3SOIPDisbjt = model->B3SOIPDisbjt
+ model->B3SOIPDlisbjt * Inv_L
+ model->B3SOIPDwisbjt * Inv_W
+ model->B3SOIPDpisbjt * Inv_LW;
pParam->B3SOIPDisdif = model->B3SOIPDisdif
+ model->B3SOIPDlisdif * Inv_L
+ model->B3SOIPDwisdif * Inv_W
+ model->B3SOIPDpisdif * Inv_LW;
pParam->B3SOIPDisrec = model->B3SOIPDisrec
+ model->B3SOIPDlisrec * Inv_L
+ model->B3SOIPDwisrec * Inv_W
+ model->B3SOIPDpisrec * Inv_LW;
pParam->B3SOIPDistun = model->B3SOIPDistun
+ model->B3SOIPDlistun * Inv_L
+ model->B3SOIPDwistun * Inv_W
+ model->B3SOIPDpistun * Inv_LW;
pParam->B3SOIPDvrec0 = model->B3SOIPDvrec0
+ model->B3SOIPDlvrec0 * Inv_L
+ model->B3SOIPDwvrec0 * Inv_W
+ model->B3SOIPDpvrec0 * Inv_LW;
pParam->B3SOIPDvtun0 = model->B3SOIPDvtun0
+ model->B3SOIPDlvtun0 * Inv_L
+ model->B3SOIPDwvtun0 * Inv_W
+ model->B3SOIPDpvtun0 * Inv_LW;
pParam->B3SOIPDnbjt = model->B3SOIPDnbjt
+ model->B3SOIPDlnbjt * Inv_L
+ model->B3SOIPDwnbjt * Inv_W + model->B3SOIPDpnbjt * Inv_LW;
pParam->B3SOIPDlbjt0 = model->B3SOIPDlbjt0
+ model->B3SOIPDllbjt0 * Inv_L
+ model->B3SOIPDwlbjt0 * Inv_W
+ model->B3SOIPDplbjt0 * Inv_LW;
pParam->B3SOIPDvabjt = model->B3SOIPDvabjt
+ model->B3SOIPDlvabjt * Inv_L
+ model->B3SOIPDwvabjt * Inv_W
+ model->B3SOIPDpvabjt * Inv_LW;
pParam->B3SOIPDaely = model->B3SOIPDaely
+ model->B3SOIPDlaely * Inv_L
+ model->B3SOIPDwaely * Inv_W + model->B3SOIPDpaely * Inv_LW;
pParam->B3SOIPDahli = model->B3SOIPDahli
+ model->B3SOIPDlahli * Inv_L
+ model->B3SOIPDwahli * Inv_W + model->B3SOIPDpahli * Inv_LW;
/* CV model */
pParam->B3SOIPDvsdfb = model->B3SOIPDvsdfb
+ model->B3SOIPDlvsdfb * Inv_L
+ model->B3SOIPDwvsdfb * Inv_W
+ model->B3SOIPDpvsdfb * Inv_LW;
pParam->B3SOIPDvsdth = model->B3SOIPDvsdth
+ model->B3SOIPDlvsdth * Inv_L
+ model->B3SOIPDwvsdth * Inv_W
+ model->B3SOIPDpvsdth * Inv_LW;
pParam->B3SOIPDdelvt = model->B3SOIPDdelvt
+ model->B3SOIPDldelvt * Inv_L
+ model->B3SOIPDwdelvt * Inv_W
+ model->B3SOIPDpdelvt * Inv_LW;
pParam->B3SOIPDacde = model->B3SOIPDacde
+ model->B3SOIPDlacde * Inv_L
+ model->B3SOIPDwacde * Inv_W + model->B3SOIPDpacde * Inv_LW;
pParam->B3SOIPDmoin = model->B3SOIPDmoin
+ model->B3SOIPDlmoin * Inv_L
+ model->B3SOIPDwmoin * Inv_W + model->B3SOIPDpmoin * Inv_LW;
/* Added for binning - END */
T0 = (TempRatio - 1.0);
pParam->B3SOIPDuatemp = pParam->B3SOIPDua; /* save ua, ub, and uc for b3soild.c */
pParam->B3SOIPDubtemp = pParam->B3SOIPDub;
pParam->B3SOIPDuctemp = pParam->B3SOIPDuc;
pParam->B3SOIPDrds0denom =
pow (pParam->B3SOIPDweff * 1E6, pParam->B3SOIPDwr);
/* v2.2 release */
pParam->B3SOIPDrth =
here->B3SOIPDrth0 / (pParam->B3SOIPDweff +
model->B3SOIPDwth0) * here->B3SOIPDnseg;
pParam->B3SOIPDcth =
here->B3SOIPDcth0 * (pParam->B3SOIPDweff +
model->B3SOIPDwth0) / here->B3SOIPDnseg;
pParam->B3SOIPDrbody =
model->B3SOIPDrbody * model->B3SOIPDrhalo / (2 *
model->
B3SOIPDrbody +
model->
B3SOIPDrhalo *
pParam->
B3SOIPDleff) *
pParam->B3SOIPDweff / here->B3SOIPDnseg;
pParam->B3SOIPDoxideRatio =
pow (model->B3SOIPDtoxref / model->B3SOIPDtoxqm,
model->B3SOIPDntox) / model->B3SOIPDtoxqm /
model->B3SOIPDtoxqm;
/* v2.2 release */
pParam->B3SOIPDua = pParam->B3SOIPDua + pParam->B3SOIPDua1 * T0;
pParam->B3SOIPDub = pParam->B3SOIPDub + pParam->B3SOIPDub1 * T0;
pParam->B3SOIPDuc = pParam->B3SOIPDuc + pParam->B3SOIPDuc1 * T0;
if (pParam->B3SOIPDu0 > 1.0)
pParam->B3SOIPDu0 = pParam->B3SOIPDu0 / 1.0e4;
pParam->B3SOIPDu0temp = pParam->B3SOIPDu0
* pow (TempRatio, pParam->B3SOIPDute);
pParam->B3SOIPDvsattemp =
pParam->B3SOIPDvsat - pParam->B3SOIPDat * T0;
pParam->B3SOIPDrds0 =
(pParam->B3SOIPDrdsw +
pParam->B3SOIPDprt * T0) / pow (pParam->B3SOIPDweff * 1E6,
pParam->B3SOIPDwr);
if (B3SOIPDcheckModel (model, here, ckt))
{
IFuid namarray[2];
namarray[0] = model->B3SOIPDmodName;
namarray[1] = here->B3SOIPDname;
(*(SPfrontEnd->IFerror)) (ERR_FATAL,
"Fatal error(s) detected during B3SOIPDV3 parameter checking for %s in model %s",
namarray);
return (E_BADPARM);
}
pParam->B3SOIPDcgdo = (model->B3SOIPDcgdo + pParam->B3SOIPDcf)
* pParam->B3SOIPDwdiodCV;
pParam->B3SOIPDcgso = (model->B3SOIPDcgso + pParam->B3SOIPDcf)
* pParam->B3SOIPDwdiosCV;
pParam->B3SOIPDcgeo = model->B3SOIPDcgeo
* pParam->B3SOIPDleffCV;
if (!model->B3SOIPDnpeakGiven && model->B3SOIPDgamma1Given)
{
T0 = pParam->B3SOIPDgamma1 * model->B3SOIPDcox;
pParam->B3SOIPDnpeak = 3.021E22 * T0 * T0;
}
T4 = Eg300 / model->B3SOIPDvtm * (TempRatio - 1.0);
T7 = model->B3SOIPDxbjt * T4 / pParam->B3SOIPDndiode;
DEXP (T7, T0);
T7 = model->B3SOIPDxdif * T4 / pParam->B3SOIPDndiode;
DEXP (T7, T1);
T7 = model->B3SOIPDxrec * T4 / pParam->B3SOIPDnrecf0;
DEXP (T7, T2);
pParam->B3SOIPDahli = pParam->B3SOIPDahli * T0;
pParam->B3SOIPDjbjt = pParam->B3SOIPDisbjt * T0;
pParam->B3SOIPDjdif = pParam->B3SOIPDisdif * T1;
pParam->B3SOIPDjrec = pParam->B3SOIPDisrec * T2;
T7 = model->B3SOIPDxtun * (TempRatio - 1);
DEXP (T7, T0);
pParam->B3SOIPDjtun = pParam->B3SOIPDistun * T0;
if (pParam->B3SOIPDnsub > 0)
pParam->B3SOIPDvfbb =
-model->B3SOIPDtype * model->B3SOIPDvtm *
log (pParam->B3SOIPDnpeak / pParam->B3SOIPDnsub);
else
pParam->B3SOIPDvfbb =
-model->B3SOIPDtype * model->B3SOIPDvtm *
log (-pParam->B3SOIPDnpeak * pParam->B3SOIPDnsub / ni / ni);
if (!model->B3SOIPDvsdfbGiven)
{
if (pParam->B3SOIPDnsub > 0)
pParam->B3SOIPDvsdfb =
-model->B3SOIPDtype * (model->B3SOIPDvtm *
log (1e20 * pParam->B3SOIPDnsub /
ni / ni) - 0.3);
else if (pParam->B3SOIPDnsub < 0)
pParam->B3SOIPDvsdfb =
-model->B3SOIPDtype * (model->B3SOIPDvtm *
log (-1e20 /
pParam->B3SOIPDnsub) + 0.3);
}
/* Phi & Gamma */
SDphi =
2.0 * model->B3SOIPDvtm * log (fabs (pParam->B3SOIPDnsub) /
ni);
SDgamma =
5.753e-12 * sqrt (fabs (pParam->B3SOIPDnsub)) /
model->B3SOIPDcbox;
if (!model->B3SOIPDvsdthGiven)
{
if (((pParam->B3SOIPDnsub > 0) && (model->B3SOIPDtype > 0))
|| ((pParam->B3SOIPDnsub < 0)
&& (model->B3SOIPDtype < 0)))
pParam->B3SOIPDvsdth =
pParam->B3SOIPDvsdfb + SDphi + SDgamma * sqrt (SDphi);
else
pParam->B3SOIPDvsdth =
pParam->B3SOIPDvsdfb - SDphi - SDgamma * sqrt (SDphi);
}
if (!model->B3SOIPDcsdminGiven)
{
/* Cdmin */
tmp = sqrt (2.0 * EPSSI * SDphi / (Charge_q *
fabs (pParam->
B3SOIPDnsub) *
1.0e6));
tmp1 = EPSSI / tmp;
model->B3SOIPDcsdmin = tmp1 * model->B3SOIPDcbox /
(tmp1 + model->B3SOIPDcbox);
}
T0 = model->B3SOIPDcsdesw * log (1 + model->B3SOIPDtsi /
model->B3SOIPDtbox);
T1 = here->B3SOIPDsourcePerimeter - here->B3SOIPDw;
if (T1 > 0.0)
pParam->B3SOIPDcsesw = T0 * T1;
else
pParam->B3SOIPDcsesw = 0.0;
T1 = here->B3SOIPDdrainPerimeter - here->B3SOIPDw;
if (T1 > 0.0)
pParam->B3SOIPDcdesw = T0 * T1;
else
pParam->B3SOIPDcdesw = 0.0;
pParam->B3SOIPDphi = 2.0 * model->B3SOIPDvtm
* log (pParam->B3SOIPDnpeak / ni);
pParam->B3SOIPDsqrtPhi = sqrt (pParam->B3SOIPDphi);
pParam->B3SOIPDphis3 =
pParam->B3SOIPDsqrtPhi * pParam->B3SOIPDphi;
pParam->B3SOIPDXdep0 = sqrt (2.0 * EPSSI / (Charge_q
*
pParam->
B3SOIPDnpeak *
1.0e6)) *
pParam->B3SOIPDsqrtPhi;
pParam->B3SOIPDsqrtXdep0 = sqrt (pParam->B3SOIPDXdep0);
pParam->B3SOIPDlitl = sqrt (3.0 * model->B3SOIPDxj
* model->B3SOIPDtox);
pParam->B3SOIPDvbi = model->B3SOIPDvtm * log (1.0e20
*
pParam->
B3SOIPDnpeak /
(ni * ni));
pParam->B3SOIPDcdep0 =
sqrt (Charge_q * EPSSI * pParam->B3SOIPDnpeak * 1.0e6 / 2.0 /
pParam->B3SOIPDphi);
if (model->B3SOIPDk1Given || model->B3SOIPDk2Given)
{
if (!model->B3SOIPDk1Given)
{
fprintf (stdout,
"Warning: k1 should be specified with k2.\n");
pParam->B3SOIPDk1 = 0.53;
}
if (!model->B3SOIPDk2Given)
{
fprintf (stdout,
"Warning: k2 should be specified with k1.\n");
pParam->B3SOIPDk2 = -0.0186;
}
if (model->B3SOIPDxtGiven)
fprintf (stdout,
"Warning: xt is ignored because k1 or k2 is given.\n");
if (model->B3SOIPDvbxGiven)
fprintf (stdout,
"Warning: vbx is ignored because k1 or k2 is given.\n");
if (model->B3SOIPDvbmGiven)
fprintf (stdout,
"Warning: vbm is ignored because k1 or k2 is given.\n");
if (model->B3SOIPDgamma1Given)
fprintf (stdout,
"Warning: gamma1 is ignored because k1 or k2 is given.\n");
if (model->B3SOIPDgamma2Given)
fprintf (stdout,
"Warning: gamma2 is ignored because k1 or k2 is given.\n");
}
else
{
if (!model->B3SOIPDvbxGiven)
pParam->B3SOIPDvbx = pParam->B3SOIPDphi - 7.7348e-4
* pParam->B3SOIPDnpeak
* pParam->B3SOIPDxt * pParam->B3SOIPDxt;
if (pParam->B3SOIPDvbx > 0.0)
pParam->B3SOIPDvbx = -pParam->B3SOIPDvbx;
if (pParam->B3SOIPDvbm > 0.0)
pParam->B3SOIPDvbm = -pParam->B3SOIPDvbm;
if (!model->B3SOIPDgamma1Given)
pParam->B3SOIPDgamma1 = 5.753e-12
* sqrt (pParam->B3SOIPDnpeak) / model->B3SOIPDcox;
if (!model->B3SOIPDgamma2Given)
pParam->B3SOIPDgamma2 = 5.753e-12
* sqrt (pParam->B3SOIPDnsub) / model->B3SOIPDcox;
T0 = pParam->B3SOIPDgamma1 - pParam->B3SOIPDgamma2;
T1 = sqrt (pParam->B3SOIPDphi - pParam->B3SOIPDvbx)
- pParam->B3SOIPDsqrtPhi;
T2 = sqrt (pParam->B3SOIPDphi * (pParam->B3SOIPDphi
- pParam->B3SOIPDvbm)) -
pParam->B3SOIPDphi;
pParam->B3SOIPDk2 =
T0 * T1 / (2.0 * T2 + pParam->B3SOIPDvbm);
pParam->B3SOIPDk1 =
pParam->B3SOIPDgamma2 -
2.0 * pParam->B3SOIPDk2 * sqrt (pParam->B3SOIPDphi -
pParam->B3SOIPDvbm);
}
if (pParam->B3SOIPDk2 < 0.0)
{
T0 = 0.5 * pParam->B3SOIPDk1 / pParam->B3SOIPDk2;
pParam->B3SOIPDvbsc = 0.9 * (pParam->B3SOIPDphi - T0 * T0);
if (pParam->B3SOIPDvbsc > -3.0)
pParam->B3SOIPDvbsc = -3.0;
else if (pParam->B3SOIPDvbsc < -30.0)
pParam->B3SOIPDvbsc = -30.0;
}
else
{
pParam->B3SOIPDvbsc = -30.0;
}
if (pParam->B3SOIPDvbsc > pParam->B3SOIPDvbm)
pParam->B3SOIPDvbsc = pParam->B3SOIPDvbm;
if ((T0 = pParam->B3SOIPDweff + pParam->B3SOIPDk1w2) < 1e-8)
T0 = 1e-8;
pParam->B3SOIPDk1eff =
pParam->B3SOIPDk1 * (1 + pParam->B3SOIPDk1w1 / T0);
if (model->B3SOIPDvth0Given)
{
pParam->B3SOIPDvfb =
model->B3SOIPDtype * pParam->B3SOIPDvth0 -
pParam->B3SOIPDphi -
pParam->B3SOIPDk1eff * pParam->B3SOIPDsqrtPhi;
}
else
{
pParam->B3SOIPDvfb = -1.0;
pParam->B3SOIPDvth0 =
model->B3SOIPDtype * (pParam->B3SOIPDvfb +
pParam->B3SOIPDphi +
pParam->B3SOIPDk1eff *
pParam->B3SOIPDsqrtPhi);
}
T1 = sqrt (EPSSI / EPSOX * model->B3SOIPDtox
* pParam->B3SOIPDXdep0);
T0 =
exp (-0.5 * pParam->B3SOIPDdsub * pParam->B3SOIPDleff / T1);
pParam->B3SOIPDtheta0vb0 = (T0 + 2.0 * T0 * T0);
T0 =
exp (-0.5 * pParam->B3SOIPDdrout * pParam->B3SOIPDleff / T1);
T2 = (T0 + 2.0 * T0 * T0);
pParam->B3SOIPDthetaRout = pParam->B3SOIPDpdibl1 * T2
+ pParam->B3SOIPDpdibl2;
}
here->B3SOIPDcsbox = model->B3SOIPDcbox * here->B3SOIPDsourceArea;
here->B3SOIPDcsmin = model->B3SOIPDcsdmin * here->B3SOIPDsourceArea;
here->B3SOIPDcdbox = model->B3SOIPDcbox * here->B3SOIPDdrainArea;
here->B3SOIPDcdmin = model->B3SOIPDcsdmin * here->B3SOIPDdrainArea;
if (((pParam->B3SOIPDnsub > 0) && (model->B3SOIPDtype > 0)) ||
((pParam->B3SOIPDnsub < 0) && (model->B3SOIPDtype < 0)))
{
T0 = pParam->B3SOIPDvsdth - pParam->B3SOIPDvsdfb;
pParam->B3SOIPDsdt1 =
pParam->B3SOIPDvsdfb + model->B3SOIPDasd * T0;
T1 = here->B3SOIPDcsbox - here->B3SOIPDcsmin;
T2 = T1 / T0 / T0;
pParam->B3SOIPDst2 = T2 / model->B3SOIPDasd;
pParam->B3SOIPDst3 = T2 / (1 - model->B3SOIPDasd);
here->B3SOIPDst4 = T0 * T1 * (1 + model->B3SOIPDasd) / 3
- here->B3SOIPDcsmin * pParam->B3SOIPDvsdfb;
T1 = here->B3SOIPDcdbox - here->B3SOIPDcdmin;
T2 = T1 / T0 / T0;
pParam->B3SOIPDdt2 = T2 / model->B3SOIPDasd;
pParam->B3SOIPDdt3 = T2 / (1 - model->B3SOIPDasd);
here->B3SOIPDdt4 = T0 * T1 * (1 + model->B3SOIPDasd) / 3
- here->B3SOIPDcdmin * pParam->B3SOIPDvsdfb;
}
else
{
T0 = pParam->B3SOIPDvsdfb - pParam->B3SOIPDvsdth;
pParam->B3SOIPDsdt1 =
pParam->B3SOIPDvsdth + model->B3SOIPDasd * T0;
T1 = here->B3SOIPDcsmin - here->B3SOIPDcsbox;
T2 = T1 / T0 / T0;
pParam->B3SOIPDst2 = T2 / model->B3SOIPDasd;
pParam->B3SOIPDst3 = T2 / (1 - model->B3SOIPDasd);
here->B3SOIPDst4 = T0 * T1 * (1 + model->B3SOIPDasd) / 3
- here->B3SOIPDcsbox * pParam->B3SOIPDvsdth;
T1 = here->B3SOIPDcdmin - here->B3SOIPDcdbox;
T2 = T1 / T0 / T0;
pParam->B3SOIPDdt2 = T2 / model->B3SOIPDasd;
pParam->B3SOIPDdt3 = T2 / (1 - model->B3SOIPDasd);
here->B3SOIPDdt4 = T0 * T1 * (1 + model->B3SOIPDasd) / 3
- here->B3SOIPDcdbox * pParam->B3SOIPDvsdth;
}
here->B3SOIPDphi = pParam->B3SOIPDphi;
/* process source/drain series resistance */
here->B3SOIPDdrainConductance = model->B3SOIPDsheetResistance
* here->B3SOIPDdrainSquares;
if (here->B3SOIPDdrainConductance > 0.0)
here->B3SOIPDdrainConductance = 1.0
/ here->B3SOIPDdrainConductance;
else
here->B3SOIPDdrainConductance = 0.0;
here->B3SOIPDsourceConductance = model->B3SOIPDsheetResistance
* here->B3SOIPDsourceSquares;
if (here->B3SOIPDsourceConductance > 0.0)
here->B3SOIPDsourceConductance = 1.0
/ here->B3SOIPDsourceConductance;
else
here->B3SOIPDsourceConductance = 0.0;
here->B3SOIPDcgso = pParam->B3SOIPDcgso;
here->B3SOIPDcgdo = pParam->B3SOIPDcgdo;
/* v2.0 release */
if (model->B3SOIPDln < 1e-15)
model->B3SOIPDln = 1e-15;
T0 =
-0.5 * pParam->B3SOIPDleff * pParam->B3SOIPDleff /
model->B3SOIPDln / model->B3SOIPDln;
DEXP (T0, T1);
pParam->B3SOIPDarfabjt = T1;
T0 =
pParam->B3SOIPDlbjt0 * (1.0 / pParam->B3SOIPDleff +
1.0 / model->B3SOIPDln);
pParam->B3SOIPDlratio = pow (T0, pParam->B3SOIPDnbjt);
pParam->B3SOIPDlratiodif =
1.0 + model->B3SOIPDldif0 * pow (T0, model->B3SOIPDndif);
if (
(pParam->B3SOIPDvearly =
pParam->B3SOIPDvabjt +
pParam->B3SOIPDaely * pParam->B3SOIPDleff) < 1)
pParam->B3SOIPDvearly = 1;
/* vfbzb calculation for capMod 3 */
tmp = sqrt (pParam->B3SOIPDXdep0);
tmp1 = pParam->B3SOIPDvbi - pParam->B3SOIPDphi;
tmp2 = model->B3SOIPDfactor1 * tmp;
T0 = -0.5 * pParam->B3SOIPDdvt1w * pParam->B3SOIPDweff
* pParam->B3SOIPDleff / 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->B3SOIPDdvt0w * T2;
T2 = T0 * tmp1;
T0 = -0.5 * pParam->B3SOIPDdvt1 * pParam->B3SOIPDleff / 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->B3SOIPDdvt0 * T3 * tmp1;
T4 = model->B3SOIPDtox * pParam->B3SOIPDphi
/ (pParam->B3SOIPDweff + pParam->B3SOIPDw0);
T0 = sqrt (1.0 + pParam->B3SOIPDnlx / pParam->B3SOIPDleff);
T5 = pParam->B3SOIPDk1eff * (T0 - 1.0) * pParam->B3SOIPDsqrtPhi
+ (pParam->B3SOIPDkt1 + pParam->B3SOIPDkt1l / pParam->B3SOIPDleff)
* (TempRatio - 1.0);
tmp3 = model->B3SOIPDtype * pParam->B3SOIPDvth0
- T2 - T3 + pParam->B3SOIPDk3 * T4 + T5;
pParam->B3SOIPDvfbzb =
tmp3 - pParam->B3SOIPDphi -
pParam->B3SOIPDk1eff * pParam->B3SOIPDsqrtPhi;
/* End of vfbzb */
pParam->B3SOIPDldeb =
sqrt (EPSSI * Vtm0 / (Charge_q * pParam->B3SOIPDnpeak * 1.0e6)) /
3.0;
pParam->B3SOIPDacde =
pParam->B3SOIPDacde * pow ((pParam->B3SOIPDnpeak / 2.0e16),
-0.25);
}
}
return (OK);
}