epilectrik
/
pyNgSpice
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

bsim4 update to version 4.8.3

pre-master-46
dwarning 8 months ago
committed by Holger Vogt
parent
c24fc9e9d0
commit
a0c7af575d
20 changed files with 5839 additions and 5860 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 196
      src/spicelib/devices/bsim4/b4.c
  2. 380
      src/spicelib/devices/bsim4/b4acld.c
  3. 212
      src/spicelib/devices/bsim4/b4ask.c
  4. 722
      src/spicelib/devices/bsim4/b4check.c
  5. 59
      src/spicelib/devices/bsim4/b4cvtest.c
  6. 224
      src/spicelib/devices/bsim4/b4geo.c
  7. 47
      src/spicelib/devices/bsim4/b4getic.c
  8. 3700
      src/spicelib/devices/bsim4/b4ld.c
  9. 648
      src/spicelib/devices/bsim4/b4mask.c
  10. 20
      src/spicelib/devices/bsim4/b4mdel.c
  11. 392
      src/spicelib/devices/bsim4/b4mpar.c
  12. 858
      src/spicelib/devices/bsim4/b4noi.c
  13. 50
      src/spicelib/devices/bsim4/b4par.c
  14. 585
      src/spicelib/devices/bsim4/b4pzld.c
  15. 789
      src/spicelib/devices/bsim4/b4set.c
  16. 2310
      src/spicelib/devices/bsim4/b4temp.c
  17. 33
      src/spicelib/devices/bsim4/b4trunc.c
  18. 432
      src/spicelib/devices/bsim4/bsim4def.h
  19. 22
      src/spicelib/devices/bsim4/bsim4ext.h
  20. 20
      src/spicelib/devices/bsim4/bsim4itf.h

196
src/spicelib/devices/bsim4/b4.c
View File

@ -1,31 +1,28 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#include "ngspice/ngspice.h"
#include "ngspice/devdefs.h"
#include "bsim4def.h"
@ -57,11 +54,10 @@ IOP( "rbpb", BSIM4_RBPB, IF_REAL , "Body resistance"),
IOP( "rbps", BSIM4_RBPS, IF_REAL , "Body resistance"),
IOP( "rbpd", BSIM4_RBPD, IF_REAL , "Body resistance"),
IOP( "delvto", BSIM4_DELVTO, IF_REAL , "Zero bias threshold voltage variation"),
IOPR( "delvt0", BSIM4_DELVTO, IF_REAL , "Zero bias threshold voltage variation"),
IOP( "mulu0", BSIM4_MULU0, IF_REAL, "Low field mobility multiplier"),
IOPR("delvt0", BSIM4_DELVTO, IF_REAL , "Zero bias threshold voltage variation"),
IOP( "xgw", BSIM4_XGW, IF_REAL, "Distance from gate contact center to device edge"),
IOP( "ngcon", BSIM4_NGCON, IF_REAL, "Number of gate contacts"),
IOP( "wnflag", BSIM4_WNFLAG, IF_INTEGER, "W/NF device flag for bin selection"),
IOP( "trnqsmod", BSIM4_TRNQSMOD, IF_INTEGER, "Transient NQS model selector"),
IOP( "acnqsmod", BSIM4_ACNQSMOD, IF_INTEGER, "AC NQS model selector"),
@ -69,6 +65,10 @@ IOP( "rbodymod", BSIM4_RBODYMOD, IF_INTEGER, "Distributed body R model selector"
IOP( "rgatemod", BSIM4_RGATEMOD, IF_INTEGER, "Gate resistance model selector"),
IOP( "geomod", BSIM4_GEOMOD, IF_INTEGER, "Geometry dependent parasitics model selector"),
IOP( "rgeomod", BSIM4_RGEOMOD, IF_INTEGER, "S/D resistance and contact model selector"),
IOP( "mult_i", BSIM4_MULT_I, IF_REAL, "Variability in current"),
IOP( "mult_q", BSIM4_MULT_Q, IF_REAL, "Variability in charge"),
IOP( "mult_fn", BSIM4_MULT_FN, IF_REAL, "Variability in flicker noise"),
IP( "ic", BSIM4_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"),
OP( "gmbs", BSIM4_GMBS, IF_REAL, "Gmb"),
OP( "gm", BSIM4_GM, IF_REAL, "Gm"),
@ -138,7 +138,6 @@ IOP( "rbodymod", BSIM4_MOD_RBODYMOD, IF_INTEGER, "Distributed body R model selec
IOP( "rgatemod", BSIM4_MOD_RGATEMOD, IF_INTEGER, "Gate R model selector"),
IOP( "permod", BSIM4_MOD_PERMOD, IF_INTEGER, "Pd and Ps model selector"),
IOP( "geomod", BSIM4_MOD_GEOMOD, IF_INTEGER, "Geometry dependent parasitics model selector"),
IOP( "rgeomod", BSIM4_MOD_RGEOMOD, IF_INTEGER, "S/D resistance and contact model selector"),
IOP( "fnoimod", BSIM4_MOD_FNOIMOD, IF_INTEGER, "Flicker noise model selector"),
IOP( "tnoimod", BSIM4_MOD_TNOIMOD, IF_INTEGER, "Thermal noise model selector"),
IOP( "mtrlmod", BSIM4_MOD_MTRLMOD, IF_INTEGER, "parameter for non-silicon substrate or metal gate selector"),
@ -164,18 +163,19 @@ IOP( "toxref", BSIM4_MOD_TOXREF, IF_REAL, "Target tox value"),
IOP( "dtox", BSIM4_MOD_DTOX, IF_REAL, "Defined as (toxe - toxp) "),
IOP( "epsrox", BSIM4_MOD_EPSROX, IF_REAL, "Dielectric constant of the gate oxide relative to vacuum"),
IOP( "cdsc", BSIM4_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"),
IOP( "cdscb", BSIM4_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"),
IOP( "cdscd", BSIM4_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"),
IOP( "cdscb", BSIM4_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"),
IOP( "cdscd", BSIM4_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"),
IOP( "cit", BSIM4_MOD_CIT, IF_REAL, "Interface state capacitance"),
IOP( "nfactor", BSIM4_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"),
IOP( "xj", BSIM4_MOD_XJ, IF_REAL, "Junction depth in meters"),
IOP( "vsat", BSIM4_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"),
IOP( "at", BSIM4_MOD_AT, IF_REAL, "Temperature coefficient of vsat"),
IOP( "a0", BSIM4_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."),
IOP( "ags", BSIM4_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."),
IOP( "a0", BSIM4_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."),
IOP( "ags", BSIM4_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."),
IOP( "a1", BSIM4_MOD_A1, IF_REAL, "Non-saturation effect coefficient"),
IOP( "a2", BSIM4_MOD_A2, IF_REAL, "Non-saturation effect coefficient"),
IOP( "keta", BSIM4_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."),
IOP( "ketac", BSIM4_MOD_KETAC, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect in dynamic evaluation."),
IOP( "phig", BSIM4_MOD_PHIG, IF_REAL, "Work function of gate"),
IOP( "epsrgate", BSIM4_MOD_EPSRGATE, IF_REAL, "Dielectric constant of gate relative to vacuum"),
IOP( "easub",BSIM4_MOD_EASUB, IF_REAL, "Electron affinity of substrate"),
@ -248,30 +248,30 @@ IOP( "cgbo", BSIM4_MOD_CGBO, IF_REAL, "Gate-bulk overlap capacitance per length"
IOP( "xpart", BSIM4_MOD_XPART, IF_REAL, "Channel charge partitioning"),
IOP( "delta", BSIM4_MOD_DELTA, IF_REAL, "Effective Vds parameter"),
IOP( "rsh", BSIM4_MOD_RSH, IF_REAL, "Source-drain sheet resistance"),
IOP( "rdsw", BSIM4_MOD_RDSW, IF_REAL, "Source-drain resistance per width"),
IOP( "rdsw", BSIM4_MOD_RDSW, IF_REAL, "Source-drain resistance per width"),
IOP( "rdswmin", BSIM4_MOD_RDSWMIN, IF_REAL, "Source-drain resistance per width at high Vg"),
IOP( "rsw", BSIM4_MOD_RSW, IF_REAL, "Source resistance per width"),
IOP( "rdw", BSIM4_MOD_RDW, IF_REAL, "Drain resistance per width"),
IOP( "rdwmin", BSIM4_MOD_RDWMIN, IF_REAL, "Drain resistance per width at high Vg"),
IOP( "rswmin", BSIM4_MOD_RSWMIN, IF_REAL, "Source resistance per width at high Vg"),
IOP( "prwg", BSIM4_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "),
IOP( "prwb", BSIM4_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "),
IOP( "prwg", BSIM4_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "),
IOP( "prwb", BSIM4_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "),
IOP( "prt", BSIM4_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "),
IOP( "prt", BSIM4_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "),
IOP( "eta0", BSIM4_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "etab", BSIM4_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "pclm", BSIM4_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"),
IOP( "pdiblc1", BSIM4_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblc2", BSIM4_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblcb", BSIM4_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"),
IOP( "pdiblc1", BSIM4_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblc2", BSIM4_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblcb", BSIM4_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"),
IOP( "fprout", BSIM4_MOD_FPROUT, IF_REAL, "Rout degradation coefficient for pocket devices"),
IOP( "pdits", BSIM4_MOD_PDITS, IF_REAL, "Coefficient for drain-induced Vth shifts"),
IOP( "pditsl", BSIM4_MOD_PDITSL, IF_REAL, "Length dependence of drain-induced Vth shifts"),
IOP( "pditsd", BSIM4_MOD_PDITSD, IF_REAL, "Vds dependence of drain-induced Vth shifts"),
IOP( "pscbe1", BSIM4_MOD_PSCBE1, IF_REAL, "Substrate current body-effect coefficient"),
IOP( "pscbe2", BSIM4_MOD_PSCBE2, IF_REAL, "Substrate current body-effect coefficient"),
IOP( "pvag", BSIM4_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"),
IOP( "pscbe1", BSIM4_MOD_PSCBE1, IF_REAL, "Substrate current body-effect coefficient"),
IOP( "pscbe2", BSIM4_MOD_PSCBE2, IF_REAL, "Substrate current body-effect coefficient"),
IOP( "pvag", BSIM4_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"),
IOP( "jss", BSIM4_MOD_JSS, IF_REAL, "Bottom source junction reverse saturation current density"),
IOP( "jsws", BSIM4_MOD_JSWS, IF_REAL, "Isolation edge sidewall source junction reverse saturation current density"),
@ -390,14 +390,14 @@ IOP( "beta0", BSIM4_MOD_BETA0, IF_REAL, "substrate current model parameter"),
IOP( "agidl", BSIM4_MOD_AGIDL, IF_REAL, "Pre-exponential constant for GIDL"),
IOP( "bgidl", BSIM4_MOD_BGIDL, IF_REAL, "Exponential constant for GIDL"),
IOP( "cgidl", BSIM4_MOD_CGIDL, IF_REAL, "Parameter for body-bias dependence of GIDL"),
IOP( "rgidl", BSIM4_MOD_RGIDL, IF_REAL, "GIDL vg parameter"), /* v4.7 New GIDL/GISL */
IOP( "rgidl", BSIM4_MOD_RGIDL, IF_REAL, "GIDL vg parameter"), /* v4.7 New GIDL/GISL */
IOP( "kgidl", BSIM4_MOD_KGIDL, IF_REAL, "GIDL vb parameter"), /* v4.7 New GIDL/GISL */
IOP( "fgidl", BSIM4_MOD_FGIDL, IF_REAL, "GIDL vb parameter"), /* v4.7 New GIDL/GISL */
IOP( "egidl", BSIM4_MOD_EGIDL, IF_REAL, "Fitting parameter for Bandbending"),
IOP( "agisl", BSIM4_MOD_AGISL, IF_REAL, "Pre-exponential constant for GISL"),
IOP( "bgisl", BSIM4_MOD_BGISL, IF_REAL, "Exponential constant for GISL"),
IOP( "cgisl", BSIM4_MOD_CGISL, IF_REAL, "Parameter for body-bias dependence of GISL"),
IOP( "rgisl", BSIM4_MOD_RGISL, IF_REAL, "GISL vg parameter"), /* v4.7 New GIDL/GISL */
IOP( "rgisl", BSIM4_MOD_RGISL, IF_REAL, "GISL vg parameter"), /* v4.7 New GIDL/GISL */
IOP( "kgisl", BSIM4_MOD_KGISL, IF_REAL, "GISL vb parameter"), /* v4.7 New GIDL/GISL */
IOP( "fgisl", BSIM4_MOD_FGISL, IF_REAL, "GISL vb parameter"), /* v4.7 New GIDL/GISL */
IOP( "egisl", BSIM4_MOD_EGISL, IF_REAL, "Fitting parameter for Bandbending"),
@ -442,7 +442,7 @@ IOP( "jtssws", BSIM4_MOD_JTSSWS, IF_REAL, "Source STI sidewall trap-assisted sat
IOP( "jtsswd", BSIM4_MOD_JTSSWD, IF_REAL, "Drain STI sidewall trap-assisted saturation current density"),
IOP( "jtsswgs", BSIM4_MOD_JTSSWGS, IF_REAL, "Source gate-edge sidewall trap-assisted saturation current density"),
IOP( "jtsswgd", BSIM4_MOD_JTSSWGD, IF_REAL, "Drain gate-edge sidewall trap-assisted saturation current density"),
IOP( "jtweff", BSIM4_MOD_JTWEFF, IF_REAL, "TAT current width dependence"),
IOP( "jtweff", BSIM4_MOD_JTWEFF, IF_REAL, "TAT current width dependance"),
IOP( "njts", BSIM4_MOD_NJTS, IF_REAL, "Non-ideality factor for bottom junction"),
IOP( "njtssw", BSIM4_MOD_NJTSSW, IF_REAL, "Non-ideality factor for STI sidewall junction"),
IOP( "njtsswg", BSIM4_MOD_NJTSSWG, IF_REAL, "Non-ideality factor for gate-edge sidewall junction"),
@ -514,11 +514,12 @@ IOP( "lnfactor", BSIM4_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"),
IOP( "lxj", BSIM4_MOD_LXJ, IF_REAL, "Length dependence of xj"),
IOP( "lvsat", BSIM4_MOD_LVSAT, IF_REAL, "Length dependence of vsat"),
IOP( "lat", BSIM4_MOD_LAT, IF_REAL, "Length dependence of at"),
IOP( "la0", BSIM4_MOD_LA0, IF_REAL, "Length dependence of a0"),
IOP( "lags", BSIM4_MOD_LAGS, IF_REAL, "Length dependence of ags"),
IOP( "la0", BSIM4_MOD_LA0, IF_REAL, "Length dependence of a0"),
IOP( "lags", BSIM4_MOD_LAGS, IF_REAL, "Length dependence of ags"),
IOP( "la1", BSIM4_MOD_LA1, IF_REAL, "Length dependence of a1"),
IOP( "la2", BSIM4_MOD_LA2, IF_REAL, "Length dependence of a2"),
IOP( "lketa", BSIM4_MOD_LKETA, IF_REAL, "Length dependence of keta"),
IOP( "lketac", BSIM4_MOD_LKETAC, IF_REAL, "Length dependence of ketac"),
IOP( "lnsub", BSIM4_MOD_LNSUB, IF_REAL, "Length dependence of nsub"),
IOP( "lndep", BSIM4_MOD_LNDEP, IF_REAL, "Length dependence of ndep"),
IOP( "lnsd", BSIM4_MOD_LNSD, IF_REAL, "Length dependence of nsd"),
@ -553,8 +554,8 @@ IOP( "ldvt1w", BSIM4_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"),
IOP( "ldvt2w", BSIM4_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"),
IOP( "ldrout", BSIM4_MOD_LDROUT, IF_REAL, "Length dependence of drout"),
IOP( "ldsub", BSIM4_MOD_LDSUB, IF_REAL, "Length dependence of dsub"),
IOP( "lvth0", BSIM4_MOD_LVTH0, IF_REAL,"Length dependence of vth0"),
IOPR("lvtho", BSIM4_MOD_LVTH0, IF_REAL,"Length dependence of vtho"),
IOP( "lvth0", BSIM4_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOPR("lvtho", BSIM4_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOP( "lua", BSIM4_MOD_LUA, IF_REAL, "Length dependence of ua"),
IOP( "lua1", BSIM4_MOD_LUA1, IF_REAL, "Length dependence of ua1"),
IOP( "lub", BSIM4_MOD_LUB, IF_REAL, "Length dependence of ub"),
@ -572,26 +573,26 @@ IOP( "lvoff", BSIM4_MOD_LVOFF, IF_REAL, "Length dependence of voff"),
IOP( "lminv", BSIM4_MOD_LMINV, IF_REAL, "Length dependence of minv"),
IOP( "lminvcv", BSIM4_MOD_LMINVCV, IF_REAL, "Length dependence of minvcv"),
IOP( "ldelta", BSIM4_MOD_LDELTA, IF_REAL, "Length dependence of delta"),
IOP( "lrdsw", BSIM4_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "),
IOP( "lrdsw", BSIM4_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "),
IOP( "lrsw", BSIM4_MOD_LRSW, IF_REAL, "Length dependence of rsw"),
IOP( "lrdw", BSIM4_MOD_LRDW, IF_REAL, "Length dependence of rdw"),
IOP( "lprwg", BSIM4_MOD_LPRWG, IF_REAL, "Length dependence of prwg "),
IOP( "lprwb", BSIM4_MOD_LPRWB, IF_REAL, "Length dependence of prwb "),
IOP( "lprwg", BSIM4_MOD_LPRWG, IF_REAL, "Length dependence of prwg "),
IOP( "lprwb", BSIM4_MOD_LPRWB, IF_REAL, "Length dependence of prwb "),
IOP( "lprt", BSIM4_MOD_LPRT, IF_REAL, "Length dependence of prt "),
IOP( "leta0", BSIM4_MOD_LETA0, IF_REAL, "Length dependence of eta0"),
IOP( "letab", BSIM4_MOD_LETAB, IF_REAL, "Length dependence of etab"),
IOP( "lpclm", BSIM4_MOD_LPCLM, IF_REAL, "Length dependence of pclm"),
IOP( "lpdiblc1", BSIM4_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"),
IOP( "lpdiblc2", BSIM4_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"),
IOP( "lpdiblcb", BSIM4_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"),
IOP( "lprt", BSIM4_MOD_LPRT, IF_REAL, "Length dependence of prt "),
IOP( "leta0", BSIM4_MOD_LETA0, IF_REAL, "Length dependence of eta0"),
IOP( "letab", BSIM4_MOD_LETAB, IF_REAL, "Length dependence of etab"),
IOP( "lpclm", BSIM4_MOD_LPCLM, IF_REAL, "Length dependence of pclm"),
IOP( "lpdiblc1", BSIM4_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"),
IOP( "lpdiblc2", BSIM4_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"),
IOP( "lpdiblcb", BSIM4_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"),
IOP( "lfprout", BSIM4_MOD_LFPROUT, IF_REAL, "Length dependence of pdiblcb"),
IOP( "lpdits", BSIM4_MOD_LPDITS, IF_REAL, "Length dependence of pdits"),
IOP( "lpditsd", BSIM4_MOD_LPDITSD, IF_REAL, "Length dependence of pditsd"),
IOP( "lpscbe1", BSIM4_MOD_LPSCBE1, IF_REAL, "Length dependence of pscbe1"),
IOP( "lpscbe2", BSIM4_MOD_LPSCBE2, IF_REAL, "Length dependence of pscbe2"),
IOP( "lpvag", BSIM4_MOD_LPVAG, IF_REAL, "Length dependence of pvag"),
IOP( "lpscbe1", BSIM4_MOD_LPSCBE1, IF_REAL, "Length dependence of pscbe1"),
IOP( "lpscbe2", BSIM4_MOD_LPSCBE2, IF_REAL, "Length dependence of pscbe2"),
IOP( "lpvag", BSIM4_MOD_LPVAG, IF_REAL, "Length dependence of pvag"),
IOP( "lwr", BSIM4_MOD_LWR, IF_REAL, "Length dependence of wr"),
IOP( "ldwg", BSIM4_MOD_LDWG, IF_REAL, "Length dependence of dwg"),
IOP( "ldwb", BSIM4_MOD_LDWB, IF_REAL, "Length dependence of dwb"),
@ -611,16 +612,16 @@ IOP( "lbeta0", BSIM4_MOD_LBETA0, IF_REAL, "Length dependence of beta0"),
IOP( "lagidl", BSIM4_MOD_LAGIDL, IF_REAL, "Length dependence of agidl"),
IOP( "lbgidl", BSIM4_MOD_LBGIDL, IF_REAL, "Length dependence of bgidl"),
IOP( "lcgidl", BSIM4_MOD_LCGIDL, IF_REAL, "Length dependence of cgidl"),
IOP( "lrgidl", BSIM4_MOD_LRGIDL, IF_REAL, "Length dependence of rgidl"), /* v4.7 New GIDL/GISL */
IOP( "lkgidl", BSIM4_MOD_LKGIDL, IF_REAL, "Length dependence of kgidl"), /* v4.7 New GIDL/GISL */
IOP( "lfgidl", BSIM4_MOD_LFGIDL, IF_REAL, "Length dependence of fgidl"), /* v4.7 New GIDL/GISL */
IOP( "lrgidl", BSIM4_MOD_LRGIDL, IF_REAL, "Length dependence of rgidl"), /* v4.7 New GIDL/GISL */
IOP( "lkgidl", BSIM4_MOD_LKGIDL, IF_REAL, "Length dependence of kgidl"), /* v4.7 New GIDL/GISL */
IOP( "lfgidl", BSIM4_MOD_LFGIDL, IF_REAL, "Length dependence of fgidl"), /* v4.7 New GIDL/GISL */
IOP( "legidl", BSIM4_MOD_LEGIDL, IF_REAL, "Length dependence of egidl"),
IOP( "lagisl", BSIM4_MOD_LAGISL, IF_REAL, "Length dependence of agisl"),
IOP( "lbgisl", BSIM4_MOD_LBGISL, IF_REAL, "Length dependence of bgisl"),
IOP( "lcgisl", BSIM4_MOD_LCGISL, IF_REAL, "Length dependence of cgisl"),
IOP( "lrgisl", BSIM4_MOD_LRGISL, IF_REAL, "Length dependence of rgisl"), /* v4.7 New GIDL/GISL */
IOP( "lkgisl", BSIM4_MOD_LKGISL, IF_REAL, "Length dependence of kgisl"), /* v4.7 New GIDL/GISL */
IOP( "lfgisl", BSIM4_MOD_LFGISL, IF_REAL, "Length dependence of fgisl"), /* v4.7 New GIDL/GISL */
IOP( "lrgisl", BSIM4_MOD_LRGISL, IF_REAL, "Length dependence of rgisl"), /* v4.7 New GIDL/GISL */
IOP( "lkgisl", BSIM4_MOD_LKGISL, IF_REAL, "Length dependence of kgisl"), /* v4.7 New GIDL/GISL */
IOP( "lfgisl", BSIM4_MOD_LFGISL, IF_REAL, "Length dependence of fgisl"), /* v4.7 New GIDL/GISL */
IOP( "legisl", BSIM4_MOD_LEGISL, IF_REAL, "Length dependence of egisl"),
IOP( "laigc", BSIM4_MOD_LAIGC, IF_REAL, "Length dependence of aigc"),
IOP( "lbigc", BSIM4_MOD_LBIGC, IF_REAL, "Length dependence of bigc"),
@ -669,18 +670,19 @@ IOP( "lteta0", BSIM4_MOD_LTETA0, IF_REAL, "Length dependence of teta0"),
IOP( "ltvoffcv", BSIM4_MOD_LTVOFFCV, IF_REAL, "Length dependence of tvoffcv"), /* v4.7 Tanvir*/
IOP( "wcdsc", BSIM4_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"),
IOP( "wcdscb", BSIM4_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"),
IOP( "wcdscd", BSIM4_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"),
IOP( "wcdscb", BSIM4_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"),
IOP( "wcdscd", BSIM4_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"),
IOP( "wcit", BSIM4_MOD_WCIT, IF_REAL, "Width dependence of cit"),
IOP( "wnfactor", BSIM4_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"),
IOP( "wxj", BSIM4_MOD_WXJ, IF_REAL, "Width dependence of xj"),
IOP( "wvsat", BSIM4_MOD_WVSAT, IF_REAL, "Width dependence of vsat"),
IOP( "wat", BSIM4_MOD_WAT, IF_REAL, "Width dependence of at"),
IOP( "wa0", BSIM4_MOD_WA0, IF_REAL, "Width dependence of a0"),
IOP( "wags", BSIM4_MOD_WAGS, IF_REAL, "Width dependence of ags"),
IOP( "wa0", BSIM4_MOD_WA0, IF_REAL, "Width dependence of a0"),
IOP( "wags", BSIM4_MOD_WAGS, IF_REAL, "Width dependence of ags"),
IOP( "wa1", BSIM4_MOD_WA1, IF_REAL, "Width dependence of a1"),
IOP( "wa2", BSIM4_MOD_WA2, IF_REAL, "Width dependence of a2"),
IOP( "wketa", BSIM4_MOD_WKETA, IF_REAL, "Width dependence of keta"),
IOP( "wketac", BSIM4_MOD_WKETAC, IF_REAL, "Width dependence of ketac"),
IOP( "wnsub", BSIM4_MOD_WNSUB, IF_REAL, "Width dependence of nsub"),
IOP( "wndep", BSIM4_MOD_WNDEP, IF_REAL, "Width dependence of ndep"),
IOP( "wnsd", BSIM4_MOD_WNSD, IF_REAL, "Width dependence of nsd"),
@ -715,8 +717,8 @@ IOP( "wdvt1w", BSIM4_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"),
IOP( "wdvt2w", BSIM4_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"),
IOP( "wdrout", BSIM4_MOD_WDROUT, IF_REAL, "Width dependence of drout"),
IOP( "wdsub", BSIM4_MOD_WDSUB, IF_REAL, "Width dependence of dsub"),
IOP( "wvth0", BSIM4_MOD_WVTH0, IF_REAL,"Width dependence of vth0"),
IOPR("wvtho", BSIM4_MOD_WVTH0, IF_REAL,"Width dependence of vtho"),
IOP( "wvth0", BSIM4_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOPR("wvtho", BSIM4_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOP( "wua", BSIM4_MOD_WUA, IF_REAL, "Width dependence of ua"),
IOP( "wua1", BSIM4_MOD_WUA1, IF_REAL, "Width dependence of ua1"),
IOP( "wub", BSIM4_MOD_WUB, IF_REAL, "Width dependence of ub"),
@ -742,18 +744,18 @@ IOP( "wprwg", BSIM4_MOD_WPRWG, IF_REAL, "Width dependence of prwg "),
IOP( "wprwb", BSIM4_MOD_WPRWB, IF_REAL, "Width dependence of prwb "),
IOP( "wprt", BSIM4_MOD_WPRT, IF_REAL, "Width dependence of prt"),
IOP( "weta0", BSIM4_MOD_WETA0, IF_REAL, "Width dependence of eta0"),
IOP( "wetab", BSIM4_MOD_WETAB, IF_REAL, "Width dependence of etab"),
IOP( "wpclm", BSIM4_MOD_WPCLM, IF_REAL, "Width dependence of pclm"),
IOP( "wpdiblc1", BSIM4_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"),
IOP( "wpdiblc2", BSIM4_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"),
IOP( "wpdiblcb", BSIM4_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"),
IOP( "weta0", BSIM4_MOD_WETA0, IF_REAL, "Width dependence of eta0"),
IOP( "wetab", BSIM4_MOD_WETAB, IF_REAL, "Width dependence of etab"),
IOP( "wpclm", BSIM4_MOD_WPCLM, IF_REAL, "Width dependence of pclm"),
IOP( "wpdiblc1", BSIM4_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"),
IOP( "wpdiblc2", BSIM4_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"),
IOP( "wpdiblcb", BSIM4_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"),
IOP( "wfprout", BSIM4_MOD_WFPROUT, IF_REAL, "Width dependence of pdiblcb"),
IOP( "wpdits", BSIM4_MOD_WPDITS, IF_REAL, "Width dependence of pdits"),
IOP( "wpditsd", BSIM4_MOD_WPDITSD, IF_REAL, "Width dependence of pditsd"),
IOP( "wpscbe1", BSIM4_MOD_WPSCBE1, IF_REAL, "Width dependence of pscbe1"),
IOP( "wpscbe2", BSIM4_MOD_WPSCBE2, IF_REAL, "Width dependence of pscbe2"),
IOP( "wpvag", BSIM4_MOD_WPVAG, IF_REAL, "Width dependence of pvag"),
IOP( "wpscbe1", BSIM4_MOD_WPSCBE1, IF_REAL, "Width dependence of pscbe1"),
IOP( "wpscbe2", BSIM4_MOD_WPSCBE2, IF_REAL, "Width dependence of pscbe2"),
IOP( "wpvag", BSIM4_MOD_WPVAG, IF_REAL, "Width dependence of pvag"),
IOP( "wwr", BSIM4_MOD_WWR, IF_REAL, "Width dependence of wr"),
IOP( "wdwg", BSIM4_MOD_WDWG, IF_REAL, "Width dependence of dwg"),
IOP( "wdwb", BSIM4_MOD_WDWB, IF_REAL, "Width dependence of dwb"),
@ -773,16 +775,16 @@ IOP( "wbeta0", BSIM4_MOD_WBETA0, IF_REAL, "Width dependence of beta0"),
IOP( "wagidl", BSIM4_MOD_WAGIDL, IF_REAL, "Width dependence of agidl"),
IOP( "wbgidl", BSIM4_MOD_WBGIDL, IF_REAL, "Width dependence of bgidl"),
IOP( "wcgidl", BSIM4_MOD_WCGIDL, IF_REAL, "Width dependence of cgidl"),
IOP( "wrgidl", BSIM4_MOD_WRGIDL, IF_REAL, "Width dependence of rgidl"), /* v4.7 New GIDL/GISL */
IOP( "wkgidl", BSIM4_MOD_WKGIDL, IF_REAL, "Width dependence of kgidl"), /* v4.7 New GIDL/GISL */
IOP( "wfgidl", BSIM4_MOD_WFGIDL, IF_REAL, "Width dependence of fgidl"), /* v4.7 New GIDL/GISL */
IOP( "wrgidl", BSIM4_MOD_WRGIDL, IF_REAL, "Width dependence of rgidl"), /* v4.7 New GIDL/GISL */
IOP( "wkgidl", BSIM4_MOD_WKGIDL, IF_REAL, "Width dependence of kgidl"), /* v4.7 New GIDL/GISL */
IOP( "wfgidl", BSIM4_MOD_WFGIDL, IF_REAL, "Width dependence of fgidl"), /* v4.7 New GIDL/GISL */
IOP( "wegidl", BSIM4_MOD_WEGIDL, IF_REAL, "Width dependence of egidl"),
IOP( "wagisl", BSIM4_MOD_WAGISL, IF_REAL, "Width dependence of agisl"),
IOP( "wbgisl", BSIM4_MOD_WBGISL, IF_REAL, "Width dependence of bgisl"),
IOP( "wcgisl", BSIM4_MOD_WCGISL, IF_REAL, "Width dependence of cgisl"),
IOP( "wrgisl", BSIM4_MOD_WRGISL, IF_REAL, "Width dependence of rgisl"), /* v4.7 New GIDL/GISL */
IOP( "wkgisl", BSIM4_MOD_WKGISL, IF_REAL, "Width dependence of kgisl"), /* v4.7 New GIDL/GISL */
IOP( "wfgisl", BSIM4_MOD_WFGISL, IF_REAL, "Width dependence of fgisl"), /* v4.7 New GIDL/GISL */
IOP( "wrgisl", BSIM4_MOD_WRGISL, IF_REAL, "Width dependence of rgisl"), /* v4.7 New GIDL/GISL */
IOP( "wkgisl", BSIM4_MOD_WKGISL, IF_REAL, "Width dependence of kgisl"), /* v4.7 New GIDL/GISL */
IOP( "wfgisl", BSIM4_MOD_WFGISL, IF_REAL, "Width dependence of fgisl"), /* v4.7 New GIDL/GISL */
IOP( "wegisl", BSIM4_MOD_WEGISL, IF_REAL, "Width dependence of egisl"),
IOP( "waigc", BSIM4_MOD_WAIGC, IF_REAL, "Width dependence of aigc"),
IOP( "wbigc", BSIM4_MOD_WBIGC, IF_REAL, "Width dependence of bigc"),
@ -830,18 +832,19 @@ IOP( "wteta0", BSIM4_MOD_WTETA0, IF_REAL, "Width dependence of teta0"),
IOP( "wtvoffcv", BSIM4_MOD_WTVOFFCV, IF_REAL, "Width dependence of tvoffcv"), /* v4.7 Tanvir*/
IOP( "pcdsc", BSIM4_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"),
IOP( "pcdscb", BSIM4_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"),
IOP( "pcdscb", BSIM4_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"),
IOP( "pcdscd", BSIM4_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"),
IOP( "pcit", BSIM4_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"),
IOP( "pnfactor", BSIM4_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"),
IOP( "pxj", BSIM4_MOD_PXJ, IF_REAL, "Cross-term dependence of xj"),
IOP( "pvsat", BSIM4_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"),
IOP( "pat", BSIM4_MOD_PAT, IF_REAL, "Cross-term dependence of at"),
IOP( "pa0", BSIM4_MOD_PA0, IF_REAL, "Cross-term dependence of a0"),
IOP( "pa0", BSIM4_MOD_PA0, IF_REAL, "Cross-term dependence of a0"),
IOP( "pags", BSIM4_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"),
IOP( "pa1", BSIM4_MOD_PA1, IF_REAL, "Cross-term dependence of a1"),
IOP( "pa2", BSIM4_MOD_PA2, IF_REAL, "Cross-term dependence of a2"),
IOP( "pketa", BSIM4_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"),
IOP( "pketac", BSIM4_MOD_PKETAC, IF_REAL, "Cross-term dependence of ketac"),
IOP( "pnsub", BSIM4_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"),
IOP( "pndep", BSIM4_MOD_PNDEP, IF_REAL, "Cross-term dependence of ndep"),
IOP( "pnsd", BSIM4_MOD_PNSD, IF_REAL, "Cross-term dependence of nsd"),
@ -876,8 +879,8 @@ IOP( "pdvt1w", BSIM4_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"),
IOP( "pdvt2w", BSIM4_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"),
IOP( "pdrout", BSIM4_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"),
IOP( "pdsub", BSIM4_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"),
IOP( "pvth0", BSIM4_MOD_PVTH0, IF_REAL,"Cross-term dependence of vth0"),
IOPR("pvtho", BSIM4_MOD_PVTH0, IF_REAL,"Cross-term dependence of vtho"),
IOP( "pvth0", BSIM4_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOPR("pvtho", BSIM4_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOP( "pua", BSIM4_MOD_PUA, IF_REAL, "Cross-term dependence of ua"),
IOP( "pua1", BSIM4_MOD_PUA1, IF_REAL, "Cross-term dependence of ua1"),
IOP( "pub", BSIM4_MOD_PUB, IF_REAL, "Cross-term dependence of ub"),
@ -895,12 +898,12 @@ IOP( "pvoff", BSIM4_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"),
IOP( "pminv", BSIM4_MOD_PMINV, IF_REAL, "Cross-term dependence of minv"),
IOP( "pminvcv", BSIM4_MOD_PMINVCV, IF_REAL, "Cross-term dependence of minvcv"),
IOP( "pdelta", BSIM4_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"),
IOP( "prdsw", BSIM4_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "),
IOP( "prdsw", BSIM4_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "),
IOP( "prsw", BSIM4_MOD_PRSW, IF_REAL, "Cross-term dependence of rsw"),
IOP( "prdw", BSIM4_MOD_PRDW, IF_REAL, "Cross-term dependence of rdw"),
IOP( "pprwg", BSIM4_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "),
IOP( "pprwb", BSIM4_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "),
IOP( "pprwg", BSIM4_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "),
IOP( "pprwb", BSIM4_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "),
IOP( "pprt", BSIM4_MOD_PPRT, IF_REAL, "Cross-term dependence of prt "),
IOP( "peta0", BSIM4_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"),
@ -914,7 +917,7 @@ IOP( "ppdits", BSIM4_MOD_PPDITS, IF_REAL, "Cross-term dependence of pdits"),
IOP( "ppditsd", BSIM4_MOD_PPDITSD, IF_REAL, "Cross-term dependence of pditsd"),
IOP( "ppscbe1", BSIM4_MOD_PPSCBE1, IF_REAL, "Cross-term dependence of pscbe1"),
IOP( "ppscbe2", BSIM4_MOD_PPSCBE2, IF_REAL, "Cross-term dependence of pscbe2"),
IOP( "ppvag", BSIM4_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"),
IOP( "ppvag", BSIM4_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"),
IOP( "pwr", BSIM4_MOD_PWR, IF_REAL, "Cross-term dependence of wr"),
IOP( "pdwg", BSIM4_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"),
IOP( "pdwb", BSIM4_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"),
@ -934,17 +937,17 @@ IOP( "pbeta0", BSIM4_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"),
IOP( "pagidl", BSIM4_MOD_PAGIDL, IF_REAL, "Cross-term dependence of agidl"),
IOP( "pbgidl", BSIM4_MOD_PBGIDL, IF_REAL, "Cross-term dependence of bgidl"),
IOP( "pcgidl", BSIM4_MOD_PCGIDL, IF_REAL, "Cross-term dependence of cgidl"),
IOP( "prgidl", BSIM4_MOD_PRGIDL, IF_REAL, "Cross-term dependence of rgidl"), /* v4.7 New GIDL/GISL */
IOP( "pkgidl", BSIM4_MOD_PKGIDL, IF_REAL, "Cross-term dependence of kgidl"), /* v4.7 New GIDL/GISL */
IOP( "pfgidl", BSIM4_MOD_PFGIDL, IF_REAL, "Cross-term dependence of fgidl"), /* v4.7 New GIDL/GISL */
IOP( "prgidl", BSIM4_MOD_PRGIDL, IF_REAL, "Cross-term dependence of rgidl"), /* v4.7 New GIDL/GISL */
IOP( "pkgidl", BSIM4_MOD_PKGIDL, IF_REAL, "Cross-term dependence of kgidl"), /* v4.7 New GIDL/GISL */
IOP( "pfgidl", BSIM4_MOD_PFGIDL, IF_REAL, "Cross-term dependence of fgidl"), /* v4.7 New GIDL/GISL */
IOP( "pegidl", BSIM4_MOD_PEGIDL, IF_REAL, "Cross-term dependence of egidl"),
IOP( "pagisl", BSIM4_MOD_PAGISL, IF_REAL, "Cross-term dependence of agisl"),
IOP( "pbgisl", BSIM4_MOD_PBGISL, IF_REAL, "Cross-term dependence of bgisl"),
IOP( "pcgisl", BSIM4_MOD_PCGISL, IF_REAL, "Cross-term dependence of cgisl"),
IOP( "pegisl", BSIM4_MOD_PEGISL, IF_REAL, "Cross-term dependence of egisl"),
IOP( "prgisl", BSIM4_MOD_PRGISL, IF_REAL, "Cross-term dependence of rgisl"), /* v4.7 New GIDL/GISL */
IOP( "pkgisl", BSIM4_MOD_PKGISL, IF_REAL, "Cross-term dependence of kgisl"), /* v4.7 New GIDL/GISL */
IOP( "pfgisl", BSIM4_MOD_PFGISL, IF_REAL, "Cross-term dependence of fgisl"), /* v4.7 New GIDL/GISL */
IOP( "prgisl", BSIM4_MOD_PRGISL, IF_REAL, "Cross-term dependence of rgisl"), /* v4.7 New GIDL/GISL */
IOP( "pkgisl", BSIM4_MOD_PKGISL, IF_REAL, "Cross-term dependence of kgisl"), /* v4.7 New GIDL/GISL */
IOP( "pfgisl", BSIM4_MOD_PFGISL, IF_REAL, "Cross-term dependence of fgisl"), /* v4.7 New GIDL/GISL */
IOP( "paigc", BSIM4_MOD_PAIGC, IF_REAL, "Cross-term dependence of aigc"),
IOP( "pbigc", BSIM4_MOD_PBIGC, IF_REAL, "Cross-term dependence of bigc"),
IOP( "pcigc", BSIM4_MOD_PCIGC, IF_REAL, "Cross-term dependence of cigc"),
@ -1071,8 +1074,9 @@ char *BSIM4names[] = {
"Charge"
};
int BSIM4nSize = NUMELEMS(BSIM4names);
int BSIM4pTSize = NUMELEMS(BSIM4pTable);
int BSIM4mPTSize = NUMELEMS(BSIM4mPTable);
int BSIM4iSize = sizeof(BSIM4instance);
int BSIM4mSize = sizeof(BSIM4model);
int BSIM4nSize = NUMELEMS(BSIM4names);
int BSIM4pTSize = NUMELEMS(BSIM4pTable);
int BSIM4mPTSize = NUMELEMS(BSIM4mPTable);
int BSIM4iSize = sizeof(BSIM4instance);
int BSIM4mSize = sizeof(BSIM4model);

380
src/spicelib/devices/bsim4/b4acld.c
View File

@ -1,38 +1,34 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#include "ngspice/ngspice.h"
#include "ngspice/cktdefs.h"
#include "bsim4def.h"
#include "ngspice/sperror.h"
#include "ngspice/suffix.h"
int
BSIM4acLoad(
GENmodel *inModel,
@ -68,15 +64,13 @@ double FwdSumr, RevSumr, Gmr, Gmbsr;
double FwdSumi, RevSumi, Gmi, Gmbsi;
struct bsim4SizeDependParam *pParam;
double ggidld, ggidlg, ggidlb, ggislg, ggislb, ggisls;
double m;
double m, mult_i, mult_q;
omega = ckt->CKTomega;
for (; model != NULL; model = BSIM4nextModel(model))
{ for (here = BSIM4instances(model); here!= NULL;
here = BSIM4nextInstance(here))
{
pParam = here->pParam;
{ pParam = here->pParam;
capbd = here->BSIM4capbd;
capbs = here->BSIM4capbs;
cgso = here->BSIM4cgso;
@ -106,7 +100,7 @@ double m;
Cdsr = here->BSIM4cdsb * T2;
Cdbr = -(Cddr + Cdgr + Cdsr);
/* WDLiu: Cxyi mulitplied by jomega below, and actually to be of conductance */
/* WDLiu: Cxyi mulitplied by jomega below, and actually to be of conductance */
Cddi = here->BSIM4cddb * T3 * omega;
Cdgi = here->BSIM4cdgb * T3 * omega;
Cdsi = here->BSIM4cdsb * T3 * omega;
@ -158,7 +152,7 @@ double m;
}
if (here->BSIM4mode >= 0)
if (here->BSIM4mode >= 0)
{ Gmr = gmr;
Gmbsr = gmbsr;
FwdSumr = Gmr + Gmbsr;
@ -236,16 +230,16 @@ double m;
xcgmdb = -cgdo * omega;
xcgmsb = -cgso * omega;
xcgmbb = -pParam->BSIM4cgbo * omega;
xcdgmb = xcgmdb;
xcsgmb = xcgmsb;
xcbgmb = xcgmbb;
xcggbr = Cggr * omega;
xcgdbr = Cgdr * omega;
xcgsbr = Cgsr * omega;
xcgbbr = -(xcggbr + xcgdbr + xcgsbr);
xcdgbr = Cdgr * omega;
xcsgbr = Csgr * omega;
xcbgb = here->BSIM4cbgb * omega;
@ -255,18 +249,18 @@ double m;
xcgdbr = (Cgdr - cgdo) * omega;
xcgsbr = (Cgsr - cgso) * omega;
xcgbbr = -(xcggbr + xcgdbr + xcgsbr);
xcdgbr = (Cdgr - cgdo) * omega;
xcsgbr = (Csgr - cgso) * omega;
xcbgb = (here->BSIM4cbgb - pParam->BSIM4cgbo) * omega;
xcdgmb = xcsgmb = xcbgmb = 0.0;
}
xcddbr = (Cddr + here->BSIM4capbd + cgdo) * omega;
xcdsbr = Cdsr * omega;
xcsdbr = Csdr * omega;
xcssbr = (here->BSIM4capbs + cgso + Cssr) * omega;
if (!here->BSIM4rbodyMod)
{ xcdbbr = -(xcdgbr + xcddbr + xcdsbr + xcdgmb);
xcsbbr = -(xcsgbr + xcsdbr + xcssbr + xcsgmb);
@ -278,11 +272,11 @@ double m;
else
{ xcdbbr = Cdbr * omega;
xcsbbr = -(xcsgbr + xcsdbr + xcssbr + xcsgmb)
+ here->BSIM4capbs * omega;
+ here->BSIM4capbs * omega;
xcbdb = here->BSIM4cbdb * omega;
xcbsb = here->BSIM4cbsb * omega;
xcdbdb = -here->BSIM4capbd * omega;
xcsbsb = -here->BSIM4capbs * omega;
}
@ -300,7 +294,7 @@ double m;
xcgdbi = Cgdi;
xcgsbi = Cgsi;
xcgbbi = Cgbi;
}
}
else /* Reverse mode */
{ Gmr = -gmr;
Gmbsr = -gmbsr;
@ -380,16 +374,16 @@ double m;
xcgmdb = -cgdo * omega;
xcgmsb = -cgso * omega;
xcgmbb = -pParam->BSIM4cgbo * omega;
xcdgmb = xcgmdb;
xcsgmb = xcgmsb;
xcbgmb = xcgmbb;
xcggbr = Cggr * omega;
xcgdbr = Cgsr * omega;
xcgsbr = Cgdr * omega;
xcgbbr = -(xcggbr + xcgdbr + xcgsbr);
xcdgbr = Csgr * omega;
xcsgbr = Cdgr * omega;
xcbgb = here->BSIM4cbgb * omega;
@ -399,18 +393,18 @@ double m;
xcgdbr = (Cgsr - cgdo) * omega;
xcgsbr = (Cgdr - cgso) * omega;
xcgbbr = -(xcggbr + xcgdbr + xcgsbr);
xcdgbr = (Csgr - cgdo) * omega;
xcsgbr = (Cdgr - cgso) * omega;
xcbgb = (here->BSIM4cbgb - pParam->BSIM4cgbo) * omega;
xcdgmb = xcsgmb = xcbgmb = 0.0;
}
xcddbr = (here->BSIM4capbd + cgdo + Cssr) * omega;
xcdsbr = Csdr * omega;
xcsdbr = Cdsr * omega;
xcssbr = (Cddr + here->BSIM4capbs + cgso) * omega;
if (!here->BSIM4rbodyMod)
{ xcdbbr = -(xcdgbr + xcddbr + xcdsbr + xcdgmb);
xcsbbr = -(xcsgbr + xcsdbr + xcssbr + xcsgmb);
@ -468,6 +462,8 @@ double m;
* Loading AC matrix
*/
m = here->BSIM4m;
mult_i = here->BSIM4mult_i;
mult_q = here->BSIM4mult_q;
if (!model->BSIM4rdsMod)
{ gdpr = here->BSIM4drainConductance;
@ -486,122 +482,122 @@ double m;
geltd = here->BSIM4grgeltd;
if (here->BSIM4rgateMod == 1)
{ *(here->BSIM4GEgePtr) += m * geltd;
*(here->BSIM4GPgePtr) -= m * geltd;
*(here->BSIM4GEgpPtr) -= m * geltd;
*(here->BSIM4GPgpPtr +1) += m * xcggbr;
*(here->BSIM4GPgpPtr) += m * (geltd + xcggbi + gIgtotg);
*(here->BSIM4GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4GPdpPtr) += m * (xcgdbi + gIgtotd);
*(here->BSIM4GPspPtr +1) += m * xcgsbr;
*(here->BSIM4GPspPtr) += m * (xcgsbi + gIgtots);
*(here->BSIM4GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4GPbpPtr) += m * (xcgbbi + gIgtotb);
{ *(here->BSIM4GEgePtr) += mult_i * geltd;
*(here->BSIM4GPgePtr) -= mult_i * geltd;
*(here->BSIM4GEgpPtr) -= mult_i * geltd;
*(here->BSIM4GPgpPtr +1) += mult_q * xcggbr;
*(here->BSIM4GPgpPtr) += mult_i * (geltd + gIgtotg) + mult_q * xcggbi;
*(here->BSIM4GPdpPtr +1) += mult_q * xcgdbr;
*(here->BSIM4GPdpPtr) += mult_q * xcgdbi + mult_i * gIgtotd;
*(here->BSIM4GPspPtr +1) += mult_q * xcgsbr;
*(here->BSIM4GPspPtr) += mult_q * xcgsbi + mult_i * gIgtots;
*(here->BSIM4GPbpPtr +1) += mult_q * xcgbbr;
*(here->BSIM4GPbpPtr) += mult_q * xcgbbi + mult_i * gIgtotb;
} /* WDLiu: gcrg already subtracted from all gcrgg below */
else if (here->BSIM4rgateMod == 2)
{ *(here->BSIM4GEgePtr) += m * gcrg;
*(here->BSIM4GEgpPtr) += m * gcrgg;
*(here->BSIM4GEdpPtr) += m * gcrgd;
*(here->BSIM4GEspPtr) += m * gcrgs;
*(here->BSIM4GEbpPtr) += m * gcrgb;
*(here->BSIM4GPgePtr) -= m * gcrg;
*(here->BSIM4GPgpPtr +1) += m * xcggbr;
*(here->BSIM4GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg);
*(here->BSIM4GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd);
*(here->BSIM4GPspPtr +1) += m * xcgsbr;
*(here->BSIM4GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots);
*(here->BSIM4GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb);
{ *(here->BSIM4GEgePtr) += mult_i * gcrg;
*(here->BSIM4GEgpPtr) += mult_i * gcrgg;
*(here->BSIM4GEdpPtr) += mult_i * gcrgd;
*(here->BSIM4GEspPtr) += mult_i * gcrgs;
*(here->BSIM4GEbpPtr) += mult_i * gcrgb;
*(here->BSIM4GPgePtr) -= mult_i * gcrg;
*(here->BSIM4GPgpPtr +1) += mult_q * xcggbr;
*(here->BSIM4GPgpPtr) -= mult_i * (gcrgg - gIgtotg) - mult_q * xcggbi;
*(here->BSIM4GPdpPtr +1) += mult_q * xcgdbr;
*(here->BSIM4GPdpPtr) -= mult_i * (gcrgd - gIgtotd) - mult_q * xcgdbi;
*(here->BSIM4GPspPtr +1) += mult_q * xcgsbr;
*(here->BSIM4GPspPtr) -= mult_i * (gcrgs - gIgtots) - mult_q * xcgsbi;
*(here->BSIM4GPbpPtr +1) += mult_q * xcgbbr;
*(here->BSIM4GPbpPtr) -= mult_i * (gcrgb - gIgtotb) - mult_q * xcgbbi;
}
else if (here->BSIM4rgateMod == 3)
{ *(here->BSIM4GEgePtr) += m * geltd;
*(here->BSIM4GEgmPtr) -= m * geltd;
*(here->BSIM4GMgePtr) -= m * geltd;
*(here->BSIM4GMgmPtr) += m * (geltd + gcrg);
*(here->BSIM4GMgmPtr +1) += m * xcgmgmb;
*(here->BSIM4GMdpPtr) += m * gcrgd;
*(here->BSIM4GMdpPtr +1) += m * xcgmdb;
*(here->BSIM4GMgpPtr) += m * gcrgg;
*(here->BSIM4GMspPtr) += m * gcrgs;
*(here->BSIM4GMspPtr +1) += m * xcgmsb;
*(here->BSIM4GMbpPtr) += m * gcrgb;
*(here->BSIM4GMbpPtr +1) += m * xcgmbb;
*(here->BSIM4DPgmPtr +1) += m * xcdgmb;
*(here->BSIM4GPgmPtr) -= m * gcrg;
*(here->BSIM4SPgmPtr +1) += m * xcsgmb;
*(here->BSIM4BPgmPtr +1) += m * xcbgmb;
*(here->BSIM4GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg);
*(here->BSIM4GPgpPtr +1) += m * xcggbr;
*(here->BSIM4GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd);
*(here->BSIM4GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots);
*(here->BSIM4GPspPtr +1) += m * xcgsbr;
*(here->BSIM4GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb);
*(here->BSIM4GPbpPtr +1) += m * xcgbbr;
{ *(here->BSIM4GEgePtr) += mult_i * geltd;
*(here->BSIM4GEgmPtr) -= mult_i * geltd;
*(here->BSIM4GMgePtr) -= mult_i * geltd;
*(here->BSIM4GMgmPtr) += mult_i * (geltd + gcrg);
*(here->BSIM4GMgmPtr +1) += mult_q * xcgmgmb;
*(here->BSIM4GMdpPtr) += mult_i * gcrgd;
*(here->BSIM4GMdpPtr +1) += mult_q * xcgmdb;
*(here->BSIM4GMgpPtr) += mult_i * gcrgg;
*(here->BSIM4GMspPtr) += mult_i * gcrgs;
*(here->BSIM4GMspPtr +1) += mult_q * xcgmsb;
*(here->BSIM4GMbpPtr) += mult_i * gcrgb;
*(here->BSIM4GMbpPtr +1) += mult_q * xcgmbb;
*(here->BSIM4DPgmPtr +1) += mult_q * xcdgmb;
*(here->BSIM4GPgmPtr) -= mult_i * gcrg;
*(here->BSIM4SPgmPtr +1) += mult_q * xcsgmb;
*(here->BSIM4BPgmPtr +1) += mult_q * xcbgmb;
*(here->BSIM4GPgpPtr) -= mult_i * (gcrgg - gIgtotg) - mult_q * xcggbi;
*(here->BSIM4GPgpPtr +1) += mult_q * xcggbr;
*(here->BSIM4GPdpPtr) -= mult_i * (gcrgd - gIgtotd) - mult_q * xcgdbi;
*(here->BSIM4GPdpPtr +1) += mult_q * xcgdbr;
*(here->BSIM4GPspPtr) -= mult_i * (gcrgs - gIgtots) - mult_q * xcgsbi;
*(here->BSIM4GPspPtr +1) += mult_q * xcgsbr;
*(here->BSIM4GPbpPtr) -= mult_i * (gcrgb - gIgtotb) - mult_q * xcgbbi;
*(here->BSIM4GPbpPtr +1) += mult_q * xcgbbr;
}
else
{ *(here->BSIM4GPgpPtr +1) += m * xcggbr;
*(here->BSIM4GPgpPtr) += m * (xcggbi + gIgtotg);
*(here->BSIM4GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4GPdpPtr) += m * (xcgdbi + gIgtotd);
*(here->BSIM4GPspPtr +1) += m * xcgsbr;
*(here->BSIM4GPspPtr) += m * (xcgsbi + gIgtots);
*(here->BSIM4GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4GPbpPtr) += m * (xcgbbi + gIgtotb);
{ *(here->BSIM4GPgpPtr +1) += mult_q * xcggbr;
*(here->BSIM4GPgpPtr) += mult_q * xcggbi + mult_i * gIgtotg;
*(here->BSIM4GPdpPtr +1) += mult_q * xcgdbr;
*(here->BSIM4GPdpPtr) += mult_q * xcgdbi + mult_i * gIgtotd;
*(here->BSIM4GPspPtr +1) += mult_q * xcgsbr;
*(here->BSIM4GPspPtr) += mult_q * xcgsbi + mult_i * gIgtots;
*(here->BSIM4GPbpPtr +1) += mult_q * xcgbbr;
*(here->BSIM4GPbpPtr) += mult_q * xcgbbi + mult_i * gIgtotb;
}
if (model->BSIM4rdsMod)
{ (*(here->BSIM4DgpPtr) += m * gdtotg);
(*(here->BSIM4DspPtr) += m * gdtots);
(*(here->BSIM4DbpPtr) += m * gdtotb);
(*(here->BSIM4SdpPtr) += m * gstotd);
(*(here->BSIM4SgpPtr) += m * gstotg);
(*(here->BSIM4SbpPtr) += m * gstotb);
{ (*(here->BSIM4DgpPtr) += mult_i * gdtotg);
(*(here->BSIM4DspPtr) += mult_i * gdtots);
(*(here->BSIM4DbpPtr) += mult_i * gdtotb);
(*(here->BSIM4SdpPtr) += mult_i * gstotd);
(*(here->BSIM4SgpPtr) += mult_i * gstotg);
(*(here->BSIM4SbpPtr) += mult_i * gstotb);
}
*(here->BSIM4DPdpPtr +1) += m * (xcddbr + gdsi + RevSumi);
*(here->BSIM4DPdpPtr) += m * (gdpr + xcddbi + gdsr + here->BSIM4gbd
- gdtotd + RevSumr + gbdpdp - gIdtotd);
*(here->BSIM4DPdPtr) -= m * (gdpr + gdtot);
*(here->BSIM4DPgpPtr +1) += m * (xcdgbr + Gmi);
*(here->BSIM4DPgpPtr) += m * (Gmr + xcdgbi - gdtotg + gbdpg - gIdtotg);
*(here->BSIM4DPspPtr +1) += m * (xcdsbr - gdsi - FwdSumi);
*(here->BSIM4DPspPtr) -= m * (gdsr - xcdsbi + FwdSumr + gdtots - gbdpsp + gIdtots);
*(here->BSIM4DPbpPtr +1) += m * (xcdbbr + Gmbsi);
*(here->BSIM4DPbpPtr) -= m * (gjbd + gdtotb - xcdbbi - Gmbsr - gbdpb + gIdtotb);
*(here->BSIM4DdpPtr) -= m * (gdpr - gdtotd);
*(here->BSIM4DdPtr) += m * (gdpr + gdtot);
*(here->BSIM4SPdpPtr +1) += m * (xcsdbr - gdsi - RevSumi);
*(here->BSIM4SPdpPtr) -= m * (gdsr - xcsdbi + gstotd + RevSumr - gbspdp + gIstotd);
*(here->BSIM4SPgpPtr +1) += m * (xcsgbr - Gmi);
*(here->BSIM4SPgpPtr) -= m * (Gmr - xcsgbi + gstotg - gbspg + gIstotg);
*(here->BSIM4SPspPtr +1) += m * (xcssbr + gdsi + FwdSumi);
*(here->BSIM4SPspPtr) += m * (gspr + xcssbi + gdsr + here->BSIM4gbs
- gstots + FwdSumr + gbspsp - gIstots);
*(here->BSIM4SPsPtr) -= m * (gspr + gstot);
*(here->BSIM4SPbpPtr +1) += m * (xcsbbr - Gmbsi);
*(here->BSIM4SPbpPtr) -= m * (gjbs + gstotb - xcsbbi + Gmbsr - gbspb + gIstotb);
*(here->BSIM4SspPtr) -= m * (gspr - gstots);
*(here->BSIM4SsPtr) += m * (gspr + gstot);
*(here->BSIM4BPdpPtr +1) += m * xcbdb;
*(here->BSIM4BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd);
*(here->BSIM4BPgpPtr +1) += m * xcbgb;
*(here->BSIM4BPgpPtr) -= m * (here->BSIM4gbgs + gIbtotg);
*(here->BSIM4BPspPtr +1) += m * xcbsb;
*(here->BSIM4BPspPtr) -= m * (gjbs - gbbsp + gIbtots);
*(here->BSIM4BPbpPtr +1) += m * xcbbb;
*(here->BSIM4BPbpPtr) += m * (gjbd + gjbs - here->BSIM4gbbs
- gIbtotb);
*(here->BSIM4DPdpPtr +1) += mult_q * xcddbr + mult_i * (gdsi + RevSumi);
*(here->BSIM4DPdpPtr) += + mult_i * (gdpr + gdsr + here->BSIM4gbd
- gdtotd + RevSumr + gbdpdp - gIdtotd) + mult_q * xcddbi;
*(here->BSIM4DPdPtr) -= mult_i * (gdpr + gdtot);
*(here->BSIM4DPgpPtr +1) += mult_q * xcdgbr + mult_i * Gmi;
*(here->BSIM4DPgpPtr) += mult_i * (Gmr - gdtotg + gbdpg - gIdtotg) + mult_q * xcdgbi;
*(here->BSIM4DPspPtr +1) += mult_q * xcdsbr - mult_i * (gdsi + FwdSumi);
*(here->BSIM4DPspPtr) -= mult_i * (gdsr + FwdSumr + gdtots - gbdpsp + gIdtots) - mult_q * xcdsbi;
*(here->BSIM4DPbpPtr +1) += mult_q * xcdbbr + mult_i * Gmbsi;
*(here->BSIM4DPbpPtr) -= mult_i * (gjbd + gdtotb - Gmbsr - gbdpb + gIdtotb) - mult_q * xcdbbi;
*(here->BSIM4DdpPtr) -= mult_i * (gdpr - gdtotd);
*(here->BSIM4DdPtr) += mult_i * (gdpr + gdtot);
*(here->BSIM4SPdpPtr +1) += mult_q * xcsdbr - mult_i * (gdsi + RevSumi);
*(here->BSIM4SPdpPtr) -= mult_i * (gdsr + gstotd + RevSumr - gbspdp + gIstotd) - mult_q * xcsdbi;
*(here->BSIM4SPgpPtr +1) += mult_q * xcsgbr - mult_i * Gmi;
*(here->BSIM4SPgpPtr) -= mult_i * (Gmr + gstotg - gbspg + gIstotg) - mult_q * xcsgbi;
*(here->BSIM4SPspPtr +1) += mult_q * xcssbr + mult_i * (gdsi + FwdSumi);
*(here->BSIM4SPspPtr) += mult_i * (gspr + gdsr + here->BSIM4gbs
- gstots + FwdSumr + gbspsp - gIstots) + mult_q * xcssbi;
*(here->BSIM4SPsPtr) -= mult_i * (gspr + gstot);
*(here->BSIM4SPbpPtr +1) += mult_q * xcsbbr - mult_i * Gmbsi;
*(here->BSIM4SPbpPtr) -= mult_i * (gjbs + gstotb + Gmbsr - gbspb + gIstotb) - mult_q * xcsbbi;
*(here->BSIM4SspPtr) -= mult_i * (gspr - gstots);
*(here->BSIM4SsPtr) += mult_i * (gspr + gstot);
*(here->BSIM4BPdpPtr +1) += mult_q * xcbdb;
*(here->BSIM4BPdpPtr) -= mult_i * (gjbd - gbbdp + gIbtotd);
*(here->BSIM4BPgpPtr +1) += mult_q * xcbgb;
*(here->BSIM4BPgpPtr) -= mult_i * (here->BSIM4gbgs + gIbtotg);
*(here->BSIM4BPspPtr +1) += mult_q * xcbsb;
*(here->BSIM4BPspPtr) -= mult_i * (gjbs - gbbsp + gIbtots);
*(here->BSIM4BPbpPtr +1) += mult_q * xcbbb;
*(here->BSIM4BPbpPtr) += mult_i * (gjbd + gjbs - here->BSIM4gbbs
- gIbtotb);
ggidld = here->BSIM4ggidld;
ggidlg = here->BSIM4ggidlg;
ggidlb = here->BSIM4ggidlb;
@ -610,67 +606,67 @@ double m;
ggislb = here->BSIM4ggislb;
/* stamp gidl */
(*(here->BSIM4DPdpPtr) += m * ggidld);
(*(here->BSIM4DPgpPtr) += m * ggidlg);
(*(here->BSIM4DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4DPbpPtr) += m * ggidlb);
(*(here->BSIM4BPdpPtr) -= m * ggidld);
(*(here->BSIM4BPgpPtr) -= m * ggidlg);
(*(here->BSIM4BPspPtr) += m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4BPbpPtr) -= m * ggidlb);
(*(here->BSIM4DPdpPtr) += mult_i * ggidld);
(*(here->BSIM4DPgpPtr) += mult_i * ggidlg);
(*(here->BSIM4DPspPtr) -= mult_i * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4DPbpPtr) += mult_i * ggidlb);
(*(here->BSIM4BPdpPtr) -= mult_i * ggidld);
(*(here->BSIM4BPgpPtr) -= mult_i * ggidlg);
(*(here->BSIM4BPspPtr) += mult_i * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4BPbpPtr) -= mult_i * ggidlb);
/* stamp gisl */
(*(here->BSIM4SPdpPtr) -= m * ((ggisls + ggislg) + ggislb));
(*(here->BSIM4SPgpPtr) += m * ggislg);
(*(here->BSIM4SPspPtr) += m * ggisls);
(*(here->BSIM4SPbpPtr) += m * ggislb);
(*(here->BSIM4BPdpPtr) += m * ((ggislg + ggisls) + ggislb));
(*(here->BSIM4BPgpPtr) -= m * ggislg);
(*(here->BSIM4BPspPtr) -= m * ggisls);
(*(here->BSIM4BPbpPtr) -= m * ggislb);
(*(here->BSIM4SPdpPtr) -= mult_i * ((ggisls + ggislg) + ggislb));
(*(here->BSIM4SPgpPtr) += mult_i * ggislg);
(*(here->BSIM4SPspPtr) += mult_i * ggisls);
(*(here->BSIM4SPbpPtr) += mult_i * ggislb);
(*(here->BSIM4BPdpPtr) += mult_i * ((ggislg + ggisls) + ggislb));
(*(here->BSIM4BPgpPtr) -= mult_i * ggislg);
(*(here->BSIM4BPspPtr) -= mult_i * ggisls);
(*(here->BSIM4BPbpPtr) -= mult_i * ggislb);
if (here->BSIM4rbodyMod)
{ (*(here->BSIM4DPdbPtr +1) += m * xcdbdb);
(*(here->BSIM4DPdbPtr) -= m * here->BSIM4gbd);
(*(here->BSIM4SPsbPtr +1) += m * xcsbsb);
(*(here->BSIM4SPsbPtr) -= m * here->BSIM4gbs);
(*(here->BSIM4DBdpPtr +1) += m * xcdbdb);
(*(here->BSIM4DBdpPtr) -= m * here->BSIM4gbd);
(*(here->BSIM4DBdbPtr +1) -= m * xcdbdb);
(*(here->BSIM4DBdbPtr) += m * (here->BSIM4gbd + here->BSIM4grbpd
{ (*(here->BSIM4DPdbPtr +1) += mult_q * xcdbdb);
(*(here->BSIM4DPdbPtr) -= mult_i * here->BSIM4gbd);
(*(here->BSIM4SPsbPtr +1) += mult_q * xcsbsb);
(*(here->BSIM4SPsbPtr) -= mult_i * here->BSIM4gbs);
(*(here->BSIM4DBdpPtr +1) += mult_q * xcdbdb);
(*(here->BSIM4DBdpPtr) -= mult_i * here->BSIM4gbd);
(*(here->BSIM4DBdbPtr +1) -= mult_q * xcdbdb);
(*(here->BSIM4DBdbPtr) += mult_i * (here->BSIM4gbd + here->BSIM4grbpd
+ here->BSIM4grbdb));
(*(here->BSIM4DBbpPtr) -= m * here->BSIM4grbpd);
(*(here->BSIM4DBbPtr) -= m * here->BSIM4grbdb);
(*(here->BSIM4BPdbPtr) -= m * here->BSIM4grbpd);
(*(here->BSIM4BPbPtr) -= m * here->BSIM4grbpb);
(*(here->BSIM4BPsbPtr) -= m * here->BSIM4grbps);
(*(here->BSIM4BPbpPtr) += m * (here->BSIM4grbpd + here->BSIM4grbps
+ here->BSIM4grbpb));
/* WDLiu: (-here->BSIM4gbbs) already added to BPbpPtr */
(*(here->BSIM4SBspPtr +1) += m * xcsbsb);
(*(here->BSIM4SBspPtr) -= m * here->BSIM4gbs);
(*(here->BSIM4SBbpPtr) -= m * here->BSIM4grbps);
(*(here->BSIM4SBbPtr) -= m * here->BSIM4grbsb);
(*(here->BSIM4SBsbPtr +1) -= m * xcsbsb);
(*(here->BSIM4SBsbPtr) += m * (here->BSIM4gbs
+ here->BSIM4grbps + here->BSIM4grbsb));
(*(here->BSIM4BdbPtr) -= m * here->BSIM4grbdb);
(*(here->BSIM4BbpPtr) -= m * here->BSIM4grbpb);
(*(here->BSIM4BsbPtr) -= m * here->BSIM4grbsb);
(*(here->BSIM4BbPtr) += m * (here->BSIM4grbsb + here->BSIM4grbdb
(*(here->BSIM4DBbpPtr) -= mult_i * here->BSIM4grbpd);
(*(here->BSIM4DBbPtr) -= mult_i * here->BSIM4grbdb);
(*(here->BSIM4BPdbPtr) -= mult_i * here->BSIM4grbpd);
(*(here->BSIM4BPbPtr) -= mult_i * here->BSIM4grbpb);
(*(here->BSIM4BPsbPtr) -= mult_i * here->BSIM4grbps);
(*(here->BSIM4BPbpPtr) += mult_i * (here->BSIM4grbpd + here->BSIM4grbps
+ here->BSIM4grbpb));
/* WDLiu: (-here->BSIM4gbbs) already added to BPbpPtr */
(*(here->BSIM4SBspPtr +1) += mult_q * xcsbsb);
(*(here->BSIM4SBspPtr) -= mult_i * here->BSIM4gbs);
(*(here->BSIM4SBbpPtr) -= mult_i * here->BSIM4grbps);
(*(here->BSIM4SBbPtr) -= mult_i * here->BSIM4grbsb);
(*(here->BSIM4SBsbPtr +1) -= mult_q * xcsbsb);
(*(here->BSIM4SBsbPtr) += mult_i * (here->BSIM4gbs
+ here->BSIM4grbps + here->BSIM4grbsb));
(*(here->BSIM4BdbPtr) -= mult_i * here->BSIM4grbdb);
(*(here->BSIM4BbpPtr) -= mult_i * here->BSIM4grbpb);
(*(here->BSIM4BsbPtr) -= mult_i * here->BSIM4grbsb);
(*(here->BSIM4BbPtr) += mult_i * (here->BSIM4grbsb + here->BSIM4grbdb
+ here->BSIM4grbpb));
}
/*
* WDLiu: The internal charge node generated for transient NQS is not needed for
* AC NQS. The following is not doing a real job, but we have to keep it;
* otherwise a singular AC NQS matrix may occur if the transient NQS is on.
* The charge node is isolated from the instance.
*/
/*
* WDLiu: The internal charge node generated for transient NQS is not needed for
* AC NQS. The following is not doing a real job, but we have to keep it;
* otherwise a singular AC NQS matrix may occur if the transient NQS is on.
* The charge node is isolated from the instance.
*/
if (here->BSIM4trnqsMod)
{ (*(here->BSIM4QqPtr) += m * 1.0);
(*(here->BSIM4QgpPtr) += 0.0);

212
src/spicelib/devices/bsim4/b4ask.c
View File

@ -1,31 +1,28 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#include "ngspice/ngspice.h"
#include "ngspice/ifsim.h"
#include "ngspice/cktdefs.h"
@ -46,7 +43,7 @@ BSIM4instance *here = (BSIM4instance*)inst;
NG_IGNORE(select);
switch(which)
switch(which)
{ case BSIM4_L:
value->rValue = here->BSIM4l;
return(OK);
@ -56,6 +53,15 @@ BSIM4instance *here = (BSIM4instance*)inst;
case BSIM4_M:
value->rValue = here->BSIM4m;
return(OK);
case BSIM4_MULT_I:
value->rValue = here->BSIM4mult_i;
return(OK);
case BSIM4_MULT_Q:
value->rValue = here->BSIM4mult_q;
return(OK);
case BSIM4_MULT_FN:
value->rValue = here->BSIM4mult_fn;
return(OK);
case BSIM4_NF:
value->rValue = here->BSIM4nf;
return(OK);
@ -123,12 +129,6 @@ BSIM4instance *here = (BSIM4instance*)inst;
case BSIM4_DELVTO:
value->rValue = here->BSIM4delvto;
return(OK);
case BSIM4_MULU0:
value->rValue = here->BSIM4mulu0;
return(OK);
case BSIM4_WNFLAG:
value->iValue = here->BSIM4wnflag;
return(OK);
case BSIM4_XGW:
value->rValue = here->BSIM4xgw;
return(OK);
@ -197,11 +197,11 @@ BSIM4instance *here = (BSIM4instance*)inst;
return(OK);
case BSIM4_SOURCECONDUCT:
value->rValue = here->BSIM4sourceConductance;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_DRAINCONDUCT:
value->rValue = here->BSIM4drainConductance;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_VBD:
value->rValue = *(ckt->CKTstate0 + here->BSIM4vbd);
@ -216,204 +216,202 @@ BSIM4instance *here = (BSIM4instance*)inst;
value->rValue = *(ckt->CKTstate0 + here->BSIM4vds);
return(OK);
case BSIM4_CD:
value->rValue = here->BSIM4cd;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4cd;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_CBS:
value->rValue = here->BSIM4cbs;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4cbs;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_CBD:
value->rValue = here->BSIM4cbd;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4cbd;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_CSUB:
value->rValue = here->BSIM4csub;
value->rValue *= here->BSIM4m;
return(OK);
case BSIM4_QINV:
value->rValue = here-> BSIM4qinv;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4csub;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_IGIDL:
value->rValue = here->BSIM4Igidl;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4Igidl;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_IGISL:
value->rValue = here->BSIM4Igisl;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4Igisl;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_IGS:
value->rValue = here->BSIM4Igs;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4Igs;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_IGD:
value->rValue = here->BSIM4Igd;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4Igd;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_IGB:
value->rValue = here->BSIM4Igb;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4Igb;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_IGCS:
value->rValue = here->BSIM4Igcs;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4Igcs;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_IGCD:
value->rValue = here->BSIM4Igcd;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4Igcd;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_GM:
value->rValue = here->BSIM4gm;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4gm;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_GDS:
value->rValue = here->BSIM4gds;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4gds;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_GMBS:
value->rValue = here->BSIM4gmbs;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4gmbs;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_GBD:
value->rValue = here->BSIM4gbd;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4gbd;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_GBS:
value->rValue = here->BSIM4gbs;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4gbs;
value->rValue *= here->BSIM4mult_i;
return(OK);
/* case BSIM4_QB:
value->rValue = *(ckt->CKTstate0 + here->BSIM4qb);
value->rValue = *(ckt->CKTstate0 + here->BSIM4qb);
return(OK); */
case BSIM4_CQB:
value->rValue = *(ckt->CKTstate0 + here->BSIM4cqb);
value->rValue = *(ckt->CKTstate0 + here->BSIM4cqb);
return(OK);
/* case BSIM4_QG:
value->rValue = *(ckt->CKTstate0 + here->BSIM4qg);
value->rValue = *(ckt->CKTstate0 + here->BSIM4qg);
return(OK); */
case BSIM4_CQG:
value->rValue = *(ckt->CKTstate0 + here->BSIM4cqg);
value->rValue = *(ckt->CKTstate0 + here->BSIM4cqg);
return(OK);
/* case BSIM4_QD:
value->rValue = *(ckt->CKTstate0 + here->BSIM4qd);
value->rValue = *(ckt->CKTstate0 + here->BSIM4qd);
return(OK); */
case BSIM4_CQD:
value->rValue = *(ckt->CKTstate0 + here->BSIM4cqd);
value->rValue = *(ckt->CKTstate0 + here->BSIM4cqd);
return(OK);
/* case BSIM4_QS:
value->rValue = *(ckt->CKTstate0 + here->BSIM4qs);
value->rValue = *(ckt->CKTstate0 + here->BSIM4qs);
return(OK); */
case BSIM4_QB:
value->rValue = here->BSIM4qbulk;
value->rValue *= here->BSIM4m;
return(OK);
value->rValue = here->BSIM4qbulk;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_QG:
value->rValue = here->BSIM4qgate;
value->rValue *= here->BSIM4m;
return(OK);
value->rValue = here->BSIM4qgate;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_QS:
value->rValue = here->BSIM4qsrc;
value->rValue *= here->BSIM4m;
return(OK);
value->rValue = here->BSIM4qsrc;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_QD:
value->rValue = here->BSIM4qdrn;
value->rValue *= here->BSIM4m;
return(OK);
value->rValue = here->BSIM4qdrn;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_QINV:
value->rValue = here->BSIM4qinv;
return(OK);
case BSIM4_QDEF:
value->rValue = *(ckt->CKTstate0 + here->BSIM4qdef);
return(OK);
value->rValue = *(ckt->CKTstate0 + here->BSIM4qdef);
return(OK);
case BSIM4_GCRG:
value->rValue = here->BSIM4gcrg;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_i;
return(OK);
case BSIM4_GTAU:
value->rValue = here->BSIM4gtau;
value->rValue *= here->BSIM4m;
return(OK);
case BSIM4_CGGB:
value->rValue = here->BSIM4cggb;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4cggb;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CGDB:
value->rValue = here->BSIM4cgdb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CGSB:
value->rValue = here->BSIM4cgsb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CDGB:
value->rValue = here->BSIM4cdgb;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4cdgb;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CDDB:
value->rValue = here->BSIM4cddb;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4cddb;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CDSB:
value->rValue = here->BSIM4cdsb;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4cdsb;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CBGB:
value->rValue = here->BSIM4cbgb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CBDB:
value->rValue = here->BSIM4cbdb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CBSB:
value->rValue = here->BSIM4cbsb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CSGB:
value->rValue = here->BSIM4csgb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CSDB:
value->rValue = here->BSIM4csdb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CSSB:
value->rValue = here->BSIM4cssb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CGBB:
value->rValue = here->BSIM4cgbb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CDBB:
value->rValue = here->BSIM4cdbb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CSBB:
value->rValue = here->BSIM4csbb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CBBB:
value->rValue = here->BSIM4cbbb;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CAPBD:
value->rValue = here->BSIM4capbd;
value->rValue *= here->BSIM4m;
value->rValue = here->BSIM4capbd;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_CAPBS:
value->rValue = here->BSIM4capbs;
value->rValue *= here->BSIM4m;
value->rValue *= here->BSIM4mult_q;
return(OK);
case BSIM4_VON:
value->rValue = here->BSIM4von;
value->rValue = here->BSIM4von;
return(OK);
case BSIM4_VDSAT:
value->rValue = here->BSIM4vdsat;
value->rValue = here->BSIM4vdsat;
return(OK);
case BSIM4_QBS:
value->rValue = *(ckt->CKTstate0 + here->BSIM4qbs);
value->rValue = *(ckt->CKTstate0 + here->BSIM4qbs);
return(OK);
case BSIM4_QBD:
value->rValue = *(ckt->CKTstate0 + here->BSIM4qbd);
value->rValue = *(ckt->CKTstate0 + here->BSIM4qbd);
return(OK);
case BSIM4_VGSTEFF:
value->rValue = here->BSIM4Vgsteff;

722
src/spicelib/devices/bsim4/b4check.c
File diff suppressed because it is too large
View File

59
src/spicelib/devices/bsim4/b4cvtest.c
View File

@ -1,31 +1,28 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#include "ngspice/ngspice.h"
#include "ngspice/cktdefs.h"
#include "bsim4def.h"
@ -35,7 +32,6 @@ under the License.
#include "ngspice/sperror.h"
#include "ngspice/suffix.h"
int
BSIM4convTest(
GENmodel *inModel,
@ -44,7 +40,7 @@ CKTcircuit *ckt)
BSIM4model *model = (BSIM4model*)inModel;
BSIM4instance *here;
double delvbd, delvbs, delvds, delvgd, delvgs;
double delvdbd, delvsbs;
double delvdbd, delvsbs;
double delvbd_jct, delvbs_jct;
double vds, vgs, vgd, vgdo, vbs, vbd;
double vdbd, vdbs, vsbs;
@ -57,8 +53,7 @@ double tol0, tol1, tol2, tol3, tol4, tol5, tol6;
for (; model != NULL; model = BSIM4nextModel(model))
{ for (here = BSIM4instances(model); here != NULL ;
here=BSIM4nextInstance(here))
{
vds = model->BSIM4type
{ vds = model->BSIM4type
* (*(ckt->CKTrhsOld + here->BSIM4dNodePrime)
- *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
vgs = model->BSIM4type
@ -72,14 +67,14 @@ double tol0, tol1, tol2, tol3, tol4, tol5, tol6;
- *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
vsbs = model->BSIM4type
* (*(ckt->CKTrhsOld + here->BSIM4sbNode)
- *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
- *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
vses = model->BSIM4type
* (*(ckt->CKTrhsOld + here->BSIM4sNode)
- *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
vdes = model->BSIM4type
* (*(ckt->CKTrhsOld + here->BSIM4dNode)
- *(ckt->CKTrhsOld + here->BSIM4sNodePrime));
vgdo = *(ckt->CKTstate0 + here->BSIM4vgs)
- *(ckt->CKTstate0 + here->BSIM4vds);
vbd = vbs - vds;
@ -125,11 +120,11 @@ double tol0, tol1, tol2, tol3, tol4, tol5, tol6;
* delvds + here->BSIM4gIgbb * delvbs;
}
else
{ Idtot = here->BSIM4cd + here->BSIM4cbd - here->BSIM4Igidl; /* bugfix */
cdhat = Idtot + here->BSIM4gbd * delvbd_jct + here->BSIM4gmbs
* delvbd + here->BSIM4gm * delvgd
- (here->BSIM4gds + here->BSIM4ggidls) * delvds
- here->BSIM4ggidlg * delvgs - here->BSIM4ggidlb * delvbs;
{ Idtot = here->BSIM4cd + here->BSIM4cbd - here->BSIM4Igidl; /* bugfix */
cdhat = Idtot + here->BSIM4gbd * delvbd_jct + here->BSIM4gmbs
* delvbd + here->BSIM4gm * delvgd
- (here->BSIM4gds + here->BSIM4ggidls) * delvds
- here->BSIM4ggidlg * delvgs - here->BSIM4ggidlb * delvbs;
Igstot = here->BSIM4Igs + here->BSIM4Igcd;
cgshat = Igstot + here->BSIM4gIgsg * delvgs + here->BSIM4gIgcdg * delvgd
@ -176,7 +171,7 @@ double tol0, tol1, tol2, tol3, tol4, tol5, tol6;
|| (fabs(cdedhat - Idedtot) >= tol2))
{ ckt->CKTnoncon++;
return(OK);
}
}
if ((fabs(cgshat - Igstot) >= tol3) || (fabs(cgdhat - Igdtot) >= tol4)
|| (fabs(cgbhat - Igbtot) >= tol5))
@ -194,15 +189,15 @@ double tol0, tol1, tol2, tol3, tol4, tol5, tol6;
- here->BSIM4ggislg * delvgd - here->BSIM4ggislb* delvbd + here->BSIM4ggisls * delvds ;
}
else
{ cbhat = Ibtot + here->BSIM4gbs * delvbs_jct + here->BSIM4gbd
* delvbd_jct - (here->BSIM4gbbs + here->BSIM4ggislb) * delvbd
- (here->BSIM4gbgs + here->BSIM4ggislg) * delvgd
+ (here->BSIM4gbds + here->BSIM4ggisld - here->BSIM4ggidls) * delvds
- here->BSIM4ggidlg * delvgs - here->BSIM4ggidlb * delvbs;
{ cbhat = Ibtot + here->BSIM4gbs * delvbs_jct + here->BSIM4gbd
* delvbd_jct - (here->BSIM4gbbs + here->BSIM4ggislb) * delvbd
- (here->BSIM4gbgs + here->BSIM4ggislg) * delvgd
+ (here->BSIM4gbds + here->BSIM4ggisld - here->BSIM4ggidls) * delvds
- here->BSIM4ggidlg * delvgs - here->BSIM4ggidlb * delvbs;
}
tol6 = ckt->CKTreltol * MAX(fabs(cbhat),
fabs(Ibtot)) + ckt->CKTabstol;
if (fabs(cbhat - Ibtot) > tol6)
tol6 = ckt->CKTreltol * MAX(fabs(cbhat),
fabs(Ibtot)) + ckt->CKTabstol;
if (fabs(cbhat - Ibtot) > tol6)
{ ckt->CKTnoncon++;
return(OK);
}

224
src/spicelib/devices/bsim4/b4geo.c
View File

@ -1,35 +1,30 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#include "ngspice/ngspice.h"
#include "bsim4def.h"
static int
BSIM4NumFingerDiff(
double nf,
@ -38,32 +33,30 @@ double *nuIntD, double *nuEndD, double *nuIntS, double *nuEndS)
{
int NF;
NF = (int)nf;
if ((NF%2) != 0)
{ *nuEndD = *nuEndS = 1.0;
*nuIntD = *nuIntS = 2.0 * MAX((nf - 1.0) / 2.0, 0.0);
}
else
{ if (minSD == 1) /* minimize # of source */
{ *nuEndD = 2.0;
*nuIntD = 2.0 * MAX((nf / 2.0 - 1.0), 0.0);
*nuEndS = 0.0;
*nuIntS = nf;
}
else
{ *nuEndD = 0.0;
if ((NF%2) != 0)
{ *nuEndD = *nuEndS = 1.0;
*nuIntD = *nuIntS = 2.0 * MAX((nf - 1.0) / 2.0, 0.0);
}
else
{ if (minSD == 1) /* minimize # of source */
{ *nuEndD = 2.0;
*nuIntD = 2.0 * MAX((nf / 2.0 - 1.0), 0.0);
*nuEndS = 0.0;
*nuIntS = nf;
}
else
{ *nuEndD = 0.0;
*nuIntD = nf;
*nuEndS = 2.0;
*nuIntS = 2.0 * MAX((nf / 2.0 - 1.0), 0.0);
}
}
}
}
return 0;
}
int
BSIM4PAeffGeo(
double nf,
int geo, int minSD,
double nf, int geo, int minSD,
double Weffcj, double DMCG, double DMCI, double DMDG,
double *Ps, double *Pd, double *As, double *Ad)
{
@ -72,29 +65,29 @@ double ADiso, ADsha, ADmer, ASiso, ASsha, ASmer;
double PDiso, PDsha, PDmer, PSiso, PSsha, PSmer;
double nuIntD = 0.0, nuEndD = 0.0, nuIntS = 0.0, nuEndS = 0.0;
if (geo < 9) /* For geo = 9 and 10, the numbers of S/D diffusions already known */
BSIM4NumFingerDiff(nf, minSD, &nuIntD, &nuEndD, &nuIntS, &nuEndS);
if (geo < 9) /* For geo = 9 and 10, the numbers of S/D diffusions already known */
BSIM4NumFingerDiff(nf, minSD, &nuIntD, &nuEndD, &nuIntS, &nuEndS);
T0 = DMCG + DMCI;
T1 = DMCG + DMCG;
T2 = DMDG + DMDG;
T0 = DMCG + DMCI;
T1 = DMCG + DMCG;
T2 = DMDG + DMDG;
PSiso = PDiso = T0 + T0 + Weffcj;
PSsha = PDsha = T1;
PSmer = PDmer = T2;
PSiso = PDiso = T0 + T0 + Weffcj;
PSsha = PDsha = T1;
PSmer = PDmer = T2;
ASiso = ADiso = T0 * Weffcj;
ASsha = ADsha = DMCG * Weffcj;
ASmer = ADmer = DMDG * Weffcj;
ASiso = ADiso = T0 * Weffcj;
ASsha = ADsha = DMCG * Weffcj;
ASmer = ADmer = DMDG * Weffcj;
switch(geo)
{ case 0:
*Ps = nuEndS * PSiso + nuIntS * PSsha;
*Pd = nuEndD * PDiso + nuIntD * PDsha;
*As = nuEndS * ASiso + nuIntS * ASsha;
*Ad = nuEndD * ADiso + nuIntD * ADsha;
break;
case 1:
switch(geo)
{ case 0:
*Ps = nuEndS * PSiso + nuIntS * PSsha;
*Pd = nuEndD * PDiso + nuIntD * PDsha;
*As = nuEndS * ASiso + nuIntS * ASsha;
*Ad = nuEndD * ADiso + nuIntD * ADsha;
break;
case 1:
*Ps = nuEndS * PSiso + nuIntS * PSsha;
*Pd = (nuEndD + nuIntD) * PDsha;
*As = nuEndS * ASiso + nuIntS * ASsha;
@ -154,61 +147,59 @@ double nuIntD = 0.0, nuEndD = 0.0, nuIntS = 0.0, nuEndS = 0.0;
*As = nf * ASsha;
*Ad = ADiso + (nf - 1.0) * ADsha;
break;
default:
printf("Warning: Specified GEO = %d not matched\n", geo);
}
default:
printf("Warning: Specified GEO = %d not matched\n", geo);
}
return 0;
}
int
BSIM4RdseffGeo(
double nf,
int geo, int rgeo, int minSD,
double Weffcj, double Rsh, double DMCG, double DMCI, double DMDG,
int Type,
double nf, int geo, int rgeo, int minSD,
double Weffcj, double Rsh, double DMCG, double DMCI, double DMDG, int Type,
double *Rtot)
{
double Rint=0.0, Rend = 0.0;
double Rint = 0.0, Rend = 0.0;
double nuIntD = 0.0, nuEndD = 0.0, nuIntS = 0.0, nuEndS = 0.0;
if (geo < 9) /* since geo = 9 and 10 only happen when nf = even */
{ BSIM4NumFingerDiff(nf, minSD, &nuIntD, &nuEndD, &nuIntS, &nuEndS);
/* Internal S/D resistance -- assume shared S or D and all wide contacts */
if (Type == 1)
{ if (nuIntS == 0.0)
Rint = 0.0;
else
Rint = Rsh * DMCG / ( Weffcj * nuIntS);
}
else
{ if (nuIntD == 0.0)
if (Type == 1)
{ if (nuIntS == 0.0)
Rint = 0.0;
else
Rint = Rsh * DMCG / ( Weffcj * nuIntS);
}
else
{ if (nuIntD == 0.0)
Rint = 0.0;
else
else
Rint = Rsh * DMCG / ( Weffcj * nuIntD);
}
}
}
}
/* End S/D resistance -- geo dependent */
switch(geo)
{ case 0:
if (Type == 1) BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndS, rgeo, 1, &Rend);
else BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndD, rgeo, 0, &Rend);
if (Type == 1) BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndS, rgeo, 1, &Rend);
else BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndD, rgeo, 0, &Rend);
break;
case 1:
if (Type == 1) BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndS, rgeo, 1, &Rend);
else BSIM4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndD, rgeo, 0, &Rend);
nuEndD, rgeo, 0, &Rend);
break;
case 2:
if (Type == 1) BSIM4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndS, rgeo, 1, &Rend);
nuEndS, rgeo, 1, &Rend);
else BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndD, rgeo, 0, &Rend);
nuEndD, rgeo, 0, &Rend);
break;
case 3:
if (Type == 1) BSIM4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG,
@ -237,20 +228,20 @@ double nuIntD = 0.0, nuEndD = 0.0, nuIntS = 0.0, nuEndS = 0.0;
nuEndD, rgeo, 0, &Rend);
break;
case 8:
Rend = Rsh * DMDG / Weffcj;
Rend = Rsh * DMDG / Weffcj;
break;
case 9: /* all wide contacts assumed for geo = 9 and 10 */
if (Type == 1)
{ Rend = 0.5 * Rsh * DMCG / Weffcj;
if (nf == 2.0)
Rint = 0.0;
else
Rint = Rsh * DMCG / (Weffcj * (nf - 2.0));
}
else
{ Rend = 0.0;
if (Type == 1)
{ Rend = 0.5 * Rsh * DMCG / Weffcj;
if (nf == 2.0)
Rint = 0.0;
else
Rint = Rsh * DMCG / (Weffcj * (nf - 2.0));
}
else
{ Rend = 0.0;
Rint = Rsh * DMCG / (Weffcj * nf);
}
}
break;
case 10:
if (Type == 1)
@ -269,14 +260,14 @@ double nuIntD = 0.0, nuEndD = 0.0, nuIntS = 0.0, nuEndS = 0.0;
printf("Warning: Specified GEO = %d not matched\n", geo);
}
if (Rint <= 0.0)
*Rtot = Rend;
else if (Rend <= 0.0)
*Rtot = Rint;
else
*Rtot = Rint * Rend / (Rint + Rend);
if (Rint <= 0.0)
*Rtot = Rend;
else if (Rend <= 0.0)
*Rtot = Rint;
else
*Rtot = Rint * Rend / (Rint + Rend);
if(*Rtot==0.0)
printf("Warning: Zero resistance returned from RdseffGeo\n");
printf("Warning: Zero resistance returned from RdseffGeo\n");
return 0;
}
@ -284,38 +275,35 @@ return 0;
int
BSIM4RdsEndIso(
double Weffcj, double Rsh, double DMCG, double DMCI, double DMDG,
double nuEnd,
int rgeo, int Type,
double *Rend)
{
NG_IGNORE(DMDG);
if (Type == 1)
{ switch(rgeo)
{ case 1:
case 2:
case 5:
if (nuEnd == 0.0)
*Rend = 0.0;
else
double nuEnd, int rgeo, int Type, double *Rend)
{
NG_IGNORE(DMDG);
if (Type == 1)
{ switch(rgeo)
{ case 1:
case 2:
case 5:
if (nuEnd == 0.0)
*Rend = 0.0;
else
*Rend = Rsh * DMCG / (Weffcj * nuEnd);
break;
break;
case 3:
case 4:
case 6:
if ((DMCG + DMCI) == 0.0)
if ((DMCG + DMCI) == 0.0)
printf("(DMCG + DMCI) can not be equal to zero\n");
if ((nuEnd == 0.0)||((DMCG+DMCI)==0.0))
*Rend = 0.0;
else
*Rend = Rsh * Weffcj / (3.0 * nuEnd * (DMCG + DMCI));
break;
default:
printf("Warning: Specified RGEO = %d not matched\n", rgeo);
default:
printf("Warning: Specified RGEO = %d not matched\n", rgeo);
}
}
else
{ switch(rgeo)
}
else
{ switch(rgeo)
{ case 1:
case 3:
case 7:
@ -337,7 +325,7 @@ double *Rend)
default:
printf("Warning: Specified RGEO = %d not matched\n", rgeo);
}
}
}
return 0;
}
@ -345,9 +333,7 @@ return 0;
int
BSIM4RdsEndSha(
double Weffcj, double Rsh, double DMCG, double DMCI, double DMDG,
double nuEnd,
int rgeo, int Type,
double *Rend)
double nuEnd, int rgeo, int Type, double *Rend)
{
NG_IGNORE(DMCI);
NG_IGNORE(DMDG);

47
src/spicelib/devices/bsim4/b4getic.c
View File

@ -1,20 +1,13 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
@ -24,6 +17,9 @@ http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#include "ngspice/ngspice.h"
@ -32,7 +28,6 @@ under the License.
#include "ngspice/sperror.h"
#include "ngspice/suffix.h"
int
BSIM4getic(
GENmodel *inModel,
@ -43,20 +38,20 @@ BSIM4instance *here;
for (; model ; model = BSIM4nextModel(model))
{ for (here = BSIM4instances(model); here; here = BSIM4nextInstance(here))
{
if (!here->BSIM4icVDSGiven)
{ here->BSIM4icVDS = *(ckt->CKTrhs + here->BSIM4dNode)
- *(ckt->CKTrhs + here->BSIM4sNode);
}
if (!here->BSIM4icVGSGiven)
{ here->BSIM4icVGS = *(ckt->CKTrhs + here->BSIM4gNodeExt)
- *(ckt->CKTrhs + here->BSIM4sNode);
}
if(!here->BSIM4icVBSGiven)
{ here->BSIM4icVBS = *(ckt->CKTrhs + here->BSIM4bNode)
- *(ckt->CKTrhs + here->BSIM4sNode);
}
}
{
if (!here->BSIM4icVDSGiven)
{ here->BSIM4icVDS = *(ckt->CKTrhs + here->BSIM4dNode)
- *(ckt->CKTrhs + here->BSIM4sNode);
}
if (!here->BSIM4icVGSGiven)
{ here->BSIM4icVGS = *(ckt->CKTrhs + here->BSIM4gNodeExt)
- *(ckt->CKTrhs + here->BSIM4sNode);
}
if(!here->BSIM4icVBSGiven)
{ here->BSIM4icVBS = *(ckt->CKTrhs + here->BSIM4bNode)
- *(ckt->CKTrhs + here->BSIM4sNode);
}
}
}
return(OK);
}

3700
src/spicelib/devices/bsim4/b4ld.c
File diff suppressed because it is too large
View File

648
src/spicelib/devices/bsim4/b4mask.c
File diff suppressed because it is too large
View File

20
src/spicelib/devices/bsim4/b4mdel.c
View File

@ -1,29 +1,25 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#include "ngspice/ngspice.h"

392
src/spicelib/devices/bsim4/b4mpar.c
File diff suppressed because it is too large
View File

858
src/spicelib/devices/bsim4/b4noi.c
File diff suppressed because it is too large
View File

50
src/spicelib/devices/bsim4/b4par.c
View File

@ -1,29 +1,25 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#include "ngspice/ngspice.h"
@ -49,9 +45,9 @@ IFvalue *select)
if (!cp_getvar("scale", CP_REAL, &scale, 0))
scale = 1;
switch (param) {
case BSIM4_W:
here->BSIM4w = value->rValue * scale;
switch(param)
{ case BSIM4_W:
here->BSIM4w = value->rValue * scale;
here->BSIM4wGiven = TRUE;
break;
case BSIM4_L:
@ -62,6 +58,18 @@ IFvalue *select)
here->BSIM4m = value->rValue;
here->BSIM4mGiven = TRUE;
break;
case BSIM4_MULT_I:
here->BSIM4mult_i = value->rValue;
here->BSIM4mult_iGiven = TRUE;
break;
case BSIM4_MULT_Q:
here->BSIM4mult_q = value->rValue;
here->BSIM4mult_qGiven = TRUE;
break;
case BSIM4_MULT_FN:
here->BSIM4mult_fn = value->rValue;
here->BSIM4mult_fnGiven = TRUE;
break;
case BSIM4_NF:
here->BSIM4nf = value->rValue;
here->BSIM4nfGiven = TRUE;
@ -149,14 +157,6 @@ IFvalue *select)
here->BSIM4delvto = value->rValue;
here->BSIM4delvtoGiven = TRUE;
break;
case BSIM4_MULU0:
here->BSIM4mulu0 = value->rValue;
here->BSIM4mulu0Given = TRUE;
break;
case BSIM4_WNFLAG:
here->BSIM4wnflag = value->iValue;
here->BSIM4wnflagGiven = TRUE;
break;
case BSIM4_XGW:
here->BSIM4xgw = value->rValue;
here->BSIM4xgwGiven = TRUE;
@ -204,8 +204,8 @@ IFvalue *select)
case BSIM4_IC:
/* FALLTHROUGH added to suppress GCC warning due to
* -Wimplicit-fallthrough flag */
switch (value->v.numValue) {
case 3:
switch(value->v.numValue)
{ case 3:
here->BSIM4icVBS = *(value->v.vec.rVec+2);
here->BSIM4icVBSGiven = TRUE;
/* FALLTHROUGH */

585
src/spicelib/devices/bsim4/b4pzld.c
View File

@ -1,31 +1,26 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
*/
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#include "ngspice/ngspice.h"
#include "ngspice/cktdefs.h"
#include "ngspice/complex.h"
@ -64,14 +59,12 @@ double T0=0.0, T1, CoxWL, qcheq, Cdg, Cdd, Cds, Csg, Csd, Css;
double ScalingFactor = 1.0e-9;
struct bsim4SizeDependParam *pParam;
double ggidld, ggidlg, ggidlb, ggislg, ggislb, ggisls;
double m;
double m, mult_i, mult_q;
for (; model != NULL; model = BSIM4nextModel(model))
{ for (here = BSIM4instances(model); here!= NULL;
here = BSIM4nextInstance(here))
{
pParam = here->pParam;
{ pParam = here->pParam;
capbd = here->BSIM4capbd;
capbs = here->BSIM4capbs;
cgso = here->BSIM4cgso;
@ -224,7 +217,7 @@ double m;
xcdgb = xcddb = xcdsb = xcdbb = 0.0;
xcsgb = xcsdb = xcssb = xcsbb = 0.0;
xgtg = here->BSIM4gtg;
xgtg = here->BSIM4gtg;
xgtd = here->BSIM4gtd;
xgts = here->BSIM4gts;
xgtb = here->BSIM4gtb;
@ -234,46 +227,46 @@ double m;
xcqsb = here->BSIM4cqsb;
xcqbb = here->BSIM4cqbb;
CoxWL = model->BSIM4coxe * here->pParam->BSIM4weffCV
CoxWL = model->BSIM4coxe * here->pParam->BSIM4weffCV
* here->BSIM4nf * here->pParam->BSIM4leffCV;
qcheq = -(here->BSIM4qgate + here->BSIM4qbulk);
if (fabs(qcheq) <= 1.0e-5 * CoxWL)
{ if (model->BSIM4xpart < 0.5)
{ dxpart = 0.4;
}
else if (model->BSIM4xpart > 0.5)
{ dxpart = 0.0;
}
else
{ dxpart = 0.5;
}
ddxpart_dVd = ddxpart_dVg = ddxpart_dVb
= ddxpart_dVs = 0.0;
}
else
{ dxpart = here->BSIM4qdrn / qcheq;
Cdd = here->BSIM4cddb;
Csd = -(here->BSIM4cgdb + here->BSIM4cddb
+ here->BSIM4cbdb);
ddxpart_dVd = (Cdd - dxpart * (Cdd + Csd)) / qcheq;
Cdg = here->BSIM4cdgb;
Csg = -(here->BSIM4cggb + here->BSIM4cdgb
+ here->BSIM4cbgb);
ddxpart_dVg = (Cdg - dxpart * (Cdg + Csg)) / qcheq;
Cds = here->BSIM4cdsb;
Css = -(here->BSIM4cgsb + here->BSIM4cdsb
+ here->BSIM4cbsb);
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);
qcheq = -(here->BSIM4qgate + here->BSIM4qbulk);
if (fabs(qcheq) <= 1.0e-5 * CoxWL)
{ if (model->BSIM4xpart < 0.5)
{ dxpart = 0.4;
}
else if (model->BSIM4xpart > 0.5)
{ dxpart = 0.0;
}
else
{ dxpart = 0.5;
}
ddxpart_dVd = ddxpart_dVg = ddxpart_dVb
= ddxpart_dVs = 0.0;
}
else
{ dxpart = here->BSIM4qdrn / qcheq;
Cdd = here->BSIM4cddb;
Csd = -(here->BSIM4cgdb + here->BSIM4cddb
+ here->BSIM4cbdb);
ddxpart_dVd = (Cdd - dxpart * (Cdd + Csd)) / qcheq;
Cdg = here->BSIM4cdgb;
Csg = -(here->BSIM4cggb + here->BSIM4cdgb
+ here->BSIM4cbgb);
ddxpart_dVg = (Cdg - dxpart * (Cdg + Csg)) / qcheq;
Cds = here->BSIM4cdsb;
Css = -(here->BSIM4cgsb + here->BSIM4cdsb
+ here->BSIM4cbsb);
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);
}
}
else
@ -432,47 +425,47 @@ double m;
xcqsb = here->BSIM4cqdb;
xcqbb = here->BSIM4cqbb;
CoxWL = model->BSIM4coxe * here->pParam->BSIM4weffCV
CoxWL = model->BSIM4coxe * here->pParam->BSIM4weffCV
* here->BSIM4nf * here->pParam->BSIM4leffCV;
qcheq = -(here->BSIM4qgate + here->BSIM4qbulk);
if (fabs(qcheq) <= 1.0e-5 * CoxWL)
{ if (model->BSIM4xpart < 0.5)
{ sxpart = 0.4;
}
else if (model->BSIM4xpart > 0.5)
{ sxpart = 0.0;
}
else
{ sxpart = 0.5;
}
dsxpart_dVd = dsxpart_dVg = dsxpart_dVb
= dsxpart_dVs = 0.0;
}
else
{ sxpart = here->BSIM4qdrn / qcheq;
Css = here->BSIM4cddb;
Cds = -(here->BSIM4cgdb + here->BSIM4cddb
+ here->BSIM4cbdb);
dsxpart_dVs = (Css - sxpart * (Css + Cds)) / qcheq;
Csg = here->BSIM4cdgb;
Cdg = -(here->BSIM4cggb + here->BSIM4cdgb
+ here->BSIM4cbgb);
dsxpart_dVg = (Csg - sxpart * (Csg + Cdg)) / qcheq;
Csd = here->BSIM4cdsb;
Cdd = -(here->BSIM4cgsb + here->BSIM4cdsb
+ here->BSIM4cbsb);
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);
qcheq = -(here->BSIM4qgate + here->BSIM4qbulk);
if (fabs(qcheq) <= 1.0e-5 * CoxWL)
{ if (model->BSIM4xpart < 0.5)
{ sxpart = 0.4;
}
else if (model->BSIM4xpart > 0.5)
{ sxpart = 0.0;
}
else
{ sxpart = 0.5;
}
dsxpart_dVd = dsxpart_dVg = dsxpart_dVb
= dsxpart_dVs = 0.0;
}
else
{ sxpart = here->BSIM4qdrn / qcheq;
Css = here->BSIM4cddb;
Cds = -(here->BSIM4cgdb + here->BSIM4cddb
+ here->BSIM4cbdb);
dsxpart_dVs = (Css - sxpart * (Css + Cds)) / qcheq;
Csg = here->BSIM4cdgb;
Cdg = -(here->BSIM4cggb + here->BSIM4cdgb
+ here->BSIM4cbgb);
dsxpart_dVg = (Csg - sxpart * (Csg + Cdg)) / qcheq;
Csd = here->BSIM4cdsb;
Cdd = -(here->BSIM4cgsb + here->BSIM4cdsb
+ here->BSIM4cbsb);
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);
}
}
if (model->BSIM4rdsMod == 1)
@ -501,6 +494,8 @@ double m;
* Loading PZ matrix
*/
m = here->BSIM4m;
mult_i = here->BSIM4mult_i;
mult_q = here->BSIM4mult_q;
if (!model->BSIM4rdsMod)
{ gdpr = here->BSIM4drainConductance;
@ -519,165 +514,165 @@ double m;
geltd = here->BSIM4grgeltd;
if (here->BSIM4rgateMod == 1)
{ *(here->BSIM4GEgePtr) += m * geltd;
*(here->BSIM4GPgePtr) -= m * geltd;
*(here->BSIM4GEgpPtr) -= m * geltd;
*(here->BSIM4GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4GPgpPtr) += m * (geltd - xgtg + gIgtotg);
*(here->BSIM4GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4GPdpPtr) -= m * (xgtd - gIgtotd);
*(here->BSIM4GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4GPspPtr) -= m * (xgts - gIgtots);
*(here->BSIM4GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4GPbpPtr) -= m * (xgtb - gIgtotb);
{ *(here->BSIM4GEgePtr) += mult_i * geltd;
*(here->BSIM4GPgePtr) -= mult_i * geltd;
*(here->BSIM4GEgpPtr) -= mult_i * geltd;
*(here->BSIM4GPgpPtr ) += mult_q * xcggb * s->real;
*(here->BSIM4GPgpPtr +1) += mult_q * xcggb * s->imag;
*(here->BSIM4GPgpPtr) += mult_i * (geltd + gIgtotg) - mult_q * xgtg;
*(here->BSIM4GPdpPtr ) += mult_q * xcgdb * s->real;
*(here->BSIM4GPdpPtr +1) += mult_q * xcgdb * s->imag;
*(here->BSIM4GPdpPtr) -= mult_q * xgtd - mult_i * gIgtotd;
*(here->BSIM4GPspPtr ) += mult_q * xcgsb * s->real;
*(here->BSIM4GPspPtr +1) += mult_q * xcgsb * s->imag;
*(here->BSIM4GPspPtr) -= mult_q * xgts - mult_i * gIgtots;
*(here->BSIM4GPbpPtr ) += mult_q * xcgbb * s->real;
*(here->BSIM4GPbpPtr +1) += mult_q * xcgbb * s->imag;
*(here->BSIM4GPbpPtr) -= mult_q * xgtb - mult_i * gIgtotb;
}
else if (here->BSIM4rgateMod == 2)
{ *(here->BSIM4GEgePtr) += m * gcrg;
*(here->BSIM4GEgpPtr) += m * gcrgg;
*(here->BSIM4GEdpPtr) += m * gcrgd;
*(here->BSIM4GEspPtr) += m * gcrgs;
*(here->BSIM4GEbpPtr) += m * gcrgb;
*(here->BSIM4GPgePtr) -= m * gcrg;
*(here->BSIM4GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg);
*(here->BSIM4GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd);
*(here->BSIM4GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4GPspPtr) -= m * (gcrgs + xgts - gIgtots);
*(here->BSIM4GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb);
{ *(here->BSIM4GEgePtr) += mult_i * gcrg;
*(here->BSIM4GEgpPtr) += mult_i * gcrgg;
*(here->BSIM4GEdpPtr) += mult_i * gcrgd;
*(here->BSIM4GEspPtr) += mult_i * gcrgs;
*(here->BSIM4GEbpPtr) += mult_i * gcrgb;
*(here->BSIM4GPgePtr) -= mult_i * gcrg;
*(here->BSIM4GPgpPtr ) += mult_q * xcggb * s->real;
*(here->BSIM4GPgpPtr +1) += mult_q * xcggb * s->imag;
*(here->BSIM4GPgpPtr) -= mult_i * (gcrgg - gIgtotg) + mult_q * xgtg;
*(here->BSIM4GPdpPtr ) += mult_q * xcgdb * s->real;
*(here->BSIM4GPdpPtr +1) += mult_q * xcgdb * s->imag;
*(here->BSIM4GPdpPtr) -= mult_i * (gcrgd - gIgtotd) + mult_q * xgtd;
*(here->BSIM4GPspPtr ) += mult_q * xcgsb * s->real;
*(here->BSIM4GPspPtr +1) += mult_q * xcgsb * s->imag;
*(here->BSIM4GPspPtr) -= mult_i * (gcrgs - gIgtots) + mult_q * xgts;
*(here->BSIM4GPbpPtr ) += mult_q * xcgbb * s->real;
*(here->BSIM4GPbpPtr +1) += mult_q * xcgbb * s->imag;
*(here->BSIM4GPbpPtr) -= mult_i * (gcrgb - gIgtotb) + mult_q * xgtb;
}
else if (here->BSIM4rgateMod == 3)
{ *(here->BSIM4GEgePtr) += m * geltd;
*(here->BSIM4GEgmPtr) -= m * geltd;
*(here->BSIM4GMgePtr) -= m * geltd;
*(here->BSIM4GMgmPtr) += m * (geltd + gcrg);
*(here->BSIM4GMgmPtr ) += m * xcgmgmb * s->real;
*(here->BSIM4GMgmPtr +1) += m * xcgmgmb * s->imag;
*(here->BSIM4GMdpPtr) += m * gcrgd;
*(here->BSIM4GMdpPtr ) += m * xcgmdb * s->real;
*(here->BSIM4GMdpPtr +1) += m * xcgmdb * s->imag;
*(here->BSIM4GMgpPtr) += m * gcrgg;
*(here->BSIM4GMspPtr) += m * gcrgs;
*(here->BSIM4GMspPtr ) += m * xcgmsb * s->real;
*(here->BSIM4GMspPtr +1) += m * xcgmsb * s->imag;
*(here->BSIM4GMbpPtr) += m * gcrgb;
*(here->BSIM4GMbpPtr ) += m * xcgmbb * s->real;
*(here->BSIM4GMbpPtr +1) += m * xcgmbb * s->imag;
*(here->BSIM4DPgmPtr ) += m * xcdgmb * s->real;
*(here->BSIM4DPgmPtr +1) += m * xcdgmb * s->imag;
*(here->BSIM4GPgmPtr) -= m * gcrg;
*(here->BSIM4SPgmPtr ) += m * xcsgmb * s->real;
*(here->BSIM4SPgmPtr +1) += m * xcsgmb * s->imag;
*(here->BSIM4BPgmPtr ) += m * xcbgmb * s->real;
*(here->BSIM4BPgmPtr +1) += m * xcbgmb * s->imag;
*(here->BSIM4GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg);
*(here->BSIM4GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd);
*(here->BSIM4GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4GPspPtr) -= m * (gcrgs + xgts - gIgtots);
*(here->BSIM4GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb);
*(here->BSIM4GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4GPbpPtr +1) += m * xcgbb * s->imag;
{ *(here->BSIM4GEgePtr) += mult_i * geltd;
*(here->BSIM4GEgmPtr) -= mult_i * geltd;
*(here->BSIM4GMgePtr) -= mult_i * geltd;
*(here->BSIM4GMgmPtr) += mult_i * (geltd + gcrg);
*(here->BSIM4GMgmPtr ) += mult_q * xcgmgmb * s->real;
*(here->BSIM4GMgmPtr +1) += mult_q * xcgmgmb * s->imag;
*(here->BSIM4GMdpPtr) += mult_i * gcrgd;
*(here->BSIM4GMdpPtr ) += mult_q * xcgmdb * s->real;
*(here->BSIM4GMdpPtr +1) += mult_q * xcgmdb * s->imag;
*(here->BSIM4GMgpPtr) += mult_i * gcrgg;
*(here->BSIM4GMspPtr) += mult_i * gcrgs;
*(here->BSIM4GMspPtr ) += mult_q * xcgmsb * s->real;
*(here->BSIM4GMspPtr +1) += mult_q * xcgmsb * s->imag;
*(here->BSIM4GMbpPtr) += mult_i * gcrgb;
*(here->BSIM4GMbpPtr ) += mult_q * xcgmbb * s->real;
*(here->BSIM4GMbpPtr +1) += mult_q * xcgmbb * s->imag;
*(here->BSIM4DPgmPtr ) += mult_q * xcdgmb * s->real;
*(here->BSIM4DPgmPtr +1) += mult_q * xcdgmb * s->imag;
*(here->BSIM4GPgmPtr) -= mult_i * gcrg;
*(here->BSIM4SPgmPtr ) += mult_q * xcsgmb * s->real;
*(here->BSIM4SPgmPtr +1) += mult_q * xcsgmb * s->imag;
*(here->BSIM4BPgmPtr ) += mult_q * xcbgmb * s->real;
*(here->BSIM4BPgmPtr +1) += mult_q * xcbgmb * s->imag;
*(here->BSIM4GPgpPtr) -= mult_i * (gcrgg - gIgtotg) + mult_q * xgtg;
*(here->BSIM4GPgpPtr ) += mult_q * xcggb * s->real;
*(here->BSIM4GPgpPtr +1) += mult_q * xcggb * s->imag;
*(here->BSIM4GPdpPtr) -= mult_i * (gcrgd - gIgtotd) + mult_q * xgtd;
*(here->BSIM4GPdpPtr ) += mult_q * xcgdb * s->real;
*(here->BSIM4GPdpPtr +1) += mult_q * xcgdb * s->imag;
*(here->BSIM4GPspPtr) -= mult_i * (gcrgs - gIgtots) + mult_q * xgts;
*(here->BSIM4GPspPtr ) += mult_q * xcgsb * s->real;
*(here->BSIM4GPspPtr +1) += mult_q * xcgsb * s->imag;
*(here->BSIM4GPbpPtr) -= mult_i * (gcrgb - gIgtotb) + mult_q * xgtb;
*(here->BSIM4GPbpPtr ) += mult_q * xcgbb * s->real;
*(here->BSIM4GPbpPtr +1) += mult_q * xcgbb * s->imag;
}
else
{ *(here->BSIM4GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4GPdpPtr) -= m * (xgtd - gIgtotd);
*(here->BSIM4GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4GPgpPtr) -= m * (xgtg - gIgtotg);
*(here->BSIM4GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4GPspPtr) -= m * (xgts - gIgtots);
*(here->BSIM4GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4GPbpPtr) -= m * (xgtb - gIgtotb);
{ *(here->BSIM4GPdpPtr ) += mult_q * xcgdb * s->real;
*(here->BSIM4GPdpPtr +1) += mult_q * xcgdb * s->imag;
*(here->BSIM4GPdpPtr) -= mult_q * xgtd - mult_i * gIgtotd;
*(here->BSIM4GPgpPtr ) += mult_q * xcggb * s->real;
*(here->BSIM4GPgpPtr +1) += mult_q * xcggb * s->imag;
*(here->BSIM4GPgpPtr) -= mult_q * xgtg - mult_i * gIgtotg;
*(here->BSIM4GPspPtr ) += mult_q * xcgsb * s->real;
*(here->BSIM4GPspPtr +1) += mult_q * xcgsb * s->imag;
*(here->BSIM4GPspPtr) -= mult_q * xgts - mult_i * gIgtots;
*(here->BSIM4GPbpPtr ) += mult_q * xcgbb * s->real;
*(here->BSIM4GPbpPtr +1) += mult_q * xcgbb * s->imag;
*(here->BSIM4GPbpPtr) -= mult_q * xgtb - mult_i * gIgtotb;
}
if (model->BSIM4rdsMod)
{ (*(here->BSIM4DgpPtr) += m * gdtotg);
(*(here->BSIM4DspPtr) += m * gdtots);
(*(here->BSIM4DbpPtr) += m * gdtotb);
(*(here->BSIM4SdpPtr) += m * gstotd);
(*(here->BSIM4SgpPtr) += m * gstotg);
(*(here->BSIM4SbpPtr) += m * gstotb);
{ (*(here->BSIM4DgpPtr) += mult_i * gdtotg);
(*(here->BSIM4DspPtr) += mult_i * gdtots);
(*(here->BSIM4DbpPtr) += mult_i * gdtotb);
(*(here->BSIM4SdpPtr) += mult_i * gstotd);
(*(here->BSIM4SgpPtr) += mult_i * gstotg);
(*(here->BSIM4SbpPtr) += mult_i * gstotb);
}
*(here->BSIM4DPdpPtr ) += m * xcddb * s->real;
*(here->BSIM4DPdpPtr +1) += m * xcddb * s->imag;
*(here->BSIM4DPdpPtr) += m * (gdpr + gds + here->BSIM4gbd
- gdtotd + RevSum + gbdpdp - gIdtotd
+ dxpart * xgtd + T1 * ddxpart_dVd);
*(here->BSIM4DPdPtr) -= m * (gdpr + gdtot);
*(here->BSIM4DPgpPtr ) += m * xcdgb * s->real;
*(here->BSIM4DPgpPtr +1) += m * xcdgb * s->imag;
*(here->BSIM4DPgpPtr) += m * (Gm - gdtotg + gbdpg - gIdtotg
+ T1 * ddxpart_dVg + dxpart * xgtg);
*(here->BSIM4DPspPtr ) += m * xcdsb * s->real;
*(here->BSIM4DPspPtr +1) += m * xcdsb * s->imag;
*(here->BSIM4DPspPtr) -= m * (gds + FwdSum + gdtots - gbdpsp + gIdtots
- T1 * ddxpart_dVs - dxpart * xgts);
*(here->BSIM4DPbpPtr ) += m * xcdbb * s->real;
*(here->BSIM4DPbpPtr +1) += m * xcdbb * s->imag;
*(here->BSIM4DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gbdpb + gIdtotb
- T1 * ddxpart_dVb - dxpart * xgtb);
*(here->BSIM4DdpPtr) -= m * (gdpr - gdtotd);
*(here->BSIM4DdPtr) += m * (gdpr + gdtot);
*(here->BSIM4SPdpPtr ) += m * xcsdb * s->real;
*(here->BSIM4SPdpPtr +1) += m * xcsdb * s->imag;
*(here->BSIM4SPdpPtr) -= m * (gds + gstotd + RevSum - gbspdp + gIstotd
- T1 * dsxpart_dVd - sxpart * xgtd);
*(here->BSIM4SPgpPtr ) += m * xcsgb * s->real;
*(here->BSIM4SPgpPtr +1) += m * xcsgb * s->imag;
*(here->BSIM4SPgpPtr) -= m * (Gm + gstotg - gbspg + gIstotg
- T1 * dsxpart_dVg - sxpart * xgtg);
*(here->BSIM4SPspPtr ) += m * xcssb * s->real;
*(here->BSIM4SPspPtr +1) += m * xcssb * s->imag;
*(here->BSIM4SPspPtr) += m * (gspr + gds + here->BSIM4gbs - gIstots
- gstots + FwdSum + gbspsp
+ sxpart * xgts + T1 * dsxpart_dVs);
*(here->BSIM4SPsPtr) -= m * (gspr + gstot);
*(here->BSIM4SPbpPtr ) += m * xcsbb * s->real;
*(here->BSIM4SPbpPtr +1) += m * xcsbb * s->imag;
*(here->BSIM4SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gbspb + gIstotb
- T1 * dsxpart_dVb - sxpart * xgtb);
*(here->BSIM4SspPtr) -= m * (gspr - gstots);
*(here->BSIM4SsPtr) += m * (gspr + gstot);
*(here->BSIM4BPdpPtr ) += m * xcbdb * s->real;
*(here->BSIM4BPdpPtr +1) += m * xcbdb * s->imag;
*(here->BSIM4BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd);
*(here->BSIM4BPgpPtr ) += m * xcbgb * s->real;
*(here->BSIM4BPgpPtr +1) += m * xcbgb * s->imag;
*(here->BSIM4BPgpPtr) -= m * (here->BSIM4gbgs + gIbtotg);
*(here->BSIM4BPspPtr ) += m * xcbsb * s->real;
*(here->BSIM4BPspPtr +1) += m * xcbsb * s->imag;
*(here->BSIM4BPspPtr) -= m * (gjbs - gbbsp + gIbtots);
*(here->BSIM4BPbpPtr ) += m * xcbbb * s->real;
*(here->BSIM4BPbpPtr +1) += m * xcbbb * s->imag;
*(here->BSIM4BPbpPtr) += m * (gjbd + gjbs - here->BSIM4gbbs
- gIbtotb);
*(here->BSIM4DPdpPtr ) += mult_q * xcddb * s->real;
*(here->BSIM4DPdpPtr +1) += mult_q * xcddb * s->imag;
*(here->BSIM4DPdpPtr) += mult_i * (gdpr + gds + here->BSIM4gbd
- gdtotd + RevSum + gbdpdp - gIdtotd)
+ mult_q * (dxpart * xgtd + T1 * ddxpart_dVd);
*(here->BSIM4DPdPtr) -= mult_i * (gdpr + gdtot);
*(here->BSIM4DPgpPtr ) += mult_q * xcdgb * s->real;
*(here->BSIM4DPgpPtr +1) += mult_q * xcdgb * s->imag;
*(here->BSIM4DPgpPtr) += mult_i * (Gm - gdtotg + gbdpg - gIdtotg)
+ mult_q * (T1 * ddxpart_dVg + dxpart * xgtg);
*(here->BSIM4DPspPtr ) += mult_q * xcdsb * s->real;
*(here->BSIM4DPspPtr +1) += mult_q * xcdsb * s->imag;
*(here->BSIM4DPspPtr) -= mult_i * (gds + FwdSum + gdtots - gbdpsp + gIdtots)
- mult_q * (T1 * ddxpart_dVs + dxpart * xgts);
*(here->BSIM4DPbpPtr ) += mult_q * xcdbb * s->real;
*(here->BSIM4DPbpPtr +1) += mult_q * xcdbb * s->imag;
*(here->BSIM4DPbpPtr) -= mult_i * (gjbd + gdtotb - Gmbs - gbdpb + gIdtotb)
- mult_q * T1 * (ddxpart_dVb + dxpart * xgtb);
*(here->BSIM4DdpPtr) -= mult_i * (gdpr - gdtotd);
*(here->BSIM4DdPtr) += mult_i * (gdpr + gdtot);
*(here->BSIM4SPdpPtr ) += mult_q * xcsdb * s->real;
*(here->BSIM4SPdpPtr +1) += mult_q * xcsdb * s->imag;
*(here->BSIM4SPdpPtr) -= mult_i * (gds + gstotd + RevSum - gbspdp + gIstotd)
- mult_q * (T1 * dsxpart_dVd + sxpart * xgtd);
*(here->BSIM4SPgpPtr ) += mult_q * xcsgb * s->real;
*(here->BSIM4SPgpPtr +1) += mult_q * xcsgb * s->imag;
*(here->BSIM4SPgpPtr) -= mult_i * (Gm + gstotg - gbspg + gIstotg)
- mult_q * (T1 * dsxpart_dVg + sxpart * xgtg);
*(here->BSIM4SPspPtr ) += mult_q * xcssb * s->real;
*(here->BSIM4SPspPtr +1) += mult_q * xcssb * s->imag;
*(here->BSIM4SPspPtr) += mult_i * (gspr + gds + here->BSIM4gbs - gIstots
- gstots + FwdSum + gbspsp)
+ mult_q * (sxpart * xgts + T1 * dsxpart_dVs);
*(here->BSIM4SPsPtr) -= mult_i * (gspr + gstot);
*(here->BSIM4SPbpPtr ) += mult_q * xcsbb * s->real;
*(here->BSIM4SPbpPtr +1) += mult_q * xcsbb * s->imag;
*(here->BSIM4SPbpPtr) -= mult_i * (gjbs + gstotb + Gmbs - gbspb + gIstotb)
- mult_q * (T1 * dsxpart_dVb + sxpart * xgtb);
*(here->BSIM4SspPtr) -= mult_i * (gspr - gstots);
*(here->BSIM4SsPtr) += mult_i * (gspr + gstot);
*(here->BSIM4BPdpPtr ) += mult_q * xcbdb * s->real;
*(here->BSIM4BPdpPtr +1) += mult_q * xcbdb * s->imag;
*(here->BSIM4BPdpPtr) -= mult_i * (gjbd - gbbdp + gIbtotd);
*(here->BSIM4BPgpPtr ) += mult_q * xcbgb * s->real;
*(here->BSIM4BPgpPtr +1) += mult_q * xcbgb * s->imag;
*(here->BSIM4BPgpPtr) -= mult_i * (here->BSIM4gbgs + gIbtotg);
*(here->BSIM4BPspPtr ) += mult_q * xcbsb * s->real;
*(here->BSIM4BPspPtr +1) += mult_q * xcbsb * s->imag;
*(here->BSIM4BPspPtr) -= mult_i * (gjbs - gbbsp + gIbtots);
*(here->BSIM4BPbpPtr ) += mult_q * xcbbb * s->real;
*(here->BSIM4BPbpPtr +1) += mult_q * xcbbb * s->imag;
*(here->BSIM4BPbpPtr) += mult_i * (gjbd + gjbs - here->BSIM4gbbs
- gIbtotb);
ggidld = here->BSIM4ggidld;
ggidlg = here->BSIM4ggidlg;
ggidlb = here->BSIM4ggidlb;
@ -686,63 +681,63 @@ double m;
ggislb = here->BSIM4ggislb;
/* stamp gidl */
(*(here->BSIM4DPdpPtr) += m * ggidld);
(*(here->BSIM4DPgpPtr) += m * ggidlg);
(*(here->BSIM4DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4DPbpPtr) += m * ggidlb);
(*(here->BSIM4BPdpPtr) -= m * ggidld);
(*(here->BSIM4BPgpPtr) -= m * ggidlg);
(*(here->BSIM4BPspPtr) += m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4BPbpPtr) -= m * ggidlb);
(*(here->BSIM4DPdpPtr) += mult_i * ggidld);
(*(here->BSIM4DPgpPtr) += mult_i * ggidlg);
(*(here->BSIM4DPspPtr) -= mult_i * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4DPbpPtr) += mult_i * ggidlb);
(*(here->BSIM4BPdpPtr) -= mult_i * ggidld);
(*(here->BSIM4BPgpPtr) -= mult_i * ggidlg);
(*(here->BSIM4BPspPtr) += mult_i * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4BPbpPtr) -= mult_i * ggidlb);
/* stamp gisl */
(*(here->BSIM4SPdpPtr) -= m * ((ggisls + ggislg) + ggislb));
(*(here->BSIM4SPgpPtr) += m * ggislg);
(*(here->BSIM4SPspPtr) += m * ggisls);
(*(here->BSIM4SPbpPtr) += m * ggislb);
(*(here->BSIM4BPdpPtr) += m * ((ggislg + ggisls) + ggislb));
(*(here->BSIM4BPgpPtr) -= m * ggislg);
(*(here->BSIM4BPspPtr) -= m * ggisls);
(*(here->BSIM4BPbpPtr) -= m * ggislb);
(*(here->BSIM4SPdpPtr) -= mult_i * ((ggisls + ggislg) + ggislb));
(*(here->BSIM4SPgpPtr) += mult_i * ggislg);
(*(here->BSIM4SPspPtr) += mult_i * ggisls);
(*(here->BSIM4SPbpPtr) += mult_i * ggislb);
(*(here->BSIM4BPdpPtr) += mult_i * ((ggislg + ggisls) + ggislb));
(*(here->BSIM4BPgpPtr) -= mult_i * ggislg);
(*(here->BSIM4BPspPtr) -= mult_i * ggisls);
(*(here->BSIM4BPbpPtr) -= mult_i * ggislb);
if (here->BSIM4rbodyMod)
{ (*(here->BSIM4DPdbPtr ) += m * xcdbdb * s->real);
(*(here->BSIM4DPdbPtr +1) += m * xcdbdb * s->imag);
(*(here->BSIM4DPdbPtr) -= m * here->BSIM4gbd);
(*(here->BSIM4SPsbPtr ) += m * xcsbsb * s->real);
(*(here->BSIM4SPsbPtr +1) += m * xcsbsb * s->imag);
(*(here->BSIM4SPsbPtr) -= m * here->BSIM4gbs);
(*(here->BSIM4DBdpPtr ) += m * xcdbdb * s->real);
(*(here->BSIM4DBdpPtr +1) += m * xcdbdb * s->imag);
(*(here->BSIM4DBdpPtr) -= m * here->BSIM4gbd);
(*(here->BSIM4DBdbPtr ) -= m * xcdbdb * s->real);
(*(here->BSIM4DBdbPtr +1) -= m * xcdbdb * s->imag);
(*(here->BSIM4DBdbPtr) += m * (here->BSIM4gbd + here->BSIM4grbpd
{ (*(here->BSIM4DPdbPtr ) += mult_q * xcdbdb * s->real);
(*(here->BSIM4DPdbPtr +1) += mult_q * xcdbdb * s->imag);
(*(here->BSIM4DPdbPtr) -= mult_i * here->BSIM4gbd);
(*(here->BSIM4SPsbPtr ) += mult_q * xcsbsb * s->real);
(*(here->BSIM4SPsbPtr +1) += mult_q * xcsbsb * s->imag);
(*(here->BSIM4SPsbPtr) -= mult_i * here->BSIM4gbs);
(*(here->BSIM4DBdpPtr ) += mult_q * xcdbdb * s->real);
(*(here->BSIM4DBdpPtr +1) += mult_q * xcdbdb * s->imag);
(*(here->BSIM4DBdpPtr) -= mult_i * here->BSIM4gbd);
(*(here->BSIM4DBdbPtr ) -= mult_q * xcdbdb * s->real);
(*(here->BSIM4DBdbPtr +1) -= mult_q * xcdbdb * s->imag);
(*(here->BSIM4DBdbPtr) += mult_i * (here->BSIM4gbd + here->BSIM4grbpd
+ here->BSIM4grbdb));
(*(here->BSIM4DBbpPtr) -= m * here->BSIM4grbpd);
(*(here->BSIM4DBbPtr) -= m * here->BSIM4grbdb);
(*(here->BSIM4BPdbPtr) -= m * here->BSIM4grbpd);
(*(here->BSIM4BPbPtr) -= m * here->BSIM4grbpb);
(*(here->BSIM4BPsbPtr) -= m * here->BSIM4grbps);
(*(here->BSIM4BPbpPtr) += m * (here->BSIM4grbpd + here->BSIM4grbps
+ here->BSIM4grbpb));
(*(here->BSIM4DBbpPtr) -= mult_i * here->BSIM4grbpd);
(*(here->BSIM4DBbPtr) -= mult_i * here->BSIM4grbdb);
(*(here->BSIM4BPdbPtr) -= mult_i * here->BSIM4grbpd);
(*(here->BSIM4BPbPtr) -= mult_i * here->BSIM4grbpb);
(*(here->BSIM4BPsbPtr) -= mult_i * here->BSIM4grbps);
(*(here->BSIM4BPbpPtr) += mult_i * (here->BSIM4grbpd + here->BSIM4grbps
+ here->BSIM4grbpb));
/* WDL: (-here->BSIM4gbbs) already added to BPbpPtr */
(*(here->BSIM4SBspPtr ) += m * xcsbsb * s->real);
(*(here->BSIM4SBspPtr +1) += m * xcsbsb * s->imag);
(*(here->BSIM4SBspPtr) -= m * here->BSIM4gbs);
(*(here->BSIM4SBbpPtr) -= m * here->BSIM4grbps);
(*(here->BSIM4SBbPtr) -= m * here->BSIM4grbsb);
(*(here->BSIM4SBsbPtr ) -= m * xcsbsb * s->real);
(*(here->BSIM4SBsbPtr +1) -= m * xcsbsb * s->imag);
(*(here->BSIM4SBsbPtr) += m * (here->BSIM4gbs
+ here->BSIM4grbps + here->BSIM4grbsb));
(*(here->BSIM4BdbPtr) -= m * here->BSIM4grbdb);
(*(here->BSIM4BbpPtr) -= m * here->BSIM4grbpb);
(*(here->BSIM4BsbPtr) -= m * here->BSIM4grbsb);
(*(here->BSIM4BbPtr) += m * (here->BSIM4grbsb + here->BSIM4grbdb
(*(here->BSIM4SBspPtr ) += mult_q * xcsbsb * s->real);
(*(here->BSIM4SBspPtr +1) += mult_q * xcsbsb * s->imag);
(*(here->BSIM4SBspPtr) -= mult_i * here->BSIM4gbs);
(*(here->BSIM4SBbpPtr) -= mult_i * here->BSIM4grbps);
(*(here->BSIM4SBbPtr) -= mult_i * here->BSIM4grbsb);
(*(here->BSIM4SBsbPtr ) -= mult_q * xcsbsb * s->real);
(*(here->BSIM4SBsbPtr +1) -= mult_q * xcsbsb * s->imag);
(*(here->BSIM4SBsbPtr) += mult_i * (here->BSIM4gbs
+ here->BSIM4grbps + here->BSIM4grbsb));
(*(here->BSIM4BdbPtr) -= mult_i * here->BSIM4grbdb);
(*(here->BSIM4BbpPtr) -= mult_i * here->BSIM4grbpb);
(*(here->BSIM4BsbPtr) -= mult_i * here->BSIM4grbsb);
(*(here->BSIM4BbPtr) += mult_i * (here->BSIM4grbsb + here->BSIM4grbdb
+ here->BSIM4grbpb));
}

789
src/spicelib/devices/bsim4/b4set.c
File diff suppressed because it is too large
View File

2310
src/spicelib/devices/bsim4/b4temp.c
File diff suppressed because it is too large
View File

33
src/spicelib/devices/bsim4/b4trunc.c
View File

@ -1,29 +1,25 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#include "ngspice/ngspice.h"
@ -32,7 +28,6 @@ under the License.
#include "ngspice/sperror.h"
#include "ngspice/suffix.h"
int
BSIM4trunc(
GENmodel *inModel,
@ -48,8 +43,8 @@ BSIM4instance *here;
for (; model != NULL; model = BSIM4nextModel(model))
{ for (here = BSIM4instances(model); here != NULL;
here = BSIM4nextInstance(here))
{
here = BSIM4nextInstance(here))
{
#ifdef STEPDEBUG
debugtemp = *timeStep;
#endif /* STEPDEBUG */
@ -61,12 +56,12 @@ BSIM4instance *here;
if (here->BSIM4rbodyMod)
{ CKTterr(here->BSIM4qbs,ckt,timeStep);
CKTterr(here->BSIM4qbd,ckt,timeStep);
}
if (here->BSIM4rgateMod == 3)
CKTterr(here->BSIM4qgmid,ckt,timeStep);
}
if (here->BSIM4rgateMod == 3)
CKTterr(here->BSIM4qgmid,ckt,timeStep);
#ifdef STEPDEBUG
if(debugtemp != *timeStep)
{ printf("device %s reduces step from %g to %g\n",
{ printf("device %s reduces step from %g to %g\n",
here->BSIM4name,debugtemp,*timeStep);
}
#endif /* STEPDEBUG */

432
src/spicelib/devices/bsim4/bsim4def.h
View File

@ -1,29 +1,25 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#ifndef BSIM4
@ -95,6 +91,7 @@ typedef struct sBSIM4instance
double BSIM4l;
double BSIM4w;
double BSIM4m;
double BSIM4drainArea;
double BSIM4sourceArea;
double BSIM4drainSquares;
@ -103,7 +100,8 @@ typedef struct sBSIM4instance
double BSIM4sourcePerimeter;
double BSIM4sourceConductance;
double BSIM4drainConductance;
/* stress effect instance param */
/* stress effect instance param */
double BSIM4sa;
double BSIM4sb;
double BSIM4sd;
@ -119,12 +117,11 @@ typedef struct sBSIM4instance
double BSIM4rbpd;
double BSIM4delvto;
double BSIM4mulu0;
int BSIM4wnflag;
double BSIM4xgw;
double BSIM4ngcon;
/* added here to account stress effect instance dependence */
/* added here to account stress effect instance dependence */
double BSIM4u0temp;
double BSIM4vsattemp;
double BSIM4vth0;
@ -142,9 +139,12 @@ typedef struct sBSIM4instance
double BSIM4icVDS;
double BSIM4icVGS;
double BSIM4icVBS;
double BSIM4m;
double BSIM4mult_i;
double BSIM4mult_q;
double BSIM4mult_fn;
double BSIM4nf;
int BSIM4off;
int BSIM4mode;
int BSIM4trnqsMod;
int BSIM4acnqsMod;
@ -286,6 +286,9 @@ typedef struct sBSIM4instance
unsigned BSIM4lGiven :1;
unsigned BSIM4wGiven :1;
unsigned BSIM4mGiven :1;
unsigned BSIM4mult_iGiven :1;
unsigned BSIM4mult_qGiven :1;
unsigned BSIM4mult_fnGiven :1;
unsigned BSIM4nfGiven :1;
unsigned BSIM4minGiven :1;
unsigned BSIM4drainAreaGiven :1;
@ -307,8 +310,6 @@ typedef struct sBSIM4instance
unsigned BSIM4rbpdGiven :1;
unsigned BSIM4rbpsGiven :1;
unsigned BSIM4delvtoGiven :1;
unsigned BSIM4mulu0Given :1;
unsigned BSIM4wnflagGiven :1;
unsigned BSIM4xgwGiven :1;
unsigned BSIM4ngconGiven :1;
unsigned BSIM4icVDSGiven :1;
@ -680,6 +681,7 @@ struct bsim4SizeDependParam
double BSIM4a1;
double BSIM4a2;
double BSIM4keta;
double BSIM4ketac;
double BSIM4nsub;
double BSIM4ndep;
double BSIM4nsd;
@ -703,7 +705,7 @@ struct bsim4SizeDependParam
double BSIM4w0;
double BSIM4dvtp0;
double BSIM4dvtp1;
double BSIM4dvtp2; /* New DIBL/Rout */
double BSIM4dvtp2; /* New DIBL/Rout */
double BSIM4dvtp3;
double BSIM4dvtp4;
double BSIM4dvtp5;
@ -730,14 +732,14 @@ struct bsim4SizeDependParam
double BSIM4lp;
double BSIM4u0;
double BSIM4eu;
double BSIM4ucs;
double BSIM4ucs;
double BSIM4ute;
double BSIM4ucste;
double BSIM4ucste;
double BSIM4voff;
double BSIM4tvoff;
double BSIM4tnfactor; /* v4.7 Temp dep of leakage current */
double BSIM4teta0; /* v4.7 temp dep of leakage current */
double BSIM4tvoffcv; /* v4.7 temp dep of leakage current */
double BSIM4tnfactor; /* v4.7 Temp dep of leakage current */
double BSIM4teta0; /* v4.7 temp dep of leakage current */
double BSIM4tvoffcv; /* v4.7 temp dep of leakage current */
double BSIM4minv;
double BSIM4minvcv;
double BSIM4vfb;
@ -872,7 +874,7 @@ struct bsim4SizeDependParam
double BSIM4theta0vb0;
double BSIM4thetaRout;
double BSIM4mstar;
double BSIM4VgsteffVth;
double BSIM4VgsteffVth;
double BSIM4mstarcv;
double BSIM4voffcbn;
double BSIM4voffcbncv;
@ -927,7 +929,6 @@ typedef struct sBSIM4model
int BSIM4rgateMod;
int BSIM4perMod;
int BSIM4geoMod;
int BSIM4rgeoMod;
int BSIM4mtrlMod;
int BSIM4mtrlCompatMod; /* v4.7 */
int BSIM4gidlMod; /* v4.7 New GIDL/GISL */
@ -936,12 +937,12 @@ typedef struct sBSIM4model
int BSIM4tempMod;
int BSIM4binUnit;
int BSIM4paramChk;
char *BSIM4version;
char *BSIM4version;
double BSIM4eot;
double BSIM4vddeot;
double BSIM4tempeot;
double BSIM4leffeot;
double BSIM4weffeot;
double BSIM4tempeot;
double BSIM4leffeot;
double BSIM4weffeot;
double BSIM4ados;
double BSIM4bdos;
double BSIM4toxe;
@ -962,6 +963,7 @@ typedef struct sBSIM4model
double BSIM4a1;
double BSIM4a2;
double BSIM4keta;
double BSIM4ketac;
double BSIM4nsub;
double BSIM4phig;
double BSIM4epsrgate;
@ -990,7 +992,7 @@ typedef struct sBSIM4model
double BSIM4w0;
double BSIM4dvtp0;
double BSIM4dvtp1;
double BSIM4dvtp2; /* New DIBL/Rout */
double BSIM4dvtp2; /* New DIBL/Rout */
double BSIM4dvtp3;
double BSIM4dvtp4;
double BSIM4dvtp5;
@ -1006,7 +1008,7 @@ typedef struct sBSIM4model
double BSIM4dsub;
double BSIM4vth0;
double BSIM4eu;
double BSIM4ucs;
double BSIM4ucs;
double BSIM4ua;
double BSIM4ua1;
double BSIM4ub;
@ -1019,12 +1021,12 @@ typedef struct sBSIM4model
double BSIM4lp;
double BSIM4u0;
double BSIM4ute;
double BSIM4ucste;
double BSIM4ucste;
double BSIM4voff;
double BSIM4tvoff;
double BSIM4tnfactor; /* v4.7 Temp dep of leakage current */
double BSIM4teta0; /* v4.7 temp dep of leakage current */
double BSIM4tvoffcv; /* v4.7 temp dep of leakage current */
double BSIM4tnfactor; /* v4.7 Temp dep of leakage current */
double BSIM4teta0; /* v4.7 temp dep of leakage current */
double BSIM4tvoffcv; /* v4.7 temp dep of leakage current */
double BSIM4minv;
double BSIM4minvcv;
double BSIM4voffl;
@ -1247,6 +1249,7 @@ typedef struct sBSIM4model
double BSIM4la1;
double BSIM4la2;
double BSIM4lketa;
double BSIM4lketac;
double BSIM4lnsub;
double BSIM4lndep;
double BSIM4lnsd;
@ -1267,7 +1270,7 @@ typedef struct sBSIM4model
double BSIM4lw0;
double BSIM4ldvtp0;
double BSIM4ldvtp1;
double BSIM4ldvtp2; /* New DIBL/Rout */
double BSIM4ldvtp2; /* New DIBL/Rout */
double BSIM4ldvtp3;
double BSIM4ldvtp4;
double BSIM4ldvtp5;
@ -1299,9 +1302,9 @@ typedef struct sBSIM4model
double BSIM4lucste;
double BSIM4lvoff;
double BSIM4ltvoff;
double BSIM4ltnfactor; /* v4.7 Temp dep of leakage current */
double BSIM4lteta0; /* v4.7 temp dep of leakage current */
double BSIM4ltvoffcv; /* v4.7 temp dep of leakage current */
double BSIM4ltnfactor; /* v4.7 Temp dep of leakage current */
double BSIM4lteta0; /* v4.7 temp dep of leakage current */
double BSIM4ltvoffcv; /* v4.7 temp dep of leakage current */
double BSIM4lminv;
double BSIM4lminvcv;
double BSIM4ldelta;
@ -1407,6 +1410,7 @@ typedef struct sBSIM4model
double BSIM4wa1;
double BSIM4wa2;
double BSIM4wketa;
double BSIM4wketac;
double BSIM4wnsub;
double BSIM4wndep;
double BSIM4wnsd;
@ -1427,7 +1431,7 @@ typedef struct sBSIM4model
double BSIM4ww0;
double BSIM4wdvtp0;
double BSIM4wdvtp1;
double BSIM4wdvtp2; /* New DIBL/Rout */
double BSIM4wdvtp2; /* New DIBL/Rout */
double BSIM4wdvtp3;
double BSIM4wdvtp4;
double BSIM4wdvtp5;
@ -1459,9 +1463,9 @@ typedef struct sBSIM4model
double BSIM4wucste;
double BSIM4wvoff;
double BSIM4wtvoff;
double BSIM4wtnfactor; /* v4.7 Temp dep of leakage current */
double BSIM4wteta0; /* v4.7 temp dep of leakage current */
double BSIM4wtvoffcv; /* v4.7 temp dep of leakage current */
double BSIM4wtnfactor; /* v4.7 Temp dep of leakage current */
double BSIM4wteta0; /* v4.7 temp dep of leakage current */
double BSIM4wtvoffcv; /* v4.7 temp dep of leakage current */
double BSIM4wminv;
double BSIM4wminvcv;
double BSIM4wdelta;
@ -1567,6 +1571,7 @@ typedef struct sBSIM4model
double BSIM4pa1;
double BSIM4pa2;
double BSIM4pketa;
double BSIM4pketac;
double BSIM4pnsub;
double BSIM4pndep;
double BSIM4pnsd;
@ -1587,7 +1592,7 @@ typedef struct sBSIM4model
double BSIM4pw0;
double BSIM4pdvtp0;
double BSIM4pdvtp1;
double BSIM4pdvtp2; /* New DIBL/Rout */
double BSIM4pdvtp2; /* New DIBL/Rout */
double BSIM4pdvtp3;
double BSIM4pdvtp4;
double BSIM4pdvtp5;
@ -1619,9 +1624,9 @@ typedef struct sBSIM4model
double BSIM4pucste;
double BSIM4pvoff;
double BSIM4ptvoff;
double BSIM4ptnfactor; /* v4.7 Temp dep of leakage current */
double BSIM4pteta0; /* v4.7 temp dep of leakage current */
double BSIM4ptvoffcv; /* v4.7 temp dep of leakage current */
double BSIM4ptnfactor; /* v4.7 Temp dep of leakage current */
double BSIM4pteta0; /* v4.7 temp dep of leakage current */
double BSIM4ptvoffcv; /* v4.7 temp dep of leakage current */
double BSIM4pminv;
double BSIM4pminvcv;
double BSIM4pdelta;
@ -1823,6 +1828,7 @@ typedef struct sBSIM4model
/* Pre-calculated constants
* move to size-dependent param */
double BSIM4Eg0;
double BSIM4vtm;
double BSIM4vtm0;
@ -1872,6 +1878,7 @@ typedef struct sBSIM4model
double BSIM4vgbrMax;
double BSIM4vbsrMax;
double BSIM4vbdrMax;
double BSIM4gidlclamp;
double BSIM4idovvdsc;
struct bsim4SizeDependParam *pSizeDependParamKnot;
@ -1892,7 +1899,6 @@ typedef struct sBSIM4model
unsigned BSIM4rgateModGiven :1;
unsigned BSIM4perModGiven :1;
unsigned BSIM4geoModGiven :1;
unsigned BSIM4rgeoModGiven :1;
unsigned BSIM4paramChkGiven :1;
unsigned BSIM4trnqsModGiven :1;
unsigned BSIM4acnqsModGiven :1;
@ -1932,6 +1938,7 @@ typedef struct sBSIM4model
unsigned BSIM4a1Given :1;
unsigned BSIM4a2Given :1;
unsigned BSIM4ketaGiven :1;
unsigned BSIM4ketacGiven :1;
unsigned BSIM4nsubGiven :1;
unsigned BSIM4phigGiven :1;
unsigned BSIM4epsrgateGiven :1;
@ -1960,7 +1967,7 @@ typedef struct sBSIM4model
unsigned BSIM4w0Given :1;
unsigned BSIM4dvtp0Given :1;
unsigned BSIM4dvtp1Given :1;
unsigned BSIM4dvtp2Given :1; /* New DIBL/Rout */
unsigned BSIM4dvtp2Given :1; /* New DIBL/Rout */
unsigned BSIM4dvtp3Given :1;
unsigned BSIM4dvtp4Given :1;
unsigned BSIM4dvtp5Given :1;
@ -1992,9 +1999,9 @@ typedef struct sBSIM4model
unsigned BSIM4ucsteGiven :1;
unsigned BSIM4voffGiven :1;
unsigned BSIM4tvoffGiven :1;
unsigned BSIM4tnfactorGiven :1; /* v4.7 Temp dep of leakage current */
unsigned BSIM4teta0Given :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4tvoffcvGiven :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4tnfactorGiven :1; /* v4.7 Temp dep of leakage current */
unsigned BSIM4teta0Given :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4tvoffcvGiven :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4vofflGiven :1;
unsigned BSIM4voffcvlGiven :1;
unsigned BSIM4minvGiven :1;
@ -2084,7 +2091,7 @@ typedef struct sBSIM4model
unsigned BSIM4jtsswdGiven :1;
unsigned BSIM4jtsswgsGiven :1;
unsigned BSIM4jtsswgdGiven :1;
unsigned BSIM4jtweffGiven :1;
unsigned BSIM4jtweffGiven :1;
unsigned BSIM4njtsGiven :1;
unsigned BSIM4njtsswGiven :1;
unsigned BSIM4njtsswgGiven :1;
@ -2217,6 +2224,7 @@ typedef struct sBSIM4model
unsigned BSIM4la1Given :1;
unsigned BSIM4la2Given :1;
unsigned BSIM4lketaGiven :1;
unsigned BSIM4lketacGiven :1;
unsigned BSIM4lnsubGiven :1;
unsigned BSIM4lndepGiven :1;
unsigned BSIM4lnsdGiven :1;
@ -2237,7 +2245,7 @@ typedef struct sBSIM4model
unsigned BSIM4lw0Given :1;
unsigned BSIM4ldvtp0Given :1;
unsigned BSIM4ldvtp1Given :1;
unsigned BSIM4ldvtp2Given :1; /* New DIBL/Rout */
unsigned BSIM4ldvtp2Given :1; /* New DIBL/Rout */
unsigned BSIM4ldvtp3Given :1;
unsigned BSIM4ldvtp4Given :1;
unsigned BSIM4ldvtp5Given :1;
@ -2264,14 +2272,14 @@ typedef struct sBSIM4model
unsigned BSIM4llpGiven :1;
unsigned BSIM4lu0Given :1;
unsigned BSIM4leuGiven :1;
unsigned BSIM4lucsGiven :1;
unsigned BSIM4lucsGiven :1;
unsigned BSIM4luteGiven :1;
unsigned BSIM4lucsteGiven :1;
unsigned BSIM4lucsteGiven :1;
unsigned BSIM4lvoffGiven :1;
unsigned BSIM4ltvoffGiven :1;
unsigned BSIM4ltnfactorGiven :1; /* v4.7 Temp dep of leakage current */
unsigned BSIM4lteta0Given :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4ltvoffcvGiven :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4ltnfactorGiven :1; /* v4.7 Temp dep of leakage current */
unsigned BSIM4lteta0Given :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4ltvoffcvGiven :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4lminvGiven :1;
unsigned BSIM4lminvcvGiven :1;
unsigned BSIM4lrdswGiven :1;
@ -2377,6 +2385,7 @@ typedef struct sBSIM4model
unsigned BSIM4wa1Given :1;
unsigned BSIM4wa2Given :1;
unsigned BSIM4wketaGiven :1;
unsigned BSIM4wketacGiven :1;
unsigned BSIM4wnsubGiven :1;
unsigned BSIM4wndepGiven :1;
unsigned BSIM4wnsdGiven :1;
@ -2397,7 +2406,7 @@ typedef struct sBSIM4model
unsigned BSIM4ww0Given :1;
unsigned BSIM4wdvtp0Given :1;
unsigned BSIM4wdvtp1Given :1;
unsigned BSIM4wdvtp2Given :1; /* New DIBL/Rout */
unsigned BSIM4wdvtp2Given :1; /* New DIBL/Rout */
unsigned BSIM4wdvtp3Given :1;
unsigned BSIM4wdvtp4Given :1;
unsigned BSIM4wdvtp5Given :1;
@ -2424,14 +2433,14 @@ typedef struct sBSIM4model
unsigned BSIM4wlpGiven :1;
unsigned BSIM4wu0Given :1;
unsigned BSIM4weuGiven :1;
unsigned BSIM4wucsGiven :1;
unsigned BSIM4wucsGiven :1;
unsigned BSIM4wuteGiven :1;
unsigned BSIM4wucsteGiven :1;
unsigned BSIM4wucsteGiven :1;
unsigned BSIM4wvoffGiven :1;
unsigned BSIM4wtvoffGiven :1;
unsigned BSIM4wtnfactorGiven :1; /* v4.7 Temp dep of leakage current */
unsigned BSIM4wteta0Given :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4wtvoffcvGiven :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4wtnfactorGiven :1; /* v4.7 Temp dep of leakage current */
unsigned BSIM4wteta0Given :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4wtvoffcvGiven :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4wminvGiven :1;
unsigned BSIM4wminvcvGiven :1;
unsigned BSIM4wrdswGiven :1;
@ -2537,6 +2546,7 @@ typedef struct sBSIM4model
unsigned BSIM4pa1Given :1;
unsigned BSIM4pa2Given :1;
unsigned BSIM4pketaGiven :1;
unsigned BSIM4pketacGiven :1;
unsigned BSIM4pnsubGiven :1;
unsigned BSIM4pndepGiven :1;
unsigned BSIM4pnsdGiven :1;
@ -2557,7 +2567,7 @@ typedef struct sBSIM4model
unsigned BSIM4pw0Given :1;
unsigned BSIM4pdvtp0Given :1;
unsigned BSIM4pdvtp1Given :1;
unsigned BSIM4pdvtp2Given :1; /* New DIBL/Rout */
unsigned BSIM4pdvtp2Given :1; /* New DIBL/Rout */
unsigned BSIM4pdvtp3Given :1;
unsigned BSIM4pdvtp4Given :1;
unsigned BSIM4pdvtp5Given :1;
@ -2584,14 +2594,14 @@ typedef struct sBSIM4model
unsigned BSIM4plpGiven :1;
unsigned BSIM4pu0Given :1;
unsigned BSIM4peuGiven :1;
unsigned BSIM4pucsGiven :1;
unsigned BSIM4pucsGiven :1;
unsigned BSIM4puteGiven :1;
unsigned BSIM4pucsteGiven :1;
unsigned BSIM4pucsteGiven :1;
unsigned BSIM4pvoffGiven :1;
unsigned BSIM4ptvoffGiven :1;
unsigned BSIM4ptnfactorGiven :1; /* v4.7 Temp dep of leakage current */
unsigned BSIM4pteta0Given :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4ptvoffcvGiven :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4ptnfactorGiven :1; /* v4.7 Temp dep of leakage current */
unsigned BSIM4pteta0Given :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4ptvoffcvGiven :1; /* v4.7 temp dep of leakage current */
unsigned BSIM4pminvGiven :1;
unsigned BSIM4pminvcvGiven :1;
unsigned BSIM4prdswGiven :1;
@ -2705,7 +2715,7 @@ typedef struct sBSIM4model
unsigned BSIM4SbulkJctGateSideGradingCoeffGiven :1;
unsigned BSIM4SunitLengthGateSidewallJctCapGiven :1;
unsigned BSIM4SjctEmissionCoeffGiven :1;
unsigned BSIM4SjctTempExponentGiven :1;
unsigned BSIM4SjctTempExponentGiven :1;
unsigned BSIM4DjctSatCurDensityGiven :1;
unsigned BSIM4DjctSidewallSatCurDensityGiven :1;
@ -2807,7 +2817,6 @@ typedef struct sBSIM4model
unsigned BSIM4pku0weGiven :1;
unsigned BSIM4gidlclampGiven :1;
unsigned BSIM4idovvdscGiven :1;
} BSIM4model;
@ -2855,35 +2864,40 @@ typedef struct sBSIM4model
#define BSIM4_SCC 36
#define BSIM4_SC 37
#define BSIM4_M 38
#define BSIM4_MULU0 39
#define BSIM4_WNFLAG 40
#define BSIM4_VGSTEFF 40
#define BSIM4_VDSEFF 41
#define BSIM4_CGSO 42
#define BSIM4_CGDO 43
#define BSIM4_CGBO 44
#define BSIM4_WEFF 45
#define BSIM4_LEFF 46
/* Global parameters */
#define BSIM4_MOD_TEMPEOT 65
#define BSIM4_MOD_LEFFEOT 66
#define BSIM4_MOD_WEFFEOT 67
#define BSIM4_MOD_UCSTE 68
#define BSIM4_MOD_LUCSTE 69
#define BSIM4_MOD_WUCSTE 70
#define BSIM4_MOD_PUCSTE 71
#define BSIM4_MOD_UCS 72
#define BSIM4_MOD_LUCS 73
#define BSIM4_MOD_WUCS 74
#define BSIM4_MOD_PUCS 75
#define BSIM4_MOD_CVCHARGEMOD 76
#define BSIM4_MOD_ADOS 77
#define BSIM4_MOD_BDOS 78
#define BSIM4_MOD_TEMPMOD 79
#define BSIM4_MOD_MTRLMOD 80
#define BSIM4_MOD_IGCMOD 81
#define BSIM4_MOD_IGBMOD 82
#define BSIM4_MOD_ACNQSMOD 83
#define BSIM4_MOD_FNOIMOD 84
#define BSIM4_MOD_RDSMOD 85
#define BSIM4_MOD_DIOMOD 86
#define BSIM4_MOD_PERMOD 87
#define BSIM4_MOD_GEOMOD 88
#define BSIM4_MOD_RGEOMOD 89
#define BSIM4_MOD_TEMPEOT 66
#define BSIM4_MOD_LEFFEOT 67
#define BSIM4_MOD_WEFFEOT 68
#define BSIM4_MOD_UCSTE 69
#define BSIM4_MOD_LUCSTE 70
#define BSIM4_MOD_WUCSTE 71
#define BSIM4_MOD_PUCSTE 72
#define BSIM4_MOD_UCS 73
#define BSIM4_MOD_LUCS 74
#define BSIM4_MOD_WUCS 75
#define BSIM4_MOD_PUCS 76
#define BSIM4_MOD_CVCHARGEMOD 77
#define BSIM4_MOD_ADOS 78
#define BSIM4_MOD_BDOS 79
#define BSIM4_MOD_TEMPMOD 80
#define BSIM4_MOD_MTRLMOD 81
#define BSIM4_MOD_IGCMOD 82
#define BSIM4_MOD_IGBMOD 83
#define BSIM4_MOD_ACNQSMOD 84
#define BSIM4_MOD_FNOIMOD 85
#define BSIM4_MOD_RDSMOD 86
#define BSIM4_MOD_DIOMOD 87
#define BSIM4_MOD_PERMOD 88
#define BSIM4_MOD_GEOMOD 89
#define BSIM4_MOD_RGATEMOD 90
#define BSIM4_MOD_RBODYMOD 91
#define BSIM4_MOD_CAPMOD 92
@ -3224,47 +3238,47 @@ typedef struct sBSIM4model
#define BSIM4_MOD_LLP 442
#define BSIM4_MOD_LMINVCV 443
#define BSIM4_MOD_FGIDL 444 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_KGIDL 445 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_RGIDL 446 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_FGISL 447 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_KGISL 448 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_RGISL 449 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LFGIDL 450 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LKGIDL 451 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LRGIDL 452 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LFGISL 453 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LKGISL 454 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LRGISL 455 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WFGIDL 456 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WKGIDL 457 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WRGIDL 458 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WFGISL 459 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WKGISL 460 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WRGISL 461 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PFGIDL 462 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PKGIDL 463 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PRGIDL 464 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PFGISL 465 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PKGISL 466 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PRGISL 467 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_GIDLMOD 379 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_DVTP2 468 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_DVTP3 469 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_DVTP4 470 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_DVTP5 471 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_LDVTP2 472 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_LDVTP3 473 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_LDVTP4 474 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_LDVTP5 475 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_WDVTP2 476 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_WDVTP3 477 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_WDVTP4 478 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_WDVTP5 479 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_PDVTP2 480 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_PDVTP3 298 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_PDVTP4 299 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_PDVTP5 300 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_FGIDL 444 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_KGIDL 445 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_RGIDL 446 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_FGISL 447 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_KGISL 448 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_RGISL 449 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LFGIDL 450 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LKGIDL 451 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LRGIDL 452 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LFGISL 453 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LKGISL 454 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_LRGISL 455 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WFGIDL 456 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WKGIDL 457 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WRGIDL 458 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WFGISL 459 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WKGISL 460 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_WRGISL 461 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PFGIDL 462 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PKGIDL 463 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PRGIDL 464 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PFGISL 465 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PKGISL 466 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_PRGISL 467 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_GIDLMOD 379 /* v4.7 New GIDL/GISL*/
#define BSIM4_MOD_DVTP2 468 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_DVTP3 469 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_DVTP4 470 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_DVTP5 471 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_LDVTP2 472 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_LDVTP3 473 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_LDVTP4 474 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_LDVTP5 475 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_WDVTP2 476 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_WDVTP3 477 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_WDVTP4 478 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_WDVTP5 479 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_PDVTP2 480 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_PDVTP3 298 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_PDVTP4 299 /* v4.7 NEW DIBL/Rout*/
#define BSIM4_MOD_PDVTP5 300 /* v4.7 NEW DIBL/Rout*/
/* Width dependence */
#define BSIM4_MOD_WCDSC 481
@ -3550,11 +3564,11 @@ typedef struct sBSIM4model
#define BSIM4_MOD_LKVTH0 808
#define BSIM4_MOD_WKVTH0 809
#define BSIM4_MOD_PKVTH0 810
#define BSIM4_MOD_WLOD 811
#define BSIM4_MOD_STK2 812
#define BSIM4_MOD_LODK2 813
#define BSIM4_MOD_STETA0 814
#define BSIM4_MOD_LODETA0 815
#define BSIM4_MOD_WLOD 811
#define BSIM4_MOD_STK2 812
#define BSIM4_MOD_LODK2 813
#define BSIM4_MOD_STETA0 814
#define BSIM4_MOD_LODETA0 815
#define BSIM4_MOD_WEB 816
#define BSIM4_MOD_WEC 817
@ -3643,29 +3657,29 @@ typedef struct sBSIM4model
/* trap-assisted tunneling */
#define BSIM4_MOD_JTSS 900
#define BSIM4_MOD_JTSD 901
#define BSIM4_MOD_JTSSWS 902
#define BSIM4_MOD_JTSSWD 903
#define BSIM4_MOD_JTSSWGS 904
#define BSIM4_MOD_JTSSWGD 905
#define BSIM4_MOD_NJTS 906
#define BSIM4_MOD_NJTSSW 907
#define BSIM4_MOD_NJTSSWG 908
#define BSIM4_MOD_XTSS 909
#define BSIM4_MOD_XTSD 910
#define BSIM4_MOD_XTSSWS 911
#define BSIM4_MOD_XTSSWD 912
#define BSIM4_MOD_XTSSWGS 913
#define BSIM4_MOD_XTSSWGD 914
#define BSIM4_MOD_TNJTS 915
#define BSIM4_MOD_TNJTSSW 916
#define BSIM4_MOD_TNJTSSWG 917
#define BSIM4_MOD_JTSD 901
#define BSIM4_MOD_JTSSWS 902
#define BSIM4_MOD_JTSSWD 903
#define BSIM4_MOD_JTSSWGS 904
#define BSIM4_MOD_JTSSWGD 905
#define BSIM4_MOD_NJTS 906
#define BSIM4_MOD_NJTSSW 907
#define BSIM4_MOD_NJTSSWG 908
#define BSIM4_MOD_XTSS 909
#define BSIM4_MOD_XTSD 910
#define BSIM4_MOD_XTSSWS 911
#define BSIM4_MOD_XTSSWD 912
#define BSIM4_MOD_XTSSWGS 913
#define BSIM4_MOD_XTSSWGD 914
#define BSIM4_MOD_TNJTS 915
#define BSIM4_MOD_TNJTSSW 916
#define BSIM4_MOD_TNJTSSWG 917
#define BSIM4_MOD_VTSS 918
#define BSIM4_MOD_VTSD 919
#define BSIM4_MOD_VTSSWS 920
#define BSIM4_MOD_VTSSWD 921
#define BSIM4_MOD_VTSSWGS 922
#define BSIM4_MOD_VTSSWGD 923
#define BSIM4_MOD_VTSD 919
#define BSIM4_MOD_VTSSWS 920
#define BSIM4_MOD_VTSSWD 921
#define BSIM4_MOD_VTSSWGS 922
#define BSIM4_MOD_VTSSWGD 923
#define BSIM4_MOD_PUD 924
#define BSIM4_MOD_PUD1 925
#define BSIM4_MOD_PUP 926
@ -3722,9 +3736,9 @@ typedef struct sBSIM4model
#define BSIM4_DRAINCONDUCT 991
#define BSIM4_CBDB 992
#define BSIM4_CBSB 993
#define BSIM4_CSUB 994
#define BSIM4_QINV 995
#define BSIM4_IGIDL 996
#define BSIM4_CSUB 994
#define BSIM4_QINV 995
#define BSIM4_IGIDL 996
#define BSIM4_CSGB 997
#define BSIM4_CSDB 998
#define BSIM4_CSSB 999
@ -3733,14 +3747,14 @@ typedef struct sBSIM4model
#define BSIM4_CSBB 1002
#define BSIM4_CBBB 1003
#define BSIM4_QS 1004
#define BSIM4_IGISL 1005
#define BSIM4_IGS 1006
#define BSIM4_IGD 1007
#define BSIM4_IGB 1008
#define BSIM4_IGCS 1009
#define BSIM4_IGCD 1010
#define BSIM4_QDEF 1011
#define BSIM4_DELVT0 1012
#define BSIM4_IGISL 1005
#define BSIM4_IGS 1006
#define BSIM4_IGD 1007
#define BSIM4_IGB 1008
#define BSIM4_IGCS 1009
#define BSIM4_IGCD 1010
#define BSIM4_QDEF 1011
#define BSIM4_DELVT0 1012
#define BSIM4_GCRG 1013
#define BSIM4_GTAU 1014
@ -3753,13 +3767,13 @@ typedef struct sBSIM4model
#define BSIM4_MOD_LKVTH0WE 1061
#define BSIM4_MOD_LK2WE 1062
#define BSIM4_MOD_LKU0WE 1063
#define BSIM4_MOD_LKU0WE 1063
#define BSIM4_MOD_WKVTH0WE 1064
#define BSIM4_MOD_WK2WE 1065
#define BSIM4_MOD_WKU0WE 1066
#define BSIM4_MOD_WKU0WE 1066
#define BSIM4_MOD_PKVTH0WE 1067
#define BSIM4_MOD_PK2WE 1068
#define BSIM4_MOD_PKU0WE 1069
#define BSIM4_MOD_PKU0WE 1069
#define BSIM4_MOD_RBPS0 1101
#define BSIM4_MOD_RBPSL 1102
@ -3843,26 +3857,35 @@ typedef struct sBSIM4model
/* v4.7 temp dep of leakage current */
#define BSIM4_MOD_TNFACTOR 1256
#define BSIM4_MOD_TETA0 1257
#define BSIM4_MOD_TVOFFCV 1258
#define BSIM4_MOD_LTNFACTOR 1260
#define BSIM4_MOD_LTETA0 1261
#define BSIM4_MOD_LTVOFFCV 1262
#define BSIM4_MOD_WTNFACTOR 1264
#define BSIM4_MOD_WTETA0 1265
#define BSIM4_MOD_WTVOFFCV 1266
#define BSIM4_MOD_PTNFACTOR 1268
#define BSIM4_MOD_PTETA0 1269
#define BSIM4_MOD_PTVOFFCV 1270
#define BSIM4_MOD_TNFACTOR 1256
#define BSIM4_MOD_TETA0 1257
#define BSIM4_MOD_TVOFFCV 1258
#define BSIM4_MOD_LTNFACTOR 1260
#define BSIM4_MOD_LTETA0 1261
#define BSIM4_MOD_LTVOFFCV 1262
#define BSIM4_MOD_WTNFACTOR 1264
#define BSIM4_MOD_WTETA0 1265
#define BSIM4_MOD_WTVOFFCV 1266
#define BSIM4_MOD_PTNFACTOR 1268
#define BSIM4_MOD_PTETA0 1269
#define BSIM4_MOD_PTVOFFCV 1270
/* tnoiMod=2 (v4.7) */
#define BSIM4_MOD_TNOIC 1272
#define BSIM4_MOD_RNOIC 1273
#define BSIM4_MOD_TNOIC 1272
#define BSIM4_MOD_RNOIC 1273
/* smoothing for gidl clamp (C.K.Dabhi) */
#define BSIM4_MOD_GIDLCLAMP 1274
#define BSIM4_MOD_GIDLCLAMP 1274
/* Tuning for noise parameter BSIM4IdovVds (C.K.Dabhi) - request cadence */
#define BSIM4_MOD_IDOVVDSC 1275
#define BSIM4_MOD_IDOVVDSC 1275
/* for dynamic evaluate */
#define BSIM4_MOD_KETAC 1276
#define BSIM4_MOD_LKETAC 1277
#define BSIM4_MOD_WKETAC 1278
#define BSIM4_MOD_PKETAC 1279
#define BSIM4_MULT_I 1280
#define BSIM4_MULT_Q 1281
#define BSIM4_MULT_FN 1282
#define BSIM4_MOD_VGS_MAX 1301
#define BSIM4_MOD_VGD_MAX 1302
@ -3876,14 +3899,6 @@ typedef struct sBSIM4model
#define BSIM4_MOD_VBSR_MAX 1310
#define BSIM4_MOD_VBDR_MAX 1311
#define BSIM4_VGSTEFF 1400
#define BSIM4_VDSEFF 1401
#define BSIM4_CGSO 1402
#define BSIM4_CGDO 1403
#define BSIM4_CGBO 1404
#define BSIM4_WEFF 1405
#define BSIM4_LEFF 1406
#include "bsim4ext.h"
extern void BSIM4evaluate(double,double,double,BSIM4instance*,BSIM4model*,
@ -3898,3 +3913,4 @@ extern int BSIM4RdsEndIso(double, double, double, double, double, double, int, i
extern int BSIM4RdsEndSha(double, double, double, double, double, double, int, int, double *);
#endif /*BSIM4*/

22
src/spicelib/devices/bsim4/bsim4ext.h
View File

@ -1,29 +1,25 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
extern int BSIM4acLoad(GENmodel *,CKTcircuit*);
@ -38,7 +34,7 @@ extern void BSIM4mosCap(CKTcircuit*, 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*,
double*, double*, double*, double*, double*, double*, double*,
double*);
extern int BSIM4param(int,IFvalue*,GENinstance*,IFvalue*);
extern int BSIM4pzLoad(GENmodel*,CKTcircuit*,SPcomplex*);

20
src/spicelib/devices/bsim4/bsim4itf.h
View File

@ -1,29 +1,25 @@
/* ******************************************************************************
* BSIM4 4.8.2 released by Chetan Kumar Dabhi 01/01/2020 *
* BSIM4 4.8.3 released on 05/19/2025 *
* BSIM4 Model Equations *
******************************************************************************
******************************************************************************
* Copyright (c) 2020 University of California *
* Copyright (c) 2025 University of California *
* *
* Project Director: Prof. Chenming Hu. *
* Current developers: Chetan Kumar Dabhi (Ph.D. student, IIT Kanpur) *
* Prof. Yogesh Chauhan (IIT Kanpur) *
* Dr. Pragya Kushwaha (Postdoc, UC Berkeley) *
* Dr. Avirup Dasgupta (Postdoc, UC Berkeley) *
* Ming-Yen Kao (Ph.D. student, UC Berkeley) *
* Authors: Gary W. Ng, Weidong Liu, Xuemei Xi, Mohan Dunga, Wenwei Yang *
* Ali Niknejad, Chetan Kumar Dabhi, Yogesh Singh Chauhan, *
* Sayeef Salahuddin, Chenming Hu *
* Project Directors: Prof. Sayeef Salahuddin and Prof. Chenming Hu *
* Developers list: https://www.bsim.berkeley.edu/models/bsim4/auth_bsim4/ *
******************************************************************************/
/*
Licensed under Educational Community License, Version 2.0 (the "License"); you may
not use this file except in compliance with the License. You may obtain a copy of the license at
http://opensource.org/licenses/ECL-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations
under the License.
BSIM4 model is supported by the members of Silicon Integration Initiative's Compact Model Coalition. A link to the most recent version of this
standard can be found at: http://www.si2.org/cmc
*/
#ifndef DEV_BSIM4

Write Preview
Loading…
Cancel
Save