pnenzi
23 years ago
23 changed files with 9551 additions and 0 deletions
-
33src/spicelib/devices/bsim3v0/Makefile.am
-
429src/spicelib/devices/bsim3v0/b3v0.c
-
185src/spicelib/devices/bsim3v0/b3v0acld.c
-
221src/spicelib/devices/bsim3v0/b3v0ask.c
-
90src/spicelib/devices/bsim3v0/b3v0cvtest.c
-
38src/spicelib/devices/bsim3v0/b3v0del.c
-
36src/spicelib/devices/bsim3v0/b3v0dest.c
-
44src/spicelib/devices/bsim3v0/b3v0getic.c
-
1935src/spicelib/devices/bsim3v0/b3v0ld.c
-
1090src/spicelib/devices/bsim3v0/b3v0mask.c
-
42src/spicelib/devices/bsim3v0/b3v0mdel.c
-
1482src/spicelib/devices/bsim3v0/b3v0mpar.c
-
356src/spicelib/devices/bsim3v0/b3v0noi.c
-
96src/spicelib/devices/bsim3v0/b3v0par.c
-
150src/spicelib/devices/bsim3v0/b3v0pzld.c
-
926src/spicelib/devices/bsim3v0/b3v0set.c
-
631src/spicelib/devices/bsim3v0/b3v0temp.c
-
50src/spicelib/devices/bsim3v0/b3v0trunc.c
-
1580src/spicelib/devices/bsim3v0/bsim3v0def.h
-
30src/spicelib/devices/bsim3v0/bsim3v0ext.h
-
82src/spicelib/devices/bsim3v0/bsim3v0init.c
-
13src/spicelib/devices/bsim3v0/bsim3v0init.h
-
12src/spicelib/devices/bsim3v0/bsim3v0itf.h
@ -0,0 +1,33 @@ |
|||
## Process this file with automake to produce Makefile.in
|
|||
|
|||
noinst_LIBRARIES = libbsim3v0.a |
|||
|
|||
libbsim3v0_a_SOURCES = \
|
|||
b3v0.c \
|
|||
b3v0acld.c \
|
|||
b3v0ask.c \
|
|||
b3v0cvtest.c \
|
|||
b3v0del.c \
|
|||
b3v0dest.c \
|
|||
b3v0getic.c \
|
|||
b3v0ld.c \
|
|||
b3v0mask.c \
|
|||
b3v0mdel.c \
|
|||
b3v0mpar.c \
|
|||
b3v0noi.c \
|
|||
b3v0par.c \
|
|||
b3v0pzld.c \
|
|||
b3v0set.c \
|
|||
b3v0temp.c \
|
|||
b3v0trunc.c \
|
|||
bsim3v0def.h \
|
|||
bsim3v0ext.h \
|
|||
bsim3v0init.c \
|
|||
bsim3v0init.h \
|
|||
bsim3v0itf.h |
|||
|
|||
|
|||
|
|||
INCLUDES = -I$(top_srcdir)/src/include |
|||
|
|||
MAINTAINERCLEANFILES = Makefile.in |
|||
@ -0,0 +1,429 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "devdefs.h" |
|||
#include "bsim3v0def.h" |
|||
#include "suffix.h" |
|||
|
|||
IFparm BSIM3v0pTable[] = { /* parameters */ |
|||
IOP( "l", BSIM3v0_L, IF_REAL , "Length"), |
|||
IOP( "w", BSIM3v0_W, IF_REAL , "Width"), |
|||
IOP( "m", BSIM3v0_M, IF_REAL , "Parallel multiplier"), |
|||
IOP( "ad", BSIM3v0_AD, IF_REAL , "Drain area"), |
|||
IOP( "as", BSIM3v0_AS, IF_REAL , "Source area"), |
|||
IOP( "pd", BSIM3v0_PD, IF_REAL , "Drain perimeter"), |
|||
IOP( "ps", BSIM3v0_PS, IF_REAL , "Source perimeter"), |
|||
IOP( "nrd", BSIM3v0_NRD, IF_REAL , "Number of squares in drain"), |
|||
IOP( "nrs", BSIM3v0_NRS, IF_REAL , "Number of squares in source"), |
|||
IOP( "off", BSIM3v0_OFF, IF_FLAG , "Device is initially off"), |
|||
IOP( "nqsmod", BSIM3v0_NQSMOD, IF_INTEGER, "Non-quasi-static model selector"), |
|||
IP( "ic", BSIM3v0_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"), |
|||
OP( "gmbs", BSIM3v0_GMBS, IF_REAL, "Gmb"), |
|||
OP( "gm", BSIM3v0_GM, IF_REAL, "Gm"), |
|||
OP( "gds", BSIM3v0_GDS, IF_REAL, "Gds"), |
|||
OP( "vdsat", BSIM3v0_VDSAT, IF_REAL, "Vdsat"), |
|||
OP( "vth", BSIM3v0_VON, IF_REAL, "Vth"), |
|||
OP( "id", BSIM3v0_CD, IF_REAL, "Ids"), |
|||
OP( "vbs", BSIM3v0_VBS, IF_REAL, "Vbs"), |
|||
OP( "vgs", BSIM3v0_VGS, IF_REAL, "Vgs"), |
|||
OP( "vds", BSIM3v0_VDS, IF_REAL, "Vds"), |
|||
}; |
|||
|
|||
IFparm BSIM3v0mPTable[] = { /* model parameters */ |
|||
IOP( "capmod", BSIM3v0_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"), |
|||
IOP( "nqsmod", BSIM3v0_MOD_NQSMOD, IF_INTEGER, "Non-quasi-static model selector"), |
|||
IOP( "mobmod", BSIM3v0_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"), |
|||
IOP( "noimod", BSIM3v0_MOD_NOIMOD, IF_INTEGER, "Noise model selector"), |
|||
IOP( "binunit", BSIM3v0_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"), |
|||
IOP( "tox", BSIM3v0_MOD_TOX, IF_REAL, "Gate oxide thickness in meters"), |
|||
|
|||
IOP( "cdsc", BSIM3v0_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"), |
|||
IOP( "cdscb", BSIM3v0_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"), |
|||
IOP( "cdscd", BSIM3v0_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"), |
|||
IOP( "cit", BSIM3v0_MOD_CIT, IF_REAL, "Interface state capacitance"), |
|||
IOP( "nfactor", BSIM3v0_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"), |
|||
IOP( "xj", BSIM3v0_MOD_XJ, IF_REAL, "Junction depth in meters"), |
|||
IOP( "vsat", BSIM3v0_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"), |
|||
IOP( "at", BSIM3v0_MOD_AT, IF_REAL, "Temperature coefficient of vsat"), |
|||
IOP( "a0", BSIM3v0_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."), |
|||
IOP( "ags", BSIM3v0_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."), |
|||
IOP( "a1", BSIM3v0_MOD_A1, IF_REAL, "Non-saturation effect coefficient"), |
|||
IOP( "a2", BSIM3v0_MOD_A2, IF_REAL, "Non-saturation effect coefficient"), |
|||
IOP( "keta", BSIM3v0_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."), |
|||
IOP( "nsub", BSIM3v0_MOD_NSUB, IF_REAL, "Substrate doping concentration"), |
|||
IOP( "nch", BSIM3v0_MOD_NPEAK, IF_REAL, "Channel doping concentration"), |
|||
IOP( "ngate", BSIM3v0_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"), |
|||
IOP( "gamma1", BSIM3v0_MOD_GAMMA1, IF_REAL, "Vth body coefficient"), |
|||
IOP( "gamma2", BSIM3v0_MOD_GAMMA2, IF_REAL, "Vth body coefficient"), |
|||
IOP( "vbx", BSIM3v0_MOD_VBX, IF_REAL, "Vth transition body Voltage"), |
|||
IOP( "vbm", BSIM3v0_MOD_VBM, IF_REAL, "Maximum body voltage"), |
|||
|
|||
IOP( "xt", BSIM3v0_MOD_XT, IF_REAL, "Doping depth"), |
|||
IOP( "k1", BSIM3v0_MOD_K1, IF_REAL, "Bulk effect coefficient 1"), |
|||
IOP( "kt1", BSIM3v0_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"), |
|||
IOP( "kt1l", BSIM3v0_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"), |
|||
IOP( "kt2", BSIM3v0_MOD_KT2, IF_REAL, "Body-coefficient of kt1"), |
|||
IOP( "k2", BSIM3v0_MOD_K2, IF_REAL, "Bulk effect coefficient 2"), |
|||
IOP( "k3", BSIM3v0_MOD_K3, IF_REAL, "Narrow width effect coefficient"), |
|||
IOP( "k3b", BSIM3v0_MOD_K3B, IF_REAL, "Body effect coefficient of k3"), |
|||
IOP( "w0", BSIM3v0_MOD_W0, IF_REAL, "Narrow width effect parameter"), |
|||
IOP( "nlx", BSIM3v0_MOD_NLX, IF_REAL, "Lateral non-uniform doping effect"), |
|||
IOP( "dvt0", BSIM3v0_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"), |
|||
IOP( "dvt1", BSIM3v0_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"), |
|||
IOP( "dvt2", BSIM3v0_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"), |
|||
IOP( "dvt0w", BSIM3v0_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"), |
|||
IOP( "dvt1w", BSIM3v0_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"), |
|||
IOP( "dvt2w", BSIM3v0_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"), |
|||
IOP( "drout", BSIM3v0_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"), |
|||
IOP( "dsub", BSIM3v0_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"), |
|||
IOP( "vth0", BSIM3v0_MOD_VTH0, IF_REAL,"Threshold voltage"), |
|||
IOP( "vtho", BSIM3v0_MOD_VTH0, IF_REAL,"Threshold voltage"), |
|||
IOP( "ua", BSIM3v0_MOD_UA, IF_REAL, "Linear gate dependence of mobility"), |
|||
IOP( "ua1", BSIM3v0_MOD_UA1, IF_REAL, "Temperature coefficient of ua"), |
|||
IOP( "ub", BSIM3v0_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"), |
|||
IOP( "ub1", BSIM3v0_MOD_UB1, IF_REAL, "Temperature coefficient of ub"), |
|||
IOP( "uc", BSIM3v0_MOD_UC, IF_REAL, "Body-bias dependence of mobility"), |
|||
IOP( "uc1", BSIM3v0_MOD_UC1, IF_REAL, "Temperature coefficient of uc"), |
|||
IOP( "u0", BSIM3v0_MOD_U0, IF_REAL, "Low-field mobility at Tnom"), |
|||
IOP( "ute", BSIM3v0_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"), |
|||
IOP( "voff", BSIM3v0_MOD_VOFF, IF_REAL, "Threshold voltage offset"), |
|||
IOP( "tnom", BSIM3v0_MOD_TNOM, IF_REAL, "Parameter measurement temperature"), |
|||
IOP( "cgso", BSIM3v0_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"), |
|||
IOP( "cgdo", BSIM3v0_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"), |
|||
IOP( "cgbo", BSIM3v0_MOD_CGBO, IF_REAL, "Gate-bulk overlap capacitance per length"), |
|||
IOP( "xpart", BSIM3v0_MOD_XPART, IF_REAL, "Channel charge partitioning"), |
|||
IOP( "elm", BSIM3v0_MOD_ELM, IF_REAL, "Non-quasi-static Elmore Constant Parameter"), |
|||
IOP( "delta", BSIM3v0_MOD_DELTA, IF_REAL, "Effective Vds parameter"), |
|||
IOP( "rsh", BSIM3v0_MOD_RSH, IF_REAL, "Source-drain sheet resistance"), |
|||
IOP( "rdsw", BSIM3v0_MOD_RDSW, IF_REAL, "Source-drain resistance per width"), |
|||
|
|||
IOP( "prwg", BSIM3v0_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "), |
|||
IOP( "prwb", BSIM3v0_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "), |
|||
|
|||
IOP( "prt", BSIM3v0_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "), |
|||
IOP( "eta0", BSIM3v0_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"), |
|||
IOP( "etab", BSIM3v0_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"), |
|||
IOP( "pclm", BSIM3v0_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"), |
|||
IOP( "pdiblc1", BSIM3v0_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"), |
|||
IOP( "pdiblc2", BSIM3v0_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"), |
|||
IOP( "pdiblcb", BSIM3v0_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"), |
|||
IOP( "pscbe1", BSIM3v0_MOD_PSCBE1, IF_REAL, "Substrate current body-effect coefficient"), |
|||
IOP( "pscbe2", BSIM3v0_MOD_PSCBE2, IF_REAL, "Substrate current body-effect coefficient"), |
|||
IOP( "pvag", BSIM3v0_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"), |
|||
IOP( "js", BSIM3v0_MOD_JS, IF_REAL, "Source/drain junction reverse saturation current density"), |
|||
IOP( "pb", BSIM3v0_MOD_PB, IF_REAL, "Source/drain junction built-in potential"), |
|||
IOP( "mj", BSIM3v0_MOD_MJ, IF_REAL, "Source/drain bottom junction capacitance grading coefficient"), |
|||
IOP( "pbsw", BSIM3v0_MOD_PBSW, IF_REAL, "Source/drain sidewall junction capacitance built in potential"), |
|||
IOP( "mjsw", BSIM3v0_MOD_MJSW, IF_REAL, "Source/drain sidewall junction capacitance grading coefficient"), |
|||
IOP( "cj", BSIM3v0_MOD_CJ, IF_REAL, "Source/drain bottom junction capacitance per unit area"), |
|||
IOP( "cjsw", BSIM3v0_MOD_CJSW, IF_REAL, "Source/drain sidewall junction capacitance per unit area"), |
|||
|
|||
IOP( "lint", BSIM3v0_MOD_LINT, IF_REAL, "Length reduction parameter"), |
|||
IOP( "ll", BSIM3v0_MOD_LL, IF_REAL, "Length reduction parameter"), |
|||
IOP( "lln", BSIM3v0_MOD_LLN, IF_REAL, "Length reduction parameter"), |
|||
IOP( "lw", BSIM3v0_MOD_LW, IF_REAL, "Length reduction parameter"), |
|||
IOP( "lwn", BSIM3v0_MOD_LWN, IF_REAL, "Length reduction parameter"), |
|||
IOP( "lwl", BSIM3v0_MOD_LWL, IF_REAL, "Length reduction parameter"), |
|||
IOP( "lmin", BSIM3v0_MOD_LMIN, IF_REAL, "Minimum length for the model"), |
|||
IOP( "lmax", BSIM3v0_MOD_LMAX, IF_REAL, "Maximum length for the model"), |
|||
|
|||
IOP( "wr", BSIM3v0_MOD_WR, IF_REAL, "Width dependence of rds"), |
|||
IOP( "wint", BSIM3v0_MOD_WINT, IF_REAL, "Width reduction parameter"), |
|||
IOP( "dwg", BSIM3v0_MOD_DWG, IF_REAL, "Width reduction parameter"), |
|||
IOP( "dwb", BSIM3v0_MOD_DWB, IF_REAL, "Width reduction parameter"), |
|||
|
|||
IOP( "wl", BSIM3v0_MOD_WL, IF_REAL, "Width reduction parameter"), |
|||
IOP( "wln", BSIM3v0_MOD_WLN, IF_REAL, "Width reduction parameter"), |
|||
IOP( "ww", BSIM3v0_MOD_WW, IF_REAL, "Width reduction parameter"), |
|||
IOP( "wwn", BSIM3v0_MOD_WWN, IF_REAL, "Width reduction parameter"), |
|||
IOP( "wwl", BSIM3v0_MOD_WWL, IF_REAL, "Width reduction parameter"), |
|||
IOP( "wmin", BSIM3v0_MOD_WMIN, IF_REAL, "Minimum width for the model"), |
|||
IOP( "wmax", BSIM3v0_MOD_WMAX, IF_REAL, "Maximum width for the model"), |
|||
|
|||
IOP( "b0", BSIM3v0_MOD_B0, IF_REAL, "Abulk narrow width parameter"), |
|||
IOP( "b1", BSIM3v0_MOD_B1, IF_REAL, "Abulk narrow width parameter"), |
|||
|
|||
IOP( "cgsl", BSIM3v0_MOD_CGSL, IF_REAL, "New C-V model parameter"), |
|||
IOP( "cgdl", BSIM3v0_MOD_CGDL, IF_REAL, "New C-V model parameter"), |
|||
IOP( "ckappa", BSIM3v0_MOD_CKAPPA, IF_REAL, "New C-V model parameter"), |
|||
IOP( "cf", BSIM3v0_MOD_CF, IF_REAL, "Fringe capacitance parameter"), |
|||
IOP( "clc", BSIM3v0_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"), |
|||
IOP( "cle", BSIM3v0_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"), |
|||
IOP( "dwc", BSIM3v0_MOD_DWC, IF_REAL, "Delta W for C-V model"), |
|||
IOP( "dlc", BSIM3v0_MOD_DLC, IF_REAL, "Delta L for C-V model"), |
|||
|
|||
IOP( "alpha0", BSIM3v0_MOD_ALPHA0, IF_REAL, "substrate current model parameter"), |
|||
IOP( "beta0", BSIM3v0_MOD_BETA0, IF_REAL, "substrate current model parameter"), |
|||
|
|||
IOP( "lcdsc", BSIM3v0_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"), |
|||
IOP( "lcdscb", BSIM3v0_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"), |
|||
IOP( "lcdscd", BSIM3v0_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"), |
|||
IOP( "lcit", BSIM3v0_MOD_LCIT, IF_REAL, "Length dependence of cit"), |
|||
IOP( "lnfactor", BSIM3v0_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"), |
|||
IOP( "lxj", BSIM3v0_MOD_LXJ, IF_REAL, "Length dependence of xj"), |
|||
IOP( "lvsat", BSIM3v0_MOD_LVSAT, IF_REAL, "Length dependence of vsat"), |
|||
IOP( "lat", BSIM3v0_MOD_LAT, IF_REAL, "Length dependence of at"), |
|||
IOP( "la0", BSIM3v0_MOD_LA0, IF_REAL, "Length dependence of a0"), |
|||
IOP( "lags", BSIM3v0_MOD_LAGS, IF_REAL, "Length dependence of ags"), |
|||
IOP( "la1", BSIM3v0_MOD_LA1, IF_REAL, "Length dependence of a1"), |
|||
IOP( "la2", BSIM3v0_MOD_LA2, IF_REAL, "Length dependence of a2"), |
|||
IOP( "lketa", BSIM3v0_MOD_LKETA, IF_REAL, "Length dependence of keta"), |
|||
IOP( "lnsub", BSIM3v0_MOD_LNSUB, IF_REAL, "Length dependence of nsub"), |
|||
IOP( "lnch", BSIM3v0_MOD_LNPEAK, IF_REAL, "Length dependence of nch"), |
|||
IOP( "lngate", BSIM3v0_MOD_LNGATE, IF_REAL, "Length dependence of ngate"), |
|||
IOP( "lgamma1", BSIM3v0_MOD_LGAMMA1, IF_REAL, "Length dependence of gamma1"), |
|||
IOP( "lgamma2", BSIM3v0_MOD_LGAMMA2, IF_REAL, "Length dependence of gamma2"), |
|||
IOP( "lvbx", BSIM3v0_MOD_LVBX, IF_REAL, "Length dependence of vbx"), |
|||
IOP( "lvbm", BSIM3v0_MOD_LVBM, IF_REAL, "Length dependence of vbm"), |
|||
IOP( "lxt", BSIM3v0_MOD_LXT, IF_REAL, "Length dependence of xt"), |
|||
IOP( "lk1", BSIM3v0_MOD_LK1, IF_REAL, "Length dependence of k1"), |
|||
IOP( "lkt1", BSIM3v0_MOD_LKT1, IF_REAL, "Length dependence of kt1"), |
|||
IOP( "lkt1l", BSIM3v0_MOD_LKT1L, IF_REAL, "Length dependence of kt1l"), |
|||
IOP( "lkt2", BSIM3v0_MOD_LKT2, IF_REAL, "Length dependence of kt2"), |
|||
IOP( "lk2", BSIM3v0_MOD_LK2, IF_REAL, "Length dependence of k2"), |
|||
IOP( "lk3", BSIM3v0_MOD_LK3, IF_REAL, "Length dependence of k3"), |
|||
IOP( "lk3b", BSIM3v0_MOD_LK3B, IF_REAL, "Length dependence of k3b"), |
|||
IOP( "lw0", BSIM3v0_MOD_LW0, IF_REAL, "Length dependence of w0"), |
|||
IOP( "lnlx", BSIM3v0_MOD_LNLX, IF_REAL, "Length dependence of nlx"), |
|||
IOP( "ldvt0", BSIM3v0_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"), |
|||
IOP( "ldvt1", BSIM3v0_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"), |
|||
IOP( "ldvt2", BSIM3v0_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"), |
|||
IOP( "ldvt0w", BSIM3v0_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"), |
|||
IOP( "ldvt1w", BSIM3v0_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"), |
|||
IOP( "ldvt2w", BSIM3v0_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"), |
|||
IOP( "ldrout", BSIM3v0_MOD_LDROUT, IF_REAL, "Length dependence of drout"), |
|||
IOP( "ldsub", BSIM3v0_MOD_LDSUB, IF_REAL, "Length dependence of dsub"), |
|||
IOP( "lvth0", BSIM3v0_MOD_LVTH0, IF_REAL,"Length dependence of vto"), |
|||
IOP( "lvtho", BSIM3v0_MOD_LVTH0, IF_REAL,"Length dependence of vto"), |
|||
IOP( "lua", BSIM3v0_MOD_LUA, IF_REAL, "Length dependence of ua"), |
|||
IOP( "lua1", BSIM3v0_MOD_LUA1, IF_REAL, "Length dependence of ua1"), |
|||
IOP( "lub", BSIM3v0_MOD_LUB, IF_REAL, "Length dependence of ub"), |
|||
IOP( "lub1", BSIM3v0_MOD_LUB1, IF_REAL, "Length dependence of ub1"), |
|||
IOP( "luc", BSIM3v0_MOD_LUC, IF_REAL, "Length dependence of uc"), |
|||
IOP( "luc1", BSIM3v0_MOD_LUC1, IF_REAL, "Length dependence of uc1"), |
|||
IOP( "lu0", BSIM3v0_MOD_LU0, IF_REAL, "Length dependence of u0"), |
|||
IOP( "lute", BSIM3v0_MOD_LUTE, IF_REAL, "Length dependence of ute"), |
|||
IOP( "lvoff", BSIM3v0_MOD_LVOFF, IF_REAL, "Length dependence of voff"), |
|||
IOP( "lelm", BSIM3v0_MOD_LELM, IF_REAL, "Length dependence of elm"), |
|||
IOP( "ldelta", BSIM3v0_MOD_LDELTA, IF_REAL, "Length dependence of delta"), |
|||
IOP( "lrdsw", BSIM3v0_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "), |
|||
|
|||
IOP( "lprwg", BSIM3v0_MOD_LPRWG, IF_REAL, "Length dependence of prwg "), |
|||
IOP( "lprwb", BSIM3v0_MOD_LPRWB, IF_REAL, "Length dependence of prwb "), |
|||
|
|||
IOP( "lprt", BSIM3v0_MOD_LPRT, IF_REAL, "Length dependence of prt "), |
|||
IOP( "leta0", BSIM3v0_MOD_LETA0, IF_REAL, "Length dependence of eta0"), |
|||
IOP( "letab", BSIM3v0_MOD_LETAB, IF_REAL, "Length dependence of etab"), |
|||
IOP( "lpclm", BSIM3v0_MOD_LPCLM, IF_REAL, "Length dependence of pclm"), |
|||
IOP( "lpdiblc1", BSIM3v0_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"), |
|||
IOP( "lpdiblc2", BSIM3v0_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"), |
|||
IOP( "lpdiblcb", BSIM3v0_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"), |
|||
IOP( "lpscbe1", BSIM3v0_MOD_LPSCBE1, IF_REAL, "Length dependence of pscbe1"), |
|||
IOP( "lpscbe2", BSIM3v0_MOD_LPSCBE2, IF_REAL, "Length dependence of pscbe2"), |
|||
IOP( "lpvag", BSIM3v0_MOD_LPVAG, IF_REAL, "Length dependence of pvag"), |
|||
IOP( "lwr", BSIM3v0_MOD_LWR, IF_REAL, "Length dependence of wr"), |
|||
IOP( "ldwg", BSIM3v0_MOD_LDWG, IF_REAL, "Length dependence of dwg"), |
|||
IOP( "ldwb", BSIM3v0_MOD_LDWB, IF_REAL, "Length dependence of dwb"), |
|||
IOP( "lb0", BSIM3v0_MOD_LB0, IF_REAL, "Length dependence of b0"), |
|||
IOP( "lb1", BSIM3v0_MOD_LB1, IF_REAL, "Length dependence of b1"), |
|||
IOP( "lcgsl", BSIM3v0_MOD_LCGSL, IF_REAL, "Length dependence of cgsl"), |
|||
IOP( "lcgdl", BSIM3v0_MOD_LCGDL, IF_REAL, "Length dependence of cgdl"), |
|||
IOP( "lckappa", BSIM3v0_MOD_LCKAPPA, IF_REAL, "Length dependence of ckappa"), |
|||
IOP( "lcf", BSIM3v0_MOD_LCF, IF_REAL, "Length dependence of cf"), |
|||
IOP( "lclc", BSIM3v0_MOD_LCLC, IF_REAL, "Length dependence of clc"), |
|||
IOP( "lcle", BSIM3v0_MOD_LCLE, IF_REAL, "Length dependence of cle"), |
|||
IOP( "lalpha0", BSIM3v0_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"), |
|||
IOP( "lbeta0", BSIM3v0_MOD_LBETA0, IF_REAL, "Length dependence of beta0"), |
|||
|
|||
IOP( "wcdsc", BSIM3v0_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"), |
|||
IOP( "wcdscb", BSIM3v0_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"), |
|||
IOP( "wcdscd", BSIM3v0_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"), |
|||
IOP( "wcit", BSIM3v0_MOD_WCIT, IF_REAL, "Width dependence of cit"), |
|||
IOP( "wnfactor", BSIM3v0_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"), |
|||
IOP( "wxj", BSIM3v0_MOD_WXJ, IF_REAL, "Width dependence of xj"), |
|||
IOP( "wvsat", BSIM3v0_MOD_WVSAT, IF_REAL, "Width dependence of vsat"), |
|||
IOP( "wat", BSIM3v0_MOD_WAT, IF_REAL, "Width dependence of at"), |
|||
IOP( "wa0", BSIM3v0_MOD_WA0, IF_REAL, "Width dependence of a0"), |
|||
IOP( "wags", BSIM3v0_MOD_WAGS, IF_REAL, "Width dependence of ags"), |
|||
IOP( "wa1", BSIM3v0_MOD_WA1, IF_REAL, "Width dependence of a1"), |
|||
IOP( "wa2", BSIM3v0_MOD_WA2, IF_REAL, "Width dependence of a2"), |
|||
IOP( "wketa", BSIM3v0_MOD_WKETA, IF_REAL, "Width dependence of keta"), |
|||
IOP( "wnsub", BSIM3v0_MOD_WNSUB, IF_REAL, "Width dependence of nsub"), |
|||
IOP( "wnch", BSIM3v0_MOD_WNPEAK, IF_REAL, "Width dependence of nch"), |
|||
IOP( "wngate", BSIM3v0_MOD_WNGATE, IF_REAL, "Width dependence of ngate"), |
|||
IOP( "wgamma1", BSIM3v0_MOD_WGAMMA1, IF_REAL, "Width dependence of gamma1"), |
|||
IOP( "wgamma2", BSIM3v0_MOD_WGAMMA2, IF_REAL, "Width dependence of gamma2"), |
|||
IOP( "wvbx", BSIM3v0_MOD_WVBX, IF_REAL, "Width dependence of vbx"), |
|||
IOP( "wvbm", BSIM3v0_MOD_WVBM, IF_REAL, "Width dependence of vbm"), |
|||
IOP( "wxt", BSIM3v0_MOD_WXT, IF_REAL, "Width dependence of xt"), |
|||
IOP( "wk1", BSIM3v0_MOD_WK1, IF_REAL, "Width dependence of k1"), |
|||
IOP( "wkt1", BSIM3v0_MOD_WKT1, IF_REAL, "Width dependence of kt1"), |
|||
IOP( "wkt1l", BSIM3v0_MOD_WKT1L, IF_REAL, "Width dependence of kt1l"), |
|||
IOP( "wkt2", BSIM3v0_MOD_WKT2, IF_REAL, "Width dependence of kt2"), |
|||
IOP( "wk2", BSIM3v0_MOD_WK2, IF_REAL, "Width dependence of k2"), |
|||
IOP( "wk3", BSIM3v0_MOD_WK3, IF_REAL, "Width dependence of k3"), |
|||
IOP( "wk3b", BSIM3v0_MOD_WK3B, IF_REAL, "Width dependence of k3b"), |
|||
IOP( "ww0", BSIM3v0_MOD_WW0, IF_REAL, "Width dependence of w0"), |
|||
IOP( "wnlx", BSIM3v0_MOD_WNLX, IF_REAL, "Width dependence of nlx"), |
|||
IOP( "wdvt0", BSIM3v0_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"), |
|||
IOP( "wdvt1", BSIM3v0_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"), |
|||
IOP( "wdvt2", BSIM3v0_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"), |
|||
IOP( "wdvt0w", BSIM3v0_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"), |
|||
IOP( "wdvt1w", BSIM3v0_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"), |
|||
IOP( "wdvt2w", BSIM3v0_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"), |
|||
IOP( "wdrout", BSIM3v0_MOD_WDROUT, IF_REAL, "Width dependence of drout"), |
|||
IOP( "wdsub", BSIM3v0_MOD_WDSUB, IF_REAL, "Width dependence of dsub"), |
|||
IOP( "wvth0", BSIM3v0_MOD_WVTH0, IF_REAL,"Width dependence of vto"), |
|||
IOP( "wvtho", BSIM3v0_MOD_WVTH0, IF_REAL,"Width dependence of vto"), |
|||
IOP( "wua", BSIM3v0_MOD_WUA, IF_REAL, "Width dependence of ua"), |
|||
IOP( "wua1", BSIM3v0_MOD_WUA1, IF_REAL, "Width dependence of ua1"), |
|||
IOP( "wub", BSIM3v0_MOD_WUB, IF_REAL, "Width dependence of ub"), |
|||
IOP( "wub1", BSIM3v0_MOD_WUB1, IF_REAL, "Width dependence of ub1"), |
|||
IOP( "wuc", BSIM3v0_MOD_WUC, IF_REAL, "Width dependence of uc"), |
|||
IOP( "wuc1", BSIM3v0_MOD_WUC1, IF_REAL, "Width dependence of uc1"), |
|||
IOP( "wu0", BSIM3v0_MOD_WU0, IF_REAL, "Width dependence of u0"), |
|||
IOP( "wute", BSIM3v0_MOD_WUTE, IF_REAL, "Width dependence of ute"), |
|||
IOP( "wvoff", BSIM3v0_MOD_WVOFF, IF_REAL, "Width dependence of voff"), |
|||
IOP( "welm", BSIM3v0_MOD_WELM, IF_REAL, "Width dependence of elm"), |
|||
IOP( "wdelta", BSIM3v0_MOD_WDELTA, IF_REAL, "Width dependence of delta"), |
|||
IOP( "wrdsw", BSIM3v0_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "), |
|||
|
|||
IOP( "wprwg", BSIM3v0_MOD_WPRWG, IF_REAL, "Width dependence of prwg "), |
|||
IOP( "wprwb", BSIM3v0_MOD_WPRWB, IF_REAL, "Width dependence of prwb "), |
|||
|
|||
IOP( "wprt", BSIM3v0_MOD_WPRT, IF_REAL, "Width dependence of prt"), |
|||
IOP( "weta0", BSIM3v0_MOD_WETA0, IF_REAL, "Width dependence of eta0"), |
|||
IOP( "wetab", BSIM3v0_MOD_WETAB, IF_REAL, "Width dependence of etab"), |
|||
IOP( "wpclm", BSIM3v0_MOD_WPCLM, IF_REAL, "Width dependence of pclm"), |
|||
IOP( "wpdiblc1", BSIM3v0_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"), |
|||
IOP( "wpdiblc2", BSIM3v0_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"), |
|||
IOP( "wpdiblcb", BSIM3v0_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"), |
|||
IOP( "wpscbe1", BSIM3v0_MOD_WPSCBE1, IF_REAL, "Width dependence of pscbe1"), |
|||
IOP( "wpscbe2", BSIM3v0_MOD_WPSCBE2, IF_REAL, "Width dependence of pscbe2"), |
|||
IOP( "wpvag", BSIM3v0_MOD_WPVAG, IF_REAL, "Width dependence of pvag"), |
|||
IOP( "wwr", BSIM3v0_MOD_WWR, IF_REAL, "Width dependence of wr"), |
|||
IOP( "wdwg", BSIM3v0_MOD_WDWG, IF_REAL, "Width dependence of dwg"), |
|||
IOP( "wdwb", BSIM3v0_MOD_WDWB, IF_REAL, "Width dependence of dwb"), |
|||
IOP( "wb0", BSIM3v0_MOD_WB0, IF_REAL, "Width dependence of b0"), |
|||
IOP( "wb1", BSIM3v0_MOD_WB1, IF_REAL, "Width dependence of b1"), |
|||
IOP( "wcgsl", BSIM3v0_MOD_WCGSL, IF_REAL, "Width dependence of cgsl"), |
|||
IOP( "wcgdl", BSIM3v0_MOD_WCGDL, IF_REAL, "Width dependence of cgdl"), |
|||
IOP( "wckappa", BSIM3v0_MOD_WCKAPPA, IF_REAL, "Width dependence of ckappa"), |
|||
IOP( "wcf", BSIM3v0_MOD_WCF, IF_REAL, "Width dependence of cf"), |
|||
IOP( "wclc", BSIM3v0_MOD_WCLC, IF_REAL, "Width dependence of clc"), |
|||
IOP( "wcle", BSIM3v0_MOD_WCLE, IF_REAL, "Width dependence of cle"), |
|||
IOP( "walpha0", BSIM3v0_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"), |
|||
IOP( "wbeta0", BSIM3v0_MOD_WBETA0, IF_REAL, "Width dependence of beta0"), |
|||
|
|||
IOP( "pcdsc", BSIM3v0_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"), |
|||
IOP( "pcdscb", BSIM3v0_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"), |
|||
IOP( "pcdscd", BSIM3v0_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"), |
|||
IOP( "pcit", BSIM3v0_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"), |
|||
IOP( "pnfactor", BSIM3v0_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"), |
|||
IOP( "pxj", BSIM3v0_MOD_PXJ, IF_REAL, "Cross-term dependence of xj"), |
|||
IOP( "pvsat", BSIM3v0_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"), |
|||
IOP( "pat", BSIM3v0_MOD_PAT, IF_REAL, "Cross-term dependence of at"), |
|||
IOP( "pa0", BSIM3v0_MOD_PA0, IF_REAL, "Cross-term dependence of a0"), |
|||
IOP( "pags", BSIM3v0_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"), |
|||
IOP( "pa1", BSIM3v0_MOD_PA1, IF_REAL, "Cross-term dependence of a1"), |
|||
IOP( "pa2", BSIM3v0_MOD_PA2, IF_REAL, "Cross-term dependence of a2"), |
|||
IOP( "pketa", BSIM3v0_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"), |
|||
IOP( "pnsub", BSIM3v0_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"), |
|||
IOP( "pnch", BSIM3v0_MOD_PNPEAK, IF_REAL, "Cross-term dependence of nch"), |
|||
IOP( "pngate", BSIM3v0_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"), |
|||
IOP( "pgamma1", BSIM3v0_MOD_PGAMMA1, IF_REAL, "Cross-term dependence of gamma1"), |
|||
IOP( "pgamma2", BSIM3v0_MOD_PGAMMA2, IF_REAL, "Cross-term dependence of gamma2"), |
|||
IOP( "pvbx", BSIM3v0_MOD_PVBX, IF_REAL, "Cross-term dependence of vbx"), |
|||
IOP( "pvbm", BSIM3v0_MOD_PVBM, IF_REAL, "Cross-term dependence of vbm"), |
|||
IOP( "pxt", BSIM3v0_MOD_PXT, IF_REAL, "Cross-term dependence of xt"), |
|||
IOP( "pk1", BSIM3v0_MOD_PK1, IF_REAL, "Cross-term dependence of k1"), |
|||
IOP( "pkt1", BSIM3v0_MOD_PKT1, IF_REAL, "Cross-term dependence of kt1"), |
|||
IOP( "pkt1l", BSIM3v0_MOD_PKT1L, IF_REAL, "Cross-term dependence of kt1l"), |
|||
IOP( "pkt2", BSIM3v0_MOD_PKT2, IF_REAL, "Cross-term dependence of kt2"), |
|||
IOP( "pk2", BSIM3v0_MOD_PK2, IF_REAL, "Cross-term dependence of k2"), |
|||
IOP( "pk3", BSIM3v0_MOD_PK3, IF_REAL, "Cross-term dependence of k3"), |
|||
IOP( "pk3b", BSIM3v0_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"), |
|||
IOP( "pw0", BSIM3v0_MOD_PW0, IF_REAL, "Cross-term dependence of w0"), |
|||
IOP( "pnlx", BSIM3v0_MOD_PNLX, IF_REAL, "Cross-term dependence of nlx"), |
|||
IOP( "pdvt0", BSIM3v0_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"), |
|||
IOP( "pdvt1", BSIM3v0_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"), |
|||
IOP( "pdvt2", BSIM3v0_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"), |
|||
IOP( "pdvt0w", BSIM3v0_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"), |
|||
IOP( "pdvt1w", BSIM3v0_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"), |
|||
IOP( "pdvt2w", BSIM3v0_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"), |
|||
IOP( "pdrout", BSIM3v0_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"), |
|||
IOP( "pdsub", BSIM3v0_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"), |
|||
IOP( "pvth0", BSIM3v0_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"), |
|||
IOP( "pvtho", BSIM3v0_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"), |
|||
IOP( "pua", BSIM3v0_MOD_PUA, IF_REAL, "Cross-term dependence of ua"), |
|||
IOP( "pua1", BSIM3v0_MOD_PUA1, IF_REAL, "Cross-term dependence of ua1"), |
|||
IOP( "pub", BSIM3v0_MOD_PUB, IF_REAL, "Cross-term dependence of ub"), |
|||
IOP( "pub1", BSIM3v0_MOD_PUB1, IF_REAL, "Cross-term dependence of ub1"), |
|||
IOP( "puc", BSIM3v0_MOD_PUC, IF_REAL, "Cross-term dependence of uc"), |
|||
IOP( "puc1", BSIM3v0_MOD_PUC1, IF_REAL, "Cross-term dependence of uc1"), |
|||
IOP( "pu0", BSIM3v0_MOD_PU0, IF_REAL, "Cross-term dependence of u0"), |
|||
IOP( "pute", BSIM3v0_MOD_PUTE, IF_REAL, "Cross-term dependence of ute"), |
|||
IOP( "pvoff", BSIM3v0_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"), |
|||
IOP( "pelm", BSIM3v0_MOD_PELM, IF_REAL, "Cross-term dependence of elm"), |
|||
IOP( "pdelta", BSIM3v0_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"), |
|||
IOP( "prdsw", BSIM3v0_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "), |
|||
|
|||
IOP( "pprwg", BSIM3v0_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "), |
|||
IOP( "pprwb", BSIM3v0_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "), |
|||
|
|||
IOP( "pprt", BSIM3v0_MOD_PPRT, IF_REAL, "Cross-term dependence of prt "), |
|||
IOP( "peta0", BSIM3v0_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"), |
|||
IOP( "petab", BSIM3v0_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"), |
|||
IOP( "ppclm", BSIM3v0_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"), |
|||
IOP( "ppdiblc1", BSIM3v0_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"), |
|||
IOP( "ppdiblc2", BSIM3v0_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"), |
|||
IOP( "ppdiblcb", BSIM3v0_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"), |
|||
IOP( "ppscbe1", BSIM3v0_MOD_PPSCBE1, IF_REAL, "Cross-term dependence of pscbe1"), |
|||
IOP( "ppscbe2", BSIM3v0_MOD_PPSCBE2, IF_REAL, "Cross-term dependence of pscbe2"), |
|||
IOP( "ppvag", BSIM3v0_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"), |
|||
IOP( "pwr", BSIM3v0_MOD_PWR, IF_REAL, "Cross-term dependence of wr"), |
|||
IOP( "pdwg", BSIM3v0_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"), |
|||
IOP( "pdwb", BSIM3v0_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"), |
|||
IOP( "pb0", BSIM3v0_MOD_PB0, IF_REAL, "Cross-term dependence of b0"), |
|||
IOP( "pb1", BSIM3v0_MOD_PB1, IF_REAL, "Cross-term dependence of b1"), |
|||
IOP( "pcgsl", BSIM3v0_MOD_PCGSL, IF_REAL, "Cross-term dependence of cgsl"), |
|||
IOP( "pcgdl", BSIM3v0_MOD_PCGDL, IF_REAL, "Cross-term dependence of cgdl"), |
|||
IOP( "pckappa", BSIM3v0_MOD_PCKAPPA, IF_REAL, "Cross-term dependence of ckappa"), |
|||
IOP( "pcf", BSIM3v0_MOD_PCF, IF_REAL, "Cross-term dependence of cf"), |
|||
IOP( "pclc", BSIM3v0_MOD_PCLC, IF_REAL, "Cross-term dependence of clc"), |
|||
IOP( "pcle", BSIM3v0_MOD_PCLE, IF_REAL, "Cross-term dependence of cle"), |
|||
IOP( "palpha0", BSIM3v0_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"), |
|||
IOP( "pbeta0", BSIM3v0_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"), |
|||
|
|||
IOP( "noia", BSIM3v0_MOD_NOIA, IF_REAL, "Flicker noise parameter"), |
|||
IOP( "noib", BSIM3v0_MOD_NOIB, IF_REAL, "Flicker noise parameter"), |
|||
IOP( "noic", BSIM3v0_MOD_NOIC, IF_REAL, "Flicker noise parameter"), |
|||
IOP( "em", BSIM3v0_MOD_EM, IF_REAL, "Flicker noise parameter"), |
|||
IOP( "ef", BSIM3v0_MOD_EF, IF_REAL, "Flicker noise frequency exponent"), |
|||
IOP( "af", BSIM3v0_MOD_AF, IF_REAL, "Flicker noise exponent"), |
|||
IOP( "kf", BSIM3v0_MOD_KF, IF_REAL, "Flicker noise coefficient"), |
|||
|
|||
IP( "nmos", BSIM3v0_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"), |
|||
IP( "pmos", BSIM3v0_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"), |
|||
}; |
|||
|
|||
char *BSIM3v0names[] = { |
|||
"Drain", |
|||
"Gate", |
|||
"Source", |
|||
"Bulk", |
|||
"Charge" |
|||
}; |
|||
|
|||
int BSIM3v0nSize = NUMELEMS(BSIM3v0names); |
|||
int BSIM3v0pTSize = NUMELEMS(BSIM3v0pTable); |
|||
int BSIM3v0mPTSize = NUMELEMS(BSIM3v0mPTable); |
|||
int BSIM3v0iSize = sizeof(BSIM3v0instance); |
|||
int BSIM3v0mSize = sizeof(BSIM3v0model); |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,185 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0acld.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "cktdefs.h" |
|||
#include "bsim3v0def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
|
|||
int |
|||
BSIM3v0acLoad(GENmodel *inModel, CKTcircuit *ckt) |
|||
{ |
|||
BSIM3v0model *model = (BSIM3v0model*)inModel; |
|||
BSIM3v0instance *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; |
|||
|
|||
double m; |
|||
|
|||
omega = ckt->CKTomega; |
|||
for (; model != NULL; model = model->BSIM3v0nextModel) |
|||
{ |
|||
|
|||
|
|||
for (here = model->BSIM3v0instances; here!= NULL; |
|||
here = here->BSIM3v0nextInstance) |
|||
{ |
|||
|
|||
if (here->BSIM3v0owner != ARCHme) |
|||
continue; |
|||
|
|||
|
|||
if (here->BSIM3v0mode >= 0) |
|||
{ Gm = here->BSIM3v0gm; |
|||
Gmbs = here->BSIM3v0gmbs; |
|||
FwdSum = Gm + Gmbs; |
|||
RevSum = 0.0; |
|||
cggb = here->BSIM3v0cggb; |
|||
cgsb = here->BSIM3v0cgsb; |
|||
cgdb = here->BSIM3v0cgdb; |
|||
|
|||
cbgb = here->BSIM3v0cbgb; |
|||
cbsb = here->BSIM3v0cbsb; |
|||
cbdb = here->BSIM3v0cbdb; |
|||
|
|||
cdgb = here->BSIM3v0cdgb; |
|||
cdsb = here->BSIM3v0cdsb; |
|||
cddb = here->BSIM3v0cddb; |
|||
|
|||
cqgb = here->BSIM3v0cqgb; |
|||
cqdb = here->BSIM3v0cqdb; |
|||
cqsb = here->BSIM3v0cqsb; |
|||
cqbb = here->BSIM3v0cqbb; |
|||
sxpart = 0.6; |
|||
dxpart = 0.4; |
|||
|
|||
} |
|||
else |
|||
{ Gm = -here->BSIM3v0gm; |
|||
Gmbs = -here->BSIM3v0gmbs; |
|||
FwdSum = 0.0; |
|||
RevSum = -Gm - Gmbs; |
|||
cggb = here->BSIM3v0cggb; |
|||
cgsb = here->BSIM3v0cgdb; |
|||
cgdb = here->BSIM3v0cgsb; |
|||
|
|||
cbgb = here->BSIM3v0cbgb; |
|||
cbsb = here->BSIM3v0cbdb; |
|||
cbdb = here->BSIM3v0cbsb; |
|||
|
|||
cdgb = -(here->BSIM3v0cdgb + cggb + cbgb); |
|||
cdsb = -(here->BSIM3v0cddb + cgsb + cbsb); |
|||
cddb = -(here->BSIM3v0cdsb + cgdb + cbdb); |
|||
|
|||
cqgb = here->BSIM3v0cqgb; |
|||
cqdb = here->BSIM3v0cqsb; |
|||
cqsb = here->BSIM3v0cqdb; |
|||
cqbb = here->BSIM3v0cqbb; |
|||
sxpart = 0.4; |
|||
dxpart = 0.6; |
|||
} |
|||
|
|||
gdpr=here->BSIM3v0drainConductance; |
|||
gspr=here->BSIM3v0sourceConductance; |
|||
gds= here->BSIM3v0gds; |
|||
gbd= here->BSIM3v0gbd; |
|||
gbs= here->BSIM3v0gbs; |
|||
capbd= here->BSIM3v0capbd; |
|||
capbs= here->BSIM3v0capbs; |
|||
|
|||
GSoverlapCap = here->BSIM3v0cgso; |
|||
GDoverlapCap = here->BSIM3v0cgdo; |
|||
GBoverlapCap = here->pParam->BSIM3v0cgbo; |
|||
|
|||
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; |
|||
|
|||
m = here->BSIM3v0m; |
|||
|
|||
*(here->BSIM3v0GgPtr +1) += m * xcggb; |
|||
*(here->BSIM3v0BbPtr +1) -= m * (xcbgb + xcbdb + xcbsb); |
|||
*(here->BSIM3v0DPdpPtr +1) += m * xcddb; |
|||
*(here->BSIM3v0SPspPtr +1) += m * xcssb; |
|||
*(here->BSIM3v0GbPtr +1) -= m * (xcggb + xcgdb + xcgsb); |
|||
*(here->BSIM3v0GdpPtr +1) += m * xcgdb; |
|||
*(here->BSIM3v0GspPtr +1) += m * xcgsb; |
|||
*(here->BSIM3v0BgPtr +1) += m * xcbgb; |
|||
*(here->BSIM3v0BdpPtr +1) += m * xcbdb; |
|||
*(here->BSIM3v0BspPtr +1) += m * xcbsb; |
|||
*(here->BSIM3v0DPgPtr +1) += m * xcdgb; |
|||
*(here->BSIM3v0DPbPtr +1) -= m * (xcdgb + xcddb + xcdsb); |
|||
*(here->BSIM3v0DPspPtr +1) += m * xcdsb; |
|||
*(here->BSIM3v0SPgPtr +1) += m * xcsgb; |
|||
*(here->BSIM3v0SPbPtr +1) -= m * (xcsgb + xcsdb + xcssb); |
|||
*(here->BSIM3v0SPdpPtr +1) += m * xcsdb; |
|||
|
|||
*(here->BSIM3v0QqPtr +1) += m * omega; |
|||
|
|||
*(here->BSIM3v0QgPtr +1) -= m * xcqgb; |
|||
*(here->BSIM3v0QdpPtr +1) -= m * xcqdb; |
|||
*(here->BSIM3v0QspPtr +1) -= m * xcqsb; |
|||
*(here->BSIM3v0QbPtr +1) -= m * xcqbb; |
|||
|
|||
|
|||
*(here->BSIM3v0DdPtr) += m * gdpr; |
|||
*(here->BSIM3v0SsPtr) += m * gspr; |
|||
*(here->BSIM3v0BbPtr) += m * (gbd + gbs); |
|||
*(here->BSIM3v0DPdpPtr) += m * (gdpr + gds + gbd + RevSum + dxpart*here->BSIM3v0gtd); |
|||
*(here->BSIM3v0SPspPtr) += m * (gspr + gds + gbs + FwdSum + sxpart*here->BSIM3v0gts); |
|||
*(here->BSIM3v0DdpPtr) -= m * gdpr; |
|||
*(here->BSIM3v0SspPtr) -= m * gspr; |
|||
*(here->BSIM3v0BdpPtr) -= m * gbd; |
|||
*(here->BSIM3v0BspPtr) -= m * gbs; |
|||
*(here->BSIM3v0DPdPtr) -= m * gdpr; |
|||
*(here->BSIM3v0DPgPtr) += m * (Gm + dxpart * here->BSIM3v0gtg); |
|||
*(here->BSIM3v0DPbPtr) -= m * (gbd - Gmbs - dxpart * here->BSIM3v0gtb); |
|||
*(here->BSIM3v0DPspPtr) -= m * (gds + FwdSum - dxpart * here->BSIM3v0gts); |
|||
*(here->BSIM3v0SPgPtr) -= m * (Gm - sxpart * here->BSIM3v0gtg); |
|||
*(here->BSIM3v0SPsPtr) -= m * gspr; |
|||
*(here->BSIM3v0SPbPtr) -= m * (gbs + Gmbs - sxpart * here->BSIM3v0gtg); |
|||
*(here->BSIM3v0SPdpPtr) -= m * (gds + RevSum - sxpart * here->BSIM3v0gtd); |
|||
*(here->BSIM3v0GgPtr) -= m * here->BSIM3v0gtg; |
|||
*(here->BSIM3v0GbPtr) -= m * here->BSIM3v0gtb; |
|||
*(here->BSIM3v0GdpPtr) -= m * here->BSIM3v0gtd; |
|||
*(here->BSIM3v0GspPtr) -= m * here->BSIM3v0gts; |
|||
|
|||
*(here->BSIM3v0QqPtr) += m * here->BSIM3v0gtau; |
|||
|
|||
*(here->BSIM3v0DPqPtr) += m * (dxpart * here->BSIM3v0gtau); |
|||
*(here->BSIM3v0SPqPtr) += m * (sxpart * here->BSIM3v0gtau); |
|||
*(here->BSIM3v0GqPtr) -= m * here->BSIM3v0gtau; |
|||
|
|||
*(here->BSIM3v0QgPtr) += m * here->BSIM3v0gtg; |
|||
*(here->BSIM3v0QdpPtr) += m * here->BSIM3v0gtd; |
|||
*(here->BSIM3v0QspPtr) += m * here->BSIM3v0gts; |
|||
*(here->BSIM3v0QbPtr) += m * here->BSIM3v0gtb; |
|||
|
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
@ -0,0 +1,221 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0ask.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "ifsim.h" |
|||
#include "cktdefs.h" |
|||
#include "devdefs.h" |
|||
#include "bsim3v0def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int |
|||
BSIM3v0ask(CKTcircuit *ckt, GENinstance *inst, int which, IFvalue *value, |
|||
IFvalue *select) |
|||
{ |
|||
BSIM3v0instance *here = (BSIM3v0instance*)inst; |
|||
|
|||
switch(which) |
|||
{ case BSIM3v0_L: |
|||
value->rValue = here->BSIM3v0l; |
|||
return(OK); |
|||
case BSIM3v0_W: |
|||
value->rValue = here->BSIM3v0w; |
|||
return(OK); |
|||
case BSIM3v0_M: |
|||
value->rValue = here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_AS: |
|||
value->rValue = here->BSIM3v0sourceArea; |
|||
return(OK); |
|||
case BSIM3v0_AD: |
|||
value->rValue = here->BSIM3v0drainArea; |
|||
return(OK); |
|||
case BSIM3v0_PS: |
|||
value->rValue = here->BSIM3v0sourcePerimeter; |
|||
return(OK); |
|||
case BSIM3v0_PD: |
|||
value->rValue = here->BSIM3v0drainPerimeter; |
|||
return(OK); |
|||
case BSIM3v0_NRS: |
|||
value->rValue = here->BSIM3v0sourceSquares; |
|||
return(OK); |
|||
case BSIM3v0_NRD: |
|||
value->rValue = here->BSIM3v0drainSquares; |
|||
return(OK); |
|||
case BSIM3v0_OFF: |
|||
value->rValue = here->BSIM3v0off; |
|||
return(OK); |
|||
case BSIM3v0_NQSMOD: |
|||
value->iValue = here->BSIM3v0nqsMod; |
|||
return(OK); |
|||
case BSIM3v0_IC_VBS: |
|||
value->rValue = here->BSIM3v0icVBS; |
|||
return(OK); |
|||
case BSIM3v0_IC_VDS: |
|||
value->rValue = here->BSIM3v0icVDS; |
|||
return(OK); |
|||
case BSIM3v0_IC_VGS: |
|||
value->rValue = here->BSIM3v0icVGS; |
|||
return(OK); |
|||
case BSIM3v0_DNODE: |
|||
value->iValue = here->BSIM3v0dNode; |
|||
return(OK); |
|||
case BSIM3v0_GNODE: |
|||
value->iValue = here->BSIM3v0gNode; |
|||
return(OK); |
|||
case BSIM3v0_SNODE: |
|||
value->iValue = here->BSIM3v0sNode; |
|||
return(OK); |
|||
case BSIM3v0_BNODE: |
|||
value->iValue = here->BSIM3v0bNode; |
|||
return(OK); |
|||
case BSIM3v0_DNODEPRIME: |
|||
value->iValue = here->BSIM3v0dNodePrime; |
|||
return(OK); |
|||
case BSIM3v0_SNODEPRIME: |
|||
value->iValue = here->BSIM3v0sNodePrime; |
|||
return(OK); |
|||
case BSIM3v0_SOURCECONDUCT: |
|||
value->rValue = here->BSIM3v0sourceConductance; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_DRAINCONDUCT: |
|||
value->rValue = here->BSIM3v0drainConductance; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_VBD: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0vbd); |
|||
return(OK); |
|||
case BSIM3v0_VBS: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0vbs); |
|||
return(OK); |
|||
case BSIM3v0_VGS: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0vgs); |
|||
return(OK); |
|||
case BSIM3v0_VDS: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0vds); |
|||
return(OK); |
|||
case BSIM3v0_CD: |
|||
value->rValue = here->BSIM3v0cd; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CBS: |
|||
value->rValue = here->BSIM3v0cbs; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CBD: |
|||
value->rValue = here->BSIM3v0cbd; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_GM: |
|||
value->rValue = here->BSIM3v0gm; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_GDS: |
|||
value->rValue = here->BSIM3v0gds; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_GMBS: |
|||
value->rValue = here->BSIM3v0gmbs; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_GBD: |
|||
value->rValue = here->BSIM3v0gbd; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_GBS: |
|||
value->rValue = here->BSIM3v0gbs; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_QB: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0qb); |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CQB: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0cqb); |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_QG: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0qg); |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CQG: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0cqg); |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_QD: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0qd); |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CQD: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0cqd); |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CGG: |
|||
value->rValue = here->BSIM3v0cggb; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CGD: |
|||
value->rValue = here->BSIM3v0cgdb; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CGS: |
|||
value->rValue = here->BSIM3v0cgsb; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CDG: |
|||
value->rValue = here->BSIM3v0cdgb; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CDD: |
|||
value->rValue = here->BSIM3v0cddb; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CDS: |
|||
value->rValue = here->BSIM3v0cdsb; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CBG: |
|||
value->rValue = here->BSIM3v0cbgb; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CBDB: |
|||
value->rValue = here->BSIM3v0cbdb; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CBSB: |
|||
value->rValue = here->BSIM3v0cbsb; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CAPBD: |
|||
value->rValue = here->BSIM3v0capbd; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_CAPBS: |
|||
value->rValue = here->BSIM3v0capbs; |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_VON: |
|||
value->rValue = here->BSIM3v0von; |
|||
return(OK); |
|||
case BSIM3v0_VDSAT: |
|||
value->rValue = here->BSIM3v0vdsat; |
|||
return(OK); |
|||
case BSIM3v0_QBS: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0qbs); |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
case BSIM3v0_QBD: |
|||
value->rValue = *(ckt->CKTstate0 + here->BSIM3v0qbd); |
|||
value->rValue *= here->BSIM3v0m; |
|||
return(OK); |
|||
default: |
|||
return(E_BADPARM); |
|||
} |
|||
/* NOTREACHED */ |
|||
} |
|||
|
|||
@ -0,0 +1,90 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0cvtest.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "cktdefs.h" |
|||
#include "bsim3v0def.h" |
|||
#include "trandefs.h" |
|||
#include "const.h" |
|||
#include "devdefs.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
|
|||
int |
|||
BSIM3v0convTest(GENmodel *inModel, CKTcircuit *ckt) |
|||
{ |
|||
BSIM3v0model *model = (BSIM3v0model*)inModel; |
|||
BSIM3v0instance *here; |
|||
double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds; |
|||
double cbd, cbhat, cbs, cd, cdhat, tol, vgd, vgdo, vgs; |
|||
|
|||
/* loop through all the BSIM3v0 device models */ |
|||
for (; model != NULL; model = model->BSIM3v0nextModel) |
|||
{ /* loop through all the instances of the model */ |
|||
for (here = model->BSIM3v0instances; here != NULL ; |
|||
here=here->BSIM3v0nextInstance) |
|||
{ |
|||
|
|||
if (here->BSIM3v0owner != ARCHme) |
|||
continue; |
|||
|
|||
vbs = model->BSIM3v0type |
|||
* (*(ckt->CKTrhsOld+here->BSIM3v0bNode) |
|||
- *(ckt->CKTrhsOld+here->BSIM3v0sNodePrime)); |
|||
vgs = model->BSIM3v0type |
|||
* (*(ckt->CKTrhsOld+here->BSIM3v0gNode) |
|||
- *(ckt->CKTrhsOld+here->BSIM3v0sNodePrime)); |
|||
vds = model->BSIM3v0type |
|||
* (*(ckt->CKTrhsOld+here->BSIM3v0dNodePrime) |
|||
- *(ckt->CKTrhsOld+here->BSIM3v0sNodePrime)); |
|||
vbd = vbs - vds; |
|||
vgd = vgs - vds; |
|||
vgdo = *(ckt->CKTstate0 + here->BSIM3v0vgs) |
|||
- *(ckt->CKTstate0 + here->BSIM3v0vds); |
|||
delvbs = vbs - *(ckt->CKTstate0 + here->BSIM3v0vbs); |
|||
delvbd = vbd - *(ckt->CKTstate0 + here->BSIM3v0vbd); |
|||
delvgs = vgs - *(ckt->CKTstate0 + here->BSIM3v0vgs); |
|||
delvds = vds - *(ckt->CKTstate0 + here->BSIM3v0vds); |
|||
delvgd = vgd-vgdo; |
|||
|
|||
cd = here->BSIM3v0cd; |
|||
if (here->BSIM3v0mode >= 0) |
|||
{ cdhat = cd - here->BSIM3v0gbd * delvbd |
|||
+ here->BSIM3v0gmbs * delvbs + here->BSIM3v0gm * delvgs |
|||
+ here->BSIM3v0gds * delvds; |
|||
} |
|||
else |
|||
{ cdhat = cd - (here->BSIM3v0gbd - here->BSIM3v0gmbs) * delvbd |
|||
- here->BSIM3v0gm * delvgd + here->BSIM3v0gds * delvds; |
|||
} |
|||
|
|||
/* |
|||
* check convergence |
|||
*/ |
|||
if ((here->BSIM3v0off == 0) || (!(ckt->CKTmode & MODEINITFIX))) |
|||
{ tol = ckt->CKTreltol * MAX(fabs(cdhat), fabs(cd)) |
|||
+ ckt->CKTabstol; |
|||
if (fabs(cdhat - cd) >= tol) |
|||
{ ckt->CKTnoncon++; |
|||
return(OK); |
|||
} |
|||
cbs = here->BSIM3v0cbs; |
|||
cbd = here->BSIM3v0cbd; |
|||
cbhat = cbs + cbd + here->BSIM3v0gbd * delvbd |
|||
+ here->BSIM3v0gbs * delvbs; |
|||
tol = ckt->CKTreltol * MAX(fabs(cbhat), fabs(cbs + cbd)) |
|||
+ ckt->CKTabstol; |
|||
if (fabs(cbhat - (cbs + cbd)) > tol) |
|||
{ ckt->CKTnoncon++; |
|||
return(OK); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
@ -0,0 +1,38 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0del.c |
|||
**********/ |
|||
/* |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "bsim3v0def.h" |
|||
#include "sperror.h" |
|||
#include "gendefs.h" |
|||
#include "suffix.h" |
|||
|
|||
|
|||
int |
|||
BSIM3v0delete(GENmodel *inModel, IFuid name, GENinstance **inInst) |
|||
{ |
|||
BSIM3v0instance **fast = (BSIM3v0instance**)inInst; |
|||
BSIM3v0model *model = (BSIM3v0model*)inModel; |
|||
BSIM3v0instance **prev = NULL; |
|||
BSIM3v0instance *here; |
|||
|
|||
for (; model ; model = model->BSIM3v0nextModel) |
|||
{ prev = &(model->BSIM3v0instances); |
|||
for (here = *prev; here ; here = *prev) |
|||
{ if (here->BSIM3v0name == name || (fast && here==*fast)) |
|||
{ *prev= here->BSIM3v0nextInstance; |
|||
FREE(here); |
|||
return(OK); |
|||
} |
|||
prev = &(here->BSIM3v0nextInstance); |
|||
} |
|||
} |
|||
return(E_NODEV); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,36 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0dest.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "bsim3v0def.h" |
|||
#include "suffix.h" |
|||
|
|||
void |
|||
BSIM3v0destroy(GENmodel **inModel) |
|||
{ |
|||
BSIM3v0model **model = (BSIM3v0model**)inModel; |
|||
BSIM3v0instance *here; |
|||
BSIM3v0instance *prev = NULL; |
|||
BSIM3v0model *mod = *model; |
|||
BSIM3v0model *oldmod = NULL; |
|||
|
|||
for (; mod ; mod = mod->BSIM3v0nextModel) |
|||
{ if(oldmod) FREE(oldmod); |
|||
oldmod = mod; |
|||
prev = (BSIM3v0instance *)NULL; |
|||
for (here = mod->BSIM3v0instances; here; here = here->BSIM3v0nextInstance) |
|||
{ if(prev) FREE(prev); |
|||
prev = here; |
|||
} |
|||
if(prev) FREE(prev); |
|||
} |
|||
if(oldmod) FREE(oldmod); |
|||
*model = NULL; |
|||
return; |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,44 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0getic.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "cktdefs.h" |
|||
#include "bsim3v0def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
|
|||
int |
|||
BSIM3v0getic(GENmodel *inModel, CKTcircuit *ckt) |
|||
{ |
|||
BSIM3v0model *model = (BSIM3v0model*)inModel; |
|||
BSIM3v0instance *here; |
|||
|
|||
for (; model ; model = model->BSIM3v0nextModel) |
|||
{ for (here = model->BSIM3v0instances; here; here = here->BSIM3v0nextInstance) |
|||
{ |
|||
|
|||
if (here->BSIM3v0owner != ARCHme) |
|||
continue; |
|||
|
|||
if(!here->BSIM3v0icVBSGiven) |
|||
{ here->BSIM3v0icVBS = *(ckt->CKTrhs + here->BSIM3v0bNode) |
|||
- *(ckt->CKTrhs + here->BSIM3v0sNode); |
|||
} |
|||
if (!here->BSIM3v0icVDSGiven) |
|||
{ here->BSIM3v0icVDS = *(ckt->CKTrhs + here->BSIM3v0dNode) |
|||
- *(ckt->CKTrhs + here->BSIM3v0sNode); |
|||
} |
|||
if (!here->BSIM3v0icVGSGiven) |
|||
{ here->BSIM3v0icVGS = *(ckt->CKTrhs + here->BSIM3v0gNode) |
|||
- *(ckt->CKTrhs + here->BSIM3v0sNode); |
|||
} |
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
|
|||
1935
src/spicelib/devices/bsim3v0/b3v0ld.c
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
1090
src/spicelib/devices/bsim3v0/b3v0mask.c
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,42 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0mdel.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "bsim3v0def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int |
|||
BSIM3v0mDelete(GENmodel **inModel, IFuid modname, GENmodel *kill) |
|||
{ |
|||
BSIM3v0model **model = (BSIM3v0model**)inModel; |
|||
BSIM3v0model *modfast = (BSIM3v0model*)kill; |
|||
BSIM3v0instance *here; |
|||
BSIM3v0instance *prev = NULL; |
|||
BSIM3v0model **oldmod; |
|||
|
|||
oldmod = model; |
|||
for (; *model ; model = &((*model)->BSIM3v0nextModel)) |
|||
{ if ((*model)->BSIM3v0modName == modname || |
|||
(modfast && *model == modfast)) |
|||
goto delgot; |
|||
oldmod = model; |
|||
} |
|||
return(E_NOMOD); |
|||
|
|||
delgot: |
|||
*oldmod = (*model)->BSIM3v0nextModel; /* cut deleted device out of list */ |
|||
for (here = (*model)->BSIM3v0instances; here; here = here->BSIM3v0nextInstance) |
|||
{ if(prev) FREE(prev); |
|||
prev = here; |
|||
} |
|||
if(prev) FREE(prev); |
|||
FREE(*model); |
|||
return(OK); |
|||
} |
|||
|
|||
|
|||
|
|||
1482
src/spicelib/devices/bsim3v0/b3v0mpar.c
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,356 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Gary W. Ng and Min-Chie Jeng. |
|||
File: b3v0noi.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "bsim3v0def.h" |
|||
#include "cktdefs.h" |
|||
#include "iferrmsg.h" |
|||
#include "noisedef.h" |
|||
#include "suffix.h" |
|||
#include "const.h" /* jwan */ |
|||
|
|||
/* |
|||
* BSIM3v0noise (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". |
|||
*/ |
|||
|
|||
extern void NevalSrc(); |
|||
extern double Nintegrate(); |
|||
|
|||
|
|||
double |
|||
StrongInversionNoiseEval(double vgs, double vds, BSIM3v0model *model, |
|||
BSIM3v0instance *here, double freq, double temp) |
|||
{ |
|||
struct bsim3v0SizeDependParam *pParam; |
|||
double cd, esat, DelClm, EffFreq, N0, Nl, Vgst; |
|||
double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Ssi; |
|||
|
|||
pParam = here->pParam; |
|||
cd = fabs(here->BSIM3v0cd) * here->BSIM3v0m; |
|||
if (vds > here->BSIM3v0vdsat) |
|||
{ esat = 2.0 * pParam->BSIM3v0vsattemp / here->BSIM3v0ueff; |
|||
T0 = ((((vds - here->BSIM3v0vdsat) / pParam->BSIM3v0litl) + model->BSIM3v0em) |
|||
/ esat); |
|||
DelClm = pParam->BSIM3v0litl * log (MAX(T0, N_MINLOG)); |
|||
} |
|||
else |
|||
DelClm = 0.0; |
|||
EffFreq = pow(freq, model->BSIM3v0ef); |
|||
T1 = CHARGE * CHARGE * 8.62e-5 * cd * (temp + CONSTCtoK) * here->BSIM3v0ueff; |
|||
T2 = 1.0e8 * EffFreq * model->BSIM3v0cox |
|||
* pParam->BSIM3v0leff * pParam->BSIM3v0leff; |
|||
Vgst = vgs - here->BSIM3v0von; |
|||
N0 = model->BSIM3v0cox * Vgst / CHARGE; |
|||
if (N0 < 0.0) |
|||
N0 = 0.0; |
|||
Nl = model->BSIM3v0cox * (Vgst - MIN(vds, here->BSIM3v0vdsat)) / CHARGE; |
|||
if (Nl < 0.0) |
|||
Nl = 0.0; |
|||
|
|||
T3 = model->BSIM3v0oxideTrapDensityA |
|||
* log(MAX(((N0 + 2.0e14) / (Nl + 2.0e14)), N_MINLOG)); |
|||
T4 = model->BSIM3v0oxideTrapDensityB * (N0 - Nl); |
|||
T5 = model->BSIM3v0oxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl); |
|||
|
|||
T6 = 8.62e-5 * (temp + CONSTCtoK) * cd * cd; |
|||
T7 = 1.0e8 * EffFreq * pParam->BSIM3v0leff |
|||
* pParam->BSIM3v0leff * pParam->BSIM3v0weff * here->BSIM3v0m; |
|||
T8 = model->BSIM3v0oxideTrapDensityA + model->BSIM3v0oxideTrapDensityB * Nl |
|||
+ model->BSIM3v0oxideTrapDensityC * Nl * Nl; |
|||
T9 = (Nl + 2.0e14) * (Nl + 2.0e14); |
|||
|
|||
Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9; |
|||
return Ssi; |
|||
} |
|||
|
|||
int |
|||
BSIM3v0noise (int mode, int operation, GENmodel *inModel, CKTcircuit *ckt, |
|||
Ndata *data, double *OnDens) |
|||
{ |
|||
BSIM3v0model *model = (BSIM3v0model *)inModel; |
|||
BSIM3v0instance *here; |
|||
struct bsim3v0SizeDependParam *pParam; |
|||
char name[N_MXVLNTH]; |
|||
double tempOnoise; |
|||
double tempInoise; |
|||
double noizDens[BSIM3v0NSRCS]; |
|||
double lnNdens[BSIM3v0NSRCS]; |
|||
|
|||
double vgs, vds, Slimit; |
|||
double N0, Nl; |
|||
double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13; |
|||
double n, ExpArg, Ssi, Swi; |
|||
|
|||
int error, i; |
|||
|
|||
/* define the names of the noise sources */ |
|||
static char *BSIM3v0nNames[BSIM3v0NSRCS] = |
|||
{ /* Note that we have to keep the order */ |
|||
".rd", /* noise due to rd */ |
|||
/* consistent with the index definitions */ |
|||
".rs", /* noise due to rs */ |
|||
/* in BSIM3v0defs.h */ |
|||
".id", /* noise due to id */ |
|||
".1overf", /* flicker (1/f) noise */ |
|||
"" /* total transistor noise */ |
|||
}; |
|||
|
|||
for (; model != NULL; model = model->BSIM3v0nextModel) |
|||
{ for (here = model->BSIM3v0instances; here != NULL; |
|||
here = here->BSIM3v0nextInstance) |
|||
{ |
|||
|
|||
if (here->BSIM3v0owner != ARCHme) |
|||
continue; |
|||
|
|||
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 < BSIM3v0NSRCS; i++) |
|||
{ (void) sprintf(name, "onoise.%s%s", |
|||
here->BSIM3v0name, |
|||
BSIM3v0nNames[i]); |
|||
data->namelist = (IFuid *) trealloc( |
|||
(char *) data->namelist, |
|||
(data->numPlots + 1) |
|||
* sizeof(IFuid)); |
|||
if (!data->namelist) |
|||
return(E_NOMEM); |
|||
(*(SPfrontEnd->IFnewUid)) (ckt, |
|||
&(data->namelist[data->numPlots++]), |
|||
(IFuid) NULL, name, UID_OTHER, |
|||
(void **) NULL); |
|||
/* we've added one more plot */ |
|||
} |
|||
break; |
|||
case INT_NOIZ: |
|||
for (i = 0; i < BSIM3v0NSRCS; i++) |
|||
{ (void) sprintf(name, "onoise_total.%s%s", |
|||
here->BSIM3v0name, |
|||
BSIM3v0nNames[i]); |
|||
data->namelist = (IFuid *) trealloc( |
|||
(char *) data->namelist, |
|||
(data->numPlots + 1) |
|||
* sizeof(IFuid)); |
|||
if (!data->namelist) |
|||
return(E_NOMEM); |
|||
(*(SPfrontEnd->IFnewUid)) (ckt, |
|||
&(data->namelist[data->numPlots++]), |
|||
(IFuid) NULL, name, UID_OTHER, |
|||
(void **) NULL); |
|||
/* we've added one more plot */ |
|||
|
|||
(void) sprintf(name, "inoise_total.%s%s", |
|||
here->BSIM3v0name, |
|||
BSIM3v0nNames[i]); |
|||
data->namelist = (IFuid *) trealloc( |
|||
(char *) data->namelist, |
|||
(data->numPlots + 1) |
|||
* sizeof(IFuid)); |
|||
if (!data->namelist) |
|||
return(E_NOMEM); |
|||
(*(SPfrontEnd->IFnewUid)) (ckt, |
|||
&(data->namelist[data->numPlots++]), |
|||
(IFuid) NULL, name, UID_OTHER, |
|||
(void **)NULL); |
|||
/* we've added one more plot */ |
|||
} |
|||
break; |
|||
} |
|||
} |
|||
break; |
|||
case N_CALC: |
|||
switch (mode) |
|||
{ case N_DENS: |
|||
NevalSrc(&noizDens[BSIM3v0RDNOIZ], |
|||
&lnNdens[BSIM3v0RDNOIZ], ckt, THERMNOISE, |
|||
here->BSIM3v0dNodePrime, here->BSIM3v0dNode, |
|||
here->BSIM3v0drainConductance * here->BSIM3v0m); |
|||
|
|||
NevalSrc(&noizDens[BSIM3v0RSNOIZ], |
|||
&lnNdens[BSIM3v0RSNOIZ], ckt, THERMNOISE, |
|||
here->BSIM3v0sNodePrime, here->BSIM3v0sNode, |
|||
here->BSIM3v0sourceConductance * here->BSIM3v0m); |
|||
|
|||
if (model->BSIM3v0noiMod == 2) |
|||
{ NevalSrc(&noizDens[BSIM3v0IDNOIZ], |
|||
&lnNdens[BSIM3v0IDNOIZ], ckt, THERMNOISE, |
|||
here->BSIM3v0dNodePrime, |
|||
here->BSIM3v0sNodePrime, (here->BSIM3v0ueff |
|||
* fabs((here->BSIM3v0qinv * here->BSIM3v0m) |
|||
/ (pParam->BSIM3v0leff |
|||
* pParam->BSIM3v0leff)))); |
|||
} |
|||
else |
|||
{ NevalSrc(&noizDens[BSIM3v0IDNOIZ], |
|||
&lnNdens[BSIM3v0IDNOIZ], ckt, THERMNOISE, |
|||
here->BSIM3v0dNodePrime, |
|||
here->BSIM3v0sNodePrime, |
|||
(2.0 / 3.0 * fabs(here->BSIM3v0gm |
|||
+ here->BSIM3v0gds) * here->BSIM3v0m)); |
|||
|
|||
} |
|||
NevalSrc(&noizDens[BSIM3v0FLNOIZ], (double*) NULL, |
|||
ckt, N_GAIN, here->BSIM3v0dNodePrime, |
|||
here->BSIM3v0sNodePrime, (double) 0.0); |
|||
|
|||
if (model->BSIM3v0noiMod == 2) |
|||
{ vgs = *(ckt->CKTstates[0] + here->BSIM3v0vgs); |
|||
vds = *(ckt->CKTstates[0] + here->BSIM3v0vds); |
|||
if (vds < 0.0) |
|||
{ vds = -vds; |
|||
vgs = vgs + vds; |
|||
} |
|||
if (vgs >= here->BSIM3v0von + 0.1) |
|||
{ Ssi = StrongInversionNoiseEval(vgs, vds, |
|||
model, here, data->freq, |
|||
ckt->CKTtemp); |
|||
noizDens[BSIM3v0FLNOIZ] *= Ssi; |
|||
} |
|||
else |
|||
{ pParam = here->pParam; |
|||
T10 = model->BSIM3v0oxideTrapDensityA |
|||
* 8.62e-5 * (ckt->CKTtemp + CONSTCtoK); |
|||
T11 = pParam->BSIM3v0weff * here->BSIM3v0m * pParam->BSIM3v0leff |
|||
* pow(data->freq, model->BSIM3v0ef) |
|||
* 4.0e36; |
|||
Swi = T10 / T11 * here->BSIM3v0cd * here->BSIM3v0m |
|||
* here->BSIM3v0cd * here->BSIM3v0m; |
|||
Slimit = StrongInversionNoiseEval( |
|||
here->BSIM3v0von + 0.1, |
|||
vds, model, here, |
|||
data->freq, ckt->CKTtemp); |
|||
T1 = Swi + Slimit; |
|||
if (T1 > 0.0) |
|||
noizDens[BSIM3v0FLNOIZ] *= (Slimit * Swi) |
|||
/ T1; |
|||
else |
|||
noizDens[BSIM3v0FLNOIZ] *= 0.0; |
|||
} |
|||
} |
|||
else |
|||
{ noizDens[BSIM3v0FLNOIZ] *= model->BSIM3v0kf * |
|||
exp(model->BSIM3v0af |
|||
* log(MAX(fabs(here->BSIM3v0cd * here->BSIM3v0m), |
|||
N_MINLOG))) |
|||
/ (pow(data->freq, model->BSIM3v0ef) |
|||
* pParam->BSIM3v0leff |
|||
* pParam->BSIM3v0leff |
|||
* model->BSIM3v0cox); |
|||
} |
|||
|
|||
lnNdens[BSIM3v0FLNOIZ] = |
|||
log(MAX(noizDens[BSIM3v0FLNOIZ], N_MINLOG)); |
|||
|
|||
noizDens[BSIM3v0TOTNOIZ] = noizDens[BSIM3v0RDNOIZ] |
|||
+ noizDens[BSIM3v0RSNOIZ] |
|||
+ noizDens[BSIM3v0IDNOIZ] |
|||
+ noizDens[BSIM3v0FLNOIZ]; |
|||
lnNdens[BSIM3v0TOTNOIZ] = |
|||
log(MAX(noizDens[BSIM3v0TOTNOIZ], N_MINLOG)); |
|||
|
|||
*OnDens += noizDens[BSIM3v0TOTNOIZ]; |
|||
|
|||
if (data->delFreq == 0.0) |
|||
{ /* if we haven't done any previous |
|||
integration, we need to initialize our |
|||
"history" variables. |
|||
*/ |
|||
|
|||
for (i = 0; i < BSIM3v0NSRCS; i++) |
|||
{ here->BSIM3v0nVar[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 < BSIM3v0NSRCS; i++) |
|||
{ here->BSIM3v0nVar[OUTNOIZ][i] = 0.0; |
|||
here->BSIM3v0nVar[INNOIZ][i] = 0.0; |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ /* data->delFreq != 0.0, |
|||
we have to integrate. |
|||
*/ |
|||
for (i = 0; i < BSIM3v0NSRCS; i++) |
|||
{ if (i != BSIM3v0TOTNOIZ) |
|||
{ tempOnoise = Nintegrate(noizDens[i], |
|||
lnNdens[i], |
|||
here->BSIM3v0nVar[LNLSTDENS][i], |
|||
data); |
|||
tempInoise = Nintegrate(noizDens[i] |
|||
* data->GainSqInv, lnNdens[i] |
|||
+ data->lnGainInv, |
|||
here->BSIM3v0nVar[LNLSTDENS][i] |
|||
+ data->lnGainInv, data); |
|||
here->BSIM3v0nVar[LNLSTDENS][i] = |
|||
lnNdens[i]; |
|||
data->outNoiz += tempOnoise; |
|||
data->inNoise += tempInoise; |
|||
if (((NOISEAN*) |
|||
ckt->CKTcurJob)->NStpsSm != 0) |
|||
{ here->BSIM3v0nVar[OUTNOIZ][i] |
|||
+= tempOnoise; |
|||
here->BSIM3v0nVar[OUTNOIZ][BSIM3v0TOTNOIZ] |
|||
+= tempOnoise; |
|||
here->BSIM3v0nVar[INNOIZ][i] |
|||
+= tempInoise; |
|||
here->BSIM3v0nVar[INNOIZ][BSIM3v0TOTNOIZ] |
|||
+= tempInoise; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if (data->prtSummary) |
|||
{ for (i = 0; i < BSIM3v0NSRCS; 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 < BSIM3v0NSRCS; i++) |
|||
{ data->outpVector[data->outNumber++] |
|||
= here->BSIM3v0nVar[OUTNOIZ][i]; |
|||
data->outpVector[data->outNumber++] |
|||
= here->BSIM3v0nVar[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); |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,96 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0par.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "ifsim.h" |
|||
#include "bsim3v0def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int |
|||
BSIM3v0param(int param, IFvalue *value, GENinstance *inst, IFvalue *select) |
|||
{ |
|||
BSIM3v0instance *here = (BSIM3v0instance*)inst; |
|||
switch(param) |
|||
{ case BSIM3v0_W: |
|||
here->BSIM3v0w = value->rValue; |
|||
here->BSIM3v0wGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_L: |
|||
here->BSIM3v0l = value->rValue; |
|||
here->BSIM3v0lGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_M: |
|||
here->BSIM3v0m = value->rValue; |
|||
here->BSIM3v0mGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_AS: |
|||
here->BSIM3v0sourceArea = value->rValue; |
|||
here->BSIM3v0sourceAreaGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_AD: |
|||
here->BSIM3v0drainArea = value->rValue; |
|||
here->BSIM3v0drainAreaGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_PS: |
|||
here->BSIM3v0sourcePerimeter = value->rValue; |
|||
here->BSIM3v0sourcePerimeterGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_PD: |
|||
here->BSIM3v0drainPerimeter = value->rValue; |
|||
here->BSIM3v0drainPerimeterGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_NRS: |
|||
here->BSIM3v0sourceSquares = value->rValue; |
|||
here->BSIM3v0sourceSquaresGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_NRD: |
|||
here->BSIM3v0drainSquares = value->rValue; |
|||
here->BSIM3v0drainSquaresGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_OFF: |
|||
here->BSIM3v0off = value->iValue; |
|||
break; |
|||
case BSIM3v0_IC_VBS: |
|||
here->BSIM3v0icVBS = value->rValue; |
|||
here->BSIM3v0icVBSGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_IC_VDS: |
|||
here->BSIM3v0icVDS = value->rValue; |
|||
here->BSIM3v0icVDSGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_IC_VGS: |
|||
here->BSIM3v0icVGS = value->rValue; |
|||
here->BSIM3v0icVGSGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_NQSMOD: |
|||
here->BSIM3v0nqsMod = value->iValue; |
|||
here->BSIM3v0nqsModGiven = TRUE; |
|||
break; |
|||
case BSIM3v0_IC: |
|||
switch(value->v.numValue){ |
|||
case 3: |
|||
here->BSIM3v0icVBS = *(value->v.vec.rVec+2); |
|||
here->BSIM3v0icVBSGiven = TRUE; |
|||
case 2: |
|||
here->BSIM3v0icVGS = *(value->v.vec.rVec+1); |
|||
here->BSIM3v0icVGSGiven = TRUE; |
|||
case 1: |
|||
here->BSIM3v0icVDS = *(value->v.vec.rVec); |
|||
here->BSIM3v0icVDSGiven = TRUE; |
|||
break; |
|||
default: |
|||
return(E_BADPARM); |
|||
} |
|||
break; |
|||
default: |
|||
return(E_BADPARM); |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,150 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0pzld.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "cktdefs.h" |
|||
#include "complex.h" |
|||
#include "sperror.h" |
|||
#include "bsim3v0def.h" |
|||
#include "suffix.h" |
|||
|
|||
int |
|||
BSIM3v0pzLoad(GENmodel *inModel, CKTcircuit *ckt, SPcomplex *s) |
|||
{ |
|||
register BSIM3v0model *model = (BSIM3v0model*)inModel; |
|||
register BSIM3v0instance *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; |
|||
|
|||
double m; |
|||
|
|||
for (; model != NULL; model = model->BSIM3v0nextModel) |
|||
{ for (here = model->BSIM3v0instances; here!= NULL; |
|||
here = here->BSIM3v0nextInstance) |
|||
{ |
|||
|
|||
if (here->BSIM3v0owner != ARCHme) |
|||
continue; |
|||
|
|||
if (here->BSIM3v0mode >= 0) |
|||
{ Gm = here->BSIM3v0gm; |
|||
Gmbs = here->BSIM3v0gmbs; |
|||
FwdSum = Gm + Gmbs; |
|||
RevSum = 0.0; |
|||
cggb = here->BSIM3v0cggb; |
|||
cgsb = here->BSIM3v0cgsb; |
|||
cgdb = here->BSIM3v0cgdb; |
|||
|
|||
cbgb = here->BSIM3v0cbgb; |
|||
cbsb = here->BSIM3v0cbsb; |
|||
cbdb = here->BSIM3v0cbdb; |
|||
|
|||
cdgb = here->BSIM3v0cdgb; |
|||
cdsb = here->BSIM3v0cdsb; |
|||
cddb = here->BSIM3v0cddb; |
|||
} |
|||
else |
|||
{ Gm = -here->BSIM3v0gm; |
|||
Gmbs = -here->BSIM3v0gmbs; |
|||
FwdSum = 0.0; |
|||
RevSum = -Gm - Gmbs; |
|||
cggb = here->BSIM3v0cggb; |
|||
cgsb = here->BSIM3v0cgdb; |
|||
cgdb = here->BSIM3v0cgsb; |
|||
|
|||
cbgb = here->BSIM3v0cbgb; |
|||
cbsb = here->BSIM3v0cbdb; |
|||
cbdb = here->BSIM3v0cbsb; |
|||
|
|||
cdgb = -(here->BSIM3v0cdgb + cggb + cbgb); |
|||
cdsb = -(here->BSIM3v0cddb + cgsb + cbsb); |
|||
cddb = -(here->BSIM3v0cdsb + cgdb + cbdb); |
|||
} |
|||
gdpr=here->BSIM3v0drainConductance; |
|||
gspr=here->BSIM3v0sourceConductance; |
|||
gds= here->BSIM3v0gds; |
|||
gbd= here->BSIM3v0gbd; |
|||
gbs= here->BSIM3v0gbs; |
|||
capbd= here->BSIM3v0capbd; |
|||
capbs= here->BSIM3v0capbs; |
|||
GSoverlapCap = here->BSIM3v0cgso; |
|||
GDoverlapCap = here->BSIM3v0cgdo; |
|||
GBoverlapCap = here->pParam->BSIM3v0cgbo; |
|||
|
|||
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); |
|||
|
|||
m = here->BSIM3v0m; |
|||
|
|||
*(here->BSIM3v0GgPtr ) += m * (xcggb * s->real); |
|||
*(here->BSIM3v0GgPtr +1) += m * (xcggb * s->imag); |
|||
*(here->BSIM3v0BbPtr ) += m * ((-xcbgb-xcbdb-xcbsb) * s->real); |
|||
*(here->BSIM3v0BbPtr +1) += m * ((-xcbgb-xcbdb-xcbsb) * s->imag); |
|||
*(here->BSIM3v0DPdpPtr ) += m * (xcddb * s->real); |
|||
*(here->BSIM3v0DPdpPtr +1) += m * (xcddb * s->imag); |
|||
*(here->BSIM3v0SPspPtr ) += m * (xcssb * s->real); |
|||
*(here->BSIM3v0SPspPtr +1) += m * (xcssb * s->imag); |
|||
*(here->BSIM3v0GbPtr ) += m * ((-xcggb-xcgdb-xcgsb) * s->real); |
|||
*(here->BSIM3v0GbPtr +1) += m * ((-xcggb-xcgdb-xcgsb) * s->imag); |
|||
*(here->BSIM3v0GdpPtr ) += m * (xcgdb * s->real); |
|||
*(here->BSIM3v0GdpPtr +1) += m * (xcgdb * s->imag); |
|||
*(here->BSIM3v0GspPtr ) += m * (xcgsb * s->real); |
|||
*(here->BSIM3v0GspPtr +1) += m * (xcgsb * s->imag); |
|||
*(here->BSIM3v0BgPtr ) += m * (xcbgb * s->real); |
|||
*(here->BSIM3v0BgPtr +1) += m * (xcbgb * s->imag); |
|||
*(here->BSIM3v0BdpPtr ) += m * (xcbdb * s->real); |
|||
*(here->BSIM3v0BdpPtr +1) += m * (xcbdb * s->imag); |
|||
*(here->BSIM3v0BspPtr ) += m * (xcbsb * s->real); |
|||
*(here->BSIM3v0BspPtr +1) += m * (xcbsb * s->imag); |
|||
*(here->BSIM3v0DPgPtr ) += m * (xcdgb * s->real); |
|||
*(here->BSIM3v0DPgPtr +1) += m * (xcdgb * s->imag); |
|||
*(here->BSIM3v0DPbPtr ) += m * ((-xcdgb-xcddb-xcdsb) * s->real); |
|||
*(here->BSIM3v0DPbPtr +1) += m * ((-xcdgb-xcddb-xcdsb) * s->imag); |
|||
*(here->BSIM3v0DPspPtr ) += m * (xcdsb * s->real); |
|||
*(here->BSIM3v0DPspPtr +1) += m * (xcdsb * s->imag); |
|||
*(here->BSIM3v0SPgPtr ) += m * (xcsgb * s->real); |
|||
*(here->BSIM3v0SPgPtr +1) += m * (xcsgb * s->imag); |
|||
*(here->BSIM3v0SPbPtr ) += m * ((-xcsgb-xcsdb-xcssb) * s->real); |
|||
*(here->BSIM3v0SPbPtr +1) += m * ((-xcsgb-xcsdb-xcssb) * s->imag); |
|||
*(here->BSIM3v0SPdpPtr ) += m * (xcsdb * s->real); |
|||
*(here->BSIM3v0SPdpPtr +1) += m * (xcsdb * s->imag); |
|||
*(here->BSIM3v0DdPtr) += m * gdpr; |
|||
*(here->BSIM3v0SsPtr) += m * gspr; |
|||
*(here->BSIM3v0BbPtr) += m * (gbd + gbs); |
|||
*(here->BSIM3v0DPdpPtr) += m * (gdpr + gds + gbd + RevSum); |
|||
*(here->BSIM3v0SPspPtr) += m * (gspr + gds + gbs + FwdSum); |
|||
*(here->BSIM3v0DdpPtr) -= m * gdpr; |
|||
*(here->BSIM3v0SspPtr) -= m * gspr; |
|||
*(here->BSIM3v0BdpPtr) -= m * gbd; |
|||
*(here->BSIM3v0BspPtr) -= m * gbs; |
|||
*(here->BSIM3v0DPdPtr) -= m * gdpr; |
|||
*(here->BSIM3v0DPgPtr) += m * Gm; |
|||
*(here->BSIM3v0DPbPtr) -= m * (gbd - Gmbs); |
|||
*(here->BSIM3v0DPspPtr) -= m * (gds + FwdSum); |
|||
*(here->BSIM3v0SPgPtr) -= m * Gm; |
|||
*(here->BSIM3v0SPsPtr) -= m * gspr; |
|||
*(here->BSIM3v0SPbPtr) -= m * (gbs + Gmbs); |
|||
*(here->BSIM3v0SPdpPtr) -= m * (gds + RevSum); |
|||
|
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,926 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0set.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "smpdefs.h" |
|||
#include "cktdefs.h" |
|||
#include "bsim3v0def.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 |
|||
BSIM3v0setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, |
|||
int *states) |
|||
{ |
|||
BSIM3v0model *model = (BSIM3v0model*)inModel; |
|||
BSIM3v0instance *here; |
|||
int error; |
|||
CKTnode *tmp; |
|||
|
|||
double tmp1, tmp2; |
|||
|
|||
CKTnode *tmpNode; |
|||
IFuid tmpName; |
|||
|
|||
/* loop through all the BSIM3v0 device models */ |
|||
for( ; model != NULL; model = model->BSIM3v0nextModel ) |
|||
{ |
|||
/* Default value Processing for BSIM3v0 MOSFET Models */ |
|||
if (!model->BSIM3v0typeGiven) |
|||
model->BSIM3v0type = NMOS; |
|||
if (!model->BSIM3v0mobModGiven) |
|||
model->BSIM3v0mobMod = 1; |
|||
if (!model->BSIM3v0binUnitGiven) |
|||
model->BSIM3v0binUnit = 1; |
|||
if (!model->BSIM3v0capModGiven) |
|||
model->BSIM3v0capMod = 1; |
|||
if (!model->BSIM3v0nqsModGiven) |
|||
model->BSIM3v0nqsMod = 0; |
|||
if (!model->BSIM3v0noiModGiven) |
|||
model->BSIM3v0noiMod = 1; |
|||
if (!model->BSIM3v0toxGiven) |
|||
model->BSIM3v0tox = 150.0e-10; |
|||
model->BSIM3v0cox = 3.453133e-11 / model->BSIM3v0tox; |
|||
|
|||
if (!model->BSIM3v0cdscGiven) |
|||
model->BSIM3v0cdsc = 2.4e-4; /* unit Q/V/m^2 */ |
|||
if (!model->BSIM3v0cdscbGiven) |
|||
model->BSIM3v0cdscb = 0.0; /* unit Q/V/m^2 */ |
|||
if (!model->BSIM3v0cdscdGiven) |
|||
model->BSIM3v0cdscd = 0.0; /* unit Q/V/m^2 */ |
|||
if (!model->BSIM3v0citGiven) |
|||
model->BSIM3v0cit = 0.0; /* unit Q/V/m^2 */ |
|||
if (!model->BSIM3v0nfactorGiven) |
|||
model->BSIM3v0nfactor = 1; |
|||
if (!model->BSIM3v0xjGiven) |
|||
model->BSIM3v0xj = .15e-6; |
|||
if (!model->BSIM3v0vsatGiven) |
|||
model->BSIM3v0vsat = 8.0e4; /* unit m/s */ |
|||
if (!model->BSIM3v0atGiven) |
|||
model->BSIM3v0at = 3.3e4; /* unit m/s */ |
|||
if (!model->BSIM3v0a0Given) |
|||
model->BSIM3v0a0 = 1.0; |
|||
if (!model->BSIM3v0agsGiven) |
|||
model->BSIM3v0ags = 0.0; |
|||
if (!model->BSIM3v0a1Given) |
|||
model->BSIM3v0a1 = 0.0; |
|||
if (!model->BSIM3v0a2Given) |
|||
model->BSIM3v0a2 = 1.0; |
|||
if (!model->BSIM3v0ketaGiven) |
|||
model->BSIM3v0keta = -0.047; /* unit / V */ |
|||
if (!model->BSIM3v0nsubGiven) |
|||
model->BSIM3v0nsub = 6.0e16; /* unit 1/cm3 */ |
|||
if (!model->BSIM3v0npeakGiven) |
|||
model->BSIM3v0npeak = 1.7e17; /* unit 1/cm3 */ |
|||
if (!model->BSIM3v0vbmGiven) |
|||
model->BSIM3v0vbm = -5.0; |
|||
if (!model->BSIM3v0xtGiven) |
|||
model->BSIM3v0xt = 1.55e-7; |
|||
if (!model->BSIM3v0kt1Given) |
|||
model->BSIM3v0kt1 = -0.11; /* unit V */ |
|||
if (!model->BSIM3v0kt1lGiven) |
|||
model->BSIM3v0kt1l = 0.0; /* unit V*m */ |
|||
if (!model->BSIM3v0kt2Given) |
|||
model->BSIM3v0kt2 = 0.022; /* No unit */ |
|||
if (!model->BSIM3v0k3Given) |
|||
model->BSIM3v0k3 = 80.0; |
|||
if (!model->BSIM3v0k3bGiven) |
|||
model->BSIM3v0k3b = 0.0; |
|||
if (!model->BSIM3v0w0Given) |
|||
model->BSIM3v0w0 = 2.5e-6; |
|||
if (!model->BSIM3v0nlxGiven) |
|||
model->BSIM3v0nlx = 1.74e-7; |
|||
if (!model->BSIM3v0dvt0Given) |
|||
model->BSIM3v0dvt0 = 2.2; |
|||
if (!model->BSIM3v0dvt1Given) |
|||
model->BSIM3v0dvt1 = 0.53; |
|||
if (!model->BSIM3v0dvt2Given) |
|||
model->BSIM3v0dvt2 = -0.032; /* unit 1 / V */ |
|||
|
|||
if (!model->BSIM3v0dvt0wGiven) |
|||
model->BSIM3v0dvt0w = 0.0; |
|||
if (!model->BSIM3v0dvt1wGiven) |
|||
model->BSIM3v0dvt1w = 5.3e6; |
|||
if (!model->BSIM3v0dvt2wGiven) |
|||
model->BSIM3v0dvt2w = -0.032; |
|||
|
|||
if (!model->BSIM3v0droutGiven) |
|||
model->BSIM3v0drout = 0.56; |
|||
if (!model->BSIM3v0dsubGiven) |
|||
model->BSIM3v0dsub = model->BSIM3v0drout; |
|||
if (!model->BSIM3v0vth0Given) |
|||
model->BSIM3v0vth0 = (model->BSIM3v0type == NMOS) ? 0.7 : -0.7; |
|||
if (!model->BSIM3v0uaGiven) |
|||
model->BSIM3v0ua = 2.25e-9; /* unit m/V */ |
|||
if (!model->BSIM3v0ua1Given) |
|||
model->BSIM3v0ua1 = 4.31e-9; /* unit m/V */ |
|||
if (!model->BSIM3v0ubGiven) |
|||
model->BSIM3v0ub = 5.87e-19; /* unit (m/V)**2 */ |
|||
if (!model->BSIM3v0ub1Given) |
|||
model->BSIM3v0ub1 = -7.61e-18; /* unit (m/V)**2 */ |
|||
if (!model->BSIM3v0ucGiven) |
|||
model->BSIM3v0uc = (model->BSIM3v0mobMod == 3) ? -0.0465 : -0.0465e-9; |
|||
if (!model->BSIM3v0uc1Given) |
|||
model->BSIM3v0uc1 = (model->BSIM3v0mobMod == 3) ? -0.056 : -0.056e-9; |
|||
if (!model->BSIM3v0u0Given) |
|||
model->BSIM3v0u0 = (model->BSIM3v0type == NMOS) ? 0.067 : 0.025; |
|||
else if (model->BSIM3v0u0 > 1.0) |
|||
model->BSIM3v0u0 = model->BSIM3v0u0 / 1.0e4; |
|||
/* if u0 > 1.0, cm.g.sec unit system is used. If should be |
|||
converted into SI unit system. */ |
|||
if (!model->BSIM3v0uteGiven) |
|||
model->BSIM3v0ute = -1.5; |
|||
if (!model->BSIM3v0voffGiven) |
|||
model->BSIM3v0voff = -0.08; |
|||
if (!model->BSIM3v0deltaGiven) |
|||
model->BSIM3v0delta = 0.01; |
|||
if (!model->BSIM3v0rdswGiven) |
|||
model->BSIM3v0rdsw = 0; |
|||
if (!model->BSIM3v0prwgGiven) |
|||
model->BSIM3v0prwg = 0.0; /* unit 1/V */ |
|||
if (!model->BSIM3v0prwbGiven) |
|||
model->BSIM3v0prwb = 0.0; |
|||
if (!model->BSIM3v0prtGiven) |
|||
if (!model->BSIM3v0prtGiven) |
|||
model->BSIM3v0prt = 0.0; |
|||
if (!model->BSIM3v0eta0Given) |
|||
model->BSIM3v0eta0 = 0.08; /* no unit */ |
|||
if (!model->BSIM3v0etabGiven) |
|||
model->BSIM3v0etab = -0.07; /* unit 1/V */ |
|||
if (!model->BSIM3v0pclmGiven) |
|||
model->BSIM3v0pclm = 1.3; /* no unit */ |
|||
if (!model->BSIM3v0pdibl1Given) |
|||
model->BSIM3v0pdibl1 = .39; /* no unit */ |
|||
if (!model->BSIM3v0pdibl2Given) |
|||
model->BSIM3v0pdibl2 = 0.0086; /* no unit */ |
|||
if (!model->BSIM3v0pdiblbGiven) |
|||
model->BSIM3v0pdiblb = 0.0; /* 1/V */ |
|||
if (!model->BSIM3v0pscbe1Given) |
|||
model->BSIM3v0pscbe1 = 4.24e8; |
|||
if (!model->BSIM3v0pscbe2Given) |
|||
model->BSIM3v0pscbe2 = 1.0e-5; |
|||
if (!model->BSIM3v0pvagGiven) |
|||
model->BSIM3v0pvag = 0.0; |
|||
if (!model->BSIM3v0wrGiven) |
|||
model->BSIM3v0wr = 1.0; |
|||
if (!model->BSIM3v0dwgGiven) |
|||
model->BSIM3v0dwg = 0.0; |
|||
if (!model->BSIM3v0dwbGiven) |
|||
model->BSIM3v0dwb = 0.0; |
|||
if (!model->BSIM3v0b0Given) |
|||
model->BSIM3v0b0 = 0.0; |
|||
if (!model->BSIM3v0b1Given) |
|||
model->BSIM3v0b1 = 0.0; |
|||
if (!model->BSIM3v0alpha0Given) |
|||
model->BSIM3v0alpha0 = 0.0; |
|||
if (!model->BSIM3v0beta0Given) |
|||
model->BSIM3v0beta0 = 30.0; |
|||
|
|||
if (!model->BSIM3v0elmGiven) |
|||
model->BSIM3v0elm = 5.0; |
|||
if (!model->BSIM3v0cgslGiven) |
|||
model->BSIM3v0cgsl = 0.0; |
|||
if (!model->BSIM3v0cgdlGiven) |
|||
model->BSIM3v0cgdl = 0.0; |
|||
if (!model->BSIM3v0ckappaGiven) |
|||
model->BSIM3v0ckappa = 0.6; |
|||
if (!model->BSIM3v0clcGiven) |
|||
model->BSIM3v0clc = 0.1e-6; |
|||
if (!model->BSIM3v0cleGiven) |
|||
model->BSIM3v0cle = 0.6; |
|||
|
|||
/* Length dependence */ |
|||
if (!model->BSIM3v0lcdscGiven) |
|||
model->BSIM3v0lcdsc = 0.0; |
|||
if (!model->BSIM3v0lcdscbGiven) |
|||
model->BSIM3v0lcdscb = 0.0; |
|||
if (!model->BSIM3v0lcdscdGiven) |
|||
model->BSIM3v0lcdscd = 0.0; |
|||
if (!model->BSIM3v0lcitGiven) |
|||
model->BSIM3v0lcit = 0.0; |
|||
if (!model->BSIM3v0lnfactorGiven) |
|||
model->BSIM3v0lnfactor = 0.0; |
|||
if (!model->BSIM3v0lxjGiven) |
|||
model->BSIM3v0lxj = 0.0; |
|||
if (!model->BSIM3v0lvsatGiven) |
|||
model->BSIM3v0lvsat = 0.0; |
|||
if (!model->BSIM3v0latGiven) |
|||
model->BSIM3v0lat = 0.0; |
|||
if (!model->BSIM3v0la0Given) |
|||
model->BSIM3v0la0 = 0.0; |
|||
if (!model->BSIM3v0lagsGiven) |
|||
model->BSIM3v0lags = 0.0; |
|||
if (!model->BSIM3v0la1Given) |
|||
model->BSIM3v0la1 = 0.0; |
|||
if (!model->BSIM3v0la2Given) |
|||
model->BSIM3v0la2 = 0.0; |
|||
if (!model->BSIM3v0lketaGiven) |
|||
model->BSIM3v0lketa = 0.0; |
|||
if (!model->BSIM3v0lnsubGiven) |
|||
model->BSIM3v0lnsub = 0.0; |
|||
if (!model->BSIM3v0lnpeakGiven) |
|||
model->BSIM3v0lnpeak = 0.0; |
|||
if (!model->BSIM3v0lvbmGiven) |
|||
model->BSIM3v0lvbm = 0.0; |
|||
if (!model->BSIM3v0lxtGiven) |
|||
model->BSIM3v0lxt = 0.0; |
|||
if (!model->BSIM3v0lkt1Given) |
|||
model->BSIM3v0lkt1 = 0.0; |
|||
if (!model->BSIM3v0lkt1lGiven) |
|||
model->BSIM3v0lkt1l = 0.0; |
|||
if (!model->BSIM3v0lkt2Given) |
|||
model->BSIM3v0lkt2 = 0.0; |
|||
if (!model->BSIM3v0lk3Given) |
|||
model->BSIM3v0lk3 = 0.0; |
|||
if (!model->BSIM3v0lk3bGiven) |
|||
model->BSIM3v0lk3b = 0.0; |
|||
if (!model->BSIM3v0lw0Given) |
|||
model->BSIM3v0lw0 = 0.0; |
|||
if (!model->BSIM3v0lnlxGiven) |
|||
model->BSIM3v0lnlx = 0.0; |
|||
if (!model->BSIM3v0ldvt0Given) |
|||
model->BSIM3v0ldvt0 = 0.0; |
|||
if (!model->BSIM3v0ldvt1Given) |
|||
model->BSIM3v0ldvt1 = 0.0; |
|||
if (!model->BSIM3v0ldvt2Given) |
|||
model->BSIM3v0ldvt2 = 0.0; |
|||
if (!model->BSIM3v0ldvt0wGiven) |
|||
model->BSIM3v0ldvt0w = 0.0; |
|||
if (!model->BSIM3v0ldvt1wGiven) |
|||
model->BSIM3v0ldvt1w = 0.0; |
|||
if (!model->BSIM3v0ldvt2wGiven) |
|||
model->BSIM3v0ldvt2w = 0.0; |
|||
if (!model->BSIM3v0ldroutGiven) |
|||
model->BSIM3v0ldrout = 0.0; |
|||
if (!model->BSIM3v0ldsubGiven) |
|||
model->BSIM3v0ldsub = 0.0; |
|||
if (!model->BSIM3v0lvth0Given) |
|||
model->BSIM3v0lvth0 = 0.0; |
|||
if (!model->BSIM3v0luaGiven) |
|||
model->BSIM3v0lua = 0.0; |
|||
if (!model->BSIM3v0lua1Given) |
|||
model->BSIM3v0lua1 = 0.0; |
|||
if (!model->BSIM3v0lubGiven) |
|||
model->BSIM3v0lub = 0.0; |
|||
if (!model->BSIM3v0lub1Given) |
|||
model->BSIM3v0lub1 = 0.0; |
|||
if (!model->BSIM3v0lucGiven) |
|||
model->BSIM3v0luc = 0.0; |
|||
if (!model->BSIM3v0luc1Given) |
|||
model->BSIM3v0luc1 = 0.0; |
|||
if (!model->BSIM3v0lu0Given) |
|||
model->BSIM3v0lu0 = 0.0; |
|||
else if (model->BSIM3v0u0 > 1.0) |
|||
model->BSIM3v0lu0 = model->BSIM3v0lu0 / 1.0e4; |
|||
if (!model->BSIM3v0luteGiven) |
|||
model->BSIM3v0lute = 0.0; |
|||
if (!model->BSIM3v0lvoffGiven) |
|||
model->BSIM3v0lvoff = 0.0; |
|||
if (!model->BSIM3v0ldeltaGiven) |
|||
model->BSIM3v0ldelta = 0.0; |
|||
if (!model->BSIM3v0lrdswGiven) |
|||
model->BSIM3v0lrdsw = 0.0; |
|||
if (!model->BSIM3v0lprwbGiven) |
|||
model->BSIM3v0lprwb = 0.0; |
|||
if (!model->BSIM3v0lprwgGiven) |
|||
model->BSIM3v0lprwg = 0.0; |
|||
if (!model->BSIM3v0lprtGiven) |
|||
if (!model->BSIM3v0lprtGiven) |
|||
model->BSIM3v0lprt = 0.0; |
|||
if (!model->BSIM3v0leta0Given) |
|||
model->BSIM3v0leta0 = 0.0; |
|||
if (!model->BSIM3v0letabGiven) |
|||
model->BSIM3v0letab = -0.0; |
|||
if (!model->BSIM3v0lpclmGiven) |
|||
model->BSIM3v0lpclm = 0.0; |
|||
if (!model->BSIM3v0lpdibl1Given) |
|||
model->BSIM3v0lpdibl1 = 0.0; |
|||
if (!model->BSIM3v0lpdibl2Given) |
|||
model->BSIM3v0lpdibl2 = 0.0; |
|||
if (!model->BSIM3v0lpdiblbGiven) |
|||
model->BSIM3v0lpdiblb = 0.0; |
|||
if (!model->BSIM3v0lpscbe1Given) |
|||
model->BSIM3v0lpscbe1 = 0.0; |
|||
if (!model->BSIM3v0lpscbe2Given) |
|||
model->BSIM3v0lpscbe2 = 0.0; |
|||
if (!model->BSIM3v0lpvagGiven) |
|||
model->BSIM3v0lpvag = 0.0; |
|||
if (!model->BSIM3v0lwrGiven) |
|||
model->BSIM3v0lwr = 0.0; |
|||
if (!model->BSIM3v0ldwgGiven) |
|||
model->BSIM3v0ldwg = 0.0; |
|||
if (!model->BSIM3v0ldwbGiven) |
|||
model->BSIM3v0ldwb = 0.0; |
|||
if (!model->BSIM3v0lb0Given) |
|||
model->BSIM3v0lb0 = 0.0; |
|||
if (!model->BSIM3v0lb1Given) |
|||
model->BSIM3v0lb1 = 0.0; |
|||
if (!model->BSIM3v0lalpha0Given) |
|||
model->BSIM3v0lalpha0 = 0.0; |
|||
if (!model->BSIM3v0lbeta0Given) |
|||
model->BSIM3v0lbeta0 = 0.0; |
|||
|
|||
if (!model->BSIM3v0lelmGiven) |
|||
model->BSIM3v0lelm = 0.0; |
|||
if (!model->BSIM3v0lcgslGiven) |
|||
model->BSIM3v0lcgsl = 0.0; |
|||
if (!model->BSIM3v0lcgdlGiven) |
|||
model->BSIM3v0lcgdl = 0.0; |
|||
if (!model->BSIM3v0lckappaGiven) |
|||
model->BSIM3v0lckappa = 0.0; |
|||
if (!model->BSIM3v0lcfGiven) |
|||
model->BSIM3v0lcf = 0.0; |
|||
if (!model->BSIM3v0lclcGiven) |
|||
model->BSIM3v0lclc = 0.0; |
|||
if (!model->BSIM3v0lcleGiven) |
|||
model->BSIM3v0lcle = 0.0; |
|||
|
|||
/* Width dependence */ |
|||
if (!model->BSIM3v0wcdscGiven) |
|||
model->BSIM3v0wcdsc = 0.0; |
|||
if (!model->BSIM3v0wcdscbGiven) |
|||
model->BSIM3v0wcdscb = 0.0; |
|||
if (!model->BSIM3v0wcdscdGiven) |
|||
model->BSIM3v0wcdscd = 0.0; |
|||
if (!model->BSIM3v0wcitGiven) |
|||
model->BSIM3v0wcit = 0.0; |
|||
if (!model->BSIM3v0wnfactorGiven) |
|||
model->BSIM3v0wnfactor = 0.0; |
|||
if (!model->BSIM3v0wxjGiven) |
|||
model->BSIM3v0wxj = 0.0; |
|||
if (!model->BSIM3v0wvsatGiven) |
|||
model->BSIM3v0wvsat = 0.0; |
|||
if (!model->BSIM3v0watGiven) |
|||
model->BSIM3v0wat = 0.0; |
|||
if (!model->BSIM3v0wa0Given) |
|||
model->BSIM3v0wa0 = 0.0; |
|||
if (!model->BSIM3v0wagsGiven) |
|||
model->BSIM3v0wags = 0.0; |
|||
if (!model->BSIM3v0wa1Given) |
|||
model->BSIM3v0wa1 = 0.0; |
|||
if (!model->BSIM3v0wa2Given) |
|||
model->BSIM3v0wa2 = 0.0; |
|||
if (!model->BSIM3v0wketaGiven) |
|||
model->BSIM3v0wketa = 0.0; |
|||
if (!model->BSIM3v0wnsubGiven) |
|||
model->BSIM3v0wnsub = 0.0; |
|||
if (!model->BSIM3v0wnpeakGiven) |
|||
model->BSIM3v0wnpeak = 0.0; |
|||
if (!model->BSIM3v0wvbmGiven) |
|||
model->BSIM3v0wvbm = 0.0; |
|||
if (!model->BSIM3v0wxtGiven) |
|||
model->BSIM3v0wxt = 0.0; |
|||
if (!model->BSIM3v0wkt1Given) |
|||
model->BSIM3v0wkt1 = 0.0; |
|||
if (!model->BSIM3v0wkt1lGiven) |
|||
model->BSIM3v0wkt1l = 0.0; |
|||
if (!model->BSIM3v0wkt2Given) |
|||
model->BSIM3v0wkt2 = 0.0; |
|||
if (!model->BSIM3v0wk3Given) |
|||
model->BSIM3v0wk3 = 0.0; |
|||
if (!model->BSIM3v0wk3bGiven) |
|||
model->BSIM3v0wk3b = 0.0; |
|||
if (!model->BSIM3v0ww0Given) |
|||
model->BSIM3v0ww0 = 0.0; |
|||
if (!model->BSIM3v0wnlxGiven) |
|||
model->BSIM3v0wnlx = 0.0; |
|||
if (!model->BSIM3v0wdvt0Given) |
|||
model->BSIM3v0wdvt0 = 0.0; |
|||
if (!model->BSIM3v0wdvt1Given) |
|||
model->BSIM3v0wdvt1 = 0.0; |
|||
if (!model->BSIM3v0wdvt2Given) |
|||
model->BSIM3v0wdvt2 = 0.0; |
|||
if (!model->BSIM3v0wdvt0wGiven) |
|||
model->BSIM3v0wdvt0w = 0.0; |
|||
if (!model->BSIM3v0wdvt1wGiven) |
|||
model->BSIM3v0wdvt1w = 0.0; |
|||
if (!model->BSIM3v0wdvt2wGiven) |
|||
model->BSIM3v0wdvt2w = 0.0; |
|||
if (!model->BSIM3v0wdroutGiven) |
|||
model->BSIM3v0wdrout = 0.0; |
|||
if (!model->BSIM3v0wdsubGiven) |
|||
model->BSIM3v0wdsub = 0.0; |
|||
if (!model->BSIM3v0wvth0Given) |
|||
model->BSIM3v0wvth0 = 0.0; |
|||
if (!model->BSIM3v0wuaGiven) |
|||
model->BSIM3v0wua = 0.0; |
|||
if (!model->BSIM3v0wua1Given) |
|||
model->BSIM3v0wua1 = 0.0; |
|||
if (!model->BSIM3v0wubGiven) |
|||
model->BSIM3v0wub = 0.0; |
|||
if (!model->BSIM3v0wub1Given) |
|||
model->BSIM3v0wub1 = 0.0; |
|||
if (!model->BSIM3v0wucGiven) |
|||
model->BSIM3v0wuc = 0.0; |
|||
if (!model->BSIM3v0wuc1Given) |
|||
model->BSIM3v0wuc1 = 0.0; |
|||
if (!model->BSIM3v0wu0Given) |
|||
model->BSIM3v0wu0 = 0.0; |
|||
else if (model->BSIM3v0u0 > 1.0) |
|||
model->BSIM3v0wu0 = model->BSIM3v0wu0 / 1.0e4; |
|||
if (!model->BSIM3v0wuteGiven) |
|||
model->BSIM3v0wute = 0.0; |
|||
if (!model->BSIM3v0wvoffGiven) |
|||
model->BSIM3v0wvoff = 0.0; |
|||
if (!model->BSIM3v0wdeltaGiven) |
|||
model->BSIM3v0wdelta = 0.0; |
|||
if (!model->BSIM3v0wrdswGiven) |
|||
model->BSIM3v0wrdsw = 0.0; |
|||
if (!model->BSIM3v0wprwbGiven) |
|||
model->BSIM3v0wprwb = 0.0; |
|||
if (!model->BSIM3v0wprwgGiven) |
|||
model->BSIM3v0wprwg = 0.0; |
|||
if (!model->BSIM3v0wprtGiven) |
|||
model->BSIM3v0wprt = 0.0; |
|||
if (!model->BSIM3v0weta0Given) |
|||
model->BSIM3v0weta0 = 0.0; |
|||
if (!model->BSIM3v0wetabGiven) |
|||
model->BSIM3v0wetab = 0.0; |
|||
if (!model->BSIM3v0wpclmGiven) |
|||
model->BSIM3v0wpclm = 0.0; |
|||
if (!model->BSIM3v0wpdibl1Given) |
|||
model->BSIM3v0wpdibl1 = 0.0; |
|||
if (!model->BSIM3v0wpdibl2Given) |
|||
model->BSIM3v0wpdibl2 = 0.0; |
|||
if (!model->BSIM3v0wpdiblbGiven) |
|||
model->BSIM3v0wpdiblb = 0.0; |
|||
if (!model->BSIM3v0wpscbe1Given) |
|||
model->BSIM3v0wpscbe1 = 0.0; |
|||
if (!model->BSIM3v0wpscbe2Given) |
|||
model->BSIM3v0wpscbe2 = 0.0; |
|||
if (!model->BSIM3v0wpvagGiven) |
|||
model->BSIM3v0wpvag = 0.0; |
|||
if (!model->BSIM3v0wwrGiven) |
|||
model->BSIM3v0wwr = 0.0; |
|||
if (!model->BSIM3v0wdwgGiven) |
|||
model->BSIM3v0wdwg = 0.0; |
|||
if (!model->BSIM3v0wdwbGiven) |
|||
model->BSIM3v0wdwb = 0.0; |
|||
if (!model->BSIM3v0wb0Given) |
|||
model->BSIM3v0wb0 = 0.0; |
|||
if (!model->BSIM3v0wb1Given) |
|||
model->BSIM3v0wb1 = 0.0; |
|||
if (!model->BSIM3v0walpha0Given) |
|||
model->BSIM3v0walpha0 = 0.0; |
|||
if (!model->BSIM3v0wbeta0Given) |
|||
model->BSIM3v0wbeta0 = 0.0; |
|||
|
|||
if (!model->BSIM3v0welmGiven) |
|||
model->BSIM3v0welm = 0.0; |
|||
if (!model->BSIM3v0wcgslGiven) |
|||
model->BSIM3v0wcgsl = 0.0; |
|||
if (!model->BSIM3v0wcgdlGiven) |
|||
model->BSIM3v0wcgdl = 0.0; |
|||
if (!model->BSIM3v0wckappaGiven) |
|||
model->BSIM3v0wckappa = 0.0; |
|||
if (!model->BSIM3v0wcfGiven) |
|||
model->BSIM3v0wcf = 0.0; |
|||
if (!model->BSIM3v0wclcGiven) |
|||
model->BSIM3v0wclc = 0.0; |
|||
if (!model->BSIM3v0wcleGiven) |
|||
model->BSIM3v0wcle = 0.0; |
|||
|
|||
/* Cross-term dependence */ |
|||
if (!model->BSIM3v0pcdscGiven) |
|||
model->BSIM3v0pcdsc = 0.0; |
|||
if (!model->BSIM3v0pcdscbGiven) |
|||
model->BSIM3v0pcdscb = 0.0; |
|||
if (!model->BSIM3v0pcdscdGiven) |
|||
model->BSIM3v0pcdscd = 0.0; |
|||
if (!model->BSIM3v0pcitGiven) |
|||
model->BSIM3v0pcit = 0.0; |
|||
if (!model->BSIM3v0pnfactorGiven) |
|||
model->BSIM3v0pnfactor = 0.0; |
|||
if (!model->BSIM3v0pxjGiven) |
|||
model->BSIM3v0pxj = 0.0; |
|||
if (!model->BSIM3v0pvsatGiven) |
|||
model->BSIM3v0pvsat = 0.0; |
|||
if (!model->BSIM3v0patGiven) |
|||
model->BSIM3v0pat = 0.0; |
|||
if (!model->BSIM3v0pa0Given) |
|||
model->BSIM3v0pa0 = 0.0; |
|||
|
|||
if (!model->BSIM3v0pagsGiven) |
|||
model->BSIM3v0pags = 0.0; |
|||
if (!model->BSIM3v0pa1Given) |
|||
model->BSIM3v0pa1 = 0.0; |
|||
if (!model->BSIM3v0pa2Given) |
|||
model->BSIM3v0pa2 = 0.0; |
|||
if (!model->BSIM3v0pketaGiven) |
|||
model->BSIM3v0pketa = 0.0; |
|||
if (!model->BSIM3v0pnsubGiven) |
|||
model->BSIM3v0pnsub = 0.0; |
|||
if (!model->BSIM3v0pnpeakGiven) |
|||
model->BSIM3v0pnpeak = 0.0; |
|||
if (!model->BSIM3v0pvbmGiven) |
|||
model->BSIM3v0pvbm = 0.0; |
|||
if (!model->BSIM3v0pxtGiven) |
|||
model->BSIM3v0pxt = 0.0; |
|||
if (!model->BSIM3v0pkt1Given) |
|||
model->BSIM3v0pkt1 = 0.0; |
|||
if (!model->BSIM3v0pkt1lGiven) |
|||
model->BSIM3v0pkt1l = 0.0; |
|||
if (!model->BSIM3v0pkt2Given) |
|||
model->BSIM3v0pkt2 = 0.0; |
|||
if (!model->BSIM3v0pk3Given) |
|||
model->BSIM3v0pk3 = 0.0; |
|||
if (!model->BSIM3v0pk3bGiven) |
|||
model->BSIM3v0pk3b = 0.0; |
|||
if (!model->BSIM3v0pw0Given) |
|||
model->BSIM3v0pw0 = 0.0; |
|||
if (!model->BSIM3v0pnlxGiven) |
|||
model->BSIM3v0pnlx = 0.0; |
|||
if (!model->BSIM3v0pdvt0Given) |
|||
model->BSIM3v0pdvt0 = 0.0; |
|||
if (!model->BSIM3v0pdvt1Given) |
|||
model->BSIM3v0pdvt1 = 0.0; |
|||
if (!model->BSIM3v0pdvt2Given) |
|||
model->BSIM3v0pdvt2 = 0.0; |
|||
if (!model->BSIM3v0pdvt0wGiven) |
|||
model->BSIM3v0pdvt0w = 0.0; |
|||
if (!model->BSIM3v0pdvt1wGiven) |
|||
model->BSIM3v0pdvt1w = 0.0; |
|||
if (!model->BSIM3v0pdvt2wGiven) |
|||
model->BSIM3v0pdvt2w = 0.0; |
|||
if (!model->BSIM3v0pdroutGiven) |
|||
model->BSIM3v0pdrout = 0.0; |
|||
if (!model->BSIM3v0pdsubGiven) |
|||
model->BSIM3v0pdsub = 0.0; |
|||
if (!model->BSIM3v0pvth0Given) |
|||
model->BSIM3v0pvth0 = 0.0; |
|||
if (!model->BSIM3v0puaGiven) |
|||
model->BSIM3v0pua = 0.0; |
|||
if (!model->BSIM3v0pua1Given) |
|||
model->BSIM3v0pua1 = 0.0; |
|||
if (!model->BSIM3v0pubGiven) |
|||
model->BSIM3v0pub = 0.0; |
|||
if (!model->BSIM3v0pub1Given) |
|||
model->BSIM3v0pub1 = 0.0; |
|||
if (!model->BSIM3v0pucGiven) |
|||
model->BSIM3v0puc = 0.0; |
|||
if (!model->BSIM3v0puc1Given) |
|||
model->BSIM3v0puc1 = 0.0; |
|||
if (!model->BSIM3v0pu0Given) |
|||
model->BSIM3v0pu0 = 0.0; |
|||
else if (model->BSIM3v0u0 > 1.0) |
|||
model->BSIM3v0pu0 = model->BSIM3v0pu0 / 1.0e4; |
|||
if (!model->BSIM3v0puteGiven) |
|||
model->BSIM3v0pute = 0.0; |
|||
if (!model->BSIM3v0pvoffGiven) |
|||
model->BSIM3v0pvoff = 0.0; |
|||
if (!model->BSIM3v0pdeltaGiven) |
|||
model->BSIM3v0pdelta = 0.0; |
|||
if (!model->BSIM3v0prdswGiven) |
|||
model->BSIM3v0prdsw = 0.0; |
|||
if (!model->BSIM3v0pprwbGiven) |
|||
model->BSIM3v0pprwb = 0.0; |
|||
if (!model->BSIM3v0pprwgGiven) |
|||
model->BSIM3v0pprwg = 0.0; |
|||
if (!model->BSIM3v0pprtGiven) |
|||
model->BSIM3v0pprt = 0.0; |
|||
if (!model->BSIM3v0peta0Given) |
|||
model->BSIM3v0peta0 = 0.0; |
|||
if (!model->BSIM3v0petabGiven) |
|||
model->BSIM3v0petab = 0.0; |
|||
if (!model->BSIM3v0ppclmGiven) |
|||
model->BSIM3v0ppclm = 0.0; |
|||
if (!model->BSIM3v0ppdibl1Given) |
|||
model->BSIM3v0ppdibl1 = 0.0; |
|||
if (!model->BSIM3v0ppdibl2Given) |
|||
model->BSIM3v0ppdibl2 = 0.0; |
|||
if (!model->BSIM3v0ppdiblbGiven) |
|||
model->BSIM3v0ppdiblb = 0.0; |
|||
if (!model->BSIM3v0ppscbe1Given) |
|||
model->BSIM3v0ppscbe1 = 0.0; |
|||
if (!model->BSIM3v0ppscbe2Given) |
|||
model->BSIM3v0ppscbe2 = 0.0; |
|||
if (!model->BSIM3v0ppvagGiven) |
|||
model->BSIM3v0ppvag = 0.0; |
|||
if (!model->BSIM3v0pwrGiven) |
|||
model->BSIM3v0pwr = 0.0; |
|||
if (!model->BSIM3v0pdwgGiven) |
|||
model->BSIM3v0pdwg = 0.0; |
|||
if (!model->BSIM3v0pdwbGiven) |
|||
model->BSIM3v0pdwb = 0.0; |
|||
if (!model->BSIM3v0pb0Given) |
|||
model->BSIM3v0pb0 = 0.0; |
|||
if (!model->BSIM3v0pb1Given) |
|||
model->BSIM3v0pb1 = 0.0; |
|||
if (!model->BSIM3v0palpha0Given) |
|||
model->BSIM3v0palpha0 = 0.0; |
|||
if (!model->BSIM3v0pbeta0Given) |
|||
model->BSIM3v0pbeta0 = 0.0; |
|||
|
|||
if (!model->BSIM3v0pelmGiven) |
|||
model->BSIM3v0pelm = 0.0; |
|||
if (!model->BSIM3v0pcgslGiven) |
|||
model->BSIM3v0pcgsl = 0.0; |
|||
if (!model->BSIM3v0pcgdlGiven) |
|||
model->BSIM3v0pcgdl = 0.0; |
|||
if (!model->BSIM3v0pckappaGiven) |
|||
model->BSIM3v0pckappa = 0.0; |
|||
if (!model->BSIM3v0pcfGiven) |
|||
model->BSIM3v0pcf = 0.0; |
|||
if (!model->BSIM3v0pclcGiven) |
|||
model->BSIM3v0pclc = 0.0; |
|||
if (!model->BSIM3v0pcleGiven) |
|||
model->BSIM3v0pcle = 0.0; |
|||
|
|||
/* unit degree celcius */ |
|||
if (!model->BSIM3v0tnomGiven) |
|||
model->BSIM3v0tnom = ckt->CKTnomTemp; |
|||
if (!model->BSIM3v0LintGiven) |
|||
model->BSIM3v0Lint = 0.0; |
|||
if (!model->BSIM3v0LlGiven) |
|||
model->BSIM3v0Ll = 0.0; |
|||
if (!model->BSIM3v0LlnGiven) |
|||
model->BSIM3v0Lln = 1.0; |
|||
if (!model->BSIM3v0LwGiven) |
|||
model->BSIM3v0Lw = 0.0; |
|||
if (!model->BSIM3v0LwnGiven) |
|||
model->BSIM3v0Lwn = 1.0; |
|||
if (!model->BSIM3v0LwlGiven) |
|||
model->BSIM3v0Lwl = 0.0; |
|||
if (!model->BSIM3v0LminGiven) |
|||
model->BSIM3v0Lmin = 0.0; |
|||
if (!model->BSIM3v0LmaxGiven) |
|||
model->BSIM3v0Lmax = 1.0; |
|||
if (!model->BSIM3v0WintGiven) |
|||
model->BSIM3v0Wint = 0.0; |
|||
if (!model->BSIM3v0WlGiven) |
|||
model->BSIM3v0Wl = 0.0; |
|||
if (!model->BSIM3v0WlnGiven) |
|||
model->BSIM3v0Wln = 1.0; |
|||
if (!model->BSIM3v0WwGiven) |
|||
model->BSIM3v0Ww = 0.0; |
|||
if (!model->BSIM3v0WwnGiven) |
|||
model->BSIM3v0Wwn = 1.0; |
|||
if (!model->BSIM3v0WwlGiven) |
|||
model->BSIM3v0Wwl = 0.0; |
|||
if (!model->BSIM3v0WminGiven) |
|||
model->BSIM3v0Wmin = 0.0; |
|||
if (!model->BSIM3v0WmaxGiven) |
|||
model->BSIM3v0Wmax = 1.0; |
|||
if (!model->BSIM3v0dwcGiven) |
|||
model->BSIM3v0dwc = model->BSIM3v0Wint; |
|||
if (!model->BSIM3v0dlcGiven) |
|||
model->BSIM3v0dlc = model->BSIM3v0Lint; |
|||
if (!model->BSIM3v0cfGiven) |
|||
model->BSIM3v0cf = 2.0 * EPSOX / PI |
|||
* log(1.0 + 0.4e-6 / model->BSIM3v0tox); |
|||
if (!model->BSIM3v0cgdoGiven) |
|||
{ if (model->BSIM3v0dlcGiven && (model->BSIM3v0dlc > 0.0)) |
|||
{ model->BSIM3v0cgdo = model->BSIM3v0dlc * model->BSIM3v0cox |
|||
- model->BSIM3v0cgdl ; |
|||
if (model->BSIM3v0cgdo < 0.0) |
|||
model->BSIM3v0cgdo = 0.0; |
|||
} |
|||
else |
|||
model->BSIM3v0cgdo = 0.6 * model->BSIM3v0xj * model->BSIM3v0cox; |
|||
} |
|||
if (!model->BSIM3v0cgsoGiven) |
|||
{ if (model->BSIM3v0dlcGiven && (model->BSIM3v0dlc > 0.0)) |
|||
{ model->BSIM3v0cgso = model->BSIM3v0dlc * model->BSIM3v0cox |
|||
- model->BSIM3v0cgsl ; |
|||
if (model->BSIM3v0cgso < 0.0) |
|||
model->BSIM3v0cgso = 0.0; |
|||
} |
|||
else |
|||
model->BSIM3v0cgso = 0.6 * model->BSIM3v0xj * model->BSIM3v0cox; |
|||
} |
|||
|
|||
if (!model->BSIM3v0cgboGiven) |
|||
model->BSIM3v0cgbo = 0.0; |
|||
if (!model->BSIM3v0xpartGiven) |
|||
model->BSIM3v0xpart = 0.0; |
|||
if (!model->BSIM3v0sheetResistanceGiven) |
|||
model->BSIM3v0sheetResistance = 0.0; |
|||
if (!model->BSIM3v0unitAreaJctCapGiven) |
|||
model->BSIM3v0unitAreaJctCap = 5.0E-4; |
|||
if (!model->BSIM3v0unitLengthSidewallJctCapGiven) |
|||
model->BSIM3v0unitLengthSidewallJctCap = 5.0E-10; |
|||
if (!model->BSIM3v0jctSatCurDensityGiven) |
|||
model->BSIM3v0jctSatCurDensity = 1.0E-4; |
|||
if (!model->BSIM3v0bulkJctPotentialGiven) |
|||
model->BSIM3v0bulkJctPotential = 1.0; |
|||
if (!model->BSIM3v0sidewallJctPotentialGiven) |
|||
model->BSIM3v0sidewallJctPotential = 1.0; |
|||
if (!model->BSIM3v0bulkJctBotGradingCoeffGiven) |
|||
model->BSIM3v0bulkJctBotGradingCoeff = 0.5; |
|||
if (!model->BSIM3v0bulkJctSideGradingCoeffGiven) |
|||
model->BSIM3v0bulkJctSideGradingCoeff = 0.33; |
|||
if (!model->BSIM3v0oxideTrapDensityAGiven) |
|||
{ if (model->BSIM3v0type == NMOS) |
|||
model->BSIM3v0oxideTrapDensityA = 1e20; |
|||
else |
|||
model->BSIM3v0oxideTrapDensityA=9.9e18; |
|||
} |
|||
if (!model->BSIM3v0oxideTrapDensityBGiven) |
|||
{ if (model->BSIM3v0type == NMOS) |
|||
model->BSIM3v0oxideTrapDensityB = 5e4; |
|||
else |
|||
model->BSIM3v0oxideTrapDensityB = 2.4e3; |
|||
} |
|||
if (!model->BSIM3v0oxideTrapDensityCGiven) |
|||
{ if (model->BSIM3v0type == NMOS) |
|||
model->BSIM3v0oxideTrapDensityC = -1.4e-12; |
|||
else |
|||
model->BSIM3v0oxideTrapDensityC = 1.4e-12; |
|||
|
|||
} |
|||
if (!model->BSIM3v0emGiven) |
|||
model->BSIM3v0em = 4.1e7; /* V/m */ |
|||
if (!model->BSIM3v0efGiven) |
|||
model->BSIM3v0ef = 1.0; |
|||
if (!model->BSIM3v0afGiven) |
|||
model->BSIM3v0af = 1.0; |
|||
if (!model->BSIM3v0kfGiven) |
|||
model->BSIM3v0kf = 0.0; |
|||
/* loop through all the instances of the model */ |
|||
for (here = model->BSIM3v0instances; here != NULL ; |
|||
here=here->BSIM3v0nextInstance) |
|||
{ |
|||
|
|||
if (here->BSIM3v0owner == ARCHme) |
|||
{ |
|||
/* allocate a chunk of the state vector */ |
|||
here->BSIM3v0states = *states; |
|||
*states += BSIM3v0numStates; |
|||
} |
|||
|
|||
/* perform the parameter defaulting */ |
|||
if (!here->BSIM3v0drainAreaGiven) |
|||
here->BSIM3v0drainArea = 0.0; |
|||
if (!here->BSIM3v0drainPerimeterGiven) |
|||
here->BSIM3v0drainPerimeter = 0.0; |
|||
if (!here->BSIM3v0drainSquaresGiven) |
|||
here->BSIM3v0drainSquares = 1.0; |
|||
if (!here->BSIM3v0icVBSGiven) |
|||
here->BSIM3v0icVBS = 0; |
|||
if (!here->BSIM3v0icVDSGiven) |
|||
here->BSIM3v0icVDS = 0; |
|||
if (!here->BSIM3v0icVGSGiven) |
|||
here->BSIM3v0icVGS = 0; |
|||
if (!here->BSIM3v0lGiven) |
|||
here->BSIM3v0l = 5e-6; |
|||
if (!here->BSIM3v0sourceAreaGiven) |
|||
here->BSIM3v0sourceArea = 0; |
|||
if (!here->BSIM3v0sourcePerimeterGiven) |
|||
here->BSIM3v0sourcePerimeter = 0; |
|||
if (!here->BSIM3v0sourceSquaresGiven) |
|||
here->BSIM3v0sourceSquares = 1; |
|||
if (!here->BSIM3v0wGiven) |
|||
here->BSIM3v0w = 5e-6; |
|||
|
|||
if (!here->BSIM3v0mGiven) |
|||
here->BSIM3v0m = 1; |
|||
|
|||
if (!here->BSIM3v0nqsModGiven) |
|||
here->BSIM3v0nqsMod = model->BSIM3v0nqsMod; |
|||
|
|||
/* process drain series resistance */ |
|||
if ((model->BSIM3v0sheetResistance > 0.0) && |
|||
(here->BSIM3v0drainSquares > 0.0 ) && |
|||
(here->BSIM3v0dNodePrime == 0)) |
|||
{ error = CKTmkVolt(ckt,&tmp,here->BSIM3v0name,"drain"); |
|||
if(error) return(error); |
|||
here->BSIM3v0dNodePrime = 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->BSIM3v0dNodePrime = here->BSIM3v0dNode; |
|||
} |
|||
|
|||
/* process source series resistance */ |
|||
if ((model->BSIM3v0sheetResistance > 0.0) && |
|||
(here->BSIM3v0sourceSquares > 0.0 ) && |
|||
(here->BSIM3v0sNodePrime == 0)) |
|||
{ error = CKTmkVolt(ckt,&tmp,here->BSIM3v0name,"source"); |
|||
if(error) return(error); |
|||
here->BSIM3v0sNodePrime = 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->BSIM3v0sNodePrime = here->BSIM3v0sNode; |
|||
} |
|||
|
|||
/* internal charge node */ |
|||
|
|||
if ((here->BSIM3v0nqsMod) && (here->BSIM3v0qNode == 0)) |
|||
{ error = CKTmkVolt(ckt,&tmp,here->BSIM3v0name,"charge"); |
|||
if(error) return(error); |
|||
here->BSIM3v0qNode = tmp->number; |
|||
} |
|||
else |
|||
{ here->BSIM3v0qNode = 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(BSIM3v0DdPtr, BSIM3v0dNode, BSIM3v0dNode) |
|||
TSTALLOC(BSIM3v0GgPtr, BSIM3v0gNode, BSIM3v0gNode) |
|||
TSTALLOC(BSIM3v0SsPtr, BSIM3v0sNode, BSIM3v0sNode) |
|||
TSTALLOC(BSIM3v0BbPtr, BSIM3v0bNode, BSIM3v0bNode) |
|||
TSTALLOC(BSIM3v0DPdpPtr, BSIM3v0dNodePrime, BSIM3v0dNodePrime) |
|||
TSTALLOC(BSIM3v0SPspPtr, BSIM3v0sNodePrime, BSIM3v0sNodePrime) |
|||
TSTALLOC(BSIM3v0DdpPtr, BSIM3v0dNode, BSIM3v0dNodePrime) |
|||
TSTALLOC(BSIM3v0GbPtr, BSIM3v0gNode, BSIM3v0bNode) |
|||
TSTALLOC(BSIM3v0GdpPtr, BSIM3v0gNode, BSIM3v0dNodePrime) |
|||
TSTALLOC(BSIM3v0GspPtr, BSIM3v0gNode, BSIM3v0sNodePrime) |
|||
TSTALLOC(BSIM3v0SspPtr, BSIM3v0sNode, BSIM3v0sNodePrime) |
|||
TSTALLOC(BSIM3v0BdpPtr, BSIM3v0bNode, BSIM3v0dNodePrime) |
|||
TSTALLOC(BSIM3v0BspPtr, BSIM3v0bNode, BSIM3v0sNodePrime) |
|||
TSTALLOC(BSIM3v0DPspPtr, BSIM3v0dNodePrime, BSIM3v0sNodePrime) |
|||
TSTALLOC(BSIM3v0DPdPtr, BSIM3v0dNodePrime, BSIM3v0dNode) |
|||
TSTALLOC(BSIM3v0BgPtr, BSIM3v0bNode, BSIM3v0gNode) |
|||
TSTALLOC(BSIM3v0DPgPtr, BSIM3v0dNodePrime, BSIM3v0gNode) |
|||
TSTALLOC(BSIM3v0SPgPtr, BSIM3v0sNodePrime, BSIM3v0gNode) |
|||
TSTALLOC(BSIM3v0SPsPtr, BSIM3v0sNodePrime, BSIM3v0sNode) |
|||
TSTALLOC(BSIM3v0DPbPtr, BSIM3v0dNodePrime, BSIM3v0bNode) |
|||
TSTALLOC(BSIM3v0SPbPtr, BSIM3v0sNodePrime, BSIM3v0bNode) |
|||
TSTALLOC(BSIM3v0SPdpPtr, BSIM3v0sNodePrime, BSIM3v0dNodePrime) |
|||
|
|||
TSTALLOC(BSIM3v0QqPtr, BSIM3v0qNode, BSIM3v0qNode) |
|||
|
|||
TSTALLOC(BSIM3v0QdpPtr, BSIM3v0qNode, BSIM3v0dNodePrime) |
|||
TSTALLOC(BSIM3v0QspPtr, BSIM3v0qNode, BSIM3v0sNodePrime) |
|||
TSTALLOC(BSIM3v0QgPtr, BSIM3v0qNode, BSIM3v0gNode) |
|||
TSTALLOC(BSIM3v0QbPtr, BSIM3v0qNode, BSIM3v0bNode) |
|||
TSTALLOC(BSIM3v0DPqPtr, BSIM3v0dNodePrime, BSIM3v0qNode) |
|||
TSTALLOC(BSIM3v0SPqPtr, BSIM3v0sNodePrime, BSIM3v0qNode) |
|||
TSTALLOC(BSIM3v0GqPtr, BSIM3v0gNode, BSIM3v0qNode) |
|||
TSTALLOC(BSIM3v0BqPtr, BSIM3v0bNode, BSIM3v0qNode) |
|||
|
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
|
|||
int |
|||
BSIM3v0unsetup(GENmodel *inModel, CKTcircuit *ckt) |
|||
{ |
|||
BSIM3v0model *model; |
|||
BSIM3v0instance *here; |
|||
|
|||
for (model = (BSIM3v0model *)inModel; model != NULL; |
|||
model = model->BSIM3v0nextModel) |
|||
{ |
|||
for (here = model->BSIM3v0instances; here != NULL; |
|||
here=here->BSIM3v0nextInstance) |
|||
{ |
|||
if (here->BSIM3v0dNodePrime |
|||
&& here->BSIM3v0dNodePrime != here->BSIM3v0dNode) |
|||
{ |
|||
CKTdltNNum(ckt, here->BSIM3v0dNodePrime); |
|||
here->BSIM3v0dNodePrime = 0; |
|||
} |
|||
if (here->BSIM3v0sNodePrime |
|||
&& here->BSIM3v0sNodePrime != here->BSIM3v0sNode) |
|||
{ |
|||
CKTdltNNum(ckt, here->BSIM3v0sNodePrime); |
|||
here->BSIM3v0sNodePrime = 0; |
|||
} |
|||
} |
|||
} |
|||
return OK; |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,631 @@ |
|||
/*********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0temp.c |
|||
**********/ |
|||
/* Lmin, Lmax, Wmin, Wmax */ |
|||
|
|||
#include "ngspice.h" |
|||
#include "smpdefs.h" |
|||
#include "cktdefs.h" |
|||
#include "bsim3v0def.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 |
|||
BSIM3v0temp(GENmodel *inModel, CKTcircuit *ckt) |
|||
{ |
|||
register BSIM3v0model *model = (BSIM3v0model*) inModel; |
|||
register BSIM3v0instance *here; |
|||
struct bsim3v0SizeDependParam *pSizeDependParamKnot, *pLastKnot, *pParam; |
|||
double tmp, tmp1, tmp2, Eg, ni, T0, T1, T2, T3, T4, T5, Ldrn, Wdrn; |
|||
double Temp, TRatio, Inv_L, Inv_W, Inv_LW, Dw, Dl, Vtm0, Tnom; |
|||
int Size_Not_Found; |
|||
|
|||
/* loop through all the BSIM3v0 device models */ |
|||
for (; model != NULL; model = model->BSIM3v0nextModel) |
|||
{ Temp = ckt->CKTtemp; |
|||
if (model->BSIM3v0bulkJctPotential < 0.1) |
|||
model->BSIM3v0bulkJctPotential = 0.1; |
|||
if (model->BSIM3v0sidewallJctPotential < 0.1) |
|||
model->BSIM3v0sidewallJctPotential = 0.1; |
|||
model->pSizeDependParamKnot = NULL; |
|||
pLastKnot = NULL; |
|||
|
|||
Tnom = model->BSIM3v0tnom; |
|||
TRatio = Temp / Tnom; |
|||
|
|||
/* loop through all the instances of the model */ |
|||
for (here = model->BSIM3v0instances; here != NULL; |
|||
here=here->BSIM3v0nextInstance) |
|||
{ |
|||
|
|||
if (here->BSIM3v0owner != ARCHme) |
|||
continue; |
|||
|
|||
pSizeDependParamKnot = model->pSizeDependParamKnot; |
|||
Size_Not_Found = 1; |
|||
while ((pSizeDependParamKnot != NULL) && Size_Not_Found) |
|||
{ if ((here->BSIM3v0l == pSizeDependParamKnot->Length) |
|||
&& (here->BSIM3v0w == pSizeDependParamKnot->Width)) |
|||
{ Size_Not_Found = 0; |
|||
here->pParam = pSizeDependParamKnot; |
|||
} |
|||
else |
|||
{ pLastKnot = pSizeDependParamKnot; |
|||
pSizeDependParamKnot = pSizeDependParamKnot->pNext; |
|||
} |
|||
} |
|||
|
|||
if (Size_Not_Found) |
|||
{ pParam = (struct bsim3v0SizeDependParam *)tmalloc( |
|||
sizeof(struct bsim3v0SizeDependParam)); |
|||
if (pLastKnot == NULL) |
|||
model->pSizeDependParamKnot = pParam; |
|||
else |
|||
pLastKnot->pNext = pParam; |
|||
pParam->pNext = NULL; |
|||
here->pParam = pParam; |
|||
|
|||
Ldrn = here->BSIM3v0l; |
|||
Wdrn = here->BSIM3v0w; |
|||
|
|||
T0 = pow(Ldrn, model->BSIM3v0Lln); |
|||
T1 = pow(Wdrn, model->BSIM3v0Lwn); |
|||
tmp1 = model->BSIM3v0Ll / T0 + model->BSIM3v0Lw / T1 |
|||
+ model->BSIM3v0Lwl / (T0 * T1); |
|||
pParam->BSIM3v0dl = model->BSIM3v0Lint + tmp1; |
|||
pParam->BSIM3v0dlc = model->BSIM3v0dlc + tmp1; |
|||
|
|||
T2 = pow(Ldrn, model->BSIM3v0Wln); |
|||
T3 = pow(Wdrn, model->BSIM3v0Wwn); |
|||
tmp2 = model->BSIM3v0Wl / T2 + model->BSIM3v0Ww / T3 |
|||
+ model->BSIM3v0Wwl / (T2 * T3); |
|||
pParam->BSIM3v0dw = model->BSIM3v0Wint + tmp2; |
|||
pParam->BSIM3v0dwc = model->BSIM3v0dwc + tmp2; |
|||
|
|||
pParam->BSIM3v0leff = here->BSIM3v0l - 2.0 * pParam->BSIM3v0dl; |
|||
if (pParam->BSIM3v0leff <= 0.0) |
|||
{ IFuid namarray[2]; |
|||
namarray[0] = model->BSIM3v0modName; |
|||
namarray[1] = here->BSIM3v0name; |
|||
(*(SPfrontEnd->IFerror))(ERR_FATAL, |
|||
"BSIM3v0: mosfet %s, model %s: Effective channel length <= 0", |
|||
namarray); |
|||
return(E_BADPARM); |
|||
} |
|||
|
|||
pParam->BSIM3v0weff = here->BSIM3v0w - 2.0 * pParam->BSIM3v0dw; |
|||
if (pParam->BSIM3v0weff <= 0.0) |
|||
{ IFuid namarray[2]; |
|||
namarray[0] = model->BSIM3v0modName; |
|||
namarray[1] = here->BSIM3v0name; |
|||
(*(SPfrontEnd->IFerror))(ERR_FATAL, |
|||
"BSIM3v0: mosfet %s, model %s: Effective channel width <= 0", |
|||
namarray); |
|||
return(E_BADPARM); |
|||
} |
|||
|
|||
pParam->BSIM3v0leffCV = here->BSIM3v0l - 2.0 * pParam->BSIM3v0dlc; |
|||
if (pParam->BSIM3v0leffCV <= 0.0) |
|||
{ IFuid namarray[2]; |
|||
namarray[0] = model->BSIM3v0modName; |
|||
namarray[1] = here->BSIM3v0name; |
|||
(*(SPfrontEnd->IFerror))(ERR_FATAL, |
|||
"BSIM3v0: mosfet %s, model %s: Effective channel length for C-V <= 0", |
|||
namarray); |
|||
return(E_BADPARM); |
|||
} |
|||
|
|||
pParam->BSIM3v0weffCV = here->BSIM3v0w - 2.0 * pParam->BSIM3v0dwc; |
|||
if (pParam->BSIM3v0weffCV <= 0.0) |
|||
{ IFuid namarray[2]; |
|||
namarray[0] = model->BSIM3v0modName; |
|||
namarray[1] = here->BSIM3v0name; |
|||
(*(SPfrontEnd->IFerror))(ERR_FATAL, |
|||
"BSIM3v0: mosfet %s, model %s: Effective channel width for C-V <= 0", |
|||
namarray); |
|||
return(E_BADPARM); |
|||
} |
|||
|
|||
model->BSIM3v0vcrit = CONSTvt0 * log(CONSTvt0 |
|||
/ (CONSTroot2 * 1.0e-14)); |
|||
model->BSIM3v0factor1 = sqrt(EPSSI / EPSOX * model->BSIM3v0tox); |
|||
|
|||
|
|||
if (model->BSIM3v0binUnit == 1) |
|||
{ Inv_L = 1.0e-6 / pParam->BSIM3v0leff; |
|||
Inv_W = 1.0e-6 / pParam->BSIM3v0weff; |
|||
Inv_LW = 1.0e-12 / (pParam->BSIM3v0leff |
|||
* pParam->BSIM3v0weff); |
|||
} |
|||
else |
|||
{ Inv_L = 1.0 / pParam->BSIM3v0leff; |
|||
Inv_W = 1.0 / pParam->BSIM3v0weff; |
|||
Inv_LW = 1.0 / (pParam->BSIM3v0leff |
|||
* pParam->BSIM3v0weff); |
|||
} |
|||
pParam->BSIM3v0cdsc = model->BSIM3v0cdsc |
|||
+ model->BSIM3v0lcdsc * Inv_L |
|||
+ model->BSIM3v0wcdsc * Inv_W |
|||
+ model->BSIM3v0pcdsc * Inv_LW; |
|||
pParam->BSIM3v0cdscb = model->BSIM3v0cdscb |
|||
+ model->BSIM3v0lcdscb * Inv_L |
|||
+ model->BSIM3v0wcdscb * Inv_W |
|||
+ model->BSIM3v0pcdscb * Inv_LW; |
|||
|
|||
pParam->BSIM3v0cdscd = model->BSIM3v0cdscd |
|||
+ model->BSIM3v0lcdscd * Inv_L |
|||
+ model->BSIM3v0wcdscd * Inv_W |
|||
+ model->BSIM3v0pcdscd * Inv_LW; |
|||
|
|||
pParam->BSIM3v0cit = model->BSIM3v0cit |
|||
+ model->BSIM3v0lcit * Inv_L |
|||
+ model->BSIM3v0wcit * Inv_W |
|||
+ model->BSIM3v0pcit * Inv_LW; |
|||
pParam->BSIM3v0nfactor = model->BSIM3v0nfactor |
|||
+ model->BSIM3v0lnfactor * Inv_L |
|||
+ model->BSIM3v0wnfactor * Inv_W |
|||
+ model->BSIM3v0pnfactor * Inv_LW; |
|||
pParam->BSIM3v0xj = model->BSIM3v0xj |
|||
+ model->BSIM3v0lxj * Inv_L |
|||
+ model->BSIM3v0wxj * Inv_W |
|||
+ model->BSIM3v0pxj * Inv_LW; |
|||
pParam->BSIM3v0vsat = model->BSIM3v0vsat |
|||
+ model->BSIM3v0lvsat * Inv_L |
|||
+ model->BSIM3v0wvsat * Inv_W |
|||
+ model->BSIM3v0pvsat * Inv_LW; |
|||
pParam->BSIM3v0at = model->BSIM3v0at |
|||
+ model->BSIM3v0lat * Inv_L |
|||
+ model->BSIM3v0wat * Inv_W |
|||
+ model->BSIM3v0pat * Inv_LW; |
|||
pParam->BSIM3v0a0 = model->BSIM3v0a0 |
|||
+ model->BSIM3v0la0 * Inv_L |
|||
+ model->BSIM3v0wa0 * Inv_W |
|||
+ model->BSIM3v0pa0 * Inv_LW; |
|||
|
|||
pParam->BSIM3v0ags = model->BSIM3v0ags |
|||
+ model->BSIM3v0lags * Inv_L |
|||
+ model->BSIM3v0wags * Inv_W |
|||
+ model->BSIM3v0pags * Inv_LW; |
|||
|
|||
pParam->BSIM3v0a1 = model->BSIM3v0a1 |
|||
+ model->BSIM3v0la1 * Inv_L |
|||
+ model->BSIM3v0wa1 * Inv_W |
|||
+ model->BSIM3v0pa1 * Inv_LW; |
|||
pParam->BSIM3v0a2 = model->BSIM3v0a2 |
|||
+ model->BSIM3v0la2 * Inv_L |
|||
+ model->BSIM3v0wa2 * Inv_W |
|||
+ model->BSIM3v0pa2 * Inv_LW; |
|||
pParam->BSIM3v0keta = model->BSIM3v0keta |
|||
+ model->BSIM3v0lketa * Inv_L |
|||
+ model->BSIM3v0wketa * Inv_W |
|||
+ model->BSIM3v0pketa * Inv_LW; |
|||
pParam->BSIM3v0nsub = model->BSIM3v0nsub |
|||
+ model->BSIM3v0lnsub * Inv_L |
|||
+ model->BSIM3v0wnsub * Inv_W |
|||
+ model->BSIM3v0pnsub * Inv_LW; |
|||
pParam->BSIM3v0npeak = model->BSIM3v0npeak |
|||
+ model->BSIM3v0lnpeak * Inv_L |
|||
+ model->BSIM3v0wnpeak * Inv_W |
|||
+ model->BSIM3v0pnpeak * Inv_LW; |
|||
pParam->BSIM3v0ngate = model->BSIM3v0ngate |
|||
+ model->BSIM3v0lngate * Inv_L |
|||
+ model->BSIM3v0wngate * Inv_W |
|||
+ model->BSIM3v0pngate * Inv_LW; |
|||
pParam->BSIM3v0gamma1 = model->BSIM3v0gamma1 |
|||
+ model->BSIM3v0lgamma1 * Inv_L |
|||
+ model->BSIM3v0wgamma1 * Inv_W |
|||
+ model->BSIM3v0pgamma1 * Inv_LW; |
|||
pParam->BSIM3v0gamma2 = model->BSIM3v0gamma2 |
|||
+ model->BSIM3v0lgamma2 * Inv_L |
|||
+ model->BSIM3v0wgamma2 * Inv_W |
|||
+ model->BSIM3v0pgamma2 * Inv_LW; |
|||
pParam->BSIM3v0vbx = model->BSIM3v0vbx |
|||
+ model->BSIM3v0lvbx * Inv_L |
|||
+ model->BSIM3v0wvbx * Inv_W |
|||
+ model->BSIM3v0pvbx * Inv_LW; |
|||
pParam->BSIM3v0vbm = model->BSIM3v0vbm |
|||
+ model->BSIM3v0lvbm * Inv_L |
|||
+ model->BSIM3v0wvbm * Inv_W |
|||
+ model->BSIM3v0pvbm * Inv_LW; |
|||
pParam->BSIM3v0xt = model->BSIM3v0xt |
|||
+ model->BSIM3v0lxt * Inv_L |
|||
+ model->BSIM3v0wxt * Inv_W |
|||
+ model->BSIM3v0pxt * Inv_LW; |
|||
pParam->BSIM3v0k1 = model->BSIM3v0k1 |
|||
+ model->BSIM3v0lk1 * Inv_L |
|||
+ model->BSIM3v0wk1 * Inv_W |
|||
+ model->BSIM3v0pk1 * Inv_LW; |
|||
pParam->BSIM3v0kt1 = model->BSIM3v0kt1 |
|||
+ model->BSIM3v0lkt1 * Inv_L |
|||
+ model->BSIM3v0wkt1 * Inv_W |
|||
+ model->BSIM3v0pkt1 * Inv_LW; |
|||
pParam->BSIM3v0kt1l = model->BSIM3v0kt1l |
|||
+ model->BSIM3v0lkt1l * Inv_L |
|||
+ model->BSIM3v0wkt1l * Inv_W |
|||
+ model->BSIM3v0pkt1l * Inv_LW; |
|||
pParam->BSIM3v0k2 = model->BSIM3v0k2 |
|||
+ model->BSIM3v0lk2 * Inv_L |
|||
+ model->BSIM3v0wk2 * Inv_W |
|||
+ model->BSIM3v0pk2 * Inv_LW; |
|||
pParam->BSIM3v0kt2 = model->BSIM3v0kt2 |
|||
+ model->BSIM3v0lkt2 * Inv_L |
|||
+ model->BSIM3v0wkt2 * Inv_W |
|||
+ model->BSIM3v0pkt2 * Inv_LW; |
|||
pParam->BSIM3v0k3 = model->BSIM3v0k3 |
|||
+ model->BSIM3v0lk3 * Inv_L |
|||
+ model->BSIM3v0wk3 * Inv_W |
|||
+ model->BSIM3v0pk3 * Inv_LW; |
|||
pParam->BSIM3v0k3b = model->BSIM3v0k3b |
|||
+ model->BSIM3v0lk3b * Inv_L |
|||
+ model->BSIM3v0wk3b * Inv_W |
|||
+ model->BSIM3v0pk3b * Inv_LW; |
|||
pParam->BSIM3v0w0 = model->BSIM3v0w0 |
|||
+ model->BSIM3v0lw0 * Inv_L |
|||
+ model->BSIM3v0ww0 * Inv_W |
|||
+ model->BSIM3v0pw0 * Inv_LW; |
|||
pParam->BSIM3v0nlx = model->BSIM3v0nlx |
|||
+ model->BSIM3v0lnlx * Inv_L |
|||
+ model->BSIM3v0wnlx * Inv_W |
|||
+ model->BSIM3v0pnlx * Inv_LW; |
|||
pParam->BSIM3v0dvt0 = model->BSIM3v0dvt0 |
|||
+ model->BSIM3v0ldvt0 * Inv_L |
|||
+ model->BSIM3v0wdvt0 * Inv_W |
|||
+ model->BSIM3v0pdvt0 * Inv_LW; |
|||
pParam->BSIM3v0dvt1 = model->BSIM3v0dvt1 |
|||
+ model->BSIM3v0ldvt1 * Inv_L |
|||
+ model->BSIM3v0wdvt1 * Inv_W |
|||
+ model->BSIM3v0pdvt1 * Inv_LW; |
|||
pParam->BSIM3v0dvt2 = model->BSIM3v0dvt2 |
|||
+ model->BSIM3v0ldvt2 * Inv_L |
|||
+ model->BSIM3v0wdvt2 * Inv_W |
|||
+ model->BSIM3v0pdvt2 * Inv_LW; |
|||
pParam->BSIM3v0dvt0w = model->BSIM3v0dvt0w |
|||
+ model->BSIM3v0ldvt0w * Inv_L |
|||
+ model->BSIM3v0wdvt0w * Inv_W |
|||
+ model->BSIM3v0pdvt0w * Inv_LW; |
|||
pParam->BSIM3v0dvt1w = model->BSIM3v0dvt1w |
|||
+ model->BSIM3v0ldvt1w * Inv_L |
|||
+ model->BSIM3v0wdvt1w * Inv_W |
|||
+ model->BSIM3v0pdvt1w * Inv_LW; |
|||
pParam->BSIM3v0dvt2w = model->BSIM3v0dvt2w |
|||
+ model->BSIM3v0ldvt2w * Inv_L |
|||
+ model->BSIM3v0wdvt2w * Inv_W |
|||
+ model->BSIM3v0pdvt2w * Inv_LW; |
|||
pParam->BSIM3v0drout = model->BSIM3v0drout |
|||
+ model->BSIM3v0ldrout * Inv_L |
|||
+ model->BSIM3v0wdrout * Inv_W |
|||
+ model->BSIM3v0pdrout * Inv_LW; |
|||
pParam->BSIM3v0dsub = model->BSIM3v0dsub |
|||
+ model->BSIM3v0ldsub * Inv_L |
|||
+ model->BSIM3v0wdsub * Inv_W |
|||
+ model->BSIM3v0pdsub * Inv_LW; |
|||
pParam->BSIM3v0vth0 = model->BSIM3v0vth0 |
|||
+ model->BSIM3v0lvth0 * Inv_L |
|||
+ model->BSIM3v0wvth0 * Inv_W |
|||
+ model->BSIM3v0pvth0 * Inv_LW; |
|||
pParam->BSIM3v0ua = model->BSIM3v0ua |
|||
+ model->BSIM3v0lua * Inv_L |
|||
+ model->BSIM3v0wua * Inv_W |
|||
+ model->BSIM3v0pua * Inv_LW; |
|||
pParam->BSIM3v0ua1 = model->BSIM3v0ua1 |
|||
+ model->BSIM3v0lua1 * Inv_L |
|||
+ model->BSIM3v0wua1 * Inv_W |
|||
+ model->BSIM3v0pua1 * Inv_LW; |
|||
pParam->BSIM3v0ub = model->BSIM3v0ub |
|||
+ model->BSIM3v0lub * Inv_L |
|||
+ model->BSIM3v0wub * Inv_W |
|||
+ model->BSIM3v0pub * Inv_LW; |
|||
pParam->BSIM3v0ub1 = model->BSIM3v0ub1 |
|||
+ model->BSIM3v0lub1 * Inv_L |
|||
+ model->BSIM3v0wub1 * Inv_W |
|||
+ model->BSIM3v0pub1 * Inv_LW; |
|||
pParam->BSIM3v0uc = model->BSIM3v0uc |
|||
+ model->BSIM3v0luc * Inv_L |
|||
+ model->BSIM3v0wuc * Inv_W |
|||
+ model->BSIM3v0puc * Inv_LW; |
|||
pParam->BSIM3v0uc1 = model->BSIM3v0uc1 |
|||
+ model->BSIM3v0luc1 * Inv_L |
|||
+ model->BSIM3v0wuc1 * Inv_W |
|||
+ model->BSIM3v0puc1 * Inv_LW; |
|||
pParam->BSIM3v0u0 = model->BSIM3v0u0 |
|||
+ model->BSIM3v0lu0 * Inv_L |
|||
+ model->BSIM3v0wu0 * Inv_W |
|||
+ model->BSIM3v0pu0 * Inv_LW; |
|||
pParam->BSIM3v0ute = model->BSIM3v0ute |
|||
+ model->BSIM3v0lute * Inv_L |
|||
+ model->BSIM3v0wute * Inv_W |
|||
+ model->BSIM3v0pute * Inv_LW; |
|||
pParam->BSIM3v0voff = model->BSIM3v0voff |
|||
+ model->BSIM3v0lvoff * Inv_L |
|||
+ model->BSIM3v0wvoff * Inv_W |
|||
+ model->BSIM3v0pvoff * Inv_LW; |
|||
pParam->BSIM3v0delta = model->BSIM3v0delta |
|||
+ model->BSIM3v0ldelta * Inv_L |
|||
+ model->BSIM3v0wdelta * Inv_W |
|||
+ model->BSIM3v0pdelta * Inv_LW; |
|||
pParam->BSIM3v0rdsw = model->BSIM3v0rdsw |
|||
+ model->BSIM3v0lrdsw * Inv_L |
|||
+ model->BSIM3v0wrdsw * Inv_W |
|||
+ model->BSIM3v0prdsw * Inv_LW; |
|||
pParam->BSIM3v0prwg = model->BSIM3v0prwg |
|||
+ model->BSIM3v0lprwg * Inv_L |
|||
+ model->BSIM3v0wprwg * Inv_W |
|||
+ model->BSIM3v0pprwg * Inv_LW; |
|||
pParam->BSIM3v0prwb = model->BSIM3v0prwb |
|||
+ model->BSIM3v0lprwb * Inv_L |
|||
+ model->BSIM3v0wprwb * Inv_W |
|||
+ model->BSIM3v0pprwb * Inv_LW; |
|||
pParam->BSIM3v0prt = model->BSIM3v0prt |
|||
+ model->BSIM3v0lprt * Inv_L |
|||
+ model->BSIM3v0wprt * Inv_W |
|||
+ model->BSIM3v0pprt * Inv_LW; |
|||
pParam->BSIM3v0eta0 = model->BSIM3v0eta0 |
|||
+ model->BSIM3v0leta0 * Inv_L |
|||
+ model->BSIM3v0weta0 * Inv_W |
|||
+ model->BSIM3v0peta0 * Inv_LW; |
|||
pParam->BSIM3v0etab = model->BSIM3v0etab |
|||
+ model->BSIM3v0letab * Inv_L |
|||
+ model->BSIM3v0wetab * Inv_W |
|||
+ model->BSIM3v0petab * Inv_LW; |
|||
pParam->BSIM3v0pclm = model->BSIM3v0pclm |
|||
+ model->BSIM3v0lpclm * Inv_L |
|||
+ model->BSIM3v0wpclm * Inv_W |
|||
+ model->BSIM3v0ppclm * Inv_LW; |
|||
pParam->BSIM3v0pdibl1 = model->BSIM3v0pdibl1 |
|||
+ model->BSIM3v0lpdibl1 * Inv_L |
|||
+ model->BSIM3v0wpdibl1 * Inv_W |
|||
+ model->BSIM3v0ppdibl1 * Inv_LW; |
|||
pParam->BSIM3v0pdibl2 = model->BSIM3v0pdibl2 |
|||
+ model->BSIM3v0lpdibl2 * Inv_L |
|||
+ model->BSIM3v0wpdibl2 * Inv_W |
|||
+ model->BSIM3v0ppdibl2 * Inv_LW; |
|||
pParam->BSIM3v0pdiblb = model->BSIM3v0pdiblb |
|||
+ model->BSIM3v0lpdiblb * Inv_L |
|||
+ model->BSIM3v0wpdiblb * Inv_W |
|||
+ model->BSIM3v0ppdiblb * Inv_LW; |
|||
pParam->BSIM3v0pscbe1 = model->BSIM3v0pscbe1 |
|||
+ model->BSIM3v0lpscbe1 * Inv_L |
|||
+ model->BSIM3v0wpscbe1 * Inv_W |
|||
+ model->BSIM3v0ppscbe1 * Inv_LW; |
|||
pParam->BSIM3v0pscbe2 = model->BSIM3v0pscbe2 |
|||
+ model->BSIM3v0lpscbe2 * Inv_L |
|||
+ model->BSIM3v0wpscbe2 * Inv_W |
|||
+ model->BSIM3v0ppscbe2 * Inv_LW; |
|||
pParam->BSIM3v0pvag = model->BSIM3v0pvag |
|||
+ model->BSIM3v0lpvag * Inv_L |
|||
+ model->BSIM3v0wpvag * Inv_W |
|||
+ model->BSIM3v0ppvag * Inv_LW; |
|||
pParam->BSIM3v0wr = model->BSIM3v0wr |
|||
+ model->BSIM3v0lwr * Inv_L |
|||
+ model->BSIM3v0wwr * Inv_W |
|||
+ model->BSIM3v0pwr * Inv_LW; |
|||
pParam->BSIM3v0dwg = model->BSIM3v0dwg |
|||
+ model->BSIM3v0ldwg * Inv_L |
|||
+ model->BSIM3v0wdwg * Inv_W |
|||
+ model->BSIM3v0pdwg * Inv_LW; |
|||
pParam->BSIM3v0dwb = model->BSIM3v0dwb |
|||
+ model->BSIM3v0ldwb * Inv_L |
|||
+ model->BSIM3v0wdwb * Inv_W |
|||
+ model->BSIM3v0pdwb * Inv_LW; |
|||
pParam->BSIM3v0b0 = model->BSIM3v0b0 |
|||
+ model->BSIM3v0lb0 * Inv_L |
|||
+ model->BSIM3v0wb0 * Inv_W |
|||
+ model->BSIM3v0pb0 * Inv_LW; |
|||
pParam->BSIM3v0b1 = model->BSIM3v0b1 |
|||
+ model->BSIM3v0lb1 * Inv_L |
|||
+ model->BSIM3v0wb1 * Inv_W |
|||
+ model->BSIM3v0pb1 * Inv_LW; |
|||
pParam->BSIM3v0alpha0 = model->BSIM3v0alpha0 |
|||
+ model->BSIM3v0lalpha0 * Inv_L |
|||
+ model->BSIM3v0walpha0 * Inv_W |
|||
+ model->BSIM3v0palpha0 * Inv_LW; |
|||
pParam->BSIM3v0beta0 = model->BSIM3v0beta0 |
|||
+ model->BSIM3v0lbeta0 * Inv_L |
|||
+ model->BSIM3v0wbeta0 * Inv_W |
|||
+ model->BSIM3v0pbeta0 * Inv_LW; |
|||
/* CV model */ |
|||
pParam->BSIM3v0elm = model->BSIM3v0elm |
|||
+ model->BSIM3v0lelm * Inv_L |
|||
+ model->BSIM3v0welm * Inv_W |
|||
+ model->BSIM3v0pelm * Inv_LW; |
|||
pParam->BSIM3v0cgsl = model->BSIM3v0cgsl |
|||
+ model->BSIM3v0lcgsl * Inv_L |
|||
+ model->BSIM3v0wcgsl * Inv_W |
|||
+ model->BSIM3v0pcgsl * Inv_LW; |
|||
pParam->BSIM3v0cgdl = model->BSIM3v0cgdl |
|||
+ model->BSIM3v0lcgdl * Inv_L |
|||
+ model->BSIM3v0wcgdl * Inv_W |
|||
+ model->BSIM3v0pcgdl * Inv_LW; |
|||
pParam->BSIM3v0ckappa = model->BSIM3v0ckappa |
|||
+ model->BSIM3v0lckappa * Inv_L |
|||
+ model->BSIM3v0wckappa * Inv_W |
|||
+ model->BSIM3v0pckappa * Inv_LW; |
|||
pParam->BSIM3v0cf = model->BSIM3v0cf |
|||
+ model->BSIM3v0lcf * Inv_L |
|||
+ model->BSIM3v0wcf * Inv_W |
|||
+ model->BSIM3v0pcf * Inv_LW; |
|||
pParam->BSIM3v0clc = model->BSIM3v0clc |
|||
+ model->BSIM3v0lclc * Inv_L |
|||
+ model->BSIM3v0wclc * Inv_W |
|||
+ model->BSIM3v0pclc * Inv_LW; |
|||
pParam->BSIM3v0cle = model->BSIM3v0cle |
|||
+ model->BSIM3v0lcle * Inv_L |
|||
+ model->BSIM3v0wcle * Inv_W |
|||
+ model->BSIM3v0pcle * Inv_LW; |
|||
pParam->BSIM3v0abulkCVfactor = 1.0 + pow((pParam->BSIM3v0clc |
|||
/ pParam->BSIM3v0leff), |
|||
pParam->BSIM3v0cle); |
|||
|
|||
pParam->BSIM3v0cgdo = (model->BSIM3v0cgdo + pParam->BSIM3v0cf) |
|||
* pParam->BSIM3v0weffCV; |
|||
pParam->BSIM3v0cgso = (model->BSIM3v0cgso + pParam->BSIM3v0cf) |
|||
* pParam->BSIM3v0weffCV; |
|||
pParam->BSIM3v0cgbo = model->BSIM3v0cgbo * pParam->BSIM3v0leffCV; |
|||
|
|||
T0 = (TRatio - 1.0); |
|||
pParam->BSIM3v0ua = pParam->BSIM3v0ua + pParam->BSIM3v0ua1 * T0; |
|||
pParam->BSIM3v0ub = pParam->BSIM3v0ub + pParam->BSIM3v0ub1 * T0; |
|||
pParam->BSIM3v0uc = pParam->BSIM3v0uc + pParam->BSIM3v0uc1 * T0; |
|||
|
|||
pParam->BSIM3v0u0temp = pParam->BSIM3v0u0 |
|||
* pow(TRatio, pParam->BSIM3v0ute); |
|||
pParam->BSIM3v0vsattemp = pParam->BSIM3v0vsat - pParam->BSIM3v0at |
|||
* T0; |
|||
pParam->BSIM3v0rds0 = (pParam->BSIM3v0rdsw + pParam->BSIM3v0prt * T0) |
|||
/ pow(pParam->BSIM3v0weff * 1E6, pParam->BSIM3v0wr); |
|||
|
|||
if (!model->BSIM3v0npeakGiven && model->BSIM3v0gamma1Given) |
|||
{ T0 = pParam->BSIM3v0gamma1 * model->BSIM3v0cox; |
|||
pParam->BSIM3v0npeak = 3.021E22 * T0 * T0; |
|||
} |
|||
|
|||
Vtm0 = KboQ * Tnom; |
|||
Eg = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0); |
|||
ni = 1.45e10 * (Tnom / 300.15) * sqrt(Tnom / 300.15) |
|||
* exp(21.5565981 - Eg / (2.0 * Vtm0)); |
|||
|
|||
pParam->BSIM3v0phi = 2.0 * Vtm0 |
|||
* log(pParam->BSIM3v0npeak / ni); |
|||
|
|||
pParam->BSIM3v0sqrtPhi = sqrt(pParam->BSIM3v0phi); |
|||
pParam->BSIM3v0phis3 = pParam->BSIM3v0sqrtPhi * pParam->BSIM3v0phi; |
|||
|
|||
pParam->BSIM3v0Xdep0 = sqrt(2.0 * EPSSI / (Charge_q |
|||
* pParam->BSIM3v0npeak * 1.0e6)) |
|||
* pParam->BSIM3v0sqrtPhi; |
|||
pParam->BSIM3v0sqrtXdep0 = sqrt(pParam->BSIM3v0Xdep0); |
|||
pParam->BSIM3v0litl = sqrt(3.0 * pParam->BSIM3v0xj |
|||
* model->BSIM3v0tox); |
|||
pParam->BSIM3v0vbi = Vtm0 * log(1.0e20 |
|||
* pParam->BSIM3v0npeak / (ni * ni)); |
|||
pParam->BSIM3v0cdep0 = sqrt(Charge_q * EPSSI |
|||
* pParam->BSIM3v0npeak * 1.0e6 / 2.0 |
|||
/ pParam->BSIM3v0phi); |
|||
|
|||
if (model->BSIM3v0k1Given || model->BSIM3v0k2Given) |
|||
{ if (!model->BSIM3v0k1Given) |
|||
{ fprintf(stdout, "Warning: k1 should be specified with k2.\n"); |
|||
pParam->BSIM3v0k1 = 0.53; |
|||
} |
|||
if (!model->BSIM3v0k2Given) |
|||
{ fprintf(stdout, "Warning: k2 should be specified with k1.\n"); |
|||
pParam->BSIM3v0k2 = -0.0186; |
|||
} |
|||
if (model->BSIM3v0nsubGiven) |
|||
fprintf(stdout, "Warning: nsub is ignored because k1 or k2 is given.\n"); |
|||
if (model->BSIM3v0xtGiven) |
|||
fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n"); |
|||
if (model->BSIM3v0vbxGiven) |
|||
fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n"); |
|||
if (model->BSIM3v0vbmGiven) |
|||
fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n"); |
|||
if (model->BSIM3v0gamma1Given) |
|||
fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n"); |
|||
if (model->BSIM3v0gamma2Given) |
|||
fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n"); |
|||
} |
|||
else |
|||
{ if (!model->BSIM3v0vbxGiven) |
|||
pParam->BSIM3v0vbx = pParam->BSIM3v0phi - 7.7348e-4 |
|||
* pParam->BSIM3v0npeak |
|||
* pParam->BSIM3v0xt * pParam->BSIM3v0xt; |
|||
if (pParam->BSIM3v0vbx > 0.0) |
|||
pParam->BSIM3v0vbx = -pParam->BSIM3v0vbx; |
|||
if (pParam->BSIM3v0vbm > 0.0) |
|||
pParam->BSIM3v0vbm = -pParam->BSIM3v0vbm; |
|||
|
|||
if (!model->BSIM3v0gamma1Given) |
|||
pParam->BSIM3v0gamma1 = 5.753e-12 |
|||
* sqrt(pParam->BSIM3v0npeak) |
|||
/ model->BSIM3v0cox; |
|||
if (!model->BSIM3v0gamma2Given) |
|||
pParam->BSIM3v0gamma2 = 5.753e-12 |
|||
* sqrt(pParam->BSIM3v0nsub) |
|||
/ model->BSIM3v0cox; |
|||
|
|||
T0 = pParam->BSIM3v0gamma1 - pParam->BSIM3v0gamma2; |
|||
T1 = sqrt(pParam->BSIM3v0phi - pParam->BSIM3v0vbx) |
|||
- pParam->BSIM3v0sqrtPhi; |
|||
T2 = sqrt(pParam->BSIM3v0phi * (pParam->BSIM3v0phi |
|||
- pParam->BSIM3v0vbm)) - pParam->BSIM3v0phi; |
|||
pParam->BSIM3v0k2 = T0 * T1 / (2.0 * T2 + pParam->BSIM3v0vbm); |
|||
pParam->BSIM3v0k1 = pParam->BSIM3v0gamma2 - 2.0 |
|||
* pParam->BSIM3v0k2 * sqrt(pParam->BSIM3v0phi |
|||
- pParam->BSIM3v0vbm); |
|||
} |
|||
|
|||
if (pParam->BSIM3v0k2 > 0.0) |
|||
{ T0 = 0.5 * pParam->BSIM3v0k1 / pParam->BSIM3v0k2; |
|||
pParam->BSIM3v0vbsc = 0.9 * (pParam->BSIM3v0phi - T0 * T0); |
|||
if (pParam->BSIM3v0vbsc > -3.0) |
|||
pParam->BSIM3v0vbsc = -3.0; |
|||
else if (pParam->BSIM3v0vbsc < -30.0) |
|||
pParam->BSIM3v0vbsc = -30.0; |
|||
} |
|||
else |
|||
{ pParam->BSIM3v0vbsc = -10.0; |
|||
} |
|||
|
|||
model->BSIM3v0vtm = KboQ * Temp; |
|||
|
|||
if (model->BSIM3v0vth0Given) |
|||
pParam->BSIM3v0vfb = model->BSIM3v0type * pParam->BSIM3v0vth0 |
|||
- pParam->BSIM3v0phi - pParam->BSIM3v0k1 |
|||
* pParam->BSIM3v0sqrtPhi; |
|||
else |
|||
pParam->BSIM3v0vth0 = model->BSIM3v0type * (-1.0 |
|||
+ pParam->BSIM3v0phi + pParam->BSIM3v0k1 |
|||
* pParam->BSIM3v0sqrtPhi); |
|||
|
|||
T1 = sqrt(EPSSI / EPSOX * model->BSIM3v0tox |
|||
* pParam->BSIM3v0Xdep0); |
|||
T0 = exp(-0.5 * pParam->BSIM3v0dsub * pParam->BSIM3v0leff / T1); |
|||
pParam->BSIM3v0theta0vb0 = (T0 + 2.0 * T0 * T0); |
|||
|
|||
T0 = exp(-0.5 * pParam->BSIM3v0drout * pParam->BSIM3v0leff / T1); |
|||
T2 = (T0 + 2.0 * T0 * T0); |
|||
pParam->BSIM3v0thetaRout = pParam->BSIM3v0pdibl1 * T2 |
|||
+ pParam->BSIM3v0pdibl2; |
|||
|
|||
/* process source/drain series resistance */ |
|||
here->BSIM3v0drainConductance = model->BSIM3v0sheetResistance |
|||
* here->BSIM3v0drainSquares; |
|||
if (here->BSIM3v0drainConductance > 0.0) |
|||
here->BSIM3v0drainConductance = 1.0 |
|||
/ here->BSIM3v0drainConductance; |
|||
else |
|||
here->BSIM3v0drainConductance = 0.0; |
|||
|
|||
here->BSIM3v0sourceConductance = model->BSIM3v0sheetResistance |
|||
* here->BSIM3v0sourceSquares; |
|||
if (here->BSIM3v0sourceConductance > 0.0) |
|||
here->BSIM3v0sourceConductance = 1.0 |
|||
/ here->BSIM3v0sourceConductance; |
|||
else |
|||
here->BSIM3v0sourceConductance = 0.0; |
|||
} |
|||
here->BSIM3v0cgso = pParam->BSIM3v0cgso; |
|||
here->BSIM3v0cgdo = pParam->BSIM3v0cgdo; |
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
@ -0,0 +1,50 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1995 Min-Chie Jeng and Mansun Chan. |
|||
File: b3v0trunc.c |
|||
**********/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "cktdefs.h" |
|||
#include "bsim3v0def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
|
|||
int |
|||
BSIM3v0trunc(GENmodel *inModel, CKTcircuit *ckt, double *timeStep) |
|||
{ |
|||
BSIM3v0model *model = (BSIM3v0model*)inModel; |
|||
BSIM3v0instance *here; |
|||
|
|||
#ifdef STEPDEBUG |
|||
double debugtemp; |
|||
#endif /* STEPDEBUG */ |
|||
|
|||
for (; model != NULL; model = model->BSIM3v0nextModel) |
|||
{ for (here = model->BSIM3v0instances; here != NULL; |
|||
here = here->BSIM3v0nextInstance) |
|||
{ |
|||
|
|||
if (here->BSIM3v0owner != ARCHme) |
|||
continue; |
|||
|
|||
#ifdef STEPDEBUG |
|||
debugtemp = *timeStep; |
|||
#endif /* STEPDEBUG */ |
|||
CKTterr(here->BSIM3v0qb,ckt,timeStep); |
|||
CKTterr(here->BSIM3v0qg,ckt,timeStep); |
|||
CKTterr(here->BSIM3v0qd,ckt,timeStep); |
|||
#ifdef STEPDEBUG |
|||
if(debugtemp != *timeStep) |
|||
{ printf("device %s reduces step from %g to %g\n", |
|||
here->BSIM3v0name,debugtemp,*timeStep); |
|||
} |
|||
#endif /* STEPDEBUG */ |
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
|
|||
|
|||
1580
src/spicelib/devices/bsim3v0/bsim3v0def.h
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,30 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1991 JianHui Huang and Min-Chie Jeng. |
|||
File: bsim3v0ext.h |
|||
**********/ |
|||
|
|||
extern int BSIM3v0acLoad(GENmodel *,CKTcircuit*); |
|||
extern int BSIM3v0ask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*); |
|||
extern int BSIM3v0convTest(GENmodel *,CKTcircuit*); |
|||
extern int BSIM3v0delete(GENmodel*,IFuid,GENinstance**); |
|||
extern void BSIM3v0destroy(GENmodel**); |
|||
extern int BSIM3v0getic(GENmodel*,CKTcircuit*); |
|||
extern int BSIM3v0load(GENmodel*,CKTcircuit*); |
|||
extern int BSIM3v0mAsk(CKTcircuit*,GENmodel *,int, IFvalue*); |
|||
extern int BSIM3v0mDelete(GENmodel**,IFuid,GENmodel*); |
|||
extern int BSIM3v0mParam(int,IFvalue*,GENmodel*); |
|||
extern void BSIM3v0mosCap(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 BSIM3v0param(int,IFvalue*,GENinstance*,IFvalue*); |
|||
extern int BSIM3v0pzLoad(GENmodel*,CKTcircuit*,SPcomplex*); |
|||
extern int BSIM3v0setup(SMPmatrix*,GENmodel*,CKTcircuit*,int*); |
|||
extern int BSIM3v0temp(GENmodel*,CKTcircuit*); |
|||
extern int BSIM3v0trunc(GENmodel*,CKTcircuit*,double*); |
|||
extern int BSIM3v0noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*); |
|||
extern int BSIM3v0unsetup(GENmodel *, CKTcircuit *); |
|||
|
|||
@ -0,0 +1,82 @@ |
|||
#include <config.h> |
|||
|
|||
#include <devdefs.h> |
|||
|
|||
#include "bsim3v0itf.h" |
|||
#include "bsim3v0ext.h" |
|||
#include "bsim3v0init.h" |
|||
|
|||
SPICEdev B3v0info = { |
|||
{ "BSIM3v0", |
|||
"Berkeley Short Channel IGFET Model Version-3 (3.0)", |
|||
|
|||
&BSIM3v0nSize, |
|||
&BSIM3v0nSize, |
|||
BSIM3v0names, |
|||
|
|||
&BSIM3v0pTSize, |
|||
BSIM3v0pTable, |
|||
|
|||
&BSIM3v0mPTSize, |
|||
BSIM3v0mPTable, |
|||
|
|||
#ifdef XSPICE |
|||
/*---- Fixed by SDB 5.2.2003 to enable XSPICE/tclspice integration -----*/ |
|||
NULL, /* This is a SPICE device, it has no MIF info data */ |
|||
|
|||
0, /* This is a SPICE device, it has no MIF info data */ |
|||
NULL, /* This is a SPICE device, it has no MIF info data */ |
|||
|
|||
0, /* This is a SPICE device, it has no MIF info data */ |
|||
NULL, /* This is a SPICE device, it has no MIF info data */ |
|||
|
|||
0, /* This is a SPICE device, it has no MIF info data */ |
|||
NULL, /* This is a SPICE device, it has no MIF info data */ |
|||
/*--------------------------- End of SDB fix -------------------------*/ |
|||
#endif |
|||
|
|||
DEV_DEFAULT |
|||
}, |
|||
|
|||
DEVparam : BSIM3v0param, |
|||
DEVmodParam : BSIM3v0mParam, |
|||
DEVload : BSIM3v0load, |
|||
DEVsetup : BSIM3v0setup, |
|||
DEVunsetup : BSIM3v0unsetup, |
|||
DEVpzSetup : BSIM3v0setup, |
|||
DEVtemperature: BSIM3v0temp, |
|||
DEVtrunc : BSIM3v0trunc, |
|||
DEVfindBranch : NULL, |
|||
DEVacLoad : BSIM3v0acLoad, |
|||
DEVaccept : NULL, |
|||
DEVdestroy : BSIM3v0destroy, |
|||
DEVmodDelete : BSIM3v0mDelete, |
|||
DEVdelete : BSIM3v0delete, |
|||
DEVsetic : BSIM3v0getic, |
|||
DEVask : BSIM3v0ask, |
|||
DEVmodAsk : BSIM3v0mAsk, |
|||
DEVpzLoad : BSIM3v0pzLoad, |
|||
DEVconvTest : BSIM3v0convTest, |
|||
DEVsenSetup : NULL, |
|||
DEVsenLoad : NULL, |
|||
DEVsenUpdate : NULL, |
|||
DEVsenAcLoad : NULL, |
|||
DEVsenPrint : NULL, |
|||
DEVsenTrunc : NULL, |
|||
DEVdisto : NULL, |
|||
DEVnoise : BSIM3v0noise, |
|||
#ifdef CIDER |
|||
DEVdump : NULL, |
|||
DEVacct : NULL, |
|||
#endif |
|||
DEVinstSize : &BSIM3v0iSize, |
|||
DEVmodSize : &BSIM3v0mSize |
|||
|
|||
}; |
|||
|
|||
|
|||
SPICEdev * |
|||
get_bsim3v0_info(void) |
|||
{ |
|||
return &B3v0info; |
|||
} |
|||
@ -0,0 +1,13 @@ |
|||
#ifndef _BSIM3v0INIT_H |
|||
#define _BSIM3v0INIT_H |
|||
|
|||
extern IFparm BSIM3v0pTable[ ]; |
|||
extern IFparm BSIM3v0mPTable[ ]; |
|||
extern char *BSIM3v0names[ ]; |
|||
extern int BSIM3v0pTSize; |
|||
extern int BSIM3v0mPTSize; |
|||
extern int BSIM3v0nSize; |
|||
extern int BSIM3v0iSize; |
|||
extern int BSIM3v0mSize; |
|||
|
|||
#endif |
|||
@ -0,0 +1,12 @@ |
|||
/********** |
|||
Copyright 1990 Regents of the University of California. All rights reserved. |
|||
Author: 1991 JianHui Huang and Min-Chie Jeng. |
|||
File: bsim3v0itf.h |
|||
**********/ |
|||
|
|||
#ifdef DEV_bsim3v0 |
|||
|
|||
SPICEdev *get_bsim3v0_info(void); |
|||
|
|||
#endif |
|||
|
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue