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

obsolete - merged with bsim3v1

pre-master-46
dwarning 15 years ago
parent
696601ca21
commit
7785cfce91
25 changed files with 0 additions and 10687 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      src/spicelib/devices/bsim3v1s/.cvsignore
  2. 34
      src/spicelib/devices/bsim3v1s/Makefile.am
  3. 444
      src/spicelib/devices/bsim3v1s/b3v1s.c
  4. 181
      src/spicelib/devices/bsim3v1s/b3v1sacld.c
  5. 195
      src/spicelib/devices/bsim3v1s/b3v1sask.c
  6. 361
      src/spicelib/devices/bsim3v1s/b3v1scheck.c
  7. 110
      src/spicelib/devices/bsim3v1s/b3v1scvtest.c
  8. 39
      src/spicelib/devices/bsim3v1s/b3v1sdel.c
  9. 37
      src/spicelib/devices/bsim3v1s/b3v1sdest.c
  10. 45
      src/spicelib/devices/bsim3v1s/b3v1sgetic.c
  11. 2447
      src/spicelib/devices/bsim3v1s/b3v1sld.c
  12. 1126
      src/spicelib/devices/bsim3v1s/b3v1smask.c
  13. 43
      src/spicelib/devices/bsim3v1s/b3v1smdel.c
  14. 1528
      src/spicelib/devices/bsim3v1s/b3v1smpar.c
  15. 366
      src/spicelib/devices/bsim3v1s/b3v1snoi.c
  16. 104
      src/spicelib/devices/bsim3v1s/b3v1spar.c
  17. 149
      src/spicelib/devices/bsim3v1s/b3v1spzld.c
  18. 981
      src/spicelib/devices/bsim3v1s/b3v1sset.c
  19. 669
      src/spicelib/devices/bsim3v1s/b3v1stemp.c
  20. 49
      src/spicelib/devices/bsim3v1s/b3v1strunc.c
  21. 1629
      src/spicelib/devices/bsim3v1s/bsim3v1sdef.h
  22. 30
      src/spicelib/devices/bsim3v1s/bsim3v1sext.h
  23. 89
      src/spicelib/devices/bsim3v1s/bsim3v1sinit.c
  24. 13
      src/spicelib/devices/bsim3v1s/bsim3v1sinit.h
  25. 12
      src/spicelib/devices/bsim3v1s/bsim3v1sitf.h

6
src/spicelib/devices/bsim3v1s/.cvsignore
View File

@ -1,6 +0,0 @@
Makefile.in
Makefile
.deps
.libs
*.lo
*.la

34
src/spicelib/devices/bsim3v1s/Makefile.am
View File

@ -1,34 +0,0 @@
## Process this file with automake to produce Makefile.in
noinst_LTLIBRARIES = libbsim3v1s.la
libbsim3v1s_la_SOURCES = \
b3v1s.c \
b3v1sacld.c \
b3v1sask.c \
b3v1scheck.c \
b3v1scvtest.c \
b3v1sdel.c \
b3v1sdest.c \
b3v1sgetic.c \
b3v1sld.c \
b3v1smask.c \
b3v1smdel.c \
b3v1smpar.c \
b3v1snoi.c \
b3v1spar.c \
b3v1spzld.c \
b3v1sset.c \
b3v1stemp.c \
b3v1strunc.c \
bsim3v1sdef.h \
bsim3v1sext.h \
bsim3v1sinit.c \
bsim3v1sinit.h \
bsim3v1sitf.h
AM_CPPFLAGS = -I$(top_srcdir)/src/include
MAINTAINERCLEANFILES = Makefile.in

444
src/spicelib/devices/bsim3v1s/b3v1s.c
View File

@ -1,444 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1s.c
**********/
#include "ngspice.h"
#include "devdefs.h"
#include "bsim3v1sdef.h"
#include "suffix.h"
IFparm BSIM3v1SpTable[] = { /* parameters */
IOP( "l", BSIM3v1S_L, IF_REAL , "Length"),
IOP( "w", BSIM3v1S_W, IF_REAL , "Width"),
IOP( "ad", BSIM3v1S_AD, IF_REAL , "Drain area"),
IOP( "as", BSIM3v1S_AS, IF_REAL , "Source area"),
IOP( "pd", BSIM3v1S_PD, IF_REAL , "Drain perimeter"),
IOP( "ps", BSIM3v1S_PS, IF_REAL , "Source perimeter"),
IOP( "nrd", BSIM3v1S_NRD, IF_REAL , "Number of squares in drain"),
IOP( "nrs", BSIM3v1S_NRS, IF_REAL , "Number of squares in source"),
IOP( "off", BSIM3v1S_OFF, IF_FLAG , "Device is initially off"),
IOP( "nqsmod", BSIM3v1S_NQSMOD, IF_INTEGER, "Non-quasi-static model selector"),
IP( "ic", BSIM3v1S_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"),
OP( "gmbs", BSIM3v1S_GMBS, IF_REAL, "Gmb"),
OP( "gm", BSIM3v1S_GM, IF_REAL, "Gm"),
OP( "gds", BSIM3v1S_GDS, IF_REAL, "Gds"),
OP( "vdsat", BSIM3v1S_VDSAT, IF_REAL, "Vdsat"),
OP( "vth", BSIM3v1S_VON, IF_REAL, "Vth"),
OP( "id", BSIM3v1S_CD, IF_REAL, "Ids"),
OP( "vbs", BSIM3v1S_VBS, IF_REAL, "Vbs"),
OP( "vgs", BSIM3v1S_VGS, IF_REAL, "Vgs"),
OP( "vds", BSIM3v1S_VDS, IF_REAL, "Vds"),
/* serban */
IOP( "m", BSIM3v1S_M, IF_REAL , "Multiplication factor"),
};
IFparm BSIM3v1SmPTable[] = { /* model parameters */
IOP( "capmod", BSIM3v1S_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"),
IOP( "nqsmod", BSIM3v1S_MOD_NQSMOD, IF_INTEGER, "Non-quasi-static model selector"),
IOP( "mobmod", BSIM3v1S_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"),
IOP( "noimod", BSIM3v1S_MOD_NOIMOD, IF_INTEGER, "Noise model selector"),
IOP( "paramchk", BSIM3v1S_MOD_PARAMCHK, IF_INTEGER, "Model parameter checking selector"),
IOP( "binunit", BSIM3v1S_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"),
IOP( "version", BSIM3v1S_MOD_VERSION, IF_REAL, " parameter for model version"),
IOP( "tox", BSIM3v1S_MOD_TOX, IF_REAL, "Gate oxide thickness in meters"),
IOP( "cdsc", BSIM3v1S_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"),
IOP( "cdscb", BSIM3v1S_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"),
IOP( "cdscd", BSIM3v1S_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"),
IOP( "cit", BSIM3v1S_MOD_CIT, IF_REAL, "Interface state capacitance"),
IOP( "nfactor", BSIM3v1S_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"),
IOP( "xj", BSIM3v1S_MOD_XJ, IF_REAL, "Junction depth in meters"),
IOP( "vsat", BSIM3v1S_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"),
IOP( "at", BSIM3v1S_MOD_AT, IF_REAL, "Temperature coefficient of vsat"),
IOP( "a0", BSIM3v1S_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."),
IOP( "ags", BSIM3v1S_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."),
IOP( "a1", BSIM3v1S_MOD_A1, IF_REAL, "Non-saturation effect coefficient"),
IOP( "a2", BSIM3v1S_MOD_A2, IF_REAL, "Non-saturation effect coefficient"),
IOP( "keta", BSIM3v1S_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."),
IOP( "nsub", BSIM3v1S_MOD_NSUB, IF_REAL, "Substrate doping concentration"),
IOP( "nch", BSIM3v1S_MOD_NPEAK, IF_REAL, "Channel doping concentration"),
IOP( "ngate", BSIM3v1S_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"),
IOP( "gamma1", BSIM3v1S_MOD_GAMMA1, IF_REAL, "Vth body coefficient"),
IOP( "gamma2", BSIM3v1S_MOD_GAMMA2, IF_REAL, "Vth body coefficient"),
IOP( "vbx", BSIM3v1S_MOD_VBX, IF_REAL, "Vth transition body Voltage"),
IOP( "vbm", BSIM3v1S_MOD_VBM, IF_REAL, "Maximum body voltage"),
IOP( "xt", BSIM3v1S_MOD_XT, IF_REAL, "Doping depth"),
IOP( "k1", BSIM3v1S_MOD_K1, IF_REAL, "Bulk effect coefficient 1"),
IOP( "kt1", BSIM3v1S_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt1l", BSIM3v1S_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt2", BSIM3v1S_MOD_KT2, IF_REAL, "Body-coefficient of kt1"),
IOP( "k2", BSIM3v1S_MOD_K2, IF_REAL, "Bulk effect coefficient 2"),
IOP( "k3", BSIM3v1S_MOD_K3, IF_REAL, "Narrow width effect coefficient"),
IOP( "k3b", BSIM3v1S_MOD_K3B, IF_REAL, "Body effect coefficient of k3"),
IOP( "w0", BSIM3v1S_MOD_W0, IF_REAL, "Narrow width effect parameter"),
IOP( "nlx", BSIM3v1S_MOD_NLX, IF_REAL, "Lateral non-uniform doping effect"),
IOP( "dvt0", BSIM3v1S_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"),
IOP( "dvt1", BSIM3v1S_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"),
IOP( "dvt2", BSIM3v1S_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"),
IOP( "dvt0w", BSIM3v1S_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"),
IOP( "dvt1w", BSIM3v1S_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"),
IOP( "dvt2w", BSIM3v1S_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"),
IOP( "drout", BSIM3v1S_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"),
IOP( "dsub", BSIM3v1S_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"),
IOP( "vth0", BSIM3v1S_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "vtho", BSIM3v1S_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "ua", BSIM3v1S_MOD_UA, IF_REAL, "Linear gate dependence of mobility"),
IOP( "ua1", BSIM3v1S_MOD_UA1, IF_REAL, "Temperature coefficient of ua"),
IOP( "ub", BSIM3v1S_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"),
IOP( "ub1", BSIM3v1S_MOD_UB1, IF_REAL, "Temperature coefficient of ub"),
IOP( "uc", BSIM3v1S_MOD_UC, IF_REAL, "Body-bias dependence of mobility"),
IOP( "uc1", BSIM3v1S_MOD_UC1, IF_REAL, "Temperature coefficient of uc"),
IOP( "u0", BSIM3v1S_MOD_U0, IF_REAL, "Low-field mobility at Tnom"),
IOP( "ute", BSIM3v1S_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"),
IOP( "voff", BSIM3v1S_MOD_VOFF, IF_REAL, "Threshold voltage offset"),
IOP( "tnom", BSIM3v1S_MOD_TNOM, IF_REAL, "Parameter measurement temperature"),
IOP( "cgso", BSIM3v1S_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"),
IOP( "cgdo", BSIM3v1S_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"),
IOP( "cgbo", BSIM3v1S_MOD_CGBO, IF_REAL, "Gate-bulk overlap capacitance per length"),
IOP( "xpart", BSIM3v1S_MOD_XPART, IF_REAL, "Channel charge partitioning"),
IOP( "elm", BSIM3v1S_MOD_ELM, IF_REAL, "Non-quasi-static Elmore Constant Parameter"),
IOP( "delta", BSIM3v1S_MOD_DELTA, IF_REAL, "Effective Vds parameter"),
IOP( "rsh", BSIM3v1S_MOD_RSH, IF_REAL, "Source-drain sheet resistance"),
IOP( "rdsw", BSIM3v1S_MOD_RDSW, IF_REAL, "Source-drain resistance per width"),
IOP( "prwg", BSIM3v1S_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "),
IOP( "prwb", BSIM3v1S_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "),
IOP( "prt", BSIM3v1S_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "),
IOP( "eta0", BSIM3v1S_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "etab", BSIM3v1S_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "pclm", BSIM3v1S_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"),
IOP( "pdiblc1", BSIM3v1S_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblc2", BSIM3v1S_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblcb", BSIM3v1S_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"),
IOP( "pscbe1", BSIM3v1S_MOD_PSCBE1, IF_REAL, "Substrate current body-effect coefficient"),
IOP( "pscbe2", BSIM3v1S_MOD_PSCBE2, IF_REAL, "Substrate current body-effect coefficient"),
IOP( "pvag", BSIM3v1S_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"),
IOP( "js", BSIM3v1S_MOD_JS, IF_REAL, "Source/drain junction reverse saturation current density"),
IOP( "jsw", BSIM3v1S_MOD_JSW, IF_REAL, "Sidewall junction reverse saturation current density"),
IOP( "pb", BSIM3v1S_MOD_PB, IF_REAL, "Source/drain junction built-in potential"),
IOP( "nj", BSIM3v1S_MOD_NJ, IF_REAL, "Source/drain junction emission coefficient"),
IOP( "xti", BSIM3v1S_MOD_XTI, IF_REAL, "Junction current temperature exponent"),
IOP( "mj", BSIM3v1S_MOD_MJ, IF_REAL, "Source/drain bottom junction capacitance grading coefficient"),
IOP( "pbsw", BSIM3v1S_MOD_PBSW, IF_REAL, "Source/drain sidewall junction capacitance built in potential"),
IOP( "mjsw", BSIM3v1S_MOD_MJSW, IF_REAL, "Source/drain sidewall junction capacitance grading coefficient"),
IOP( "pbswg", BSIM3v1S_MOD_PBSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance built in potential"),
IOP( "mjswg", BSIM3v1S_MOD_MJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance grading coefficient"),
IOP( "cj", BSIM3v1S_MOD_CJ, IF_REAL, "Source/drain bottom junction capacitance per unit area"),
IOP( "vfbcv", BSIM3v1S_MOD_VFBCV, IF_REAL, "Flat Band Voltage parameter for capmod=0 only"),
IOP( "cjsw", BSIM3v1S_MOD_CJSW, IF_REAL, "Source/drain sidewall junction capacitance per unit periphery"),
IOP( "cjswg", BSIM3v1S_MOD_CJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance per unit width"),
IOP( "lint", BSIM3v1S_MOD_LINT, IF_REAL, "Length reduction parameter"),
IOP( "ll", BSIM3v1S_MOD_LL, IF_REAL, "Length reduction parameter"),
IOP( "lln", BSIM3v1S_MOD_LLN, IF_REAL, "Length reduction parameter"),
IOP( "lw", BSIM3v1S_MOD_LW, IF_REAL, "Length reduction parameter"),
IOP( "lwn", BSIM3v1S_MOD_LWN, IF_REAL, "Length reduction parameter"),
IOP( "lwl", BSIM3v1S_MOD_LWL, IF_REAL, "Length reduction parameter"),
IOP( "lmin", BSIM3v1S_MOD_LMIN, IF_REAL, "Minimum length for the model"),
IOP( "lmax", BSIM3v1S_MOD_LMAX, IF_REAL, "Maximum length for the model"),
IOP( "wr", BSIM3v1S_MOD_WR, IF_REAL, "Width dependence of rds"),
IOP( "wint", BSIM3v1S_MOD_WINT, IF_REAL, "Width reduction parameter"),
IOP( "dwg", BSIM3v1S_MOD_DWG, IF_REAL, "Width reduction parameter"),
IOP( "dwb", BSIM3v1S_MOD_DWB, IF_REAL, "Width reduction parameter"),
IOP( "wl", BSIM3v1S_MOD_WL, IF_REAL, "Width reduction parameter"),
IOP( "wln", BSIM3v1S_MOD_WLN, IF_REAL, "Width reduction parameter"),
IOP( "ww", BSIM3v1S_MOD_WW, IF_REAL, "Width reduction parameter"),
IOP( "wwn", BSIM3v1S_MOD_WWN, IF_REAL, "Width reduction parameter"),
IOP( "wwl", BSIM3v1S_MOD_WWL, IF_REAL, "Width reduction parameter"),
IOP( "wmin", BSIM3v1S_MOD_WMIN, IF_REAL, "Minimum width for the model"),
IOP( "wmax", BSIM3v1S_MOD_WMAX, IF_REAL, "Maximum width for the model"),
IOP( "b0", BSIM3v1S_MOD_B0, IF_REAL, "Abulk narrow width parameter"),
IOP( "b1", BSIM3v1S_MOD_B1, IF_REAL, "Abulk narrow width parameter"),
IOP( "cgsl", BSIM3v1S_MOD_CGSL, IF_REAL, "New C-V model parameter"),
IOP( "cgdl", BSIM3v1S_MOD_CGDL, IF_REAL, "New C-V model parameter"),
IOP( "ckappa", BSIM3v1S_MOD_CKAPPA, IF_REAL, "New C-V model parameter"),
IOP( "cf", BSIM3v1S_MOD_CF, IF_REAL, "Fringe capacitance parameter"),
IOP( "clc", BSIM3v1S_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "cle", BSIM3v1S_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "dwc", BSIM3v1S_MOD_DWC, IF_REAL, "Delta W for C-V model"),
IOP( "dlc", BSIM3v1S_MOD_DLC, IF_REAL, "Delta L for C-V model"),
IOP( "alpha0", BSIM3v1S_MOD_ALPHA0, IF_REAL, "substrate current model parameter"),
IOP( "beta0", BSIM3v1S_MOD_BETA0, IF_REAL, "substrate current model parameter"),
IOP( "lcdsc", BSIM3v1S_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"),
IOP( "lcdscb", BSIM3v1S_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"),
IOP( "lcdscd", BSIM3v1S_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"),
IOP( "lcit", BSIM3v1S_MOD_LCIT, IF_REAL, "Length dependence of cit"),
IOP( "lnfactor", BSIM3v1S_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"),
IOP( "lxj", BSIM3v1S_MOD_LXJ, IF_REAL, "Length dependence of xj"),
IOP( "lvsat", BSIM3v1S_MOD_LVSAT, IF_REAL, "Length dependence of vsat"),
IOP( "lat", BSIM3v1S_MOD_LAT, IF_REAL, "Length dependence of at"),
IOP( "la0", BSIM3v1S_MOD_LA0, IF_REAL, "Length dependence of a0"),
IOP( "lags", BSIM3v1S_MOD_LAGS, IF_REAL, "Length dependence of ags"),
IOP( "la1", BSIM3v1S_MOD_LA1, IF_REAL, "Length dependence of a1"),
IOP( "la2", BSIM3v1S_MOD_LA2, IF_REAL, "Length dependence of a2"),
IOP( "lketa", BSIM3v1S_MOD_LKETA, IF_REAL, "Length dependence of keta"),
IOP( "lnsub", BSIM3v1S_MOD_LNSUB, IF_REAL, "Length dependence of nsub"),
IOP( "lnch", BSIM3v1S_MOD_LNPEAK, IF_REAL, "Length dependence of nch"),
IOP( "lngate", BSIM3v1S_MOD_LNGATE, IF_REAL, "Length dependence of ngate"),
IOP( "lgamma1", BSIM3v1S_MOD_LGAMMA1, IF_REAL, "Length dependence of gamma1"),
IOP( "lgamma2", BSIM3v1S_MOD_LGAMMA2, IF_REAL, "Length dependence of gamma2"),
IOP( "lvbx", BSIM3v1S_MOD_LVBX, IF_REAL, "Length dependence of vbx"),
IOP( "lvbm", BSIM3v1S_MOD_LVBM, IF_REAL, "Length dependence of vbm"),
IOP( "lxt", BSIM3v1S_MOD_LXT, IF_REAL, "Length dependence of xt"),
IOP( "lk1", BSIM3v1S_MOD_LK1, IF_REAL, "Length dependence of k1"),
IOP( "lkt1", BSIM3v1S_MOD_LKT1, IF_REAL, "Length dependence of kt1"),
IOP( "lkt1l", BSIM3v1S_MOD_LKT1L, IF_REAL, "Length dependence of kt1l"),
IOP( "lkt2", BSIM3v1S_MOD_LKT2, IF_REAL, "Length dependence of kt2"),
IOP( "lk2", BSIM3v1S_MOD_LK2, IF_REAL, "Length dependence of k2"),
IOP( "lk3", BSIM3v1S_MOD_LK3, IF_REAL, "Length dependence of k3"),
IOP( "lk3b", BSIM3v1S_MOD_LK3B, IF_REAL, "Length dependence of k3b"),
IOP( "lw0", BSIM3v1S_MOD_LW0, IF_REAL, "Length dependence of w0"),
IOP( "lnlx", BSIM3v1S_MOD_LNLX, IF_REAL, "Length dependence of nlx"),
IOP( "ldvt0", BSIM3v1S_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"),
IOP( "ldvt1", BSIM3v1S_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"),
IOP( "ldvt2", BSIM3v1S_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"),
IOP( "ldvt0w", BSIM3v1S_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"),
IOP( "ldvt1w", BSIM3v1S_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"),
IOP( "ldvt2w", BSIM3v1S_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"),
IOP( "ldrout", BSIM3v1S_MOD_LDROUT, IF_REAL, "Length dependence of drout"),
IOP( "ldsub", BSIM3v1S_MOD_LDSUB, IF_REAL, "Length dependence of dsub"),
IOP( "lvth0", BSIM3v1S_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOP( "lvtho", BSIM3v1S_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOP( "lua", BSIM3v1S_MOD_LUA, IF_REAL, "Length dependence of ua"),
IOP( "lua1", BSIM3v1S_MOD_LUA1, IF_REAL, "Length dependence of ua1"),
IOP( "lub", BSIM3v1S_MOD_LUB, IF_REAL, "Length dependence of ub"),
IOP( "lub1", BSIM3v1S_MOD_LUB1, IF_REAL, "Length dependence of ub1"),
IOP( "luc", BSIM3v1S_MOD_LUC, IF_REAL, "Length dependence of uc"),
IOP( "luc1", BSIM3v1S_MOD_LUC1, IF_REAL, "Length dependence of uc1"),
IOP( "lu0", BSIM3v1S_MOD_LU0, IF_REAL, "Length dependence of u0"),
IOP( "lute", BSIM3v1S_MOD_LUTE, IF_REAL, "Length dependence of ute"),
IOP( "lvoff", BSIM3v1S_MOD_LVOFF, IF_REAL, "Length dependence of voff"),
IOP( "lelm", BSIM3v1S_MOD_LELM, IF_REAL, "Length dependence of elm"),
IOP( "ldelta", BSIM3v1S_MOD_LDELTA, IF_REAL, "Length dependence of delta"),
IOP( "lrdsw", BSIM3v1S_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "),
IOP( "lprwg", BSIM3v1S_MOD_LPRWG, IF_REAL, "Length dependence of prwg "),
IOP( "lprwb", BSIM3v1S_MOD_LPRWB, IF_REAL, "Length dependence of prwb "),
IOP( "lprt", BSIM3v1S_MOD_LPRT, IF_REAL, "Length dependence of prt "),
IOP( "leta0", BSIM3v1S_MOD_LETA0, IF_REAL, "Length dependence of eta0"),
IOP( "letab", BSIM3v1S_MOD_LETAB, IF_REAL, "Length dependence of etab"),
IOP( "lpclm", BSIM3v1S_MOD_LPCLM, IF_REAL, "Length dependence of pclm"),
IOP( "lpdiblc1", BSIM3v1S_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"),
IOP( "lpdiblc2", BSIM3v1S_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"),
IOP( "lpdiblcb", BSIM3v1S_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"),
IOP( "lpscbe1", BSIM3v1S_MOD_LPSCBE1, IF_REAL, "Length dependence of pscbe1"),
IOP( "lpscbe2", BSIM3v1S_MOD_LPSCBE2, IF_REAL, "Length dependence of pscbe2"),
IOP( "lpvag", BSIM3v1S_MOD_LPVAG, IF_REAL, "Length dependence of pvag"),
IOP( "lwr", BSIM3v1S_MOD_LWR, IF_REAL, "Length dependence of wr"),
IOP( "ldwg", BSIM3v1S_MOD_LDWG, IF_REAL, "Length dependence of dwg"),
IOP( "ldwb", BSIM3v1S_MOD_LDWB, IF_REAL, "Length dependence of dwb"),
IOP( "lb0", BSIM3v1S_MOD_LB0, IF_REAL, "Length dependence of b0"),
IOP( "lb1", BSIM3v1S_MOD_LB1, IF_REAL, "Length dependence of b1"),
IOP( "lcgsl", BSIM3v1S_MOD_LCGSL, IF_REAL, "Length dependence of cgsl"),
IOP( "lcgdl", BSIM3v1S_MOD_LCGDL, IF_REAL, "Length dependence of cgdl"),
IOP( "lckappa", BSIM3v1S_MOD_LCKAPPA, IF_REAL, "Length dependence of ckappa"),
IOP( "lcf", BSIM3v1S_MOD_LCF, IF_REAL, "Length dependence of cf"),
IOP( "lclc", BSIM3v1S_MOD_LCLC, IF_REAL, "Length dependence of clc"),
IOP( "lcle", BSIM3v1S_MOD_LCLE, IF_REAL, "Length dependence of cle"),
IOP( "lalpha0", BSIM3v1S_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"),
IOP( "lbeta0", BSIM3v1S_MOD_LBETA0, IF_REAL, "Length dependence of beta0"),
IOP( "lvfbcv", BSIM3v1S_MOD_LVFBCV, IF_REAL, "Length dependence of vfbcv"),
IOP( "wcdsc", BSIM3v1S_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"),
IOP( "wcdscb", BSIM3v1S_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"),
IOP( "wcdscd", BSIM3v1S_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"),
IOP( "wcit", BSIM3v1S_MOD_WCIT, IF_REAL, "Width dependence of cit"),
IOP( "wnfactor", BSIM3v1S_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"),
IOP( "wxj", BSIM3v1S_MOD_WXJ, IF_REAL, "Width dependence of xj"),
IOP( "wvsat", BSIM3v1S_MOD_WVSAT, IF_REAL, "Width dependence of vsat"),
IOP( "wat", BSIM3v1S_MOD_WAT, IF_REAL, "Width dependence of at"),
IOP( "wa0", BSIM3v1S_MOD_WA0, IF_REAL, "Width dependence of a0"),
IOP( "wags", BSIM3v1S_MOD_WAGS, IF_REAL, "Width dependence of ags"),
IOP( "wa1", BSIM3v1S_MOD_WA1, IF_REAL, "Width dependence of a1"),
IOP( "wa2", BSIM3v1S_MOD_WA2, IF_REAL, "Width dependence of a2"),
IOP( "wketa", BSIM3v1S_MOD_WKETA, IF_REAL, "Width dependence of keta"),
IOP( "wnsub", BSIM3v1S_MOD_WNSUB, IF_REAL, "Width dependence of nsub"),
IOP( "wnch", BSIM3v1S_MOD_WNPEAK, IF_REAL, "Width dependence of nch"),
IOP( "wngate", BSIM3v1S_MOD_WNGATE, IF_REAL, "Width dependence of ngate"),
IOP( "wgamma1", BSIM3v1S_MOD_WGAMMA1, IF_REAL, "Width dependence of gamma1"),
IOP( "wgamma2", BSIM3v1S_MOD_WGAMMA2, IF_REAL, "Width dependence of gamma2"),
IOP( "wvbx", BSIM3v1S_MOD_WVBX, IF_REAL, "Width dependence of vbx"),
IOP( "wvbm", BSIM3v1S_MOD_WVBM, IF_REAL, "Width dependence of vbm"),
IOP( "wxt", BSIM3v1S_MOD_WXT, IF_REAL, "Width dependence of xt"),
IOP( "wk1", BSIM3v1S_MOD_WK1, IF_REAL, "Width dependence of k1"),
IOP( "wkt1", BSIM3v1S_MOD_WKT1, IF_REAL, "Width dependence of kt1"),
IOP( "wkt1l", BSIM3v1S_MOD_WKT1L, IF_REAL, "Width dependence of kt1l"),
IOP( "wkt2", BSIM3v1S_MOD_WKT2, IF_REAL, "Width dependence of kt2"),
IOP( "wk2", BSIM3v1S_MOD_WK2, IF_REAL, "Width dependence of k2"),
IOP( "wk3", BSIM3v1S_MOD_WK3, IF_REAL, "Width dependence of k3"),
IOP( "wk3b", BSIM3v1S_MOD_WK3B, IF_REAL, "Width dependence of k3b"),
IOP( "ww0", BSIM3v1S_MOD_WW0, IF_REAL, "Width dependence of w0"),
IOP( "wnlx", BSIM3v1S_MOD_WNLX, IF_REAL, "Width dependence of nlx"),
IOP( "wdvt0", BSIM3v1S_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"),
IOP( "wdvt1", BSIM3v1S_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"),
IOP( "wdvt2", BSIM3v1S_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"),
IOP( "wdvt0w", BSIM3v1S_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"),
IOP( "wdvt1w", BSIM3v1S_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"),
IOP( "wdvt2w", BSIM3v1S_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"),
IOP( "wdrout", BSIM3v1S_MOD_WDROUT, IF_REAL, "Width dependence of drout"),
IOP( "wdsub", BSIM3v1S_MOD_WDSUB, IF_REAL, "Width dependence of dsub"),
IOP( "wvth0", BSIM3v1S_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOP( "wvtho", BSIM3v1S_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOP( "wua", BSIM3v1S_MOD_WUA, IF_REAL, "Width dependence of ua"),
IOP( "wua1", BSIM3v1S_MOD_WUA1, IF_REAL, "Width dependence of ua1"),
IOP( "wub", BSIM3v1S_MOD_WUB, IF_REAL, "Width dependence of ub"),
IOP( "wub1", BSIM3v1S_MOD_WUB1, IF_REAL, "Width dependence of ub1"),
IOP( "wuc", BSIM3v1S_MOD_WUC, IF_REAL, "Width dependence of uc"),
IOP( "wuc1", BSIM3v1S_MOD_WUC1, IF_REAL, "Width dependence of uc1"),
IOP( "wu0", BSIM3v1S_MOD_WU0, IF_REAL, "Width dependence of u0"),
IOP( "wute", BSIM3v1S_MOD_WUTE, IF_REAL, "Width dependence of ute"),
IOP( "wvoff", BSIM3v1S_MOD_WVOFF, IF_REAL, "Width dependence of voff"),
IOP( "welm", BSIM3v1S_MOD_WELM, IF_REAL, "Width dependence of elm"),
IOP( "wdelta", BSIM3v1S_MOD_WDELTA, IF_REAL, "Width dependence of delta"),
IOP( "wrdsw", BSIM3v1S_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "),
IOP( "wprwg", BSIM3v1S_MOD_WPRWG, IF_REAL, "Width dependence of prwg "),
IOP( "wprwb", BSIM3v1S_MOD_WPRWB, IF_REAL, "Width dependence of prwb "),
IOP( "wprt", BSIM3v1S_MOD_WPRT, IF_REAL, "Width dependence of prt"),
IOP( "weta0", BSIM3v1S_MOD_WETA0, IF_REAL, "Width dependence of eta0"),
IOP( "wetab", BSIM3v1S_MOD_WETAB, IF_REAL, "Width dependence of etab"),
IOP( "wpclm", BSIM3v1S_MOD_WPCLM, IF_REAL, "Width dependence of pclm"),
IOP( "wpdiblc1", BSIM3v1S_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"),
IOP( "wpdiblc2", BSIM3v1S_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"),
IOP( "wpdiblcb", BSIM3v1S_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"),
IOP( "wpscbe1", BSIM3v1S_MOD_WPSCBE1, IF_REAL, "Width dependence of pscbe1"),
IOP( "wpscbe2", BSIM3v1S_MOD_WPSCBE2, IF_REAL, "Width dependence of pscbe2"),
IOP( "wpvag", BSIM3v1S_MOD_WPVAG, IF_REAL, "Width dependence of pvag"),
IOP( "wwr", BSIM3v1S_MOD_WWR, IF_REAL, "Width dependence of wr"),
IOP( "wdwg", BSIM3v1S_MOD_WDWG, IF_REAL, "Width dependence of dwg"),
IOP( "wdwb", BSIM3v1S_MOD_WDWB, IF_REAL, "Width dependence of dwb"),
IOP( "wb0", BSIM3v1S_MOD_WB0, IF_REAL, "Width dependence of b0"),
IOP( "wb1", BSIM3v1S_MOD_WB1, IF_REAL, "Width dependence of b1"),
IOP( "wcgsl", BSIM3v1S_MOD_WCGSL, IF_REAL, "Width dependence of cgsl"),
IOP( "wcgdl", BSIM3v1S_MOD_WCGDL, IF_REAL, "Width dependence of cgdl"),
IOP( "wckappa", BSIM3v1S_MOD_WCKAPPA, IF_REAL, "Width dependence of ckappa"),
IOP( "wcf", BSIM3v1S_MOD_WCF, IF_REAL, "Width dependence of cf"),
IOP( "wclc", BSIM3v1S_MOD_WCLC, IF_REAL, "Width dependence of clc"),
IOP( "wcle", BSIM3v1S_MOD_WCLE, IF_REAL, "Width dependence of cle"),
IOP( "walpha0", BSIM3v1S_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"),
IOP( "wbeta0", BSIM3v1S_MOD_WBETA0, IF_REAL, "Width dependence of beta0"),
IOP( "wvfbcv", BSIM3v1S_MOD_WVFBCV, IF_REAL, "Width dependence of vfbcv"),
IOP( "pcdsc", BSIM3v1S_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"),
IOP( "pcdscb", BSIM3v1S_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"),
IOP( "pcdscd", BSIM3v1S_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"),
IOP( "pcit", BSIM3v1S_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"),
IOP( "pnfactor", BSIM3v1S_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"),
IOP( "pxj", BSIM3v1S_MOD_PXJ, IF_REAL, "Cross-term dependence of xj"),
IOP( "pvsat", BSIM3v1S_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"),
IOP( "pat", BSIM3v1S_MOD_PAT, IF_REAL, "Cross-term dependence of at"),
IOP( "pa0", BSIM3v1S_MOD_PA0, IF_REAL, "Cross-term dependence of a0"),
IOP( "pags", BSIM3v1S_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"),
IOP( "pa1", BSIM3v1S_MOD_PA1, IF_REAL, "Cross-term dependence of a1"),
IOP( "pa2", BSIM3v1S_MOD_PA2, IF_REAL, "Cross-term dependence of a2"),
IOP( "pketa", BSIM3v1S_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"),
IOP( "pnsub", BSIM3v1S_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"),
IOP( "pnch", BSIM3v1S_MOD_PNPEAK, IF_REAL, "Cross-term dependence of nch"),
IOP( "pngate", BSIM3v1S_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"),
IOP( "pgamma1", BSIM3v1S_MOD_PGAMMA1, IF_REAL, "Cross-term dependence of gamma1"),
IOP( "pgamma2", BSIM3v1S_MOD_PGAMMA2, IF_REAL, "Cross-term dependence of gamma2"),
IOP( "pvbx", BSIM3v1S_MOD_PVBX, IF_REAL, "Cross-term dependence of vbx"),
IOP( "pvbm", BSIM3v1S_MOD_PVBM, IF_REAL, "Cross-term dependence of vbm"),
IOP( "pxt", BSIM3v1S_MOD_PXT, IF_REAL, "Cross-term dependence of xt"),
IOP( "pk1", BSIM3v1S_MOD_PK1, IF_REAL, "Cross-term dependence of k1"),
IOP( "pkt1", BSIM3v1S_MOD_PKT1, IF_REAL, "Cross-term dependence of kt1"),
IOP( "pkt1l", BSIM3v1S_MOD_PKT1L, IF_REAL, "Cross-term dependence of kt1l"),
IOP( "pkt2", BSIM3v1S_MOD_PKT2, IF_REAL, "Cross-term dependence of kt2"),
IOP( "pk2", BSIM3v1S_MOD_PK2, IF_REAL, "Cross-term dependence of k2"),
IOP( "pk3", BSIM3v1S_MOD_PK3, IF_REAL, "Cross-term dependence of k3"),
IOP( "pk3b", BSIM3v1S_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"),
IOP( "pw0", BSIM3v1S_MOD_PW0, IF_REAL, "Cross-term dependence of w0"),
IOP( "pnlx", BSIM3v1S_MOD_PNLX, IF_REAL, "Cross-term dependence of nlx"),
IOP( "pdvt0", BSIM3v1S_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"),
IOP( "pdvt1", BSIM3v1S_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"),
IOP( "pdvt2", BSIM3v1S_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"),
IOP( "pdvt0w", BSIM3v1S_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"),
IOP( "pdvt1w", BSIM3v1S_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"),
IOP( "pdvt2w", BSIM3v1S_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"),
IOP( "pdrout", BSIM3v1S_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"),
IOP( "pdsub", BSIM3v1S_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"),
IOP( "pvth0", BSIM3v1S_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOP( "pvtho", BSIM3v1S_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOP( "pua", BSIM3v1S_MOD_PUA, IF_REAL, "Cross-term dependence of ua"),
IOP( "pua1", BSIM3v1S_MOD_PUA1, IF_REAL, "Cross-term dependence of ua1"),
IOP( "pub", BSIM3v1S_MOD_PUB, IF_REAL, "Cross-term dependence of ub"),
IOP( "pub1", BSIM3v1S_MOD_PUB1, IF_REAL, "Cross-term dependence of ub1"),
IOP( "puc", BSIM3v1S_MOD_PUC, IF_REAL, "Cross-term dependence of uc"),
IOP( "puc1", BSIM3v1S_MOD_PUC1, IF_REAL, "Cross-term dependence of uc1"),
IOP( "pu0", BSIM3v1S_MOD_PU0, IF_REAL, "Cross-term dependence of u0"),
IOP( "pute", BSIM3v1S_MOD_PUTE, IF_REAL, "Cross-term dependence of ute"),
IOP( "pvoff", BSIM3v1S_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"),
IOP( "pelm", BSIM3v1S_MOD_PELM, IF_REAL, "Cross-term dependence of elm"),
IOP( "pdelta", BSIM3v1S_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"),
IOP( "prdsw", BSIM3v1S_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "),
IOP( "pprwg", BSIM3v1S_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "),
IOP( "pprwb", BSIM3v1S_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "),
IOP( "pprt", BSIM3v1S_MOD_PPRT, IF_REAL, "Cross-term dependence of prt "),
IOP( "peta0", BSIM3v1S_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"),
IOP( "petab", BSIM3v1S_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"),
IOP( "ppclm", BSIM3v1S_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"),
IOP( "ppdiblc1", BSIM3v1S_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"),
IOP( "ppdiblc2", BSIM3v1S_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"),
IOP( "ppdiblcb", BSIM3v1S_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"),
IOP( "ppscbe1", BSIM3v1S_MOD_PPSCBE1, IF_REAL, "Cross-term dependence of pscbe1"),
IOP( "ppscbe2", BSIM3v1S_MOD_PPSCBE2, IF_REAL, "Cross-term dependence of pscbe2"),
IOP( "ppvag", BSIM3v1S_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"),
IOP( "pwr", BSIM3v1S_MOD_PWR, IF_REAL, "Cross-term dependence of wr"),
IOP( "pdwg", BSIM3v1S_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"),
IOP( "pdwb", BSIM3v1S_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"),
IOP( "pb0", BSIM3v1S_MOD_PB0, IF_REAL, "Cross-term dependence of b0"),
IOP( "pb1", BSIM3v1S_MOD_PB1, IF_REAL, "Cross-term dependence of b1"),
IOP( "pcgsl", BSIM3v1S_MOD_PCGSL, IF_REAL, "Cross-term dependence of cgsl"),
IOP( "pcgdl", BSIM3v1S_MOD_PCGDL, IF_REAL, "Cross-term dependence of cgdl"),
IOP( "pckappa", BSIM3v1S_MOD_PCKAPPA, IF_REAL, "Cross-term dependence of ckappa"),
IOP( "pcf", BSIM3v1S_MOD_PCF, IF_REAL, "Cross-term dependence of cf"),
IOP( "pclc", BSIM3v1S_MOD_PCLC, IF_REAL, "Cross-term dependence of clc"),
IOP( "pcle", BSIM3v1S_MOD_PCLE, IF_REAL, "Cross-term dependence of cle"),
IOP( "palpha0", BSIM3v1S_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"),
IOP( "pbeta0", BSIM3v1S_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"),
IOP( "pvfbcv", BSIM3v1S_MOD_PVFBCV, IF_REAL, "Cross-term dependence of vfbcv"),
IOP( "noia", BSIM3v1S_MOD_NOIA, IF_REAL, "Flicker noise parameter"),
IOP( "noib", BSIM3v1S_MOD_NOIB, IF_REAL, "Flicker noise parameter"),
IOP( "noic", BSIM3v1S_MOD_NOIC, IF_REAL, "Flicker noise parameter"),
IOP( "em", BSIM3v1S_MOD_EM, IF_REAL, "Flicker noise parameter"),
IOP( "ef", BSIM3v1S_MOD_EF, IF_REAL, "Flicker noise frequency exponent"),
IOP( "af", BSIM3v1S_MOD_AF, IF_REAL, "Flicker noise exponent"),
IOP( "kf", BSIM3v1S_MOD_KF, IF_REAL, "Flicker noise coefficient"),
IP( "nmos", BSIM3v1S_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"),
IP( "pmos", BSIM3v1S_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"),
/* serban */
IOP( "hdif", BSIM3v1S_MOD_HDIF, IF_REAL, "S/D junction extension (HSPICE style)"),
};
char *BSIM3v1Snames[] = {
"Drain",
"Gate",
"Source",
"Bulk",
"Charge"
};
int BSIM3v1SnSize = NUMELEMS(BSIM3v1Snames);
int BSIM3v1SpTSize = NUMELEMS(BSIM3v1SpTable);
int BSIM3v1SmPTSize = NUMELEMS(BSIM3v1SmPTable);
int BSIM3v1SiSize = sizeof(BSIM3v1Sinstance);
int BSIM3v1SmSize = sizeof(BSIM3v1Smodel);

181
src/spicelib/devices/bsim3v1s/b3v1sacld.c
View File

@ -1,181 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1sacld.c
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "bsim3v1sdef.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3v1SacLoad(GENmodel *inModel, CKTcircuit *ckt)
{
BSIM3v1Smodel *model = (BSIM3v1Smodel*)inModel;
BSIM3v1Sinstance *here;
double xcggb, xcgdb, xcgsb, xcbgb, xcbdb, xcbsb, xcddb, xcssb, xcdgb;
double gdpr, gspr, gds, gbd, gbs, capbd, capbs, xcsgb, xcdsb, xcsdb;
double cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cddb, cdgb, cdsb, omega;
double GSoverlapCap, GDoverlapCap, GBoverlapCap, FwdSum, RevSum, Gm, Gmbs;
double dxpart, sxpart, cqgb, cqdb, cqsb, cqbb, xcqgb, xcqdb, xcqsb, xcqbb;
omega = ckt->CKTomega;
for (; model != NULL; model = model->BSIM3v1SnextModel)
{
for (here = model->BSIM3v1Sinstances; here!= NULL;
here = here->BSIM3v1SnextInstance)
{
if (here->BSIM3v1Sowner != ARCHme)
continue;
if (here->BSIM3v1Smode >= 0)
{ Gm = here->BSIM3v1Sgm;
Gmbs = here->BSIM3v1Sgmbs;
FwdSum = Gm + Gmbs;
RevSum = 0.0;
cggb = here->BSIM3v1Scggb;
cgsb = here->BSIM3v1Scgsb;
cgdb = here->BSIM3v1Scgdb;
cbgb = here->BSIM3v1Scbgb;
cbsb = here->BSIM3v1Scbsb;
cbdb = here->BSIM3v1Scbdb;
cdgb = here->BSIM3v1Scdgb;
cdsb = here->BSIM3v1Scdsb;
cddb = here->BSIM3v1Scddb;
cqgb = here->BSIM3v1Scqgb;
cqdb = here->BSIM3v1Scqdb;
cqsb = here->BSIM3v1Scqsb;
cqbb = here->BSIM3v1Scqbb;
sxpart = 0.6;
dxpart = 0.4;
}
else
{ Gm = -here->BSIM3v1Sgm;
Gmbs = -here->BSIM3v1Sgmbs;
FwdSum = 0.0;
RevSum = -Gm - Gmbs;
cggb = here->BSIM3v1Scggb;
cgsb = here->BSIM3v1Scgdb;
cgdb = here->BSIM3v1Scgsb;
cbgb = here->BSIM3v1Scbgb;
cbsb = here->BSIM3v1Scbdb;
cbdb = here->BSIM3v1Scbsb;
cdgb = -(here->BSIM3v1Scdgb + cggb + cbgb);
cdsb = -(here->BSIM3v1Scddb + cgsb + cbsb);
cddb = -(here->BSIM3v1Scdsb + cgdb + cbdb);
cqgb = here->BSIM3v1Scqgb;
cqdb = here->BSIM3v1Scqsb;
cqsb = here->BSIM3v1Scqdb;
cqbb = here->BSIM3v1Scqbb;
sxpart = 0.4;
dxpart = 0.6;
}
gdpr=here->BSIM3v1SdrainConductance;
gspr=here->BSIM3v1SsourceConductance;
gds= here->BSIM3v1Sgds;
gbd= here->BSIM3v1Sgbd;
gbs= here->BSIM3v1Sgbs;
capbd= here->BSIM3v1Scapbd;
capbs= here->BSIM3v1Scapbs;
GSoverlapCap = here->BSIM3v1Scgso;
GDoverlapCap = here->BSIM3v1Scgdo;
GBoverlapCap = here->pParam->BSIM3v1Scgbo;
xcdgb = (cdgb - GDoverlapCap) * omega;
xcddb = (cddb + capbd + GDoverlapCap) * omega;
xcdsb = cdsb * omega;
xcsgb = -(cggb + cbgb + cdgb + GSoverlapCap) * omega;
xcsdb = -(cgdb + cbdb + cddb) * omega;
xcssb = (capbs + GSoverlapCap - (cgsb + cbsb + cdsb)) * omega;
xcggb = (cggb + GDoverlapCap + GSoverlapCap + GBoverlapCap)
* omega;
xcgdb = (cgdb - GDoverlapCap ) * omega;
xcgsb = (cgsb - GSoverlapCap) * omega;
xcbgb = (cbgb - GBoverlapCap) * omega;
xcbdb = (cbdb - capbd ) * omega;
xcbsb = (cbsb - capbs ) * omega;
xcqgb = cqgb * omega;
xcqdb = cqdb * omega;
xcqsb = cqsb * omega;
xcqbb = cqbb * omega;
*(here->BSIM3v1SGgPtr +1) += xcggb;
*(here->BSIM3v1SBbPtr +1) -= xcbgb + xcbdb + xcbsb;
*(here->BSIM3v1SDPdpPtr +1) += xcddb;
*(here->BSIM3v1SSPspPtr +1) += xcssb;
*(here->BSIM3v1SGbPtr +1) -= xcggb + xcgdb + xcgsb;
*(here->BSIM3v1SGdpPtr +1) += xcgdb;
*(here->BSIM3v1SGspPtr +1) += xcgsb;
*(here->BSIM3v1SBgPtr +1) += xcbgb;
*(here->BSIM3v1SBdpPtr +1) += xcbdb;
*(here->BSIM3v1SBspPtr +1) += xcbsb;
*(here->BSIM3v1SDPgPtr +1) += xcdgb;
*(here->BSIM3v1SDPbPtr +1) -= xcdgb + xcddb + xcdsb;
*(here->BSIM3v1SDPspPtr +1) += xcdsb;
*(here->BSIM3v1SSPgPtr +1) += xcsgb;
*(here->BSIM3v1SSPbPtr +1) -= xcsgb + xcsdb + xcssb;
*(here->BSIM3v1SSPdpPtr +1) += xcsdb;
*(here->BSIM3v1SQqPtr +1) += omega;
*(here->BSIM3v1SQgPtr +1) -= xcqgb;
*(here->BSIM3v1SQdpPtr +1) -= xcqdb;
*(here->BSIM3v1SQspPtr +1) -= xcqsb;
*(here->BSIM3v1SQbPtr +1) -= xcqbb;
*(here->BSIM3v1SDdPtr) += gdpr;
*(here->BSIM3v1SSsPtr) += gspr;
*(here->BSIM3v1SBbPtr) += gbd + gbs;
*(here->BSIM3v1SDPdpPtr) += gdpr + gds + gbd + RevSum + dxpart*here->BSIM3v1Sgtd;
*(here->BSIM3v1SSPspPtr) += gspr + gds + gbs + FwdSum + sxpart*here->BSIM3v1Sgts;
*(here->BSIM3v1SDdpPtr) -= gdpr;
*(here->BSIM3v1SSspPtr) -= gspr;
*(here->BSIM3v1SBdpPtr) -= gbd;
*(here->BSIM3v1SBspPtr) -= gbs;
*(here->BSIM3v1SDPdPtr) -= gdpr;
*(here->BSIM3v1SDPgPtr) += Gm + dxpart * here->BSIM3v1Sgtg;
*(here->BSIM3v1SDPbPtr) -= gbd - Gmbs - dxpart * here->BSIM3v1Sgtb;
*(here->BSIM3v1SDPspPtr) -= gds + FwdSum - dxpart * here->BSIM3v1Sgts;
*(here->BSIM3v1SSPgPtr) -= Gm - sxpart * here->BSIM3v1Sgtg;
*(here->BSIM3v1SSPsPtr) -= gspr;
*(here->BSIM3v1SSPbPtr) -= gbs + Gmbs - sxpart * here->BSIM3v1Sgtg;
*(here->BSIM3v1SSPdpPtr) -= gds + RevSum - sxpart * here->BSIM3v1Sgtd;
*(here->BSIM3v1SGgPtr) -= here->BSIM3v1Sgtg;
*(here->BSIM3v1SGbPtr) -= here->BSIM3v1Sgtb;
*(here->BSIM3v1SGdpPtr) -= here->BSIM3v1Sgtd;
*(here->BSIM3v1SGspPtr) -= here->BSIM3v1Sgts;
*(here->BSIM3v1SQqPtr) += here->BSIM3v1Sgtau;
*(here->BSIM3v1SDPqPtr) += dxpart * here->BSIM3v1Sgtau;
*(here->BSIM3v1SSPqPtr) += sxpart * here->BSIM3v1Sgtau;
*(here->BSIM3v1SGqPtr) -= here->BSIM3v1Sgtau;
*(here->BSIM3v1SQgPtr) += here->BSIM3v1Sgtg;
*(here->BSIM3v1SQdpPtr) += here->BSIM3v1Sgtd;
*(here->BSIM3v1SQspPtr) += here->BSIM3v1Sgts;
*(here->BSIM3v1SQbPtr) += here->BSIM3v1Sgtb;
}
}
return(OK);
}

195
src/spicelib/devices/bsim3v1s/b3v1sask.c
View File

@ -1,195 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1sask.c
**********/
#include "ngspice.h"
#include "ifsim.h"
#include "cktdefs.h"
#include "devdefs.h"
#include "bsim3v1sdef.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3v1Sask(CKTcircuit *ckt, GENinstance *inst, int which, IFvalue *value,
IFvalue *select)
{
BSIM3v1Sinstance *here = (BSIM3v1Sinstance*)inst;
NG_IGNORE(select);
switch(which)
{ case BSIM3v1S_L:
value->rValue = here->BSIM3v1Sl;
return(OK);
case BSIM3v1S_W:
value->rValue = here->BSIM3v1Sw;
return(OK);
case BSIM3v1S_AS:
value->rValue = here->BSIM3v1SsourceArea;
return(OK);
case BSIM3v1S_AD:
value->rValue = here->BSIM3v1SdrainArea;
return(OK);
case BSIM3v1S_PS:
value->rValue = here->BSIM3v1SsourcePerimeter;
return(OK);
case BSIM3v1S_PD:
value->rValue = here->BSIM3v1SdrainPerimeter;
return(OK);
case BSIM3v1S_NRS:
value->rValue = here->BSIM3v1SsourceSquares;
return(OK);
case BSIM3v1S_NRD:
value->rValue = here->BSIM3v1SdrainSquares;
return(OK);
case BSIM3v1S_OFF:
value->rValue = here->BSIM3v1Soff;
return(OK);
case BSIM3v1S_NQSMOD:
value->iValue = here->BSIM3v1SnqsMod;
return(OK);
case BSIM3v1S_M:
value->rValue = here->BSIM3v1Sm;
return(OK);
case BSIM3v1S_IC_VBS:
value->rValue = here->BSIM3v1SicVBS;
return(OK);
case BSIM3v1S_IC_VDS:
value->rValue = here->BSIM3v1SicVDS;
return(OK);
case BSIM3v1S_IC_VGS:
value->rValue = here->BSIM3v1SicVGS;
return(OK);
case BSIM3v1S_DNODE:
value->iValue = here->BSIM3v1SdNode;
return(OK);
case BSIM3v1S_GNODE:
value->iValue = here->BSIM3v1SgNode;
return(OK);
case BSIM3v1S_SNODE:
value->iValue = here->BSIM3v1SsNode;
return(OK);
case BSIM3v1S_BNODE:
value->iValue = here->BSIM3v1SbNode;
return(OK);
case BSIM3v1S_DNODEPRIME:
value->iValue = here->BSIM3v1SdNodePrime;
return(OK);
case BSIM3v1S_SNODEPRIME:
value->iValue = here->BSIM3v1SsNodePrime;
return(OK);
case BSIM3v1S_SOURCECONDUCT:
value->rValue = here->BSIM3v1SsourceConductance;
return(OK);
case BSIM3v1S_DRAINCONDUCT:
value->rValue = here->BSIM3v1SdrainConductance;
return(OK);
case BSIM3v1S_VBD:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Svbd);
return(OK);
case BSIM3v1S_VBS:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Svbs);
return(OK);
case BSIM3v1S_VGS:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Svgs);
return(OK);
case BSIM3v1S_VDS:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Svds);
return(OK);
case BSIM3v1S_CD:
value->rValue = here->BSIM3v1Scd;
return(OK);
case BSIM3v1S_CBS:
value->rValue = here->BSIM3v1Scbs;
return(OK);
case BSIM3v1S_CBD:
value->rValue = here->BSIM3v1Scbd;
return(OK);
case BSIM3v1S_GM:
value->rValue = here->BSIM3v1Sgm;
return(OK);
case BSIM3v1S_GDS:
value->rValue = here->BSIM3v1Sgds;
return(OK);
case BSIM3v1S_GMBS:
value->rValue = here->BSIM3v1Sgmbs;
return(OK);
case BSIM3v1S_GBD:
value->rValue = here->BSIM3v1Sgbd;
return(OK);
case BSIM3v1S_GBS:
value->rValue = here->BSIM3v1Sgbs;
return(OK);
case BSIM3v1S_QB:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Sqb);
return(OK);
case BSIM3v1S_CQB:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Scqb);
return(OK);
case BSIM3v1S_QG:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Sqg);
return(OK);
case BSIM3v1S_CQG:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Scqg);
return(OK);
case BSIM3v1S_QD:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Sqd);
return(OK);
case BSIM3v1S_CQD:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Scqd);
return(OK);
case BSIM3v1S_CGG:
value->rValue = here->BSIM3v1Scggb;
return(OK);
case BSIM3v1S_CGD:
value->rValue = here->BSIM3v1Scgdb;
return(OK);
case BSIM3v1S_CGS:
value->rValue = here->BSIM3v1Scgsb;
return(OK);
case BSIM3v1S_CDG:
value->rValue = here->BSIM3v1Scdgb;
return(OK);
case BSIM3v1S_CDD:
value->rValue = here->BSIM3v1Scddb;
return(OK);
case BSIM3v1S_CDS:
value->rValue = here->BSIM3v1Scdsb;
return(OK);
case BSIM3v1S_CBG:
value->rValue = here->BSIM3v1Scbgb;
return(OK);
case BSIM3v1S_CBDB:
value->rValue = here->BSIM3v1Scbdb;
return(OK);
case BSIM3v1S_CBSB:
value->rValue = here->BSIM3v1Scbsb;
return(OK);
case BSIM3v1S_CAPBD:
value->rValue = here->BSIM3v1Scapbd;
return(OK);
case BSIM3v1S_CAPBS:
value->rValue = here->BSIM3v1Scapbs;
return(OK);
case BSIM3v1S_VON:
value->rValue = here->BSIM3v1Svon;
return(OK);
case BSIM3v1S_VDSAT:
value->rValue = here->BSIM3v1Svdsat;
return(OK);
case BSIM3v1S_QBS:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Sqbs);
return(OK);
case BSIM3v1S_QBD:
value->rValue = *(ckt->CKTstate0 + here->BSIM3v1Sqbd);
return(OK);
default:
return(E_BADPARM);
}
/* NOTREACHED */
}

361
src/spicelib/devices/bsim3v1s/b3v1scheck.c
View File

@ -1,361 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: Min-Chie Jeng.
Modified by Paolo Nenzi 2002
File: b3v1scheck.c
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "bsim3v1sdef.h"
#include "trandefs.h"
#include "const.h"
#include "sperror.h"
#include "devdefs.h"
#include "suffix.h"
int
BSIM3v1ScheckModel(BSIM3v1Smodel *model, BSIM3v1Sinstance *here,
CKTcircuit *ckt)
{
struct bsim3v1sSizeDependParam *pParam;
int Fatal_Flag = 0;
FILE *fplog;
NG_IGNORE(ckt);
if ((fplog = fopen("BSIM3V3_1S_check.log", "w")) != NULL)
{ pParam = here->pParam;
fprintf(fplog, "BSIM3V3.1 (Serban) Parameter Check\n");
fprintf(fplog, "Model = %s\n", model->BSIM3v1SmodName);
fprintf(fplog, "W = %g, L = %g\n", here->BSIM3v1Sw, here->BSIM3v1Sl);
if (pParam->BSIM3v1Snlx < -pParam->BSIM3v1Sleff)
{ fprintf(fplog, "Fatal: Nlx = %g is less than -Leff.\n",
pParam->BSIM3v1Snlx);
printf("Fatal: Nlx = %g is less than -Leff.\n",
pParam->BSIM3v1Snlx);
Fatal_Flag = 1;
}
if (model->BSIM3v1Stox <= 0.0)
{ fprintf(fplog, "Fatal: Tox = %g is not positive.\n",
model->BSIM3v1Stox);
printf("Fatal: Tox = %g is not positive.\n", model->BSIM3v1Stox);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Snpeak <= 0.0)
{ fprintf(fplog, "Fatal: Nch = %g is not positive.\n",
pParam->BSIM3v1Snpeak);
printf("Fatal: Nch = %g is not positive.\n",
pParam->BSIM3v1Snpeak);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Snsub <= 0.0)
{ fprintf(fplog, "Fatal: Nsub = %g is not positive.\n",
pParam->BSIM3v1Snsub);
printf("Fatal: Nsub = %g is not positive.\n",
pParam->BSIM3v1Snsub);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Sngate < 0.0)
{ fprintf(fplog, "Fatal: Ngate = %g is not positive.\n",
pParam->BSIM3v1Sngate);
printf("Fatal: Ngate = %g Ngate is not positive.\n",
pParam->BSIM3v1Sngate);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Sngate > 1.e25)
{ fprintf(fplog, "Fatal: Ngate = %g is too high.\n",
pParam->BSIM3v1Sngate);
printf("Fatal: Ngate = %g Ngate is too high\n",
pParam->BSIM3v1Sngate);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Sxj <= 0.0)
{ fprintf(fplog, "Fatal: Xj = %g is not positive.\n",
pParam->BSIM3v1Sxj);
printf("Fatal: Xj = %g is not positive.\n", pParam->BSIM3v1Sxj);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Sdvt1 < 0.0)
{ fprintf(fplog, "Fatal: Dvt1 = %g is negative.\n",
pParam->BSIM3v1Sdvt1);
printf("Fatal: Dvt1 = %g is negative.\n", pParam->BSIM3v1Sdvt1);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Sdvt1w < 0.0)
{ fprintf(fplog, "Fatal: Dvt1w = %g is negative.\n",
pParam->BSIM3v1Sdvt1w);
printf("Fatal: Dvt1w = %g is negative.\n", pParam->BSIM3v1Sdvt1w);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Sw0 == -pParam->BSIM3v1Sweff)
{ fprintf(fplog, "Fatal: (W0 + Weff) = 0 cauing divided-by-zero.\n");
printf("Fatal: (W0 + Weff) = 0 cauing divided-by-zero.\n");
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Sdsub < 0.0)
{ fprintf(fplog, "Fatal: Dsub = %g is negative.\n", pParam->BSIM3v1Sdsub);
printf("Fatal: Dsub = %g is negative.\n", pParam->BSIM3v1Sdsub);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Sb1 == -pParam->BSIM3v1Sweff)
{ fprintf(fplog, "Fatal: (B1 + Weff) = 0 causing divided-by-zero.\n");
printf("Fatal: (B1 + Weff) = 0 causing divided-by-zero.\n");
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Su0temp <= 0.0)
{ fprintf(fplog, "Fatal: u0 at current temperature = %g is not positive.\n", pParam->BSIM3v1Su0temp);
printf("Fatal: u0 at current temperature = %g is not positive.\n",
pParam->BSIM3v1Su0temp);
Fatal_Flag = 1;
}
/* Check delta parameter */
if (pParam->BSIM3v1Sdelta < 0.0)
{ fprintf(fplog, "Fatal: Delta = %g is less than zero.\n",
pParam->BSIM3v1Sdelta);
printf("Fatal: Delta = %g is less than zero.\n", pParam->BSIM3v1Sdelta);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Svsattemp <= 0.0)
{ fprintf(fplog, "Fatal: Vsat at current temperature = %g is not positive.\n", pParam->BSIM3v1Svsattemp);
printf("Fatal: Vsat at current temperature = %g is not positive.\n",
pParam->BSIM3v1Svsattemp);
Fatal_Flag = 1;
}
/* Check Rout parameters */
if (pParam->BSIM3v1Spclm <= 0.0)
{ fprintf(fplog, "Fatal: Pclm = %g is not positive.\n", pParam->BSIM3v1Spclm);
printf("Fatal: Pclm = %g is not positive.\n", pParam->BSIM3v1Spclm);
Fatal_Flag = 1;
}
if (pParam->BSIM3v1Sdrout < 0.0)
{ fprintf(fplog, "Fatal: Drout = %g is negative.\n", pParam->BSIM3v1Sdrout);
printf("Fatal: Drout = %g is negative.\n", pParam->BSIM3v1Sdrout);
Fatal_Flag = 1;
}
if (model->BSIM3v1SunitLengthSidewallJctCap > 0.0 ||
model->BSIM3v1SunitLengthGateSidewallJctCap > 0.0)
{
if (here->BSIM3v1SdrainPerimeter < pParam->BSIM3v1Sweff)
{ fprintf(fplog, "Warning: Pd = %g is less than W.\n",
here->BSIM3v1SdrainPerimeter);
printf("Warning: Pd = %g is less than W.\n",
here->BSIM3v1SdrainPerimeter);
here->BSIM3v1SdrainPerimeter =pParam->BSIM3v1Sweff;
}
if (here->BSIM3v1SsourcePerimeter < pParam->BSIM3v1Sweff)
{ fprintf(fplog, "Warning: Ps = %g is less than W.\n",
here->BSIM3v1SsourcePerimeter);
printf("Warning: Ps = %g is less than W.\n",
here->BSIM3v1SsourcePerimeter);
here->BSIM3v1SsourcePerimeter =pParam->BSIM3v1Sweff;
}
}
/* Check capacitance parameters */
if (pParam->BSIM3v1Sclc < 0.0)
{ fprintf(fplog, "Fatal: Clc = %g is negative.\n", pParam->BSIM3v1Sclc);
printf("Fatal: Clc = %g is negative.\n", pParam->BSIM3v1Sclc);
Fatal_Flag = 1;
}
if (model->BSIM3v1SparamChk ==1)
{
/* Check L and W parameters */
if (pParam->BSIM3v1Sleff <= 5.0e-8)
{ fprintf(fplog, "Warning: Leff = %g may be too small.\n",
pParam->BSIM3v1Sleff);
printf("Warning: Leff = %g may be too small.\n",
pParam->BSIM3v1Sleff);
}
if (pParam->BSIM3v1SleffCV <= 5.0e-8)
{ fprintf(fplog, "Warning: Leff for CV = %g may be too small.\n",
pParam->BSIM3v1SleffCV);
printf("Warning: Leff for CV = %g may be too small.\n",
pParam->BSIM3v1SleffCV);
}
if (pParam->BSIM3v1Sweff <= 1.0e-7)
{ fprintf(fplog, "Warning: Weff = %g may be too small.\n",
pParam->BSIM3v1Sweff);
printf("Warning: Weff = %g may be too small.\n",
pParam->BSIM3v1Sweff);
}
if (pParam->BSIM3v1SweffCV <= 1.0e-7)
{ fprintf(fplog, "Warning: Weff for CV = %g may be too small.\n",
pParam->BSIM3v1SweffCV);
printf("Warning: Weff for CV = %g may be too small.\n",
pParam->BSIM3v1SweffCV);
}
/* Check threshold voltage parameters */
if (pParam->BSIM3v1Snlx < 0.0)
{ fprintf(fplog, "Warning: Nlx = %g is negative.\n", pParam->BSIM3v1Snlx);
printf("Warning: Nlx = %g is negative.\n", pParam->BSIM3v1Snlx);
}
if (model->BSIM3v1Stox < 1.0e-9)
{ fprintf(fplog, "Warning: Tox = %g is less than 10A.\n",
model->BSIM3v1Stox);
printf("Warning: Tox = %g is less than 10A.\n", model->BSIM3v1Stox);
}
if (pParam->BSIM3v1Snpeak <= 1.0e15)
{ fprintf(fplog, "Warning: Nch = %g may be too small.\n",
pParam->BSIM3v1Snpeak);
printf("Warning: Nch = %g may be too small.\n",
pParam->BSIM3v1Snpeak);
}
else if (pParam->BSIM3v1Snpeak >= 1.0e21)
{ fprintf(fplog, "Warning: Nch = %g may be too large.\n",
pParam->BSIM3v1Snpeak);
printf("Warning: Nch = %g may be too large.\n",
pParam->BSIM3v1Snpeak);
}
if (pParam->BSIM3v1Snsub <= 1.0e14)
{ fprintf(fplog, "Warning: Nsub = %g may be too small.\n",
pParam->BSIM3v1Snsub);
printf("Warning: Nsub = %g may be too small.\n",
pParam->BSIM3v1Snsub);
}
else if (pParam->BSIM3v1Snsub >= 1.0e21)
{ fprintf(fplog, "Warning: Nsub = %g may be too large.\n",
pParam->BSIM3v1Snsub);
printf("Warning: Nsub = %g may be too large.\n",
pParam->BSIM3v1Snsub);
}
if ((pParam->BSIM3v1Sngate > 0.0) &&
(pParam->BSIM3v1Sngate <= 1.e18))
{ fprintf(fplog, "Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->BSIM3v1Sngate);
printf("Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->BSIM3v1Sngate);
}
if (pParam->BSIM3v1Sdvt0 < 0.0)
{ fprintf(fplog, "Warning: Dvt0 = %g is negative.\n",
pParam->BSIM3v1Sdvt0);
printf("Warning: Dvt0 = %g is negative.\n", pParam->BSIM3v1Sdvt0);
}
if (fabs(1.0e-6 / (pParam->BSIM3v1Sw0 + pParam->BSIM3v1Sweff)) > 10.0)
{ fprintf(fplog, "Warning: (W0 + Weff) may be too small.\n");
printf("Warning: (W0 + Weff) may be too small.\n");
}
/* Check subthreshold parameters */
if (pParam->BSIM3v1Snfactor < 0.0)
{ fprintf(fplog, "Warning: Nfactor = %g is negative.\n",
pParam->BSIM3v1Snfactor);
printf("Warning: Nfactor = %g is negative.\n", pParam->BSIM3v1Snfactor);
}
if (pParam->BSIM3v1Scdsc < 0.0)
{ fprintf(fplog, "Warning: Cdsc = %g is negative.\n",
pParam->BSIM3v1Scdsc);
printf("Warning: Cdsc = %g is negative.\n", pParam->BSIM3v1Scdsc);
}
if (pParam->BSIM3v1Scdscd < 0.0)
{ fprintf(fplog, "Warning: Cdscd = %g is negative.\n",
pParam->BSIM3v1Scdscd);
printf("Warning: Cdscd = %g is negative.\n", pParam->BSIM3v1Scdscd);
}
/* Check DIBL parameters */
if (pParam->BSIM3v1Seta0 < 0.0)
{ fprintf(fplog, "Warning: Eta0 = %g is negative.\n",
pParam->BSIM3v1Seta0);
printf("Warning: Eta0 = %g is negative.\n", pParam->BSIM3v1Seta0);
}
/* Check Abulk parameters */
if (fabs(1.0e-6 / (pParam->BSIM3v1Sb1 + pParam->BSIM3v1Sweff)) > 10.0)
{ fprintf(fplog, "Warning: (B1 + Weff) may be too small.\n");
printf("Warning: (B1 + Weff) may be too small.\n");
}
/* Check Saturation parameters */
if (pParam->BSIM3v1Sa2 < 0.01)
{ fprintf(fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", pParam->BSIM3v1Sa2);
printf("Warning: A2 = %g is too small. Set to 0.01.\n",
pParam->BSIM3v1Sa2);
pParam->BSIM3v1Sa2 = 0.01;
}
else if (pParam->BSIM3v1Sa2 > 1.0)
{ fprintf(fplog, "Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->BSIM3v1Sa2);
printf("Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->BSIM3v1Sa2);
pParam->BSIM3v1Sa2 = 1.0;
pParam->BSIM3v1Sa1 = 0.0;
}
if (pParam->BSIM3v1Srdsw < 0.0)
{ fprintf(fplog, "Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->BSIM3v1Srdsw);
printf("Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->BSIM3v1Srdsw);
pParam->BSIM3v1Srdsw = 0.0;
pParam->BSIM3v1Srds0 = 0.0;
}
else if ((pParam->BSIM3v1Srds0 > 0.0) && (pParam->BSIM3v1Srds0 < 0.001))
{ fprintf(fplog, "Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n",
pParam->BSIM3v1Srds0);
printf("Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n",
pParam->BSIM3v1Srds0);
pParam->BSIM3v1Srds0 = 0.0;
}
if (pParam->BSIM3v1Svsattemp < 1.0e3)
{ fprintf(fplog, "Warning: Vsat at current temperature = %g may be too small.\n", pParam->BSIM3v1Svsattemp);
printf("Warning: Vsat at current temperature = %g may be too small.\n", pParam->BSIM3v1Svsattemp);
}
if (pParam->BSIM3v1Spdibl1 < 0.0)
{ fprintf(fplog, "Warning: Pdibl1 = %g is negative.\n",
pParam->BSIM3v1Spdibl1);
printf("Warning: Pdibl1 = %g is negative.\n", pParam->BSIM3v1Spdibl1);
}
if (pParam->BSIM3v1Spdibl2 < 0.0)
{ fprintf(fplog, "Warning: Pdibl2 = %g is negative.\n",
pParam->BSIM3v1Spdibl2);
printf("Warning: Pdibl2 = %g is negative.\n", pParam->BSIM3v1Spdibl2);
}
/* Check overlap capacitance parameters */
if (model->BSIM3v1Scgdo < 0.0)
{ fprintf(fplog, "Warning: cgdo = %g is negative. Set to zero.\n", model->BSIM3v1Scgdo);
printf("Warning: cgdo = %g is negative. Set to zero.\n", model->BSIM3v1Scgdo);
model->BSIM3v1Scgdo = 0.0;
}
if (model->BSIM3v1Scgso < 0.0)
{ fprintf(fplog, "Warning: cgso = %g is negative. Set to zero.\n", model->BSIM3v1Scgso);
printf("Warning: cgso = %g is negative. Set to zero.\n", model->BSIM3v1Scgso);
model->BSIM3v1Scgso = 0.0;
}
if (model->BSIM3v1Scgbo < 0.0)
{ fprintf(fplog, "Warning: cgbo = %g is negative. Set to zero.\n", model->BSIM3v1Scgbo);
printf("Warning: cgbo = %g is negative. Set to zero.\n", model->BSIM3v1Scgbo);
model->BSIM3v1Scgbo = 0.0;
}
}/* loop for the parameter check for warning messages */
fclose(fplog);
}
else
{ fprintf(stderr, "Warning: Can't open log file. Parameter checking skipped.\n");
}
return(Fatal_Flag);
}

110
src/spicelib/devices/bsim3v1s/b3v1scvtest.c
View File

@ -1,110 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1scvtest.c
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "bsim3v1sdef.h"
#include "trandefs.h"
#include "const.h"
#include "devdefs.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3v1SconvTest(GENmodel *inModel, CKTcircuit *ckt)
{
BSIM3v1Smodel *model = (BSIM3v1Smodel*)inModel;
BSIM3v1Sinstance *here;
double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds;
double cbd, cbhat, cbs, cd, cdhat, tol, vgd, vgdo, vgs;
/* loop through all the BSIM3v1S device models */
for (; model != NULL; model = model->BSIM3v1SnextModel)
{ /* loop through all the instances of the model */
for (here = model->BSIM3v1Sinstances; here != NULL ;
here=here->BSIM3v1SnextInstance)
{
if (here->BSIM3v1Sowner != ARCHme) continue;
vbs = model->BSIM3v1Stype
* (*(ckt->CKTrhsOld+here->BSIM3v1SbNode)
- *(ckt->CKTrhsOld+here->BSIM3v1SsNodePrime));
vgs = model->BSIM3v1Stype
* (*(ckt->CKTrhsOld+here->BSIM3v1SgNode)
- *(ckt->CKTrhsOld+here->BSIM3v1SsNodePrime));
vds = model->BSIM3v1Stype
* (*(ckt->CKTrhsOld+here->BSIM3v1SdNodePrime)
- *(ckt->CKTrhsOld+here->BSIM3v1SsNodePrime));
vbd = vbs - vds;
vgd = vgs - vds;
vgdo = *(ckt->CKTstate0 + here->BSIM3v1Svgs)
- *(ckt->CKTstate0 + here->BSIM3v1Svds);
delvbs = vbs - *(ckt->CKTstate0 + here->BSIM3v1Svbs);
delvbd = vbd - *(ckt->CKTstate0 + here->BSIM3v1Svbd);
delvgs = vgs - *(ckt->CKTstate0 + here->BSIM3v1Svgs);
delvds = vds - *(ckt->CKTstate0 + here->BSIM3v1Svds);
delvgd = vgd-vgdo;
cd = here->BSIM3v1Scd;
if (here->BSIM3v1Smode >= 0)
{ cdhat = cd - here->BSIM3v1Sgbd * delvbd
+ here->BSIM3v1Sgmbs * delvbs + here->BSIM3v1Sgm * delvgs
+ here->BSIM3v1Sgds * delvds;
}
else
{ cdhat = cd - (here->BSIM3v1Sgbd - here->BSIM3v1Sgmbs) * delvbd
- here->BSIM3v1Sgm * delvgd + here->BSIM3v1Sgds * delvds;
}
/*
* check convergence
*/
if ((here->BSIM3v1Soff == 0) || (!(ckt->CKTmode & MODEINITFIX)))
{ tol = ckt->CKTreltol * MAX(fabs(cdhat), fabs(cd))
+ ckt->CKTabstol;
if (fabs(cdhat - cd) >= tol) {
#ifdef STRANGE_PATCH
/* gtri - begin - wbk - report conv prob */
if(ckt->enh->conv_debug.report_conv_probs) {
ENHreport_conv_prob(ENH_ANALOG_INSTANCE,
(char *) here->BSIM3v1Sname,
"");
}
/* gtri - end - wbk - report conv prob */
#endif /* STRANGE_PATCH */
ckt->CKTnoncon++;
return(OK);
}
cbs = here->BSIM3v1Scbs;
cbd = here->BSIM3v1Scbd;
cbhat = cbs + cbd + here->BSIM3v1Sgbd * delvbd
+ here->BSIM3v1Sgbs * delvbs;
tol = ckt->CKTreltol * MAX(fabs(cbhat), fabs(cbs + cbd))
+ ckt->CKTabstol;
if (fabs(cbhat - (cbs + cbd)) > tol) {
#ifdef STRANGE_PATCH
/* gtri - begin - wbk - report conv prob */
if(ckt->enh->conv_debug.report_conv_probs) {
ENHreport_conv_prob(ENH_ANALOG_INSTANCE,
(char *) here->BSIM3v1Sname,
"");
}
/* gtri - end - wbk - report conv prob */
#endif /* STRANGE_PATCH */
ckt->CKTnoncon++;
return(OK);
}
}
}
}
return(OK);
}

39
src/spicelib/devices/bsim3v1s/b3v1sdel.c
View File

@ -1,39 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1sdel.c
**********/
/*
*/
#include "ngspice.h"
#include "bsim3v1sdef.h"
#include "sperror.h"
#include "gendefs.h"
#include "suffix.h"
int
BSIM3v1Sdelete(GENmodel *inModel, IFuid name, GENinstance **inInst)
{
BSIM3v1Sinstance **fast = (BSIM3v1Sinstance**)inInst;
BSIM3v1Smodel *model = (BSIM3v1Smodel*)inModel;
BSIM3v1Sinstance **prev = NULL;
BSIM3v1Sinstance *here;
for (; model ; model = model->BSIM3v1SnextModel)
{ prev = &(model->BSIM3v1Sinstances);
for (here = *prev; here ; here = *prev)
{ if (here->BSIM3v1Sname == name || (fast && here==*fast))
{ *prev= here->BSIM3v1SnextInstance;
FREE(here);
return(OK);
}
prev = &(here->BSIM3v1SnextInstance);
}
}
return(E_NODEV);
}

37
src/spicelib/devices/bsim3v1s/b3v1sdest.c
View File

@ -1,37 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1sdest.c
**********/
#include "ngspice.h"
#include "bsim3v1sdef.h"
#include "suffix.h"
void
BSIM3v1Sdestroy(GENmodel **inModel)
{
BSIM3v1Smodel **model = (BSIM3v1Smodel**)inModel;
BSIM3v1Sinstance *here;
BSIM3v1Sinstance *prev = NULL;
BSIM3v1Smodel *mod = *model;
BSIM3v1Smodel *oldmod = NULL;
for (; mod ; mod = mod->BSIM3v1SnextModel)
{ if(oldmod) FREE(oldmod);
oldmod = mod;
prev = (BSIM3v1Sinstance *)NULL;
for (here = mod->BSIM3v1Sinstances; here; here = here->BSIM3v1SnextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
}
if(oldmod) FREE(oldmod);
*model = NULL;
return;
}

45
src/spicelib/devices/bsim3v1s/b3v1sgetic.c
View File

@ -1,45 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1getic.c
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "bsim3v1sdef.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3v1Sgetic(GENmodel *inModel, CKTcircuit *ckt)
{
BSIM3v1Smodel *model = (BSIM3v1Smodel*)inModel;
BSIM3v1Sinstance *here;
for (; model ; model = model->BSIM3v1SnextModel)
{ for (here = model->BSIM3v1Sinstances; here; here = here->BSIM3v1SnextInstance)
{
if (here->BSIM3v1Sowner != ARCHme)
continue;
if(!here->BSIM3v1SicVBSGiven)
{ here->BSIM3v1SicVBS = *(ckt->CKTrhs + here->BSIM3v1SbNode)
- *(ckt->CKTrhs + here->BSIM3v1SsNode);
}
if (!here->BSIM3v1SicVDSGiven)
{ here->BSIM3v1SicVDS = *(ckt->CKTrhs + here->BSIM3v1SdNode)
- *(ckt->CKTrhs + here->BSIM3v1SsNode);
}
if (!here->BSIM3v1SicVGSGiven)
{ here->BSIM3v1SicVGS = *(ckt->CKTrhs + here->BSIM3v1SgNode)
- *(ckt->CKTrhs + here->BSIM3v1SsNode);
}
}
}
return(OK);
}

2447
src/spicelib/devices/bsim3v1s/b3v1sld.c
File diff suppressed because it is too large
View File

1126
src/spicelib/devices/bsim3v1s/b3v1smask.c
File diff suppressed because it is too large
View File

43
src/spicelib/devices/bsim3v1s/b3v1smdel.c
View File

@ -1,43 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1mdel.c
**********/
#include "ngspice.h"
#include "bsim3v1sdef.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3v1SmDelete(GENmodel **inModel, IFuid modname, GENmodel *kill)
{
BSIM3v1Smodel **model = (BSIM3v1Smodel**)inModel;
BSIM3v1Smodel *modfast = (BSIM3v1Smodel*)kill;
BSIM3v1Sinstance *here;
BSIM3v1Sinstance *prev = NULL;
BSIM3v1Smodel **oldmod;
oldmod = model;
for (; *model ; model = &((*model)->BSIM3v1SnextModel))
{ if ((*model)->BSIM3v1SmodName == modname ||
(modfast && *model == modfast))
goto delgot;
oldmod = model;
}
return(E_NOMOD);
delgot:
*oldmod = (*model)->BSIM3v1SnextModel; /* cut deleted device out of list */
for (here = (*model)->BSIM3v1Sinstances; here; here = here->BSIM3v1SnextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
FREE(*model);
return(OK);
}

1528
src/spicelib/devices/bsim3v1s/b3v1smpar.c
File diff suppressed because it is too large
View File

366
src/spicelib/devices/bsim3v1s/b3v1snoi.c
View File

@ -1,366 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Gary W. Ng and Min-Chie Jeng.
Modified by Paolo Nenzi 2002
File: b3v1snoi.c
**********/
#include "ngspice.h"
#include "bsim3v1sdef.h"
#include "cktdefs.h"
#include "iferrmsg.h"
#include "noisedef.h"
#include "suffix.h"
#include "const.h" /* jwan */
/*
* BSIM3v1Snoise (mode, operation, firstModel, ckt, data, OnDens)
* This routine names and evaluates all of the noise sources
* associated with MOSFET's. It starts with the model *firstModel and
* traverses all of its insts. It then proceeds to any other models
* on the linked list. The total output noise density generated by
* all of the MOSFET's is summed with the variable "OnDens".
*/
/*
Channel thermal and flicker noises are calculated based on the value
of model->BSIM3v1SnoiMod.
If model->BSIM3v1SnoiMod = 1,
Channel thermal noise = SPICE2 model
Flicker noise = SPICE2 model
If model->BSIM3v1SnoiMod = 2,
Channel thermal noise = BSIM3v1S model
Flicker noise = BSIM3v1S model
If model->BSIM3v1SnoiMod = 3,
Channel thermal noise = SPICE2 model
Flicker noise = BSIM3v1S model
If model->BSIM3v1SnoiMod = 4,
Channel thermal noise = BSIM3v1S model
Flicker noise = SPICE2 model
*/
static double
StrongInversionNoiseEval_b3v1s(double vgs, double vds, BSIM3v1Smodel *model,
BSIM3v1Sinstance *here, double freq, double temp)
{
struct bsim3v1sSizeDependParam *pParam;
double cd, esat, DelClm, EffFreq, N0, Nl, Vgst;
double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9;
double Ssi;
pParam = here->pParam;
cd = fabs(here->BSIM3v1Scd);
if (vds > here->BSIM3v1Svdsat)
{ esat = 2.0 * pParam->BSIM3v1Svsattemp / here->BSIM3v1Sueff;
T0 = ((((vds - here->BSIM3v1Svdsat) / pParam->BSIM3v1Slitl) + model->BSIM3v1Sem)
/ esat);
DelClm = pParam->BSIM3v1Slitl * log (MAX(T0, N_MINLOG));
}
else
DelClm = 0.0;
EffFreq = pow(freq, model->BSIM3v1Sef);
T1 = CHARGE * CHARGE * 8.62e-5 * cd * temp * here->BSIM3v1Sueff;
T2 = 1.0e8 * EffFreq * model->BSIM3v1Scox
* pParam->BSIM3v1Sleff * pParam->BSIM3v1Sleff;
Vgst = vgs - here->BSIM3v1Svon;
N0 = model->BSIM3v1Scox * Vgst / CHARGE;
if (N0 < 0.0)
N0 = 0.0;
Nl = model->BSIM3v1Scox * (Vgst - MIN(vds, here->BSIM3v1Svdsat)) / CHARGE;
if (Nl < 0.0)
Nl = 0.0;
T3 = model->BSIM3v1SoxideTrapDensityA
* log(MAX(((N0 + 2.0e14) / (Nl + 2.0e14)), N_MINLOG));
T4 = model->BSIM3v1SoxideTrapDensityB * (N0 - Nl);
T5 = model->BSIM3v1SoxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl);
T6 = 8.62e-5 * temp * cd * cd;
T7 = 1.0e8 * EffFreq * pParam->BSIM3v1Sleff
* pParam->BSIM3v1Sleff * pParam->BSIM3v1Sweff;
T8 = model->BSIM3v1SoxideTrapDensityA + model->BSIM3v1SoxideTrapDensityB * Nl
+ model->BSIM3v1SoxideTrapDensityC * Nl * Nl;
T9 = (Nl + 2.0e14) * (Nl + 2.0e14);
Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9;
return Ssi;
}
int
BSIM3v1Snoise (int mode, int operation, GENmodel *inModel, CKTcircuit *ckt,
Ndata *data, double *OnDens)
{
BSIM3v1Smodel *model = (BSIM3v1Smodel *)inModel;
BSIM3v1Sinstance *here;
struct bsim3v1sSizeDependParam *pParam;
char name[N_MXVLNTH];
double tempOnoise;
double tempInoise;
double noizDens[BSIM3v1SNSRCS];
double lnNdens[BSIM3v1SNSRCS];
double vgs, vds, Slimit;
double T1, T10, T11;
double Ssi, Swi;
int i;
/* define the names of the noise sources */
static char *BSIM3v1SnNames[BSIM3v1SNSRCS] =
{ /* Note that we have to keep the order */
".rd", /* noise due to rd */
/* consistent with the index definitions */
".rs", /* noise due to rs */
/* in BSIM3v1Sdefs.h */
".id", /* noise due to id */
".1overf", /* flicker (1/f) noise */
"" /* total transistor noise */
};
for (; model != NULL; model = model->BSIM3v1SnextModel)
{ for (here = model->BSIM3v1Sinstances; here != NULL;
here = here->BSIM3v1SnextInstance)
{ pParam = here->pParam;
switch (operation)
{ case N_OPEN:
/* see if we have to to produce a summary report */
/* if so, name all the noise generators */
if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0)
{ switch (mode)
{ case N_DENS:
for (i = 0; i < BSIM3v1SNSRCS; i++)
{ (void) sprintf(name, "onoise.%s%s",
here->BSIM3v1Sname,
BSIM3v1SnNames[i]);
data->namelist = TREALLOC(IFuid, data->namelist, data->numPlots + 1);
if (!data->namelist)
return(E_NOMEM);
(*(SPfrontEnd->IFnewUid)) (ckt,
&(data->namelist[data->numPlots++]),
(IFuid) NULL, name, UID_OTHER,
NULL);
/* we've added one more plot */
}
break;
case INT_NOIZ:
for (i = 0; i < BSIM3v1SNSRCS; i++)
{ (void) sprintf(name, "onoise_total.%s%s",
here->BSIM3v1Sname,
BSIM3v1SnNames[i]);
data->namelist = TREALLOC(IFuid, data->namelist, data->numPlots + 1);
if (!data->namelist)
return(E_NOMEM);
(*(SPfrontEnd->IFnewUid)) (ckt,
&(data->namelist[data->numPlots++]),
(IFuid) NULL, name, UID_OTHER,
NULL);
/* we've added one more plot */
(void) sprintf(name, "inoise_total.%s%s",
here->BSIM3v1Sname,
BSIM3v1SnNames[i]);
data->namelist = TREALLOC(IFuid, data->namelist, data->numPlots + 1);
if (!data->namelist)
return(E_NOMEM);
(*(SPfrontEnd->IFnewUid)) (ckt,
&(data->namelist[data->numPlots++]),
(IFuid) NULL, name, UID_OTHER,
NULL);
/* we've added one more plot */
}
break;
}
}
break;
case N_CALC:
switch (mode)
{ case N_DENS:
NevalSrc(&noizDens[BSIM3v1SRDNOIZ],
&lnNdens[BSIM3v1SRDNOIZ], ckt, THERMNOISE,
here->BSIM3v1SdNodePrime, here->BSIM3v1SdNode,
here->BSIM3v1SdrainConductance);
NevalSrc(&noizDens[BSIM3v1SRSNOIZ],
&lnNdens[BSIM3v1SRSNOIZ], ckt, THERMNOISE,
here->BSIM3v1SsNodePrime, here->BSIM3v1SsNode,
here->BSIM3v1SsourceConductance);
switch( model->BSIM3v1SnoiMod )
{ case 1:
case 3:
NevalSrc(&noizDens[BSIM3v1SIDNOIZ],
&lnNdens[BSIM3v1SIDNOIZ], ckt,
THERMNOISE, here->BSIM3v1SdNodePrime,
here->BSIM3v1SsNodePrime,
(2.0 / 3.0 * fabs(here->BSIM3v1Sgm
+ here->BSIM3v1Sgds
+ here->BSIM3v1Sgmbs)));
break;
case 2:
case 4:
NevalSrc(&noizDens[BSIM3v1SIDNOIZ],
&lnNdens[BSIM3v1SIDNOIZ], ckt,
THERMNOISE, here->BSIM3v1SdNodePrime,
here->BSIM3v1SsNodePrime,
(here->BSIM3v1Sueff
* fabs(here->BSIM3v1Sqinv
/ (pParam->BSIM3v1Sleff
* pParam->BSIM3v1Sleff))));
break;
}
NevalSrc(&noizDens[BSIM3v1SFLNOIZ], (double*) NULL,
ckt, N_GAIN, here->BSIM3v1SdNodePrime,
here->BSIM3v1SsNodePrime, (double) 0.0);
switch( model->BSIM3v1SnoiMod )
{ case 1:
case 4:
noizDens[BSIM3v1SFLNOIZ] *= model->BSIM3v1Skf
* exp(model->BSIM3v1Saf
* log(MAX(fabs(here->BSIM3v1Scd),
N_MINLOG)))
/ (pow(data->freq, model->BSIM3v1Sef)
* pParam->BSIM3v1Sleff
* pParam->BSIM3v1Sleff
* model->BSIM3v1Scox);
break;
case 2:
case 3:
vgs = *(ckt->CKTstates[0] + here->BSIM3v1Svgs);
vds = *(ckt->CKTstates[0] + here->BSIM3v1Svds);
if (vds < 0.0)
{ vds = -vds;
vgs = vgs + vds;
}
if (vgs >= here->BSIM3v1Svon + 0.1)
{ Ssi = StrongInversionNoiseEval_b3v1s(vgs,
vds, model, here, data->freq,
ckt->CKTtemp);
noizDens[BSIM3v1SFLNOIZ] *= Ssi;
}
else
{ pParam = here->pParam;
T10 = model->BSIM3v1SoxideTrapDensityA
* 8.62e-5 * ckt->CKTtemp;
T11 = pParam->BSIM3v1Sweff
* pParam->BSIM3v1Sleff
* pow(data->freq, model->BSIM3v1Sef)
* 4.0e36;
Swi = T10 / T11 * here->BSIM3v1Scd
* here->BSIM3v1Scd;
Slimit = StrongInversionNoiseEval_b3v1s(
here->BSIM3v1Svon + 0.1, vds, model,
here, data->freq, ckt->CKTtemp);
T1 = Swi + Slimit;
if (T1 > 0.0)
noizDens[BSIM3v1SFLNOIZ] *= (Slimit
* Swi) / T1;
else
noizDens[BSIM3v1SFLNOIZ] *= 0.0;
}
break;
}
lnNdens[BSIM3v1SFLNOIZ] =
log(MAX(noizDens[BSIM3v1SFLNOIZ], N_MINLOG));
noizDens[BSIM3v1STOTNOIZ] = noizDens[BSIM3v1SRDNOIZ]
+ noizDens[BSIM3v1SRSNOIZ]
+ noizDens[BSIM3v1SIDNOIZ]
+ noizDens[BSIM3v1SFLNOIZ];
lnNdens[BSIM3v1STOTNOIZ] =
log(MAX(noizDens[BSIM3v1STOTNOIZ], N_MINLOG));
*OnDens += noizDens[BSIM3v1STOTNOIZ];
if (data->delFreq == 0.0)
{ /* if we haven't done any previous
integration, we need to initialize our
"history" variables.
*/
for (i = 0; i < BSIM3v1SNSRCS; i++)
{ here->BSIM3v1SnVar[LNLSTDENS][i] =
lnNdens[i];
}
/* clear out our integration variables
if it's the first pass
*/
if (data->freq ==
((NOISEAN*) ckt->CKTcurJob)->NstartFreq)
{ for (i = 0; i < BSIM3v1SNSRCS; i++)
{ here->BSIM3v1SnVar[OUTNOIZ][i] = 0.0;
here->BSIM3v1SnVar[INNOIZ][i] = 0.0;
}
}
}
else
{ /* data->delFreq != 0.0,
we have to integrate.
*/
for (i = 0; i < BSIM3v1SNSRCS; i++)
{ if (i != BSIM3v1STOTNOIZ)
{ tempOnoise = Nintegrate(noizDens[i],
lnNdens[i],
here->BSIM3v1SnVar[LNLSTDENS][i],
data);
tempInoise = Nintegrate(noizDens[i]
* data->GainSqInv, lnNdens[i]
+ data->lnGainInv,
here->BSIM3v1SnVar[LNLSTDENS][i]
+ data->lnGainInv, data);
here->BSIM3v1SnVar[LNLSTDENS][i] =
lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if (((NOISEAN*)
ckt->CKTcurJob)->NStpsSm != 0)
{ here->BSIM3v1SnVar[OUTNOIZ][i]
+= tempOnoise;
here->BSIM3v1SnVar[OUTNOIZ][BSIM3v1STOTNOIZ]
+= tempOnoise;
here->BSIM3v1SnVar[INNOIZ][i]
+= tempInoise;
here->BSIM3v1SnVar[INNOIZ][BSIM3v1STOTNOIZ]
+= tempInoise;
}
}
}
}
if (data->prtSummary)
{ for (i = 0; i < BSIM3v1SNSRCS; i++)
{ /* print a summary report */
data->outpVector[data->outNumber++]
= noizDens[i];
}
}
break;
case INT_NOIZ:
/* already calculated, just output */
if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0)
{ for (i = 0; i < BSIM3v1SNSRCS; i++)
{ data->outpVector[data->outNumber++]
= here->BSIM3v1SnVar[OUTNOIZ][i];
data->outpVector[data->outNumber++]
= here->BSIM3v1SnVar[INNOIZ][i];
}
}
break;
}
break;
case N_CLOSE:
/* do nothing, the main calling routine will close */
return (OK);
break; /* the plots */
} /* switch (operation) */
} /* for here */
} /* for model */
return(OK);
}

104
src/spicelib/devices/bsim3v1s/b3v1spar.c
View File

@ -1,104 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1spar.c
**********/
#include "ngspice.h"
#include "ifsim.h"
#include "bsim3v1sdef.h"
#include "sperror.h"
#include "suffix.h"
#include "fteext.h"
int
BSIM3v1Sparam(int param, IFvalue *value, GENinstance *inst, IFvalue *select)
{
double scale;
BSIM3v1Sinstance *here = (BSIM3v1Sinstance*)inst;
NG_IGNORE(select);
if ( !cp_getvar( "scale", CP_REAL, (double*) &scale ) ) scale = 1;
switch(param)
{ case BSIM3v1S_W:
here->BSIM3v1Sw = value->rValue*scale;
here->BSIM3v1SwGiven = TRUE;
break;
case BSIM3v1S_L:
here->BSIM3v1Sl = value->rValue*scale;
here->BSIM3v1SlGiven = TRUE;
break;
case BSIM3v1S_AS:
here->BSIM3v1SsourceArea = value->rValue*scale*scale;
here->BSIM3v1SsourceAreaGiven = TRUE;
break;
case BSIM3v1S_AD:
here->BSIM3v1SdrainArea = value->rValue*scale*scale;
here->BSIM3v1SdrainAreaGiven = TRUE;
break;
case BSIM3v1S_PS:
here->BSIM3v1SsourcePerimeter = value->rValue*scale;
here->BSIM3v1SsourcePerimeterGiven = TRUE;
break;
case BSIM3v1S_PD:
here->BSIM3v1SdrainPerimeter = value->rValue*scale;
here->BSIM3v1SdrainPerimeterGiven = TRUE;
break;
case BSIM3v1S_NRS:
here->BSIM3v1SsourceSquares = value->rValue;
here->BSIM3v1SsourceSquaresGiven = TRUE;
break;
case BSIM3v1S_NRD:
here->BSIM3v1SdrainSquares = value->rValue;
here->BSIM3v1SdrainSquaresGiven = TRUE;
break;
case BSIM3v1S_OFF:
here->BSIM3v1Soff = value->iValue;
break;
case BSIM3v1S_M:
here->BSIM3v1Sm = value->rValue;
break;
case BSIM3v1S_IC_VBS:
here->BSIM3v1SicVBS = value->rValue;
here->BSIM3v1SicVBSGiven = TRUE;
break;
case BSIM3v1S_IC_VDS:
here->BSIM3v1SicVDS = value->rValue;
here->BSIM3v1SicVDSGiven = TRUE;
break;
case BSIM3v1S_IC_VGS:
here->BSIM3v1SicVGS = value->rValue;
here->BSIM3v1SicVGSGiven = TRUE;
break;
case BSIM3v1S_NQSMOD:
here->BSIM3v1SnqsMod = value->iValue;
here->BSIM3v1SnqsModGiven = TRUE;
break;
case BSIM3v1S_IC:
switch(value->v.numValue){
case 3:
here->BSIM3v1SicVBS = *(value->v.vec.rVec+2);
here->BSIM3v1SicVBSGiven = TRUE;
case 2:
here->BSIM3v1SicVGS = *(value->v.vec.rVec+1);
here->BSIM3v1SicVGSGiven = TRUE;
case 1:
here->BSIM3v1SicVDS = *(value->v.vec.rVec);
here->BSIM3v1SicVDSGiven = TRUE;
break;
default:
return(E_BADPARM);
}
break;
default:
return(E_BADPARM);
}
return(OK);
}

149
src/spicelib/devices/bsim3v1s/b3v1spzld.c
View File

@ -1,149 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1pzld.c
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "complex.h"
#include "sperror.h"
#include "bsim3v1sdef.h"
#include "suffix.h"
int
BSIM3v1SpzLoad(GENmodel *inModel, CKTcircuit *ckt, SPcomplex *s)
{
BSIM3v1Smodel *model = (BSIM3v1Smodel*)inModel;
BSIM3v1Sinstance *here;
double xcggb, xcgdb, xcgsb, xcbgb, xcbdb, xcbsb, xcddb, xcssb, xcdgb;
double gdpr, gspr, gds, gbd, gbs, capbd, capbs, xcsgb, xcdsb, xcsdb;
double cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cddb, cdgb, cdsb;
double GSoverlapCap, GDoverlapCap, GBoverlapCap;
double FwdSum, RevSum, Gm, Gmbs;
NG_IGNORE(ckt);
for (; model != NULL; model = model->BSIM3v1SnextModel)
{ for (here = model->BSIM3v1Sinstances; here!= NULL;
here = here->BSIM3v1SnextInstance)
{
if (here->BSIM3v1Sowner != ARCHme)
continue;
if (here->BSIM3v1Smode >= 0)
{ Gm = here->BSIM3v1Sgm;
Gmbs = here->BSIM3v1Sgmbs;
FwdSum = Gm + Gmbs;
RevSum = 0.0;
cggb = here->BSIM3v1Scggb;
cgsb = here->BSIM3v1Scgsb;
cgdb = here->BSIM3v1Scgdb;
cbgb = here->BSIM3v1Scbgb;
cbsb = here->BSIM3v1Scbsb;
cbdb = here->BSIM3v1Scbdb;
cdgb = here->BSIM3v1Scdgb;
cdsb = here->BSIM3v1Scdsb;
cddb = here->BSIM3v1Scddb;
}
else
{ Gm = -here->BSIM3v1Sgm;
Gmbs = -here->BSIM3v1Sgmbs;
FwdSum = 0.0;
RevSum = -Gm - Gmbs;
cggb = here->BSIM3v1Scggb;
cgsb = here->BSIM3v1Scgdb;
cgdb = here->BSIM3v1Scgsb;
cbgb = here->BSIM3v1Scbgb;
cbsb = here->BSIM3v1Scbdb;
cbdb = here->BSIM3v1Scbsb;
cdgb = -(here->BSIM3v1Scdgb + cggb + cbgb);
cdsb = -(here->BSIM3v1Scddb + cgsb + cbsb);
cddb = -(here->BSIM3v1Scdsb + cgdb + cbdb);
}
gdpr=here->BSIM3v1SdrainConductance;
gspr=here->BSIM3v1SsourceConductance;
gds= here->BSIM3v1Sgds;
gbd= here->BSIM3v1Sgbd;
gbs= here->BSIM3v1Sgbs;
capbd= here->BSIM3v1Scapbd;
capbs= here->BSIM3v1Scapbs;
GSoverlapCap = here->BSIM3v1Scgso;
GDoverlapCap = here->BSIM3v1Scgdo;
GBoverlapCap = here->pParam->BSIM3v1Scgbo;
xcdgb = (cdgb - GDoverlapCap);
xcddb = (cddb + capbd + GDoverlapCap);
xcdsb = cdsb;
xcsgb = -(cggb + cbgb + cdgb + GSoverlapCap);
xcsdb = -(cgdb + cbdb + cddb);
xcssb = (capbs + GSoverlapCap - (cgsb+cbsb+cdsb));
xcggb = (cggb + GDoverlapCap + GSoverlapCap + GBoverlapCap);
xcgdb = (cgdb - GDoverlapCap);
xcgsb = (cgsb - GSoverlapCap);
xcbgb = (cbgb - GBoverlapCap);
xcbdb = (cbdb - capbd);
xcbsb = (cbsb - capbs);
*(here->BSIM3v1SGgPtr ) += xcggb * s->real;
*(here->BSIM3v1SGgPtr +1) += xcggb * s->imag;
*(here->BSIM3v1SBbPtr ) += (-xcbgb-xcbdb-xcbsb) * s->real;
*(here->BSIM3v1SBbPtr +1) += (-xcbgb-xcbdb-xcbsb) * s->imag;
*(here->BSIM3v1SDPdpPtr ) += xcddb * s->real;
*(here->BSIM3v1SDPdpPtr +1) += xcddb * s->imag;
*(here->BSIM3v1SSPspPtr ) += xcssb * s->real;
*(here->BSIM3v1SSPspPtr +1) += xcssb * s->imag;
*(here->BSIM3v1SGbPtr ) += (-xcggb-xcgdb-xcgsb) * s->real;
*(here->BSIM3v1SGbPtr +1) += (-xcggb-xcgdb-xcgsb) * s->imag;
*(here->BSIM3v1SGdpPtr ) += xcgdb * s->real;
*(here->BSIM3v1SGdpPtr +1) += xcgdb * s->imag;
*(here->BSIM3v1SGspPtr ) += xcgsb * s->real;
*(here->BSIM3v1SGspPtr +1) += xcgsb * s->imag;
*(here->BSIM3v1SBgPtr ) += xcbgb * s->real;
*(here->BSIM3v1SBgPtr +1) += xcbgb * s->imag;
*(here->BSIM3v1SBdpPtr ) += xcbdb * s->real;
*(here->BSIM3v1SBdpPtr +1) += xcbdb * s->imag;
*(here->BSIM3v1SBspPtr ) += xcbsb * s->real;
*(here->BSIM3v1SBspPtr +1) += xcbsb * s->imag;
*(here->BSIM3v1SDPgPtr ) += xcdgb * s->real;
*(here->BSIM3v1SDPgPtr +1) += xcdgb * s->imag;
*(here->BSIM3v1SDPbPtr ) += (-xcdgb-xcddb-xcdsb) * s->real;
*(here->BSIM3v1SDPbPtr +1) += (-xcdgb-xcddb-xcdsb) * s->imag;
*(here->BSIM3v1SDPspPtr ) += xcdsb * s->real;
*(here->BSIM3v1SDPspPtr +1) += xcdsb * s->imag;
*(here->BSIM3v1SSPgPtr ) += xcsgb * s->real;
*(here->BSIM3v1SSPgPtr +1) += xcsgb * s->imag;
*(here->BSIM3v1SSPbPtr ) += (-xcsgb-xcsdb-xcssb) * s->real;
*(here->BSIM3v1SSPbPtr +1) += (-xcsgb-xcsdb-xcssb) * s->imag;
*(here->BSIM3v1SSPdpPtr ) += xcsdb * s->real;
*(here->BSIM3v1SSPdpPtr +1) += xcsdb * s->imag;
*(here->BSIM3v1SDdPtr) += gdpr;
*(here->BSIM3v1SSsPtr) += gspr;
*(here->BSIM3v1SBbPtr) += gbd+gbs;
*(here->BSIM3v1SDPdpPtr) += gdpr+gds+gbd+RevSum;
*(here->BSIM3v1SSPspPtr) += gspr+gds+gbs+FwdSum;
*(here->BSIM3v1SDdpPtr) -= gdpr;
*(here->BSIM3v1SSspPtr) -= gspr;
*(here->BSIM3v1SBdpPtr) -= gbd;
*(here->BSIM3v1SBspPtr) -= gbs;
*(here->BSIM3v1SDPdPtr) -= gdpr;
*(here->BSIM3v1SDPgPtr) += Gm;
*(here->BSIM3v1SDPbPtr) -= gbd - Gmbs;
*(here->BSIM3v1SDPspPtr) -= gds + FwdSum;
*(here->BSIM3v1SSPgPtr) -= Gm;
*(here->BSIM3v1SSPsPtr) -= gspr;
*(here->BSIM3v1SSPbPtr) -= gbs + Gmbs;
*(here->BSIM3v1SSPdpPtr) -= gds + RevSum;
}
}
return(OK);
}

981
src/spicelib/devices/bsim3v1s/b3v1sset.c
View File

@ -1,981 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1sset.c
**********/
#include "ngspice.h"
#include "smpdefs.h"
#include "cktdefs.h"
#include "bsim3v1sdef.h"
#include "const.h"
#include "sperror.h"
#include "suffix.h"
#define MAX_EXP 5.834617425e14
#define MIN_EXP 1.713908431e-15
#define EXP_THRESHOLD 34.0
#define SMOOTHFACTOR 0.1
#define EPSOX 3.453133e-11
#define EPSSI 1.03594e-10
#define PI 3.141592654
#define Charge_q 1.60219e-19
#define Meter2Micron 1.0e6
int
BSIM3v1Ssetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
int *states)
{
BSIM3v1Smodel *model = (BSIM3v1Smodel*)inModel;
BSIM3v1Sinstance *here;
int error;
CKTnode *tmp;
CKTnode *tmpNode;
IFuid tmpName;
/* loop through all the BSIM3v1S device models */
for( ; model != NULL; model = model->BSIM3v1SnextModel )
{
/* Default value Processing for BSIM3v1S MOSFET Models */
if (!model->BSIM3v1StypeGiven)
model->BSIM3v1Stype = NMOS;
if (!model->BSIM3v1SmobModGiven)
model->BSIM3v1SmobMod = 1;
if (!model->BSIM3v1SbinUnitGiven)
model->BSIM3v1SbinUnit = 1;
if (!model->BSIM3v1SparamChkGiven)
model->BSIM3v1SparamChk = 0;
if (!model->BSIM3v1ScapModGiven)
model->BSIM3v1ScapMod = 2;
if (!model->BSIM3v1SnqsModGiven)
model->BSIM3v1SnqsMod = 0;
if (!model->BSIM3v1SnoiModGiven)
model->BSIM3v1SnoiMod = 1;
if (!model->BSIM3v1SversionGiven)
model->BSIM3v1Sversion = 3.1;
if (!model->BSIM3v1StoxGiven)
model->BSIM3v1Stox = 150.0e-10;
model->BSIM3v1Scox = 3.453133e-11 / model->BSIM3v1Stox;
if (!model->BSIM3v1ScdscGiven)
model->BSIM3v1Scdsc = 2.4e-4; /* unit Q/V/m^2 */
if (!model->BSIM3v1ScdscbGiven)
model->BSIM3v1Scdscb = 0.0; /* unit Q/V/m^2 */
if (!model->BSIM3v1ScdscdGiven)
model->BSIM3v1Scdscd = 0.0; /* unit Q/V/m^2 */
if (!model->BSIM3v1ScitGiven)
model->BSIM3v1Scit = 0.0; /* unit Q/V/m^2 */
if (!model->BSIM3v1SnfactorGiven)
model->BSIM3v1Snfactor = 1;
if (!model->BSIM3v1SxjGiven)
model->BSIM3v1Sxj = .15e-6;
if (!model->BSIM3v1SvsatGiven)
model->BSIM3v1Svsat = 8.0e4; /* unit m/s */
if (!model->BSIM3v1SatGiven)
model->BSIM3v1Sat = 3.3e4; /* unit m/s */
if (!model->BSIM3v1Sa0Given)
model->BSIM3v1Sa0 = 1.0;
if (!model->BSIM3v1SagsGiven)
model->BSIM3v1Sags = 0.0;
if (!model->BSIM3v1Sa1Given)
model->BSIM3v1Sa1 = 0.0;
if (!model->BSIM3v1Sa2Given)
model->BSIM3v1Sa2 = 1.0;
if (!model->BSIM3v1SketaGiven)
model->BSIM3v1Sketa = -0.047; /* unit / V */
if (!model->BSIM3v1SnsubGiven)
model->BSIM3v1Snsub = 6.0e16; /* unit 1/cm3 */
if (!model->BSIM3v1SnpeakGiven)
model->BSIM3v1Snpeak = 1.7e17; /* unit 1/cm3 */
if (!model->BSIM3v1SngateGiven)
model->BSIM3v1Sngate = 0; /* unit 1/cm3 */
if (!model->BSIM3v1SvbmGiven)
model->BSIM3v1Svbm = -3.0;
if (!model->BSIM3v1SxtGiven)
model->BSIM3v1Sxt = 1.55e-7;
if (!model->BSIM3v1Skt1Given)
model->BSIM3v1Skt1 = -0.11; /* unit V */
if (!model->BSIM3v1Skt1lGiven)
model->BSIM3v1Skt1l = 0.0; /* unit V*m */
if (!model->BSIM3v1Skt2Given)
model->BSIM3v1Skt2 = 0.022; /* No unit */
if (!model->BSIM3v1Sk3Given)
model->BSIM3v1Sk3 = 80.0;
if (!model->BSIM3v1Sk3bGiven)
model->BSIM3v1Sk3b = 0.0;
if (!model->BSIM3v1Sw0Given)
model->BSIM3v1Sw0 = 2.5e-6;
if (!model->BSIM3v1SnlxGiven)
model->BSIM3v1Snlx = 1.74e-7;
if (!model->BSIM3v1Sdvt0Given)
model->BSIM3v1Sdvt0 = 2.2;
if (!model->BSIM3v1Sdvt1Given)
model->BSIM3v1Sdvt1 = 0.53;
if (!model->BSIM3v1Sdvt2Given)
model->BSIM3v1Sdvt2 = -0.032; /* unit 1 / V */
if (!model->BSIM3v1Sdvt0wGiven)
model->BSIM3v1Sdvt0w = 0.0;
if (!model->BSIM3v1Sdvt1wGiven)
model->BSIM3v1Sdvt1w = 5.3e6;
if (!model->BSIM3v1Sdvt2wGiven)
model->BSIM3v1Sdvt2w = -0.032;
if (!model->BSIM3v1SdroutGiven)
model->BSIM3v1Sdrout = 0.56;
if (!model->BSIM3v1SdsubGiven)
model->BSIM3v1Sdsub = model->BSIM3v1Sdrout;
if (!model->BSIM3v1Svth0Given)
model->BSIM3v1Svth0 = (model->BSIM3v1Stype == NMOS) ? 0.7 : -0.7;
if (!model->BSIM3v1SuaGiven)
model->BSIM3v1Sua = 2.25e-9; /* unit m/V */
if (!model->BSIM3v1Sua1Given)
model->BSIM3v1Sua1 = 4.31e-9; /* unit m/V */
if (!model->BSIM3v1SubGiven)
model->BSIM3v1Sub = 5.87e-19; /* unit (m/V)**2 */
if (!model->BSIM3v1Sub1Given)
model->BSIM3v1Sub1 = -7.61e-18; /* unit (m/V)**2 */
if (!model->BSIM3v1SucGiven)
model->BSIM3v1Suc = (model->BSIM3v1SmobMod == 3) ? -0.0465 : -0.0465e-9;
if (!model->BSIM3v1Suc1Given)
model->BSIM3v1Suc1 = (model->BSIM3v1SmobMod == 3) ? -0.056 : -0.056e-9;
if (!model->BSIM3v1Su0Given)
model->BSIM3v1Su0 = (model->BSIM3v1Stype == NMOS) ? 0.067 : 0.025;
if (!model->BSIM3v1SuteGiven)
model->BSIM3v1Sute = -1.5;
if (!model->BSIM3v1SvoffGiven)
model->BSIM3v1Svoff = -0.08;
if (!model->BSIM3v1SdeltaGiven)
model->BSIM3v1Sdelta = 0.01;
if (!model->BSIM3v1SrdswGiven)
model->BSIM3v1Srdsw = 0;
if (!model->BSIM3v1SprwgGiven)
model->BSIM3v1Sprwg = 0.0; /* unit 1/V */
if (!model->BSIM3v1SprwbGiven)
model->BSIM3v1Sprwb = 0.0;
if (!model->BSIM3v1SprtGiven)
if (!model->BSIM3v1SprtGiven)
model->BSIM3v1Sprt = 0.0;
if (!model->BSIM3v1Seta0Given)
model->BSIM3v1Seta0 = 0.08; /* no unit */
if (!model->BSIM3v1SetabGiven)
model->BSIM3v1Setab = -0.07; /* unit 1/V */
if (!model->BSIM3v1SpclmGiven)
model->BSIM3v1Spclm = 1.3; /* no unit */
if (!model->BSIM3v1Spdibl1Given)
model->BSIM3v1Spdibl1 = .39; /* no unit */
if (!model->BSIM3v1Spdibl2Given)
model->BSIM3v1Spdibl2 = 0.0086; /* no unit */
if (!model->BSIM3v1SpdiblbGiven)
model->BSIM3v1Spdiblb = 0.0; /* 1/V */
if (!model->BSIM3v1Spscbe1Given)
model->BSIM3v1Spscbe1 = 4.24e8;
if (!model->BSIM3v1Spscbe2Given)
model->BSIM3v1Spscbe2 = 1.0e-5;
if (!model->BSIM3v1SpvagGiven)
model->BSIM3v1Spvag = 0.0;
if (!model->BSIM3v1SwrGiven)
model->BSIM3v1Swr = 1.0;
if (!model->BSIM3v1SdwgGiven)
model->BSIM3v1Sdwg = 0.0;
if (!model->BSIM3v1SdwbGiven)
model->BSIM3v1Sdwb = 0.0;
if (!model->BSIM3v1Sb0Given)
model->BSIM3v1Sb0 = 0.0;
if (!model->BSIM3v1Sb1Given)
model->BSIM3v1Sb1 = 0.0;
if (!model->BSIM3v1Salpha0Given)
model->BSIM3v1Salpha0 = 0.0;
if (!model->BSIM3v1Sbeta0Given)
model->BSIM3v1Sbeta0 = 30.0;
if (!model->BSIM3v1SelmGiven)
model->BSIM3v1Selm = 5.0;
if (!model->BSIM3v1ScgslGiven)
model->BSIM3v1Scgsl = 0.0;
if (!model->BSIM3v1ScgdlGiven)
model->BSIM3v1Scgdl = 0.0;
if (!model->BSIM3v1SckappaGiven)
model->BSIM3v1Sckappa = 0.6;
if (!model->BSIM3v1SclcGiven)
model->BSIM3v1Sclc = 0.1e-6;
if (!model->BSIM3v1ScleGiven)
model->BSIM3v1Scle = 0.6;
if (!model->BSIM3v1SvfbcvGiven)
model->BSIM3v1Svfbcv = -1.0;
/* Length dependence */
if (!model->BSIM3v1SlcdscGiven)
model->BSIM3v1Slcdsc = 0.0;
if (!model->BSIM3v1SlcdscbGiven)
model->BSIM3v1Slcdscb = 0.0;
if (!model->BSIM3v1SlcdscdGiven)
model->BSIM3v1Slcdscd = 0.0;
if (!model->BSIM3v1SlcitGiven)
model->BSIM3v1Slcit = 0.0;
if (!model->BSIM3v1SlnfactorGiven)
model->BSIM3v1Slnfactor = 0.0;
if (!model->BSIM3v1SlxjGiven)
model->BSIM3v1Slxj = 0.0;
if (!model->BSIM3v1SlvsatGiven)
model->BSIM3v1Slvsat = 0.0;
if (!model->BSIM3v1SlatGiven)
model->BSIM3v1Slat = 0.0;
if (!model->BSIM3v1Sla0Given)
model->BSIM3v1Sla0 = 0.0;
if (!model->BSIM3v1SlagsGiven)
model->BSIM3v1Slags = 0.0;
if (!model->BSIM3v1Sla1Given)
model->BSIM3v1Sla1 = 0.0;
if (!model->BSIM3v1Sla2Given)
model->BSIM3v1Sla2 = 0.0;
if (!model->BSIM3v1SlketaGiven)
model->BSIM3v1Slketa = 0.0;
if (!model->BSIM3v1SlnsubGiven)
model->BSIM3v1Slnsub = 0.0;
if (!model->BSIM3v1SlnpeakGiven)
model->BSIM3v1Slnpeak = 0.0;
if (!model->BSIM3v1SlngateGiven)
model->BSIM3v1Slngate = 0.0;
if (!model->BSIM3v1SlvbmGiven)
model->BSIM3v1Slvbm = 0.0;
if (!model->BSIM3v1SlxtGiven)
model->BSIM3v1Slxt = 0.0;
if (!model->BSIM3v1Slkt1Given)
model->BSIM3v1Slkt1 = 0.0;
if (!model->BSIM3v1Slkt1lGiven)
model->BSIM3v1Slkt1l = 0.0;
if (!model->BSIM3v1Slkt2Given)
model->BSIM3v1Slkt2 = 0.0;
if (!model->BSIM3v1Slk3Given)
model->BSIM3v1Slk3 = 0.0;
if (!model->BSIM3v1Slk3bGiven)
model->BSIM3v1Slk3b = 0.0;
if (!model->BSIM3v1Slw0Given)
model->BSIM3v1Slw0 = 0.0;
if (!model->BSIM3v1SlnlxGiven)
model->BSIM3v1Slnlx = 0.0;
if (!model->BSIM3v1Sldvt0Given)
model->BSIM3v1Sldvt0 = 0.0;
if (!model->BSIM3v1Sldvt1Given)
model->BSIM3v1Sldvt1 = 0.0;
if (!model->BSIM3v1Sldvt2Given)
model->BSIM3v1Sldvt2 = 0.0;
if (!model->BSIM3v1Sldvt0wGiven)
model->BSIM3v1Sldvt0w = 0.0;
if (!model->BSIM3v1Sldvt1wGiven)
model->BSIM3v1Sldvt1w = 0.0;
if (!model->BSIM3v1Sldvt2wGiven)
model->BSIM3v1Sldvt2w = 0.0;
if (!model->BSIM3v1SldroutGiven)
model->BSIM3v1Sldrout = 0.0;
if (!model->BSIM3v1SldsubGiven)
model->BSIM3v1Sldsub = 0.0;
if (!model->BSIM3v1Slvth0Given)
model->BSIM3v1Slvth0 = 0.0;
if (!model->BSIM3v1SluaGiven)
model->BSIM3v1Slua = 0.0;
if (!model->BSIM3v1Slua1Given)
model->BSIM3v1Slua1 = 0.0;
if (!model->BSIM3v1SlubGiven)
model->BSIM3v1Slub = 0.0;
if (!model->BSIM3v1Slub1Given)
model->BSIM3v1Slub1 = 0.0;
if (!model->BSIM3v1SlucGiven)
model->BSIM3v1Sluc = 0.0;
if (!model->BSIM3v1Sluc1Given)
model->BSIM3v1Sluc1 = 0.0;
if (!model->BSIM3v1Slu0Given)
model->BSIM3v1Slu0 = 0.0;
if (!model->BSIM3v1SluteGiven)
model->BSIM3v1Slute = 0.0;
if (!model->BSIM3v1SlvoffGiven)
model->BSIM3v1Slvoff = 0.0;
if (!model->BSIM3v1SldeltaGiven)
model->BSIM3v1Sldelta = 0.0;
if (!model->BSIM3v1SlrdswGiven)
model->BSIM3v1Slrdsw = 0.0;
if (!model->BSIM3v1SlprwbGiven)
model->BSIM3v1Slprwb = 0.0;
if (!model->BSIM3v1SlprwgGiven)
model->BSIM3v1Slprwg = 0.0;
if (!model->BSIM3v1SlprtGiven)
if (!model->BSIM3v1SlprtGiven)
model->BSIM3v1Slprt = 0.0;
if (!model->BSIM3v1Sleta0Given)
model->BSIM3v1Sleta0 = 0.0;
if (!model->BSIM3v1SletabGiven)
model->BSIM3v1Sletab = -0.0;
if (!model->BSIM3v1SlpclmGiven)
model->BSIM3v1Slpclm = 0.0;
if (!model->BSIM3v1Slpdibl1Given)
model->BSIM3v1Slpdibl1 = 0.0;
if (!model->BSIM3v1Slpdibl2Given)
model->BSIM3v1Slpdibl2 = 0.0;
if (!model->BSIM3v1SlpdiblbGiven)
model->BSIM3v1Slpdiblb = 0.0;
if (!model->BSIM3v1Slpscbe1Given)
model->BSIM3v1Slpscbe1 = 0.0;
if (!model->BSIM3v1Slpscbe2Given)
model->BSIM3v1Slpscbe2 = 0.0;
if (!model->BSIM3v1SlpvagGiven)
model->BSIM3v1Slpvag = 0.0;
if (!model->BSIM3v1SlwrGiven)
model->BSIM3v1Slwr = 0.0;
if (!model->BSIM3v1SldwgGiven)
model->BSIM3v1Sldwg = 0.0;
if (!model->BSIM3v1SldwbGiven)
model->BSIM3v1Sldwb = 0.0;
if (!model->BSIM3v1Slb0Given)
model->BSIM3v1Slb0 = 0.0;
if (!model->BSIM3v1Slb1Given)
model->BSIM3v1Slb1 = 0.0;
if (!model->BSIM3v1Slalpha0Given)
model->BSIM3v1Slalpha0 = 0.0;
if (!model->BSIM3v1Slbeta0Given)
model->BSIM3v1Slbeta0 = 0.0;
if (!model->BSIM3v1SlelmGiven)
model->BSIM3v1Slelm = 0.0;
if (!model->BSIM3v1SlcgslGiven)
model->BSIM3v1Slcgsl = 0.0;
if (!model->BSIM3v1SlcgdlGiven)
model->BSIM3v1Slcgdl = 0.0;
if (!model->BSIM3v1SlckappaGiven)
model->BSIM3v1Slckappa = 0.0;
if (!model->BSIM3v1SlclcGiven)
model->BSIM3v1Slclc = 0.0;
if (!model->BSIM3v1SlcleGiven)
model->BSIM3v1Slcle = 0.0;
if (!model->BSIM3v1SlcfGiven)
model->BSIM3v1Slcf = 0.0;
if (!model->BSIM3v1SlvfbcvGiven)
model->BSIM3v1Slvfbcv = 0.0;
/* Width dependence */
if (!model->BSIM3v1SwcdscGiven)
model->BSIM3v1Swcdsc = 0.0;
if (!model->BSIM3v1SwcdscbGiven)
model->BSIM3v1Swcdscb = 0.0;
if (!model->BSIM3v1SwcdscdGiven)
model->BSIM3v1Swcdscd = 0.0;
if (!model->BSIM3v1SwcitGiven)
model->BSIM3v1Swcit = 0.0;
if (!model->BSIM3v1SwnfactorGiven)
model->BSIM3v1Swnfactor = 0.0;
if (!model->BSIM3v1SwxjGiven)
model->BSIM3v1Swxj = 0.0;
if (!model->BSIM3v1SwvsatGiven)
model->BSIM3v1Swvsat = 0.0;
if (!model->BSIM3v1SwatGiven)
model->BSIM3v1Swat = 0.0;
if (!model->BSIM3v1Swa0Given)
model->BSIM3v1Swa0 = 0.0;
if (!model->BSIM3v1SwagsGiven)
model->BSIM3v1Swags = 0.0;
if (!model->BSIM3v1Swa1Given)
model->BSIM3v1Swa1 = 0.0;
if (!model->BSIM3v1Swa2Given)
model->BSIM3v1Swa2 = 0.0;
if (!model->BSIM3v1SwketaGiven)
model->BSIM3v1Swketa = 0.0;
if (!model->BSIM3v1SwnsubGiven)
model->BSIM3v1Swnsub = 0.0;
if (!model->BSIM3v1SwnpeakGiven)
model->BSIM3v1Swnpeak = 0.0;
if (!model->BSIM3v1SwngateGiven)
model->BSIM3v1Swngate = 0.0;
if (!model->BSIM3v1SwvbmGiven)
model->BSIM3v1Swvbm = 0.0;
if (!model->BSIM3v1SwxtGiven)
model->BSIM3v1Swxt = 0.0;
if (!model->BSIM3v1Swkt1Given)
model->BSIM3v1Swkt1 = 0.0;
if (!model->BSIM3v1Swkt1lGiven)
model->BSIM3v1Swkt1l = 0.0;
if (!model->BSIM3v1Swkt2Given)
model->BSIM3v1Swkt2 = 0.0;
if (!model->BSIM3v1Swk3Given)
model->BSIM3v1Swk3 = 0.0;
if (!model->BSIM3v1Swk3bGiven)
model->BSIM3v1Swk3b = 0.0;
if (!model->BSIM3v1Sww0Given)
model->BSIM3v1Sww0 = 0.0;
if (!model->BSIM3v1SwnlxGiven)
model->BSIM3v1Swnlx = 0.0;
if (!model->BSIM3v1Swdvt0Given)
model->BSIM3v1Swdvt0 = 0.0;
if (!model->BSIM3v1Swdvt1Given)
model->BSIM3v1Swdvt1 = 0.0;
if (!model->BSIM3v1Swdvt2Given)
model->BSIM3v1Swdvt2 = 0.0;
if (!model->BSIM3v1Swdvt0wGiven)
model->BSIM3v1Swdvt0w = 0.0;
if (!model->BSIM3v1Swdvt1wGiven)
model->BSIM3v1Swdvt1w = 0.0;
if (!model->BSIM3v1Swdvt2wGiven)
model->BSIM3v1Swdvt2w = 0.0;
if (!model->BSIM3v1SwdroutGiven)
model->BSIM3v1Swdrout = 0.0;
if (!model->BSIM3v1SwdsubGiven)
model->BSIM3v1Swdsub = 0.0;
if (!model->BSIM3v1Swvth0Given)
model->BSIM3v1Swvth0 = 0.0;
if (!model->BSIM3v1SwuaGiven)
model->BSIM3v1Swua = 0.0;
if (!model->BSIM3v1Swua1Given)
model->BSIM3v1Swua1 = 0.0;
if (!model->BSIM3v1SwubGiven)
model->BSIM3v1Swub = 0.0;
if (!model->BSIM3v1Swub1Given)
model->BSIM3v1Swub1 = 0.0;
if (!model->BSIM3v1SwucGiven)
model->BSIM3v1Swuc = 0.0;
if (!model->BSIM3v1Swuc1Given)
model->BSIM3v1Swuc1 = 0.0;
if (!model->BSIM3v1Swu0Given)
model->BSIM3v1Swu0 = 0.0;
if (!model->BSIM3v1SwuteGiven)
model->BSIM3v1Swute = 0.0;
if (!model->BSIM3v1SwvoffGiven)
model->BSIM3v1Swvoff = 0.0;
if (!model->BSIM3v1SwdeltaGiven)
model->BSIM3v1Swdelta = 0.0;
if (!model->BSIM3v1SwrdswGiven)
model->BSIM3v1Swrdsw = 0.0;
if (!model->BSIM3v1SwprwbGiven)
model->BSIM3v1Swprwb = 0.0;
if (!model->BSIM3v1SwprwgGiven)
model->BSIM3v1Swprwg = 0.0;
if (!model->BSIM3v1SwprtGiven)
model->BSIM3v1Swprt = 0.0;
if (!model->BSIM3v1Sweta0Given)
model->BSIM3v1Sweta0 = 0.0;
if (!model->BSIM3v1SwetabGiven)
model->BSIM3v1Swetab = 0.0;
if (!model->BSIM3v1SwpclmGiven)
model->BSIM3v1Swpclm = 0.0;
if (!model->BSIM3v1Swpdibl1Given)
model->BSIM3v1Swpdibl1 = 0.0;
if (!model->BSIM3v1Swpdibl2Given)
model->BSIM3v1Swpdibl2 = 0.0;
if (!model->BSIM3v1SwpdiblbGiven)
model->BSIM3v1Swpdiblb = 0.0;
if (!model->BSIM3v1Swpscbe1Given)
model->BSIM3v1Swpscbe1 = 0.0;
if (!model->BSIM3v1Swpscbe2Given)
model->BSIM3v1Swpscbe2 = 0.0;
if (!model->BSIM3v1SwpvagGiven)
model->BSIM3v1Swpvag = 0.0;
if (!model->BSIM3v1SwwrGiven)
model->BSIM3v1Swwr = 0.0;
if (!model->BSIM3v1SwdwgGiven)
model->BSIM3v1Swdwg = 0.0;
if (!model->BSIM3v1SwdwbGiven)
model->BSIM3v1Swdwb = 0.0;
if (!model->BSIM3v1Swb0Given)
model->BSIM3v1Swb0 = 0.0;
if (!model->BSIM3v1Swb1Given)
model->BSIM3v1Swb1 = 0.0;
if (!model->BSIM3v1Swalpha0Given)
model->BSIM3v1Swalpha0 = 0.0;
if (!model->BSIM3v1Swbeta0Given)
model->BSIM3v1Swbeta0 = 0.0;
if (!model->BSIM3v1SwelmGiven)
model->BSIM3v1Swelm = 0.0;
if (!model->BSIM3v1SwcgslGiven)
model->BSIM3v1Swcgsl = 0.0;
if (!model->BSIM3v1SwcgdlGiven)
model->BSIM3v1Swcgdl = 0.0;
if (!model->BSIM3v1SwckappaGiven)
model->BSIM3v1Swckappa = 0.0;
if (!model->BSIM3v1SwcfGiven)
model->BSIM3v1Swcf = 0.0;
if (!model->BSIM3v1SwclcGiven)
model->BSIM3v1Swclc = 0.0;
if (!model->BSIM3v1SwcleGiven)
model->BSIM3v1Swcle = 0.0;
if (!model->BSIM3v1SwvfbcvGiven)
model->BSIM3v1Swvfbcv = 0.0;
/* Cross-term dependence */
if (!model->BSIM3v1SpcdscGiven)
model->BSIM3v1Spcdsc = 0.0;
if (!model->BSIM3v1SpcdscbGiven)
model->BSIM3v1Spcdscb = 0.0;
if (!model->BSIM3v1SpcdscdGiven)
model->BSIM3v1Spcdscd = 0.0;
if (!model->BSIM3v1SpcitGiven)
model->BSIM3v1Spcit = 0.0;
if (!model->BSIM3v1SpnfactorGiven)
model->BSIM3v1Spnfactor = 0.0;
if (!model->BSIM3v1SpxjGiven)
model->BSIM3v1Spxj = 0.0;
if (!model->BSIM3v1SpvsatGiven)
model->BSIM3v1Spvsat = 0.0;
if (!model->BSIM3v1SpatGiven)
model->BSIM3v1Spat = 0.0;
if (!model->BSIM3v1Spa0Given)
model->BSIM3v1Spa0 = 0.0;
if (!model->BSIM3v1SpagsGiven)
model->BSIM3v1Spags = 0.0;
if (!model->BSIM3v1Spa1Given)
model->BSIM3v1Spa1 = 0.0;
if (!model->BSIM3v1Spa2Given)
model->BSIM3v1Spa2 = 0.0;
if (!model->BSIM3v1SpketaGiven)
model->BSIM3v1Spketa = 0.0;
if (!model->BSIM3v1SpnsubGiven)
model->BSIM3v1Spnsub = 0.0;
if (!model->BSIM3v1SpnpeakGiven)
model->BSIM3v1Spnpeak = 0.0;
if (!model->BSIM3v1SpngateGiven)
model->BSIM3v1Spngate = 0.0;
if (!model->BSIM3v1SpvbmGiven)
model->BSIM3v1Spvbm = 0.0;
if (!model->BSIM3v1SpxtGiven)
model->BSIM3v1Spxt = 0.0;
if (!model->BSIM3v1Spkt1Given)
model->BSIM3v1Spkt1 = 0.0;
if (!model->BSIM3v1Spkt1lGiven)
model->BSIM3v1Spkt1l = 0.0;
if (!model->BSIM3v1Spkt2Given)
model->BSIM3v1Spkt2 = 0.0;
if (!model->BSIM3v1Spk3Given)
model->BSIM3v1Spk3 = 0.0;
if (!model->BSIM3v1Spk3bGiven)
model->BSIM3v1Spk3b = 0.0;
if (!model->BSIM3v1Spw0Given)
model->BSIM3v1Spw0 = 0.0;
if (!model->BSIM3v1SpnlxGiven)
model->BSIM3v1Spnlx = 0.0;
if (!model->BSIM3v1Spdvt0Given)
model->BSIM3v1Spdvt0 = 0.0;
if (!model->BSIM3v1Spdvt1Given)
model->BSIM3v1Spdvt1 = 0.0;
if (!model->BSIM3v1Spdvt2Given)
model->BSIM3v1Spdvt2 = 0.0;
if (!model->BSIM3v1Spdvt0wGiven)
model->BSIM3v1Spdvt0w = 0.0;
if (!model->BSIM3v1Spdvt1wGiven)
model->BSIM3v1Spdvt1w = 0.0;
if (!model->BSIM3v1Spdvt2wGiven)
model->BSIM3v1Spdvt2w = 0.0;
if (!model->BSIM3v1SpdroutGiven)
model->BSIM3v1Spdrout = 0.0;
if (!model->BSIM3v1SpdsubGiven)
model->BSIM3v1Spdsub = 0.0;
if (!model->BSIM3v1Spvth0Given)
model->BSIM3v1Spvth0 = 0.0;
if (!model->BSIM3v1SpuaGiven)
model->BSIM3v1Spua = 0.0;
if (!model->BSIM3v1Spua1Given)
model->BSIM3v1Spua1 = 0.0;
if (!model->BSIM3v1SpubGiven)
model->BSIM3v1Spub = 0.0;
if (!model->BSIM3v1Spub1Given)
model->BSIM3v1Spub1 = 0.0;
if (!model->BSIM3v1SpucGiven)
model->BSIM3v1Spuc = 0.0;
if (!model->BSIM3v1Spuc1Given)
model->BSIM3v1Spuc1 = 0.0;
if (!model->BSIM3v1Spu0Given)
model->BSIM3v1Spu0 = 0.0;
if (!model->BSIM3v1SputeGiven)
model->BSIM3v1Spute = 0.0;
if (!model->BSIM3v1SpvoffGiven)
model->BSIM3v1Spvoff = 0.0;
if (!model->BSIM3v1SpdeltaGiven)
model->BSIM3v1Spdelta = 0.0;
if (!model->BSIM3v1SprdswGiven)
model->BSIM3v1Sprdsw = 0.0;
if (!model->BSIM3v1SpprwbGiven)
model->BSIM3v1Spprwb = 0.0;
if (!model->BSIM3v1SpprwgGiven)
model->BSIM3v1Spprwg = 0.0;
if (!model->BSIM3v1SpprtGiven)
model->BSIM3v1Spprt = 0.0;
if (!model->BSIM3v1Speta0Given)
model->BSIM3v1Speta0 = 0.0;
if (!model->BSIM3v1SpetabGiven)
model->BSIM3v1Spetab = 0.0;
if (!model->BSIM3v1SppclmGiven)
model->BSIM3v1Sppclm = 0.0;
if (!model->BSIM3v1Sppdibl1Given)
model->BSIM3v1Sppdibl1 = 0.0;
if (!model->BSIM3v1Sppdibl2Given)
model->BSIM3v1Sppdibl2 = 0.0;
if (!model->BSIM3v1SppdiblbGiven)
model->BSIM3v1Sppdiblb = 0.0;
if (!model->BSIM3v1Sppscbe1Given)
model->BSIM3v1Sppscbe1 = 0.0;
if (!model->BSIM3v1Sppscbe2Given)
model->BSIM3v1Sppscbe2 = 0.0;
if (!model->BSIM3v1SppvagGiven)
model->BSIM3v1Sppvag = 0.0;
if (!model->BSIM3v1SpwrGiven)
model->BSIM3v1Spwr = 0.0;
if (!model->BSIM3v1SpdwgGiven)
model->BSIM3v1Spdwg = 0.0;
if (!model->BSIM3v1SpdwbGiven)
model->BSIM3v1Spdwb = 0.0;
if (!model->BSIM3v1Spb0Given)
model->BSIM3v1Spb0 = 0.0;
if (!model->BSIM3v1Spb1Given)
model->BSIM3v1Spb1 = 0.0;
if (!model->BSIM3v1Spalpha0Given)
model->BSIM3v1Spalpha0 = 0.0;
if (!model->BSIM3v1Spbeta0Given)
model->BSIM3v1Spbeta0 = 0.0;
if (!model->BSIM3v1SpelmGiven)
model->BSIM3v1Spelm = 0.0;
if (!model->BSIM3v1SpcgslGiven)
model->BSIM3v1Spcgsl = 0.0;
if (!model->BSIM3v1SpcgdlGiven)
model->BSIM3v1Spcgdl = 0.0;
if (!model->BSIM3v1SpckappaGiven)
model->BSIM3v1Spckappa = 0.0;
if (!model->BSIM3v1SpcfGiven)
model->BSIM3v1Spcf = 0.0;
if (!model->BSIM3v1SpclcGiven)
model->BSIM3v1Spclc = 0.0;
if (!model->BSIM3v1SpcleGiven)
model->BSIM3v1Spcle = 0.0;
if (!model->BSIM3v1SpvfbcvGiven)
model->BSIM3v1Spvfbcv = 0.0;
/* unit degree celcius */
if (!model->BSIM3v1StnomGiven)
model->BSIM3v1Stnom = ckt->CKTnomTemp;
if (!model->BSIM3v1SLintGiven)
model->BSIM3v1SLint = 0.0;
if (!model->BSIM3v1SLlGiven)
model->BSIM3v1SLl = 0.0;
if (!model->BSIM3v1SLlnGiven)
model->BSIM3v1SLln = 1.0;
if (!model->BSIM3v1SLwGiven)
model->BSIM3v1SLw = 0.0;
if (!model->BSIM3v1SLwnGiven)
model->BSIM3v1SLwn = 1.0;
if (!model->BSIM3v1SLwlGiven)
model->BSIM3v1SLwl = 0.0;
if (!model->BSIM3v1SLminGiven)
model->BSIM3v1SLmin = 0.0;
if (!model->BSIM3v1SLmaxGiven)
model->BSIM3v1SLmax = 1.0;
if (!model->BSIM3v1SWintGiven)
model->BSIM3v1SWint = 0.0;
if (!model->BSIM3v1SWlGiven)
model->BSIM3v1SWl = 0.0;
if (!model->BSIM3v1SWlnGiven)
model->BSIM3v1SWln = 1.0;
if (!model->BSIM3v1SWwGiven)
model->BSIM3v1SWw = 0.0;
if (!model->BSIM3v1SWwnGiven)
model->BSIM3v1SWwn = 1.0;
if (!model->BSIM3v1SWwlGiven)
model->BSIM3v1SWwl = 0.0;
if (!model->BSIM3v1SWminGiven)
model->BSIM3v1SWmin = 0.0;
if (!model->BSIM3v1SWmaxGiven)
model->BSIM3v1SWmax = 1.0;
if (!model->BSIM3v1SdwcGiven)
model->BSIM3v1Sdwc = model->BSIM3v1SWint;
if (!model->BSIM3v1SdlcGiven)
model->BSIM3v1Sdlc = model->BSIM3v1SLint;
if (!model->BSIM3v1ScfGiven)
model->BSIM3v1Scf = 2.0 * EPSOX / PI
* log(1.0 + 0.4e-6 / model->BSIM3v1Stox);
if (!model->BSIM3v1ScgdoGiven)
{ if (model->BSIM3v1SdlcGiven && (model->BSIM3v1Sdlc > 0.0))
{ model->BSIM3v1Scgdo = model->BSIM3v1Sdlc * model->BSIM3v1Scox
- model->BSIM3v1Scgdl ;
}
else
model->BSIM3v1Scgdo = 0.6 * model->BSIM3v1Sxj * model->BSIM3v1Scox;
}
if (!model->BSIM3v1ScgsoGiven)
{ if (model->BSIM3v1SdlcGiven && (model->BSIM3v1Sdlc > 0.0))
{ model->BSIM3v1Scgso = model->BSIM3v1Sdlc * model->BSIM3v1Scox
- model->BSIM3v1Scgsl ;
}
else
model->BSIM3v1Scgso = 0.6 * model->BSIM3v1Sxj * model->BSIM3v1Scox;
}
if (!model->BSIM3v1ScgboGiven)
{ model->BSIM3v1Scgbo = 2.0 * model->BSIM3v1Sdwc * model->BSIM3v1Scox;
}
if (!model->BSIM3v1SxpartGiven)
model->BSIM3v1Sxpart = 0.0;
if (!model->BSIM3v1SsheetResistanceGiven)
model->BSIM3v1SsheetResistance = 0.0;
if (!model->BSIM3v1SunitAreaJctCapGiven)
model->BSIM3v1SunitAreaJctCap = 5.0E-4;
if (!model->BSIM3v1SunitLengthSidewallJctCapGiven)
model->BSIM3v1SunitLengthSidewallJctCap = 5.0E-10;
if (!model->BSIM3v1SunitLengthGateSidewallJctCapGiven)
model->BSIM3v1SunitLengthGateSidewallJctCap = model->BSIM3v1SunitLengthSidewallJctCap ;
if (!model->BSIM3v1SjctSatCurDensityGiven)
model->BSIM3v1SjctSatCurDensity = 1.0E-4;
if (!model->BSIM3v1SjctSidewallSatCurDensityGiven)
model->BSIM3v1SjctSidewallSatCurDensity = 0.0;
if (!model->BSIM3v1SbulkJctPotentialGiven)
model->BSIM3v1SbulkJctPotential = 1.0;
if (!model->BSIM3v1SsidewallJctPotentialGiven)
model->BSIM3v1SsidewallJctPotential = 1.0;
if (!model->BSIM3v1SGatesidewallJctPotentialGiven)
model->BSIM3v1SGatesidewallJctPotential = model->BSIM3v1SsidewallJctPotential;
if (!model->BSIM3v1SbulkJctBotGradingCoeffGiven)
model->BSIM3v1SbulkJctBotGradingCoeff = 0.5;
if (!model->BSIM3v1SbulkJctSideGradingCoeffGiven)
model->BSIM3v1SbulkJctSideGradingCoeff = 0.33;
if (!model->BSIM3v1SbulkJctGateSideGradingCoeffGiven)
model->BSIM3v1SbulkJctGateSideGradingCoeff = model->BSIM3v1SbulkJctSideGradingCoeff;
if (!model->BSIM3v1SjctEmissionCoeffGiven)
model->BSIM3v1SjctEmissionCoeff = 1.0;
if (!model->BSIM3v1SjctTempExponentGiven)
model->BSIM3v1SjctTempExponent = 3.0;
if (!model->BSIM3v1SoxideTrapDensityAGiven)
if (!model->BSIM3v1SoxideTrapDensityAGiven)
{ if (model->BSIM3v1Stype == NMOS)
model->BSIM3v1SoxideTrapDensityA = 1e20;
else
model->BSIM3v1SoxideTrapDensityA=9.9e18;
}
if (!model->BSIM3v1SoxideTrapDensityBGiven)
{ if (model->BSIM3v1Stype == NMOS)
model->BSIM3v1SoxideTrapDensityB = 5e4;
else
model->BSIM3v1SoxideTrapDensityB = 2.4e3;
}
if (!model->BSIM3v1SoxideTrapDensityCGiven)
{ if (model->BSIM3v1Stype == NMOS)
model->BSIM3v1SoxideTrapDensityC = -1.4e-12;
else
model->BSIM3v1SoxideTrapDensityC = 1.4e-12;
}
if (!model->BSIM3v1SemGiven)
model->BSIM3v1Sem = 4.1e7; /* V/m */
if (!model->BSIM3v1SefGiven)
model->BSIM3v1Sef = 1.0;
if (!model->BSIM3v1SafGiven)
model->BSIM3v1Saf = 1.0;
if (!model->BSIM3v1SkfGiven)
model->BSIM3v1Skf = 0.0;
/* loop through all the instances of the model */
for (here = model->BSIM3v1Sinstances; here != NULL ;
here=here->BSIM3v1SnextInstance)
{
if (here->BSIM3v1Sowner == ARCHme) {
/* allocate a chunk of the state vector */
here->BSIM3v1Sstates = *states;
*states += BSIM3v1SnumStates;
}
/* perform the parameter defaulting */
if(here->BSIM3v1Sm == 0.0)
here->BSIM3v1Sm = 1.0;
fprintf(stderr, "M = %.2f\n", here->BSIM3v1Sm);
if (!here->BSIM3v1SwGiven)
here->BSIM3v1Sw = 5e-6;
here->BSIM3v1Sw *= here->BSIM3v1Sm;
if (!here->BSIM3v1SdrainAreaGiven)
{
if(model->BSIM3v1ShdifGiven)
here->BSIM3v1SdrainArea = here->BSIM3v1Sw * 2 * model->BSIM3v1Shdif;
else
here->BSIM3v1SdrainArea = 0.0;
}
here->BSIM3v1SdrainArea *= here->BSIM3v1Sm;
if (!here->BSIM3v1SdrainPerimeterGiven)
{
if(model->BSIM3v1ShdifGiven)
here->BSIM3v1SdrainPerimeter =
2 * here->BSIM3v1Sw + 4 * model->BSIM3v1Shdif;
else
here->BSIM3v1SdrainPerimeter = 0.0;
}
here->BSIM3v1SdrainPerimeter *= here->BSIM3v1Sm;
if (!here->BSIM3v1SdrainSquaresGiven)
here->BSIM3v1SdrainSquares = 1.0;
here->BSIM3v1SdrainSquares /= here->BSIM3v1Sm;
if (!here->BSIM3v1SicVBSGiven)
here->BSIM3v1SicVBS = 0;
if (!here->BSIM3v1SicVDSGiven)
here->BSIM3v1SicVDS = 0;
if (!here->BSIM3v1SicVGSGiven)
here->BSIM3v1SicVGS = 0;
if (!here->BSIM3v1SlGiven)
here->BSIM3v1Sl = 5e-6;
if (!here->BSIM3v1SsourceAreaGiven)
{
if(model->BSIM3v1ShdifGiven)
here->BSIM3v1SsourceArea = here->BSIM3v1Sw * 2 * model->BSIM3v1Shdif;
else
here->BSIM3v1SsourceArea = 0.0;
}
here->BSIM3v1SsourceArea *= here->BSIM3v1Sm;
if (!here->BSIM3v1SsourcePerimeterGiven)
{
if(model->BSIM3v1ShdifGiven)
here->BSIM3v1SsourcePerimeter =
2 * here->BSIM3v1Sw + 4 * model->BSIM3v1Shdif;
else
here->BSIM3v1SsourcePerimeter = 0.0;
}
here->BSIM3v1SsourcePerimeter *= here->BSIM3v1Sm;
if (!here->BSIM3v1SsourceSquaresGiven)
here->BSIM3v1SsourceSquares = 1.0;
here->BSIM3v1SsourceSquares /= here->BSIM3v1Sm;
if (!here->BSIM3v1SnqsModGiven)
here->BSIM3v1SnqsMod = model->BSIM3v1SnqsMod;
/* process drain series resistance */
if ((model->BSIM3v1SsheetResistance > 0.0) &&
(here->BSIM3v1SdrainSquares > 0.0 ) &&
(here->BSIM3v1SdNodePrime == 0))
{ error = CKTmkVolt(ckt,&tmp,here->BSIM3v1Sname,"drain");
if(error) return(error);
here->BSIM3v1SdNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) {
if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
}
}
}
}
else
{ here->BSIM3v1SdNodePrime = here->BSIM3v1SdNode;
}
/* process source series resistance */
if ((model->BSIM3v1SsheetResistance > 0.0) &&
(here->BSIM3v1SsourceSquares > 0.0 ) &&
(here->BSIM3v1SsNodePrime == 0))
{ error = CKTmkVolt(ckt,&tmp,here->BSIM3v1Sname,"source");
if(error) return(error);
here->BSIM3v1SsNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) {
if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
}
}
}
}
else
{ here->BSIM3v1SsNodePrime = here->BSIM3v1SsNode;
}
/* internal charge node */
if ((here->BSIM3v1SnqsMod) && (here->BSIM3v1SqNode == 0))
{ error = CKTmkVolt(ckt,&tmp,here->BSIM3v1Sname,"charge");
if(error) return(error);
here->BSIM3v1SqNode = tmp->number;
}
else
{ here->BSIM3v1SqNode = 0;
}
/* set Sparse Matrix Pointers */
/* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
return(E_NOMEM);\
}
TSTALLOC(BSIM3v1SDdPtr, BSIM3v1SdNode, BSIM3v1SdNode)
TSTALLOC(BSIM3v1SGgPtr, BSIM3v1SgNode, BSIM3v1SgNode)
TSTALLOC(BSIM3v1SSsPtr, BSIM3v1SsNode, BSIM3v1SsNode)
TSTALLOC(BSIM3v1SBbPtr, BSIM3v1SbNode, BSIM3v1SbNode)
TSTALLOC(BSIM3v1SDPdpPtr, BSIM3v1SdNodePrime, BSIM3v1SdNodePrime)
TSTALLOC(BSIM3v1SSPspPtr, BSIM3v1SsNodePrime, BSIM3v1SsNodePrime)
TSTALLOC(BSIM3v1SDdpPtr, BSIM3v1SdNode, BSIM3v1SdNodePrime)
TSTALLOC(BSIM3v1SGbPtr, BSIM3v1SgNode, BSIM3v1SbNode)
TSTALLOC(BSIM3v1SGdpPtr, BSIM3v1SgNode, BSIM3v1SdNodePrime)
TSTALLOC(BSIM3v1SGspPtr, BSIM3v1SgNode, BSIM3v1SsNodePrime)
TSTALLOC(BSIM3v1SSspPtr, BSIM3v1SsNode, BSIM3v1SsNodePrime)
TSTALLOC(BSIM3v1SBdpPtr, BSIM3v1SbNode, BSIM3v1SdNodePrime)
TSTALLOC(BSIM3v1SBspPtr, BSIM3v1SbNode, BSIM3v1SsNodePrime)
TSTALLOC(BSIM3v1SDPspPtr, BSIM3v1SdNodePrime, BSIM3v1SsNodePrime)
TSTALLOC(BSIM3v1SDPdPtr, BSIM3v1SdNodePrime, BSIM3v1SdNode)
TSTALLOC(BSIM3v1SBgPtr, BSIM3v1SbNode, BSIM3v1SgNode)
TSTALLOC(BSIM3v1SDPgPtr, BSIM3v1SdNodePrime, BSIM3v1SgNode)
TSTALLOC(BSIM3v1SSPgPtr, BSIM3v1SsNodePrime, BSIM3v1SgNode)
TSTALLOC(BSIM3v1SSPsPtr, BSIM3v1SsNodePrime, BSIM3v1SsNode)
TSTALLOC(BSIM3v1SDPbPtr, BSIM3v1SdNodePrime, BSIM3v1SbNode)
TSTALLOC(BSIM3v1SSPbPtr, BSIM3v1SsNodePrime, BSIM3v1SbNode)
TSTALLOC(BSIM3v1SSPdpPtr, BSIM3v1SsNodePrime, BSIM3v1SdNodePrime)
TSTALLOC(BSIM3v1SQqPtr, BSIM3v1SqNode, BSIM3v1SqNode)
TSTALLOC(BSIM3v1SQdpPtr, BSIM3v1SqNode, BSIM3v1SdNodePrime)
TSTALLOC(BSIM3v1SQspPtr, BSIM3v1SqNode, BSIM3v1SsNodePrime)
TSTALLOC(BSIM3v1SQgPtr, BSIM3v1SqNode, BSIM3v1SgNode)
TSTALLOC(BSIM3v1SQbPtr, BSIM3v1SqNode, BSIM3v1SbNode)
TSTALLOC(BSIM3v1SDPqPtr, BSIM3v1SdNodePrime, BSIM3v1SqNode)
TSTALLOC(BSIM3v1SSPqPtr, BSIM3v1SsNodePrime, BSIM3v1SqNode)
TSTALLOC(BSIM3v1SGqPtr, BSIM3v1SgNode, BSIM3v1SqNode)
TSTALLOC(BSIM3v1SBqPtr, BSIM3v1SbNode, BSIM3v1SqNode)
}
}
return(OK);
}
int
BSIM3v1Sunsetup(GENmodel *inModel, CKTcircuit *ckt)
{
BSIM3v1Smodel *model;
BSIM3v1Sinstance *here;
for (model = (BSIM3v1Smodel *)inModel; model != NULL;
model = model->BSIM3v1SnextModel)
{
for (here = model->BSIM3v1Sinstances; here != NULL;
here=here->BSIM3v1SnextInstance)
{
if (here->BSIM3v1SdNodePrime
&& here->BSIM3v1SdNodePrime != here->BSIM3v1SdNode)
{
CKTdltNNum(ckt, here->BSIM3v1SdNodePrime);
here->BSIM3v1SdNodePrime = 0;
}
if (here->BSIM3v1SsNodePrime
&& here->BSIM3v1SsNodePrime != here->BSIM3v1SsNode)
{
CKTdltNNum(ckt, here->BSIM3v1SsNodePrime);
here->BSIM3v1SsNodePrime = 0;
}
}
}
return OK;
}

669
src/spicelib/devices/bsim3v1s/b3v1stemp.c
View File

@ -1,669 +0,0 @@
/***********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1stemp.c
**********/
/* Lmin, Lmax, Wmin, Wmax */
#include "ngspice.h"
#include "smpdefs.h"
#include "cktdefs.h"
#include "bsim3v1sdef.h"
#include "const.h"
#include "sperror.h"
#include "suffix.h"
#define Kb 1.3806226e-23
#define KboQ 8.617087e-5 /* Kb / q where q = 1.60219e-19 */
#define EPSOX 3.453133e-11
#define EPSSI 1.03594e-10
#define PI 3.141592654
#define MAX_EXP 5.834617425e14
#define MIN_EXP 1.713908431e-15
#define EXP_THRESHOLD 34.0
#define Charge_q 1.60219e-19
/* ARGSUSED */
int
BSIM3v1Stemp(GENmodel *inModel, CKTcircuit *ckt)
{
BSIM3v1Smodel *model = (BSIM3v1Smodel*) inModel;
BSIM3v1Sinstance *here;
struct bsim3v1sSizeDependParam *pSizeDependParamKnot, *pLastKnot, *pParam = NULL;
double tmp1, tmp2, Eg, Eg0, ni, T0, T1, T2, T3, Ldrn, Wdrn;
double Temp, TRatio, Inv_L, Inv_W, Inv_LW, Vtm0, Tnom;
int Size_Not_Found;
/* loop through all the BSIM3v1S device models */
for (; model != NULL; model = model->BSIM3v1SnextModel)
{ Temp = ckt->CKTtemp;
if (model->BSIM3v1SbulkJctPotential < 0.1)
model->BSIM3v1SbulkJctPotential = 0.1;
if (model->BSIM3v1SsidewallJctPotential < 0.1)
model->BSIM3v1SsidewallJctPotential = 0.1;
if (model->BSIM3v1SGatesidewallJctPotential < 0.1)
model->BSIM3v1SGatesidewallJctPotential = 0.1;
model->pSizeDependParamKnot = NULL;
pLastKnot = NULL;
Tnom = model->BSIM3v1Stnom;
TRatio = Temp / Tnom;
model->BSIM3v1Svcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14));
model->BSIM3v1Sfactor1 = sqrt(EPSSI / EPSOX * model->BSIM3v1Stox);
Vtm0 = KboQ * Tnom;
Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0);
ni = 1.45e10 * (Tnom / 300.15) * sqrt(Tnom / 300.15)
* exp(21.5565981 - Eg0 / (2.0 * Vtm0));
model->BSIM3v1Svtm = KboQ * Temp;
Eg = 1.16 - 7.02e-4 * Temp * Temp / (Temp + 1108.0);
if (Temp != Tnom)
{ T0 = Eg0 / Vtm0 - Eg / model->BSIM3v1Svtm + model->BSIM3v1SjctTempExponent
* log(Temp / Tnom);
T1 = exp(T0 / model->BSIM3v1SjctEmissionCoeff);
model->BSIM3v1SjctTempSatCurDensity = model->BSIM3v1SjctSatCurDensity
* T1;
model->BSIM3v1SjctSidewallTempSatCurDensity
= model->BSIM3v1SjctSidewallSatCurDensity * T1;
}
else
{ model->BSIM3v1SjctTempSatCurDensity = model->BSIM3v1SjctSatCurDensity;
model->BSIM3v1SjctSidewallTempSatCurDensity
= model->BSIM3v1SjctSidewallSatCurDensity;
}
if (model->BSIM3v1SjctTempSatCurDensity < 0.0)
model->BSIM3v1SjctTempSatCurDensity = 0.0;
if (model->BSIM3v1SjctSidewallTempSatCurDensity < 0.0)
model->BSIM3v1SjctSidewallTempSatCurDensity = 0.0;
/* loop through all the instances of the model */
/* MCJ: Length and Width not initialized */
for (here = model->BSIM3v1Sinstances; here != NULL;
here = here->BSIM3v1SnextInstance)
{
if (here->BSIM3v1Sowner != ARCHme)
continue;
pSizeDependParamKnot = model->pSizeDependParamKnot;
Size_Not_Found = 1;
while ((pSizeDependParamKnot != NULL) && Size_Not_Found)
{ if ((here->BSIM3v1Sl == pSizeDependParamKnot->Length)
&& (here->BSIM3v1Sw == pSizeDependParamKnot->Width))
{ Size_Not_Found = 0;
here->pParam = pSizeDependParamKnot;
}
else
{ pLastKnot = pSizeDependParamKnot;
pSizeDependParamKnot = pSizeDependParamKnot->pNext;
}
}
if (Size_Not_Found)
{ pParam = TMALLOC(struct bsim3v1sSizeDependParam, 1);
if (pLastKnot == NULL)
model->pSizeDependParamKnot = pParam;
else
pLastKnot->pNext = pParam;
pParam->pNext = NULL;
here->pParam = pParam;
Ldrn = here->BSIM3v1Sl;
Wdrn = here->BSIM3v1Sw;
pParam->Length = Ldrn;
pParam->Width = Wdrn;
T0 = pow(Ldrn, model->BSIM3v1SLln);
T1 = pow(Wdrn, model->BSIM3v1SLwn);
tmp1 = model->BSIM3v1SLl / T0 + model->BSIM3v1SLw / T1
+ model->BSIM3v1SLwl / (T0 * T1);
pParam->BSIM3v1Sdl = model->BSIM3v1SLint + tmp1;
pParam->BSIM3v1Sdlc = model->BSIM3v1Sdlc + tmp1;
T2 = pow(Ldrn, model->BSIM3v1SWln);
T3 = pow(Wdrn, model->BSIM3v1SWwn);
tmp2 = model->BSIM3v1SWl / T2 + model->BSIM3v1SWw / T3
+ model->BSIM3v1SWwl / (T2 * T3);
pParam->BSIM3v1Sdw = model->BSIM3v1SWint + tmp2;
pParam->BSIM3v1Sdwc = model->BSIM3v1Sdwc + tmp2;
pParam->BSIM3v1Sleff = here->BSIM3v1Sl - 2.0 * pParam->BSIM3v1Sdl;
if (pParam->BSIM3v1Sleff <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->BSIM3v1SmodName;
namarray[1] = here->BSIM3v1Sname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"BSIM3v1S: mosfet %s, model %s: Effective channel length <= 0",
namarray);
return(E_BADPARM);
}
pParam->BSIM3v1Sweff = here->BSIM3v1Sw - 2.0 * pParam->BSIM3v1Sdw;
if (pParam->BSIM3v1Sweff <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->BSIM3v1SmodName;
namarray[1] = here->BSIM3v1Sname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"BSIM3v1S: mosfet %s, model %s: Effective channel width <= 0",
namarray);
return(E_BADPARM);
}
pParam->BSIM3v1SleffCV = here->BSIM3v1Sl - 2.0 * pParam->BSIM3v1Sdlc;
if (pParam->BSIM3v1SleffCV <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->BSIM3v1SmodName;
namarray[1] = here->BSIM3v1Sname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"BSIM3v1S: mosfet %s, model %s: Effective channel length for C-V <= 0",
namarray);
return(E_BADPARM);
}
pParam->BSIM3v1SweffCV = here->BSIM3v1Sw - 2.0 * pParam->BSIM3v1Sdwc;
if (pParam->BSIM3v1SweffCV <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->BSIM3v1SmodName;
namarray[1] = here->BSIM3v1Sname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"BSIM3v1S: mosfet %s, model %s: Effective channel width for C-V <= 0",
namarray);
return(E_BADPARM);
}
if (model->BSIM3v1SbinUnit == 1)
{ Inv_L = 1.0e-6 / pParam->BSIM3v1Sleff;
Inv_W = 1.0e-6 / pParam->BSIM3v1Sweff;
Inv_LW = 1.0e-12 / (pParam->BSIM3v1Sleff
* pParam->BSIM3v1Sweff);
}
else
{ Inv_L = 1.0 / pParam->BSIM3v1Sleff;
Inv_W = 1.0 / pParam->BSIM3v1Sweff;
Inv_LW = 1.0 / (pParam->BSIM3v1Sleff
* pParam->BSIM3v1Sweff);
}
pParam->BSIM3v1Scdsc = model->BSIM3v1Scdsc
+ model->BSIM3v1Slcdsc * Inv_L
+ model->BSIM3v1Swcdsc * Inv_W
+ model->BSIM3v1Spcdsc * Inv_LW;
pParam->BSIM3v1Scdscb = model->BSIM3v1Scdscb
+ model->BSIM3v1Slcdscb * Inv_L
+ model->BSIM3v1Swcdscb * Inv_W
+ model->BSIM3v1Spcdscb * Inv_LW;
pParam->BSIM3v1Scdscd = model->BSIM3v1Scdscd
+ model->BSIM3v1Slcdscd * Inv_L
+ model->BSIM3v1Swcdscd * Inv_W
+ model->BSIM3v1Spcdscd * Inv_LW;
pParam->BSIM3v1Scit = model->BSIM3v1Scit
+ model->BSIM3v1Slcit * Inv_L
+ model->BSIM3v1Swcit * Inv_W
+ model->BSIM3v1Spcit * Inv_LW;
pParam->BSIM3v1Snfactor = model->BSIM3v1Snfactor
+ model->BSIM3v1Slnfactor * Inv_L
+ model->BSIM3v1Swnfactor * Inv_W
+ model->BSIM3v1Spnfactor * Inv_LW;
pParam->BSIM3v1Sxj = model->BSIM3v1Sxj
+ model->BSIM3v1Slxj * Inv_L
+ model->BSIM3v1Swxj * Inv_W
+ model->BSIM3v1Spxj * Inv_LW;
pParam->BSIM3v1Svsat = model->BSIM3v1Svsat
+ model->BSIM3v1Slvsat * Inv_L
+ model->BSIM3v1Swvsat * Inv_W
+ model->BSIM3v1Spvsat * Inv_LW;
pParam->BSIM3v1Sat = model->BSIM3v1Sat
+ model->BSIM3v1Slat * Inv_L
+ model->BSIM3v1Swat * Inv_W
+ model->BSIM3v1Spat * Inv_LW;
pParam->BSIM3v1Sa0 = model->BSIM3v1Sa0
+ model->BSIM3v1Sla0 * Inv_L
+ model->BSIM3v1Swa0 * Inv_W
+ model->BSIM3v1Spa0 * Inv_LW;
pParam->BSIM3v1Sags = model->BSIM3v1Sags
+ model->BSIM3v1Slags * Inv_L
+ model->BSIM3v1Swags * Inv_W
+ model->BSIM3v1Spags * Inv_LW;
pParam->BSIM3v1Sa1 = model->BSIM3v1Sa1
+ model->BSIM3v1Sla1 * Inv_L
+ model->BSIM3v1Swa1 * Inv_W
+ model->BSIM3v1Spa1 * Inv_LW;
pParam->BSIM3v1Sa2 = model->BSIM3v1Sa2
+ model->BSIM3v1Sla2 * Inv_L
+ model->BSIM3v1Swa2 * Inv_W
+ model->BSIM3v1Spa2 * Inv_LW;
pParam->BSIM3v1Sketa = model->BSIM3v1Sketa
+ model->BSIM3v1Slketa * Inv_L
+ model->BSIM3v1Swketa * Inv_W
+ model->BSIM3v1Spketa * Inv_LW;
pParam->BSIM3v1Snsub = model->BSIM3v1Snsub
+ model->BSIM3v1Slnsub * Inv_L
+ model->BSIM3v1Swnsub * Inv_W
+ model->BSIM3v1Spnsub * Inv_LW;
pParam->BSIM3v1Snpeak = model->BSIM3v1Snpeak
+ model->BSIM3v1Slnpeak * Inv_L
+ model->BSIM3v1Swnpeak * Inv_W
+ model->BSIM3v1Spnpeak * Inv_LW;
pParam->BSIM3v1Sngate = model->BSIM3v1Sngate
+ model->BSIM3v1Slngate * Inv_L
+ model->BSIM3v1Swngate * Inv_W
+ model->BSIM3v1Spngate * Inv_LW;
pParam->BSIM3v1Sgamma1 = model->BSIM3v1Sgamma1
+ model->BSIM3v1Slgamma1 * Inv_L
+ model->BSIM3v1Swgamma1 * Inv_W
+ model->BSIM3v1Spgamma1 * Inv_LW;
pParam->BSIM3v1Sgamma2 = model->BSIM3v1Sgamma2
+ model->BSIM3v1Slgamma2 * Inv_L
+ model->BSIM3v1Swgamma2 * Inv_W
+ model->BSIM3v1Spgamma2 * Inv_LW;
pParam->BSIM3v1Svbx = model->BSIM3v1Svbx
+ model->BSIM3v1Slvbx * Inv_L
+ model->BSIM3v1Swvbx * Inv_W
+ model->BSIM3v1Spvbx * Inv_LW;
pParam->BSIM3v1Svbm = model->BSIM3v1Svbm
+ model->BSIM3v1Slvbm * Inv_L
+ model->BSIM3v1Swvbm * Inv_W
+ model->BSIM3v1Spvbm * Inv_LW;
pParam->BSIM3v1Sxt = model->BSIM3v1Sxt
+ model->BSIM3v1Slxt * Inv_L
+ model->BSIM3v1Swxt * Inv_W
+ model->BSIM3v1Spxt * Inv_LW;
pParam->BSIM3v1Sk1 = model->BSIM3v1Sk1
+ model->BSIM3v1Slk1 * Inv_L
+ model->BSIM3v1Swk1 * Inv_W
+ model->BSIM3v1Spk1 * Inv_LW;
pParam->BSIM3v1Skt1 = model->BSIM3v1Skt1
+ model->BSIM3v1Slkt1 * Inv_L
+ model->BSIM3v1Swkt1 * Inv_W
+ model->BSIM3v1Spkt1 * Inv_LW;
pParam->BSIM3v1Skt1l = model->BSIM3v1Skt1l
+ model->BSIM3v1Slkt1l * Inv_L
+ model->BSIM3v1Swkt1l * Inv_W
+ model->BSIM3v1Spkt1l * Inv_LW;
pParam->BSIM3v1Sk2 = model->BSIM3v1Sk2
+ model->BSIM3v1Slk2 * Inv_L
+ model->BSIM3v1Swk2 * Inv_W
+ model->BSIM3v1Spk2 * Inv_LW;
pParam->BSIM3v1Skt2 = model->BSIM3v1Skt2
+ model->BSIM3v1Slkt2 * Inv_L
+ model->BSIM3v1Swkt2 * Inv_W
+ model->BSIM3v1Spkt2 * Inv_LW;
pParam->BSIM3v1Sk3 = model->BSIM3v1Sk3
+ model->BSIM3v1Slk3 * Inv_L
+ model->BSIM3v1Swk3 * Inv_W
+ model->BSIM3v1Spk3 * Inv_LW;
pParam->BSIM3v1Sk3b = model->BSIM3v1Sk3b
+ model->BSIM3v1Slk3b * Inv_L
+ model->BSIM3v1Swk3b * Inv_W
+ model->BSIM3v1Spk3b * Inv_LW;
pParam->BSIM3v1Sw0 = model->BSIM3v1Sw0
+ model->BSIM3v1Slw0 * Inv_L
+ model->BSIM3v1Sww0 * Inv_W
+ model->BSIM3v1Spw0 * Inv_LW;
pParam->BSIM3v1Snlx = model->BSIM3v1Snlx
+ model->BSIM3v1Slnlx * Inv_L
+ model->BSIM3v1Swnlx * Inv_W
+ model->BSIM3v1Spnlx * Inv_LW;
pParam->BSIM3v1Sdvt0 = model->BSIM3v1Sdvt0
+ model->BSIM3v1Sldvt0 * Inv_L
+ model->BSIM3v1Swdvt0 * Inv_W
+ model->BSIM3v1Spdvt0 * Inv_LW;
pParam->BSIM3v1Sdvt1 = model->BSIM3v1Sdvt1
+ model->BSIM3v1Sldvt1 * Inv_L
+ model->BSIM3v1Swdvt1 * Inv_W
+ model->BSIM3v1Spdvt1 * Inv_LW;
pParam->BSIM3v1Sdvt2 = model->BSIM3v1Sdvt2
+ model->BSIM3v1Sldvt2 * Inv_L
+ model->BSIM3v1Swdvt2 * Inv_W
+ model->BSIM3v1Spdvt2 * Inv_LW;
pParam->BSIM3v1Sdvt0w = model->BSIM3v1Sdvt0w
+ model->BSIM3v1Sldvt0w * Inv_L
+ model->BSIM3v1Swdvt0w * Inv_W
+ model->BSIM3v1Spdvt0w * Inv_LW;
pParam->BSIM3v1Sdvt1w = model->BSIM3v1Sdvt1w
+ model->BSIM3v1Sldvt1w * Inv_L
+ model->BSIM3v1Swdvt1w * Inv_W
+ model->BSIM3v1Spdvt1w * Inv_LW;
pParam->BSIM3v1Sdvt2w = model->BSIM3v1Sdvt2w
+ model->BSIM3v1Sldvt2w * Inv_L
+ model->BSIM3v1Swdvt2w * Inv_W
+ model->BSIM3v1Spdvt2w * Inv_LW;
pParam->BSIM3v1Sdrout = model->BSIM3v1Sdrout
+ model->BSIM3v1Sldrout * Inv_L
+ model->BSIM3v1Swdrout * Inv_W
+ model->BSIM3v1Spdrout * Inv_LW;
pParam->BSIM3v1Sdsub = model->BSIM3v1Sdsub
+ model->BSIM3v1Sldsub * Inv_L
+ model->BSIM3v1Swdsub * Inv_W
+ model->BSIM3v1Spdsub * Inv_LW;
pParam->BSIM3v1Svth0 = model->BSIM3v1Svth0
+ model->BSIM3v1Slvth0 * Inv_L
+ model->BSIM3v1Swvth0 * Inv_W
+ model->BSIM3v1Spvth0 * Inv_LW;
pParam->BSIM3v1Sua = model->BSIM3v1Sua
+ model->BSIM3v1Slua * Inv_L
+ model->BSIM3v1Swua * Inv_W
+ model->BSIM3v1Spua * Inv_LW;
pParam->BSIM3v1Sua1 = model->BSIM3v1Sua1
+ model->BSIM3v1Slua1 * Inv_L
+ model->BSIM3v1Swua1 * Inv_W
+ model->BSIM3v1Spua1 * Inv_LW;
pParam->BSIM3v1Sub = model->BSIM3v1Sub
+ model->BSIM3v1Slub * Inv_L
+ model->BSIM3v1Swub * Inv_W
+ model->BSIM3v1Spub * Inv_LW;
pParam->BSIM3v1Sub1 = model->BSIM3v1Sub1
+ model->BSIM3v1Slub1 * Inv_L
+ model->BSIM3v1Swub1 * Inv_W
+ model->BSIM3v1Spub1 * Inv_LW;
pParam->BSIM3v1Suc = model->BSIM3v1Suc
+ model->BSIM3v1Sluc * Inv_L
+ model->BSIM3v1Swuc * Inv_W
+ model->BSIM3v1Spuc * Inv_LW;
pParam->BSIM3v1Suc1 = model->BSIM3v1Suc1
+ model->BSIM3v1Sluc1 * Inv_L
+ model->BSIM3v1Swuc1 * Inv_W
+ model->BSIM3v1Spuc1 * Inv_LW;
pParam->BSIM3v1Su0 = model->BSIM3v1Su0
+ model->BSIM3v1Slu0 * Inv_L
+ model->BSIM3v1Swu0 * Inv_W
+ model->BSIM3v1Spu0 * Inv_LW;
pParam->BSIM3v1Sute = model->BSIM3v1Sute
+ model->BSIM3v1Slute * Inv_L
+ model->BSIM3v1Swute * Inv_W
+ model->BSIM3v1Spute * Inv_LW;
pParam->BSIM3v1Svoff = model->BSIM3v1Svoff
+ model->BSIM3v1Slvoff * Inv_L
+ model->BSIM3v1Swvoff * Inv_W
+ model->BSIM3v1Spvoff * Inv_LW;
pParam->BSIM3v1Sdelta = model->BSIM3v1Sdelta
+ model->BSIM3v1Sldelta * Inv_L
+ model->BSIM3v1Swdelta * Inv_W
+ model->BSIM3v1Spdelta * Inv_LW;
pParam->BSIM3v1Srdsw = model->BSIM3v1Srdsw
+ model->BSIM3v1Slrdsw * Inv_L
+ model->BSIM3v1Swrdsw * Inv_W
+ model->BSIM3v1Sprdsw * Inv_LW;
pParam->BSIM3v1Sprwg = model->BSIM3v1Sprwg
+ model->BSIM3v1Slprwg * Inv_L
+ model->BSIM3v1Swprwg * Inv_W
+ model->BSIM3v1Spprwg * Inv_LW;
pParam->BSIM3v1Sprwb = model->BSIM3v1Sprwb
+ model->BSIM3v1Slprwb * Inv_L
+ model->BSIM3v1Swprwb * Inv_W
+ model->BSIM3v1Spprwb * Inv_LW;
pParam->BSIM3v1Sprt = model->BSIM3v1Sprt
+ model->BSIM3v1Slprt * Inv_L
+ model->BSIM3v1Swprt * Inv_W
+ model->BSIM3v1Spprt * Inv_LW;
pParam->BSIM3v1Seta0 = model->BSIM3v1Seta0
+ model->BSIM3v1Sleta0 * Inv_L
+ model->BSIM3v1Sweta0 * Inv_W
+ model->BSIM3v1Speta0 * Inv_LW;
pParam->BSIM3v1Setab = model->BSIM3v1Setab
+ model->BSIM3v1Sletab * Inv_L
+ model->BSIM3v1Swetab * Inv_W
+ model->BSIM3v1Spetab * Inv_LW;
pParam->BSIM3v1Spclm = model->BSIM3v1Spclm
+ model->BSIM3v1Slpclm * Inv_L
+ model->BSIM3v1Swpclm * Inv_W
+ model->BSIM3v1Sppclm * Inv_LW;
pParam->BSIM3v1Spdibl1 = model->BSIM3v1Spdibl1
+ model->BSIM3v1Slpdibl1 * Inv_L
+ model->BSIM3v1Swpdibl1 * Inv_W
+ model->BSIM3v1Sppdibl1 * Inv_LW;
pParam->BSIM3v1Spdibl2 = model->BSIM3v1Spdibl2
+ model->BSIM3v1Slpdibl2 * Inv_L
+ model->BSIM3v1Swpdibl2 * Inv_W
+ model->BSIM3v1Sppdibl2 * Inv_LW;
pParam->BSIM3v1Spdiblb = model->BSIM3v1Spdiblb
+ model->BSIM3v1Slpdiblb * Inv_L
+ model->BSIM3v1Swpdiblb * Inv_W
+ model->BSIM3v1Sppdiblb * Inv_LW;
pParam->BSIM3v1Spscbe1 = model->BSIM3v1Spscbe1
+ model->BSIM3v1Slpscbe1 * Inv_L
+ model->BSIM3v1Swpscbe1 * Inv_W
+ model->BSIM3v1Sppscbe1 * Inv_LW;
pParam->BSIM3v1Spscbe2 = model->BSIM3v1Spscbe2
+ model->BSIM3v1Slpscbe2 * Inv_L
+ model->BSIM3v1Swpscbe2 * Inv_W
+ model->BSIM3v1Sppscbe2 * Inv_LW;
pParam->BSIM3v1Spvag = model->BSIM3v1Spvag
+ model->BSIM3v1Slpvag * Inv_L
+ model->BSIM3v1Swpvag * Inv_W
+ model->BSIM3v1Sppvag * Inv_LW;
pParam->BSIM3v1Swr = model->BSIM3v1Swr
+ model->BSIM3v1Slwr * Inv_L
+ model->BSIM3v1Swwr * Inv_W
+ model->BSIM3v1Spwr * Inv_LW;
pParam->BSIM3v1Sdwg = model->BSIM3v1Sdwg
+ model->BSIM3v1Sldwg * Inv_L
+ model->BSIM3v1Swdwg * Inv_W
+ model->BSIM3v1Spdwg * Inv_LW;
pParam->BSIM3v1Sdwb = model->BSIM3v1Sdwb
+ model->BSIM3v1Sldwb * Inv_L
+ model->BSIM3v1Swdwb * Inv_W
+ model->BSIM3v1Spdwb * Inv_LW;
pParam->BSIM3v1Sb0 = model->BSIM3v1Sb0
+ model->BSIM3v1Slb0 * Inv_L
+ model->BSIM3v1Swb0 * Inv_W
+ model->BSIM3v1Spb0 * Inv_LW;
pParam->BSIM3v1Sb1 = model->BSIM3v1Sb1
+ model->BSIM3v1Slb1 * Inv_L
+ model->BSIM3v1Swb1 * Inv_W
+ model->BSIM3v1Spb1 * Inv_LW;
pParam->BSIM3v1Salpha0 = model->BSIM3v1Salpha0
+ model->BSIM3v1Slalpha0 * Inv_L
+ model->BSIM3v1Swalpha0 * Inv_W
+ model->BSIM3v1Spalpha0 * Inv_LW;
pParam->BSIM3v1Sbeta0 = model->BSIM3v1Sbeta0
+ model->BSIM3v1Slbeta0 * Inv_L
+ model->BSIM3v1Swbeta0 * Inv_W
+ model->BSIM3v1Spbeta0 * Inv_LW;
/* CV model */
pParam->BSIM3v1Selm = model->BSIM3v1Selm
+ model->BSIM3v1Slelm * Inv_L
+ model->BSIM3v1Swelm * Inv_W
+ model->BSIM3v1Spelm * Inv_LW;
pParam->BSIM3v1Scgsl = model->BSIM3v1Scgsl
+ model->BSIM3v1Slcgsl * Inv_L
+ model->BSIM3v1Swcgsl * Inv_W
+ model->BSIM3v1Spcgsl * Inv_LW;
pParam->BSIM3v1Scgdl = model->BSIM3v1Scgdl
+ model->BSIM3v1Slcgdl * Inv_L
+ model->BSIM3v1Swcgdl * Inv_W
+ model->BSIM3v1Spcgdl * Inv_LW;
pParam->BSIM3v1Sckappa = model->BSIM3v1Sckappa
+ model->BSIM3v1Slckappa * Inv_L
+ model->BSIM3v1Swckappa * Inv_W
+ model->BSIM3v1Spckappa * Inv_LW;
pParam->BSIM3v1Scf = model->BSIM3v1Scf
+ model->BSIM3v1Slcf * Inv_L
+ model->BSIM3v1Swcf * Inv_W
+ model->BSIM3v1Spcf * Inv_LW;
pParam->BSIM3v1Sclc = model->BSIM3v1Sclc
+ model->BSIM3v1Slclc * Inv_L
+ model->BSIM3v1Swclc * Inv_W
+ model->BSIM3v1Spclc * Inv_LW;
pParam->BSIM3v1Scle = model->BSIM3v1Scle
+ model->BSIM3v1Slcle * Inv_L
+ model->BSIM3v1Swcle * Inv_W
+ model->BSIM3v1Spcle * Inv_LW;
pParam->BSIM3v1Svfbcv = model->BSIM3v1Svfbcv
+ model->BSIM3v1Slvfbcv * Inv_L
+ model->BSIM3v1Swvfbcv * Inv_W
+ model->BSIM3v1Spvfbcv * Inv_LW;
pParam->BSIM3v1SabulkCVfactor = 1.0 + pow((pParam->BSIM3v1Sclc
/ pParam->BSIM3v1Sleff),
pParam->BSIM3v1Scle);
T0 = (TRatio - 1.0);
pParam->BSIM3v1Sua = pParam->BSIM3v1Sua + pParam->BSIM3v1Sua1 * T0;
pParam->BSIM3v1Sub = pParam->BSIM3v1Sub + pParam->BSIM3v1Sub1 * T0;
pParam->BSIM3v1Suc = pParam->BSIM3v1Suc + pParam->BSIM3v1Suc1 * T0;
if (pParam->BSIM3v1Su0 > 1.0)
pParam->BSIM3v1Su0 = pParam->BSIM3v1Su0 / 1.0e4;
pParam->BSIM3v1Su0temp = pParam->BSIM3v1Su0
* pow(TRatio, pParam->BSIM3v1Sute);
pParam->BSIM3v1Svsattemp = pParam->BSIM3v1Svsat - pParam->BSIM3v1Sat
* T0;
pParam->BSIM3v1Srds0 = (pParam->BSIM3v1Srdsw + pParam->BSIM3v1Sprt * T0)
/ pow(pParam->BSIM3v1Sweff * 1E6, pParam->BSIM3v1Swr);
if (BSIM3v1ScheckModel(model, here, ckt))
{ IFuid namarray[2];
namarray[0] = model->BSIM3v1SmodName;
namarray[1] = here->BSIM3v1Sname;
(*(SPfrontEnd->IFerror)) (ERR_FATAL, "Fatal error(s) detected during BSIM3v1SV3 parameter checking for %s in model %s", namarray);
return(E_BADPARM);
}
pParam->BSIM3v1Scgdo = (model->BSIM3v1Scgdo + pParam->BSIM3v1Scf)
* pParam->BSIM3v1SweffCV;
pParam->BSIM3v1Scgso = (model->BSIM3v1Scgso + pParam->BSIM3v1Scf)
* pParam->BSIM3v1SweffCV;
pParam->BSIM3v1Scgbo = model->BSIM3v1Scgbo * pParam->BSIM3v1SleffCV;
if (!model->BSIM3v1SnpeakGiven && model->BSIM3v1Sgamma1Given)
{ T0 = pParam->BSIM3v1Sgamma1 * model->BSIM3v1Scox;
pParam->BSIM3v1Snpeak = 3.021E22 * T0 * T0;
}
pParam->BSIM3v1Sphi = 2.0 * Vtm0
* log(pParam->BSIM3v1Snpeak / ni);
pParam->BSIM3v1SsqrtPhi = sqrt(pParam->BSIM3v1Sphi);
pParam->BSIM3v1Sphis3 = pParam->BSIM3v1SsqrtPhi * pParam->BSIM3v1Sphi;
pParam->BSIM3v1SXdep0 = sqrt(2.0 * EPSSI / (Charge_q
* pParam->BSIM3v1Snpeak * 1.0e6))
* pParam->BSIM3v1SsqrtPhi;
pParam->BSIM3v1SsqrtXdep0 = sqrt(pParam->BSIM3v1SXdep0);
pParam->BSIM3v1Slitl = sqrt(3.0 * pParam->BSIM3v1Sxj
* model->BSIM3v1Stox);
pParam->BSIM3v1Svbi = Vtm0 * log(1.0e20
* pParam->BSIM3v1Snpeak / (ni * ni));
pParam->BSIM3v1Scdep0 = sqrt(Charge_q * EPSSI
* pParam->BSIM3v1Snpeak * 1.0e6 / 2.0
/ pParam->BSIM3v1Sphi);
if (model->BSIM3v1Sk1Given || model->BSIM3v1Sk2Given)
{ if (!model->BSIM3v1Sk1Given)
{ fprintf(stdout, "Warning: k1 should be specified with k2.\n");
pParam->BSIM3v1Sk1 = 0.53;
}
if (!model->BSIM3v1Sk2Given)
{ fprintf(stdout, "Warning: k2 should be specified with k1.\n");
pParam->BSIM3v1Sk2 = -0.0186;
}
if (model->BSIM3v1SnsubGiven)
fprintf(stdout, "Warning: nsub is ignored because k1 or k2 is given.\n");
if (model->BSIM3v1SxtGiven)
fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n");
if (model->BSIM3v1SvbxGiven)
fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n");
if (model->BSIM3v1SvbmGiven)
fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n");
if (model->BSIM3v1Sgamma1Given)
fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n");
if (model->BSIM3v1Sgamma2Given)
fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n");
}
else
{ if (!model->BSIM3v1SvbxGiven)
pParam->BSIM3v1Svbx = pParam->BSIM3v1Sphi - 7.7348e-4
* pParam->BSIM3v1Snpeak
* pParam->BSIM3v1Sxt * pParam->BSIM3v1Sxt;
if (pParam->BSIM3v1Svbx > 0.0)
pParam->BSIM3v1Svbx = -pParam->BSIM3v1Svbx;
if (pParam->BSIM3v1Svbm > 0.0)
pParam->BSIM3v1Svbm = -pParam->BSIM3v1Svbm;
if (!model->BSIM3v1Sgamma1Given)
pParam->BSIM3v1Sgamma1 = 5.753e-12
* sqrt(pParam->BSIM3v1Snpeak)
/ model->BSIM3v1Scox;
if (!model->BSIM3v1Sgamma2Given)
pParam->BSIM3v1Sgamma2 = 5.753e-12
* sqrt(pParam->BSIM3v1Snsub)
/ model->BSIM3v1Scox;
T0 = pParam->BSIM3v1Sgamma1 - pParam->BSIM3v1Sgamma2;
T1 = sqrt(pParam->BSIM3v1Sphi - pParam->BSIM3v1Svbx)
- pParam->BSIM3v1SsqrtPhi;
T2 = sqrt(pParam->BSIM3v1Sphi * (pParam->BSIM3v1Sphi
- pParam->BSIM3v1Svbm)) - pParam->BSIM3v1Sphi;
pParam->BSIM3v1Sk2 = T0 * T1 / (2.0 * T2 + pParam->BSIM3v1Svbm);
pParam->BSIM3v1Sk1 = pParam->BSIM3v1Sgamma2 - 2.0
* pParam->BSIM3v1Sk2 * sqrt(pParam->BSIM3v1Sphi
- pParam->BSIM3v1Svbm);
}
if (pParam->BSIM3v1Sk2 < 0.0)
{ T0 = 0.5 * pParam->BSIM3v1Sk1 / pParam->BSIM3v1Sk2;
pParam->BSIM3v1Svbsc = 0.9 * (pParam->BSIM3v1Sphi - T0 * T0);
if (pParam->BSIM3v1Svbsc > -3.0)
pParam->BSIM3v1Svbsc = -3.0;
else if (pParam->BSIM3v1Svbsc < -30.0)
pParam->BSIM3v1Svbsc = -30.0;
}
else
{ pParam->BSIM3v1Svbsc = -30.0;
}
if (pParam->BSIM3v1Svbsc > pParam->BSIM3v1Svbm)
pParam->BSIM3v1Svbsc = pParam->BSIM3v1Svbm;
if (model->BSIM3v1Svth0Given)
{ pParam->BSIM3v1Svfb = model->BSIM3v1Stype * pParam->BSIM3v1Svth0
- pParam->BSIM3v1Sphi - pParam->BSIM3v1Sk1
* pParam->BSIM3v1SsqrtPhi;
}
else
{ pParam->BSIM3v1Svfb = -1.0;
pParam->BSIM3v1Svth0 = model->BSIM3v1Stype * (pParam->BSIM3v1Svfb
+ pParam->BSIM3v1Sphi + pParam->BSIM3v1Sk1
* pParam->BSIM3v1SsqrtPhi);
}
T1 = sqrt(EPSSI / EPSOX * model->BSIM3v1Stox
* pParam->BSIM3v1SXdep0);
T0 = exp(-0.5 * pParam->BSIM3v1Sdsub * pParam->BSIM3v1Sleff / T1);
pParam->BSIM3v1Stheta0vb0 = (T0 + 2.0 * T0 * T0);
T0 = exp(-0.5 * pParam->BSIM3v1Sdrout * pParam->BSIM3v1Sleff / T1);
T2 = (T0 + 2.0 * T0 * T0);
pParam->BSIM3v1SthetaRout = pParam->BSIM3v1Spdibl1 * T2
+ pParam->BSIM3v1Spdibl2;
}
/* process source/drain series resistance */
here->BSIM3v1SdrainConductance = model->BSIM3v1SsheetResistance
* here->BSIM3v1SdrainSquares;
if (here->BSIM3v1SdrainConductance > 0.0)
here->BSIM3v1SdrainConductance = 1.0
/ here->BSIM3v1SdrainConductance;
else
here->BSIM3v1SdrainConductance = 0.0;
here->BSIM3v1SsourceConductance = model->BSIM3v1SsheetResistance
* here->BSIM3v1SsourceSquares;
if (here->BSIM3v1SsourceConductance > 0.0)
here->BSIM3v1SsourceConductance = 1.0
/ here->BSIM3v1SsourceConductance;
else
here->BSIM3v1SsourceConductance = 0.0;
here->BSIM3v1Scgso = pParam->BSIM3v1Scgso;
here->BSIM3v1Scgdo = pParam->BSIM3v1Scgdo;
}
}
return(OK);
}

49
src/spicelib/devices/bsim3v1s/b3v1strunc.c
View File

@ -1,49 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Paolo Nenzi 2002
File: b3v1strunc.c
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "bsim3v1sdef.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3v1Strunc(GENmodel *inModel, CKTcircuit *ckt, double *timeStep)
{
BSIM3v1Smodel *model = (BSIM3v1Smodel*)inModel;
BSIM3v1Sinstance *here;
#ifdef STEPDEBUG
double debugtemp;
#endif /* STEPDEBUG */
for (; model != NULL; model = model->BSIM3v1SnextModel)
{ for (here = model->BSIM3v1Sinstances; here != NULL;
here = here->BSIM3v1SnextInstance)
{
if (here->BSIM3v1Sowner != ARCHme)
continue;
#ifdef STEPDEBUG
debugtemp = *timeStep;
#endif /* STEPDEBUG */
CKTterr(here->BSIM3v1Sqb,ckt,timeStep);
CKTterr(here->BSIM3v1Sqg,ckt,timeStep);
CKTterr(here->BSIM3v1Sqd,ckt,timeStep);
#ifdef STEPDEBUG
if(debugtemp != *timeStep)
{ printf("device %s reduces step from %g to %g\n",
here->BSIM3v1Sname,debugtemp,*timeStep);
}
#endif /* STEPDEBUG */
}
}
return(OK);
}

1629
src/spicelib/devices/bsim3v1s/bsim3v1sdef.h
File diff suppressed because it is too large
View File

30
src/spicelib/devices/bsim3v1s/bsim3v1sext.h
View File

@ -1,30 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1991 JianHui Huang and Min-Chie Jeng.
Modified by Paolo Nenzi 2002
File: bsim3v1sext.h
**********/
extern int BSIM3v1SacLoad(GENmodel *,CKTcircuit*);
extern int BSIM3v1Sask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*);
extern int BSIM3v1SconvTest(GENmodel *,CKTcircuit*);
extern int BSIM3v1Sdelete(GENmodel*,IFuid,GENinstance**);
extern void BSIM3v1Sdestroy(GENmodel**);
extern int BSIM3v1Sgetic(GENmodel*,CKTcircuit*);
extern int BSIM3v1Sload(GENmodel*,CKTcircuit*);
extern int BSIM3v1SmAsk(CKTcircuit*,GENmodel *,int, IFvalue*);
extern int BSIM3v1SmDelete(GENmodel**,IFuid,GENmodel*);
extern int BSIM3v1SmParam(int,IFvalue*,GENmodel*);
extern void BSIM3v1SmosCap(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*);
extern int BSIM3v1Sparam(int,IFvalue*,GENinstance*,IFvalue*);
extern int BSIM3v1SpzLoad(GENmodel*,CKTcircuit*,SPcomplex*);
extern int BSIM3v1Ssetup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
extern int BSIM3v1Stemp(GENmodel*,CKTcircuit*);
extern int BSIM3v1Strunc(GENmodel*,CKTcircuit*,double*);
extern int BSIM3v1Snoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
extern int BSIM3v1Sunsetup(GENmodel *, CKTcircuit *);

89
src/spicelib/devices/bsim3v1s/bsim3v1sinit.c
View File

@ -1,89 +0,0 @@
#include "config.h"
#include "devdefs.h"
#include "bsim3v1sitf.h"
#include "bsim3v1sext.h"
#include "bsim3v1sinit.h"
SPICEdev BSIM3v1Sinfo = {
{
"BSIM3v1S",
"Berkeley Short Channel IGFET Model Version-3 (3.1 Serban)",
&BSIM3v1SnSize,
&BSIM3v1SnSize,
BSIM3v1Snames,
&BSIM3v1SpTSize,
BSIM3v1SpTable,
&BSIM3v1SmPTSize,
BSIM3v1SmPTable,
#ifdef XSPICE
/*
* OH what a hack this is!!! I have no idea what the proper values
* should be so I am just going to zero it out! This is a heck of a
* lot better than what existed perviously which was to convert
* DEV_DEFAULT to a function pointer. Would have started executing
* data at that point. Gotta love it!!!
*/
NULL,
0,
NULL,
0,
NULL,
0,
NULL,
#endif
DEV_DEFAULT,
},
/* DEVparam */ BSIM3v1Sparam,
/* DEVmodParam */ BSIM3v1SmParam,
/* DEVload */ BSIM3v1Sload,
/* DEVsetup */ BSIM3v1Ssetup,
/* DEVunsetup */ BSIM3v1Sunsetup,
/* DEVpzSetup */ BSIM3v1Ssetup,
/* DEVtemperature*/ BSIM3v1Stemp,
/* DEVtrunc */ BSIM3v1Strunc,
/* DEVfindBranch */ NULL,
/* DEVacLoad */ BSIM3v1SacLoad,
/* DEVaccept */ NULL,
/* DEVdestroy */ BSIM3v1Sdestroy,
/* DEVmodDelete */ BSIM3v1SmDelete,
/* DEVdelete */ BSIM3v1Sdelete,
/* DEVsetic */ BSIM3v1Sgetic,
/* DEVask */ BSIM3v1Sask,
/* DEVmodAsk */ BSIM3v1SmAsk,
/* DEVpzLoad */ BSIM3v1SpzLoad,
/* DEVconvTest */ BSIM3v1SconvTest,
/* DEVsenSetup */ NULL,
/* DEVsenLoad */ NULL,
/* DEVsenUpdate */ NULL,
/* DEVsenAcLoad */ NULL,
/* DEVsenPrint */ NULL,
/* DEVsenTrunc */ NULL,
/* DEVdisto */ NULL,
/* DEVnoise */ BSIM3v1Snoise,
#ifdef CIDER
/* DEVdump */ NULL,
/* DEVacct */ NULL,
#endif
/* DEVinstSize */ &BSIM3v1SiSize,
/* DEVmodSize */ &BSIM3v1SmSize
};
SPICEdev *
get_bsim3v1s_info(void)
{
return &BSIM3v1Sinfo;
}

13
src/spicelib/devices/bsim3v1s/bsim3v1sinit.h
View File

@ -1,13 +0,0 @@
#ifndef _BSIM3v1SINIT_H
#define _BSIM3v1SINIT_H
extern IFparm BSIM3v1SpTable[ ];
extern IFparm BSIM3v1SmPTable[ ];
extern char *BSIM3v1Snames[ ];
extern int BSIM3v1SpTSize;
extern int BSIM3v1SmPTSize;
extern int BSIM3v1SnSize;
extern int BSIM3v1SiSize;
extern int BSIM3v1SmSize;
#endif

12
src/spicelib/devices/bsim3v1s/bsim3v1sitf.h
View File

@ -1,12 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1991 JianHui Huang and Min-Chie Jeng.
Modified by Paolo Nenzi 2002
File: bsim3v1sitf.h
**********/
#ifndef DEV_BSIM3v1S
#define DEV_BSIM3v1S
SPICEdev *get_bsim3v1s_info(void);
#endif
Write Preview
Loading…
Cancel
Save