From f6131887283fbb4d621b4c83a9ae5409dcc63366 Mon Sep 17 00:00:00 2001 From: dwarning Date: Sun, 1 Jan 2023 17:53:17 +0100 Subject: [PATCH] adaption trap tunnel currents for bsim3.2 --- src/spicelib/devices/bsim3v32/b3v32.c | 37 ++++++ src/spicelib/devices/bsim3v32/b3v32ld.c | 133 ++++++++++++++++++++ src/spicelib/devices/bsim3v32/b3v32mask.c | 98 +++++++++++++++ src/spicelib/devices/bsim3v32/b3v32mpar.c | 130 +++++++++++++++++++ src/spicelib/devices/bsim3v32/b3v32set.c | 68 ++++++++++ src/spicelib/devices/bsim3v32/b3v32temp.c | 42 +++++++ src/spicelib/devices/bsim3v32/bsim3v32def.h | 124 ++++++++++++++++++ 7 files changed, 632 insertions(+) diff --git a/src/spicelib/devices/bsim3v32/b3v32.c b/src/spicelib/devices/bsim3v32/b3v32.c index 8b38ff9b3..b276dd9b2 100644 --- a/src/spicelib/devices/bsim3v32/b3v32.c +++ b/src/spicelib/devices/bsim3v32/b3v32.c @@ -512,6 +512,43 @@ IOP("vgbr_max", BSIM3v32_MOD_VGBR_MAX, IF_REAL, "maximum voltage G-B branch"), IOP("vbsr_max", BSIM3v32_MOD_VBSR_MAX, IF_REAL, "maximum voltage B-S branch"), IOP("vbdr_max", BSIM3v32_MOD_VBDR_MAX, IF_REAL, "maximum voltage B-D branch"), +/* trap-assisted tunneling current enhancement */ +IOP("bsim4diode", BSIM3v32_MOD_BSIM4DIODE, IF_INTEGER, "flag invoking trap-assisted diode model"), +IOP("jtss", BSIM3v32_MOD_JTSS, IF_REAL, "Bottom trap-assisted saturation current density"), +IOP("jtsd", BSIM3v32_MOD_JTSD, IF_REAL, "Bottom trap-assisted saturation current density"), +IOP("jtssws", BSIM3v32_MOD_JTSSWS, IF_REAL, "STI sidewall trap-assisted saturation current density"), +IOP("jtsswd", BSIM3v32_MOD_JTSSWD, IF_REAL, "STI sidewall trap-assisted saturation current density"), +IOP("jtsswgs", BSIM3v32_MOD_JTSSWGS, IF_REAL, "Gate-edge sidewall trap-assisted saturation current density"), +IOP("jtsswgd", BSIM3v32_MOD_JTSSWGD, IF_REAL, "Gate-edge sidewall trap-assisted saturation current density"), + +IOP("njts", BSIM3v32_MOD_NJTS, IF_REAL, "Non-ideality factor for JTSS and JTSD"), +IOP("njtsd", BSIM3v32_MOD_NJTSD, IF_REAL, "Non-ideality factor for JTSD"), +IOP("njtssw", BSIM3v32_MOD_NJTSSW, IF_REAL, "Non-ideality factor for JTSSWS and JTSSWD"), +IOP("njtsswd", BSIM3v32_MOD_NJTSSWD, IF_REAL, "Non-ideality factor for JTSSWS"), +IOP("njtsswg", BSIM3v32_MOD_NJTSSWG, IF_REAL, "Non-ideality factor for JTSSWGS"), +IOP("njtsswgd", BSIM3v32_MOD_NJTSSWGD, IF_REAL, "Non-ideality factor for JTSSWGD"), + +IOP("vtss", BSIM3v32_MOD_VTSS, IF_REAL, "Bottom source junction trap-assisted current voltage dependent parameter"), +IOP("vtsd", BSIM3v32_MOD_VTSD, IF_REAL, "Bottom drain junction trap-assisted current voltage dependent parameter"), +IOP("vtssws", BSIM3v32_MOD_VTSSWS, IF_REAL, "Unit length trap-assisted current voltage dependent parameter for sidewall source junctio"), +IOP("vtsswd", BSIM3v32_MOD_VTSSWD, IF_REAL, "Unit length trap-assisted current voltage dependent parameter for sidewall drain junction"), +IOP("vtsswgs", BSIM3v32_MOD_VTSSWGS, IF_REAL, "Unit length trap-assisted current voltage dependent parameter for gate-edge sidewall source junction"), +IOP("vtsswgd", BSIM3v32_MOD_VTSSWGD, IF_REAL, "Unit length trap-assisted current voltage dependent parameter for gate-edge sidewall drain junction"), + +IOP("xtss", BSIM3v32_MOD_XTSS, IF_REAL, "Power dependence of JTSS, JTSD on temperature"), +IOP("xtsd", BSIM3v32_MOD_XTSD, IF_REAL, "Power dependence of JTSS, JTSD on temperature"), +IOP("xtssws", BSIM3v32_MOD_XTSSWS, IF_REAL, "Power dependence of JTSSWS, JTSSWD on temperature"), +IOP("xtsswd", BSIM3v32_MOD_XTSSWD, IF_REAL, "Power dependence of JTSSWS, JTSSWD on temperature"), +IOP("xtsswgs", BSIM3v32_MOD_XTSSWGS, IF_REAL, "Power dependence of JTSSWGS, JTSSWGD on temperature"), +IOP("xtsswgd", BSIM3v32_MOD_XTSSWGD, IF_REAL, "Power dependence of JTSSWGS, JTSSWGD on temperature"), + +IOP("tnjts", BSIM3v32_MOD_TNJTS, IF_REAL, "Temperature coefficient for NJTS"), +IOP("tnjtssw", BSIM3v32_MOD_TNJTSSW, IF_REAL, "Temperature coefficient for NJTSD"), +IOP("tnjtsswg", BSIM3v32_MOD_TNJTSSWG, IF_REAL, "Temperature coefficient for NJTSSW"), +IOP("tnjtsd", BSIM3v32_MOD_TNJTSD, IF_REAL, "Temperature coefficient for NJTSSWD"), +IOP("tnjtsswd", BSIM3v32_MOD_TNJTSSWD, IF_REAL, "Temperature coefficient for NJTSSWG"), +IOP("tnjtsswgd", BSIM3v32_MOD_TNJTSSWGD, IF_REAL, "Temperature coefficient for NJTSSWGD"), + IP( "nmos", BSIM3v32_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"), IP( "pmos", BSIM3v32_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"), }; diff --git a/src/spicelib/devices/bsim3v32/b3v32ld.c b/src/spicelib/devices/bsim3v32/b3v32ld.c index 60a8c3261..b891d218a 100644 --- a/src/spicelib/devices/bsim3v32/b3v32ld.c +++ b/src/spicelib/devices/bsim3v32/b3v32ld.c @@ -30,6 +30,18 @@ #define DELTA_2 0.02 #define DELTA_3 0.02 #define DELTA_4 0.02 +#define DEXP(A,B,C) { \ + if (A > EXP_THRESHOLD) { \ + B = MAX_EXP*(1.0+(A)-EXP_THRESHOLD); \ + C = MAX_EXP; \ + } else if (A < -EXP_THRESHOLD) { \ + B = MIN_EXP; \ + C = 0; \ + } else { \ + B = exp(A); \ + C = B; \ + } \ + } #ifdef USE_OMP int BSIM3v32LoadOMP(BSIM3v32instance *here, CKTcircuit *ckt); @@ -499,6 +511,127 @@ for (; model != NULL; model = BSIM3v32nextModel(model)) } } } + + /* trap-assisted tunneling current enhancement */ + if ((model->BSIM3v32acmMod == 12) && (model->BSIM3v32bsim4diodeGiven)) + { + double dT4_dVb, dT5_dVb, dT6_dVb; + double Nvtmrss = model->BSIM3v32vtm * model->BSIM3v32njtstemp; + double Nvtmrsd = model->BSIM3v32vtm * model->BSIM3v32njtsdtemp; + double Nvtmrssws = model->BSIM3v32vtm * model->BSIM3v32njtsswtemp; + double Nvtmrsswd = model->BSIM3v32vtm * model->BSIM3v32njtsswdtemp; + double Nvtmrsswgs = model->BSIM3v32vtm * model->BSIM3v32njtsswgtemp; + double Nvtmrsswgd = model->BSIM3v32vtm * model->BSIM3v32njtsswgdtemp; + + if (model->BSIM3v32jtss > 0.0) + { + if ((model->BSIM3v32vtss - vbs) < (model->BSIM3v32vtss * 1e-3)) + { T9 = 1.0e3; + T0 = - vbs / Nvtmrss * T9; + DEXP(T0, T1, T10); + dT1_dVb = T10 / Nvtmrss * T9; + } else { + T9 = 1.0 / (model->BSIM3v32vtss - vbs); + T0 = -vbs / Nvtmrss * model->BSIM3v32vtss * T9; + dT0_dVb = model->BSIM3v32vtss / Nvtmrss * (T9 + vbs * T9 * T9) ; + DEXP(T0, T1, T10); + dT1_dVb = T10 * dT0_dVb; + } + here->BSIM3v32gbs += here->BSIM3v32sourceArea * model->BSIM3v32jtsstemp * dT1_dVb; + here->BSIM3v32cbs -= here->BSIM3v32sourceArea * model->BSIM3v32jtsstemp * (T1 - 1.0); + } + + if (model->BSIM3v32jtssws > 0.0) + { + if ((model->BSIM3v32vtsd - vbd) < (model->BSIM3v32vtsd * 1e-3) ) + { T9 = 1.0e3; + T0 = -vbd / Nvtmrsd * T9; + DEXP(T0, T2, T10); + dT2_dVb = T10 / Nvtmrsd * T9; + } else { + T9 = 1.0 / (model->BSIM3v32vtsd - vbd); + T0 = -vbd / Nvtmrsd * model->BSIM3v32vtsd * T9; + dT0_dVb = model->BSIM3v32vtsd / Nvtmrsd * (T9 + vbd * T9 * T9) ; + DEXP(T0, T2, T10); + dT2_dVb = T10 * dT0_dVb; + } + here->BSIM3v32gbs += here->BSIM3v32sourcePerimeter * model->BSIM3v32jtsswstemp * dT2_dVb; + here->BSIM3v32cbs -= here->BSIM3v32sourcePerimeter * model->BSIM3v32jtsswstemp * (T2 - 1.0); + } + + if (model->BSIM3v32jtsswgs > 0.0) + { + if ((model->BSIM3v32vtssws - vbs) < (model->BSIM3v32vtssws * 1e-3) ) + { T9 = 1.0e3; + T0 = -vbs / Nvtmrssws * T9; + DEXP(T0, T3, T10); + dT3_dVb = T10 / Nvtmrssws * T9; + } else { + T9 = 1.0 / (model->BSIM3v32vtssws - vbs); + T0 = -vbs / Nvtmrssws * model->BSIM3v32vtssws * T9; + dT0_dVb = model->BSIM3v32vtssws / Nvtmrssws * (T9 + vbs * T9 * T9) ; + DEXP(T0, T3, T10); + dT3_dVb = T10 * dT0_dVb; + } + here->BSIM3v32gbs += pParam->BSIM3v32weff * model->BSIM3v32jtsswgstemp * dT3_dVb; + here->BSIM3v32cbs -= pParam->BSIM3v32weff * model->BSIM3v32jtsswgstemp * (T3 - 1.0); + } + + if (model->BSIM3v32jtsd > 0.0) + { + if ((model->BSIM3v32vtsswd - vbd) < (model->BSIM3v32vtsswd * 1e-3) ) + { T9 = 1.0e3; + T0 = -vbd / Nvtmrsswd * T9; + DEXP(T0, T4, T10); + dT4_dVb = T10 / Nvtmrsswd * T9; + } else { + T9 = 1.0 / (model->BSIM3v32vtsswd - vbd); + T0 = -vbd / Nvtmrsswd * model->BSIM3v32vtsswd * T9; + dT0_dVb = model->BSIM3v32vtsswd / Nvtmrsswd * (T9 + vbd * T9 * T9) ; + DEXP(T0, T4, T10); + dT4_dVb = T10 * dT0_dVb; + } + here->BSIM3v32gbd += here->BSIM3v32drainArea * model->BSIM3v32jtsdtemp * dT4_dVb; + here->BSIM3v32cbd -= here->BSIM3v32drainArea * model->BSIM3v32jtsdtemp * (T4 - 1.0); + } + + if (model->BSIM3v32jtsswd > 0.0) + { + if ((model->BSIM3v32vtsswgs - vbs) < (model->BSIM3v32vtsswgs * 1e-3) ) + { T9 = 1.0e3; + T0 = -vbs / Nvtmrsswgs * T9; + DEXP(T0, T5, T10); + dT5_dVb = T10 / Nvtmrsswgs * T9; + } else { + T9 = 1.0 / (model->BSIM3v32vtsswgs - vbs); + T0 = -vbs / Nvtmrsswgs * model->BSIM3v32vtsswgs * T9; + dT0_dVb = model->BSIM3v32vtsswgs / Nvtmrsswgs * (T9 + vbs * T9 * T9) ; + DEXP(T0, T5, T10); + dT5_dVb = T10 * dT0_dVb; + } + here->BSIM3v32gbd += here->BSIM3v32drainPerimeter * model->BSIM3v32jtsswdtemp * dT5_dVb; + here->BSIM3v32cbd -= here->BSIM3v32drainPerimeter * model->BSIM3v32jtsswdtemp * (T5 - 1.0); + } + + if (model->BSIM3v32jtsswgd > 0.0) + { + if ((model->BSIM3v32vtsswgd - vbd) < (model->BSIM3v32vtsswgd * 1e-3) ) + { T9 = 1.0e3; + T0 = -vbd / Nvtmrsswgd * T9; + DEXP(T0, T6, T10); + dT6_dVb = T10 / Nvtmrsswgd * T9; + } else { + T9 = 1.0 / (model->BSIM3v32vtsswgd - vbd); + T0 = -vbd / Nvtmrsswgd * model->BSIM3v32vtsswgd * T9; + dT0_dVb = model->BSIM3v32vtsswgd / Nvtmrsswgd * (T9 + vbd * T9 * T9) ; + DEXP(T0, T6, T10); + dT6_dVb = T10 * dT0_dVb; + } + here->BSIM3v32gbd += pParam->BSIM3v32weff * model->BSIM3v32jtsswgdtemp * dT6_dVb; + here->BSIM3v32cbd -= pParam->BSIM3v32weff * model->BSIM3v32jtsswgdtemp * (T6 - 1.0); + } + + } /* End of diode DC model */ if (vds >= 0.0) diff --git a/src/spicelib/devices/bsim3v32/b3v32mask.c b/src/spicelib/devices/bsim3v32/b3v32mask.c index 15ba67204..e43c60d35 100644 --- a/src/spicelib/devices/bsim3v32/b3v32mask.c +++ b/src/spicelib/devices/bsim3v32/b3v32mask.c @@ -1312,6 +1312,104 @@ BSIM3v32mAsk (CKTcircuit *ckt, GENmodel *inst, int which, IFvalue *value) case BSIM3v32_MOD_VBDR_MAX: value->rValue = model->BSIM3v32vbdrMax; return(OK); +/* trap-assisted tunneling current enhancement */ + case BSIM3v32_MOD_BSIM4DIODE: + value->iValue = model->BSIM3v32bsim4diode; + return(OK); + case BSIM3v32_MOD_JTSS: + value->rValue = model->BSIM3v32jtss; + return(OK); + case BSIM3v32_MOD_JTSD: + value->rValue = model->BSIM3v32jtsd; + return(OK); + case BSIM3v32_MOD_JTSSWS: + value->rValue = model->BSIM3v32jtssws; + return(OK); + case BSIM3v32_MOD_JTSSWD: + value->rValue = model->BSIM3v32jtsswd; + return(OK); + case BSIM3v32_MOD_JTSSWGS: + value->rValue = model->BSIM3v32jtsswgs; + return(OK); + case BSIM3v32_MOD_JTSSWGD: + value->rValue = model->BSIM3v32jtsswgd; + return(OK); + + case BSIM3v32_MOD_NJTS: + value->rValue = model->BSIM3v32njts; + return(OK); + case BSIM3v32_MOD_NJTSSW: + value->rValue = model->BSIM3v32njtssw; + return(OK); + case BSIM3v32_MOD_NJTSSWG: + value->rValue = model->BSIM3v32njtsswg; + return(OK); + case BSIM3v32_MOD_NJTSD: + value->rValue = model->BSIM3v32njtsd; + return(OK); + case BSIM3v32_MOD_NJTSSWD: + value->rValue = model->BSIM3v32njtsswd; + return(OK); + case BSIM3v32_MOD_NJTSSWGD: + value->rValue = model->BSIM3v32njtsswgd; + return(OK); + + case BSIM3v32_MOD_VTSS: + value->rValue = model->BSIM3v32vtss; + return(OK); + case BSIM3v32_MOD_VTSD: + value->rValue = model->BSIM3v32vtsd; + return(OK); + case BSIM3v32_MOD_VTSSWS: + value->rValue = model->BSIM3v32vtssws; + return(OK); + case BSIM3v32_MOD_VTSSWD: + value->rValue = model->BSIM3v32vtsswd; + return(OK); + case BSIM3v32_MOD_VTSSWGS: + value->rValue = model->BSIM3v32vtsswgs; + return(OK); + case BSIM3v32_MOD_VTSSWGD: + value->rValue = model->BSIM3v32vtsswgd; + return(OK); + + case BSIM3v32_MOD_XTSS: + value->rValue = model->BSIM3v32xtss; + return(OK); + case BSIM3v32_MOD_XTSD: + value->rValue = model->BSIM3v32xtsd; + return(OK); + case BSIM3v32_MOD_XTSSWS: + value->rValue = model->BSIM3v32xtssws; + return(OK); + case BSIM3v32_MOD_XTSSWD: + value->rValue = model->BSIM3v32xtsswd; + return(OK); + case BSIM3v32_MOD_XTSSWGS: + value->rValue = model->BSIM3v32xtsswgs; + return(OK); + case BSIM3v32_MOD_XTSSWGD: + value->rValue = model->BSIM3v32xtsswgd; + return(OK); + + case BSIM3v32_MOD_TNJTS: + value->rValue = model->BSIM3v32tnjts; + return(OK); + case BSIM3v32_MOD_TNJTSSW: + value->rValue = model->BSIM3v32tnjtssw; + return(OK); + case BSIM3v32_MOD_TNJTSSWG: + value->rValue = model->BSIM3v32tnjtsswg; + return(OK); + case BSIM3v32_MOD_TNJTSD: + value->rValue = model->BSIM3v32tnjtsd; + return(OK); + case BSIM3v32_MOD_TNJTSSWD: + value->rValue = model->BSIM3v32tnjtsswd; + return(OK); + case BSIM3v32_MOD_TNJTSSWGD: + value->rValue = model->BSIM3v32tnjtsswgd; + return(OK); default: return(E_BADPARM); diff --git a/src/spicelib/devices/bsim3v32/b3v32mpar.c b/src/spicelib/devices/bsim3v32/b3v32mpar.c index 33112c05a..7a1549c1b 100644 --- a/src/spicelib/devices/bsim3v32/b3v32mpar.c +++ b/src/spicelib/devices/bsim3v32/b3v32mpar.c @@ -1761,6 +1761,136 @@ BSIM3v32mParam(int param, IFvalue *value, GENmodel *inMod) mod->BSIM3v32vbdrMaxGiven = TRUE; break; +/* trap-assisted tunneling current enhancement */ + case BSIM3v32_MOD_BSIM4DIODE: + mod->BSIM3v32bsim4diode = value->iValue; + mod->BSIM3v32bsim4diodeGiven = TRUE; + break; + case BSIM3v32_MOD_JTSS: + mod->BSIM3v32jtss = value->rValue; + mod->BSIM3v32jtssGiven = TRUE; + break; + case BSIM3v32_MOD_JTSD: + mod->BSIM3v32jtsd = value->rValue; + mod->BSIM3v32jtsdGiven = TRUE; + break; + case BSIM3v32_MOD_JTSSWS: + mod->BSIM3v32jtssws = value->rValue; + mod->BSIM3v32jtsswsGiven = TRUE; + break; + case BSIM3v32_MOD_JTSSWD: + mod->BSIM3v32jtsswd = value->rValue; + mod->BSIM3v32jtsswdGiven = TRUE; + break; + case BSIM3v32_MOD_JTSSWGS: + mod->BSIM3v32jtsswgs = value->rValue; + mod->BSIM3v32jtsswgsGiven = TRUE; + break; + case BSIM3v32_MOD_JTSSWGD: + mod->BSIM3v32jtsswgd = value->rValue; + mod->BSIM3v32jtsswgdGiven = TRUE; + break; + + case BSIM3v32_MOD_NJTS: + mod->BSIM3v32njts = value->rValue; + mod->BSIM3v32njtsGiven = TRUE; + break; + case BSIM3v32_MOD_NJTSSW: + mod->BSIM3v32njtssw = value->rValue; + mod->BSIM3v32njtsswGiven = TRUE; + break; + case BSIM3v32_MOD_NJTSSWG: + mod->BSIM3v32njtsswg = value->rValue; + mod->BSIM3v32njtsswgGiven = TRUE; + break; + case BSIM3v32_MOD_NJTSD: + mod->BSIM3v32njtsd = value->rValue; + mod->BSIM3v32njtsdGiven = TRUE; + break; + case BSIM3v32_MOD_NJTSSWD: + mod->BSIM3v32njtsswd = value->rValue; + mod->BSIM3v32njtsswdGiven = TRUE; + break; + case BSIM3v32_MOD_NJTSSWGD: + mod->BSIM3v32njtsswgd = value->rValue; + mod->BSIM3v32njtsswgdGiven = TRUE; + break; + + case BSIM3v32_MOD_VTSS: + mod->BSIM3v32vtss = value->rValue; + mod->BSIM3v32vtssGiven = TRUE; + break; + case BSIM3v32_MOD_VTSD: + mod->BSIM3v32vtsd = value->rValue; + mod->BSIM3v32vtsdGiven = TRUE; + break; + case BSIM3v32_MOD_VTSSWS: + mod->BSIM3v32vtssws = value->rValue; + mod->BSIM3v32vtsswsGiven = TRUE; + break; + case BSIM3v32_MOD_VTSSWD: + mod->BSIM3v32vtsswd = value->rValue; + mod->BSIM3v32vtsswdGiven = TRUE; + break; + case BSIM3v32_MOD_VTSSWGS: + mod->BSIM3v32vtsswgs = value->rValue; + mod->BSIM3v32vtsswgsGiven = TRUE; + break; + case BSIM3v32_MOD_VTSSWGD: + mod->BSIM3v32vtsswgd = value->rValue; + mod->BSIM3v32vtsswgdGiven = TRUE; + break; + + case BSIM3v32_MOD_XTSS: + mod->BSIM3v32xtss = value->rValue; + mod->BSIM3v32xtssGiven = TRUE; + break; + case BSIM3v32_MOD_XTSD: + mod->BSIM3v32xtsd = value->rValue; + mod->BSIM3v32xtsdGiven = TRUE; + break; + case BSIM3v32_MOD_XTSSWS: + mod->BSIM3v32xtssws = value->rValue; + mod->BSIM3v32xtsswsGiven = TRUE; + break; + case BSIM3v32_MOD_XTSSWD: + mod->BSIM3v32xtsswd = value->rValue; + mod->BSIM3v32xtsswdGiven = TRUE; + break; + case BSIM3v32_MOD_XTSSWGS: + mod->BSIM3v32xtsswgs = value->rValue; + mod->BSIM3v32xtsswgsGiven = TRUE; + break; + case BSIM3v32_MOD_XTSSWGD: + mod->BSIM3v32xtsswgd = value->rValue; + mod->BSIM3v32xtsswgdGiven = TRUE; + break; + + case BSIM3v32_MOD_TNJTS: + mod->BSIM3v32tnjts = value->rValue; + mod->BSIM3v32tnjtsGiven = TRUE; + break; + case BSIM3v32_MOD_TNJTSSW: + mod->BSIM3v32tnjtssw = value->rValue; + mod->BSIM3v32tnjtsswGiven = TRUE; + break; + case BSIM3v32_MOD_TNJTSSWG: + mod->BSIM3v32tnjtsswg = value->rValue; + mod->BSIM3v32tnjtsswgGiven = TRUE; + break; + case BSIM3v32_MOD_TNJTSD: + mod->BSIM3v32tnjtsd = value->rValue; + mod->BSIM3v32tnjtsdGiven = TRUE; + break; + case BSIM3v32_MOD_TNJTSSWD: + mod->BSIM3v32tnjtsswd = value->rValue; + mod->BSIM3v32tnjtsswdGiven = TRUE; + break; + case BSIM3v32_MOD_TNJTSSWGD: + mod->BSIM3v32tnjtsswgd = value->rValue; + mod->BSIM3v32tnjtsswgdGiven = TRUE; + break; + case BSIM3v32_MOD_NMOS : if(value->iValue) { mod->BSIM3v32type = 1; diff --git a/src/spicelib/devices/bsim3v32/b3v32set.c b/src/spicelib/devices/bsim3v32/b3v32set.c index 919b0f2ee..9d2dfb54b 100644 --- a/src/spicelib/devices/bsim3v32/b3v32set.c +++ b/src/spicelib/devices/bsim3v32/b3v32set.c @@ -935,6 +935,74 @@ BSIM3v32instance **InstArray; if (!model->BSIM3v32vbdrMaxGiven) model->BSIM3v32vbdrMax = 1e99; +/* trap-assisted tunneling current enhancement */ + if (!model->BSIM3v32bsim4diodeGiven) + model->BSIM3v32bsim4diode = 0; + if (!model->BSIM3v32jtssGiven) + model->BSIM3v32jtss = 0.0; + if (!model->BSIM3v32jtsdGiven) + model->BSIM3v32jtsd = model->BSIM3v32jtss; + if (!model->BSIM3v32jtsswsGiven) + model->BSIM3v32jtssws = 0.0; + if (!model->BSIM3v32jtsswdGiven) + model->BSIM3v32jtsswd = model->BSIM3v32jtssws; + if (!model->BSIM3v32jtsswgsGiven) + model->BSIM3v32jtsswgs = 0.0; + if (!model->BSIM3v32jtsswgdGiven) + model->BSIM3v32jtsswgd = model->BSIM3v32jtsswgs; + + if (!model->BSIM3v32njtsGiven) + model->BSIM3v32njts = 20.0; + if (!model->BSIM3v32njtsswGiven) + model->BSIM3v32njtssw = 20.0; + if (!model->BSIM3v32njtsswgGiven) + model->BSIM3v32njtsswg = 20.0; + if (!model->BSIM3v32njtsdGiven) + model->BSIM3v32njtsd = model->BSIM3v32njts; + if (!model->BSIM3v32njtsswdGiven) + model->BSIM3v32njtsswd = model->BSIM3v32njtssw; + if (!model->BSIM3v32njtsswgdGiven) + model->BSIM3v32njtsswgd = model->BSIM3v32njtsswg; + + if (!model->BSIM3v32vtssGiven) + model->BSIM3v32vtss = 10.0; + if (!model->BSIM3v32vtsdGiven) + model->BSIM3v32vtsd = model->BSIM3v32vtss; + if (!model->BSIM3v32vtsswsGiven) + model->BSIM3v32vtssws = 10.0; + if (!model->BSIM3v32vtsswdGiven) + model->BSIM3v32vtsswd = model->BSIM3v32vtssws; + if (!model->BSIM3v32vtsswgsGiven) + model->BSIM3v32vtsswgs = 10.0; + if (!model->BSIM3v32vtsswgdGiven) + model->BSIM3v32vtsswgd = model->BSIM3v32vtsswgs; + + if (!model->BSIM3v32xtssGiven) + model->BSIM3v32xtss = 0.02; + if (!model->BSIM3v32xtsdGiven) + model->BSIM3v32xtsd = 0.02; + if (!model->BSIM3v32xtsswsGiven) + model->BSIM3v32xtssws = 0.02; + if (!model->BSIM3v32xtsswdGiven) + model->BSIM3v32xtsswd = 0.02; + if (!model->BSIM3v32xtsswgsGiven) + model->BSIM3v32xtsswgs = 0.02; + if (!model->BSIM3v32xtsswgdGiven) + model->BSIM3v32xtsswgd = 0.02; + + if (!model->BSIM3v32tnjtsGiven) + model->BSIM3v32tnjts = 0.0; + if (!model->BSIM3v32tnjtsswGiven) + model->BSIM3v32tnjtssw = 0.0; + if (!model->BSIM3v32tnjtsswgGiven) + model->BSIM3v32tnjtsswg = 0.0; + if (!model->BSIM3v32tnjtsdGiven) + model->BSIM3v32tnjtsd = 0.0; + if (!model->BSIM3v32tnjtsswdGiven) + model->BSIM3v32tnjtsswd = 0.0; + if (!model->BSIM3v32tnjtsswgdGiven) + model->BSIM3v32tnjtsswgd = 0.0; + /* loop through all the instances of the model */ for (here = BSIM3v32instances(model); here != NULL ; here=BSIM3v32nextInstance(here)) diff --git a/src/spicelib/devices/bsim3v32/b3v32temp.c b/src/spicelib/devices/bsim3v32/b3v32temp.c index 18550edf6..504bd5ce2 100644 --- a/src/spicelib/devices/bsim3v32/b3v32temp.c +++ b/src/spicelib/devices/bsim3v32/b3v32temp.c @@ -27,6 +27,15 @@ #define MIN_EXP 1.713908431e-15 #define EXP_THRESHOLD 34.0 #define Charge_q 1.60219e-19 +#define DEXP(A,B) { \ + if (A > EXP_THRESHOLD) { \ + B = MAX_EXP*(1.0+(A)-EXP_THRESHOLD); \ + } else if (A < -EXP_THRESHOLD) { \ + B = MIN_EXP; \ + } else { \ + B = exp(A); \ + } \ + } /* ARGSUSED */ int @@ -214,6 +223,39 @@ int Size_Not_Found, error; } /* End of junction capacitance */ + /* trap-assisted tunneling current enhancement */ + if ((model->BSIM3v32acmMod == 12) && (model->BSIM3v32bsim4diodeGiven)) + { + double T6, T7, T9; + T0 = (TRatio - 1.0); + model->BSIM3v32njtstemp = model->BSIM3v32njts * (1.0 + model->BSIM3v32tnjts * T0); + model->BSIM3v32njtsdtemp = model->BSIM3v32njtsd * (1.0 + model->BSIM3v32tnjtsd * T0); + model->BSIM3v32njtsswtemp = model->BSIM3v32njtssw * (1.0 + model->BSIM3v32tnjtssw * T0); + model->BSIM3v32njtsswdtemp = model->BSIM3v32njtsswd * (1.0 + model->BSIM3v32tnjtsswd * T0); + model->BSIM3v32njtsswgtemp = model->BSIM3v32njtsswg * (1.0 + model->BSIM3v32tnjtsswg * T0); + model->BSIM3v32njtsswgdtemp = model->BSIM3v32njtsswgd * (1.0 + model->BSIM3v32tnjtsswgd * T0); + T7 = Eg0 / model->BSIM3v32vtm * T0; + T9 = model->BSIM3v32xtss * T7; + DEXP(T9, T1); + T9 = model->BSIM3v32xtsd * T7; + DEXP(T9, T2); + T9 = model->BSIM3v32xtssws * T7; + DEXP(T9, T3); + T9 = model->BSIM3v32xtsswd * T7; + DEXP(T9, T4); + T9 = model->BSIM3v32xtsswgs * T7; + DEXP(T9, T5); + T9 = model->BSIM3v32xtsswgd * T7; + DEXP(T9, T6); + model->BSIM3v32jtsstemp = T1 * model->BSIM3v32jtss; + model->BSIM3v32jtsdtemp = T2 * model->BSIM3v32jtsd; + model->BSIM3v32jtsswstemp = T3 * model->BSIM3v32jtssws; + model->BSIM3v32jtsswdtemp = T4 * model->BSIM3v32jtsswd; + model->BSIM3v32jtsswgstemp = T5 * model->BSIM3v32jtsswgs; + model->BSIM3v32jtsswgdtemp = T6 * model->BSIM3v32jtsswgd; + + } + /* loop through all the instances of the model */ /* MCJ: Length and Width not initialized */ for (here = BSIM3v32instances(model); here != NULL; diff --git a/src/spicelib/devices/bsim3v32/bsim3v32def.h b/src/spicelib/devices/bsim3v32/bsim3v32def.h index 85192c57f..5d7e5fd94 100644 --- a/src/spicelib/devices/bsim3v32/bsim3v32def.h +++ b/src/spicelib/devices/bsim3v32/bsim3v32def.h @@ -886,6 +886,56 @@ typedef struct sBSIM3v32model double BSIM3v32vbsrMax; double BSIM3v32vbdrMax; +/* trap-assisted tunneling current enhancement */ + int BSIM3v32bsim4diode; + double BSIM3v32jtss; + double BSIM3v32jtsd; + double BSIM3v32jtssws; + double BSIM3v32jtsswd; + double BSIM3v32jtsswgs; + double BSIM3v32jtsswgd; + + double BSIM3v32njts; + double BSIM3v32njtssw; + double BSIM3v32njtsswg; + double BSIM3v32njtsd; + double BSIM3v32njtsswd; + double BSIM3v32njtsswgd; + + double BSIM3v32vtss; + double BSIM3v32vtsd; + double BSIM3v32vtssws; + double BSIM3v32vtsswd; + double BSIM3v32vtsswgs; + double BSIM3v32vtsswgd; + + double BSIM3v32xtss; + double BSIM3v32xtsd; + double BSIM3v32xtssws; + double BSIM3v32xtsswd; + double BSIM3v32xtsswgs; + double BSIM3v32xtsswgd; + + double BSIM3v32tnjts; + double BSIM3v32tnjtssw; + double BSIM3v32tnjtsswg; + double BSIM3v32tnjtsd; + double BSIM3v32tnjtsswd; + double BSIM3v32tnjtsswgd; + + double BSIM3v32njtstemp; + double BSIM3v32njtsswtemp; + double BSIM3v32njtsswgtemp; + double BSIM3v32njtsdtemp; + double BSIM3v32njtsswdtemp; + double BSIM3v32njtsswgdtemp; + double BSIM3v32jtsstemp; + double BSIM3v32jtsdtemp; + double BSIM3v32jtsswstemp; + double BSIM3v32jtsswdtemp; + double BSIM3v32jtsswgstemp; + double BSIM3v32jtsswgdtemp; + struct bsim3v32SizeDependParam *pSizeDependParamKnot; #ifdef USE_OMP @@ -1342,6 +1392,43 @@ typedef struct sBSIM3v32model unsigned BSIM3v32vbsrMaxGiven :1; unsigned BSIM3v32vbdrMaxGiven :1; +/* trap-assisted tunneling current enhancement */ + unsigned BSIM3v32bsim4diodeGiven :1; + unsigned BSIM3v32jtssGiven :1; + unsigned BSIM3v32jtsdGiven :1; + unsigned BSIM3v32jtsswsGiven :1; + unsigned BSIM3v32jtsswdGiven :1; + unsigned BSIM3v32jtsswgsGiven :1; + unsigned BSIM3v32jtsswgdGiven :1; + + unsigned BSIM3v32njtsGiven :1; + unsigned BSIM3v32njtsswGiven :1; + unsigned BSIM3v32njtsswgGiven :1; + unsigned BSIM3v32njtsdGiven :1; + unsigned BSIM3v32njtsswdGiven :1; + unsigned BSIM3v32njtsswgdGiven :1; + + unsigned BSIM3v32vtssGiven :1; + unsigned BSIM3v32vtsdGiven :1; + unsigned BSIM3v32vtsswsGiven :1; + unsigned BSIM3v32vtsswdGiven :1; + unsigned BSIM3v32vtsswgsGiven :1; + unsigned BSIM3v32vtsswgdGiven :1; + + unsigned BSIM3v32xtssGiven :1; + unsigned BSIM3v32xtsdGiven :1; + unsigned BSIM3v32xtsswsGiven :1; + unsigned BSIM3v32xtsswdGiven :1; + unsigned BSIM3v32xtsswgsGiven :1; + unsigned BSIM3v32xtsswgdGiven :1; + + unsigned BSIM3v32tnjtsGiven :1; + unsigned BSIM3v32tnjtsswGiven :1; + unsigned BSIM3v32tnjtsswgGiven :1; + unsigned BSIM3v32tnjtsdGiven :1; + unsigned BSIM3v32tnjtsswdGiven :1; + unsigned BSIM3v32tnjtsswgdGiven :1; + } BSIM3v32model; @@ -1911,6 +1998,43 @@ typedef struct sBSIM3v32model #define BSIM3v32_MOD_VBSR_MAX 810 #define BSIM3v32_MOD_VBDR_MAX 811 +/* trap-assisted tunneling current enhancement */ +#define BSIM3v32_MOD_BSIM4DIODE 820 +#define BSIM3v32_MOD_JTSS 821 +#define BSIM3v32_MOD_JTSD 822 +#define BSIM3v32_MOD_JTSSWS 823 +#define BSIM3v32_MOD_JTSSWD 824 +#define BSIM3v32_MOD_JTSSWGS 825 +#define BSIM3v32_MOD_JTSSWGD 826 + +#define BSIM3v32_MOD_NJTS 827 +#define BSIM3v32_MOD_NJTSSW 828 +#define BSIM3v32_MOD_NJTSSWG 829 +#define BSIM3v32_MOD_NJTSD 830 +#define BSIM3v32_MOD_NJTSSWD 831 +#define BSIM3v32_MOD_NJTSSWGD 832 + +#define BSIM3v32_MOD_VTSS 833 +#define BSIM3v32_MOD_VTSD 834 +#define BSIM3v32_MOD_VTSSWS 835 +#define BSIM3v32_MOD_VTSSWD 836 +#define BSIM3v32_MOD_VTSSWGS 837 +#define BSIM3v32_MOD_VTSSWGD 838 + +#define BSIM3v32_MOD_XTSS 839 +#define BSIM3v32_MOD_XTSD 840 +#define BSIM3v32_MOD_XTSSWS 841 +#define BSIM3v32_MOD_XTSSWD 842 +#define BSIM3v32_MOD_XTSSWGS 843 +#define BSIM3v32_MOD_XTSSWGD 844 + +#define BSIM3v32_MOD_TNJTS 845 +#define BSIM3v32_MOD_TNJTSSW 846 +#define BSIM3v32_MOD_TNJTSSWG 847 +#define BSIM3v32_MOD_TNJTSD 848 +#define BSIM3v32_MOD_TNJTSSWD 849 +#define BSIM3v32_MOD_TNJTSSWGD 850 + #include "bsim3v32ext.h" extern void BSIM3v32evaluate(double,double,double,BSIM3v32instance*,BSIM3v32model*,