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

bsim4v4 version code added

This commit is contained in:
dwarning 2007-10-31 07:22:05 +00:00
parent b20af86749
commit 4ec429100f
33 changed files with 21145 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
configure.in
View File

@ -812,6 +812,7 @@ src/spicelib/devices/bsim3v1a/Makefile \
src/spicelib/devices/bsim3v1s/Makefile \
src/spicelib/devices/bsim3/Makefile \
src/spicelib/devices/bsim4/Makefile \
src/spicelib/devices/bsim4v4/Makefile \
src/spicelib/devices/bsim3soi/Makefile \
src/spicelib/devices/bsim3soi_pd/Makefile \
src/spicelib/devices/bsim3soi_fd/Makefile \

1
src/Makefile.am
View File

@ -34,6 +34,7 @@ DYNAMIC_DEVICELIBS = \
spicelib/devices/bsim3v1s/libbsim3v1s.a \
spicelib/devices/bsim3v1a/libbsim3v1a.a \
spicelib/devices/bsim4/libbsim4.a \
spicelib/devices/bsim4v4/libbsim4v4.a \
spicelib/devices/cap/libcap.a \
spicelib/devices/bsim3soi/libbsim3soi.a \
spicelib/devices/bsim3soi_pd/libbsim3soipd.a \

2
src/spicelib/devices/Makefile.am
View File

@ -9,6 +9,7 @@ SUBDIRS = \
bsim3 \
bsim3soi \
bsim4 \
bsim4v4 \
bsim3v0 \
bsim3v1 \
bsim3v1s \
@ -61,6 +62,7 @@ DIST_SUBDIRS = \
bsim3 \
bsim3soi \
bsim4 \
bsim4v4 \
bsim3v0 \
bsim3v1 \
bsim3v1s \

0
src/spicelib/devices/bsim4v4/ChangeLog Normal file
View File

35
src/spicelib/devices/bsim4v4/Makefile.am Normal file
View File

@ -0,0 +1,35 @@
## Process this file with automake to produce Makefile.in
pkglib_LIBRARIES = libbsim4v4.a
libbsim4v4_a_SOURCES = \
b4v4.c \
b4v4acld.c \
b4v4ask.c \
b4v4check.c \
b4v4cvtest.c \
b4v4del.c \
b4v4dest.c \
b4v4geo.c \
b4v4getic.c \
b4v4ld.c \
b4v4mask.c \
b4v4mdel.c \
b4v4mpar.c \
b4v4noi.c \
b4v4par.c \
b4v4pzld.c \
b4v4set.c \
b4v4temp.c \
b4v4trunc.c \
bsim4v4def.h \
bsim4v4ext.h \
bsim4v4init.c \
bsim4v4init.h \
bsim4v4itf.h
INCLUDES = -I$(top_srcdir)/src/include
MAINTAINERCLEANFILES = Makefile.in

824
src/spicelib/devices/bsim4v4/b4v4.c Normal file
View File

@ -0,0 +1,824 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
* Modified by Xuemei Xi, 04/06/2001.
* Modified by Xuemei Xi, 10/05/2001.
* Modified by Xuemei Xi, 11/15/2002.
* Modified by Xuemei Xi, 05/09/2003.
* Modified by Xuemei Xi, 03/04/2004.
**********/
#include "ngspice.h"
#include "devdefs.h"
#include "bsim4v4def.h"
#include "suffix.h"
IFparm BSIM4V4pTable[] = { /* parameters */
IOP( "l", BSIM4V4_L, IF_REAL , "Length"),
IOP( "w", BSIM4V4_W, IF_REAL , "Width"),
IOP( "m", BSIM4V4_M, IF_REAL , "Separate Parallel multiplier"),
IOP( "nf", BSIM4V4_NF, IF_REAL , "Number of fingers"),
IOP( "sa", BSIM4V4_SA, IF_REAL , "distance between OD edge to poly of one side "),
IOP( "sb", BSIM4V4_SB, IF_REAL , "distance between OD edge to poly of the other side"),
IOP( "sd", BSIM4V4_SD, IF_REAL , "distance between neighbour fingers"),
IOP( "min", BSIM4V4_MIN, IF_INTEGER , "Minimize either D or S"),
IOP( "ad", BSIM4V4_AD, IF_REAL , "Drain area"),
IOP( "as", BSIM4V4_AS, IF_REAL , "Source area"),
IOP( "pd", BSIM4V4_PD, IF_REAL , "Drain perimeter"),
IOP( "ps", BSIM4V4_PS, IF_REAL , "Source perimeter"),
IOP( "nrd", BSIM4V4_NRD, IF_REAL , "Number of squares in drain"),
IOP( "nrs", BSIM4V4_NRS, IF_REAL , "Number of squares in source"),
IOP( "off", BSIM4V4_OFF, IF_FLAG , "Device is initially off"),
IOP( "rbdb", BSIM4V4_RBDB, IF_REAL , "Body resistance"),
IOP( "rbsb", BSIM4V4_RBSB, IF_REAL , "Body resistance"),
IOP( "rbpb", BSIM4V4_RBPB, IF_REAL , "Body resistance"),
IOP( "rbps", BSIM4V4_RBPS, IF_REAL , "Body resistance"),
IOP( "rbpd", BSIM4V4_RBPD, IF_REAL , "Body resistance"),
IOP( "trnqsmod", BSIM4V4_TRNQSMOD, IF_INTEGER, "Transient NQS model selector"),
IOP( "acnqsmod", BSIM4V4_ACNQSMOD, IF_INTEGER, "AC NQS model selector"),
IOP( "rbodymod", BSIM4V4_RBODYMOD, IF_INTEGER, "Distributed body R model selector"),
IOP( "rgatemod", BSIM4V4_RGATEMOD, IF_INTEGER, "Gate resistance model selector"),
IOP( "geomod", BSIM4V4_GEOMOD, IF_INTEGER, "Geometry dependent parasitics model selector"),
IOP( "rgeomod", BSIM4V4_RGEOMOD, IF_INTEGER, "S/D resistance and contact model selector"),
IP( "ic", BSIM4V4_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"),
OP( "gmbs", BSIM4V4_GMBS, IF_REAL, "Gmb"),
OP( "gm", BSIM4V4_GM, IF_REAL, "Gm"),
OP( "gds", BSIM4V4_GDS, IF_REAL, "Gds"),
OP( "vdsat", BSIM4V4_VDSAT, IF_REAL, "Vdsat"),
OP( "vth", BSIM4V4_VON, IF_REAL, "Vth"),
OP( "id", BSIM4V4_CD, IF_REAL, "Ids"),
OP( "ibd", BSIM4V4_CBD, IF_REAL, "Ibd"),
OP( "ibs", BSIM4V4_CBS, IF_REAL, "Ibs"),
OP( "gbd", BSIM4V4_GBD, IF_REAL, "gbd"),
OP( "gbs", BSIM4V4_GBS, IF_REAL, "gbs"),
OP( "isub", BSIM4V4_CSUB, IF_REAL, "Isub"),
OP( "igidl", BSIM4V4_IGIDL, IF_REAL, "Igidl"),
OP( "igisl", BSIM4V4_IGISL, IF_REAL, "Igisl"),
OP( "igs", BSIM4V4_IGS, IF_REAL, "Igs"),
OP( "igd", BSIM4V4_IGD, IF_REAL, "Igd"),
OP( "igb", BSIM4V4_IGB, IF_REAL, "Igb"),
OP( "igcs", BSIM4V4_IGCS, IF_REAL, "Igcs"),
OP( "igcd", BSIM4V4_IGCD, IF_REAL, "Igcd"),
OP( "vbs", BSIM4V4_VBS, IF_REAL, "Vbs"),
OP( "vgs", BSIM4V4_VGS, IF_REAL, "Vgs"),
OP( "vds", BSIM4V4_VDS, IF_REAL, "Vds"),
OP( "cgg", BSIM4V4_CGGB, IF_REAL, "Cggb"),
OP( "cgs", BSIM4V4_CGSB, IF_REAL, "Cgsb"),
OP( "cgd", BSIM4V4_CGDB, IF_REAL, "Cgdb"),
OP( "cbg", BSIM4V4_CBGB, IF_REAL, "Cbgb"),
OP( "cbd", BSIM4V4_CBDB, IF_REAL, "Cbdb"),
OP( "cbs", BSIM4V4_CBSB, IF_REAL, "Cbsb"),
OP( "cdg", BSIM4V4_CDGB, IF_REAL, "Cdgb"),
OP( "cdd", BSIM4V4_CDDB, IF_REAL, "Cddb"),
OP( "cds", BSIM4V4_CDSB, IF_REAL, "Cdsb"),
OP( "csg", BSIM4V4_CSGB, IF_REAL, "Csgb"),
OP( "csd", BSIM4V4_CSDB, IF_REAL, "Csdb"),
OP( "css", BSIM4V4_CSSB, IF_REAL, "Cssb"),
OP( "cgb", BSIM4V4_CGBB, IF_REAL, "Cgbb"),
OP( "cdb", BSIM4V4_CDBB, IF_REAL, "Cdbb"),
OP( "csb", BSIM4V4_CSBB, IF_REAL, "Csbb"),
OP( "cbb", BSIM4V4_CBBB, IF_REAL, "Cbbb"),
OP( "capbd", BSIM4V4_CAPBD, IF_REAL, "Capbd"),
OP( "capbs", BSIM4V4_CAPBS, IF_REAL, "Capbs"),
OP( "qg", BSIM4V4_QG, IF_REAL, "Qgate"),
OP( "qb", BSIM4V4_QB, IF_REAL, "Qbulk"),
OP( "qd", BSIM4V4_QD, IF_REAL, "Qdrain"),
OP( "qs", BSIM4V4_QS, IF_REAL, "Qsource"),
OP( "qinv", BSIM4V4_QINV, IF_REAL, "Qinversion"),
};
IFparm BSIM4V4mPTable[] = { /* model parameters */
IOP( "rgeomod", BSIM4V4_MOD_RGEOMOD, IF_INTEGER, "S/D resistance and contact model selector"),
IOP( "capmod", BSIM4V4_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"),
IOP( "diomod", BSIM4V4_MOD_DIOMOD, IF_INTEGER, "Diode IV model selector"),
IOP( "rdsmod", BSIM4V4_MOD_RDSMOD, IF_INTEGER, "Bias-dependent S/D resistance model selector"),
IOP( "trnqsmod", BSIM4V4_MOD_TRNQSMOD, IF_INTEGER, "Transient NQS model selector"),
IOP( "acnqsmod", BSIM4V4_MOD_ACNQSMOD, IF_INTEGER, "AC NQS model selector"),
IOP( "mobmod", BSIM4V4_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"),
IOP( "rbodymod", BSIM4V4_MOD_RBODYMOD, IF_INTEGER, "Distributed body R model selector"),
IOP( "rgatemod", BSIM4V4_MOD_RGATEMOD, IF_INTEGER, "Gate R model selector"),
IOP( "permod", BSIM4V4_MOD_PERMOD, IF_INTEGER, "Pd and Ps model selector"),
IOP( "geomod", BSIM4V4_MOD_GEOMOD, IF_INTEGER, "Geometry dependent parasitics model selector"),
IOP( "fnoimod", BSIM4V4_MOD_FNOIMOD, IF_INTEGER, "Flicker noise model selector"),
IOP( "tnoimod", BSIM4V4_MOD_TNOIMOD, IF_INTEGER, "Thermal noise model selector"),
IOP( "igcmod", BSIM4V4_MOD_IGCMOD, IF_INTEGER, "Gate-to-channel Ig model selector"),
IOP( "igbmod", BSIM4V4_MOD_IGBMOD, IF_INTEGER, "Gate-to-body Ig model selector"),
IOP( "tempmod", BSIM4V4_MOD_TEMPMOD, IF_INTEGER, "Temperature model selector"),
IOP( "paramchk", BSIM4V4_MOD_PARAMCHK, IF_INTEGER, "Model parameter checking selector"),
IOP( "binunit", BSIM4V4_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"),
IOP( "version", BSIM4V4_MOD_VERSION, IF_STRING, "parameter for model version"),
IOP( "toxe", BSIM4V4_MOD_TOXE, IF_REAL, "Electrical gate oxide thickness in meters"),
IOP( "toxp", BSIM4V4_MOD_TOXP, IF_REAL, "Physical gate oxide thickness in meters"),
IOP( "toxm", BSIM4V4_MOD_TOXM, IF_REAL, "Gate oxide thickness at which parameters are extracted"),
IOP( "toxref", BSIM4V4_MOD_TOXREF, IF_REAL, "Target tox value"),
IOP( "dtox", BSIM4V4_MOD_DTOX, IF_REAL, "Defined as (toxe - toxp) "),
IOP( "epsrox", BSIM4V4_MOD_EPSROX, IF_REAL, "Dielectric constant of the gate oxide relative to vacuum"),
IOP( "cdsc", BSIM4V4_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"),
IOP( "cdscb", BSIM4V4_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"),
IOP( "cdscd", BSIM4V4_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"),
IOP( "cit", BSIM4V4_MOD_CIT, IF_REAL, "Interface state capacitance"),
IOP( "nfactor", BSIM4V4_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"),
IOP( "xj", BSIM4V4_MOD_XJ, IF_REAL, "Junction depth in meters"),
IOP( "vsat", BSIM4V4_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"),
IOP( "at", BSIM4V4_MOD_AT, IF_REAL, "Temperature coefficient of vsat"),
IOP( "a0", BSIM4V4_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."),
IOP( "ags", BSIM4V4_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."),
IOP( "a1", BSIM4V4_MOD_A1, IF_REAL, "Non-saturation effect coefficient"),
IOP( "a2", BSIM4V4_MOD_A2, IF_REAL, "Non-saturation effect coefficient"),
IOP( "keta", BSIM4V4_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."),
IOP( "nsub", BSIM4V4_MOD_NSUB, IF_REAL, "Substrate doping concentration"),
IOP( "ndep", BSIM4V4_MOD_NDEP, IF_REAL, "Channel doping concentration at the depletion edge"),
IOP( "nsd", BSIM4V4_MOD_NSD, IF_REAL, "S/D doping concentration"),
IOP( "phin", BSIM4V4_MOD_PHIN, IF_REAL, "Adjusting parameter for surface potential due to non-uniform vertical doping"),
IOP( "ngate", BSIM4V4_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"),
IOP( "gamma1", BSIM4V4_MOD_GAMMA1, IF_REAL, "Vth body coefficient"),
IOP( "gamma2", BSIM4V4_MOD_GAMMA2, IF_REAL, "Vth body coefficient"),
IOP( "vbx", BSIM4V4_MOD_VBX, IF_REAL, "Vth transition body Voltage"),
IOP( "vbm", BSIM4V4_MOD_VBM, IF_REAL, "Maximum body voltage"),
IOP( "xt", BSIM4V4_MOD_XT, IF_REAL, "Doping depth"),
IOP( "k1", BSIM4V4_MOD_K1, IF_REAL, "Bulk effect coefficient 1"),
IOP( "kt1", BSIM4V4_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt1l", BSIM4V4_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt2", BSIM4V4_MOD_KT2, IF_REAL, "Body-coefficient of kt1"),
IOP( "k2", BSIM4V4_MOD_K2, IF_REAL, "Bulk effect coefficient 2"),
IOP( "k3", BSIM4V4_MOD_K3, IF_REAL, "Narrow width effect coefficient"),
IOP( "k3b", BSIM4V4_MOD_K3B, IF_REAL, "Body effect coefficient of k3"),
IOP( "w0", BSIM4V4_MOD_W0, IF_REAL, "Narrow width effect parameter"),
IOP( "dvtp0", BSIM4V4_MOD_DVTP0, IF_REAL, "First parameter for Vth shift due to pocket"),
IOP( "dvtp1", BSIM4V4_MOD_DVTP1, IF_REAL, "Second parameter for Vth shift due to pocket"),
IOP( "lpe0", BSIM4V4_MOD_LPE0, IF_REAL, "Equivalent length of pocket region at zero bias"),
IOP( "lpeb", BSIM4V4_MOD_LPEB, IF_REAL, "Equivalent length of pocket region accounting for body bias"),
IOP( "dvt0", BSIM4V4_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"),
IOP( "dvt1", BSIM4V4_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"),
IOP( "dvt2", BSIM4V4_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"),
IOP( "dvt0w", BSIM4V4_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"),
IOP( "dvt1w", BSIM4V4_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"),
IOP( "dvt2w", BSIM4V4_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"),
IOP( "drout", BSIM4V4_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"),
IOP( "dsub", BSIM4V4_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"),
IOP( "vth0", BSIM4V4_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "vtho", BSIM4V4_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "ua", BSIM4V4_MOD_UA, IF_REAL, "Linear gate dependence of mobility"),
IOP( "ua1", BSIM4V4_MOD_UA1, IF_REAL, "Temperature coefficient of ua"),
IOP( "ub", BSIM4V4_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"),
IOP( "ub1", BSIM4V4_MOD_UB1, IF_REAL, "Temperature coefficient of ub"),
IOP( "uc", BSIM4V4_MOD_UC, IF_REAL, "Body-bias dependence of mobility"),
IOP( "uc1", BSIM4V4_MOD_UC1, IF_REAL, "Temperature coefficient of uc"),
IOP( "u0", BSIM4V4_MOD_U0, IF_REAL, "Low-field mobility at Tnom"),
IOP( "eu", BSIM4V4_MOD_EU, IF_REAL, "Mobility exponent"),
IOP( "ute", BSIM4V4_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"),
IOP( "voff", BSIM4V4_MOD_VOFF, IF_REAL, "Threshold voltage offset"),
IOP( "minv", BSIM4V4_MOD_MINV, IF_REAL, "Fitting parameter for moderate invversion in Vgsteff"),
IOP( "voffl", BSIM4V4_MOD_VOFFL, IF_REAL, "Length dependence parameter for Vth offset"),
IOP( "tnom", BSIM4V4_MOD_TNOM, IF_REAL, "Parameter measurement temperature"),
IOP( "cgso", BSIM4V4_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"),
IOP( "cgdo", BSIM4V4_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"),
IOP( "cgbo", BSIM4V4_MOD_CGBO, IF_REAL, "Gate-bulk overlap capacitance per length"),
IOP( "xpart", BSIM4V4_MOD_XPART, IF_REAL, "Channel charge partitioning"),
IOP( "delta", BSIM4V4_MOD_DELTA, IF_REAL, "Effective Vds parameter"),
IOP( "rsh", BSIM4V4_MOD_RSH, IF_REAL, "Source-drain sheet resistance"),
IOP( "rdsw", BSIM4V4_MOD_RDSW, IF_REAL, "Source-drain resistance per width"),
IOP( "rdswmin", BSIM4V4_MOD_RDSWMIN, IF_REAL, "Source-drain resistance per width at high Vg"),
IOP( "rsw", BSIM4V4_MOD_RSW, IF_REAL, "Source resistance per width"),
IOP( "rdw", BSIM4V4_MOD_RDW, IF_REAL, "Drain resistance per width"),
IOP( "rdwmin", BSIM4V4_MOD_RDWMIN, IF_REAL, "Drain resistance per width at high Vg"),
IOP( "rswmin", BSIM4V4_MOD_RSWMIN, IF_REAL, "Source resistance per width at high Vg"),
IOP( "prwg", BSIM4V4_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "),
IOP( "prwb", BSIM4V4_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "),
IOP( "prt", BSIM4V4_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "),
IOP( "eta0", BSIM4V4_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "etab", BSIM4V4_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "pclm", BSIM4V4_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"),
IOP( "pdiblc1", BSIM4V4_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblc2", BSIM4V4_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblcb", BSIM4V4_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"),
IOP( "fprout", BSIM4V4_MOD_FPROUT, IF_REAL, "Rout degradation coefficient for pocket devices"),
IOP( "pdits", BSIM4V4_MOD_PDITS, IF_REAL, "Coefficient for drain-induced Vth shifts"),
IOP( "pditsl", BSIM4V4_MOD_PDITSL, IF_REAL, "Length dependence of drain-induced Vth shifts"),
IOP( "pditsd", BSIM4V4_MOD_PDITSD, IF_REAL, "Vds dependence of drain-induced Vth shifts"),
IOP( "pscbe1", BSIM4V4_MOD_PSCBE1, IF_REAL, "Substrate current body-effect coefficient"),
IOP( "pscbe2", BSIM4V4_MOD_PSCBE2, IF_REAL, "Substrate current body-effect coefficient"),
IOP( "pvag", BSIM4V4_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"),
IOP( "jss", BSIM4V4_MOD_JSS, IF_REAL, "Bottom source junction reverse saturation current density"),
IOP( "jsws", BSIM4V4_MOD_JSWS, IF_REAL, "Isolation edge sidewall source junction reverse saturation current density"),
IOP( "jswgs", BSIM4V4_MOD_JSWGS, IF_REAL, "Gate edge source junction reverse saturation current density"),
IOP( "pbs", BSIM4V4_MOD_PBS, IF_REAL, "Source junction built-in potential"),
IOP( "njs", BSIM4V4_MOD_NJS, IF_REAL, "Source junction emission coefficient"),
IOP( "xtis", BSIM4V4_MOD_XTIS, IF_REAL, "Source junction current temperature exponent"),
IOP( "mjs", BSIM4V4_MOD_MJS, IF_REAL, "Source bottom junction capacitance grading coefficient"),
IOP( "pbsws", BSIM4V4_MOD_PBSWS, IF_REAL, "Source sidewall junction capacitance built in potential"),
IOP( "mjsws", BSIM4V4_MOD_MJSWS, IF_REAL, "Source sidewall junction capacitance grading coefficient"),
IOP( "pbswgs", BSIM4V4_MOD_PBSWGS, IF_REAL, "Source (gate side) sidewall junction capacitance built in potential"),
IOP( "mjswgs", BSIM4V4_MOD_MJSWGS, IF_REAL, "Source (gate side) sidewall junction capacitance grading coefficient"),
IOP( "cjs", BSIM4V4_MOD_CJS, IF_REAL, "Source bottom junction capacitance per unit area"),
IOP( "cjsws", BSIM4V4_MOD_CJSWS, IF_REAL, "Source sidewall junction capacitance per unit periphery"),
IOP( "cjswgs", BSIM4V4_MOD_CJSWGS, IF_REAL, "Source (gate side) sidewall junction capacitance per unit width"),
IOP( "jsd", BSIM4V4_MOD_JSD, IF_REAL, "Bottom drain junction reverse saturation current density"),
IOP( "jswd", BSIM4V4_MOD_JSWD, IF_REAL, "Isolation edge sidewall drain junction reverse saturation current density"),
IOP( "jswgd", BSIM4V4_MOD_JSWGD, IF_REAL, "Gate edge drain junction reverse saturation current density"),
IOP( "pbd", BSIM4V4_MOD_PBD, IF_REAL, "Drain junction built-in potential"),
IOP( "njd", BSIM4V4_MOD_NJD, IF_REAL, "Drain junction emission coefficient"),
IOP( "xtid", BSIM4V4_MOD_XTID, IF_REAL, "Drainjunction current temperature exponent"),
IOP( "mjd", BSIM4V4_MOD_MJD, IF_REAL, "Drain bottom junction capacitance grading coefficient"),
IOP( "pbswd", BSIM4V4_MOD_PBSWD, IF_REAL, "Drain sidewall junction capacitance built in potential"),
IOP( "mjswd", BSIM4V4_MOD_MJSWD, IF_REAL, "Drain sidewall junction capacitance grading coefficient"),
IOP( "pbswgd", BSIM4V4_MOD_PBSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance built in potential"),
IOP( "mjswgd", BSIM4V4_MOD_MJSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance grading coefficient"),
IOP( "cjd", BSIM4V4_MOD_CJD, IF_REAL, "Drain bottom junction capacitance per unit area"),
IOP( "cjswd", BSIM4V4_MOD_CJSWD, IF_REAL, "Drain sidewall junction capacitance per unit periphery"),
IOP( "cjswgd", BSIM4V4_MOD_CJSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance per unit width"),
IOP( "vfbcv", BSIM4V4_MOD_VFBCV, IF_REAL, "Flat Band Voltage parameter for capmod=0 only"),
IOP( "vfb", BSIM4V4_MOD_VFB, IF_REAL, "Flat Band Voltage"),
IOP( "tpb", BSIM4V4_MOD_TPB, IF_REAL, "Temperature coefficient of pb"),
IOP( "tcj", BSIM4V4_MOD_TCJ, IF_REAL, "Temperature coefficient of cj"),
IOP( "tpbsw", BSIM4V4_MOD_TPBSW, IF_REAL, "Temperature coefficient of pbsw"),
IOP( "tcjsw", BSIM4V4_MOD_TCJSW, IF_REAL, "Temperature coefficient of cjsw"),
IOP( "tpbswg", BSIM4V4_MOD_TPBSWG, IF_REAL, "Temperature coefficient of pbswg"),
IOP( "tcjswg", BSIM4V4_MOD_TCJSWG, IF_REAL, "Temperature coefficient of cjswg"),
IOP( "acde", BSIM4V4_MOD_ACDE, IF_REAL, "Exponential coefficient for finite charge thickness"),
IOP( "moin", BSIM4V4_MOD_MOIN, IF_REAL, "Coefficient for gate-bias dependent surface potential"),
IOP( "noff", BSIM4V4_MOD_NOFF, IF_REAL, "C-V turn-on/off parameter"),
IOP( "voffcv", BSIM4V4_MOD_VOFFCV, IF_REAL, "C-V lateral-shift parameter"),
IOP( "dmcg", BSIM4V4_MOD_DMCG, IF_REAL, "Distance of Mid-Contact to Gate edge"),
IOP( "dmci", BSIM4V4_MOD_DMCI, IF_REAL, "Distance of Mid-Contact to Isolation"),
IOP( "dmdg", BSIM4V4_MOD_DMDG, IF_REAL, "Distance of Mid-Diffusion to Gate edge"),
IOP( "dmcgt", BSIM4V4_MOD_DMCGT, IF_REAL, "Distance of Mid-Contact to Gate edge in Test structures"),
IOP( "xgw", BSIM4V4_MOD_XGW, IF_REAL, "Distance from gate contact center to device edge"),
IOP( "xgl", BSIM4V4_MOD_XGL, IF_REAL, "Variation in Ldrawn"),
IOP( "rshg", BSIM4V4_MOD_RSHG, IF_REAL, "Gate sheet resistance"),
IOP( "ngcon", BSIM4V4_MOD_NGCON, IF_REAL, "Number of gate contacts"),
IOP( "xrcrg1", BSIM4V4_MOD_XRCRG1, IF_REAL, "First fitting parameter the bias-dependent Rg"),
IOP( "xrcrg2", BSIM4V4_MOD_XRCRG2, IF_REAL, "Second fitting parameter the bias-dependent Rg"),
IOP( "lambda", BSIM4V4_MOD_LAMBDA, IF_REAL, " Velocity overshoot parameter"),
IOP( "vtl", BSIM4V4_MOD_VTL, IF_REAL, " thermal velocity"),
IOP( "lc", BSIM4V4_MOD_LC, IF_REAL, " back scattering parameter"),
IOP( "xn", BSIM4V4_MOD_XN, IF_REAL, " back scattering parameter"),
IOP( "vfbsdoff", BSIM4V4_MOD_VFBSDOFF, IF_REAL, "S/D flatband voltage offset"),
IOP( "lintnoi", BSIM4V4_MOD_LINTNOI, IF_REAL, "lint offset for noise calculation"),
IOP( "lint", BSIM4V4_MOD_LINT, IF_REAL, "Length reduction parameter"),
IOP( "ll", BSIM4V4_MOD_LL, IF_REAL, "Length reduction parameter"),
IOP( "llc", BSIM4V4_MOD_LLC, IF_REAL, "Length reduction parameter for CV"),
IOP( "lln", BSIM4V4_MOD_LLN, IF_REAL, "Length reduction parameter"),
IOP( "lw", BSIM4V4_MOD_LW, IF_REAL, "Length reduction parameter"),
IOP( "lwc", BSIM4V4_MOD_LWC, IF_REAL, "Length reduction parameter for CV"),
IOP( "lwn", BSIM4V4_MOD_LWN, IF_REAL, "Length reduction parameter"),
IOP( "lwl", BSIM4V4_MOD_LWL, IF_REAL, "Length reduction parameter"),
IOP( "lwlc", BSIM4V4_MOD_LWLC, IF_REAL, "Length reduction parameter for CV"),
IOP( "lmin", BSIM4V4_MOD_LMIN, IF_REAL, "Minimum length for the model"),
IOP( "lmax", BSIM4V4_MOD_LMAX, IF_REAL, "Maximum length for the model"),
IOP( "wr", BSIM4V4_MOD_WR, IF_REAL, "Width dependence of rds"),
IOP( "wint", BSIM4V4_MOD_WINT, IF_REAL, "Width reduction parameter"),
IOP( "dwg", BSIM4V4_MOD_DWG, IF_REAL, "Width reduction parameter"),
IOP( "dwb", BSIM4V4_MOD_DWB, IF_REAL, "Width reduction parameter"),
IOP( "wl", BSIM4V4_MOD_WL, IF_REAL, "Width reduction parameter"),
IOP( "wlc", BSIM4V4_MOD_WLC, IF_REAL, "Width reduction parameter for CV"),
IOP( "wln", BSIM4V4_MOD_WLN, IF_REAL, "Width reduction parameter"),
IOP( "ww", BSIM4V4_MOD_WW, IF_REAL, "Width reduction parameter"),
IOP( "wwc", BSIM4V4_MOD_WWC, IF_REAL, "Width reduction parameter for CV"),
IOP( "wwn", BSIM4V4_MOD_WWN, IF_REAL, "Width reduction parameter"),
IOP( "wwl", BSIM4V4_MOD_WWL, IF_REAL, "Width reduction parameter"),
IOP( "wwlc", BSIM4V4_MOD_WWLC, IF_REAL, "Width reduction parameter for CV"),
IOP( "wmin", BSIM4V4_MOD_WMIN, IF_REAL, "Minimum width for the model"),
IOP( "wmax", BSIM4V4_MOD_WMAX, IF_REAL, "Maximum width for the model"),
IOP( "b0", BSIM4V4_MOD_B0, IF_REAL, "Abulk narrow width parameter"),
IOP( "b1", BSIM4V4_MOD_B1, IF_REAL, "Abulk narrow width parameter"),
IOP( "cgsl", BSIM4V4_MOD_CGSL, IF_REAL, "New C-V model parameter"),
IOP( "cgdl", BSIM4V4_MOD_CGDL, IF_REAL, "New C-V model parameter"),
IOP( "ckappas", BSIM4V4_MOD_CKAPPAS, IF_REAL, "S/G overlap C-V parameter "),
IOP( "ckappad", BSIM4V4_MOD_CKAPPAD, IF_REAL, "D/G overlap C-V parameter"),
IOP( "cf", BSIM4V4_MOD_CF, IF_REAL, "Fringe capacitance parameter"),
IOP( "clc", BSIM4V4_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "cle", BSIM4V4_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "dwc", BSIM4V4_MOD_DWC, IF_REAL, "Delta W for C-V model"),
IOP( "dlc", BSIM4V4_MOD_DLC, IF_REAL, "Delta L for C-V model"),
IOP( "xw", BSIM4V4_MOD_XW, IF_REAL, "W offset for channel width due to mask/etch effect"),
IOP( "xl", BSIM4V4_MOD_XL, IF_REAL, "L offset for channel length due to mask/etch effect"),
IOP( "dlcig", BSIM4V4_MOD_DLCIG, IF_REAL, "Delta L for Ig model"),
IOP( "dwj", BSIM4V4_MOD_DWJ, IF_REAL, "Delta W for S/D junctions"),
IOP( "alpha0", BSIM4V4_MOD_ALPHA0, IF_REAL, "substrate current model parameter"),
IOP( "alpha1", BSIM4V4_MOD_ALPHA1, IF_REAL, "substrate current model parameter"),
IOP( "beta0", BSIM4V4_MOD_BETA0, IF_REAL, "substrate current model parameter"),
IOP( "agidl", BSIM4V4_MOD_AGIDL, IF_REAL, "Pre-exponential constant for GIDL"),
IOP( "bgidl", BSIM4V4_MOD_BGIDL, IF_REAL, "Exponential constant for GIDL"),
IOP( "cgidl", BSIM4V4_MOD_CGIDL, IF_REAL, "Parameter for body-bias dependence of GIDL"),
IOP( "egidl", BSIM4V4_MOD_EGIDL, IF_REAL, "Fitting parameter for Bandbending"),
IOP( "aigc", BSIM4V4_MOD_AIGC, IF_REAL, "Parameter for Igc"),
IOP( "bigc", BSIM4V4_MOD_BIGC, IF_REAL, "Parameter for Igc"),
IOP( "cigc", BSIM4V4_MOD_CIGC, IF_REAL, "Parameter for Igc"),
IOP( "aigsd", BSIM4V4_MOD_AIGSD, IF_REAL, "Parameter for Igs,d"),
IOP( "bigsd", BSIM4V4_MOD_BIGSD, IF_REAL, "Parameter for Igs,d"),
IOP( "cigsd", BSIM4V4_MOD_CIGSD, IF_REAL, "Parameter for Igs,d"),
IOP( "aigbacc", BSIM4V4_MOD_AIGBACC, IF_REAL, "Parameter for Igb"),
IOP( "bigbacc", BSIM4V4_MOD_BIGBACC, IF_REAL, "Parameter for Igb"),
IOP( "cigbacc", BSIM4V4_MOD_CIGBACC, IF_REAL, "Parameter for Igb"),
IOP( "aigbinv", BSIM4V4_MOD_AIGBINV, IF_REAL, "Parameter for Igb"),
IOP( "bigbinv", BSIM4V4_MOD_BIGBINV, IF_REAL, "Parameter for Igb"),
IOP( "cigbinv", BSIM4V4_MOD_CIGBINV, IF_REAL, "Parameter for Igb"),
IOP( "nigc", BSIM4V4_MOD_NIGC, IF_REAL, "Parameter for Igc slope"),
IOP( "nigbinv", BSIM4V4_MOD_NIGBINV, IF_REAL, "Parameter for Igbinv slope"),
IOP( "nigbacc", BSIM4V4_MOD_NIGBACC, IF_REAL, "Parameter for Igbacc slope"),
IOP( "ntox", BSIM4V4_MOD_NTOX, IF_REAL, "Exponent for Tox ratio"),
IOP( "eigbinv", BSIM4V4_MOD_EIGBINV, IF_REAL, "Parameter for the Si bandgap for Igbinv"),
IOP( "pigcd", BSIM4V4_MOD_PIGCD, IF_REAL, "Parameter for Igc partition"),
IOP( "poxedge", BSIM4V4_MOD_POXEDGE, IF_REAL, "Factor for the gate edge Tox"),
IOP( "ijthdfwd", BSIM4V4_MOD_IJTHDFWD, IF_REAL, "Forward drain diode forward limiting current"),
IOP( "ijthsfwd", BSIM4V4_MOD_IJTHSFWD, IF_REAL, "Forward source diode forward limiting current"),
IOP( "ijthdrev", BSIM4V4_MOD_IJTHDREV, IF_REAL, "Reverse drain diode forward limiting current"),
IOP( "ijthsrev", BSIM4V4_MOD_IJTHSREV, IF_REAL, "Reverse source diode forward limiting current"),
IOP( "xjbvd", BSIM4V4_MOD_XJBVD, IF_REAL, "Fitting parameter for drain diode breakdown current"),
IOP( "xjbvs", BSIM4V4_MOD_XJBVS, IF_REAL, "Fitting parameter for source diode breakdown current"),
IOP( "bvd", BSIM4V4_MOD_BVD, IF_REAL, "Drain diode breakdown voltage"),
IOP( "bvs", BSIM4V4_MOD_BVS, IF_REAL, "Source diode breakdown voltage"),
IOP( "jtss", BSIM4V4_MOD_JTSS, IF_REAL, "Source bottom trap-assisted saturation current density"),
IOP( "jtsd", BSIM4V4_MOD_JTSD, IF_REAL, "Drain bottom trap-assisted saturation current density"),
IOP( "jtssws", BSIM4V4_MOD_JTSSWS, IF_REAL, "Source STI sidewall trap-assisted saturation current density"),
IOP( "jtsswd", BSIM4V4_MOD_JTSSWD, IF_REAL, "Drain STI sidewall trap-assisted saturation current density"),
IOP( "jtsswgs", BSIM4V4_MOD_JTSSWGS, IF_REAL, "Source gate-edge sidewall trap-assisted saturation current density"),
IOP( "jtsswgd", BSIM4V4_MOD_JTSSWGD, IF_REAL, "Drain gate-edge sidewall trap-assisted saturation current density"),
IOP( "njts", BSIM4V4_MOD_NJTS, IF_REAL, "Non-ideality factor for bottom junction"),
IOP( "njtssw", BSIM4V4_MOD_NJTSSW, IF_REAL, "Non-ideality factor for STI sidewall junction"),
IOP( "njtsswg", BSIM4V4_MOD_NJTSSWG, IF_REAL, "Non-ideality factor for gate-edge sidewall junction"),
IOP( "xtss", BSIM4V4_MOD_XTSS, IF_REAL, "Power dependence of JTSS on temperature"),
IOP( "xtsd", BSIM4V4_MOD_XTSD, IF_REAL, "Power dependence of JTSD on temperature"),
IOP( "xtssws", BSIM4V4_MOD_XTSSWS, IF_REAL, "Power dependence of JTSSWS on temperature"),
IOP( "xtsswd", BSIM4V4_MOD_XTSSWD, IF_REAL, "Power dependence of JTSSWD on temperature"),
IOP( "xtsswgs", BSIM4V4_MOD_XTSSWGS, IF_REAL, "Power dependence of JTSSWGS on temperature"),
IOP( "xtsswgd", BSIM4V4_MOD_XTSSWGD, IF_REAL, "Power dependence of JTSSWGD on temperature"),
IOP( "tnjts", BSIM4V4_MOD_TNJTS, IF_REAL, "Temperature coefficient for NJTS"),
IOP( "tnjtssw", BSIM4V4_MOD_TNJTSSW, IF_REAL, "Temperature coefficient for NJTSSW"),
IOP( "tnjtsswg", BSIM4V4_MOD_TNJTSSWG, IF_REAL, "Temperature coefficient for NJTSSWG"),
IOP( "vtss", BSIM4V4_MOD_VTSS, IF_REAL, "Source bottom trap-assisted voltage dependent parameter"),
IOP( "vtsd", BSIM4V4_MOD_VTSD, IF_REAL, "Drain bottom trap-assisted voltage dependent parameter"),
IOP( "vtssws", BSIM4V4_MOD_VTSSWS, IF_REAL, "Source STI sidewall trap-assisted voltage dependent parameter"),
IOP( "vtsswd", BSIM4V4_MOD_VTSSWD, IF_REAL, "Drain STI sidewall trap-assisted voltage dependent parameter"),
IOP( "vtsswgs", BSIM4V4_MOD_VTSSWGS, IF_REAL, "Source gate-edge sidewall trap-assisted voltage dependent parameter"),
IOP( "vtsswgd", BSIM4V4_MOD_VTSSWGD, IF_REAL, "Drain gate-edge sidewall trap-assisted voltage dependent parameter"),
IOP( "gbmin", BSIM4V4_MOD_GBMIN, IF_REAL, "Minimum body conductance"),
IOP( "rbdb", BSIM4V4_MOD_RBDB, IF_REAL, "Resistance between bNode and dbNode"),
IOP( "rbpb", BSIM4V4_MOD_RBPB, IF_REAL, "Resistance between bNodePrime and bNode"),
IOP( "rbsb", BSIM4V4_MOD_RBSB, IF_REAL, "Resistance between bNode and sbNode"),
IOP( "rbps", BSIM4V4_MOD_RBPS, IF_REAL, "Resistance between bNodePrime and sbNode"),
IOP( "rbpd", BSIM4V4_MOD_RBPD, IF_REAL, "Resistance between bNodePrime and bNode"),
IOP( "lcdsc", BSIM4V4_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"),
IOP( "lcdscb", BSIM4V4_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"),
IOP( "lcdscd", BSIM4V4_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"),
IOP( "lcit", BSIM4V4_MOD_LCIT, IF_REAL, "Length dependence of cit"),
IOP( "lnfactor", BSIM4V4_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"),
IOP( "lxj", BSIM4V4_MOD_LXJ, IF_REAL, "Length dependence of xj"),
IOP( "lvsat", BSIM4V4_MOD_LVSAT, IF_REAL, "Length dependence of vsat"),
IOP( "lat", BSIM4V4_MOD_LAT, IF_REAL, "Length dependence of at"),
IOP( "la0", BSIM4V4_MOD_LA0, IF_REAL, "Length dependence of a0"),
IOP( "lags", BSIM4V4_MOD_LAGS, IF_REAL, "Length dependence of ags"),
IOP( "la1", BSIM4V4_MOD_LA1, IF_REAL, "Length dependence of a1"),
IOP( "la2", BSIM4V4_MOD_LA2, IF_REAL, "Length dependence of a2"),
IOP( "lketa", BSIM4V4_MOD_LKETA, IF_REAL, "Length dependence of keta"),
IOP( "lnsub", BSIM4V4_MOD_LNSUB, IF_REAL, "Length dependence of nsub"),
IOP( "lndep", BSIM4V4_MOD_LNDEP, IF_REAL, "Length dependence of ndep"),
IOP( "lnsd", BSIM4V4_MOD_LNSD, IF_REAL, "Length dependence of nsd"),
IOP( "lphin", BSIM4V4_MOD_LPHIN, IF_REAL, "Length dependence of phin"),
IOP( "lngate", BSIM4V4_MOD_LNGATE, IF_REAL, "Length dependence of ngate"),
IOP( "lgamma1", BSIM4V4_MOD_LGAMMA1, IF_REAL, "Length dependence of gamma1"),
IOP( "lgamma2", BSIM4V4_MOD_LGAMMA2, IF_REAL, "Length dependence of gamma2"),
IOP( "lvbx", BSIM4V4_MOD_LVBX, IF_REAL, "Length dependence of vbx"),
IOP( "lvbm", BSIM4V4_MOD_LVBM, IF_REAL, "Length dependence of vbm"),
IOP( "lxt", BSIM4V4_MOD_LXT, IF_REAL, "Length dependence of xt"),
IOP( "lk1", BSIM4V4_MOD_LK1, IF_REAL, "Length dependence of k1"),
IOP( "lkt1", BSIM4V4_MOD_LKT1, IF_REAL, "Length dependence of kt1"),
IOP( "lkt1l", BSIM4V4_MOD_LKT1L, IF_REAL, "Length dependence of kt1l"),
IOP( "lkt2", BSIM4V4_MOD_LKT2, IF_REAL, "Length dependence of kt2"),
IOP( "lk2", BSIM4V4_MOD_LK2, IF_REAL, "Length dependence of k2"),
IOP( "lk3", BSIM4V4_MOD_LK3, IF_REAL, "Length dependence of k3"),
IOP( "lk3b", BSIM4V4_MOD_LK3B, IF_REAL, "Length dependence of k3b"),
IOP( "lw0", BSIM4V4_MOD_LW0, IF_REAL, "Length dependence of w0"),
IOP( "ldvtp0", BSIM4V4_MOD_LDVTP0, IF_REAL, "Length dependence of dvtp0"),
IOP( "ldvtp1", BSIM4V4_MOD_LDVTP1, IF_REAL, "Length dependence of dvtp1"),
IOP( "llpe0", BSIM4V4_MOD_LLPE0, IF_REAL, "Length dependence of lpe0"),
IOP( "llpeb", BSIM4V4_MOD_LLPEB, IF_REAL, "Length dependence of lpeb"),
IOP( "ldvt0", BSIM4V4_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"),
IOP( "ldvt1", BSIM4V4_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"),
IOP( "ldvt2", BSIM4V4_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"),
IOP( "ldvt0w", BSIM4V4_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"),
IOP( "ldvt1w", BSIM4V4_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"),
IOP( "ldvt2w", BSIM4V4_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"),
IOP( "ldrout", BSIM4V4_MOD_LDROUT, IF_REAL, "Length dependence of drout"),
IOP( "ldsub", BSIM4V4_MOD_LDSUB, IF_REAL, "Length dependence of dsub"),
IOP( "lvth0", BSIM4V4_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOP( "lvtho", BSIM4V4_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOP( "lua", BSIM4V4_MOD_LUA, IF_REAL, "Length dependence of ua"),
IOP( "lua1", BSIM4V4_MOD_LUA1, IF_REAL, "Length dependence of ua1"),
IOP( "lub", BSIM4V4_MOD_LUB, IF_REAL, "Length dependence of ub"),
IOP( "lub1", BSIM4V4_MOD_LUB1, IF_REAL, "Length dependence of ub1"),
IOP( "luc", BSIM4V4_MOD_LUC, IF_REAL, "Length dependence of uc"),
IOP( "luc1", BSIM4V4_MOD_LUC1, IF_REAL, "Length dependence of uc1"),
IOP( "lu0", BSIM4V4_MOD_LU0, IF_REAL, "Length dependence of u0"),
IOP( "lute", BSIM4V4_MOD_LUTE, IF_REAL, "Length dependence of ute"),
IOP( "lvoff", BSIM4V4_MOD_LVOFF, IF_REAL, "Length dependence of voff"),
IOP( "lminv", BSIM4V4_MOD_LMINV, IF_REAL, "Length dependence of minv"),
IOP( "ldelta", BSIM4V4_MOD_LDELTA, IF_REAL, "Length dependence of delta"),
IOP( "lrdsw", BSIM4V4_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "),
IOP( "lrsw", BSIM4V4_MOD_LRSW, IF_REAL, "Length dependence of rsw"),
IOP( "lrdw", BSIM4V4_MOD_LRDW, IF_REAL, "Length dependence of rdw"),
IOP( "lprwg", BSIM4V4_MOD_LPRWG, IF_REAL, "Length dependence of prwg "),
IOP( "lprwb", BSIM4V4_MOD_LPRWB, IF_REAL, "Length dependence of prwb "),
IOP( "lprt", BSIM4V4_MOD_LPRT, IF_REAL, "Length dependence of prt "),
IOP( "leta0", BSIM4V4_MOD_LETA0, IF_REAL, "Length dependence of eta0"),
IOP( "letab", BSIM4V4_MOD_LETAB, IF_REAL, "Length dependence of etab"),
IOP( "lpclm", BSIM4V4_MOD_LPCLM, IF_REAL, "Length dependence of pclm"),
IOP( "lpdiblc1", BSIM4V4_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"),
IOP( "lpdiblc2", BSIM4V4_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"),
IOP( "lpdiblcb", BSIM4V4_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"),
IOP( "lfprout", BSIM4V4_MOD_LFPROUT, IF_REAL, "Length dependence of pdiblcb"),
IOP( "lpdits", BSIM4V4_MOD_LPDITS, IF_REAL, "Length dependence of pdits"),
IOP( "lpditsd", BSIM4V4_MOD_LPDITSD, IF_REAL, "Length dependence of pditsd"),
IOP( "lpscbe1", BSIM4V4_MOD_LPSCBE1, IF_REAL, "Length dependence of pscbe1"),
IOP( "lpscbe2", BSIM4V4_MOD_LPSCBE2, IF_REAL, "Length dependence of pscbe2"),
IOP( "lpvag", BSIM4V4_MOD_LPVAG, IF_REAL, "Length dependence of pvag"),
IOP( "lwr", BSIM4V4_MOD_LWR, IF_REAL, "Length dependence of wr"),
IOP( "ldwg", BSIM4V4_MOD_LDWG, IF_REAL, "Length dependence of dwg"),
IOP( "ldwb", BSIM4V4_MOD_LDWB, IF_REAL, "Length dependence of dwb"),
IOP( "lb0", BSIM4V4_MOD_LB0, IF_REAL, "Length dependence of b0"),
IOP( "lb1", BSIM4V4_MOD_LB1, IF_REAL, "Length dependence of b1"),
IOP( "lcgsl", BSIM4V4_MOD_LCGSL, IF_REAL, "Length dependence of cgsl"),
IOP( "lcgdl", BSIM4V4_MOD_LCGDL, IF_REAL, "Length dependence of cgdl"),
IOP( "lckappas", BSIM4V4_MOD_LCKAPPAS, IF_REAL, "Length dependence of ckappas"),
IOP( "lckappad", BSIM4V4_MOD_LCKAPPAD, IF_REAL, "Length dependence of ckappad"),
IOP( "lcf", BSIM4V4_MOD_LCF, IF_REAL, "Length dependence of cf"),
IOP( "lclc", BSIM4V4_MOD_LCLC, IF_REAL, "Length dependence of clc"),
IOP( "lcle", BSIM4V4_MOD_LCLE, IF_REAL, "Length dependence of cle"),
IOP( "lalpha0", BSIM4V4_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"),
IOP( "lalpha1", BSIM4V4_MOD_LALPHA1, IF_REAL, "Length dependence of alpha1"),
IOP( "lbeta0", BSIM4V4_MOD_LBETA0, IF_REAL, "Length dependence of beta0"),
IOP( "lagidl", BSIM4V4_MOD_LAGIDL, IF_REAL, "Length dependence of agidl"),
IOP( "lbgidl", BSIM4V4_MOD_LBGIDL, IF_REAL, "Length dependence of bgidl"),
IOP( "lcgidl", BSIM4V4_MOD_LCGIDL, IF_REAL, "Length dependence of cgidl"),
IOP( "legidl", BSIM4V4_MOD_LEGIDL, IF_REAL, "Length dependence of egidl"),
IOP( "laigc", BSIM4V4_MOD_LAIGC, IF_REAL, "Length dependence of aigc"),
IOP( "lbigc", BSIM4V4_MOD_LBIGC, IF_REAL, "Length dependence of bigc"),
IOP( "lcigc", BSIM4V4_MOD_LCIGC, IF_REAL, "Length dependence of cigc"),
IOP( "laigsd", BSIM4V4_MOD_LAIGSD, IF_REAL, "Length dependence of aigsd"),
IOP( "lbigsd", BSIM4V4_MOD_LBIGSD, IF_REAL, "Length dependence of bigsd"),
IOP( "lcigsd", BSIM4V4_MOD_LCIGSD, IF_REAL, "Length dependence of cigsd"),
IOP( "laigbacc", BSIM4V4_MOD_LAIGBACC, IF_REAL, "Length dependence of aigbacc"),
IOP( "lbigbacc", BSIM4V4_MOD_LBIGBACC, IF_REAL, "Length dependence of bigbacc"),
IOP( "lcigbacc", BSIM4V4_MOD_LCIGBACC, IF_REAL, "Length dependence of cigbacc"),
IOP( "laigbinv", BSIM4V4_MOD_LAIGBINV, IF_REAL, "Length dependence of aigbinv"),
IOP( "lbigbinv", BSIM4V4_MOD_LBIGBINV, IF_REAL, "Length dependence of bigbinv"),
IOP( "lcigbinv", BSIM4V4_MOD_LCIGBINV, IF_REAL, "Length dependence of cigbinv"),
IOP( "lnigc", BSIM4V4_MOD_LNIGC, IF_REAL, "Length dependence of nigc"),
IOP( "lnigbinv", BSIM4V4_MOD_LNIGBINV, IF_REAL, "Length dependence of nigbinv"),
IOP( "lnigbacc", BSIM4V4_MOD_LNIGBACC, IF_REAL, "Length dependence of nigbacc"),
IOP( "lntox", BSIM4V4_MOD_LNTOX, IF_REAL, "Length dependence of ntox"),
IOP( "leigbinv", BSIM4V4_MOD_LEIGBINV, IF_REAL, "Length dependence for eigbinv"),
IOP( "lpigcd", BSIM4V4_MOD_LPIGCD, IF_REAL, "Length dependence for pigcd"),
IOP( "lpoxedge", BSIM4V4_MOD_LPOXEDGE, IF_REAL, "Length dependence for poxedge"),
IOP( "lvfbcv", BSIM4V4_MOD_LVFBCV, IF_REAL, "Length dependence of vfbcv"),
IOP( "lvfb", BSIM4V4_MOD_LVFB, IF_REAL, "Length dependence of vfb"),
IOP( "lacde", BSIM4V4_MOD_LACDE, IF_REAL, "Length dependence of acde"),
IOP( "lmoin", BSIM4V4_MOD_LMOIN, IF_REAL, "Length dependence of moin"),
IOP( "lnoff", BSIM4V4_MOD_LNOFF, IF_REAL, "Length dependence of noff"),
IOP( "lvoffcv", BSIM4V4_MOD_LVOFFCV, IF_REAL, "Length dependence of voffcv"),
IOP( "lxrcrg1", BSIM4V4_MOD_LXRCRG1, IF_REAL, "Length dependence of xrcrg1"),
IOP( "lxrcrg2", BSIM4V4_MOD_LXRCRG2, IF_REAL, "Length dependence of xrcrg2"),
IOP( "llambda", BSIM4V4_MOD_LLAMBDA, IF_REAL, "Length dependence of lambda"),
IOP( "lvtl", BSIM4V4_MOD_LVTL, IF_REAL, " Length dependence of vtl"),
IOP( "lxn", BSIM4V4_MOD_LXN, IF_REAL, " Length dependence of xn"),
IOP( "leu", BSIM4V4_MOD_LEU, IF_REAL, " Length dependence of eu"),
IOP( "lvfbsdoff", BSIM4V4_MOD_LVFBSDOFF, IF_REAL, "Length dependence of vfbsdoff"),
IOP( "wcdsc", BSIM4V4_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"),
IOP( "wcdscb", BSIM4V4_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"),
IOP( "wcdscd", BSIM4V4_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"),
IOP( "wcit", BSIM4V4_MOD_WCIT, IF_REAL, "Width dependence of cit"),
IOP( "wnfactor", BSIM4V4_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"),
IOP( "wxj", BSIM4V4_MOD_WXJ, IF_REAL, "Width dependence of xj"),
IOP( "wvsat", BSIM4V4_MOD_WVSAT, IF_REAL, "Width dependence of vsat"),
IOP( "wat", BSIM4V4_MOD_WAT, IF_REAL, "Width dependence of at"),
IOP( "wa0", BSIM4V4_MOD_WA0, IF_REAL, "Width dependence of a0"),
IOP( "wags", BSIM4V4_MOD_WAGS, IF_REAL, "Width dependence of ags"),
IOP( "wa1", BSIM4V4_MOD_WA1, IF_REAL, "Width dependence of a1"),
IOP( "wa2", BSIM4V4_MOD_WA2, IF_REAL, "Width dependence of a2"),
IOP( "wketa", BSIM4V4_MOD_WKETA, IF_REAL, "Width dependence of keta"),
IOP( "wnsub", BSIM4V4_MOD_WNSUB, IF_REAL, "Width dependence of nsub"),
IOP( "wndep", BSIM4V4_MOD_WNDEP, IF_REAL, "Width dependence of ndep"),
IOP( "wnsd", BSIM4V4_MOD_WNSD, IF_REAL, "Width dependence of nsd"),
IOP( "wphin", BSIM4V4_MOD_WPHIN, IF_REAL, "Width dependence of phin"),
IOP( "wngate", BSIM4V4_MOD_WNGATE, IF_REAL, "Width dependence of ngate"),
IOP( "wgamma1", BSIM4V4_MOD_WGAMMA1, IF_REAL, "Width dependence of gamma1"),
IOP( "wgamma2", BSIM4V4_MOD_WGAMMA2, IF_REAL, "Width dependence of gamma2"),
IOP( "wvbx", BSIM4V4_MOD_WVBX, IF_REAL, "Width dependence of vbx"),
IOP( "wvbm", BSIM4V4_MOD_WVBM, IF_REAL, "Width dependence of vbm"),
IOP( "wxt", BSIM4V4_MOD_WXT, IF_REAL, "Width dependence of xt"),
IOP( "wk1", BSIM4V4_MOD_WK1, IF_REAL, "Width dependence of k1"),
IOP( "wkt1", BSIM4V4_MOD_WKT1, IF_REAL, "Width dependence of kt1"),
IOP( "wkt1l", BSIM4V4_MOD_WKT1L, IF_REAL, "Width dependence of kt1l"),
IOP( "wkt2", BSIM4V4_MOD_WKT2, IF_REAL, "Width dependence of kt2"),
IOP( "wk2", BSIM4V4_MOD_WK2, IF_REAL, "Width dependence of k2"),
IOP( "wk3", BSIM4V4_MOD_WK3, IF_REAL, "Width dependence of k3"),
IOP( "wk3b", BSIM4V4_MOD_WK3B, IF_REAL, "Width dependence of k3b"),
IOP( "ww0", BSIM4V4_MOD_WW0, IF_REAL, "Width dependence of w0"),
IOP( "wdvtp0", BSIM4V4_MOD_WDVTP0, IF_REAL, "Width dependence of dvtp0"),
IOP( "wdvtp1", BSIM4V4_MOD_WDVTP1, IF_REAL, "Width dependence of dvtp1"),
IOP( "wlpe0", BSIM4V4_MOD_WLPE0, IF_REAL, "Width dependence of lpe0"),
IOP( "wlpeb", BSIM4V4_MOD_WLPEB, IF_REAL, "Width dependence of lpeb"),
IOP( "wdvt0", BSIM4V4_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"),
IOP( "wdvt1", BSIM4V4_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"),
IOP( "wdvt2", BSIM4V4_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"),
IOP( "wdvt0w", BSIM4V4_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"),
IOP( "wdvt1w", BSIM4V4_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"),
IOP( "wdvt2w", BSIM4V4_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"),
IOP( "wdrout", BSIM4V4_MOD_WDROUT, IF_REAL, "Width dependence of drout"),
IOP( "wdsub", BSIM4V4_MOD_WDSUB, IF_REAL, "Width dependence of dsub"),
IOP( "wvth0", BSIM4V4_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOP( "wvtho", BSIM4V4_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOP( "wua", BSIM4V4_MOD_WUA, IF_REAL, "Width dependence of ua"),
IOP( "wua1", BSIM4V4_MOD_WUA1, IF_REAL, "Width dependence of ua1"),
IOP( "wub", BSIM4V4_MOD_WUB, IF_REAL, "Width dependence of ub"),
IOP( "wub1", BSIM4V4_MOD_WUB1, IF_REAL, "Width dependence of ub1"),
IOP( "wuc", BSIM4V4_MOD_WUC, IF_REAL, "Width dependence of uc"),
IOP( "wuc1", BSIM4V4_MOD_WUC1, IF_REAL, "Width dependence of uc1"),
IOP( "wu0", BSIM4V4_MOD_WU0, IF_REAL, "Width dependence of u0"),
IOP( "wute", BSIM4V4_MOD_WUTE, IF_REAL, "Width dependence of ute"),
IOP( "wvoff", BSIM4V4_MOD_WVOFF, IF_REAL, "Width dependence of voff"),
IOP( "wminv", BSIM4V4_MOD_WMINV, IF_REAL, "Width dependence of minv"),
IOP( "wdelta", BSIM4V4_MOD_WDELTA, IF_REAL, "Width dependence of delta"),
IOP( "wrdsw", BSIM4V4_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "),
IOP( "wrsw", BSIM4V4_MOD_WRSW, IF_REAL, "Width dependence of rsw"),
IOP( "wrdw", BSIM4V4_MOD_WRDW, IF_REAL, "Width dependence of rdw"),
IOP( "wprwg", BSIM4V4_MOD_WPRWG, IF_REAL, "Width dependence of prwg "),
IOP( "wprwb", BSIM4V4_MOD_WPRWB, IF_REAL, "Width dependence of prwb "),
IOP( "wprt", BSIM4V4_MOD_WPRT, IF_REAL, "Width dependence of prt"),
IOP( "weta0", BSIM4V4_MOD_WETA0, IF_REAL, "Width dependence of eta0"),
IOP( "wetab", BSIM4V4_MOD_WETAB, IF_REAL, "Width dependence of etab"),
IOP( "wpclm", BSIM4V4_MOD_WPCLM, IF_REAL, "Width dependence of pclm"),
IOP( "wpdiblc1", BSIM4V4_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"),
IOP( "wpdiblc2", BSIM4V4_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"),
IOP( "wpdiblcb", BSIM4V4_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"),
IOP( "wfprout", BSIM4V4_MOD_WFPROUT, IF_REAL, "Width dependence of pdiblcb"),
IOP( "wpdits", BSIM4V4_MOD_WPDITS, IF_REAL, "Width dependence of pdits"),
IOP( "wpditsd", BSIM4V4_MOD_WPDITSD, IF_REAL, "Width dependence of pditsd"),
IOP( "wpscbe1", BSIM4V4_MOD_WPSCBE1, IF_REAL, "Width dependence of pscbe1"),
IOP( "wpscbe2", BSIM4V4_MOD_WPSCBE2, IF_REAL, "Width dependence of pscbe2"),
IOP( "wpvag", BSIM4V4_MOD_WPVAG, IF_REAL, "Width dependence of pvag"),
IOP( "wwr", BSIM4V4_MOD_WWR, IF_REAL, "Width dependence of wr"),
IOP( "wdwg", BSIM4V4_MOD_WDWG, IF_REAL, "Width dependence of dwg"),
IOP( "wdwb", BSIM4V4_MOD_WDWB, IF_REAL, "Width dependence of dwb"),
IOP( "wb0", BSIM4V4_MOD_WB0, IF_REAL, "Width dependence of b0"),
IOP( "wb1", BSIM4V4_MOD_WB1, IF_REAL, "Width dependence of b1"),
IOP( "wcgsl", BSIM4V4_MOD_WCGSL, IF_REAL, "Width dependence of cgsl"),
IOP( "wcgdl", BSIM4V4_MOD_WCGDL, IF_REAL, "Width dependence of cgdl"),
IOP( "wckappas", BSIM4V4_MOD_WCKAPPAS, IF_REAL, "Width dependence of ckappas"),
IOP( "wckappad", BSIM4V4_MOD_WCKAPPAD, IF_REAL, "Width dependence of ckappad"),
IOP( "wcf", BSIM4V4_MOD_WCF, IF_REAL, "Width dependence of cf"),
IOP( "wclc", BSIM4V4_MOD_WCLC, IF_REAL, "Width dependence of clc"),
IOP( "wcle", BSIM4V4_MOD_WCLE, IF_REAL, "Width dependence of cle"),
IOP( "walpha0", BSIM4V4_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"),
IOP( "walpha1", BSIM4V4_MOD_WALPHA1, IF_REAL, "Width dependence of alpha1"),
IOP( "wbeta0", BSIM4V4_MOD_WBETA0, IF_REAL, "Width dependence of beta0"),
IOP( "wagidl", BSIM4V4_MOD_WAGIDL, IF_REAL, "Width dependence of agidl"),
IOP( "wbgidl", BSIM4V4_MOD_WBGIDL, IF_REAL, "Width dependence of bgidl"),
IOP( "wcgidl", BSIM4V4_MOD_WCGIDL, IF_REAL, "Width dependence of cgidl"),
IOP( "wegidl", BSIM4V4_MOD_WEGIDL, IF_REAL, "Width dependence of egidl"),
IOP( "waigc", BSIM4V4_MOD_WAIGC, IF_REAL, "Width dependence of aigc"),
IOP( "wbigc", BSIM4V4_MOD_WBIGC, IF_REAL, "Width dependence of bigc"),
IOP( "wcigc", BSIM4V4_MOD_WCIGC, IF_REAL, "Width dependence of cigc"),
IOP( "waigsd", BSIM4V4_MOD_WAIGSD, IF_REAL, "Width dependence of aigsd"),
IOP( "wbigsd", BSIM4V4_MOD_WBIGSD, IF_REAL, "Width dependence of bigsd"),
IOP( "wcigsd", BSIM4V4_MOD_WCIGSD, IF_REAL, "Width dependence of cigsd"),
IOP( "waigbacc", BSIM4V4_MOD_WAIGBACC, IF_REAL, "Width dependence of aigbacc"),
IOP( "wbigbacc", BSIM4V4_MOD_WBIGBACC, IF_REAL, "Width dependence of bigbacc"),
IOP( "wcigbacc", BSIM4V4_MOD_WCIGBACC, IF_REAL, "Width dependence of cigbacc"),
IOP( "waigbinv", BSIM4V4_MOD_WAIGBINV, IF_REAL, "Width dependence of aigbinv"),
IOP( "wbigbinv", BSIM4V4_MOD_WBIGBINV, IF_REAL, "Width dependence of bigbinv"),
IOP( "wcigbinv", BSIM4V4_MOD_WCIGBINV, IF_REAL, "Width dependence of cigbinv"),
IOP( "wnigc", BSIM4V4_MOD_WNIGC, IF_REAL, "Width dependence of nigc"),
IOP( "wnigbinv", BSIM4V4_MOD_WNIGBINV, IF_REAL, "Width dependence of nigbinv"),
IOP( "wnigbacc", BSIM4V4_MOD_WNIGBACC, IF_REAL, "Width dependence of nigbacc"),
IOP( "wntox", BSIM4V4_MOD_WNTOX, IF_REAL, "Width dependence of ntox"),
IOP( "weigbinv", BSIM4V4_MOD_WEIGBINV, IF_REAL, "Width dependence for eigbinv"),
IOP( "wpigcd", BSIM4V4_MOD_WPIGCD, IF_REAL, "Width dependence for pigcd"),
IOP( "wpoxedge", BSIM4V4_MOD_WPOXEDGE, IF_REAL, "Width dependence for poxedge"),
IOP( "wvfbcv", BSIM4V4_MOD_WVFBCV, IF_REAL, "Width dependence of vfbcv"),
IOP( "wvfb", BSIM4V4_MOD_WVFB, IF_REAL, "Width dependence of vfb"),
IOP( "wacde", BSIM4V4_MOD_WACDE, IF_REAL, "Width dependence of acde"),
IOP( "wmoin", BSIM4V4_MOD_WMOIN, IF_REAL, "Width dependence of moin"),
IOP( "wnoff", BSIM4V4_MOD_WNOFF, IF_REAL, "Width dependence of noff"),
IOP( "wvoffcv", BSIM4V4_MOD_WVOFFCV, IF_REAL, "Width dependence of voffcv"),
IOP( "wxrcrg1", BSIM4V4_MOD_WXRCRG1, IF_REAL, "Width dependence of xrcrg1"),
IOP( "wxrcrg2", BSIM4V4_MOD_WXRCRG2, IF_REAL, "Width dependence of xrcrg2"),
IOP( "wlambda", BSIM4V4_MOD_WLAMBDA, IF_REAL, "Width dependence of lambda"),
IOP( "wvtl", BSIM4V4_MOD_WVTL, IF_REAL, "Width dependence of vtl"),
IOP( "wxn", BSIM4V4_MOD_WXN, IF_REAL, "Width dependence of xn"),
IOP( "weu", BSIM4V4_MOD_WEU, IF_REAL, "Width dependence of eu"),
IOP( "wvfbsdoff", BSIM4V4_MOD_WVFBSDOFF, IF_REAL, "Width dependence of vfbsdoff"),
IOP( "pcdsc", BSIM4V4_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"),
IOP( "pcdscb", BSIM4V4_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"),
IOP( "pcdscd", BSIM4V4_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"),
IOP( "pcit", BSIM4V4_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"),
IOP( "pnfactor", BSIM4V4_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"),
IOP( "pxj", BSIM4V4_MOD_PXJ, IF_REAL, "Cross-term dependence of xj"),
IOP( "pvsat", BSIM4V4_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"),
IOP( "pat", BSIM4V4_MOD_PAT, IF_REAL, "Cross-term dependence of at"),
IOP( "pa0", BSIM4V4_MOD_PA0, IF_REAL, "Cross-term dependence of a0"),
IOP( "pags", BSIM4V4_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"),
IOP( "pa1", BSIM4V4_MOD_PA1, IF_REAL, "Cross-term dependence of a1"),
IOP( "pa2", BSIM4V4_MOD_PA2, IF_REAL, "Cross-term dependence of a2"),
IOP( "pketa", BSIM4V4_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"),
IOP( "pnsub", BSIM4V4_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"),
IOP( "pndep", BSIM4V4_MOD_PNDEP, IF_REAL, "Cross-term dependence of ndep"),
IOP( "pnsd", BSIM4V4_MOD_PNSD, IF_REAL, "Cross-term dependence of nsd"),
IOP( "pphin", BSIM4V4_MOD_PPHIN, IF_REAL, "Cross-term dependence of phin"),
IOP( "pngate", BSIM4V4_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"),
IOP( "pgamma1", BSIM4V4_MOD_PGAMMA1, IF_REAL, "Cross-term dependence of gamma1"),
IOP( "pgamma2", BSIM4V4_MOD_PGAMMA2, IF_REAL, "Cross-term dependence of gamma2"),
IOP( "pvbx", BSIM4V4_MOD_PVBX, IF_REAL, "Cross-term dependence of vbx"),
IOP( "pvbm", BSIM4V4_MOD_PVBM, IF_REAL, "Cross-term dependence of vbm"),
IOP( "pxt", BSIM4V4_MOD_PXT, IF_REAL, "Cross-term dependence of xt"),
IOP( "pk1", BSIM4V4_MOD_PK1, IF_REAL, "Cross-term dependence of k1"),
IOP( "pkt1", BSIM4V4_MOD_PKT1, IF_REAL, "Cross-term dependence of kt1"),
IOP( "pkt1l", BSIM4V4_MOD_PKT1L, IF_REAL, "Cross-term dependence of kt1l"),
IOP( "pkt2", BSIM4V4_MOD_PKT2, IF_REAL, "Cross-term dependence of kt2"),
IOP( "pk2", BSIM4V4_MOD_PK2, IF_REAL, "Cross-term dependence of k2"),
IOP( "pk3", BSIM4V4_MOD_PK3, IF_REAL, "Cross-term dependence of k3"),
IOP( "pk3b", BSIM4V4_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"),
IOP( "pw0", BSIM4V4_MOD_PW0, IF_REAL, "Cross-term dependence of w0"),
IOP( "pdvtp0", BSIM4V4_MOD_PDVTP0, IF_REAL, "Cross-term dependence of dvtp0"),
IOP( "pdvtp1", BSIM4V4_MOD_PDVTP1, IF_REAL, "Cross-term dependence of dvtp1"),
IOP( "plpe0", BSIM4V4_MOD_PLPE0, IF_REAL, "Cross-term dependence of lpe0"),
IOP( "plpeb", BSIM4V4_MOD_PLPEB, IF_REAL, "Cross-term dependence of lpeb"),
IOP( "pdvt0", BSIM4V4_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"),
IOP( "pdvt1", BSIM4V4_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"),
IOP( "pdvt2", BSIM4V4_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"),
IOP( "pdvt0w", BSIM4V4_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"),
IOP( "pdvt1w", BSIM4V4_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"),
IOP( "pdvt2w", BSIM4V4_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"),
IOP( "pdrout", BSIM4V4_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"),
IOP( "pdsub", BSIM4V4_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"),
IOP( "pvth0", BSIM4V4_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOP( "pvtho", BSIM4V4_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOP( "pua", BSIM4V4_MOD_PUA, IF_REAL, "Cross-term dependence of ua"),
IOP( "pua1", BSIM4V4_MOD_PUA1, IF_REAL, "Cross-term dependence of ua1"),
IOP( "pub", BSIM4V4_MOD_PUB, IF_REAL, "Cross-term dependence of ub"),
IOP( "pub1", BSIM4V4_MOD_PUB1, IF_REAL, "Cross-term dependence of ub1"),
IOP( "puc", BSIM4V4_MOD_PUC, IF_REAL, "Cross-term dependence of uc"),
IOP( "puc1", BSIM4V4_MOD_PUC1, IF_REAL, "Cross-term dependence of uc1"),
IOP( "pu0", BSIM4V4_MOD_PU0, IF_REAL, "Cross-term dependence of u0"),
IOP( "pute", BSIM4V4_MOD_PUTE, IF_REAL, "Cross-term dependence of ute"),
IOP( "pvoff", BSIM4V4_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"),
IOP( "pminv", BSIM4V4_MOD_PMINV, IF_REAL, "Cross-term dependence of minv"),
IOP( "pdelta", BSIM4V4_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"),
IOP( "prdsw", BSIM4V4_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "),
IOP( "prsw", BSIM4V4_MOD_PRSW, IF_REAL, "Cross-term dependence of rsw"),
IOP( "prdw", BSIM4V4_MOD_PRDW, IF_REAL, "Cross-term dependence of rdw"),
IOP( "pprwg", BSIM4V4_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "),
IOP( "pprwb", BSIM4V4_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "),
IOP( "pprt", BSIM4V4_MOD_PPRT, IF_REAL, "Cross-term dependence of prt "),
IOP( "peta0", BSIM4V4_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"),
IOP( "petab", BSIM4V4_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"),
IOP( "ppclm", BSIM4V4_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"),
IOP( "ppdiblc1", BSIM4V4_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"),
IOP( "ppdiblc2", BSIM4V4_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"),
IOP( "ppdiblcb", BSIM4V4_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"),
IOP( "pfprout", BSIM4V4_MOD_PFPROUT, IF_REAL, "Cross-term dependence of pdiblcb"),
IOP( "ppdits", BSIM4V4_MOD_PPDITS, IF_REAL, "Cross-term dependence of pdits"),
IOP( "ppditsd", BSIM4V4_MOD_PPDITSD, IF_REAL, "Cross-term dependence of pditsd"),
IOP( "ppscbe1", BSIM4V4_MOD_PPSCBE1, IF_REAL, "Cross-term dependence of pscbe1"),
IOP( "ppscbe2", BSIM4V4_MOD_PPSCBE2, IF_REAL, "Cross-term dependence of pscbe2"),
IOP( "ppvag", BSIM4V4_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"),
IOP( "pwr", BSIM4V4_MOD_PWR, IF_REAL, "Cross-term dependence of wr"),
IOP( "pdwg", BSIM4V4_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"),
IOP( "pdwb", BSIM4V4_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"),
IOP( "pb0", BSIM4V4_MOD_PB0, IF_REAL, "Cross-term dependence of b0"),
IOP( "pb1", BSIM4V4_MOD_PB1, IF_REAL, "Cross-term dependence of b1"),
IOP( "pcgsl", BSIM4V4_MOD_PCGSL, IF_REAL, "Cross-term dependence of cgsl"),
IOP( "pcgdl", BSIM4V4_MOD_PCGDL, IF_REAL, "Cross-term dependence of cgdl"),
IOP( "pckappas", BSIM4V4_MOD_PCKAPPAS, IF_REAL, "Cross-term dependence of ckappas"),
IOP( "pckappad", BSIM4V4_MOD_PCKAPPAD, IF_REAL, "Cross-term dependence of ckappad"),
IOP( "pcf", BSIM4V4_MOD_PCF, IF_REAL, "Cross-term dependence of cf"),
IOP( "pclc", BSIM4V4_MOD_PCLC, IF_REAL, "Cross-term dependence of clc"),
IOP( "pcle", BSIM4V4_MOD_PCLE, IF_REAL, "Cross-term dependence of cle"),
IOP( "palpha0", BSIM4V4_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"),
IOP( "palpha1", BSIM4V4_MOD_PALPHA1, IF_REAL, "Cross-term dependence of alpha1"),
IOP( "pbeta0", BSIM4V4_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"),
IOP( "pagidl", BSIM4V4_MOD_PAGIDL, IF_REAL, "Cross-term dependence of agidl"),
IOP( "pbgidl", BSIM4V4_MOD_PBGIDL, IF_REAL, "Cross-term dependence of bgidl"),
IOP( "pcgidl", BSIM4V4_MOD_PCGIDL, IF_REAL, "Cross-term dependence of cgidl"),
IOP( "pegidl", BSIM4V4_MOD_PEGIDL, IF_REAL, "Cross-term dependence of egidl"),
IOP( "paigc", BSIM4V4_MOD_PAIGC, IF_REAL, "Cross-term dependence of aigc"),
IOP( "pbigc", BSIM4V4_MOD_PBIGC, IF_REAL, "Cross-term dependence of bigc"),
IOP( "pcigc", BSIM4V4_MOD_PCIGC, IF_REAL, "Cross-term dependence of cigc"),
IOP( "paigsd", BSIM4V4_MOD_PAIGSD, IF_REAL, "Cross-term dependence of aigsd"),
IOP( "pbigsd", BSIM4V4_MOD_PBIGSD, IF_REAL, "Cross-term dependence of bigsd"),
IOP( "pcigsd", BSIM4V4_MOD_PCIGSD, IF_REAL, "Cross-term dependence of cigsd"),
IOP( "paigbacc", BSIM4V4_MOD_PAIGBACC, IF_REAL, "Cross-term dependence of aigbacc"),
IOP( "pbigbacc", BSIM4V4_MOD_PBIGBACC, IF_REAL, "Cross-term dependence of bigbacc"),
IOP( "pcigbacc", BSIM4V4_MOD_PCIGBACC, IF_REAL, "Cross-term dependence of cigbacc"),
IOP( "paigbinv", BSIM4V4_MOD_PAIGBINV, IF_REAL, "Cross-term dependence of aigbinv"),
IOP( "pbigbinv", BSIM4V4_MOD_PBIGBINV, IF_REAL, "Cross-term dependence of bigbinv"),
IOP( "pcigbinv", BSIM4V4_MOD_PCIGBINV, IF_REAL, "Cross-term dependence of cigbinv"),
IOP( "pnigc", BSIM4V4_MOD_PNIGC, IF_REAL, "Cross-term dependence of nigc"),
IOP( "pnigbinv", BSIM4V4_MOD_PNIGBINV, IF_REAL, "Cross-term dependence of nigbinv"),
IOP( "pnigbacc", BSIM4V4_MOD_PNIGBACC, IF_REAL, "Cross-term dependence of nigbacc"),
IOP( "pntox", BSIM4V4_MOD_PNTOX, IF_REAL, "Cross-term dependence of ntox"),
IOP( "peigbinv", BSIM4V4_MOD_PEIGBINV, IF_REAL, "Cross-term dependence for eigbinv"),
IOP( "ppigcd", BSIM4V4_MOD_PPIGCD, IF_REAL, "Cross-term dependence for pigcd"),
IOP( "ppoxedge", BSIM4V4_MOD_PPOXEDGE, IF_REAL, "Cross-term dependence for poxedge"),
IOP( "pvfbcv", BSIM4V4_MOD_PVFBCV, IF_REAL, "Cross-term dependence of vfbcv"),
IOP( "pvfb", BSIM4V4_MOD_PVFB, IF_REAL, "Cross-term dependence of vfb"),
IOP( "pacde", BSIM4V4_MOD_PACDE, IF_REAL, "Cross-term dependence of acde"),
IOP( "pmoin", BSIM4V4_MOD_PMOIN, IF_REAL, "Cross-term dependence of moin"),
IOP( "pnoff", BSIM4V4_MOD_PNOFF, IF_REAL, "Cross-term dependence of noff"),
IOP( "pvoffcv", BSIM4V4_MOD_PVOFFCV, IF_REAL, "Cross-term dependence of voffcv"),
IOP( "pxrcrg1", BSIM4V4_MOD_PXRCRG1, IF_REAL, "Cross-term dependence of xrcrg1"),
IOP( "pxrcrg2", BSIM4V4_MOD_PXRCRG2, IF_REAL, "Cross-term dependence of xrcrg2"),
IOP( "plambda", BSIM4V4_MOD_PLAMBDA, IF_REAL, "Cross-term dependence of lambda"),
IOP( "pvtl", BSIM4V4_MOD_PVTL, IF_REAL, "Cross-term dependence of vtl"),
IOP( "pxn", BSIM4V4_MOD_PXN, IF_REAL, "Cross-term dependence of xn"),
IOP( "peu", BSIM4V4_MOD_PEU, IF_REAL, "Cross-term dependence of eu"),
IOP( "pvfbsdoff", BSIM4V4_MOD_PVFBSDOFF, IF_REAL, "Cross-term dependence of vfbsdoff"),
/* stress effect*/
IOP( "saref", BSIM4V4_MOD_SAREF, IF_REAL, "Reference distance between OD edge to poly of one side"),
IOP( "sbref", BSIM4V4_MOD_SBREF, IF_REAL, "Reference distance between OD edge to poly of the other side"),
IOP( "wlod", BSIM4V4_MOD_WLOD, IF_REAL, "Width parameter for stress effect"),
IOP( "ku0", BSIM4V4_MOD_KU0, IF_REAL, "Mobility degradation/enhancement coefficient for LOD"),
IOP( "kvsat", BSIM4V4_MOD_KVSAT, IF_REAL, "Saturation velocity degradation/enhancement parameter for LOD"),
IOP( "kvth0", BSIM4V4_MOD_KVTH0, IF_REAL, "Threshold degradation/enhancement parameter for LOD"),
IOP( "tku0", BSIM4V4_MOD_TKU0, IF_REAL, "Temperature coefficient of KU0"),
IOP( "llodku0", BSIM4V4_MOD_LLODKU0, IF_REAL, "Length parameter for u0 LOD effect"),
IOP( "wlodku0", BSIM4V4_MOD_WLODKU0, IF_REAL, "Width parameter for u0 LOD effect"),
IOP( "llodvth", BSIM4V4_MOD_LLODVTH, IF_REAL, "Length parameter for vth LOD effect"),
IOP( "wlodvth", BSIM4V4_MOD_WLODVTH, IF_REAL, "Width parameter for vth LOD effect"),
IOP( "lku0", BSIM4V4_MOD_LKU0, IF_REAL, "Length dependence of ku0"),
IOP( "wku0", BSIM4V4_MOD_WKU0, IF_REAL, "Width dependence of ku0"),
IOP( "pku0", BSIM4V4_MOD_PKU0, IF_REAL, "Cross-term dependence of ku0"),
IOP( "lkvth0", BSIM4V4_MOD_LKVTH0, IF_REAL, "Length dependence of kvth0"),
IOP( "wkvth0", BSIM4V4_MOD_WKVTH0, IF_REAL, "Width dependence of kvth0"),
IOP( "pkvth0", BSIM4V4_MOD_PKVTH0, IF_REAL, "Cross-term dependence of kvth0"),
IOP( "stk2", BSIM4V4_MOD_STK2, IF_REAL, "K2 shift factor related to stress effect on vth"),
IOP( "lodk2", BSIM4V4_MOD_LODK2, IF_REAL, "K2 shift modification factor for stress effect"),
IOP( "steta0", BSIM4V4_MOD_STETA0, IF_REAL, "eta0 shift factor related to stress effect on vth"),
IOP( "lodeta0", BSIM4V4_MOD_LODETA0, IF_REAL, "eta0 shift modification factor for stress effect"),
IOP( "noia", BSIM4V4_MOD_NOIA, IF_REAL, "Flicker noise parameter"),
IOP( "noib", BSIM4V4_MOD_NOIB, IF_REAL, "Flicker noise parameter"),
IOP( "noic", BSIM4V4_MOD_NOIC, IF_REAL, "Flicker noise parameter"),
IOP( "tnoia", BSIM4V4_MOD_TNOIA, IF_REAL, "Thermal noise parameter"),
IOP( "tnoib", BSIM4V4_MOD_TNOIB, IF_REAL, "Thermal noise parameter"),
IOP( "rnoia", BSIM4V4_MOD_RNOIA, IF_REAL, "Thermal noise coefficient"),
IOP( "rnoib", BSIM4V4_MOD_RNOIB, IF_REAL, "Thermal noise coefficient"),
IOP( "ntnoi", BSIM4V4_MOD_NTNOI, IF_REAL, "Thermal noise parameter"),
IOP( "em", BSIM4V4_MOD_EM, IF_REAL, "Flicker noise parameter"),
IOP( "ef", BSIM4V4_MOD_EF, IF_REAL, "Flicker noise frequency exponent"),
IOP( "af", BSIM4V4_MOD_AF, IF_REAL, "Flicker noise exponent"),
IOP( "kf", BSIM4V4_MOD_KF, IF_REAL, "Flicker noise coefficient"),
IOP( "stimod", BSIM4V4_MOD_STIMOD, IF_REAL, "Stress effect model selector"),
IOP( "sa0", BSIM4V4_MOD_SA0, IF_REAL, "Distance between OD edge to poly of one side"),
IOP( "sb0", BSIM4V4_MOD_SB0, IF_REAL, "Distance between OD edge to poly of other side"),
IP( "nmos", BSIM4V4_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"),
IP( "pmos", BSIM4V4_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"),
};
char *BSIM4V4names[] = {
"Drain",
"Gate",
"Source",
"Bulk",
"Charge"
};
int BSIM4V4nSize = NUMELEMS(BSIM4V4names);
int BSIM4V4pTSize = NUMELEMS(BSIM4V4pTable);
int BSIM4V4mPTSize = NUMELEMS(BSIM4V4mPTable);
int BSIM4V4iSize = sizeof(BSIM4V4instance);
int BSIM4V4mSize = sizeof(BSIM4V4model);

672
src/spicelib/devices/bsim4v4/b4v4acld.c Normal file
View File

@ -0,0 +1,672 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4acld.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
* Modified by Xuemei Xi, 10/05/2001.
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "bsim4v4def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM4V4acLoad(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
BSIM4V4model *model = (BSIM4V4model*)inModel;
BSIM4V4instance *here;
double gjbd, gjbs, geltd, gcrg, gcrgg, gcrgd, gcrgs, gcrgb;
double xcbgb, xcbdb, xcbsb, xcbbb;
double xcggbr, xcgdbr, xcgsbr, xcgbbr, xcggbi, xcgdbi, xcgsbi, xcgbbi;
double Cggr, Cgdr, Cgsr, Cgbr, Cggi, Cgdi, Cgsi, Cgbi;
double xcddbr, xcdgbr, xcdsbr, xcdbbr, xcsdbr, xcsgbr, xcssbr, xcsbbr;
double xcddbi, xcdgbi, xcdsbi, xcdbbi, xcsdbi, xcsgbi, xcssbi, xcsbbi;
double xcdbdb, xcsbsb=0.0, xcgmgmb=0.0, xcgmdb=0.0, xcgmsb=0.0, xcdgmb, xcsgmb;
double xcgmbb=0.0, xcbgmb;
double capbd, capbs, omega;
double gstot, gstotd, gstotg, gstots, gstotb, gspr;
double gdtot, gdtotd, gdtotg, gdtots, gdtotb, gdpr;
double gIstotg, gIstotd, gIstots, gIstotb;
double gIdtotg, gIdtotd, gIdtots, gIdtotb;
double gIbtotg, gIbtotd, gIbtots, gIbtotb;
double gIgtotg, gIgtotd, gIgtots, gIgtotb;
double cgso, cgdo, cgbo;
double gbspsp, gbbdp, gbbsp, gbspg, gbspb;
double gbspdp, gbdpdp, gbdpg, gbdpb, gbdpsp;
double T0=0.0, T1, T2, T3;
double Csg, Csd, Css;
double Cdgr, Cddr, Cdsr, Cdbr, Csgr, Csdr, Cssr, Csbr;
double Cdgi, Cddi, Cdsi, Cdbi, Csgi, Csdi, Cssi, Csbi;
double gmr, gmi, gmbsr, gmbsi, gdsr, gdsi;
double FwdSumr, RevSumr, Gmr, Gmbsr;
double FwdSumi, RevSumi, Gmi, Gmbsi;
struct bsim4SizeDependParam *pParam;
double ggidld, ggidlg, ggidlb, ggislg, ggislb, ggisls;
double m;
omega = ckt->CKTomega;
for (; model != NULL; model = model->BSIM4V4nextModel)
{ for (here = model->BSIM4V4instances; here!= NULL;
here = here->BSIM4V4nextInstance)
{ if (here->BSIM4V4owner != ARCHme) continue;
pParam = here->pParam;
capbd = here->BSIM4V4capbd;
capbs = here->BSIM4V4capbs;
cgso = here->BSIM4V4cgso;
cgdo = here->BSIM4V4cgdo;
cgbo = pParam->BSIM4V4cgbo;
Csd = -(here->BSIM4V4cddb + here->BSIM4V4cgdb + here->BSIM4V4cbdb);
Csg = -(here->BSIM4V4cdgb + here->BSIM4V4cggb + here->BSIM4V4cbgb);
Css = -(here->BSIM4V4cdsb + here->BSIM4V4cgsb + here->BSIM4V4cbsb);
if (here->BSIM4V4acnqsMod)
{ T0 = omega * here->BSIM4V4taunet;
T1 = T0 * T0;
T2 = 1.0 / (1.0 + T1);
T3 = T0 * T2;
gmr = here->BSIM4V4gm * T2;
gmbsr = here->BSIM4V4gmbs * T2;
gdsr = here->BSIM4V4gds * T2;
gmi = -here->BSIM4V4gm * T3;
gmbsi = -here->BSIM4V4gmbs * T3;
gdsi = -here->BSIM4V4gds * T3;
Cddr = here->BSIM4V4cddb * T2;
Cdgr = here->BSIM4V4cdgb * T2;
Cdsr = here->BSIM4V4cdsb * T2;
Cdbr = -(Cddr + Cdgr + Cdsr);
/* WDLiu: Cxyi mulitplied by jomega below, and actually to be of conductance */
Cddi = here->BSIM4V4cddb * T3 * omega;
Cdgi = here->BSIM4V4cdgb * T3 * omega;
Cdsi = here->BSIM4V4cdsb * T3 * omega;
Cdbi = -(Cddi + Cdgi + Cdsi);
Csdr = Csd * T2;
Csgr = Csg * T2;
Cssr = Css * T2;
Csbr = -(Csdr + Csgr + Cssr);
Csdi = Csd * T3 * omega;
Csgi = Csg * T3 * omega;
Cssi = Css * T3 * omega;
Csbi = -(Csdi + Csgi + Cssi);
Cgdr = -(Cddr + Csdr + here->BSIM4V4cbdb);
Cggr = -(Cdgr + Csgr + here->BSIM4V4cbgb);
Cgsr = -(Cdsr + Cssr + here->BSIM4V4cbsb);
Cgbr = -(Cgdr + Cggr + Cgsr);
Cgdi = -(Cddi + Csdi);
Cggi = -(Cdgi + Csgi);
Cgsi = -(Cdsi + Cssi);
Cgbi = -(Cgdi + Cggi + Cgsi);
}
else /* QS */
{ gmr = here->BSIM4V4gm;
gmbsr = here->BSIM4V4gmbs;
gdsr = here->BSIM4V4gds;
gmi = gmbsi = gdsi = 0.0;
Cddr = here->BSIM4V4cddb;
Cdgr = here->BSIM4V4cdgb;
Cdsr = here->BSIM4V4cdsb;
Cdbr = -(Cddr + Cdgr + Cdsr);
Cddi = Cdgi = Cdsi = Cdbi = 0.0;
Csdr = Csd;
Csgr = Csg;
Cssr = Css;
Csbr = -(Csdr + Csgr + Cssr);
Csdi = Csgi = Cssi = Csbi = 0.0;
Cgdr = here->BSIM4V4cgdb;
Cggr = here->BSIM4V4cggb;
Cgsr = here->BSIM4V4cgsb;
Cgbr = -(Cgdr + Cggr + Cgsr);
Cgdi = Cggi = Cgsi = Cgbi = 0.0;
}
if (here->BSIM4V4mode >= 0)
{ Gmr = gmr;
Gmbsr = gmbsr;
FwdSumr = Gmr + Gmbsr;
RevSumr = 0.0;
Gmi = gmi;
Gmbsi = gmbsi;
FwdSumi = Gmi + Gmbsi;
RevSumi = 0.0;
gbbdp = -(here->BSIM4V4gbds);
gbbsp = here->BSIM4V4gbds + here->BSIM4V4gbgs + here->BSIM4V4gbbs;
gbdpg = here->BSIM4V4gbgs;
gbdpdp = here->BSIM4V4gbds;
gbdpb = here->BSIM4V4gbbs;
gbdpsp = -(gbdpg + gbdpdp + gbdpb);
gbspdp = 0.0;
gbspg = 0.0;
gbspb = 0.0;
gbspsp = 0.0;
if (model->BSIM4V4igcMod)
{ gIstotg = here->BSIM4V4gIgsg + here->BSIM4V4gIgcsg;
gIstotd = here->BSIM4V4gIgcsd;
gIstots = here->BSIM4V4gIgss + here->BSIM4V4gIgcss;
gIstotb = here->BSIM4V4gIgcsb;
gIdtotg = here->BSIM4V4gIgdg + here->BSIM4V4gIgcdg;
gIdtotd = here->BSIM4V4gIgdd + here->BSIM4V4gIgcdd;
gIdtots = here->BSIM4V4gIgcds;
gIdtotb = here->BSIM4V4gIgcdb;
}
else
{ gIstotg = gIstotd = gIstots = gIstotb = 0.0;
gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0;
}
if (model->BSIM4V4igbMod)
{ gIbtotg = here->BSIM4V4gIgbg;
gIbtotd = here->BSIM4V4gIgbd;
gIbtots = here->BSIM4V4gIgbs;
gIbtotb = here->BSIM4V4gIgbb;
}
else
gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0;
if ((model->BSIM4V4igcMod != 0) || (model->BSIM4V4igbMod != 0))
{ gIgtotg = gIstotg + gIdtotg + gIbtotg;
gIgtotd = gIstotd + gIdtotd + gIbtotd ;
gIgtots = gIstots + gIdtots + gIbtots;
gIgtotb = gIstotb + gIdtotb + gIbtotb;
}
else
gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0;
if (here->BSIM4V4rgateMod == 2)
T0 = *(ckt->CKTstates[0] + here->BSIM4V4vges)
- *(ckt->CKTstates[0] + here->BSIM4V4vgs);
else if (here->BSIM4V4rgateMod == 3)
T0 = *(ckt->CKTstates[0] + here->BSIM4V4vgms)
- *(ckt->CKTstates[0] + here->BSIM4V4vgs);
if (here->BSIM4V4rgateMod > 1)
{ gcrgd = here->BSIM4V4gcrgd * T0;
gcrgg = here->BSIM4V4gcrgg * T0;
gcrgs = here->BSIM4V4gcrgs * T0;
gcrgb = here->BSIM4V4gcrgb * T0;
gcrgg -= here->BSIM4V4gcrg;
gcrg = here->BSIM4V4gcrg;
}
else
gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0;
if (here->BSIM4V4rgateMod == 3)
{ xcgmgmb = (cgdo + cgso + pParam->BSIM4V4cgbo) * omega;
xcgmdb = -cgdo * omega;
xcgmsb = -cgso * omega;
xcgmbb = -pParam->BSIM4V4cgbo * omega;
xcdgmb = xcgmdb;
xcsgmb = xcgmsb;
xcbgmb = xcgmbb;
xcggbr = Cggr * omega;
xcgdbr = Cgdr * omega;
xcgsbr = Cgsr * omega;
xcgbbr = -(xcggbr + xcgdbr + xcgsbr);
xcdgbr = Cdgr * omega;
xcsgbr = Csgr * omega;
xcbgb = here->BSIM4V4cbgb * omega;
}
else
{ xcggbr = (Cggr + cgdo + cgso + pParam->BSIM4V4cgbo ) * omega;
xcgdbr = (Cgdr - cgdo) * omega;
xcgsbr = (Cgsr - cgso) * omega;
xcgbbr = -(xcggbr + xcgdbr + xcgsbr);
xcdgbr = (Cdgr - cgdo) * omega;
xcsgbr = (Csgr - cgso) * omega;
xcbgb = (here->BSIM4V4cbgb - pParam->BSIM4V4cgbo) * omega;
xcdgmb = xcsgmb = xcbgmb = 0.0;
}
xcddbr = (Cddr + here->BSIM4V4capbd + cgdo) * omega;
xcdsbr = Cdsr * omega;
xcsdbr = Csdr * omega;
xcssbr = (here->BSIM4V4capbs + cgso + Cssr) * omega;
if (!here->BSIM4V4rbodyMod)
{ xcdbbr = -(xcdgbr + xcddbr + xcdsbr + xcdgmb);
xcsbbr = -(xcsgbr + xcsdbr + xcssbr + xcsgmb);
xcbdb = (here->BSIM4V4cbdb - here->BSIM4V4capbd) * omega;
xcbsb = (here->BSIM4V4cbsb - here->BSIM4V4capbs) * omega;
xcdbdb = 0.0;
}
else
{ xcdbbr = Cdbr * omega;
xcsbbr = -(xcsgbr + xcsdbr + xcssbr + xcsgmb)
+ here->BSIM4V4capbs * omega;
xcbdb = here->BSIM4V4cbdb * omega;
xcbsb = here->BSIM4V4cbsb * omega;
xcdbdb = -here->BSIM4V4capbd * omega;
xcsbsb = -here->BSIM4V4capbs * omega;
}
xcbbb = -(xcbdb + xcbgb + xcbsb + xcbgmb);
xcdgbi = Cdgi;
xcsgbi = Csgi;
xcddbi = Cddi;
xcdsbi = Cdsi;
xcsdbi = Csdi;
xcssbi = Cssi;
xcdbbi = Cdbi;
xcsbbi = Csbi;
xcggbi = Cggi;
xcgdbi = Cgdi;
xcgsbi = Cgsi;
xcgbbi = Cgbi;
}
else /* Reverse mode */
{ Gmr = -gmr;
Gmbsr = -gmbsr;
FwdSumr = 0.0;
RevSumr = -(Gmr + Gmbsr);
Gmi = -gmi;
Gmbsi = -gmbsi;
FwdSumi = 0.0;
RevSumi = -(Gmi + Gmbsi);
gbbsp = -(here->BSIM4V4gbds);
gbbdp = here->BSIM4V4gbds + here->BSIM4V4gbgs + here->BSIM4V4gbbs;
gbdpg = 0.0;
gbdpsp = 0.0;
gbdpb = 0.0;
gbdpdp = 0.0;
gbspg = here->BSIM4V4gbgs;
gbspsp = here->BSIM4V4gbds;
gbspb = here->BSIM4V4gbbs;
gbspdp = -(gbspg + gbspsp + gbspb);
if (model->BSIM4V4igcMod)
{ gIstotg = here->BSIM4V4gIgsg + here->BSIM4V4gIgcdg;
gIstotd = here->BSIM4V4gIgcds;
gIstots = here->BSIM4V4gIgss + here->BSIM4V4gIgcdd;
gIstotb = here->BSIM4V4gIgcdb;
gIdtotg = here->BSIM4V4gIgdg + here->BSIM4V4gIgcsg;
gIdtotd = here->BSIM4V4gIgdd + here->BSIM4V4gIgcss;
gIdtots = here->BSIM4V4gIgcsd;
gIdtotb = here->BSIM4V4gIgcsb;
}
else
{ gIstotg = gIstotd = gIstots = gIstotb = 0.0;
gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0;
}
if (model->BSIM4V4igbMod)
{ gIbtotg = here->BSIM4V4gIgbg;
gIbtotd = here->BSIM4V4gIgbs;
gIbtots = here->BSIM4V4gIgbd;
gIbtotb = here->BSIM4V4gIgbb;
}
else
gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0;
if ((model->BSIM4V4igcMod != 0) || (model->BSIM4V4igbMod != 0))
{ gIgtotg = gIstotg + gIdtotg + gIbtotg;
gIgtotd = gIstotd + gIdtotd + gIbtotd ;
gIgtots = gIstots + gIdtots + gIbtots;
gIgtotb = gIstotb + gIdtotb + gIbtotb;
}
else
gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0;
if (here->BSIM4V4rgateMod == 2)
T0 = *(ckt->CKTstates[0] + here->BSIM4V4vges)
- *(ckt->CKTstates[0] + here->BSIM4V4vgs);
else if (here->BSIM4V4rgateMod == 3)
T0 = *(ckt->CKTstates[0] + here->BSIM4V4vgms)
- *(ckt->CKTstates[0] + here->BSIM4V4vgs);
if (here->BSIM4V4rgateMod > 1)
{ gcrgd = here->BSIM4V4gcrgs * T0;
gcrgg = here->BSIM4V4gcrgg * T0;
gcrgs = here->BSIM4V4gcrgd * T0;
gcrgb = here->BSIM4V4gcrgb * T0;
gcrgg -= here->BSIM4V4gcrg;
gcrg = here->BSIM4V4gcrg;
}
else
gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0;
if (here->BSIM4V4rgateMod == 3)
{ xcgmgmb = (cgdo + cgso + pParam->BSIM4V4cgbo) * omega;
xcgmdb = -cgdo * omega;
xcgmsb = -cgso * omega;
xcgmbb = -pParam->BSIM4V4cgbo * omega;
xcdgmb = xcgmdb;
xcsgmb = xcgmsb;
xcbgmb = xcgmbb;
xcggbr = Cggr * omega;
xcgdbr = Cgsr * omega;
xcgsbr = Cgdr * omega;
xcgbbr = -(xcggbr + xcgdbr + xcgsbr);
xcdgbr = Csgr * omega;
xcsgbr = Cdgr * omega;
xcbgb = here->BSIM4V4cbgb * omega;
}
else
{ xcggbr = (Cggr + cgdo + cgso + pParam->BSIM4V4cgbo ) * omega;
xcgdbr = (Cgsr - cgdo) * omega;
xcgsbr = (Cgdr - cgso) * omega;
xcgbbr = -(xcggbr + xcgdbr + xcgsbr);
xcdgbr = (Csgr - cgdo) * omega;
xcsgbr = (Cdgr - cgso) * omega;
xcbgb = (here->BSIM4V4cbgb - pParam->BSIM4V4cgbo) * omega;
xcdgmb = xcsgmb = xcbgmb = 0.0;
}
xcddbr = (here->BSIM4V4capbd + cgdo + Cssr) * omega;
xcdsbr = Csdr * omega;
xcsdbr = Cdsr * omega;
xcssbr = (Cddr + here->BSIM4V4capbs + cgso) * omega;
if (!here->BSIM4V4rbodyMod)
{ xcdbbr = -(xcdgbr + xcddbr + xcdsbr + xcdgmb);
xcsbbr = -(xcsgbr + xcsdbr + xcssbr + xcsgmb);
xcbdb = (here->BSIM4V4cbsb - here->BSIM4V4capbd) * omega;
xcbsb = (here->BSIM4V4cbdb - here->BSIM4V4capbs) * omega;
xcdbdb = 0.0;
}
else
{ xcdbbr = -(xcdgbr + xcddbr + xcdsbr + xcdgmb)
+ here->BSIM4V4capbd * omega;
xcsbbr = Cdbr * omega;
xcbdb = here->BSIM4V4cbsb * omega;
xcbsb = here->BSIM4V4cbdb * omega;
xcdbdb = -here->BSIM4V4capbd * omega;
xcsbsb = -here->BSIM4V4capbs * omega;
}
xcbbb = -(xcbgb + xcbdb + xcbsb + xcbgmb);
xcdgbi = Csgi;
xcsgbi = Cdgi;
xcddbi = Cssi;
xcdsbi = Csdi;
xcsdbi = Cdsi;
xcssbi = Cddi;
xcdbbi = Csbi;
xcsbbi = Cdbi;
xcggbi = Cggi;
xcgdbi = Cgsi;
xcgsbi = Cgdi;
xcgbbi = Cgbi;
}
if (model->BSIM4V4rdsMod == 1)
{ gstot = here->BSIM4V4gstot;
gstotd = here->BSIM4V4gstotd;
gstotg = here->BSIM4V4gstotg;
gstots = here->BSIM4V4gstots - gstot;
gstotb = here->BSIM4V4gstotb;
gdtot = here->BSIM4V4gdtot;
gdtotd = here->BSIM4V4gdtotd - gdtot;
gdtotg = here->BSIM4V4gdtotg;
gdtots = here->BSIM4V4gdtots;
gdtotb = here->BSIM4V4gdtotb;
}
else
{ gstot = gstotd = gstotg = gstots = gstotb = 0.0;
gdtot = gdtotd = gdtotg = gdtots = gdtotb = 0.0;
}
/*
* Loading AC matrix
*/
m = here->BSIM4V4m;
if (!model->BSIM4V4rdsMod)
{ gdpr = here->BSIM4V4drainConductance;
gspr = here->BSIM4V4sourceConductance;
}
else
gdpr = gspr = 0.0;
if (!here->BSIM4V4rbodyMod)
{ gjbd = here->BSIM4V4gbd;
gjbs = here->BSIM4V4gbs;
}
else
gjbd = gjbs = 0.0;
geltd = here->BSIM4V4grgeltd;
if (here->BSIM4V4rgateMod == 1)
{ *(here->BSIM4V4GEgePtr) += m * geltd;
*(here->BSIM4V4GPgePtr) -= m * geltd;
*(here->BSIM4V4GEgpPtr) -= m * geltd;
*(here->BSIM4V4GPgpPtr +1) += m * xcggbr;
*(here->BSIM4V4GPgpPtr) += m * (geltd + xcggbi + gIgtotg);
*(here->BSIM4V4GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4V4GPdpPtr) += m * (xcgdbi + gIgtotd);
*(here->BSIM4V4GPspPtr +1) += m * xcgsbr;
*(here->BSIM4V4GPspPtr) += m * (xcgsbi + gIgtots);
*(here->BSIM4V4GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4V4GPbpPtr) += m * (xcgbbi + gIgtotb);
} /* WDLiu: gcrg already subtracted from all gcrgg below */
else if (here->BSIM4V4rgateMod == 2)
{ *(here->BSIM4V4GEgePtr) += m * gcrg;
*(here->BSIM4V4GEgpPtr) += m * gcrgg;
*(here->BSIM4V4GEdpPtr) += m * gcrgd;
*(here->BSIM4V4GEspPtr) += m * gcrgs;
*(here->BSIM4V4GEbpPtr) += m * gcrgb;
*(here->BSIM4V4GPgePtr) -= m * gcrg;
*(here->BSIM4V4GPgpPtr +1) += m * xcggbr;
*(here->BSIM4V4GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg);
*(here->BSIM4V4GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4V4GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd);
*(here->BSIM4V4GPspPtr +1) += m * xcgsbr;
*(here->BSIM4V4GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots);
*(here->BSIM4V4GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4V4GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb);
}
else if (here->BSIM4V4rgateMod == 3)
{ *(here->BSIM4V4GEgePtr) += m * geltd;
*(here->BSIM4V4GEgmPtr) -= m * geltd;
*(here->BSIM4V4GMgePtr) -= m * geltd;
*(here->BSIM4V4GMgmPtr) += m * (geltd + gcrg);
*(here->BSIM4V4GMgmPtr +1) += m * xcgmgmb;
*(here->BSIM4V4GMdpPtr) += m * gcrgd;
*(here->BSIM4V4GMdpPtr +1) += m * xcgmdb;
*(here->BSIM4V4GMgpPtr) += m * gcrgg;
*(here->BSIM4V4GMspPtr) += m * gcrgs;
*(here->BSIM4V4GMspPtr +1) += m * xcgmsb;
*(here->BSIM4V4GMbpPtr) += m * gcrgb;
*(here->BSIM4V4GMbpPtr +1) += m * xcgmbb;
*(here->BSIM4V4DPgmPtr +1) += m * xcdgmb;
*(here->BSIM4V4GPgmPtr) -= m * gcrg;
*(here->BSIM4V4SPgmPtr +1) += m * xcsgmb;
*(here->BSIM4V4BPgmPtr +1) += m * xcbgmb;
*(here->BSIM4V4GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg);
*(here->BSIM4V4GPgpPtr +1) += m * xcggbr;
*(here->BSIM4V4GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd);
*(here->BSIM4V4GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4V4GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots);
*(here->BSIM4V4GPspPtr +1) += m * xcgsbr;
*(here->BSIM4V4GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb);
*(here->BSIM4V4GPbpPtr +1) += m * xcgbbr;
}
else
{ *(here->BSIM4V4GPgpPtr +1) += m * xcggbr;
*(here->BSIM4V4GPgpPtr) += m * (xcggbi + gIgtotg);
*(here->BSIM4V4GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4V4GPdpPtr) += m * (xcgdbi + gIgtotd);
*(here->BSIM4V4GPspPtr +1) += m * xcgsbr;
*(here->BSIM4V4GPspPtr) += m * (xcgsbi + gIgtots);
*(here->BSIM4V4GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4V4GPbpPtr) += m * (xcgbbi + gIgtotb);
}
if (model->BSIM4V4rdsMod)
{ (*(here->BSIM4V4DgpPtr) += m * gdtotg);
(*(here->BSIM4V4DspPtr) += m * gdtots);
(*(here->BSIM4V4DbpPtr) += m * gdtotb);
(*(here->BSIM4V4SdpPtr) += m * gstotd);
(*(here->BSIM4V4SgpPtr) += m * gstotg);
(*(here->BSIM4V4SbpPtr) += m * gstotb);
}
*(here->BSIM4V4DPdpPtr +1) += m * (xcddbr + gdsi + RevSumi);
*(here->BSIM4V4DPdpPtr) += m * (gdpr + xcddbi + gdsr + here->BSIM4V4gbd
- gdtotd + RevSumr + gbdpdp - gIdtotd);
*(here->BSIM4V4DPdPtr) -= m * (gdpr + gdtot);
*(here->BSIM4V4DPgpPtr +1) += m * (xcdgbr + Gmi);
*(here->BSIM4V4DPgpPtr) += m * (Gmr + xcdgbi - gdtotg + gbdpg - gIdtotg);
*(here->BSIM4V4DPspPtr +1) += m * (xcdsbr - gdsi - FwdSumi);
*(here->BSIM4V4DPspPtr) -= m * (gdsr - xcdsbi + FwdSumr + gdtots - gbdpsp + gIdtots);
*(here->BSIM4V4DPbpPtr +1) += m * (xcdbbr + Gmbsi);
*(here->BSIM4V4DPbpPtr) -= m * (gjbd + gdtotb - xcdbbi - Gmbsr - gbdpb + gIdtotb);
*(here->BSIM4V4DdpPtr) -= m * (gdpr - gdtotd);
*(here->BSIM4V4DdPtr) += m * (gdpr + gdtot);
*(here->BSIM4V4SPdpPtr +1) += m * (xcsdbr - gdsi - RevSumi);
*(here->BSIM4V4SPdpPtr) -= m * (gdsr - xcsdbi + gstotd + RevSumr - gbspdp + gIstotd);
*(here->BSIM4V4SPgpPtr +1) += m * (xcsgbr - Gmi);
*(here->BSIM4V4SPgpPtr) -= m * (Gmr - xcsgbi + gstotg - gbspg + gIstotg);
*(here->BSIM4V4SPspPtr +1) += m * (xcssbr + gdsi + FwdSumi);
*(here->BSIM4V4SPspPtr) += m * (gspr + xcssbi + gdsr + here->BSIM4V4gbs
- gstots + FwdSumr + gbspsp - gIstots);
*(here->BSIM4V4SPsPtr) -= m * (gspr + gstot);
*(here->BSIM4V4SPbpPtr +1) += m * (xcsbbr - Gmbsi);
*(here->BSIM4V4SPbpPtr) -= m * (gjbs + gstotb - xcsbbi + Gmbsr - gbspb + gIstotb);
*(here->BSIM4V4SspPtr) -= m * (gspr - gstots);
*(here->BSIM4V4SsPtr) += m * (gspr + gstot);
*(here->BSIM4V4BPdpPtr +1) += m * xcbdb;
*(here->BSIM4V4BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd);
*(here->BSIM4V4BPgpPtr +1) += m * xcbgb;
*(here->BSIM4V4BPgpPtr) -= m * (here->BSIM4V4gbgs + gIbtotg);
*(here->BSIM4V4BPspPtr +1) += m * xcbsb;
*(here->BSIM4V4BPspPtr) -= m * (gjbs - gbbsp + gIbtots);
*(here->BSIM4V4BPbpPtr +1) += m * xcbbb;
*(here->BSIM4V4BPbpPtr) += m * (gjbd + gjbs - here->BSIM4V4gbbs
- gIbtotb);
ggidld = here->BSIM4V4ggidld;
ggidlg = here->BSIM4V4ggidlg;
ggidlb = here->BSIM4V4ggidlb;
ggislg = here->BSIM4V4ggislg;
ggisls = here->BSIM4V4ggisls;
ggislb = here->BSIM4V4ggislb;
/* stamp gidl */
(*(here->BSIM4V4DPdpPtr) += m * ggidld);
(*(here->BSIM4V4DPgpPtr) += m * ggidlg);
(*(here->BSIM4V4DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4V4DPbpPtr) += m * ggidlb);
(*(here->BSIM4V4BPdpPtr) -= m * ggidld);
(*(here->BSIM4V4BPgpPtr) -= m * ggidlg);
(*(here->BSIM4V4BPspPtr) += m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4V4BPbpPtr) -= m * ggidlb);
/* stamp gisl */
(*(here->BSIM4V4SPdpPtr) -= m * ((ggisls + ggislg) + ggislb));
(*(here->BSIM4V4SPgpPtr) += m * ggislg);
(*(here->BSIM4V4SPspPtr) += m * ggisls);
(*(here->BSIM4V4SPbpPtr) += m * ggislb);
(*(here->BSIM4V4BPdpPtr) += m * ((ggislg + ggisls) + ggislb));
(*(here->BSIM4V4BPgpPtr) -= m * ggislg);
(*(here->BSIM4V4BPspPtr) -= m * ggisls);
(*(here->BSIM4V4BPbpPtr) -= m * ggislb);
if (here->BSIM4V4rbodyMod)
{ (*(here->BSIM4V4DPdbPtr +1) += m * xcdbdb);
(*(here->BSIM4V4DPdbPtr) -= m * here->BSIM4V4gbd);
(*(here->BSIM4V4SPsbPtr +1) += m * xcsbsb);
(*(here->BSIM4V4SPsbPtr) -= m * here->BSIM4V4gbs);
(*(here->BSIM4V4DBdpPtr +1) += m * xcdbdb);
(*(here->BSIM4V4DBdpPtr) -= m * here->BSIM4V4gbd);
(*(here->BSIM4V4DBdbPtr +1) -= m * xcdbdb);
(*(here->BSIM4V4DBdbPtr) += m * (here->BSIM4V4gbd + here->BSIM4V4grbpd
+ here->BSIM4V4grbdb));
(*(here->BSIM4V4DBbpPtr) -= m * here->BSIM4V4grbpd);
(*(here->BSIM4V4DBbPtr) -= m * here->BSIM4V4grbdb);
(*(here->BSIM4V4BPdbPtr) -= m * here->BSIM4V4grbpd);
(*(here->BSIM4V4BPbPtr) -= m * here->BSIM4V4grbpb);
(*(here->BSIM4V4BPsbPtr) -= m * here->BSIM4V4grbps);
(*(here->BSIM4V4BPbpPtr) += m * (here->BSIM4V4grbpd + here->BSIM4V4grbps
+ here->BSIM4V4grbpb));
/* WDLiu: (-here->BSIM4V4gbbs) already added to BPbpPtr */
(*(here->BSIM4V4SBspPtr +1) += m * xcsbsb);
(*(here->BSIM4V4SBspPtr) -= m * here->BSIM4V4gbs);
(*(here->BSIM4V4SBbpPtr) -= m * here->BSIM4V4grbps);
(*(here->BSIM4V4SBbPtr) -= m * here->BSIM4V4grbsb);
(*(here->BSIM4V4SBsbPtr +1) -= m * xcsbsb);
(*(here->BSIM4V4SBsbPtr) += m * (here->BSIM4V4gbs
+ here->BSIM4V4grbps + here->BSIM4V4grbsb));
(*(here->BSIM4V4BdbPtr) -= m * here->BSIM4V4grbdb);
(*(here->BSIM4V4BbpPtr) -= m * here->BSIM4V4grbpb);
(*(here->BSIM4V4BsbPtr) -= m * here->BSIM4V4grbsb);
(*(here->BSIM4V4BbPtr) += m * (here->BSIM4V4grbsb + here->BSIM4V4grbdb
+ here->BSIM4V4grbpb));
}
/*
* WDLiu: The internal charge node generated for transient NQS is not needed for
* AC NQS. The following is not doing a real job, but we have to keep it;
* otherwise a singular AC NQS matrix may occur if the transient NQS is on.
* The charge node is isolated from the instance.
*/
if (here->BSIM4V4trnqsMod)
{ (*(here->BSIM4V4QqPtr) += m * 1.0);
(*(here->BSIM4V4QgpPtr) += 0.0);
(*(here->BSIM4V4QdpPtr) += 0.0);
(*(here->BSIM4V4QspPtr) += 0.0);
(*(here->BSIM4V4QbpPtr) += 0.0);
(*(here->BSIM4V4DPqPtr) += 0.0);
(*(here->BSIM4V4SPqPtr) += 0.0);
(*(here->BSIM4V4GPqPtr) += 0.0);
}
}
}
return(OK);
}

323
src/spicelib/devices/bsim4v4/b4v4ask.c Normal file
View File

@ -0,0 +1,323 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4ask.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
* Modified by Xuemei Xi, 04/06/2001.
* Modified by Xuemei Xi, 10/05/2001.
* Modified by Xuemei Xi, 05/09/2003.
**********/
#include "ngspice.h"
#include "ifsim.h"
#include "cktdefs.h"
#include "devdefs.h"
#include "bsim4v4def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM4V4ask(ckt,inst,which,value,select)
CKTcircuit *ckt;
GENinstance *inst;
int which;
IFvalue *value;
IFvalue *select;
{
BSIM4V4instance *here = (BSIM4V4instance*)inst;
switch(which)
{ case BSIM4V4_L:
value->rValue = here->BSIM4V4l;
return(OK);
case BSIM4V4_W:
value->rValue = here->BSIM4V4w;
return(OK);
case BSIM4V4_M:
value->rValue = here->BSIM4V4m;
return(OK);
case BSIM4V4_NF:
value->rValue = here->BSIM4V4nf;
return(OK);
case BSIM4V4_MIN:
value->iValue = here->BSIM4V4min;
return(OK);
case BSIM4V4_AS:
value->rValue = here->BSIM4V4sourceArea;
return(OK);
case BSIM4V4_AD:
value->rValue = here->BSIM4V4drainArea;
return(OK);
case BSIM4V4_PS:
value->rValue = here->BSIM4V4sourcePerimeter;
return(OK);
case BSIM4V4_PD:
value->rValue = here->BSIM4V4drainPerimeter;
return(OK);
case BSIM4V4_NRS:
value->rValue = here->BSIM4V4sourceSquares;
return(OK);
case BSIM4V4_NRD:
value->rValue = here->BSIM4V4drainSquares;
return(OK);
case BSIM4V4_OFF:
value->rValue = here->BSIM4V4off;
return(OK);
case BSIM4V4_SA:
value->rValue = here->BSIM4V4sa ;
return(OK);
case BSIM4V4_SB:
value->rValue = here->BSIM4V4sb ;
return(OK);
case BSIM4V4_SD:
value->rValue = here->BSIM4V4sd ;
return(OK);
case BSIM4V4_RBSB:
value->rValue = here->BSIM4V4rbsb;
return(OK);
case BSIM4V4_RBDB:
value->rValue = here->BSIM4V4rbdb;
return(OK);
case BSIM4V4_RBPB:
value->rValue = here->BSIM4V4rbpb;
return(OK);
case BSIM4V4_RBPS:
value->rValue = here->BSIM4V4rbps;
return(OK);
case BSIM4V4_RBPD:
value->rValue = here->BSIM4V4rbpd;
return(OK);
case BSIM4V4_TRNQSMOD:
value->iValue = here->BSIM4V4trnqsMod;
return(OK);
case BSIM4V4_ACNQSMOD:
value->iValue = here->BSIM4V4acnqsMod;
return(OK);
case BSIM4V4_RBODYMOD:
value->iValue = here->BSIM4V4rbodyMod;
return(OK);
case BSIM4V4_RGATEMOD:
value->iValue = here->BSIM4V4rgateMod;
return(OK);
case BSIM4V4_GEOMOD:
value->iValue = here->BSIM4V4geoMod;
return(OK);
case BSIM4V4_RGEOMOD:
value->iValue = here->BSIM4V4rgeoMod;
return(OK);
case BSIM4V4_IC_VDS:
value->rValue = here->BSIM4V4icVDS;
return(OK);
case BSIM4V4_IC_VGS:
value->rValue = here->BSIM4V4icVGS;
return(OK);
case BSIM4V4_IC_VBS:
value->rValue = here->BSIM4V4icVBS;
return(OK);
case BSIM4V4_DNODE:
value->iValue = here->BSIM4V4dNode;
return(OK);
case BSIM4V4_GNODEEXT:
value->iValue = here->BSIM4V4gNodeExt;
return(OK);
case BSIM4V4_SNODE:
value->iValue = here->BSIM4V4sNode;
return(OK);
case BSIM4V4_BNODE:
value->iValue = here->BSIM4V4bNode;
return(OK);
case BSIM4V4_DNODEPRIME:
value->iValue = here->BSIM4V4dNodePrime;
return(OK);
case BSIM4V4_GNODEPRIME:
value->iValue = here->BSIM4V4gNodePrime;
return(OK);
case BSIM4V4_GNODEMID:
value->iValue = here->BSIM4V4gNodeMid;
return(OK);
case BSIM4V4_SNODEPRIME:
value->iValue = here->BSIM4V4sNodePrime;
return(OK);
case BSIM4V4_DBNODE:
value->iValue = here->BSIM4V4dbNode;
return(OK);
case BSIM4V4_BNODEPRIME:
value->iValue = here->BSIM4V4bNodePrime;
return(OK);
case BSIM4V4_SBNODE:
value->iValue = here->BSIM4V4sbNode;
return(OK);
case BSIM4V4_SOURCECONDUCT:
value->rValue = here->BSIM4V4sourceConductance;
return(OK);
case BSIM4V4_DRAINCONDUCT:
value->rValue = here->BSIM4V4drainConductance;
return(OK);
case BSIM4V4_VBD:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4vbd);
return(OK);
case BSIM4V4_VBS:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4vbs);
return(OK);
case BSIM4V4_VGS:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4vgs);
return(OK);
case BSIM4V4_VDS:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4vds);
return(OK);
case BSIM4V4_CD:
value->rValue = here->BSIM4V4cd;
return(OK);
case BSIM4V4_CBS:
value->rValue = here->BSIM4V4cbs;
return(OK);
case BSIM4V4_CBD:
value->rValue = here->BSIM4V4cbd;
return(OK);
case BSIM4V4_CSUB:
value->rValue = here->BSIM4V4csub;
return(OK);
case BSIM4V4_IGIDL:
value->rValue = here->BSIM4V4Igidl;
return(OK);
case BSIM4V4_IGISL:
value->rValue = here->BSIM4V4Igisl;
return(OK);
case BSIM4V4_IGS:
value->rValue = here->BSIM4V4Igs;
return(OK);
case BSIM4V4_IGD:
value->rValue = here->BSIM4V4Igd;
return(OK);
case BSIM4V4_IGB:
value->rValue = here->BSIM4V4Igb;
return(OK);
case BSIM4V4_IGCS:
value->rValue = here->BSIM4V4Igcs;
return(OK);
case BSIM4V4_IGCD:
value->rValue = here->BSIM4V4Igcd;
return(OK);
case BSIM4V4_GM:
value->rValue = here->BSIM4V4gm;
return(OK);
case BSIM4V4_GDS:
value->rValue = here->BSIM4V4gds;
return(OK);
case BSIM4V4_GMBS:
value->rValue = here->BSIM4V4gmbs;
return(OK);
case BSIM4V4_GBD:
value->rValue = here->BSIM4V4gbd;
return(OK);
case BSIM4V4_GBS:
value->rValue = here->BSIM4V4gbs;
return(OK);
/* case BSIM4V4_QB:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4qb);
return(OK); */
case BSIM4V4_CQB:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4cqb);
return(OK);
/* case BSIM4V4_QG:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4qg);
return(OK); */
case BSIM4V4_CQG:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4cqg);
return(OK);
/* case BSIM4V4_QD:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4qd);
return(OK); */
case BSIM4V4_CQD:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4cqd);
return(OK);
/* case BSIM4V4_QS:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4qs);
return(OK); */
case BSIM4V4_QB:
value->rValue = here->BSIM4V4qbulk;
return(OK);
case BSIM4V4_QG:
value->rValue = here->BSIM4V4qgate;
return(OK);
case BSIM4V4_QS:
value->rValue = here->BSIM4V4qsrc;
return(OK);
case BSIM4V4_QD:
value->rValue = here->BSIM4V4qdrn;
return(OK);
case BSIM4V4_CGGB:
value->rValue = here->BSIM4V4cggb;
return(OK);
case BSIM4V4_CGDB:
value->rValue = here->BSIM4V4cgdb;
return(OK);
case BSIM4V4_CGSB:
value->rValue = here->BSIM4V4cgsb;
return(OK);
case BSIM4V4_CDGB:
value->rValue = here->BSIM4V4cdgb;
return(OK);
case BSIM4V4_CDDB:
value->rValue = here->BSIM4V4cddb;
return(OK);
case BSIM4V4_CDSB:
value->rValue = here->BSIM4V4cdsb;
return(OK);
case BSIM4V4_CBGB:
value->rValue = here->BSIM4V4cbgb;
return(OK);
case BSIM4V4_CBDB:
value->rValue = here->BSIM4V4cbdb;
return(OK);
case BSIM4V4_CBSB:
value->rValue = here->BSIM4V4cbsb;
return(OK);
case BSIM4V4_CSGB:
value->rValue = here->BSIM4V4csgb;
return(OK);
case BSIM4V4_CSDB:
value->rValue = here->BSIM4V4csdb;
return(OK);
case BSIM4V4_CSSB:
value->rValue = here->BSIM4V4cssb;
return(OK);
case BSIM4V4_CGBB:
value->rValue = here->BSIM4V4cgbb;
return(OK);
case BSIM4V4_CDBB:
value->rValue = here->BSIM4V4cdbb;
return(OK);
case BSIM4V4_CSBB:
value->rValue = here->BSIM4V4csbb;
return(OK);
case BSIM4V4_CBBB:
value->rValue = here->BSIM4V4cbbb;
return(OK);
case BSIM4V4_CAPBD:
value->rValue = here->BSIM4V4capbd;
return(OK);
case BSIM4V4_CAPBS:
value->rValue = here->BSIM4V4capbs;
return(OK);
case BSIM4V4_VON:
value->rValue = here->BSIM4V4von;
return(OK);
case BSIM4V4_VDSAT:
value->rValue = here->BSIM4V4vdsat;
return(OK);
case BSIM4V4_QBS:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4qbs);
return(OK);
case BSIM4V4_QBD:
value->rValue = *(ckt->CKTstate0 + here->BSIM4V4qbd);
return(OK);
default:
return(E_BADPARM);
}
/* NOTREACHED */
}

747
src/spicelib/devices/bsim4v4/b4v4check.c Normal file
View File

@ -0,0 +1,747 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4check.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
* Modified by Xuemei Xi, 04/06/2001.
* Modified by Xuemei Xi, 10/05/2001.
* Modified by Xuemei Xi, 11/15/2002.
* Modified by Xuemei Xi, 05/09/2003.
* Modified by Xuemei Xi, 03/04/2004.
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "bsim4v4def.h"
#include "trandefs.h"
#include "const.h"
#include "sperror.h"
#include "devdefs.h"
#include "suffix.h"
int
BSIM4V4checkModel(model, here, ckt)
BSIM4V4model *model;
BSIM4V4instance *here;
CKTcircuit *ckt;
{
struct bsim4SizeDependParam *pParam;
int Fatal_Flag = 0;
FILE *fplog;
double model_version = atof(model->BSIM4V4version);
if ((fplog = fopen("bsim4.out", "w")) != NULL)
{ pParam = here->pParam;
fprintf(fplog, "BSIM4V4: Berkeley Short Channel IGFET Model-4\n");
fprintf(fplog, "Developed by Xuemei (Jane) Xi, Jin He, Mohan Dunga, Prof. Ali Niknejad and Prof. Chenming Hu in 2003.\n");
fprintf(fplog, "\n");
fprintf(fplog, "++++++++++ BSIM4V4 PARAMETER CHECKING BELOW ++++++++++\n");
if ( !strstr( model->BSIM4V4version, "4.4" ) )
{ fprintf(fplog, "Warning: This model is BSIM4V4.4.0; you specified a wrong version number '%s'.\n",model->BSIM4V4version);
printf("Warning: This model is BSIM4V4.4.0; you specified a wrong version number '%s'.\n",model->BSIM4V4version);
}
fprintf(fplog, "Model = %s\n", model->BSIM4V4modName);
if ((here->BSIM4V4rgateMod == 2) || (here->BSIM4V4rgateMod == 3))
{ if ((here->BSIM4V4trnqsMod == 1) || (here->BSIM4V4acnqsMod == 1))
{ fprintf(fplog, "Warning: You've selected both Rg and charge deficit NQS; select one only.\n");
printf("Warning: You've selected both Rg and charge deficit NQS; select one only.\n");
}
}
if (model->BSIM4V4toxe <= 0.0)
{ fprintf(fplog, "Fatal: Toxe = %g is not positive.\n",
model->BSIM4V4toxe);
printf("Fatal: Toxe = %g is not positive.\n", model->BSIM4V4toxe);
Fatal_Flag = 1;
}
if (model->BSIM4V4toxp <= 0.0)
{ fprintf(fplog, "Fatal: Toxp = %g is not positive.\n",
model->BSIM4V4toxp);
printf("Fatal: Toxp = %g is not positive.\n", model->BSIM4V4toxp);
Fatal_Flag = 1;
}
if (model->BSIM4V4toxm <= 0.0)
{ fprintf(fplog, "Fatal: Toxm = %g is not positive.\n",
model->BSIM4V4toxm);
printf("Fatal: Toxm = %g is not positive.\n", model->BSIM4V4toxm);
Fatal_Flag = 1;
}
if (model->BSIM4V4toxref <= 0.0)
{ fprintf(fplog, "Fatal: Toxref = %g is not positive.\n",
model->BSIM4V4toxref);
printf("Fatal: Toxref = %g is not positive.\n", model->BSIM4V4toxref);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4lpe0 < -pParam->BSIM4V4leff)
{ fprintf(fplog, "Fatal: Lpe0 = %g is less than -Leff.\n",
pParam->BSIM4V4lpe0);
printf("Fatal: Lpe0 = %g is less than -Leff.\n",
pParam->BSIM4V4lpe0);
Fatal_Flag = 1;
}
if (model->BSIM4V4lintnoi > pParam->BSIM4V4leff/2)
{ fprintf(fplog, "Fatal: Lintnoi = %g is too large - Leff for noise is negative.\n",
model->BSIM4V4lintnoi);
printf("Fatal: Lintnoi = %g is too large - Leff for noise is negative.\n",
model->BSIM4V4lintnoi);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4lpeb < -pParam->BSIM4V4leff)
{ fprintf(fplog, "Fatal: Lpeb = %g is less than -Leff.\n",
pParam->BSIM4V4lpeb);
printf("Fatal: Lpeb = %g is less than -Leff.\n",
pParam->BSIM4V4lpeb);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4ndep <= 0.0)
{ fprintf(fplog, "Fatal: Ndep = %g is not positive.\n",
pParam->BSIM4V4ndep);
printf("Fatal: Ndep = %g is not positive.\n",
pParam->BSIM4V4ndep);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4phi <= 0.0)
{ fprintf(fplog, "Fatal: Phi = %g is not positive. Please check Phin and Ndep\n",
pParam->BSIM4V4phi);
fprintf(fplog, " Phin = %g Ndep = %g \n",
pParam->BSIM4V4phin, pParam->BSIM4V4ndep);
printf("Fatal: Phi = %g is not positive. Please check Phin and Ndep\n",
pParam->BSIM4V4phi);
printf(" Phin = %g Ndep = %g \n",
pParam->BSIM4V4phin, pParam->BSIM4V4ndep);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4nsub <= 0.0)
{ fprintf(fplog, "Fatal: Nsub = %g is not positive.\n",
pParam->BSIM4V4nsub);
printf("Fatal: Nsub = %g is not positive.\n",
pParam->BSIM4V4nsub);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4ngate < 0.0)
{ fprintf(fplog, "Fatal: Ngate = %g is not positive.\n",
pParam->BSIM4V4ngate);
printf("Fatal: Ngate = %g Ngate is not positive.\n",
pParam->BSIM4V4ngate);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4ngate > 1.e25)
{ fprintf(fplog, "Fatal: Ngate = %g is too high.\n",
pParam->BSIM4V4ngate);
printf("Fatal: Ngate = %g Ngate is too high\n",
pParam->BSIM4V4ngate);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4xj <= 0.0)
{ fprintf(fplog, "Fatal: Xj = %g is not positive.\n",
pParam->BSIM4V4xj);
printf("Fatal: Xj = %g is not positive.\n", pParam->BSIM4V4xj);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4dvt1 < 0.0)
{ fprintf(fplog, "Fatal: Dvt1 = %g is negative.\n",
pParam->BSIM4V4dvt1);
printf("Fatal: Dvt1 = %g is negative.\n", pParam->BSIM4V4dvt1);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4dvt1w < 0.0)
{ fprintf(fplog, "Fatal: Dvt1w = %g is negative.\n",
pParam->BSIM4V4dvt1w);
printf("Fatal: Dvt1w = %g is negative.\n", pParam->BSIM4V4dvt1w);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4w0 == -pParam->BSIM4V4weff)
{ 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->BSIM4V4dsub < 0.0)
{ fprintf(fplog, "Fatal: Dsub = %g is negative.\n", pParam->BSIM4V4dsub);
printf("Fatal: Dsub = %g is negative.\n", pParam->BSIM4V4dsub);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4b1 == -pParam->BSIM4V4weff)
{ 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 (here->BSIM4V4u0temp <= 0.0)
{ fprintf(fplog, "Fatal: u0 at current temperature = %g is not positive.\n", here->BSIM4V4u0temp);
printf("Fatal: u0 at current temperature = %g is not positive.\n",
here->BSIM4V4u0temp);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4delta < 0.0)
{ fprintf(fplog, "Fatal: Delta = %g is less than zero.\n",
pParam->BSIM4V4delta);
printf("Fatal: Delta = %g is less than zero.\n", pParam->BSIM4V4delta);
Fatal_Flag = 1;
}
if (here->BSIM4V4vsattemp <= 0.0)
{ fprintf(fplog, "Fatal: Vsat at current temperature = %g is not positive.\n", here->BSIM4V4vsattemp);
printf("Fatal: Vsat at current temperature = %g is not positive.\n",
here->BSIM4V4vsattemp);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4pclm <= 0.0)
{ fprintf(fplog, "Fatal: Pclm = %g is not positive.\n", pParam->BSIM4V4pclm);
printf("Fatal: Pclm = %g is not positive.\n", pParam->BSIM4V4pclm);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4drout < 0.0)
{ fprintf(fplog, "Fatal: Drout = %g is negative.\n", pParam->BSIM4V4drout);
printf("Fatal: Drout = %g is negative.\n", pParam->BSIM4V4drout);
Fatal_Flag = 1;
}
if (here->BSIM4V4m <= 0.0)
{ fprintf(fplog, "Fatal: multiplier = %g is not positive.\n", here->BSIM4V4m);
printf("Fatal: multiplier = %g is not positive.\n", here->BSIM4V4m);
Fatal_Flag = 1;
}
if (here->BSIM4V4nf < 1.0)
{ fprintf(fplog, "Fatal: Number of finger = %g is smaller than one.\n", here->BSIM4V4nf);
printf("Fatal: Number of finger = %g is smaller than one.\n", here->BSIM4V4nf);
Fatal_Flag = 1;
}
if((here->BSIM4V4sa > 0.0) && (here->BSIM4V4sb > 0.0) &&
((here->BSIM4V4nf == 1.0) || ((here->BSIM4V4nf > 1.0) && (here->BSIM4V4sd > 0.0))) )
{ if (model->BSIM4V4saref <= 0.0)
{ fprintf(fplog, "Fatal: SAref = %g is not positive.\n",model->BSIM4V4saref);
printf("Fatal: SAref = %g is not positive.\n",model->BSIM4V4saref);
Fatal_Flag = 1;
}
if (model->BSIM4V4sbref <= 0.0)
{ fprintf(fplog, "Fatal: SBref = %g is not positive.\n",model->BSIM4V4sbref);
printf("Fatal: SBref = %g is not positive.\n",model->BSIM4V4sbref);
Fatal_Flag = 1;
}
}
if ((here->BSIM4V4l + model->BSIM4V4xl) <= model->BSIM4V4xgl)
{ fprintf(fplog, "Fatal: The parameter xgl must be smaller than Ldrawn+XL.\n");
printf("Fatal: The parameter xgl must be smaller than Ldrawn+XL.\n");
Fatal_Flag = 1;
}
if (model->BSIM4V4ngcon < 1.0)
{ fprintf(fplog, "Fatal: The parameter ngcon cannot be smaller than one.\n");
printf("Fatal: The parameter ngcon cannot be smaller than one.\n");
Fatal_Flag = 1;
}
if ((model->BSIM4V4ngcon != 1.0) && (model->BSIM4V4ngcon != 2.0))
{ model->BSIM4V4ngcon = 1.0;
fprintf(fplog, "Warning: Ngcon must be equal to one or two; reset to 1.0.\n");
printf("Warning: Ngcon must be equal to one or two; reset to 1.0.\n");
}
if (model->BSIM4V4gbmin < 1.0e-20)
{ fprintf(fplog, "Warning: Gbmin = %g is too small.\n",
model->BSIM4V4gbmin);
printf("Warning: Gbmin = %g is too small.\n", model->BSIM4V4gbmin);
}
/* Check saturation parameters */
if (pParam->BSIM4V4fprout < 0.0)
{ fprintf(fplog, "Fatal: fprout = %g is negative.\n",
pParam->BSIM4V4fprout);
printf("Fatal: fprout = %g is negative.\n", pParam->BSIM4V4fprout);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4pdits < 0.0)
{ fprintf(fplog, "Fatal: pdits = %g is negative.\n",
pParam->BSIM4V4pdits);
printf("Fatal: pdits = %g is negative.\n", pParam->BSIM4V4pdits);
Fatal_Flag = 1;
}
if (model->BSIM4V4pditsl < 0.0)
{ fprintf(fplog, "Fatal: pditsl = %g is negative.\n",
model->BSIM4V4pditsl);
printf("Fatal: pditsl = %g is negative.\n", model->BSIM4V4pditsl);
Fatal_Flag = 1;
}
/* Check gate current parameters */
if (model->BSIM4V4igbMod) {
if (pParam->BSIM4V4nigbinv <= 0.0)
{ fprintf(fplog, "Fatal: nigbinv = %g is non-positive.\n",
pParam->BSIM4V4nigbinv);
printf("Fatal: nigbinv = %g is non-positive.\n", pParam->BSIM4V4nigbinv);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4nigbacc <= 0.0)
{ fprintf(fplog, "Fatal: nigbacc = %g is non-positive.\n",
pParam->BSIM4V4nigbacc);
printf("Fatal: nigbacc = %g is non-positive.\n", pParam->BSIM4V4nigbacc);
Fatal_Flag = 1;
}
}
if (model->BSIM4V4igcMod) {
if (pParam->BSIM4V4nigc <= 0.0)
{ fprintf(fplog, "Fatal: nigc = %g is non-positive.\n",
pParam->BSIM4V4nigc);
printf("Fatal: nigc = %g is non-positive.\n", pParam->BSIM4V4nigc);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4poxedge <= 0.0)
{ fprintf(fplog, "Fatal: poxedge = %g is non-positive.\n",
pParam->BSIM4V4poxedge);
printf("Fatal: poxedge = %g is non-positive.\n", pParam->BSIM4V4poxedge);
Fatal_Flag = 1;
}
if (pParam->BSIM4V4pigcd <= 0.0)
{ fprintf(fplog, "Fatal: pigcd = %g is non-positive.\n",
pParam->BSIM4V4pigcd);
printf("Fatal: pigcd = %g is non-positive.\n", pParam->BSIM4V4pigcd);
Fatal_Flag = 1;
}
}
/* Check capacitance parameters */
if (pParam->BSIM4V4clc < 0.0)
{ fprintf(fplog, "Fatal: Clc = %g is negative.\n", pParam->BSIM4V4clc);
printf("Fatal: Clc = %g is negative.\n", pParam->BSIM4V4clc);
Fatal_Flag = 1;
}
/* Check overlap capacitance parameters */
if (pParam->BSIM4V4ckappas < 0.02)
{ fprintf(fplog, "Warning: ckappas = %g is too small. Set to 0.02\n",
pParam->BSIM4V4ckappas);
printf("Warning: ckappas = %g is too small.\n", pParam->BSIM4V4ckappas);
pParam->BSIM4V4ckappas = 0.02;
}
if (pParam->BSIM4V4ckappad < 0.02)
{ fprintf(fplog, "Warning: ckappad = %g is too small. Set to 0.02\n",
pParam->BSIM4V4ckappad);
printf("Warning: ckappad = %g is too small.\n", pParam->BSIM4V4ckappad);
pParam->BSIM4V4ckappad = 0.02;
}
if (model->BSIM4V4paramChk ==1)
{
/* Check L and W parameters */
if (pParam->BSIM4V4leff <= 1.0e-9)
{ fprintf(fplog, "Warning: Leff = %g <= 1.0e-9. Recommended Leff >= 1e-8 \n",
pParam->BSIM4V4leff);
printf("Warning: Leff = %g <= 1.0e-9. Recommended Leff >= 1e-8 \n",
pParam->BSIM4V4leff);
}
if (pParam->BSIM4V4leffCV <= 1.0e-9)
{ fprintf(fplog, "Warning: Leff for CV = %g <= 1.0e-9. Recommended LeffCV >=1e-8 \n",
pParam->BSIM4V4leffCV);
printf("Warning: Leff for CV = %g <= 1.0e-9. Recommended LeffCV >=1e-8 \n",
pParam->BSIM4V4leffCV);
}
if (pParam->BSIM4V4weff <= 1.0e-9)
{ fprintf(fplog, "Warning: Weff = %g <= 1.0e-9. Recommended Weff >=1e-7 \n",
pParam->BSIM4V4weff);
printf("Warning: Weff = %g <= 1.0e-9. Recommended Weff >=1e-7 \n",
pParam->BSIM4V4weff);
}
if (pParam->BSIM4V4weffCV <= 1.0e-9)
{ fprintf(fplog, "Warning: Weff for CV = %g <= 1.0e-9. Recommended WeffCV >= 1e-7 \n",
pParam->BSIM4V4weffCV);
printf("Warning: Weff for CV = %g <= 1.0e-9. Recommended WeffCV >= 1e-7 \n",
pParam->BSIM4V4weffCV);
}
/* Check threshold voltage parameters */
if (model->BSIM4V4toxe < 1.0e-10)
{ fprintf(fplog, "Warning: Toxe = %g is less than 1A. Recommended Toxe >= 5A\n",
model->BSIM4V4toxe);
printf("Warning: Toxe = %g is less than 1A. Recommended Toxe >= 5A\n", model->BSIM4V4toxe);
}
if (model->BSIM4V4toxp < 1.0e-10)
{ fprintf(fplog, "Warning: Toxp = %g is less than 1A. Recommended Toxp >= 5A\n",
model->BSIM4V4toxp);
printf("Warning: Toxp = %g is less than 1A. Recommended Toxp >= 5A\n", model->BSIM4V4toxp);
}
if (model->BSIM4V4toxm < 1.0e-10)
{ fprintf(fplog, "Warning: Toxm = %g is less than 1A. Recommended Toxm >= 5A\n",
model->BSIM4V4toxm);
printf("Warning: Toxm = %g is less than 1A. Recommended Toxm >= 5A\n", model->BSIM4V4toxm);
}
if (pParam->BSIM4V4ndep <= 1.0e12)
{ fprintf(fplog, "Warning: Ndep = %g may be too small.\n",
pParam->BSIM4V4ndep);
printf("Warning: Ndep = %g may be too small.\n",
pParam->BSIM4V4ndep);
}
else if (pParam->BSIM4V4ndep >= 1.0e21)
{ fprintf(fplog, "Warning: Ndep = %g may be too large.\n",
pParam->BSIM4V4ndep);
printf("Warning: Ndep = %g may be too large.\n",
pParam->BSIM4V4ndep);
}
if (pParam->BSIM4V4nsub <= 1.0e14)
{ fprintf(fplog, "Warning: Nsub = %g may be too small.\n",
pParam->BSIM4V4nsub);
printf("Warning: Nsub = %g may be too small.\n",
pParam->BSIM4V4nsub);
}
else if (pParam->BSIM4V4nsub >= 1.0e21)
{ fprintf(fplog, "Warning: Nsub = %g may be too large.\n",
pParam->BSIM4V4nsub);
printf("Warning: Nsub = %g may be too large.\n",
pParam->BSIM4V4nsub);
}
if ((pParam->BSIM4V4ngate > 0.0) &&
(pParam->BSIM4V4ngate <= 1.e18))
{ fprintf(fplog, "Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->BSIM4V4ngate);
printf("Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->BSIM4V4ngate);
}
if (pParam->BSIM4V4dvt0 < 0.0)
{ fprintf(fplog, "Warning: Dvt0 = %g is negative.\n",
pParam->BSIM4V4dvt0);
printf("Warning: Dvt0 = %g is negative.\n", pParam->BSIM4V4dvt0);
}
if (fabs(1.0e-8 / (pParam->BSIM4V4w0 + pParam->BSIM4V4weff)) > 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->BSIM4V4nfactor < 0.0)
{ fprintf(fplog, "Warning: Nfactor = %g is negative.\n",
pParam->BSIM4V4nfactor);
printf("Warning: Nfactor = %g is negative.\n", pParam->BSIM4V4nfactor);
}
if (pParam->BSIM4V4cdsc < 0.0)
{ fprintf(fplog, "Warning: Cdsc = %g is negative.\n",
pParam->BSIM4V4cdsc);
printf("Warning: Cdsc = %g is negative.\n", pParam->BSIM4V4cdsc);
}
if (pParam->BSIM4V4cdscd < 0.0)
{ fprintf(fplog, "Warning: Cdscd = %g is negative.\n",
pParam->BSIM4V4cdscd);
printf("Warning: Cdscd = %g is negative.\n", pParam->BSIM4V4cdscd);
}
/* Check DIBL parameters */
/* if (here->BSIM4V4eta0 < 0.0)
{ fprintf(fplog, "Warning: Eta0 = %g is negative.\n",
here->BSIM4V4eta0);
printf("Warning: Eta0 = %g is negative.\n", here->BSIM4V4eta0);
}
*/
/* Check Abulk parameters */
if (fabs(1.0e-8 / (pParam->BSIM4V4b1 + pParam->BSIM4V4weff)) > 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->BSIM4V4a2 < 0.01)
{ fprintf(fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", pParam->BSIM4V4a2);
printf("Warning: A2 = %g is too small. Set to 0.01.\n",
pParam->BSIM4V4a2);
pParam->BSIM4V4a2 = 0.01;
}
else if (pParam->BSIM4V4a2 > 1.0)
{ fprintf(fplog, "Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->BSIM4V4a2);
printf("Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->BSIM4V4a2);
pParam->BSIM4V4a2 = 1.0;
pParam->BSIM4V4a1 = 0.0;
}
if (pParam->BSIM4V4prwg < 0.0)
{ fprintf(fplog, "Warning: Prwg = %g is negative. Set to zero.\n",
pParam->BSIM4V4prwg);
printf("Warning: Prwg = %g is negative. Set to zero.\n",
pParam->BSIM4V4prwg);
pParam->BSIM4V4prwg = 0.0;
}
if (pParam->BSIM4V4rdsw < 0.0)
{ fprintf(fplog, "Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->BSIM4V4rdsw);
printf("Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->BSIM4V4rdsw);
pParam->BSIM4V4rdsw = 0.0;
pParam->BSIM4V4rds0 = 0.0;
}
if (pParam->BSIM4V4rds0 < 0.0)
{ fprintf(fplog, "Warning: Rds at current temperature = %g is negative. Set to zero.\n",
pParam->BSIM4V4rds0);
printf("Warning: Rds at current temperature = %g is negative. Set to zero.\n",
pParam->BSIM4V4rds0);
pParam->BSIM4V4rds0 = 0.0;
}
if (pParam->BSIM4V4rdswmin < 0.0)
{ fprintf(fplog, "Warning: Rdswmin at current temperature = %g is negative. Set to zero.\n",
pParam->BSIM4V4rdswmin);
printf("Warning: Rdswmin at current temperature = %g is negative. Set to zero.\n",
pParam->BSIM4V4rdswmin);
pParam->BSIM4V4rdswmin = 0.0;
}
if (pParam->BSIM4V4pscbe2 <= 0.0)
{ fprintf(fplog, "Warning: Pscbe2 = %g is not positive.\n",
pParam->BSIM4V4pscbe2);
printf("Warning: Pscbe2 = %g is not positive.\n", pParam->BSIM4V4pscbe2);
}
if (pParam->BSIM4V4vsattemp < 1.0e3)
{ fprintf(fplog, "Warning: Vsat at current temperature = %g may be too small.\n", pParam->BSIM4V4vsattemp);
printf("Warning: Vsat at current temperature = %g may be too small.\n", pParam->BSIM4V4vsattemp);
}
if((model->BSIM4V4lambdaGiven) && (pParam->BSIM4V4lambda > 0.0) )
{
if (pParam->BSIM4V4lambda > 1.0e-9)
{ fprintf(fplog, "Warning: Lambda = %g may be too large.\n", pParam->BSIM4V4lambda);
printf("Warning: Lambda = %g may be too large.\n", pParam->BSIM4V4lambda);
}
}
if((model->BSIM4V4vtlGiven) && (pParam->BSIM4V4vtl > 0.0) )
{
if (pParam->BSIM4V4vtl < 6.0e4)
{ fprintf(fplog, "Warning: Thermal velocity vtl = %g may be too small.\n", pParam->BSIM4V4vtl);
printf("Warning: Thermal velocity vtl = %g may be too small.\n", pParam->BSIM4V4vtl);
}
if (pParam->BSIM4V4xn < 3.0)
{ fprintf(fplog, "Warning: back scattering coeff xn = %g is too small.\n", pParam->BSIM4V4xn);
printf("Warning: back scattering coeff xn = %g is too small. Reset to 3.0 \n", pParam->BSIM4V4xn);
pParam->BSIM4V4xn = 3.0;
}
if (model->BSIM4V4lc < 0.0)
{ fprintf(fplog, "Warning: back scattering coeff lc = %g is too small.\n", model->BSIM4V4lc);
printf("Warning: back scattering coeff lc = %g is too small. Reset to 0.0\n", model->BSIM4V4lc);
pParam->BSIM4V4lc = 0.0;
}
}
if (pParam->BSIM4V4pdibl1 < 0.0)
{ fprintf(fplog, "Warning: Pdibl1 = %g is negative.\n",
pParam->BSIM4V4pdibl1);
printf("Warning: Pdibl1 = %g is negative.\n", pParam->BSIM4V4pdibl1);
}
/* if (pParam->BSIM4V4pdibl2 < 0.0)
{ fprintf(fplog, "Warning: Pdibl2 = %g is negative.\n",
pParam->BSIM4V4pdibl2);
printf("Warning: Pdibl2 = %g is negative.\n", pParam->BSIM4V4pdibl2);
}
*/
/* Check stress effect parameters */
if((here->BSIM4V4sa > 0.0) && (here->BSIM4V4sb > 0.0) &&
((here->BSIM4V4nf == 1.0) || ((here->BSIM4V4nf > 1.0) && (here->BSIM4V4sd > 0.0))) )
{ if (model->BSIM4V4lodk2 <= 0.0)
{ fprintf(fplog, "Warning: LODK2 = %g is not positive.\n",model->BSIM4V4lodk2);
printf("Warning: LODK2 = %g is not positive.\n",model->BSIM4V4lodk2);
}
if (model->BSIM4V4lodeta0 <= 0.0)
{ fprintf(fplog, "Warning: LODETA0 = %g is not positive.\n",model->BSIM4V4lodeta0);
printf("Warning: LODETA0 = %g is not positive.\n",model->BSIM4V4lodeta0);
}
}
/* Check gate resistance parameters */
if (here->BSIM4V4rgateMod == 1)
{ if (model->BSIM4V4rshg <= 0.0)
printf("Warning: rshg should be positive for rgateMod = 1.\n");
}
else if (here->BSIM4V4rgateMod == 2)
{ if (model->BSIM4V4rshg <= 0.0)
printf("Warning: rshg <= 0.0 for rgateMod = 2.\n");
else if (pParam->BSIM4V4xrcrg1 <= 0.0)
printf("Warning: xrcrg1 <= 0.0 for rgateMod = 2.\n");
}
if (here->BSIM4V4rgateMod == 3)
{ if (model->BSIM4V4rshg <= 0.0)
printf("Warning: rshg should be positive for rgateMod = 3.\n");
else if (pParam->BSIM4V4xrcrg1 <= 0.0)
printf("Warning: xrcrg1 should be positive for rgateMod = 3.\n");
}
/* Check capacitance parameters */
if (pParam->BSIM4V4noff < 0.1)
{ fprintf(fplog, "Warning: Noff = %g is too small.\n",
pParam->BSIM4V4noff);
printf("Warning: Noff = %g is too small.\n", pParam->BSIM4V4noff);
}
if (pParam->BSIM4V4voffcv < -0.5)
{ fprintf(fplog, "Warning: Voffcv = %g is too small.\n",
pParam->BSIM4V4voffcv);
printf("Warning: Voffcv = %g is too small.\n", pParam->BSIM4V4voffcv);
}
if (pParam->BSIM4V4moin < 5.0)
{ fprintf(fplog, "Warning: Moin = %g is too small.\n",
pParam->BSIM4V4moin);
printf("Warning: Moin = %g is too small.\n", pParam->BSIM4V4moin);
}
if (pParam->BSIM4V4moin > 25.0)
{ fprintf(fplog, "Warning: Moin = %g is too large.\n",
pParam->BSIM4V4moin);
printf("Warning: Moin = %g is too large.\n", pParam->BSIM4V4moin);
}
if(model->BSIM4V4capMod ==2) {
if (pParam->BSIM4V4acde < 0.1)
{ fprintf(fplog, "Warning: Acde = %g is too small.\n",
pParam->BSIM4V4acde);
printf("Warning: Acde = %g is too small.\n", pParam->BSIM4V4acde);
}
if (pParam->BSIM4V4acde > 1.6)
{ fprintf(fplog, "Warning: Acde = %g is too large.\n",
pParam->BSIM4V4acde);
printf("Warning: Acde = %g is too large.\n", pParam->BSIM4V4acde);
}
}
/* Check overlap capacitance parameters */
if (model->BSIM4V4cgdo < 0.0)
{ fprintf(fplog, "Warning: cgdo = %g is negative. Set to zero.\n", model->BSIM4V4cgdo);
printf("Warning: cgdo = %g is negative. Set to zero.\n", model->BSIM4V4cgdo);
model->BSIM4V4cgdo = 0.0;
}
if (model->BSIM4V4cgso < 0.0)
{ fprintf(fplog, "Warning: cgso = %g is negative. Set to zero.\n", model->BSIM4V4cgso);
printf("Warning: cgso = %g is negative. Set to zero.\n", model->BSIM4V4cgso);
model->BSIM4V4cgso = 0.0;
}
if (model->BSIM4V4tnoiMod == 1) {
if (model->BSIM4V4tnoia < 0.0)
{ fprintf(fplog, "Warning: tnoia = %g is negative. Set to zero.\n", model->BSIM4V4tnoia);
printf("Warning: tnoia = %g is negative. Set to zero.\n", model->BSIM4V4tnoia);
model->BSIM4V4tnoia = 0.0;
}
if (model->BSIM4V4tnoib < 0.0)
{ fprintf(fplog, "Warning: tnoib = %g is negative. Set to zero.\n", model->BSIM4V4tnoib);
printf("Warning: tnoib = %g is negative. Set to zero.\n", model->BSIM4V4tnoib);
model->BSIM4V4tnoib = 0.0;
}
if (model->BSIM4V4rnoia < 0.0)
{ fprintf(fplog, "Warning: rnoia = %g is negative. Set to zero.\n", model->BSIM4V4rnoia);
printf("Warning: rnoia = %g is negative. Set to zero.\n", model->BSIM4V4rnoia);
model->BSIM4V4rnoia = 0.0;
}
if (model->BSIM4V4rnoib < 0.0)
{ fprintf(fplog, "Warning: rnoib = %g is negative. Set to zero.\n", model->BSIM4V4rnoib);
printf("Warning: rnoib = %g is negative. Set to zero.\n", model->BSIM4V4rnoib);
model->BSIM4V4rnoib = 0.0;
}
}
if (model->BSIM4V4SjctEmissionCoeff < 0.0)
{ fprintf(fplog, "Warning: Njs = %g is negative.\n",
model->BSIM4V4SjctEmissionCoeff);
printf("Warning: Njs = %g is negative.\n",
model->BSIM4V4SjctEmissionCoeff);
}
if (model->BSIM4V4DjctEmissionCoeff < 0.0)
{ fprintf(fplog, "Warning: Njd = %g is negative.\n",
model->BSIM4V4DjctEmissionCoeff);
printf("Warning: Njd = %g is negative.\n",
model->BSIM4V4DjctEmissionCoeff);
}
if (model->BSIM4V4njtstemp < 0.0)
{ fprintf(fplog, "Warning: Njts = %g is negative at temperature = %g.\n",
model->BSIM4V4njtstemp, ckt->CKTtemp);
printf("Warning: Njts = %g is negative at temperature = %g.\n",
model->BSIM4V4njtstemp, ckt->CKTtemp);
}
if (model->BSIM4V4njtsswtemp < 0.0)
{ fprintf(fplog, "Warning: Njtssw = %g is negative at temperature = %g.\n",
model->BSIM4V4njtsswtemp, ckt->CKTtemp);
printf("Warning: Njtssw = %g is negative at temperature = %g.\n",
model->BSIM4V4njtsswtemp, ckt->CKTtemp);
}
if (model->BSIM4V4njtsswgtemp < 0.0)
{ fprintf(fplog, "Warning: Njtsswg = %g is negative at temperature = %g.\n",
model->BSIM4V4njtsswgtemp, ckt->CKTtemp);
printf("Warning: Njtsswg = %g is negative at temperature = %g.\n",
model->BSIM4V4njtsswgtemp, ckt->CKTtemp);
}
if (model->BSIM4V4vtss < 0.0)
{ fprintf(fplog, "Warning: Vtss = %g is negative.\n",
model->BSIM4V4vtss);
printf("Warning: Vtss = %g is negative.\n",
model->BSIM4V4vtss);
}
if (model->BSIM4V4vtsd < 0.0)
{ fprintf(fplog, "Warning: Vtsd = %g is negative.\n",
model->BSIM4V4vtsd);
printf("Warning: Vtsd = %g is negative.\n",
model->BSIM4V4vtsd);
}
if (model->BSIM4V4vtssws < 0.0)
{ fprintf(fplog, "Warning: Vtssws = %g is negative.\n",
model->BSIM4V4vtssws);
printf("Warning: Vtssws = %g is negative.\n",
model->BSIM4V4vtssws);
}
if (model->BSIM4V4vtsswd < 0.0)
{ fprintf(fplog, "Warning: Vtsswd = %g is negative.\n",
model->BSIM4V4vtsswd);
printf("Warning: Vtsswd = %g is negative.\n",
model->BSIM4V4vtsswd);
}
if (model->BSIM4V4vtsswgs < 0.0)
{ fprintf(fplog, "Warning: Vtsswgs = %g is negative.\n",
model->BSIM4V4vtsswgs);
printf("Warning: Vtsswgs = %g is negative.\n",
model->BSIM4V4vtsswgs);
}
if (model->BSIM4V4vtsswgd < 0.0)
{ fprintf(fplog, "Warning: Vtsswgd = %g is negative.\n",
model->BSIM4V4vtsswgd);
printf("Warning: Vtsswgd = %g is negative.\n",
model->BSIM4V4vtsswgd);
}
if (model->BSIM4V4ntnoi < 0.0)
{ fprintf(fplog, "Warning: ntnoi = %g is negative. Set to zero.\n", model->BSIM4V4ntnoi);
printf("Warning: ntnoi = %g is negative. Set to zero.\n", model->BSIM4V4ntnoi);
model->BSIM4V4ntnoi = 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);
}

199
src/spicelib/devices/bsim4v4/b4v4cvtest.c Normal file
View File

@ -0,0 +1,199 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4cvtest.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
* Modified by Xuemei Xi, 04/06/2001.
* Modified by Xuemei Xi, 10/05/2001.
* Modified by Xuemei Xi, 05/09/2003.
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "bsim4v4def.h"
#include "trandefs.h"
#include "const.h"
#include "devdefs.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM4V4convTest(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
BSIM4V4model *model = (BSIM4V4model*)inModel;
BSIM4V4instance *here;
double delvbd, delvbs, delvds, delvgd, delvgs;
double delvdbd, delvsbs;
double delvbd_jct, delvbs_jct;
double vds, vgs, vgd, vgdo, vbs, vbd;
double vdbd, vdbs, vsbs;
double cbhat, cdhat, Idtot, Ibtot;
double vses, vdes, vdedo, delvses, delvded, delvdes;
double Isestot, cseshat, Idedtot, cdedhat;
double Igstot, cgshat, Igdtot, cgdhat, Igbtot, cgbhat;
double tol0, tol1, tol2, tol3, tol4, tol5, tol6;
for (; model != NULL; model = model->BSIM4V4nextModel)
{ for (here = model->BSIM4V4instances; here != NULL ;
here=here->BSIM4V4nextInstance)
{
if (here->BSIM4V4owner != ARCHme) continue;
vds = model->BSIM4V4type
* (*(ckt->CKTrhsOld + here->BSIM4V4dNodePrime)
- *(ckt->CKTrhsOld + here->BSIM4V4sNodePrime));
vgs = model->BSIM4V4type
* (*(ckt->CKTrhsOld + here->BSIM4V4gNodePrime)
- *(ckt->CKTrhsOld + here->BSIM4V4sNodePrime));
vbs = model->BSIM4V4type
* (*(ckt->CKTrhsOld + here->BSIM4V4bNodePrime)
- *(ckt->CKTrhsOld + here->BSIM4V4sNodePrime));
vdbs = model->BSIM4V4type
* (*(ckt->CKTrhsOld + here->BSIM4V4dbNode)
- *(ckt->CKTrhsOld + here->BSIM4V4sNodePrime));
vsbs = model->BSIM4V4type
* (*(ckt->CKTrhsOld + here->BSIM4V4sbNode)
- *(ckt->CKTrhsOld + here->BSIM4V4sNodePrime));
vses = model->BSIM4V4type
* (*(ckt->CKTrhsOld + here->BSIM4V4sNode)
- *(ckt->CKTrhsOld + here->BSIM4V4sNodePrime));
vdes = model->BSIM4V4type
* (*(ckt->CKTrhsOld + here->BSIM4V4dNode)
- *(ckt->CKTrhsOld + here->BSIM4V4sNodePrime));
vgdo = *(ckt->CKTstate0 + here->BSIM4V4vgs)
- *(ckt->CKTstate0 + here->BSIM4V4vds);
vbd = vbs - vds;
vdbd = vdbs - vds;
vgd = vgs - vds;
delvbd = vbd - *(ckt->CKTstate0 + here->BSIM4V4vbd);
delvdbd = vdbd - *(ckt->CKTstate0 + here->BSIM4V4vdbd);
delvgd = vgd - vgdo;
delvds = vds - *(ckt->CKTstate0 + here->BSIM4V4vds);
delvgs = vgs - *(ckt->CKTstate0 + here->BSIM4V4vgs);
delvbs = vbs - *(ckt->CKTstate0 + here->BSIM4V4vbs);
delvsbs = vsbs - *(ckt->CKTstate0 + here->BSIM4V4vsbs);
delvses = vses - (*(ckt->CKTstate0 + here->BSIM4V4vses));
vdedo = *(ckt->CKTstate0 + here->BSIM4V4vdes)
- *(ckt->CKTstate0 + here->BSIM4V4vds);
delvdes = vdes - *(ckt->CKTstate0 + here->BSIM4V4vdes);
delvded = vdes - vds - vdedo;
delvbd_jct = (!here->BSIM4V4rbodyMod) ? delvbd : delvdbd;
delvbs_jct = (!here->BSIM4V4rbodyMod) ? delvbs : delvsbs;
if (here->BSIM4V4mode >= 0)
{ Idtot = here->BSIM4V4cd + here->BSIM4V4csub - here->BSIM4V4cbd
+ here->BSIM4V4Igidl;
cdhat = Idtot - here->BSIM4V4gbd * delvbd_jct
+ (here->BSIM4V4gmbs + here->BSIM4V4gbbs + here->BSIM4V4ggidlb) * delvbs
+ (here->BSIM4V4gm + here->BSIM4V4gbgs + here->BSIM4V4ggidlg) * delvgs
+ (here->BSIM4V4gds + here->BSIM4V4gbds + here->BSIM4V4ggidld) * delvds;
Igstot = here->BSIM4V4Igs + here->BSIM4V4Igcs;
cgshat = Igstot + (here->BSIM4V4gIgsg + here->BSIM4V4gIgcsg) * delvgs
+ here->BSIM4V4gIgcsd * delvds + here->BSIM4V4gIgcsb * delvbs;
Igdtot = here->BSIM4V4Igd + here->BSIM4V4Igcd;
cgdhat = Igdtot + here->BSIM4V4gIgdg * delvgd + here->BSIM4V4gIgcdg * delvgs
+ here->BSIM4V4gIgcdd * delvds + here->BSIM4V4gIgcdb * delvbs;
Igbtot = here->BSIM4V4Igb;
cgbhat = here->BSIM4V4Igb + here->BSIM4V4gIgbg * delvgs + here->BSIM4V4gIgbd
* delvds + here->BSIM4V4gIgbb * delvbs;
}
else
{ Idtot = here->BSIM4V4cd + here->BSIM4V4cbd - here->BSIM4V4Igidl; /* bugfix */
cdhat = Idtot + here->BSIM4V4gbd * delvbd_jct + here->BSIM4V4gmbs
* delvbd + here->BSIM4V4gm * delvgd
- (here->BSIM4V4gds + here->BSIM4V4ggidls) * delvds
- here->BSIM4V4ggidlg * delvgs - here->BSIM4V4ggidlb * delvbs;
Igstot = here->BSIM4V4Igs + here->BSIM4V4Igcd;
cgshat = Igstot + here->BSIM4V4gIgsg * delvgs + here->BSIM4V4gIgcdg * delvgd
- here->BSIM4V4gIgcdd * delvds + here->BSIM4V4gIgcdb * delvbd;
Igdtot = here->BSIM4V4Igd + here->BSIM4V4Igcs;
cgdhat = Igdtot + (here->BSIM4V4gIgdg + here->BSIM4V4gIgcsg) * delvgd
- here->BSIM4V4gIgcsd * delvds + here->BSIM4V4gIgcsb * delvbd;
Igbtot = here->BSIM4V4Igb;
cgbhat = here->BSIM4V4Igb + here->BSIM4V4gIgbg * delvgd - here->BSIM4V4gIgbd
* delvds + here->BSIM4V4gIgbb * delvbd;
}
Isestot = here->BSIM4V4gstot * (*(ckt->CKTstate0 + here->BSIM4V4vses));
cseshat = Isestot + here->BSIM4V4gstot * delvses
+ here->BSIM4V4gstotd * delvds + here->BSIM4V4gstotg * delvgs
+ here->BSIM4V4gstotb * delvbs;
Idedtot = here->BSIM4V4gdtot * vdedo;
cdedhat = Idedtot + here->BSIM4V4gdtot * delvded
+ here->BSIM4V4gdtotd * delvds + here->BSIM4V4gdtotg * delvgs
+ here->BSIM4V4gdtotb * delvbs;
/*
* Check convergence
*/
if ((here->BSIM4V4off == 0) || (!(ckt->CKTmode & MODEINITFIX)))
{ tol0 = ckt->CKTreltol * MAX(fabs(cdhat), fabs(Idtot))
+ ckt->CKTabstol;
tol1 = ckt->CKTreltol * MAX(fabs(cseshat), fabs(Isestot))
+ ckt->CKTabstol;
tol2 = ckt->CKTreltol * MAX(fabs(cdedhat), fabs(Idedtot))
+ ckt->CKTabstol;
tol3 = ckt->CKTreltol * MAX(fabs(cgshat), fabs(Igstot))
+ ckt->CKTabstol;
tol4 = ckt->CKTreltol * MAX(fabs(cgdhat), fabs(Igdtot))
+ ckt->CKTabstol;
tol5 = ckt->CKTreltol * MAX(fabs(cgbhat), fabs(Igbtot))
+ ckt->CKTabstol;
if ((fabs(cdhat - Idtot) >= tol0) || (fabs(cseshat - Isestot) >= tol1)
|| (fabs(cdedhat - Idedtot) >= tol2))
{ ckt->CKTnoncon++;
return(OK);
}
if ((fabs(cgshat - Igstot) >= tol3) || (fabs(cgdhat - Igdtot) >= tol4)
|| (fabs(cgbhat - Igbtot) >= tol5))
{ ckt->CKTnoncon++;
return(OK);
}
Ibtot = here->BSIM4V4cbs + here->BSIM4V4cbd
- here->BSIM4V4Igidl - here->BSIM4V4Igisl - here->BSIM4V4csub;
if (here->BSIM4V4mode >= 0)
{ cbhat = Ibtot + here->BSIM4V4gbd * delvbd_jct
+ here->BSIM4V4gbs * delvbs_jct - (here->BSIM4V4gbbs + here->BSIM4V4ggidlb)
* delvbs - (here->BSIM4V4gbgs + here->BSIM4V4ggidlg) * delvgs
- (here->BSIM4V4gbds + here->BSIM4V4ggidld) * delvds
- here->BSIM4V4ggislg * delvgd - here->BSIM4V4ggislb* delvbd + here->BSIM4V4ggisls * delvds ;
}
else
{ cbhat = Ibtot + here->BSIM4V4gbs * delvbs_jct + here->BSIM4V4gbd
* delvbd_jct - (here->BSIM4V4gbbs + here->BSIM4V4ggislb) * delvbd
- (here->BSIM4V4gbgs + here->BSIM4V4ggislg) * delvgd
+ (here->BSIM4V4gbds + here->BSIM4V4ggisld - here->BSIM4V4ggidls) * delvds
- here->BSIM4V4ggidlg * delvgs - here->BSIM4V4ggidlb * delvbs;
}
tol6 = ckt->CKTreltol * MAX(fabs(cbhat),
fabs(Ibtot)) + ckt->CKTabstol;
if (fabs(cbhat - Ibtot) > tol6)
{ ckt->CKTnoncon++;
return(OK);
}
}
}
}
return(OK);
}

41
src/spicelib/devices/bsim4v4/b4v4del.c Normal file
View File

@ -0,0 +1,41 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4del.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
**********/
#include "ngspice.h"
#include "bsim4v4def.h"
#include "sperror.h"
#include "gendefs.h"
#include "suffix.h"
int
BSIM4V4delete(inModel,name,inInst)
GENmodel *inModel;
IFuid name;
GENinstance **inInst;
{
BSIM4V4instance **fast = (BSIM4V4instance**)inInst;
BSIM4V4model *model = (BSIM4V4model*)inModel;
BSIM4V4instance **prev = NULL;
BSIM4V4instance *here;
for (; model ; model = model->BSIM4V4nextModel)
{ prev = &(model->BSIM4V4instances);
for (here = *prev; here ; here = *prev)
{ if (here->BSIM4V4name == name || (fast && here==*fast))
{ *prev= here->BSIM4V4nextInstance;
FREE(here);
return(OK);
}
prev = &(here->BSIM4V4nextInstance);
}
}
return(E_NODEV);
}

38
src/spicelib/devices/bsim4v4/b4v4dest.c Normal file
View File

@ -0,0 +1,38 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4dest.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
**********/
#include "ngspice.h"
#include "bsim4v4def.h"
#include "suffix.h"
void
BSIM4V4destroy(inModel)
GENmodel **inModel;
{
BSIM4V4model **model = (BSIM4V4model**)inModel;
BSIM4V4instance *here;
BSIM4V4instance *prev = NULL;
BSIM4V4model *mod = *model;
BSIM4V4model *oldmod = NULL;
for (; mod ; mod = mod->BSIM4V4nextModel)
{ if(oldmod) FREE(oldmod);
oldmod = mod;
prev = (BSIM4V4instance *)NULL;
for (here = mod->BSIM4V4instances; here; here = here->BSIM4V4nextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
}
if(oldmod) FREE(oldmod);
*model = NULL;
return;
}

385
src/spicelib/devices/bsim4v4/b4v4geo.c Normal file
View File

@ -0,0 +1,385 @@
/**** BSIM4.4.0 Released by Xuemei(Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2003 Regents of the University of California. All rights reserved.
* File: b4geo.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
**********/
#include "ngspice.h"
/*
* WDLiu:
* This subrutine is a special module to process the geometry dependent
* parasitics for BSIM4V4, which calculates Ps, Pd, As, Ad, and Rs and Rd
* for multi-fingers and varous GEO and RGEO options.
*/
int
BSIM4V4RdsEndIso(double, double, double, double, double, double, int, int, double *);
int
BSIM4V4RdsEndSha(double, double, double, double, double, double, int, int, double *);
int
BSIM4V4NumFingerDiff(nf, minSD, nuIntD, nuEndD, nuIntS, nuEndS)
int minSD;
double nf, *nuIntD, *nuEndD, *nuIntS, *nuEndS;
{
int NF;
NF = (int)nf;
if ((NF%2) != 0)
{ *nuEndD = *nuEndS = 1.0;
*nuIntD = *nuIntS = 2.0 * MAX((nf - 1.0) / 2.0, 0.0);
}
else
{ if (minSD == 1) /* minimize # of source */
{ *nuEndD = 2.0;
*nuIntD = 2.0 * MAX((nf / 2.0 - 1.0), 0.0);
*nuEndS = 0.0;
*nuIntS = nf;
}
else
{ *nuEndD = 0.0;
*nuIntD = nf;
*nuEndS = 2.0;
*nuIntS = 2.0 * MAX((nf / 2.0 - 1.0), 0.0);
}
}
return 0;
}
int
BSIM4V4PAeffGeo(nf, geo, minSD, Weffcj, DMCG, DMCI, DMDG, Ps, Pd, As, Ad)
int geo, minSD;
double Weffcj, DMCG, DMCI, DMDG;
double nf, *Ps, *Pd, *As, *Ad;
{
double T0, T1, T2;
double ADiso, ADsha, ADmer, ASiso, ASsha, ASmer;
double PDiso, PDsha, PDmer, PSiso, PSsha, PSmer;
double nuIntD = 0.0, nuEndD = 0.0, nuIntS = 0.0, nuEndS = 0.0;
if (geo < 9) /* For geo = 9 and 10, the numbers of S/D diffusions already known */
BSIM4V4NumFingerDiff(nf, minSD, &nuIntD, &nuEndD, &nuIntS, &nuEndS);
T0 = DMCG + DMCI;
T1 = DMCG + DMCG;
T2 = DMDG + DMDG;
PSiso = PDiso = T0 + T0 + Weffcj;
PSsha = PDsha = T1;
PSmer = PDmer = T2;
ASiso = ADiso = T0 * Weffcj;
ASsha = ADsha = DMCG * Weffcj;
ASmer = ADmer = DMDG * Weffcj;
switch(geo)
{ case 0:
*Ps = nuEndS * PSiso + nuIntS * PSsha;
*Pd = nuEndD * PDiso + nuIntD * PDsha;
*As = nuEndS * ASiso + nuIntS * ASsha;
*Ad = nuEndD * ADiso + nuIntD * ADsha;
break;
case 1:
*Ps = nuEndS * PSiso + nuIntS * PSsha;
*Pd = (nuEndD + nuIntD) * PDsha;
*As = nuEndS * ASiso + nuIntS * ASsha;
*Ad = (nuEndD + nuIntD) * ADsha;
break;
case 2:
*Ps = (nuEndS + nuIntS) * PSsha;
*Pd = nuEndD * PDiso + nuIntD * PDsha;
*As = (nuEndS + nuIntS) * ASsha;
*Ad = nuEndD * ADiso + nuIntD * ADsha;
break;
case 3:
*Ps = (nuEndS + nuIntS) * PSsha;
*Pd = (nuEndD + nuIntD) * PDsha;
*As = (nuEndS + nuIntS) * ASsha;
*Ad = (nuEndD + nuIntD) * ADsha;
break;
case 4:
*Ps = nuEndS * PSiso + nuIntS * PSsha;
*Pd = nuEndD * PDmer + nuIntD * PDsha;
*As = nuEndS * ASiso + nuIntS * ASsha;
*Ad = nuEndD * ADmer + nuIntD * ADsha;
break;
case 5:
*Ps = (nuEndS + nuIntS) * PSsha;
*Pd = nuEndD * PDmer + nuIntD * PDsha;
*As = (nuEndS + nuIntS) * ASsha;
*Ad = nuEndD * ADmer + nuIntD * ADsha;
break;
case 6:
*Ps = nuEndS * PSmer + nuIntS * PSsha;
*Pd = nuEndD * PDiso + nuIntD * PDsha;
*As = nuEndS * ASmer + nuIntS * ASsha;
*Ad = nuEndD * ADiso + nuIntD * ADsha;
break;
case 7:
*Ps = nuEndS * PSmer + nuIntS * PSsha;
*Pd = (nuEndD + nuIntD) * PDsha;
*As = nuEndS * ASmer + nuIntS * ASsha;
*Ad = (nuEndD + nuIntD) * ADsha;
break;
case 8:
*Ps = nuEndS * PSmer + nuIntS * PSsha;
*Pd = nuEndD * PDmer + nuIntD * PDsha;
*As = nuEndS * ASmer + nuIntS * ASsha;
*Ad = nuEndD * ADmer + nuIntD * ADsha;
break;
case 9: /* geo = 9 and 10 happen only when nf = even */
*Ps = PSiso + (nf - 1.0) * PSsha;
*Pd = nf * PDsha;
*As = ASiso + (nf - 1.0) * ASsha;
*Ad = nf * ADsha;
break;
case 10:
*Ps = nf * PSsha;
*Pd = PDiso + (nf - 1.0) * PDsha;
*As = nf * ASsha;
*Ad = ADiso + (nf - 1.0) * ADsha;
break;
default:
printf("Warning: Specified GEO = %d not matched\n", geo);
}
return 0;
}
int
BSIM4V4RdseffGeo(nf, geo, rgeo, minSD, Weffcj, Rsh, DMCG, DMCI, DMDG, Type, Rtot)
int geo, rgeo, minSD, Type;
double nf, Weffcj, Rsh, DMCG, DMCI, DMDG;
double *Rtot;
{
double Rint=0.0, Rend = 0.0;
double nuIntD = 0.0, nuEndD = 0.0, nuIntS = 0.0, nuEndS = 0.0;
if (geo < 9) /* since geo = 9 and 10 only happen when nf = even */
{ BSIM4V4NumFingerDiff(nf, minSD, &nuIntD, &nuEndD, &nuIntS, &nuEndS);
/* Internal S/D resistance -- assume shared S or D and all wide contacts */
if (Type == 1)
{ if (nuIntS == 0.0)
Rint = 0.0;
else
Rint = Rsh * DMCG / ( Weffcj * nuIntS);
}
else
{ if (nuIntD == 0.0)
Rint = 0.0;
else
Rint = Rsh * DMCG / ( Weffcj * nuIntD);
}
}
/* End S/D resistance -- geo dependent */
switch(geo)
{ case 0:
if (Type == 1) BSIM4V4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndS, rgeo, 1, &Rend);
else BSIM4V4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndD, rgeo, 0, &Rend);
break;
case 1:
if (Type == 1) BSIM4V4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndS, rgeo, 1, &Rend);
else BSIM4V4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndD, rgeo, 0, &Rend);
break;
case 2:
if (Type == 1) BSIM4V4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndS, rgeo, 1, &Rend);
else BSIM4V4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndD, rgeo, 0, &Rend);
break;
case 3:
if (Type == 1) BSIM4V4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndS, rgeo, 1, &Rend);
else BSIM4V4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndD, rgeo, 0, &Rend);
break;
case 4:
if (Type == 1) BSIM4V4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndS, rgeo, 1, &Rend);
else Rend = Rsh * DMDG / Weffcj;
break;
case 5:
if (Type == 1) BSIM4V4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndS, rgeo, 1, &Rend);
else Rend = Rsh * DMDG / (Weffcj * nuEndD);
break;
case 6:
if (Type == 1) Rend = Rsh * DMDG / Weffcj;
else BSIM4V4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndD, rgeo, 0, &Rend);
break;
case 7:
if (Type == 1) Rend = Rsh * DMDG / (Weffcj * nuEndS);
else BSIM4V4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG,
nuEndD, rgeo, 0, &Rend);
break;
case 8:
Rend = Rsh * DMDG / Weffcj;
break;
case 9: /* all wide contacts assumed for geo = 9 and 10 */
if (Type == 1)
{ Rend = 0.5 * Rsh * DMCG / Weffcj;
if (nf == 2.0)
Rint = 0.0;
else
Rint = Rsh * DMCG / (Weffcj * (nf - 2.0));
}
else
{ Rend = 0.0;
Rint = Rsh * DMCG / (Weffcj * nf);
}
break;
case 10:
if (Type == 1)
{ Rend = 0.0;
Rint = Rsh * DMCG / (Weffcj * nf);
}
else
{ Rend = 0.5 * Rsh * DMCG / Weffcj;;
if (nf == 2.0)
Rint = 0.0;
else
Rint = Rsh * DMCG / (Weffcj * (nf - 2.0));
}
break;
default:
printf("Warning: Specified GEO = %d not matched\n", geo);
}
if (Rint <= 0.0)
*Rtot = Rend;
else if (Rend <= 0.0)
*Rtot = Rint;
else
*Rtot = Rint * Rend / (Rint + Rend);
if(*Rtot==0.0)
printf("Warning: Zero resistance returned from RdseffGeo\n");
return 0;
}
int
BSIM4V4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEnd, rgeo, Type, Rend)
double Weffcj, Rsh, DMCG, DMCI, DMDG;
int rgeo, Type;
double nuEnd, *Rend;
{
if (Type == 1)
{ switch(rgeo)
{ case 1:
case 2:
case 5:
if (nuEnd == 0.0)
*Rend = 0.0;
else
*Rend = Rsh * DMCG / (Weffcj * nuEnd);
break;
case 3:
case 4:
case 6:
if ((DMCG + DMCI) == 0.0)
printf("(DMCG + DMCI) can not be equal to zero\n");
if (nuEnd == 0.0)
*Rend = 0.0;
else
*Rend = Rsh * Weffcj / (3.0 * nuEnd * (DMCG + DMCI));
break;
default:
printf("Warning: Specified RGEO = %d not matched\n", rgeo);
}
}
else
{ switch(rgeo)
{ case 1:
case 3:
case 7:
if (nuEnd == 0.0)
*Rend = 0.0;
else
*Rend = Rsh * DMCG / (Weffcj * nuEnd);
break;
case 2:
case 4:
case 8:
if ((DMCG + DMCI) == 0.0)
printf("(DMCG + DMCI) can not be equal to zero\n");
if (nuEnd == 0.0)
*Rend = 0.0;
else
*Rend = Rsh * Weffcj / (3.0 * nuEnd * (DMCG + DMCI));
break;
default:
printf("Warning: Specified RGEO = %d not matched\n", rgeo);
}
}
return 0;
}
int
BSIM4V4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEnd, rgeo, Type, Rend)
double Weffcj, Rsh, DMCG, DMCI, DMDG;
int rgeo, Type;
double nuEnd, *Rend;
{
if (Type == 1)
{ switch(rgeo)
{ case 1:
case 2:
case 5:
if (nuEnd == 0.0)
*Rend = 0.0;
else
*Rend = Rsh * DMCG / (Weffcj * nuEnd);
break;
case 3:
case 4:
case 6:
if (DMCG == 0.0)
printf("DMCG can not be equal to zero\n");
if (nuEnd == 0.0)
*Rend = 0.0;
else
*Rend = Rsh * Weffcj / (6.0 * nuEnd * DMCG);
break;
default:
printf("Warning: Specified RGEO = %d not matched\n", rgeo);
}
}
else
{ switch(rgeo)
{ case 1:
case 3:
case 7:
if (nuEnd == 0.0)
*Rend = 0.0;
else
*Rend = Rsh * DMCG / (Weffcj * nuEnd);
break;
case 2:
case 4:
case 8:
if (DMCG == 0.0)
printf("DMCG can not be equal to zero\n");
if (nuEnd == 0.0)
*Rend = 0.0;
else
*Rend = Rsh * Weffcj / (6.0 * nuEnd * DMCG);
break;
default:
printf("Warning: Specified RGEO = %d not matched\n", rgeo);
}
}
return 0;
}

44
src/spicelib/devices/bsim4v4/b4v4getic.c Normal file
View File

@ -0,0 +1,44 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4getic.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "bsim4v4def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM4V4getic(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
BSIM4V4model *model = (BSIM4V4model*)inModel;
BSIM4V4instance *here;
for (; model ; model = model->BSIM4V4nextModel)
{ for (here = model->BSIM4V4instances; here; here = here->BSIM4V4nextInstance)
{ if (here->BSIM4V4owner != ARCHme) continue;
if (!here->BSIM4V4icVDSGiven)
{ here->BSIM4V4icVDS = *(ckt->CKTrhs + here->BSIM4V4dNode)
- *(ckt->CKTrhs + here->BSIM4V4sNode);
}
if (!here->BSIM4V4icVGSGiven)
{ here->BSIM4V4icVGS = *(ckt->CKTrhs + here->BSIM4V4gNodeExt)
- *(ckt->CKTrhs + here->BSIM4V4sNode);
}
if(!here->BSIM4V4icVBSGiven)
{ here->BSIM4V4icVBS = *(ckt->CKTrhs + here->BSIM4V4bNode)
- *(ckt->CKTrhs + here->BSIM4V4sNode);
}
}
}
return(OK);
}

4743
src/spicelib/devices/bsim4v4/b4v4ld.c Normal file
View File

File diff suppressed because it is too large Load Diff

1979
src/spicelib/devices/bsim4v4/b4v4mask.c Normal file
View File

File diff suppressed because it is too large Load Diff

46
src/spicelib/devices/bsim4v4/b4v4mdel.c Normal file
View File

@ -0,0 +1,46 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4mdel.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
**********/
#include "ngspice.h"
#include "bsim4v4def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM4V4mDelete(inModel,modname,kill)
GENmodel **inModel;
IFuid modname;
GENmodel *kill;
{
BSIM4V4model **model = (BSIM4V4model**)inModel;
BSIM4V4model *modfast = (BSIM4V4model*)kill;
BSIM4V4instance *here;
BSIM4V4instance *prev = NULL;
BSIM4V4model **oldmod;
oldmod = model;
for (; *model ; model = &((*model)->BSIM4V4nextModel))
{ if ((*model)->BSIM4V4modName == modname ||
(modfast && *model == modfast))
goto delgot;
oldmod = model;
}
return(E_NOMOD);
delgot:
*oldmod = (*model)->BSIM4V4nextModel; /* cut deleted device out of list */
for (here = (*model)->BSIM4V4instances; here; here = here->BSIM4V4nextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
FREE(*model);
return(OK);
}

2817
src/spicelib/devices/bsim4v4/b4v4mpar.c Normal file
View File

File diff suppressed because it is too large Load Diff

488
src/spicelib/devices/bsim4v4/b4v4noi.c Normal file
View File

@ -0,0 +1,488 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4noi.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
* Modified by Xuemei Xi, 04/06/2001.
* Modified by Xuemei Xi, 10/05/2001.
* Modified by Xuemei Xi, 11/15/2002.
* Modified by Xuemei Xi, 05/09/2003.
* Modified by Xuemei Xi, 03/04/2004.
**********/
#include "ngspice.h"
#include "bsim4v4def.h"
#include "cktdefs.h"
#include "iferrmsg.h"
#include "noisedef.h"
#include "suffix.h"
#include "const.h"
extern void NevalSrc();
extern double Nintegrate();
/*
* WDL: 1/f noise model has been smoothed out and enhanced with
* bulk charge effect as well as physical N* equ. and necessary
* conversion into the SI unit system.
*/
static double
Eval1ovFNoise(Vds, model, here, freq, temp)
double Vds, freq, temp;
BSIM4V4model *model;
BSIM4V4instance *here;
{
struct bsim4SizeDependParam *pParam;
double cd, esat, DelClm, EffFreq, N0, Nl, Leff, Leffsq;
double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ssi;
pParam = here->pParam;
cd = fabs(here->BSIM4V4cd);
Leff = pParam->BSIM4V4leff - 2.0 * model->BSIM4V4lintnoi;
Leffsq = Leff * Leff;
esat = 2.0 * here->BSIM4V4vsattemp / here->BSIM4V4ueff;
if(model->BSIM4V4em<=0.0) DelClm = 0.0; /* flicker noise modified -JX */
else {
T0 = ((((Vds - here->BSIM4V4Vdseff) / pParam->BSIM4V4litl)
+ model->BSIM4V4em) / esat);
DelClm = pParam->BSIM4V4litl * log (MAX(T0, N_MINLOG));
}
EffFreq = pow(freq, model->BSIM4V4ef);
T1 = CHARGE * CHARGE * CONSTboltz * cd * temp * here->BSIM4V4ueff;
T2 = 1.0e10 * EffFreq * here->BSIM4V4Abulk * model->BSIM4V4coxe * Leffsq;
N0 = model->BSIM4V4coxe * here->BSIM4V4Vgsteff / CHARGE;
Nl = model->BSIM4V4coxe * here->BSIM4V4Vgsteff
* (1.0 - here->BSIM4V4AbovVgst2Vtm * here->BSIM4V4Vdseff) / CHARGE;
T3 = model->BSIM4V4oxideTrapDensityA
* log(MAX(((N0 + here->BSIM4V4nstar) / (Nl + here->BSIM4V4nstar)), N_MINLOG));
T4 = model->BSIM4V4oxideTrapDensityB * (N0 - Nl);
T5 = model->BSIM4V4oxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl);
T6 = CONSTboltz * temp * cd * cd;
T7 = 1.0e10 * EffFreq * Leffsq * pParam->BSIM4V4weff;
T8 = model->BSIM4V4oxideTrapDensityA + model->BSIM4V4oxideTrapDensityB * Nl
+ model->BSIM4V4oxideTrapDensityC * Nl * Nl;
T9 = (Nl + here->BSIM4V4nstar) * (Nl + here->BSIM4V4nstar);
Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9;
return Ssi;
}
int
BSIM4V4noise (mode, operation, inModel, ckt, data, OnDens)
int mode, operation;
GENmodel *inModel;
CKTcircuit *ckt;
Ndata *data;
double *OnDens;
{
BSIM4V4model *model = (BSIM4V4model *)inModel;
BSIM4V4instance *here;
struct bsim4SizeDependParam *pParam;
char name[N_MXVLNTH];
double tempOnoise;
double tempInoise;
double noizDens[BSIM4V4NSRCS];
double lnNdens[BSIM4V4NSRCS];
double T0, T1, T2, T5, T10, T11;
double Vds, Ssi, Swi;
double tmp=0.0, gdpr, gspr, npart_theta=0.0, npart_beta=0.0, igsquare;
double m;
int i;
/* define the names of the noise sources */
static char *BSIM4V4nNames[BSIM4V4NSRCS] =
{ /* Note that we have to keep the order */
".rd", /* noise due to rd */
".rs", /* noise due to rs */
".rg", /* noise due to rgeltd */
".rbps", /* noise due to rbps */
".rbpd", /* noise due to rbpd */
".rbpb", /* noise due to rbpb */
".rbsb", /* noise due to rbsb */
".rbdb", /* noise due to rbdb */
".id", /* noise due to id */
".1overf", /* flicker (1/f) noise */
".igs", /* shot noise due to IGS */
".igd", /* shot noise due to IGD */
".igb", /* shot noise due to IGB */
"" /* total transistor noise */
};
for (; model != NULL; model = model->BSIM4V4nextModel)
{ for (here = model->BSIM4V4instances; here != NULL;
here = here->BSIM4V4nextInstance)
{ 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 < BSIM4V4NSRCS; i++)
{ (void) sprintf(name, "onoise.%s%s",
here->BSIM4V4name,
BSIM4V4nNames[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 < BSIM4V4NSRCS; i++)
{ (void) sprintf(name, "onoise_total.%s%s",
here->BSIM4V4name,
BSIM4V4nNames[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->BSIM4V4name,
BSIM4V4nNames[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:
m = here->BSIM4V4m;
switch (mode)
{ case N_DENS:
if (model->BSIM4V4tnoiMod == 0)
{ if (model->BSIM4V4rdsMod == 0)
{ gspr = here->BSIM4V4sourceConductance;
gdpr = here->BSIM4V4drainConductance;
if (here->BSIM4V4grdsw > 0.0)
tmp = 1.0 / here->BSIM4V4grdsw; /* tmp used below */
else
tmp = 0.0;
}
else
{ gspr = here->BSIM4V4gstot;
gdpr = here->BSIM4V4gdtot;
tmp = 0.0;
}
}
else
{ T5 = here->BSIM4V4Vgsteff / here->BSIM4V4EsatL;
T5 *= T5;
npart_beta = model->BSIM4V4rnoia * (1.0 + T5
* model->BSIM4V4tnoia * pParam->BSIM4V4leff);
npart_theta = model->BSIM4V4rnoib * (1.0 + T5
* model->BSIM4V4tnoib * pParam->BSIM4V4leff);
if (model->BSIM4V4rdsMod == 0)
{ gspr = here->BSIM4V4sourceConductance;
gdpr = here->BSIM4V4drainConductance;
}
else
{ gspr = here->BSIM4V4gstot;
gdpr = here->BSIM4V4gdtot;
}
if ((*(ckt->CKTstates[0] + here->BSIM4V4vds)) >= 0.0)
gspr = gspr / (1.0 + npart_theta * npart_theta * gspr
/ here->BSIM4V4IdovVds); /* bugfix */
else
gdpr = gdpr / (1.0 + npart_theta * npart_theta * gdpr
/ here->BSIM4V4IdovVds);
}
NevalSrc(&noizDens[BSIM4V4RDNOIZ],
&lnNdens[BSIM4V4RDNOIZ], ckt, THERMNOISE,
here->BSIM4V4dNodePrime, here->BSIM4V4dNode,
gdpr * m);
NevalSrc(&noizDens[BSIM4V4RSNOIZ],
&lnNdens[BSIM4V4RSNOIZ], ckt, THERMNOISE,
here->BSIM4V4sNodePrime, here->BSIM4V4sNode,
gspr * m);
if ((here->BSIM4V4rgateMod == 1) || (here->BSIM4V4rgateMod == 2))
{ NevalSrc(&noizDens[BSIM4V4RGNOIZ],
&lnNdens[BSIM4V4RGNOIZ], ckt, THERMNOISE,
here->BSIM4V4gNodePrime, here->BSIM4V4gNodeExt,
here->BSIM4V4grgeltd * m);
}
else if (here->BSIM4V4rgateMod == 3)
{ NevalSrc(&noizDens[BSIM4V4RGNOIZ],
&lnNdens[BSIM4V4RGNOIZ], ckt, THERMNOISE,
here->BSIM4V4gNodeMid, here->BSIM4V4gNodeExt,
here->BSIM4V4grgeltd * m);
}
else
{ noizDens[BSIM4V4RGNOIZ] = 0.0;
lnNdens[BSIM4V4RGNOIZ] =
log(MAX(noizDens[BSIM4V4RGNOIZ], N_MINLOG));
}
if (here->BSIM4V4rbodyMod)
{ NevalSrc(&noizDens[BSIM4V4RBPSNOIZ],
&lnNdens[BSIM4V4RBPSNOIZ], ckt, THERMNOISE,
here->BSIM4V4bNodePrime, here->BSIM4V4sbNode,
here->BSIM4V4grbps * m);
NevalSrc(&noizDens[BSIM4V4RBPDNOIZ],
&lnNdens[BSIM4V4RBPDNOIZ], ckt, THERMNOISE,
here->BSIM4V4bNodePrime, here->BSIM4V4dbNode,
here->BSIM4V4grbpd * m);
NevalSrc(&noizDens[BSIM4V4RBPBNOIZ],
&lnNdens[BSIM4V4RBPBNOIZ], ckt, THERMNOISE,
here->BSIM4V4bNodePrime, here->BSIM4V4bNode,
here->BSIM4V4grbpb * m);
NevalSrc(&noizDens[BSIM4V4RBSBNOIZ],
&lnNdens[BSIM4V4RBSBNOIZ], ckt, THERMNOISE,
here->BSIM4V4bNode, here->BSIM4V4sbNode,
here->BSIM4V4grbsb * m);
NevalSrc(&noizDens[BSIM4V4RBDBNOIZ],
&lnNdens[BSIM4V4RBDBNOIZ], ckt, THERMNOISE,
here->BSIM4V4bNode, here->BSIM4V4dbNode,
here->BSIM4V4grbdb * m);
}
else
{ noizDens[BSIM4V4RBPSNOIZ] = noizDens[BSIM4V4RBPDNOIZ] = 0.0;
noizDens[BSIM4V4RBPBNOIZ] = 0.0;
noizDens[BSIM4V4RBSBNOIZ] = noizDens[BSIM4V4RBDBNOIZ] = 0.0;
lnNdens[BSIM4V4RBPSNOIZ] =
log(MAX(noizDens[BSIM4V4RBPSNOIZ], N_MINLOG));
lnNdens[BSIM4V4RBPDNOIZ] =
log(MAX(noizDens[BSIM4V4RBPDNOIZ], N_MINLOG));
lnNdens[BSIM4V4RBPBNOIZ] =
log(MAX(noizDens[BSIM4V4RBPBNOIZ], N_MINLOG));
lnNdens[BSIM4V4RBSBNOIZ] =
log(MAX(noizDens[BSIM4V4RBSBNOIZ], N_MINLOG));
lnNdens[BSIM4V4RBDBNOIZ] =
log(MAX(noizDens[BSIM4V4RBDBNOIZ], N_MINLOG));
}
switch(model->BSIM4V4tnoiMod)
{ case 0:
T0 = m * here->BSIM4V4ueff * fabs(here->BSIM4V4qinv);
T1 = T0 * tmp + pParam->BSIM4V4leff
* pParam->BSIM4V4leff;
NevalSrc(&noizDens[BSIM4V4IDNOIZ],
&lnNdens[BSIM4V4IDNOIZ], ckt,
THERMNOISE, here->BSIM4V4dNodePrime,
here->BSIM4V4sNodePrime,
(T0 / T1) * model->BSIM4V4ntnoi);
break;
case 1:
T0 = m * (here->BSIM4V4gm + here->BSIM4V4gmbs + here->BSIM4V4gds);
T0 *= T0;
igsquare = npart_theta * npart_theta * T0 / here->BSIM4V4IdovVds;
T1 = npart_beta * (here->BSIM4V4gm
+ here->BSIM4V4gmbs) + here->BSIM4V4gds;
T2 = T1 * T1 / here->BSIM4V4IdovVds;
NevalSrc(&noizDens[BSIM4V4IDNOIZ],
&lnNdens[BSIM4V4IDNOIZ], ckt,
THERMNOISE, here->BSIM4V4dNodePrime,
here->BSIM4V4sNodePrime, (T2 - igsquare));
break;
}
NevalSrc(&noizDens[BSIM4V4FLNOIZ], (double*) NULL,
ckt, N_GAIN, here->BSIM4V4dNodePrime,
here->BSIM4V4sNodePrime, (double) 0.0);
switch(model->BSIM4V4fnoiMod)
{ case 0:
noizDens[BSIM4V4FLNOIZ] *= m * model->BSIM4V4kf
* exp(model->BSIM4V4af
* log(MAX(fabs(here->BSIM4V4cd),
N_MINLOG)))
/ (pow(data->freq, model->BSIM4V4ef)
* pParam->BSIM4V4leff
* pParam->BSIM4V4leff
* model->BSIM4V4coxe);
break;
case 1:
Vds = *(ckt->CKTstates[0] + here->BSIM4V4vds);
if (Vds < 0.0)
Vds = -Vds;
Ssi = Eval1ovFNoise(Vds, model, here,
data->freq, ckt->CKTtemp);
T10 = model->BSIM4V4oxideTrapDensityA
* CONSTboltz * ckt->CKTtemp;
T11 = pParam->BSIM4V4weff * pParam->BSIM4V4leff
* pow(data->freq, model->BSIM4V4ef) * 1.0e10
* here->BSIM4V4nstar * here->BSIM4V4nstar;
Swi = T10 / T11 * here->BSIM4V4cd
* here->BSIM4V4cd;
T1 = Swi + Ssi;
if (T1 > 0.0)
noizDens[BSIM4V4FLNOIZ] *= m * (Ssi * Swi) / T1;
else
noizDens[BSIM4V4FLNOIZ] *= 0.0;
break;
}
lnNdens[BSIM4V4FLNOIZ] =
log(MAX(noizDens[BSIM4V4FLNOIZ], N_MINLOG));
if(here->BSIM4V4mode >= 0) { /* bugfix */
NevalSrc(&noizDens[BSIM4V4IGSNOIZ],
&lnNdens[BSIM4V4IGSNOIZ], ckt, SHOTNOISE,
here->BSIM4V4gNodePrime, here->BSIM4V4sNodePrime,
m * (here->BSIM4V4Igs + here->BSIM4V4Igcs));
NevalSrc(&noizDens[BSIM4V4IGDNOIZ],
&lnNdens[BSIM4V4IGDNOIZ], ckt, SHOTNOISE,
here->BSIM4V4gNodePrime, here->BSIM4V4dNodePrime,
m * (here->BSIM4V4Igd + here->BSIM4V4Igcd));
} else {
NevalSrc(&noizDens[BSIM4V4IGSNOIZ],
&lnNdens[BSIM4V4IGSNOIZ], ckt, SHOTNOISE,
here->BSIM4V4gNodePrime, here->BSIM4V4sNodePrime,
m * (here->BSIM4V4Igs + here->BSIM4V4Igcd));
NevalSrc(&noizDens[BSIM4V4IGDNOIZ],
&lnNdens[BSIM4V4IGDNOIZ], ckt, SHOTNOISE,
here->BSIM4V4gNodePrime, here->BSIM4V4dNodePrime,
m * (here->BSIM4V4Igd + here->BSIM4V4Igcs));
}
NevalSrc(&noizDens[BSIM4V4IGBNOIZ],
&lnNdens[BSIM4V4IGBNOIZ], ckt, SHOTNOISE,
here->BSIM4V4gNodePrime, here->BSIM4V4bNodePrime,
m * here->BSIM4V4Igb);
noizDens[BSIM4V4TOTNOIZ] = noizDens[BSIM4V4RDNOIZ]
+ noizDens[BSIM4V4RSNOIZ] + noizDens[BSIM4V4RGNOIZ]
+ noizDens[BSIM4V4RBPSNOIZ] + noizDens[BSIM4V4RBPDNOIZ]
+ noizDens[BSIM4V4RBPBNOIZ]
+ noizDens[BSIM4V4RBSBNOIZ] + noizDens[BSIM4V4RBDBNOIZ]
+ noizDens[BSIM4V4IDNOIZ] + noizDens[BSIM4V4FLNOIZ]
+ noizDens[BSIM4V4IGSNOIZ] + noizDens[BSIM4V4IGDNOIZ]
+ noizDens[BSIM4V4IGBNOIZ];
lnNdens[BSIM4V4TOTNOIZ] =
log(MAX(noizDens[BSIM4V4TOTNOIZ], N_MINLOG));
*OnDens += noizDens[BSIM4V4TOTNOIZ];
if (data->delFreq == 0.0)
{ /* if we haven't done any previous
integration, we need to initialize our
"history" variables.
*/
for (i = 0; i < BSIM4V4NSRCS; i++)
{ here->BSIM4V4nVar[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 < BSIM4V4NSRCS; i++)
{ here->BSIM4V4nVar[OUTNOIZ][i] = 0.0;
here->BSIM4V4nVar[INNOIZ][i] = 0.0;
}
}
}
else
{ /* data->delFreq != 0.0,
we have to integrate.
*/
for (i = 0; i < BSIM4V4NSRCS; i++)
{ if (i != BSIM4V4TOTNOIZ)
{ tempOnoise = Nintegrate(noizDens[i],
lnNdens[i],
here->BSIM4V4nVar[LNLSTDENS][i],
data);
tempInoise = Nintegrate(noizDens[i]
* data->GainSqInv, lnNdens[i]
+ data->lnGainInv,
here->BSIM4V4nVar[LNLSTDENS][i]
+ data->lnGainInv, data);
here->BSIM4V4nVar[LNLSTDENS][i] =
lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if (((NOISEAN*)
ckt->CKTcurJob)->NStpsSm != 0)
{ here->BSIM4V4nVar[OUTNOIZ][i]
+= tempOnoise;
here->BSIM4V4nVar[OUTNOIZ][BSIM4V4TOTNOIZ]
+= tempOnoise;
here->BSIM4V4nVar[INNOIZ][i]
+= tempInoise;
here->BSIM4V4nVar[INNOIZ][BSIM4V4TOTNOIZ]
+= tempInoise;
}
}
}
}
if (data->prtSummary)
{ for (i = 0; i < BSIM4V4NSRCS; 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 < BSIM4V4NSRCS; i++)
{ data->outpVector[data->outNumber++]
= here->BSIM4V4nVar[OUTNOIZ][i];
data->outpVector[data->outNumber++]
= here->BSIM4V4nVar[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);
}

169
src/spicelib/devices/bsim4v4/b4v4par.c Normal file
View File

@ -0,0 +1,169 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4par.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
* Modified by Xuemei Xi, 04/06/2001.
* Modified by Xuemei Xi, 11/15/2002.
* Modified by Xuemei Xi, 05/09/2003.
**********/
#include "ngspice.h"
#include "ifsim.h"
#include "bsim4v4def.h"
#include "sperror.h"
#include "suffix.h"
#include "fteext.h"
int
BSIM4V4param(param,value,inst,select)
int param;
IFvalue *value;
GENinstance *inst;
IFvalue *select;
{
double scale;
if ( !cp_getvar( "scale", CP_REAL, (double*) &scale ) ) scale = 1;
BSIM4V4instance *here = (BSIM4V4instance*)inst;
switch(param)
{ case BSIM4V4_W:
here->BSIM4V4w = value->rValue*scale;
here->BSIM4V4wGiven = TRUE;
break;
case BSIM4V4_L:
here->BSIM4V4l = value->rValue*scale;
here->BSIM4V4lGiven = TRUE;
break;
case BSIM4V4_M:
here->BSIM4V4m = value->rValue;
here->BSIM4V4mGiven = TRUE;
break;
case BSIM4V4_NF:
here->BSIM4V4nf = value->rValue;
here->BSIM4V4nfGiven = TRUE;
break;
case BSIM4V4_MIN:
here->BSIM4V4min = value->iValue;
here->BSIM4V4minGiven = TRUE;
break;
case BSIM4V4_AS:
here->BSIM4V4sourceArea = value->rValue*scale*scale;
here->BSIM4V4sourceAreaGiven = TRUE;
break;
case BSIM4V4_AD:
here->BSIM4V4drainArea = value->rValue*scale*scale;
here->BSIM4V4drainAreaGiven = TRUE;
break;
case BSIM4V4_PS:
here->BSIM4V4sourcePerimeter = value->rValue*scale;
here->BSIM4V4sourcePerimeterGiven = TRUE;
break;
case BSIM4V4_PD:
here->BSIM4V4drainPerimeter = value->rValue*scale;
here->BSIM4V4drainPerimeterGiven = TRUE;
break;
case BSIM4V4_NRS:
here->BSIM4V4sourceSquares = value->rValue;
here->BSIM4V4sourceSquaresGiven = TRUE;
break;
case BSIM4V4_NRD:
here->BSIM4V4drainSquares = value->rValue;
here->BSIM4V4drainSquaresGiven = TRUE;
break;
case BSIM4V4_OFF:
here->BSIM4V4off = value->iValue;
break;
case BSIM4V4_SA:
here->BSIM4V4sa = value->rValue*scale;
here->BSIM4V4saGiven = TRUE;
break;
case BSIM4V4_SB:
here->BSIM4V4sb = value->rValue*scale;
here->BSIM4V4sbGiven = TRUE;
break;
case BSIM4V4_SD:
here->BSIM4V4sd = value->rValue*scale;
here->BSIM4V4sdGiven = TRUE;
break;
case BSIM4V4_RBSB:
here->BSIM4V4rbsb = value->rValue;
here->BSIM4V4rbsbGiven = TRUE;
break;
case BSIM4V4_RBDB:
here->BSIM4V4rbdb = value->rValue;
here->BSIM4V4rbdbGiven = TRUE;
break;
case BSIM4V4_RBPB:
here->BSIM4V4rbpb = value->rValue;
here->BSIM4V4rbpbGiven = TRUE;
break;
case BSIM4V4_RBPS:
here->BSIM4V4rbps = value->rValue;
here->BSIM4V4rbpsGiven = TRUE;
break;
case BSIM4V4_RBPD:
here->BSIM4V4rbpd = value->rValue;
here->BSIM4V4rbpdGiven = TRUE;
break;
case BSIM4V4_TRNQSMOD:
here->BSIM4V4trnqsMod = value->iValue;
here->BSIM4V4trnqsModGiven = TRUE;
break;
case BSIM4V4_ACNQSMOD:
here->BSIM4V4acnqsMod = value->iValue;
here->BSIM4V4acnqsModGiven = TRUE;
break;
case BSIM4V4_RBODYMOD:
here->BSIM4V4rbodyMod = value->iValue;
here->BSIM4V4rbodyModGiven = TRUE;
break;
case BSIM4V4_RGATEMOD:
here->BSIM4V4rgateMod = value->iValue;
here->BSIM4V4rgateModGiven = TRUE;
break;
case BSIM4V4_GEOMOD:
here->BSIM4V4geoMod = value->iValue;
here->BSIM4V4geoModGiven = TRUE;
break;
case BSIM4V4_RGEOMOD:
here->BSIM4V4rgeoMod = value->iValue;
here->BSIM4V4rgeoModGiven = TRUE;
break;
case BSIM4V4_IC_VDS:
here->BSIM4V4icVDS = value->rValue;
here->BSIM4V4icVDSGiven = TRUE;
break;
case BSIM4V4_IC_VGS:
here->BSIM4V4icVGS = value->rValue;
here->BSIM4V4icVGSGiven = TRUE;
break;
case BSIM4V4_IC_VBS:
here->BSIM4V4icVBS = value->rValue;
here->BSIM4V4icVBSGiven = TRUE;
break;
case BSIM4V4_IC:
switch(value->v.numValue)
{ case 3:
here->BSIM4V4icVBS = *(value->v.vec.rVec+2);
here->BSIM4V4icVBSGiven = TRUE;
case 2:
here->BSIM4V4icVGS = *(value->v.vec.rVec+1);
here->BSIM4V4icVGSGiven = TRUE;
case 1:
here->BSIM4V4icVDS = *(value->v.vec.rVec);
here->BSIM4V4icVDSGiven = TRUE;
break;
default:
return(E_BADPARM);
}
break;
default:
return(E_BADPARM);
}
return(OK);
}

758
src/spicelib/devices/bsim4v4/b4v4pzld.c Normal file
View File

@ -0,0 +1,758 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4pzld.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
* Modified by Xuemei Xi, 10/05/2001.
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "complex.h"
#include "sperror.h"
#include "bsim4v4def.h"
#include "suffix.h"
int
BSIM4V4pzLoad(inModel,ckt,s)
GENmodel *inModel;
CKTcircuit *ckt;
SPcomplex *s;
{
BSIM4V4model *model = (BSIM4V4model*)inModel;
BSIM4V4instance *here;
double gjbd, gjbs, geltd, gcrg, gcrgg, gcrgd, gcrgs, gcrgb;
double xcggb, xcgdb, xcgsb, xcgbb, xcbgb, xcbdb, xcbsb, xcbbb;
double xcdgb, xcddb, xcdsb, xcdbb, xcsgb, xcsdb, xcssb, xcsbb;
double gds, capbd, capbs, FwdSum, RevSum, Gm, Gmbs;
double gstot, gstotd, gstotg, gstots, gstotb, gspr;
double gdtot, gdtotd, gdtotg, gdtots, gdtotb, gdpr;
double gIstotg, gIstotd, gIstots, gIstotb;
double gIdtotg, gIdtotd, gIdtots, gIdtotb;
double gIbtotg, gIbtotd, gIbtots, gIbtotb;
double gIgtotg, gIgtotd, gIgtots, gIgtotb;
double cgso, cgdo, cgbo;
double xcdbdb=0.0, xcsbsb=0.0, xcgmgmb=0.0, xcgmdb=0.0, xcgmsb=0.0, xcdgmb=0.0, xcsgmb=0.0;
double xcgmbb=0.0, xcbgmb=0.0;
double dxpart, sxpart, xgtg, xgtd, xgts, xgtb, xcqgb=0.0, xcqdb=0.0, xcqsb=0.0, xcqbb=0.0;
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 T0=0.0, T1, CoxWL, qcheq, Cdg, Cdd, Cds, Csg, Csd, Css;
double ScalingFactor = 1.0e-9;
struct bsim4SizeDependParam *pParam;
double ggidld, ggidlg, ggidlb, ggislg, ggislb, ggisls;
double m;
for (; model != NULL; model = model->BSIM4V4nextModel)
{ for (here = model->BSIM4V4instances; here!= NULL;
here = here->BSIM4V4nextInstance)
{ if (here->BSIM4V4owner != ARCHme) continue;
pParam = here->pParam;
capbd = here->BSIM4V4capbd;
capbs = here->BSIM4V4capbs;
cgso = here->BSIM4V4cgso;
cgdo = here->BSIM4V4cgdo;
cgbo = pParam->BSIM4V4cgbo;
if (here->BSIM4V4mode >= 0)
{ Gm = here->BSIM4V4gm;
Gmbs = here->BSIM4V4gmbs;
FwdSum = Gm + Gmbs;
RevSum = 0.0;
gbbdp = -(here->BSIM4V4gbds);
gbbsp = here->BSIM4V4gbds + here->BSIM4V4gbgs + here->BSIM4V4gbbs;
gbdpg = here->BSIM4V4gbgs;
gbdpdp = here->BSIM4V4gbds;
gbdpb = here->BSIM4V4gbbs;
gbdpsp = -(gbdpg + gbdpdp + gbdpb);
gbspdp = 0.0;
gbspg = 0.0;
gbspb = 0.0;
gbspsp = 0.0;
if (model->BSIM4V4igcMod)
{ gIstotg = here->BSIM4V4gIgsg + here->BSIM4V4gIgcsg;
gIstotd = here->BSIM4V4gIgcsd;
gIstots = here->BSIM4V4gIgss + here->BSIM4V4gIgcss;
gIstotb = here->BSIM4V4gIgcsb;
gIdtotg = here->BSIM4V4gIgdg + here->BSIM4V4gIgcdg;
gIdtotd = here->BSIM4V4gIgdd + here->BSIM4V4gIgcdd;
gIdtots = here->BSIM4V4gIgcds;
gIdtotb = here->BSIM4V4gIgcdb;
}
else
{ gIstotg = gIstotd = gIstots = gIstotb = 0.0;
gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0;
}
if (model->BSIM4V4igbMod)
{ gIbtotg = here->BSIM4V4gIgbg;
gIbtotd = here->BSIM4V4gIgbd;
gIbtots = here->BSIM4V4gIgbs;
gIbtotb = here->BSIM4V4gIgbb;
}
else
gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0;
if ((model->BSIM4V4igcMod != 0) || (model->BSIM4V4igbMod != 0))
{ gIgtotg = gIstotg + gIdtotg + gIbtotg;
gIgtotd = gIstotd + gIdtotd + gIbtotd ;
gIgtots = gIstots + gIdtots + gIbtots;
gIgtotb = gIstotb + gIdtotb + gIbtotb;
}
else
gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0;
if (here->BSIM4V4rgateMod == 2)
T0 = *(ckt->CKTstates[0] + here->BSIM4V4vges)
- *(ckt->CKTstates[0] + here->BSIM4V4vgs);
else if (here->BSIM4V4rgateMod == 3)
T0 = *(ckt->CKTstates[0] + here->BSIM4V4vgms)
- *(ckt->CKTstates[0] + here->BSIM4V4vgs);
if (here->BSIM4V4rgateMod > 1)
{ gcrgd = here->BSIM4V4gcrgd * T0;
gcrgg = here->BSIM4V4gcrgg * T0;
gcrgs = here->BSIM4V4gcrgs * T0;
gcrgb = here->BSIM4V4gcrgb * T0;
gcrgg -= here->BSIM4V4gcrg;
gcrg = here->BSIM4V4gcrg;
}
else
gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0;
if (here->BSIM4V4acnqsMod == 0)
{ if (here->BSIM4V4rgateMod == 3)
{ xcgmgmb = cgdo + cgso + pParam->BSIM4V4cgbo;
xcgmdb = -cgdo;
xcgmsb = -cgso;
xcgmbb = -pParam->BSIM4V4cgbo;
xcdgmb = xcgmdb;
xcsgmb = xcgmsb;
xcbgmb = xcgmbb;
xcggb = here->BSIM4V4cggb;
xcgdb = here->BSIM4V4cgdb;
xcgsb = here->BSIM4V4cgsb;
xcgbb = -(xcggb + xcgdb + xcgsb);
xcdgb = here->BSIM4V4cdgb;
xcsgb = -(here->BSIM4V4cggb + here->BSIM4V4cbgb
+ here->BSIM4V4cdgb);
xcbgb = here->BSIM4V4cbgb;
}
else
{ xcggb = here->BSIM4V4cggb + cgdo + cgso
+ pParam->BSIM4V4cgbo;
xcgdb = here->BSIM4V4cgdb - cgdo;
xcgsb = here->BSIM4V4cgsb - cgso;
xcgbb = -(xcggb + xcgdb + xcgsb);
xcdgb = here->BSIM4V4cdgb - cgdo;
xcsgb = -(here->BSIM4V4cggb + here->BSIM4V4cbgb
+ here->BSIM4V4cdgb + cgso);
xcbgb = here->BSIM4V4cbgb - pParam->BSIM4V4cgbo;
xcdgmb = xcsgmb = xcbgmb = 0.0;
}
xcddb = here->BSIM4V4cddb + here->BSIM4V4capbd + cgdo;
xcdsb = here->BSIM4V4cdsb;
xcsdb = -(here->BSIM4V4cgdb + here->BSIM4V4cbdb
+ here->BSIM4V4cddb);
xcssb = here->BSIM4V4capbs + cgso - (here->BSIM4V4cgsb
+ here->BSIM4V4cbsb + here->BSIM4V4cdsb);
if (!here->BSIM4V4rbodyMod)
{ xcdbb = -(xcdgb + xcddb + xcdsb + xcdgmb);
xcsbb = -(xcsgb + xcsdb + xcssb + xcsgmb);
xcbdb = here->BSIM4V4cbdb - here->BSIM4V4capbd;
xcbsb = here->BSIM4V4cbsb - here->BSIM4V4capbs;
xcdbdb = 0.0;
}
else
{ xcdbb = -(here->BSIM4V4cddb + here->BSIM4V4cdgb
+ here->BSIM4V4cdsb);
xcsbb = -(xcsgb + xcsdb + xcssb + xcsgmb)
+ here->BSIM4V4capbs;
xcbdb = here->BSIM4V4cbdb;
xcbsb = here->BSIM4V4cbsb;
xcdbdb = -here->BSIM4V4capbd;
xcsbsb = -here->BSIM4V4capbs;
}
xcbbb = -(xcbdb + xcbgb + xcbsb + xcbgmb);
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
{ xcggb = xcgdb = xcgsb = xcgbb = 0.0;
xcbgb = xcbdb = xcbsb = xcbbb = 0.0;
xcdgb = xcddb = xcdsb = xcdbb = 0.0;
xcsgb = xcsdb = xcssb = xcsbb = 0.0;
xgtg = here->BSIM4V4gtg;
xgtd = here->BSIM4V4gtd;
xgts = here->BSIM4V4gts;
xgtb = here->BSIM4V4gtb;
xcqgb = here->BSIM4V4cqgb;
xcqdb = here->BSIM4V4cqdb;
xcqsb = here->BSIM4V4cqsb;
xcqbb = here->BSIM4V4cqbb;
CoxWL = model->BSIM4V4coxe * here->pParam->BSIM4V4weffCV
* here->BSIM4V4nf * here->pParam->BSIM4V4leffCV;
qcheq = -(here->BSIM4V4qgate + here->BSIM4V4qbulk);
if (fabs(qcheq) <= 1.0e-5 * CoxWL)
{ if (model->BSIM4V4xpart < 0.5)
{ dxpart = 0.4;
}
else if (model->BSIM4V4xpart > 0.5)
{ dxpart = 0.0;
}
else
{ dxpart = 0.5;
}
ddxpart_dVd = ddxpart_dVg = ddxpart_dVb
= ddxpart_dVs = 0.0;
}
else
{ dxpart = here->BSIM4V4qdrn / qcheq;
Cdd = here->BSIM4V4cddb;
Csd = -(here->BSIM4V4cgdb + here->BSIM4V4cddb
+ here->BSIM4V4cbdb);
ddxpart_dVd = (Cdd - dxpart * (Cdd + Csd)) / qcheq;
Cdg = here->BSIM4V4cdgb;
Csg = -(here->BSIM4V4cggb + here->BSIM4V4cdgb
+ here->BSIM4V4cbgb);
ddxpart_dVg = (Cdg - dxpart * (Cdg + Csg)) / qcheq;
Cds = here->BSIM4V4cdsb;
Css = -(here->BSIM4V4cgsb + here->BSIM4V4cdsb
+ here->BSIM4V4cbsb);
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->BSIM4V4gm;
Gmbs = -here->BSIM4V4gmbs;
FwdSum = 0.0;
RevSum = -(Gm + Gmbs);
gbbsp = -(here->BSIM4V4gbds);
gbbdp = here->BSIM4V4gbds + here->BSIM4V4gbgs + here->BSIM4V4gbbs;
gbdpg = 0.0;
gbdpsp = 0.0;
gbdpb = 0.0;
gbdpdp = 0.0;
gbspg = here->BSIM4V4gbgs;
gbspsp = here->BSIM4V4gbds;
gbspb = here->BSIM4V4gbbs;
gbspdp = -(gbspg + gbspsp + gbspb);
if (model->BSIM4V4igcMod)
{ gIstotg = here->BSIM4V4gIgsg + here->BSIM4V4gIgcdg;
gIstotd = here->BSIM4V4gIgcds;
gIstots = here->BSIM4V4gIgss + here->BSIM4V4gIgcdd;
gIstotb = here->BSIM4V4gIgcdb;
gIdtotg = here->BSIM4V4gIgdg + here->BSIM4V4gIgcsg;
gIdtotd = here->BSIM4V4gIgdd + here->BSIM4V4gIgcss;
gIdtots = here->BSIM4V4gIgcsd;
gIdtotb = here->BSIM4V4gIgcsb;
}
else
{ gIstotg = gIstotd = gIstots = gIstotb = 0.0;
gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0;
}
if (model->BSIM4V4igbMod)
{ gIbtotg = here->BSIM4V4gIgbg;
gIbtotd = here->BSIM4V4gIgbs;
gIbtots = here->BSIM4V4gIgbd;
gIbtotb = here->BSIM4V4gIgbb;
}
else
gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0;
if ((model->BSIM4V4igcMod != 0) || (model->BSIM4V4igbMod != 0))
{ gIgtotg = gIstotg + gIdtotg + gIbtotg;
gIgtotd = gIstotd + gIdtotd + gIbtotd ;
gIgtots = gIstots + gIdtots + gIbtots;
gIgtotb = gIstotb + gIdtotb + gIbtotb;
}
else
gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0;
if (here->BSIM4V4rgateMod == 2)
T0 = *(ckt->CKTstates[0] + here->BSIM4V4vges)
- *(ckt->CKTstates[0] + here->BSIM4V4vgs);
else if (here->BSIM4V4rgateMod == 3)
T0 = *(ckt->CKTstates[0] + here->BSIM4V4vgms)
- *(ckt->CKTstates[0] + here->BSIM4V4vgs);
if (here->BSIM4V4rgateMod > 1)
{ gcrgd = here->BSIM4V4gcrgs * T0;
gcrgg = here->BSIM4V4gcrgg * T0;
gcrgs = here->BSIM4V4gcrgd * T0;
gcrgb = here->BSIM4V4gcrgb * T0;
gcrgg -= here->BSIM4V4gcrg;
gcrg = here->BSIM4V4gcrg;
}
else
gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0;
if (here->BSIM4V4acnqsMod == 0)
{ if (here->BSIM4V4rgateMod == 3)
{ xcgmgmb = cgdo + cgso + pParam->BSIM4V4cgbo;
xcgmdb = -cgdo;
xcgmsb = -cgso;
xcgmbb = -pParam->BSIM4V4cgbo;
xcdgmb = xcgmdb;
xcsgmb = xcgmsb;
xcbgmb = xcgmbb;
xcggb = here->BSIM4V4cggb;
xcgdb = here->BSIM4V4cgsb;
xcgsb = here->BSIM4V4cgdb;
xcgbb = -(xcggb + xcgdb + xcgsb);
xcdgb = -(here->BSIM4V4cggb + here->BSIM4V4cbgb
+ here->BSIM4V4cdgb);
xcsgb = here->BSIM4V4cdgb;
xcbgb = here->BSIM4V4cbgb;
}
else
{ xcggb = here->BSIM4V4cggb + cgdo + cgso
+ pParam->BSIM4V4cgbo;
xcgdb = here->BSIM4V4cgsb - cgdo;
xcgsb = here->BSIM4V4cgdb - cgso;
xcgbb = -(xcggb + xcgdb + xcgsb);
xcdgb = -(here->BSIM4V4cggb + here->BSIM4V4cbgb
+ here->BSIM4V4cdgb + cgdo);
xcsgb = here->BSIM4V4cdgb - cgso;
xcbgb = here->BSIM4V4cbgb - pParam->BSIM4V4cgbo;
xcdgmb = xcsgmb = xcbgmb = 0.0;
}
xcddb = here->BSIM4V4capbd + cgdo - (here->BSIM4V4cgsb
+ here->BSIM4V4cbsb + here->BSIM4V4cdsb);
xcdsb = -(here->BSIM4V4cgdb + here->BSIM4V4cbdb
+ here->BSIM4V4cddb);
xcsdb = here->BSIM4V4cdsb;
xcssb = here->BSIM4V4cddb + here->BSIM4V4capbs + cgso;
if (!here->BSIM4V4rbodyMod)
{ xcdbb = -(xcdgb + xcddb + xcdsb + xcdgmb);
xcsbb = -(xcsgb + xcsdb + xcssb + xcsgmb);
xcbdb = here->BSIM4V4cbsb - here->BSIM4V4capbd;
xcbsb = here->BSIM4V4cbdb - here->BSIM4V4capbs;
xcdbdb = 0.0;
}
else
{ xcdbb = -(xcdgb + xcddb + xcdsb + xcdgmb)
+ here->BSIM4V4capbd;
xcsbb = -(here->BSIM4V4cddb + here->BSIM4V4cdgb
+ here->BSIM4V4cdsb);
xcbdb = here->BSIM4V4cbsb;
xcbsb = here->BSIM4V4cbdb;
xcdbdb = -here->BSIM4V4capbd;
xcsbsb = -here->BSIM4V4capbs;
}
xcbbb = -(xcbgb + xcbdb + xcbsb + xcbgmb);
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
{ xcggb = xcgdb = xcgsb = xcgbb = 0.0;
xcbgb = xcbdb = xcbsb = xcbbb = 0.0;
xcdgb = xcddb = xcdsb = xcdbb = 0.0;
xcsgb = xcsdb = xcssb = xcsbb = 0.0;
xgtg = here->BSIM4V4gtg;
xgtd = here->BSIM4V4gts;
xgts = here->BSIM4V4gtd;
xgtb = here->BSIM4V4gtb;
xcqgb = here->BSIM4V4cqgb;
xcqdb = here->BSIM4V4cqsb;
xcqsb = here->BSIM4V4cqdb;
xcqbb = here->BSIM4V4cqbb;
CoxWL = model->BSIM4V4coxe * here->pParam->BSIM4V4weffCV
* here->BSIM4V4nf * here->pParam->BSIM4V4leffCV;
qcheq = -(here->BSIM4V4qgate + here->BSIM4V4qbulk);
if (fabs(qcheq) <= 1.0e-5 * CoxWL)
{ if (model->BSIM4V4xpart < 0.5)
{ sxpart = 0.4;
}
else if (model->BSIM4V4xpart > 0.5)
{ sxpart = 0.0;
}
else
{ sxpart = 0.5;
}
dsxpart_dVd = dsxpart_dVg = dsxpart_dVb
= dsxpart_dVs = 0.0;
}
else
{ sxpart = here->BSIM4V4qdrn / qcheq;
Css = here->BSIM4V4cddb;
Cds = -(here->BSIM4V4cgdb + here->BSIM4V4cddb
+ here->BSIM4V4cbdb);
dsxpart_dVs = (Css - sxpart * (Css + Cds)) / qcheq;
Csg = here->BSIM4V4cdgb;
Cdg = -(here->BSIM4V4cggb + here->BSIM4V4cdgb
+ here->BSIM4V4cbgb);
dsxpart_dVg = (Csg - sxpart * (Csg + Cdg)) / qcheq;
Csd = here->BSIM4V4cdsb;
Cdd = -(here->BSIM4V4cgsb + here->BSIM4V4cdsb
+ here->BSIM4V4cbsb);
dsxpart_dVd = (Csd - sxpart * (Csd + Cdd)) / qcheq;
dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg
+ dsxpart_dVs);
}
dxpart = 1.0 - sxpart;
ddxpart_dVd = -dsxpart_dVd;
ddxpart_dVg = -dsxpart_dVg;
ddxpart_dVs = -dsxpart_dVs;
ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs);
}
}
if (model->BSIM4V4rdsMod == 1)
{ gstot = here->BSIM4V4gstot;
gstotd = here->BSIM4V4gstotd;
gstotg = here->BSIM4V4gstotg;
gstots = here->BSIM4V4gstots - gstot;
gstotb = here->BSIM4V4gstotb;
gdtot = here->BSIM4V4gdtot;
gdtotd = here->BSIM4V4gdtotd - gdtot;
gdtotg = here->BSIM4V4gdtotg;
gdtots = here->BSIM4V4gdtots;
gdtotb = here->BSIM4V4gdtotb;
}
else
{ gstot = gstotd = gstotg = gstots = gstotb = 0.0;
gdtot = gdtotd = gdtotg = gdtots = gdtotb = 0.0;
}
T1 = *(ckt->CKTstate0 + here->BSIM4V4qdef) * here->BSIM4V4gtau;
gds = here->BSIM4V4gds;
/*
* Loading PZ matrix
*/
m = here->BSIM4V4m;
if (!model->BSIM4V4rdsMod)
{ gdpr = here->BSIM4V4drainConductance;
gspr = here->BSIM4V4sourceConductance;
}
else
gdpr = gspr = 0.0;
if (!here->BSIM4V4rbodyMod)
{ gjbd = here->BSIM4V4gbd;
gjbs = here->BSIM4V4gbs;
}
else
gjbd = gjbs = 0.0;
geltd = here->BSIM4V4grgeltd;
if (here->BSIM4V4rgateMod == 1)
{ *(here->BSIM4V4GEgePtr) += m * geltd;
*(here->BSIM4V4GPgePtr) -= m * geltd;
*(here->BSIM4V4GEgpPtr) -= m * geltd;
*(here->BSIM4V4GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4V4GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4V4GPgpPtr) += m * (geltd - xgtg + gIgtotg);
*(here->BSIM4V4GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4V4GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4V4GPdpPtr) -= m * (xgtd - gIgtotd);
*(here->BSIM4V4GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4V4GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4V4GPspPtr) -= m * (xgts - gIgtots);
*(here->BSIM4V4GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4V4GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4V4GPbpPtr) -= m * (xgtb - gIgtotb);
}
else if (here->BSIM4V4rgateMod == 2)
{ *(here->BSIM4V4GEgePtr) += m * gcrg;
*(here->BSIM4V4GEgpPtr) += m * gcrgg;
*(here->BSIM4V4GEdpPtr) += m * gcrgd;
*(here->BSIM4V4GEspPtr) += m * gcrgs;
*(here->BSIM4V4GEbpPtr) += m * gcrgb;
*(here->BSIM4V4GPgePtr) -= m * gcrg;
*(here->BSIM4V4GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4V4GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4V4GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg);
*(here->BSIM4V4GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4V4GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4V4GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd);
*(here->BSIM4V4GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4V4GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4V4GPspPtr) -= m * (gcrgs + xgts - gIgtots);
*(here->BSIM4V4GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4V4GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4V4GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb);
}
else if (here->BSIM4V4rgateMod == 3)
{ *(here->BSIM4V4GEgePtr) += m * geltd;
*(here->BSIM4V4GEgmPtr) -= m * geltd;
*(here->BSIM4V4GMgePtr) -= m * geltd;
*(here->BSIM4V4GMgmPtr) += m * (geltd + gcrg);
*(here->BSIM4V4GMgmPtr ) += m * xcgmgmb * s->real;
*(here->BSIM4V4GMgmPtr +1) += m * xcgmgmb * s->imag;
*(here->BSIM4V4GMdpPtr) += m * gcrgd;
*(here->BSIM4V4GMdpPtr ) += m * xcgmdb * s->real;
*(here->BSIM4V4GMdpPtr +1) += m * xcgmdb * s->imag;
*(here->BSIM4V4GMgpPtr) += m * gcrgg;
*(here->BSIM4V4GMspPtr) += m * gcrgs;
*(here->BSIM4V4GMspPtr ) += m * xcgmsb * s->real;
*(here->BSIM4V4GMspPtr +1) += m * xcgmsb * s->imag;
*(here->BSIM4V4GMbpPtr) += m * gcrgb;
*(here->BSIM4V4GMbpPtr ) += m * xcgmbb * s->real;
*(here->BSIM4V4GMbpPtr +1) += m * xcgmbb * s->imag;
*(here->BSIM4V4DPgmPtr ) += m * xcdgmb * s->real;
*(here->BSIM4V4DPgmPtr +1) += m * xcdgmb * s->imag;
*(here->BSIM4V4GPgmPtr) -= m * gcrg;
*(here->BSIM4V4SPgmPtr ) += m * xcsgmb * s->real;
*(here->BSIM4V4SPgmPtr +1) += m * xcsgmb * s->imag;
*(here->BSIM4V4BPgmPtr ) += m * xcbgmb * s->real;
*(here->BSIM4V4BPgmPtr +1) += m * xcbgmb * s->imag;
*(here->BSIM4V4GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg);
*(here->BSIM4V4GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4V4GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4V4GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd);
*(here->BSIM4V4GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4V4GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4V4GPspPtr) -= m * (gcrgs + xgts - gIgtots);
*(here->BSIM4V4GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4V4GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4V4GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb);
*(here->BSIM4V4GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4V4GPbpPtr +1) += m * xcgbb * s->imag;
}
else
{ *(here->BSIM4V4GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4V4GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4V4GPdpPtr) -= m * (xgtd - gIgtotd);
*(here->BSIM4V4GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4V4GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4V4GPgpPtr) -= m * (xgtg - gIgtotg);
*(here->BSIM4V4GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4V4GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4V4GPspPtr) -= m * (xgts - gIgtots);
*(here->BSIM4V4GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4V4GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4V4GPbpPtr) -= m * (xgtb - gIgtotb);
}
if (model->BSIM4V4rdsMod)
{ (*(here->BSIM4V4DgpPtr) += m * gdtotg);
(*(here->BSIM4V4DspPtr) += m * gdtots);
(*(here->BSIM4V4DbpPtr) += m * gdtotb);
(*(here->BSIM4V4SdpPtr) += m * gstotd);
(*(here->BSIM4V4SgpPtr) += m * gstotg);
(*(here->BSIM4V4SbpPtr) += m * gstotb);
}
*(here->BSIM4V4DPdpPtr ) += m * xcddb * s->real;
*(here->BSIM4V4DPdpPtr +1) += m * xcddb * s->imag;
*(here->BSIM4V4DPdpPtr) += m * (gdpr + gds + here->BSIM4V4gbd
- gdtotd + RevSum + gbdpdp - gIdtotd
+ dxpart * xgtd + T1 * ddxpart_dVd);
*(here->BSIM4V4DPdPtr) -= m * (gdpr + gdtot);
*(here->BSIM4V4DPgpPtr ) += m * xcdgb * s->real;
*(here->BSIM4V4DPgpPtr +1) += m * xcdgb * s->imag;
*(here->BSIM4V4DPgpPtr) += m * (Gm - gdtotg + gbdpg - gIdtotg
+ T1 * ddxpart_dVg + dxpart * xgtg);
*(here->BSIM4V4DPspPtr ) += m * xcdsb * s->real;
*(here->BSIM4V4DPspPtr +1) += m * xcdsb * s->imag;
*(here->BSIM4V4DPspPtr) -= m * (gds + FwdSum + gdtots - gbdpsp + gIdtots
- T1 * ddxpart_dVs - dxpart * xgts);
*(here->BSIM4V4DPbpPtr ) += m * xcdbb * s->real;
*(here->BSIM4V4DPbpPtr +1) += m * xcdbb * s->imag;
*(here->BSIM4V4DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gbdpb + gIdtotb
- T1 * ddxpart_dVb - dxpart * xgtb);
*(here->BSIM4V4DdpPtr) -= m * (gdpr - gdtotd);
*(here->BSIM4V4DdPtr) += m * (gdpr + gdtot);
*(here->BSIM4V4SPdpPtr ) += m * xcsdb * s->real;
*(here->BSIM4V4SPdpPtr +1) += m * xcsdb * s->imag;
*(here->BSIM4V4SPdpPtr) -= m * (gds + gstotd + RevSum - gbspdp + gIstotd
- T1 * dsxpart_dVd - sxpart * xgtd);
*(here->BSIM4V4SPgpPtr ) += m * xcsgb * s->real;
*(here->BSIM4V4SPgpPtr +1) += m * xcsgb * s->imag;
*(here->BSIM4V4SPgpPtr) -= m * (Gm + gstotg - gbspg + gIstotg
- T1 * dsxpart_dVg - sxpart * xgtg);
*(here->BSIM4V4SPspPtr ) += m * xcssb * s->real;
*(here->BSIM4V4SPspPtr +1) += m * xcssb * s->imag;
*(here->BSIM4V4SPspPtr) += m * (gspr + gds + here->BSIM4V4gbs - gIstots
- gstots + FwdSum + gbspsp
+ sxpart * xgts + T1 * dsxpart_dVs);
*(here->BSIM4V4SPsPtr) -= m * (gspr + gstot);
*(here->BSIM4V4SPbpPtr ) += m * xcsbb * s->real;
*(here->BSIM4V4SPbpPtr +1) += m * xcsbb * s->imag;
*(here->BSIM4V4SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gbspb + gIstotb
- T1 * dsxpart_dVb - sxpart * xgtb);
*(here->BSIM4V4SspPtr) -= m * (gspr - gstots);
*(here->BSIM4V4SsPtr) += m * (gspr + gstot);
*(here->BSIM4V4BPdpPtr ) += m * xcbdb * s->real;
*(here->BSIM4V4BPdpPtr +1) += m * xcbdb * s->imag;
*(here->BSIM4V4BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd);
*(here->BSIM4V4BPgpPtr ) += m * xcbgb * s->real;
*(here->BSIM4V4BPgpPtr +1) += m * xcbgb * s->imag;
*(here->BSIM4V4BPgpPtr) -= m * (here->BSIM4V4gbgs + gIbtotg);
*(here->BSIM4V4BPspPtr ) += m * xcbsb * s->real;
*(here->BSIM4V4BPspPtr +1) += m * xcbsb * s->imag;
*(here->BSIM4V4BPspPtr) -= m * (gjbs - gbbsp + gIbtots);
*(here->BSIM4V4BPbpPtr ) += m * xcbbb * s->real;
*(here->BSIM4V4BPbpPtr +1) += m * xcbbb * s->imag;
*(here->BSIM4V4BPbpPtr) += m * (gjbd + gjbs - here->BSIM4V4gbbs
- gIbtotb);
ggidld = here->BSIM4V4ggidld;
ggidlg = here->BSIM4V4ggidlg;
ggidlb = here->BSIM4V4ggidlb;
ggislg = here->BSIM4V4ggislg;
ggisls = here->BSIM4V4ggisls;
ggislb = here->BSIM4V4ggislb;
/* stamp gidl */
(*(here->BSIM4V4DPdpPtr) += m * ggidld);
(*(here->BSIM4V4DPgpPtr) += m * ggidlg);
(*(here->BSIM4V4DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4V4DPbpPtr) += m * ggidlb);
(*(here->BSIM4V4BPdpPtr) -= m * ggidld);
(*(here->BSIM4V4BPgpPtr) -= m * ggidlg);
(*(here->BSIM4V4BPspPtr) += m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4V4BPbpPtr) -= m * ggidlb);
/* stamp gisl */
(*(here->BSIM4V4SPdpPtr) -= m * ((ggisls + ggislg) + ggislb));
(*(here->BSIM4V4SPgpPtr) += m * ggislg);
(*(here->BSIM4V4SPspPtr) += m * ggisls);
(*(here->BSIM4V4SPbpPtr) += m * ggislb);
(*(here->BSIM4V4BPdpPtr) += m * ((ggislg + ggisls) + ggislb));
(*(here->BSIM4V4BPgpPtr) -= m * ggislg);
(*(here->BSIM4V4BPspPtr) -= m * ggisls);
(*(here->BSIM4V4BPbpPtr) -= m * ggislb);
if (here->BSIM4V4rbodyMod)
{ (*(here->BSIM4V4DPdbPtr ) += m * xcdbdb * s->real);
(*(here->BSIM4V4DPdbPtr +1) += m * xcdbdb * s->imag);
(*(here->BSIM4V4DPdbPtr) -= m * here->BSIM4V4gbd);
(*(here->BSIM4V4SPsbPtr ) += m * xcsbsb * s->real);
(*(here->BSIM4V4SPsbPtr +1) += m * xcsbsb * s->imag);
(*(here->BSIM4V4SPsbPtr) -= m * here->BSIM4V4gbs);
(*(here->BSIM4V4DBdpPtr ) += m * xcdbdb * s->real);
(*(here->BSIM4V4DBdpPtr +1) += m * xcdbdb * s->imag);
(*(here->BSIM4V4DBdpPtr) -= m * here->BSIM4V4gbd);
(*(here->BSIM4V4DBdbPtr ) -= m * xcdbdb * s->real);
(*(here->BSIM4V4DBdbPtr +1) -= m * xcdbdb * s->imag);
(*(here->BSIM4V4DBdbPtr) += m * (here->BSIM4V4gbd + here->BSIM4V4grbpd
+ here->BSIM4V4grbdb));
(*(here->BSIM4V4DBbpPtr) -= m * here->BSIM4V4grbpd);
(*(here->BSIM4V4DBbPtr) -= m * here->BSIM4V4grbdb);
(*(here->BSIM4V4BPdbPtr) -= m * here->BSIM4V4grbpd);
(*(here->BSIM4V4BPbPtr) -= m * here->BSIM4V4grbpb);
(*(here->BSIM4V4BPsbPtr) -= m * here->BSIM4V4grbps);
(*(here->BSIM4V4BPbpPtr) += m * (here->BSIM4V4grbpd + here->BSIM4V4grbps
+ here->BSIM4V4grbpb));
/* WDL: (-here->BSIM4V4gbbs) already added to BPbpPtr */
(*(here->BSIM4V4SBspPtr ) += m * xcsbsb * s->real);
(*(here->BSIM4V4SBspPtr +1) += m * xcsbsb * s->imag);
(*(here->BSIM4V4SBspPtr) -= m * here->BSIM4V4gbs);
(*(here->BSIM4V4SBbpPtr) -= m * here->BSIM4V4grbps);
(*(here->BSIM4V4SBbPtr) -= m * here->BSIM4V4grbsb);
(*(here->BSIM4V4SBsbPtr ) -= m * xcsbsb * s->real);
(*(here->BSIM4V4SBsbPtr +1) -= m * xcsbsb * s->imag);
(*(here->BSIM4V4SBsbPtr) += m * (here->BSIM4V4gbs
+ here->BSIM4V4grbps + here->BSIM4V4grbsb));
(*(here->BSIM4V4BdbPtr) -= m * here->BSIM4V4grbdb);
(*(here->BSIM4V4BbpPtr) -= m * here->BSIM4V4grbpb);
(*(here->BSIM4V4BsbPtr) -= m * here->BSIM4V4grbsb);
(*(here->BSIM4V4BbPtr) += m * (here->BSIM4V4grbsb + here->BSIM4V4grbdb
+ here->BSIM4V4grbpb));
}
if (here->BSIM4V4acnqsMod)
{ *(here->BSIM4V4QqPtr ) += m * s->real * ScalingFactor;
*(here->BSIM4V4QqPtr +1) += m * s->imag * ScalingFactor;
*(here->BSIM4V4QgpPtr ) -= m * xcqgb * s->real;
*(here->BSIM4V4QgpPtr +1) -= m * xcqgb * s->imag;
*(here->BSIM4V4QdpPtr ) -= m * xcqdb * s->real;
*(here->BSIM4V4QdpPtr +1) -= m * xcqdb * s->imag;
*(here->BSIM4V4QbpPtr ) -= m * xcqbb * s->real;
*(here->BSIM4V4QbpPtr +1) -= m * xcqbb * s->imag;
*(here->BSIM4V4QspPtr ) -= m * xcqsb * s->real;
*(here->BSIM4V4QspPtr +1) -= m * xcqsb * s->imag;
*(here->BSIM4V4GPqPtr) -= m * here->BSIM4V4gtau;
*(here->BSIM4V4DPqPtr) += m * dxpart * here->BSIM4V4gtau;
*(here->BSIM4V4SPqPtr) += m * sxpart * here->BSIM4V4gtau;
*(here->BSIM4V4QqPtr) += m * here->BSIM4V4gtau;
*(here->BSIM4V4QgpPtr) += m * xgtg;
*(here->BSIM4V4QdpPtr) += m * xgtd;
*(here->BSIM4V4QbpPtr) += m * xgtb;
*(here->BSIM4V4QspPtr) += m * xgts;
}
}
}
return(OK);
}

1922
src/spicelib/devices/bsim4v4/b4v4set.c Normal file
View File

File diff suppressed because it is too large Load Diff

1709
src/spicelib/devices/bsim4v4/b4v4temp.c Normal file
View File

File diff suppressed because it is too large Load Diff

58
src/spicelib/devices/bsim4v4/b4v4trunc.c Normal file
View File

@ -0,0 +1,58 @@
/**** BSIM4.4.0 Released by Xuemei (Jane) Xi 03/04/2004 ****/
/**********
* Copyright 2004 Regents of the University of California. All rights reserved.
* File: b4trunc.c of BSIM4.4.0.
* Author: 2000 Weidong Liu
* Authors: 2001- Xuemei Xi, Jin He, Kanyu Cao, Mohan Dunga, Mansun Chan, Ali Niknejad, Chenming Hu.
* Project Director: Prof. Chenming Hu.
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "bsim4v4def.h"
#include "sperror.h"
#include "suffix.h"
int
BSIM4V4trunc(inModel,ckt,timeStep)
GENmodel *inModel;
CKTcircuit *ckt;
double *timeStep;
{
BSIM4V4model *model = (BSIM4V4model*)inModel;
BSIM4V4instance *here;
#ifdef STEPDEBUG
double debugtemp;
#endif /* STEPDEBUG */
for (; model != NULL; model = model->BSIM4V4nextModel)
{ for (here = model->BSIM4V4instances; here != NULL;
here = here->BSIM4V4nextInstance)
{
if (here->BSIM4V4owner != ARCHme) continue;
#ifdef STEPDEBUG
debugtemp = *timeStep;
#endif /* STEPDEBUG */
CKTterr(here->BSIM4V4qb,ckt,timeStep);
CKTterr(here->BSIM4V4qg,ckt,timeStep);
CKTterr(here->BSIM4V4qd,ckt,timeStep);
if (here->BSIM4V4trnqsMod)
CKTterr(here->BSIM4V4qcdump,ckt,timeStep);
if (here->BSIM4V4rbodyMod)
{ CKTterr(here->BSIM4V4qbs,ckt,timeStep);
CKTterr(here->BSIM4V4qbd,ckt,timeStep);
}
if (here->BSIM4V4rgateMod == 3)
CKTterr(here->BSIM4V4qgmid,ckt,timeStep);
#ifdef STEPDEBUG
if(debugtemp != *timeStep)
{ printf("device %s reduces step from %g to %g\n",
here->BSIM4V4name,debugtemp,*timeStep);
}
#endif /* STEPDEBUG */
}
}
return(OK);
}

2935
src/spicelib/devices/bsim4v4/bsim4v4def.h Normal file
View File

File diff suppressed because it is too large Load Diff

33
src/spicelib/devices/bsim4v4/bsim4v4ext.h Normal file
View File

@ -0,0 +1,33 @@
/**********
Copyright 2004 Regents of the University of California. All rights reserved.
Author: 2000 Weidong Liu
Author: 2001- Xuemei Xi
File: bsim4ext.h
**********/
extern int BSIM4V4acLoad(GENmodel *,CKTcircuit*);
extern int BSIM4V4ask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*);
extern int BSIM4V4convTest(GENmodel *,CKTcircuit*);
extern int BSIM4V4delete(GENmodel*,IFuid,GENinstance**);
extern void BSIM4V4destroy(GENmodel**);
extern int BSIM4V4getic(GENmodel*,CKTcircuit*);
extern int BSIM4V4load(GENmodel*,CKTcircuit*);
extern int BSIM4V4mAsk(CKTcircuit*,GENmodel *,int, IFvalue*);
extern int BSIM4V4mDelete(GENmodel**,IFuid,GENmodel*);
extern int BSIM4V4mParam(int,IFvalue*,GENmodel*);
extern void BSIM4V4mosCap(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 BSIM4V4param(int,IFvalue*,GENinstance*,IFvalue*);
extern int BSIM4V4pzLoad(GENmodel*,CKTcircuit*,SPcomplex*);
extern int BSIM4V4setup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
extern int BSIM4V4temp(GENmodel*,CKTcircuit*);
extern int BSIM4V4trunc(GENmodel*,CKTcircuit*,double*);
extern int BSIM4V4noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
extern int BSIM4V4unsetup(GENmodel*,CKTcircuit*);

83
src/spicelib/devices/bsim4v4/bsim4v4init.c Normal file
View File

@ -0,0 +1,83 @@
#include "config.h"
#include "devdefs.h"
#include "bsim4v4itf.h"
#include "bsim4v4ext.h"
#include "bsim4v4init.h"
SPICEdev BSIM4V4info = {
{
"BSIM4v4",
"Berkeley Short Channel IGFET Model-4",
&BSIM4V4nSize,
&BSIM4V4nSize,
BSIM4V4names,
&BSIM4V4pTSize,
BSIM4V4pTable,
&BSIM4V4mPTSize,
BSIM4V4mPTable,
#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
},
BSIM4V4param, /* DEVparam */
BSIM4V4mParam, /* DEVmodParam */
BSIM4V4load, /* DEVload */
BSIM4V4setup, /* DEVsetup */
BSIM4V4unsetup, /* DEVunsetup */
BSIM4V4setup, /* DEVpzSetup */
BSIM4V4temp, /* DEVtemperature */
BSIM4V4trunc, /* DEVtrunc */
NULL, /* DEVfindBranch */
BSIM4V4acLoad, /* DEVacLoad */
NULL, /* DEVaccept */
BSIM4V4destroy, /* DEVdestroy */
BSIM4V4mDelete, /* DEVmodDelete */
BSIM4V4delete, /* DEVdelete */
BSIM4V4getic, /* DEVsetic */
BSIM4V4ask, /* DEVask */
BSIM4V4mAsk, /* DEVmodAsk */
BSIM4V4pzLoad, /* DEVpzLoad */
BSIM4V4convTest, /* DEVconvTest */
NULL, /* DEVsenSetup */
NULL, /* DEVsenLoad */
NULL, /* DEVsenUpdate */
NULL, /* DEVsenAcLoad */
NULL, /* DEVsenPrint */
NULL, /* DEVsenTrunc */
NULL, /* DEVdisto */
BSIM4V4noise, /* DEVnoise */
#ifdef CIDER
NULL, /* DEVdump */
NULL, /* DEVacct */
#endif
&BSIM4V4iSize, /* DEVinstSize */
&BSIM4V4mSize /* DEVmodSize */
};
SPICEdev *
get_bsim4v4_info(void)
{
return &BSIM4V4info;
}

13
src/spicelib/devices/bsim4v4/bsim4v4init.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef _BSIM4V4INIT_H
#define _BSIM4V4INIT_H
extern IFparm BSIM4V4pTable[ ];
extern IFparm BSIM4V4mPTable[ ];
extern char *BSIM4V4names[ ];
extern int BSIM4V4pTSize;
extern int BSIM4V4mPTSize;
extern int BSIM4V4nSize;
extern int BSIM4V4iSize;
extern int BSIM4V4mSize;
#endif

13
src/spicelib/devices/bsim4v4/bsim4v4itf.h Normal file
View File

@ -0,0 +1,13 @@
/**********
Copyright 2004 Regents of the University of California. All rights reserved.
Author: 2000 Weidong Liu.
Author: 2001- Xuemei Xi
File: bsim4itf.h
**********/
#ifndef DEV_BSIM4V4
#define DEV_BSIM4V4
SPICEdev *get_bsim4v4_info(void);
#endif

112
src/spicelib/devices/dev.c
View File

@ -80,8 +80,9 @@ int add_udn(int,Evt_Udn_Info_t **);
#include "bsim3v1/bsim3v1itf.h"
#include "bsim3v1a/bsim3v1aitf.h"
#include "bsim3v1s/bsim3v1sitf.h"
#include "bsim3soi/b3soiitf.h"
#include "bsim4/bsim4itf.h"
#include "bsim4v4/bsim4v4itf.h"
#include "bsim3soi/b3soiitf.h"
#include "bsim3soi_pd/b3soipditf.h"
#include "bsim3soi_fd/b3soifditf.h"
#include "bsim3soi_dd/b3soidditf.h"
@ -137,9 +138,9 @@ int add_udn(int,Evt_Udn_Info_t **);
/*saj in xspice the DEVices size can be varied so DEVNUM is an int*/
#ifdef XSPICE
static int DEVNUM = 60;
static int DEVNUM = 61;
#else
#define DEVNUM 60
#define DEVNUM 61
#endif
/*Make this dynamic for later attempt to make all devices dynamic*/
@ -188,75 +189,76 @@ spice_init_devices(void)
DEVices[10] = get_bsim3v1s_info();
DEVices[11] = get_b3soi_info();
DEVices[12] = get_bsim4_info();
DEVices[13] = get_b3soipd_info();
DEVices[14] = get_b3soifd_info();
DEVices[15] = get_b3soidd_info();
DEVices[16] = get_cap_info();
DEVices[17] = get_cccs_info();
DEVices[18] = get_ccvs_info();
DEVices[19] = get_cpl_info();
DEVices[20] = get_csw_info();
DEVices[21] = get_dio_info();
DEVices[22] = get_hfeta_info();
DEVices[23] = get_hfet2_info();
DEVices[24] = get_hsm1_info();
DEVices[25] = get_ind_info();
DEVices[26] = get_mut_info();
DEVices[27] = get_isrc_info();
DEVices[28] = get_jfet_info();
DEVices[29] = get_jfet2_info();
DEVices[30] = get_ltra_info();
DEVices[31] = get_mes_info();
DEVices[32] = get_mesa_info();
DEVices[33] = get_mos1_info();
DEVices[34] = get_mos2_info();
DEVices[35] = get_mos3_info();
DEVices[36] = get_mos6_info();
DEVices[37] = get_mos9_info();
DEVices[38] = get_res_info();
DEVices[39] = get_soi3_info();
DEVices[40] = get_sw_info();
DEVices[41] = get_tra_info();
DEVices[42] = get_txl_info();
DEVices[43] = get_vbic_info();
DEVices[44] = get_vccs_info();
DEVices[45] = get_vcvs_info();
DEVices[46] = get_vsrc_info();
DEVices[13] = get_bsim4v4_info();
DEVices[14] = get_b3soipd_info();
DEVices[15] = get_b3soifd_info();
DEVices[16] = get_b3soidd_info();
DEVices[17] = get_cap_info();
DEVices[18] = get_cccs_info();
DEVices[19] = get_ccvs_info();
DEVices[20] = get_cpl_info();
DEVices[21] = get_csw_info();
DEVices[22] = get_dio_info();
DEVices[23] = get_hfeta_info();
DEVices[24] = get_hfet2_info();
DEVices[25] = get_hsm1_info();
DEVices[26] = get_ind_info();
DEVices[27] = get_mut_info();
DEVices[28] = get_isrc_info();
DEVices[29] = get_jfet_info();
DEVices[30] = get_jfet2_info();
DEVices[31] = get_ltra_info();
DEVices[32] = get_mes_info();
DEVices[33] = get_mesa_info();
DEVices[34] = get_mos1_info();
DEVices[35] = get_mos2_info();
DEVices[36] = get_mos3_info();
DEVices[37] = get_mos6_info();
DEVices[38] = get_mos9_info();
DEVices[39] = get_res_info();
DEVices[40] = get_soi3_info();
DEVices[41] = get_sw_info();
DEVices[42] = get_tra_info();
DEVices[43] = get_txl_info();
DEVices[44] = get_vbic_info();
DEVices[45] = get_vccs_info();
DEVices[46] = get_vcvs_info();
DEVices[47] = get_vsrc_info();
#ifdef CIDER
DEVices[47] = get_nbjt_info();
DEVices[48] = get_nbjt2_info();
DEVices[49] = get_numd_info();
DEVices[50] = get_numd2_info();
DEVices[51] = get_numos_info();
DEVices[48] = get_nbjt_info();
DEVices[49] = get_nbjt2_info();
DEVices[50] = get_numd_info();
DEVices[51] = get_numd2_info();
DEVices[52] = get_numos_info();
#else
DEVices[47] = NULL;
DEVices[48] = NULL;
DEVices[49] = NULL;
DEVices[50] = NULL;
DEVices[51] = NULL;
DEVices[51] = NULL;
DEVices[52] = NULL;
#endif
#ifdef ADMS
DEVices[52] = get_hicum0_info();
DEVices[53] = get_hicum2_info();
DEVices[54] = get_mextram_info();
DEVices[55] = get_ekv_info();
DEVices[56] = get_psp102_info();
DEVices[53] = get_hicum0_info();
DEVices[54] = get_hicum2_info();
DEVices[55] = get_mextram_info();
DEVices[56] = get_ekv_info();
DEVices[57] = get_psp102_info();
#else
DEVices[52] = NULL;
DEVices[53] = NULL;
DEVices[54] = NULL;
DEVices[55] = NULL;
DEVices[56] = NULL;
DEVices[57] = NULL;
#endif
#ifdef NDEV /* NDEV */
DEVices[57] = get_ndev_info();
DEVices[58] = get_ndev_info();
#else
DEVices[57] = NULL;
#endif
DEVices[58] = NULL;
#endif
DEVices[59] = NULL;
DEVices[60] = NULL;
return;
}
@ -280,11 +282,11 @@ SPICEdev ** devices(void)
/*not yet usable*/
#ifdef ADMS
#define DEVICES_USED {"asrc", "bjt", "bjt2", "vbic", "bsim1", "bsim2", "bsim3", "bsim3v2", "bsim3v1", "bsim4", "bsim3soipd", "bsim3soifd", "bsim3soidd", \
#define DEVICES_USED {"asrc", "bjt", "bjt2", "vbic", "bsim1", "bsim2", "bsim3", "bsim3v2", "bsim3v1", "bsim4", "bsim4v4", "bsim3soipd", "bsim3soifd", "bsim3soidd", \
"cap", "cccs", "ccvs", "csw", "dio", "hfet", "hfet2", "ind", "isrc", "jfet", "ltra", "mes", "mesa" ,"mos1", "mos2", "mos3", \
"mos6", "mos9", "res", "soi3", "sw", "tra", "urc", "vccs", "vcvs", "vsrc", "hicum0", "hicum2", "mextram", "ekv", "psp102"}
#else
#define DEVICES_USED {"asrc", "bjt", "bjt2", "vbic", "bsim1", "bsim2", "bsim3", "bsim3v2", "bsim3v1", "bsim4", "bsim3soipd", "bsim3soifd", "bsim3soidd", \
#define DEVICES_USED {"asrc", "bjt", "bjt2", "vbic", "bsim1", "bsim2", "bsim3", "bsim3v2", "bsim3v1", "bsim4", "bsim4v4", "bsim3soipd", "bsim3soifd", "bsim3soidd", \
"cap", "cccs", "ccvs", "csw", "dio", "hfet", "hfet2", "ind", "isrc", "jfet", "ltra", "mes", "mesa" ,"mos1", "mos2", "mos3", \
"mos6", "mos9", "res", "soi3", "sw", "tra", "urc", "vccs", "vcvs", "vsrc"}
#endif

1
src/spicelib/parser/inp2m.c
View File

@ -215,6 +215,7 @@ INP2M (void *ckt, INPtables * tab, card * current)
&& thismodel->INPmodType != INPtypelook ("B3SOIFD")
&& thismodel->INPmodType != INPtypelook ("B3SOIDD")
&& thismodel->INPmodType != INPtypelook ("BSIM4")
&& thismodel->INPmodType != INPtypelook ("BSIM4v4")
&& thismodel->INPmodType != INPtypelook ("BSIM3v0")
&& thismodel->INPmodType != INPtypelook ("BSIM3v1")
&& thismodel->INPmodType != INPtypelook ("BSIM3v1S")

15
src/spicelib/parser/inpdomod.c
View File

@ -281,17 +281,18 @@ char *INPdomodel(void *ckt, card * image, INPtables * tab)
("Device type BSIM3 not available in this binary\n");
}
break;
case 9:
type = INPtypelook("Mos9");
if(type < 0) {
err = INPmkTemp
("Device type MOS9 not available in this binary\n");
}
break;
if(type < 0) {
err = INPmkTemp
("Device type MOS9 not available in this binary\n");
}
break;
case 14:
type = INPtypelook("BSIM4");
if ( (strstr( ver, "4.4")) || (strstr( ver, "4.4.0")) ) {
type = INPtypelook("BSIM4v4");
}
if (type < 0) {
err =
INPmkTemp

2
src/spicelib/parser/inpgmod.c
View File

@ -208,7 +208,7 @@ INPgetModBin( void* ckt, char* name, INPmodel** model, INPtables* tab, char* lin
for ( modtmp = modtab; modtmp != (INPmodel*)NULL; modtmp = modtmp->INPnextModel ) {
if ( modtmp->INPmodType != INPtypelook( "BSIM3" ) && modtmp->INPmodType != INPtypelook( "BSIM4" ) &&
modtmp->INPmodType != INPtypelook( "BSIM4v5" ) && modtmp->INPmodType != INPtypelook( "BSIM4v6" ) )
modtmp->INPmodType != INPtypelook( "BSIM4v4" ) && modtmp->INPmodType != INPtypelook( "BSIM4v6" ) )
continue;
if ( parse_line( modtmp->INPmodLine->line, model_tokens, 4, parse_values, parse_found ) != TRUE )