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

Bsim 3v2 model is now in bsim3 directory. Multirevision code.

This commit is contained in:
pnenzi 2003-08-11 20:48:45 +00:00
parent 623418b603
commit ae57bef3b4
26 changed files with 0 additions and 12243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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

17
src/spicelib/devices/bsim3v2/ChangeLog
View File

@ -1,17 +0,0 @@
2000-01-29 Paolo Nenzi <p.nenzi@ieee.org>
* bsim3v2def.h : Added BSIM3V2owner to the BSIM3V2instance structure
for compatibility with Cider. This spice uses a modificed version of
devices, as desscribed in the CIDer package, for a "parallel"
processing support.
* b3v2{acld,cvtest,getic,ld,pzld,set,temp,trunc}.c:
added the check if the current instance is a task of this
processor. This is part of the "parallel" support of Cider.
2000-01-16 Emmanuel Rouat <emmanuel.rouat@wanadoo.fr>
* *.c : replaced all FABS macros by the 'fabs' function
* *.c : had to rename structure bsim3SizeDependParam into
BSIM3V2SizeDependParam for consistency

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

@ -1,34 +0,0 @@
## Process this file with automake to produce Makefile.in
noinst_LIBRARIES = libbsim3v2.a
libbsim3v2_a_SOURCES = \
b3v2.c \
b3v2acld.c \
b3v2ask.c \
b3v2check.c \
b3v2cvtest.c \
b3v2del.c \
b3v2dest.c \
b3v2getic.c \
b3v2ld.c \
b3v2mask.c \
b3v2mdel.c \
b3v2mpar.c \
b3v2noi.c \
b3v2par.c \
b3v2pzld.c \
b3v2set.c \
b3v2temp.c \
b3v2trunc.c \
bsim3v2def.h \
bsim3v2ext.h \
bsim3v2init.c \
bsim3v2init.h \
bsim3v2itf.h
INCLUDES = -I$(top_srcdir)/src/include
MAINTAINERCLEANFILES = Makefile.in

477
src/spicelib/devices/bsim3v2/b3v2.c
View File

@ -1,477 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Weidong Liu (1997-1998).
File: b3v2.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include "devdefs.h"
#include "bsim3v2def.h"
#include "suffix.h"
IFparm BSIM3V2pTable[] = { /* parameters */
IOP( "l", BSIM3V2_L, IF_REAL , "Length"),
IOP( "w", BSIM3V2_W, IF_REAL , "Width"),
IOP( "ad", BSIM3V2_AD, IF_REAL , "Drain area"),
IOP( "as", BSIM3V2_AS, IF_REAL , "Source area"),
IOP( "pd", BSIM3V2_PD, IF_REAL , "Drain perimeter"),
IOP( "ps", BSIM3V2_PS, IF_REAL , "Source perimeter"),
IOP( "nrd", BSIM3V2_NRD, IF_REAL , "Number of squares in drain"),
IOP( "nrs", BSIM3V2_NRS, IF_REAL , "Number of squares in source"),
IOP( "off", BSIM3V2_OFF, IF_FLAG , "Device is initially off"),
IOP( "nqsmod", BSIM3V2_NQSMOD, IF_INTEGER, "Non-quasi-static model selector"),
IP( "ic", BSIM3V2_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"),
OP( "gmbs", BSIM3V2_GMBS, IF_REAL, "Gmb"),
OP( "gm", BSIM3V2_GM, IF_REAL, "Gm"),
OP( "gds", BSIM3V2_GDS, IF_REAL, "Gds"),
OP( "vdsat", BSIM3V2_VDSAT, IF_REAL, "Vdsat"),
OP( "vth", BSIM3V2_VON, IF_REAL, "Vth"),
OP( "id", BSIM3V2_CD, IF_REAL, "Ids"),
OP( "vbs", BSIM3V2_VBS, IF_REAL, "Vbs"),
OP( "vgs", BSIM3V2_VGS, IF_REAL, "Vgs"),
OP( "vds", BSIM3V2_VDS, IF_REAL, "Vds"),
};
IFparm BSIM3V2mPTable[] = { /* model parameters */
IOP( "capmod", BSIM3V2_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"),
IOP( "mobmod", BSIM3V2_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"),
IOP( "noimod", BSIM3V2_MOD_NOIMOD, IF_INTEGER, "Noise model selector"),
IOP( "paramchk", BSIM3V2_MOD_PARAMCHK, IF_INTEGER, "Model parameter checking selector"),
IOP( "binunit", BSIM3V2_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"),
IOP( "version", BSIM3V2_MOD_VERSION, IF_REAL, " parameter for model version"),
IOP( "tox", BSIM3V2_MOD_TOX, IF_REAL, "Gate oxide thickness in meters"),
IOP( "toxm", BSIM3V2_MOD_TOXM, IF_REAL, "Gate oxide thickness used in extraction"),
IOP( "cdsc", BSIM3V2_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"),
IOP( "cdscb", BSIM3V2_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"),
IOP( "cdscd", BSIM3V2_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"),
IOP( "cit", BSIM3V2_MOD_CIT, IF_REAL, "Interface state capacitance"),
IOP( "nfactor", BSIM3V2_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"),
IOP( "xj", BSIM3V2_MOD_XJ, IF_REAL, "Junction depth in meters"),
IOP( "vsat", BSIM3V2_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"),
IOP( "at", BSIM3V2_MOD_AT, IF_REAL, "Temperature coefficient of vsat"),
IOP( "a0", BSIM3V2_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."),
IOP( "ags", BSIM3V2_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."),
IOP( "a1", BSIM3V2_MOD_A1, IF_REAL, "Non-saturation effect coefficient"),
IOP( "a2", BSIM3V2_MOD_A2, IF_REAL, "Non-saturation effect coefficient"),
IOP( "keta", BSIM3V2_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."),
IOP( "nsub", BSIM3V2_MOD_NSUB, IF_REAL, "Substrate doping concentration"),
IOP( "nch", BSIM3V2_MOD_NPEAK, IF_REAL, "Channel doping concentration"),
IOP( "ngate", BSIM3V2_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"),
IOP( "gamma1", BSIM3V2_MOD_GAMMA1, IF_REAL, "Vth body coefficient"),
IOP( "gamma2", BSIM3V2_MOD_GAMMA2, IF_REAL, "Vth body coefficient"),
IOP( "vbx", BSIM3V2_MOD_VBX, IF_REAL, "Vth transition body Voltage"),
IOP( "vbm", BSIM3V2_MOD_VBM, IF_REAL, "Maximum body voltage"),
IOP( "xt", BSIM3V2_MOD_XT, IF_REAL, "Doping depth"),
IOP( "k1", BSIM3V2_MOD_K1, IF_REAL, "Bulk effect coefficient 1"),
IOP( "kt1", BSIM3V2_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt1l", BSIM3V2_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt2", BSIM3V2_MOD_KT2, IF_REAL, "Body-coefficient of kt1"),
IOP( "k2", BSIM3V2_MOD_K2, IF_REAL, "Bulk effect coefficient 2"),
IOP( "k3", BSIM3V2_MOD_K3, IF_REAL, "Narrow width effect coefficient"),
IOP( "k3b", BSIM3V2_MOD_K3B, IF_REAL, "Body effect coefficient of k3"),
IOP( "w0", BSIM3V2_MOD_W0, IF_REAL, "Narrow width effect parameter"),
IOP( "nlx", BSIM3V2_MOD_NLX, IF_REAL, "Lateral non-uniform doping effect"),
IOP( "dvt0", BSIM3V2_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"),
IOP( "dvt1", BSIM3V2_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"),
IOP( "dvt2", BSIM3V2_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"),
IOP( "dvt0w", BSIM3V2_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"),
IOP( "dvt1w", BSIM3V2_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"),
IOP( "dvt2w", BSIM3V2_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"),
IOP( "drout", BSIM3V2_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"),
IOP( "dsub", BSIM3V2_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"),
IOP( "vth0", BSIM3V2_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "vtho", BSIM3V2_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "ua", BSIM3V2_MOD_UA, IF_REAL, "Linear gate dependence of mobility"),
IOP( "ua1", BSIM3V2_MOD_UA1, IF_REAL, "Temperature coefficient of ua"),
IOP( "ub", BSIM3V2_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"),
IOP( "ub1", BSIM3V2_MOD_UB1, IF_REAL, "Temperature coefficient of ub"),
IOP( "uc", BSIM3V2_MOD_UC, IF_REAL, "Body-bias dependence of mobility"),
IOP( "uc1", BSIM3V2_MOD_UC1, IF_REAL, "Temperature coefficient of uc"),
IOP( "u0", BSIM3V2_MOD_U0, IF_REAL, "Low-field mobility at Tnom"),
IOP( "ute", BSIM3V2_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"),
IOP( "voff", BSIM3V2_MOD_VOFF, IF_REAL, "Threshold voltage offset"),
IOP( "tnom", BSIM3V2_MOD_TNOM, IF_REAL, "Parameter measurement temperature"),
IOP( "cgso", BSIM3V2_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"),
IOP( "cgdo", BSIM3V2_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"),
IOP( "cgbo", BSIM3V2_MOD_CGBO, IF_REAL, "Gate-bulk overlap capacitance per length"),
IOP( "xpart", BSIM3V2_MOD_XPART, IF_REAL, "Channel charge partitioning"),
IOP( "elm", BSIM3V2_MOD_ELM, IF_REAL, "Non-quasi-static Elmore Constant Parameter"),
IOP( "delta", BSIM3V2_MOD_DELTA, IF_REAL, "Effective Vds parameter"),
IOP( "rsh", BSIM3V2_MOD_RSH, IF_REAL, "Source-drain sheet resistance"),
IOP( "rdsw", BSIM3V2_MOD_RDSW, IF_REAL, "Source-drain resistance per width"),
IOP( "prwg", BSIM3V2_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "),
IOP( "prwb", BSIM3V2_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "),
IOP( "prt", BSIM3V2_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "),
IOP( "eta0", BSIM3V2_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "etab", BSIM3V2_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "pclm", BSIM3V2_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"),
IOP( "pdiblc1", BSIM3V2_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblc2", BSIM3V2_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblcb", BSIM3V2_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"),
IOP( "pscbe1", BSIM3V2_MOD_PSCBE1, IF_REAL, "Substrate current body-effect coefficient"),
IOP( "pscbe2", BSIM3V2_MOD_PSCBE2, IF_REAL, "Substrate current body-effect coefficient"),
IOP( "pvag", BSIM3V2_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"),
IOP( "js", BSIM3V2_MOD_JS, IF_REAL, "Source/drain junction reverse saturation current density"),
IOP( "jsw", BSIM3V2_MOD_JSW, IF_REAL, "Sidewall junction reverse saturation current density"),
IOP( "pb", BSIM3V2_MOD_PB, IF_REAL, "Source/drain junction built-in potential"),
IOP( "nj", BSIM3V2_MOD_NJ, IF_REAL, "Source/drain junction emission coefficient"),
IOP( "xti", BSIM3V2_MOD_XTI, IF_REAL, "Junction current temperature exponent"),
IOP( "mj", BSIM3V2_MOD_MJ, IF_REAL, "Source/drain bottom junction capacitance grading coefficient"),
IOP( "pbsw", BSIM3V2_MOD_PBSW, IF_REAL, "Source/drain sidewall junction capacitance built in potential"),
IOP( "mjsw", BSIM3V2_MOD_MJSW, IF_REAL, "Source/drain sidewall junction capacitance grading coefficient"),
IOP( "pbswg", BSIM3V2_MOD_PBSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance built in potential"),
IOP( "mjswg", BSIM3V2_MOD_MJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance grading coefficient"),
IOP( "cj", BSIM3V2_MOD_CJ, IF_REAL, "Source/drain bottom junction capacitance per unit area"),
IOP( "vfbcv", BSIM3V2_MOD_VFBCV, IF_REAL, "Flat Band Voltage parameter for capmod=0 only"),
IOP( "vfb", BSIM3V2_MOD_VFB, IF_REAL, "Flat Band Voltage"),
IOP( "cjsw", BSIM3V2_MOD_CJSW, IF_REAL, "Source/drain sidewall junction capacitance per unit periphery"),
IOP( "cjswg", BSIM3V2_MOD_CJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance per unit width"),
IOP( "tpb", BSIM3V2_MOD_TPB, IF_REAL, "Temperature coefficient of pb"),
IOP( "tcj", BSIM3V2_MOD_TCJ, IF_REAL, "Temperature coefficient of cj"),
IOP( "tpbsw", BSIM3V2_MOD_TPBSW, IF_REAL, "Temperature coefficient of pbsw"),
IOP( "tcjsw", BSIM3V2_MOD_TCJSW, IF_REAL, "Temperature coefficient of cjsw"),
IOP( "tpbswg", BSIM3V2_MOD_TPBSWG, IF_REAL, "Temperature coefficient of pbswg"),
IOP( "tcjswg", BSIM3V2_MOD_TCJSWG, IF_REAL, "Temperature coefficient of cjswg"),
IOP( "acde", BSIM3V2_MOD_ACDE, IF_REAL, "Exponential coefficient for finite charge thickness"),
IOP( "moin", BSIM3V2_MOD_MOIN, IF_REAL, "Coefficient for gate-bias dependent surface potential"),
IOP( "noff", BSIM3V2_MOD_NOFF, IF_REAL, "C-V turn-on/off parameter"),
IOP( "voffcv", BSIM3V2_MOD_VOFFCV, IF_REAL, "C-V lateral-shift parameter"),
IOP( "lint", BSIM3V2_MOD_LINT, IF_REAL, "Length reduction parameter"),
IOP( "ll", BSIM3V2_MOD_LL, IF_REAL, "Length reduction parameter"),
IOP( "llc", BSIM3V2_MOD_LLC, IF_REAL, "Length reduction parameter for CV"),
IOP( "lln", BSIM3V2_MOD_LLN, IF_REAL, "Length reduction parameter"),
IOP( "lw", BSIM3V2_MOD_LW, IF_REAL, "Length reduction parameter"),
IOP( "lwc", BSIM3V2_MOD_LWC, IF_REAL, "Length reduction parameter for CV"),
IOP( "lwn", BSIM3V2_MOD_LWN, IF_REAL, "Length reduction parameter"),
IOP( "lwl", BSIM3V2_MOD_LWL, IF_REAL, "Length reduction parameter"),
IOP( "lwlc", BSIM3V2_MOD_LWLC, IF_REAL, "Length reduction parameter for CV"),
IOP( "lmin", BSIM3V2_MOD_LMIN, IF_REAL, "Minimum length for the model"),
IOP( "lmax", BSIM3V2_MOD_LMAX, IF_REAL, "Maximum length for the model"),
IOP( "wr", BSIM3V2_MOD_WR, IF_REAL, "Width dependence of rds"),
IOP( "wint", BSIM3V2_MOD_WINT, IF_REAL, "Width reduction parameter"),
IOP( "dwg", BSIM3V2_MOD_DWG, IF_REAL, "Width reduction parameter"),
IOP( "dwb", BSIM3V2_MOD_DWB, IF_REAL, "Width reduction parameter"),
IOP( "wl", BSIM3V2_MOD_WL, IF_REAL, "Width reduction parameter"),
IOP( "wlc", BSIM3V2_MOD_WLC, IF_REAL, "Width reduction parameter for CV"),
IOP( "wln", BSIM3V2_MOD_WLN, IF_REAL, "Width reduction parameter"),
IOP( "ww", BSIM3V2_MOD_WW, IF_REAL, "Width reduction parameter"),
IOP( "wwc", BSIM3V2_MOD_WWC, IF_REAL, "Width reduction parameter for CV"),
IOP( "wwn", BSIM3V2_MOD_WWN, IF_REAL, "Width reduction parameter"),
IOP( "wwl", BSIM3V2_MOD_WWL, IF_REAL, "Width reduction parameter"),
IOP( "wwlc", BSIM3V2_MOD_WWLC, IF_REAL, "Width reduction parameter for CV"),
IOP( "wmin", BSIM3V2_MOD_WMIN, IF_REAL, "Minimum width for the model"),
IOP( "wmax", BSIM3V2_MOD_WMAX, IF_REAL, "Maximum width for the model"),
IOP( "b0", BSIM3V2_MOD_B0, IF_REAL, "Abulk narrow width parameter"),
IOP( "b1", BSIM3V2_MOD_B1, IF_REAL, "Abulk narrow width parameter"),
IOP( "cgsl", BSIM3V2_MOD_CGSL, IF_REAL, "New C-V model parameter"),
IOP( "cgdl", BSIM3V2_MOD_CGDL, IF_REAL, "New C-V model parameter"),
IOP( "ckappa", BSIM3V2_MOD_CKAPPA, IF_REAL, "New C-V model parameter"),
IOP( "cf", BSIM3V2_MOD_CF, IF_REAL, "Fringe capacitance parameter"),
IOP( "clc", BSIM3V2_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "cle", BSIM3V2_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "dwc", BSIM3V2_MOD_DWC, IF_REAL, "Delta W for C-V model"),
IOP( "dlc", BSIM3V2_MOD_DLC, IF_REAL, "Delta L for C-V model"),
IOP( "alpha0", BSIM3V2_MOD_ALPHA0, IF_REAL, "substrate current model parameter"),
IOP( "alpha1", BSIM3V2_MOD_ALPHA1, IF_REAL, "substrate current model parameter"),
IOP( "beta0", BSIM3V2_MOD_BETA0, IF_REAL, "substrate current model parameter"),
IOP( "ijth", BSIM3V2_MOD_IJTH, IF_REAL, "Diode limiting current"),
IOP( "lcdsc", BSIM3V2_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"),
IOP( "lcdscb", BSIM3V2_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"),
IOP( "lcdscd", BSIM3V2_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"),
IOP( "lcit", BSIM3V2_MOD_LCIT, IF_REAL, "Length dependence of cit"),
IOP( "lnfactor", BSIM3V2_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"),
IOP( "lxj", BSIM3V2_MOD_LXJ, IF_REAL, "Length dependence of xj"),
IOP( "lvsat", BSIM3V2_MOD_LVSAT, IF_REAL, "Length dependence of vsat"),
IOP( "lat", BSIM3V2_MOD_LAT, IF_REAL, "Length dependence of at"),
IOP( "la0", BSIM3V2_MOD_LA0, IF_REAL, "Length dependence of a0"),
IOP( "lags", BSIM3V2_MOD_LAGS, IF_REAL, "Length dependence of ags"),
IOP( "la1", BSIM3V2_MOD_LA1, IF_REAL, "Length dependence of a1"),
IOP( "la2", BSIM3V2_MOD_LA2, IF_REAL, "Length dependence of a2"),
IOP( "lketa", BSIM3V2_MOD_LKETA, IF_REAL, "Length dependence of keta"),
IOP( "lnsub", BSIM3V2_MOD_LNSUB, IF_REAL, "Length dependence of nsub"),
IOP( "lnch", BSIM3V2_MOD_LNPEAK, IF_REAL, "Length dependence of nch"),
IOP( "lngate", BSIM3V2_MOD_LNGATE, IF_REAL, "Length dependence of ngate"),
IOP( "lgamma1", BSIM3V2_MOD_LGAMMA1, IF_REAL, "Length dependence of gamma1"),
IOP( "lgamma2", BSIM3V2_MOD_LGAMMA2, IF_REAL, "Length dependence of gamma2"),
IOP( "lvbx", BSIM3V2_MOD_LVBX, IF_REAL, "Length dependence of vbx"),
IOP( "lvbm", BSIM3V2_MOD_LVBM, IF_REAL, "Length dependence of vbm"),
IOP( "lxt", BSIM3V2_MOD_LXT, IF_REAL, "Length dependence of xt"),
IOP( "lk1", BSIM3V2_MOD_LK1, IF_REAL, "Length dependence of k1"),
IOP( "lkt1", BSIM3V2_MOD_LKT1, IF_REAL, "Length dependence of kt1"),
IOP( "lkt1l", BSIM3V2_MOD_LKT1L, IF_REAL, "Length dependence of kt1l"),
IOP( "lkt2", BSIM3V2_MOD_LKT2, IF_REAL, "Length dependence of kt2"),
IOP( "lk2", BSIM3V2_MOD_LK2, IF_REAL, "Length dependence of k2"),
IOP( "lk3", BSIM3V2_MOD_LK3, IF_REAL, "Length dependence of k3"),
IOP( "lk3b", BSIM3V2_MOD_LK3B, IF_REAL, "Length dependence of k3b"),
IOP( "lw0", BSIM3V2_MOD_LW0, IF_REAL, "Length dependence of w0"),
IOP( "lnlx", BSIM3V2_MOD_LNLX, IF_REAL, "Length dependence of nlx"),
IOP( "ldvt0", BSIM3V2_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"),
IOP( "ldvt1", BSIM3V2_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"),
IOP( "ldvt2", BSIM3V2_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"),
IOP( "ldvt0w", BSIM3V2_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"),
IOP( "ldvt1w", BSIM3V2_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"),
IOP( "ldvt2w", BSIM3V2_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"),
IOP( "ldrout", BSIM3V2_MOD_LDROUT, IF_REAL, "Length dependence of drout"),
IOP( "ldsub", BSIM3V2_MOD_LDSUB, IF_REAL, "Length dependence of dsub"),
IOP( "lvth0", BSIM3V2_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOP( "lvtho", BSIM3V2_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOP( "lua", BSIM3V2_MOD_LUA, IF_REAL, "Length dependence of ua"),
IOP( "lua1", BSIM3V2_MOD_LUA1, IF_REAL, "Length dependence of ua1"),
IOP( "lub", BSIM3V2_MOD_LUB, IF_REAL, "Length dependence of ub"),
IOP( "lub1", BSIM3V2_MOD_LUB1, IF_REAL, "Length dependence of ub1"),
IOP( "luc", BSIM3V2_MOD_LUC, IF_REAL, "Length dependence of uc"),
IOP( "luc1", BSIM3V2_MOD_LUC1, IF_REAL, "Length dependence of uc1"),
IOP( "lu0", BSIM3V2_MOD_LU0, IF_REAL, "Length dependence of u0"),
IOP( "lute", BSIM3V2_MOD_LUTE, IF_REAL, "Length dependence of ute"),
IOP( "lvoff", BSIM3V2_MOD_LVOFF, IF_REAL, "Length dependence of voff"),
IOP( "lelm", BSIM3V2_MOD_LELM, IF_REAL, "Length dependence of elm"),
IOP( "ldelta", BSIM3V2_MOD_LDELTA, IF_REAL, "Length dependence of delta"),
IOP( "lrdsw", BSIM3V2_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "),
IOP( "lprwg", BSIM3V2_MOD_LPRWG, IF_REAL, "Length dependence of prwg "),
IOP( "lprwb", BSIM3V2_MOD_LPRWB, IF_REAL, "Length dependence of prwb "),
IOP( "lprt", BSIM3V2_MOD_LPRT, IF_REAL, "Length dependence of prt "),
IOP( "leta0", BSIM3V2_MOD_LETA0, IF_REAL, "Length dependence of eta0"),
IOP( "letab", BSIM3V2_MOD_LETAB, IF_REAL, "Length dependence of etab"),
IOP( "lpclm", BSIM3V2_MOD_LPCLM, IF_REAL, "Length dependence of pclm"),
IOP( "lpdiblc1", BSIM3V2_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"),
IOP( "lpdiblc2", BSIM3V2_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"),
IOP( "lpdiblcb", BSIM3V2_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"),
IOP( "lpscbe1", BSIM3V2_MOD_LPSCBE1, IF_REAL, "Length dependence of pscbe1"),
IOP( "lpscbe2", BSIM3V2_MOD_LPSCBE2, IF_REAL, "Length dependence of pscbe2"),
IOP( "lpvag", BSIM3V2_MOD_LPVAG, IF_REAL, "Length dependence of pvag"),
IOP( "lwr", BSIM3V2_MOD_LWR, IF_REAL, "Length dependence of wr"),
IOP( "ldwg", BSIM3V2_MOD_LDWG, IF_REAL, "Length dependence of dwg"),
IOP( "ldwb", BSIM3V2_MOD_LDWB, IF_REAL, "Length dependence of dwb"),
IOP( "lb0", BSIM3V2_MOD_LB0, IF_REAL, "Length dependence of b0"),
IOP( "lb1", BSIM3V2_MOD_LB1, IF_REAL, "Length dependence of b1"),
IOP( "lcgsl", BSIM3V2_MOD_LCGSL, IF_REAL, "Length dependence of cgsl"),
IOP( "lcgdl", BSIM3V2_MOD_LCGDL, IF_REAL, "Length dependence of cgdl"),
IOP( "lckappa", BSIM3V2_MOD_LCKAPPA, IF_REAL, "Length dependence of ckappa"),
IOP( "lcf", BSIM3V2_MOD_LCF, IF_REAL, "Length dependence of cf"),
IOP( "lclc", BSIM3V2_MOD_LCLC, IF_REAL, "Length dependence of clc"),
IOP( "lcle", BSIM3V2_MOD_LCLE, IF_REAL, "Length dependence of cle"),
IOP( "lalpha0", BSIM3V2_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"),
IOP( "lalpha1", BSIM3V2_MOD_LALPHA1, IF_REAL, "Length dependence of alpha1"),
IOP( "lbeta0", BSIM3V2_MOD_LBETA0, IF_REAL, "Length dependence of beta0"),
IOP( "lvfbcv", BSIM3V2_MOD_LVFBCV, IF_REAL, "Length dependence of vfbcv"),
IOP( "lvfb", BSIM3V2_MOD_LVFB, IF_REAL, "Length dependence of vfb"),
IOP( "lacde", BSIM3V2_MOD_LACDE, IF_REAL, "Length dependence of acde"),
IOP( "lmoin", BSIM3V2_MOD_LMOIN, IF_REAL, "Length dependence of moin"),
IOP( "lnoff", BSIM3V2_MOD_LNOFF, IF_REAL, "Length dependence of noff"),
IOP( "lvoffcv", BSIM3V2_MOD_LVOFFCV, IF_REAL, "Length dependence of voffcv"),
IOP( "wcdsc", BSIM3V2_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"),
IOP( "wcdscb", BSIM3V2_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"),
IOP( "wcdscd", BSIM3V2_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"),
IOP( "wcit", BSIM3V2_MOD_WCIT, IF_REAL, "Width dependence of cit"),
IOP( "wnfactor", BSIM3V2_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"),
IOP( "wxj", BSIM3V2_MOD_WXJ, IF_REAL, "Width dependence of xj"),
IOP( "wvsat", BSIM3V2_MOD_WVSAT, IF_REAL, "Width dependence of vsat"),
IOP( "wat", BSIM3V2_MOD_WAT, IF_REAL, "Width dependence of at"),
IOP( "wa0", BSIM3V2_MOD_WA0, IF_REAL, "Width dependence of a0"),
IOP( "wags", BSIM3V2_MOD_WAGS, IF_REAL, "Width dependence of ags"),
IOP( "wa1", BSIM3V2_MOD_WA1, IF_REAL, "Width dependence of a1"),
IOP( "wa2", BSIM3V2_MOD_WA2, IF_REAL, "Width dependence of a2"),
IOP( "wketa", BSIM3V2_MOD_WKETA, IF_REAL, "Width dependence of keta"),
IOP( "wnsub", BSIM3V2_MOD_WNSUB, IF_REAL, "Width dependence of nsub"),
IOP( "wnch", BSIM3V2_MOD_WNPEAK, IF_REAL, "Width dependence of nch"),
IOP( "wngate", BSIM3V2_MOD_WNGATE, IF_REAL, "Width dependence of ngate"),
IOP( "wgamma1", BSIM3V2_MOD_WGAMMA1, IF_REAL, "Width dependence of gamma1"),
IOP( "wgamma2", BSIM3V2_MOD_WGAMMA2, IF_REAL, "Width dependence of gamma2"),
IOP( "wvbx", BSIM3V2_MOD_WVBX, IF_REAL, "Width dependence of vbx"),
IOP( "wvbm", BSIM3V2_MOD_WVBM, IF_REAL, "Width dependence of vbm"),
IOP( "wxt", BSIM3V2_MOD_WXT, IF_REAL, "Width dependence of xt"),
IOP( "wk1", BSIM3V2_MOD_WK1, IF_REAL, "Width dependence of k1"),
IOP( "wkt1", BSIM3V2_MOD_WKT1, IF_REAL, "Width dependence of kt1"),
IOP( "wkt1l", BSIM3V2_MOD_WKT1L, IF_REAL, "Width dependence of kt1l"),
IOP( "wkt2", BSIM3V2_MOD_WKT2, IF_REAL, "Width dependence of kt2"),
IOP( "wk2", BSIM3V2_MOD_WK2, IF_REAL, "Width dependence of k2"),
IOP( "wk3", BSIM3V2_MOD_WK3, IF_REAL, "Width dependence of k3"),
IOP( "wk3b", BSIM3V2_MOD_WK3B, IF_REAL, "Width dependence of k3b"),
IOP( "ww0", BSIM3V2_MOD_WW0, IF_REAL, "Width dependence of w0"),
IOP( "wnlx", BSIM3V2_MOD_WNLX, IF_REAL, "Width dependence of nlx"),
IOP( "wdvt0", BSIM3V2_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"),
IOP( "wdvt1", BSIM3V2_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"),
IOP( "wdvt2", BSIM3V2_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"),
IOP( "wdvt0w", BSIM3V2_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"),
IOP( "wdvt1w", BSIM3V2_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"),
IOP( "wdvt2w", BSIM3V2_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"),
IOP( "wdrout", BSIM3V2_MOD_WDROUT, IF_REAL, "Width dependence of drout"),
IOP( "wdsub", BSIM3V2_MOD_WDSUB, IF_REAL, "Width dependence of dsub"),
IOP( "wvth0", BSIM3V2_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOP( "wvtho", BSIM3V2_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOP( "wua", BSIM3V2_MOD_WUA, IF_REAL, "Width dependence of ua"),
IOP( "wua1", BSIM3V2_MOD_WUA1, IF_REAL, "Width dependence of ua1"),
IOP( "wub", BSIM3V2_MOD_WUB, IF_REAL, "Width dependence of ub"),
IOP( "wub1", BSIM3V2_MOD_WUB1, IF_REAL, "Width dependence of ub1"),
IOP( "wuc", BSIM3V2_MOD_WUC, IF_REAL, "Width dependence of uc"),
IOP( "wuc1", BSIM3V2_MOD_WUC1, IF_REAL, "Width dependence of uc1"),
IOP( "wu0", BSIM3V2_MOD_WU0, IF_REAL, "Width dependence of u0"),
IOP( "wute", BSIM3V2_MOD_WUTE, IF_REAL, "Width dependence of ute"),
IOP( "wvoff", BSIM3V2_MOD_WVOFF, IF_REAL, "Width dependence of voff"),
IOP( "welm", BSIM3V2_MOD_WELM, IF_REAL, "Width dependence of elm"),
IOP( "wdelta", BSIM3V2_MOD_WDELTA, IF_REAL, "Width dependence of delta"),
IOP( "wrdsw", BSIM3V2_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "),
IOP( "wprwg", BSIM3V2_MOD_WPRWG, IF_REAL, "Width dependence of prwg "),
IOP( "wprwb", BSIM3V2_MOD_WPRWB, IF_REAL, "Width dependence of prwb "),
IOP( "wprt", BSIM3V2_MOD_WPRT, IF_REAL, "Width dependence of prt"),
IOP( "weta0", BSIM3V2_MOD_WETA0, IF_REAL, "Width dependence of eta0"),
IOP( "wetab", BSIM3V2_MOD_WETAB, IF_REAL, "Width dependence of etab"),
IOP( "wpclm", BSIM3V2_MOD_WPCLM, IF_REAL, "Width dependence of pclm"),
IOP( "wpdiblc1", BSIM3V2_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"),
IOP( "wpdiblc2", BSIM3V2_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"),
IOP( "wpdiblcb", BSIM3V2_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"),
IOP( "wpscbe1", BSIM3V2_MOD_WPSCBE1, IF_REAL, "Width dependence of pscbe1"),
IOP( "wpscbe2", BSIM3V2_MOD_WPSCBE2, IF_REAL, "Width dependence of pscbe2"),
IOP( "wpvag", BSIM3V2_MOD_WPVAG, IF_REAL, "Width dependence of pvag"),
IOP( "wwr", BSIM3V2_MOD_WWR, IF_REAL, "Width dependence of wr"),
IOP( "wdwg", BSIM3V2_MOD_WDWG, IF_REAL, "Width dependence of dwg"),
IOP( "wdwb", BSIM3V2_MOD_WDWB, IF_REAL, "Width dependence of dwb"),
IOP( "wb0", BSIM3V2_MOD_WB0, IF_REAL, "Width dependence of b0"),
IOP( "wb1", BSIM3V2_MOD_WB1, IF_REAL, "Width dependence of b1"),
IOP( "wcgsl", BSIM3V2_MOD_WCGSL, IF_REAL, "Width dependence of cgsl"),
IOP( "wcgdl", BSIM3V2_MOD_WCGDL, IF_REAL, "Width dependence of cgdl"),
IOP( "wckappa", BSIM3V2_MOD_WCKAPPA, IF_REAL, "Width dependence of ckappa"),
IOP( "wcf", BSIM3V2_MOD_WCF, IF_REAL, "Width dependence of cf"),
IOP( "wclc", BSIM3V2_MOD_WCLC, IF_REAL, "Width dependence of clc"),
IOP( "wcle", BSIM3V2_MOD_WCLE, IF_REAL, "Width dependence of cle"),
IOP( "walpha0", BSIM3V2_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"),
IOP( "walpha1", BSIM3V2_MOD_WALPHA1, IF_REAL, "Width dependence of alpha1"),
IOP( "wbeta0", BSIM3V2_MOD_WBETA0, IF_REAL, "Width dependence of beta0"),
IOP( "wvfbcv", BSIM3V2_MOD_WVFBCV, IF_REAL, "Width dependence of vfbcv"),
IOP( "wvfb", BSIM3V2_MOD_WVFB, IF_REAL, "Width dependence of vfb"),
IOP( "wacde", BSIM3V2_MOD_WACDE, IF_REAL, "Width dependence of acde"),
IOP( "wmoin", BSIM3V2_MOD_WMOIN, IF_REAL, "Width dependence of moin"),
IOP( "wnoff", BSIM3V2_MOD_WNOFF, IF_REAL, "Width dependence of noff"),
IOP( "wvoffcv", BSIM3V2_MOD_WVOFFCV, IF_REAL, "Width dependence of voffcv"),
IOP( "pcdsc", BSIM3V2_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"),
IOP( "pcdscb", BSIM3V2_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"),
IOP( "pcdscd", BSIM3V2_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"),
IOP( "pcit", BSIM3V2_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"),
IOP( "pnfactor", BSIM3V2_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"),
IOP( "pxj", BSIM3V2_MOD_PXJ, IF_REAL, "Cross-term dependence of xj"),
IOP( "pvsat", BSIM3V2_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"),
IOP( "pat", BSIM3V2_MOD_PAT, IF_REAL, "Cross-term dependence of at"),
IOP( "pa0", BSIM3V2_MOD_PA0, IF_REAL, "Cross-term dependence of a0"),
IOP( "pags", BSIM3V2_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"),
IOP( "pa1", BSIM3V2_MOD_PA1, IF_REAL, "Cross-term dependence of a1"),
IOP( "pa2", BSIM3V2_MOD_PA2, IF_REAL, "Cross-term dependence of a2"),
IOP( "pketa", BSIM3V2_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"),
IOP( "pnsub", BSIM3V2_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"),
IOP( "pnch", BSIM3V2_MOD_PNPEAK, IF_REAL, "Cross-term dependence of nch"),
IOP( "pngate", BSIM3V2_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"),
IOP( "pgamma1", BSIM3V2_MOD_PGAMMA1, IF_REAL, "Cross-term dependence of gamma1"),
IOP( "pgamma2", BSIM3V2_MOD_PGAMMA2, IF_REAL, "Cross-term dependence of gamma2"),
IOP( "pvbx", BSIM3V2_MOD_PVBX, IF_REAL, "Cross-term dependence of vbx"),
IOP( "pvbm", BSIM3V2_MOD_PVBM, IF_REAL, "Cross-term dependence of vbm"),
IOP( "pxt", BSIM3V2_MOD_PXT, IF_REAL, "Cross-term dependence of xt"),
IOP( "pk1", BSIM3V2_MOD_PK1, IF_REAL, "Cross-term dependence of k1"),
IOP( "pkt1", BSIM3V2_MOD_PKT1, IF_REAL, "Cross-term dependence of kt1"),
IOP( "pkt1l", BSIM3V2_MOD_PKT1L, IF_REAL, "Cross-term dependence of kt1l"),
IOP( "pkt2", BSIM3V2_MOD_PKT2, IF_REAL, "Cross-term dependence of kt2"),
IOP( "pk2", BSIM3V2_MOD_PK2, IF_REAL, "Cross-term dependence of k2"),
IOP( "pk3", BSIM3V2_MOD_PK3, IF_REAL, "Cross-term dependence of k3"),
IOP( "pk3b", BSIM3V2_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"),
IOP( "pw0", BSIM3V2_MOD_PW0, IF_REAL, "Cross-term dependence of w0"),
IOP( "pnlx", BSIM3V2_MOD_PNLX, IF_REAL, "Cross-term dependence of nlx"),
IOP( "pdvt0", BSIM3V2_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"),
IOP( "pdvt1", BSIM3V2_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"),
IOP( "pdvt2", BSIM3V2_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"),
IOP( "pdvt0w", BSIM3V2_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"),
IOP( "pdvt1w", BSIM3V2_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"),
IOP( "pdvt2w", BSIM3V2_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"),
IOP( "pdrout", BSIM3V2_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"),
IOP( "pdsub", BSIM3V2_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"),
IOP( "pvth0", BSIM3V2_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOP( "pvtho", BSIM3V2_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOP( "pua", BSIM3V2_MOD_PUA, IF_REAL, "Cross-term dependence of ua"),
IOP( "pua1", BSIM3V2_MOD_PUA1, IF_REAL, "Cross-term dependence of ua1"),
IOP( "pub", BSIM3V2_MOD_PUB, IF_REAL, "Cross-term dependence of ub"),
IOP( "pub1", BSIM3V2_MOD_PUB1, IF_REAL, "Cross-term dependence of ub1"),
IOP( "puc", BSIM3V2_MOD_PUC, IF_REAL, "Cross-term dependence of uc"),
IOP( "puc1", BSIM3V2_MOD_PUC1, IF_REAL, "Cross-term dependence of uc1"),
IOP( "pu0", BSIM3V2_MOD_PU0, IF_REAL, "Cross-term dependence of u0"),
IOP( "pute", BSIM3V2_MOD_PUTE, IF_REAL, "Cross-term dependence of ute"),
IOP( "pvoff", BSIM3V2_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"),
IOP( "pelm", BSIM3V2_MOD_PELM, IF_REAL, "Cross-term dependence of elm"),
IOP( "pdelta", BSIM3V2_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"),
IOP( "prdsw", BSIM3V2_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "),
IOP( "pprwg", BSIM3V2_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "),
IOP( "pprwb", BSIM3V2_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "),
IOP( "pprt", BSIM3V2_MOD_PPRT, IF_REAL, "Cross-term dependence of prt "),
IOP( "peta0", BSIM3V2_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"),
IOP( "petab", BSIM3V2_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"),
IOP( "ppclm", BSIM3V2_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"),
IOP( "ppdiblc1", BSIM3V2_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"),
IOP( "ppdiblc2", BSIM3V2_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"),
IOP( "ppdiblcb", BSIM3V2_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"),
IOP( "ppscbe1", BSIM3V2_MOD_PPSCBE1, IF_REAL, "Cross-term dependence of pscbe1"),
IOP( "ppscbe2", BSIM3V2_MOD_PPSCBE2, IF_REAL, "Cross-term dependence of pscbe2"),
IOP( "ppvag", BSIM3V2_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"),
IOP( "pwr", BSIM3V2_MOD_PWR, IF_REAL, "Cross-term dependence of wr"),
IOP( "pdwg", BSIM3V2_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"),
IOP( "pdwb", BSIM3V2_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"),
IOP( "pb0", BSIM3V2_MOD_PB0, IF_REAL, "Cross-term dependence of b0"),
IOP( "pb1", BSIM3V2_MOD_PB1, IF_REAL, "Cross-term dependence of b1"),
IOP( "pcgsl", BSIM3V2_MOD_PCGSL, IF_REAL, "Cross-term dependence of cgsl"),
IOP( "pcgdl", BSIM3V2_MOD_PCGDL, IF_REAL, "Cross-term dependence of cgdl"),
IOP( "pckappa", BSIM3V2_MOD_PCKAPPA, IF_REAL, "Cross-term dependence of ckappa"),
IOP( "pcf", BSIM3V2_MOD_PCF, IF_REAL, "Cross-term dependence of cf"),
IOP( "pclc", BSIM3V2_MOD_PCLC, IF_REAL, "Cross-term dependence of clc"),
IOP( "pcle", BSIM3V2_MOD_PCLE, IF_REAL, "Cross-term dependence of cle"),
IOP( "palpha0", BSIM3V2_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"),
IOP( "palpha1", BSIM3V2_MOD_PALPHA1, IF_REAL, "Cross-term dependence of alpha1"),
IOP( "pbeta0", BSIM3V2_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"),
IOP( "pvfbcv", BSIM3V2_MOD_PVFBCV, IF_REAL, "Cross-term dependence of vfbcv"),
IOP( "pvfb", BSIM3V2_MOD_PVFB, IF_REAL, "Cross-term dependence of vfb"),
IOP( "pacde", BSIM3V2_MOD_PACDE, IF_REAL, "Cross-term dependence of acde"),
IOP( "pmoin", BSIM3V2_MOD_PMOIN, IF_REAL, "Cross-term dependence of moin"),
IOP( "pnoff", BSIM3V2_MOD_PNOFF, IF_REAL, "Cross-term dependence of noff"),
IOP( "pvoffcv", BSIM3V2_MOD_PVOFFCV, IF_REAL, "Cross-term dependence of voffcv"),
IOP( "noia", BSIM3V2_MOD_NOIA, IF_REAL, "Flicker noise parameter"),
IOP( "noib", BSIM3V2_MOD_NOIB, IF_REAL, "Flicker noise parameter"),
IOP( "noic", BSIM3V2_MOD_NOIC, IF_REAL, "Flicker noise parameter"),
IOP( "em", BSIM3V2_MOD_EM, IF_REAL, "Flicker noise parameter"),
IOP( "ef", BSIM3V2_MOD_EF, IF_REAL, "Flicker noise frequency exponent"),
IOP( "af", BSIM3V2_MOD_AF, IF_REAL, "Flicker noise exponent"),
IOP( "kf", BSIM3V2_MOD_KF, IF_REAL, "Flicker noise coefficient"),
IP( "nmos", BSIM3V2_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"),
IP( "pmos", BSIM3V2_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"),
};
char *BSIM3V2names[] = {
"Drain",
"Gate",
"Source",
"Bulk",
"Charge"
};
int BSIM3V2nSize = NUMELEMS(BSIM3V2names);
int BSIM3V2pTSize = NUMELEMS(BSIM3V2pTable);
int BSIM3V2mPTSize = NUMELEMS(BSIM3V2mPTable);
int BSIM3V2iSize = sizeof(BSIM3V2instance);
int BSIM3V2mSize = sizeof(BSIM3V2model);

337
src/spicelib/devices/bsim3v2/b3v2acld.c
View File

@ -1,337 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Weidong Liu (1997-1998).
File: b3acld.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "bsim3v2def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3V2acLoad(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
BSIM3V2model *model = (BSIM3V2model*)inModel;
BSIM3V2instance *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, xgtg, xgtd, xgts, xgtb, xcqgb, xcqdb, xcqsb, xcqbb;
double gbspsp, gbbdp, gbbsp, gbspg, gbspb;
double gbspdp, gbdpdp, gbdpg, gbdpb, gbdpsp;
double ddxpart_dVd, ddxpart_dVg, ddxpart_dVb, ddxpart_dVs;
double dsxpart_dVd, dsxpart_dVg, dsxpart_dVb, dsxpart_dVs;
double T1, CoxWL, qcheq, Cdg, Cdd, Cds, Csg, Csd, Css;
omega = ckt->CKTomega;
for (; model != NULL; model = model->BSIM3V2nextModel)
{ for (here = model->BSIM3V2instances; here!= NULL;
here = here->BSIM3V2nextInstance)
{ if (here->BSIM3V2owner != ARCHme) continue;
if (here->BSIM3V2mode >= 0)
{ Gm = here->BSIM3V2gm;
Gmbs = here->BSIM3V2gmbs;
FwdSum = Gm + Gmbs;
RevSum = 0.0;
gbbdp = -here->BSIM3V2gbds;
gbbsp = here->BSIM3V2gbds + here->BSIM3V2gbgs + here->BSIM3V2gbbs;
gbdpg = here->BSIM3V2gbgs;
gbdpb = here->BSIM3V2gbbs;
gbdpdp = here->BSIM3V2gbds;
gbdpsp = -(gbdpg + gbdpb + gbdpdp);
gbspdp = 0.0;
gbspg = 0.0;
gbspb = 0.0;
gbspsp = 0.0;
if (here->BSIM3V2nqsMod == 0)
{ cggb = here->BSIM3V2cggb;
cgsb = here->BSIM3V2cgsb;
cgdb = here->BSIM3V2cgdb;
cbgb = here->BSIM3V2cbgb;
cbsb = here->BSIM3V2cbsb;
cbdb = here->BSIM3V2cbdb;
cdgb = here->BSIM3V2cdgb;
cdsb = here->BSIM3V2cdsb;
cddb = here->BSIM3V2cddb;
xgtg = xgtd = xgts = xgtb = 0.0;
sxpart = 0.6;
dxpart = 0.4;
ddxpart_dVd = ddxpart_dVg = ddxpart_dVb
= ddxpart_dVs = 0.0;
dsxpart_dVd = dsxpart_dVg = dsxpart_dVb
= dsxpart_dVs = 0.0;
}
else
{ cggb = cgdb = cgsb = 0.0;
cbgb = cbdb = cbsb = 0.0;
cdgb = cddb = cdsb = 0.0;
xgtg = here->BSIM3V2gtg;
xgtd = here->BSIM3V2gtd;
xgts = here->BSIM3V2gts;
xgtb = here->BSIM3V2gtb;
xcqgb = here->BSIM3V2cqgb * omega;
xcqdb = here->BSIM3V2cqdb * omega;
xcqsb = here->BSIM3V2cqsb * omega;
xcqbb = here->BSIM3V2cqbb * omega;
CoxWL = model->BSIM3V2cox * here->pParam->BSIM3V2weffCV
* here->pParam->BSIM3V2leffCV;
qcheq = -(here->BSIM3V2qgate + here->BSIM3V2qbulk);
if (fabs(qcheq) <= 1.0e-5 * CoxWL)
{ if (model->BSIM3V2xpart < 0.5)
{ dxpart = 0.4;
}
else if (model->BSIM3V2xpart > 0.5)
{ dxpart = 0.0;
}
else
{ dxpart = 0.5;
}
ddxpart_dVd = ddxpart_dVg = ddxpart_dVb
= ddxpart_dVs = 0.0;
}
else
{ dxpart = here->BSIM3V2qdrn / qcheq;
Cdd = here->BSIM3V2cddb;
Csd = -(here->BSIM3V2cgdb + here->BSIM3V2cddb
+ here->BSIM3V2cbdb);
ddxpart_dVd = (Cdd - dxpart * (Cdd + Csd)) / qcheq;
Cdg = here->BSIM3V2cdgb;
Csg = -(here->BSIM3V2cggb + here->BSIM3V2cdgb
+ here->BSIM3V2cbgb);
ddxpart_dVg = (Cdg - dxpart * (Cdg + Csg)) / qcheq;
Cds = here->BSIM3V2cdsb;
Css = -(here->BSIM3V2cgsb + here->BSIM3V2cdsb
+ here->BSIM3V2cbsb);
ddxpart_dVs = (Cds - dxpart * (Cds + Css)) / qcheq;
ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg
+ ddxpart_dVs);
}
sxpart = 1.0 - dxpart;
dsxpart_dVd = -ddxpart_dVd;
dsxpart_dVg = -ddxpart_dVg;
dsxpart_dVs = -ddxpart_dVs;
dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg + dsxpart_dVs);
}
}
else
{ Gm = -here->BSIM3V2gm;
Gmbs = -here->BSIM3V2gmbs;
FwdSum = 0.0;
RevSum = -(Gm + Gmbs);
gbbsp = -here->BSIM3V2gbds;
gbbdp = here->BSIM3V2gbds + here->BSIM3V2gbgs + here->BSIM3V2gbbs;
gbdpg = 0.0;
gbdpsp = 0.0;
gbdpb = 0.0;
gbdpdp = 0.0;
gbspg = here->BSIM3V2gbgs;
gbspsp = here->BSIM3V2gbds;
gbspb = here->BSIM3V2gbbs;
gbspdp = -(gbspg + gbspsp + gbspb);
if (here->BSIM3V2nqsMod == 0)
{ cggb = here->BSIM3V2cggb;
cgsb = here->BSIM3V2cgdb;
cgdb = here->BSIM3V2cgsb;
cbgb = here->BSIM3V2cbgb;
cbsb = here->BSIM3V2cbdb;
cbdb = here->BSIM3V2cbsb;
cdgb = -(here->BSIM3V2cdgb + cggb + cbgb);
cdsb = -(here->BSIM3V2cddb + cgsb + cbsb);
cddb = -(here->BSIM3V2cdsb + cgdb + cbdb);
xgtg = xgtd = xgts = xgtb = 0.0;
sxpart = 0.4;
dxpart = 0.6;
ddxpart_dVd = ddxpart_dVg = ddxpart_dVb
= ddxpart_dVs = 0.0;
dsxpart_dVd = dsxpart_dVg = dsxpart_dVb
= dsxpart_dVs = 0.0;
}
else
{ cggb = cgdb = cgsb = 0.0;
cbgb = cbdb = cbsb = 0.0;
cdgb = cddb = cdsb = 0.0;
xgtg = here->BSIM3V2gtg;
xgtd = here->BSIM3V2gts;
xgts = here->BSIM3V2gtd;
xgtb = here->BSIM3V2gtb;
xcqgb = here->BSIM3V2cqgb * omega;
xcqdb = here->BSIM3V2cqsb * omega;
xcqsb = here->BSIM3V2cqdb * omega;
xcqbb = here->BSIM3V2cqbb * omega;
CoxWL = model->BSIM3V2cox * here->pParam->BSIM3V2weffCV
* here->pParam->BSIM3V2leffCV;
qcheq = -(here->BSIM3V2qgate + here->BSIM3V2qbulk);
if (fabs(qcheq) <= 1.0e-5 * CoxWL)
{ if (model->BSIM3V2xpart < 0.5)
{ sxpart = 0.4;
}
else if (model->BSIM3V2xpart > 0.5)
{ sxpart = 0.0;
}
else
{ sxpart = 0.5;
}
dsxpart_dVd = dsxpart_dVg = dsxpart_dVb
= dsxpart_dVs = 0.0;
}
else
{ sxpart = here->BSIM3V2qdrn / qcheq;
Css = here->BSIM3V2cddb;
Cds = -(here->BSIM3V2cgdb + here->BSIM3V2cddb
+ here->BSIM3V2cbdb);
dsxpart_dVs = (Css - sxpart * (Css + Cds)) / qcheq;
Csg = here->BSIM3V2cdgb;
Cdg = -(here->BSIM3V2cggb + here->BSIM3V2cdgb
+ here->BSIM3V2cbgb);
dsxpart_dVg = (Csg - sxpart * (Csg + Cdg)) / qcheq;
Csd = here->BSIM3V2cdsb;
Cdd = -(here->BSIM3V2cgsb + here->BSIM3V2cdsb
+ here->BSIM3V2cbsb);
dsxpart_dVd = (Csd - sxpart * (Csd + Cdd)) / qcheq;
dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg
+ dsxpart_dVs);
}
dxpart = 1.0 - sxpart;
ddxpart_dVd = -dsxpart_dVd;
ddxpart_dVg = -dsxpart_dVg;
ddxpart_dVs = -dsxpart_dVs;
ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs);
}
}
T1 = *(ckt->CKTstate0 + here->BSIM3V2qdef) * here->BSIM3V2gtau;
gdpr = here->BSIM3V2drainConductance;
gspr = here->BSIM3V2sourceConductance;
gds = here->BSIM3V2gds;
gbd = here->BSIM3V2gbd;
gbs = here->BSIM3V2gbs;
capbd = here->BSIM3V2capbd;
capbs = here->BSIM3V2capbs;
GSoverlapCap = here->BSIM3V2cgso;
GDoverlapCap = here->BSIM3V2cgdo;
GBoverlapCap = here->pParam->BSIM3V2cgbo;
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;
*(here->BSIM3V2GgPtr +1) += xcggb;
*(here->BSIM3V2BbPtr +1) -= xcbgb + xcbdb + xcbsb;
*(here->BSIM3V2DPdpPtr +1) += xcddb;
*(here->BSIM3V2SPspPtr +1) += xcssb;
*(here->BSIM3V2GbPtr +1) -= xcggb + xcgdb + xcgsb;
*(here->BSIM3V2GdpPtr +1) += xcgdb;
*(here->BSIM3V2GspPtr +1) += xcgsb;
*(here->BSIM3V2BgPtr +1) += xcbgb;
*(here->BSIM3V2BdpPtr +1) += xcbdb;
*(here->BSIM3V2BspPtr +1) += xcbsb;
*(here->BSIM3V2DPgPtr +1) += xcdgb;
*(here->BSIM3V2DPbPtr +1) -= xcdgb + xcddb + xcdsb;
*(here->BSIM3V2DPspPtr +1) += xcdsb;
*(here->BSIM3V2SPgPtr +1) += xcsgb;
*(here->BSIM3V2SPbPtr +1) -= xcsgb + xcsdb + xcssb;
*(here->BSIM3V2SPdpPtr +1) += xcsdb;
*(here->BSIM3V2DdPtr) += gdpr;
*(here->BSIM3V2SsPtr) += gspr;
*(here->BSIM3V2BbPtr) += gbd + gbs - here->BSIM3V2gbbs;
*(here->BSIM3V2DPdpPtr) += gdpr + gds + gbd + RevSum
+ dxpart * xgtd + T1 * ddxpart_dVd + gbdpdp;
*(here->BSIM3V2SPspPtr) += gspr + gds + gbs + FwdSum
+ sxpart * xgts + T1 * dsxpart_dVs + gbspsp;
*(here->BSIM3V2DdpPtr) -= gdpr;
*(here->BSIM3V2SspPtr) -= gspr;
*(here->BSIM3V2BgPtr) -= here->BSIM3V2gbgs;
*(here->BSIM3V2BdpPtr) -= gbd - gbbdp;
*(here->BSIM3V2BspPtr) -= gbs - gbbsp;
*(here->BSIM3V2DPdPtr) -= gdpr;
*(here->BSIM3V2DPgPtr) += Gm + dxpart * xgtg + T1 * ddxpart_dVg
+ gbdpg;
*(here->BSIM3V2DPbPtr) -= gbd - Gmbs - dxpart * xgtb
- T1 * ddxpart_dVb - gbdpb;
*(here->BSIM3V2DPspPtr) -= gds + FwdSum - dxpart * xgts
- T1 * ddxpart_dVs - gbdpsp;
*(here->BSIM3V2SPgPtr) -= Gm - sxpart * xgtg - T1 * dsxpart_dVg
- gbspg;
*(here->BSIM3V2SPsPtr) -= gspr;
*(here->BSIM3V2SPbPtr) -= gbs + Gmbs - sxpart * xgtb
- T1 * dsxpart_dVb - gbspb;
*(here->BSIM3V2SPdpPtr) -= gds + RevSum - sxpart * xgtd
- T1 * dsxpart_dVd - gbspdp;
*(here->BSIM3V2GgPtr) -= xgtg;
*(here->BSIM3V2GbPtr) -= xgtb;
*(here->BSIM3V2GdpPtr) -= xgtd;
*(here->BSIM3V2GspPtr) -= xgts;
if (here->BSIM3V2nqsMod)
{ *(here->BSIM3V2QqPtr +1) += omega;
*(here->BSIM3V2QgPtr +1) -= xcqgb;
*(here->BSIM3V2QdpPtr +1) -= xcqdb;
*(here->BSIM3V2QspPtr +1) -= xcqsb;
*(here->BSIM3V2QbPtr +1) -= xcqbb;
*(here->BSIM3V2QqPtr) += here->BSIM3V2gtau;
*(here->BSIM3V2DPqPtr) += dxpart * here->BSIM3V2gtau;
*(here->BSIM3V2SPqPtr) += sxpart * here->BSIM3V2gtau;
*(here->BSIM3V2GqPtr) -= here->BSIM3V2gtau;
*(here->BSIM3V2QgPtr) += xgtg;
*(here->BSIM3V2QdpPtr) += xgtd;
*(here->BSIM3V2QspPtr) += xgts;
*(here->BSIM3V2QbPtr) += xgtb;
}
}
}
return(OK);
}

195
src/spicelib/devices/bsim3v2/b3v2ask.c
View File

@ -1,195 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
File: b3v2ask.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "ifsim.h"
#include "cktdefs.h"
#include "devdefs.h"
#include "bsim3v2def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3V2ask(ckt,inst,which,value,select)
CKTcircuit *ckt;
GENinstance *inst;
int which;
IFvalue *value;
IFvalue *select;
{
BSIM3V2instance *here = (BSIM3V2instance*)inst;
switch(which)
{ case BSIM3V2_L:
value->rValue = here->BSIM3V2l;
return(OK);
case BSIM3V2_W:
value->rValue = here->BSIM3V2w;
return(OK);
case BSIM3V2_AS:
value->rValue = here->BSIM3V2sourceArea;
return(OK);
case BSIM3V2_AD:
value->rValue = here->BSIM3V2drainArea;
return(OK);
case BSIM3V2_PS:
value->rValue = here->BSIM3V2sourcePerimeter;
return(OK);
case BSIM3V2_PD:
value->rValue = here->BSIM3V2drainPerimeter;
return(OK);
case BSIM3V2_NRS:
value->rValue = here->BSIM3V2sourceSquares;
return(OK);
case BSIM3V2_NRD:
value->rValue = here->BSIM3V2drainSquares;
return(OK);
case BSIM3V2_OFF:
value->rValue = here->BSIM3V2off;
return(OK);
case BSIM3V2_NQSMOD:
value->iValue = here->BSIM3V2nqsMod;
return(OK);
case BSIM3V2_IC_VBS:
value->rValue = here->BSIM3V2icVBS;
return(OK);
case BSIM3V2_IC_VDS:
value->rValue = here->BSIM3V2icVDS;
return(OK);
case BSIM3V2_IC_VGS:
value->rValue = here->BSIM3V2icVGS;
return(OK);
case BSIM3V2_DNODE:
value->iValue = here->BSIM3V2dNode;
return(OK);
case BSIM3V2_GNODE:
value->iValue = here->BSIM3V2gNode;
return(OK);
case BSIM3V2_SNODE:
value->iValue = here->BSIM3V2sNode;
return(OK);
case BSIM3V2_BNODE:
value->iValue = here->BSIM3V2bNode;
return(OK);
case BSIM3V2_DNODEPRIME:
value->iValue = here->BSIM3V2dNodePrime;
return(OK);
case BSIM3V2_SNODEPRIME:
value->iValue = here->BSIM3V2sNodePrime;
return(OK);
case BSIM3V2_SOURCECONDUCT:
value->rValue = here->BSIM3V2sourceConductance;
return(OK);
case BSIM3V2_DRAINCONDUCT:
value->rValue = here->BSIM3V2drainConductance;
return(OK);
case BSIM3V2_VBD:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2vbd);
return(OK);
case BSIM3V2_VBS:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2vbs);
return(OK);
case BSIM3V2_VGS:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2vgs);
return(OK);
case BSIM3V2_VDS:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2vds);
return(OK);
case BSIM3V2_CD:
value->rValue = here->BSIM3V2cd;
return(OK);
case BSIM3V2_CBS:
value->rValue = here->BSIM3V2cbs;
return(OK);
case BSIM3V2_CBD:
value->rValue = here->BSIM3V2cbd;
return(OK);
case BSIM3V2_GM:
value->rValue = here->BSIM3V2gm;
return(OK);
case BSIM3V2_GDS:
value->rValue = here->BSIM3V2gds;
return(OK);
case BSIM3V2_GMBS:
value->rValue = here->BSIM3V2gmbs;
return(OK);
case BSIM3V2_GBD:
value->rValue = here->BSIM3V2gbd;
return(OK);
case BSIM3V2_GBS:
value->rValue = here->BSIM3V2gbs;
return(OK);
case BSIM3V2_QB:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2qb);
return(OK);
case BSIM3V2_CQB:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2cqb);
return(OK);
case BSIM3V2_QG:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2qg);
return(OK);
case BSIM3V2_CQG:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2cqg);
return(OK);
case BSIM3V2_QD:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2qd);
return(OK);
case BSIM3V2_CQD:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2cqd);
return(OK);
case BSIM3V2_CGG:
value->rValue = here->BSIM3V2cggb;
return(OK);
case BSIM3V2_CGD:
value->rValue = here->BSIM3V2cgdb;
return(OK);
case BSIM3V2_CGS:
value->rValue = here->BSIM3V2cgsb;
return(OK);
case BSIM3V2_CDG:
value->rValue = here->BSIM3V2cdgb;
return(OK);
case BSIM3V2_CDD:
value->rValue = here->BSIM3V2cddb;
return(OK);
case BSIM3V2_CDS:
value->rValue = here->BSIM3V2cdsb;
return(OK);
case BSIM3V2_CBG:
value->rValue = here->BSIM3V2cbgb;
return(OK);
case BSIM3V2_CBDB:
value->rValue = here->BSIM3V2cbdb;
return(OK);
case BSIM3V2_CBSB:
value->rValue = here->BSIM3V2cbsb;
return(OK);
case BSIM3V2_CAPBD:
value->rValue = here->BSIM3V2capbd;
return(OK);
case BSIM3V2_CAPBS:
value->rValue = here->BSIM3V2capbs;
return(OK);
case BSIM3V2_VON:
value->rValue = here->BSIM3V2von;
return(OK);
case BSIM3V2_VDSAT:
value->rValue = here->BSIM3V2vdsat;
return(OK);
case BSIM3V2_QBS:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2qbs);
return(OK);
case BSIM3V2_QBD:
value->rValue = *(ckt->CKTstate0 + here->BSIM3V2qbd);
return(OK);
default:
return(E_BADPARM);
}
/* NOTREACHED */
}

428
src/spicelib/devices/bsim3v2/b3v2check.c
View File

@ -1,428 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: Min-Chie Jeng.
Modified by Weidong Liu (1997-1998).
File: b3v2check.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "bsim3v2def.h"
#include "trandefs.h"
#include "const.h"
#include "sperror.h"
#include "devdefs.h"
#include "suffix.h"
int
BSIM3V2checkModel(model, here, ckt)
BSIM3V2model *model;
BSIM3V2instance *here;
CKTcircuit *ckt;
{
struct BSIM3V2SizeDependParam *pParam;
int Fatal_Flag = 0;
FILE *fplog;
if ((fplog = fopen("b3v3check.log", "w")) != NULL)
{ pParam = here->pParam;
fprintf(fplog, "BSIM3V3.2 Parameter Check\n");
fprintf(fplog, "Model = %s\n", model->BSIM3V2modName);
fprintf(fplog, "W = %g, L = %g\n", here->BSIM3V2w, here->BSIM3V2l);
if (pParam->BSIM3V2nlx < -pParam->BSIM3V2leff)
{ fprintf(fplog, "Fatal: Nlx = %g is less than -Leff.\n",
pParam->BSIM3V2nlx);
printf("Fatal: Nlx = %g is less than -Leff.\n",
pParam->BSIM3V2nlx);
Fatal_Flag = 1;
}
if (model->BSIM3V2tox <= 0.0)
{ fprintf(fplog, "Fatal: Tox = %g is not positive.\n",
model->BSIM3V2tox);
printf("Fatal: Tox = %g is not positive.\n", model->BSIM3V2tox);
Fatal_Flag = 1;
}
if (model->BSIM3V2toxm <= 0.0)
{ fprintf(fplog, "Fatal: Toxm = %g is not positive.\n",
model->BSIM3V2toxm);
printf("Fatal: Toxm = %g is not positive.\n", model->BSIM3V2toxm);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2npeak <= 0.0)
{ fprintf(fplog, "Fatal: Nch = %g is not positive.\n",
pParam->BSIM3V2npeak);
printf("Fatal: Nch = %g is not positive.\n",
pParam->BSIM3V2npeak);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2nsub <= 0.0)
{ fprintf(fplog, "Fatal: Nsub = %g is not positive.\n",
pParam->BSIM3V2nsub);
printf("Fatal: Nsub = %g is not positive.\n",
pParam->BSIM3V2nsub);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2ngate < 0.0)
{ fprintf(fplog, "Fatal: Ngate = %g is not positive.\n",
pParam->BSIM3V2ngate);
printf("Fatal: Ngate = %g Ngate is not positive.\n",
pParam->BSIM3V2ngate);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2ngate > 1.e25)
{ fprintf(fplog, "Fatal: Ngate = %g is too high.\n",
pParam->BSIM3V2ngate);
printf("Fatal: Ngate = %g Ngate is too high\n",
pParam->BSIM3V2ngate);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2xj <= 0.0)
{ fprintf(fplog, "Fatal: Xj = %g is not positive.\n",
pParam->BSIM3V2xj);
printf("Fatal: Xj = %g is not positive.\n", pParam->BSIM3V2xj);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2dvt1 < 0.0)
{ fprintf(fplog, "Fatal: Dvt1 = %g is negative.\n",
pParam->BSIM3V2dvt1);
printf("Fatal: Dvt1 = %g is negative.\n", pParam->BSIM3V2dvt1);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2dvt1w < 0.0)
{ fprintf(fplog, "Fatal: Dvt1w = %g is negative.\n",
pParam->BSIM3V2dvt1w);
printf("Fatal: Dvt1w = %g is negative.\n", pParam->BSIM3V2dvt1w);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2w0 == -pParam->BSIM3V2weff)
{ fprintf(fplog, "Fatal: (W0 + Weff) = 0 causing divided-by-zero.\n");
printf("Fatal: (W0 + Weff) = 0 causing divided-by-zero.\n");
Fatal_Flag = 1;
}
if (pParam->BSIM3V2dsub < 0.0)
{ fprintf(fplog, "Fatal: Dsub = %g is negative.\n", pParam->BSIM3V2dsub);
printf("Fatal: Dsub = %g is negative.\n", pParam->BSIM3V2dsub);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2b1 == -pParam->BSIM3V2weff)
{ fprintf(fplog, "Fatal: (B1 + Weff) = 0 causing divided-by-zero.\n");
printf("Fatal: (B1 + Weff) = 0 causing divided-by-zero.\n");
Fatal_Flag = 1;
}
if (pParam->BSIM3V2u0temp <= 0.0)
{ fprintf(fplog, "Fatal: u0 at current temperature = %g is not positive.\n", pParam->BSIM3V2u0temp);
printf("Fatal: u0 at current temperature = %g is not positive.\n",
pParam->BSIM3V2u0temp);
Fatal_Flag = 1;
}
/* Check delta parameter */
if (pParam->BSIM3V2delta < 0.0)
{ fprintf(fplog, "Fatal: Delta = %g is less than zero.\n",
pParam->BSIM3V2delta);
printf("Fatal: Delta = %g is less than zero.\n", pParam->BSIM3V2delta);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2vsattemp <= 0.0)
{ fprintf(fplog, "Fatal: Vsat at current temperature = %g is not positive.\n", pParam->BSIM3V2vsattemp);
printf("Fatal: Vsat at current temperature = %g is not positive.\n",
pParam->BSIM3V2vsattemp);
Fatal_Flag = 1;
}
/* Check Rout parameters */
if (pParam->BSIM3V2pclm <= 0.0)
{ fprintf(fplog, "Fatal: Pclm = %g is not positive.\n", pParam->BSIM3V2pclm);
printf("Fatal: Pclm = %g is not positive.\n", pParam->BSIM3V2pclm);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2drout < 0.0)
{ fprintf(fplog, "Fatal: Drout = %g is negative.\n", pParam->BSIM3V2drout);
printf("Fatal: Drout = %g is negative.\n", pParam->BSIM3V2drout);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2pscbe2 <= 0.0)
{ fprintf(fplog, "Warning: Pscbe2 = %g is not positive.\n",
pParam->BSIM3V2pscbe2);
printf("Warning: Pscbe2 = %g is not positive.\n", pParam->BSIM3V2pscbe2);
}
if (model->BSIM3V2unitLengthSidewallJctCap > 0.0 ||
model->BSIM3V2unitLengthGateSidewallJctCap > 0.0)
{
if (here->BSIM3V2drainPerimeter < pParam->BSIM3V2weff)
{ fprintf(fplog, "Warning: Pd = %g is less than W.\n",
here->BSIM3V2drainPerimeter);
printf("Warning: Pd = %g is less than W.\n",
here->BSIM3V2drainPerimeter);
}
if (here->BSIM3V2sourcePerimeter < pParam->BSIM3V2weff)
{ fprintf(fplog, "Warning: Ps = %g is less than W.\n",
here->BSIM3V2sourcePerimeter);
printf("Warning: Ps = %g is less than W.\n",
here->BSIM3V2sourcePerimeter);
}
}
if (pParam->BSIM3V2noff < 0.1)
{ fprintf(fplog, "Warning: Noff = %g is too small.\n",
pParam->BSIM3V2noff);
printf("Warning: Noff = %g is too small.\n", pParam->BSIM3V2noff);
}
if (pParam->BSIM3V2noff > 4.0)
{ fprintf(fplog, "Warning: Noff = %g is too large.\n",
pParam->BSIM3V2noff);
printf("Warning: Noff = %g is too large.\n", pParam->BSIM3V2noff);
}
if (pParam->BSIM3V2voffcv < -0.5)
{ fprintf(fplog, "Warning: Voffcv = %g is too small.\n",
pParam->BSIM3V2voffcv);
printf("Warning: Voffcv = %g is too small.\n", pParam->BSIM3V2voffcv);
}
if (pParam->BSIM3V2voffcv > 0.5)
{ fprintf(fplog, "Warning: Voffcv = %g is too large.\n",
pParam->BSIM3V2voffcv);
printf("Warning: Voffcv = %g is too large.\n", pParam->BSIM3V2voffcv);
}
if (model->BSIM3V2ijth < 0.0)
{ fprintf(fplog, "Fatal: Ijth = %g cannot be negative.\n",
model->BSIM3V2ijth);
printf("Fatal: Ijth = %g cannot be negative.\n", model->BSIM3V2ijth);
Fatal_Flag = 1;
}
/* Check capacitance parameters */
if (pParam->BSIM3V2clc < 0.0)
{ fprintf(fplog, "Fatal: Clc = %g is negative.\n", pParam->BSIM3V2clc);
printf("Fatal: Clc = %g is negative.\n", pParam->BSIM3V2clc);
Fatal_Flag = 1;
}
if (pParam->BSIM3V2moin < 5.0)
{ fprintf(fplog, "Warning: Moin = %g is too small.\n",
pParam->BSIM3V2moin);
printf("Warning: Moin = %g is too small.\n", pParam->BSIM3V2moin);
}
if (pParam->BSIM3V2moin > 25.0)
{ fprintf(fplog, "Warning: Moin = %g is too large.\n",
pParam->BSIM3V2moin);
printf("Warning: Moin = %g is too large.\n", pParam->BSIM3V2moin);
}
if (pParam->BSIM3V2acde < 0.4)
{ fprintf(fplog, "Warning: Acde = %g is too small.\n",
pParam->BSIM3V2acde);
printf("Warning: Acde = %g is too small.\n", pParam->BSIM3V2acde);
}
if (pParam->BSIM3V2acde > 1.6)
{ fprintf(fplog, "Warning: Acde = %g is too large.\n",
pParam->BSIM3V2acde);
printf("Warning: Acde = %g is too large.\n", pParam->BSIM3V2acde);
}
if (model->BSIM3V2paramChk ==1)
{
/* Check L and W parameters */
if (pParam->BSIM3V2leff <= 5.0e-8)
{ fprintf(fplog, "Warning: Leff = %g may be too small.\n",
pParam->BSIM3V2leff);
printf("Warning: Leff = %g may be too small.\n",
pParam->BSIM3V2leff);
}
if (pParam->BSIM3V2leffCV <= 5.0e-8)
{ fprintf(fplog, "Warning: Leff for CV = %g may be too small.\n",
pParam->BSIM3V2leffCV);
printf("Warning: Leff for CV = %g may be too small.\n",
pParam->BSIM3V2leffCV);
}
if (pParam->BSIM3V2weff <= 1.0e-7)
{ fprintf(fplog, "Warning: Weff = %g may be too small.\n",
pParam->BSIM3V2weff);
printf("Warning: Weff = %g may be too small.\n",
pParam->BSIM3V2weff);
}
if (pParam->BSIM3V2weffCV <= 1.0e-7)
{ fprintf(fplog, "Warning: Weff for CV = %g may be too small.\n",
pParam->BSIM3V2weffCV);
printf("Warning: Weff for CV = %g may be too small.\n",
pParam->BSIM3V2weffCV);
}
/* Check threshold voltage parameters */
if (pParam->BSIM3V2nlx < 0.0)
{ fprintf(fplog, "Warning: Nlx = %g is negative.\n", pParam->BSIM3V2nlx);
printf("Warning: Nlx = %g is negative.\n", pParam->BSIM3V2nlx);
}
if (model->BSIM3V2tox < 1.0e-9)
{ fprintf(fplog, "Warning: Tox = %g is less than 10A.\n",
model->BSIM3V2tox);
printf("Warning: Tox = %g is less than 10A.\n", model->BSIM3V2tox);
}
if (pParam->BSIM3V2npeak <= 1.0e15)
{ fprintf(fplog, "Warning: Nch = %g may be too small.\n",
pParam->BSIM3V2npeak);
printf("Warning: Nch = %g may be too small.\n",
pParam->BSIM3V2npeak);
}
else if (pParam->BSIM3V2npeak >= 1.0e21)
{ fprintf(fplog, "Warning: Nch = %g may be too large.\n",
pParam->BSIM3V2npeak);
printf("Warning: Nch = %g may be too large.\n",
pParam->BSIM3V2npeak);
}
if (pParam->BSIM3V2nsub <= 1.0e14)
{ fprintf(fplog, "Warning: Nsub = %g may be too small.\n",
pParam->BSIM3V2nsub);
printf("Warning: Nsub = %g may be too small.\n",
pParam->BSIM3V2nsub);
}
else if (pParam->BSIM3V2nsub >= 1.0e21)
{ fprintf(fplog, "Warning: Nsub = %g may be too large.\n",
pParam->BSIM3V2nsub);
printf("Warning: Nsub = %g may be too large.\n",
pParam->BSIM3V2nsub);
}
if ((pParam->BSIM3V2ngate > 0.0) &&
(pParam->BSIM3V2ngate <= 1.e18))
{ fprintf(fplog, "Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->BSIM3V2ngate);
printf("Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->BSIM3V2ngate);
}
if (pParam->BSIM3V2dvt0 < 0.0)
{ fprintf(fplog, "Warning: Dvt0 = %g is negative.\n",
pParam->BSIM3V2dvt0);
printf("Warning: Dvt0 = %g is negative.\n", pParam->BSIM3V2dvt0);
}
if (fabs(1.0e-6 / (pParam->BSIM3V2w0 + pParam->BSIM3V2weff)) > 10.0)
{ fprintf(fplog, "Warning: (W0 + Weff) may be too small.\n");
printf("Warning: (W0 + Weff) may be too small.\n");
}
/* Check subthreshold parameters */
if (pParam->BSIM3V2nfactor < 0.0)
{ fprintf(fplog, "Warning: Nfactor = %g is negative.\n",
pParam->BSIM3V2nfactor);
printf("Warning: Nfactor = %g is negative.\n", pParam->BSIM3V2nfactor);
}
if (pParam->BSIM3V2cdsc < 0.0)
{ fprintf(fplog, "Warning: Cdsc = %g is negative.\n",
pParam->BSIM3V2cdsc);
printf("Warning: Cdsc = %g is negative.\n", pParam->BSIM3V2cdsc);
}
if (pParam->BSIM3V2cdscd < 0.0)
{ fprintf(fplog, "Warning: Cdscd = %g is negative.\n",
pParam->BSIM3V2cdscd);
printf("Warning: Cdscd = %g is negative.\n", pParam->BSIM3V2cdscd);
}
/* Check DIBL parameters */
if (pParam->BSIM3V2eta0 < 0.0)
{ fprintf(fplog, "Warning: Eta0 = %g is negative.\n",
pParam->BSIM3V2eta0);
printf("Warning: Eta0 = %g is negative.\n", pParam->BSIM3V2eta0);
}
/* Check Abulk parameters */
if (fabs(1.0e-6 / (pParam->BSIM3V2b1 + pParam->BSIM3V2weff)) > 10.0)
{ fprintf(fplog, "Warning: (B1 + Weff) may be too small.\n");
printf("Warning: (B1 + Weff) may be too small.\n");
}
/* Check Saturation parameters */
if (pParam->BSIM3V2a2 < 0.01)
{ fprintf(fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", pParam->BSIM3V2a2);
printf("Warning: A2 = %g is too small. Set to 0.01.\n",
pParam->BSIM3V2a2);
pParam->BSIM3V2a2 = 0.01;
}
else if (pParam->BSIM3V2a2 > 1.0)
{ fprintf(fplog, "Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->BSIM3V2a2);
printf("Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->BSIM3V2a2);
pParam->BSIM3V2a2 = 1.0;
pParam->BSIM3V2a1 = 0.0;
}
if (pParam->BSIM3V2rdsw < 0.0)
{ fprintf(fplog, "Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->BSIM3V2rdsw);
printf("Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->BSIM3V2rdsw);
pParam->BSIM3V2rdsw = 0.0;
pParam->BSIM3V2rds0 = 0.0;
}
else if ((pParam->BSIM3V2rds0 > 0.0) && (pParam->BSIM3V2rds0 < 0.001))
{ fprintf(fplog, "Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n",
pParam->BSIM3V2rds0);
printf("Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n",
pParam->BSIM3V2rds0);
pParam->BSIM3V2rds0 = 0.0;
}
if (pParam->BSIM3V2vsattemp < 1.0e3)
{ fprintf(fplog, "Warning: Vsat at current temperature = %g may be too small.\n", pParam->BSIM3V2vsattemp);
printf("Warning: Vsat at current temperature = %g may be too small.\n", pParam->BSIM3V2vsattemp);
}
if (pParam->BSIM3V2pdibl1 < 0.0)
{ fprintf(fplog, "Warning: Pdibl1 = %g is negative.\n",
pParam->BSIM3V2pdibl1);
printf("Warning: Pdibl1 = %g is negative.\n", pParam->BSIM3V2pdibl1);
}
if (pParam->BSIM3V2pdibl2 < 0.0)
{ fprintf(fplog, "Warning: Pdibl2 = %g is negative.\n",
pParam->BSIM3V2pdibl2);
printf("Warning: Pdibl2 = %g is negative.\n", pParam->BSIM3V2pdibl2);
}
/* Check overlap capacitance parameters */
if (model->BSIM3V2cgdo < 0.0)
{ fprintf(fplog, "Warning: cgdo = %g is negative. Set to zero.\n", model->BSIM3V2cgdo);
printf("Warning: cgdo = %g is negative. Set to zero.\n", model->BSIM3V2cgdo);
model->BSIM3V2cgdo = 0.0;
}
if (model->BSIM3V2cgso < 0.0)
{ fprintf(fplog, "Warning: cgso = %g is negative. Set to zero.\n", model->BSIM3V2cgso);
printf("Warning: cgso = %g is negative. Set to zero.\n", model->BSIM3V2cgso);
model->BSIM3V2cgso = 0.0;
}
if (model->BSIM3V2cgbo < 0.0)
{ fprintf(fplog, "Warning: cgbo = %g is negative. Set to zero.\n", model->BSIM3V2cgbo);
printf("Warning: cgbo = %g is negative. Set to zero.\n", model->BSIM3V2cgbo);
model->BSIM3V2cgbo = 0.0;
}
}/* loop for the parameter check for warning messages */
fclose(fplog);
}
else
{ fprintf(stderr, "Warning: Can't open log file. Parameter checking skipped.\n");
}
return(Fatal_Flag);
}

106
src/spicelib/devices/bsim3v2/b3v2cvtest.c
View File

@ -1,106 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
File: b3v2cvtest.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "bsim3v2def.h"
#include "trandefs.h"
#include "const.h"
#include "devdefs.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3V2convTest(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
BSIM3V2model *model = (BSIM3V2model*)inModel;
BSIM3V2instance *here;
double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds;
double cbd, cbhat, cbs, cd, cdhat, tol, vgd, vgdo, vgs;
/* loop through all the BSIM3V2 device models */
for (; model != NULL; model = model->BSIM3V2nextModel)
{ /* loop through all the instances of the model */
for (here = model->BSIM3V2instances; here != NULL ;
here=here->BSIM3V2nextInstance)
{
if (here->BSIM3V2owner != ARCHme) continue;
vbs = model->BSIM3V2type
* (*(ckt->CKTrhsOld+here->BSIM3V2bNode)
- *(ckt->CKTrhsOld+here->BSIM3V2sNodePrime));
vgs = model->BSIM3V2type
* (*(ckt->CKTrhsOld+here->BSIM3V2gNode)
- *(ckt->CKTrhsOld+here->BSIM3V2sNodePrime));
vds = model->BSIM3V2type
* (*(ckt->CKTrhsOld+here->BSIM3V2dNodePrime)
- *(ckt->CKTrhsOld+here->BSIM3V2sNodePrime));
vbd = vbs - vds;
vgd = vgs - vds;
vgdo = *(ckt->CKTstate0 + here->BSIM3V2vgs)
- *(ckt->CKTstate0 + here->BSIM3V2vds);
delvbs = vbs - *(ckt->CKTstate0 + here->BSIM3V2vbs);
delvbd = vbd - *(ckt->CKTstate0 + here->BSIM3V2vbd);
delvgs = vgs - *(ckt->CKTstate0 + here->BSIM3V2vgs);
delvds = vds - *(ckt->CKTstate0 + here->BSIM3V2vds);
delvgd = vgd-vgdo;
cd = here->BSIM3V2cd - here->BSIM3V2cbd;
if (here->BSIM3V2mode >= 0)
{ cd += here->BSIM3V2csub;
cdhat = cd - here->BSIM3V2gbd * delvbd
+ (here->BSIM3V2gmbs + here->BSIM3V2gbbs) * delvbs
+ (here->BSIM3V2gm + here->BSIM3V2gbgs) * delvgs
+ (here->BSIM3V2gds + here->BSIM3V2gbds) * delvds;
}
else
{ cdhat = cd + (here->BSIM3V2gmbs - here->BSIM3V2gbd) * delvbd
+ here->BSIM3V2gm * delvgd - here->BSIM3V2gds * delvds;
}
/*
* check convergence
*/
if ((here->BSIM3V2off == 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->BSIM3V2cbs;
cbd = here->BSIM3V2cbd;
if (here->BSIM3V2mode >= 0)
{ cbhat = cbs + cbd - here->BSIM3V2csub
+ here->BSIM3V2gbd * delvbd
+ (here->BSIM3V2gbs - here->BSIM3V2gbbs) * delvbs
- here->BSIM3V2gbgs * delvgs
- here->BSIM3V2gbds * delvds;
}
else
{ cbhat = cbs + cbd - here->BSIM3V2csub
+ here->BSIM3V2gbs * delvbs
+ (here->BSIM3V2gbd - here->BSIM3V2gbbs) * delvbd
- here->BSIM3V2gbgs * delvgd
+ here->BSIM3V2gbds * delvds;
}
tol = ckt->CKTreltol * MAX(fabs(cbhat),
fabs(cbs + cbd - here->BSIM3V2csub)) + ckt->CKTabstol;
if (fabs(cbhat - (cbs + cbd - here->BSIM3V2csub)) > tol)
{ ckt->CKTnoncon++;
return(OK);
}
}
}
}
return(OK);
}

42
src/spicelib/devices/bsim3v2/b3v2del.c
View File

@ -1,42 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
File: b3v2del.c
**********/
/*
*/
#include "ngspice.h"
#include <stdio.h>
#include "bsim3v2def.h"
#include "sperror.h"
#include "gendefs.h"
#include "suffix.h"
int
BSIM3V2delete(inModel,name,inInst)
GENmodel *inModel;
IFuid name;
GENinstance **inInst;
{
BSIM3V2instance **fast = (BSIM3V2instance**)inInst;
BSIM3V2model *model = (BSIM3V2model*)inModel;
BSIM3V2instance **prev = NULL;
BSIM3V2instance *here;
for (; model ; model = model->BSIM3V2nextModel)
{ prev = &(model->BSIM3V2instances);
for (here = *prev; here ; here = *prev)
{ if (here->BSIM3V2name == name || (fast && here==*fast))
{ *prev= here->BSIM3V2nextInstance;
FREE(here);
return(OK);
}
prev = &(here->BSIM3V2nextInstance);
}
}
return(E_NODEV);
}

38
src/spicelib/devices/bsim3v2/b3v2dest.c
View File

@ -1,38 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
File: b3v2dest.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include "bsim3v2def.h"
#include "suffix.h"
void
BSIM3V2destroy(inModel)
GENmodel **inModel;
{
BSIM3V2model **model = (BSIM3V2model**)inModel;
BSIM3V2instance *here;
BSIM3V2instance *prev = NULL;
BSIM3V2model *mod = *model;
BSIM3V2model *oldmod = NULL;
for (; mod ; mod = mod->BSIM3V2nextModel)
{ if(oldmod) FREE(oldmod);
oldmod = mod;
prev = (BSIM3V2instance *)NULL;
for (here = mod->BSIM3V2instances; here; here = here->BSIM3V2nextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
}
if(oldmod) FREE(oldmod);
*model = NULL;
return;
}

44
src/spicelib/devices/bsim3v2/b3v2getic.c
View File

@ -1,44 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
File: b3v2getic.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "bsim3v2def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3V2getic(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
BSIM3V2model *model = (BSIM3V2model*)inModel;
BSIM3V2instance *here;
for (; model ; model = model->BSIM3V2nextModel)
{ for (here = model->BSIM3V2instances; here; here = here->BSIM3V2nextInstance)
{
if (here->BSIM3V2owner != ARCHme) continue;
if(!here->BSIM3V2icVBSGiven)
{ here->BSIM3V2icVBS = *(ckt->CKTrhs + here->BSIM3V2bNode)
- *(ckt->CKTrhs + here->BSIM3V2sNode);
}
if (!here->BSIM3V2icVDSGiven)
{ here->BSIM3V2icVDS = *(ckt->CKTrhs + here->BSIM3V2dNode)
- *(ckt->CKTrhs + here->BSIM3V2sNode);
}
if (!here->BSIM3V2icVGSGiven)
{ here->BSIM3V2icVGS = *(ckt->CKTrhs + here->BSIM3V2gNode)
- *(ckt->CKTrhs + here->BSIM3V2sNode);
}
}
}
return(OK);
}

2906
src/spicelib/devices/bsim3v2/b3v2ld.c
View File

File diff suppressed because it is too large Load Diff

1239
src/spicelib/devices/bsim3v2/b3v2mask.c
View File

File diff suppressed because it is too large Load Diff

46
src/spicelib/devices/bsim3v2/b3v2mdel.c
View File

@ -1,46 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
File: b3v2mdel.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include "bsim3v2def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3V2mDelete(inModel,modname,kill)
GENmodel **inModel;
IFuid modname;
GENmodel *kill;
{
BSIM3V2model **model = (BSIM3V2model**)inModel;
BSIM3V2model *modfast = (BSIM3V2model*)kill;
BSIM3V2instance *here;
BSIM3V2instance *prev = NULL;
BSIM3V2model **oldmod;
oldmod = model;
for (; *model ; model = &((*model)->BSIM3V2nextModel))
{ if ((*model)->BSIM3V2modName == modname ||
(modfast && *model == modfast))
goto delgot;
oldmod = model;
}
return(E_NOMOD);
delgot:
*oldmod = (*model)->BSIM3V2nextModel; /* cut deleted device out of list */
for (here = (*model)->BSIM3V2instances; here; here = here->BSIM3V2nextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
FREE(*model);
return(OK);
}

1675
src/spicelib/devices/bsim3v2/b3v2mpar.c
View File

File diff suppressed because it is too large Load Diff

384
src/spicelib/devices/bsim3v2/b3v2noi.c
View File

@ -1,384 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Gary W. Ng and Min-Chie Jeng.
File: b3v2noi.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "bsim3v2def.h"
#include "cktdefs.h"
#include "iferrmsg.h"
#include "noisedef.h"
#include "suffix.h"
#include "const.h" /* jwan */
/*
* BSIM3V2noise (mode, operation, firstModel, ckt, data, OnDens)
* This routine names and evaluates all of the noise sources
* associated with MOSFET's. It starts with the model *firstModel and
* traverses all of its insts. It then proceeds to any other models
* on the linked list. The total output noise density generated by
* all of the MOSFET's is summed with the variable "OnDens".
*/
/*
Channel thermal and flicker noises are calculated based on the value
of model->BSIM3V2noiMod.
If model->BSIM3V2noiMod = 1,
Channel thermal noise = SPICE2 model
Flicker noise = SPICE2 model
If model->BSIM3V2noiMod = 2,
Channel thermal noise = BSIM3V2 model
Flicker noise = BSIM3V2 model
If model->BSIM3V2noiMod = 3,
Channel thermal noise = SPICE2 model
Flicker noise = BSIM3V2 model
If model->BSIM3V2noiMod = 4,
Channel thermal noise = BSIM3V2 model
Flicker noise = SPICE2 model
*/
extern void NevalSrc();
extern double Nintegrate();
double
BSIM3V2StrongInversionNoiseEval(vgs, vds, model, here, freq, temp)
double vgs, vds, freq, temp;
BSIM3V2model *model;
BSIM3V2instance *here;
{
struct BSIM3V2SizeDependParam *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->BSIM3V2cd);
if (vds > here->BSIM3V2vdsat)
{ esat = 2.0 * pParam->BSIM3V2vsattemp / here->BSIM3V2ueff;
T0 = ((((vds - here->BSIM3V2vdsat) / pParam->BSIM3V2litl) + model->BSIM3V2em)
/ esat);
DelClm = pParam->BSIM3V2litl * log (MAX(T0, N_MINLOG));
}
else
DelClm = 0.0;
EffFreq = pow(freq, model->BSIM3V2ef);
T1 = CHARGE * CHARGE * 8.62e-5 * cd * temp * here->BSIM3V2ueff;
T2 = 1.0e8 * EffFreq * model->BSIM3V2cox
* pParam->BSIM3V2leff * pParam->BSIM3V2leff;
Vgst = vgs - here->BSIM3V2von;
N0 = model->BSIM3V2cox * Vgst / CHARGE;
if (N0 < 0.0)
N0 = 0.0;
Nl = model->BSIM3V2cox * (Vgst - MIN(vds, here->BSIM3V2vdsat)) / CHARGE;
if (Nl < 0.0)
Nl = 0.0;
T3 = model->BSIM3V2oxideTrapDensityA
* log(MAX(((N0 + 2.0e14) / (Nl + 2.0e14)), N_MINLOG));
T4 = model->BSIM3V2oxideTrapDensityB * (N0 - Nl);
T5 = model->BSIM3V2oxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl);
T6 = 8.62e-5 * temp * cd * cd;
T7 = 1.0e8 * EffFreq * pParam->BSIM3V2leff
* pParam->BSIM3V2leff * pParam->BSIM3V2weff;
T8 = model->BSIM3V2oxideTrapDensityA + model->BSIM3V2oxideTrapDensityB * Nl
+ model->BSIM3V2oxideTrapDensityC * Nl * Nl;
T9 = (Nl + 2.0e14) * (Nl + 2.0e14);
Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9;
return Ssi;
}
int
BSIM3V2noise (mode, operation, inModel, ckt, data, OnDens)
int mode, operation;
GENmodel *inModel;
CKTcircuit *ckt;
Ndata *data;
double *OnDens;
{
BSIM3V2model *model = (BSIM3V2model *)inModel;
BSIM3V2instance *here;
struct BSIM3V2SizeDependParam *pParam;
char name[N_MXVLNTH];
double tempOnoise;
double tempInoise;
double noizDens[BSIM3V2NSRCS];
double lnNdens[BSIM3V2NSRCS];
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 *BSIM3V2nNames[BSIM3V2NSRCS] =
{ /* Note that we have to keep the order */
".rd", /* noise due to rd */
/* consistent with the index definitions */
".rs", /* noise due to rs */
/* in BSIM3V2defs.h */
".id", /* noise due to id */
".1overf", /* flicker (1/f) noise */
"" /* total transistor noise */
};
for (; model != NULL; model = model->BSIM3V2nextModel)
{ for (here = model->BSIM3V2instances; here != NULL;
here = here->BSIM3V2nextInstance)
{ 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 < BSIM3V2NSRCS; i++)
{ (void) sprintf(name, "onoise.%s%s",
here->BSIM3V2name,
BSIM3V2nNames[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 < BSIM3V2NSRCS; i++)
{ (void) sprintf(name, "onoise_total.%s%s",
here->BSIM3V2name,
BSIM3V2nNames[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->BSIM3V2name,
BSIM3V2nNames[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[BSIM3V2RDNOIZ],
&lnNdens[BSIM3V2RDNOIZ], ckt, THERMNOISE,
here->BSIM3V2dNodePrime, here->BSIM3V2dNode,
here->BSIM3V2drainConductance);
NevalSrc(&noizDens[BSIM3V2RSNOIZ],
&lnNdens[BSIM3V2RSNOIZ], ckt, THERMNOISE,
here->BSIM3V2sNodePrime, here->BSIM3V2sNode,
here->BSIM3V2sourceConductance);
switch( model->BSIM3V2noiMod )
{ case 1:
case 3:
NevalSrc(&noizDens[BSIM3V2IDNOIZ],
&lnNdens[BSIM3V2IDNOIZ], ckt,
THERMNOISE, here->BSIM3V2dNodePrime,
here->BSIM3V2sNodePrime,
(2.0 / 3.0 * fabs(here->BSIM3V2gm
+ here->BSIM3V2gds
+ here->BSIM3V2gmbs)));
break;
case 2:
case 4:
NevalSrc(&noizDens[BSIM3V2IDNOIZ],
&lnNdens[BSIM3V2IDNOIZ], ckt,
THERMNOISE, here->BSIM3V2dNodePrime,
here->BSIM3V2sNodePrime,
(here->BSIM3V2ueff
* fabs(here->BSIM3V2qinv
/ (pParam->BSIM3V2leff
* pParam->BSIM3V2leff))));
break;
}
NevalSrc(&noizDens[BSIM3V2FLNOIZ], (double*) NULL,
ckt, N_GAIN, here->BSIM3V2dNodePrime,
here->BSIM3V2sNodePrime, (double) 0.0);
switch( model->BSIM3V2noiMod )
{ case 1:
case 4:
noizDens[BSIM3V2FLNOIZ] *= model->BSIM3V2kf
* exp(model->BSIM3V2af
* log(MAX(fabs(here->BSIM3V2cd),
N_MINLOG)))
/ (pow(data->freq, model->BSIM3V2ef)
* pParam->BSIM3V2leff
* pParam->BSIM3V2leff
* model->BSIM3V2cox);
break;
case 2:
case 3:
vgs = *(ckt->CKTstates[0] + here->BSIM3V2vgs);
vds = *(ckt->CKTstates[0] + here->BSIM3V2vds);
if (vds < 0.0)
{ vds = -vds;
vgs = vgs + vds;
}
if (vgs >= here->BSIM3V2von + 0.1)
{ Ssi = BSIM3V2StrongInversionNoiseEval(vgs,
vds, model, here, data->freq,
ckt->CKTtemp);
noizDens[BSIM3V2FLNOIZ] *= Ssi;
}
else
{ pParam = here->pParam;
T10 = model->BSIM3V2oxideTrapDensityA
* 8.62e-5 * ckt->CKTtemp;
T11 = pParam->BSIM3V2weff
* pParam->BSIM3V2leff
* pow(data->freq, model->BSIM3V2ef)
* 4.0e36;
Swi = T10 / T11 * here->BSIM3V2cd
* here->BSIM3V2cd;
Slimit = BSIM3V2StrongInversionNoiseEval(
here->BSIM3V2von + 0.1, vds, model,
here, data->freq, ckt->CKTtemp);
T1 = Swi + Slimit;
if (T1 > 0.0)
noizDens[BSIM3V2FLNOIZ] *= (Slimit
* Swi) / T1;
else
noizDens[BSIM3V2FLNOIZ] *= 0.0;
}
break;
}
lnNdens[BSIM3V2FLNOIZ] =
log(MAX(noizDens[BSIM3V2FLNOIZ], N_MINLOG));
noizDens[BSIM3V2TOTNOIZ] = noizDens[BSIM3V2RDNOIZ]
+ noizDens[BSIM3V2RSNOIZ]
+ noizDens[BSIM3V2IDNOIZ]
+ noizDens[BSIM3V2FLNOIZ];
lnNdens[BSIM3V2TOTNOIZ] =
log(MAX(noizDens[BSIM3V2TOTNOIZ], N_MINLOG));
*OnDens += noizDens[BSIM3V2TOTNOIZ];
if (data->delFreq == 0.0)
{ /* if we haven't done any previous
integration, we need to initialize our
"history" variables.
*/
for (i = 0; i < BSIM3V2NSRCS; i++)
{ here->BSIM3V2nVar[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 < BSIM3V2NSRCS; i++)
{ here->BSIM3V2nVar[OUTNOIZ][i] = 0.0;
here->BSIM3V2nVar[INNOIZ][i] = 0.0;
}
}
}
else
{ /* data->delFreq != 0.0,
we have to integrate.
*/
for (i = 0; i < BSIM3V2NSRCS; i++)
{ if (i != BSIM3V2TOTNOIZ)
{ tempOnoise = Nintegrate(noizDens[i],
lnNdens[i],
here->BSIM3V2nVar[LNLSTDENS][i],
data);
tempInoise = Nintegrate(noizDens[i]
* data->GainSqInv, lnNdens[i]
+ data->lnGainInv,
here->BSIM3V2nVar[LNLSTDENS][i]
+ data->lnGainInv, data);
here->BSIM3V2nVar[LNLSTDENS][i] =
lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if (((NOISEAN*)
ckt->CKTcurJob)->NStpsSm != 0)
{ here->BSIM3V2nVar[OUTNOIZ][i]
+= tempOnoise;
here->BSIM3V2nVar[OUTNOIZ][BSIM3V2TOTNOIZ]
+= tempOnoise;
here->BSIM3V2nVar[INNOIZ][i]
+= tempInoise;
here->BSIM3V2nVar[INNOIZ][BSIM3V2TOTNOIZ]
+= tempInoise;
}
}
}
}
if (data->prtSummary)
{ for (i = 0; i < BSIM3V2NSRCS; 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 < BSIM3V2NSRCS; i++)
{ data->outpVector[data->outNumber++]
= here->BSIM3V2nVar[OUTNOIZ][i];
data->outpVector[data->outNumber++]
= here->BSIM3V2nVar[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);
}

97
src/spicelib/devices/bsim3v2/b3v2par.c
View File

@ -1,97 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
File: b3v2par.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include "ifsim.h"
#include "bsim3v2def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3V2param(param,value,inst,select)
int param;
IFvalue *value;
GENinstance *inst;
IFvalue *select;
{
BSIM3V2instance *here = (BSIM3V2instance*)inst;
switch(param)
{ case BSIM3V2_W:
here->BSIM3V2w = value->rValue;
here->BSIM3V2wGiven = TRUE;
break;
case BSIM3V2_L:
here->BSIM3V2l = value->rValue;
here->BSIM3V2lGiven = TRUE;
break;
case BSIM3V2_AS:
here->BSIM3V2sourceArea = value->rValue;
here->BSIM3V2sourceAreaGiven = TRUE;
break;
case BSIM3V2_AD:
here->BSIM3V2drainArea = value->rValue;
here->BSIM3V2drainAreaGiven = TRUE;
break;
case BSIM3V2_PS:
here->BSIM3V2sourcePerimeter = value->rValue;
here->BSIM3V2sourcePerimeterGiven = TRUE;
break;
case BSIM3V2_PD:
here->BSIM3V2drainPerimeter = value->rValue;
here->BSIM3V2drainPerimeterGiven = TRUE;
break;
case BSIM3V2_NRS:
here->BSIM3V2sourceSquares = value->rValue;
here->BSIM3V2sourceSquaresGiven = TRUE;
break;
case BSIM3V2_NRD:
here->BSIM3V2drainSquares = value->rValue;
here->BSIM3V2drainSquaresGiven = TRUE;
break;
case BSIM3V2_OFF:
here->BSIM3V2off = value->iValue;
break;
case BSIM3V2_IC_VBS:
here->BSIM3V2icVBS = value->rValue;
here->BSIM3V2icVBSGiven = TRUE;
break;
case BSIM3V2_IC_VDS:
here->BSIM3V2icVDS = value->rValue;
here->BSIM3V2icVDSGiven = TRUE;
break;
case BSIM3V2_IC_VGS:
here->BSIM3V2icVGS = value->rValue;
here->BSIM3V2icVGSGiven = TRUE;
break;
case BSIM3V2_NQSMOD:
here->BSIM3V2nqsMod = value->iValue;
here->BSIM3V2nqsModGiven = TRUE;
break;
case BSIM3V2_IC:
switch(value->v.numValue){
case 3:
here->BSIM3V2icVBS = *(value->v.vec.rVec+2);
here->BSIM3V2icVBSGiven = TRUE;
case 2:
here->BSIM3V2icVGS = *(value->v.vec.rVec+1);
here->BSIM3V2icVGSGiven = TRUE;
case 1:
here->BSIM3V2icVDS = *(value->v.vec.rVec);
here->BSIM3V2icVDSGiven = TRUE;
break;
default:
return(E_BADPARM);
}
break;
default:
return(E_BADPARM);
}
return(OK);
}

366
src/spicelib/devices/bsim3v2/b3v2pzld.c
View File

@ -1,366 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Weidong Liu (1997-1998).
File: b3v2pzld.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "complex.h"
#include "sperror.h"
#include "bsim3v2def.h"
#include "suffix.h"
int
BSIM3V2pzLoad(inModel,ckt,s)
GENmodel *inModel;
CKTcircuit *ckt;
SPcomplex *s;
{
BSIM3V2model *model = (BSIM3V2model*)inModel;
BSIM3V2instance *here;
double xcggb, xcgdb, xcgsb, xcgbb, xcbgb, xcbdb, xcbsb, xcbbb;
double xcdgb, xcddb, xcdsb, xcdbb, xcsgb, xcsdb, xcssb, xcsbb;
double gdpr, gspr, gds, gbd, gbs, capbd, capbs, FwdSum, RevSum, Gm, Gmbs;
double cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cddb, cdgb, cdsb;
double GSoverlapCap, GDoverlapCap, GBoverlapCap;
double dxpart, sxpart, xgtg, xgtd, xgts, xgtb, xcqgb, xcqdb, xcqsb, xcqbb;
double gbspsp, gbbdp, gbbsp, gbspg, gbspb;
double gbspdp, gbdpdp, gbdpg, gbdpb, gbdpsp;
double ddxpart_dVd, ddxpart_dVg, ddxpart_dVb, ddxpart_dVs;
double dsxpart_dVd, dsxpart_dVg, dsxpart_dVb, dsxpart_dVs;
double T1, CoxWL, qcheq, Cdg, Cdd, Cds, Cdb, Csg, Csd, Css, Csb;
for (; model != NULL; model = model->BSIM3V2nextModel)
{ for (here = model->BSIM3V2instances; here!= NULL;
here = here->BSIM3V2nextInstance)
{
if (here->BSIM3V2owner != ARCHme) continue;
if (here->BSIM3V2mode >= 0)
{ Gm = here->BSIM3V2gm;
Gmbs = here->BSIM3V2gmbs;
FwdSum = Gm + Gmbs;
RevSum = 0.0;
gbbdp = -here->BSIM3V2gbds;
gbbsp = here->BSIM3V2gbds + here->BSIM3V2gbgs + here->BSIM3V2gbbs;
gbdpg = here->BSIM3V2gbgs;
gbdpdp = here->BSIM3V2gbds;
gbdpb = here->BSIM3V2gbbs;
gbdpsp = -(gbdpg + gbdpdp + gbdpb);
gbspg = 0.0;
gbspdp = 0.0;
gbspb = 0.0;
gbspsp = 0.0;
if (here->BSIM3V2nqsMod == 0)
{ cggb = here->BSIM3V2cggb;
cgsb = here->BSIM3V2cgsb;
cgdb = here->BSIM3V2cgdb;
cbgb = here->BSIM3V2cbgb;
cbsb = here->BSIM3V2cbsb;
cbdb = here->BSIM3V2cbdb;
cdgb = here->BSIM3V2cdgb;
cdsb = here->BSIM3V2cdsb;
cddb = here->BSIM3V2cddb;
xgtg = xgtd = xgts = xgtb = 0.0;
sxpart = 0.6;
dxpart = 0.4;
ddxpart_dVd = ddxpart_dVg = ddxpart_dVb
= ddxpart_dVs = 0.0;
dsxpart_dVd = dsxpart_dVg = dsxpart_dVb
= dsxpart_dVs = 0.0;
}
else
{ cggb = cgdb = cgsb = 0.0;
cbgb = cbdb = cbsb = 0.0;
cdgb = cddb = cdsb = 0.0;
xgtg = here->BSIM3V2gtg;
xgtd = here->BSIM3V2gtd;
xgts = here->BSIM3V2gts;
xgtb = here->BSIM3V2gtb;
xcqgb = here->BSIM3V2cqgb;
xcqdb = here->BSIM3V2cqdb;
xcqsb = here->BSIM3V2cqsb;
xcqbb = here->BSIM3V2cqbb;
CoxWL = model->BSIM3V2cox * here->pParam->BSIM3V2weffCV
* here->pParam->BSIM3V2leffCV;
qcheq = -(here->BSIM3V2qgate + here->BSIM3V2qbulk);
if (fabs(qcheq) <= 1.0e-5 * CoxWL)
{ if (model->BSIM3V2xpart < 0.5)
{ dxpart = 0.4;
}
else if (model->BSIM3V2xpart > 0.5)
{ dxpart = 0.0;
}
else
{ dxpart = 0.5;
}
ddxpart_dVd = ddxpart_dVg = ddxpart_dVb
= ddxpart_dVs = 0.0;
}
else
{ dxpart = here->BSIM3V2qdrn / qcheq;
Cdd = here->BSIM3V2cddb;
Csd = -(here->BSIM3V2cgdb + here->BSIM3V2cddb
+ here->BSIM3V2cbdb);
ddxpart_dVd = (Cdd - dxpart * (Cdd + Csd)) / qcheq;
Cdg = here->BSIM3V2cdgb;
Csg = -(here->BSIM3V2cggb + here->BSIM3V2cdgb
+ here->BSIM3V2cbgb);
ddxpart_dVg = (Cdg - dxpart * (Cdg + Csg)) / qcheq;
Cds = here->BSIM3V2cdsb;
Css = -(here->BSIM3V2cgsb + here->BSIM3V2cdsb
+ here->BSIM3V2cbsb);
ddxpart_dVs = (Cds - dxpart * (Cds + Css)) / qcheq;
ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg
+ ddxpart_dVs);
}
sxpart = 1.0 - dxpart;
dsxpart_dVd = -ddxpart_dVd;
dsxpart_dVg = -ddxpart_dVg;
dsxpart_dVs = -ddxpart_dVs;
dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg + dsxpart_dVs);
}
}
else
{ Gm = -here->BSIM3V2gm;
Gmbs = -here->BSIM3V2gmbs;
FwdSum = 0.0;
RevSum = -(Gm + Gmbs);
gbbsp = -here->BSIM3V2gbds;
gbbdp = here->BSIM3V2gbds + here->BSIM3V2gbgs + here->BSIM3V2gbbs;
gbdpg = 0.0;
gbdpsp = 0.0;
gbdpb = 0.0;
gbdpdp = 0.0;
gbspg = here->BSIM3V2gbgs;
gbspsp = here->BSIM3V2gbds;
gbspb = here->BSIM3V2gbbs;
gbspdp = -(gbspg + gbspsp + gbspb);
if (here->BSIM3V2nqsMod == 0)
{ cggb = here->BSIM3V2cggb;
cgsb = here->BSIM3V2cgdb;
cgdb = here->BSIM3V2cgsb;
cbgb = here->BSIM3V2cbgb;
cbsb = here->BSIM3V2cbdb;
cbdb = here->BSIM3V2cbsb;
cdgb = -(here->BSIM3V2cdgb + cggb + cbgb);
cdsb = -(here->BSIM3V2cddb + cgsb + cbsb);
cddb = -(here->BSIM3V2cdsb + cgdb + cbdb);
xgtg = xgtd = xgts = xgtb = 0.0;
sxpart = 0.4;
dxpart = 0.6;
ddxpart_dVd = ddxpart_dVg = ddxpart_dVb
= ddxpart_dVs = 0.0;
dsxpart_dVd = dsxpart_dVg = dsxpart_dVb
= dsxpart_dVs = 0.0;
}
else
{ cggb = cgdb = cgsb = 0.0;
cbgb = cbdb = cbsb = 0.0;
cdgb = cddb = cdsb = 0.0;
xgtg = here->BSIM3V2gtg;
xgtd = here->BSIM3V2gts;
xgts = here->BSIM3V2gtd;
xgtb = here->BSIM3V2gtb;
xcqgb = here->BSIM3V2cqgb;
xcqdb = here->BSIM3V2cqsb;
xcqsb = here->BSIM3V2cqdb;
xcqbb = here->BSIM3V2cqbb;
CoxWL = model->BSIM3V2cox * here->pParam->BSIM3V2weffCV
* here->pParam->BSIM3V2leffCV;
qcheq = -(here->BSIM3V2qgate + here->BSIM3V2qbulk);
if (fabs(qcheq) <= 1.0e-5 * CoxWL)
{ if (model->BSIM3V2xpart < 0.5)
{ sxpart = 0.4;
}
else if (model->BSIM3V2xpart > 0.5)
{ sxpart = 0.0;
}
else
{ sxpart = 0.5;
}
dsxpart_dVd = dsxpart_dVg = dsxpart_dVb
= dsxpart_dVs = 0.0;
}
else
{ sxpart = here->BSIM3V2qdrn / qcheq;
Css = here->BSIM3V2cddb;
Cds = -(here->BSIM3V2cgdb + here->BSIM3V2cddb
+ here->BSIM3V2cbdb);
dsxpart_dVs = (Css - sxpart * (Css + Cds)) / qcheq;
Csg = here->BSIM3V2cdgb;
Cdg = -(here->BSIM3V2cggb + here->BSIM3V2cdgb
+ here->BSIM3V2cbgb);
dsxpart_dVg = (Csg - sxpart * (Csg + Cdg)) / qcheq;
Csd = here->BSIM3V2cdsb;
Cdd = -(here->BSIM3V2cgsb + here->BSIM3V2cdsb
+ here->BSIM3V2cbsb);
dsxpart_dVd = (Csd - sxpart * (Csd + Cdd)) / qcheq;
dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg
+ dsxpart_dVs);
}
dxpart = 1.0 - sxpart;
ddxpart_dVd = -dsxpart_dVd;
ddxpart_dVg = -dsxpart_dVg;
ddxpart_dVs = -dsxpart_dVs;
ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs);
}
}
T1 = *(ckt->CKTstate0 + here->BSIM3V2qdef) * here->BSIM3V2gtau;
gdpr = here->BSIM3V2drainConductance;
gspr = here->BSIM3V2sourceConductance;
gds = here->BSIM3V2gds;
gbd = here->BSIM3V2gbd;
gbs = here->BSIM3V2gbs;
capbd = here->BSIM3V2capbd;
capbs = here->BSIM3V2capbs;
GSoverlapCap = here->BSIM3V2cgso;
GDoverlapCap = here->BSIM3V2cgdo;
GBoverlapCap = here->pParam->BSIM3V2cgbo;
xcdgb = (cdgb - GDoverlapCap);
xcddb = (cddb + capbd + GDoverlapCap);
xcdsb = cdsb;
xcdbb = -(xcdgb + xcddb + xcdsb);
xcsgb = -(cggb + cbgb + cdgb + GSoverlapCap);
xcsdb = -(cgdb + cbdb + cddb);
xcssb = (capbs + GSoverlapCap - (cgsb + cbsb + cdsb));
xcsbb = -(xcsgb + xcsdb + xcssb);
xcggb = (cggb + GDoverlapCap + GSoverlapCap + GBoverlapCap);
xcgdb = (cgdb - GDoverlapCap);
xcgsb = (cgsb - GSoverlapCap);
xcgbb = -(xcggb + xcgdb + xcgsb);
xcbgb = (cbgb - GBoverlapCap);
xcbdb = (cbdb - capbd);
xcbsb = (cbsb - capbs);
xcbbb = -(xcbgb + xcbdb + xcbsb);
*(here->BSIM3V2GgPtr ) += xcggb * s->real;
*(here->BSIM3V2GgPtr +1) += xcggb * s->imag;
*(here->BSIM3V2BbPtr ) += xcbbb * s->real;
*(here->BSIM3V2BbPtr +1) += xcbbb * s->imag;
*(here->BSIM3V2DPdpPtr ) += xcddb * s->real;
*(here->BSIM3V2DPdpPtr +1) += xcddb * s->imag;
*(here->BSIM3V2SPspPtr ) += xcssb * s->real;
*(here->BSIM3V2SPspPtr +1) += xcssb * s->imag;
*(here->BSIM3V2GbPtr ) += xcgbb * s->real;
*(here->BSIM3V2GbPtr +1) += xcgbb * s->imag;
*(here->BSIM3V2GdpPtr ) += xcgdb * s->real;
*(here->BSIM3V2GdpPtr +1) += xcgdb * s->imag;
*(here->BSIM3V2GspPtr ) += xcgsb * s->real;
*(here->BSIM3V2GspPtr +1) += xcgsb * s->imag;
*(here->BSIM3V2BgPtr ) += xcbgb * s->real;
*(here->BSIM3V2BgPtr +1) += xcbgb * s->imag;
*(here->BSIM3V2BdpPtr ) += xcbdb * s->real;
*(here->BSIM3V2BdpPtr +1) += xcbdb * s->imag;
*(here->BSIM3V2BspPtr ) += xcbsb * s->real;
*(here->BSIM3V2BspPtr +1) += xcbsb * s->imag;
*(here->BSIM3V2DPgPtr ) += xcdgb * s->real;
*(here->BSIM3V2DPgPtr +1) += xcdgb * s->imag;
*(here->BSIM3V2DPbPtr ) += xcdbb * s->real;
*(here->BSIM3V2DPbPtr +1) += xcdbb * s->imag;
*(here->BSIM3V2DPspPtr ) += xcdsb * s->real;
*(here->BSIM3V2DPspPtr +1) += xcdsb * s->imag;
*(here->BSIM3V2SPgPtr ) += xcsgb * s->real;
*(here->BSIM3V2SPgPtr +1) += xcsgb * s->imag;
*(here->BSIM3V2SPbPtr ) += xcsbb * s->real;
*(here->BSIM3V2SPbPtr +1) += xcsbb * s->imag;
*(here->BSIM3V2SPdpPtr ) += xcsdb * s->real;
*(here->BSIM3V2SPdpPtr +1) += xcsdb * s->imag;
*(here->BSIM3V2DdPtr) += gdpr;
*(here->BSIM3V2DdpPtr) -= gdpr;
*(here->BSIM3V2DPdPtr) -= gdpr;
*(here->BSIM3V2SsPtr) += gspr;
*(here->BSIM3V2SspPtr) -= gspr;
*(here->BSIM3V2SPsPtr) -= gspr;
*(here->BSIM3V2BgPtr) -= here->BSIM3V2gbgs;
*(here->BSIM3V2BbPtr) += gbd + gbs - here->BSIM3V2gbbs;
*(here->BSIM3V2BdpPtr) -= gbd - gbbdp;
*(here->BSIM3V2BspPtr) -= gbs - gbbsp;
*(here->BSIM3V2DPgPtr) += Gm + dxpart * xgtg
+ T1 * ddxpart_dVg + gbdpg;
*(here->BSIM3V2DPdpPtr) += gdpr + gds + gbd + RevSum
+ dxpart * xgtd + T1 * ddxpart_dVd + gbdpdp;
*(here->BSIM3V2DPspPtr) -= gds + FwdSum - dxpart * xgts
- T1 * ddxpart_dVs - gbdpsp;
*(here->BSIM3V2DPbPtr) -= gbd - Gmbs - dxpart * xgtb
- T1 * ddxpart_dVb - gbdpb;
*(here->BSIM3V2SPgPtr) -= Gm - sxpart * xgtg
- T1 * dsxpart_dVg - gbspg;
*(here->BSIM3V2SPspPtr) += gspr + gds + gbs + FwdSum
+ sxpart * xgts + T1 * dsxpart_dVs + gbspsp;
*(here->BSIM3V2SPbPtr) -= gbs + Gmbs - sxpart * xgtb
- T1 * dsxpart_dVb - gbspb;
*(here->BSIM3V2SPdpPtr) -= gds + RevSum - sxpart * xgtd
- T1 * dsxpart_dVd - gbspdp;
*(here->BSIM3V2GgPtr) -= xgtg;
*(here->BSIM3V2GbPtr) -= xgtb;
*(here->BSIM3V2GdpPtr) -= xgtd;
*(here->BSIM3V2GspPtr) -= xgts;
if (here->BSIM3V2nqsMod)
{ *(here->BSIM3V2QqPtr ) += s->real;
*(here->BSIM3V2QqPtr +1) += s->imag;
*(here->BSIM3V2QgPtr ) -= xcqgb * s->real;
*(here->BSIM3V2QgPtr +1) -= xcqgb * s->imag;
*(here->BSIM3V2QdpPtr ) -= xcqdb * s->real;
*(here->BSIM3V2QdpPtr +1) -= xcqdb * s->imag;
*(here->BSIM3V2QbPtr ) -= xcqbb * s->real;
*(here->BSIM3V2QbPtr +1) -= xcqbb * s->imag;
*(here->BSIM3V2QspPtr ) -= xcqsb * s->real;
*(here->BSIM3V2QspPtr +1) -= xcqsb * s->imag;
*(here->BSIM3V2GqPtr) -= here->BSIM3V2gtau;
*(here->BSIM3V2DPqPtr) += dxpart * here->BSIM3V2gtau;
*(here->BSIM3V2SPqPtr) += sxpart * here->BSIM3V2gtau;
*(here->BSIM3V2QqPtr) += here->BSIM3V2gtau;
*(here->BSIM3V2QgPtr) += xgtg;
*(here->BSIM3V2QdpPtr) += xgtd;
*(here->BSIM3V2QbPtr) += xgtb;
*(here->BSIM3V2QspPtr) += xgts;
}
}
}
return(OK);
}

995
src/spicelib/devices/bsim3v2/b3v2set.c
View File

@ -1,995 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Weidong Liu (1997-1998).
File: b3v2set.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "smpdefs.h"
#include "cktdefs.h"
#include "bsim3v2def.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
BSIM3V2setup(matrix,inModel,ckt,states)
SMPmatrix *matrix;
GENmodel *inModel;
CKTcircuit *ckt;
int *states;
{
BSIM3V2model *model = (BSIM3V2model*)inModel;
BSIM3V2instance *here;
int error;
CKTnode *tmp;
double tmp1, tmp2;
/* loop through all the BSIM3V2 device models */
for( ; model != NULL; model = model->BSIM3V2nextModel )
{
/* Default value Processing for BSIM3V2 MOSFET Models */
if (!model->BSIM3V2typeGiven)
model->BSIM3V2type = NMOS;
if (!model->BSIM3V2mobModGiven)
model->BSIM3V2mobMod = 1;
if (!model->BSIM3V2binUnitGiven)
model->BSIM3V2binUnit = 1;
if (!model->BSIM3V2paramChkGiven)
model->BSIM3V2paramChk = 0;
if (!model->BSIM3V2capModGiven)
model->BSIM3V2capMod = 3;
if (!model->BSIM3V2noiModGiven)
model->BSIM3V2noiMod = 1;
if (!model->BSIM3V2versionGiven)
model->BSIM3V2version = 3.2;
if (!model->BSIM3V2toxGiven)
model->BSIM3V2tox = 150.0e-10;
model->BSIM3V2cox = 3.453133e-11 / model->BSIM3V2tox;
if (!model->BSIM3V2toxmGiven)
model->BSIM3V2toxm = model->BSIM3V2tox;
if (!model->BSIM3V2cdscGiven)
model->BSIM3V2cdsc = 2.4e-4; /* unit Q/V/m^2 */
if (!model->BSIM3V2cdscbGiven)
model->BSIM3V2cdscb = 0.0; /* unit Q/V/m^2 */
if (!model->BSIM3V2cdscdGiven)
model->BSIM3V2cdscd = 0.0; /* unit Q/V/m^2 */
if (!model->BSIM3V2citGiven)
model->BSIM3V2cit = 0.0; /* unit Q/V/m^2 */
if (!model->BSIM3V2nfactorGiven)
model->BSIM3V2nfactor = 1;
if (!model->BSIM3V2xjGiven)
model->BSIM3V2xj = .15e-6;
if (!model->BSIM3V2vsatGiven)
model->BSIM3V2vsat = 8.0e4; /* unit m/s */
if (!model->BSIM3V2atGiven)
model->BSIM3V2at = 3.3e4; /* unit m/s */
if (!model->BSIM3V2a0Given)
model->BSIM3V2a0 = 1.0;
if (!model->BSIM3V2agsGiven)
model->BSIM3V2ags = 0.0;
if (!model->BSIM3V2a1Given)
model->BSIM3V2a1 = 0.0;
if (!model->BSIM3V2a2Given)
model->BSIM3V2a2 = 1.0;
if (!model->BSIM3V2ketaGiven)
model->BSIM3V2keta = -0.047; /* unit / V */
if (!model->BSIM3V2nsubGiven)
model->BSIM3V2nsub = 6.0e16; /* unit 1/cm3 */
if (!model->BSIM3V2npeakGiven)
model->BSIM3V2npeak = 1.7e17; /* unit 1/cm3 */
if (!model->BSIM3V2ngateGiven)
model->BSIM3V2ngate = 0; /* unit 1/cm3 */
if (!model->BSIM3V2vbmGiven)
model->BSIM3V2vbm = -3.0;
if (!model->BSIM3V2xtGiven)
model->BSIM3V2xt = 1.55e-7;
if (!model->BSIM3V2kt1Given)
model->BSIM3V2kt1 = -0.11; /* unit V */
if (!model->BSIM3V2kt1lGiven)
model->BSIM3V2kt1l = 0.0; /* unit V*m */
if (!model->BSIM3V2kt2Given)
model->BSIM3V2kt2 = 0.022; /* No unit */
if (!model->BSIM3V2k3Given)
model->BSIM3V2k3 = 80.0;
if (!model->BSIM3V2k3bGiven)
model->BSIM3V2k3b = 0.0;
if (!model->BSIM3V2w0Given)
model->BSIM3V2w0 = 2.5e-6;
if (!model->BSIM3V2nlxGiven)
model->BSIM3V2nlx = 1.74e-7;
if (!model->BSIM3V2dvt0Given)
model->BSIM3V2dvt0 = 2.2;
if (!model->BSIM3V2dvt1Given)
model->BSIM3V2dvt1 = 0.53;
if (!model->BSIM3V2dvt2Given)
model->BSIM3V2dvt2 = -0.032; /* unit 1 / V */
if (!model->BSIM3V2dvt0wGiven)
model->BSIM3V2dvt0w = 0.0;
if (!model->BSIM3V2dvt1wGiven)
model->BSIM3V2dvt1w = 5.3e6;
if (!model->BSIM3V2dvt2wGiven)
model->BSIM3V2dvt2w = -0.032;
if (!model->BSIM3V2droutGiven)
model->BSIM3V2drout = 0.56;
if (!model->BSIM3V2dsubGiven)
model->BSIM3V2dsub = model->BSIM3V2drout;
if (!model->BSIM3V2vth0Given)
model->BSIM3V2vth0 = (model->BSIM3V2type == NMOS) ? 0.7 : -0.7;
if (!model->BSIM3V2uaGiven)
model->BSIM3V2ua = 2.25e-9; /* unit m/V */
if (!model->BSIM3V2ua1Given)
model->BSIM3V2ua1 = 4.31e-9; /* unit m/V */
if (!model->BSIM3V2ubGiven)
model->BSIM3V2ub = 5.87e-19; /* unit (m/V)**2 */
if (!model->BSIM3V2ub1Given)
model->BSIM3V2ub1 = -7.61e-18; /* unit (m/V)**2 */
if (!model->BSIM3V2ucGiven)
model->BSIM3V2uc = (model->BSIM3V2mobMod == 3) ? -0.0465 : -0.0465e-9;
if (!model->BSIM3V2uc1Given)
model->BSIM3V2uc1 = (model->BSIM3V2mobMod == 3) ? -0.056 : -0.056e-9;
if (!model->BSIM3V2u0Given)
model->BSIM3V2u0 = (model->BSIM3V2type == NMOS) ? 0.067 : 0.025;
if (!model->BSIM3V2uteGiven)
model->BSIM3V2ute = -1.5;
if (!model->BSIM3V2voffGiven)
model->BSIM3V2voff = -0.08;
if (!model->BSIM3V2deltaGiven)
model->BSIM3V2delta = 0.01;
if (!model->BSIM3V2rdswGiven)
model->BSIM3V2rdsw = 0;
if (!model->BSIM3V2prwgGiven)
model->BSIM3V2prwg = 0.0; /* unit 1/V */
if (!model->BSIM3V2prwbGiven)
model->BSIM3V2prwb = 0.0;
if (!model->BSIM3V2prtGiven)
if (!model->BSIM3V2prtGiven)
model->BSIM3V2prt = 0.0;
if (!model->BSIM3V2eta0Given)
model->BSIM3V2eta0 = 0.08; /* no unit */
if (!model->BSIM3V2etabGiven)
model->BSIM3V2etab = -0.07; /* unit 1/V */
if (!model->BSIM3V2pclmGiven)
model->BSIM3V2pclm = 1.3; /* no unit */
if (!model->BSIM3V2pdibl1Given)
model->BSIM3V2pdibl1 = .39; /* no unit */
if (!model->BSIM3V2pdibl2Given)
model->BSIM3V2pdibl2 = 0.0086; /* no unit */
if (!model->BSIM3V2pdiblbGiven)
model->BSIM3V2pdiblb = 0.0; /* 1/V */
if (!model->BSIM3V2pscbe1Given)
model->BSIM3V2pscbe1 = 4.24e8;
if (!model->BSIM3V2pscbe2Given)
model->BSIM3V2pscbe2 = 1.0e-5;
if (!model->BSIM3V2pvagGiven)
model->BSIM3V2pvag = 0.0;
if (!model->BSIM3V2wrGiven)
model->BSIM3V2wr = 1.0;
if (!model->BSIM3V2dwgGiven)
model->BSIM3V2dwg = 0.0;
if (!model->BSIM3V2dwbGiven)
model->BSIM3V2dwb = 0.0;
if (!model->BSIM3V2b0Given)
model->BSIM3V2b0 = 0.0;
if (!model->BSIM3V2b1Given)
model->BSIM3V2b1 = 0.0;
if (!model->BSIM3V2alpha0Given)
model->BSIM3V2alpha0 = 0.0;
if (!model->BSIM3V2alpha1Given)
model->BSIM3V2alpha1 = 0.0;
if (!model->BSIM3V2beta0Given)
model->BSIM3V2beta0 = 30.0;
if (!model->BSIM3V2ijthGiven)
model->BSIM3V2ijth = 0.1; /* unit A */
if (!model->BSIM3V2elmGiven)
model->BSIM3V2elm = 5.0;
if (!model->BSIM3V2cgslGiven)
model->BSIM3V2cgsl = 0.0;
if (!model->BSIM3V2cgdlGiven)
model->BSIM3V2cgdl = 0.0;
if (!model->BSIM3V2ckappaGiven)
model->BSIM3V2ckappa = 0.6;
if (!model->BSIM3V2clcGiven)
model->BSIM3V2clc = 0.1e-6;
if (!model->BSIM3V2cleGiven)
model->BSIM3V2cle = 0.6;
if (!model->BSIM3V2vfbcvGiven)
model->BSIM3V2vfbcv = -1.0;
if (!model->BSIM3V2acdeGiven)
model->BSIM3V2acde = 1.0;
if (!model->BSIM3V2moinGiven)
model->BSIM3V2moin = 15.0;
if (!model->BSIM3V2noffGiven)
model->BSIM3V2noff = 1.0;
if (!model->BSIM3V2voffcvGiven)
model->BSIM3V2voffcv = 0.0;
if (!model->BSIM3V2tcjGiven)
model->BSIM3V2tcj = 0.0;
if (!model->BSIM3V2tpbGiven)
model->BSIM3V2tpb = 0.0;
if (!model->BSIM3V2tcjswGiven)
model->BSIM3V2tcjsw = 0.0;
if (!model->BSIM3V2tpbswGiven)
model->BSIM3V2tpbsw = 0.0;
if (!model->BSIM3V2tcjswgGiven)
model->BSIM3V2tcjswg = 0.0;
if (!model->BSIM3V2tpbswgGiven)
model->BSIM3V2tpbswg = 0.0;
/* Length dependence */
if (!model->BSIM3V2lcdscGiven)
model->BSIM3V2lcdsc = 0.0;
if (!model->BSIM3V2lcdscbGiven)
model->BSIM3V2lcdscb = 0.0;
if (!model->BSIM3V2lcdscdGiven)
model->BSIM3V2lcdscd = 0.0;
if (!model->BSIM3V2lcitGiven)
model->BSIM3V2lcit = 0.0;
if (!model->BSIM3V2lnfactorGiven)
model->BSIM3V2lnfactor = 0.0;
if (!model->BSIM3V2lxjGiven)
model->BSIM3V2lxj = 0.0;
if (!model->BSIM3V2lvsatGiven)
model->BSIM3V2lvsat = 0.0;
if (!model->BSIM3V2latGiven)
model->BSIM3V2lat = 0.0;
if (!model->BSIM3V2la0Given)
model->BSIM3V2la0 = 0.0;
if (!model->BSIM3V2lagsGiven)
model->BSIM3V2lags = 0.0;
if (!model->BSIM3V2la1Given)
model->BSIM3V2la1 = 0.0;
if (!model->BSIM3V2la2Given)
model->BSIM3V2la2 = 0.0;
if (!model->BSIM3V2lketaGiven)
model->BSIM3V2lketa = 0.0;
if (!model->BSIM3V2lnsubGiven)
model->BSIM3V2lnsub = 0.0;
if (!model->BSIM3V2lnpeakGiven)
model->BSIM3V2lnpeak = 0.0;
if (!model->BSIM3V2lngateGiven)
model->BSIM3V2lngate = 0.0;
if (!model->BSIM3V2lvbmGiven)
model->BSIM3V2lvbm = 0.0;
if (!model->BSIM3V2lxtGiven)
model->BSIM3V2lxt = 0.0;
if (!model->BSIM3V2lkt1Given)
model->BSIM3V2lkt1 = 0.0;
if (!model->BSIM3V2lkt1lGiven)
model->BSIM3V2lkt1l = 0.0;
if (!model->BSIM3V2lkt2Given)
model->BSIM3V2lkt2 = 0.0;
if (!model->BSIM3V2lk3Given)
model->BSIM3V2lk3 = 0.0;
if (!model->BSIM3V2lk3bGiven)
model->BSIM3V2lk3b = 0.0;
if (!model->BSIM3V2lw0Given)
model->BSIM3V2lw0 = 0.0;
if (!model->BSIM3V2lnlxGiven)
model->BSIM3V2lnlx = 0.0;
if (!model->BSIM3V2ldvt0Given)
model->BSIM3V2ldvt0 = 0.0;
if (!model->BSIM3V2ldvt1Given)
model->BSIM3V2ldvt1 = 0.0;
if (!model->BSIM3V2ldvt2Given)
model->BSIM3V2ldvt2 = 0.0;
if (!model->BSIM3V2ldvt0wGiven)
model->BSIM3V2ldvt0w = 0.0;
if (!model->BSIM3V2ldvt1wGiven)
model->BSIM3V2ldvt1w = 0.0;
if (!model->BSIM3V2ldvt2wGiven)
model->BSIM3V2ldvt2w = 0.0;
if (!model->BSIM3V2ldroutGiven)
model->BSIM3V2ldrout = 0.0;
if (!model->BSIM3V2ldsubGiven)
model->BSIM3V2ldsub = 0.0;
if (!model->BSIM3V2lvth0Given)
model->BSIM3V2lvth0 = 0.0;
if (!model->BSIM3V2luaGiven)
model->BSIM3V2lua = 0.0;
if (!model->BSIM3V2lua1Given)
model->BSIM3V2lua1 = 0.0;
if (!model->BSIM3V2lubGiven)
model->BSIM3V2lub = 0.0;
if (!model->BSIM3V2lub1Given)
model->BSIM3V2lub1 = 0.0;
if (!model->BSIM3V2lucGiven)
model->BSIM3V2luc = 0.0;
if (!model->BSIM3V2luc1Given)
model->BSIM3V2luc1 = 0.0;
if (!model->BSIM3V2lu0Given)
model->BSIM3V2lu0 = 0.0;
if (!model->BSIM3V2luteGiven)
model->BSIM3V2lute = 0.0;
if (!model->BSIM3V2lvoffGiven)
model->BSIM3V2lvoff = 0.0;
if (!model->BSIM3V2ldeltaGiven)
model->BSIM3V2ldelta = 0.0;
if (!model->BSIM3V2lrdswGiven)
model->BSIM3V2lrdsw = 0.0;
if (!model->BSIM3V2lprwbGiven)
model->BSIM3V2lprwb = 0.0;
if (!model->BSIM3V2lprwgGiven)
model->BSIM3V2lprwg = 0.0;
if (!model->BSIM3V2lprtGiven)
model->BSIM3V2lprt = 0.0;
if (!model->BSIM3V2leta0Given)
model->BSIM3V2leta0 = 0.0;
if (!model->BSIM3V2letabGiven)
model->BSIM3V2letab = -0.0;
if (!model->BSIM3V2lpclmGiven)
model->BSIM3V2lpclm = 0.0;
if (!model->BSIM3V2lpdibl1Given)
model->BSIM3V2lpdibl1 = 0.0;
if (!model->BSIM3V2lpdibl2Given)
model->BSIM3V2lpdibl2 = 0.0;
if (!model->BSIM3V2lpdiblbGiven)
model->BSIM3V2lpdiblb = 0.0;
if (!model->BSIM3V2lpscbe1Given)
model->BSIM3V2lpscbe1 = 0.0;
if (!model->BSIM3V2lpscbe2Given)
model->BSIM3V2lpscbe2 = 0.0;
if (!model->BSIM3V2lpvagGiven)
model->BSIM3V2lpvag = 0.0;
if (!model->BSIM3V2lwrGiven)
model->BSIM3V2lwr = 0.0;
if (!model->BSIM3V2ldwgGiven)
model->BSIM3V2ldwg = 0.0;
if (!model->BSIM3V2ldwbGiven)
model->BSIM3V2ldwb = 0.0;
if (!model->BSIM3V2lb0Given)
model->BSIM3V2lb0 = 0.0;
if (!model->BSIM3V2lb1Given)
model->BSIM3V2lb1 = 0.0;
if (!model->BSIM3V2lalpha0Given)
model->BSIM3V2lalpha0 = 0.0;
if (!model->BSIM3V2lalpha1Given)
model->BSIM3V2lalpha1 = 0.0;
if (!model->BSIM3V2lbeta0Given)
model->BSIM3V2lbeta0 = 0.0;
if (!model->BSIM3V2lvfbGiven)
model->BSIM3V2lvfb = 0.0;
if (!model->BSIM3V2lelmGiven)
model->BSIM3V2lelm = 0.0;
if (!model->BSIM3V2lcgslGiven)
model->BSIM3V2lcgsl = 0.0;
if (!model->BSIM3V2lcgdlGiven)
model->BSIM3V2lcgdl = 0.0;
if (!model->BSIM3V2lckappaGiven)
model->BSIM3V2lckappa = 0.0;
if (!model->BSIM3V2lclcGiven)
model->BSIM3V2lclc = 0.0;
if (!model->BSIM3V2lcleGiven)
model->BSIM3V2lcle = 0.0;
if (!model->BSIM3V2lcfGiven)
model->BSIM3V2lcf = 0.0;
if (!model->BSIM3V2lvfbcvGiven)
model->BSIM3V2lvfbcv = 0.0;
if (!model->BSIM3V2lacdeGiven)
model->BSIM3V2lacde = 0.0;
if (!model->BSIM3V2lmoinGiven)
model->BSIM3V2lmoin = 0.0;
if (!model->BSIM3V2lnoffGiven)
model->BSIM3V2lnoff = 0.0;
if (!model->BSIM3V2lvoffcvGiven)
model->BSIM3V2lvoffcv = 0.0;
/* Width dependence */
if (!model->BSIM3V2wcdscGiven)
model->BSIM3V2wcdsc = 0.0;
if (!model->BSIM3V2wcdscbGiven)
model->BSIM3V2wcdscb = 0.0;
if (!model->BSIM3V2wcdscdGiven)
model->BSIM3V2wcdscd = 0.0;
if (!model->BSIM3V2wcitGiven)
model->BSIM3V2wcit = 0.0;
if (!model->BSIM3V2wnfactorGiven)
model->BSIM3V2wnfactor = 0.0;
if (!model->BSIM3V2wxjGiven)
model->BSIM3V2wxj = 0.0;
if (!model->BSIM3V2wvsatGiven)
model->BSIM3V2wvsat = 0.0;
if (!model->BSIM3V2watGiven)
model->BSIM3V2wat = 0.0;
if (!model->BSIM3V2wa0Given)
model->BSIM3V2wa0 = 0.0;
if (!model->BSIM3V2wagsGiven)
model->BSIM3V2wags = 0.0;
if (!model->BSIM3V2wa1Given)
model->BSIM3V2wa1 = 0.0;
if (!model->BSIM3V2wa2Given)
model->BSIM3V2wa2 = 0.0;
if (!model->BSIM3V2wketaGiven)
model->BSIM3V2wketa = 0.0;
if (!model->BSIM3V2wnsubGiven)
model->BSIM3V2wnsub = 0.0;
if (!model->BSIM3V2wnpeakGiven)
model->BSIM3V2wnpeak = 0.0;
if (!model->BSIM3V2wngateGiven)
model->BSIM3V2wngate = 0.0;
if (!model->BSIM3V2wvbmGiven)
model->BSIM3V2wvbm = 0.0;
if (!model->BSIM3V2wxtGiven)
model->BSIM3V2wxt = 0.0;
if (!model->BSIM3V2wkt1Given)
model->BSIM3V2wkt1 = 0.0;
if (!model->BSIM3V2wkt1lGiven)
model->BSIM3V2wkt1l = 0.0;
if (!model->BSIM3V2wkt2Given)
model->BSIM3V2wkt2 = 0.0;
if (!model->BSIM3V2wk3Given)
model->BSIM3V2wk3 = 0.0;
if (!model->BSIM3V2wk3bGiven)
model->BSIM3V2wk3b = 0.0;
if (!model->BSIM3V2ww0Given)
model->BSIM3V2ww0 = 0.0;
if (!model->BSIM3V2wnlxGiven)
model->BSIM3V2wnlx = 0.0;
if (!model->BSIM3V2wdvt0Given)
model->BSIM3V2wdvt0 = 0.0;
if (!model->BSIM3V2wdvt1Given)
model->BSIM3V2wdvt1 = 0.0;
if (!model->BSIM3V2wdvt2Given)
model->BSIM3V2wdvt2 = 0.0;
if (!model->BSIM3V2wdvt0wGiven)
model->BSIM3V2wdvt0w = 0.0;
if (!model->BSIM3V2wdvt1wGiven)
model->BSIM3V2wdvt1w = 0.0;
if (!model->BSIM3V2wdvt2wGiven)
model->BSIM3V2wdvt2w = 0.0;
if (!model->BSIM3V2wdroutGiven)
model->BSIM3V2wdrout = 0.0;
if (!model->BSIM3V2wdsubGiven)
model->BSIM3V2wdsub = 0.0;
if (!model->BSIM3V2wvth0Given)
model->BSIM3V2wvth0 = 0.0;
if (!model->BSIM3V2wuaGiven)
model->BSIM3V2wua = 0.0;
if (!model->BSIM3V2wua1Given)
model->BSIM3V2wua1 = 0.0;
if (!model->BSIM3V2wubGiven)
model->BSIM3V2wub = 0.0;
if (!model->BSIM3V2wub1Given)
model->BSIM3V2wub1 = 0.0;
if (!model->BSIM3V2wucGiven)
model->BSIM3V2wuc = 0.0;
if (!model->BSIM3V2wuc1Given)
model->BSIM3V2wuc1 = 0.0;
if (!model->BSIM3V2wu0Given)
model->BSIM3V2wu0 = 0.0;
if (!model->BSIM3V2wuteGiven)
model->BSIM3V2wute = 0.0;
if (!model->BSIM3V2wvoffGiven)
model->BSIM3V2wvoff = 0.0;
if (!model->BSIM3V2wdeltaGiven)
model->BSIM3V2wdelta = 0.0;
if (!model->BSIM3V2wrdswGiven)
model->BSIM3V2wrdsw = 0.0;
if (!model->BSIM3V2wprwbGiven)
model->BSIM3V2wprwb = 0.0;
if (!model->BSIM3V2wprwgGiven)
model->BSIM3V2wprwg = 0.0;
if (!model->BSIM3V2wprtGiven)
model->BSIM3V2wprt = 0.0;
if (!model->BSIM3V2weta0Given)
model->BSIM3V2weta0 = 0.0;
if (!model->BSIM3V2wetabGiven)
model->BSIM3V2wetab = 0.0;
if (!model->BSIM3V2wpclmGiven)
model->BSIM3V2wpclm = 0.0;
if (!model->BSIM3V2wpdibl1Given)
model->BSIM3V2wpdibl1 = 0.0;
if (!model->BSIM3V2wpdibl2Given)
model->BSIM3V2wpdibl2 = 0.0;
if (!model->BSIM3V2wpdiblbGiven)
model->BSIM3V2wpdiblb = 0.0;
if (!model->BSIM3V2wpscbe1Given)
model->BSIM3V2wpscbe1 = 0.0;
if (!model->BSIM3V2wpscbe2Given)
model->BSIM3V2wpscbe2 = 0.0;
if (!model->BSIM3V2wpvagGiven)
model->BSIM3V2wpvag = 0.0;
if (!model->BSIM3V2wwrGiven)
model->BSIM3V2wwr = 0.0;
if (!model->BSIM3V2wdwgGiven)
model->BSIM3V2wdwg = 0.0;
if (!model->BSIM3V2wdwbGiven)
model->BSIM3V2wdwb = 0.0;
if (!model->BSIM3V2wb0Given)
model->BSIM3V2wb0 = 0.0;
if (!model->BSIM3V2wb1Given)
model->BSIM3V2wb1 = 0.0;
if (!model->BSIM3V2walpha0Given)
model->BSIM3V2walpha0 = 0.0;
if (!model->BSIM3V2walpha1Given)
model->BSIM3V2walpha1 = 0.0;
if (!model->BSIM3V2wbeta0Given)
model->BSIM3V2wbeta0 = 0.0;
if (!model->BSIM3V2wvfbGiven)
model->BSIM3V2wvfb = 0.0;
if (!model->BSIM3V2welmGiven)
model->BSIM3V2welm = 0.0;
if (!model->BSIM3V2wcgslGiven)
model->BSIM3V2wcgsl = 0.0;
if (!model->BSIM3V2wcgdlGiven)
model->BSIM3V2wcgdl = 0.0;
if (!model->BSIM3V2wckappaGiven)
model->BSIM3V2wckappa = 0.0;
if (!model->BSIM3V2wcfGiven)
model->BSIM3V2wcf = 0.0;
if (!model->BSIM3V2wclcGiven)
model->BSIM3V2wclc = 0.0;
if (!model->BSIM3V2wcleGiven)
model->BSIM3V2wcle = 0.0;
if (!model->BSIM3V2wvfbcvGiven)
model->BSIM3V2wvfbcv = 0.0;
if (!model->BSIM3V2wacdeGiven)
model->BSIM3V2wacde = 0.0;
if (!model->BSIM3V2wmoinGiven)
model->BSIM3V2wmoin = 0.0;
if (!model->BSIM3V2wnoffGiven)
model->BSIM3V2wnoff = 0.0;
if (!model->BSIM3V2wvoffcvGiven)
model->BSIM3V2wvoffcv = 0.0;
/* Cross-term dependence */
if (!model->BSIM3V2pcdscGiven)
model->BSIM3V2pcdsc = 0.0;
if (!model->BSIM3V2pcdscbGiven)
model->BSIM3V2pcdscb = 0.0;
if (!model->BSIM3V2pcdscdGiven)
model->BSIM3V2pcdscd = 0.0;
if (!model->BSIM3V2pcitGiven)
model->BSIM3V2pcit = 0.0;
if (!model->BSIM3V2pnfactorGiven)
model->BSIM3V2pnfactor = 0.0;
if (!model->BSIM3V2pxjGiven)
model->BSIM3V2pxj = 0.0;
if (!model->BSIM3V2pvsatGiven)
model->BSIM3V2pvsat = 0.0;
if (!model->BSIM3V2patGiven)
model->BSIM3V2pat = 0.0;
if (!model->BSIM3V2pa0Given)
model->BSIM3V2pa0 = 0.0;
if (!model->BSIM3V2pagsGiven)
model->BSIM3V2pags = 0.0;
if (!model->BSIM3V2pa1Given)
model->BSIM3V2pa1 = 0.0;
if (!model->BSIM3V2pa2Given)
model->BSIM3V2pa2 = 0.0;
if (!model->BSIM3V2pketaGiven)
model->BSIM3V2pketa = 0.0;
if (!model->BSIM3V2pnsubGiven)
model->BSIM3V2pnsub = 0.0;
if (!model->BSIM3V2pnpeakGiven)
model->BSIM3V2pnpeak = 0.0;
if (!model->BSIM3V2pngateGiven)
model->BSIM3V2pngate = 0.0;
if (!model->BSIM3V2pvbmGiven)
model->BSIM3V2pvbm = 0.0;
if (!model->BSIM3V2pxtGiven)
model->BSIM3V2pxt = 0.0;
if (!model->BSIM3V2pkt1Given)
model->BSIM3V2pkt1 = 0.0;
if (!model->BSIM3V2pkt1lGiven)
model->BSIM3V2pkt1l = 0.0;
if (!model->BSIM3V2pkt2Given)
model->BSIM3V2pkt2 = 0.0;
if (!model->BSIM3V2pk3Given)
model->BSIM3V2pk3 = 0.0;
if (!model->BSIM3V2pk3bGiven)
model->BSIM3V2pk3b = 0.0;
if (!model->BSIM3V2pw0Given)
model->BSIM3V2pw0 = 0.0;
if (!model->BSIM3V2pnlxGiven)
model->BSIM3V2pnlx = 0.0;
if (!model->BSIM3V2pdvt0Given)
model->BSIM3V2pdvt0 = 0.0;
if (!model->BSIM3V2pdvt1Given)
model->BSIM3V2pdvt1 = 0.0;
if (!model->BSIM3V2pdvt2Given)
model->BSIM3V2pdvt2 = 0.0;
if (!model->BSIM3V2pdvt0wGiven)
model->BSIM3V2pdvt0w = 0.0;
if (!model->BSIM3V2pdvt1wGiven)
model->BSIM3V2pdvt1w = 0.0;
if (!model->BSIM3V2pdvt2wGiven)
model->BSIM3V2pdvt2w = 0.0;
if (!model->BSIM3V2pdroutGiven)
model->BSIM3V2pdrout = 0.0;
if (!model->BSIM3V2pdsubGiven)
model->BSIM3V2pdsub = 0.0;
if (!model->BSIM3V2pvth0Given)
model->BSIM3V2pvth0 = 0.0;
if (!model->BSIM3V2puaGiven)
model->BSIM3V2pua = 0.0;
if (!model->BSIM3V2pua1Given)
model->BSIM3V2pua1 = 0.0;
if (!model->BSIM3V2pubGiven)
model->BSIM3V2pub = 0.0;
if (!model->BSIM3V2pub1Given)
model->BSIM3V2pub1 = 0.0;
if (!model->BSIM3V2pucGiven)
model->BSIM3V2puc = 0.0;
if (!model->BSIM3V2puc1Given)
model->BSIM3V2puc1 = 0.0;
if (!model->BSIM3V2pu0Given)
model->BSIM3V2pu0 = 0.0;
if (!model->BSIM3V2puteGiven)
model->BSIM3V2pute = 0.0;
if (!model->BSIM3V2pvoffGiven)
model->BSIM3V2pvoff = 0.0;
if (!model->BSIM3V2pdeltaGiven)
model->BSIM3V2pdelta = 0.0;
if (!model->BSIM3V2prdswGiven)
model->BSIM3V2prdsw = 0.0;
if (!model->BSIM3V2pprwbGiven)
model->BSIM3V2pprwb = 0.0;
if (!model->BSIM3V2pprwgGiven)
model->BSIM3V2pprwg = 0.0;
if (!model->BSIM3V2pprtGiven)
model->BSIM3V2pprt = 0.0;
if (!model->BSIM3V2peta0Given)
model->BSIM3V2peta0 = 0.0;
if (!model->BSIM3V2petabGiven)
model->BSIM3V2petab = 0.0;
if (!model->BSIM3V2ppclmGiven)
model->BSIM3V2ppclm = 0.0;
if (!model->BSIM3V2ppdibl1Given)
model->BSIM3V2ppdibl1 = 0.0;
if (!model->BSIM3V2ppdibl2Given)
model->BSIM3V2ppdibl2 = 0.0;
if (!model->BSIM3V2ppdiblbGiven)
model->BSIM3V2ppdiblb = 0.0;
if (!model->BSIM3V2ppscbe1Given)
model->BSIM3V2ppscbe1 = 0.0;
if (!model->BSIM3V2ppscbe2Given)
model->BSIM3V2ppscbe2 = 0.0;
if (!model->BSIM3V2ppvagGiven)
model->BSIM3V2ppvag = 0.0;
if (!model->BSIM3V2pwrGiven)
model->BSIM3V2pwr = 0.0;
if (!model->BSIM3V2pdwgGiven)
model->BSIM3V2pdwg = 0.0;
if (!model->BSIM3V2pdwbGiven)
model->BSIM3V2pdwb = 0.0;
if (!model->BSIM3V2pb0Given)
model->BSIM3V2pb0 = 0.0;
if (!model->BSIM3V2pb1Given)
model->BSIM3V2pb1 = 0.0;
if (!model->BSIM3V2palpha0Given)
model->BSIM3V2palpha0 = 0.0;
if (!model->BSIM3V2palpha1Given)
model->BSIM3V2palpha1 = 0.0;
if (!model->BSIM3V2pbeta0Given)
model->BSIM3V2pbeta0 = 0.0;
if (!model->BSIM3V2pvfbGiven)
model->BSIM3V2pvfb = 0.0;
if (!model->BSIM3V2pelmGiven)
model->BSIM3V2pelm = 0.0;
if (!model->BSIM3V2pcgslGiven)
model->BSIM3V2pcgsl = 0.0;
if (!model->BSIM3V2pcgdlGiven)
model->BSIM3V2pcgdl = 0.0;
if (!model->BSIM3V2pckappaGiven)
model->BSIM3V2pckappa = 0.0;
if (!model->BSIM3V2pcfGiven)
model->BSIM3V2pcf = 0.0;
if (!model->BSIM3V2pclcGiven)
model->BSIM3V2pclc = 0.0;
if (!model->BSIM3V2pcleGiven)
model->BSIM3V2pcle = 0.0;
if (!model->BSIM3V2pvfbcvGiven)
model->BSIM3V2pvfbcv = 0.0;
if (!model->BSIM3V2pacdeGiven)
model->BSIM3V2pacde = 0.0;
if (!model->BSIM3V2pmoinGiven)
model->BSIM3V2pmoin = 0.0;
if (!model->BSIM3V2pnoffGiven)
model->BSIM3V2pnoff = 0.0;
if (!model->BSIM3V2pvoffcvGiven)
model->BSIM3V2pvoffcv = 0.0;
/* unit degree celcius */
if (!model->BSIM3V2tnomGiven)
model->BSIM3V2tnom = ckt->CKTnomTemp;
/* else
model->BSIM3V2tnom = model->BSIM3V2tnom + 273.15; */
if (!model->BSIM3V2LintGiven)
model->BSIM3V2Lint = 0.0;
if (!model->BSIM3V2LlGiven)
model->BSIM3V2Ll = 0.0;
if (!model->BSIM3V2LlcGiven)
model->BSIM3V2Llc = model->BSIM3V2Ll;
if (!model->BSIM3V2LlnGiven)
model->BSIM3V2Lln = 1.0;
if (!model->BSIM3V2LwGiven)
model->BSIM3V2Lw = 0.0;
if (!model->BSIM3V2LwcGiven)
model->BSIM3V2Lwc = model->BSIM3V2Lw;
if (!model->BSIM3V2LwnGiven)
model->BSIM3V2Lwn = 1.0;
if (!model->BSIM3V2LwlGiven)
model->BSIM3V2Lwl = 0.0;
if (!model->BSIM3V2LwlcGiven)
model->BSIM3V2Lwlc = model->BSIM3V2Lwl;
if (!model->BSIM3V2LminGiven)
model->BSIM3V2Lmin = 0.0;
if (!model->BSIM3V2LmaxGiven)
model->BSIM3V2Lmax = 1.0;
if (!model->BSIM3V2WintGiven)
model->BSIM3V2Wint = 0.0;
if (!model->BSIM3V2WlGiven)
model->BSIM3V2Wl = 0.0;
if (!model->BSIM3V2WlcGiven)
model->BSIM3V2Wlc = model->BSIM3V2Wl;
if (!model->BSIM3V2WlnGiven)
model->BSIM3V2Wln = 1.0;
if (!model->BSIM3V2WwGiven)
model->BSIM3V2Ww = 0.0;
if (!model->BSIM3V2WwcGiven)
model->BSIM3V2Wwc = model->BSIM3V2Ww;
if (!model->BSIM3V2WwnGiven)
model->BSIM3V2Wwn = 1.0;
if (!model->BSIM3V2WwlGiven)
model->BSIM3V2Wwl = 0.0;
if (!model->BSIM3V2WwlcGiven)
model->BSIM3V2Wwlc = model->BSIM3V2Wwl;
if (!model->BSIM3V2WminGiven)
model->BSIM3V2Wmin = 0.0;
if (!model->BSIM3V2WmaxGiven)
model->BSIM3V2Wmax = 1.0;
if (!model->BSIM3V2dwcGiven)
model->BSIM3V2dwc = model->BSIM3V2Wint;
if (!model->BSIM3V2dlcGiven)
model->BSIM3V2dlc = model->BSIM3V2Lint;
if (!model->BSIM3V2cfGiven)
model->BSIM3V2cf = 2.0 * EPSOX / PI
* log(1.0 + 0.4e-6 / model->BSIM3V2tox);
if (!model->BSIM3V2cgdoGiven)
{ if (model->BSIM3V2dlcGiven && (model->BSIM3V2dlc > 0.0))
{ model->BSIM3V2cgdo = model->BSIM3V2dlc * model->BSIM3V2cox
- model->BSIM3V2cgdl ;
}
else
model->BSIM3V2cgdo = 0.6 * model->BSIM3V2xj * model->BSIM3V2cox;
}
if (!model->BSIM3V2cgsoGiven)
{ if (model->BSIM3V2dlcGiven && (model->BSIM3V2dlc > 0.0))
{ model->BSIM3V2cgso = model->BSIM3V2dlc * model->BSIM3V2cox
- model->BSIM3V2cgsl ;
}
else
model->BSIM3V2cgso = 0.6 * model->BSIM3V2xj * model->BSIM3V2cox;
}
if (!model->BSIM3V2cgboGiven)
{ model->BSIM3V2cgbo = 2.0 * model->BSIM3V2dwc * model->BSIM3V2cox;
}
if (!model->BSIM3V2xpartGiven)
model->BSIM3V2xpart = 0.0;
if (!model->BSIM3V2sheetResistanceGiven)
model->BSIM3V2sheetResistance = 0.0;
if (!model->BSIM3V2unitAreaJctCapGiven)
model->BSIM3V2unitAreaJctCap = 5.0E-4;
if (!model->BSIM3V2unitLengthSidewallJctCapGiven)
model->BSIM3V2unitLengthSidewallJctCap = 5.0E-10;
if (!model->BSIM3V2unitLengthGateSidewallJctCapGiven)
model->BSIM3V2unitLengthGateSidewallJctCap = model->BSIM3V2unitLengthSidewallJctCap ;
if (!model->BSIM3V2jctSatCurDensityGiven)
model->BSIM3V2jctSatCurDensity = 1.0E-4;
if (!model->BSIM3V2jctSidewallSatCurDensityGiven)
model->BSIM3V2jctSidewallSatCurDensity = 0.0;
if (!model->BSIM3V2bulkJctPotentialGiven)
model->BSIM3V2bulkJctPotential = 1.0;
if (!model->BSIM3V2sidewallJctPotentialGiven)
model->BSIM3V2sidewallJctPotential = 1.0;
if (!model->BSIM3V2GatesidewallJctPotentialGiven)
model->BSIM3V2GatesidewallJctPotential = model->BSIM3V2sidewallJctPotential;
if (!model->BSIM3V2bulkJctBotGradingCoeffGiven)
model->BSIM3V2bulkJctBotGradingCoeff = 0.5;
if (!model->BSIM3V2bulkJctSideGradingCoeffGiven)
model->BSIM3V2bulkJctSideGradingCoeff = 0.33;
if (!model->BSIM3V2bulkJctGateSideGradingCoeffGiven)
model->BSIM3V2bulkJctGateSideGradingCoeff = model->BSIM3V2bulkJctSideGradingCoeff;
if (!model->BSIM3V2jctEmissionCoeffGiven)
model->BSIM3V2jctEmissionCoeff = 1.0;
if (!model->BSIM3V2jctTempExponentGiven)
model->BSIM3V2jctTempExponent = 3.0;
if (!model->BSIM3V2oxideTrapDensityAGiven)
{ if (model->BSIM3V2type == NMOS)
model->BSIM3V2oxideTrapDensityA = 1e20;
else
model->BSIM3V2oxideTrapDensityA=9.9e18;
}
if (!model->BSIM3V2oxideTrapDensityBGiven)
{ if (model->BSIM3V2type == NMOS)
model->BSIM3V2oxideTrapDensityB = 5e4;
else
model->BSIM3V2oxideTrapDensityB = 2.4e3;
}
if (!model->BSIM3V2oxideTrapDensityCGiven)
{ if (model->BSIM3V2type == NMOS)
model->BSIM3V2oxideTrapDensityC = -1.4e-12;
else
model->BSIM3V2oxideTrapDensityC = 1.4e-12;
}
if (!model->BSIM3V2emGiven)
model->BSIM3V2em = 4.1e7; /* V/m */
if (!model->BSIM3V2efGiven)
model->BSIM3V2ef = 1.0;
if (!model->BSIM3V2afGiven)
model->BSIM3V2af = 1.0;
if (!model->BSIM3V2kfGiven)
model->BSIM3V2kf = 0.0;
/* loop through all the instances of the model */
for (here = model->BSIM3V2instances; here != NULL ;
here=here->BSIM3V2nextInstance)
{
if (here->BSIM3V2owner == ARCHme) {
/* allocate a chunk of the state vector */
here->BSIM3V2states = *states;
*states += BSIM3V2numStates;
}
/* perform the parameter defaulting */
if (!here->BSIM3V2drainAreaGiven)
here->BSIM3V2drainArea = 0.0;
if (!here->BSIM3V2drainPerimeterGiven)
here->BSIM3V2drainPerimeter = 0.0;
if (!here->BSIM3V2drainSquaresGiven)
here->BSIM3V2drainSquares = 1.0;
if (!here->BSIM3V2icVBSGiven)
here->BSIM3V2icVBS = 0.0;
if (!here->BSIM3V2icVDSGiven)
here->BSIM3V2icVDS = 0.0;
if (!here->BSIM3V2icVGSGiven)
here->BSIM3V2icVGS = 0.0;
if (!here->BSIM3V2lGiven)
here->BSIM3V2l = 5.0e-6;
if (!here->BSIM3V2sourceAreaGiven)
here->BSIM3V2sourceArea = 0.0;
if (!here->BSIM3V2sourcePerimeterGiven)
here->BSIM3V2sourcePerimeter = 0.0;
if (!here->BSIM3V2sourceSquaresGiven)
here->BSIM3V2sourceSquares = 1.0;
if (!here->BSIM3V2wGiven)
here->BSIM3V2w = 5.0e-6;
if (!here->BSIM3V2nqsModGiven)
here->BSIM3V2nqsMod = 0;
/* process drain series resistance */
if ((model->BSIM3V2sheetResistance > 0.0) &&
(here->BSIM3V2drainSquares > 0.0 ) &&
(here->BSIM3V2dNodePrime == 0))
{ error = CKTmkVolt(ckt,&tmp,here->BSIM3V2name,"drain");
if(error) return(error);
here->BSIM3V2dNodePrime = tmp->number;
}
else
{ here->BSIM3V2dNodePrime = here->BSIM3V2dNode;
}
/* process source series resistance */
if ((model->BSIM3V2sheetResistance > 0.0) &&
(here->BSIM3V2sourceSquares > 0.0 ) &&
(here->BSIM3V2sNodePrime == 0))
{ error = CKTmkVolt(ckt,&tmp,here->BSIM3V2name,"source");
if(error) return(error);
here->BSIM3V2sNodePrime = tmp->number;
}
else
{ here->BSIM3V2sNodePrime = here->BSIM3V2sNode;
}
/* internal charge node */
if ((here->BSIM3V2nqsMod) && (here->BSIM3V2qNode == 0))
{ error = CKTmkVolt(ckt,&tmp,here->BSIM3V2name,"charge");
if(error) return(error);
here->BSIM3V2qNode = tmp->number;
}
else
{ here->BSIM3V2qNode = 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(BSIM3V2DdPtr, BSIM3V2dNode, BSIM3V2dNode)
TSTALLOC(BSIM3V2GgPtr, BSIM3V2gNode, BSIM3V2gNode)
TSTALLOC(BSIM3V2SsPtr, BSIM3V2sNode, BSIM3V2sNode)
TSTALLOC(BSIM3V2BbPtr, BSIM3V2bNode, BSIM3V2bNode)
TSTALLOC(BSIM3V2DPdpPtr, BSIM3V2dNodePrime, BSIM3V2dNodePrime)
TSTALLOC(BSIM3V2SPspPtr, BSIM3V2sNodePrime, BSIM3V2sNodePrime)
TSTALLOC(BSIM3V2DdpPtr, BSIM3V2dNode, BSIM3V2dNodePrime)
TSTALLOC(BSIM3V2GbPtr, BSIM3V2gNode, BSIM3V2bNode)
TSTALLOC(BSIM3V2GdpPtr, BSIM3V2gNode, BSIM3V2dNodePrime)
TSTALLOC(BSIM3V2GspPtr, BSIM3V2gNode, BSIM3V2sNodePrime)
TSTALLOC(BSIM3V2SspPtr, BSIM3V2sNode, BSIM3V2sNodePrime)
TSTALLOC(BSIM3V2BdpPtr, BSIM3V2bNode, BSIM3V2dNodePrime)
TSTALLOC(BSIM3V2BspPtr, BSIM3V2bNode, BSIM3V2sNodePrime)
TSTALLOC(BSIM3V2DPspPtr, BSIM3V2dNodePrime, BSIM3V2sNodePrime)
TSTALLOC(BSIM3V2DPdPtr, BSIM3V2dNodePrime, BSIM3V2dNode)
TSTALLOC(BSIM3V2BgPtr, BSIM3V2bNode, BSIM3V2gNode)
TSTALLOC(BSIM3V2DPgPtr, BSIM3V2dNodePrime, BSIM3V2gNode)
TSTALLOC(BSIM3V2SPgPtr, BSIM3V2sNodePrime, BSIM3V2gNode)
TSTALLOC(BSIM3V2SPsPtr, BSIM3V2sNodePrime, BSIM3V2sNode)
TSTALLOC(BSIM3V2DPbPtr, BSIM3V2dNodePrime, BSIM3V2bNode)
TSTALLOC(BSIM3V2SPbPtr, BSIM3V2sNodePrime, BSIM3V2bNode)
TSTALLOC(BSIM3V2SPdpPtr, BSIM3V2sNodePrime, BSIM3V2dNodePrime)
TSTALLOC(BSIM3V2QqPtr, BSIM3V2qNode, BSIM3V2qNode)
TSTALLOC(BSIM3V2QdpPtr, BSIM3V2qNode, BSIM3V2dNodePrime)
TSTALLOC(BSIM3V2QspPtr, BSIM3V2qNode, BSIM3V2sNodePrime)
TSTALLOC(BSIM3V2QgPtr, BSIM3V2qNode, BSIM3V2gNode)
TSTALLOC(BSIM3V2QbPtr, BSIM3V2qNode, BSIM3V2bNode)
TSTALLOC(BSIM3V2DPqPtr, BSIM3V2dNodePrime, BSIM3V2qNode)
TSTALLOC(BSIM3V2SPqPtr, BSIM3V2sNodePrime, BSIM3V2qNode)
TSTALLOC(BSIM3V2GqPtr, BSIM3V2gNode, BSIM3V2qNode)
TSTALLOC(BSIM3V2BqPtr, BSIM3V2bNode, BSIM3V2qNode)
}
}
return(OK);
}
int
BSIM3V2unsetup(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
BSIM3V2model *model;
BSIM3V2instance *here;
for (model = (BSIM3V2model *)inModel; model != NULL;
model = model->BSIM3V2nextModel)
{
for (here = model->BSIM3V2instances; here != NULL;
here=here->BSIM3V2nextInstance)
{
if (here->BSIM3V2dNodePrime
&& here->BSIM3V2dNodePrime != here->BSIM3V2dNode)
{
CKTdltNNum(ckt, here->BSIM3V2dNodePrime);
here->BSIM3V2dNodePrime = 0;
}
if (here->BSIM3V2sNodePrime
&& here->BSIM3V2sNodePrime != here->BSIM3V2sNode)
{
CKTdltNNum(ckt, here->BSIM3V2sNodePrime);
here->BSIM3V2sNodePrime = 0;
}
}
}
return OK;
}

846
src/spicelib/devices/bsim3v2/b3v2temp.c
View File

@ -1,846 +0,0 @@
/***********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
Modified by Weidong Liu (1997-1998).
File: b3v2temp.c
**********/
/* Lmin, Lmax, Wmin, Wmax */
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "smpdefs.h"
#include "cktdefs.h"
#include "bsim3v2def.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
BSIM3V2temp(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
BSIM3V2model *model = (BSIM3V2model*) inModel;
BSIM3V2instance *here;
struct BSIM3V2SizeDependParam *pSizeDependParamKnot, *pLastKnot, *pParam;
double tmp, tmp1, tmp2, tmp3, Eg, Eg0, ni, T0, T1, T2, T3, T4, T5, Ldrn, Wdrn;
double delTemp, Temp, TRatio, Inv_L, Inv_W, Inv_LW, Dw, Dl, Vtm0, Tnom;
double Nvtm, SourceSatCurrent, DrainSatCurrent;
int Size_Not_Found;
/* loop through all the BSIM3V2 device models */
for (; model != NULL; model = model->BSIM3V2nextModel)
{ Temp = ckt->CKTtemp;
if (model->BSIM3V2bulkJctPotential < 0.1)
{ model->BSIM3V2bulkJctPotential = 0.1;
fprintf(stderr, "Given pb is less than 0.1. Pb is set to 0.1.\n");
}
if (model->BSIM3V2sidewallJctPotential < 0.1)
{ model->BSIM3V2sidewallJctPotential = 0.1;
fprintf(stderr, "Given pbsw is less than 0.1. Pbsw is set to 0.1.\n");
}
if (model->BSIM3V2GatesidewallJctPotential < 0.1)
{ model->BSIM3V2GatesidewallJctPotential = 0.1;
fprintf(stderr, "Given pbswg is less than 0.1. Pbswg is set to 0.1.\n");
}
model->pSizeDependParamKnot = NULL;
pLastKnot = NULL;
Tnom = model->BSIM3V2tnom;
TRatio = Temp / Tnom;
model->BSIM3V2vcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14));
model->BSIM3V2factor1 = sqrt(EPSSI / EPSOX * model->BSIM3V2tox);
Vtm0 = KboQ * Tnom;
Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0);
ni = 1.45e10 * (Tnom / 300.15) * sqrt(Tnom / 300.15)
* exp(21.5565981 - Eg0 / (2.0 * Vtm0));
model->BSIM3V2vtm = KboQ * Temp;
Eg = 1.16 - 7.02e-4 * Temp * Temp / (Temp + 1108.0);
if (Temp != Tnom)
{ T0 = Eg0 / Vtm0 - Eg / model->BSIM3V2vtm + model->BSIM3V2jctTempExponent
* log(Temp / Tnom);
T1 = exp(T0 / model->BSIM3V2jctEmissionCoeff);
model->BSIM3V2jctTempSatCurDensity = model->BSIM3V2jctSatCurDensity
* T1;
model->BSIM3V2jctSidewallTempSatCurDensity
= model->BSIM3V2jctSidewallSatCurDensity * T1;
}
else
{ model->BSIM3V2jctTempSatCurDensity = model->BSIM3V2jctSatCurDensity;
model->BSIM3V2jctSidewallTempSatCurDensity
= model->BSIM3V2jctSidewallSatCurDensity;
}
if (model->BSIM3V2jctTempSatCurDensity < 0.0)
model->BSIM3V2jctTempSatCurDensity = 0.0;
if (model->BSIM3V2jctSidewallTempSatCurDensity < 0.0)
model->BSIM3V2jctSidewallTempSatCurDensity = 0.0;
/* Temperature dependence of D/B and S/B diode capacitance begins */
delTemp = ckt->CKTtemp - model->BSIM3V2tnom;
T0 = model->BSIM3V2tcj * delTemp;
if (T0 >= -1.0)
{ model->BSIM3V2unitAreaJctCap *= 1.0 + T0;
}
else if (model->BSIM3V2unitAreaJctCap > 0.0)
{ model->BSIM3V2unitAreaJctCap = 0.0;
fprintf(stderr, "Temperature effect has caused cj to be negative. Cj is clamped to zero.\n");
}
T0 = model->BSIM3V2tcjsw * delTemp;
if (T0 >= -1.0)
{ model->BSIM3V2unitLengthSidewallJctCap *= 1.0 + T0;
}
else if (model->BSIM3V2unitLengthSidewallJctCap > 0.0)
{ model->BSIM3V2unitLengthSidewallJctCap = 0.0;
fprintf(stderr, "Temperature effect has caused cjsw to be negative. Cjsw is clamped to zero.\n");
}
T0 = model->BSIM3V2tcjswg * delTemp;
if (T0 >= -1.0)
{ model->BSIM3V2unitLengthGateSidewallJctCap *= 1.0 + T0;
}
else if (model->BSIM3V2unitLengthGateSidewallJctCap > 0.0)
{ model->BSIM3V2unitLengthGateSidewallJctCap = 0.0;
fprintf(stderr, "Temperature effect has caused cjswg to be negative. Cjswg is clamped to zero.\n");
}
model->BSIM3V2PhiB = model->BSIM3V2bulkJctPotential
- model->BSIM3V2tpb * delTemp;
if (model->BSIM3V2PhiB < 0.01)
{ model->BSIM3V2PhiB = 0.01;
fprintf(stderr, "Temperature effect has caused pb to be less than 0.01. Pb is clamped to 0.01.\n");
}
model->BSIM3V2PhiBSW = model->BSIM3V2sidewallJctPotential
- model->BSIM3V2tpbsw * delTemp;
if (model->BSIM3V2PhiBSW <= 0.01)
{ model->BSIM3V2PhiBSW = 0.01;
fprintf(stderr, "Temperature effect has caused pbsw to be less than 0.01. Pbsw is clamped to 0.01.\n");
}
model->BSIM3V2PhiBSWG = model->BSIM3V2GatesidewallJctPotential
- model->BSIM3V2tpbswg * delTemp;
if (model->BSIM3V2PhiBSWG <= 0.01)
{ model->BSIM3V2PhiBSWG = 0.01;
fprintf(stderr, "Temperature effect has caused pbswg to be less than 0.01. Pbswg is clamped to 0.01.\n");
}
/* End of junction capacitance - Weidong & Min-Chie 5/1998 */
/* loop through all the instances of the model */
/* MCJ: Length and Width not initialized */
for (here = model->BSIM3V2instances; here != NULL;
here = here->BSIM3V2nextInstance)
{
if (here->BSIM3V2owner != ARCHme) continue;
pSizeDependParamKnot = model->pSizeDependParamKnot;
Size_Not_Found = 1;
while ((pSizeDependParamKnot != NULL) && Size_Not_Found)
{ if ((here->BSIM3V2l == pSizeDependParamKnot->Length)
&& (here->BSIM3V2w == pSizeDependParamKnot->Width))
{ Size_Not_Found = 0;
here->pParam = pSizeDependParamKnot;
}
else
{ pLastKnot = pSizeDependParamKnot;
pSizeDependParamKnot = pSizeDependParamKnot->pNext;
}
}
if (Size_Not_Found)
{ pParam = (struct BSIM3V2SizeDependParam *)tmalloc(
sizeof(struct BSIM3V2SizeDependParam));
if (pLastKnot == NULL)
model->pSizeDependParamKnot = pParam;
else
pLastKnot->pNext = pParam;
pParam->pNext = NULL;
here->pParam = pParam;
Ldrn = here->BSIM3V2l;
Wdrn = here->BSIM3V2w;
pParam->Length = Ldrn;
pParam->Width = Wdrn;
T0 = pow(Ldrn, model->BSIM3V2Lln);
T1 = pow(Wdrn, model->BSIM3V2Lwn);
tmp1 = model->BSIM3V2Ll / T0 + model->BSIM3V2Lw / T1
+ model->BSIM3V2Lwl / (T0 * T1);
pParam->BSIM3V2dl = model->BSIM3V2Lint + tmp1;
tmp2 = model->BSIM3V2Llc / T0 + model->BSIM3V2Lwc / T1
+ model->BSIM3V2Lwlc / (T0 * T1);
pParam->BSIM3V2dlc = model->BSIM3V2dlc + tmp2;
T2 = pow(Ldrn, model->BSIM3V2Wln);
T3 = pow(Wdrn, model->BSIM3V2Wwn);
tmp1 = model->BSIM3V2Wl / T2 + model->BSIM3V2Ww / T3
+ model->BSIM3V2Wwl / (T2 * T3);
pParam->BSIM3V2dw = model->BSIM3V2Wint + tmp1;
tmp2 = model->BSIM3V2Wlc / T2 + model->BSIM3V2Wwc / T3
+ model->BSIM3V2Wwlc / (T2 * T3);
pParam->BSIM3V2dwc = model->BSIM3V2dwc + tmp2;
pParam->BSIM3V2leff = here->BSIM3V2l - 2.0 * pParam->BSIM3V2dl;
if (pParam->BSIM3V2leff <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->BSIM3V2modName;
namarray[1] = here->BSIM3V2name;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"BSIM3V2: mosfet %s, model %s: Effective channel length <= 0",
namarray);
return(E_BADPARM);
}
pParam->BSIM3V2weff = here->BSIM3V2w - 2.0 * pParam->BSIM3V2dw;
if (pParam->BSIM3V2weff <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->BSIM3V2modName;
namarray[1] = here->BSIM3V2name;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"BSIM3V2: mosfet %s, model %s: Effective channel width <= 0",
namarray);
return(E_BADPARM);
}
pParam->BSIM3V2leffCV = here->BSIM3V2l - 2.0 * pParam->BSIM3V2dlc;
if (pParam->BSIM3V2leffCV <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->BSIM3V2modName;
namarray[1] = here->BSIM3V2name;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"BSIM3V2: mosfet %s, model %s: Effective channel length for C-V <= 0",
namarray);
return(E_BADPARM);
}
pParam->BSIM3V2weffCV = here->BSIM3V2w - 2.0 * pParam->BSIM3V2dwc;
if (pParam->BSIM3V2weffCV <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->BSIM3V2modName;
namarray[1] = here->BSIM3V2name;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"BSIM3V2: mosfet %s, model %s: Effective channel width for C-V <= 0",
namarray);
return(E_BADPARM);
}
if (model->BSIM3V2binUnit == 1)
{ Inv_L = 1.0e-6 / pParam->BSIM3V2leff;
Inv_W = 1.0e-6 / pParam->BSIM3V2weff;
Inv_LW = 1.0e-12 / (pParam->BSIM3V2leff
* pParam->BSIM3V2weff);
}
else
{ Inv_L = 1.0 / pParam->BSIM3V2leff;
Inv_W = 1.0 / pParam->BSIM3V2weff;
Inv_LW = 1.0 / (pParam->BSIM3V2leff
* pParam->BSIM3V2weff);
}
pParam->BSIM3V2cdsc = model->BSIM3V2cdsc
+ model->BSIM3V2lcdsc * Inv_L
+ model->BSIM3V2wcdsc * Inv_W
+ model->BSIM3V2pcdsc * Inv_LW;
pParam->BSIM3V2cdscb = model->BSIM3V2cdscb
+ model->BSIM3V2lcdscb * Inv_L
+ model->BSIM3V2wcdscb * Inv_W
+ model->BSIM3V2pcdscb * Inv_LW;
pParam->BSIM3V2cdscd = model->BSIM3V2cdscd
+ model->BSIM3V2lcdscd * Inv_L
+ model->BSIM3V2wcdscd * Inv_W
+ model->BSIM3V2pcdscd * Inv_LW;
pParam->BSIM3V2cit = model->BSIM3V2cit
+ model->BSIM3V2lcit * Inv_L
+ model->BSIM3V2wcit * Inv_W
+ model->BSIM3V2pcit * Inv_LW;
pParam->BSIM3V2nfactor = model->BSIM3V2nfactor
+ model->BSIM3V2lnfactor * Inv_L
+ model->BSIM3V2wnfactor * Inv_W
+ model->BSIM3V2pnfactor * Inv_LW;
pParam->BSIM3V2xj = model->BSIM3V2xj
+ model->BSIM3V2lxj * Inv_L
+ model->BSIM3V2wxj * Inv_W
+ model->BSIM3V2pxj * Inv_LW;
pParam->BSIM3V2vsat = model->BSIM3V2vsat
+ model->BSIM3V2lvsat * Inv_L
+ model->BSIM3V2wvsat * Inv_W
+ model->BSIM3V2pvsat * Inv_LW;
pParam->BSIM3V2at = model->BSIM3V2at
+ model->BSIM3V2lat * Inv_L
+ model->BSIM3V2wat * Inv_W
+ model->BSIM3V2pat * Inv_LW;
pParam->BSIM3V2a0 = model->BSIM3V2a0
+ model->BSIM3V2la0 * Inv_L
+ model->BSIM3V2wa0 * Inv_W
+ model->BSIM3V2pa0 * Inv_LW;
pParam->BSIM3V2ags = model->BSIM3V2ags
+ model->BSIM3V2lags * Inv_L
+ model->BSIM3V2wags * Inv_W
+ model->BSIM3V2pags * Inv_LW;
pParam->BSIM3V2a1 = model->BSIM3V2a1
+ model->BSIM3V2la1 * Inv_L
+ model->BSIM3V2wa1 * Inv_W
+ model->BSIM3V2pa1 * Inv_LW;
pParam->BSIM3V2a2 = model->BSIM3V2a2
+ model->BSIM3V2la2 * Inv_L
+ model->BSIM3V2wa2 * Inv_W
+ model->BSIM3V2pa2 * Inv_LW;
pParam->BSIM3V2keta = model->BSIM3V2keta
+ model->BSIM3V2lketa * Inv_L
+ model->BSIM3V2wketa * Inv_W
+ model->BSIM3V2pketa * Inv_LW;
pParam->BSIM3V2nsub = model->BSIM3V2nsub
+ model->BSIM3V2lnsub * Inv_L
+ model->BSIM3V2wnsub * Inv_W
+ model->BSIM3V2pnsub * Inv_LW;
pParam->BSIM3V2npeak = model->BSIM3V2npeak
+ model->BSIM3V2lnpeak * Inv_L
+ model->BSIM3V2wnpeak * Inv_W
+ model->BSIM3V2pnpeak * Inv_LW;
pParam->BSIM3V2ngate = model->BSIM3V2ngate
+ model->BSIM3V2lngate * Inv_L
+ model->BSIM3V2wngate * Inv_W
+ model->BSIM3V2pngate * Inv_LW;
pParam->BSIM3V2gamma1 = model->BSIM3V2gamma1
+ model->BSIM3V2lgamma1 * Inv_L
+ model->BSIM3V2wgamma1 * Inv_W
+ model->BSIM3V2pgamma1 * Inv_LW;
pParam->BSIM3V2gamma2 = model->BSIM3V2gamma2
+ model->BSIM3V2lgamma2 * Inv_L
+ model->BSIM3V2wgamma2 * Inv_W
+ model->BSIM3V2pgamma2 * Inv_LW;
pParam->BSIM3V2vbx = model->BSIM3V2vbx
+ model->BSIM3V2lvbx * Inv_L
+ model->BSIM3V2wvbx * Inv_W
+ model->BSIM3V2pvbx * Inv_LW;
pParam->BSIM3V2vbm = model->BSIM3V2vbm
+ model->BSIM3V2lvbm * Inv_L
+ model->BSIM3V2wvbm * Inv_W
+ model->BSIM3V2pvbm * Inv_LW;
pParam->BSIM3V2xt = model->BSIM3V2xt
+ model->BSIM3V2lxt * Inv_L
+ model->BSIM3V2wxt * Inv_W
+ model->BSIM3V2pxt * Inv_LW;
pParam->BSIM3V2vfb = model->BSIM3V2vfb
+ model->BSIM3V2lvfb * Inv_L
+ model->BSIM3V2wvfb * Inv_W
+ model->BSIM3V2pvfb * Inv_LW;
pParam->BSIM3V2k1 = model->BSIM3V2k1
+ model->BSIM3V2lk1 * Inv_L
+ model->BSIM3V2wk1 * Inv_W
+ model->BSIM3V2pk1 * Inv_LW;
pParam->BSIM3V2kt1 = model->BSIM3V2kt1
+ model->BSIM3V2lkt1 * Inv_L
+ model->BSIM3V2wkt1 * Inv_W
+ model->BSIM3V2pkt1 * Inv_LW;
pParam->BSIM3V2kt1l = model->BSIM3V2kt1l
+ model->BSIM3V2lkt1l * Inv_L
+ model->BSIM3V2wkt1l * Inv_W
+ model->BSIM3V2pkt1l * Inv_LW;
pParam->BSIM3V2k2 = model->BSIM3V2k2
+ model->BSIM3V2lk2 * Inv_L
+ model->BSIM3V2wk2 * Inv_W
+ model->BSIM3V2pk2 * Inv_LW;
pParam->BSIM3V2kt2 = model->BSIM3V2kt2
+ model->BSIM3V2lkt2 * Inv_L
+ model->BSIM3V2wkt2 * Inv_W
+ model->BSIM3V2pkt2 * Inv_LW;
pParam->BSIM3V2k3 = model->BSIM3V2k3
+ model->BSIM3V2lk3 * Inv_L
+ model->BSIM3V2wk3 * Inv_W
+ model->BSIM3V2pk3 * Inv_LW;
pParam->BSIM3V2k3b = model->BSIM3V2k3b
+ model->BSIM3V2lk3b * Inv_L
+ model->BSIM3V2wk3b * Inv_W
+ model->BSIM3V2pk3b * Inv_LW;
pParam->BSIM3V2w0 = model->BSIM3V2w0
+ model->BSIM3V2lw0 * Inv_L
+ model->BSIM3V2ww0 * Inv_W
+ model->BSIM3V2pw0 * Inv_LW;
pParam->BSIM3V2nlx = model->BSIM3V2nlx
+ model->BSIM3V2lnlx * Inv_L
+ model->BSIM3V2wnlx * Inv_W
+ model->BSIM3V2pnlx * Inv_LW;
pParam->BSIM3V2dvt0 = model->BSIM3V2dvt0
+ model->BSIM3V2ldvt0 * Inv_L
+ model->BSIM3V2wdvt0 * Inv_W
+ model->BSIM3V2pdvt0 * Inv_LW;
pParam->BSIM3V2dvt1 = model->BSIM3V2dvt1
+ model->BSIM3V2ldvt1 * Inv_L
+ model->BSIM3V2wdvt1 * Inv_W
+ model->BSIM3V2pdvt1 * Inv_LW;
pParam->BSIM3V2dvt2 = model->BSIM3V2dvt2
+ model->BSIM3V2ldvt2 * Inv_L
+ model->BSIM3V2wdvt2 * Inv_W
+ model->BSIM3V2pdvt2 * Inv_LW;
pParam->BSIM3V2dvt0w = model->BSIM3V2dvt0w
+ model->BSIM3V2ldvt0w * Inv_L
+ model->BSIM3V2wdvt0w * Inv_W
+ model->BSIM3V2pdvt0w * Inv_LW;
pParam->BSIM3V2dvt1w = model->BSIM3V2dvt1w
+ model->BSIM3V2ldvt1w * Inv_L
+ model->BSIM3V2wdvt1w * Inv_W
+ model->BSIM3V2pdvt1w * Inv_LW;
pParam->BSIM3V2dvt2w = model->BSIM3V2dvt2w
+ model->BSIM3V2ldvt2w * Inv_L
+ model->BSIM3V2wdvt2w * Inv_W
+ model->BSIM3V2pdvt2w * Inv_LW;
pParam->BSIM3V2drout = model->BSIM3V2drout
+ model->BSIM3V2ldrout * Inv_L
+ model->BSIM3V2wdrout * Inv_W
+ model->BSIM3V2pdrout * Inv_LW;
pParam->BSIM3V2dsub = model->BSIM3V2dsub
+ model->BSIM3V2ldsub * Inv_L
+ model->BSIM3V2wdsub * Inv_W
+ model->BSIM3V2pdsub * Inv_LW;
pParam->BSIM3V2vth0 = model->BSIM3V2vth0
+ model->BSIM3V2lvth0 * Inv_L
+ model->BSIM3V2wvth0 * Inv_W
+ model->BSIM3V2pvth0 * Inv_LW;
pParam->BSIM3V2ua = model->BSIM3V2ua
+ model->BSIM3V2lua * Inv_L
+ model->BSIM3V2wua * Inv_W
+ model->BSIM3V2pua * Inv_LW;
pParam->BSIM3V2ua1 = model->BSIM3V2ua1
+ model->BSIM3V2lua1 * Inv_L
+ model->BSIM3V2wua1 * Inv_W
+ model->BSIM3V2pua1 * Inv_LW;
pParam->BSIM3V2ub = model->BSIM3V2ub
+ model->BSIM3V2lub * Inv_L
+ model->BSIM3V2wub * Inv_W
+ model->BSIM3V2pub * Inv_LW;
pParam->BSIM3V2ub1 = model->BSIM3V2ub1
+ model->BSIM3V2lub1 * Inv_L
+ model->BSIM3V2wub1 * Inv_W
+ model->BSIM3V2pub1 * Inv_LW;
pParam->BSIM3V2uc = model->BSIM3V2uc
+ model->BSIM3V2luc * Inv_L
+ model->BSIM3V2wuc * Inv_W
+ model->BSIM3V2puc * Inv_LW;
pParam->BSIM3V2uc1 = model->BSIM3V2uc1
+ model->BSIM3V2luc1 * Inv_L
+ model->BSIM3V2wuc1 * Inv_W
+ model->BSIM3V2puc1 * Inv_LW;
pParam->BSIM3V2u0 = model->BSIM3V2u0
+ model->BSIM3V2lu0 * Inv_L
+ model->BSIM3V2wu0 * Inv_W
+ model->BSIM3V2pu0 * Inv_LW;
pParam->BSIM3V2ute = model->BSIM3V2ute
+ model->BSIM3V2lute * Inv_L
+ model->BSIM3V2wute * Inv_W
+ model->BSIM3V2pute * Inv_LW;
pParam->BSIM3V2voff = model->BSIM3V2voff
+ model->BSIM3V2lvoff * Inv_L
+ model->BSIM3V2wvoff * Inv_W
+ model->BSIM3V2pvoff * Inv_LW;
pParam->BSIM3V2delta = model->BSIM3V2delta
+ model->BSIM3V2ldelta * Inv_L
+ model->BSIM3V2wdelta * Inv_W
+ model->BSIM3V2pdelta * Inv_LW;
pParam->BSIM3V2rdsw = model->BSIM3V2rdsw
+ model->BSIM3V2lrdsw * Inv_L
+ model->BSIM3V2wrdsw * Inv_W
+ model->BSIM3V2prdsw * Inv_LW;
pParam->BSIM3V2prwg = model->BSIM3V2prwg
+ model->BSIM3V2lprwg * Inv_L
+ model->BSIM3V2wprwg * Inv_W
+ model->BSIM3V2pprwg * Inv_LW;
pParam->BSIM3V2prwb = model->BSIM3V2prwb
+ model->BSIM3V2lprwb * Inv_L
+ model->BSIM3V2wprwb * Inv_W
+ model->BSIM3V2pprwb * Inv_LW;
pParam->BSIM3V2prt = model->BSIM3V2prt
+ model->BSIM3V2lprt * Inv_L
+ model->BSIM3V2wprt * Inv_W
+ model->BSIM3V2pprt * Inv_LW;
pParam->BSIM3V2eta0 = model->BSIM3V2eta0
+ model->BSIM3V2leta0 * Inv_L
+ model->BSIM3V2weta0 * Inv_W
+ model->BSIM3V2peta0 * Inv_LW;
pParam->BSIM3V2etab = model->BSIM3V2etab
+ model->BSIM3V2letab * Inv_L
+ model->BSIM3V2wetab * Inv_W
+ model->BSIM3V2petab * Inv_LW;
pParam->BSIM3V2pclm = model->BSIM3V2pclm
+ model->BSIM3V2lpclm * Inv_L
+ model->BSIM3V2wpclm * Inv_W
+ model->BSIM3V2ppclm * Inv_LW;
pParam->BSIM3V2pdibl1 = model->BSIM3V2pdibl1
+ model->BSIM3V2lpdibl1 * Inv_L
+ model->BSIM3V2wpdibl1 * Inv_W
+ model->BSIM3V2ppdibl1 * Inv_LW;
pParam->BSIM3V2pdibl2 = model->BSIM3V2pdibl2
+ model->BSIM3V2lpdibl2 * Inv_L
+ model->BSIM3V2wpdibl2 * Inv_W
+ model->BSIM3V2ppdibl2 * Inv_LW;
pParam->BSIM3V2pdiblb = model->BSIM3V2pdiblb
+ model->BSIM3V2lpdiblb * Inv_L
+ model->BSIM3V2wpdiblb * Inv_W
+ model->BSIM3V2ppdiblb * Inv_LW;
pParam->BSIM3V2pscbe1 = model->BSIM3V2pscbe1
+ model->BSIM3V2lpscbe1 * Inv_L
+ model->BSIM3V2wpscbe1 * Inv_W
+ model->BSIM3V2ppscbe1 * Inv_LW;
pParam->BSIM3V2pscbe2 = model->BSIM3V2pscbe2
+ model->BSIM3V2lpscbe2 * Inv_L
+ model->BSIM3V2wpscbe2 * Inv_W
+ model->BSIM3V2ppscbe2 * Inv_LW;
pParam->BSIM3V2pvag = model->BSIM3V2pvag
+ model->BSIM3V2lpvag * Inv_L
+ model->BSIM3V2wpvag * Inv_W
+ model->BSIM3V2ppvag * Inv_LW;
pParam->BSIM3V2wr = model->BSIM3V2wr
+ model->BSIM3V2lwr * Inv_L
+ model->BSIM3V2wwr * Inv_W
+ model->BSIM3V2pwr * Inv_LW;
pParam->BSIM3V2dwg = model->BSIM3V2dwg
+ model->BSIM3V2ldwg * Inv_L
+ model->BSIM3V2wdwg * Inv_W
+ model->BSIM3V2pdwg * Inv_LW;
pParam->BSIM3V2dwb = model->BSIM3V2dwb
+ model->BSIM3V2ldwb * Inv_L
+ model->BSIM3V2wdwb * Inv_W
+ model->BSIM3V2pdwb * Inv_LW;
pParam->BSIM3V2b0 = model->BSIM3V2b0
+ model->BSIM3V2lb0 * Inv_L
+ model->BSIM3V2wb0 * Inv_W
+ model->BSIM3V2pb0 * Inv_LW;
pParam->BSIM3V2b1 = model->BSIM3V2b1
+ model->BSIM3V2lb1 * Inv_L
+ model->BSIM3V2wb1 * Inv_W
+ model->BSIM3V2pb1 * Inv_LW;
pParam->BSIM3V2alpha0 = model->BSIM3V2alpha0
+ model->BSIM3V2lalpha0 * Inv_L
+ model->BSIM3V2walpha0 * Inv_W
+ model->BSIM3V2palpha0 * Inv_LW;
pParam->BSIM3V2alpha1 = model->BSIM3V2alpha1
+ model->BSIM3V2lalpha1 * Inv_L
+ model->BSIM3V2walpha1 * Inv_W
+ model->BSIM3V2palpha1 * Inv_LW;
pParam->BSIM3V2beta0 = model->BSIM3V2beta0
+ model->BSIM3V2lbeta0 * Inv_L
+ model->BSIM3V2wbeta0 * Inv_W
+ model->BSIM3V2pbeta0 * Inv_LW;
/* CV model */
pParam->BSIM3V2elm = model->BSIM3V2elm
+ model->BSIM3V2lelm * Inv_L
+ model->BSIM3V2welm * Inv_W
+ model->BSIM3V2pelm * Inv_LW;
pParam->BSIM3V2cgsl = model->BSIM3V2cgsl
+ model->BSIM3V2lcgsl * Inv_L
+ model->BSIM3V2wcgsl * Inv_W
+ model->BSIM3V2pcgsl * Inv_LW;
pParam->BSIM3V2cgdl = model->BSIM3V2cgdl
+ model->BSIM3V2lcgdl * Inv_L
+ model->BSIM3V2wcgdl * Inv_W
+ model->BSIM3V2pcgdl * Inv_LW;
pParam->BSIM3V2ckappa = model->BSIM3V2ckappa
+ model->BSIM3V2lckappa * Inv_L
+ model->BSIM3V2wckappa * Inv_W
+ model->BSIM3V2pckappa * Inv_LW;
pParam->BSIM3V2cf = model->BSIM3V2cf
+ model->BSIM3V2lcf * Inv_L
+ model->BSIM3V2wcf * Inv_W
+ model->BSIM3V2pcf * Inv_LW;
pParam->BSIM3V2clc = model->BSIM3V2clc
+ model->BSIM3V2lclc * Inv_L
+ model->BSIM3V2wclc * Inv_W
+ model->BSIM3V2pclc * Inv_LW;
pParam->BSIM3V2cle = model->BSIM3V2cle
+ model->BSIM3V2lcle * Inv_L
+ model->BSIM3V2wcle * Inv_W
+ model->BSIM3V2pcle * Inv_LW;
pParam->BSIM3V2vfbcv = model->BSIM3V2vfbcv
+ model->BSIM3V2lvfbcv * Inv_L
+ model->BSIM3V2wvfbcv * Inv_W
+ model->BSIM3V2pvfbcv * Inv_LW;
pParam->BSIM3V2acde = model->BSIM3V2acde
+ model->BSIM3V2lacde * Inv_L
+ model->BSIM3V2wacde * Inv_W
+ model->BSIM3V2pacde * Inv_LW;
pParam->BSIM3V2moin = model->BSIM3V2moin
+ model->BSIM3V2lmoin * Inv_L
+ model->BSIM3V2wmoin * Inv_W
+ model->BSIM3V2pmoin * Inv_LW;
pParam->BSIM3V2noff = model->BSIM3V2noff
+ model->BSIM3V2lnoff * Inv_L
+ model->BSIM3V2wnoff * Inv_W
+ model->BSIM3V2pnoff * Inv_LW;
pParam->BSIM3V2voffcv = model->BSIM3V2voffcv
+ model->BSIM3V2lvoffcv * Inv_L
+ model->BSIM3V2wvoffcv * Inv_W
+ model->BSIM3V2pvoffcv * Inv_LW;
pParam->BSIM3V2abulkCVfactor = 1.0 + pow((pParam->BSIM3V2clc
/ pParam->BSIM3V2leffCV),
pParam->BSIM3V2cle);
T0 = (TRatio - 1.0);
pParam->BSIM3V2ua = pParam->BSIM3V2ua + pParam->BSIM3V2ua1 * T0;
pParam->BSIM3V2ub = pParam->BSIM3V2ub + pParam->BSIM3V2ub1 * T0;
pParam->BSIM3V2uc = pParam->BSIM3V2uc + pParam->BSIM3V2uc1 * T0;
if (pParam->BSIM3V2u0 > 1.0)
pParam->BSIM3V2u0 = pParam->BSIM3V2u0 / 1.0e4;
pParam->BSIM3V2u0temp = pParam->BSIM3V2u0
* pow(TRatio, pParam->BSIM3V2ute);
pParam->BSIM3V2vsattemp = pParam->BSIM3V2vsat - pParam->BSIM3V2at
* T0;
pParam->BSIM3V2rds0 = (pParam->BSIM3V2rdsw + pParam->BSIM3V2prt * T0)
/ pow(pParam->BSIM3V2weff * 1E6, pParam->BSIM3V2wr);
if (BSIM3V2checkModel(model, here, ckt))
{ IFuid namarray[2];
namarray[0] = model->BSIM3V2modName;
namarray[1] = here->BSIM3V2name;
(*(SPfrontEnd->IFerror)) (ERR_FATAL, "Fatal error(s) detected during BSIM3V2V3.2 parameter checking for %s in model %s", namarray);
return(E_BADPARM);
}
pParam->BSIM3V2cgdo = (model->BSIM3V2cgdo + pParam->BSIM3V2cf)
* pParam->BSIM3V2weffCV;
pParam->BSIM3V2cgso = (model->BSIM3V2cgso + pParam->BSIM3V2cf)
* pParam->BSIM3V2weffCV;
pParam->BSIM3V2cgbo = model->BSIM3V2cgbo * pParam->BSIM3V2leffCV;
T0 = pParam->BSIM3V2leffCV * pParam->BSIM3V2leffCV;
pParam->BSIM3V2tconst = pParam->BSIM3V2u0temp * pParam->BSIM3V2elm / (model->BSIM3V2cox
* pParam->BSIM3V2weffCV * pParam->BSIM3V2leffCV * T0);
if (!model->BSIM3V2npeakGiven && model->BSIM3V2gamma1Given)
{ T0 = pParam->BSIM3V2gamma1 * model->BSIM3V2cox;
pParam->BSIM3V2npeak = 3.021E22 * T0 * T0;
}
pParam->BSIM3V2phi = 2.0 * Vtm0
* log(pParam->BSIM3V2npeak / ni);
pParam->BSIM3V2sqrtPhi = sqrt(pParam->BSIM3V2phi);
pParam->BSIM3V2phis3 = pParam->BSIM3V2sqrtPhi * pParam->BSIM3V2phi;
pParam->BSIM3V2Xdep0 = sqrt(2.0 * EPSSI / (Charge_q
* pParam->BSIM3V2npeak * 1.0e6))
* pParam->BSIM3V2sqrtPhi;
pParam->BSIM3V2sqrtXdep0 = sqrt(pParam->BSIM3V2Xdep0);
pParam->BSIM3V2litl = sqrt(3.0 * pParam->BSIM3V2xj
* model->BSIM3V2tox);
pParam->BSIM3V2vbi = Vtm0 * log(1.0e20
* pParam->BSIM3V2npeak / (ni * ni));
pParam->BSIM3V2cdep0 = sqrt(Charge_q * EPSSI
* pParam->BSIM3V2npeak * 1.0e6 / 2.0
/ pParam->BSIM3V2phi);
pParam->BSIM3V2ldeb = sqrt(EPSSI * Vtm0 / (Charge_q
* pParam->BSIM3V2npeak * 1.0e6)) / 3.0;
pParam->BSIM3V2acde *= pow((pParam->BSIM3V2npeak / 2.0e16), -0.25);
if (model->BSIM3V2k1Given || model->BSIM3V2k2Given)
{ if (!model->BSIM3V2k1Given)
{ fprintf(stdout, "Warning: k1 should be specified with k2.\n");
pParam->BSIM3V2k1 = 0.53;
}
if (!model->BSIM3V2k2Given)
{ fprintf(stdout, "Warning: k2 should be specified with k1.\n");
pParam->BSIM3V2k2 = -0.0186;
}
if (model->BSIM3V2nsubGiven)
fprintf(stdout, "Warning: nsub is ignored because k1 or k2 is given.\n");
if (model->BSIM3V2xtGiven)
fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n");
if (model->BSIM3V2vbxGiven)
fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n");
if (model->BSIM3V2gamma1Given)
fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n");
if (model->BSIM3V2gamma2Given)
fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n");
}
else
{ if (!model->BSIM3V2vbxGiven)
pParam->BSIM3V2vbx = pParam->BSIM3V2phi - 7.7348e-4
* pParam->BSIM3V2npeak
* pParam->BSIM3V2xt * pParam->BSIM3V2xt;
if (pParam->BSIM3V2vbx > 0.0)
pParam->BSIM3V2vbx = -pParam->BSIM3V2vbx;
if (pParam->BSIM3V2vbm > 0.0)
pParam->BSIM3V2vbm = -pParam->BSIM3V2vbm;
if (!model->BSIM3V2gamma1Given)
pParam->BSIM3V2gamma1 = 5.753e-12
* sqrt(pParam->BSIM3V2npeak)
/ model->BSIM3V2cox;
if (!model->BSIM3V2gamma2Given)
pParam->BSIM3V2gamma2 = 5.753e-12
* sqrt(pParam->BSIM3V2nsub)
/ model->BSIM3V2cox;
T0 = pParam->BSIM3V2gamma1 - pParam->BSIM3V2gamma2;
T1 = sqrt(pParam->BSIM3V2phi - pParam->BSIM3V2vbx)
- pParam->BSIM3V2sqrtPhi;
T2 = sqrt(pParam->BSIM3V2phi * (pParam->BSIM3V2phi
- pParam->BSIM3V2vbm)) - pParam->BSIM3V2phi;
pParam->BSIM3V2k2 = T0 * T1 / (2.0 * T2 + pParam->BSIM3V2vbm);
pParam->BSIM3V2k1 = pParam->BSIM3V2gamma2 - 2.0
* pParam->BSIM3V2k2 * sqrt(pParam->BSIM3V2phi
- pParam->BSIM3V2vbm);
}
if (pParam->BSIM3V2k2 < 0.0)
{ T0 = 0.5 * pParam->BSIM3V2k1 / pParam->BSIM3V2k2;
pParam->BSIM3V2vbsc = 0.9 * (pParam->BSIM3V2phi - T0 * T0);
if (pParam->BSIM3V2vbsc > -3.0)
pParam->BSIM3V2vbsc = -3.0;
else if (pParam->BSIM3V2vbsc < -30.0)
pParam->BSIM3V2vbsc = -30.0;
}
else
{ pParam->BSIM3V2vbsc = -30.0;
}
if (pParam->BSIM3V2vbsc > pParam->BSIM3V2vbm)
pParam->BSIM3V2vbsc = pParam->BSIM3V2vbm;
if (!model->BSIM3V2vfbGiven)
{ if (model->BSIM3V2vth0Given)
{ pParam->BSIM3V2vfb = model->BSIM3V2type * pParam->BSIM3V2vth0
- pParam->BSIM3V2phi - pParam->BSIM3V2k1
* pParam->BSIM3V2sqrtPhi;
}
else
{ pParam->BSIM3V2vfb = -1.0;
}
}
if (!model->BSIM3V2vth0Given)
{ pParam->BSIM3V2vth0 = model->BSIM3V2type * (pParam->BSIM3V2vfb
+ pParam->BSIM3V2phi + pParam->BSIM3V2k1
* pParam->BSIM3V2sqrtPhi);
}
pParam->BSIM3V2k1ox = pParam->BSIM3V2k1 * model->BSIM3V2tox
/ model->BSIM3V2toxm;
pParam->BSIM3V2k2ox = pParam->BSIM3V2k2 * model->BSIM3V2tox
/ model->BSIM3V2toxm;
T1 = sqrt(EPSSI / EPSOX * model->BSIM3V2tox
* pParam->BSIM3V2Xdep0);
T0 = exp(-0.5 * pParam->BSIM3V2dsub * pParam->BSIM3V2leff / T1);
pParam->BSIM3V2theta0vb0 = (T0 + 2.0 * T0 * T0);
T0 = exp(-0.5 * pParam->BSIM3V2drout * pParam->BSIM3V2leff / T1);
T2 = (T0 + 2.0 * T0 * T0);
pParam->BSIM3V2thetaRout = pParam->BSIM3V2pdibl1 * T2
+ pParam->BSIM3V2pdibl2;
/* vfbzb for capMod 1, 2 & 3 - Weidong 4/1997 */
tmp = sqrt(pParam->BSIM3V2Xdep0);
tmp1 = pParam->BSIM3V2vbi - pParam->BSIM3V2phi;
tmp2 = model->BSIM3V2factor1 * tmp;
T0 = -0.5 * pParam->BSIM3V2dvt1w * pParam->BSIM3V2weff
* pParam->BSIM3V2leff / tmp2;
if (T0 > -EXP_THRESHOLD)
{ T1 = exp(T0);
T2 = T1 * (1.0 + 2.0 * T1);
}
else
{ T1 = MIN_EXP;
T2 = T1 * (1.0 + 2.0 * T1);
}
T0 = pParam->BSIM3V2dvt0w * T2;
T2 = T0 * tmp1;
T0 = -0.5 * pParam->BSIM3V2dvt1 * pParam->BSIM3V2leff / tmp2;
if (T0 > -EXP_THRESHOLD)
{ T1 = exp(T0);
T3 = T1 * (1.0 + 2.0 * T1);
}
else
{ T1 = MIN_EXP;
T3 = T1 * (1.0 + 2.0 * T1);
}
T3 = pParam->BSIM3V2dvt0 * T3 * tmp1;
T4 = model->BSIM3V2tox * pParam->BSIM3V2phi
/ (pParam->BSIM3V2weff + pParam->BSIM3V2w0);
T0 = sqrt(1.0 + pParam->BSIM3V2nlx / pParam->BSIM3V2leff);
T5 = pParam->BSIM3V2k1ox * (T0 - 1.0) * pParam->BSIM3V2sqrtPhi
+ (pParam->BSIM3V2kt1 + pParam->BSIM3V2kt1l / pParam->BSIM3V2leff)
* (TRatio - 1.0);
tmp3 = model->BSIM3V2type * pParam->BSIM3V2vth0
- T2 - T3 + pParam->BSIM3V2k3 * T4 + T5;
pParam->BSIM3V2vfbzb = tmp3 - pParam->BSIM3V2phi - pParam->BSIM3V2k1
* pParam->BSIM3V2sqrtPhi;
/* End of vfbzb */
}
/* process source/drain series resistance */
here->BSIM3V2drainConductance = model->BSIM3V2sheetResistance
* here->BSIM3V2drainSquares;
if (here->BSIM3V2drainConductance > 0.0)
here->BSIM3V2drainConductance = 1.0
/ here->BSIM3V2drainConductance;
else
here->BSIM3V2drainConductance = 0.0;
here->BSIM3V2sourceConductance = model->BSIM3V2sheetResistance
* here->BSIM3V2sourceSquares;
if (here->BSIM3V2sourceConductance > 0.0)
here->BSIM3V2sourceConductance = 1.0
/ here->BSIM3V2sourceConductance;
else
here->BSIM3V2sourceConductance = 0.0;
here->BSIM3V2cgso = pParam->BSIM3V2cgso;
here->BSIM3V2cgdo = pParam->BSIM3V2cgdo;
Nvtm = model->BSIM3V2vtm * model->BSIM3V2jctEmissionCoeff;
if ((here->BSIM3V2sourceArea <= 0.0) &&
(here->BSIM3V2sourcePerimeter <= 0.0))
{ SourceSatCurrent = 1.0e-14;
}
else
{ SourceSatCurrent = here->BSIM3V2sourceArea
* model->BSIM3V2jctTempSatCurDensity
+ here->BSIM3V2sourcePerimeter
* model->BSIM3V2jctSidewallTempSatCurDensity;
}
if ((SourceSatCurrent > 0.0) && (model->BSIM3V2ijth > 0.0))
{ here->BSIM3V2vjsm = Nvtm * log(model->BSIM3V2ijth
/ SourceSatCurrent + 1.0);
}
if ((here->BSIM3V2drainArea <= 0.0) &&
(here->BSIM3V2drainPerimeter <= 0.0))
{ DrainSatCurrent = 1.0e-14;
}
else
{ DrainSatCurrent = here->BSIM3V2drainArea
* model->BSIM3V2jctTempSatCurDensity
+ here->BSIM3V2drainPerimeter
* model->BSIM3V2jctSidewallTempSatCurDensity;
}
if ((DrainSatCurrent > 0.0) && (model->BSIM3V2ijth > 0.0))
{ here->BSIM3V2vjdm = Nvtm * log(model->BSIM3V2ijth
/ DrainSatCurrent + 1.0);
}
}
}
return(OK);
}

52
src/spicelib/devices/bsim3v2/b3v2trunc.c
View File

@ -1,52 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1995 Min-Chie Jeng and Mansun Chan.
File: b3v2trunc.c
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "bsim3v2def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM3V2trunc(inModel,ckt,timeStep)
GENmodel *inModel;
CKTcircuit *ckt;
double *timeStep;
{
BSIM3V2model *model = (BSIM3V2model*)inModel;
BSIM3V2instance *here;
#ifdef STEPDEBUG
double debugtemp;
#endif /* STEPDEBUG */
for (; model != NULL; model = model->BSIM3V2nextModel)
{ for (here = model->BSIM3V2instances; here != NULL;
here = here->BSIM3V2nextInstance)
{
if (here->BSIM3V2owner != ARCHme) continue;
#ifdef STEPDEBUG
debugtemp = *timeStep;
#endif /* STEPDEBUG */
CKTterr(here->BSIM3V2qb,ckt,timeStep);
CKTterr(here->BSIM3V2qg,ckt,timeStep);
CKTterr(here->BSIM3V2qd,ckt,timeStep);
#ifdef STEPDEBUG
if(debugtemp != *timeStep)
{ printf("device %s reduces step from %g to %g\n",
here->BSIM3V2name,debugtemp,*timeStep);
}
#endif /* STEPDEBUG */
}
}
return(OK);
}

1756
src/spicelib/devices/bsim3v2/bsim3v2def.h
View File

File diff suppressed because it is too large Load Diff

53
src/spicelib/devices/bsim3v2/bsim3v2ext.h
View File

@ -1,53 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1991 JianHui Huang and Min-Chie Jeng.
File: bsim3v2ext.h
**********/
#ifdef __STDC__
extern int BSIM3V2acLoad(GENmodel *,CKTcircuit*);
extern int BSIM3V2ask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*);
extern int BSIM3V2convTest(GENmodel *,CKTcircuit*);
extern int BSIM3V2delete(GENmodel*,IFuid,GENinstance**);
extern void BSIM3V2destroy(GENmodel**);
extern int BSIM3V2getic(GENmodel*,CKTcircuit*);
extern int BSIM3V2load(GENmodel*,CKTcircuit*);
extern int BSIM3V2mAsk(CKTcircuit*,GENmodel *,int, IFvalue*);
extern int BSIM3V2mDelete(GENmodel**,IFuid,GENmodel*);
extern int BSIM3V2mParam(int,IFvalue*,GENmodel*);
extern void BSIM3V2mosCap(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 BSIM3V2param(int,IFvalue*,GENinstance*,IFvalue*);
extern int BSIM3V2pzLoad(GENmodel*,CKTcircuit*,SPcomplex*);
extern int BSIM3V2setup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
extern int BSIM3V2unsetup(GENmodel*,CKTcircuit*);
extern int BSIM3V2temp(GENmodel*,CKTcircuit*);
extern int BSIM3V2trunc(GENmodel*,CKTcircuit*,double*);
extern int BSIM3V2noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
#else /* stdc */
extern int BSIM3V2acLoad();
extern int BSIM3V2delete();
extern void BSIM3V2destroy();
extern int BSIM3V2getic();
extern int BSIM3V2load();
extern int BSIM3V2mDelete();
extern int BSIM3V2ask();
extern int BSIM3V2mAsk();
extern int BSIM3V2convTest();
extern int BSIM3V2temp();
extern int BSIM3V2mParam();
extern void BSIM3V2mosCap();
extern int BSIM3V2param();
extern int BSIM3V2pzLoad();
extern int BSIM3V2setup();
extern int BSIM3V2unsetup();
extern int BSIM3V2trunc();
extern int BSIM3V2noise();
#endif /* stdc */

80
src/spicelib/devices/bsim3v2/bsim3v2init.c
View File

@ -1,80 +0,0 @@
#include <config.h>
#include <devdefs.h>
#include "bsim3v2itf.h"
#include "bsim3v2ext.h"
#include "bsim3v2init.h"
SPICEdev BSIM3V2info = {
{ "BSIM3V2",
"Berkeley Short Channel IGFET Model Version-3 (3v3.2)",
&BSIM3V2nSize,
&BSIM3V2nSize,
BSIM3V2names,
&BSIM3V2pTSize,
BSIM3V2pTable,
&BSIM3V2mPTSize,
BSIM3V2mPTable,
#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 : BSIM3V2param,
DEVmodParam : BSIM3V2mParam,
DEVload : BSIM3V2load,
DEVsetup : BSIM3V2setup,
DEVunsetup : BSIM3V2unsetup,
DEVpzSetup : BSIM3V2setup,
DEVtemperature: BSIM3V2temp,
DEVtrunc : BSIM3V2trunc,
DEVfindBranch : NULL,
DEVacLoad : BSIM3V2acLoad,
DEVaccept : NULL,
DEVdestroy : BSIM3V2destroy,
DEVmodDelete : BSIM3V2mDelete,
DEVdelete : BSIM3V2delete,
DEVsetic : BSIM3V2getic,
DEVask : BSIM3V2ask,
DEVmodAsk : BSIM3V2mAsk,
DEVpzLoad : BSIM3V2pzLoad,
DEVconvTest : BSIM3V2convTest,
DEVsenSetup : NULL,
DEVsenLoad : NULL,
DEVsenUpdate : NULL,
DEVsenAcLoad : NULL,
DEVsenPrint : NULL,
DEVsenTrunc : NULL,
DEVdisto : NULL,
DEVnoise : BSIM3V2noise,
DEVinstSize : &BSIM3V2iSize,
DEVmodSize : &BSIM3V2mSize
};
SPICEdev *
get_bsim3v2_info(void)
{
return &BSIM3V2info;
}

13
src/spicelib/devices/bsim3v2/bsim3v2init.h
View File

@ -1,13 +0,0 @@
#ifndef _BSIM3V2INIT_H
#define _BSIM3V2INIT_H
extern IFparm BSIM3V2pTable[ ];
extern IFparm BSIM3V2mPTable[ ];
extern char *BSIM3V2names[ ];
extern int BSIM3V2pTSize;
extern int BSIM3V2mPTSize;
extern int BSIM3V2nSize;
extern int BSIM3V2iSize;
extern int BSIM3V2mSize;
#endif

11
src/spicelib/devices/bsim3v2/bsim3v2itf.h
View File

@ -1,11 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1991 JianHui Huang and Min-Chie Jeng.
File: bsim3v2itf.h
**********/
#ifndef DEV_BSIM3V2
#define DEV_BSIM3V2
SPICEdev *get_bsim3v2_info(void);
#endif