From 5f0a6aa0fbe29d47442217fa1b6a97bbd305e8db Mon Sep 17 00:00:00 2001 From: dwarning Date: Sun, 5 May 2013 11:43:26 +0200 Subject: [PATCH] devices/bsim3: whitespace cleanup --- src/spicelib/devices/bsim3/b3.c | 171 +- src/spicelib/devices/bsim3/b3ask.c | 106 +- src/spicelib/devices/bsim3/b3ld.c | 2252 ++++++++++++------------- src/spicelib/devices/bsim3/b3par.c | 10 +- src/spicelib/devices/bsim3/b3set.c | 4 +- src/spicelib/devices/bsim3/b3temp.c | 972 +++++------ src/spicelib/devices/bsim3/bsim3def.h | 656 +++---- 7 files changed, 2084 insertions(+), 2087 deletions(-) diff --git a/src/spicelib/devices/bsim3/b3.c b/src/spicelib/devices/bsim3/b3.c index e5d288a79..c73585430 100644 --- a/src/spicelib/devices/bsim3/b3.c +++ b/src/spicelib/devices/bsim3/b3.c @@ -26,37 +26,37 @@ IOP( "nrs", BSIM3_NRS, IF_REAL , "Number of squares in source"), IOP( "off", BSIM3_OFF, IF_FLAG , "Device is initially off"), IOP( "nqsmod", BSIM3_NQSMOD, IF_INTEGER, "Non-quasi-static model selector"), IOP( "acnqsmod", BSIM3_ACNQSMOD, IF_INTEGER, "AC NQS model selector"), -IP( "ic", BSIM3_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"), -OP( "gmbs", BSIM3_GMBS, IF_REAL, "Gmb"), -OP( "gm", BSIM3_GM, IF_REAL, "Gm"), -OP( "gds", BSIM3_GDS, IF_REAL, "Gds"), -OP( "vdsat", BSIM3_VDSAT, IF_REAL, "Vdsat"), -OP( "vth", BSIM3_VON, IF_REAL, "Vth"), -OP( "id", BSIM3_CD, IF_REAL, "Ids"), -OP( "vbs", BSIM3_VBS, IF_REAL, "Vbs"), -OP( "vgs", BSIM3_VGS, IF_REAL, "Vgs"), -OP( "vds", BSIM3_VDS, IF_REAL, "Vds"), -OP( "ibd", BSIM3_CBD, IF_REAL, "Ibd"), /* newly added from here */ -OP( "ibs", BSIM3_CBS, IF_REAL, "Ibs"), -OP( "gbd", BSIM3_GBD, IF_REAL, "gbd"), -OP( "gbs", BSIM3_GBS, IF_REAL, "gbs"), -OP( "qb", BSIM3_QB, IF_REAL, "Qbulk"), -OP( "cqb", BSIM3_CQB, IF_REAL, "CQbulk"), -OP( "qg", BSIM3_QG, IF_REAL, "Qgate"), -OP( "cqg", BSIM3_CQG, IF_REAL, "CQgate"), -OP( "qd", BSIM3_QD, IF_REAL, "Qdrain"), -OP( "cqd", BSIM3_CQD, IF_REAL, "CQdrain"), -OP( "cgg", BSIM3_CGG, IF_REAL, "Cggb"), -OP( "cgd", BSIM3_CGD, IF_REAL, "Cgdb"), -OP( "cgs", BSIM3_CGS, IF_REAL, "Cgsb"), -OP( "cdg", BSIM3_CDG, IF_REAL, "Cdgb"), -OP( "cdd", BSIM3_CDD, IF_REAL, "Cddb"), -OP( "cds", BSIM3_CDS, IF_REAL, "Cdsb"), -OP( "cbg", BSIM3_CBG, IF_REAL, "Cbgb"), -OP( "cbd", BSIM3_CBDB, IF_REAL, "Cbdb"), -OP( "cbs", BSIM3_CBSB, IF_REAL, "Cbsb"), -OP( "capbd", BSIM3_CAPBD, IF_REAL, "Capbd"), -OP( "capbs", BSIM3_CAPBS, IF_REAL, "Capbs"), +IP( "ic", BSIM3_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"), +OP( "gmbs", BSIM3_GMBS, IF_REAL, "Gmb"), +OP( "gm", BSIM3_GM, IF_REAL, "Gm"), +OP( "gds", BSIM3_GDS, IF_REAL, "Gds"), +OP( "vdsat", BSIM3_VDSAT, IF_REAL, "Vdsat"), +OP( "vth", BSIM3_VON, IF_REAL, "Vth"), +OP( "id", BSIM3_CD, IF_REAL, "Ids"), +OP( "vbs", BSIM3_VBS, IF_REAL, "Vbs"), +OP( "vgs", BSIM3_VGS, IF_REAL, "Vgs"), +OP( "vds", BSIM3_VDS, IF_REAL, "Vds"), +OP( "ibd", BSIM3_CBD, IF_REAL, "Ibd"), /* newly added from here */ +OP( "ibs", BSIM3_CBS, IF_REAL, "Ibs"), +OP( "gbd", BSIM3_GBD, IF_REAL, "gbd"), +OP( "gbs", BSIM3_GBS, IF_REAL, "gbs"), +OP( "qb", BSIM3_QB, IF_REAL, "Qbulk"), +OP( "cqb", BSIM3_CQB, IF_REAL, "CQbulk"), +OP( "qg", BSIM3_QG, IF_REAL, "Qgate"), +OP( "cqg", BSIM3_CQG, IF_REAL, "CQgate"), +OP( "qd", BSIM3_QD, IF_REAL, "Qdrain"), +OP( "cqd", BSIM3_CQD, IF_REAL, "CQdrain"), +OP( "cgg", BSIM3_CGG, IF_REAL, "Cggb"), +OP( "cgd", BSIM3_CGD, IF_REAL, "Cgdb"), +OP( "cgs", BSIM3_CGS, IF_REAL, "Cgsb"), +OP( "cdg", BSIM3_CDG, IF_REAL, "Cdgb"), +OP( "cdd", BSIM3_CDD, IF_REAL, "Cddb"), +OP( "cds", BSIM3_CDS, IF_REAL, "Cdsb"), +OP( "cbg", BSIM3_CBG, IF_REAL, "Cbgb"), +OP( "cbd", BSIM3_CBDB, IF_REAL, "Cbdb"), +OP( "cbs", BSIM3_CBSB, IF_REAL, "Cbsb"), +OP( "capbd", BSIM3_CAPBD, IF_REAL, "Capbd"), +OP( "capbs", BSIM3_CAPBS, IF_REAL, "Capbs"), }; IFparm BSIM3mPTable[] = { /* model parameters */ @@ -71,15 +71,15 @@ IOP( "tox", BSIM3_MOD_TOX, IF_REAL, "Gate oxide thickness in meters"), IOP( "toxm", BSIM3_MOD_TOXM, IF_REAL, "Gate oxide thickness used in extraction"), IOP( "cdsc", BSIM3_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"), -IOP( "cdscb", BSIM3_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"), -IOP( "cdscd", BSIM3_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"), +IOP( "cdscb", BSIM3_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"), +IOP( "cdscd", BSIM3_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"), IOP( "cit", BSIM3_MOD_CIT, IF_REAL, "Interface state capacitance"), IOP( "nfactor", BSIM3_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"), IOP( "xj", BSIM3_MOD_XJ, IF_REAL, "Junction depth in meters"), IOP( "vsat", BSIM3_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"), IOP( "at", BSIM3_MOD_AT, IF_REAL, "Temperature coefficient of vsat"), -IOP( "a0", BSIM3_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."), -IOP( "ags", BSIM3_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."), +IOP( "a0", BSIM3_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."), +IOP( "ags", BSIM3_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."), IOP( "a1", BSIM3_MOD_A1, IF_REAL, "Non-saturation effect coefficient"), IOP( "a2", BSIM3_MOD_A2, IF_REAL, "Non-saturation effect coefficient"), IOP( "keta", BSIM3_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."), @@ -128,21 +128,21 @@ IOP( "xpart", BSIM3_MOD_XPART, IF_REAL, "Channel charge partitioning"), IOP( "elm", BSIM3_MOD_ELM, IF_REAL, "Non-quasi-static Elmore Constant Parameter"), IOP( "delta", BSIM3_MOD_DELTA, IF_REAL, "Effective Vds parameter"), IOP( "rsh", BSIM3_MOD_RSH, IF_REAL, "Source-drain sheet resistance"), -IOP( "rdsw", BSIM3_MOD_RDSW, IF_REAL, "Source-drain resistance per width"), +IOP( "rdsw", BSIM3_MOD_RDSW, IF_REAL, "Source-drain resistance per width"), -IOP( "prwg", BSIM3_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "), -IOP( "prwb", BSIM3_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "), +IOP( "prwg", BSIM3_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "), +IOP( "prwb", BSIM3_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "), -IOP( "prt", BSIM3_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "), +IOP( "prt", BSIM3_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "), IOP( "eta0", BSIM3_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"), IOP( "etab", BSIM3_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"), IOP( "pclm", BSIM3_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"), -IOP( "pdiblc1", BSIM3_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"), -IOP( "pdiblc2", BSIM3_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"), -IOP( "pdiblcb", BSIM3_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"), -IOP( "pscbe1", BSIM3_MOD_PSCBE1, IF_REAL, "Substrate current body-effect coefficient"), -IOP( "pscbe2", BSIM3_MOD_PSCBE2, IF_REAL, "Substrate current body-effect coefficient"), -IOP( "pvag", BSIM3_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"), +IOP( "pdiblc1", BSIM3_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"), +IOP( "pdiblc2", BSIM3_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"), +IOP( "pdiblcb", BSIM3_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"), +IOP( "pscbe1", BSIM3_MOD_PSCBE1, IF_REAL, "Substrate current body-effect coefficient"), +IOP( "pscbe2", BSIM3_MOD_PSCBE2, IF_REAL, "Substrate current body-effect coefficient"), +IOP( "pvag", BSIM3_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"), IOP( "js", BSIM3_MOD_JS, IF_REAL, "Source/drain junction reverse saturation current density"), IOP( "jsw", BSIM3_MOD_JSW, IF_REAL, "Sidewall junction reverse saturation current density"), IOP( "pb", BSIM3_MOD_PB, IF_REAL, "Source/drain junction built-in potential"), @@ -221,8 +221,8 @@ IOP( "lnfactor", BSIM3_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"), IOP( "lxj", BSIM3_MOD_LXJ, IF_REAL, "Length dependence of xj"), IOP( "lvsat", BSIM3_MOD_LVSAT, IF_REAL, "Length dependence of vsat"), IOP( "lat", BSIM3_MOD_LAT, IF_REAL, "Length dependence of at"), -IOP( "la0", BSIM3_MOD_LA0, IF_REAL, "Length dependence of a0"), -IOP( "lags", BSIM3_MOD_LAGS, IF_REAL, "Length dependence of ags"), +IOP( "la0", BSIM3_MOD_LA0, IF_REAL, "Length dependence of a0"), +IOP( "lags", BSIM3_MOD_LAGS, IF_REAL, "Length dependence of ags"), IOP( "la1", BSIM3_MOD_LA1, IF_REAL, "Length dependence of a1"), IOP( "la2", BSIM3_MOD_LA2, IF_REAL, "Length dependence of a2"), IOP( "lketa", BSIM3_MOD_LKETA, IF_REAL, "Length dependence of keta"), @@ -264,21 +264,21 @@ IOP( "lute", BSIM3_MOD_LUTE, IF_REAL, "Length dependence of ute"), IOP( "lvoff", BSIM3_MOD_LVOFF, IF_REAL, "Length dependence of voff"), IOP( "lelm", BSIM3_MOD_LELM, IF_REAL, "Length dependence of elm"), IOP( "ldelta", BSIM3_MOD_LDELTA, IF_REAL, "Length dependence of delta"), -IOP( "lrdsw", BSIM3_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "), +IOP( "lrdsw", BSIM3_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "), -IOP( "lprwg", BSIM3_MOD_LPRWG, IF_REAL, "Length dependence of prwg "), -IOP( "lprwb", BSIM3_MOD_LPRWB, IF_REAL, "Length dependence of prwb "), +IOP( "lprwg", BSIM3_MOD_LPRWG, IF_REAL, "Length dependence of prwg "), +IOP( "lprwb", BSIM3_MOD_LPRWB, IF_REAL, "Length dependence of prwb "), -IOP( "lprt", BSIM3_MOD_LPRT, IF_REAL, "Length dependence of prt "), -IOP( "leta0", BSIM3_MOD_LETA0, IF_REAL, "Length dependence of eta0"), -IOP( "letab", BSIM3_MOD_LETAB, IF_REAL, "Length dependence of etab"), -IOP( "lpclm", BSIM3_MOD_LPCLM, IF_REAL, "Length dependence of pclm"), -IOP( "lpdiblc1", BSIM3_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"), -IOP( "lpdiblc2", BSIM3_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"), -IOP( "lpdiblcb", BSIM3_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"), -IOP( "lpscbe1", BSIM3_MOD_LPSCBE1, IF_REAL, "Length dependence of pscbe1"), -IOP( "lpscbe2", BSIM3_MOD_LPSCBE2, IF_REAL, "Length dependence of pscbe2"), -IOP( "lpvag", BSIM3_MOD_LPVAG, IF_REAL, "Length dependence of pvag"), +IOP( "lprt", BSIM3_MOD_LPRT, IF_REAL, "Length dependence of prt "), +IOP( "leta0", BSIM3_MOD_LETA0, IF_REAL, "Length dependence of eta0"), +IOP( "letab", BSIM3_MOD_LETAB, IF_REAL, "Length dependence of etab"), +IOP( "lpclm", BSIM3_MOD_LPCLM, IF_REAL, "Length dependence of pclm"), +IOP( "lpdiblc1", BSIM3_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"), +IOP( "lpdiblc2", BSIM3_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"), +IOP( "lpdiblcb", BSIM3_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"), +IOP( "lpscbe1", BSIM3_MOD_LPSCBE1, IF_REAL, "Length dependence of pscbe1"), +IOP( "lpscbe2", BSIM3_MOD_LPSCBE2, IF_REAL, "Length dependence of pscbe2"), +IOP( "lpvag", BSIM3_MOD_LPVAG, IF_REAL, "Length dependence of pvag"), IOP( "lwr", BSIM3_MOD_LWR, IF_REAL, "Length dependence of wr"), IOP( "ldwg", BSIM3_MOD_LDWG, IF_REAL, "Length dependence of dwg"), IOP( "ldwb", BSIM3_MOD_LDWB, IF_REAL, "Length dependence of dwb"), @@ -300,15 +300,15 @@ IOP( "lmoin", BSIM3_MOD_LMOIN, IF_REAL, "Length dependence of moin"), IOP( "lnoff", BSIM3_MOD_LNOFF, IF_REAL, "Length dependence of noff"), IOP( "lvoffcv", BSIM3_MOD_LVOFFCV, IF_REAL, "Length dependence of voffcv"), IOP( "wcdsc", BSIM3_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"), -IOP( "wcdscb", BSIM3_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"), -IOP( "wcdscd", BSIM3_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"), +IOP( "wcdscb", BSIM3_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"), +IOP( "wcdscd", BSIM3_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"), IOP( "wcit", BSIM3_MOD_WCIT, IF_REAL, "Width dependence of cit"), IOP( "wnfactor", BSIM3_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"), IOP( "wxj", BSIM3_MOD_WXJ, IF_REAL, "Width dependence of xj"), IOP( "wvsat", BSIM3_MOD_WVSAT, IF_REAL, "Width dependence of vsat"), IOP( "wat", BSIM3_MOD_WAT, IF_REAL, "Width dependence of at"), -IOP( "wa0", BSIM3_MOD_WA0, IF_REAL, "Width dependence of a0"), -IOP( "wags", BSIM3_MOD_WAGS, IF_REAL, "Width dependence of ags"), +IOP( "wa0", BSIM3_MOD_WA0, IF_REAL, "Width dependence of a0"), +IOP( "wags", BSIM3_MOD_WAGS, IF_REAL, "Width dependence of ags"), IOP( "wa1", BSIM3_MOD_WA1, IF_REAL, "Width dependence of a1"), IOP( "wa2", BSIM3_MOD_WA2, IF_REAL, "Width dependence of a2"), IOP( "wketa", BSIM3_MOD_WKETA, IF_REAL, "Width dependence of keta"), @@ -356,15 +356,15 @@ IOP( "wprwg", BSIM3_MOD_WPRWG, IF_REAL, "Width dependence of prwg "), IOP( "wprwb", BSIM3_MOD_WPRWB, IF_REAL, "Width dependence of prwb "), IOP( "wprt", BSIM3_MOD_WPRT, IF_REAL, "Width dependence of prt"), -IOP( "weta0", BSIM3_MOD_WETA0, IF_REAL, "Width dependence of eta0"), -IOP( "wetab", BSIM3_MOD_WETAB, IF_REAL, "Width dependence of etab"), -IOP( "wpclm", BSIM3_MOD_WPCLM, IF_REAL, "Width dependence of pclm"), -IOP( "wpdiblc1", BSIM3_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"), -IOP( "wpdiblc2", BSIM3_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"), -IOP( "wpdiblcb", BSIM3_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"), -IOP( "wpscbe1", BSIM3_MOD_WPSCBE1, IF_REAL, "Width dependence of pscbe1"), -IOP( "wpscbe2", BSIM3_MOD_WPSCBE2, IF_REAL, "Width dependence of pscbe2"), -IOP( "wpvag", BSIM3_MOD_WPVAG, IF_REAL, "Width dependence of pvag"), +IOP( "weta0", BSIM3_MOD_WETA0, IF_REAL, "Width dependence of eta0"), +IOP( "wetab", BSIM3_MOD_WETAB, IF_REAL, "Width dependence of etab"), +IOP( "wpclm", BSIM3_MOD_WPCLM, IF_REAL, "Width dependence of pclm"), +IOP( "wpdiblc1", BSIM3_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"), +IOP( "wpdiblc2", BSIM3_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"), +IOP( "wpdiblcb", BSIM3_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"), +IOP( "wpscbe1", BSIM3_MOD_WPSCBE1, IF_REAL, "Width dependence of pscbe1"), +IOP( "wpscbe2", BSIM3_MOD_WPSCBE2, IF_REAL, "Width dependence of pscbe2"), +IOP( "wpvag", BSIM3_MOD_WPVAG, IF_REAL, "Width dependence of pvag"), IOP( "wwr", BSIM3_MOD_WWR, IF_REAL, "Width dependence of wr"), IOP( "wdwg", BSIM3_MOD_WDWG, IF_REAL, "Width dependence of dwg"), IOP( "wdwb", BSIM3_MOD_WDWB, IF_REAL, "Width dependence of dwb"), @@ -387,14 +387,14 @@ IOP( "wnoff", BSIM3_MOD_WNOFF, IF_REAL, "Width dependence of noff"), IOP( "wvoffcv", BSIM3_MOD_WVOFFCV, IF_REAL, "Width dependence of voffcv"), IOP( "pcdsc", BSIM3_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"), -IOP( "pcdscb", BSIM3_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"), +IOP( "pcdscb", BSIM3_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"), IOP( "pcdscd", BSIM3_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"), IOP( "pcit", BSIM3_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"), IOP( "pnfactor", BSIM3_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"), IOP( "pxj", BSIM3_MOD_PXJ, IF_REAL, "Cross-term dependence of xj"), IOP( "pvsat", BSIM3_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"), IOP( "pat", BSIM3_MOD_PAT, IF_REAL, "Cross-term dependence of at"), -IOP( "pa0", BSIM3_MOD_PA0, IF_REAL, "Cross-term dependence of a0"), +IOP( "pa0", BSIM3_MOD_PA0, IF_REAL, "Cross-term dependence of a0"), IOP( "pags", BSIM3_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"), IOP( "pa1", BSIM3_MOD_PA1, IF_REAL, "Cross-term dependence of a1"), IOP( "pa2", BSIM3_MOD_PA2, IF_REAL, "Cross-term dependence of a2"), @@ -437,10 +437,10 @@ IOP( "pute", BSIM3_MOD_PUTE, IF_REAL, "Cross-term dependence of ute"), IOP( "pvoff", BSIM3_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"), IOP( "pelm", BSIM3_MOD_PELM, IF_REAL, "Cross-term dependence of elm"), IOP( "pdelta", BSIM3_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"), -IOP( "prdsw", BSIM3_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "), +IOP( "prdsw", BSIM3_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "), -IOP( "pprwg", BSIM3_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "), -IOP( "pprwb", BSIM3_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "), +IOP( "pprwg", BSIM3_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "), +IOP( "pprwb", BSIM3_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "), IOP( "pprt", BSIM3_MOD_PPRT, IF_REAL, "Cross-term dependence of prt "), IOP( "peta0", BSIM3_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"), @@ -451,7 +451,7 @@ IOP( "ppdiblc2", BSIM3_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2") IOP( "ppdiblcb", BSIM3_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"), IOP( "ppscbe1", BSIM3_MOD_PPSCBE1, IF_REAL, "Cross-term dependence of pscbe1"), IOP( "ppscbe2", BSIM3_MOD_PPSCBE2, IF_REAL, "Cross-term dependence of pscbe2"), -IOP( "ppvag", BSIM3_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"), +IOP( "ppvag", BSIM3_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"), IOP( "pwr", BSIM3_MOD_PWR, IF_REAL, "Cross-term dependence of wr"), IOP( "pdwg", BSIM3_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"), IOP( "pdwb", BSIM3_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"), @@ -493,11 +493,8 @@ char *BSIM3names[] = { "Charge" }; -int BSIM3nSize = NUMELEMS(BSIM3names); -int BSIM3pTSize = NUMELEMS(BSIM3pTable); -int BSIM3mPTSize = NUMELEMS(BSIM3mPTable); -int BSIM3iSize = sizeof(BSIM3instance); -int BSIM3mSize = sizeof(BSIM3model); - - - +int BSIM3nSize = NUMELEMS(BSIM3names); +int BSIM3pTSize = NUMELEMS(BSIM3pTable); +int BSIM3mPTSize = NUMELEMS(BSIM3mPTable); +int BSIM3iSize = sizeof(BSIM3instance); +int BSIM3mSize = sizeof(BSIM3model); diff --git a/src/spicelib/devices/bsim3/b3ask.c b/src/spicelib/devices/bsim3/b3ask.c index 5ff21ecf2..1a0138fae 100644 --- a/src/spicelib/devices/bsim3/b3ask.c +++ b/src/spicelib/devices/bsim3/b3ask.c @@ -28,7 +28,7 @@ BSIM3instance *here = (BSIM3instance*)inst; NG_IGNORE(select); - switch(which) + switch(which) { case BSIM3_L: value->rValue = here->BSIM3l; return(OK); @@ -94,11 +94,11 @@ BSIM3instance *here = (BSIM3instance*)inst; return(OK); case BSIM3_SOURCECONDUCT: value->rValue = here->BSIM3sourceConductance; - value->rValue *= here->BSIM3m; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_DRAINCONDUCT: value->rValue = here->BSIM3drainConductance; - value->rValue *= here->BSIM3m; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_VBD: value->rValue = *(ckt->CKTstate0 + here->BSIM3vbd); @@ -113,118 +113,118 @@ BSIM3instance *here = (BSIM3instance*)inst; value->rValue = *(ckt->CKTstate0 + here->BSIM3vds); return(OK); case BSIM3_CD: - value->rValue = here->BSIM3cd; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3cd; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CBS: - value->rValue = here->BSIM3cbs; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3cbs; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CBD: - value->rValue = here->BSIM3cbd; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3cbd; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_GM: - value->rValue = here->BSIM3gm; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3gm; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_GDS: - value->rValue = here->BSIM3gds; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3gds; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_GMBS: - value->rValue = here->BSIM3gmbs; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3gmbs; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_GBD: - value->rValue = here->BSIM3gbd; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3gbd; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_GBS: - value->rValue = here->BSIM3gbs; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3gbs; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_QB: - value->rValue = *(ckt->CKTstate0 + here->BSIM3qb); - value->rValue *= here->BSIM3m; + value->rValue = *(ckt->CKTstate0 + here->BSIM3qb); + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CQB: - value->rValue = *(ckt->CKTstate0 + here->BSIM3cqb); - value->rValue *= here->BSIM3m; + value->rValue = *(ckt->CKTstate0 + here->BSIM3cqb); + value->rValue *= here->BSIM3m; return(OK); case BSIM3_QG: - value->rValue = *(ckt->CKTstate0 + here->BSIM3qg); - value->rValue *= here->BSIM3m; + value->rValue = *(ckt->CKTstate0 + here->BSIM3qg); + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CQG: - value->rValue = *(ckt->CKTstate0 + here->BSIM3cqg); - value->rValue *= here->BSIM3m; + value->rValue = *(ckt->CKTstate0 + here->BSIM3cqg); + value->rValue *= here->BSIM3m; return(OK); case BSIM3_QD: - value->rValue = *(ckt->CKTstate0 + here->BSIM3qd); - value->rValue *= here->BSIM3m; + value->rValue = *(ckt->CKTstate0 + here->BSIM3qd); + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CQD: - value->rValue = *(ckt->CKTstate0 + here->BSIM3cqd); - value->rValue *= here->BSIM3m; + value->rValue = *(ckt->CKTstate0 + here->BSIM3cqd); + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CGG: - value->rValue = here->BSIM3cggb; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3cggb; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CGD: value->rValue = here->BSIM3cgdb; - value->rValue *= here->BSIM3m; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CGS: value->rValue = here->BSIM3cgsb; - value->rValue *= here->BSIM3m; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CDG: - value->rValue = here->BSIM3cdgb; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3cdgb; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CDD: - value->rValue = here->BSIM3cddb; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3cddb; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CDS: - value->rValue = here->BSIM3cdsb; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3cdsb; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CBG: value->rValue = here->BSIM3cbgb; - value->rValue *= here->BSIM3m; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CBDB: value->rValue = here->BSIM3cbdb; - value->rValue *= here->BSIM3m; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CBSB: value->rValue = here->BSIM3cbsb; - value->rValue *= here->BSIM3m; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CAPBD: - value->rValue = here->BSIM3capbd; - value->rValue *= here->BSIM3m; + value->rValue = here->BSIM3capbd; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_CAPBS: value->rValue = here->BSIM3capbs; - value->rValue *= here->BSIM3m; + value->rValue *= here->BSIM3m; return(OK); case BSIM3_VON: - value->rValue = here->BSIM3von; + value->rValue = here->BSIM3von; return(OK); case BSIM3_VDSAT: - value->rValue = here->BSIM3vdsat; + value->rValue = here->BSIM3vdsat; return(OK); case BSIM3_QBS: - value->rValue = *(ckt->CKTstate0 + here->BSIM3qbs); - value->rValue *= here->BSIM3m; + value->rValue = *(ckt->CKTstate0 + here->BSIM3qbs); + value->rValue *= here->BSIM3m; return(OK); case BSIM3_QBD: - value->rValue = *(ckt->CKTstate0 + here->BSIM3qbd); - value->rValue *= here->BSIM3m; + value->rValue = *(ckt->CKTstate0 + here->BSIM3qbd); + value->rValue *= here->BSIM3m; return(OK); default: return(E_BADPARM); diff --git a/src/spicelib/devices/bsim3/b3ld.c b/src/spicelib/devices/bsim3/b3ld.c index c044e99ac..88a2ca769 100644 --- a/src/spicelib/devices/bsim3/b3ld.c +++ b/src/spicelib/devices/bsim3/b3ld.c @@ -58,7 +58,7 @@ CKTcircuit *ckt) } BSIM3LoadRhsMat(inModel, ckt); - + return good; } @@ -96,14 +96,14 @@ double DeltaPhi, dDeltaPhi_dVg, VgDP, dVgDP_dVg; double Cox, Tox, Tcen, dTcen_dVg, dTcen_dVd, dTcen_dVb; double Ccen, Coxeff, dCoxeff_dVg, dCoxeff_dVd, dCoxeff_dVb; double Denomi, dDenomi_dVg, dDenomi_dVd, dDenomi_dVb; -double ueff, dueff_dVg, dueff_dVd, dueff_dVb; +double ueff, dueff_dVg, dueff_dVd, dueff_dVb; double Esat, Vdsat; double EsatL, dEsatL_dVg, dEsatL_dVd, dEsatL_dVb; -double dVdsat_dVg, dVdsat_dVb, dVdsat_dVd, Vasat, dAlphaz_dVg, dAlphaz_dVb; -double dVasat_dVg, dVasat_dVb, dVasat_dVd, Va, dVa_dVd, dVa_dVg, dVa_dVb; -double Vbseff, dVbseff_dVb, VbseffCV, dVbseffCV_dVb; -double Arg1, One_Third_CoxWL, Two_Third_CoxWL, Alphaz, CoxWL; +double dVdsat_dVg, dVdsat_dVb, dVdsat_dVd, Vasat, dAlphaz_dVg, dAlphaz_dVb; +double dVasat_dVg, dVasat_dVb, dVasat_dVd, Va, dVa_dVd, dVa_dVg, dVa_dVb; +double Vbseff, dVbseff_dVb, VbseffCV, dVbseffCV_dVb; +double Arg1, One_Third_CoxWL, Two_Third_CoxWL, Alphaz, CoxWL; double T0, dT0_dVg, dT0_dVd, dT0_dVb; double T1, dT1_dVg, dT1_dVd, dT1_dVb; @@ -115,7 +115,7 @@ double T6; double T7; double T8; double T9; -double T10; +double T10; double T11, T12; double tmp, Abulk, dAbulk_dVb, Abulk0, dAbulk0_dVb; @@ -133,9 +133,9 @@ double tempv; #endif double a1, ScalingFactor; -double Vgsteff, dVgsteff_dVg, dVgsteff_dVd, dVgsteff_dVb; -double Vdseff, dVdseff_dVg, dVdseff_dVd, dVdseff_dVb; -double VdseffCV, dVdseffCV_dVg, dVdseffCV_dVd, dVdseffCV_dVb; +double Vgsteff, dVgsteff_dVg, dVgsteff_dVd, dVgsteff_dVb; +double Vdseff, dVdseff_dVg, dVdseff_dVd, dVdseff_dVb; +double VdseffCV, dVdseffCV_dVg, dVdseffCV_dVd, dVdseffCV_dVb; double diffVds, dAbulk_dVg; double beta, dbeta_dVg, dbeta_dVd, dbeta_dVb; double gche, dgche_dVg, dgche_dVd, dgche_dVb; @@ -159,13 +159,13 @@ double dxpart, sxpart, ggtg, ggtd, ggts, ggtb; double ddxpart_dVd, ddxpart_dVg, ddxpart_dVb, ddxpart_dVs; double dsxpart_dVd, dsxpart_dVg, dsxpart_dVb, dsxpart_dVs; -double gbspsp, gbbdp, gbbsp, gbspg, gbspb, gbspdp; -double gbdpdp, gbdpg, gbdpb, gbdpsp; +double gbspsp, gbbdp, gbbsp, gbspg, gbspb, gbspdp; +double gbdpdp, gbdpg, gbdpb, gbdpsp; double Cgg, Cgd, Cgb, Cdg, Cdd, Cds; double Csg, Csd, Css, Csb, Cbg, Cbd, Cbb; double Cgg1, Cgb1, Cgd1, Cbg1, Cbb1, Cbd1, Qac0, Qsub0; double dQac0_dVg, dQac0_dVb, dQsub0_dVg, dQsub0_dVd, dQsub0_dVb; - + double m; struct bsim3SizeDependParam *pParam; @@ -177,67 +177,67 @@ model = here->BSIM3modPtr; #endif ScalingFactor = 1.0e-9; -ChargeComputationNeeded = +ChargeComputationNeeded = ((ckt->CKTmode & (MODEDCTRANCURVE | MODEAC | MODETRAN | MODEINITSMSIG)) || ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC))) ? 1 : 0; #ifndef USE_OMP for (; model != NULL; model = model->BSIM3nextModel) -{ for (here = model->BSIM3instances; here != NULL; +{ for (here = model->BSIM3instances; here != NULL; here = here->BSIM3nextInstance) { #endif Check = 1; ByPass = 0; - pParam = here->pParam; + pParam = here->pParam; if ((ckt->CKTmode & MODEINITSMSIG)) - { vbs = *(ckt->CKTstate0 + here->BSIM3vbs); + { vbs = *(ckt->CKTstate0 + here->BSIM3vbs); vgs = *(ckt->CKTstate0 + here->BSIM3vgs); vds = *(ckt->CKTstate0 + here->BSIM3vds); qdef = *(ckt->CKTstate0 + here->BSIM3qdef); } - else if ((ckt->CKTmode & MODEINITTRAN)) - { vbs = *(ckt->CKTstate1 + here->BSIM3vbs); + else if ((ckt->CKTmode & MODEINITTRAN)) + { vbs = *(ckt->CKTstate1 + here->BSIM3vbs); vgs = *(ckt->CKTstate1 + here->BSIM3vgs); vds = *(ckt->CKTstate1 + here->BSIM3vds); qdef = *(ckt->CKTstate1 + here->BSIM3qdef); } - else if ((ckt->CKTmode & MODEINITJCT) && !here->BSIM3off) - { vds = model->BSIM3type * here->BSIM3icVDS; + else if ((ckt->CKTmode & MODEINITJCT) && !here->BSIM3off) + { vds = model->BSIM3type * here->BSIM3icVDS; vgs = model->BSIM3type * here->BSIM3icVGS; vbs = model->BSIM3type * here->BSIM3icVBS; qdef = 0.0; - if ((vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) && + if ((vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) && ((ckt->CKTmode & (MODETRAN | MODEAC|MODEDCOP | MODEDCTRANCURVE)) || (!(ckt->CKTmode & MODEUIC)))) - { vbs = 0.0; + { vbs = 0.0; vgs = model->BSIM3type * pParam->BSIM3vth0 + 0.1; vds = 0.1; } } - else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) && - (here->BSIM3off)) + else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) && + (here->BSIM3off)) { qdef = vbs = vgs = vds = 0.0; - } + } else - { + { #ifndef PREDICTOR if ((ckt->CKTmode & MODEINITPRED)) - { xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1]; - *(ckt->CKTstate0 + here->BSIM3vbs) = + { xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1]; + *(ckt->CKTstate0 + here->BSIM3vbs) = *(ckt->CKTstate1 + here->BSIM3vbs); vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3vbs)) - (xfact * (*(ckt->CKTstate2 + here->BSIM3vbs))); - *(ckt->CKTstate0 + here->BSIM3vgs) = + *(ckt->CKTstate0 + here->BSIM3vgs) = *(ckt->CKTstate1 + here->BSIM3vgs); vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3vgs)) - (xfact * (*(ckt->CKTstate2 + here->BSIM3vgs))); - *(ckt->CKTstate0 + here->BSIM3vds) = + *(ckt->CKTstate0 + here->BSIM3vds) = *(ckt->CKTstate1 + here->BSIM3vds); vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3vds)) - (xfact * (*(ckt->CKTstate2 + here->BSIM3vds))); - *(ckt->CKTstate0 + here->BSIM3vbd) = + *(ckt->CKTstate0 + here->BSIM3vbd) = *(ckt->CKTstate0 + here->BSIM3vbs) - *(ckt->CKTstate0 + here->BSIM3vds); *(ckt->CKTstate0 + here->BSIM3qdef) = @@ -245,14 +245,14 @@ for (; model != NULL; model = model->BSIM3nextModel) qdef = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3qdef)) -(xfact * (*(ckt->CKTstate2 + here->BSIM3qdef))); } - else - { + else + { #endif /* PREDICTOR */ vbs = model->BSIM3type * (*(ckt->CKTrhsOld + here->BSIM3bNode) - *(ckt->CKTrhsOld + here->BSIM3sNodePrime)); vgs = model->BSIM3type - * (*(ckt->CKTrhsOld + here->BSIM3gNode) + * (*(ckt->CKTrhsOld + here->BSIM3gNode) - *(ckt->CKTrhsOld + here->BSIM3sNodePrime)); vds = model->BSIM3type * (*(ckt->CKTrhsOld + here->BSIM3dNodePrime) @@ -316,7 +316,7 @@ for (; model != NULL; model = model->BSIM3nextModel) * MAX(fabs(cdhat),fabs(Idtot)) + ckt->CKTabstol)) { tempv = MAX(fabs(cbhat),fabs(Ibtot)) + ckt->CKTabstol; if ((fabs(cbhat - Ibtot)) < ckt->CKTreltol * tempv) - { /* bypass code */ + { /* bypass code */ vbs = *(ckt->CKTstate0 + here->BSIM3vbs); vbd = *(ckt->CKTstate0 + here->BSIM3vbd); vgs = *(ckt->CKTstate0 + here->BSIM3vgs); @@ -327,46 +327,46 @@ for (; model != NULL; model = model->BSIM3nextModel) vgb = vgs - vbs; cdrain = here->BSIM3cd; - if ((ckt->CKTmode & (MODETRAN | MODEAC)) || - ((ckt->CKTmode & MODETRANOP) && + if ((ckt->CKTmode & (MODETRAN | MODEAC)) || + ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC))) - { ByPass = 1; + { ByPass = 1; qgate = here->BSIM3qgate; qbulk = here->BSIM3qbulk; qdrn = here->BSIM3qdrn; - goto line755; + goto line755; + } + else + { goto line850; } - else - { goto line850; - } } } #endif /*NOBYPASS*/ von = here->BSIM3von; if (*(ckt->CKTstate0 + here->BSIM3vds) >= 0.0) - { vgs = DEVfetlim(vgs, *(ckt->CKTstate0+here->BSIM3vgs), von); + { vgs = DEVfetlim(vgs, *(ckt->CKTstate0+here->BSIM3vgs), von); vds = vgs - vgd; vds = DEVlimvds(vds, *(ckt->CKTstate0 + here->BSIM3vds)); vgd = vgs - vds; } - else - { vgd = DEVfetlim(vgd, vgdo, von); + else + { vgd = DEVfetlim(vgd, vgdo, von); vds = vgs - vgd; vds = -DEVlimvds(-vds, -(*(ckt->CKTstate0+here->BSIM3vds))); vgs = vgd + vds; } if (vds >= 0.0) - { vbs = DEVpnjlim(vbs, *(ckt->CKTstate0 + here->BSIM3vbs), + { vbs = DEVpnjlim(vbs, *(ckt->CKTstate0 + here->BSIM3vbs), CONSTvt0, model->BSIM3vcrit, &Check); vbd = vbs - vds; } - else - { vbd = DEVpnjlim(vbd, *(ckt->CKTstate0 + here->BSIM3vbd), - CONSTvt0, model->BSIM3vcrit, &Check); + else + { vbd = DEVpnjlim(vbd, *(ckt->CKTstate0 + here->BSIM3vbd), + CONSTvt0, model->BSIM3vcrit, &Check); vbs = vbd + vds; } } @@ -378,17 +378,17 @@ for (; model != NULL; model = model->BSIM3nextModel) /* Source/drain junction diode DC model begins */ Nvtm = model->BSIM3vtm * model->BSIM3jctEmissionCoeff; - if ((here->BSIM3sourceArea <= 0.0) && (here->BSIM3sourcePerimeter <= 0.0)) - { SourceSatCurrent = 1.0e-14; - } - else - { SourceSatCurrent = here->BSIM3sourceArea + if ((here->BSIM3sourceArea <= 0.0) && (here->BSIM3sourcePerimeter <= 0.0)) + { SourceSatCurrent = 1.0e-14; + } + else + { SourceSatCurrent = here->BSIM3sourceArea * model->BSIM3jctTempSatCurDensity - + here->BSIM3sourcePerimeter - * model->BSIM3jctSidewallTempSatCurDensity; - } - if (SourceSatCurrent <= 0.0) - { here->BSIM3gbs = ckt->CKTgmin; + + here->BSIM3sourcePerimeter + * model->BSIM3jctSidewallTempSatCurDensity; + } + if (SourceSatCurrent <= 0.0) + { here->BSIM3gbs = ckt->CKTgmin; here->BSIM3cbs = here->BSIM3gbs * vbs; } else @@ -396,7 +396,7 @@ for (; model != NULL; model = model->BSIM3nextModel) { evbs = exp(vbs / Nvtm); here->BSIM3gbs = SourceSatCurrent * evbs / Nvtm + ckt->CKTgmin; here->BSIM3cbs = SourceSatCurrent * (evbs - 1.0) - + ckt->CKTgmin * vbs; + + ckt->CKTgmin * vbs; } else { if (vbs < here->BSIM3vjsm) @@ -415,17 +415,17 @@ for (; model != NULL; model = model->BSIM3nextModel) } } - if ((here->BSIM3drainArea <= 0.0) && (here->BSIM3drainPerimeter <= 0.0)) - { DrainSatCurrent = 1.0e-14; - } - else - { DrainSatCurrent = here->BSIM3drainArea - * model->BSIM3jctTempSatCurDensity - + here->BSIM3drainPerimeter - * model->BSIM3jctSidewallTempSatCurDensity; - } - if (DrainSatCurrent <= 0.0) - { here->BSIM3gbd = ckt->CKTgmin; + if ((here->BSIM3drainArea <= 0.0) && (here->BSIM3drainPerimeter <= 0.0)) + { DrainSatCurrent = 1.0e-14; + } + else + { DrainSatCurrent = here->BSIM3drainArea + * model->BSIM3jctTempSatCurDensity + + here->BSIM3drainPerimeter + * model->BSIM3jctSidewallTempSatCurDensity; + } + if (DrainSatCurrent <= 0.0) + { here->BSIM3gbd = ckt->CKTgmin; here->BSIM3cbd = here->BSIM3gbd * vbd; } else @@ -454,44 +454,44 @@ for (; model != NULL; model = model->BSIM3nextModel) /* End of diode DC model */ if (vds >= 0.0) - { /* normal mode */ + { /* normal mode */ here->BSIM3mode = 1; Vds = vds; Vgs = vgs; Vbs = vbs; } - else - { /* inverse mode */ + else + { /* inverse mode */ here->BSIM3mode = -1; Vds = -vds; Vgs = vgd; Vbs = vbd; } - T0 = Vbs - pParam->BSIM3vbsc - 0.001; - T1 = sqrt(T0 * T0 - 0.004 * pParam->BSIM3vbsc); - Vbseff = pParam->BSIM3vbsc + 0.5 * (T0 + T1); - dVbseff_dVb = 0.5 * (1.0 + T0 / T1); + T0 = Vbs - pParam->BSIM3vbsc - 0.001; + T1 = sqrt(T0 * T0 - 0.004 * pParam->BSIM3vbsc); + Vbseff = pParam->BSIM3vbsc + 0.5 * (T0 + T1); + dVbseff_dVb = 0.5 * (1.0 + T0 / T1); if (Vbseff < Vbs) { Vbseff = Vbs; } if (Vbseff > 0.0) - { T0 = pParam->BSIM3phi / (pParam->BSIM3phi + Vbseff); + { T0 = pParam->BSIM3phi / (pParam->BSIM3phi + Vbseff); Phis = pParam->BSIM3phi * T0; dPhis_dVb = -T0 * T0; sqrtPhis = pParam->BSIM3phis3 / (pParam->BSIM3phi + 0.5 * Vbseff); dsqrtPhis_dVb = -0.5 * sqrtPhis * sqrtPhis / pParam->BSIM3phis3; } - else - { Phis = pParam->BSIM3phi - Vbseff; + else + { Phis = pParam->BSIM3phi - Vbseff; dPhis_dVb = -1.0; sqrtPhis = sqrt(Phis); - dsqrtPhis_dVb = -0.5 / sqrtPhis; + dsqrtPhis_dVb = -0.5 / sqrtPhis; } Xdep = pParam->BSIM3Xdep0 * sqrtPhis / pParam->BSIM3sqrtPhi; dXdep_dVb = (pParam->BSIM3Xdep0 / pParam->BSIM3sqrtPhi) - * dsqrtPhis_dVb; + * dsqrtPhis_dVb; Leff = pParam->BSIM3leff; Vtm = model->BSIM3vtm; @@ -501,27 +501,27 @@ for (; model != NULL; model = model->BSIM3nextModel) T0 = pParam->BSIM3dvt2 * Vbseff; if (T0 >= - 0.5) - { T1 = 1.0 + T0; - T2 = pParam->BSIM3dvt2; - } - else /* Added to avoid any discontinuity problems caused by dvt2 */ - { T4 = 1.0 / (3.0 + 8.0 * T0); - T1 = (1.0 + 3.0 * T0) * T4; - T2 = pParam->BSIM3dvt2 * T4 * T4; - } + { T1 = 1.0 + T0; + T2 = pParam->BSIM3dvt2; + } + else /* Added to avoid any discontinuity problems caused by dvt2 */ + { T4 = 1.0 / (3.0 + 8.0 * T0); + T1 = (1.0 + 3.0 * T0) * T4; + T2 = pParam->BSIM3dvt2 * T4 * T4; + } lt1 = model->BSIM3factor1 * T3 * T1; dlt1_dVb = model->BSIM3factor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); T0 = pParam->BSIM3dvt2w * Vbseff; if (T0 >= - 0.5) - { T1 = 1.0 + T0; - T2 = pParam->BSIM3dvt2w; - } - else /* Added to avoid any discontinuity problems caused by dvt2w */ - { T4 = 1.0 / (3.0 + 8.0 * T0); - T1 = (1.0 + 3.0 * T0) * T4; - T2 = pParam->BSIM3dvt2w * T4 * T4; - } + { T1 = 1.0 + T0; + T2 = pParam->BSIM3dvt2w; + } + else /* Added to avoid any discontinuity problems caused by dvt2w */ + { T4 = 1.0 / (3.0 + 8.0 * T0); + T1 = (1.0 + 3.0 * T0) * T4; + T2 = pParam->BSIM3dvt2w * T4 * T4; + } ltw = model->BSIM3factor1 * T3 * T1; dltw_dVb = model->BSIM3factor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); @@ -565,18 +565,18 @@ for (; model != NULL; model = model->BSIM3nextModel) + (pParam->BSIM3kt1 + pParam->BSIM3kt1l / Leff + pParam->BSIM3kt2 * Vbseff) * TempRatio; tmp2 = model->BSIM3tox * pParam->BSIM3phi - / (pParam->BSIM3weff + pParam->BSIM3w0); + / (pParam->BSIM3weff + pParam->BSIM3w0); - T3 = pParam->BSIM3eta0 + pParam->BSIM3etab * Vbseff; - if (T3 < 1.0e-4) /* avoid discontinuity problems caused by etab */ - { T9 = 1.0 / (3.0 - 2.0e4 * T3); - T3 = (2.0e-4 - T3) * T9; - T4 = T9 * T9; - } - else - { T4 = 1.0; - } - dDIBL_Sft_dVd = T3 * pParam->BSIM3theta0vb0; + T3 = pParam->BSIM3eta0 + pParam->BSIM3etab * Vbseff; + if (T3 < 1.0e-4) /* avoid discontinuity problems caused by etab */ + { T9 = 1.0 / (3.0 - 2.0e4 * T3); + T3 = (2.0e-4 - T3) * T9; + T4 = T9 * T9; + } + else + { T4 = 1.0; + } + dDIBL_Sft_dVd = T3 * pParam->BSIM3theta0vb0; DIBL_Sft = dDIBL_Sft_dVd * Vds; Vth = model->BSIM3type * pParam->BSIM3vth0 - pParam->BSIM3k1 @@ -584,7 +584,7 @@ for (; model != NULL; model = model->BSIM3nextModel) - pParam->BSIM3k2ox * Vbseff - Delt_vth - T2 + (pParam->BSIM3k3 + pParam->BSIM3k3b * Vbseff) * tmp2 + T1 - DIBL_Sft; - here->BSIM3von = Vth; + here->BSIM3von = Vth; dVth_dVb = pParam->BSIM3k1ox * dsqrtPhis_dVb - pParam->BSIM3k2ox - dDelt_vth_dVb - dT2_dVb + pParam->BSIM3k3b * tmp2 @@ -596,28 +596,28 @@ for (; model != NULL; model = model->BSIM3nextModel) tmp2 = pParam->BSIM3nfactor * EPSSI / Xdep; tmp3 = pParam->BSIM3cdsc + pParam->BSIM3cdscb * Vbseff + pParam->BSIM3cdscd * Vds; - tmp4 = (tmp2 + tmp3 * Theta0 + pParam->BSIM3cit) / model->BSIM3cox; - if (tmp4 >= -0.5) - { n = 1.0 + tmp4; - dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb + tmp4 = (tmp2 + tmp3 * Theta0 + pParam->BSIM3cit) / model->BSIM3cox; + if (tmp4 >= -0.5) + { n = 1.0 + tmp4; + dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb + pParam->BSIM3cdscb * Theta0) / model->BSIM3cox; dn_dVd = pParam->BSIM3cdscd * Theta0 / model->BSIM3cox; - } - else - /* avoid discontinuity problems caused by tmp4 */ - { T0 = 1.0 / (3.0 + 8.0 * tmp4); - n = (1.0 + 3.0 * tmp4) * T0; - T0 *= T0; - dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb + } + else + /* avoid discontinuity problems caused by tmp4 */ + { T0 = 1.0 / (3.0 + 8.0 * tmp4); + n = (1.0 + 3.0 * tmp4) * T0; + T0 *= T0; + dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb + pParam->BSIM3cdscb * Theta0) / model->BSIM3cox * T0; dn_dVd = pParam->BSIM3cdscd * Theta0 / model->BSIM3cox * T0; - } + } /* Poly Gate Si Depletion Effect */ - T0 = pParam->BSIM3vfb + pParam->BSIM3phi; - if ((pParam->BSIM3ngate > 1.e18) && (pParam->BSIM3ngate < 1.e25) + T0 = pParam->BSIM3vfb + pParam->BSIM3phi; + if ((pParam->BSIM3ngate > 1.e18) && (pParam->BSIM3ngate < 1.e25) && (Vgs > T0)) - /* added to avoid the problem caused by ngate */ + /* added to avoid the problem caused by ngate */ { T1 = 1.0e6 * Charge_q * EPSSI * pParam->BSIM3ngate / (model->BSIM3cox * model->BSIM3cox); T4 = sqrt(1.0 + 2.0 * (Vgs - T0) / T1); @@ -627,10 +627,10 @@ for (; model != NULL; model = model->BSIM3nextModel) T6 = sqrt(T7 * T7 + 0.224); T5 = 1.12 - 0.5 * (T7 + T6); Vgs_eff = Vgs - T5; - dVgs_eff_dVg = 1.0 - (0.5 - 0.5 / T4) * (1.0 + T7 / T6); + dVgs_eff_dVg = 1.0 - (0.5 - 0.5 / T4) * (1.0 + T7 / T6); } - else - { Vgs_eff = Vgs; + else + { Vgs_eff = Vgs; dVgs_eff_dVg = 1.0; } Vgst = Vgs_eff - Vth; @@ -641,140 +641,140 @@ for (; model != NULL; model = model->BSIM3nextModel) VgstNVt = Vgst / T10; ExpArg = (2.0 * pParam->BSIM3voff - Vgst) / T10; - /* MCJ: Very small Vgst */ + /* MCJ: Very small Vgst */ if (VgstNVt > EXP_THRESHOLD) - { Vgsteff = Vgst; + { Vgsteff = Vgst; dVgsteff_dVg = dVgs_eff_dVg; dVgsteff_dVd = -dVth_dVd; dVgsteff_dVb = -dVth_dVb; - } - else if (ExpArg > EXP_THRESHOLD) - { T0 = (Vgst - pParam->BSIM3voff) / (n * Vtm); - ExpVgst = exp(T0); - Vgsteff = Vtm * pParam->BSIM3cdep0 / model->BSIM3cox * ExpVgst; + } + else if (ExpArg > EXP_THRESHOLD) + { T0 = (Vgst - pParam->BSIM3voff) / (n * Vtm); + ExpVgst = exp(T0); + Vgsteff = Vtm * pParam->BSIM3cdep0 / model->BSIM3cox * ExpVgst; dVgsteff_dVg = Vgsteff / (n * Vtm); dVgsteff_dVd = -dVgsteff_dVg * (dVth_dVd + T0 * Vtm * dn_dVd); dVgsteff_dVb = -dVgsteff_dVg * (dVth_dVb + T0 * Vtm * dn_dVb); - dVgsteff_dVg *= dVgs_eff_dVg; - } - else - { ExpVgst = exp(VgstNVt); + dVgsteff_dVg *= dVgs_eff_dVg; + } + else + { ExpVgst = exp(VgstNVt); T1 = T10 * log(1.0 + ExpVgst); dT1_dVg = ExpVgst / (1.0 + ExpVgst); dT1_dVb = -dT1_dVg * (dVth_dVb + Vgst / n * dn_dVb) - + T1 / n * dn_dVb; - dT1_dVd = -dT1_dVg * (dVth_dVd + Vgst / n * dn_dVd) - + T1 / n * dn_dVd; + + T1 / n * dn_dVb; + dT1_dVd = -dT1_dVg * (dVth_dVd + Vgst / n * dn_dVd) + + T1 / n * dn_dVd; - dT2_dVg = -model->BSIM3cox / (Vtm * pParam->BSIM3cdep0) - * exp(ExpArg); + dT2_dVg = -model->BSIM3cox / (Vtm * pParam->BSIM3cdep0) + * exp(ExpArg); T2 = 1.0 - T10 * dT2_dVg; dT2_dVd = -dT2_dVg * (dVth_dVd - 2.0 * Vtm * ExpArg * dn_dVd) - + (T2 - 1.0) / n * dn_dVd; + + (T2 - 1.0) / n * dn_dVd; dT2_dVb = -dT2_dVg * (dVth_dVb - 2.0 * Vtm * ExpArg * dn_dVb) - + (T2 - 1.0) / n * dn_dVb; + + (T2 - 1.0) / n * dn_dVb; Vgsteff = T1 / T2; - T3 = T2 * T2; + T3 = T2 * T2; dVgsteff_dVg = (T2 * dT1_dVg - T1 * dT2_dVg) / T3 * dVgs_eff_dVg; dVgsteff_dVd = (T2 * dT1_dVd - T1 * dT2_dVd) / T3; dVgsteff_dVb = (T2 * dT1_dVb - T1 * dT2_dVb) / T3; - } - here->BSIM3Vgsteff = Vgsteff; + } + here->BSIM3Vgsteff = Vgsteff; /* Calculate Effective Channel Geometry */ T9 = sqrtPhis - pParam->BSIM3sqrtPhi; - Weff = pParam->BSIM3weff - 2.0 * (pParam->BSIM3dwg * Vgsteff - + pParam->BSIM3dwb * T9); + Weff = pParam->BSIM3weff - 2.0 * (pParam->BSIM3dwg * Vgsteff + + pParam->BSIM3dwb * T9); dWeff_dVg = -2.0 * pParam->BSIM3dwg; dWeff_dVb = -2.0 * pParam->BSIM3dwb * dsqrtPhis_dVb; if (Weff < 2.0e-8) /* to avoid the discontinuity problem due to Weff*/ - { T0 = 1.0 / (6.0e-8 - 2.0 * Weff); - Weff = 2.0e-8 * (4.0e-8 - Weff) * T0; - T0 *= T0 * 4.0e-16; + { T0 = 1.0 / (6.0e-8 - 2.0 * Weff); + Weff = 2.0e-8 * (4.0e-8 - Weff) * T0; + T0 *= T0 * 4.0e-16; dWeff_dVg *= T0; - dWeff_dVb *= T0; + dWeff_dVb *= T0; } T0 = pParam->BSIM3prwg * Vgsteff + pParam->BSIM3prwb * T9; - if (T0 >= -0.9) - { Rds = pParam->BSIM3rds0 * (1.0 + T0); - dRds_dVg = pParam->BSIM3rds0 * pParam->BSIM3prwg; + if (T0 >= -0.9) + { Rds = pParam->BSIM3rds0 * (1.0 + T0); + dRds_dVg = pParam->BSIM3rds0 * pParam->BSIM3prwg; dRds_dVb = pParam->BSIM3rds0 * pParam->BSIM3prwb * dsqrtPhis_dVb; - } - else + } + else /* to avoid the discontinuity problem due to prwg and prwb*/ - { T1 = 1.0 / (17.0 + 20.0 * T0); - Rds = pParam->BSIM3rds0 * (0.8 + T0) * T1; - T1 *= T1; - dRds_dVg = pParam->BSIM3rds0 * pParam->BSIM3prwg * T1; + { T1 = 1.0 / (17.0 + 20.0 * T0); + Rds = pParam->BSIM3rds0 * (0.8 + T0) * T1; + T1 *= T1; + dRds_dVg = pParam->BSIM3rds0 * pParam->BSIM3prwg * T1; dRds_dVb = pParam->BSIM3rds0 * pParam->BSIM3prwb * dsqrtPhis_dVb - * T1; - } - here->BSIM3rds = Rds; /* Noise Bugfix */ - + * T1; + } + here->BSIM3rds = Rds; /* Noise Bugfix */ + /* Calculate Abulk */ T1 = 0.5 * pParam->BSIM3k1ox / sqrtPhis; dT1_dVb = -T1 / sqrtPhis * dsqrtPhis_dVb; T9 = sqrt(pParam->BSIM3xj * Xdep); tmp1 = Leff + 2.0 * T9; - T5 = Leff / tmp1; + T5 = Leff / tmp1; tmp2 = pParam->BSIM3a0 * T5; - tmp3 = pParam->BSIM3weff + pParam->BSIM3b1; + tmp3 = pParam->BSIM3weff + pParam->BSIM3b1; tmp4 = pParam->BSIM3b0 / tmp3; T2 = tmp2 + tmp4; dT2_dVb = -T9 / tmp1 / Xdep * dXdep_dVb; T6 = T5 * T5; T7 = T5 * T6; - Abulk0 = 1.0 + T1 * T2; + Abulk0 = 1.0 + T1 * T2; dAbulk0_dVb = T1 * tmp2 * dT2_dVb + T2 * dT1_dVb; T8 = pParam->BSIM3ags * pParam->BSIM3a0 * T7; dAbulk_dVg = -T1 * T8; - Abulk = Abulk0 + dAbulk_dVg * Vgsteff; + Abulk = Abulk0 + dAbulk_dVg * Vgsteff; dAbulk_dVb = dAbulk0_dVb - T8 * Vgsteff * (dT1_dVb - + 3.0 * T1 * dT2_dVb); + + 3.0 * T1 * dT2_dVb); if (Abulk0 < 0.1) /* added to avoid the problems caused by Abulk0 */ - { T9 = 1.0 / (3.0 - 20.0 * Abulk0); - Abulk0 = (0.2 - Abulk0) * T9; - dAbulk0_dVb *= T9 * T9; - } + { T9 = 1.0 / (3.0 - 20.0 * Abulk0); + Abulk0 = (0.2 - Abulk0) * T9; + dAbulk0_dVb *= T9 * T9; + } if (Abulk < 0.1) /* added to avoid the problems caused by Abulk */ - { T9 = 1.0 / (3.0 - 20.0 * Abulk); - Abulk = (0.2 - Abulk) * T9; + { T9 = 1.0 / (3.0 - 20.0 * Abulk); + Abulk = (0.2 - Abulk) * T9; T10 = T9 * T9; - dAbulk_dVb *= T10; + dAbulk_dVb *= T10; dAbulk_dVg *= T10; - } - here->BSIM3Abulk = Abulk; + } + here->BSIM3Abulk = Abulk; T2 = pParam->BSIM3keta * Vbseff; - if (T2 >= -0.9) - { T0 = 1.0 / (1.0 + T2); + if (T2 >= -0.9) + { T0 = 1.0 / (1.0 + T2); dT0_dVb = -pParam->BSIM3keta * T0 * T0; - } - else + } + else /* added to avoid the problems caused by Keta */ - { T1 = 1.0 / (0.8 + T2); - T0 = (17.0 + 20.0 * T2) * T1; + { T1 = 1.0 / (0.8 + T2); + T0 = (17.0 + 20.0 * T2) * T1; dT0_dVb = -pParam->BSIM3keta * T1 * T1; - } - dAbulk_dVg *= T0; - dAbulk_dVb = dAbulk_dVb * T0 + Abulk * dT0_dVb; - dAbulk0_dVb = dAbulk0_dVb * T0 + Abulk0 * dT0_dVb; - Abulk *= T0; - Abulk0 *= T0; + } + dAbulk_dVg *= T0; + dAbulk_dVb = dAbulk_dVb * T0 + Abulk * dT0_dVb; + dAbulk0_dVb = dAbulk0_dVb * T0 + Abulk0 * dT0_dVb; + Abulk *= T0; + Abulk0 *= T0; /* Mobility calculation */ if (model->BSIM3mobMod == 1) - { T0 = Vgsteff + Vth + Vth; + { T0 = Vgsteff + Vth + Vth; T2 = pParam->BSIM3ua + pParam->BSIM3uc * Vbseff; T3 = T0 / model->BSIM3tox; T5 = T3 * (T2 + pParam->BSIM3ub * T3); @@ -782,49 +782,49 @@ for (; model != NULL; model = model->BSIM3nextModel) dDenomi_dVd = dDenomi_dVg * 2.0 * dVth_dVd; dDenomi_dVb = dDenomi_dVg * 2.0 * dVth_dVb + pParam->BSIM3uc * T3; } - else if (model->BSIM3mobMod == 2) - { T5 = Vgsteff / model->BSIM3tox * (pParam->BSIM3ua - + pParam->BSIM3uc * Vbseff + pParam->BSIM3ub * Vgsteff + else if (model->BSIM3mobMod == 2) + { T5 = Vgsteff / model->BSIM3tox * (pParam->BSIM3ua + + pParam->BSIM3uc * Vbseff + pParam->BSIM3ub * Vgsteff / model->BSIM3tox); dDenomi_dVg = (pParam->BSIM3ua + pParam->BSIM3uc * Vbseff - + 2.0 * pParam->BSIM3ub * Vgsteff / model->BSIM3tox) - / model->BSIM3tox; + + 2.0 * pParam->BSIM3ub * Vgsteff / model->BSIM3tox) + / model->BSIM3tox; dDenomi_dVd = 0.0; - dDenomi_dVb = Vgsteff * pParam->BSIM3uc / model->BSIM3tox; + dDenomi_dVb = Vgsteff * pParam->BSIM3uc / model->BSIM3tox; } - else - { T0 = Vgsteff + Vth + Vth; + else + { T0 = Vgsteff + Vth + Vth; T2 = 1.0 + pParam->BSIM3uc * Vbseff; T3 = T0 / model->BSIM3tox; T4 = T3 * (pParam->BSIM3ua + pParam->BSIM3ub * T3); - T5 = T4 * T2; + T5 = T4 * T2; dDenomi_dVg = (pParam->BSIM3ua + 2.0 * pParam->BSIM3ub * T3) * T2 - / model->BSIM3tox; + / model->BSIM3tox; dDenomi_dVd = dDenomi_dVg * 2.0 * dVth_dVd; dDenomi_dVb = dDenomi_dVg * 2.0 * dVth_dVb + pParam->BSIM3uc * T4; } - if (T5 >= -0.8) - { Denomi = 1.0 + T5; - } - else /* Added to avoid the discontinuity problem caused by ua and ub*/ - { T9 = 1.0 / (7.0 + 10.0 * T5); - Denomi = (0.6 + T5) * T9; - T9 *= T9; + if (T5 >= -0.8) + { Denomi = 1.0 + T5; + } + else /* Added to avoid the discontinuity problem caused by ua and ub*/ + { T9 = 1.0 / (7.0 + 10.0 * T5); + Denomi = (0.6 + T5) * T9; + T9 *= T9; dDenomi_dVg *= T9; dDenomi_dVd *= T9; dDenomi_dVb *= T9; - } + } here->BSIM3ueff = ueff = pParam->BSIM3u0temp / Denomi; - T9 = -ueff / Denomi; + T9 = -ueff / Denomi; dueff_dVg = T9 * dDenomi_dVg; dueff_dVd = T9 * dDenomi_dVd; dueff_dVb = T9 * dDenomi_dVb; /* Saturation Drain Voltage Vdsat */ WVCox = Weff * pParam->BSIM3vsattemp * model->BSIM3cox; - WVCoxRds = WVCox * Rds; + WVCoxRds = WVCox * Rds; Esat = 2.0 * pParam->BSIM3vsattemp / ueff; EsatL = Esat * Leff; @@ -832,28 +832,28 @@ for (; model != NULL; model = model->BSIM3nextModel) dEsatL_dVg = T0 * dueff_dVg; dEsatL_dVd = T0 * dueff_dVd; dEsatL_dVb = T0 * dueff_dVb; - - /* Sqrt() */ + + /* Sqrt() */ a1 = pParam->BSIM3a1; - if (a1 == 0.0) - { Lambda = pParam->BSIM3a2; - dLambda_dVg = 0.0; - } - else if (a1 > 0.0) + if (a1 == 0.0) + { Lambda = pParam->BSIM3a2; + dLambda_dVg = 0.0; + } + else if (a1 > 0.0) /* Added to avoid the discontinuity problem caused by a1 and a2 (Lambda) */ - { T0 = 1.0 - pParam->BSIM3a2; - T1 = T0 - pParam->BSIM3a1 * Vgsteff - 0.0001; - T2 = sqrt(T1 * T1 + 0.0004 * T0); - Lambda = pParam->BSIM3a2 + T0 - 0.5 * (T1 + T2); - dLambda_dVg = 0.5 * pParam->BSIM3a1 * (1.0 + T1 / T2); - } - else - { T1 = pParam->BSIM3a2 + pParam->BSIM3a1 * Vgsteff - 0.0001; - T2 = sqrt(T1 * T1 + 0.0004 * pParam->BSIM3a2); - Lambda = 0.5 * (T1 + T2); - dLambda_dVg = 0.5 * pParam->BSIM3a1 * (1.0 + T1 / T2); - } + { T0 = 1.0 - pParam->BSIM3a2; + T1 = T0 - pParam->BSIM3a1 * Vgsteff - 0.0001; + T2 = sqrt(T1 * T1 + 0.0004 * T0); + Lambda = pParam->BSIM3a2 + T0 - 0.5 * (T1 + T2); + dLambda_dVg = 0.5 * pParam->BSIM3a1 * (1.0 + T1 / T2); + } + else + { T1 = pParam->BSIM3a2 + pParam->BSIM3a1 * Vgsteff - 0.0001; + T2 = sqrt(T1 * T1 + 0.0004 * pParam->BSIM3a2); + Lambda = 0.5 * (T1 + T2); + dLambda_dVg = 0.5 * pParam->BSIM3a1 * (1.0 + T1 / T2); + } Vgst2Vtm = Vgsteff + 2.0 * Vtm; here->BSIM3AbovVgst2Vtm = Abulk / Vgst2Vtm; @@ -865,48 +865,48 @@ for (; model != NULL; model = model->BSIM3nextModel) else { tmp2 = dWeff_dVg / Weff; tmp3 = dWeff_dVb / Weff; - } + } if ((Rds == 0.0) && (Lambda == 1.0)) { T0 = 1.0 / (Abulk * EsatL + Vgst2Vtm); tmp1 = 0.0; - T1 = T0 * T0; - T2 = Vgst2Vtm * T0; + T1 = T0 * T0; + T2 = Vgst2Vtm * T0; T3 = EsatL * Vgst2Vtm; Vdsat = T3 * T0; - + dT0_dVg = -(Abulk * dEsatL_dVg + EsatL * dAbulk_dVg + 1.0) * T1; - dT0_dVd = -(Abulk * dEsatL_dVd) * T1; - dT0_dVb = -(Abulk * dEsatL_dVb + dAbulk_dVb * EsatL) * T1; + dT0_dVd = -(Abulk * dEsatL_dVd) * T1; + dT0_dVb = -(Abulk * dEsatL_dVb + dAbulk_dVb * EsatL) * T1; dVdsat_dVg = T3 * dT0_dVg + T2 * dEsatL_dVg + EsatL * T0; dVdsat_dVd = T3 * dT0_dVd + T2 * dEsatL_dVd; - dVdsat_dVb = T3 * dT0_dVb + T2 * dEsatL_dVb; + dVdsat_dVb = T3 * dT0_dVb + T2 * dEsatL_dVb; } else { tmp1 = dLambda_dVg / (Lambda * Lambda); T9 = Abulk * WVCoxRds; - T8 = Abulk * T9; - T7 = Vgst2Vtm * T9; + T8 = Abulk * T9; + T7 = Vgst2Vtm * T9; T6 = Vgst2Vtm * WVCoxRds; - T0 = 2.0 * Abulk * (T9 - 1.0 + 1.0 / Lambda); + T0 = 2.0 * Abulk * (T9 - 1.0 + 1.0 / Lambda); dT0_dVg = 2.0 * (T8 * tmp2 - Abulk * tmp1 - + (2.0 * T9 + 1.0 / Lambda - 1.0) * dAbulk_dVg); - + + (2.0 * T9 + 1.0 / Lambda - 1.0) * dAbulk_dVg); + dT0_dVb = 2.0 * (T8 * (2.0 / Abulk * dAbulk_dVb + tmp3) - + (1.0 / Lambda - 1.0) * dAbulk_dVb); - dT0_dVd = 0.0; + + (1.0 / Lambda - 1.0) * dAbulk_dVb); + dT0_dVd = 0.0; T1 = Vgst2Vtm * (2.0 / Lambda - 1.0) + Abulk * EsatL + 3.0 * T7; - + dT1_dVg = (2.0 / Lambda - 1.0) - 2.0 * Vgst2Vtm * tmp1 - + Abulk * dEsatL_dVg + EsatL * dAbulk_dVg + 3.0 * (T9 - + T7 * tmp2 + T6 * dAbulk_dVg); + + Abulk * dEsatL_dVg + EsatL * dAbulk_dVg + 3.0 * (T9 + + T7 * tmp2 + T6 * dAbulk_dVg); dT1_dVb = Abulk * dEsatL_dVb + EsatL * dAbulk_dVb - + 3.0 * (T6 * dAbulk_dVb + T7 * tmp3); + + 3.0 * (T6 * dAbulk_dVb + T7 * tmp3); dT1_dVd = Abulk * dEsatL_dVd; T2 = Vgst2Vtm * (EsatL + 2.0 * T6); dT2_dVg = EsatL + Vgst2Vtm * dEsatL_dVg - + T6 * (4.0 + 2.0 * Vgst2Vtm * tmp2); + + T6 * (4.0 + 2.0 * Vgst2Vtm * tmp2); dT2_dVb = Vgst2Vtm * (dEsatL_dVb + 2.0 * T6 * tmp3); dT2_dVd = Vgst2Vtm * dEsatL_dVd; @@ -914,16 +914,16 @@ for (; model != NULL; model = model->BSIM3nextModel) Vdsat = (T1 - T3) / T0; dT3_dVg = (T1 * dT1_dVg - 2.0 * (T0 * dT2_dVg + T2 * dT0_dVg)) - / T3; + / T3; dT3_dVd = (T1 * dT1_dVd - 2.0 * (T0 * dT2_dVd + T2 * dT0_dVd)) - / T3; + / T3; dT3_dVb = (T1 * dT1_dVb - 2.0 * (T0 * dT2_dVb + T2 * dT0_dVb)) - / T3; + / T3; dVdsat_dVg = (dT1_dVg - (T1 * dT1_dVg - dT0_dVg * T2 - - T0 * dT2_dVg) / T3 - Vdsat * dT0_dVg) / T0; + - T0 * dT2_dVg) / T3 - Vdsat * dT0_dVg) / T0; dVdsat_dVb = (dT1_dVb - (T1 * dT1_dVb - dT0_dVb * T2 - - T0 * dT2_dVb) / T3 - Vdsat * dT0_dVb) / T0; + - T0 * dT2_dVb) / T3 - Vdsat * dT0_dVb) / T0; dVdsat_dVd = (dT1_dVd - (T1 * dT1_dVd - T0 * dT2_dVd) / T3) / T0; } here->BSIM3vdsat = Vdsat; @@ -935,40 +935,40 @@ for (; model != NULL; model = model->BSIM3nextModel) dT1_dVb = dVdsat_dVb; T2 = sqrt(T1 * T1 + 4.0 * pParam->BSIM3delta * Vdsat); - T0 = T1 / T2; - T3 = 2.0 * pParam->BSIM3delta / T2; + T0 = T1 / T2; + T3 = 2.0 * pParam->BSIM3delta / T2; dT2_dVg = T0 * dT1_dVg + T3 * dVdsat_dVg; dT2_dVd = T0 * dT1_dVd + T3 * dVdsat_dVd; dT2_dVb = T0 * dT1_dVb + T3 * dVdsat_dVb; Vdseff = Vdsat - 0.5 * (T1 + T2); - dVdseff_dVg = dVdsat_dVg - 0.5 * (dT1_dVg + dT2_dVg); - dVdseff_dVd = dVdsat_dVd - 0.5 * (dT1_dVd + dT2_dVd); - dVdseff_dVb = dVdsat_dVb - 0.5 * (dT1_dVb + dT2_dVb); + dVdseff_dVg = dVdsat_dVg - 0.5 * (dT1_dVg + dT2_dVg); + dVdseff_dVd = dVdsat_dVd - 0.5 * (dT1_dVd + dT2_dVd); + dVdseff_dVb = dVdsat_dVb - 0.5 * (dT1_dVb + dT2_dVb); /* Added to eliminate non-zero Vdseff at Vds=0.0 */ if (Vds == 0.0) { Vdseff = 0.0; dVdseff_dVg = 0.0; - dVdseff_dVb = 0.0; + dVdseff_dVb = 0.0; } /* Calculate VAsat */ tmp4 = 1.0 - 0.5 * Abulk * Vdsat / Vgst2Vtm; T9 = WVCoxRds * Vgsteff; - T8 = T9 / Vgst2Vtm; + T8 = T9 / Vgst2Vtm; T0 = EsatL + Vdsat + 2.0 * T9 * tmp4; - + T7 = 2.0 * WVCoxRds * tmp4; dT0_dVg = dEsatL_dVg + dVdsat_dVg + T7 * (1.0 + tmp2 * Vgsteff) - - T8 * (Abulk * dVdsat_dVg - Abulk * Vdsat / Vgst2Vtm - + Vdsat * dAbulk_dVg); - + - T8 * (Abulk * dVdsat_dVg - Abulk * Vdsat / Vgst2Vtm + + Vdsat * dAbulk_dVg); + dT0_dVb = dEsatL_dVb + dVdsat_dVb + T7 * tmp3 * Vgsteff - - T8 * (dAbulk_dVb * Vdsat + Abulk * dVdsat_dVb); + - T8 * (dAbulk_dVb * Vdsat + Abulk * dVdsat_dVb); dT0_dVd = dEsatL_dVd + dVdsat_dVd - T8 * Abulk * dVdsat_dVd; - T9 = WVCoxRds * Abulk; - T1 = 2.0 / Lambda - 1.0 + T9; + T9 = WVCoxRds * Abulk; + T1 = 2.0 / Lambda - 1.0 + T9; dT1_dVg = -2.0 * tmp1 + WVCoxRds * (Abulk * tmp2 + dAbulk_dVg); dT1_dVb = dAbulk_dVb * WVCoxRds + T9 * tmp3; @@ -980,39 +980,39 @@ for (; model != NULL; model = model->BSIM3nextModel) if (Vdseff > Vds) Vdseff = Vds; diffVds = Vds - Vdseff; - here->BSIM3Vdseff = Vdseff; + here->BSIM3Vdseff = Vdseff; /* Calculate VACLM */ if ((pParam->BSIM3pclm > 0.0) && (diffVds > 1.0e-10)) - { T0 = 1.0 / (pParam->BSIM3pclm * Abulk * pParam->BSIM3litl); + { T0 = 1.0 / (pParam->BSIM3pclm * Abulk * pParam->BSIM3litl); dT0_dVb = -T0 / Abulk * dAbulk_dVb; - dT0_dVg = -T0 / Abulk * dAbulk_dVg; - - T2 = Vgsteff / EsatL; - T1 = Leff * (Abulk + T2); + dT0_dVg = -T0 / Abulk * dAbulk_dVg; + + T2 = Vgsteff / EsatL; + T1 = Leff * (Abulk + T2); dT1_dVg = Leff * ((1.0 - T2 * dEsatL_dVg) / EsatL + dAbulk_dVg); dT1_dVb = Leff * (dAbulk_dVb - T2 * dEsatL_dVb / EsatL); dT1_dVd = -T2 * dEsatL_dVd / Esat; - T9 = T0 * T1; + T9 = T0 * T1; VACLM = T9 * diffVds; dVACLM_dVg = T0 * dT1_dVg * diffVds - T9 * dVdseff_dVg + T1 * diffVds * dT0_dVg; dVACLM_dVb = (dT0_dVb * T1 + T0 * dT1_dVb) * diffVds - - T9 * dVdseff_dVb; + - T9 * dVdseff_dVb; dVACLM_dVd = T0 * dT1_dVd * diffVds + T9 * (1.0 - dVdseff_dVd); } - else - { VACLM = MAX_EXP; + else + { VACLM = MAX_EXP; dVACLM_dVd = dVACLM_dVg = dVACLM_dVb = 0.0; } /* Calculate VADIBL */ if (pParam->BSIM3thetaRout > 0.0) - { T8 = Abulk * Vdsat; - T0 = Vgst2Vtm * T8; + { T8 = Abulk * Vdsat; + T0 = Vgst2Vtm * T8; dT0_dVg = Vgst2Vtm * Abulk * dVdsat_dVg + T8 - + Vgst2Vtm * Vdsat * dAbulk_dVg; + + Vgst2Vtm * Vdsat * dAbulk_dVg; dT0_dVb = Vgst2Vtm * (dAbulk_dVb * Vdsat + Abulk * dVdsat_dVb); dT0_dVd = Vgst2Vtm * Abulk * dVdsat_dVd; @@ -1021,59 +1021,59 @@ for (; model != NULL; model = model->BSIM3nextModel) dT1_dVb = Abulk * dVdsat_dVb + dAbulk_dVb * Vdsat; dT1_dVd = Abulk * dVdsat_dVd; - T9 = T1 * T1; - T2 = pParam->BSIM3thetaRout; + T9 = T1 * T1; + T2 = pParam->BSIM3thetaRout; VADIBL = (Vgst2Vtm - T0 / T1) / T2; dVADIBL_dVg = (1.0 - dT0_dVg / T1 + T0 * dT1_dVg / T9) / T2; dVADIBL_dVb = (-dT0_dVb / T1 + T0 * dT1_dVb / T9) / T2; dVADIBL_dVd = (-dT0_dVd / T1 + T0 * dT1_dVd / T9) / T2; - T7 = pParam->BSIM3pdiblb * Vbseff; - if (T7 >= -0.9) - { T3 = 1.0 / (1.0 + T7); + T7 = pParam->BSIM3pdiblb * Vbseff; + if (T7 >= -0.9) + { T3 = 1.0 / (1.0 + T7); VADIBL *= T3; dVADIBL_dVg *= T3; dVADIBL_dVb = (dVADIBL_dVb - VADIBL * pParam->BSIM3pdiblb) - * T3; + * T3; dVADIBL_dVd *= T3; - } - else + } + else /* Added to avoid the discontinuity problem caused by pdiblcb */ - { T4 = 1.0 / (0.8 + T7); - T3 = (17.0 + 20.0 * T7) * T4; + { T4 = 1.0 / (0.8 + T7); + T3 = (17.0 + 20.0 * T7) * T4; dVADIBL_dVg *= T3; dVADIBL_dVb = dVADIBL_dVb * T3 - - VADIBL * pParam->BSIM3pdiblb * T4 * T4; + - VADIBL * pParam->BSIM3pdiblb * T4 * T4; dVADIBL_dVd *= T3; VADIBL *= T3; - } + } } - else - { VADIBL = MAX_EXP; + else + { VADIBL = MAX_EXP; dVADIBL_dVd = dVADIBL_dVg = dVADIBL_dVb = 0.0; } /* Calculate VA */ - - T8 = pParam->BSIM3pvag / EsatL; - T9 = T8 * Vgsteff; - if (T9 > -0.9) - { T0 = 1.0 + T9; + + T8 = pParam->BSIM3pvag / EsatL; + T9 = T8 * Vgsteff; + if (T9 > -0.9) + { T0 = 1.0 + T9; dT0_dVg = T8 * (1.0 - Vgsteff * dEsatL_dVg / EsatL); dT0_dVb = -T9 * dEsatL_dVb / EsatL; dT0_dVd = -T9 * dEsatL_dVd / EsatL; - } - else /* Added to avoid the discontinuity problems caused by pvag */ - { T1 = 1.0 / (17.0 + 20.0 * T9); - T0 = (0.8 + T9) * T1; - T1 *= T1; + } + else /* Added to avoid the discontinuity problems caused by pvag */ + { T1 = 1.0 / (17.0 + 20.0 * T9); + T0 = (0.8 + T9) * T1; + T1 *= T1; dT0_dVg = T8 * (1.0 - Vgsteff * dEsatL_dVg / EsatL) * T1; T9 *= T1 / EsatL; dT0_dVb = -T9 * dEsatL_dVb; dT0_dVd = -T9 * dEsatL_dVd; - } - + } + tmp1 = VACLM * VACLM; tmp2 = VADIBL * VADIBL; tmp3 = VACLM + VADIBL; @@ -1090,25 +1090,25 @@ for (; model != NULL; model = model->BSIM3nextModel) dVa_dVb = dVasat_dVb + T1 * dT0_dVb + T0 * dT1_dVb; /* Calculate VASCBE */ - if (pParam->BSIM3pscbe2 > 0.0) - { if (diffVds > pParam->BSIM3pscbe1 * pParam->BSIM3litl - / EXP_THRESHOLD) - { T0 = pParam->BSIM3pscbe1 * pParam->BSIM3litl / diffVds; - VASCBE = Leff * exp(T0) / pParam->BSIM3pscbe2; + if (pParam->BSIM3pscbe2 > 0.0) + { if (diffVds > pParam->BSIM3pscbe1 * pParam->BSIM3litl + / EXP_THRESHOLD) + { T0 = pParam->BSIM3pscbe1 * pParam->BSIM3litl / diffVds; + VASCBE = Leff * exp(T0) / pParam->BSIM3pscbe2; T1 = T0 * VASCBE / diffVds; dVASCBE_dVg = T1 * dVdseff_dVg; dVASCBE_dVd = -T1 * (1.0 - dVdseff_dVd); dVASCBE_dVb = T1 * dVdseff_dVb; } - else - { VASCBE = MAX_EXP * Leff/pParam->BSIM3pscbe2; + else + { VASCBE = MAX_EXP * Leff/pParam->BSIM3pscbe2; dVASCBE_dVg = dVASCBE_dVd = dVASCBE_dVb = 0.0; } - } - else - { VASCBE = MAX_EXP; + } + else + { VASCBE = MAX_EXP; dVASCBE_dVg = dVASCBE_dVd = dVASCBE_dVb = 0.0; - } + } /* Calculate Ids */ CoxWovL = model->BSIM3cox * Weff / Leff; @@ -1118,48 +1118,48 @@ for (; model != NULL; model = model->BSIM3nextModel) dbeta_dVb = CoxWovL * dueff_dVb + beta * dWeff_dVb / Weff; T0 = 1.0 - 0.5 * Abulk * Vdseff / Vgst2Vtm; - dT0_dVg = -0.5 * (Abulk * dVdseff_dVg - - Abulk * Vdseff / Vgst2Vtm + Vdseff * dAbulk_dVg) / Vgst2Vtm; + dT0_dVg = -0.5 * (Abulk * dVdseff_dVg + - Abulk * Vdseff / Vgst2Vtm + Vdseff * dAbulk_dVg) / Vgst2Vtm; dT0_dVd = -0.5 * Abulk * dVdseff_dVd / Vgst2Vtm; dT0_dVb = -0.5 * (Abulk * dVdseff_dVb + dAbulk_dVb * Vdseff) / Vgst2Vtm; fgche1 = Vgsteff * T0; - dfgche1_dVg = Vgsteff * dT0_dVg + T0; - dfgche1_dVd = Vgsteff * dT0_dVd; - dfgche1_dVb = Vgsteff * dT0_dVb; + dfgche1_dVg = Vgsteff * dT0_dVg + T0; + dfgche1_dVd = Vgsteff * dT0_dVd; + dfgche1_dVb = Vgsteff * dT0_dVb; T9 = Vdseff / EsatL; fgche2 = 1.0 + T9; dfgche2_dVg = (dVdseff_dVg - T9 * dEsatL_dVg) / EsatL; dfgche2_dVd = (dVdseff_dVd - T9 * dEsatL_dVd) / EsatL; dfgche2_dVb = (dVdseff_dVb - T9 * dEsatL_dVb) / EsatL; - + gche = beta * fgche1 / fgche2; dgche_dVg = (beta * dfgche1_dVg + fgche1 * dbeta_dVg - - gche * dfgche2_dVg) / fgche2; + - gche * dfgche2_dVg) / fgche2; dgche_dVd = (beta * dfgche1_dVd + fgche1 * dbeta_dVd - - gche * dfgche2_dVd) / fgche2; + - gche * dfgche2_dVd) / fgche2; dgche_dVb = (beta * dfgche1_dVb + fgche1 * dbeta_dVb - - gche * dfgche2_dVb) / fgche2; + - gche * dfgche2_dVb) / fgche2; T0 = 1.0 + gche * Rds; T9 = Vdseff / T0; Idl = gche * T9; dIdl_dVg = (gche * dVdseff_dVg + T9 * dgche_dVg) / T0 - - Idl * gche / T0 * dRds_dVg ; + - Idl * gche / T0 * dRds_dVg ; - dIdl_dVd = (gche * dVdseff_dVd + T9 * dgche_dVd) / T0; - dIdl_dVb = (gche * dVdseff_dVb + T9 * dgche_dVb - - Idl * dRds_dVb * gche) / T0; + dIdl_dVd = (gche * dVdseff_dVd + T9 * dgche_dVd) / T0; + dIdl_dVb = (gche * dVdseff_dVb + T9 * dgche_dVb + - Idl * dRds_dVb * gche) / T0; T9 = diffVds / Va; T0 = 1.0 + T9; Idsa = Idl * T0; dIdsa_dVg = T0 * dIdl_dVg - Idl * (dVdseff_dVg + T9 * dVa_dVg) / Va; dIdsa_dVd = T0 * dIdl_dVd + Idl * (1.0 - dVdseff_dVd - - T9 * dVa_dVd) / Va; + - T9 * dVa_dVd) / Va; dIdsa_dVb = T0 * dIdl_dVb - Idl * (dVdseff_dVb + T9 * dVa_dVb) / Va; T9 = diffVds / VASCBE; @@ -1168,33 +1168,33 @@ for (; model != NULL; model = model->BSIM3nextModel) Gm = T0 * dIdsa_dVg - Idsa * (dVdseff_dVg + T9 * dVASCBE_dVg) / VASCBE; Gds = T0 * dIdsa_dVd + Idsa * (1.0 - dVdseff_dVd - - T9 * dVASCBE_dVd) / VASCBE; + - T9 * dVASCBE_dVd) / VASCBE; Gmb = T0 * dIdsa_dVb - Idsa * (dVdseff_dVb - + T9 * dVASCBE_dVb) / VASCBE; + + T9 * dVASCBE_dVb) / VASCBE; Gds += Gm * dVgsteff_dVd; - Gmb += Gm * dVgsteff_dVb; - Gm *= dVgsteff_dVg; - Gmb *= dVbseff_dVb; + Gmb += Gm * dVgsteff_dVb; + Gm *= dVgsteff_dVg; + Gmb *= dVbseff_dVb; /* Substrate current begins */ tmp = pParam->BSIM3alpha0 + pParam->BSIM3alpha1 * Leff; if ((tmp <= 0.0) || (pParam->BSIM3beta0 <= 0.0)) - { Isub = Gbd = Gbb = Gbg = 0.0; + { Isub = Gbd = Gbb = Gbg = 0.0; } - else - { T2 = tmp / Leff; - if (diffVds > pParam->BSIM3beta0 / EXP_THRESHOLD) - { T0 = -pParam->BSIM3beta0 / diffVds; - T1 = T2 * diffVds * exp(T0); - T3 = T1 / diffVds * (T0 - 1.0); + else + { T2 = tmp / Leff; + if (diffVds > pParam->BSIM3beta0 / EXP_THRESHOLD) + { T0 = -pParam->BSIM3beta0 / diffVds; + T1 = T2 * diffVds * exp(T0); + T3 = T1 / diffVds * (T0 - 1.0); dT1_dVg = T3 * dVdseff_dVg; dT1_dVd = T3 * (dVdseff_dVd - 1.0); dT1_dVb = T3 * dVdseff_dVb; } - else - { T3 = T2 * MIN_EXP; - T1 = T3 * diffVds; + else + { T3 = T2 * MIN_EXP; + T1 = T3 * diffVds; dT1_dVg = -T3 * dVdseff_dVg; dT1_dVd = T3 * (1.0 - dVdseff_dVd); dT1_dVb = -T3 * dVdseff_dVb; @@ -1205,59 +1205,59 @@ for (; model != NULL; model = model->BSIM3nextModel) Gbb = T1 * dIdsa_dVb + Idsa * dT1_dVb; Gbd += Gbg * dVgsteff_dVd; - Gbb += Gbg * dVgsteff_dVb; - Gbg *= dVgsteff_dVg; - Gbb *= dVbseff_dVb; /* bug fixing */ + Gbb += Gbg * dVgsteff_dVb; + Gbg *= dVgsteff_dVg; + Gbb *= dVbseff_dVb; /* bug fixing */ } - + cdrain = Ids; here->BSIM3gds = Gds; here->BSIM3gm = Gm; here->BSIM3gmbs = Gmb; - + here->BSIM3gbbs = Gbb; here->BSIM3gbgs = Gbg; here->BSIM3gbds = Gbd; here->BSIM3csub = Isub; - /* BSIM3 thermal noise Qinv calculated from all capMod + /* BSIM3 thermal noise Qinv calculated from all capMod * 0, 1, 2 & 3 stored in here->BSIM3qinv 1/1998 */ if ((model->BSIM3xpart < 0) || (!ChargeComputationNeeded)) - { qgate = qdrn = qsrc = qbulk = 0.0; + { qgate = qdrn = qsrc = qbulk = 0.0; here->BSIM3cggb = here->BSIM3cgsb = here->BSIM3cgdb = 0.0; here->BSIM3cdgb = here->BSIM3cdsb = here->BSIM3cddb = 0.0; here->BSIM3cbgb = here->BSIM3cbsb = here->BSIM3cbdb = 0.0; - here->BSIM3cqdb = here->BSIM3cqsb = here->BSIM3cqgb + here->BSIM3cqdb = here->BSIM3cqsb = here->BSIM3cqgb = here->BSIM3cqbb = 0.0; here->BSIM3gtau = 0.0; goto finished; } - else if (model->BSIM3capMod == 0) - { + else if (model->BSIM3capMod == 0) + { if (Vbseff < 0.0) - { Vbseff = Vbs; + { Vbseff = Vbs; dVbseff_dVb = 1.0; } - else - { Vbseff = pParam->BSIM3phi - Phis; + else + { Vbseff = pParam->BSIM3phi - Phis; dVbseff_dVb = -dPhis_dVb; } Vfb = pParam->BSIM3vfbcv; - Vth = Vfb + pParam->BSIM3phi + pParam->BSIM3k1ox * sqrtPhis; + Vth = Vfb + pParam->BSIM3phi + pParam->BSIM3k1ox * sqrtPhis; Vgst = Vgs_eff - Vth; - dVth_dVb = pParam->BSIM3k1ox * dsqrtPhis_dVb; + dVth_dVb = pParam->BSIM3k1ox * dsqrtPhis_dVb; dVgst_dVb = -dVth_dVb; - dVgst_dVg = dVgs_eff_dVg; + dVgst_dVg = dVgs_eff_dVg; CoxWL = model->BSIM3cox * pParam->BSIM3weffCV * pParam->BSIM3leffCV; Arg1 = Vgs_eff - Vbseff - Vfb; if (Arg1 <= 0.0) - { qgate = CoxWL * Arg1; + { qgate = CoxWL * Arg1; qbulk = -qgate; qdrn = 0.0; @@ -1274,18 +1274,18 @@ for (; model != NULL; model = model->BSIM3nextModel) here->BSIM3cbsb = -here->BSIM3cgsb; here->BSIM3qinv = 0.0; } - else if (Vgst <= 0.0) - { T1 = 0.5 * pParam->BSIM3k1ox; - T2 = sqrt(T1 * T1 + Arg1); - qgate = CoxWL * pParam->BSIM3k1ox * (T2 - T1); + else if (Vgst <= 0.0) + { T1 = 0.5 * pParam->BSIM3k1ox; + T2 = sqrt(T1 * T1 + Arg1); + qgate = CoxWL * pParam->BSIM3k1ox * (T2 - T1); qbulk = -qgate; qdrn = 0.0; - T0 = CoxWL * T1 / T2; - here->BSIM3cggb = T0 * dVgs_eff_dVg; - here->BSIM3cgdb = 0.0; + T0 = CoxWL * T1 / T2; + here->BSIM3cggb = T0 * dVgs_eff_dVg; + here->BSIM3cgdb = 0.0; here->BSIM3cgsb = T0 * (dVbseff_dVb - dVgs_eff_dVg); - + here->BSIM3cdgb = 0.0; here->BSIM3cddb = 0.0; here->BSIM3cdsb = 0.0; @@ -1295,63 +1295,63 @@ for (; model != NULL; model = model->BSIM3nextModel) here->BSIM3cbsb = -here->BSIM3cgsb; here->BSIM3qinv = 0.0; } - else - { One_Third_CoxWL = CoxWL / 3.0; + else + { One_Third_CoxWL = CoxWL / 3.0; Two_Third_CoxWL = 2.0 * One_Third_CoxWL; AbulkCV = Abulk0 * pParam->BSIM3abulkCVfactor; dAbulkCV_dVb = pParam->BSIM3abulkCVfactor * dAbulk0_dVb; - Vdsat = Vgst / AbulkCV; - dVdsat_dVg = dVgs_eff_dVg / AbulkCV; - dVdsat_dVb = - (Vdsat * dAbulkCV_dVb + dVth_dVb)/ AbulkCV; + Vdsat = Vgst / AbulkCV; + dVdsat_dVg = dVgs_eff_dVg / AbulkCV; + dVdsat_dVb = - (Vdsat * dAbulkCV_dVb + dVth_dVb)/ AbulkCV; if (model->BSIM3xpart > 0.5) - { /* 0/100 Charge partition model */ - if (Vdsat <= Vds) - { /* saturation region */ - T1 = Vdsat / 3.0; - qgate = CoxWL * (Vgs_eff - Vfb - - pParam->BSIM3phi - T1); - T2 = -Two_Third_CoxWL * Vgst; - qbulk = -(qgate + T2); - qdrn = 0.0; + { /* 0/100 Charge partition model */ + if (Vdsat <= Vds) + { /* saturation region */ + T1 = Vdsat / 3.0; + qgate = CoxWL * (Vgs_eff - Vfb + - pParam->BSIM3phi - T1); + T2 = -Two_Third_CoxWL * Vgst; + qbulk = -(qgate + T2); + qdrn = 0.0; - here->BSIM3cggb = One_Third_CoxWL * (3.0 - - dVdsat_dVg) * dVgs_eff_dVg; - T2 = -One_Third_CoxWL * dVdsat_dVb; - here->BSIM3cgsb = -(here->BSIM3cggb + T2); + here->BSIM3cggb = One_Third_CoxWL * (3.0 + - dVdsat_dVg) * dVgs_eff_dVg; + T2 = -One_Third_CoxWL * dVdsat_dVb; + here->BSIM3cgsb = -(here->BSIM3cggb + T2); here->BSIM3cgdb = 0.0; - + here->BSIM3cdgb = 0.0; here->BSIM3cddb = 0.0; here->BSIM3cdsb = 0.0; - here->BSIM3cbgb = -(here->BSIM3cggb - - Two_Third_CoxWL * dVgs_eff_dVg); - T3 = -(T2 + Two_Third_CoxWL * dVth_dVb); - here->BSIM3cbsb = -(here->BSIM3cbgb + T3); + here->BSIM3cbgb = -(here->BSIM3cggb + - Two_Third_CoxWL * dVgs_eff_dVg); + T3 = -(T2 + Two_Third_CoxWL * dVth_dVb); + here->BSIM3cbsb = -(here->BSIM3cbgb + T3); here->BSIM3cbdb = 0.0; here->BSIM3qinv = -(qgate + qbulk); - } - else - { /* linear region */ - Alphaz = Vgst / Vdsat; - T1 = 2.0 * Vdsat - Vds; - T2 = Vds / (3.0 * T1); - T3 = T2 * Vds; - T9 = 0.25 * CoxWL; - T4 = T9 * Alphaz; - T7 = 2.0 * Vds - T1 - 3.0 * T3; - T8 = T3 - T1 - 2.0 * Vds; - qgate = CoxWL * (Vgs_eff - Vfb - - pParam->BSIM3phi - 0.5 * (Vds - T3)); - T10 = T4 * T8; - qdrn = T4 * T7; - qbulk = -(qgate + qdrn + T10); - + } + else + { /* linear region */ + Alphaz = Vgst / Vdsat; + T1 = 2.0 * Vdsat - Vds; + T2 = Vds / (3.0 * T1); + T3 = T2 * Vds; + T9 = 0.25 * CoxWL; + T4 = T9 * Alphaz; + T7 = 2.0 * Vds - T1 - 3.0 * T3; + T8 = T3 - T1 - 2.0 * Vds; + qgate = CoxWL * (Vgs_eff - Vfb + - pParam->BSIM3phi - 0.5 * (Vds - T3)); + T10 = T4 * T8; + qdrn = T4 * T7; + qbulk = -(qgate + qdrn + T10); + T5 = T3 / T1; here->BSIM3cggb = CoxWL * (1.0 - T5 * dVdsat_dVg) - * dVgs_eff_dVg; + * dVgs_eff_dVg; T11 = -CoxWL * T5 * dVdsat_dVb; here->BSIM3cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5); here->BSIM3cgsb = -(here->BSIM3cggb + T11 @@ -1363,7 +1363,7 @@ for (; model != NULL; model = model->BSIM3nextModel) T8 = T9 * T8; T9 = 2.0 * T4 * (1.0 - 3.0 * T5); here->BSIM3cdgb = (T7 * dAlphaz_dVg - T9 - * dVdsat_dVg) * dVgs_eff_dVg; + * dVdsat_dVg) * dVgs_eff_dVg; T12 = T7 * dAlphaz_dVb - T9 * dVdsat_dVb; here->BSIM3cddb = T4 * (3.0 - 6.0 * T2 - 3.0 * T5); here->BSIM3cdsb = -(here->BSIM3cdgb + T12 @@ -1371,200 +1371,200 @@ for (; model != NULL; model = model->BSIM3nextModel) T9 = 2.0 * T4 * (1.0 + T5); T10 = (T8 * dAlphaz_dVg - T9 * dVdsat_dVg) - * dVgs_eff_dVg; + * dVgs_eff_dVg; T11 = T8 * dAlphaz_dVb - T9 * dVdsat_dVb; - T12 = T4 * (2.0 * T2 + T5 - 1.0); + T12 = T4 * (2.0 * T2 + T5 - 1.0); T0 = -(T10 + T11 + T12); here->BSIM3cbgb = -(here->BSIM3cggb - + here->BSIM3cdgb + T10); - here->BSIM3cbdb = -(here->BSIM3cgdb - + here->BSIM3cddb + T12); + + here->BSIM3cdgb + T10); + here->BSIM3cbdb = -(here->BSIM3cgdb + + here->BSIM3cddb + T12); here->BSIM3cbsb = -(here->BSIM3cgsb - + here->BSIM3cdsb + T0); + + here->BSIM3cdsb + T0); here->BSIM3qinv = -(qgate + qbulk); } } - else if (model->BSIM3xpart < 0.5) - { /* 40/60 Charge partition model */ - if (Vds >= Vdsat) - { /* saturation region */ - T1 = Vdsat / 3.0; - qgate = CoxWL * (Vgs_eff - Vfb - - pParam->BSIM3phi - T1); - T2 = -Two_Third_CoxWL * Vgst; - qbulk = -(qgate + T2); - qdrn = 0.4 * T2; + else if (model->BSIM3xpart < 0.5) + { /* 40/60 Charge partition model */ + if (Vds >= Vdsat) + { /* saturation region */ + T1 = Vdsat / 3.0; + qgate = CoxWL * (Vgs_eff - Vfb + - pParam->BSIM3phi - T1); + T2 = -Two_Third_CoxWL * Vgst; + qbulk = -(qgate + T2); + qdrn = 0.4 * T2; - here->BSIM3cggb = One_Third_CoxWL * (3.0 - - dVdsat_dVg) * dVgs_eff_dVg; - T2 = -One_Third_CoxWL * dVdsat_dVb; - here->BSIM3cgsb = -(here->BSIM3cggb + T2); - here->BSIM3cgdb = 0.0; - - T3 = 0.4 * Two_Third_CoxWL; + here->BSIM3cggb = One_Third_CoxWL * (3.0 + - dVdsat_dVg) * dVgs_eff_dVg; + T2 = -One_Third_CoxWL * dVdsat_dVb; + here->BSIM3cgsb = -(here->BSIM3cggb + T2); + here->BSIM3cgdb = 0.0; + + T3 = 0.4 * Two_Third_CoxWL; here->BSIM3cdgb = -T3 * dVgs_eff_dVg; here->BSIM3cddb = 0.0; - T4 = T3 * dVth_dVb; + T4 = T3 * dVth_dVb; here->BSIM3cdsb = -(T4 + here->BSIM3cdgb); - here->BSIM3cbgb = -(here->BSIM3cggb - - Two_Third_CoxWL * dVgs_eff_dVg); - T3 = -(T2 + Two_Third_CoxWL * dVth_dVb); - here->BSIM3cbsb = -(here->BSIM3cbgb + T3); + here->BSIM3cbgb = -(here->BSIM3cggb + - Two_Third_CoxWL * dVgs_eff_dVg); + T3 = -(T2 + Two_Third_CoxWL * dVth_dVb); + here->BSIM3cbsb = -(here->BSIM3cbgb + T3); here->BSIM3cbdb = 0.0; here->BSIM3qinv = -(qgate + qbulk); - } - else - { /* linear region */ - Alphaz = Vgst / Vdsat; - T1 = 2.0 * Vdsat - Vds; - T2 = Vds / (3.0 * T1); - T3 = T2 * Vds; - T9 = 0.25 * CoxWL; - T4 = T9 * Alphaz; - qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM3phi - - 0.5 * (Vds - T3)); + } + else + { /* linear region */ + Alphaz = Vgst / Vdsat; + T1 = 2.0 * Vdsat - Vds; + T2 = Vds / (3.0 * T1); + T3 = T2 * Vds; + T9 = 0.25 * CoxWL; + T4 = T9 * Alphaz; + qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM3phi + - 0.5 * (Vds - T3)); - T5 = T3 / T1; + T5 = T3 / T1; here->BSIM3cggb = CoxWL * (1.0 - T5 * dVdsat_dVg) - * dVgs_eff_dVg; + * dVgs_eff_dVg; tmp = -CoxWL * T5 * dVdsat_dVb; here->BSIM3cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5); - here->BSIM3cgsb = -(here->BSIM3cggb - + here->BSIM3cgdb + tmp); + here->BSIM3cgsb = -(here->BSIM3cggb + + here->BSIM3cgdb + tmp); - T6 = 1.0 / Vdsat; + T6 = 1.0 / Vdsat; dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg); dAlphaz_dVb = -T6 * (dVth_dVb + Alphaz * dVdsat_dVb); - T6 = 8.0 * Vdsat * Vdsat - 6.0 * Vdsat * Vds - + 1.2 * Vds * Vds; - T8 = T2 / T1; - T7 = Vds - T1 - T8 * T6; - qdrn = T4 * T7; - T7 *= T9; - tmp = T8 / T1; - tmp1 = T4 * (2.0 - 4.0 * tmp * T6 - + T8 * (16.0 * Vdsat - 6.0 * Vds)); + T6 = 8.0 * Vdsat * Vdsat - 6.0 * Vdsat * Vds + + 1.2 * Vds * Vds; + T8 = T2 / T1; + T7 = Vds - T1 - T8 * T6; + qdrn = T4 * T7; + T7 *= T9; + tmp = T8 / T1; + tmp1 = T4 * (2.0 - 4.0 * tmp * T6 + + T8 * (16.0 * Vdsat - 6.0 * Vds)); here->BSIM3cdgb = (T7 * dAlphaz_dVg - tmp1 - * dVdsat_dVg) * dVgs_eff_dVg; + * dVdsat_dVg) * dVgs_eff_dVg; T10 = T7 * dAlphaz_dVb - tmp1 * dVdsat_dVb; here->BSIM3cddb = T4 * (2.0 - (1.0 / (3.0 * T1 - * T1) + 2.0 * tmp) * T6 + T8 - * (6.0 * Vdsat - 2.4 * Vds)); - here->BSIM3cdsb = -(here->BSIM3cdgb - + T10 + here->BSIM3cddb); + * T1) + 2.0 * tmp) * T6 + T8 + * (6.0 * Vdsat - 2.4 * Vds)); + here->BSIM3cdsb = -(here->BSIM3cdgb + + T10 + here->BSIM3cddb); - T7 = 2.0 * (T1 + T3); - qbulk = -(qgate - T4 * T7); - T7 *= T9; - T0 = 4.0 * T4 * (1.0 - T5); - T12 = (-T7 * dAlphaz_dVg - here->BSIM3cdgb - - T0 * dVdsat_dVg) * dVgs_eff_dVg; - T11 = -T7 * dAlphaz_dVb - T10 - T0 * dVdsat_dVb; - T10 = -4.0 * T4 * (T2 - 0.5 + 0.5 * T5) - - here->BSIM3cddb; + T7 = 2.0 * (T1 + T3); + qbulk = -(qgate - T4 * T7); + T7 *= T9; + T0 = 4.0 * T4 * (1.0 - T5); + T12 = (-T7 * dAlphaz_dVg - here->BSIM3cdgb + - T0 * dVdsat_dVg) * dVgs_eff_dVg; + T11 = -T7 * dAlphaz_dVb - T10 - T0 * dVdsat_dVb; + T10 = -4.0 * T4 * (T2 - 0.5 + 0.5 * T5) + - here->BSIM3cddb; tmp = -(T10 + T11 + T12); - here->BSIM3cbgb = -(here->BSIM3cggb - + here->BSIM3cdgb + T12); + here->BSIM3cbgb = -(here->BSIM3cggb + + here->BSIM3cdgb + T12); here->BSIM3cbdb = -(here->BSIM3cgdb - + here->BSIM3cddb + T10); /* bug fix */ + + here->BSIM3cddb + T10); /* bug fix */ here->BSIM3cbsb = -(here->BSIM3cgsb - + here->BSIM3cdsb + tmp); + + here->BSIM3cdsb + tmp); here->BSIM3qinv = -(qgate + qbulk); } } - else - { /* 50/50 partitioning */ - if (Vds >= Vdsat) - { /* saturation region */ - T1 = Vdsat / 3.0; - qgate = CoxWL * (Vgs_eff - Vfb - - pParam->BSIM3phi - T1); - T2 = -Two_Third_CoxWL * Vgst; - qbulk = -(qgate + T2); - qdrn = 0.5 * T2; + else + { /* 50/50 partitioning */ + if (Vds >= Vdsat) + { /* saturation region */ + T1 = Vdsat / 3.0; + qgate = CoxWL * (Vgs_eff - Vfb + - pParam->BSIM3phi - T1); + T2 = -Two_Third_CoxWL * Vgst; + qbulk = -(qgate + T2); + qdrn = 0.5 * T2; + + here->BSIM3cggb = One_Third_CoxWL * (3.0 + - dVdsat_dVg) * dVgs_eff_dVg; + T2 = -One_Third_CoxWL * dVdsat_dVb; + here->BSIM3cgsb = -(here->BSIM3cggb + T2); + here->BSIM3cgdb = 0.0; - here->BSIM3cggb = One_Third_CoxWL * (3.0 - - dVdsat_dVg) * dVgs_eff_dVg; - T2 = -One_Third_CoxWL * dVdsat_dVb; - here->BSIM3cgsb = -(here->BSIM3cggb + T2); - here->BSIM3cgdb = 0.0; - here->BSIM3cdgb = -One_Third_CoxWL * dVgs_eff_dVg; here->BSIM3cddb = 0.0; - T4 = One_Third_CoxWL * dVth_dVb; + T4 = One_Third_CoxWL * dVth_dVb; here->BSIM3cdsb = -(T4 + here->BSIM3cdgb); - here->BSIM3cbgb = -(here->BSIM3cggb - - Two_Third_CoxWL * dVgs_eff_dVg); - T3 = -(T2 + Two_Third_CoxWL * dVth_dVb); - here->BSIM3cbsb = -(here->BSIM3cbgb + T3); + here->BSIM3cbgb = -(here->BSIM3cggb + - Two_Third_CoxWL * dVgs_eff_dVg); + T3 = -(T2 + Two_Third_CoxWL * dVth_dVb); + here->BSIM3cbsb = -(here->BSIM3cbgb + T3); here->BSIM3cbdb = 0.0; here->BSIM3qinv = -(qgate + qbulk); - } - else - { /* linear region */ - Alphaz = Vgst / Vdsat; - T1 = 2.0 * Vdsat - Vds; - T2 = Vds / (3.0 * T1); - T3 = T2 * Vds; - T9 = 0.25 * CoxWL; - T4 = T9 * Alphaz; - qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM3phi - - 0.5 * (Vds - T3)); + } + else + { /* linear region */ + Alphaz = Vgst / Vdsat; + T1 = 2.0 * Vdsat - Vds; + T2 = Vds / (3.0 * T1); + T3 = T2 * Vds; + T9 = 0.25 * CoxWL; + T4 = T9 * Alphaz; + qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM3phi + - 0.5 * (Vds - T3)); - T5 = T3 / T1; + T5 = T3 / T1; here->BSIM3cggb = CoxWL * (1.0 - T5 * dVdsat_dVg) - * dVgs_eff_dVg; + * dVgs_eff_dVg; tmp = -CoxWL * T5 * dVdsat_dVb; here->BSIM3cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5); - here->BSIM3cgsb = -(here->BSIM3cggb - + here->BSIM3cgdb + tmp); + here->BSIM3cgsb = -(here->BSIM3cggb + + here->BSIM3cgdb + tmp); - T6 = 1.0 / Vdsat; + T6 = 1.0 / Vdsat; dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg); dAlphaz_dVb = -T6 * (dVth_dVb + Alphaz * dVdsat_dVb); - T7 = T1 + T3; - qdrn = -T4 * T7; - qbulk = - (qgate + qdrn + qdrn); - T7 *= T9; - T0 = T4 * (2.0 * T5 - 2.0); + T7 = T1 + T3; + qdrn = -T4 * T7; + qbulk = - (qgate + qdrn + qdrn); + T7 *= T9; + T0 = T4 * (2.0 * T5 - 2.0); here->BSIM3cdgb = (T0 * dVdsat_dVg - T7 - * dAlphaz_dVg) * dVgs_eff_dVg; - T12 = T0 * dVdsat_dVb - T7 * dAlphaz_dVb; + * dAlphaz_dVg) * dVgs_eff_dVg; + T12 = T0 * dVdsat_dVb - T7 * dAlphaz_dVb; here->BSIM3cddb = T4 * (1.0 - 2.0 * T2 - T5); here->BSIM3cdsb = -(here->BSIM3cdgb + T12 + here->BSIM3cddb); here->BSIM3cbgb = -(here->BSIM3cggb - + 2.0 * here->BSIM3cdgb); + + 2.0 * here->BSIM3cdgb); here->BSIM3cbdb = -(here->BSIM3cgdb - + 2.0 * here->BSIM3cddb); + + 2.0 * here->BSIM3cddb); here->BSIM3cbsb = -(here->BSIM3cgsb - + 2.0 * here->BSIM3cdsb); + + 2.0 * here->BSIM3cdsb); here->BSIM3qinv = -(qgate + qbulk); } - } - } - } - else - { if (Vbseff < 0.0) - { VbseffCV = Vbseff; + } + } + } + else + { if (Vbseff < 0.0) + { VbseffCV = Vbseff; dVbseffCV_dVb = 1.0; } - else - { VbseffCV = pParam->BSIM3phi - Phis; + else + { VbseffCV = pParam->BSIM3phi - Phis; dVbseffCV_dVb = -dPhis_dVb; } CoxWL = model->BSIM3cox * pParam->BSIM3weffCV - * pParam->BSIM3leffCV; + * pParam->BSIM3leffCV; /* Seperate VgsteffCV with noff and voffcv */ noff = n * pParam->BSIM3noff; @@ -1598,84 +1598,84 @@ for (; model != NULL; model = model->BSIM3nextModel) dVgsteff_dVg *= dVgs_eff_dVg; } /* End of VgsteffCV */ - if (model->BSIM3capMod == 1) - { Vfb = pParam->BSIM3vfbzb; + if (model->BSIM3capMod == 1) + { Vfb = pParam->BSIM3vfbzb; Arg1 = Vgs_eff - VbseffCV - Vfb - Vgsteff; if (Arg1 <= 0.0) - { qgate = CoxWL * Arg1; + { qgate = CoxWL * Arg1; Cgg = CoxWL * (dVgs_eff_dVg - dVgsteff_dVg); Cgd = -CoxWL * dVgsteff_dVd; Cgb = -CoxWL * (dVbseffCV_dVb + dVgsteff_dVb); } - else - { T0 = 0.5 * pParam->BSIM3k1ox; - T1 = sqrt(T0 * T0 + Arg1); + else + { T0 = 0.5 * pParam->BSIM3k1ox; + T1 = sqrt(T0 * T0 + Arg1); T2 = CoxWL * T0 / T1; - + qgate = CoxWL * pParam->BSIM3k1ox * (T1 - T0); Cgg = T2 * (dVgs_eff_dVg - dVgsteff_dVg); Cgd = -T2 * dVgsteff_dVd; Cgb = -T2 * (dVbseffCV_dVb + dVgsteff_dVb); } - qbulk = -qgate; - Cbg = -Cgg; - Cbd = -Cgd; - Cbb = -Cgb; + qbulk = -qgate; + Cbg = -Cgg; + Cbd = -Cgd; + Cbb = -Cgb; One_Third_CoxWL = CoxWL / 3.0; Two_Third_CoxWL = 2.0 * One_Third_CoxWL; AbulkCV = Abulk0 * pParam->BSIM3abulkCVfactor; dAbulkCV_dVb = pParam->BSIM3abulkCVfactor * dAbulk0_dVb; - VdsatCV = Vgsteff / AbulkCV; + VdsatCV = Vgsteff / AbulkCV; if (VdsatCV < Vds) - { dVdsatCV_dVg = 1.0 / AbulkCV; - dVdsatCV_dVb = -VdsatCV * dAbulkCV_dVb / AbulkCV; - T0 = Vgsteff - VdsatCV / 3.0; + { dVdsatCV_dVg = 1.0 / AbulkCV; + dVdsatCV_dVb = -VdsatCV * dAbulkCV_dVb / AbulkCV; + T0 = Vgsteff - VdsatCV / 3.0; dT0_dVg = 1.0 - dVdsatCV_dVg / 3.0; dT0_dVb = -dVdsatCV_dVb / 3.0; qgate += CoxWL * T0; - Cgg1 = CoxWL * dT0_dVg; + Cgg1 = CoxWL * dT0_dVg; Cgb1 = CoxWL * dT0_dVb + Cgg1 * dVgsteff_dVb; Cgd1 = Cgg1 * dVgsteff_dVd; - Cgg1 *= dVgsteff_dVg; - Cgg += Cgg1; - Cgb += Cgb1; - Cgd += Cgd1; + Cgg1 *= dVgsteff_dVg; + Cgg += Cgg1; + Cgb += Cgb1; + Cgd += Cgd1; - T0 = VdsatCV - Vgsteff; - dT0_dVg = dVdsatCV_dVg - 1.0; - dT0_dVb = dVdsatCV_dVb; + T0 = VdsatCV - Vgsteff; + dT0_dVg = dVdsatCV_dVg - 1.0; + dT0_dVb = dVdsatCV_dVb; qbulk += One_Third_CoxWL * T0; Cbg1 = One_Third_CoxWL * dT0_dVg; - Cbb1 = One_Third_CoxWL * dT0_dVb + Cbg1 * dVgsteff_dVb; - Cbd1 = Cbg1 * dVgsteff_dVd; - Cbg1 *= dVgsteff_dVg; - Cbg += Cbg1; - Cbb += Cbb1; + Cbb1 = One_Third_CoxWL * dT0_dVb + Cbg1 * dVgsteff_dVb; + Cbd1 = Cbg1 * dVgsteff_dVd; + Cbg1 *= dVgsteff_dVg; + Cbg += Cbg1; + Cbb += Cbb1; Cbd += Cbd1; if (model->BSIM3xpart > 0.5) - T0 = -Two_Third_CoxWL; + T0 = -Two_Third_CoxWL; else if (model->BSIM3xpart < 0.5) - T0 = -0.4 * CoxWL; + T0 = -0.4 * CoxWL; else - T0 = -One_Third_CoxWL; + T0 = -One_Third_CoxWL; qsrc = T0 * Vgsteff; Csg = T0 * dVgsteff_dVg; Csb = T0 * dVgsteff_dVb; Csd = T0 * dVgsteff_dVd; - Cgb *= dVbseff_dVb; - Cbb *= dVbseff_dVb; - Csb *= dVbseff_dVb; + Cgb *= dVbseff_dVb; + Cbb *= dVbseff_dVb; + Csb *= dVbseff_dVb; } - else - { T0 = AbulkCV * Vds; + else + { T0 = AbulkCV * Vds; T1 = 12.0 * (Vgsteff - 0.5 * T0 + 1.e-20); - T2 = Vds / T1; - T3 = T0 * T2; + T2 = Vds / T1; + T3 = T0 * T2; dT3_dVg = -12.0 * T2 * T2 * AbulkCV; dT3_dVd = 6.0 * T0 * (4.0 * Vgsteff - T0) / T1 / T1 - 0.5; dT3_dVb = 12.0 * T2 * T2 * dAbulkCV_dVb * Vgsteff; @@ -1684,137 +1684,137 @@ for (; model != NULL; model = model->BSIM3nextModel) Cgg1 = CoxWL * (1.0 + dT3_dVg); Cgb1 = CoxWL * dT3_dVb + Cgg1 * dVgsteff_dVb; Cgd1 = CoxWL * dT3_dVd + Cgg1 * dVgsteff_dVd; - Cgg1 *= dVgsteff_dVg; - Cgg += Cgg1; - Cgb += Cgb1; - Cgd += Cgd1; + Cgg1 *= dVgsteff_dVg; + Cgg += Cgg1; + Cgb += Cgb1; + Cgd += Cgd1; qbulk += CoxWL * (1.0 - AbulkCV) * (0.5 * Vds - T3); - Cbg1 = -CoxWL * ((1.0 - AbulkCV) * dT3_dVg); - Cbb1 = -CoxWL * ((1.0 - AbulkCV) * dT3_dVb - + (0.5 * Vds - T3) * dAbulkCV_dVb) - + Cbg1 * dVgsteff_dVb; - Cbd1 = -CoxWL * (1.0 - AbulkCV) * dT3_dVd - + Cbg1 * dVgsteff_dVd; - Cbg1 *= dVgsteff_dVg; - Cbg += Cbg1; - Cbb += Cbb1; - Cbd += Cbd1; + Cbg1 = -CoxWL * ((1.0 - AbulkCV) * dT3_dVg); + Cbb1 = -CoxWL * ((1.0 - AbulkCV) * dT3_dVb + + (0.5 * Vds - T3) * dAbulkCV_dVb) + + Cbg1 * dVgsteff_dVb; + Cbd1 = -CoxWL * (1.0 - AbulkCV) * dT3_dVd + + Cbg1 * dVgsteff_dVd; + Cbg1 *= dVgsteff_dVg; + Cbg += Cbg1; + Cbb += Cbb1; + Cbd += Cbd1; if (model->BSIM3xpart > 0.5) - { /* 0/100 Charge petition model */ - T1 = T1 + T1; + { /* 0/100 Charge petition model */ + T1 = T1 + T1; qsrc = -CoxWL * (0.5 * Vgsteff + 0.25 * T0 - - T0 * T0 / T1); - Csg = -CoxWL * (0.5 + 24.0 * T0 * Vds / T1 / T1 - * AbulkCV); + - T0 * T0 / T1); + Csg = -CoxWL * (0.5 + 24.0 * T0 * Vds / T1 / T1 + * AbulkCV); Csb = -CoxWL * (0.25 * Vds * dAbulkCV_dVb - - 12.0 * T0 * Vds / T1 / T1 * (4.0 * Vgsteff - T0) - * dAbulkCV_dVb) + Csg * dVgsteff_dVb; - Csd = -CoxWL * (0.25 * AbulkCV - 12.0 * AbulkCV * T0 - / T1 / T1 * (4.0 * Vgsteff - T0)) - + Csg * dVgsteff_dVd; - Csg *= dVgsteff_dVg; + - 12.0 * T0 * Vds / T1 / T1 * (4.0 * Vgsteff - T0) + * dAbulkCV_dVb) + Csg * dVgsteff_dVb; + Csd = -CoxWL * (0.25 * AbulkCV - 12.0 * AbulkCV * T0 + / T1 / T1 * (4.0 * Vgsteff - T0)) + + Csg * dVgsteff_dVd; + Csg *= dVgsteff_dVg; } - else if (model->BSIM3xpart < 0.5) - { /* 40/60 Charge petition model */ - T1 = T1 / 12.0; - T2 = 0.5 * CoxWL / (T1 * T1); - T3 = Vgsteff * (2.0 * T0 * T0 / 3.0 + Vgsteff - * (Vgsteff - 4.0 * T0 / 3.0)) - - 2.0 * T0 * T0 * T0 / 15.0; - qsrc = -T2 * T3; - T4 = 4.0 / 3.0 * Vgsteff * (Vgsteff - T0) - + 0.4 * T0 * T0; - Csg = -2.0 * qsrc / T1 - T2 * (Vgsteff * (3.0 - * Vgsteff - 8.0 * T0 / 3.0) - + 2.0 * T0 * T0 / 3.0); - Csb = (qsrc / T1 * Vds + T2 * T4 * Vds) * dAbulkCV_dVb - + Csg * dVgsteff_dVb; - Csd = (qsrc / T1 + T2 * T4) * AbulkCV - + Csg * dVgsteff_dVd; - Csg *= dVgsteff_dVg; + else if (model->BSIM3xpart < 0.5) + { /* 40/60 Charge petition model */ + T1 = T1 / 12.0; + T2 = 0.5 * CoxWL / (T1 * T1); + T3 = Vgsteff * (2.0 * T0 * T0 / 3.0 + Vgsteff + * (Vgsteff - 4.0 * T0 / 3.0)) + - 2.0 * T0 * T0 * T0 / 15.0; + qsrc = -T2 * T3; + T4 = 4.0 / 3.0 * Vgsteff * (Vgsteff - T0) + + 0.4 * T0 * T0; + Csg = -2.0 * qsrc / T1 - T2 * (Vgsteff * (3.0 + * Vgsteff - 8.0 * T0 / 3.0) + + 2.0 * T0 * T0 / 3.0); + Csb = (qsrc / T1 * Vds + T2 * T4 * Vds) * dAbulkCV_dVb + + Csg * dVgsteff_dVb; + Csd = (qsrc / T1 + T2 * T4) * AbulkCV + + Csg * dVgsteff_dVd; + Csg *= dVgsteff_dVg; } - else - { /* 50/50 Charge petition model */ + else + { /* 50/50 Charge petition model */ qsrc = -0.5 * (qgate + qbulk); Csg = -0.5 * (Cgg1 + Cbg1); - Csb = -0.5 * (Cgb1 + Cbb1); - Csd = -0.5 * (Cgd1 + Cbd1); + Csb = -0.5 * (Cgb1 + Cbb1); + Csd = -0.5 * (Cgd1 + Cbd1); } - Cgb *= dVbseff_dVb; - Cbb *= dVbseff_dVb; - Csb *= dVbseff_dVb; + Cgb *= dVbseff_dVb; + Cbb *= dVbseff_dVb; + Csb *= dVbseff_dVb; } qdrn = -(qgate + qbulk + qsrc); here->BSIM3cggb = Cgg; - here->BSIM3cgsb = -(Cgg + Cgd + Cgb); - here->BSIM3cgdb = Cgd; + here->BSIM3cgsb = -(Cgg + Cgd + Cgb); + here->BSIM3cgdb = Cgd; here->BSIM3cdgb = -(Cgg + Cbg + Csg); - here->BSIM3cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb - + Csg + Csd + Csb); - here->BSIM3cddb = -(Cgd + Cbd + Csd); + here->BSIM3cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb + + Csg + Csd + Csb); + here->BSIM3cddb = -(Cgd + Cbd + Csd); here->BSIM3cbgb = Cbg; - here->BSIM3cbsb = -(Cbg + Cbd + Cbb); - here->BSIM3cbdb = Cbd; + here->BSIM3cbsb = -(Cbg + Cbd + Cbb); + here->BSIM3cbdb = Cbd; here->BSIM3qinv = -(qgate + qbulk); - } + } - else if (model->BSIM3capMod == 2) - { Vfb = pParam->BSIM3vfbzb; + else if (model->BSIM3capMod == 2) + { Vfb = pParam->BSIM3vfbzb; V3 = Vfb - Vgs_eff + VbseffCV - DELTA_3; - if (Vfb <= 0.0) - { T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * Vfb); - T2 = -DELTA_3 / T0; - } - else - { T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * Vfb); - T2 = DELTA_3 / T0; - } + if (Vfb <= 0.0) + { T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * Vfb); + T2 = -DELTA_3 / T0; + } + else + { T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * Vfb); + T2 = DELTA_3 / T0; + } - T1 = 0.5 * (1.0 + V3 / T0); - Vfbeff = Vfb - 0.5 * (V3 + T0); - dVfbeff_dVg = T1 * dVgs_eff_dVg; - dVfbeff_dVb = -T1 * dVbseffCV_dVb; - Qac0 = CoxWL * (Vfbeff - Vfb); - dQac0_dVg = CoxWL * dVfbeff_dVg; - dQac0_dVb = CoxWL * dVfbeff_dVb; + T1 = 0.5 * (1.0 + V3 / T0); + Vfbeff = Vfb - 0.5 * (V3 + T0); + dVfbeff_dVg = T1 * dVgs_eff_dVg; + dVfbeff_dVb = -T1 * dVbseffCV_dVb; + Qac0 = CoxWL * (Vfbeff - Vfb); + dQac0_dVg = CoxWL * dVfbeff_dVg; + dQac0_dVb = CoxWL * dVfbeff_dVb; T0 = 0.5 * pParam->BSIM3k1ox; - T3 = Vgs_eff - Vfbeff - VbseffCV - Vgsteff; + T3 = Vgs_eff - Vfbeff - VbseffCV - Vgsteff; if (pParam->BSIM3k1ox == 0.0) { T1 = 0.0; T2 = 0.0; } - else if (T3 < 0.0) - { T1 = T0 + T3 / pParam->BSIM3k1ox; + else if (T3 < 0.0) + { T1 = T0 + T3 / pParam->BSIM3k1ox; T2 = CoxWL; - } - else - { T1 = sqrt(T0 * T0 + T3); + } + else + { T1 = sqrt(T0 * T0 + T3); T2 = CoxWL * T0 / T1; - } + } - Qsub0 = CoxWL * pParam->BSIM3k1ox * (T1 - T0); + Qsub0 = CoxWL * pParam->BSIM3k1ox * (T1 - T0); dQsub0_dVg = T2 * (dVgs_eff_dVg - dVfbeff_dVg - dVgsteff_dVg); dQsub0_dVd = -T2 * dVgsteff_dVd; - dQsub0_dVb = -T2 * (dVfbeff_dVb + dVbseffCV_dVb + dQsub0_dVb = -T2 * (dVfbeff_dVb + dVbseffCV_dVb + dVgsteff_dVb); AbulkCV = Abulk0 * pParam->BSIM3abulkCVfactor; dAbulkCV_dVb = pParam->BSIM3abulkCVfactor * dAbulk0_dVb; - VdsatCV = Vgsteff / AbulkCV; + VdsatCV = Vgsteff / AbulkCV; - V4 = VdsatCV - Vds - DELTA_4; - T0 = sqrt(V4 * V4 + 4.0 * DELTA_4 * VdsatCV); - VdseffCV = VdsatCV - 0.5 * (V4 + T0); - T1 = 0.5 * (1.0 + V4 / T0); - T2 = DELTA_4 / T0; - T3 = (1.0 - T1 - T2) / AbulkCV; - dVdseffCV_dVg = T3; - dVdseffCV_dVd = T1; - dVdseffCV_dVb = -T3 * VdsatCV * dAbulkCV_dVb; + V4 = VdsatCV - Vds - DELTA_4; + T0 = sqrt(V4 * V4 + 4.0 * DELTA_4 * VdsatCV); + VdseffCV = VdsatCV - 0.5 * (V4 + T0); + T1 = 0.5 * (1.0 + V4 / T0); + T2 = DELTA_4 / T0; + T3 = (1.0 - T1 - T2) / AbulkCV; + dVdseffCV_dVg = T3; + dVdseffCV_dVd = T1; + dVdseffCV_dVb = -T3 * VdsatCV * dAbulkCV_dVb; /* Added to eliminate non-zero VdseffCV at Vds=0.0 */ if (Vds == 0.0) { VdseffCV = 0.0; @@ -1822,10 +1822,10 @@ for (; model != NULL; model = model->BSIM3nextModel) dVdseffCV_dVb = 0.0; } - T0 = AbulkCV * VdseffCV; + T0 = AbulkCV * VdseffCV; T1 = 12.0 * (Vgsteff - 0.5 * T0 + 1e-20); - T2 = VdseffCV / T1; - T3 = T0 * T2; + T2 = VdseffCV / T1; + T3 = T0 * T2; T4 = (1.0 - 12.0 * T2 * T2 * AbulkCV); T5 = (6.0 * T0 * (4.0 * Vgsteff - T0) / (T1 * T1) - 0.5); @@ -1836,109 +1836,109 @@ for (; model != NULL; model = model->BSIM3nextModel) Cgg1 = CoxWL * (T4 + T5 * dVdseffCV_dVg); Cgd1 = CoxWL * T5 * dVdseffCV_dVd + Cgg1 * dVgsteff_dVd; Cgb1 = CoxWL * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb) - + Cgg1 * dVgsteff_dVb; - Cgg1 *= dVgsteff_dVg; + + Cgg1 * dVgsteff_dVb; + Cgg1 *= dVgsteff_dVg; - T7 = 1.0 - AbulkCV; + T7 = 1.0 - AbulkCV; qbulk = CoxWL * T7 * (0.5 * VdseffCV - T3); - T4 = -T7 * (T4 - 1.0); - T5 = -T7 * T5; - T6 = -(T7 * T6 + (0.5 * VdseffCV - T3)); + T4 = -T7 * (T4 - 1.0); + T5 = -T7 * T5; + T6 = -(T7 * T6 + (0.5 * VdseffCV - T3)); Cbg1 = CoxWL * (T4 + T5 * dVdseffCV_dVg); Cbd1 = CoxWL * T5 * dVdseffCV_dVd + Cbg1 * dVgsteff_dVd; Cbb1 = CoxWL * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb) - + Cbg1 * dVgsteff_dVb; - Cbg1 *= dVgsteff_dVg; + + Cbg1 * dVgsteff_dVb; + Cbg1 *= dVgsteff_dVg; if (model->BSIM3xpart > 0.5) - { /* 0/100 Charge petition model */ - T1 = T1 + T1; + { /* 0/100 Charge petition model */ + T1 = T1 + T1; qsrc = -CoxWL * (0.5 * Vgsteff + 0.25 * T0 - - T0 * T0 / T1); - T7 = (4.0 * Vgsteff - T0) / (T1 * T1); - T4 = -(0.5 + 24.0 * T0 * T0 / (T1 * T1)); - T5 = -(0.25 * AbulkCV - 12.0 * AbulkCV * T0 * T7); + - T0 * T0 / T1); + T7 = (4.0 * Vgsteff - T0) / (T1 * T1); + T4 = -(0.5 + 24.0 * T0 * T0 / (T1 * T1)); + T5 = -(0.25 * AbulkCV - 12.0 * AbulkCV * T0 * T7); T6 = -(0.25 * VdseffCV - 12.0 * T0 * VdseffCV * T7); Csg = CoxWL * (T4 + T5 * dVdseffCV_dVg); Csd = CoxWL * T5 * dVdseffCV_dVd + Csg * dVgsteff_dVd; Csb = CoxWL * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb) - + Csg * dVgsteff_dVb; - Csg *= dVgsteff_dVg; + + Csg * dVgsteff_dVb; + Csg *= dVgsteff_dVg; } - else if (model->BSIM3xpart < 0.5) - { /* 40/60 Charge petition model */ - T1 = T1 / 12.0; - T2 = 0.5 * CoxWL / (T1 * T1); - T3 = Vgsteff * (2.0 * T0 * T0 / 3.0 + Vgsteff - * (Vgsteff - 4.0 * T0 / 3.0)) - - 2.0 * T0 * T0 * T0 / 15.0; - qsrc = -T2 * T3; - T7 = 4.0 / 3.0 * Vgsteff * (Vgsteff - T0) - + 0.4 * T0 * T0; - T4 = -2.0 * qsrc / T1 - T2 * (Vgsteff * (3.0 - * Vgsteff - 8.0 * T0 / 3.0) - + 2.0 * T0 * T0 / 3.0); - T5 = (qsrc / T1 + T2 * T7) * AbulkCV; - T6 = (qsrc / T1 * VdseffCV + T2 * T7 * VdseffCV); + else if (model->BSIM3xpart < 0.5) + { /* 40/60 Charge petition model */ + T1 = T1 / 12.0; + T2 = 0.5 * CoxWL / (T1 * T1); + T3 = Vgsteff * (2.0 * T0 * T0 / 3.0 + Vgsteff + * (Vgsteff - 4.0 * T0 / 3.0)) + - 2.0 * T0 * T0 * T0 / 15.0; + qsrc = -T2 * T3; + T7 = 4.0 / 3.0 * Vgsteff * (Vgsteff - T0) + + 0.4 * T0 * T0; + T4 = -2.0 * qsrc / T1 - T2 * (Vgsteff * (3.0 + * Vgsteff - 8.0 * T0 / 3.0) + + 2.0 * T0 * T0 / 3.0); + T5 = (qsrc / T1 + T2 * T7) * AbulkCV; + T6 = (qsrc / T1 * VdseffCV + T2 * T7 * VdseffCV); Csg = (T4 + T5 * dVdseffCV_dVg); Csd = T5 * dVdseffCV_dVd + Csg * dVgsteff_dVd; Csb = (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb) - + Csg * dVgsteff_dVb; - Csg *= dVgsteff_dVg; + + Csg * dVgsteff_dVb; + Csg *= dVgsteff_dVg; } - else - { /* 50/50 Charge petition model */ + else + { /* 50/50 Charge petition model */ qsrc = -0.5 * (qgate + qbulk); Csg = -0.5 * (Cgg1 + Cbg1); - Csb = -0.5 * (Cgb1 + Cbb1); - Csd = -0.5 * (Cgd1 + Cbd1); + Csb = -0.5 * (Cgb1 + Cbb1); + Csd = -0.5 * (Cgd1 + Cbd1); } - qgate += Qac0 + Qsub0; - qbulk -= (Qac0 + Qsub0); + qgate += Qac0 + Qsub0; + qbulk -= (Qac0 + Qsub0); qdrn = -(qgate + qbulk + qsrc); - Cgg = dQac0_dVg + dQsub0_dVg + Cgg1; - Cgd = dQsub0_dVd + Cgd1; - Cgb = dQac0_dVb + dQsub0_dVb + Cgb1; + Cgg = dQac0_dVg + dQsub0_dVg + Cgg1; + Cgd = dQsub0_dVd + Cgd1; + Cgb = dQac0_dVb + dQsub0_dVb + Cgb1; - Cbg = Cbg1 - dQac0_dVg - dQsub0_dVg; - Cbd = Cbd1 - dQsub0_dVd; - Cbb = Cbb1 - dQac0_dVb - dQsub0_dVb; + Cbg = Cbg1 - dQac0_dVg - dQsub0_dVg; + Cbd = Cbd1 - dQsub0_dVd; + Cbb = Cbb1 - dQac0_dVb - dQsub0_dVb; - Cgb *= dVbseff_dVb; - Cbb *= dVbseff_dVb; - Csb *= dVbseff_dVb; + Cgb *= dVbseff_dVb; + Cbb *= dVbseff_dVb; + Csb *= dVbseff_dVb; here->BSIM3cggb = Cgg; - here->BSIM3cgsb = -(Cgg + Cgd + Cgb); - here->BSIM3cgdb = Cgd; + here->BSIM3cgsb = -(Cgg + Cgd + Cgb); + here->BSIM3cgdb = Cgd; here->BSIM3cdgb = -(Cgg + Cbg + Csg); - here->BSIM3cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb - + Csg + Csd + Csb); - here->BSIM3cddb = -(Cgd + Cbd + Csd); + here->BSIM3cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb + + Csg + Csd + Csb); + here->BSIM3cddb = -(Cgd + Cbd + Csd); here->BSIM3cbgb = Cbg; - here->BSIM3cbsb = -(Cbg + Cbd + Cbb); - here->BSIM3cbdb = Cbd; + here->BSIM3cbsb = -(Cbg + Cbd + Cbb); + here->BSIM3cbdb = Cbd; here->BSIM3qinv = qinoi; - } + } /* New Charge-Thickness capMod (CTM) begins */ - else if (model->BSIM3capMod == 3) - { V3 = pParam->BSIM3vfbzb - Vgs_eff + VbseffCV - DELTA_3; - if (pParam->BSIM3vfbzb <= 0.0) - { T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * pParam->BSIM3vfbzb); - T2 = -DELTA_3 / T0; - } - else - { T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * pParam->BSIM3vfbzb); - T2 = DELTA_3 / T0; - } + else if (model->BSIM3capMod == 3) + { V3 = pParam->BSIM3vfbzb - Vgs_eff + VbseffCV - DELTA_3; + if (pParam->BSIM3vfbzb <= 0.0) + { T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * pParam->BSIM3vfbzb); + T2 = -DELTA_3 / T0; + } + else + { T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * pParam->BSIM3vfbzb); + T2 = DELTA_3 / T0; + } - T1 = 0.5 * (1.0 + V3 / T0); - Vfbeff = pParam->BSIM3vfbzb - 0.5 * (V3 + T0); - dVfbeff_dVg = T1 * dVgs_eff_dVg; - dVfbeff_dVb = -T1 * dVbseffCV_dVb; + T1 = 0.5 * (1.0 + V3 / T0); + Vfbeff = pParam->BSIM3vfbzb - 0.5 * (V3 + T0); + dVfbeff_dVg = T1 * dVgs_eff_dVg; + dVfbeff_dVb = -T1 * dVbseffCV_dVb; Cox = model->BSIM3cox; Tox = 1.0e8 * model->BSIM3tox; @@ -1983,8 +1983,8 @@ for (; model != NULL; model = model->BSIM3nextModel) QovCox = Qac0 / Coxeff; dQac0_dVg = CoxWLcen * dVfbeff_dVg + QovCox * dCoxeff_dVg; - dQac0_dVb = CoxWLcen * dVfbeff_dVb - + QovCox * dCoxeff_dVb; + dQac0_dVb = CoxWLcen * dVfbeff_dVb + + QovCox * dCoxeff_dVb; T0 = 0.5 * pParam->BSIM3k1ox; T3 = Vgs_eff - Vfbeff - VbseffCV - Vgsteff; @@ -2009,21 +2009,21 @@ for (; model != NULL; model = model->BSIM3nextModel) dQsub0_dVb = -T2 * (dVfbeff_dVb + dVbseffCV_dVb + dVgsteff_dVb) + QovCox * dCoxeff_dVb; - /* Gate-bias dependent delta Phis begins */ - if (pParam->BSIM3k1ox <= 0.0) - { Denomi = 0.25 * pParam->BSIM3moin * Vtm; + /* Gate-bias dependent delta Phis begins */ + if (pParam->BSIM3k1ox <= 0.0) + { Denomi = 0.25 * pParam->BSIM3moin * Vtm; T0 = 0.5 * pParam->BSIM3sqrtPhi; - } - else - { Denomi = pParam->BSIM3moin * Vtm - * pParam->BSIM3k1ox * pParam->BSIM3k1ox; + } + else + { Denomi = pParam->BSIM3moin * Vtm + * pParam->BSIM3k1ox * pParam->BSIM3k1ox; T0 = pParam->BSIM3k1ox * pParam->BSIM3sqrtPhi; - } + } T1 = 2.0 * T0 + Vgsteff; - DeltaPhi = Vtm * log(1.0 + T1 * Vgsteff / Denomi); - dDeltaPhi_dVg = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff); - /* End of delta Phis */ + DeltaPhi = Vtm * log(1.0 + T1 * Vgsteff / Denomi); + dDeltaPhi_dVg = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff); + /* End of delta Phis */ /* VgDP = Vgsteff - DeltaPhi */ T0 = Vgsteff - DeltaPhi - 0.001; @@ -2054,19 +2054,19 @@ for (; model != NULL; model = model->BSIM3nextModel) dTcen_dVd *= dT0_dVd; dTcen_dVg *= dVgsteff_dVg; - Ccen = EPSSI / Tcen; - T0 = Cox / (Cox + Ccen); - Coxeff = T0 * Ccen; - T1 = -Ccen / Tcen; - dCoxeff_dVg = T0 * T0 * T1; - dCoxeff_dVd = dCoxeff_dVg * dTcen_dVd; - dCoxeff_dVb = dCoxeff_dVg * dTcen_dVb; - dCoxeff_dVg *= dTcen_dVg; - CoxWLcen = CoxWL * Coxeff / Cox; + Ccen = EPSSI / Tcen; + T0 = Cox / (Cox + Ccen); + Coxeff = T0 * Ccen; + T1 = -Ccen / Tcen; + dCoxeff_dVg = T0 * T0 * T1; + dCoxeff_dVd = dCoxeff_dVg * dTcen_dVd; + dCoxeff_dVb = dCoxeff_dVg * dTcen_dVb; + dCoxeff_dVg *= dTcen_dVg; + CoxWLcen = CoxWL * Coxeff / Cox; - AbulkCV = Abulk0 * pParam->BSIM3abulkCVfactor; - dAbulkCV_dVb = pParam->BSIM3abulkCVfactor * dAbulk0_dVb; - VdsatCV = VgDP / AbulkCV; + AbulkCV = Abulk0 * pParam->BSIM3abulkCVfactor; + dAbulkCV_dVb = pParam->BSIM3abulkCVfactor * dAbulk0_dVb; + VdsatCV = VgDP / AbulkCV; T0 = VdsatCV - Vds - DELTA_4; dT0_dVg = dVgDP_dVg / AbulkCV; dT0_dVb = -VdsatCV * dAbulkCV_dVb / AbulkCV; @@ -2099,22 +2099,22 @@ for (; model != NULL; model = model->BSIM3nextModel) } T0 = AbulkCV * VdseffCV; - T1 = VgDP; + T1 = VgDP; T2 = 12.0 * (T1 - 0.5 * T0 + 1.0e-20); T3 = T0 / T2; T4 = 1.0 - 12.0 * T3 * T3; T5 = AbulkCV * (6.0 * T0 * (4.0 * T1 - T0) / (T2 * T2) - 0.5); - T6 = T5 * VdseffCV / AbulkCV; + T6 = T5 * VdseffCV / AbulkCV; qgate = qinoi = CoxWLcen * (T1 - T0 * (0.5 - T3)); - QovCox = qgate / Coxeff; - Cgg1 = CoxWLcen * (T4 * dVgDP_dVg - + T5 * dVdseffCV_dVg); - Cgd1 = CoxWLcen * T5 * dVdseffCV_dVd + Cgg1 - * dVgsteff_dVd + QovCox * dCoxeff_dVd; - Cgb1 = CoxWLcen * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb) - + Cgg1 * dVgsteff_dVb + QovCox * dCoxeff_dVb; - Cgg1 = Cgg1 * dVgsteff_dVg + QovCox * dCoxeff_dVg; + QovCox = qgate / Coxeff; + Cgg1 = CoxWLcen * (T4 * dVgDP_dVg + + T5 * dVdseffCV_dVg); + Cgd1 = CoxWLcen * T5 * dVdseffCV_dVd + Cgg1 + * dVgsteff_dVd + QovCox * dCoxeff_dVd; + Cgb1 = CoxWLcen * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb) + + Cgg1 * dVgsteff_dVb + QovCox * dCoxeff_dVb; + Cgg1 = Cgg1 * dVgsteff_dVg + QovCox * dCoxeff_dVg; T7 = 1.0 - AbulkCV; @@ -2124,95 +2124,95 @@ for (; model != NULL; model = model->BSIM3nextModel) T11 = -T7 * T5 / AbulkCV; T12 = -(T9 * T1 / AbulkCV + VdseffCV * (0.5 - T0 / T2)); - qbulk = CoxWLcen * T7 * (0.5 * VdseffCV - T0 * VdseffCV / T2); - QovCox = qbulk / Coxeff; - Cbg1 = CoxWLcen * (T10 + T11 * dVdseffCV_dVg); - Cbd1 = CoxWLcen * T11 * dVdseffCV_dVd + Cbg1 - * dVgsteff_dVd + QovCox * dCoxeff_dVd; - Cbb1 = CoxWLcen * (T11 * dVdseffCV_dVb + T12 * dAbulkCV_dVb) - + Cbg1 * dVgsteff_dVb + QovCox * dCoxeff_dVb; - Cbg1 = Cbg1 * dVgsteff_dVg + QovCox * dCoxeff_dVg; + qbulk = CoxWLcen * T7 * (0.5 * VdseffCV - T0 * VdseffCV / T2); + QovCox = qbulk / Coxeff; + Cbg1 = CoxWLcen * (T10 + T11 * dVdseffCV_dVg); + Cbd1 = CoxWLcen * T11 * dVdseffCV_dVd + Cbg1 + * dVgsteff_dVd + QovCox * dCoxeff_dVd; + Cbb1 = CoxWLcen * (T11 * dVdseffCV_dVb + T12 * dAbulkCV_dVb) + + Cbg1 * dVgsteff_dVb + QovCox * dCoxeff_dVb; + Cbg1 = Cbg1 * dVgsteff_dVg + QovCox * dCoxeff_dVg; if (model->BSIM3xpart > 0.5) - { /* 0/100 partition */ - qsrc = -CoxWLcen * (T1 / 2.0 + T0 / 4.0 - - 0.5 * T0 * T0 / T2); - QovCox = qsrc / Coxeff; - T2 += T2; - T3 = T2 * T2; - T7 = -(0.25 - 12.0 * T0 * (4.0 * T1 - T0) / T3); - T4 = -(0.5 + 24.0 * T0 * T0 / T3) * dVgDP_dVg; - T5 = T7 * AbulkCV; - T6 = T7 * VdseffCV; + { /* 0/100 partition */ + qsrc = -CoxWLcen * (T1 / 2.0 + T0 / 4.0 + - 0.5 * T0 * T0 / T2); + QovCox = qsrc / Coxeff; + T2 += T2; + T3 = T2 * T2; + T7 = -(0.25 - 12.0 * T0 * (4.0 * T1 - T0) / T3); + T4 = -(0.5 + 24.0 * T0 * T0 / T3) * dVgDP_dVg; + T5 = T7 * AbulkCV; + T6 = T7 * VdseffCV; - Csg = CoxWLcen * (T4 + T5 * dVdseffCV_dVg); - Csd = CoxWLcen * T5 * dVdseffCV_dVd + Csg * dVgsteff_dVd - + QovCox * dCoxeff_dVd; - Csb = CoxWLcen * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb) - + Csg * dVgsteff_dVb + QovCox * dCoxeff_dVb; - Csg = Csg * dVgsteff_dVg + QovCox * dCoxeff_dVg; + Csg = CoxWLcen * (T4 + T5 * dVdseffCV_dVg); + Csd = CoxWLcen * T5 * dVdseffCV_dVd + Csg * dVgsteff_dVd + + QovCox * dCoxeff_dVd; + Csb = CoxWLcen * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb) + + Csg * dVgsteff_dVb + QovCox * dCoxeff_dVb; + Csg = Csg * dVgsteff_dVg + QovCox * dCoxeff_dVg; } - else if (model->BSIM3xpart < 0.5) - { /* 40/60 partition */ - T2 = T2 / 12.0; - T3 = 0.5 * CoxWLcen / (T2 * T2); - T4 = T1 * (2.0 * T0 * T0 / 3.0 + T1 * (T1 - 4.0 + else if (model->BSIM3xpart < 0.5) + { /* 40/60 partition */ + T2 = T2 / 12.0; + T3 = 0.5 * CoxWLcen / (T2 * T2); + T4 = T1 * (2.0 * T0 * T0 / 3.0 + T1 * (T1 - 4.0 * T0 / 3.0)) - 2.0 * T0 * T0 * T0 / 15.0; - qsrc = -T3 * T4; - QovCox = qsrc / Coxeff; - T8 = 4.0 / 3.0 * T1 * (T1 - T0) + 0.4 * T0 * T0; - T5 = -2.0 * qsrc / T2 - T3 * (T1 * (3.0 * T1 - 8.0 - * T0 / 3.0) + 2.0 * T0 * T0 / 3.0); - T6 = AbulkCV * (qsrc / T2 + T3 * T8); - T7 = T6 * VdseffCV / AbulkCV; + qsrc = -T3 * T4; + QovCox = qsrc / Coxeff; + T8 = 4.0 / 3.0 * T1 * (T1 - T0) + 0.4 * T0 * T0; + T5 = -2.0 * qsrc / T2 - T3 * (T1 * (3.0 * T1 - 8.0 + * T0 / 3.0) + 2.0 * T0 * T0 / 3.0); + T6 = AbulkCV * (qsrc / T2 + T3 * T8); + T7 = T6 * VdseffCV / AbulkCV; - Csg = T5 * dVgDP_dVg + T6 * dVdseffCV_dVg; - Csd = Csg * dVgsteff_dVd + T6 * dVdseffCV_dVd - + QovCox * dCoxeff_dVd; - Csb = Csg * dVgsteff_dVb + T6 * dVdseffCV_dVb - + T7 * dAbulkCV_dVb + QovCox * dCoxeff_dVb; - Csg = Csg * dVgsteff_dVg + QovCox * dCoxeff_dVg; + Csg = T5 * dVgDP_dVg + T6 * dVdseffCV_dVg; + Csd = Csg * dVgsteff_dVd + T6 * dVdseffCV_dVd + + QovCox * dCoxeff_dVd; + Csb = Csg * dVgsteff_dVb + T6 * dVdseffCV_dVb + + T7 * dAbulkCV_dVb + QovCox * dCoxeff_dVb; + Csg = Csg * dVgsteff_dVg + QovCox * dCoxeff_dVg; } - else - { /* 50/50 partition */ + else + { /* 50/50 partition */ qsrc = -0.5 * qgate; Csg = -0.5 * Cgg1; - Csd = -0.5 * Cgd1; - Csb = -0.5 * Cgb1; + Csd = -0.5 * Cgd1; + Csb = -0.5 * Cgb1; } - qgate += Qac0 + Qsub0 - qbulk; - qbulk -= (Qac0 + Qsub0); + qgate += Qac0 + Qsub0 - qbulk; + qbulk -= (Qac0 + Qsub0); qdrn = -(qgate + qbulk + qsrc); - Cbg = Cbg1 - dQac0_dVg - dQsub0_dVg; - Cbd = Cbd1 - dQsub0_dVd; - Cbb = Cbb1 - dQac0_dVb - dQsub0_dVb; + Cbg = Cbg1 - dQac0_dVg - dQsub0_dVg; + Cbd = Cbd1 - dQsub0_dVd; + Cbb = Cbb1 - dQac0_dVb - dQsub0_dVb; Cgg = Cgg1 - Cbg; Cgd = Cgd1 - Cbd; Cgb = Cgb1 - Cbb; - Cgb *= dVbseff_dVb; - Cbb *= dVbseff_dVb; - Csb *= dVbseff_dVb; + Cgb *= dVbseff_dVb; + Cbb *= dVbseff_dVb; + Csb *= dVbseff_dVb; here->BSIM3cggb = Cgg; - here->BSIM3cgsb = -(Cgg + Cgd + Cgb); - here->BSIM3cgdb = Cgd; + here->BSIM3cgsb = -(Cgg + Cgd + Cgb); + here->BSIM3cgdb = Cgd; here->BSIM3cdgb = -(Cgg + Cbg + Csg); - here->BSIM3cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb - + Csg + Csd + Csb); - here->BSIM3cddb = -(Cgd + Cbd + Csd); + here->BSIM3cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb + + Csg + Csd + Csb); + here->BSIM3cddb = -(Cgd + Cbd + Csd); here->BSIM3cbgb = Cbg; - here->BSIM3cbsb = -(Cbg + Cbd + Cbb); - here->BSIM3cbdb = Cbd; + here->BSIM3cbsb = -(Cbg + Cbd + Cbb); + here->BSIM3cbdb = Cbd; here->BSIM3qinv = -qinoi; - } /* End of CTM */ + } /* End of CTM */ } -finished: - /* Returning Values to Calling Routine */ +finished: + /* Returning Values to Calling Routine */ /* * COMPUTE EQUIVALENT DRAIN CURRENT SOURCE */ @@ -2223,150 +2223,150 @@ finished: here->BSIM3cd = cdrain; if (ChargeComputationNeeded) - { /* charge storage elements + { /* charge storage elements * bulk-drain and bulk-source depletion capacitances * czbd : zero bias drain junction capacitance * czbs : zero bias source junction capacitance * czbdsw: zero bias drain junction sidewall capacitance - along field oxide + along field oxide * czbssw: zero bias source junction sidewall capacitance - along field oxide - * czbdswg: zero bias drain junction sidewall capacitance - along gate side - * czbsswg: zero bias source junction sidewall capacitance - along gate side + along field oxide + * czbdswg: zero bias drain junction sidewall capacitance + along gate side + * czbsswg: zero bias source junction sidewall capacitance + along gate side */ czbd = model->BSIM3unitAreaTempJctCap * here->BSIM3drainArea; /*bug fix */ czbs = model->BSIM3unitAreaTempJctCap * here->BSIM3sourceArea; if (here->BSIM3drainPerimeter < pParam->BSIM3weff) - { - czbdswg = model->BSIM3unitLengthGateSidewallTempJctCap - * here->BSIM3drainPerimeter; + { + czbdswg = model->BSIM3unitLengthGateSidewallTempJctCap + * here->BSIM3drainPerimeter; czbdsw = 0.0; } else { - czbdsw = model->BSIM3unitLengthSidewallTempJctCap - * (here->BSIM3drainPerimeter - pParam->BSIM3weff); - czbdswg = model->BSIM3unitLengthGateSidewallTempJctCap - * pParam->BSIM3weff; + czbdsw = model->BSIM3unitLengthSidewallTempJctCap + * (here->BSIM3drainPerimeter - pParam->BSIM3weff); + czbdswg = model->BSIM3unitLengthGateSidewallTempJctCap + * pParam->BSIM3weff; } if (here->BSIM3sourcePerimeter < pParam->BSIM3weff) { - czbssw = 0.0; - czbsswg = model->BSIM3unitLengthGateSidewallTempJctCap - * here->BSIM3sourcePerimeter; + czbssw = 0.0; + czbsswg = model->BSIM3unitLengthGateSidewallTempJctCap + * here->BSIM3sourcePerimeter; } else { - czbssw = model->BSIM3unitLengthSidewallTempJctCap - * (here->BSIM3sourcePerimeter - pParam->BSIM3weff); - czbsswg = model->BSIM3unitLengthGateSidewallTempJctCap - * pParam->BSIM3weff; + czbssw = model->BSIM3unitLengthSidewallTempJctCap + * (here->BSIM3sourcePerimeter - pParam->BSIM3weff); + czbsswg = model->BSIM3unitLengthGateSidewallTempJctCap + * pParam->BSIM3weff; } MJ = model->BSIM3bulkJctBotGradingCoeff; MJSW = model->BSIM3bulkJctSideGradingCoeff; - MJSWG = model->BSIM3bulkJctGateSideGradingCoeff; + MJSWG = model->BSIM3bulkJctGateSideGradingCoeff; /* Source Bulk Junction */ - if (vbs == 0.0) - { *(ckt->CKTstate0 + here->BSIM3qbs) = 0.0; + if (vbs == 0.0) + { *(ckt->CKTstate0 + here->BSIM3qbs) = 0.0; here->BSIM3capbs = czbs + czbssw + czbsswg; - } - else if (vbs < 0.0) - { if (czbs > 0.0) - { arg = 1.0 - vbs / model->BSIM3PhiB; - if (MJ == 0.5) + } + else if (vbs < 0.0) + { if (czbs > 0.0) + { arg = 1.0 - vbs / model->BSIM3PhiB; + if (MJ == 0.5) sarg = 1.0 / sqrt(arg); - else + else sarg = exp(-MJ * log(arg)); - *(ckt->CKTstate0 + here->BSIM3qbs) = model->BSIM3PhiB * czbs - * (1.0 - arg * sarg) / (1.0 - MJ); - here->BSIM3capbs = czbs * sarg; - } - else - { *(ckt->CKTstate0 + here->BSIM3qbs) = 0.0; - here->BSIM3capbs = 0.0; - } - if (czbssw > 0.0) - { arg = 1.0 - vbs / model->BSIM3PhiBSW; - if (MJSW == 0.5) + *(ckt->CKTstate0 + here->BSIM3qbs) = model->BSIM3PhiB * czbs + * (1.0 - arg * sarg) / (1.0 - MJ); + here->BSIM3capbs = czbs * sarg; + } + else + { *(ckt->CKTstate0 + here->BSIM3qbs) = 0.0; + here->BSIM3capbs = 0.0; + } + if (czbssw > 0.0) + { arg = 1.0 - vbs / model->BSIM3PhiBSW; + if (MJSW == 0.5) sarg = 1.0 / sqrt(arg); - else + else sarg = exp(-MJSW * log(arg)); *(ckt->CKTstate0 + here->BSIM3qbs) += model->BSIM3PhiBSW * czbssw - * (1.0 - arg * sarg) / (1.0 - MJSW); + * (1.0 - arg * sarg) / (1.0 - MJSW); here->BSIM3capbs += czbssw * sarg; - } - if (czbsswg > 0.0) - { arg = 1.0 - vbs / model->BSIM3PhiBSWG; - if (MJSWG == 0.5) + } + if (czbsswg > 0.0) + { arg = 1.0 - vbs / model->BSIM3PhiBSWG; + if (MJSWG == 0.5) sarg = 1.0 / sqrt(arg); - else + else sarg = exp(-MJSWG * log(arg)); *(ckt->CKTstate0 + here->BSIM3qbs) += model->BSIM3PhiBSWG * czbsswg - * (1.0 - arg * sarg) / (1.0 - MJSWG); + * (1.0 - arg * sarg) / (1.0 - MJSWG); here->BSIM3capbs += czbsswg * sarg; - } + } } - else - { T0 = czbs + czbssw + czbsswg; - T1 = vbs * (czbs * MJ / model->BSIM3PhiB + czbssw * MJSW - / model->BSIM3PhiBSW + czbsswg * MJSWG / model->BSIM3PhiBSWG); + else + { T0 = czbs + czbssw + czbsswg; + T1 = vbs * (czbs * MJ / model->BSIM3PhiB + czbssw * MJSW + / model->BSIM3PhiBSW + czbsswg * MJSWG / model->BSIM3PhiBSWG); *(ckt->CKTstate0 + here->BSIM3qbs) = vbs * (T0 + 0.5 * T1); here->BSIM3capbs = T0 + T1; } /* Drain Bulk Junction */ - if (vbd == 0.0) - { *(ckt->CKTstate0 + here->BSIM3qbd) = 0.0; + if (vbd == 0.0) + { *(ckt->CKTstate0 + here->BSIM3qbd) = 0.0; here->BSIM3capbd = czbd + czbdsw + czbdswg; - } - else if (vbd < 0.0) - { if (czbd > 0.0) - { arg = 1.0 - vbd / model->BSIM3PhiB; - if (MJ == 0.5) + } + else if (vbd < 0.0) + { if (czbd > 0.0) + { arg = 1.0 - vbd / model->BSIM3PhiB; + if (MJ == 0.5) sarg = 1.0 / sqrt(arg); - else + else sarg = exp(-MJ * log(arg)); - *(ckt->CKTstate0 + here->BSIM3qbd) = model->BSIM3PhiB * czbd - * (1.0 - arg * sarg) / (1.0 - MJ); + *(ckt->CKTstate0 + here->BSIM3qbd) = model->BSIM3PhiB * czbd + * (1.0 - arg * sarg) / (1.0 - MJ); here->BSIM3capbd = czbd * sarg; - } - else - { *(ckt->CKTstate0 + here->BSIM3qbd) = 0.0; + } + else + { *(ckt->CKTstate0 + here->BSIM3qbd) = 0.0; here->BSIM3capbd = 0.0; - } - if (czbdsw > 0.0) - { arg = 1.0 - vbd / model->BSIM3PhiBSW; - if (MJSW == 0.5) + } + if (czbdsw > 0.0) + { arg = 1.0 - vbd / model->BSIM3PhiBSW; + if (MJSW == 0.5) sarg = 1.0 / sqrt(arg); - else + else sarg = exp(-MJSW * log(arg)); - *(ckt->CKTstate0 + here->BSIM3qbd) += model->BSIM3PhiBSW * czbdsw - * (1.0 - arg * sarg) / (1.0 - MJSW); + *(ckt->CKTstate0 + here->BSIM3qbd) += model->BSIM3PhiBSW * czbdsw + * (1.0 - arg * sarg) / (1.0 - MJSW); here->BSIM3capbd += czbdsw * sarg; - } - if (czbdswg > 0.0) - { arg = 1.0 - vbd / model->BSIM3PhiBSWG; - if (MJSWG == 0.5) + } + if (czbdswg > 0.0) + { arg = 1.0 - vbd / model->BSIM3PhiBSWG; + if (MJSWG == 0.5) sarg = 1.0 / sqrt(arg); - else + else sarg = exp(-MJSWG * log(arg)); *(ckt->CKTstate0 + here->BSIM3qbd) += model->BSIM3PhiBSWG * czbdswg - * (1.0 - arg * sarg) / (1.0 - MJSWG); + * (1.0 - arg * sarg) / (1.0 - MJSWG); here->BSIM3capbd += czbdswg * sarg; - } + } } - else - { T0 = czbd + czbdsw + czbdswg; + else + { T0 = czbd + czbdsw + czbdswg; T1 = vbd * (czbd * MJ / model->BSIM3PhiB + czbdsw * MJSW / model->BSIM3PhiBSW + czbdswg * MJSWG / model->BSIM3PhiBSWG); *(ckt->CKTstate0 + here->BSIM3qbd) = vbd * (T0 + 0.5 * T1); - here->BSIM3capbd = T0 + T1; + here->BSIM3capbd = T0 + T1; } } @@ -2374,11 +2374,11 @@ finished: * check convergence */ if ((here->BSIM3off == 0) || (!(ckt->CKTmode & MODEINITFIX))) - { if (Check == 1) - { ckt->CKTnoncon++; + { if (Check == 1) + { ckt->CKTnoncon++; #ifndef NEWCONV - } - else + } + else { if (here->BSIM3mode >= 0) { Idtot = here->BSIM3cd + here->BSIM3csub - here->BSIM3cbd; } @@ -2395,7 +2395,7 @@ finished: tol = ckt->CKTreltol * MAX(fabs(cbhat), fabs(Ibtot)) + ckt->CKTabstol; if (fabs(cbhat - Ibtot) > tol) - { ckt->CKTnoncon++; + { ckt->CKTnoncon++; } } #endif /* NEWCONV */ @@ -2410,7 +2410,7 @@ finished: /* bulk and channel charge plus overlaps */ if (!ChargeComputationNeeded) - goto line850; + goto line850; #ifndef NOBYPASS line755: #endif @@ -2427,71 +2427,71 @@ line755: gtau_drift = fabs(pParam->BSIM3tconst * qcheq) * ScalingFactor; T0 = pParam->BSIM3leffCV * pParam->BSIM3leffCV; gtau_diff = 16.0 * pParam->BSIM3u0temp * model->BSIM3vtm / T0 - * ScalingFactor; + * ScalingFactor; here->BSIM3gtau = gtau_drift + gtau_diff; if (here->BSIM3acnqsMod) here->BSIM3taunet = ScalingFactor / here->BSIM3gtau; } - if (model->BSIM3capMod == 0) /* code merge -JX */ - { - cgdo = pParam->BSIM3cgdo; - qgdo = pParam->BSIM3cgdo * vgd; - cgso = pParam->BSIM3cgso; - qgso = pParam->BSIM3cgso * vgs; - } - else if (model->BSIM3capMod == 1) - { if (vgd < 0.0) - { T1 = sqrt(1.0 - 4.0 * vgd / pParam->BSIM3ckappa); - cgdo = pParam->BSIM3cgdo + pParam->BSIM3weffCV - * pParam->BSIM3cgdl / T1; - qgdo = pParam->BSIM3cgdo * vgd - pParam->BSIM3weffCV * 0.5 - * pParam->BSIM3cgdl * pParam->BSIM3ckappa * (T1 - 1.0); - } - else - { cgdo = pParam->BSIM3cgdo + pParam->BSIM3weffCV - * pParam->BSIM3cgdl; - qgdo = (pParam->BSIM3weffCV * pParam->BSIM3cgdl - + pParam->BSIM3cgdo) * vgd; - } + if (model->BSIM3capMod == 0) /* code merge -JX */ + { + cgdo = pParam->BSIM3cgdo; + qgdo = pParam->BSIM3cgdo * vgd; + cgso = pParam->BSIM3cgso; + qgso = pParam->BSIM3cgso * vgs; + } + else if (model->BSIM3capMod == 1) + { if (vgd < 0.0) + { T1 = sqrt(1.0 - 4.0 * vgd / pParam->BSIM3ckappa); + cgdo = pParam->BSIM3cgdo + pParam->BSIM3weffCV + * pParam->BSIM3cgdl / T1; + qgdo = pParam->BSIM3cgdo * vgd - pParam->BSIM3weffCV * 0.5 + * pParam->BSIM3cgdl * pParam->BSIM3ckappa * (T1 - 1.0); + } + else + { cgdo = pParam->BSIM3cgdo + pParam->BSIM3weffCV + * pParam->BSIM3cgdl; + qgdo = (pParam->BSIM3weffCV * pParam->BSIM3cgdl + + pParam->BSIM3cgdo) * vgd; + } - if (vgs < 0.0) - { T1 = sqrt(1.0 - 4.0 * vgs / pParam->BSIM3ckappa); - cgso = pParam->BSIM3cgso + pParam->BSIM3weffCV - * pParam->BSIM3cgsl / T1; - qgso = pParam->BSIM3cgso * vgs - pParam->BSIM3weffCV * 0.5 - * pParam->BSIM3cgsl * pParam->BSIM3ckappa * (T1 - 1.0); - } - else - { cgso = pParam->BSIM3cgso + pParam->BSIM3weffCV - * pParam->BSIM3cgsl; - qgso = (pParam->BSIM3weffCV * pParam->BSIM3cgsl - + pParam->BSIM3cgso) * vgs; - } - } - else - { T0 = vgd + DELTA_1; - T1 = sqrt(T0 * T0 + 4.0 * DELTA_1); - T2 = 0.5 * (T0 - T1); + if (vgs < 0.0) + { T1 = sqrt(1.0 - 4.0 * vgs / pParam->BSIM3ckappa); + cgso = pParam->BSIM3cgso + pParam->BSIM3weffCV + * pParam->BSIM3cgsl / T1; + qgso = pParam->BSIM3cgso * vgs - pParam->BSIM3weffCV * 0.5 + * pParam->BSIM3cgsl * pParam->BSIM3ckappa * (T1 - 1.0); + } + else + { cgso = pParam->BSIM3cgso + pParam->BSIM3weffCV + * pParam->BSIM3cgsl; + qgso = (pParam->BSIM3weffCV * pParam->BSIM3cgsl + + pParam->BSIM3cgso) * vgs; + } + } + else + { T0 = vgd + DELTA_1; + T1 = sqrt(T0 * T0 + 4.0 * DELTA_1); + T2 = 0.5 * (T0 - T1); - T3 = pParam->BSIM3weffCV * pParam->BSIM3cgdl; - T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM3ckappa); - cgdo = pParam->BSIM3cgdo + T3 - T3 * (1.0 - 1.0 / T4) - * (0.5 - 0.5 * T0 / T1); - qgdo = (pParam->BSIM3cgdo + T3) * vgd - T3 * (T2 - + 0.5 * pParam->BSIM3ckappa * (T4 - 1.0)); + T3 = pParam->BSIM3weffCV * pParam->BSIM3cgdl; + T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM3ckappa); + cgdo = pParam->BSIM3cgdo + T3 - T3 * (1.0 - 1.0 / T4) + * (0.5 - 0.5 * T0 / T1); + qgdo = (pParam->BSIM3cgdo + T3) * vgd - T3 * (T2 + + 0.5 * pParam->BSIM3ckappa * (T4 - 1.0)); - T0 = vgs + DELTA_1; - T1 = sqrt(T0 * T0 + 4.0 * DELTA_1); - T2 = 0.5 * (T0 - T1); - T3 = pParam->BSIM3weffCV * pParam->BSIM3cgsl; - T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM3ckappa); - cgso = pParam->BSIM3cgso + T3 - T3 * (1.0 - 1.0 / T4) - * (0.5 - 0.5 * T0 / T1); - qgso = (pParam->BSIM3cgso + T3) * vgs - T3 * (T2 - + 0.5 * pParam->BSIM3ckappa * (T4 - 1.0)); - } + T0 = vgs + DELTA_1; + T1 = sqrt(T0 * T0 + 4.0 * DELTA_1); + T2 = 0.5 * (T0 - T1); + T3 = pParam->BSIM3weffCV * pParam->BSIM3cgsl; + T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM3ckappa); + cgso = pParam->BSIM3cgso + T3 - T3 * (1.0 - 1.0 / T4) + * (0.5 - 0.5 * T0 / T1); + qgso = (pParam->BSIM3cgso + T3) * vgs - T3 * (T2 + + 0.5 * pParam->BSIM3ckappa * (T4 - 1.0)); + } here->BSIM3cgdo = cgdo; here->BSIM3cgso = cgso; @@ -2528,10 +2528,10 @@ line755: qsrc = -(qgate + qbulk + qdrn); ggtg = ggtd = ggtb = ggts = 0.0; - sxpart = 0.6; + sxpart = 0.6; dxpart = 0.4; - ddxpart_dVd = ddxpart_dVg = ddxpart_dVb = ddxpart_dVs = 0.0; - dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0; + ddxpart_dVd = ddxpart_dVg = ddxpart_dVb = ddxpart_dVs = 0.0; + dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0; } else { if (qcheq > 0.0) @@ -2542,7 +2542,7 @@ line755: ggtd = here->BSIM3gtd = T0 * here->BSIM3cqdb; ggts = here->BSIM3gts = T0 * here->BSIM3cqsb; ggtb = here->BSIM3gtb = T0 * here->BSIM3cqbb; - gqdef = ScalingFactor * ag0; + gqdef = ScalingFactor * ag0; gcqgb = here->BSIM3cqgb * ag0; gcqdb = here->BSIM3cqdb * ag0; @@ -2565,44 +2565,44 @@ line755: gcbdb = -here->BSIM3capbd * ag0; gcbsb = -here->BSIM3capbs * ag0; - CoxWL = model->BSIM3cox * pParam->BSIM3weffCV + CoxWL = model->BSIM3cox * pParam->BSIM3weffCV * pParam->BSIM3leffCV; - if (fabs(qcheq) <= 1.0e-5 * CoxWL) - { if (model->BSIM3xpart < 0.5) - { dxpart = 0.4; - } - else if (model->BSIM3xpart > 0.5) - { dxpart = 0.0; - } - else - { dxpart = 0.5; - } - ddxpart_dVd = ddxpart_dVg = ddxpart_dVb - = ddxpart_dVs = 0.0; - } - else - { dxpart = qdrn / qcheq; - Cdd = here->BSIM3cddb; - Csd = -(here->BSIM3cgdb + here->BSIM3cddb - + here->BSIM3cbdb); - ddxpart_dVd = (Cdd - dxpart * (Cdd + Csd)) / qcheq; - Cdg = here->BSIM3cdgb; - Csg = -(here->BSIM3cggb + here->BSIM3cdgb - + here->BSIM3cbgb); - ddxpart_dVg = (Cdg - dxpart * (Cdg + Csg)) / qcheq; + if (fabs(qcheq) <= 1.0e-5 * CoxWL) + { if (model->BSIM3xpart < 0.5) + { dxpart = 0.4; + } + else if (model->BSIM3xpart > 0.5) + { dxpart = 0.0; + } + else + { dxpart = 0.5; + } + ddxpart_dVd = ddxpart_dVg = ddxpart_dVb + = ddxpart_dVs = 0.0; + } + else + { dxpart = qdrn / qcheq; + Cdd = here->BSIM3cddb; + Csd = -(here->BSIM3cgdb + here->BSIM3cddb + + here->BSIM3cbdb); + ddxpart_dVd = (Cdd - dxpart * (Cdd + Csd)) / qcheq; + Cdg = here->BSIM3cdgb; + Csg = -(here->BSIM3cggb + here->BSIM3cdgb + + here->BSIM3cbgb); + ddxpart_dVg = (Cdg - dxpart * (Cdg + Csg)) / qcheq; - Cds = here->BSIM3cdsb; - Css = -(here->BSIM3cgsb + here->BSIM3cdsb - + here->BSIM3cbsb); - ddxpart_dVs = (Cds - dxpart * (Cds + Css)) / qcheq; + Cds = here->BSIM3cdsb; + Css = -(here->BSIM3cgsb + here->BSIM3cdsb + + here->BSIM3cbsb); + ddxpart_dVs = (Cds - dxpart * (Cds + Css)) / qcheq; - ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs); - } - sxpart = 1.0 - dxpart; - dsxpart_dVd = -ddxpart_dVd; - dsxpart_dVg = -ddxpart_dVg; - dsxpart_dVs = -ddxpart_dVs; - dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg + dsxpart_dVs); + ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs); + } + sxpart = 1.0 - dxpart; + dsxpart_dVd = -ddxpart_dVd; + dsxpart_dVg = -ddxpart_dVg; + dsxpart_dVs = -ddxpart_dVs; + dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg + dsxpart_dVs); qgd = qgdo; qgs = qgso; @@ -2644,10 +2644,10 @@ line755: qdrn = -(qgate + qbulk + qsrc); ggtg = ggtd = ggtb = ggts = 0.0; - sxpart = 0.4; + sxpart = 0.4; dxpart = 0.6; - ddxpart_dVd = ddxpart_dVg = ddxpart_dVb = ddxpart_dVs = 0.0; - dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0; + ddxpart_dVd = ddxpart_dVg = ddxpart_dVb = ddxpart_dVs = 0.0; + dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0; } else { if (qcheq > 0.0) @@ -2658,7 +2658,7 @@ line755: ggts = here->BSIM3gtd = T0 * here->BSIM3cqdb; ggtd = here->BSIM3gts = T0 * here->BSIM3cqsb; ggtb = here->BSIM3gtb = T0 * here->BSIM3cqbb; - gqdef = ScalingFactor * ag0; + gqdef = ScalingFactor * ag0; gcqgb = here->BSIM3cqgb * ag0; gcqdb = here->BSIM3cqsb * ag0; @@ -2681,44 +2681,44 @@ line755: gcbdb = -here->BSIM3capbd * ag0; gcbsb = -here->BSIM3capbs * ag0; - CoxWL = model->BSIM3cox * pParam->BSIM3weffCV + CoxWL = model->BSIM3cox * pParam->BSIM3weffCV * pParam->BSIM3leffCV; - if (fabs(qcheq) <= 1.0e-5 * CoxWL) - { if (model->BSIM3xpart < 0.5) - { sxpart = 0.4; - } - else if (model->BSIM3xpart > 0.5) - { sxpart = 0.0; - } - else - { sxpart = 0.5; - } - dsxpart_dVd = dsxpart_dVg = dsxpart_dVb - = dsxpart_dVs = 0.0; - } - else - { sxpart = qdrn / qcheq; - Css = here->BSIM3cddb; - Cds = -(here->BSIM3cgdb + here->BSIM3cddb - + here->BSIM3cbdb); - dsxpart_dVs = (Css - sxpart * (Css + Cds)) / qcheq; - Csg = here->BSIM3cdgb; - Cdg = -(here->BSIM3cggb + here->BSIM3cdgb - + here->BSIM3cbgb); - dsxpart_dVg = (Csg - sxpart * (Csg + Cdg)) / qcheq; + if (fabs(qcheq) <= 1.0e-5 * CoxWL) + { if (model->BSIM3xpart < 0.5) + { sxpart = 0.4; + } + else if (model->BSIM3xpart > 0.5) + { sxpart = 0.0; + } + else + { sxpart = 0.5; + } + dsxpart_dVd = dsxpart_dVg = dsxpart_dVb + = dsxpart_dVs = 0.0; + } + else + { sxpart = qdrn / qcheq; + Css = here->BSIM3cddb; + Cds = -(here->BSIM3cgdb + here->BSIM3cddb + + here->BSIM3cbdb); + dsxpart_dVs = (Css - sxpart * (Css + Cds)) / qcheq; + Csg = here->BSIM3cdgb; + Cdg = -(here->BSIM3cggb + here->BSIM3cdgb + + here->BSIM3cbgb); + dsxpart_dVg = (Csg - sxpart * (Csg + Cdg)) / qcheq; - Csd = here->BSIM3cdsb; - Cdd = -(here->BSIM3cgsb + here->BSIM3cdsb - + here->BSIM3cbsb); - dsxpart_dVd = (Csd - sxpart * (Csd + Cdd)) / qcheq; + Csd = here->BSIM3cdsb; + Cdd = -(here->BSIM3cgsb + here->BSIM3cdsb + + here->BSIM3cbsb); + dsxpart_dVd = (Csd - sxpart * (Csd + Cdd)) / qcheq; - dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg + dsxpart_dVs); - } - dxpart = 1.0 - sxpart; - ddxpart_dVd = -dsxpart_dVd; - ddxpart_dVg = -dsxpart_dVg; - ddxpart_dVs = -dsxpart_dVs; - ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs); + dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg + dsxpart_dVs); + } + dxpart = 1.0 - sxpart; + ddxpart_dVd = -dsxpart_dVd; + ddxpart_dVg = -dsxpart_dVg; + ddxpart_dVs = -dsxpart_dVs; + ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs); qgd = qgdo; qgs = qgso; @@ -2730,7 +2730,7 @@ line755: } } - cqdef = cqcheq = 0.0; + cqdef = cqcheq = 0.0; if (ByPass) goto line860; *(ckt->CKTstate0 + here->BSIM3qg) = qgate; @@ -2797,21 +2797,21 @@ line850: gcggb = gcgdb = gcgsb = 0.0; gcbgb = gcbdb = gcbsb = 0.0; - gqdef = gcqgb = gcqdb = gcqsb = gcqbb = 0.0; + gqdef = gcqgb = gcqdb = gcqsb = gcqbb = 0.0; ggtg = ggtd = ggtb = ggts = 0.0; sxpart = (1.0 - (dxpart = (here->BSIM3mode > 0) ? 0.4 : 0.6)); - ddxpart_dVd = ddxpart_dVg = ddxpart_dVb = ddxpart_dVs = 0.0; - dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0; + ddxpart_dVd = ddxpart_dVg = ddxpart_dVb = ddxpart_dVs = 0.0; + dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0; if (here->BSIM3nqsMod) - here->BSIM3gtau = 16.0 * pParam->BSIM3u0temp * model->BSIM3vtm + here->BSIM3gtau = 16.0 * pParam->BSIM3u0temp * model->BSIM3vtm / pParam->BSIM3leffCV / pParam->BSIM3leffCV - * ScalingFactor; - else + * ScalingFactor; + else here->BSIM3gtau = 0.0; goto line900; - + line860: /* evaluate equivalent charge current */ @@ -2826,9 +2826,9 @@ line860: if (here->BSIM3nqsMod) { T0 = ggtg * vgb - ggtd * vbd - ggts * vbs; ceqqg += T0; - T1 = qdef * here->BSIM3gtau; + T1 = qdef * here->BSIM3gtau; ceqqd -= dxpart * T0 + T1 * (ddxpart_dVg * vgb - ddxpart_dVd - * vbd - ddxpart_dVs * vbs); + * vbd - ddxpart_dVs * vbs); cqdef = *(ckt->CKTstate0 + here->BSIM3cqcdump) - gqdef * qdef; cqcheq = *(ckt->CKTstate0 + here->BSIM3cqcheq) - (gcqgb * vgb - gcqdb * vbd - gcqsb * vbs) + T0; @@ -2856,16 +2856,16 @@ line860: line900: if (here->BSIM3mode >= 0) - { Gm = here->BSIM3gm; + { Gm = here->BSIM3gm; Gmbs = here->BSIM3gmbs; FwdSum = Gm + Gmbs; RevSum = 0.0; cdreq = model->BSIM3type * (cdrain - here->BSIM3gds * vds - - Gm * vgs - Gmbs * vbs); + - Gm * vgs - Gmbs * vbs); - ceqbd = -model->BSIM3type * (here->BSIM3csub - - here->BSIM3gbds * vds - here->BSIM3gbgs * vgs - - here->BSIM3gbbs * vbs); + ceqbd = -model->BSIM3type * (here->BSIM3csub + - here->BSIM3gbds * vds - here->BSIM3gbgs * vgs + - here->BSIM3gbbs * vbs); ceqbs = 0.0; gbbdp = -here->BSIM3gbds; @@ -2881,17 +2881,17 @@ line900: gbspb = 0.0; gbspsp = 0.0; } - else - { Gm = -here->BSIM3gm; + else + { Gm = -here->BSIM3gm; Gmbs = -here->BSIM3gmbs; FwdSum = 0.0; RevSum = -(Gm + Gmbs); cdreq = -model->BSIM3type * (cdrain + here->BSIM3gds * vds + Gm * vgd + Gmbs * vbd); - ceqbs = -model->BSIM3type * (here->BSIM3csub - + here->BSIM3gbds * vds - here->BSIM3gbgs * vgd - - here->BSIM3gbbs * vbd); + ceqbs = -model->BSIM3type * (here->BSIM3csub + + here->BSIM3gbds * vds - here->BSIM3gbgs * vgd + - here->BSIM3gbbs * vbd); ceqbd = 0.0; gbbsp = -here->BSIM3gbds; @@ -2908,26 +2908,26 @@ line900: gbspdp = -(gbspg + gbspsp + gbspb); } - if (model->BSIM3type > 0) - { ceqbs += (here->BSIM3cbs - here->BSIM3gbs * vbs); + if (model->BSIM3type > 0) + { ceqbs += (here->BSIM3cbs - here->BSIM3gbs * vbs); ceqbd += (here->BSIM3cbd - here->BSIM3gbd * vbd); - /* + /* ceqqg = ceqqg; ceqqb = ceqqb; ceqqd = ceqqd; cqdef = cqdef; cqcheq = cqcheq; - */ - } - else - { ceqbs -= (here->BSIM3cbs - here->BSIM3gbs * vbs); + */ + } + else + { ceqbs -= (here->BSIM3cbs - here->BSIM3gbs * vbs); ceqbd -= (here->BSIM3cbd - here->BSIM3gbd * vbd); ceqqg = -ceqqg; ceqqb = -ceqqb; ceqqd = -ceqqd; cqdef = -cqdef; cqcheq = -cqcheq; - } + } m = here->BSIM3m; #ifdef USE_OMP @@ -2935,7 +2935,7 @@ line900: here->BSIM3rhsB = m * (ceqbs + ceqbd + ceqqb); here->BSIM3rhsD = m * (ceqbd - cdreq - ceqqd); here->BSIM3rhsS = m * (cdreq + ceqbs + ceqqg - + ceqqb + ceqqd); + + ceqqb + ceqqd); if (here->BSIM3nqsMod) here->BSIM3rhsQ = m * (cqcheq - cqdef); #else @@ -2943,7 +2943,7 @@ line900: (*(ckt->CKTrhs + here->BSIM3bNode) -= m * (ceqbs + ceqbd + ceqqb)); (*(ckt->CKTrhs + here->BSIM3dNodePrime) += m * (ceqbd - cdreq - ceqqd)); (*(ckt->CKTrhs + here->BSIM3sNodePrime) += m * (cdreq + ceqbs + ceqqg - + ceqqb + ceqqd)); + + ceqqb + ceqqd)); if (here->BSIM3nqsMod) *(ckt->CKTrhs + here->BSIM3qNode) += m * (cqcheq - cqdef); #endif @@ -2951,7 +2951,7 @@ line900: * load y matrix */ - T1 = qdef * here->BSIM3gtau; + T1 = qdef * here->BSIM3gtau; #ifdef USE_OMP here->BSIM3DdPt = m * here->BSIM3drainConductance; here->BSIM3GgPt = m * (gcggb - ggtg); @@ -2960,12 +2960,12 @@ line900: - gcbgb - gcbdb - gcbsb - here->BSIM3gbbs); here->BSIM3DPdpPt = m * (here->BSIM3drainConductance + here->BSIM3gds + here->BSIM3gbd - + RevSum + gcddb + dxpart * ggtd - + T1 * ddxpart_dVd + gbdpdp); + + RevSum + gcddb + dxpart * ggtd + + T1 * ddxpart_dVd + gbdpdp); here->BSIM3SPspPt = m * (here->BSIM3sourceConductance + here->BSIM3gds + here->BSIM3gbs + FwdSum + gcssb + sxpart * ggts - + T1 * dsxpart_dVs + gbspsp); + + T1 * dsxpart_dVs + gbspsp); here->BSIM3DdpPt = m * here->BSIM3drainConductance; here->BSIM3GbPt = m * (gcggb + gcgdb + gcgsb + ggtb); here->BSIM3GdpPt = m * (gcgdb - ggtd); @@ -2975,19 +2975,19 @@ line900: here->BSIM3BdpPt = m * (gcbdb - here->BSIM3gbd + gbbdp); here->BSIM3BspPt = m * (gcbsb - here->BSIM3gbs + gbbsp); here->BSIM3DPdPt = m * here->BSIM3drainConductance; - here->BSIM3DPgPt = m * (Gm + gcdgb + dxpart * ggtg - + T1 * ddxpart_dVg + gbdpg); + here->BSIM3DPgPt = m * (Gm + gcdgb + dxpart * ggtg + + T1 * ddxpart_dVg + gbdpg); here->BSIM3DPbPt = m * (here->BSIM3gbd - Gmbs + gcdgb + gcddb + gcdsb - dxpart * ggtb - - T1 * ddxpart_dVb - gbdpb); + - T1 * ddxpart_dVb - gbdpb); here->BSIM3DPspPt = m * (here->BSIM3gds + FwdSum - gcdsb - - dxpart * ggts - T1 * ddxpart_dVs - gbdpsp); - here->BSIM3SPgPt = m * (gcsgb - Gm + sxpart * ggtg - + T1 * dsxpart_dVg + gbspg); + - dxpart * ggts - T1 * ddxpart_dVs - gbdpsp); + here->BSIM3SPgPt = m * (gcsgb - Gm + sxpart * ggtg + + T1 * dsxpart_dVg + gbspg); here->BSIM3SPsPt = m * here->BSIM3sourceConductance; here->BSIM3SPbPt = m * (here->BSIM3gbs + Gmbs + gcsgb + gcsdb + gcssb - sxpart * ggtb - - T1 * dsxpart_dVb - gbspb); + - T1 * dsxpart_dVb - gbspb); here->BSIM3SPdpPt = m * (here->BSIM3gds + RevSum - gcsdb - sxpart * ggtd - T1 * dsxpart_dVd - gbspdp); @@ -3011,12 +3011,12 @@ line900: - gcbgb - gcbdb - gcbsb - here->BSIM3gbbs)); (*(here->BSIM3DPdpPtr) += m * (here->BSIM3drainConductance + here->BSIM3gds + here->BSIM3gbd - + RevSum + gcddb + dxpart * ggtd - + T1 * ddxpart_dVd + gbdpdp)); + + RevSum + gcddb + dxpart * ggtd + + T1 * ddxpart_dVd + gbdpdp)); (*(here->BSIM3SPspPtr) += m * (here->BSIM3sourceConductance + here->BSIM3gds + here->BSIM3gbs + FwdSum + gcssb + sxpart * ggts - + T1 * dsxpart_dVs + gbspsp)); + + T1 * dsxpart_dVs + gbspsp)); (*(here->BSIM3DdpPtr) -= m * here->BSIM3drainConductance); (*(here->BSIM3GbPtr) -= m * (gcggb + gcgdb + gcgsb + ggtb)); (*(here->BSIM3GdpPtr) += m * (gcgdb - ggtd)); @@ -3026,19 +3026,19 @@ line900: (*(here->BSIM3BdpPtr) += m * (gcbdb - here->BSIM3gbd + gbbdp)); (*(here->BSIM3BspPtr) += m * (gcbsb - here->BSIM3gbs + gbbsp)); (*(here->BSIM3DPdPtr) -= m * here->BSIM3drainConductance); - (*(here->BSIM3DPgPtr) += m * (Gm + gcdgb + dxpart * ggtg - + T1 * ddxpart_dVg + gbdpg)); + (*(here->BSIM3DPgPtr) += m * (Gm + gcdgb + dxpart * ggtg + + T1 * ddxpart_dVg + gbdpg)); (*(here->BSIM3DPbPtr) -= m * (here->BSIM3gbd - Gmbs + gcdgb + gcddb + gcdsb - dxpart * ggtb - - T1 * ddxpart_dVb - gbdpb)); + - T1 * ddxpart_dVb - gbdpb)); (*(here->BSIM3DPspPtr) -= m * (here->BSIM3gds + FwdSum - gcdsb - - dxpart * ggts - T1 * ddxpart_dVs - gbdpsp)); - (*(here->BSIM3SPgPtr) += m * (gcsgb - Gm + sxpart * ggtg - + T1 * dsxpart_dVg + gbspg)); + - dxpart * ggts - T1 * ddxpart_dVs - gbdpsp)); + (*(here->BSIM3SPgPtr) += m * (gcsgb - Gm + sxpart * ggtg + + T1 * dsxpart_dVg + gbspg)); (*(here->BSIM3SPsPtr) -= m * here->BSIM3sourceConductance); (*(here->BSIM3SPbPtr) -= m * (here->BSIM3gbs + Gmbs + gcsgb + gcsdb + gcssb - sxpart * ggtb - - T1 * dsxpart_dVb - gbspb)); + - T1 * dsxpart_dVb - gbspb)); (*(here->BSIM3SPdpPtr) -= m * (here->BSIM3gds + RevSum - gcsdb - sxpart * ggtd - T1 * dsxpart_dVd - gbspdp)); diff --git a/src/spicelib/devices/bsim3/b3par.c b/src/spicelib/devices/bsim3/b3par.c index 555376443..7ca78cd0e 100644 --- a/src/spicelib/devices/bsim3/b3par.c +++ b/src/spicelib/devices/bsim3/b3par.c @@ -31,7 +31,7 @@ IFvalue *select) if (!cp_getvar("scale", CP_REAL, &scale)) scale = 1; - switch(param) + switch(param) { case BSIM3_W: here->BSIM3w = value->rValue*scale; here->BSIM3wGiven = TRUE; @@ -40,10 +40,10 @@ IFvalue *select) here->BSIM3l = value->rValue*scale; here->BSIM3lGiven = TRUE; break; - case BSIM3_M: - here->BSIM3m = value->rValue; - here->BSIM3mGiven = TRUE; - break; + case BSIM3_M: + here->BSIM3m = value->rValue; + here->BSIM3mGiven = TRUE; + break; case BSIM3_AS: here->BSIM3sourceArea = value->rValue*scale*scale; here->BSIM3sourceAreaGiven = TRUE; diff --git a/src/spicelib/devices/bsim3/b3set.c b/src/spicelib/devices/bsim3/b3set.c index 857e85395..44d5e5ce3 100644 --- a/src/spicelib/devices/bsim3/b3set.c +++ b/src/spicelib/devices/bsim3/b3set.c @@ -906,7 +906,7 @@ BSIM3instance **InstArray; here->BSIM3m = 1; /* process drain series resistance */ - if ((model->BSIM3sheetResistance > 0.0) && + if ((model->BSIM3sheetResistance > 0.0) && (here->BSIM3drainSquares > 0.0 )) { if(here->BSIM3dNodePrime == 0) { @@ -928,7 +928,7 @@ BSIM3instance **InstArray; } /* process source series resistance */ - if ((model->BSIM3sheetResistance > 0.0) && + if ((model->BSIM3sheetResistance > 0.0) && (here->BSIM3sourceSquares > 0.0 )) { if(here->BSIM3sNodePrime == 0) { diff --git a/src/spicelib/devices/bsim3/b3temp.c b/src/spicelib/devices/bsim3/b3temp.c index 9ac4d396b..62783d74c 100644 --- a/src/spicelib/devices/bsim3/b3temp.c +++ b/src/spicelib/devices/bsim3/b3temp.c @@ -3,7 +3,7 @@ /********** * Copyright 2004 Regents of the University of California. All rights reserved. * File: b3temp.c of BSIM3v3.3.0 - * Author: 1995 Min-Chie Jeng and Mansun Chan. + * Author: 1995 Min-Chie Jeng and Mansun Chan. * Author: 1997-1999 Weidong Liu. * Author: 2001 Xuemei Xi **********/ @@ -45,135 +45,135 @@ int Size_Not_Found; /* loop through all the BSIM3 device models */ for (; model != NULL; model = model->BSIM3nextModel) { Temp = ckt->CKTtemp; - if (model->BSIM3bulkJctPotential < 0.1) - { model->BSIM3bulkJctPotential = 0.1; - fprintf(stderr, "Given pb is less than 0.1. Pb is set to 0.1.\n"); - } + if (model->BSIM3bulkJctPotential < 0.1) + { model->BSIM3bulkJctPotential = 0.1; + fprintf(stderr, "Given pb is less than 0.1. Pb is set to 0.1.\n"); + } if (model->BSIM3sidewallJctPotential < 0.1) - { model->BSIM3sidewallJctPotential = 0.1; - fprintf(stderr, "Given pbsw is less than 0.1. Pbsw is set to 0.1.\n"); - } + { model->BSIM3sidewallJctPotential = 0.1; + fprintf(stderr, "Given pbsw is less than 0.1. Pbsw is set to 0.1.\n"); + } if (model->BSIM3GatesidewallJctPotential < 0.1) - { model->BSIM3GatesidewallJctPotential = 0.1; - fprintf(stderr, "Given pbswg is less than 0.1. Pbswg is set to 0.1.\n"); - } + { model->BSIM3GatesidewallJctPotential = 0.1; + fprintf(stderr, "Given pbswg is less than 0.1. Pbswg is set to 0.1.\n"); + } model->pSizeDependParamKnot = NULL; - pLastKnot = NULL; + pLastKnot = NULL; - Tnom = model->BSIM3tnom; - TRatio = Temp / Tnom; + Tnom = model->BSIM3tnom; + TRatio = Temp / Tnom; - model->BSIM3vcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14)); + model->BSIM3vcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14)); model->BSIM3factor1 = sqrt(EPSSI / EPSOX * model->BSIM3tox); Vtm0 = KboQ * Tnom; Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0); - ni = 1.45e10 * (Tnom / 300.15) * sqrt(Tnom / 300.15) + ni = 1.45e10 * (Tnom / 300.15) * sqrt(Tnom / 300.15) * exp(21.5565981 - Eg0 / (2.0 * Vtm0)); model->BSIM3vtm = KboQ * Temp; Eg = 1.16 - 7.02e-4 * Temp * Temp / (Temp + 1108.0); - if (Temp != Tnom) - { T0 = Eg0 / Vtm0 - Eg / model->BSIM3vtm + model->BSIM3jctTempExponent - * log(Temp / Tnom); - T1 = exp(T0 / model->BSIM3jctEmissionCoeff); - model->BSIM3jctTempSatCurDensity = model->BSIM3jctSatCurDensity - * T1; - model->BSIM3jctSidewallTempSatCurDensity - = model->BSIM3jctSidewallSatCurDensity * T1; - } - else - { model->BSIM3jctTempSatCurDensity = model->BSIM3jctSatCurDensity; - model->BSIM3jctSidewallTempSatCurDensity - = model->BSIM3jctSidewallSatCurDensity; - } + if (Temp != Tnom) + { T0 = Eg0 / Vtm0 - Eg / model->BSIM3vtm + model->BSIM3jctTempExponent + * log(Temp / Tnom); + T1 = exp(T0 / model->BSIM3jctEmissionCoeff); + model->BSIM3jctTempSatCurDensity = model->BSIM3jctSatCurDensity + * T1; + model->BSIM3jctSidewallTempSatCurDensity + = model->BSIM3jctSidewallSatCurDensity * T1; + } + else + { model->BSIM3jctTempSatCurDensity = model->BSIM3jctSatCurDensity; + model->BSIM3jctSidewallTempSatCurDensity + = model->BSIM3jctSidewallSatCurDensity; + } - if (model->BSIM3jctTempSatCurDensity < 0.0) - model->BSIM3jctTempSatCurDensity = 0.0; - if (model->BSIM3jctSidewallTempSatCurDensity < 0.0) - model->BSIM3jctSidewallTempSatCurDensity = 0.0; + if (model->BSIM3jctTempSatCurDensity < 0.0) + model->BSIM3jctTempSatCurDensity = 0.0; + if (model->BSIM3jctSidewallTempSatCurDensity < 0.0) + model->BSIM3jctSidewallTempSatCurDensity = 0.0; - /* Temperature dependence of D/B and S/B diode capacitance begins */ - delTemp = ckt->CKTtemp - model->BSIM3tnom; - T0 = model->BSIM3tcj * delTemp; - if (T0 >= -1.0) - { model->BSIM3unitAreaTempJctCap = model->BSIM3unitAreaJctCap * (1.0 + T0); - } - else if (model->BSIM3unitAreaJctCap > 0.0) - { model->BSIM3unitAreaTempJctCap = 0.0; - fprintf(stderr, "Temperature effect has caused cj to be negative. Cj is clamped to zero.\n"); - } + /* Temperature dependence of D/B and S/B diode capacitance begins */ + delTemp = ckt->CKTtemp - model->BSIM3tnom; + T0 = model->BSIM3tcj * delTemp; + if (T0 >= -1.0) + { model->BSIM3unitAreaTempJctCap = model->BSIM3unitAreaJctCap * (1.0 + T0); + } + else if (model->BSIM3unitAreaJctCap > 0.0) + { model->BSIM3unitAreaTempJctCap = 0.0; + fprintf(stderr, "Temperature effect has caused cj to be negative. Cj is clamped to zero.\n"); + } T0 = model->BSIM3tcjsw * delTemp; - if (T0 >= -1.0) - { model->BSIM3unitLengthSidewallTempJctCap = model->BSIM3unitLengthSidewallJctCap * (1.0 + T0); - } - else if (model->BSIM3unitLengthSidewallJctCap > 0.0) - { model->BSIM3unitLengthSidewallTempJctCap = 0.0; - fprintf(stderr, "Temperature effect has caused cjsw to be negative. Cjsw is clamped to zero.\n"); - } + if (T0 >= -1.0) + { model->BSIM3unitLengthSidewallTempJctCap = model->BSIM3unitLengthSidewallJctCap * (1.0 + T0); + } + else if (model->BSIM3unitLengthSidewallJctCap > 0.0) + { model->BSIM3unitLengthSidewallTempJctCap = 0.0; + fprintf(stderr, "Temperature effect has caused cjsw to be negative. Cjsw is clamped to zero.\n"); + } T0 = model->BSIM3tcjswg * delTemp; - if (T0 >= -1.0) - { model->BSIM3unitLengthGateSidewallTempJctCap = model->BSIM3unitLengthGateSidewallJctCap * (1.0 + T0); - } - else if (model->BSIM3unitLengthGateSidewallJctCap > 0.0) - { model->BSIM3unitLengthGateSidewallTempJctCap = 0.0; - fprintf(stderr, "Temperature effect has caused cjswg to be negative. Cjswg is clamped to zero.\n"); - } + if (T0 >= -1.0) + { model->BSIM3unitLengthGateSidewallTempJctCap = model->BSIM3unitLengthGateSidewallJctCap * (1.0 + T0); + } + else if (model->BSIM3unitLengthGateSidewallJctCap > 0.0) + { model->BSIM3unitLengthGateSidewallTempJctCap = 0.0; + fprintf(stderr, "Temperature effect has caused cjswg to be negative. Cjswg is clamped to zero.\n"); + } model->BSIM3PhiB = model->BSIM3bulkJctPotential - - model->BSIM3tpb * delTemp; + - model->BSIM3tpb * delTemp; if (model->BSIM3PhiB < 0.01) - { model->BSIM3PhiB = 0.01; - fprintf(stderr, "Temperature effect has caused pb to be less than 0.01. Pb is clamped to 0.01.\n"); - } + { model->BSIM3PhiB = 0.01; + fprintf(stderr, "Temperature effect has caused pb to be less than 0.01. Pb is clamped to 0.01.\n"); + } model->BSIM3PhiBSW = model->BSIM3sidewallJctPotential - model->BSIM3tpbsw * delTemp; if (model->BSIM3PhiBSW <= 0.01) - { model->BSIM3PhiBSW = 0.01; - fprintf(stderr, "Temperature effect has caused pbsw to be less than 0.01. Pbsw is clamped to 0.01.\n"); - } - model->BSIM3PhiBSWG = model->BSIM3GatesidewallJctPotential + { model->BSIM3PhiBSW = 0.01; + fprintf(stderr, "Temperature effect has caused pbsw to be less than 0.01. Pbsw is clamped to 0.01.\n"); + } + model->BSIM3PhiBSWG = model->BSIM3GatesidewallJctPotential - model->BSIM3tpbswg * delTemp; if (model->BSIM3PhiBSWG <= 0.01) - { model->BSIM3PhiBSWG = 0.01; - fprintf(stderr, "Temperature effect has caused pbswg to be less than 0.01. Pbswg is clamped to 0.01.\n"); - } + { model->BSIM3PhiBSWG = 0.01; + fprintf(stderr, "Temperature effect has caused pbswg to be less than 0.01. Pbswg is clamped to 0.01.\n"); + } /* End of junction capacitance */ /* loop through all the instances of the model */ - /* MCJ: Length and Width not initialized */ + /* MCJ: Length and Width not initialized */ for (here = model->BSIM3instances; here != NULL; - here = here->BSIM3nextInstance) - { + here = here->BSIM3nextInstance) + { pSizeDependParamKnot = model->pSizeDependParamKnot; - Size_Not_Found = 1; - while ((pSizeDependParamKnot != NULL) && Size_Not_Found) - { if ((here->BSIM3l == pSizeDependParamKnot->Length) - && (here->BSIM3w == pSizeDependParamKnot->Width)) + Size_Not_Found = 1; + while ((pSizeDependParamKnot != NULL) && Size_Not_Found) + { if ((here->BSIM3l == pSizeDependParamKnot->Length) + && (here->BSIM3w == pSizeDependParamKnot->Width)) { Size_Not_Found = 0; - here->pParam = pSizeDependParamKnot; - pParam = here->pParam; /*bug-fix */ - } - else - { pLastKnot = pSizeDependParamKnot; - pSizeDependParamKnot = pSizeDependParamKnot->pNext; - } + here->pParam = pSizeDependParamKnot; + pParam = here->pParam; /*bug-fix */ + } + else + { pLastKnot = pSizeDependParamKnot; + pSizeDependParamKnot = pSizeDependParamKnot->pNext; + } } - if (Size_Not_Found) - { pParam = TMALLOC(struct bsim3SizeDependParam, 1); + if (Size_Not_Found) + { pParam = TMALLOC(struct bsim3SizeDependParam, 1); if (pLastKnot == NULL) - model->pSizeDependParamKnot = pParam; + model->pSizeDependParamKnot = pParam; else - pLastKnot->pNext = pParam; + pLastKnot->pNext = pParam; pParam->pNext = NULL; here->pParam = pParam; - Ldrn = here->BSIM3l; - Wdrn = here->BSIM3w; + Ldrn = here->BSIM3l; + Wdrn = here->BSIM3w; pParam->Length = Ldrn; pParam->Width = Wdrn; - + T0 = pow(Ldrn, model->BSIM3Lln); T1 = pow(Wdrn, model->BSIM3Lwn); tmp1 = model->BSIM3Ll / T0 + model->BSIM3Lw / T1 @@ -194,7 +194,7 @@ int Size_Not_Found; pParam->BSIM3leff = here->BSIM3l - 2.0 * pParam->BSIM3dl; if (pParam->BSIM3leff <= 0.0) - { IFuid namarray[2]; + { IFuid namarray[2]; namarray[0] = model->BSIM3modName; namarray[1] = here->BSIM3name; SPfrontEnd->IFerror (ERR_FATAL, @@ -205,7 +205,7 @@ int Size_Not_Found; pParam->BSIM3weff = here->BSIM3w - 2.0 * pParam->BSIM3dw; if (pParam->BSIM3weff <= 0.0) - { IFuid namarray[2]; + { IFuid namarray[2]; namarray[0] = model->BSIM3modName; namarray[1] = here->BSIM3name; SPfrontEnd->IFerror (ERR_FATAL, @@ -216,7 +216,7 @@ int Size_Not_Found; pParam->BSIM3leffCV = here->BSIM3l - 2.0 * pParam->BSIM3dlc; if (pParam->BSIM3leffCV <= 0.0) - { IFuid namarray[2]; + { IFuid namarray[2]; namarray[0] = model->BSIM3modName; namarray[1] = here->BSIM3name; SPfrontEnd->IFerror (ERR_FATAL, @@ -227,7 +227,7 @@ int Size_Not_Found; pParam->BSIM3weffCV = here->BSIM3w - 2.0 * pParam->BSIM3dwc; if (pParam->BSIM3weffCV <= 0.0) - { IFuid namarray[2]; + { IFuid namarray[2]; namarray[0] = model->BSIM3modName; namarray[1] = here->BSIM3name; SPfrontEnd->IFerror (ERR_FATAL, @@ -237,339 +237,339 @@ int Size_Not_Found; } - if (model->BSIM3binUnit == 1) - { Inv_L = 1.0e-6 / pParam->BSIM3leff; - Inv_W = 1.0e-6 / pParam->BSIM3weff; - Inv_LW = 1.0e-12 / (pParam->BSIM3leff - * pParam->BSIM3weff); - } - else - { Inv_L = 1.0 / pParam->BSIM3leff; - Inv_W = 1.0 / pParam->BSIM3weff; - Inv_LW = 1.0 / (pParam->BSIM3leff - * pParam->BSIM3weff); - } - pParam->BSIM3cdsc = model->BSIM3cdsc - + model->BSIM3lcdsc * Inv_L - + model->BSIM3wcdsc * Inv_W - + model->BSIM3pcdsc * Inv_LW; - pParam->BSIM3cdscb = model->BSIM3cdscb - + model->BSIM3lcdscb * Inv_L - + model->BSIM3wcdscb * Inv_W - + model->BSIM3pcdscb * Inv_LW; - - pParam->BSIM3cdscd = model->BSIM3cdscd - + model->BSIM3lcdscd * Inv_L - + model->BSIM3wcdscd * Inv_W - + model->BSIM3pcdscd * Inv_LW; - - pParam->BSIM3cit = model->BSIM3cit - + model->BSIM3lcit * Inv_L - + model->BSIM3wcit * Inv_W - + model->BSIM3pcit * Inv_LW; - pParam->BSIM3nfactor = model->BSIM3nfactor - + model->BSIM3lnfactor * Inv_L - + model->BSIM3wnfactor * Inv_W - + model->BSIM3pnfactor * Inv_LW; - pParam->BSIM3xj = model->BSIM3xj - + model->BSIM3lxj * Inv_L - + model->BSIM3wxj * Inv_W - + model->BSIM3pxj * Inv_LW; - pParam->BSIM3vsat = model->BSIM3vsat - + model->BSIM3lvsat * Inv_L - + model->BSIM3wvsat * Inv_W - + model->BSIM3pvsat * Inv_LW; - pParam->BSIM3at = model->BSIM3at - + model->BSIM3lat * Inv_L - + model->BSIM3wat * Inv_W - + model->BSIM3pat * Inv_LW; - pParam->BSIM3a0 = model->BSIM3a0 - + model->BSIM3la0 * Inv_L - + model->BSIM3wa0 * Inv_W - + model->BSIM3pa0 * Inv_LW; - - pParam->BSIM3ags = model->BSIM3ags - + model->BSIM3lags * Inv_L - + model->BSIM3wags * Inv_W - + model->BSIM3pags * Inv_LW; - - pParam->BSIM3a1 = model->BSIM3a1 - + model->BSIM3la1 * Inv_L - + model->BSIM3wa1 * Inv_W - + model->BSIM3pa1 * Inv_LW; - pParam->BSIM3a2 = model->BSIM3a2 - + model->BSIM3la2 * Inv_L - + model->BSIM3wa2 * Inv_W - + model->BSIM3pa2 * Inv_LW; - pParam->BSIM3keta = model->BSIM3keta - + model->BSIM3lketa * Inv_L - + model->BSIM3wketa * Inv_W - + model->BSIM3pketa * Inv_LW; - pParam->BSIM3nsub = model->BSIM3nsub - + model->BSIM3lnsub * Inv_L - + model->BSIM3wnsub * Inv_W - + model->BSIM3pnsub * Inv_LW; - pParam->BSIM3npeak = model->BSIM3npeak - + model->BSIM3lnpeak * Inv_L - + model->BSIM3wnpeak * Inv_W - + model->BSIM3pnpeak * Inv_LW; - pParam->BSIM3ngate = model->BSIM3ngate - + model->BSIM3lngate * Inv_L - + model->BSIM3wngate * Inv_W - + model->BSIM3pngate * Inv_LW; - pParam->BSIM3gamma1 = model->BSIM3gamma1 - + model->BSIM3lgamma1 * Inv_L - + model->BSIM3wgamma1 * Inv_W - + model->BSIM3pgamma1 * Inv_LW; - pParam->BSIM3gamma2 = model->BSIM3gamma2 - + model->BSIM3lgamma2 * Inv_L - + model->BSIM3wgamma2 * Inv_W - + model->BSIM3pgamma2 * Inv_LW; - pParam->BSIM3vbx = model->BSIM3vbx - + model->BSIM3lvbx * Inv_L - + model->BSIM3wvbx * Inv_W - + model->BSIM3pvbx * Inv_LW; - pParam->BSIM3vbm = model->BSIM3vbm - + model->BSIM3lvbm * Inv_L - + model->BSIM3wvbm * Inv_W - + model->BSIM3pvbm * Inv_LW; - pParam->BSIM3xt = model->BSIM3xt - + model->BSIM3lxt * Inv_L - + model->BSIM3wxt * Inv_W - + model->BSIM3pxt * Inv_LW; + if (model->BSIM3binUnit == 1) + { Inv_L = 1.0e-6 / pParam->BSIM3leff; + Inv_W = 1.0e-6 / pParam->BSIM3weff; + Inv_LW = 1.0e-12 / (pParam->BSIM3leff + * pParam->BSIM3weff); + } + else + { Inv_L = 1.0 / pParam->BSIM3leff; + Inv_W = 1.0 / pParam->BSIM3weff; + Inv_LW = 1.0 / (pParam->BSIM3leff + * pParam->BSIM3weff); + } + pParam->BSIM3cdsc = model->BSIM3cdsc + + model->BSIM3lcdsc * Inv_L + + model->BSIM3wcdsc * Inv_W + + model->BSIM3pcdsc * Inv_LW; + pParam->BSIM3cdscb = model->BSIM3cdscb + + model->BSIM3lcdscb * Inv_L + + model->BSIM3wcdscb * Inv_W + + model->BSIM3pcdscb * Inv_LW; + + pParam->BSIM3cdscd = model->BSIM3cdscd + + model->BSIM3lcdscd * Inv_L + + model->BSIM3wcdscd * Inv_W + + model->BSIM3pcdscd * Inv_LW; + + pParam->BSIM3cit = model->BSIM3cit + + model->BSIM3lcit * Inv_L + + model->BSIM3wcit * Inv_W + + model->BSIM3pcit * Inv_LW; + pParam->BSIM3nfactor = model->BSIM3nfactor + + model->BSIM3lnfactor * Inv_L + + model->BSIM3wnfactor * Inv_W + + model->BSIM3pnfactor * Inv_LW; + pParam->BSIM3xj = model->BSIM3xj + + model->BSIM3lxj * Inv_L + + model->BSIM3wxj * Inv_W + + model->BSIM3pxj * Inv_LW; + pParam->BSIM3vsat = model->BSIM3vsat + + model->BSIM3lvsat * Inv_L + + model->BSIM3wvsat * Inv_W + + model->BSIM3pvsat * Inv_LW; + pParam->BSIM3at = model->BSIM3at + + model->BSIM3lat * Inv_L + + model->BSIM3wat * Inv_W + + model->BSIM3pat * Inv_LW; + pParam->BSIM3a0 = model->BSIM3a0 + + model->BSIM3la0 * Inv_L + + model->BSIM3wa0 * Inv_W + + model->BSIM3pa0 * Inv_LW; + + pParam->BSIM3ags = model->BSIM3ags + + model->BSIM3lags * Inv_L + + model->BSIM3wags * Inv_W + + model->BSIM3pags * Inv_LW; + + pParam->BSIM3a1 = model->BSIM3a1 + + model->BSIM3la1 * Inv_L + + model->BSIM3wa1 * Inv_W + + model->BSIM3pa1 * Inv_LW; + pParam->BSIM3a2 = model->BSIM3a2 + + model->BSIM3la2 * Inv_L + + model->BSIM3wa2 * Inv_W + + model->BSIM3pa2 * Inv_LW; + pParam->BSIM3keta = model->BSIM3keta + + model->BSIM3lketa * Inv_L + + model->BSIM3wketa * Inv_W + + model->BSIM3pketa * Inv_LW; + pParam->BSIM3nsub = model->BSIM3nsub + + model->BSIM3lnsub * Inv_L + + model->BSIM3wnsub * Inv_W + + model->BSIM3pnsub * Inv_LW; + pParam->BSIM3npeak = model->BSIM3npeak + + model->BSIM3lnpeak * Inv_L + + model->BSIM3wnpeak * Inv_W + + model->BSIM3pnpeak * Inv_LW; + pParam->BSIM3ngate = model->BSIM3ngate + + model->BSIM3lngate * Inv_L + + model->BSIM3wngate * Inv_W + + model->BSIM3pngate * Inv_LW; + pParam->BSIM3gamma1 = model->BSIM3gamma1 + + model->BSIM3lgamma1 * Inv_L + + model->BSIM3wgamma1 * Inv_W + + model->BSIM3pgamma1 * Inv_LW; + pParam->BSIM3gamma2 = model->BSIM3gamma2 + + model->BSIM3lgamma2 * Inv_L + + model->BSIM3wgamma2 * Inv_W + + model->BSIM3pgamma2 * Inv_LW; + pParam->BSIM3vbx = model->BSIM3vbx + + model->BSIM3lvbx * Inv_L + + model->BSIM3wvbx * Inv_W + + model->BSIM3pvbx * Inv_LW; + pParam->BSIM3vbm = model->BSIM3vbm + + model->BSIM3lvbm * Inv_L + + model->BSIM3wvbm * Inv_W + + model->BSIM3pvbm * Inv_LW; + pParam->BSIM3xt = model->BSIM3xt + + model->BSIM3lxt * Inv_L + + model->BSIM3wxt * Inv_W + + model->BSIM3pxt * Inv_LW; pParam->BSIM3vfb = model->BSIM3vfb + model->BSIM3lvfb * Inv_L + model->BSIM3wvfb * Inv_W + model->BSIM3pvfb * Inv_LW; - pParam->BSIM3k1 = model->BSIM3k1 - + model->BSIM3lk1 * Inv_L - + model->BSIM3wk1 * Inv_W - + model->BSIM3pk1 * Inv_LW; - pParam->BSIM3kt1 = model->BSIM3kt1 - + model->BSIM3lkt1 * Inv_L - + model->BSIM3wkt1 * Inv_W - + model->BSIM3pkt1 * Inv_LW; - pParam->BSIM3kt1l = model->BSIM3kt1l - + model->BSIM3lkt1l * Inv_L - + model->BSIM3wkt1l * Inv_W - + model->BSIM3pkt1l * Inv_LW; - pParam->BSIM3k2 = model->BSIM3k2 - + model->BSIM3lk2 * Inv_L - + model->BSIM3wk2 * Inv_W - + model->BSIM3pk2 * Inv_LW; - pParam->BSIM3kt2 = model->BSIM3kt2 - + model->BSIM3lkt2 * Inv_L - + model->BSIM3wkt2 * Inv_W - + model->BSIM3pkt2 * Inv_LW; - pParam->BSIM3k3 = model->BSIM3k3 - + model->BSIM3lk3 * Inv_L - + model->BSIM3wk3 * Inv_W - + model->BSIM3pk3 * Inv_LW; - pParam->BSIM3k3b = model->BSIM3k3b - + model->BSIM3lk3b * Inv_L - + model->BSIM3wk3b * Inv_W - + model->BSIM3pk3b * Inv_LW; - pParam->BSIM3w0 = model->BSIM3w0 - + model->BSIM3lw0 * Inv_L - + model->BSIM3ww0 * Inv_W - + model->BSIM3pw0 * Inv_LW; - pParam->BSIM3nlx = model->BSIM3nlx - + model->BSIM3lnlx * Inv_L - + model->BSIM3wnlx * Inv_W - + model->BSIM3pnlx * Inv_LW; - pParam->BSIM3dvt0 = model->BSIM3dvt0 - + model->BSIM3ldvt0 * Inv_L - + model->BSIM3wdvt0 * Inv_W - + model->BSIM3pdvt0 * Inv_LW; - pParam->BSIM3dvt1 = model->BSIM3dvt1 - + model->BSIM3ldvt1 * Inv_L - + model->BSIM3wdvt1 * Inv_W - + model->BSIM3pdvt1 * Inv_LW; - pParam->BSIM3dvt2 = model->BSIM3dvt2 - + model->BSIM3ldvt2 * Inv_L - + model->BSIM3wdvt2 * Inv_W - + model->BSIM3pdvt2 * Inv_LW; - pParam->BSIM3dvt0w = model->BSIM3dvt0w - + model->BSIM3ldvt0w * Inv_L - + model->BSIM3wdvt0w * Inv_W - + model->BSIM3pdvt0w * Inv_LW; - pParam->BSIM3dvt1w = model->BSIM3dvt1w - + model->BSIM3ldvt1w * Inv_L - + model->BSIM3wdvt1w * Inv_W - + model->BSIM3pdvt1w * Inv_LW; - pParam->BSIM3dvt2w = model->BSIM3dvt2w - + model->BSIM3ldvt2w * Inv_L - + model->BSIM3wdvt2w * Inv_W - + model->BSIM3pdvt2w * Inv_LW; - pParam->BSIM3drout = model->BSIM3drout - + model->BSIM3ldrout * Inv_L - + model->BSIM3wdrout * Inv_W - + model->BSIM3pdrout * Inv_LW; - pParam->BSIM3dsub = model->BSIM3dsub - + model->BSIM3ldsub * Inv_L - + model->BSIM3wdsub * Inv_W - + model->BSIM3pdsub * Inv_LW; - pParam->BSIM3vth0 = model->BSIM3vth0 - + model->BSIM3lvth0 * Inv_L - + model->BSIM3wvth0 * Inv_W - + model->BSIM3pvth0 * Inv_LW; - pParam->BSIM3ua = model->BSIM3ua - + model->BSIM3lua * Inv_L - + model->BSIM3wua * Inv_W - + model->BSIM3pua * Inv_LW; - pParam->BSIM3ua1 = model->BSIM3ua1 - + model->BSIM3lua1 * Inv_L - + model->BSIM3wua1 * Inv_W - + model->BSIM3pua1 * Inv_LW; - pParam->BSIM3ub = model->BSIM3ub - + model->BSIM3lub * Inv_L - + model->BSIM3wub * Inv_W - + model->BSIM3pub * Inv_LW; - pParam->BSIM3ub1 = model->BSIM3ub1 - + model->BSIM3lub1 * Inv_L - + model->BSIM3wub1 * Inv_W - + model->BSIM3pub1 * Inv_LW; - pParam->BSIM3uc = model->BSIM3uc - + model->BSIM3luc * Inv_L - + model->BSIM3wuc * Inv_W - + model->BSIM3puc * Inv_LW; - pParam->BSIM3uc1 = model->BSIM3uc1 - + model->BSIM3luc1 * Inv_L - + model->BSIM3wuc1 * Inv_W - + model->BSIM3puc1 * Inv_LW; - pParam->BSIM3u0 = model->BSIM3u0 - + model->BSIM3lu0 * Inv_L - + model->BSIM3wu0 * Inv_W - + model->BSIM3pu0 * Inv_LW; - pParam->BSIM3ute = model->BSIM3ute - + model->BSIM3lute * Inv_L - + model->BSIM3wute * Inv_W - + model->BSIM3pute * Inv_LW; - pParam->BSIM3voff = model->BSIM3voff - + model->BSIM3lvoff * Inv_L - + model->BSIM3wvoff * Inv_W - + model->BSIM3pvoff * Inv_LW; - pParam->BSIM3delta = model->BSIM3delta - + model->BSIM3ldelta * Inv_L - + model->BSIM3wdelta * Inv_W - + model->BSIM3pdelta * Inv_LW; - pParam->BSIM3rdsw = model->BSIM3rdsw - + model->BSIM3lrdsw * Inv_L - + model->BSIM3wrdsw * Inv_W - + model->BSIM3prdsw * Inv_LW; - pParam->BSIM3prwg = model->BSIM3prwg - + model->BSIM3lprwg * Inv_L - + model->BSIM3wprwg * Inv_W - + model->BSIM3pprwg * Inv_LW; - pParam->BSIM3prwb = model->BSIM3prwb - + model->BSIM3lprwb * Inv_L - + model->BSIM3wprwb * Inv_W - + model->BSIM3pprwb * Inv_LW; - pParam->BSIM3prt = model->BSIM3prt - + model->BSIM3lprt * Inv_L - + model->BSIM3wprt * Inv_W - + model->BSIM3pprt * Inv_LW; - pParam->BSIM3eta0 = model->BSIM3eta0 - + model->BSIM3leta0 * Inv_L - + model->BSIM3weta0 * Inv_W - + model->BSIM3peta0 * Inv_LW; - pParam->BSIM3etab = model->BSIM3etab - + model->BSIM3letab * Inv_L - + model->BSIM3wetab * Inv_W - + model->BSIM3petab * Inv_LW; - pParam->BSIM3pclm = model->BSIM3pclm - + model->BSIM3lpclm * Inv_L - + model->BSIM3wpclm * Inv_W - + model->BSIM3ppclm * Inv_LW; - pParam->BSIM3pdibl1 = model->BSIM3pdibl1 - + model->BSIM3lpdibl1 * Inv_L - + model->BSIM3wpdibl1 * Inv_W - + model->BSIM3ppdibl1 * Inv_LW; - pParam->BSIM3pdibl2 = model->BSIM3pdibl2 - + model->BSIM3lpdibl2 * Inv_L - + model->BSIM3wpdibl2 * Inv_W - + model->BSIM3ppdibl2 * Inv_LW; - pParam->BSIM3pdiblb = model->BSIM3pdiblb - + model->BSIM3lpdiblb * Inv_L - + model->BSIM3wpdiblb * Inv_W - + model->BSIM3ppdiblb * Inv_LW; - pParam->BSIM3pscbe1 = model->BSIM3pscbe1 - + model->BSIM3lpscbe1 * Inv_L - + model->BSIM3wpscbe1 * Inv_W - + model->BSIM3ppscbe1 * Inv_LW; - pParam->BSIM3pscbe2 = model->BSIM3pscbe2 - + model->BSIM3lpscbe2 * Inv_L - + model->BSIM3wpscbe2 * Inv_W - + model->BSIM3ppscbe2 * Inv_LW; - pParam->BSIM3pvag = model->BSIM3pvag - + model->BSIM3lpvag * Inv_L - + model->BSIM3wpvag * Inv_W - + model->BSIM3ppvag * Inv_LW; - pParam->BSIM3wr = model->BSIM3wr - + model->BSIM3lwr * Inv_L - + model->BSIM3wwr * Inv_W - + model->BSIM3pwr * Inv_LW; - pParam->BSIM3dwg = model->BSIM3dwg - + model->BSIM3ldwg * Inv_L - + model->BSIM3wdwg * Inv_W - + model->BSIM3pdwg * Inv_LW; - pParam->BSIM3dwb = model->BSIM3dwb - + model->BSIM3ldwb * Inv_L - + model->BSIM3wdwb * Inv_W - + model->BSIM3pdwb * Inv_LW; - pParam->BSIM3b0 = model->BSIM3b0 - + model->BSIM3lb0 * Inv_L - + model->BSIM3wb0 * Inv_W - + model->BSIM3pb0 * Inv_LW; - pParam->BSIM3b1 = model->BSIM3b1 - + model->BSIM3lb1 * Inv_L - + model->BSIM3wb1 * Inv_W - + model->BSIM3pb1 * Inv_LW; - pParam->BSIM3alpha0 = model->BSIM3alpha0 - + model->BSIM3lalpha0 * Inv_L - + model->BSIM3walpha0 * Inv_W - + model->BSIM3palpha0 * Inv_LW; + pParam->BSIM3k1 = model->BSIM3k1 + + model->BSIM3lk1 * Inv_L + + model->BSIM3wk1 * Inv_W + + model->BSIM3pk1 * Inv_LW; + pParam->BSIM3kt1 = model->BSIM3kt1 + + model->BSIM3lkt1 * Inv_L + + model->BSIM3wkt1 * Inv_W + + model->BSIM3pkt1 * Inv_LW; + pParam->BSIM3kt1l = model->BSIM3kt1l + + model->BSIM3lkt1l * Inv_L + + model->BSIM3wkt1l * Inv_W + + model->BSIM3pkt1l * Inv_LW; + pParam->BSIM3k2 = model->BSIM3k2 + + model->BSIM3lk2 * Inv_L + + model->BSIM3wk2 * Inv_W + + model->BSIM3pk2 * Inv_LW; + pParam->BSIM3kt2 = model->BSIM3kt2 + + model->BSIM3lkt2 * Inv_L + + model->BSIM3wkt2 * Inv_W + + model->BSIM3pkt2 * Inv_LW; + pParam->BSIM3k3 = model->BSIM3k3 + + model->BSIM3lk3 * Inv_L + + model->BSIM3wk3 * Inv_W + + model->BSIM3pk3 * Inv_LW; + pParam->BSIM3k3b = model->BSIM3k3b + + model->BSIM3lk3b * Inv_L + + model->BSIM3wk3b * Inv_W + + model->BSIM3pk3b * Inv_LW; + pParam->BSIM3w0 = model->BSIM3w0 + + model->BSIM3lw0 * Inv_L + + model->BSIM3ww0 * Inv_W + + model->BSIM3pw0 * Inv_LW; + pParam->BSIM3nlx = model->BSIM3nlx + + model->BSIM3lnlx * Inv_L + + model->BSIM3wnlx * Inv_W + + model->BSIM3pnlx * Inv_LW; + pParam->BSIM3dvt0 = model->BSIM3dvt0 + + model->BSIM3ldvt0 * Inv_L + + model->BSIM3wdvt0 * Inv_W + + model->BSIM3pdvt0 * Inv_LW; + pParam->BSIM3dvt1 = model->BSIM3dvt1 + + model->BSIM3ldvt1 * Inv_L + + model->BSIM3wdvt1 * Inv_W + + model->BSIM3pdvt1 * Inv_LW; + pParam->BSIM3dvt2 = model->BSIM3dvt2 + + model->BSIM3ldvt2 * Inv_L + + model->BSIM3wdvt2 * Inv_W + + model->BSIM3pdvt2 * Inv_LW; + pParam->BSIM3dvt0w = model->BSIM3dvt0w + + model->BSIM3ldvt0w * Inv_L + + model->BSIM3wdvt0w * Inv_W + + model->BSIM3pdvt0w * Inv_LW; + pParam->BSIM3dvt1w = model->BSIM3dvt1w + + model->BSIM3ldvt1w * Inv_L + + model->BSIM3wdvt1w * Inv_W + + model->BSIM3pdvt1w * Inv_LW; + pParam->BSIM3dvt2w = model->BSIM3dvt2w + + model->BSIM3ldvt2w * Inv_L + + model->BSIM3wdvt2w * Inv_W + + model->BSIM3pdvt2w * Inv_LW; + pParam->BSIM3drout = model->BSIM3drout + + model->BSIM3ldrout * Inv_L + + model->BSIM3wdrout * Inv_W + + model->BSIM3pdrout * Inv_LW; + pParam->BSIM3dsub = model->BSIM3dsub + + model->BSIM3ldsub * Inv_L + + model->BSIM3wdsub * Inv_W + + model->BSIM3pdsub * Inv_LW; + pParam->BSIM3vth0 = model->BSIM3vth0 + + model->BSIM3lvth0 * Inv_L + + model->BSIM3wvth0 * Inv_W + + model->BSIM3pvth0 * Inv_LW; + pParam->BSIM3ua = model->BSIM3ua + + model->BSIM3lua * Inv_L + + model->BSIM3wua * Inv_W + + model->BSIM3pua * Inv_LW; + pParam->BSIM3ua1 = model->BSIM3ua1 + + model->BSIM3lua1 * Inv_L + + model->BSIM3wua1 * Inv_W + + model->BSIM3pua1 * Inv_LW; + pParam->BSIM3ub = model->BSIM3ub + + model->BSIM3lub * Inv_L + + model->BSIM3wub * Inv_W + + model->BSIM3pub * Inv_LW; + pParam->BSIM3ub1 = model->BSIM3ub1 + + model->BSIM3lub1 * Inv_L + + model->BSIM3wub1 * Inv_W + + model->BSIM3pub1 * Inv_LW; + pParam->BSIM3uc = model->BSIM3uc + + model->BSIM3luc * Inv_L + + model->BSIM3wuc * Inv_W + + model->BSIM3puc * Inv_LW; + pParam->BSIM3uc1 = model->BSIM3uc1 + + model->BSIM3luc1 * Inv_L + + model->BSIM3wuc1 * Inv_W + + model->BSIM3puc1 * Inv_LW; + pParam->BSIM3u0 = model->BSIM3u0 + + model->BSIM3lu0 * Inv_L + + model->BSIM3wu0 * Inv_W + + model->BSIM3pu0 * Inv_LW; + pParam->BSIM3ute = model->BSIM3ute + + model->BSIM3lute * Inv_L + + model->BSIM3wute * Inv_W + + model->BSIM3pute * Inv_LW; + pParam->BSIM3voff = model->BSIM3voff + + model->BSIM3lvoff * Inv_L + + model->BSIM3wvoff * Inv_W + + model->BSIM3pvoff * Inv_LW; + pParam->BSIM3delta = model->BSIM3delta + + model->BSIM3ldelta * Inv_L + + model->BSIM3wdelta * Inv_W + + model->BSIM3pdelta * Inv_LW; + pParam->BSIM3rdsw = model->BSIM3rdsw + + model->BSIM3lrdsw * Inv_L + + model->BSIM3wrdsw * Inv_W + + model->BSIM3prdsw * Inv_LW; + pParam->BSIM3prwg = model->BSIM3prwg + + model->BSIM3lprwg * Inv_L + + model->BSIM3wprwg * Inv_W + + model->BSIM3pprwg * Inv_LW; + pParam->BSIM3prwb = model->BSIM3prwb + + model->BSIM3lprwb * Inv_L + + model->BSIM3wprwb * Inv_W + + model->BSIM3pprwb * Inv_LW; + pParam->BSIM3prt = model->BSIM3prt + + model->BSIM3lprt * Inv_L + + model->BSIM3wprt * Inv_W + + model->BSIM3pprt * Inv_LW; + pParam->BSIM3eta0 = model->BSIM3eta0 + + model->BSIM3leta0 * Inv_L + + model->BSIM3weta0 * Inv_W + + model->BSIM3peta0 * Inv_LW; + pParam->BSIM3etab = model->BSIM3etab + + model->BSIM3letab * Inv_L + + model->BSIM3wetab * Inv_W + + model->BSIM3petab * Inv_LW; + pParam->BSIM3pclm = model->BSIM3pclm + + model->BSIM3lpclm * Inv_L + + model->BSIM3wpclm * Inv_W + + model->BSIM3ppclm * Inv_LW; + pParam->BSIM3pdibl1 = model->BSIM3pdibl1 + + model->BSIM3lpdibl1 * Inv_L + + model->BSIM3wpdibl1 * Inv_W + + model->BSIM3ppdibl1 * Inv_LW; + pParam->BSIM3pdibl2 = model->BSIM3pdibl2 + + model->BSIM3lpdibl2 * Inv_L + + model->BSIM3wpdibl2 * Inv_W + + model->BSIM3ppdibl2 * Inv_LW; + pParam->BSIM3pdiblb = model->BSIM3pdiblb + + model->BSIM3lpdiblb * Inv_L + + model->BSIM3wpdiblb * Inv_W + + model->BSIM3ppdiblb * Inv_LW; + pParam->BSIM3pscbe1 = model->BSIM3pscbe1 + + model->BSIM3lpscbe1 * Inv_L + + model->BSIM3wpscbe1 * Inv_W + + model->BSIM3ppscbe1 * Inv_LW; + pParam->BSIM3pscbe2 = model->BSIM3pscbe2 + + model->BSIM3lpscbe2 * Inv_L + + model->BSIM3wpscbe2 * Inv_W + + model->BSIM3ppscbe2 * Inv_LW; + pParam->BSIM3pvag = model->BSIM3pvag + + model->BSIM3lpvag * Inv_L + + model->BSIM3wpvag * Inv_W + + model->BSIM3ppvag * Inv_LW; + pParam->BSIM3wr = model->BSIM3wr + + model->BSIM3lwr * Inv_L + + model->BSIM3wwr * Inv_W + + model->BSIM3pwr * Inv_LW; + pParam->BSIM3dwg = model->BSIM3dwg + + model->BSIM3ldwg * Inv_L + + model->BSIM3wdwg * Inv_W + + model->BSIM3pdwg * Inv_LW; + pParam->BSIM3dwb = model->BSIM3dwb + + model->BSIM3ldwb * Inv_L + + model->BSIM3wdwb * Inv_W + + model->BSIM3pdwb * Inv_LW; + pParam->BSIM3b0 = model->BSIM3b0 + + model->BSIM3lb0 * Inv_L + + model->BSIM3wb0 * Inv_W + + model->BSIM3pb0 * Inv_LW; + pParam->BSIM3b1 = model->BSIM3b1 + + model->BSIM3lb1 * Inv_L + + model->BSIM3wb1 * Inv_W + + model->BSIM3pb1 * Inv_LW; + pParam->BSIM3alpha0 = model->BSIM3alpha0 + + model->BSIM3lalpha0 * Inv_L + + model->BSIM3walpha0 * Inv_W + + model->BSIM3palpha0 * Inv_LW; pParam->BSIM3alpha1 = model->BSIM3alpha1 + model->BSIM3lalpha1 * Inv_L + model->BSIM3walpha1 * Inv_W + model->BSIM3palpha1 * Inv_LW; - pParam->BSIM3beta0 = model->BSIM3beta0 - + model->BSIM3lbeta0 * Inv_L - + model->BSIM3wbeta0 * Inv_W - + model->BSIM3pbeta0 * Inv_LW; - /* CV model */ - pParam->BSIM3elm = model->BSIM3elm - + model->BSIM3lelm * Inv_L - + model->BSIM3welm * Inv_W - + model->BSIM3pelm * Inv_LW; - pParam->BSIM3cgsl = model->BSIM3cgsl - + model->BSIM3lcgsl * Inv_L - + model->BSIM3wcgsl * Inv_W - + model->BSIM3pcgsl * Inv_LW; - pParam->BSIM3cgdl = model->BSIM3cgdl - + model->BSIM3lcgdl * Inv_L - + model->BSIM3wcgdl * Inv_W - + model->BSIM3pcgdl * Inv_LW; - pParam->BSIM3ckappa = model->BSIM3ckappa - + model->BSIM3lckappa * Inv_L - + model->BSIM3wckappa * Inv_W - + model->BSIM3pckappa * Inv_LW; - pParam->BSIM3cf = model->BSIM3cf - + model->BSIM3lcf * Inv_L - + model->BSIM3wcf * Inv_W - + model->BSIM3pcf * Inv_LW; - pParam->BSIM3clc = model->BSIM3clc - + model->BSIM3lclc * Inv_L - + model->BSIM3wclc * Inv_W - + model->BSIM3pclc * Inv_LW; - pParam->BSIM3cle = model->BSIM3cle - + model->BSIM3lcle * Inv_L - + model->BSIM3wcle * Inv_W - + model->BSIM3pcle * Inv_LW; - pParam->BSIM3vfbcv = model->BSIM3vfbcv - + model->BSIM3lvfbcv * Inv_L - + model->BSIM3wvfbcv * Inv_W - + model->BSIM3pvfbcv * Inv_LW; + pParam->BSIM3beta0 = model->BSIM3beta0 + + model->BSIM3lbeta0 * Inv_L + + model->BSIM3wbeta0 * Inv_W + + model->BSIM3pbeta0 * Inv_LW; + /* CV model */ + pParam->BSIM3elm = model->BSIM3elm + + model->BSIM3lelm * Inv_L + + model->BSIM3welm * Inv_W + + model->BSIM3pelm * Inv_LW; + pParam->BSIM3cgsl = model->BSIM3cgsl + + model->BSIM3lcgsl * Inv_L + + model->BSIM3wcgsl * Inv_W + + model->BSIM3pcgsl * Inv_LW; + pParam->BSIM3cgdl = model->BSIM3cgdl + + model->BSIM3lcgdl * Inv_L + + model->BSIM3wcgdl * Inv_W + + model->BSIM3pcgdl * Inv_LW; + pParam->BSIM3ckappa = model->BSIM3ckappa + + model->BSIM3lckappa * Inv_L + + model->BSIM3wckappa * Inv_W + + model->BSIM3pckappa * Inv_LW; + pParam->BSIM3cf = model->BSIM3cf + + model->BSIM3lcf * Inv_L + + model->BSIM3wcf * Inv_W + + model->BSIM3pcf * Inv_LW; + pParam->BSIM3clc = model->BSIM3clc + + model->BSIM3lclc * Inv_L + + model->BSIM3wclc * Inv_W + + model->BSIM3pclc * Inv_LW; + pParam->BSIM3cle = model->BSIM3cle + + model->BSIM3lcle * Inv_L + + model->BSIM3wcle * Inv_W + + model->BSIM3pcle * Inv_LW; + pParam->BSIM3vfbcv = model->BSIM3vfbcv + + model->BSIM3lvfbcv * Inv_L + + model->BSIM3wvfbcv * Inv_W + + model->BSIM3pvfbcv * Inv_LW; pParam->BSIM3acde = model->BSIM3acde + model->BSIM3lacde * Inv_L + model->BSIM3wacde * Inv_W @@ -588,35 +588,35 @@ int Size_Not_Found; + model->BSIM3pvoffcv * Inv_LW; pParam->BSIM3abulkCVfactor = 1.0 + pow((pParam->BSIM3clc - / pParam->BSIM3leffCV), - pParam->BSIM3cle); + / pParam->BSIM3leffCV), + pParam->BSIM3cle); - T0 = (TRatio - 1.0); - pParam->BSIM3ua = pParam->BSIM3ua + pParam->BSIM3ua1 * T0; - pParam->BSIM3ub = pParam->BSIM3ub + pParam->BSIM3ub1 * T0; - pParam->BSIM3uc = pParam->BSIM3uc + pParam->BSIM3uc1 * T0; - if (pParam->BSIM3u0 > 1.0) + T0 = (TRatio - 1.0); + pParam->BSIM3ua = pParam->BSIM3ua + pParam->BSIM3ua1 * T0; + pParam->BSIM3ub = pParam->BSIM3ub + pParam->BSIM3ub1 * T0; + pParam->BSIM3uc = pParam->BSIM3uc + pParam->BSIM3uc1 * T0; + if (pParam->BSIM3u0 > 1.0) pParam->BSIM3u0 = pParam->BSIM3u0 / 1.0e4; pParam->BSIM3u0temp = pParam->BSIM3u0 - * pow(TRatio, pParam->BSIM3ute); - pParam->BSIM3vsattemp = pParam->BSIM3vsat - pParam->BSIM3at - * T0; - pParam->BSIM3rds0 = (pParam->BSIM3rdsw + pParam->BSIM3prt * T0) + * pow(TRatio, pParam->BSIM3ute); + pParam->BSIM3vsattemp = pParam->BSIM3vsat - pParam->BSIM3at + * T0; + pParam->BSIM3rds0 = (pParam->BSIM3rdsw + pParam->BSIM3prt * T0) / pow(pParam->BSIM3weff * 1E6, pParam->BSIM3wr); - if (BSIM3checkModel(model, here, ckt)) - { IFuid namarray[2]; + if (BSIM3checkModel(model, here, ckt)) + { IFuid namarray[2]; namarray[0] = model->BSIM3modName; namarray[1] = here->BSIM3name; SPfrontEnd->IFerror (ERR_FATAL, "Fatal error(s) detected during BSIM3V3.2 parameter checking for %s in model %s", namarray); - return(E_BADPARM); - } + return(E_BADPARM); + } pParam->BSIM3cgdo = (model->BSIM3cgdo + pParam->BSIM3cf) - * pParam->BSIM3weffCV; + * pParam->BSIM3weffCV; pParam->BSIM3cgso = (model->BSIM3cgso + pParam->BSIM3cf) - * pParam->BSIM3weffCV; + * pParam->BSIM3weffCV; pParam->BSIM3cgbo = model->BSIM3cgbo * pParam->BSIM3leffCV; T0 = pParam->BSIM3leffCV * pParam->BSIM3leffCV; @@ -628,23 +628,23 @@ int Size_Not_Found; pParam->BSIM3npeak = 3.021E22 * T0 * T0; } - pParam->BSIM3phi = 2.0 * Vtm0 - * log(pParam->BSIM3npeak / ni); + pParam->BSIM3phi = 2.0 * Vtm0 + * log(pParam->BSIM3npeak / ni); - pParam->BSIM3sqrtPhi = sqrt(pParam->BSIM3phi); - pParam->BSIM3phis3 = pParam->BSIM3sqrtPhi * pParam->BSIM3phi; + pParam->BSIM3sqrtPhi = sqrt(pParam->BSIM3phi); + pParam->BSIM3phis3 = pParam->BSIM3sqrtPhi * pParam->BSIM3phi; pParam->BSIM3Xdep0 = sqrt(2.0 * EPSSI / (Charge_q - * pParam->BSIM3npeak * 1.0e6)) - * pParam->BSIM3sqrtPhi; + * pParam->BSIM3npeak * 1.0e6)) + * pParam->BSIM3sqrtPhi; pParam->BSIM3sqrtXdep0 = sqrt(pParam->BSIM3Xdep0); pParam->BSIM3litl = sqrt(3.0 * pParam->BSIM3xj - * model->BSIM3tox); + * model->BSIM3tox); pParam->BSIM3vbi = Vtm0 * log(1.0e20 - * pParam->BSIM3npeak / (ni * ni)); + * pParam->BSIM3npeak / (ni * ni)); pParam->BSIM3cdep0 = sqrt(Charge_q * EPSSI - * pParam->BSIM3npeak * 1.0e6 / 2.0 - / pParam->BSIM3phi); + * pParam->BSIM3npeak * 1.0e6 / 2.0 + / pParam->BSIM3phi); pParam->BSIM3ldeb = sqrt(EPSSI * Vtm0 / (Charge_q * pParam->BSIM3npeak * 1.0e6)) / 3.0; @@ -678,48 +678,48 @@ int Size_Not_Found; } } else - { if (!model->BSIM3vbxGiven) - pParam->BSIM3vbx = pParam->BSIM3phi - 7.7348e-4 + { if (!model->BSIM3vbxGiven) + pParam->BSIM3vbx = pParam->BSIM3phi - 7.7348e-4 * pParam->BSIM3npeak - * pParam->BSIM3xt * pParam->BSIM3xt; - if (pParam->BSIM3vbx > 0.0) - pParam->BSIM3vbx = -pParam->BSIM3vbx; - if (pParam->BSIM3vbm > 0.0) + * pParam->BSIM3xt * pParam->BSIM3xt; + if (pParam->BSIM3vbx > 0.0) + pParam->BSIM3vbx = -pParam->BSIM3vbx; + if (pParam->BSIM3vbm > 0.0) pParam->BSIM3vbm = -pParam->BSIM3vbm; - + if (!model->BSIM3gamma1Given) pParam->BSIM3gamma1 = 5.753e-12 - * sqrt(pParam->BSIM3npeak) + * sqrt(pParam->BSIM3npeak) / model->BSIM3cox; if (!model->BSIM3gamma2Given) pParam->BSIM3gamma2 = 5.753e-12 - * sqrt(pParam->BSIM3nsub) + * sqrt(pParam->BSIM3nsub) / model->BSIM3cox; T0 = pParam->BSIM3gamma1 - pParam->BSIM3gamma2; T1 = sqrt(pParam->BSIM3phi - pParam->BSIM3vbx) - - pParam->BSIM3sqrtPhi; + - pParam->BSIM3sqrtPhi; T2 = sqrt(pParam->BSIM3phi * (pParam->BSIM3phi - - pParam->BSIM3vbm)) - pParam->BSIM3phi; + - pParam->BSIM3vbm)) - pParam->BSIM3phi; pParam->BSIM3k2 = T0 * T1 / (2.0 * T2 + pParam->BSIM3vbm); pParam->BSIM3k1 = pParam->BSIM3gamma2 - 2.0 - * pParam->BSIM3k2 * sqrt(pParam->BSIM3phi - - pParam->BSIM3vbm); + * pParam->BSIM3k2 * sqrt(pParam->BSIM3phi + - pParam->BSIM3vbm); } - - if (pParam->BSIM3k2 < 0.0) - { T0 = 0.5 * pParam->BSIM3k1 / pParam->BSIM3k2; + + if (pParam->BSIM3k2 < 0.0) + { T0 = 0.5 * pParam->BSIM3k1 / pParam->BSIM3k2; pParam->BSIM3vbsc = 0.9 * (pParam->BSIM3phi - T0 * T0); - if (pParam->BSIM3vbsc > -3.0) - pParam->BSIM3vbsc = -3.0; - else if (pParam->BSIM3vbsc < -30.0) - pParam->BSIM3vbsc = -30.0; - } - else - { pParam->BSIM3vbsc = -30.0; - } - if (pParam->BSIM3vbsc > pParam->BSIM3vbm) - pParam->BSIM3vbsc = pParam->BSIM3vbm; + if (pParam->BSIM3vbsc > -3.0) + pParam->BSIM3vbsc = -3.0; + else if (pParam->BSIM3vbsc < -30.0) + pParam->BSIM3vbsc = -30.0; + } + else + { pParam->BSIM3vbsc = -30.0; + } + if (pParam->BSIM3vbsc > pParam->BSIM3vbm) + pParam->BSIM3vbsc = pParam->BSIM3vbm; if (!model->BSIM3vfbGiven) { if (model->BSIM3vth0Given) @@ -743,14 +743,14 @@ int Size_Not_Found; / model->BSIM3toxm; T1 = sqrt(EPSSI / EPSOX * model->BSIM3tox - * pParam->BSIM3Xdep0); + * pParam->BSIM3Xdep0); T0 = exp(-0.5 * pParam->BSIM3dsub * pParam->BSIM3leff / T1); pParam->BSIM3theta0vb0 = (T0 + 2.0 * T0 * T0); T0 = exp(-0.5 * pParam->BSIM3drout * pParam->BSIM3leff / T1); T2 = (T0 + 2.0 * T0 * T0); pParam->BSIM3thetaRout = pParam->BSIM3pdibl1 * T2 - + pParam->BSIM3pdibl2; + + pParam->BSIM3pdibl2; tmp = sqrt(pParam->BSIM3Xdep0); tmp1 = pParam->BSIM3vbi - pParam->BSIM3phi; @@ -796,23 +796,23 @@ int Size_Not_Found; } /* process source/drain series resistance */ - here->BSIM3drainConductance = model->BSIM3sheetResistance - * here->BSIM3drainSquares; + here->BSIM3drainConductance = model->BSIM3sheetResistance + * here->BSIM3drainSquares; if (here->BSIM3drainConductance > 0.0) here->BSIM3drainConductance = 1.0 - / here->BSIM3drainConductance; - else + / here->BSIM3drainConductance; + else here->BSIM3drainConductance = 0.0; - - here->BSIM3sourceConductance = model->BSIM3sheetResistance - * here->BSIM3sourceSquares; - if (here->BSIM3sourceConductance > 0.0) + + here->BSIM3sourceConductance = model->BSIM3sheetResistance + * here->BSIM3sourceSquares; + if (here->BSIM3sourceConductance > 0.0) here->BSIM3sourceConductance = 1.0 - / here->BSIM3sourceConductance; - else + / here->BSIM3sourceConductance; + else here->BSIM3sourceConductance = 0.0; - here->BSIM3cgso = pParam->BSIM3cgso; - here->BSIM3cgdo = pParam->BSIM3cgdo; + here->BSIM3cgso = pParam->BSIM3cgso; + here->BSIM3cgdo = pParam->BSIM3cgdo; Nvtm = model->BSIM3vtm * model->BSIM3jctEmissionCoeff; if ((here->BSIM3sourceArea <= 0.0) && diff --git a/src/spicelib/devices/bsim3/bsim3def.h b/src/spicelib/devices/bsim3/bsim3def.h index 86efe6955..4ecbb31ca 100644 --- a/src/spicelib/devices/bsim3/bsim3def.h +++ b/src/spicelib/devices/bsim3/bsim3def.h @@ -14,7 +14,7 @@ File: bsim3def.h #include "ngspice/gendefs.h" #include "ngspice/cktdefs.h" #include "ngspice/complex.h" -#include "ngspice/noisedef.h" +#include "ngspice/noisedef.h" typedef struct sBSIM3instance { @@ -32,7 +32,7 @@ typedef struct sBSIM3instance /* MCJ */ double BSIM3ueff; - double BSIM3thetavth; + double BSIM3thetavth; double BSIM3von; double BSIM3vdsat; double BSIM3cgdo; @@ -44,7 +44,7 @@ typedef struct sBSIM3instance double BSIM3l; double BSIM3w; - double BSIM3m; + double BSIM3m; double BSIM3drainArea; double BSIM3sourceArea; double BSIM3drainSquares; @@ -115,7 +115,7 @@ typedef struct sBSIM3instance unsigned BSIM3lGiven :1; unsigned BSIM3wGiven :1; - unsigned BSIM3mGiven :1; + unsigned BSIM3mGiven :1; unsigned BSIM3drainAreaGiven :1; unsigned BSIM3sourceAreaGiven :1; unsigned BSIM3drainSquaresGiven :1; @@ -253,29 +253,29 @@ struct bsim3SizeDependParam double Width; double Length; - double BSIM3cdsc; - double BSIM3cdscb; - double BSIM3cdscd; - double BSIM3cit; - double BSIM3nfactor; + double BSIM3cdsc; + double BSIM3cdscb; + double BSIM3cdscd; + double BSIM3cit; + double BSIM3nfactor; double BSIM3xj; - double BSIM3vsat; - double BSIM3at; - double BSIM3a0; - double BSIM3ags; - double BSIM3a1; - double BSIM3a2; - double BSIM3keta; + double BSIM3vsat; + double BSIM3at; + double BSIM3a0; + double BSIM3ags; + double BSIM3a1; + double BSIM3a2; + double BSIM3keta; double BSIM3nsub; - double BSIM3npeak; - double BSIM3ngate; - double BSIM3gamma1; - double BSIM3gamma2; - double BSIM3vbx; - double BSIM3vbi; - double BSIM3vbm; - double BSIM3vbsc; - double BSIM3xt; + double BSIM3npeak; + double BSIM3ngate; + double BSIM3gamma1; + double BSIM3gamma2; + double BSIM3vbx; + double BSIM3vbi; + double BSIM3vbm; + double BSIM3vbsc; + double BSIM3xt; double BSIM3phi; double BSIM3litl; double BSIM3k1; @@ -287,14 +287,14 @@ struct bsim3SizeDependParam double BSIM3k3b; double BSIM3w0; double BSIM3nlx; - double BSIM3dvt0; - double BSIM3dvt1; - double BSIM3dvt2; - double BSIM3dvt0w; - double BSIM3dvt1w; - double BSIM3dvt2w; - double BSIM3drout; - double BSIM3dsub; + double BSIM3dvt0; + double BSIM3dvt1; + double BSIM3dvt2; + double BSIM3dvt0w; + double BSIM3dvt1w; + double BSIM3dvt2w; + double BSIM3drout; + double BSIM3dsub; double BSIM3vth0; double BSIM3ua; double BSIM3ua1; @@ -307,20 +307,20 @@ struct bsim3SizeDependParam double BSIM3voff; double BSIM3vfb; double BSIM3delta; - double BSIM3rdsw; - double BSIM3rds0; - double BSIM3prwg; - double BSIM3prwb; - double BSIM3prt; - double BSIM3eta0; - double BSIM3etab; - double BSIM3pclm; - double BSIM3pdibl1; - double BSIM3pdibl2; - double BSIM3pdiblb; - double BSIM3pscbe1; - double BSIM3pscbe2; - double BSIM3pvag; + double BSIM3rdsw; + double BSIM3rds0; + double BSIM3prwg; + double BSIM3prwb; + double BSIM3prt; + double BSIM3eta0; + double BSIM3etab; + double BSIM3pclm; + double BSIM3pdibl1; + double BSIM3pdibl2; + double BSIM3pdiblb; + double BSIM3pscbe1; + double BSIM3pscbe2; + double BSIM3pvag; double BSIM3wr; double BSIM3dwg; double BSIM3dwb; @@ -363,14 +363,14 @@ struct bsim3SizeDependParam double BSIM3cgbo; double BSIM3tconst; - double BSIM3u0temp; - double BSIM3vsattemp; - double BSIM3sqrtPhi; - double BSIM3phis3; - double BSIM3Xdep0; - double BSIM3sqrtXdep0; + double BSIM3u0temp; + double BSIM3vsattemp; + double BSIM3sqrtPhi; + double BSIM3phis3; + double BSIM3Xdep0; + double BSIM3sqrtXdep0; double BSIM3theta0vb0; - double BSIM3thetaRout; + double BSIM3thetaRout; double BSIM3cof1; double BSIM3cof2; @@ -386,12 +386,12 @@ struct bsim3SizeDependParam }; -typedef struct sBSIM3model +typedef struct sBSIM3model { int BSIM3modType; struct sBSIM3model *BSIM3nextModel; BSIM3instance *BSIM3instances; - IFuid BSIM3modName; + IFuid BSIM3modName; int BSIM3type; int BSIM3mobMod; @@ -400,30 +400,30 @@ typedef struct sBSIM3model int BSIM3acnqsMod; int BSIM3binUnit; int BSIM3paramChk; - char *BSIM3version; - double BSIM3tox; + char *BSIM3version; + double BSIM3tox; double BSIM3toxm; - double BSIM3cdsc; - double BSIM3cdscb; - double BSIM3cdscd; - double BSIM3cit; - double BSIM3nfactor; + double BSIM3cdsc; + double BSIM3cdscb; + double BSIM3cdscd; + double BSIM3cit; + double BSIM3nfactor; double BSIM3xj; - double BSIM3vsat; - double BSIM3at; - double BSIM3a0; - double BSIM3ags; - double BSIM3a1; - double BSIM3a2; - double BSIM3keta; + double BSIM3vsat; + double BSIM3at; + double BSIM3a0; + double BSIM3ags; + double BSIM3a1; + double BSIM3a2; + double BSIM3keta; double BSIM3nsub; - double BSIM3npeak; - double BSIM3ngate; - double BSIM3gamma1; - double BSIM3gamma2; - double BSIM3vbx; - double BSIM3vbm; - double BSIM3xt; + double BSIM3npeak; + double BSIM3ngate; + double BSIM3gamma1; + double BSIM3gamma2; + double BSIM3vbx; + double BSIM3vbm; + double BSIM3xt; double BSIM3k1; double BSIM3kt1; double BSIM3kt1l; @@ -433,14 +433,14 @@ typedef struct sBSIM3model double BSIM3k3b; double BSIM3w0; double BSIM3nlx; - double BSIM3dvt0; - double BSIM3dvt1; - double BSIM3dvt2; - double BSIM3dvt0w; - double BSIM3dvt1w; - double BSIM3dvt2w; - double BSIM3drout; - double BSIM3dsub; + double BSIM3dvt0; + double BSIM3dvt1; + double BSIM3dvt2; + double BSIM3dvt0w; + double BSIM3dvt1w; + double BSIM3dvt2w; + double BSIM3drout; + double BSIM3dsub; double BSIM3vth0; double BSIM3ua; double BSIM3ua1; @@ -452,19 +452,19 @@ typedef struct sBSIM3model double BSIM3ute; double BSIM3voff; double BSIM3delta; - double BSIM3rdsw; + double BSIM3rdsw; double BSIM3prwg; double BSIM3prwb; - double BSIM3prt; - double BSIM3eta0; - double BSIM3etab; - double BSIM3pclm; - double BSIM3pdibl1; - double BSIM3pdibl2; + double BSIM3prt; + double BSIM3eta0; + double BSIM3etab; + double BSIM3pclm; + double BSIM3pdibl1; + double BSIM3pdibl2; double BSIM3pdiblb; - double BSIM3pscbe1; - double BSIM3pscbe2; - double BSIM3pvag; + double BSIM3pscbe1; + double BSIM3pscbe2; + double BSIM3pvag; double BSIM3wr; double BSIM3dwg; double BSIM3dwb; @@ -499,27 +499,27 @@ typedef struct sBSIM3model double BSIM3tpbswg; /* Length Dependence */ - double BSIM3lcdsc; - double BSIM3lcdscb; - double BSIM3lcdscd; - double BSIM3lcit; - double BSIM3lnfactor; + double BSIM3lcdsc; + double BSIM3lcdscb; + double BSIM3lcdscd; + double BSIM3lcit; + double BSIM3lnfactor; double BSIM3lxj; - double BSIM3lvsat; - double BSIM3lat; - double BSIM3la0; - double BSIM3lags; - double BSIM3la1; - double BSIM3la2; - double BSIM3lketa; + double BSIM3lvsat; + double BSIM3lat; + double BSIM3la0; + double BSIM3lags; + double BSIM3la1; + double BSIM3la2; + double BSIM3lketa; double BSIM3lnsub; - double BSIM3lnpeak; - double BSIM3lngate; - double BSIM3lgamma1; - double BSIM3lgamma2; - double BSIM3lvbx; - double BSIM3lvbm; - double BSIM3lxt; + double BSIM3lnpeak; + double BSIM3lngate; + double BSIM3lgamma1; + double BSIM3lgamma2; + double BSIM3lvbx; + double BSIM3lvbm; + double BSIM3lxt; double BSIM3lk1; double BSIM3lkt1; double BSIM3lkt1l; @@ -529,14 +529,14 @@ typedef struct sBSIM3model double BSIM3lk3b; double BSIM3lw0; double BSIM3lnlx; - double BSIM3ldvt0; - double BSIM3ldvt1; - double BSIM3ldvt2; - double BSIM3ldvt0w; - double BSIM3ldvt1w; - double BSIM3ldvt2w; - double BSIM3ldrout; - double BSIM3ldsub; + double BSIM3ldvt0; + double BSIM3ldvt1; + double BSIM3ldvt2; + double BSIM3ldvt0w; + double BSIM3ldvt1w; + double BSIM3ldvt2w; + double BSIM3ldrout; + double BSIM3ldsub; double BSIM3lvth0; double BSIM3lua; double BSIM3lua1; @@ -548,19 +548,19 @@ typedef struct sBSIM3model double BSIM3lute; double BSIM3lvoff; double BSIM3ldelta; - double BSIM3lrdsw; + double BSIM3lrdsw; double BSIM3lprwg; double BSIM3lprwb; - double BSIM3lprt; - double BSIM3leta0; - double BSIM3letab; - double BSIM3lpclm; - double BSIM3lpdibl1; - double BSIM3lpdibl2; + double BSIM3lprt; + double BSIM3leta0; + double BSIM3letab; + double BSIM3lpclm; + double BSIM3lpdibl1; + double BSIM3lpdibl2; double BSIM3lpdiblb; - double BSIM3lpscbe1; - double BSIM3lpscbe2; - double BSIM3lpvag; + double BSIM3lpscbe1; + double BSIM3lpscbe2; + double BSIM3lpvag; double BSIM3lwr; double BSIM3ldwg; double BSIM3ldwb; @@ -586,27 +586,27 @@ typedef struct sBSIM3model double BSIM3lmoin; /* Width Dependence */ - double BSIM3wcdsc; - double BSIM3wcdscb; - double BSIM3wcdscd; - double BSIM3wcit; - double BSIM3wnfactor; + double BSIM3wcdsc; + double BSIM3wcdscb; + double BSIM3wcdscd; + double BSIM3wcit; + double BSIM3wnfactor; double BSIM3wxj; - double BSIM3wvsat; - double BSIM3wat; - double BSIM3wa0; - double BSIM3wags; - double BSIM3wa1; - double BSIM3wa2; - double BSIM3wketa; + double BSIM3wvsat; + double BSIM3wat; + double BSIM3wa0; + double BSIM3wags; + double BSIM3wa1; + double BSIM3wa2; + double BSIM3wketa; double BSIM3wnsub; - double BSIM3wnpeak; - double BSIM3wngate; - double BSIM3wgamma1; - double BSIM3wgamma2; - double BSIM3wvbx; - double BSIM3wvbm; - double BSIM3wxt; + double BSIM3wnpeak; + double BSIM3wngate; + double BSIM3wgamma1; + double BSIM3wgamma2; + double BSIM3wvbx; + double BSIM3wvbm; + double BSIM3wxt; double BSIM3wk1; double BSIM3wkt1; double BSIM3wkt1l; @@ -616,14 +616,14 @@ typedef struct sBSIM3model double BSIM3wk3b; double BSIM3ww0; double BSIM3wnlx; - double BSIM3wdvt0; - double BSIM3wdvt1; - double BSIM3wdvt2; - double BSIM3wdvt0w; - double BSIM3wdvt1w; - double BSIM3wdvt2w; - double BSIM3wdrout; - double BSIM3wdsub; + double BSIM3wdvt0; + double BSIM3wdvt1; + double BSIM3wdvt2; + double BSIM3wdvt0w; + double BSIM3wdvt1w; + double BSIM3wdvt2w; + double BSIM3wdrout; + double BSIM3wdsub; double BSIM3wvth0; double BSIM3wua; double BSIM3wua1; @@ -635,19 +635,19 @@ typedef struct sBSIM3model double BSIM3wute; double BSIM3wvoff; double BSIM3wdelta; - double BSIM3wrdsw; + double BSIM3wrdsw; double BSIM3wprwg; double BSIM3wprwb; - double BSIM3wprt; - double BSIM3weta0; - double BSIM3wetab; - double BSIM3wpclm; - double BSIM3wpdibl1; - double BSIM3wpdibl2; + double BSIM3wprt; + double BSIM3weta0; + double BSIM3wetab; + double BSIM3wpclm; + double BSIM3wpdibl1; + double BSIM3wpdibl2; double BSIM3wpdiblb; - double BSIM3wpscbe1; - double BSIM3wpscbe2; - double BSIM3wpvag; + double BSIM3wpscbe1; + double BSIM3wpscbe2; + double BSIM3wpvag; double BSIM3wwr; double BSIM3wdwg; double BSIM3wdwb; @@ -673,27 +673,27 @@ typedef struct sBSIM3model double BSIM3wmoin; /* Cross-term Dependence */ - double BSIM3pcdsc; - double BSIM3pcdscb; - double BSIM3pcdscd; - double BSIM3pcit; - double BSIM3pnfactor; + double BSIM3pcdsc; + double BSIM3pcdscb; + double BSIM3pcdscd; + double BSIM3pcit; + double BSIM3pnfactor; double BSIM3pxj; - double BSIM3pvsat; - double BSIM3pat; - double BSIM3pa0; - double BSIM3pags; - double BSIM3pa1; - double BSIM3pa2; - double BSIM3pketa; + double BSIM3pvsat; + double BSIM3pat; + double BSIM3pa0; + double BSIM3pags; + double BSIM3pa1; + double BSIM3pa2; + double BSIM3pketa; double BSIM3pnsub; - double BSIM3pnpeak; - double BSIM3pngate; - double BSIM3pgamma1; - double BSIM3pgamma2; - double BSIM3pvbx; - double BSIM3pvbm; - double BSIM3pxt; + double BSIM3pnpeak; + double BSIM3pngate; + double BSIM3pgamma1; + double BSIM3pgamma2; + double BSIM3pvbx; + double BSIM3pvbm; + double BSIM3pxt; double BSIM3pk1; double BSIM3pkt1; double BSIM3pkt1l; @@ -703,14 +703,14 @@ typedef struct sBSIM3model double BSIM3pk3b; double BSIM3pw0; double BSIM3pnlx; - double BSIM3pdvt0; - double BSIM3pdvt1; - double BSIM3pdvt2; - double BSIM3pdvt0w; - double BSIM3pdvt1w; - double BSIM3pdvt2w; - double BSIM3pdrout; - double BSIM3pdsub; + double BSIM3pdvt0; + double BSIM3pdvt1; + double BSIM3pdvt2; + double BSIM3pdvt0w; + double BSIM3pdvt1w; + double BSIM3pdvt2w; + double BSIM3pdrout; + double BSIM3pdsub; double BSIM3pvth0; double BSIM3pua; double BSIM3pua1; @@ -725,16 +725,16 @@ typedef struct sBSIM3model double BSIM3prdsw; double BSIM3pprwg; double BSIM3pprwb; - double BSIM3pprt; - double BSIM3peta0; - double BSIM3petab; - double BSIM3ppclm; - double BSIM3ppdibl1; - double BSIM3ppdibl2; + double BSIM3pprt; + double BSIM3peta0; + double BSIM3petab; + double BSIM3ppclm; + double BSIM3ppdibl1; + double BSIM3ppdibl2; double BSIM3ppdiblb; - double BSIM3ppscbe1; - double BSIM3ppscbe2; - double BSIM3ppvag; + double BSIM3ppscbe1; + double BSIM3ppscbe2; + double BSIM3ppvag; double BSIM3pwr; double BSIM3pdwg; double BSIM3pdwb; @@ -809,7 +809,7 @@ typedef struct sBSIM3model /* Pre-calculated constants */ /* MCJ: move to size-dependent param. */ - double BSIM3vtm; + double BSIM3vtm; double BSIM3cox; double BSIM3cof1; double BSIM3cof2; @@ -826,18 +826,18 @@ typedef struct sBSIM3model double BSIM3unitLengthSidewallTempJctCap; double BSIM3unitLengthGateSidewallTempJctCap; - double BSIM3oxideTrapDensityA; - double BSIM3oxideTrapDensityB; - double BSIM3oxideTrapDensityC; - double BSIM3em; - double BSIM3ef; - double BSIM3af; - double BSIM3kf; + double BSIM3oxideTrapDensityA; + double BSIM3oxideTrapDensityB; + double BSIM3oxideTrapDensityC; + double BSIM3em; + double BSIM3ef; + double BSIM3af; + double BSIM3kf; double BSIM3lintnoi; /* lint offset for noise calculation */ struct bsim3SizeDependParam *pSizeDependParamKnot; - + #ifdef USE_OMP int BSIM3InstCount; struct sBSIM3instance **BSIM3InstanceArray; @@ -866,7 +866,7 @@ typedef struct sBSIM3model unsigned BSIM3agsGiven :1; unsigned BSIM3a1Given :1; unsigned BSIM3a2Given :1; - unsigned BSIM3ketaGiven :1; + unsigned BSIM3ketaGiven :1; unsigned BSIM3nsubGiven :1; unsigned BSIM3npeakGiven :1; unsigned BSIM3ngateGiven :1; @@ -884,14 +884,14 @@ typedef struct sBSIM3model unsigned BSIM3k3bGiven :1; unsigned BSIM3w0Given :1; unsigned BSIM3nlxGiven :1; - unsigned BSIM3dvt0Given :1; - unsigned BSIM3dvt1Given :1; - unsigned BSIM3dvt2Given :1; - unsigned BSIM3dvt0wGiven :1; - unsigned BSIM3dvt1wGiven :1; - unsigned BSIM3dvt2wGiven :1; - unsigned BSIM3droutGiven :1; - unsigned BSIM3dsubGiven :1; + unsigned BSIM3dvt0Given :1; + unsigned BSIM3dvt1Given :1; + unsigned BSIM3dvt2Given :1; + unsigned BSIM3dvt0wGiven :1; + unsigned BSIM3dvt1wGiven :1; + unsigned BSIM3dvt2wGiven :1; + unsigned BSIM3droutGiven :1; + unsigned BSIM3dsubGiven :1; unsigned BSIM3vth0Given :1; unsigned BSIM3uaGiven :1; unsigned BSIM3ua1Given :1; @@ -902,20 +902,20 @@ typedef struct sBSIM3model unsigned BSIM3u0Given :1; unsigned BSIM3uteGiven :1; unsigned BSIM3voffGiven :1; - unsigned BSIM3rdswGiven :1; - unsigned BSIM3prwgGiven :1; - unsigned BSIM3prwbGiven :1; - unsigned BSIM3prtGiven :1; - unsigned BSIM3eta0Given :1; - unsigned BSIM3etabGiven :1; - unsigned BSIM3pclmGiven :1; - unsigned BSIM3pdibl1Given :1; - unsigned BSIM3pdibl2Given :1; - unsigned BSIM3pdiblbGiven :1; - unsigned BSIM3pscbe1Given :1; - unsigned BSIM3pscbe2Given :1; - unsigned BSIM3pvagGiven :1; - unsigned BSIM3deltaGiven :1; + unsigned BSIM3rdswGiven :1; + unsigned BSIM3prwgGiven :1; + unsigned BSIM3prwbGiven :1; + unsigned BSIM3prtGiven :1; + unsigned BSIM3eta0Given :1; + unsigned BSIM3etabGiven :1; + unsigned BSIM3pclmGiven :1; + unsigned BSIM3pdibl1Given :1; + unsigned BSIM3pdibl2Given :1; + unsigned BSIM3pdiblbGiven :1; + unsigned BSIM3pscbe1Given :1; + unsigned BSIM3pscbe2Given :1; + unsigned BSIM3pvagGiven :1; + unsigned BSIM3deltaGiven :1; unsigned BSIM3wrGiven :1; unsigned BSIM3dwgGiven :1; unsigned BSIM3dwbGiven :1; @@ -928,7 +928,7 @@ typedef struct sBSIM3model unsigned BSIM3vfbGiven :1; /* CV model */ - unsigned BSIM3elmGiven :1; + unsigned BSIM3elmGiven :1; unsigned BSIM3cgslGiven :1; unsigned BSIM3cgdlGiven :1; unsigned BSIM3ckappaGiven :1; @@ -963,7 +963,7 @@ typedef struct sBSIM3model unsigned BSIM3lagsGiven :1; unsigned BSIM3la1Given :1; unsigned BSIM3la2Given :1; - unsigned BSIM3lketaGiven :1; + unsigned BSIM3lketaGiven :1; unsigned BSIM3lnsubGiven :1; unsigned BSIM3lnpeakGiven :1; unsigned BSIM3lngateGiven :1; @@ -981,14 +981,14 @@ typedef struct sBSIM3model unsigned BSIM3lk3bGiven :1; unsigned BSIM3lw0Given :1; unsigned BSIM3lnlxGiven :1; - unsigned BSIM3ldvt0Given :1; - unsigned BSIM3ldvt1Given :1; - unsigned BSIM3ldvt2Given :1; - unsigned BSIM3ldvt0wGiven :1; - unsigned BSIM3ldvt1wGiven :1; - unsigned BSIM3ldvt2wGiven :1; - unsigned BSIM3ldroutGiven :1; - unsigned BSIM3ldsubGiven :1; + unsigned BSIM3ldvt0Given :1; + unsigned BSIM3ldvt1Given :1; + unsigned BSIM3ldvt2Given :1; + unsigned BSIM3ldvt0wGiven :1; + unsigned BSIM3ldvt1wGiven :1; + unsigned BSIM3ldvt2wGiven :1; + unsigned BSIM3ldroutGiven :1; + unsigned BSIM3ldsubGiven :1; unsigned BSIM3lvth0Given :1; unsigned BSIM3luaGiven :1; unsigned BSIM3lua1Given :1; @@ -999,20 +999,20 @@ typedef struct sBSIM3model unsigned BSIM3lu0Given :1; unsigned BSIM3luteGiven :1; unsigned BSIM3lvoffGiven :1; - unsigned BSIM3lrdswGiven :1; - unsigned BSIM3lprwgGiven :1; - unsigned BSIM3lprwbGiven :1; - unsigned BSIM3lprtGiven :1; - unsigned BSIM3leta0Given :1; - unsigned BSIM3letabGiven :1; - unsigned BSIM3lpclmGiven :1; - unsigned BSIM3lpdibl1Given :1; - unsigned BSIM3lpdibl2Given :1; - unsigned BSIM3lpdiblbGiven :1; - unsigned BSIM3lpscbe1Given :1; - unsigned BSIM3lpscbe2Given :1; - unsigned BSIM3lpvagGiven :1; - unsigned BSIM3ldeltaGiven :1; + unsigned BSIM3lrdswGiven :1; + unsigned BSIM3lprwgGiven :1; + unsigned BSIM3lprwbGiven :1; + unsigned BSIM3lprtGiven :1; + unsigned BSIM3leta0Given :1; + unsigned BSIM3letabGiven :1; + unsigned BSIM3lpclmGiven :1; + unsigned BSIM3lpdibl1Given :1; + unsigned BSIM3lpdibl2Given :1; + unsigned BSIM3lpdiblbGiven :1; + unsigned BSIM3lpscbe1Given :1; + unsigned BSIM3lpscbe2Given :1; + unsigned BSIM3lpvagGiven :1; + unsigned BSIM3ldeltaGiven :1; unsigned BSIM3lwrGiven :1; unsigned BSIM3ldwgGiven :1; unsigned BSIM3ldwbGiven :1; @@ -1024,7 +1024,7 @@ typedef struct sBSIM3model unsigned BSIM3lvfbGiven :1; /* CV model */ - unsigned BSIM3lelmGiven :1; + unsigned BSIM3lelmGiven :1; unsigned BSIM3lcgslGiven :1; unsigned BSIM3lcgdlGiven :1; unsigned BSIM3lckappaGiven :1; @@ -1050,7 +1050,7 @@ typedef struct sBSIM3model unsigned BSIM3wagsGiven :1; unsigned BSIM3wa1Given :1; unsigned BSIM3wa2Given :1; - unsigned BSIM3wketaGiven :1; + unsigned BSIM3wketaGiven :1; unsigned BSIM3wnsubGiven :1; unsigned BSIM3wnpeakGiven :1; unsigned BSIM3wngateGiven :1; @@ -1068,14 +1068,14 @@ typedef struct sBSIM3model unsigned BSIM3wk3bGiven :1; unsigned BSIM3ww0Given :1; unsigned BSIM3wnlxGiven :1; - unsigned BSIM3wdvt0Given :1; - unsigned BSIM3wdvt1Given :1; - unsigned BSIM3wdvt2Given :1; - unsigned BSIM3wdvt0wGiven :1; - unsigned BSIM3wdvt1wGiven :1; - unsigned BSIM3wdvt2wGiven :1; - unsigned BSIM3wdroutGiven :1; - unsigned BSIM3wdsubGiven :1; + unsigned BSIM3wdvt0Given :1; + unsigned BSIM3wdvt1Given :1; + unsigned BSIM3wdvt2Given :1; + unsigned BSIM3wdvt0wGiven :1; + unsigned BSIM3wdvt1wGiven :1; + unsigned BSIM3wdvt2wGiven :1; + unsigned BSIM3wdroutGiven :1; + unsigned BSIM3wdsubGiven :1; unsigned BSIM3wvth0Given :1; unsigned BSIM3wuaGiven :1; unsigned BSIM3wua1Given :1; @@ -1086,20 +1086,20 @@ typedef struct sBSIM3model unsigned BSIM3wu0Given :1; unsigned BSIM3wuteGiven :1; unsigned BSIM3wvoffGiven :1; - unsigned BSIM3wrdswGiven :1; - unsigned BSIM3wprwgGiven :1; - unsigned BSIM3wprwbGiven :1; - unsigned BSIM3wprtGiven :1; - unsigned BSIM3weta0Given :1; - unsigned BSIM3wetabGiven :1; - unsigned BSIM3wpclmGiven :1; - unsigned BSIM3wpdibl1Given :1; - unsigned BSIM3wpdibl2Given :1; - unsigned BSIM3wpdiblbGiven :1; - unsigned BSIM3wpscbe1Given :1; - unsigned BSIM3wpscbe2Given :1; - unsigned BSIM3wpvagGiven :1; - unsigned BSIM3wdeltaGiven :1; + unsigned BSIM3wrdswGiven :1; + unsigned BSIM3wprwgGiven :1; + unsigned BSIM3wprwbGiven :1; + unsigned BSIM3wprtGiven :1; + unsigned BSIM3weta0Given :1; + unsigned BSIM3wetabGiven :1; + unsigned BSIM3wpclmGiven :1; + unsigned BSIM3wpdibl1Given :1; + unsigned BSIM3wpdibl2Given :1; + unsigned BSIM3wpdiblbGiven :1; + unsigned BSIM3wpscbe1Given :1; + unsigned BSIM3wpscbe2Given :1; + unsigned BSIM3wpvagGiven :1; + unsigned BSIM3wdeltaGiven :1; unsigned BSIM3wwrGiven :1; unsigned BSIM3wdwgGiven :1; unsigned BSIM3wdwbGiven :1; @@ -1111,7 +1111,7 @@ typedef struct sBSIM3model unsigned BSIM3wvfbGiven :1; /* CV model */ - unsigned BSIM3welmGiven :1; + unsigned BSIM3welmGiven :1; unsigned BSIM3wcgslGiven :1; unsigned BSIM3wcgdlGiven :1; unsigned BSIM3wckappaGiven :1; @@ -1137,7 +1137,7 @@ typedef struct sBSIM3model unsigned BSIM3pagsGiven :1; unsigned BSIM3pa1Given :1; unsigned BSIM3pa2Given :1; - unsigned BSIM3pketaGiven :1; + unsigned BSIM3pketaGiven :1; unsigned BSIM3pnsubGiven :1; unsigned BSIM3pnpeakGiven :1; unsigned BSIM3pngateGiven :1; @@ -1155,14 +1155,14 @@ typedef struct sBSIM3model unsigned BSIM3pk3bGiven :1; unsigned BSIM3pw0Given :1; unsigned BSIM3pnlxGiven :1; - unsigned BSIM3pdvt0Given :1; - unsigned BSIM3pdvt1Given :1; - unsigned BSIM3pdvt2Given :1; - unsigned BSIM3pdvt0wGiven :1; - unsigned BSIM3pdvt1wGiven :1; - unsigned BSIM3pdvt2wGiven :1; - unsigned BSIM3pdroutGiven :1; - unsigned BSIM3pdsubGiven :1; + unsigned BSIM3pdvt0Given :1; + unsigned BSIM3pdvt1Given :1; + unsigned BSIM3pdvt2Given :1; + unsigned BSIM3pdvt0wGiven :1; + unsigned BSIM3pdvt1wGiven :1; + unsigned BSIM3pdvt2wGiven :1; + unsigned BSIM3pdroutGiven :1; + unsigned BSIM3pdsubGiven :1; unsigned BSIM3pvth0Given :1; unsigned BSIM3puaGiven :1; unsigned BSIM3pua1Given :1; @@ -1173,20 +1173,20 @@ typedef struct sBSIM3model unsigned BSIM3pu0Given :1; unsigned BSIM3puteGiven :1; unsigned BSIM3pvoffGiven :1; - unsigned BSIM3prdswGiven :1; - unsigned BSIM3pprwgGiven :1; - unsigned BSIM3pprwbGiven :1; - unsigned BSIM3pprtGiven :1; - unsigned BSIM3peta0Given :1; - unsigned BSIM3petabGiven :1; - unsigned BSIM3ppclmGiven :1; - unsigned BSIM3ppdibl1Given :1; - unsigned BSIM3ppdibl2Given :1; - unsigned BSIM3ppdiblbGiven :1; - unsigned BSIM3ppscbe1Given :1; - unsigned BSIM3ppscbe2Given :1; - unsigned BSIM3ppvagGiven :1; - unsigned BSIM3pdeltaGiven :1; + unsigned BSIM3prdswGiven :1; + unsigned BSIM3pprwgGiven :1; + unsigned BSIM3pprwbGiven :1; + unsigned BSIM3pprtGiven :1; + unsigned BSIM3peta0Given :1; + unsigned BSIM3petabGiven :1; + unsigned BSIM3ppclmGiven :1; + unsigned BSIM3ppdibl1Given :1; + unsigned BSIM3ppdibl2Given :1; + unsigned BSIM3ppdiblbGiven :1; + unsigned BSIM3ppscbe1Given :1; + unsigned BSIM3ppscbe2Given :1; + unsigned BSIM3ppvagGiven :1; + unsigned BSIM3pdeltaGiven :1; unsigned BSIM3pwrGiven :1; unsigned BSIM3pdwgGiven :1; unsigned BSIM3pdwbGiven :1; @@ -1198,7 +1198,7 @@ typedef struct sBSIM3model unsigned BSIM3pvfbGiven :1; /* CV model */ - unsigned BSIM3pelmGiven :1; + unsigned BSIM3pelmGiven :1; unsigned BSIM3pcgslGiven :1; unsigned BSIM3pcgdlGiven :1; unsigned BSIM3pckappaGiven :1; @@ -1231,15 +1231,15 @@ typedef struct sBSIM3model unsigned BSIM3bulkJctGateSideGradingCoeffGiven :1; unsigned BSIM3unitLengthGateSidewallJctCapGiven :1; unsigned BSIM3jctEmissionCoeffGiven :1; - unsigned BSIM3jctTempExponentGiven :1; + unsigned BSIM3jctTempExponentGiven :1; - unsigned BSIM3oxideTrapDensityAGiven :1; - unsigned BSIM3oxideTrapDensityBGiven :1; - unsigned BSIM3oxideTrapDensityCGiven :1; - unsigned BSIM3emGiven :1; - unsigned BSIM3efGiven :1; - unsigned BSIM3afGiven :1; - unsigned BSIM3kfGiven :1; + unsigned BSIM3oxideTrapDensityAGiven :1; + unsigned BSIM3oxideTrapDensityBGiven :1; + unsigned BSIM3oxideTrapDensityCGiven :1; + unsigned BSIM3emGiven :1; + unsigned BSIM3efGiven :1; + unsigned BSIM3afGiven :1; + unsigned BSIM3kfGiven :1; unsigned BSIM3lintnoiGiven :1; unsigned BSIM3LintGiven :1; @@ -1295,8 +1295,8 @@ typedef struct sBSIM3model /* model parameters */ #define BSIM3_MOD_CAPMOD 101 -#define BSIM3_MOD_MOBMOD 103 -#define BSIM3_MOD_NOIMOD 104 +#define BSIM3_MOD_MOBMOD 103 +#define BSIM3_MOD_NOIMOD 104 #define BSIM3_MOD_TOX 105 @@ -1310,14 +1310,14 @@ typedef struct sBSIM3model #define BSIM3_MOD_A0 113 #define BSIM3_MOD_A1 114 #define BSIM3_MOD_A2 115 -#define BSIM3_MOD_KETA 116 +#define BSIM3_MOD_KETA 116 #define BSIM3_MOD_NSUB 117 #define BSIM3_MOD_NPEAK 118 #define BSIM3_MOD_NGATE 120 #define BSIM3_MOD_GAMMA1 121 #define BSIM3_MOD_GAMMA2 122 #define BSIM3_MOD_VBX 123 -#define BSIM3_MOD_BINUNIT 124 +#define BSIM3_MOD_BINUNIT 124 #define BSIM3_MOD_VBM 125 @@ -1419,7 +1419,7 @@ typedef struct sBSIM3model #define BSIM3_MOD_LA0 258 #define BSIM3_MOD_LA1 259 #define BSIM3_MOD_LA2 260 -#define BSIM3_MOD_LKETA 261 +#define BSIM3_MOD_LKETA 261 #define BSIM3_MOD_LNSUB 262 #define BSIM3_MOD_LNPEAK 263 #define BSIM3_MOD_LNGATE 265 @@ -1487,7 +1487,7 @@ typedef struct sBSIM3model #define BSIM3_MOD_LCDSCD 327 #define BSIM3_MOD_LAGS 328 - + #define BSIM3_MOD_LFRINGE 331 #define BSIM3_MOD_LELM 332 @@ -1516,7 +1516,7 @@ typedef struct sBSIM3model #define BSIM3_MOD_WA0 388 #define BSIM3_MOD_WA1 389 #define BSIM3_MOD_WA2 390 -#define BSIM3_MOD_WKETA 391 +#define BSIM3_MOD_WKETA 391 #define BSIM3_MOD_WNSUB 392 #define BSIM3_MOD_WNPEAK 393 #define BSIM3_MOD_WNGATE 395 @@ -1613,7 +1613,7 @@ typedef struct sBSIM3model #define BSIM3_MOD_PA0 518 #define BSIM3_MOD_PA1 519 #define BSIM3_MOD_PA2 520 -#define BSIM3_MOD_PKETA 521 +#define BSIM3_MOD_PKETA 521 #define BSIM3_MOD_PNSUB 522 #define BSIM3_MOD_PNPEAK 523 #define BSIM3_MOD_PNGATE 525 @@ -1810,8 +1810,8 @@ typedef struct sBSIM3model #include "bsim3ext.h" extern void BSIM3evaluate(double,double,double,BSIM3instance*,BSIM3model*, - double*,double*,double*, double*, double*, double*, double*, - double*, double*, double*, double*, double*, double*, double*, + double*,double*,double*, double*, double*, double*, double*, + double*, double*, double*, double*, double*, double*, double*, double*, double*, double*, double*, CKTcircuit*); extern int BSIM3debug(BSIM3model*, BSIM3instance*, CKTcircuit*, int); extern int BSIM3checkModel(BSIM3model*, BSIM3instance*, CKTcircuit*);