luke
/
ngspice
mirror of https://git.code.sf.net/p/ngspice/ngspice
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

bsim 3v0 model. Import.

This commit is contained in:
pnenzi 2003-08-11 19:53:13 +00:00
parent 7f26f46d77
commit 57f8eed5db
23 changed files with 9551 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
src/spicelib/devices/bsim3v0/Makefile.am Normal file
View File

@ -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

429
src/spicelib/devices/bsim3v0/b3v0.c Normal file
View File

@ -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);

185
src/spicelib/devices/bsim3v0/b3v0acld.c Normal file
View File

@ -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);
}

221
src/spicelib/devices/bsim3v0/b3v0ask.c Normal file
View File

@ -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 */
}

90
src/spicelib/devices/bsim3v0/b3v0cvtest.c Normal file
View File

@ -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);
}

38
src/spicelib/devices/bsim3v0/b3v0del.c Normal file
View File

@ -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);
}

36
src/spicelib/devices/bsim3v0/b3v0dest.c Normal file
View File

@ -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;
}

44
src/spicelib/devices/bsim3v0/b3v0getic.c Normal file
View File

@ -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 Normal file
View File

File diff suppressed because it is too large Load Diff

1090
src/spicelib/devices/bsim3v0/b3v0mask.c Normal file
View File

File diff suppressed because it is too large Load Diff

42
src/spicelib/devices/bsim3v0/b3v0mdel.c Normal file
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 Normal file
View File

File diff suppressed because it is too large Load Diff

356
src/spicelib/devices/bsim3v0/b3v0noi.c Normal file
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);
}

96
src/spicelib/devices/bsim3v0/b3v0par.c Normal file
View File

@ -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);
}

150
src/spicelib/devices/bsim3v0/b3v0pzld.c Normal file
View File

@ -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);
}

926
src/spicelib/devices/bsim3v0/b3v0set.c Normal file
View File

@ -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;
}

631
src/spicelib/devices/bsim3v0/b3v0temp.c Normal file
View File

@ -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);
}

50
src/spicelib/devices/bsim3v0/b3v0trunc.c Normal file
View File

@ -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 Normal file
View File

File diff suppressed because it is too large Load Diff

30
src/spicelib/devices/bsim3v0/bsim3v0ext.h Normal file
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 *);

82
src/spicelib/devices/bsim3v0/bsim3v0init.c Normal file
View File

@ -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;
}

13
src/spicelib/devices/bsim3v0/bsim3v0init.h Normal file
View File

@ -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

12
src/spicelib/devices/bsim3v0/bsim3v0itf.h Normal file
View File

@ -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