From 58122ce47b3157820608298ee21bb6aa73dfe6a7 Mon Sep 17 00:00:00 2001 From: dwarning Date: Mon, 19 May 2014 23:23:55 +0200 Subject: [PATCH] devices/bsim4v7, string substitution, bsim4 -> bsim4v7 --- src/spicelib/devices/bsim4v7/Makefile.am | 54 +- src/spicelib/devices/bsim4v7/b4v7.c | 1954 +++--- src/spicelib/devices/bsim4v7/b4v7acld.c | 634 +- src/spicelib/devices/bsim4v7/b4v7ask.c | 516 +- src/spicelib/devices/bsim4v7/b4v7check.c | 864 +-- src/spicelib/devices/bsim4v7/b4v7cvtest.c | 188 +- src/spicelib/devices/bsim4v7/b4v7del.c | 22 +- src/spicelib/devices/bsim4v7/b4v7dest.c | 28 +- src/spicelib/devices/bsim4v7/b4v7geo.c | 42 +- src/spicelib/devices/bsim4v7/b4v7getic.c | 30 +- src/spicelib/devices/bsim4v7/b4v7ld.c | 3906 +++++------ src/spicelib/devices/bsim4v7/b4v7mask.c | 3530 +++++----- src/spicelib/devices/bsim4v7/b4v7mdel.c | 22 +- src/spicelib/devices/bsim4v7/b4v7mpar.c | 5352 +++++++-------- src/spicelib/devices/bsim4v7/b4v7noi.c | 580 +- src/spicelib/devices/bsim4v7/b4v7par.c | 234 +- src/spicelib/devices/bsim4v7/b4v7pzld.c | 858 +-- src/spicelib/devices/bsim4v7/b4v7set.c | 4242 ++++++------ src/spicelib/devices/bsim4v7/b4v7soachk.c | 60 +- src/spicelib/devices/bsim4v7/b4v7temp.c | 2972 ++++----- src/spicelib/devices/bsim4v7/b4v7trunc.c | 36 +- src/spicelib/devices/bsim4v7/bsim4v7def.h | 7046 ++++++++++---------- src/spicelib/devices/bsim4v7/bsim4v7ext.h | 40 +- src/spicelib/devices/bsim4v7/bsim4v7init.c | 70 +- src/spicelib/devices/bsim4v7/bsim4v7init.h | 20 +- src/spicelib/devices/bsim4v7/bsim4v7itf.h | 8 +- 26 files changed, 16654 insertions(+), 16654 deletions(-) diff --git a/src/spicelib/devices/bsim4v7/Makefile.am b/src/spicelib/devices/bsim4v7/Makefile.am index 047ffdfc6..9e6ed7349 100644 --- a/src/spicelib/devices/bsim4v7/Makefile.am +++ b/src/spicelib/devices/bsim4v7/Makefile.am @@ -1,33 +1,33 @@ ## Process this file with automake to produce Makefile.in -noinst_LTLIBRARIES = libbsim4.la +noinst_LTLIBRARIES = libbsim4v7.la -libbsim4_la_SOURCES = \ - b4.c \ - b4acld.c \ - b4ask.c \ - b4check.c \ - b4cvtest.c \ - b4del.c \ - b4dest.c \ - b4geo.c \ - b4getic.c \ - b4ld.c \ - b4mask.c \ - b4mdel.c \ - b4mpar.c \ - b4noi.c \ - b4par.c \ - b4pzld.c \ - b4set.c \ - b4soachk.c \ - b4temp.c \ - b4trunc.c \ - bsim4def.h \ - bsim4ext.h \ - bsim4init.c \ - bsim4init.h \ - bsim4itf.h +libbsim4v7_la_SOURCES = \ + b4v7.c \ + b4v7acld.c \ + b4v7ask.c \ + b4v7check.c \ + b4v7cvtest.c \ + b4v7del.c \ + b4v7dest.c \ + b4v7geo.c \ + b4v7getic.c \ + b4v7ld.c \ + b4v7mask.c \ + b4v7mdel.c \ + b4v7mpar.c \ + b4v7noi.c \ + b4v7par.c \ + b4v7pzld.c \ + b4v7set.c \ + b4v7soachk.c \ + b4v7temp.c \ + b4v7trunc.c \ + bsim4v7def.h \ + bsim4v7ext.h \ + bsim4v7init.c \ + bsim4v7init.h \ + bsim4v7itf.h diff --git a/src/spicelib/devices/bsim4v7/b4v7.c b/src/spicelib/devices/bsim4v7/b4v7.c index ce7e479e5..e12221855 100644 --- a/src/spicelib/devices/bsim4v7/b4v7.c +++ b/src/spicelib/devices/bsim4v7/b4v7.c @@ -23,1026 +23,1026 @@ #include "ngspice/ngspice.h" #include "ngspice/devdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/suffix.h" -IFparm BSIM4pTable[] = { /* parameters */ -IOP( "l", BSIM4_L, IF_REAL , "Length"), -IOP( "w", BSIM4_W, IF_REAL , "Width"), -IOP( "m", BSIM4_M, IF_REAL , "Separate Parallel multiplier"), -IOP( "nf", BSIM4_NF, IF_REAL , "Number of fingers"), -IOP( "sa", BSIM4_SA, IF_REAL , "distance between OD edge to poly of one side "), -IOP( "sb", BSIM4_SB, IF_REAL , "distance between OD edge to poly of the other side"), -IOP( "sd", BSIM4_SD, IF_REAL , "distance between neighbour fingers"), -IOP( "sca", BSIM4_SCA, IF_REAL , "Integral of the first distribution function for scattered well dopant"), -IOP( "scb", BSIM4_SCB, IF_REAL , "Integral of the second distribution function for scattered well dopant"), -IOP( "scc", BSIM4_SCC, IF_REAL , "Integral of the third distribution function for scattered well dopant"), -IOP( "sc", BSIM4_SC, IF_REAL , "Distance to a single well edge "), -IOP( "min", BSIM4_MIN, IF_INTEGER , "Minimize either D or S"), -IOP( "ad", BSIM4_AD, IF_REAL , "Drain area"), -IOP( "as", BSIM4_AS, IF_REAL , "Source area"), -IOP( "pd", BSIM4_PD, IF_REAL , "Drain perimeter"), -IOP( "ps", BSIM4_PS, IF_REAL , "Source perimeter"), -IOP( "nrd", BSIM4_NRD, IF_REAL , "Number of squares in drain"), -IOP( "nrs", BSIM4_NRS, IF_REAL , "Number of squares in source"), -IOP( "off", BSIM4_OFF, IF_FLAG , "Device is initially off"), -IOP( "rbdb", BSIM4_RBDB, IF_REAL , "Body resistance"), -IOP( "rbsb", BSIM4_RBSB, IF_REAL , "Body resistance"), -IOP( "rbpb", BSIM4_RBPB, IF_REAL , "Body resistance"), -IOP( "rbps", BSIM4_RBPS, IF_REAL , "Body resistance"), -IOP( "rbpd", BSIM4_RBPD, IF_REAL , "Body resistance"), -IOP( "delvto", BSIM4_DELVTO, IF_REAL , "Zero bias threshold voltage variation"), -IOP( "xgw", BSIM4_XGW, IF_REAL, "Distance from gate contact center to device edge"), -IOP( "ngcon", BSIM4_NGCON, IF_REAL, "Number of gate contacts"), +IFparm BSIM4v7pTable[] = { /* parameters */ +IOP( "l", BSIM4v7_L, IF_REAL , "Length"), +IOP( "w", BSIM4v7_W, IF_REAL , "Width"), +IOP( "m", BSIM4v7_M, IF_REAL , "Separate Parallel multiplier"), +IOP( "nf", BSIM4v7_NF, IF_REAL , "Number of fingers"), +IOP( "sa", BSIM4v7_SA, IF_REAL , "distance between OD edge to poly of one side "), +IOP( "sb", BSIM4v7_SB, IF_REAL , "distance between OD edge to poly of the other side"), +IOP( "sd", BSIM4v7_SD, IF_REAL , "distance between neighbour fingers"), +IOP( "sca", BSIM4v7_SCA, IF_REAL , "Integral of the first distribution function for scattered well dopant"), +IOP( "scb", BSIM4v7_SCB, IF_REAL , "Integral of the second distribution function for scattered well dopant"), +IOP( "scc", BSIM4v7_SCC, IF_REAL , "Integral of the third distribution function for scattered well dopant"), +IOP( "sc", BSIM4v7_SC, IF_REAL , "Distance to a single well edge "), +IOP( "min", BSIM4v7_MIN, IF_INTEGER , "Minimize either D or S"), +IOP( "ad", BSIM4v7_AD, IF_REAL , "Drain area"), +IOP( "as", BSIM4v7_AS, IF_REAL , "Source area"), +IOP( "pd", BSIM4v7_PD, IF_REAL , "Drain perimeter"), +IOP( "ps", BSIM4v7_PS, IF_REAL , "Source perimeter"), +IOP( "nrd", BSIM4v7_NRD, IF_REAL , "Number of squares in drain"), +IOP( "nrs", BSIM4v7_NRS, IF_REAL , "Number of squares in source"), +IOP( "off", BSIM4v7_OFF, IF_FLAG , "Device is initially off"), +IOP( "rbdb", BSIM4v7_RBDB, IF_REAL , "Body resistance"), +IOP( "rbsb", BSIM4v7_RBSB, IF_REAL , "Body resistance"), +IOP( "rbpb", BSIM4v7_RBPB, IF_REAL , "Body resistance"), +IOP( "rbps", BSIM4v7_RBPS, IF_REAL , "Body resistance"), +IOP( "rbpd", BSIM4v7_RBPD, IF_REAL , "Body resistance"), +IOP( "delvto", BSIM4v7_DELVTO, IF_REAL , "Zero bias threshold voltage variation"), +IOP( "xgw", BSIM4v7_XGW, IF_REAL, "Distance from gate contact center to device edge"), +IOP( "ngcon", BSIM4v7_NGCON, IF_REAL, "Number of gate contacts"), -IOP( "trnqsmod", BSIM4_TRNQSMOD, IF_INTEGER, "Transient NQS model selector"), -IOP( "acnqsmod", BSIM4_ACNQSMOD, IF_INTEGER, "AC NQS model selector"), -IOP( "rbodymod", BSIM4_RBODYMOD, IF_INTEGER, "Distributed body R model selector"), -IOP( "rgatemod", BSIM4_RGATEMOD, IF_INTEGER, "Gate resistance model selector"), -IOP( "geomod", BSIM4_GEOMOD, IF_INTEGER, "Geometry dependent parasitics model selector"), -IOP( "rgeomod", BSIM4_RGEOMOD, IF_INTEGER, "S/D resistance and contact model selector"), -IP( "ic", BSIM4_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"), -OP( "gmbs", BSIM4_GMBS, IF_REAL, "Gmb"), -OP( "gm", BSIM4_GM, IF_REAL, "Gm"), -OP( "gds", BSIM4_GDS, IF_REAL, "Gds"), -OP( "vdsat", BSIM4_VDSAT, IF_REAL, "Vdsat"), -OP( "vth", BSIM4_VON, IF_REAL, "Vth"), -OP( "id", BSIM4_CD, IF_REAL, "Ids"), -OP( "ibd", BSIM4_CBD, IF_REAL, "Ibd"), -OP( "ibs", BSIM4_CBS, IF_REAL, "Ibs"), -OP( "gbd", BSIM4_GBD, IF_REAL, "gbd"), -OP( "gbs", BSIM4_GBS, IF_REAL, "gbs"), -OP( "isub", BSIM4_CSUB, IF_REAL, "Isub"), -OP( "igidl", BSIM4_IGIDL, IF_REAL, "Igidl"), -OP( "igisl", BSIM4_IGISL, IF_REAL, "Igisl"), -OP( "igs", BSIM4_IGS, IF_REAL, "Igs"), -OP( "igd", BSIM4_IGD, IF_REAL, "Igd"), -OP( "igb", BSIM4_IGB, IF_REAL, "Igb"), -OP( "igcs", BSIM4_IGCS, IF_REAL, "Igcs"), -OP( "igcd", BSIM4_IGCD, IF_REAL, "Igcd"), -OP( "vbs", BSIM4_VBS, IF_REAL, "Vbs"), -OP( "vgs", BSIM4_VGS, IF_REAL, "Vgs"), -OP( "vds", BSIM4_VDS, IF_REAL, "Vds"), -OP( "cgg", BSIM4_CGGB, IF_REAL, "Cggb"), -OP( "cgs", BSIM4_CGSB, IF_REAL, "Cgsb"), -OP( "cgd", BSIM4_CGDB, IF_REAL, "Cgdb"), -OP( "cbg", BSIM4_CBGB, IF_REAL, "Cbgb"), -OP( "cbd", BSIM4_CBDB, IF_REAL, "Cbdb"), -OP( "cbs", BSIM4_CBSB, IF_REAL, "Cbsb"), -OP( "cdg", BSIM4_CDGB, IF_REAL, "Cdgb"), -OP( "cdd", BSIM4_CDDB, IF_REAL, "Cddb"), -OP( "cds", BSIM4_CDSB, IF_REAL, "Cdsb"), -OP( "csg", BSIM4_CSGB, IF_REAL, "Csgb"), -OP( "csd", BSIM4_CSDB, IF_REAL, "Csdb"), -OP( "css", BSIM4_CSSB, IF_REAL, "Cssb"), -OP( "cgb", BSIM4_CGBB, IF_REAL, "Cgbb"), -OP( "cdb", BSIM4_CDBB, IF_REAL, "Cdbb"), -OP( "csb", BSIM4_CSBB, IF_REAL, "Csbb"), -OP( "cbb", BSIM4_CBBB, IF_REAL, "Cbbb"), -OP( "capbd", BSIM4_CAPBD, IF_REAL, "Capbd"), -OP( "capbs", BSIM4_CAPBS, IF_REAL, "Capbs"), -OP( "qg", BSIM4_QG, IF_REAL, "Qgate"), -OP( "qb", BSIM4_QB, IF_REAL, "Qbulk"), -OP( "qd", BSIM4_QD, IF_REAL, "Qdrain"), -OP( "qs", BSIM4_QS, IF_REAL, "Qsource"), -OP( "qinv", BSIM4_QINV, IF_REAL, "Qinversion"), -OP( "qdef", BSIM4_QDEF, IF_REAL, "Qdef"), -OP( "gcrg", BSIM4_GCRG, IF_REAL, "Gcrg"), -OP( "gtau", BSIM4_GTAU, IF_REAL, "Gtau"), +IOP( "trnqsmod", BSIM4v7_TRNQSMOD, IF_INTEGER, "Transient NQS model selector"), +IOP( "acnqsmod", BSIM4v7_ACNQSMOD, IF_INTEGER, "AC NQS model selector"), +IOP( "rbodymod", BSIM4v7_RBODYMOD, IF_INTEGER, "Distributed body R model selector"), +IOP( "rgatemod", BSIM4v7_RGATEMOD, IF_INTEGER, "Gate resistance model selector"), +IOP( "geomod", BSIM4v7_GEOMOD, IF_INTEGER, "Geometry dependent parasitics model selector"), +IOP( "rgeomod", BSIM4v7_RGEOMOD, IF_INTEGER, "S/D resistance and contact model selector"), +IP( "ic", BSIM4v7_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"), +OP( "gmbs", BSIM4v7_GMBS, IF_REAL, "Gmb"), +OP( "gm", BSIM4v7_GM, IF_REAL, "Gm"), +OP( "gds", BSIM4v7_GDS, IF_REAL, "Gds"), +OP( "vdsat", BSIM4v7_VDSAT, IF_REAL, "Vdsat"), +OP( "vth", BSIM4v7_VON, IF_REAL, "Vth"), +OP( "id", BSIM4v7_CD, IF_REAL, "Ids"), +OP( "ibd", BSIM4v7_CBD, IF_REAL, "Ibd"), +OP( "ibs", BSIM4v7_CBS, IF_REAL, "Ibs"), +OP( "gbd", BSIM4v7_GBD, IF_REAL, "gbd"), +OP( "gbs", BSIM4v7_GBS, IF_REAL, "gbs"), +OP( "isub", BSIM4v7_CSUB, IF_REAL, "Isub"), +OP( "igidl", BSIM4v7_IGIDL, IF_REAL, "Igidl"), +OP( "igisl", BSIM4v7_IGISL, IF_REAL, "Igisl"), +OP( "igs", BSIM4v7_IGS, IF_REAL, "Igs"), +OP( "igd", BSIM4v7_IGD, IF_REAL, "Igd"), +OP( "igb", BSIM4v7_IGB, IF_REAL, "Igb"), +OP( "igcs", BSIM4v7_IGCS, IF_REAL, "Igcs"), +OP( "igcd", BSIM4v7_IGCD, IF_REAL, "Igcd"), +OP( "vbs", BSIM4v7_VBS, IF_REAL, "Vbs"), +OP( "vgs", BSIM4v7_VGS, IF_REAL, "Vgs"), +OP( "vds", BSIM4v7_VDS, IF_REAL, "Vds"), +OP( "cgg", BSIM4v7_CGGB, IF_REAL, "Cggb"), +OP( "cgs", BSIM4v7_CGSB, IF_REAL, "Cgsb"), +OP( "cgd", BSIM4v7_CGDB, IF_REAL, "Cgdb"), +OP( "cbg", BSIM4v7_CBGB, IF_REAL, "Cbgb"), +OP( "cbd", BSIM4v7_CBDB, IF_REAL, "Cbdb"), +OP( "cbs", BSIM4v7_CBSB, IF_REAL, "Cbsb"), +OP( "cdg", BSIM4v7_CDGB, IF_REAL, "Cdgb"), +OP( "cdd", BSIM4v7_CDDB, IF_REAL, "Cddb"), +OP( "cds", BSIM4v7_CDSB, IF_REAL, "Cdsb"), +OP( "csg", BSIM4v7_CSGB, IF_REAL, "Csgb"), +OP( "csd", BSIM4v7_CSDB, IF_REAL, "Csdb"), +OP( "css", BSIM4v7_CSSB, IF_REAL, "Cssb"), +OP( "cgb", BSIM4v7_CGBB, IF_REAL, "Cgbb"), +OP( "cdb", BSIM4v7_CDBB, IF_REAL, "Cdbb"), +OP( "csb", BSIM4v7_CSBB, IF_REAL, "Csbb"), +OP( "cbb", BSIM4v7_CBBB, IF_REAL, "Cbbb"), +OP( "capbd", BSIM4v7_CAPBD, IF_REAL, "Capbd"), +OP( "capbs", BSIM4v7_CAPBS, IF_REAL, "Capbs"), +OP( "qg", BSIM4v7_QG, IF_REAL, "Qgate"), +OP( "qb", BSIM4v7_QB, IF_REAL, "Qbulk"), +OP( "qd", BSIM4v7_QD, IF_REAL, "Qdrain"), +OP( "qs", BSIM4v7_QS, IF_REAL, "Qsource"), +OP( "qinv", BSIM4v7_QINV, IF_REAL, "Qinversion"), +OP( "qdef", BSIM4v7_QDEF, IF_REAL, "Qdef"), +OP( "gcrg", BSIM4v7_GCRG, IF_REAL, "Gcrg"), +OP( "gtau", BSIM4v7_GTAU, IF_REAL, "Gtau"), }; -IFparm BSIM4mPTable[] = { /* model parameters */ -IOP( "cvchargemod", BSIM4_MOD_CVCHARGEMOD, IF_INTEGER, "Capacitance Charge model selector"), -IOP( "capmod", BSIM4_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"), -IOP( "diomod", BSIM4_MOD_DIOMOD, IF_INTEGER, "Diode IV model selector"), -IOP( "rdsmod", BSIM4_MOD_RDSMOD, IF_INTEGER, "Bias-dependent S/D resistance model selector"), -IOP( "trnqsmod", BSIM4_MOD_TRNQSMOD, IF_INTEGER, "Transient NQS model selector"), -IOP( "acnqsmod", BSIM4_MOD_ACNQSMOD, IF_INTEGER, "AC NQS model selector"), -IOP( "mobmod", BSIM4_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"), -IOP( "rbodymod", BSIM4_MOD_RBODYMOD, IF_INTEGER, "Distributed body R model selector"), -IOP( "rgatemod", BSIM4_MOD_RGATEMOD, IF_INTEGER, "Gate R model selector"), -IOP( "permod", BSIM4_MOD_PERMOD, IF_INTEGER, "Pd and Ps model selector"), -IOP( "geomod", BSIM4_MOD_GEOMOD, IF_INTEGER, "Geometry dependent parasitics model selector"), -IOP( "rgeomod", BSIM4_MOD_RGEOMOD, IF_INTEGER, "S/D resistance and contact model selector"), -IOP( "fnoimod", BSIM4_MOD_FNOIMOD, IF_INTEGER, "Flicker noise model selector"), -IOP( "tnoimod", BSIM4_MOD_TNOIMOD, IF_INTEGER, "Thermal noise model selector"), -IOP( "mtrlmod", BSIM4_MOD_MTRLMOD, IF_INTEGER, "parameter for non-silicon substrate or metal gate selector"), -IOP( "mtrlcompatmod", BSIM4_MOD_MTRLCOMPATMOD, IF_INTEGER, "New Material Mod backward compatibility selector"), -IOP( "igcmod", BSIM4_MOD_IGCMOD, IF_INTEGER, "Gate-to-channel Ig model selector"), -IOP( "igbmod", BSIM4_MOD_IGBMOD, IF_INTEGER, "Gate-to-body Ig model selector"), -IOP( "tempmod", BSIM4_MOD_TEMPMOD, IF_INTEGER, "Temperature model selector"), -IOP( "gidlmod", BSIM4_MOD_GIDLMOD, IF_INTEGER, "parameter for GIDL selector"), /* v4.7 New GIDL/GISL */ -IOP( "paramchk", BSIM4_MOD_PARAMCHK, IF_INTEGER, "Model parameter checking selector"), -IOP( "binunit", BSIM4_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"), -IOP( "version", BSIM4_MOD_VERSION, IF_STRING, "parameter for model version"), -IOP( "eot", BSIM4_MOD_EOT, IF_REAL, "Equivalent gate oxide thickness in meters"), -IOP( "vddeot", BSIM4_MOD_VDDEOT, IF_REAL, "Voltage for extraction of Equivalent gate oxide thickness"), -IOP( "tempeot", BSIM4_MOD_TEMPEOT, IF_REAL, " Temperature for extraction of EOT"), -IOP( "leffeot", BSIM4_MOD_LEFFEOT, IF_REAL, " Effective length for extraction of EOT"), -IOP( "weffeot", BSIM4_MOD_WEFFEOT, IF_REAL, "Effective width for extraction of EOT"), -IOP( "ados", BSIM4_MOD_ADOS, IF_REAL, "Charge centroid parameter"), -IOP( "bdos", BSIM4_MOD_BDOS, IF_REAL, "Charge centroid parameter"), -IOP( "toxe", BSIM4_MOD_TOXE, IF_REAL, "Electrical gate oxide thickness in meters"), -IOP( "toxp", BSIM4_MOD_TOXP, IF_REAL, "Physical gate oxide thickness in meters"), -IOP( "toxm", BSIM4_MOD_TOXM, IF_REAL, "Gate oxide thickness at which parameters are extracted"), -IOP( "toxref", BSIM4_MOD_TOXREF, IF_REAL, "Target tox value"), -IOP( "dtox", BSIM4_MOD_DTOX, IF_REAL, "Defined as (toxe - toxp) "), -IOP( "epsrox", BSIM4_MOD_EPSROX, IF_REAL, "Dielectric constant of the gate oxide relative to vacuum"), -IOP( "cdsc", BSIM4_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"), -IOP( "cdscb", BSIM4_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"), -IOP( "cdscd", BSIM4_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"), -IOP( "cit", BSIM4_MOD_CIT, IF_REAL, "Interface state capacitance"), -IOP( "nfactor", BSIM4_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"), -IOP( "xj", BSIM4_MOD_XJ, IF_REAL, "Junction depth in meters"), -IOP( "vsat", BSIM4_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"), -IOP( "at", BSIM4_MOD_AT, IF_REAL, "Temperature coefficient of vsat"), -IOP( "a0", BSIM4_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."), -IOP( "ags", BSIM4_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."), -IOP( "a1", BSIM4_MOD_A1, IF_REAL, "Non-saturation effect coefficient"), -IOP( "a2", BSIM4_MOD_A2, IF_REAL, "Non-saturation effect coefficient"), -IOP( "keta", BSIM4_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."), -IOP( "phig", BSIM4_MOD_PHIG, IF_REAL, "Work function of gate"), -IOP( "epsrgate", BSIM4_MOD_EPSRGATE, IF_REAL, "Dielectric constant of gate relative to vacuum"), -IOP( "easub",BSIM4_MOD_EASUB, IF_REAL, "Electron affinity of substrate"), -IOP( "epsrsub", BSIM4_MOD_EPSRSUB, IF_REAL, "Dielectric constant of substrate relative to vacuum"), -IOP( "ni0sub", BSIM4_MOD_NI0SUB, IF_REAL, "Intrinsic carrier concentration of substrate at 300.15K"), -IOP( "bg0sub", BSIM4_MOD_BG0SUB, IF_REAL, "Band-gap of substrate at T=0K"), -IOP( "tbgasub", BSIM4_MOD_TBGASUB, IF_REAL, "First parameter of band-gap change due to temperature"), -IOP( "tbgbsub", BSIM4_MOD_TBGBSUB, IF_REAL, "Second parameter of band-gap change due to temperature"), -IOP( "nsub", BSIM4_MOD_NSUB, IF_REAL, "Substrate doping concentration"), -IOP( "ndep", BSIM4_MOD_NDEP, IF_REAL, "Channel doping concentration at the depletion edge"), -IOP( "nsd", BSIM4_MOD_NSD, IF_REAL, "S/D doping concentration"), -IOP( "phin", BSIM4_MOD_PHIN, IF_REAL, "Adjusting parameter for surface potential due to non-uniform vertical doping"), -IOP( "ngate", BSIM4_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"), -IOP( "gamma1", BSIM4_MOD_GAMMA1, IF_REAL, "Vth body coefficient"), -IOP( "gamma2", BSIM4_MOD_GAMMA2, IF_REAL, "Vth body coefficient"), -IOP( "vbx", BSIM4_MOD_VBX, IF_REAL, "Vth transition body Voltage"), -IOP( "vbm", BSIM4_MOD_VBM, IF_REAL, "Maximum body voltage"), +IFparm BSIM4v7mPTable[] = { /* model parameters */ +IOP( "cvchargemod", BSIM4v7_MOD_CVCHARGEMOD, IF_INTEGER, "Capacitance Charge model selector"), +IOP( "capmod", BSIM4v7_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"), +IOP( "diomod", BSIM4v7_MOD_DIOMOD, IF_INTEGER, "Diode IV model selector"), +IOP( "rdsmod", BSIM4v7_MOD_RDSMOD, IF_INTEGER, "Bias-dependent S/D resistance model selector"), +IOP( "trnqsmod", BSIM4v7_MOD_TRNQSMOD, IF_INTEGER, "Transient NQS model selector"), +IOP( "acnqsmod", BSIM4v7_MOD_ACNQSMOD, IF_INTEGER, "AC NQS model selector"), +IOP( "mobmod", BSIM4v7_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"), +IOP( "rbodymod", BSIM4v7_MOD_RBODYMOD, IF_INTEGER, "Distributed body R model selector"), +IOP( "rgatemod", BSIM4v7_MOD_RGATEMOD, IF_INTEGER, "Gate R model selector"), +IOP( "permod", BSIM4v7_MOD_PERMOD, IF_INTEGER, "Pd and Ps model selector"), +IOP( "geomod", BSIM4v7_MOD_GEOMOD, IF_INTEGER, "Geometry dependent parasitics model selector"), +IOP( "rgeomod", BSIM4v7_MOD_RGEOMOD, IF_INTEGER, "S/D resistance and contact model selector"), +IOP( "fnoimod", BSIM4v7_MOD_FNOIMOD, IF_INTEGER, "Flicker noise model selector"), +IOP( "tnoimod", BSIM4v7_MOD_TNOIMOD, IF_INTEGER, "Thermal noise model selector"), +IOP( "mtrlmod", BSIM4v7_MOD_MTRLMOD, IF_INTEGER, "parameter for non-silicon substrate or metal gate selector"), +IOP( "mtrlcompatmod", BSIM4v7_MOD_MTRLCOMPATMOD, IF_INTEGER, "New Material Mod backward compatibility selector"), +IOP( "igcmod", BSIM4v7_MOD_IGCMOD, IF_INTEGER, "Gate-to-channel Ig model selector"), +IOP( "igbmod", BSIM4v7_MOD_IGBMOD, IF_INTEGER, "Gate-to-body Ig model selector"), +IOP( "tempmod", BSIM4v7_MOD_TEMPMOD, IF_INTEGER, "Temperature model selector"), +IOP( "gidlmod", BSIM4v7_MOD_GIDLMOD, IF_INTEGER, "parameter for GIDL selector"), /* v4.7 New GIDL/GISL */ +IOP( "paramchk", BSIM4v7_MOD_PARAMCHK, IF_INTEGER, "Model parameter checking selector"), +IOP( "binunit", BSIM4v7_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"), +IOP( "version", BSIM4v7_MOD_VERSION, IF_STRING, "parameter for model version"), +IOP( "eot", BSIM4v7_MOD_EOT, IF_REAL, "Equivalent gate oxide thickness in meters"), +IOP( "vddeot", BSIM4v7_MOD_VDDEOT, IF_REAL, "Voltage for extraction of Equivalent gate oxide thickness"), +IOP( "tempeot", BSIM4v7_MOD_TEMPEOT, IF_REAL, " Temperature for extraction of EOT"), +IOP( "leffeot", BSIM4v7_MOD_LEFFEOT, IF_REAL, " Effective length for extraction of EOT"), +IOP( "weffeot", BSIM4v7_MOD_WEFFEOT, IF_REAL, "Effective width for extraction of EOT"), +IOP( "ados", BSIM4v7_MOD_ADOS, IF_REAL, "Charge centroid parameter"), +IOP( "bdos", BSIM4v7_MOD_BDOS, IF_REAL, "Charge centroid parameter"), +IOP( "toxe", BSIM4v7_MOD_TOXE, IF_REAL, "Electrical gate oxide thickness in meters"), +IOP( "toxp", BSIM4v7_MOD_TOXP, IF_REAL, "Physical gate oxide thickness in meters"), +IOP( "toxm", BSIM4v7_MOD_TOXM, IF_REAL, "Gate oxide thickness at which parameters are extracted"), +IOP( "toxref", BSIM4v7_MOD_TOXREF, IF_REAL, "Target tox value"), +IOP( "dtox", BSIM4v7_MOD_DTOX, IF_REAL, "Defined as (toxe - toxp) "), +IOP( "epsrox", BSIM4v7_MOD_EPSROX, IF_REAL, "Dielectric constant of the gate oxide relative to vacuum"), +IOP( "cdsc", BSIM4v7_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"), +IOP( "cdscb", BSIM4v7_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"), +IOP( "cdscd", BSIM4v7_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"), +IOP( "cit", BSIM4v7_MOD_CIT, IF_REAL, "Interface state capacitance"), +IOP( "nfactor", BSIM4v7_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"), +IOP( "xj", BSIM4v7_MOD_XJ, IF_REAL, "Junction depth in meters"), +IOP( "vsat", BSIM4v7_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"), +IOP( "at", BSIM4v7_MOD_AT, IF_REAL, "Temperature coefficient of vsat"), +IOP( "a0", BSIM4v7_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."), +IOP( "ags", BSIM4v7_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."), +IOP( "a1", BSIM4v7_MOD_A1, IF_REAL, "Non-saturation effect coefficient"), +IOP( "a2", BSIM4v7_MOD_A2, IF_REAL, "Non-saturation effect coefficient"), +IOP( "keta", BSIM4v7_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."), +IOP( "phig", BSIM4v7_MOD_PHIG, IF_REAL, "Work function of gate"), +IOP( "epsrgate", BSIM4v7_MOD_EPSRGATE, IF_REAL, "Dielectric constant of gate relative to vacuum"), +IOP( "easub",BSIM4v7_MOD_EASUB, IF_REAL, "Electron affinity of substrate"), +IOP( "epsrsub", BSIM4v7_MOD_EPSRSUB, IF_REAL, "Dielectric constant of substrate relative to vacuum"), +IOP( "ni0sub", BSIM4v7_MOD_NI0SUB, IF_REAL, "Intrinsic carrier concentration of substrate at 300.15K"), +IOP( "bg0sub", BSIM4v7_MOD_BG0SUB, IF_REAL, "Band-gap of substrate at T=0K"), +IOP( "tbgasub", BSIM4v7_MOD_TBGASUB, IF_REAL, "First parameter of band-gap change due to temperature"), +IOP( "tbgbsub", BSIM4v7_MOD_TBGBSUB, IF_REAL, "Second parameter of band-gap change due to temperature"), +IOP( "nsub", BSIM4v7_MOD_NSUB, IF_REAL, "Substrate doping concentration"), +IOP( "ndep", BSIM4v7_MOD_NDEP, IF_REAL, "Channel doping concentration at the depletion edge"), +IOP( "nsd", BSIM4v7_MOD_NSD, IF_REAL, "S/D doping concentration"), +IOP( "phin", BSIM4v7_MOD_PHIN, IF_REAL, "Adjusting parameter for surface potential due to non-uniform vertical doping"), +IOP( "ngate", BSIM4v7_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"), +IOP( "gamma1", BSIM4v7_MOD_GAMMA1, IF_REAL, "Vth body coefficient"), +IOP( "gamma2", BSIM4v7_MOD_GAMMA2, IF_REAL, "Vth body coefficient"), +IOP( "vbx", BSIM4v7_MOD_VBX, IF_REAL, "Vth transition body Voltage"), +IOP( "vbm", BSIM4v7_MOD_VBM, IF_REAL, "Maximum body voltage"), -IOP( "xt", BSIM4_MOD_XT, IF_REAL, "Doping depth"), -IOP( "k1", BSIM4_MOD_K1, IF_REAL, "Bulk effect coefficient 1"), -IOP( "kt1", BSIM4_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"), -IOP( "kt1l", BSIM4_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"), -IOP( "kt2", BSIM4_MOD_KT2, IF_REAL, "Body-coefficient of kt1"), -IOP( "k2", BSIM4_MOD_K2, IF_REAL, "Bulk effect coefficient 2"), -IOP( "k3", BSIM4_MOD_K3, IF_REAL, "Narrow width effect coefficient"), -IOP( "k3b", BSIM4_MOD_K3B, IF_REAL, "Body effect coefficient of k3"), -IOP( "w0", BSIM4_MOD_W0, IF_REAL, "Narrow width effect parameter"), -IOP( "dvtp0", BSIM4_MOD_DVTP0, IF_REAL, "First parameter for Vth shift due to pocket"), -IOP( "dvtp1", BSIM4_MOD_DVTP1, IF_REAL, "Second parameter for Vth shift due to pocket"), -IOP( "dvtp2", BSIM4_MOD_DVTP2, IF_REAL, "3rd parameter for Vth shift due to pocket"), -IOP( "dvtp3", BSIM4_MOD_DVTP3, IF_REAL, "4th parameter for Vth shift due to pocket"), -IOP( "dvtp4", BSIM4_MOD_DVTP4, IF_REAL, "5th parameter for Vth shift due to pocket"), -IOP( "dvtp5", BSIM4_MOD_DVTP5, IF_REAL, "6th parameter for Vth shift due to pocket"), -IOP( "lpe0", BSIM4_MOD_LPE0, IF_REAL, "Equivalent length of pocket region at zero bias"), -IOP( "lpeb", BSIM4_MOD_LPEB, IF_REAL, "Equivalent length of pocket region accounting for body bias"), -IOP( "dvt0", BSIM4_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"), -IOP( "dvt1", BSIM4_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"), -IOP( "dvt2", BSIM4_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"), -IOP( "dvt0w", BSIM4_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"), -IOP( "dvt1w", BSIM4_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"), -IOP( "dvt2w", BSIM4_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"), -IOP( "drout", BSIM4_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"), -IOP( "dsub", BSIM4_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"), -IOP( "vth0", BSIM4_MOD_VTH0, IF_REAL,"Threshold voltage"), -IOP( "vtho", BSIM4_MOD_VTH0, IF_REAL,"Threshold voltage"), -IOP( "ua", BSIM4_MOD_UA, IF_REAL, "Linear gate dependence of mobility"), -IOP( "ua1", BSIM4_MOD_UA1, IF_REAL, "Temperature coefficient of ua"), -IOP( "ub", BSIM4_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"), -IOP( "ub1", BSIM4_MOD_UB1, IF_REAL, "Temperature coefficient of ub"), -IOP( "uc", BSIM4_MOD_UC, IF_REAL, "Body-bias dependence of mobility"), -IOP( "uc1", BSIM4_MOD_UC1, IF_REAL, "Temperature coefficient of uc"), -IOP( "ud", BSIM4_MOD_UD, IF_REAL, "Coulomb scattering factor of mobility"), -IOP( "ud1", BSIM4_MOD_UD1, IF_REAL, "Temperature coefficient of ud"), -IOP( "up", BSIM4_MOD_UP, IF_REAL, "Channel length linear factor of mobility"), -IOP( "lp", BSIM4_MOD_LP, IF_REAL, "Channel length exponential factor of mobility"), -IOP( "u0", BSIM4_MOD_U0, IF_REAL, "Low-field mobility at Tnom"), -IOP( "eu", BSIM4_MOD_EU, IF_REAL, "Mobility exponent"), -IOP( "ucs", BSIM4_MOD_UCS, IF_REAL, "Colombic scattering exponent"), -IOP( "ute", BSIM4_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"), -IOP( "ucste", BSIM4_MOD_UCSTE, IF_REAL,"Temperature coefficient of colombic mobility"), -IOP( "voff", BSIM4_MOD_VOFF, IF_REAL, "Threshold voltage offset"), -IOP( "minv", BSIM4_MOD_MINV, IF_REAL, "Fitting parameter for moderate inversion in Vgsteff"), -IOP( "minvcv", BSIM4_MOD_MINVCV, IF_REAL, "Fitting parameter for moderate inversion in Vgsteffcv"), -IOP( "voffl", BSIM4_MOD_VOFFL, IF_REAL, "Length dependence parameter for Vth offset"), -IOP( "voffcvl", BSIM4_MOD_VOFFCVL, IF_REAL, "Length dependence parameter for Vth offset in CV"), -IOP( "tnom", BSIM4_MOD_TNOM, IF_REAL, "Parameter measurement temperature"), -IOP( "cgso", BSIM4_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"), -IOP( "cgdo", BSIM4_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"), -IOP( "cgbo", BSIM4_MOD_CGBO, IF_REAL, "Gate-bulk overlap capacitance per length"), -IOP( "xpart", BSIM4_MOD_XPART, IF_REAL, "Channel charge partitioning"), -IOP( "delta", BSIM4_MOD_DELTA, IF_REAL, "Effective Vds parameter"), -IOP( "rsh", BSIM4_MOD_RSH, IF_REAL, "Source-drain sheet resistance"), -IOP( "rdsw", BSIM4_MOD_RDSW, IF_REAL, "Source-drain resistance per width"), -IOP( "rdswmin", BSIM4_MOD_RDSWMIN, IF_REAL, "Source-drain resistance per width at high Vg"), -IOP( "rsw", BSIM4_MOD_RSW, IF_REAL, "Source resistance per width"), -IOP( "rdw", BSIM4_MOD_RDW, IF_REAL, "Drain resistance per width"), -IOP( "rdwmin", BSIM4_MOD_RDWMIN, IF_REAL, "Drain resistance per width at high Vg"), -IOP( "rswmin", BSIM4_MOD_RSWMIN, IF_REAL, "Source resistance per width at high Vg"), +IOP( "xt", BSIM4v7_MOD_XT, IF_REAL, "Doping depth"), +IOP( "k1", BSIM4v7_MOD_K1, IF_REAL, "Bulk effect coefficient 1"), +IOP( "kt1", BSIM4v7_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"), +IOP( "kt1l", BSIM4v7_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"), +IOP( "kt2", BSIM4v7_MOD_KT2, IF_REAL, "Body-coefficient of kt1"), +IOP( "k2", BSIM4v7_MOD_K2, IF_REAL, "Bulk effect coefficient 2"), +IOP( "k3", BSIM4v7_MOD_K3, IF_REAL, "Narrow width effect coefficient"), +IOP( "k3b", BSIM4v7_MOD_K3B, IF_REAL, "Body effect coefficient of k3"), +IOP( "w0", BSIM4v7_MOD_W0, IF_REAL, "Narrow width effect parameter"), +IOP( "dvtp0", BSIM4v7_MOD_DVTP0, IF_REAL, "First parameter for Vth shift due to pocket"), +IOP( "dvtp1", BSIM4v7_MOD_DVTP1, IF_REAL, "Second parameter for Vth shift due to pocket"), +IOP( "dvtp2", BSIM4v7_MOD_DVTP2, IF_REAL, "3rd parameter for Vth shift due to pocket"), +IOP( "dvtp3", BSIM4v7_MOD_DVTP3, IF_REAL, "4th parameter for Vth shift due to pocket"), +IOP( "dvtp4", BSIM4v7_MOD_DVTP4, IF_REAL, "5th parameter for Vth shift due to pocket"), +IOP( "dvtp5", BSIM4v7_MOD_DVTP5, IF_REAL, "6th parameter for Vth shift due to pocket"), +IOP( "lpe0", BSIM4v7_MOD_LPE0, IF_REAL, "Equivalent length of pocket region at zero bias"), +IOP( "lpeb", BSIM4v7_MOD_LPEB, IF_REAL, "Equivalent length of pocket region accounting for body bias"), +IOP( "dvt0", BSIM4v7_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"), +IOP( "dvt1", BSIM4v7_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"), +IOP( "dvt2", BSIM4v7_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"), +IOP( "dvt0w", BSIM4v7_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"), +IOP( "dvt1w", BSIM4v7_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"), +IOP( "dvt2w", BSIM4v7_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"), +IOP( "drout", BSIM4v7_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"), +IOP( "dsub", BSIM4v7_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"), +IOP( "vth0", BSIM4v7_MOD_VTH0, IF_REAL,"Threshold voltage"), +IOP( "vtho", BSIM4v7_MOD_VTH0, IF_REAL,"Threshold voltage"), +IOP( "ua", BSIM4v7_MOD_UA, IF_REAL, "Linear gate dependence of mobility"), +IOP( "ua1", BSIM4v7_MOD_UA1, IF_REAL, "Temperature coefficient of ua"), +IOP( "ub", BSIM4v7_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"), +IOP( "ub1", BSIM4v7_MOD_UB1, IF_REAL, "Temperature coefficient of ub"), +IOP( "uc", BSIM4v7_MOD_UC, IF_REAL, "Body-bias dependence of mobility"), +IOP( "uc1", BSIM4v7_MOD_UC1, IF_REAL, "Temperature coefficient of uc"), +IOP( "ud", BSIM4v7_MOD_UD, IF_REAL, "Coulomb scattering factor of mobility"), +IOP( "ud1", BSIM4v7_MOD_UD1, IF_REAL, "Temperature coefficient of ud"), +IOP( "up", BSIM4v7_MOD_UP, IF_REAL, "Channel length linear factor of mobility"), +IOP( "lp", BSIM4v7_MOD_LP, IF_REAL, "Channel length exponential factor of mobility"), +IOP( "u0", BSIM4v7_MOD_U0, IF_REAL, "Low-field mobility at Tnom"), +IOP( "eu", BSIM4v7_MOD_EU, IF_REAL, "Mobility exponent"), +IOP( "ucs", BSIM4v7_MOD_UCS, IF_REAL, "Colombic scattering exponent"), +IOP( "ute", BSIM4v7_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"), +IOP( "ucste", BSIM4v7_MOD_UCSTE, IF_REAL,"Temperature coefficient of colombic mobility"), +IOP( "voff", BSIM4v7_MOD_VOFF, IF_REAL, "Threshold voltage offset"), +IOP( "minv", BSIM4v7_MOD_MINV, IF_REAL, "Fitting parameter for moderate inversion in Vgsteff"), +IOP( "minvcv", BSIM4v7_MOD_MINVCV, IF_REAL, "Fitting parameter for moderate inversion in Vgsteffcv"), +IOP( "voffl", BSIM4v7_MOD_VOFFL, IF_REAL, "Length dependence parameter for Vth offset"), +IOP( "voffcvl", BSIM4v7_MOD_VOFFCVL, IF_REAL, "Length dependence parameter for Vth offset in CV"), +IOP( "tnom", BSIM4v7_MOD_TNOM, IF_REAL, "Parameter measurement temperature"), +IOP( "cgso", BSIM4v7_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"), +IOP( "cgdo", BSIM4v7_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"), +IOP( "cgbo", BSIM4v7_MOD_CGBO, IF_REAL, "Gate-bulk overlap capacitance per length"), +IOP( "xpart", BSIM4v7_MOD_XPART, IF_REAL, "Channel charge partitioning"), +IOP( "delta", BSIM4v7_MOD_DELTA, IF_REAL, "Effective Vds parameter"), +IOP( "rsh", BSIM4v7_MOD_RSH, IF_REAL, "Source-drain sheet resistance"), +IOP( "rdsw", BSIM4v7_MOD_RDSW, IF_REAL, "Source-drain resistance per width"), +IOP( "rdswmin", BSIM4v7_MOD_RDSWMIN, IF_REAL, "Source-drain resistance per width at high Vg"), +IOP( "rsw", BSIM4v7_MOD_RSW, IF_REAL, "Source resistance per width"), +IOP( "rdw", BSIM4v7_MOD_RDW, IF_REAL, "Drain resistance per width"), +IOP( "rdwmin", BSIM4v7_MOD_RDWMIN, IF_REAL, "Drain resistance per width at high Vg"), +IOP( "rswmin", BSIM4v7_MOD_RSWMIN, IF_REAL, "Source resistance per width at high Vg"), -IOP( "prwg", BSIM4_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "), -IOP( "prwb", BSIM4_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "), +IOP( "prwg", BSIM4v7_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "), +IOP( "prwb", BSIM4v7_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "), -IOP( "prt", BSIM4_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "), -IOP( "eta0", BSIM4_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"), -IOP( "etab", BSIM4_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"), -IOP( "pclm", BSIM4_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"), -IOP( "pdiblc1", BSIM4_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"), -IOP( "pdiblc2", BSIM4_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"), -IOP( "pdiblcb", BSIM4_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"), -IOP( "fprout", BSIM4_MOD_FPROUT, IF_REAL, "Rout degradation coefficient for pocket devices"), -IOP( "pdits", BSIM4_MOD_PDITS, IF_REAL, "Coefficient for drain-induced Vth shifts"), -IOP( "pditsl", BSIM4_MOD_PDITSL, IF_REAL, "Length dependence of drain-induced Vth shifts"), -IOP( "pditsd", BSIM4_MOD_PDITSD, IF_REAL, "Vds dependence of drain-induced Vth shifts"), -IOP( "pscbe1", BSIM4_MOD_PSCBE1, IF_REAL, "Substrate current body-effect coefficient"), -IOP( "pscbe2", BSIM4_MOD_PSCBE2, IF_REAL, "Substrate current body-effect coefficient"), -IOP( "pvag", BSIM4_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"), +IOP( "prt", BSIM4v7_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "), +IOP( "eta0", BSIM4v7_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"), +IOP( "etab", BSIM4v7_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"), +IOP( "pclm", BSIM4v7_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"), +IOP( "pdiblc1", BSIM4v7_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"), +IOP( "pdiblc2", BSIM4v7_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"), +IOP( "pdiblcb", BSIM4v7_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"), +IOP( "fprout", BSIM4v7_MOD_FPROUT, IF_REAL, "Rout degradation coefficient for pocket devices"), +IOP( "pdits", BSIM4v7_MOD_PDITS, IF_REAL, "Coefficient for drain-induced Vth shifts"), +IOP( "pditsl", BSIM4v7_MOD_PDITSL, IF_REAL, "Length dependence of drain-induced Vth shifts"), +IOP( "pditsd", BSIM4v7_MOD_PDITSD, IF_REAL, "Vds dependence of drain-induced Vth shifts"), +IOP( "pscbe1", BSIM4v7_MOD_PSCBE1, IF_REAL, "Substrate current body-effect coefficient"), +IOP( "pscbe2", BSIM4v7_MOD_PSCBE2, IF_REAL, "Substrate current body-effect coefficient"), +IOP( "pvag", BSIM4v7_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"), -IOP( "jss", BSIM4_MOD_JSS, IF_REAL, "Bottom source junction reverse saturation current density"), -IOP( "jsws", BSIM4_MOD_JSWS, IF_REAL, "Isolation edge sidewall source junction reverse saturation current density"), -IOP( "jswgs", BSIM4_MOD_JSWGS, IF_REAL, "Gate edge source junction reverse saturation current density"), -IOP( "pbs", BSIM4_MOD_PBS, IF_REAL, "Source junction built-in potential"), -IOP( "njs", BSIM4_MOD_NJS, IF_REAL, "Source junction emission coefficient"), -IOP( "xtis", BSIM4_MOD_XTIS, IF_REAL, "Source junction current temperature exponent"), -IOP( "mjs", BSIM4_MOD_MJS, IF_REAL, "Source bottom junction capacitance grading coefficient"), -IOP( "pbsws", BSIM4_MOD_PBSWS, IF_REAL, "Source sidewall junction capacitance built in potential"), -IOP( "mjsws", BSIM4_MOD_MJSWS, IF_REAL, "Source sidewall junction capacitance grading coefficient"), -IOP( "pbswgs", BSIM4_MOD_PBSWGS, IF_REAL, "Source (gate side) sidewall junction capacitance built in potential"), -IOP( "mjswgs", BSIM4_MOD_MJSWGS, IF_REAL, "Source (gate side) sidewall junction capacitance grading coefficient"), -IOP( "cjs", BSIM4_MOD_CJS, IF_REAL, "Source bottom junction capacitance per unit area"), -IOP( "cjsws", BSIM4_MOD_CJSWS, IF_REAL, "Source sidewall junction capacitance per unit periphery"), -IOP( "cjswgs", BSIM4_MOD_CJSWGS, IF_REAL, "Source (gate side) sidewall junction capacitance per unit width"), +IOP( "jss", BSIM4v7_MOD_JSS, IF_REAL, "Bottom source junction reverse saturation current density"), +IOP( "jsws", BSIM4v7_MOD_JSWS, IF_REAL, "Isolation edge sidewall source junction reverse saturation current density"), +IOP( "jswgs", BSIM4v7_MOD_JSWGS, IF_REAL, "Gate edge source junction reverse saturation current density"), +IOP( "pbs", BSIM4v7_MOD_PBS, IF_REAL, "Source junction built-in potential"), +IOP( "njs", BSIM4v7_MOD_NJS, IF_REAL, "Source junction emission coefficient"), +IOP( "xtis", BSIM4v7_MOD_XTIS, IF_REAL, "Source junction current temperature exponent"), +IOP( "mjs", BSIM4v7_MOD_MJS, IF_REAL, "Source bottom junction capacitance grading coefficient"), +IOP( "pbsws", BSIM4v7_MOD_PBSWS, IF_REAL, "Source sidewall junction capacitance built in potential"), +IOP( "mjsws", BSIM4v7_MOD_MJSWS, IF_REAL, "Source sidewall junction capacitance grading coefficient"), +IOP( "pbswgs", BSIM4v7_MOD_PBSWGS, IF_REAL, "Source (gate side) sidewall junction capacitance built in potential"), +IOP( "mjswgs", BSIM4v7_MOD_MJSWGS, IF_REAL, "Source (gate side) sidewall junction capacitance grading coefficient"), +IOP( "cjs", BSIM4v7_MOD_CJS, IF_REAL, "Source bottom junction capacitance per unit area"), +IOP( "cjsws", BSIM4v7_MOD_CJSWS, IF_REAL, "Source sidewall junction capacitance per unit periphery"), +IOP( "cjswgs", BSIM4v7_MOD_CJSWGS, IF_REAL, "Source (gate side) sidewall junction capacitance per unit width"), -IOP( "jsd", BSIM4_MOD_JSD, IF_REAL, "Bottom drain junction reverse saturation current density"), -IOP( "jswd", BSIM4_MOD_JSWD, IF_REAL, "Isolation edge sidewall drain junction reverse saturation current density"), -IOP( "jswgd", BSIM4_MOD_JSWGD, IF_REAL, "Gate edge drain junction reverse saturation current density"), -IOP( "pbd", BSIM4_MOD_PBD, IF_REAL, "Drain junction built-in potential"), -IOP( "njd", BSIM4_MOD_NJD, IF_REAL, "Drain junction emission coefficient"), -IOP( "xtid", BSIM4_MOD_XTID, IF_REAL, "Drainjunction current temperature exponent"), -IOP( "mjd", BSIM4_MOD_MJD, IF_REAL, "Drain bottom junction capacitance grading coefficient"), -IOP( "pbswd", BSIM4_MOD_PBSWD, IF_REAL, "Drain sidewall junction capacitance built in potential"), -IOP( "mjswd", BSIM4_MOD_MJSWD, IF_REAL, "Drain sidewall junction capacitance grading coefficient"), -IOP( "pbswgd", BSIM4_MOD_PBSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance built in potential"), -IOP( "mjswgd", BSIM4_MOD_MJSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance grading coefficient"), -IOP( "cjd", BSIM4_MOD_CJD, IF_REAL, "Drain bottom junction capacitance per unit area"), -IOP( "cjswd", BSIM4_MOD_CJSWD, IF_REAL, "Drain sidewall junction capacitance per unit periphery"), -IOP( "cjswgd", BSIM4_MOD_CJSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance per unit width"), +IOP( "jsd", BSIM4v7_MOD_JSD, IF_REAL, "Bottom drain junction reverse saturation current density"), +IOP( "jswd", BSIM4v7_MOD_JSWD, IF_REAL, "Isolation edge sidewall drain junction reverse saturation current density"), +IOP( "jswgd", BSIM4v7_MOD_JSWGD, IF_REAL, "Gate edge drain junction reverse saturation current density"), +IOP( "pbd", BSIM4v7_MOD_PBD, IF_REAL, "Drain junction built-in potential"), +IOP( "njd", BSIM4v7_MOD_NJD, IF_REAL, "Drain junction emission coefficient"), +IOP( "xtid", BSIM4v7_MOD_XTID, IF_REAL, "Drainjunction current temperature exponent"), +IOP( "mjd", BSIM4v7_MOD_MJD, IF_REAL, "Drain bottom junction capacitance grading coefficient"), +IOP( "pbswd", BSIM4v7_MOD_PBSWD, IF_REAL, "Drain sidewall junction capacitance built in potential"), +IOP( "mjswd", BSIM4v7_MOD_MJSWD, IF_REAL, "Drain sidewall junction capacitance grading coefficient"), +IOP( "pbswgd", BSIM4v7_MOD_PBSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance built in potential"), +IOP( "mjswgd", BSIM4v7_MOD_MJSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance grading coefficient"), +IOP( "cjd", BSIM4v7_MOD_CJD, IF_REAL, "Drain bottom junction capacitance per unit area"), +IOP( "cjswd", BSIM4v7_MOD_CJSWD, IF_REAL, "Drain sidewall junction capacitance per unit periphery"), +IOP( "cjswgd", BSIM4v7_MOD_CJSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance per unit width"), -IOP( "vfbcv", BSIM4_MOD_VFBCV, IF_REAL, "Flat Band Voltage parameter for capmod=0 only"), -IOP( "vfb", BSIM4_MOD_VFB, IF_REAL, "Flat Band Voltage"), -IOP( "tpb", BSIM4_MOD_TPB, IF_REAL, "Temperature coefficient of pb"), -IOP( "tcj", BSIM4_MOD_TCJ, IF_REAL, "Temperature coefficient of cj"), -IOP( "tpbsw", BSIM4_MOD_TPBSW, IF_REAL, "Temperature coefficient of pbsw"), -IOP( "tcjsw", BSIM4_MOD_TCJSW, IF_REAL, "Temperature coefficient of cjsw"), -IOP( "tpbswg", BSIM4_MOD_TPBSWG, IF_REAL, "Temperature coefficient of pbswg"), -IOP( "tcjswg", BSIM4_MOD_TCJSWG, IF_REAL, "Temperature coefficient of cjswg"), -IOP( "acde", BSIM4_MOD_ACDE, IF_REAL, "Exponential coefficient for finite charge thickness"), -IOP( "moin", BSIM4_MOD_MOIN, IF_REAL, "Coefficient for gate-bias dependent surface potential"), -IOP( "noff", BSIM4_MOD_NOFF, IF_REAL, "C-V turn-on/off parameter"), -IOP( "voffcv", BSIM4_MOD_VOFFCV, IF_REAL, "C-V lateral-shift parameter"), -IOP( "dmcg", BSIM4_MOD_DMCG, IF_REAL, "Distance of Mid-Contact to Gate edge"), -IOP( "dmci", BSIM4_MOD_DMCI, IF_REAL, "Distance of Mid-Contact to Isolation"), -IOP( "dmdg", BSIM4_MOD_DMDG, IF_REAL, "Distance of Mid-Diffusion to Gate edge"), -IOP( "dmcgt", BSIM4_MOD_DMCGT, IF_REAL, "Distance of Mid-Contact to Gate edge in Test structures"), -IOP( "xgw", BSIM4_MOD_XGW, IF_REAL, "Distance from gate contact center to device edge"), -IOP( "xgl", BSIM4_MOD_XGL, IF_REAL, "Variation in Ldrawn"), -IOP( "rshg", BSIM4_MOD_RSHG, IF_REAL, "Gate sheet resistance"), -IOP( "ngcon", BSIM4_MOD_NGCON, IF_REAL, "Number of gate contacts"), -IOP( "xrcrg1", BSIM4_MOD_XRCRG1, IF_REAL, "First fitting parameter the bias-dependent Rg"), -IOP( "xrcrg2", BSIM4_MOD_XRCRG2, IF_REAL, "Second fitting parameter the bias-dependent Rg"), -IOP( "lambda", BSIM4_MOD_LAMBDA, IF_REAL, " Velocity overshoot parameter"), -IOP( "vtl", BSIM4_MOD_VTL, IF_REAL, " thermal velocity"), -IOP( "lc", BSIM4_MOD_LC, IF_REAL, " back scattering parameter"), -IOP( "xn", BSIM4_MOD_XN, IF_REAL, " back scattering parameter"), -IOP( "vfbsdoff", BSIM4_MOD_VFBSDOFF, IF_REAL, "S/D flatband voltage offset"), -IOP( "tvfbsdoff", BSIM4_MOD_TVFBSDOFF, IF_REAL, "Temperature parameter for vfbsdoff"), -IOP( "tvoff", BSIM4_MOD_TVOFF, IF_REAL, "Temperature parameter for voff"), -IOP( "tnfactor", BSIM4_MOD_TNFACTOR, IF_REAL, "Temperature parameter for nfactor"), /* v4.7 Tanvir*/ -IOP( "teta0", BSIM4_MOD_TETA0, IF_REAL, "Temperature parameter for eta0"), /* v4.7 Tanvir*/ -IOP( "tvoffcv", BSIM4_MOD_TVOFFCV, IF_REAL, "Temperature parameter for tvoffcv"), /* v4.7 Tanvir*/ +IOP( "vfbcv", BSIM4v7_MOD_VFBCV, IF_REAL, "Flat Band Voltage parameter for capmod=0 only"), +IOP( "vfb", BSIM4v7_MOD_VFB, IF_REAL, "Flat Band Voltage"), +IOP( "tpb", BSIM4v7_MOD_TPB, IF_REAL, "Temperature coefficient of pb"), +IOP( "tcj", BSIM4v7_MOD_TCJ, IF_REAL, "Temperature coefficient of cj"), +IOP( "tpbsw", BSIM4v7_MOD_TPBSW, IF_REAL, "Temperature coefficient of pbsw"), +IOP( "tcjsw", BSIM4v7_MOD_TCJSW, IF_REAL, "Temperature coefficient of cjsw"), +IOP( "tpbswg", BSIM4v7_MOD_TPBSWG, IF_REAL, "Temperature coefficient of pbswg"), +IOP( "tcjswg", BSIM4v7_MOD_TCJSWG, IF_REAL, "Temperature coefficient of cjswg"), +IOP( "acde", BSIM4v7_MOD_ACDE, IF_REAL, "Exponential coefficient for finite charge thickness"), +IOP( "moin", BSIM4v7_MOD_MOIN, IF_REAL, "Coefficient for gate-bias dependent surface potential"), +IOP( "noff", BSIM4v7_MOD_NOFF, IF_REAL, "C-V turn-on/off parameter"), +IOP( "voffcv", BSIM4v7_MOD_VOFFCV, IF_REAL, "C-V lateral-shift parameter"), +IOP( "dmcg", BSIM4v7_MOD_DMCG, IF_REAL, "Distance of Mid-Contact to Gate edge"), +IOP( "dmci", BSIM4v7_MOD_DMCI, IF_REAL, "Distance of Mid-Contact to Isolation"), +IOP( "dmdg", BSIM4v7_MOD_DMDG, IF_REAL, "Distance of Mid-Diffusion to Gate edge"), +IOP( "dmcgt", BSIM4v7_MOD_DMCGT, IF_REAL, "Distance of Mid-Contact to Gate edge in Test structures"), +IOP( "xgw", BSIM4v7_MOD_XGW, IF_REAL, "Distance from gate contact center to device edge"), +IOP( "xgl", BSIM4v7_MOD_XGL, IF_REAL, "Variation in Ldrawn"), +IOP( "rshg", BSIM4v7_MOD_RSHG, IF_REAL, "Gate sheet resistance"), +IOP( "ngcon", BSIM4v7_MOD_NGCON, IF_REAL, "Number of gate contacts"), +IOP( "xrcrg1", BSIM4v7_MOD_XRCRG1, IF_REAL, "First fitting parameter the bias-dependent Rg"), +IOP( "xrcrg2", BSIM4v7_MOD_XRCRG2, IF_REAL, "Second fitting parameter the bias-dependent Rg"), +IOP( "lambda", BSIM4v7_MOD_LAMBDA, IF_REAL, " Velocity overshoot parameter"), +IOP( "vtl", BSIM4v7_MOD_VTL, IF_REAL, " thermal velocity"), +IOP( "lc", BSIM4v7_MOD_LC, IF_REAL, " back scattering parameter"), +IOP( "xn", BSIM4v7_MOD_XN, IF_REAL, " back scattering parameter"), +IOP( "vfbsdoff", BSIM4v7_MOD_VFBSDOFF, IF_REAL, "S/D flatband voltage offset"), +IOP( "tvfbsdoff", BSIM4v7_MOD_TVFBSDOFF, IF_REAL, "Temperature parameter for vfbsdoff"), +IOP( "tvoff", BSIM4v7_MOD_TVOFF, IF_REAL, "Temperature parameter for voff"), +IOP( "tnfactor", BSIM4v7_MOD_TNFACTOR, IF_REAL, "Temperature parameter for nfactor"), /* v4.7 Tanvir*/ +IOP( "teta0", BSIM4v7_MOD_TETA0, IF_REAL, "Temperature parameter for eta0"), /* v4.7 Tanvir*/ +IOP( "tvoffcv", BSIM4v7_MOD_TVOFFCV, IF_REAL, "Temperature parameter for tvoffcv"), /* v4.7 Tanvir*/ -IOP( "lintnoi", BSIM4_MOD_LINTNOI, IF_REAL, "lint offset for noise calculation"), -IOP( "lint", BSIM4_MOD_LINT, IF_REAL, "Length reduction parameter"), -IOP( "ll", BSIM4_MOD_LL, IF_REAL, "Length reduction parameter"), -IOP( "llc", BSIM4_MOD_LLC, IF_REAL, "Length reduction parameter for CV"), -IOP( "lln", BSIM4_MOD_LLN, IF_REAL, "Length reduction parameter"), -IOP( "lw", BSIM4_MOD_LW, IF_REAL, "Length reduction parameter"), -IOP( "lwc", BSIM4_MOD_LWC, IF_REAL, "Length reduction parameter for CV"), -IOP( "lwn", BSIM4_MOD_LWN, IF_REAL, "Length reduction parameter"), -IOP( "lwl", BSIM4_MOD_LWL, IF_REAL, "Length reduction parameter"), -IOP( "lwlc", BSIM4_MOD_LWLC, IF_REAL, "Length reduction parameter for CV"), -IOP( "lmin", BSIM4_MOD_LMIN, IF_REAL, "Minimum length for the model"), -IOP( "lmax", BSIM4_MOD_LMAX, IF_REAL, "Maximum length for the model"), +IOP( "lintnoi", BSIM4v7_MOD_LINTNOI, IF_REAL, "lint offset for noise calculation"), +IOP( "lint", BSIM4v7_MOD_LINT, IF_REAL, "Length reduction parameter"), +IOP( "ll", BSIM4v7_MOD_LL, IF_REAL, "Length reduction parameter"), +IOP( "llc", BSIM4v7_MOD_LLC, IF_REAL, "Length reduction parameter for CV"), +IOP( "lln", BSIM4v7_MOD_LLN, IF_REAL, "Length reduction parameter"), +IOP( "lw", BSIM4v7_MOD_LW, IF_REAL, "Length reduction parameter"), +IOP( "lwc", BSIM4v7_MOD_LWC, IF_REAL, "Length reduction parameter for CV"), +IOP( "lwn", BSIM4v7_MOD_LWN, IF_REAL, "Length reduction parameter"), +IOP( "lwl", BSIM4v7_MOD_LWL, IF_REAL, "Length reduction parameter"), +IOP( "lwlc", BSIM4v7_MOD_LWLC, IF_REAL, "Length reduction parameter for CV"), +IOP( "lmin", BSIM4v7_MOD_LMIN, IF_REAL, "Minimum length for the model"), +IOP( "lmax", BSIM4v7_MOD_LMAX, IF_REAL, "Maximum length for the model"), -IOP( "wr", BSIM4_MOD_WR, IF_REAL, "Width dependence of rds"), -IOP( "wint", BSIM4_MOD_WINT, IF_REAL, "Width reduction parameter"), -IOP( "dwg", BSIM4_MOD_DWG, IF_REAL, "Width reduction parameter"), -IOP( "dwb", BSIM4_MOD_DWB, IF_REAL, "Width reduction parameter"), +IOP( "wr", BSIM4v7_MOD_WR, IF_REAL, "Width dependence of rds"), +IOP( "wint", BSIM4v7_MOD_WINT, IF_REAL, "Width reduction parameter"), +IOP( "dwg", BSIM4v7_MOD_DWG, IF_REAL, "Width reduction parameter"), +IOP( "dwb", BSIM4v7_MOD_DWB, IF_REAL, "Width reduction parameter"), -IOP( "wl", BSIM4_MOD_WL, IF_REAL, "Width reduction parameter"), -IOP( "wlc", BSIM4_MOD_WLC, IF_REAL, "Width reduction parameter for CV"), -IOP( "wln", BSIM4_MOD_WLN, IF_REAL, "Width reduction parameter"), -IOP( "ww", BSIM4_MOD_WW, IF_REAL, "Width reduction parameter"), -IOP( "wwc", BSIM4_MOD_WWC, IF_REAL, "Width reduction parameter for CV"), -IOP( "wwn", BSIM4_MOD_WWN, IF_REAL, "Width reduction parameter"), -IOP( "wwl", BSIM4_MOD_WWL, IF_REAL, "Width reduction parameter"), -IOP( "wwlc", BSIM4_MOD_WWLC, IF_REAL, "Width reduction parameter for CV"), -IOP( "wmin", BSIM4_MOD_WMIN, IF_REAL, "Minimum width for the model"), -IOP( "wmax", BSIM4_MOD_WMAX, IF_REAL, "Maximum width for the model"), +IOP( "wl", BSIM4v7_MOD_WL, IF_REAL, "Width reduction parameter"), +IOP( "wlc", BSIM4v7_MOD_WLC, IF_REAL, "Width reduction parameter for CV"), +IOP( "wln", BSIM4v7_MOD_WLN, IF_REAL, "Width reduction parameter"), +IOP( "ww", BSIM4v7_MOD_WW, IF_REAL, "Width reduction parameter"), +IOP( "wwc", BSIM4v7_MOD_WWC, IF_REAL, "Width reduction parameter for CV"), +IOP( "wwn", BSIM4v7_MOD_WWN, IF_REAL, "Width reduction parameter"), +IOP( "wwl", BSIM4v7_MOD_WWL, IF_REAL, "Width reduction parameter"), +IOP( "wwlc", BSIM4v7_MOD_WWLC, IF_REAL, "Width reduction parameter for CV"), +IOP( "wmin", BSIM4v7_MOD_WMIN, IF_REAL, "Minimum width for the model"), +IOP( "wmax", BSIM4v7_MOD_WMAX, IF_REAL, "Maximum width for the model"), -IOP( "b0", BSIM4_MOD_B0, IF_REAL, "Abulk narrow width parameter"), -IOP( "b1", BSIM4_MOD_B1, IF_REAL, "Abulk narrow width parameter"), +IOP( "b0", BSIM4v7_MOD_B0, IF_REAL, "Abulk narrow width parameter"), +IOP( "b1", BSIM4v7_MOD_B1, IF_REAL, "Abulk narrow width parameter"), -IOP( "cgsl", BSIM4_MOD_CGSL, IF_REAL, "New C-V model parameter"), -IOP( "cgdl", BSIM4_MOD_CGDL, IF_REAL, "New C-V model parameter"), -IOP( "ckappas", BSIM4_MOD_CKAPPAS, IF_REAL, "S/G overlap C-V parameter "), -IOP( "ckappad", BSIM4_MOD_CKAPPAD, IF_REAL, "D/G overlap C-V parameter"), -IOP( "cf", BSIM4_MOD_CF, IF_REAL, "Fringe capacitance parameter"), -IOP( "clc", BSIM4_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"), -IOP( "cle", BSIM4_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"), -IOP( "dwc", BSIM4_MOD_DWC, IF_REAL, "Delta W for C-V model"), -IOP( "dlc", BSIM4_MOD_DLC, IF_REAL, "Delta L for C-V model"), -IOP( "xw", BSIM4_MOD_XW, IF_REAL, "W offset for channel width due to mask/etch effect"), -IOP( "xl", BSIM4_MOD_XL, IF_REAL, "L offset for channel length due to mask/etch effect"), -IOP( "dlcig", BSIM4_MOD_DLCIG, IF_REAL, "Delta L for Ig model"), -IOP( "dlcigd", BSIM4_MOD_DLCIGD, IF_REAL, "Delta L for Ig model drain side"), -IOP( "dwj", BSIM4_MOD_DWJ, IF_REAL, "Delta W for S/D junctions"), +IOP( "cgsl", BSIM4v7_MOD_CGSL, IF_REAL, "New C-V model parameter"), +IOP( "cgdl", BSIM4v7_MOD_CGDL, IF_REAL, "New C-V model parameter"), +IOP( "ckappas", BSIM4v7_MOD_CKAPPAS, IF_REAL, "S/G overlap C-V parameter "), +IOP( "ckappad", BSIM4v7_MOD_CKAPPAD, IF_REAL, "D/G overlap C-V parameter"), +IOP( "cf", BSIM4v7_MOD_CF, IF_REAL, "Fringe capacitance parameter"), +IOP( "clc", BSIM4v7_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"), +IOP( "cle", BSIM4v7_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"), +IOP( "dwc", BSIM4v7_MOD_DWC, IF_REAL, "Delta W for C-V model"), +IOP( "dlc", BSIM4v7_MOD_DLC, IF_REAL, "Delta L for C-V model"), +IOP( "xw", BSIM4v7_MOD_XW, IF_REAL, "W offset for channel width due to mask/etch effect"), +IOP( "xl", BSIM4v7_MOD_XL, IF_REAL, "L offset for channel length due to mask/etch effect"), +IOP( "dlcig", BSIM4v7_MOD_DLCIG, IF_REAL, "Delta L for Ig model"), +IOP( "dlcigd", BSIM4v7_MOD_DLCIGD, IF_REAL, "Delta L for Ig model drain side"), +IOP( "dwj", BSIM4v7_MOD_DWJ, IF_REAL, "Delta W for S/D junctions"), -IOP( "alpha0", BSIM4_MOD_ALPHA0, IF_REAL, "substrate current model parameter"), -IOP( "alpha1", BSIM4_MOD_ALPHA1, IF_REAL, "substrate current model parameter"), -IOP( "beta0", BSIM4_MOD_BETA0, IF_REAL, "substrate current model parameter"), +IOP( "alpha0", BSIM4v7_MOD_ALPHA0, IF_REAL, "substrate current model parameter"), +IOP( "alpha1", BSIM4v7_MOD_ALPHA1, IF_REAL, "substrate current model parameter"), +IOP( "beta0", BSIM4v7_MOD_BETA0, IF_REAL, "substrate current model parameter"), -IOP( "agidl", BSIM4_MOD_AGIDL, IF_REAL, "Pre-exponential constant for GIDL"), -IOP( "bgidl", BSIM4_MOD_BGIDL, IF_REAL, "Exponential constant for GIDL"), -IOP( "cgidl", BSIM4_MOD_CGIDL, IF_REAL, "Parameter for body-bias dependence of GIDL"), -IOP( "rgidl", BSIM4_MOD_RGIDL, IF_REAL, "GIDL vg parameter"), /* v4.7 New GIDL/GISL */ -IOP( "kgidl", BSIM4_MOD_KGIDL, IF_REAL, "GIDL vb parameter"), /* v4.7 New GIDL/GISL */ -IOP( "fgidl", BSIM4_MOD_FGIDL, IF_REAL, "GIDL vb parameter"), /* v4.7 New GIDL/GISL */ -IOP( "egidl", BSIM4_MOD_EGIDL, IF_REAL, "Fitting parameter for Bandbending"), -IOP( "agisl", BSIM4_MOD_AGISL, IF_REAL, "Pre-exponential constant for GISL"), -IOP( "bgisl", BSIM4_MOD_BGISL, IF_REAL, "Exponential constant for GISL"), -IOP( "cgisl", BSIM4_MOD_CGISL, IF_REAL, "Parameter for body-bias dependence of GISL"), -IOP( "rgisl", BSIM4_MOD_RGISL, IF_REAL, "GISL vg parameter"), /* v4.7 New GIDL/GISL */ -IOP( "kgisl", BSIM4_MOD_KGISL, IF_REAL, "GISL vb parameter"), /* v4.7 New GIDL/GISL */ -IOP( "fgisl", BSIM4_MOD_FGISL, IF_REAL, "GISL vb parameter"), /* v4.7 New GIDL/GISL */ -IOP( "egisl", BSIM4_MOD_EGISL, IF_REAL, "Fitting parameter for Bandbending"), -IOP( "aigc", BSIM4_MOD_AIGC, IF_REAL, "Parameter for Igc"), -IOP( "bigc", BSIM4_MOD_BIGC, IF_REAL, "Parameter for Igc"), -IOP( "cigc", BSIM4_MOD_CIGC, IF_REAL, "Parameter for Igc"), -IOP( "aigsd", BSIM4_MOD_AIGSD, IF_REAL, "Parameter for Igs,d"), -IOP( "bigsd", BSIM4_MOD_BIGSD, IF_REAL, "Parameter for Igs,d"), -IOP( "cigsd", BSIM4_MOD_CIGSD, IF_REAL, "Parameter for Igs,d"), -IOP( "aigs", BSIM4_MOD_AIGS, IF_REAL, "Parameter for Igs"), -IOP( "bigs", BSIM4_MOD_BIGS, IF_REAL, "Parameter for Igs"), -IOP( "cigs", BSIM4_MOD_CIGS, IF_REAL, "Parameter for Igs"), -IOP( "aigd", BSIM4_MOD_AIGD, IF_REAL, "Parameter for Igd"), -IOP( "bigd", BSIM4_MOD_BIGD, IF_REAL, "Parameter for Igd"), -IOP( "cigd", BSIM4_MOD_CIGD, IF_REAL, "Parameter for Igd"), -IOP( "aigbacc", BSIM4_MOD_AIGBACC, IF_REAL, "Parameter for Igb"), -IOP( "bigbacc", BSIM4_MOD_BIGBACC, IF_REAL, "Parameter for Igb"), -IOP( "cigbacc", BSIM4_MOD_CIGBACC, IF_REAL, "Parameter for Igb"), -IOP( "aigbinv", BSIM4_MOD_AIGBINV, IF_REAL, "Parameter for Igb"), -IOP( "bigbinv", BSIM4_MOD_BIGBINV, IF_REAL, "Parameter for Igb"), -IOP( "cigbinv", BSIM4_MOD_CIGBINV, IF_REAL, "Parameter for Igb"), -IOP( "nigc", BSIM4_MOD_NIGC, IF_REAL, "Parameter for Igc slope"), -IOP( "nigbinv", BSIM4_MOD_NIGBINV, IF_REAL, "Parameter for Igbinv slope"), -IOP( "nigbacc", BSIM4_MOD_NIGBACC, IF_REAL, "Parameter for Igbacc slope"), -IOP( "ntox", BSIM4_MOD_NTOX, IF_REAL, "Exponent for Tox ratio"), -IOP( "eigbinv", BSIM4_MOD_EIGBINV, IF_REAL, "Parameter for the Si bandgap for Igbinv"), -IOP( "pigcd", BSIM4_MOD_PIGCD, IF_REAL, "Parameter for Igc partition"), -IOP( "poxedge", BSIM4_MOD_POXEDGE, IF_REAL, "Factor for the gate edge Tox"), +IOP( "agidl", BSIM4v7_MOD_AGIDL, IF_REAL, "Pre-exponential constant for GIDL"), +IOP( "bgidl", BSIM4v7_MOD_BGIDL, IF_REAL, "Exponential constant for GIDL"), +IOP( "cgidl", BSIM4v7_MOD_CGIDL, IF_REAL, "Parameter for body-bias dependence of GIDL"), +IOP( "rgidl", BSIM4v7_MOD_RGIDL, IF_REAL, "GIDL vg parameter"), /* v4.7 New GIDL/GISL */ +IOP( "kgidl", BSIM4v7_MOD_KGIDL, IF_REAL, "GIDL vb parameter"), /* v4.7 New GIDL/GISL */ +IOP( "fgidl", BSIM4v7_MOD_FGIDL, IF_REAL, "GIDL vb parameter"), /* v4.7 New GIDL/GISL */ +IOP( "egidl", BSIM4v7_MOD_EGIDL, IF_REAL, "Fitting parameter for Bandbending"), +IOP( "agisl", BSIM4v7_MOD_AGISL, IF_REAL, "Pre-exponential constant for GISL"), +IOP( "bgisl", BSIM4v7_MOD_BGISL, IF_REAL, "Exponential constant for GISL"), +IOP( "cgisl", BSIM4v7_MOD_CGISL, IF_REAL, "Parameter for body-bias dependence of GISL"), +IOP( "rgisl", BSIM4v7_MOD_RGISL, IF_REAL, "GISL vg parameter"), /* v4.7 New GIDL/GISL */ +IOP( "kgisl", BSIM4v7_MOD_KGISL, IF_REAL, "GISL vb parameter"), /* v4.7 New GIDL/GISL */ +IOP( "fgisl", BSIM4v7_MOD_FGISL, IF_REAL, "GISL vb parameter"), /* v4.7 New GIDL/GISL */ +IOP( "egisl", BSIM4v7_MOD_EGISL, IF_REAL, "Fitting parameter for Bandbending"), +IOP( "aigc", BSIM4v7_MOD_AIGC, IF_REAL, "Parameter for Igc"), +IOP( "bigc", BSIM4v7_MOD_BIGC, IF_REAL, "Parameter for Igc"), +IOP( "cigc", BSIM4v7_MOD_CIGC, IF_REAL, "Parameter for Igc"), +IOP( "aigsd", BSIM4v7_MOD_AIGSD, IF_REAL, "Parameter for Igs,d"), +IOP( "bigsd", BSIM4v7_MOD_BIGSD, IF_REAL, "Parameter for Igs,d"), +IOP( "cigsd", BSIM4v7_MOD_CIGSD, IF_REAL, "Parameter for Igs,d"), +IOP( "aigs", BSIM4v7_MOD_AIGS, IF_REAL, "Parameter for Igs"), +IOP( "bigs", BSIM4v7_MOD_BIGS, IF_REAL, "Parameter for Igs"), +IOP( "cigs", BSIM4v7_MOD_CIGS, IF_REAL, "Parameter for Igs"), +IOP( "aigd", BSIM4v7_MOD_AIGD, IF_REAL, "Parameter for Igd"), +IOP( "bigd", BSIM4v7_MOD_BIGD, IF_REAL, "Parameter for Igd"), +IOP( "cigd", BSIM4v7_MOD_CIGD, IF_REAL, "Parameter for Igd"), +IOP( "aigbacc", BSIM4v7_MOD_AIGBACC, IF_REAL, "Parameter for Igb"), +IOP( "bigbacc", BSIM4v7_MOD_BIGBACC, IF_REAL, "Parameter for Igb"), +IOP( "cigbacc", BSIM4v7_MOD_CIGBACC, IF_REAL, "Parameter for Igb"), +IOP( "aigbinv", BSIM4v7_MOD_AIGBINV, IF_REAL, "Parameter for Igb"), +IOP( "bigbinv", BSIM4v7_MOD_BIGBINV, IF_REAL, "Parameter for Igb"), +IOP( "cigbinv", BSIM4v7_MOD_CIGBINV, IF_REAL, "Parameter for Igb"), +IOP( "nigc", BSIM4v7_MOD_NIGC, IF_REAL, "Parameter for Igc slope"), +IOP( "nigbinv", BSIM4v7_MOD_NIGBINV, IF_REAL, "Parameter for Igbinv slope"), +IOP( "nigbacc", BSIM4v7_MOD_NIGBACC, IF_REAL, "Parameter for Igbacc slope"), +IOP( "ntox", BSIM4v7_MOD_NTOX, IF_REAL, "Exponent for Tox ratio"), +IOP( "eigbinv", BSIM4v7_MOD_EIGBINV, IF_REAL, "Parameter for the Si bandgap for Igbinv"), +IOP( "pigcd", BSIM4v7_MOD_PIGCD, IF_REAL, "Parameter for Igc partition"), +IOP( "poxedge", BSIM4v7_MOD_POXEDGE, IF_REAL, "Factor for the gate edge Tox"), -IOP( "ijthdfwd", BSIM4_MOD_IJTHDFWD, IF_REAL, "Forward drain diode forward limiting current"), -IOP( "ijthsfwd", BSIM4_MOD_IJTHSFWD, IF_REAL, "Forward source diode forward limiting current"), -IOP( "ijthdrev", BSIM4_MOD_IJTHDREV, IF_REAL, "Reverse drain diode forward limiting current"), -IOP( "ijthsrev", BSIM4_MOD_IJTHSREV, IF_REAL, "Reverse source diode forward limiting current"), -IOP( "xjbvd", BSIM4_MOD_XJBVD, IF_REAL, "Fitting parameter for drain diode breakdown current"), -IOP( "xjbvs", BSIM4_MOD_XJBVS, IF_REAL, "Fitting parameter for source diode breakdown current"), -IOP( "bvd", BSIM4_MOD_BVD, IF_REAL, "Drain diode breakdown voltage"), -IOP( "bvs", BSIM4_MOD_BVS, IF_REAL, "Source diode breakdown voltage"), +IOP( "ijthdfwd", BSIM4v7_MOD_IJTHDFWD, IF_REAL, "Forward drain diode forward limiting current"), +IOP( "ijthsfwd", BSIM4v7_MOD_IJTHSFWD, IF_REAL, "Forward source diode forward limiting current"), +IOP( "ijthdrev", BSIM4v7_MOD_IJTHDREV, IF_REAL, "Reverse drain diode forward limiting current"), +IOP( "ijthsrev", BSIM4v7_MOD_IJTHSREV, IF_REAL, "Reverse source diode forward limiting current"), +IOP( "xjbvd", BSIM4v7_MOD_XJBVD, IF_REAL, "Fitting parameter for drain diode breakdown current"), +IOP( "xjbvs", BSIM4v7_MOD_XJBVS, IF_REAL, "Fitting parameter for source diode breakdown current"), +IOP( "bvd", BSIM4v7_MOD_BVD, IF_REAL, "Drain diode breakdown voltage"), +IOP( "bvs", BSIM4v7_MOD_BVS, IF_REAL, "Source diode breakdown voltage"), -IOP( "jtss", BSIM4_MOD_JTSS, IF_REAL, "Source bottom trap-assisted saturation current density"), -IOP( "jtsd", BSIM4_MOD_JTSD, IF_REAL, "Drain bottom trap-assisted saturation current density"), -IOP( "jtssws", BSIM4_MOD_JTSSWS, IF_REAL, "Source STI sidewall trap-assisted saturation current density"), -IOP( "jtsswd", BSIM4_MOD_JTSSWD, IF_REAL, "Drain STI sidewall trap-assisted saturation current density"), -IOP( "jtsswgs", BSIM4_MOD_JTSSWGS, IF_REAL, "Source gate-edge sidewall trap-assisted saturation current density"), -IOP( "jtsswgd", BSIM4_MOD_JTSSWGD, IF_REAL, "Drain gate-edge sidewall trap-assisted saturation current density"), -IOP( "jtweff", BSIM4_MOD_JTWEFF, IF_REAL, "TAT current width dependance"), -IOP( "njts", BSIM4_MOD_NJTS, IF_REAL, "Non-ideality factor for bottom junction"), -IOP( "njtssw", BSIM4_MOD_NJTSSW, IF_REAL, "Non-ideality factor for STI sidewall junction"), -IOP( "njtsswg", BSIM4_MOD_NJTSSWG, IF_REAL, "Non-ideality factor for gate-edge sidewall junction"), -IOP( "njtsd", BSIM4_MOD_NJTSD, IF_REAL, "Non-ideality factor for bottom junction drain side"), -IOP( "njtsswd", BSIM4_MOD_NJTSSWD, IF_REAL, "Non-ideality factor for STI sidewall junction drain side"), -IOP( "njtsswgd", BSIM4_MOD_NJTSSWGD, IF_REAL, "Non-ideality factor for gate-edge sidewall junction drain side"), -IOP( "xtss", BSIM4_MOD_XTSS, IF_REAL, "Power dependence of JTSS on temperature"), -IOP( "xtsd", BSIM4_MOD_XTSD, IF_REAL, "Power dependence of JTSD on temperature"), -IOP( "xtssws", BSIM4_MOD_XTSSWS, IF_REAL, "Power dependence of JTSSWS on temperature"), -IOP( "xtsswd", BSIM4_MOD_XTSSWD, IF_REAL, "Power dependence of JTSSWD on temperature"), -IOP( "xtsswgs", BSIM4_MOD_XTSSWGS, IF_REAL, "Power dependence of JTSSWGS on temperature"), -IOP( "xtsswgd", BSIM4_MOD_XTSSWGD, IF_REAL, "Power dependence of JTSSWGD on temperature"), -IOP( "tnjts", BSIM4_MOD_TNJTS, IF_REAL, "Temperature coefficient for NJTS"), -IOP( "tnjtssw", BSIM4_MOD_TNJTSSW, IF_REAL, "Temperature coefficient for NJTSSW"), -IOP( "tnjtsswg", BSIM4_MOD_TNJTSSWG, IF_REAL, "Temperature coefficient for NJTSSWG"), -IOP( "tnjtsd", BSIM4_MOD_TNJTSD, IF_REAL, "Temperature coefficient for NJTSD"), -IOP( "tnjtsswd", BSIM4_MOD_TNJTSSWD, IF_REAL, "Temperature coefficient for NJTSSWD"), -IOP( "tnjtsswgd", BSIM4_MOD_TNJTSSWGD, IF_REAL, "Temperature coefficient for NJTSSWGD"), -IOP( "vtss", BSIM4_MOD_VTSS, IF_REAL, "Source bottom trap-assisted voltage dependent parameter"), -IOP( "vtsd", BSIM4_MOD_VTSD, IF_REAL, "Drain bottom trap-assisted voltage dependent parameter"), -IOP( "vtssws", BSIM4_MOD_VTSSWS, IF_REAL, "Source STI sidewall trap-assisted voltage dependent parameter"), -IOP( "vtsswd", BSIM4_MOD_VTSSWD, IF_REAL, "Drain STI sidewall trap-assisted voltage dependent parameter"), -IOP( "vtsswgs", BSIM4_MOD_VTSSWGS, IF_REAL, "Source gate-edge sidewall trap-assisted voltage dependent parameter"), -IOP( "vtsswgd", BSIM4_MOD_VTSSWGD, IF_REAL, "Drain gate-edge sidewall trap-assisted voltage dependent parameter"), +IOP( "jtss", BSIM4v7_MOD_JTSS, IF_REAL, "Source bottom trap-assisted saturation current density"), +IOP( "jtsd", BSIM4v7_MOD_JTSD, IF_REAL, "Drain bottom trap-assisted saturation current density"), +IOP( "jtssws", BSIM4v7_MOD_JTSSWS, IF_REAL, "Source STI sidewall trap-assisted saturation current density"), +IOP( "jtsswd", BSIM4v7_MOD_JTSSWD, IF_REAL, "Drain STI sidewall trap-assisted saturation current density"), +IOP( "jtsswgs", BSIM4v7_MOD_JTSSWGS, IF_REAL, "Source gate-edge sidewall trap-assisted saturation current density"), +IOP( "jtsswgd", BSIM4v7_MOD_JTSSWGD, IF_REAL, "Drain gate-edge sidewall trap-assisted saturation current density"), +IOP( "jtweff", BSIM4v7_MOD_JTWEFF, IF_REAL, "TAT current width dependance"), +IOP( "njts", BSIM4v7_MOD_NJTS, IF_REAL, "Non-ideality factor for bottom junction"), +IOP( "njtssw", BSIM4v7_MOD_NJTSSW, IF_REAL, "Non-ideality factor for STI sidewall junction"), +IOP( "njtsswg", BSIM4v7_MOD_NJTSSWG, IF_REAL, "Non-ideality factor for gate-edge sidewall junction"), +IOP( "njtsd", BSIM4v7_MOD_NJTSD, IF_REAL, "Non-ideality factor for bottom junction drain side"), +IOP( "njtsswd", BSIM4v7_MOD_NJTSSWD, IF_REAL, "Non-ideality factor for STI sidewall junction drain side"), +IOP( "njtsswgd", BSIM4v7_MOD_NJTSSWGD, IF_REAL, "Non-ideality factor for gate-edge sidewall junction drain side"), +IOP( "xtss", BSIM4v7_MOD_XTSS, IF_REAL, "Power dependence of JTSS on temperature"), +IOP( "xtsd", BSIM4v7_MOD_XTSD, IF_REAL, "Power dependence of JTSD on temperature"), +IOP( "xtssws", BSIM4v7_MOD_XTSSWS, IF_REAL, "Power dependence of JTSSWS on temperature"), +IOP( "xtsswd", BSIM4v7_MOD_XTSSWD, IF_REAL, "Power dependence of JTSSWD on temperature"), +IOP( "xtsswgs", BSIM4v7_MOD_XTSSWGS, IF_REAL, "Power dependence of JTSSWGS on temperature"), +IOP( "xtsswgd", BSIM4v7_MOD_XTSSWGD, IF_REAL, "Power dependence of JTSSWGD on temperature"), +IOP( "tnjts", BSIM4v7_MOD_TNJTS, IF_REAL, "Temperature coefficient for NJTS"), +IOP( "tnjtssw", BSIM4v7_MOD_TNJTSSW, IF_REAL, "Temperature coefficient for NJTSSW"), +IOP( "tnjtsswg", BSIM4v7_MOD_TNJTSSWG, IF_REAL, "Temperature coefficient for NJTSSWG"), +IOP( "tnjtsd", BSIM4v7_MOD_TNJTSD, IF_REAL, "Temperature coefficient for NJTSD"), +IOP( "tnjtsswd", BSIM4v7_MOD_TNJTSSWD, IF_REAL, "Temperature coefficient for NJTSSWD"), +IOP( "tnjtsswgd", BSIM4v7_MOD_TNJTSSWGD, IF_REAL, "Temperature coefficient for NJTSSWGD"), +IOP( "vtss", BSIM4v7_MOD_VTSS, IF_REAL, "Source bottom trap-assisted voltage dependent parameter"), +IOP( "vtsd", BSIM4v7_MOD_VTSD, IF_REAL, "Drain bottom trap-assisted voltage dependent parameter"), +IOP( "vtssws", BSIM4v7_MOD_VTSSWS, IF_REAL, "Source STI sidewall trap-assisted voltage dependent parameter"), +IOP( "vtsswd", BSIM4v7_MOD_VTSSWD, IF_REAL, "Drain STI sidewall trap-assisted voltage dependent parameter"), +IOP( "vtsswgs", BSIM4v7_MOD_VTSSWGS, IF_REAL, "Source gate-edge sidewall trap-assisted voltage dependent parameter"), +IOP( "vtsswgd", BSIM4v7_MOD_VTSSWGD, IF_REAL, "Drain gate-edge sidewall trap-assisted voltage dependent parameter"), -IOP( "gbmin", BSIM4_MOD_GBMIN, IF_REAL, "Minimum body conductance"), -IOP( "rbdb", BSIM4_MOD_RBDB, IF_REAL, "Resistance between bNode and dbNode"), -IOP( "rbpb", BSIM4_MOD_RBPB, IF_REAL, "Resistance between bNodePrime and bNode"), -IOP( "rbsb", BSIM4_MOD_RBSB, IF_REAL, "Resistance between bNode and sbNode"), -IOP( "rbps", BSIM4_MOD_RBPS, IF_REAL, "Resistance between bNodePrime and sbNode"), -IOP( "rbpd", BSIM4_MOD_RBPD, IF_REAL, "Resistance between bNodePrime and bNode"), +IOP( "gbmin", BSIM4v7_MOD_GBMIN, IF_REAL, "Minimum body conductance"), +IOP( "rbdb", BSIM4v7_MOD_RBDB, IF_REAL, "Resistance between bNode and dbNode"), +IOP( "rbpb", BSIM4v7_MOD_RBPB, IF_REAL, "Resistance between bNodePrime and bNode"), +IOP( "rbsb", BSIM4v7_MOD_RBSB, IF_REAL, "Resistance between bNode and sbNode"), +IOP( "rbps", BSIM4v7_MOD_RBPS, IF_REAL, "Resistance between bNodePrime and sbNode"), +IOP( "rbpd", BSIM4v7_MOD_RBPD, IF_REAL, "Resistance between bNodePrime and bNode"), -IOP( "rbps0", BSIM4_MOD_RBPS0, IF_REAL , "Body resistance RBPS scaling"), -IOP( "rbpsl", BSIM4_MOD_RBPSL, IF_REAL , "Body resistance RBPS L scaling"), -IOP( "rbpsw", BSIM4_MOD_RBPSW, IF_REAL , "Body resistance RBPS W scaling"), -IOP( "rbpsnf", BSIM4_MOD_RBPSNF, IF_REAL , "Body resistance RBPS NF scaling"), +IOP( "rbps0", BSIM4v7_MOD_RBPS0, IF_REAL , "Body resistance RBPS scaling"), +IOP( "rbpsl", BSIM4v7_MOD_RBPSL, IF_REAL , "Body resistance RBPS L scaling"), +IOP( "rbpsw", BSIM4v7_MOD_RBPSW, IF_REAL , "Body resistance RBPS W scaling"), +IOP( "rbpsnf", BSIM4v7_MOD_RBPSNF, IF_REAL , "Body resistance RBPS NF scaling"), -IOP( "rbpd0", BSIM4_MOD_RBPD0, IF_REAL , "Body resistance RBPD scaling"), -IOP( "rbpdl", BSIM4_MOD_RBPDL, IF_REAL , "Body resistance RBPD L scaling"), -IOP( "rbpdw", BSIM4_MOD_RBPDW, IF_REAL , "Body resistance RBPD W scaling"), -IOP( "rbpdnf", BSIM4_MOD_RBPDNF, IF_REAL , "Body resistance RBPD NF scaling"), +IOP( "rbpd0", BSIM4v7_MOD_RBPD0, IF_REAL , "Body resistance RBPD scaling"), +IOP( "rbpdl", BSIM4v7_MOD_RBPDL, IF_REAL , "Body resistance RBPD L scaling"), +IOP( "rbpdw", BSIM4v7_MOD_RBPDW, IF_REAL , "Body resistance RBPD W scaling"), +IOP( "rbpdnf", BSIM4v7_MOD_RBPDNF, IF_REAL , "Body resistance RBPD NF scaling"), -IOP( "rbpbx0", BSIM4_MOD_RBPBX0, IF_REAL , "Body resistance RBPBX scaling"), -IOP( "rbpbxl", BSIM4_MOD_RBPBXL, IF_REAL , "Body resistance RBPBX L scaling"), -IOP( "rbpbxw", BSIM4_MOD_RBPBXW, IF_REAL , "Body resistance RBPBX W scaling"), -IOP( "rbpbxnf", BSIM4_MOD_RBPBXNF, IF_REAL , "Body resistance RBPBX NF scaling"), -IOP( "rbpby0", BSIM4_MOD_RBPBY0, IF_REAL , "Body resistance RBPBY scaling"), -IOP( "rbpbyl", BSIM4_MOD_RBPBYL, IF_REAL , "Body resistance RBPBY L scaling"), -IOP( "rbpbyw", BSIM4_MOD_RBPBYW, IF_REAL , "Body resistance RBPBY W scaling"), -IOP( "rbpbynf", BSIM4_MOD_RBPBYNF, IF_REAL , "Body resistance RBPBY NF scaling"), +IOP( "rbpbx0", BSIM4v7_MOD_RBPBX0, IF_REAL , "Body resistance RBPBX scaling"), +IOP( "rbpbxl", BSIM4v7_MOD_RBPBXL, IF_REAL , "Body resistance RBPBX L scaling"), +IOP( "rbpbxw", BSIM4v7_MOD_RBPBXW, IF_REAL , "Body resistance RBPBX W scaling"), +IOP( "rbpbxnf", BSIM4v7_MOD_RBPBXNF, IF_REAL , "Body resistance RBPBX NF scaling"), +IOP( "rbpby0", BSIM4v7_MOD_RBPBY0, IF_REAL , "Body resistance RBPBY scaling"), +IOP( "rbpbyl", BSIM4v7_MOD_RBPBYL, IF_REAL , "Body resistance RBPBY L scaling"), +IOP( "rbpbyw", BSIM4v7_MOD_RBPBYW, IF_REAL , "Body resistance RBPBY W scaling"), +IOP( "rbpbynf", BSIM4v7_MOD_RBPBYNF, IF_REAL , "Body resistance RBPBY NF scaling"), -IOP( "rbsbx0", BSIM4_MOD_RBSBX0, IF_REAL , "Body resistance RBSBX scaling"), -IOP( "rbsby0", BSIM4_MOD_RBSBY0, IF_REAL , "Body resistance RBSBY scaling"), -IOP( "rbdbx0", BSIM4_MOD_RBDBX0, IF_REAL , "Body resistance RBDBX scaling"), -IOP( "rbdby0", BSIM4_MOD_RBDBY0, IF_REAL , "Body resistance RBDBY scaling"), +IOP( "rbsbx0", BSIM4v7_MOD_RBSBX0, IF_REAL , "Body resistance RBSBX scaling"), +IOP( "rbsby0", BSIM4v7_MOD_RBSBY0, IF_REAL , "Body resistance RBSBY scaling"), +IOP( "rbdbx0", BSIM4v7_MOD_RBDBX0, IF_REAL , "Body resistance RBDBX scaling"), +IOP( "rbdby0", BSIM4v7_MOD_RBDBY0, IF_REAL , "Body resistance RBDBY scaling"), -IOP( "rbsdbxl", BSIM4_MOD_RBSDBXL, IF_REAL , "Body resistance RBSDBX L scaling"), -IOP( "rbsdbxw", BSIM4_MOD_RBSDBXW, IF_REAL , "Body resistance RBSDBX W scaling"), -IOP( "rbsdbxnf", BSIM4_MOD_RBSDBXNF, IF_REAL , "Body resistance RBSDBX NF scaling"), -IOP( "rbsdbyl", BSIM4_MOD_RBSDBYL, IF_REAL , "Body resistance RBSDBY L scaling"), -IOP( "rbsdbyw", BSIM4_MOD_RBSDBYW, IF_REAL , "Body resistance RBSDBY W scaling"), -IOP( "rbsdbynf", BSIM4_MOD_RBSDBYNF, IF_REAL , "Body resistance RBSDBY NF scaling"), +IOP( "rbsdbxl", BSIM4v7_MOD_RBSDBXL, IF_REAL , "Body resistance RBSDBX L scaling"), +IOP( "rbsdbxw", BSIM4v7_MOD_RBSDBXW, IF_REAL , "Body resistance RBSDBX W scaling"), +IOP( "rbsdbxnf", BSIM4v7_MOD_RBSDBXNF, IF_REAL , "Body resistance RBSDBX NF scaling"), +IOP( "rbsdbyl", BSIM4v7_MOD_RBSDBYL, IF_REAL , "Body resistance RBSDBY L scaling"), +IOP( "rbsdbyw", BSIM4v7_MOD_RBSDBYW, IF_REAL , "Body resistance RBSDBY W scaling"), +IOP( "rbsdbynf", BSIM4v7_MOD_RBSDBYNF, IF_REAL , "Body resistance RBSDBY NF scaling"), -IOP( "lcdsc", BSIM4_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"), -IOP( "lcdscb", BSIM4_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"), -IOP( "lcdscd", BSIM4_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"), -IOP( "lcit", BSIM4_MOD_LCIT, IF_REAL, "Length dependence of cit"), -IOP( "lnfactor", BSIM4_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"), -IOP( "lxj", BSIM4_MOD_LXJ, IF_REAL, "Length dependence of xj"), -IOP( "lvsat", BSIM4_MOD_LVSAT, IF_REAL, "Length dependence of vsat"), -IOP( "lat", BSIM4_MOD_LAT, IF_REAL, "Length dependence of at"), -IOP( "la0", BSIM4_MOD_LA0, IF_REAL, "Length dependence of a0"), -IOP( "lags", BSIM4_MOD_LAGS, IF_REAL, "Length dependence of ags"), -IOP( "la1", BSIM4_MOD_LA1, IF_REAL, "Length dependence of a1"), -IOP( "la2", BSIM4_MOD_LA2, IF_REAL, "Length dependence of a2"), -IOP( "lketa", BSIM4_MOD_LKETA, IF_REAL, "Length dependence of keta"), -IOP( "lnsub", BSIM4_MOD_LNSUB, IF_REAL, "Length dependence of nsub"), -IOP( "lndep", BSIM4_MOD_LNDEP, IF_REAL, "Length dependence of ndep"), -IOP( "lnsd", BSIM4_MOD_LNSD, IF_REAL, "Length dependence of nsd"), -IOP( "lphin", BSIM4_MOD_LPHIN, IF_REAL, "Length dependence of phin"), -IOP( "lngate", BSIM4_MOD_LNGATE, IF_REAL, "Length dependence of ngate"), -IOP( "lgamma1", BSIM4_MOD_LGAMMA1, IF_REAL, "Length dependence of gamma1"), -IOP( "lgamma2", BSIM4_MOD_LGAMMA2, IF_REAL, "Length dependence of gamma2"), -IOP( "lvbx", BSIM4_MOD_LVBX, IF_REAL, "Length dependence of vbx"), -IOP( "lvbm", BSIM4_MOD_LVBM, IF_REAL, "Length dependence of vbm"), -IOP( "lxt", BSIM4_MOD_LXT, IF_REAL, "Length dependence of xt"), -IOP( "lk1", BSIM4_MOD_LK1, IF_REAL, "Length dependence of k1"), -IOP( "lkt1", BSIM4_MOD_LKT1, IF_REAL, "Length dependence of kt1"), -IOP( "lkt1l", BSIM4_MOD_LKT1L, IF_REAL, "Length dependence of kt1l"), -IOP( "lkt2", BSIM4_MOD_LKT2, IF_REAL, "Length dependence of kt2"), -IOP( "lk2", BSIM4_MOD_LK2, IF_REAL, "Length dependence of k2"), -IOP( "lk3", BSIM4_MOD_LK3, IF_REAL, "Length dependence of k3"), -IOP( "lk3b", BSIM4_MOD_LK3B, IF_REAL, "Length dependence of k3b"), -IOP( "lw0", BSIM4_MOD_LW0, IF_REAL, "Length dependence of w0"), -IOP( "ldvtp0", BSIM4_MOD_LDVTP0, IF_REAL, "Length dependence of dvtp0"), -IOP( "ldvtp1", BSIM4_MOD_LDVTP1, IF_REAL, "Length dependence of dvtp1"), -IOP( "ldvtp2", BSIM4_MOD_LDVTP2, IF_REAL, "Length dependence of dvtp2"), -IOP( "ldvtp3", BSIM4_MOD_LDVTP3, IF_REAL, "Length dependence of dvtp3"), -IOP( "ldvtp4", BSIM4_MOD_LDVTP4, IF_REAL, "Length dependence of dvtp4"), -IOP( "ldvtp5", BSIM4_MOD_LDVTP5, IF_REAL, "Length dependence of dvtp5"), -IOP( "llpe0", BSIM4_MOD_LLPE0, IF_REAL, "Length dependence of lpe0"), -IOP( "llpeb", BSIM4_MOD_LLPEB, IF_REAL, "Length dependence of lpeb"), -IOP( "ldvt0", BSIM4_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"), -IOP( "ldvt1", BSIM4_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"), -IOP( "ldvt2", BSIM4_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"), -IOP( "ldvt0w", BSIM4_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"), -IOP( "ldvt1w", BSIM4_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"), -IOP( "ldvt2w", BSIM4_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"), -IOP( "ldrout", BSIM4_MOD_LDROUT, IF_REAL, "Length dependence of drout"), -IOP( "ldsub", BSIM4_MOD_LDSUB, IF_REAL, "Length dependence of dsub"), -IOP( "lvth0", BSIM4_MOD_LVTH0, IF_REAL,"Length dependence of vto"), -IOP( "lvtho", BSIM4_MOD_LVTH0, IF_REAL,"Length dependence of vto"), -IOP( "lua", BSIM4_MOD_LUA, IF_REAL, "Length dependence of ua"), -IOP( "lua1", BSIM4_MOD_LUA1, IF_REAL, "Length dependence of ua1"), -IOP( "lub", BSIM4_MOD_LUB, IF_REAL, "Length dependence of ub"), -IOP( "lub1", BSIM4_MOD_LUB1, IF_REAL, "Length dependence of ub1"), -IOP( "luc", BSIM4_MOD_LUC, IF_REAL, "Length dependence of uc"), -IOP( "luc1", BSIM4_MOD_LUC1, IF_REAL, "Length dependence of uc1"), -IOP( "lud", BSIM4_MOD_LUD, IF_REAL, "Length dependence of ud"), -IOP( "lud1", BSIM4_MOD_LUD1, IF_REAL, "Length dependence of ud1"), -IOP( "lup", BSIM4_MOD_LUP, IF_REAL, "Length dependence of up"), -IOP( "llp", BSIM4_MOD_LLP, IF_REAL, "Length dependence of lp"), -IOP( "lu0", BSIM4_MOD_LU0, IF_REAL, "Length dependence of u0"), -IOP( "lute", BSIM4_MOD_LUTE, IF_REAL, "Length dependence of ute"), -IOP( "lucste", BSIM4_MOD_LUCSTE, IF_REAL, "Length dependence of ucste"), -IOP( "lvoff", BSIM4_MOD_LVOFF, IF_REAL, "Length dependence of voff"), -IOP( "lminv", BSIM4_MOD_LMINV, IF_REAL, "Length dependence of minv"), -IOP( "lminvcv", BSIM4_MOD_LMINVCV, IF_REAL, "Length dependence of minvcv"), -IOP( "ldelta", BSIM4_MOD_LDELTA, IF_REAL, "Length dependence of delta"), -IOP( "lrdsw", BSIM4_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "), -IOP( "lrsw", BSIM4_MOD_LRSW, IF_REAL, "Length dependence of rsw"), -IOP( "lrdw", BSIM4_MOD_LRDW, IF_REAL, "Length dependence of rdw"), +IOP( "lcdsc", BSIM4v7_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"), +IOP( "lcdscb", BSIM4v7_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"), +IOP( "lcdscd", BSIM4v7_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"), +IOP( "lcit", BSIM4v7_MOD_LCIT, IF_REAL, "Length dependence of cit"), +IOP( "lnfactor", BSIM4v7_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"), +IOP( "lxj", BSIM4v7_MOD_LXJ, IF_REAL, "Length dependence of xj"), +IOP( "lvsat", BSIM4v7_MOD_LVSAT, IF_REAL, "Length dependence of vsat"), +IOP( "lat", BSIM4v7_MOD_LAT, IF_REAL, "Length dependence of at"), +IOP( "la0", BSIM4v7_MOD_LA0, IF_REAL, "Length dependence of a0"), +IOP( "lags", BSIM4v7_MOD_LAGS, IF_REAL, "Length dependence of ags"), +IOP( "la1", BSIM4v7_MOD_LA1, IF_REAL, "Length dependence of a1"), +IOP( "la2", BSIM4v7_MOD_LA2, IF_REAL, "Length dependence of a2"), +IOP( "lketa", BSIM4v7_MOD_LKETA, IF_REAL, "Length dependence of keta"), +IOP( "lnsub", BSIM4v7_MOD_LNSUB, IF_REAL, "Length dependence of nsub"), +IOP( "lndep", BSIM4v7_MOD_LNDEP, IF_REAL, "Length dependence of ndep"), +IOP( "lnsd", BSIM4v7_MOD_LNSD, IF_REAL, "Length dependence of nsd"), +IOP( "lphin", BSIM4v7_MOD_LPHIN, IF_REAL, "Length dependence of phin"), +IOP( "lngate", BSIM4v7_MOD_LNGATE, IF_REAL, "Length dependence of ngate"), +IOP( "lgamma1", BSIM4v7_MOD_LGAMMA1, IF_REAL, "Length dependence of gamma1"), +IOP( "lgamma2", BSIM4v7_MOD_LGAMMA2, IF_REAL, "Length dependence of gamma2"), +IOP( "lvbx", BSIM4v7_MOD_LVBX, IF_REAL, "Length dependence of vbx"), +IOP( "lvbm", BSIM4v7_MOD_LVBM, IF_REAL, "Length dependence of vbm"), +IOP( "lxt", BSIM4v7_MOD_LXT, IF_REAL, "Length dependence of xt"), +IOP( "lk1", BSIM4v7_MOD_LK1, IF_REAL, "Length dependence of k1"), +IOP( "lkt1", BSIM4v7_MOD_LKT1, IF_REAL, "Length dependence of kt1"), +IOP( "lkt1l", BSIM4v7_MOD_LKT1L, IF_REAL, "Length dependence of kt1l"), +IOP( "lkt2", BSIM4v7_MOD_LKT2, IF_REAL, "Length dependence of kt2"), +IOP( "lk2", BSIM4v7_MOD_LK2, IF_REAL, "Length dependence of k2"), +IOP( "lk3", BSIM4v7_MOD_LK3, IF_REAL, "Length dependence of k3"), +IOP( "lk3b", BSIM4v7_MOD_LK3B, IF_REAL, "Length dependence of k3b"), +IOP( "lw0", BSIM4v7_MOD_LW0, IF_REAL, "Length dependence of w0"), +IOP( "ldvtp0", BSIM4v7_MOD_LDVTP0, IF_REAL, "Length dependence of dvtp0"), +IOP( "ldvtp1", BSIM4v7_MOD_LDVTP1, IF_REAL, "Length dependence of dvtp1"), +IOP( "ldvtp2", BSIM4v7_MOD_LDVTP2, IF_REAL, "Length dependence of dvtp2"), +IOP( "ldvtp3", BSIM4v7_MOD_LDVTP3, IF_REAL, "Length dependence of dvtp3"), +IOP( "ldvtp4", BSIM4v7_MOD_LDVTP4, IF_REAL, "Length dependence of dvtp4"), +IOP( "ldvtp5", BSIM4v7_MOD_LDVTP5, IF_REAL, "Length dependence of dvtp5"), +IOP( "llpe0", BSIM4v7_MOD_LLPE0, IF_REAL, "Length dependence of lpe0"), +IOP( "llpeb", BSIM4v7_MOD_LLPEB, IF_REAL, "Length dependence of lpeb"), +IOP( "ldvt0", BSIM4v7_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"), +IOP( "ldvt1", BSIM4v7_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"), +IOP( "ldvt2", BSIM4v7_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"), +IOP( "ldvt0w", BSIM4v7_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"), +IOP( "ldvt1w", BSIM4v7_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"), +IOP( "ldvt2w", BSIM4v7_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"), +IOP( "ldrout", BSIM4v7_MOD_LDROUT, IF_REAL, "Length dependence of drout"), +IOP( "ldsub", BSIM4v7_MOD_LDSUB, IF_REAL, "Length dependence of dsub"), +IOP( "lvth0", BSIM4v7_MOD_LVTH0, IF_REAL,"Length dependence of vto"), +IOP( "lvtho", BSIM4v7_MOD_LVTH0, IF_REAL,"Length dependence of vto"), +IOP( "lua", BSIM4v7_MOD_LUA, IF_REAL, "Length dependence of ua"), +IOP( "lua1", BSIM4v7_MOD_LUA1, IF_REAL, "Length dependence of ua1"), +IOP( "lub", BSIM4v7_MOD_LUB, IF_REAL, "Length dependence of ub"), +IOP( "lub1", BSIM4v7_MOD_LUB1, IF_REAL, "Length dependence of ub1"), +IOP( "luc", BSIM4v7_MOD_LUC, IF_REAL, "Length dependence of uc"), +IOP( "luc1", BSIM4v7_MOD_LUC1, IF_REAL, "Length dependence of uc1"), +IOP( "lud", BSIM4v7_MOD_LUD, IF_REAL, "Length dependence of ud"), +IOP( "lud1", BSIM4v7_MOD_LUD1, IF_REAL, "Length dependence of ud1"), +IOP( "lup", BSIM4v7_MOD_LUP, IF_REAL, "Length dependence of up"), +IOP( "llp", BSIM4v7_MOD_LLP, IF_REAL, "Length dependence of lp"), +IOP( "lu0", BSIM4v7_MOD_LU0, IF_REAL, "Length dependence of u0"), +IOP( "lute", BSIM4v7_MOD_LUTE, IF_REAL, "Length dependence of ute"), +IOP( "lucste", BSIM4v7_MOD_LUCSTE, IF_REAL, "Length dependence of ucste"), +IOP( "lvoff", BSIM4v7_MOD_LVOFF, IF_REAL, "Length dependence of voff"), +IOP( "lminv", BSIM4v7_MOD_LMINV, IF_REAL, "Length dependence of minv"), +IOP( "lminvcv", BSIM4v7_MOD_LMINVCV, IF_REAL, "Length dependence of minvcv"), +IOP( "ldelta", BSIM4v7_MOD_LDELTA, IF_REAL, "Length dependence of delta"), +IOP( "lrdsw", BSIM4v7_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "), +IOP( "lrsw", BSIM4v7_MOD_LRSW, IF_REAL, "Length dependence of rsw"), +IOP( "lrdw", BSIM4v7_MOD_LRDW, IF_REAL, "Length dependence of rdw"), -IOP( "lprwg", BSIM4_MOD_LPRWG, IF_REAL, "Length dependence of prwg "), -IOP( "lprwb", BSIM4_MOD_LPRWB, IF_REAL, "Length dependence of prwb "), +IOP( "lprwg", BSIM4v7_MOD_LPRWG, IF_REAL, "Length dependence of prwg "), +IOP( "lprwb", BSIM4v7_MOD_LPRWB, IF_REAL, "Length dependence of prwb "), -IOP( "lprt", BSIM4_MOD_LPRT, IF_REAL, "Length dependence of prt "), -IOP( "leta0", BSIM4_MOD_LETA0, IF_REAL, "Length dependence of eta0"), -IOP( "letab", BSIM4_MOD_LETAB, IF_REAL, "Length dependence of etab"), -IOP( "lpclm", BSIM4_MOD_LPCLM, IF_REAL, "Length dependence of pclm"), -IOP( "lpdiblc1", BSIM4_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"), -IOP( "lpdiblc2", BSIM4_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"), -IOP( "lpdiblcb", BSIM4_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"), -IOP( "lfprout", BSIM4_MOD_LFPROUT, IF_REAL, "Length dependence of pdiblcb"), -IOP( "lpdits", BSIM4_MOD_LPDITS, IF_REAL, "Length dependence of pdits"), -IOP( "lpditsd", BSIM4_MOD_LPDITSD, IF_REAL, "Length dependence of pditsd"), -IOP( "lpscbe1", BSIM4_MOD_LPSCBE1, IF_REAL, "Length dependence of pscbe1"), -IOP( "lpscbe2", BSIM4_MOD_LPSCBE2, IF_REAL, "Length dependence of pscbe2"), -IOP( "lpvag", BSIM4_MOD_LPVAG, IF_REAL, "Length dependence of pvag"), -IOP( "lwr", BSIM4_MOD_LWR, IF_REAL, "Length dependence of wr"), -IOP( "ldwg", BSIM4_MOD_LDWG, IF_REAL, "Length dependence of dwg"), -IOP( "ldwb", BSIM4_MOD_LDWB, IF_REAL, "Length dependence of dwb"), -IOP( "lb0", BSIM4_MOD_LB0, IF_REAL, "Length dependence of b0"), -IOP( "lb1", BSIM4_MOD_LB1, IF_REAL, "Length dependence of b1"), -IOP( "lcgsl", BSIM4_MOD_LCGSL, IF_REAL, "Length dependence of cgsl"), -IOP( "lcgdl", BSIM4_MOD_LCGDL, IF_REAL, "Length dependence of cgdl"), -IOP( "lckappas", BSIM4_MOD_LCKAPPAS, IF_REAL, "Length dependence of ckappas"), -IOP( "lckappad", BSIM4_MOD_LCKAPPAD, IF_REAL, "Length dependence of ckappad"), -IOP( "lcf", BSIM4_MOD_LCF, IF_REAL, "Length dependence of cf"), -IOP( "lclc", BSIM4_MOD_LCLC, IF_REAL, "Length dependence of clc"), -IOP( "lcle", BSIM4_MOD_LCLE, IF_REAL, "Length dependence of cle"), -IOP( "lalpha0", BSIM4_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"), -IOP( "lalpha1", BSIM4_MOD_LALPHA1, IF_REAL, "Length dependence of alpha1"), -IOP( "lbeta0", BSIM4_MOD_LBETA0, IF_REAL, "Length dependence of beta0"), +IOP( "lprt", BSIM4v7_MOD_LPRT, IF_REAL, "Length dependence of prt "), +IOP( "leta0", BSIM4v7_MOD_LETA0, IF_REAL, "Length dependence of eta0"), +IOP( "letab", BSIM4v7_MOD_LETAB, IF_REAL, "Length dependence of etab"), +IOP( "lpclm", BSIM4v7_MOD_LPCLM, IF_REAL, "Length dependence of pclm"), +IOP( "lpdiblc1", BSIM4v7_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"), +IOP( "lpdiblc2", BSIM4v7_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"), +IOP( "lpdiblcb", BSIM4v7_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"), +IOP( "lfprout", BSIM4v7_MOD_LFPROUT, IF_REAL, "Length dependence of pdiblcb"), +IOP( "lpdits", BSIM4v7_MOD_LPDITS, IF_REAL, "Length dependence of pdits"), +IOP( "lpditsd", BSIM4v7_MOD_LPDITSD, IF_REAL, "Length dependence of pditsd"), +IOP( "lpscbe1", BSIM4v7_MOD_LPSCBE1, IF_REAL, "Length dependence of pscbe1"), +IOP( "lpscbe2", BSIM4v7_MOD_LPSCBE2, IF_REAL, "Length dependence of pscbe2"), +IOP( "lpvag", BSIM4v7_MOD_LPVAG, IF_REAL, "Length dependence of pvag"), +IOP( "lwr", BSIM4v7_MOD_LWR, IF_REAL, "Length dependence of wr"), +IOP( "ldwg", BSIM4v7_MOD_LDWG, IF_REAL, "Length dependence of dwg"), +IOP( "ldwb", BSIM4v7_MOD_LDWB, IF_REAL, "Length dependence of dwb"), +IOP( "lb0", BSIM4v7_MOD_LB0, IF_REAL, "Length dependence of b0"), +IOP( "lb1", BSIM4v7_MOD_LB1, IF_REAL, "Length dependence of b1"), +IOP( "lcgsl", BSIM4v7_MOD_LCGSL, IF_REAL, "Length dependence of cgsl"), +IOP( "lcgdl", BSIM4v7_MOD_LCGDL, IF_REAL, "Length dependence of cgdl"), +IOP( "lckappas", BSIM4v7_MOD_LCKAPPAS, IF_REAL, "Length dependence of ckappas"), +IOP( "lckappad", BSIM4v7_MOD_LCKAPPAD, IF_REAL, "Length dependence of ckappad"), +IOP( "lcf", BSIM4v7_MOD_LCF, IF_REAL, "Length dependence of cf"), +IOP( "lclc", BSIM4v7_MOD_LCLC, IF_REAL, "Length dependence of clc"), +IOP( "lcle", BSIM4v7_MOD_LCLE, IF_REAL, "Length dependence of cle"), +IOP( "lalpha0", BSIM4v7_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"), +IOP( "lalpha1", BSIM4v7_MOD_LALPHA1, IF_REAL, "Length dependence of alpha1"), +IOP( "lbeta0", BSIM4v7_MOD_LBETA0, IF_REAL, "Length dependence of beta0"), -IOP( "lagidl", BSIM4_MOD_LAGIDL, IF_REAL, "Length dependence of agidl"), -IOP( "lbgidl", BSIM4_MOD_LBGIDL, IF_REAL, "Length dependence of bgidl"), -IOP( "lcgidl", BSIM4_MOD_LCGIDL, IF_REAL, "Length dependence of cgidl"), -IOP( "lrgidl", BSIM4_MOD_LRGIDL, IF_REAL, "Length dependence of rgidl"), /* v4.7 New GIDL/GISL */ -IOP( "lkgidl", BSIM4_MOD_LKGIDL, IF_REAL, "Length dependence of kgidl"), /* v4.7 New GIDL/GISL */ -IOP( "lfgidl", BSIM4_MOD_LFGIDL, IF_REAL, "Length dependence of fgidl"), /* v4.7 New GIDL/GISL */ -IOP( "legidl", BSIM4_MOD_LEGIDL, IF_REAL, "Length dependence of egidl"), -IOP( "lagisl", BSIM4_MOD_LAGISL, IF_REAL, "Length dependence of agisl"), -IOP( "lbgisl", BSIM4_MOD_LBGISL, IF_REAL, "Length dependence of bgisl"), -IOP( "lcgisl", BSIM4_MOD_LCGISL, IF_REAL, "Length dependence of cgisl"), -IOP( "lrgisl", BSIM4_MOD_LRGISL, IF_REAL, "Length dependence of rgisl"), /* v4.7 New GIDL/GISL */ -IOP( "lkgisl", BSIM4_MOD_LKGISL, IF_REAL, "Length dependence of kgisl"), /* v4.7 New GIDL/GISL */ -IOP( "lfgisl", BSIM4_MOD_LFGISL, IF_REAL, "Length dependence of fgisl"), /* v4.7 New GIDL/GISL */ -IOP( "legisl", BSIM4_MOD_LEGISL, IF_REAL, "Length dependence of egisl"), -IOP( "laigc", BSIM4_MOD_LAIGC, IF_REAL, "Length dependence of aigc"), -IOP( "lbigc", BSIM4_MOD_LBIGC, IF_REAL, "Length dependence of bigc"), -IOP( "lcigc", BSIM4_MOD_LCIGC, IF_REAL, "Length dependence of cigc"), -IOP( "laigsd", BSIM4_MOD_LAIGSD, IF_REAL, "Length dependence of aigsd"), -IOP( "lbigsd", BSIM4_MOD_LBIGSD, IF_REAL, "Length dependence of bigsd"), -IOP( "lcigsd", BSIM4_MOD_LCIGSD, IF_REAL, "Length dependence of cigsd"), -IOP( "laigs", BSIM4_MOD_LAIGS, IF_REAL, "Length dependence of aigs"), -IOP( "lbigs", BSIM4_MOD_LBIGS, IF_REAL, "Length dependence of bigs"), -IOP( "lcigs", BSIM4_MOD_LCIGS, IF_REAL, "Length dependence of cigs"), -IOP( "laigd", BSIM4_MOD_LAIGD, IF_REAL, "Length dependence of aigd"), -IOP( "lbigd", BSIM4_MOD_LBIGD, IF_REAL, "Length dependence of bigd"), -IOP( "lcigd", BSIM4_MOD_LCIGD, IF_REAL, "Length dependence of cigd"), -IOP( "laigbacc", BSIM4_MOD_LAIGBACC, IF_REAL, "Length dependence of aigbacc"), -IOP( "lbigbacc", BSIM4_MOD_LBIGBACC, IF_REAL, "Length dependence of bigbacc"), -IOP( "lcigbacc", BSIM4_MOD_LCIGBACC, IF_REAL, "Length dependence of cigbacc"), -IOP( "laigbinv", BSIM4_MOD_LAIGBINV, IF_REAL, "Length dependence of aigbinv"), -IOP( "lbigbinv", BSIM4_MOD_LBIGBINV, IF_REAL, "Length dependence of bigbinv"), -IOP( "lcigbinv", BSIM4_MOD_LCIGBINV, IF_REAL, "Length dependence of cigbinv"), -IOP( "lnigc", BSIM4_MOD_LNIGC, IF_REAL, "Length dependence of nigc"), -IOP( "lnigbinv", BSIM4_MOD_LNIGBINV, IF_REAL, "Length dependence of nigbinv"), -IOP( "lnigbacc", BSIM4_MOD_LNIGBACC, IF_REAL, "Length dependence of nigbacc"), -IOP( "lntox", BSIM4_MOD_LNTOX, IF_REAL, "Length dependence of ntox"), -IOP( "leigbinv", BSIM4_MOD_LEIGBINV, IF_REAL, "Length dependence for eigbinv"), -IOP( "lpigcd", BSIM4_MOD_LPIGCD, IF_REAL, "Length dependence for pigcd"), -IOP( "lpoxedge", BSIM4_MOD_LPOXEDGE, IF_REAL, "Length dependence for poxedge"), +IOP( "lagidl", BSIM4v7_MOD_LAGIDL, IF_REAL, "Length dependence of agidl"), +IOP( "lbgidl", BSIM4v7_MOD_LBGIDL, IF_REAL, "Length dependence of bgidl"), +IOP( "lcgidl", BSIM4v7_MOD_LCGIDL, IF_REAL, "Length dependence of cgidl"), +IOP( "lrgidl", BSIM4v7_MOD_LRGIDL, IF_REAL, "Length dependence of rgidl"), /* v4.7 New GIDL/GISL */ +IOP( "lkgidl", BSIM4v7_MOD_LKGIDL, IF_REAL, "Length dependence of kgidl"), /* v4.7 New GIDL/GISL */ +IOP( "lfgidl", BSIM4v7_MOD_LFGIDL, IF_REAL, "Length dependence of fgidl"), /* v4.7 New GIDL/GISL */ +IOP( "legidl", BSIM4v7_MOD_LEGIDL, IF_REAL, "Length dependence of egidl"), +IOP( "lagisl", BSIM4v7_MOD_LAGISL, IF_REAL, "Length dependence of agisl"), +IOP( "lbgisl", BSIM4v7_MOD_LBGISL, IF_REAL, "Length dependence of bgisl"), +IOP( "lcgisl", BSIM4v7_MOD_LCGISL, IF_REAL, "Length dependence of cgisl"), +IOP( "lrgisl", BSIM4v7_MOD_LRGISL, IF_REAL, "Length dependence of rgisl"), /* v4.7 New GIDL/GISL */ +IOP( "lkgisl", BSIM4v7_MOD_LKGISL, IF_REAL, "Length dependence of kgisl"), /* v4.7 New GIDL/GISL */ +IOP( "lfgisl", BSIM4v7_MOD_LFGISL, IF_REAL, "Length dependence of fgisl"), /* v4.7 New GIDL/GISL */ +IOP( "legisl", BSIM4v7_MOD_LEGISL, IF_REAL, "Length dependence of egisl"), +IOP( "laigc", BSIM4v7_MOD_LAIGC, IF_REAL, "Length dependence of aigc"), +IOP( "lbigc", BSIM4v7_MOD_LBIGC, IF_REAL, "Length dependence of bigc"), +IOP( "lcigc", BSIM4v7_MOD_LCIGC, IF_REAL, "Length dependence of cigc"), +IOP( "laigsd", BSIM4v7_MOD_LAIGSD, IF_REAL, "Length dependence of aigsd"), +IOP( "lbigsd", BSIM4v7_MOD_LBIGSD, IF_REAL, "Length dependence of bigsd"), +IOP( "lcigsd", BSIM4v7_MOD_LCIGSD, IF_REAL, "Length dependence of cigsd"), +IOP( "laigs", BSIM4v7_MOD_LAIGS, IF_REAL, "Length dependence of aigs"), +IOP( "lbigs", BSIM4v7_MOD_LBIGS, IF_REAL, "Length dependence of bigs"), +IOP( "lcigs", BSIM4v7_MOD_LCIGS, IF_REAL, "Length dependence of cigs"), +IOP( "laigd", BSIM4v7_MOD_LAIGD, IF_REAL, "Length dependence of aigd"), +IOP( "lbigd", BSIM4v7_MOD_LBIGD, IF_REAL, "Length dependence of bigd"), +IOP( "lcigd", BSIM4v7_MOD_LCIGD, IF_REAL, "Length dependence of cigd"), +IOP( "laigbacc", BSIM4v7_MOD_LAIGBACC, IF_REAL, "Length dependence of aigbacc"), +IOP( "lbigbacc", BSIM4v7_MOD_LBIGBACC, IF_REAL, "Length dependence of bigbacc"), +IOP( "lcigbacc", BSIM4v7_MOD_LCIGBACC, IF_REAL, "Length dependence of cigbacc"), +IOP( "laigbinv", BSIM4v7_MOD_LAIGBINV, IF_REAL, "Length dependence of aigbinv"), +IOP( "lbigbinv", BSIM4v7_MOD_LBIGBINV, IF_REAL, "Length dependence of bigbinv"), +IOP( "lcigbinv", BSIM4v7_MOD_LCIGBINV, IF_REAL, "Length dependence of cigbinv"), +IOP( "lnigc", BSIM4v7_MOD_LNIGC, IF_REAL, "Length dependence of nigc"), +IOP( "lnigbinv", BSIM4v7_MOD_LNIGBINV, IF_REAL, "Length dependence of nigbinv"), +IOP( "lnigbacc", BSIM4v7_MOD_LNIGBACC, IF_REAL, "Length dependence of nigbacc"), +IOP( "lntox", BSIM4v7_MOD_LNTOX, IF_REAL, "Length dependence of ntox"), +IOP( "leigbinv", BSIM4v7_MOD_LEIGBINV, IF_REAL, "Length dependence for eigbinv"), +IOP( "lpigcd", BSIM4v7_MOD_LPIGCD, IF_REAL, "Length dependence for pigcd"), +IOP( "lpoxedge", BSIM4v7_MOD_LPOXEDGE, IF_REAL, "Length dependence for poxedge"), -IOP( "lvfbcv", BSIM4_MOD_LVFBCV, IF_REAL, "Length dependence of vfbcv"), -IOP( "lvfb", BSIM4_MOD_LVFB, IF_REAL, "Length dependence of vfb"), -IOP( "lacde", BSIM4_MOD_LACDE, IF_REAL, "Length dependence of acde"), -IOP( "lmoin", BSIM4_MOD_LMOIN, IF_REAL, "Length dependence of moin"), -IOP( "lnoff", BSIM4_MOD_LNOFF, IF_REAL, "Length dependence of noff"), -IOP( "lvoffcv", BSIM4_MOD_LVOFFCV, IF_REAL, "Length dependence of voffcv"), -IOP( "lxrcrg1", BSIM4_MOD_LXRCRG1, IF_REAL, "Length dependence of xrcrg1"), -IOP( "lxrcrg2", BSIM4_MOD_LXRCRG2, IF_REAL, "Length dependence of xrcrg2"), -IOP( "llambda", BSIM4_MOD_LLAMBDA, IF_REAL, "Length dependence of lambda"), -IOP( "lvtl", BSIM4_MOD_LVTL, IF_REAL, " Length dependence of vtl"), -IOP( "lxn", BSIM4_MOD_LXN, IF_REAL, " Length dependence of xn"), -IOP( "leu", BSIM4_MOD_LEU, IF_REAL, " Length dependence of eu"), -IOP( "lucs", BSIM4_MOD_LUCS, IF_REAL, "Length dependence of lucs"), -IOP( "lvfbsdoff", BSIM4_MOD_LVFBSDOFF, IF_REAL, "Length dependence of vfbsdoff"), -IOP( "ltvfbsdoff", BSIM4_MOD_LTVFBSDOFF, IF_REAL, "Length dependence of tvfbsdoff"), -IOP( "ltvoff", BSIM4_MOD_LTVOFF, IF_REAL, "Length dependence of tvoff"), -IOP( "ltnfactor", BSIM4_MOD_LTNFACTOR, IF_REAL, "Length dependence of tnfactor"), /* v4.7 Tanvir*/ -IOP( "lteta0", BSIM4_MOD_LTETA0, IF_REAL, "Length dependence of teta0"), /* v4.7 Tanvir*/ -IOP( "ltvoffcv", BSIM4_MOD_LTVOFFCV, IF_REAL, "Length dependence of tvoffcv"), /* v4.7 Tanvir*/ +IOP( "lvfbcv", BSIM4v7_MOD_LVFBCV, IF_REAL, "Length dependence of vfbcv"), +IOP( "lvfb", BSIM4v7_MOD_LVFB, IF_REAL, "Length dependence of vfb"), +IOP( "lacde", BSIM4v7_MOD_LACDE, IF_REAL, "Length dependence of acde"), +IOP( "lmoin", BSIM4v7_MOD_LMOIN, IF_REAL, "Length dependence of moin"), +IOP( "lnoff", BSIM4v7_MOD_LNOFF, IF_REAL, "Length dependence of noff"), +IOP( "lvoffcv", BSIM4v7_MOD_LVOFFCV, IF_REAL, "Length dependence of voffcv"), +IOP( "lxrcrg1", BSIM4v7_MOD_LXRCRG1, IF_REAL, "Length dependence of xrcrg1"), +IOP( "lxrcrg2", BSIM4v7_MOD_LXRCRG2, IF_REAL, "Length dependence of xrcrg2"), +IOP( "llambda", BSIM4v7_MOD_LLAMBDA, IF_REAL, "Length dependence of lambda"), +IOP( "lvtl", BSIM4v7_MOD_LVTL, IF_REAL, " Length dependence of vtl"), +IOP( "lxn", BSIM4v7_MOD_LXN, IF_REAL, " Length dependence of xn"), +IOP( "leu", BSIM4v7_MOD_LEU, IF_REAL, " Length dependence of eu"), +IOP( "lucs", BSIM4v7_MOD_LUCS, IF_REAL, "Length dependence of lucs"), +IOP( "lvfbsdoff", BSIM4v7_MOD_LVFBSDOFF, IF_REAL, "Length dependence of vfbsdoff"), +IOP( "ltvfbsdoff", BSIM4v7_MOD_LTVFBSDOFF, IF_REAL, "Length dependence of tvfbsdoff"), +IOP( "ltvoff", BSIM4v7_MOD_LTVOFF, IF_REAL, "Length dependence of tvoff"), +IOP( "ltnfactor", BSIM4v7_MOD_LTNFACTOR, IF_REAL, "Length dependence of tnfactor"), /* v4.7 Tanvir*/ +IOP( "lteta0", BSIM4v7_MOD_LTETA0, IF_REAL, "Length dependence of teta0"), /* v4.7 Tanvir*/ +IOP( "ltvoffcv", BSIM4v7_MOD_LTVOFFCV, IF_REAL, "Length dependence of tvoffcv"), /* v4.7 Tanvir*/ -IOP( "wcdsc", BSIM4_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"), -IOP( "wcdscb", BSIM4_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"), -IOP( "wcdscd", BSIM4_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"), -IOP( "wcit", BSIM4_MOD_WCIT, IF_REAL, "Width dependence of cit"), -IOP( "wnfactor", BSIM4_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"), -IOP( "wxj", BSIM4_MOD_WXJ, IF_REAL, "Width dependence of xj"), -IOP( "wvsat", BSIM4_MOD_WVSAT, IF_REAL, "Width dependence of vsat"), -IOP( "wat", BSIM4_MOD_WAT, IF_REAL, "Width dependence of at"), -IOP( "wa0", BSIM4_MOD_WA0, IF_REAL, "Width dependence of a0"), -IOP( "wags", BSIM4_MOD_WAGS, IF_REAL, "Width dependence of ags"), -IOP( "wa1", BSIM4_MOD_WA1, IF_REAL, "Width dependence of a1"), -IOP( "wa2", BSIM4_MOD_WA2, IF_REAL, "Width dependence of a2"), -IOP( "wketa", BSIM4_MOD_WKETA, IF_REAL, "Width dependence of keta"), -IOP( "wnsub", BSIM4_MOD_WNSUB, IF_REAL, "Width dependence of nsub"), -IOP( "wndep", BSIM4_MOD_WNDEP, IF_REAL, "Width dependence of ndep"), -IOP( "wnsd", BSIM4_MOD_WNSD, IF_REAL, "Width dependence of nsd"), -IOP( "wphin", BSIM4_MOD_WPHIN, IF_REAL, "Width dependence of phin"), -IOP( "wngate", BSIM4_MOD_WNGATE, IF_REAL, "Width dependence of ngate"), -IOP( "wgamma1", BSIM4_MOD_WGAMMA1, IF_REAL, "Width dependence of gamma1"), -IOP( "wgamma2", BSIM4_MOD_WGAMMA2, IF_REAL, "Width dependence of gamma2"), -IOP( "wvbx", BSIM4_MOD_WVBX, IF_REAL, "Width dependence of vbx"), -IOP( "wvbm", BSIM4_MOD_WVBM, IF_REAL, "Width dependence of vbm"), -IOP( "wxt", BSIM4_MOD_WXT, IF_REAL, "Width dependence of xt"), -IOP( "wk1", BSIM4_MOD_WK1, IF_REAL, "Width dependence of k1"), -IOP( "wkt1", BSIM4_MOD_WKT1, IF_REAL, "Width dependence of kt1"), -IOP( "wkt1l", BSIM4_MOD_WKT1L, IF_REAL, "Width dependence of kt1l"), -IOP( "wkt2", BSIM4_MOD_WKT2, IF_REAL, "Width dependence of kt2"), -IOP( "wk2", BSIM4_MOD_WK2, IF_REAL, "Width dependence of k2"), -IOP( "wk3", BSIM4_MOD_WK3, IF_REAL, "Width dependence of k3"), -IOP( "wk3b", BSIM4_MOD_WK3B, IF_REAL, "Width dependence of k3b"), -IOP( "ww0", BSIM4_MOD_WW0, IF_REAL, "Width dependence of w0"), -IOP( "wdvtp0", BSIM4_MOD_WDVTP0, IF_REAL, "Width dependence of dvtp0"), -IOP( "wdvtp1", BSIM4_MOD_WDVTP1, IF_REAL, "Width dependence of dvtp1"), -IOP( "wdvtp2", BSIM4_MOD_WDVTP2, IF_REAL, "Width dependence of dvtp2"), -IOP( "wdvtp3", BSIM4_MOD_WDVTP3, IF_REAL, "Width dependence of dvtp3"), -IOP( "wdvtp4", BSIM4_MOD_WDVTP4, IF_REAL, "Width dependence of dvtp4"), -IOP( "wdvtp5", BSIM4_MOD_WDVTP5, IF_REAL, "Width dependence of dvtp5"), -IOP( "wlpe0", BSIM4_MOD_WLPE0, IF_REAL, "Width dependence of lpe0"), -IOP( "wlpeb", BSIM4_MOD_WLPEB, IF_REAL, "Width dependence of lpeb"), -IOP( "wdvt0", BSIM4_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"), -IOP( "wdvt1", BSIM4_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"), -IOP( "wdvt2", BSIM4_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"), -IOP( "wdvt0w", BSIM4_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"), -IOP( "wdvt1w", BSIM4_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"), -IOP( "wdvt2w", BSIM4_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"), -IOP( "wdrout", BSIM4_MOD_WDROUT, IF_REAL, "Width dependence of drout"), -IOP( "wdsub", BSIM4_MOD_WDSUB, IF_REAL, "Width dependence of dsub"), -IOP( "wvth0", BSIM4_MOD_WVTH0, IF_REAL,"Width dependence of vto"), -IOP( "wvtho", BSIM4_MOD_WVTH0, IF_REAL,"Width dependence of vto"), -IOP( "wua", BSIM4_MOD_WUA, IF_REAL, "Width dependence of ua"), -IOP( "wua1", BSIM4_MOD_WUA1, IF_REAL, "Width dependence of ua1"), -IOP( "wub", BSIM4_MOD_WUB, IF_REAL, "Width dependence of ub"), -IOP( "wub1", BSIM4_MOD_WUB1, IF_REAL, "Width dependence of ub1"), -IOP( "wuc", BSIM4_MOD_WUC, IF_REAL, "Width dependence of uc"), -IOP( "wuc1", BSIM4_MOD_WUC1, IF_REAL, "Width dependence of uc1"), -IOP( "wud", BSIM4_MOD_WUD, IF_REAL, "Width dependence of ud"), -IOP( "wud1", BSIM4_MOD_WUD1, IF_REAL, "Width dependence of ud1"), -IOP( "wup", BSIM4_MOD_WUP, IF_REAL, "Width dependence of up"), -IOP( "wlp", BSIM4_MOD_WLP, IF_REAL, "Width dependence of lp"), -IOP( "wu0", BSIM4_MOD_WU0, IF_REAL, "Width dependence of u0"), -IOP( "wute", BSIM4_MOD_WUTE, IF_REAL, "Width dependence of ute"), -IOP( "wucste", BSIM4_MOD_WUCSTE, IF_REAL, "Width dependence of ucste"), -IOP( "wvoff", BSIM4_MOD_WVOFF, IF_REAL, "Width dependence of voff"), -IOP( "wminv", BSIM4_MOD_WMINV, IF_REAL, "Width dependence of minv"), -IOP( "wminvcv", BSIM4_MOD_WMINVCV, IF_REAL, "Width dependence of minvcv"), -IOP( "wdelta", BSIM4_MOD_WDELTA, IF_REAL, "Width dependence of delta"), -IOP( "wrdsw", BSIM4_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "), -IOP( "wrsw", BSIM4_MOD_WRSW, IF_REAL, "Width dependence of rsw"), -IOP( "wrdw", BSIM4_MOD_WRDW, IF_REAL, "Width dependence of rdw"), +IOP( "wcdsc", BSIM4v7_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"), +IOP( "wcdscb", BSIM4v7_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"), +IOP( "wcdscd", BSIM4v7_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"), +IOP( "wcit", BSIM4v7_MOD_WCIT, IF_REAL, "Width dependence of cit"), +IOP( "wnfactor", BSIM4v7_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"), +IOP( "wxj", BSIM4v7_MOD_WXJ, IF_REAL, "Width dependence of xj"), +IOP( "wvsat", BSIM4v7_MOD_WVSAT, IF_REAL, "Width dependence of vsat"), +IOP( "wat", BSIM4v7_MOD_WAT, IF_REAL, "Width dependence of at"), +IOP( "wa0", BSIM4v7_MOD_WA0, IF_REAL, "Width dependence of a0"), +IOP( "wags", BSIM4v7_MOD_WAGS, IF_REAL, "Width dependence of ags"), +IOP( "wa1", BSIM4v7_MOD_WA1, IF_REAL, "Width dependence of a1"), +IOP( "wa2", BSIM4v7_MOD_WA2, IF_REAL, "Width dependence of a2"), +IOP( "wketa", BSIM4v7_MOD_WKETA, IF_REAL, "Width dependence of keta"), +IOP( "wnsub", BSIM4v7_MOD_WNSUB, IF_REAL, "Width dependence of nsub"), +IOP( "wndep", BSIM4v7_MOD_WNDEP, IF_REAL, "Width dependence of ndep"), +IOP( "wnsd", BSIM4v7_MOD_WNSD, IF_REAL, "Width dependence of nsd"), +IOP( "wphin", BSIM4v7_MOD_WPHIN, IF_REAL, "Width dependence of phin"), +IOP( "wngate", BSIM4v7_MOD_WNGATE, IF_REAL, "Width dependence of ngate"), +IOP( "wgamma1", BSIM4v7_MOD_WGAMMA1, IF_REAL, "Width dependence of gamma1"), +IOP( "wgamma2", BSIM4v7_MOD_WGAMMA2, IF_REAL, "Width dependence of gamma2"), +IOP( "wvbx", BSIM4v7_MOD_WVBX, IF_REAL, "Width dependence of vbx"), +IOP( "wvbm", BSIM4v7_MOD_WVBM, IF_REAL, "Width dependence of vbm"), +IOP( "wxt", BSIM4v7_MOD_WXT, IF_REAL, "Width dependence of xt"), +IOP( "wk1", BSIM4v7_MOD_WK1, IF_REAL, "Width dependence of k1"), +IOP( "wkt1", BSIM4v7_MOD_WKT1, IF_REAL, "Width dependence of kt1"), +IOP( "wkt1l", BSIM4v7_MOD_WKT1L, IF_REAL, "Width dependence of kt1l"), +IOP( "wkt2", BSIM4v7_MOD_WKT2, IF_REAL, "Width dependence of kt2"), +IOP( "wk2", BSIM4v7_MOD_WK2, IF_REAL, "Width dependence of k2"), +IOP( "wk3", BSIM4v7_MOD_WK3, IF_REAL, "Width dependence of k3"), +IOP( "wk3b", BSIM4v7_MOD_WK3B, IF_REAL, "Width dependence of k3b"), +IOP( "ww0", BSIM4v7_MOD_WW0, IF_REAL, "Width dependence of w0"), +IOP( "wdvtp0", BSIM4v7_MOD_WDVTP0, IF_REAL, "Width dependence of dvtp0"), +IOP( "wdvtp1", BSIM4v7_MOD_WDVTP1, IF_REAL, "Width dependence of dvtp1"), +IOP( "wdvtp2", BSIM4v7_MOD_WDVTP2, IF_REAL, "Width dependence of dvtp2"), +IOP( "wdvtp3", BSIM4v7_MOD_WDVTP3, IF_REAL, "Width dependence of dvtp3"), +IOP( "wdvtp4", BSIM4v7_MOD_WDVTP4, IF_REAL, "Width dependence of dvtp4"), +IOP( "wdvtp5", BSIM4v7_MOD_WDVTP5, IF_REAL, "Width dependence of dvtp5"), +IOP( "wlpe0", BSIM4v7_MOD_WLPE0, IF_REAL, "Width dependence of lpe0"), +IOP( "wlpeb", BSIM4v7_MOD_WLPEB, IF_REAL, "Width dependence of lpeb"), +IOP( "wdvt0", BSIM4v7_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"), +IOP( "wdvt1", BSIM4v7_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"), +IOP( "wdvt2", BSIM4v7_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"), +IOP( "wdvt0w", BSIM4v7_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"), +IOP( "wdvt1w", BSIM4v7_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"), +IOP( "wdvt2w", BSIM4v7_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"), +IOP( "wdrout", BSIM4v7_MOD_WDROUT, IF_REAL, "Width dependence of drout"), +IOP( "wdsub", BSIM4v7_MOD_WDSUB, IF_REAL, "Width dependence of dsub"), +IOP( "wvth0", BSIM4v7_MOD_WVTH0, IF_REAL,"Width dependence of vto"), +IOP( "wvtho", BSIM4v7_MOD_WVTH0, IF_REAL,"Width dependence of vto"), +IOP( "wua", BSIM4v7_MOD_WUA, IF_REAL, "Width dependence of ua"), +IOP( "wua1", BSIM4v7_MOD_WUA1, IF_REAL, "Width dependence of ua1"), +IOP( "wub", BSIM4v7_MOD_WUB, IF_REAL, "Width dependence of ub"), +IOP( "wub1", BSIM4v7_MOD_WUB1, IF_REAL, "Width dependence of ub1"), +IOP( "wuc", BSIM4v7_MOD_WUC, IF_REAL, "Width dependence of uc"), +IOP( "wuc1", BSIM4v7_MOD_WUC1, IF_REAL, "Width dependence of uc1"), +IOP( "wud", BSIM4v7_MOD_WUD, IF_REAL, "Width dependence of ud"), +IOP( "wud1", BSIM4v7_MOD_WUD1, IF_REAL, "Width dependence of ud1"), +IOP( "wup", BSIM4v7_MOD_WUP, IF_REAL, "Width dependence of up"), +IOP( "wlp", BSIM4v7_MOD_WLP, IF_REAL, "Width dependence of lp"), +IOP( "wu0", BSIM4v7_MOD_WU0, IF_REAL, "Width dependence of u0"), +IOP( "wute", BSIM4v7_MOD_WUTE, IF_REAL, "Width dependence of ute"), +IOP( "wucste", BSIM4v7_MOD_WUCSTE, IF_REAL, "Width dependence of ucste"), +IOP( "wvoff", BSIM4v7_MOD_WVOFF, IF_REAL, "Width dependence of voff"), +IOP( "wminv", BSIM4v7_MOD_WMINV, IF_REAL, "Width dependence of minv"), +IOP( "wminvcv", BSIM4v7_MOD_WMINVCV, IF_REAL, "Width dependence of minvcv"), +IOP( "wdelta", BSIM4v7_MOD_WDELTA, IF_REAL, "Width dependence of delta"), +IOP( "wrdsw", BSIM4v7_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "), +IOP( "wrsw", BSIM4v7_MOD_WRSW, IF_REAL, "Width dependence of rsw"), +IOP( "wrdw", BSIM4v7_MOD_WRDW, IF_REAL, "Width dependence of rdw"), -IOP( "wprwg", BSIM4_MOD_WPRWG, IF_REAL, "Width dependence of prwg "), -IOP( "wprwb", BSIM4_MOD_WPRWB, IF_REAL, "Width dependence of prwb "), +IOP( "wprwg", BSIM4v7_MOD_WPRWG, IF_REAL, "Width dependence of prwg "), +IOP( "wprwb", BSIM4v7_MOD_WPRWB, IF_REAL, "Width dependence of prwb "), -IOP( "wprt", BSIM4_MOD_WPRT, IF_REAL, "Width dependence of prt"), -IOP( "weta0", BSIM4_MOD_WETA0, IF_REAL, "Width dependence of eta0"), -IOP( "wetab", BSIM4_MOD_WETAB, IF_REAL, "Width dependence of etab"), -IOP( "wpclm", BSIM4_MOD_WPCLM, IF_REAL, "Width dependence of pclm"), -IOP( "wpdiblc1", BSIM4_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"), -IOP( "wpdiblc2", BSIM4_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"), -IOP( "wpdiblcb", BSIM4_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"), -IOP( "wfprout", BSIM4_MOD_WFPROUT, IF_REAL, "Width dependence of pdiblcb"), -IOP( "wpdits", BSIM4_MOD_WPDITS, IF_REAL, "Width dependence of pdits"), -IOP( "wpditsd", BSIM4_MOD_WPDITSD, IF_REAL, "Width dependence of pditsd"), -IOP( "wpscbe1", BSIM4_MOD_WPSCBE1, IF_REAL, "Width dependence of pscbe1"), -IOP( "wpscbe2", BSIM4_MOD_WPSCBE2, IF_REAL, "Width dependence of pscbe2"), -IOP( "wpvag", BSIM4_MOD_WPVAG, IF_REAL, "Width dependence of pvag"), -IOP( "wwr", BSIM4_MOD_WWR, IF_REAL, "Width dependence of wr"), -IOP( "wdwg", BSIM4_MOD_WDWG, IF_REAL, "Width dependence of dwg"), -IOP( "wdwb", BSIM4_MOD_WDWB, IF_REAL, "Width dependence of dwb"), -IOP( "wb0", BSIM4_MOD_WB0, IF_REAL, "Width dependence of b0"), -IOP( "wb1", BSIM4_MOD_WB1, IF_REAL, "Width dependence of b1"), -IOP( "wcgsl", BSIM4_MOD_WCGSL, IF_REAL, "Width dependence of cgsl"), -IOP( "wcgdl", BSIM4_MOD_WCGDL, IF_REAL, "Width dependence of cgdl"), -IOP( "wckappas", BSIM4_MOD_WCKAPPAS, IF_REAL, "Width dependence of ckappas"), -IOP( "wckappad", BSIM4_MOD_WCKAPPAD, IF_REAL, "Width dependence of ckappad"), -IOP( "wcf", BSIM4_MOD_WCF, IF_REAL, "Width dependence of cf"), -IOP( "wclc", BSIM4_MOD_WCLC, IF_REAL, "Width dependence of clc"), -IOP( "wcle", BSIM4_MOD_WCLE, IF_REAL, "Width dependence of cle"), -IOP( "walpha0", BSIM4_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"), -IOP( "walpha1", BSIM4_MOD_WALPHA1, IF_REAL, "Width dependence of alpha1"), -IOP( "wbeta0", BSIM4_MOD_WBETA0, IF_REAL, "Width dependence of beta0"), +IOP( "wprt", BSIM4v7_MOD_WPRT, IF_REAL, "Width dependence of prt"), +IOP( "weta0", BSIM4v7_MOD_WETA0, IF_REAL, "Width dependence of eta0"), +IOP( "wetab", BSIM4v7_MOD_WETAB, IF_REAL, "Width dependence of etab"), +IOP( "wpclm", BSIM4v7_MOD_WPCLM, IF_REAL, "Width dependence of pclm"), +IOP( "wpdiblc1", BSIM4v7_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"), +IOP( "wpdiblc2", BSIM4v7_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"), +IOP( "wpdiblcb", BSIM4v7_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"), +IOP( "wfprout", BSIM4v7_MOD_WFPROUT, IF_REAL, "Width dependence of pdiblcb"), +IOP( "wpdits", BSIM4v7_MOD_WPDITS, IF_REAL, "Width dependence of pdits"), +IOP( "wpditsd", BSIM4v7_MOD_WPDITSD, IF_REAL, "Width dependence of pditsd"), +IOP( "wpscbe1", BSIM4v7_MOD_WPSCBE1, IF_REAL, "Width dependence of pscbe1"), +IOP( "wpscbe2", BSIM4v7_MOD_WPSCBE2, IF_REAL, "Width dependence of pscbe2"), +IOP( "wpvag", BSIM4v7_MOD_WPVAG, IF_REAL, "Width dependence of pvag"), +IOP( "wwr", BSIM4v7_MOD_WWR, IF_REAL, "Width dependence of wr"), +IOP( "wdwg", BSIM4v7_MOD_WDWG, IF_REAL, "Width dependence of dwg"), +IOP( "wdwb", BSIM4v7_MOD_WDWB, IF_REAL, "Width dependence of dwb"), +IOP( "wb0", BSIM4v7_MOD_WB0, IF_REAL, "Width dependence of b0"), +IOP( "wb1", BSIM4v7_MOD_WB1, IF_REAL, "Width dependence of b1"), +IOP( "wcgsl", BSIM4v7_MOD_WCGSL, IF_REAL, "Width dependence of cgsl"), +IOP( "wcgdl", BSIM4v7_MOD_WCGDL, IF_REAL, "Width dependence of cgdl"), +IOP( "wckappas", BSIM4v7_MOD_WCKAPPAS, IF_REAL, "Width dependence of ckappas"), +IOP( "wckappad", BSIM4v7_MOD_WCKAPPAD, IF_REAL, "Width dependence of ckappad"), +IOP( "wcf", BSIM4v7_MOD_WCF, IF_REAL, "Width dependence of cf"), +IOP( "wclc", BSIM4v7_MOD_WCLC, IF_REAL, "Width dependence of clc"), +IOP( "wcle", BSIM4v7_MOD_WCLE, IF_REAL, "Width dependence of cle"), +IOP( "walpha0", BSIM4v7_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"), +IOP( "walpha1", BSIM4v7_MOD_WALPHA1, IF_REAL, "Width dependence of alpha1"), +IOP( "wbeta0", BSIM4v7_MOD_WBETA0, IF_REAL, "Width dependence of beta0"), -IOP( "wagidl", BSIM4_MOD_WAGIDL, IF_REAL, "Width dependence of agidl"), -IOP( "wbgidl", BSIM4_MOD_WBGIDL, IF_REAL, "Width dependence of bgidl"), -IOP( "wcgidl", BSIM4_MOD_WCGIDL, IF_REAL, "Width dependence of cgidl"), -IOP( "wrgidl", BSIM4_MOD_WRGIDL, IF_REAL, "Width dependence of rgidl"), /* v4.7 New GIDL/GISL */ -IOP( "wkgidl", BSIM4_MOD_WKGIDL, IF_REAL, "Width dependence of kgidl"), /* v4.7 New GIDL/GISL */ -IOP( "wfgidl", BSIM4_MOD_WFGIDL, IF_REAL, "Width dependence of fgidl"), /* v4.7 New GIDL/GISL */ -IOP( "wegidl", BSIM4_MOD_WEGIDL, IF_REAL, "Width dependence of egidl"), -IOP( "wagisl", BSIM4_MOD_WAGISL, IF_REAL, "Width dependence of agisl"), -IOP( "wbgisl", BSIM4_MOD_WBGISL, IF_REAL, "Width dependence of bgisl"), -IOP( "wcgisl", BSIM4_MOD_WCGISL, IF_REAL, "Width dependence of cgisl"), -IOP( "wrgisl", BSIM4_MOD_WRGISL, IF_REAL, "Width dependence of rgisl"), /* v4.7 New GIDL/GISL */ -IOP( "wkgisl", BSIM4_MOD_WKGISL, IF_REAL, "Width dependence of kgisl"), /* v4.7 New GIDL/GISL */ -IOP( "wfgisl", BSIM4_MOD_WFGISL, IF_REAL, "Width dependence of fgisl"), /* v4.7 New GIDL/GISL */ -IOP( "wegisl", BSIM4_MOD_WEGISL, IF_REAL, "Width dependence of egisl"), -IOP( "waigc", BSIM4_MOD_WAIGC, IF_REAL, "Width dependence of aigc"), -IOP( "wbigc", BSIM4_MOD_WBIGC, IF_REAL, "Width dependence of bigc"), -IOP( "wcigc", BSIM4_MOD_WCIGC, IF_REAL, "Width dependence of cigc"), -IOP( "waigsd", BSIM4_MOD_WAIGSD, IF_REAL, "Width dependence of aigsd"), -IOP( "wbigsd", BSIM4_MOD_WBIGSD, IF_REAL, "Width dependence of bigsd"), -IOP( "wcigsd", BSIM4_MOD_WCIGSD, IF_REAL, "Width dependence of cigsd"), -IOP( "waigs", BSIM4_MOD_WAIGS, IF_REAL, "Width dependence of aigs"), -IOP( "wbigs", BSIM4_MOD_WBIGS, IF_REAL, "Width dependence of bigs"), -IOP( "wcigs", BSIM4_MOD_WCIGS, IF_REAL, "Width dependence of cigs"), -IOP( "waigd", BSIM4_MOD_WAIGD, IF_REAL, "Width dependence of aigd"), -IOP( "wbigd", BSIM4_MOD_WBIGD, IF_REAL, "Width dependence of bigd"), -IOP( "wcigd", BSIM4_MOD_WCIGD, IF_REAL, "Width dependence of cigd"), -IOP( "waigbacc", BSIM4_MOD_WAIGBACC, IF_REAL, "Width dependence of aigbacc"), -IOP( "wbigbacc", BSIM4_MOD_WBIGBACC, IF_REAL, "Width dependence of bigbacc"), -IOP( "wcigbacc", BSIM4_MOD_WCIGBACC, IF_REAL, "Width dependence of cigbacc"), -IOP( "waigbinv", BSIM4_MOD_WAIGBINV, IF_REAL, "Width dependence of aigbinv"), -IOP( "wbigbinv", BSIM4_MOD_WBIGBINV, IF_REAL, "Width dependence of bigbinv"), -IOP( "wcigbinv", BSIM4_MOD_WCIGBINV, IF_REAL, "Width dependence of cigbinv"), -IOP( "wnigc", BSIM4_MOD_WNIGC, IF_REAL, "Width dependence of nigc"), -IOP( "wnigbinv", BSIM4_MOD_WNIGBINV, IF_REAL, "Width dependence of nigbinv"), -IOP( "wnigbacc", BSIM4_MOD_WNIGBACC, IF_REAL, "Width dependence of nigbacc"), -IOP( "wntox", BSIM4_MOD_WNTOX, IF_REAL, "Width dependence of ntox"), -IOP( "weigbinv", BSIM4_MOD_WEIGBINV, IF_REAL, "Width dependence for eigbinv"), -IOP( "wpigcd", BSIM4_MOD_WPIGCD, IF_REAL, "Width dependence for pigcd"), -IOP( "wpoxedge", BSIM4_MOD_WPOXEDGE, IF_REAL, "Width dependence for poxedge"), -IOP( "wvfbcv", BSIM4_MOD_WVFBCV, IF_REAL, "Width dependence of vfbcv"), -IOP( "wvfb", BSIM4_MOD_WVFB, IF_REAL, "Width dependence of vfb"), -IOP( "wacde", BSIM4_MOD_WACDE, IF_REAL, "Width dependence of acde"), -IOP( "wmoin", BSIM4_MOD_WMOIN, IF_REAL, "Width dependence of moin"), -IOP( "wnoff", BSIM4_MOD_WNOFF, IF_REAL, "Width dependence of noff"), -IOP( "wvoffcv", BSIM4_MOD_WVOFFCV, IF_REAL, "Width dependence of voffcv"), -IOP( "wxrcrg1", BSIM4_MOD_WXRCRG1, IF_REAL, "Width dependence of xrcrg1"), -IOP( "wxrcrg2", BSIM4_MOD_WXRCRG2, IF_REAL, "Width dependence of xrcrg2"), -IOP( "wlambda", BSIM4_MOD_WLAMBDA, IF_REAL, "Width dependence of lambda"), -IOP( "wvtl", BSIM4_MOD_WVTL, IF_REAL, "Width dependence of vtl"), -IOP( "wxn", BSIM4_MOD_WXN, IF_REAL, "Width dependence of xn"), -IOP( "weu", BSIM4_MOD_WEU, IF_REAL, "Width dependence of eu"), -IOP( "wucs", BSIM4_MOD_WUCS, IF_REAL, "Width dependence of ucs"), -IOP( "wvfbsdoff", BSIM4_MOD_WVFBSDOFF, IF_REAL, "Width dependence of vfbsdoff"), -IOP( "wtvfbsdoff", BSIM4_MOD_WTVFBSDOFF, IF_REAL, "Width dependence of tvfbsdoff"), -IOP( "wtvoff", BSIM4_MOD_WTVOFF, IF_REAL, "Width dependence of tvoff"), -IOP( "wtnfactor", BSIM4_MOD_WTNFACTOR, IF_REAL, "Width dependence of tnfactor"), /* v4.7 Tanvir*/ -IOP( "wteta0", BSIM4_MOD_WTETA0, IF_REAL, "Width dependence of teta0"), /* v4.7 Tanvir*/ -IOP( "wtvoffcv", BSIM4_MOD_WTVOFFCV, IF_REAL, "Width dependence of tvoffcv"), /* v4.7 Tanvir*/ +IOP( "wagidl", BSIM4v7_MOD_WAGIDL, IF_REAL, "Width dependence of agidl"), +IOP( "wbgidl", BSIM4v7_MOD_WBGIDL, IF_REAL, "Width dependence of bgidl"), +IOP( "wcgidl", BSIM4v7_MOD_WCGIDL, IF_REAL, "Width dependence of cgidl"), +IOP( "wrgidl", BSIM4v7_MOD_WRGIDL, IF_REAL, "Width dependence of rgidl"), /* v4.7 New GIDL/GISL */ +IOP( "wkgidl", BSIM4v7_MOD_WKGIDL, IF_REAL, "Width dependence of kgidl"), /* v4.7 New GIDL/GISL */ +IOP( "wfgidl", BSIM4v7_MOD_WFGIDL, IF_REAL, "Width dependence of fgidl"), /* v4.7 New GIDL/GISL */ +IOP( "wegidl", BSIM4v7_MOD_WEGIDL, IF_REAL, "Width dependence of egidl"), +IOP( "wagisl", BSIM4v7_MOD_WAGISL, IF_REAL, "Width dependence of agisl"), +IOP( "wbgisl", BSIM4v7_MOD_WBGISL, IF_REAL, "Width dependence of bgisl"), +IOP( "wcgisl", BSIM4v7_MOD_WCGISL, IF_REAL, "Width dependence of cgisl"), +IOP( "wrgisl", BSIM4v7_MOD_WRGISL, IF_REAL, "Width dependence of rgisl"), /* v4.7 New GIDL/GISL */ +IOP( "wkgisl", BSIM4v7_MOD_WKGISL, IF_REAL, "Width dependence of kgisl"), /* v4.7 New GIDL/GISL */ +IOP( "wfgisl", BSIM4v7_MOD_WFGISL, IF_REAL, "Width dependence of fgisl"), /* v4.7 New GIDL/GISL */ +IOP( "wegisl", BSIM4v7_MOD_WEGISL, IF_REAL, "Width dependence of egisl"), +IOP( "waigc", BSIM4v7_MOD_WAIGC, IF_REAL, "Width dependence of aigc"), +IOP( "wbigc", BSIM4v7_MOD_WBIGC, IF_REAL, "Width dependence of bigc"), +IOP( "wcigc", BSIM4v7_MOD_WCIGC, IF_REAL, "Width dependence of cigc"), +IOP( "waigsd", BSIM4v7_MOD_WAIGSD, IF_REAL, "Width dependence of aigsd"), +IOP( "wbigsd", BSIM4v7_MOD_WBIGSD, IF_REAL, "Width dependence of bigsd"), +IOP( "wcigsd", BSIM4v7_MOD_WCIGSD, IF_REAL, "Width dependence of cigsd"), +IOP( "waigs", BSIM4v7_MOD_WAIGS, IF_REAL, "Width dependence of aigs"), +IOP( "wbigs", BSIM4v7_MOD_WBIGS, IF_REAL, "Width dependence of bigs"), +IOP( "wcigs", BSIM4v7_MOD_WCIGS, IF_REAL, "Width dependence of cigs"), +IOP( "waigd", BSIM4v7_MOD_WAIGD, IF_REAL, "Width dependence of aigd"), +IOP( "wbigd", BSIM4v7_MOD_WBIGD, IF_REAL, "Width dependence of bigd"), +IOP( "wcigd", BSIM4v7_MOD_WCIGD, IF_REAL, "Width dependence of cigd"), +IOP( "waigbacc", BSIM4v7_MOD_WAIGBACC, IF_REAL, "Width dependence of aigbacc"), +IOP( "wbigbacc", BSIM4v7_MOD_WBIGBACC, IF_REAL, "Width dependence of bigbacc"), +IOP( "wcigbacc", BSIM4v7_MOD_WCIGBACC, IF_REAL, "Width dependence of cigbacc"), +IOP( "waigbinv", BSIM4v7_MOD_WAIGBINV, IF_REAL, "Width dependence of aigbinv"), +IOP( "wbigbinv", BSIM4v7_MOD_WBIGBINV, IF_REAL, "Width dependence of bigbinv"), +IOP( "wcigbinv", BSIM4v7_MOD_WCIGBINV, IF_REAL, "Width dependence of cigbinv"), +IOP( "wnigc", BSIM4v7_MOD_WNIGC, IF_REAL, "Width dependence of nigc"), +IOP( "wnigbinv", BSIM4v7_MOD_WNIGBINV, IF_REAL, "Width dependence of nigbinv"), +IOP( "wnigbacc", BSIM4v7_MOD_WNIGBACC, IF_REAL, "Width dependence of nigbacc"), +IOP( "wntox", BSIM4v7_MOD_WNTOX, IF_REAL, "Width dependence of ntox"), +IOP( "weigbinv", BSIM4v7_MOD_WEIGBINV, IF_REAL, "Width dependence for eigbinv"), +IOP( "wpigcd", BSIM4v7_MOD_WPIGCD, IF_REAL, "Width dependence for pigcd"), +IOP( "wpoxedge", BSIM4v7_MOD_WPOXEDGE, IF_REAL, "Width dependence for poxedge"), +IOP( "wvfbcv", BSIM4v7_MOD_WVFBCV, IF_REAL, "Width dependence of vfbcv"), +IOP( "wvfb", BSIM4v7_MOD_WVFB, IF_REAL, "Width dependence of vfb"), +IOP( "wacde", BSIM4v7_MOD_WACDE, IF_REAL, "Width dependence of acde"), +IOP( "wmoin", BSIM4v7_MOD_WMOIN, IF_REAL, "Width dependence of moin"), +IOP( "wnoff", BSIM4v7_MOD_WNOFF, IF_REAL, "Width dependence of noff"), +IOP( "wvoffcv", BSIM4v7_MOD_WVOFFCV, IF_REAL, "Width dependence of voffcv"), +IOP( "wxrcrg1", BSIM4v7_MOD_WXRCRG1, IF_REAL, "Width dependence of xrcrg1"), +IOP( "wxrcrg2", BSIM4v7_MOD_WXRCRG2, IF_REAL, "Width dependence of xrcrg2"), +IOP( "wlambda", BSIM4v7_MOD_WLAMBDA, IF_REAL, "Width dependence of lambda"), +IOP( "wvtl", BSIM4v7_MOD_WVTL, IF_REAL, "Width dependence of vtl"), +IOP( "wxn", BSIM4v7_MOD_WXN, IF_REAL, "Width dependence of xn"), +IOP( "weu", BSIM4v7_MOD_WEU, IF_REAL, "Width dependence of eu"), +IOP( "wucs", BSIM4v7_MOD_WUCS, IF_REAL, "Width dependence of ucs"), +IOP( "wvfbsdoff", BSIM4v7_MOD_WVFBSDOFF, IF_REAL, "Width dependence of vfbsdoff"), +IOP( "wtvfbsdoff", BSIM4v7_MOD_WTVFBSDOFF, IF_REAL, "Width dependence of tvfbsdoff"), +IOP( "wtvoff", BSIM4v7_MOD_WTVOFF, IF_REAL, "Width dependence of tvoff"), +IOP( "wtnfactor", BSIM4v7_MOD_WTNFACTOR, IF_REAL, "Width dependence of tnfactor"), /* v4.7 Tanvir*/ +IOP( "wteta0", BSIM4v7_MOD_WTETA0, IF_REAL, "Width dependence of teta0"), /* v4.7 Tanvir*/ +IOP( "wtvoffcv", BSIM4v7_MOD_WTVOFFCV, IF_REAL, "Width dependence of tvoffcv"), /* v4.7 Tanvir*/ -IOP( "pcdsc", BSIM4_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"), -IOP( "pcdscb", BSIM4_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"), -IOP( "pcdscd", BSIM4_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"), -IOP( "pcit", BSIM4_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"), -IOP( "pnfactor", BSIM4_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"), -IOP( "pxj", BSIM4_MOD_PXJ, IF_REAL, "Cross-term dependence of xj"), -IOP( "pvsat", BSIM4_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"), -IOP( "pat", BSIM4_MOD_PAT, IF_REAL, "Cross-term dependence of at"), -IOP( "pa0", BSIM4_MOD_PA0, IF_REAL, "Cross-term dependence of a0"), -IOP( "pags", BSIM4_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"), -IOP( "pa1", BSIM4_MOD_PA1, IF_REAL, "Cross-term dependence of a1"), -IOP( "pa2", BSIM4_MOD_PA2, IF_REAL, "Cross-term dependence of a2"), -IOP( "pketa", BSIM4_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"), -IOP( "pnsub", BSIM4_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"), -IOP( "pndep", BSIM4_MOD_PNDEP, IF_REAL, "Cross-term dependence of ndep"), -IOP( "pnsd", BSIM4_MOD_PNSD, IF_REAL, "Cross-term dependence of nsd"), -IOP( "pphin", BSIM4_MOD_PPHIN, IF_REAL, "Cross-term dependence of phin"), -IOP( "pngate", BSIM4_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"), -IOP( "pgamma1", BSIM4_MOD_PGAMMA1, IF_REAL, "Cross-term dependence of gamma1"), -IOP( "pgamma2", BSIM4_MOD_PGAMMA2, IF_REAL, "Cross-term dependence of gamma2"), -IOP( "pvbx", BSIM4_MOD_PVBX, IF_REAL, "Cross-term dependence of vbx"), -IOP( "pvbm", BSIM4_MOD_PVBM, IF_REAL, "Cross-term dependence of vbm"), -IOP( "pxt", BSIM4_MOD_PXT, IF_REAL, "Cross-term dependence of xt"), -IOP( "pk1", BSIM4_MOD_PK1, IF_REAL, "Cross-term dependence of k1"), -IOP( "pkt1", BSIM4_MOD_PKT1, IF_REAL, "Cross-term dependence of kt1"), -IOP( "pkt1l", BSIM4_MOD_PKT1L, IF_REAL, "Cross-term dependence of kt1l"), -IOP( "pkt2", BSIM4_MOD_PKT2, IF_REAL, "Cross-term dependence of kt2"), -IOP( "pk2", BSIM4_MOD_PK2, IF_REAL, "Cross-term dependence of k2"), -IOP( "pk3", BSIM4_MOD_PK3, IF_REAL, "Cross-term dependence of k3"), -IOP( "pk3b", BSIM4_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"), -IOP( "pw0", BSIM4_MOD_PW0, IF_REAL, "Cross-term dependence of w0"), -IOP( "pdvtp0", BSIM4_MOD_PDVTP0, IF_REAL, "Cross-term dependence of dvtp0"), -IOP( "pdvtp1", BSIM4_MOD_PDVTP1, IF_REAL, "Cross-term dependence of dvtp1"), -IOP( "pdvtp2", BSIM4_MOD_PDVTP2, IF_REAL, "Cross-term dependence of dvtp2"), -IOP( "pdvtp3", BSIM4_MOD_PDVTP3, IF_REAL, "Cross-term dependence of dvtp3"), -IOP( "pdvtp4", BSIM4_MOD_PDVTP4, IF_REAL, "Cross-term dependence of dvtp4"), -IOP( "pdvtp5", BSIM4_MOD_PDVTP5, IF_REAL, "Cross-term dependence of dvtp5"), -IOP( "plpe0", BSIM4_MOD_PLPE0, IF_REAL, "Cross-term dependence of lpe0"), -IOP( "plpeb", BSIM4_MOD_PLPEB, IF_REAL, "Cross-term dependence of lpeb"), -IOP( "pdvt0", BSIM4_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"), -IOP( "pdvt1", BSIM4_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"), -IOP( "pdvt2", BSIM4_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"), -IOP( "pdvt0w", BSIM4_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"), -IOP( "pdvt1w", BSIM4_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"), -IOP( "pdvt2w", BSIM4_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"), -IOP( "pdrout", BSIM4_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"), -IOP( "pdsub", BSIM4_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"), -IOP( "pvth0", BSIM4_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"), -IOP( "pvtho", BSIM4_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"), -IOP( "pua", BSIM4_MOD_PUA, IF_REAL, "Cross-term dependence of ua"), -IOP( "pua1", BSIM4_MOD_PUA1, IF_REAL, "Cross-term dependence of ua1"), -IOP( "pub", BSIM4_MOD_PUB, IF_REAL, "Cross-term dependence of ub"), -IOP( "pub1", BSIM4_MOD_PUB1, IF_REAL, "Cross-term dependence of ub1"), -IOP( "puc", BSIM4_MOD_PUC, IF_REAL, "Cross-term dependence of uc"), -IOP( "puc1", BSIM4_MOD_PUC1, IF_REAL, "Cross-term dependence of uc1"), -IOP( "pud", BSIM4_MOD_PUD, IF_REAL, "Cross-term dependence of ud"), -IOP( "pud1", BSIM4_MOD_PUD1, IF_REAL, "Cross-term dependence of ud1"), -IOP( "pup", BSIM4_MOD_PUP, IF_REAL, "Cross-term dependence of up"), -IOP( "plp", BSIM4_MOD_PLP, IF_REAL, "Cross-term dependence of lp"), -IOP( "pu0", BSIM4_MOD_PU0, IF_REAL, "Cross-term dependence of u0"), -IOP( "pute", BSIM4_MOD_PUTE, IF_REAL, "Cross-term dependence of ute"), -IOP( "pucste", BSIM4_MOD_PUCSTE, IF_REAL, "Cross-term dependence of ucste"), -IOP( "pvoff", BSIM4_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"), -IOP( "pminv", BSIM4_MOD_PMINV, IF_REAL, "Cross-term dependence of minv"), -IOP( "pminvcv", BSIM4_MOD_PMINVCV, IF_REAL, "Cross-term dependence of minvcv"), -IOP( "pdelta", BSIM4_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"), -IOP( "prdsw", BSIM4_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "), -IOP( "prsw", BSIM4_MOD_PRSW, IF_REAL, "Cross-term dependence of rsw"), -IOP( "prdw", BSIM4_MOD_PRDW, IF_REAL, "Cross-term dependence of rdw"), +IOP( "pcdsc", BSIM4v7_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"), +IOP( "pcdscb", BSIM4v7_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"), +IOP( "pcdscd", BSIM4v7_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"), +IOP( "pcit", BSIM4v7_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"), +IOP( "pnfactor", BSIM4v7_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"), +IOP( "pxj", BSIM4v7_MOD_PXJ, IF_REAL, "Cross-term dependence of xj"), +IOP( "pvsat", BSIM4v7_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"), +IOP( "pat", BSIM4v7_MOD_PAT, IF_REAL, "Cross-term dependence of at"), +IOP( "pa0", BSIM4v7_MOD_PA0, IF_REAL, "Cross-term dependence of a0"), +IOP( "pags", BSIM4v7_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"), +IOP( "pa1", BSIM4v7_MOD_PA1, IF_REAL, "Cross-term dependence of a1"), +IOP( "pa2", BSIM4v7_MOD_PA2, IF_REAL, "Cross-term dependence of a2"), +IOP( "pketa", BSIM4v7_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"), +IOP( "pnsub", BSIM4v7_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"), +IOP( "pndep", BSIM4v7_MOD_PNDEP, IF_REAL, "Cross-term dependence of ndep"), +IOP( "pnsd", BSIM4v7_MOD_PNSD, IF_REAL, "Cross-term dependence of nsd"), +IOP( "pphin", BSIM4v7_MOD_PPHIN, IF_REAL, "Cross-term dependence of phin"), +IOP( "pngate", BSIM4v7_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"), +IOP( "pgamma1", BSIM4v7_MOD_PGAMMA1, IF_REAL, "Cross-term dependence of gamma1"), +IOP( "pgamma2", BSIM4v7_MOD_PGAMMA2, IF_REAL, "Cross-term dependence of gamma2"), +IOP( "pvbx", BSIM4v7_MOD_PVBX, IF_REAL, "Cross-term dependence of vbx"), +IOP( "pvbm", BSIM4v7_MOD_PVBM, IF_REAL, "Cross-term dependence of vbm"), +IOP( "pxt", BSIM4v7_MOD_PXT, IF_REAL, "Cross-term dependence of xt"), +IOP( "pk1", BSIM4v7_MOD_PK1, IF_REAL, "Cross-term dependence of k1"), +IOP( "pkt1", BSIM4v7_MOD_PKT1, IF_REAL, "Cross-term dependence of kt1"), +IOP( "pkt1l", BSIM4v7_MOD_PKT1L, IF_REAL, "Cross-term dependence of kt1l"), +IOP( "pkt2", BSIM4v7_MOD_PKT2, IF_REAL, "Cross-term dependence of kt2"), +IOP( "pk2", BSIM4v7_MOD_PK2, IF_REAL, "Cross-term dependence of k2"), +IOP( "pk3", BSIM4v7_MOD_PK3, IF_REAL, "Cross-term dependence of k3"), +IOP( "pk3b", BSIM4v7_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"), +IOP( "pw0", BSIM4v7_MOD_PW0, IF_REAL, "Cross-term dependence of w0"), +IOP( "pdvtp0", BSIM4v7_MOD_PDVTP0, IF_REAL, "Cross-term dependence of dvtp0"), +IOP( "pdvtp1", BSIM4v7_MOD_PDVTP1, IF_REAL, "Cross-term dependence of dvtp1"), +IOP( "pdvtp2", BSIM4v7_MOD_PDVTP2, IF_REAL, "Cross-term dependence of dvtp2"), +IOP( "pdvtp3", BSIM4v7_MOD_PDVTP3, IF_REAL, "Cross-term dependence of dvtp3"), +IOP( "pdvtp4", BSIM4v7_MOD_PDVTP4, IF_REAL, "Cross-term dependence of dvtp4"), +IOP( "pdvtp5", BSIM4v7_MOD_PDVTP5, IF_REAL, "Cross-term dependence of dvtp5"), +IOP( "plpe0", BSIM4v7_MOD_PLPE0, IF_REAL, "Cross-term dependence of lpe0"), +IOP( "plpeb", BSIM4v7_MOD_PLPEB, IF_REAL, "Cross-term dependence of lpeb"), +IOP( "pdvt0", BSIM4v7_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"), +IOP( "pdvt1", BSIM4v7_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"), +IOP( "pdvt2", BSIM4v7_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"), +IOP( "pdvt0w", BSIM4v7_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"), +IOP( "pdvt1w", BSIM4v7_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"), +IOP( "pdvt2w", BSIM4v7_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"), +IOP( "pdrout", BSIM4v7_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"), +IOP( "pdsub", BSIM4v7_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"), +IOP( "pvth0", BSIM4v7_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"), +IOP( "pvtho", BSIM4v7_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"), +IOP( "pua", BSIM4v7_MOD_PUA, IF_REAL, "Cross-term dependence of ua"), +IOP( "pua1", BSIM4v7_MOD_PUA1, IF_REAL, "Cross-term dependence of ua1"), +IOP( "pub", BSIM4v7_MOD_PUB, IF_REAL, "Cross-term dependence of ub"), +IOP( "pub1", BSIM4v7_MOD_PUB1, IF_REAL, "Cross-term dependence of ub1"), +IOP( "puc", BSIM4v7_MOD_PUC, IF_REAL, "Cross-term dependence of uc"), +IOP( "puc1", BSIM4v7_MOD_PUC1, IF_REAL, "Cross-term dependence of uc1"), +IOP( "pud", BSIM4v7_MOD_PUD, IF_REAL, "Cross-term dependence of ud"), +IOP( "pud1", BSIM4v7_MOD_PUD1, IF_REAL, "Cross-term dependence of ud1"), +IOP( "pup", BSIM4v7_MOD_PUP, IF_REAL, "Cross-term dependence of up"), +IOP( "plp", BSIM4v7_MOD_PLP, IF_REAL, "Cross-term dependence of lp"), +IOP( "pu0", BSIM4v7_MOD_PU0, IF_REAL, "Cross-term dependence of u0"), +IOP( "pute", BSIM4v7_MOD_PUTE, IF_REAL, "Cross-term dependence of ute"), +IOP( "pucste", BSIM4v7_MOD_PUCSTE, IF_REAL, "Cross-term dependence of ucste"), +IOP( "pvoff", BSIM4v7_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"), +IOP( "pminv", BSIM4v7_MOD_PMINV, IF_REAL, "Cross-term dependence of minv"), +IOP( "pminvcv", BSIM4v7_MOD_PMINVCV, IF_REAL, "Cross-term dependence of minvcv"), +IOP( "pdelta", BSIM4v7_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"), +IOP( "prdsw", BSIM4v7_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "), +IOP( "prsw", BSIM4v7_MOD_PRSW, IF_REAL, "Cross-term dependence of rsw"), +IOP( "prdw", BSIM4v7_MOD_PRDW, IF_REAL, "Cross-term dependence of rdw"), -IOP( "pprwg", BSIM4_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "), -IOP( "pprwb", BSIM4_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "), +IOP( "pprwg", BSIM4v7_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "), +IOP( "pprwb", BSIM4v7_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "), -IOP( "pprt", BSIM4_MOD_PPRT, IF_REAL, "Cross-term dependence of prt "), -IOP( "peta0", BSIM4_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"), -IOP( "petab", BSIM4_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"), -IOP( "ppclm", BSIM4_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"), -IOP( "ppdiblc1", BSIM4_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"), -IOP( "ppdiblc2", BSIM4_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"), -IOP( "ppdiblcb", BSIM4_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"), -IOP( "pfprout", BSIM4_MOD_PFPROUT, IF_REAL, "Cross-term dependence of pdiblcb"), -IOP( "ppdits", BSIM4_MOD_PPDITS, IF_REAL, "Cross-term dependence of pdits"), -IOP( "ppditsd", BSIM4_MOD_PPDITSD, IF_REAL, "Cross-term dependence of pditsd"), -IOP( "ppscbe1", BSIM4_MOD_PPSCBE1, IF_REAL, "Cross-term dependence of pscbe1"), -IOP( "ppscbe2", BSIM4_MOD_PPSCBE2, IF_REAL, "Cross-term dependence of pscbe2"), -IOP( "ppvag", BSIM4_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"), -IOP( "pwr", BSIM4_MOD_PWR, IF_REAL, "Cross-term dependence of wr"), -IOP( "pdwg", BSIM4_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"), -IOP( "pdwb", BSIM4_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"), -IOP( "pb0", BSIM4_MOD_PB0, IF_REAL, "Cross-term dependence of b0"), -IOP( "pb1", BSIM4_MOD_PB1, IF_REAL, "Cross-term dependence of b1"), -IOP( "pcgsl", BSIM4_MOD_PCGSL, IF_REAL, "Cross-term dependence of cgsl"), -IOP( "pcgdl", BSIM4_MOD_PCGDL, IF_REAL, "Cross-term dependence of cgdl"), -IOP( "pckappas", BSIM4_MOD_PCKAPPAS, IF_REAL, "Cross-term dependence of ckappas"), -IOP( "pckappad", BSIM4_MOD_PCKAPPAD, IF_REAL, "Cross-term dependence of ckappad"), -IOP( "pcf", BSIM4_MOD_PCF, IF_REAL, "Cross-term dependence of cf"), -IOP( "pclc", BSIM4_MOD_PCLC, IF_REAL, "Cross-term dependence of clc"), -IOP( "pcle", BSIM4_MOD_PCLE, IF_REAL, "Cross-term dependence of cle"), -IOP( "palpha0", BSIM4_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"), -IOP( "palpha1", BSIM4_MOD_PALPHA1, IF_REAL, "Cross-term dependence of alpha1"), -IOP( "pbeta0", BSIM4_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"), +IOP( "pprt", BSIM4v7_MOD_PPRT, IF_REAL, "Cross-term dependence of prt "), +IOP( "peta0", BSIM4v7_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"), +IOP( "petab", BSIM4v7_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"), +IOP( "ppclm", BSIM4v7_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"), +IOP( "ppdiblc1", BSIM4v7_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"), +IOP( "ppdiblc2", BSIM4v7_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"), +IOP( "ppdiblcb", BSIM4v7_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"), +IOP( "pfprout", BSIM4v7_MOD_PFPROUT, IF_REAL, "Cross-term dependence of pdiblcb"), +IOP( "ppdits", BSIM4v7_MOD_PPDITS, IF_REAL, "Cross-term dependence of pdits"), +IOP( "ppditsd", BSIM4v7_MOD_PPDITSD, IF_REAL, "Cross-term dependence of pditsd"), +IOP( "ppscbe1", BSIM4v7_MOD_PPSCBE1, IF_REAL, "Cross-term dependence of pscbe1"), +IOP( "ppscbe2", BSIM4v7_MOD_PPSCBE2, IF_REAL, "Cross-term dependence of pscbe2"), +IOP( "ppvag", BSIM4v7_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"), +IOP( "pwr", BSIM4v7_MOD_PWR, IF_REAL, "Cross-term dependence of wr"), +IOP( "pdwg", BSIM4v7_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"), +IOP( "pdwb", BSIM4v7_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"), +IOP( "pb0", BSIM4v7_MOD_PB0, IF_REAL, "Cross-term dependence of b0"), +IOP( "pb1", BSIM4v7_MOD_PB1, IF_REAL, "Cross-term dependence of b1"), +IOP( "pcgsl", BSIM4v7_MOD_PCGSL, IF_REAL, "Cross-term dependence of cgsl"), +IOP( "pcgdl", BSIM4v7_MOD_PCGDL, IF_REAL, "Cross-term dependence of cgdl"), +IOP( "pckappas", BSIM4v7_MOD_PCKAPPAS, IF_REAL, "Cross-term dependence of ckappas"), +IOP( "pckappad", BSIM4v7_MOD_PCKAPPAD, IF_REAL, "Cross-term dependence of ckappad"), +IOP( "pcf", BSIM4v7_MOD_PCF, IF_REAL, "Cross-term dependence of cf"), +IOP( "pclc", BSIM4v7_MOD_PCLC, IF_REAL, "Cross-term dependence of clc"), +IOP( "pcle", BSIM4v7_MOD_PCLE, IF_REAL, "Cross-term dependence of cle"), +IOP( "palpha0", BSIM4v7_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"), +IOP( "palpha1", BSIM4v7_MOD_PALPHA1, IF_REAL, "Cross-term dependence of alpha1"), +IOP( "pbeta0", BSIM4v7_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"), -IOP( "pagidl", BSIM4_MOD_PAGIDL, IF_REAL, "Cross-term dependence of agidl"), -IOP( "pbgidl", BSIM4_MOD_PBGIDL, IF_REAL, "Cross-term dependence of bgidl"), -IOP( "pcgidl", BSIM4_MOD_PCGIDL, IF_REAL, "Cross-term dependence of cgidl"), -IOP( "prgidl", BSIM4_MOD_PRGIDL, IF_REAL, "Cross-term dependence of rgidl"), /* v4.7 New GIDL/GISL */ -IOP( "pkgidl", BSIM4_MOD_PKGIDL, IF_REAL, "Cross-term dependence of kgidl"), /* v4.7 New GIDL/GISL */ -IOP( "pfgidl", BSIM4_MOD_PFGIDL, IF_REAL, "Cross-term dependence of fgidl"), /* v4.7 New GIDL/GISL */ -IOP( "pegidl", BSIM4_MOD_PEGIDL, IF_REAL, "Cross-term dependence of egidl"), -IOP( "pagisl", BSIM4_MOD_PAGISL, IF_REAL, "Cross-term dependence of agisl"), -IOP( "pbgisl", BSIM4_MOD_PBGISL, IF_REAL, "Cross-term dependence of bgisl"), -IOP( "pcgisl", BSIM4_MOD_PCGISL, IF_REAL, "Cross-term dependence of cgisl"), -IOP( "pegisl", BSIM4_MOD_PEGISL, IF_REAL, "Cross-term dependence of egisl"), -IOP( "prgisl", BSIM4_MOD_PRGISL, IF_REAL, "Cross-term dependence of rgisl"), /* v4.7 New GIDL/GISL */ -IOP( "pkgisl", BSIM4_MOD_PKGISL, IF_REAL, "Cross-term dependence of kgisl"), /* v4.7 New GIDL/GISL */ -IOP( "pfgisl", BSIM4_MOD_PFGISL, IF_REAL, "Cross-term dependence of fgisl"), /* v4.7 New GIDL/GISL */ -IOP( "paigc", BSIM4_MOD_PAIGC, IF_REAL, "Cross-term dependence of aigc"), -IOP( "pbigc", BSIM4_MOD_PBIGC, IF_REAL, "Cross-term dependence of bigc"), -IOP( "pcigc", BSIM4_MOD_PCIGC, IF_REAL, "Cross-term dependence of cigc"), -IOP( "paigsd", BSIM4_MOD_PAIGSD, IF_REAL, "Cross-term dependence of aigsd"), -IOP( "pbigsd", BSIM4_MOD_PBIGSD, IF_REAL, "Cross-term dependence of bigsd"), -IOP( "pcigsd", BSIM4_MOD_PCIGSD, IF_REAL, "Cross-term dependence of cigsd"), -IOP( "paigs", BSIM4_MOD_PAIGS, IF_REAL, "Cross-term dependence of aigs"), -IOP( "pbigs", BSIM4_MOD_PBIGS, IF_REAL, "Cross-term dependence of bigs"), -IOP( "pcigs", BSIM4_MOD_PCIGS, IF_REAL, "Cross-term dependence of cigs"), -IOP( "paigd", BSIM4_MOD_PAIGD, IF_REAL, "Cross-term dependence of aigd"), -IOP( "pbigd", BSIM4_MOD_PBIGD, IF_REAL, "Cross-term dependence of bigd"), -IOP( "pcigd", BSIM4_MOD_PCIGD, IF_REAL, "Cross-term dependence of cigd"), -IOP( "paigbacc", BSIM4_MOD_PAIGBACC, IF_REAL, "Cross-term dependence of aigbacc"), -IOP( "pbigbacc", BSIM4_MOD_PBIGBACC, IF_REAL, "Cross-term dependence of bigbacc"), -IOP( "pcigbacc", BSIM4_MOD_PCIGBACC, IF_REAL, "Cross-term dependence of cigbacc"), -IOP( "paigbinv", BSIM4_MOD_PAIGBINV, IF_REAL, "Cross-term dependence of aigbinv"), -IOP( "pbigbinv", BSIM4_MOD_PBIGBINV, IF_REAL, "Cross-term dependence of bigbinv"), -IOP( "pcigbinv", BSIM4_MOD_PCIGBINV, IF_REAL, "Cross-term dependence of cigbinv"), -IOP( "pnigc", BSIM4_MOD_PNIGC, IF_REAL, "Cross-term dependence of nigc"), -IOP( "pnigbinv", BSIM4_MOD_PNIGBINV, IF_REAL, "Cross-term dependence of nigbinv"), -IOP( "pnigbacc", BSIM4_MOD_PNIGBACC, IF_REAL, "Cross-term dependence of nigbacc"), -IOP( "pntox", BSIM4_MOD_PNTOX, IF_REAL, "Cross-term dependence of ntox"), -IOP( "peigbinv", BSIM4_MOD_PEIGBINV, IF_REAL, "Cross-term dependence for eigbinv"), -IOP( "ppigcd", BSIM4_MOD_PPIGCD, IF_REAL, "Cross-term dependence for pigcd"), -IOP( "ppoxedge", BSIM4_MOD_PPOXEDGE, IF_REAL, "Cross-term dependence for poxedge"), -IOP( "pvfbcv", BSIM4_MOD_PVFBCV, IF_REAL, "Cross-term dependence of vfbcv"), -IOP( "pvfb", BSIM4_MOD_PVFB, IF_REAL, "Cross-term dependence of vfb"), -IOP( "pacde", BSIM4_MOD_PACDE, IF_REAL, "Cross-term dependence of acde"), -IOP( "pmoin", BSIM4_MOD_PMOIN, IF_REAL, "Cross-term dependence of moin"), -IOP( "pnoff", BSIM4_MOD_PNOFF, IF_REAL, "Cross-term dependence of noff"), -IOP( "pvoffcv", BSIM4_MOD_PVOFFCV, IF_REAL, "Cross-term dependence of voffcv"), -IOP( "pxrcrg1", BSIM4_MOD_PXRCRG1, IF_REAL, "Cross-term dependence of xrcrg1"), -IOP( "pxrcrg2", BSIM4_MOD_PXRCRG2, IF_REAL, "Cross-term dependence of xrcrg2"), -IOP( "plambda", BSIM4_MOD_PLAMBDA, IF_REAL, "Cross-term dependence of lambda"), -IOP( "pvtl", BSIM4_MOD_PVTL, IF_REAL, "Cross-term dependence of vtl"), -IOP( "pxn", BSIM4_MOD_PXN, IF_REAL, "Cross-term dependence of xn"), -IOP( "peu", BSIM4_MOD_PEU, IF_REAL, "Cross-term dependence of eu"), -IOP( "pucs", BSIM4_MOD_PUCS, IF_REAL, "Cross-term dependence of ucs"), -IOP( "pvfbsdoff", BSIM4_MOD_PVFBSDOFF, IF_REAL, "Cross-term dependence of vfbsdoff"), -IOP( "ptvfbsdoff", BSIM4_MOD_PTVFBSDOFF, IF_REAL, "Cross-term dependence of tvfbsdoff"), -IOP( "ptvoff", BSIM4_MOD_PTVOFF, IF_REAL, "Cross-term dependence of tvoff"), -IOP( "ptnfactor", BSIM4_MOD_PTNFACTOR, IF_REAL, "Cross-term dependence of tnfactor"), /* v4.7 Tanvir*/ -IOP( "pteta0", BSIM4_MOD_PTETA0, IF_REAL, "Cross-term dependence of teta0"), /* v4.7 Tanvir*/ -IOP( "ptvoffcv", BSIM4_MOD_PTVOFFCV, IF_REAL, "Cross-term dependence of tvoffcv"), /* v4.7 Tanvir*/ +IOP( "pagidl", BSIM4v7_MOD_PAGIDL, IF_REAL, "Cross-term dependence of agidl"), +IOP( "pbgidl", BSIM4v7_MOD_PBGIDL, IF_REAL, "Cross-term dependence of bgidl"), +IOP( "pcgidl", BSIM4v7_MOD_PCGIDL, IF_REAL, "Cross-term dependence of cgidl"), +IOP( "prgidl", BSIM4v7_MOD_PRGIDL, IF_REAL, "Cross-term dependence of rgidl"), /* v4.7 New GIDL/GISL */ +IOP( "pkgidl", BSIM4v7_MOD_PKGIDL, IF_REAL, "Cross-term dependence of kgidl"), /* v4.7 New GIDL/GISL */ +IOP( "pfgidl", BSIM4v7_MOD_PFGIDL, IF_REAL, "Cross-term dependence of fgidl"), /* v4.7 New GIDL/GISL */ +IOP( "pegidl", BSIM4v7_MOD_PEGIDL, IF_REAL, "Cross-term dependence of egidl"), +IOP( "pagisl", BSIM4v7_MOD_PAGISL, IF_REAL, "Cross-term dependence of agisl"), +IOP( "pbgisl", BSIM4v7_MOD_PBGISL, IF_REAL, "Cross-term dependence of bgisl"), +IOP( "pcgisl", BSIM4v7_MOD_PCGISL, IF_REAL, "Cross-term dependence of cgisl"), +IOP( "pegisl", BSIM4v7_MOD_PEGISL, IF_REAL, "Cross-term dependence of egisl"), +IOP( "prgisl", BSIM4v7_MOD_PRGISL, IF_REAL, "Cross-term dependence of rgisl"), /* v4.7 New GIDL/GISL */ +IOP( "pkgisl", BSIM4v7_MOD_PKGISL, IF_REAL, "Cross-term dependence of kgisl"), /* v4.7 New GIDL/GISL */ +IOP( "pfgisl", BSIM4v7_MOD_PFGISL, IF_REAL, "Cross-term dependence of fgisl"), /* v4.7 New GIDL/GISL */ +IOP( "paigc", BSIM4v7_MOD_PAIGC, IF_REAL, "Cross-term dependence of aigc"), +IOP( "pbigc", BSIM4v7_MOD_PBIGC, IF_REAL, "Cross-term dependence of bigc"), +IOP( "pcigc", BSIM4v7_MOD_PCIGC, IF_REAL, "Cross-term dependence of cigc"), +IOP( "paigsd", BSIM4v7_MOD_PAIGSD, IF_REAL, "Cross-term dependence of aigsd"), +IOP( "pbigsd", BSIM4v7_MOD_PBIGSD, IF_REAL, "Cross-term dependence of bigsd"), +IOP( "pcigsd", BSIM4v7_MOD_PCIGSD, IF_REAL, "Cross-term dependence of cigsd"), +IOP( "paigs", BSIM4v7_MOD_PAIGS, IF_REAL, "Cross-term dependence of aigs"), +IOP( "pbigs", BSIM4v7_MOD_PBIGS, IF_REAL, "Cross-term dependence of bigs"), +IOP( "pcigs", BSIM4v7_MOD_PCIGS, IF_REAL, "Cross-term dependence of cigs"), +IOP( "paigd", BSIM4v7_MOD_PAIGD, IF_REAL, "Cross-term dependence of aigd"), +IOP( "pbigd", BSIM4v7_MOD_PBIGD, IF_REAL, "Cross-term dependence of bigd"), +IOP( "pcigd", BSIM4v7_MOD_PCIGD, IF_REAL, "Cross-term dependence of cigd"), +IOP( "paigbacc", BSIM4v7_MOD_PAIGBACC, IF_REAL, "Cross-term dependence of aigbacc"), +IOP( "pbigbacc", BSIM4v7_MOD_PBIGBACC, IF_REAL, "Cross-term dependence of bigbacc"), +IOP( "pcigbacc", BSIM4v7_MOD_PCIGBACC, IF_REAL, "Cross-term dependence of cigbacc"), +IOP( "paigbinv", BSIM4v7_MOD_PAIGBINV, IF_REAL, "Cross-term dependence of aigbinv"), +IOP( "pbigbinv", BSIM4v7_MOD_PBIGBINV, IF_REAL, "Cross-term dependence of bigbinv"), +IOP( "pcigbinv", BSIM4v7_MOD_PCIGBINV, IF_REAL, "Cross-term dependence of cigbinv"), +IOP( "pnigc", BSIM4v7_MOD_PNIGC, IF_REAL, "Cross-term dependence of nigc"), +IOP( "pnigbinv", BSIM4v7_MOD_PNIGBINV, IF_REAL, "Cross-term dependence of nigbinv"), +IOP( "pnigbacc", BSIM4v7_MOD_PNIGBACC, IF_REAL, "Cross-term dependence of nigbacc"), +IOP( "pntox", BSIM4v7_MOD_PNTOX, IF_REAL, "Cross-term dependence of ntox"), +IOP( "peigbinv", BSIM4v7_MOD_PEIGBINV, IF_REAL, "Cross-term dependence for eigbinv"), +IOP( "ppigcd", BSIM4v7_MOD_PPIGCD, IF_REAL, "Cross-term dependence for pigcd"), +IOP( "ppoxedge", BSIM4v7_MOD_PPOXEDGE, IF_REAL, "Cross-term dependence for poxedge"), +IOP( "pvfbcv", BSIM4v7_MOD_PVFBCV, IF_REAL, "Cross-term dependence of vfbcv"), +IOP( "pvfb", BSIM4v7_MOD_PVFB, IF_REAL, "Cross-term dependence of vfb"), +IOP( "pacde", BSIM4v7_MOD_PACDE, IF_REAL, "Cross-term dependence of acde"), +IOP( "pmoin", BSIM4v7_MOD_PMOIN, IF_REAL, "Cross-term dependence of moin"), +IOP( "pnoff", BSIM4v7_MOD_PNOFF, IF_REAL, "Cross-term dependence of noff"), +IOP( "pvoffcv", BSIM4v7_MOD_PVOFFCV, IF_REAL, "Cross-term dependence of voffcv"), +IOP( "pxrcrg1", BSIM4v7_MOD_PXRCRG1, IF_REAL, "Cross-term dependence of xrcrg1"), +IOP( "pxrcrg2", BSIM4v7_MOD_PXRCRG2, IF_REAL, "Cross-term dependence of xrcrg2"), +IOP( "plambda", BSIM4v7_MOD_PLAMBDA, IF_REAL, "Cross-term dependence of lambda"), +IOP( "pvtl", BSIM4v7_MOD_PVTL, IF_REAL, "Cross-term dependence of vtl"), +IOP( "pxn", BSIM4v7_MOD_PXN, IF_REAL, "Cross-term dependence of xn"), +IOP( "peu", BSIM4v7_MOD_PEU, IF_REAL, "Cross-term dependence of eu"), +IOP( "pucs", BSIM4v7_MOD_PUCS, IF_REAL, "Cross-term dependence of ucs"), +IOP( "pvfbsdoff", BSIM4v7_MOD_PVFBSDOFF, IF_REAL, "Cross-term dependence of vfbsdoff"), +IOP( "ptvfbsdoff", BSIM4v7_MOD_PTVFBSDOFF, IF_REAL, "Cross-term dependence of tvfbsdoff"), +IOP( "ptvoff", BSIM4v7_MOD_PTVOFF, IF_REAL, "Cross-term dependence of tvoff"), +IOP( "ptnfactor", BSIM4v7_MOD_PTNFACTOR, IF_REAL, "Cross-term dependence of tnfactor"), /* v4.7 Tanvir*/ +IOP( "pteta0", BSIM4v7_MOD_PTETA0, IF_REAL, "Cross-term dependence of teta0"), /* v4.7 Tanvir*/ +IOP( "ptvoffcv", BSIM4v7_MOD_PTVOFFCV, IF_REAL, "Cross-term dependence of tvoffcv"), /* v4.7 Tanvir*/ /* stress effect*/ -IOP( "saref", BSIM4_MOD_SAREF, IF_REAL, "Reference distance between OD edge to poly of one side"), -IOP( "sbref", BSIM4_MOD_SBREF, IF_REAL, "Reference distance between OD edge to poly of the other side"), -IOP( "wlod", BSIM4_MOD_WLOD, IF_REAL, "Width parameter for stress effect"), -IOP( "ku0", BSIM4_MOD_KU0, IF_REAL, "Mobility degradation/enhancement coefficient for LOD"), -IOP( "kvsat", BSIM4_MOD_KVSAT, IF_REAL, "Saturation velocity degradation/enhancement parameter for LOD"), -IOP( "kvth0", BSIM4_MOD_KVTH0, IF_REAL, "Threshold degradation/enhancement parameter for LOD"), -IOP( "tku0", BSIM4_MOD_TKU0, IF_REAL, "Temperature coefficient of KU0"), -IOP( "llodku0", BSIM4_MOD_LLODKU0, IF_REAL, "Length parameter for u0 LOD effect"), -IOP( "wlodku0", BSIM4_MOD_WLODKU0, IF_REAL, "Width parameter for u0 LOD effect"), -IOP( "llodvth", BSIM4_MOD_LLODVTH, IF_REAL, "Length parameter for vth LOD effect"), -IOP( "wlodvth", BSIM4_MOD_WLODVTH, IF_REAL, "Width parameter for vth LOD effect"), -IOP( "lku0", BSIM4_MOD_LKU0, IF_REAL, "Length dependence of ku0"), -IOP( "wku0", BSIM4_MOD_WKU0, IF_REAL, "Width dependence of ku0"), -IOP( "pku0", BSIM4_MOD_PKU0, IF_REAL, "Cross-term dependence of ku0"), -IOP( "lkvth0", BSIM4_MOD_LKVTH0, IF_REAL, "Length dependence of kvth0"), -IOP( "wkvth0", BSIM4_MOD_WKVTH0, IF_REAL, "Width dependence of kvth0"), -IOP( "pkvth0", BSIM4_MOD_PKVTH0, IF_REAL, "Cross-term dependence of kvth0"), -IOP( "stk2", BSIM4_MOD_STK2, IF_REAL, "K2 shift factor related to stress effect on vth"), -IOP( "lodk2", BSIM4_MOD_LODK2, IF_REAL, "K2 shift modification factor for stress effect"), -IOP( "steta0", BSIM4_MOD_STETA0, IF_REAL, "eta0 shift factor related to stress effect on vth"), -IOP( "lodeta0", BSIM4_MOD_LODETA0, IF_REAL, "eta0 shift modification factor for stress effect"), +IOP( "saref", BSIM4v7_MOD_SAREF, IF_REAL, "Reference distance between OD edge to poly of one side"), +IOP( "sbref", BSIM4v7_MOD_SBREF, IF_REAL, "Reference distance between OD edge to poly of the other side"), +IOP( "wlod", BSIM4v7_MOD_WLOD, IF_REAL, "Width parameter for stress effect"), +IOP( "ku0", BSIM4v7_MOD_KU0, IF_REAL, "Mobility degradation/enhancement coefficient for LOD"), +IOP( "kvsat", BSIM4v7_MOD_KVSAT, IF_REAL, "Saturation velocity degradation/enhancement parameter for LOD"), +IOP( "kvth0", BSIM4v7_MOD_KVTH0, IF_REAL, "Threshold degradation/enhancement parameter for LOD"), +IOP( "tku0", BSIM4v7_MOD_TKU0, IF_REAL, "Temperature coefficient of KU0"), +IOP( "llodku0", BSIM4v7_MOD_LLODKU0, IF_REAL, "Length parameter for u0 LOD effect"), +IOP( "wlodku0", BSIM4v7_MOD_WLODKU0, IF_REAL, "Width parameter for u0 LOD effect"), +IOP( "llodvth", BSIM4v7_MOD_LLODVTH, IF_REAL, "Length parameter for vth LOD effect"), +IOP( "wlodvth", BSIM4v7_MOD_WLODVTH, IF_REAL, "Width parameter for vth LOD effect"), +IOP( "lku0", BSIM4v7_MOD_LKU0, IF_REAL, "Length dependence of ku0"), +IOP( "wku0", BSIM4v7_MOD_WKU0, IF_REAL, "Width dependence of ku0"), +IOP( "pku0", BSIM4v7_MOD_PKU0, IF_REAL, "Cross-term dependence of ku0"), +IOP( "lkvth0", BSIM4v7_MOD_LKVTH0, IF_REAL, "Length dependence of kvth0"), +IOP( "wkvth0", BSIM4v7_MOD_WKVTH0, IF_REAL, "Width dependence of kvth0"), +IOP( "pkvth0", BSIM4v7_MOD_PKVTH0, IF_REAL, "Cross-term dependence of kvth0"), +IOP( "stk2", BSIM4v7_MOD_STK2, IF_REAL, "K2 shift factor related to stress effect on vth"), +IOP( "lodk2", BSIM4v7_MOD_LODK2, IF_REAL, "K2 shift modification factor for stress effect"), +IOP( "steta0", BSIM4v7_MOD_STETA0, IF_REAL, "eta0 shift factor related to stress effect on vth"), +IOP( "lodeta0", BSIM4v7_MOD_LODETA0, IF_REAL, "eta0 shift modification factor for stress effect"), /* Well Proximity Effect */ -IOP( "web", BSIM4_MOD_WEB, IF_REAL, "Coefficient for SCB"), -IOP( "wec", BSIM4_MOD_WEC, IF_REAL, "Coefficient for SCC"), -IOP( "kvth0we", BSIM4_MOD_KVTH0WE, IF_REAL, "Threshold shift factor for well proximity effect"), -IOP( "k2we", BSIM4_MOD_K2WE, IF_REAL, " K2 shift factor for well proximity effect "), -IOP( "ku0we", BSIM4_MOD_KU0WE, IF_REAL, " Mobility degradation factor for well proximity effect "), -IOP( "scref", BSIM4_MOD_SCREF, IF_REAL, " Reference distance to calculate SCA, SCB and SCC"), -IOP( "wpemod", BSIM4_MOD_WPEMOD, IF_REAL, " Flag for WPE model (WPEMOD=1 to activate this model) "), -IOP( "lkvth0we", BSIM4_MOD_LKVTH0WE, IF_REAL, "Length dependence of kvth0we"), -IOP( "lk2we", BSIM4_MOD_LK2WE, IF_REAL, " Length dependence of k2we "), -IOP( "lku0we", BSIM4_MOD_LKU0WE, IF_REAL, " Length dependence of ku0we "), -IOP( "wkvth0we", BSIM4_MOD_WKVTH0WE, IF_REAL, "Width dependence of kvth0we"), -IOP( "wk2we", BSIM4_MOD_WK2WE, IF_REAL, " Width dependence of k2we "), -IOP( "wku0we", BSIM4_MOD_WKU0WE, IF_REAL, " Width dependence of ku0we "), -IOP( "pkvth0we", BSIM4_MOD_PKVTH0WE, IF_REAL, "Cross-term dependence of kvth0we"), -IOP( "pk2we", BSIM4_MOD_PK2WE, IF_REAL, " Cross-term dependence of k2we "), -IOP( "pku0we", BSIM4_MOD_PKU0WE, IF_REAL, " Cross-term dependence of ku0we "), +IOP( "web", BSIM4v7_MOD_WEB, IF_REAL, "Coefficient for SCB"), +IOP( "wec", BSIM4v7_MOD_WEC, IF_REAL, "Coefficient for SCC"), +IOP( "kvth0we", BSIM4v7_MOD_KVTH0WE, IF_REAL, "Threshold shift factor for well proximity effect"), +IOP( "k2we", BSIM4v7_MOD_K2WE, IF_REAL, " K2 shift factor for well proximity effect "), +IOP( "ku0we", BSIM4v7_MOD_KU0WE, IF_REAL, " Mobility degradation factor for well proximity effect "), +IOP( "scref", BSIM4v7_MOD_SCREF, IF_REAL, " Reference distance to calculate SCA, SCB and SCC"), +IOP( "wpemod", BSIM4v7_MOD_WPEMOD, IF_REAL, " Flag for WPE model (WPEMOD=1 to activate this model) "), +IOP( "lkvth0we", BSIM4v7_MOD_LKVTH0WE, IF_REAL, "Length dependence of kvth0we"), +IOP( "lk2we", BSIM4v7_MOD_LK2WE, IF_REAL, " Length dependence of k2we "), +IOP( "lku0we", BSIM4v7_MOD_LKU0WE, IF_REAL, " Length dependence of ku0we "), +IOP( "wkvth0we", BSIM4v7_MOD_WKVTH0WE, IF_REAL, "Width dependence of kvth0we"), +IOP( "wk2we", BSIM4v7_MOD_WK2WE, IF_REAL, " Width dependence of k2we "), +IOP( "wku0we", BSIM4v7_MOD_WKU0WE, IF_REAL, " Width dependence of ku0we "), +IOP( "pkvth0we", BSIM4v7_MOD_PKVTH0WE, IF_REAL, "Cross-term dependence of kvth0we"), +IOP( "pk2we", BSIM4v7_MOD_PK2WE, IF_REAL, " Cross-term dependence of k2we "), +IOP( "pku0we", BSIM4v7_MOD_PKU0WE, IF_REAL, " Cross-term dependence of ku0we "), -IOP( "noia", BSIM4_MOD_NOIA, IF_REAL, "Flicker noise parameter"), -IOP( "noib", BSIM4_MOD_NOIB, IF_REAL, "Flicker noise parameter"), -IOP( "noic", BSIM4_MOD_NOIC, IF_REAL, "Flicker noise parameter"), -IOP( "tnoia", BSIM4_MOD_TNOIA, IF_REAL, "Thermal noise parameter"), -IOP( "tnoib", BSIM4_MOD_TNOIB, IF_REAL, "Thermal noise parameter"), -IOP( "tnoic", BSIM4_MOD_TNOIC, IF_REAL, "Thermal noise parameter"), -IOP( "rnoia", BSIM4_MOD_RNOIA, IF_REAL, "Thermal noise coefficient"), -IOP( "rnoib", BSIM4_MOD_RNOIB, IF_REAL, "Thermal noise coefficient"), -IOP( "rnoic", BSIM4_MOD_RNOIC, IF_REAL, "Thermal noise coefficient"), -IOP( "ntnoi", BSIM4_MOD_NTNOI, IF_REAL, "Thermal noise parameter"), -IOP( "em", BSIM4_MOD_EM, IF_REAL, "Flicker noise parameter"), -IOP( "ef", BSIM4_MOD_EF, IF_REAL, "Flicker noise frequency exponent"), -IOP( "af", BSIM4_MOD_AF, IF_REAL, "Flicker noise exponent"), -IOP( "kf", BSIM4_MOD_KF, IF_REAL, "Flicker noise coefficient"), +IOP( "noia", BSIM4v7_MOD_NOIA, IF_REAL, "Flicker noise parameter"), +IOP( "noib", BSIM4v7_MOD_NOIB, IF_REAL, "Flicker noise parameter"), +IOP( "noic", BSIM4v7_MOD_NOIC, IF_REAL, "Flicker noise parameter"), +IOP( "tnoia", BSIM4v7_MOD_TNOIA, IF_REAL, "Thermal noise parameter"), +IOP( "tnoib", BSIM4v7_MOD_TNOIB, IF_REAL, "Thermal noise parameter"), +IOP( "tnoic", BSIM4v7_MOD_TNOIC, IF_REAL, "Thermal noise parameter"), +IOP( "rnoia", BSIM4v7_MOD_RNOIA, IF_REAL, "Thermal noise coefficient"), +IOP( "rnoib", BSIM4v7_MOD_RNOIB, IF_REAL, "Thermal noise coefficient"), +IOP( "rnoic", BSIM4v7_MOD_RNOIC, IF_REAL, "Thermal noise coefficient"), +IOP( "ntnoi", BSIM4v7_MOD_NTNOI, IF_REAL, "Thermal noise parameter"), +IOP( "em", BSIM4v7_MOD_EM, IF_REAL, "Flicker noise parameter"), +IOP( "ef", BSIM4v7_MOD_EF, IF_REAL, "Flicker noise frequency exponent"), +IOP( "af", BSIM4v7_MOD_AF, IF_REAL, "Flicker noise exponent"), +IOP( "kf", BSIM4v7_MOD_KF, IF_REAL, "Flicker noise coefficient"), -IOP("vgs_max", BSIM4_MOD_VGS_MAX, IF_REAL, "maximum voltage G-S branch"), -IOP("vgd_max", BSIM4_MOD_VGD_MAX, IF_REAL, "maximum voltage G-D branch"), -IOP("vgb_max", BSIM4_MOD_VGB_MAX, IF_REAL, "maximum voltage G-B branch"), -IOP("vds_max", BSIM4_MOD_VDS_MAX, IF_REAL, "maximum voltage D-S branch"), -IOP("vbs_max", BSIM4_MOD_VBS_MAX, IF_REAL, "maximum voltage B-S branch"), -IOP("vbd_max", BSIM4_MOD_VBD_MAX, IF_REAL, "maximum voltage B-D branch"), +IOP("vgs_max", BSIM4v7_MOD_VGS_MAX, IF_REAL, "maximum voltage G-S branch"), +IOP("vgd_max", BSIM4v7_MOD_VGD_MAX, IF_REAL, "maximum voltage G-D branch"), +IOP("vgb_max", BSIM4v7_MOD_VGB_MAX, IF_REAL, "maximum voltage G-B branch"), +IOP("vds_max", BSIM4v7_MOD_VDS_MAX, IF_REAL, "maximum voltage D-S branch"), +IOP("vbs_max", BSIM4v7_MOD_VBS_MAX, IF_REAL, "maximum voltage B-S branch"), +IOP("vbd_max", BSIM4v7_MOD_VBD_MAX, IF_REAL, "maximum voltage B-D branch"), -IP( "nmos", BSIM4_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"), -IP( "pmos", BSIM4_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"), +IP( "nmos", BSIM4v7_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"), +IP( "pmos", BSIM4v7_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"), }; -char *BSIM4names[] = { +char *BSIM4v7names[] = { "Drain", "Gate", "Source", @@ -1050,8 +1050,8 @@ char *BSIM4names[] = { "Charge" }; -int BSIM4nSize = NUMELEMS(BSIM4names); -int BSIM4pTSize = NUMELEMS(BSIM4pTable); -int BSIM4mPTSize = NUMELEMS(BSIM4mPTable); -int BSIM4iSize = sizeof(BSIM4instance); -int BSIM4mSize = sizeof(BSIM4model); +int BSIM4v7nSize = NUMELEMS(BSIM4v7names); +int BSIM4v7pTSize = NUMELEMS(BSIM4v7pTable); +int BSIM4v7mPTSize = NUMELEMS(BSIM4v7mPTable); +int BSIM4v7iSize = sizeof(BSIM4v7instance); +int BSIM4v7mSize = sizeof(BSIM4v7model); diff --git a/src/spicelib/devices/bsim4v7/b4v7acld.c b/src/spicelib/devices/bsim4v7/b4v7acld.c index ca363e394..00a16c107 100644 --- a/src/spicelib/devices/bsim4v7/b4v7acld.c +++ b/src/spicelib/devices/bsim4v7/b4v7acld.c @@ -13,18 +13,18 @@ #include "ngspice/ngspice.h" #include "ngspice/cktdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" int -BSIM4acLoad( +BSIM4v7acLoad( GENmodel *inModel, CKTcircuit *ckt) { -BSIM4model *model = (BSIM4model*)inModel; -BSIM4instance *here; +BSIM4v7model *model = (BSIM4v7model*)inModel; +BSIM4v7instance *here; double gjbd, gjbs, geltd, gcrg, gcrgg, gcrgd, gcrgs, gcrgb; double xcbgb, xcbdb, xcbsb, xcbbb; @@ -57,44 +57,44 @@ double ggidld, ggidlg, ggidlb, ggislg, ggislb, ggisls; double m; omega = ckt->CKTomega; - for (; model != NULL; model = model->BSIM4nextModel) - { for (here = model->BSIM4instances; here!= NULL; - here = here->BSIM4nextInstance) + for (; model != NULL; model = model->BSIM4v7nextModel) + { for (here = model->BSIM4v7instances; here!= NULL; + here = here->BSIM4v7nextInstance) { pParam = here->pParam; - capbd = here->BSIM4capbd; - capbs = here->BSIM4capbs; - cgso = here->BSIM4cgso; - cgdo = here->BSIM4cgdo; - cgbo = pParam->BSIM4cgbo; + capbd = here->BSIM4v7capbd; + capbs = here->BSIM4v7capbs; + cgso = here->BSIM4v7cgso; + cgdo = here->BSIM4v7cgdo; + cgbo = pParam->BSIM4v7cgbo; - Csd = -(here->BSIM4cddb + here->BSIM4cgdb + here->BSIM4cbdb); - Csg = -(here->BSIM4cdgb + here->BSIM4cggb + here->BSIM4cbgb); - Css = -(here->BSIM4cdsb + here->BSIM4cgsb + here->BSIM4cbsb); + Csd = -(here->BSIM4v7cddb + here->BSIM4v7cgdb + here->BSIM4v7cbdb); + Csg = -(here->BSIM4v7cdgb + here->BSIM4v7cggb + here->BSIM4v7cbgb); + Css = -(here->BSIM4v7cdsb + here->BSIM4v7cgsb + here->BSIM4v7cbsb); - if (here->BSIM4acnqsMod) - { T0 = omega * here->BSIM4taunet; + if (here->BSIM4v7acnqsMod) + { T0 = omega * here->BSIM4v7taunet; T1 = T0 * T0; T2 = 1.0 / (1.0 + T1); T3 = T0 * T2; - gmr = here->BSIM4gm * T2; - gmbsr = here->BSIM4gmbs * T2; - gdsr = here->BSIM4gds * T2; + gmr = here->BSIM4v7gm * T2; + gmbsr = here->BSIM4v7gmbs * T2; + gdsr = here->BSIM4v7gds * T2; - gmi = -here->BSIM4gm * T3; - gmbsi = -here->BSIM4gmbs * T3; - gdsi = -here->BSIM4gds * T3; + gmi = -here->BSIM4v7gm * T3; + gmbsi = -here->BSIM4v7gmbs * T3; + gdsi = -here->BSIM4v7gds * T3; - Cddr = here->BSIM4cddb * T2; - Cdgr = here->BSIM4cdgb * T2; - Cdsr = here->BSIM4cdsb * T2; + Cddr = here->BSIM4v7cddb * T2; + Cdgr = here->BSIM4v7cdgb * T2; + Cdsr = here->BSIM4v7cdsb * T2; Cdbr = -(Cddr + Cdgr + Cdsr); /* WDLiu: Cxyi mulitplied by jomega below, and actually to be of conductance */ - Cddi = here->BSIM4cddb * T3 * omega; - Cdgi = here->BSIM4cdgb * T3 * omega; - Cdsi = here->BSIM4cdsb * T3 * omega; + Cddi = here->BSIM4v7cddb * T3 * omega; + Cdgi = here->BSIM4v7cdgb * T3 * omega; + Cdsi = here->BSIM4v7cdsb * T3 * omega; Cdbi = -(Cddi + Cdgi + Cdsi); Csdr = Csd * T2; @@ -107,9 +107,9 @@ double m; Cssi = Css * T3 * omega; Csbi = -(Csdi + Csgi + Cssi); - Cgdr = -(Cddr + Csdr + here->BSIM4cbdb); - Cggr = -(Cdgr + Csgr + here->BSIM4cbgb); - Cgsr = -(Cdsr + Cssr + here->BSIM4cbsb); + Cgdr = -(Cddr + Csdr + here->BSIM4v7cbdb); + Cggr = -(Cdgr + Csgr + here->BSIM4v7cbgb); + Cgsr = -(Cdsr + Cssr + here->BSIM4v7cbsb); Cgbr = -(Cgdr + Cggr + Cgsr); Cgdi = -(Cddi + Csdi); @@ -118,14 +118,14 @@ double m; Cgbi = -(Cgdi + Cggi + Cgsi); } else /* QS */ - { gmr = here->BSIM4gm; - gmbsr = here->BSIM4gmbs; - gdsr = here->BSIM4gds; + { gmr = here->BSIM4v7gm; + gmbsr = here->BSIM4v7gmbs; + gdsr = here->BSIM4v7gds; gmi = gmbsi = gdsi = 0.0; - Cddr = here->BSIM4cddb; - Cdgr = here->BSIM4cdgb; - Cdsr = here->BSIM4cdsb; + Cddr = here->BSIM4v7cddb; + Cdgr = here->BSIM4v7cdgb; + Cdsr = here->BSIM4v7cdsb; Cdbr = -(Cddr + Cdgr + Cdsr); Cddi = Cdgi = Cdsi = Cdbi = 0.0; @@ -135,15 +135,15 @@ double m; Csbr = -(Csdr + Csgr + Cssr); Csdi = Csgi = Cssi = Csbi = 0.0; - Cgdr = here->BSIM4cgdb; - Cggr = here->BSIM4cggb; - Cgsr = here->BSIM4cgsb; + Cgdr = here->BSIM4v7cgdb; + Cggr = here->BSIM4v7cggb; + Cgsr = here->BSIM4v7cgsb; Cgbr = -(Cgdr + Cggr + Cgsr); Cgdi = Cggi = Cgsi = Cgbi = 0.0; } - if (here->BSIM4mode >= 0) + if (here->BSIM4v7mode >= 0) { Gmr = gmr; Gmbsr = gmbsr; FwdSumr = Gmr + Gmbsr; @@ -153,11 +153,11 @@ double m; FwdSumi = Gmi + Gmbsi; RevSumi = 0.0; - gbbdp = -(here->BSIM4gbds); - gbbsp = here->BSIM4gbds + here->BSIM4gbgs + here->BSIM4gbbs; - gbdpg = here->BSIM4gbgs; - gbdpdp = here->BSIM4gbds; - gbdpb = here->BSIM4gbbs; + gbbdp = -(here->BSIM4v7gbds); + gbbsp = here->BSIM4v7gbds + here->BSIM4v7gbgs + here->BSIM4v7gbbs; + gbdpg = here->BSIM4v7gbgs; + gbdpdp = here->BSIM4v7gbds; + gbdpb = here->BSIM4v7gbbs; gbdpsp = -(gbdpg + gbdpdp + gbdpb); gbspdp = 0.0; @@ -165,32 +165,32 @@ double m; gbspb = 0.0; gbspsp = 0.0; - if (model->BSIM4igcMod) - { gIstotg = here->BSIM4gIgsg + here->BSIM4gIgcsg; - gIstotd = here->BSIM4gIgcsd; - gIstots = here->BSIM4gIgss + here->BSIM4gIgcss; - gIstotb = here->BSIM4gIgcsb; + if (model->BSIM4v7igcMod) + { gIstotg = here->BSIM4v7gIgsg + here->BSIM4v7gIgcsg; + gIstotd = here->BSIM4v7gIgcsd; + gIstots = here->BSIM4v7gIgss + here->BSIM4v7gIgcss; + gIstotb = here->BSIM4v7gIgcsb; - gIdtotg = here->BSIM4gIgdg + here->BSIM4gIgcdg; - gIdtotd = here->BSIM4gIgdd + here->BSIM4gIgcdd; - gIdtots = here->BSIM4gIgcds; - gIdtotb = here->BSIM4gIgcdb; + gIdtotg = here->BSIM4v7gIgdg + here->BSIM4v7gIgcdg; + gIdtotd = here->BSIM4v7gIgdd + here->BSIM4v7gIgcdd; + gIdtots = here->BSIM4v7gIgcds; + gIdtotb = here->BSIM4v7gIgcdb; } else { gIstotg = gIstotd = gIstots = gIstotb = 0.0; gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0; } - if (model->BSIM4igbMod) - { gIbtotg = here->BSIM4gIgbg; - gIbtotd = here->BSIM4gIgbd; - gIbtots = here->BSIM4gIgbs; - gIbtotb = here->BSIM4gIgbb; + if (model->BSIM4v7igbMod) + { gIbtotg = here->BSIM4v7gIgbg; + gIbtotd = here->BSIM4v7gIgbd; + gIbtots = here->BSIM4v7gIgbs; + gIbtotb = here->BSIM4v7gIgbb; } else gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0; - if ((model->BSIM4igcMod != 0) || (model->BSIM4igbMod != 0)) + if ((model->BSIM4v7igcMod != 0) || (model->BSIM4v7igbMod != 0)) { gIgtotg = gIstotg + gIdtotg + gIbtotg; gIgtotd = gIstotd + gIdtotd + gIbtotd ; gIgtots = gIstots + gIdtots + gIbtots; @@ -199,28 +199,28 @@ double m; else gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0; - if (here->BSIM4rgateMod == 2) - T0 = *(ckt->CKTstates[0] + here->BSIM4vges) - - *(ckt->CKTstates[0] + here->BSIM4vgs); - else if (here->BSIM4rgateMod == 3) - T0 = *(ckt->CKTstates[0] + here->BSIM4vgms) - - *(ckt->CKTstates[0] + here->BSIM4vgs); - if (here->BSIM4rgateMod > 1) - { gcrgd = here->BSIM4gcrgd * T0; - gcrgg = here->BSIM4gcrgg * T0; - gcrgs = here->BSIM4gcrgs * T0; - gcrgb = here->BSIM4gcrgb * T0; - gcrgg -= here->BSIM4gcrg; - gcrg = here->BSIM4gcrg; + if (here->BSIM4v7rgateMod == 2) + T0 = *(ckt->CKTstates[0] + here->BSIM4v7vges) + - *(ckt->CKTstates[0] + here->BSIM4v7vgs); + else if (here->BSIM4v7rgateMod == 3) + T0 = *(ckt->CKTstates[0] + here->BSIM4v7vgms) + - *(ckt->CKTstates[0] + here->BSIM4v7vgs); + if (here->BSIM4v7rgateMod > 1) + { gcrgd = here->BSIM4v7gcrgd * T0; + gcrgg = here->BSIM4v7gcrgg * T0; + gcrgs = here->BSIM4v7gcrgs * T0; + gcrgb = here->BSIM4v7gcrgb * T0; + gcrgg -= here->BSIM4v7gcrg; + gcrg = here->BSIM4v7gcrg; } else gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0; - if (here->BSIM4rgateMod == 3) - { xcgmgmb = (cgdo + cgso + pParam->BSIM4cgbo) * omega; + if (here->BSIM4v7rgateMod == 3) + { xcgmgmb = (cgdo + cgso + pParam->BSIM4v7cgbo) * omega; xcgmdb = -cgdo * omega; xcgmsb = -cgso * omega; - xcgmbb = -pParam->BSIM4cgbo * omega; + xcgmbb = -pParam->BSIM4v7cgbo * omega; xcdgmb = xcgmdb; xcsgmb = xcgmsb; @@ -233,43 +233,43 @@ double m; xcdgbr = Cdgr * omega; xcsgbr = Csgr * omega; - xcbgb = here->BSIM4cbgb * omega; + xcbgb = here->BSIM4v7cbgb * omega; } else - { xcggbr = (Cggr + cgdo + cgso + pParam->BSIM4cgbo ) * omega; + { xcggbr = (Cggr + cgdo + cgso + pParam->BSIM4v7cgbo ) * omega; xcgdbr = (Cgdr - cgdo) * omega; xcgsbr = (Cgsr - cgso) * omega; xcgbbr = -(xcggbr + xcgdbr + xcgsbr); xcdgbr = (Cdgr - cgdo) * omega; xcsgbr = (Csgr - cgso) * omega; - xcbgb = (here->BSIM4cbgb - pParam->BSIM4cgbo) * omega; + xcbgb = (here->BSIM4v7cbgb - pParam->BSIM4v7cgbo) * omega; xcdgmb = xcsgmb = xcbgmb = 0.0; } - xcddbr = (Cddr + here->BSIM4capbd + cgdo) * omega; + xcddbr = (Cddr + here->BSIM4v7capbd + cgdo) * omega; xcdsbr = Cdsr * omega; xcsdbr = Csdr * omega; - xcssbr = (here->BSIM4capbs + cgso + Cssr) * omega; + xcssbr = (here->BSIM4v7capbs + cgso + Cssr) * omega; - if (!here->BSIM4rbodyMod) + if (!here->BSIM4v7rbodyMod) { xcdbbr = -(xcdgbr + xcddbr + xcdsbr + xcdgmb); xcsbbr = -(xcsgbr + xcsdbr + xcssbr + xcsgmb); - xcbdb = (here->BSIM4cbdb - here->BSIM4capbd) * omega; - xcbsb = (here->BSIM4cbsb - here->BSIM4capbs) * omega; + xcbdb = (here->BSIM4v7cbdb - here->BSIM4v7capbd) * omega; + xcbsb = (here->BSIM4v7cbsb - here->BSIM4v7capbs) * omega; xcdbdb = 0.0; } else { xcdbbr = Cdbr * omega; xcsbbr = -(xcsgbr + xcsdbr + xcssbr + xcsgmb) - + here->BSIM4capbs * omega; + + here->BSIM4v7capbs * omega; - xcbdb = here->BSIM4cbdb * omega; - xcbsb = here->BSIM4cbsb * omega; + xcbdb = here->BSIM4v7cbdb * omega; + xcbsb = here->BSIM4v7cbsb * omega; - xcdbdb = -here->BSIM4capbd * omega; - xcsbsb = -here->BSIM4capbs * omega; + xcdbdb = -here->BSIM4v7capbd * omega; + xcsbsb = -here->BSIM4v7capbs * omega; } xcbbb = -(xcbdb + xcbgb + xcbsb + xcbgmb); @@ -296,45 +296,45 @@ double m; FwdSumi = 0.0; RevSumi = -(Gmi + Gmbsi); - gbbsp = -(here->BSIM4gbds); - gbbdp = here->BSIM4gbds + here->BSIM4gbgs + here->BSIM4gbbs; + gbbsp = -(here->BSIM4v7gbds); + gbbdp = here->BSIM4v7gbds + here->BSIM4v7gbgs + here->BSIM4v7gbbs; gbdpg = 0.0; gbdpsp = 0.0; gbdpb = 0.0; gbdpdp = 0.0; - gbspg = here->BSIM4gbgs; - gbspsp = here->BSIM4gbds; - gbspb = here->BSIM4gbbs; + gbspg = here->BSIM4v7gbgs; + gbspsp = here->BSIM4v7gbds; + gbspb = here->BSIM4v7gbbs; gbspdp = -(gbspg + gbspsp + gbspb); - if (model->BSIM4igcMod) - { gIstotg = here->BSIM4gIgsg + here->BSIM4gIgcdg; - gIstotd = here->BSIM4gIgcds; - gIstots = here->BSIM4gIgss + here->BSIM4gIgcdd; - gIstotb = here->BSIM4gIgcdb; + if (model->BSIM4v7igcMod) + { gIstotg = here->BSIM4v7gIgsg + here->BSIM4v7gIgcdg; + gIstotd = here->BSIM4v7gIgcds; + gIstots = here->BSIM4v7gIgss + here->BSIM4v7gIgcdd; + gIstotb = here->BSIM4v7gIgcdb; - gIdtotg = here->BSIM4gIgdg + here->BSIM4gIgcsg; - gIdtotd = here->BSIM4gIgdd + here->BSIM4gIgcss; - gIdtots = here->BSIM4gIgcsd; - gIdtotb = here->BSIM4gIgcsb; + gIdtotg = here->BSIM4v7gIgdg + here->BSIM4v7gIgcsg; + gIdtotd = here->BSIM4v7gIgdd + here->BSIM4v7gIgcss; + gIdtots = here->BSIM4v7gIgcsd; + gIdtotb = here->BSIM4v7gIgcsb; } else { gIstotg = gIstotd = gIstots = gIstotb = 0.0; gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0; } - if (model->BSIM4igbMod) - { gIbtotg = here->BSIM4gIgbg; - gIbtotd = here->BSIM4gIgbs; - gIbtots = here->BSIM4gIgbd; - gIbtotb = here->BSIM4gIgbb; + if (model->BSIM4v7igbMod) + { gIbtotg = here->BSIM4v7gIgbg; + gIbtotd = here->BSIM4v7gIgbs; + gIbtots = here->BSIM4v7gIgbd; + gIbtotb = here->BSIM4v7gIgbb; } else gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0; - if ((model->BSIM4igcMod != 0) || (model->BSIM4igbMod != 0)) + if ((model->BSIM4v7igcMod != 0) || (model->BSIM4v7igbMod != 0)) { gIgtotg = gIstotg + gIdtotg + gIbtotg; gIgtotd = gIstotd + gIdtotd + gIbtotd ; gIgtots = gIstots + gIdtots + gIbtots; @@ -343,28 +343,28 @@ double m; else gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0; - if (here->BSIM4rgateMod == 2) - T0 = *(ckt->CKTstates[0] + here->BSIM4vges) - - *(ckt->CKTstates[0] + here->BSIM4vgs); - else if (here->BSIM4rgateMod == 3) - T0 = *(ckt->CKTstates[0] + here->BSIM4vgms) - - *(ckt->CKTstates[0] + here->BSIM4vgs); - if (here->BSIM4rgateMod > 1) - { gcrgd = here->BSIM4gcrgs * T0; - gcrgg = here->BSIM4gcrgg * T0; - gcrgs = here->BSIM4gcrgd * T0; - gcrgb = here->BSIM4gcrgb * T0; - gcrgg -= here->BSIM4gcrg; - gcrg = here->BSIM4gcrg; + if (here->BSIM4v7rgateMod == 2) + T0 = *(ckt->CKTstates[0] + here->BSIM4v7vges) + - *(ckt->CKTstates[0] + here->BSIM4v7vgs); + else if (here->BSIM4v7rgateMod == 3) + T0 = *(ckt->CKTstates[0] + here->BSIM4v7vgms) + - *(ckt->CKTstates[0] + here->BSIM4v7vgs); + if (here->BSIM4v7rgateMod > 1) + { gcrgd = here->BSIM4v7gcrgs * T0; + gcrgg = here->BSIM4v7gcrgg * T0; + gcrgs = here->BSIM4v7gcrgd * T0; + gcrgb = here->BSIM4v7gcrgb * T0; + gcrgg -= here->BSIM4v7gcrg; + gcrg = here->BSIM4v7gcrg; } else gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0; - if (here->BSIM4rgateMod == 3) - { xcgmgmb = (cgdo + cgso + pParam->BSIM4cgbo) * omega; + if (here->BSIM4v7rgateMod == 3) + { xcgmgmb = (cgdo + cgso + pParam->BSIM4v7cgbo) * omega; xcgmdb = -cgdo * omega; xcgmsb = -cgso * omega; - xcgmbb = -pParam->BSIM4cgbo * omega; + xcgmbb = -pParam->BSIM4v7cgbo * omega; xcdgmb = xcgmdb; xcsgmb = xcgmsb; @@ -377,42 +377,42 @@ double m; xcdgbr = Csgr * omega; xcsgbr = Cdgr * omega; - xcbgb = here->BSIM4cbgb * omega; + xcbgb = here->BSIM4v7cbgb * omega; } else - { xcggbr = (Cggr + cgdo + cgso + pParam->BSIM4cgbo ) * omega; + { xcggbr = (Cggr + cgdo + cgso + pParam->BSIM4v7cgbo ) * omega; xcgdbr = (Cgsr - cgdo) * omega; xcgsbr = (Cgdr - cgso) * omega; xcgbbr = -(xcggbr + xcgdbr + xcgsbr); xcdgbr = (Csgr - cgdo) * omega; xcsgbr = (Cdgr - cgso) * omega; - xcbgb = (here->BSIM4cbgb - pParam->BSIM4cgbo) * omega; + xcbgb = (here->BSIM4v7cbgb - pParam->BSIM4v7cgbo) * omega; xcdgmb = xcsgmb = xcbgmb = 0.0; } - xcddbr = (here->BSIM4capbd + cgdo + Cssr) * omega; + xcddbr = (here->BSIM4v7capbd + cgdo + Cssr) * omega; xcdsbr = Csdr * omega; xcsdbr = Cdsr * omega; - xcssbr = (Cddr + here->BSIM4capbs + cgso) * omega; + xcssbr = (Cddr + here->BSIM4v7capbs + cgso) * omega; - if (!here->BSIM4rbodyMod) + if (!here->BSIM4v7rbodyMod) { xcdbbr = -(xcdgbr + xcddbr + xcdsbr + xcdgmb); xcsbbr = -(xcsgbr + xcsdbr + xcssbr + xcsgmb); - xcbdb = (here->BSIM4cbsb - here->BSIM4capbd) * omega; - xcbsb = (here->BSIM4cbdb - here->BSIM4capbs) * omega; + xcbdb = (here->BSIM4v7cbsb - here->BSIM4v7capbd) * omega; + xcbsb = (here->BSIM4v7cbdb - here->BSIM4v7capbs) * omega; xcdbdb = 0.0; } else { xcdbbr = -(xcdgbr + xcddbr + xcdsbr + xcdgmb) - + here->BSIM4capbd * omega; + + here->BSIM4v7capbd * omega; xcsbbr = Cdbr * omega; - xcbdb = here->BSIM4cbsb * omega; - xcbsb = here->BSIM4cbdb * omega; - xcdbdb = -here->BSIM4capbd * omega; - xcsbsb = -here->BSIM4capbs * omega; + xcbdb = here->BSIM4v7cbsb * omega; + xcbsb = here->BSIM4v7cbdb * omega; + xcdbdb = -here->BSIM4v7capbd * omega; + xcsbsb = -here->BSIM4v7capbs * omega; } xcbbb = -(xcbgb + xcbdb + xcbsb + xcbgmb); @@ -430,18 +430,18 @@ double m; xcgbbi = Cgbi; } - if (model->BSIM4rdsMod == 1) - { gstot = here->BSIM4gstot; - gstotd = here->BSIM4gstotd; - gstotg = here->BSIM4gstotg; - gstots = here->BSIM4gstots - gstot; - gstotb = here->BSIM4gstotb; + if (model->BSIM4v7rdsMod == 1) + { gstot = here->BSIM4v7gstot; + gstotd = here->BSIM4v7gstotd; + gstotg = here->BSIM4v7gstotg; + gstots = here->BSIM4v7gstots - gstot; + gstotb = here->BSIM4v7gstotb; - gdtot = here->BSIM4gdtot; - gdtotd = here->BSIM4gdtotd - gdtot; - gdtotg = here->BSIM4gdtotg; - gdtots = here->BSIM4gdtots; - gdtotb = here->BSIM4gdtotb; + gdtot = here->BSIM4v7gdtot; + gdtotd = here->BSIM4v7gdtotd - gdtot; + gdtotg = here->BSIM4v7gdtotg; + gdtots = here->BSIM4v7gdtots; + gdtotb = here->BSIM4v7gdtotb; } else { gstot = gstotd = gstotg = gstots = gstotb = 0.0; @@ -452,201 +452,201 @@ double m; /* * Loading AC matrix */ - m = here->BSIM4m; + m = here->BSIM4v7m; - if (!model->BSIM4rdsMod) - { gdpr = here->BSIM4drainConductance; - gspr = here->BSIM4sourceConductance; + if (!model->BSIM4v7rdsMod) + { gdpr = here->BSIM4v7drainConductance; + gspr = here->BSIM4v7sourceConductance; } else gdpr = gspr = 0.0; - if (!here->BSIM4rbodyMod) - { gjbd = here->BSIM4gbd; - gjbs = here->BSIM4gbs; + if (!here->BSIM4v7rbodyMod) + { gjbd = here->BSIM4v7gbd; + gjbs = here->BSIM4v7gbs; } else gjbd = gjbs = 0.0; - geltd = here->BSIM4grgeltd; + geltd = here->BSIM4v7grgeltd; - if (here->BSIM4rgateMod == 1) - { *(here->BSIM4GEgePtr) += m * geltd; - *(here->BSIM4GPgePtr) -= m * geltd; - *(here->BSIM4GEgpPtr) -= m * geltd; + if (here->BSIM4v7rgateMod == 1) + { *(here->BSIM4v7GEgePtr) += m * geltd; + *(here->BSIM4v7GPgePtr) -= m * geltd; + *(here->BSIM4v7GEgpPtr) -= m * geltd; - *(here->BSIM4GPgpPtr +1) += m * xcggbr; - *(here->BSIM4GPgpPtr) += m * (geltd + xcggbi + gIgtotg); - *(here->BSIM4GPdpPtr +1) += m * xcgdbr; - *(here->BSIM4GPdpPtr) += m * (xcgdbi + gIgtotd); - *(here->BSIM4GPspPtr +1) += m * xcgsbr; - *(here->BSIM4GPspPtr) += m * (xcgsbi + gIgtots); - *(here->BSIM4GPbpPtr +1) += m * xcgbbr; - *(here->BSIM4GPbpPtr) += m * (xcgbbi + gIgtotb); + *(here->BSIM4v7GPgpPtr +1) += m * xcggbr; + *(here->BSIM4v7GPgpPtr) += m * (geltd + xcggbi + gIgtotg); + *(here->BSIM4v7GPdpPtr +1) += m * xcgdbr; + *(here->BSIM4v7GPdpPtr) += m * (xcgdbi + gIgtotd); + *(here->BSIM4v7GPspPtr +1) += m * xcgsbr; + *(here->BSIM4v7GPspPtr) += m * (xcgsbi + gIgtots); + *(here->BSIM4v7GPbpPtr +1) += m * xcgbbr; + *(here->BSIM4v7GPbpPtr) += m * (xcgbbi + gIgtotb); } /* WDLiu: gcrg already subtracted from all gcrgg below */ - else if (here->BSIM4rgateMod == 2) - { *(here->BSIM4GEgePtr) += m * gcrg; - *(here->BSIM4GEgpPtr) += m * gcrgg; - *(here->BSIM4GEdpPtr) += m * gcrgd; - *(here->BSIM4GEspPtr) += m * gcrgs; - *(here->BSIM4GEbpPtr) += m * gcrgb; + else if (here->BSIM4v7rgateMod == 2) + { *(here->BSIM4v7GEgePtr) += m * gcrg; + *(here->BSIM4v7GEgpPtr) += m * gcrgg; + *(here->BSIM4v7GEdpPtr) += m * gcrgd; + *(here->BSIM4v7GEspPtr) += m * gcrgs; + *(here->BSIM4v7GEbpPtr) += m * gcrgb; - *(here->BSIM4GPgePtr) -= m * gcrg; - *(here->BSIM4GPgpPtr +1) += m * xcggbr; - *(here->BSIM4GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg); - *(here->BSIM4GPdpPtr +1) += m * xcgdbr; - *(here->BSIM4GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd); - *(here->BSIM4GPspPtr +1) += m * xcgsbr; - *(here->BSIM4GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots); - *(here->BSIM4GPbpPtr +1) += m * xcgbbr; - *(here->BSIM4GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb); + *(here->BSIM4v7GPgePtr) -= m * gcrg; + *(here->BSIM4v7GPgpPtr +1) += m * xcggbr; + *(here->BSIM4v7GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg); + *(here->BSIM4v7GPdpPtr +1) += m * xcgdbr; + *(here->BSIM4v7GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd); + *(here->BSIM4v7GPspPtr +1) += m * xcgsbr; + *(here->BSIM4v7GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots); + *(here->BSIM4v7GPbpPtr +1) += m * xcgbbr; + *(here->BSIM4v7GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb); } - else if (here->BSIM4rgateMod == 3) - { *(here->BSIM4GEgePtr) += m * geltd; - *(here->BSIM4GEgmPtr) -= m * geltd; - *(here->BSIM4GMgePtr) -= m * geltd; - *(here->BSIM4GMgmPtr) += m * (geltd + gcrg); - *(here->BSIM4GMgmPtr +1) += m * xcgmgmb; + else if (here->BSIM4v7rgateMod == 3) + { *(here->BSIM4v7GEgePtr) += m * geltd; + *(here->BSIM4v7GEgmPtr) -= m * geltd; + *(here->BSIM4v7GMgePtr) -= m * geltd; + *(here->BSIM4v7GMgmPtr) += m * (geltd + gcrg); + *(here->BSIM4v7GMgmPtr +1) += m * xcgmgmb; - *(here->BSIM4GMdpPtr) += m * gcrgd; - *(here->BSIM4GMdpPtr +1) += m * xcgmdb; - *(here->BSIM4GMgpPtr) += m * gcrgg; - *(here->BSIM4GMspPtr) += m * gcrgs; - *(here->BSIM4GMspPtr +1) += m * xcgmsb; - *(here->BSIM4GMbpPtr) += m * gcrgb; - *(here->BSIM4GMbpPtr +1) += m * xcgmbb; + *(here->BSIM4v7GMdpPtr) += m * gcrgd; + *(here->BSIM4v7GMdpPtr +1) += m * xcgmdb; + *(here->BSIM4v7GMgpPtr) += m * gcrgg; + *(here->BSIM4v7GMspPtr) += m * gcrgs; + *(here->BSIM4v7GMspPtr +1) += m * xcgmsb; + *(here->BSIM4v7GMbpPtr) += m * gcrgb; + *(here->BSIM4v7GMbpPtr +1) += m * xcgmbb; - *(here->BSIM4DPgmPtr +1) += m * xcdgmb; - *(here->BSIM4GPgmPtr) -= m * gcrg; - *(here->BSIM4SPgmPtr +1) += m * xcsgmb; - *(here->BSIM4BPgmPtr +1) += m * xcbgmb; + *(here->BSIM4v7DPgmPtr +1) += m * xcdgmb; + *(here->BSIM4v7GPgmPtr) -= m * gcrg; + *(here->BSIM4v7SPgmPtr +1) += m * xcsgmb; + *(here->BSIM4v7BPgmPtr +1) += m * xcbgmb; - *(here->BSIM4GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg); - *(here->BSIM4GPgpPtr +1) += m * xcggbr; - *(here->BSIM4GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd); - *(here->BSIM4GPdpPtr +1) += m * xcgdbr; - *(here->BSIM4GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots); - *(here->BSIM4GPspPtr +1) += m * xcgsbr; - *(here->BSIM4GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb); - *(here->BSIM4GPbpPtr +1) += m * xcgbbr; + *(here->BSIM4v7GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg); + *(here->BSIM4v7GPgpPtr +1) += m * xcggbr; + *(here->BSIM4v7GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd); + *(here->BSIM4v7GPdpPtr +1) += m * xcgdbr; + *(here->BSIM4v7GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots); + *(here->BSIM4v7GPspPtr +1) += m * xcgsbr; + *(here->BSIM4v7GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb); + *(here->BSIM4v7GPbpPtr +1) += m * xcgbbr; } else - { *(here->BSIM4GPgpPtr +1) += m * xcggbr; - *(here->BSIM4GPgpPtr) += m * (xcggbi + gIgtotg); - *(here->BSIM4GPdpPtr +1) += m * xcgdbr; - *(here->BSIM4GPdpPtr) += m * (xcgdbi + gIgtotd); - *(here->BSIM4GPspPtr +1) += m * xcgsbr; - *(here->BSIM4GPspPtr) += m * (xcgsbi + gIgtots); - *(here->BSIM4GPbpPtr +1) += m * xcgbbr; - *(here->BSIM4GPbpPtr) += m * (xcgbbi + gIgtotb); + { *(here->BSIM4v7GPgpPtr +1) += m * xcggbr; + *(here->BSIM4v7GPgpPtr) += m * (xcggbi + gIgtotg); + *(here->BSIM4v7GPdpPtr +1) += m * xcgdbr; + *(here->BSIM4v7GPdpPtr) += m * (xcgdbi + gIgtotd); + *(here->BSIM4v7GPspPtr +1) += m * xcgsbr; + *(here->BSIM4v7GPspPtr) += m * (xcgsbi + gIgtots); + *(here->BSIM4v7GPbpPtr +1) += m * xcgbbr; + *(here->BSIM4v7GPbpPtr) += m * (xcgbbi + gIgtotb); } - if (model->BSIM4rdsMod) - { (*(here->BSIM4DgpPtr) += m * gdtotg); - (*(here->BSIM4DspPtr) += m * gdtots); - (*(here->BSIM4DbpPtr) += m * gdtotb); - (*(here->BSIM4SdpPtr) += m * gstotd); - (*(here->BSIM4SgpPtr) += m * gstotg); - (*(here->BSIM4SbpPtr) += m * gstotb); + if (model->BSIM4v7rdsMod) + { (*(here->BSIM4v7DgpPtr) += m * gdtotg); + (*(here->BSIM4v7DspPtr) += m * gdtots); + (*(here->BSIM4v7DbpPtr) += m * gdtotb); + (*(here->BSIM4v7SdpPtr) += m * gstotd); + (*(here->BSIM4v7SgpPtr) += m * gstotg); + (*(here->BSIM4v7SbpPtr) += m * gstotb); } - *(here->BSIM4DPdpPtr +1) += m * (xcddbr + gdsi + RevSumi); - *(here->BSIM4DPdpPtr) += m * (gdpr + xcddbi + gdsr + here->BSIM4gbd + *(here->BSIM4v7DPdpPtr +1) += m * (xcddbr + gdsi + RevSumi); + *(here->BSIM4v7DPdpPtr) += m * (gdpr + xcddbi + gdsr + here->BSIM4v7gbd - gdtotd + RevSumr + gbdpdp - gIdtotd); - *(here->BSIM4DPdPtr) -= m * (gdpr + gdtot); - *(here->BSIM4DPgpPtr +1) += m * (xcdgbr + Gmi); - *(here->BSIM4DPgpPtr) += m * (Gmr + xcdgbi - gdtotg + gbdpg - gIdtotg); - *(here->BSIM4DPspPtr +1) += m * (xcdsbr - gdsi - FwdSumi); - *(here->BSIM4DPspPtr) -= m * (gdsr - xcdsbi + FwdSumr + gdtots - gbdpsp + gIdtots); - *(here->BSIM4DPbpPtr +1) += m * (xcdbbr + Gmbsi); - *(here->BSIM4DPbpPtr) -= m * (gjbd + gdtotb - xcdbbi - Gmbsr - gbdpb + gIdtotb); + *(here->BSIM4v7DPdPtr) -= m * (gdpr + gdtot); + *(here->BSIM4v7DPgpPtr +1) += m * (xcdgbr + Gmi); + *(here->BSIM4v7DPgpPtr) += m * (Gmr + xcdgbi - gdtotg + gbdpg - gIdtotg); + *(here->BSIM4v7DPspPtr +1) += m * (xcdsbr - gdsi - FwdSumi); + *(here->BSIM4v7DPspPtr) -= m * (gdsr - xcdsbi + FwdSumr + gdtots - gbdpsp + gIdtots); + *(here->BSIM4v7DPbpPtr +1) += m * (xcdbbr + Gmbsi); + *(here->BSIM4v7DPbpPtr) -= m * (gjbd + gdtotb - xcdbbi - Gmbsr - gbdpb + gIdtotb); - *(here->BSIM4DdpPtr) -= m * (gdpr - gdtotd); - *(here->BSIM4DdPtr) += m * (gdpr + gdtot); + *(here->BSIM4v7DdpPtr) -= m * (gdpr - gdtotd); + *(here->BSIM4v7DdPtr) += m * (gdpr + gdtot); - *(here->BSIM4SPdpPtr +1) += m * (xcsdbr - gdsi - RevSumi); - *(here->BSIM4SPdpPtr) -= m * (gdsr - xcsdbi + gstotd + RevSumr - gbspdp + gIstotd); - *(here->BSIM4SPgpPtr +1) += m * (xcsgbr - Gmi); - *(here->BSIM4SPgpPtr) -= m * (Gmr - xcsgbi + gstotg - gbspg + gIstotg); - *(here->BSIM4SPspPtr +1) += m * (xcssbr + gdsi + FwdSumi); - *(here->BSIM4SPspPtr) += m * (gspr + xcssbi + gdsr + here->BSIM4gbs + *(here->BSIM4v7SPdpPtr +1) += m * (xcsdbr - gdsi - RevSumi); + *(here->BSIM4v7SPdpPtr) -= m * (gdsr - xcsdbi + gstotd + RevSumr - gbspdp + gIstotd); + *(here->BSIM4v7SPgpPtr +1) += m * (xcsgbr - Gmi); + *(here->BSIM4v7SPgpPtr) -= m * (Gmr - xcsgbi + gstotg - gbspg + gIstotg); + *(here->BSIM4v7SPspPtr +1) += m * (xcssbr + gdsi + FwdSumi); + *(here->BSIM4v7SPspPtr) += m * (gspr + xcssbi + gdsr + here->BSIM4v7gbs - gstots + FwdSumr + gbspsp - gIstots); - *(here->BSIM4SPsPtr) -= m * (gspr + gstot); - *(here->BSIM4SPbpPtr +1) += m * (xcsbbr - Gmbsi); - *(here->BSIM4SPbpPtr) -= m * (gjbs + gstotb - xcsbbi + Gmbsr - gbspb + gIstotb); + *(here->BSIM4v7SPsPtr) -= m * (gspr + gstot); + *(here->BSIM4v7SPbpPtr +1) += m * (xcsbbr - Gmbsi); + *(here->BSIM4v7SPbpPtr) -= m * (gjbs + gstotb - xcsbbi + Gmbsr - gbspb + gIstotb); - *(here->BSIM4SspPtr) -= m * (gspr - gstots); - *(here->BSIM4SsPtr) += m * (gspr + gstot); + *(here->BSIM4v7SspPtr) -= m * (gspr - gstots); + *(here->BSIM4v7SsPtr) += m * (gspr + gstot); - *(here->BSIM4BPdpPtr +1) += m * xcbdb; - *(here->BSIM4BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd); - *(here->BSIM4BPgpPtr +1) += m * xcbgb; - *(here->BSIM4BPgpPtr) -= m * (here->BSIM4gbgs + gIbtotg); - *(here->BSIM4BPspPtr +1) += m * xcbsb; - *(here->BSIM4BPspPtr) -= m * (gjbs - gbbsp + gIbtots); - *(here->BSIM4BPbpPtr +1) += m * xcbbb; - *(here->BSIM4BPbpPtr) += m * (gjbd + gjbs - here->BSIM4gbbs + *(here->BSIM4v7BPdpPtr +1) += m * xcbdb; + *(here->BSIM4v7BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd); + *(here->BSIM4v7BPgpPtr +1) += m * xcbgb; + *(here->BSIM4v7BPgpPtr) -= m * (here->BSIM4v7gbgs + gIbtotg); + *(here->BSIM4v7BPspPtr +1) += m * xcbsb; + *(here->BSIM4v7BPspPtr) -= m * (gjbs - gbbsp + gIbtots); + *(here->BSIM4v7BPbpPtr +1) += m * xcbbb; + *(here->BSIM4v7BPbpPtr) += m * (gjbd + gjbs - here->BSIM4v7gbbs - gIbtotb); - ggidld = here->BSIM4ggidld; - ggidlg = here->BSIM4ggidlg; - ggidlb = here->BSIM4ggidlb; - ggislg = here->BSIM4ggislg; - ggisls = here->BSIM4ggisls; - ggislb = here->BSIM4ggislb; + ggidld = here->BSIM4v7ggidld; + ggidlg = here->BSIM4v7ggidlg; + ggidlb = here->BSIM4v7ggidlb; + ggislg = here->BSIM4v7ggislg; + ggisls = here->BSIM4v7ggisls; + ggislb = here->BSIM4v7ggislb; /* stamp gidl */ - (*(here->BSIM4DPdpPtr) += m * ggidld); - (*(here->BSIM4DPgpPtr) += m * ggidlg); - (*(here->BSIM4DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb)); - (*(here->BSIM4DPbpPtr) += m * ggidlb); - (*(here->BSIM4BPdpPtr) -= m * ggidld); - (*(here->BSIM4BPgpPtr) -= m * ggidlg); - (*(here->BSIM4BPspPtr) += m * ((ggidlg + ggidld) + ggidlb)); - (*(here->BSIM4BPbpPtr) -= m * ggidlb); + (*(here->BSIM4v7DPdpPtr) += m * ggidld); + (*(here->BSIM4v7DPgpPtr) += m * ggidlg); + (*(here->BSIM4v7DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb)); + (*(here->BSIM4v7DPbpPtr) += m * ggidlb); + (*(here->BSIM4v7BPdpPtr) -= m * ggidld); + (*(here->BSIM4v7BPgpPtr) -= m * ggidlg); + (*(here->BSIM4v7BPspPtr) += m * ((ggidlg + ggidld) + ggidlb)); + (*(here->BSIM4v7BPbpPtr) -= m * ggidlb); /* stamp gisl */ - (*(here->BSIM4SPdpPtr) -= m * ((ggisls + ggislg) + ggislb)); - (*(here->BSIM4SPgpPtr) += m * ggislg); - (*(here->BSIM4SPspPtr) += m * ggisls); - (*(here->BSIM4SPbpPtr) += m * ggislb); - (*(here->BSIM4BPdpPtr) += m * ((ggislg + ggisls) + ggislb)); - (*(here->BSIM4BPgpPtr) -= m * ggislg); - (*(here->BSIM4BPspPtr) -= m * ggisls); - (*(here->BSIM4BPbpPtr) -= m * ggislb); + (*(here->BSIM4v7SPdpPtr) -= m * ((ggisls + ggislg) + ggislb)); + (*(here->BSIM4v7SPgpPtr) += m * ggislg); + (*(here->BSIM4v7SPspPtr) += m * ggisls); + (*(here->BSIM4v7SPbpPtr) += m * ggislb); + (*(here->BSIM4v7BPdpPtr) += m * ((ggislg + ggisls) + ggislb)); + (*(here->BSIM4v7BPgpPtr) -= m * ggislg); + (*(here->BSIM4v7BPspPtr) -= m * ggisls); + (*(here->BSIM4v7BPbpPtr) -= m * ggislb); - if (here->BSIM4rbodyMod) - { (*(here->BSIM4DPdbPtr +1) += m * xcdbdb); - (*(here->BSIM4DPdbPtr) -= m * here->BSIM4gbd); - (*(here->BSIM4SPsbPtr +1) += m * xcsbsb); - (*(here->BSIM4SPsbPtr) -= m * here->BSIM4gbs); + if (here->BSIM4v7rbodyMod) + { (*(here->BSIM4v7DPdbPtr +1) += m * xcdbdb); + (*(here->BSIM4v7DPdbPtr) -= m * here->BSIM4v7gbd); + (*(here->BSIM4v7SPsbPtr +1) += m * xcsbsb); + (*(here->BSIM4v7SPsbPtr) -= m * here->BSIM4v7gbs); - (*(here->BSIM4DBdpPtr +1) += m * xcdbdb); - (*(here->BSIM4DBdpPtr) -= m * here->BSIM4gbd); - (*(here->BSIM4DBdbPtr +1) -= m * xcdbdb); - (*(here->BSIM4DBdbPtr) += m * (here->BSIM4gbd + here->BSIM4grbpd - + here->BSIM4grbdb)); - (*(here->BSIM4DBbpPtr) -= m * here->BSIM4grbpd); - (*(here->BSIM4DBbPtr) -= m * here->BSIM4grbdb); + (*(here->BSIM4v7DBdpPtr +1) += m * xcdbdb); + (*(here->BSIM4v7DBdpPtr) -= m * here->BSIM4v7gbd); + (*(here->BSIM4v7DBdbPtr +1) -= m * xcdbdb); + (*(here->BSIM4v7DBdbPtr) += m * (here->BSIM4v7gbd + here->BSIM4v7grbpd + + here->BSIM4v7grbdb)); + (*(here->BSIM4v7DBbpPtr) -= m * here->BSIM4v7grbpd); + (*(here->BSIM4v7DBbPtr) -= m * here->BSIM4v7grbdb); - (*(here->BSIM4BPdbPtr) -= m * here->BSIM4grbpd); - (*(here->BSIM4BPbPtr) -= m * here->BSIM4grbpb); - (*(here->BSIM4BPsbPtr) -= m * here->BSIM4grbps); - (*(here->BSIM4BPbpPtr) += m * (here->BSIM4grbpd + here->BSIM4grbps - + here->BSIM4grbpb)); - /* WDLiu: (-here->BSIM4gbbs) already added to BPbpPtr */ + (*(here->BSIM4v7BPdbPtr) -= m * here->BSIM4v7grbpd); + (*(here->BSIM4v7BPbPtr) -= m * here->BSIM4v7grbpb); + (*(here->BSIM4v7BPsbPtr) -= m * here->BSIM4v7grbps); + (*(here->BSIM4v7BPbpPtr) += m * (here->BSIM4v7grbpd + here->BSIM4v7grbps + + here->BSIM4v7grbpb)); + /* WDLiu: (-here->BSIM4v7gbbs) already added to BPbpPtr */ - (*(here->BSIM4SBspPtr +1) += m * xcsbsb); - (*(here->BSIM4SBspPtr) -= m * here->BSIM4gbs); - (*(here->BSIM4SBbpPtr) -= m * here->BSIM4grbps); - (*(here->BSIM4SBbPtr) -= m * here->BSIM4grbsb); - (*(here->BSIM4SBsbPtr +1) -= m * xcsbsb); - (*(here->BSIM4SBsbPtr) += m * (here->BSIM4gbs - + here->BSIM4grbps + here->BSIM4grbsb)); + (*(here->BSIM4v7SBspPtr +1) += m * xcsbsb); + (*(here->BSIM4v7SBspPtr) -= m * here->BSIM4v7gbs); + (*(here->BSIM4v7SBbpPtr) -= m * here->BSIM4v7grbps); + (*(here->BSIM4v7SBbPtr) -= m * here->BSIM4v7grbsb); + (*(here->BSIM4v7SBsbPtr +1) -= m * xcsbsb); + (*(here->BSIM4v7SBsbPtr) += m * (here->BSIM4v7gbs + + here->BSIM4v7grbps + here->BSIM4v7grbsb)); - (*(here->BSIM4BdbPtr) -= m * here->BSIM4grbdb); - (*(here->BSIM4BbpPtr) -= m * here->BSIM4grbpb); - (*(here->BSIM4BsbPtr) -= m * here->BSIM4grbsb); - (*(here->BSIM4BbPtr) += m * (here->BSIM4grbsb + here->BSIM4grbdb - + here->BSIM4grbpb)); + (*(here->BSIM4v7BdbPtr) -= m * here->BSIM4v7grbdb); + (*(here->BSIM4v7BbpPtr) -= m * here->BSIM4v7grbpb); + (*(here->BSIM4v7BsbPtr) -= m * here->BSIM4v7grbsb); + (*(here->BSIM4v7BbPtr) += m * (here->BSIM4v7grbsb + here->BSIM4v7grbdb + + here->BSIM4v7grbpb)); } @@ -656,16 +656,16 @@ double m; * otherwise a singular AC NQS matrix may occur if the transient NQS is on. * The charge node is isolated from the instance. */ - if (here->BSIM4trnqsMod) - { (*(here->BSIM4QqPtr) += m * 1.0); - (*(here->BSIM4QgpPtr) += 0.0); - (*(here->BSIM4QdpPtr) += 0.0); - (*(here->BSIM4QspPtr) += 0.0); - (*(here->BSIM4QbpPtr) += 0.0); + if (here->BSIM4v7trnqsMod) + { (*(here->BSIM4v7QqPtr) += m * 1.0); + (*(here->BSIM4v7QgpPtr) += 0.0); + (*(here->BSIM4v7QdpPtr) += 0.0); + (*(here->BSIM4v7QspPtr) += 0.0); + (*(here->BSIM4v7QbpPtr) += 0.0); - (*(here->BSIM4DPqPtr) += 0.0); - (*(here->BSIM4SPqPtr) += 0.0); - (*(here->BSIM4GPqPtr) += 0.0); + (*(here->BSIM4v7DPqPtr) += 0.0); + (*(here->BSIM4v7SPqPtr) += 0.0); + (*(here->BSIM4v7GPqPtr) += 0.0); } } } diff --git a/src/spicelib/devices/bsim4v7/b4v7ask.c b/src/spicelib/devices/bsim4v7/b4v7ask.c index e00155a37..b23b92666 100644 --- a/src/spicelib/devices/bsim4v7/b4v7ask.c +++ b/src/spicelib/devices/bsim4v7/b4v7ask.c @@ -18,384 +18,384 @@ #include "ngspice/ifsim.h" #include "ngspice/cktdefs.h" #include "ngspice/devdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" int -BSIM4ask( +BSIM4v7ask( CKTcircuit *ckt, GENinstance *inst, int which, IFvalue *value, IFvalue *select) { -BSIM4instance *here = (BSIM4instance*)inst; +BSIM4v7instance *here = (BSIM4v7instance*)inst; NG_IGNORE(select); switch(which) - { case BSIM4_L: - value->rValue = here->BSIM4l; + { case BSIM4v7_L: + value->rValue = here->BSIM4v7l; return(OK); - case BSIM4_W: - value->rValue = here->BSIM4w; + case BSIM4v7_W: + value->rValue = here->BSIM4v7w; return(OK); - case BSIM4_M: - value->rValue = here->BSIM4m; + case BSIM4v7_M: + value->rValue = here->BSIM4v7m; return(OK); - case BSIM4_NF: - value->rValue = here->BSIM4nf; + case BSIM4v7_NF: + value->rValue = here->BSIM4v7nf; return(OK); - case BSIM4_MIN: - value->iValue = here->BSIM4min; + case BSIM4v7_MIN: + value->iValue = here->BSIM4v7min; return(OK); - case BSIM4_AS: - value->rValue = here->BSIM4sourceArea; + case BSIM4v7_AS: + value->rValue = here->BSIM4v7sourceArea; return(OK); - case BSIM4_AD: - value->rValue = here->BSIM4drainArea; + case BSIM4v7_AD: + value->rValue = here->BSIM4v7drainArea; return(OK); - case BSIM4_PS: - value->rValue = here->BSIM4sourcePerimeter; + case BSIM4v7_PS: + value->rValue = here->BSIM4v7sourcePerimeter; return(OK); - case BSIM4_PD: - value->rValue = here->BSIM4drainPerimeter; + case BSIM4v7_PD: + value->rValue = here->BSIM4v7drainPerimeter; return(OK); - case BSIM4_NRS: - value->rValue = here->BSIM4sourceSquares; + case BSIM4v7_NRS: + value->rValue = here->BSIM4v7sourceSquares; return(OK); - case BSIM4_NRD: - value->rValue = here->BSIM4drainSquares; + case BSIM4v7_NRD: + value->rValue = here->BSIM4v7drainSquares; return(OK); - case BSIM4_OFF: - value->rValue = here->BSIM4off; + case BSIM4v7_OFF: + value->rValue = here->BSIM4v7off; return(OK); - case BSIM4_SA: - value->rValue = here->BSIM4sa ; + case BSIM4v7_SA: + value->rValue = here->BSIM4v7sa ; return(OK); - case BSIM4_SB: - value->rValue = here->BSIM4sb ; + case BSIM4v7_SB: + value->rValue = here->BSIM4v7sb ; return(OK); - case BSIM4_SD: - value->rValue = here->BSIM4sd ; + case BSIM4v7_SD: + value->rValue = here->BSIM4v7sd ; return(OK); - case BSIM4_SCA: - value->rValue = here->BSIM4sca ; + case BSIM4v7_SCA: + value->rValue = here->BSIM4v7sca ; return(OK); - case BSIM4_SCB: - value->rValue = here->BSIM4scb ; + case BSIM4v7_SCB: + value->rValue = here->BSIM4v7scb ; return(OK); - case BSIM4_SCC: - value->rValue = here->BSIM4scc ; + case BSIM4v7_SCC: + value->rValue = here->BSIM4v7scc ; return(OK); - case BSIM4_SC: - value->rValue = here->BSIM4sc ; + case BSIM4v7_SC: + value->rValue = here->BSIM4v7sc ; return(OK); - case BSIM4_RBSB: - value->rValue = here->BSIM4rbsb; + case BSIM4v7_RBSB: + value->rValue = here->BSIM4v7rbsb; return(OK); - case BSIM4_RBDB: - value->rValue = here->BSIM4rbdb; + case BSIM4v7_RBDB: + value->rValue = here->BSIM4v7rbdb; return(OK); - case BSIM4_RBPB: - value->rValue = here->BSIM4rbpb; + case BSIM4v7_RBPB: + value->rValue = here->BSIM4v7rbpb; return(OK); - case BSIM4_RBPS: - value->rValue = here->BSIM4rbps; + case BSIM4v7_RBPS: + value->rValue = here->BSIM4v7rbps; return(OK); - case BSIM4_RBPD: - value->rValue = here->BSIM4rbpd; + case BSIM4v7_RBPD: + value->rValue = here->BSIM4v7rbpd; return(OK); - case BSIM4_DELVTO: - value->rValue = here->BSIM4delvto; + case BSIM4v7_DELVTO: + value->rValue = here->BSIM4v7delvto; return(OK); - case BSIM4_XGW: - value->rValue = here->BSIM4xgw; + case BSIM4v7_XGW: + value->rValue = here->BSIM4v7xgw; return(OK); - case BSIM4_NGCON: - value->rValue = here->BSIM4ngcon; + case BSIM4v7_NGCON: + value->rValue = here->BSIM4v7ngcon; return(OK); - case BSIM4_TRNQSMOD: - value->iValue = here->BSIM4trnqsMod; + case BSIM4v7_TRNQSMOD: + value->iValue = here->BSIM4v7trnqsMod; return(OK); - case BSIM4_ACNQSMOD: - value->iValue = here->BSIM4acnqsMod; + case BSIM4v7_ACNQSMOD: + value->iValue = here->BSIM4v7acnqsMod; return(OK); - case BSIM4_RBODYMOD: - value->iValue = here->BSIM4rbodyMod; + case BSIM4v7_RBODYMOD: + value->iValue = here->BSIM4v7rbodyMod; return(OK); - case BSIM4_RGATEMOD: - value->iValue = here->BSIM4rgateMod; + case BSIM4v7_RGATEMOD: + value->iValue = here->BSIM4v7rgateMod; return(OK); - case BSIM4_GEOMOD: - value->iValue = here->BSIM4geoMod; + case BSIM4v7_GEOMOD: + value->iValue = here->BSIM4v7geoMod; return(OK); - case BSIM4_RGEOMOD: - value->iValue = here->BSIM4rgeoMod; + case BSIM4v7_RGEOMOD: + value->iValue = here->BSIM4v7rgeoMod; return(OK); - case BSIM4_IC_VDS: - value->rValue = here->BSIM4icVDS; + case BSIM4v7_IC_VDS: + value->rValue = here->BSIM4v7icVDS; return(OK); - case BSIM4_IC_VGS: - value->rValue = here->BSIM4icVGS; + case BSIM4v7_IC_VGS: + value->rValue = here->BSIM4v7icVGS; return(OK); - case BSIM4_IC_VBS: - value->rValue = here->BSIM4icVBS; + case BSIM4v7_IC_VBS: + value->rValue = here->BSIM4v7icVBS; return(OK); - case BSIM4_DNODE: - value->iValue = here->BSIM4dNode; + case BSIM4v7_DNODE: + value->iValue = here->BSIM4v7dNode; return(OK); - case BSIM4_GNODEEXT: - value->iValue = here->BSIM4gNodeExt; + case BSIM4v7_GNODEEXT: + value->iValue = here->BSIM4v7gNodeExt; return(OK); - case BSIM4_SNODE: - value->iValue = here->BSIM4sNode; + case BSIM4v7_SNODE: + value->iValue = here->BSIM4v7sNode; return(OK); - case BSIM4_BNODE: - value->iValue = here->BSIM4bNode; + case BSIM4v7_BNODE: + value->iValue = here->BSIM4v7bNode; return(OK); - case BSIM4_DNODEPRIME: - value->iValue = here->BSIM4dNodePrime; + case BSIM4v7_DNODEPRIME: + value->iValue = here->BSIM4v7dNodePrime; return(OK); - case BSIM4_GNODEPRIME: - value->iValue = here->BSIM4gNodePrime; + case BSIM4v7_GNODEPRIME: + value->iValue = here->BSIM4v7gNodePrime; return(OK); - case BSIM4_GNODEMID: - value->iValue = here->BSIM4gNodeMid; + case BSIM4v7_GNODEMID: + value->iValue = here->BSIM4v7gNodeMid; return(OK); - case BSIM4_SNODEPRIME: - value->iValue = here->BSIM4sNodePrime; + case BSIM4v7_SNODEPRIME: + value->iValue = here->BSIM4v7sNodePrime; return(OK); - case BSIM4_DBNODE: - value->iValue = here->BSIM4dbNode; + case BSIM4v7_DBNODE: + value->iValue = here->BSIM4v7dbNode; return(OK); - case BSIM4_BNODEPRIME: - value->iValue = here->BSIM4bNodePrime; + case BSIM4v7_BNODEPRIME: + value->iValue = here->BSIM4v7bNodePrime; return(OK); - case BSIM4_SBNODE: - value->iValue = here->BSIM4sbNode; + case BSIM4v7_SBNODE: + value->iValue = here->BSIM4v7sbNode; return(OK); - case BSIM4_SOURCECONDUCT: - value->rValue = here->BSIM4sourceConductance; - value->rValue *= here->BSIM4m; + case BSIM4v7_SOURCECONDUCT: + value->rValue = here->BSIM4v7sourceConductance; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_DRAINCONDUCT: - value->rValue = here->BSIM4drainConductance; - value->rValue *= here->BSIM4m; + case BSIM4v7_DRAINCONDUCT: + value->rValue = here->BSIM4v7drainConductance; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_VBD: - value->rValue = *(ckt->CKTstate0 + here->BSIM4vbd); + case BSIM4v7_VBD: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7vbd); return(OK); - case BSIM4_VBS: - value->rValue = *(ckt->CKTstate0 + here->BSIM4vbs); + case BSIM4v7_VBS: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7vbs); return(OK); - case BSIM4_VGS: - value->rValue = *(ckt->CKTstate0 + here->BSIM4vgs); + case BSIM4v7_VGS: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7vgs); return(OK); - case BSIM4_VDS: - value->rValue = *(ckt->CKTstate0 + here->BSIM4vds); + case BSIM4v7_VDS: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7vds); return(OK); - case BSIM4_CD: - value->rValue = here->BSIM4cd; - value->rValue *= here->BSIM4m; + case BSIM4v7_CD: + value->rValue = here->BSIM4v7cd; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CBS: - value->rValue = here->BSIM4cbs; - value->rValue *= here->BSIM4m; + case BSIM4v7_CBS: + value->rValue = here->BSIM4v7cbs; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CBD: - value->rValue = here->BSIM4cbd; - value->rValue *= here->BSIM4m; + case BSIM4v7_CBD: + value->rValue = here->BSIM4v7cbd; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CSUB: - value->rValue = here->BSIM4csub; - value->rValue *= here->BSIM4m; + case BSIM4v7_CSUB: + value->rValue = here->BSIM4v7csub; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_QINV: - value->rValue = here-> BSIM4qinv; - value->rValue *= here->BSIM4m; + case BSIM4v7_QINV: + value->rValue = here-> BSIM4v7qinv; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_IGIDL: - value->rValue = here->BSIM4Igidl; - value->rValue *= here->BSIM4m; + case BSIM4v7_IGIDL: + value->rValue = here->BSIM4v7Igidl; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_IGISL: - value->rValue = here->BSIM4Igisl; - value->rValue *= here->BSIM4m; + case BSIM4v7_IGISL: + value->rValue = here->BSIM4v7Igisl; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_IGS: - value->rValue = here->BSIM4Igs; - value->rValue *= here->BSIM4m; + case BSIM4v7_IGS: + value->rValue = here->BSIM4v7Igs; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_IGD: - value->rValue = here->BSIM4Igd; - value->rValue *= here->BSIM4m; + case BSIM4v7_IGD: + value->rValue = here->BSIM4v7Igd; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_IGB: - value->rValue = here->BSIM4Igb; - value->rValue *= here->BSIM4m; + case BSIM4v7_IGB: + value->rValue = here->BSIM4v7Igb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_IGCS: - value->rValue = here->BSIM4Igcs; - value->rValue *= here->BSIM4m; + case BSIM4v7_IGCS: + value->rValue = here->BSIM4v7Igcs; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_IGCD: - value->rValue = here->BSIM4Igcd; - value->rValue *= here->BSIM4m; + case BSIM4v7_IGCD: + value->rValue = here->BSIM4v7Igcd; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_GM: - value->rValue = here->BSIM4gm; - value->rValue *= here->BSIM4m; + case BSIM4v7_GM: + value->rValue = here->BSIM4v7gm; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_GDS: - value->rValue = here->BSIM4gds; - value->rValue *= here->BSIM4m; + case BSIM4v7_GDS: + value->rValue = here->BSIM4v7gds; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_GMBS: - value->rValue = here->BSIM4gmbs; - value->rValue *= here->BSIM4m; + case BSIM4v7_GMBS: + value->rValue = here->BSIM4v7gmbs; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_GBD: - value->rValue = here->BSIM4gbd; - value->rValue *= here->BSIM4m; + case BSIM4v7_GBD: + value->rValue = here->BSIM4v7gbd; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_GBS: - value->rValue = here->BSIM4gbs; - value->rValue *= here->BSIM4m; + case BSIM4v7_GBS: + value->rValue = here->BSIM4v7gbs; + value->rValue *= here->BSIM4v7m; return(OK); -/* case BSIM4_QB: - value->rValue = *(ckt->CKTstate0 + here->BSIM4qb); +/* case BSIM4v7_QB: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7qb); return(OK); */ - case BSIM4_CQB: - value->rValue = *(ckt->CKTstate0 + here->BSIM4cqb); + case BSIM4v7_CQB: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7cqb); return(OK); -/* case BSIM4_QG: - value->rValue = *(ckt->CKTstate0 + here->BSIM4qg); +/* case BSIM4v7_QG: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7qg); return(OK); */ - case BSIM4_CQG: - value->rValue = *(ckt->CKTstate0 + here->BSIM4cqg); + case BSIM4v7_CQG: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7cqg); return(OK); -/* case BSIM4_QD: - value->rValue = *(ckt->CKTstate0 + here->BSIM4qd); +/* case BSIM4v7_QD: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7qd); return(OK); */ - case BSIM4_CQD: - value->rValue = *(ckt->CKTstate0 + here->BSIM4cqd); + case BSIM4v7_CQD: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7cqd); return(OK); -/* case BSIM4_QS: - value->rValue = *(ckt->CKTstate0 + here->BSIM4qs); +/* case BSIM4v7_QS: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7qs); return(OK); */ - case BSIM4_QB: - value->rValue = here->BSIM4qbulk; - value->rValue *= here->BSIM4m; + case BSIM4v7_QB: + value->rValue = here->BSIM4v7qbulk; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_QG: - value->rValue = here->BSIM4qgate; - value->rValue *= here->BSIM4m; + case BSIM4v7_QG: + value->rValue = here->BSIM4v7qgate; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_QS: - value->rValue = here->BSIM4qsrc; - value->rValue *= here->BSIM4m; + case BSIM4v7_QS: + value->rValue = here->BSIM4v7qsrc; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_QD: - value->rValue = here->BSIM4qdrn; - value->rValue *= here->BSIM4m; + case BSIM4v7_QD: + value->rValue = here->BSIM4v7qdrn; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_QDEF: - value->rValue = *(ckt->CKTstate0 + here->BSIM4qdef); + case BSIM4v7_QDEF: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7qdef); return(OK); - case BSIM4_GCRG: - value->rValue = here->BSIM4gcrg; - value->rValue *= here->BSIM4m; + case BSIM4v7_GCRG: + value->rValue = here->BSIM4v7gcrg; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_GTAU: - value->rValue = here->BSIM4gtau; - value->rValue *= here->BSIM4m; + case BSIM4v7_GTAU: + value->rValue = here->BSIM4v7gtau; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CGGB: - value->rValue = here->BSIM4cggb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CGGB: + value->rValue = here->BSIM4v7cggb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CGDB: - value->rValue = here->BSIM4cgdb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CGDB: + value->rValue = here->BSIM4v7cgdb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CGSB: - value->rValue = here->BSIM4cgsb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CGSB: + value->rValue = here->BSIM4v7cgsb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CDGB: - value->rValue = here->BSIM4cdgb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CDGB: + value->rValue = here->BSIM4v7cdgb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CDDB: - value->rValue = here->BSIM4cddb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CDDB: + value->rValue = here->BSIM4v7cddb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CDSB: - value->rValue = here->BSIM4cdsb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CDSB: + value->rValue = here->BSIM4v7cdsb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CBGB: - value->rValue = here->BSIM4cbgb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CBGB: + value->rValue = here->BSIM4v7cbgb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CBDB: - value->rValue = here->BSIM4cbdb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CBDB: + value->rValue = here->BSIM4v7cbdb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CBSB: - value->rValue = here->BSIM4cbsb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CBSB: + value->rValue = here->BSIM4v7cbsb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CSGB: - value->rValue = here->BSIM4csgb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CSGB: + value->rValue = here->BSIM4v7csgb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CSDB: - value->rValue = here->BSIM4csdb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CSDB: + value->rValue = here->BSIM4v7csdb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CSSB: - value->rValue = here->BSIM4cssb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CSSB: + value->rValue = here->BSIM4v7cssb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CGBB: - value->rValue = here->BSIM4cgbb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CGBB: + value->rValue = here->BSIM4v7cgbb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CDBB: - value->rValue = here->BSIM4cdbb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CDBB: + value->rValue = here->BSIM4v7cdbb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CSBB: - value->rValue = here->BSIM4csbb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CSBB: + value->rValue = here->BSIM4v7csbb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CBBB: - value->rValue = here->BSIM4cbbb; - value->rValue *= here->BSIM4m; + case BSIM4v7_CBBB: + value->rValue = here->BSIM4v7cbbb; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CAPBD: - value->rValue = here->BSIM4capbd; - value->rValue *= here->BSIM4m; + case BSIM4v7_CAPBD: + value->rValue = here->BSIM4v7capbd; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_CAPBS: - value->rValue = here->BSIM4capbs; - value->rValue *= here->BSIM4m; + case BSIM4v7_CAPBS: + value->rValue = here->BSIM4v7capbs; + value->rValue *= here->BSIM4v7m; return(OK); - case BSIM4_VON: - value->rValue = here->BSIM4von; + case BSIM4v7_VON: + value->rValue = here->BSIM4v7von; return(OK); - case BSIM4_VDSAT: - value->rValue = here->BSIM4vdsat; + case BSIM4v7_VDSAT: + value->rValue = here->BSIM4v7vdsat; return(OK); - case BSIM4_QBS: - value->rValue = *(ckt->CKTstate0 + here->BSIM4qbs); + case BSIM4v7_QBS: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7qbs); return(OK); - case BSIM4_QBD: - value->rValue = *(ckt->CKTstate0 + here->BSIM4qbd); + case BSIM4v7_QBD: + value->rValue = *(ckt->CKTstate0 + here->BSIM4v7qbd); return(OK); default: return(E_BADPARM); diff --git a/src/spicelib/devices/bsim4v7/b4v7check.c b/src/spicelib/devices/bsim4v7/b4v7check.c index dc5c8ec8e..981022f2f 100644 --- a/src/spicelib/devices/bsim4v7/b4v7check.c +++ b/src/spicelib/devices/bsim4v7/b4v7check.c @@ -22,7 +22,7 @@ #include "ngspice/ngspice.h" #include "ngspice/cktdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/trandefs.h" #include "ngspice/const.h" #include "ngspice/sperror.h" @@ -30,9 +30,9 @@ #include "ngspice/suffix.h" int -BSIM4checkModel( -BSIM4model *model, -BSIM4instance *here, +BSIM4v7checkModel( +BSIM4v7model *model, +BSIM4v7instance *here, CKTcircuit *ckt) { struct bsim4SizeDependParam *pParam; @@ -41,848 +41,848 @@ FILE *fplog; if ((fplog = fopen("bsim4.out", "w")) != NULL) { pParam = here->pParam; - fprintf(fplog, "BSIM4: Berkeley Short Channel IGFET Model-4\n"); + fprintf(fplog, "BSIM4v7: Berkeley Short Channel IGFET Model-4\n"); fprintf(fplog, "Developed by Xuemei (Jane) Xi, Mohan Dunga, Prof. Ali Niknejad and Prof. Chenming Hu in 2003.\n"); fprintf(fplog, "\n"); - fprintf(fplog, "++++++++++ BSIM4 PARAMETER CHECKING BELOW ++++++++++\n"); + fprintf(fplog, "++++++++++ BSIM4v7 PARAMETER CHECKING BELOW ++++++++++\n"); - if ((strcmp(model->BSIM4version, "4.7.0")) && (strcmp(model->BSIM4version, "4.70")) && (strcmp(model->BSIM4version, "4.7"))) + if ((strcmp(model->BSIM4v7version, "4.7.0")) && (strcmp(model->BSIM4v7version, "4.70")) && (strcmp(model->BSIM4v7version, "4.7"))) { fprintf(fplog, "Warning: This model is BSIM4.7.0; you specified a wrong version number.\n"); printf("Warning: This model is BSIM4.7.0; you specified a wrong version number.\n"); } - fprintf(fplog, "Model = %s\n", model->BSIM4modName); + fprintf(fplog, "Model = %s\n", model->BSIM4v7modName); - if ((here->BSIM4rgateMod == 2) || (here->BSIM4rgateMod == 3)) - { if ((here->BSIM4trnqsMod == 1) || (here->BSIM4acnqsMod == 1)) + if ((here->BSIM4v7rgateMod == 2) || (here->BSIM4v7rgateMod == 3)) + { if ((here->BSIM4v7trnqsMod == 1) || (here->BSIM4v7acnqsMod == 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->BSIM4toxe <= 0.0) + if (model->BSIM4v7toxe <= 0.0) { fprintf(fplog, "Fatal: Toxe = %g is not positive.\n", - model->BSIM4toxe); - printf("Fatal: Toxe = %g is not positive.\n", model->BSIM4toxe); + model->BSIM4v7toxe); + printf("Fatal: Toxe = %g is not positive.\n", model->BSIM4v7toxe); Fatal_Flag = 1; } - if (model->BSIM4toxp <= 0.0) + if (model->BSIM4v7toxp <= 0.0) { fprintf(fplog, "Fatal: Toxp = %g is not positive.\n", - model->BSIM4toxp); - printf("Fatal: Toxp = %g is not positive.\n", model->BSIM4toxp); + model->BSIM4v7toxp); + printf("Fatal: Toxp = %g is not positive.\n", model->BSIM4v7toxp); Fatal_Flag = 1; } - if (model->BSIM4eot <= 0.0) + if (model->BSIM4v7eot <= 0.0) { fprintf(fplog, "Fatal: EOT = %g is not positive.\n", - model->BSIM4eot); - printf("Fatal: EOT = %g is not positive.\n", model->BSIM4eot); + model->BSIM4v7eot); + printf("Fatal: EOT = %g is not positive.\n", model->BSIM4v7eot); Fatal_Flag = 1; } - if (model->BSIM4epsrgate < 0.0) + if (model->BSIM4v7epsrgate < 0.0) { fprintf(fplog, "Fatal: Epsrgate = %g is not positive.\n", - model->BSIM4epsrgate); - printf("Fatal: Epsrgate = %g is not positive.\n", model->BSIM4epsrgate); + model->BSIM4v7epsrgate); + printf("Fatal: Epsrgate = %g is not positive.\n", model->BSIM4v7epsrgate); Fatal_Flag = 1; } - if (model->BSIM4epsrsub < 0.0) + if (model->BSIM4v7epsrsub < 0.0) { fprintf(fplog, "Fatal: Epsrsub = %g is not positive.\n", - model->BSIM4epsrsub); - printf("Fatal: Epsrsub = %g is not positive.\n", model->BSIM4epsrsub); + model->BSIM4v7epsrsub); + printf("Fatal: Epsrsub = %g is not positive.\n", model->BSIM4v7epsrsub); Fatal_Flag = 1; } - if (model->BSIM4easub < 0.0) + if (model->BSIM4v7easub < 0.0) { fprintf(fplog, "Fatal: Easub = %g is not positive.\n", - model->BSIM4easub); - printf("Fatal: Easub = %g is not positive.\n", model->BSIM4easub); + model->BSIM4v7easub); + printf("Fatal: Easub = %g is not positive.\n", model->BSIM4v7easub); Fatal_Flag = 1; } - if (model->BSIM4ni0sub <= 0.0) + if (model->BSIM4v7ni0sub <= 0.0) { fprintf(fplog, "Fatal: Ni0sub = %g is not positive.\n", - model->BSIM4ni0sub); - printf("Fatal: Easub = %g is not positive.\n", model->BSIM4ni0sub); + model->BSIM4v7ni0sub); + printf("Fatal: Easub = %g is not positive.\n", model->BSIM4v7ni0sub); Fatal_Flag = 1; } - if (model->BSIM4toxm <= 0.0) + if (model->BSIM4v7toxm <= 0.0) { fprintf(fplog, "Fatal: Toxm = %g is not positive.\n", - model->BSIM4toxm); - printf("Fatal: Toxm = %g is not positive.\n", model->BSIM4toxm); + model->BSIM4v7toxm); + printf("Fatal: Toxm = %g is not positive.\n", model->BSIM4v7toxm); Fatal_Flag = 1; } - if (model->BSIM4toxref <= 0.0) + if (model->BSIM4v7toxref <= 0.0) { fprintf(fplog, "Fatal: Toxref = %g is not positive.\n", - model->BSIM4toxref); - printf("Fatal: Toxref = %g is not positive.\n", model->BSIM4toxref); + model->BSIM4v7toxref); + printf("Fatal: Toxref = %g is not positive.\n", model->BSIM4v7toxref); Fatal_Flag = 1; } - if (pParam->BSIM4lpe0 < -pParam->BSIM4leff) + if (pParam->BSIM4v7lpe0 < -pParam->BSIM4v7leff) { fprintf(fplog, "Fatal: Lpe0 = %g is less than -Leff.\n", - pParam->BSIM4lpe0); + pParam->BSIM4v7lpe0); printf("Fatal: Lpe0 = %g is less than -Leff.\n", - pParam->BSIM4lpe0); + pParam->BSIM4v7lpe0); Fatal_Flag = 1; } - if (model->BSIM4lintnoi > pParam->BSIM4leff/2) + if (model->BSIM4v7lintnoi > pParam->BSIM4v7leff/2) { fprintf(fplog, "Fatal: Lintnoi = %g is too large - Leff for noise is negative.\n", - model->BSIM4lintnoi); + model->BSIM4v7lintnoi); printf("Fatal: Lintnoi = %g is too large - Leff for noise is negative.\n", - model->BSIM4lintnoi); + model->BSIM4v7lintnoi); Fatal_Flag = 1; } - if (pParam->BSIM4lpeb < -pParam->BSIM4leff) + if (pParam->BSIM4v7lpeb < -pParam->BSIM4v7leff) { fprintf(fplog, "Fatal: Lpeb = %g is less than -Leff.\n", - pParam->BSIM4lpeb); + pParam->BSIM4v7lpeb); printf("Fatal: Lpeb = %g is less than -Leff.\n", - pParam->BSIM4lpeb); + pParam->BSIM4v7lpeb); Fatal_Flag = 1; } - if (pParam->BSIM4ndep <= 0.0) + if (pParam->BSIM4v7ndep <= 0.0) { fprintf(fplog, "Fatal: Ndep = %g is not positive.\n", - pParam->BSIM4ndep); + pParam->BSIM4v7ndep); printf("Fatal: Ndep = %g is not positive.\n", - pParam->BSIM4ndep); + pParam->BSIM4v7ndep); Fatal_Flag = 1; } - if (pParam->BSIM4phi <= 0.0) + if (pParam->BSIM4v7phi <= 0.0) { fprintf(fplog, "Fatal: Phi = %g is not positive. Please check Phin and Ndep\n", - pParam->BSIM4phi); + pParam->BSIM4v7phi); fprintf(fplog, " Phin = %g Ndep = %g \n", - pParam->BSIM4phin, pParam->BSIM4ndep); + pParam->BSIM4v7phin, pParam->BSIM4v7ndep); printf("Fatal: Phi = %g is not positive. Please check Phin and Ndep\n", - pParam->BSIM4phi); + pParam->BSIM4v7phi); printf(" Phin = %g Ndep = %g \n", - pParam->BSIM4phin, pParam->BSIM4ndep); + pParam->BSIM4v7phin, pParam->BSIM4v7ndep); Fatal_Flag = 1; } - if (pParam->BSIM4nsub <= 0.0) + if (pParam->BSIM4v7nsub <= 0.0) { fprintf(fplog, "Fatal: Nsub = %g is not positive.\n", - pParam->BSIM4nsub); + pParam->BSIM4v7nsub); printf("Fatal: Nsub = %g is not positive.\n", - pParam->BSIM4nsub); + pParam->BSIM4v7nsub); Fatal_Flag = 1; } - if (pParam->BSIM4ngate < 0.0) + if (pParam->BSIM4v7ngate < 0.0) { fprintf(fplog, "Fatal: Ngate = %g is not positive.\n", - pParam->BSIM4ngate); + pParam->BSIM4v7ngate); printf("Fatal: Ngate = %g Ngate is not positive.\n", - pParam->BSIM4ngate); + pParam->BSIM4v7ngate); Fatal_Flag = 1; } - if (pParam->BSIM4ngate > 1.e25) + if (pParam->BSIM4v7ngate > 1.e25) { fprintf(fplog, "Fatal: Ngate = %g is too high.\n", - pParam->BSIM4ngate); + pParam->BSIM4v7ngate); printf("Fatal: Ngate = %g Ngate is too high\n", - pParam->BSIM4ngate); + pParam->BSIM4v7ngate); Fatal_Flag = 1; } - if (pParam->BSIM4xj <= 0.0) + if (pParam->BSIM4v7xj <= 0.0) { fprintf(fplog, "Fatal: Xj = %g is not positive.\n", - pParam->BSIM4xj); - printf("Fatal: Xj = %g is not positive.\n", pParam->BSIM4xj); + pParam->BSIM4v7xj); + printf("Fatal: Xj = %g is not positive.\n", pParam->BSIM4v7xj); Fatal_Flag = 1; } - if (pParam->BSIM4dvt1 < 0.0) + if (pParam->BSIM4v7dvt1 < 0.0) { fprintf(fplog, "Fatal: Dvt1 = %g is negative.\n", - pParam->BSIM4dvt1); - printf("Fatal: Dvt1 = %g is negative.\n", pParam->BSIM4dvt1); + pParam->BSIM4v7dvt1); + printf("Fatal: Dvt1 = %g is negative.\n", pParam->BSIM4v7dvt1); Fatal_Flag = 1; } - if (pParam->BSIM4dvt1w < 0.0) + if (pParam->BSIM4v7dvt1w < 0.0) { fprintf(fplog, "Fatal: Dvt1w = %g is negative.\n", - pParam->BSIM4dvt1w); - printf("Fatal: Dvt1w = %g is negative.\n", pParam->BSIM4dvt1w); + pParam->BSIM4v7dvt1w); + printf("Fatal: Dvt1w = %g is negative.\n", pParam->BSIM4v7dvt1w); Fatal_Flag = 1; } - if (pParam->BSIM4w0 == -pParam->BSIM4weff) + if (pParam->BSIM4v7w0 == -pParam->BSIM4v7weff) { 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->BSIM4dsub < 0.0) - { fprintf(fplog, "Fatal: Dsub = %g is negative.\n", pParam->BSIM4dsub); - printf("Fatal: Dsub = %g is negative.\n", pParam->BSIM4dsub); + if (pParam->BSIM4v7dsub < 0.0) + { fprintf(fplog, "Fatal: Dsub = %g is negative.\n", pParam->BSIM4v7dsub); + printf("Fatal: Dsub = %g is negative.\n", pParam->BSIM4v7dsub); Fatal_Flag = 1; } - if (pParam->BSIM4b1 == -pParam->BSIM4weff) + if (pParam->BSIM4v7b1 == -pParam->BSIM4v7weff) { 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->BSIM4u0temp <= 0.0) - { fprintf(fplog, "Fatal: u0 at current temperature = %g is not positive.\n", here->BSIM4u0temp); + if (here->BSIM4v7u0temp <= 0.0) + { fprintf(fplog, "Fatal: u0 at current temperature = %g is not positive.\n", here->BSIM4v7u0temp); printf("Fatal: u0 at current temperature = %g is not positive.\n", - here->BSIM4u0temp); + here->BSIM4v7u0temp); Fatal_Flag = 1; } - if (pParam->BSIM4delta < 0.0) + if (pParam->BSIM4v7delta < 0.0) { fprintf(fplog, "Fatal: Delta = %g is less than zero.\n", - pParam->BSIM4delta); - printf("Fatal: Delta = %g is less than zero.\n", pParam->BSIM4delta); + pParam->BSIM4v7delta); + printf("Fatal: Delta = %g is less than zero.\n", pParam->BSIM4v7delta); Fatal_Flag = 1; } - if (here->BSIM4vsattemp <= 0.0) - { fprintf(fplog, "Fatal: Vsat at current temperature = %g is not positive.\n", here->BSIM4vsattemp); + if (here->BSIM4v7vsattemp <= 0.0) + { fprintf(fplog, "Fatal: Vsat at current temperature = %g is not positive.\n", here->BSIM4v7vsattemp); printf("Fatal: Vsat at current temperature = %g is not positive.\n", - here->BSIM4vsattemp); + here->BSIM4v7vsattemp); Fatal_Flag = 1; } - if (pParam->BSIM4pclm <= 0.0) - { fprintf(fplog, "Fatal: Pclm = %g is not positive.\n", pParam->BSIM4pclm); - printf("Fatal: Pclm = %g is not positive.\n", pParam->BSIM4pclm); + if (pParam->BSIM4v7pclm <= 0.0) + { fprintf(fplog, "Fatal: Pclm = %g is not positive.\n", pParam->BSIM4v7pclm); + printf("Fatal: Pclm = %g is not positive.\n", pParam->BSIM4v7pclm); Fatal_Flag = 1; } - if (pParam->BSIM4drout < 0.0) - { fprintf(fplog, "Fatal: Drout = %g is negative.\n", pParam->BSIM4drout); - printf("Fatal: Drout = %g is negative.\n", pParam->BSIM4drout); + if (pParam->BSIM4v7drout < 0.0) + { fprintf(fplog, "Fatal: Drout = %g is negative.\n", pParam->BSIM4v7drout); + printf("Fatal: Drout = %g is negative.\n", pParam->BSIM4v7drout); Fatal_Flag = 1; } - if (here->BSIM4m < 1.0) - { fprintf(fplog, "Fatal: Number of multiplier = %g is smaller than one.\n", here->BSIM4m); - printf("Fatal: Number of multiplier = %g is smaller than one.\n", here->BSIM4m); + if (here->BSIM4v7m < 1.0) + { fprintf(fplog, "Fatal: Number of multiplier = %g is smaller than one.\n", here->BSIM4v7m); + printf("Fatal: Number of multiplier = %g is smaller than one.\n", here->BSIM4v7m); Fatal_Flag = 1; } - if (here->BSIM4nf < 1.0) - { fprintf(fplog, "Fatal: Number of finger = %g is smaller than one.\n", here->BSIM4nf); - printf("Fatal: Number of finger = %g is smaller than one.\n", here->BSIM4nf); + if (here->BSIM4v7nf < 1.0) + { fprintf(fplog, "Fatal: Number of finger = %g is smaller than one.\n", here->BSIM4v7nf); + printf("Fatal: Number of finger = %g is smaller than one.\n", here->BSIM4v7nf); Fatal_Flag = 1; } - if((here->BSIM4sa > 0.0) && (here->BSIM4sb > 0.0) && - ((here->BSIM4nf == 1.0) || ((here->BSIM4nf > 1.0) && (here->BSIM4sd > 0.0))) ) - { if (model->BSIM4saref <= 0.0) - { fprintf(fplog, "Fatal: SAref = %g is not positive.\n",model->BSIM4saref); - printf("Fatal: SAref = %g is not positive.\n",model->BSIM4saref); + if((here->BSIM4v7sa > 0.0) && (here->BSIM4v7sb > 0.0) && + ((here->BSIM4v7nf == 1.0) || ((here->BSIM4v7nf > 1.0) && (here->BSIM4v7sd > 0.0))) ) + { if (model->BSIM4v7saref <= 0.0) + { fprintf(fplog, "Fatal: SAref = %g is not positive.\n",model->BSIM4v7saref); + printf("Fatal: SAref = %g is not positive.\n",model->BSIM4v7saref); Fatal_Flag = 1; } - if (model->BSIM4sbref <= 0.0) - { fprintf(fplog, "Fatal: SBref = %g is not positive.\n",model->BSIM4sbref); - printf("Fatal: SBref = %g is not positive.\n",model->BSIM4sbref); + if (model->BSIM4v7sbref <= 0.0) + { fprintf(fplog, "Fatal: SBref = %g is not positive.\n",model->BSIM4v7sbref); + printf("Fatal: SBref = %g is not positive.\n",model->BSIM4v7sbref); Fatal_Flag = 1; } } - if ((here->BSIM4l + model->BSIM4xl) <= model->BSIM4xgl) + if ((here->BSIM4v7l + model->BSIM4v7xl) <= model->BSIM4v7xgl) { 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 (here->BSIM4ngcon < 1.0) + if (here->BSIM4v7ngcon < 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 ((here->BSIM4ngcon != 1.0) && (here->BSIM4ngcon != 2.0)) - { here->BSIM4ngcon = 1.0; + if ((here->BSIM4v7ngcon != 1.0) && (here->BSIM4v7ngcon != 2.0)) + { here->BSIM4v7ngcon = 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->BSIM4gbmin < 1.0e-20) + if (model->BSIM4v7gbmin < 1.0e-20) { fprintf(fplog, "Warning: Gbmin = %g is too small.\n", - model->BSIM4gbmin); - printf("Warning: Gbmin = %g is too small.\n", model->BSIM4gbmin); + model->BSIM4v7gbmin); + printf("Warning: Gbmin = %g is too small.\n", model->BSIM4v7gbmin); } /* Check saturation parameters */ - if (pParam->BSIM4fprout < 0.0) + if (pParam->BSIM4v7fprout < 0.0) { fprintf(fplog, "Fatal: fprout = %g is negative.\n", - pParam->BSIM4fprout); - printf("Fatal: fprout = %g is negative.\n", pParam->BSIM4fprout); + pParam->BSIM4v7fprout); + printf("Fatal: fprout = %g is negative.\n", pParam->BSIM4v7fprout); Fatal_Flag = 1; } - if (pParam->BSIM4pdits < 0.0) + if (pParam->BSIM4v7pdits < 0.0) { fprintf(fplog, "Fatal: pdits = %g is negative.\n", - pParam->BSIM4pdits); - printf("Fatal: pdits = %g is negative.\n", pParam->BSIM4pdits); + pParam->BSIM4v7pdits); + printf("Fatal: pdits = %g is negative.\n", pParam->BSIM4v7pdits); Fatal_Flag = 1; } - if (model->BSIM4pditsl < 0.0) + if (model->BSIM4v7pditsl < 0.0) { fprintf(fplog, "Fatal: pditsl = %g is negative.\n", - model->BSIM4pditsl); - printf("Fatal: pditsl = %g is negative.\n", model->BSIM4pditsl); + model->BSIM4v7pditsl); + printf("Fatal: pditsl = %g is negative.\n", model->BSIM4v7pditsl); Fatal_Flag = 1; } /* Check gate current parameters */ - if (model->BSIM4igbMod) { - if (pParam->BSIM4nigbinv <= 0.0) + if (model->BSIM4v7igbMod) { + if (pParam->BSIM4v7nigbinv <= 0.0) { fprintf(fplog, "Fatal: nigbinv = %g is non-positive.\n", - pParam->BSIM4nigbinv); - printf("Fatal: nigbinv = %g is non-positive.\n", pParam->BSIM4nigbinv); + pParam->BSIM4v7nigbinv); + printf("Fatal: nigbinv = %g is non-positive.\n", pParam->BSIM4v7nigbinv); Fatal_Flag = 1; } - if (pParam->BSIM4nigbacc <= 0.0) + if (pParam->BSIM4v7nigbacc <= 0.0) { fprintf(fplog, "Fatal: nigbacc = %g is non-positive.\n", - pParam->BSIM4nigbacc); - printf("Fatal: nigbacc = %g is non-positive.\n", pParam->BSIM4nigbacc); + pParam->BSIM4v7nigbacc); + printf("Fatal: nigbacc = %g is non-positive.\n", pParam->BSIM4v7nigbacc); Fatal_Flag = 1; } } - if (model->BSIM4igcMod) { - if (pParam->BSIM4nigc <= 0.0) + if (model->BSIM4v7igcMod) { + if (pParam->BSIM4v7nigc <= 0.0) { fprintf(fplog, "Fatal: nigc = %g is non-positive.\n", - pParam->BSIM4nigc); - printf("Fatal: nigc = %g is non-positive.\n", pParam->BSIM4nigc); + pParam->BSIM4v7nigc); + printf("Fatal: nigc = %g is non-positive.\n", pParam->BSIM4v7nigc); Fatal_Flag = 1; } - if (pParam->BSIM4poxedge <= 0.0) + if (pParam->BSIM4v7poxedge <= 0.0) { fprintf(fplog, "Fatal: poxedge = %g is non-positive.\n", - pParam->BSIM4poxedge); - printf("Fatal: poxedge = %g is non-positive.\n", pParam->BSIM4poxedge); + pParam->BSIM4v7poxedge); + printf("Fatal: poxedge = %g is non-positive.\n", pParam->BSIM4v7poxedge); Fatal_Flag = 1; } - if (pParam->BSIM4pigcd <= 0.0) + if (pParam->BSIM4v7pigcd <= 0.0) { fprintf(fplog, "Fatal: pigcd = %g is non-positive.\n", - pParam->BSIM4pigcd); - printf("Fatal: pigcd = %g is non-positive.\n", pParam->BSIM4pigcd); + pParam->BSIM4v7pigcd); + printf("Fatal: pigcd = %g is non-positive.\n", pParam->BSIM4v7pigcd); Fatal_Flag = 1; } } /* Check capacitance parameters */ - if (pParam->BSIM4clc < 0.0) - { fprintf(fplog, "Fatal: Clc = %g is negative.\n", pParam->BSIM4clc); - printf("Fatal: Clc = %g is negative.\n", pParam->BSIM4clc); + if (pParam->BSIM4v7clc < 0.0) + { fprintf(fplog, "Fatal: Clc = %g is negative.\n", pParam->BSIM4v7clc); + printf("Fatal: Clc = %g is negative.\n", pParam->BSIM4v7clc); Fatal_Flag = 1; } /* Check overlap capacitance parameters */ - if (pParam->BSIM4ckappas < 0.02) + if (pParam->BSIM4v7ckappas < 0.02) { fprintf(fplog, "Warning: ckappas = %g is too small. Set to 0.02\n", - pParam->BSIM4ckappas); - printf("Warning: ckappas = %g is too small.\n", pParam->BSIM4ckappas); - pParam->BSIM4ckappas = 0.02; + pParam->BSIM4v7ckappas); + printf("Warning: ckappas = %g is too small.\n", pParam->BSIM4v7ckappas); + pParam->BSIM4v7ckappas = 0.02; } - if (pParam->BSIM4ckappad < 0.02) + if (pParam->BSIM4v7ckappad < 0.02) { fprintf(fplog, "Warning: ckappad = %g is too small. Set to 0.02\n", - pParam->BSIM4ckappad); - printf("Warning: ckappad = %g is too small.\n", pParam->BSIM4ckappad); - pParam->BSIM4ckappad = 0.02; + pParam->BSIM4v7ckappad); + printf("Warning: ckappad = %g is too small.\n", pParam->BSIM4v7ckappad); + pParam->BSIM4v7ckappad = 0.02; } - if (model->BSIM4vtss < 0.0) + if (model->BSIM4v7vtss < 0.0) { fprintf(fplog, "Fatal: Vtss = %g is negative.\n", - model->BSIM4vtss); + model->BSIM4v7vtss); printf("Fatal: Vtss = %g is negative.\n", - model->BSIM4vtss); + model->BSIM4v7vtss); Fatal_Flag = 1; } - if (model->BSIM4vtsd < 0.0) + if (model->BSIM4v7vtsd < 0.0) { fprintf(fplog, "Fatal: Vtsd = %g is negative.\n", - model->BSIM4vtsd); + model->BSIM4v7vtsd); printf("Fatal: Vtsd = %g is negative.\n", - model->BSIM4vtsd); + model->BSIM4v7vtsd); Fatal_Flag = 1; } - if (model->BSIM4vtssws < 0.0) + if (model->BSIM4v7vtssws < 0.0) { fprintf(fplog, "Fatal: Vtssws = %g is negative.\n", - model->BSIM4vtssws); + model->BSIM4v7vtssws); printf("Fatal: Vtssws = %g is negative.\n", - model->BSIM4vtssws); + model->BSIM4v7vtssws); Fatal_Flag = 1; } - if (model->BSIM4vtsswd < 0.0) + if (model->BSIM4v7vtsswd < 0.0) { fprintf(fplog, "Fatal: Vtsswd = %g is negative.\n", - model->BSIM4vtsswd); + model->BSIM4v7vtsswd); printf("Fatal: Vtsswd = %g is negative.\n", - model->BSIM4vtsswd); + model->BSIM4v7vtsswd); Fatal_Flag = 1; } - if (model->BSIM4vtsswgs < 0.0) + if (model->BSIM4v7vtsswgs < 0.0) { fprintf(fplog, "Fatal: Vtsswgs = %g is negative.\n", - model->BSIM4vtsswgs); + model->BSIM4v7vtsswgs); printf("Fatal: Vtsswgs = %g is negative.\n", - model->BSIM4vtsswgs); + model->BSIM4v7vtsswgs); Fatal_Flag = 1; } - if (model->BSIM4vtsswgd < 0.0) + if (model->BSIM4v7vtsswgd < 0.0) { fprintf(fplog, "Fatal: Vtsswgd = %g is negative.\n", - model->BSIM4vtsswgd); + model->BSIM4v7vtsswgd); printf("Fatal: Vtsswgd = %g is negative.\n", - model->BSIM4vtsswgd); + model->BSIM4v7vtsswgd); Fatal_Flag = 1; } - if (model->BSIM4paramChk ==1) + if (model->BSIM4v7paramChk ==1) { /* Check L and W parameters */ - if (pParam->BSIM4leff <= 1.0e-9) + if (pParam->BSIM4v7leff <= 1.0e-9) { fprintf(fplog, "Warning: Leff = %g <= 1.0e-9. Recommended Leff >= 1e-8 \n", - pParam->BSIM4leff); + pParam->BSIM4v7leff); printf("Warning: Leff = %g <= 1.0e-9. Recommended Leff >= 1e-8 \n", - pParam->BSIM4leff); + pParam->BSIM4v7leff); } - if (pParam->BSIM4leffCV <= 1.0e-9) + if (pParam->BSIM4v7leffCV <= 1.0e-9) { fprintf(fplog, "Warning: Leff for CV = %g <= 1.0e-9. Recommended LeffCV >=1e-8 \n", - pParam->BSIM4leffCV); + pParam->BSIM4v7leffCV); printf("Warning: Leff for CV = %g <= 1.0e-9. Recommended LeffCV >=1e-8 \n", - pParam->BSIM4leffCV); + pParam->BSIM4v7leffCV); } - if (pParam->BSIM4weff <= 1.0e-9) + if (pParam->BSIM4v7weff <= 1.0e-9) { fprintf(fplog, "Warning: Weff = %g <= 1.0e-9. Recommended Weff >=1e-7 \n", - pParam->BSIM4weff); + pParam->BSIM4v7weff); printf("Warning: Weff = %g <= 1.0e-9. Recommended Weff >=1e-7 \n", - pParam->BSIM4weff); + pParam->BSIM4v7weff); } - if (pParam->BSIM4weffCV <= 1.0e-9) + if (pParam->BSIM4v7weffCV <= 1.0e-9) { fprintf(fplog, "Warning: Weff for CV = %g <= 1.0e-9. Recommended WeffCV >= 1e-7 \n", - pParam->BSIM4weffCV); + pParam->BSIM4v7weffCV); printf("Warning: Weff for CV = %g <= 1.0e-9. Recommended WeffCV >= 1e-7 \n", - pParam->BSIM4weffCV); + pParam->BSIM4v7weffCV); } /* Check threshold voltage parameters */ - if (model->BSIM4toxe < 1.0e-10) + if (model->BSIM4v7toxe < 1.0e-10) { fprintf(fplog, "Warning: Toxe = %g is less than 1A. Recommended Toxe >= 5A\n", - model->BSIM4toxe); - printf("Warning: Toxe = %g is less than 1A. Recommended Toxe >= 5A\n", model->BSIM4toxe); + model->BSIM4v7toxe); + printf("Warning: Toxe = %g is less than 1A. Recommended Toxe >= 5A\n", model->BSIM4v7toxe); } - if (model->BSIM4toxp < 1.0e-10) + if (model->BSIM4v7toxp < 1.0e-10) { fprintf(fplog, "Warning: Toxp = %g is less than 1A. Recommended Toxp >= 5A\n", - model->BSIM4toxp); - printf("Warning: Toxp = %g is less than 1A. Recommended Toxp >= 5A\n", model->BSIM4toxp); + model->BSIM4v7toxp); + printf("Warning: Toxp = %g is less than 1A. Recommended Toxp >= 5A\n", model->BSIM4v7toxp); } - if (model->BSIM4toxm < 1.0e-10) + if (model->BSIM4v7toxm < 1.0e-10) { fprintf(fplog, "Warning: Toxm = %g is less than 1A. Recommended Toxm >= 5A\n", - model->BSIM4toxm); - printf("Warning: Toxm = %g is less than 1A. Recommended Toxm >= 5A\n", model->BSIM4toxm); + model->BSIM4v7toxm); + printf("Warning: Toxm = %g is less than 1A. Recommended Toxm >= 5A\n", model->BSIM4v7toxm); } - if (pParam->BSIM4ndep <= 1.0e12) + if (pParam->BSIM4v7ndep <= 1.0e12) { fprintf(fplog, "Warning: Ndep = %g may be too small.\n", - pParam->BSIM4ndep); + pParam->BSIM4v7ndep); printf("Warning: Ndep = %g may be too small.\n", - pParam->BSIM4ndep); + pParam->BSIM4v7ndep); } - else if (pParam->BSIM4ndep >= 1.0e21) + else if (pParam->BSIM4v7ndep >= 1.0e21) { fprintf(fplog, "Warning: Ndep = %g may be too large.\n", - pParam->BSIM4ndep); + pParam->BSIM4v7ndep); printf("Warning: Ndep = %g may be too large.\n", - pParam->BSIM4ndep); + pParam->BSIM4v7ndep); } - if (pParam->BSIM4nsub <= 1.0e14) + if (pParam->BSIM4v7nsub <= 1.0e14) { fprintf(fplog, "Warning: Nsub = %g may be too small.\n", - pParam->BSIM4nsub); + pParam->BSIM4v7nsub); printf("Warning: Nsub = %g may be too small.\n", - pParam->BSIM4nsub); + pParam->BSIM4v7nsub); } - else if (pParam->BSIM4nsub >= 1.0e21) + else if (pParam->BSIM4v7nsub >= 1.0e21) { fprintf(fplog, "Warning: Nsub = %g may be too large.\n", - pParam->BSIM4nsub); + pParam->BSIM4v7nsub); printf("Warning: Nsub = %g may be too large.\n", - pParam->BSIM4nsub); + pParam->BSIM4v7nsub); } - if ((pParam->BSIM4ngate > 0.0) && - (pParam->BSIM4ngate <= 1.e18)) + if ((pParam->BSIM4v7ngate > 0.0) && + (pParam->BSIM4v7ngate <= 1.e18)) { fprintf(fplog, "Warning: Ngate = %g is less than 1.E18cm^-3.\n", - pParam->BSIM4ngate); + pParam->BSIM4v7ngate); printf("Warning: Ngate = %g is less than 1.E18cm^-3.\n", - pParam->BSIM4ngate); + pParam->BSIM4v7ngate); } - if (pParam->BSIM4dvt0 < 0.0) + if (pParam->BSIM4v7dvt0 < 0.0) { fprintf(fplog, "Warning: Dvt0 = %g is negative.\n", - pParam->BSIM4dvt0); - printf("Warning: Dvt0 = %g is negative.\n", pParam->BSIM4dvt0); + pParam->BSIM4v7dvt0); + printf("Warning: Dvt0 = %g is negative.\n", pParam->BSIM4v7dvt0); } - if (fabs(1.0e-8 / (pParam->BSIM4w0 + pParam->BSIM4weff)) > 10.0) + if (fabs(1.0e-8 / (pParam->BSIM4v7w0 + pParam->BSIM4v7weff)) > 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->BSIM4nfactor < 0.0) + if (pParam->BSIM4v7nfactor < 0.0) { fprintf(fplog, "Warning: Nfactor = %g is negative.\n", - pParam->BSIM4nfactor); - printf("Warning: Nfactor = %g is negative.\n", pParam->BSIM4nfactor); + pParam->BSIM4v7nfactor); + printf("Warning: Nfactor = %g is negative.\n", pParam->BSIM4v7nfactor); } - if (pParam->BSIM4cdsc < 0.0) + if (pParam->BSIM4v7cdsc < 0.0) { fprintf(fplog, "Warning: Cdsc = %g is negative.\n", - pParam->BSIM4cdsc); - printf("Warning: Cdsc = %g is negative.\n", pParam->BSIM4cdsc); + pParam->BSIM4v7cdsc); + printf("Warning: Cdsc = %g is negative.\n", pParam->BSIM4v7cdsc); } - if (pParam->BSIM4cdscd < 0.0) + if (pParam->BSIM4v7cdscd < 0.0) { fprintf(fplog, "Warning: Cdscd = %g is negative.\n", - pParam->BSIM4cdscd); - printf("Warning: Cdscd = %g is negative.\n", pParam->BSIM4cdscd); + pParam->BSIM4v7cdscd); + printf("Warning: Cdscd = %g is negative.\n", pParam->BSIM4v7cdscd); } /* Check DIBL parameters */ - if (here->BSIM4eta0 < 0.0) + if (here->BSIM4v7eta0 < 0.0) { fprintf(fplog, "Warning: Eta0 = %g is negative.\n", - here->BSIM4eta0); - printf("Warning: Eta0 = %g is negative.\n", here->BSIM4eta0); + here->BSIM4v7eta0); + printf("Warning: Eta0 = %g is negative.\n", here->BSIM4v7eta0); } /* Check Abulk parameters */ - if (fabs(1.0e-8 / (pParam->BSIM4b1 + pParam->BSIM4weff)) > 10.0) + if (fabs(1.0e-8 / (pParam->BSIM4v7b1 + pParam->BSIM4v7weff)) > 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->BSIM4a2 < 0.01) - { fprintf(fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", pParam->BSIM4a2); + if (pParam->BSIM4v7a2 < 0.01) + { fprintf(fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", pParam->BSIM4v7a2); printf("Warning: A2 = %g is too small. Set to 0.01.\n", - pParam->BSIM4a2); - pParam->BSIM4a2 = 0.01; + pParam->BSIM4v7a2); + pParam->BSIM4v7a2 = 0.01; } - else if (pParam->BSIM4a2 > 1.0) + else if (pParam->BSIM4v7a2 > 1.0) { fprintf(fplog, "Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n", - pParam->BSIM4a2); + pParam->BSIM4v7a2); printf("Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n", - pParam->BSIM4a2); - pParam->BSIM4a2 = 1.0; - pParam->BSIM4a1 = 0.0; + pParam->BSIM4v7a2); + pParam->BSIM4v7a2 = 1.0; + pParam->BSIM4v7a1 = 0.0; } - if (pParam->BSIM4prwg < 0.0) + if (pParam->BSIM4v7prwg < 0.0) { fprintf(fplog, "Warning: Prwg = %g is negative. Set to zero.\n", - pParam->BSIM4prwg); + pParam->BSIM4v7prwg); printf("Warning: Prwg = %g is negative. Set to zero.\n", - pParam->BSIM4prwg); - pParam->BSIM4prwg = 0.0; + pParam->BSIM4v7prwg); + pParam->BSIM4v7prwg = 0.0; } - if (pParam->BSIM4rdsw < 0.0) + if (pParam->BSIM4v7rdsw < 0.0) { fprintf(fplog, "Warning: Rdsw = %g is negative. Set to zero.\n", - pParam->BSIM4rdsw); + pParam->BSIM4v7rdsw); printf("Warning: Rdsw = %g is negative. Set to zero.\n", - pParam->BSIM4rdsw); - pParam->BSIM4rdsw = 0.0; - pParam->BSIM4rds0 = 0.0; + pParam->BSIM4v7rdsw); + pParam->BSIM4v7rdsw = 0.0; + pParam->BSIM4v7rds0 = 0.0; } - if (pParam->BSIM4rds0 < 0.0) + if (pParam->BSIM4v7rds0 < 0.0) { fprintf(fplog, "Warning: Rds at current temperature = %g is negative. Set to zero.\n", - pParam->BSIM4rds0); + pParam->BSIM4v7rds0); printf("Warning: Rds at current temperature = %g is negative. Set to zero.\n", - pParam->BSIM4rds0); - pParam->BSIM4rds0 = 0.0; + pParam->BSIM4v7rds0); + pParam->BSIM4v7rds0 = 0.0; } - if (pParam->BSIM4rdswmin < 0.0) + if (pParam->BSIM4v7rdswmin < 0.0) { fprintf(fplog, "Warning: Rdswmin at current temperature = %g is negative. Set to zero.\n", - pParam->BSIM4rdswmin); + pParam->BSIM4v7rdswmin); printf("Warning: Rdswmin at current temperature = %g is negative. Set to zero.\n", - pParam->BSIM4rdswmin); - pParam->BSIM4rdswmin = 0.0; + pParam->BSIM4v7rdswmin); + pParam->BSIM4v7rdswmin = 0.0; } - if (pParam->BSIM4pscbe2 <= 0.0) + if (pParam->BSIM4v7pscbe2 <= 0.0) { fprintf(fplog, "Warning: Pscbe2 = %g is not positive.\n", - pParam->BSIM4pscbe2); - printf("Warning: Pscbe2 = %g is not positive.\n", pParam->BSIM4pscbe2); + pParam->BSIM4v7pscbe2); + printf("Warning: Pscbe2 = %g is not positive.\n", pParam->BSIM4v7pscbe2); } - if (pParam->BSIM4vsattemp < 1.0e3) - { fprintf(fplog, "Warning: Vsat at current temperature = %g may be too small.\n", pParam->BSIM4vsattemp); - printf("Warning: Vsat at current temperature = %g may be too small.\n", pParam->BSIM4vsattemp); + if (pParam->BSIM4v7vsattemp < 1.0e3) + { fprintf(fplog, "Warning: Vsat at current temperature = %g may be too small.\n", pParam->BSIM4v7vsattemp); + printf("Warning: Vsat at current temperature = %g may be too small.\n", pParam->BSIM4v7vsattemp); } - if((model->BSIM4lambdaGiven) && (pParam->BSIM4lambda > 0.0) ) + if((model->BSIM4v7lambdaGiven) && (pParam->BSIM4v7lambda > 0.0) ) { - if (pParam->BSIM4lambda > 1.0e-9) - { fprintf(fplog, "Warning: Lambda = %g may be too large.\n", pParam->BSIM4lambda); - printf("Warning: Lambda = %g may be too large.\n", pParam->BSIM4lambda); + if (pParam->BSIM4v7lambda > 1.0e-9) + { fprintf(fplog, "Warning: Lambda = %g may be too large.\n", pParam->BSIM4v7lambda); + printf("Warning: Lambda = %g may be too large.\n", pParam->BSIM4v7lambda); } } - if((model->BSIM4vtlGiven) && (pParam->BSIM4vtl > 0.0) ) + if((model->BSIM4v7vtlGiven) && (pParam->BSIM4v7vtl > 0.0) ) { - if (pParam->BSIM4vtl < 6.0e4) - { fprintf(fplog, "Warning: Thermal velocity vtl = %g may be too small.\n", pParam->BSIM4vtl); - printf("Warning: Thermal velocity vtl = %g may be too small.\n", pParam->BSIM4vtl); + if (pParam->BSIM4v7vtl < 6.0e4) + { fprintf(fplog, "Warning: Thermal velocity vtl = %g may be too small.\n", pParam->BSIM4v7vtl); + printf("Warning: Thermal velocity vtl = %g may be too small.\n", pParam->BSIM4v7vtl); } - if (pParam->BSIM4xn < 3.0) - { fprintf(fplog, "Warning: back scattering coeff xn = %g is too small.\n", pParam->BSIM4xn); - printf("Warning: back scattering coeff xn = %g is too small. Reset to 3.0 \n", pParam->BSIM4xn); - pParam->BSIM4xn = 3.0; + if (pParam->BSIM4v7xn < 3.0) + { fprintf(fplog, "Warning: back scattering coeff xn = %g is too small.\n", pParam->BSIM4v7xn); + printf("Warning: back scattering coeff xn = %g is too small. Reset to 3.0 \n", pParam->BSIM4v7xn); + pParam->BSIM4v7xn = 3.0; } - if (model->BSIM4lc < 0.0) - { fprintf(fplog, "Warning: back scattering coeff lc = %g is too small.\n", model->BSIM4lc); - printf("Warning: back scattering coeff lc = %g is too small. Reset to 0.0\n", model->BSIM4lc); - pParam->BSIM4lc = 0.0; + if (model->BSIM4v7lc < 0.0) + { fprintf(fplog, "Warning: back scattering coeff lc = %g is too small.\n", model->BSIM4v7lc); + printf("Warning: back scattering coeff lc = %g is too small. Reset to 0.0\n", model->BSIM4v7lc); + pParam->BSIM4v7lc = 0.0; } } - if (pParam->BSIM4pdibl1 < 0.0) + if (pParam->BSIM4v7pdibl1 < 0.0) { fprintf(fplog, "Warning: Pdibl1 = %g is negative.\n", - pParam->BSIM4pdibl1); - printf("Warning: Pdibl1 = %g is negative.\n", pParam->BSIM4pdibl1); + pParam->BSIM4v7pdibl1); + printf("Warning: Pdibl1 = %g is negative.\n", pParam->BSIM4v7pdibl1); } - if (pParam->BSIM4pdibl2 < 0.0) + if (pParam->BSIM4v7pdibl2 < 0.0) { fprintf(fplog, "Warning: Pdibl2 = %g is negative.\n", - pParam->BSIM4pdibl2); - printf("Warning: Pdibl2 = %g is negative.\n", pParam->BSIM4pdibl2); + pParam->BSIM4v7pdibl2); + printf("Warning: Pdibl2 = %g is negative.\n", pParam->BSIM4v7pdibl2); } /* Check stress effect parameters */ - if((here->BSIM4sa > 0.0) && (here->BSIM4sb > 0.0) && - ((here->BSIM4nf == 1.0) || ((here->BSIM4nf > 1.0) && (here->BSIM4sd > 0.0))) ) - { if (model->BSIM4lodk2 <= 0.0) - { fprintf(fplog, "Warning: LODK2 = %g is not positive.\n",model->BSIM4lodk2); - printf("Warning: LODK2 = %g is not positive.\n",model->BSIM4lodk2); + if((here->BSIM4v7sa > 0.0) && (here->BSIM4v7sb > 0.0) && + ((here->BSIM4v7nf == 1.0) || ((here->BSIM4v7nf > 1.0) && (here->BSIM4v7sd > 0.0))) ) + { if (model->BSIM4v7lodk2 <= 0.0) + { fprintf(fplog, "Warning: LODK2 = %g is not positive.\n",model->BSIM4v7lodk2); + printf("Warning: LODK2 = %g is not positive.\n",model->BSIM4v7lodk2); } - if (model->BSIM4lodeta0 <= 0.0) - { fprintf(fplog, "Warning: LODETA0 = %g is not positive.\n",model->BSIM4lodeta0); - printf("Warning: LODETA0 = %g is not positive.\n",model->BSIM4lodeta0); + if (model->BSIM4v7lodeta0 <= 0.0) + { fprintf(fplog, "Warning: LODETA0 = %g is not positive.\n",model->BSIM4v7lodeta0); + printf("Warning: LODETA0 = %g is not positive.\n",model->BSIM4v7lodeta0); } } /* Check gate resistance parameters */ - if (here->BSIM4rgateMod == 1) - { if (model->BSIM4rshg <= 0.0) + if (here->BSIM4v7rgateMod == 1) + { if (model->BSIM4v7rshg <= 0.0) printf("Warning: rshg should be positive for rgateMod = 1.\n"); } - else if (here->BSIM4rgateMod == 2) - { if (model->BSIM4rshg <= 0.0) + else if (here->BSIM4v7rgateMod == 2) + { if (model->BSIM4v7rshg <= 0.0) printf("Warning: rshg <= 0.0 for rgateMod = 2.\n"); - else if (pParam->BSIM4xrcrg1 <= 0.0) + else if (pParam->BSIM4v7xrcrg1 <= 0.0) printf("Warning: xrcrg1 <= 0.0 for rgateMod = 2.\n"); } - if (here->BSIM4rgateMod == 3) - { if (model->BSIM4rshg <= 0.0) + if (here->BSIM4v7rgateMod == 3) + { if (model->BSIM4v7rshg <= 0.0) printf("Warning: rshg should be positive for rgateMod = 3.\n"); - else if (pParam->BSIM4xrcrg1 <= 0.0) + else if (pParam->BSIM4v7xrcrg1 <= 0.0) printf("Warning: xrcrg1 should be positive for rgateMod = 3.\n"); } /* Check capacitance parameters */ - if (pParam->BSIM4noff < 0.1) + if (pParam->BSIM4v7noff < 0.1) { fprintf(fplog, "Warning: Noff = %g is too small.\n", - pParam->BSIM4noff); - printf("Warning: Noff = %g is too small.\n", pParam->BSIM4noff); + pParam->BSIM4v7noff); + printf("Warning: Noff = %g is too small.\n", pParam->BSIM4v7noff); } - if (pParam->BSIM4voffcv < -0.5) + if (pParam->BSIM4v7voffcv < -0.5) { fprintf(fplog, "Warning: Voffcv = %g is too small.\n", - pParam->BSIM4voffcv); - printf("Warning: Voffcv = %g is too small.\n", pParam->BSIM4voffcv); + pParam->BSIM4v7voffcv); + printf("Warning: Voffcv = %g is too small.\n", pParam->BSIM4v7voffcv); } - if (pParam->BSIM4moin < 5.0) + if (pParam->BSIM4v7moin < 5.0) { fprintf(fplog, "Warning: Moin = %g is too small.\n", - pParam->BSIM4moin); - printf("Warning: Moin = %g is too small.\n", pParam->BSIM4moin); + pParam->BSIM4v7moin); + printf("Warning: Moin = %g is too small.\n", pParam->BSIM4v7moin); } - if (pParam->BSIM4moin > 25.0) + if (pParam->BSIM4v7moin > 25.0) { fprintf(fplog, "Warning: Moin = %g is too large.\n", - pParam->BSIM4moin); - printf("Warning: Moin = %g is too large.\n", pParam->BSIM4moin); + pParam->BSIM4v7moin); + printf("Warning: Moin = %g is too large.\n", pParam->BSIM4v7moin); } - if(model->BSIM4capMod ==2) { - if (pParam->BSIM4acde < 0.1) + if(model->BSIM4v7capMod ==2) { + if (pParam->BSIM4v7acde < 0.1) { fprintf(fplog, "Warning: Acde = %g is too small.\n", - pParam->BSIM4acde); - printf("Warning: Acde = %g is too small.\n", pParam->BSIM4acde); + pParam->BSIM4v7acde); + printf("Warning: Acde = %g is too small.\n", pParam->BSIM4v7acde); } - if (pParam->BSIM4acde > 1.6) + if (pParam->BSIM4v7acde > 1.6) { fprintf(fplog, "Warning: Acde = %g is too large.\n", - pParam->BSIM4acde); - printf("Warning: Acde = %g is too large.\n", pParam->BSIM4acde); + pParam->BSIM4v7acde); + printf("Warning: Acde = %g is too large.\n", pParam->BSIM4v7acde); } } /* Check overlap capacitance parameters */ - if (model->BSIM4cgdo < 0.0) - { fprintf(fplog, "Warning: cgdo = %g is negative. Set to zero.\n", model->BSIM4cgdo); - printf("Warning: cgdo = %g is negative. Set to zero.\n", model->BSIM4cgdo); - model->BSIM4cgdo = 0.0; + if (model->BSIM4v7cgdo < 0.0) + { fprintf(fplog, "Warning: cgdo = %g is negative. Set to zero.\n", model->BSIM4v7cgdo); + printf("Warning: cgdo = %g is negative. Set to zero.\n", model->BSIM4v7cgdo); + model->BSIM4v7cgdo = 0.0; } - if (model->BSIM4cgso < 0.0) - { fprintf(fplog, "Warning: cgso = %g is negative. Set to zero.\n", model->BSIM4cgso); - printf("Warning: cgso = %g is negative. Set to zero.\n", model->BSIM4cgso); - model->BSIM4cgso = 0.0; + if (model->BSIM4v7cgso < 0.0) + { fprintf(fplog, "Warning: cgso = %g is negative. Set to zero.\n", model->BSIM4v7cgso); + printf("Warning: cgso = %g is negative. Set to zero.\n", model->BSIM4v7cgso); + model->BSIM4v7cgso = 0.0; } - if (model->BSIM4cgbo < 0.0) - { fprintf(fplog, "Warning: cgbo = %g is negative. Set to zero.\n", model->BSIM4cgbo); - printf("Warning: cgbo = %g is negative. Set to zero.\n", model->BSIM4cgbo); - model->BSIM4cgbo = 0.0; + if (model->BSIM4v7cgbo < 0.0) + { fprintf(fplog, "Warning: cgbo = %g is negative. Set to zero.\n", model->BSIM4v7cgbo); + printf("Warning: cgbo = %g is negative. Set to zero.\n", model->BSIM4v7cgbo); + model->BSIM4v7cgbo = 0.0; } /* v4.7 */ - if (model->BSIM4tnoiMod == 1 || model->BSIM4tnoiMod == 2) { - if (model->BSIM4tnoia < 0.0) { - fprintf(fplog, "Warning: tnoia = %g is negative. Set to zero.\n", model->BSIM4tnoia); - printf("Warning: tnoia = %g is negative. Set to zero.\n", model->BSIM4tnoia); - model->BSIM4tnoia = 0.0; + if (model->BSIM4v7tnoiMod == 1 || model->BSIM4v7tnoiMod == 2) { + if (model->BSIM4v7tnoia < 0.0) { + fprintf(fplog, "Warning: tnoia = %g is negative. Set to zero.\n", model->BSIM4v7tnoia); + printf("Warning: tnoia = %g is negative. Set to zero.\n", model->BSIM4v7tnoia); + model->BSIM4v7tnoia = 0.0; } - if (model->BSIM4tnoib < 0.0) { - fprintf(fplog, "Warning: tnoib = %g is negative. Set to zero.\n", model->BSIM4tnoib); - printf("Warning: tnoib = %g is negative. Set to zero.\n", model->BSIM4tnoib); - model->BSIM4tnoib = 0.0; + if (model->BSIM4v7tnoib < 0.0) { + fprintf(fplog, "Warning: tnoib = %g is negative. Set to zero.\n", model->BSIM4v7tnoib); + printf("Warning: tnoib = %g is negative. Set to zero.\n", model->BSIM4v7tnoib); + model->BSIM4v7tnoib = 0.0; } - if (model->BSIM4rnoia < 0.0) { - fprintf(fplog, "Warning: rnoia = %g is negative. Set to zero.\n", model->BSIM4rnoia); - printf("Warning: rnoia = %g is negative. Set to zero.\n", model->BSIM4rnoia); - model->BSIM4rnoia = 0.0; + if (model->BSIM4v7rnoia < 0.0) { + fprintf(fplog, "Warning: rnoia = %g is negative. Set to zero.\n", model->BSIM4v7rnoia); + printf("Warning: rnoia = %g is negative. Set to zero.\n", model->BSIM4v7rnoia); + model->BSIM4v7rnoia = 0.0; } - if (model->BSIM4rnoib < 0.0) { - fprintf(fplog, "Warning: rnoib = %g is negative. Set to zero.\n", model->BSIM4rnoib); - printf("Warning: rnoib = %g is negative. Set to zero.\n", model->BSIM4rnoib); - model->BSIM4rnoib = 0.0; + if (model->BSIM4v7rnoib < 0.0) { + fprintf(fplog, "Warning: rnoib = %g is negative. Set to zero.\n", model->BSIM4v7rnoib); + printf("Warning: rnoib = %g is negative. Set to zero.\n", model->BSIM4v7rnoib); + model->BSIM4v7rnoib = 0.0; } } /* v4.7 */ - if (model->BSIM4tnoiMod == 2) { - if (model->BSIM4tnoic < 0.0) { - fprintf(fplog, "Warning: tnoic = %g is negative. Set to zero.\n", model->BSIM4tnoic); - printf("Warning: tnoic = %g is negative. Set to zero.\n", model->BSIM4tnoic); - model->BSIM4tnoic = 0.0; + if (model->BSIM4v7tnoiMod == 2) { + if (model->BSIM4v7tnoic < 0.0) { + fprintf(fplog, "Warning: tnoic = %g is negative. Set to zero.\n", model->BSIM4v7tnoic); + printf("Warning: tnoic = %g is negative. Set to zero.\n", model->BSIM4v7tnoic); + model->BSIM4v7tnoic = 0.0; } - if (model->BSIM4rnoic < 0.0) { - fprintf(fplog, "Warning: rnoic = %g is negative. Set to zero.\n", model->BSIM4rnoic); - printf("Warning: rnoic = %g is negative. Set to zero.\n", model->BSIM4rnoic); - model->BSIM4rnoic = 0.0; + if (model->BSIM4v7rnoic < 0.0) { + fprintf(fplog, "Warning: rnoic = %g is negative. Set to zero.\n", model->BSIM4v7rnoic); + printf("Warning: rnoic = %g is negative. Set to zero.\n", model->BSIM4v7rnoic); + model->BSIM4v7rnoic = 0.0; } } - /* Limits of Njs and Njd modified in BSIM4.7 */ - if (model->BSIM4SjctEmissionCoeff < 0.1) { - fprintf(fplog, "Warning: Njs = %g is less than 0.1. Setting Njs to 0.1.\n", model->BSIM4SjctEmissionCoeff); - printf("Warning: Njs = %g is less than 0.1. Setting Njs to 0.1.\n", model->BSIM4SjctEmissionCoeff); - model->BSIM4SjctEmissionCoeff = 0.1; + /* Limits of Njs and Njd modified in BSIM4v7.7 */ + if (model->BSIM4v7SjctEmissionCoeff < 0.1) { + fprintf(fplog, "Warning: Njs = %g is less than 0.1. Setting Njs to 0.1.\n", model->BSIM4v7SjctEmissionCoeff); + printf("Warning: Njs = %g is less than 0.1. Setting Njs to 0.1.\n", model->BSIM4v7SjctEmissionCoeff); + model->BSIM4v7SjctEmissionCoeff = 0.1; } - else if (model->BSIM4SjctEmissionCoeff < 0.7) { - fprintf(fplog, "Warning: Njs = %g is less than 0.7.\n", model->BSIM4SjctEmissionCoeff); - printf("Warning: Njs = %g is less than 0.7.\n", model->BSIM4SjctEmissionCoeff); + else if (model->BSIM4v7SjctEmissionCoeff < 0.7) { + fprintf(fplog, "Warning: Njs = %g is less than 0.7.\n", model->BSIM4v7SjctEmissionCoeff); + printf("Warning: Njs = %g is less than 0.7.\n", model->BSIM4v7SjctEmissionCoeff); } - if (model->BSIM4DjctEmissionCoeff < 0.1) { - fprintf(fplog, "Warning: Njd = %g is less than 0.1. Setting Njd to 0.1.\n", model->BSIM4DjctEmissionCoeff); - printf("Warning: Njd = %g is less than 0.1. Setting Njd to 0.1.\n", model->BSIM4DjctEmissionCoeff); - model->BSIM4DjctEmissionCoeff = 0.1; + if (model->BSIM4v7DjctEmissionCoeff < 0.1) { + fprintf(fplog, "Warning: Njd = %g is less than 0.1. Setting Njd to 0.1.\n", model->BSIM4v7DjctEmissionCoeff); + printf("Warning: Njd = %g is less than 0.1. Setting Njd to 0.1.\n", model->BSIM4v7DjctEmissionCoeff); + model->BSIM4v7DjctEmissionCoeff = 0.1; } - else if (model->BSIM4DjctEmissionCoeff < 0.7) { - fprintf(fplog, "Warning: Njd = %g is less than 0.7.\n", model->BSIM4DjctEmissionCoeff); - printf("Warning: Njd = %g is less than 0.7.\n", model->BSIM4DjctEmissionCoeff); + else if (model->BSIM4v7DjctEmissionCoeff < 0.7) { + fprintf(fplog, "Warning: Njd = %g is less than 0.7.\n", model->BSIM4v7DjctEmissionCoeff); + printf("Warning: Njd = %g is less than 0.7.\n", model->BSIM4v7DjctEmissionCoeff); } - if (model->BSIM4njtsstemp < 0.0) + if (model->BSIM4v7njtsstemp < 0.0) { fprintf(fplog, "Warning: Njts = %g is negative at temperature = %g.\n", - model->BSIM4njtsstemp, ckt->CKTtemp); + model->BSIM4v7njtsstemp, ckt->CKTtemp); printf("Warning: Njts = %g is negative at temperature = %g.\n", - model->BSIM4njtsstemp, ckt->CKTtemp); + model->BSIM4v7njtsstemp, ckt->CKTtemp); } - if (model->BSIM4njtsswstemp < 0.0) + if (model->BSIM4v7njtsswstemp < 0.0) { fprintf(fplog, "Warning: Njtssw = %g is negative at temperature = %g.\n", - model->BSIM4njtsswstemp, ckt->CKTtemp); + model->BSIM4v7njtsswstemp, ckt->CKTtemp); printf("Warning: Njtssw = %g is negative at temperature = %g.\n", - model->BSIM4njtsswstemp, ckt->CKTtemp); + model->BSIM4v7njtsswstemp, ckt->CKTtemp); } - if (model->BSIM4njtsswgstemp < 0.0) + if (model->BSIM4v7njtsswgstemp < 0.0) { fprintf(fplog, "Warning: Njtsswg = %g is negative at temperature = %g.\n", - model->BSIM4njtsswgstemp, ckt->CKTtemp); + model->BSIM4v7njtsswgstemp, ckt->CKTtemp); printf("Warning: Njtsswg = %g is negative at temperature = %g.\n", - model->BSIM4njtsswgstemp, ckt->CKTtemp); + model->BSIM4v7njtsswgstemp, ckt->CKTtemp); } - if (model->BSIM4njtsdGiven && model->BSIM4njtsdtemp < 0.0) + if (model->BSIM4v7njtsdGiven && model->BSIM4v7njtsdtemp < 0.0) { fprintf(fplog, "Warning: Njtsd = %g is negative at temperature = %g.\n", - model->BSIM4njtsdtemp, ckt->CKTtemp); + model->BSIM4v7njtsdtemp, ckt->CKTtemp); printf("Warning: Njtsd = %g is negative at temperature = %g.\n", - model->BSIM4njtsdtemp, ckt->CKTtemp); + model->BSIM4v7njtsdtemp, ckt->CKTtemp); } - if (model->BSIM4njtsswdGiven && model->BSIM4njtsswdtemp < 0.0) + if (model->BSIM4v7njtsswdGiven && model->BSIM4v7njtsswdtemp < 0.0) { fprintf(fplog, "Warning: Njtsswd = %g is negative at temperature = %g.\n", - model->BSIM4njtsswdtemp, ckt->CKTtemp); + model->BSIM4v7njtsswdtemp, ckt->CKTtemp); printf("Warning: Njtsswd = %g is negative at temperature = %g.\n", - model->BSIM4njtsswdtemp, ckt->CKTtemp); + model->BSIM4v7njtsswdtemp, ckt->CKTtemp); } - if (model->BSIM4njtsswgdGiven && model->BSIM4njtsswgdtemp < 0.0) + if (model->BSIM4v7njtsswgdGiven && model->BSIM4v7njtsswgdtemp < 0.0) { fprintf(fplog, "Warning: Njtsswgd = %g is negative at temperature = %g.\n", - model->BSIM4njtsswgdtemp, ckt->CKTtemp); + model->BSIM4v7njtsswgdtemp, ckt->CKTtemp); printf("Warning: Njtsswgd = %g is negative at temperature = %g.\n", - model->BSIM4njtsswgdtemp, ckt->CKTtemp); + model->BSIM4v7njtsswgdtemp, ckt->CKTtemp); } - if (model->BSIM4ntnoi < 0.0) - { fprintf(fplog, "Warning: ntnoi = %g is negative. Set to zero.\n", model->BSIM4ntnoi); - printf("Warning: ntnoi = %g is negative. Set to zero.\n", model->BSIM4ntnoi); - model->BSIM4ntnoi = 0.0; + if (model->BSIM4v7ntnoi < 0.0) + { fprintf(fplog, "Warning: ntnoi = %g is negative. Set to zero.\n", model->BSIM4v7ntnoi); + printf("Warning: ntnoi = %g is negative. Set to zero.\n", model->BSIM4v7ntnoi); + model->BSIM4v7ntnoi = 0.0; } /* diode model */ - if (model->BSIM4SbulkJctBotGradingCoeff >= 0.99) - { fprintf(fplog, "Warning: MJS = %g is too big. Set to 0.99.\n", model->BSIM4SbulkJctBotGradingCoeff); - printf("Warning: MJS = %g is too big. Set to 0.99.\n", model->BSIM4SbulkJctBotGradingCoeff); - model->BSIM4SbulkJctBotGradingCoeff = 0.99; + if (model->BSIM4v7SbulkJctBotGradingCoeff >= 0.99) + { fprintf(fplog, "Warning: MJS = %g is too big. Set to 0.99.\n", model->BSIM4v7SbulkJctBotGradingCoeff); + printf("Warning: MJS = %g is too big. Set to 0.99.\n", model->BSIM4v7SbulkJctBotGradingCoeff); + model->BSIM4v7SbulkJctBotGradingCoeff = 0.99; } - if (model->BSIM4SbulkJctSideGradingCoeff >= 0.99) - { fprintf(fplog, "Warning: MJSWS = %g is too big. Set to 0.99.\n", model->BSIM4SbulkJctSideGradingCoeff); - printf("Warning: MJSWS = %g is too big. Set to 0.99.\n", model->BSIM4SbulkJctSideGradingCoeff); - model->BSIM4SbulkJctSideGradingCoeff = 0.99; + if (model->BSIM4v7SbulkJctSideGradingCoeff >= 0.99) + { fprintf(fplog, "Warning: MJSWS = %g is too big. Set to 0.99.\n", model->BSIM4v7SbulkJctSideGradingCoeff); + printf("Warning: MJSWS = %g is too big. Set to 0.99.\n", model->BSIM4v7SbulkJctSideGradingCoeff); + model->BSIM4v7SbulkJctSideGradingCoeff = 0.99; } - if (model->BSIM4SbulkJctGateSideGradingCoeff >= 0.99) - { fprintf(fplog, "Warning: MJSWGS = %g is too big. Set to 0.99.\n", model->BSIM4SbulkJctGateSideGradingCoeff); - printf("Warning: MJSWGS = %g is too big. Set to 0.99.\n", model->BSIM4SbulkJctGateSideGradingCoeff); - model->BSIM4SbulkJctGateSideGradingCoeff = 0.99; + if (model->BSIM4v7SbulkJctGateSideGradingCoeff >= 0.99) + { fprintf(fplog, "Warning: MJSWGS = %g is too big. Set to 0.99.\n", model->BSIM4v7SbulkJctGateSideGradingCoeff); + printf("Warning: MJSWGS = %g is too big. Set to 0.99.\n", model->BSIM4v7SbulkJctGateSideGradingCoeff); + model->BSIM4v7SbulkJctGateSideGradingCoeff = 0.99; } - if (model->BSIM4DbulkJctBotGradingCoeff >= 0.99) - { fprintf(fplog, "Warning: MJD = %g is too big. Set to 0.99.\n", model->BSIM4DbulkJctBotGradingCoeff); - printf("Warning: MJD = %g is too big. Set to 0.99.\n", model->BSIM4DbulkJctBotGradingCoeff); - model->BSIM4DbulkJctBotGradingCoeff = 0.99; + if (model->BSIM4v7DbulkJctBotGradingCoeff >= 0.99) + { fprintf(fplog, "Warning: MJD = %g is too big. Set to 0.99.\n", model->BSIM4v7DbulkJctBotGradingCoeff); + printf("Warning: MJD = %g is too big. Set to 0.99.\n", model->BSIM4v7DbulkJctBotGradingCoeff); + model->BSIM4v7DbulkJctBotGradingCoeff = 0.99; } - if (model->BSIM4DbulkJctSideGradingCoeff >= 0.99) - { fprintf(fplog, "Warning: MJSWD = %g is too big. Set to 0.99.\n", model->BSIM4DbulkJctSideGradingCoeff); - printf("Warning: MJSWD = %g is too big. Set to 0.99.\n", model->BSIM4DbulkJctSideGradingCoeff); - model->BSIM4DbulkJctSideGradingCoeff = 0.99; + if (model->BSIM4v7DbulkJctSideGradingCoeff >= 0.99) + { fprintf(fplog, "Warning: MJSWD = %g is too big. Set to 0.99.\n", model->BSIM4v7DbulkJctSideGradingCoeff); + printf("Warning: MJSWD = %g is too big. Set to 0.99.\n", model->BSIM4v7DbulkJctSideGradingCoeff); + model->BSIM4v7DbulkJctSideGradingCoeff = 0.99; } - if (model->BSIM4DbulkJctGateSideGradingCoeff >= 0.99) - { fprintf(fplog, "Warning: MJSWGD = %g is too big. Set to 0.99.\n", model->BSIM4DbulkJctGateSideGradingCoeff); - printf("Warning: MJSWGD = %g is too big. Set to 0.99.\n", model->BSIM4DbulkJctGateSideGradingCoeff); - model->BSIM4DbulkJctGateSideGradingCoeff = 0.99; + if (model->BSIM4v7DbulkJctGateSideGradingCoeff >= 0.99) + { fprintf(fplog, "Warning: MJSWGD = %g is too big. Set to 0.99.\n", model->BSIM4v7DbulkJctGateSideGradingCoeff); + printf("Warning: MJSWGD = %g is too big. Set to 0.99.\n", model->BSIM4v7DbulkJctGateSideGradingCoeff); + model->BSIM4v7DbulkJctGateSideGradingCoeff = 0.99; } - if (model->BSIM4wpemod == 1) + if (model->BSIM4v7wpemod == 1) { - if (model->BSIM4scref <= 0.0) - { fprintf(fplog, "Warning: SCREF = %g is not positive. Set to 1e-6.\n", model->BSIM4scref); - printf("Warning: SCREF = %g is not positive. Set to 1e-6.\n", model->BSIM4scref); - model->BSIM4scref = 1e-6; + if (model->BSIM4v7scref <= 0.0) + { fprintf(fplog, "Warning: SCREF = %g is not positive. Set to 1e-6.\n", model->BSIM4v7scref); + printf("Warning: SCREF = %g is not positive. Set to 1e-6.\n", model->BSIM4v7scref); + model->BSIM4v7scref = 1e-6; } /*Move these checks to temp.c for sceff calculation*/ /* - if (here->BSIM4sca < 0.0) - { fprintf(fplog, "Warning: SCA = %g is negative. Set to 0.0.\n", here->BSIM4sca); - printf("Warning: SCA = %g is negative. Set to 0.0.\n", here->BSIM4sca); - here->BSIM4sca = 0.0; + if (here->BSIM4v7sca < 0.0) + { fprintf(fplog, "Warning: SCA = %g is negative. Set to 0.0.\n", here->BSIM4v7sca); + printf("Warning: SCA = %g is negative. Set to 0.0.\n", here->BSIM4v7sca); + here->BSIM4v7sca = 0.0; } - if (here->BSIM4scb < 0.0) - { fprintf(fplog, "Warning: SCB = %g is negative. Set to 0.0.\n", here->BSIM4scb); - printf("Warning: SCB = %g is negative. Set to 0.0.\n", here->BSIM4scb); - here->BSIM4scb = 0.0; + if (here->BSIM4v7scb < 0.0) + { fprintf(fplog, "Warning: SCB = %g is negative. Set to 0.0.\n", here->BSIM4v7scb); + printf("Warning: SCB = %g is negative. Set to 0.0.\n", here->BSIM4v7scb); + here->BSIM4v7scb = 0.0; } - if (here->BSIM4scc < 0.0) - { fprintf(fplog, "Warning: SCC = %g is negative. Set to 0.0.\n", here->BSIM4scc); - printf("Warning: SCC = %g is negative. Set to 0.0.\n", here->BSIM4scc); - here->BSIM4scc = 0.0; + if (here->BSIM4v7scc < 0.0) + { fprintf(fplog, "Warning: SCC = %g is negative. Set to 0.0.\n", here->BSIM4v7scc); + printf("Warning: SCC = %g is negative. Set to 0.0.\n", here->BSIM4v7scc); + here->BSIM4v7scc = 0.0; } - if (here->BSIM4sc < 0.0) - { fprintf(fplog, "Warning: SC = %g is negative. Set to 0.0.\n", here->BSIM4sc); - printf("Warning: SC = %g is negative. Set to 0.0.\n", here->BSIM4sc); - here->BSIM4sc = 0.0; + if (here->BSIM4v7sc < 0.0) + { fprintf(fplog, "Warning: SC = %g is negative. Set to 0.0.\n", here->BSIM4v7sc); + printf("Warning: SC = %g is negative. Set to 0.0.\n", here->BSIM4v7sc); + here->BSIM4v7sc = 0.0; } */ diff --git a/src/spicelib/devices/bsim4v7/b4v7cvtest.c b/src/spicelib/devices/bsim4v7/b4v7cvtest.c index 4a21c43f8..da2fceb7f 100644 --- a/src/spicelib/devices/bsim4v7/b4v7cvtest.c +++ b/src/spicelib/devices/bsim4v7/b4v7cvtest.c @@ -15,7 +15,7 @@ #include "ngspice/ngspice.h" #include "ngspice/cktdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/trandefs.h" #include "ngspice/const.h" #include "ngspice/devdefs.h" @@ -24,12 +24,12 @@ int -BSIM4convTest( +BSIM4v7convTest( GENmodel *inModel, CKTcircuit *ckt) { -BSIM4model *model = (BSIM4model*)inModel; -BSIM4instance *here; +BSIM4v7model *model = (BSIM4v7model*)inModel; +BSIM4v7instance *here; double delvbd, delvbs, delvds, delvgd, delvgs; double delvdbd, delvsbs; double delvbd_jct, delvbs_jct; @@ -41,111 +41,111 @@ 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->BSIM4nextModel) - { for (here = model->BSIM4instances; here != NULL ; - here=here->BSIM4nextInstance) + for (; model != NULL; model = model->BSIM4v7nextModel) + { for (here = model->BSIM4v7instances; here != NULL ; + here=here->BSIM4v7nextInstance) { - vds = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4dNodePrime) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vgs = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4gNodePrime) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vbs = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4bNodePrime) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vdbs = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4dbNode) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vsbs = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4sbNode) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vses = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4sNode) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vdes = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4dNode) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); + vds = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7dNodePrime) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vgs = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7gNodePrime) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vbs = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7bNodePrime) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vdbs = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7dbNode) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vsbs = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7sbNode) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vses = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7sNode) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vdes = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7dNode) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); - vgdo = *(ckt->CKTstate0 + here->BSIM4vgs) - - *(ckt->CKTstate0 + here->BSIM4vds); + vgdo = *(ckt->CKTstate0 + here->BSIM4v7vgs) + - *(ckt->CKTstate0 + here->BSIM4v7vds); vbd = vbs - vds; vdbd = vdbs - vds; vgd = vgs - vds; - delvbd = vbd - *(ckt->CKTstate0 + here->BSIM4vbd); - delvdbd = vdbd - *(ckt->CKTstate0 + here->BSIM4vdbd); + delvbd = vbd - *(ckt->CKTstate0 + here->BSIM4v7vbd); + delvdbd = vdbd - *(ckt->CKTstate0 + here->BSIM4v7vdbd); delvgd = vgd - vgdo; - delvds = vds - *(ckt->CKTstate0 + here->BSIM4vds); - delvgs = vgs - *(ckt->CKTstate0 + here->BSIM4vgs); - delvbs = vbs - *(ckt->CKTstate0 + here->BSIM4vbs); - delvsbs = vsbs - *(ckt->CKTstate0 + here->BSIM4vsbs); + delvds = vds - *(ckt->CKTstate0 + here->BSIM4v7vds); + delvgs = vgs - *(ckt->CKTstate0 + here->BSIM4v7vgs); + delvbs = vbs - *(ckt->CKTstate0 + here->BSIM4v7vbs); + delvsbs = vsbs - *(ckt->CKTstate0 + here->BSIM4v7vsbs); - delvses = vses - (*(ckt->CKTstate0 + here->BSIM4vses)); - vdedo = *(ckt->CKTstate0 + here->BSIM4vdes) - - *(ckt->CKTstate0 + here->BSIM4vds); - delvdes = vdes - *(ckt->CKTstate0 + here->BSIM4vdes); + delvses = vses - (*(ckt->CKTstate0 + here->BSIM4v7vses)); + vdedo = *(ckt->CKTstate0 + here->BSIM4v7vdes) + - *(ckt->CKTstate0 + here->BSIM4v7vds); + delvdes = vdes - *(ckt->CKTstate0 + here->BSIM4v7vdes); delvded = vdes - vds - vdedo; - delvbd_jct = (!here->BSIM4rbodyMod) ? delvbd : delvdbd; - delvbs_jct = (!here->BSIM4rbodyMod) ? delvbs : delvsbs; + delvbd_jct = (!here->BSIM4v7rbodyMod) ? delvbd : delvdbd; + delvbs_jct = (!here->BSIM4v7rbodyMod) ? delvbs : delvsbs; - if (here->BSIM4mode >= 0) - { Idtot = here->BSIM4cd + here->BSIM4csub - here->BSIM4cbd - + here->BSIM4Igidl; - cdhat = Idtot - here->BSIM4gbd * delvbd_jct - + (here->BSIM4gmbs + here->BSIM4gbbs + here->BSIM4ggidlb) * delvbs - + (here->BSIM4gm + here->BSIM4gbgs + here->BSIM4ggidlg) * delvgs - + (here->BSIM4gds + here->BSIM4gbds + here->BSIM4ggidld) * delvds; + if (here->BSIM4v7mode >= 0) + { Idtot = here->BSIM4v7cd + here->BSIM4v7csub - here->BSIM4v7cbd + + here->BSIM4v7Igidl; + cdhat = Idtot - here->BSIM4v7gbd * delvbd_jct + + (here->BSIM4v7gmbs + here->BSIM4v7gbbs + here->BSIM4v7ggidlb) * delvbs + + (here->BSIM4v7gm + here->BSIM4v7gbgs + here->BSIM4v7ggidlg) * delvgs + + (here->BSIM4v7gds + here->BSIM4v7gbds + here->BSIM4v7ggidld) * delvds; - Igstot = here->BSIM4Igs + here->BSIM4Igcs; - cgshat = Igstot + (here->BSIM4gIgsg + here->BSIM4gIgcsg) * delvgs - + here->BSIM4gIgcsd * delvds + here->BSIM4gIgcsb * delvbs; + Igstot = here->BSIM4v7Igs + here->BSIM4v7Igcs; + cgshat = Igstot + (here->BSIM4v7gIgsg + here->BSIM4v7gIgcsg) * delvgs + + here->BSIM4v7gIgcsd * delvds + here->BSIM4v7gIgcsb * delvbs; - Igdtot = here->BSIM4Igd + here->BSIM4Igcd; - cgdhat = Igdtot + here->BSIM4gIgdg * delvgd + here->BSIM4gIgcdg * delvgs - + here->BSIM4gIgcdd * delvds + here->BSIM4gIgcdb * delvbs; + Igdtot = here->BSIM4v7Igd + here->BSIM4v7Igcd; + cgdhat = Igdtot + here->BSIM4v7gIgdg * delvgd + here->BSIM4v7gIgcdg * delvgs + + here->BSIM4v7gIgcdd * delvds + here->BSIM4v7gIgcdb * delvbs; - Igbtot = here->BSIM4Igb; - cgbhat = here->BSIM4Igb + here->BSIM4gIgbg * delvgs + here->BSIM4gIgbd - * delvds + here->BSIM4gIgbb * delvbs; + Igbtot = here->BSIM4v7Igb; + cgbhat = here->BSIM4v7Igb + here->BSIM4v7gIgbg * delvgs + here->BSIM4v7gIgbd + * delvds + here->BSIM4v7gIgbb * delvbs; } else - { Idtot = here->BSIM4cd + here->BSIM4cbd - here->BSIM4Igidl; /* bugfix */ - cdhat = Idtot + here->BSIM4gbd * delvbd_jct + here->BSIM4gmbs - * delvbd + here->BSIM4gm * delvgd - - (here->BSIM4gds + here->BSIM4ggidls) * delvds - - here->BSIM4ggidlg * delvgs - here->BSIM4ggidlb * delvbs; + { Idtot = here->BSIM4v7cd + here->BSIM4v7cbd - here->BSIM4v7Igidl; /* bugfix */ + cdhat = Idtot + here->BSIM4v7gbd * delvbd_jct + here->BSIM4v7gmbs + * delvbd + here->BSIM4v7gm * delvgd + - (here->BSIM4v7gds + here->BSIM4v7ggidls) * delvds + - here->BSIM4v7ggidlg * delvgs - here->BSIM4v7ggidlb * delvbs; - Igstot = here->BSIM4Igs + here->BSIM4Igcd; - cgshat = Igstot + here->BSIM4gIgsg * delvgs + here->BSIM4gIgcdg * delvgd - - here->BSIM4gIgcdd * delvds + here->BSIM4gIgcdb * delvbd; + Igstot = here->BSIM4v7Igs + here->BSIM4v7Igcd; + cgshat = Igstot + here->BSIM4v7gIgsg * delvgs + here->BSIM4v7gIgcdg * delvgd + - here->BSIM4v7gIgcdd * delvds + here->BSIM4v7gIgcdb * delvbd; - Igdtot = here->BSIM4Igd + here->BSIM4Igcs; - cgdhat = Igdtot + (here->BSIM4gIgdg + here->BSIM4gIgcsg) * delvgd - - here->BSIM4gIgcsd * delvds + here->BSIM4gIgcsb * delvbd; + Igdtot = here->BSIM4v7Igd + here->BSIM4v7Igcs; + cgdhat = Igdtot + (here->BSIM4v7gIgdg + here->BSIM4v7gIgcsg) * delvgd + - here->BSIM4v7gIgcsd * delvds + here->BSIM4v7gIgcsb * delvbd; - Igbtot = here->BSIM4Igb; - cgbhat = here->BSIM4Igb + here->BSIM4gIgbg * delvgd - here->BSIM4gIgbd - * delvds + here->BSIM4gIgbb * delvbd; + Igbtot = here->BSIM4v7Igb; + cgbhat = here->BSIM4v7Igb + here->BSIM4v7gIgbg * delvgd - here->BSIM4v7gIgbd + * delvds + here->BSIM4v7gIgbb * delvbd; } - Isestot = here->BSIM4gstot * (*(ckt->CKTstate0 + here->BSIM4vses)); - cseshat = Isestot + here->BSIM4gstot * delvses - + here->BSIM4gstotd * delvds + here->BSIM4gstotg * delvgs - + here->BSIM4gstotb * delvbs; + Isestot = here->BSIM4v7gstot * (*(ckt->CKTstate0 + here->BSIM4v7vses)); + cseshat = Isestot + here->BSIM4v7gstot * delvses + + here->BSIM4v7gstotd * delvds + here->BSIM4v7gstotg * delvgs + + here->BSIM4v7gstotb * delvbs; - Idedtot = here->BSIM4gdtot * vdedo; - cdedhat = Idedtot + here->BSIM4gdtot * delvded - + here->BSIM4gdtotd * delvds + here->BSIM4gdtotg * delvgs - + here->BSIM4gdtotb * delvbs; + Idedtot = here->BSIM4v7gdtot * vdedo; + cdedhat = Idedtot + here->BSIM4v7gdtot * delvded + + here->BSIM4v7gdtotd * delvds + here->BSIM4v7gdtotg * delvgs + + here->BSIM4v7gdtotb * delvbs; /* * Check convergence */ - if ((here->BSIM4off == 0) || (!(ckt->CKTmode & MODEINITFIX))) + if ((here->BSIM4v7off == 0) || (!(ckt->CKTmode & MODEINITFIX))) { tol0 = ckt->CKTreltol * MAX(fabs(cdhat), fabs(Idtot)) + ckt->CKTabstol; tol1 = ckt->CKTreltol * MAX(fabs(cseshat), fabs(Isestot)) @@ -171,21 +171,21 @@ double tol0, tol1, tol2, tol3, tol4, tol5, tol6; return(OK); } - Ibtot = here->BSIM4cbs + here->BSIM4cbd - - here->BSIM4Igidl - here->BSIM4Igisl - here->BSIM4csub; - if (here->BSIM4mode >= 0) - { cbhat = Ibtot + here->BSIM4gbd * delvbd_jct - + here->BSIM4gbs * delvbs_jct - (here->BSIM4gbbs + here->BSIM4ggidlb) - * delvbs - (here->BSIM4gbgs + here->BSIM4ggidlg) * delvgs - - (here->BSIM4gbds + here->BSIM4ggidld) * delvds - - here->BSIM4ggislg * delvgd - here->BSIM4ggislb* delvbd + here->BSIM4ggisls * delvds ; + Ibtot = here->BSIM4v7cbs + here->BSIM4v7cbd + - here->BSIM4v7Igidl - here->BSIM4v7Igisl - here->BSIM4v7csub; + if (here->BSIM4v7mode >= 0) + { cbhat = Ibtot + here->BSIM4v7gbd * delvbd_jct + + here->BSIM4v7gbs * delvbs_jct - (here->BSIM4v7gbbs + here->BSIM4v7ggidlb) + * delvbs - (here->BSIM4v7gbgs + here->BSIM4v7ggidlg) * delvgs + - (here->BSIM4v7gbds + here->BSIM4v7ggidld) * delvds + - here->BSIM4v7ggislg * delvgd - here->BSIM4v7ggislb* delvbd + here->BSIM4v7ggisls * delvds ; } else - { cbhat = Ibtot + here->BSIM4gbs * delvbs_jct + here->BSIM4gbd - * delvbd_jct - (here->BSIM4gbbs + here->BSIM4ggislb) * delvbd - - (here->BSIM4gbgs + here->BSIM4ggislg) * delvgd - + (here->BSIM4gbds + here->BSIM4ggisld - here->BSIM4ggidls) * delvds - - here->BSIM4ggidlg * delvgs - here->BSIM4ggidlb * delvbs; + { cbhat = Ibtot + here->BSIM4v7gbs * delvbs_jct + here->BSIM4v7gbd + * delvbd_jct - (here->BSIM4v7gbbs + here->BSIM4v7ggislb) * delvbd + - (here->BSIM4v7gbgs + here->BSIM4v7ggislg) * delvgd + + (here->BSIM4v7gbds + here->BSIM4v7ggisld - here->BSIM4v7ggidls) * delvds + - here->BSIM4v7ggidlg * delvgs - here->BSIM4v7ggidlb * delvbs; } tol6 = ckt->CKTreltol * MAX(fabs(cbhat), fabs(Ibtot)) + ckt->CKTabstol; diff --git a/src/spicelib/devices/bsim4v7/b4v7del.c b/src/spicelib/devices/bsim4v7/b4v7del.c index b20a7e522..451386877 100644 --- a/src/spicelib/devices/bsim4v7/b4v7del.c +++ b/src/spicelib/devices/bsim4v7/b4v7del.c @@ -11,32 +11,32 @@ **********/ #include "ngspice/ngspice.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/sperror.h" #include "ngspice/gendefs.h" #include "ngspice/suffix.h" int -BSIM4delete( +BSIM4v7delete( GENmodel *inModel, IFuid name, GENinstance **inInst) { -BSIM4instance **fast = (BSIM4instance**)inInst; -BSIM4model *model = (BSIM4model*)inModel; -BSIM4instance **prev = NULL; -BSIM4instance *here; +BSIM4v7instance **fast = (BSIM4v7instance**)inInst; +BSIM4v7model *model = (BSIM4v7model*)inModel; +BSIM4v7instance **prev = NULL; +BSIM4v7instance *here; - for (; model ; model = model->BSIM4nextModel) - { prev = &(model->BSIM4instances); + for (; model ; model = model->BSIM4v7nextModel) + { prev = &(model->BSIM4v7instances); for (here = *prev; here ; here = *prev) - { if (here->BSIM4name == name || (fast && here==*fast)) - { *prev= here->BSIM4nextInstance; + { if (here->BSIM4v7name == name || (fast && here==*fast)) + { *prev= here->BSIM4v7nextInstance; FREE(here); return(OK); } - prev = &(here->BSIM4nextInstance); + prev = &(here->BSIM4v7nextInstance); } } return(E_NODEV); diff --git a/src/spicelib/devices/bsim4v7/b4v7dest.c b/src/spicelib/devices/bsim4v7/b4v7dest.c index 00e1f2163..2be76e360 100644 --- a/src/spicelib/devices/bsim4v7/b4v7dest.c +++ b/src/spicelib/devices/bsim4v7/b4v7dest.c @@ -11,20 +11,20 @@ **********/ #include "ngspice/ngspice.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/suffix.h" void -BSIM4destroy( +BSIM4v7destroy( GENmodel **inModel) { - BSIM4model **model = (BSIM4model**)inModel; - BSIM4instance *here; - BSIM4instance *prev = NULL; - BSIM4model *mod = *model; - BSIM4model *oldmod = NULL; + BSIM4v7model **model = (BSIM4v7model**)inModel; + BSIM4v7instance *here; + BSIM4v7instance *prev = NULL; + BSIM4v7model *mod = *model; + BSIM4v7model *oldmod = NULL; - for (; mod ; mod = mod->BSIM4nextModel) { + for (; mod ; mod = mod->BSIM4v7nextModel) { /** added to get rid of link list pSizeDependParamKnot **/ struct bsim4SizeDependParam *pParam, *pParamOld=NULL; @@ -38,12 +38,12 @@ BSIM4destroy( pParam = NULL; /** end of extra code **/ if(oldmod) { - FREE(oldmod->BSIM4version); + FREE(oldmod->BSIM4v7version); FREE(oldmod); } oldmod = mod; - prev = (BSIM4instance *)NULL; - for (here = mod->BSIM4instances; here; here = here->BSIM4nextInstance) { + prev = (BSIM4v7instance *)NULL; + for (here = mod->BSIM4v7instances; here; here = here->BSIM4v7nextInstance) { if(prev) FREE(prev); prev = here; } @@ -52,10 +52,10 @@ BSIM4destroy( if(oldmod) { #ifdef USE_OMP /* free just once for all models */ - FREE(oldmod->BSIM4InstanceArray); + FREE(oldmod->BSIM4v7InstanceArray); #endif - /* oldmod->BSIM4modName to be freed in INPtabEnd() */ - FREE(oldmod->BSIM4version); + /* oldmod->BSIM4v7modName to be freed in INPtabEnd() */ + FREE(oldmod->BSIM4v7version); FREE(oldmod); } *model = NULL; diff --git a/src/spicelib/devices/bsim4v7/b4v7geo.c b/src/spicelib/devices/bsim4v7/b4v7geo.c index 4ef573c18..503c212b9 100644 --- a/src/spicelib/devices/bsim4v7/b4v7geo.c +++ b/src/spicelib/devices/bsim4v7/b4v7geo.c @@ -11,18 +11,18 @@ **********/ #include "ngspice/ngspice.h" -#include "bsim4def.h" +#include "bsim4v7def.h" /* * WDLiu: * This subrutine is a special module to process the geometry dependent - * parasitics for BSIM4, which calculates Ps, Pd, As, Ad, and Rs and Rd + * parasitics for BSIM4v7, which calculates Ps, Pd, As, Ad, and Rs and Rd * for multi-fingers and varous GEO and RGEO options. */ static int -BSIM4NumFingerDiff( +BSIM4v7NumFingerDiff( double nf, int minSD, double *nuIntD, double *nuEndD, double *nuIntS, double *nuEndS) @@ -52,7 +52,7 @@ return 0; int -BSIM4PAeffGeo( +BSIM4v7PAeffGeo( double nf, int geo, int minSD, double Weffcj, double DMCG, double DMCI, double DMDG, @@ -64,7 +64,7 @@ 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 */ - BSIM4NumFingerDiff(nf, minSD, &nuIntD, &nuEndD, &nuIntS, &nuEndS); + BSIM4v7NumFingerDiff(nf, minSD, &nuIntD, &nuEndD, &nuIntS, &nuEndS); T0 = DMCG + DMCI; T1 = DMCG + DMCG; @@ -153,7 +153,7 @@ return 0; int -BSIM4RdseffGeo( +BSIM4v7RdseffGeo( double nf, int geo, int rgeo, int minSD, double Weffcj, double Rsh, double DMCG, double DMCI, double DMDG, @@ -164,7 +164,7 @@ 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 */ - { BSIM4NumFingerDiff(nf, minSD, &nuIntD, &nuEndD, &nuIntS, &nuEndS); + { BSIM4v7NumFingerDiff(nf, minSD, &nuIntD, &nuEndD, &nuIntS, &nuEndS); /* Internal S/D resistance -- assume shared S or D and all wide contacts */ if (Type == 1) @@ -184,47 +184,47 @@ double nuIntD = 0.0, nuEndD = 0.0, nuIntS = 0.0, nuEndS = 0.0; /* End S/D resistance -- geo dependent */ switch(geo) { case 0: - if (Type == 1) BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, + if (Type == 1) BSIM4v7RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndS, rgeo, 1, &Rend); - else BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, + else BSIM4v7RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndD, rgeo, 0, &Rend); break; case 1: - if (Type == 1) BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, + if (Type == 1) BSIM4v7RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndS, rgeo, 1, &Rend); - else BSIM4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, + else BSIM4v7RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndD, rgeo, 0, &Rend); break; case 2: - if (Type == 1) BSIM4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, + if (Type == 1) BSIM4v7RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndS, rgeo, 1, &Rend); - else BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, + else BSIM4v7RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndD, rgeo, 0, &Rend); break; case 3: - if (Type == 1) BSIM4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, + if (Type == 1) BSIM4v7RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndS, rgeo, 1, &Rend); - else BSIM4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, + else BSIM4v7RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndD, rgeo, 0, &Rend); break; case 4: - if (Type == 1) BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, + if (Type == 1) BSIM4v7RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndS, rgeo, 1, &Rend); else Rend = Rsh * DMDG / Weffcj; break; case 5: - if (Type == 1) BSIM4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, + if (Type == 1) BSIM4v7RdsEndSha(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 BSIM4RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, + else BSIM4v7RdsEndIso(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndD, rgeo, 0, &Rend); break; case 7: if (Type == 1) Rend = Rsh * DMDG / (Weffcj * nuEndS); - else BSIM4RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, + else BSIM4v7RdsEndSha(Weffcj, Rsh, DMCG, DMCI, DMDG, nuEndD, rgeo, 0, &Rend); break; case 8: @@ -273,7 +273,7 @@ return 0; int -BSIM4RdsEndIso( +BSIM4v7RdsEndIso( double Weffcj, double Rsh, double DMCG, double DMCI, double DMDG, double nuEnd, int rgeo, int Type, @@ -334,7 +334,7 @@ return 0; int -BSIM4RdsEndSha( +BSIM4v7RdsEndSha( double Weffcj, double Rsh, double DMCG, double DMCI, double DMDG, double nuEnd, int rgeo, int Type, diff --git a/src/spicelib/devices/bsim4v7/b4v7getic.c b/src/spicelib/devices/bsim4v7/b4v7getic.c index 437a0de13..8d6e33c9c 100644 --- a/src/spicelib/devices/bsim4v7/b4v7getic.c +++ b/src/spicelib/devices/bsim4v7/b4v7getic.c @@ -12,33 +12,33 @@ #include "ngspice/ngspice.h" #include "ngspice/cktdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" int -BSIM4getic( +BSIM4v7getic( GENmodel *inModel, CKTcircuit *ckt) { -BSIM4model *model = (BSIM4model*)inModel; -BSIM4instance *here; +BSIM4v7model *model = (BSIM4v7model*)inModel; +BSIM4v7instance *here; - for (; model ; model = model->BSIM4nextModel) - { for (here = model->BSIM4instances; here; here = here->BSIM4nextInstance) + for (; model ; model = model->BSIM4v7nextModel) + { for (here = model->BSIM4v7instances; here; here = here->BSIM4v7nextInstance) { - if (!here->BSIM4icVDSGiven) - { here->BSIM4icVDS = *(ckt->CKTrhs + here->BSIM4dNode) - - *(ckt->CKTrhs + here->BSIM4sNode); + if (!here->BSIM4v7icVDSGiven) + { here->BSIM4v7icVDS = *(ckt->CKTrhs + here->BSIM4v7dNode) + - *(ckt->CKTrhs + here->BSIM4v7sNode); } - if (!here->BSIM4icVGSGiven) - { here->BSIM4icVGS = *(ckt->CKTrhs + here->BSIM4gNodeExt) - - *(ckt->CKTrhs + here->BSIM4sNode); + if (!here->BSIM4v7icVGSGiven) + { here->BSIM4v7icVGS = *(ckt->CKTrhs + here->BSIM4v7gNodeExt) + - *(ckt->CKTrhs + here->BSIM4v7sNode); } - if(!here->BSIM4icVBSGiven) - { here->BSIM4icVBS = *(ckt->CKTrhs + here->BSIM4bNode) - - *(ckt->CKTrhs + here->BSIM4sNode); + if(!here->BSIM4v7icVBSGiven) + { here->BSIM4v7icVBS = *(ckt->CKTrhs + here->BSIM4v7bNode) + - *(ckt->CKTrhs + here->BSIM4v7sNode); } } } diff --git a/src/spicelib/devices/bsim4v7/b4v7ld.c b/src/spicelib/devices/bsim4v7/b4v7ld.c index 73b1a6909..5fc05e273 100644 --- a/src/spicelib/devices/bsim4v7/b4v7ld.c +++ b/src/spicelib/devices/bsim4v7/b4v7ld.c @@ -24,7 +24,7 @@ #include "ngspice/ngspice.h" #include "ngspice/cktdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/trandefs.h" #include "ngspice/const.h" #include "ngspice/sperror.h" @@ -60,42 +60,42 @@ } #ifdef USE_OMP -int BSIM4LoadOMP(BSIM4instance *here, CKTcircuit *ckt); -void BSIM4LoadRhsMat(GENmodel *inModel, CKTcircuit *ckt); +int BSIM4v7LoadOMP(BSIM4v7instance *here, CKTcircuit *ckt); +void BSIM4v7LoadRhsMat(GENmodel *inModel, CKTcircuit *ckt); #endif -int BSIM4polyDepletion(double phi, double ngate,double epsgate, double coxe, double Vgs, double *Vgs_eff, double *dVgs_eff_dVg); +int BSIM4v7polyDepletion(double phi, double ngate,double epsgate, double coxe, double Vgs, double *Vgs_eff, double *dVgs_eff_dVg); int -BSIM4load( +BSIM4v7load( GENmodel *inModel, CKTcircuit *ckt) { #ifdef USE_OMP int idx; - BSIM4model *model = (BSIM4model*)inModel; + BSIM4v7model *model = (BSIM4v7model*)inModel; int good = 0; - BSIM4instance *here; - BSIM4instance **InstArray; - InstArray = model->BSIM4InstanceArray; + BSIM4v7instance *here; + BSIM4v7instance **InstArray; + InstArray = model->BSIM4v7InstanceArray; #pragma omp parallel for private(here) - for (idx = 0; idx < model->BSIM4InstCount; idx++) { + for (idx = 0; idx < model->BSIM4v7InstCount; idx++) { here = InstArray[idx]; - good = BSIM4LoadOMP(here, ckt); + good = BSIM4v7LoadOMP(here, ckt); } - BSIM4LoadRhsMat(inModel, ckt); + BSIM4v7LoadRhsMat(inModel, ckt); return good; } -int BSIM4LoadOMP(BSIM4instance *here, CKTcircuit *ckt) { -BSIM4model *model; +int BSIM4v7LoadOMP(BSIM4v7instance *here, CKTcircuit *ckt) { +BSIM4v7model *model; #else -BSIM4model *model = (BSIM4model*)inModel; -BSIM4instance *here; +BSIM4v7model *model = (BSIM4v7model*)inModel; +BSIM4v7instance *here; #endif double ceqgstot, dgstot_dvd, dgstot_dvg, dgstot_dvs, dgstot_dvb; double ceqgdtot, dgdtot_dvd, dgdtot_dvg, dgdtot_dvs, dgdtot_dvb; @@ -241,7 +241,7 @@ int ByPass, ChargeComputationNeeded, error, Check, Check1, Check2; double m; #ifdef USE_OMP -model = here->BSIM4modPtr; +model = here->BSIM4v7modPtr; #endif ScalingFactor = 1.0e-9; @@ -251,9 +251,9 @@ ChargeComputationNeeded = ? 1 : 0; #ifndef USE_OMP -for (; model != NULL; model = model->BSIM4nextModel) -{ for (here = model->BSIM4instances; here != NULL; - here = here->BSIM4nextInstance) +for (; model != NULL; model = model->BSIM4v7nextModel) +{ for (here = model->BSIM4v7instances; here != NULL; + here = here->BSIM4v7nextInstance) { #endif @@ -262,35 +262,35 @@ for (; model != NULL; model = model->BSIM4nextModel) pParam = here->pParam; if ((ckt->CKTmode & MODEINITSMSIG)) - { vds = *(ckt->CKTstate0 + here->BSIM4vds); - vgs = *(ckt->CKTstate0 + here->BSIM4vgs); - vbs = *(ckt->CKTstate0 + here->BSIM4vbs); - vges = *(ckt->CKTstate0 + here->BSIM4vges); - vgms = *(ckt->CKTstate0 + here->BSIM4vgms); - vdbs = *(ckt->CKTstate0 + here->BSIM4vdbs); - vsbs = *(ckt->CKTstate0 + here->BSIM4vsbs); - vses = *(ckt->CKTstate0 + here->BSIM4vses); - vdes = *(ckt->CKTstate0 + here->BSIM4vdes); + { vds = *(ckt->CKTstate0 + here->BSIM4v7vds); + vgs = *(ckt->CKTstate0 + here->BSIM4v7vgs); + vbs = *(ckt->CKTstate0 + here->BSIM4v7vbs); + vges = *(ckt->CKTstate0 + here->BSIM4v7vges); + vgms = *(ckt->CKTstate0 + here->BSIM4v7vgms); + vdbs = *(ckt->CKTstate0 + here->BSIM4v7vdbs); + vsbs = *(ckt->CKTstate0 + here->BSIM4v7vsbs); + vses = *(ckt->CKTstate0 + here->BSIM4v7vses); + vdes = *(ckt->CKTstate0 + here->BSIM4v7vdes); - qdef = *(ckt->CKTstate0 + here->BSIM4qdef); + qdef = *(ckt->CKTstate0 + here->BSIM4v7qdef); } else if ((ckt->CKTmode & MODEINITTRAN)) - { vds = *(ckt->CKTstate1 + here->BSIM4vds); - vgs = *(ckt->CKTstate1 + here->BSIM4vgs); - vbs = *(ckt->CKTstate1 + here->BSIM4vbs); - vges = *(ckt->CKTstate1 + here->BSIM4vges); - vgms = *(ckt->CKTstate1 + here->BSIM4vgms); - vdbs = *(ckt->CKTstate1 + here->BSIM4vdbs); - vsbs = *(ckt->CKTstate1 + here->BSIM4vsbs); - vses = *(ckt->CKTstate1 + here->BSIM4vses); - vdes = *(ckt->CKTstate1 + here->BSIM4vdes); + { vds = *(ckt->CKTstate1 + here->BSIM4v7vds); + vgs = *(ckt->CKTstate1 + here->BSIM4v7vgs); + vbs = *(ckt->CKTstate1 + here->BSIM4v7vbs); + vges = *(ckt->CKTstate1 + here->BSIM4v7vges); + vgms = *(ckt->CKTstate1 + here->BSIM4v7vgms); + vdbs = *(ckt->CKTstate1 + here->BSIM4v7vdbs); + vsbs = *(ckt->CKTstate1 + here->BSIM4v7vsbs); + vses = *(ckt->CKTstate1 + here->BSIM4v7vses); + vdes = *(ckt->CKTstate1 + here->BSIM4v7vdes); - qdef = *(ckt->CKTstate1 + here->BSIM4qdef); + qdef = *(ckt->CKTstate1 + here->BSIM4v7qdef); } - else if ((ckt->CKTmode & MODEINITJCT) && !here->BSIM4off) - { vds = model->BSIM4type * here->BSIM4icVDS; - vgs = vges = vgms = model->BSIM4type * here->BSIM4icVGS; - vbs = vdbs = vsbs = model->BSIM4type * here->BSIM4icVBS; + else if ((ckt->CKTmode & MODEINITJCT) && !here->BSIM4v7off) + { vds = model->BSIM4v7type * here->BSIM4v7icVDS; + vgs = vges = vgms = model->BSIM4v7type * here->BSIM4v7icVGS; + vbs = vdbs = vsbs = model->BSIM4v7type * here->BSIM4v7icVBS; if (vds > 0.0) { vdes = vds + 0.01; vses = -0.01; @@ -310,13 +310,13 @@ for (; model != NULL; model = model->BSIM4nextModel) { vds = 0.1; vdes = 0.11; vses = -0.01; - vgs = vges = vgms = model->BSIM4type - * here->BSIM4vth0 + 0.1; + vgs = vges = vgms = model->BSIM4v7type + * here->BSIM4v7vth0 + 0.1; vbs = vdbs = vsbs = 0.0; } } else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) && - (here->BSIM4off)) + (here->BSIM4v7off)) { vds = vgs = vbs = vges = vgms = 0.0; vdbs = vsbs = vdes = vses = qdef = 0.0; } @@ -325,96 +325,96 @@ for (; model != NULL; model = model->BSIM4nextModel) #ifndef PREDICTOR if ((ckt->CKTmode & MODEINITPRED)) { xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1]; - *(ckt->CKTstate0 + here->BSIM4vds) = - *(ckt->CKTstate1 + here->BSIM4vds); - vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vds)) - - (xfact * (*(ckt->CKTstate2 + here->BSIM4vds))); - *(ckt->CKTstate0 + here->BSIM4vgs) = - *(ckt->CKTstate1 + here->BSIM4vgs); - vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vgs)) - - (xfact * (*(ckt->CKTstate2 + here->BSIM4vgs))); - *(ckt->CKTstate0 + here->BSIM4vges) = - *(ckt->CKTstate1 + here->BSIM4vges); - vges = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vges)) - - (xfact * (*(ckt->CKTstate2 + here->BSIM4vges))); - *(ckt->CKTstate0 + here->BSIM4vgms) = - *(ckt->CKTstate1 + here->BSIM4vgms); - vgms = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vgms)) - - (xfact * (*(ckt->CKTstate2 + here->BSIM4vgms))); - *(ckt->CKTstate0 + here->BSIM4vbs) = - *(ckt->CKTstate1 + here->BSIM4vbs); - vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vbs)) - - (xfact * (*(ckt->CKTstate2 + here->BSIM4vbs))); - *(ckt->CKTstate0 + here->BSIM4vbd) = - *(ckt->CKTstate0 + here->BSIM4vbs) - - *(ckt->CKTstate0 + here->BSIM4vds); - *(ckt->CKTstate0 + here->BSIM4vdbs) = - *(ckt->CKTstate1 + here->BSIM4vdbs); - vdbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vdbs)) - - (xfact * (*(ckt->CKTstate2 + here->BSIM4vdbs))); - *(ckt->CKTstate0 + here->BSIM4vdbd) = - *(ckt->CKTstate0 + here->BSIM4vdbs) - - *(ckt->CKTstate0 + here->BSIM4vds); - *(ckt->CKTstate0 + here->BSIM4vsbs) = - *(ckt->CKTstate1 + here->BSIM4vsbs); - vsbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vsbs)) - - (xfact * (*(ckt->CKTstate2 + here->BSIM4vsbs))); - *(ckt->CKTstate0 + here->BSIM4vses) = - *(ckt->CKTstate1 + here->BSIM4vses); - vses = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vses)) - - (xfact * (*(ckt->CKTstate2 + here->BSIM4vses))); - *(ckt->CKTstate0 + here->BSIM4vdes) = - *(ckt->CKTstate1 + here->BSIM4vdes); - vdes = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4vdes)) - - (xfact * (*(ckt->CKTstate2 + here->BSIM4vdes))); + *(ckt->CKTstate0 + here->BSIM4v7vds) = + *(ckt->CKTstate1 + here->BSIM4v7vds); + vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4v7vds)) + - (xfact * (*(ckt->CKTstate2 + here->BSIM4v7vds))); + *(ckt->CKTstate0 + here->BSIM4v7vgs) = + *(ckt->CKTstate1 + here->BSIM4v7vgs); + vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4v7vgs)) + - (xfact * (*(ckt->CKTstate2 + here->BSIM4v7vgs))); + *(ckt->CKTstate0 + here->BSIM4v7vges) = + *(ckt->CKTstate1 + here->BSIM4v7vges); + vges = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4v7vges)) + - (xfact * (*(ckt->CKTstate2 + here->BSIM4v7vges))); + *(ckt->CKTstate0 + here->BSIM4v7vgms) = + *(ckt->CKTstate1 + here->BSIM4v7vgms); + vgms = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4v7vgms)) + - (xfact * (*(ckt->CKTstate2 + here->BSIM4v7vgms))); + *(ckt->CKTstate0 + here->BSIM4v7vbs) = + *(ckt->CKTstate1 + here->BSIM4v7vbs); + vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4v7vbs)) + - (xfact * (*(ckt->CKTstate2 + here->BSIM4v7vbs))); + *(ckt->CKTstate0 + here->BSIM4v7vbd) = + *(ckt->CKTstate0 + here->BSIM4v7vbs) + - *(ckt->CKTstate0 + here->BSIM4v7vds); + *(ckt->CKTstate0 + here->BSIM4v7vdbs) = + *(ckt->CKTstate1 + here->BSIM4v7vdbs); + vdbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4v7vdbs)) + - (xfact * (*(ckt->CKTstate2 + here->BSIM4v7vdbs))); + *(ckt->CKTstate0 + here->BSIM4v7vdbd) = + *(ckt->CKTstate0 + here->BSIM4v7vdbs) + - *(ckt->CKTstate0 + here->BSIM4v7vds); + *(ckt->CKTstate0 + here->BSIM4v7vsbs) = + *(ckt->CKTstate1 + here->BSIM4v7vsbs); + vsbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4v7vsbs)) + - (xfact * (*(ckt->CKTstate2 + here->BSIM4v7vsbs))); + *(ckt->CKTstate0 + here->BSIM4v7vses) = + *(ckt->CKTstate1 + here->BSIM4v7vses); + vses = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4v7vses)) + - (xfact * (*(ckt->CKTstate2 + here->BSIM4v7vses))); + *(ckt->CKTstate0 + here->BSIM4v7vdes) = + *(ckt->CKTstate1 + here->BSIM4v7vdes); + vdes = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4v7vdes)) + - (xfact * (*(ckt->CKTstate2 + here->BSIM4v7vdes))); - *(ckt->CKTstate0 + here->BSIM4qdef) = - *(ckt->CKTstate1 + here->BSIM4qdef); - qdef = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4qdef)) - -(xfact * (*(ckt->CKTstate2 + here->BSIM4qdef))); + *(ckt->CKTstate0 + here->BSIM4v7qdef) = + *(ckt->CKTstate1 + here->BSIM4v7qdef); + qdef = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM4v7qdef)) + -(xfact * (*(ckt->CKTstate2 + here->BSIM4v7qdef))); } else { #endif /* PREDICTOR */ - vds = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4dNodePrime) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vgs = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4gNodePrime) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vbs = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4bNodePrime) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vges = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4gNodeExt) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vgms = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4gNodeMid) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vdbs = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4dbNode) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vsbs = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4sbNode) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vses = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4sNode) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - vdes = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4dNode) - - *(ckt->CKTrhsOld + here->BSIM4sNodePrime)); - qdef = model->BSIM4type - * (*(ckt->CKTrhsOld + here->BSIM4qNode)); + vds = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7dNodePrime) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vgs = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7gNodePrime) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vbs = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7bNodePrime) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vges = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7gNodeExt) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vgms = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7gNodeMid) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vdbs = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7dbNode) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vsbs = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7sbNode) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vses = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7sNode) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + vdes = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7dNode) + - *(ckt->CKTrhsOld + here->BSIM4v7sNodePrime)); + qdef = model->BSIM4v7type + * (*(ckt->CKTrhsOld + here->BSIM4v7qNode)); #ifndef PREDICTOR } #endif /* PREDICTOR */ - vgdo = *(ckt->CKTstate0 + here->BSIM4vgs) - - *(ckt->CKTstate0 + here->BSIM4vds); - vgedo = *(ckt->CKTstate0 + here->BSIM4vges) - - *(ckt->CKTstate0 + here->BSIM4vds); - vgmdo = *(ckt->CKTstate0 + here->BSIM4vgms) - - *(ckt->CKTstate0 + here->BSIM4vds); + vgdo = *(ckt->CKTstate0 + here->BSIM4v7vgs) + - *(ckt->CKTstate0 + here->BSIM4v7vds); + vgedo = *(ckt->CKTstate0 + here->BSIM4v7vges) + - *(ckt->CKTstate0 + here->BSIM4v7vds); + vgmdo = *(ckt->CKTstate0 + here->BSIM4v7vgms) + - *(ckt->CKTstate0 + here->BSIM4v7vds); vbd = vbs - vds; vdbd = vdbs - vds; @@ -422,91 +422,91 @@ for (; model != NULL; model = model->BSIM4nextModel) vged = vges - vds; vgmd = vgms - vds; - delvbd = vbd - *(ckt->CKTstate0 + here->BSIM4vbd); - delvdbd = vdbd - *(ckt->CKTstate0 + here->BSIM4vdbd); + delvbd = vbd - *(ckt->CKTstate0 + here->BSIM4v7vbd); + delvdbd = vdbd - *(ckt->CKTstate0 + here->BSIM4v7vdbd); delvgd = vgd - vgdo; delvged = vged - vgedo; delvgmd = vgmd - vgmdo; - delvds = vds - *(ckt->CKTstate0 + here->BSIM4vds); - delvgs = vgs - *(ckt->CKTstate0 + here->BSIM4vgs); - delvges = vges - *(ckt->CKTstate0 + here->BSIM4vges); - delvgms = vgms - *(ckt->CKTstate0 + here->BSIM4vgms); - delvbs = vbs - *(ckt->CKTstate0 + here->BSIM4vbs); - delvdbs = vdbs - *(ckt->CKTstate0 + here->BSIM4vdbs); - delvsbs = vsbs - *(ckt->CKTstate0 + here->BSIM4vsbs); + delvds = vds - *(ckt->CKTstate0 + here->BSIM4v7vds); + delvgs = vgs - *(ckt->CKTstate0 + here->BSIM4v7vgs); + delvges = vges - *(ckt->CKTstate0 + here->BSIM4v7vges); + delvgms = vgms - *(ckt->CKTstate0 + here->BSIM4v7vgms); + delvbs = vbs - *(ckt->CKTstate0 + here->BSIM4v7vbs); + delvdbs = vdbs - *(ckt->CKTstate0 + here->BSIM4v7vdbs); + delvsbs = vsbs - *(ckt->CKTstate0 + here->BSIM4v7vsbs); - delvses = vses - (*(ckt->CKTstate0 + here->BSIM4vses)); - vdedo = *(ckt->CKTstate0 + here->BSIM4vdes) - - *(ckt->CKTstate0 + here->BSIM4vds); - delvdes = vdes - *(ckt->CKTstate0 + here->BSIM4vdes); + delvses = vses - (*(ckt->CKTstate0 + here->BSIM4v7vses)); + vdedo = *(ckt->CKTstate0 + here->BSIM4v7vdes) + - *(ckt->CKTstate0 + here->BSIM4v7vds); + delvdes = vdes - *(ckt->CKTstate0 + here->BSIM4v7vdes); delvded = vdes - vds - vdedo; - delvbd_jct = (!here->BSIM4rbodyMod) ? delvbd : delvdbd; - delvbs_jct = (!here->BSIM4rbodyMod) ? delvbs : delvsbs; - if (here->BSIM4mode >= 0) - { Idtot = here->BSIM4cd + here->BSIM4csub - here->BSIM4cbd - + here->BSIM4Igidl; - cdhat = Idtot - here->BSIM4gbd * delvbd_jct - + (here->BSIM4gmbs + here->BSIM4gbbs + here->BSIM4ggidlb) * delvbs - + (here->BSIM4gm + here->BSIM4gbgs + here->BSIM4ggidlg) * delvgs - + (here->BSIM4gds + here->BSIM4gbds + here->BSIM4ggidld) * delvds; - Ibtot = here->BSIM4cbs + here->BSIM4cbd - - here->BSIM4Igidl - here->BSIM4Igisl - here->BSIM4csub; - cbhat = Ibtot + here->BSIM4gbd * delvbd_jct - + here->BSIM4gbs * delvbs_jct - (here->BSIM4gbbs + here->BSIM4ggidlb) - * delvbs - (here->BSIM4gbgs + here->BSIM4ggidlg) * delvgs - - (here->BSIM4gbds + here->BSIM4ggidld - here->BSIM4ggisls) * delvds - - here->BSIM4ggislg * delvgd - here->BSIM4ggislb* delvbd; + delvbd_jct = (!here->BSIM4v7rbodyMod) ? delvbd : delvdbd; + delvbs_jct = (!here->BSIM4v7rbodyMod) ? delvbs : delvsbs; + if (here->BSIM4v7mode >= 0) + { Idtot = here->BSIM4v7cd + here->BSIM4v7csub - here->BSIM4v7cbd + + here->BSIM4v7Igidl; + cdhat = Idtot - here->BSIM4v7gbd * delvbd_jct + + (here->BSIM4v7gmbs + here->BSIM4v7gbbs + here->BSIM4v7ggidlb) * delvbs + + (here->BSIM4v7gm + here->BSIM4v7gbgs + here->BSIM4v7ggidlg) * delvgs + + (here->BSIM4v7gds + here->BSIM4v7gbds + here->BSIM4v7ggidld) * delvds; + Ibtot = here->BSIM4v7cbs + here->BSIM4v7cbd + - here->BSIM4v7Igidl - here->BSIM4v7Igisl - here->BSIM4v7csub; + cbhat = Ibtot + here->BSIM4v7gbd * delvbd_jct + + here->BSIM4v7gbs * delvbs_jct - (here->BSIM4v7gbbs + here->BSIM4v7ggidlb) + * delvbs - (here->BSIM4v7gbgs + here->BSIM4v7ggidlg) * delvgs + - (here->BSIM4v7gbds + here->BSIM4v7ggidld - here->BSIM4v7ggisls) * delvds + - here->BSIM4v7ggislg * delvgd - here->BSIM4v7ggislb* delvbd; - Igstot = here->BSIM4Igs + here->BSIM4Igcs; - cgshat = Igstot + (here->BSIM4gIgsg + here->BSIM4gIgcsg) * delvgs - + here->BSIM4gIgcsd * delvds + here->BSIM4gIgcsb * delvbs; + Igstot = here->BSIM4v7Igs + here->BSIM4v7Igcs; + cgshat = Igstot + (here->BSIM4v7gIgsg + here->BSIM4v7gIgcsg) * delvgs + + here->BSIM4v7gIgcsd * delvds + here->BSIM4v7gIgcsb * delvbs; - Igdtot = here->BSIM4Igd + here->BSIM4Igcd; - cgdhat = Igdtot + here->BSIM4gIgdg * delvgd + here->BSIM4gIgcdg * delvgs - + here->BSIM4gIgcdd * delvds + here->BSIM4gIgcdb * delvbs; + Igdtot = here->BSIM4v7Igd + here->BSIM4v7Igcd; + cgdhat = Igdtot + here->BSIM4v7gIgdg * delvgd + here->BSIM4v7gIgcdg * delvgs + + here->BSIM4v7gIgcdd * delvds + here->BSIM4v7gIgcdb * delvbs; - Igbtot = here->BSIM4Igb; - cgbhat = here->BSIM4Igb + here->BSIM4gIgbg * delvgs + here->BSIM4gIgbd - * delvds + here->BSIM4gIgbb * delvbs; + Igbtot = here->BSIM4v7Igb; + cgbhat = here->BSIM4v7Igb + here->BSIM4v7gIgbg * delvgs + here->BSIM4v7gIgbd + * delvds + here->BSIM4v7gIgbb * delvbs; } else - { Idtot = here->BSIM4cd + here->BSIM4cbd - here->BSIM4Igidl; /* bugfix */ - cdhat = Idtot + here->BSIM4gbd * delvbd_jct + here->BSIM4gmbs - * delvbd + here->BSIM4gm * delvgd - - (here->BSIM4gds + here->BSIM4ggidls) * delvds - - here->BSIM4ggidlg * delvgs - here->BSIM4ggidlb * delvbs; - Ibtot = here->BSIM4cbs + here->BSIM4cbd - - here->BSIM4Igidl - here->BSIM4Igisl - here->BSIM4csub; - cbhat = Ibtot + here->BSIM4gbs * delvbs_jct + here->BSIM4gbd - * delvbd_jct - (here->BSIM4gbbs + here->BSIM4ggislb) * delvbd - - (here->BSIM4gbgs + here->BSIM4ggislg) * delvgd - + (here->BSIM4gbds + here->BSIM4ggisld - here->BSIM4ggidls) * delvds - - here->BSIM4ggidlg * delvgs - here->BSIM4ggidlb * delvbs; + { Idtot = here->BSIM4v7cd + here->BSIM4v7cbd - here->BSIM4v7Igidl; /* bugfix */ + cdhat = Idtot + here->BSIM4v7gbd * delvbd_jct + here->BSIM4v7gmbs + * delvbd + here->BSIM4v7gm * delvgd + - (here->BSIM4v7gds + here->BSIM4v7ggidls) * delvds + - here->BSIM4v7ggidlg * delvgs - here->BSIM4v7ggidlb * delvbs; + Ibtot = here->BSIM4v7cbs + here->BSIM4v7cbd + - here->BSIM4v7Igidl - here->BSIM4v7Igisl - here->BSIM4v7csub; + cbhat = Ibtot + here->BSIM4v7gbs * delvbs_jct + here->BSIM4v7gbd + * delvbd_jct - (here->BSIM4v7gbbs + here->BSIM4v7ggislb) * delvbd + - (here->BSIM4v7gbgs + here->BSIM4v7ggislg) * delvgd + + (here->BSIM4v7gbds + here->BSIM4v7ggisld - here->BSIM4v7ggidls) * delvds + - here->BSIM4v7ggidlg * delvgs - here->BSIM4v7ggidlb * delvbs; - Igstot = here->BSIM4Igs + here->BSIM4Igcd; - cgshat = Igstot + here->BSIM4gIgsg * delvgs + here->BSIM4gIgcdg * delvgd - - here->BSIM4gIgcdd * delvds + here->BSIM4gIgcdb * delvbd; + Igstot = here->BSIM4v7Igs + here->BSIM4v7Igcd; + cgshat = Igstot + here->BSIM4v7gIgsg * delvgs + here->BSIM4v7gIgcdg * delvgd + - here->BSIM4v7gIgcdd * delvds + here->BSIM4v7gIgcdb * delvbd; - Igdtot = here->BSIM4Igd + here->BSIM4Igcs; - cgdhat = Igdtot + (here->BSIM4gIgdg + here->BSIM4gIgcsg) * delvgd - - here->BSIM4gIgcsd * delvds + here->BSIM4gIgcsb * delvbd; + Igdtot = here->BSIM4v7Igd + here->BSIM4v7Igcs; + cgdhat = Igdtot + (here->BSIM4v7gIgdg + here->BSIM4v7gIgcsg) * delvgd + - here->BSIM4v7gIgcsd * delvds + here->BSIM4v7gIgcsb * delvbd; - Igbtot = here->BSIM4Igb; - cgbhat = here->BSIM4Igb + here->BSIM4gIgbg * delvgd - here->BSIM4gIgbd - * delvds + here->BSIM4gIgbb * delvbd; + Igbtot = here->BSIM4v7Igb; + cgbhat = here->BSIM4v7Igb + here->BSIM4v7gIgbg * delvgd - here->BSIM4v7gIgbd + * delvds + here->BSIM4v7gIgbb * delvbd; } - Isestot = here->BSIM4gstot * (*(ckt->CKTstate0 + here->BSIM4vses)); - cseshat = Isestot + here->BSIM4gstot * delvses - + here->BSIM4gstotd * delvds + here->BSIM4gstotg * delvgs - + here->BSIM4gstotb * delvbs; + Isestot = here->BSIM4v7gstot * (*(ckt->CKTstate0 + here->BSIM4v7vses)); + cseshat = Isestot + here->BSIM4v7gstot * delvses + + here->BSIM4v7gstotd * delvds + here->BSIM4v7gstotg * delvgs + + here->BSIM4v7gstotb * delvbs; - Idedtot = here->BSIM4gdtot * vdedo; - cdedhat = Idedtot + here->BSIM4gdtot * delvded - + here->BSIM4gdtotd * delvds + here->BSIM4gdtotg * delvgs - + here->BSIM4gdtotb * delvbs; + Idedtot = here->BSIM4v7gdtot * vdedo; + cdedhat = Idedtot + here->BSIM4v7gdtot * delvded + + here->BSIM4v7gdtotd * delvds + here->BSIM4v7gdtotg * delvgs + + here->BSIM4v7gdtotb * delvbs; #ifndef NOBYPASS @@ -516,60 +516,60 @@ for (; model != NULL; model = model->BSIM4nextModel) if ((!(ckt->CKTmode & MODEINITPRED)) && (ckt->CKTbypass)) if ((fabs(delvds) < (ckt->CKTreltol * MAX(fabs(vds), - fabs(*(ckt->CKTstate0 + here->BSIM4vds))) + ckt->CKTvoltTol))) + fabs(*(ckt->CKTstate0 + here->BSIM4v7vds))) + ckt->CKTvoltTol))) if ((fabs(delvgs) < (ckt->CKTreltol * MAX(fabs(vgs), - fabs(*(ckt->CKTstate0 + here->BSIM4vgs))) + ckt->CKTvoltTol))) + fabs(*(ckt->CKTstate0 + here->BSIM4v7vgs))) + ckt->CKTvoltTol))) if ((fabs(delvbs) < (ckt->CKTreltol * MAX(fabs(vbs), - fabs(*(ckt->CKTstate0 + here->BSIM4vbs))) + ckt->CKTvoltTol))) + fabs(*(ckt->CKTstate0 + here->BSIM4v7vbs))) + ckt->CKTvoltTol))) if ((fabs(delvbd) < (ckt->CKTreltol * MAX(fabs(vbd), - fabs(*(ckt->CKTstate0 + here->BSIM4vbd))) + ckt->CKTvoltTol))) - if ((here->BSIM4rgateMod == 0) || (here->BSIM4rgateMod == 1) + fabs(*(ckt->CKTstate0 + here->BSIM4v7vbd))) + ckt->CKTvoltTol))) + if ((here->BSIM4v7rgateMod == 0) || (here->BSIM4v7rgateMod == 1) || (fabs(delvges) < (ckt->CKTreltol * MAX(fabs(vges), - fabs(*(ckt->CKTstate0 + here->BSIM4vges))) + ckt->CKTvoltTol))) - if ((here->BSIM4rgateMod != 3) || (fabs(delvgms) < (ckt->CKTreltol - * MAX(fabs(vgms), fabs(*(ckt->CKTstate0 + here->BSIM4vgms))) + fabs(*(ckt->CKTstate0 + here->BSIM4v7vges))) + ckt->CKTvoltTol))) + if ((here->BSIM4v7rgateMod != 3) || (fabs(delvgms) < (ckt->CKTreltol + * MAX(fabs(vgms), fabs(*(ckt->CKTstate0 + here->BSIM4v7vgms))) + ckt->CKTvoltTol))) - if ((!here->BSIM4rbodyMod) || (fabs(delvdbs) < (ckt->CKTreltol - * MAX(fabs(vdbs), fabs(*(ckt->CKTstate0 + here->BSIM4vdbs))) + if ((!here->BSIM4v7rbodyMod) || (fabs(delvdbs) < (ckt->CKTreltol + * MAX(fabs(vdbs), fabs(*(ckt->CKTstate0 + here->BSIM4v7vdbs))) + ckt->CKTvoltTol))) - if ((!here->BSIM4rbodyMod) || (fabs(delvdbd) < (ckt->CKTreltol - * MAX(fabs(vdbd), fabs(*(ckt->CKTstate0 + here->BSIM4vdbd))) + if ((!here->BSIM4v7rbodyMod) || (fabs(delvdbd) < (ckt->CKTreltol + * MAX(fabs(vdbd), fabs(*(ckt->CKTstate0 + here->BSIM4v7vdbd))) + ckt->CKTvoltTol))) - if ((!here->BSIM4rbodyMod) || (fabs(delvsbs) < (ckt->CKTreltol - * MAX(fabs(vsbs), fabs(*(ckt->CKTstate0 + here->BSIM4vsbs))) + if ((!here->BSIM4v7rbodyMod) || (fabs(delvsbs) < (ckt->CKTreltol + * MAX(fabs(vsbs), fabs(*(ckt->CKTstate0 + here->BSIM4v7vsbs))) + ckt->CKTvoltTol))) - if ((!model->BSIM4rdsMod) || (fabs(delvses) < (ckt->CKTreltol - * MAX(fabs(vses), fabs(*(ckt->CKTstate0 + here->BSIM4vses))) + if ((!model->BSIM4v7rdsMod) || (fabs(delvses) < (ckt->CKTreltol + * MAX(fabs(vses), fabs(*(ckt->CKTstate0 + here->BSIM4v7vses))) + ckt->CKTvoltTol))) - if ((!model->BSIM4rdsMod) || (fabs(delvdes) < (ckt->CKTreltol - * MAX(fabs(vdes), fabs(*(ckt->CKTstate0 + here->BSIM4vdes))) + if ((!model->BSIM4v7rdsMod) || (fabs(delvdes) < (ckt->CKTreltol + * MAX(fabs(vdes), fabs(*(ckt->CKTstate0 + here->BSIM4v7vdes))) + ckt->CKTvoltTol))) if ((fabs(cdhat - Idtot) < ckt->CKTreltol * MAX(fabs(cdhat), fabs(Idtot)) + ckt->CKTabstol)) if ((fabs(cbhat - Ibtot) < ckt->CKTreltol * MAX(fabs(cbhat), fabs(Ibtot)) + ckt->CKTabstol)) - if ((!model->BSIM4igcMod) || ((fabs(cgshat - Igstot) < ckt->CKTreltol + if ((!model->BSIM4v7igcMod) || ((fabs(cgshat - Igstot) < ckt->CKTreltol * MAX(fabs(cgshat), fabs(Igstot)) + ckt->CKTabstol))) - if ((!model->BSIM4igcMod) || ((fabs(cgdhat - Igdtot) < ckt->CKTreltol + if ((!model->BSIM4v7igcMod) || ((fabs(cgdhat - Igdtot) < ckt->CKTreltol * MAX(fabs(cgdhat), fabs(Igdtot)) + ckt->CKTabstol))) - if ((!model->BSIM4igbMod) || ((fabs(cgbhat - Igbtot) < ckt->CKTreltol + if ((!model->BSIM4v7igbMod) || ((fabs(cgbhat - Igbtot) < ckt->CKTreltol * MAX(fabs(cgbhat), fabs(Igbtot)) + ckt->CKTabstol))) - if ((!model->BSIM4rdsMod) || ((fabs(cseshat - Isestot) < ckt->CKTreltol + if ((!model->BSIM4v7rdsMod) || ((fabs(cseshat - Isestot) < ckt->CKTreltol * MAX(fabs(cseshat), fabs(Isestot)) + ckt->CKTabstol))) - if ((!model->BSIM4rdsMod) || ((fabs(cdedhat - Idedtot) < ckt->CKTreltol + if ((!model->BSIM4v7rdsMod) || ((fabs(cdedhat - Idedtot) < ckt->CKTreltol * MAX(fabs(cdedhat), fabs(Idedtot)) + ckt->CKTabstol))) - { vds = *(ckt->CKTstate0 + here->BSIM4vds); - vgs = *(ckt->CKTstate0 + here->BSIM4vgs); - vbs = *(ckt->CKTstate0 + here->BSIM4vbs); - vges = *(ckt->CKTstate0 + here->BSIM4vges); - vgms = *(ckt->CKTstate0 + here->BSIM4vgms); + { vds = *(ckt->CKTstate0 + here->BSIM4v7vds); + vgs = *(ckt->CKTstate0 + here->BSIM4v7vgs); + vbs = *(ckt->CKTstate0 + here->BSIM4v7vbs); + vges = *(ckt->CKTstate0 + here->BSIM4v7vges); + vgms = *(ckt->CKTstate0 + here->BSIM4v7vgms); - vbd = *(ckt->CKTstate0 + here->BSIM4vbd); - vdbs = *(ckt->CKTstate0 + here->BSIM4vdbs); - vdbd = *(ckt->CKTstate0 + here->BSIM4vdbd); - vsbs = *(ckt->CKTstate0 + here->BSIM4vsbs); - vses = *(ckt->CKTstate0 + here->BSIM4vses); - vdes = *(ckt->CKTstate0 + here->BSIM4vdes); + vbd = *(ckt->CKTstate0 + here->BSIM4v7vbd); + vdbs = *(ckt->CKTstate0 + here->BSIM4v7vdbs); + vdbd = *(ckt->CKTstate0 + here->BSIM4v7vdbd); + vsbs = *(ckt->CKTstate0 + here->BSIM4v7vsbs); + vses = *(ckt->CKTstate0 + here->BSIM4v7vses); + vdes = *(ckt->CKTstate0 + here->BSIM4v7vdes); vgd = vgs - vds; vgb = vgs - vbs; @@ -577,26 +577,26 @@ for (; model != NULL; model = model->BSIM4nextModel) vgmd = vgms - vds; vgmb = vgms - vbs; - vbs_jct = (!here->BSIM4rbodyMod) ? vbs : vsbs; - vbd_jct = (!here->BSIM4rbodyMod) ? vbd : vdbd; + vbs_jct = (!here->BSIM4v7rbodyMod) ? vbs : vsbs; + vbd_jct = (!here->BSIM4v7rbodyMod) ? vbd : vdbd; /*** qdef should not be kept fixed even if vgs, vds & vbs has converged -**** qdef = *(ckt->CKTstate0 + here->BSIM4qdef); +**** qdef = *(ckt->CKTstate0 + here->BSIM4v7qdef); ***/ - cdrain = here->BSIM4cd; + cdrain = here->BSIM4v7cd; if ((ckt->CKTmode & (MODETRAN | MODEAC)) || ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC))) { ByPass = 1; - qgate = here->BSIM4qgate; - qbulk = here->BSIM4qbulk; - qdrn = here->BSIM4qdrn; - cgdo = here->BSIM4cgdo; - qgdo = here->BSIM4qgdo; - cgso = here->BSIM4cgso; - qgso = here->BSIM4qgso; + qgate = here->BSIM4v7qgate; + qbulk = here->BSIM4v7qbulk; + qdrn = here->BSIM4v7qdrn; + cgdo = here->BSIM4v7cgdo; + qgdo = here->BSIM4v7qgdo; + cgso = here->BSIM4v7cgso; + qgso = here->BSIM4v7qgso; goto line755; } @@ -605,62 +605,62 @@ for (; model != NULL; model = model->BSIM4nextModel) } #endif /*NOBYPASS*/ - von = here->BSIM4von; - if (*(ckt->CKTstate0 + here->BSIM4vds) >= 0.0) - { vgs = DEVfetlim(vgs, *(ckt->CKTstate0 + here->BSIM4vgs), von); + von = here->BSIM4v7von; + if (*(ckt->CKTstate0 + here->BSIM4v7vds) >= 0.0) + { vgs = DEVfetlim(vgs, *(ckt->CKTstate0 + here->BSIM4v7vgs), von); vds = vgs - vgd; - vds = DEVlimvds(vds, *(ckt->CKTstate0 + here->BSIM4vds)); + vds = DEVlimvds(vds, *(ckt->CKTstate0 + here->BSIM4v7vds)); vgd = vgs - vds; - if (here->BSIM4rgateMod == 3) - { vges = DEVfetlim(vges, *(ckt->CKTstate0 + here->BSIM4vges), von); - vgms = DEVfetlim(vgms, *(ckt->CKTstate0 + here->BSIM4vgms), von); + if (here->BSIM4v7rgateMod == 3) + { vges = DEVfetlim(vges, *(ckt->CKTstate0 + here->BSIM4v7vges), von); + vgms = DEVfetlim(vgms, *(ckt->CKTstate0 + here->BSIM4v7vgms), von); vged = vges - vds; vgmd = vgms - vds; } - else if ((here->BSIM4rgateMod == 1) || (here->BSIM4rgateMod == 2)) - { vges = DEVfetlim(vges, *(ckt->CKTstate0 + here->BSIM4vges), von); + else if ((here->BSIM4v7rgateMod == 1) || (here->BSIM4v7rgateMod == 2)) + { vges = DEVfetlim(vges, *(ckt->CKTstate0 + here->BSIM4v7vges), von); vged = vges - vds; } - if (model->BSIM4rdsMod) - { vdes = DEVlimvds(vdes, *(ckt->CKTstate0 + here->BSIM4vdes)); - vses = -DEVlimvds(-vses, -(*(ckt->CKTstate0 + here->BSIM4vses))); + if (model->BSIM4v7rdsMod) + { vdes = DEVlimvds(vdes, *(ckt->CKTstate0 + here->BSIM4v7vdes)); + vses = -DEVlimvds(-vses, -(*(ckt->CKTstate0 + here->BSIM4v7vses))); } } else { vgd = DEVfetlim(vgd, vgdo, von); vds = vgs - vgd; - vds = -DEVlimvds(-vds, -(*(ckt->CKTstate0 + here->BSIM4vds))); + vds = -DEVlimvds(-vds, -(*(ckt->CKTstate0 + here->BSIM4v7vds))); vgs = vgd + vds; - if (here->BSIM4rgateMod == 3) + if (here->BSIM4v7rgateMod == 3) { vged = DEVfetlim(vged, vgedo, von); vges = vged + vds; vgmd = DEVfetlim(vgmd, vgmdo, von); vgms = vgmd + vds; } - if ((here->BSIM4rgateMod == 1) || (here->BSIM4rgateMod == 2)) + if ((here->BSIM4v7rgateMod == 1) || (here->BSIM4v7rgateMod == 2)) { vged = DEVfetlim(vged, vgedo, von); vges = vged + vds; } - if (model->BSIM4rdsMod) - { vdes = -DEVlimvds(-vdes, -(*(ckt->CKTstate0 + here->BSIM4vdes))); - vses = DEVlimvds(vses, *(ckt->CKTstate0 + here->BSIM4vses)); + if (model->BSIM4v7rdsMod) + { vdes = -DEVlimvds(-vdes, -(*(ckt->CKTstate0 + here->BSIM4v7vdes))); + vses = DEVlimvds(vses, *(ckt->CKTstate0 + here->BSIM4v7vses)); } } if (vds >= 0.0) - { vbs = DEVpnjlim(vbs, *(ckt->CKTstate0 + here->BSIM4vbs), - CONSTvt0, model->BSIM4vcrit, &Check); + { vbs = DEVpnjlim(vbs, *(ckt->CKTstate0 + here->BSIM4v7vbs), + CONSTvt0, model->BSIM4v7vcrit, &Check); vbd = vbs - vds; - if (here->BSIM4rbodyMod) - { vdbs = DEVpnjlim(vdbs, *(ckt->CKTstate0 + here->BSIM4vdbs), - CONSTvt0, model->BSIM4vcrit, &Check1); + if (here->BSIM4v7rbodyMod) + { vdbs = DEVpnjlim(vdbs, *(ckt->CKTstate0 + here->BSIM4v7vdbs), + CONSTvt0, model->BSIM4v7vcrit, &Check1); vdbd = vdbs - vds; - vsbs = DEVpnjlim(vsbs, *(ckt->CKTstate0 + here->BSIM4vsbs), - CONSTvt0, model->BSIM4vcrit, &Check2); + vsbs = DEVpnjlim(vsbs, *(ckt->CKTstate0 + here->BSIM4v7vsbs), + CONSTvt0, model->BSIM4v7vcrit, &Check2); if ((Check1 == 0) && (Check2 == 0)) Check = 0; else @@ -668,17 +668,17 @@ for (; model != NULL; model = model->BSIM4nextModel) } } else - { vbd = DEVpnjlim(vbd, *(ckt->CKTstate0 + here->BSIM4vbd), - CONSTvt0, model->BSIM4vcrit, &Check); + { vbd = DEVpnjlim(vbd, *(ckt->CKTstate0 + here->BSIM4v7vbd), + CONSTvt0, model->BSIM4v7vcrit, &Check); vbs = vbd + vds; - if (here->BSIM4rbodyMod) - { vdbd = DEVpnjlim(vdbd, *(ckt->CKTstate0 + here->BSIM4vdbd), - CONSTvt0, model->BSIM4vcrit, &Check1); + if (here->BSIM4v7rbodyMod) + { vdbd = DEVpnjlim(vdbd, *(ckt->CKTstate0 + here->BSIM4v7vdbd), + CONSTvt0, model->BSIM4v7vcrit, &Check1); vdbs = vdbd + vds; - vsbdo = *(ckt->CKTstate0 + here->BSIM4vsbs) - - *(ckt->CKTstate0 + here->BSIM4vds); + vsbdo = *(ckt->CKTstate0 + here->BSIM4v7vsbs) + - *(ckt->CKTstate0 + here->BSIM4v7vds); vsbd = vsbs - vds; - vsbd = DEVpnjlim(vsbd, vsbdo, CONSTvt0, model->BSIM4vcrit, &Check2); + vsbd = DEVpnjlim(vsbd, vsbdo, CONSTvt0, model->BSIM4v7vcrit, &Check2); vsbs = vsbd + vds; if ((Check1 == 0) && (Check2 == 0)) Check = 0; @@ -697,60 +697,60 @@ for (; model != NULL; model = model->BSIM4nextModel) vgmb = vgms - vbs; vdbd = vdbs - vds; - vbs_jct = (!here->BSIM4rbodyMod) ? vbs : vsbs; - vbd_jct = (!here->BSIM4rbodyMod) ? vbd : vdbd; + vbs_jct = (!here->BSIM4v7rbodyMod) ? vbs : vsbs; + vbd_jct = (!here->BSIM4v7rbodyMod) ? vbd : vdbd; /* Source/drain junction diode DC model begins */ - Nvtms = model->BSIM4vtm * model->BSIM4SjctEmissionCoeff; -/* if ((here->BSIM4Aseff <= 0.0) && (here->BSIM4Pseff <= 0.0)) + Nvtms = model->BSIM4v7vtm * model->BSIM4v7SjctEmissionCoeff; +/* if ((here->BSIM4v7Aseff <= 0.0) && (here->BSIM4v7Pseff <= 0.0)) { SourceSatCurrent = 1.0e-14; } v4.7 */ - if ((here->BSIM4Aseff <= 0.0) && (here->BSIM4Pseff <= 0.0)) + if ((here->BSIM4v7Aseff <= 0.0) && (here->BSIM4v7Pseff <= 0.0)) { SourceSatCurrent = 0.0; } else - { SourceSatCurrent = here->BSIM4Aseff * model->BSIM4SjctTempSatCurDensity - + here->BSIM4Pseff * model->BSIM4SjctSidewallTempSatCurDensity - + pParam->BSIM4weffCJ * here->BSIM4nf - * model->BSIM4SjctGateSidewallTempSatCurDensity; + { SourceSatCurrent = here->BSIM4v7Aseff * model->BSIM4v7SjctTempSatCurDensity + + here->BSIM4v7Pseff * model->BSIM4v7SjctSidewallTempSatCurDensity + + pParam->BSIM4v7weffCJ * here->BSIM4v7nf + * model->BSIM4v7SjctGateSidewallTempSatCurDensity; } if (SourceSatCurrent <= 0.0) - { here->BSIM4gbs = ckt->CKTgmin; - here->BSIM4cbs = here->BSIM4gbs * vbs_jct; + { here->BSIM4v7gbs = ckt->CKTgmin; + here->BSIM4v7cbs = here->BSIM4v7gbs * vbs_jct; } else - { switch(model->BSIM4dioMod) + { switch(model->BSIM4v7dioMod) { case 0: evbs = exp(vbs_jct / Nvtms); - T1 = model->BSIM4xjbvs * exp(-(model->BSIM4bvs + vbs_jct) / Nvtms); - /* WDLiu: Magic T1 in this form; different from BSIM4 beta. */ - here->BSIM4gbs = SourceSatCurrent * (evbs + T1) / Nvtms + ckt->CKTgmin; - here->BSIM4cbs = SourceSatCurrent * (evbs + here->BSIM4XExpBVS + T1 = model->BSIM4v7xjbvs * exp(-(model->BSIM4v7bvs + vbs_jct) / Nvtms); + /* WDLiu: Magic T1 in this form; different from BSIM4v7 beta. */ + here->BSIM4v7gbs = SourceSatCurrent * (evbs + T1) / Nvtms + ckt->CKTgmin; + here->BSIM4v7cbs = SourceSatCurrent * (evbs + here->BSIM4v7XExpBVS - T1 - 1.0) + ckt->CKTgmin * vbs_jct; break; case 1: T2 = vbs_jct / Nvtms; if (T2 < -EXP_THRESHOLD) - { here->BSIM4gbs = ckt->CKTgmin; - here->BSIM4cbs = SourceSatCurrent * (MIN_EXP - 1.0) + { here->BSIM4v7gbs = ckt->CKTgmin; + here->BSIM4v7cbs = SourceSatCurrent * (MIN_EXP - 1.0) + ckt->CKTgmin * vbs_jct; } - else if (vbs_jct <= here->BSIM4vjsmFwd) + else if (vbs_jct <= here->BSIM4v7vjsmFwd) { evbs = exp(T2); - here->BSIM4gbs = SourceSatCurrent * evbs / Nvtms + ckt->CKTgmin; - here->BSIM4cbs = SourceSatCurrent * (evbs - 1.0) + here->BSIM4v7gbs = SourceSatCurrent * evbs / Nvtms + ckt->CKTgmin; + here->BSIM4v7cbs = SourceSatCurrent * (evbs - 1.0) + ckt->CKTgmin * vbs_jct; } else - { T0 = here->BSIM4IVjsmFwd / Nvtms; - here->BSIM4gbs = T0 + ckt->CKTgmin; - here->BSIM4cbs = here->BSIM4IVjsmFwd - SourceSatCurrent + T0 - * (vbs_jct - here->BSIM4vjsmFwd) + ckt->CKTgmin * vbs_jct; + { T0 = here->BSIM4v7IVjsmFwd / Nvtms; + here->BSIM4v7gbs = T0 + ckt->CKTgmin; + here->BSIM4v7cbs = here->BSIM4v7IVjsmFwd - SourceSatCurrent + T0 + * (vbs_jct - here->BSIM4v7vjsmFwd) + ckt->CKTgmin * vbs_jct; } break; case 2: - if (vbs_jct < here->BSIM4vjsmRev) + if (vbs_jct < here->BSIM4v7vjsmRev) { T0 = vbs_jct / Nvtms; if (T0 < -EXP_THRESHOLD) { evbs = MIN_EXP; @@ -762,12 +762,12 @@ for (; model != NULL; model = model->BSIM4nextModel) } T1 = evbs - 1.0; - T2 = here->BSIM4IVjsmRev + here->BSIM4SslpRev - * (vbs_jct - here->BSIM4vjsmRev); - here->BSIM4gbs = devbs_dvb * T2 + T1 * here->BSIM4SslpRev + ckt->CKTgmin; - here->BSIM4cbs = T1 * T2 + ckt->CKTgmin * vbs_jct; + T2 = here->BSIM4v7IVjsmRev + here->BSIM4v7SslpRev + * (vbs_jct - here->BSIM4v7vjsmRev); + here->BSIM4v7gbs = devbs_dvb * T2 + T1 * here->BSIM4v7SslpRev + ckt->CKTgmin; + here->BSIM4v7cbs = T1 * T2 + ckt->CKTgmin * vbs_jct; } - else if (vbs_jct <= here->BSIM4vjsmFwd) + else if (vbs_jct <= here->BSIM4v7vjsmFwd) { T0 = vbs_jct / Nvtms; if (T0 < -EXP_THRESHOLD) { evbs = MIN_EXP; @@ -778,7 +778,7 @@ for (; model != NULL; model = model->BSIM4nextModel) devbs_dvb = evbs / Nvtms; } - T1 = (model->BSIM4bvs + vbs_jct) / Nvtms; + T1 = (model->BSIM4v7bvs + vbs_jct) / Nvtms; if (T1 > EXP_THRESHOLD) { T2 = MIN_EXP; T3 = 0.0; @@ -787,71 +787,71 @@ for (; model != NULL; model = model->BSIM4nextModel) { T2 = exp(-T1); T3 = -T2 /Nvtms; } - here->BSIM4gbs = SourceSatCurrent * (devbs_dvb - model->BSIM4xjbvs * T3) + here->BSIM4v7gbs = SourceSatCurrent * (devbs_dvb - model->BSIM4v7xjbvs * T3) + ckt->CKTgmin; - here->BSIM4cbs = SourceSatCurrent * (evbs + here->BSIM4XExpBVS - 1.0 - - model->BSIM4xjbvs * T2) + ckt->CKTgmin * vbs_jct; + here->BSIM4v7cbs = SourceSatCurrent * (evbs + here->BSIM4v7XExpBVS - 1.0 + - model->BSIM4v7xjbvs * T2) + ckt->CKTgmin * vbs_jct; } else - { here->BSIM4gbs = here->BSIM4SslpFwd + ckt->CKTgmin; - here->BSIM4cbs = here->BSIM4IVjsmFwd + here->BSIM4SslpFwd * (vbs_jct - - here->BSIM4vjsmFwd) + ckt->CKTgmin * vbs_jct; + { here->BSIM4v7gbs = here->BSIM4v7SslpFwd + ckt->CKTgmin; + here->BSIM4v7cbs = here->BSIM4v7IVjsmFwd + here->BSIM4v7SslpFwd * (vbs_jct + - here->BSIM4v7vjsmFwd) + ckt->CKTgmin * vbs_jct; } break; default: break; } } - Nvtmd = model->BSIM4vtm * model->BSIM4DjctEmissionCoeff; -/* if ((here->BSIM4Adeff <= 0.0) && (here->BSIM4Pdeff <= 0.0)) + Nvtmd = model->BSIM4v7vtm * model->BSIM4v7DjctEmissionCoeff; +/* if ((here->BSIM4v7Adeff <= 0.0) && (here->BSIM4v7Pdeff <= 0.0)) { DrainSatCurrent = 1.0e-14; } v4.7 */ - if ((here->BSIM4Adeff <= 0.0) && (here->BSIM4Pdeff <= 0.0)) + if ((here->BSIM4v7Adeff <= 0.0) && (here->BSIM4v7Pdeff <= 0.0)) { DrainSatCurrent = 0.0; } else - { DrainSatCurrent = here->BSIM4Adeff * model->BSIM4DjctTempSatCurDensity - + here->BSIM4Pdeff * model->BSIM4DjctSidewallTempSatCurDensity - + pParam->BSIM4weffCJ * here->BSIM4nf - * model->BSIM4DjctGateSidewallTempSatCurDensity; + { DrainSatCurrent = here->BSIM4v7Adeff * model->BSIM4v7DjctTempSatCurDensity + + here->BSIM4v7Pdeff * model->BSIM4v7DjctSidewallTempSatCurDensity + + pParam->BSIM4v7weffCJ * here->BSIM4v7nf + * model->BSIM4v7DjctGateSidewallTempSatCurDensity; } if (DrainSatCurrent <= 0.0) - { here->BSIM4gbd = ckt->CKTgmin; - here->BSIM4cbd = here->BSIM4gbd * vbd_jct; + { here->BSIM4v7gbd = ckt->CKTgmin; + here->BSIM4v7cbd = here->BSIM4v7gbd * vbd_jct; } else - { switch(model->BSIM4dioMod) + { switch(model->BSIM4v7dioMod) { case 0: evbd = exp(vbd_jct / Nvtmd); - T1 = model->BSIM4xjbvd * exp(-(model->BSIM4bvd + vbd_jct) / Nvtmd); - /* WDLiu: Magic T1 in this form; different from BSIM4 beta. */ - here->BSIM4gbd = DrainSatCurrent * (evbd + T1) / Nvtmd + ckt->CKTgmin; - here->BSIM4cbd = DrainSatCurrent * (evbd + here->BSIM4XExpBVD + T1 = model->BSIM4v7xjbvd * exp(-(model->BSIM4v7bvd + vbd_jct) / Nvtmd); + /* WDLiu: Magic T1 in this form; different from BSIM4v7 beta. */ + here->BSIM4v7gbd = DrainSatCurrent * (evbd + T1) / Nvtmd + ckt->CKTgmin; + here->BSIM4v7cbd = DrainSatCurrent * (evbd + here->BSIM4v7XExpBVD - T1 - 1.0) + ckt->CKTgmin * vbd_jct; break; case 1: T2 = vbd_jct / Nvtmd; if (T2 < -EXP_THRESHOLD) - { here->BSIM4gbd = ckt->CKTgmin; - here->BSIM4cbd = DrainSatCurrent * (MIN_EXP - 1.0) + { here->BSIM4v7gbd = ckt->CKTgmin; + here->BSIM4v7cbd = DrainSatCurrent * (MIN_EXP - 1.0) + ckt->CKTgmin * vbd_jct; } - else if (vbd_jct <= here->BSIM4vjdmFwd) + else if (vbd_jct <= here->BSIM4v7vjdmFwd) { evbd = exp(T2); - here->BSIM4gbd = DrainSatCurrent * evbd / Nvtmd + ckt->CKTgmin; - here->BSIM4cbd = DrainSatCurrent * (evbd - 1.0) + here->BSIM4v7gbd = DrainSatCurrent * evbd / Nvtmd + ckt->CKTgmin; + here->BSIM4v7cbd = DrainSatCurrent * (evbd - 1.0) + ckt->CKTgmin * vbd_jct; } else - { T0 = here->BSIM4IVjdmFwd / Nvtmd; - here->BSIM4gbd = T0 + ckt->CKTgmin; - here->BSIM4cbd = here->BSIM4IVjdmFwd - DrainSatCurrent + T0 - * (vbd_jct - here->BSIM4vjdmFwd) + ckt->CKTgmin * vbd_jct; + { T0 = here->BSIM4v7IVjdmFwd / Nvtmd; + here->BSIM4v7gbd = T0 + ckt->CKTgmin; + here->BSIM4v7cbd = here->BSIM4v7IVjdmFwd - DrainSatCurrent + T0 + * (vbd_jct - here->BSIM4v7vjdmFwd) + ckt->CKTgmin * vbd_jct; } break; case 2: - if (vbd_jct < here->BSIM4vjdmRev) + if (vbd_jct < here->BSIM4v7vjdmRev) { T0 = vbd_jct / Nvtmd; if (T0 < -EXP_THRESHOLD) { evbd = MIN_EXP; @@ -863,12 +863,12 @@ for (; model != NULL; model = model->BSIM4nextModel) } T1 = evbd - 1.0; - T2 = here->BSIM4IVjdmRev + here->BSIM4DslpRev - * (vbd_jct - here->BSIM4vjdmRev); - here->BSIM4gbd = devbd_dvb * T2 + T1 * here->BSIM4DslpRev + ckt->CKTgmin; - here->BSIM4cbd = T1 * T2 + ckt->CKTgmin * vbd_jct; + T2 = here->BSIM4v7IVjdmRev + here->BSIM4v7DslpRev + * (vbd_jct - here->BSIM4v7vjdmRev); + here->BSIM4v7gbd = devbd_dvb * T2 + T1 * here->BSIM4v7DslpRev + ckt->CKTgmin; + here->BSIM4v7cbd = T1 * T2 + ckt->CKTgmin * vbd_jct; } - else if (vbd_jct <= here->BSIM4vjdmFwd) + else if (vbd_jct <= here->BSIM4v7vjdmFwd) { T0 = vbd_jct / Nvtmd; if (T0 < -EXP_THRESHOLD) { evbd = MIN_EXP; @@ -879,7 +879,7 @@ for (; model != NULL; model = model->BSIM4nextModel) devbd_dvb = evbd / Nvtmd; } - T1 = (model->BSIM4bvd + vbd_jct) / Nvtmd; + T1 = (model->BSIM4v7bvd + vbd_jct) / Nvtmd; if (T1 > EXP_THRESHOLD) { T2 = MIN_EXP; T3 = 0.0; @@ -888,15 +888,15 @@ for (; model != NULL; model = model->BSIM4nextModel) { T2 = exp(-T1); T3 = -T2 /Nvtmd; } - here->BSIM4gbd = DrainSatCurrent * (devbd_dvb - model->BSIM4xjbvd * T3) + here->BSIM4v7gbd = DrainSatCurrent * (devbd_dvb - model->BSIM4v7xjbvd * T3) + ckt->CKTgmin; - here->BSIM4cbd = DrainSatCurrent * (evbd + here->BSIM4XExpBVD - 1.0 - - model->BSIM4xjbvd * T2) + ckt->CKTgmin * vbd_jct; + here->BSIM4v7cbd = DrainSatCurrent * (evbd + here->BSIM4v7XExpBVD - 1.0 + - model->BSIM4v7xjbvd * T2) + ckt->CKTgmin * vbd_jct; } else - { here->BSIM4gbd = here->BSIM4DslpFwd + ckt->CKTgmin; - here->BSIM4cbd = here->BSIM4IVjdmFwd + here->BSIM4DslpFwd * (vbd_jct - - here->BSIM4vjdmFwd) + ckt->CKTgmin * vbd_jct; + { here->BSIM4v7gbd = here->BSIM4v7DslpFwd + ckt->CKTgmin; + here->BSIM4v7cbd = here->BSIM4v7IVjdmFwd + here->BSIM4v7DslpFwd * (vbd_jct + - here->BSIM4v7vjdmFwd) + ckt->CKTgmin * vbd_jct; } break; default: break; @@ -904,108 +904,108 @@ for (; model != NULL; model = model->BSIM4nextModel) } /* trap-assisted tunneling and recombination current for reverse bias */ - Nvtmrssws = model->BSIM4vtm0 * model->BSIM4njtsswstemp; - Nvtmrsswgs = model->BSIM4vtm0 * model->BSIM4njtsswgstemp; - Nvtmrss = model->BSIM4vtm0 * model->BSIM4njtsstemp; - Nvtmrsswd = model->BSIM4vtm0 * model->BSIM4njtsswdtemp; - Nvtmrsswgd = model->BSIM4vtm0 * model->BSIM4njtsswgdtemp; - Nvtmrsd = model->BSIM4vtm0 * model->BSIM4njtsdtemp; + Nvtmrssws = model->BSIM4v7vtm0 * model->BSIM4v7njtsswstemp; + Nvtmrsswgs = model->BSIM4v7vtm0 * model->BSIM4v7njtsswgstemp; + Nvtmrss = model->BSIM4v7vtm0 * model->BSIM4v7njtsstemp; + Nvtmrsswd = model->BSIM4v7vtm0 * model->BSIM4v7njtsswdtemp; + Nvtmrsswgd = model->BSIM4v7vtm0 * model->BSIM4v7njtsswgdtemp; + Nvtmrsd = model->BSIM4v7vtm0 * model->BSIM4v7njtsdtemp; - if ((model->BSIM4vtss - vbs_jct) < (model->BSIM4vtss * 1e-3)) + if ((model->BSIM4v7vtss - vbs_jct) < (model->BSIM4v7vtss * 1e-3)) { T9 = 1.0e3; T0 = - vbs_jct / Nvtmrss * T9; DEXP(T0, T1, T10); dT1_dVb = T10 / Nvtmrss * T9; } else { - T9 = 1.0 / (model->BSIM4vtss - vbs_jct); - T0 = -vbs_jct / Nvtmrss * model->BSIM4vtss * T9; - dT0_dVb = model->BSIM4vtss / Nvtmrss * (T9 + vbs_jct * T9 * T9) ; + T9 = 1.0 / (model->BSIM4v7vtss - vbs_jct); + T0 = -vbs_jct / Nvtmrss * model->BSIM4v7vtss * T9; + dT0_dVb = model->BSIM4v7vtss / Nvtmrss * (T9 + vbs_jct * T9 * T9) ; DEXP(T0, T1, T10); dT1_dVb = T10 * dT0_dVb; } - if ((model->BSIM4vtsd - vbd_jct) < (model->BSIM4vtsd * 1e-3) ) + if ((model->BSIM4v7vtsd - vbd_jct) < (model->BSIM4v7vtsd * 1e-3) ) { T9 = 1.0e3; T0 = -vbd_jct / Nvtmrsd * T9; DEXP(T0, T2, T10); dT2_dVb = T10 / Nvtmrsd * T9; } else { - T9 = 1.0 / (model->BSIM4vtsd - vbd_jct); - T0 = -vbd_jct / Nvtmrsd * model->BSIM4vtsd * T9; - dT0_dVb = model->BSIM4vtsd / Nvtmrsd * (T9 + vbd_jct * T9 * T9) ; + T9 = 1.0 / (model->BSIM4v7vtsd - vbd_jct); + T0 = -vbd_jct / Nvtmrsd * model->BSIM4v7vtsd * T9; + dT0_dVb = model->BSIM4v7vtsd / Nvtmrsd * (T9 + vbd_jct * T9 * T9) ; DEXP(T0, T2, T10); dT2_dVb = T10 * dT0_dVb; } - if ((model->BSIM4vtssws - vbs_jct) < (model->BSIM4vtssws * 1e-3) ) + if ((model->BSIM4v7vtssws - vbs_jct) < (model->BSIM4v7vtssws * 1e-3) ) { T9 = 1.0e3; T0 = -vbs_jct / Nvtmrssws * T9; DEXP(T0, T3, T10); dT3_dVb = T10 / Nvtmrssws * T9; } else { - T9 = 1.0 / (model->BSIM4vtssws - vbs_jct); - T0 = -vbs_jct / Nvtmrssws * model->BSIM4vtssws * T9; - dT0_dVb = model->BSIM4vtssws / Nvtmrssws * (T9 + vbs_jct * T9 * T9) ; + T9 = 1.0 / (model->BSIM4v7vtssws - vbs_jct); + T0 = -vbs_jct / Nvtmrssws * model->BSIM4v7vtssws * T9; + dT0_dVb = model->BSIM4v7vtssws / Nvtmrssws * (T9 + vbs_jct * T9 * T9) ; DEXP(T0, T3, T10); dT3_dVb = T10 * dT0_dVb; } - if ((model->BSIM4vtsswd - vbd_jct) < (model->BSIM4vtsswd * 1e-3) ) + if ((model->BSIM4v7vtsswd - vbd_jct) < (model->BSIM4v7vtsswd * 1e-3) ) { T9 = 1.0e3; T0 = -vbd_jct / Nvtmrsswd * T9; DEXP(T0, T4, T10); dT4_dVb = T10 / Nvtmrsswd * T9; } else { - T9 = 1.0 / (model->BSIM4vtsswd - vbd_jct); - T0 = -vbd_jct / Nvtmrsswd * model->BSIM4vtsswd * T9; - dT0_dVb = model->BSIM4vtsswd / Nvtmrsswd * (T9 + vbd_jct * T9 * T9) ; + T9 = 1.0 / (model->BSIM4v7vtsswd - vbd_jct); + T0 = -vbd_jct / Nvtmrsswd * model->BSIM4v7vtsswd * T9; + dT0_dVb = model->BSIM4v7vtsswd / Nvtmrsswd * (T9 + vbd_jct * T9 * T9) ; DEXP(T0, T4, T10); dT4_dVb = T10 * dT0_dVb; } - if ((model->BSIM4vtsswgs - vbs_jct) < (model->BSIM4vtsswgs * 1e-3) ) + if ((model->BSIM4v7vtsswgs - vbs_jct) < (model->BSIM4v7vtsswgs * 1e-3) ) { T9 = 1.0e3; T0 = -vbs_jct / Nvtmrsswgs * T9; DEXP(T0, T5, T10); dT5_dVb = T10 / Nvtmrsswgs * T9; } else { - T9 = 1.0 / (model->BSIM4vtsswgs - vbs_jct); - T0 = -vbs_jct / Nvtmrsswgs * model->BSIM4vtsswgs * T9; - dT0_dVb = model->BSIM4vtsswgs / Nvtmrsswgs * (T9 + vbs_jct * T9 * T9) ; + T9 = 1.0 / (model->BSIM4v7vtsswgs - vbs_jct); + T0 = -vbs_jct / Nvtmrsswgs * model->BSIM4v7vtsswgs * T9; + dT0_dVb = model->BSIM4v7vtsswgs / Nvtmrsswgs * (T9 + vbs_jct * T9 * T9) ; DEXP(T0, T5, T10); dT5_dVb = T10 * dT0_dVb; } - if ((model->BSIM4vtsswgd - vbd_jct) < (model->BSIM4vtsswgd * 1e-3) ) + if ((model->BSIM4v7vtsswgd - vbd_jct) < (model->BSIM4v7vtsswgd * 1e-3) ) { T9 = 1.0e3; T0 = -vbd_jct / Nvtmrsswgd * T9; DEXP(T0, T6, T10); dT6_dVb = T10 / Nvtmrsswgd * T9; } else { - T9 = 1.0 / (model->BSIM4vtsswgd - vbd_jct); - T0 = -vbd_jct / Nvtmrsswgd * model->BSIM4vtsswgd * T9; - dT0_dVb = model->BSIM4vtsswgd / Nvtmrsswgd * (T9 + vbd_jct * T9 * T9) ; + T9 = 1.0 / (model->BSIM4v7vtsswgd - vbd_jct); + T0 = -vbd_jct / Nvtmrsswgd * model->BSIM4v7vtsswgd * T9; + dT0_dVb = model->BSIM4v7vtsswgd / Nvtmrsswgd * (T9 + vbd_jct * T9 * T9) ; DEXP(T0, T6, T10); dT6_dVb = T10 * dT0_dVb; } - here->BSIM4gbs += here->BSIM4SjctTempRevSatCur * dT1_dVb - + here->BSIM4SswTempRevSatCur * dT3_dVb - + here->BSIM4SswgTempRevSatCur * dT5_dVb; - here->BSIM4cbs -= here->BSIM4SjctTempRevSatCur * (T1 - 1.0) - + here->BSIM4SswTempRevSatCur * (T3 - 1.0) - + here->BSIM4SswgTempRevSatCur * (T5 - 1.0); - here->BSIM4gbd += here->BSIM4DjctTempRevSatCur * dT2_dVb - + here->BSIM4DswTempRevSatCur * dT4_dVb - + here->BSIM4DswgTempRevSatCur * dT6_dVb; - here->BSIM4cbd -= here->BSIM4DjctTempRevSatCur * (T2 - 1.0) - + here->BSIM4DswTempRevSatCur * (T4 - 1.0) - + here->BSIM4DswgTempRevSatCur * (T6 - 1.0); + here->BSIM4v7gbs += here->BSIM4v7SjctTempRevSatCur * dT1_dVb + + here->BSIM4v7SswTempRevSatCur * dT3_dVb + + here->BSIM4v7SswgTempRevSatCur * dT5_dVb; + here->BSIM4v7cbs -= here->BSIM4v7SjctTempRevSatCur * (T1 - 1.0) + + here->BSIM4v7SswTempRevSatCur * (T3 - 1.0) + + here->BSIM4v7SswgTempRevSatCur * (T5 - 1.0); + here->BSIM4v7gbd += here->BSIM4v7DjctTempRevSatCur * dT2_dVb + + here->BSIM4v7DswTempRevSatCur * dT4_dVb + + here->BSIM4v7DswgTempRevSatCur * dT6_dVb; + here->BSIM4v7cbd -= here->BSIM4v7DjctTempRevSatCur * (T2 - 1.0) + + here->BSIM4v7DswTempRevSatCur * (T4 - 1.0) + + here->BSIM4v7DswgTempRevSatCur * (T6 - 1.0); /* End of diode DC model */ if (vds >= 0.0) - { here->BSIM4mode = 1; + { here->BSIM4v7mode = 1; Vds = vds; Vgs = vgs; Vbs = vbs; @@ -1013,7 +1013,7 @@ for (; model != NULL; model = model->BSIM4nextModel) } else - { here->BSIM4mode = -1; + { here->BSIM4v7mode = -1; Vds = -vds; Vgs = vgd; Vbs = vbd; @@ -1022,82 +1022,82 @@ for (; model != NULL; model = model->BSIM4nextModel) /* dunga */ - if(model->BSIM4mtrlMod) + if(model->BSIM4v7mtrlMod) { epsrox = 3.9; - toxe = model->BSIM4eot; - epssub = EPS0 * model->BSIM4epsrsub; + toxe = model->BSIM4v7eot; + epssub = EPS0 * model->BSIM4v7epsrsub; } else { - epsrox = model->BSIM4epsrox; - toxe = model->BSIM4toxe; + epsrox = model->BSIM4v7epsrox; + toxe = model->BSIM4v7toxe; epssub = EPSSI; } - T0 = Vbs - here->BSIM4vbsc - 0.001; - T1 = sqrt(T0 * T0 - 0.004 * here->BSIM4vbsc); + T0 = Vbs - here->BSIM4v7vbsc - 0.001; + T1 = sqrt(T0 * T0 - 0.004 * here->BSIM4v7vbsc); if (T0 >= 0.0) - { Vbseff = here->BSIM4vbsc + 0.5 * (T0 + T1); + { Vbseff = here->BSIM4v7vbsc + 0.5 * (T0 + T1); dVbseff_dVb = 0.5 * (1.0 + T0 / T1); } else { T2 = -0.002 / (T1 - T0); - Vbseff = here->BSIM4vbsc * (1.0 + T2); - dVbseff_dVb = T2 * here->BSIM4vbsc / T1; + Vbseff = here->BSIM4v7vbsc * (1.0 + T2); + dVbseff_dVb = T2 * here->BSIM4v7vbsc / T1; } /* JX: Correction to forward body bias */ - T9 = 0.95 * pParam->BSIM4phi; + T9 = 0.95 * pParam->BSIM4v7phi; T0 = T9 - Vbseff - 0.001; T1 = sqrt(T0 * T0 + 0.004 * T9); Vbseff = T9 - 0.5 * (T0 + T1); dVbseff_dVb *= 0.5 * (1.0 + T0 / T1); - Phis = pParam->BSIM4phi - Vbseff; + Phis = pParam->BSIM4v7phi - Vbseff; dPhis_dVb = -1.0; sqrtPhis = sqrt(Phis); dsqrtPhis_dVb = -0.5 / sqrtPhis; - Xdep = pParam->BSIM4Xdep0 * sqrtPhis / pParam->BSIM4sqrtPhi; - dXdep_dVb = (pParam->BSIM4Xdep0 / pParam->BSIM4sqrtPhi) + Xdep = pParam->BSIM4v7Xdep0 * sqrtPhis / pParam->BSIM4v7sqrtPhi; + dXdep_dVb = (pParam->BSIM4v7Xdep0 / pParam->BSIM4v7sqrtPhi) * dsqrtPhis_dVb; - Leff = pParam->BSIM4leff; - Vtm = model->BSIM4vtm; - Vtm0 = model->BSIM4vtm0; + Leff = pParam->BSIM4v7leff; + Vtm = model->BSIM4v7vtm; + Vtm0 = model->BSIM4v7vtm0; /* Vth Calculation */ T3 = sqrt(Xdep); - V0 = pParam->BSIM4vbi - pParam->BSIM4phi; + V0 = pParam->BSIM4v7vbi - pParam->BSIM4v7phi; - T0 = pParam->BSIM4dvt2 * Vbseff; + T0 = pParam->BSIM4v7dvt2 * Vbseff; if (T0 >= - 0.5) { T1 = 1.0 + T0; - T2 = pParam->BSIM4dvt2; + T2 = pParam->BSIM4v7dvt2; } else { T4 = 1.0 / (3.0 + 8.0 * T0); T1 = (1.0 + 3.0 * T0) * T4; - T2 = pParam->BSIM4dvt2 * T4 * T4; + T2 = pParam->BSIM4v7dvt2 * T4 * T4; } - lt1 = model->BSIM4factor1 * T3 * T1; - dlt1_dVb = model->BSIM4factor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + lt1 = model->BSIM4v7factor1 * T3 * T1; + dlt1_dVb = model->BSIM4v7factor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); - T0 = pParam->BSIM4dvt2w * Vbseff; + T0 = pParam->BSIM4v7dvt2w * Vbseff; if (T0 >= - 0.5) { T1 = 1.0 + T0; - T2 = pParam->BSIM4dvt2w; + T2 = pParam->BSIM4v7dvt2w; } else { T4 = 1.0 / (3.0 + 8.0 * T0); T1 = (1.0 + 3.0 * T0) * T4; - T2 = pParam->BSIM4dvt2w * T4 * T4; + T2 = pParam->BSIM4v7dvt2w * T4 * T4; } - ltw = model->BSIM4factor1 * T3 * T1; - dltw_dVb = model->BSIM4factor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + ltw = model->BSIM4v7factor1 * T3 * T1; + dltw_dVb = model->BSIM4v7factor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); - T0 = pParam->BSIM4dvt1 * Leff / lt1; + T0 = pParam->BSIM4v7dvt1 * Leff / lt1; if (T0 < EXP_THRESHOLD) { T1 = exp(T0); T2 = T1 - 1.0; @@ -1111,11 +1111,11 @@ for (; model != NULL; model = model->BSIM4nextModel) { Theta0 = 1.0 / (MAX_EXP - 2.0); /* 3.0 * MIN_EXP omitted */ dTheta0_dVb = 0.0; } - here->BSIM4thetavth = pParam->BSIM4dvt0 * Theta0; - Delt_vth = here->BSIM4thetavth * V0; - dDelt_vth_dVb = pParam->BSIM4dvt0 * dTheta0_dVb * V0; + here->BSIM4v7thetavth = pParam->BSIM4v7dvt0 * Theta0; + Delt_vth = here->BSIM4v7thetavth * V0; + dDelt_vth_dVb = pParam->BSIM4v7dvt0 * dTheta0_dVb * V0; - T0 = pParam->BSIM4dvt1w * pParam->BSIM4weff * Leff / ltw; + T0 = pParam->BSIM4v7dvt1w * pParam->BSIM4v7weff * Leff / ltw; if (T0 < EXP_THRESHOLD) { T1 = exp(T0); T2 = T1 - 1.0; @@ -1129,19 +1129,19 @@ for (; model != NULL; model = model->BSIM4nextModel) { T5 = 1.0 / (MAX_EXP - 2.0); /* 3.0 * MIN_EXP omitted */ dT5_dVb = 0.0; } - T0 = pParam->BSIM4dvt0w * T5; + T0 = pParam->BSIM4v7dvt0w * T5; T2 = T0 * V0; - dT2_dVb = pParam->BSIM4dvt0w * dT5_dVb * V0; + dT2_dVb = pParam->BSIM4v7dvt0w * dT5_dVb * V0; - TempRatio = ckt->CKTtemp / model->BSIM4tnom - 1.0; - T0 = sqrt(1.0 + pParam->BSIM4lpe0 / Leff); - T1 = pParam->BSIM4k1ox * (T0 - 1.0) * pParam->BSIM4sqrtPhi - + (pParam->BSIM4kt1 + pParam->BSIM4kt1l / Leff - + pParam->BSIM4kt2 * Vbseff) * TempRatio; - Vth_NarrowW = toxe * pParam->BSIM4phi - / (pParam->BSIM4weff + pParam->BSIM4w0); + TempRatio = ckt->CKTtemp / model->BSIM4v7tnom - 1.0; + T0 = sqrt(1.0 + pParam->BSIM4v7lpe0 / Leff); + T1 = pParam->BSIM4v7k1ox * (T0 - 1.0) * pParam->BSIM4v7sqrtPhi + + (pParam->BSIM4v7kt1 + pParam->BSIM4v7kt1l / Leff + + pParam->BSIM4v7kt2 * Vbseff) * TempRatio; + Vth_NarrowW = toxe * pParam->BSIM4v7phi + / (pParam->BSIM4v7weff + pParam->BSIM4v7w0); - T3 = here->BSIM4eta0 + pParam->BSIM4etab * Vbseff; + T3 = here->BSIM4v7eta0 + pParam->BSIM4v7etab * Vbseff; if (T3 < 1.0e-4) { T9 = 1.0 / (3.0 - 2.0e4 * T3); T3 = (2.0e-4 - T3) * T9; @@ -1150,70 +1150,70 @@ for (; model != NULL; model = model->BSIM4nextModel) else { T4 = 1.0; } - dDIBL_Sft_dVd = T3 * pParam->BSIM4theta0vb0; + dDIBL_Sft_dVd = T3 * pParam->BSIM4v7theta0vb0; DIBL_Sft = dDIBL_Sft_dVd * Vds; - Lpe_Vb = sqrt(1.0 + pParam->BSIM4lpeb / Leff); + Lpe_Vb = sqrt(1.0 + pParam->BSIM4v7lpeb / Leff); - Vth = model->BSIM4type * here->BSIM4vth0 + (pParam->BSIM4k1ox * sqrtPhis - - pParam->BSIM4k1 * pParam->BSIM4sqrtPhi) * Lpe_Vb - - here->BSIM4k2ox * Vbseff - Delt_vth - T2 + (pParam->BSIM4k3 - + pParam->BSIM4k3b * Vbseff) * Vth_NarrowW + T1 - DIBL_Sft; + Vth = model->BSIM4v7type * here->BSIM4v7vth0 + (pParam->BSIM4v7k1ox * sqrtPhis + - pParam->BSIM4v7k1 * pParam->BSIM4v7sqrtPhi) * Lpe_Vb + - here->BSIM4v7k2ox * Vbseff - Delt_vth - T2 + (pParam->BSIM4v7k3 + + pParam->BSIM4v7k3b * Vbseff) * Vth_NarrowW + T1 - DIBL_Sft; - dVth_dVb = Lpe_Vb * pParam->BSIM4k1ox * dsqrtPhis_dVb - here->BSIM4k2ox - - dDelt_vth_dVb - dT2_dVb + pParam->BSIM4k3b * Vth_NarrowW - - pParam->BSIM4etab * Vds * pParam->BSIM4theta0vb0 * T4 - + pParam->BSIM4kt2 * TempRatio; + dVth_dVb = Lpe_Vb * pParam->BSIM4v7k1ox * dsqrtPhis_dVb - here->BSIM4v7k2ox + - dDelt_vth_dVb - dT2_dVb + pParam->BSIM4v7k3b * Vth_NarrowW + - pParam->BSIM4v7etab * Vds * pParam->BSIM4v7theta0vb0 * T4 + + pParam->BSIM4v7kt2 * TempRatio; dVth_dVd = -dDIBL_Sft_dVd; /* Calculate n */ tmp1 = epssub / Xdep; - here->BSIM4nstar = model->BSIM4vtm / Charge_q * (model->BSIM4coxe - + tmp1 + pParam->BSIM4cit); - tmp2 = pParam->BSIM4nfactor * tmp1; - tmp3 = pParam->BSIM4cdsc + pParam->BSIM4cdscb * Vbseff - + pParam->BSIM4cdscd * Vds; - tmp4 = (tmp2 + tmp3 * Theta0 + pParam->BSIM4cit) / model->BSIM4coxe; + here->BSIM4v7nstar = model->BSIM4v7vtm / Charge_q * (model->BSIM4v7coxe + + tmp1 + pParam->BSIM4v7cit); + tmp2 = pParam->BSIM4v7nfactor * tmp1; + tmp3 = pParam->BSIM4v7cdsc + pParam->BSIM4v7cdscb * Vbseff + + pParam->BSIM4v7cdscd * Vds; + tmp4 = (tmp2 + tmp3 * Theta0 + pParam->BSIM4v7cit) / model->BSIM4v7coxe; if (tmp4 >= -0.5) { n = 1.0 + tmp4; dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb - + pParam->BSIM4cdscb * Theta0) / model->BSIM4coxe; - dn_dVd = pParam->BSIM4cdscd * Theta0 / model->BSIM4coxe; + + pParam->BSIM4v7cdscb * Theta0) / model->BSIM4v7coxe; + dn_dVd = pParam->BSIM4v7cdscd * Theta0 / model->BSIM4v7coxe; } else { T0 = 1.0 / (3.0 + 8.0 * tmp4); n = (1.0 + 3.0 * tmp4) * T0; T0 *= T0; dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb - + pParam->BSIM4cdscb * Theta0) / model->BSIM4coxe * T0; - dn_dVd = pParam->BSIM4cdscd * Theta0 / model->BSIM4coxe * T0; + + pParam->BSIM4v7cdscb * Theta0) / model->BSIM4v7coxe * T0; + dn_dVd = pParam->BSIM4v7cdscd * Theta0 / model->BSIM4v7coxe * T0; } /* Vth correction for Pocket implant */ - if (pParam->BSIM4dvtp0 > 0.0) - { T0 = -pParam->BSIM4dvtp1 * Vds; + if (pParam->BSIM4v7dvtp0 > 0.0) + { T0 = -pParam->BSIM4v7dvtp1 * Vds; if (T0 < -EXP_THRESHOLD) { T2 = MIN_EXP; dT2_dVd = 0.0; } else { T2 = exp(T0); - dT2_dVd = -pParam->BSIM4dvtp1 * T2; + dT2_dVd = -pParam->BSIM4v7dvtp1 * T2; } - T3 = Leff + pParam->BSIM4dvtp0 * (1.0 + T2); - dT3_dVd = pParam->BSIM4dvtp0 * dT2_dVd; - if (model->BSIM4tempMod < 2) + T3 = Leff + pParam->BSIM4v7dvtp0 * (1.0 + T2); + dT3_dVd = pParam->BSIM4v7dvtp0 * dT2_dVd; + if (model->BSIM4v7tempMod < 2) { T4 = Vtm * log(Leff / T3); dT4_dVd = -Vtm * dT3_dVd / T3; } else { - T4 = model->BSIM4vtm0 * log(Leff / T3); - dT4_dVd = -model->BSIM4vtm0 * dT3_dVd / T3; + T4 = model->BSIM4v7vtm0 * log(Leff / T3); + dT4_dVd = -model->BSIM4v7vtm0 * dT3_dVd / T3; } dDITS_Sft_dVd = dn_dVd * T4 + n * dT4_dVd; dDITS_Sft_dVb = T4 * dn_dVb; @@ -1224,63 +1224,63 @@ for (; model != NULL; model = model->BSIM4nextModel) } /* v4.7 DITS_SFT2 */ - if ((pParam->BSIM4dvtp4 == 0.0) || (pParam->BSIM4dvtp2factor == 0.0)) { + if ((pParam->BSIM4v7dvtp4 == 0.0) || (pParam->BSIM4v7dvtp2factor == 0.0)) { T0 = 0.0; DITS_Sft2 = 0.0; } else { - //T0 = exp(2.0 * pParam->BSIM4dvtp4 * Vds); /* beta code */ - T1 = 2.0 * pParam->BSIM4dvtp4 * Vds; + //T0 = exp(2.0 * pParam->BSIM4v7dvtp4 * Vds); /* beta code */ + T1 = 2.0 * pParam->BSIM4v7dvtp4 * Vds; DEXP(T1, T0, T10); - DITS_Sft2 = pParam->BSIM4dvtp2factor * (T0-1) / (T0+1); - //dDITS_Sft2_dVd = pParam->BSIM4dvtp2factor * pParam->BSIM4dvtp4 * 4.0 * T0 / ((T0+1) * (T0+1)); /* beta code */ - dDITS_Sft2_dVd = pParam->BSIM4dvtp2factor * pParam->BSIM4dvtp4 * 4.0 * T10 / ((T0+1) * (T0+1)); + DITS_Sft2 = pParam->BSIM4v7dvtp2factor * (T0-1) / (T0+1); + //dDITS_Sft2_dVd = pParam->BSIM4v7dvtp2factor * pParam->BSIM4v7dvtp4 * 4.0 * T0 / ((T0+1) * (T0+1)); /* beta code */ + dDITS_Sft2_dVd = pParam->BSIM4v7dvtp2factor * pParam->BSIM4v7dvtp4 * 4.0 * T10 / ((T0+1) * (T0+1)); Vth -= DITS_Sft2; dVth_dVd -= dDITS_Sft2_dVd; } - here->BSIM4von = Vth; + here->BSIM4v7von = Vth; /* Poly Gate Si Depletion Effect */ - T0 = here->BSIM4vfb + pParam->BSIM4phi; - if(model->BSIM4mtrlMod == 0) + T0 = here->BSIM4v7vfb + pParam->BSIM4v7phi; + if(model->BSIM4v7mtrlMod == 0) T1 = EPSSI; else - T1 = model->BSIM4epsrgate * EPS0; + T1 = model->BSIM4v7epsrgate * EPS0; - BSIM4polyDepletion(T0, pParam->BSIM4ngate, T1, model->BSIM4coxe, vgs, &vgs_eff, &dvgs_eff_dvg); + BSIM4v7polyDepletion(T0, pParam->BSIM4v7ngate, T1, model->BSIM4v7coxe, vgs, &vgs_eff, &dvgs_eff_dvg); - BSIM4polyDepletion(T0, pParam->BSIM4ngate, T1, model->BSIM4coxe, vgd, &vgd_eff, &dvgd_eff_dvg); + BSIM4v7polyDepletion(T0, pParam->BSIM4v7ngate, T1, model->BSIM4v7coxe, vgd, &vgd_eff, &dvgd_eff_dvg); - if(here->BSIM4mode>0) { + if(here->BSIM4v7mode>0) { Vgs_eff = vgs_eff; dVgs_eff_dVg = dvgs_eff_dvg; } else { Vgs_eff = vgd_eff; dVgs_eff_dVg = dvgd_eff_dvg; } - here->BSIM4vgs_eff = vgs_eff; - here->BSIM4vgd_eff = vgd_eff; - here->BSIM4dvgs_eff_dvg = dvgs_eff_dvg; - here->BSIM4dvgd_eff_dvg = dvgd_eff_dvg; + here->BSIM4v7vgs_eff = vgs_eff; + here->BSIM4v7vgd_eff = vgd_eff; + here->BSIM4v7dvgs_eff_dvg = dvgs_eff_dvg; + here->BSIM4v7dvgd_eff_dvg = dvgd_eff_dvg; Vgst = Vgs_eff - Vth; /* Calculate Vgsteff */ T0 = n * Vtm; - T1 = pParam->BSIM4mstar * Vgst; + T1 = pParam->BSIM4v7mstar * Vgst; T2 = T1 / T0; if (T2 > EXP_THRESHOLD) { T10 = T1; - dT10_dVg = pParam->BSIM4mstar * dVgs_eff_dVg; - dT10_dVd = -dVth_dVd * pParam->BSIM4mstar; - dT10_dVb = -dVth_dVb * pParam->BSIM4mstar; + dT10_dVg = pParam->BSIM4v7mstar * dVgs_eff_dVg; + dT10_dVd = -dVth_dVd * pParam->BSIM4v7mstar; + dT10_dVb = -dVth_dVb * pParam->BSIM4v7mstar; } else if (T2 < -EXP_THRESHOLD) { T10 = Vtm * log(1.0 + MIN_EXP); @@ -1293,51 +1293,51 @@ for (; model != NULL; model = model->BSIM4nextModel) { ExpVgst = exp(T2); T3 = Vtm * log(1.0 + ExpVgst); T10 = n * T3; - dT10_dVg = pParam->BSIM4mstar * ExpVgst / (1.0 + ExpVgst); + dT10_dVg = pParam->BSIM4v7mstar * ExpVgst / (1.0 + ExpVgst); dT10_dVb = T3 * dn_dVb - dT10_dVg * (dVth_dVb + Vgst * dn_dVb / n); dT10_dVd = T3 * dn_dVd - dT10_dVg * (dVth_dVd + Vgst * dn_dVd / n); dT10_dVg *= dVgs_eff_dVg; } - T1 = pParam->BSIM4voffcbn - (1.0 - pParam->BSIM4mstar) * Vgst; + T1 = pParam->BSIM4v7voffcbn - (1.0 - pParam->BSIM4v7mstar) * Vgst; T2 = T1 / T0; if (T2 < -EXP_THRESHOLD) - { T3 = model->BSIM4coxe * MIN_EXP / pParam->BSIM4cdep0; - T9 = pParam->BSIM4mstar + T3 * n; + { T3 = model->BSIM4v7coxe * MIN_EXP / pParam->BSIM4v7cdep0; + T9 = pParam->BSIM4v7mstar + T3 * n; dT9_dVg = 0.0; dT9_dVd = dn_dVd * T3; dT9_dVb = dn_dVb * T3; } else if (T2 > EXP_THRESHOLD) - { T3 = model->BSIM4coxe * MAX_EXP / pParam->BSIM4cdep0; - T9 = pParam->BSIM4mstar + T3 * n; + { T3 = model->BSIM4v7coxe * MAX_EXP / pParam->BSIM4v7cdep0; + T9 = pParam->BSIM4v7mstar + T3 * n; dT9_dVg = 0.0; dT9_dVd = dn_dVd * T3; dT9_dVb = dn_dVb * T3; } else { ExpVgst = exp(T2); - T3 = model->BSIM4coxe / pParam->BSIM4cdep0; + T3 = model->BSIM4v7coxe / pParam->BSIM4v7cdep0; T4 = T3 * ExpVgst; T5 = T1 * T4 / T0; - T9 = pParam->BSIM4mstar + n * T4; - dT9_dVg = T3 * (pParam->BSIM4mstar - 1.0) * ExpVgst / Vtm; + T9 = pParam->BSIM4v7mstar + n * T4; + dT9_dVg = T3 * (pParam->BSIM4v7mstar - 1.0) * ExpVgst / Vtm; dT9_dVb = T4 * dn_dVb - dT9_dVg * dVth_dVb - T5 * dn_dVb; dT9_dVd = T4 * dn_dVd - dT9_dVg * dVth_dVd - T5 * dn_dVd; dT9_dVg *= dVgs_eff_dVg; } - here->BSIM4Vgsteff = Vgsteff = T10 / T9; + here->BSIM4v7Vgsteff = Vgsteff = T10 / T9; T11 = T9 * T9; dVgsteff_dVg = (T9 * dT10_dVg - T10 * dT9_dVg) / T11; dVgsteff_dVd = (T9 * dT10_dVd - T10 * dT9_dVd) / T11; dVgsteff_dVb = (T9 * dT10_dVb - T10 * dT9_dVb) / T11; /* Calculate Effective Channel Geometry */ - T9 = sqrtPhis - pParam->BSIM4sqrtPhi; - Weff = pParam->BSIM4weff - 2.0 * (pParam->BSIM4dwg * Vgsteff - + pParam->BSIM4dwb * T9); - dWeff_dVg = -2.0 * pParam->BSIM4dwg; - dWeff_dVb = -2.0 * pParam->BSIM4dwb * dsqrtPhis_dVb; + T9 = sqrtPhis - pParam->BSIM4v7sqrtPhi; + Weff = pParam->BSIM4v7weff - 2.0 * (pParam->BSIM4v7dwg * Vgsteff + + pParam->BSIM4v7dwb * T9); + dWeff_dVg = -2.0 * pParam->BSIM4v7dwg; + dWeff_dVb = -2.0 * pParam->BSIM4v7dwb * dsqrtPhis_dVb; if (Weff < 2.0e-8) /* to avoid the discontinuity problem due to Weff*/ { T0 = 1.0 / (6.0e-8 - 2.0 * Weff); @@ -1347,13 +1347,13 @@ for (; model != NULL; model = model->BSIM4nextModel) dWeff_dVb *= T0; } - if (model->BSIM4rdsMod == 1) + if (model->BSIM4v7rdsMod == 1) Rds = dRds_dVg = dRds_dVb = 0.0; else - { T0 = 1.0 + pParam->BSIM4prwg * Vgsteff; - dT0_dVg = -pParam->BSIM4prwg / T0 / T0; - T1 = pParam->BSIM4prwb * T9; - dT1_dVb = pParam->BSIM4prwb * dsqrtPhis_dVb; + { T0 = 1.0 + pParam->BSIM4v7prwg * Vgsteff; + dT0_dVg = -pParam->BSIM4v7prwg / T0 / T0; + T1 = pParam->BSIM4v7prwb * T9; + dT1_dVb = pParam->BSIM4v7prwb * dsqrtPhis_dVb; T2 = 1.0 / T0 + T1; T3 = T2 + sqrt(T2 * T2 + 0.01); /* 0.01 = 4.0 * 0.05 * 0.05 */ @@ -1361,28 +1361,28 @@ for (; model != NULL; model = model->BSIM4nextModel) dT3_dVb = dT3_dVg * dT1_dVb; dT3_dVg *= dT0_dVg; - T4 = pParam->BSIM4rds0 * 0.5; - Rds = pParam->BSIM4rdswmin + T3 * T4; + T4 = pParam->BSIM4v7rds0 * 0.5; + Rds = pParam->BSIM4v7rdswmin + T3 * T4; dRds_dVg = T4 * dT3_dVg; dRds_dVb = T4 * dT3_dVb; if (Rds > 0.0) - here->BSIM4grdsw = 1.0 / Rds* here->BSIM4nf; /*4.6.2*/ + here->BSIM4v7grdsw = 1.0 / Rds* here->BSIM4v7nf; /*4.6.2*/ else - here->BSIM4grdsw = 0.0; + here->BSIM4v7grdsw = 0.0; } /* Calculate Abulk */ - T9 = 0.5 * pParam->BSIM4k1ox * Lpe_Vb / sqrtPhis; - T1 = T9 + here->BSIM4k2ox - pParam->BSIM4k3b * Vth_NarrowW; + T9 = 0.5 * pParam->BSIM4v7k1ox * Lpe_Vb / sqrtPhis; + T1 = T9 + here->BSIM4v7k2ox - pParam->BSIM4v7k3b * Vth_NarrowW; dT1_dVb = -T9 / sqrtPhis * dsqrtPhis_dVb; - T9 = sqrt(pParam->BSIM4xj * Xdep); + T9 = sqrt(pParam->BSIM4v7xj * Xdep); tmp1 = Leff + 2.0 * T9; T5 = Leff / tmp1; - tmp2 = pParam->BSIM4a0 * T5; - tmp3 = pParam->BSIM4weff + pParam->BSIM4b1; - tmp4 = pParam->BSIM4b0 / tmp3; + tmp2 = pParam->BSIM4v7a0 * T5; + tmp3 = pParam->BSIM4v7weff + pParam->BSIM4v7b1; + tmp4 = pParam->BSIM4v7b0 / tmp3; T2 = tmp2 + tmp4; dT2_dVb = -T9 / tmp1 / Xdep * dXdep_dVb; T6 = T5 * T5; @@ -1391,7 +1391,7 @@ for (; model != NULL; model = model->BSIM4nextModel) Abulk0 = 1.0 + T1 * T2; dAbulk0_dVb = T1 * tmp2 * dT2_dVb + T2 * dT1_dVb; - T8 = pParam->BSIM4ags * pParam->BSIM4a0 * T7; + T8 = pParam->BSIM4v7ags * pParam->BSIM4v7a0 * T7; dAbulk_dVg = -T1 * T8; Abulk = Abulk0 + dAbulk_dVg * Vgsteff; dAbulk_dVb = dAbulk0_dVb - T8 * Vgsteff * (dT1_dVb @@ -1410,17 +1410,17 @@ for (; model != NULL; model = model->BSIM4nextModel) dAbulk_dVb *= T10; dAbulk_dVg *= T10; } - here->BSIM4Abulk = Abulk; + here->BSIM4v7Abulk = Abulk; - T2 = pParam->BSIM4keta * Vbseff; + T2 = pParam->BSIM4v7keta * Vbseff; if (T2 >= -0.9) { T0 = 1.0 / (1.0 + T2); - dT0_dVb = -pParam->BSIM4keta * T0 * T0; + dT0_dVb = -pParam->BSIM4v7keta * T0 * T0; } else { T1 = 1.0 / (0.8 + T2); T0 = (17.0 + 20.0 * T2) * T1; - dT0_dVb = -pParam->BSIM4keta * T1 * T1; + dT0_dVb = -pParam->BSIM4v7keta * T1 * T1; } dAbulk_dVg *= T0; dAbulk_dVb = dAbulk_dVb * T0 + Abulk * dT0_dVb; @@ -1429,59 +1429,59 @@ for (; model != NULL; model = model->BSIM4nextModel) Abulk0 *= T0; /* Mobility calculation */ - if (model->BSIM4mtrlMod && model->BSIM4mtrlCompatMod == 0) - T14 = 2.0 * model->BSIM4type *(model->BSIM4phig - model->BSIM4easub - 0.5*model->BSIM4Eg0 + 0.45); + if (model->BSIM4v7mtrlMod && model->BSIM4v7mtrlCompatMod == 0) + T14 = 2.0 * model->BSIM4v7type *(model->BSIM4v7phig - model->BSIM4v7easub - 0.5*model->BSIM4v7Eg0 + 0.45); else T14 = 0.0; - if (model->BSIM4mobMod == 0) + if (model->BSIM4v7mobMod == 0) { T0 = Vgsteff + Vth + Vth - T14; - T2 = pParam->BSIM4ua + pParam->BSIM4uc * Vbseff; + T2 = pParam->BSIM4v7ua + pParam->BSIM4v7uc * Vbseff; T3 = T0 / toxe; T12 = sqrt(Vth * Vth + 0.0001); T9 = 1.0/(Vgsteff + 2*T12); T10 = T9*toxe; - T8 = pParam->BSIM4ud * T10 * T10 * Vth; + T8 = pParam->BSIM4v7ud * T10 * T10 * Vth; T6 = T8 * Vth; - T5 = T3 * (T2 + pParam->BSIM4ub * T3) + T6; + T5 = T3 * (T2 + pParam->BSIM4v7ub * T3) + T6; T7 = - 2.0 * T6 * T9; T11 = T7 * Vth/T12; - dDenomi_dVg = (T2 + 2.0 * pParam->BSIM4ub * T3) / toxe; + dDenomi_dVg = (T2 + 2.0 * pParam->BSIM4v7ub * T3) / toxe; T13 = 2.0 * (dDenomi_dVg + T11 + T8); dDenomi_dVd = T13 * dVth_dVd; - dDenomi_dVb = T13 * dVth_dVb + pParam->BSIM4uc * T3; + dDenomi_dVb = T13 * dVth_dVb + pParam->BSIM4v7uc * T3; dDenomi_dVg+= T7; } - else if (model->BSIM4mobMod == 1) + else if (model->BSIM4v7mobMod == 1) { T0 = Vgsteff + Vth + Vth - T14; - T2 = 1.0 + pParam->BSIM4uc * Vbseff; + T2 = 1.0 + pParam->BSIM4v7uc * Vbseff; T3 = T0 / toxe; - T4 = T3 * (pParam->BSIM4ua + pParam->BSIM4ub * T3); + T4 = T3 * (pParam->BSIM4v7ua + pParam->BSIM4v7ub * T3); T12 = sqrt(Vth * Vth + 0.0001); T9 = 1.0/(Vgsteff + 2*T12); T10 = T9*toxe; - T8 = pParam->BSIM4ud * T10 * T10 * Vth; + T8 = pParam->BSIM4v7ud * T10 * T10 * Vth; T6 = T8 * Vth; T5 = T4 * T2 + T6; T7 = - 2.0 * T6 * T9; T11 = T7 * Vth/T12; - dDenomi_dVg = (pParam->BSIM4ua + 2.0 * pParam->BSIM4ub * T3) * T2 / toxe; + dDenomi_dVg = (pParam->BSIM4v7ua + 2.0 * pParam->BSIM4v7ub * T3) * T2 / toxe; T13 = 2.0 * (dDenomi_dVg + T11 + T8); dDenomi_dVd = T13 * dVth_dVd; - dDenomi_dVb = T13 * dVth_dVb + pParam->BSIM4uc * T4; + dDenomi_dVb = T13 * dVth_dVb + pParam->BSIM4v7uc * T4; dDenomi_dVg+= T7; } - else if (model->BSIM4mobMod == 2) - { T0 = (Vgsteff + here->BSIM4vtfbphi1) / toxe; - T1 = exp(pParam->BSIM4eu * log(T0)); - dT1_dVg = T1 * pParam->BSIM4eu / T0 / toxe; - T2 = pParam->BSIM4ua + pParam->BSIM4uc * Vbseff; + else if (model->BSIM4v7mobMod == 2) + { T0 = (Vgsteff + here->BSIM4v7vtfbphi1) / toxe; + T1 = exp(pParam->BSIM4v7eu * log(T0)); + dT1_dVg = T1 * pParam->BSIM4v7eu / T0 / toxe; + T2 = pParam->BSIM4v7ua + pParam->BSIM4v7uc * Vbseff; T3 = T0 / toxe; /*Do we need it?*/ T12 = sqrt(Vth * Vth + 0.0001); T9 = 1.0/(Vgsteff + 2*T12); T10 = T9*toxe; - T8 = pParam->BSIM4ud * T10 * T10 * Vth; + T8 = pParam->BSIM4v7ud * T10 * T10 * Vth; T6 = T8 * Vth; T5 = T1 * T2 + T6; T7 = - 2.0 * T6 * T9; @@ -1489,7 +1489,7 @@ for (; model != NULL; model = model->BSIM4nextModel) dDenomi_dVg = T2 * dT1_dVg + T7; T13 = 2.0 * (T11 + T8); dDenomi_dVd = T13 * dVth_dVd; - dDenomi_dVb = T13 * dVth_dVb + T1 * pParam->BSIM4uc; + dDenomi_dVb = T13 * dVth_dVb + T1 * pParam->BSIM4v7uc; } /*high K mobility*/ else @@ -1497,21 +1497,21 @@ for (; model != NULL; model = model->BSIM4nextModel) /*univsersal mobility*/ - T0 = (Vgsteff + here->BSIM4vtfbphi1)* 1.0e-8 / toxe/6.0; - T1 = exp(pParam->BSIM4eu * log(T0)); - dT1_dVg = T1 * pParam->BSIM4eu * 1.0e-8/ T0 / toxe/6.0; - T2 = pParam->BSIM4ua + pParam->BSIM4uc * Vbseff; + T0 = (Vgsteff + here->BSIM4v7vtfbphi1)* 1.0e-8 / toxe/6.0; + T1 = exp(pParam->BSIM4v7eu * log(T0)); + dT1_dVg = T1 * pParam->BSIM4v7eu * 1.0e-8/ T0 / toxe/6.0; + T2 = pParam->BSIM4v7ua + pParam->BSIM4v7uc * Vbseff; /*Coulombic*/ - VgsteffVth = pParam->BSIM4VgsteffVth; + VgsteffVth = pParam->BSIM4v7VgsteffVth; - T10 = exp(pParam->BSIM4ucs * log(0.5 + 0.5 * Vgsteff/VgsteffVth)); - T11 = pParam->BSIM4ud/T10; - dT11_dVg = - 0.5 * pParam->BSIM4ucs * T11 /(0.5 + 0.5*Vgsteff/VgsteffVth)/VgsteffVth; + T10 = exp(pParam->BSIM4v7ucs * log(0.5 + 0.5 * Vgsteff/VgsteffVth)); + T11 = pParam->BSIM4v7ud/T10; + dT11_dVg = - 0.5 * pParam->BSIM4v7ucs * T11 /(0.5 + 0.5*Vgsteff/VgsteffVth)/VgsteffVth; dDenomi_dVg = T2 * dT1_dVg + dT11_dVg; dDenomi_dVd = 0.0; - dDenomi_dVb = T1 * pParam->BSIM4uc; + dDenomi_dVb = T1 * pParam->BSIM4v7uc; T5 = T1 * T2 + T11; } @@ -1533,41 +1533,41 @@ for (; model != NULL; model = model->BSIM4nextModel) } - here->BSIM4ueff = ueff = here->BSIM4u0temp / Denomi; + here->BSIM4v7ueff = ueff = here->BSIM4v7u0temp / Denomi; T9 = -ueff / Denomi; dueff_dVg = T9 * dDenomi_dVg; dueff_dVd = T9 * dDenomi_dVd; dueff_dVb = T9 * dDenomi_dVb; /* Saturation Drain Voltage Vdsat */ - WVCox = Weff * here->BSIM4vsattemp * model->BSIM4coxe; + WVCox = Weff * here->BSIM4v7vsattemp * model->BSIM4v7coxe; WVCoxRds = WVCox * Rds; - Esat = 2.0 * here->BSIM4vsattemp / ueff; - here->BSIM4EsatL = EsatL = Esat * Leff; + Esat = 2.0 * here->BSIM4v7vsattemp / ueff; + here->BSIM4v7EsatL = EsatL = Esat * Leff; T0 = -EsatL /ueff; dEsatL_dVg = T0 * dueff_dVg; dEsatL_dVd = T0 * dueff_dVd; dEsatL_dVb = T0 * dueff_dVb; /* Sqrt() */ - a1 = pParam->BSIM4a1; + a1 = pParam->BSIM4v7a1; if (a1 == 0.0) - { Lambda = pParam->BSIM4a2; + { Lambda = pParam->BSIM4v7a2; dLambda_dVg = 0.0; } else if (a1 > 0.0) - { T0 = 1.0 - pParam->BSIM4a2; - T1 = T0 - pParam->BSIM4a1 * Vgsteff - 0.0001; + { T0 = 1.0 - pParam->BSIM4v7a2; + T1 = T0 - pParam->BSIM4v7a1 * Vgsteff - 0.0001; T2 = sqrt(T1 * T1 + 0.0004 * T0); - Lambda = pParam->BSIM4a2 + T0 - 0.5 * (T1 + T2); - dLambda_dVg = 0.5 * pParam->BSIM4a1 * (1.0 + T1 / T2); + Lambda = pParam->BSIM4v7a2 + T0 - 0.5 * (T1 + T2); + dLambda_dVg = 0.5 * pParam->BSIM4v7a1 * (1.0 + T1 / T2); } else - { T1 = pParam->BSIM4a2 + pParam->BSIM4a1 * Vgsteff - 0.0001; - T2 = sqrt(T1 * T1 + 0.0004 * pParam->BSIM4a2); + { T1 = pParam->BSIM4v7a2 + pParam->BSIM4v7a1 * Vgsteff - 0.0001; + T2 = sqrt(T1 * T1 + 0.0004 * pParam->BSIM4v7a2); Lambda = 0.5 * (T1 + T2); - dLambda_dVg = 0.5 * pParam->BSIM4a1 * (1.0 + T1 / T2); + dLambda_dVg = 0.5 * pParam->BSIM4v7a1 * (1.0 + T1 / T2); } Vgst2Vtm = Vgsteff + 2.0 * Vtm; @@ -1639,17 +1639,17 @@ for (; model != NULL; model = model->BSIM4nextModel) - T0 * dT2_dVb) / T3 - Vdsat * dT0_dVb) / T0; dVdsat_dVd = (dT1_dVd - (T1 * dT1_dVd - T0 * dT2_dVd) / T3) / T0; } - here->BSIM4vdsat = Vdsat; + here->BSIM4v7vdsat = Vdsat; /* Calculate Vdseff */ - T1 = Vdsat - Vds - pParam->BSIM4delta; + T1 = Vdsat - Vds - pParam->BSIM4v7delta; dT1_dVg = dVdsat_dVg; dT1_dVd = dVdsat_dVd - 1.0; dT1_dVb = dVdsat_dVb; - T2 = sqrt(T1 * T1 + 4.0 * pParam->BSIM4delta * Vdsat); + T2 = sqrt(T1 * T1 + 4.0 * pParam->BSIM4v7delta * Vdsat); T0 = T1 / T2; - T9 = 2.0 * pParam->BSIM4delta; + T9 = 2.0 * pParam->BSIM4v7delta; T3 = T9 / T2; dT2_dVg = T0 * dT1_dVg + T3 * dVdsat_dVg; dT2_dVd = T0 * dT1_dVd + T3 * dVdsat_dVd; @@ -1680,18 +1680,18 @@ for (; model != NULL; model = model->BSIM4nextModel) if (Vdseff > Vds) Vdseff = Vds; diffVds = Vds - Vdseff; - here->BSIM4Vdseff = Vdseff; + here->BSIM4v7Vdseff = Vdseff; /* Velocity Overshoot */ - if((model->BSIM4lambdaGiven) && (model->BSIM4lambda > 0.0) ) + if((model->BSIM4v7lambdaGiven) && (model->BSIM4v7lambda > 0.0) ) { T1 = Leff * ueff; - T2 = pParam->BSIM4lambda / T1; + T2 = pParam->BSIM4v7lambda / T1; T3 = -T2 / T1 * Leff; dT2_dVd = T3 * dueff_dVd; dT2_dVg = T3 * dueff_dVg; dT2_dVb = T3 * dueff_dVb; - T5 = 1.0 / (Esat * pParam->BSIM4litl); + T5 = 1.0 / (Esat * pParam->BSIM4v7litl); T4 = -T5 / EsatL; dT5_dVg = dEsatL_dVg * T4; dT5_dVd = dEsatL_dVd * T4; @@ -1721,7 +1721,7 @@ for (; model != NULL; model = model->BSIM4nextModel) dEsatL_dVb += EsatL * dT10_dVb; EsatL *= T10; Esat = EsatL / Leff; /* bugfix by Wenwei Yang (4.6.4) */ - here->BSIM4EsatL = EsatL; + here->BSIM4v7EsatL = EsatL; } /* Calculate Vasat */ @@ -1751,20 +1751,20 @@ for (; model != NULL; model = model->BSIM4nextModel) /* Calculate Idl first */ - tmp1 = here->BSIM4vtfbphi2; - tmp2 = 2.0e8 * model->BSIM4toxp; + tmp1 = here->BSIM4v7vtfbphi2; + tmp2 = 2.0e8 * model->BSIM4v7toxp; dT0_dVg = 1.0 / tmp2; T0 = (Vgsteff + tmp1) * dT0_dVg; - tmp3 = exp(model->BSIM4bdos * 0.7 * log(T0)); + tmp3 = exp(model->BSIM4v7bdos * 0.7 * log(T0)); T1 = 1.0 + tmp3; - T2 = model->BSIM4bdos * 0.7 * tmp3 / T0; - Tcen = model->BSIM4ados * 1.9e-9 / T1; + T2 = model->BSIM4v7bdos * 0.7 * tmp3 / T0; + Tcen = model->BSIM4v7ados * 1.9e-9 / T1; dTcen_dVg = -Tcen * T2 * dT0_dVg / T1; - Coxeff = epssub * model->BSIM4coxp - / (epssub + model->BSIM4coxp * Tcen); - here->BSIM4Coxeff = Coxeff; + Coxeff = epssub * model->BSIM4v7coxp + / (epssub + model->BSIM4v7coxp * Tcen); + here->BSIM4v7Coxeff = Coxeff; dCoxeff_dVg = -Coxeff * Coxeff * dTcen_dVg / epssub; CoxeffWovL = Coxeff * Weff / Leff; @@ -1775,8 +1775,8 @@ for (; model != NULL; model = model->BSIM4nextModel) dbeta_dVd = CoxeffWovL * dueff_dVd; dbeta_dVb = CoxeffWovL * dueff_dVb + T3 * Coxeff * dWeff_dVb; - here->BSIM4AbovVgst2Vtm = Abulk / Vgst2Vtm; - T0 = 1.0 - 0.5 * Vdseff * here->BSIM4AbovVgst2Vtm; + here->BSIM4v7AbovVgst2Vtm = Abulk / Vgst2Vtm; + T0 = 1.0 - 0.5 * Vdseff * here->BSIM4v7AbovVgst2Vtm; dT0_dVg = -0.5 * (Abulk * dVdseff_dVg - Abulk * Vdseff / Vgst2Vtm + Vdseff * dAbulk_dVg) / Vgst2Vtm; dT0_dVd = -0.5 * Abulk * dVdseff_dVd / Vgst2Vtm; @@ -1812,18 +1812,18 @@ for (; model != NULL; model = model->BSIM4nextModel) /* Calculate degradation factor due to pocket implant */ - if (pParam->BSIM4fprout <= 0.0) + if (pParam->BSIM4v7fprout <= 0.0) { FP = 1.0; dFP_dVg = 0.0; } else - { T9 = pParam->BSIM4fprout * sqrt(Leff) / Vgst2Vtm; + { T9 = pParam->BSIM4v7fprout * sqrt(Leff) / Vgst2Vtm; FP = 1.0 / (1.0 + T9); dFP_dVg = FP * FP * T9 / Vgst2Vtm; } /* Calculate VACLM */ - T8 = pParam->BSIM4pvag / EsatL; + T8 = pParam->BSIM4v7pvag / EsatL; T9 = T8 * Vgsteff; if (T9 > -0.9) { PvagTerm = 1.0 + T9; @@ -1841,7 +1841,7 @@ for (; model != NULL; model = model->BSIM4nextModel) dPvagTerm_dVd = -T9 * dEsatL_dVd; } - if ((pParam->BSIM4pclm > MIN_EXP) && (diffVds > 1.0e-10)) + if ((pParam->BSIM4v7pclm > MIN_EXP) && (diffVds > 1.0e-10)) { T0 = 1.0 + Rds * Idl; dT0_dVg = dRds_dVg * Idl + Rds * dIdl_dVg; dT0_dVd = Rds * dIdl_dVd; @@ -1853,7 +1853,7 @@ for (; model != NULL; model = model->BSIM4nextModel) dT1_dVd = (dVdsat_dVd - T2 * dEsatL_dVd / Leff) / Esat; dT1_dVb = (dVdsat_dVb - T2 * dEsatL_dVb / Leff) / Esat; - Cclm = FP * PvagTerm * T0 * T1 / (pParam->BSIM4pclm * pParam->BSIM4litl); + Cclm = FP * PvagTerm * T0 * T1 / (pParam->BSIM4v7pclm * pParam->BSIM4v7litl); dCclm_dVg = Cclm * (dFP_dVg / FP + dPvagTerm_dVg / PvagTerm + dT0_dVg / T0 + dT1_dVg / T1); dCclm_dVb = Cclm * (dPvagTerm_dVb / PvagTerm + dT0_dVb / T0 @@ -1873,7 +1873,7 @@ for (; model != NULL; model = model->BSIM4nextModel) } /* Calculate VADIBL */ - if (pParam->BSIM4thetaRout > MIN_EXP) + if (pParam->BSIM4v7thetaRout > MIN_EXP) { T8 = Abulk * Vdsat; T0 = Vgst2Vtm * T8; dT0_dVg = Vgst2Vtm * Abulk * dVdsat_dVg + T8 @@ -1887,18 +1887,18 @@ for (; model != NULL; model = model->BSIM4nextModel) dT1_dVd = Abulk * dVdsat_dVd; T9 = T1 * T1; - T2 = pParam->BSIM4thetaRout; + T2 = pParam->BSIM4v7thetaRout; VADIBL = (Vgst2Vtm - T0 / T1) / T2; dVADIBL_dVg = (1.0 - dT0_dVg / T1 + T0 * dT1_dVg / T9) / T2; dVADIBL_dVb = (-dT0_dVb / T1 + T0 * dT1_dVb / T9) / T2; dVADIBL_dVd = (-dT0_dVd / T1 + T0 * dT1_dVd / T9) / T2; - T7 = pParam->BSIM4pdiblb * Vbseff; + T7 = pParam->BSIM4v7pdiblb * Vbseff; if (T7 >= -0.9) { T3 = 1.0 / (1.0 + T7); VADIBL *= T3; dVADIBL_dVg *= T3; - dVADIBL_dVb = (dVADIBL_dVb - VADIBL * pParam->BSIM4pdiblb) + dVADIBL_dVb = (dVADIBL_dVb - VADIBL * pParam->BSIM4v7pdiblb) * T3; dVADIBL_dVd *= T3; } @@ -1907,7 +1907,7 @@ for (; model != NULL; model = model->BSIM4nextModel) T3 = (17.0 + 20.0 * T7) * T4; dVADIBL_dVg *= T3; dVADIBL_dVb = dVADIBL_dVb * T3 - - VADIBL * pParam->BSIM4pdiblb * T4 * T4; + - VADIBL * pParam->BSIM4v7pdiblb * T4 * T4; dVADIBL_dVd *= T3; VADIBL *= T3; } @@ -1929,21 +1929,21 @@ for (; model != NULL; model = model->BSIM4nextModel) dVa_dVd = dVasat_dVd + dVACLM_dVd; /* Calculate VADITS */ - T0 = pParam->BSIM4pditsd * Vds; + T0 = pParam->BSIM4v7pditsd * Vds; if (T0 > EXP_THRESHOLD) { T1 = MAX_EXP; dT1_dVd = 0; } else { T1 = exp(T0); - dT1_dVd = T1 * pParam->BSIM4pditsd; + dT1_dVd = T1 * pParam->BSIM4v7pditsd; } - if (pParam->BSIM4pdits > MIN_EXP) - { T2 = 1.0 + model->BSIM4pditsl * Leff; - VADITS = (1.0 + T2 * T1) / pParam->BSIM4pdits; + if (pParam->BSIM4v7pdits > MIN_EXP) + { T2 = 1.0 + model->BSIM4v7pditsl * Leff; + VADITS = (1.0 + T2 * T1) / pParam->BSIM4v7pdits; dVADITS_dVg = VADITS * dFP_dVg; - dVADITS_dVd = FP * T2 * dT1_dVd / pParam->BSIM4pdits; + dVADITS_dVd = FP * T2 * dT1_dVd / pParam->BSIM4v7pdits; VADITS *= FP; } else @@ -1952,18 +1952,18 @@ for (; model != NULL; model = model->BSIM4nextModel) } /* Calculate VASCBE */ - if ((pParam->BSIM4pscbe2 > 0.0)&&(pParam->BSIM4pscbe1>=0.0)) /*4.6.2*/ - { if (diffVds > pParam->BSIM4pscbe1 * pParam->BSIM4litl + if ((pParam->BSIM4v7pscbe2 > 0.0)&&(pParam->BSIM4v7pscbe1>=0.0)) /*4.6.2*/ + { if (diffVds > pParam->BSIM4v7pscbe1 * pParam->BSIM4v7litl / EXP_THRESHOLD) - { T0 = pParam->BSIM4pscbe1 * pParam->BSIM4litl / diffVds; - VASCBE = Leff * exp(T0) / pParam->BSIM4pscbe2; + { T0 = pParam->BSIM4v7pscbe1 * pParam->BSIM4v7litl / diffVds; + VASCBE = Leff * exp(T0) / pParam->BSIM4v7pscbe2; T1 = T0 * VASCBE / diffVds; dVASCBE_dVg = T1 * dVdseff_dVg; dVASCBE_dVd = -T1 * (1.0 - dVdseff_dVd); dVASCBE_dVb = T1 * dVdseff_dVb; } else - { VASCBE = MAX_EXP * Leff/pParam->BSIM4pscbe2; + { VASCBE = MAX_EXP * Leff/pParam->BSIM4v7pscbe2; dVASCBE_dVg = dVASCBE_dVd = dVASCBE_dVb = 0.0; } } @@ -2007,14 +2007,14 @@ for (; model != NULL; model = model->BSIM4nextModel) Idsa *= T9; /* Substrate current begins */ - tmp = pParam->BSIM4alpha0 + pParam->BSIM4alpha1 * Leff; - if ((tmp <= 0.0) || (pParam->BSIM4beta0 <= 0.0)) + tmp = pParam->BSIM4v7alpha0 + pParam->BSIM4v7alpha1 * Leff; + if ((tmp <= 0.0) || (pParam->BSIM4v7beta0 <= 0.0)) { Isub = Gbd = Gbb = Gbg = 0.0; } else { T2 = tmp / Leff; - if (diffVds > pParam->BSIM4beta0 / EXP_THRESHOLD) - { T0 = -pParam->BSIM4beta0 / diffVds; + if (diffVds > pParam->BSIM4v7beta0 / EXP_THRESHOLD) + { T0 = -pParam->BSIM4v7beta0 / diffVds; T1 = T2 * diffVds * exp(T0); T3 = T1 / diffVds * (T0 - 1.0); dT1_dVg = T3 * dVdseff_dVg; @@ -2042,10 +2042,10 @@ for (; model != NULL; model = model->BSIM4nextModel) Gbg *= dVgsteff_dVg; Gbb *= dVbseff_dVb; } - here->BSIM4csub = Isub; - here->BSIM4gbbs = Gbb; - here->BSIM4gbgs = Gbg; - here->BSIM4gbds = Gbd; + here->BSIM4v7csub = Isub; + here->BSIM4v7gbbs = Gbb; + here->BSIM4v7gbgs = Gbg; + here->BSIM4v7gbds = Gbd; /* Add SCBE to Ids */ T9 = diffVds / VASCBE; @@ -2073,7 +2073,7 @@ for (; model != NULL; model = model->BSIM4nextModel) cdrain = Ids * Vdseff; /* Source End Velocity Limit */ - if((model->BSIM4vtlGiven) && (model->BSIM4vtl > 0.0) ) { + if((model->BSIM4v7vtlGiven) && (model->BSIM4v7vtl > 0.0) ) { T12 = 1.0 / Leff / CoxeffWovL; T11 = T12 / Vgsteff; T10 = -T11 / Vgsteff; @@ -2082,7 +2082,7 @@ for (; model != NULL; model = model->BSIM4nextModel) dvs_dVd = Gds * T11 + cdrain * T10 * dVgsteff_dVd; dvs_dVb = Gmb * T11 + cdrain * T10 * dVgsteff_dVb; T0 = 2 * MM; - T1 = vs / (pParam->BSIM4vtl * pParam->BSIM4tfactor); + T1 = vs / (pParam->BSIM4v7vtl * pParam->BSIM4v7tfactor); if(T1 > 0.0) { T2 = 1.0 + exp(T0 * log(T1)); T3 = (T2 - 1.0) * T0 / vs; @@ -2110,61 +2110,61 @@ for (; model != NULL; model = model->BSIM4nextModel) cdrain *= Fsevl; } - here->BSIM4gds = Gds; - here->BSIM4gm = Gm; - here->BSIM4gmbs = Gmb; - here->BSIM4IdovVds = Ids; - if( here->BSIM4IdovVds <= 1.0e-9) here->BSIM4IdovVds = 1.0e-9; + here->BSIM4v7gds = Gds; + here->BSIM4v7gm = Gm; + here->BSIM4v7gmbs = Gmb; + here->BSIM4v7IdovVds = Ids; + if( here->BSIM4v7IdovVds <= 1.0e-9) here->BSIM4v7IdovVds = 1.0e-9; /* Calculate Rg */ - if ((here->BSIM4rgateMod > 1) || - (here->BSIM4trnqsMod != 0) || (here->BSIM4acnqsMod != 0)) - { T9 = pParam->BSIM4xrcrg2 * model->BSIM4vtm; + if ((here->BSIM4v7rgateMod > 1) || + (here->BSIM4v7trnqsMod != 0) || (here->BSIM4v7acnqsMod != 0)) + { T9 = pParam->BSIM4v7xrcrg2 * model->BSIM4v7vtm; T0 = T9 * beta; dT0_dVd = (dbeta_dVd + dbeta_dVg * dVgsteff_dVd) * T9; dT0_dVb = (dbeta_dVb + dbeta_dVg * dVgsteff_dVb) * T9; dT0_dVg = dbeta_dVg * T9; - here->BSIM4gcrg = pParam->BSIM4xrcrg1 * ( T0 + Ids); - here->BSIM4gcrgd = pParam->BSIM4xrcrg1 * (dT0_dVd + tmp1); - here->BSIM4gcrgb = pParam->BSIM4xrcrg1 * (dT0_dVb + tmp2) + here->BSIM4v7gcrg = pParam->BSIM4v7xrcrg1 * ( T0 + Ids); + here->BSIM4v7gcrgd = pParam->BSIM4v7xrcrg1 * (dT0_dVd + tmp1); + here->BSIM4v7gcrgb = pParam->BSIM4v7xrcrg1 * (dT0_dVb + tmp2) * dVbseff_dVb; - here->BSIM4gcrgg = pParam->BSIM4xrcrg1 * (dT0_dVg + tmp3) + here->BSIM4v7gcrgg = pParam->BSIM4v7xrcrg1 * (dT0_dVg + tmp3) * dVgsteff_dVg; - if (here->BSIM4nf != 1.0) - { here->BSIM4gcrg *= here->BSIM4nf; - here->BSIM4gcrgg *= here->BSIM4nf; - here->BSIM4gcrgd *= here->BSIM4nf; - here->BSIM4gcrgb *= here->BSIM4nf; + if (here->BSIM4v7nf != 1.0) + { here->BSIM4v7gcrg *= here->BSIM4v7nf; + here->BSIM4v7gcrgg *= here->BSIM4v7nf; + here->BSIM4v7gcrgd *= here->BSIM4v7nf; + here->BSIM4v7gcrgb *= here->BSIM4v7nf; } - if (here->BSIM4rgateMod == 2) - { T10 = here->BSIM4grgeltd * here->BSIM4grgeltd; - T11 = here->BSIM4grgeltd + here->BSIM4gcrg; - here->BSIM4gcrg = here->BSIM4grgeltd * here->BSIM4gcrg / T11; + if (here->BSIM4v7rgateMod == 2) + { T10 = here->BSIM4v7grgeltd * here->BSIM4v7grgeltd; + T11 = here->BSIM4v7grgeltd + here->BSIM4v7gcrg; + here->BSIM4v7gcrg = here->BSIM4v7grgeltd * here->BSIM4v7gcrg / T11; T12 = T10 / T11 / T11; - here->BSIM4gcrgg *= T12; - here->BSIM4gcrgd *= T12; - here->BSIM4gcrgb *= T12; + here->BSIM4v7gcrgg *= T12; + here->BSIM4v7gcrgd *= T12; + here->BSIM4v7gcrgb *= T12; } - here->BSIM4gcrgs = -(here->BSIM4gcrgg + here->BSIM4gcrgd - + here->BSIM4gcrgb); + here->BSIM4v7gcrgs = -(here->BSIM4v7gcrgg + here->BSIM4v7gcrgd + + here->BSIM4v7gcrgb); } /* Calculate bias-dependent external S/D resistance */ - if (model->BSIM4rdsMod) + if (model->BSIM4v7rdsMod) { /* Rs(V) */ - T0 = vgs - pParam->BSIM4vfbsd; + T0 = vgs - pParam->BSIM4v7vfbsd; T1 = sqrt(T0 * T0 + 1.0e-4); vgs_eff = 0.5 * (T0 + T1); dvgs_eff_dvg = vgs_eff / T1; - T0 = 1.0 + pParam->BSIM4prwg * vgs_eff; - dT0_dvg = -pParam->BSIM4prwg / T0 / T0 * dvgs_eff_dvg; - T1 = -pParam->BSIM4prwb * vbs; - dT1_dvb = -pParam->BSIM4prwb; + T0 = 1.0 + pParam->BSIM4v7prwg * vgs_eff; + dT0_dvg = -pParam->BSIM4v7prwg / T0 / T0 * dvgs_eff_dvg; + T1 = -pParam->BSIM4v7prwb * vbs; + dT1_dvb = -pParam->BSIM4v7prwb; T2 = 1.0 / T0 + T1; T3 = T2 + sqrt(T2 * T2 + 0.01); @@ -2172,29 +2172,29 @@ for (; model != NULL; model = model->BSIM4nextModel) dT3_dvb = dT3_dvg * dT1_dvb; dT3_dvg *= dT0_dvg; - T4 = pParam->BSIM4rs0 * 0.5; - Rs = pParam->BSIM4rswmin + T3 * T4; + T4 = pParam->BSIM4v7rs0 * 0.5; + Rs = pParam->BSIM4v7rswmin + T3 * T4; dRs_dvg = T4 * dT3_dvg; dRs_dvb = T4 * dT3_dvb; - T0 = 1.0 + here->BSIM4sourceConductance * Rs; - here->BSIM4gstot = here->BSIM4sourceConductance / T0; - T0 = -here->BSIM4gstot * here->BSIM4gstot; + T0 = 1.0 + here->BSIM4v7sourceConductance * Rs; + here->BSIM4v7gstot = here->BSIM4v7sourceConductance / T0; + T0 = -here->BSIM4v7gstot * here->BSIM4v7gstot; dgstot_dvd = 0.0; /* place holder */ dgstot_dvg = T0 * dRs_dvg; dgstot_dvb = T0 * dRs_dvb; dgstot_dvs = -(dgstot_dvg + dgstot_dvb + dgstot_dvd); /* Rd(V) */ - T0 = vgd - pParam->BSIM4vfbsd; + T0 = vgd - pParam->BSIM4v7vfbsd; T1 = sqrt(T0 * T0 + 1.0e-4); vgd_eff = 0.5 * (T0 + T1); dvgd_eff_dvg = vgd_eff / T1; - T0 = 1.0 + pParam->BSIM4prwg * vgd_eff; - dT0_dvg = -pParam->BSIM4prwg / T0 / T0 * dvgd_eff_dvg; - T1 = -pParam->BSIM4prwb * vbd; - dT1_dvb = -pParam->BSIM4prwb; + T0 = 1.0 + pParam->BSIM4v7prwg * vgd_eff; + dT0_dvg = -pParam->BSIM4v7prwg / T0 / T0 * dvgd_eff_dvg; + T1 = -pParam->BSIM4v7prwb * vbd; + dT1_dvb = -pParam->BSIM4v7prwb; T2 = 1.0 / T0 + T1; T3 = T2 + sqrt(T2 * T2 + 0.01); @@ -2202,73 +2202,73 @@ for (; model != NULL; model = model->BSIM4nextModel) dT3_dvb = dT3_dvg * dT1_dvb; dT3_dvg *= dT0_dvg; - T4 = pParam->BSIM4rd0 * 0.5; - Rd = pParam->BSIM4rdwmin + T3 * T4; + T4 = pParam->BSIM4v7rd0 * 0.5; + Rd = pParam->BSIM4v7rdwmin + T3 * T4; dRd_dvg = T4 * dT3_dvg; dRd_dvb = T4 * dT3_dvb; - T0 = 1.0 + here->BSIM4drainConductance * Rd; - here->BSIM4gdtot = here->BSIM4drainConductance / T0; - T0 = -here->BSIM4gdtot * here->BSIM4gdtot; + T0 = 1.0 + here->BSIM4v7drainConductance * Rd; + here->BSIM4v7gdtot = here->BSIM4v7drainConductance / T0; + T0 = -here->BSIM4v7gdtot * here->BSIM4v7gdtot; dgdtot_dvs = 0.0; dgdtot_dvg = T0 * dRd_dvg; dgdtot_dvb = T0 * dRd_dvb; dgdtot_dvd = -(dgdtot_dvg + dgdtot_dvb + dgdtot_dvs); - here->BSIM4gstotd = vses * dgstot_dvd; - here->BSIM4gstotg = vses * dgstot_dvg; - here->BSIM4gstots = vses * dgstot_dvs; - here->BSIM4gstotb = vses * dgstot_dvb; + here->BSIM4v7gstotd = vses * dgstot_dvd; + here->BSIM4v7gstotg = vses * dgstot_dvg; + here->BSIM4v7gstots = vses * dgstot_dvs; + here->BSIM4v7gstotb = vses * dgstot_dvb; T2 = vdes - vds; - here->BSIM4gdtotd = T2 * dgdtot_dvd; - here->BSIM4gdtotg = T2 * dgdtot_dvg; - here->BSIM4gdtots = T2 * dgdtot_dvs; - here->BSIM4gdtotb = T2 * dgdtot_dvb; + here->BSIM4v7gdtotd = T2 * dgdtot_dvd; + here->BSIM4v7gdtotg = T2 * dgdtot_dvg; + here->BSIM4v7gdtots = T2 * dgdtot_dvs; + here->BSIM4v7gdtotb = T2 * dgdtot_dvb; } else /* WDLiu: for bypass */ - { here->BSIM4gstot = here->BSIM4gstotd = here->BSIM4gstotg = 0.0; - here->BSIM4gstots = here->BSIM4gstotb = 0.0; - here->BSIM4gdtot = here->BSIM4gdtotd = here->BSIM4gdtotg = 0.0; - here->BSIM4gdtots = here->BSIM4gdtotb = 0.0; + { here->BSIM4v7gstot = here->BSIM4v7gstotd = here->BSIM4v7gstotg = 0.0; + here->BSIM4v7gstots = here->BSIM4v7gstotb = 0.0; + here->BSIM4v7gdtot = here->BSIM4v7gdtotd = here->BSIM4v7gdtotg = 0.0; + here->BSIM4v7gdtots = here->BSIM4v7gdtotb = 0.0; } /* GIDL/GISL Models */ - if(model->BSIM4mtrlMod == 0) + if(model->BSIM4v7mtrlMod == 0) T0 = 3.0 * toxe; else - T0 = model->BSIM4epsrsub * toxe / epsrox; + T0 = model->BSIM4v7epsrsub * toxe / epsrox; /* Calculate GIDL current */ - vgs_eff = here->BSIM4vgs_eff; - dvgs_eff_dvg = here->BSIM4dvgs_eff_dvg; - vgd_eff = here->BSIM4vgd_eff; - dvgd_eff_dvg = here->BSIM4dvgd_eff_dvg; + vgs_eff = here->BSIM4v7vgs_eff; + dvgs_eff_dvg = here->BSIM4v7dvgs_eff_dvg; + vgd_eff = here->BSIM4v7vgd_eff; + dvgd_eff_dvg = here->BSIM4v7dvgd_eff_dvg; - if (model->BSIM4gidlMod==0){ + if (model->BSIM4v7gidlMod==0){ - if(model->BSIM4mtrlMod ==0) - T1 = (vds - vgs_eff - pParam->BSIM4egidl ) / T0; + if(model->BSIM4v7mtrlMod ==0) + T1 = (vds - vgs_eff - pParam->BSIM4v7egidl ) / T0; else - T1 = (vds - vgs_eff - pParam->BSIM4egidl + pParam->BSIM4vfbsd) / T0; + T1 = (vds - vgs_eff - pParam->BSIM4v7egidl + pParam->BSIM4v7vfbsd) / T0; - if ((pParam->BSIM4agidl <= 0.0) || (pParam->BSIM4bgidl <= 0.0) - || (T1 <= 0.0) || (pParam->BSIM4cgidl <= 0.0) || (vbd > 0.0)) + if ((pParam->BSIM4v7agidl <= 0.0) || (pParam->BSIM4v7bgidl <= 0.0) + || (T1 <= 0.0) || (pParam->BSIM4v7cgidl <= 0.0) || (vbd > 0.0)) Igidl = Ggidld = Ggidlg = Ggidlb = 0.0; else { dT1_dVd = 1.0 / T0; dT1_dVg = -dvgs_eff_dvg * dT1_dVd; - T2 = pParam->BSIM4bgidl / T1; + T2 = pParam->BSIM4v7bgidl / T1; if (T2 < 100.0) - { Igidl = pParam->BSIM4agidl * pParam->BSIM4weffCJ * T1 * exp(-T2); + { Igidl = pParam->BSIM4v7agidl * pParam->BSIM4v7weffCJ * T1 * exp(-T2); T3 = Igidl * (1.0 + T2) / T1; Ggidld = T3 * dT1_dVd; Ggidlg = T3 * dT1_dVg; } else - { Igidl = pParam->BSIM4agidl * pParam->BSIM4weffCJ * 3.720075976e-44; + { Igidl = pParam->BSIM4v7agidl * pParam->BSIM4v7weffCJ * 3.720075976e-44; Ggidld = Igidl * dT1_dVd; Ggidlg = Igidl * dT1_dVg; Igidl *= T1; @@ -2276,40 +2276,40 @@ for (; model != NULL; model = model->BSIM4nextModel) T4 = vbd * vbd; T5 = -vbd * T4; - T6 = pParam->BSIM4cgidl + T5; + T6 = pParam->BSIM4v7cgidl + T5; T7 = T5 / T6; - T8 = 3.0 * pParam->BSIM4cgidl * T4 / T6 / T6; + T8 = 3.0 * pParam->BSIM4v7cgidl * T4 / T6 / T6; Ggidld = Ggidld * T7 + Igidl * T8; Ggidlg = Ggidlg * T7; Ggidlb = -Igidl * T8; Igidl *= T7; } - here->BSIM4Igidl = Igidl; - here->BSIM4ggidld = Ggidld; - here->BSIM4ggidlg = Ggidlg; - here->BSIM4ggidlb = Ggidlb; + here->BSIM4v7Igidl = Igidl; + here->BSIM4v7ggidld = Ggidld; + here->BSIM4v7ggidlg = Ggidlg; + here->BSIM4v7ggidlb = Ggidlb; /* Calculate GISL current */ - if(model->BSIM4mtrlMod ==0) - T1 = (-vds - vgd_eff - pParam->BSIM4egisl ) / T0; + if(model->BSIM4v7mtrlMod ==0) + T1 = (-vds - vgd_eff - pParam->BSIM4v7egisl ) / T0; else - T1 = (-vds - vgd_eff - pParam->BSIM4egisl + pParam->BSIM4vfbsd ) / T0; + T1 = (-vds - vgd_eff - pParam->BSIM4v7egisl + pParam->BSIM4v7vfbsd ) / T0; - if ((pParam->BSIM4agisl <= 0.0) || (pParam->BSIM4bgisl <= 0.0) - || (T1 <= 0.0) || (pParam->BSIM4cgisl <= 0.0) || (vbs > 0.0)) + if ((pParam->BSIM4v7agisl <= 0.0) || (pParam->BSIM4v7bgisl <= 0.0) + || (T1 <= 0.0) || (pParam->BSIM4v7cgisl <= 0.0) || (vbs > 0.0)) Igisl = Ggisls = Ggislg = Ggislb = 0.0; else { dT1_dVd = 1.0 / T0; dT1_dVg = -dvgd_eff_dvg * dT1_dVd; - T2 = pParam->BSIM4bgisl / T1; + T2 = pParam->BSIM4v7bgisl / T1; if (T2 < 100.0) - { Igisl = pParam->BSIM4agisl * pParam->BSIM4weffCJ * T1 * exp(-T2); + { Igisl = pParam->BSIM4v7agisl * pParam->BSIM4v7weffCJ * T1 * exp(-T2); T3 = Igisl * (1.0 + T2) / T1; Ggisls = T3 * dT1_dVd; Ggislg = T3 * dT1_dVg; } else - { Igisl = pParam->BSIM4agisl * pParam->BSIM4weffCJ * 3.720075976e-44; + { Igisl = pParam->BSIM4v7agisl * pParam->BSIM4v7weffCJ * 3.720075976e-44; Ggisls = Igisl * dT1_dVd; Ggislg = Igisl * dT1_dVg; Igisl *= T1; @@ -2317,58 +2317,58 @@ for (; model != NULL; model = model->BSIM4nextModel) T4 = vbs * vbs; T5 = -vbs * T4; - T6 = pParam->BSIM4cgisl + T5; + T6 = pParam->BSIM4v7cgisl + T5; T7 = T5 / T6; - T8 = 3.0 * pParam->BSIM4cgisl * T4 / T6 / T6; + T8 = 3.0 * pParam->BSIM4v7cgisl * T4 / T6 / T6; Ggisls = Ggisls * T7 + Igisl * T8; Ggislg = Ggislg * T7; Ggislb = -Igisl * T8; Igisl *= T7; } - here->BSIM4Igisl = Igisl; - here->BSIM4ggisls = Ggisls; - here->BSIM4ggislg = Ggislg; - here->BSIM4ggislb = Ggislb; + here->BSIM4v7Igisl = Igisl; + here->BSIM4v7ggisls = Ggisls; + here->BSIM4v7ggislg = Ggislg; + here->BSIM4v7ggislb = Ggislb; } else{ /* v4.7 New Gidl/GISL model */ /* GISL */ - if (model->BSIM4mtrlMod==0) - T1 = (-vds - pParam->BSIM4rgisl * vgd_eff - pParam->BSIM4egisl) / T0; + if (model->BSIM4v7mtrlMod==0) + T1 = (-vds - pParam->BSIM4v7rgisl * vgd_eff - pParam->BSIM4v7egisl) / T0; else - T1 = (-vds - pParam->BSIM4rgisl * vgd_eff - pParam->BSIM4egisl + pParam->BSIM4vfbsd) / T0; + T1 = (-vds - pParam->BSIM4v7rgisl * vgd_eff - pParam->BSIM4v7egisl + pParam->BSIM4v7vfbsd) / T0; - if ((pParam->BSIM4agisl <= 0.0) || - (pParam->BSIM4bgisl <= 0.0) || (T1 <= 0.0) || - (pParam->BSIM4cgisl < 0.0) ) + if ((pParam->BSIM4v7agisl <= 0.0) || + (pParam->BSIM4v7bgisl <= 0.0) || (T1 <= 0.0) || + (pParam->BSIM4v7cgisl < 0.0) ) Igisl = Ggisls = Ggislg = Ggislb = 0.0; else { dT1_dVd = 1 / T0; - dT1_dVg = - pParam->BSIM4rgisl * dT1_dVd * dvgd_eff_dvg; - T2 = pParam->BSIM4bgisl / T1; + dT1_dVg = - pParam->BSIM4v7rgisl * dT1_dVd * dvgd_eff_dvg; + T2 = pParam->BSIM4v7bgisl / T1; if (T2 < EXPL_THRESHOLD) { - Igisl = pParam->BSIM4weffCJ * pParam->BSIM4agisl * T1 * exp(-T2); + Igisl = pParam->BSIM4v7weffCJ * pParam->BSIM4v7agisl * T1 * exp(-T2); T3 = Igisl / T1 * (T2 + 1); Ggisls = T3 * dT1_dVd; Ggislg = T3 * dT1_dVg; } else { - T3 = pParam->BSIM4weffCJ * pParam->BSIM4agisl * MIN_EXPL; + T3 = pParam->BSIM4v7weffCJ * pParam->BSIM4v7agisl * MIN_EXPL; Igisl = T3 * T1 ; Ggisls = T3 * dT1_dVd; Ggislg = T3 * dT1_dVg; } - T4 = vbs - pParam->BSIM4fgisl; + T4 = vbs - pParam->BSIM4v7fgisl; if (T4==0) T5 = EXPL_THRESHOLD; else - T5 = pParam->BSIM4kgisl / T4; + T5 = pParam->BSIM4v7kgisl / T4; if (T5BSIM4nextModel) Igisl*=T6; } - here->BSIM4Igisl = Igisl; - here->BSIM4ggisls = Ggisls; - here->BSIM4ggislg = Ggislg; - here->BSIM4ggislb = Ggislb; + here->BSIM4v7Igisl = Igisl; + here->BSIM4v7ggisls = Ggisls; + here->BSIM4v7ggislg = Ggislg; + here->BSIM4v7ggislb = Ggislb; /* End of GISL */ /* GIDL */ - if (model->BSIM4mtrlMod==0) - T1 = (vds - pParam->BSIM4rgidl * vgs_eff - pParam->BSIM4egidl) / T0; + if (model->BSIM4v7mtrlMod==0) + T1 = (vds - pParam->BSIM4v7rgidl * vgs_eff - pParam->BSIM4v7egidl) / T0; else - T1 = (vds - pParam->BSIM4rgidl * vgs_eff - pParam->BSIM4egidl + pParam->BSIM4vfbsd) / T0; + T1 = (vds - pParam->BSIM4v7rgidl * vgs_eff - pParam->BSIM4v7egidl + pParam->BSIM4v7vfbsd) / T0; - if ((pParam->BSIM4agidl <= 0.0) || - (pParam->BSIM4bgidl <= 0.0) || (T1 <= 0.0) || - (pParam->BSIM4cgidl < 0.0) ) + if ((pParam->BSIM4v7agidl <= 0.0) || + (pParam->BSIM4v7bgidl <= 0.0) || (T1 <= 0.0) || + (pParam->BSIM4v7cgidl < 0.0) ) Igidl = Ggidld = Ggidlg = Ggidlb = 0.0; else { dT1_dVd = 1 / T0; - dT1_dVg = - pParam->BSIM4rgidl * dT1_dVd * dvgs_eff_dvg; - T2 = pParam->BSIM4bgidl / T1; + dT1_dVg = - pParam->BSIM4v7rgidl * dT1_dVd * dvgs_eff_dvg; + T2 = pParam->BSIM4v7bgidl / T1; if (T2 < EXPL_THRESHOLD) { - Igidl = pParam->BSIM4weffCJ * pParam->BSIM4agidl * T1 * exp(-T2); + Igidl = pParam->BSIM4v7weffCJ * pParam->BSIM4v7agidl * T1 * exp(-T2); T3 = Igidl / T1 * (T2 + 1); Ggidld = T3 * dT1_dVd; Ggidlg = T3 * dT1_dVg; } else { - T3 = pParam->BSIM4weffCJ * pParam->BSIM4agidl * MIN_EXPL; + T3 = pParam->BSIM4v7weffCJ * pParam->BSIM4v7agidl * MIN_EXPL; Igidl = T3 * T1 ; Ggidld = T3 * dT1_dVd; Ggidlg = T3 * dT1_dVg; } - T4 = vbd - pParam->BSIM4fgidl; + T4 = vbd - pParam->BSIM4v7fgidl; if (T4==0) T5 = EXPL_THRESHOLD; else - T5 = pParam->BSIM4kgidl / T4; + T5 = pParam->BSIM4v7kgidl / T4; if (T5BSIM4nextModel) Ggidlg *= T6; Igidl *= T6; } - here->BSIM4Igidl = Igidl; - here->BSIM4ggidld = Ggidld; - here->BSIM4ggidlg = Ggidlg; - here->BSIM4ggidlb = Ggidlb; + here->BSIM4v7Igidl = Igidl; + here->BSIM4v7ggidld = Ggidld; + here->BSIM4v7ggidlg = Ggidlg; + here->BSIM4v7ggidlb = Ggidlb; /* End of New GIDL */ } /*End of Gidl*/ @@ -2447,8 +2447,8 @@ for (; model != NULL; model = model->BSIM4nextModel) /* Calculate gate tunneling current */ - if ((model->BSIM4igcMod != 0) || (model->BSIM4igbMod != 0)) - { Vfb = here->BSIM4vfbzb; + if ((model->BSIM4v7igcMod != 0) || (model->BSIM4v7igbMod != 0)) + { Vfb = here->BSIM4v7vfbzb; V3 = Vfb - Vgs_eff + Vbseff - DELTA_3; if (Vfb <= 0.0) T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * Vfb); @@ -2465,9 +2465,9 @@ for (; model != NULL; model = model->BSIM4nextModel) if (Voxacc < 0.0) /* WDLiu: Avoiding numerical instability. */ Voxacc = dVoxacc_dVg = dVoxacc_dVb = 0.0; - T0 = 0.5 * pParam->BSIM4k1ox; + T0 = 0.5 * pParam->BSIM4v7k1ox; T3 = Vgs_eff - Vfbeff - Vbseff - Vgsteff; - if (pParam->BSIM4k1ox == 0.0) + if (pParam->BSIM4v7k1ox == 0.0) Voxdepinv = dVoxdepinv_dVg = dVoxdepinv_dVd = dVoxdepinv_dVb = 0.0; else if (T3 < 0.0) @@ -2480,7 +2480,7 @@ for (; model != NULL; model = model->BSIM4nextModel) else { T1 = sqrt(T0 * T0 + T3); T2 = T0 / T1; - Voxdepinv = pParam->BSIM4k1ox * (T1 - T0); + Voxdepinv = pParam->BSIM4v7k1ox * (T1 - T0); dVoxdepinv_dVg = T2 * (dVgs_eff_dVg - dVfbeff_dVg - dVgsteff_dVg); dVoxdepinv_dVd = -T2 * dVgsteff_dVd; @@ -2493,24 +2493,24 @@ for (; model != NULL; model = model->BSIM4nextModel) dVoxdepinv_dVb += dVgsteff_dVb; } - if(model->BSIM4tempMod < 2) + if(model->BSIM4v7tempMod < 2) tmp = Vtm; - else /* model->BSIM4tempMod = 2 , 3*/ + else /* model->BSIM4v7tempMod = 2 , 3*/ tmp = Vtm0; - if (model->BSIM4igcMod) - { T0 = tmp * pParam->BSIM4nigc; - if(model->BSIM4igcMod == 1) { - VxNVt = (Vgs_eff - model->BSIM4type * here->BSIM4vth0) / T0; + if (model->BSIM4v7igcMod) + { T0 = tmp * pParam->BSIM4v7nigc; + if(model->BSIM4v7igcMod == 1) { + VxNVt = (Vgs_eff - model->BSIM4v7type * here->BSIM4v7vth0) / T0; if (VxNVt > EXP_THRESHOLD) - { Vaux = Vgs_eff - model->BSIM4type * here->BSIM4vth0; + { Vaux = Vgs_eff - model->BSIM4v7type * here->BSIM4v7vth0; dVaux_dVg = dVgs_eff_dVg; dVaux_dVd = 0.0; dVaux_dVb = 0.0; } - } else if (model->BSIM4igcMod == 2) { - VxNVt = (Vgs_eff - here->BSIM4von) / T0; + } else if (model->BSIM4v7igcMod == 2) { + VxNVt = (Vgs_eff - here->BSIM4v7von) / T0; if (VxNVt > EXP_THRESHOLD) - { Vaux = Vgs_eff - here->BSIM4von; + { Vaux = Vgs_eff - here->BSIM4v7von; dVaux_dVg = dVgs_eff_dVg; dVaux_dVd = -dVth_dVd; dVaux_dVb = -dVth_dVb; @@ -2524,10 +2524,10 @@ for (; model != NULL; model = model->BSIM4nextModel) { ExpVxNVt = exp(VxNVt); Vaux = T0 * log(1.0 + ExpVxNVt); dVaux_dVg = ExpVxNVt / (1.0 + ExpVxNVt); - if(model->BSIM4igcMod == 1) { + if(model->BSIM4v7igcMod == 1) { dVaux_dVd = 0.0; dVaux_dVb = 0.0; - } else if (model->BSIM4igcMod == 2) { + } else if (model->BSIM4v7igcMod == 2) { dVaux_dVd = -dVgs_eff_dVg * dVth_dVd; dVaux_dVb = -dVgs_eff_dVg * dVth_dVb; } @@ -2539,12 +2539,12 @@ for (; model != NULL; model = model->BSIM4nextModel) dT2_dVd = Vgs_eff * dVaux_dVd; dT2_dVb = Vgs_eff * dVaux_dVb; - T11 = pParam->BSIM4Aechvb; - T12 = pParam->BSIM4Bechvb; - T3 = pParam->BSIM4aigc * pParam->BSIM4cigc - - pParam->BSIM4bigc; - T4 = pParam->BSIM4bigc * pParam->BSIM4cigc; - T5 = T12 * (pParam->BSIM4aigc + T3 * Voxdepinv + T11 = pParam->BSIM4v7Aechvb; + T12 = pParam->BSIM4v7Bechvb; + T3 = pParam->BSIM4v7aigc * pParam->BSIM4v7cigc + - pParam->BSIM4v7bigc; + T4 = pParam->BSIM4v7bigc * pParam->BSIM4v7cigc; + T5 = T12 * (pParam->BSIM4v7aigc + T3 * Voxdepinv - T4 * Voxdepinv * Voxdepinv); if (T5 > EXP_THRESHOLD) @@ -2568,13 +2568,13 @@ for (; model != NULL; model = model->BSIM4nextModel) dIgc_dVd = T11 * (T2 * dT6_dVd + T6 * dT2_dVd); dIgc_dVb = T11 * (T2 * dT6_dVb + T6 * dT2_dVb); - if (model->BSIM4pigcdGiven) - { Pigcd = pParam->BSIM4pigcd; + if (model->BSIM4v7pigcdGiven) + { Pigcd = pParam->BSIM4v7pigcd; dPigcd_dVg = dPigcd_dVd = dPigcd_dVb = 0.0; } else - { /* T11 = pParam->BSIM4Bechvb * toxe; v4.7 */ - T11 = -pParam->BSIM4Bechvb; + { /* T11 = pParam->BSIM4v7Bechvb * toxe; v4.7 */ + T11 = -pParam->BSIM4v7Bechvb; T12 = Vgsteff + 1.0e-20; T13 = T11 / T12 / T12; T14 = -T13 / T12; @@ -2637,27 +2637,27 @@ for (; model != NULL; model = model->BSIM4nextModel) dIgcd_dVd = dIgc_dVd * T10 + Igc * dT10_dVd; dIgcd_dVb = dIgc_dVb * T10 + Igc * dT10_dVb; - here->BSIM4Igcs = Igcs; - here->BSIM4gIgcsg = dIgcs_dVg; - here->BSIM4gIgcsd = dIgcs_dVd; - here->BSIM4gIgcsb = dIgcs_dVb * dVbseff_dVb; - here->BSIM4Igcd = Igcd; - here->BSIM4gIgcdg = dIgcd_dVg; - here->BSIM4gIgcdd = dIgcd_dVd; - here->BSIM4gIgcdb = dIgcd_dVb * dVbseff_dVb; + here->BSIM4v7Igcs = Igcs; + here->BSIM4v7gIgcsg = dIgcs_dVg; + here->BSIM4v7gIgcsd = dIgcs_dVd; + here->BSIM4v7gIgcsb = dIgcs_dVb * dVbseff_dVb; + here->BSIM4v7Igcd = Igcd; + here->BSIM4v7gIgcdg = dIgcd_dVg; + here->BSIM4v7gIgcdd = dIgcd_dVd; + here->BSIM4v7gIgcdb = dIgcd_dVb * dVbseff_dVb; - T0 = vgs - (pParam->BSIM4vfbsd + pParam->BSIM4vfbsdoff); + T0 = vgs - (pParam->BSIM4v7vfbsd + pParam->BSIM4v7vfbsdoff); vgs_eff = sqrt(T0 * T0 + 1.0e-4); dvgs_eff_dvg = T0 / vgs_eff; T2 = vgs * vgs_eff; dT2_dVg = vgs * dvgs_eff_dvg + vgs_eff; - T11 = pParam->BSIM4AechvbEdgeS; - T12 = pParam->BSIM4BechvbEdge; - T3 = pParam->BSIM4aigs * pParam->BSIM4cigs - - pParam->BSIM4bigs; - T4 = pParam->BSIM4bigs * pParam->BSIM4cigs; - T5 = T12 * (pParam->BSIM4aigs + T3 * vgs_eff + T11 = pParam->BSIM4v7AechvbEdgeS; + T12 = pParam->BSIM4v7BechvbEdge; + T3 = pParam->BSIM4v7aigs * pParam->BSIM4v7cigs + - pParam->BSIM4v7bigs; + T4 = pParam->BSIM4v7bigs * pParam->BSIM4v7cigs; + T5 = T12 * (pParam->BSIM4v7aigs + T3 * vgs_eff - T4 * vgs_eff * vgs_eff); if (T5 > EXP_THRESHOLD) { T6 = MAX_EXP; @@ -2677,17 +2677,17 @@ for (; model != NULL; model = model->BSIM4nextModel) dIgs_dVs = -dIgs_dVg; - T0 = vgd - (pParam->BSIM4vfbsd + pParam->BSIM4vfbsdoff); + T0 = vgd - (pParam->BSIM4v7vfbsd + pParam->BSIM4v7vfbsdoff); vgd_eff = sqrt(T0 * T0 + 1.0e-4); dvgd_eff_dvg = T0 / vgd_eff; T2 = vgd * vgd_eff; dT2_dVg = vgd * dvgd_eff_dvg + vgd_eff; - T11 = pParam->BSIM4AechvbEdgeD; - T3 = pParam->BSIM4aigd * pParam->BSIM4cigd - - pParam->BSIM4bigd; - T4 = pParam->BSIM4bigd * pParam->BSIM4cigd; - T5 = T12 * (pParam->BSIM4aigd + T3 * vgd_eff + T11 = pParam->BSIM4v7AechvbEdgeD; + T3 = pParam->BSIM4v7aigd * pParam->BSIM4v7cigd + - pParam->BSIM4v7bigd; + T4 = pParam->BSIM4v7bigd * pParam->BSIM4v7cigd; + T5 = T12 * (pParam->BSIM4v7aigd + T3 * vgd_eff - T4 * vgd_eff * vgd_eff); if (T5 > EXP_THRESHOLD) { T6 = MAX_EXP; @@ -2706,24 +2706,24 @@ for (; model != NULL; model = model->BSIM4nextModel) dIgd_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg); dIgd_dVd = -dIgd_dVg; - here->BSIM4Igs = Igs; - here->BSIM4gIgsg = dIgs_dVg; - here->BSIM4gIgss = dIgs_dVs; - here->BSIM4Igd = Igd; - here->BSIM4gIgdg = dIgd_dVg; - here->BSIM4gIgdd = dIgd_dVd; + here->BSIM4v7Igs = Igs; + here->BSIM4v7gIgsg = dIgs_dVg; + here->BSIM4v7gIgss = dIgs_dVs; + here->BSIM4v7Igd = Igd; + here->BSIM4v7gIgdg = dIgd_dVg; + here->BSIM4v7gIgdd = dIgd_dVd; } else - { here->BSIM4Igcs = here->BSIM4gIgcsg = here->BSIM4gIgcsd - = here->BSIM4gIgcsb = 0.0; - here->BSIM4Igcd = here->BSIM4gIgcdg = here->BSIM4gIgcdd - = here->BSIM4gIgcdb = 0.0; - here->BSIM4Igs = here->BSIM4gIgsg = here->BSIM4gIgss = 0.0; - here->BSIM4Igd = here->BSIM4gIgdg = here->BSIM4gIgdd = 0.0; + { here->BSIM4v7Igcs = here->BSIM4v7gIgcsg = here->BSIM4v7gIgcsd + = here->BSIM4v7gIgcsb = 0.0; + here->BSIM4v7Igcd = here->BSIM4v7gIgcdg = here->BSIM4v7gIgcdd + = here->BSIM4v7gIgcdb = 0.0; + here->BSIM4v7Igs = here->BSIM4v7gIgsg = here->BSIM4v7gIgss = 0.0; + here->BSIM4v7Igd = here->BSIM4v7gIgdg = here->BSIM4v7gIgdd = 0.0; } - if (model->BSIM4igbMod) - { T0 = tmp * pParam->BSIM4nigbacc; + if (model->BSIM4v7igbMod) + { T0 = tmp * pParam->BSIM4v7nigbacc; T1 = -Vgs_eff + Vbseff + Vfb; VxNVt = T1 / T0; if (VxNVt > EXP_THRESHOLD) @@ -2746,13 +2746,13 @@ for (; model != NULL; model = model->BSIM4nextModel) dT2_dVg = dVgs_eff_dVg * Vaux + (Vgs_eff - Vbseff) * dVaux_dVg; dT2_dVb = -Vaux + (Vgs_eff - Vbseff) * dVaux_dVb; - T11 = 4.97232e-7 * pParam->BSIM4weff - * pParam->BSIM4leff * pParam->BSIM4ToxRatio; + T11 = 4.97232e-7 * pParam->BSIM4v7weff + * pParam->BSIM4v7leff * pParam->BSIM4v7ToxRatio; T12 = -7.45669e11 * toxe; - T3 = pParam->BSIM4aigbacc * pParam->BSIM4cigbacc - - pParam->BSIM4bigbacc; - T4 = pParam->BSIM4bigbacc * pParam->BSIM4cigbacc; - T5 = T12 * (pParam->BSIM4aigbacc + T3 * Voxacc + T3 = pParam->BSIM4v7aigbacc * pParam->BSIM4v7cigbacc + - pParam->BSIM4v7bigbacc; + T4 = pParam->BSIM4v7bigbacc * pParam->BSIM4v7cigbacc; + T5 = T12 * (pParam->BSIM4v7aigbacc + T3 * Voxacc - T4 * Voxacc * Voxacc); if (T5 > EXP_THRESHOLD) @@ -2775,8 +2775,8 @@ for (; model != NULL; model = model->BSIM4nextModel) dIgbacc_dVb = T11 * (T2 * dT6_dVb + T6 * dT2_dVb); - T0 = tmp * pParam->BSIM4nigbinv; - T1 = Voxdepinv - pParam->BSIM4eigbinv; + T0 = tmp * pParam->BSIM4v7nigbinv; + T1 = Voxdepinv - pParam->BSIM4v7eigbinv; VxNVt = T1 / T0; if (VxNVt > EXP_THRESHOLD) { Vaux = T1; @@ -2804,10 +2804,10 @@ for (; model != NULL; model = model->BSIM4nextModel) T11 *= 0.75610; T12 *= 1.31724; - T3 = pParam->BSIM4aigbinv * pParam->BSIM4cigbinv - - pParam->BSIM4bigbinv; - T4 = pParam->BSIM4bigbinv * pParam->BSIM4cigbinv; - T5 = T12 * (pParam->BSIM4aigbinv + T3 * Voxdepinv + T3 = pParam->BSIM4v7aigbinv * pParam->BSIM4v7cigbinv + - pParam->BSIM4v7bigbinv; + T4 = pParam->BSIM4v7bigbinv * pParam->BSIM4v7cigbinv; + T5 = T12 * (pParam->BSIM4v7aigbinv + T3 * Voxdepinv - T4 * Voxdepinv * Voxdepinv); if (T5 > EXP_THRESHOLD) @@ -2831,77 +2831,77 @@ for (; model != NULL; model = model->BSIM4nextModel) dIgbinv_dVd = T11 * (T2 * dT6_dVd + T6 * dT2_dVd); dIgbinv_dVb = T11 * (T2 * dT6_dVb + T6 * dT2_dVb); - here->BSIM4Igb = Igbinv + Igbacc; - here->BSIM4gIgbg = dIgbinv_dVg + dIgbacc_dVg; - here->BSIM4gIgbd = dIgbinv_dVd; - here->BSIM4gIgbb = (dIgbinv_dVb + dIgbacc_dVb) * dVbseff_dVb; + here->BSIM4v7Igb = Igbinv + Igbacc; + here->BSIM4v7gIgbg = dIgbinv_dVg + dIgbacc_dVg; + here->BSIM4v7gIgbd = dIgbinv_dVd; + here->BSIM4v7gIgbb = (dIgbinv_dVb + dIgbacc_dVb) * dVbseff_dVb; } else - { here->BSIM4Igb = here->BSIM4gIgbg = here->BSIM4gIgbd - = here->BSIM4gIgbs = here->BSIM4gIgbb = 0.0; + { here->BSIM4v7Igb = here->BSIM4v7gIgbg = here->BSIM4v7gIgbd + = here->BSIM4v7gIgbs = here->BSIM4v7gIgbb = 0.0; } /* End of Gate current */ - if (here->BSIM4nf != 1.0) - { cdrain *= here->BSIM4nf; - here->BSIM4gds *= here->BSIM4nf; - here->BSIM4gm *= here->BSIM4nf; - here->BSIM4gmbs *= here->BSIM4nf; - here->BSIM4IdovVds *= here->BSIM4nf; + if (here->BSIM4v7nf != 1.0) + { cdrain *= here->BSIM4v7nf; + here->BSIM4v7gds *= here->BSIM4v7nf; + here->BSIM4v7gm *= here->BSIM4v7nf; + here->BSIM4v7gmbs *= here->BSIM4v7nf; + here->BSIM4v7IdovVds *= here->BSIM4v7nf; - here->BSIM4gbbs *= here->BSIM4nf; - here->BSIM4gbgs *= here->BSIM4nf; - here->BSIM4gbds *= here->BSIM4nf; - here->BSIM4csub *= here->BSIM4nf; + here->BSIM4v7gbbs *= here->BSIM4v7nf; + here->BSIM4v7gbgs *= here->BSIM4v7nf; + here->BSIM4v7gbds *= here->BSIM4v7nf; + here->BSIM4v7csub *= here->BSIM4v7nf; - here->BSIM4Igidl *= here->BSIM4nf; - here->BSIM4ggidld *= here->BSIM4nf; - here->BSIM4ggidlg *= here->BSIM4nf; - here->BSIM4ggidlb *= here->BSIM4nf; + here->BSIM4v7Igidl *= here->BSIM4v7nf; + here->BSIM4v7ggidld *= here->BSIM4v7nf; + here->BSIM4v7ggidlg *= here->BSIM4v7nf; + here->BSIM4v7ggidlb *= here->BSIM4v7nf; - here->BSIM4Igisl *= here->BSIM4nf; - here->BSIM4ggisls *= here->BSIM4nf; - here->BSIM4ggislg *= here->BSIM4nf; - here->BSIM4ggislb *= here->BSIM4nf; + here->BSIM4v7Igisl *= here->BSIM4v7nf; + here->BSIM4v7ggisls *= here->BSIM4v7nf; + here->BSIM4v7ggislg *= here->BSIM4v7nf; + here->BSIM4v7ggislb *= here->BSIM4v7nf; - here->BSIM4Igcs *= here->BSIM4nf; - here->BSIM4gIgcsg *= here->BSIM4nf; - here->BSIM4gIgcsd *= here->BSIM4nf; - here->BSIM4gIgcsb *= here->BSIM4nf; - here->BSIM4Igcd *= here->BSIM4nf; - here->BSIM4gIgcdg *= here->BSIM4nf; - here->BSIM4gIgcdd *= here->BSIM4nf; - here->BSIM4gIgcdb *= here->BSIM4nf; + here->BSIM4v7Igcs *= here->BSIM4v7nf; + here->BSIM4v7gIgcsg *= here->BSIM4v7nf; + here->BSIM4v7gIgcsd *= here->BSIM4v7nf; + here->BSIM4v7gIgcsb *= here->BSIM4v7nf; + here->BSIM4v7Igcd *= here->BSIM4v7nf; + here->BSIM4v7gIgcdg *= here->BSIM4v7nf; + here->BSIM4v7gIgcdd *= here->BSIM4v7nf; + here->BSIM4v7gIgcdb *= here->BSIM4v7nf; - here->BSIM4Igs *= here->BSIM4nf; - here->BSIM4gIgsg *= here->BSIM4nf; - here->BSIM4gIgss *= here->BSIM4nf; - here->BSIM4Igd *= here->BSIM4nf; - here->BSIM4gIgdg *= here->BSIM4nf; - here->BSIM4gIgdd *= here->BSIM4nf; + here->BSIM4v7Igs *= here->BSIM4v7nf; + here->BSIM4v7gIgsg *= here->BSIM4v7nf; + here->BSIM4v7gIgss *= here->BSIM4v7nf; + here->BSIM4v7Igd *= here->BSIM4v7nf; + here->BSIM4v7gIgdg *= here->BSIM4v7nf; + here->BSIM4v7gIgdd *= here->BSIM4v7nf; - here->BSIM4Igb *= here->BSIM4nf; - here->BSIM4gIgbg *= here->BSIM4nf; - here->BSIM4gIgbd *= here->BSIM4nf; - here->BSIM4gIgbb *= here->BSIM4nf; + here->BSIM4v7Igb *= here->BSIM4v7nf; + here->BSIM4v7gIgbg *= here->BSIM4v7nf; + here->BSIM4v7gIgbd *= here->BSIM4v7nf; + here->BSIM4v7gIgbb *= here->BSIM4v7nf; } - here->BSIM4ggidls = -(here->BSIM4ggidld + here->BSIM4ggidlg - + here->BSIM4ggidlb); - here->BSIM4ggisld = -(here->BSIM4ggisls + here->BSIM4ggislg - + here->BSIM4ggislb); - here->BSIM4gIgbs = -(here->BSIM4gIgbg + here->BSIM4gIgbd - + here->BSIM4gIgbb); - here->BSIM4gIgcss = -(here->BSIM4gIgcsg + here->BSIM4gIgcsd - + here->BSIM4gIgcsb); - here->BSIM4gIgcds = -(here->BSIM4gIgcdg + here->BSIM4gIgcdd - + here->BSIM4gIgcdb); - here->BSIM4cd = cdrain; + here->BSIM4v7ggidls = -(here->BSIM4v7ggidld + here->BSIM4v7ggidlg + + here->BSIM4v7ggidlb); + here->BSIM4v7ggisld = -(here->BSIM4v7ggisls + here->BSIM4v7ggislg + + here->BSIM4v7ggislb); + here->BSIM4v7gIgbs = -(here->BSIM4v7gIgbg + here->BSIM4v7gIgbd + + here->BSIM4v7gIgbb); + here->BSIM4v7gIgcss = -(here->BSIM4v7gIgcsg + here->BSIM4v7gIgcsd + + here->BSIM4v7gIgcsb); + here->BSIM4v7gIgcds = -(here->BSIM4v7gIgcdg + here->BSIM4v7gIgcdd + + here->BSIM4v7gIgcdb); + here->BSIM4v7cd = cdrain; /* Calculations for noise analysis */ - if (model->BSIM4tnoiMod == 0) - { Abulk = Abulk0 * pParam->BSIM4abulkCVfactor; + if (model->BSIM4v7tnoiMod == 0) + { Abulk = Abulk0 * pParam->BSIM4v7abulkCVfactor; Vdsat = Vgsteff / Abulk; T0 = Vdsat - Vds - DELTA_4; T1 = sqrt(T0 * T0 + 4.0 * DELTA_4 * Vdsat); @@ -2920,51 +2920,51 @@ for (; model != NULL; model = model->BSIM4nextModel) T1 = 12.0 * (Vgsteff - 0.5 * T0 + 1.0e-20); T2 = Vdseff / T1; T3 = T0 * T2; - here->BSIM4qinv = Coxeff * pParam->BSIM4weffCV * here->BSIM4nf - * pParam->BSIM4leffCV + here->BSIM4v7qinv = Coxeff * pParam->BSIM4v7weffCV * here->BSIM4v7nf + * pParam->BSIM4v7leffCV * (Vgsteff - 0.5 * T0 + Abulk * T3); } - else if(model->BSIM4tnoiMod == 2) + else if(model->BSIM4v7tnoiMod == 2) { - here->BSIM4noiGd0 = here->BSIM4nf * beta * Vgsteff / (1.0 + gche * Rds); + here->BSIM4v7noiGd0 = here->BSIM4v7nf * beta * Vgsteff / (1.0 + gche * Rds); } /* - * BSIM4 C-V begins + * BSIM4v7 C-V begins */ - if ((model->BSIM4xpart < 0) || (!ChargeComputationNeeded)) + if ((model->BSIM4v7xpart < 0) || (!ChargeComputationNeeded)) { qgate = qdrn = qsrc = qbulk = 0.0; - here->BSIM4cggb = here->BSIM4cgsb = here->BSIM4cgdb = 0.0; - here->BSIM4cdgb = here->BSIM4cdsb = here->BSIM4cddb = 0.0; - here->BSIM4cbgb = here->BSIM4cbsb = here->BSIM4cbdb = 0.0; - here->BSIM4csgb = here->BSIM4cssb = here->BSIM4csdb = 0.0; - here->BSIM4cgbb = here->BSIM4csbb = here->BSIM4cdbb = here->BSIM4cbbb = 0.0; - here->BSIM4cqdb = here->BSIM4cqsb = here->BSIM4cqgb - = here->BSIM4cqbb = 0.0; - here->BSIM4gtau = 0.0; + here->BSIM4v7cggb = here->BSIM4v7cgsb = here->BSIM4v7cgdb = 0.0; + here->BSIM4v7cdgb = here->BSIM4v7cdsb = here->BSIM4v7cddb = 0.0; + here->BSIM4v7cbgb = here->BSIM4v7cbsb = here->BSIM4v7cbdb = 0.0; + here->BSIM4v7csgb = here->BSIM4v7cssb = here->BSIM4v7csdb = 0.0; + here->BSIM4v7cgbb = here->BSIM4v7csbb = here->BSIM4v7cdbb = here->BSIM4v7cbbb = 0.0; + here->BSIM4v7cqdb = here->BSIM4v7cqsb = here->BSIM4v7cqgb + = here->BSIM4v7cqbb = 0.0; + here->BSIM4v7gtau = 0.0; goto finished; } - else if (model->BSIM4capMod == 0) + else if (model->BSIM4v7capMod == 0) { if (Vbseff < 0.0) { VbseffCV = Vbs; /*4.6.2*/ dVbseffCV_dVb = 1.0; } else - { VbseffCV = pParam->BSIM4phi - Phis; + { VbseffCV = pParam->BSIM4v7phi - Phis; dVbseffCV_dVb = -dPhis_dVb * dVbseff_dVb; /*4.6.2*/ } - Vfb = pParam->BSIM4vfbcv; - Vth = Vfb + pParam->BSIM4phi + pParam->BSIM4k1ox * sqrtPhis; + Vfb = pParam->BSIM4v7vfbcv; + Vth = Vfb + pParam->BSIM4v7phi + pParam->BSIM4v7k1ox * sqrtPhis; Vgst = Vgs_eff - Vth; - dVth_dVb = pParam->BSIM4k1ox * dsqrtPhis_dVb *dVbseff_dVb; /*4.6.2*/ + dVth_dVb = pParam->BSIM4v7k1ox * dsqrtPhis_dVb *dVbseff_dVb; /*4.6.2*/ dVgst_dVb = -dVth_dVb; dVgst_dVg = dVgs_eff_dVg; - CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV - * pParam->BSIM4leffCV * here->BSIM4nf; + CoxWL = model->BSIM4v7coxe * pParam->BSIM4v7weffCV + * pParam->BSIM4v7leffCV * here->BSIM4v7nf; Arg1 = Vgs_eff - VbseffCV - Vfb; if (Arg1 <= 0.0) @@ -2972,75 +2972,75 @@ for (; model != NULL; model = model->BSIM4nextModel) qbulk = -qgate; qdrn = 0.0; - here->BSIM4cggb = CoxWL * dVgs_eff_dVg; - here->BSIM4cgdb = 0.0; - here->BSIM4cgsb = CoxWL * (dVbseffCV_dVb - dVgs_eff_dVg); + here->BSIM4v7cggb = CoxWL * dVgs_eff_dVg; + here->BSIM4v7cgdb = 0.0; + here->BSIM4v7cgsb = CoxWL * (dVbseffCV_dVb - dVgs_eff_dVg); - here->BSIM4cdgb = 0.0; - here->BSIM4cddb = 0.0; - here->BSIM4cdsb = 0.0; + here->BSIM4v7cdgb = 0.0; + here->BSIM4v7cddb = 0.0; + here->BSIM4v7cdsb = 0.0; - here->BSIM4cbgb = -CoxWL * dVgs_eff_dVg; - here->BSIM4cbdb = 0.0; - here->BSIM4cbsb = -here->BSIM4cgsb; + here->BSIM4v7cbgb = -CoxWL * dVgs_eff_dVg; + here->BSIM4v7cbdb = 0.0; + here->BSIM4v7cbsb = -here->BSIM4v7cgsb; } /* Arg1 <= 0.0, end of accumulation */ else if (Vgst <= 0.0) - { T1 = 0.5 * pParam->BSIM4k1ox; + { T1 = 0.5 * pParam->BSIM4v7k1ox; T2 = sqrt(T1 * T1 + Arg1); - qgate = CoxWL * pParam->BSIM4k1ox * (T2 - T1); + qgate = CoxWL * pParam->BSIM4v7k1ox * (T2 - T1); qbulk = -qgate; qdrn = 0.0; T0 = CoxWL * T1 / T2; - here->BSIM4cggb = T0 * dVgs_eff_dVg; - here->BSIM4cgdb = 0.0; - here->BSIM4cgsb = T0 * (dVbseffCV_dVb - dVgs_eff_dVg); + here->BSIM4v7cggb = T0 * dVgs_eff_dVg; + here->BSIM4v7cgdb = 0.0; + here->BSIM4v7cgsb = T0 * (dVbseffCV_dVb - dVgs_eff_dVg); - here->BSIM4cdgb = 0.0; - here->BSIM4cddb = 0.0; - here->BSIM4cdsb = 0.0; + here->BSIM4v7cdgb = 0.0; + here->BSIM4v7cddb = 0.0; + here->BSIM4v7cdsb = 0.0; - here->BSIM4cbgb = -here->BSIM4cggb; - here->BSIM4cbdb = 0.0; - here->BSIM4cbsb = -here->BSIM4cgsb; + here->BSIM4v7cbgb = -here->BSIM4v7cggb; + here->BSIM4v7cbdb = 0.0; + here->BSIM4v7cbsb = -here->BSIM4v7cgsb; } /* Vgst <= 0.0, end of depletion */ else { One_Third_CoxWL = CoxWL / 3.0; Two_Third_CoxWL = 2.0 * One_Third_CoxWL; - AbulkCV = Abulk0 * pParam->BSIM4abulkCVfactor; - dAbulkCV_dVb = pParam->BSIM4abulkCVfactor * dAbulk0_dVb*dVbseff_dVb; + AbulkCV = Abulk0 * pParam->BSIM4v7abulkCVfactor; + dAbulkCV_dVb = pParam->BSIM4v7abulkCVfactor * dAbulk0_dVb*dVbseff_dVb; dVdsat_dVg = 1.0 / AbulkCV; /*4.6.2*/ Vdsat = Vgst * dVdsat_dVg; dVdsat_dVb = - (Vdsat * dAbulkCV_dVb + dVth_dVb)* dVdsat_dVg; - if (model->BSIM4xpart > 0.5) + if (model->BSIM4v7xpart > 0.5) { /* 0/100 Charge partition model */ if (Vdsat <= Vds) { /* saturation region */ T1 = Vdsat / 3.0; qgate = CoxWL * (Vgs_eff - Vfb - - pParam->BSIM4phi - T1); + - pParam->BSIM4v7phi - T1); T2 = -Two_Third_CoxWL * Vgst; qbulk = -(qgate + T2); qdrn = 0.0; - here->BSIM4cggb = One_Third_CoxWL * (3.0 + here->BSIM4v7cggb = One_Third_CoxWL * (3.0 - dVdsat_dVg) * dVgs_eff_dVg; T2 = -One_Third_CoxWL * dVdsat_dVb; - here->BSIM4cgsb = -(here->BSIM4cggb + T2); - here->BSIM4cgdb = 0.0; + here->BSIM4v7cgsb = -(here->BSIM4v7cggb + T2); + here->BSIM4v7cgdb = 0.0; - here->BSIM4cdgb = 0.0; - here->BSIM4cddb = 0.0; - here->BSIM4cdsb = 0.0; + here->BSIM4v7cdgb = 0.0; + here->BSIM4v7cddb = 0.0; + here->BSIM4v7cdsb = 0.0; - here->BSIM4cbgb = -(here->BSIM4cggb + here->BSIM4v7cbgb = -(here->BSIM4v7cggb - Two_Third_CoxWL * dVgs_eff_dVg); T3 = -(T2 + Two_Third_CoxWL * dVth_dVb); - here->BSIM4cbsb = -(here->BSIM4cbgb + T3); - here->BSIM4cbdb = 0.0; + here->BSIM4v7cbsb = -(here->BSIM4v7cbgb + T3); + here->BSIM4v7cbdb = 0.0; } else { /* linear region */ @@ -3053,30 +3053,30 @@ for (; model != NULL; model = model->BSIM4nextModel) T7 = 2.0 * Vds - T1 - 3.0 * T3; T8 = T3 - T1 - 2.0 * Vds; qgate = CoxWL * (Vgs_eff - Vfb - - pParam->BSIM4phi - 0.5 * (Vds - T3)); + - pParam->BSIM4v7phi - 0.5 * (Vds - T3)); T10 = T4 * T8; qdrn = T4 * T7; qbulk = -(qgate + qdrn + T10); T5 = T3 / T1; - here->BSIM4cggb = CoxWL * (1.0 - T5 * dVdsat_dVg) + here->BSIM4v7cggb = CoxWL * (1.0 - T5 * dVdsat_dVg) * dVgs_eff_dVg; T11 = -CoxWL * T5 * dVdsat_dVb; - here->BSIM4cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5); - here->BSIM4cgsb = -(here->BSIM4cggb + T11 - + here->BSIM4cgdb); + here->BSIM4v7cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5); + here->BSIM4v7cgsb = -(here->BSIM4v7cggb + T11 + + here->BSIM4v7cgdb); T6 = 1.0 / Vdsat; dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg); dAlphaz_dVb = -T6 * (dVth_dVb + Alphaz * dVdsat_dVb); T7 = T9 * T7; T8 = T9 * T8; T9 = 2.0 * T4 * (1.0 - 3.0 * T5); - here->BSIM4cdgb = (T7 * dAlphaz_dVg - T9 + here->BSIM4v7cdgb = (T7 * dAlphaz_dVg - T9 * dVdsat_dVg) * dVgs_eff_dVg; T12 = T7 * dAlphaz_dVb - T9 * dVdsat_dVb; - here->BSIM4cddb = T4 * (3.0 - 6.0 * T2 - 3.0 * T5); - here->BSIM4cdsb = -(here->BSIM4cdgb + T12 - + here->BSIM4cddb); + here->BSIM4v7cddb = T4 * (3.0 - 6.0 * T2 - 3.0 * T5); + here->BSIM4v7cdsb = -(here->BSIM4v7cdgb + T12 + + here->BSIM4v7cddb); T9 = 2.0 * T4 * (1.0 + T5); T10 = (T8 * dAlphaz_dVg - T9 * dVdsat_dVg) @@ -3085,42 +3085,42 @@ for (; model != NULL; model = model->BSIM4nextModel) T12 = T4 * (2.0 * T2 + T5 - 1.0); T0 = -(T10 + T11 + T12); - here->BSIM4cbgb = -(here->BSIM4cggb - + here->BSIM4cdgb + T10); - here->BSIM4cbdb = -(here->BSIM4cgdb - + here->BSIM4cddb + T12); - here->BSIM4cbsb = -(here->BSIM4cgsb - + here->BSIM4cdsb + T0); + here->BSIM4v7cbgb = -(here->BSIM4v7cggb + + here->BSIM4v7cdgb + T10); + here->BSIM4v7cbdb = -(here->BSIM4v7cgdb + + here->BSIM4v7cddb + T12); + here->BSIM4v7cbsb = -(here->BSIM4v7cgsb + + here->BSIM4v7cdsb + T0); } } - else if (model->BSIM4xpart < 0.5) + else if (model->BSIM4v7xpart < 0.5) { /* 40/60 Charge partition model */ if (Vds >= Vdsat) { /* saturation region */ T1 = Vdsat / 3.0; qgate = CoxWL * (Vgs_eff - Vfb - - pParam->BSIM4phi - T1); + - pParam->BSIM4v7phi - T1); T2 = -Two_Third_CoxWL * Vgst; qbulk = -(qgate + T2); qdrn = 0.4 * T2; - here->BSIM4cggb = One_Third_CoxWL * (3.0 + here->BSIM4v7cggb = One_Third_CoxWL * (3.0 - dVdsat_dVg) * dVgs_eff_dVg; T2 = -One_Third_CoxWL * dVdsat_dVb; - here->BSIM4cgsb = -(here->BSIM4cggb + T2); - here->BSIM4cgdb = 0.0; + here->BSIM4v7cgsb = -(here->BSIM4v7cggb + T2); + here->BSIM4v7cgdb = 0.0; T3 = 0.4 * Two_Third_CoxWL; - here->BSIM4cdgb = -T3 * dVgs_eff_dVg; - here->BSIM4cddb = 0.0; + here->BSIM4v7cdgb = -T3 * dVgs_eff_dVg; + here->BSIM4v7cddb = 0.0; T4 = T3 * dVth_dVb; - here->BSIM4cdsb = -(T4 + here->BSIM4cdgb); + here->BSIM4v7cdsb = -(T4 + here->BSIM4v7cdgb); - here->BSIM4cbgb = -(here->BSIM4cggb + here->BSIM4v7cbgb = -(here->BSIM4v7cggb - Two_Third_CoxWL * dVgs_eff_dVg); T3 = -(T2 + Two_Third_CoxWL * dVth_dVb); - here->BSIM4cbsb = -(here->BSIM4cbgb + T3); - here->BSIM4cbdb = 0.0; + here->BSIM4v7cbsb = -(here->BSIM4v7cbgb + T3); + here->BSIM4v7cbdb = 0.0; } else { /* linear region */ @@ -3130,16 +3130,16 @@ for (; model != NULL; model = model->BSIM4nextModel) T3 = T2 * Vds; T9 = 0.25 * CoxWL; T4 = T9 * Alphaz; - qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM4phi + qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM4v7phi - 0.5 * (Vds - T3)); T5 = T3 / T1; - here->BSIM4cggb = CoxWL * (1.0 - T5 * dVdsat_dVg) + here->BSIM4v7cggb = CoxWL * (1.0 - T5 * dVdsat_dVg) * dVgs_eff_dVg; tmp = -CoxWL * T5 * dVdsat_dVb; - here->BSIM4cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5); - here->BSIM4cgsb = -(here->BSIM4cggb - + here->BSIM4cgdb + tmp); + here->BSIM4v7cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5); + here->BSIM4v7cgsb = -(here->BSIM4v7cggb + + here->BSIM4v7cgdb + tmp); T6 = 1.0 / Vdsat; dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg); @@ -3155,32 +3155,32 @@ for (; model != NULL; model = model->BSIM4nextModel) tmp1 = T4 * (2.0 - 4.0 * tmp * T6 + T8 * (16.0 * Vdsat - 6.0 * Vds)); - here->BSIM4cdgb = (T7 * dAlphaz_dVg - tmp1 + here->BSIM4v7cdgb = (T7 * dAlphaz_dVg - tmp1 * dVdsat_dVg) * dVgs_eff_dVg; T10 = T7 * dAlphaz_dVb - tmp1 * dVdsat_dVb; - here->BSIM4cddb = T4 * (2.0 - (1.0 / (3.0 * T1 + here->BSIM4v7cddb = T4 * (2.0 - (1.0 / (3.0 * T1 * T1) + 2.0 * tmp) * T6 + T8 * (6.0 * Vdsat - 2.4 * Vds)); - here->BSIM4cdsb = -(here->BSIM4cdgb - + T10 + here->BSIM4cddb); + here->BSIM4v7cdsb = -(here->BSIM4v7cdgb + + T10 + here->BSIM4v7cddb); T7 = 2.0 * (T1 + T3); qbulk = -(qgate - T4 * T7); T7 *= T9; T0 = 4.0 * T4 * (1.0 - T5); T12 = (-T7 * dAlphaz_dVg - T0 * dVdsat_dVg) * dVgs_eff_dVg - - here->BSIM4cdgb; /*4.6.2*/ + - here->BSIM4v7cdgb; /*4.6.2*/ T11 = -T7 * dAlphaz_dVb - T10 - T0 * dVdsat_dVb; T10 = -4.0 * T4 * (T2 - 0.5 + 0.5 * T5) - - here->BSIM4cddb; + - here->BSIM4v7cddb; tmp = -(T10 + T11 + T12); - here->BSIM4cbgb = -(here->BSIM4cggb - + here->BSIM4cdgb + T12); - here->BSIM4cbdb = -(here->BSIM4cgdb - + here->BSIM4cddb + T10); - here->BSIM4cbsb = -(here->BSIM4cgsb - + here->BSIM4cdsb + tmp); + here->BSIM4v7cbgb = -(here->BSIM4v7cggb + + here->BSIM4v7cdgb + T12); + here->BSIM4v7cbdb = -(here->BSIM4v7cgdb + + here->BSIM4v7cddb + T10); + here->BSIM4v7cbsb = -(here->BSIM4v7cgsb + + here->BSIM4v7cdsb + tmp); } } else @@ -3189,27 +3189,27 @@ for (; model != NULL; model = model->BSIM4nextModel) { /* saturation region */ T1 = Vdsat / 3.0; qgate = CoxWL * (Vgs_eff - Vfb - - pParam->BSIM4phi - T1); + - pParam->BSIM4v7phi - T1); T2 = -Two_Third_CoxWL * Vgst; qbulk = -(qgate + T2); qdrn = 0.5 * T2; - here->BSIM4cggb = One_Third_CoxWL * (3.0 + here->BSIM4v7cggb = One_Third_CoxWL * (3.0 - dVdsat_dVg) * dVgs_eff_dVg; T2 = -One_Third_CoxWL * dVdsat_dVb; - here->BSIM4cgsb = -(here->BSIM4cggb + T2); - here->BSIM4cgdb = 0.0; + here->BSIM4v7cgsb = -(here->BSIM4v7cggb + T2); + here->BSIM4v7cgdb = 0.0; - here->BSIM4cdgb = -One_Third_CoxWL * dVgs_eff_dVg; - here->BSIM4cddb = 0.0; + here->BSIM4v7cdgb = -One_Third_CoxWL * dVgs_eff_dVg; + here->BSIM4v7cddb = 0.0; T4 = One_Third_CoxWL * dVth_dVb; - here->BSIM4cdsb = -(T4 + here->BSIM4cdgb); + here->BSIM4v7cdsb = -(T4 + here->BSIM4v7cdgb); - here->BSIM4cbgb = -(here->BSIM4cggb + here->BSIM4v7cbgb = -(here->BSIM4v7cggb - Two_Third_CoxWL * dVgs_eff_dVg); T3 = -(T2 + Two_Third_CoxWL * dVth_dVb); - here->BSIM4cbsb = -(here->BSIM4cbgb + T3); - here->BSIM4cbdb = 0.0; + here->BSIM4v7cbsb = -(here->BSIM4v7cbgb + T3); + here->BSIM4v7cbdb = 0.0; } else { /* linear region */ @@ -3219,16 +3219,16 @@ for (; model != NULL; model = model->BSIM4nextModel) T3 = T2 * Vds; T9 = 0.25 * CoxWL; T4 = T9 * Alphaz; - qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM4phi + qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM4v7phi - 0.5 * (Vds - T3)); T5 = T3 / T1; - here->BSIM4cggb = CoxWL * (1.0 - T5 * dVdsat_dVg) + here->BSIM4v7cggb = CoxWL * (1.0 - T5 * dVdsat_dVg) * dVgs_eff_dVg; tmp = -CoxWL * T5 * dVdsat_dVb; - here->BSIM4cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5); - here->BSIM4cgsb = -(here->BSIM4cggb - + here->BSIM4cgdb + tmp); + here->BSIM4v7cgdb = CoxWL * (T2 - 0.5 + 0.5 * T5); + here->BSIM4v7cgsb = -(here->BSIM4v7cggb + + here->BSIM4v7cgdb + tmp); T6 = 1.0 / Vdsat; dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg); @@ -3240,19 +3240,19 @@ for (; model != NULL; model = model->BSIM4nextModel) T7 *= T9; T0 = T4 * (2.0 * T5 - 2.0); - here->BSIM4cdgb = (T0 * dVdsat_dVg - T7 + here->BSIM4v7cdgb = (T0 * dVdsat_dVg - T7 * dAlphaz_dVg) * dVgs_eff_dVg; T12 = T0 * dVdsat_dVb - T7 * dAlphaz_dVb; - here->BSIM4cddb = T4 * (1.0 - 2.0 * T2 - T5); - here->BSIM4cdsb = -(here->BSIM4cdgb + T12 - + here->BSIM4cddb); + here->BSIM4v7cddb = T4 * (1.0 - 2.0 * T2 - T5); + here->BSIM4v7cdsb = -(here->BSIM4v7cdgb + T12 + + here->BSIM4v7cddb); - here->BSIM4cbgb = -(here->BSIM4cggb - + 2.0 * here->BSIM4cdgb); - here->BSIM4cbdb = -(here->BSIM4cgdb - + 2.0 * here->BSIM4cddb); - here->BSIM4cbsb = -(here->BSIM4cgsb - + 2.0 * here->BSIM4cdsb); + here->BSIM4v7cbgb = -(here->BSIM4v7cggb + + 2.0 * here->BSIM4v7cdgb); + here->BSIM4v7cbdb = -(here->BSIM4v7cgdb + + 2.0 * here->BSIM4v7cddb); + here->BSIM4v7cbsb = -(here->BSIM4v7cgsb + + 2.0 * here->BSIM4v7cdsb); } /* end of linear region */ } /* end of 50/50 partition */ } /* end of inversion */ @@ -3263,21 +3263,21 @@ for (; model != NULL; model = model->BSIM4nextModel) dVbseffCV_dVb = 1.0; } else - { VbseffCV = pParam->BSIM4phi - Phis; + { VbseffCV = pParam->BSIM4v7phi - Phis; dVbseffCV_dVb = -dPhis_dVb; } - CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV - * pParam->BSIM4leffCV * here->BSIM4nf; + CoxWL = model->BSIM4v7coxe * pParam->BSIM4v7weffCV + * pParam->BSIM4v7leffCV * here->BSIM4v7nf; - if(model->BSIM4cvchargeMod == 0) + if(model->BSIM4v7cvchargeMod == 0) { /* Seperate VgsteffCV with noff and voffcv */ - noff = n * pParam->BSIM4noff; - dnoff_dVd = pParam->BSIM4noff * dn_dVd; - dnoff_dVb = pParam->BSIM4noff * dn_dVb; + noff = n * pParam->BSIM4v7noff; + dnoff_dVd = pParam->BSIM4v7noff * dn_dVd; + dnoff_dVb = pParam->BSIM4v7noff * dn_dVb; T0 = Vtm * noff; - voffcv = pParam->BSIM4voffcv; + voffcv = pParam->BSIM4v7voffcv; VgstNVt = (Vgst - voffcv) / T0; if (VgstNVt > EXP_THRESHOLD) @@ -3311,14 +3311,14 @@ for (; model != NULL; model = model->BSIM4nextModel) else { T0 = n * Vtm; - T1 = pParam->BSIM4mstarcv * Vgst; + T1 = pParam->BSIM4v7mstarcv * Vgst; T2 = T1 / T0; if (T2 > EXP_THRESHOLD) { T10 = T1; - dT10_dVg = pParam->BSIM4mstarcv * dVgs_eff_dVg; - dT10_dVd = -dVth_dVd * pParam->BSIM4mstarcv; - dT10_dVb = -dVth_dVb * pParam->BSIM4mstarcv; + dT10_dVg = pParam->BSIM4v7mstarcv * dVgs_eff_dVg; + dT10_dVd = -dVth_dVd * pParam->BSIM4v7mstarcv; + dT10_dVb = -dVth_dVb * pParam->BSIM4v7mstarcv; } else if (T2 < -EXP_THRESHOLD) { @@ -3333,26 +3333,26 @@ for (; model != NULL; model = model->BSIM4nextModel) ExpVgst = exp(T2); T3 = Vtm * log(1.0 + ExpVgst); T10 = n * T3; - dT10_dVg = pParam->BSIM4mstarcv * ExpVgst / (1.0 + ExpVgst); + dT10_dVg = pParam->BSIM4v7mstarcv * ExpVgst / (1.0 + ExpVgst); dT10_dVb = T3 * dn_dVb - dT10_dVg * (dVth_dVb + Vgst * dn_dVb / n); dT10_dVd = T3 * dn_dVd - dT10_dVg * (dVth_dVd + Vgst * dn_dVd / n); dT10_dVg *= dVgs_eff_dVg; } - T1 = pParam->BSIM4voffcbncv - (1.0 - pParam->BSIM4mstarcv) * Vgst; + T1 = pParam->BSIM4v7voffcbncv - (1.0 - pParam->BSIM4v7mstarcv) * Vgst; T2 = T1 / T0; if (T2 < -EXP_THRESHOLD) { - T3 = model->BSIM4coxe * MIN_EXP / pParam->BSIM4cdep0; - T9 = pParam->BSIM4mstarcv + T3 * n; + T3 = model->BSIM4v7coxe * MIN_EXP / pParam->BSIM4v7cdep0; + T9 = pParam->BSIM4v7mstarcv + T3 * n; dT9_dVg = 0.0; dT9_dVd = dn_dVd * T3; dT9_dVb = dn_dVb * T3; } else if (T2 > EXP_THRESHOLD) { - T3 = model->BSIM4coxe * MAX_EXP / pParam->BSIM4cdep0; - T9 = pParam->BSIM4mstarcv + T3 * n; + T3 = model->BSIM4v7coxe * MAX_EXP / pParam->BSIM4v7cdep0; + T9 = pParam->BSIM4v7mstarcv + T3 * n; dT9_dVg = 0.0; dT9_dVd = dn_dVd * T3; dT9_dVb = dn_dVb * T3; @@ -3360,11 +3360,11 @@ for (; model != NULL; model = model->BSIM4nextModel) else { ExpVgst = exp(T2); - T3 = model->BSIM4coxe / pParam->BSIM4cdep0; + T3 = model->BSIM4v7coxe / pParam->BSIM4v7cdep0; T4 = T3 * ExpVgst; T5 = T1 * T4 / T0; - T9 = pParam->BSIM4mstarcv + n * T4; - dT9_dVg = T3 * (pParam->BSIM4mstarcv - 1.0) * ExpVgst / Vtm; + T9 = pParam->BSIM4v7mstarcv + n * T4; + dT9_dVg = T3 * (pParam->BSIM4v7mstarcv - 1.0) * ExpVgst / Vtm; dT9_dVb = T4 * dn_dVb - dT9_dVg * dVth_dVb - T5 * dn_dVb; dT9_dVd = T4 * dn_dVd - dT9_dVg * dVth_dVd - T5 * dn_dVd; dT9_dVg *= dVgs_eff_dVg; @@ -3379,8 +3379,8 @@ for (; model != NULL; model = model->BSIM4nextModel) } - if (model->BSIM4capMod == 1) - { Vfb = here->BSIM4vfbzb; + if (model->BSIM4v7capMod == 1) + { Vfb = here->BSIM4v7vfbzb; V3 = Vfb - Vgs_eff + VbseffCV - DELTA_3; if (Vfb <= 0.0) T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * Vfb); @@ -3395,14 +3395,14 @@ for (; model != NULL; model = model->BSIM4nextModel) dQac0_dVg = CoxWL * dVfbeff_dVg; dQac0_dVb = CoxWL * dVfbeff_dVb; - T0 = 0.5 * pParam->BSIM4k1ox; + T0 = 0.5 * pParam->BSIM4v7k1ox; T3 = Vgs_eff - Vfbeff - VbseffCV - Vgsteff; - if (pParam->BSIM4k1ox == 0.0) + if (pParam->BSIM4v7k1ox == 0.0) { T1 = 0.0; T2 = 0.0; } else if (T3 < 0.0) - { T1 = T0 + T3 / pParam->BSIM4k1ox; + { T1 = T0 + T3 / pParam->BSIM4v7k1ox; T2 = CoxWL; } else @@ -3410,15 +3410,15 @@ for (; model != NULL; model = model->BSIM4nextModel) T2 = CoxWL * T0 / T1; } - Qsub0 = CoxWL * pParam->BSIM4k1ox * (T1 - T0); + Qsub0 = CoxWL * pParam->BSIM4v7k1ox * (T1 - T0); dQsub0_dVg = T2 * (dVgs_eff_dVg - dVfbeff_dVg - dVgsteff_dVg); dQsub0_dVd = -T2 * dVgsteff_dVd; dQsub0_dVb = -T2 * (dVfbeff_dVb + dVbseffCV_dVb + dVgsteff_dVb); - AbulkCV = Abulk0 * pParam->BSIM4abulkCVfactor; - dAbulkCV_dVb = pParam->BSIM4abulkCVfactor * dAbulk0_dVb; + AbulkCV = Abulk0 * pParam->BSIM4v7abulkCVfactor; + dAbulkCV_dVb = pParam->BSIM4v7abulkCVfactor * dAbulk0_dVb; VdsatCV = Vgsteff / AbulkCV; T0 = VdsatCV - Vds - DELTA_4; @@ -3478,7 +3478,7 @@ for (; model != NULL; model = model->BSIM4nextModel) + Cbg1 * dVgsteff_dVb; Cbg1 *= dVgsteff_dVg; - if (model->BSIM4xpart > 0.5) + if (model->BSIM4v7xpart > 0.5) { /* 0/100 Charge petition model */ T1 = T1 + T1; qsrc = -CoxWL * (0.5 * Vgsteff + 0.25 * T0 @@ -3493,7 +3493,7 @@ for (; model != NULL; model = model->BSIM4nextModel) + Csg * dVgsteff_dVb; Csg *= dVgsteff_dVg; } - else if (model->BSIM4xpart < 0.5) + else if (model->BSIM4v7xpart < 0.5) { /* 40/60 Charge petition model */ T1 = T1 / 12.0; T2 = 0.5 * CoxWL / (T1 * T1); @@ -3538,57 +3538,57 @@ for (; model != NULL; model = model->BSIM4nextModel) Cbb *= dVbseff_dVb; Csb *= dVbseff_dVb; - here->BSIM4cggb = Cgg; - here->BSIM4cgsb = -(Cgg + Cgd + Cgb); - here->BSIM4cgdb = Cgd; - here->BSIM4cdgb = -(Cgg + Cbg + Csg); - here->BSIM4cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb + here->BSIM4v7cggb = Cgg; + here->BSIM4v7cgsb = -(Cgg + Cgd + Cgb); + here->BSIM4v7cgdb = Cgd; + here->BSIM4v7cdgb = -(Cgg + Cbg + Csg); + here->BSIM4v7cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb + Csg + Csd + Csb); - here->BSIM4cddb = -(Cgd + Cbd + Csd); - here->BSIM4cbgb = Cbg; - here->BSIM4cbsb = -(Cbg + Cbd + Cbb); - here->BSIM4cbdb = Cbd; + here->BSIM4v7cddb = -(Cgd + Cbd + Csd); + here->BSIM4v7cbgb = Cbg; + here->BSIM4v7cbsb = -(Cbg + Cbd + Cbb); + here->BSIM4v7cbdb = Cbd; } /* Charge-Thickness capMod (CTM) begins */ - else if (model->BSIM4capMod == 2) - { V3 = here->BSIM4vfbzb - Vgs_eff + VbseffCV - DELTA_3; - if (here->BSIM4vfbzb <= 0.0) - T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * here->BSIM4vfbzb); + else if (model->BSIM4v7capMod == 2) + { V3 = here->BSIM4v7vfbzb - Vgs_eff + VbseffCV - DELTA_3; + if (here->BSIM4v7vfbzb <= 0.0) + T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * here->BSIM4v7vfbzb); else - T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * here->BSIM4vfbzb); + T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * here->BSIM4v7vfbzb); T1 = 0.5 * (1.0 + V3 / T0); - Vfbeff = here->BSIM4vfbzb - 0.5 * (V3 + T0); + Vfbeff = here->BSIM4v7vfbzb - 0.5 * (V3 + T0); dVfbeff_dVg = T1 * dVgs_eff_dVg; dVfbeff_dVb = -T1 * dVbseffCV_dVb; - Cox = model->BSIM4coxp; - Tox = 1.0e8 * model->BSIM4toxp; - T0 = (Vgs_eff - VbseffCV - here->BSIM4vfbzb) / Tox; + Cox = model->BSIM4v7coxp; + Tox = 1.0e8 * model->BSIM4v7toxp; + T0 = (Vgs_eff - VbseffCV - here->BSIM4v7vfbzb) / Tox; dT0_dVg = dVgs_eff_dVg / Tox; dT0_dVb = -dVbseffCV_dVb / Tox; - tmp = T0 * pParam->BSIM4acde; + tmp = T0 * pParam->BSIM4v7acde; if ((-EXP_THRESHOLD < tmp) && (tmp < EXP_THRESHOLD)) - { Tcen = pParam->BSIM4ldeb * exp(tmp); - dTcen_dVg = pParam->BSIM4acde * Tcen; + { Tcen = pParam->BSIM4v7ldeb * exp(tmp); + dTcen_dVg = pParam->BSIM4v7acde * Tcen; dTcen_dVb = dTcen_dVg * dT0_dVb; dTcen_dVg *= dT0_dVg; } else if (tmp <= -EXP_THRESHOLD) - { Tcen = pParam->BSIM4ldeb * MIN_EXP; + { Tcen = pParam->BSIM4v7ldeb * MIN_EXP; dTcen_dVg = dTcen_dVb = 0.0; } else - { Tcen = pParam->BSIM4ldeb * MAX_EXP; + { Tcen = pParam->BSIM4v7ldeb * MAX_EXP; dTcen_dVg = dTcen_dVb = 0.0; } - LINK = 1.0e-3 * model->BSIM4toxp; - V3 = pParam->BSIM4ldeb - Tcen - LINK; - V4 = sqrt(V3 * V3 + 4.0 * LINK * pParam->BSIM4ldeb); - Tcen = pParam->BSIM4ldeb - 0.5 * (V3 + V4); + LINK = 1.0e-3 * model->BSIM4v7toxp; + V3 = pParam->BSIM4v7ldeb - Tcen - LINK; + V4 = sqrt(V3 * V3 + 4.0 * LINK * pParam->BSIM4v7ldeb); + Tcen = pParam->BSIM4v7ldeb - 0.5 * (V3 + V4); T1 = 0.5 * (1.0 + V3 / V4); dTcen_dVg *= T1; dTcen_dVb *= T1; @@ -3600,23 +3600,23 @@ for (; model != NULL; model = model->BSIM4nextModel) dCoxeff_dVg = T2 * T2 * T3; dCoxeff_dVb = dCoxeff_dVg * dTcen_dVb; dCoxeff_dVg *= dTcen_dVg; - CoxWLcen = CoxWL * Coxeff / model->BSIM4coxe; + CoxWLcen = CoxWL * Coxeff / model->BSIM4v7coxe; - Qac0 = CoxWLcen * (Vfbeff - here->BSIM4vfbzb); + Qac0 = CoxWLcen * (Vfbeff - here->BSIM4v7vfbzb); QovCox = Qac0 / Coxeff; dQac0_dVg = CoxWLcen * dVfbeff_dVg + QovCox * dCoxeff_dVg; dQac0_dVb = CoxWLcen * dVfbeff_dVb + QovCox * dCoxeff_dVb; - T0 = 0.5 * pParam->BSIM4k1ox; + T0 = 0.5 * pParam->BSIM4v7k1ox; T3 = Vgs_eff - Vfbeff - VbseffCV - Vgsteff; - if (pParam->BSIM4k1ox == 0.0) + if (pParam->BSIM4v7k1ox == 0.0) { T1 = 0.0; T2 = 0.0; } else if (T3 < 0.0) - { T1 = T0 + T3 / pParam->BSIM4k1ox; + { T1 = T0 + T3 / pParam->BSIM4v7k1ox; T2 = CoxWLcen; } else @@ -3624,7 +3624,7 @@ for (; model != NULL; model = model->BSIM4nextModel) T2 = CoxWLcen * T0 / T1; } - Qsub0 = CoxWLcen * pParam->BSIM4k1ox * (T1 - T0); + Qsub0 = CoxWLcen * pParam->BSIM4v7k1ox * (T1 - T0); QovCox = Qsub0 / Coxeff; dQsub0_dVg = T2 * (dVgs_eff_dVg - dVfbeff_dVg - dVgsteff_dVg) + QovCox * dCoxeff_dVg; @@ -3633,14 +3633,14 @@ for (; model != NULL; model = model->BSIM4nextModel) + QovCox * dCoxeff_dVb; /* Gate-bias dependent delta Phis begins */ - if (pParam->BSIM4k1ox <= 0.0) - { Denomi = 0.25 * pParam->BSIM4moin * Vtm; - T0 = 0.5 * pParam->BSIM4sqrtPhi; + if (pParam->BSIM4v7k1ox <= 0.0) + { Denomi = 0.25 * pParam->BSIM4v7moin * Vtm; + T0 = 0.5 * pParam->BSIM4v7sqrtPhi; } else - { Denomi = pParam->BSIM4moin * Vtm - * pParam->BSIM4k1ox * pParam->BSIM4k1ox; - T0 = pParam->BSIM4k1ox * pParam->BSIM4sqrtPhi; + { Denomi = pParam->BSIM4v7moin * Vtm + * pParam->BSIM4v7k1ox * pParam->BSIM4v7k1ox; + T0 = pParam->BSIM4v7k1ox * pParam->BSIM4v7sqrtPhi; } T1 = 2.0 * T0 + Vgsteff; @@ -3656,11 +3656,11 @@ for (; model != NULL; model = model->BSIM4nextModel) dVgDP_dVg = 0.5 * (dT0_dVg + (T0 * dT0_dVg + 0.002) / T1); Tox += Tox; /* WDLiu: Tcen reevaluated below due to different Vgsteff */ - T0 = (Vgsteff + here->BSIM4vtfbphi2) / Tox; - tmp = exp(model->BSIM4bdos * 0.7 * log(T0)); + T0 = (Vgsteff + here->BSIM4v7vtfbphi2) / Tox; + tmp = exp(model->BSIM4v7bdos * 0.7 * log(T0)); T1 = 1.0 + tmp; - T2 = model->BSIM4bdos * 0.7 * tmp / (T0 * Tox); - Tcen = model->BSIM4ados * 1.9e-9 / T1; + T2 = model->BSIM4v7bdos * 0.7 * tmp / (T0 * Tox); + Tcen = model->BSIM4v7ados * 1.9e-9 / T1; dTcen_dVg = -Tcen * T2 / T1; dTcen_dVd = dTcen_dVg * dVgsteff_dVd; dTcen_dVb = dTcen_dVg * dVgsteff_dVb; @@ -3674,10 +3674,10 @@ for (; model != NULL; model = model->BSIM4nextModel) dCoxeff_dVd = dCoxeff_dVg * dTcen_dVd; dCoxeff_dVb = dCoxeff_dVg * dTcen_dVb; dCoxeff_dVg *= dTcen_dVg; - CoxWLcen = CoxWL * Coxeff / model->BSIM4coxe; + CoxWLcen = CoxWL * Coxeff / model->BSIM4v7coxe; - AbulkCV = Abulk0 * pParam->BSIM4abulkCVfactor; - dAbulkCV_dVb = pParam->BSIM4abulkCVfactor * dAbulk0_dVb; + AbulkCV = Abulk0 * pParam->BSIM4v7abulkCVfactor; + dAbulkCV_dVb = pParam->BSIM4v7abulkCVfactor * dAbulk0_dVb; VdsatCV = VgDP / AbulkCV; T0 = VdsatCV - Vds - DELTA_4; @@ -3745,7 +3745,7 @@ for (; model != NULL; model = model->BSIM4nextModel) + Cbg1 * dVgsteff_dVb + QovCox * dCoxeff_dVb; Cbg1 = Cbg1 * dVgsteff_dVg + QovCox * dCoxeff_dVg; - if (model->BSIM4xpart > 0.5) + if (model->BSIM4v7xpart > 0.5) { /* 0/100 partition */ qsrc = -CoxWLcen * (T1 / 2.0 + T0 / 4.0 - 0.5 * T0 * T0 / T2); @@ -3764,7 +3764,7 @@ for (; model != NULL; model = model->BSIM4nextModel) + Csg * dVgsteff_dVb + QovCox * dCoxeff_dVb; Csg = Csg * dVgsteff_dVg + QovCox * dCoxeff_dVg; } - else if (model->BSIM4xpart < 0.5) + else if (model->BSIM4v7xpart < 0.5) { /* 40/60 partition */ T2 = T2 / 12.0; T3 = 0.5 * CoxWLcen / (T2 * T2); @@ -3809,54 +3809,54 @@ for (; model != NULL; model = model->BSIM4nextModel) Cbb *= dVbseff_dVb; Csb *= dVbseff_dVb; - here->BSIM4cggb = Cgg; - here->BSIM4cgsb = -(Cgg + Cgd + Cgb); - here->BSIM4cgdb = Cgd; - here->BSIM4cdgb = -(Cgg + Cbg + Csg); - here->BSIM4cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb + here->BSIM4v7cggb = Cgg; + here->BSIM4v7cgsb = -(Cgg + Cgd + Cgb); + here->BSIM4v7cgdb = Cgd; + here->BSIM4v7cdgb = -(Cgg + Cbg + Csg); + here->BSIM4v7cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb + Csg + Csd + Csb); - here->BSIM4cddb = -(Cgd + Cbd + Csd); - here->BSIM4cbgb = Cbg; - here->BSIM4cbsb = -(Cbg + Cbd + Cbb); - here->BSIM4cbdb = Cbd; + here->BSIM4v7cddb = -(Cgd + Cbd + Csd); + here->BSIM4v7cbgb = Cbg; + here->BSIM4v7cbsb = -(Cbg + Cbd + Cbb); + here->BSIM4v7cbdb = Cbd; } /* End of CTM */ } - here->BSIM4csgb = - here->BSIM4cggb - here->BSIM4cdgb - here->BSIM4cbgb; - here->BSIM4csdb = - here->BSIM4cgdb - here->BSIM4cddb - here->BSIM4cbdb; - here->BSIM4cssb = - here->BSIM4cgsb - here->BSIM4cdsb - here->BSIM4cbsb; - here->BSIM4cgbb = - here->BSIM4cgdb - here->BSIM4cggb - here->BSIM4cgsb; - here->BSIM4cdbb = - here->BSIM4cddb - here->BSIM4cdgb - here->BSIM4cdsb; - here->BSIM4cbbb = - here->BSIM4cbgb - here->BSIM4cbdb - here->BSIM4cbsb; - here->BSIM4csbb = - here->BSIM4cgbb - here->BSIM4cdbb - here->BSIM4cbbb; - here->BSIM4qgate = qgate; - here->BSIM4qbulk = qbulk; - here->BSIM4qdrn = qdrn; - here->BSIM4qsrc = -(qgate + qbulk + qdrn); + here->BSIM4v7csgb = - here->BSIM4v7cggb - here->BSIM4v7cdgb - here->BSIM4v7cbgb; + here->BSIM4v7csdb = - here->BSIM4v7cgdb - here->BSIM4v7cddb - here->BSIM4v7cbdb; + here->BSIM4v7cssb = - here->BSIM4v7cgsb - here->BSIM4v7cdsb - here->BSIM4v7cbsb; + here->BSIM4v7cgbb = - here->BSIM4v7cgdb - here->BSIM4v7cggb - here->BSIM4v7cgsb; + here->BSIM4v7cdbb = - here->BSIM4v7cddb - here->BSIM4v7cdgb - here->BSIM4v7cdsb; + here->BSIM4v7cbbb = - here->BSIM4v7cbgb - here->BSIM4v7cbdb - here->BSIM4v7cbsb; + here->BSIM4v7csbb = - here->BSIM4v7cgbb - here->BSIM4v7cdbb - here->BSIM4v7cbbb; + here->BSIM4v7qgate = qgate; + here->BSIM4v7qbulk = qbulk; + here->BSIM4v7qdrn = qdrn; + here->BSIM4v7qsrc = -(qgate + qbulk + qdrn); /* NQS begins */ - if ((here->BSIM4trnqsMod) || (here->BSIM4acnqsMod)) - { here->BSIM4qchqs = qcheq = -(qbulk + qgate); - here->BSIM4cqgb = -(here->BSIM4cggb + here->BSIM4cbgb); - here->BSIM4cqdb = -(here->BSIM4cgdb + here->BSIM4cbdb); - here->BSIM4cqsb = -(here->BSIM4cgsb + here->BSIM4cbsb); - here->BSIM4cqbb = -(here->BSIM4cqgb + here->BSIM4cqdb - + here->BSIM4cqsb); + if ((here->BSIM4v7trnqsMod) || (here->BSIM4v7acnqsMod)) + { here->BSIM4v7qchqs = qcheq = -(qbulk + qgate); + here->BSIM4v7cqgb = -(here->BSIM4v7cggb + here->BSIM4v7cbgb); + here->BSIM4v7cqdb = -(here->BSIM4v7cgdb + here->BSIM4v7cbdb); + here->BSIM4v7cqsb = -(here->BSIM4v7cgsb + here->BSIM4v7cbsb); + here->BSIM4v7cqbb = -(here->BSIM4v7cqgb + here->BSIM4v7cqdb + + here->BSIM4v7cqsb); - CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV * here->BSIM4nf - * pParam->BSIM4leffCV; - T1 = here->BSIM4gcrg / CoxWL; /* 1 / tau */ - here->BSIM4gtau = T1 * ScalingFactor; + CoxWL = model->BSIM4v7coxe * pParam->BSIM4v7weffCV * here->BSIM4v7nf + * pParam->BSIM4v7leffCV; + T1 = here->BSIM4v7gcrg / CoxWL; /* 1 / tau */ + here->BSIM4v7gtau = T1 * ScalingFactor; - if (here->BSIM4acnqsMod) - here->BSIM4taunet = 1.0 / T1; + if (here->BSIM4v7acnqsMod) + here->BSIM4v7taunet = 1.0 / T1; - *(ckt->CKTstate0 + here->BSIM4qcheq) = qcheq; + *(ckt->CKTstate0 + here->BSIM4v7qcheq) = qcheq; if (ckt->CKTmode & MODEINITTRAN) - *(ckt->CKTstate1 + here->BSIM4qcheq) = - *(ckt->CKTstate0 + here->BSIM4qcheq); - if (here->BSIM4trnqsMod) - { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qcheq); + *(ckt->CKTstate1 + here->BSIM4v7qcheq) = + *(ckt->CKTstate0 + here->BSIM4v7qcheq); + if (here->BSIM4v7trnqsMod) + { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4v7qcheq); if (error) return(error); } @@ -3867,120 +3867,120 @@ finished: /* Calculate junction C-V */ if (ChargeComputationNeeded) - { czbd = model->BSIM4DunitAreaTempJctCap * here->BSIM4Adeff; /* bug fix */ - czbs = model->BSIM4SunitAreaTempJctCap * here->BSIM4Aseff; - czbdsw = model->BSIM4DunitLengthSidewallTempJctCap * here->BSIM4Pdeff; - czbdswg = model->BSIM4DunitLengthGateSidewallTempJctCap - * pParam->BSIM4weffCJ * here->BSIM4nf; - czbssw = model->BSIM4SunitLengthSidewallTempJctCap * here->BSIM4Pseff; - czbsswg = model->BSIM4SunitLengthGateSidewallTempJctCap - * pParam->BSIM4weffCJ * here->BSIM4nf; + { czbd = model->BSIM4v7DunitAreaTempJctCap * here->BSIM4v7Adeff; /* bug fix */ + czbs = model->BSIM4v7SunitAreaTempJctCap * here->BSIM4v7Aseff; + czbdsw = model->BSIM4v7DunitLengthSidewallTempJctCap * here->BSIM4v7Pdeff; + czbdswg = model->BSIM4v7DunitLengthGateSidewallTempJctCap + * pParam->BSIM4v7weffCJ * here->BSIM4v7nf; + czbssw = model->BSIM4v7SunitLengthSidewallTempJctCap * here->BSIM4v7Pseff; + czbsswg = model->BSIM4v7SunitLengthGateSidewallTempJctCap + * pParam->BSIM4v7weffCJ * here->BSIM4v7nf; - MJS = model->BSIM4SbulkJctBotGradingCoeff; - MJSWS = model->BSIM4SbulkJctSideGradingCoeff; - MJSWGS = model->BSIM4SbulkJctGateSideGradingCoeff; + MJS = model->BSIM4v7SbulkJctBotGradingCoeff; + MJSWS = model->BSIM4v7SbulkJctSideGradingCoeff; + MJSWGS = model->BSIM4v7SbulkJctGateSideGradingCoeff; - MJD = model->BSIM4DbulkJctBotGradingCoeff; - MJSWD = model->BSIM4DbulkJctSideGradingCoeff; - MJSWGD = model->BSIM4DbulkJctGateSideGradingCoeff; + MJD = model->BSIM4v7DbulkJctBotGradingCoeff; + MJSWD = model->BSIM4v7DbulkJctSideGradingCoeff; + MJSWGD = model->BSIM4v7DbulkJctGateSideGradingCoeff; /* Source Bulk Junction */ if (vbs_jct == 0.0) - { *(ckt->CKTstate0 + here->BSIM4qbs) = 0.0; - here->BSIM4capbs = czbs + czbssw + czbsswg; + { *(ckt->CKTstate0 + here->BSIM4v7qbs) = 0.0; + here->BSIM4v7capbs = czbs + czbssw + czbsswg; } else if (vbs_jct < 0.0) { if (czbs > 0.0) - { arg = 1.0 - vbs_jct / model->BSIM4PhiBS; + { arg = 1.0 - vbs_jct / model->BSIM4v7PhiBS; if (MJS == 0.5) sarg = 1.0 / sqrt(arg); else sarg = exp(-MJS * log(arg)); - *(ckt->CKTstate0 + here->BSIM4qbs) = model->BSIM4PhiBS * czbs + *(ckt->CKTstate0 + here->BSIM4v7qbs) = model->BSIM4v7PhiBS * czbs * (1.0 - arg * sarg) / (1.0 - MJS); - here->BSIM4capbs = czbs * sarg; + here->BSIM4v7capbs = czbs * sarg; } else - { *(ckt->CKTstate0 + here->BSIM4qbs) = 0.0; - here->BSIM4capbs = 0.0; + { *(ckt->CKTstate0 + here->BSIM4v7qbs) = 0.0; + here->BSIM4v7capbs = 0.0; } if (czbssw > 0.0) - { arg = 1.0 - vbs_jct / model->BSIM4PhiBSWS; + { arg = 1.0 - vbs_jct / model->BSIM4v7PhiBSWS; if (MJSWS == 0.5) sarg = 1.0 / sqrt(arg); else sarg = exp(-MJSWS * log(arg)); - *(ckt->CKTstate0 + here->BSIM4qbs) += model->BSIM4PhiBSWS * czbssw + *(ckt->CKTstate0 + here->BSIM4v7qbs) += model->BSIM4v7PhiBSWS * czbssw * (1.0 - arg * sarg) / (1.0 - MJSWS); - here->BSIM4capbs += czbssw * sarg; + here->BSIM4v7capbs += czbssw * sarg; } if (czbsswg > 0.0) - { arg = 1.0 - vbs_jct / model->BSIM4PhiBSWGS; + { arg = 1.0 - vbs_jct / model->BSIM4v7PhiBSWGS; if (MJSWGS == 0.5) sarg = 1.0 / sqrt(arg); else sarg = exp(-MJSWGS * log(arg)); - *(ckt->CKTstate0 + here->BSIM4qbs) += model->BSIM4PhiBSWGS * czbsswg + *(ckt->CKTstate0 + here->BSIM4v7qbs) += model->BSIM4v7PhiBSWGS * czbsswg * (1.0 - arg * sarg) / (1.0 - MJSWGS); - here->BSIM4capbs += czbsswg * sarg; + here->BSIM4v7capbs += czbsswg * sarg; } } else { T0 = czbs + czbssw + czbsswg; - T1 = vbs_jct * (czbs * MJS / model->BSIM4PhiBS + czbssw * MJSWS - / model->BSIM4PhiBSWS + czbsswg * MJSWGS / model->BSIM4PhiBSWGS); - *(ckt->CKTstate0 + here->BSIM4qbs) = vbs_jct * (T0 + 0.5 * T1); - here->BSIM4capbs = T0 + T1; + T1 = vbs_jct * (czbs * MJS / model->BSIM4v7PhiBS + czbssw * MJSWS + / model->BSIM4v7PhiBSWS + czbsswg * MJSWGS / model->BSIM4v7PhiBSWGS); + *(ckt->CKTstate0 + here->BSIM4v7qbs) = vbs_jct * (T0 + 0.5 * T1); + here->BSIM4v7capbs = T0 + T1; } /* Drain Bulk Junction */ if (vbd_jct == 0.0) - { *(ckt->CKTstate0 + here->BSIM4qbd) = 0.0; - here->BSIM4capbd = czbd + czbdsw + czbdswg; + { *(ckt->CKTstate0 + here->BSIM4v7qbd) = 0.0; + here->BSIM4v7capbd = czbd + czbdsw + czbdswg; } else if (vbd_jct < 0.0) { if (czbd > 0.0) - { arg = 1.0 - vbd_jct / model->BSIM4PhiBD; + { arg = 1.0 - vbd_jct / model->BSIM4v7PhiBD; if (MJD == 0.5) sarg = 1.0 / sqrt(arg); else sarg = exp(-MJD * log(arg)); - *(ckt->CKTstate0 + here->BSIM4qbd) = model->BSIM4PhiBD* czbd + *(ckt->CKTstate0 + here->BSIM4v7qbd) = model->BSIM4v7PhiBD* czbd * (1.0 - arg * sarg) / (1.0 - MJD); - here->BSIM4capbd = czbd * sarg; + here->BSIM4v7capbd = czbd * sarg; } else - { *(ckt->CKTstate0 + here->BSIM4qbd) = 0.0; - here->BSIM4capbd = 0.0; + { *(ckt->CKTstate0 + here->BSIM4v7qbd) = 0.0; + here->BSIM4v7capbd = 0.0; } if (czbdsw > 0.0) - { arg = 1.0 - vbd_jct / model->BSIM4PhiBSWD; + { arg = 1.0 - vbd_jct / model->BSIM4v7PhiBSWD; if (MJSWD == 0.5) sarg = 1.0 / sqrt(arg); else sarg = exp(-MJSWD * log(arg)); - *(ckt->CKTstate0 + here->BSIM4qbd) += model->BSIM4PhiBSWD * czbdsw + *(ckt->CKTstate0 + here->BSIM4v7qbd) += model->BSIM4v7PhiBSWD * czbdsw * (1.0 - arg * sarg) / (1.0 - MJSWD); - here->BSIM4capbd += czbdsw * sarg; + here->BSIM4v7capbd += czbdsw * sarg; } if (czbdswg > 0.0) - { arg = 1.0 - vbd_jct / model->BSIM4PhiBSWGD; + { arg = 1.0 - vbd_jct / model->BSIM4v7PhiBSWGD; if (MJSWGD == 0.5) sarg = 1.0 / sqrt(arg); else sarg = exp(-MJSWGD * log(arg)); - *(ckt->CKTstate0 + here->BSIM4qbd) += model->BSIM4PhiBSWGD * czbdswg + *(ckt->CKTstate0 + here->BSIM4v7qbd) += model->BSIM4v7PhiBSWGD * czbdswg * (1.0 - arg * sarg) / (1.0 - MJSWGD); - here->BSIM4capbd += czbdswg * sarg; + here->BSIM4v7capbd += czbdswg * sarg; } } else { T0 = czbd + czbdsw + czbdswg; - T1 = vbd_jct * (czbd * MJD / model->BSIM4PhiBD + czbdsw * MJSWD - / model->BSIM4PhiBSWD + czbdswg * MJSWGD / model->BSIM4PhiBSWGD); - *(ckt->CKTstate0 + here->BSIM4qbd) = vbd_jct * (T0 + 0.5 * T1); - here->BSIM4capbd = T0 + T1; + T1 = vbd_jct * (czbd * MJD / model->BSIM4v7PhiBD + czbdsw * MJSWD + / model->BSIM4v7PhiBSWD + czbdswg * MJSWGD / model->BSIM4v7PhiBSWGD); + *(ckt->CKTstate0 + here->BSIM4v7qbd) = vbd_jct * (T0 + 0.5 * T1); + here->BSIM4v7capbd = T0 + T1; } } @@ -3989,18 +3989,18 @@ finished: * check convergence */ - if ((here->BSIM4off == 0) || (!(ckt->CKTmode & MODEINITFIX))) + if ((here->BSIM4v7off == 0) || (!(ckt->CKTmode & MODEINITFIX))) { if (Check == 1) { ckt->CKTnoncon++; #ifndef NEWCONV } else - { if (here->BSIM4mode >= 0) - { Idtot = here->BSIM4cd + here->BSIM4csub - + here->BSIM4Igidl - here->BSIM4cbd; + { if (here->BSIM4v7mode >= 0) + { Idtot = here->BSIM4v7cd + here->BSIM4v7csub + + here->BSIM4v7Igidl - here->BSIM4v7cbd; } else - { Idtot = here->BSIM4cd + here->BSIM4cbd - here->BSIM4Igidl; /* bugfix */ + { Idtot = here->BSIM4v7cd + here->BSIM4v7cbd - here->BSIM4v7Igidl; /* bugfix */ } tol0 = ckt->CKTreltol * MAX(fabs(cdhat), fabs(Idtot)) + ckt->CKTabstol; @@ -4023,8 +4023,8 @@ finished: { ckt->CKTnoncon++; } else - { Ibtot = here->BSIM4cbs + here->BSIM4cbd - - here->BSIM4Igidl - here->BSIM4Igisl - here->BSIM4csub; + { Ibtot = here->BSIM4v7cbs + here->BSIM4v7cbd + - here->BSIM4v7Igidl - here->BSIM4v7Igisl - here->BSIM4v7csub; tol6 = ckt->CKTreltol * MAX(fabs(cbhat), fabs(Ibtot)) + ckt->CKTabstol; if (fabs(cbhat - Ibtot) > tol6) @@ -4034,24 +4034,24 @@ finished: #endif /* NEWCONV */ } } - *(ckt->CKTstate0 + here->BSIM4vds) = vds; - *(ckt->CKTstate0 + here->BSIM4vgs) = vgs; - *(ckt->CKTstate0 + here->BSIM4vbs) = vbs; - *(ckt->CKTstate0 + here->BSIM4vbd) = vbd; - *(ckt->CKTstate0 + here->BSIM4vges) = vges; - *(ckt->CKTstate0 + here->BSIM4vgms) = vgms; - *(ckt->CKTstate0 + here->BSIM4vdbs) = vdbs; - *(ckt->CKTstate0 + here->BSIM4vdbd) = vdbd; - *(ckt->CKTstate0 + here->BSIM4vsbs) = vsbs; - *(ckt->CKTstate0 + here->BSIM4vses) = vses; - *(ckt->CKTstate0 + here->BSIM4vdes) = vdes; - *(ckt->CKTstate0 + here->BSIM4qdef) = qdef; + *(ckt->CKTstate0 + here->BSIM4v7vds) = vds; + *(ckt->CKTstate0 + here->BSIM4v7vgs) = vgs; + *(ckt->CKTstate0 + here->BSIM4v7vbs) = vbs; + *(ckt->CKTstate0 + here->BSIM4v7vbd) = vbd; + *(ckt->CKTstate0 + here->BSIM4v7vges) = vges; + *(ckt->CKTstate0 + here->BSIM4v7vgms) = vgms; + *(ckt->CKTstate0 + here->BSIM4v7vdbs) = vdbs; + *(ckt->CKTstate0 + here->BSIM4v7vdbd) = vdbd; + *(ckt->CKTstate0 + here->BSIM4v7vsbs) = vsbs; + *(ckt->CKTstate0 + here->BSIM4v7vses) = vses; + *(ckt->CKTstate0 + here->BSIM4v7vdes) = vdes; + *(ckt->CKTstate0 + here->BSIM4v7qdef) = qdef; if (!ChargeComputationNeeded) goto line850; - if (here->BSIM4rgateMod == 3) + if (here->BSIM4v7rgateMod == 3) { vgdx = vgmd; vgsx = vgms; @@ -4061,123 +4061,123 @@ finished: vgdx = vgd; vgsx = vgs; } - if (model->BSIM4capMod == 0) + if (model->BSIM4v7capMod == 0) { - cgdo = pParam->BSIM4cgdo; - qgdo = pParam->BSIM4cgdo * vgdx; - cgso = pParam->BSIM4cgso; - qgso = pParam->BSIM4cgso * vgsx; + cgdo = pParam->BSIM4v7cgdo; + qgdo = pParam->BSIM4v7cgdo * vgdx; + cgso = pParam->BSIM4v7cgso; + qgso = pParam->BSIM4v7cgso * vgsx; } else /* For both capMod == 1 and 2 */ { T0 = vgdx + DELTA_1; T1 = sqrt(T0 * T0 + 4.0 * DELTA_1); T2 = 0.5 * (T0 - T1); - T3 = pParam->BSIM4weffCV * pParam->BSIM4cgdl; - T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM4ckappad); - cgdo = pParam->BSIM4cgdo + T3 - T3 * (1.0 - 1.0 / T4) + T3 = pParam->BSIM4v7weffCV * pParam->BSIM4v7cgdl; + T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM4v7ckappad); + cgdo = pParam->BSIM4v7cgdo + T3 - T3 * (1.0 - 1.0 / T4) * (0.5 - 0.5 * T0 / T1); - qgdo = (pParam->BSIM4cgdo + T3) * vgdx - T3 * (T2 - + 0.5 * pParam->BSIM4ckappad * (T4 - 1.0)); + qgdo = (pParam->BSIM4v7cgdo + T3) * vgdx - T3 * (T2 + + 0.5 * pParam->BSIM4v7ckappad * (T4 - 1.0)); T0 = vgsx + DELTA_1; T1 = sqrt(T0 * T0 + 4.0 * DELTA_1); T2 = 0.5 * (T0 - T1); - T3 = pParam->BSIM4weffCV * pParam->BSIM4cgsl; - T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM4ckappas); - cgso = pParam->BSIM4cgso + T3 - T3 * (1.0 - 1.0 / T4) + T3 = pParam->BSIM4v7weffCV * pParam->BSIM4v7cgsl; + T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM4v7ckappas); + cgso = pParam->BSIM4v7cgso + T3 - T3 * (1.0 - 1.0 / T4) * (0.5 - 0.5 * T0 / T1); - qgso = (pParam->BSIM4cgso + T3) * vgsx - T3 * (T2 - + 0.5 * pParam->BSIM4ckappas * (T4 - 1.0)); + qgso = (pParam->BSIM4v7cgso + T3) * vgsx - T3 * (T2 + + 0.5 * pParam->BSIM4v7ckappas * (T4 - 1.0)); } - if (here->BSIM4nf != 1.0) - { cgdo *= here->BSIM4nf; - cgso *= here->BSIM4nf; - qgdo *= here->BSIM4nf; - qgso *= here->BSIM4nf; + if (here->BSIM4v7nf != 1.0) + { cgdo *= here->BSIM4v7nf; + cgso *= here->BSIM4v7nf; + qgdo *= here->BSIM4v7nf; + qgso *= here->BSIM4v7nf; } - here->BSIM4cgdo = cgdo; - here->BSIM4qgdo = qgdo; - here->BSIM4cgso = cgso; - here->BSIM4qgso = qgso; + here->BSIM4v7cgdo = cgdo; + here->BSIM4v7qgdo = qgdo; + here->BSIM4v7cgso = cgso; + here->BSIM4v7qgso = qgso; #ifndef NOBYPASS line755: #endif ag0 = ckt->CKTag[0]; - if (here->BSIM4mode > 0) - { if (here->BSIM4trnqsMod == 0) + if (here->BSIM4v7mode > 0) + { if (here->BSIM4v7trnqsMod == 0) { qdrn -= qgdo; - if (here->BSIM4rgateMod == 3) - { gcgmgmb = (cgdo + cgso + pParam->BSIM4cgbo) * ag0; + if (here->BSIM4v7rgateMod == 3) + { gcgmgmb = (cgdo + cgso + pParam->BSIM4v7cgbo) * ag0; gcgmdb = -cgdo * ag0; gcgmsb = -cgso * ag0; - gcgmbb = -pParam->BSIM4cgbo * ag0; + gcgmbb = -pParam->BSIM4v7cgbo * ag0; gcdgmb = gcgmdb; gcsgmb = gcgmsb; gcbgmb = gcgmbb; - gcggb = here->BSIM4cggb * ag0; - gcgdb = here->BSIM4cgdb * ag0; - gcgsb = here->BSIM4cgsb * ag0; + gcggb = here->BSIM4v7cggb * ag0; + gcgdb = here->BSIM4v7cgdb * ag0; + gcgsb = here->BSIM4v7cgsb * ag0; gcgbb = -(gcggb + gcgdb + gcgsb); - gcdgb = here->BSIM4cdgb * ag0; - gcsgb = -(here->BSIM4cggb + here->BSIM4cbgb - + here->BSIM4cdgb) * ag0; - gcbgb = here->BSIM4cbgb * ag0; + gcdgb = here->BSIM4v7cdgb * ag0; + gcsgb = -(here->BSIM4v7cggb + here->BSIM4v7cbgb + + here->BSIM4v7cdgb) * ag0; + gcbgb = here->BSIM4v7cbgb * ag0; - qgmb = pParam->BSIM4cgbo * vgmb; + qgmb = pParam->BSIM4v7cgbo * vgmb; qgmid = qgdo + qgso + qgmb; qbulk -= qgmb; qsrc = -(qgate + qgmid + qbulk + qdrn); } else - { gcggb = (here->BSIM4cggb + cgdo + cgso - + pParam->BSIM4cgbo ) * ag0; - gcgdb = (here->BSIM4cgdb - cgdo) * ag0; - gcgsb = (here->BSIM4cgsb - cgso) * ag0; + { gcggb = (here->BSIM4v7cggb + cgdo + cgso + + pParam->BSIM4v7cgbo ) * ag0; + gcgdb = (here->BSIM4v7cgdb - cgdo) * ag0; + gcgsb = (here->BSIM4v7cgsb - cgso) * ag0; gcgbb = -(gcggb + gcgdb + gcgsb); - gcdgb = (here->BSIM4cdgb - cgdo) * ag0; - gcsgb = -(here->BSIM4cggb + here->BSIM4cbgb - + here->BSIM4cdgb + cgso) * ag0; - gcbgb = (here->BSIM4cbgb - pParam->BSIM4cgbo) * ag0; + gcdgb = (here->BSIM4v7cdgb - cgdo) * ag0; + gcsgb = -(here->BSIM4v7cggb + here->BSIM4v7cbgb + + here->BSIM4v7cdgb + cgso) * ag0; + gcbgb = (here->BSIM4v7cbgb - pParam->BSIM4v7cgbo) * ag0; gcdgmb = gcsgmb = gcbgmb = 0.0; - qgb = pParam->BSIM4cgbo * vgb; + qgb = pParam->BSIM4v7cgbo * vgb; qgate += qgdo + qgso + qgb; qbulk -= qgb; qsrc = -(qgate + qbulk + qdrn); } - gcddb = (here->BSIM4cddb + here->BSIM4capbd + cgdo) * ag0; - gcdsb = here->BSIM4cdsb * ag0; + gcddb = (here->BSIM4v7cddb + here->BSIM4v7capbd + cgdo) * ag0; + gcdsb = here->BSIM4v7cdsb * ag0; - gcsdb = -(here->BSIM4cgdb + here->BSIM4cbdb - + here->BSIM4cddb) * ag0; - gcssb = (here->BSIM4capbs + cgso - (here->BSIM4cgsb - + here->BSIM4cbsb + here->BSIM4cdsb)) * ag0; + gcsdb = -(here->BSIM4v7cgdb + here->BSIM4v7cbdb + + here->BSIM4v7cddb) * ag0; + gcssb = (here->BSIM4v7capbs + cgso - (here->BSIM4v7cgsb + + here->BSIM4v7cbsb + here->BSIM4v7cdsb)) * ag0; - if (!here->BSIM4rbodyMod) + if (!here->BSIM4v7rbodyMod) { gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb); gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb); - gcbdb = (here->BSIM4cbdb - here->BSIM4capbd) * ag0; - gcbsb = (here->BSIM4cbsb - here->BSIM4capbs) * ag0; + gcbdb = (here->BSIM4v7cbdb - here->BSIM4v7capbd) * ag0; + gcbsb = (here->BSIM4v7cbsb - here->BSIM4v7capbs) * ag0; gcdbdb = 0.0; gcsbsb = 0.0; } else - { gcdbb = -(here->BSIM4cddb + here->BSIM4cdgb - + here->BSIM4cdsb) * ag0; + { gcdbb = -(here->BSIM4v7cddb + here->BSIM4v7cdgb + + here->BSIM4v7cdsb) * ag0; gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb) - + here->BSIM4capbs * ag0; - gcbdb = here->BSIM4cbdb * ag0; - gcbsb = here->BSIM4cbsb * ag0; + + here->BSIM4v7capbs * ag0; + gcbdb = here->BSIM4v7cbdb * ag0; + gcbsb = here->BSIM4v7cbsb * ag0; - gcdbdb = -here->BSIM4capbd * ag0; - gcsbsb = -here->BSIM4capbs * ag0; + gcdbdb = -here->BSIM4v7capbd * ag0; + gcsbsb = -here->BSIM4v7capbs * ag0; } gcbbb = -(gcbdb + gcbgb + gcbsb + gcbgmb); @@ -4188,27 +4188,27 @@ line755: dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0; } else - { qcheq = here->BSIM4qchqs; - CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV * here->BSIM4nf - * pParam->BSIM4leffCV; + { qcheq = here->BSIM4v7qchqs; + CoxWL = model->BSIM4v7coxe * pParam->BSIM4v7weffCV * here->BSIM4v7nf + * pParam->BSIM4v7leffCV; T0 = qdef * ScalingFactor / CoxWL; - ggtg = here->BSIM4gtg = T0 * here->BSIM4gcrgg; - ggtd = here->BSIM4gtd = T0 * here->BSIM4gcrgd; - ggts = here->BSIM4gts = T0 * here->BSIM4gcrgs; - ggtb = here->BSIM4gtb = T0 * here->BSIM4gcrgb; + ggtg = here->BSIM4v7gtg = T0 * here->BSIM4v7gcrgg; + ggtd = here->BSIM4v7gtd = T0 * here->BSIM4v7gcrgd; + ggts = here->BSIM4v7gts = T0 * here->BSIM4v7gcrgs; + ggtb = here->BSIM4v7gtb = T0 * here->BSIM4v7gcrgb; gqdef = ScalingFactor * ag0; - gcqgb = here->BSIM4cqgb * ag0; - gcqdb = here->BSIM4cqdb * ag0; - gcqsb = here->BSIM4cqsb * ag0; - gcqbb = here->BSIM4cqbb * ag0; + gcqgb = here->BSIM4v7cqgb * ag0; + gcqdb = here->BSIM4v7cqdb * ag0; + gcqsb = here->BSIM4v7cqsb * ag0; + gcqbb = here->BSIM4v7cqbb * ag0; if (fabs(qcheq) <= 1.0e-5 * CoxWL) - { if (model->BSIM4xpart < 0.5) + { if (model->BSIM4v7xpart < 0.5) { dxpart = 0.4; } - else if (model->BSIM4xpart > 0.5) + else if (model->BSIM4v7xpart > 0.5) { dxpart = 0.0; } else @@ -4219,18 +4219,18 @@ line755: } else { dxpart = qdrn / qcheq; - Cdd = here->BSIM4cddb; - Csd = -(here->BSIM4cgdb + here->BSIM4cddb - + here->BSIM4cbdb); + Cdd = here->BSIM4v7cddb; + Csd = -(here->BSIM4v7cgdb + here->BSIM4v7cddb + + here->BSIM4v7cbdb); ddxpart_dVd = (Cdd - dxpart * (Cdd + Csd)) / qcheq; - Cdg = here->BSIM4cdgb; - Csg = -(here->BSIM4cggb + here->BSIM4cdgb - + here->BSIM4cbgb); + Cdg = here->BSIM4v7cdgb; + Csg = -(here->BSIM4v7cggb + here->BSIM4v7cdgb + + here->BSIM4v7cbgb); ddxpart_dVg = (Cdg - dxpart * (Cdg + Csg)) / qcheq; - Cds = here->BSIM4cdsb; - Css = -(here->BSIM4cgsb + here->BSIM4cdsb - + here->BSIM4cbsb); + Cds = here->BSIM4v7cdsb; + Css = -(here->BSIM4v7cgsb + here->BSIM4v7cdsb + + here->BSIM4v7cbsb); ddxpart_dVs = (Cds - dxpart * (Cds + Css)) / qcheq; ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs); @@ -4241,11 +4241,11 @@ line755: dsxpart_dVs = -ddxpart_dVs; dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg + dsxpart_dVs); - if (here->BSIM4rgateMod == 3) - { gcgmgmb = (cgdo + cgso + pParam->BSIM4cgbo) * ag0; + if (here->BSIM4v7rgateMod == 3) + { gcgmgmb = (cgdo + cgso + pParam->BSIM4v7cgbo) * ag0; gcgmdb = -cgdo * ag0; gcgmsb = -cgso * ag0; - gcgmbb = -pParam->BSIM4cgbo * ag0; + gcgmbb = -pParam->BSIM4v7cgbo * ag0; gcdgmb = gcgmdb; gcsgmb = gcgmsb; @@ -4254,7 +4254,7 @@ line755: gcdgb = gcsgb = gcbgb = 0.0; gcggb = gcgdb = gcgsb = gcgbb = 0.0; - qgmb = pParam->BSIM4cgbo * vgmb; + qgmb = pParam->BSIM4v7cgbo * vgmb; qgmid = qgdo + qgso + qgmb; qgate = 0.0; qbulk = -qgmb; @@ -4262,113 +4262,113 @@ line755: qsrc = -(qgmid + qbulk + qdrn); } else - { gcggb = (cgdo + cgso + pParam->BSIM4cgbo ) * ag0; + { gcggb = (cgdo + cgso + pParam->BSIM4v7cgbo ) * ag0; gcgdb = -cgdo * ag0; gcgsb = -cgso * ag0; - gcgbb = -pParam->BSIM4cgbo * ag0; + gcgbb = -pParam->BSIM4v7cgbo * ag0; gcdgb = gcgdb; gcsgb = gcgsb; gcbgb = gcgbb; gcdgmb = gcsgmb = gcbgmb = 0.0; - qgb = pParam->BSIM4cgbo * vgb; + qgb = pParam->BSIM4v7cgbo * vgb; qgate = qgdo + qgso + qgb; qbulk = -qgb; qdrn = -qgdo; qsrc = -(qgate + qbulk + qdrn); } - gcddb = (here->BSIM4capbd + cgdo) * ag0; + gcddb = (here->BSIM4v7capbd + cgdo) * ag0; gcdsb = gcsdb = 0.0; - gcssb = (here->BSIM4capbs + cgso) * ag0; + gcssb = (here->BSIM4v7capbs + cgso) * ag0; - if (!here->BSIM4rbodyMod) + if (!here->BSIM4v7rbodyMod) { gcdbb = -(gcdgb + gcddb + gcdgmb); gcsbb = -(gcsgb + gcssb + gcsgmb); - gcbdb = -here->BSIM4capbd * ag0; - gcbsb = -here->BSIM4capbs * ag0; + gcbdb = -here->BSIM4v7capbd * ag0; + gcbsb = -here->BSIM4v7capbs * ag0; gcdbdb = 0.0; gcsbsb = 0.0; } else { gcdbb = gcsbb = gcbdb = gcbsb = 0.0; - gcdbdb = -here->BSIM4capbd * ag0; - gcsbsb = -here->BSIM4capbs * ag0; + gcdbdb = -here->BSIM4v7capbd * ag0; + gcsbsb = -here->BSIM4v7capbs * ag0; } gcbbb = -(gcbdb + gcbgb + gcbsb + gcbgmb); } } else - { if (here->BSIM4trnqsMod == 0) + { if (here->BSIM4v7trnqsMod == 0) { qsrc = qdrn - qgso; - if (here->BSIM4rgateMod == 3) - { gcgmgmb = (cgdo + cgso + pParam->BSIM4cgbo) * ag0; + if (here->BSIM4v7rgateMod == 3) + { gcgmgmb = (cgdo + cgso + pParam->BSIM4v7cgbo) * ag0; gcgmdb = -cgdo * ag0; gcgmsb = -cgso * ag0; - gcgmbb = -pParam->BSIM4cgbo * ag0; + gcgmbb = -pParam->BSIM4v7cgbo * ag0; gcdgmb = gcgmdb; gcsgmb = gcgmsb; gcbgmb = gcgmbb; - gcggb = here->BSIM4cggb * ag0; - gcgdb = here->BSIM4cgsb * ag0; - gcgsb = here->BSIM4cgdb * ag0; + gcggb = here->BSIM4v7cggb * ag0; + gcgdb = here->BSIM4v7cgsb * ag0; + gcgsb = here->BSIM4v7cgdb * ag0; gcgbb = -(gcggb + gcgdb + gcgsb); - gcdgb = -(here->BSIM4cggb + here->BSIM4cbgb - + here->BSIM4cdgb) * ag0; - gcsgb = here->BSIM4cdgb * ag0; - gcbgb = here->BSIM4cbgb * ag0; + gcdgb = -(here->BSIM4v7cggb + here->BSIM4v7cbgb + + here->BSIM4v7cdgb) * ag0; + gcsgb = here->BSIM4v7cdgb * ag0; + gcbgb = here->BSIM4v7cbgb * ag0; - qgmb = pParam->BSIM4cgbo * vgmb; + qgmb = pParam->BSIM4v7cgbo * vgmb; qgmid = qgdo + qgso + qgmb; qbulk -= qgmb; qdrn = -(qgate + qgmid + qbulk + qsrc); } else - { gcggb = (here->BSIM4cggb + cgdo + cgso - + pParam->BSIM4cgbo ) * ag0; - gcgdb = (here->BSIM4cgsb - cgdo) * ag0; - gcgsb = (here->BSIM4cgdb - cgso) * ag0; + { gcggb = (here->BSIM4v7cggb + cgdo + cgso + + pParam->BSIM4v7cgbo ) * ag0; + gcgdb = (here->BSIM4v7cgsb - cgdo) * ag0; + gcgsb = (here->BSIM4v7cgdb - cgso) * ag0; gcgbb = -(gcggb + gcgdb + gcgsb); - gcdgb = -(here->BSIM4cggb + here->BSIM4cbgb - + here->BSIM4cdgb + cgdo) * ag0; - gcsgb = (here->BSIM4cdgb - cgso) * ag0; - gcbgb = (here->BSIM4cbgb - pParam->BSIM4cgbo) * ag0; + gcdgb = -(here->BSIM4v7cggb + here->BSIM4v7cbgb + + here->BSIM4v7cdgb + cgdo) * ag0; + gcsgb = (here->BSIM4v7cdgb - cgso) * ag0; + gcbgb = (here->BSIM4v7cbgb - pParam->BSIM4v7cgbo) * ag0; gcdgmb = gcsgmb = gcbgmb = 0.0; - qgb = pParam->BSIM4cgbo * vgb; + qgb = pParam->BSIM4v7cgbo * vgb; qgate += qgdo + qgso + qgb; qbulk -= qgb; qdrn = -(qgate + qbulk + qsrc); } - gcddb = (here->BSIM4capbd + cgdo - (here->BSIM4cgsb - + here->BSIM4cbsb + here->BSIM4cdsb)) * ag0; - gcdsb = -(here->BSIM4cgdb + here->BSIM4cbdb - + here->BSIM4cddb) * ag0; + gcddb = (here->BSIM4v7capbd + cgdo - (here->BSIM4v7cgsb + + here->BSIM4v7cbsb + here->BSIM4v7cdsb)) * ag0; + gcdsb = -(here->BSIM4v7cgdb + here->BSIM4v7cbdb + + here->BSIM4v7cddb) * ag0; - gcsdb = here->BSIM4cdsb * ag0; - gcssb = (here->BSIM4cddb + here->BSIM4capbs + cgso) * ag0; + gcsdb = here->BSIM4v7cdsb * ag0; + gcssb = (here->BSIM4v7cddb + here->BSIM4v7capbs + cgso) * ag0; - if (!here->BSIM4rbodyMod) + if (!here->BSIM4v7rbodyMod) { gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb); gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb); - gcbdb = (here->BSIM4cbsb - here->BSIM4capbd) * ag0; - gcbsb = (here->BSIM4cbdb - here->BSIM4capbs) * ag0; + gcbdb = (here->BSIM4v7cbsb - here->BSIM4v7capbd) * ag0; + gcbsb = (here->BSIM4v7cbdb - here->BSIM4v7capbs) * ag0; gcdbdb = 0.0; gcsbsb = 0.0; } else { gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb) - + here->BSIM4capbd * ag0; - gcsbb = -(here->BSIM4cddb + here->BSIM4cdgb - + here->BSIM4cdsb) * ag0; - gcbdb = here->BSIM4cbsb * ag0; - gcbsb = here->BSIM4cbdb * ag0; - gcdbdb = -here->BSIM4capbd * ag0; - gcsbsb = -here->BSIM4capbs * ag0; + + here->BSIM4v7capbd * ag0; + gcsbb = -(here->BSIM4v7cddb + here->BSIM4v7cdgb + + here->BSIM4v7cdsb) * ag0; + gcbdb = here->BSIM4v7cbsb * ag0; + gcbsb = here->BSIM4v7cbdb * ag0; + gcdbdb = -here->BSIM4v7capbd * ag0; + gcsbsb = -here->BSIM4v7capbs * ag0; } gcbbb = -(gcbgb + gcbdb + gcbsb + gcbgmb); @@ -4379,26 +4379,26 @@ line755: dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0; } else - { qcheq = here->BSIM4qchqs; - CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV * here->BSIM4nf - * pParam->BSIM4leffCV; + { qcheq = here->BSIM4v7qchqs; + CoxWL = model->BSIM4v7coxe * pParam->BSIM4v7weffCV * here->BSIM4v7nf + * pParam->BSIM4v7leffCV; T0 = qdef * ScalingFactor / CoxWL; - ggtg = here->BSIM4gtg = T0 * here->BSIM4gcrgg; - ggts = here->BSIM4gts = T0 * here->BSIM4gcrgd; - ggtd = here->BSIM4gtd = T0 * here->BSIM4gcrgs; - ggtb = here->BSIM4gtb = T0 * here->BSIM4gcrgb; + ggtg = here->BSIM4v7gtg = T0 * here->BSIM4v7gcrgg; + ggts = here->BSIM4v7gts = T0 * here->BSIM4v7gcrgd; + ggtd = here->BSIM4v7gtd = T0 * here->BSIM4v7gcrgs; + ggtb = here->BSIM4v7gtb = T0 * here->BSIM4v7gcrgb; gqdef = ScalingFactor * ag0; - gcqgb = here->BSIM4cqgb * ag0; - gcqdb = here->BSIM4cqsb * ag0; - gcqsb = here->BSIM4cqdb * ag0; - gcqbb = here->BSIM4cqbb * ag0; + gcqgb = here->BSIM4v7cqgb * ag0; + gcqdb = here->BSIM4v7cqsb * ag0; + gcqsb = here->BSIM4v7cqdb * ag0; + gcqbb = here->BSIM4v7cqbb * ag0; if (fabs(qcheq) <= 1.0e-5 * CoxWL) - { if (model->BSIM4xpart < 0.5) + { if (model->BSIM4v7xpart < 0.5) { sxpart = 0.4; } - else if (model->BSIM4xpart > 0.5) + else if (model->BSIM4v7xpart > 0.5) { sxpart = 0.0; } else @@ -4409,18 +4409,18 @@ line755: } else { sxpart = qdrn / qcheq; - Css = here->BSIM4cddb; - Cds = -(here->BSIM4cgdb + here->BSIM4cddb - + here->BSIM4cbdb); + Css = here->BSIM4v7cddb; + Cds = -(here->BSIM4v7cgdb + here->BSIM4v7cddb + + here->BSIM4v7cbdb); dsxpart_dVs = (Css - sxpart * (Css + Cds)) / qcheq; - Csg = here->BSIM4cdgb; - Cdg = -(here->BSIM4cggb + here->BSIM4cdgb - + here->BSIM4cbgb); + Csg = here->BSIM4v7cdgb; + Cdg = -(here->BSIM4v7cggb + here->BSIM4v7cdgb + + here->BSIM4v7cbgb); dsxpart_dVg = (Csg - sxpart * (Csg + Cdg)) / qcheq; - Csd = here->BSIM4cdsb; - Cdd = -(here->BSIM4cgsb + here->BSIM4cdsb - + here->BSIM4cbsb); + Csd = here->BSIM4v7cdsb; + Cdd = -(here->BSIM4v7cgsb + here->BSIM4v7cdsb + + here->BSIM4v7cbsb); dsxpart_dVd = (Csd - sxpart * (Csd + Cdd)) / qcheq; dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg + dsxpart_dVs); @@ -4431,11 +4431,11 @@ line755: ddxpart_dVs = -dsxpart_dVs; ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg + ddxpart_dVs); - if (here->BSIM4rgateMod == 3) - { gcgmgmb = (cgdo + cgso + pParam->BSIM4cgbo) * ag0; + if (here->BSIM4v7rgateMod == 3) + { gcgmgmb = (cgdo + cgso + pParam->BSIM4v7cgbo) * ag0; gcgmdb = -cgdo * ag0; gcgmsb = -cgso * ag0; - gcgmbb = -pParam->BSIM4cgbo * ag0; + gcgmbb = -pParam->BSIM4v7cgbo * ag0; gcdgmb = gcgmdb; gcsgmb = gcgmsb; @@ -4444,7 +4444,7 @@ line755: gcdgb = gcsgb = gcbgb = 0.0; gcggb = gcgdb = gcgsb = gcgbb = 0.0; - qgmb = pParam->BSIM4cgbo * vgmb; + qgmb = pParam->BSIM4v7cgbo * vgmb; qgmid = qgdo + qgso + qgmb; qgate = 0.0; qbulk = -qgmb; @@ -4452,70 +4452,70 @@ line755: qsrc = -qgso; } else - { gcggb = (cgdo + cgso + pParam->BSIM4cgbo ) * ag0; + { gcggb = (cgdo + cgso + pParam->BSIM4v7cgbo ) * ag0; gcgdb = -cgdo * ag0; gcgsb = -cgso * ag0; - gcgbb = -pParam->BSIM4cgbo * ag0; + gcgbb = -pParam->BSIM4v7cgbo * ag0; gcdgb = gcgdb; gcsgb = gcgsb; gcbgb = gcgbb; gcdgmb = gcsgmb = gcbgmb = 0.0; - qgb = pParam->BSIM4cgbo * vgb; + qgb = pParam->BSIM4v7cgbo * vgb; qgate = qgdo + qgso + qgb; qbulk = -qgb; qdrn = -qgdo; qsrc = -qgso; } - gcddb = (here->BSIM4capbd + cgdo) * ag0; + gcddb = (here->BSIM4v7capbd + cgdo) * ag0; gcdsb = gcsdb = 0.0; - gcssb = (here->BSIM4capbs + cgso) * ag0; - if (!here->BSIM4rbodyMod) + gcssb = (here->BSIM4v7capbs + cgso) * ag0; + if (!here->BSIM4v7rbodyMod) { gcdbb = -(gcdgb + gcddb + gcdgmb); gcsbb = -(gcsgb + gcssb + gcsgmb); - gcbdb = -here->BSIM4capbd * ag0; - gcbsb = -here->BSIM4capbs * ag0; + gcbdb = -here->BSIM4v7capbd * ag0; + gcbsb = -here->BSIM4v7capbs * ag0; gcdbdb = 0.0; gcsbsb = 0.0; } else { gcdbb = gcsbb = gcbdb = gcbsb = 0.0; - gcdbdb = -here->BSIM4capbd * ag0; - gcsbsb = -here->BSIM4capbs * ag0; + gcdbdb = -here->BSIM4v7capbd * ag0; + gcsbsb = -here->BSIM4v7capbs * ag0; } gcbbb = -(gcbdb + gcbgb + gcbsb + gcbgmb); } } - if (here->BSIM4trnqsMod) - { *(ckt->CKTstate0 + here->BSIM4qcdump) = qdef * ScalingFactor; + if (here->BSIM4v7trnqsMod) + { *(ckt->CKTstate0 + here->BSIM4v7qcdump) = qdef * ScalingFactor; if (ckt->CKTmode & MODEINITTRAN) - *(ckt->CKTstate1 + here->BSIM4qcdump) = - *(ckt->CKTstate0 + here->BSIM4qcdump); - error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qcdump); + *(ckt->CKTstate1 + here->BSIM4v7qcdump) = + *(ckt->CKTstate0 + here->BSIM4v7qcdump); + error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4v7qcdump); if (error) return(error); } if (ByPass) goto line860; - *(ckt->CKTstate0 + here->BSIM4qg) = qgate; - *(ckt->CKTstate0 + here->BSIM4qd) = qdrn - - *(ckt->CKTstate0 + here->BSIM4qbd); - *(ckt->CKTstate0 + here->BSIM4qs) = qsrc - - *(ckt->CKTstate0 + here->BSIM4qbs); - if (here->BSIM4rgateMod == 3) - *(ckt->CKTstate0 + here->BSIM4qgmid) = qgmid; + *(ckt->CKTstate0 + here->BSIM4v7qg) = qgate; + *(ckt->CKTstate0 + here->BSIM4v7qd) = qdrn + - *(ckt->CKTstate0 + here->BSIM4v7qbd); + *(ckt->CKTstate0 + here->BSIM4v7qs) = qsrc + - *(ckt->CKTstate0 + here->BSIM4v7qbs); + if (here->BSIM4v7rgateMod == 3) + *(ckt->CKTstate0 + here->BSIM4v7qgmid) = qgmid; - if (!here->BSIM4rbodyMod) - { *(ckt->CKTstate0 + here->BSIM4qb) = qbulk - + *(ckt->CKTstate0 + here->BSIM4qbd) - + *(ckt->CKTstate0 + here->BSIM4qbs); + if (!here->BSIM4v7rbodyMod) + { *(ckt->CKTstate0 + here->BSIM4v7qb) = qbulk + + *(ckt->CKTstate0 + here->BSIM4v7qbd) + + *(ckt->CKTstate0 + here->BSIM4v7qbs); } else - *(ckt->CKTstate0 + here->BSIM4qb) = qbulk; + *(ckt->CKTstate0 + here->BSIM4v7qb) = qbulk; /* Store small signal parameters */ @@ -4527,43 +4527,43 @@ line755: goto line850; if (ckt->CKTmode & MODEINITTRAN) - { *(ckt->CKTstate1 + here->BSIM4qb) = - *(ckt->CKTstate0 + here->BSIM4qb); - *(ckt->CKTstate1 + here->BSIM4qg) = - *(ckt->CKTstate0 + here->BSIM4qg); - *(ckt->CKTstate1 + here->BSIM4qd) = - *(ckt->CKTstate0 + here->BSIM4qd); - if (here->BSIM4rgateMod == 3) - *(ckt->CKTstate1 + here->BSIM4qgmid) = - *(ckt->CKTstate0 + here->BSIM4qgmid); - if (here->BSIM4rbodyMod) - { *(ckt->CKTstate1 + here->BSIM4qbs) = - *(ckt->CKTstate0 + here->BSIM4qbs); - *(ckt->CKTstate1 + here->BSIM4qbd) = - *(ckt->CKTstate0 + here->BSIM4qbd); + { *(ckt->CKTstate1 + here->BSIM4v7qb) = + *(ckt->CKTstate0 + here->BSIM4v7qb); + *(ckt->CKTstate1 + here->BSIM4v7qg) = + *(ckt->CKTstate0 + here->BSIM4v7qg); + *(ckt->CKTstate1 + here->BSIM4v7qd) = + *(ckt->CKTstate0 + here->BSIM4v7qd); + if (here->BSIM4v7rgateMod == 3) + *(ckt->CKTstate1 + here->BSIM4v7qgmid) = + *(ckt->CKTstate0 + here->BSIM4v7qgmid); + if (here->BSIM4v7rbodyMod) + { *(ckt->CKTstate1 + here->BSIM4v7qbs) = + *(ckt->CKTstate0 + here->BSIM4v7qbs); + *(ckt->CKTstate1 + here->BSIM4v7qbd) = + *(ckt->CKTstate0 + here->BSIM4v7qbd); } } - error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qb); + error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4v7qb); if (error) return(error); - error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qg); + error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4v7qg); if (error) return(error); - error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qd); + error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4v7qd); if (error) return(error); - if (here->BSIM4rgateMod == 3) - { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qgmid); + if (here->BSIM4v7rgateMod == 3) + { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4v7qgmid); if (error) return(error); } - if (here->BSIM4rbodyMod) - { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qbs); + if (here->BSIM4v7rbodyMod) + { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4v7qbs); if (error) return(error); - error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4qbd); + error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM4v7qbd); if (error) return(error); } @@ -4588,18 +4588,18 @@ line850: gqdef = gcqgb = gcqdb = gcqsb = gcqbb = 0.0; ggtg = ggtd = ggtb = ggts = 0.0; - sxpart = (1.0 - (dxpart = (here->BSIM4mode > 0) ? 0.4 : 0.6)); + sxpart = (1.0 - (dxpart = (here->BSIM4v7mode > 0) ? 0.4 : 0.6)); ddxpart_dVd = ddxpart_dVg = ddxpart_dVb = ddxpart_dVs = 0.0; dsxpart_dVd = dsxpart_dVg = dsxpart_dVb = dsxpart_dVs = 0.0; - if (here->BSIM4trnqsMod) - { CoxWL = model->BSIM4coxe * pParam->BSIM4weffCV * here->BSIM4nf - * pParam->BSIM4leffCV; - T1 = here->BSIM4gcrg / CoxWL; - here->BSIM4gtau = T1 * ScalingFactor; + if (here->BSIM4v7trnqsMod) + { CoxWL = model->BSIM4v7coxe * pParam->BSIM4v7weffCV * here->BSIM4v7nf + * pParam->BSIM4v7leffCV; + T1 = here->BSIM4v7gcrg / CoxWL; + here->BSIM4v7gtau = T1 * ScalingFactor; } else - here->BSIM4gtau = 0.0; + here->BSIM4v7gtau = 0.0; goto line900; @@ -4607,9 +4607,9 @@ line850: line860: /* Calculate equivalent charge current */ - cqgate = *(ckt->CKTstate0 + here->BSIM4cqg); - cqbody = *(ckt->CKTstate0 + here->BSIM4cqb); - cqdrn = *(ckt->CKTstate0 + here->BSIM4cqd); + cqgate = *(ckt->CKTstate0 + here->BSIM4v7cqg); + cqbody = *(ckt->CKTstate0 + here->BSIM4v7cqb); + cqdrn = *(ckt->CKTstate0 + here->BSIM4v7cqd); ceqqg = cqgate - gcggb * vgb + gcgdb * vbd + gcgsb * vbs; ceqqd = cqdrn - gcdgb * vgb - gcdgmb * vgmb + (gcddb + gcdbdb) @@ -4618,45 +4618,45 @@ line860: + gcbdb * vbd + gcbsb * vbs; - if (here->BSIM4rgateMod == 3) - ceqqgmid = *(ckt->CKTstate0 + here->BSIM4cqgmid) + if (here->BSIM4v7rgateMod == 3) + ceqqgmid = *(ckt->CKTstate0 + here->BSIM4v7cqgmid) + gcgmdb * vbd + gcgmsb * vbs - gcgmgmb * vgmb; else ceqqgmid = 0.0; - if (here->BSIM4rbodyMod) - { ceqqjs = *(ckt->CKTstate0 + here->BSIM4cqbs) + gcsbsb * vbs_jct; - ceqqjd = *(ckt->CKTstate0 + here->BSIM4cqbd) + gcdbdb * vbd_jct; + if (here->BSIM4v7rbodyMod) + { ceqqjs = *(ckt->CKTstate0 + here->BSIM4v7cqbs) + gcsbsb * vbs_jct; + ceqqjd = *(ckt->CKTstate0 + here->BSIM4v7cqbd) + gcdbdb * vbd_jct; } - if (here->BSIM4trnqsMod) + if (here->BSIM4v7trnqsMod) { T0 = ggtg * vgb - ggtd * vbd - ggts * vbs; ceqqg += T0; - T1 = qdef * here->BSIM4gtau; + T1 = qdef * here->BSIM4v7gtau; ceqqd -= dxpart * T0 + T1 * (ddxpart_dVg * vgb - ddxpart_dVd * vbd - ddxpart_dVs * vbs); - cqdef = *(ckt->CKTstate0 + here->BSIM4cqcdump) - gqdef * qdef; - cqcheq = *(ckt->CKTstate0 + here->BSIM4cqcheq) + cqdef = *(ckt->CKTstate0 + here->BSIM4v7cqcdump) - gqdef * qdef; + cqcheq = *(ckt->CKTstate0 + here->BSIM4v7cqcheq) - (gcqgb * vgb - gcqdb * vbd - gcqsb * vbs) + T0; } if (ckt->CKTmode & MODEINITTRAN) - { *(ckt->CKTstate1 + here->BSIM4cqb) = - *(ckt->CKTstate0 + here->BSIM4cqb); - *(ckt->CKTstate1 + here->BSIM4cqg) = - *(ckt->CKTstate0 + here->BSIM4cqg); - *(ckt->CKTstate1 + here->BSIM4cqd) = - *(ckt->CKTstate0 + here->BSIM4cqd); + { *(ckt->CKTstate1 + here->BSIM4v7cqb) = + *(ckt->CKTstate0 + here->BSIM4v7cqb); + *(ckt->CKTstate1 + here->BSIM4v7cqg) = + *(ckt->CKTstate0 + here->BSIM4v7cqg); + *(ckt->CKTstate1 + here->BSIM4v7cqd) = + *(ckt->CKTstate0 + here->BSIM4v7cqd); - if (here->BSIM4rgateMod == 3) - *(ckt->CKTstate1 + here->BSIM4cqgmid) = - *(ckt->CKTstate0 + here->BSIM4cqgmid); + if (here->BSIM4v7rgateMod == 3) + *(ckt->CKTstate1 + here->BSIM4v7cqgmid) = + *(ckt->CKTstate0 + here->BSIM4v7cqgmid); - if (here->BSIM4rbodyMod) - { *(ckt->CKTstate1 + here->BSIM4cqbs) = - *(ckt->CKTstate0 + here->BSIM4cqbs); - *(ckt->CKTstate1 + here->BSIM4cqbd) = - *(ckt->CKTstate0 + here->BSIM4cqbd); + if (here->BSIM4v7rbodyMod) + { *(ckt->CKTstate1 + here->BSIM4v7cqbs) = + *(ckt->CKTstate0 + here->BSIM4v7cqbs); + *(ckt->CKTstate1 + here->BSIM4v7cqbd) = + *(ckt->CKTstate0 + here->BSIM4v7cqbd); } } @@ -4666,27 +4666,27 @@ line860: */ line900: - if (here->BSIM4mode >= 0) - { Gm = here->BSIM4gm; - Gmbs = here->BSIM4gmbs; + if (here->BSIM4v7mode >= 0) + { Gm = here->BSIM4v7gm; + Gmbs = here->BSIM4v7gmbs; FwdSum = Gm + Gmbs; RevSum = 0.0; - ceqdrn = model->BSIM4type * (cdrain - here->BSIM4gds * vds + ceqdrn = model->BSIM4v7type * (cdrain - here->BSIM4v7gds * vds - Gm * vgs - Gmbs * vbs); - ceqbd = model->BSIM4type * (here->BSIM4csub + here->BSIM4Igidl - - (here->BSIM4gbds + here->BSIM4ggidld) * vds - - (here->BSIM4gbgs + here->BSIM4ggidlg) * vgs - - (here->BSIM4gbbs + here->BSIM4ggidlb) * vbs); - ceqbs = model->BSIM4type * (here->BSIM4Igisl + here->BSIM4ggisls * vds - - here->BSIM4ggislg * vgd - here->BSIM4ggislb * vbd); + ceqbd = model->BSIM4v7type * (here->BSIM4v7csub + here->BSIM4v7Igidl + - (here->BSIM4v7gbds + here->BSIM4v7ggidld) * vds + - (here->BSIM4v7gbgs + here->BSIM4v7ggidlg) * vgs + - (here->BSIM4v7gbbs + here->BSIM4v7ggidlb) * vbs); + ceqbs = model->BSIM4v7type * (here->BSIM4v7Igisl + here->BSIM4v7ggisls * vds + - here->BSIM4v7ggislg * vgd - here->BSIM4v7ggislb * vbd); - gbbdp = -(here->BSIM4gbds); - gbbsp = here->BSIM4gbds + here->BSIM4gbgs + here->BSIM4gbbs; + gbbdp = -(here->BSIM4v7gbds); + gbbsp = here->BSIM4v7gbds + here->BSIM4v7gbgs + here->BSIM4v7gbbs; - gbdpg = here->BSIM4gbgs; - gbdpdp = here->BSIM4gbds; - gbdpb = here->BSIM4gbbs; + gbdpg = here->BSIM4v7gbgs; + gbdpdp = here->BSIM4v7gbds; + gbdpb = here->BSIM4v7gbbs; gbdpsp = -(gbdpg + gbdpdp + gbdpb); gbspg = 0.0; @@ -4694,41 +4694,41 @@ line900: gbspb = 0.0; gbspsp = 0.0; - if (model->BSIM4igcMod) - { gIstotg = here->BSIM4gIgsg + here->BSIM4gIgcsg; - gIstotd = here->BSIM4gIgcsd; - gIstots = here->BSIM4gIgss + here->BSIM4gIgcss; - gIstotb = here->BSIM4gIgcsb; - Istoteq = model->BSIM4type * (here->BSIM4Igs + here->BSIM4Igcs - - gIstotg * vgs - here->BSIM4gIgcsd * vds - - here->BSIM4gIgcsb * vbs); + if (model->BSIM4v7igcMod) + { gIstotg = here->BSIM4v7gIgsg + here->BSIM4v7gIgcsg; + gIstotd = here->BSIM4v7gIgcsd; + gIstots = here->BSIM4v7gIgss + here->BSIM4v7gIgcss; + gIstotb = here->BSIM4v7gIgcsb; + Istoteq = model->BSIM4v7type * (here->BSIM4v7Igs + here->BSIM4v7Igcs + - gIstotg * vgs - here->BSIM4v7gIgcsd * vds + - here->BSIM4v7gIgcsb * vbs); - gIdtotg = here->BSIM4gIgdg + here->BSIM4gIgcdg; - gIdtotd = here->BSIM4gIgdd + here->BSIM4gIgcdd; - gIdtots = here->BSIM4gIgcds; - gIdtotb = here->BSIM4gIgcdb; - Idtoteq = model->BSIM4type * (here->BSIM4Igd + here->BSIM4Igcd - - here->BSIM4gIgdg * vgd - here->BSIM4gIgcdg * vgs - - here->BSIM4gIgcdd * vds - here->BSIM4gIgcdb * vbs); + gIdtotg = here->BSIM4v7gIgdg + here->BSIM4v7gIgcdg; + gIdtotd = here->BSIM4v7gIgdd + here->BSIM4v7gIgcdd; + gIdtots = here->BSIM4v7gIgcds; + gIdtotb = here->BSIM4v7gIgcdb; + Idtoteq = model->BSIM4v7type * (here->BSIM4v7Igd + here->BSIM4v7Igcd + - here->BSIM4v7gIgdg * vgd - here->BSIM4v7gIgcdg * vgs + - here->BSIM4v7gIgcdd * vds - here->BSIM4v7gIgcdb * vbs); } else { gIstotg = gIstotd = gIstots = gIstotb = Istoteq = 0.0; gIdtotg = gIdtotd = gIdtots = gIdtotb = Idtoteq = 0.0; } - if (model->BSIM4igbMod) - { gIbtotg = here->BSIM4gIgbg; - gIbtotd = here->BSIM4gIgbd; - gIbtots = here->BSIM4gIgbs; - gIbtotb = here->BSIM4gIgbb; - Ibtoteq = model->BSIM4type * (here->BSIM4Igb - - here->BSIM4gIgbg * vgs - here->BSIM4gIgbd * vds - - here->BSIM4gIgbb * vbs); + if (model->BSIM4v7igbMod) + { gIbtotg = here->BSIM4v7gIgbg; + gIbtotd = here->BSIM4v7gIgbd; + gIbtots = here->BSIM4v7gIgbs; + gIbtotb = here->BSIM4v7gIgbb; + Ibtoteq = model->BSIM4v7type * (here->BSIM4v7Igb + - here->BSIM4v7gIgbg * vgs - here->BSIM4v7gIgbd * vds + - here->BSIM4v7gIgbb * vbs); } else gIbtotg = gIbtotd = gIbtots = gIbtotb = Ibtoteq = 0.0; - if ((model->BSIM4igcMod != 0) || (model->BSIM4igbMod != 0)) + if ((model->BSIM4v7igcMod != 0) || (model->BSIM4v7igbMod != 0)) { gIgtotg = gIstotg + gIdtotg + gIbtotg; gIgtotd = gIstotd + gIdtotd + gIbtotd ; gIgtots = gIstots + gIdtots + gIbtots; @@ -4739,87 +4739,87 @@ line900: gIgtotg = gIgtotd = gIgtots = gIgtotb = Igtoteq = 0.0; - if (here->BSIM4rgateMod == 2) + if (here->BSIM4v7rgateMod == 2) T0 = vges - vgs; - else if (here->BSIM4rgateMod == 3) + else if (here->BSIM4v7rgateMod == 3) T0 = vgms - vgs; - if (here->BSIM4rgateMod > 1) - { gcrgd = here->BSIM4gcrgd * T0; - gcrgg = here->BSIM4gcrgg * T0; - gcrgs = here->BSIM4gcrgs * T0; - gcrgb = here->BSIM4gcrgb * T0; + if (here->BSIM4v7rgateMod > 1) + { gcrgd = here->BSIM4v7gcrgd * T0; + gcrgg = here->BSIM4v7gcrgg * T0; + gcrgs = here->BSIM4v7gcrgs * T0; + gcrgb = here->BSIM4v7gcrgb * T0; ceqgcrg = -(gcrgd * vds + gcrgg * vgs + gcrgb * vbs); - gcrgg -= here->BSIM4gcrg; - gcrg = here->BSIM4gcrg; + gcrgg -= here->BSIM4v7gcrg; + gcrg = here->BSIM4v7gcrg; } else ceqgcrg = gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0; } else - { Gm = -here->BSIM4gm; - Gmbs = -here->BSIM4gmbs; + { Gm = -here->BSIM4v7gm; + Gmbs = -here->BSIM4v7gmbs; FwdSum = 0.0; RevSum = -(Gm + Gmbs); - ceqdrn = -model->BSIM4type * (cdrain + here->BSIM4gds * vds + ceqdrn = -model->BSIM4v7type * (cdrain + here->BSIM4v7gds * vds + Gm * vgd + Gmbs * vbd); - ceqbs = model->BSIM4type * (here->BSIM4csub + here->BSIM4Igisl - + (here->BSIM4gbds + here->BSIM4ggisls) * vds - - (here->BSIM4gbgs + here->BSIM4ggislg) * vgd - - (here->BSIM4gbbs + here->BSIM4ggislb) * vbd); - ceqbd = model->BSIM4type * (here->BSIM4Igidl - here->BSIM4ggidld * vds - - here->BSIM4ggidlg * vgs - here->BSIM4ggidlb * vbs); + ceqbs = model->BSIM4v7type * (here->BSIM4v7csub + here->BSIM4v7Igisl + + (here->BSIM4v7gbds + here->BSIM4v7ggisls) * vds + - (here->BSIM4v7gbgs + here->BSIM4v7ggislg) * vgd + - (here->BSIM4v7gbbs + here->BSIM4v7ggislb) * vbd); + ceqbd = model->BSIM4v7type * (here->BSIM4v7Igidl - here->BSIM4v7ggidld * vds + - here->BSIM4v7ggidlg * vgs - here->BSIM4v7ggidlb * vbs); - gbbsp = -(here->BSIM4gbds); - gbbdp = here->BSIM4gbds + here->BSIM4gbgs + here->BSIM4gbbs; + gbbsp = -(here->BSIM4v7gbds); + gbbdp = here->BSIM4v7gbds + here->BSIM4v7gbgs + here->BSIM4v7gbbs; gbdpg = 0.0; gbdpsp = 0.0; gbdpb = 0.0; gbdpdp = 0.0; - gbspg = here->BSIM4gbgs; - gbspsp = here->BSIM4gbds; - gbspb = here->BSIM4gbbs; + gbspg = here->BSIM4v7gbgs; + gbspsp = here->BSIM4v7gbds; + gbspb = here->BSIM4v7gbbs; gbspdp = -(gbspg + gbspsp + gbspb); - if (model->BSIM4igcMod) - { gIstotg = here->BSIM4gIgsg + here->BSIM4gIgcdg; - gIstotd = here->BSIM4gIgcds; - gIstots = here->BSIM4gIgss + here->BSIM4gIgcdd; - gIstotb = here->BSIM4gIgcdb; - Istoteq = model->BSIM4type * (here->BSIM4Igs + here->BSIM4Igcd - - here->BSIM4gIgsg * vgs - here->BSIM4gIgcdg * vgd - + here->BSIM4gIgcdd * vds - here->BSIM4gIgcdb * vbd); + if (model->BSIM4v7igcMod) + { gIstotg = here->BSIM4v7gIgsg + here->BSIM4v7gIgcdg; + gIstotd = here->BSIM4v7gIgcds; + gIstots = here->BSIM4v7gIgss + here->BSIM4v7gIgcdd; + gIstotb = here->BSIM4v7gIgcdb; + Istoteq = model->BSIM4v7type * (here->BSIM4v7Igs + here->BSIM4v7Igcd + - here->BSIM4v7gIgsg * vgs - here->BSIM4v7gIgcdg * vgd + + here->BSIM4v7gIgcdd * vds - here->BSIM4v7gIgcdb * vbd); - gIdtotg = here->BSIM4gIgdg + here->BSIM4gIgcsg; - gIdtotd = here->BSIM4gIgdd + here->BSIM4gIgcss; - gIdtots = here->BSIM4gIgcsd; - gIdtotb = here->BSIM4gIgcsb; - Idtoteq = model->BSIM4type * (here->BSIM4Igd + here->BSIM4Igcs - - (here->BSIM4gIgdg + here->BSIM4gIgcsg) * vgd - + here->BSIM4gIgcsd * vds - here->BSIM4gIgcsb * vbd); + gIdtotg = here->BSIM4v7gIgdg + here->BSIM4v7gIgcsg; + gIdtotd = here->BSIM4v7gIgdd + here->BSIM4v7gIgcss; + gIdtots = here->BSIM4v7gIgcsd; + gIdtotb = here->BSIM4v7gIgcsb; + Idtoteq = model->BSIM4v7type * (here->BSIM4v7Igd + here->BSIM4v7Igcs + - (here->BSIM4v7gIgdg + here->BSIM4v7gIgcsg) * vgd + + here->BSIM4v7gIgcsd * vds - here->BSIM4v7gIgcsb * vbd); } else { gIstotg = gIstotd = gIstots = gIstotb = Istoteq = 0.0; gIdtotg = gIdtotd = gIdtots = gIdtotb = Idtoteq = 0.0; } - if (model->BSIM4igbMod) - { gIbtotg = here->BSIM4gIgbg; - gIbtotd = here->BSIM4gIgbs; - gIbtots = here->BSIM4gIgbd; - gIbtotb = here->BSIM4gIgbb; - Ibtoteq = model->BSIM4type * (here->BSIM4Igb - - here->BSIM4gIgbg * vgd + here->BSIM4gIgbd * vds - - here->BSIM4gIgbb * vbd); + if (model->BSIM4v7igbMod) + { gIbtotg = here->BSIM4v7gIgbg; + gIbtotd = here->BSIM4v7gIgbs; + gIbtots = here->BSIM4v7gIgbd; + gIbtotb = here->BSIM4v7gIgbb; + Ibtoteq = model->BSIM4v7type * (here->BSIM4v7Igb + - here->BSIM4v7gIgbg * vgd + here->BSIM4v7gIgbd * vds + - here->BSIM4v7gIgbb * vbd); } else gIbtotg = gIbtotd = gIbtots = gIbtotb = Ibtoteq = 0.0; - if ((model->BSIM4igcMod != 0) || (model->BSIM4igbMod != 0)) + if ((model->BSIM4v7igcMod != 0) || (model->BSIM4v7igbMod != 0)) { gIgtotg = gIstotg + gIdtotg + gIbtotg; gIgtotd = gIstotd + gIdtotd + gIbtotd ; gIgtots = gIstots + gIdtots + gIbtots; @@ -4830,71 +4830,71 @@ line900: gIgtotg = gIgtotd = gIgtots = gIgtotb = Igtoteq = 0.0; - if (here->BSIM4rgateMod == 2) + if (here->BSIM4v7rgateMod == 2) T0 = vges - vgs; - else if (here->BSIM4rgateMod == 3) + else if (here->BSIM4v7rgateMod == 3) T0 = vgms - vgs; - if (here->BSIM4rgateMod > 1) - { gcrgd = here->BSIM4gcrgs * T0; - gcrgg = here->BSIM4gcrgg * T0; - gcrgs = here->BSIM4gcrgd * T0; - gcrgb = here->BSIM4gcrgb * T0; + if (here->BSIM4v7rgateMod > 1) + { gcrgd = here->BSIM4v7gcrgs * T0; + gcrgg = here->BSIM4v7gcrgg * T0; + gcrgs = here->BSIM4v7gcrgd * T0; + gcrgb = here->BSIM4v7gcrgb * T0; ceqgcrg = -(gcrgg * vgd - gcrgs * vds + gcrgb * vbd); - gcrgg -= here->BSIM4gcrg; - gcrg = here->BSIM4gcrg; + gcrgg -= here->BSIM4v7gcrg; + gcrg = here->BSIM4v7gcrg; } else ceqgcrg = gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0; } - if (model->BSIM4rdsMod == 1) - { ceqgstot = model->BSIM4type * (here->BSIM4gstotd * vds - + here->BSIM4gstotg * vgs + here->BSIM4gstotb * vbs); + if (model->BSIM4v7rdsMod == 1) + { ceqgstot = model->BSIM4v7type * (here->BSIM4v7gstotd * vds + + here->BSIM4v7gstotg * vgs + here->BSIM4v7gstotb * vbs); /* WDLiu: ceqgstot flowing away from sNodePrime */ - gstot = here->BSIM4gstot; - gstotd = here->BSIM4gstotd; - gstotg = here->BSIM4gstotg; - gstots = here->BSIM4gstots - gstot; - gstotb = here->BSIM4gstotb; + gstot = here->BSIM4v7gstot; + gstotd = here->BSIM4v7gstotd; + gstotg = here->BSIM4v7gstotg; + gstots = here->BSIM4v7gstots - gstot; + gstotb = here->BSIM4v7gstotb; - ceqgdtot = -model->BSIM4type * (here->BSIM4gdtotd * vds - + here->BSIM4gdtotg * vgs + here->BSIM4gdtotb * vbs); + ceqgdtot = -model->BSIM4v7type * (here->BSIM4v7gdtotd * vds + + here->BSIM4v7gdtotg * vgs + here->BSIM4v7gdtotb * vbs); /* WDLiu: ceqgdtot defined as flowing into dNodePrime */ - gdtot = here->BSIM4gdtot; - gdtotd = here->BSIM4gdtotd - gdtot; - gdtotg = here->BSIM4gdtotg; - gdtots = here->BSIM4gdtots; - gdtotb = here->BSIM4gdtotb; + gdtot = here->BSIM4v7gdtot; + gdtotd = here->BSIM4v7gdtotd - gdtot; + gdtotg = here->BSIM4v7gdtotg; + gdtots = here->BSIM4v7gdtots; + gdtotb = here->BSIM4v7gdtotb; } else { gstot = gstotd = gstotg = gstots = gstotb = ceqgstot = 0.0; gdtot = gdtotd = gdtotg = gdtots = gdtotb = ceqgdtot = 0.0; } - if (model->BSIM4type > 0) - { ceqjs = (here->BSIM4cbs - here->BSIM4gbs * vbs_jct); - ceqjd = (here->BSIM4cbd - here->BSIM4gbd * vbd_jct); + if (model->BSIM4v7type > 0) + { ceqjs = (here->BSIM4v7cbs - here->BSIM4v7gbs * vbs_jct); + ceqjd = (here->BSIM4v7cbd - here->BSIM4v7gbd * vbd_jct); } else - { ceqjs = -(here->BSIM4cbs - here->BSIM4gbs * vbs_jct); - ceqjd = -(here->BSIM4cbd - here->BSIM4gbd * vbd_jct); + { ceqjs = -(here->BSIM4v7cbs - here->BSIM4v7gbs * vbs_jct); + ceqjd = -(here->BSIM4v7cbd - here->BSIM4v7gbd * vbd_jct); ceqqg = -ceqqg; ceqqd = -ceqqd; ceqqb = -ceqqb; ceqgcrg = -ceqgcrg; - if (here->BSIM4trnqsMod) + if (here->BSIM4v7trnqsMod) { cqdef = -cqdef; cqcheq = -cqcheq; } - if (here->BSIM4rbodyMod) + if (here->BSIM4v7rbodyMod) { ceqqjs = -ceqqjs; ceqqjd = -ceqqjd; } - if (here->BSIM4rgateMod == 3) + if (here->BSIM4v7rgateMod == 3) ceqqgmid = -ceqqgmid; } @@ -4903,411 +4903,411 @@ line900: * Loading RHS */ - m = here->BSIM4m; + m = here->BSIM4v7m; #ifdef USE_OMP - here->BSIM4rhsdPrime = m * (ceqjd - ceqbd + ceqgdtot + here->BSIM4v7rhsdPrime = m * (ceqjd - ceqbd + ceqgdtot - ceqdrn - ceqqd + Idtoteq); - here->BSIM4rhsgPrime = m * (ceqqg - ceqgcrg + Igtoteq); + here->BSIM4v7rhsgPrime = m * (ceqqg - ceqgcrg + Igtoteq); - if (here->BSIM4rgateMod == 2) - here->BSIM4rhsgExt = m * ceqgcrg; - else if (here->BSIM4rgateMod == 3) - here->BSIM4grhsMid = m * (ceqqgmid + ceqgcrg); + if (here->BSIM4v7rgateMod == 2) + here->BSIM4v7rhsgExt = m * ceqgcrg; + else if (here->BSIM4v7rgateMod == 3) + here->BSIM4v7grhsMid = m * (ceqqgmid + ceqgcrg); - if (!here->BSIM4rbodyMod) - { here->BSIM4rhsbPrime = m * (ceqbd + ceqbs - ceqjd + if (!here->BSIM4v7rbodyMod) + { here->BSIM4v7rhsbPrime = m * (ceqbd + ceqbs - ceqjd - ceqjs - ceqqb + Ibtoteq); - here->BSIM4rhssPrime = m * (ceqdrn - ceqbs + ceqjs + here->BSIM4v7rhssPrime = m * (ceqdrn - ceqbs + ceqjs + ceqqg + ceqqb + ceqqd + ceqqgmid - ceqgstot + Istoteq); } else - { here->BSIM4rhsdb = m * (ceqjd + ceqqjd); - here->BSIM4rhsbPrime = m * (ceqbd + ceqbs - ceqqb + Ibtoteq); - here->BSIM4rhssb = m * (ceqjs + ceqqjs); - here->BSIM4rhssPrime = m * (ceqdrn - ceqbs + ceqjs + ceqqd + { here->BSIM4v7rhsdb = m * (ceqjd + ceqqjd); + here->BSIM4v7rhsbPrime = m * (ceqbd + ceqbs - ceqqb + Ibtoteq); + here->BSIM4v7rhssb = m * (ceqjs + ceqqjs); + here->BSIM4v7rhssPrime = m * (ceqdrn - ceqbs + ceqjs + ceqqd + ceqqg + ceqqb + ceqqjd + ceqqjs + ceqqgmid - ceqgstot + Istoteq); } - if (model->BSIM4rdsMod) - { here->BSIM4rhsd = m * ceqgdtot; - here->BSIM4rhss = m * ceqgstot; + if (model->BSIM4v7rdsMod) + { here->BSIM4v7rhsd = m * ceqgdtot; + here->BSIM4v7rhss = m * ceqgstot; } - if (here->BSIM4trnqsMod) - here->BSIM4rhsq = m * (cqcheq - cqdef); + if (here->BSIM4v7trnqsMod) + here->BSIM4v7rhsq = m * (cqcheq - cqdef); #else - (*(ckt->CKTrhs + here->BSIM4dNodePrime) += m * (ceqjd - ceqbd + ceqgdtot + (*(ckt->CKTrhs + here->BSIM4v7dNodePrime) += m * (ceqjd - ceqbd + ceqgdtot - ceqdrn - ceqqd + Idtoteq)); - (*(ckt->CKTrhs + here->BSIM4gNodePrime) -= m * (ceqqg - ceqgcrg + Igtoteq)); + (*(ckt->CKTrhs + here->BSIM4v7gNodePrime) -= m * (ceqqg - ceqgcrg + Igtoteq)); - if (here->BSIM4rgateMod == 2) - (*(ckt->CKTrhs + here->BSIM4gNodeExt) -= m * ceqgcrg); - else if (here->BSIM4rgateMod == 3) - (*(ckt->CKTrhs + here->BSIM4gNodeMid) -= m * (ceqqgmid + ceqgcrg)); + if (here->BSIM4v7rgateMod == 2) + (*(ckt->CKTrhs + here->BSIM4v7gNodeExt) -= m * ceqgcrg); + else if (here->BSIM4v7rgateMod == 3) + (*(ckt->CKTrhs + here->BSIM4v7gNodeMid) -= m * (ceqqgmid + ceqgcrg)); - if (!here->BSIM4rbodyMod) - { (*(ckt->CKTrhs + here->BSIM4bNodePrime) += m * (ceqbd + ceqbs - ceqjd + if (!here->BSIM4v7rbodyMod) + { (*(ckt->CKTrhs + here->BSIM4v7bNodePrime) += m * (ceqbd + ceqbs - ceqjd - ceqjs - ceqqb + Ibtoteq)); - (*(ckt->CKTrhs + here->BSIM4sNodePrime) += m * (ceqdrn - ceqbs + ceqjs + (*(ckt->CKTrhs + here->BSIM4v7sNodePrime) += m * (ceqdrn - ceqbs + ceqjs + ceqqg + ceqqb + ceqqd + ceqqgmid - ceqgstot + Istoteq)); } else - { (*(ckt->CKTrhs + here->BSIM4dbNode) -= m * (ceqjd + ceqqjd)); - (*(ckt->CKTrhs + here->BSIM4bNodePrime) += m * (ceqbd + ceqbs - ceqqb + Ibtoteq)); - (*(ckt->CKTrhs + here->BSIM4sbNode) -= m * (ceqjs + ceqqjs)); - (*(ckt->CKTrhs + here->BSIM4sNodePrime) += m * (ceqdrn - ceqbs + ceqjs + ceqqd + { (*(ckt->CKTrhs + here->BSIM4v7dbNode) -= m * (ceqjd + ceqqjd)); + (*(ckt->CKTrhs + here->BSIM4v7bNodePrime) += m * (ceqbd + ceqbs - ceqqb + Ibtoteq)); + (*(ckt->CKTrhs + here->BSIM4v7sbNode) -= m * (ceqjs + ceqqjs)); + (*(ckt->CKTrhs + here->BSIM4v7sNodePrime) += m * (ceqdrn - ceqbs + ceqjs + ceqqd + ceqqg + ceqqb + ceqqjd + ceqqjs + ceqqgmid - ceqgstot + Istoteq)); } - if (model->BSIM4rdsMod) - { (*(ckt->CKTrhs + here->BSIM4dNode) -= m * ceqgdtot); - (*(ckt->CKTrhs + here->BSIM4sNode) += m * ceqgstot); + if (model->BSIM4v7rdsMod) + { (*(ckt->CKTrhs + here->BSIM4v7dNode) -= m * ceqgdtot); + (*(ckt->CKTrhs + here->BSIM4v7sNode) += m * ceqgstot); } - if (here->BSIM4trnqsMod) - *(ckt->CKTrhs + here->BSIM4qNode) += m * (cqcheq - cqdef); + if (here->BSIM4v7trnqsMod) + *(ckt->CKTrhs + here->BSIM4v7qNode) += m * (cqcheq - cqdef); #endif /* * Loading matrix */ - if (!here->BSIM4rbodyMod) - { gjbd = here->BSIM4gbd; - gjbs = here->BSIM4gbs; + if (!here->BSIM4v7rbodyMod) + { gjbd = here->BSIM4v7gbd; + gjbs = here->BSIM4v7gbs; } else gjbd = gjbs = 0.0; - if (!model->BSIM4rdsMod) - { gdpr = here->BSIM4drainConductance; - gspr = here->BSIM4sourceConductance; + if (!model->BSIM4v7rdsMod) + { gdpr = here->BSIM4v7drainConductance; + gspr = here->BSIM4v7sourceConductance; } else gdpr = gspr = 0.0; - geltd = here->BSIM4grgeltd; + geltd = here->BSIM4v7grgeltd; - T1 = qdef * here->BSIM4gtau; + T1 = qdef * here->BSIM4v7gtau; #ifdef USE_OMP - if (here->BSIM4rgateMod == 1) - { here->BSIM4_1 = m * geltd; - here->BSIM4_2 = m * geltd; - here->BSIM4_3 = m * geltd; - here->BSIM4_4 = m * (gcggb + geltd - ggtg + gIgtotg); - here->BSIM4_5 = m * (gcgdb - ggtd + gIgtotd); - here->BSIM4_6 = m * (gcgsb - ggts + gIgtots); - here->BSIM4_7 = m * (gcgbb - ggtb + gIgtotb); + if (here->BSIM4v7rgateMod == 1) + { here->BSIM4v7_1 = m * geltd; + here->BSIM4v7_2 = m * geltd; + here->BSIM4v7_3 = m * geltd; + here->BSIM4v7_4 = m * (gcggb + geltd - ggtg + gIgtotg); + here->BSIM4v7_5 = m * (gcgdb - ggtd + gIgtotd); + here->BSIM4v7_6 = m * (gcgsb - ggts + gIgtots); + here->BSIM4v7_7 = m * (gcgbb - ggtb + gIgtotb); } /* WDLiu: gcrg already subtracted from all gcrgg below */ - else if (here->BSIM4rgateMod == 2) - { here->BSIM4_8 = m * gcrg; - here->BSIM4_9 = m * gcrgg; - here->BSIM4_10 = m * gcrgd; - here->BSIM4_11 = m * gcrgs; - here->BSIM4_12 = m * gcrgb; + else if (here->BSIM4v7rgateMod == 2) + { here->BSIM4v7_8 = m * gcrg; + here->BSIM4v7_9 = m * gcrgg; + here->BSIM4v7_10 = m * gcrgd; + here->BSIM4v7_11 = m * gcrgs; + here->BSIM4v7_12 = m * gcrgb; - here->BSIM4_13 = m * gcrg; - here->BSIM4_14 = m * (gcggb - gcrgg - ggtg + gIgtotg); - here->BSIM4_15 = m * (gcgdb - gcrgd - ggtd + gIgtotd); - here->BSIM4_16 = m * (gcgsb - gcrgs - ggts + gIgtots); - here->BSIM4_17 = m * (gcgbb - gcrgb - ggtb + gIgtotb); + here->BSIM4v7_13 = m * gcrg; + here->BSIM4v7_14 = m * (gcggb - gcrgg - ggtg + gIgtotg); + here->BSIM4v7_15 = m * (gcgdb - gcrgd - ggtd + gIgtotd); + here->BSIM4v7_16 = m * (gcgsb - gcrgs - ggts + gIgtots); + here->BSIM4v7_17 = m * (gcgbb - gcrgb - ggtb + gIgtotb); } - else if (here->BSIM4rgateMod == 3) - { here->BSIM4_18 = m * geltd; - here->BSIM4_19 = m * geltd; - here->BSIM4_20 = m * geltd; - here->BSIM4_21 = m * (geltd + gcrg + gcgmgmb); + else if (here->BSIM4v7rgateMod == 3) + { here->BSIM4v7_18 = m * geltd; + here->BSIM4v7_19 = m * geltd; + here->BSIM4v7_20 = m * geltd; + here->BSIM4v7_21 = m * (geltd + gcrg + gcgmgmb); - here->BSIM4_22 = m * (gcrgd + gcgmdb); - here->BSIM4_23 = m * gcrgg; - here->BSIM4_24 = m * (gcrgs + gcgmsb); - here->BSIM4_25 = m * (gcrgb + gcgmbb); + here->BSIM4v7_22 = m * (gcrgd + gcgmdb); + here->BSIM4v7_23 = m * gcrgg; + here->BSIM4v7_24 = m * (gcrgs + gcgmsb); + here->BSIM4v7_25 = m * (gcrgb + gcgmbb); - here->BSIM4_26 = m * gcdgmb; - here->BSIM4_26 = m * gcrg; - here->BSIM4_28 = m * gcsgmb; - here->BSIM4_29 = m * gcbgmb; + here->BSIM4v7_26 = m * gcdgmb; + here->BSIM4v7_26 = m * gcrg; + here->BSIM4v7_28 = m * gcsgmb; + here->BSIM4v7_29 = m * gcbgmb; - here->BSIM4_30 = m * (gcggb - gcrgg - ggtg + gIgtotg); - here->BSIM4_31 = m * (gcgdb - gcrgd - ggtd + gIgtotd); - here->BSIM4_32 = m * (gcgsb - gcrgs - ggts + gIgtots); - here->BSIM4_33 = m * (gcgbb - gcrgb - ggtb + gIgtotb); + here->BSIM4v7_30 = m * (gcggb - gcrgg - ggtg + gIgtotg); + here->BSIM4v7_31 = m * (gcgdb - gcrgd - ggtd + gIgtotd); + here->BSIM4v7_32 = m * (gcgsb - gcrgs - ggts + gIgtots); + here->BSIM4v7_33 = m * (gcgbb - gcrgb - ggtb + gIgtotb); } else - { here->BSIM4_34 = m * (gcggb - ggtg + gIgtotg); - here->BSIM4_35 = m * (gcgdb - ggtd + gIgtotd); - here->BSIM4_36 = m * (gcgsb - ggts + gIgtots); - here->BSIM4_37 = m * (gcgbb - ggtb + gIgtotb); + { here->BSIM4v7_34 = m * (gcggb - ggtg + gIgtotg); + here->BSIM4v7_35 = m * (gcgdb - ggtd + gIgtotd); + here->BSIM4v7_36 = m * (gcgsb - ggts + gIgtots); + here->BSIM4v7_37 = m * (gcgbb - ggtb + gIgtotb); } - if (model->BSIM4rdsMod) - { here->BSIM4_38 = m * gdtotg; - here->BSIM4_39 = m * gdtots; - here->BSIM4_40 = m * gdtotb; - here->BSIM4_41 = m * gstotd; - here->BSIM4_42 = m * gstotg; - here->BSIM4_43 = m * gstotb; + if (model->BSIM4v7rdsMod) + { here->BSIM4v7_38 = m * gdtotg; + here->BSIM4v7_39 = m * gdtots; + here->BSIM4v7_40 = m * gdtotb; + here->BSIM4v7_41 = m * gstotd; + here->BSIM4v7_42 = m * gstotg; + here->BSIM4v7_43 = m * gstotb; } - here->BSIM4_44 = m * (gdpr + here->BSIM4gds + here->BSIM4gbd + T1 * ddxpart_dVd + here->BSIM4v7_44 = m * (gdpr + here->BSIM4v7gds + here->BSIM4v7gbd + T1 * ddxpart_dVd - gdtotd + RevSum + gcddb + gbdpdp + dxpart * ggtd - gIdtotd); - here->BSIM4_45 = m * (gdpr + gdtot); - here->BSIM4_46 = m * (Gm + gcdgb - gdtotg + gbdpg - gIdtotg + here->BSIM4v7_45 = m * (gdpr + gdtot); + here->BSIM4v7_46 = m * (Gm + gcdgb - gdtotg + gbdpg - gIdtotg + dxpart * ggtg + T1 * ddxpart_dVg); - here->BSIM4_47 = m * (here->BSIM4gds + gdtots - dxpart * ggts + gIdtots + here->BSIM4v7_47 = m * (here->BSIM4v7gds + gdtots - dxpart * ggts + gIdtots - T1 * ddxpart_dVs + FwdSum - gcdsb - gbdpsp); - here->BSIM4_48 = m * (gjbd + gdtotb - Gmbs - gcdbb - gbdpb + gIdtotb + here->BSIM4v7_48 = m * (gjbd + gdtotb - Gmbs - gcdbb - gbdpb + gIdtotb - T1 * ddxpart_dVb - dxpart * ggtb); - here->BSIM4_49 = m * (gdpr - gdtotd); - here->BSIM4_50 = m * (gdpr + gdtot); + here->BSIM4v7_49 = m * (gdpr - gdtotd); + here->BSIM4v7_50 = m * (gdpr + gdtot); - here->BSIM4_51 = m * (here->BSIM4gds + gstotd + RevSum - gcsdb - gbspdp + here->BSIM4v7_51 = m * (here->BSIM4v7gds + gstotd + RevSum - gcsdb - gbspdp - T1 * dsxpart_dVd - sxpart * ggtd + gIstotd); - here->BSIM4_52 = m * (gcsgb - Gm - gstotg + gbspg + sxpart * ggtg + here->BSIM4v7_52 = m * (gcsgb - Gm - gstotg + gbspg + sxpart * ggtg + T1 * dsxpart_dVg - gIstotg); - here->BSIM4_53 = m * (gspr + here->BSIM4gds + here->BSIM4gbs + T1 * dsxpart_dVs + here->BSIM4v7_53 = m * (gspr + here->BSIM4v7gds + here->BSIM4v7gbs + T1 * dsxpart_dVs - gstots + FwdSum + gcssb + gbspsp + sxpart * ggts - gIstots); - here->BSIM4_54 = m * (gspr + gstot); - here->BSIM4_55 = m * (gjbs + gstotb + Gmbs - gcsbb - gbspb - sxpart * ggtb + here->BSIM4v7_54 = m * (gspr + gstot); + here->BSIM4v7_55 = m * (gjbs + gstotb + Gmbs - gcsbb - gbspb - sxpart * ggtb - T1 * dsxpart_dVb + gIstotb); - here->BSIM4_56 = m * (gspr - gstots); - here->BSIM4_57 = m * (gspr + gstot); + here->BSIM4v7_56 = m * (gspr - gstots); + here->BSIM4v7_57 = m * (gspr + gstot); - here->BSIM4_58 = m * (gcbdb - gjbd + gbbdp - gIbtotd); - here->BSIM4_59 = m * (gcbgb - here->BSIM4gbgs - gIbtotg); - here->BSIM4_60 = m * (gcbsb - gjbs + gbbsp - gIbtots); - here->BSIM4_61 = m * (gjbd + gjbs + gcbbb - here->BSIM4gbbs - gIbtotb); + here->BSIM4v7_58 = m * (gcbdb - gjbd + gbbdp - gIbtotd); + here->BSIM4v7_59 = m * (gcbgb - here->BSIM4v7gbgs - gIbtotg); + here->BSIM4v7_60 = m * (gcbsb - gjbs + gbbsp - gIbtots); + here->BSIM4v7_61 = m * (gjbd + gjbs + gcbbb - here->BSIM4v7gbbs - gIbtotb); - ggidld = here->BSIM4ggidld; - ggidlg = here->BSIM4ggidlg; - ggidlb = here->BSIM4ggidlb; - ggislg = here->BSIM4ggislg; - ggisls = here->BSIM4ggisls; - ggislb = here->BSIM4ggislb; + ggidld = here->BSIM4v7ggidld; + ggidlg = here->BSIM4v7ggidlg; + ggidlb = here->BSIM4v7ggidlb; + ggislg = here->BSIM4v7ggislg; + ggisls = here->BSIM4v7ggisls; + ggislb = here->BSIM4v7ggislb; /* stamp gidl */ - here->BSIM4_62 = m * ggidld; - here->BSIM4_63 = m * ggidlg; - here->BSIM4_64 = m * (ggidlg + ggidld + ggidlb); - here->BSIM4_65 = m * ggidlb; - here->BSIM4_66 = m * ggidld; - here->BSIM4_67 = m * ggidlg; - here->BSIM4_68 = m * (ggidlg + ggidld + ggidlb); - here->BSIM4_69 = m * ggidlb; + here->BSIM4v7_62 = m * ggidld; + here->BSIM4v7_63 = m * ggidlg; + here->BSIM4v7_64 = m * (ggidlg + ggidld + ggidlb); + here->BSIM4v7_65 = m * ggidlb; + here->BSIM4v7_66 = m * ggidld; + here->BSIM4v7_67 = m * ggidlg; + here->BSIM4v7_68 = m * (ggidlg + ggidld + ggidlb); + here->BSIM4v7_69 = m * ggidlb; /* stamp gisl */ - here->BSIM4_70 = m * (ggisls + ggislg + ggislb); - here->BSIM4_71 = m * ggislg; - here->BSIM4_72 = m * ggisls; - here->BSIM4_73 = m * ggislb; - here->BSIM4_74 = m * (ggislg + ggisls + ggislb); - here->BSIM4_75 = m * ggislg; - here->BSIM4_76 = m * ggisls; - here->BSIM4_77 = m * ggislb; + here->BSIM4v7_70 = m * (ggisls + ggislg + ggislb); + here->BSIM4v7_71 = m * ggislg; + here->BSIM4v7_72 = m * ggisls; + here->BSIM4v7_73 = m * ggislb; + here->BSIM4v7_74 = m * (ggislg + ggisls + ggislb); + here->BSIM4v7_75 = m * ggislg; + here->BSIM4v7_76 = m * ggisls; + here->BSIM4v7_77 = m * ggislb; - if (here->BSIM4rbodyMod) - { here->BSIM4_78 = m * (gcdbdb - here->BSIM4gbd); - here->BSIM4_79 = m * (here->BSIM4gbs - gcsbsb); + if (here->BSIM4v7rbodyMod) + { here->BSIM4v7_78 = m * (gcdbdb - here->BSIM4v7gbd); + here->BSIM4v7_79 = m * (here->BSIM4v7gbs - gcsbsb); - here->BSIM4_80 = m * (gcdbdb - here->BSIM4gbd); - here->BSIM4_81 = m * (here->BSIM4gbd - gcdbdb - + here->BSIM4grbpd + here->BSIM4grbdb); - here->BSIM4_82 = m * here->BSIM4grbpd; - here->BSIM4_83 = m * here->BSIM4grbdb; + here->BSIM4v7_80 = m * (gcdbdb - here->BSIM4v7gbd); + here->BSIM4v7_81 = m * (here->BSIM4v7gbd - gcdbdb + + here->BSIM4v7grbpd + here->BSIM4v7grbdb); + here->BSIM4v7_82 = m * here->BSIM4v7grbpd; + here->BSIM4v7_83 = m * here->BSIM4v7grbdb; - here->BSIM4_84 = m * here->BSIM4grbpd; - here->BSIM4_85 = m * here->BSIM4grbpb; - here->BSIM4_86 = m * here->BSIM4grbps; - here->BSIM4_87 = m * (here->BSIM4grbpd + here->BSIM4grbps - + here->BSIM4grbpb); - /* WDLiu: (gcbbb - here->BSIM4gbbs) already added to BPbpPtr */ + here->BSIM4v7_84 = m * here->BSIM4v7grbpd; + here->BSIM4v7_85 = m * here->BSIM4v7grbpb; + here->BSIM4v7_86 = m * here->BSIM4v7grbps; + here->BSIM4v7_87 = m * (here->BSIM4v7grbpd + here->BSIM4v7grbps + + here->BSIM4v7grbpb); + /* WDLiu: (gcbbb - here->BSIM4v7gbbs) already added to BPbpPtr */ - here->BSIM4_88 = m * (gcsbsb - here->BSIM4gbs); - here->BSIM4_89 = m * here->BSIM4grbps; - here->BSIM4_90 = m * here->BSIM4grbsb; - here->BSIM4_91 = m * (here->BSIM4gbs - gcsbsb - + here->BSIM4grbps + here->BSIM4grbsb); + here->BSIM4v7_88 = m * (gcsbsb - here->BSIM4v7gbs); + here->BSIM4v7_89 = m * here->BSIM4v7grbps; + here->BSIM4v7_90 = m * here->BSIM4v7grbsb; + here->BSIM4v7_91 = m * (here->BSIM4v7gbs - gcsbsb + + here->BSIM4v7grbps + here->BSIM4v7grbsb); - here->BSIM4_92 = m * here->BSIM4grbdb; - here->BSIM4_93 = m * here->BSIM4grbpb; - here->BSIM4_94 = m * here->BSIM4grbsb; - here->BSIM4_95 = m * (here->BSIM4grbsb + here->BSIM4grbdb - + here->BSIM4grbpb); + here->BSIM4v7_92 = m * here->BSIM4v7grbdb; + here->BSIM4v7_93 = m * here->BSIM4v7grbpb; + here->BSIM4v7_94 = m * here->BSIM4v7grbsb; + here->BSIM4v7_95 = m * (here->BSIM4v7grbsb + here->BSIM4v7grbdb + + here->BSIM4v7grbpb); } - if (here->BSIM4trnqsMod) - { here->BSIM4_96 = m * (gqdef + here->BSIM4gtau); - here->BSIM4_97 = m * (ggtg - gcqgb); - here->BSIM4_98 = m * (ggtd - gcqdb); - here->BSIM4_99 = m * (ggts - gcqsb); - here->BSIM4_100 = m * (ggtb - gcqbb); + if (here->BSIM4v7trnqsMod) + { here->BSIM4v7_96 = m * (gqdef + here->BSIM4v7gtau); + here->BSIM4v7_97 = m * (ggtg - gcqgb); + here->BSIM4v7_98 = m * (ggtd - gcqdb); + here->BSIM4v7_99 = m * (ggts - gcqsb); + here->BSIM4v7_100 = m * (ggtb - gcqbb); - here->BSIM4_101 = m * dxpart * here->BSIM4gtau; - here->BSIM4_102 = m * sxpart * here->BSIM4gtau; - here->BSIM4_103 = m * here->BSIM4gtau; + here->BSIM4v7_101 = m * dxpart * here->BSIM4v7gtau; + here->BSIM4v7_102 = m * sxpart * here->BSIM4v7gtau; + here->BSIM4v7_103 = m * here->BSIM4v7gtau; } #else - if (here->BSIM4rgateMod == 1) - { (*(here->BSIM4GEgePtr) += m * geltd); - (*(here->BSIM4GPgePtr) -= m * geltd); - (*(here->BSIM4GEgpPtr) -= m * geltd); - (*(here->BSIM4GPgpPtr) += m * (gcggb + geltd - ggtg + gIgtotg)); - (*(here->BSIM4GPdpPtr) += m * (gcgdb - ggtd + gIgtotd)); - (*(here->BSIM4GPspPtr) += m * (gcgsb - ggts + gIgtots)); - (*(here->BSIM4GPbpPtr) += m * (gcgbb - ggtb + gIgtotb)); + if (here->BSIM4v7rgateMod == 1) + { (*(here->BSIM4v7GEgePtr) += m * geltd); + (*(here->BSIM4v7GPgePtr) -= m * geltd); + (*(here->BSIM4v7GEgpPtr) -= m * geltd); + (*(here->BSIM4v7GPgpPtr) += m * (gcggb + geltd - ggtg + gIgtotg)); + (*(here->BSIM4v7GPdpPtr) += m * (gcgdb - ggtd + gIgtotd)); + (*(here->BSIM4v7GPspPtr) += m * (gcgsb - ggts + gIgtots)); + (*(here->BSIM4v7GPbpPtr) += m * (gcgbb - ggtb + gIgtotb)); } /* WDLiu: gcrg already subtracted from all gcrgg below */ - else if (here->BSIM4rgateMod == 2) - { (*(here->BSIM4GEgePtr) += m * gcrg); - (*(here->BSIM4GEgpPtr) += m * gcrgg); - (*(here->BSIM4GEdpPtr) += m * gcrgd); - (*(here->BSIM4GEspPtr) += m * gcrgs); - (*(here->BSIM4GEbpPtr) += m * gcrgb); + else if (here->BSIM4v7rgateMod == 2) + { (*(here->BSIM4v7GEgePtr) += m * gcrg); + (*(here->BSIM4v7GEgpPtr) += m * gcrgg); + (*(here->BSIM4v7GEdpPtr) += m * gcrgd); + (*(here->BSIM4v7GEspPtr) += m * gcrgs); + (*(here->BSIM4v7GEbpPtr) += m * gcrgb); - (*(here->BSIM4GPgePtr) -= m * gcrg); - (*(here->BSIM4GPgpPtr) += m * (gcggb - gcrgg - ggtg + gIgtotg)); - (*(here->BSIM4GPdpPtr) += m * (gcgdb - gcrgd - ggtd + gIgtotd)); - (*(here->BSIM4GPspPtr) += m * (gcgsb - gcrgs - ggts + gIgtots)); - (*(here->BSIM4GPbpPtr) += m * (gcgbb - gcrgb - ggtb + gIgtotb)); + (*(here->BSIM4v7GPgePtr) -= m * gcrg); + (*(here->BSIM4v7GPgpPtr) += m * (gcggb - gcrgg - ggtg + gIgtotg)); + (*(here->BSIM4v7GPdpPtr) += m * (gcgdb - gcrgd - ggtd + gIgtotd)); + (*(here->BSIM4v7GPspPtr) += m * (gcgsb - gcrgs - ggts + gIgtots)); + (*(here->BSIM4v7GPbpPtr) += m * (gcgbb - gcrgb - ggtb + gIgtotb)); } - else if (here->BSIM4rgateMod == 3) - { (*(here->BSIM4GEgePtr) += m * geltd); - (*(here->BSIM4GEgmPtr) -= m * geltd); - (*(here->BSIM4GMgePtr) -= m * geltd); - (*(here->BSIM4GMgmPtr) += m * (geltd + gcrg + gcgmgmb)); + else if (here->BSIM4v7rgateMod == 3) + { (*(here->BSIM4v7GEgePtr) += m * geltd); + (*(here->BSIM4v7GEgmPtr) -= m * geltd); + (*(here->BSIM4v7GMgePtr) -= m * geltd); + (*(here->BSIM4v7GMgmPtr) += m * (geltd + gcrg + gcgmgmb)); - (*(here->BSIM4GMdpPtr) += m * (gcrgd + gcgmdb)); - (*(here->BSIM4GMgpPtr) += m * gcrgg); - (*(here->BSIM4GMspPtr) += m * (gcrgs + gcgmsb)); - (*(here->BSIM4GMbpPtr) += m * (gcrgb + gcgmbb)); + (*(here->BSIM4v7GMdpPtr) += m * (gcrgd + gcgmdb)); + (*(here->BSIM4v7GMgpPtr) += m * gcrgg); + (*(here->BSIM4v7GMspPtr) += m * (gcrgs + gcgmsb)); + (*(here->BSIM4v7GMbpPtr) += m * (gcrgb + gcgmbb)); - (*(here->BSIM4DPgmPtr) += m * gcdgmb); - (*(here->BSIM4GPgmPtr) -= m * gcrg); - (*(here->BSIM4SPgmPtr) += m * gcsgmb); - (*(here->BSIM4BPgmPtr) += m * gcbgmb); + (*(here->BSIM4v7DPgmPtr) += m * gcdgmb); + (*(here->BSIM4v7GPgmPtr) -= m * gcrg); + (*(here->BSIM4v7SPgmPtr) += m * gcsgmb); + (*(here->BSIM4v7BPgmPtr) += m * gcbgmb); - (*(here->BSIM4GPgpPtr) += m * (gcggb - gcrgg - ggtg + gIgtotg)); - (*(here->BSIM4GPdpPtr) += m * (gcgdb - gcrgd - ggtd + gIgtotd)); - (*(here->BSIM4GPspPtr) += m * (gcgsb - gcrgs - ggts + gIgtots)); - (*(here->BSIM4GPbpPtr) += m * (gcgbb - gcrgb - ggtb + gIgtotb)); + (*(here->BSIM4v7GPgpPtr) += m * (gcggb - gcrgg - ggtg + gIgtotg)); + (*(here->BSIM4v7GPdpPtr) += m * (gcgdb - gcrgd - ggtd + gIgtotd)); + (*(here->BSIM4v7GPspPtr) += m * (gcgsb - gcrgs - ggts + gIgtots)); + (*(here->BSIM4v7GPbpPtr) += m * (gcgbb - gcrgb - ggtb + gIgtotb)); } else - { (*(here->BSIM4GPgpPtr) += m * (gcggb - ggtg + gIgtotg)); - (*(here->BSIM4GPdpPtr) += m * (gcgdb - ggtd + gIgtotd)); - (*(here->BSIM4GPspPtr) += m * (gcgsb - ggts + gIgtots)); - (*(here->BSIM4GPbpPtr) += m * (gcgbb - ggtb + gIgtotb)); + { (*(here->BSIM4v7GPgpPtr) += m * (gcggb - ggtg + gIgtotg)); + (*(here->BSIM4v7GPdpPtr) += m * (gcgdb - ggtd + gIgtotd)); + (*(here->BSIM4v7GPspPtr) += m * (gcgsb - ggts + gIgtots)); + (*(here->BSIM4v7GPbpPtr) += m * (gcgbb - ggtb + gIgtotb)); } - if (model->BSIM4rdsMod) - { (*(here->BSIM4DgpPtr) += m * gdtotg); - (*(here->BSIM4DspPtr) += m * gdtots); - (*(here->BSIM4DbpPtr) += m * gdtotb); - (*(here->BSIM4SdpPtr) += m * gstotd); - (*(here->BSIM4SgpPtr) += m * gstotg); - (*(here->BSIM4SbpPtr) += m * gstotb); + if (model->BSIM4v7rdsMod) + { (*(here->BSIM4v7DgpPtr) += m * gdtotg); + (*(here->BSIM4v7DspPtr) += m * gdtots); + (*(here->BSIM4v7DbpPtr) += m * gdtotb); + (*(here->BSIM4v7SdpPtr) += m * gstotd); + (*(here->BSIM4v7SgpPtr) += m * gstotg); + (*(here->BSIM4v7SbpPtr) += m * gstotb); } - (*(here->BSIM4DPdpPtr) += m * (gdpr + here->BSIM4gds + here->BSIM4gbd + T1 * ddxpart_dVd + (*(here->BSIM4v7DPdpPtr) += m * (gdpr + here->BSIM4v7gds + here->BSIM4v7gbd + T1 * ddxpart_dVd - gdtotd + RevSum + gcddb + gbdpdp + dxpart * ggtd - gIdtotd)); - (*(here->BSIM4DPdPtr) -= m * (gdpr + gdtot)); - (*(here->BSIM4DPgpPtr) += m * (Gm + gcdgb - gdtotg + gbdpg - gIdtotg + (*(here->BSIM4v7DPdPtr) -= m * (gdpr + gdtot)); + (*(here->BSIM4v7DPgpPtr) += m * (Gm + gcdgb - gdtotg + gbdpg - gIdtotg + dxpart * ggtg + T1 * ddxpart_dVg)); - (*(here->BSIM4DPspPtr) -= m * (here->BSIM4gds + gdtots - dxpart * ggts + gIdtots + (*(here->BSIM4v7DPspPtr) -= m * (here->BSIM4v7gds + gdtots - dxpart * ggts + gIdtots - T1 * ddxpart_dVs + FwdSum - gcdsb - gbdpsp)); - (*(here->BSIM4DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gcdbb - gbdpb + gIdtotb + (*(here->BSIM4v7DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gcdbb - gbdpb + gIdtotb - T1 * ddxpart_dVb - dxpart * ggtb)); - (*(here->BSIM4DdpPtr) -= m * (gdpr - gdtotd)); - (*(here->BSIM4DdPtr) += m * (gdpr + gdtot)); + (*(here->BSIM4v7DdpPtr) -= m * (gdpr - gdtotd)); + (*(here->BSIM4v7DdPtr) += m * (gdpr + gdtot)); - (*(here->BSIM4SPdpPtr) -= m * (here->BSIM4gds + gstotd + RevSum - gcsdb - gbspdp + (*(here->BSIM4v7SPdpPtr) -= m * (here->BSIM4v7gds + gstotd + RevSum - gcsdb - gbspdp - T1 * dsxpart_dVd - sxpart * ggtd + gIstotd)); - (*(here->BSIM4SPgpPtr) += m * (gcsgb - Gm - gstotg + gbspg + sxpart * ggtg + (*(here->BSIM4v7SPgpPtr) += m * (gcsgb - Gm - gstotg + gbspg + sxpart * ggtg + T1 * dsxpart_dVg - gIstotg)); - (*(here->BSIM4SPspPtr) += m * (gspr + here->BSIM4gds + here->BSIM4gbs + T1 * dsxpart_dVs + (*(here->BSIM4v7SPspPtr) += m * (gspr + here->BSIM4v7gds + here->BSIM4v7gbs + T1 * dsxpart_dVs - gstots + FwdSum + gcssb + gbspsp + sxpart * ggts - gIstots)); - (*(here->BSIM4SPsPtr) -= m * (gspr + gstot)); - (*(here->BSIM4SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gcsbb - gbspb - sxpart * ggtb + (*(here->BSIM4v7SPsPtr) -= m * (gspr + gstot)); + (*(here->BSIM4v7SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gcsbb - gbspb - sxpart * ggtb - T1 * dsxpart_dVb + gIstotb)); - (*(here->BSIM4SspPtr) -= m * (gspr - gstots)); - (*(here->BSIM4SsPtr) += m * (gspr + gstot)); + (*(here->BSIM4v7SspPtr) -= m * (gspr - gstots)); + (*(here->BSIM4v7SsPtr) += m * (gspr + gstot)); - (*(here->BSIM4BPdpPtr) += m * (gcbdb - gjbd + gbbdp - gIbtotd)); - (*(here->BSIM4BPgpPtr) += m * (gcbgb - here->BSIM4gbgs - gIbtotg)); - (*(here->BSIM4BPspPtr) += m * (gcbsb - gjbs + gbbsp - gIbtots)); - (*(here->BSIM4BPbpPtr) += m * (gjbd + gjbs + gcbbb - here->BSIM4gbbs + (*(here->BSIM4v7BPdpPtr) += m * (gcbdb - gjbd + gbbdp - gIbtotd)); + (*(here->BSIM4v7BPgpPtr) += m * (gcbgb - here->BSIM4v7gbgs - gIbtotg)); + (*(here->BSIM4v7BPspPtr) += m * (gcbsb - gjbs + gbbsp - gIbtots)); + (*(here->BSIM4v7BPbpPtr) += m * (gjbd + gjbs + gcbbb - here->BSIM4v7gbbs - gIbtotb)); - ggidld = here->BSIM4ggidld; - ggidlg = here->BSIM4ggidlg; - ggidlb = here->BSIM4ggidlb; - ggislg = here->BSIM4ggislg; - ggisls = here->BSIM4ggisls; - ggislb = here->BSIM4ggislb; + ggidld = here->BSIM4v7ggidld; + ggidlg = here->BSIM4v7ggidlg; + ggidlb = here->BSIM4v7ggidlb; + ggislg = here->BSIM4v7ggislg; + ggisls = here->BSIM4v7ggisls; + ggislb = here->BSIM4v7ggislb; /* stamp gidl */ - (*(here->BSIM4DPdpPtr) += m * ggidld); - (*(here->BSIM4DPgpPtr) += m * ggidlg); - (*(here->BSIM4DPspPtr) -= m * (ggidlg + ggidld + ggidlb)); - (*(here->BSIM4DPbpPtr) += m * ggidlb); - (*(here->BSIM4BPdpPtr) -= m * ggidld); - (*(here->BSIM4BPgpPtr) -= m * ggidlg); - (*(here->BSIM4BPspPtr) += m * (ggidlg + ggidld + ggidlb)); - (*(here->BSIM4BPbpPtr) -= m * ggidlb); + (*(here->BSIM4v7DPdpPtr) += m * ggidld); + (*(here->BSIM4v7DPgpPtr) += m * ggidlg); + (*(here->BSIM4v7DPspPtr) -= m * (ggidlg + ggidld + ggidlb)); + (*(here->BSIM4v7DPbpPtr) += m * ggidlb); + (*(here->BSIM4v7BPdpPtr) -= m * ggidld); + (*(here->BSIM4v7BPgpPtr) -= m * ggidlg); + (*(here->BSIM4v7BPspPtr) += m * (ggidlg + ggidld + ggidlb)); + (*(here->BSIM4v7BPbpPtr) -= m * ggidlb); /* stamp gisl */ - (*(here->BSIM4SPdpPtr) -= m * (ggisls + ggislg + ggislb)); - (*(here->BSIM4SPgpPtr) += m * ggislg); - (*(here->BSIM4SPspPtr) += m * ggisls); - (*(here->BSIM4SPbpPtr) += m * ggislb); - (*(here->BSIM4BPdpPtr) += m * (ggislg + ggisls + ggislb)); - (*(here->BSIM4BPgpPtr) -= m * ggislg); - (*(here->BSIM4BPspPtr) -= m * ggisls); - (*(here->BSIM4BPbpPtr) -= m * ggislb); + (*(here->BSIM4v7SPdpPtr) -= m * (ggisls + ggislg + ggislb)); + (*(here->BSIM4v7SPgpPtr) += m * ggislg); + (*(here->BSIM4v7SPspPtr) += m * ggisls); + (*(here->BSIM4v7SPbpPtr) += m * ggislb); + (*(here->BSIM4v7BPdpPtr) += m * (ggislg + ggisls + ggislb)); + (*(here->BSIM4v7BPgpPtr) -= m * ggislg); + (*(here->BSIM4v7BPspPtr) -= m * ggisls); + (*(here->BSIM4v7BPbpPtr) -= m * ggislb); - if (here->BSIM4rbodyMod) - { (*(here->BSIM4DPdbPtr) += m * (gcdbdb - here->BSIM4gbd)); - (*(here->BSIM4SPsbPtr) -= m * (here->BSIM4gbs - gcsbsb)); + if (here->BSIM4v7rbodyMod) + { (*(here->BSIM4v7DPdbPtr) += m * (gcdbdb - here->BSIM4v7gbd)); + (*(here->BSIM4v7SPsbPtr) -= m * (here->BSIM4v7gbs - gcsbsb)); - (*(here->BSIM4DBdpPtr) += m * (gcdbdb - here->BSIM4gbd)); - (*(here->BSIM4DBdbPtr) += m * (here->BSIM4gbd - gcdbdb - + here->BSIM4grbpd + here->BSIM4grbdb)); - (*(here->BSIM4DBbpPtr) -= m * here->BSIM4grbpd); - (*(here->BSIM4DBbPtr) -= m * here->BSIM4grbdb); + (*(here->BSIM4v7DBdpPtr) += m * (gcdbdb - here->BSIM4v7gbd)); + (*(here->BSIM4v7DBdbPtr) += m * (here->BSIM4v7gbd - gcdbdb + + here->BSIM4v7grbpd + here->BSIM4v7grbdb)); + (*(here->BSIM4v7DBbpPtr) -= m * here->BSIM4v7grbpd); + (*(here->BSIM4v7DBbPtr) -= m * here->BSIM4v7grbdb); - (*(here->BSIM4BPdbPtr) -= m * here->BSIM4grbpd); - (*(here->BSIM4BPbPtr) -= m * here->BSIM4grbpb); - (*(here->BSIM4BPsbPtr) -= m * here->BSIM4grbps); - (*(here->BSIM4BPbpPtr) += m * (here->BSIM4grbpd + here->BSIM4grbps - + here->BSIM4grbpb)); - /* WDLiu: (gcbbb - here->BSIM4gbbs) already added to BPbpPtr */ + (*(here->BSIM4v7BPdbPtr) -= m * here->BSIM4v7grbpd); + (*(here->BSIM4v7BPbPtr) -= m * here->BSIM4v7grbpb); + (*(here->BSIM4v7BPsbPtr) -= m * here->BSIM4v7grbps); + (*(here->BSIM4v7BPbpPtr) += m * (here->BSIM4v7grbpd + here->BSIM4v7grbps + + here->BSIM4v7grbpb)); + /* WDLiu: (gcbbb - here->BSIM4v7gbbs) already added to BPbpPtr */ - (*(here->BSIM4SBspPtr) += m * (gcsbsb - here->BSIM4gbs)); - (*(here->BSIM4SBbpPtr) -= m * here->BSIM4grbps); - (*(here->BSIM4SBbPtr) -= m * here->BSIM4grbsb); - (*(here->BSIM4SBsbPtr) += m * (here->BSIM4gbs - gcsbsb - + here->BSIM4grbps + here->BSIM4grbsb)); + (*(here->BSIM4v7SBspPtr) += m * (gcsbsb - here->BSIM4v7gbs)); + (*(here->BSIM4v7SBbpPtr) -= m * here->BSIM4v7grbps); + (*(here->BSIM4v7SBbPtr) -= m * here->BSIM4v7grbsb); + (*(here->BSIM4v7SBsbPtr) += m * (here->BSIM4v7gbs - gcsbsb + + here->BSIM4v7grbps + here->BSIM4v7grbsb)); - (*(here->BSIM4BdbPtr) -= m * here->BSIM4grbdb); - (*(here->BSIM4BbpPtr) -= m * here->BSIM4grbpb); - (*(here->BSIM4BsbPtr) -= m * here->BSIM4grbsb); - (*(here->BSIM4BbPtr) += m * (here->BSIM4grbsb + here->BSIM4grbdb - + here->BSIM4grbpb)); + (*(here->BSIM4v7BdbPtr) -= m * here->BSIM4v7grbdb); + (*(here->BSIM4v7BbpPtr) -= m * here->BSIM4v7grbpb); + (*(here->BSIM4v7BsbPtr) -= m * here->BSIM4v7grbsb); + (*(here->BSIM4v7BbPtr) += m * (here->BSIM4v7grbsb + here->BSIM4v7grbdb + + here->BSIM4v7grbpb)); } - if (here->BSIM4trnqsMod) - { (*(here->BSIM4QqPtr) += m * (gqdef + here->BSIM4gtau)); - (*(here->BSIM4QgpPtr) += m * (ggtg - gcqgb)); - (*(here->BSIM4QdpPtr) += m * (ggtd - gcqdb)); - (*(here->BSIM4QspPtr) += m * (ggts - gcqsb)); - (*(here->BSIM4QbpPtr) += m * (ggtb - gcqbb)); + if (here->BSIM4v7trnqsMod) + { (*(here->BSIM4v7QqPtr) += m * (gqdef + here->BSIM4v7gtau)); + (*(here->BSIM4v7QgpPtr) += m * (ggtg - gcqgb)); + (*(here->BSIM4v7QdpPtr) += m * (ggtd - gcqdb)); + (*(here->BSIM4v7QspPtr) += m * (ggts - gcqsb)); + (*(here->BSIM4v7QbpPtr) += m * (ggtb - gcqbb)); - (*(here->BSIM4DPqPtr) += m * dxpart * here->BSIM4gtau); - (*(here->BSIM4SPqPtr) += m * sxpart * here->BSIM4gtau); - (*(here->BSIM4GPqPtr) -= m * here->BSIM4gtau); + (*(here->BSIM4v7DPqPtr) += m * dxpart * here->BSIM4v7gtau); + (*(here->BSIM4v7SPqPtr) += m * sxpart * here->BSIM4v7gtau); + (*(here->BSIM4v7GPqPtr) -= m * here->BSIM4v7gtau); } #endif @@ -5322,7 +5322,7 @@ return(OK); } /* function to compute poly depletion effect */ -int BSIM4polyDepletion( +int BSIM4v7polyDepletion( double phi, double ngate, double epsgate, @@ -5356,188 +5356,188 @@ int BSIM4polyDepletion( } #ifdef USE_OMP -void BSIM4LoadRhsMat(GENmodel *inModel, CKTcircuit *ckt) +void BSIM4v7LoadRhsMat(GENmodel *inModel, CKTcircuit *ckt) { unsigned int InstCount, idx; - BSIM4instance **InstArray; - BSIM4instance *here; - BSIM4model *model = (BSIM4model*)inModel; + BSIM4v7instance **InstArray; + BSIM4v7instance *here; + BSIM4v7model *model = (BSIM4v7model*)inModel; - InstArray = model->BSIM4InstanceArray; - InstCount = model->BSIM4InstCount; + InstArray = model->BSIM4v7InstanceArray; + InstCount = model->BSIM4v7InstCount; for(idx = 0; idx < InstCount; idx++) { here = InstArray[idx]; /* Update b for Ax = b */ - (*(ckt->CKTrhs + here->BSIM4dNodePrime) += here->BSIM4rhsdPrime); - (*(ckt->CKTrhs + here->BSIM4gNodePrime) -= here->BSIM4rhsgPrime); + (*(ckt->CKTrhs + here->BSIM4v7dNodePrime) += here->BSIM4v7rhsdPrime); + (*(ckt->CKTrhs + here->BSIM4v7gNodePrime) -= here->BSIM4v7rhsgPrime); - if (here->BSIM4rgateMod == 2) - (*(ckt->CKTrhs + here->BSIM4gNodeExt) -= here->BSIM4rhsgExt); - else if (here->BSIM4rgateMod == 3) - (*(ckt->CKTrhs + here->BSIM4gNodeMid) -= here->BSIM4grhsMid); + if (here->BSIM4v7rgateMod == 2) + (*(ckt->CKTrhs + here->BSIM4v7gNodeExt) -= here->BSIM4v7rhsgExt); + else if (here->BSIM4v7rgateMod == 3) + (*(ckt->CKTrhs + here->BSIM4v7gNodeMid) -= here->BSIM4v7grhsMid); - if (!here->BSIM4rbodyMod) - { (*(ckt->CKTrhs + here->BSIM4bNodePrime) += here->BSIM4rhsbPrime); - (*(ckt->CKTrhs + here->BSIM4sNodePrime) += here->BSIM4rhssPrime); + if (!here->BSIM4v7rbodyMod) + { (*(ckt->CKTrhs + here->BSIM4v7bNodePrime) += here->BSIM4v7rhsbPrime); + (*(ckt->CKTrhs + here->BSIM4v7sNodePrime) += here->BSIM4v7rhssPrime); } else - { (*(ckt->CKTrhs + here->BSIM4dbNode) -= here->BSIM4rhsdb); - (*(ckt->CKTrhs + here->BSIM4bNodePrime) += here->BSIM4rhsbPrime); - (*(ckt->CKTrhs + here->BSIM4sbNode) -= here->BSIM4rhssb); - (*(ckt->CKTrhs + here->BSIM4sNodePrime) += here->BSIM4rhssPrime); + { (*(ckt->CKTrhs + here->BSIM4v7dbNode) -= here->BSIM4v7rhsdb); + (*(ckt->CKTrhs + here->BSIM4v7bNodePrime) += here->BSIM4v7rhsbPrime); + (*(ckt->CKTrhs + here->BSIM4v7sbNode) -= here->BSIM4v7rhssb); + (*(ckt->CKTrhs + here->BSIM4v7sNodePrime) += here->BSIM4v7rhssPrime); } - if (model->BSIM4rdsMod) - { (*(ckt->CKTrhs + here->BSIM4dNode) -= here->BSIM4rhsd); - (*(ckt->CKTrhs + here->BSIM4sNode) += here->BSIM4rhss); + if (model->BSIM4v7rdsMod) + { (*(ckt->CKTrhs + here->BSIM4v7dNode) -= here->BSIM4v7rhsd); + (*(ckt->CKTrhs + here->BSIM4v7sNode) += here->BSIM4v7rhss); } - if (here->BSIM4trnqsMod) - *(ckt->CKTrhs + here->BSIM4qNode) += here->BSIM4rhsq; + if (here->BSIM4v7trnqsMod) + *(ckt->CKTrhs + here->BSIM4v7qNode) += here->BSIM4v7rhsq; /* Update A for Ax = b */ - if (here->BSIM4rgateMod == 1) - { (*(here->BSIM4GEgePtr) += here->BSIM4_1); - (*(here->BSIM4GPgePtr) -= here->BSIM4_2); - (*(here->BSIM4GEgpPtr) -= here->BSIM4_3); - (*(here->BSIM4GPgpPtr) += here->BSIM4_4); - (*(here->BSIM4GPdpPtr) += here->BSIM4_5); - (*(here->BSIM4GPspPtr) += here->BSIM4_6); - (*(here->BSIM4GPbpPtr) += here->BSIM4_7); + if (here->BSIM4v7rgateMod == 1) + { (*(here->BSIM4v7GEgePtr) += here->BSIM4v7_1); + (*(here->BSIM4v7GPgePtr) -= here->BSIM4v7_2); + (*(here->BSIM4v7GEgpPtr) -= here->BSIM4v7_3); + (*(here->BSIM4v7GPgpPtr) += here->BSIM4v7_4); + (*(here->BSIM4v7GPdpPtr) += here->BSIM4v7_5); + (*(here->BSIM4v7GPspPtr) += here->BSIM4v7_6); + (*(here->BSIM4v7GPbpPtr) += here->BSIM4v7_7); } - else if (here->BSIM4rgateMod == 2) - { (*(here->BSIM4GEgePtr) += here->BSIM4_8); - (*(here->BSIM4GEgpPtr) += here->BSIM4_9); - (*(here->BSIM4GEdpPtr) += here->BSIM4_10); - (*(here->BSIM4GEspPtr) += here->BSIM4_11); - (*(here->BSIM4GEbpPtr) += here->BSIM4_12); + else if (here->BSIM4v7rgateMod == 2) + { (*(here->BSIM4v7GEgePtr) += here->BSIM4v7_8); + (*(here->BSIM4v7GEgpPtr) += here->BSIM4v7_9); + (*(here->BSIM4v7GEdpPtr) += here->BSIM4v7_10); + (*(here->BSIM4v7GEspPtr) += here->BSIM4v7_11); + (*(here->BSIM4v7GEbpPtr) += here->BSIM4v7_12); - (*(here->BSIM4GPgePtr) -= here->BSIM4_13); - (*(here->BSIM4GPgpPtr) += here->BSIM4_14); - (*(here->BSIM4GPdpPtr) += here->BSIM4_15); - (*(here->BSIM4GPspPtr) += here->BSIM4_16); - (*(here->BSIM4GPbpPtr) += here->BSIM4_17); + (*(here->BSIM4v7GPgePtr) -= here->BSIM4v7_13); + (*(here->BSIM4v7GPgpPtr) += here->BSIM4v7_14); + (*(here->BSIM4v7GPdpPtr) += here->BSIM4v7_15); + (*(here->BSIM4v7GPspPtr) += here->BSIM4v7_16); + (*(here->BSIM4v7GPbpPtr) += here->BSIM4v7_17); } - else if (here->BSIM4rgateMod == 3) - { (*(here->BSIM4GEgePtr) += here->BSIM4_18); - (*(here->BSIM4GEgmPtr) -= here->BSIM4_19); - (*(here->BSIM4GMgePtr) -= here->BSIM4_20); - (*(here->BSIM4GMgmPtr) += here->BSIM4_21); + else if (here->BSIM4v7rgateMod == 3) + { (*(here->BSIM4v7GEgePtr) += here->BSIM4v7_18); + (*(here->BSIM4v7GEgmPtr) -= here->BSIM4v7_19); + (*(here->BSIM4v7GMgePtr) -= here->BSIM4v7_20); + (*(here->BSIM4v7GMgmPtr) += here->BSIM4v7_21); - (*(here->BSIM4GMdpPtr) += here->BSIM4_22); - (*(here->BSIM4GMgpPtr) += here->BSIM4_23); - (*(here->BSIM4GMspPtr) += here->BSIM4_24); - (*(here->BSIM4GMbpPtr) += here->BSIM4_25); + (*(here->BSIM4v7GMdpPtr) += here->BSIM4v7_22); + (*(here->BSIM4v7GMgpPtr) += here->BSIM4v7_23); + (*(here->BSIM4v7GMspPtr) += here->BSIM4v7_24); + (*(here->BSIM4v7GMbpPtr) += here->BSIM4v7_25); - (*(here->BSIM4DPgmPtr) += here->BSIM4_26); - (*(here->BSIM4GPgmPtr) -= here->BSIM4_27); - (*(here->BSIM4SPgmPtr) += here->BSIM4_28); - (*(here->BSIM4BPgmPtr) += here->BSIM4_29); + (*(here->BSIM4v7DPgmPtr) += here->BSIM4v7_26); + (*(here->BSIM4v7GPgmPtr) -= here->BSIM4v7_27); + (*(here->BSIM4v7SPgmPtr) += here->BSIM4v7_28); + (*(here->BSIM4v7BPgmPtr) += here->BSIM4v7_29); - (*(here->BSIM4GPgpPtr) += here->BSIM4_30); - (*(here->BSIM4GPdpPtr) += here->BSIM4_31); - (*(here->BSIM4GPspPtr) += here->BSIM4_32); - (*(here->BSIM4GPbpPtr) += here->BSIM4_33); + (*(here->BSIM4v7GPgpPtr) += here->BSIM4v7_30); + (*(here->BSIM4v7GPdpPtr) += here->BSIM4v7_31); + (*(here->BSIM4v7GPspPtr) += here->BSIM4v7_32); + (*(here->BSIM4v7GPbpPtr) += here->BSIM4v7_33); } else - { (*(here->BSIM4GPgpPtr) += here->BSIM4_34); - (*(here->BSIM4GPdpPtr) += here->BSIM4_35); - (*(here->BSIM4GPspPtr) += here->BSIM4_36); - (*(here->BSIM4GPbpPtr) += here->BSIM4_37); + { (*(here->BSIM4v7GPgpPtr) += here->BSIM4v7_34); + (*(here->BSIM4v7GPdpPtr) += here->BSIM4v7_35); + (*(here->BSIM4v7GPspPtr) += here->BSIM4v7_36); + (*(here->BSIM4v7GPbpPtr) += here->BSIM4v7_37); } - if (model->BSIM4rdsMod) - { (*(here->BSIM4DgpPtr) += here->BSIM4_38); - (*(here->BSIM4DspPtr) += here->BSIM4_39); - (*(here->BSIM4DbpPtr) += here->BSIM4_40); - (*(here->BSIM4SdpPtr) += here->BSIM4_41); - (*(here->BSIM4SgpPtr) += here->BSIM4_42); - (*(here->BSIM4SbpPtr) += here->BSIM4_43); + if (model->BSIM4v7rdsMod) + { (*(here->BSIM4v7DgpPtr) += here->BSIM4v7_38); + (*(here->BSIM4v7DspPtr) += here->BSIM4v7_39); + (*(here->BSIM4v7DbpPtr) += here->BSIM4v7_40); + (*(here->BSIM4v7SdpPtr) += here->BSIM4v7_41); + (*(here->BSIM4v7SgpPtr) += here->BSIM4v7_42); + (*(here->BSIM4v7SbpPtr) += here->BSIM4v7_43); } - (*(here->BSIM4DPdpPtr) += here->BSIM4_44); - (*(here->BSIM4DPdPtr) -= here->BSIM4_45); - (*(here->BSIM4DPgpPtr) += here->BSIM4_46); - (*(here->BSIM4DPspPtr) -= here->BSIM4_47); - (*(here->BSIM4DPbpPtr) -= here->BSIM4_48); + (*(here->BSIM4v7DPdpPtr) += here->BSIM4v7_44); + (*(here->BSIM4v7DPdPtr) -= here->BSIM4v7_45); + (*(here->BSIM4v7DPgpPtr) += here->BSIM4v7_46); + (*(here->BSIM4v7DPspPtr) -= here->BSIM4v7_47); + (*(here->BSIM4v7DPbpPtr) -= here->BSIM4v7_48); - (*(here->BSIM4DdpPtr) -= here->BSIM4_49); - (*(here->BSIM4DdPtr) += here->BSIM4_50); + (*(here->BSIM4v7DdpPtr) -= here->BSIM4v7_49); + (*(here->BSIM4v7DdPtr) += here->BSIM4v7_50); - (*(here->BSIM4SPdpPtr) -= here->BSIM4_51); - (*(here->BSIM4SPgpPtr) += here->BSIM4_52); - (*(here->BSIM4SPspPtr) += here->BSIM4_53); - (*(here->BSIM4SPsPtr) -= here->BSIM4_54); - (*(here->BSIM4SPbpPtr) -= here->BSIM4_55); + (*(here->BSIM4v7SPdpPtr) -= here->BSIM4v7_51); + (*(here->BSIM4v7SPgpPtr) += here->BSIM4v7_52); + (*(here->BSIM4v7SPspPtr) += here->BSIM4v7_53); + (*(here->BSIM4v7SPsPtr) -= here->BSIM4v7_54); + (*(here->BSIM4v7SPbpPtr) -= here->BSIM4v7_55); - (*(here->BSIM4SspPtr) -= here->BSIM4_56); - (*(here->BSIM4SsPtr) += here->BSIM4_57); + (*(here->BSIM4v7SspPtr) -= here->BSIM4v7_56); + (*(here->BSIM4v7SsPtr) += here->BSIM4v7_57); - (*(here->BSIM4BPdpPtr) += here->BSIM4_58); - (*(here->BSIM4BPgpPtr) += here->BSIM4_59); - (*(here->BSIM4BPspPtr) += here->BSIM4_60); - (*(here->BSIM4BPbpPtr) += here->BSIM4_61); + (*(here->BSIM4v7BPdpPtr) += here->BSIM4v7_58); + (*(here->BSIM4v7BPgpPtr) += here->BSIM4v7_59); + (*(here->BSIM4v7BPspPtr) += here->BSIM4v7_60); + (*(here->BSIM4v7BPbpPtr) += here->BSIM4v7_61); /* stamp gidl */ - (*(here->BSIM4DPdpPtr) += here->BSIM4_62); - (*(here->BSIM4DPgpPtr) += here->BSIM4_63); - (*(here->BSIM4DPspPtr) -= here->BSIM4_64); - (*(here->BSIM4DPbpPtr) += here->BSIM4_65); - (*(here->BSIM4BPdpPtr) -= here->BSIM4_66); - (*(here->BSIM4BPgpPtr) -= here->BSIM4_67); - (*(here->BSIM4BPspPtr) += here->BSIM4_68); - (*(here->BSIM4BPbpPtr) -= here->BSIM4_69); + (*(here->BSIM4v7DPdpPtr) += here->BSIM4v7_62); + (*(here->BSIM4v7DPgpPtr) += here->BSIM4v7_63); + (*(here->BSIM4v7DPspPtr) -= here->BSIM4v7_64); + (*(here->BSIM4v7DPbpPtr) += here->BSIM4v7_65); + (*(here->BSIM4v7BPdpPtr) -= here->BSIM4v7_66); + (*(here->BSIM4v7BPgpPtr) -= here->BSIM4v7_67); + (*(here->BSIM4v7BPspPtr) += here->BSIM4v7_68); + (*(here->BSIM4v7BPbpPtr) -= here->BSIM4v7_69); /* stamp gisl */ - (*(here->BSIM4SPdpPtr) -= here->BSIM4_70); - (*(here->BSIM4SPgpPtr) += here->BSIM4_71); - (*(here->BSIM4SPspPtr) += here->BSIM4_72); - (*(here->BSIM4SPbpPtr) += here->BSIM4_73); - (*(here->BSIM4BPdpPtr) += here->BSIM4_74); - (*(here->BSIM4BPgpPtr) -= here->BSIM4_75); - (*(here->BSIM4BPspPtr) -= here->BSIM4_76); - (*(here->BSIM4BPbpPtr) -= here->BSIM4_77); + (*(here->BSIM4v7SPdpPtr) -= here->BSIM4v7_70); + (*(here->BSIM4v7SPgpPtr) += here->BSIM4v7_71); + (*(here->BSIM4v7SPspPtr) += here->BSIM4v7_72); + (*(here->BSIM4v7SPbpPtr) += here->BSIM4v7_73); + (*(here->BSIM4v7BPdpPtr) += here->BSIM4v7_74); + (*(here->BSIM4v7BPgpPtr) -= here->BSIM4v7_75); + (*(here->BSIM4v7BPspPtr) -= here->BSIM4v7_76); + (*(here->BSIM4v7BPbpPtr) -= here->BSIM4v7_77); - if (here->BSIM4rbodyMod) - { (*(here->BSIM4DPdbPtr) += here->BSIM4_78); - (*(here->BSIM4SPsbPtr) -= here->BSIM4_79); + if (here->BSIM4v7rbodyMod) + { (*(here->BSIM4v7DPdbPtr) += here->BSIM4v7_78); + (*(here->BSIM4v7SPsbPtr) -= here->BSIM4v7_79); - (*(here->BSIM4DBdpPtr) += here->BSIM4_80); - (*(here->BSIM4DBdbPtr) += here->BSIM4_81); - (*(here->BSIM4DBbpPtr) -= here->BSIM4_82); - (*(here->BSIM4DBbPtr) -= here->BSIM4_83); + (*(here->BSIM4v7DBdpPtr) += here->BSIM4v7_80); + (*(here->BSIM4v7DBdbPtr) += here->BSIM4v7_81); + (*(here->BSIM4v7DBbpPtr) -= here->BSIM4v7_82); + (*(here->BSIM4v7DBbPtr) -= here->BSIM4v7_83); - (*(here->BSIM4BPdbPtr) -= here->BSIM4_84); - (*(here->BSIM4BPbPtr) -= here->BSIM4_85); - (*(here->BSIM4BPsbPtr) -= here->BSIM4_86); - (*(here->BSIM4BPbpPtr) += here->BSIM4_87); + (*(here->BSIM4v7BPdbPtr) -= here->BSIM4v7_84); + (*(here->BSIM4v7BPbPtr) -= here->BSIM4v7_85); + (*(here->BSIM4v7BPsbPtr) -= here->BSIM4v7_86); + (*(here->BSIM4v7BPbpPtr) += here->BSIM4v7_87); - (*(here->BSIM4SBspPtr) += here->BSIM4_88); - (*(here->BSIM4SBbpPtr) -= here->BSIM4_89); - (*(here->BSIM4SBbPtr) -= here->BSIM4_90); - (*(here->BSIM4SBsbPtr) += here->BSIM4_91); + (*(here->BSIM4v7SBspPtr) += here->BSIM4v7_88); + (*(here->BSIM4v7SBbpPtr) -= here->BSIM4v7_89); + (*(here->BSIM4v7SBbPtr) -= here->BSIM4v7_90); + (*(here->BSIM4v7SBsbPtr) += here->BSIM4v7_91); - (*(here->BSIM4BdbPtr) -= here->BSIM4_92); - (*(here->BSIM4BbpPtr) -= here->BSIM4_93); - (*(here->BSIM4BsbPtr) -= here->BSIM4_94); - (*(here->BSIM4BbPtr) += here->BSIM4_95); + (*(here->BSIM4v7BdbPtr) -= here->BSIM4v7_92); + (*(here->BSIM4v7BbpPtr) -= here->BSIM4v7_93); + (*(here->BSIM4v7BsbPtr) -= here->BSIM4v7_94); + (*(here->BSIM4v7BbPtr) += here->BSIM4v7_95); } - if (here->BSIM4trnqsMod) - { (*(here->BSIM4QqPtr) += here->BSIM4_96); - (*(here->BSIM4QgpPtr) += here->BSIM4_97); - (*(here->BSIM4QdpPtr) += here->BSIM4_98); - (*(here->BSIM4QspPtr) += here->BSIM4_99); - (*(here->BSIM4QbpPtr) += here->BSIM4_100); + if (here->BSIM4v7trnqsMod) + { (*(here->BSIM4v7QqPtr) += here->BSIM4v7_96); + (*(here->BSIM4v7QgpPtr) += here->BSIM4v7_97); + (*(here->BSIM4v7QdpPtr) += here->BSIM4v7_98); + (*(here->BSIM4v7QspPtr) += here->BSIM4v7_99); + (*(here->BSIM4v7QbpPtr) += here->BSIM4v7_100); - (*(here->BSIM4DPqPtr) += here->BSIM4_101); - (*(here->BSIM4SPqPtr) += here->BSIM4_102); - (*(here->BSIM4GPqPtr) -= here->BSIM4_103); + (*(here->BSIM4v7DPqPtr) += here->BSIM4v7_101); + (*(here->BSIM4v7SPqPtr) += here->BSIM4v7_102); + (*(here->BSIM4v7GPqPtr) -= here->BSIM4v7_103); } } } diff --git a/src/spicelib/devices/bsim4v7/b4v7mask.c b/src/spicelib/devices/bsim4v7/b4v7mask.c index 5c5b3f7e6..0acdaf4cc 100644 --- a/src/spicelib/devices/bsim4v7/b4v7mask.c +++ b/src/spicelib/devices/bsim4v7/b4v7mask.c @@ -23,2694 +23,2694 @@ #include "ngspice/ifsim.h" #include "ngspice/cktdefs.h" #include "ngspice/devdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" int -BSIM4mAsk( +BSIM4v7mAsk( CKTcircuit *ckt, GENmodel *inst, int which, IFvalue *value) { - BSIM4model *model = (BSIM4model *)inst; + BSIM4v7model *model = (BSIM4v7model *)inst; NG_IGNORE(ckt); switch(which) - { case BSIM4_MOD_MOBMOD : - value->iValue = model->BSIM4mobMod; + { case BSIM4v7_MOD_MOBMOD : + value->iValue = model->BSIM4v7mobMod; return(OK); - case BSIM4_MOD_PARAMCHK : - value->iValue = model->BSIM4paramChk; + case BSIM4v7_MOD_PARAMCHK : + value->iValue = model->BSIM4v7paramChk; return(OK); - case BSIM4_MOD_BINUNIT : - value->iValue = model->BSIM4binUnit; + case BSIM4v7_MOD_BINUNIT : + value->iValue = model->BSIM4v7binUnit; return(OK); - case BSIM4_MOD_CVCHARGEMOD : - value->iValue = model->BSIM4cvchargeMod; + case BSIM4v7_MOD_CVCHARGEMOD : + value->iValue = model->BSIM4v7cvchargeMod; return(OK); - case BSIM4_MOD_CAPMOD : - value->iValue = model->BSIM4capMod; + case BSIM4v7_MOD_CAPMOD : + value->iValue = model->BSIM4v7capMod; return(OK); - case BSIM4_MOD_DIOMOD : - value->iValue = model->BSIM4dioMod; + case BSIM4v7_MOD_DIOMOD : + value->iValue = model->BSIM4v7dioMod; return(OK); - case BSIM4_MOD_TRNQSMOD : - value->iValue = model->BSIM4trnqsMod; + case BSIM4v7_MOD_TRNQSMOD : + value->iValue = model->BSIM4v7trnqsMod; return(OK); - case BSIM4_MOD_ACNQSMOD : - value->iValue = model->BSIM4acnqsMod; + case BSIM4v7_MOD_ACNQSMOD : + value->iValue = model->BSIM4v7acnqsMod; return(OK); - case BSIM4_MOD_FNOIMOD : - value->iValue = model->BSIM4fnoiMod; + case BSIM4v7_MOD_FNOIMOD : + value->iValue = model->BSIM4v7fnoiMod; return(OK); - case BSIM4_MOD_TNOIMOD : - value->iValue = model->BSIM4tnoiMod; + case BSIM4v7_MOD_TNOIMOD : + value->iValue = model->BSIM4v7tnoiMod; return(OK); - case BSIM4_MOD_RDSMOD : - value->iValue = model->BSIM4rdsMod; + case BSIM4v7_MOD_RDSMOD : + value->iValue = model->BSIM4v7rdsMod; return(OK); - case BSIM4_MOD_RBODYMOD : - value->iValue = model->BSIM4rbodyMod; + case BSIM4v7_MOD_RBODYMOD : + value->iValue = model->BSIM4v7rbodyMod; return(OK); - case BSIM4_MOD_RGATEMOD : - value->iValue = model->BSIM4rgateMod; + case BSIM4v7_MOD_RGATEMOD : + value->iValue = model->BSIM4v7rgateMod; return(OK); - case BSIM4_MOD_PERMOD : - value->iValue = model->BSIM4perMod; + case BSIM4v7_MOD_PERMOD : + value->iValue = model->BSIM4v7perMod; return(OK); - case BSIM4_MOD_GEOMOD : - value->iValue = model->BSIM4geoMod; + case BSIM4v7_MOD_GEOMOD : + value->iValue = model->BSIM4v7geoMod; return(OK); - case BSIM4_MOD_RGEOMOD : - value->iValue = model->BSIM4rgeoMod; + case BSIM4v7_MOD_RGEOMOD : + value->iValue = model->BSIM4v7rgeoMod; return(OK); - case BSIM4_MOD_MTRLMOD : - value->iValue = model->BSIM4mtrlMod; + case BSIM4v7_MOD_MTRLMOD : + value->iValue = model->BSIM4v7mtrlMod; return(OK); - case BSIM4_MOD_GIDLMOD : /* v4.7 New GIDL/GISL*/ - value->iValue = model->BSIM4gidlMod; + case BSIM4v7_MOD_GIDLMOD : /* v4.7 New GIDL/GISL*/ + value->iValue = model->BSIM4v7gidlMod; return(OK); - case BSIM4_MOD_MTRLCOMPATMOD : - value->iValue = model->BSIM4mtrlCompatMod; + case BSIM4v7_MOD_MTRLCOMPATMOD : + value->iValue = model->BSIM4v7mtrlCompatMod; return(OK); - case BSIM4_MOD_IGCMOD : - value->iValue = model->BSIM4igcMod; + case BSIM4v7_MOD_IGCMOD : + value->iValue = model->BSIM4v7igcMod; return(OK); - case BSIM4_MOD_IGBMOD : - value->iValue = model->BSIM4igbMod; + case BSIM4v7_MOD_IGBMOD : + value->iValue = model->BSIM4v7igbMod; return(OK); - case BSIM4_MOD_TEMPMOD : - value->iValue = model->BSIM4tempMod; + case BSIM4v7_MOD_TEMPMOD : + value->iValue = model->BSIM4v7tempMod; return(OK); - case BSIM4_MOD_VERSION : - value->sValue = model->BSIM4version; + case BSIM4v7_MOD_VERSION : + value->sValue = model->BSIM4v7version; return(OK); - case BSIM4_MOD_TOXREF : - value->rValue = model->BSIM4toxref; + case BSIM4v7_MOD_TOXREF : + value->rValue = model->BSIM4v7toxref; return(OK); - case BSIM4_MOD_EOT : - value->rValue = model->BSIM4eot; + case BSIM4v7_MOD_EOT : + value->rValue = model->BSIM4v7eot; return(OK); - case BSIM4_MOD_VDDEOT : - value->rValue = model->BSIM4vddeot; + case BSIM4v7_MOD_VDDEOT : + value->rValue = model->BSIM4v7vddeot; return(OK); - case BSIM4_MOD_TEMPEOT : - value->rValue = model->BSIM4tempeot; + case BSIM4v7_MOD_TEMPEOT : + value->rValue = model->BSIM4v7tempeot; return(OK); - case BSIM4_MOD_LEFFEOT : - value->rValue = model->BSIM4leffeot; + case BSIM4v7_MOD_LEFFEOT : + value->rValue = model->BSIM4v7leffeot; return(OK); - case BSIM4_MOD_WEFFEOT : - value->rValue = model->BSIM4weffeot; + case BSIM4v7_MOD_WEFFEOT : + value->rValue = model->BSIM4v7weffeot; return(OK); - case BSIM4_MOD_ADOS : - value->rValue = model->BSIM4ados; + case BSIM4v7_MOD_ADOS : + value->rValue = model->BSIM4v7ados; return(OK); - case BSIM4_MOD_BDOS : - value->rValue = model->BSIM4bdos; + case BSIM4v7_MOD_BDOS : + value->rValue = model->BSIM4v7bdos; return(OK); - case BSIM4_MOD_TOXE : - value->rValue = model->BSIM4toxe; + case BSIM4v7_MOD_TOXE : + value->rValue = model->BSIM4v7toxe; return(OK); - case BSIM4_MOD_TOXP : - value->rValue = model->BSIM4toxp; + case BSIM4v7_MOD_TOXP : + value->rValue = model->BSIM4v7toxp; return(OK); - case BSIM4_MOD_TOXM : - value->rValue = model->BSIM4toxm; + case BSIM4v7_MOD_TOXM : + value->rValue = model->BSIM4v7toxm; return(OK); - case BSIM4_MOD_DTOX : - value->rValue = model->BSIM4dtox; + case BSIM4v7_MOD_DTOX : + value->rValue = model->BSIM4v7dtox; return(OK); - case BSIM4_MOD_EPSROX : - value->rValue = model->BSIM4epsrox; + case BSIM4v7_MOD_EPSROX : + value->rValue = model->BSIM4v7epsrox; return(OK); - case BSIM4_MOD_CDSC : - value->rValue = model->BSIM4cdsc; + case BSIM4v7_MOD_CDSC : + value->rValue = model->BSIM4v7cdsc; return(OK); - case BSIM4_MOD_CDSCB : - value->rValue = model->BSIM4cdscb; + case BSIM4v7_MOD_CDSCB : + value->rValue = model->BSIM4v7cdscb; return(OK); - case BSIM4_MOD_CDSCD : - value->rValue = model->BSIM4cdscd; + case BSIM4v7_MOD_CDSCD : + value->rValue = model->BSIM4v7cdscd; return(OK); - case BSIM4_MOD_CIT : - value->rValue = model->BSIM4cit; + case BSIM4v7_MOD_CIT : + value->rValue = model->BSIM4v7cit; return(OK); - case BSIM4_MOD_NFACTOR : - value->rValue = model->BSIM4nfactor; + case BSIM4v7_MOD_NFACTOR : + value->rValue = model->BSIM4v7nfactor; return(OK); - case BSIM4_MOD_XJ: - value->rValue = model->BSIM4xj; + case BSIM4v7_MOD_XJ: + value->rValue = model->BSIM4v7xj; return(OK); - case BSIM4_MOD_VSAT: - value->rValue = model->BSIM4vsat; + case BSIM4v7_MOD_VSAT: + value->rValue = model->BSIM4v7vsat; return(OK); - case BSIM4_MOD_VTL: - value->rValue = model->BSIM4vtl; + case BSIM4v7_MOD_VTL: + value->rValue = model->BSIM4v7vtl; return(OK); - case BSIM4_MOD_XN: - value->rValue = model->BSIM4xn; + case BSIM4v7_MOD_XN: + value->rValue = model->BSIM4v7xn; return(OK); - case BSIM4_MOD_LC: - value->rValue = model->BSIM4lc; + case BSIM4v7_MOD_LC: + value->rValue = model->BSIM4v7lc; return(OK); - case BSIM4_MOD_LAMBDA: - value->rValue = model->BSIM4lambda; + case BSIM4v7_MOD_LAMBDA: + value->rValue = model->BSIM4v7lambda; return(OK); - case BSIM4_MOD_AT: - value->rValue = model->BSIM4at; + case BSIM4v7_MOD_AT: + value->rValue = model->BSIM4v7at; return(OK); - case BSIM4_MOD_A0: - value->rValue = model->BSIM4a0; + case BSIM4v7_MOD_A0: + value->rValue = model->BSIM4v7a0; return(OK); - case BSIM4_MOD_AGS: - value->rValue = model->BSIM4ags; + case BSIM4v7_MOD_AGS: + value->rValue = model->BSIM4v7ags; return(OK); - case BSIM4_MOD_A1: - value->rValue = model->BSIM4a1; + case BSIM4v7_MOD_A1: + value->rValue = model->BSIM4v7a1; return(OK); - case BSIM4_MOD_A2: - value->rValue = model->BSIM4a2; + case BSIM4v7_MOD_A2: + value->rValue = model->BSIM4v7a2; return(OK); - case BSIM4_MOD_KETA: - value->rValue = model->BSIM4keta; + case BSIM4v7_MOD_KETA: + value->rValue = model->BSIM4v7keta; return(OK); - case BSIM4_MOD_NSUB: - value->rValue = model->BSIM4nsub; + case BSIM4v7_MOD_NSUB: + value->rValue = model->BSIM4v7nsub; return(OK); - case BSIM4_MOD_PHIG: - value->rValue = model->BSIM4phig; + case BSIM4v7_MOD_PHIG: + value->rValue = model->BSIM4v7phig; return(OK); - case BSIM4_MOD_EPSRGATE: - value->rValue = model->BSIM4epsrgate; + case BSIM4v7_MOD_EPSRGATE: + value->rValue = model->BSIM4v7epsrgate; return(OK); - case BSIM4_MOD_EASUB: - value->rValue = model->BSIM4easub; + case BSIM4v7_MOD_EASUB: + value->rValue = model->BSIM4v7easub; return(OK); - case BSIM4_MOD_EPSRSUB: - value->rValue = model->BSIM4epsrsub; + case BSIM4v7_MOD_EPSRSUB: + value->rValue = model->BSIM4v7epsrsub; return(OK); - case BSIM4_MOD_NI0SUB: - value->rValue = model->BSIM4ni0sub; + case BSIM4v7_MOD_NI0SUB: + value->rValue = model->BSIM4v7ni0sub; return(OK); - case BSIM4_MOD_BG0SUB: - value->rValue = model->BSIM4bg0sub; + case BSIM4v7_MOD_BG0SUB: + value->rValue = model->BSIM4v7bg0sub; return(OK); - case BSIM4_MOD_TBGASUB: - value->rValue = model->BSIM4tbgasub; + case BSIM4v7_MOD_TBGASUB: + value->rValue = model->BSIM4v7tbgasub; return(OK); - case BSIM4_MOD_TBGBSUB: - value->rValue = model->BSIM4tbgbsub; + case BSIM4v7_MOD_TBGBSUB: + value->rValue = model->BSIM4v7tbgbsub; return(OK); - case BSIM4_MOD_NDEP: - value->rValue = model->BSIM4ndep; + case BSIM4v7_MOD_NDEP: + value->rValue = model->BSIM4v7ndep; return(OK); - case BSIM4_MOD_NSD: - value->rValue = model->BSIM4nsd; + case BSIM4v7_MOD_NSD: + value->rValue = model->BSIM4v7nsd; return(OK); - case BSIM4_MOD_NGATE: - value->rValue = model->BSIM4ngate; + case BSIM4v7_MOD_NGATE: + value->rValue = model->BSIM4v7ngate; return(OK); - case BSIM4_MOD_GAMMA1: - value->rValue = model->BSIM4gamma1; + case BSIM4v7_MOD_GAMMA1: + value->rValue = model->BSIM4v7gamma1; return(OK); - case BSIM4_MOD_GAMMA2: - value->rValue = model->BSIM4gamma2; + case BSIM4v7_MOD_GAMMA2: + value->rValue = model->BSIM4v7gamma2; return(OK); - case BSIM4_MOD_VBX: - value->rValue = model->BSIM4vbx; + case BSIM4v7_MOD_VBX: + value->rValue = model->BSIM4v7vbx; return(OK); - case BSIM4_MOD_VBM: - value->rValue = model->BSIM4vbm; + case BSIM4v7_MOD_VBM: + value->rValue = model->BSIM4v7vbm; return(OK); - case BSIM4_MOD_XT: - value->rValue = model->BSIM4xt; + case BSIM4v7_MOD_XT: + value->rValue = model->BSIM4v7xt; return(OK); - case BSIM4_MOD_K1: - value->rValue = model->BSIM4k1; + case BSIM4v7_MOD_K1: + value->rValue = model->BSIM4v7k1; return(OK); - case BSIM4_MOD_KT1: - value->rValue = model->BSIM4kt1; + case BSIM4v7_MOD_KT1: + value->rValue = model->BSIM4v7kt1; return(OK); - case BSIM4_MOD_KT1L: - value->rValue = model->BSIM4kt1l; + case BSIM4v7_MOD_KT1L: + value->rValue = model->BSIM4v7kt1l; return(OK); - case BSIM4_MOD_KT2 : - value->rValue = model->BSIM4kt2; + case BSIM4v7_MOD_KT2 : + value->rValue = model->BSIM4v7kt2; return(OK); - case BSIM4_MOD_K2 : - value->rValue = model->BSIM4k2; + case BSIM4v7_MOD_K2 : + value->rValue = model->BSIM4v7k2; return(OK); - case BSIM4_MOD_K3: - value->rValue = model->BSIM4k3; + case BSIM4v7_MOD_K3: + value->rValue = model->BSIM4v7k3; return(OK); - case BSIM4_MOD_K3B: - value->rValue = model->BSIM4k3b; + case BSIM4v7_MOD_K3B: + value->rValue = model->BSIM4v7k3b; return(OK); - case BSIM4_MOD_W0: - value->rValue = model->BSIM4w0; + case BSIM4v7_MOD_W0: + value->rValue = model->BSIM4v7w0; return(OK); - case BSIM4_MOD_LPE0: - value->rValue = model->BSIM4lpe0; + case BSIM4v7_MOD_LPE0: + value->rValue = model->BSIM4v7lpe0; return(OK); - case BSIM4_MOD_LPEB: - value->rValue = model->BSIM4lpeb; + case BSIM4v7_MOD_LPEB: + value->rValue = model->BSIM4v7lpeb; return(OK); - case BSIM4_MOD_DVTP0: - value->rValue = model->BSIM4dvtp0; + case BSIM4v7_MOD_DVTP0: + value->rValue = model->BSIM4v7dvtp0; return(OK); - case BSIM4_MOD_DVTP1: - value->rValue = model->BSIM4dvtp1; + case BSIM4v7_MOD_DVTP1: + value->rValue = model->BSIM4v7dvtp1; return(OK); - case BSIM4_MOD_DVTP2: - value->rValue = model->BSIM4dvtp2; /* New DIBL/Rout */ + case BSIM4v7_MOD_DVTP2: + value->rValue = model->BSIM4v7dvtp2; /* New DIBL/Rout */ return(OK); - case BSIM4_MOD_DVTP3: - value->rValue = model->BSIM4dvtp3; + case BSIM4v7_MOD_DVTP3: + value->rValue = model->BSIM4v7dvtp3; return(OK); - case BSIM4_MOD_DVTP4: - value->rValue = model->BSIM4dvtp4; + case BSIM4v7_MOD_DVTP4: + value->rValue = model->BSIM4v7dvtp4; return(OK); - case BSIM4_MOD_DVTP5: - value->rValue = model->BSIM4dvtp5; + case BSIM4v7_MOD_DVTP5: + value->rValue = model->BSIM4v7dvtp5; return(OK); - case BSIM4_MOD_DVT0 : - value->rValue = model->BSIM4dvt0; + case BSIM4v7_MOD_DVT0 : + value->rValue = model->BSIM4v7dvt0; return(OK); - case BSIM4_MOD_DVT1 : - value->rValue = model->BSIM4dvt1; + case BSIM4v7_MOD_DVT1 : + value->rValue = model->BSIM4v7dvt1; return(OK); - case BSIM4_MOD_DVT2 : - value->rValue = model->BSIM4dvt2; + case BSIM4v7_MOD_DVT2 : + value->rValue = model->BSIM4v7dvt2; return(OK); - case BSIM4_MOD_DVT0W : - value->rValue = model->BSIM4dvt0w; + case BSIM4v7_MOD_DVT0W : + value->rValue = model->BSIM4v7dvt0w; return(OK); - case BSIM4_MOD_DVT1W : - value->rValue = model->BSIM4dvt1w; + case BSIM4v7_MOD_DVT1W : + value->rValue = model->BSIM4v7dvt1w; return(OK); - case BSIM4_MOD_DVT2W : - value->rValue = model->BSIM4dvt2w; + case BSIM4v7_MOD_DVT2W : + value->rValue = model->BSIM4v7dvt2w; return(OK); - case BSIM4_MOD_DROUT : - value->rValue = model->BSIM4drout; + case BSIM4v7_MOD_DROUT : + value->rValue = model->BSIM4v7drout; return(OK); - case BSIM4_MOD_DSUB : - value->rValue = model->BSIM4dsub; + case BSIM4v7_MOD_DSUB : + value->rValue = model->BSIM4v7dsub; return(OK); - case BSIM4_MOD_VTH0: - value->rValue = model->BSIM4vth0; + case BSIM4v7_MOD_VTH0: + value->rValue = model->BSIM4v7vth0; return(OK); - case BSIM4_MOD_EU: - value->rValue = model->BSIM4eu; + case BSIM4v7_MOD_EU: + value->rValue = model->BSIM4v7eu; return(OK); - case BSIM4_MOD_UCS: - value->rValue = model->BSIM4ucs; + case BSIM4v7_MOD_UCS: + value->rValue = model->BSIM4v7ucs; return(OK); - case BSIM4_MOD_UA: - value->rValue = model->BSIM4ua; + case BSIM4v7_MOD_UA: + value->rValue = model->BSIM4v7ua; return(OK); - case BSIM4_MOD_UA1: - value->rValue = model->BSIM4ua1; + case BSIM4v7_MOD_UA1: + value->rValue = model->BSIM4v7ua1; return(OK); - case BSIM4_MOD_UB: - value->rValue = model->BSIM4ub; + case BSIM4v7_MOD_UB: + value->rValue = model->BSIM4v7ub; return(OK); - case BSIM4_MOD_UB1: - value->rValue = model->BSIM4ub1; + case BSIM4v7_MOD_UB1: + value->rValue = model->BSIM4v7ub1; return(OK); - case BSIM4_MOD_UC: - value->rValue = model->BSIM4uc; + case BSIM4v7_MOD_UC: + value->rValue = model->BSIM4v7uc; return(OK); - case BSIM4_MOD_UC1: - value->rValue = model->BSIM4uc1; + case BSIM4v7_MOD_UC1: + value->rValue = model->BSIM4v7uc1; return(OK); - case BSIM4_MOD_UD: - value->rValue = model->BSIM4ud; + case BSIM4v7_MOD_UD: + value->rValue = model->BSIM4v7ud; return(OK); - case BSIM4_MOD_UD1: - value->rValue = model->BSIM4ud1; + case BSIM4v7_MOD_UD1: + value->rValue = model->BSIM4v7ud1; return(OK); - case BSIM4_MOD_UP: - value->rValue = model->BSIM4up; + case BSIM4v7_MOD_UP: + value->rValue = model->BSIM4v7up; return(OK); - case BSIM4_MOD_LP: - value->rValue = model->BSIM4lp; + case BSIM4v7_MOD_LP: + value->rValue = model->BSIM4v7lp; return(OK); - case BSIM4_MOD_U0: - value->rValue = model->BSIM4u0; + case BSIM4v7_MOD_U0: + value->rValue = model->BSIM4v7u0; return(OK); - case BSIM4_MOD_UTE: - value->rValue = model->BSIM4ute; + case BSIM4v7_MOD_UTE: + value->rValue = model->BSIM4v7ute; return(OK); - case BSIM4_MOD_UCSTE: - value->rValue = model->BSIM4ucste; + case BSIM4v7_MOD_UCSTE: + value->rValue = model->BSIM4v7ucste; return(OK); - case BSIM4_MOD_VOFF: - value->rValue = model->BSIM4voff; + case BSIM4v7_MOD_VOFF: + value->rValue = model->BSIM4v7voff; return(OK); - case BSIM4_MOD_TVOFF: - value->rValue = model->BSIM4tvoff; + case BSIM4v7_MOD_TVOFF: + value->rValue = model->BSIM4v7tvoff; return(OK); - case BSIM4_MOD_TNFACTOR: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4tnfactor; + case BSIM4v7_MOD_TNFACTOR: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7tnfactor; return(OK); - case BSIM4_MOD_TETA0: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4teta0; + case BSIM4v7_MOD_TETA0: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7teta0; return(OK); - case BSIM4_MOD_TVOFFCV: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4tvoffcv; + case BSIM4v7_MOD_TVOFFCV: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7tvoffcv; return(OK); - case BSIM4_MOD_VFBSDOFF: - value->rValue = model->BSIM4vfbsdoff; + case BSIM4v7_MOD_VFBSDOFF: + value->rValue = model->BSIM4v7vfbsdoff; return(OK); - case BSIM4_MOD_TVFBSDOFF: - value->rValue = model->BSIM4tvfbsdoff; + case BSIM4v7_MOD_TVFBSDOFF: + value->rValue = model->BSIM4v7tvfbsdoff; return(OK); - case BSIM4_MOD_VOFFL: - value->rValue = model->BSIM4voffl; + case BSIM4v7_MOD_VOFFL: + value->rValue = model->BSIM4v7voffl; return(OK); - case BSIM4_MOD_VOFFCVL: - value->rValue = model->BSIM4voffcvl; + case BSIM4v7_MOD_VOFFCVL: + value->rValue = model->BSIM4v7voffcvl; return(OK); - case BSIM4_MOD_MINV: - value->rValue = model->BSIM4minv; + case BSIM4v7_MOD_MINV: + value->rValue = model->BSIM4v7minv; return(OK); - case BSIM4_MOD_MINVCV: - value->rValue = model->BSIM4minvcv; + case BSIM4v7_MOD_MINVCV: + value->rValue = model->BSIM4v7minvcv; return(OK); - case BSIM4_MOD_FPROUT: - value->rValue = model->BSIM4fprout; + case BSIM4v7_MOD_FPROUT: + value->rValue = model->BSIM4v7fprout; return(OK); - case BSIM4_MOD_PDITS: - value->rValue = model->BSIM4pdits; + case BSIM4v7_MOD_PDITS: + value->rValue = model->BSIM4v7pdits; return(OK); - case BSIM4_MOD_PDITSD: - value->rValue = model->BSIM4pditsd; + case BSIM4v7_MOD_PDITSD: + value->rValue = model->BSIM4v7pditsd; return(OK); - case BSIM4_MOD_PDITSL: - value->rValue = model->BSIM4pditsl; + case BSIM4v7_MOD_PDITSL: + value->rValue = model->BSIM4v7pditsl; return(OK); - case BSIM4_MOD_DELTA: - value->rValue = model->BSIM4delta; + case BSIM4v7_MOD_DELTA: + value->rValue = model->BSIM4v7delta; return(OK); - case BSIM4_MOD_RDSW: - value->rValue = model->BSIM4rdsw; + case BSIM4v7_MOD_RDSW: + value->rValue = model->BSIM4v7rdsw; return(OK); - case BSIM4_MOD_RDSWMIN: - value->rValue = model->BSIM4rdswmin; + case BSIM4v7_MOD_RDSWMIN: + value->rValue = model->BSIM4v7rdswmin; return(OK); - case BSIM4_MOD_RDWMIN: - value->rValue = model->BSIM4rdwmin; + case BSIM4v7_MOD_RDWMIN: + value->rValue = model->BSIM4v7rdwmin; return(OK); - case BSIM4_MOD_RSWMIN: - value->rValue = model->BSIM4rswmin; + case BSIM4v7_MOD_RSWMIN: + value->rValue = model->BSIM4v7rswmin; return(OK); - case BSIM4_MOD_RDW: - value->rValue = model->BSIM4rdw; + case BSIM4v7_MOD_RDW: + value->rValue = model->BSIM4v7rdw; return(OK); - case BSIM4_MOD_RSW: - value->rValue = model->BSIM4rsw; + case BSIM4v7_MOD_RSW: + value->rValue = model->BSIM4v7rsw; return(OK); - case BSIM4_MOD_PRWG: - value->rValue = model->BSIM4prwg; + case BSIM4v7_MOD_PRWG: + value->rValue = model->BSIM4v7prwg; return(OK); - case BSIM4_MOD_PRWB: - value->rValue = model->BSIM4prwb; + case BSIM4v7_MOD_PRWB: + value->rValue = model->BSIM4v7prwb; return(OK); - case BSIM4_MOD_PRT: - value->rValue = model->BSIM4prt; + case BSIM4v7_MOD_PRT: + value->rValue = model->BSIM4v7prt; return(OK); - case BSIM4_MOD_ETA0: - value->rValue = model->BSIM4eta0; + case BSIM4v7_MOD_ETA0: + value->rValue = model->BSIM4v7eta0; return(OK); - case BSIM4_MOD_ETAB: - value->rValue = model->BSIM4etab; + case BSIM4v7_MOD_ETAB: + value->rValue = model->BSIM4v7etab; return(OK); - case BSIM4_MOD_PCLM: - value->rValue = model->BSIM4pclm; + case BSIM4v7_MOD_PCLM: + value->rValue = model->BSIM4v7pclm; return(OK); - case BSIM4_MOD_PDIBL1: - value->rValue = model->BSIM4pdibl1; + case BSIM4v7_MOD_PDIBL1: + value->rValue = model->BSIM4v7pdibl1; return(OK); - case BSIM4_MOD_PDIBL2: - value->rValue = model->BSIM4pdibl2; + case BSIM4v7_MOD_PDIBL2: + value->rValue = model->BSIM4v7pdibl2; return(OK); - case BSIM4_MOD_PDIBLB: - value->rValue = model->BSIM4pdiblb; + case BSIM4v7_MOD_PDIBLB: + value->rValue = model->BSIM4v7pdiblb; return(OK); - case BSIM4_MOD_PSCBE1: - value->rValue = model->BSIM4pscbe1; + case BSIM4v7_MOD_PSCBE1: + value->rValue = model->BSIM4v7pscbe1; return(OK); - case BSIM4_MOD_PSCBE2: - value->rValue = model->BSIM4pscbe2; + case BSIM4v7_MOD_PSCBE2: + value->rValue = model->BSIM4v7pscbe2; return(OK); - case BSIM4_MOD_PVAG: - value->rValue = model->BSIM4pvag; + case BSIM4v7_MOD_PVAG: + value->rValue = model->BSIM4v7pvag; return(OK); - case BSIM4_MOD_WR: - value->rValue = model->BSIM4wr; + case BSIM4v7_MOD_WR: + value->rValue = model->BSIM4v7wr; return(OK); - case BSIM4_MOD_DWG: - value->rValue = model->BSIM4dwg; + case BSIM4v7_MOD_DWG: + value->rValue = model->BSIM4v7dwg; return(OK); - case BSIM4_MOD_DWB: - value->rValue = model->BSIM4dwb; + case BSIM4v7_MOD_DWB: + value->rValue = model->BSIM4v7dwb; return(OK); - case BSIM4_MOD_B0: - value->rValue = model->BSIM4b0; + case BSIM4v7_MOD_B0: + value->rValue = model->BSIM4v7b0; return(OK); - case BSIM4_MOD_B1: - value->rValue = model->BSIM4b1; + case BSIM4v7_MOD_B1: + value->rValue = model->BSIM4v7b1; return(OK); - case BSIM4_MOD_ALPHA0: - value->rValue = model->BSIM4alpha0; + case BSIM4v7_MOD_ALPHA0: + value->rValue = model->BSIM4v7alpha0; return(OK); - case BSIM4_MOD_ALPHA1: - value->rValue = model->BSIM4alpha1; + case BSIM4v7_MOD_ALPHA1: + value->rValue = model->BSIM4v7alpha1; return(OK); - case BSIM4_MOD_BETA0: - value->rValue = model->BSIM4beta0; + case BSIM4v7_MOD_BETA0: + value->rValue = model->BSIM4v7beta0; return(OK); - case BSIM4_MOD_AGIDL: - value->rValue = model->BSIM4agidl; + case BSIM4v7_MOD_AGIDL: + value->rValue = model->BSIM4v7agidl; return(OK); - case BSIM4_MOD_BGIDL: - value->rValue = model->BSIM4bgidl; + case BSIM4v7_MOD_BGIDL: + value->rValue = model->BSIM4v7bgidl; return(OK); - case BSIM4_MOD_CGIDL: - value->rValue = model->BSIM4cgidl; + case BSIM4v7_MOD_CGIDL: + value->rValue = model->BSIM4v7cgidl; return(OK); - case BSIM4_MOD_EGIDL: - value->rValue = model->BSIM4egidl; + case BSIM4v7_MOD_EGIDL: + value->rValue = model->BSIM4v7egidl; return(OK); - case BSIM4_MOD_FGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4fgidl; + case BSIM4v7_MOD_FGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7fgidl; return(OK); - case BSIM4_MOD_KGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4kgidl; + case BSIM4v7_MOD_KGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7kgidl; return(OK); - case BSIM4_MOD_RGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4rgidl; + case BSIM4v7_MOD_RGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7rgidl; return(OK); - case BSIM4_MOD_AGISL: - value->rValue = model->BSIM4agisl; + case BSIM4v7_MOD_AGISL: + value->rValue = model->BSIM4v7agisl; return(OK); - case BSIM4_MOD_BGISL: - value->rValue = model->BSIM4bgisl; + case BSIM4v7_MOD_BGISL: + value->rValue = model->BSIM4v7bgisl; return(OK); - case BSIM4_MOD_CGISL: - value->rValue = model->BSIM4cgisl; + case BSIM4v7_MOD_CGISL: + value->rValue = model->BSIM4v7cgisl; return(OK); - case BSIM4_MOD_EGISL: - value->rValue = model->BSIM4egisl; + case BSIM4v7_MOD_EGISL: + value->rValue = model->BSIM4v7egisl; return(OK); - case BSIM4_MOD_FGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4fgisl; + case BSIM4v7_MOD_FGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7fgisl; return(OK); - case BSIM4_MOD_KGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4kgisl; + case BSIM4v7_MOD_KGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7kgisl; return(OK); - case BSIM4_MOD_RGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4rgisl; + case BSIM4v7_MOD_RGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7rgisl; return(OK); - case BSIM4_MOD_AIGC: - value->rValue = model->BSIM4aigc; + case BSIM4v7_MOD_AIGC: + value->rValue = model->BSIM4v7aigc; return(OK); - case BSIM4_MOD_BIGC: - value->rValue = model->BSIM4bigc; + case BSIM4v7_MOD_BIGC: + value->rValue = model->BSIM4v7bigc; return(OK); - case BSIM4_MOD_CIGC: - value->rValue = model->BSIM4cigc; + case BSIM4v7_MOD_CIGC: + value->rValue = model->BSIM4v7cigc; return(OK); - case BSIM4_MOD_AIGSD: - value->rValue = model->BSIM4aigsd; + case BSIM4v7_MOD_AIGSD: + value->rValue = model->BSIM4v7aigsd; return(OK); - case BSIM4_MOD_BIGSD: - value->rValue = model->BSIM4bigsd; + case BSIM4v7_MOD_BIGSD: + value->rValue = model->BSIM4v7bigsd; return(OK); - case BSIM4_MOD_CIGSD: - value->rValue = model->BSIM4cigsd; + case BSIM4v7_MOD_CIGSD: + value->rValue = model->BSIM4v7cigsd; return(OK); - case BSIM4_MOD_AIGS: - value->rValue = model->BSIM4aigs; + case BSIM4v7_MOD_AIGS: + value->rValue = model->BSIM4v7aigs; return(OK); - case BSIM4_MOD_BIGS: - value->rValue = model->BSIM4bigs; + case BSIM4v7_MOD_BIGS: + value->rValue = model->BSIM4v7bigs; return(OK); - case BSIM4_MOD_CIGS: - value->rValue = model->BSIM4cigs; + case BSIM4v7_MOD_CIGS: + value->rValue = model->BSIM4v7cigs; return(OK); - case BSIM4_MOD_AIGD: - value->rValue = model->BSIM4aigd; + case BSIM4v7_MOD_AIGD: + value->rValue = model->BSIM4v7aigd; return(OK); - case BSIM4_MOD_BIGD: - value->rValue = model->BSIM4bigd; + case BSIM4v7_MOD_BIGD: + value->rValue = model->BSIM4v7bigd; return(OK); - case BSIM4_MOD_CIGD: - value->rValue = model->BSIM4cigd; + case BSIM4v7_MOD_CIGD: + value->rValue = model->BSIM4v7cigd; return(OK); - case BSIM4_MOD_AIGBACC: - value->rValue = model->BSIM4aigbacc; + case BSIM4v7_MOD_AIGBACC: + value->rValue = model->BSIM4v7aigbacc; return(OK); - case BSIM4_MOD_BIGBACC: - value->rValue = model->BSIM4bigbacc; + case BSIM4v7_MOD_BIGBACC: + value->rValue = model->BSIM4v7bigbacc; return(OK); - case BSIM4_MOD_CIGBACC: - value->rValue = model->BSIM4cigbacc; + case BSIM4v7_MOD_CIGBACC: + value->rValue = model->BSIM4v7cigbacc; return(OK); - case BSIM4_MOD_AIGBINV: - value->rValue = model->BSIM4aigbinv; + case BSIM4v7_MOD_AIGBINV: + value->rValue = model->BSIM4v7aigbinv; return(OK); - case BSIM4_MOD_BIGBINV: - value->rValue = model->BSIM4bigbinv; + case BSIM4v7_MOD_BIGBINV: + value->rValue = model->BSIM4v7bigbinv; return(OK); - case BSIM4_MOD_CIGBINV: - value->rValue = model->BSIM4cigbinv; + case BSIM4v7_MOD_CIGBINV: + value->rValue = model->BSIM4v7cigbinv; return(OK); - case BSIM4_MOD_NIGC: - value->rValue = model->BSIM4nigc; + case BSIM4v7_MOD_NIGC: + value->rValue = model->BSIM4v7nigc; return(OK); - case BSIM4_MOD_NIGBACC: - value->rValue = model->BSIM4nigbacc; + case BSIM4v7_MOD_NIGBACC: + value->rValue = model->BSIM4v7nigbacc; return(OK); - case BSIM4_MOD_NIGBINV: - value->rValue = model->BSIM4nigbinv; + case BSIM4v7_MOD_NIGBINV: + value->rValue = model->BSIM4v7nigbinv; return(OK); - case BSIM4_MOD_NTOX: - value->rValue = model->BSIM4ntox; + case BSIM4v7_MOD_NTOX: + value->rValue = model->BSIM4v7ntox; return(OK); - case BSIM4_MOD_EIGBINV: - value->rValue = model->BSIM4eigbinv; + case BSIM4v7_MOD_EIGBINV: + value->rValue = model->BSIM4v7eigbinv; return(OK); - case BSIM4_MOD_PIGCD: - value->rValue = model->BSIM4pigcd; + case BSIM4v7_MOD_PIGCD: + value->rValue = model->BSIM4v7pigcd; return(OK); - case BSIM4_MOD_POXEDGE: - value->rValue = model->BSIM4poxedge; + case BSIM4v7_MOD_POXEDGE: + value->rValue = model->BSIM4v7poxedge; return(OK); - case BSIM4_MOD_PHIN: - value->rValue = model->BSIM4phin; + case BSIM4v7_MOD_PHIN: + value->rValue = model->BSIM4v7phin; return(OK); - case BSIM4_MOD_XRCRG1: - value->rValue = model->BSIM4xrcrg1; + case BSIM4v7_MOD_XRCRG1: + value->rValue = model->BSIM4v7xrcrg1; return(OK); - case BSIM4_MOD_XRCRG2: - value->rValue = model->BSIM4xrcrg2; + case BSIM4v7_MOD_XRCRG2: + value->rValue = model->BSIM4v7xrcrg2; return(OK); - case BSIM4_MOD_TNOIA: - value->rValue = model->BSIM4tnoia; + case BSIM4v7_MOD_TNOIA: + value->rValue = model->BSIM4v7tnoia; return(OK); - case BSIM4_MOD_TNOIB: - value->rValue = model->BSIM4tnoib; + case BSIM4v7_MOD_TNOIB: + value->rValue = model->BSIM4v7tnoib; return(OK); - case BSIM4_MOD_TNOIC: - value->rValue = model->BSIM4tnoic; + case BSIM4v7_MOD_TNOIC: + value->rValue = model->BSIM4v7tnoic; return(OK); - case BSIM4_MOD_RNOIA: - value->rValue = model->BSIM4rnoia; + case BSIM4v7_MOD_RNOIA: + value->rValue = model->BSIM4v7rnoia; return(OK); - case BSIM4_MOD_RNOIB: - value->rValue = model->BSIM4rnoib; + case BSIM4v7_MOD_RNOIB: + value->rValue = model->BSIM4v7rnoib; return(OK); - case BSIM4_MOD_RNOIC: - value->rValue = model->BSIM4rnoic; + case BSIM4v7_MOD_RNOIC: + value->rValue = model->BSIM4v7rnoic; return(OK); - case BSIM4_MOD_NTNOI: - value->rValue = model->BSIM4ntnoi; + case BSIM4v7_MOD_NTNOI: + value->rValue = model->BSIM4v7ntnoi; return(OK); - case BSIM4_MOD_IJTHDFWD: - value->rValue = model->BSIM4ijthdfwd; + case BSIM4v7_MOD_IJTHDFWD: + value->rValue = model->BSIM4v7ijthdfwd; return(OK); - case BSIM4_MOD_IJTHSFWD: - value->rValue = model->BSIM4ijthsfwd; + case BSIM4v7_MOD_IJTHSFWD: + value->rValue = model->BSIM4v7ijthsfwd; return(OK); - case BSIM4_MOD_IJTHDREV: - value->rValue = model->BSIM4ijthdrev; + case BSIM4v7_MOD_IJTHDREV: + value->rValue = model->BSIM4v7ijthdrev; return(OK); - case BSIM4_MOD_IJTHSREV: - value->rValue = model->BSIM4ijthsrev; + case BSIM4v7_MOD_IJTHSREV: + value->rValue = model->BSIM4v7ijthsrev; return(OK); - case BSIM4_MOD_XJBVD: - value->rValue = model->BSIM4xjbvd; + case BSIM4v7_MOD_XJBVD: + value->rValue = model->BSIM4v7xjbvd; return(OK); - case BSIM4_MOD_XJBVS: - value->rValue = model->BSIM4xjbvs; + case BSIM4v7_MOD_XJBVS: + value->rValue = model->BSIM4v7xjbvs; return(OK); - case BSIM4_MOD_BVD: - value->rValue = model->BSIM4bvd; + case BSIM4v7_MOD_BVD: + value->rValue = model->BSIM4v7bvd; return(OK); - case BSIM4_MOD_BVS: - value->rValue = model->BSIM4bvs; + case BSIM4v7_MOD_BVS: + value->rValue = model->BSIM4v7bvs; return(OK); - case BSIM4_MOD_VFB: - value->rValue = model->BSIM4vfb; + case BSIM4v7_MOD_VFB: + value->rValue = model->BSIM4v7vfb; return(OK); - case BSIM4_MOD_JTSS: - value->rValue = model->BSIM4jtss; + case BSIM4v7_MOD_JTSS: + value->rValue = model->BSIM4v7jtss; return(OK); - case BSIM4_MOD_JTSD: - value->rValue = model->BSIM4jtsd; + case BSIM4v7_MOD_JTSD: + value->rValue = model->BSIM4v7jtsd; return(OK); - case BSIM4_MOD_JTSSWS: - value->rValue = model->BSIM4jtssws; + case BSIM4v7_MOD_JTSSWS: + value->rValue = model->BSIM4v7jtssws; return(OK); - case BSIM4_MOD_JTSSWD: - value->rValue = model->BSIM4jtsswd; + case BSIM4v7_MOD_JTSSWD: + value->rValue = model->BSIM4v7jtsswd; return(OK); - case BSIM4_MOD_JTSSWGS: - value->rValue = model->BSIM4jtsswgs; + case BSIM4v7_MOD_JTSSWGS: + value->rValue = model->BSIM4v7jtsswgs; return(OK); - case BSIM4_MOD_JTSSWGD: - value->rValue = model->BSIM4jtsswgd; + case BSIM4v7_MOD_JTSSWGD: + value->rValue = model->BSIM4v7jtsswgd; return(OK); - case BSIM4_MOD_JTWEFF: - value->rValue = model->BSIM4jtweff; + case BSIM4v7_MOD_JTWEFF: + value->rValue = model->BSIM4v7jtweff; return(OK); - case BSIM4_MOD_NJTS: - value->rValue = model->BSIM4njts; + case BSIM4v7_MOD_NJTS: + value->rValue = model->BSIM4v7njts; return(OK); - case BSIM4_MOD_NJTSSW: - value->rValue = model->BSIM4njtssw; + case BSIM4v7_MOD_NJTSSW: + value->rValue = model->BSIM4v7njtssw; return(OK); - case BSIM4_MOD_NJTSSWG: - value->rValue = model->BSIM4njtsswg; + case BSIM4v7_MOD_NJTSSWG: + value->rValue = model->BSIM4v7njtsswg; return(OK); - case BSIM4_MOD_NJTSD: - value->rValue = model->BSIM4njtsd; + case BSIM4v7_MOD_NJTSD: + value->rValue = model->BSIM4v7njtsd; return(OK); - case BSIM4_MOD_NJTSSWD: - value->rValue = model->BSIM4njtsswd; + case BSIM4v7_MOD_NJTSSWD: + value->rValue = model->BSIM4v7njtsswd; return(OK); - case BSIM4_MOD_NJTSSWGD: - value->rValue = model->BSIM4njtsswgd; + case BSIM4v7_MOD_NJTSSWGD: + value->rValue = model->BSIM4v7njtsswgd; return(OK); - case BSIM4_MOD_XTSS: - value->rValue = model->BSIM4xtss; + case BSIM4v7_MOD_XTSS: + value->rValue = model->BSIM4v7xtss; return(OK); - case BSIM4_MOD_XTSD: - value->rValue = model->BSIM4xtsd; + case BSIM4v7_MOD_XTSD: + value->rValue = model->BSIM4v7xtsd; return(OK); - case BSIM4_MOD_XTSSWS: - value->rValue = model->BSIM4xtssws; + case BSIM4v7_MOD_XTSSWS: + value->rValue = model->BSIM4v7xtssws; return(OK); - case BSIM4_MOD_XTSSWD: - value->rValue = model->BSIM4xtsswd; + case BSIM4v7_MOD_XTSSWD: + value->rValue = model->BSIM4v7xtsswd; return(OK); - case BSIM4_MOD_XTSSWGS: - value->rValue = model->BSIM4xtsswgs; + case BSIM4v7_MOD_XTSSWGS: + value->rValue = model->BSIM4v7xtsswgs; return(OK); - case BSIM4_MOD_XTSSWGD: - value->rValue = model->BSIM4xtsswgd; + case BSIM4v7_MOD_XTSSWGD: + value->rValue = model->BSIM4v7xtsswgd; return(OK); - case BSIM4_MOD_TNJTS: - value->rValue = model->BSIM4tnjts; + case BSIM4v7_MOD_TNJTS: + value->rValue = model->BSIM4v7tnjts; return(OK); - case BSIM4_MOD_TNJTSSW: - value->rValue = model->BSIM4tnjtssw; + case BSIM4v7_MOD_TNJTSSW: + value->rValue = model->BSIM4v7tnjtssw; return(OK); - case BSIM4_MOD_TNJTSSWG: - value->rValue = model->BSIM4tnjtsswg; + case BSIM4v7_MOD_TNJTSSWG: + value->rValue = model->BSIM4v7tnjtsswg; return(OK); - case BSIM4_MOD_TNJTSD: - value->rValue = model->BSIM4tnjtsd; + case BSIM4v7_MOD_TNJTSD: + value->rValue = model->BSIM4v7tnjtsd; return(OK); - case BSIM4_MOD_TNJTSSWD: - value->rValue = model->BSIM4tnjtsswd; + case BSIM4v7_MOD_TNJTSSWD: + value->rValue = model->BSIM4v7tnjtsswd; return(OK); - case BSIM4_MOD_TNJTSSWGD: - value->rValue = model->BSIM4tnjtsswgd; + case BSIM4v7_MOD_TNJTSSWGD: + value->rValue = model->BSIM4v7tnjtsswgd; return(OK); - case BSIM4_MOD_VTSS: - value->rValue = model->BSIM4vtss; + case BSIM4v7_MOD_VTSS: + value->rValue = model->BSIM4v7vtss; return(OK); - case BSIM4_MOD_VTSD: - value->rValue = model->BSIM4vtsd; + case BSIM4v7_MOD_VTSD: + value->rValue = model->BSIM4v7vtsd; return(OK); - case BSIM4_MOD_VTSSWS: - value->rValue = model->BSIM4vtssws; + case BSIM4v7_MOD_VTSSWS: + value->rValue = model->BSIM4v7vtssws; return(OK); - case BSIM4_MOD_VTSSWD: - value->rValue = model->BSIM4vtsswd; + case BSIM4v7_MOD_VTSSWD: + value->rValue = model->BSIM4v7vtsswd; return(OK); - case BSIM4_MOD_VTSSWGS: - value->rValue = model->BSIM4vtsswgs; + case BSIM4v7_MOD_VTSSWGS: + value->rValue = model->BSIM4v7vtsswgs; return(OK); - case BSIM4_MOD_VTSSWGD: - value->rValue = model->BSIM4vtsswgd; + case BSIM4v7_MOD_VTSSWGD: + value->rValue = model->BSIM4v7vtsswgd; return(OK); - case BSIM4_MOD_GBMIN: - value->rValue = model->BSIM4gbmin; + case BSIM4v7_MOD_GBMIN: + value->rValue = model->BSIM4v7gbmin; return(OK); - case BSIM4_MOD_RBDB: - value->rValue = model->BSIM4rbdb; + case BSIM4v7_MOD_RBDB: + value->rValue = model->BSIM4v7rbdb; return(OK); - case BSIM4_MOD_RBPB: - value->rValue = model->BSIM4rbpb; + case BSIM4v7_MOD_RBPB: + value->rValue = model->BSIM4v7rbpb; return(OK); - case BSIM4_MOD_RBSB: - value->rValue = model->BSIM4rbsb; + case BSIM4v7_MOD_RBSB: + value->rValue = model->BSIM4v7rbsb; return(OK); - case BSIM4_MOD_RBPS: - value->rValue = model->BSIM4rbps; + case BSIM4v7_MOD_RBPS: + value->rValue = model->BSIM4v7rbps; return(OK); - case BSIM4_MOD_RBPD: - value->rValue = model->BSIM4rbpd; + case BSIM4v7_MOD_RBPD: + value->rValue = model->BSIM4v7rbpd; return(OK); - case BSIM4_MOD_RBPS0: - value->rValue = model->BSIM4rbps0; + case BSIM4v7_MOD_RBPS0: + value->rValue = model->BSIM4v7rbps0; return(OK); - case BSIM4_MOD_RBPSL: - value->rValue = model->BSIM4rbpsl; + case BSIM4v7_MOD_RBPSL: + value->rValue = model->BSIM4v7rbpsl; return(OK); - case BSIM4_MOD_RBPSW: - value->rValue = model->BSIM4rbpsw; + case BSIM4v7_MOD_RBPSW: + value->rValue = model->BSIM4v7rbpsw; return(OK); - case BSIM4_MOD_RBPSNF: - value->rValue = model->BSIM4rbpsnf; + case BSIM4v7_MOD_RBPSNF: + value->rValue = model->BSIM4v7rbpsnf; return(OK); - case BSIM4_MOD_RBPD0: - value->rValue = model->BSIM4rbpd0; + case BSIM4v7_MOD_RBPD0: + value->rValue = model->BSIM4v7rbpd0; return(OK); - case BSIM4_MOD_RBPDL: - value->rValue = model->BSIM4rbpdl; + case BSIM4v7_MOD_RBPDL: + value->rValue = model->BSIM4v7rbpdl; return(OK); - case BSIM4_MOD_RBPDW: - value->rValue = model->BSIM4rbpdw; + case BSIM4v7_MOD_RBPDW: + value->rValue = model->BSIM4v7rbpdw; return(OK); - case BSIM4_MOD_RBPDNF: - value->rValue = model->BSIM4rbpdnf; + case BSIM4v7_MOD_RBPDNF: + value->rValue = model->BSIM4v7rbpdnf; return(OK); - case BSIM4_MOD_RBPBX0: - value->rValue = model->BSIM4rbpbx0; + case BSIM4v7_MOD_RBPBX0: + value->rValue = model->BSIM4v7rbpbx0; return(OK); - case BSIM4_MOD_RBPBXL: - value->rValue = model->BSIM4rbpbxl; + case BSIM4v7_MOD_RBPBXL: + value->rValue = model->BSIM4v7rbpbxl; return(OK); - case BSIM4_MOD_RBPBXW: - value->rValue = model->BSIM4rbpbxw; + case BSIM4v7_MOD_RBPBXW: + value->rValue = model->BSIM4v7rbpbxw; return(OK); - case BSIM4_MOD_RBPBXNF: - value->rValue = model->BSIM4rbpbxnf; + case BSIM4v7_MOD_RBPBXNF: + value->rValue = model->BSIM4v7rbpbxnf; return(OK); - case BSIM4_MOD_RBPBY0: - value->rValue = model->BSIM4rbpby0; + case BSIM4v7_MOD_RBPBY0: + value->rValue = model->BSIM4v7rbpby0; return(OK); - case BSIM4_MOD_RBPBYL: - value->rValue = model->BSIM4rbpbyl; + case BSIM4v7_MOD_RBPBYL: + value->rValue = model->BSIM4v7rbpbyl; return(OK); - case BSIM4_MOD_RBPBYW: - value->rValue = model->BSIM4rbpbyw; + case BSIM4v7_MOD_RBPBYW: + value->rValue = model->BSIM4v7rbpbyw; return(OK); - case BSIM4_MOD_RBPBYNF: - value->rValue = model->BSIM4rbpbynf; + case BSIM4v7_MOD_RBPBYNF: + value->rValue = model->BSIM4v7rbpbynf; return(OK); - case BSIM4_MOD_RBSBX0: - value->rValue = model->BSIM4rbsbx0; + case BSIM4v7_MOD_RBSBX0: + value->rValue = model->BSIM4v7rbsbx0; return(OK); - case BSIM4_MOD_RBSBY0: - value->rValue = model->BSIM4rbsby0; + case BSIM4v7_MOD_RBSBY0: + value->rValue = model->BSIM4v7rbsby0; return(OK); - case BSIM4_MOD_RBDBX0: - value->rValue = model->BSIM4rbdbx0; + case BSIM4v7_MOD_RBDBX0: + value->rValue = model->BSIM4v7rbdbx0; return(OK); - case BSIM4_MOD_RBDBY0: - value->rValue = model->BSIM4rbdby0; + case BSIM4v7_MOD_RBDBY0: + value->rValue = model->BSIM4v7rbdby0; return(OK); - case BSIM4_MOD_RBSDBXL: - value->rValue = model->BSIM4rbsdbxl; + case BSIM4v7_MOD_RBSDBXL: + value->rValue = model->BSIM4v7rbsdbxl; return(OK); - case BSIM4_MOD_RBSDBXW: - value->rValue = model->BSIM4rbsdbxw; + case BSIM4v7_MOD_RBSDBXW: + value->rValue = model->BSIM4v7rbsdbxw; return(OK); - case BSIM4_MOD_RBSDBXNF: - value->rValue = model->BSIM4rbsdbxnf; + case BSIM4v7_MOD_RBSDBXNF: + value->rValue = model->BSIM4v7rbsdbxnf; return(OK); - case BSIM4_MOD_RBSDBYL: - value->rValue = model->BSIM4rbsdbyl; + case BSIM4v7_MOD_RBSDBYL: + value->rValue = model->BSIM4v7rbsdbyl; return(OK); - case BSIM4_MOD_RBSDBYW: - value->rValue = model->BSIM4rbsdbyw; + case BSIM4v7_MOD_RBSDBYW: + value->rValue = model->BSIM4v7rbsdbyw; return(OK); - case BSIM4_MOD_RBSDBYNF: - value->rValue = model->BSIM4rbsdbynf; + case BSIM4v7_MOD_RBSDBYNF: + value->rValue = model->BSIM4v7rbsdbynf; return(OK); - case BSIM4_MOD_CGSL: - value->rValue = model->BSIM4cgsl; + case BSIM4v7_MOD_CGSL: + value->rValue = model->BSIM4v7cgsl; return(OK); - case BSIM4_MOD_CGDL: - value->rValue = model->BSIM4cgdl; + case BSIM4v7_MOD_CGDL: + value->rValue = model->BSIM4v7cgdl; return(OK); - case BSIM4_MOD_CKAPPAS: - value->rValue = model->BSIM4ckappas; + case BSIM4v7_MOD_CKAPPAS: + value->rValue = model->BSIM4v7ckappas; return(OK); - case BSIM4_MOD_CKAPPAD: - value->rValue = model->BSIM4ckappad; + case BSIM4v7_MOD_CKAPPAD: + value->rValue = model->BSIM4v7ckappad; return(OK); - case BSIM4_MOD_CF: - value->rValue = model->BSIM4cf; + case BSIM4v7_MOD_CF: + value->rValue = model->BSIM4v7cf; return(OK); - case BSIM4_MOD_CLC: - value->rValue = model->BSIM4clc; + case BSIM4v7_MOD_CLC: + value->rValue = model->BSIM4v7clc; return(OK); - case BSIM4_MOD_CLE: - value->rValue = model->BSIM4cle; + case BSIM4v7_MOD_CLE: + value->rValue = model->BSIM4v7cle; return(OK); - case BSIM4_MOD_DWC: - value->rValue = model->BSIM4dwc; + case BSIM4v7_MOD_DWC: + value->rValue = model->BSIM4v7dwc; return(OK); - case BSIM4_MOD_DLC: - value->rValue = model->BSIM4dlc; + case BSIM4v7_MOD_DLC: + value->rValue = model->BSIM4v7dlc; return(OK); - case BSIM4_MOD_XW: - value->rValue = model->BSIM4xw; + case BSIM4v7_MOD_XW: + value->rValue = model->BSIM4v7xw; return(OK); - case BSIM4_MOD_XL: - value->rValue = model->BSIM4xl; + case BSIM4v7_MOD_XL: + value->rValue = model->BSIM4v7xl; return(OK); - case BSIM4_MOD_DLCIG: - value->rValue = model->BSIM4dlcig; + case BSIM4v7_MOD_DLCIG: + value->rValue = model->BSIM4v7dlcig; return(OK); - case BSIM4_MOD_DLCIGD: - value->rValue = model->BSIM4dlcigd; + case BSIM4v7_MOD_DLCIGD: + value->rValue = model->BSIM4v7dlcigd; return(OK); - case BSIM4_MOD_DWJ: - value->rValue = model->BSIM4dwj; + case BSIM4v7_MOD_DWJ: + value->rValue = model->BSIM4v7dwj; return(OK); - case BSIM4_MOD_VFBCV: - value->rValue = model->BSIM4vfbcv; + case BSIM4v7_MOD_VFBCV: + value->rValue = model->BSIM4v7vfbcv; return(OK); - case BSIM4_MOD_ACDE: - value->rValue = model->BSIM4acde; + case BSIM4v7_MOD_ACDE: + value->rValue = model->BSIM4v7acde; return(OK); - case BSIM4_MOD_MOIN: - value->rValue = model->BSIM4moin; + case BSIM4v7_MOD_MOIN: + value->rValue = model->BSIM4v7moin; return(OK); - case BSIM4_MOD_NOFF: - value->rValue = model->BSIM4noff; + case BSIM4v7_MOD_NOFF: + value->rValue = model->BSIM4v7noff; return(OK); - case BSIM4_MOD_VOFFCV: - value->rValue = model->BSIM4voffcv; + case BSIM4v7_MOD_VOFFCV: + value->rValue = model->BSIM4v7voffcv; return(OK); - case BSIM4_MOD_DMCG: - value->rValue = model->BSIM4dmcg; + case BSIM4v7_MOD_DMCG: + value->rValue = model->BSIM4v7dmcg; return(OK); - case BSIM4_MOD_DMCI: - value->rValue = model->BSIM4dmci; + case BSIM4v7_MOD_DMCI: + value->rValue = model->BSIM4v7dmci; return(OK); - case BSIM4_MOD_DMDG: - value->rValue = model->BSIM4dmdg; + case BSIM4v7_MOD_DMDG: + value->rValue = model->BSIM4v7dmdg; return(OK); - case BSIM4_MOD_DMCGT: - value->rValue = model->BSIM4dmcgt; + case BSIM4v7_MOD_DMCGT: + value->rValue = model->BSIM4v7dmcgt; return(OK); - case BSIM4_MOD_XGW: - value->rValue = model->BSIM4xgw; + case BSIM4v7_MOD_XGW: + value->rValue = model->BSIM4v7xgw; return(OK); - case BSIM4_MOD_XGL: - value->rValue = model->BSIM4xgl; + case BSIM4v7_MOD_XGL: + value->rValue = model->BSIM4v7xgl; return(OK); - case BSIM4_MOD_RSHG: - value->rValue = model->BSIM4rshg; + case BSIM4v7_MOD_RSHG: + value->rValue = model->BSIM4v7rshg; return(OK); - case BSIM4_MOD_NGCON: - value->rValue = model->BSIM4ngcon; + case BSIM4v7_MOD_NGCON: + value->rValue = model->BSIM4v7ngcon; return(OK); - case BSIM4_MOD_TCJ: - value->rValue = model->BSIM4tcj; + case BSIM4v7_MOD_TCJ: + value->rValue = model->BSIM4v7tcj; return(OK); - case BSIM4_MOD_TPB: - value->rValue = model->BSIM4tpb; + case BSIM4v7_MOD_TPB: + value->rValue = model->BSIM4v7tpb; return(OK); - case BSIM4_MOD_TCJSW: - value->rValue = model->BSIM4tcjsw; + case BSIM4v7_MOD_TCJSW: + value->rValue = model->BSIM4v7tcjsw; return(OK); - case BSIM4_MOD_TPBSW: - value->rValue = model->BSIM4tpbsw; + case BSIM4v7_MOD_TPBSW: + value->rValue = model->BSIM4v7tpbsw; return(OK); - case BSIM4_MOD_TCJSWG: - value->rValue = model->BSIM4tcjswg; + case BSIM4v7_MOD_TCJSWG: + value->rValue = model->BSIM4v7tcjswg; return(OK); - case BSIM4_MOD_TPBSWG: - value->rValue = model->BSIM4tpbswg; + case BSIM4v7_MOD_TPBSWG: + value->rValue = model->BSIM4v7tpbswg; return(OK); /* Length dependence */ - case BSIM4_MOD_LCDSC : - value->rValue = model->BSIM4lcdsc; + case BSIM4v7_MOD_LCDSC : + value->rValue = model->BSIM4v7lcdsc; return(OK); - case BSIM4_MOD_LCDSCB : - value->rValue = model->BSIM4lcdscb; + case BSIM4v7_MOD_LCDSCB : + value->rValue = model->BSIM4v7lcdscb; return(OK); - case BSIM4_MOD_LCDSCD : - value->rValue = model->BSIM4lcdscd; + case BSIM4v7_MOD_LCDSCD : + value->rValue = model->BSIM4v7lcdscd; return(OK); - case BSIM4_MOD_LCIT : - value->rValue = model->BSIM4lcit; + case BSIM4v7_MOD_LCIT : + value->rValue = model->BSIM4v7lcit; return(OK); - case BSIM4_MOD_LNFACTOR : - value->rValue = model->BSIM4lnfactor; + case BSIM4v7_MOD_LNFACTOR : + value->rValue = model->BSIM4v7lnfactor; return(OK); - case BSIM4_MOD_LXJ: - value->rValue = model->BSIM4lxj; + case BSIM4v7_MOD_LXJ: + value->rValue = model->BSIM4v7lxj; return(OK); - case BSIM4_MOD_LVSAT: - value->rValue = model->BSIM4lvsat; + case BSIM4v7_MOD_LVSAT: + value->rValue = model->BSIM4v7lvsat; return(OK); - case BSIM4_MOD_LAT: - value->rValue = model->BSIM4lat; + case BSIM4v7_MOD_LAT: + value->rValue = model->BSIM4v7lat; return(OK); - case BSIM4_MOD_LA0: - value->rValue = model->BSIM4la0; + case BSIM4v7_MOD_LA0: + value->rValue = model->BSIM4v7la0; return(OK); - case BSIM4_MOD_LAGS: - value->rValue = model->BSIM4lags; + case BSIM4v7_MOD_LAGS: + value->rValue = model->BSIM4v7lags; return(OK); - case BSIM4_MOD_LA1: - value->rValue = model->BSIM4la1; + case BSIM4v7_MOD_LA1: + value->rValue = model->BSIM4v7la1; return(OK); - case BSIM4_MOD_LA2: - value->rValue = model->BSIM4la2; + case BSIM4v7_MOD_LA2: + value->rValue = model->BSIM4v7la2; return(OK); - case BSIM4_MOD_LKETA: - value->rValue = model->BSIM4lketa; + case BSIM4v7_MOD_LKETA: + value->rValue = model->BSIM4v7lketa; return(OK); - case BSIM4_MOD_LNSUB: - value->rValue = model->BSIM4lnsub; + case BSIM4v7_MOD_LNSUB: + value->rValue = model->BSIM4v7lnsub; return(OK); - case BSIM4_MOD_LNDEP: - value->rValue = model->BSIM4lndep; + case BSIM4v7_MOD_LNDEP: + value->rValue = model->BSIM4v7lndep; return(OK); - case BSIM4_MOD_LNSD: - value->rValue = model->BSIM4lnsd; + case BSIM4v7_MOD_LNSD: + value->rValue = model->BSIM4v7lnsd; return(OK); - case BSIM4_MOD_LNGATE: - value->rValue = model->BSIM4lngate; + case BSIM4v7_MOD_LNGATE: + value->rValue = model->BSIM4v7lngate; return(OK); - case BSIM4_MOD_LGAMMA1: - value->rValue = model->BSIM4lgamma1; + case BSIM4v7_MOD_LGAMMA1: + value->rValue = model->BSIM4v7lgamma1; return(OK); - case BSIM4_MOD_LGAMMA2: - value->rValue = model->BSIM4lgamma2; + case BSIM4v7_MOD_LGAMMA2: + value->rValue = model->BSIM4v7lgamma2; return(OK); - case BSIM4_MOD_LVBX: - value->rValue = model->BSIM4lvbx; + case BSIM4v7_MOD_LVBX: + value->rValue = model->BSIM4v7lvbx; return(OK); - case BSIM4_MOD_LVBM: - value->rValue = model->BSIM4lvbm; + case BSIM4v7_MOD_LVBM: + value->rValue = model->BSIM4v7lvbm; return(OK); - case BSIM4_MOD_LXT: - value->rValue = model->BSIM4lxt; + case BSIM4v7_MOD_LXT: + value->rValue = model->BSIM4v7lxt; return(OK); - case BSIM4_MOD_LK1: - value->rValue = model->BSIM4lk1; + case BSIM4v7_MOD_LK1: + value->rValue = model->BSIM4v7lk1; return(OK); - case BSIM4_MOD_LKT1: - value->rValue = model->BSIM4lkt1; + case BSIM4v7_MOD_LKT1: + value->rValue = model->BSIM4v7lkt1; return(OK); - case BSIM4_MOD_LKT1L: - value->rValue = model->BSIM4lkt1l; + case BSIM4v7_MOD_LKT1L: + value->rValue = model->BSIM4v7lkt1l; return(OK); - case BSIM4_MOD_LKT2 : - value->rValue = model->BSIM4lkt2; + case BSIM4v7_MOD_LKT2 : + value->rValue = model->BSIM4v7lkt2; return(OK); - case BSIM4_MOD_LK2 : - value->rValue = model->BSIM4lk2; + case BSIM4v7_MOD_LK2 : + value->rValue = model->BSIM4v7lk2; return(OK); - case BSIM4_MOD_LK3: - value->rValue = model->BSIM4lk3; + case BSIM4v7_MOD_LK3: + value->rValue = model->BSIM4v7lk3; return(OK); - case BSIM4_MOD_LK3B: - value->rValue = model->BSIM4lk3b; + case BSIM4v7_MOD_LK3B: + value->rValue = model->BSIM4v7lk3b; return(OK); - case BSIM4_MOD_LW0: - value->rValue = model->BSIM4lw0; + case BSIM4v7_MOD_LW0: + value->rValue = model->BSIM4v7lw0; return(OK); - case BSIM4_MOD_LLPE0: - value->rValue = model->BSIM4llpe0; + case BSIM4v7_MOD_LLPE0: + value->rValue = model->BSIM4v7llpe0; return(OK); - case BSIM4_MOD_LLPEB: - value->rValue = model->BSIM4llpeb; + case BSIM4v7_MOD_LLPEB: + value->rValue = model->BSIM4v7llpeb; return(OK); - case BSIM4_MOD_LDVTP0: - value->rValue = model->BSIM4ldvtp0; + case BSIM4v7_MOD_LDVTP0: + value->rValue = model->BSIM4v7ldvtp0; return(OK); - case BSIM4_MOD_LDVTP1: - value->rValue = model->BSIM4ldvtp1; + case BSIM4v7_MOD_LDVTP1: + value->rValue = model->BSIM4v7ldvtp1; return(OK); - case BSIM4_MOD_LDVTP2: - value->rValue = model->BSIM4ldvtp2; /* New DIBL/Rout */ + case BSIM4v7_MOD_LDVTP2: + value->rValue = model->BSIM4v7ldvtp2; /* New DIBL/Rout */ return(OK); - case BSIM4_MOD_LDVTP3: - value->rValue = model->BSIM4ldvtp3; + case BSIM4v7_MOD_LDVTP3: + value->rValue = model->BSIM4v7ldvtp3; return(OK); - case BSIM4_MOD_LDVTP4: - value->rValue = model->BSIM4ldvtp4; + case BSIM4v7_MOD_LDVTP4: + value->rValue = model->BSIM4v7ldvtp4; return(OK); - case BSIM4_MOD_LDVTP5: - value->rValue = model->BSIM4ldvtp5; + case BSIM4v7_MOD_LDVTP5: + value->rValue = model->BSIM4v7ldvtp5; return(OK); - case BSIM4_MOD_LDVT0: - value->rValue = model->BSIM4ldvt0; + case BSIM4v7_MOD_LDVT0: + value->rValue = model->BSIM4v7ldvt0; return(OK); - case BSIM4_MOD_LDVT1 : - value->rValue = model->BSIM4ldvt1; + case BSIM4v7_MOD_LDVT1 : + value->rValue = model->BSIM4v7ldvt1; return(OK); - case BSIM4_MOD_LDVT2 : - value->rValue = model->BSIM4ldvt2; + case BSIM4v7_MOD_LDVT2 : + value->rValue = model->BSIM4v7ldvt2; return(OK); - case BSIM4_MOD_LDVT0W : - value->rValue = model->BSIM4ldvt0w; + case BSIM4v7_MOD_LDVT0W : + value->rValue = model->BSIM4v7ldvt0w; return(OK); - case BSIM4_MOD_LDVT1W : - value->rValue = model->BSIM4ldvt1w; + case BSIM4v7_MOD_LDVT1W : + value->rValue = model->BSIM4v7ldvt1w; return(OK); - case BSIM4_MOD_LDVT2W : - value->rValue = model->BSIM4ldvt2w; + case BSIM4v7_MOD_LDVT2W : + value->rValue = model->BSIM4v7ldvt2w; return(OK); - case BSIM4_MOD_LDROUT : - value->rValue = model->BSIM4ldrout; + case BSIM4v7_MOD_LDROUT : + value->rValue = model->BSIM4v7ldrout; return(OK); - case BSIM4_MOD_LDSUB : - value->rValue = model->BSIM4ldsub; + case BSIM4v7_MOD_LDSUB : + value->rValue = model->BSIM4v7ldsub; return(OK); - case BSIM4_MOD_LVTH0: - value->rValue = model->BSIM4lvth0; + case BSIM4v7_MOD_LVTH0: + value->rValue = model->BSIM4v7lvth0; return(OK); - case BSIM4_MOD_LUA: - value->rValue = model->BSIM4lua; + case BSIM4v7_MOD_LUA: + value->rValue = model->BSIM4v7lua; return(OK); - case BSIM4_MOD_LUA1: - value->rValue = model->BSIM4lua1; + case BSIM4v7_MOD_LUA1: + value->rValue = model->BSIM4v7lua1; return(OK); - case BSIM4_MOD_LUB: - value->rValue = model->BSIM4lub; + case BSIM4v7_MOD_LUB: + value->rValue = model->BSIM4v7lub; return(OK); - case BSIM4_MOD_LUB1: - value->rValue = model->BSIM4lub1; + case BSIM4v7_MOD_LUB1: + value->rValue = model->BSIM4v7lub1; return(OK); - case BSIM4_MOD_LUC: - value->rValue = model->BSIM4luc; + case BSIM4v7_MOD_LUC: + value->rValue = model->BSIM4v7luc; return(OK); - case BSIM4_MOD_LUC1: - value->rValue = model->BSIM4luc1; + case BSIM4v7_MOD_LUC1: + value->rValue = model->BSIM4v7luc1; return(OK); - case BSIM4_MOD_LUD: - value->rValue = model->BSIM4lud; + case BSIM4v7_MOD_LUD: + value->rValue = model->BSIM4v7lud; return(OK); - case BSIM4_MOD_LUD1: - value->rValue = model->BSIM4lud1; + case BSIM4v7_MOD_LUD1: + value->rValue = model->BSIM4v7lud1; return(OK); - case BSIM4_MOD_LUP: - value->rValue = model->BSIM4lup; + case BSIM4v7_MOD_LUP: + value->rValue = model->BSIM4v7lup; return(OK); - case BSIM4_MOD_LLP: - value->rValue = model->BSIM4llp; + case BSIM4v7_MOD_LLP: + value->rValue = model->BSIM4v7llp; return(OK); - case BSIM4_MOD_LU0: - value->rValue = model->BSIM4lu0; + case BSIM4v7_MOD_LU0: + value->rValue = model->BSIM4v7lu0; return(OK); - case BSIM4_MOD_LUTE: - value->rValue = model->BSIM4lute; + case BSIM4v7_MOD_LUTE: + value->rValue = model->BSIM4v7lute; return(OK); - case BSIM4_MOD_LUCSTE: - value->rValue = model->BSIM4lucste; + case BSIM4v7_MOD_LUCSTE: + value->rValue = model->BSIM4v7lucste; return(OK); - case BSIM4_MOD_LVOFF: - value->rValue = model->BSIM4lvoff; + case BSIM4v7_MOD_LVOFF: + value->rValue = model->BSIM4v7lvoff; return(OK); - case BSIM4_MOD_LTVOFF: - value->rValue = model->BSIM4ltvoff; + case BSIM4v7_MOD_LTVOFF: + value->rValue = model->BSIM4v7ltvoff; return(OK); - case BSIM4_MOD_LTNFACTOR: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4ltnfactor; + case BSIM4v7_MOD_LTNFACTOR: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7ltnfactor; return(OK); - case BSIM4_MOD_LTETA0: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4lteta0; + case BSIM4v7_MOD_LTETA0: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7lteta0; return(OK); - case BSIM4_MOD_LTVOFFCV: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4ltvoffcv; + case BSIM4v7_MOD_LTVOFFCV: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7ltvoffcv; return(OK); - case BSIM4_MOD_LMINV: - value->rValue = model->BSIM4lminv; + case BSIM4v7_MOD_LMINV: + value->rValue = model->BSIM4v7lminv; return(OK); - case BSIM4_MOD_LMINVCV: - value->rValue = model->BSIM4lminvcv; + case BSIM4v7_MOD_LMINVCV: + value->rValue = model->BSIM4v7lminvcv; return(OK); - case BSIM4_MOD_LFPROUT: - value->rValue = model->BSIM4lfprout; + case BSIM4v7_MOD_LFPROUT: + value->rValue = model->BSIM4v7lfprout; return(OK); - case BSIM4_MOD_LPDITS: - value->rValue = model->BSIM4lpdits; + case BSIM4v7_MOD_LPDITS: + value->rValue = model->BSIM4v7lpdits; return(OK); - case BSIM4_MOD_LPDITSD: - value->rValue = model->BSIM4lpditsd; + case BSIM4v7_MOD_LPDITSD: + value->rValue = model->BSIM4v7lpditsd; return(OK); - case BSIM4_MOD_LDELTA: - value->rValue = model->BSIM4ldelta; + case BSIM4v7_MOD_LDELTA: + value->rValue = model->BSIM4v7ldelta; return(OK); - case BSIM4_MOD_LRDSW: - value->rValue = model->BSIM4lrdsw; + case BSIM4v7_MOD_LRDSW: + value->rValue = model->BSIM4v7lrdsw; return(OK); - case BSIM4_MOD_LRDW: - value->rValue = model->BSIM4lrdw; + case BSIM4v7_MOD_LRDW: + value->rValue = model->BSIM4v7lrdw; return(OK); - case BSIM4_MOD_LRSW: - value->rValue = model->BSIM4lrsw; + case BSIM4v7_MOD_LRSW: + value->rValue = model->BSIM4v7lrsw; return(OK); - case BSIM4_MOD_LPRWB: - value->rValue = model->BSIM4lprwb; + case BSIM4v7_MOD_LPRWB: + value->rValue = model->BSIM4v7lprwb; return(OK); - case BSIM4_MOD_LPRWG: - value->rValue = model->BSIM4lprwg; + case BSIM4v7_MOD_LPRWG: + value->rValue = model->BSIM4v7lprwg; return(OK); - case BSIM4_MOD_LPRT: - value->rValue = model->BSIM4lprt; + case BSIM4v7_MOD_LPRT: + value->rValue = model->BSIM4v7lprt; return(OK); - case BSIM4_MOD_LETA0: - value->rValue = model->BSIM4leta0; + case BSIM4v7_MOD_LETA0: + value->rValue = model->BSIM4v7leta0; return(OK); - case BSIM4_MOD_LETAB: - value->rValue = model->BSIM4letab; + case BSIM4v7_MOD_LETAB: + value->rValue = model->BSIM4v7letab; return(OK); - case BSIM4_MOD_LPCLM: - value->rValue = model->BSIM4lpclm; + case BSIM4v7_MOD_LPCLM: + value->rValue = model->BSIM4v7lpclm; return(OK); - case BSIM4_MOD_LPDIBL1: - value->rValue = model->BSIM4lpdibl1; + case BSIM4v7_MOD_LPDIBL1: + value->rValue = model->BSIM4v7lpdibl1; return(OK); - case BSIM4_MOD_LPDIBL2: - value->rValue = model->BSIM4lpdibl2; + case BSIM4v7_MOD_LPDIBL2: + value->rValue = model->BSIM4v7lpdibl2; return(OK); - case BSIM4_MOD_LPDIBLB: - value->rValue = model->BSIM4lpdiblb; + case BSIM4v7_MOD_LPDIBLB: + value->rValue = model->BSIM4v7lpdiblb; return(OK); - case BSIM4_MOD_LPSCBE1: - value->rValue = model->BSIM4lpscbe1; + case BSIM4v7_MOD_LPSCBE1: + value->rValue = model->BSIM4v7lpscbe1; return(OK); - case BSIM4_MOD_LPSCBE2: - value->rValue = model->BSIM4lpscbe2; + case BSIM4v7_MOD_LPSCBE2: + value->rValue = model->BSIM4v7lpscbe2; return(OK); - case BSIM4_MOD_LPVAG: - value->rValue = model->BSIM4lpvag; + case BSIM4v7_MOD_LPVAG: + value->rValue = model->BSIM4v7lpvag; return(OK); - case BSIM4_MOD_LWR: - value->rValue = model->BSIM4lwr; + case BSIM4v7_MOD_LWR: + value->rValue = model->BSIM4v7lwr; return(OK); - case BSIM4_MOD_LDWG: - value->rValue = model->BSIM4ldwg; + case BSIM4v7_MOD_LDWG: + value->rValue = model->BSIM4v7ldwg; return(OK); - case BSIM4_MOD_LDWB: - value->rValue = model->BSIM4ldwb; + case BSIM4v7_MOD_LDWB: + value->rValue = model->BSIM4v7ldwb; return(OK); - case BSIM4_MOD_LB0: - value->rValue = model->BSIM4lb0; + case BSIM4v7_MOD_LB0: + value->rValue = model->BSIM4v7lb0; return(OK); - case BSIM4_MOD_LB1: - value->rValue = model->BSIM4lb1; + case BSIM4v7_MOD_LB1: + value->rValue = model->BSIM4v7lb1; return(OK); - case BSIM4_MOD_LALPHA0: - value->rValue = model->BSIM4lalpha0; + case BSIM4v7_MOD_LALPHA0: + value->rValue = model->BSIM4v7lalpha0; return(OK); - case BSIM4_MOD_LALPHA1: - value->rValue = model->BSIM4lalpha1; + case BSIM4v7_MOD_LALPHA1: + value->rValue = model->BSIM4v7lalpha1; return(OK); - case BSIM4_MOD_LBETA0: - value->rValue = model->BSIM4lbeta0; + case BSIM4v7_MOD_LBETA0: + value->rValue = model->BSIM4v7lbeta0; return(OK); - case BSIM4_MOD_LAGIDL: - value->rValue = model->BSIM4lagidl; + case BSIM4v7_MOD_LAGIDL: + value->rValue = model->BSIM4v7lagidl; return(OK); - case BSIM4_MOD_LBGIDL: - value->rValue = model->BSIM4lbgidl; + case BSIM4v7_MOD_LBGIDL: + value->rValue = model->BSIM4v7lbgidl; return(OK); - case BSIM4_MOD_LCGIDL: - value->rValue = model->BSIM4lcgidl; + case BSIM4v7_MOD_LCGIDL: + value->rValue = model->BSIM4v7lcgidl; return(OK); - case BSIM4_MOD_LEGIDL: - value->rValue = model->BSIM4legidl; + case BSIM4v7_MOD_LEGIDL: + value->rValue = model->BSIM4v7legidl; return(OK); - case BSIM4_MOD_LFGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4lfgidl; + case BSIM4v7_MOD_LFGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7lfgidl; return(OK); - case BSIM4_MOD_LKGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4lkgidl; + case BSIM4v7_MOD_LKGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7lkgidl; return(OK); - case BSIM4_MOD_LRGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4lrgidl; + case BSIM4v7_MOD_LRGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7lrgidl; return(OK); - case BSIM4_MOD_LAGISL: - value->rValue = model->BSIM4lagisl; + case BSIM4v7_MOD_LAGISL: + value->rValue = model->BSIM4v7lagisl; return(OK); - case BSIM4_MOD_LBGISL: - value->rValue = model->BSIM4lbgisl; + case BSIM4v7_MOD_LBGISL: + value->rValue = model->BSIM4v7lbgisl; return(OK); - case BSIM4_MOD_LCGISL: - value->rValue = model->BSIM4lcgisl; + case BSIM4v7_MOD_LCGISL: + value->rValue = model->BSIM4v7lcgisl; return(OK); - case BSIM4_MOD_LEGISL: - value->rValue = model->BSIM4legisl; + case BSIM4v7_MOD_LEGISL: + value->rValue = model->BSIM4v7legisl; return(OK); - case BSIM4_MOD_LFGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4lfgisl; + case BSIM4v7_MOD_LFGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7lfgisl; return(OK); - case BSIM4_MOD_LKGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4lkgisl; + case BSIM4v7_MOD_LKGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7lkgisl; return(OK); - case BSIM4_MOD_LRGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4lrgisl; + case BSIM4v7_MOD_LRGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7lrgisl; return(OK); - case BSIM4_MOD_LAIGC: - value->rValue = model->BSIM4laigc; + case BSIM4v7_MOD_LAIGC: + value->rValue = model->BSIM4v7laigc; return(OK); - case BSIM4_MOD_LBIGC: - value->rValue = model->BSIM4lbigc; + case BSIM4v7_MOD_LBIGC: + value->rValue = model->BSIM4v7lbigc; return(OK); - case BSIM4_MOD_LCIGC: - value->rValue = model->BSIM4lcigc; + case BSIM4v7_MOD_LCIGC: + value->rValue = model->BSIM4v7lcigc; return(OK); - case BSIM4_MOD_LAIGSD: - value->rValue = model->BSIM4laigsd; + case BSIM4v7_MOD_LAIGSD: + value->rValue = model->BSIM4v7laigsd; return(OK); - case BSIM4_MOD_LBIGSD: - value->rValue = model->BSIM4lbigsd; + case BSIM4v7_MOD_LBIGSD: + value->rValue = model->BSIM4v7lbigsd; return(OK); - case BSIM4_MOD_LCIGSD: - value->rValue = model->BSIM4lcigsd; + case BSIM4v7_MOD_LCIGSD: + value->rValue = model->BSIM4v7lcigsd; return(OK); - case BSIM4_MOD_LAIGS: - value->rValue = model->BSIM4laigs; + case BSIM4v7_MOD_LAIGS: + value->rValue = model->BSIM4v7laigs; return(OK); - case BSIM4_MOD_LBIGS: - value->rValue = model->BSIM4lbigs; + case BSIM4v7_MOD_LBIGS: + value->rValue = model->BSIM4v7lbigs; return(OK); - case BSIM4_MOD_LCIGS: - value->rValue = model->BSIM4lcigs; + case BSIM4v7_MOD_LCIGS: + value->rValue = model->BSIM4v7lcigs; return(OK); - case BSIM4_MOD_LAIGD: - value->rValue = model->BSIM4laigd; + case BSIM4v7_MOD_LAIGD: + value->rValue = model->BSIM4v7laigd; return(OK); - case BSIM4_MOD_LBIGD: - value->rValue = model->BSIM4lbigd; + case BSIM4v7_MOD_LBIGD: + value->rValue = model->BSIM4v7lbigd; return(OK); - case BSIM4_MOD_LCIGD: - value->rValue = model->BSIM4lcigd; + case BSIM4v7_MOD_LCIGD: + value->rValue = model->BSIM4v7lcigd; return(OK); - case BSIM4_MOD_LAIGBACC: - value->rValue = model->BSIM4laigbacc; + case BSIM4v7_MOD_LAIGBACC: + value->rValue = model->BSIM4v7laigbacc; return(OK); - case BSIM4_MOD_LBIGBACC: - value->rValue = model->BSIM4lbigbacc; + case BSIM4v7_MOD_LBIGBACC: + value->rValue = model->BSIM4v7lbigbacc; return(OK); - case BSIM4_MOD_LCIGBACC: - value->rValue = model->BSIM4lcigbacc; + case BSIM4v7_MOD_LCIGBACC: + value->rValue = model->BSIM4v7lcigbacc; return(OK); - case BSIM4_MOD_LAIGBINV: - value->rValue = model->BSIM4laigbinv; + case BSIM4v7_MOD_LAIGBINV: + value->rValue = model->BSIM4v7laigbinv; return(OK); - case BSIM4_MOD_LBIGBINV: - value->rValue = model->BSIM4lbigbinv; + case BSIM4v7_MOD_LBIGBINV: + value->rValue = model->BSIM4v7lbigbinv; return(OK); - case BSIM4_MOD_LCIGBINV: - value->rValue = model->BSIM4lcigbinv; + case BSIM4v7_MOD_LCIGBINV: + value->rValue = model->BSIM4v7lcigbinv; return(OK); - case BSIM4_MOD_LNIGC: - value->rValue = model->BSIM4lnigc; + case BSIM4v7_MOD_LNIGC: + value->rValue = model->BSIM4v7lnigc; return(OK); - case BSIM4_MOD_LNIGBACC: - value->rValue = model->BSIM4lnigbacc; + case BSIM4v7_MOD_LNIGBACC: + value->rValue = model->BSIM4v7lnigbacc; return(OK); - case BSIM4_MOD_LNIGBINV: - value->rValue = model->BSIM4lnigbinv; + case BSIM4v7_MOD_LNIGBINV: + value->rValue = model->BSIM4v7lnigbinv; return(OK); - case BSIM4_MOD_LNTOX: - value->rValue = model->BSIM4lntox; + case BSIM4v7_MOD_LNTOX: + value->rValue = model->BSIM4v7lntox; return(OK); - case BSIM4_MOD_LEIGBINV: - value->rValue = model->BSIM4leigbinv; + case BSIM4v7_MOD_LEIGBINV: + value->rValue = model->BSIM4v7leigbinv; return(OK); - case BSIM4_MOD_LPIGCD: - value->rValue = model->BSIM4lpigcd; + case BSIM4v7_MOD_LPIGCD: + value->rValue = model->BSIM4v7lpigcd; return(OK); - case BSIM4_MOD_LPOXEDGE: - value->rValue = model->BSIM4lpoxedge; + case BSIM4v7_MOD_LPOXEDGE: + value->rValue = model->BSIM4v7lpoxedge; return(OK); - case BSIM4_MOD_LPHIN: - value->rValue = model->BSIM4lphin; + case BSIM4v7_MOD_LPHIN: + value->rValue = model->BSIM4v7lphin; return(OK); - case BSIM4_MOD_LXRCRG1: - value->rValue = model->BSIM4lxrcrg1; + case BSIM4v7_MOD_LXRCRG1: + value->rValue = model->BSIM4v7lxrcrg1; return(OK); - case BSIM4_MOD_LXRCRG2: - value->rValue = model->BSIM4lxrcrg2; + case BSIM4v7_MOD_LXRCRG2: + value->rValue = model->BSIM4v7lxrcrg2; return(OK); - case BSIM4_MOD_LEU: - value->rValue = model->BSIM4leu; + case BSIM4v7_MOD_LEU: + value->rValue = model->BSIM4v7leu; return(OK); - case BSIM4_MOD_LUCS: - value->rValue = model->BSIM4lucs; + case BSIM4v7_MOD_LUCS: + value->rValue = model->BSIM4v7lucs; return(OK); - case BSIM4_MOD_LVFB: - value->rValue = model->BSIM4lvfb; + case BSIM4v7_MOD_LVFB: + value->rValue = model->BSIM4v7lvfb; return(OK); - case BSIM4_MOD_LCGSL: - value->rValue = model->BSIM4lcgsl; + case BSIM4v7_MOD_LCGSL: + value->rValue = model->BSIM4v7lcgsl; return(OK); - case BSIM4_MOD_LCGDL: - value->rValue = model->BSIM4lcgdl; + case BSIM4v7_MOD_LCGDL: + value->rValue = model->BSIM4v7lcgdl; return(OK); - case BSIM4_MOD_LCKAPPAS: - value->rValue = model->BSIM4lckappas; + case BSIM4v7_MOD_LCKAPPAS: + value->rValue = model->BSIM4v7lckappas; return(OK); - case BSIM4_MOD_LCKAPPAD: - value->rValue = model->BSIM4lckappad; + case BSIM4v7_MOD_LCKAPPAD: + value->rValue = model->BSIM4v7lckappad; return(OK); - case BSIM4_MOD_LCF: - value->rValue = model->BSIM4lcf; + case BSIM4v7_MOD_LCF: + value->rValue = model->BSIM4v7lcf; return(OK); - case BSIM4_MOD_LCLC: - value->rValue = model->BSIM4lclc; + case BSIM4v7_MOD_LCLC: + value->rValue = model->BSIM4v7lclc; return(OK); - case BSIM4_MOD_LCLE: - value->rValue = model->BSIM4lcle; + case BSIM4v7_MOD_LCLE: + value->rValue = model->BSIM4v7lcle; return(OK); - case BSIM4_MOD_LVFBCV: - value->rValue = model->BSIM4lvfbcv; + case BSIM4v7_MOD_LVFBCV: + value->rValue = model->BSIM4v7lvfbcv; return(OK); - case BSIM4_MOD_LACDE: - value->rValue = model->BSIM4lacde; + case BSIM4v7_MOD_LACDE: + value->rValue = model->BSIM4v7lacde; return(OK); - case BSIM4_MOD_LMOIN: - value->rValue = model->BSIM4lmoin; + case BSIM4v7_MOD_LMOIN: + value->rValue = model->BSIM4v7lmoin; return(OK); - case BSIM4_MOD_LNOFF: - value->rValue = model->BSIM4lnoff; + case BSIM4v7_MOD_LNOFF: + value->rValue = model->BSIM4v7lnoff; return(OK); - case BSIM4_MOD_LVOFFCV: - value->rValue = model->BSIM4lvoffcv; + case BSIM4v7_MOD_LVOFFCV: + value->rValue = model->BSIM4v7lvoffcv; return(OK); - case BSIM4_MOD_LVFBSDOFF: - value->rValue = model->BSIM4lvfbsdoff; + case BSIM4v7_MOD_LVFBSDOFF: + value->rValue = model->BSIM4v7lvfbsdoff; return(OK); - case BSIM4_MOD_LTVFBSDOFF: - value->rValue = model->BSIM4ltvfbsdoff; + case BSIM4v7_MOD_LTVFBSDOFF: + value->rValue = model->BSIM4v7ltvfbsdoff; return(OK); - case BSIM4_MOD_LLAMBDA: - value->rValue = model->BSIM4llambda; + case BSIM4v7_MOD_LLAMBDA: + value->rValue = model->BSIM4v7llambda; return(OK); - case BSIM4_MOD_LVTL: - value->rValue = model->BSIM4lvtl; + case BSIM4v7_MOD_LVTL: + value->rValue = model->BSIM4v7lvtl; return(OK); - case BSIM4_MOD_LXN: - value->rValue = model->BSIM4lxn; + case BSIM4v7_MOD_LXN: + value->rValue = model->BSIM4v7lxn; return(OK); /* Width dependence */ - case BSIM4_MOD_WCDSC : - value->rValue = model->BSIM4wcdsc; + case BSIM4v7_MOD_WCDSC : + value->rValue = model->BSIM4v7wcdsc; return(OK); - case BSIM4_MOD_WCDSCB : - value->rValue = model->BSIM4wcdscb; + case BSIM4v7_MOD_WCDSCB : + value->rValue = model->BSIM4v7wcdscb; return(OK); - case BSIM4_MOD_WCDSCD : - value->rValue = model->BSIM4wcdscd; + case BSIM4v7_MOD_WCDSCD : + value->rValue = model->BSIM4v7wcdscd; return(OK); - case BSIM4_MOD_WCIT : - value->rValue = model->BSIM4wcit; + case BSIM4v7_MOD_WCIT : + value->rValue = model->BSIM4v7wcit; return(OK); - case BSIM4_MOD_WNFACTOR : - value->rValue = model->BSIM4wnfactor; + case BSIM4v7_MOD_WNFACTOR : + value->rValue = model->BSIM4v7wnfactor; return(OK); - case BSIM4_MOD_WXJ: - value->rValue = model->BSIM4wxj; + case BSIM4v7_MOD_WXJ: + value->rValue = model->BSIM4v7wxj; return(OK); - case BSIM4_MOD_WVSAT: - value->rValue = model->BSIM4wvsat; + case BSIM4v7_MOD_WVSAT: + value->rValue = model->BSIM4v7wvsat; return(OK); - case BSIM4_MOD_WAT: - value->rValue = model->BSIM4wat; + case BSIM4v7_MOD_WAT: + value->rValue = model->BSIM4v7wat; return(OK); - case BSIM4_MOD_WA0: - value->rValue = model->BSIM4wa0; + case BSIM4v7_MOD_WA0: + value->rValue = model->BSIM4v7wa0; return(OK); - case BSIM4_MOD_WAGS: - value->rValue = model->BSIM4wags; + case BSIM4v7_MOD_WAGS: + value->rValue = model->BSIM4v7wags; return(OK); - case BSIM4_MOD_WA1: - value->rValue = model->BSIM4wa1; + case BSIM4v7_MOD_WA1: + value->rValue = model->BSIM4v7wa1; return(OK); - case BSIM4_MOD_WA2: - value->rValue = model->BSIM4wa2; + case BSIM4v7_MOD_WA2: + value->rValue = model->BSIM4v7wa2; return(OK); - case BSIM4_MOD_WKETA: - value->rValue = model->BSIM4wketa; + case BSIM4v7_MOD_WKETA: + value->rValue = model->BSIM4v7wketa; return(OK); - case BSIM4_MOD_WNSUB: - value->rValue = model->BSIM4wnsub; + case BSIM4v7_MOD_WNSUB: + value->rValue = model->BSIM4v7wnsub; return(OK); - case BSIM4_MOD_WNDEP: - value->rValue = model->BSIM4wndep; + case BSIM4v7_MOD_WNDEP: + value->rValue = model->BSIM4v7wndep; return(OK); - case BSIM4_MOD_WNSD: - value->rValue = model->BSIM4wnsd; + case BSIM4v7_MOD_WNSD: + value->rValue = model->BSIM4v7wnsd; return(OK); - case BSIM4_MOD_WNGATE: - value->rValue = model->BSIM4wngate; + case BSIM4v7_MOD_WNGATE: + value->rValue = model->BSIM4v7wngate; return(OK); - case BSIM4_MOD_WGAMMA1: - value->rValue = model->BSIM4wgamma1; + case BSIM4v7_MOD_WGAMMA1: + value->rValue = model->BSIM4v7wgamma1; return(OK); - case BSIM4_MOD_WGAMMA2: - value->rValue = model->BSIM4wgamma2; + case BSIM4v7_MOD_WGAMMA2: + value->rValue = model->BSIM4v7wgamma2; return(OK); - case BSIM4_MOD_WVBX: - value->rValue = model->BSIM4wvbx; + case BSIM4v7_MOD_WVBX: + value->rValue = model->BSIM4v7wvbx; return(OK); - case BSIM4_MOD_WVBM: - value->rValue = model->BSIM4wvbm; + case BSIM4v7_MOD_WVBM: + value->rValue = model->BSIM4v7wvbm; return(OK); - case BSIM4_MOD_WXT: - value->rValue = model->BSIM4wxt; + case BSIM4v7_MOD_WXT: + value->rValue = model->BSIM4v7wxt; return(OK); - case BSIM4_MOD_WK1: - value->rValue = model->BSIM4wk1; + case BSIM4v7_MOD_WK1: + value->rValue = model->BSIM4v7wk1; return(OK); - case BSIM4_MOD_WKT1: - value->rValue = model->BSIM4wkt1; + case BSIM4v7_MOD_WKT1: + value->rValue = model->BSIM4v7wkt1; return(OK); - case BSIM4_MOD_WKT1L: - value->rValue = model->BSIM4wkt1l; + case BSIM4v7_MOD_WKT1L: + value->rValue = model->BSIM4v7wkt1l; return(OK); - case BSIM4_MOD_WKT2 : - value->rValue = model->BSIM4wkt2; + case BSIM4v7_MOD_WKT2 : + value->rValue = model->BSIM4v7wkt2; return(OK); - case BSIM4_MOD_WK2 : - value->rValue = model->BSIM4wk2; + case BSIM4v7_MOD_WK2 : + value->rValue = model->BSIM4v7wk2; return(OK); - case BSIM4_MOD_WK3: - value->rValue = model->BSIM4wk3; + case BSIM4v7_MOD_WK3: + value->rValue = model->BSIM4v7wk3; return(OK); - case BSIM4_MOD_WK3B: - value->rValue = model->BSIM4wk3b; + case BSIM4v7_MOD_WK3B: + value->rValue = model->BSIM4v7wk3b; return(OK); - case BSIM4_MOD_WW0: - value->rValue = model->BSIM4ww0; + case BSIM4v7_MOD_WW0: + value->rValue = model->BSIM4v7ww0; return(OK); - case BSIM4_MOD_WLPE0: - value->rValue = model->BSIM4wlpe0; + case BSIM4v7_MOD_WLPE0: + value->rValue = model->BSIM4v7wlpe0; return(OK); - case BSIM4_MOD_WDVTP0: - value->rValue = model->BSIM4wdvtp0; + case BSIM4v7_MOD_WDVTP0: + value->rValue = model->BSIM4v7wdvtp0; return(OK); - case BSIM4_MOD_WDVTP1: - value->rValue = model->BSIM4wdvtp1; + case BSIM4v7_MOD_WDVTP1: + value->rValue = model->BSIM4v7wdvtp1; return(OK); - case BSIM4_MOD_WDVTP2: - value->rValue = model->BSIM4wdvtp2; /* New DIBL/Rout */ + case BSIM4v7_MOD_WDVTP2: + value->rValue = model->BSIM4v7wdvtp2; /* New DIBL/Rout */ return(OK); - case BSIM4_MOD_WDVTP3: - value->rValue = model->BSIM4wdvtp3; + case BSIM4v7_MOD_WDVTP3: + value->rValue = model->BSIM4v7wdvtp3; return(OK); - case BSIM4_MOD_WDVTP4: - value->rValue = model->BSIM4wdvtp4; + case BSIM4v7_MOD_WDVTP4: + value->rValue = model->BSIM4v7wdvtp4; return(OK); - case BSIM4_MOD_WDVTP5: - value->rValue = model->BSIM4wdvtp5; + case BSIM4v7_MOD_WDVTP5: + value->rValue = model->BSIM4v7wdvtp5; return(OK); - case BSIM4_MOD_WLPEB: - value->rValue = model->BSIM4wlpeb; + case BSIM4v7_MOD_WLPEB: + value->rValue = model->BSIM4v7wlpeb; return(OK); - case BSIM4_MOD_WDVT0: - value->rValue = model->BSIM4wdvt0; + case BSIM4v7_MOD_WDVT0: + value->rValue = model->BSIM4v7wdvt0; return(OK); - case BSIM4_MOD_WDVT1 : - value->rValue = model->BSIM4wdvt1; + case BSIM4v7_MOD_WDVT1 : + value->rValue = model->BSIM4v7wdvt1; return(OK); - case BSIM4_MOD_WDVT2 : - value->rValue = model->BSIM4wdvt2; + case BSIM4v7_MOD_WDVT2 : + value->rValue = model->BSIM4v7wdvt2; return(OK); - case BSIM4_MOD_WDVT0W : - value->rValue = model->BSIM4wdvt0w; + case BSIM4v7_MOD_WDVT0W : + value->rValue = model->BSIM4v7wdvt0w; return(OK); - case BSIM4_MOD_WDVT1W : - value->rValue = model->BSIM4wdvt1w; + case BSIM4v7_MOD_WDVT1W : + value->rValue = model->BSIM4v7wdvt1w; return(OK); - case BSIM4_MOD_WDVT2W : - value->rValue = model->BSIM4wdvt2w; + case BSIM4v7_MOD_WDVT2W : + value->rValue = model->BSIM4v7wdvt2w; return(OK); - case BSIM4_MOD_WDROUT : - value->rValue = model->BSIM4wdrout; + case BSIM4v7_MOD_WDROUT : + value->rValue = model->BSIM4v7wdrout; return(OK); - case BSIM4_MOD_WDSUB : - value->rValue = model->BSIM4wdsub; + case BSIM4v7_MOD_WDSUB : + value->rValue = model->BSIM4v7wdsub; return(OK); - case BSIM4_MOD_WVTH0: - value->rValue = model->BSIM4wvth0; + case BSIM4v7_MOD_WVTH0: + value->rValue = model->BSIM4v7wvth0; return(OK); - case BSIM4_MOD_WUA: - value->rValue = model->BSIM4wua; + case BSIM4v7_MOD_WUA: + value->rValue = model->BSIM4v7wua; return(OK); - case BSIM4_MOD_WUA1: - value->rValue = model->BSIM4wua1; + case BSIM4v7_MOD_WUA1: + value->rValue = model->BSIM4v7wua1; return(OK); - case BSIM4_MOD_WUB: - value->rValue = model->BSIM4wub; + case BSIM4v7_MOD_WUB: + value->rValue = model->BSIM4v7wub; return(OK); - case BSIM4_MOD_WUB1: - value->rValue = model->BSIM4wub1; + case BSIM4v7_MOD_WUB1: + value->rValue = model->BSIM4v7wub1; return(OK); - case BSIM4_MOD_WUC: - value->rValue = model->BSIM4wuc; + case BSIM4v7_MOD_WUC: + value->rValue = model->BSIM4v7wuc; return(OK); - case BSIM4_MOD_WUC1: - value->rValue = model->BSIM4wuc1; + case BSIM4v7_MOD_WUC1: + value->rValue = model->BSIM4v7wuc1; return(OK); - case BSIM4_MOD_WUD: - value->rValue = model->BSIM4wud; + case BSIM4v7_MOD_WUD: + value->rValue = model->BSIM4v7wud; return(OK); - case BSIM4_MOD_WUD1: - value->rValue = model->BSIM4wud1; + case BSIM4v7_MOD_WUD1: + value->rValue = model->BSIM4v7wud1; return(OK); - case BSIM4_MOD_WUP: - value->rValue = model->BSIM4wup; + case BSIM4v7_MOD_WUP: + value->rValue = model->BSIM4v7wup; return(OK); - case BSIM4_MOD_WLP: - value->rValue = model->BSIM4wlp; + case BSIM4v7_MOD_WLP: + value->rValue = model->BSIM4v7wlp; return(OK); - case BSIM4_MOD_WU0: - value->rValue = model->BSIM4wu0; + case BSIM4v7_MOD_WU0: + value->rValue = model->BSIM4v7wu0; return(OK); - case BSIM4_MOD_WUTE: - value->rValue = model->BSIM4wute; + case BSIM4v7_MOD_WUTE: + value->rValue = model->BSIM4v7wute; return(OK); - case BSIM4_MOD_WUCSTE: - value->rValue = model->BSIM4wucste; + case BSIM4v7_MOD_WUCSTE: + value->rValue = model->BSIM4v7wucste; return(OK); - case BSIM4_MOD_WVOFF: - value->rValue = model->BSIM4wvoff; + case BSIM4v7_MOD_WVOFF: + value->rValue = model->BSIM4v7wvoff; return(OK); - case BSIM4_MOD_WTVOFF: - value->rValue = model->BSIM4wtvoff; + case BSIM4v7_MOD_WTVOFF: + value->rValue = model->BSIM4v7wtvoff; return(OK); - case BSIM4_MOD_WTNFACTOR: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4wtnfactor; + case BSIM4v7_MOD_WTNFACTOR: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7wtnfactor; return(OK); - case BSIM4_MOD_WTETA0: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4wteta0; + case BSIM4v7_MOD_WTETA0: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7wteta0; return(OK); - case BSIM4_MOD_WTVOFFCV: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4wtvoffcv; + case BSIM4v7_MOD_WTVOFFCV: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7wtvoffcv; return(OK); - case BSIM4_MOD_WMINV: - value->rValue = model->BSIM4wminv; + case BSIM4v7_MOD_WMINV: + value->rValue = model->BSIM4v7wminv; return(OK); - case BSIM4_MOD_WMINVCV: - value->rValue = model->BSIM4wminvcv; + case BSIM4v7_MOD_WMINVCV: + value->rValue = model->BSIM4v7wminvcv; return(OK); - case BSIM4_MOD_WFPROUT: - value->rValue = model->BSIM4wfprout; + case BSIM4v7_MOD_WFPROUT: + value->rValue = model->BSIM4v7wfprout; return(OK); - case BSIM4_MOD_WPDITS: - value->rValue = model->BSIM4wpdits; + case BSIM4v7_MOD_WPDITS: + value->rValue = model->BSIM4v7wpdits; return(OK); - case BSIM4_MOD_WPDITSD: - value->rValue = model->BSIM4wpditsd; + case BSIM4v7_MOD_WPDITSD: + value->rValue = model->BSIM4v7wpditsd; return(OK); - case BSIM4_MOD_WDELTA: - value->rValue = model->BSIM4wdelta; + case BSIM4v7_MOD_WDELTA: + value->rValue = model->BSIM4v7wdelta; return(OK); - case BSIM4_MOD_WRDSW: - value->rValue = model->BSIM4wrdsw; + case BSIM4v7_MOD_WRDSW: + value->rValue = model->BSIM4v7wrdsw; return(OK); - case BSIM4_MOD_WRDW: - value->rValue = model->BSIM4wrdw; + case BSIM4v7_MOD_WRDW: + value->rValue = model->BSIM4v7wrdw; return(OK); - case BSIM4_MOD_WRSW: - value->rValue = model->BSIM4wrsw; + case BSIM4v7_MOD_WRSW: + value->rValue = model->BSIM4v7wrsw; return(OK); - case BSIM4_MOD_WPRWB: - value->rValue = model->BSIM4wprwb; + case BSIM4v7_MOD_WPRWB: + value->rValue = model->BSIM4v7wprwb; return(OK); - case BSIM4_MOD_WPRWG: - value->rValue = model->BSIM4wprwg; + case BSIM4v7_MOD_WPRWG: + value->rValue = model->BSIM4v7wprwg; return(OK); - case BSIM4_MOD_WPRT: - value->rValue = model->BSIM4wprt; + case BSIM4v7_MOD_WPRT: + value->rValue = model->BSIM4v7wprt; return(OK); - case BSIM4_MOD_WETA0: - value->rValue = model->BSIM4weta0; + case BSIM4v7_MOD_WETA0: + value->rValue = model->BSIM4v7weta0; return(OK); - case BSIM4_MOD_WETAB: - value->rValue = model->BSIM4wetab; + case BSIM4v7_MOD_WETAB: + value->rValue = model->BSIM4v7wetab; return(OK); - case BSIM4_MOD_WPCLM: - value->rValue = model->BSIM4wpclm; + case BSIM4v7_MOD_WPCLM: + value->rValue = model->BSIM4v7wpclm; return(OK); - case BSIM4_MOD_WPDIBL1: - value->rValue = model->BSIM4wpdibl1; + case BSIM4v7_MOD_WPDIBL1: + value->rValue = model->BSIM4v7wpdibl1; return(OK); - case BSIM4_MOD_WPDIBL2: - value->rValue = model->BSIM4wpdibl2; + case BSIM4v7_MOD_WPDIBL2: + value->rValue = model->BSIM4v7wpdibl2; return(OK); - case BSIM4_MOD_WPDIBLB: - value->rValue = model->BSIM4wpdiblb; + case BSIM4v7_MOD_WPDIBLB: + value->rValue = model->BSIM4v7wpdiblb; return(OK); - case BSIM4_MOD_WPSCBE1: - value->rValue = model->BSIM4wpscbe1; + case BSIM4v7_MOD_WPSCBE1: + value->rValue = model->BSIM4v7wpscbe1; return(OK); - case BSIM4_MOD_WPSCBE2: - value->rValue = model->BSIM4wpscbe2; + case BSIM4v7_MOD_WPSCBE2: + value->rValue = model->BSIM4v7wpscbe2; return(OK); - case BSIM4_MOD_WPVAG: - value->rValue = model->BSIM4wpvag; + case BSIM4v7_MOD_WPVAG: + value->rValue = model->BSIM4v7wpvag; return(OK); - case BSIM4_MOD_WWR: - value->rValue = model->BSIM4wwr; + case BSIM4v7_MOD_WWR: + value->rValue = model->BSIM4v7wwr; return(OK); - case BSIM4_MOD_WDWG: - value->rValue = model->BSIM4wdwg; + case BSIM4v7_MOD_WDWG: + value->rValue = model->BSIM4v7wdwg; return(OK); - case BSIM4_MOD_WDWB: - value->rValue = model->BSIM4wdwb; + case BSIM4v7_MOD_WDWB: + value->rValue = model->BSIM4v7wdwb; return(OK); - case BSIM4_MOD_WB0: - value->rValue = model->BSIM4wb0; + case BSIM4v7_MOD_WB0: + value->rValue = model->BSIM4v7wb0; return(OK); - case BSIM4_MOD_WB1: - value->rValue = model->BSIM4wb1; + case BSIM4v7_MOD_WB1: + value->rValue = model->BSIM4v7wb1; return(OK); - case BSIM4_MOD_WALPHA0: - value->rValue = model->BSIM4walpha0; + case BSIM4v7_MOD_WALPHA0: + value->rValue = model->BSIM4v7walpha0; return(OK); - case BSIM4_MOD_WALPHA1: - value->rValue = model->BSIM4walpha1; + case BSIM4v7_MOD_WALPHA1: + value->rValue = model->BSIM4v7walpha1; return(OK); - case BSIM4_MOD_WBETA0: - value->rValue = model->BSIM4wbeta0; + case BSIM4v7_MOD_WBETA0: + value->rValue = model->BSIM4v7wbeta0; return(OK); - case BSIM4_MOD_WAGIDL: - value->rValue = model->BSIM4wagidl; + case BSIM4v7_MOD_WAGIDL: + value->rValue = model->BSIM4v7wagidl; return(OK); - case BSIM4_MOD_WBGIDL: - value->rValue = model->BSIM4wbgidl; + case BSIM4v7_MOD_WBGIDL: + value->rValue = model->BSIM4v7wbgidl; return(OK); - case BSIM4_MOD_WCGIDL: - value->rValue = model->BSIM4wcgidl; + case BSIM4v7_MOD_WCGIDL: + value->rValue = model->BSIM4v7wcgidl; return(OK); - case BSIM4_MOD_WEGIDL: - value->rValue = model->BSIM4wegidl; + case BSIM4v7_MOD_WEGIDL: + value->rValue = model->BSIM4v7wegidl; return(OK); - case BSIM4_MOD_WFGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4wfgidl; + case BSIM4v7_MOD_WFGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7wfgidl; return(OK); - case BSIM4_MOD_WKGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4wkgidl; + case BSIM4v7_MOD_WKGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7wkgidl; return(OK); - case BSIM4_MOD_WRGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4wrgidl; + case BSIM4v7_MOD_WRGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7wrgidl; return(OK); - case BSIM4_MOD_WAGISL: - value->rValue = model->BSIM4wagisl; + case BSIM4v7_MOD_WAGISL: + value->rValue = model->BSIM4v7wagisl; return(OK); - case BSIM4_MOD_WBGISL: - value->rValue = model->BSIM4wbgisl; + case BSIM4v7_MOD_WBGISL: + value->rValue = model->BSIM4v7wbgisl; return(OK); - case BSIM4_MOD_WCGISL: - value->rValue = model->BSIM4wcgisl; + case BSIM4v7_MOD_WCGISL: + value->rValue = model->BSIM4v7wcgisl; return(OK); - case BSIM4_MOD_WEGISL: - value->rValue = model->BSIM4wegisl; + case BSIM4v7_MOD_WEGISL: + value->rValue = model->BSIM4v7wegisl; return(OK); - case BSIM4_MOD_WFGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4wfgisl; + case BSIM4v7_MOD_WFGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7wfgisl; return(OK); - case BSIM4_MOD_WKGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4wkgisl; + case BSIM4v7_MOD_WKGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7wkgisl; return(OK); - case BSIM4_MOD_WRGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4wrgisl; + case BSIM4v7_MOD_WRGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7wrgisl; return(OK); - case BSIM4_MOD_WAIGC: - value->rValue = model->BSIM4waigc; + case BSIM4v7_MOD_WAIGC: + value->rValue = model->BSIM4v7waigc; return(OK); - case BSIM4_MOD_WBIGC: - value->rValue = model->BSIM4wbigc; + case BSIM4v7_MOD_WBIGC: + value->rValue = model->BSIM4v7wbigc; return(OK); - case BSIM4_MOD_WCIGC: - value->rValue = model->BSIM4wcigc; + case BSIM4v7_MOD_WCIGC: + value->rValue = model->BSIM4v7wcigc; return(OK); - case BSIM4_MOD_WAIGSD: - value->rValue = model->BSIM4waigsd; + case BSIM4v7_MOD_WAIGSD: + value->rValue = model->BSIM4v7waigsd; return(OK); - case BSIM4_MOD_WBIGSD: - value->rValue = model->BSIM4wbigsd; + case BSIM4v7_MOD_WBIGSD: + value->rValue = model->BSIM4v7wbigsd; return(OK); - case BSIM4_MOD_WCIGSD: - value->rValue = model->BSIM4wcigsd; + case BSIM4v7_MOD_WCIGSD: + value->rValue = model->BSIM4v7wcigsd; return(OK); - case BSIM4_MOD_WAIGS: - value->rValue = model->BSIM4waigs; + case BSIM4v7_MOD_WAIGS: + value->rValue = model->BSIM4v7waigs; return(OK); - case BSIM4_MOD_WBIGS: - value->rValue = model->BSIM4wbigs; + case BSIM4v7_MOD_WBIGS: + value->rValue = model->BSIM4v7wbigs; return(OK); - case BSIM4_MOD_WCIGS: - value->rValue = model->BSIM4wcigs; + case BSIM4v7_MOD_WCIGS: + value->rValue = model->BSIM4v7wcigs; return(OK); - case BSIM4_MOD_WAIGD: - value->rValue = model->BSIM4waigd; + case BSIM4v7_MOD_WAIGD: + value->rValue = model->BSIM4v7waigd; return(OK); - case BSIM4_MOD_WBIGD: - value->rValue = model->BSIM4wbigd; + case BSIM4v7_MOD_WBIGD: + value->rValue = model->BSIM4v7wbigd; return(OK); - case BSIM4_MOD_WCIGD: - value->rValue = model->BSIM4wcigd; + case BSIM4v7_MOD_WCIGD: + value->rValue = model->BSIM4v7wcigd; return(OK); - case BSIM4_MOD_WAIGBACC: - value->rValue = model->BSIM4waigbacc; + case BSIM4v7_MOD_WAIGBACC: + value->rValue = model->BSIM4v7waigbacc; return(OK); - case BSIM4_MOD_WBIGBACC: - value->rValue = model->BSIM4wbigbacc; + case BSIM4v7_MOD_WBIGBACC: + value->rValue = model->BSIM4v7wbigbacc; return(OK); - case BSIM4_MOD_WCIGBACC: - value->rValue = model->BSIM4wcigbacc; + case BSIM4v7_MOD_WCIGBACC: + value->rValue = model->BSIM4v7wcigbacc; return(OK); - case BSIM4_MOD_WAIGBINV: - value->rValue = model->BSIM4waigbinv; + case BSIM4v7_MOD_WAIGBINV: + value->rValue = model->BSIM4v7waigbinv; return(OK); - case BSIM4_MOD_WBIGBINV: - value->rValue = model->BSIM4wbigbinv; + case BSIM4v7_MOD_WBIGBINV: + value->rValue = model->BSIM4v7wbigbinv; return(OK); - case BSIM4_MOD_WCIGBINV: - value->rValue = model->BSIM4wcigbinv; + case BSIM4v7_MOD_WCIGBINV: + value->rValue = model->BSIM4v7wcigbinv; return(OK); - case BSIM4_MOD_WNIGC: - value->rValue = model->BSIM4wnigc; + case BSIM4v7_MOD_WNIGC: + value->rValue = model->BSIM4v7wnigc; return(OK); - case BSIM4_MOD_WNIGBACC: - value->rValue = model->BSIM4wnigbacc; + case BSIM4v7_MOD_WNIGBACC: + value->rValue = model->BSIM4v7wnigbacc; return(OK); - case BSIM4_MOD_WNIGBINV: - value->rValue = model->BSIM4wnigbinv; + case BSIM4v7_MOD_WNIGBINV: + value->rValue = model->BSIM4v7wnigbinv; return(OK); - case BSIM4_MOD_WNTOX: - value->rValue = model->BSIM4wntox; + case BSIM4v7_MOD_WNTOX: + value->rValue = model->BSIM4v7wntox; return(OK); - case BSIM4_MOD_WEIGBINV: - value->rValue = model->BSIM4weigbinv; + case BSIM4v7_MOD_WEIGBINV: + value->rValue = model->BSIM4v7weigbinv; return(OK); - case BSIM4_MOD_WPIGCD: - value->rValue = model->BSIM4wpigcd; + case BSIM4v7_MOD_WPIGCD: + value->rValue = model->BSIM4v7wpigcd; return(OK); - case BSIM4_MOD_WPOXEDGE: - value->rValue = model->BSIM4wpoxedge; + case BSIM4v7_MOD_WPOXEDGE: + value->rValue = model->BSIM4v7wpoxedge; return(OK); - case BSIM4_MOD_WPHIN: - value->rValue = model->BSIM4wphin; + case BSIM4v7_MOD_WPHIN: + value->rValue = model->BSIM4v7wphin; return(OK); - case BSIM4_MOD_WXRCRG1: - value->rValue = model->BSIM4wxrcrg1; + case BSIM4v7_MOD_WXRCRG1: + value->rValue = model->BSIM4v7wxrcrg1; return(OK); - case BSIM4_MOD_WXRCRG2: - value->rValue = model->BSIM4wxrcrg2; + case BSIM4v7_MOD_WXRCRG2: + value->rValue = model->BSIM4v7wxrcrg2; return(OK); - case BSIM4_MOD_WEU: - value->rValue = model->BSIM4weu; + case BSIM4v7_MOD_WEU: + value->rValue = model->BSIM4v7weu; return(OK); - case BSIM4_MOD_WUCS: - value->rValue = model->BSIM4wucs; + case BSIM4v7_MOD_WUCS: + value->rValue = model->BSIM4v7wucs; return(OK); - case BSIM4_MOD_WVFB: - value->rValue = model->BSIM4wvfb; + case BSIM4v7_MOD_WVFB: + value->rValue = model->BSIM4v7wvfb; return(OK); - case BSIM4_MOD_WCGSL: - value->rValue = model->BSIM4wcgsl; + case BSIM4v7_MOD_WCGSL: + value->rValue = model->BSIM4v7wcgsl; return(OK); - case BSIM4_MOD_WCGDL: - value->rValue = model->BSIM4wcgdl; + case BSIM4v7_MOD_WCGDL: + value->rValue = model->BSIM4v7wcgdl; return(OK); - case BSIM4_MOD_WCKAPPAS: - value->rValue = model->BSIM4wckappas; + case BSIM4v7_MOD_WCKAPPAS: + value->rValue = model->BSIM4v7wckappas; return(OK); - case BSIM4_MOD_WCKAPPAD: - value->rValue = model->BSIM4wckappad; + case BSIM4v7_MOD_WCKAPPAD: + value->rValue = model->BSIM4v7wckappad; return(OK); - case BSIM4_MOD_WCF: - value->rValue = model->BSIM4wcf; + case BSIM4v7_MOD_WCF: + value->rValue = model->BSIM4v7wcf; return(OK); - case BSIM4_MOD_WCLC: - value->rValue = model->BSIM4wclc; + case BSIM4v7_MOD_WCLC: + value->rValue = model->BSIM4v7wclc; return(OK); - case BSIM4_MOD_WCLE: - value->rValue = model->BSIM4wcle; + case BSIM4v7_MOD_WCLE: + value->rValue = model->BSIM4v7wcle; return(OK); - case BSIM4_MOD_WVFBCV: - value->rValue = model->BSIM4wvfbcv; + case BSIM4v7_MOD_WVFBCV: + value->rValue = model->BSIM4v7wvfbcv; return(OK); - case BSIM4_MOD_WACDE: - value->rValue = model->BSIM4wacde; + case BSIM4v7_MOD_WACDE: + value->rValue = model->BSIM4v7wacde; return(OK); - case BSIM4_MOD_WMOIN: - value->rValue = model->BSIM4wmoin; + case BSIM4v7_MOD_WMOIN: + value->rValue = model->BSIM4v7wmoin; return(OK); - case BSIM4_MOD_WNOFF: - value->rValue = model->BSIM4wnoff; + case BSIM4v7_MOD_WNOFF: + value->rValue = model->BSIM4v7wnoff; return(OK); - case BSIM4_MOD_WVOFFCV: - value->rValue = model->BSIM4wvoffcv; + case BSIM4v7_MOD_WVOFFCV: + value->rValue = model->BSIM4v7wvoffcv; return(OK); - case BSIM4_MOD_WVFBSDOFF: - value->rValue = model->BSIM4wvfbsdoff; + case BSIM4v7_MOD_WVFBSDOFF: + value->rValue = model->BSIM4v7wvfbsdoff; return(OK); - case BSIM4_MOD_WTVFBSDOFF: - value->rValue = model->BSIM4wtvfbsdoff; + case BSIM4v7_MOD_WTVFBSDOFF: + value->rValue = model->BSIM4v7wtvfbsdoff; return(OK); - case BSIM4_MOD_WLAMBDA: - value->rValue = model->BSIM4wlambda; + case BSIM4v7_MOD_WLAMBDA: + value->rValue = model->BSIM4v7wlambda; return(OK); - case BSIM4_MOD_WVTL: - value->rValue = model->BSIM4wvtl; + case BSIM4v7_MOD_WVTL: + value->rValue = model->BSIM4v7wvtl; return(OK); - case BSIM4_MOD_WXN: - value->rValue = model->BSIM4wxn; + case BSIM4v7_MOD_WXN: + value->rValue = model->BSIM4v7wxn; return(OK); /* Cross-term dependence */ - case BSIM4_MOD_PCDSC : - value->rValue = model->BSIM4pcdsc; + case BSIM4v7_MOD_PCDSC : + value->rValue = model->BSIM4v7pcdsc; return(OK); - case BSIM4_MOD_PCDSCB : - value->rValue = model->BSIM4pcdscb; + case BSIM4v7_MOD_PCDSCB : + value->rValue = model->BSIM4v7pcdscb; return(OK); - case BSIM4_MOD_PCDSCD : - value->rValue = model->BSIM4pcdscd; + case BSIM4v7_MOD_PCDSCD : + value->rValue = model->BSIM4v7pcdscd; return(OK); - case BSIM4_MOD_PCIT : - value->rValue = model->BSIM4pcit; + case BSIM4v7_MOD_PCIT : + value->rValue = model->BSIM4v7pcit; return(OK); - case BSIM4_MOD_PNFACTOR : - value->rValue = model->BSIM4pnfactor; + case BSIM4v7_MOD_PNFACTOR : + value->rValue = model->BSIM4v7pnfactor; return(OK); - case BSIM4_MOD_PXJ: - value->rValue = model->BSIM4pxj; + case BSIM4v7_MOD_PXJ: + value->rValue = model->BSIM4v7pxj; return(OK); - case BSIM4_MOD_PVSAT: - value->rValue = model->BSIM4pvsat; + case BSIM4v7_MOD_PVSAT: + value->rValue = model->BSIM4v7pvsat; return(OK); - case BSIM4_MOD_PAT: - value->rValue = model->BSIM4pat; + case BSIM4v7_MOD_PAT: + value->rValue = model->BSIM4v7pat; return(OK); - case BSIM4_MOD_PA0: - value->rValue = model->BSIM4pa0; + case BSIM4v7_MOD_PA0: + value->rValue = model->BSIM4v7pa0; return(OK); - case BSIM4_MOD_PAGS: - value->rValue = model->BSIM4pags; + case BSIM4v7_MOD_PAGS: + value->rValue = model->BSIM4v7pags; return(OK); - case BSIM4_MOD_PA1: - value->rValue = model->BSIM4pa1; + case BSIM4v7_MOD_PA1: + value->rValue = model->BSIM4v7pa1; return(OK); - case BSIM4_MOD_PA2: - value->rValue = model->BSIM4pa2; + case BSIM4v7_MOD_PA2: + value->rValue = model->BSIM4v7pa2; return(OK); - case BSIM4_MOD_PKETA: - value->rValue = model->BSIM4pketa; + case BSIM4v7_MOD_PKETA: + value->rValue = model->BSIM4v7pketa; return(OK); - case BSIM4_MOD_PNSUB: - value->rValue = model->BSIM4pnsub; + case BSIM4v7_MOD_PNSUB: + value->rValue = model->BSIM4v7pnsub; return(OK); - case BSIM4_MOD_PNDEP: - value->rValue = model->BSIM4pndep; + case BSIM4v7_MOD_PNDEP: + value->rValue = model->BSIM4v7pndep; return(OK); - case BSIM4_MOD_PNSD: - value->rValue = model->BSIM4pnsd; + case BSIM4v7_MOD_PNSD: + value->rValue = model->BSIM4v7pnsd; return(OK); - case BSIM4_MOD_PNGATE: - value->rValue = model->BSIM4pngate; + case BSIM4v7_MOD_PNGATE: + value->rValue = model->BSIM4v7pngate; return(OK); - case BSIM4_MOD_PGAMMA1: - value->rValue = model->BSIM4pgamma1; + case BSIM4v7_MOD_PGAMMA1: + value->rValue = model->BSIM4v7pgamma1; return(OK); - case BSIM4_MOD_PGAMMA2: - value->rValue = model->BSIM4pgamma2; + case BSIM4v7_MOD_PGAMMA2: + value->rValue = model->BSIM4v7pgamma2; return(OK); - case BSIM4_MOD_PVBX: - value->rValue = model->BSIM4pvbx; + case BSIM4v7_MOD_PVBX: + value->rValue = model->BSIM4v7pvbx; return(OK); - case BSIM4_MOD_PVBM: - value->rValue = model->BSIM4pvbm; + case BSIM4v7_MOD_PVBM: + value->rValue = model->BSIM4v7pvbm; return(OK); - case BSIM4_MOD_PXT: - value->rValue = model->BSIM4pxt; + case BSIM4v7_MOD_PXT: + value->rValue = model->BSIM4v7pxt; return(OK); - case BSIM4_MOD_PK1: - value->rValue = model->BSIM4pk1; + case BSIM4v7_MOD_PK1: + value->rValue = model->BSIM4v7pk1; return(OK); - case BSIM4_MOD_PKT1: - value->rValue = model->BSIM4pkt1; + case BSIM4v7_MOD_PKT1: + value->rValue = model->BSIM4v7pkt1; return(OK); - case BSIM4_MOD_PKT1L: - value->rValue = model->BSIM4pkt1l; + case BSIM4v7_MOD_PKT1L: + value->rValue = model->BSIM4v7pkt1l; return(OK); - case BSIM4_MOD_PKT2 : - value->rValue = model->BSIM4pkt2; + case BSIM4v7_MOD_PKT2 : + value->rValue = model->BSIM4v7pkt2; return(OK); - case BSIM4_MOD_PK2 : - value->rValue = model->BSIM4pk2; + case BSIM4v7_MOD_PK2 : + value->rValue = model->BSIM4v7pk2; return(OK); - case BSIM4_MOD_PK3: - value->rValue = model->BSIM4pk3; + case BSIM4v7_MOD_PK3: + value->rValue = model->BSIM4v7pk3; return(OK); - case BSIM4_MOD_PK3B: - value->rValue = model->BSIM4pk3b; + case BSIM4v7_MOD_PK3B: + value->rValue = model->BSIM4v7pk3b; return(OK); - case BSIM4_MOD_PW0: - value->rValue = model->BSIM4pw0; + case BSIM4v7_MOD_PW0: + value->rValue = model->BSIM4v7pw0; return(OK); - case BSIM4_MOD_PLPE0: - value->rValue = model->BSIM4plpe0; + case BSIM4v7_MOD_PLPE0: + value->rValue = model->BSIM4v7plpe0; return(OK); - case BSIM4_MOD_PLPEB: - value->rValue = model->BSIM4plpeb; + case BSIM4v7_MOD_PLPEB: + value->rValue = model->BSIM4v7plpeb; return(OK); - case BSIM4_MOD_PDVTP0: - value->rValue = model->BSIM4pdvtp0; + case BSIM4v7_MOD_PDVTP0: + value->rValue = model->BSIM4v7pdvtp0; return(OK); - case BSIM4_MOD_PDVTP1: - value->rValue = model->BSIM4pdvtp1; + case BSIM4v7_MOD_PDVTP1: + value->rValue = model->BSIM4v7pdvtp1; return(OK); - case BSIM4_MOD_PDVTP2: - value->rValue = model->BSIM4pdvtp2; /* New DIBL/Rout */ + case BSIM4v7_MOD_PDVTP2: + value->rValue = model->BSIM4v7pdvtp2; /* New DIBL/Rout */ return(OK); - case BSIM4_MOD_PDVTP3: - value->rValue = model->BSIM4pdvtp3; + case BSIM4v7_MOD_PDVTP3: + value->rValue = model->BSIM4v7pdvtp3; return(OK); - case BSIM4_MOD_PDVTP4: - value->rValue = model->BSIM4pdvtp4; + case BSIM4v7_MOD_PDVTP4: + value->rValue = model->BSIM4v7pdvtp4; return(OK); - case BSIM4_MOD_PDVTP5: - value->rValue = model->BSIM4pdvtp5; + case BSIM4v7_MOD_PDVTP5: + value->rValue = model->BSIM4v7pdvtp5; return(OK); - case BSIM4_MOD_PDVT0 : - value->rValue = model->BSIM4pdvt0; + case BSIM4v7_MOD_PDVT0 : + value->rValue = model->BSIM4v7pdvt0; return(OK); - case BSIM4_MOD_PDVT1 : - value->rValue = model->BSIM4pdvt1; + case BSIM4v7_MOD_PDVT1 : + value->rValue = model->BSIM4v7pdvt1; return(OK); - case BSIM4_MOD_PDVT2 : - value->rValue = model->BSIM4pdvt2; + case BSIM4v7_MOD_PDVT2 : + value->rValue = model->BSIM4v7pdvt2; return(OK); - case BSIM4_MOD_PDVT0W : - value->rValue = model->BSIM4pdvt0w; + case BSIM4v7_MOD_PDVT0W : + value->rValue = model->BSIM4v7pdvt0w; return(OK); - case BSIM4_MOD_PDVT1W : - value->rValue = model->BSIM4pdvt1w; + case BSIM4v7_MOD_PDVT1W : + value->rValue = model->BSIM4v7pdvt1w; return(OK); - case BSIM4_MOD_PDVT2W : - value->rValue = model->BSIM4pdvt2w; + case BSIM4v7_MOD_PDVT2W : + value->rValue = model->BSIM4v7pdvt2w; return(OK); - case BSIM4_MOD_PDROUT : - value->rValue = model->BSIM4pdrout; + case BSIM4v7_MOD_PDROUT : + value->rValue = model->BSIM4v7pdrout; return(OK); - case BSIM4_MOD_PDSUB : - value->rValue = model->BSIM4pdsub; + case BSIM4v7_MOD_PDSUB : + value->rValue = model->BSIM4v7pdsub; return(OK); - case BSIM4_MOD_PVTH0: - value->rValue = model->BSIM4pvth0; + case BSIM4v7_MOD_PVTH0: + value->rValue = model->BSIM4v7pvth0; return(OK); - case BSIM4_MOD_PUA: - value->rValue = model->BSIM4pua; + case BSIM4v7_MOD_PUA: + value->rValue = model->BSIM4v7pua; return(OK); - case BSIM4_MOD_PUA1: - value->rValue = model->BSIM4pua1; + case BSIM4v7_MOD_PUA1: + value->rValue = model->BSIM4v7pua1; return(OK); - case BSIM4_MOD_PUB: - value->rValue = model->BSIM4pub; + case BSIM4v7_MOD_PUB: + value->rValue = model->BSIM4v7pub; return(OK); - case BSIM4_MOD_PUB1: - value->rValue = model->BSIM4pub1; + case BSIM4v7_MOD_PUB1: + value->rValue = model->BSIM4v7pub1; return(OK); - case BSIM4_MOD_PUC: - value->rValue = model->BSIM4puc; + case BSIM4v7_MOD_PUC: + value->rValue = model->BSIM4v7puc; return(OK); - case BSIM4_MOD_PUC1: - value->rValue = model->BSIM4puc1; + case BSIM4v7_MOD_PUC1: + value->rValue = model->BSIM4v7puc1; return(OK); - case BSIM4_MOD_PUD: - value->rValue = model->BSIM4pud; + case BSIM4v7_MOD_PUD: + value->rValue = model->BSIM4v7pud; return(OK); - case BSIM4_MOD_PUD1: - value->rValue = model->BSIM4pud1; + case BSIM4v7_MOD_PUD1: + value->rValue = model->BSIM4v7pud1; return(OK); - case BSIM4_MOD_PUP: - value->rValue = model->BSIM4pup; + case BSIM4v7_MOD_PUP: + value->rValue = model->BSIM4v7pup; return(OK); - case BSIM4_MOD_PLP: - value->rValue = model->BSIM4plp; + case BSIM4v7_MOD_PLP: + value->rValue = model->BSIM4v7plp; return(OK); - case BSIM4_MOD_PU0: - value->rValue = model->BSIM4pu0; + case BSIM4v7_MOD_PU0: + value->rValue = model->BSIM4v7pu0; return(OK); - case BSIM4_MOD_PUTE: - value->rValue = model->BSIM4pute; + case BSIM4v7_MOD_PUTE: + value->rValue = model->BSIM4v7pute; return(OK); - case BSIM4_MOD_PUCSTE: - value->rValue = model->BSIM4pucste; + case BSIM4v7_MOD_PUCSTE: + value->rValue = model->BSIM4v7pucste; return(OK); - case BSIM4_MOD_PVOFF: - value->rValue = model->BSIM4pvoff; + case BSIM4v7_MOD_PVOFF: + value->rValue = model->BSIM4v7pvoff; return(OK); - case BSIM4_MOD_PTVOFF: - value->rValue = model->BSIM4ptvoff; + case BSIM4v7_MOD_PTVOFF: + value->rValue = model->BSIM4v7ptvoff; return(OK); - case BSIM4_MOD_PTNFACTOR: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4ptnfactor; + case BSIM4v7_MOD_PTNFACTOR: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7ptnfactor; return(OK); - case BSIM4_MOD_PTETA0: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4pteta0; + case BSIM4v7_MOD_PTETA0: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7pteta0; return(OK); - case BSIM4_MOD_PTVOFFCV: /* v4.7 temp dep of leakage current */ - value->rValue = model->BSIM4ptvoffcv; + case BSIM4v7_MOD_PTVOFFCV: /* v4.7 temp dep of leakage current */ + value->rValue = model->BSIM4v7ptvoffcv; return(OK); - case BSIM4_MOD_PMINV: - value->rValue = model->BSIM4pminv; + case BSIM4v7_MOD_PMINV: + value->rValue = model->BSIM4v7pminv; return(OK); - case BSIM4_MOD_PMINVCV: - value->rValue = model->BSIM4pminvcv; + case BSIM4v7_MOD_PMINVCV: + value->rValue = model->BSIM4v7pminvcv; return(OK); - case BSIM4_MOD_PFPROUT: - value->rValue = model->BSIM4pfprout; + case BSIM4v7_MOD_PFPROUT: + value->rValue = model->BSIM4v7pfprout; return(OK); - case BSIM4_MOD_PPDITS: - value->rValue = model->BSIM4ppdits; + case BSIM4v7_MOD_PPDITS: + value->rValue = model->BSIM4v7ppdits; return(OK); - case BSIM4_MOD_PPDITSD: - value->rValue = model->BSIM4ppditsd; + case BSIM4v7_MOD_PPDITSD: + value->rValue = model->BSIM4v7ppditsd; return(OK); - case BSIM4_MOD_PDELTA: - value->rValue = model->BSIM4pdelta; + case BSIM4v7_MOD_PDELTA: + value->rValue = model->BSIM4v7pdelta; return(OK); - case BSIM4_MOD_PRDSW: - value->rValue = model->BSIM4prdsw; + case BSIM4v7_MOD_PRDSW: + value->rValue = model->BSIM4v7prdsw; return(OK); - case BSIM4_MOD_PRDW: - value->rValue = model->BSIM4prdw; + case BSIM4v7_MOD_PRDW: + value->rValue = model->BSIM4v7prdw; return(OK); - case BSIM4_MOD_PRSW: - value->rValue = model->BSIM4prsw; + case BSIM4v7_MOD_PRSW: + value->rValue = model->BSIM4v7prsw; return(OK); - case BSIM4_MOD_PPRWB: - value->rValue = model->BSIM4pprwb; + case BSIM4v7_MOD_PPRWB: + value->rValue = model->BSIM4v7pprwb; return(OK); - case BSIM4_MOD_PPRWG: - value->rValue = model->BSIM4pprwg; + case BSIM4v7_MOD_PPRWG: + value->rValue = model->BSIM4v7pprwg; return(OK); - case BSIM4_MOD_PPRT: - value->rValue = model->BSIM4pprt; + case BSIM4v7_MOD_PPRT: + value->rValue = model->BSIM4v7pprt; return(OK); - case BSIM4_MOD_PETA0: - value->rValue = model->BSIM4peta0; + case BSIM4v7_MOD_PETA0: + value->rValue = model->BSIM4v7peta0; return(OK); - case BSIM4_MOD_PETAB: - value->rValue = model->BSIM4petab; + case BSIM4v7_MOD_PETAB: + value->rValue = model->BSIM4v7petab; return(OK); - case BSIM4_MOD_PPCLM: - value->rValue = model->BSIM4ppclm; + case BSIM4v7_MOD_PPCLM: + value->rValue = model->BSIM4v7ppclm; return(OK); - case BSIM4_MOD_PPDIBL1: - value->rValue = model->BSIM4ppdibl1; + case BSIM4v7_MOD_PPDIBL1: + value->rValue = model->BSIM4v7ppdibl1; return(OK); - case BSIM4_MOD_PPDIBL2: - value->rValue = model->BSIM4ppdibl2; + case BSIM4v7_MOD_PPDIBL2: + value->rValue = model->BSIM4v7ppdibl2; return(OK); - case BSIM4_MOD_PPDIBLB: - value->rValue = model->BSIM4ppdiblb; + case BSIM4v7_MOD_PPDIBLB: + value->rValue = model->BSIM4v7ppdiblb; return(OK); - case BSIM4_MOD_PPSCBE1: - value->rValue = model->BSIM4ppscbe1; + case BSIM4v7_MOD_PPSCBE1: + value->rValue = model->BSIM4v7ppscbe1; return(OK); - case BSIM4_MOD_PPSCBE2: - value->rValue = model->BSIM4ppscbe2; + case BSIM4v7_MOD_PPSCBE2: + value->rValue = model->BSIM4v7ppscbe2; return(OK); - case BSIM4_MOD_PPVAG: - value->rValue = model->BSIM4ppvag; + case BSIM4v7_MOD_PPVAG: + value->rValue = model->BSIM4v7ppvag; return(OK); - case BSIM4_MOD_PWR: - value->rValue = model->BSIM4pwr; + case BSIM4v7_MOD_PWR: + value->rValue = model->BSIM4v7pwr; return(OK); - case BSIM4_MOD_PDWG: - value->rValue = model->BSIM4pdwg; + case BSIM4v7_MOD_PDWG: + value->rValue = model->BSIM4v7pdwg; return(OK); - case BSIM4_MOD_PDWB: - value->rValue = model->BSIM4pdwb; + case BSIM4v7_MOD_PDWB: + value->rValue = model->BSIM4v7pdwb; return(OK); - case BSIM4_MOD_PB0: - value->rValue = model->BSIM4pb0; + case BSIM4v7_MOD_PB0: + value->rValue = model->BSIM4v7pb0; return(OK); - case BSIM4_MOD_PB1: - value->rValue = model->BSIM4pb1; + case BSIM4v7_MOD_PB1: + value->rValue = model->BSIM4v7pb1; return(OK); - case BSIM4_MOD_PALPHA0: - value->rValue = model->BSIM4palpha0; + case BSIM4v7_MOD_PALPHA0: + value->rValue = model->BSIM4v7palpha0; return(OK); - case BSIM4_MOD_PALPHA1: - value->rValue = model->BSIM4palpha1; + case BSIM4v7_MOD_PALPHA1: + value->rValue = model->BSIM4v7palpha1; return(OK); - case BSIM4_MOD_PBETA0: - value->rValue = model->BSIM4pbeta0; + case BSIM4v7_MOD_PBETA0: + value->rValue = model->BSIM4v7pbeta0; return(OK); - case BSIM4_MOD_PAGIDL: - value->rValue = model->BSIM4pagidl; + case BSIM4v7_MOD_PAGIDL: + value->rValue = model->BSIM4v7pagidl; return(OK); - case BSIM4_MOD_PBGIDL: - value->rValue = model->BSIM4pbgidl; + case BSIM4v7_MOD_PBGIDL: + value->rValue = model->BSIM4v7pbgidl; return(OK); - case BSIM4_MOD_PCGIDL: - value->rValue = model->BSIM4pcgidl; + case BSIM4v7_MOD_PCGIDL: + value->rValue = model->BSIM4v7pcgidl; return(OK); - case BSIM4_MOD_PEGIDL: - value->rValue = model->BSIM4pegidl; + case BSIM4v7_MOD_PEGIDL: + value->rValue = model->BSIM4v7pegidl; return(OK); - case BSIM4_MOD_PFGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4pfgidl; + case BSIM4v7_MOD_PFGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7pfgidl; return(OK); - case BSIM4_MOD_PKGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4pkgidl; + case BSIM4v7_MOD_PKGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7pkgidl; return(OK); - case BSIM4_MOD_PRGIDL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4prgidl; + case BSIM4v7_MOD_PRGIDL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7prgidl; return(OK); - case BSIM4_MOD_PAGISL: - value->rValue = model->BSIM4pagisl; + case BSIM4v7_MOD_PAGISL: + value->rValue = model->BSIM4v7pagisl; return(OK); - case BSIM4_MOD_PBGISL: - value->rValue = model->BSIM4pbgisl; + case BSIM4v7_MOD_PBGISL: + value->rValue = model->BSIM4v7pbgisl; return(OK); - case BSIM4_MOD_PCGISL: - value->rValue = model->BSIM4pcgisl; + case BSIM4v7_MOD_PCGISL: + value->rValue = model->BSIM4v7pcgisl; return(OK); - case BSIM4_MOD_PEGISL: - value->rValue = model->BSIM4pegisl; + case BSIM4v7_MOD_PEGISL: + value->rValue = model->BSIM4v7pegisl; return(OK); - case BSIM4_MOD_PFGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4pfgisl; + case BSIM4v7_MOD_PFGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7pfgisl; return(OK); - case BSIM4_MOD_PKGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4pkgisl; + case BSIM4v7_MOD_PKGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7pkgisl; return(OK); - case BSIM4_MOD_PRGISL: /* v4.7 New GIDL/GISL*/ - value->rValue = model->BSIM4prgisl; + case BSIM4v7_MOD_PRGISL: /* v4.7 New GIDL/GISL*/ + value->rValue = model->BSIM4v7prgisl; return(OK); - case BSIM4_MOD_PAIGC: - value->rValue = model->BSIM4paigc; + case BSIM4v7_MOD_PAIGC: + value->rValue = model->BSIM4v7paigc; return(OK); - case BSIM4_MOD_PBIGC: - value->rValue = model->BSIM4pbigc; + case BSIM4v7_MOD_PBIGC: + value->rValue = model->BSIM4v7pbigc; return(OK); - case BSIM4_MOD_PCIGC: - value->rValue = model->BSIM4pcigc; + case BSIM4v7_MOD_PCIGC: + value->rValue = model->BSIM4v7pcigc; return(OK); - case BSIM4_MOD_PAIGSD: - value->rValue = model->BSIM4paigsd; + case BSIM4v7_MOD_PAIGSD: + value->rValue = model->BSIM4v7paigsd; return(OK); - case BSIM4_MOD_PBIGSD: - value->rValue = model->BSIM4pbigsd; + case BSIM4v7_MOD_PBIGSD: + value->rValue = model->BSIM4v7pbigsd; return(OK); - case BSIM4_MOD_PCIGSD: - value->rValue = model->BSIM4pcigsd; + case BSIM4v7_MOD_PCIGSD: + value->rValue = model->BSIM4v7pcigsd; return(OK); - case BSIM4_MOD_PAIGS: - value->rValue = model->BSIM4paigs; + case BSIM4v7_MOD_PAIGS: + value->rValue = model->BSIM4v7paigs; return(OK); - case BSIM4_MOD_PBIGS: - value->rValue = model->BSIM4pbigs; + case BSIM4v7_MOD_PBIGS: + value->rValue = model->BSIM4v7pbigs; return(OK); - case BSIM4_MOD_PCIGS: - value->rValue = model->BSIM4pcigs; + case BSIM4v7_MOD_PCIGS: + value->rValue = model->BSIM4v7pcigs; return(OK); - case BSIM4_MOD_PAIGD: - value->rValue = model->BSIM4paigd; + case BSIM4v7_MOD_PAIGD: + value->rValue = model->BSIM4v7paigd; return(OK); - case BSIM4_MOD_PBIGD: - value->rValue = model->BSIM4pbigd; + case BSIM4v7_MOD_PBIGD: + value->rValue = model->BSIM4v7pbigd; return(OK); - case BSIM4_MOD_PCIGD: - value->rValue = model->BSIM4pcigd; + case BSIM4v7_MOD_PCIGD: + value->rValue = model->BSIM4v7pcigd; return(OK); - case BSIM4_MOD_PAIGBACC: - value->rValue = model->BSIM4paigbacc; + case BSIM4v7_MOD_PAIGBACC: + value->rValue = model->BSIM4v7paigbacc; return(OK); - case BSIM4_MOD_PBIGBACC: - value->rValue = model->BSIM4pbigbacc; + case BSIM4v7_MOD_PBIGBACC: + value->rValue = model->BSIM4v7pbigbacc; return(OK); - case BSIM4_MOD_PCIGBACC: - value->rValue = model->BSIM4pcigbacc; + case BSIM4v7_MOD_PCIGBACC: + value->rValue = model->BSIM4v7pcigbacc; return(OK); - case BSIM4_MOD_PAIGBINV: - value->rValue = model->BSIM4paigbinv; + case BSIM4v7_MOD_PAIGBINV: + value->rValue = model->BSIM4v7paigbinv; return(OK); - case BSIM4_MOD_PBIGBINV: - value->rValue = model->BSIM4pbigbinv; + case BSIM4v7_MOD_PBIGBINV: + value->rValue = model->BSIM4v7pbigbinv; return(OK); - case BSIM4_MOD_PCIGBINV: - value->rValue = model->BSIM4pcigbinv; + case BSIM4v7_MOD_PCIGBINV: + value->rValue = model->BSIM4v7pcigbinv; return(OK); - case BSIM4_MOD_PNIGC: - value->rValue = model->BSIM4pnigc; + case BSIM4v7_MOD_PNIGC: + value->rValue = model->BSIM4v7pnigc; return(OK); - case BSIM4_MOD_PNIGBACC: - value->rValue = model->BSIM4pnigbacc; + case BSIM4v7_MOD_PNIGBACC: + value->rValue = model->BSIM4v7pnigbacc; return(OK); - case BSIM4_MOD_PNIGBINV: - value->rValue = model->BSIM4pnigbinv; + case BSIM4v7_MOD_PNIGBINV: + value->rValue = model->BSIM4v7pnigbinv; return(OK); - case BSIM4_MOD_PNTOX: - value->rValue = model->BSIM4pntox; + case BSIM4v7_MOD_PNTOX: + value->rValue = model->BSIM4v7pntox; return(OK); - case BSIM4_MOD_PEIGBINV: - value->rValue = model->BSIM4peigbinv; + case BSIM4v7_MOD_PEIGBINV: + value->rValue = model->BSIM4v7peigbinv; return(OK); - case BSIM4_MOD_PPIGCD: - value->rValue = model->BSIM4ppigcd; + case BSIM4v7_MOD_PPIGCD: + value->rValue = model->BSIM4v7ppigcd; return(OK); - case BSIM4_MOD_PPOXEDGE: - value->rValue = model->BSIM4ppoxedge; + case BSIM4v7_MOD_PPOXEDGE: + value->rValue = model->BSIM4v7ppoxedge; return(OK); - case BSIM4_MOD_PPHIN: - value->rValue = model->BSIM4pphin; + case BSIM4v7_MOD_PPHIN: + value->rValue = model->BSIM4v7pphin; return(OK); - case BSIM4_MOD_PXRCRG1: - value->rValue = model->BSIM4pxrcrg1; + case BSIM4v7_MOD_PXRCRG1: + value->rValue = model->BSIM4v7pxrcrg1; return(OK); - case BSIM4_MOD_PXRCRG2: - value->rValue = model->BSIM4pxrcrg2; + case BSIM4v7_MOD_PXRCRG2: + value->rValue = model->BSIM4v7pxrcrg2; return(OK); - case BSIM4_MOD_PEU: - value->rValue = model->BSIM4peu; + case BSIM4v7_MOD_PEU: + value->rValue = model->BSIM4v7peu; return(OK); - case BSIM4_MOD_PUCS: - value->rValue = model->BSIM4pucs; + case BSIM4v7_MOD_PUCS: + value->rValue = model->BSIM4v7pucs; return(OK); - case BSIM4_MOD_PVFB: - value->rValue = model->BSIM4pvfb; + case BSIM4v7_MOD_PVFB: + value->rValue = model->BSIM4v7pvfb; return(OK); - case BSIM4_MOD_PCGSL: - value->rValue = model->BSIM4pcgsl; + case BSIM4v7_MOD_PCGSL: + value->rValue = model->BSIM4v7pcgsl; return(OK); - case BSIM4_MOD_PCGDL: - value->rValue = model->BSIM4pcgdl; + case BSIM4v7_MOD_PCGDL: + value->rValue = model->BSIM4v7pcgdl; return(OK); - case BSIM4_MOD_PCKAPPAS: - value->rValue = model->BSIM4pckappas; + case BSIM4v7_MOD_PCKAPPAS: + value->rValue = model->BSIM4v7pckappas; return(OK); - case BSIM4_MOD_PCKAPPAD: - value->rValue = model->BSIM4pckappad; + case BSIM4v7_MOD_PCKAPPAD: + value->rValue = model->BSIM4v7pckappad; return(OK); - case BSIM4_MOD_PCF: - value->rValue = model->BSIM4pcf; + case BSIM4v7_MOD_PCF: + value->rValue = model->BSIM4v7pcf; return(OK); - case BSIM4_MOD_PCLC: - value->rValue = model->BSIM4pclc; + case BSIM4v7_MOD_PCLC: + value->rValue = model->BSIM4v7pclc; return(OK); - case BSIM4_MOD_PCLE: - value->rValue = model->BSIM4pcle; + case BSIM4v7_MOD_PCLE: + value->rValue = model->BSIM4v7pcle; return(OK); - case BSIM4_MOD_PVFBCV: - value->rValue = model->BSIM4pvfbcv; + case BSIM4v7_MOD_PVFBCV: + value->rValue = model->BSIM4v7pvfbcv; return(OK); - case BSIM4_MOD_PACDE: - value->rValue = model->BSIM4pacde; + case BSIM4v7_MOD_PACDE: + value->rValue = model->BSIM4v7pacde; return(OK); - case BSIM4_MOD_PMOIN: - value->rValue = model->BSIM4pmoin; + case BSIM4v7_MOD_PMOIN: + value->rValue = model->BSIM4v7pmoin; return(OK); - case BSIM4_MOD_PNOFF: - value->rValue = model->BSIM4pnoff; + case BSIM4v7_MOD_PNOFF: + value->rValue = model->BSIM4v7pnoff; return(OK); - case BSIM4_MOD_PVOFFCV: - value->rValue = model->BSIM4pvoffcv; + case BSIM4v7_MOD_PVOFFCV: + value->rValue = model->BSIM4v7pvoffcv; return(OK); - case BSIM4_MOD_PVFBSDOFF: - value->rValue = model->BSIM4pvfbsdoff; + case BSIM4v7_MOD_PVFBSDOFF: + value->rValue = model->BSIM4v7pvfbsdoff; return(OK); - case BSIM4_MOD_PTVFBSDOFF: - value->rValue = model->BSIM4ptvfbsdoff; + case BSIM4v7_MOD_PTVFBSDOFF: + value->rValue = model->BSIM4v7ptvfbsdoff; return(OK); - case BSIM4_MOD_PLAMBDA: - value->rValue = model->BSIM4plambda; + case BSIM4v7_MOD_PLAMBDA: + value->rValue = model->BSIM4v7plambda; return(OK); - case BSIM4_MOD_PVTL: - value->rValue = model->BSIM4pvtl; + case BSIM4v7_MOD_PVTL: + value->rValue = model->BSIM4v7pvtl; return(OK); - case BSIM4_MOD_PXN: - value->rValue = model->BSIM4pxn; + case BSIM4v7_MOD_PXN: + value->rValue = model->BSIM4v7pxn; return(OK); - case BSIM4_MOD_TNOM : - value->rValue = model->BSIM4tnom; + case BSIM4v7_MOD_TNOM : + value->rValue = model->BSIM4v7tnom; return(OK); - case BSIM4_MOD_CGSO: - value->rValue = model->BSIM4cgso; + case BSIM4v7_MOD_CGSO: + value->rValue = model->BSIM4v7cgso; return(OK); - case BSIM4_MOD_CGDO: - value->rValue = model->BSIM4cgdo; + case BSIM4v7_MOD_CGDO: + value->rValue = model->BSIM4v7cgdo; return(OK); - case BSIM4_MOD_CGBO: - value->rValue = model->BSIM4cgbo; + case BSIM4v7_MOD_CGBO: + value->rValue = model->BSIM4v7cgbo; return(OK); - case BSIM4_MOD_XPART: - value->rValue = model->BSIM4xpart; + case BSIM4v7_MOD_XPART: + value->rValue = model->BSIM4v7xpart; return(OK); - case BSIM4_MOD_RSH: - value->rValue = model->BSIM4sheetResistance; + case BSIM4v7_MOD_RSH: + value->rValue = model->BSIM4v7sheetResistance; return(OK); - case BSIM4_MOD_JSS: - value->rValue = model->BSIM4SjctSatCurDensity; + case BSIM4v7_MOD_JSS: + value->rValue = model->BSIM4v7SjctSatCurDensity; return(OK); - case BSIM4_MOD_JSWS: - value->rValue = model->BSIM4SjctSidewallSatCurDensity; + case BSIM4v7_MOD_JSWS: + value->rValue = model->BSIM4v7SjctSidewallSatCurDensity; return(OK); - case BSIM4_MOD_JSWGS: - value->rValue = model->BSIM4SjctGateSidewallSatCurDensity; + case BSIM4v7_MOD_JSWGS: + value->rValue = model->BSIM4v7SjctGateSidewallSatCurDensity; return(OK); - case BSIM4_MOD_PBS: - value->rValue = model->BSIM4SbulkJctPotential; + case BSIM4v7_MOD_PBS: + value->rValue = model->BSIM4v7SbulkJctPotential; return(OK); - case BSIM4_MOD_MJS: - value->rValue = model->BSIM4SbulkJctBotGradingCoeff; + case BSIM4v7_MOD_MJS: + value->rValue = model->BSIM4v7SbulkJctBotGradingCoeff; return(OK); - case BSIM4_MOD_PBSWS: - value->rValue = model->BSIM4SsidewallJctPotential; + case BSIM4v7_MOD_PBSWS: + value->rValue = model->BSIM4v7SsidewallJctPotential; return(OK); - case BSIM4_MOD_MJSWS: - value->rValue = model->BSIM4SbulkJctSideGradingCoeff; + case BSIM4v7_MOD_MJSWS: + value->rValue = model->BSIM4v7SbulkJctSideGradingCoeff; return(OK); - case BSIM4_MOD_CJS: - value->rValue = model->BSIM4SunitAreaJctCap; + case BSIM4v7_MOD_CJS: + value->rValue = model->BSIM4v7SunitAreaJctCap; return(OK); - case BSIM4_MOD_CJSWS: - value->rValue = model->BSIM4SunitLengthSidewallJctCap; + case BSIM4v7_MOD_CJSWS: + value->rValue = model->BSIM4v7SunitLengthSidewallJctCap; return(OK); - case BSIM4_MOD_PBSWGS: - value->rValue = model->BSIM4SGatesidewallJctPotential; + case BSIM4v7_MOD_PBSWGS: + value->rValue = model->BSIM4v7SGatesidewallJctPotential; return(OK); - case BSIM4_MOD_MJSWGS: - value->rValue = model->BSIM4SbulkJctGateSideGradingCoeff; + case BSIM4v7_MOD_MJSWGS: + value->rValue = model->BSIM4v7SbulkJctGateSideGradingCoeff; return(OK); - case BSIM4_MOD_CJSWGS: - value->rValue = model->BSIM4SunitLengthGateSidewallJctCap; + case BSIM4v7_MOD_CJSWGS: + value->rValue = model->BSIM4v7SunitLengthGateSidewallJctCap; return(OK); - case BSIM4_MOD_NJS: - value->rValue = model->BSIM4SjctEmissionCoeff; + case BSIM4v7_MOD_NJS: + value->rValue = model->BSIM4v7SjctEmissionCoeff; return(OK); - case BSIM4_MOD_XTIS: - value->rValue = model->BSIM4SjctTempExponent; + case BSIM4v7_MOD_XTIS: + value->rValue = model->BSIM4v7SjctTempExponent; return(OK); - case BSIM4_MOD_JSD: - value->rValue = model->BSIM4DjctSatCurDensity; + case BSIM4v7_MOD_JSD: + value->rValue = model->BSIM4v7DjctSatCurDensity; return(OK); - case BSIM4_MOD_JSWD: - value->rValue = model->BSIM4DjctSidewallSatCurDensity; + case BSIM4v7_MOD_JSWD: + value->rValue = model->BSIM4v7DjctSidewallSatCurDensity; return(OK); - case BSIM4_MOD_JSWGD: - value->rValue = model->BSIM4DjctGateSidewallSatCurDensity; + case BSIM4v7_MOD_JSWGD: + value->rValue = model->BSIM4v7DjctGateSidewallSatCurDensity; return(OK); - case BSIM4_MOD_PBD: - value->rValue = model->BSIM4DbulkJctPotential; + case BSIM4v7_MOD_PBD: + value->rValue = model->BSIM4v7DbulkJctPotential; return(OK); - case BSIM4_MOD_MJD: - value->rValue = model->BSIM4DbulkJctBotGradingCoeff; + case BSIM4v7_MOD_MJD: + value->rValue = model->BSIM4v7DbulkJctBotGradingCoeff; return(OK); - case BSIM4_MOD_PBSWD: - value->rValue = model->BSIM4DsidewallJctPotential; + case BSIM4v7_MOD_PBSWD: + value->rValue = model->BSIM4v7DsidewallJctPotential; return(OK); - case BSIM4_MOD_MJSWD: - value->rValue = model->BSIM4DbulkJctSideGradingCoeff; + case BSIM4v7_MOD_MJSWD: + value->rValue = model->BSIM4v7DbulkJctSideGradingCoeff; return(OK); - case BSIM4_MOD_CJD: - value->rValue = model->BSIM4DunitAreaJctCap; + case BSIM4v7_MOD_CJD: + value->rValue = model->BSIM4v7DunitAreaJctCap; return(OK); - case BSIM4_MOD_CJSWD: - value->rValue = model->BSIM4DunitLengthSidewallJctCap; + case BSIM4v7_MOD_CJSWD: + value->rValue = model->BSIM4v7DunitLengthSidewallJctCap; return(OK); - case BSIM4_MOD_PBSWGD: - value->rValue = model->BSIM4DGatesidewallJctPotential; + case BSIM4v7_MOD_PBSWGD: + value->rValue = model->BSIM4v7DGatesidewallJctPotential; return(OK); - case BSIM4_MOD_MJSWGD: - value->rValue = model->BSIM4DbulkJctGateSideGradingCoeff; + case BSIM4v7_MOD_MJSWGD: + value->rValue = model->BSIM4v7DbulkJctGateSideGradingCoeff; return(OK); - case BSIM4_MOD_CJSWGD: - value->rValue = model->BSIM4DunitLengthGateSidewallJctCap; + case BSIM4v7_MOD_CJSWGD: + value->rValue = model->BSIM4v7DunitLengthGateSidewallJctCap; return(OK); - case BSIM4_MOD_NJD: - value->rValue = model->BSIM4DjctEmissionCoeff; + case BSIM4v7_MOD_NJD: + value->rValue = model->BSIM4v7DjctEmissionCoeff; return(OK); - case BSIM4_MOD_XTID: - value->rValue = model->BSIM4DjctTempExponent; + case BSIM4v7_MOD_XTID: + value->rValue = model->BSIM4v7DjctTempExponent; return(OK); - case BSIM4_MOD_LINTNOI: - value->rValue = model->BSIM4lintnoi; + case BSIM4v7_MOD_LINTNOI: + value->rValue = model->BSIM4v7lintnoi; return(OK); - case BSIM4_MOD_LINT: - value->rValue = model->BSIM4Lint; + case BSIM4v7_MOD_LINT: + value->rValue = model->BSIM4v7Lint; return(OK); - case BSIM4_MOD_LL: - value->rValue = model->BSIM4Ll; + case BSIM4v7_MOD_LL: + value->rValue = model->BSIM4v7Ll; return(OK); - case BSIM4_MOD_LLC: - value->rValue = model->BSIM4Llc; + case BSIM4v7_MOD_LLC: + value->rValue = model->BSIM4v7Llc; return(OK); - case BSIM4_MOD_LLN: - value->rValue = model->BSIM4Lln; + case BSIM4v7_MOD_LLN: + value->rValue = model->BSIM4v7Lln; return(OK); - case BSIM4_MOD_LW: - value->rValue = model->BSIM4Lw; + case BSIM4v7_MOD_LW: + value->rValue = model->BSIM4v7Lw; return(OK); - case BSIM4_MOD_LWC: - value->rValue = model->BSIM4Lwc; + case BSIM4v7_MOD_LWC: + value->rValue = model->BSIM4v7Lwc; return(OK); - case BSIM4_MOD_LWN: - value->rValue = model->BSIM4Lwn; + case BSIM4v7_MOD_LWN: + value->rValue = model->BSIM4v7Lwn; return(OK); - case BSIM4_MOD_LWL: - value->rValue = model->BSIM4Lwl; + case BSIM4v7_MOD_LWL: + value->rValue = model->BSIM4v7Lwl; return(OK); - case BSIM4_MOD_LWLC: - value->rValue = model->BSIM4Lwlc; + case BSIM4v7_MOD_LWLC: + value->rValue = model->BSIM4v7Lwlc; return(OK); - case BSIM4_MOD_LMIN: - value->rValue = model->BSIM4Lmin; + case BSIM4v7_MOD_LMIN: + value->rValue = model->BSIM4v7Lmin; return(OK); - case BSIM4_MOD_LMAX: - value->rValue = model->BSIM4Lmax; + case BSIM4v7_MOD_LMAX: + value->rValue = model->BSIM4v7Lmax; return(OK); - case BSIM4_MOD_WINT: - value->rValue = model->BSIM4Wint; + case BSIM4v7_MOD_WINT: + value->rValue = model->BSIM4v7Wint; return(OK); - case BSIM4_MOD_WL: - value->rValue = model->BSIM4Wl; + case BSIM4v7_MOD_WL: + value->rValue = model->BSIM4v7Wl; return(OK); - case BSIM4_MOD_WLC: - value->rValue = model->BSIM4Wlc; + case BSIM4v7_MOD_WLC: + value->rValue = model->BSIM4v7Wlc; return(OK); - case BSIM4_MOD_WLN: - value->rValue = model->BSIM4Wln; + case BSIM4v7_MOD_WLN: + value->rValue = model->BSIM4v7Wln; return(OK); - case BSIM4_MOD_WW: - value->rValue = model->BSIM4Ww; + case BSIM4v7_MOD_WW: + value->rValue = model->BSIM4v7Ww; return(OK); - case BSIM4_MOD_WWC: - value->rValue = model->BSIM4Wwc; + case BSIM4v7_MOD_WWC: + value->rValue = model->BSIM4v7Wwc; return(OK); - case BSIM4_MOD_WWN: - value->rValue = model->BSIM4Wwn; + case BSIM4v7_MOD_WWN: + value->rValue = model->BSIM4v7Wwn; return(OK); - case BSIM4_MOD_WWL: - value->rValue = model->BSIM4Wwl; + case BSIM4v7_MOD_WWL: + value->rValue = model->BSIM4v7Wwl; return(OK); - case BSIM4_MOD_WWLC: - value->rValue = model->BSIM4Wwlc; + case BSIM4v7_MOD_WWLC: + value->rValue = model->BSIM4v7Wwlc; return(OK); - case BSIM4_MOD_WMIN: - value->rValue = model->BSIM4Wmin; + case BSIM4v7_MOD_WMIN: + value->rValue = model->BSIM4v7Wmin; return(OK); - case BSIM4_MOD_WMAX: - value->rValue = model->BSIM4Wmax; + case BSIM4v7_MOD_WMAX: + value->rValue = model->BSIM4v7Wmax; return(OK); /* stress effect */ - case BSIM4_MOD_SAREF: - value->rValue = model->BSIM4saref; + case BSIM4v7_MOD_SAREF: + value->rValue = model->BSIM4v7saref; return(OK); - case BSIM4_MOD_SBREF: - value->rValue = model->BSIM4sbref; + case BSIM4v7_MOD_SBREF: + value->rValue = model->BSIM4v7sbref; return(OK); - case BSIM4_MOD_WLOD: - value->rValue = model->BSIM4wlod; + case BSIM4v7_MOD_WLOD: + value->rValue = model->BSIM4v7wlod; return(OK); - case BSIM4_MOD_KU0: - value->rValue = model->BSIM4ku0; + case BSIM4v7_MOD_KU0: + value->rValue = model->BSIM4v7ku0; return(OK); - case BSIM4_MOD_KVSAT: - value->rValue = model->BSIM4kvsat; + case BSIM4v7_MOD_KVSAT: + value->rValue = model->BSIM4v7kvsat; return(OK); - case BSIM4_MOD_KVTH0: - value->rValue = model->BSIM4kvth0; + case BSIM4v7_MOD_KVTH0: + value->rValue = model->BSIM4v7kvth0; return(OK); - case BSIM4_MOD_TKU0: - value->rValue = model->BSIM4tku0; + case BSIM4v7_MOD_TKU0: + value->rValue = model->BSIM4v7tku0; return(OK); - case BSIM4_MOD_LLODKU0: - value->rValue = model->BSIM4llodku0; + case BSIM4v7_MOD_LLODKU0: + value->rValue = model->BSIM4v7llodku0; return(OK); - case BSIM4_MOD_WLODKU0: - value->rValue = model->BSIM4wlodku0; + case BSIM4v7_MOD_WLODKU0: + value->rValue = model->BSIM4v7wlodku0; return(OK); - case BSIM4_MOD_LLODVTH: - value->rValue = model->BSIM4llodvth; + case BSIM4v7_MOD_LLODVTH: + value->rValue = model->BSIM4v7llodvth; return(OK); - case BSIM4_MOD_WLODVTH: - value->rValue = model->BSIM4wlodvth; + case BSIM4v7_MOD_WLODVTH: + value->rValue = model->BSIM4v7wlodvth; return(OK); - case BSIM4_MOD_LKU0: - value->rValue = model->BSIM4lku0; + case BSIM4v7_MOD_LKU0: + value->rValue = model->BSIM4v7lku0; return(OK); - case BSIM4_MOD_WKU0: - value->rValue = model->BSIM4wku0; + case BSIM4v7_MOD_WKU0: + value->rValue = model->BSIM4v7wku0; return(OK); - case BSIM4_MOD_PKU0: - value->rValue = model->BSIM4pku0; + case BSIM4v7_MOD_PKU0: + value->rValue = model->BSIM4v7pku0; return(OK); - case BSIM4_MOD_LKVTH0: - value->rValue = model->BSIM4lkvth0; + case BSIM4v7_MOD_LKVTH0: + value->rValue = model->BSIM4v7lkvth0; return(OK); - case BSIM4_MOD_WKVTH0: - value->rValue = model->BSIM4wkvth0; + case BSIM4v7_MOD_WKVTH0: + value->rValue = model->BSIM4v7wkvth0; return(OK); - case BSIM4_MOD_PKVTH0: - value->rValue = model->BSIM4pkvth0; + case BSIM4v7_MOD_PKVTH0: + value->rValue = model->BSIM4v7pkvth0; return(OK); - case BSIM4_MOD_STK2: - value->rValue = model->BSIM4stk2; + case BSIM4v7_MOD_STK2: + value->rValue = model->BSIM4v7stk2; return(OK); - case BSIM4_MOD_LODK2: - value->rValue = model->BSIM4lodk2; + case BSIM4v7_MOD_LODK2: + value->rValue = model->BSIM4v7lodk2; return(OK); - case BSIM4_MOD_STETA0: - value->rValue = model->BSIM4steta0; + case BSIM4v7_MOD_STETA0: + value->rValue = model->BSIM4v7steta0; return(OK); - case BSIM4_MOD_LODETA0: - value->rValue = model->BSIM4lodeta0; + case BSIM4v7_MOD_LODETA0: + value->rValue = model->BSIM4v7lodeta0; return(OK); /* Well Proximity Effect */ - case BSIM4_MOD_WEB: - value->rValue = model->BSIM4web; + case BSIM4v7_MOD_WEB: + value->rValue = model->BSIM4v7web; return(OK); - case BSIM4_MOD_WEC: - value->rValue = model->BSIM4wec; + case BSIM4v7_MOD_WEC: + value->rValue = model->BSIM4v7wec; return(OK); - case BSIM4_MOD_KVTH0WE: - value->rValue = model->BSIM4kvth0we; + case BSIM4v7_MOD_KVTH0WE: + value->rValue = model->BSIM4v7kvth0we; return(OK); - case BSIM4_MOD_K2WE: - value->rValue = model->BSIM4k2we; + case BSIM4v7_MOD_K2WE: + value->rValue = model->BSIM4v7k2we; return(OK); - case BSIM4_MOD_KU0WE: - value->rValue = model->BSIM4ku0we; + case BSIM4v7_MOD_KU0WE: + value->rValue = model->BSIM4v7ku0we; return(OK); - case BSIM4_MOD_SCREF: - value->rValue = model->BSIM4scref; + case BSIM4v7_MOD_SCREF: + value->rValue = model->BSIM4v7scref; return(OK); - case BSIM4_MOD_WPEMOD: - value->rValue = model->BSIM4wpemod; + case BSIM4v7_MOD_WPEMOD: + value->rValue = model->BSIM4v7wpemod; return(OK); - case BSIM4_MOD_LKVTH0WE: - value->rValue = model->BSIM4lkvth0we; + case BSIM4v7_MOD_LKVTH0WE: + value->rValue = model->BSIM4v7lkvth0we; return(OK); - case BSIM4_MOD_LK2WE: - value->rValue = model->BSIM4lk2we; + case BSIM4v7_MOD_LK2WE: + value->rValue = model->BSIM4v7lk2we; return(OK); - case BSIM4_MOD_LKU0WE: - value->rValue = model->BSIM4lku0we; + case BSIM4v7_MOD_LKU0WE: + value->rValue = model->BSIM4v7lku0we; return(OK); - case BSIM4_MOD_WKVTH0WE: - value->rValue = model->BSIM4wkvth0we; + case BSIM4v7_MOD_WKVTH0WE: + value->rValue = model->BSIM4v7wkvth0we; return(OK); - case BSIM4_MOD_WK2WE: - value->rValue = model->BSIM4wk2we; + case BSIM4v7_MOD_WK2WE: + value->rValue = model->BSIM4v7wk2we; return(OK); - case BSIM4_MOD_WKU0WE: - value->rValue = model->BSIM4wku0we; + case BSIM4v7_MOD_WKU0WE: + value->rValue = model->BSIM4v7wku0we; return(OK); - case BSIM4_MOD_PKVTH0WE: - value->rValue = model->BSIM4pkvth0we; + case BSIM4v7_MOD_PKVTH0WE: + value->rValue = model->BSIM4v7pkvth0we; return(OK); - case BSIM4_MOD_PK2WE: - value->rValue = model->BSIM4pk2we; + case BSIM4v7_MOD_PK2WE: + value->rValue = model->BSIM4v7pk2we; return(OK); - case BSIM4_MOD_PKU0WE: - value->rValue = model->BSIM4pku0we; + case BSIM4v7_MOD_PKU0WE: + value->rValue = model->BSIM4v7pku0we; return(OK); - case BSIM4_MOD_NOIA: - value->rValue = model->BSIM4oxideTrapDensityA; + case BSIM4v7_MOD_NOIA: + value->rValue = model->BSIM4v7oxideTrapDensityA; return(OK); - case BSIM4_MOD_NOIB: - value->rValue = model->BSIM4oxideTrapDensityB; + case BSIM4v7_MOD_NOIB: + value->rValue = model->BSIM4v7oxideTrapDensityB; return(OK); - case BSIM4_MOD_NOIC: - value->rValue = model->BSIM4oxideTrapDensityC; + case BSIM4v7_MOD_NOIC: + value->rValue = model->BSIM4v7oxideTrapDensityC; return(OK); - case BSIM4_MOD_EM: - value->rValue = model->BSIM4em; + case BSIM4v7_MOD_EM: + value->rValue = model->BSIM4v7em; return(OK); - case BSIM4_MOD_EF: - value->rValue = model->BSIM4ef; + case BSIM4v7_MOD_EF: + value->rValue = model->BSIM4v7ef; return(OK); - case BSIM4_MOD_AF: - value->rValue = model->BSIM4af; + case BSIM4v7_MOD_AF: + value->rValue = model->BSIM4v7af; return(OK); - case BSIM4_MOD_KF: - value->rValue = model->BSIM4kf; + case BSIM4v7_MOD_KF: + value->rValue = model->BSIM4v7kf; return(OK); - case BSIM4_MOD_VGS_MAX: - value->rValue = model->BSIM4vgsMax; + case BSIM4v7_MOD_VGS_MAX: + value->rValue = model->BSIM4v7vgsMax; return(OK); - case BSIM4_MOD_VGD_MAX: - value->rValue = model->BSIM4vgdMax; + case BSIM4v7_MOD_VGD_MAX: + value->rValue = model->BSIM4v7vgdMax; return(OK); - case BSIM4_MOD_VGB_MAX: - value->rValue = model->BSIM4vgbMax; + case BSIM4v7_MOD_VGB_MAX: + value->rValue = model->BSIM4v7vgbMax; return(OK); - case BSIM4_MOD_VDS_MAX: - value->rValue = model->BSIM4vdsMax; + case BSIM4v7_MOD_VDS_MAX: + value->rValue = model->BSIM4v7vdsMax; return(OK); - case BSIM4_MOD_VBS_MAX: - value->rValue = model->BSIM4vbsMax; + case BSIM4v7_MOD_VBS_MAX: + value->rValue = model->BSIM4v7vbsMax; return(OK); - case BSIM4_MOD_VBD_MAX: - value->rValue = model->BSIM4vbdMax; + case BSIM4v7_MOD_VBD_MAX: + value->rValue = model->BSIM4v7vbdMax; return(OK); default: diff --git a/src/spicelib/devices/bsim4v7/b4v7mdel.c b/src/spicelib/devices/bsim4v7/b4v7mdel.c index 71f23ed00..1ed1e50b0 100644 --- a/src/spicelib/devices/bsim4v7/b4v7mdel.c +++ b/src/spicelib/devices/bsim4v7/b4v7mdel.c @@ -11,25 +11,25 @@ **********/ #include "ngspice/ngspice.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" int -BSIM4mDelete( +BSIM4v7mDelete( GENmodel **inModel, IFuid modname, GENmodel *kill) { -BSIM4model **model = (BSIM4model**)inModel; -BSIM4model *modfast = (BSIM4model*)kill; -BSIM4instance *here; -BSIM4instance *prev = NULL; -BSIM4model **oldmod; +BSIM4v7model **model = (BSIM4v7model**)inModel; +BSIM4v7model *modfast = (BSIM4v7model*)kill; +BSIM4v7instance *here; +BSIM4v7instance *prev = NULL; +BSIM4v7model **oldmod; oldmod = model; - for (; *model ; model = &((*model)->BSIM4nextModel)) - { if ((*model)->BSIM4modName == modname || + for (; *model ; model = &((*model)->BSIM4v7nextModel)) + { if ((*model)->BSIM4v7modName == modname || (modfast && *model == modfast)) goto delgot; oldmod = model; @@ -37,8 +37,8 @@ BSIM4model **oldmod; return(E_NOMOD); delgot: - *oldmod = (*model)->BSIM4nextModel; /* cut deleted device out of list */ - for (here = (*model)->BSIM4instances; here; here = here->BSIM4nextInstance) + *oldmod = (*model)->BSIM4v7nextModel; /* cut deleted device out of list */ + for (here = (*model)->BSIM4v7instances; here; here = here->BSIM4v7nextInstance) { if(prev) FREE(prev); prev = here; } diff --git a/src/spicelib/devices/bsim4v7/b4v7mpar.c b/src/spicelib/devices/bsim4v7/b4v7mpar.c index 7fc0e25ce..bd9724b22 100644 --- a/src/spicelib/devices/bsim4v7/b4v7mpar.c +++ b/src/spicelib/devices/bsim4v7/b4v7mpar.c @@ -22,3622 +22,3622 @@ **********/ #include "ngspice/ngspice.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/ifsim.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" #include "ngspice/const.h" int -BSIM4mParam( +BSIM4v7mParam( int param, IFvalue *value, GENmodel *inMod) { - BSIM4model *mod = (BSIM4model*)inMod; + BSIM4v7model *mod = (BSIM4v7model*)inMod; switch(param) - { case BSIM4_MOD_MOBMOD : - mod->BSIM4mobMod = value->iValue; - mod->BSIM4mobModGiven = TRUE; + { case BSIM4v7_MOD_MOBMOD : + mod->BSIM4v7mobMod = value->iValue; + mod->BSIM4v7mobModGiven = TRUE; break; - case BSIM4_MOD_BINUNIT : - mod->BSIM4binUnit = value->iValue; - mod->BSIM4binUnitGiven = TRUE; + case BSIM4v7_MOD_BINUNIT : + mod->BSIM4v7binUnit = value->iValue; + mod->BSIM4v7binUnitGiven = TRUE; break; - case BSIM4_MOD_PARAMCHK : - mod->BSIM4paramChk = value->iValue; - mod->BSIM4paramChkGiven = TRUE; + case BSIM4v7_MOD_PARAMCHK : + mod->BSIM4v7paramChk = value->iValue; + mod->BSIM4v7paramChkGiven = TRUE; break; - case BSIM4_MOD_CVCHARGEMOD : - mod->BSIM4cvchargeMod = value->iValue; - mod->BSIM4cvchargeModGiven = TRUE; + case BSIM4v7_MOD_CVCHARGEMOD : + mod->BSIM4v7cvchargeMod = value->iValue; + mod->BSIM4v7cvchargeModGiven = TRUE; break; - case BSIM4_MOD_CAPMOD : - mod->BSIM4capMod = value->iValue; - mod->BSIM4capModGiven = TRUE; + case BSIM4v7_MOD_CAPMOD : + mod->BSIM4v7capMod = value->iValue; + mod->BSIM4v7capModGiven = TRUE; break; - case BSIM4_MOD_DIOMOD : - mod->BSIM4dioMod = value->iValue; - mod->BSIM4dioModGiven = TRUE; + case BSIM4v7_MOD_DIOMOD : + mod->BSIM4v7dioMod = value->iValue; + mod->BSIM4v7dioModGiven = TRUE; break; - case BSIM4_MOD_RDSMOD : - mod->BSIM4rdsMod = value->iValue; - mod->BSIM4rdsModGiven = TRUE; + case BSIM4v7_MOD_RDSMOD : + mod->BSIM4v7rdsMod = value->iValue; + mod->BSIM4v7rdsModGiven = TRUE; break; - case BSIM4_MOD_TRNQSMOD : - mod->BSIM4trnqsMod = value->iValue; - mod->BSIM4trnqsModGiven = TRUE; + case BSIM4v7_MOD_TRNQSMOD : + mod->BSIM4v7trnqsMod = value->iValue; + mod->BSIM4v7trnqsModGiven = TRUE; break; - case BSIM4_MOD_ACNQSMOD : - mod->BSIM4acnqsMod = value->iValue; - mod->BSIM4acnqsModGiven = TRUE; + case BSIM4v7_MOD_ACNQSMOD : + mod->BSIM4v7acnqsMod = value->iValue; + mod->BSIM4v7acnqsModGiven = TRUE; break; - case BSIM4_MOD_RBODYMOD : - mod->BSIM4rbodyMod = value->iValue; - mod->BSIM4rbodyModGiven = TRUE; + case BSIM4v7_MOD_RBODYMOD : + mod->BSIM4v7rbodyMod = value->iValue; + mod->BSIM4v7rbodyModGiven = TRUE; break; - case BSIM4_MOD_RGATEMOD : - mod->BSIM4rgateMod = value->iValue; - mod->BSIM4rgateModGiven = TRUE; + case BSIM4v7_MOD_RGATEMOD : + mod->BSIM4v7rgateMod = value->iValue; + mod->BSIM4v7rgateModGiven = TRUE; break; - case BSIM4_MOD_PERMOD : - mod->BSIM4perMod = value->iValue; - mod->BSIM4perModGiven = TRUE; + case BSIM4v7_MOD_PERMOD : + mod->BSIM4v7perMod = value->iValue; + mod->BSIM4v7perModGiven = TRUE; break; - case BSIM4_MOD_GEOMOD : - mod->BSIM4geoMod = value->iValue; - mod->BSIM4geoModGiven = TRUE; + case BSIM4v7_MOD_GEOMOD : + mod->BSIM4v7geoMod = value->iValue; + mod->BSIM4v7geoModGiven = TRUE; break; - case BSIM4_MOD_RGEOMOD : - mod->BSIM4rgeoMod = value->iValue; - mod->BSIM4rgeoModGiven = TRUE; + case BSIM4v7_MOD_RGEOMOD : + mod->BSIM4v7rgeoMod = value->iValue; + mod->BSIM4v7rgeoModGiven = TRUE; break; - case BSIM4_MOD_FNOIMOD : - mod->BSIM4fnoiMod = value->iValue; - mod->BSIM4fnoiModGiven = TRUE; + case BSIM4v7_MOD_FNOIMOD : + mod->BSIM4v7fnoiMod = value->iValue; + mod->BSIM4v7fnoiModGiven = TRUE; break; - case BSIM4_MOD_TNOIMOD : - mod->BSIM4tnoiMod = value->iValue; - mod->BSIM4tnoiModGiven = TRUE; + case BSIM4v7_MOD_TNOIMOD : + mod->BSIM4v7tnoiMod = value->iValue; + mod->BSIM4v7tnoiModGiven = TRUE; break; - case BSIM4_MOD_MTRLMOD : - mod->BSIM4mtrlMod = value->iValue; - mod->BSIM4mtrlModGiven = TRUE; + case BSIM4v7_MOD_MTRLMOD : + mod->BSIM4v7mtrlMod = value->iValue; + mod->BSIM4v7mtrlModGiven = TRUE; break; - case BSIM4_MOD_MTRLCOMPATMOD : - mod->BSIM4mtrlCompatMod = value->iValue; - mod->BSIM4mtrlCompatModGiven = TRUE; + case BSIM4v7_MOD_MTRLCOMPATMOD : + mod->BSIM4v7mtrlCompatMod = value->iValue; + mod->BSIM4v7mtrlCompatModGiven = TRUE; break; - case BSIM4_MOD_GIDLMOD : /* v4.7 New GIDL/GISL */ - mod->BSIM4gidlMod = value->iValue; - mod->BSIM4gidlModGiven = TRUE; + case BSIM4v7_MOD_GIDLMOD : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7gidlMod = value->iValue; + mod->BSIM4v7gidlModGiven = TRUE; break; - case BSIM4_MOD_IGCMOD : - mod->BSIM4igcMod = value->iValue; - mod->BSIM4igcModGiven = TRUE; + case BSIM4v7_MOD_IGCMOD : + mod->BSIM4v7igcMod = value->iValue; + mod->BSIM4v7igcModGiven = TRUE; break; - case BSIM4_MOD_IGBMOD : - mod->BSIM4igbMod = value->iValue; - mod->BSIM4igbModGiven = TRUE; + case BSIM4v7_MOD_IGBMOD : + mod->BSIM4v7igbMod = value->iValue; + mod->BSIM4v7igbModGiven = TRUE; break; - case BSIM4_MOD_TEMPMOD : - mod->BSIM4tempMod = value->iValue; - mod->BSIM4tempModGiven = TRUE; + case BSIM4v7_MOD_TEMPMOD : + mod->BSIM4v7tempMod = value->iValue; + mod->BSIM4v7tempModGiven = TRUE; break; - case BSIM4_MOD_VERSION : - mod->BSIM4version = value->sValue; - mod->BSIM4versionGiven = TRUE; + case BSIM4v7_MOD_VERSION : + mod->BSIM4v7version = value->sValue; + mod->BSIM4v7versionGiven = TRUE; break; - case BSIM4_MOD_TOXREF : - mod->BSIM4toxref = value->rValue; - mod->BSIM4toxrefGiven = TRUE; + case BSIM4v7_MOD_TOXREF : + mod->BSIM4v7toxref = value->rValue; + mod->BSIM4v7toxrefGiven = TRUE; break; - case BSIM4_MOD_EOT : - mod->BSIM4eot = value->rValue; - mod->BSIM4eotGiven = TRUE; + case BSIM4v7_MOD_EOT : + mod->BSIM4v7eot = value->rValue; + mod->BSIM4v7eotGiven = TRUE; break; - case BSIM4_MOD_VDDEOT : - mod->BSIM4vddeot = value->rValue; - mod->BSIM4vddeotGiven = TRUE; + case BSIM4v7_MOD_VDDEOT : + mod->BSIM4v7vddeot = value->rValue; + mod->BSIM4v7vddeotGiven = TRUE; break; - case BSIM4_MOD_TEMPEOT : - mod->BSIM4tempeot = value->rValue; - mod->BSIM4tempeotGiven = TRUE; + case BSIM4v7_MOD_TEMPEOT : + mod->BSIM4v7tempeot = value->rValue; + mod->BSIM4v7tempeotGiven = TRUE; break; - case BSIM4_MOD_LEFFEOT : - mod->BSIM4leffeot = value->rValue; - mod->BSIM4leffeotGiven = TRUE; + case BSIM4v7_MOD_LEFFEOT : + mod->BSIM4v7leffeot = value->rValue; + mod->BSIM4v7leffeotGiven = TRUE; break; - case BSIM4_MOD_WEFFEOT : - mod->BSIM4weffeot = value->rValue; - mod->BSIM4weffeotGiven = TRUE; + case BSIM4v7_MOD_WEFFEOT : + mod->BSIM4v7weffeot = value->rValue; + mod->BSIM4v7weffeotGiven = TRUE; break; - case BSIM4_MOD_ADOS : - mod->BSIM4ados = value->rValue; - mod->BSIM4adosGiven = TRUE; + case BSIM4v7_MOD_ADOS : + mod->BSIM4v7ados = value->rValue; + mod->BSIM4v7adosGiven = TRUE; break; - case BSIM4_MOD_BDOS : - mod->BSIM4bdos = value->rValue; - mod->BSIM4bdosGiven = TRUE; + case BSIM4v7_MOD_BDOS : + mod->BSIM4v7bdos = value->rValue; + mod->BSIM4v7bdosGiven = TRUE; break; - case BSIM4_MOD_TOXE : - mod->BSIM4toxe = value->rValue; - mod->BSIM4toxeGiven = TRUE; + case BSIM4v7_MOD_TOXE : + mod->BSIM4v7toxe = value->rValue; + mod->BSIM4v7toxeGiven = TRUE; break; - case BSIM4_MOD_TOXP : - mod->BSIM4toxp = value->rValue; - mod->BSIM4toxpGiven = TRUE; + case BSIM4v7_MOD_TOXP : + mod->BSIM4v7toxp = value->rValue; + mod->BSIM4v7toxpGiven = TRUE; break; - case BSIM4_MOD_TOXM : - mod->BSIM4toxm = value->rValue; - mod->BSIM4toxmGiven = TRUE; + case BSIM4v7_MOD_TOXM : + mod->BSIM4v7toxm = value->rValue; + mod->BSIM4v7toxmGiven = TRUE; break; - case BSIM4_MOD_DTOX : - mod->BSIM4dtox = value->rValue; - mod->BSIM4dtoxGiven = TRUE; + case BSIM4v7_MOD_DTOX : + mod->BSIM4v7dtox = value->rValue; + mod->BSIM4v7dtoxGiven = TRUE; break; - case BSIM4_MOD_EPSROX : - mod->BSIM4epsrox = value->rValue; - mod->BSIM4epsroxGiven = TRUE; + case BSIM4v7_MOD_EPSROX : + mod->BSIM4v7epsrox = value->rValue; + mod->BSIM4v7epsroxGiven = TRUE; break; - case BSIM4_MOD_CDSC : - mod->BSIM4cdsc = value->rValue; - mod->BSIM4cdscGiven = TRUE; + case BSIM4v7_MOD_CDSC : + mod->BSIM4v7cdsc = value->rValue; + mod->BSIM4v7cdscGiven = TRUE; break; - case BSIM4_MOD_CDSCB : - mod->BSIM4cdscb = value->rValue; - mod->BSIM4cdscbGiven = TRUE; + case BSIM4v7_MOD_CDSCB : + mod->BSIM4v7cdscb = value->rValue; + mod->BSIM4v7cdscbGiven = TRUE; break; - case BSIM4_MOD_CDSCD : - mod->BSIM4cdscd = value->rValue; - mod->BSIM4cdscdGiven = TRUE; + case BSIM4v7_MOD_CDSCD : + mod->BSIM4v7cdscd = value->rValue; + mod->BSIM4v7cdscdGiven = TRUE; break; - case BSIM4_MOD_CIT : - mod->BSIM4cit = value->rValue; - mod->BSIM4citGiven = TRUE; + case BSIM4v7_MOD_CIT : + mod->BSIM4v7cit = value->rValue; + mod->BSIM4v7citGiven = TRUE; break; - case BSIM4_MOD_NFACTOR : - mod->BSIM4nfactor = value->rValue; - mod->BSIM4nfactorGiven = TRUE; + case BSIM4v7_MOD_NFACTOR : + mod->BSIM4v7nfactor = value->rValue; + mod->BSIM4v7nfactorGiven = TRUE; break; - case BSIM4_MOD_XJ: - mod->BSIM4xj = value->rValue; - mod->BSIM4xjGiven = TRUE; + case BSIM4v7_MOD_XJ: + mod->BSIM4v7xj = value->rValue; + mod->BSIM4v7xjGiven = TRUE; break; - case BSIM4_MOD_VSAT: - mod->BSIM4vsat = value->rValue; - mod->BSIM4vsatGiven = TRUE; + case BSIM4v7_MOD_VSAT: + mod->BSIM4v7vsat = value->rValue; + mod->BSIM4v7vsatGiven = TRUE; break; - case BSIM4_MOD_A0: - mod->BSIM4a0 = value->rValue; - mod->BSIM4a0Given = TRUE; + case BSIM4v7_MOD_A0: + mod->BSIM4v7a0 = value->rValue; + mod->BSIM4v7a0Given = TRUE; break; - case BSIM4_MOD_AGS: - mod->BSIM4ags= value->rValue; - mod->BSIM4agsGiven = TRUE; + case BSIM4v7_MOD_AGS: + mod->BSIM4v7ags= value->rValue; + mod->BSIM4v7agsGiven = TRUE; break; - case BSIM4_MOD_A1: - mod->BSIM4a1 = value->rValue; - mod->BSIM4a1Given = TRUE; + case BSIM4v7_MOD_A1: + mod->BSIM4v7a1 = value->rValue; + mod->BSIM4v7a1Given = TRUE; break; - case BSIM4_MOD_A2: - mod->BSIM4a2 = value->rValue; - mod->BSIM4a2Given = TRUE; + case BSIM4v7_MOD_A2: + mod->BSIM4v7a2 = value->rValue; + mod->BSIM4v7a2Given = TRUE; break; - case BSIM4_MOD_AT: - mod->BSIM4at = value->rValue; - mod->BSIM4atGiven = TRUE; + case BSIM4v7_MOD_AT: + mod->BSIM4v7at = value->rValue; + mod->BSIM4v7atGiven = TRUE; break; - case BSIM4_MOD_KETA: - mod->BSIM4keta = value->rValue; - mod->BSIM4ketaGiven = TRUE; + case BSIM4v7_MOD_KETA: + mod->BSIM4v7keta = value->rValue; + mod->BSIM4v7ketaGiven = TRUE; break; - case BSIM4_MOD_NSUB: - mod->BSIM4nsub = value->rValue; - mod->BSIM4nsubGiven = TRUE; + case BSIM4v7_MOD_NSUB: + mod->BSIM4v7nsub = value->rValue; + mod->BSIM4v7nsubGiven = TRUE; break; - case BSIM4_MOD_PHIG: - mod->BSIM4phig = value->rValue; - mod->BSIM4phigGiven = TRUE; + case BSIM4v7_MOD_PHIG: + mod->BSIM4v7phig = value->rValue; + mod->BSIM4v7phigGiven = TRUE; break; - case BSIM4_MOD_EPSRGATE: - mod->BSIM4epsrgate = value->rValue; - mod->BSIM4epsrgateGiven = TRUE; + case BSIM4v7_MOD_EPSRGATE: + mod->BSIM4v7epsrgate = value->rValue; + mod->BSIM4v7epsrgateGiven = TRUE; break; - case BSIM4_MOD_EASUB: - mod->BSIM4easub = value->rValue; - mod->BSIM4easubGiven = TRUE; + case BSIM4v7_MOD_EASUB: + mod->BSIM4v7easub = value->rValue; + mod->BSIM4v7easubGiven = TRUE; break; - case BSIM4_MOD_EPSRSUB: - mod->BSIM4epsrsub = value->rValue; - mod->BSIM4epsrsubGiven = TRUE; + case BSIM4v7_MOD_EPSRSUB: + mod->BSIM4v7epsrsub = value->rValue; + mod->BSIM4v7epsrsubGiven = TRUE; break; - case BSIM4_MOD_NI0SUB: - mod->BSIM4ni0sub = value->rValue; - mod->BSIM4ni0subGiven = TRUE; + case BSIM4v7_MOD_NI0SUB: + mod->BSIM4v7ni0sub = value->rValue; + mod->BSIM4v7ni0subGiven = TRUE; break; - case BSIM4_MOD_BG0SUB: - mod->BSIM4bg0sub = value->rValue; - mod->BSIM4bg0subGiven = TRUE; + case BSIM4v7_MOD_BG0SUB: + mod->BSIM4v7bg0sub = value->rValue; + mod->BSIM4v7bg0subGiven = TRUE; break; - case BSIM4_MOD_TBGASUB: - mod->BSIM4tbgasub = value->rValue; - mod->BSIM4tbgasubGiven = TRUE; + case BSIM4v7_MOD_TBGASUB: + mod->BSIM4v7tbgasub = value->rValue; + mod->BSIM4v7tbgasubGiven = TRUE; break; - case BSIM4_MOD_TBGBSUB: - mod->BSIM4tbgbsub = value->rValue; - mod->BSIM4tbgbsubGiven = TRUE; + case BSIM4v7_MOD_TBGBSUB: + mod->BSIM4v7tbgbsub = value->rValue; + mod->BSIM4v7tbgbsubGiven = TRUE; break; - case BSIM4_MOD_NDEP: - mod->BSIM4ndep = value->rValue; - mod->BSIM4ndepGiven = TRUE; - if (mod->BSIM4ndep > 1.0e20) - mod->BSIM4ndep *= 1.0e-6; + case BSIM4v7_MOD_NDEP: + mod->BSIM4v7ndep = value->rValue; + mod->BSIM4v7ndepGiven = TRUE; + if (mod->BSIM4v7ndep > 1.0e20) + mod->BSIM4v7ndep *= 1.0e-6; break; - case BSIM4_MOD_NSD: - mod->BSIM4nsd = value->rValue; - mod->BSIM4nsdGiven = TRUE; - if (mod->BSIM4nsd > 1.0e23) - mod->BSIM4nsd *= 1.0e-6; + case BSIM4v7_MOD_NSD: + mod->BSIM4v7nsd = value->rValue; + mod->BSIM4v7nsdGiven = TRUE; + if (mod->BSIM4v7nsd > 1.0e23) + mod->BSIM4v7nsd *= 1.0e-6; break; - case BSIM4_MOD_NGATE: - mod->BSIM4ngate = value->rValue; - mod->BSIM4ngateGiven = TRUE; - if (mod->BSIM4ngate > 1.0e23) - mod->BSIM4ngate *= 1.0e-6; + case BSIM4v7_MOD_NGATE: + mod->BSIM4v7ngate = value->rValue; + mod->BSIM4v7ngateGiven = TRUE; + if (mod->BSIM4v7ngate > 1.0e23) + mod->BSIM4v7ngate *= 1.0e-6; break; - case BSIM4_MOD_GAMMA1: - mod->BSIM4gamma1 = value->rValue; - mod->BSIM4gamma1Given = TRUE; + case BSIM4v7_MOD_GAMMA1: + mod->BSIM4v7gamma1 = value->rValue; + mod->BSIM4v7gamma1Given = TRUE; break; - case BSIM4_MOD_GAMMA2: - mod->BSIM4gamma2 = value->rValue; - mod->BSIM4gamma2Given = TRUE; + case BSIM4v7_MOD_GAMMA2: + mod->BSIM4v7gamma2 = value->rValue; + mod->BSIM4v7gamma2Given = TRUE; break; - case BSIM4_MOD_VBX: - mod->BSIM4vbx = value->rValue; - mod->BSIM4vbxGiven = TRUE; + case BSIM4v7_MOD_VBX: + mod->BSIM4v7vbx = value->rValue; + mod->BSIM4v7vbxGiven = TRUE; break; - case BSIM4_MOD_VBM: - mod->BSIM4vbm = value->rValue; - mod->BSIM4vbmGiven = TRUE; + case BSIM4v7_MOD_VBM: + mod->BSIM4v7vbm = value->rValue; + mod->BSIM4v7vbmGiven = TRUE; break; - case BSIM4_MOD_XT: - mod->BSIM4xt = value->rValue; - mod->BSIM4xtGiven = TRUE; + case BSIM4v7_MOD_XT: + mod->BSIM4v7xt = value->rValue; + mod->BSIM4v7xtGiven = TRUE; break; - case BSIM4_MOD_K1: - mod->BSIM4k1 = value->rValue; - mod->BSIM4k1Given = TRUE; + case BSIM4v7_MOD_K1: + mod->BSIM4v7k1 = value->rValue; + mod->BSIM4v7k1Given = TRUE; break; - case BSIM4_MOD_KT1: - mod->BSIM4kt1 = value->rValue; - mod->BSIM4kt1Given = TRUE; + case BSIM4v7_MOD_KT1: + mod->BSIM4v7kt1 = value->rValue; + mod->BSIM4v7kt1Given = TRUE; break; - case BSIM4_MOD_KT1L: - mod->BSIM4kt1l = value->rValue; - mod->BSIM4kt1lGiven = TRUE; + case BSIM4v7_MOD_KT1L: + mod->BSIM4v7kt1l = value->rValue; + mod->BSIM4v7kt1lGiven = TRUE; break; - case BSIM4_MOD_KT2: - mod->BSIM4kt2 = value->rValue; - mod->BSIM4kt2Given = TRUE; + case BSIM4v7_MOD_KT2: + mod->BSIM4v7kt2 = value->rValue; + mod->BSIM4v7kt2Given = TRUE; break; - case BSIM4_MOD_K2: - mod->BSIM4k2 = value->rValue; - mod->BSIM4k2Given = TRUE; + case BSIM4v7_MOD_K2: + mod->BSIM4v7k2 = value->rValue; + mod->BSIM4v7k2Given = TRUE; break; - case BSIM4_MOD_K3: - mod->BSIM4k3 = value->rValue; - mod->BSIM4k3Given = TRUE; + case BSIM4v7_MOD_K3: + mod->BSIM4v7k3 = value->rValue; + mod->BSIM4v7k3Given = TRUE; break; - case BSIM4_MOD_K3B: - mod->BSIM4k3b = value->rValue; - mod->BSIM4k3bGiven = TRUE; + case BSIM4v7_MOD_K3B: + mod->BSIM4v7k3b = value->rValue; + mod->BSIM4v7k3bGiven = TRUE; break; - case BSIM4_MOD_LPE0: - mod->BSIM4lpe0 = value->rValue; - mod->BSIM4lpe0Given = TRUE; + case BSIM4v7_MOD_LPE0: + mod->BSIM4v7lpe0 = value->rValue; + mod->BSIM4v7lpe0Given = TRUE; break; - case BSIM4_MOD_LPEB: - mod->BSIM4lpeb = value->rValue; - mod->BSIM4lpebGiven = TRUE; + case BSIM4v7_MOD_LPEB: + mod->BSIM4v7lpeb = value->rValue; + mod->BSIM4v7lpebGiven = TRUE; break; - case BSIM4_MOD_DVTP0: - mod->BSIM4dvtp0 = value->rValue; - mod->BSIM4dvtp0Given = TRUE; + case BSIM4v7_MOD_DVTP0: + mod->BSIM4v7dvtp0 = value->rValue; + mod->BSIM4v7dvtp0Given = TRUE; break; - case BSIM4_MOD_DVTP1: - mod->BSIM4dvtp1 = value->rValue; - mod->BSIM4dvtp1Given = TRUE; + case BSIM4v7_MOD_DVTP1: + mod->BSIM4v7dvtp1 = value->rValue; + mod->BSIM4v7dvtp1Given = TRUE; break; - case BSIM4_MOD_DVTP2: /* New DIBL/Rout */ - mod->BSIM4dvtp2 = value->rValue; - mod->BSIM4dvtp2Given = TRUE; + case BSIM4v7_MOD_DVTP2: /* New DIBL/Rout */ + mod->BSIM4v7dvtp2 = value->rValue; + mod->BSIM4v7dvtp2Given = TRUE; break; - case BSIM4_MOD_DVTP3: - mod->BSIM4dvtp3 = value->rValue; - mod->BSIM4dvtp3Given = TRUE; + case BSIM4v7_MOD_DVTP3: + mod->BSIM4v7dvtp3 = value->rValue; + mod->BSIM4v7dvtp3Given = TRUE; break; - case BSIM4_MOD_DVTP4: - mod->BSIM4dvtp4 = value->rValue; - mod->BSIM4dvtp4Given = TRUE; + case BSIM4v7_MOD_DVTP4: + mod->BSIM4v7dvtp4 = value->rValue; + mod->BSIM4v7dvtp4Given = TRUE; break; - case BSIM4_MOD_DVTP5: - mod->BSIM4dvtp5 = value->rValue; - mod->BSIM4dvtp5Given = TRUE; + case BSIM4v7_MOD_DVTP5: + mod->BSIM4v7dvtp5 = value->rValue; + mod->BSIM4v7dvtp5Given = TRUE; break; - case BSIM4_MOD_W0: - mod->BSIM4w0 = value->rValue; - mod->BSIM4w0Given = TRUE; + case BSIM4v7_MOD_W0: + mod->BSIM4v7w0 = value->rValue; + mod->BSIM4v7w0Given = TRUE; break; - case BSIM4_MOD_DVT0: - mod->BSIM4dvt0 = value->rValue; - mod->BSIM4dvt0Given = TRUE; + case BSIM4v7_MOD_DVT0: + mod->BSIM4v7dvt0 = value->rValue; + mod->BSIM4v7dvt0Given = TRUE; break; - case BSIM4_MOD_DVT1: - mod->BSIM4dvt1 = value->rValue; - mod->BSIM4dvt1Given = TRUE; + case BSIM4v7_MOD_DVT1: + mod->BSIM4v7dvt1 = value->rValue; + mod->BSIM4v7dvt1Given = TRUE; break; - case BSIM4_MOD_DVT2: - mod->BSIM4dvt2 = value->rValue; - mod->BSIM4dvt2Given = TRUE; + case BSIM4v7_MOD_DVT2: + mod->BSIM4v7dvt2 = value->rValue; + mod->BSIM4v7dvt2Given = TRUE; break; - case BSIM4_MOD_DVT0W: - mod->BSIM4dvt0w = value->rValue; - mod->BSIM4dvt0wGiven = TRUE; + case BSIM4v7_MOD_DVT0W: + mod->BSIM4v7dvt0w = value->rValue; + mod->BSIM4v7dvt0wGiven = TRUE; break; - case BSIM4_MOD_DVT1W: - mod->BSIM4dvt1w = value->rValue; - mod->BSIM4dvt1wGiven = TRUE; + case BSIM4v7_MOD_DVT1W: + mod->BSIM4v7dvt1w = value->rValue; + mod->BSIM4v7dvt1wGiven = TRUE; break; - case BSIM4_MOD_DVT2W: - mod->BSIM4dvt2w = value->rValue; - mod->BSIM4dvt2wGiven = TRUE; + case BSIM4v7_MOD_DVT2W: + mod->BSIM4v7dvt2w = value->rValue; + mod->BSIM4v7dvt2wGiven = TRUE; break; - case BSIM4_MOD_DROUT: - mod->BSIM4drout = value->rValue; - mod->BSIM4droutGiven = TRUE; + case BSIM4v7_MOD_DROUT: + mod->BSIM4v7drout = value->rValue; + mod->BSIM4v7droutGiven = TRUE; break; - case BSIM4_MOD_DSUB: - mod->BSIM4dsub = value->rValue; - mod->BSIM4dsubGiven = TRUE; + case BSIM4v7_MOD_DSUB: + mod->BSIM4v7dsub = value->rValue; + mod->BSIM4v7dsubGiven = TRUE; break; - case BSIM4_MOD_VTH0: - mod->BSIM4vth0 = value->rValue; - mod->BSIM4vth0Given = TRUE; + case BSIM4v7_MOD_VTH0: + mod->BSIM4v7vth0 = value->rValue; + mod->BSIM4v7vth0Given = TRUE; break; - case BSIM4_MOD_EU: - mod->BSIM4eu = value->rValue; - mod->BSIM4euGiven = TRUE; + case BSIM4v7_MOD_EU: + mod->BSIM4v7eu = value->rValue; + mod->BSIM4v7euGiven = TRUE; break; - case BSIM4_MOD_UCS: - mod->BSIM4ucs = value->rValue; - mod->BSIM4ucsGiven = TRUE; + case BSIM4v7_MOD_UCS: + mod->BSIM4v7ucs = value->rValue; + mod->BSIM4v7ucsGiven = TRUE; break; - case BSIM4_MOD_UA: - mod->BSIM4ua = value->rValue; - mod->BSIM4uaGiven = TRUE; + case BSIM4v7_MOD_UA: + mod->BSIM4v7ua = value->rValue; + mod->BSIM4v7uaGiven = TRUE; break; - case BSIM4_MOD_UA1: - mod->BSIM4ua1 = value->rValue; - mod->BSIM4ua1Given = TRUE; + case BSIM4v7_MOD_UA1: + mod->BSIM4v7ua1 = value->rValue; + mod->BSIM4v7ua1Given = TRUE; break; - case BSIM4_MOD_UB: - mod->BSIM4ub = value->rValue; - mod->BSIM4ubGiven = TRUE; + case BSIM4v7_MOD_UB: + mod->BSIM4v7ub = value->rValue; + mod->BSIM4v7ubGiven = TRUE; break; - case BSIM4_MOD_UB1: - mod->BSIM4ub1 = value->rValue; - mod->BSIM4ub1Given = TRUE; + case BSIM4v7_MOD_UB1: + mod->BSIM4v7ub1 = value->rValue; + mod->BSIM4v7ub1Given = TRUE; break; - case BSIM4_MOD_UC: - mod->BSIM4uc = value->rValue; - mod->BSIM4ucGiven = TRUE; + case BSIM4v7_MOD_UC: + mod->BSIM4v7uc = value->rValue; + mod->BSIM4v7ucGiven = TRUE; break; - case BSIM4_MOD_UC1: - mod->BSIM4uc1 = value->rValue; - mod->BSIM4uc1Given = TRUE; + case BSIM4v7_MOD_UC1: + mod->BSIM4v7uc1 = value->rValue; + mod->BSIM4v7uc1Given = TRUE; break; - case BSIM4_MOD_U0 : - mod->BSIM4u0 = value->rValue; - mod->BSIM4u0Given = TRUE; + case BSIM4v7_MOD_U0 : + mod->BSIM4v7u0 = value->rValue; + mod->BSIM4v7u0Given = TRUE; break; - case BSIM4_MOD_UTE : - mod->BSIM4ute = value->rValue; - mod->BSIM4uteGiven = TRUE; + case BSIM4v7_MOD_UTE : + mod->BSIM4v7ute = value->rValue; + mod->BSIM4v7uteGiven = TRUE; break; - case BSIM4_MOD_UCSTE : - mod->BSIM4ucste = value->rValue; - mod->BSIM4ucsteGiven = TRUE; + case BSIM4v7_MOD_UCSTE : + mod->BSIM4v7ucste = value->rValue; + mod->BSIM4v7ucsteGiven = TRUE; break; - case BSIM4_MOD_UD: - mod->BSIM4ud = value->rValue; - mod->BSIM4udGiven = TRUE; + case BSIM4v7_MOD_UD: + mod->BSIM4v7ud = value->rValue; + mod->BSIM4v7udGiven = TRUE; break; - case BSIM4_MOD_UD1: - mod->BSIM4ud1 = value->rValue; - mod->BSIM4ud1Given = TRUE; + case BSIM4v7_MOD_UD1: + mod->BSIM4v7ud1 = value->rValue; + mod->BSIM4v7ud1Given = TRUE; break; - case BSIM4_MOD_UP: - mod->BSIM4up = value->rValue; - mod->BSIM4upGiven = TRUE; + case BSIM4v7_MOD_UP: + mod->BSIM4v7up = value->rValue; + mod->BSIM4v7upGiven = TRUE; break; - case BSIM4_MOD_LP: - mod->BSIM4lp = value->rValue; - mod->BSIM4lpGiven = TRUE; + case BSIM4v7_MOD_LP: + mod->BSIM4v7lp = value->rValue; + mod->BSIM4v7lpGiven = TRUE; break; - case BSIM4_MOD_LUD: - mod->BSIM4lud = value->rValue; - mod->BSIM4ludGiven = TRUE; + case BSIM4v7_MOD_LUD: + mod->BSIM4v7lud = value->rValue; + mod->BSIM4v7ludGiven = TRUE; break; - case BSIM4_MOD_LUD1: - mod->BSIM4lud1 = value->rValue; - mod->BSIM4lud1Given = TRUE; + case BSIM4v7_MOD_LUD1: + mod->BSIM4v7lud1 = value->rValue; + mod->BSIM4v7lud1Given = TRUE; break; - case BSIM4_MOD_LUP: - mod->BSIM4lup = value->rValue; - mod->BSIM4lupGiven = TRUE; + case BSIM4v7_MOD_LUP: + mod->BSIM4v7lup = value->rValue; + mod->BSIM4v7lupGiven = TRUE; break; - case BSIM4_MOD_LLP: - mod->BSIM4llp = value->rValue; - mod->BSIM4llpGiven = TRUE; + case BSIM4v7_MOD_LLP: + mod->BSIM4v7llp = value->rValue; + mod->BSIM4v7llpGiven = TRUE; break; - case BSIM4_MOD_WUD: - mod->BSIM4wud = value->rValue; - mod->BSIM4wudGiven = TRUE; + case BSIM4v7_MOD_WUD: + mod->BSIM4v7wud = value->rValue; + mod->BSIM4v7wudGiven = TRUE; break; - case BSIM4_MOD_WUD1: - mod->BSIM4wud1 = value->rValue; - mod->BSIM4wud1Given = TRUE; + case BSIM4v7_MOD_WUD1: + mod->BSIM4v7wud1 = value->rValue; + mod->BSIM4v7wud1Given = TRUE; break; - case BSIM4_MOD_WUP: - mod->BSIM4wup = value->rValue; - mod->BSIM4wupGiven = TRUE; + case BSIM4v7_MOD_WUP: + mod->BSIM4v7wup = value->rValue; + mod->BSIM4v7wupGiven = TRUE; break; - case BSIM4_MOD_WLP: - mod->BSIM4wlp = value->rValue; - mod->BSIM4wlpGiven = TRUE; + case BSIM4v7_MOD_WLP: + mod->BSIM4v7wlp = value->rValue; + mod->BSIM4v7wlpGiven = TRUE; break; - case BSIM4_MOD_PUD: - mod->BSIM4pud = value->rValue; - mod->BSIM4pudGiven = TRUE; + case BSIM4v7_MOD_PUD: + mod->BSIM4v7pud = value->rValue; + mod->BSIM4v7pudGiven = TRUE; break; - case BSIM4_MOD_PUD1: - mod->BSIM4pud1 = value->rValue; - mod->BSIM4pud1Given = TRUE; + case BSIM4v7_MOD_PUD1: + mod->BSIM4v7pud1 = value->rValue; + mod->BSIM4v7pud1Given = TRUE; break; - case BSIM4_MOD_PUP: - mod->BSIM4pup = value->rValue; - mod->BSIM4pupGiven = TRUE; + case BSIM4v7_MOD_PUP: + mod->BSIM4v7pup = value->rValue; + mod->BSIM4v7pupGiven = TRUE; break; - case BSIM4_MOD_PLP: - mod->BSIM4plp = value->rValue; - mod->BSIM4plpGiven = TRUE; + case BSIM4v7_MOD_PLP: + mod->BSIM4v7plp = value->rValue; + mod->BSIM4v7plpGiven = TRUE; break; - case BSIM4_MOD_VOFF: - mod->BSIM4voff = value->rValue; - mod->BSIM4voffGiven = TRUE; + case BSIM4v7_MOD_VOFF: + mod->BSIM4v7voff = value->rValue; + mod->BSIM4v7voffGiven = TRUE; break; - case BSIM4_MOD_TVOFF: - mod->BSIM4tvoff = value->rValue; - mod->BSIM4tvoffGiven = TRUE; + case BSIM4v7_MOD_TVOFF: + mod->BSIM4v7tvoff = value->rValue; + mod->BSIM4v7tvoffGiven = TRUE; break; - case BSIM4_MOD_TNFACTOR: /* v4.7 temp dep of leakage current */ - mod->BSIM4tnfactor = value->rValue; - mod->BSIM4tnfactorGiven = TRUE; + case BSIM4v7_MOD_TNFACTOR: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7tnfactor = value->rValue; + mod->BSIM4v7tnfactorGiven = TRUE; break; - case BSIM4_MOD_TETA0: /* v4.7 temp dep of leakage current */ - mod->BSIM4teta0 = value->rValue; - mod->BSIM4teta0Given = TRUE; + case BSIM4v7_MOD_TETA0: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7teta0 = value->rValue; + mod->BSIM4v7teta0Given = TRUE; break; - case BSIM4_MOD_TVOFFCV: /* v4.7 temp dep of leakage current */ - mod->BSIM4tvoffcv = value->rValue; - mod->BSIM4tvoffcvGiven = TRUE; + case BSIM4v7_MOD_TVOFFCV: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7tvoffcv = value->rValue; + mod->BSIM4v7tvoffcvGiven = TRUE; break; - case BSIM4_MOD_VOFFL: - mod->BSIM4voffl = value->rValue; - mod->BSIM4vofflGiven = TRUE; + case BSIM4v7_MOD_VOFFL: + mod->BSIM4v7voffl = value->rValue; + mod->BSIM4v7vofflGiven = TRUE; break; - case BSIM4_MOD_VOFFCVL: - mod->BSIM4voffcvl = value->rValue; - mod->BSIM4voffcvlGiven = TRUE; + case BSIM4v7_MOD_VOFFCVL: + mod->BSIM4v7voffcvl = value->rValue; + mod->BSIM4v7voffcvlGiven = TRUE; break; - case BSIM4_MOD_MINV: - mod->BSIM4minv = value->rValue; - mod->BSIM4minvGiven = TRUE; + case BSIM4v7_MOD_MINV: + mod->BSIM4v7minv = value->rValue; + mod->BSIM4v7minvGiven = TRUE; break; - case BSIM4_MOD_MINVCV: - mod->BSIM4minvcv = value->rValue; - mod->BSIM4minvcvGiven = TRUE; + case BSIM4v7_MOD_MINVCV: + mod->BSIM4v7minvcv = value->rValue; + mod->BSIM4v7minvcvGiven = TRUE; break; - case BSIM4_MOD_FPROUT: - mod->BSIM4fprout = value->rValue; - mod->BSIM4fproutGiven = TRUE; + case BSIM4v7_MOD_FPROUT: + mod->BSIM4v7fprout = value->rValue; + mod->BSIM4v7fproutGiven = TRUE; break; - case BSIM4_MOD_PDITS: - mod->BSIM4pdits = value->rValue; - mod->BSIM4pditsGiven = TRUE; + case BSIM4v7_MOD_PDITS: + mod->BSIM4v7pdits = value->rValue; + mod->BSIM4v7pditsGiven = TRUE; break; - case BSIM4_MOD_PDITSD: - mod->BSIM4pditsd = value->rValue; - mod->BSIM4pditsdGiven = TRUE; + case BSIM4v7_MOD_PDITSD: + mod->BSIM4v7pditsd = value->rValue; + mod->BSIM4v7pditsdGiven = TRUE; break; - case BSIM4_MOD_PDITSL: - mod->BSIM4pditsl = value->rValue; - mod->BSIM4pditslGiven = TRUE; + case BSIM4v7_MOD_PDITSL: + mod->BSIM4v7pditsl = value->rValue; + mod->BSIM4v7pditslGiven = TRUE; break; - case BSIM4_MOD_DELTA : - mod->BSIM4delta = value->rValue; - mod->BSIM4deltaGiven = TRUE; + case BSIM4v7_MOD_DELTA : + mod->BSIM4v7delta = value->rValue; + mod->BSIM4v7deltaGiven = TRUE; break; - case BSIM4_MOD_RDSW: - mod->BSIM4rdsw = value->rValue; - mod->BSIM4rdswGiven = TRUE; + case BSIM4v7_MOD_RDSW: + mod->BSIM4v7rdsw = value->rValue; + mod->BSIM4v7rdswGiven = TRUE; break; - case BSIM4_MOD_RDSWMIN: - mod->BSIM4rdswmin = value->rValue; - mod->BSIM4rdswminGiven = TRUE; + case BSIM4v7_MOD_RDSWMIN: + mod->BSIM4v7rdswmin = value->rValue; + mod->BSIM4v7rdswminGiven = TRUE; break; - case BSIM4_MOD_RDWMIN: - mod->BSIM4rdwmin = value->rValue; - mod->BSIM4rdwminGiven = TRUE; + case BSIM4v7_MOD_RDWMIN: + mod->BSIM4v7rdwmin = value->rValue; + mod->BSIM4v7rdwminGiven = TRUE; break; - case BSIM4_MOD_RSWMIN: - mod->BSIM4rswmin = value->rValue; - mod->BSIM4rswminGiven = TRUE; + case BSIM4v7_MOD_RSWMIN: + mod->BSIM4v7rswmin = value->rValue; + mod->BSIM4v7rswminGiven = TRUE; break; - case BSIM4_MOD_RDW: - mod->BSIM4rdw = value->rValue; - mod->BSIM4rdwGiven = TRUE; + case BSIM4v7_MOD_RDW: + mod->BSIM4v7rdw = value->rValue; + mod->BSIM4v7rdwGiven = TRUE; break; - case BSIM4_MOD_RSW: - mod->BSIM4rsw = value->rValue; - mod->BSIM4rswGiven = TRUE; + case BSIM4v7_MOD_RSW: + mod->BSIM4v7rsw = value->rValue; + mod->BSIM4v7rswGiven = TRUE; break; - case BSIM4_MOD_PRWG: - mod->BSIM4prwg = value->rValue; - mod->BSIM4prwgGiven = TRUE; + case BSIM4v7_MOD_PRWG: + mod->BSIM4v7prwg = value->rValue; + mod->BSIM4v7prwgGiven = TRUE; break; - case BSIM4_MOD_PRWB: - mod->BSIM4prwb = value->rValue; - mod->BSIM4prwbGiven = TRUE; + case BSIM4v7_MOD_PRWB: + mod->BSIM4v7prwb = value->rValue; + mod->BSIM4v7prwbGiven = TRUE; break; - case BSIM4_MOD_PRT: - mod->BSIM4prt = value->rValue; - mod->BSIM4prtGiven = TRUE; + case BSIM4v7_MOD_PRT: + mod->BSIM4v7prt = value->rValue; + mod->BSIM4v7prtGiven = TRUE; break; - case BSIM4_MOD_ETA0: - mod->BSIM4eta0 = value->rValue; - mod->BSIM4eta0Given = TRUE; + case BSIM4v7_MOD_ETA0: + mod->BSIM4v7eta0 = value->rValue; + mod->BSIM4v7eta0Given = TRUE; break; - case BSIM4_MOD_ETAB: - mod->BSIM4etab = value->rValue; - mod->BSIM4etabGiven = TRUE; + case BSIM4v7_MOD_ETAB: + mod->BSIM4v7etab = value->rValue; + mod->BSIM4v7etabGiven = TRUE; break; - case BSIM4_MOD_PCLM: - mod->BSIM4pclm = value->rValue; - mod->BSIM4pclmGiven = TRUE; + case BSIM4v7_MOD_PCLM: + mod->BSIM4v7pclm = value->rValue; + mod->BSIM4v7pclmGiven = TRUE; break; - case BSIM4_MOD_PDIBL1: - mod->BSIM4pdibl1 = value->rValue; - mod->BSIM4pdibl1Given = TRUE; + case BSIM4v7_MOD_PDIBL1: + mod->BSIM4v7pdibl1 = value->rValue; + mod->BSIM4v7pdibl1Given = TRUE; break; - case BSIM4_MOD_PDIBL2: - mod->BSIM4pdibl2 = value->rValue; - mod->BSIM4pdibl2Given = TRUE; + case BSIM4v7_MOD_PDIBL2: + mod->BSIM4v7pdibl2 = value->rValue; + mod->BSIM4v7pdibl2Given = TRUE; break; - case BSIM4_MOD_PDIBLB: - mod->BSIM4pdiblb = value->rValue; - mod->BSIM4pdiblbGiven = TRUE; + case BSIM4v7_MOD_PDIBLB: + mod->BSIM4v7pdiblb = value->rValue; + mod->BSIM4v7pdiblbGiven = TRUE; break; - case BSIM4_MOD_PSCBE1: - mod->BSIM4pscbe1 = value->rValue; - mod->BSIM4pscbe1Given = TRUE; + case BSIM4v7_MOD_PSCBE1: + mod->BSIM4v7pscbe1 = value->rValue; + mod->BSIM4v7pscbe1Given = TRUE; break; - case BSIM4_MOD_PSCBE2: - mod->BSIM4pscbe2 = value->rValue; - mod->BSIM4pscbe2Given = TRUE; + case BSIM4v7_MOD_PSCBE2: + mod->BSIM4v7pscbe2 = value->rValue; + mod->BSIM4v7pscbe2Given = TRUE; break; - case BSIM4_MOD_PVAG: - mod->BSIM4pvag = value->rValue; - mod->BSIM4pvagGiven = TRUE; + case BSIM4v7_MOD_PVAG: + mod->BSIM4v7pvag = value->rValue; + mod->BSIM4v7pvagGiven = TRUE; break; - case BSIM4_MOD_WR : - mod->BSIM4wr = value->rValue; - mod->BSIM4wrGiven = TRUE; + case BSIM4v7_MOD_WR : + mod->BSIM4v7wr = value->rValue; + mod->BSIM4v7wrGiven = TRUE; break; - case BSIM4_MOD_DWG : - mod->BSIM4dwg = value->rValue; - mod->BSIM4dwgGiven = TRUE; + case BSIM4v7_MOD_DWG : + mod->BSIM4v7dwg = value->rValue; + mod->BSIM4v7dwgGiven = TRUE; break; - case BSIM4_MOD_DWB : - mod->BSIM4dwb = value->rValue; - mod->BSIM4dwbGiven = TRUE; + case BSIM4v7_MOD_DWB : + mod->BSIM4v7dwb = value->rValue; + mod->BSIM4v7dwbGiven = TRUE; break; - case BSIM4_MOD_B0 : - mod->BSIM4b0 = value->rValue; - mod->BSIM4b0Given = TRUE; + case BSIM4v7_MOD_B0 : + mod->BSIM4v7b0 = value->rValue; + mod->BSIM4v7b0Given = TRUE; break; - case BSIM4_MOD_B1 : - mod->BSIM4b1 = value->rValue; - mod->BSIM4b1Given = TRUE; + case BSIM4v7_MOD_B1 : + mod->BSIM4v7b1 = value->rValue; + mod->BSIM4v7b1Given = TRUE; break; - case BSIM4_MOD_ALPHA0 : - mod->BSIM4alpha0 = value->rValue; - mod->BSIM4alpha0Given = TRUE; + case BSIM4v7_MOD_ALPHA0 : + mod->BSIM4v7alpha0 = value->rValue; + mod->BSIM4v7alpha0Given = TRUE; break; - case BSIM4_MOD_ALPHA1 : - mod->BSIM4alpha1 = value->rValue; - mod->BSIM4alpha1Given = TRUE; + case BSIM4v7_MOD_ALPHA1 : + mod->BSIM4v7alpha1 = value->rValue; + mod->BSIM4v7alpha1Given = TRUE; break; - case BSIM4_MOD_PHIN : - mod->BSIM4phin = value->rValue; - mod->BSIM4phinGiven = TRUE; + case BSIM4v7_MOD_PHIN : + mod->BSIM4v7phin = value->rValue; + mod->BSIM4v7phinGiven = TRUE; break; - case BSIM4_MOD_AGIDL : - mod->BSIM4agidl = value->rValue; - mod->BSIM4agidlGiven = TRUE; + case BSIM4v7_MOD_AGIDL : + mod->BSIM4v7agidl = value->rValue; + mod->BSIM4v7agidlGiven = TRUE; break; - case BSIM4_MOD_BGIDL : - mod->BSIM4bgidl = value->rValue; - mod->BSIM4bgidlGiven = TRUE; + case BSIM4v7_MOD_BGIDL : + mod->BSIM4v7bgidl = value->rValue; + mod->BSIM4v7bgidlGiven = TRUE; break; - case BSIM4_MOD_CGIDL : - mod->BSIM4cgidl = value->rValue; - mod->BSIM4cgidlGiven = TRUE; + case BSIM4v7_MOD_CGIDL : + mod->BSIM4v7cgidl = value->rValue; + mod->BSIM4v7cgidlGiven = TRUE; break; - case BSIM4_MOD_EGIDL : - mod->BSIM4egidl = value->rValue; - mod->BSIM4egidlGiven = TRUE; + case BSIM4v7_MOD_EGIDL : + mod->BSIM4v7egidl = value->rValue; + mod->BSIM4v7egidlGiven = TRUE; break; - case BSIM4_MOD_FGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4fgidl = value->rValue; - mod->BSIM4fgidlGiven = TRUE; + case BSIM4v7_MOD_FGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7fgidl = value->rValue; + mod->BSIM4v7fgidlGiven = TRUE; break; - case BSIM4_MOD_KGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4kgidl = value->rValue; - mod->BSIM4kgidlGiven = TRUE; + case BSIM4v7_MOD_KGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7kgidl = value->rValue; + mod->BSIM4v7kgidlGiven = TRUE; break; - case BSIM4_MOD_RGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4rgidl = value->rValue; - mod->BSIM4rgidlGiven = TRUE; + case BSIM4v7_MOD_RGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7rgidl = value->rValue; + mod->BSIM4v7rgidlGiven = TRUE; break; - case BSIM4_MOD_AGISL : - mod->BSIM4agisl = value->rValue; - mod->BSIM4agislGiven = TRUE; + case BSIM4v7_MOD_AGISL : + mod->BSIM4v7agisl = value->rValue; + mod->BSIM4v7agislGiven = TRUE; break; - case BSIM4_MOD_BGISL : - mod->BSIM4bgisl = value->rValue; - mod->BSIM4bgislGiven = TRUE; + case BSIM4v7_MOD_BGISL : + mod->BSIM4v7bgisl = value->rValue; + mod->BSIM4v7bgislGiven = TRUE; break; - case BSIM4_MOD_CGISL : - mod->BSIM4cgisl = value->rValue; - mod->BSIM4cgislGiven = TRUE; + case BSIM4v7_MOD_CGISL : + mod->BSIM4v7cgisl = value->rValue; + mod->BSIM4v7cgislGiven = TRUE; break; - case BSIM4_MOD_EGISL : - mod->BSIM4egisl = value->rValue; - mod->BSIM4egislGiven = TRUE; + case BSIM4v7_MOD_EGISL : + mod->BSIM4v7egisl = value->rValue; + mod->BSIM4v7egislGiven = TRUE; break; - case BSIM4_MOD_FGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4fgisl = value->rValue; - mod->BSIM4fgislGiven = TRUE; + case BSIM4v7_MOD_FGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7fgisl = value->rValue; + mod->BSIM4v7fgislGiven = TRUE; break; - case BSIM4_MOD_KGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4kgisl = value->rValue; - mod->BSIM4kgislGiven = TRUE; + case BSIM4v7_MOD_KGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7kgisl = value->rValue; + mod->BSIM4v7kgislGiven = TRUE; break; - case BSIM4_MOD_RGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4rgisl = value->rValue; - mod->BSIM4rgislGiven = TRUE; + case BSIM4v7_MOD_RGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7rgisl = value->rValue; + mod->BSIM4v7rgislGiven = TRUE; break; - case BSIM4_MOD_AIGC : - mod->BSIM4aigc = value->rValue; - mod->BSIM4aigcGiven = TRUE; + case BSIM4v7_MOD_AIGC : + mod->BSIM4v7aigc = value->rValue; + mod->BSIM4v7aigcGiven = TRUE; break; - case BSIM4_MOD_BIGC : - mod->BSIM4bigc = value->rValue; - mod->BSIM4bigcGiven = TRUE; + case BSIM4v7_MOD_BIGC : + mod->BSIM4v7bigc = value->rValue; + mod->BSIM4v7bigcGiven = TRUE; break; - case BSIM4_MOD_CIGC : - mod->BSIM4cigc = value->rValue; - mod->BSIM4cigcGiven = TRUE; + case BSIM4v7_MOD_CIGC : + mod->BSIM4v7cigc = value->rValue; + mod->BSIM4v7cigcGiven = TRUE; break; - case BSIM4_MOD_AIGSD : - mod->BSIM4aigsd = value->rValue; - mod->BSIM4aigsdGiven = TRUE; + case BSIM4v7_MOD_AIGSD : + mod->BSIM4v7aigsd = value->rValue; + mod->BSIM4v7aigsdGiven = TRUE; break; - case BSIM4_MOD_BIGSD : - mod->BSIM4bigsd = value->rValue; - mod->BSIM4bigsdGiven = TRUE; + case BSIM4v7_MOD_BIGSD : + mod->BSIM4v7bigsd = value->rValue; + mod->BSIM4v7bigsdGiven = TRUE; break; - case BSIM4_MOD_CIGSD : - mod->BSIM4cigsd = value->rValue; - mod->BSIM4cigsdGiven = TRUE; + case BSIM4v7_MOD_CIGSD : + mod->BSIM4v7cigsd = value->rValue; + mod->BSIM4v7cigsdGiven = TRUE; break; - case BSIM4_MOD_AIGS : - mod->BSIM4aigs = value->rValue; - mod->BSIM4aigsGiven = TRUE; + case BSIM4v7_MOD_AIGS : + mod->BSIM4v7aigs = value->rValue; + mod->BSIM4v7aigsGiven = TRUE; break; - case BSIM4_MOD_BIGS : - mod->BSIM4bigs = value->rValue; - mod->BSIM4bigsGiven = TRUE; + case BSIM4v7_MOD_BIGS : + mod->BSIM4v7bigs = value->rValue; + mod->BSIM4v7bigsGiven = TRUE; break; - case BSIM4_MOD_CIGS : - mod->BSIM4cigs = value->rValue; - mod->BSIM4cigsGiven = TRUE; + case BSIM4v7_MOD_CIGS : + mod->BSIM4v7cigs = value->rValue; + mod->BSIM4v7cigsGiven = TRUE; break; - case BSIM4_MOD_AIGD : - mod->BSIM4aigd = value->rValue; - mod->BSIM4aigdGiven = TRUE; + case BSIM4v7_MOD_AIGD : + mod->BSIM4v7aigd = value->rValue; + mod->BSIM4v7aigdGiven = TRUE; break; - case BSIM4_MOD_BIGD : - mod->BSIM4bigd = value->rValue; - mod->BSIM4bigdGiven = TRUE; + case BSIM4v7_MOD_BIGD : + mod->BSIM4v7bigd = value->rValue; + mod->BSIM4v7bigdGiven = TRUE; break; - case BSIM4_MOD_CIGD : - mod->BSIM4cigd = value->rValue; - mod->BSIM4cigdGiven = TRUE; + case BSIM4v7_MOD_CIGD : + mod->BSIM4v7cigd = value->rValue; + mod->BSIM4v7cigdGiven = TRUE; break; - case BSIM4_MOD_AIGBACC : - mod->BSIM4aigbacc = value->rValue; - mod->BSIM4aigbaccGiven = TRUE; + case BSIM4v7_MOD_AIGBACC : + mod->BSIM4v7aigbacc = value->rValue; + mod->BSIM4v7aigbaccGiven = TRUE; break; - case BSIM4_MOD_BIGBACC : - mod->BSIM4bigbacc = value->rValue; - mod->BSIM4bigbaccGiven = TRUE; + case BSIM4v7_MOD_BIGBACC : + mod->BSIM4v7bigbacc = value->rValue; + mod->BSIM4v7bigbaccGiven = TRUE; break; - case BSIM4_MOD_CIGBACC : - mod->BSIM4cigbacc = value->rValue; - mod->BSIM4cigbaccGiven = TRUE; + case BSIM4v7_MOD_CIGBACC : + mod->BSIM4v7cigbacc = value->rValue; + mod->BSIM4v7cigbaccGiven = TRUE; break; - case BSIM4_MOD_AIGBINV : - mod->BSIM4aigbinv = value->rValue; - mod->BSIM4aigbinvGiven = TRUE; + case BSIM4v7_MOD_AIGBINV : + mod->BSIM4v7aigbinv = value->rValue; + mod->BSIM4v7aigbinvGiven = TRUE; break; - case BSIM4_MOD_BIGBINV : - mod->BSIM4bigbinv = value->rValue; - mod->BSIM4bigbinvGiven = TRUE; + case BSIM4v7_MOD_BIGBINV : + mod->BSIM4v7bigbinv = value->rValue; + mod->BSIM4v7bigbinvGiven = TRUE; break; - case BSIM4_MOD_CIGBINV : - mod->BSIM4cigbinv = value->rValue; - mod->BSIM4cigbinvGiven = TRUE; + case BSIM4v7_MOD_CIGBINV : + mod->BSIM4v7cigbinv = value->rValue; + mod->BSIM4v7cigbinvGiven = TRUE; break; - case BSIM4_MOD_NIGC : - mod->BSIM4nigc = value->rValue; - mod->BSIM4nigcGiven = TRUE; + case BSIM4v7_MOD_NIGC : + mod->BSIM4v7nigc = value->rValue; + mod->BSIM4v7nigcGiven = TRUE; break; - case BSIM4_MOD_NIGBINV : - mod->BSIM4nigbinv = value->rValue; - mod->BSIM4nigbinvGiven = TRUE; + case BSIM4v7_MOD_NIGBINV : + mod->BSIM4v7nigbinv = value->rValue; + mod->BSIM4v7nigbinvGiven = TRUE; break; - case BSIM4_MOD_NIGBACC : - mod->BSIM4nigbacc = value->rValue; - mod->BSIM4nigbaccGiven = TRUE; + case BSIM4v7_MOD_NIGBACC : + mod->BSIM4v7nigbacc = value->rValue; + mod->BSIM4v7nigbaccGiven = TRUE; break; - case BSIM4_MOD_NTOX : - mod->BSIM4ntox = value->rValue; - mod->BSIM4ntoxGiven = TRUE; + case BSIM4v7_MOD_NTOX : + mod->BSIM4v7ntox = value->rValue; + mod->BSIM4v7ntoxGiven = TRUE; break; - case BSIM4_MOD_EIGBINV : - mod->BSIM4eigbinv = value->rValue; - mod->BSIM4eigbinvGiven = TRUE; + case BSIM4v7_MOD_EIGBINV : + mod->BSIM4v7eigbinv = value->rValue; + mod->BSIM4v7eigbinvGiven = TRUE; break; - case BSIM4_MOD_PIGCD : - mod->BSIM4pigcd = value->rValue; - mod->BSIM4pigcdGiven = TRUE; + case BSIM4v7_MOD_PIGCD : + mod->BSIM4v7pigcd = value->rValue; + mod->BSIM4v7pigcdGiven = TRUE; break; - case BSIM4_MOD_POXEDGE : - mod->BSIM4poxedge = value->rValue; - mod->BSIM4poxedgeGiven = TRUE; + case BSIM4v7_MOD_POXEDGE : + mod->BSIM4v7poxedge = value->rValue; + mod->BSIM4v7poxedgeGiven = TRUE; break; - case BSIM4_MOD_XRCRG1 : - mod->BSIM4xrcrg1 = value->rValue; - mod->BSIM4xrcrg1Given = TRUE; + case BSIM4v7_MOD_XRCRG1 : + mod->BSIM4v7xrcrg1 = value->rValue; + mod->BSIM4v7xrcrg1Given = TRUE; break; - case BSIM4_MOD_XRCRG2 : - mod->BSIM4xrcrg2 = value->rValue; - mod->BSIM4xrcrg2Given = TRUE; + case BSIM4v7_MOD_XRCRG2 : + mod->BSIM4v7xrcrg2 = value->rValue; + mod->BSIM4v7xrcrg2Given = TRUE; break; - case BSIM4_MOD_LAMBDA : - mod->BSIM4lambda = value->rValue; - mod->BSIM4lambdaGiven = TRUE; + case BSIM4v7_MOD_LAMBDA : + mod->BSIM4v7lambda = value->rValue; + mod->BSIM4v7lambdaGiven = TRUE; break; - case BSIM4_MOD_VTL : - mod->BSIM4vtl = value->rValue; - mod->BSIM4vtlGiven = TRUE; + case BSIM4v7_MOD_VTL : + mod->BSIM4v7vtl = value->rValue; + mod->BSIM4v7vtlGiven = TRUE; break; - case BSIM4_MOD_XN: - mod->BSIM4xn = value->rValue; - mod->BSIM4xnGiven = TRUE; + case BSIM4v7_MOD_XN: + mod->BSIM4v7xn = value->rValue; + mod->BSIM4v7xnGiven = TRUE; break; - case BSIM4_MOD_LC: - mod->BSIM4lc = value->rValue; - mod->BSIM4lcGiven = TRUE; + case BSIM4v7_MOD_LC: + mod->BSIM4v7lc = value->rValue; + mod->BSIM4v7lcGiven = TRUE; break; - case BSIM4_MOD_TNOIA : - mod->BSIM4tnoia = value->rValue; - mod->BSIM4tnoiaGiven = TRUE; + case BSIM4v7_MOD_TNOIA : + mod->BSIM4v7tnoia = value->rValue; + mod->BSIM4v7tnoiaGiven = TRUE; break; - case BSIM4_MOD_TNOIB : - mod->BSIM4tnoib = value->rValue; - mod->BSIM4tnoibGiven = TRUE; + case BSIM4v7_MOD_TNOIB : + mod->BSIM4v7tnoib = value->rValue; + mod->BSIM4v7tnoibGiven = TRUE; break; - case BSIM4_MOD_TNOIC : - mod->BSIM4tnoic = value->rValue; - mod->BSIM4tnoicGiven = TRUE; + case BSIM4v7_MOD_TNOIC : + mod->BSIM4v7tnoic = value->rValue; + mod->BSIM4v7tnoicGiven = TRUE; break; - case BSIM4_MOD_RNOIA : - mod->BSIM4rnoia = value->rValue; - mod->BSIM4rnoiaGiven = TRUE; + case BSIM4v7_MOD_RNOIA : + mod->BSIM4v7rnoia = value->rValue; + mod->BSIM4v7rnoiaGiven = TRUE; break; - case BSIM4_MOD_RNOIB : - mod->BSIM4rnoib = value->rValue; - mod->BSIM4rnoibGiven = TRUE; + case BSIM4v7_MOD_RNOIB : + mod->BSIM4v7rnoib = value->rValue; + mod->BSIM4v7rnoibGiven = TRUE; break; - case BSIM4_MOD_RNOIC : - mod->BSIM4rnoic = value->rValue; - mod->BSIM4rnoicGiven = TRUE; + case BSIM4v7_MOD_RNOIC : + mod->BSIM4v7rnoic = value->rValue; + mod->BSIM4v7rnoicGiven = TRUE; break; - case BSIM4_MOD_NTNOI : - mod->BSIM4ntnoi = value->rValue; - mod->BSIM4ntnoiGiven = TRUE; + case BSIM4v7_MOD_NTNOI : + mod->BSIM4v7ntnoi = value->rValue; + mod->BSIM4v7ntnoiGiven = TRUE; break; - case BSIM4_MOD_VFBSDOFF: - mod->BSIM4vfbsdoff = value->rValue; - mod->BSIM4vfbsdoffGiven = TRUE; + case BSIM4v7_MOD_VFBSDOFF: + mod->BSIM4v7vfbsdoff = value->rValue; + mod->BSIM4v7vfbsdoffGiven = TRUE; break; - case BSIM4_MOD_TVFBSDOFF: - mod->BSIM4tvfbsdoff = value->rValue; - mod->BSIM4tvfbsdoffGiven = TRUE; + case BSIM4v7_MOD_TVFBSDOFF: + mod->BSIM4v7tvfbsdoff = value->rValue; + mod->BSIM4v7tvfbsdoffGiven = TRUE; break; - case BSIM4_MOD_LINTNOI: - mod->BSIM4lintnoi = value->rValue; - mod->BSIM4lintnoiGiven = TRUE; + case BSIM4v7_MOD_LINTNOI: + mod->BSIM4v7lintnoi = value->rValue; + mod->BSIM4v7lintnoiGiven = TRUE; break; /* stress effect */ - case BSIM4_MOD_SAREF : - mod->BSIM4saref = value->rValue; - mod->BSIM4sarefGiven = TRUE; + case BSIM4v7_MOD_SAREF : + mod->BSIM4v7saref = value->rValue; + mod->BSIM4v7sarefGiven = TRUE; break; - case BSIM4_MOD_SBREF : - mod->BSIM4sbref = value->rValue; - mod->BSIM4sbrefGiven = TRUE; + case BSIM4v7_MOD_SBREF : + mod->BSIM4v7sbref = value->rValue; + mod->BSIM4v7sbrefGiven = TRUE; break; - case BSIM4_MOD_WLOD : - mod->BSIM4wlod = value->rValue; - mod->BSIM4wlodGiven = TRUE; + case BSIM4v7_MOD_WLOD : + mod->BSIM4v7wlod = value->rValue; + mod->BSIM4v7wlodGiven = TRUE; break; - case BSIM4_MOD_KU0 : - mod->BSIM4ku0 = value->rValue; - mod->BSIM4ku0Given = TRUE; + case BSIM4v7_MOD_KU0 : + mod->BSIM4v7ku0 = value->rValue; + mod->BSIM4v7ku0Given = TRUE; break; - case BSIM4_MOD_KVSAT : - mod->BSIM4kvsat = value->rValue; - mod->BSIM4kvsatGiven = TRUE; + case BSIM4v7_MOD_KVSAT : + mod->BSIM4v7kvsat = value->rValue; + mod->BSIM4v7kvsatGiven = TRUE; break; - case BSIM4_MOD_KVTH0 : - mod->BSIM4kvth0 = value->rValue; - mod->BSIM4kvth0Given = TRUE; + case BSIM4v7_MOD_KVTH0 : + mod->BSIM4v7kvth0 = value->rValue; + mod->BSIM4v7kvth0Given = TRUE; break; - case BSIM4_MOD_TKU0 : - mod->BSIM4tku0 = value->rValue; - mod->BSIM4tku0Given = TRUE; + case BSIM4v7_MOD_TKU0 : + mod->BSIM4v7tku0 = value->rValue; + mod->BSIM4v7tku0Given = TRUE; break; - case BSIM4_MOD_LLODKU0 : - mod->BSIM4llodku0 = value->rValue; - mod->BSIM4llodku0Given = TRUE; + case BSIM4v7_MOD_LLODKU0 : + mod->BSIM4v7llodku0 = value->rValue; + mod->BSIM4v7llodku0Given = TRUE; break; - case BSIM4_MOD_WLODKU0 : - mod->BSIM4wlodku0 = value->rValue; - mod->BSIM4wlodku0Given = TRUE; + case BSIM4v7_MOD_WLODKU0 : + mod->BSIM4v7wlodku0 = value->rValue; + mod->BSIM4v7wlodku0Given = TRUE; break; - case BSIM4_MOD_LLODVTH : - mod->BSIM4llodvth = value->rValue; - mod->BSIM4llodvthGiven = TRUE; + case BSIM4v7_MOD_LLODVTH : + mod->BSIM4v7llodvth = value->rValue; + mod->BSIM4v7llodvthGiven = TRUE; break; - case BSIM4_MOD_WLODVTH : - mod->BSIM4wlodvth = value->rValue; - mod->BSIM4wlodvthGiven = TRUE; + case BSIM4v7_MOD_WLODVTH : + mod->BSIM4v7wlodvth = value->rValue; + mod->BSIM4v7wlodvthGiven = TRUE; break; - case BSIM4_MOD_LKU0 : - mod->BSIM4lku0 = value->rValue; - mod->BSIM4lku0Given = TRUE; + case BSIM4v7_MOD_LKU0 : + mod->BSIM4v7lku0 = value->rValue; + mod->BSIM4v7lku0Given = TRUE; break; - case BSIM4_MOD_WKU0 : - mod->BSIM4wku0 = value->rValue; - mod->BSIM4wku0Given = TRUE; + case BSIM4v7_MOD_WKU0 : + mod->BSIM4v7wku0 = value->rValue; + mod->BSIM4v7wku0Given = TRUE; break; - case BSIM4_MOD_PKU0 : - mod->BSIM4pku0 = value->rValue; - mod->BSIM4pku0Given = TRUE; + case BSIM4v7_MOD_PKU0 : + mod->BSIM4v7pku0 = value->rValue; + mod->BSIM4v7pku0Given = TRUE; break; - case BSIM4_MOD_LKVTH0 : - mod->BSIM4lkvth0 = value->rValue; - mod->BSIM4lkvth0Given = TRUE; + case BSIM4v7_MOD_LKVTH0 : + mod->BSIM4v7lkvth0 = value->rValue; + mod->BSIM4v7lkvth0Given = TRUE; break; - case BSIM4_MOD_WKVTH0 : - mod->BSIM4wkvth0 = value->rValue; - mod->BSIM4wkvth0Given = TRUE; + case BSIM4v7_MOD_WKVTH0 : + mod->BSIM4v7wkvth0 = value->rValue; + mod->BSIM4v7wkvth0Given = TRUE; break; - case BSIM4_MOD_PKVTH0 : - mod->BSIM4pkvth0 = value->rValue; - mod->BSIM4pkvth0Given = TRUE; + case BSIM4v7_MOD_PKVTH0 : + mod->BSIM4v7pkvth0 = value->rValue; + mod->BSIM4v7pkvth0Given = TRUE; break; - case BSIM4_MOD_STK2 : - mod->BSIM4stk2 = value->rValue; - mod->BSIM4stk2Given = TRUE; + case BSIM4v7_MOD_STK2 : + mod->BSIM4v7stk2 = value->rValue; + mod->BSIM4v7stk2Given = TRUE; break; - case BSIM4_MOD_LODK2 : - mod->BSIM4lodk2 = value->rValue; - mod->BSIM4lodk2Given = TRUE; + case BSIM4v7_MOD_LODK2 : + mod->BSIM4v7lodk2 = value->rValue; + mod->BSIM4v7lodk2Given = TRUE; break; - case BSIM4_MOD_STETA0 : - mod->BSIM4steta0 = value->rValue; - mod->BSIM4steta0Given = TRUE; + case BSIM4v7_MOD_STETA0 : + mod->BSIM4v7steta0 = value->rValue; + mod->BSIM4v7steta0Given = TRUE; break; - case BSIM4_MOD_LODETA0 : - mod->BSIM4lodeta0 = value->rValue; - mod->BSIM4lodeta0Given = TRUE; + case BSIM4v7_MOD_LODETA0 : + mod->BSIM4v7lodeta0 = value->rValue; + mod->BSIM4v7lodeta0Given = TRUE; break; - case BSIM4_MOD_WEB : - mod->BSIM4web = value->rValue; - mod->BSIM4webGiven = TRUE; + case BSIM4v7_MOD_WEB : + mod->BSIM4v7web = value->rValue; + mod->BSIM4v7webGiven = TRUE; break; - case BSIM4_MOD_WEC : - mod->BSIM4wec = value->rValue; - mod->BSIM4wecGiven = TRUE; + case BSIM4v7_MOD_WEC : + mod->BSIM4v7wec = value->rValue; + mod->BSIM4v7wecGiven = TRUE; break; - case BSIM4_MOD_KVTH0WE : - mod->BSIM4kvth0we = value->rValue; - mod->BSIM4kvth0weGiven = TRUE; + case BSIM4v7_MOD_KVTH0WE : + mod->BSIM4v7kvth0we = value->rValue; + mod->BSIM4v7kvth0weGiven = TRUE; break; - case BSIM4_MOD_K2WE : - mod->BSIM4k2we = value->rValue; - mod->BSIM4k2weGiven = TRUE; + case BSIM4v7_MOD_K2WE : + mod->BSIM4v7k2we = value->rValue; + mod->BSIM4v7k2weGiven = TRUE; break; - case BSIM4_MOD_KU0WE : - mod->BSIM4ku0we = value->rValue; - mod->BSIM4ku0weGiven = TRUE; + case BSIM4v7_MOD_KU0WE : + mod->BSIM4v7ku0we = value->rValue; + mod->BSIM4v7ku0weGiven = TRUE; break; - case BSIM4_MOD_SCREF : - mod->BSIM4scref = value->rValue; - mod->BSIM4screfGiven = TRUE; + case BSIM4v7_MOD_SCREF : + mod->BSIM4v7scref = value->rValue; + mod->BSIM4v7screfGiven = TRUE; break; - case BSIM4_MOD_WPEMOD : - mod->BSIM4wpemod = value->rValue; - mod->BSIM4wpemodGiven = TRUE; + case BSIM4v7_MOD_WPEMOD : + mod->BSIM4v7wpemod = value->rValue; + mod->BSIM4v7wpemodGiven = TRUE; break; - case BSIM4_MOD_LKVTH0WE : - mod->BSIM4lkvth0we = value->rValue; - mod->BSIM4lkvth0weGiven = TRUE; + case BSIM4v7_MOD_LKVTH0WE : + mod->BSIM4v7lkvth0we = value->rValue; + mod->BSIM4v7lkvth0weGiven = TRUE; break; - case BSIM4_MOD_LK2WE : - mod->BSIM4lk2we = value->rValue; - mod->BSIM4lk2weGiven = TRUE; + case BSIM4v7_MOD_LK2WE : + mod->BSIM4v7lk2we = value->rValue; + mod->BSIM4v7lk2weGiven = TRUE; break; - case BSIM4_MOD_LKU0WE : - mod->BSIM4lku0we = value->rValue; - mod->BSIM4lku0weGiven = TRUE; + case BSIM4v7_MOD_LKU0WE : + mod->BSIM4v7lku0we = value->rValue; + mod->BSIM4v7lku0weGiven = TRUE; break; - case BSIM4_MOD_WKVTH0WE : - mod->BSIM4wkvth0we = value->rValue; - mod->BSIM4wkvth0weGiven = TRUE; + case BSIM4v7_MOD_WKVTH0WE : + mod->BSIM4v7wkvth0we = value->rValue; + mod->BSIM4v7wkvth0weGiven = TRUE; break; - case BSIM4_MOD_WK2WE : - mod->BSIM4wk2we = value->rValue; - mod->BSIM4wk2weGiven = TRUE; + case BSIM4v7_MOD_WK2WE : + mod->BSIM4v7wk2we = value->rValue; + mod->BSIM4v7wk2weGiven = TRUE; break; - case BSIM4_MOD_WKU0WE : - mod->BSIM4wku0we = value->rValue; - mod->BSIM4wku0weGiven = TRUE; + case BSIM4v7_MOD_WKU0WE : + mod->BSIM4v7wku0we = value->rValue; + mod->BSIM4v7wku0weGiven = TRUE; break; - case BSIM4_MOD_PKVTH0WE : - mod->BSIM4pkvth0we = value->rValue; - mod->BSIM4pkvth0weGiven = TRUE; + case BSIM4v7_MOD_PKVTH0WE : + mod->BSIM4v7pkvth0we = value->rValue; + mod->BSIM4v7pkvth0weGiven = TRUE; break; - case BSIM4_MOD_PK2WE : - mod->BSIM4pk2we = value->rValue; - mod->BSIM4pk2weGiven = TRUE; + case BSIM4v7_MOD_PK2WE : + mod->BSIM4v7pk2we = value->rValue; + mod->BSIM4v7pk2weGiven = TRUE; break; - case BSIM4_MOD_PKU0WE : - mod->BSIM4pku0we = value->rValue; - mod->BSIM4pku0weGiven = TRUE; + case BSIM4v7_MOD_PKU0WE : + mod->BSIM4v7pku0we = value->rValue; + mod->BSIM4v7pku0weGiven = TRUE; break; - case BSIM4_MOD_BETA0 : - mod->BSIM4beta0 = value->rValue; - mod->BSIM4beta0Given = TRUE; + case BSIM4v7_MOD_BETA0 : + mod->BSIM4v7beta0 = value->rValue; + mod->BSIM4v7beta0Given = TRUE; break; - case BSIM4_MOD_IJTHDFWD : - mod->BSIM4ijthdfwd = value->rValue; - mod->BSIM4ijthdfwdGiven = TRUE; + case BSIM4v7_MOD_IJTHDFWD : + mod->BSIM4v7ijthdfwd = value->rValue; + mod->BSIM4v7ijthdfwdGiven = TRUE; break; - case BSIM4_MOD_IJTHSFWD : - mod->BSIM4ijthsfwd = value->rValue; - mod->BSIM4ijthsfwdGiven = TRUE; + case BSIM4v7_MOD_IJTHSFWD : + mod->BSIM4v7ijthsfwd = value->rValue; + mod->BSIM4v7ijthsfwdGiven = TRUE; break; - case BSIM4_MOD_IJTHDREV : - mod->BSIM4ijthdrev = value->rValue; - mod->BSIM4ijthdrevGiven = TRUE; + case BSIM4v7_MOD_IJTHDREV : + mod->BSIM4v7ijthdrev = value->rValue; + mod->BSIM4v7ijthdrevGiven = TRUE; break; - case BSIM4_MOD_IJTHSREV : - mod->BSIM4ijthsrev = value->rValue; - mod->BSIM4ijthsrevGiven = TRUE; + case BSIM4v7_MOD_IJTHSREV : + mod->BSIM4v7ijthsrev = value->rValue; + mod->BSIM4v7ijthsrevGiven = TRUE; break; - case BSIM4_MOD_XJBVD : - mod->BSIM4xjbvd = value->rValue; - mod->BSIM4xjbvdGiven = TRUE; + case BSIM4v7_MOD_XJBVD : + mod->BSIM4v7xjbvd = value->rValue; + mod->BSIM4v7xjbvdGiven = TRUE; break; - case BSIM4_MOD_XJBVS : - mod->BSIM4xjbvs = value->rValue; - mod->BSIM4xjbvsGiven = TRUE; + case BSIM4v7_MOD_XJBVS : + mod->BSIM4v7xjbvs = value->rValue; + mod->BSIM4v7xjbvsGiven = TRUE; break; - case BSIM4_MOD_BVD : - mod->BSIM4bvd = value->rValue; - mod->BSIM4bvdGiven = TRUE; + case BSIM4v7_MOD_BVD : + mod->BSIM4v7bvd = value->rValue; + mod->BSIM4v7bvdGiven = TRUE; break; - case BSIM4_MOD_BVS : - mod->BSIM4bvs = value->rValue; - mod->BSIM4bvsGiven = TRUE; + case BSIM4v7_MOD_BVS : + mod->BSIM4v7bvs = value->rValue; + mod->BSIM4v7bvsGiven = TRUE; break; /* reverse diode */ - case BSIM4_MOD_JTSS : - mod->BSIM4jtss = value->rValue; - mod->BSIM4jtssGiven = TRUE; + case BSIM4v7_MOD_JTSS : + mod->BSIM4v7jtss = value->rValue; + mod->BSIM4v7jtssGiven = TRUE; break; - case BSIM4_MOD_JTSD : - mod->BSIM4jtsd = value->rValue; - mod->BSIM4jtsdGiven = TRUE; + case BSIM4v7_MOD_JTSD : + mod->BSIM4v7jtsd = value->rValue; + mod->BSIM4v7jtsdGiven = TRUE; break; - case BSIM4_MOD_JTSSWS : - mod->BSIM4jtssws = value->rValue; - mod->BSIM4jtsswsGiven = TRUE; + case BSIM4v7_MOD_JTSSWS : + mod->BSIM4v7jtssws = value->rValue; + mod->BSIM4v7jtsswsGiven = TRUE; break; - case BSIM4_MOD_JTSSWD : - mod->BSIM4jtsswd = value->rValue; - mod->BSIM4jtsswdGiven = TRUE; + case BSIM4v7_MOD_JTSSWD : + mod->BSIM4v7jtsswd = value->rValue; + mod->BSIM4v7jtsswdGiven = TRUE; break; - case BSIM4_MOD_JTSSWGS : - mod->BSIM4jtsswgs = value->rValue; - mod->BSIM4jtsswgsGiven = TRUE; + case BSIM4v7_MOD_JTSSWGS : + mod->BSIM4v7jtsswgs = value->rValue; + mod->BSIM4v7jtsswgsGiven = TRUE; break; - case BSIM4_MOD_JTSSWGD : - mod->BSIM4jtsswgd = value->rValue; - mod->BSIM4jtsswgdGiven = TRUE; + case BSIM4v7_MOD_JTSSWGD : + mod->BSIM4v7jtsswgd = value->rValue; + mod->BSIM4v7jtsswgdGiven = TRUE; break; - case BSIM4_MOD_JTWEFF : - mod->BSIM4jtweff = value->rValue; - mod->BSIM4jtweffGiven = TRUE; + case BSIM4v7_MOD_JTWEFF : + mod->BSIM4v7jtweff = value->rValue; + mod->BSIM4v7jtweffGiven = TRUE; break; - case BSIM4_MOD_NJTS : - mod->BSIM4njts = value->rValue; - mod->BSIM4njtsGiven = TRUE; + case BSIM4v7_MOD_NJTS : + mod->BSIM4v7njts = value->rValue; + mod->BSIM4v7njtsGiven = TRUE; break; - case BSIM4_MOD_NJTSSW : - mod->BSIM4njtssw = value->rValue; - mod->BSIM4njtsswGiven = TRUE; + case BSIM4v7_MOD_NJTSSW : + mod->BSIM4v7njtssw = value->rValue; + mod->BSIM4v7njtsswGiven = TRUE; break; - case BSIM4_MOD_NJTSSWG : - mod->BSIM4njtsswg = value->rValue; - mod->BSIM4njtsswgGiven = TRUE; + case BSIM4v7_MOD_NJTSSWG : + mod->BSIM4v7njtsswg = value->rValue; + mod->BSIM4v7njtsswgGiven = TRUE; break; - case BSIM4_MOD_NJTSD : - mod->BSIM4njtsd = value->rValue; - mod->BSIM4njtsdGiven = TRUE; + case BSIM4v7_MOD_NJTSD : + mod->BSIM4v7njtsd = value->rValue; + mod->BSIM4v7njtsdGiven = TRUE; break; - case BSIM4_MOD_NJTSSWD : - mod->BSIM4njtsswd = value->rValue; - mod->BSIM4njtsswdGiven = TRUE; + case BSIM4v7_MOD_NJTSSWD : + mod->BSIM4v7njtsswd = value->rValue; + mod->BSIM4v7njtsswdGiven = TRUE; break; - case BSIM4_MOD_NJTSSWGD : - mod->BSIM4njtsswgd = value->rValue; - mod->BSIM4njtsswgdGiven = TRUE; + case BSIM4v7_MOD_NJTSSWGD : + mod->BSIM4v7njtsswgd = value->rValue; + mod->BSIM4v7njtsswgdGiven = TRUE; break; - case BSIM4_MOD_XTSS : - mod->BSIM4xtss = value->rValue; - mod->BSIM4xtssGiven = TRUE; + case BSIM4v7_MOD_XTSS : + mod->BSIM4v7xtss = value->rValue; + mod->BSIM4v7xtssGiven = TRUE; break; - case BSIM4_MOD_XTSD : - mod->BSIM4xtsd = value->rValue; - mod->BSIM4xtsdGiven = TRUE; + case BSIM4v7_MOD_XTSD : + mod->BSIM4v7xtsd = value->rValue; + mod->BSIM4v7xtsdGiven = TRUE; break; - case BSIM4_MOD_XTSSWS : - mod->BSIM4xtssws = value->rValue; - mod->BSIM4xtsswsGiven = TRUE; + case BSIM4v7_MOD_XTSSWS : + mod->BSIM4v7xtssws = value->rValue; + mod->BSIM4v7xtsswsGiven = TRUE; break; - case BSIM4_MOD_XTSSWD : - mod->BSIM4xtsswd = value->rValue; - mod->BSIM4xtsswdGiven = TRUE; + case BSIM4v7_MOD_XTSSWD : + mod->BSIM4v7xtsswd = value->rValue; + mod->BSIM4v7xtsswdGiven = TRUE; break; - case BSIM4_MOD_XTSSWGS : - mod->BSIM4xtsswgs = value->rValue; - mod->BSIM4xtsswgsGiven = TRUE; + case BSIM4v7_MOD_XTSSWGS : + mod->BSIM4v7xtsswgs = value->rValue; + mod->BSIM4v7xtsswgsGiven = TRUE; break; - case BSIM4_MOD_XTSSWGD : - mod->BSIM4xtsswgd = value->rValue; - mod->BSIM4xtsswgdGiven = TRUE; + case BSIM4v7_MOD_XTSSWGD : + mod->BSIM4v7xtsswgd = value->rValue; + mod->BSIM4v7xtsswgdGiven = TRUE; break; - case BSIM4_MOD_TNJTS : - mod->BSIM4tnjts = value->rValue; - mod->BSIM4tnjtsGiven = TRUE; + case BSIM4v7_MOD_TNJTS : + mod->BSIM4v7tnjts = value->rValue; + mod->BSIM4v7tnjtsGiven = TRUE; break; - case BSIM4_MOD_TNJTSSW : - mod->BSIM4tnjtssw = value->rValue; - mod->BSIM4tnjtsswGiven = TRUE; + case BSIM4v7_MOD_TNJTSSW : + mod->BSIM4v7tnjtssw = value->rValue; + mod->BSIM4v7tnjtsswGiven = TRUE; break; - case BSIM4_MOD_TNJTSSWG : - mod->BSIM4tnjtsswg = value->rValue; - mod->BSIM4tnjtsswgGiven = TRUE; + case BSIM4v7_MOD_TNJTSSWG : + mod->BSIM4v7tnjtsswg = value->rValue; + mod->BSIM4v7tnjtsswgGiven = TRUE; break; - case BSIM4_MOD_TNJTSD : - mod->BSIM4tnjtsd = value->rValue; - mod->BSIM4tnjtsdGiven = TRUE; + case BSIM4v7_MOD_TNJTSD : + mod->BSIM4v7tnjtsd = value->rValue; + mod->BSIM4v7tnjtsdGiven = TRUE; break; - case BSIM4_MOD_TNJTSSWD : - mod->BSIM4tnjtsswd = value->rValue; - mod->BSIM4tnjtsswdGiven = TRUE; + case BSIM4v7_MOD_TNJTSSWD : + mod->BSIM4v7tnjtsswd = value->rValue; + mod->BSIM4v7tnjtsswdGiven = TRUE; break; - case BSIM4_MOD_TNJTSSWGD : - mod->BSIM4tnjtsswgd = value->rValue; - mod->BSIM4tnjtsswgdGiven = TRUE; + case BSIM4v7_MOD_TNJTSSWGD : + mod->BSIM4v7tnjtsswgd = value->rValue; + mod->BSIM4v7tnjtsswgdGiven = TRUE; break; - case BSIM4_MOD_VTSS : - mod->BSIM4vtss = value->rValue; - mod->BSIM4vtssGiven = TRUE; + case BSIM4v7_MOD_VTSS : + mod->BSIM4v7vtss = value->rValue; + mod->BSIM4v7vtssGiven = TRUE; break; - case BSIM4_MOD_VTSD : - mod->BSIM4vtsd = value->rValue; - mod->BSIM4vtsdGiven = TRUE; + case BSIM4v7_MOD_VTSD : + mod->BSIM4v7vtsd = value->rValue; + mod->BSIM4v7vtsdGiven = TRUE; break; - case BSIM4_MOD_VTSSWS : - mod->BSIM4vtssws = value->rValue; - mod->BSIM4vtsswsGiven = TRUE; + case BSIM4v7_MOD_VTSSWS : + mod->BSIM4v7vtssws = value->rValue; + mod->BSIM4v7vtsswsGiven = TRUE; break; - case BSIM4_MOD_VTSSWD : - mod->BSIM4vtsswd = value->rValue; - mod->BSIM4vtsswdGiven = TRUE; + case BSIM4v7_MOD_VTSSWD : + mod->BSIM4v7vtsswd = value->rValue; + mod->BSIM4v7vtsswdGiven = TRUE; break; - case BSIM4_MOD_VTSSWGS : - mod->BSIM4vtsswgs = value->rValue; - mod->BSIM4vtsswgsGiven = TRUE; + case BSIM4v7_MOD_VTSSWGS : + mod->BSIM4v7vtsswgs = value->rValue; + mod->BSIM4v7vtsswgsGiven = TRUE; break; - case BSIM4_MOD_VTSSWGD : - mod->BSIM4vtsswgd = value->rValue; - mod->BSIM4vtsswgdGiven = TRUE; + case BSIM4v7_MOD_VTSSWGD : + mod->BSIM4v7vtsswgd = value->rValue; + mod->BSIM4v7vtsswgdGiven = TRUE; break; - case BSIM4_MOD_VFB : - mod->BSIM4vfb = value->rValue; - mod->BSIM4vfbGiven = TRUE; + case BSIM4v7_MOD_VFB : + mod->BSIM4v7vfb = value->rValue; + mod->BSIM4v7vfbGiven = TRUE; break; - case BSIM4_MOD_GBMIN : - mod->BSIM4gbmin = value->rValue; - mod->BSIM4gbminGiven = TRUE; + case BSIM4v7_MOD_GBMIN : + mod->BSIM4v7gbmin = value->rValue; + mod->BSIM4v7gbminGiven = TRUE; break; - case BSIM4_MOD_RBDB : - mod->BSIM4rbdb = value->rValue; - mod->BSIM4rbdbGiven = TRUE; + case BSIM4v7_MOD_RBDB : + mod->BSIM4v7rbdb = value->rValue; + mod->BSIM4v7rbdbGiven = TRUE; break; - case BSIM4_MOD_RBPB : - mod->BSIM4rbpb = value->rValue; - mod->BSIM4rbpbGiven = TRUE; + case BSIM4v7_MOD_RBPB : + mod->BSIM4v7rbpb = value->rValue; + mod->BSIM4v7rbpbGiven = TRUE; break; - case BSIM4_MOD_RBSB : - mod->BSIM4rbsb = value->rValue; - mod->BSIM4rbsbGiven = TRUE; + case BSIM4v7_MOD_RBSB : + mod->BSIM4v7rbsb = value->rValue; + mod->BSIM4v7rbsbGiven = TRUE; break; - case BSIM4_MOD_RBPS : - mod->BSIM4rbps = value->rValue; - mod->BSIM4rbpsGiven = TRUE; + case BSIM4v7_MOD_RBPS : + mod->BSIM4v7rbps = value->rValue; + mod->BSIM4v7rbpsGiven = TRUE; break; - case BSIM4_MOD_RBPD : - mod->BSIM4rbpd = value->rValue; - mod->BSIM4rbpdGiven = TRUE; + case BSIM4v7_MOD_RBPD : + mod->BSIM4v7rbpd = value->rValue; + mod->BSIM4v7rbpdGiven = TRUE; break; - case BSIM4_MOD_RBPS0 : - mod->BSIM4rbps0 = value->rValue; - mod->BSIM4rbps0Given = TRUE; + case BSIM4v7_MOD_RBPS0 : + mod->BSIM4v7rbps0 = value->rValue; + mod->BSIM4v7rbps0Given = TRUE; break; - case BSIM4_MOD_RBPSL : - mod->BSIM4rbpsl = value->rValue; - mod->BSIM4rbpslGiven = TRUE; + case BSIM4v7_MOD_RBPSL : + mod->BSIM4v7rbpsl = value->rValue; + mod->BSIM4v7rbpslGiven = TRUE; break; - case BSIM4_MOD_RBPSW : - mod->BSIM4rbpsw = value->rValue; - mod->BSIM4rbpswGiven = TRUE; + case BSIM4v7_MOD_RBPSW : + mod->BSIM4v7rbpsw = value->rValue; + mod->BSIM4v7rbpswGiven = TRUE; break; - case BSIM4_MOD_RBPSNF : - mod->BSIM4rbpsnf = value->rValue; - mod->BSIM4rbpsnfGiven = TRUE; + case BSIM4v7_MOD_RBPSNF : + mod->BSIM4v7rbpsnf = value->rValue; + mod->BSIM4v7rbpsnfGiven = TRUE; break; - case BSIM4_MOD_RBPD0 : - mod->BSIM4rbpd0 = value->rValue; - mod->BSIM4rbpd0Given = TRUE; + case BSIM4v7_MOD_RBPD0 : + mod->BSIM4v7rbpd0 = value->rValue; + mod->BSIM4v7rbpd0Given = TRUE; break; - case BSIM4_MOD_RBPDL : - mod->BSIM4rbpdl = value->rValue; - mod->BSIM4rbpdlGiven = TRUE; + case BSIM4v7_MOD_RBPDL : + mod->BSIM4v7rbpdl = value->rValue; + mod->BSIM4v7rbpdlGiven = TRUE; break; - case BSIM4_MOD_RBPDW : - mod->BSIM4rbpdw = value->rValue; - mod->BSIM4rbpdwGiven = TRUE; + case BSIM4v7_MOD_RBPDW : + mod->BSIM4v7rbpdw = value->rValue; + mod->BSIM4v7rbpdwGiven = TRUE; break; - case BSIM4_MOD_RBPDNF : - mod->BSIM4rbpdnf = value->rValue; - mod->BSIM4rbpdnfGiven = TRUE; + case BSIM4v7_MOD_RBPDNF : + mod->BSIM4v7rbpdnf = value->rValue; + mod->BSIM4v7rbpdnfGiven = TRUE; break; - case BSIM4_MOD_RBPBX0 : - mod->BSIM4rbpbx0 = value->rValue; - mod->BSIM4rbpbx0Given = TRUE; + case BSIM4v7_MOD_RBPBX0 : + mod->BSIM4v7rbpbx0 = value->rValue; + mod->BSIM4v7rbpbx0Given = TRUE; break; - case BSIM4_MOD_RBPBXL : - mod->BSIM4rbpbxl = value->rValue; - mod->BSIM4rbpbxlGiven = TRUE; + case BSIM4v7_MOD_RBPBXL : + mod->BSIM4v7rbpbxl = value->rValue; + mod->BSIM4v7rbpbxlGiven = TRUE; break; - case BSIM4_MOD_RBPBXW : - mod->BSIM4rbpbxw = value->rValue; - mod->BSIM4rbpbxwGiven = TRUE; + case BSIM4v7_MOD_RBPBXW : + mod->BSIM4v7rbpbxw = value->rValue; + mod->BSIM4v7rbpbxwGiven = TRUE; break; - case BSIM4_MOD_RBPBXNF : - mod->BSIM4rbpbxnf = value->rValue; - mod->BSIM4rbpbxnfGiven = TRUE; + case BSIM4v7_MOD_RBPBXNF : + mod->BSIM4v7rbpbxnf = value->rValue; + mod->BSIM4v7rbpbxnfGiven = TRUE; break; - case BSIM4_MOD_RBPBY0 : - mod->BSIM4rbpby0 = value->rValue; - mod->BSIM4rbpby0Given = TRUE; + case BSIM4v7_MOD_RBPBY0 : + mod->BSIM4v7rbpby0 = value->rValue; + mod->BSIM4v7rbpby0Given = TRUE; break; - case BSIM4_MOD_RBPBYL : - mod->BSIM4rbpbyl = value->rValue; - mod->BSIM4rbpbylGiven = TRUE; + case BSIM4v7_MOD_RBPBYL : + mod->BSIM4v7rbpbyl = value->rValue; + mod->BSIM4v7rbpbylGiven = TRUE; break; - case BSIM4_MOD_RBPBYW : - mod->BSIM4rbpbyw = value->rValue; - mod->BSIM4rbpbywGiven = TRUE; + case BSIM4v7_MOD_RBPBYW : + mod->BSIM4v7rbpbyw = value->rValue; + mod->BSIM4v7rbpbywGiven = TRUE; break; - case BSIM4_MOD_RBPBYNF : - mod->BSIM4rbpbynf = value->rValue; - mod->BSIM4rbpbynfGiven = TRUE; + case BSIM4v7_MOD_RBPBYNF : + mod->BSIM4v7rbpbynf = value->rValue; + mod->BSIM4v7rbpbynfGiven = TRUE; break; - case BSIM4_MOD_RBSBX0 : - mod->BSIM4rbsbx0 = value->rValue; - mod->BSIM4rbsbx0Given = TRUE; + case BSIM4v7_MOD_RBSBX0 : + mod->BSIM4v7rbsbx0 = value->rValue; + mod->BSIM4v7rbsbx0Given = TRUE; break; - case BSIM4_MOD_RBSBY0 : - mod->BSIM4rbsby0 = value->rValue; - mod->BSIM4rbsby0Given = TRUE; + case BSIM4v7_MOD_RBSBY0 : + mod->BSIM4v7rbsby0 = value->rValue; + mod->BSIM4v7rbsby0Given = TRUE; break; - case BSIM4_MOD_RBDBX0 : - mod->BSIM4rbdbx0 = value->rValue; - mod->BSIM4rbdbx0Given = TRUE; + case BSIM4v7_MOD_RBDBX0 : + mod->BSIM4v7rbdbx0 = value->rValue; + mod->BSIM4v7rbdbx0Given = TRUE; break; - case BSIM4_MOD_RBDBY0 : - mod->BSIM4rbdby0 = value->rValue; - mod->BSIM4rbdby0Given = TRUE; + case BSIM4v7_MOD_RBDBY0 : + mod->BSIM4v7rbdby0 = value->rValue; + mod->BSIM4v7rbdby0Given = TRUE; break; - case BSIM4_MOD_RBSDBXL : - mod->BSIM4rbsdbxl = value->rValue; - mod->BSIM4rbsdbxlGiven = TRUE; + case BSIM4v7_MOD_RBSDBXL : + mod->BSIM4v7rbsdbxl = value->rValue; + mod->BSIM4v7rbsdbxlGiven = TRUE; break; - case BSIM4_MOD_RBSDBXW : - mod->BSIM4rbsdbxw = value->rValue; - mod->BSIM4rbsdbxwGiven = TRUE; + case BSIM4v7_MOD_RBSDBXW : + mod->BSIM4v7rbsdbxw = value->rValue; + mod->BSIM4v7rbsdbxwGiven = TRUE; break; - case BSIM4_MOD_RBSDBXNF : - mod->BSIM4rbsdbxnf = value->rValue; - mod->BSIM4rbsdbxnfGiven = TRUE; + case BSIM4v7_MOD_RBSDBXNF : + mod->BSIM4v7rbsdbxnf = value->rValue; + mod->BSIM4v7rbsdbxnfGiven = TRUE; break; - case BSIM4_MOD_RBSDBYL : - mod->BSIM4rbsdbyl = value->rValue; - mod->BSIM4rbsdbylGiven = TRUE; + case BSIM4v7_MOD_RBSDBYL : + mod->BSIM4v7rbsdbyl = value->rValue; + mod->BSIM4v7rbsdbylGiven = TRUE; break; - case BSIM4_MOD_RBSDBYW : - mod->BSIM4rbsdbyw = value->rValue; - mod->BSIM4rbsdbywGiven = TRUE; + case BSIM4v7_MOD_RBSDBYW : + mod->BSIM4v7rbsdbyw = value->rValue; + mod->BSIM4v7rbsdbywGiven = TRUE; break; - case BSIM4_MOD_RBSDBYNF : - mod->BSIM4rbsdbynf = value->rValue; - mod->BSIM4rbsdbynfGiven = TRUE; + case BSIM4v7_MOD_RBSDBYNF : + mod->BSIM4v7rbsdbynf = value->rValue; + mod->BSIM4v7rbsdbynfGiven = TRUE; break; - case BSIM4_MOD_CGSL : - mod->BSIM4cgsl = value->rValue; - mod->BSIM4cgslGiven = TRUE; + case BSIM4v7_MOD_CGSL : + mod->BSIM4v7cgsl = value->rValue; + mod->BSIM4v7cgslGiven = TRUE; break; - case BSIM4_MOD_CGDL : - mod->BSIM4cgdl = value->rValue; - mod->BSIM4cgdlGiven = TRUE; + case BSIM4v7_MOD_CGDL : + mod->BSIM4v7cgdl = value->rValue; + mod->BSIM4v7cgdlGiven = TRUE; break; - case BSIM4_MOD_CKAPPAS : - mod->BSIM4ckappas = value->rValue; - mod->BSIM4ckappasGiven = TRUE; + case BSIM4v7_MOD_CKAPPAS : + mod->BSIM4v7ckappas = value->rValue; + mod->BSIM4v7ckappasGiven = TRUE; break; - case BSIM4_MOD_CKAPPAD : - mod->BSIM4ckappad = value->rValue; - mod->BSIM4ckappadGiven = TRUE; + case BSIM4v7_MOD_CKAPPAD : + mod->BSIM4v7ckappad = value->rValue; + mod->BSIM4v7ckappadGiven = TRUE; break; - case BSIM4_MOD_CF : - mod->BSIM4cf = value->rValue; - mod->BSIM4cfGiven = TRUE; + case BSIM4v7_MOD_CF : + mod->BSIM4v7cf = value->rValue; + mod->BSIM4v7cfGiven = TRUE; break; - case BSIM4_MOD_CLC : - mod->BSIM4clc = value->rValue; - mod->BSIM4clcGiven = TRUE; + case BSIM4v7_MOD_CLC : + mod->BSIM4v7clc = value->rValue; + mod->BSIM4v7clcGiven = TRUE; break; - case BSIM4_MOD_CLE : - mod->BSIM4cle = value->rValue; - mod->BSIM4cleGiven = TRUE; + case BSIM4v7_MOD_CLE : + mod->BSIM4v7cle = value->rValue; + mod->BSIM4v7cleGiven = TRUE; break; - case BSIM4_MOD_DWC : - mod->BSIM4dwc = value->rValue; - mod->BSIM4dwcGiven = TRUE; + case BSIM4v7_MOD_DWC : + mod->BSIM4v7dwc = value->rValue; + mod->BSIM4v7dwcGiven = TRUE; break; - case BSIM4_MOD_DLC : - mod->BSIM4dlc = value->rValue; - mod->BSIM4dlcGiven = TRUE; + case BSIM4v7_MOD_DLC : + mod->BSIM4v7dlc = value->rValue; + mod->BSIM4v7dlcGiven = TRUE; break; - case BSIM4_MOD_XW : - mod->BSIM4xw = value->rValue; - mod->BSIM4xwGiven = TRUE; + case BSIM4v7_MOD_XW : + mod->BSIM4v7xw = value->rValue; + mod->BSIM4v7xwGiven = TRUE; break; - case BSIM4_MOD_XL : - mod->BSIM4xl = value->rValue; - mod->BSIM4xlGiven = TRUE; + case BSIM4v7_MOD_XL : + mod->BSIM4v7xl = value->rValue; + mod->BSIM4v7xlGiven = TRUE; break; - case BSIM4_MOD_DLCIG : - mod->BSIM4dlcig = value->rValue; - mod->BSIM4dlcigGiven = TRUE; + case BSIM4v7_MOD_DLCIG : + mod->BSIM4v7dlcig = value->rValue; + mod->BSIM4v7dlcigGiven = TRUE; break; - case BSIM4_MOD_DLCIGD : - mod->BSIM4dlcigd = value->rValue; - mod->BSIM4dlcigdGiven = TRUE; + case BSIM4v7_MOD_DLCIGD : + mod->BSIM4v7dlcigd = value->rValue; + mod->BSIM4v7dlcigdGiven = TRUE; break; - case BSIM4_MOD_DWJ : - mod->BSIM4dwj = value->rValue; - mod->BSIM4dwjGiven = TRUE; + case BSIM4v7_MOD_DWJ : + mod->BSIM4v7dwj = value->rValue; + mod->BSIM4v7dwjGiven = TRUE; break; - case BSIM4_MOD_VFBCV : - mod->BSIM4vfbcv = value->rValue; - mod->BSIM4vfbcvGiven = TRUE; + case BSIM4v7_MOD_VFBCV : + mod->BSIM4v7vfbcv = value->rValue; + mod->BSIM4v7vfbcvGiven = TRUE; break; - case BSIM4_MOD_ACDE : - mod->BSIM4acde = value->rValue; - mod->BSIM4acdeGiven = TRUE; + case BSIM4v7_MOD_ACDE : + mod->BSIM4v7acde = value->rValue; + mod->BSIM4v7acdeGiven = TRUE; break; - case BSIM4_MOD_MOIN : - mod->BSIM4moin = value->rValue; - mod->BSIM4moinGiven = TRUE; + case BSIM4v7_MOD_MOIN : + mod->BSIM4v7moin = value->rValue; + mod->BSIM4v7moinGiven = TRUE; break; - case BSIM4_MOD_NOFF : - mod->BSIM4noff = value->rValue; - mod->BSIM4noffGiven = TRUE; + case BSIM4v7_MOD_NOFF : + mod->BSIM4v7noff = value->rValue; + mod->BSIM4v7noffGiven = TRUE; break; - case BSIM4_MOD_VOFFCV : - mod->BSIM4voffcv = value->rValue; - mod->BSIM4voffcvGiven = TRUE; + case BSIM4v7_MOD_VOFFCV : + mod->BSIM4v7voffcv = value->rValue; + mod->BSIM4v7voffcvGiven = TRUE; break; - case BSIM4_MOD_DMCG : - mod->BSIM4dmcg = value->rValue; - mod->BSIM4dmcgGiven = TRUE; + case BSIM4v7_MOD_DMCG : + mod->BSIM4v7dmcg = value->rValue; + mod->BSIM4v7dmcgGiven = TRUE; break; - case BSIM4_MOD_DMCI : - mod->BSIM4dmci = value->rValue; - mod->BSIM4dmciGiven = TRUE; + case BSIM4v7_MOD_DMCI : + mod->BSIM4v7dmci = value->rValue; + mod->BSIM4v7dmciGiven = TRUE; break; - case BSIM4_MOD_DMDG : - mod->BSIM4dmdg = value->rValue; - mod->BSIM4dmdgGiven = TRUE; + case BSIM4v7_MOD_DMDG : + mod->BSIM4v7dmdg = value->rValue; + mod->BSIM4v7dmdgGiven = TRUE; break; - case BSIM4_MOD_DMCGT : - mod->BSIM4dmcgt = value->rValue; - mod->BSIM4dmcgtGiven = TRUE; + case BSIM4v7_MOD_DMCGT : + mod->BSIM4v7dmcgt = value->rValue; + mod->BSIM4v7dmcgtGiven = TRUE; break; - case BSIM4_MOD_XGW : - mod->BSIM4xgw = value->rValue; - mod->BSIM4xgwGiven = TRUE; + case BSIM4v7_MOD_XGW : + mod->BSIM4v7xgw = value->rValue; + mod->BSIM4v7xgwGiven = TRUE; break; - case BSIM4_MOD_XGL : - mod->BSIM4xgl = value->rValue; - mod->BSIM4xglGiven = TRUE; + case BSIM4v7_MOD_XGL : + mod->BSIM4v7xgl = value->rValue; + mod->BSIM4v7xglGiven = TRUE; break; - case BSIM4_MOD_RSHG : - mod->BSIM4rshg = value->rValue; - mod->BSIM4rshgGiven = TRUE; + case BSIM4v7_MOD_RSHG : + mod->BSIM4v7rshg = value->rValue; + mod->BSIM4v7rshgGiven = TRUE; break; - case BSIM4_MOD_NGCON : - mod->BSIM4ngcon = value->rValue; - mod->BSIM4ngconGiven = TRUE; + case BSIM4v7_MOD_NGCON : + mod->BSIM4v7ngcon = value->rValue; + mod->BSIM4v7ngconGiven = TRUE; break; - case BSIM4_MOD_TCJ : - mod->BSIM4tcj = value->rValue; - mod->BSIM4tcjGiven = TRUE; + case BSIM4v7_MOD_TCJ : + mod->BSIM4v7tcj = value->rValue; + mod->BSIM4v7tcjGiven = TRUE; break; - case BSIM4_MOD_TPB : - mod->BSIM4tpb = value->rValue; - mod->BSIM4tpbGiven = TRUE; + case BSIM4v7_MOD_TPB : + mod->BSIM4v7tpb = value->rValue; + mod->BSIM4v7tpbGiven = TRUE; break; - case BSIM4_MOD_TCJSW : - mod->BSIM4tcjsw = value->rValue; - mod->BSIM4tcjswGiven = TRUE; + case BSIM4v7_MOD_TCJSW : + mod->BSIM4v7tcjsw = value->rValue; + mod->BSIM4v7tcjswGiven = TRUE; break; - case BSIM4_MOD_TPBSW : - mod->BSIM4tpbsw = value->rValue; - mod->BSIM4tpbswGiven = TRUE; + case BSIM4v7_MOD_TPBSW : + mod->BSIM4v7tpbsw = value->rValue; + mod->BSIM4v7tpbswGiven = TRUE; break; - case BSIM4_MOD_TCJSWG : - mod->BSIM4tcjswg = value->rValue; - mod->BSIM4tcjswgGiven = TRUE; + case BSIM4v7_MOD_TCJSWG : + mod->BSIM4v7tcjswg = value->rValue; + mod->BSIM4v7tcjswgGiven = TRUE; break; - case BSIM4_MOD_TPBSWG : - mod->BSIM4tpbswg = value->rValue; - mod->BSIM4tpbswgGiven = TRUE; + case BSIM4v7_MOD_TPBSWG : + mod->BSIM4v7tpbswg = value->rValue; + mod->BSIM4v7tpbswgGiven = TRUE; break; /* Length dependence */ - case BSIM4_MOD_LCDSC : - mod->BSIM4lcdsc = value->rValue; - mod->BSIM4lcdscGiven = TRUE; + case BSIM4v7_MOD_LCDSC : + mod->BSIM4v7lcdsc = value->rValue; + mod->BSIM4v7lcdscGiven = TRUE; break; - case BSIM4_MOD_LCDSCB : - mod->BSIM4lcdscb = value->rValue; - mod->BSIM4lcdscbGiven = TRUE; + case BSIM4v7_MOD_LCDSCB : + mod->BSIM4v7lcdscb = value->rValue; + mod->BSIM4v7lcdscbGiven = TRUE; break; - case BSIM4_MOD_LCDSCD : - mod->BSIM4lcdscd = value->rValue; - mod->BSIM4lcdscdGiven = TRUE; + case BSIM4v7_MOD_LCDSCD : + mod->BSIM4v7lcdscd = value->rValue; + mod->BSIM4v7lcdscdGiven = TRUE; break; - case BSIM4_MOD_LCIT : - mod->BSIM4lcit = value->rValue; - mod->BSIM4lcitGiven = TRUE; + case BSIM4v7_MOD_LCIT : + mod->BSIM4v7lcit = value->rValue; + mod->BSIM4v7lcitGiven = TRUE; break; - case BSIM4_MOD_LNFACTOR : - mod->BSIM4lnfactor = value->rValue; - mod->BSIM4lnfactorGiven = TRUE; + case BSIM4v7_MOD_LNFACTOR : + mod->BSIM4v7lnfactor = value->rValue; + mod->BSIM4v7lnfactorGiven = TRUE; break; - case BSIM4_MOD_LXJ: - mod->BSIM4lxj = value->rValue; - mod->BSIM4lxjGiven = TRUE; + case BSIM4v7_MOD_LXJ: + mod->BSIM4v7lxj = value->rValue; + mod->BSIM4v7lxjGiven = TRUE; break; - case BSIM4_MOD_LVSAT: - mod->BSIM4lvsat = value->rValue; - mod->BSIM4lvsatGiven = TRUE; + case BSIM4v7_MOD_LVSAT: + mod->BSIM4v7lvsat = value->rValue; + mod->BSIM4v7lvsatGiven = TRUE; break; - case BSIM4_MOD_LA0: - mod->BSIM4la0 = value->rValue; - mod->BSIM4la0Given = TRUE; + case BSIM4v7_MOD_LA0: + mod->BSIM4v7la0 = value->rValue; + mod->BSIM4v7la0Given = TRUE; break; - case BSIM4_MOD_LAGS: - mod->BSIM4lags = value->rValue; - mod->BSIM4lagsGiven = TRUE; + case BSIM4v7_MOD_LAGS: + mod->BSIM4v7lags = value->rValue; + mod->BSIM4v7lagsGiven = TRUE; break; - case BSIM4_MOD_LA1: - mod->BSIM4la1 = value->rValue; - mod->BSIM4la1Given = TRUE; + case BSIM4v7_MOD_LA1: + mod->BSIM4v7la1 = value->rValue; + mod->BSIM4v7la1Given = TRUE; break; - case BSIM4_MOD_LA2: - mod->BSIM4la2 = value->rValue; - mod->BSIM4la2Given = TRUE; + case BSIM4v7_MOD_LA2: + mod->BSIM4v7la2 = value->rValue; + mod->BSIM4v7la2Given = TRUE; break; - case BSIM4_MOD_LAT: - mod->BSIM4lat = value->rValue; - mod->BSIM4latGiven = TRUE; + case BSIM4v7_MOD_LAT: + mod->BSIM4v7lat = value->rValue; + mod->BSIM4v7latGiven = TRUE; break; - case BSIM4_MOD_LKETA: - mod->BSIM4lketa = value->rValue; - mod->BSIM4lketaGiven = TRUE; + case BSIM4v7_MOD_LKETA: + mod->BSIM4v7lketa = value->rValue; + mod->BSIM4v7lketaGiven = TRUE; break; - case BSIM4_MOD_LNSUB: - mod->BSIM4lnsub = value->rValue; - mod->BSIM4lnsubGiven = TRUE; + case BSIM4v7_MOD_LNSUB: + mod->BSIM4v7lnsub = value->rValue; + mod->BSIM4v7lnsubGiven = TRUE; break; - case BSIM4_MOD_LNDEP: - mod->BSIM4lndep = value->rValue; - mod->BSIM4lndepGiven = TRUE; - if (mod->BSIM4lndep > 1.0e20) - mod->BSIM4lndep *= 1.0e-6; + case BSIM4v7_MOD_LNDEP: + mod->BSIM4v7lndep = value->rValue; + mod->BSIM4v7lndepGiven = TRUE; + if (mod->BSIM4v7lndep > 1.0e20) + mod->BSIM4v7lndep *= 1.0e-6; break; - case BSIM4_MOD_LNSD: - mod->BSIM4lnsd = value->rValue; - mod->BSIM4lnsdGiven = TRUE; - if (mod->BSIM4lnsd > 1.0e23) - mod->BSIM4lnsd *= 1.0e-6; + case BSIM4v7_MOD_LNSD: + mod->BSIM4v7lnsd = value->rValue; + mod->BSIM4v7lnsdGiven = TRUE; + if (mod->BSIM4v7lnsd > 1.0e23) + mod->BSIM4v7lnsd *= 1.0e-6; break; - case BSIM4_MOD_LNGATE: - mod->BSIM4lngate = value->rValue; - mod->BSIM4lngateGiven = TRUE; - if (mod->BSIM4lngate > 1.0e23) - mod->BSIM4lngate *= 1.0e-6; + case BSIM4v7_MOD_LNGATE: + mod->BSIM4v7lngate = value->rValue; + mod->BSIM4v7lngateGiven = TRUE; + if (mod->BSIM4v7lngate > 1.0e23) + mod->BSIM4v7lngate *= 1.0e-6; break; - case BSIM4_MOD_LGAMMA1: - mod->BSIM4lgamma1 = value->rValue; - mod->BSIM4lgamma1Given = TRUE; + case BSIM4v7_MOD_LGAMMA1: + mod->BSIM4v7lgamma1 = value->rValue; + mod->BSIM4v7lgamma1Given = TRUE; break; - case BSIM4_MOD_LGAMMA2: - mod->BSIM4lgamma2 = value->rValue; - mod->BSIM4lgamma2Given = TRUE; + case BSIM4v7_MOD_LGAMMA2: + mod->BSIM4v7lgamma2 = value->rValue; + mod->BSIM4v7lgamma2Given = TRUE; break; - case BSIM4_MOD_LVBX: - mod->BSIM4lvbx = value->rValue; - mod->BSIM4lvbxGiven = TRUE; + case BSIM4v7_MOD_LVBX: + mod->BSIM4v7lvbx = value->rValue; + mod->BSIM4v7lvbxGiven = TRUE; break; - case BSIM4_MOD_LVBM: - mod->BSIM4lvbm = value->rValue; - mod->BSIM4lvbmGiven = TRUE; + case BSIM4v7_MOD_LVBM: + mod->BSIM4v7lvbm = value->rValue; + mod->BSIM4v7lvbmGiven = TRUE; break; - case BSIM4_MOD_LXT: - mod->BSIM4lxt = value->rValue; - mod->BSIM4lxtGiven = TRUE; + case BSIM4v7_MOD_LXT: + mod->BSIM4v7lxt = value->rValue; + mod->BSIM4v7lxtGiven = TRUE; break; - case BSIM4_MOD_LK1: - mod->BSIM4lk1 = value->rValue; - mod->BSIM4lk1Given = TRUE; + case BSIM4v7_MOD_LK1: + mod->BSIM4v7lk1 = value->rValue; + mod->BSIM4v7lk1Given = TRUE; break; - case BSIM4_MOD_LKT1: - mod->BSIM4lkt1 = value->rValue; - mod->BSIM4lkt1Given = TRUE; + case BSIM4v7_MOD_LKT1: + mod->BSIM4v7lkt1 = value->rValue; + mod->BSIM4v7lkt1Given = TRUE; break; - case BSIM4_MOD_LKT1L: - mod->BSIM4lkt1l = value->rValue; - mod->BSIM4lkt1lGiven = TRUE; + case BSIM4v7_MOD_LKT1L: + mod->BSIM4v7lkt1l = value->rValue; + mod->BSIM4v7lkt1lGiven = TRUE; break; - case BSIM4_MOD_LKT2: - mod->BSIM4lkt2 = value->rValue; - mod->BSIM4lkt2Given = TRUE; + case BSIM4v7_MOD_LKT2: + mod->BSIM4v7lkt2 = value->rValue; + mod->BSIM4v7lkt2Given = TRUE; break; - case BSIM4_MOD_LK2: - mod->BSIM4lk2 = value->rValue; - mod->BSIM4lk2Given = TRUE; + case BSIM4v7_MOD_LK2: + mod->BSIM4v7lk2 = value->rValue; + mod->BSIM4v7lk2Given = TRUE; break; - case BSIM4_MOD_LK3: - mod->BSIM4lk3 = value->rValue; - mod->BSIM4lk3Given = TRUE; + case BSIM4v7_MOD_LK3: + mod->BSIM4v7lk3 = value->rValue; + mod->BSIM4v7lk3Given = TRUE; break; - case BSIM4_MOD_LK3B: - mod->BSIM4lk3b = value->rValue; - mod->BSIM4lk3bGiven = TRUE; + case BSIM4v7_MOD_LK3B: + mod->BSIM4v7lk3b = value->rValue; + mod->BSIM4v7lk3bGiven = TRUE; break; - case BSIM4_MOD_LLPE0: - mod->BSIM4llpe0 = value->rValue; - mod->BSIM4llpe0Given = TRUE; + case BSIM4v7_MOD_LLPE0: + mod->BSIM4v7llpe0 = value->rValue; + mod->BSIM4v7llpe0Given = TRUE; break; - case BSIM4_MOD_LLPEB: - mod->BSIM4llpeb = value->rValue; - mod->BSIM4llpebGiven = TRUE; + case BSIM4v7_MOD_LLPEB: + mod->BSIM4v7llpeb = value->rValue; + mod->BSIM4v7llpebGiven = TRUE; break; - case BSIM4_MOD_LDVTP0: - mod->BSIM4ldvtp0 = value->rValue; - mod->BSIM4ldvtp0Given = TRUE; + case BSIM4v7_MOD_LDVTP0: + mod->BSIM4v7ldvtp0 = value->rValue; + mod->BSIM4v7ldvtp0Given = TRUE; break; - case BSIM4_MOD_LDVTP1: - mod->BSIM4ldvtp1 = value->rValue; - mod->BSIM4ldvtp1Given = TRUE; + case BSIM4v7_MOD_LDVTP1: + mod->BSIM4v7ldvtp1 = value->rValue; + mod->BSIM4v7ldvtp1Given = TRUE; break; - case BSIM4_MOD_LDVTP2: /* New DIBL/Rout */ - mod->BSIM4ldvtp2 = value->rValue; - mod->BSIM4ldvtp2Given = TRUE; + case BSIM4v7_MOD_LDVTP2: /* New DIBL/Rout */ + mod->BSIM4v7ldvtp2 = value->rValue; + mod->BSIM4v7ldvtp2Given = TRUE; break; - case BSIM4_MOD_LDVTP3: - mod->BSIM4ldvtp3 = value->rValue; - mod->BSIM4ldvtp3Given = TRUE; + case BSIM4v7_MOD_LDVTP3: + mod->BSIM4v7ldvtp3 = value->rValue; + mod->BSIM4v7ldvtp3Given = TRUE; break; - case BSIM4_MOD_LDVTP4: - mod->BSIM4ldvtp4 = value->rValue; - mod->BSIM4ldvtp4Given = TRUE; + case BSIM4v7_MOD_LDVTP4: + mod->BSIM4v7ldvtp4 = value->rValue; + mod->BSIM4v7ldvtp4Given = TRUE; break; - case BSIM4_MOD_LDVTP5: - mod->BSIM4ldvtp5 = value->rValue; - mod->BSIM4ldvtp5Given = TRUE; + case BSIM4v7_MOD_LDVTP5: + mod->BSIM4v7ldvtp5 = value->rValue; + mod->BSIM4v7ldvtp5Given = TRUE; break; - case BSIM4_MOD_LW0: - mod->BSIM4lw0 = value->rValue; - mod->BSIM4lw0Given = TRUE; + case BSIM4v7_MOD_LW0: + mod->BSIM4v7lw0 = value->rValue; + mod->BSIM4v7lw0Given = TRUE; break; - case BSIM4_MOD_LDVT0: - mod->BSIM4ldvt0 = value->rValue; - mod->BSIM4ldvt0Given = TRUE; + case BSIM4v7_MOD_LDVT0: + mod->BSIM4v7ldvt0 = value->rValue; + mod->BSIM4v7ldvt0Given = TRUE; break; - case BSIM4_MOD_LDVT1: - mod->BSIM4ldvt1 = value->rValue; - mod->BSIM4ldvt1Given = TRUE; + case BSIM4v7_MOD_LDVT1: + mod->BSIM4v7ldvt1 = value->rValue; + mod->BSIM4v7ldvt1Given = TRUE; break; - case BSIM4_MOD_LDVT2: - mod->BSIM4ldvt2 = value->rValue; - mod->BSIM4ldvt2Given = TRUE; + case BSIM4v7_MOD_LDVT2: + mod->BSIM4v7ldvt2 = value->rValue; + mod->BSIM4v7ldvt2Given = TRUE; break; - case BSIM4_MOD_LDVT0W: - mod->BSIM4ldvt0w = value->rValue; - mod->BSIM4ldvt0wGiven = TRUE; + case BSIM4v7_MOD_LDVT0W: + mod->BSIM4v7ldvt0w = value->rValue; + mod->BSIM4v7ldvt0wGiven = TRUE; break; - case BSIM4_MOD_LDVT1W: - mod->BSIM4ldvt1w = value->rValue; - mod->BSIM4ldvt1wGiven = TRUE; + case BSIM4v7_MOD_LDVT1W: + mod->BSIM4v7ldvt1w = value->rValue; + mod->BSIM4v7ldvt1wGiven = TRUE; break; - case BSIM4_MOD_LDVT2W: - mod->BSIM4ldvt2w = value->rValue; - mod->BSIM4ldvt2wGiven = TRUE; + case BSIM4v7_MOD_LDVT2W: + mod->BSIM4v7ldvt2w = value->rValue; + mod->BSIM4v7ldvt2wGiven = TRUE; break; - case BSIM4_MOD_LDROUT: - mod->BSIM4ldrout = value->rValue; - mod->BSIM4ldroutGiven = TRUE; + case BSIM4v7_MOD_LDROUT: + mod->BSIM4v7ldrout = value->rValue; + mod->BSIM4v7ldroutGiven = TRUE; break; - case BSIM4_MOD_LDSUB: - mod->BSIM4ldsub = value->rValue; - mod->BSIM4ldsubGiven = TRUE; + case BSIM4v7_MOD_LDSUB: + mod->BSIM4v7ldsub = value->rValue; + mod->BSIM4v7ldsubGiven = TRUE; break; - case BSIM4_MOD_LVTH0: - mod->BSIM4lvth0 = value->rValue; - mod->BSIM4lvth0Given = TRUE; + case BSIM4v7_MOD_LVTH0: + mod->BSIM4v7lvth0 = value->rValue; + mod->BSIM4v7lvth0Given = TRUE; break; - case BSIM4_MOD_LUA: - mod->BSIM4lua = value->rValue; - mod->BSIM4luaGiven = TRUE; + case BSIM4v7_MOD_LUA: + mod->BSIM4v7lua = value->rValue; + mod->BSIM4v7luaGiven = TRUE; break; - case BSIM4_MOD_LUA1: - mod->BSIM4lua1 = value->rValue; - mod->BSIM4lua1Given = TRUE; + case BSIM4v7_MOD_LUA1: + mod->BSIM4v7lua1 = value->rValue; + mod->BSIM4v7lua1Given = TRUE; break; - case BSIM4_MOD_LUB: - mod->BSIM4lub = value->rValue; - mod->BSIM4lubGiven = TRUE; + case BSIM4v7_MOD_LUB: + mod->BSIM4v7lub = value->rValue; + mod->BSIM4v7lubGiven = TRUE; break; - case BSIM4_MOD_LUB1: - mod->BSIM4lub1 = value->rValue; - mod->BSIM4lub1Given = TRUE; + case BSIM4v7_MOD_LUB1: + mod->BSIM4v7lub1 = value->rValue; + mod->BSIM4v7lub1Given = TRUE; break; - case BSIM4_MOD_LUC: - mod->BSIM4luc = value->rValue; - mod->BSIM4lucGiven = TRUE; + case BSIM4v7_MOD_LUC: + mod->BSIM4v7luc = value->rValue; + mod->BSIM4v7lucGiven = TRUE; break; - case BSIM4_MOD_LUC1: - mod->BSIM4luc1 = value->rValue; - mod->BSIM4luc1Given = TRUE; + case BSIM4v7_MOD_LUC1: + mod->BSIM4v7luc1 = value->rValue; + mod->BSIM4v7luc1Given = TRUE; break; - case BSIM4_MOD_LU0 : - mod->BSIM4lu0 = value->rValue; - mod->BSIM4lu0Given = TRUE; + case BSIM4v7_MOD_LU0 : + mod->BSIM4v7lu0 = value->rValue; + mod->BSIM4v7lu0Given = TRUE; break; - case BSIM4_MOD_LUTE : - mod->BSIM4lute = value->rValue; - mod->BSIM4luteGiven = TRUE; + case BSIM4v7_MOD_LUTE : + mod->BSIM4v7lute = value->rValue; + mod->BSIM4v7luteGiven = TRUE; break; - case BSIM4_MOD_LUCSTE : - mod->BSIM4lucste = value->rValue; - mod->BSIM4lucsteGiven = TRUE; + case BSIM4v7_MOD_LUCSTE : + mod->BSIM4v7lucste = value->rValue; + mod->BSIM4v7lucsteGiven = TRUE; break; - case BSIM4_MOD_LVOFF: - mod->BSIM4lvoff = value->rValue; - mod->BSIM4lvoffGiven = TRUE; + case BSIM4v7_MOD_LVOFF: + mod->BSIM4v7lvoff = value->rValue; + mod->BSIM4v7lvoffGiven = TRUE; break; - case BSIM4_MOD_LTVOFF: - mod->BSIM4ltvoff = value->rValue; - mod->BSIM4ltvoffGiven = TRUE; + case BSIM4v7_MOD_LTVOFF: + mod->BSIM4v7ltvoff = value->rValue; + mod->BSIM4v7ltvoffGiven = TRUE; break; - case BSIM4_MOD_LTNFACTOR: /* v4.7 temp dep of leakage current */ - mod->BSIM4ltnfactor = value->rValue; - mod->BSIM4ltnfactorGiven = TRUE; + case BSIM4v7_MOD_LTNFACTOR: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7ltnfactor = value->rValue; + mod->BSIM4v7ltnfactorGiven = TRUE; break; - case BSIM4_MOD_LTETA0: /* v4.7 temp dep of leakage current */ - mod->BSIM4lteta0 = value->rValue; - mod->BSIM4lteta0Given = TRUE; + case BSIM4v7_MOD_LTETA0: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7lteta0 = value->rValue; + mod->BSIM4v7lteta0Given = TRUE; break; - case BSIM4_MOD_LTVOFFCV: /* v4.7 temp dep of leakage current */ - mod->BSIM4ltvoffcv = value->rValue; - mod->BSIM4ltvoffcvGiven = TRUE; + case BSIM4v7_MOD_LTVOFFCV: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7ltvoffcv = value->rValue; + mod->BSIM4v7ltvoffcvGiven = TRUE; break; - case BSIM4_MOD_LMINV: - mod->BSIM4lminv = value->rValue; - mod->BSIM4lminvGiven = TRUE; + case BSIM4v7_MOD_LMINV: + mod->BSIM4v7lminv = value->rValue; + mod->BSIM4v7lminvGiven = TRUE; break; - case BSIM4_MOD_LMINVCV: - mod->BSIM4lminvcv = value->rValue; - mod->BSIM4lminvcvGiven = TRUE; + case BSIM4v7_MOD_LMINVCV: + mod->BSIM4v7lminvcv = value->rValue; + mod->BSIM4v7lminvcvGiven = TRUE; break; - case BSIM4_MOD_LFPROUT: - mod->BSIM4lfprout = value->rValue; - mod->BSIM4lfproutGiven = TRUE; + case BSIM4v7_MOD_LFPROUT: + mod->BSIM4v7lfprout = value->rValue; + mod->BSIM4v7lfproutGiven = TRUE; break; - case BSIM4_MOD_LPDITS: - mod->BSIM4lpdits = value->rValue; - mod->BSIM4lpditsGiven = TRUE; + case BSIM4v7_MOD_LPDITS: + mod->BSIM4v7lpdits = value->rValue; + mod->BSIM4v7lpditsGiven = TRUE; break; - case BSIM4_MOD_LPDITSD: - mod->BSIM4lpditsd = value->rValue; - mod->BSIM4lpditsdGiven = TRUE; + case BSIM4v7_MOD_LPDITSD: + mod->BSIM4v7lpditsd = value->rValue; + mod->BSIM4v7lpditsdGiven = TRUE; break; - case BSIM4_MOD_LDELTA : - mod->BSIM4ldelta = value->rValue; - mod->BSIM4ldeltaGiven = TRUE; + case BSIM4v7_MOD_LDELTA : + mod->BSIM4v7ldelta = value->rValue; + mod->BSIM4v7ldeltaGiven = TRUE; break; - case BSIM4_MOD_LRDSW: - mod->BSIM4lrdsw = value->rValue; - mod->BSIM4lrdswGiven = TRUE; + case BSIM4v7_MOD_LRDSW: + mod->BSIM4v7lrdsw = value->rValue; + mod->BSIM4v7lrdswGiven = TRUE; break; - case BSIM4_MOD_LRDW: - mod->BSIM4lrdw = value->rValue; - mod->BSIM4lrdwGiven = TRUE; + case BSIM4v7_MOD_LRDW: + mod->BSIM4v7lrdw = value->rValue; + mod->BSIM4v7lrdwGiven = TRUE; break; - case BSIM4_MOD_LRSW: - mod->BSIM4lrsw = value->rValue; - mod->BSIM4lrswGiven = TRUE; + case BSIM4v7_MOD_LRSW: + mod->BSIM4v7lrsw = value->rValue; + mod->BSIM4v7lrswGiven = TRUE; break; - case BSIM4_MOD_LPRWB: - mod->BSIM4lprwb = value->rValue; - mod->BSIM4lprwbGiven = TRUE; + case BSIM4v7_MOD_LPRWB: + mod->BSIM4v7lprwb = value->rValue; + mod->BSIM4v7lprwbGiven = TRUE; break; - case BSIM4_MOD_LPRWG: - mod->BSIM4lprwg = value->rValue; - mod->BSIM4lprwgGiven = TRUE; + case BSIM4v7_MOD_LPRWG: + mod->BSIM4v7lprwg = value->rValue; + mod->BSIM4v7lprwgGiven = TRUE; break; - case BSIM4_MOD_LPRT: - mod->BSIM4lprt = value->rValue; - mod->BSIM4lprtGiven = TRUE; + case BSIM4v7_MOD_LPRT: + mod->BSIM4v7lprt = value->rValue; + mod->BSIM4v7lprtGiven = TRUE; break; - case BSIM4_MOD_LETA0: - mod->BSIM4leta0 = value->rValue; - mod->BSIM4leta0Given = TRUE; + case BSIM4v7_MOD_LETA0: + mod->BSIM4v7leta0 = value->rValue; + mod->BSIM4v7leta0Given = TRUE; break; - case BSIM4_MOD_LETAB: - mod->BSIM4letab = value->rValue; - mod->BSIM4letabGiven = TRUE; + case BSIM4v7_MOD_LETAB: + mod->BSIM4v7letab = value->rValue; + mod->BSIM4v7letabGiven = TRUE; break; - case BSIM4_MOD_LPCLM: - mod->BSIM4lpclm = value->rValue; - mod->BSIM4lpclmGiven = TRUE; + case BSIM4v7_MOD_LPCLM: + mod->BSIM4v7lpclm = value->rValue; + mod->BSIM4v7lpclmGiven = TRUE; break; - case BSIM4_MOD_LPDIBL1: - mod->BSIM4lpdibl1 = value->rValue; - mod->BSIM4lpdibl1Given = TRUE; + case BSIM4v7_MOD_LPDIBL1: + mod->BSIM4v7lpdibl1 = value->rValue; + mod->BSIM4v7lpdibl1Given = TRUE; break; - case BSIM4_MOD_LPDIBL2: - mod->BSIM4lpdibl2 = value->rValue; - mod->BSIM4lpdibl2Given = TRUE; + case BSIM4v7_MOD_LPDIBL2: + mod->BSIM4v7lpdibl2 = value->rValue; + mod->BSIM4v7lpdibl2Given = TRUE; break; - case BSIM4_MOD_LPDIBLB: - mod->BSIM4lpdiblb = value->rValue; - mod->BSIM4lpdiblbGiven = TRUE; + case BSIM4v7_MOD_LPDIBLB: + mod->BSIM4v7lpdiblb = value->rValue; + mod->BSIM4v7lpdiblbGiven = TRUE; break; - case BSIM4_MOD_LPSCBE1: - mod->BSIM4lpscbe1 = value->rValue; - mod->BSIM4lpscbe1Given = TRUE; + case BSIM4v7_MOD_LPSCBE1: + mod->BSIM4v7lpscbe1 = value->rValue; + mod->BSIM4v7lpscbe1Given = TRUE; break; - case BSIM4_MOD_LPSCBE2: - mod->BSIM4lpscbe2 = value->rValue; - mod->BSIM4lpscbe2Given = TRUE; + case BSIM4v7_MOD_LPSCBE2: + mod->BSIM4v7lpscbe2 = value->rValue; + mod->BSIM4v7lpscbe2Given = TRUE; break; - case BSIM4_MOD_LPVAG: - mod->BSIM4lpvag = value->rValue; - mod->BSIM4lpvagGiven = TRUE; + case BSIM4v7_MOD_LPVAG: + mod->BSIM4v7lpvag = value->rValue; + mod->BSIM4v7lpvagGiven = TRUE; break; - case BSIM4_MOD_LWR : - mod->BSIM4lwr = value->rValue; - mod->BSIM4lwrGiven = TRUE; + case BSIM4v7_MOD_LWR : + mod->BSIM4v7lwr = value->rValue; + mod->BSIM4v7lwrGiven = TRUE; break; - case BSIM4_MOD_LDWG : - mod->BSIM4ldwg = value->rValue; - mod->BSIM4ldwgGiven = TRUE; + case BSIM4v7_MOD_LDWG : + mod->BSIM4v7ldwg = value->rValue; + mod->BSIM4v7ldwgGiven = TRUE; break; - case BSIM4_MOD_LDWB : - mod->BSIM4ldwb = value->rValue; - mod->BSIM4ldwbGiven = TRUE; + case BSIM4v7_MOD_LDWB : + mod->BSIM4v7ldwb = value->rValue; + mod->BSIM4v7ldwbGiven = TRUE; break; - case BSIM4_MOD_LB0 : - mod->BSIM4lb0 = value->rValue; - mod->BSIM4lb0Given = TRUE; + case BSIM4v7_MOD_LB0 : + mod->BSIM4v7lb0 = value->rValue; + mod->BSIM4v7lb0Given = TRUE; break; - case BSIM4_MOD_LB1 : - mod->BSIM4lb1 = value->rValue; - mod->BSIM4lb1Given = TRUE; + case BSIM4v7_MOD_LB1 : + mod->BSIM4v7lb1 = value->rValue; + mod->BSIM4v7lb1Given = TRUE; break; - case BSIM4_MOD_LALPHA0 : - mod->BSIM4lalpha0 = value->rValue; - mod->BSIM4lalpha0Given = TRUE; + case BSIM4v7_MOD_LALPHA0 : + mod->BSIM4v7lalpha0 = value->rValue; + mod->BSIM4v7lalpha0Given = TRUE; break; - case BSIM4_MOD_LALPHA1 : - mod->BSIM4lalpha1 = value->rValue; - mod->BSIM4lalpha1Given = TRUE; + case BSIM4v7_MOD_LALPHA1 : + mod->BSIM4v7lalpha1 = value->rValue; + mod->BSIM4v7lalpha1Given = TRUE; break; - case BSIM4_MOD_LBETA0 : - mod->BSIM4lbeta0 = value->rValue; - mod->BSIM4lbeta0Given = TRUE; + case BSIM4v7_MOD_LBETA0 : + mod->BSIM4v7lbeta0 = value->rValue; + mod->BSIM4v7lbeta0Given = TRUE; break; - case BSIM4_MOD_LPHIN : - mod->BSIM4lphin = value->rValue; - mod->BSIM4lphinGiven = TRUE; + case BSIM4v7_MOD_LPHIN : + mod->BSIM4v7lphin = value->rValue; + mod->BSIM4v7lphinGiven = TRUE; break; - case BSIM4_MOD_LAGIDL : - mod->BSIM4lagidl = value->rValue; - mod->BSIM4lagidlGiven = TRUE; + case BSIM4v7_MOD_LAGIDL : + mod->BSIM4v7lagidl = value->rValue; + mod->BSIM4v7lagidlGiven = TRUE; break; - case BSIM4_MOD_LBGIDL : - mod->BSIM4lbgidl = value->rValue; - mod->BSIM4lbgidlGiven = TRUE; + case BSIM4v7_MOD_LBGIDL : + mod->BSIM4v7lbgidl = value->rValue; + mod->BSIM4v7lbgidlGiven = TRUE; break; - case BSIM4_MOD_LCGIDL : - mod->BSIM4lcgidl = value->rValue; - mod->BSIM4lcgidlGiven = TRUE; + case BSIM4v7_MOD_LCGIDL : + mod->BSIM4v7lcgidl = value->rValue; + mod->BSIM4v7lcgidlGiven = TRUE; break; - case BSIM4_MOD_LEGIDL : - mod->BSIM4legidl = value->rValue; - mod->BSIM4legidlGiven = TRUE; + case BSIM4v7_MOD_LEGIDL : + mod->BSIM4v7legidl = value->rValue; + mod->BSIM4v7legidlGiven = TRUE; break; - case BSIM4_MOD_LFGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4lfgidl = value->rValue; - mod->BSIM4lfgidlGiven = TRUE; + case BSIM4v7_MOD_LFGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7lfgidl = value->rValue; + mod->BSIM4v7lfgidlGiven = TRUE; break; - case BSIM4_MOD_LKGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4lkgidl = value->rValue; - mod->BSIM4lkgidlGiven = TRUE; + case BSIM4v7_MOD_LKGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7lkgidl = value->rValue; + mod->BSIM4v7lkgidlGiven = TRUE; break; - case BSIM4_MOD_LRGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4lrgidl = value->rValue; - mod->BSIM4lrgidlGiven = TRUE; + case BSIM4v7_MOD_LRGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7lrgidl = value->rValue; + mod->BSIM4v7lrgidlGiven = TRUE; break; - case BSIM4_MOD_LAGISL : - mod->BSIM4lagisl = value->rValue; - mod->BSIM4lagislGiven = TRUE; + case BSIM4v7_MOD_LAGISL : + mod->BSIM4v7lagisl = value->rValue; + mod->BSIM4v7lagislGiven = TRUE; break; - case BSIM4_MOD_LBGISL : - mod->BSIM4lbgisl = value->rValue; - mod->BSIM4lbgislGiven = TRUE; + case BSIM4v7_MOD_LBGISL : + mod->BSIM4v7lbgisl = value->rValue; + mod->BSIM4v7lbgislGiven = TRUE; break; - case BSIM4_MOD_LCGISL : - mod->BSIM4lcgisl = value->rValue; - mod->BSIM4lcgislGiven = TRUE; + case BSIM4v7_MOD_LCGISL : + mod->BSIM4v7lcgisl = value->rValue; + mod->BSIM4v7lcgislGiven = TRUE; break; - case BSIM4_MOD_LEGISL : - mod->BSIM4legisl = value->rValue; - mod->BSIM4legislGiven = TRUE; + case BSIM4v7_MOD_LEGISL : + mod->BSIM4v7legisl = value->rValue; + mod->BSIM4v7legislGiven = TRUE; break; - case BSIM4_MOD_LFGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4lfgisl = value->rValue; - mod->BSIM4lfgislGiven = TRUE; + case BSIM4v7_MOD_LFGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7lfgisl = value->rValue; + mod->BSIM4v7lfgislGiven = TRUE; break; - case BSIM4_MOD_LKGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4lkgisl = value->rValue; - mod->BSIM4lkgislGiven = TRUE; + case BSIM4v7_MOD_LKGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7lkgisl = value->rValue; + mod->BSIM4v7lkgislGiven = TRUE; break; - case BSIM4_MOD_LRGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4lrgisl = value->rValue; - mod->BSIM4lrgislGiven = TRUE; + case BSIM4v7_MOD_LRGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7lrgisl = value->rValue; + mod->BSIM4v7lrgislGiven = TRUE; break; - case BSIM4_MOD_LAIGC : - mod->BSIM4laigc = value->rValue; - mod->BSIM4laigcGiven = TRUE; + case BSIM4v7_MOD_LAIGC : + mod->BSIM4v7laigc = value->rValue; + mod->BSIM4v7laigcGiven = TRUE; break; - case BSIM4_MOD_LBIGC : - mod->BSIM4lbigc = value->rValue; - mod->BSIM4lbigcGiven = TRUE; + case BSIM4v7_MOD_LBIGC : + mod->BSIM4v7lbigc = value->rValue; + mod->BSIM4v7lbigcGiven = TRUE; break; - case BSIM4_MOD_LCIGC : - mod->BSIM4lcigc = value->rValue; - mod->BSIM4lcigcGiven = TRUE; + case BSIM4v7_MOD_LCIGC : + mod->BSIM4v7lcigc = value->rValue; + mod->BSIM4v7lcigcGiven = TRUE; break; - case BSIM4_MOD_LAIGSD : - mod->BSIM4laigsd = value->rValue; - mod->BSIM4laigsdGiven = TRUE; + case BSIM4v7_MOD_LAIGSD : + mod->BSIM4v7laigsd = value->rValue; + mod->BSIM4v7laigsdGiven = TRUE; break; - case BSIM4_MOD_LBIGSD : - mod->BSIM4lbigsd = value->rValue; - mod->BSIM4lbigsdGiven = TRUE; + case BSIM4v7_MOD_LBIGSD : + mod->BSIM4v7lbigsd = value->rValue; + mod->BSIM4v7lbigsdGiven = TRUE; break; - case BSIM4_MOD_LCIGSD : - mod->BSIM4lcigsd = value->rValue; - mod->BSIM4lcigsdGiven = TRUE; + case BSIM4v7_MOD_LCIGSD : + mod->BSIM4v7lcigsd = value->rValue; + mod->BSIM4v7lcigsdGiven = TRUE; break; - case BSIM4_MOD_LAIGS : - mod->BSIM4laigs = value->rValue; - mod->BSIM4laigsGiven = TRUE; + case BSIM4v7_MOD_LAIGS : + mod->BSIM4v7laigs = value->rValue; + mod->BSIM4v7laigsGiven = TRUE; break; - case BSIM4_MOD_LBIGS : - mod->BSIM4lbigs = value->rValue; - mod->BSIM4lbigsGiven = TRUE; + case BSIM4v7_MOD_LBIGS : + mod->BSIM4v7lbigs = value->rValue; + mod->BSIM4v7lbigsGiven = TRUE; break; - case BSIM4_MOD_LCIGS : - mod->BSIM4lcigs = value->rValue; - mod->BSIM4lcigsGiven = TRUE; + case BSIM4v7_MOD_LCIGS : + mod->BSIM4v7lcigs = value->rValue; + mod->BSIM4v7lcigsGiven = TRUE; break; - case BSIM4_MOD_LAIGD : - mod->BSIM4laigd = value->rValue; - mod->BSIM4laigdGiven = TRUE; + case BSIM4v7_MOD_LAIGD : + mod->BSIM4v7laigd = value->rValue; + mod->BSIM4v7laigdGiven = TRUE; break; - case BSIM4_MOD_LBIGD : - mod->BSIM4lbigd = value->rValue; - mod->BSIM4lbigdGiven = TRUE; + case BSIM4v7_MOD_LBIGD : + mod->BSIM4v7lbigd = value->rValue; + mod->BSIM4v7lbigdGiven = TRUE; break; - case BSIM4_MOD_LCIGD : - mod->BSIM4lcigd = value->rValue; - mod->BSIM4lcigdGiven = TRUE; + case BSIM4v7_MOD_LCIGD : + mod->BSIM4v7lcigd = value->rValue; + mod->BSIM4v7lcigdGiven = TRUE; break; - case BSIM4_MOD_LAIGBACC : - mod->BSIM4laigbacc = value->rValue; - mod->BSIM4laigbaccGiven = TRUE; + case BSIM4v7_MOD_LAIGBACC : + mod->BSIM4v7laigbacc = value->rValue; + mod->BSIM4v7laigbaccGiven = TRUE; break; - case BSIM4_MOD_LBIGBACC : - mod->BSIM4lbigbacc = value->rValue; - mod->BSIM4lbigbaccGiven = TRUE; + case BSIM4v7_MOD_LBIGBACC : + mod->BSIM4v7lbigbacc = value->rValue; + mod->BSIM4v7lbigbaccGiven = TRUE; break; - case BSIM4_MOD_LCIGBACC : - mod->BSIM4lcigbacc = value->rValue; - mod->BSIM4lcigbaccGiven = TRUE; + case BSIM4v7_MOD_LCIGBACC : + mod->BSIM4v7lcigbacc = value->rValue; + mod->BSIM4v7lcigbaccGiven = TRUE; break; - case BSIM4_MOD_LAIGBINV : - mod->BSIM4laigbinv = value->rValue; - mod->BSIM4laigbinvGiven = TRUE; + case BSIM4v7_MOD_LAIGBINV : + mod->BSIM4v7laigbinv = value->rValue; + mod->BSIM4v7laigbinvGiven = TRUE; break; - case BSIM4_MOD_LBIGBINV : - mod->BSIM4lbigbinv = value->rValue; - mod->BSIM4lbigbinvGiven = TRUE; + case BSIM4v7_MOD_LBIGBINV : + mod->BSIM4v7lbigbinv = value->rValue; + mod->BSIM4v7lbigbinvGiven = TRUE; break; - case BSIM4_MOD_LCIGBINV : - mod->BSIM4lcigbinv = value->rValue; - mod->BSIM4lcigbinvGiven = TRUE; + case BSIM4v7_MOD_LCIGBINV : + mod->BSIM4v7lcigbinv = value->rValue; + mod->BSIM4v7lcigbinvGiven = TRUE; break; - case BSIM4_MOD_LNIGC : - mod->BSIM4lnigc = value->rValue; - mod->BSIM4lnigcGiven = TRUE; + case BSIM4v7_MOD_LNIGC : + mod->BSIM4v7lnigc = value->rValue; + mod->BSIM4v7lnigcGiven = TRUE; break; - case BSIM4_MOD_LNIGBINV : - mod->BSIM4lnigbinv = value->rValue; - mod->BSIM4lnigbinvGiven = TRUE; + case BSIM4v7_MOD_LNIGBINV : + mod->BSIM4v7lnigbinv = value->rValue; + mod->BSIM4v7lnigbinvGiven = TRUE; break; - case BSIM4_MOD_LNIGBACC : - mod->BSIM4lnigbacc = value->rValue; - mod->BSIM4lnigbaccGiven = TRUE; + case BSIM4v7_MOD_LNIGBACC : + mod->BSIM4v7lnigbacc = value->rValue; + mod->BSIM4v7lnigbaccGiven = TRUE; break; - case BSIM4_MOD_LNTOX : - mod->BSIM4lntox = value->rValue; - mod->BSIM4lntoxGiven = TRUE; + case BSIM4v7_MOD_LNTOX : + mod->BSIM4v7lntox = value->rValue; + mod->BSIM4v7lntoxGiven = TRUE; break; - case BSIM4_MOD_LEIGBINV : - mod->BSIM4leigbinv = value->rValue; - mod->BSIM4leigbinvGiven = TRUE; + case BSIM4v7_MOD_LEIGBINV : + mod->BSIM4v7leigbinv = value->rValue; + mod->BSIM4v7leigbinvGiven = TRUE; break; - case BSIM4_MOD_LPIGCD : - mod->BSIM4lpigcd = value->rValue; - mod->BSIM4lpigcdGiven = TRUE; + case BSIM4v7_MOD_LPIGCD : + mod->BSIM4v7lpigcd = value->rValue; + mod->BSIM4v7lpigcdGiven = TRUE; break; - case BSIM4_MOD_LPOXEDGE : - mod->BSIM4lpoxedge = value->rValue; - mod->BSIM4lpoxedgeGiven = TRUE; + case BSIM4v7_MOD_LPOXEDGE : + mod->BSIM4v7lpoxedge = value->rValue; + mod->BSIM4v7lpoxedgeGiven = TRUE; break; - case BSIM4_MOD_LXRCRG1 : - mod->BSIM4lxrcrg1 = value->rValue; - mod->BSIM4lxrcrg1Given = TRUE; + case BSIM4v7_MOD_LXRCRG1 : + mod->BSIM4v7lxrcrg1 = value->rValue; + mod->BSIM4v7lxrcrg1Given = TRUE; break; - case BSIM4_MOD_LXRCRG2 : - mod->BSIM4lxrcrg2 = value->rValue; - mod->BSIM4lxrcrg2Given = TRUE; + case BSIM4v7_MOD_LXRCRG2 : + mod->BSIM4v7lxrcrg2 = value->rValue; + mod->BSIM4v7lxrcrg2Given = TRUE; break; - case BSIM4_MOD_LLAMBDA : - mod->BSIM4llambda = value->rValue; - mod->BSIM4llambdaGiven = TRUE; + case BSIM4v7_MOD_LLAMBDA : + mod->BSIM4v7llambda = value->rValue; + mod->BSIM4v7llambdaGiven = TRUE; break; - case BSIM4_MOD_LVTL : - mod->BSIM4lvtl = value->rValue; - mod->BSIM4lvtlGiven = TRUE; + case BSIM4v7_MOD_LVTL : + mod->BSIM4v7lvtl = value->rValue; + mod->BSIM4v7lvtlGiven = TRUE; break; - case BSIM4_MOD_LXN: - mod->BSIM4lxn = value->rValue; - mod->BSIM4lxnGiven = TRUE; + case BSIM4v7_MOD_LXN: + mod->BSIM4v7lxn = value->rValue; + mod->BSIM4v7lxnGiven = TRUE; break; - case BSIM4_MOD_LVFBSDOFF: - mod->BSIM4lvfbsdoff = value->rValue; - mod->BSIM4lvfbsdoffGiven = TRUE; + case BSIM4v7_MOD_LVFBSDOFF: + mod->BSIM4v7lvfbsdoff = value->rValue; + mod->BSIM4v7lvfbsdoffGiven = TRUE; break; - case BSIM4_MOD_LTVFBSDOFF: - mod->BSIM4ltvfbsdoff = value->rValue; - mod->BSIM4ltvfbsdoffGiven = TRUE; + case BSIM4v7_MOD_LTVFBSDOFF: + mod->BSIM4v7ltvfbsdoff = value->rValue; + mod->BSIM4v7ltvfbsdoffGiven = TRUE; break; - case BSIM4_MOD_LEU : - mod->BSIM4leu = value->rValue; - mod->BSIM4leuGiven = TRUE; + case BSIM4v7_MOD_LEU : + mod->BSIM4v7leu = value->rValue; + mod->BSIM4v7leuGiven = TRUE; break; - case BSIM4_MOD_LUCS : - mod->BSIM4lucs = value->rValue; - mod->BSIM4lucsGiven = TRUE; + case BSIM4v7_MOD_LUCS : + mod->BSIM4v7lucs = value->rValue; + mod->BSIM4v7lucsGiven = TRUE; break; - case BSIM4_MOD_LVFB : - mod->BSIM4lvfb = value->rValue; - mod->BSIM4lvfbGiven = TRUE; + case BSIM4v7_MOD_LVFB : + mod->BSIM4v7lvfb = value->rValue; + mod->BSIM4v7lvfbGiven = TRUE; break; - case BSIM4_MOD_LCGSL : - mod->BSIM4lcgsl = value->rValue; - mod->BSIM4lcgslGiven = TRUE; + case BSIM4v7_MOD_LCGSL : + mod->BSIM4v7lcgsl = value->rValue; + mod->BSIM4v7lcgslGiven = TRUE; break; - case BSIM4_MOD_LCGDL : - mod->BSIM4lcgdl = value->rValue; - mod->BSIM4lcgdlGiven = TRUE; + case BSIM4v7_MOD_LCGDL : + mod->BSIM4v7lcgdl = value->rValue; + mod->BSIM4v7lcgdlGiven = TRUE; break; - case BSIM4_MOD_LCKAPPAS : - mod->BSIM4lckappas = value->rValue; - mod->BSIM4lckappasGiven = TRUE; + case BSIM4v7_MOD_LCKAPPAS : + mod->BSIM4v7lckappas = value->rValue; + mod->BSIM4v7lckappasGiven = TRUE; break; - case BSIM4_MOD_LCKAPPAD : - mod->BSIM4lckappad = value->rValue; - mod->BSIM4lckappadGiven = TRUE; + case BSIM4v7_MOD_LCKAPPAD : + mod->BSIM4v7lckappad = value->rValue; + mod->BSIM4v7lckappadGiven = TRUE; break; - case BSIM4_MOD_LCF : - mod->BSIM4lcf = value->rValue; - mod->BSIM4lcfGiven = TRUE; + case BSIM4v7_MOD_LCF : + mod->BSIM4v7lcf = value->rValue; + mod->BSIM4v7lcfGiven = TRUE; break; - case BSIM4_MOD_LCLC : - mod->BSIM4lclc = value->rValue; - mod->BSIM4lclcGiven = TRUE; + case BSIM4v7_MOD_LCLC : + mod->BSIM4v7lclc = value->rValue; + mod->BSIM4v7lclcGiven = TRUE; break; - case BSIM4_MOD_LCLE : - mod->BSIM4lcle = value->rValue; - mod->BSIM4lcleGiven = TRUE; + case BSIM4v7_MOD_LCLE : + mod->BSIM4v7lcle = value->rValue; + mod->BSIM4v7lcleGiven = TRUE; break; - case BSIM4_MOD_LVFBCV : - mod->BSIM4lvfbcv = value->rValue; - mod->BSIM4lvfbcvGiven = TRUE; + case BSIM4v7_MOD_LVFBCV : + mod->BSIM4v7lvfbcv = value->rValue; + mod->BSIM4v7lvfbcvGiven = TRUE; break; - case BSIM4_MOD_LACDE : - mod->BSIM4lacde = value->rValue; - mod->BSIM4lacdeGiven = TRUE; + case BSIM4v7_MOD_LACDE : + mod->BSIM4v7lacde = value->rValue; + mod->BSIM4v7lacdeGiven = TRUE; break; - case BSIM4_MOD_LMOIN : - mod->BSIM4lmoin = value->rValue; - mod->BSIM4lmoinGiven = TRUE; + case BSIM4v7_MOD_LMOIN : + mod->BSIM4v7lmoin = value->rValue; + mod->BSIM4v7lmoinGiven = TRUE; break; - case BSIM4_MOD_LNOFF : - mod->BSIM4lnoff = value->rValue; - mod->BSIM4lnoffGiven = TRUE; + case BSIM4v7_MOD_LNOFF : + mod->BSIM4v7lnoff = value->rValue; + mod->BSIM4v7lnoffGiven = TRUE; break; - case BSIM4_MOD_LVOFFCV : - mod->BSIM4lvoffcv = value->rValue; - mod->BSIM4lvoffcvGiven = TRUE; + case BSIM4v7_MOD_LVOFFCV : + mod->BSIM4v7lvoffcv = value->rValue; + mod->BSIM4v7lvoffcvGiven = TRUE; break; /* Width dependence */ - case BSIM4_MOD_WCDSC : - mod->BSIM4wcdsc = value->rValue; - mod->BSIM4wcdscGiven = TRUE; + case BSIM4v7_MOD_WCDSC : + mod->BSIM4v7wcdsc = value->rValue; + mod->BSIM4v7wcdscGiven = TRUE; break; - case BSIM4_MOD_WCDSCB : - mod->BSIM4wcdscb = value->rValue; - mod->BSIM4wcdscbGiven = TRUE; + case BSIM4v7_MOD_WCDSCB : + mod->BSIM4v7wcdscb = value->rValue; + mod->BSIM4v7wcdscbGiven = TRUE; break; - case BSIM4_MOD_WCDSCD : - mod->BSIM4wcdscd = value->rValue; - mod->BSIM4wcdscdGiven = TRUE; + case BSIM4v7_MOD_WCDSCD : + mod->BSIM4v7wcdscd = value->rValue; + mod->BSIM4v7wcdscdGiven = TRUE; break; - case BSIM4_MOD_WCIT : - mod->BSIM4wcit = value->rValue; - mod->BSIM4wcitGiven = TRUE; + case BSIM4v7_MOD_WCIT : + mod->BSIM4v7wcit = value->rValue; + mod->BSIM4v7wcitGiven = TRUE; break; - case BSIM4_MOD_WNFACTOR : - mod->BSIM4wnfactor = value->rValue; - mod->BSIM4wnfactorGiven = TRUE; + case BSIM4v7_MOD_WNFACTOR : + mod->BSIM4v7wnfactor = value->rValue; + mod->BSIM4v7wnfactorGiven = TRUE; break; - case BSIM4_MOD_WXJ: - mod->BSIM4wxj = value->rValue; - mod->BSIM4wxjGiven = TRUE; + case BSIM4v7_MOD_WXJ: + mod->BSIM4v7wxj = value->rValue; + mod->BSIM4v7wxjGiven = TRUE; break; - case BSIM4_MOD_WVSAT: - mod->BSIM4wvsat = value->rValue; - mod->BSIM4wvsatGiven = TRUE; + case BSIM4v7_MOD_WVSAT: + mod->BSIM4v7wvsat = value->rValue; + mod->BSIM4v7wvsatGiven = TRUE; break; - case BSIM4_MOD_WA0: - mod->BSIM4wa0 = value->rValue; - mod->BSIM4wa0Given = TRUE; + case BSIM4v7_MOD_WA0: + mod->BSIM4v7wa0 = value->rValue; + mod->BSIM4v7wa0Given = TRUE; break; - case BSIM4_MOD_WAGS: - mod->BSIM4wags = value->rValue; - mod->BSIM4wagsGiven = TRUE; + case BSIM4v7_MOD_WAGS: + mod->BSIM4v7wags = value->rValue; + mod->BSIM4v7wagsGiven = TRUE; break; - case BSIM4_MOD_WA1: - mod->BSIM4wa1 = value->rValue; - mod->BSIM4wa1Given = TRUE; + case BSIM4v7_MOD_WA1: + mod->BSIM4v7wa1 = value->rValue; + mod->BSIM4v7wa1Given = TRUE; break; - case BSIM4_MOD_WA2: - mod->BSIM4wa2 = value->rValue; - mod->BSIM4wa2Given = TRUE; + case BSIM4v7_MOD_WA2: + mod->BSIM4v7wa2 = value->rValue; + mod->BSIM4v7wa2Given = TRUE; break; - case BSIM4_MOD_WAT: - mod->BSIM4wat = value->rValue; - mod->BSIM4watGiven = TRUE; + case BSIM4v7_MOD_WAT: + mod->BSIM4v7wat = value->rValue; + mod->BSIM4v7watGiven = TRUE; break; - case BSIM4_MOD_WKETA: - mod->BSIM4wketa = value->rValue; - mod->BSIM4wketaGiven = TRUE; + case BSIM4v7_MOD_WKETA: + mod->BSIM4v7wketa = value->rValue; + mod->BSIM4v7wketaGiven = TRUE; break; - case BSIM4_MOD_WNSUB: - mod->BSIM4wnsub = value->rValue; - mod->BSIM4wnsubGiven = TRUE; + case BSIM4v7_MOD_WNSUB: + mod->BSIM4v7wnsub = value->rValue; + mod->BSIM4v7wnsubGiven = TRUE; break; - case BSIM4_MOD_WNDEP: - mod->BSIM4wndep = value->rValue; - mod->BSIM4wndepGiven = TRUE; - if (mod->BSIM4wndep > 1.0e20) - mod->BSIM4wndep *= 1.0e-6; + case BSIM4v7_MOD_WNDEP: + mod->BSIM4v7wndep = value->rValue; + mod->BSIM4v7wndepGiven = TRUE; + if (mod->BSIM4v7wndep > 1.0e20) + mod->BSIM4v7wndep *= 1.0e-6; break; - case BSIM4_MOD_WNSD: - mod->BSIM4wnsd = value->rValue; - mod->BSIM4wnsdGiven = TRUE; - if (mod->BSIM4wnsd > 1.0e23) - mod->BSIM4wnsd *= 1.0e-6; + case BSIM4v7_MOD_WNSD: + mod->BSIM4v7wnsd = value->rValue; + mod->BSIM4v7wnsdGiven = TRUE; + if (mod->BSIM4v7wnsd > 1.0e23) + mod->BSIM4v7wnsd *= 1.0e-6; break; - case BSIM4_MOD_WNGATE: - mod->BSIM4wngate = value->rValue; - mod->BSIM4wngateGiven = TRUE; - if (mod->BSIM4wngate > 1.0e23) - mod->BSIM4wngate *= 1.0e-6; + case BSIM4v7_MOD_WNGATE: + mod->BSIM4v7wngate = value->rValue; + mod->BSIM4v7wngateGiven = TRUE; + if (mod->BSIM4v7wngate > 1.0e23) + mod->BSIM4v7wngate *= 1.0e-6; break; - case BSIM4_MOD_WGAMMA1: - mod->BSIM4wgamma1 = value->rValue; - mod->BSIM4wgamma1Given = TRUE; + case BSIM4v7_MOD_WGAMMA1: + mod->BSIM4v7wgamma1 = value->rValue; + mod->BSIM4v7wgamma1Given = TRUE; break; - case BSIM4_MOD_WGAMMA2: - mod->BSIM4wgamma2 = value->rValue; - mod->BSIM4wgamma2Given = TRUE; + case BSIM4v7_MOD_WGAMMA2: + mod->BSIM4v7wgamma2 = value->rValue; + mod->BSIM4v7wgamma2Given = TRUE; break; - case BSIM4_MOD_WVBX: - mod->BSIM4wvbx = value->rValue; - mod->BSIM4wvbxGiven = TRUE; + case BSIM4v7_MOD_WVBX: + mod->BSIM4v7wvbx = value->rValue; + mod->BSIM4v7wvbxGiven = TRUE; break; - case BSIM4_MOD_WVBM: - mod->BSIM4wvbm = value->rValue; - mod->BSIM4wvbmGiven = TRUE; + case BSIM4v7_MOD_WVBM: + mod->BSIM4v7wvbm = value->rValue; + mod->BSIM4v7wvbmGiven = TRUE; break; - case BSIM4_MOD_WXT: - mod->BSIM4wxt = value->rValue; - mod->BSIM4wxtGiven = TRUE; + case BSIM4v7_MOD_WXT: + mod->BSIM4v7wxt = value->rValue; + mod->BSIM4v7wxtGiven = TRUE; break; - case BSIM4_MOD_WK1: - mod->BSIM4wk1 = value->rValue; - mod->BSIM4wk1Given = TRUE; + case BSIM4v7_MOD_WK1: + mod->BSIM4v7wk1 = value->rValue; + mod->BSIM4v7wk1Given = TRUE; break; - case BSIM4_MOD_WKT1: - mod->BSIM4wkt1 = value->rValue; - mod->BSIM4wkt1Given = TRUE; + case BSIM4v7_MOD_WKT1: + mod->BSIM4v7wkt1 = value->rValue; + mod->BSIM4v7wkt1Given = TRUE; break; - case BSIM4_MOD_WKT1L: - mod->BSIM4wkt1l = value->rValue; - mod->BSIM4wkt1lGiven = TRUE; + case BSIM4v7_MOD_WKT1L: + mod->BSIM4v7wkt1l = value->rValue; + mod->BSIM4v7wkt1lGiven = TRUE; break; - case BSIM4_MOD_WKT2: - mod->BSIM4wkt2 = value->rValue; - mod->BSIM4wkt2Given = TRUE; + case BSIM4v7_MOD_WKT2: + mod->BSIM4v7wkt2 = value->rValue; + mod->BSIM4v7wkt2Given = TRUE; break; - case BSIM4_MOD_WK2: - mod->BSIM4wk2 = value->rValue; - mod->BSIM4wk2Given = TRUE; + case BSIM4v7_MOD_WK2: + mod->BSIM4v7wk2 = value->rValue; + mod->BSIM4v7wk2Given = TRUE; break; - case BSIM4_MOD_WK3: - mod->BSIM4wk3 = value->rValue; - mod->BSIM4wk3Given = TRUE; + case BSIM4v7_MOD_WK3: + mod->BSIM4v7wk3 = value->rValue; + mod->BSIM4v7wk3Given = TRUE; break; - case BSIM4_MOD_WK3B: - mod->BSIM4wk3b = value->rValue; - mod->BSIM4wk3bGiven = TRUE; + case BSIM4v7_MOD_WK3B: + mod->BSIM4v7wk3b = value->rValue; + mod->BSIM4v7wk3bGiven = TRUE; break; - case BSIM4_MOD_WLPE0: - mod->BSIM4wlpe0 = value->rValue; - mod->BSIM4wlpe0Given = TRUE; + case BSIM4v7_MOD_WLPE0: + mod->BSIM4v7wlpe0 = value->rValue; + mod->BSIM4v7wlpe0Given = TRUE; break; - case BSIM4_MOD_WLPEB: - mod->BSIM4wlpeb = value->rValue; - mod->BSIM4wlpebGiven = TRUE; + case BSIM4v7_MOD_WLPEB: + mod->BSIM4v7wlpeb = value->rValue; + mod->BSIM4v7wlpebGiven = TRUE; break; - case BSIM4_MOD_WDVTP0: - mod->BSIM4wdvtp0 = value->rValue; - mod->BSIM4wdvtp0Given = TRUE; + case BSIM4v7_MOD_WDVTP0: + mod->BSIM4v7wdvtp0 = value->rValue; + mod->BSIM4v7wdvtp0Given = TRUE; break; - case BSIM4_MOD_WDVTP1: - mod->BSIM4wdvtp1 = value->rValue; - mod->BSIM4wdvtp1Given = TRUE; + case BSIM4v7_MOD_WDVTP1: + mod->BSIM4v7wdvtp1 = value->rValue; + mod->BSIM4v7wdvtp1Given = TRUE; break; - case BSIM4_MOD_WDVTP2: /* New DIBL/Rout */ - mod->BSIM4wdvtp2 = value->rValue; - mod->BSIM4wdvtp2Given = TRUE; + case BSIM4v7_MOD_WDVTP2: /* New DIBL/Rout */ + mod->BSIM4v7wdvtp2 = value->rValue; + mod->BSIM4v7wdvtp2Given = TRUE; break; - case BSIM4_MOD_WDVTP3: - mod->BSIM4wdvtp3 = value->rValue; - mod->BSIM4wdvtp3Given = TRUE; + case BSIM4v7_MOD_WDVTP3: + mod->BSIM4v7wdvtp3 = value->rValue; + mod->BSIM4v7wdvtp3Given = TRUE; break; - case BSIM4_MOD_WDVTP4: - mod->BSIM4wdvtp4 = value->rValue; - mod->BSIM4wdvtp4Given = TRUE; + case BSIM4v7_MOD_WDVTP4: + mod->BSIM4v7wdvtp4 = value->rValue; + mod->BSIM4v7wdvtp4Given = TRUE; break; - case BSIM4_MOD_WDVTP5: - mod->BSIM4wdvtp5 = value->rValue; - mod->BSIM4wdvtp5Given = TRUE; + case BSIM4v7_MOD_WDVTP5: + mod->BSIM4v7wdvtp5 = value->rValue; + mod->BSIM4v7wdvtp5Given = TRUE; break; - case BSIM4_MOD_WW0: - mod->BSIM4ww0 = value->rValue; - mod->BSIM4ww0Given = TRUE; + case BSIM4v7_MOD_WW0: + mod->BSIM4v7ww0 = value->rValue; + mod->BSIM4v7ww0Given = TRUE; break; - case BSIM4_MOD_WDVT0: - mod->BSIM4wdvt0 = value->rValue; - mod->BSIM4wdvt0Given = TRUE; + case BSIM4v7_MOD_WDVT0: + mod->BSIM4v7wdvt0 = value->rValue; + mod->BSIM4v7wdvt0Given = TRUE; break; - case BSIM4_MOD_WDVT1: - mod->BSIM4wdvt1 = value->rValue; - mod->BSIM4wdvt1Given = TRUE; + case BSIM4v7_MOD_WDVT1: + mod->BSIM4v7wdvt1 = value->rValue; + mod->BSIM4v7wdvt1Given = TRUE; break; - case BSIM4_MOD_WDVT2: - mod->BSIM4wdvt2 = value->rValue; - mod->BSIM4wdvt2Given = TRUE; + case BSIM4v7_MOD_WDVT2: + mod->BSIM4v7wdvt2 = value->rValue; + mod->BSIM4v7wdvt2Given = TRUE; break; - case BSIM4_MOD_WDVT0W: - mod->BSIM4wdvt0w = value->rValue; - mod->BSIM4wdvt0wGiven = TRUE; + case BSIM4v7_MOD_WDVT0W: + mod->BSIM4v7wdvt0w = value->rValue; + mod->BSIM4v7wdvt0wGiven = TRUE; break; - case BSIM4_MOD_WDVT1W: - mod->BSIM4wdvt1w = value->rValue; - mod->BSIM4wdvt1wGiven = TRUE; + case BSIM4v7_MOD_WDVT1W: + mod->BSIM4v7wdvt1w = value->rValue; + mod->BSIM4v7wdvt1wGiven = TRUE; break; - case BSIM4_MOD_WDVT2W: - mod->BSIM4wdvt2w = value->rValue; - mod->BSIM4wdvt2wGiven = TRUE; + case BSIM4v7_MOD_WDVT2W: + mod->BSIM4v7wdvt2w = value->rValue; + mod->BSIM4v7wdvt2wGiven = TRUE; break; - case BSIM4_MOD_WDROUT: - mod->BSIM4wdrout = value->rValue; - mod->BSIM4wdroutGiven = TRUE; + case BSIM4v7_MOD_WDROUT: + mod->BSIM4v7wdrout = value->rValue; + mod->BSIM4v7wdroutGiven = TRUE; break; - case BSIM4_MOD_WDSUB: - mod->BSIM4wdsub = value->rValue; - mod->BSIM4wdsubGiven = TRUE; + case BSIM4v7_MOD_WDSUB: + mod->BSIM4v7wdsub = value->rValue; + mod->BSIM4v7wdsubGiven = TRUE; break; - case BSIM4_MOD_WVTH0: - mod->BSIM4wvth0 = value->rValue; - mod->BSIM4wvth0Given = TRUE; + case BSIM4v7_MOD_WVTH0: + mod->BSIM4v7wvth0 = value->rValue; + mod->BSIM4v7wvth0Given = TRUE; break; - case BSIM4_MOD_WUA: - mod->BSIM4wua = value->rValue; - mod->BSIM4wuaGiven = TRUE; + case BSIM4v7_MOD_WUA: + mod->BSIM4v7wua = value->rValue; + mod->BSIM4v7wuaGiven = TRUE; break; - case BSIM4_MOD_WUA1: - mod->BSIM4wua1 = value->rValue; - mod->BSIM4wua1Given = TRUE; + case BSIM4v7_MOD_WUA1: + mod->BSIM4v7wua1 = value->rValue; + mod->BSIM4v7wua1Given = TRUE; break; - case BSIM4_MOD_WUB: - mod->BSIM4wub = value->rValue; - mod->BSIM4wubGiven = TRUE; + case BSIM4v7_MOD_WUB: + mod->BSIM4v7wub = value->rValue; + mod->BSIM4v7wubGiven = TRUE; break; - case BSIM4_MOD_WUB1: - mod->BSIM4wub1 = value->rValue; - mod->BSIM4wub1Given = TRUE; + case BSIM4v7_MOD_WUB1: + mod->BSIM4v7wub1 = value->rValue; + mod->BSIM4v7wub1Given = TRUE; break; - case BSIM4_MOD_WUC: - mod->BSIM4wuc = value->rValue; - mod->BSIM4wucGiven = TRUE; + case BSIM4v7_MOD_WUC: + mod->BSIM4v7wuc = value->rValue; + mod->BSIM4v7wucGiven = TRUE; break; - case BSIM4_MOD_WUC1: - mod->BSIM4wuc1 = value->rValue; - mod->BSIM4wuc1Given = TRUE; + case BSIM4v7_MOD_WUC1: + mod->BSIM4v7wuc1 = value->rValue; + mod->BSIM4v7wuc1Given = TRUE; break; - case BSIM4_MOD_WU0 : - mod->BSIM4wu0 = value->rValue; - mod->BSIM4wu0Given = TRUE; + case BSIM4v7_MOD_WU0 : + mod->BSIM4v7wu0 = value->rValue; + mod->BSIM4v7wu0Given = TRUE; break; - case BSIM4_MOD_WUTE : - mod->BSIM4wute = value->rValue; - mod->BSIM4wuteGiven = TRUE; + case BSIM4v7_MOD_WUTE : + mod->BSIM4v7wute = value->rValue; + mod->BSIM4v7wuteGiven = TRUE; break; - case BSIM4_MOD_WUCSTE : - mod->BSIM4wucste = value->rValue; - mod->BSIM4wucsteGiven = TRUE; + case BSIM4v7_MOD_WUCSTE : + mod->BSIM4v7wucste = value->rValue; + mod->BSIM4v7wucsteGiven = TRUE; break; - case BSIM4_MOD_WVOFF: - mod->BSIM4wvoff = value->rValue; - mod->BSIM4wvoffGiven = TRUE; + case BSIM4v7_MOD_WVOFF: + mod->BSIM4v7wvoff = value->rValue; + mod->BSIM4v7wvoffGiven = TRUE; break; - case BSIM4_MOD_WTVOFF: - mod->BSIM4wtvoff = value->rValue; - mod->BSIM4wtvoffGiven = TRUE; + case BSIM4v7_MOD_WTVOFF: + mod->BSIM4v7wtvoff = value->rValue; + mod->BSIM4v7wtvoffGiven = TRUE; break; - case BSIM4_MOD_WTNFACTOR: /* v4.7 temp dep of leakage current */ - mod->BSIM4wtnfactor = value->rValue; - mod->BSIM4wtnfactorGiven = TRUE; + case BSIM4v7_MOD_WTNFACTOR: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7wtnfactor = value->rValue; + mod->BSIM4v7wtnfactorGiven = TRUE; break; - case BSIM4_MOD_WTETA0: /* v4.7 temp dep of leakage current */ - mod->BSIM4wteta0 = value->rValue; - mod->BSIM4wteta0Given = TRUE; + case BSIM4v7_MOD_WTETA0: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7wteta0 = value->rValue; + mod->BSIM4v7wteta0Given = TRUE; break; - case BSIM4_MOD_WTVOFFCV: /* v4.7 temp dep of leakage current */ - mod->BSIM4wtvoffcv = value->rValue; - mod->BSIM4wtvoffcvGiven = TRUE; + case BSIM4v7_MOD_WTVOFFCV: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7wtvoffcv = value->rValue; + mod->BSIM4v7wtvoffcvGiven = TRUE; break; - case BSIM4_MOD_WMINV: - mod->BSIM4wminv = value->rValue; - mod->BSIM4wminvGiven = TRUE; + case BSIM4v7_MOD_WMINV: + mod->BSIM4v7wminv = value->rValue; + mod->BSIM4v7wminvGiven = TRUE; break; - case BSIM4_MOD_WMINVCV: - mod->BSIM4wminvcv = value->rValue; - mod->BSIM4wminvcvGiven = TRUE; + case BSIM4v7_MOD_WMINVCV: + mod->BSIM4v7wminvcv = value->rValue; + mod->BSIM4v7wminvcvGiven = TRUE; break; - case BSIM4_MOD_WFPROUT: - mod->BSIM4wfprout = value->rValue; - mod->BSIM4wfproutGiven = TRUE; + case BSIM4v7_MOD_WFPROUT: + mod->BSIM4v7wfprout = value->rValue; + mod->BSIM4v7wfproutGiven = TRUE; break; - case BSIM4_MOD_WPDITS: - mod->BSIM4wpdits = value->rValue; - mod->BSIM4wpditsGiven = TRUE; + case BSIM4v7_MOD_WPDITS: + mod->BSIM4v7wpdits = value->rValue; + mod->BSIM4v7wpditsGiven = TRUE; break; - case BSIM4_MOD_WPDITSD: - mod->BSIM4wpditsd = value->rValue; - mod->BSIM4wpditsdGiven = TRUE; + case BSIM4v7_MOD_WPDITSD: + mod->BSIM4v7wpditsd = value->rValue; + mod->BSIM4v7wpditsdGiven = TRUE; break; - case BSIM4_MOD_WDELTA : - mod->BSIM4wdelta = value->rValue; - mod->BSIM4wdeltaGiven = TRUE; + case BSIM4v7_MOD_WDELTA : + mod->BSIM4v7wdelta = value->rValue; + mod->BSIM4v7wdeltaGiven = TRUE; break; - case BSIM4_MOD_WRDSW: - mod->BSIM4wrdsw = value->rValue; - mod->BSIM4wrdswGiven = TRUE; + case BSIM4v7_MOD_WRDSW: + mod->BSIM4v7wrdsw = value->rValue; + mod->BSIM4v7wrdswGiven = TRUE; break; - case BSIM4_MOD_WRDW: - mod->BSIM4wrdw = value->rValue; - mod->BSIM4wrdwGiven = TRUE; + case BSIM4v7_MOD_WRDW: + mod->BSIM4v7wrdw = value->rValue; + mod->BSIM4v7wrdwGiven = TRUE; break; - case BSIM4_MOD_WRSW: - mod->BSIM4wrsw = value->rValue; - mod->BSIM4wrswGiven = TRUE; + case BSIM4v7_MOD_WRSW: + mod->BSIM4v7wrsw = value->rValue; + mod->BSIM4v7wrswGiven = TRUE; break; - case BSIM4_MOD_WPRWB: - mod->BSIM4wprwb = value->rValue; - mod->BSIM4wprwbGiven = TRUE; + case BSIM4v7_MOD_WPRWB: + mod->BSIM4v7wprwb = value->rValue; + mod->BSIM4v7wprwbGiven = TRUE; break; - case BSIM4_MOD_WPRWG: - mod->BSIM4wprwg = value->rValue; - mod->BSIM4wprwgGiven = TRUE; + case BSIM4v7_MOD_WPRWG: + mod->BSIM4v7wprwg = value->rValue; + mod->BSIM4v7wprwgGiven = TRUE; break; - case BSIM4_MOD_WPRT: - mod->BSIM4wprt = value->rValue; - mod->BSIM4wprtGiven = TRUE; + case BSIM4v7_MOD_WPRT: + mod->BSIM4v7wprt = value->rValue; + mod->BSIM4v7wprtGiven = TRUE; break; - case BSIM4_MOD_WETA0: - mod->BSIM4weta0 = value->rValue; - mod->BSIM4weta0Given = TRUE; + case BSIM4v7_MOD_WETA0: + mod->BSIM4v7weta0 = value->rValue; + mod->BSIM4v7weta0Given = TRUE; break; - case BSIM4_MOD_WETAB: - mod->BSIM4wetab = value->rValue; - mod->BSIM4wetabGiven = TRUE; + case BSIM4v7_MOD_WETAB: + mod->BSIM4v7wetab = value->rValue; + mod->BSIM4v7wetabGiven = TRUE; break; - case BSIM4_MOD_WPCLM: - mod->BSIM4wpclm = value->rValue; - mod->BSIM4wpclmGiven = TRUE; + case BSIM4v7_MOD_WPCLM: + mod->BSIM4v7wpclm = value->rValue; + mod->BSIM4v7wpclmGiven = TRUE; break; - case BSIM4_MOD_WPDIBL1: - mod->BSIM4wpdibl1 = value->rValue; - mod->BSIM4wpdibl1Given = TRUE; + case BSIM4v7_MOD_WPDIBL1: + mod->BSIM4v7wpdibl1 = value->rValue; + mod->BSIM4v7wpdibl1Given = TRUE; break; - case BSIM4_MOD_WPDIBL2: - mod->BSIM4wpdibl2 = value->rValue; - mod->BSIM4wpdibl2Given = TRUE; + case BSIM4v7_MOD_WPDIBL2: + mod->BSIM4v7wpdibl2 = value->rValue; + mod->BSIM4v7wpdibl2Given = TRUE; break; - case BSIM4_MOD_WPDIBLB: - mod->BSIM4wpdiblb = value->rValue; - mod->BSIM4wpdiblbGiven = TRUE; + case BSIM4v7_MOD_WPDIBLB: + mod->BSIM4v7wpdiblb = value->rValue; + mod->BSIM4v7wpdiblbGiven = TRUE; break; - case BSIM4_MOD_WPSCBE1: - mod->BSIM4wpscbe1 = value->rValue; - mod->BSIM4wpscbe1Given = TRUE; + case BSIM4v7_MOD_WPSCBE1: + mod->BSIM4v7wpscbe1 = value->rValue; + mod->BSIM4v7wpscbe1Given = TRUE; break; - case BSIM4_MOD_WPSCBE2: - mod->BSIM4wpscbe2 = value->rValue; - mod->BSIM4wpscbe2Given = TRUE; + case BSIM4v7_MOD_WPSCBE2: + mod->BSIM4v7wpscbe2 = value->rValue; + mod->BSIM4v7wpscbe2Given = TRUE; break; - case BSIM4_MOD_WPVAG: - mod->BSIM4wpvag = value->rValue; - mod->BSIM4wpvagGiven = TRUE; + case BSIM4v7_MOD_WPVAG: + mod->BSIM4v7wpvag = value->rValue; + mod->BSIM4v7wpvagGiven = TRUE; break; - case BSIM4_MOD_WWR : - mod->BSIM4wwr = value->rValue; - mod->BSIM4wwrGiven = TRUE; + case BSIM4v7_MOD_WWR : + mod->BSIM4v7wwr = value->rValue; + mod->BSIM4v7wwrGiven = TRUE; break; - case BSIM4_MOD_WDWG : - mod->BSIM4wdwg = value->rValue; - mod->BSIM4wdwgGiven = TRUE; + case BSIM4v7_MOD_WDWG : + mod->BSIM4v7wdwg = value->rValue; + mod->BSIM4v7wdwgGiven = TRUE; break; - case BSIM4_MOD_WDWB : - mod->BSIM4wdwb = value->rValue; - mod->BSIM4wdwbGiven = TRUE; + case BSIM4v7_MOD_WDWB : + mod->BSIM4v7wdwb = value->rValue; + mod->BSIM4v7wdwbGiven = TRUE; break; - case BSIM4_MOD_WB0 : - mod->BSIM4wb0 = value->rValue; - mod->BSIM4wb0Given = TRUE; + case BSIM4v7_MOD_WB0 : + mod->BSIM4v7wb0 = value->rValue; + mod->BSIM4v7wb0Given = TRUE; break; - case BSIM4_MOD_WB1 : - mod->BSIM4wb1 = value->rValue; - mod->BSIM4wb1Given = TRUE; + case BSIM4v7_MOD_WB1 : + mod->BSIM4v7wb1 = value->rValue; + mod->BSIM4v7wb1Given = TRUE; break; - case BSIM4_MOD_WALPHA0 : - mod->BSIM4walpha0 = value->rValue; - mod->BSIM4walpha0Given = TRUE; + case BSIM4v7_MOD_WALPHA0 : + mod->BSIM4v7walpha0 = value->rValue; + mod->BSIM4v7walpha0Given = TRUE; break; - case BSIM4_MOD_WALPHA1 : - mod->BSIM4walpha1 = value->rValue; - mod->BSIM4walpha1Given = TRUE; + case BSIM4v7_MOD_WALPHA1 : + mod->BSIM4v7walpha1 = value->rValue; + mod->BSIM4v7walpha1Given = TRUE; break; - case BSIM4_MOD_WBETA0 : - mod->BSIM4wbeta0 = value->rValue; - mod->BSIM4wbeta0Given = TRUE; + case BSIM4v7_MOD_WBETA0 : + mod->BSIM4v7wbeta0 = value->rValue; + mod->BSIM4v7wbeta0Given = TRUE; break; - case BSIM4_MOD_WPHIN : - mod->BSIM4wphin = value->rValue; - mod->BSIM4wphinGiven = TRUE; + case BSIM4v7_MOD_WPHIN : + mod->BSIM4v7wphin = value->rValue; + mod->BSIM4v7wphinGiven = TRUE; break; - case BSIM4_MOD_WAGIDL : - mod->BSIM4wagidl = value->rValue; - mod->BSIM4wagidlGiven = TRUE; + case BSIM4v7_MOD_WAGIDL : + mod->BSIM4v7wagidl = value->rValue; + mod->BSIM4v7wagidlGiven = TRUE; break; - case BSIM4_MOD_WBGIDL : - mod->BSIM4wbgidl = value->rValue; - mod->BSIM4wbgidlGiven = TRUE; + case BSIM4v7_MOD_WBGIDL : + mod->BSIM4v7wbgidl = value->rValue; + mod->BSIM4v7wbgidlGiven = TRUE; break; - case BSIM4_MOD_WCGIDL : - mod->BSIM4wcgidl = value->rValue; - mod->BSIM4wcgidlGiven = TRUE; + case BSIM4v7_MOD_WCGIDL : + mod->BSIM4v7wcgidl = value->rValue; + mod->BSIM4v7wcgidlGiven = TRUE; break; - case BSIM4_MOD_WEGIDL : - mod->BSIM4wegidl = value->rValue; - mod->BSIM4wegidlGiven = TRUE; + case BSIM4v7_MOD_WEGIDL : + mod->BSIM4v7wegidl = value->rValue; + mod->BSIM4v7wegidlGiven = TRUE; break; - case BSIM4_MOD_WFGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4wfgidl = value->rValue; - mod->BSIM4wfgidlGiven = TRUE; + case BSIM4v7_MOD_WFGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7wfgidl = value->rValue; + mod->BSIM4v7wfgidlGiven = TRUE; break; - case BSIM4_MOD_WKGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4wkgidl = value->rValue; - mod->BSIM4wkgidlGiven = TRUE; + case BSIM4v7_MOD_WKGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7wkgidl = value->rValue; + mod->BSIM4v7wkgidlGiven = TRUE; break; - case BSIM4_MOD_WRGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4wrgidl = value->rValue; - mod->BSIM4wrgidlGiven = TRUE; + case BSIM4v7_MOD_WRGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7wrgidl = value->rValue; + mod->BSIM4v7wrgidlGiven = TRUE; break; - case BSIM4_MOD_WAGISL : - mod->BSIM4wagisl = value->rValue; - mod->BSIM4wagislGiven = TRUE; + case BSIM4v7_MOD_WAGISL : + mod->BSIM4v7wagisl = value->rValue; + mod->BSIM4v7wagislGiven = TRUE; break; - case BSIM4_MOD_WBGISL : - mod->BSIM4wbgisl = value->rValue; - mod->BSIM4wbgislGiven = TRUE; + case BSIM4v7_MOD_WBGISL : + mod->BSIM4v7wbgisl = value->rValue; + mod->BSIM4v7wbgislGiven = TRUE; break; - case BSIM4_MOD_WCGISL : - mod->BSIM4wcgisl = value->rValue; - mod->BSIM4wcgislGiven = TRUE; + case BSIM4v7_MOD_WCGISL : + mod->BSIM4v7wcgisl = value->rValue; + mod->BSIM4v7wcgislGiven = TRUE; break; - case BSIM4_MOD_WEGISL : - mod->BSIM4wegisl = value->rValue; - mod->BSIM4wegislGiven = TRUE; + case BSIM4v7_MOD_WEGISL : + mod->BSIM4v7wegisl = value->rValue; + mod->BSIM4v7wegislGiven = TRUE; break; - case BSIM4_MOD_WFGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4wfgisl = value->rValue; - mod->BSIM4wfgislGiven = TRUE; + case BSIM4v7_MOD_WFGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7wfgisl = value->rValue; + mod->BSIM4v7wfgislGiven = TRUE; break; - case BSIM4_MOD_WKGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4wkgisl = value->rValue; - mod->BSIM4wkgislGiven = TRUE; + case BSIM4v7_MOD_WKGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7wkgisl = value->rValue; + mod->BSIM4v7wkgislGiven = TRUE; break; - case BSIM4_MOD_WRGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4wrgisl = value->rValue; - mod->BSIM4wrgislGiven = TRUE; + case BSIM4v7_MOD_WRGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7wrgisl = value->rValue; + mod->BSIM4v7wrgislGiven = TRUE; break; - case BSIM4_MOD_WAIGC : - mod->BSIM4waigc = value->rValue; - mod->BSIM4waigcGiven = TRUE; + case BSIM4v7_MOD_WAIGC : + mod->BSIM4v7waigc = value->rValue; + mod->BSIM4v7waigcGiven = TRUE; break; - case BSIM4_MOD_WBIGC : - mod->BSIM4wbigc = value->rValue; - mod->BSIM4wbigcGiven = TRUE; + case BSIM4v7_MOD_WBIGC : + mod->BSIM4v7wbigc = value->rValue; + mod->BSIM4v7wbigcGiven = TRUE; break; - case BSIM4_MOD_WCIGC : - mod->BSIM4wcigc = value->rValue; - mod->BSIM4wcigcGiven = TRUE; + case BSIM4v7_MOD_WCIGC : + mod->BSIM4v7wcigc = value->rValue; + mod->BSIM4v7wcigcGiven = TRUE; break; - case BSIM4_MOD_WAIGSD : - mod->BSIM4waigsd = value->rValue; - mod->BSIM4waigsdGiven = TRUE; + case BSIM4v7_MOD_WAIGSD : + mod->BSIM4v7waigsd = value->rValue; + mod->BSIM4v7waigsdGiven = TRUE; break; - case BSIM4_MOD_WBIGSD : - mod->BSIM4wbigsd = value->rValue; - mod->BSIM4wbigsdGiven = TRUE; + case BSIM4v7_MOD_WBIGSD : + mod->BSIM4v7wbigsd = value->rValue; + mod->BSIM4v7wbigsdGiven = TRUE; break; - case BSIM4_MOD_WCIGSD : - mod->BSIM4wcigsd = value->rValue; - mod->BSIM4wcigsdGiven = TRUE; + case BSIM4v7_MOD_WCIGSD : + mod->BSIM4v7wcigsd = value->rValue; + mod->BSIM4v7wcigsdGiven = TRUE; break; - case BSIM4_MOD_WAIGS : - mod->BSIM4waigs = value->rValue; - mod->BSIM4waigsGiven = TRUE; + case BSIM4v7_MOD_WAIGS : + mod->BSIM4v7waigs = value->rValue; + mod->BSIM4v7waigsGiven = TRUE; break; - case BSIM4_MOD_WBIGS : - mod->BSIM4wbigs = value->rValue; - mod->BSIM4wbigsGiven = TRUE; + case BSIM4v7_MOD_WBIGS : + mod->BSIM4v7wbigs = value->rValue; + mod->BSIM4v7wbigsGiven = TRUE; break; - case BSIM4_MOD_WCIGS : - mod->BSIM4wcigs = value->rValue; - mod->BSIM4wcigsGiven = TRUE; + case BSIM4v7_MOD_WCIGS : + mod->BSIM4v7wcigs = value->rValue; + mod->BSIM4v7wcigsGiven = TRUE; break; - case BSIM4_MOD_WAIGD : - mod->BSIM4waigd = value->rValue; - mod->BSIM4waigdGiven = TRUE; + case BSIM4v7_MOD_WAIGD : + mod->BSIM4v7waigd = value->rValue; + mod->BSIM4v7waigdGiven = TRUE; break; - case BSIM4_MOD_WBIGD : - mod->BSIM4wbigd = value->rValue; - mod->BSIM4wbigdGiven = TRUE; + case BSIM4v7_MOD_WBIGD : + mod->BSIM4v7wbigd = value->rValue; + mod->BSIM4v7wbigdGiven = TRUE; break; - case BSIM4_MOD_WCIGD : - mod->BSIM4wcigd = value->rValue; - mod->BSIM4wcigdGiven = TRUE; + case BSIM4v7_MOD_WCIGD : + mod->BSIM4v7wcigd = value->rValue; + mod->BSIM4v7wcigdGiven = TRUE; break; - case BSIM4_MOD_WAIGBACC : - mod->BSIM4waigbacc = value->rValue; - mod->BSIM4waigbaccGiven = TRUE; + case BSIM4v7_MOD_WAIGBACC : + mod->BSIM4v7waigbacc = value->rValue; + mod->BSIM4v7waigbaccGiven = TRUE; break; - case BSIM4_MOD_WBIGBACC : - mod->BSIM4wbigbacc = value->rValue; - mod->BSIM4wbigbaccGiven = TRUE; + case BSIM4v7_MOD_WBIGBACC : + mod->BSIM4v7wbigbacc = value->rValue; + mod->BSIM4v7wbigbaccGiven = TRUE; break; - case BSIM4_MOD_WCIGBACC : - mod->BSIM4wcigbacc = value->rValue; - mod->BSIM4wcigbaccGiven = TRUE; + case BSIM4v7_MOD_WCIGBACC : + mod->BSIM4v7wcigbacc = value->rValue; + mod->BSIM4v7wcigbaccGiven = TRUE; break; - case BSIM4_MOD_WAIGBINV : - mod->BSIM4waigbinv = value->rValue; - mod->BSIM4waigbinvGiven = TRUE; + case BSIM4v7_MOD_WAIGBINV : + mod->BSIM4v7waigbinv = value->rValue; + mod->BSIM4v7waigbinvGiven = TRUE; break; - case BSIM4_MOD_WBIGBINV : - mod->BSIM4wbigbinv = value->rValue; - mod->BSIM4wbigbinvGiven = TRUE; + case BSIM4v7_MOD_WBIGBINV : + mod->BSIM4v7wbigbinv = value->rValue; + mod->BSIM4v7wbigbinvGiven = TRUE; break; - case BSIM4_MOD_WCIGBINV : - mod->BSIM4wcigbinv = value->rValue; - mod->BSIM4wcigbinvGiven = TRUE; + case BSIM4v7_MOD_WCIGBINV : + mod->BSIM4v7wcigbinv = value->rValue; + mod->BSIM4v7wcigbinvGiven = TRUE; break; - case BSIM4_MOD_WNIGC : - mod->BSIM4wnigc = value->rValue; - mod->BSIM4wnigcGiven = TRUE; + case BSIM4v7_MOD_WNIGC : + mod->BSIM4v7wnigc = value->rValue; + mod->BSIM4v7wnigcGiven = TRUE; break; - case BSIM4_MOD_WNIGBINV : - mod->BSIM4wnigbinv = value->rValue; - mod->BSIM4wnigbinvGiven = TRUE; + case BSIM4v7_MOD_WNIGBINV : + mod->BSIM4v7wnigbinv = value->rValue; + mod->BSIM4v7wnigbinvGiven = TRUE; break; - case BSIM4_MOD_WNIGBACC : - mod->BSIM4wnigbacc = value->rValue; - mod->BSIM4wnigbaccGiven = TRUE; + case BSIM4v7_MOD_WNIGBACC : + mod->BSIM4v7wnigbacc = value->rValue; + mod->BSIM4v7wnigbaccGiven = TRUE; break; - case BSIM4_MOD_WNTOX : - mod->BSIM4wntox = value->rValue; - mod->BSIM4wntoxGiven = TRUE; + case BSIM4v7_MOD_WNTOX : + mod->BSIM4v7wntox = value->rValue; + mod->BSIM4v7wntoxGiven = TRUE; break; - case BSIM4_MOD_WEIGBINV : - mod->BSIM4weigbinv = value->rValue; - mod->BSIM4weigbinvGiven = TRUE; + case BSIM4v7_MOD_WEIGBINV : + mod->BSIM4v7weigbinv = value->rValue; + mod->BSIM4v7weigbinvGiven = TRUE; break; - case BSIM4_MOD_WPIGCD : - mod->BSIM4wpigcd = value->rValue; - mod->BSIM4wpigcdGiven = TRUE; + case BSIM4v7_MOD_WPIGCD : + mod->BSIM4v7wpigcd = value->rValue; + mod->BSIM4v7wpigcdGiven = TRUE; break; - case BSIM4_MOD_WPOXEDGE : - mod->BSIM4wpoxedge = value->rValue; - mod->BSIM4wpoxedgeGiven = TRUE; + case BSIM4v7_MOD_WPOXEDGE : + mod->BSIM4v7wpoxedge = value->rValue; + mod->BSIM4v7wpoxedgeGiven = TRUE; break; - case BSIM4_MOD_WXRCRG1 : - mod->BSIM4wxrcrg1 = value->rValue; - mod->BSIM4wxrcrg1Given = TRUE; + case BSIM4v7_MOD_WXRCRG1 : + mod->BSIM4v7wxrcrg1 = value->rValue; + mod->BSIM4v7wxrcrg1Given = TRUE; break; - case BSIM4_MOD_WXRCRG2 : - mod->BSIM4wxrcrg2 = value->rValue; - mod->BSIM4wxrcrg2Given = TRUE; + case BSIM4v7_MOD_WXRCRG2 : + mod->BSIM4v7wxrcrg2 = value->rValue; + mod->BSIM4v7wxrcrg2Given = TRUE; break; - case BSIM4_MOD_WLAMBDA : - mod->BSIM4wlambda = value->rValue; - mod->BSIM4wlambdaGiven = TRUE; + case BSIM4v7_MOD_WLAMBDA : + mod->BSIM4v7wlambda = value->rValue; + mod->BSIM4v7wlambdaGiven = TRUE; break; - case BSIM4_MOD_WVTL : - mod->BSIM4wvtl = value->rValue; - mod->BSIM4wvtlGiven = TRUE; + case BSIM4v7_MOD_WVTL : + mod->BSIM4v7wvtl = value->rValue; + mod->BSIM4v7wvtlGiven = TRUE; break; - case BSIM4_MOD_WXN: - mod->BSIM4wxn = value->rValue; - mod->BSIM4wxnGiven = TRUE; + case BSIM4v7_MOD_WXN: + mod->BSIM4v7wxn = value->rValue; + mod->BSIM4v7wxnGiven = TRUE; break; - case BSIM4_MOD_WVFBSDOFF: - mod->BSIM4wvfbsdoff = value->rValue; - mod->BSIM4wvfbsdoffGiven = TRUE; + case BSIM4v7_MOD_WVFBSDOFF: + mod->BSIM4v7wvfbsdoff = value->rValue; + mod->BSIM4v7wvfbsdoffGiven = TRUE; break; - case BSIM4_MOD_WTVFBSDOFF: - mod->BSIM4wtvfbsdoff = value->rValue; - mod->BSIM4wtvfbsdoffGiven = TRUE; + case BSIM4v7_MOD_WTVFBSDOFF: + mod->BSIM4v7wtvfbsdoff = value->rValue; + mod->BSIM4v7wtvfbsdoffGiven = TRUE; break; - case BSIM4_MOD_WEU : - mod->BSIM4weu = value->rValue; - mod->BSIM4weuGiven = TRUE; + case BSIM4v7_MOD_WEU : + mod->BSIM4v7weu = value->rValue; + mod->BSIM4v7weuGiven = TRUE; break; - case BSIM4_MOD_WUCS : - mod->BSIM4wucs = value->rValue; - mod->BSIM4wucsGiven = TRUE; + case BSIM4v7_MOD_WUCS : + mod->BSIM4v7wucs = value->rValue; + mod->BSIM4v7wucsGiven = TRUE; break; - case BSIM4_MOD_WVFB : - mod->BSIM4wvfb = value->rValue; - mod->BSIM4wvfbGiven = TRUE; + case BSIM4v7_MOD_WVFB : + mod->BSIM4v7wvfb = value->rValue; + mod->BSIM4v7wvfbGiven = TRUE; break; - case BSIM4_MOD_WCGSL : - mod->BSIM4wcgsl = value->rValue; - mod->BSIM4wcgslGiven = TRUE; + case BSIM4v7_MOD_WCGSL : + mod->BSIM4v7wcgsl = value->rValue; + mod->BSIM4v7wcgslGiven = TRUE; break; - case BSIM4_MOD_WCGDL : - mod->BSIM4wcgdl = value->rValue; - mod->BSIM4wcgdlGiven = TRUE; + case BSIM4v7_MOD_WCGDL : + mod->BSIM4v7wcgdl = value->rValue; + mod->BSIM4v7wcgdlGiven = TRUE; break; - case BSIM4_MOD_WCKAPPAS : - mod->BSIM4wckappas = value->rValue; - mod->BSIM4wckappasGiven = TRUE; + case BSIM4v7_MOD_WCKAPPAS : + mod->BSIM4v7wckappas = value->rValue; + mod->BSIM4v7wckappasGiven = TRUE; break; - case BSIM4_MOD_WCKAPPAD : - mod->BSIM4wckappad = value->rValue; - mod->BSIM4wckappadGiven = TRUE; + case BSIM4v7_MOD_WCKAPPAD : + mod->BSIM4v7wckappad = value->rValue; + mod->BSIM4v7wckappadGiven = TRUE; break; - case BSIM4_MOD_WCF : - mod->BSIM4wcf = value->rValue; - mod->BSIM4wcfGiven = TRUE; + case BSIM4v7_MOD_WCF : + mod->BSIM4v7wcf = value->rValue; + mod->BSIM4v7wcfGiven = TRUE; break; - case BSIM4_MOD_WCLC : - mod->BSIM4wclc = value->rValue; - mod->BSIM4wclcGiven = TRUE; + case BSIM4v7_MOD_WCLC : + mod->BSIM4v7wclc = value->rValue; + mod->BSIM4v7wclcGiven = TRUE; break; - case BSIM4_MOD_WCLE : - mod->BSIM4wcle = value->rValue; - mod->BSIM4wcleGiven = TRUE; + case BSIM4v7_MOD_WCLE : + mod->BSIM4v7wcle = value->rValue; + mod->BSIM4v7wcleGiven = TRUE; break; - case BSIM4_MOD_WVFBCV : - mod->BSIM4wvfbcv = value->rValue; - mod->BSIM4wvfbcvGiven = TRUE; + case BSIM4v7_MOD_WVFBCV : + mod->BSIM4v7wvfbcv = value->rValue; + mod->BSIM4v7wvfbcvGiven = TRUE; break; - case BSIM4_MOD_WACDE : - mod->BSIM4wacde = value->rValue; - mod->BSIM4wacdeGiven = TRUE; + case BSIM4v7_MOD_WACDE : + mod->BSIM4v7wacde = value->rValue; + mod->BSIM4v7wacdeGiven = TRUE; break; - case BSIM4_MOD_WMOIN : - mod->BSIM4wmoin = value->rValue; - mod->BSIM4wmoinGiven = TRUE; + case BSIM4v7_MOD_WMOIN : + mod->BSIM4v7wmoin = value->rValue; + mod->BSIM4v7wmoinGiven = TRUE; break; - case BSIM4_MOD_WNOFF : - mod->BSIM4wnoff = value->rValue; - mod->BSIM4wnoffGiven = TRUE; + case BSIM4v7_MOD_WNOFF : + mod->BSIM4v7wnoff = value->rValue; + mod->BSIM4v7wnoffGiven = TRUE; break; - case BSIM4_MOD_WVOFFCV : - mod->BSIM4wvoffcv = value->rValue; - mod->BSIM4wvoffcvGiven = TRUE; + case BSIM4v7_MOD_WVOFFCV : + mod->BSIM4v7wvoffcv = value->rValue; + mod->BSIM4v7wvoffcvGiven = TRUE; break; /* Cross-term dependence */ - case BSIM4_MOD_PCDSC : - mod->BSIM4pcdsc = value->rValue; - mod->BSIM4pcdscGiven = TRUE; + case BSIM4v7_MOD_PCDSC : + mod->BSIM4v7pcdsc = value->rValue; + mod->BSIM4v7pcdscGiven = TRUE; break; - case BSIM4_MOD_PCDSCB : - mod->BSIM4pcdscb = value->rValue; - mod->BSIM4pcdscbGiven = TRUE; + case BSIM4v7_MOD_PCDSCB : + mod->BSIM4v7pcdscb = value->rValue; + mod->BSIM4v7pcdscbGiven = TRUE; break; - case BSIM4_MOD_PCDSCD : - mod->BSIM4pcdscd = value->rValue; - mod->BSIM4pcdscdGiven = TRUE; + case BSIM4v7_MOD_PCDSCD : + mod->BSIM4v7pcdscd = value->rValue; + mod->BSIM4v7pcdscdGiven = TRUE; break; - case BSIM4_MOD_PCIT : - mod->BSIM4pcit = value->rValue; - mod->BSIM4pcitGiven = TRUE; + case BSIM4v7_MOD_PCIT : + mod->BSIM4v7pcit = value->rValue; + mod->BSIM4v7pcitGiven = TRUE; break; - case BSIM4_MOD_PNFACTOR : - mod->BSIM4pnfactor = value->rValue; - mod->BSIM4pnfactorGiven = TRUE; + case BSIM4v7_MOD_PNFACTOR : + mod->BSIM4v7pnfactor = value->rValue; + mod->BSIM4v7pnfactorGiven = TRUE; break; - case BSIM4_MOD_PXJ: - mod->BSIM4pxj = value->rValue; - mod->BSIM4pxjGiven = TRUE; + case BSIM4v7_MOD_PXJ: + mod->BSIM4v7pxj = value->rValue; + mod->BSIM4v7pxjGiven = TRUE; break; - case BSIM4_MOD_PVSAT: - mod->BSIM4pvsat = value->rValue; - mod->BSIM4pvsatGiven = TRUE; + case BSIM4v7_MOD_PVSAT: + mod->BSIM4v7pvsat = value->rValue; + mod->BSIM4v7pvsatGiven = TRUE; break; - case BSIM4_MOD_PA0: - mod->BSIM4pa0 = value->rValue; - mod->BSIM4pa0Given = TRUE; + case BSIM4v7_MOD_PA0: + mod->BSIM4v7pa0 = value->rValue; + mod->BSIM4v7pa0Given = TRUE; break; - case BSIM4_MOD_PAGS: - mod->BSIM4pags = value->rValue; - mod->BSIM4pagsGiven = TRUE; + case BSIM4v7_MOD_PAGS: + mod->BSIM4v7pags = value->rValue; + mod->BSIM4v7pagsGiven = TRUE; break; - case BSIM4_MOD_PA1: - mod->BSIM4pa1 = value->rValue; - mod->BSIM4pa1Given = TRUE; + case BSIM4v7_MOD_PA1: + mod->BSIM4v7pa1 = value->rValue; + mod->BSIM4v7pa1Given = TRUE; break; - case BSIM4_MOD_PA2: - mod->BSIM4pa2 = value->rValue; - mod->BSIM4pa2Given = TRUE; + case BSIM4v7_MOD_PA2: + mod->BSIM4v7pa2 = value->rValue; + mod->BSIM4v7pa2Given = TRUE; break; - case BSIM4_MOD_PAT: - mod->BSIM4pat = value->rValue; - mod->BSIM4patGiven = TRUE; + case BSIM4v7_MOD_PAT: + mod->BSIM4v7pat = value->rValue; + mod->BSIM4v7patGiven = TRUE; break; - case BSIM4_MOD_PKETA: - mod->BSIM4pketa = value->rValue; - mod->BSIM4pketaGiven = TRUE; + case BSIM4v7_MOD_PKETA: + mod->BSIM4v7pketa = value->rValue; + mod->BSIM4v7pketaGiven = TRUE; break; - case BSIM4_MOD_PNSUB: - mod->BSIM4pnsub = value->rValue; - mod->BSIM4pnsubGiven = TRUE; + case BSIM4v7_MOD_PNSUB: + mod->BSIM4v7pnsub = value->rValue; + mod->BSIM4v7pnsubGiven = TRUE; break; - case BSIM4_MOD_PNDEP: - mod->BSIM4pndep = value->rValue; - mod->BSIM4pndepGiven = TRUE; - if (mod->BSIM4pndep > 1.0e20) - mod->BSIM4pndep *= 1.0e-6; + case BSIM4v7_MOD_PNDEP: + mod->BSIM4v7pndep = value->rValue; + mod->BSIM4v7pndepGiven = TRUE; + if (mod->BSIM4v7pndep > 1.0e20) + mod->BSIM4v7pndep *= 1.0e-6; break; - case BSIM4_MOD_PNSD: - mod->BSIM4pnsd = value->rValue; - mod->BSIM4pnsdGiven = TRUE; - if (mod->BSIM4pnsd > 1.0e23) - mod->BSIM4pnsd *= 1.0e-6; + case BSIM4v7_MOD_PNSD: + mod->BSIM4v7pnsd = value->rValue; + mod->BSIM4v7pnsdGiven = TRUE; + if (mod->BSIM4v7pnsd > 1.0e23) + mod->BSIM4v7pnsd *= 1.0e-6; break; - case BSIM4_MOD_PNGATE: - mod->BSIM4pngate = value->rValue; - mod->BSIM4pngateGiven = TRUE; - if (mod->BSIM4pngate > 1.0e23) - mod->BSIM4pngate *= 1.0e-6; + case BSIM4v7_MOD_PNGATE: + mod->BSIM4v7pngate = value->rValue; + mod->BSIM4v7pngateGiven = TRUE; + if (mod->BSIM4v7pngate > 1.0e23) + mod->BSIM4v7pngate *= 1.0e-6; break; - case BSIM4_MOD_PGAMMA1: - mod->BSIM4pgamma1 = value->rValue; - mod->BSIM4pgamma1Given = TRUE; + case BSIM4v7_MOD_PGAMMA1: + mod->BSIM4v7pgamma1 = value->rValue; + mod->BSIM4v7pgamma1Given = TRUE; break; - case BSIM4_MOD_PGAMMA2: - mod->BSIM4pgamma2 = value->rValue; - mod->BSIM4pgamma2Given = TRUE; + case BSIM4v7_MOD_PGAMMA2: + mod->BSIM4v7pgamma2 = value->rValue; + mod->BSIM4v7pgamma2Given = TRUE; break; - case BSIM4_MOD_PVBX: - mod->BSIM4pvbx = value->rValue; - mod->BSIM4pvbxGiven = TRUE; + case BSIM4v7_MOD_PVBX: + mod->BSIM4v7pvbx = value->rValue; + mod->BSIM4v7pvbxGiven = TRUE; break; - case BSIM4_MOD_PVBM: - mod->BSIM4pvbm = value->rValue; - mod->BSIM4pvbmGiven = TRUE; + case BSIM4v7_MOD_PVBM: + mod->BSIM4v7pvbm = value->rValue; + mod->BSIM4v7pvbmGiven = TRUE; break; - case BSIM4_MOD_PXT: - mod->BSIM4pxt = value->rValue; - mod->BSIM4pxtGiven = TRUE; + case BSIM4v7_MOD_PXT: + mod->BSIM4v7pxt = value->rValue; + mod->BSIM4v7pxtGiven = TRUE; break; - case BSIM4_MOD_PK1: - mod->BSIM4pk1 = value->rValue; - mod->BSIM4pk1Given = TRUE; + case BSIM4v7_MOD_PK1: + mod->BSIM4v7pk1 = value->rValue; + mod->BSIM4v7pk1Given = TRUE; break; - case BSIM4_MOD_PKT1: - mod->BSIM4pkt1 = value->rValue; - mod->BSIM4pkt1Given = TRUE; + case BSIM4v7_MOD_PKT1: + mod->BSIM4v7pkt1 = value->rValue; + mod->BSIM4v7pkt1Given = TRUE; break; - case BSIM4_MOD_PKT1L: - mod->BSIM4pkt1l = value->rValue; - mod->BSIM4pkt1lGiven = TRUE; + case BSIM4v7_MOD_PKT1L: + mod->BSIM4v7pkt1l = value->rValue; + mod->BSIM4v7pkt1lGiven = TRUE; break; - case BSIM4_MOD_PKT2: - mod->BSIM4pkt2 = value->rValue; - mod->BSIM4pkt2Given = TRUE; + case BSIM4v7_MOD_PKT2: + mod->BSIM4v7pkt2 = value->rValue; + mod->BSIM4v7pkt2Given = TRUE; break; - case BSIM4_MOD_PK2: - mod->BSIM4pk2 = value->rValue; - mod->BSIM4pk2Given = TRUE; + case BSIM4v7_MOD_PK2: + mod->BSIM4v7pk2 = value->rValue; + mod->BSIM4v7pk2Given = TRUE; break; - case BSIM4_MOD_PK3: - mod->BSIM4pk3 = value->rValue; - mod->BSIM4pk3Given = TRUE; + case BSIM4v7_MOD_PK3: + mod->BSIM4v7pk3 = value->rValue; + mod->BSIM4v7pk3Given = TRUE; break; - case BSIM4_MOD_PK3B: - mod->BSIM4pk3b = value->rValue; - mod->BSIM4pk3bGiven = TRUE; + case BSIM4v7_MOD_PK3B: + mod->BSIM4v7pk3b = value->rValue; + mod->BSIM4v7pk3bGiven = TRUE; break; - case BSIM4_MOD_PLPE0: - mod->BSIM4plpe0 = value->rValue; - mod->BSIM4plpe0Given = TRUE; + case BSIM4v7_MOD_PLPE0: + mod->BSIM4v7plpe0 = value->rValue; + mod->BSIM4v7plpe0Given = TRUE; break; - case BSIM4_MOD_PLPEB: - mod->BSIM4plpeb = value->rValue; - mod->BSIM4plpebGiven = TRUE; + case BSIM4v7_MOD_PLPEB: + mod->BSIM4v7plpeb = value->rValue; + mod->BSIM4v7plpebGiven = TRUE; break; - case BSIM4_MOD_PDVTP0: - mod->BSIM4pdvtp0 = value->rValue; - mod->BSIM4pdvtp0Given = TRUE; + case BSIM4v7_MOD_PDVTP0: + mod->BSIM4v7pdvtp0 = value->rValue; + mod->BSIM4v7pdvtp0Given = TRUE; break; - case BSIM4_MOD_PDVTP1: - mod->BSIM4pdvtp1 = value->rValue; - mod->BSIM4pdvtp1Given = TRUE; + case BSIM4v7_MOD_PDVTP1: + mod->BSIM4v7pdvtp1 = value->rValue; + mod->BSIM4v7pdvtp1Given = TRUE; break; - case BSIM4_MOD_PDVTP2: /* New DIBL/Rout */ - mod->BSIM4pdvtp2 = value->rValue; - mod->BSIM4pdvtp2Given = TRUE; + case BSIM4v7_MOD_PDVTP2: /* New DIBL/Rout */ + mod->BSIM4v7pdvtp2 = value->rValue; + mod->BSIM4v7pdvtp2Given = TRUE; break; - case BSIM4_MOD_PDVTP3: - mod->BSIM4pdvtp3 = value->rValue; - mod->BSIM4pdvtp3Given = TRUE; + case BSIM4v7_MOD_PDVTP3: + mod->BSIM4v7pdvtp3 = value->rValue; + mod->BSIM4v7pdvtp3Given = TRUE; break; - case BSIM4_MOD_PDVTP4: - mod->BSIM4pdvtp4 = value->rValue; - mod->BSIM4pdvtp4Given = TRUE; + case BSIM4v7_MOD_PDVTP4: + mod->BSIM4v7pdvtp4 = value->rValue; + mod->BSIM4v7pdvtp4Given = TRUE; break; - case BSIM4_MOD_PDVTP5: - mod->BSIM4pdvtp5 = value->rValue; - mod->BSIM4pdvtp5Given = TRUE; + case BSIM4v7_MOD_PDVTP5: + mod->BSIM4v7pdvtp5 = value->rValue; + mod->BSIM4v7pdvtp5Given = TRUE; break; - case BSIM4_MOD_PW0: - mod->BSIM4pw0 = value->rValue; - mod->BSIM4pw0Given = TRUE; + case BSIM4v7_MOD_PW0: + mod->BSIM4v7pw0 = value->rValue; + mod->BSIM4v7pw0Given = TRUE; break; - case BSIM4_MOD_PDVT0: - mod->BSIM4pdvt0 = value->rValue; - mod->BSIM4pdvt0Given = TRUE; + case BSIM4v7_MOD_PDVT0: + mod->BSIM4v7pdvt0 = value->rValue; + mod->BSIM4v7pdvt0Given = TRUE; break; - case BSIM4_MOD_PDVT1: - mod->BSIM4pdvt1 = value->rValue; - mod->BSIM4pdvt1Given = TRUE; + case BSIM4v7_MOD_PDVT1: + mod->BSIM4v7pdvt1 = value->rValue; + mod->BSIM4v7pdvt1Given = TRUE; break; - case BSIM4_MOD_PDVT2: - mod->BSIM4pdvt2 = value->rValue; - mod->BSIM4pdvt2Given = TRUE; + case BSIM4v7_MOD_PDVT2: + mod->BSIM4v7pdvt2 = value->rValue; + mod->BSIM4v7pdvt2Given = TRUE; break; - case BSIM4_MOD_PDVT0W: - mod->BSIM4pdvt0w = value->rValue; - mod->BSIM4pdvt0wGiven = TRUE; + case BSIM4v7_MOD_PDVT0W: + mod->BSIM4v7pdvt0w = value->rValue; + mod->BSIM4v7pdvt0wGiven = TRUE; break; - case BSIM4_MOD_PDVT1W: - mod->BSIM4pdvt1w = value->rValue; - mod->BSIM4pdvt1wGiven = TRUE; + case BSIM4v7_MOD_PDVT1W: + mod->BSIM4v7pdvt1w = value->rValue; + mod->BSIM4v7pdvt1wGiven = TRUE; break; - case BSIM4_MOD_PDVT2W: - mod->BSIM4pdvt2w = value->rValue; - mod->BSIM4pdvt2wGiven = TRUE; + case BSIM4v7_MOD_PDVT2W: + mod->BSIM4v7pdvt2w = value->rValue; + mod->BSIM4v7pdvt2wGiven = TRUE; break; - case BSIM4_MOD_PDROUT: - mod->BSIM4pdrout = value->rValue; - mod->BSIM4pdroutGiven = TRUE; + case BSIM4v7_MOD_PDROUT: + mod->BSIM4v7pdrout = value->rValue; + mod->BSIM4v7pdroutGiven = TRUE; break; - case BSIM4_MOD_PDSUB: - mod->BSIM4pdsub = value->rValue; - mod->BSIM4pdsubGiven = TRUE; + case BSIM4v7_MOD_PDSUB: + mod->BSIM4v7pdsub = value->rValue; + mod->BSIM4v7pdsubGiven = TRUE; break; - case BSIM4_MOD_PVTH0: - mod->BSIM4pvth0 = value->rValue; - mod->BSIM4pvth0Given = TRUE; + case BSIM4v7_MOD_PVTH0: + mod->BSIM4v7pvth0 = value->rValue; + mod->BSIM4v7pvth0Given = TRUE; break; - case BSIM4_MOD_PUA: - mod->BSIM4pua = value->rValue; - mod->BSIM4puaGiven = TRUE; + case BSIM4v7_MOD_PUA: + mod->BSIM4v7pua = value->rValue; + mod->BSIM4v7puaGiven = TRUE; break; - case BSIM4_MOD_PUA1: - mod->BSIM4pua1 = value->rValue; - mod->BSIM4pua1Given = TRUE; + case BSIM4v7_MOD_PUA1: + mod->BSIM4v7pua1 = value->rValue; + mod->BSIM4v7pua1Given = TRUE; break; - case BSIM4_MOD_PUB: - mod->BSIM4pub = value->rValue; - mod->BSIM4pubGiven = TRUE; + case BSIM4v7_MOD_PUB: + mod->BSIM4v7pub = value->rValue; + mod->BSIM4v7pubGiven = TRUE; break; - case BSIM4_MOD_PUB1: - mod->BSIM4pub1 = value->rValue; - mod->BSIM4pub1Given = TRUE; + case BSIM4v7_MOD_PUB1: + mod->BSIM4v7pub1 = value->rValue; + mod->BSIM4v7pub1Given = TRUE; break; - case BSIM4_MOD_PUC: - mod->BSIM4puc = value->rValue; - mod->BSIM4pucGiven = TRUE; + case BSIM4v7_MOD_PUC: + mod->BSIM4v7puc = value->rValue; + mod->BSIM4v7pucGiven = TRUE; break; - case BSIM4_MOD_PUC1: - mod->BSIM4puc1 = value->rValue; - mod->BSIM4puc1Given = TRUE; + case BSIM4v7_MOD_PUC1: + mod->BSIM4v7puc1 = value->rValue; + mod->BSIM4v7puc1Given = TRUE; break; - case BSIM4_MOD_PU0 : - mod->BSIM4pu0 = value->rValue; - mod->BSIM4pu0Given = TRUE; + case BSIM4v7_MOD_PU0 : + mod->BSIM4v7pu0 = value->rValue; + mod->BSIM4v7pu0Given = TRUE; break; - case BSIM4_MOD_PUTE : - mod->BSIM4pute = value->rValue; - mod->BSIM4puteGiven = TRUE; + case BSIM4v7_MOD_PUTE : + mod->BSIM4v7pute = value->rValue; + mod->BSIM4v7puteGiven = TRUE; break; - case BSIM4_MOD_PUCSTE : - mod->BSIM4pucste = value->rValue; - mod->BSIM4pucsteGiven = TRUE; + case BSIM4v7_MOD_PUCSTE : + mod->BSIM4v7pucste = value->rValue; + mod->BSIM4v7pucsteGiven = TRUE; break; - case BSIM4_MOD_PVOFF: - mod->BSIM4pvoff = value->rValue; - mod->BSIM4pvoffGiven = TRUE; + case BSIM4v7_MOD_PVOFF: + mod->BSIM4v7pvoff = value->rValue; + mod->BSIM4v7pvoffGiven = TRUE; break; - case BSIM4_MOD_PTVOFF: - mod->BSIM4ptvoff = value->rValue; - mod->BSIM4ptvoffGiven = TRUE; + case BSIM4v7_MOD_PTVOFF: + mod->BSIM4v7ptvoff = value->rValue; + mod->BSIM4v7ptvoffGiven = TRUE; break; - case BSIM4_MOD_PTNFACTOR: /* v4.7 temp dep of leakage current */ - mod->BSIM4ptnfactor = value->rValue; - mod->BSIM4ptnfactorGiven = TRUE; + case BSIM4v7_MOD_PTNFACTOR: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7ptnfactor = value->rValue; + mod->BSIM4v7ptnfactorGiven = TRUE; break; - case BSIM4_MOD_PTETA0: /* v4.7 temp dep of leakage current */ - mod->BSIM4pteta0 = value->rValue; - mod->BSIM4pteta0Given = TRUE; + case BSIM4v7_MOD_PTETA0: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7pteta0 = value->rValue; + mod->BSIM4v7pteta0Given = TRUE; break; - case BSIM4_MOD_PTVOFFCV: /* v4.7 temp dep of leakage current */ - mod->BSIM4ptvoffcv = value->rValue; - mod->BSIM4ptvoffcvGiven = TRUE; + case BSIM4v7_MOD_PTVOFFCV: /* v4.7 temp dep of leakage current */ + mod->BSIM4v7ptvoffcv = value->rValue; + mod->BSIM4v7ptvoffcvGiven = TRUE; break; - case BSIM4_MOD_PMINV: - mod->BSIM4pminv = value->rValue; - mod->BSIM4pminvGiven = TRUE; + case BSIM4v7_MOD_PMINV: + mod->BSIM4v7pminv = value->rValue; + mod->BSIM4v7pminvGiven = TRUE; break; - case BSIM4_MOD_PMINVCV: - mod->BSIM4pminvcv = value->rValue; - mod->BSIM4pminvcvGiven = TRUE; + case BSIM4v7_MOD_PMINVCV: + mod->BSIM4v7pminvcv = value->rValue; + mod->BSIM4v7pminvcvGiven = TRUE; break; - case BSIM4_MOD_PFPROUT: - mod->BSIM4pfprout = value->rValue; - mod->BSIM4pfproutGiven = TRUE; + case BSIM4v7_MOD_PFPROUT: + mod->BSIM4v7pfprout = value->rValue; + mod->BSIM4v7pfproutGiven = TRUE; break; - case BSIM4_MOD_PPDITS: - mod->BSIM4ppdits = value->rValue; - mod->BSIM4ppditsGiven = TRUE; + case BSIM4v7_MOD_PPDITS: + mod->BSIM4v7ppdits = value->rValue; + mod->BSIM4v7ppditsGiven = TRUE; break; - case BSIM4_MOD_PPDITSD: - mod->BSIM4ppditsd = value->rValue; - mod->BSIM4ppditsdGiven = TRUE; + case BSIM4v7_MOD_PPDITSD: + mod->BSIM4v7ppditsd = value->rValue; + mod->BSIM4v7ppditsdGiven = TRUE; break; - case BSIM4_MOD_PDELTA : - mod->BSIM4pdelta = value->rValue; - mod->BSIM4pdeltaGiven = TRUE; + case BSIM4v7_MOD_PDELTA : + mod->BSIM4v7pdelta = value->rValue; + mod->BSIM4v7pdeltaGiven = TRUE; break; - case BSIM4_MOD_PRDSW: - mod->BSIM4prdsw = value->rValue; - mod->BSIM4prdswGiven = TRUE; + case BSIM4v7_MOD_PRDSW: + mod->BSIM4v7prdsw = value->rValue; + mod->BSIM4v7prdswGiven = TRUE; break; - case BSIM4_MOD_PRDW: - mod->BSIM4prdw = value->rValue; - mod->BSIM4prdwGiven = TRUE; + case BSIM4v7_MOD_PRDW: + mod->BSIM4v7prdw = value->rValue; + mod->BSIM4v7prdwGiven = TRUE; break; - case BSIM4_MOD_PRSW: - mod->BSIM4prsw = value->rValue; - mod->BSIM4prswGiven = TRUE; + case BSIM4v7_MOD_PRSW: + mod->BSIM4v7prsw = value->rValue; + mod->BSIM4v7prswGiven = TRUE; break; - case BSIM4_MOD_PPRWB: - mod->BSIM4pprwb = value->rValue; - mod->BSIM4pprwbGiven = TRUE; + case BSIM4v7_MOD_PPRWB: + mod->BSIM4v7pprwb = value->rValue; + mod->BSIM4v7pprwbGiven = TRUE; break; - case BSIM4_MOD_PPRWG: - mod->BSIM4pprwg = value->rValue; - mod->BSIM4pprwgGiven = TRUE; + case BSIM4v7_MOD_PPRWG: + mod->BSIM4v7pprwg = value->rValue; + mod->BSIM4v7pprwgGiven = TRUE; break; - case BSIM4_MOD_PPRT: - mod->BSIM4pprt = value->rValue; - mod->BSIM4pprtGiven = TRUE; + case BSIM4v7_MOD_PPRT: + mod->BSIM4v7pprt = value->rValue; + mod->BSIM4v7pprtGiven = TRUE; break; - case BSIM4_MOD_PETA0: - mod->BSIM4peta0 = value->rValue; - mod->BSIM4peta0Given = TRUE; + case BSIM4v7_MOD_PETA0: + mod->BSIM4v7peta0 = value->rValue; + mod->BSIM4v7peta0Given = TRUE; break; - case BSIM4_MOD_PETAB: - mod->BSIM4petab = value->rValue; - mod->BSIM4petabGiven = TRUE; + case BSIM4v7_MOD_PETAB: + mod->BSIM4v7petab = value->rValue; + mod->BSIM4v7petabGiven = TRUE; break; - case BSIM4_MOD_PPCLM: - mod->BSIM4ppclm = value->rValue; - mod->BSIM4ppclmGiven = TRUE; + case BSIM4v7_MOD_PPCLM: + mod->BSIM4v7ppclm = value->rValue; + mod->BSIM4v7ppclmGiven = TRUE; break; - case BSIM4_MOD_PPDIBL1: - mod->BSIM4ppdibl1 = value->rValue; - mod->BSIM4ppdibl1Given = TRUE; + case BSIM4v7_MOD_PPDIBL1: + mod->BSIM4v7ppdibl1 = value->rValue; + mod->BSIM4v7ppdibl1Given = TRUE; break; - case BSIM4_MOD_PPDIBL2: - mod->BSIM4ppdibl2 = value->rValue; - mod->BSIM4ppdibl2Given = TRUE; + case BSIM4v7_MOD_PPDIBL2: + mod->BSIM4v7ppdibl2 = value->rValue; + mod->BSIM4v7ppdibl2Given = TRUE; break; - case BSIM4_MOD_PPDIBLB: - mod->BSIM4ppdiblb = value->rValue; - mod->BSIM4ppdiblbGiven = TRUE; + case BSIM4v7_MOD_PPDIBLB: + mod->BSIM4v7ppdiblb = value->rValue; + mod->BSIM4v7ppdiblbGiven = TRUE; break; - case BSIM4_MOD_PPSCBE1: - mod->BSIM4ppscbe1 = value->rValue; - mod->BSIM4ppscbe1Given = TRUE; + case BSIM4v7_MOD_PPSCBE1: + mod->BSIM4v7ppscbe1 = value->rValue; + mod->BSIM4v7ppscbe1Given = TRUE; break; - case BSIM4_MOD_PPSCBE2: - mod->BSIM4ppscbe2 = value->rValue; - mod->BSIM4ppscbe2Given = TRUE; + case BSIM4v7_MOD_PPSCBE2: + mod->BSIM4v7ppscbe2 = value->rValue; + mod->BSIM4v7ppscbe2Given = TRUE; break; - case BSIM4_MOD_PPVAG: - mod->BSIM4ppvag = value->rValue; - mod->BSIM4ppvagGiven = TRUE; + case BSIM4v7_MOD_PPVAG: + mod->BSIM4v7ppvag = value->rValue; + mod->BSIM4v7ppvagGiven = TRUE; break; - case BSIM4_MOD_PWR : - mod->BSIM4pwr = value->rValue; - mod->BSIM4pwrGiven = TRUE; + case BSIM4v7_MOD_PWR : + mod->BSIM4v7pwr = value->rValue; + mod->BSIM4v7pwrGiven = TRUE; break; - case BSIM4_MOD_PDWG : - mod->BSIM4pdwg = value->rValue; - mod->BSIM4pdwgGiven = TRUE; + case BSIM4v7_MOD_PDWG : + mod->BSIM4v7pdwg = value->rValue; + mod->BSIM4v7pdwgGiven = TRUE; break; - case BSIM4_MOD_PDWB : - mod->BSIM4pdwb = value->rValue; - mod->BSIM4pdwbGiven = TRUE; + case BSIM4v7_MOD_PDWB : + mod->BSIM4v7pdwb = value->rValue; + mod->BSIM4v7pdwbGiven = TRUE; break; - case BSIM4_MOD_PB0 : - mod->BSIM4pb0 = value->rValue; - mod->BSIM4pb0Given = TRUE; + case BSIM4v7_MOD_PB0 : + mod->BSIM4v7pb0 = value->rValue; + mod->BSIM4v7pb0Given = TRUE; break; - case BSIM4_MOD_PB1 : - mod->BSIM4pb1 = value->rValue; - mod->BSIM4pb1Given = TRUE; + case BSIM4v7_MOD_PB1 : + mod->BSIM4v7pb1 = value->rValue; + mod->BSIM4v7pb1Given = TRUE; break; - case BSIM4_MOD_PALPHA0 : - mod->BSIM4palpha0 = value->rValue; - mod->BSIM4palpha0Given = TRUE; + case BSIM4v7_MOD_PALPHA0 : + mod->BSIM4v7palpha0 = value->rValue; + mod->BSIM4v7palpha0Given = TRUE; break; - case BSIM4_MOD_PALPHA1 : - mod->BSIM4palpha1 = value->rValue; - mod->BSIM4palpha1Given = TRUE; + case BSIM4v7_MOD_PALPHA1 : + mod->BSIM4v7palpha1 = value->rValue; + mod->BSIM4v7palpha1Given = TRUE; break; - case BSIM4_MOD_PBETA0 : - mod->BSIM4pbeta0 = value->rValue; - mod->BSIM4pbeta0Given = TRUE; + case BSIM4v7_MOD_PBETA0 : + mod->BSIM4v7pbeta0 = value->rValue; + mod->BSIM4v7pbeta0Given = TRUE; break; - case BSIM4_MOD_PPHIN : - mod->BSIM4pphin = value->rValue; - mod->BSIM4pphinGiven = TRUE; + case BSIM4v7_MOD_PPHIN : + mod->BSIM4v7pphin = value->rValue; + mod->BSIM4v7pphinGiven = TRUE; break; - case BSIM4_MOD_PAGIDL : - mod->BSIM4pagidl = value->rValue; - mod->BSIM4pagidlGiven = TRUE; + case BSIM4v7_MOD_PAGIDL : + mod->BSIM4v7pagidl = value->rValue; + mod->BSIM4v7pagidlGiven = TRUE; break; - case BSIM4_MOD_PBGIDL : - mod->BSIM4pbgidl = value->rValue; - mod->BSIM4pbgidlGiven = TRUE; + case BSIM4v7_MOD_PBGIDL : + mod->BSIM4v7pbgidl = value->rValue; + mod->BSIM4v7pbgidlGiven = TRUE; break; - case BSIM4_MOD_PCGIDL : - mod->BSIM4pcgidl = value->rValue; - mod->BSIM4pcgidlGiven = TRUE; + case BSIM4v7_MOD_PCGIDL : + mod->BSIM4v7pcgidl = value->rValue; + mod->BSIM4v7pcgidlGiven = TRUE; break; - case BSIM4_MOD_PEGIDL : - mod->BSIM4pegidl = value->rValue; - mod->BSIM4pegidlGiven = TRUE; + case BSIM4v7_MOD_PEGIDL : + mod->BSIM4v7pegidl = value->rValue; + mod->BSIM4v7pegidlGiven = TRUE; break; - case BSIM4_MOD_PFGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4pfgidl = value->rValue; - mod->BSIM4pfgidlGiven = TRUE; + case BSIM4v7_MOD_PFGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7pfgidl = value->rValue; + mod->BSIM4v7pfgidlGiven = TRUE; break; - case BSIM4_MOD_PKGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4pkgidl = value->rValue; - mod->BSIM4pkgidlGiven = TRUE; + case BSIM4v7_MOD_PKGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7pkgidl = value->rValue; + mod->BSIM4v7pkgidlGiven = TRUE; break; - case BSIM4_MOD_PRGIDL : /* v4.7 New GIDL/GISL */ - mod->BSIM4prgidl = value->rValue; - mod->BSIM4prgidlGiven = TRUE; + case BSIM4v7_MOD_PRGIDL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7prgidl = value->rValue; + mod->BSIM4v7prgidlGiven = TRUE; break; - case BSIM4_MOD_PAGISL : - mod->BSIM4pagisl = value->rValue; - mod->BSIM4pagislGiven = TRUE; + case BSIM4v7_MOD_PAGISL : + mod->BSIM4v7pagisl = value->rValue; + mod->BSIM4v7pagislGiven = TRUE; break; - case BSIM4_MOD_PBGISL : - mod->BSIM4pbgisl = value->rValue; - mod->BSIM4pbgislGiven = TRUE; + case BSIM4v7_MOD_PBGISL : + mod->BSIM4v7pbgisl = value->rValue; + mod->BSIM4v7pbgislGiven = TRUE; break; - case BSIM4_MOD_PCGISL : - mod->BSIM4pcgisl = value->rValue; - mod->BSIM4pcgislGiven = TRUE; + case BSIM4v7_MOD_PCGISL : + mod->BSIM4v7pcgisl = value->rValue; + mod->BSIM4v7pcgislGiven = TRUE; break; - case BSIM4_MOD_PEGISL : - mod->BSIM4pegisl = value->rValue; - mod->BSIM4pegislGiven = TRUE; + case BSIM4v7_MOD_PEGISL : + mod->BSIM4v7pegisl = value->rValue; + mod->BSIM4v7pegislGiven = TRUE; break; - case BSIM4_MOD_PFGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4pfgisl = value->rValue; - mod->BSIM4pfgislGiven = TRUE; + case BSIM4v7_MOD_PFGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7pfgisl = value->rValue; + mod->BSIM4v7pfgislGiven = TRUE; break; - case BSIM4_MOD_PKGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4pkgisl = value->rValue; - mod->BSIM4pkgislGiven = TRUE; + case BSIM4v7_MOD_PKGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7pkgisl = value->rValue; + mod->BSIM4v7pkgislGiven = TRUE; break; - case BSIM4_MOD_PRGISL : /* v4.7 New GIDL/GISL */ - mod->BSIM4prgisl = value->rValue; - mod->BSIM4prgislGiven = TRUE; + case BSIM4v7_MOD_PRGISL : /* v4.7 New GIDL/GISL */ + mod->BSIM4v7prgisl = value->rValue; + mod->BSIM4v7prgislGiven = TRUE; break; - case BSIM4_MOD_PAIGC : - mod->BSIM4paigc = value->rValue; - mod->BSIM4paigcGiven = TRUE; + case BSIM4v7_MOD_PAIGC : + mod->BSIM4v7paigc = value->rValue; + mod->BSIM4v7paigcGiven = TRUE; break; - case BSIM4_MOD_PBIGC : - mod->BSIM4pbigc = value->rValue; - mod->BSIM4pbigcGiven = TRUE; + case BSIM4v7_MOD_PBIGC : + mod->BSIM4v7pbigc = value->rValue; + mod->BSIM4v7pbigcGiven = TRUE; break; - case BSIM4_MOD_PCIGC : - mod->BSIM4pcigc = value->rValue; - mod->BSIM4pcigcGiven = TRUE; + case BSIM4v7_MOD_PCIGC : + mod->BSIM4v7pcigc = value->rValue; + mod->BSIM4v7pcigcGiven = TRUE; break; - case BSIM4_MOD_PAIGSD : - mod->BSIM4paigsd = value->rValue; - mod->BSIM4paigsdGiven = TRUE; + case BSIM4v7_MOD_PAIGSD : + mod->BSIM4v7paigsd = value->rValue; + mod->BSIM4v7paigsdGiven = TRUE; break; - case BSIM4_MOD_PBIGSD : - mod->BSIM4pbigsd = value->rValue; - mod->BSIM4pbigsdGiven = TRUE; + case BSIM4v7_MOD_PBIGSD : + mod->BSIM4v7pbigsd = value->rValue; + mod->BSIM4v7pbigsdGiven = TRUE; break; - case BSIM4_MOD_PCIGSD : - mod->BSIM4pcigsd = value->rValue; - mod->BSIM4pcigsdGiven = TRUE; + case BSIM4v7_MOD_PCIGSD : + mod->BSIM4v7pcigsd = value->rValue; + mod->BSIM4v7pcigsdGiven = TRUE; break; - case BSIM4_MOD_PAIGS : - mod->BSIM4paigs = value->rValue; - mod->BSIM4paigsGiven = TRUE; + case BSIM4v7_MOD_PAIGS : + mod->BSIM4v7paigs = value->rValue; + mod->BSIM4v7paigsGiven = TRUE; break; - case BSIM4_MOD_PBIGS : - mod->BSIM4pbigs = value->rValue; - mod->BSIM4pbigsGiven = TRUE; + case BSIM4v7_MOD_PBIGS : + mod->BSIM4v7pbigs = value->rValue; + mod->BSIM4v7pbigsGiven = TRUE; break; - case BSIM4_MOD_PCIGS : - mod->BSIM4pcigs = value->rValue; - mod->BSIM4pcigsGiven = TRUE; + case BSIM4v7_MOD_PCIGS : + mod->BSIM4v7pcigs = value->rValue; + mod->BSIM4v7pcigsGiven = TRUE; break; - case BSIM4_MOD_PAIGD : - mod->BSIM4paigd = value->rValue; - mod->BSIM4paigdGiven = TRUE; + case BSIM4v7_MOD_PAIGD : + mod->BSIM4v7paigd = value->rValue; + mod->BSIM4v7paigdGiven = TRUE; break; - case BSIM4_MOD_PBIGD : - mod->BSIM4pbigd = value->rValue; - mod->BSIM4pbigdGiven = TRUE; + case BSIM4v7_MOD_PBIGD : + mod->BSIM4v7pbigd = value->rValue; + mod->BSIM4v7pbigdGiven = TRUE; break; - case BSIM4_MOD_PCIGD : - mod->BSIM4pcigd = value->rValue; - mod->BSIM4pcigdGiven = TRUE; + case BSIM4v7_MOD_PCIGD : + mod->BSIM4v7pcigd = value->rValue; + mod->BSIM4v7pcigdGiven = TRUE; break; - case BSIM4_MOD_PAIGBACC : - mod->BSIM4paigbacc = value->rValue; - mod->BSIM4paigbaccGiven = TRUE; + case BSIM4v7_MOD_PAIGBACC : + mod->BSIM4v7paigbacc = value->rValue; + mod->BSIM4v7paigbaccGiven = TRUE; break; - case BSIM4_MOD_PBIGBACC : - mod->BSIM4pbigbacc = value->rValue; - mod->BSIM4pbigbaccGiven = TRUE; + case BSIM4v7_MOD_PBIGBACC : + mod->BSIM4v7pbigbacc = value->rValue; + mod->BSIM4v7pbigbaccGiven = TRUE; break; - case BSIM4_MOD_PCIGBACC : - mod->BSIM4pcigbacc = value->rValue; - mod->BSIM4pcigbaccGiven = TRUE; + case BSIM4v7_MOD_PCIGBACC : + mod->BSIM4v7pcigbacc = value->rValue; + mod->BSIM4v7pcigbaccGiven = TRUE; break; - case BSIM4_MOD_PAIGBINV : - mod->BSIM4paigbinv = value->rValue; - mod->BSIM4paigbinvGiven = TRUE; + case BSIM4v7_MOD_PAIGBINV : + mod->BSIM4v7paigbinv = value->rValue; + mod->BSIM4v7paigbinvGiven = TRUE; break; - case BSIM4_MOD_PBIGBINV : - mod->BSIM4pbigbinv = value->rValue; - mod->BSIM4pbigbinvGiven = TRUE; + case BSIM4v7_MOD_PBIGBINV : + mod->BSIM4v7pbigbinv = value->rValue; + mod->BSIM4v7pbigbinvGiven = TRUE; break; - case BSIM4_MOD_PCIGBINV : - mod->BSIM4pcigbinv = value->rValue; - mod->BSIM4pcigbinvGiven = TRUE; + case BSIM4v7_MOD_PCIGBINV : + mod->BSIM4v7pcigbinv = value->rValue; + mod->BSIM4v7pcigbinvGiven = TRUE; break; - case BSIM4_MOD_PNIGC : - mod->BSIM4pnigc = value->rValue; - mod->BSIM4pnigcGiven = TRUE; + case BSIM4v7_MOD_PNIGC : + mod->BSIM4v7pnigc = value->rValue; + mod->BSIM4v7pnigcGiven = TRUE; break; - case BSIM4_MOD_PNIGBINV : - mod->BSIM4pnigbinv = value->rValue; - mod->BSIM4pnigbinvGiven = TRUE; + case BSIM4v7_MOD_PNIGBINV : + mod->BSIM4v7pnigbinv = value->rValue; + mod->BSIM4v7pnigbinvGiven = TRUE; break; - case BSIM4_MOD_PNIGBACC : - mod->BSIM4pnigbacc = value->rValue; - mod->BSIM4pnigbaccGiven = TRUE; + case BSIM4v7_MOD_PNIGBACC : + mod->BSIM4v7pnigbacc = value->rValue; + mod->BSIM4v7pnigbaccGiven = TRUE; break; - case BSIM4_MOD_PNTOX : - mod->BSIM4pntox = value->rValue; - mod->BSIM4pntoxGiven = TRUE; + case BSIM4v7_MOD_PNTOX : + mod->BSIM4v7pntox = value->rValue; + mod->BSIM4v7pntoxGiven = TRUE; break; - case BSIM4_MOD_PEIGBINV : - mod->BSIM4peigbinv = value->rValue; - mod->BSIM4peigbinvGiven = TRUE; + case BSIM4v7_MOD_PEIGBINV : + mod->BSIM4v7peigbinv = value->rValue; + mod->BSIM4v7peigbinvGiven = TRUE; break; - case BSIM4_MOD_PPIGCD : - mod->BSIM4ppigcd = value->rValue; - mod->BSIM4ppigcdGiven = TRUE; + case BSIM4v7_MOD_PPIGCD : + mod->BSIM4v7ppigcd = value->rValue; + mod->BSIM4v7ppigcdGiven = TRUE; break; - case BSIM4_MOD_PPOXEDGE : - mod->BSIM4ppoxedge = value->rValue; - mod->BSIM4ppoxedgeGiven = TRUE; + case BSIM4v7_MOD_PPOXEDGE : + mod->BSIM4v7ppoxedge = value->rValue; + mod->BSIM4v7ppoxedgeGiven = TRUE; break; - case BSIM4_MOD_PXRCRG1 : - mod->BSIM4pxrcrg1 = value->rValue; - mod->BSIM4pxrcrg1Given = TRUE; + case BSIM4v7_MOD_PXRCRG1 : + mod->BSIM4v7pxrcrg1 = value->rValue; + mod->BSIM4v7pxrcrg1Given = TRUE; break; - case BSIM4_MOD_PXRCRG2 : - mod->BSIM4pxrcrg2 = value->rValue; - mod->BSIM4pxrcrg2Given = TRUE; + case BSIM4v7_MOD_PXRCRG2 : + mod->BSIM4v7pxrcrg2 = value->rValue; + mod->BSIM4v7pxrcrg2Given = TRUE; break; - case BSIM4_MOD_PLAMBDA : - mod->BSIM4plambda = value->rValue; - mod->BSIM4plambdaGiven = TRUE; + case BSIM4v7_MOD_PLAMBDA : + mod->BSIM4v7plambda = value->rValue; + mod->BSIM4v7plambdaGiven = TRUE; break; - case BSIM4_MOD_PVTL : - mod->BSIM4pvtl = value->rValue; - mod->BSIM4pvtlGiven = TRUE; + case BSIM4v7_MOD_PVTL : + mod->BSIM4v7pvtl = value->rValue; + mod->BSIM4v7pvtlGiven = TRUE; break; - case BSIM4_MOD_PXN: - mod->BSIM4pxn = value->rValue; - mod->BSIM4pxnGiven = TRUE; + case BSIM4v7_MOD_PXN: + mod->BSIM4v7pxn = value->rValue; + mod->BSIM4v7pxnGiven = TRUE; break; - case BSIM4_MOD_PVFBSDOFF: - mod->BSIM4pvfbsdoff = value->rValue; - mod->BSIM4pvfbsdoffGiven = TRUE; + case BSIM4v7_MOD_PVFBSDOFF: + mod->BSIM4v7pvfbsdoff = value->rValue; + mod->BSIM4v7pvfbsdoffGiven = TRUE; break; - case BSIM4_MOD_PTVFBSDOFF: - mod->BSIM4ptvfbsdoff = value->rValue; - mod->BSIM4ptvfbsdoffGiven = TRUE; + case BSIM4v7_MOD_PTVFBSDOFF: + mod->BSIM4v7ptvfbsdoff = value->rValue; + mod->BSIM4v7ptvfbsdoffGiven = TRUE; break; - case BSIM4_MOD_PEU : - mod->BSIM4peu = value->rValue; - mod->BSIM4peuGiven = TRUE; + case BSIM4v7_MOD_PEU : + mod->BSIM4v7peu = value->rValue; + mod->BSIM4v7peuGiven = TRUE; break; - case BSIM4_MOD_PUCS : - mod->BSIM4pucs = value->rValue; - mod->BSIM4pucsGiven = TRUE; + case BSIM4v7_MOD_PUCS : + mod->BSIM4v7pucs = value->rValue; + mod->BSIM4v7pucsGiven = TRUE; break; - case BSIM4_MOD_PVFB : - mod->BSIM4pvfb = value->rValue; - mod->BSIM4pvfbGiven = TRUE; + case BSIM4v7_MOD_PVFB : + mod->BSIM4v7pvfb = value->rValue; + mod->BSIM4v7pvfbGiven = TRUE; break; - case BSIM4_MOD_PCGSL : - mod->BSIM4pcgsl = value->rValue; - mod->BSIM4pcgslGiven = TRUE; + case BSIM4v7_MOD_PCGSL : + mod->BSIM4v7pcgsl = value->rValue; + mod->BSIM4v7pcgslGiven = TRUE; break; - case BSIM4_MOD_PCGDL : - mod->BSIM4pcgdl = value->rValue; - mod->BSIM4pcgdlGiven = TRUE; + case BSIM4v7_MOD_PCGDL : + mod->BSIM4v7pcgdl = value->rValue; + mod->BSIM4v7pcgdlGiven = TRUE; break; - case BSIM4_MOD_PCKAPPAS : - mod->BSIM4pckappas = value->rValue; - mod->BSIM4pckappasGiven = TRUE; + case BSIM4v7_MOD_PCKAPPAS : + mod->BSIM4v7pckappas = value->rValue; + mod->BSIM4v7pckappasGiven = TRUE; break; - case BSIM4_MOD_PCKAPPAD : - mod->BSIM4pckappad = value->rValue; - mod->BSIM4pckappadGiven = TRUE; + case BSIM4v7_MOD_PCKAPPAD : + mod->BSIM4v7pckappad = value->rValue; + mod->BSIM4v7pckappadGiven = TRUE; break; - case BSIM4_MOD_PCF : - mod->BSIM4pcf = value->rValue; - mod->BSIM4pcfGiven = TRUE; + case BSIM4v7_MOD_PCF : + mod->BSIM4v7pcf = value->rValue; + mod->BSIM4v7pcfGiven = TRUE; break; - case BSIM4_MOD_PCLC : - mod->BSIM4pclc = value->rValue; - mod->BSIM4pclcGiven = TRUE; + case BSIM4v7_MOD_PCLC : + mod->BSIM4v7pclc = value->rValue; + mod->BSIM4v7pclcGiven = TRUE; break; - case BSIM4_MOD_PCLE : - mod->BSIM4pcle = value->rValue; - mod->BSIM4pcleGiven = TRUE; + case BSIM4v7_MOD_PCLE : + mod->BSIM4v7pcle = value->rValue; + mod->BSIM4v7pcleGiven = TRUE; break; - case BSIM4_MOD_PVFBCV : - mod->BSIM4pvfbcv = value->rValue; - mod->BSIM4pvfbcvGiven = TRUE; + case BSIM4v7_MOD_PVFBCV : + mod->BSIM4v7pvfbcv = value->rValue; + mod->BSIM4v7pvfbcvGiven = TRUE; break; - case BSIM4_MOD_PACDE : - mod->BSIM4pacde = value->rValue; - mod->BSIM4pacdeGiven = TRUE; + case BSIM4v7_MOD_PACDE : + mod->BSIM4v7pacde = value->rValue; + mod->BSIM4v7pacdeGiven = TRUE; break; - case BSIM4_MOD_PMOIN : - mod->BSIM4pmoin = value->rValue; - mod->BSIM4pmoinGiven = TRUE; + case BSIM4v7_MOD_PMOIN : + mod->BSIM4v7pmoin = value->rValue; + mod->BSIM4v7pmoinGiven = TRUE; break; - case BSIM4_MOD_PNOFF : - mod->BSIM4pnoff = value->rValue; - mod->BSIM4pnoffGiven = TRUE; + case BSIM4v7_MOD_PNOFF : + mod->BSIM4v7pnoff = value->rValue; + mod->BSIM4v7pnoffGiven = TRUE; break; - case BSIM4_MOD_PVOFFCV : - mod->BSIM4pvoffcv = value->rValue; - mod->BSIM4pvoffcvGiven = TRUE; + case BSIM4v7_MOD_PVOFFCV : + mod->BSIM4v7pvoffcv = value->rValue; + mod->BSIM4v7pvoffcvGiven = TRUE; break; - case BSIM4_MOD_TNOM : - mod->BSIM4tnom = value->rValue + CONSTCtoK; - mod->BSIM4tnomGiven = TRUE; + case BSIM4v7_MOD_TNOM : + mod->BSIM4v7tnom = value->rValue + CONSTCtoK; + mod->BSIM4v7tnomGiven = TRUE; break; - case BSIM4_MOD_CGSO : - mod->BSIM4cgso = value->rValue; - mod->BSIM4cgsoGiven = TRUE; + case BSIM4v7_MOD_CGSO : + mod->BSIM4v7cgso = value->rValue; + mod->BSIM4v7cgsoGiven = TRUE; break; - case BSIM4_MOD_CGDO : - mod->BSIM4cgdo = value->rValue; - mod->BSIM4cgdoGiven = TRUE; + case BSIM4v7_MOD_CGDO : + mod->BSIM4v7cgdo = value->rValue; + mod->BSIM4v7cgdoGiven = TRUE; break; - case BSIM4_MOD_CGBO : - mod->BSIM4cgbo = value->rValue; - mod->BSIM4cgboGiven = TRUE; + case BSIM4v7_MOD_CGBO : + mod->BSIM4v7cgbo = value->rValue; + mod->BSIM4v7cgboGiven = TRUE; break; - case BSIM4_MOD_XPART : - mod->BSIM4xpart = value->rValue; - mod->BSIM4xpartGiven = TRUE; + case BSIM4v7_MOD_XPART : + mod->BSIM4v7xpart = value->rValue; + mod->BSIM4v7xpartGiven = TRUE; break; - case BSIM4_MOD_RSH : - mod->BSIM4sheetResistance = value->rValue; - mod->BSIM4sheetResistanceGiven = TRUE; + case BSIM4v7_MOD_RSH : + mod->BSIM4v7sheetResistance = value->rValue; + mod->BSIM4v7sheetResistanceGiven = TRUE; break; - case BSIM4_MOD_JSS : - mod->BSIM4SjctSatCurDensity = value->rValue; - mod->BSIM4SjctSatCurDensityGiven = TRUE; + case BSIM4v7_MOD_JSS : + mod->BSIM4v7SjctSatCurDensity = value->rValue; + mod->BSIM4v7SjctSatCurDensityGiven = TRUE; break; - case BSIM4_MOD_JSWS : - mod->BSIM4SjctSidewallSatCurDensity = value->rValue; - mod->BSIM4SjctSidewallSatCurDensityGiven = TRUE; + case BSIM4v7_MOD_JSWS : + mod->BSIM4v7SjctSidewallSatCurDensity = value->rValue; + mod->BSIM4v7SjctSidewallSatCurDensityGiven = TRUE; break; - case BSIM4_MOD_JSWGS : - mod->BSIM4SjctGateSidewallSatCurDensity = value->rValue; - mod->BSIM4SjctGateSidewallSatCurDensityGiven = TRUE; + case BSIM4v7_MOD_JSWGS : + mod->BSIM4v7SjctGateSidewallSatCurDensity = value->rValue; + mod->BSIM4v7SjctGateSidewallSatCurDensityGiven = TRUE; break; - case BSIM4_MOD_PBS : - mod->BSIM4SbulkJctPotential = value->rValue; - mod->BSIM4SbulkJctPotentialGiven = TRUE; + case BSIM4v7_MOD_PBS : + mod->BSIM4v7SbulkJctPotential = value->rValue; + mod->BSIM4v7SbulkJctPotentialGiven = TRUE; break; - case BSIM4_MOD_MJS : - mod->BSIM4SbulkJctBotGradingCoeff = value->rValue; - mod->BSIM4SbulkJctBotGradingCoeffGiven = TRUE; + case BSIM4v7_MOD_MJS : + mod->BSIM4v7SbulkJctBotGradingCoeff = value->rValue; + mod->BSIM4v7SbulkJctBotGradingCoeffGiven = TRUE; break; - case BSIM4_MOD_PBSWS : - mod->BSIM4SsidewallJctPotential = value->rValue; - mod->BSIM4SsidewallJctPotentialGiven = TRUE; + case BSIM4v7_MOD_PBSWS : + mod->BSIM4v7SsidewallJctPotential = value->rValue; + mod->BSIM4v7SsidewallJctPotentialGiven = TRUE; break; - case BSIM4_MOD_MJSWS : - mod->BSIM4SbulkJctSideGradingCoeff = value->rValue; - mod->BSIM4SbulkJctSideGradingCoeffGiven = TRUE; + case BSIM4v7_MOD_MJSWS : + mod->BSIM4v7SbulkJctSideGradingCoeff = value->rValue; + mod->BSIM4v7SbulkJctSideGradingCoeffGiven = TRUE; break; - case BSIM4_MOD_CJS : - mod->BSIM4SunitAreaJctCap = value->rValue; - mod->BSIM4SunitAreaJctCapGiven = TRUE; + case BSIM4v7_MOD_CJS : + mod->BSIM4v7SunitAreaJctCap = value->rValue; + mod->BSIM4v7SunitAreaJctCapGiven = TRUE; break; - case BSIM4_MOD_CJSWS : - mod->BSIM4SunitLengthSidewallJctCap = value->rValue; - mod->BSIM4SunitLengthSidewallJctCapGiven = TRUE; + case BSIM4v7_MOD_CJSWS : + mod->BSIM4v7SunitLengthSidewallJctCap = value->rValue; + mod->BSIM4v7SunitLengthSidewallJctCapGiven = TRUE; break; - case BSIM4_MOD_NJS : - mod->BSIM4SjctEmissionCoeff = value->rValue; - mod->BSIM4SjctEmissionCoeffGiven = TRUE; + case BSIM4v7_MOD_NJS : + mod->BSIM4v7SjctEmissionCoeff = value->rValue; + mod->BSIM4v7SjctEmissionCoeffGiven = TRUE; break; - case BSIM4_MOD_PBSWGS : - mod->BSIM4SGatesidewallJctPotential = value->rValue; - mod->BSIM4SGatesidewallJctPotentialGiven = TRUE; + case BSIM4v7_MOD_PBSWGS : + mod->BSIM4v7SGatesidewallJctPotential = value->rValue; + mod->BSIM4v7SGatesidewallJctPotentialGiven = TRUE; break; - case BSIM4_MOD_MJSWGS : - mod->BSIM4SbulkJctGateSideGradingCoeff = value->rValue; - mod->BSIM4SbulkJctGateSideGradingCoeffGiven = TRUE; + case BSIM4v7_MOD_MJSWGS : + mod->BSIM4v7SbulkJctGateSideGradingCoeff = value->rValue; + mod->BSIM4v7SbulkJctGateSideGradingCoeffGiven = TRUE; break; - case BSIM4_MOD_CJSWGS : - mod->BSIM4SunitLengthGateSidewallJctCap = value->rValue; - mod->BSIM4SunitLengthGateSidewallJctCapGiven = TRUE; + case BSIM4v7_MOD_CJSWGS : + mod->BSIM4v7SunitLengthGateSidewallJctCap = value->rValue; + mod->BSIM4v7SunitLengthGateSidewallJctCapGiven = TRUE; break; - case BSIM4_MOD_XTIS : - mod->BSIM4SjctTempExponent = value->rValue; - mod->BSIM4SjctTempExponentGiven = TRUE; + case BSIM4v7_MOD_XTIS : + mod->BSIM4v7SjctTempExponent = value->rValue; + mod->BSIM4v7SjctTempExponentGiven = TRUE; break; - case BSIM4_MOD_JSD : - mod->BSIM4DjctSatCurDensity = value->rValue; - mod->BSIM4DjctSatCurDensityGiven = TRUE; + case BSIM4v7_MOD_JSD : + mod->BSIM4v7DjctSatCurDensity = value->rValue; + mod->BSIM4v7DjctSatCurDensityGiven = TRUE; break; - case BSIM4_MOD_JSWD : - mod->BSIM4DjctSidewallSatCurDensity = value->rValue; - mod->BSIM4DjctSidewallSatCurDensityGiven = TRUE; + case BSIM4v7_MOD_JSWD : + mod->BSIM4v7DjctSidewallSatCurDensity = value->rValue; + mod->BSIM4v7DjctSidewallSatCurDensityGiven = TRUE; break; - case BSIM4_MOD_JSWGD : - mod->BSIM4DjctGateSidewallSatCurDensity = value->rValue; - mod->BSIM4DjctGateSidewallSatCurDensityGiven = TRUE; + case BSIM4v7_MOD_JSWGD : + mod->BSIM4v7DjctGateSidewallSatCurDensity = value->rValue; + mod->BSIM4v7DjctGateSidewallSatCurDensityGiven = TRUE; break; - case BSIM4_MOD_PBD : - mod->BSIM4DbulkJctPotential = value->rValue; - mod->BSIM4DbulkJctPotentialGiven = TRUE; + case BSIM4v7_MOD_PBD : + mod->BSIM4v7DbulkJctPotential = value->rValue; + mod->BSIM4v7DbulkJctPotentialGiven = TRUE; break; - case BSIM4_MOD_MJD : - mod->BSIM4DbulkJctBotGradingCoeff = value->rValue; - mod->BSIM4DbulkJctBotGradingCoeffGiven = TRUE; + case BSIM4v7_MOD_MJD : + mod->BSIM4v7DbulkJctBotGradingCoeff = value->rValue; + mod->BSIM4v7DbulkJctBotGradingCoeffGiven = TRUE; break; - case BSIM4_MOD_PBSWD : - mod->BSIM4DsidewallJctPotential = value->rValue; - mod->BSIM4DsidewallJctPotentialGiven = TRUE; + case BSIM4v7_MOD_PBSWD : + mod->BSIM4v7DsidewallJctPotential = value->rValue; + mod->BSIM4v7DsidewallJctPotentialGiven = TRUE; break; - case BSIM4_MOD_MJSWD : - mod->BSIM4DbulkJctSideGradingCoeff = value->rValue; - mod->BSIM4DbulkJctSideGradingCoeffGiven = TRUE; + case BSIM4v7_MOD_MJSWD : + mod->BSIM4v7DbulkJctSideGradingCoeff = value->rValue; + mod->BSIM4v7DbulkJctSideGradingCoeffGiven = TRUE; break; - case BSIM4_MOD_CJD : - mod->BSIM4DunitAreaJctCap = value->rValue; - mod->BSIM4DunitAreaJctCapGiven = TRUE; + case BSIM4v7_MOD_CJD : + mod->BSIM4v7DunitAreaJctCap = value->rValue; + mod->BSIM4v7DunitAreaJctCapGiven = TRUE; break; - case BSIM4_MOD_CJSWD : - mod->BSIM4DunitLengthSidewallJctCap = value->rValue; - mod->BSIM4DunitLengthSidewallJctCapGiven = TRUE; + case BSIM4v7_MOD_CJSWD : + mod->BSIM4v7DunitLengthSidewallJctCap = value->rValue; + mod->BSIM4v7DunitLengthSidewallJctCapGiven = TRUE; break; - case BSIM4_MOD_NJD : - mod->BSIM4DjctEmissionCoeff = value->rValue; - mod->BSIM4DjctEmissionCoeffGiven = TRUE; + case BSIM4v7_MOD_NJD : + mod->BSIM4v7DjctEmissionCoeff = value->rValue; + mod->BSIM4v7DjctEmissionCoeffGiven = TRUE; break; - case BSIM4_MOD_PBSWGD : - mod->BSIM4DGatesidewallJctPotential = value->rValue; - mod->BSIM4DGatesidewallJctPotentialGiven = TRUE; + case BSIM4v7_MOD_PBSWGD : + mod->BSIM4v7DGatesidewallJctPotential = value->rValue; + mod->BSIM4v7DGatesidewallJctPotentialGiven = TRUE; break; - case BSIM4_MOD_MJSWGD : - mod->BSIM4DbulkJctGateSideGradingCoeff = value->rValue; - mod->BSIM4DbulkJctGateSideGradingCoeffGiven = TRUE; + case BSIM4v7_MOD_MJSWGD : + mod->BSIM4v7DbulkJctGateSideGradingCoeff = value->rValue; + mod->BSIM4v7DbulkJctGateSideGradingCoeffGiven = TRUE; break; - case BSIM4_MOD_CJSWGD : - mod->BSIM4DunitLengthGateSidewallJctCap = value->rValue; - mod->BSIM4DunitLengthGateSidewallJctCapGiven = TRUE; + case BSIM4v7_MOD_CJSWGD : + mod->BSIM4v7DunitLengthGateSidewallJctCap = value->rValue; + mod->BSIM4v7DunitLengthGateSidewallJctCapGiven = TRUE; break; - case BSIM4_MOD_XTID : - mod->BSIM4DjctTempExponent = value->rValue; - mod->BSIM4DjctTempExponentGiven = TRUE; + case BSIM4v7_MOD_XTID : + mod->BSIM4v7DjctTempExponent = value->rValue; + mod->BSIM4v7DjctTempExponentGiven = TRUE; break; - case BSIM4_MOD_LINT : - mod->BSIM4Lint = value->rValue; - mod->BSIM4LintGiven = TRUE; + case BSIM4v7_MOD_LINT : + mod->BSIM4v7Lint = value->rValue; + mod->BSIM4v7LintGiven = TRUE; break; - case BSIM4_MOD_LL : - mod->BSIM4Ll = value->rValue; - mod->BSIM4LlGiven = TRUE; + case BSIM4v7_MOD_LL : + mod->BSIM4v7Ll = value->rValue; + mod->BSIM4v7LlGiven = TRUE; break; - case BSIM4_MOD_LLC : - mod->BSIM4Llc = value->rValue; - mod->BSIM4LlcGiven = TRUE; + case BSIM4v7_MOD_LLC : + mod->BSIM4v7Llc = value->rValue; + mod->BSIM4v7LlcGiven = TRUE; break; - case BSIM4_MOD_LLN : - mod->BSIM4Lln = value->rValue; - mod->BSIM4LlnGiven = TRUE; + case BSIM4v7_MOD_LLN : + mod->BSIM4v7Lln = value->rValue; + mod->BSIM4v7LlnGiven = TRUE; break; - case BSIM4_MOD_LW : - mod->BSIM4Lw = value->rValue; - mod->BSIM4LwGiven = TRUE; + case BSIM4v7_MOD_LW : + mod->BSIM4v7Lw = value->rValue; + mod->BSIM4v7LwGiven = TRUE; break; - case BSIM4_MOD_LWC : - mod->BSIM4Lwc = value->rValue; - mod->BSIM4LwcGiven = TRUE; + case BSIM4v7_MOD_LWC : + mod->BSIM4v7Lwc = value->rValue; + mod->BSIM4v7LwcGiven = TRUE; break; - case BSIM4_MOD_LWN : - mod->BSIM4Lwn = value->rValue; - mod->BSIM4LwnGiven = TRUE; + case BSIM4v7_MOD_LWN : + mod->BSIM4v7Lwn = value->rValue; + mod->BSIM4v7LwnGiven = TRUE; break; - case BSIM4_MOD_LWL : - mod->BSIM4Lwl = value->rValue; - mod->BSIM4LwlGiven = TRUE; + case BSIM4v7_MOD_LWL : + mod->BSIM4v7Lwl = value->rValue; + mod->BSIM4v7LwlGiven = TRUE; break; - case BSIM4_MOD_LWLC : - mod->BSIM4Lwlc = value->rValue; - mod->BSIM4LwlcGiven = TRUE; + case BSIM4v7_MOD_LWLC : + mod->BSIM4v7Lwlc = value->rValue; + mod->BSIM4v7LwlcGiven = TRUE; break; - case BSIM4_MOD_LMIN : - mod->BSIM4Lmin = value->rValue; - mod->BSIM4LminGiven = TRUE; + case BSIM4v7_MOD_LMIN : + mod->BSIM4v7Lmin = value->rValue; + mod->BSIM4v7LminGiven = TRUE; break; - case BSIM4_MOD_LMAX : - mod->BSIM4Lmax = value->rValue; - mod->BSIM4LmaxGiven = TRUE; + case BSIM4v7_MOD_LMAX : + mod->BSIM4v7Lmax = value->rValue; + mod->BSIM4v7LmaxGiven = TRUE; break; - case BSIM4_MOD_WINT : - mod->BSIM4Wint = value->rValue; - mod->BSIM4WintGiven = TRUE; + case BSIM4v7_MOD_WINT : + mod->BSIM4v7Wint = value->rValue; + mod->BSIM4v7WintGiven = TRUE; break; - case BSIM4_MOD_WL : - mod->BSIM4Wl = value->rValue; - mod->BSIM4WlGiven = TRUE; + case BSIM4v7_MOD_WL : + mod->BSIM4v7Wl = value->rValue; + mod->BSIM4v7WlGiven = TRUE; break; - case BSIM4_MOD_WLC : - mod->BSIM4Wlc = value->rValue; - mod->BSIM4WlcGiven = TRUE; + case BSIM4v7_MOD_WLC : + mod->BSIM4v7Wlc = value->rValue; + mod->BSIM4v7WlcGiven = TRUE; break; - case BSIM4_MOD_WLN : - mod->BSIM4Wln = value->rValue; - mod->BSIM4WlnGiven = TRUE; + case BSIM4v7_MOD_WLN : + mod->BSIM4v7Wln = value->rValue; + mod->BSIM4v7WlnGiven = TRUE; break; - case BSIM4_MOD_WW : - mod->BSIM4Ww = value->rValue; - mod->BSIM4WwGiven = TRUE; + case BSIM4v7_MOD_WW : + mod->BSIM4v7Ww = value->rValue; + mod->BSIM4v7WwGiven = TRUE; break; - case BSIM4_MOD_WWC : - mod->BSIM4Wwc = value->rValue; - mod->BSIM4WwcGiven = TRUE; + case BSIM4v7_MOD_WWC : + mod->BSIM4v7Wwc = value->rValue; + mod->BSIM4v7WwcGiven = TRUE; break; - case BSIM4_MOD_WWN : - mod->BSIM4Wwn = value->rValue; - mod->BSIM4WwnGiven = TRUE; + case BSIM4v7_MOD_WWN : + mod->BSIM4v7Wwn = value->rValue; + mod->BSIM4v7WwnGiven = TRUE; break; - case BSIM4_MOD_WWL : - mod->BSIM4Wwl = value->rValue; - mod->BSIM4WwlGiven = TRUE; + case BSIM4v7_MOD_WWL : + mod->BSIM4v7Wwl = value->rValue; + mod->BSIM4v7WwlGiven = TRUE; break; - case BSIM4_MOD_WWLC : - mod->BSIM4Wwlc = value->rValue; - mod->BSIM4WwlcGiven = TRUE; + case BSIM4v7_MOD_WWLC : + mod->BSIM4v7Wwlc = value->rValue; + mod->BSIM4v7WwlcGiven = TRUE; break; - case BSIM4_MOD_WMIN : - mod->BSIM4Wmin = value->rValue; - mod->BSIM4WminGiven = TRUE; + case BSIM4v7_MOD_WMIN : + mod->BSIM4v7Wmin = value->rValue; + mod->BSIM4v7WminGiven = TRUE; break; - case BSIM4_MOD_WMAX : - mod->BSIM4Wmax = value->rValue; - mod->BSIM4WmaxGiven = TRUE; + case BSIM4v7_MOD_WMAX : + mod->BSIM4v7Wmax = value->rValue; + mod->BSIM4v7WmaxGiven = TRUE; break; - case BSIM4_MOD_NOIA : - mod->BSIM4oxideTrapDensityA = value->rValue; - mod->BSIM4oxideTrapDensityAGiven = TRUE; + case BSIM4v7_MOD_NOIA : + mod->BSIM4v7oxideTrapDensityA = value->rValue; + mod->BSIM4v7oxideTrapDensityAGiven = TRUE; break; - case BSIM4_MOD_NOIB : - mod->BSIM4oxideTrapDensityB = value->rValue; - mod->BSIM4oxideTrapDensityBGiven = TRUE; + case BSIM4v7_MOD_NOIB : + mod->BSIM4v7oxideTrapDensityB = value->rValue; + mod->BSIM4v7oxideTrapDensityBGiven = TRUE; break; - case BSIM4_MOD_NOIC : - mod->BSIM4oxideTrapDensityC = value->rValue; - mod->BSIM4oxideTrapDensityCGiven = TRUE; + case BSIM4v7_MOD_NOIC : + mod->BSIM4v7oxideTrapDensityC = value->rValue; + mod->BSIM4v7oxideTrapDensityCGiven = TRUE; break; - case BSIM4_MOD_EM : - mod->BSIM4em = value->rValue; - mod->BSIM4emGiven = TRUE; + case BSIM4v7_MOD_EM : + mod->BSIM4v7em = value->rValue; + mod->BSIM4v7emGiven = TRUE; break; - case BSIM4_MOD_EF : - mod->BSIM4ef = value->rValue; - mod->BSIM4efGiven = TRUE; + case BSIM4v7_MOD_EF : + mod->BSIM4v7ef = value->rValue; + mod->BSIM4v7efGiven = TRUE; break; - case BSIM4_MOD_AF : - mod->BSIM4af = value->rValue; - mod->BSIM4afGiven = TRUE; + case BSIM4v7_MOD_AF : + mod->BSIM4v7af = value->rValue; + mod->BSIM4v7afGiven = TRUE; break; - case BSIM4_MOD_KF : - mod->BSIM4kf = value->rValue; - mod->BSIM4kfGiven = TRUE; + case BSIM4v7_MOD_KF : + mod->BSIM4v7kf = value->rValue; + mod->BSIM4v7kfGiven = TRUE; break; - case BSIM4_MOD_VGS_MAX: - mod->BSIM4vgsMax = value->rValue; - mod->BSIM4vgsMaxGiven = TRUE; + case BSIM4v7_MOD_VGS_MAX: + mod->BSIM4v7vgsMax = value->rValue; + mod->BSIM4v7vgsMaxGiven = TRUE; break; - case BSIM4_MOD_VGD_MAX: - mod->BSIM4vgdMax = value->rValue; - mod->BSIM4vgdMaxGiven = TRUE; + case BSIM4v7_MOD_VGD_MAX: + mod->BSIM4v7vgdMax = value->rValue; + mod->BSIM4v7vgdMaxGiven = TRUE; break; - case BSIM4_MOD_VGB_MAX: - mod->BSIM4vgbMax = value->rValue; - mod->BSIM4vgbMaxGiven = TRUE; + case BSIM4v7_MOD_VGB_MAX: + mod->BSIM4v7vgbMax = value->rValue; + mod->BSIM4v7vgbMaxGiven = TRUE; break; - case BSIM4_MOD_VDS_MAX: - mod->BSIM4vdsMax = value->rValue; - mod->BSIM4vdsMaxGiven = TRUE; + case BSIM4v7_MOD_VDS_MAX: + mod->BSIM4v7vdsMax = value->rValue; + mod->BSIM4v7vdsMaxGiven = TRUE; break; - case BSIM4_MOD_VBS_MAX: - mod->BSIM4vbsMax = value->rValue; - mod->BSIM4vbsMaxGiven = TRUE; + case BSIM4v7_MOD_VBS_MAX: + mod->BSIM4v7vbsMax = value->rValue; + mod->BSIM4v7vbsMaxGiven = TRUE; break; - case BSIM4_MOD_VBD_MAX: - mod->BSIM4vbdMax = value->rValue; - mod->BSIM4vbdMaxGiven = TRUE; + case BSIM4v7_MOD_VBD_MAX: + mod->BSIM4v7vbdMax = value->rValue; + mod->BSIM4v7vbdMaxGiven = TRUE; break; - case BSIM4_MOD_NMOS : + case BSIM4v7_MOD_NMOS : if(value->iValue) { - mod->BSIM4type = 1; - mod->BSIM4typeGiven = TRUE; + mod->BSIM4v7type = 1; + mod->BSIM4v7typeGiven = TRUE; } break; - case BSIM4_MOD_PMOS : + case BSIM4v7_MOD_PMOS : if(value->iValue) { - mod->BSIM4type = - 1; - mod->BSIM4typeGiven = TRUE; + mod->BSIM4v7type = - 1; + mod->BSIM4v7typeGiven = TRUE; } break; default: diff --git a/src/spicelib/devices/bsim4v7/b4v7noi.c b/src/spicelib/devices/bsim4v7/b4v7noi.c index 57f8c043d..1a758348d 100644 --- a/src/spicelib/devices/bsim4v7/b4v7noi.c +++ b/src/spicelib/devices/bsim4v7/b4v7noi.c @@ -20,7 +20,7 @@ **********/ #include "ngspice/ngspice.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/cktdefs.h" #include "ngspice/iferrmsg.h" #include "ngspice/noisedef.h" @@ -37,8 +37,8 @@ static double Eval1ovFNoise( double Vds, -BSIM4model *model, -BSIM4instance *here, +BSIM4v7model *model, +BSIM4v7instance *here, double freq, double temp) { struct bsim4SizeDependParam *pParam; @@ -46,41 +46,41 @@ double cd, esat, DelClm, EffFreq, N0, Nl, Leff, Leffsq; double T0=0.0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ssi; pParam = here->pParam; - cd = fabs(here->BSIM4cd); - Leff = pParam->BSIM4leff - 2.0 * model->BSIM4lintnoi; + cd = fabs(here->BSIM4v7cd); + Leff = pParam->BSIM4v7leff - 2.0 * model->BSIM4v7lintnoi; Leffsq = Leff * Leff; - esat = 2.0 * here->BSIM4vsattemp / here->BSIM4ueff; - if(model->BSIM4em<=0.0) DelClm = 0.0; /* flicker noise modified -JX */ + esat = 2.0 * here->BSIM4v7vsattemp / here->BSIM4v7ueff; + if(model->BSIM4v7em<=0.0) DelClm = 0.0; /* flicker noise modified -JX */ else { - T0 = ((((Vds - here->BSIM4Vdseff) / pParam->BSIM4litl) - + model->BSIM4em) / esat); - DelClm = pParam->BSIM4litl * log (MAX(T0, N_MINLOG)); + T0 = ((((Vds - here->BSIM4v7Vdseff) / pParam->BSIM4v7litl) + + model->BSIM4v7em) / esat); + DelClm = pParam->BSIM4v7litl * log (MAX(T0, N_MINLOG)); if (DelClm < 0.0) DelClm = 0.0; /* bugfix */ } - EffFreq = pow(freq, model->BSIM4ef); - T1 = CHARGE * CHARGE * CONSTboltz * cd * temp * here->BSIM4ueff; - T2 = 1.0e10 * EffFreq * here->BSIM4Abulk * model->BSIM4coxe * Leffsq; - N0 = model->BSIM4coxe * here->BSIM4Vgsteff / CHARGE; - Nl = model->BSIM4coxe * here->BSIM4Vgsteff - * (1.0 - here->BSIM4AbovVgst2Vtm * here->BSIM4Vdseff) / CHARGE; + EffFreq = pow(freq, model->BSIM4v7ef); + T1 = CHARGE * CHARGE * CONSTboltz * cd * temp * here->BSIM4v7ueff; + T2 = 1.0e10 * EffFreq * here->BSIM4v7Abulk * model->BSIM4v7coxe * Leffsq; + N0 = model->BSIM4v7coxe * here->BSIM4v7Vgsteff / CHARGE; + Nl = model->BSIM4v7coxe * here->BSIM4v7Vgsteff + * (1.0 - here->BSIM4v7AbovVgst2Vtm * here->BSIM4v7Vdseff) / CHARGE; - T3 = model->BSIM4oxideTrapDensityA - * log(MAX(((N0 + here->BSIM4nstar) / (Nl + here->BSIM4nstar)), N_MINLOG)); - T4 = model->BSIM4oxideTrapDensityB * (N0 - Nl); - T5 = model->BSIM4oxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl); + T3 = model->BSIM4v7oxideTrapDensityA + * log(MAX(((N0 + here->BSIM4v7nstar) / (Nl + here->BSIM4v7nstar)), N_MINLOG)); + T4 = model->BSIM4v7oxideTrapDensityB * (N0 - Nl); + T5 = model->BSIM4v7oxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl); T6 = CONSTboltz * temp * cd * cd; - T7 = 1.0e10 * EffFreq * Leffsq * pParam->BSIM4weff * here->BSIM4nf; - T8 = model->BSIM4oxideTrapDensityA + model->BSIM4oxideTrapDensityB * Nl - + model->BSIM4oxideTrapDensityC * Nl * Nl; - T9 = (Nl + here->BSIM4nstar) * (Nl + here->BSIM4nstar); + T7 = 1.0e10 * EffFreq * Leffsq * pParam->BSIM4v7weff * here->BSIM4v7nf; + T8 = model->BSIM4v7oxideTrapDensityA + model->BSIM4v7oxideTrapDensityB * Nl + + model->BSIM4v7oxideTrapDensityC * Nl * Nl; + T9 = (Nl + here->BSIM4v7nstar) * (Nl + here->BSIM4v7nstar); Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9; return Ssi; } int -BSIM4noise ( +BSIM4v7noise ( int mode, int operation, GENmodel *inModel, CKTcircuit *ckt, @@ -89,14 +89,14 @@ double *OnDens) { NOISEAN *job = (NOISEAN *) ckt->CKTcurJob; -BSIM4model *model = (BSIM4model *)inModel; -BSIM4instance *here; +BSIM4v7model *model = (BSIM4v7model *)inModel; +BSIM4v7instance *here; struct bsim4SizeDependParam *pParam; char name[N_MXVLNTH]; double tempOnoise; double tempInoise; -double noizDens[BSIM4NSRCS]; -double lnNdens[BSIM4NSRCS]; +double noizDens[BSIM4v7NSRCS]; +double lnNdens[BSIM4v7NSRCS]; double T0, T1, T2, T3, T4, T5, T6, T7, T8, T10, T11; double Vds, Ssi, Swi; @@ -111,7 +111,7 @@ int i; double m; /* define the names of the noise sources */ - static char *BSIM4nNames[BSIM4NSRCS] = + static char *BSIM4v7nNames[BSIM4v7NSRCS] = { /* Note that we have to keep the order */ ".rd", /* noise due to rd */ ".rs", /* noise due to rs */ @@ -130,14 +130,14 @@ double m; "" /* total transistor noise */ }; - for (; model != NULL; model = model->BSIM4nextModel) + for (; model != NULL; model = model->BSIM4v7nextModel) { - if(model->BSIM4tnoiMod != 2) { - noizDens[BSIM4CORLNOIZ] = 0.0; - lnNdens[BSIM4CORLNOIZ] = N_MINLOG; + if(model->BSIM4v7tnoiMod != 2) { + noizDens[BSIM4v7CORLNOIZ] = 0.0; + lnNdens[BSIM4v7CORLNOIZ] = N_MINLOG; } - for (here = model->BSIM4instances; here != NULL; - here = here->BSIM4nextInstance) + for (here = model->BSIM4v7instances; here != NULL; + here = here->BSIM4v7nextInstance) { pParam = here->pParam; switch (operation) { case N_OPEN: @@ -147,10 +147,10 @@ double m; if (job->NStpsSm != 0) { switch (mode) { case N_DENS: - for (i = 0; i < BSIM4NSRCS; i++) + for (i = 0; i < BSIM4v7NSRCS; i++) { (void) sprintf(name, "onoise.%s%s", - here->BSIM4name, - BSIM4nNames[i]); + here->BSIM4v7name, + BSIM4v7nNames[i]); data->namelist = TREALLOC(IFuid, data->namelist, data->numPlots + 1); @@ -163,10 +163,10 @@ double m; } break; case INT_NOIZ: - for (i = 0; i < BSIM4NSRCS; i++) + for (i = 0; i < BSIM4v7NSRCS; i++) { (void) sprintf(name, "onoise_total.%s%s", - here->BSIM4name, - BSIM4nNames[i]); + here->BSIM4v7name, + BSIM4v7nNames[i]); data->namelist = TREALLOC(IFuid, data->namelist, data->numPlots + 1); @@ -178,8 +178,8 @@ double m; /* we've added one more plot */ (void) sprintf(name, "inoise_total.%s%s", - here->BSIM4name, - BSIM4nNames[i]); + here->BSIM4v7name, + BSIM4v7nNames[i]); data->namelist = TREALLOC(IFuid, data->namelist, data->numPlots + 1); @@ -195,205 +195,205 @@ double m; } break; case N_CALC: - m = here->BSIM4m; + m = here->BSIM4v7m; switch (mode) { case N_DENS: - if (model->BSIM4tnoiMod == 0) - { if (model->BSIM4rdsMod == 0) - { gspr = here->BSIM4sourceConductance; - gdpr = here->BSIM4drainConductance; - if (here->BSIM4grdsw > 0.0) - tmp = 1.0 / here->BSIM4grdsw; /* tmp used below */ + if (model->BSIM4v7tnoiMod == 0) + { if (model->BSIM4v7rdsMod == 0) + { gspr = here->BSIM4v7sourceConductance; + gdpr = here->BSIM4v7drainConductance; + if (here->BSIM4v7grdsw > 0.0) + tmp = 1.0 / here->BSIM4v7grdsw; /* tmp used below */ else tmp = 0.0; } else - { gspr = here->BSIM4gstot; - gdpr = here->BSIM4gdtot; + { gspr = here->BSIM4v7gstot; + gdpr = here->BSIM4v7gdtot; tmp = 0.0; } } - else if(model->BSIM4tnoiMod == 1) - { T5 = here->BSIM4Vgsteff / here->BSIM4EsatL; + else if(model->BSIM4v7tnoiMod == 1) + { T5 = here->BSIM4v7Vgsteff / here->BSIM4v7EsatL; T5 *= T5; - npart_beta = model->BSIM4rnoia * (1.0 + T5 - * model->BSIM4tnoia * pParam->BSIM4leff); - npart_theta = model->BSIM4rnoib * (1.0 + T5 - * model->BSIM4tnoib * pParam->BSIM4leff); + npart_beta = model->BSIM4v7rnoia * (1.0 + T5 + * model->BSIM4v7tnoia * pParam->BSIM4v7leff); + npart_theta = model->BSIM4v7rnoib * (1.0 + T5 + * model->BSIM4v7tnoib * pParam->BSIM4v7leff); if(npart_theta > 0.9) npart_theta = 0.9; if(npart_theta > 0.9 * npart_beta) npart_theta = 0.9 * npart_beta; //4.6.2 - if (model->BSIM4rdsMod == 0) - { gspr = here->BSIM4sourceConductance; - gdpr = here->BSIM4drainConductance; + if (model->BSIM4v7rdsMod == 0) + { gspr = here->BSIM4v7sourceConductance; + gdpr = here->BSIM4v7drainConductance; } else - { gspr = here->BSIM4gstot; - gdpr = here->BSIM4gdtot; + { gspr = here->BSIM4v7gstot; + gdpr = here->BSIM4v7gdtot; } - if ((*(ckt->CKTstates[0] + here->BSIM4vds)) >= 0.0) + if ((*(ckt->CKTstates[0] + here->BSIM4v7vds)) >= 0.0) gspr = gspr * (1.0 + npart_theta * npart_theta * gspr - / here->BSIM4IdovVds); + / here->BSIM4v7IdovVds); else gdpr = gdpr * (1.0 + npart_theta * npart_theta * gdpr - / here->BSIM4IdovVds); + / here->BSIM4v7IdovVds); } else { /* tnoiMod=2 (v4.7) */ - if (model->BSIM4rdsMod == 0) - { gspr = here->BSIM4sourceConductance; - gdpr = here->BSIM4drainConductance; + if (model->BSIM4v7rdsMod == 0) + { gspr = here->BSIM4v7sourceConductance; + gdpr = here->BSIM4v7drainConductance; } else - { gspr = here->BSIM4gstot; - gdpr = here->BSIM4gdtot; + { gspr = here->BSIM4v7gstot; + gdpr = here->BSIM4v7gdtot; } } - NevalSrc(&noizDens[BSIM4RDNOIZ], - &lnNdens[BSIM4RDNOIZ], ckt, THERMNOISE, - here->BSIM4dNodePrime, here->BSIM4dNode, + NevalSrc(&noizDens[BSIM4v7RDNOIZ], + &lnNdens[BSIM4v7RDNOIZ], ckt, THERMNOISE, + here->BSIM4v7dNodePrime, here->BSIM4v7dNode, gdpr * m); - NevalSrc(&noizDens[BSIM4RSNOIZ], - &lnNdens[BSIM4RSNOIZ], ckt, THERMNOISE, - here->BSIM4sNodePrime, here->BSIM4sNode, + NevalSrc(&noizDens[BSIM4v7RSNOIZ], + &lnNdens[BSIM4v7RSNOIZ], ckt, THERMNOISE, + here->BSIM4v7sNodePrime, here->BSIM4v7sNode, gspr * m); - if (here->BSIM4rgateMod == 1) - { NevalSrc(&noizDens[BSIM4RGNOIZ], - &lnNdens[BSIM4RGNOIZ], ckt, THERMNOISE, - here->BSIM4gNodePrime, here->BSIM4gNodeExt, - here->BSIM4grgeltd * m); + if (here->BSIM4v7rgateMod == 1) + { NevalSrc(&noizDens[BSIM4v7RGNOIZ], + &lnNdens[BSIM4v7RGNOIZ], ckt, THERMNOISE, + here->BSIM4v7gNodePrime, here->BSIM4v7gNodeExt, + here->BSIM4v7grgeltd * m); } - else if (here->BSIM4rgateMod == 2) + else if (here->BSIM4v7rgateMod == 2) { - T0 = 1.0 + here->BSIM4grgeltd/here->BSIM4gcrg; + T0 = 1.0 + here->BSIM4v7grgeltd/here->BSIM4v7gcrg; T1 = T0 * T0; - NevalSrc(&noizDens[BSIM4RGNOIZ], - &lnNdens[BSIM4RGNOIZ], ckt, THERMNOISE, - here->BSIM4gNodePrime, here->BSIM4gNodeExt, - here->BSIM4grgeltd * m / T1); + NevalSrc(&noizDens[BSIM4v7RGNOIZ], + &lnNdens[BSIM4v7RGNOIZ], ckt, THERMNOISE, + here->BSIM4v7gNodePrime, here->BSIM4v7gNodeExt, + here->BSIM4v7grgeltd * m / T1); } - else if (here->BSIM4rgateMod == 3) - { NevalSrc(&noizDens[BSIM4RGNOIZ], - &lnNdens[BSIM4RGNOIZ], ckt, THERMNOISE, - here->BSIM4gNodeMid, here->BSIM4gNodeExt, - here->BSIM4grgeltd * m); + else if (here->BSIM4v7rgateMod == 3) + { NevalSrc(&noizDens[BSIM4v7RGNOIZ], + &lnNdens[BSIM4v7RGNOIZ], ckt, THERMNOISE, + here->BSIM4v7gNodeMid, here->BSIM4v7gNodeExt, + here->BSIM4v7grgeltd * m); } else - { noizDens[BSIM4RGNOIZ] = 0.0; - lnNdens[BSIM4RGNOIZ] = - log(MAX(noizDens[BSIM4RGNOIZ], N_MINLOG)); + { noizDens[BSIM4v7RGNOIZ] = 0.0; + lnNdens[BSIM4v7RGNOIZ] = + log(MAX(noizDens[BSIM4v7RGNOIZ], N_MINLOG)); } bodymode = 5; - if (here->BSIM4rbodyMod == 2) - { if( ( !model->BSIM4rbps0Given) || - ( !model->BSIM4rbpd0Given) ) + if (here->BSIM4v7rbodyMod == 2) + { if( ( !model->BSIM4v7rbps0Given) || + ( !model->BSIM4v7rbpd0Given) ) bodymode = 1; else - if( (!model->BSIM4rbsbx0Given && !model->BSIM4rbsby0Given) || - (!model->BSIM4rbdbx0Given && !model->BSIM4rbdby0Given) ) + if( (!model->BSIM4v7rbsbx0Given && !model->BSIM4v7rbsby0Given) || + (!model->BSIM4v7rbdbx0Given && !model->BSIM4v7rbdby0Given) ) bodymode = 3; } - if (here->BSIM4rbodyMod) + if (here->BSIM4v7rbodyMod) { if(bodymode == 5) { - NevalSrc(&noizDens[BSIM4RBPSNOIZ], - &lnNdens[BSIM4RBPSNOIZ], ckt, THERMNOISE, - here->BSIM4bNodePrime, here->BSIM4sbNode, - here->BSIM4grbps * m); - NevalSrc(&noizDens[BSIM4RBPDNOIZ], - &lnNdens[BSIM4RBPDNOIZ], ckt, THERMNOISE, - here->BSIM4bNodePrime, here->BSIM4dbNode, - here->BSIM4grbpd * m); - NevalSrc(&noizDens[BSIM4RBPBNOIZ], - &lnNdens[BSIM4RBPBNOIZ], ckt, THERMNOISE, - here->BSIM4bNodePrime, here->BSIM4bNode, - here->BSIM4grbpb * m); - NevalSrc(&noizDens[BSIM4RBSBNOIZ], - &lnNdens[BSIM4RBSBNOIZ], ckt, THERMNOISE, - here->BSIM4bNode, here->BSIM4sbNode, - here->BSIM4grbsb * m); - NevalSrc(&noizDens[BSIM4RBDBNOIZ], - &lnNdens[BSIM4RBDBNOIZ], ckt, THERMNOISE, - here->BSIM4bNode, here->BSIM4dbNode, - here->BSIM4grbdb * m); + NevalSrc(&noizDens[BSIM4v7RBPSNOIZ], + &lnNdens[BSIM4v7RBPSNOIZ], ckt, THERMNOISE, + here->BSIM4v7bNodePrime, here->BSIM4v7sbNode, + here->BSIM4v7grbps * m); + NevalSrc(&noizDens[BSIM4v7RBPDNOIZ], + &lnNdens[BSIM4v7RBPDNOIZ], ckt, THERMNOISE, + here->BSIM4v7bNodePrime, here->BSIM4v7dbNode, + here->BSIM4v7grbpd * m); + NevalSrc(&noizDens[BSIM4v7RBPBNOIZ], + &lnNdens[BSIM4v7RBPBNOIZ], ckt, THERMNOISE, + here->BSIM4v7bNodePrime, here->BSIM4v7bNode, + here->BSIM4v7grbpb * m); + NevalSrc(&noizDens[BSIM4v7RBSBNOIZ], + &lnNdens[BSIM4v7RBSBNOIZ], ckt, THERMNOISE, + here->BSIM4v7bNode, here->BSIM4v7sbNode, + here->BSIM4v7grbsb * m); + NevalSrc(&noizDens[BSIM4v7RBDBNOIZ], + &lnNdens[BSIM4v7RBDBNOIZ], ckt, THERMNOISE, + here->BSIM4v7bNode, here->BSIM4v7dbNode, + here->BSIM4v7grbdb * m); } if(bodymode == 3) { - NevalSrc(&noizDens[BSIM4RBPSNOIZ], - &lnNdens[BSIM4RBPSNOIZ], ckt, THERMNOISE, - here->BSIM4bNodePrime, here->BSIM4sbNode, - here->BSIM4grbps * m); - NevalSrc(&noizDens[BSIM4RBPDNOIZ], - &lnNdens[BSIM4RBPDNOIZ], ckt, THERMNOISE, - here->BSIM4bNodePrime, here->BSIM4dbNode, - here->BSIM4grbpd * m); - NevalSrc(&noizDens[BSIM4RBPBNOIZ], - &lnNdens[BSIM4RBPBNOIZ], ckt, THERMNOISE, - here->BSIM4bNodePrime, here->BSIM4bNode, - here->BSIM4grbpb * m); - noizDens[BSIM4RBSBNOIZ] = noizDens[BSIM4RBDBNOIZ] = 0.0; - lnNdens[BSIM4RBSBNOIZ] = - log(MAX(noizDens[BSIM4RBSBNOIZ], N_MINLOG)); - lnNdens[BSIM4RBDBNOIZ] = - log(MAX(noizDens[BSIM4RBDBNOIZ], N_MINLOG)); + NevalSrc(&noizDens[BSIM4v7RBPSNOIZ], + &lnNdens[BSIM4v7RBPSNOIZ], ckt, THERMNOISE, + here->BSIM4v7bNodePrime, here->BSIM4v7sbNode, + here->BSIM4v7grbps * m); + NevalSrc(&noizDens[BSIM4v7RBPDNOIZ], + &lnNdens[BSIM4v7RBPDNOIZ], ckt, THERMNOISE, + here->BSIM4v7bNodePrime, here->BSIM4v7dbNode, + here->BSIM4v7grbpd * m); + NevalSrc(&noizDens[BSIM4v7RBPBNOIZ], + &lnNdens[BSIM4v7RBPBNOIZ], ckt, THERMNOISE, + here->BSIM4v7bNodePrime, here->BSIM4v7bNode, + here->BSIM4v7grbpb * m); + noizDens[BSIM4v7RBSBNOIZ] = noizDens[BSIM4v7RBDBNOIZ] = 0.0; + lnNdens[BSIM4v7RBSBNOIZ] = + log(MAX(noizDens[BSIM4v7RBSBNOIZ], N_MINLOG)); + lnNdens[BSIM4v7RBDBNOIZ] = + log(MAX(noizDens[BSIM4v7RBDBNOIZ], N_MINLOG)); } if(bodymode == 1) { - NevalSrc(&noizDens[BSIM4RBPBNOIZ], - &lnNdens[BSIM4RBPBNOIZ], ckt, THERMNOISE, - here->BSIM4bNodePrime, here->BSIM4bNode, - here->BSIM4grbpb * m); - noizDens[BSIM4RBPSNOIZ] = noizDens[BSIM4RBPDNOIZ] = 0.0; - noizDens[BSIM4RBSBNOIZ] = noizDens[BSIM4RBDBNOIZ] = 0.0; - lnNdens[BSIM4RBPSNOIZ] = - log(MAX(noizDens[BSIM4RBPSNOIZ], N_MINLOG)); - lnNdens[BSIM4RBPDNOIZ] = - log(MAX(noizDens[BSIM4RBPDNOIZ], N_MINLOG)); - lnNdens[BSIM4RBSBNOIZ] = - log(MAX(noizDens[BSIM4RBSBNOIZ], N_MINLOG)); - lnNdens[BSIM4RBDBNOIZ] = - log(MAX(noizDens[BSIM4RBDBNOIZ], N_MINLOG)); + NevalSrc(&noizDens[BSIM4v7RBPBNOIZ], + &lnNdens[BSIM4v7RBPBNOIZ], ckt, THERMNOISE, + here->BSIM4v7bNodePrime, here->BSIM4v7bNode, + here->BSIM4v7grbpb * m); + noizDens[BSIM4v7RBPSNOIZ] = noizDens[BSIM4v7RBPDNOIZ] = 0.0; + noizDens[BSIM4v7RBSBNOIZ] = noizDens[BSIM4v7RBDBNOIZ] = 0.0; + lnNdens[BSIM4v7RBPSNOIZ] = + log(MAX(noizDens[BSIM4v7RBPSNOIZ], N_MINLOG)); + lnNdens[BSIM4v7RBPDNOIZ] = + log(MAX(noizDens[BSIM4v7RBPDNOIZ], N_MINLOG)); + lnNdens[BSIM4v7RBSBNOIZ] = + log(MAX(noizDens[BSIM4v7RBSBNOIZ], N_MINLOG)); + lnNdens[BSIM4v7RBDBNOIZ] = + log(MAX(noizDens[BSIM4v7RBDBNOIZ], N_MINLOG)); } } else - { noizDens[BSIM4RBPSNOIZ] = noizDens[BSIM4RBPDNOIZ] = 0.0; - noizDens[BSIM4RBPBNOIZ] = 0.0; - noizDens[BSIM4RBSBNOIZ] = noizDens[BSIM4RBDBNOIZ] = 0.0; - lnNdens[BSIM4RBPSNOIZ] = - log(MAX(noizDens[BSIM4RBPSNOIZ], N_MINLOG)); - lnNdens[BSIM4RBPDNOIZ] = - log(MAX(noizDens[BSIM4RBPDNOIZ], N_MINLOG)); - lnNdens[BSIM4RBPBNOIZ] = - log(MAX(noizDens[BSIM4RBPBNOIZ], N_MINLOG)); - lnNdens[BSIM4RBSBNOIZ] = - log(MAX(noizDens[BSIM4RBSBNOIZ], N_MINLOG)); - lnNdens[BSIM4RBDBNOIZ] = - log(MAX(noizDens[BSIM4RBDBNOIZ], N_MINLOG)); + { noizDens[BSIM4v7RBPSNOIZ] = noizDens[BSIM4v7RBPDNOIZ] = 0.0; + noizDens[BSIM4v7RBPBNOIZ] = 0.0; + noizDens[BSIM4v7RBSBNOIZ] = noizDens[BSIM4v7RBDBNOIZ] = 0.0; + lnNdens[BSIM4v7RBPSNOIZ] = + log(MAX(noizDens[BSIM4v7RBPSNOIZ], N_MINLOG)); + lnNdens[BSIM4v7RBPDNOIZ] = + log(MAX(noizDens[BSIM4v7RBPDNOIZ], N_MINLOG)); + lnNdens[BSIM4v7RBPBNOIZ] = + log(MAX(noizDens[BSIM4v7RBPBNOIZ], N_MINLOG)); + lnNdens[BSIM4v7RBSBNOIZ] = + log(MAX(noizDens[BSIM4v7RBSBNOIZ], N_MINLOG)); + lnNdens[BSIM4v7RBDBNOIZ] = + log(MAX(noizDens[BSIM4v7RBDBNOIZ], N_MINLOG)); } - if(model->BSIM4tnoiMod == 2) + if(model->BSIM4v7tnoiMod == 2) { - eta = 1.0 - here->BSIM4Vdseff * here->BSIM4AbovVgst2Vtm; + eta = 1.0 - here->BSIM4v7Vdseff * here->BSIM4v7AbovVgst2Vtm; T0 = 1.0 - eta; T1 = 1.0 + eta; - T2 = T1 + 2.0 * here->BSIM4Abulk * model->BSIM4vtm / here->BSIM4Vgsteff; - Leff = pParam->BSIM4leff; - Lvsat = Leff * (1.0 + here->BSIM4Vdseff / here->BSIM4EsatL); + T2 = T1 + 2.0 * here->BSIM4v7Abulk * model->BSIM4v7vtm / here->BSIM4v7Vgsteff; + Leff = pParam->BSIM4v7leff; + Lvsat = Leff * (1.0 + here->BSIM4v7Vdseff / here->BSIM4v7EsatL); T6 = Leff / Lvsat; - T5 = here->BSIM4Vgsteff / here->BSIM4EsatL; + T5 = here->BSIM4v7Vgsteff / here->BSIM4v7EsatL; T5 = T5 * T5; gamma = T6 * (0.5 * T1 + T0 * T0 / (6.0 * T2)); T3 = T2 * T2; @@ -403,56 +403,56 @@ double m; T7 = T0 / T2; epsilon = (T7 - T7 * T7 * T7 / 3.0) / (6.0 * T6); - T8 = here->BSIM4Vgsteff / here->BSIM4EsatL; + T8 = here->BSIM4v7Vgsteff / here->BSIM4v7EsatL; T8 *= T8; - npart_c = model->BSIM4rnoic * (1.0 + T8 - * model->BSIM4tnoic * Leff); + npart_c = model->BSIM4v7rnoic * (1.0 + T8 + * model->BSIM4v7tnoic * Leff); ctnoi = epsilon / sqrt(gamma * delta) * (2.5316 * npart_c); - npart_beta = model->BSIM4rnoia * (1.0 + T8 - * model->BSIM4tnoia * Leff); - npart_theta = model->BSIM4rnoib * (1.0 + T8 - * model->BSIM4tnoib * Leff); + npart_beta = model->BSIM4v7rnoia * (1.0 + T8 + * model->BSIM4v7tnoia * Leff); + npart_theta = model->BSIM4v7rnoib * (1.0 + T8 + * model->BSIM4v7tnoib * Leff); gamma = gamma * (3.0 * npart_beta * npart_beta); delta = delta * (3.75 * npart_theta * npart_theta); - GammaGd0 = gamma * here->BSIM4noiGd0; - C0 = here->BSIM4Coxeff * pParam->BSIM4weffCV * here->BSIM4nf * pParam->BSIM4leffCV; - T0 = C0 / here->BSIM4noiGd0; + GammaGd0 = gamma * here->BSIM4v7noiGd0; + C0 = here->BSIM4v7Coxeff * pParam->BSIM4v7weffCV * here->BSIM4v7nf * pParam->BSIM4v7leffCV; + T0 = C0 / here->BSIM4v7noiGd0; sigrat = T0 * sqrt(delta / gamma); } - switch(model->BSIM4tnoiMod) + switch(model->BSIM4v7tnoiMod) { case 0: - T0 = here->BSIM4ueff * fabs(here->BSIM4qinv); - T1 = T0 * tmp + pParam->BSIM4leff - * pParam->BSIM4leff; - NevalSrc(&noizDens[BSIM4IDNOIZ], - &lnNdens[BSIM4IDNOIZ], ckt, - THERMNOISE, here->BSIM4dNodePrime, - here->BSIM4sNodePrime, - (T0 / T1) * model->BSIM4ntnoi * m); + T0 = here->BSIM4v7ueff * fabs(here->BSIM4v7qinv); + T1 = T0 * tmp + pParam->BSIM4v7leff + * pParam->BSIM4v7leff; + NevalSrc(&noizDens[BSIM4v7IDNOIZ], + &lnNdens[BSIM4v7IDNOIZ], ckt, + THERMNOISE, here->BSIM4v7dNodePrime, + here->BSIM4v7sNodePrime, + (T0 / T1) * model->BSIM4v7ntnoi * m); break; case 1: - T0 = here->BSIM4gm + here->BSIM4gmbs + here->BSIM4gds; + T0 = here->BSIM4v7gm + here->BSIM4v7gmbs + here->BSIM4v7gds; T0 *= T0; - igsquare = npart_theta * npart_theta * T0 / here->BSIM4IdovVds; - T1 = npart_beta * (here->BSIM4gm - + here->BSIM4gmbs) + here->BSIM4gds; - T2 = T1 * T1 / here->BSIM4IdovVds; - NevalSrc(&noizDens[BSIM4IDNOIZ], - &lnNdens[BSIM4IDNOIZ], ckt, - THERMNOISE, here->BSIM4dNodePrime, - here->BSIM4sNodePrime, (T2 - igsquare) * m); + igsquare = npart_theta * npart_theta * T0 / here->BSIM4v7IdovVds; + T1 = npart_beta * (here->BSIM4v7gm + + here->BSIM4v7gmbs) + here->BSIM4v7gds; + T2 = T1 * T1 / here->BSIM4v7IdovVds; + NevalSrc(&noizDens[BSIM4v7IDNOIZ], + &lnNdens[BSIM4v7IDNOIZ], ckt, + THERMNOISE, here->BSIM4v7dNodePrime, + here->BSIM4v7sNodePrime, (T2 - igsquare) * m); break; case 2: T2 = GammaGd0; T3 = ctnoi * ctnoi; T4 = 1.0 - T3; - NevalSrc(&noizDens[BSIM4IDNOIZ], - &lnNdens[BSIM4IDNOIZ], ckt, - THERMNOISE, here->BSIM4dNodePrime, - here->BSIM4sNodePrime, T2 * T4 * m); + NevalSrc(&noizDens[BSIM4v7IDNOIZ], + &lnNdens[BSIM4v7IDNOIZ], ckt, + THERMNOISE, here->BSIM4v7dNodePrime, + here->BSIM4v7sNodePrime, T2 * T4 * m); /* Evaluate output noise due to two correlated noise sources */ omega = 2.0 * M_PI * data->freq; @@ -460,106 +460,106 @@ double m; T6 = T5 * T5; T7 = T6 / (1.0 + T6); - if (here->BSIM4mode >= 0) { - NevalSrc2(&noizDens[BSIM4CORLNOIZ], - &lnNdens[BSIM4CORLNOIZ], ckt, - THERMNOISE, here->BSIM4dNodePrime, - here->BSIM4sNodePrime, T2 * T3 * m, - here->BSIM4gNodePrime, - here->BSIM4sNodePrime, + if (here->BSIM4v7mode >= 0) { + NevalSrc2(&noizDens[BSIM4v7CORLNOIZ], + &lnNdens[BSIM4v7CORLNOIZ], ckt, + THERMNOISE, here->BSIM4v7dNodePrime, + here->BSIM4v7sNodePrime, T2 * T3 * m, + here->BSIM4v7gNodePrime, + here->BSIM4v7sNodePrime, T2 * T7 * m, 0.5 * M_PI); } else { - NevalSrc2(&noizDens[BSIM4CORLNOIZ], - &lnNdens[BSIM4CORLNOIZ], ckt, - THERMNOISE, here->BSIM4sNodePrime, - here->BSIM4dNodePrime, T2 * T3 * m, - here->BSIM4gNodePrime, - here->BSIM4dNodePrime, + NevalSrc2(&noizDens[BSIM4v7CORLNOIZ], + &lnNdens[BSIM4v7CORLNOIZ], ckt, + THERMNOISE, here->BSIM4v7sNodePrime, + here->BSIM4v7dNodePrime, T2 * T3 * m, + here->BSIM4v7gNodePrime, + here->BSIM4v7dNodePrime, T2 * T7 * m, 0.5 * M_PI); } break; } - NevalSrc(&noizDens[BSIM4FLNOIZ], (double*) NULL, - ckt, N_GAIN, here->BSIM4dNodePrime, - here->BSIM4sNodePrime, (double) 0.0); + NevalSrc(&noizDens[BSIM4v7FLNOIZ], (double*) NULL, + ckt, N_GAIN, here->BSIM4v7dNodePrime, + here->BSIM4v7sNodePrime, (double) 0.0); - switch(model->BSIM4fnoiMod) + switch(model->BSIM4v7fnoiMod) { case 0: - noizDens[BSIM4FLNOIZ] *= m * model->BSIM4kf - * exp(model->BSIM4af - * log(MAX(fabs(here->BSIM4cd), + noizDens[BSIM4v7FLNOIZ] *= m * model->BSIM4v7kf + * exp(model->BSIM4v7af + * log(MAX(fabs(here->BSIM4v7cd), N_MINLOG))) - / (pow(data->freq, model->BSIM4ef) - * pParam->BSIM4leff - * pParam->BSIM4leff - * model->BSIM4coxe); + / (pow(data->freq, model->BSIM4v7ef) + * pParam->BSIM4v7leff + * pParam->BSIM4v7leff + * model->BSIM4v7coxe); break; case 1: - Vds = *(ckt->CKTstates[0] + here->BSIM4vds); + Vds = *(ckt->CKTstates[0] + here->BSIM4v7vds); if (Vds < 0.0) Vds = -Vds; Ssi = Eval1ovFNoise(Vds, model, here, data->freq, ckt->CKTtemp); - T10 = model->BSIM4oxideTrapDensityA + T10 = model->BSIM4v7oxideTrapDensityA * CONSTboltz * ckt->CKTtemp; - T11 = pParam->BSIM4weff * here->BSIM4nf * pParam->BSIM4leff - * pow(data->freq, model->BSIM4ef) * 1.0e10 - * here->BSIM4nstar * here->BSIM4nstar; - Swi = T10 / T11 * here->BSIM4cd - * here->BSIM4cd; + T11 = pParam->BSIM4v7weff * here->BSIM4v7nf * pParam->BSIM4v7leff + * pow(data->freq, model->BSIM4v7ef) * 1.0e10 + * here->BSIM4v7nstar * here->BSIM4v7nstar; + Swi = T10 / T11 * here->BSIM4v7cd + * here->BSIM4v7cd; T1 = Swi + Ssi; if (T1 > 0.0) - noizDens[BSIM4FLNOIZ] *= m * (Ssi * Swi) / T1; + noizDens[BSIM4v7FLNOIZ] *= m * (Ssi * Swi) / T1; else - noizDens[BSIM4FLNOIZ] *= 0.0; + noizDens[BSIM4v7FLNOIZ] *= 0.0; break; } - lnNdens[BSIM4FLNOIZ] = - log(MAX(noizDens[BSIM4FLNOIZ], N_MINLOG)); + lnNdens[BSIM4v7FLNOIZ] = + log(MAX(noizDens[BSIM4v7FLNOIZ], N_MINLOG)); - if(here->BSIM4mode >= 0) { /* bugfix */ - NevalSrc(&noizDens[BSIM4IGSNOIZ], - &lnNdens[BSIM4IGSNOIZ], ckt, SHOTNOISE, - here->BSIM4gNodePrime, here->BSIM4sNodePrime, - m * (here->BSIM4Igs + here->BSIM4Igcs)); - NevalSrc(&noizDens[BSIM4IGDNOIZ], - &lnNdens[BSIM4IGDNOIZ], ckt, SHOTNOISE, - here->BSIM4gNodePrime, here->BSIM4dNodePrime, - m * (here->BSIM4Igd + here->BSIM4Igcd)); + if(here->BSIM4v7mode >= 0) { /* bugfix */ + NevalSrc(&noizDens[BSIM4v7IGSNOIZ], + &lnNdens[BSIM4v7IGSNOIZ], ckt, SHOTNOISE, + here->BSIM4v7gNodePrime, here->BSIM4v7sNodePrime, + m * (here->BSIM4v7Igs + here->BSIM4v7Igcs)); + NevalSrc(&noizDens[BSIM4v7IGDNOIZ], + &lnNdens[BSIM4v7IGDNOIZ], ckt, SHOTNOISE, + here->BSIM4v7gNodePrime, here->BSIM4v7dNodePrime, + m * (here->BSIM4v7Igd + here->BSIM4v7Igcd)); } else { - NevalSrc(&noizDens[BSIM4IGSNOIZ], - &lnNdens[BSIM4IGSNOIZ], ckt, SHOTNOISE, - here->BSIM4gNodePrime, here->BSIM4sNodePrime, - m * (here->BSIM4Igs + here->BSIM4Igcd)); - NevalSrc(&noizDens[BSIM4IGDNOIZ], - &lnNdens[BSIM4IGDNOIZ], ckt, SHOTNOISE, - here->BSIM4gNodePrime, here->BSIM4dNodePrime, - m * (here->BSIM4Igd + here->BSIM4Igcs)); + NevalSrc(&noizDens[BSIM4v7IGSNOIZ], + &lnNdens[BSIM4v7IGSNOIZ], ckt, SHOTNOISE, + here->BSIM4v7gNodePrime, here->BSIM4v7sNodePrime, + m * (here->BSIM4v7Igs + here->BSIM4v7Igcd)); + NevalSrc(&noizDens[BSIM4v7IGDNOIZ], + &lnNdens[BSIM4v7IGDNOIZ], ckt, SHOTNOISE, + here->BSIM4v7gNodePrime, here->BSIM4v7dNodePrime, + m * (here->BSIM4v7Igd + here->BSIM4v7Igcs)); } - NevalSrc(&noizDens[BSIM4IGBNOIZ], - &lnNdens[BSIM4IGBNOIZ], ckt, SHOTNOISE, - here->BSIM4gNodePrime, here->BSIM4bNodePrime, - m * here->BSIM4Igb); + NevalSrc(&noizDens[BSIM4v7IGBNOIZ], + &lnNdens[BSIM4v7IGBNOIZ], ckt, SHOTNOISE, + here->BSIM4v7gNodePrime, here->BSIM4v7bNodePrime, + m * here->BSIM4v7Igb); - noizDens[BSIM4TOTNOIZ] = noizDens[BSIM4RDNOIZ] - + noizDens[BSIM4RSNOIZ] + noizDens[BSIM4RGNOIZ] - + noizDens[BSIM4RBPSNOIZ] + noizDens[BSIM4RBPDNOIZ] - + noizDens[BSIM4RBPBNOIZ] - + noizDens[BSIM4RBSBNOIZ] + noizDens[BSIM4RBDBNOIZ] - + noizDens[BSIM4IDNOIZ] + noizDens[BSIM4FLNOIZ] - + noizDens[BSIM4IGSNOIZ] + noizDens[BSIM4IGDNOIZ] - + noizDens[BSIM4IGBNOIZ] + noizDens[BSIM4CORLNOIZ]; - lnNdens[BSIM4TOTNOIZ] = - log(MAX(noizDens[BSIM4TOTNOIZ], N_MINLOG)); + noizDens[BSIM4v7TOTNOIZ] = noizDens[BSIM4v7RDNOIZ] + + noizDens[BSIM4v7RSNOIZ] + noizDens[BSIM4v7RGNOIZ] + + noizDens[BSIM4v7RBPSNOIZ] + noizDens[BSIM4v7RBPDNOIZ] + + noizDens[BSIM4v7RBPBNOIZ] + + noizDens[BSIM4v7RBSBNOIZ] + noizDens[BSIM4v7RBDBNOIZ] + + noizDens[BSIM4v7IDNOIZ] + noizDens[BSIM4v7FLNOIZ] + + noizDens[BSIM4v7IGSNOIZ] + noizDens[BSIM4v7IGDNOIZ] + + noizDens[BSIM4v7IGBNOIZ] + noizDens[BSIM4v7CORLNOIZ]; + lnNdens[BSIM4v7TOTNOIZ] = + log(MAX(noizDens[BSIM4v7TOTNOIZ], N_MINLOG)); - *OnDens += noizDens[BSIM4TOTNOIZ]; + *OnDens += noizDens[BSIM4v7TOTNOIZ]; if (data->delFreq == 0.0) { /* if we haven't done any previous @@ -567,8 +567,8 @@ double m; "history" variables. */ - for (i = 0; i < BSIM4NSRCS; i++) - { here->BSIM4nVar[LNLSTDENS][i] = + for (i = 0; i < BSIM4v7NSRCS; i++) + { here->BSIM4v7nVar[LNLSTDENS][i] = lnNdens[i]; } @@ -577,9 +577,9 @@ double m; */ if (data->freq == job->NstartFreq) - { for (i = 0; i < BSIM4NSRCS; i++) - { here->BSIM4nVar[OUTNOIZ][i] = 0.0; - here->BSIM4nVar[INNOIZ][i] = 0.0; + { for (i = 0; i < BSIM4v7NSRCS; i++) + { here->BSIM4v7nVar[OUTNOIZ][i] = 0.0; + here->BSIM4v7nVar[INNOIZ][i] = 0.0; } } } @@ -587,36 +587,36 @@ double m; { /* data->delFreq != 0.0, we have to integrate. */ - for (i = 0; i < BSIM4NSRCS; i++) - { if (i != BSIM4TOTNOIZ) + for (i = 0; i < BSIM4v7NSRCS; i++) + { if (i != BSIM4v7TOTNOIZ) { tempOnoise = Nintegrate(noizDens[i], lnNdens[i], - here->BSIM4nVar[LNLSTDENS][i], + here->BSIM4v7nVar[LNLSTDENS][i], data); tempInoise = Nintegrate(noizDens[i] * data->GainSqInv, lnNdens[i] + data->lnGainInv, - here->BSIM4nVar[LNLSTDENS][i] + here->BSIM4v7nVar[LNLSTDENS][i] + data->lnGainInv, data); - here->BSIM4nVar[LNLSTDENS][i] = + here->BSIM4v7nVar[LNLSTDENS][i] = lnNdens[i]; data->outNoiz += tempOnoise; data->inNoise += tempInoise; if (job->NStpsSm != 0) - { here->BSIM4nVar[OUTNOIZ][i] + { here->BSIM4v7nVar[OUTNOIZ][i] += tempOnoise; - here->BSIM4nVar[OUTNOIZ][BSIM4TOTNOIZ] + here->BSIM4v7nVar[OUTNOIZ][BSIM4v7TOTNOIZ] += tempOnoise; - here->BSIM4nVar[INNOIZ][i] + here->BSIM4v7nVar[INNOIZ][i] += tempInoise; - here->BSIM4nVar[INNOIZ][BSIM4TOTNOIZ] + here->BSIM4v7nVar[INNOIZ][BSIM4v7TOTNOIZ] += tempInoise; } } } } if (data->prtSummary) - { for (i = 0; i < BSIM4NSRCS; i++) + { for (i = 0; i < BSIM4v7NSRCS; i++) { /* print a summary report */ data->outpVector[data->outNumber++] = noizDens[i]; @@ -626,11 +626,11 @@ double m; case INT_NOIZ: /* already calculated, just output */ if (job->NStpsSm != 0) - { for (i = 0; i < BSIM4NSRCS; i++) + { for (i = 0; i < BSIM4v7NSRCS; i++) { data->outpVector[data->outNumber++] - = here->BSIM4nVar[OUTNOIZ][i]; + = here->BSIM4v7nVar[OUTNOIZ][i]; data->outpVector[data->outNumber++] - = here->BSIM4nVar[INNOIZ][i]; + = here->BSIM4v7nVar[INNOIZ][i]; } } break; diff --git a/src/spicelib/devices/bsim4v7/b4v7par.c b/src/spicelib/devices/bsim4v7/b4v7par.c index 4812242f6..3301e2366 100644 --- a/src/spicelib/devices/bsim4v7/b4v7par.c +++ b/src/spicelib/devices/bsim4v7/b4v7par.c @@ -16,13 +16,13 @@ #include "ngspice/ngspice.h" #include "ngspice/ifsim.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" #include "ngspice/fteext.h" int -BSIM4param( +BSIM4v7param( int param, IFvalue *value, GENinstance *inst, @@ -30,7 +30,7 @@ IFvalue *select) { double scale; - BSIM4instance *here = (BSIM4instance*)inst; + BSIM4v7instance *here = (BSIM4v7instance*)inst; NG_IGNORE(select); @@ -38,160 +38,160 @@ IFvalue *select) scale = 1; switch(param) - { case BSIM4_W: - here->BSIM4w = value->rValue * scale; - here->BSIM4wGiven = TRUE; + { case BSIM4v7_W: + here->BSIM4v7w = value->rValue * scale; + here->BSIM4v7wGiven = TRUE; break; - case BSIM4_L: - here->BSIM4l = value->rValue * scale; - here->BSIM4lGiven = TRUE; + case BSIM4v7_L: + here->BSIM4v7l = value->rValue * scale; + here->BSIM4v7lGiven = TRUE; break; - case BSIM4_M: - here->BSIM4m = value->rValue; - here->BSIM4mGiven = TRUE; + case BSIM4v7_M: + here->BSIM4v7m = value->rValue; + here->BSIM4v7mGiven = TRUE; break; - case BSIM4_NF: - here->BSIM4nf = value->rValue; - here->BSIM4nfGiven = TRUE; + case BSIM4v7_NF: + here->BSIM4v7nf = value->rValue; + here->BSIM4v7nfGiven = TRUE; break; - case BSIM4_MIN: - here->BSIM4min = value->iValue; - here->BSIM4minGiven = TRUE; + case BSIM4v7_MIN: + here->BSIM4v7min = value->iValue; + here->BSIM4v7minGiven = TRUE; break; - case BSIM4_AS: - here->BSIM4sourceArea = value->rValue * scale * scale; - here->BSIM4sourceAreaGiven = TRUE; + case BSIM4v7_AS: + here->BSIM4v7sourceArea = value->rValue * scale * scale; + here->BSIM4v7sourceAreaGiven = TRUE; break; - case BSIM4_AD: - here->BSIM4drainArea = value->rValue * scale * scale; - here->BSIM4drainAreaGiven = TRUE; + case BSIM4v7_AD: + here->BSIM4v7drainArea = value->rValue * scale * scale; + here->BSIM4v7drainAreaGiven = TRUE; break; - case BSIM4_PS: - here->BSIM4sourcePerimeter = value->rValue * scale; - here->BSIM4sourcePerimeterGiven = TRUE; + case BSIM4v7_PS: + here->BSIM4v7sourcePerimeter = value->rValue * scale; + here->BSIM4v7sourcePerimeterGiven = TRUE; break; - case BSIM4_PD: - here->BSIM4drainPerimeter = value->rValue * scale; - here->BSIM4drainPerimeterGiven = TRUE; + case BSIM4v7_PD: + here->BSIM4v7drainPerimeter = value->rValue * scale; + here->BSIM4v7drainPerimeterGiven = TRUE; break; - case BSIM4_NRS: - here->BSIM4sourceSquares = value->rValue; - here->BSIM4sourceSquaresGiven = TRUE; + case BSIM4v7_NRS: + here->BSIM4v7sourceSquares = value->rValue; + here->BSIM4v7sourceSquaresGiven = TRUE; break; - case BSIM4_NRD: - here->BSIM4drainSquares = value->rValue; - here->BSIM4drainSquaresGiven = TRUE; + case BSIM4v7_NRD: + here->BSIM4v7drainSquares = value->rValue; + here->BSIM4v7drainSquaresGiven = TRUE; break; - case BSIM4_OFF: - here->BSIM4off = value->iValue; + case BSIM4v7_OFF: + here->BSIM4v7off = value->iValue; break; - case BSIM4_SA: - here->BSIM4sa = value->rValue; - here->BSIM4saGiven = TRUE; + case BSIM4v7_SA: + here->BSIM4v7sa = value->rValue; + here->BSIM4v7saGiven = TRUE; break; - case BSIM4_SB: - here->BSIM4sb = value->rValue; - here->BSIM4sbGiven = TRUE; + case BSIM4v7_SB: + here->BSIM4v7sb = value->rValue; + here->BSIM4v7sbGiven = TRUE; break; - case BSIM4_SD: - here->BSIM4sd = value->rValue; - here->BSIM4sdGiven = TRUE; + case BSIM4v7_SD: + here->BSIM4v7sd = value->rValue; + here->BSIM4v7sdGiven = TRUE; break; - case BSIM4_SCA: - here->BSIM4sca = value->rValue; - here->BSIM4scaGiven = TRUE; + case BSIM4v7_SCA: + here->BSIM4v7sca = value->rValue; + here->BSIM4v7scaGiven = TRUE; break; - case BSIM4_SCB: - here->BSIM4scb = value->rValue; - here->BSIM4scbGiven = TRUE; + case BSIM4v7_SCB: + here->BSIM4v7scb = value->rValue; + here->BSIM4v7scbGiven = TRUE; break; - case BSIM4_SCC: - here->BSIM4scc = value->rValue; - here->BSIM4sccGiven = TRUE; + case BSIM4v7_SCC: + here->BSIM4v7scc = value->rValue; + here->BSIM4v7sccGiven = TRUE; break; - case BSIM4_SC: - here->BSIM4sc = value->rValue; - here->BSIM4scGiven = TRUE; + case BSIM4v7_SC: + here->BSIM4v7sc = value->rValue; + here->BSIM4v7scGiven = TRUE; break; - case BSIM4_RBSB: - here->BSIM4rbsb = value->rValue; - here->BSIM4rbsbGiven = TRUE; + case BSIM4v7_RBSB: + here->BSIM4v7rbsb = value->rValue; + here->BSIM4v7rbsbGiven = TRUE; break; - case BSIM4_RBDB: - here->BSIM4rbdb = value->rValue; - here->BSIM4rbdbGiven = TRUE; + case BSIM4v7_RBDB: + here->BSIM4v7rbdb = value->rValue; + here->BSIM4v7rbdbGiven = TRUE; break; - case BSIM4_RBPB: - here->BSIM4rbpb = value->rValue; - here->BSIM4rbpbGiven = TRUE; + case BSIM4v7_RBPB: + here->BSIM4v7rbpb = value->rValue; + here->BSIM4v7rbpbGiven = TRUE; break; - case BSIM4_RBPS: - here->BSIM4rbps = value->rValue; - here->BSIM4rbpsGiven = TRUE; + case BSIM4v7_RBPS: + here->BSIM4v7rbps = value->rValue; + here->BSIM4v7rbpsGiven = TRUE; break; - case BSIM4_RBPD: - here->BSIM4rbpd = value->rValue; - here->BSIM4rbpdGiven = TRUE; + case BSIM4v7_RBPD: + here->BSIM4v7rbpd = value->rValue; + here->BSIM4v7rbpdGiven = TRUE; break; - case BSIM4_DELVTO: - here->BSIM4delvto = value->rValue; - here->BSIM4delvtoGiven = TRUE; + case BSIM4v7_DELVTO: + here->BSIM4v7delvto = value->rValue; + here->BSIM4v7delvtoGiven = TRUE; break; - case BSIM4_XGW: - here->BSIM4xgw = value->rValue; - here->BSIM4xgwGiven = TRUE; + case BSIM4v7_XGW: + here->BSIM4v7xgw = value->rValue; + here->BSIM4v7xgwGiven = TRUE; break; - case BSIM4_NGCON: - here->BSIM4ngcon = value->rValue; - here->BSIM4ngconGiven = TRUE; + case BSIM4v7_NGCON: + here->BSIM4v7ngcon = value->rValue; + here->BSIM4v7ngconGiven = TRUE; break; - case BSIM4_TRNQSMOD: - here->BSIM4trnqsMod = value->iValue; - here->BSIM4trnqsModGiven = TRUE; + case BSIM4v7_TRNQSMOD: + here->BSIM4v7trnqsMod = value->iValue; + here->BSIM4v7trnqsModGiven = TRUE; break; - case BSIM4_ACNQSMOD: - here->BSIM4acnqsMod = value->iValue; - here->BSIM4acnqsModGiven = TRUE; + case BSIM4v7_ACNQSMOD: + here->BSIM4v7acnqsMod = value->iValue; + here->BSIM4v7acnqsModGiven = TRUE; break; - case BSIM4_RBODYMOD: - here->BSIM4rbodyMod = value->iValue; - here->BSIM4rbodyModGiven = TRUE; + case BSIM4v7_RBODYMOD: + here->BSIM4v7rbodyMod = value->iValue; + here->BSIM4v7rbodyModGiven = TRUE; break; - case BSIM4_RGATEMOD: - here->BSIM4rgateMod = value->iValue; - here->BSIM4rgateModGiven = TRUE; + case BSIM4v7_RGATEMOD: + here->BSIM4v7rgateMod = value->iValue; + here->BSIM4v7rgateModGiven = TRUE; break; - case BSIM4_GEOMOD: - here->BSIM4geoMod = value->iValue; - here->BSIM4geoModGiven = TRUE; + case BSIM4v7_GEOMOD: + here->BSIM4v7geoMod = value->iValue; + here->BSIM4v7geoModGiven = TRUE; break; - case BSIM4_RGEOMOD: - here->BSIM4rgeoMod = value->iValue; - here->BSIM4rgeoModGiven = TRUE; + case BSIM4v7_RGEOMOD: + here->BSIM4v7rgeoMod = value->iValue; + here->BSIM4v7rgeoModGiven = TRUE; break; - case BSIM4_IC_VDS: - here->BSIM4icVDS = value->rValue; - here->BSIM4icVDSGiven = TRUE; + case BSIM4v7_IC_VDS: + here->BSIM4v7icVDS = value->rValue; + here->BSIM4v7icVDSGiven = TRUE; break; - case BSIM4_IC_VGS: - here->BSIM4icVGS = value->rValue; - here->BSIM4icVGSGiven = TRUE; + case BSIM4v7_IC_VGS: + here->BSIM4v7icVGS = value->rValue; + here->BSIM4v7icVGSGiven = TRUE; break; - case BSIM4_IC_VBS: - here->BSIM4icVBS = value->rValue; - here->BSIM4icVBSGiven = TRUE; + case BSIM4v7_IC_VBS: + here->BSIM4v7icVBS = value->rValue; + here->BSIM4v7icVBSGiven = TRUE; break; - case BSIM4_IC: + case BSIM4v7_IC: switch(value->v.numValue) { case 3: - here->BSIM4icVBS = *(value->v.vec.rVec+2); - here->BSIM4icVBSGiven = TRUE; + here->BSIM4v7icVBS = *(value->v.vec.rVec+2); + here->BSIM4v7icVBSGiven = TRUE; case 2: - here->BSIM4icVGS = *(value->v.vec.rVec+1); - here->BSIM4icVGSGiven = TRUE; + here->BSIM4v7icVGS = *(value->v.vec.rVec+1); + here->BSIM4v7icVGSGiven = TRUE; case 1: - here->BSIM4icVDS = *(value->v.vec.rVec); - here->BSIM4icVDSGiven = TRUE; + here->BSIM4v7icVDS = *(value->v.vec.rVec); + here->BSIM4v7icVDSGiven = TRUE; break; default: return(E_BADPARM); diff --git a/src/spicelib/devices/bsim4v7/b4v7pzld.c b/src/spicelib/devices/bsim4v7/b4v7pzld.c index 7307bf081..0d93ee1a4 100644 --- a/src/spicelib/devices/bsim4v7/b4v7pzld.c +++ b/src/spicelib/devices/bsim4v7/b4v7pzld.c @@ -15,17 +15,17 @@ #include "ngspice/cktdefs.h" #include "ngspice/complex.h" #include "ngspice/sperror.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/suffix.h" int -BSIM4pzLoad( +BSIM4v7pzLoad( GENmodel *inModel, CKTcircuit *ckt, SPcomplex *s) { -BSIM4model *model = (BSIM4model*)inModel; -BSIM4instance *here; +BSIM4v7model *model = (BSIM4v7model*)inModel; +BSIM4v7instance *here; double gjbd, gjbs, geltd, gcrg, gcrgg, gcrgd, gcrgs, gcrgb; double xcggb, xcgdb, xcgsb, xcgbb, xcbgb, xcbdb, xcbsb, xcbbb; @@ -52,28 +52,28 @@ double ggidld, ggidlg, ggidlb, ggislg, ggislb, ggisls; double m; - for (; model != NULL; model = model->BSIM4nextModel) - { for (here = model->BSIM4instances; here!= NULL; - here = here->BSIM4nextInstance) + for (; model != NULL; model = model->BSIM4v7nextModel) + { for (here = model->BSIM4v7instances; here!= NULL; + here = here->BSIM4v7nextInstance) { pParam = here->pParam; - capbd = here->BSIM4capbd; - capbs = here->BSIM4capbs; - cgso = here->BSIM4cgso; - cgdo = here->BSIM4cgdo; - cgbo = pParam->BSIM4cgbo; + capbd = here->BSIM4v7capbd; + capbs = here->BSIM4v7capbs; + cgso = here->BSIM4v7cgso; + cgdo = here->BSIM4v7cgdo; + cgbo = pParam->BSIM4v7cgbo; - if (here->BSIM4mode >= 0) - { Gm = here->BSIM4gm; - Gmbs = here->BSIM4gmbs; + if (here->BSIM4v7mode >= 0) + { Gm = here->BSIM4v7gm; + Gmbs = here->BSIM4v7gmbs; FwdSum = Gm + Gmbs; RevSum = 0.0; - gbbdp = -(here->BSIM4gbds); - gbbsp = here->BSIM4gbds + here->BSIM4gbgs + here->BSIM4gbbs; - gbdpg = here->BSIM4gbgs; - gbdpdp = here->BSIM4gbds; - gbdpb = here->BSIM4gbbs; + gbbdp = -(here->BSIM4v7gbds); + gbbsp = here->BSIM4v7gbds + here->BSIM4v7gbgs + here->BSIM4v7gbbs; + gbdpg = here->BSIM4v7gbgs; + gbdpdp = here->BSIM4v7gbds; + gbdpb = here->BSIM4v7gbbs; gbdpsp = -(gbdpg + gbdpdp + gbdpb); gbspdp = 0.0; @@ -81,32 +81,32 @@ double m; gbspb = 0.0; gbspsp = 0.0; - if (model->BSIM4igcMod) - { gIstotg = here->BSIM4gIgsg + here->BSIM4gIgcsg; - gIstotd = here->BSIM4gIgcsd; - gIstots = here->BSIM4gIgss + here->BSIM4gIgcss; - gIstotb = here->BSIM4gIgcsb; + if (model->BSIM4v7igcMod) + { gIstotg = here->BSIM4v7gIgsg + here->BSIM4v7gIgcsg; + gIstotd = here->BSIM4v7gIgcsd; + gIstots = here->BSIM4v7gIgss + here->BSIM4v7gIgcss; + gIstotb = here->BSIM4v7gIgcsb; - gIdtotg = here->BSIM4gIgdg + here->BSIM4gIgcdg; - gIdtotd = here->BSIM4gIgdd + here->BSIM4gIgcdd; - gIdtots = here->BSIM4gIgcds; - gIdtotb = here->BSIM4gIgcdb; + gIdtotg = here->BSIM4v7gIgdg + here->BSIM4v7gIgcdg; + gIdtotd = here->BSIM4v7gIgdd + here->BSIM4v7gIgcdd; + gIdtots = here->BSIM4v7gIgcds; + gIdtotb = here->BSIM4v7gIgcdb; } else { gIstotg = gIstotd = gIstots = gIstotb = 0.0; gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0; } - if (model->BSIM4igbMod) - { gIbtotg = here->BSIM4gIgbg; - gIbtotd = here->BSIM4gIgbd; - gIbtots = here->BSIM4gIgbs; - gIbtotb = here->BSIM4gIgbb; + if (model->BSIM4v7igbMod) + { gIbtotg = here->BSIM4v7gIgbg; + gIbtotd = here->BSIM4v7gIgbd; + gIbtots = here->BSIM4v7gIgbs; + gIbtotb = here->BSIM4v7gIgbb; } else gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0; - if ((model->BSIM4igcMod != 0) || (model->BSIM4igbMod != 0)) + if ((model->BSIM4v7igcMod != 0) || (model->BSIM4v7igbMod != 0)) { gIgtotg = gIstotg + gIdtotg + gIbtotg; gIgtotd = gIstotd + gIdtotd + gIbtotd ; gIgtots = gIstots + gIdtots + gIbtots; @@ -115,83 +115,83 @@ double m; else gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0; - if (here->BSIM4rgateMod == 2) - T0 = *(ckt->CKTstates[0] + here->BSIM4vges) - - *(ckt->CKTstates[0] + here->BSIM4vgs); - else if (here->BSIM4rgateMod == 3) - T0 = *(ckt->CKTstates[0] + here->BSIM4vgms) - - *(ckt->CKTstates[0] + here->BSIM4vgs); - if (here->BSIM4rgateMod > 1) - { gcrgd = here->BSIM4gcrgd * T0; - gcrgg = here->BSIM4gcrgg * T0; - gcrgs = here->BSIM4gcrgs * T0; - gcrgb = here->BSIM4gcrgb * T0; - gcrgg -= here->BSIM4gcrg; - gcrg = here->BSIM4gcrg; + if (here->BSIM4v7rgateMod == 2) + T0 = *(ckt->CKTstates[0] + here->BSIM4v7vges) + - *(ckt->CKTstates[0] + here->BSIM4v7vgs); + else if (here->BSIM4v7rgateMod == 3) + T0 = *(ckt->CKTstates[0] + here->BSIM4v7vgms) + - *(ckt->CKTstates[0] + here->BSIM4v7vgs); + if (here->BSIM4v7rgateMod > 1) + { gcrgd = here->BSIM4v7gcrgd * T0; + gcrgg = here->BSIM4v7gcrgg * T0; + gcrgs = here->BSIM4v7gcrgs * T0; + gcrgb = here->BSIM4v7gcrgb * T0; + gcrgg -= here->BSIM4v7gcrg; + gcrg = here->BSIM4v7gcrg; } else gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0; - if (here->BSIM4acnqsMod == 0) - { if (here->BSIM4rgateMod == 3) - { xcgmgmb = cgdo + cgso + pParam->BSIM4cgbo; + if (here->BSIM4v7acnqsMod == 0) + { if (here->BSIM4v7rgateMod == 3) + { xcgmgmb = cgdo + cgso + pParam->BSIM4v7cgbo; xcgmdb = -cgdo; xcgmsb = -cgso; - xcgmbb = -pParam->BSIM4cgbo; + xcgmbb = -pParam->BSIM4v7cgbo; xcdgmb = xcgmdb; xcsgmb = xcgmsb; xcbgmb = xcgmbb; - xcggb = here->BSIM4cggb; - xcgdb = here->BSIM4cgdb; - xcgsb = here->BSIM4cgsb; + xcggb = here->BSIM4v7cggb; + xcgdb = here->BSIM4v7cgdb; + xcgsb = here->BSIM4v7cgsb; xcgbb = -(xcggb + xcgdb + xcgsb); - xcdgb = here->BSIM4cdgb; - xcsgb = -(here->BSIM4cggb + here->BSIM4cbgb - + here->BSIM4cdgb); - xcbgb = here->BSIM4cbgb; + xcdgb = here->BSIM4v7cdgb; + xcsgb = -(here->BSIM4v7cggb + here->BSIM4v7cbgb + + here->BSIM4v7cdgb); + xcbgb = here->BSIM4v7cbgb; } else - { xcggb = here->BSIM4cggb + cgdo + cgso - + pParam->BSIM4cgbo; - xcgdb = here->BSIM4cgdb - cgdo; - xcgsb = here->BSIM4cgsb - cgso; + { xcggb = here->BSIM4v7cggb + cgdo + cgso + + pParam->BSIM4v7cgbo; + xcgdb = here->BSIM4v7cgdb - cgdo; + xcgsb = here->BSIM4v7cgsb - cgso; xcgbb = -(xcggb + xcgdb + xcgsb); - xcdgb = here->BSIM4cdgb - cgdo; - xcsgb = -(here->BSIM4cggb + here->BSIM4cbgb - + here->BSIM4cdgb + cgso); - xcbgb = here->BSIM4cbgb - pParam->BSIM4cgbo; + xcdgb = here->BSIM4v7cdgb - cgdo; + xcsgb = -(here->BSIM4v7cggb + here->BSIM4v7cbgb + + here->BSIM4v7cdgb + cgso); + xcbgb = here->BSIM4v7cbgb - pParam->BSIM4v7cgbo; xcdgmb = xcsgmb = xcbgmb = 0.0; } - xcddb = here->BSIM4cddb + here->BSIM4capbd + cgdo; - xcdsb = here->BSIM4cdsb; + xcddb = here->BSIM4v7cddb + here->BSIM4v7capbd + cgdo; + xcdsb = here->BSIM4v7cdsb; - xcsdb = -(here->BSIM4cgdb + here->BSIM4cbdb - + here->BSIM4cddb); - xcssb = here->BSIM4capbs + cgso - (here->BSIM4cgsb - + here->BSIM4cbsb + here->BSIM4cdsb); + xcsdb = -(here->BSIM4v7cgdb + here->BSIM4v7cbdb + + here->BSIM4v7cddb); + xcssb = here->BSIM4v7capbs + cgso - (here->BSIM4v7cgsb + + here->BSIM4v7cbsb + here->BSIM4v7cdsb); - if (!here->BSIM4rbodyMod) + if (!here->BSIM4v7rbodyMod) { xcdbb = -(xcdgb + xcddb + xcdsb + xcdgmb); xcsbb = -(xcsgb + xcsdb + xcssb + xcsgmb); - xcbdb = here->BSIM4cbdb - here->BSIM4capbd; - xcbsb = here->BSIM4cbsb - here->BSIM4capbs; + xcbdb = here->BSIM4v7cbdb - here->BSIM4v7capbd; + xcbsb = here->BSIM4v7cbsb - here->BSIM4v7capbs; xcdbdb = 0.0; } else - { xcdbb = -(here->BSIM4cddb + here->BSIM4cdgb - + here->BSIM4cdsb); + { xcdbb = -(here->BSIM4v7cddb + here->BSIM4v7cdgb + + here->BSIM4v7cdsb); xcsbb = -(xcsgb + xcsdb + xcssb + xcsgmb) - + here->BSIM4capbs; - xcbdb = here->BSIM4cbdb; - xcbsb = here->BSIM4cbsb; + + here->BSIM4v7capbs; + xcbdb = here->BSIM4v7cbdb; + xcbsb = here->BSIM4v7cbsb; - xcdbdb = -here->BSIM4capbd; - xcsbsb = -here->BSIM4capbs; + xcdbdb = -here->BSIM4v7capbd; + xcsbsb = -here->BSIM4v7capbs; } xcbbb = -(xcbdb + xcbgb + xcbsb + xcbgmb); @@ -209,24 +209,24 @@ double m; xcdgb = xcddb = xcdsb = xcdbb = 0.0; xcsgb = xcsdb = xcssb = xcsbb = 0.0; - xgtg = here->BSIM4gtg; - xgtd = here->BSIM4gtd; - xgts = here->BSIM4gts; - xgtb = here->BSIM4gtb; + xgtg = here->BSIM4v7gtg; + xgtd = here->BSIM4v7gtd; + xgts = here->BSIM4v7gts; + xgtb = here->BSIM4v7gtb; - xcqgb = here->BSIM4cqgb; - xcqdb = here->BSIM4cqdb; - xcqsb = here->BSIM4cqsb; - xcqbb = here->BSIM4cqbb; + xcqgb = here->BSIM4v7cqgb; + xcqdb = here->BSIM4v7cqdb; + xcqsb = here->BSIM4v7cqsb; + xcqbb = here->BSIM4v7cqbb; - CoxWL = model->BSIM4coxe * here->pParam->BSIM4weffCV - * here->BSIM4nf * here->pParam->BSIM4leffCV; - qcheq = -(here->BSIM4qgate + here->BSIM4qbulk); + CoxWL = model->BSIM4v7coxe * here->pParam->BSIM4v7weffCV + * here->BSIM4v7nf * here->pParam->BSIM4v7leffCV; + qcheq = -(here->BSIM4v7qgate + here->BSIM4v7qbulk); if (fabs(qcheq) <= 1.0e-5 * CoxWL) - { if (model->BSIM4xpart < 0.5) + { if (model->BSIM4v7xpart < 0.5) { dxpart = 0.4; } - else if (model->BSIM4xpart > 0.5) + else if (model->BSIM4v7xpart > 0.5) { dxpart = 0.0; } else @@ -236,19 +236,19 @@ double m; = ddxpart_dVs = 0.0; } else - { dxpart = here->BSIM4qdrn / qcheq; - Cdd = here->BSIM4cddb; - Csd = -(here->BSIM4cgdb + here->BSIM4cddb - + here->BSIM4cbdb); + { dxpart = here->BSIM4v7qdrn / qcheq; + Cdd = here->BSIM4v7cddb; + Csd = -(here->BSIM4v7cgdb + here->BSIM4v7cddb + + here->BSIM4v7cbdb); ddxpart_dVd = (Cdd - dxpart * (Cdd + Csd)) / qcheq; - Cdg = here->BSIM4cdgb; - Csg = -(here->BSIM4cggb + here->BSIM4cdgb - + here->BSIM4cbgb); + Cdg = here->BSIM4v7cdgb; + Csg = -(here->BSIM4v7cggb + here->BSIM4v7cdgb + + here->BSIM4v7cbgb); ddxpart_dVg = (Cdg - dxpart * (Cdg + Csg)) / qcheq; - Cds = here->BSIM4cdsb; - Css = -(here->BSIM4cgsb + here->BSIM4cdsb - + here->BSIM4cbsb); + Cds = here->BSIM4v7cdsb; + Css = -(here->BSIM4v7cgsb + here->BSIM4v7cdsb + + here->BSIM4v7cbsb); ddxpart_dVs = (Cds - dxpart * (Cds + Css)) / qcheq; ddxpart_dVb = -(ddxpart_dVd + ddxpart_dVg @@ -262,50 +262,50 @@ double m; } } else - { Gm = -here->BSIM4gm; - Gmbs = -here->BSIM4gmbs; + { Gm = -here->BSIM4v7gm; + Gmbs = -here->BSIM4v7gmbs; FwdSum = 0.0; RevSum = -(Gm + Gmbs); - gbbsp = -(here->BSIM4gbds); - gbbdp = here->BSIM4gbds + here->BSIM4gbgs + here->BSIM4gbbs; + gbbsp = -(here->BSIM4v7gbds); + gbbdp = here->BSIM4v7gbds + here->BSIM4v7gbgs + here->BSIM4v7gbbs; gbdpg = 0.0; gbdpsp = 0.0; gbdpb = 0.0; gbdpdp = 0.0; - gbspg = here->BSIM4gbgs; - gbspsp = here->BSIM4gbds; - gbspb = here->BSIM4gbbs; + gbspg = here->BSIM4v7gbgs; + gbspsp = here->BSIM4v7gbds; + gbspb = here->BSIM4v7gbbs; gbspdp = -(gbspg + gbspsp + gbspb); - if (model->BSIM4igcMod) - { gIstotg = here->BSIM4gIgsg + here->BSIM4gIgcdg; - gIstotd = here->BSIM4gIgcds; - gIstots = here->BSIM4gIgss + here->BSIM4gIgcdd; - gIstotb = here->BSIM4gIgcdb; + if (model->BSIM4v7igcMod) + { gIstotg = here->BSIM4v7gIgsg + here->BSIM4v7gIgcdg; + gIstotd = here->BSIM4v7gIgcds; + gIstots = here->BSIM4v7gIgss + here->BSIM4v7gIgcdd; + gIstotb = here->BSIM4v7gIgcdb; - gIdtotg = here->BSIM4gIgdg + here->BSIM4gIgcsg; - gIdtotd = here->BSIM4gIgdd + here->BSIM4gIgcss; - gIdtots = here->BSIM4gIgcsd; - gIdtotb = here->BSIM4gIgcsb; + gIdtotg = here->BSIM4v7gIgdg + here->BSIM4v7gIgcsg; + gIdtotd = here->BSIM4v7gIgdd + here->BSIM4v7gIgcss; + gIdtots = here->BSIM4v7gIgcsd; + gIdtotb = here->BSIM4v7gIgcsb; } else { gIstotg = gIstotd = gIstots = gIstotb = 0.0; gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0; } - if (model->BSIM4igbMod) - { gIbtotg = here->BSIM4gIgbg; - gIbtotd = here->BSIM4gIgbs; - gIbtots = here->BSIM4gIgbd; - gIbtotb = here->BSIM4gIgbb; + if (model->BSIM4v7igbMod) + { gIbtotg = here->BSIM4v7gIgbg; + gIbtotd = here->BSIM4v7gIgbs; + gIbtots = here->BSIM4v7gIgbd; + gIbtotb = here->BSIM4v7gIgbb; } else gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0; - if ((model->BSIM4igcMod != 0) || (model->BSIM4igbMod != 0)) + if ((model->BSIM4v7igcMod != 0) || (model->BSIM4v7igbMod != 0)) { gIgtotg = gIstotg + gIdtotg + gIbtotg; gIgtotd = gIstotd + gIdtotd + gIbtotd ; gIgtots = gIstots + gIdtots + gIbtots; @@ -314,82 +314,82 @@ double m; else gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0; - if (here->BSIM4rgateMod == 2) - T0 = *(ckt->CKTstates[0] + here->BSIM4vges) - - *(ckt->CKTstates[0] + here->BSIM4vgs); - else if (here->BSIM4rgateMod == 3) - T0 = *(ckt->CKTstates[0] + here->BSIM4vgms) - - *(ckt->CKTstates[0] + here->BSIM4vgs); - if (here->BSIM4rgateMod > 1) - { gcrgd = here->BSIM4gcrgs * T0; - gcrgg = here->BSIM4gcrgg * T0; - gcrgs = here->BSIM4gcrgd * T0; - gcrgb = here->BSIM4gcrgb * T0; - gcrgg -= here->BSIM4gcrg; - gcrg = here->BSIM4gcrg; + if (here->BSIM4v7rgateMod == 2) + T0 = *(ckt->CKTstates[0] + here->BSIM4v7vges) + - *(ckt->CKTstates[0] + here->BSIM4v7vgs); + else if (here->BSIM4v7rgateMod == 3) + T0 = *(ckt->CKTstates[0] + here->BSIM4v7vgms) + - *(ckt->CKTstates[0] + here->BSIM4v7vgs); + if (here->BSIM4v7rgateMod > 1) + { gcrgd = here->BSIM4v7gcrgs * T0; + gcrgg = here->BSIM4v7gcrgg * T0; + gcrgs = here->BSIM4v7gcrgd * T0; + gcrgb = here->BSIM4v7gcrgb * T0; + gcrgg -= here->BSIM4v7gcrg; + gcrg = here->BSIM4v7gcrg; } else gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0; - if (here->BSIM4acnqsMod == 0) - { if (here->BSIM4rgateMod == 3) - { xcgmgmb = cgdo + cgso + pParam->BSIM4cgbo; + if (here->BSIM4v7acnqsMod == 0) + { if (here->BSIM4v7rgateMod == 3) + { xcgmgmb = cgdo + cgso + pParam->BSIM4v7cgbo; xcgmdb = -cgdo; xcgmsb = -cgso; - xcgmbb = -pParam->BSIM4cgbo; + xcgmbb = -pParam->BSIM4v7cgbo; xcdgmb = xcgmdb; xcsgmb = xcgmsb; xcbgmb = xcgmbb; - xcggb = here->BSIM4cggb; - xcgdb = here->BSIM4cgsb; - xcgsb = here->BSIM4cgdb; + xcggb = here->BSIM4v7cggb; + xcgdb = here->BSIM4v7cgsb; + xcgsb = here->BSIM4v7cgdb; xcgbb = -(xcggb + xcgdb + xcgsb); - xcdgb = -(here->BSIM4cggb + here->BSIM4cbgb - + here->BSIM4cdgb); - xcsgb = here->BSIM4cdgb; - xcbgb = here->BSIM4cbgb; + xcdgb = -(here->BSIM4v7cggb + here->BSIM4v7cbgb + + here->BSIM4v7cdgb); + xcsgb = here->BSIM4v7cdgb; + xcbgb = here->BSIM4v7cbgb; } else - { xcggb = here->BSIM4cggb + cgdo + cgso - + pParam->BSIM4cgbo; - xcgdb = here->BSIM4cgsb - cgdo; - xcgsb = here->BSIM4cgdb - cgso; + { xcggb = here->BSIM4v7cggb + cgdo + cgso + + pParam->BSIM4v7cgbo; + xcgdb = here->BSIM4v7cgsb - cgdo; + xcgsb = here->BSIM4v7cgdb - cgso; xcgbb = -(xcggb + xcgdb + xcgsb); - xcdgb = -(here->BSIM4cggb + here->BSIM4cbgb - + here->BSIM4cdgb + cgdo); - xcsgb = here->BSIM4cdgb - cgso; - xcbgb = here->BSIM4cbgb - pParam->BSIM4cgbo; + xcdgb = -(here->BSIM4v7cggb + here->BSIM4v7cbgb + + here->BSIM4v7cdgb + cgdo); + xcsgb = here->BSIM4v7cdgb - cgso; + xcbgb = here->BSIM4v7cbgb - pParam->BSIM4v7cgbo; xcdgmb = xcsgmb = xcbgmb = 0.0; } - xcddb = here->BSIM4capbd + cgdo - (here->BSIM4cgsb - + here->BSIM4cbsb + here->BSIM4cdsb); - xcdsb = -(here->BSIM4cgdb + here->BSIM4cbdb - + here->BSIM4cddb); + xcddb = here->BSIM4v7capbd + cgdo - (here->BSIM4v7cgsb + + here->BSIM4v7cbsb + here->BSIM4v7cdsb); + xcdsb = -(here->BSIM4v7cgdb + here->BSIM4v7cbdb + + here->BSIM4v7cddb); - xcsdb = here->BSIM4cdsb; - xcssb = here->BSIM4cddb + here->BSIM4capbs + cgso; + xcsdb = here->BSIM4v7cdsb; + xcssb = here->BSIM4v7cddb + here->BSIM4v7capbs + cgso; - if (!here->BSIM4rbodyMod) + if (!here->BSIM4v7rbodyMod) { xcdbb = -(xcdgb + xcddb + xcdsb + xcdgmb); xcsbb = -(xcsgb + xcsdb + xcssb + xcsgmb); - xcbdb = here->BSIM4cbsb - here->BSIM4capbd; - xcbsb = here->BSIM4cbdb - here->BSIM4capbs; + xcbdb = here->BSIM4v7cbsb - here->BSIM4v7capbd; + xcbsb = here->BSIM4v7cbdb - here->BSIM4v7capbs; xcdbdb = 0.0; } else { xcdbb = -(xcdgb + xcddb + xcdsb + xcdgmb) - + here->BSIM4capbd; - xcsbb = -(here->BSIM4cddb + here->BSIM4cdgb - + here->BSIM4cdsb); - xcbdb = here->BSIM4cbsb; - xcbsb = here->BSIM4cbdb; - xcdbdb = -here->BSIM4capbd; - xcsbsb = -here->BSIM4capbs; + + here->BSIM4v7capbd; + xcsbb = -(here->BSIM4v7cddb + here->BSIM4v7cdgb + + here->BSIM4v7cdsb); + xcbdb = here->BSIM4v7cbsb; + xcbsb = here->BSIM4v7cbdb; + xcdbdb = -here->BSIM4v7capbd; + xcsbsb = -here->BSIM4v7capbs; } xcbbb = -(xcbgb + xcbdb + xcbsb + xcbgmb); @@ -407,24 +407,24 @@ double m; xcdgb = xcddb = xcdsb = xcdbb = 0.0; xcsgb = xcsdb = xcssb = xcsbb = 0.0; - xgtg = here->BSIM4gtg; - xgtd = here->BSIM4gts; - xgts = here->BSIM4gtd; - xgtb = here->BSIM4gtb; + xgtg = here->BSIM4v7gtg; + xgtd = here->BSIM4v7gts; + xgts = here->BSIM4v7gtd; + xgtb = here->BSIM4v7gtb; - xcqgb = here->BSIM4cqgb; - xcqdb = here->BSIM4cqsb; - xcqsb = here->BSIM4cqdb; - xcqbb = here->BSIM4cqbb; + xcqgb = here->BSIM4v7cqgb; + xcqdb = here->BSIM4v7cqsb; + xcqsb = here->BSIM4v7cqdb; + xcqbb = here->BSIM4v7cqbb; - CoxWL = model->BSIM4coxe * here->pParam->BSIM4weffCV - * here->BSIM4nf * here->pParam->BSIM4leffCV; - qcheq = -(here->BSIM4qgate + here->BSIM4qbulk); + CoxWL = model->BSIM4v7coxe * here->pParam->BSIM4v7weffCV + * here->BSIM4v7nf * here->pParam->BSIM4v7leffCV; + qcheq = -(here->BSIM4v7qgate + here->BSIM4v7qbulk); if (fabs(qcheq) <= 1.0e-5 * CoxWL) - { if (model->BSIM4xpart < 0.5) + { if (model->BSIM4v7xpart < 0.5) { sxpart = 0.4; } - else if (model->BSIM4xpart > 0.5) + else if (model->BSIM4v7xpart > 0.5) { sxpart = 0.0; } else @@ -434,19 +434,19 @@ double m; = dsxpart_dVs = 0.0; } else - { sxpart = here->BSIM4qdrn / qcheq; - Css = here->BSIM4cddb; - Cds = -(here->BSIM4cgdb + here->BSIM4cddb - + here->BSIM4cbdb); + { sxpart = here->BSIM4v7qdrn / qcheq; + Css = here->BSIM4v7cddb; + Cds = -(here->BSIM4v7cgdb + here->BSIM4v7cddb + + here->BSIM4v7cbdb); dsxpart_dVs = (Css - sxpart * (Css + Cds)) / qcheq; - Csg = here->BSIM4cdgb; - Cdg = -(here->BSIM4cggb + here->BSIM4cdgb - + here->BSIM4cbgb); + Csg = here->BSIM4v7cdgb; + Cdg = -(here->BSIM4v7cggb + here->BSIM4v7cdgb + + here->BSIM4v7cbgb); dsxpart_dVg = (Csg - sxpart * (Csg + Cdg)) / qcheq; - Csd = here->BSIM4cdsb; - Cdd = -(here->BSIM4cgsb + here->BSIM4cdsb - + here->BSIM4cbsb); + Csd = here->BSIM4v7cdsb; + Cdd = -(here->BSIM4v7cgsb + here->BSIM4v7cdsb + + here->BSIM4v7cbsb); dsxpart_dVd = (Csd - sxpart * (Csd + Cdd)) / qcheq; dsxpart_dVb = -(dsxpart_dVd + dsxpart_dVg @@ -460,18 +460,18 @@ double m; } } - if (model->BSIM4rdsMod == 1) - { gstot = here->BSIM4gstot; - gstotd = here->BSIM4gstotd; - gstotg = here->BSIM4gstotg; - gstots = here->BSIM4gstots - gstot; - gstotb = here->BSIM4gstotb; + if (model->BSIM4v7rdsMod == 1) + { gstot = here->BSIM4v7gstot; + gstotd = here->BSIM4v7gstotd; + gstotg = here->BSIM4v7gstotg; + gstots = here->BSIM4v7gstots - gstot; + gstotb = here->BSIM4v7gstotb; - gdtot = here->BSIM4gdtot; - gdtotd = here->BSIM4gdtotd - gdtot; - gdtotg = here->BSIM4gdtotg; - gdtots = here->BSIM4gdtots; - gdtotb = here->BSIM4gdtotb; + gdtot = here->BSIM4v7gdtot; + gdtotd = here->BSIM4v7gdtotd - gdtot; + gdtotg = here->BSIM4v7gdtotg; + gdtots = here->BSIM4v7gdtots; + gdtotb = here->BSIM4v7gdtotb; } else { gstot = gstotd = gstotg = gstots = gstotb = 0.0; @@ -479,279 +479,279 @@ double m; } - T1 = *(ckt->CKTstate0 + here->BSIM4qdef) * here->BSIM4gtau; - gds = here->BSIM4gds; + T1 = *(ckt->CKTstate0 + here->BSIM4v7qdef) * here->BSIM4v7gtau; + gds = here->BSIM4v7gds; /* * Loading PZ matrix */ - m = here->BSIM4m; + m = here->BSIM4v7m; - if (!model->BSIM4rdsMod) - { gdpr = here->BSIM4drainConductance; - gspr = here->BSIM4sourceConductance; + if (!model->BSIM4v7rdsMod) + { gdpr = here->BSIM4v7drainConductance; + gspr = here->BSIM4v7sourceConductance; } else gdpr = gspr = 0.0; - if (!here->BSIM4rbodyMod) - { gjbd = here->BSIM4gbd; - gjbs = here->BSIM4gbs; + if (!here->BSIM4v7rbodyMod) + { gjbd = here->BSIM4v7gbd; + gjbs = here->BSIM4v7gbs; } else gjbd = gjbs = 0.0; - geltd = here->BSIM4grgeltd; + geltd = here->BSIM4v7grgeltd; - if (here->BSIM4rgateMod == 1) - { *(here->BSIM4GEgePtr) += m * geltd; - *(here->BSIM4GPgePtr) -= m * geltd; - *(here->BSIM4GEgpPtr) -= m * geltd; + if (here->BSIM4v7rgateMod == 1) + { *(here->BSIM4v7GEgePtr) += m * geltd; + *(here->BSIM4v7GPgePtr) -= m * geltd; + *(here->BSIM4v7GEgpPtr) -= m * geltd; - *(here->BSIM4GPgpPtr ) += m * xcggb * s->real; - *(here->BSIM4GPgpPtr +1) += m * xcggb * s->imag; - *(here->BSIM4GPgpPtr) += m * (geltd - xgtg + gIgtotg); - *(here->BSIM4GPdpPtr ) += m * xcgdb * s->real; - *(here->BSIM4GPdpPtr +1) += m * xcgdb * s->imag; - *(here->BSIM4GPdpPtr) -= m * (xgtd - gIgtotd); - *(here->BSIM4GPspPtr ) += m * xcgsb * s->real; - *(here->BSIM4GPspPtr +1) += m * xcgsb * s->imag; - *(here->BSIM4GPspPtr) -= m * (xgts - gIgtots); - *(here->BSIM4GPbpPtr ) += m * xcgbb * s->real; - *(here->BSIM4GPbpPtr +1) += m * xcgbb * s->imag; - *(here->BSIM4GPbpPtr) -= m * (xgtb - gIgtotb); + *(here->BSIM4v7GPgpPtr ) += m * xcggb * s->real; + *(here->BSIM4v7GPgpPtr +1) += m * xcggb * s->imag; + *(here->BSIM4v7GPgpPtr) += m * (geltd - xgtg + gIgtotg); + *(here->BSIM4v7GPdpPtr ) += m * xcgdb * s->real; + *(here->BSIM4v7GPdpPtr +1) += m * xcgdb * s->imag; + *(here->BSIM4v7GPdpPtr) -= m * (xgtd - gIgtotd); + *(here->BSIM4v7GPspPtr ) += m * xcgsb * s->real; + *(here->BSIM4v7GPspPtr +1) += m * xcgsb * s->imag; + *(here->BSIM4v7GPspPtr) -= m * (xgts - gIgtots); + *(here->BSIM4v7GPbpPtr ) += m * xcgbb * s->real; + *(here->BSIM4v7GPbpPtr +1) += m * xcgbb * s->imag; + *(here->BSIM4v7GPbpPtr) -= m * (xgtb - gIgtotb); } - else if (here->BSIM4rgateMod == 2) - { *(here->BSIM4GEgePtr) += m * gcrg; - *(here->BSIM4GEgpPtr) += m * gcrgg; - *(here->BSIM4GEdpPtr) += m * gcrgd; - *(here->BSIM4GEspPtr) += m * gcrgs; - *(here->BSIM4GEbpPtr) += m * gcrgb; + else if (here->BSIM4v7rgateMod == 2) + { *(here->BSIM4v7GEgePtr) += m * gcrg; + *(here->BSIM4v7GEgpPtr) += m * gcrgg; + *(here->BSIM4v7GEdpPtr) += m * gcrgd; + *(here->BSIM4v7GEspPtr) += m * gcrgs; + *(here->BSIM4v7GEbpPtr) += m * gcrgb; - *(here->BSIM4GPgePtr) -= m * gcrg; - *(here->BSIM4GPgpPtr ) += m * xcggb * s->real; - *(here->BSIM4GPgpPtr +1) += m * xcggb * s->imag; - *(here->BSIM4GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg); - *(here->BSIM4GPdpPtr ) += m * xcgdb * s->real; - *(here->BSIM4GPdpPtr +1) += m * xcgdb * s->imag; - *(here->BSIM4GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd); - *(here->BSIM4GPspPtr ) += m * xcgsb * s->real; - *(here->BSIM4GPspPtr +1) += m * xcgsb * s->imag; - *(here->BSIM4GPspPtr) -= m * (gcrgs + xgts - gIgtots); - *(here->BSIM4GPbpPtr ) += m * xcgbb * s->real; - *(here->BSIM4GPbpPtr +1) += m * xcgbb * s->imag; - *(here->BSIM4GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb); + *(here->BSIM4v7GPgePtr) -= m * gcrg; + *(here->BSIM4v7GPgpPtr ) += m * xcggb * s->real; + *(here->BSIM4v7GPgpPtr +1) += m * xcggb * s->imag; + *(here->BSIM4v7GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg); + *(here->BSIM4v7GPdpPtr ) += m * xcgdb * s->real; + *(here->BSIM4v7GPdpPtr +1) += m * xcgdb * s->imag; + *(here->BSIM4v7GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd); + *(here->BSIM4v7GPspPtr ) += m * xcgsb * s->real; + *(here->BSIM4v7GPspPtr +1) += m * xcgsb * s->imag; + *(here->BSIM4v7GPspPtr) -= m * (gcrgs + xgts - gIgtots); + *(here->BSIM4v7GPbpPtr ) += m * xcgbb * s->real; + *(here->BSIM4v7GPbpPtr +1) += m * xcgbb * s->imag; + *(here->BSIM4v7GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb); } - else if (here->BSIM4rgateMod == 3) - { *(here->BSIM4GEgePtr) += m * geltd; - *(here->BSIM4GEgmPtr) -= m * geltd; - *(here->BSIM4GMgePtr) -= m * geltd; - *(here->BSIM4GMgmPtr) += m * (geltd + gcrg); - *(here->BSIM4GMgmPtr ) += m * xcgmgmb * s->real; - *(here->BSIM4GMgmPtr +1) += m * xcgmgmb * s->imag; + else if (here->BSIM4v7rgateMod == 3) + { *(here->BSIM4v7GEgePtr) += m * geltd; + *(here->BSIM4v7GEgmPtr) -= m * geltd; + *(here->BSIM4v7GMgePtr) -= m * geltd; + *(here->BSIM4v7GMgmPtr) += m * (geltd + gcrg); + *(here->BSIM4v7GMgmPtr ) += m * xcgmgmb * s->real; + *(here->BSIM4v7GMgmPtr +1) += m * xcgmgmb * s->imag; - *(here->BSIM4GMdpPtr) += m * gcrgd; - *(here->BSIM4GMdpPtr ) += m * xcgmdb * s->real; - *(here->BSIM4GMdpPtr +1) += m * xcgmdb * s->imag; - *(here->BSIM4GMgpPtr) += m * gcrgg; - *(here->BSIM4GMspPtr) += m * gcrgs; - *(here->BSIM4GMspPtr ) += m * xcgmsb * s->real; - *(here->BSIM4GMspPtr +1) += m * xcgmsb * s->imag; - *(here->BSIM4GMbpPtr) += m * gcrgb; - *(here->BSIM4GMbpPtr ) += m * xcgmbb * s->real; - *(here->BSIM4GMbpPtr +1) += m * xcgmbb * s->imag; + *(here->BSIM4v7GMdpPtr) += m * gcrgd; + *(here->BSIM4v7GMdpPtr ) += m * xcgmdb * s->real; + *(here->BSIM4v7GMdpPtr +1) += m * xcgmdb * s->imag; + *(here->BSIM4v7GMgpPtr) += m * gcrgg; + *(here->BSIM4v7GMspPtr) += m * gcrgs; + *(here->BSIM4v7GMspPtr ) += m * xcgmsb * s->real; + *(here->BSIM4v7GMspPtr +1) += m * xcgmsb * s->imag; + *(here->BSIM4v7GMbpPtr) += m * gcrgb; + *(here->BSIM4v7GMbpPtr ) += m * xcgmbb * s->real; + *(here->BSIM4v7GMbpPtr +1) += m * xcgmbb * s->imag; - *(here->BSIM4DPgmPtr ) += m * xcdgmb * s->real; - *(here->BSIM4DPgmPtr +1) += m * xcdgmb * s->imag; - *(here->BSIM4GPgmPtr) -= m * gcrg; - *(here->BSIM4SPgmPtr ) += m * xcsgmb * s->real; - *(here->BSIM4SPgmPtr +1) += m * xcsgmb * s->imag; - *(here->BSIM4BPgmPtr ) += m * xcbgmb * s->real; - *(here->BSIM4BPgmPtr +1) += m * xcbgmb * s->imag; + *(here->BSIM4v7DPgmPtr ) += m * xcdgmb * s->real; + *(here->BSIM4v7DPgmPtr +1) += m * xcdgmb * s->imag; + *(here->BSIM4v7GPgmPtr) -= m * gcrg; + *(here->BSIM4v7SPgmPtr ) += m * xcsgmb * s->real; + *(here->BSIM4v7SPgmPtr +1) += m * xcsgmb * s->imag; + *(here->BSIM4v7BPgmPtr ) += m * xcbgmb * s->real; + *(here->BSIM4v7BPgmPtr +1) += m * xcbgmb * s->imag; - *(here->BSIM4GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg); - *(here->BSIM4GPgpPtr ) += m * xcggb * s->real; - *(here->BSIM4GPgpPtr +1) += m * xcggb * s->imag; - *(here->BSIM4GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd); - *(here->BSIM4GPdpPtr ) += m * xcgdb * s->real; - *(here->BSIM4GPdpPtr +1) += m * xcgdb * s->imag; - *(here->BSIM4GPspPtr) -= m * (gcrgs + xgts - gIgtots); - *(here->BSIM4GPspPtr ) += m * xcgsb * s->real; - *(here->BSIM4GPspPtr +1) += m * xcgsb * s->imag; - *(here->BSIM4GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb); - *(here->BSIM4GPbpPtr ) += m * xcgbb * s->real; - *(here->BSIM4GPbpPtr +1) += m * xcgbb * s->imag; + *(here->BSIM4v7GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg); + *(here->BSIM4v7GPgpPtr ) += m * xcggb * s->real; + *(here->BSIM4v7GPgpPtr +1) += m * xcggb * s->imag; + *(here->BSIM4v7GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd); + *(here->BSIM4v7GPdpPtr ) += m * xcgdb * s->real; + *(here->BSIM4v7GPdpPtr +1) += m * xcgdb * s->imag; + *(here->BSIM4v7GPspPtr) -= m * (gcrgs + xgts - gIgtots); + *(here->BSIM4v7GPspPtr ) += m * xcgsb * s->real; + *(here->BSIM4v7GPspPtr +1) += m * xcgsb * s->imag; + *(here->BSIM4v7GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb); + *(here->BSIM4v7GPbpPtr ) += m * xcgbb * s->real; + *(here->BSIM4v7GPbpPtr +1) += m * xcgbb * s->imag; } else - { *(here->BSIM4GPdpPtr ) += m * xcgdb * s->real; - *(here->BSIM4GPdpPtr +1) += m * xcgdb * s->imag; - *(here->BSIM4GPdpPtr) -= m * (xgtd - gIgtotd); - *(here->BSIM4GPgpPtr ) += m * xcggb * s->real; - *(here->BSIM4GPgpPtr +1) += m * xcggb * s->imag; - *(here->BSIM4GPgpPtr) -= m * (xgtg - gIgtotg); - *(here->BSIM4GPspPtr ) += m * xcgsb * s->real; - *(here->BSIM4GPspPtr +1) += m * xcgsb * s->imag; - *(here->BSIM4GPspPtr) -= m * (xgts - gIgtots); - *(here->BSIM4GPbpPtr ) += m * xcgbb * s->real; - *(here->BSIM4GPbpPtr +1) += m * xcgbb * s->imag; - *(here->BSIM4GPbpPtr) -= m * (xgtb - gIgtotb); + { *(here->BSIM4v7GPdpPtr ) += m * xcgdb * s->real; + *(here->BSIM4v7GPdpPtr +1) += m * xcgdb * s->imag; + *(here->BSIM4v7GPdpPtr) -= m * (xgtd - gIgtotd); + *(here->BSIM4v7GPgpPtr ) += m * xcggb * s->real; + *(here->BSIM4v7GPgpPtr +1) += m * xcggb * s->imag; + *(here->BSIM4v7GPgpPtr) -= m * (xgtg - gIgtotg); + *(here->BSIM4v7GPspPtr ) += m * xcgsb * s->real; + *(here->BSIM4v7GPspPtr +1) += m * xcgsb * s->imag; + *(here->BSIM4v7GPspPtr) -= m * (xgts - gIgtots); + *(here->BSIM4v7GPbpPtr ) += m * xcgbb * s->real; + *(here->BSIM4v7GPbpPtr +1) += m * xcgbb * s->imag; + *(here->BSIM4v7GPbpPtr) -= m * (xgtb - gIgtotb); } - if (model->BSIM4rdsMod) - { (*(here->BSIM4DgpPtr) += m * gdtotg); - (*(here->BSIM4DspPtr) += m * gdtots); - (*(here->BSIM4DbpPtr) += m * gdtotb); - (*(here->BSIM4SdpPtr) += m * gstotd); - (*(here->BSIM4SgpPtr) += m * gstotg); - (*(here->BSIM4SbpPtr) += m * gstotb); + if (model->BSIM4v7rdsMod) + { (*(here->BSIM4v7DgpPtr) += m * gdtotg); + (*(here->BSIM4v7DspPtr) += m * gdtots); + (*(here->BSIM4v7DbpPtr) += m * gdtotb); + (*(here->BSIM4v7SdpPtr) += m * gstotd); + (*(here->BSIM4v7SgpPtr) += m * gstotg); + (*(here->BSIM4v7SbpPtr) += m * gstotb); } - *(here->BSIM4DPdpPtr ) += m * xcddb * s->real; - *(here->BSIM4DPdpPtr +1) += m * xcddb * s->imag; - *(here->BSIM4DPdpPtr) += m * (gdpr + gds + here->BSIM4gbd + *(here->BSIM4v7DPdpPtr ) += m * xcddb * s->real; + *(here->BSIM4v7DPdpPtr +1) += m * xcddb * s->imag; + *(here->BSIM4v7DPdpPtr) += m * (gdpr + gds + here->BSIM4v7gbd - gdtotd + RevSum + gbdpdp - gIdtotd + dxpart * xgtd + T1 * ddxpart_dVd); - *(here->BSIM4DPdPtr) -= m * (gdpr + gdtot); - *(here->BSIM4DPgpPtr ) += m * xcdgb * s->real; - *(here->BSIM4DPgpPtr +1) += m * xcdgb * s->imag; - *(here->BSIM4DPgpPtr) += m * (Gm - gdtotg + gbdpg - gIdtotg + *(here->BSIM4v7DPdPtr) -= m * (gdpr + gdtot); + *(here->BSIM4v7DPgpPtr ) += m * xcdgb * s->real; + *(here->BSIM4v7DPgpPtr +1) += m * xcdgb * s->imag; + *(here->BSIM4v7DPgpPtr) += m * (Gm - gdtotg + gbdpg - gIdtotg + T1 * ddxpart_dVg + dxpart * xgtg); - *(here->BSIM4DPspPtr ) += m * xcdsb * s->real; - *(here->BSIM4DPspPtr +1) += m * xcdsb * s->imag; - *(here->BSIM4DPspPtr) -= m * (gds + FwdSum + gdtots - gbdpsp + gIdtots + *(here->BSIM4v7DPspPtr ) += m * xcdsb * s->real; + *(here->BSIM4v7DPspPtr +1) += m * xcdsb * s->imag; + *(here->BSIM4v7DPspPtr) -= m * (gds + FwdSum + gdtots - gbdpsp + gIdtots - T1 * ddxpart_dVs - dxpart * xgts); - *(here->BSIM4DPbpPtr ) += m * xcdbb * s->real; - *(here->BSIM4DPbpPtr +1) += m * xcdbb * s->imag; - *(here->BSIM4DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gbdpb + gIdtotb + *(here->BSIM4v7DPbpPtr ) += m * xcdbb * s->real; + *(here->BSIM4v7DPbpPtr +1) += m * xcdbb * s->imag; + *(here->BSIM4v7DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gbdpb + gIdtotb - T1 * ddxpart_dVb - dxpart * xgtb); - *(here->BSIM4DdpPtr) -= m * (gdpr - gdtotd); - *(here->BSIM4DdPtr) += m * (gdpr + gdtot); + *(here->BSIM4v7DdpPtr) -= m * (gdpr - gdtotd); + *(here->BSIM4v7DdPtr) += m * (gdpr + gdtot); - *(here->BSIM4SPdpPtr ) += m * xcsdb * s->real; - *(here->BSIM4SPdpPtr +1) += m * xcsdb * s->imag; - *(here->BSIM4SPdpPtr) -= m * (gds + gstotd + RevSum - gbspdp + gIstotd + *(here->BSIM4v7SPdpPtr ) += m * xcsdb * s->real; + *(here->BSIM4v7SPdpPtr +1) += m * xcsdb * s->imag; + *(here->BSIM4v7SPdpPtr) -= m * (gds + gstotd + RevSum - gbspdp + gIstotd - T1 * dsxpart_dVd - sxpart * xgtd); - *(here->BSIM4SPgpPtr ) += m * xcsgb * s->real; - *(here->BSIM4SPgpPtr +1) += m * xcsgb * s->imag; - *(here->BSIM4SPgpPtr) -= m * (Gm + gstotg - gbspg + gIstotg + *(here->BSIM4v7SPgpPtr ) += m * xcsgb * s->real; + *(here->BSIM4v7SPgpPtr +1) += m * xcsgb * s->imag; + *(here->BSIM4v7SPgpPtr) -= m * (Gm + gstotg - gbspg + gIstotg - T1 * dsxpart_dVg - sxpart * xgtg); - *(here->BSIM4SPspPtr ) += m * xcssb * s->real; - *(here->BSIM4SPspPtr +1) += m * xcssb * s->imag; - *(here->BSIM4SPspPtr) += m * (gspr + gds + here->BSIM4gbs - gIstots + *(here->BSIM4v7SPspPtr ) += m * xcssb * s->real; + *(here->BSIM4v7SPspPtr +1) += m * xcssb * s->imag; + *(here->BSIM4v7SPspPtr) += m * (gspr + gds + here->BSIM4v7gbs - gIstots - gstots + FwdSum + gbspsp + sxpart * xgts + T1 * dsxpart_dVs); - *(here->BSIM4SPsPtr) -= m * (gspr + gstot); - *(here->BSIM4SPbpPtr ) += m * xcsbb * s->real; - *(here->BSIM4SPbpPtr +1) += m * xcsbb * s->imag; - *(here->BSIM4SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gbspb + gIstotb + *(here->BSIM4v7SPsPtr) -= m * (gspr + gstot); + *(here->BSIM4v7SPbpPtr ) += m * xcsbb * s->real; + *(here->BSIM4v7SPbpPtr +1) += m * xcsbb * s->imag; + *(here->BSIM4v7SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gbspb + gIstotb - T1 * dsxpart_dVb - sxpart * xgtb); - *(here->BSIM4SspPtr) -= m * (gspr - gstots); - *(here->BSIM4SsPtr) += m * (gspr + gstot); + *(here->BSIM4v7SspPtr) -= m * (gspr - gstots); + *(here->BSIM4v7SsPtr) += m * (gspr + gstot); - *(here->BSIM4BPdpPtr ) += m * xcbdb * s->real; - *(here->BSIM4BPdpPtr +1) += m * xcbdb * s->imag; - *(here->BSIM4BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd); - *(here->BSIM4BPgpPtr ) += m * xcbgb * s->real; - *(here->BSIM4BPgpPtr +1) += m * xcbgb * s->imag; - *(here->BSIM4BPgpPtr) -= m * (here->BSIM4gbgs + gIbtotg); - *(here->BSIM4BPspPtr ) += m * xcbsb * s->real; - *(here->BSIM4BPspPtr +1) += m * xcbsb * s->imag; - *(here->BSIM4BPspPtr) -= m * (gjbs - gbbsp + gIbtots); - *(here->BSIM4BPbpPtr ) += m * xcbbb * s->real; - *(here->BSIM4BPbpPtr +1) += m * xcbbb * s->imag; - *(here->BSIM4BPbpPtr) += m * (gjbd + gjbs - here->BSIM4gbbs + *(here->BSIM4v7BPdpPtr ) += m * xcbdb * s->real; + *(here->BSIM4v7BPdpPtr +1) += m * xcbdb * s->imag; + *(here->BSIM4v7BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd); + *(here->BSIM4v7BPgpPtr ) += m * xcbgb * s->real; + *(here->BSIM4v7BPgpPtr +1) += m * xcbgb * s->imag; + *(here->BSIM4v7BPgpPtr) -= m * (here->BSIM4v7gbgs + gIbtotg); + *(here->BSIM4v7BPspPtr ) += m * xcbsb * s->real; + *(here->BSIM4v7BPspPtr +1) += m * xcbsb * s->imag; + *(here->BSIM4v7BPspPtr) -= m * (gjbs - gbbsp + gIbtots); + *(here->BSIM4v7BPbpPtr ) += m * xcbbb * s->real; + *(here->BSIM4v7BPbpPtr +1) += m * xcbbb * s->imag; + *(here->BSIM4v7BPbpPtr) += m * (gjbd + gjbs - here->BSIM4v7gbbs - gIbtotb); - ggidld = here->BSIM4ggidld; - ggidlg = here->BSIM4ggidlg; - ggidlb = here->BSIM4ggidlb; - ggislg = here->BSIM4ggislg; - ggisls = here->BSIM4ggisls; - ggislb = here->BSIM4ggislb; + ggidld = here->BSIM4v7ggidld; + ggidlg = here->BSIM4v7ggidlg; + ggidlb = here->BSIM4v7ggidlb; + ggislg = here->BSIM4v7ggislg; + ggisls = here->BSIM4v7ggisls; + ggislb = here->BSIM4v7ggislb; /* stamp gidl */ - (*(here->BSIM4DPdpPtr) += m * ggidld); - (*(here->BSIM4DPgpPtr) += m * ggidlg); - (*(here->BSIM4DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb)); - (*(here->BSIM4DPbpPtr) += m * ggidlb); - (*(here->BSIM4BPdpPtr) -= m * ggidld); - (*(here->BSIM4BPgpPtr) -= m * ggidlg); - (*(here->BSIM4BPspPtr) += m * ((ggidlg + ggidld) + ggidlb)); - (*(here->BSIM4BPbpPtr) -= m * ggidlb); + (*(here->BSIM4v7DPdpPtr) += m * ggidld); + (*(here->BSIM4v7DPgpPtr) += m * ggidlg); + (*(here->BSIM4v7DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb)); + (*(here->BSIM4v7DPbpPtr) += m * ggidlb); + (*(here->BSIM4v7BPdpPtr) -= m * ggidld); + (*(here->BSIM4v7BPgpPtr) -= m * ggidlg); + (*(here->BSIM4v7BPspPtr) += m * ((ggidlg + ggidld) + ggidlb)); + (*(here->BSIM4v7BPbpPtr) -= m * ggidlb); /* stamp gisl */ - (*(here->BSIM4SPdpPtr) -= m * ((ggisls + ggislg) + ggislb)); - (*(here->BSIM4SPgpPtr) += m * ggislg); - (*(here->BSIM4SPspPtr) += m * ggisls); - (*(here->BSIM4SPbpPtr) += m * ggislb); - (*(here->BSIM4BPdpPtr) += m * ((ggislg + ggisls) + ggislb)); - (*(here->BSIM4BPgpPtr) -= m * ggislg); - (*(here->BSIM4BPspPtr) -= m * ggisls); - (*(here->BSIM4BPbpPtr) -= m * ggislb); + (*(here->BSIM4v7SPdpPtr) -= m * ((ggisls + ggislg) + ggislb)); + (*(here->BSIM4v7SPgpPtr) += m * ggislg); + (*(here->BSIM4v7SPspPtr) += m * ggisls); + (*(here->BSIM4v7SPbpPtr) += m * ggislb); + (*(here->BSIM4v7BPdpPtr) += m * ((ggislg + ggisls) + ggislb)); + (*(here->BSIM4v7BPgpPtr) -= m * ggislg); + (*(here->BSIM4v7BPspPtr) -= m * ggisls); + (*(here->BSIM4v7BPbpPtr) -= m * ggislb); - if (here->BSIM4rbodyMod) - { (*(here->BSIM4DPdbPtr ) += m * xcdbdb * s->real); - (*(here->BSIM4DPdbPtr +1) += m * xcdbdb * s->imag); - (*(here->BSIM4DPdbPtr) -= m * here->BSIM4gbd); - (*(here->BSIM4SPsbPtr ) += m * xcsbsb * s->real); - (*(here->BSIM4SPsbPtr +1) += m * xcsbsb * s->imag); - (*(here->BSIM4SPsbPtr) -= m * here->BSIM4gbs); + if (here->BSIM4v7rbodyMod) + { (*(here->BSIM4v7DPdbPtr ) += m * xcdbdb * s->real); + (*(here->BSIM4v7DPdbPtr +1) += m * xcdbdb * s->imag); + (*(here->BSIM4v7DPdbPtr) -= m * here->BSIM4v7gbd); + (*(here->BSIM4v7SPsbPtr ) += m * xcsbsb * s->real); + (*(here->BSIM4v7SPsbPtr +1) += m * xcsbsb * s->imag); + (*(here->BSIM4v7SPsbPtr) -= m * here->BSIM4v7gbs); - (*(here->BSIM4DBdpPtr ) += m * xcdbdb * s->real); - (*(here->BSIM4DBdpPtr +1) += m * xcdbdb * s->imag); - (*(here->BSIM4DBdpPtr) -= m * here->BSIM4gbd); - (*(here->BSIM4DBdbPtr ) -= m * xcdbdb * s->real); - (*(here->BSIM4DBdbPtr +1) -= m * xcdbdb * s->imag); - (*(here->BSIM4DBdbPtr) += m * (here->BSIM4gbd + here->BSIM4grbpd - + here->BSIM4grbdb)); - (*(here->BSIM4DBbpPtr) -= m * here->BSIM4grbpd); - (*(here->BSIM4DBbPtr) -= m * here->BSIM4grbdb); + (*(here->BSIM4v7DBdpPtr ) += m * xcdbdb * s->real); + (*(here->BSIM4v7DBdpPtr +1) += m * xcdbdb * s->imag); + (*(here->BSIM4v7DBdpPtr) -= m * here->BSIM4v7gbd); + (*(here->BSIM4v7DBdbPtr ) -= m * xcdbdb * s->real); + (*(here->BSIM4v7DBdbPtr +1) -= m * xcdbdb * s->imag); + (*(here->BSIM4v7DBdbPtr) += m * (here->BSIM4v7gbd + here->BSIM4v7grbpd + + here->BSIM4v7grbdb)); + (*(here->BSIM4v7DBbpPtr) -= m * here->BSIM4v7grbpd); + (*(here->BSIM4v7DBbPtr) -= m * here->BSIM4v7grbdb); - (*(here->BSIM4BPdbPtr) -= m * here->BSIM4grbpd); - (*(here->BSIM4BPbPtr) -= m * here->BSIM4grbpb); - (*(here->BSIM4BPsbPtr) -= m * here->BSIM4grbps); - (*(here->BSIM4BPbpPtr) += m * (here->BSIM4grbpd + here->BSIM4grbps - + here->BSIM4grbpb)); - /* WDL: (-here->BSIM4gbbs) already added to BPbpPtr */ + (*(here->BSIM4v7BPdbPtr) -= m * here->BSIM4v7grbpd); + (*(here->BSIM4v7BPbPtr) -= m * here->BSIM4v7grbpb); + (*(here->BSIM4v7BPsbPtr) -= m * here->BSIM4v7grbps); + (*(here->BSIM4v7BPbpPtr) += m * (here->BSIM4v7grbpd + here->BSIM4v7grbps + + here->BSIM4v7grbpb)); + /* WDL: (-here->BSIM4v7gbbs) already added to BPbpPtr */ - (*(here->BSIM4SBspPtr ) += m * xcsbsb * s->real); - (*(here->BSIM4SBspPtr +1) += m * xcsbsb * s->imag); - (*(here->BSIM4SBspPtr) -= m * here->BSIM4gbs); - (*(here->BSIM4SBbpPtr) -= m * here->BSIM4grbps); - (*(here->BSIM4SBbPtr) -= m * here->BSIM4grbsb); - (*(here->BSIM4SBsbPtr ) -= m * xcsbsb * s->real); - (*(here->BSIM4SBsbPtr +1) -= m * xcsbsb * s->imag); - (*(here->BSIM4SBsbPtr) += m * (here->BSIM4gbs - + here->BSIM4grbps + here->BSIM4grbsb)); + (*(here->BSIM4v7SBspPtr ) += m * xcsbsb * s->real); + (*(here->BSIM4v7SBspPtr +1) += m * xcsbsb * s->imag); + (*(here->BSIM4v7SBspPtr) -= m * here->BSIM4v7gbs); + (*(here->BSIM4v7SBbpPtr) -= m * here->BSIM4v7grbps); + (*(here->BSIM4v7SBbPtr) -= m * here->BSIM4v7grbsb); + (*(here->BSIM4v7SBsbPtr ) -= m * xcsbsb * s->real); + (*(here->BSIM4v7SBsbPtr +1) -= m * xcsbsb * s->imag); + (*(here->BSIM4v7SBsbPtr) += m * (here->BSIM4v7gbs + + here->BSIM4v7grbps + here->BSIM4v7grbsb)); - (*(here->BSIM4BdbPtr) -= m * here->BSIM4grbdb); - (*(here->BSIM4BbpPtr) -= m * here->BSIM4grbpb); - (*(here->BSIM4BsbPtr) -= m * here->BSIM4grbsb); - (*(here->BSIM4BbPtr) += m * (here->BSIM4grbsb + here->BSIM4grbdb - + here->BSIM4grbpb)); + (*(here->BSIM4v7BdbPtr) -= m * here->BSIM4v7grbdb); + (*(here->BSIM4v7BbpPtr) -= m * here->BSIM4v7grbpb); + (*(here->BSIM4v7BsbPtr) -= m * here->BSIM4v7grbsb); + (*(here->BSIM4v7BbPtr) += m * (here->BSIM4v7grbsb + here->BSIM4v7grbdb + + here->BSIM4v7grbpb)); } - if (here->BSIM4acnqsMod) - { *(here->BSIM4QqPtr ) += m * s->real * ScalingFactor; - *(here->BSIM4QqPtr +1) += m * s->imag * ScalingFactor; - *(here->BSIM4QgpPtr ) -= m * xcqgb * s->real; - *(here->BSIM4QgpPtr +1) -= m * xcqgb * s->imag; - *(here->BSIM4QdpPtr ) -= m * xcqdb * s->real; - *(here->BSIM4QdpPtr +1) -= m * xcqdb * s->imag; - *(here->BSIM4QbpPtr ) -= m * xcqbb * s->real; - *(here->BSIM4QbpPtr +1) -= m * xcqbb * s->imag; - *(here->BSIM4QspPtr ) -= m * xcqsb * s->real; - *(here->BSIM4QspPtr +1) -= m * xcqsb * s->imag; + if (here->BSIM4v7acnqsMod) + { *(here->BSIM4v7QqPtr ) += m * s->real * ScalingFactor; + *(here->BSIM4v7QqPtr +1) += m * s->imag * ScalingFactor; + *(here->BSIM4v7QgpPtr ) -= m * xcqgb * s->real; + *(here->BSIM4v7QgpPtr +1) -= m * xcqgb * s->imag; + *(here->BSIM4v7QdpPtr ) -= m * xcqdb * s->real; + *(here->BSIM4v7QdpPtr +1) -= m * xcqdb * s->imag; + *(here->BSIM4v7QbpPtr ) -= m * xcqbb * s->real; + *(here->BSIM4v7QbpPtr +1) -= m * xcqbb * s->imag; + *(here->BSIM4v7QspPtr ) -= m * xcqsb * s->real; + *(here->BSIM4v7QspPtr +1) -= m * xcqsb * s->imag; - *(here->BSIM4GPqPtr) -= m * here->BSIM4gtau; - *(here->BSIM4DPqPtr) += m * dxpart * here->BSIM4gtau; - *(here->BSIM4SPqPtr) += m * sxpart * here->BSIM4gtau; + *(here->BSIM4v7GPqPtr) -= m * here->BSIM4v7gtau; + *(here->BSIM4v7DPqPtr) += m * dxpart * here->BSIM4v7gtau; + *(here->BSIM4v7SPqPtr) += m * sxpart * here->BSIM4v7gtau; - *(here->BSIM4QqPtr) += m * here->BSIM4gtau; - *(here->BSIM4QgpPtr) += m * xgtg; - *(here->BSIM4QdpPtr) += m * xgtd; - *(here->BSIM4QbpPtr) += m * xgtb; - *(here->BSIM4QspPtr) += m * xgts; + *(here->BSIM4v7QqPtr) += m * here->BSIM4v7gtau; + *(here->BSIM4v7QgpPtr) += m * xgtg; + *(here->BSIM4v7QdpPtr) += m * xgtd; + *(here->BSIM4v7QbpPtr) += m * xgtb; + *(here->BSIM4v7QspPtr) += m * xgts; } } } diff --git a/src/spicelib/devices/bsim4v7/b4v7set.c b/src/spicelib/devices/bsim4v7/b4v7set.c index 96790106e..e34e8a93c 100644 --- a/src/spicelib/devices/bsim4v7/b4v7set.c +++ b/src/spicelib/devices/bsim4v7/b4v7set.c @@ -26,7 +26,7 @@ #include "ngspice/ftedefs.h" #include "ngspice/smpdefs.h" #include "ngspice/cktdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/const.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" @@ -44,14 +44,14 @@ #define Charge_q 1.60219e-19 int -BSIM4setup( +BSIM4v7setup( SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states) { -BSIM4model *model = (BSIM4model*)inModel; -BSIM4instance *here; +BSIM4v7model *model = (BSIM4v7model*)inModel; +BSIM4v7instance *here; int error; CKTnode *tmp; int noiseAnalGiven = 0, createNode; /* Criteria for new node creation */ @@ -60,7 +60,7 @@ JOB *job; #ifdef USE_OMP unsigned int idx, InstCount; -BSIM4instance **InstArray; +BSIM4v7instance **InstArray; #endif /* Search for a noise analysis request */ @@ -71,2274 +71,2274 @@ BSIM4instance **InstArray; } } - /* loop through all the BSIM4 device models */ - for( ; model != NULL; model = model->BSIM4nextModel ) + /* loop through all the BSIM4v7 device models */ + for( ; model != NULL; model = model->BSIM4v7nextModel ) { /* process defaults of model parameters */ - if (!model->BSIM4typeGiven) - model->BSIM4type = NMOS; + if (!model->BSIM4v7typeGiven) + model->BSIM4v7type = NMOS; - if (!model->BSIM4mobModGiven) - model->BSIM4mobMod = 0; - else if ((model->BSIM4mobMod != 0) && (model->BSIM4mobMod != 1) - && (model->BSIM4mobMod != 2)&& (model->BSIM4mobMod != 3)) - { model->BSIM4mobMod = 0; + if (!model->BSIM4v7mobModGiven) + model->BSIM4v7mobMod = 0; + else if ((model->BSIM4v7mobMod != 0) && (model->BSIM4v7mobMod != 1) + && (model->BSIM4v7mobMod != 2)&& (model->BSIM4v7mobMod != 3)) + { model->BSIM4v7mobMod = 0; printf("Warning: mobMod has been set to its default value: 0.\n"); } - if (!model->BSIM4binUnitGiven) - model->BSIM4binUnit = 1; - if (!model->BSIM4paramChkGiven) - model->BSIM4paramChk = 1; + if (!model->BSIM4v7binUnitGiven) + model->BSIM4v7binUnit = 1; + if (!model->BSIM4v7paramChkGiven) + model->BSIM4v7paramChk = 1; - if (!model->BSIM4dioModGiven) - model->BSIM4dioMod = 1; - else if ((model->BSIM4dioMod != 0) && (model->BSIM4dioMod != 1) - && (model->BSIM4dioMod != 2)) - { model->BSIM4dioMod = 1; + if (!model->BSIM4v7dioModGiven) + model->BSIM4v7dioMod = 1; + else if ((model->BSIM4v7dioMod != 0) && (model->BSIM4v7dioMod != 1) + && (model->BSIM4v7dioMod != 2)) + { model->BSIM4v7dioMod = 1; printf("Warning: dioMod has been set to its default value: 1.\n"); } - if (!model->BSIM4cvchargeModGiven) - model->BSIM4cvchargeMod = 0; - if (!model->BSIM4capModGiven) - model->BSIM4capMod = 2; - else if ((model->BSIM4capMod != 0) && (model->BSIM4capMod != 1) - && (model->BSIM4capMod != 2)) - { model->BSIM4capMod = 2; + if (!model->BSIM4v7cvchargeModGiven) + model->BSIM4v7cvchargeMod = 0; + if (!model->BSIM4v7capModGiven) + model->BSIM4v7capMod = 2; + else if ((model->BSIM4v7capMod != 0) && (model->BSIM4v7capMod != 1) + && (model->BSIM4v7capMod != 2)) + { model->BSIM4v7capMod = 2; printf("Warning: capMod has been set to its default value: 2.\n"); } - if (!model->BSIM4rdsModGiven) - model->BSIM4rdsMod = 0; - else if ((model->BSIM4rdsMod != 0) && (model->BSIM4rdsMod != 1)) - { model->BSIM4rdsMod = 0; + if (!model->BSIM4v7rdsModGiven) + model->BSIM4v7rdsMod = 0; + else if ((model->BSIM4v7rdsMod != 0) && (model->BSIM4v7rdsMod != 1)) + { model->BSIM4v7rdsMod = 0; printf("Warning: rdsMod has been set to its default value: 0.\n"); } - if (!model->BSIM4rbodyModGiven) - model->BSIM4rbodyMod = 0; - else if ((model->BSIM4rbodyMod != 0) && (model->BSIM4rbodyMod != 1) && (model->BSIM4rbodyMod != 2)) - { model->BSIM4rbodyMod = 0; + if (!model->BSIM4v7rbodyModGiven) + model->BSIM4v7rbodyMod = 0; + else if ((model->BSIM4v7rbodyMod != 0) && (model->BSIM4v7rbodyMod != 1) && (model->BSIM4v7rbodyMod != 2)) + { model->BSIM4v7rbodyMod = 0; printf("Warning: rbodyMod has been set to its default value: 0.\n"); } - if (!model->BSIM4rgateModGiven) - model->BSIM4rgateMod = 0; - else if ((model->BSIM4rgateMod != 0) && (model->BSIM4rgateMod != 1) - && (model->BSIM4rgateMod != 2) && (model->BSIM4rgateMod != 3)) - { model->BSIM4rgateMod = 0; + if (!model->BSIM4v7rgateModGiven) + model->BSIM4v7rgateMod = 0; + else if ((model->BSIM4v7rgateMod != 0) && (model->BSIM4v7rgateMod != 1) + && (model->BSIM4v7rgateMod != 2) && (model->BSIM4v7rgateMod != 3)) + { model->BSIM4v7rgateMod = 0; printf("Warning: rgateMod has been set to its default value: 0.\n"); } - if (!model->BSIM4perModGiven) - model->BSIM4perMod = 1; - else if ((model->BSIM4perMod != 0) && (model->BSIM4perMod != 1)) - { model->BSIM4perMod = 1; + if (!model->BSIM4v7perModGiven) + model->BSIM4v7perMod = 1; + else if ((model->BSIM4v7perMod != 0) && (model->BSIM4v7perMod != 1)) + { model->BSIM4v7perMod = 1; printf("Warning: perMod has been set to its default value: 1.\n"); } - if (!model->BSIM4geoModGiven) - model->BSIM4geoMod = 0; + if (!model->BSIM4v7geoModGiven) + model->BSIM4v7geoMod = 0; - if (!model->BSIM4rgeoModGiven) - model->BSIM4rgeoMod = 0; - else if ((model->BSIM4rgeoMod != 0) && (model->BSIM4rgeoMod != 1)) - { model->BSIM4rgeoMod = 1; + if (!model->BSIM4v7rgeoModGiven) + model->BSIM4v7rgeoMod = 0; + else if ((model->BSIM4v7rgeoMod != 0) && (model->BSIM4v7rgeoMod != 1)) + { model->BSIM4v7rgeoMod = 1; printf("Warning: rgeoMod has been set to its default value: 1.\n"); } - if (!model->BSIM4fnoiModGiven) - model->BSIM4fnoiMod = 1; - else if ((model->BSIM4fnoiMod != 0) && (model->BSIM4fnoiMod != 1)) - { model->BSIM4fnoiMod = 1; + if (!model->BSIM4v7fnoiModGiven) + model->BSIM4v7fnoiMod = 1; + else if ((model->BSIM4v7fnoiMod != 0) && (model->BSIM4v7fnoiMod != 1)) + { model->BSIM4v7fnoiMod = 1; printf("Warning: fnoiMod has been set to its default value: 1.\n"); } - if (!model->BSIM4tnoiModGiven) - model->BSIM4tnoiMod = 0; /* WDLiu: tnoiMod=1 needs to set internal S/D nodes */ - else if ((model->BSIM4tnoiMod != 0) && (model->BSIM4tnoiMod != 1) && (model->BSIM4tnoiMod != 2)) /* v4.7 */ - { model->BSIM4tnoiMod = 0; + if (!model->BSIM4v7tnoiModGiven) + model->BSIM4v7tnoiMod = 0; /* WDLiu: tnoiMod=1 needs to set internal S/D nodes */ + else if ((model->BSIM4v7tnoiMod != 0) && (model->BSIM4v7tnoiMod != 1) && (model->BSIM4v7tnoiMod != 2)) /* v4.7 */ + { model->BSIM4v7tnoiMod = 0; printf("Warning: tnoiMod has been set to its default value: 0.\n"); } - if (!model->BSIM4trnqsModGiven) - model->BSIM4trnqsMod = 0; - else if ((model->BSIM4trnqsMod != 0) && (model->BSIM4trnqsMod != 1)) - { model->BSIM4trnqsMod = 0; + if (!model->BSIM4v7trnqsModGiven) + model->BSIM4v7trnqsMod = 0; + else if ((model->BSIM4v7trnqsMod != 0) && (model->BSIM4v7trnqsMod != 1)) + { model->BSIM4v7trnqsMod = 0; printf("Warning: trnqsMod has been set to its default value: 0.\n"); } - if (!model->BSIM4acnqsModGiven) - model->BSIM4acnqsMod = 0; - else if ((model->BSIM4acnqsMod != 0) && (model->BSIM4acnqsMod != 1)) - { model->BSIM4acnqsMod = 0; + if (!model->BSIM4v7acnqsModGiven) + model->BSIM4v7acnqsMod = 0; + else if ((model->BSIM4v7acnqsMod != 0) && (model->BSIM4v7acnqsMod != 1)) + { model->BSIM4v7acnqsMod = 0; printf("Warning: acnqsMod has been set to its default value: 0.\n"); } - if (!model->BSIM4mtrlModGiven) - model->BSIM4mtrlMod = 0; - else if((model->BSIM4mtrlMod != 0) && (model->BSIM4mtrlMod != 1)) + if (!model->BSIM4v7mtrlModGiven) + model->BSIM4v7mtrlMod = 0; + else if((model->BSIM4v7mtrlMod != 0) && (model->BSIM4v7mtrlMod != 1)) { - model->BSIM4mtrlMod = 0; + model->BSIM4v7mtrlMod = 0; printf("Warning: mtrlMod has been set to its default value: 0.\n"); } - if (!model->BSIM4mtrlCompatModGiven) - model->BSIM4mtrlCompatMod = 0; - else if((model->BSIM4mtrlCompatMod != 0) && (model->BSIM4mtrlCompatMod != 1)) + if (!model->BSIM4v7mtrlCompatModGiven) + model->BSIM4v7mtrlCompatMod = 0; + else if((model->BSIM4v7mtrlCompatMod != 0) && (model->BSIM4v7mtrlCompatMod != 1)) { - model->BSIM4mtrlCompatMod = 0; + model->BSIM4v7mtrlCompatMod = 0; printf("Warning: mtrlCompatMod has been set to its default value: 0.\n"); } - if (!model->BSIM4igcModGiven) - model->BSIM4igcMod = 0; - else if ((model->BSIM4igcMod != 0) && (model->BSIM4igcMod != 1) - && (model->BSIM4igcMod != 2)) - { model->BSIM4igcMod = 0; + if (!model->BSIM4v7igcModGiven) + model->BSIM4v7igcMod = 0; + else if ((model->BSIM4v7igcMod != 0) && (model->BSIM4v7igcMod != 1) + && (model->BSIM4v7igcMod != 2)) + { model->BSIM4v7igcMod = 0; printf("Warning: igcMod has been set to its default value: 0.\n"); } - if (!model->BSIM4igbModGiven) - model->BSIM4igbMod = 0; - else if ((model->BSIM4igbMod != 0) && (model->BSIM4igbMod != 1)) - { model->BSIM4igbMod = 0; + if (!model->BSIM4v7igbModGiven) + model->BSIM4v7igbMod = 0; + else if ((model->BSIM4v7igbMod != 0) && (model->BSIM4v7igbMod != 1)) + { model->BSIM4v7igbMod = 0; printf("Warning: igbMod has been set to its default value: 0.\n"); } - if (!model->BSIM4tempModGiven) - model->BSIM4tempMod = 0; - else if ((model->BSIM4tempMod != 0) && (model->BSIM4tempMod != 1) - && (model->BSIM4tempMod != 2) && (model->BSIM4tempMod != 3)) - { model->BSIM4tempMod = 0; + if (!model->BSIM4v7tempModGiven) + model->BSIM4v7tempMod = 0; + else if ((model->BSIM4v7tempMod != 0) && (model->BSIM4v7tempMod != 1) + && (model->BSIM4v7tempMod != 2) && (model->BSIM4v7tempMod != 3)) + { model->BSIM4v7tempMod = 0; printf("Warning: tempMod has been set to its default value: 0.\n"); } - if (!model->BSIM4versionGiven) - model->BSIM4version = copy("4.7.0"); - if (!model->BSIM4toxrefGiven) - model->BSIM4toxref = 30.0e-10; - if (!model->BSIM4eotGiven) - model->BSIM4eot = 15.0e-10; - if (!model->BSIM4vddeotGiven) - model->BSIM4vddeot = (model->BSIM4type == NMOS) ? 1.5 : -1.5; - if (!model->BSIM4tempeotGiven) - model->BSIM4tempeot = 300.15; - if (!model->BSIM4leffeotGiven) - model->BSIM4leffeot = 1; - if (!model->BSIM4weffeotGiven) - model->BSIM4weffeot = 10; - if (!model->BSIM4adosGiven) - model->BSIM4ados = 1.0; - if (!model->BSIM4bdosGiven) - model->BSIM4bdos = 1.0; - if (!model->BSIM4toxeGiven) - model->BSIM4toxe = 30.0e-10; - if (!model->BSIM4toxpGiven) - model->BSIM4toxp = model->BSIM4toxe; - if (!model->BSIM4toxmGiven) - model->BSIM4toxm = model->BSIM4toxe; - if (!model->BSIM4dtoxGiven) - model->BSIM4dtox = 0.0; - if (!model->BSIM4epsroxGiven) - model->BSIM4epsrox = 3.9; + if (!model->BSIM4v7versionGiven) + model->BSIM4v7version = copy("4.7.0"); + if (!model->BSIM4v7toxrefGiven) + model->BSIM4v7toxref = 30.0e-10; + if (!model->BSIM4v7eotGiven) + model->BSIM4v7eot = 15.0e-10; + if (!model->BSIM4v7vddeotGiven) + model->BSIM4v7vddeot = (model->BSIM4v7type == NMOS) ? 1.5 : -1.5; + if (!model->BSIM4v7tempeotGiven) + model->BSIM4v7tempeot = 300.15; + if (!model->BSIM4v7leffeotGiven) + model->BSIM4v7leffeot = 1; + if (!model->BSIM4v7weffeotGiven) + model->BSIM4v7weffeot = 10; + if (!model->BSIM4v7adosGiven) + model->BSIM4v7ados = 1.0; + if (!model->BSIM4v7bdosGiven) + model->BSIM4v7bdos = 1.0; + if (!model->BSIM4v7toxeGiven) + model->BSIM4v7toxe = 30.0e-10; + if (!model->BSIM4v7toxpGiven) + model->BSIM4v7toxp = model->BSIM4v7toxe; + if (!model->BSIM4v7toxmGiven) + model->BSIM4v7toxm = model->BSIM4v7toxe; + if (!model->BSIM4v7dtoxGiven) + model->BSIM4v7dtox = 0.0; + if (!model->BSIM4v7epsroxGiven) + model->BSIM4v7epsrox = 3.9; - if (!model->BSIM4cdscGiven) - model->BSIM4cdsc = 2.4e-4; /* unit Q/V/m^2 */ - if (!model->BSIM4cdscbGiven) - model->BSIM4cdscb = 0.0; /* unit Q/V/m^2 */ - if (!model->BSIM4cdscdGiven) - model->BSIM4cdscd = 0.0; /* unit Q/V/m^2 */ - if (!model->BSIM4citGiven) - model->BSIM4cit = 0.0; /* unit Q/V/m^2 */ - if (!model->BSIM4nfactorGiven) - model->BSIM4nfactor = 1.0; - if (!model->BSIM4xjGiven) - model->BSIM4xj = .15e-6; - if (!model->BSIM4vsatGiven) - model->BSIM4vsat = 8.0e4; /* unit m/s */ - if (!model->BSIM4atGiven) - model->BSIM4at = 3.3e4; /* unit m/s */ - if (!model->BSIM4a0Given) - model->BSIM4a0 = 1.0; - if (!model->BSIM4agsGiven) - model->BSIM4ags = 0.0; - if (!model->BSIM4a1Given) - model->BSIM4a1 = 0.0; - if (!model->BSIM4a2Given) - model->BSIM4a2 = 1.0; - if (!model->BSIM4ketaGiven) - model->BSIM4keta = -0.047; /* unit / V */ - if (!model->BSIM4nsubGiven) - model->BSIM4nsub = 6.0e16; /* unit 1/cm3 */ - if (!model->BSIM4phigGiven) - model->BSIM4phig = 4.05; - if (!model->BSIM4epsrgateGiven) - model->BSIM4epsrgate = 11.7; - if (!model->BSIM4easubGiven) - model->BSIM4easub = 4.05; - if (!model->BSIM4epsrsubGiven) - model->BSIM4epsrsub = 11.7; - if (!model->BSIM4ni0subGiven) - model->BSIM4ni0sub = 1.45e10; /* unit 1/cm3 */ - if (!model->BSIM4bg0subGiven) - model->BSIM4bg0sub = 1.16; /* unit eV */ - if (!model->BSIM4tbgasubGiven) - model->BSIM4tbgasub = 7.02e-4; - if (!model->BSIM4tbgbsubGiven) - model->BSIM4tbgbsub = 1108.0; - if (!model->BSIM4ndepGiven) - model->BSIM4ndep = 1.7e17; /* unit 1/cm3 */ - if (!model->BSIM4nsdGiven) - model->BSIM4nsd = 1.0e20; /* unit 1/cm3 */ - if (!model->BSIM4phinGiven) - model->BSIM4phin = 0.0; /* unit V */ - if (!model->BSIM4ngateGiven) - model->BSIM4ngate = 0; /* unit 1/cm3 */ - if (!model->BSIM4vbmGiven) - model->BSIM4vbm = -3.0; - if (!model->BSIM4xtGiven) - model->BSIM4xt = 1.55e-7; - if (!model->BSIM4kt1Given) - model->BSIM4kt1 = -0.11; /* unit V */ - if (!model->BSIM4kt1lGiven) - model->BSIM4kt1l = 0.0; /* unit V*m */ - if (!model->BSIM4kt2Given) - model->BSIM4kt2 = 0.022; /* No unit */ - if (!model->BSIM4k3Given) - model->BSIM4k3 = 80.0; - if (!model->BSIM4k3bGiven) - model->BSIM4k3b = 0.0; - if (!model->BSIM4w0Given) - model->BSIM4w0 = 2.5e-6; - if (!model->BSIM4lpe0Given) - model->BSIM4lpe0 = 1.74e-7; - if (!model->BSIM4lpebGiven) - model->BSIM4lpeb = 0.0; - if (!model->BSIM4dvtp0Given) - model->BSIM4dvtp0 = 0.0; - if (!model->BSIM4dvtp1Given) - model->BSIM4dvtp1 = 0.0; - if (!model->BSIM4dvtp2Given) /* New DIBL/Rout */ - model->BSIM4dvtp2 = 0.0; - if (!model->BSIM4dvtp3Given) - model->BSIM4dvtp3 = 0.0; - if (!model->BSIM4dvtp4Given) - model->BSIM4dvtp4 = 0.0; - if (!model->BSIM4dvtp5Given) - model->BSIM4dvtp5 = 0.0; - if (!model->BSIM4dvt0Given) - model->BSIM4dvt0 = 2.2; - if (!model->BSIM4dvt1Given) - model->BSIM4dvt1 = 0.53; - if (!model->BSIM4dvt2Given) - model->BSIM4dvt2 = -0.032; /* unit 1 / V */ + if (!model->BSIM4v7cdscGiven) + model->BSIM4v7cdsc = 2.4e-4; /* unit Q/V/m^2 */ + if (!model->BSIM4v7cdscbGiven) + model->BSIM4v7cdscb = 0.0; /* unit Q/V/m^2 */ + if (!model->BSIM4v7cdscdGiven) + model->BSIM4v7cdscd = 0.0; /* unit Q/V/m^2 */ + if (!model->BSIM4v7citGiven) + model->BSIM4v7cit = 0.0; /* unit Q/V/m^2 */ + if (!model->BSIM4v7nfactorGiven) + model->BSIM4v7nfactor = 1.0; + if (!model->BSIM4v7xjGiven) + model->BSIM4v7xj = .15e-6; + if (!model->BSIM4v7vsatGiven) + model->BSIM4v7vsat = 8.0e4; /* unit m/s */ + if (!model->BSIM4v7atGiven) + model->BSIM4v7at = 3.3e4; /* unit m/s */ + if (!model->BSIM4v7a0Given) + model->BSIM4v7a0 = 1.0; + if (!model->BSIM4v7agsGiven) + model->BSIM4v7ags = 0.0; + if (!model->BSIM4v7a1Given) + model->BSIM4v7a1 = 0.0; + if (!model->BSIM4v7a2Given) + model->BSIM4v7a2 = 1.0; + if (!model->BSIM4v7ketaGiven) + model->BSIM4v7keta = -0.047; /* unit / V */ + if (!model->BSIM4v7nsubGiven) + model->BSIM4v7nsub = 6.0e16; /* unit 1/cm3 */ + if (!model->BSIM4v7phigGiven) + model->BSIM4v7phig = 4.05; + if (!model->BSIM4v7epsrgateGiven) + model->BSIM4v7epsrgate = 11.7; + if (!model->BSIM4v7easubGiven) + model->BSIM4v7easub = 4.05; + if (!model->BSIM4v7epsrsubGiven) + model->BSIM4v7epsrsub = 11.7; + if (!model->BSIM4v7ni0subGiven) + model->BSIM4v7ni0sub = 1.45e10; /* unit 1/cm3 */ + if (!model->BSIM4v7bg0subGiven) + model->BSIM4v7bg0sub = 1.16; /* unit eV */ + if (!model->BSIM4v7tbgasubGiven) + model->BSIM4v7tbgasub = 7.02e-4; + if (!model->BSIM4v7tbgbsubGiven) + model->BSIM4v7tbgbsub = 1108.0; + if (!model->BSIM4v7ndepGiven) + model->BSIM4v7ndep = 1.7e17; /* unit 1/cm3 */ + if (!model->BSIM4v7nsdGiven) + model->BSIM4v7nsd = 1.0e20; /* unit 1/cm3 */ + if (!model->BSIM4v7phinGiven) + model->BSIM4v7phin = 0.0; /* unit V */ + if (!model->BSIM4v7ngateGiven) + model->BSIM4v7ngate = 0; /* unit 1/cm3 */ + if (!model->BSIM4v7vbmGiven) + model->BSIM4v7vbm = -3.0; + if (!model->BSIM4v7xtGiven) + model->BSIM4v7xt = 1.55e-7; + if (!model->BSIM4v7kt1Given) + model->BSIM4v7kt1 = -0.11; /* unit V */ + if (!model->BSIM4v7kt1lGiven) + model->BSIM4v7kt1l = 0.0; /* unit V*m */ + if (!model->BSIM4v7kt2Given) + model->BSIM4v7kt2 = 0.022; /* No unit */ + if (!model->BSIM4v7k3Given) + model->BSIM4v7k3 = 80.0; + if (!model->BSIM4v7k3bGiven) + model->BSIM4v7k3b = 0.0; + if (!model->BSIM4v7w0Given) + model->BSIM4v7w0 = 2.5e-6; + if (!model->BSIM4v7lpe0Given) + model->BSIM4v7lpe0 = 1.74e-7; + if (!model->BSIM4v7lpebGiven) + model->BSIM4v7lpeb = 0.0; + if (!model->BSIM4v7dvtp0Given) + model->BSIM4v7dvtp0 = 0.0; + if (!model->BSIM4v7dvtp1Given) + model->BSIM4v7dvtp1 = 0.0; + if (!model->BSIM4v7dvtp2Given) /* New DIBL/Rout */ + model->BSIM4v7dvtp2 = 0.0; + if (!model->BSIM4v7dvtp3Given) + model->BSIM4v7dvtp3 = 0.0; + if (!model->BSIM4v7dvtp4Given) + model->BSIM4v7dvtp4 = 0.0; + if (!model->BSIM4v7dvtp5Given) + model->BSIM4v7dvtp5 = 0.0; + if (!model->BSIM4v7dvt0Given) + model->BSIM4v7dvt0 = 2.2; + if (!model->BSIM4v7dvt1Given) + model->BSIM4v7dvt1 = 0.53; + if (!model->BSIM4v7dvt2Given) + model->BSIM4v7dvt2 = -0.032; /* unit 1 / V */ - if (!model->BSIM4dvt0wGiven) - model->BSIM4dvt0w = 0.0; - if (!model->BSIM4dvt1wGiven) - model->BSIM4dvt1w = 5.3e6; - if (!model->BSIM4dvt2wGiven) - model->BSIM4dvt2w = -0.032; + if (!model->BSIM4v7dvt0wGiven) + model->BSIM4v7dvt0w = 0.0; + if (!model->BSIM4v7dvt1wGiven) + model->BSIM4v7dvt1w = 5.3e6; + if (!model->BSIM4v7dvt2wGiven) + model->BSIM4v7dvt2w = -0.032; - if (!model->BSIM4droutGiven) - model->BSIM4drout = 0.56; - if (!model->BSIM4dsubGiven) - model->BSIM4dsub = model->BSIM4drout; - if (!model->BSIM4vth0Given) - model->BSIM4vth0 = (model->BSIM4type == NMOS) ? 0.7 : -0.7; - if (!model->BSIM4vfbGiven) - model->BSIM4vfb = -1.0; - if (!model->BSIM4euGiven) - model->BSIM4eu = (model->BSIM4type == NMOS) ? 1.67 : 1.0; - if (!model->BSIM4ucsGiven) - model->BSIM4ucs = (model->BSIM4type == NMOS) ? 1.67 : 1.0; - if (!model->BSIM4uaGiven) - model->BSIM4ua = ((model->BSIM4mobMod == 2)) ? 1.0e-15 : 1.0e-9; /* unit m/V */ - if (!model->BSIM4ua1Given) - model->BSIM4ua1 = 1.0e-9; /* unit m/V */ - if (!model->BSIM4ubGiven) - model->BSIM4ub = 1.0e-19; /* unit (m/V)**2 */ - if (!model->BSIM4ub1Given) - model->BSIM4ub1 = -1.0e-18; /* unit (m/V)**2 */ - if (!model->BSIM4ucGiven) - model->BSIM4uc = (model->BSIM4mobMod == 1) ? -0.0465 : -0.0465e-9; - if (!model->BSIM4uc1Given) - model->BSIM4uc1 = (model->BSIM4mobMod == 1) ? -0.056 : -0.056e-9; - if (!model->BSIM4udGiven) - model->BSIM4ud = 0.0; /* unit m**(-2) */ - if (!model->BSIM4ud1Given) - model->BSIM4ud1 = 0.0; - if (!model->BSIM4upGiven) - model->BSIM4up = 0.0; - if (!model->BSIM4lpGiven) - model->BSIM4lp = 1.0e-8; - if (!model->BSIM4u0Given) - model->BSIM4u0 = (model->BSIM4type == NMOS) ? 0.067 : 0.025; - if (!model->BSIM4uteGiven) - model->BSIM4ute = -1.5; - if (!model->BSIM4ucsteGiven) - model->BSIM4ucste = -4.775e-3; - if (!model->BSIM4voffGiven) - model->BSIM4voff = -0.08; - if (!model->BSIM4vofflGiven) - model->BSIM4voffl = 0.0; - if (!model->BSIM4voffcvlGiven) - model->BSIM4voffcvl = 0.0; - if (!model->BSIM4minvGiven) - model->BSIM4minv = 0.0; - if (!model->BSIM4minvcvGiven) - model->BSIM4minvcv = 0.0; - if (!model->BSIM4fproutGiven) - model->BSIM4fprout = 0.0; - if (!model->BSIM4pditsGiven) - model->BSIM4pdits = 0.0; - if (!model->BSIM4pditsdGiven) - model->BSIM4pditsd = 0.0; - if (!model->BSIM4pditslGiven) - model->BSIM4pditsl = 0.0; - if (!model->BSIM4deltaGiven) - model->BSIM4delta = 0.01; - if (!model->BSIM4rdswminGiven) - model->BSIM4rdswmin = 0.0; - if (!model->BSIM4rdwminGiven) - model->BSIM4rdwmin = 0.0; - if (!model->BSIM4rswminGiven) - model->BSIM4rswmin = 0.0; - if (!model->BSIM4rdswGiven) - model->BSIM4rdsw = 200.0; /* in ohm*um */ - if (!model->BSIM4rdwGiven) - model->BSIM4rdw = 100.0; - if (!model->BSIM4rswGiven) - model->BSIM4rsw = 100.0; - if (!model->BSIM4prwgGiven) - model->BSIM4prwg = 1.0; /* in 1/V */ - if (!model->BSIM4prwbGiven) - model->BSIM4prwb = 0.0; - if (!model->BSIM4prtGiven) - if (!model->BSIM4prtGiven) - model->BSIM4prt = 0.0; - if (!model->BSIM4eta0Given) - model->BSIM4eta0 = 0.08; /* no unit */ - if (!model->BSIM4etabGiven) - model->BSIM4etab = -0.07; /* unit 1/V */ - if (!model->BSIM4pclmGiven) - model->BSIM4pclm = 1.3; /* no unit */ - if (!model->BSIM4pdibl1Given) - model->BSIM4pdibl1 = 0.39; /* no unit */ - if (!model->BSIM4pdibl2Given) - model->BSIM4pdibl2 = 0.0086; /* no unit */ - if (!model->BSIM4pdiblbGiven) - model->BSIM4pdiblb = 0.0; /* 1/V */ - if (!model->BSIM4pscbe1Given) - model->BSIM4pscbe1 = 4.24e8; - if (!model->BSIM4pscbe2Given) - model->BSIM4pscbe2 = 1.0e-5; - if (!model->BSIM4pvagGiven) - model->BSIM4pvag = 0.0; - if (!model->BSIM4wrGiven) - model->BSIM4wr = 1.0; - if (!model->BSIM4dwgGiven) - model->BSIM4dwg = 0.0; - if (!model->BSIM4dwbGiven) - model->BSIM4dwb = 0.0; - if (!model->BSIM4b0Given) - model->BSIM4b0 = 0.0; - if (!model->BSIM4b1Given) - model->BSIM4b1 = 0.0; - if (!model->BSIM4alpha0Given) - model->BSIM4alpha0 = 0.0; - if (!model->BSIM4alpha1Given) - model->BSIM4alpha1 = 0.0; - if (!model->BSIM4beta0Given) - model->BSIM4beta0 = 0.0; - if (!model->BSIM4gidlModGiven) - model->BSIM4gidlMod = 0; /* v4.7 New GIDL/GISL */ - if (!model->BSIM4agidlGiven) - model->BSIM4agidl = 0.0; - if (!model->BSIM4bgidlGiven) - model->BSIM4bgidl = 2.3e9; /* V/m */ - if (!model->BSIM4cgidlGiven) - model->BSIM4cgidl = 0.5; /* V^3 */ - if (!model->BSIM4egidlGiven) - model->BSIM4egidl = 0.8; /* V */ - if (!model->BSIM4rgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4rgidl = 1.0; - if (!model->BSIM4kgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4kgidl = 0.0; - if (!model->BSIM4fgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4fgidl = 0.0; - if (!model->BSIM4agislGiven) + if (!model->BSIM4v7droutGiven) + model->BSIM4v7drout = 0.56; + if (!model->BSIM4v7dsubGiven) + model->BSIM4v7dsub = model->BSIM4v7drout; + if (!model->BSIM4v7vth0Given) + model->BSIM4v7vth0 = (model->BSIM4v7type == NMOS) ? 0.7 : -0.7; + if (!model->BSIM4v7vfbGiven) + model->BSIM4v7vfb = -1.0; + if (!model->BSIM4v7euGiven) + model->BSIM4v7eu = (model->BSIM4v7type == NMOS) ? 1.67 : 1.0; + if (!model->BSIM4v7ucsGiven) + model->BSIM4v7ucs = (model->BSIM4v7type == NMOS) ? 1.67 : 1.0; + if (!model->BSIM4v7uaGiven) + model->BSIM4v7ua = ((model->BSIM4v7mobMod == 2)) ? 1.0e-15 : 1.0e-9; /* unit m/V */ + if (!model->BSIM4v7ua1Given) + model->BSIM4v7ua1 = 1.0e-9; /* unit m/V */ + if (!model->BSIM4v7ubGiven) + model->BSIM4v7ub = 1.0e-19; /* unit (m/V)**2 */ + if (!model->BSIM4v7ub1Given) + model->BSIM4v7ub1 = -1.0e-18; /* unit (m/V)**2 */ + if (!model->BSIM4v7ucGiven) + model->BSIM4v7uc = (model->BSIM4v7mobMod == 1) ? -0.0465 : -0.0465e-9; + if (!model->BSIM4v7uc1Given) + model->BSIM4v7uc1 = (model->BSIM4v7mobMod == 1) ? -0.056 : -0.056e-9; + if (!model->BSIM4v7udGiven) + model->BSIM4v7ud = 0.0; /* unit m**(-2) */ + if (!model->BSIM4v7ud1Given) + model->BSIM4v7ud1 = 0.0; + if (!model->BSIM4v7upGiven) + model->BSIM4v7up = 0.0; + if (!model->BSIM4v7lpGiven) + model->BSIM4v7lp = 1.0e-8; + if (!model->BSIM4v7u0Given) + model->BSIM4v7u0 = (model->BSIM4v7type == NMOS) ? 0.067 : 0.025; + if (!model->BSIM4v7uteGiven) + model->BSIM4v7ute = -1.5; + if (!model->BSIM4v7ucsteGiven) + model->BSIM4v7ucste = -4.775e-3; + if (!model->BSIM4v7voffGiven) + model->BSIM4v7voff = -0.08; + if (!model->BSIM4v7vofflGiven) + model->BSIM4v7voffl = 0.0; + if (!model->BSIM4v7voffcvlGiven) + model->BSIM4v7voffcvl = 0.0; + if (!model->BSIM4v7minvGiven) + model->BSIM4v7minv = 0.0; + if (!model->BSIM4v7minvcvGiven) + model->BSIM4v7minvcv = 0.0; + if (!model->BSIM4v7fproutGiven) + model->BSIM4v7fprout = 0.0; + if (!model->BSIM4v7pditsGiven) + model->BSIM4v7pdits = 0.0; + if (!model->BSIM4v7pditsdGiven) + model->BSIM4v7pditsd = 0.0; + if (!model->BSIM4v7pditslGiven) + model->BSIM4v7pditsl = 0.0; + if (!model->BSIM4v7deltaGiven) + model->BSIM4v7delta = 0.01; + if (!model->BSIM4v7rdswminGiven) + model->BSIM4v7rdswmin = 0.0; + if (!model->BSIM4v7rdwminGiven) + model->BSIM4v7rdwmin = 0.0; + if (!model->BSIM4v7rswminGiven) + model->BSIM4v7rswmin = 0.0; + if (!model->BSIM4v7rdswGiven) + model->BSIM4v7rdsw = 200.0; /* in ohm*um */ + if (!model->BSIM4v7rdwGiven) + model->BSIM4v7rdw = 100.0; + if (!model->BSIM4v7rswGiven) + model->BSIM4v7rsw = 100.0; + if (!model->BSIM4v7prwgGiven) + model->BSIM4v7prwg = 1.0; /* in 1/V */ + if (!model->BSIM4v7prwbGiven) + model->BSIM4v7prwb = 0.0; + if (!model->BSIM4v7prtGiven) + if (!model->BSIM4v7prtGiven) + model->BSIM4v7prt = 0.0; + if (!model->BSIM4v7eta0Given) + model->BSIM4v7eta0 = 0.08; /* no unit */ + if (!model->BSIM4v7etabGiven) + model->BSIM4v7etab = -0.07; /* unit 1/V */ + if (!model->BSIM4v7pclmGiven) + model->BSIM4v7pclm = 1.3; /* no unit */ + if (!model->BSIM4v7pdibl1Given) + model->BSIM4v7pdibl1 = 0.39; /* no unit */ + if (!model->BSIM4v7pdibl2Given) + model->BSIM4v7pdibl2 = 0.0086; /* no unit */ + if (!model->BSIM4v7pdiblbGiven) + model->BSIM4v7pdiblb = 0.0; /* 1/V */ + if (!model->BSIM4v7pscbe1Given) + model->BSIM4v7pscbe1 = 4.24e8; + if (!model->BSIM4v7pscbe2Given) + model->BSIM4v7pscbe2 = 1.0e-5; + if (!model->BSIM4v7pvagGiven) + model->BSIM4v7pvag = 0.0; + if (!model->BSIM4v7wrGiven) + model->BSIM4v7wr = 1.0; + if (!model->BSIM4v7dwgGiven) + model->BSIM4v7dwg = 0.0; + if (!model->BSIM4v7dwbGiven) + model->BSIM4v7dwb = 0.0; + if (!model->BSIM4v7b0Given) + model->BSIM4v7b0 = 0.0; + if (!model->BSIM4v7b1Given) + model->BSIM4v7b1 = 0.0; + if (!model->BSIM4v7alpha0Given) + model->BSIM4v7alpha0 = 0.0; + if (!model->BSIM4v7alpha1Given) + model->BSIM4v7alpha1 = 0.0; + if (!model->BSIM4v7beta0Given) + model->BSIM4v7beta0 = 0.0; + if (!model->BSIM4v7gidlModGiven) + model->BSIM4v7gidlMod = 0; /* v4.7 New GIDL/GISL */ + if (!model->BSIM4v7agidlGiven) + model->BSIM4v7agidl = 0.0; + if (!model->BSIM4v7bgidlGiven) + model->BSIM4v7bgidl = 2.3e9; /* V/m */ + if (!model->BSIM4v7cgidlGiven) + model->BSIM4v7cgidl = 0.5; /* V^3 */ + if (!model->BSIM4v7egidlGiven) + model->BSIM4v7egidl = 0.8; /* V */ + if (!model->BSIM4v7rgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7rgidl = 1.0; + if (!model->BSIM4v7kgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7kgidl = 0.0; + if (!model->BSIM4v7fgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7fgidl = 0.0; + if (!model->BSIM4v7agislGiven) { - if (model->BSIM4agidlGiven) - model->BSIM4agisl = model->BSIM4agidl; + if (model->BSIM4v7agidlGiven) + model->BSIM4v7agisl = model->BSIM4v7agidl; else - model->BSIM4agisl = 0.0; + model->BSIM4v7agisl = 0.0; } - if (!model->BSIM4bgislGiven) + if (!model->BSIM4v7bgislGiven) { - if (model->BSIM4bgidlGiven) - model->BSIM4bgisl = model->BSIM4bgidl; + if (model->BSIM4v7bgidlGiven) + model->BSIM4v7bgisl = model->BSIM4v7bgidl; else - model->BSIM4bgisl = 2.3e9; /* V/m */ + model->BSIM4v7bgisl = 2.3e9; /* V/m */ } - if (!model->BSIM4cgislGiven) + if (!model->BSIM4v7cgislGiven) { - if (model->BSIM4cgidlGiven) - model->BSIM4cgisl = model->BSIM4cgidl; + if (model->BSIM4v7cgidlGiven) + model->BSIM4v7cgisl = model->BSIM4v7cgidl; else - model->BSIM4cgisl = 0.5; /* V^3 */ + model->BSIM4v7cgisl = 0.5; /* V^3 */ } - if (!model->BSIM4egislGiven) + if (!model->BSIM4v7egislGiven) { - if (model->BSIM4egidlGiven) - model->BSIM4egisl = model->BSIM4egidl; + if (model->BSIM4v7egidlGiven) + model->BSIM4v7egisl = model->BSIM4v7egidl; else - model->BSIM4egisl = 0.8; /* V */ + model->BSIM4v7egisl = 0.8; /* V */ } - if (!model->BSIM4rgislGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4rgisl = model->BSIM4rgidl; - if (!model->BSIM4kgislGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4kgisl = model->BSIM4kgidl; - if (!model->BSIM4fgislGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4fgisl = model->BSIM4fgidl; - if (!model->BSIM4aigcGiven) - model->BSIM4aigc = (model->BSIM4type == NMOS) ? 1.36e-2 : 9.80e-3; - if (!model->BSIM4bigcGiven) - model->BSIM4bigc = (model->BSIM4type == NMOS) ? 1.71e-3 : 7.59e-4; - if (!model->BSIM4cigcGiven) - model->BSIM4cigc = (model->BSIM4type == NMOS) ? 0.075 : 0.03; - if (model->BSIM4aigsdGiven) + if (!model->BSIM4v7rgislGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7rgisl = model->BSIM4v7rgidl; + if (!model->BSIM4v7kgislGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7kgisl = model->BSIM4v7kgidl; + if (!model->BSIM4v7fgislGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7fgisl = model->BSIM4v7fgidl; + if (!model->BSIM4v7aigcGiven) + model->BSIM4v7aigc = (model->BSIM4v7type == NMOS) ? 1.36e-2 : 9.80e-3; + if (!model->BSIM4v7bigcGiven) + model->BSIM4v7bigc = (model->BSIM4v7type == NMOS) ? 1.71e-3 : 7.59e-4; + if (!model->BSIM4v7cigcGiven) + model->BSIM4v7cigc = (model->BSIM4v7type == NMOS) ? 0.075 : 0.03; + if (model->BSIM4v7aigsdGiven) { - model->BSIM4aigs = model->BSIM4aigd = model->BSIM4aigsd; + model->BSIM4v7aigs = model->BSIM4v7aigd = model->BSIM4v7aigsd; } else { - model->BSIM4aigsd = (model->BSIM4type == NMOS) ? 1.36e-2 : 9.80e-3; - if (!model->BSIM4aigsGiven) - model->BSIM4aigs = (model->BSIM4type == NMOS) ? 1.36e-2 : 9.80e-3; - if (!model->BSIM4aigdGiven) - model->BSIM4aigd = (model->BSIM4type == NMOS) ? 1.36e-2 : 9.80e-3; + model->BSIM4v7aigsd = (model->BSIM4v7type == NMOS) ? 1.36e-2 : 9.80e-3; + if (!model->BSIM4v7aigsGiven) + model->BSIM4v7aigs = (model->BSIM4v7type == NMOS) ? 1.36e-2 : 9.80e-3; + if (!model->BSIM4v7aigdGiven) + model->BSIM4v7aigd = (model->BSIM4v7type == NMOS) ? 1.36e-2 : 9.80e-3; } - if (model->BSIM4bigsdGiven) + if (model->BSIM4v7bigsdGiven) { - model->BSIM4bigs = model->BSIM4bigd = model->BSIM4bigsd; + model->BSIM4v7bigs = model->BSIM4v7bigd = model->BSIM4v7bigsd; } else { - model->BSIM4bigsd = (model->BSIM4type == NMOS) ? 1.71e-3 : 7.59e-4; - if (!model->BSIM4bigsGiven) - model->BSIM4bigs = (model->BSIM4type == NMOS) ? 1.71e-3 : 7.59e-4; - if (!model->BSIM4bigdGiven) - model->BSIM4bigd = (model->BSIM4type == NMOS) ? 1.71e-3 : 7.59e-4; + model->BSIM4v7bigsd = (model->BSIM4v7type == NMOS) ? 1.71e-3 : 7.59e-4; + if (!model->BSIM4v7bigsGiven) + model->BSIM4v7bigs = (model->BSIM4v7type == NMOS) ? 1.71e-3 : 7.59e-4; + if (!model->BSIM4v7bigdGiven) + model->BSIM4v7bigd = (model->BSIM4v7type == NMOS) ? 1.71e-3 : 7.59e-4; } - if (model->BSIM4cigsdGiven) + if (model->BSIM4v7cigsdGiven) { - model->BSIM4cigs = model->BSIM4cigd = model->BSIM4cigsd; + model->BSIM4v7cigs = model->BSIM4v7cigd = model->BSIM4v7cigsd; } else { - model->BSIM4cigsd = (model->BSIM4type == NMOS) ? 0.075 : 0.03; - if (!model->BSIM4cigsGiven) - model->BSIM4cigs = (model->BSIM4type == NMOS) ? 0.075 : 0.03; - if (!model->BSIM4cigdGiven) - model->BSIM4cigd = (model->BSIM4type == NMOS) ? 0.075 : 0.03; + model->BSIM4v7cigsd = (model->BSIM4v7type == NMOS) ? 0.075 : 0.03; + if (!model->BSIM4v7cigsGiven) + model->BSIM4v7cigs = (model->BSIM4v7type == NMOS) ? 0.075 : 0.03; + if (!model->BSIM4v7cigdGiven) + model->BSIM4v7cigd = (model->BSIM4v7type == NMOS) ? 0.075 : 0.03; } - if (!model->BSIM4aigbaccGiven) - model->BSIM4aigbacc = 1.36e-2; - if (!model->BSIM4bigbaccGiven) - model->BSIM4bigbacc = 1.71e-3; - if (!model->BSIM4cigbaccGiven) - model->BSIM4cigbacc = 0.075; - if (!model->BSIM4aigbinvGiven) - model->BSIM4aigbinv = 1.11e-2; - if (!model->BSIM4bigbinvGiven) - model->BSIM4bigbinv = 9.49e-4; - if (!model->BSIM4cigbinvGiven) - model->BSIM4cigbinv = 0.006; - if (!model->BSIM4nigcGiven) - model->BSIM4nigc = 1.0; - if (!model->BSIM4nigbinvGiven) - model->BSIM4nigbinv = 3.0; - if (!model->BSIM4nigbaccGiven) - model->BSIM4nigbacc = 1.0; - if (!model->BSIM4ntoxGiven) - model->BSIM4ntox = 1.0; - if (!model->BSIM4eigbinvGiven) - model->BSIM4eigbinv = 1.1; - if (!model->BSIM4pigcdGiven) - model->BSIM4pigcd = 1.0; - if (!model->BSIM4poxedgeGiven) - model->BSIM4poxedge = 1.0; - if (!model->BSIM4xrcrg1Given) - model->BSIM4xrcrg1 = 12.0; - if (!model->BSIM4xrcrg2Given) - model->BSIM4xrcrg2 = 1.0; - if (!model->BSIM4ijthsfwdGiven) - model->BSIM4ijthsfwd = 0.1; /* unit A */ - if (!model->BSIM4ijthdfwdGiven) - model->BSIM4ijthdfwd = model->BSIM4ijthsfwd; - if (!model->BSIM4ijthsrevGiven) - model->BSIM4ijthsrev = 0.1; /* unit A */ - if (!model->BSIM4ijthdrevGiven) - model->BSIM4ijthdrev = model->BSIM4ijthsrev; - if (!model->BSIM4tnoiaGiven) - model->BSIM4tnoia = 1.5; - if (!model->BSIM4tnoibGiven) - model->BSIM4tnoib = 3.5; - if (!model->BSIM4tnoicGiven) - model->BSIM4tnoic = 0.0; - if (!model->BSIM4rnoiaGiven) - model->BSIM4rnoia = 0.577; - if (!model->BSIM4rnoibGiven) - model->BSIM4rnoib = 0.5164; - if (!model->BSIM4rnoicGiven) - model->BSIM4rnoic = 0.395; - if (!model->BSIM4ntnoiGiven) - model->BSIM4ntnoi = 1.0; - if (!model->BSIM4lambdaGiven) - model->BSIM4lambda = 0.0; - if (!model->BSIM4vtlGiven) - model->BSIM4vtl = 2.0e5; /* unit m/s */ - if (!model->BSIM4xnGiven) - model->BSIM4xn = 3.0; - if (!model->BSIM4lcGiven) - model->BSIM4lc = 5.0e-9; - if (!model->BSIM4vfbsdoffGiven) - model->BSIM4vfbsdoff = 0.0; /* unit v */ - if (!model->BSIM4tvfbsdoffGiven) - model->BSIM4tvfbsdoff = 0.0; - if (!model->BSIM4tvoffGiven) - model->BSIM4tvoff = 0.0; - if (!model->BSIM4tnfactorGiven) /* v4.7 temp dep of leakage current */ - model->BSIM4tnfactor = 0.0; - if (!model->BSIM4teta0Given) /* v4.7 temp dep of leakage current */ - model->BSIM4teta0 = 0.0; - if (!model->BSIM4tvoffcvGiven) /* v4.7 temp dep of leakage current */ - model->BSIM4tvoffcv = 0.0; + if (!model->BSIM4v7aigbaccGiven) + model->BSIM4v7aigbacc = 1.36e-2; + if (!model->BSIM4v7bigbaccGiven) + model->BSIM4v7bigbacc = 1.71e-3; + if (!model->BSIM4v7cigbaccGiven) + model->BSIM4v7cigbacc = 0.075; + if (!model->BSIM4v7aigbinvGiven) + model->BSIM4v7aigbinv = 1.11e-2; + if (!model->BSIM4v7bigbinvGiven) + model->BSIM4v7bigbinv = 9.49e-4; + if (!model->BSIM4v7cigbinvGiven) + model->BSIM4v7cigbinv = 0.006; + if (!model->BSIM4v7nigcGiven) + model->BSIM4v7nigc = 1.0; + if (!model->BSIM4v7nigbinvGiven) + model->BSIM4v7nigbinv = 3.0; + if (!model->BSIM4v7nigbaccGiven) + model->BSIM4v7nigbacc = 1.0; + if (!model->BSIM4v7ntoxGiven) + model->BSIM4v7ntox = 1.0; + if (!model->BSIM4v7eigbinvGiven) + model->BSIM4v7eigbinv = 1.1; + if (!model->BSIM4v7pigcdGiven) + model->BSIM4v7pigcd = 1.0; + if (!model->BSIM4v7poxedgeGiven) + model->BSIM4v7poxedge = 1.0; + if (!model->BSIM4v7xrcrg1Given) + model->BSIM4v7xrcrg1 = 12.0; + if (!model->BSIM4v7xrcrg2Given) + model->BSIM4v7xrcrg2 = 1.0; + if (!model->BSIM4v7ijthsfwdGiven) + model->BSIM4v7ijthsfwd = 0.1; /* unit A */ + if (!model->BSIM4v7ijthdfwdGiven) + model->BSIM4v7ijthdfwd = model->BSIM4v7ijthsfwd; + if (!model->BSIM4v7ijthsrevGiven) + model->BSIM4v7ijthsrev = 0.1; /* unit A */ + if (!model->BSIM4v7ijthdrevGiven) + model->BSIM4v7ijthdrev = model->BSIM4v7ijthsrev; + if (!model->BSIM4v7tnoiaGiven) + model->BSIM4v7tnoia = 1.5; + if (!model->BSIM4v7tnoibGiven) + model->BSIM4v7tnoib = 3.5; + if (!model->BSIM4v7tnoicGiven) + model->BSIM4v7tnoic = 0.0; + if (!model->BSIM4v7rnoiaGiven) + model->BSIM4v7rnoia = 0.577; + if (!model->BSIM4v7rnoibGiven) + model->BSIM4v7rnoib = 0.5164; + if (!model->BSIM4v7rnoicGiven) + model->BSIM4v7rnoic = 0.395; + if (!model->BSIM4v7ntnoiGiven) + model->BSIM4v7ntnoi = 1.0; + if (!model->BSIM4v7lambdaGiven) + model->BSIM4v7lambda = 0.0; + if (!model->BSIM4v7vtlGiven) + model->BSIM4v7vtl = 2.0e5; /* unit m/s */ + if (!model->BSIM4v7xnGiven) + model->BSIM4v7xn = 3.0; + if (!model->BSIM4v7lcGiven) + model->BSIM4v7lc = 5.0e-9; + if (!model->BSIM4v7vfbsdoffGiven) + model->BSIM4v7vfbsdoff = 0.0; /* unit v */ + if (!model->BSIM4v7tvfbsdoffGiven) + model->BSIM4v7tvfbsdoff = 0.0; + if (!model->BSIM4v7tvoffGiven) + model->BSIM4v7tvoff = 0.0; + if (!model->BSIM4v7tnfactorGiven) /* v4.7 temp dep of leakage current */ + model->BSIM4v7tnfactor = 0.0; + if (!model->BSIM4v7teta0Given) /* v4.7 temp dep of leakage current */ + model->BSIM4v7teta0 = 0.0; + if (!model->BSIM4v7tvoffcvGiven) /* v4.7 temp dep of leakage current */ + model->BSIM4v7tvoffcv = 0.0; - if (!model->BSIM4lintnoiGiven) - model->BSIM4lintnoi = 0.0; /* unit m */ + if (!model->BSIM4v7lintnoiGiven) + model->BSIM4v7lintnoi = 0.0; /* unit m */ - if (!model->BSIM4xjbvsGiven) - model->BSIM4xjbvs = 1.0; /* no unit */ - if (!model->BSIM4xjbvdGiven) - model->BSIM4xjbvd = model->BSIM4xjbvs; - if (!model->BSIM4bvsGiven) - model->BSIM4bvs = 10.0; /* V */ - if (!model->BSIM4bvdGiven) - model->BSIM4bvd = model->BSIM4bvs; + if (!model->BSIM4v7xjbvsGiven) + model->BSIM4v7xjbvs = 1.0; /* no unit */ + if (!model->BSIM4v7xjbvdGiven) + model->BSIM4v7xjbvd = model->BSIM4v7xjbvs; + if (!model->BSIM4v7bvsGiven) + model->BSIM4v7bvs = 10.0; /* V */ + if (!model->BSIM4v7bvdGiven) + model->BSIM4v7bvd = model->BSIM4v7bvs; - if (!model->BSIM4gbminGiven) - model->BSIM4gbmin = 1.0e-12; /* in mho */ - if (!model->BSIM4rbdbGiven) - model->BSIM4rbdb = 50.0; /* in ohm */ - if (!model->BSIM4rbpbGiven) - model->BSIM4rbpb = 50.0; - if (!model->BSIM4rbsbGiven) - model->BSIM4rbsb = 50.0; - if (!model->BSIM4rbpsGiven) - model->BSIM4rbps = 50.0; - if (!model->BSIM4rbpdGiven) - model->BSIM4rbpd = 50.0; + if (!model->BSIM4v7gbminGiven) + model->BSIM4v7gbmin = 1.0e-12; /* in mho */ + if (!model->BSIM4v7rbdbGiven) + model->BSIM4v7rbdb = 50.0; /* in ohm */ + if (!model->BSIM4v7rbpbGiven) + model->BSIM4v7rbpb = 50.0; + if (!model->BSIM4v7rbsbGiven) + model->BSIM4v7rbsb = 50.0; + if (!model->BSIM4v7rbpsGiven) + model->BSIM4v7rbps = 50.0; + if (!model->BSIM4v7rbpdGiven) + model->BSIM4v7rbpd = 50.0; - if (!model->BSIM4rbps0Given) - model->BSIM4rbps0 = 50.0; - if (!model->BSIM4rbpslGiven) - model->BSIM4rbpsl = 0.0; - if (!model->BSIM4rbpswGiven) - model->BSIM4rbpsw = 0.0; - if (!model->BSIM4rbpsnfGiven) - model->BSIM4rbpsnf = 0.0; + if (!model->BSIM4v7rbps0Given) + model->BSIM4v7rbps0 = 50.0; + if (!model->BSIM4v7rbpslGiven) + model->BSIM4v7rbpsl = 0.0; + if (!model->BSIM4v7rbpswGiven) + model->BSIM4v7rbpsw = 0.0; + if (!model->BSIM4v7rbpsnfGiven) + model->BSIM4v7rbpsnf = 0.0; - if (!model->BSIM4rbpd0Given) - model->BSIM4rbpd0 = 50.0; - if (!model->BSIM4rbpdlGiven) - model->BSIM4rbpdl = 0.0; - if (!model->BSIM4rbpdwGiven) - model->BSIM4rbpdw = 0.0; - if (!model->BSIM4rbpdnfGiven) - model->BSIM4rbpdnf = 0.0; + if (!model->BSIM4v7rbpd0Given) + model->BSIM4v7rbpd0 = 50.0; + if (!model->BSIM4v7rbpdlGiven) + model->BSIM4v7rbpdl = 0.0; + if (!model->BSIM4v7rbpdwGiven) + model->BSIM4v7rbpdw = 0.0; + if (!model->BSIM4v7rbpdnfGiven) + model->BSIM4v7rbpdnf = 0.0; - if (!model->BSIM4rbpbx0Given) - model->BSIM4rbpbx0 = 100.0; - if (!model->BSIM4rbpbxlGiven) - model->BSIM4rbpbxl = 0.0; - if (!model->BSIM4rbpbxwGiven) - model->BSIM4rbpbxw = 0.0; - if (!model->BSIM4rbpbxnfGiven) - model->BSIM4rbpbxnf = 0.0; - if (!model->BSIM4rbpby0Given) - model->BSIM4rbpby0 = 100.0; - if (!model->BSIM4rbpbylGiven) - model->BSIM4rbpbyl = 0.0; - if (!model->BSIM4rbpbywGiven) - model->BSIM4rbpbyw = 0.0; - if (!model->BSIM4rbpbynfGiven) - model->BSIM4rbpbynf = 0.0; + if (!model->BSIM4v7rbpbx0Given) + model->BSIM4v7rbpbx0 = 100.0; + if (!model->BSIM4v7rbpbxlGiven) + model->BSIM4v7rbpbxl = 0.0; + if (!model->BSIM4v7rbpbxwGiven) + model->BSIM4v7rbpbxw = 0.0; + if (!model->BSIM4v7rbpbxnfGiven) + model->BSIM4v7rbpbxnf = 0.0; + if (!model->BSIM4v7rbpby0Given) + model->BSIM4v7rbpby0 = 100.0; + if (!model->BSIM4v7rbpbylGiven) + model->BSIM4v7rbpbyl = 0.0; + if (!model->BSIM4v7rbpbywGiven) + model->BSIM4v7rbpbyw = 0.0; + if (!model->BSIM4v7rbpbynfGiven) + model->BSIM4v7rbpbynf = 0.0; - if (!model->BSIM4rbsbx0Given) - model->BSIM4rbsbx0 = 100.0; - if (!model->BSIM4rbsby0Given) - model->BSIM4rbsby0 = 100.0; - if (!model->BSIM4rbdbx0Given) - model->BSIM4rbdbx0 = 100.0; - if (!model->BSIM4rbdby0Given) - model->BSIM4rbdby0 = 100.0; + if (!model->BSIM4v7rbsbx0Given) + model->BSIM4v7rbsbx0 = 100.0; + if (!model->BSIM4v7rbsby0Given) + model->BSIM4v7rbsby0 = 100.0; + if (!model->BSIM4v7rbdbx0Given) + model->BSIM4v7rbdbx0 = 100.0; + if (!model->BSIM4v7rbdby0Given) + model->BSIM4v7rbdby0 = 100.0; - if (!model->BSIM4rbsdbxlGiven) - model->BSIM4rbsdbxl = 0.0; - if (!model->BSIM4rbsdbxwGiven) - model->BSIM4rbsdbxw = 0.0; - if (!model->BSIM4rbsdbxnfGiven) - model->BSIM4rbsdbxnf = 0.0; - if (!model->BSIM4rbsdbylGiven) - model->BSIM4rbsdbyl = 0.0; - if (!model->BSIM4rbsdbywGiven) - model->BSIM4rbsdbyw = 0.0; - if (!model->BSIM4rbsdbynfGiven) - model->BSIM4rbsdbynf = 0.0; + if (!model->BSIM4v7rbsdbxlGiven) + model->BSIM4v7rbsdbxl = 0.0; + if (!model->BSIM4v7rbsdbxwGiven) + model->BSIM4v7rbsdbxw = 0.0; + if (!model->BSIM4v7rbsdbxnfGiven) + model->BSIM4v7rbsdbxnf = 0.0; + if (!model->BSIM4v7rbsdbylGiven) + model->BSIM4v7rbsdbyl = 0.0; + if (!model->BSIM4v7rbsdbywGiven) + model->BSIM4v7rbsdbyw = 0.0; + if (!model->BSIM4v7rbsdbynfGiven) + model->BSIM4v7rbsdbynf = 0.0; - if (!model->BSIM4cgslGiven) - model->BSIM4cgsl = 0.0; - if (!model->BSIM4cgdlGiven) - model->BSIM4cgdl = 0.0; - if (!model->BSIM4ckappasGiven) - model->BSIM4ckappas = 0.6; - if (!model->BSIM4ckappadGiven) - model->BSIM4ckappad = model->BSIM4ckappas; - if (!model->BSIM4clcGiven) - model->BSIM4clc = 0.1e-6; - if (!model->BSIM4cleGiven) - model->BSIM4cle = 0.6; - if (!model->BSIM4vfbcvGiven) - model->BSIM4vfbcv = -1.0; - if (!model->BSIM4acdeGiven) - model->BSIM4acde = 1.0; - if (!model->BSIM4moinGiven) - model->BSIM4moin = 15.0; - if (!model->BSIM4noffGiven) - model->BSIM4noff = 1.0; - if (!model->BSIM4voffcvGiven) - model->BSIM4voffcv = 0.0; - if (!model->BSIM4dmcgGiven) - model->BSIM4dmcg = 0.0; - if (!model->BSIM4dmciGiven) - model->BSIM4dmci = model->BSIM4dmcg; - if (!model->BSIM4dmdgGiven) - model->BSIM4dmdg = 0.0; - if (!model->BSIM4dmcgtGiven) - model->BSIM4dmcgt = 0.0; - if (!model->BSIM4xgwGiven) - model->BSIM4xgw = 0.0; - if (!model->BSIM4xglGiven) - model->BSIM4xgl = 0.0; - if (!model->BSIM4rshgGiven) - model->BSIM4rshg = 0.1; - if (!model->BSIM4ngconGiven) - model->BSIM4ngcon = 1.0; - if (!model->BSIM4tcjGiven) - model->BSIM4tcj = 0.0; - if (!model->BSIM4tpbGiven) - model->BSIM4tpb = 0.0; - if (!model->BSIM4tcjswGiven) - model->BSIM4tcjsw = 0.0; - if (!model->BSIM4tpbswGiven) - model->BSIM4tpbsw = 0.0; - if (!model->BSIM4tcjswgGiven) - model->BSIM4tcjswg = 0.0; - if (!model->BSIM4tpbswgGiven) - model->BSIM4tpbswg = 0.0; + if (!model->BSIM4v7cgslGiven) + model->BSIM4v7cgsl = 0.0; + if (!model->BSIM4v7cgdlGiven) + model->BSIM4v7cgdl = 0.0; + if (!model->BSIM4v7ckappasGiven) + model->BSIM4v7ckappas = 0.6; + if (!model->BSIM4v7ckappadGiven) + model->BSIM4v7ckappad = model->BSIM4v7ckappas; + if (!model->BSIM4v7clcGiven) + model->BSIM4v7clc = 0.1e-6; + if (!model->BSIM4v7cleGiven) + model->BSIM4v7cle = 0.6; + if (!model->BSIM4v7vfbcvGiven) + model->BSIM4v7vfbcv = -1.0; + if (!model->BSIM4v7acdeGiven) + model->BSIM4v7acde = 1.0; + if (!model->BSIM4v7moinGiven) + model->BSIM4v7moin = 15.0; + if (!model->BSIM4v7noffGiven) + model->BSIM4v7noff = 1.0; + if (!model->BSIM4v7voffcvGiven) + model->BSIM4v7voffcv = 0.0; + if (!model->BSIM4v7dmcgGiven) + model->BSIM4v7dmcg = 0.0; + if (!model->BSIM4v7dmciGiven) + model->BSIM4v7dmci = model->BSIM4v7dmcg; + if (!model->BSIM4v7dmdgGiven) + model->BSIM4v7dmdg = 0.0; + if (!model->BSIM4v7dmcgtGiven) + model->BSIM4v7dmcgt = 0.0; + if (!model->BSIM4v7xgwGiven) + model->BSIM4v7xgw = 0.0; + if (!model->BSIM4v7xglGiven) + model->BSIM4v7xgl = 0.0; + if (!model->BSIM4v7rshgGiven) + model->BSIM4v7rshg = 0.1; + if (!model->BSIM4v7ngconGiven) + model->BSIM4v7ngcon = 1.0; + if (!model->BSIM4v7tcjGiven) + model->BSIM4v7tcj = 0.0; + if (!model->BSIM4v7tpbGiven) + model->BSIM4v7tpb = 0.0; + if (!model->BSIM4v7tcjswGiven) + model->BSIM4v7tcjsw = 0.0; + if (!model->BSIM4v7tpbswGiven) + model->BSIM4v7tpbsw = 0.0; + if (!model->BSIM4v7tcjswgGiven) + model->BSIM4v7tcjswg = 0.0; + if (!model->BSIM4v7tpbswgGiven) + model->BSIM4v7tpbswg = 0.0; /* Length dependence */ - if (!model->BSIM4lcdscGiven) - model->BSIM4lcdsc = 0.0; - if (!model->BSIM4lcdscbGiven) - model->BSIM4lcdscb = 0.0; - if (!model->BSIM4lcdscdGiven) - model->BSIM4lcdscd = 0.0; - if (!model->BSIM4lcitGiven) - model->BSIM4lcit = 0.0; - if (!model->BSIM4lnfactorGiven) - model->BSIM4lnfactor = 0.0; - if (!model->BSIM4lxjGiven) - model->BSIM4lxj = 0.0; - if (!model->BSIM4lvsatGiven) - model->BSIM4lvsat = 0.0; - if (!model->BSIM4latGiven) - model->BSIM4lat = 0.0; - if (!model->BSIM4la0Given) - model->BSIM4la0 = 0.0; - if (!model->BSIM4lagsGiven) - model->BSIM4lags = 0.0; - if (!model->BSIM4la1Given) - model->BSIM4la1 = 0.0; - if (!model->BSIM4la2Given) - model->BSIM4la2 = 0.0; - if (!model->BSIM4lketaGiven) - model->BSIM4lketa = 0.0; - if (!model->BSIM4lnsubGiven) - model->BSIM4lnsub = 0.0; - if (!model->BSIM4lndepGiven) - model->BSIM4lndep = 0.0; - if (!model->BSIM4lnsdGiven) - model->BSIM4lnsd = 0.0; - if (!model->BSIM4lphinGiven) - model->BSIM4lphin = 0.0; - if (!model->BSIM4lngateGiven) - model->BSIM4lngate = 0.0; - if (!model->BSIM4lvbmGiven) - model->BSIM4lvbm = 0.0; - if (!model->BSIM4lxtGiven) - model->BSIM4lxt = 0.0; - if (!model->BSIM4lkt1Given) - model->BSIM4lkt1 = 0.0; - if (!model->BSIM4lkt1lGiven) - model->BSIM4lkt1l = 0.0; - if (!model->BSIM4lkt2Given) - model->BSIM4lkt2 = 0.0; - if (!model->BSIM4lk3Given) - model->BSIM4lk3 = 0.0; - if (!model->BSIM4lk3bGiven) - model->BSIM4lk3b = 0.0; - if (!model->BSIM4lw0Given) - model->BSIM4lw0 = 0.0; - if (!model->BSIM4llpe0Given) - model->BSIM4llpe0 = 0.0; - if (!model->BSIM4llpebGiven) - model->BSIM4llpeb = 0.0; - if (!model->BSIM4ldvtp0Given) - model->BSIM4ldvtp0 = 0.0; - if (!model->BSIM4ldvtp1Given) - model->BSIM4ldvtp1 = 0.0; - if (!model->BSIM4ldvtp2Given) /* New DIBL/Rout */ - model->BSIM4ldvtp2 = 0.0; - if (!model->BSIM4ldvtp3Given) - model->BSIM4ldvtp3 = 0.0; - if (!model->BSIM4ldvtp4Given) - model->BSIM4ldvtp4 = 0.0; - if (!model->BSIM4ldvtp5Given) - model->BSIM4ldvtp5 = 0.0; - if (!model->BSIM4ldvt0Given) - model->BSIM4ldvt0 = 0.0; - if (!model->BSIM4ldvt1Given) - model->BSIM4ldvt1 = 0.0; - if (!model->BSIM4ldvt2Given) - model->BSIM4ldvt2 = 0.0; - if (!model->BSIM4ldvt0wGiven) - model->BSIM4ldvt0w = 0.0; - if (!model->BSIM4ldvt1wGiven) - model->BSIM4ldvt1w = 0.0; - if (!model->BSIM4ldvt2wGiven) - model->BSIM4ldvt2w = 0.0; - if (!model->BSIM4ldroutGiven) - model->BSIM4ldrout = 0.0; - if (!model->BSIM4ldsubGiven) - model->BSIM4ldsub = 0.0; - if (!model->BSIM4lvth0Given) - model->BSIM4lvth0 = 0.0; - if (!model->BSIM4luaGiven) - model->BSIM4lua = 0.0; - if (!model->BSIM4lua1Given) - model->BSIM4lua1 = 0.0; - if (!model->BSIM4lubGiven) - model->BSIM4lub = 0.0; - if (!model->BSIM4lub1Given) - model->BSIM4lub1 = 0.0; - if (!model->BSIM4lucGiven) - model->BSIM4luc = 0.0; - if (!model->BSIM4luc1Given) - model->BSIM4luc1 = 0.0; - if (!model->BSIM4ludGiven) - model->BSIM4lud = 0.0; - if (!model->BSIM4lud1Given) - model->BSIM4lud1 = 0.0; - if (!model->BSIM4lupGiven) - model->BSIM4lup = 0.0; - if (!model->BSIM4llpGiven) - model->BSIM4llp = 0.0; - if (!model->BSIM4lu0Given) - model->BSIM4lu0 = 0.0; - if (!model->BSIM4luteGiven) - model->BSIM4lute = 0.0; - if (!model->BSIM4lucsteGiven) - model->BSIM4lucste = 0.0; - if (!model->BSIM4lvoffGiven) - model->BSIM4lvoff = 0.0; - if (!model->BSIM4lminvGiven) - model->BSIM4lminv = 0.0; - if (!model->BSIM4lminvcvGiven) - model->BSIM4lminvcv = 0.0; - if (!model->BSIM4lfproutGiven) - model->BSIM4lfprout = 0.0; - if (!model->BSIM4lpditsGiven) - model->BSIM4lpdits = 0.0; - if (!model->BSIM4lpditsdGiven) - model->BSIM4lpditsd = 0.0; - if (!model->BSIM4ldeltaGiven) - model->BSIM4ldelta = 0.0; - if (!model->BSIM4lrdswGiven) - model->BSIM4lrdsw = 0.0; - if (!model->BSIM4lrdwGiven) - model->BSIM4lrdw = 0.0; - if (!model->BSIM4lrswGiven) - model->BSIM4lrsw = 0.0; - if (!model->BSIM4lprwbGiven) - model->BSIM4lprwb = 0.0; - if (!model->BSIM4lprwgGiven) - model->BSIM4lprwg = 0.0; - if (!model->BSIM4lprtGiven) - model->BSIM4lprt = 0.0; - if (!model->BSIM4leta0Given) - model->BSIM4leta0 = 0.0; - if (!model->BSIM4letabGiven) - model->BSIM4letab = -0.0; - if (!model->BSIM4lpclmGiven) - model->BSIM4lpclm = 0.0; - if (!model->BSIM4lpdibl1Given) - model->BSIM4lpdibl1 = 0.0; - if (!model->BSIM4lpdibl2Given) - model->BSIM4lpdibl2 = 0.0; - if (!model->BSIM4lpdiblbGiven) - model->BSIM4lpdiblb = 0.0; - if (!model->BSIM4lpscbe1Given) - model->BSIM4lpscbe1 = 0.0; - if (!model->BSIM4lpscbe2Given) - model->BSIM4lpscbe2 = 0.0; - if (!model->BSIM4lpvagGiven) - model->BSIM4lpvag = 0.0; - if (!model->BSIM4lwrGiven) - model->BSIM4lwr = 0.0; - if (!model->BSIM4ldwgGiven) - model->BSIM4ldwg = 0.0; - if (!model->BSIM4ldwbGiven) - model->BSIM4ldwb = 0.0; - if (!model->BSIM4lb0Given) - model->BSIM4lb0 = 0.0; - if (!model->BSIM4lb1Given) - model->BSIM4lb1 = 0.0; - if (!model->BSIM4lalpha0Given) - model->BSIM4lalpha0 = 0.0; - if (!model->BSIM4lalpha1Given) - model->BSIM4lalpha1 = 0.0; - if (!model->BSIM4lbeta0Given) - model->BSIM4lbeta0 = 0.0; - if (!model->BSIM4lagidlGiven) - model->BSIM4lagidl = 0.0; - if (!model->BSIM4lbgidlGiven) - model->BSIM4lbgidl = 0.0; - if (!model->BSIM4lcgidlGiven) - model->BSIM4lcgidl = 0.0; - if (!model->BSIM4legidlGiven) - model->BSIM4legidl = 0.0; - if (!model->BSIM4lrgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4lrgidl = 0.0; - if (!model->BSIM4lkgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4lkgidl = 0.0; - if (!model->BSIM4lfgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4lfgidl = 0.0; + if (!model->BSIM4v7lcdscGiven) + model->BSIM4v7lcdsc = 0.0; + if (!model->BSIM4v7lcdscbGiven) + model->BSIM4v7lcdscb = 0.0; + if (!model->BSIM4v7lcdscdGiven) + model->BSIM4v7lcdscd = 0.0; + if (!model->BSIM4v7lcitGiven) + model->BSIM4v7lcit = 0.0; + if (!model->BSIM4v7lnfactorGiven) + model->BSIM4v7lnfactor = 0.0; + if (!model->BSIM4v7lxjGiven) + model->BSIM4v7lxj = 0.0; + if (!model->BSIM4v7lvsatGiven) + model->BSIM4v7lvsat = 0.0; + if (!model->BSIM4v7latGiven) + model->BSIM4v7lat = 0.0; + if (!model->BSIM4v7la0Given) + model->BSIM4v7la0 = 0.0; + if (!model->BSIM4v7lagsGiven) + model->BSIM4v7lags = 0.0; + if (!model->BSIM4v7la1Given) + model->BSIM4v7la1 = 0.0; + if (!model->BSIM4v7la2Given) + model->BSIM4v7la2 = 0.0; + if (!model->BSIM4v7lketaGiven) + model->BSIM4v7lketa = 0.0; + if (!model->BSIM4v7lnsubGiven) + model->BSIM4v7lnsub = 0.0; + if (!model->BSIM4v7lndepGiven) + model->BSIM4v7lndep = 0.0; + if (!model->BSIM4v7lnsdGiven) + model->BSIM4v7lnsd = 0.0; + if (!model->BSIM4v7lphinGiven) + model->BSIM4v7lphin = 0.0; + if (!model->BSIM4v7lngateGiven) + model->BSIM4v7lngate = 0.0; + if (!model->BSIM4v7lvbmGiven) + model->BSIM4v7lvbm = 0.0; + if (!model->BSIM4v7lxtGiven) + model->BSIM4v7lxt = 0.0; + if (!model->BSIM4v7lkt1Given) + model->BSIM4v7lkt1 = 0.0; + if (!model->BSIM4v7lkt1lGiven) + model->BSIM4v7lkt1l = 0.0; + if (!model->BSIM4v7lkt2Given) + model->BSIM4v7lkt2 = 0.0; + if (!model->BSIM4v7lk3Given) + model->BSIM4v7lk3 = 0.0; + if (!model->BSIM4v7lk3bGiven) + model->BSIM4v7lk3b = 0.0; + if (!model->BSIM4v7lw0Given) + model->BSIM4v7lw0 = 0.0; + if (!model->BSIM4v7llpe0Given) + model->BSIM4v7llpe0 = 0.0; + if (!model->BSIM4v7llpebGiven) + model->BSIM4v7llpeb = 0.0; + if (!model->BSIM4v7ldvtp0Given) + model->BSIM4v7ldvtp0 = 0.0; + if (!model->BSIM4v7ldvtp1Given) + model->BSIM4v7ldvtp1 = 0.0; + if (!model->BSIM4v7ldvtp2Given) /* New DIBL/Rout */ + model->BSIM4v7ldvtp2 = 0.0; + if (!model->BSIM4v7ldvtp3Given) + model->BSIM4v7ldvtp3 = 0.0; + if (!model->BSIM4v7ldvtp4Given) + model->BSIM4v7ldvtp4 = 0.0; + if (!model->BSIM4v7ldvtp5Given) + model->BSIM4v7ldvtp5 = 0.0; + if (!model->BSIM4v7ldvt0Given) + model->BSIM4v7ldvt0 = 0.0; + if (!model->BSIM4v7ldvt1Given) + model->BSIM4v7ldvt1 = 0.0; + if (!model->BSIM4v7ldvt2Given) + model->BSIM4v7ldvt2 = 0.0; + if (!model->BSIM4v7ldvt0wGiven) + model->BSIM4v7ldvt0w = 0.0; + if (!model->BSIM4v7ldvt1wGiven) + model->BSIM4v7ldvt1w = 0.0; + if (!model->BSIM4v7ldvt2wGiven) + model->BSIM4v7ldvt2w = 0.0; + if (!model->BSIM4v7ldroutGiven) + model->BSIM4v7ldrout = 0.0; + if (!model->BSIM4v7ldsubGiven) + model->BSIM4v7ldsub = 0.0; + if (!model->BSIM4v7lvth0Given) + model->BSIM4v7lvth0 = 0.0; + if (!model->BSIM4v7luaGiven) + model->BSIM4v7lua = 0.0; + if (!model->BSIM4v7lua1Given) + model->BSIM4v7lua1 = 0.0; + if (!model->BSIM4v7lubGiven) + model->BSIM4v7lub = 0.0; + if (!model->BSIM4v7lub1Given) + model->BSIM4v7lub1 = 0.0; + if (!model->BSIM4v7lucGiven) + model->BSIM4v7luc = 0.0; + if (!model->BSIM4v7luc1Given) + model->BSIM4v7luc1 = 0.0; + if (!model->BSIM4v7ludGiven) + model->BSIM4v7lud = 0.0; + if (!model->BSIM4v7lud1Given) + model->BSIM4v7lud1 = 0.0; + if (!model->BSIM4v7lupGiven) + model->BSIM4v7lup = 0.0; + if (!model->BSIM4v7llpGiven) + model->BSIM4v7llp = 0.0; + if (!model->BSIM4v7lu0Given) + model->BSIM4v7lu0 = 0.0; + if (!model->BSIM4v7luteGiven) + model->BSIM4v7lute = 0.0; + if (!model->BSIM4v7lucsteGiven) + model->BSIM4v7lucste = 0.0; + if (!model->BSIM4v7lvoffGiven) + model->BSIM4v7lvoff = 0.0; + if (!model->BSIM4v7lminvGiven) + model->BSIM4v7lminv = 0.0; + if (!model->BSIM4v7lminvcvGiven) + model->BSIM4v7lminvcv = 0.0; + if (!model->BSIM4v7lfproutGiven) + model->BSIM4v7lfprout = 0.0; + if (!model->BSIM4v7lpditsGiven) + model->BSIM4v7lpdits = 0.0; + if (!model->BSIM4v7lpditsdGiven) + model->BSIM4v7lpditsd = 0.0; + if (!model->BSIM4v7ldeltaGiven) + model->BSIM4v7ldelta = 0.0; + if (!model->BSIM4v7lrdswGiven) + model->BSIM4v7lrdsw = 0.0; + if (!model->BSIM4v7lrdwGiven) + model->BSIM4v7lrdw = 0.0; + if (!model->BSIM4v7lrswGiven) + model->BSIM4v7lrsw = 0.0; + if (!model->BSIM4v7lprwbGiven) + model->BSIM4v7lprwb = 0.0; + if (!model->BSIM4v7lprwgGiven) + model->BSIM4v7lprwg = 0.0; + if (!model->BSIM4v7lprtGiven) + model->BSIM4v7lprt = 0.0; + if (!model->BSIM4v7leta0Given) + model->BSIM4v7leta0 = 0.0; + if (!model->BSIM4v7letabGiven) + model->BSIM4v7letab = -0.0; + if (!model->BSIM4v7lpclmGiven) + model->BSIM4v7lpclm = 0.0; + if (!model->BSIM4v7lpdibl1Given) + model->BSIM4v7lpdibl1 = 0.0; + if (!model->BSIM4v7lpdibl2Given) + model->BSIM4v7lpdibl2 = 0.0; + if (!model->BSIM4v7lpdiblbGiven) + model->BSIM4v7lpdiblb = 0.0; + if (!model->BSIM4v7lpscbe1Given) + model->BSIM4v7lpscbe1 = 0.0; + if (!model->BSIM4v7lpscbe2Given) + model->BSIM4v7lpscbe2 = 0.0; + if (!model->BSIM4v7lpvagGiven) + model->BSIM4v7lpvag = 0.0; + if (!model->BSIM4v7lwrGiven) + model->BSIM4v7lwr = 0.0; + if (!model->BSIM4v7ldwgGiven) + model->BSIM4v7ldwg = 0.0; + if (!model->BSIM4v7ldwbGiven) + model->BSIM4v7ldwb = 0.0; + if (!model->BSIM4v7lb0Given) + model->BSIM4v7lb0 = 0.0; + if (!model->BSIM4v7lb1Given) + model->BSIM4v7lb1 = 0.0; + if (!model->BSIM4v7lalpha0Given) + model->BSIM4v7lalpha0 = 0.0; + if (!model->BSIM4v7lalpha1Given) + model->BSIM4v7lalpha1 = 0.0; + if (!model->BSIM4v7lbeta0Given) + model->BSIM4v7lbeta0 = 0.0; + if (!model->BSIM4v7lagidlGiven) + model->BSIM4v7lagidl = 0.0; + if (!model->BSIM4v7lbgidlGiven) + model->BSIM4v7lbgidl = 0.0; + if (!model->BSIM4v7lcgidlGiven) + model->BSIM4v7lcgidl = 0.0; + if (!model->BSIM4v7legidlGiven) + model->BSIM4v7legidl = 0.0; + if (!model->BSIM4v7lrgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7lrgidl = 0.0; + if (!model->BSIM4v7lkgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7lkgidl = 0.0; + if (!model->BSIM4v7lfgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7lfgidl = 0.0; - if (!model->BSIM4lagislGiven) + if (!model->BSIM4v7lagislGiven) { - if (model->BSIM4lagidlGiven) - model->BSIM4lagisl = model->BSIM4lagidl; + if (model->BSIM4v7lagidlGiven) + model->BSIM4v7lagisl = model->BSIM4v7lagidl; else - model->BSIM4lagisl = 0.0; + model->BSIM4v7lagisl = 0.0; } - if (!model->BSIM4lbgislGiven) + if (!model->BSIM4v7lbgislGiven) { - if (model->BSIM4lbgidlGiven) - model->BSIM4lbgisl = model->BSIM4lbgidl; + if (model->BSIM4v7lbgidlGiven) + model->BSIM4v7lbgisl = model->BSIM4v7lbgidl; else - model->BSIM4lbgisl = 0.0; + model->BSIM4v7lbgisl = 0.0; } - if (!model->BSIM4lcgislGiven) + if (!model->BSIM4v7lcgislGiven) { - if (model->BSIM4lcgidlGiven) - model->BSIM4lcgisl = model->BSIM4lcgidl; + if (model->BSIM4v7lcgidlGiven) + model->BSIM4v7lcgisl = model->BSIM4v7lcgidl; else - model->BSIM4lcgisl = 0.0; + model->BSIM4v7lcgisl = 0.0; } - if (!model->BSIM4legislGiven) + if (!model->BSIM4v7legislGiven) { - if (model->BSIM4legidlGiven) - model->BSIM4legisl = model->BSIM4legidl; + if (model->BSIM4v7legidlGiven) + model->BSIM4v7legisl = model->BSIM4v7legidl; else - model->BSIM4legisl = 0.0; + model->BSIM4v7legisl = 0.0; } - if (!model->BSIM4lrgislGiven) /* v4.7 New GIDL/GISL */ + if (!model->BSIM4v7lrgislGiven) /* v4.7 New GIDL/GISL */ { - if (model->BSIM4lrgidlGiven) - model->BSIM4lrgisl = model->BSIM4lrgidl; + if (model->BSIM4v7lrgidlGiven) + model->BSIM4v7lrgisl = model->BSIM4v7lrgidl; } - if (!model->BSIM4lkgislGiven) /* v4.7 New GIDL/GISL */ + if (!model->BSIM4v7lkgislGiven) /* v4.7 New GIDL/GISL */ { - if (model->BSIM4lkgidlGiven) - model->BSIM4lkgisl = model->BSIM4lkgidl; + if (model->BSIM4v7lkgidlGiven) + model->BSIM4v7lkgisl = model->BSIM4v7lkgidl; } - if (!model->BSIM4lfgislGiven) /* v4.7 New GIDL/GISL */ + if (!model->BSIM4v7lfgislGiven) /* v4.7 New GIDL/GISL */ { - if (model->BSIM4lfgidlGiven) - model->BSIM4lfgisl = model->BSIM4lfgidl; + if (model->BSIM4v7lfgidlGiven) + model->BSIM4v7lfgisl = model->BSIM4v7lfgidl; } - if (!model->BSIM4laigcGiven) - model->BSIM4laigc = 0.0; - if (!model->BSIM4lbigcGiven) - model->BSIM4lbigc = 0.0; - if (!model->BSIM4lcigcGiven) - model->BSIM4lcigc = 0.0; - if (!model->BSIM4aigsdGiven && (model->BSIM4aigsGiven || model->BSIM4aigdGiven)) + if (!model->BSIM4v7laigcGiven) + model->BSIM4v7laigc = 0.0; + if (!model->BSIM4v7lbigcGiven) + model->BSIM4v7lbigc = 0.0; + if (!model->BSIM4v7lcigcGiven) + model->BSIM4v7lcigc = 0.0; + if (!model->BSIM4v7aigsdGiven && (model->BSIM4v7aigsGiven || model->BSIM4v7aigdGiven)) { - if (!model->BSIM4laigsGiven) - model->BSIM4laigs = 0.0; - if (!model->BSIM4laigdGiven) - model->BSIM4laigd = 0.0; + if (!model->BSIM4v7laigsGiven) + model->BSIM4v7laigs = 0.0; + if (!model->BSIM4v7laigdGiven) + model->BSIM4v7laigd = 0.0; } else { - if (!model->BSIM4laigsdGiven) - model->BSIM4laigsd = 0.0; - model->BSIM4laigs = model->BSIM4laigd = model->BSIM4laigsd; + if (!model->BSIM4v7laigsdGiven) + model->BSIM4v7laigsd = 0.0; + model->BSIM4v7laigs = model->BSIM4v7laigd = model->BSIM4v7laigsd; } - if (!model->BSIM4bigsdGiven && (model->BSIM4bigsGiven || model->BSIM4bigdGiven)) + if (!model->BSIM4v7bigsdGiven && (model->BSIM4v7bigsGiven || model->BSIM4v7bigdGiven)) { - if (!model->BSIM4lbigsGiven) - model->BSIM4lbigs = 0.0; - if (!model->BSIM4lbigdGiven) - model->BSIM4lbigd = 0.0; + if (!model->BSIM4v7lbigsGiven) + model->BSIM4v7lbigs = 0.0; + if (!model->BSIM4v7lbigdGiven) + model->BSIM4v7lbigd = 0.0; } else { - if (!model->BSIM4lbigsdGiven) - model->BSIM4lbigsd = 0.0; - model->BSIM4lbigs = model->BSIM4lbigd = model->BSIM4lbigsd; + if (!model->BSIM4v7lbigsdGiven) + model->BSIM4v7lbigsd = 0.0; + model->BSIM4v7lbigs = model->BSIM4v7lbigd = model->BSIM4v7lbigsd; } - if (!model->BSIM4cigsdGiven && (model->BSIM4cigsGiven || model->BSIM4cigdGiven)) + if (!model->BSIM4v7cigsdGiven && (model->BSIM4v7cigsGiven || model->BSIM4v7cigdGiven)) { - if (!model->BSIM4lcigsGiven) - model->BSIM4lcigs = 0.0; - if (!model->BSIM4lcigdGiven) - model->BSIM4lcigd = 0.0; + if (!model->BSIM4v7lcigsGiven) + model->BSIM4v7lcigs = 0.0; + if (!model->BSIM4v7lcigdGiven) + model->BSIM4v7lcigd = 0.0; } else { - if (!model->BSIM4lcigsdGiven) - model->BSIM4lcigsd = 0.0; - model->BSIM4lcigs = model->BSIM4lcigd = model->BSIM4lcigsd; + if (!model->BSIM4v7lcigsdGiven) + model->BSIM4v7lcigsd = 0.0; + model->BSIM4v7lcigs = model->BSIM4v7lcigd = model->BSIM4v7lcigsd; } - if (!model->BSIM4laigbaccGiven) - model->BSIM4laigbacc = 0.0; - if (!model->BSIM4lbigbaccGiven) - model->BSIM4lbigbacc = 0.0; - if (!model->BSIM4lcigbaccGiven) - model->BSIM4lcigbacc = 0.0; - if (!model->BSIM4laigbinvGiven) - model->BSIM4laigbinv = 0.0; - if (!model->BSIM4lbigbinvGiven) - model->BSIM4lbigbinv = 0.0; - if (!model->BSIM4lcigbinvGiven) - model->BSIM4lcigbinv = 0.0; - if (!model->BSIM4lnigcGiven) - model->BSIM4lnigc = 0.0; - if (!model->BSIM4lnigbinvGiven) - model->BSIM4lnigbinv = 0.0; - if (!model->BSIM4lnigbaccGiven) - model->BSIM4lnigbacc = 0.0; - if (!model->BSIM4lntoxGiven) - model->BSIM4lntox = 0.0; - if (!model->BSIM4leigbinvGiven) - model->BSIM4leigbinv = 0.0; - if (!model->BSIM4lpigcdGiven) - model->BSIM4lpigcd = 0.0; - if (!model->BSIM4lpoxedgeGiven) - model->BSIM4lpoxedge = 0.0; - if (!model->BSIM4lxrcrg1Given) - model->BSIM4lxrcrg1 = 0.0; - if (!model->BSIM4lxrcrg2Given) - model->BSIM4lxrcrg2 = 0.0; - if (!model->BSIM4leuGiven) - model->BSIM4leu = 0.0; - if (!model->BSIM4lucsGiven) - model->BSIM4lucs = 0.0; - if (!model->BSIM4lvfbGiven) - model->BSIM4lvfb = 0.0; - if (!model->BSIM4llambdaGiven) - model->BSIM4llambda = 0.0; - if (!model->BSIM4lvtlGiven) - model->BSIM4lvtl = 0.0; - if (!model->BSIM4lxnGiven) - model->BSIM4lxn = 0.0; - if (!model->BSIM4lvfbsdoffGiven) - model->BSIM4lvfbsdoff = 0.0; - if (!model->BSIM4ltvfbsdoffGiven) - model->BSIM4ltvfbsdoff = 0.0; - if (!model->BSIM4ltvoffGiven) - model->BSIM4ltvoff = 0.0; - if (!model->BSIM4ltnfactorGiven) /* v4.7 temp dep of leakage current */ - model->BSIM4ltnfactor = 0.0; - if (!model->BSIM4lteta0Given) /* v4.7 temp dep of leakage current */ - model->BSIM4lteta0 = 0.0; - if (!model->BSIM4ltvoffcvGiven) /* v4.7 temp dep of leakage current */ - model->BSIM4ltvoffcv = 0.0; + if (!model->BSIM4v7laigbaccGiven) + model->BSIM4v7laigbacc = 0.0; + if (!model->BSIM4v7lbigbaccGiven) + model->BSIM4v7lbigbacc = 0.0; + if (!model->BSIM4v7lcigbaccGiven) + model->BSIM4v7lcigbacc = 0.0; + if (!model->BSIM4v7laigbinvGiven) + model->BSIM4v7laigbinv = 0.0; + if (!model->BSIM4v7lbigbinvGiven) + model->BSIM4v7lbigbinv = 0.0; + if (!model->BSIM4v7lcigbinvGiven) + model->BSIM4v7lcigbinv = 0.0; + if (!model->BSIM4v7lnigcGiven) + model->BSIM4v7lnigc = 0.0; + if (!model->BSIM4v7lnigbinvGiven) + model->BSIM4v7lnigbinv = 0.0; + if (!model->BSIM4v7lnigbaccGiven) + model->BSIM4v7lnigbacc = 0.0; + if (!model->BSIM4v7lntoxGiven) + model->BSIM4v7lntox = 0.0; + if (!model->BSIM4v7leigbinvGiven) + model->BSIM4v7leigbinv = 0.0; + if (!model->BSIM4v7lpigcdGiven) + model->BSIM4v7lpigcd = 0.0; + if (!model->BSIM4v7lpoxedgeGiven) + model->BSIM4v7lpoxedge = 0.0; + if (!model->BSIM4v7lxrcrg1Given) + model->BSIM4v7lxrcrg1 = 0.0; + if (!model->BSIM4v7lxrcrg2Given) + model->BSIM4v7lxrcrg2 = 0.0; + if (!model->BSIM4v7leuGiven) + model->BSIM4v7leu = 0.0; + if (!model->BSIM4v7lucsGiven) + model->BSIM4v7lucs = 0.0; + if (!model->BSIM4v7lvfbGiven) + model->BSIM4v7lvfb = 0.0; + if (!model->BSIM4v7llambdaGiven) + model->BSIM4v7llambda = 0.0; + if (!model->BSIM4v7lvtlGiven) + model->BSIM4v7lvtl = 0.0; + if (!model->BSIM4v7lxnGiven) + model->BSIM4v7lxn = 0.0; + if (!model->BSIM4v7lvfbsdoffGiven) + model->BSIM4v7lvfbsdoff = 0.0; + if (!model->BSIM4v7ltvfbsdoffGiven) + model->BSIM4v7ltvfbsdoff = 0.0; + if (!model->BSIM4v7ltvoffGiven) + model->BSIM4v7ltvoff = 0.0; + if (!model->BSIM4v7ltnfactorGiven) /* v4.7 temp dep of leakage current */ + model->BSIM4v7ltnfactor = 0.0; + if (!model->BSIM4v7lteta0Given) /* v4.7 temp dep of leakage current */ + model->BSIM4v7lteta0 = 0.0; + if (!model->BSIM4v7ltvoffcvGiven) /* v4.7 temp dep of leakage current */ + model->BSIM4v7ltvoffcv = 0.0; - if (!model->BSIM4lcgslGiven) - model->BSIM4lcgsl = 0.0; - if (!model->BSIM4lcgdlGiven) - model->BSIM4lcgdl = 0.0; - if (!model->BSIM4lckappasGiven) - model->BSIM4lckappas = 0.0; - if (!model->BSIM4lckappadGiven) - model->BSIM4lckappad = 0.0; - if (!model->BSIM4lclcGiven) - model->BSIM4lclc = 0.0; - if (!model->BSIM4lcleGiven) - model->BSIM4lcle = 0.0; - if (!model->BSIM4lcfGiven) - model->BSIM4lcf = 0.0; - if (!model->BSIM4lvfbcvGiven) - model->BSIM4lvfbcv = 0.0; - if (!model->BSIM4lacdeGiven) - model->BSIM4lacde = 0.0; - if (!model->BSIM4lmoinGiven) - model->BSIM4lmoin = 0.0; - if (!model->BSIM4lnoffGiven) - model->BSIM4lnoff = 0.0; - if (!model->BSIM4lvoffcvGiven) - model->BSIM4lvoffcv = 0.0; + if (!model->BSIM4v7lcgslGiven) + model->BSIM4v7lcgsl = 0.0; + if (!model->BSIM4v7lcgdlGiven) + model->BSIM4v7lcgdl = 0.0; + if (!model->BSIM4v7lckappasGiven) + model->BSIM4v7lckappas = 0.0; + if (!model->BSIM4v7lckappadGiven) + model->BSIM4v7lckappad = 0.0; + if (!model->BSIM4v7lclcGiven) + model->BSIM4v7lclc = 0.0; + if (!model->BSIM4v7lcleGiven) + model->BSIM4v7lcle = 0.0; + if (!model->BSIM4v7lcfGiven) + model->BSIM4v7lcf = 0.0; + if (!model->BSIM4v7lvfbcvGiven) + model->BSIM4v7lvfbcv = 0.0; + if (!model->BSIM4v7lacdeGiven) + model->BSIM4v7lacde = 0.0; + if (!model->BSIM4v7lmoinGiven) + model->BSIM4v7lmoin = 0.0; + if (!model->BSIM4v7lnoffGiven) + model->BSIM4v7lnoff = 0.0; + if (!model->BSIM4v7lvoffcvGiven) + model->BSIM4v7lvoffcv = 0.0; /* Width dependence */ - if (!model->BSIM4wcdscGiven) - model->BSIM4wcdsc = 0.0; - if (!model->BSIM4wcdscbGiven) - model->BSIM4wcdscb = 0.0; - if (!model->BSIM4wcdscdGiven) - model->BSIM4wcdscd = 0.0; - if (!model->BSIM4wcitGiven) - model->BSIM4wcit = 0.0; - if (!model->BSIM4wnfactorGiven) - model->BSIM4wnfactor = 0.0; - if (!model->BSIM4wxjGiven) - model->BSIM4wxj = 0.0; - if (!model->BSIM4wvsatGiven) - model->BSIM4wvsat = 0.0; - if (!model->BSIM4watGiven) - model->BSIM4wat = 0.0; - if (!model->BSIM4wa0Given) - model->BSIM4wa0 = 0.0; - if (!model->BSIM4wagsGiven) - model->BSIM4wags = 0.0; - if (!model->BSIM4wa1Given) - model->BSIM4wa1 = 0.0; - if (!model->BSIM4wa2Given) - model->BSIM4wa2 = 0.0; - if (!model->BSIM4wketaGiven) - model->BSIM4wketa = 0.0; - if (!model->BSIM4wnsubGiven) - model->BSIM4wnsub = 0.0; - if (!model->BSIM4wndepGiven) - model->BSIM4wndep = 0.0; - if (!model->BSIM4wnsdGiven) - model->BSIM4wnsd = 0.0; - if (!model->BSIM4wphinGiven) - model->BSIM4wphin = 0.0; - if (!model->BSIM4wngateGiven) - model->BSIM4wngate = 0.0; - if (!model->BSIM4wvbmGiven) - model->BSIM4wvbm = 0.0; - if (!model->BSIM4wxtGiven) - model->BSIM4wxt = 0.0; - if (!model->BSIM4wkt1Given) - model->BSIM4wkt1 = 0.0; - if (!model->BSIM4wkt1lGiven) - model->BSIM4wkt1l = 0.0; - if (!model->BSIM4wkt2Given) - model->BSIM4wkt2 = 0.0; - if (!model->BSIM4wk3Given) - model->BSIM4wk3 = 0.0; - if (!model->BSIM4wk3bGiven) - model->BSIM4wk3b = 0.0; - if (!model->BSIM4ww0Given) - model->BSIM4ww0 = 0.0; - if (!model->BSIM4wlpe0Given) - model->BSIM4wlpe0 = 0.0; - if (!model->BSIM4wlpebGiven) - model->BSIM4wlpeb = 0.0; - if (!model->BSIM4wdvtp0Given) - model->BSIM4wdvtp0 = 0.0; - if (!model->BSIM4wdvtp1Given) - model->BSIM4wdvtp1 = 0.0; - if (!model->BSIM4wdvtp2Given) /* New DIBL/Rout */ - model->BSIM4wdvtp2 = 0.0; - if (!model->BSIM4wdvtp3Given) - model->BSIM4wdvtp3 = 0.0; - if (!model->BSIM4wdvtp4Given) - model->BSIM4wdvtp4 = 0.0; - if (!model->BSIM4wdvtp5Given) - model->BSIM4wdvtp5 = 0.0; - if (!model->BSIM4wdvt0Given) - model->BSIM4wdvt0 = 0.0; - if (!model->BSIM4wdvt1Given) - model->BSIM4wdvt1 = 0.0; - if (!model->BSIM4wdvt2Given) - model->BSIM4wdvt2 = 0.0; - if (!model->BSIM4wdvt0wGiven) - model->BSIM4wdvt0w = 0.0; - if (!model->BSIM4wdvt1wGiven) - model->BSIM4wdvt1w = 0.0; - if (!model->BSIM4wdvt2wGiven) - model->BSIM4wdvt2w = 0.0; - if (!model->BSIM4wdroutGiven) - model->BSIM4wdrout = 0.0; - if (!model->BSIM4wdsubGiven) - model->BSIM4wdsub = 0.0; - if (!model->BSIM4wvth0Given) - model->BSIM4wvth0 = 0.0; - if (!model->BSIM4wuaGiven) - model->BSIM4wua = 0.0; - if (!model->BSIM4wua1Given) - model->BSIM4wua1 = 0.0; - if (!model->BSIM4wubGiven) - model->BSIM4wub = 0.0; - if (!model->BSIM4wub1Given) - model->BSIM4wub1 = 0.0; - if (!model->BSIM4wucGiven) - model->BSIM4wuc = 0.0; - if (!model->BSIM4wuc1Given) - model->BSIM4wuc1 = 0.0; - if (!model->BSIM4wudGiven) - model->BSIM4wud = 0.0; - if (!model->BSIM4wud1Given) - model->BSIM4wud1 = 0.0; - if (!model->BSIM4wupGiven) - model->BSIM4wup = 0.0; - if (!model->BSIM4wlpGiven) - model->BSIM4wlp = 0.0; - if (!model->BSIM4wu0Given) - model->BSIM4wu0 = 0.0; - if (!model->BSIM4wuteGiven) - model->BSIM4wute = 0.0; - if (!model->BSIM4wucsteGiven) - model->BSIM4wucste = 0.0; - if (!model->BSIM4wvoffGiven) - model->BSIM4wvoff = 0.0; - if (!model->BSIM4wminvGiven) - model->BSIM4wminv = 0.0; - if (!model->BSIM4wminvcvGiven) - model->BSIM4wminvcv = 0.0; - if (!model->BSIM4wfproutGiven) - model->BSIM4wfprout = 0.0; - if (!model->BSIM4wpditsGiven) - model->BSIM4wpdits = 0.0; - if (!model->BSIM4wpditsdGiven) - model->BSIM4wpditsd = 0.0; - if (!model->BSIM4wdeltaGiven) - model->BSIM4wdelta = 0.0; - if (!model->BSIM4wrdswGiven) - model->BSIM4wrdsw = 0.0; - if (!model->BSIM4wrdwGiven) - model->BSIM4wrdw = 0.0; - if (!model->BSIM4wrswGiven) - model->BSIM4wrsw = 0.0; - if (!model->BSIM4wprwbGiven) - model->BSIM4wprwb = 0.0; - if (!model->BSIM4wprwgGiven) - model->BSIM4wprwg = 0.0; - if (!model->BSIM4wprtGiven) - model->BSIM4wprt = 0.0; - if (!model->BSIM4weta0Given) - model->BSIM4weta0 = 0.0; - if (!model->BSIM4wetabGiven) - model->BSIM4wetab = 0.0; - if (!model->BSIM4wpclmGiven) - model->BSIM4wpclm = 0.0; - if (!model->BSIM4wpdibl1Given) - model->BSIM4wpdibl1 = 0.0; - if (!model->BSIM4wpdibl2Given) - model->BSIM4wpdibl2 = 0.0; - if (!model->BSIM4wpdiblbGiven) - model->BSIM4wpdiblb = 0.0; - if (!model->BSIM4wpscbe1Given) - model->BSIM4wpscbe1 = 0.0; - if (!model->BSIM4wpscbe2Given) - model->BSIM4wpscbe2 = 0.0; - if (!model->BSIM4wpvagGiven) - model->BSIM4wpvag = 0.0; - if (!model->BSIM4wwrGiven) - model->BSIM4wwr = 0.0; - if (!model->BSIM4wdwgGiven) - model->BSIM4wdwg = 0.0; - if (!model->BSIM4wdwbGiven) - model->BSIM4wdwb = 0.0; - if (!model->BSIM4wb0Given) - model->BSIM4wb0 = 0.0; - if (!model->BSIM4wb1Given) - model->BSIM4wb1 = 0.0; - if (!model->BSIM4walpha0Given) - model->BSIM4walpha0 = 0.0; - if (!model->BSIM4walpha1Given) - model->BSIM4walpha1 = 0.0; - if (!model->BSIM4wbeta0Given) - model->BSIM4wbeta0 = 0.0; - if (!model->BSIM4wagidlGiven) - model->BSIM4wagidl = 0.0; - if (!model->BSIM4wbgidlGiven) - model->BSIM4wbgidl = 0.0; - if (!model->BSIM4wcgidlGiven) - model->BSIM4wcgidl = 0.0; - if (!model->BSIM4wegidlGiven) - model->BSIM4wegidl = 0.0; - if (!model->BSIM4wrgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4wrgidl = 0.0; - if (!model->BSIM4wkgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4wkgidl = 0.0; - if (!model->BSIM4wfgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4wfgidl = 0.0; + if (!model->BSIM4v7wcdscGiven) + model->BSIM4v7wcdsc = 0.0; + if (!model->BSIM4v7wcdscbGiven) + model->BSIM4v7wcdscb = 0.0; + if (!model->BSIM4v7wcdscdGiven) + model->BSIM4v7wcdscd = 0.0; + if (!model->BSIM4v7wcitGiven) + model->BSIM4v7wcit = 0.0; + if (!model->BSIM4v7wnfactorGiven) + model->BSIM4v7wnfactor = 0.0; + if (!model->BSIM4v7wxjGiven) + model->BSIM4v7wxj = 0.0; + if (!model->BSIM4v7wvsatGiven) + model->BSIM4v7wvsat = 0.0; + if (!model->BSIM4v7watGiven) + model->BSIM4v7wat = 0.0; + if (!model->BSIM4v7wa0Given) + model->BSIM4v7wa0 = 0.0; + if (!model->BSIM4v7wagsGiven) + model->BSIM4v7wags = 0.0; + if (!model->BSIM4v7wa1Given) + model->BSIM4v7wa1 = 0.0; + if (!model->BSIM4v7wa2Given) + model->BSIM4v7wa2 = 0.0; + if (!model->BSIM4v7wketaGiven) + model->BSIM4v7wketa = 0.0; + if (!model->BSIM4v7wnsubGiven) + model->BSIM4v7wnsub = 0.0; + if (!model->BSIM4v7wndepGiven) + model->BSIM4v7wndep = 0.0; + if (!model->BSIM4v7wnsdGiven) + model->BSIM4v7wnsd = 0.0; + if (!model->BSIM4v7wphinGiven) + model->BSIM4v7wphin = 0.0; + if (!model->BSIM4v7wngateGiven) + model->BSIM4v7wngate = 0.0; + if (!model->BSIM4v7wvbmGiven) + model->BSIM4v7wvbm = 0.0; + if (!model->BSIM4v7wxtGiven) + model->BSIM4v7wxt = 0.0; + if (!model->BSIM4v7wkt1Given) + model->BSIM4v7wkt1 = 0.0; + if (!model->BSIM4v7wkt1lGiven) + model->BSIM4v7wkt1l = 0.0; + if (!model->BSIM4v7wkt2Given) + model->BSIM4v7wkt2 = 0.0; + if (!model->BSIM4v7wk3Given) + model->BSIM4v7wk3 = 0.0; + if (!model->BSIM4v7wk3bGiven) + model->BSIM4v7wk3b = 0.0; + if (!model->BSIM4v7ww0Given) + model->BSIM4v7ww0 = 0.0; + if (!model->BSIM4v7wlpe0Given) + model->BSIM4v7wlpe0 = 0.0; + if (!model->BSIM4v7wlpebGiven) + model->BSIM4v7wlpeb = 0.0; + if (!model->BSIM4v7wdvtp0Given) + model->BSIM4v7wdvtp0 = 0.0; + if (!model->BSIM4v7wdvtp1Given) + model->BSIM4v7wdvtp1 = 0.0; + if (!model->BSIM4v7wdvtp2Given) /* New DIBL/Rout */ + model->BSIM4v7wdvtp2 = 0.0; + if (!model->BSIM4v7wdvtp3Given) + model->BSIM4v7wdvtp3 = 0.0; + if (!model->BSIM4v7wdvtp4Given) + model->BSIM4v7wdvtp4 = 0.0; + if (!model->BSIM4v7wdvtp5Given) + model->BSIM4v7wdvtp5 = 0.0; + if (!model->BSIM4v7wdvt0Given) + model->BSIM4v7wdvt0 = 0.0; + if (!model->BSIM4v7wdvt1Given) + model->BSIM4v7wdvt1 = 0.0; + if (!model->BSIM4v7wdvt2Given) + model->BSIM4v7wdvt2 = 0.0; + if (!model->BSIM4v7wdvt0wGiven) + model->BSIM4v7wdvt0w = 0.0; + if (!model->BSIM4v7wdvt1wGiven) + model->BSIM4v7wdvt1w = 0.0; + if (!model->BSIM4v7wdvt2wGiven) + model->BSIM4v7wdvt2w = 0.0; + if (!model->BSIM4v7wdroutGiven) + model->BSIM4v7wdrout = 0.0; + if (!model->BSIM4v7wdsubGiven) + model->BSIM4v7wdsub = 0.0; + if (!model->BSIM4v7wvth0Given) + model->BSIM4v7wvth0 = 0.0; + if (!model->BSIM4v7wuaGiven) + model->BSIM4v7wua = 0.0; + if (!model->BSIM4v7wua1Given) + model->BSIM4v7wua1 = 0.0; + if (!model->BSIM4v7wubGiven) + model->BSIM4v7wub = 0.0; + if (!model->BSIM4v7wub1Given) + model->BSIM4v7wub1 = 0.0; + if (!model->BSIM4v7wucGiven) + model->BSIM4v7wuc = 0.0; + if (!model->BSIM4v7wuc1Given) + model->BSIM4v7wuc1 = 0.0; + if (!model->BSIM4v7wudGiven) + model->BSIM4v7wud = 0.0; + if (!model->BSIM4v7wud1Given) + model->BSIM4v7wud1 = 0.0; + if (!model->BSIM4v7wupGiven) + model->BSIM4v7wup = 0.0; + if (!model->BSIM4v7wlpGiven) + model->BSIM4v7wlp = 0.0; + if (!model->BSIM4v7wu0Given) + model->BSIM4v7wu0 = 0.0; + if (!model->BSIM4v7wuteGiven) + model->BSIM4v7wute = 0.0; + if (!model->BSIM4v7wucsteGiven) + model->BSIM4v7wucste = 0.0; + if (!model->BSIM4v7wvoffGiven) + model->BSIM4v7wvoff = 0.0; + if (!model->BSIM4v7wminvGiven) + model->BSIM4v7wminv = 0.0; + if (!model->BSIM4v7wminvcvGiven) + model->BSIM4v7wminvcv = 0.0; + if (!model->BSIM4v7wfproutGiven) + model->BSIM4v7wfprout = 0.0; + if (!model->BSIM4v7wpditsGiven) + model->BSIM4v7wpdits = 0.0; + if (!model->BSIM4v7wpditsdGiven) + model->BSIM4v7wpditsd = 0.0; + if (!model->BSIM4v7wdeltaGiven) + model->BSIM4v7wdelta = 0.0; + if (!model->BSIM4v7wrdswGiven) + model->BSIM4v7wrdsw = 0.0; + if (!model->BSIM4v7wrdwGiven) + model->BSIM4v7wrdw = 0.0; + if (!model->BSIM4v7wrswGiven) + model->BSIM4v7wrsw = 0.0; + if (!model->BSIM4v7wprwbGiven) + model->BSIM4v7wprwb = 0.0; + if (!model->BSIM4v7wprwgGiven) + model->BSIM4v7wprwg = 0.0; + if (!model->BSIM4v7wprtGiven) + model->BSIM4v7wprt = 0.0; + if (!model->BSIM4v7weta0Given) + model->BSIM4v7weta0 = 0.0; + if (!model->BSIM4v7wetabGiven) + model->BSIM4v7wetab = 0.0; + if (!model->BSIM4v7wpclmGiven) + model->BSIM4v7wpclm = 0.0; + if (!model->BSIM4v7wpdibl1Given) + model->BSIM4v7wpdibl1 = 0.0; + if (!model->BSIM4v7wpdibl2Given) + model->BSIM4v7wpdibl2 = 0.0; + if (!model->BSIM4v7wpdiblbGiven) + model->BSIM4v7wpdiblb = 0.0; + if (!model->BSIM4v7wpscbe1Given) + model->BSIM4v7wpscbe1 = 0.0; + if (!model->BSIM4v7wpscbe2Given) + model->BSIM4v7wpscbe2 = 0.0; + if (!model->BSIM4v7wpvagGiven) + model->BSIM4v7wpvag = 0.0; + if (!model->BSIM4v7wwrGiven) + model->BSIM4v7wwr = 0.0; + if (!model->BSIM4v7wdwgGiven) + model->BSIM4v7wdwg = 0.0; + if (!model->BSIM4v7wdwbGiven) + model->BSIM4v7wdwb = 0.0; + if (!model->BSIM4v7wb0Given) + model->BSIM4v7wb0 = 0.0; + if (!model->BSIM4v7wb1Given) + model->BSIM4v7wb1 = 0.0; + if (!model->BSIM4v7walpha0Given) + model->BSIM4v7walpha0 = 0.0; + if (!model->BSIM4v7walpha1Given) + model->BSIM4v7walpha1 = 0.0; + if (!model->BSIM4v7wbeta0Given) + model->BSIM4v7wbeta0 = 0.0; + if (!model->BSIM4v7wagidlGiven) + model->BSIM4v7wagidl = 0.0; + if (!model->BSIM4v7wbgidlGiven) + model->BSIM4v7wbgidl = 0.0; + if (!model->BSIM4v7wcgidlGiven) + model->BSIM4v7wcgidl = 0.0; + if (!model->BSIM4v7wegidlGiven) + model->BSIM4v7wegidl = 0.0; + if (!model->BSIM4v7wrgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7wrgidl = 0.0; + if (!model->BSIM4v7wkgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7wkgidl = 0.0; + if (!model->BSIM4v7wfgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7wfgidl = 0.0; - if (!model->BSIM4wagislGiven) + if (!model->BSIM4v7wagislGiven) { - if (model->BSIM4wagidlGiven) - model->BSIM4wagisl = model->BSIM4wagidl; + if (model->BSIM4v7wagidlGiven) + model->BSIM4v7wagisl = model->BSIM4v7wagidl; else - model->BSIM4wagisl = 0.0; + model->BSIM4v7wagisl = 0.0; } - if (!model->BSIM4wbgislGiven) + if (!model->BSIM4v7wbgislGiven) { - if (model->BSIM4wbgidlGiven) - model->BSIM4wbgisl = model->BSIM4wbgidl; + if (model->BSIM4v7wbgidlGiven) + model->BSIM4v7wbgisl = model->BSIM4v7wbgidl; else - model->BSIM4wbgisl = 0.0; + model->BSIM4v7wbgisl = 0.0; } - if (!model->BSIM4wcgislGiven) + if (!model->BSIM4v7wcgislGiven) { - if (model->BSIM4wcgidlGiven) - model->BSIM4wcgisl = model->BSIM4wcgidl; + if (model->BSIM4v7wcgidlGiven) + model->BSIM4v7wcgisl = model->BSIM4v7wcgidl; else - model->BSIM4wcgisl = 0.0; + model->BSIM4v7wcgisl = 0.0; } - if (!model->BSIM4wegislGiven) + if (!model->BSIM4v7wegislGiven) { - if (model->BSIM4wegidlGiven) - model->BSIM4wegisl = model->BSIM4wegidl; + if (model->BSIM4v7wegidlGiven) + model->BSIM4v7wegisl = model->BSIM4v7wegidl; else - model->BSIM4wegisl = 0.0; + model->BSIM4v7wegisl = 0.0; } - if (!model->BSIM4wrgislGiven) /* v4.7 New GIDL/GISL */ + if (!model->BSIM4v7wrgislGiven) /* v4.7 New GIDL/GISL */ { - if (model->BSIM4wrgidlGiven) - model->BSIM4wrgisl = model->BSIM4wrgidl; + if (model->BSIM4v7wrgidlGiven) + model->BSIM4v7wrgisl = model->BSIM4v7wrgidl; } - if (!model->BSIM4wkgislGiven) /* v4.7 New GIDL/GISL */ + if (!model->BSIM4v7wkgislGiven) /* v4.7 New GIDL/GISL */ { - if (model->BSIM4wkgidlGiven) - model->BSIM4wkgisl = model->BSIM4wkgidl; + if (model->BSIM4v7wkgidlGiven) + model->BSIM4v7wkgisl = model->BSIM4v7wkgidl; } - if (!model->BSIM4wfgislGiven) /* v4.7 New GIDL/GISL */ + if (!model->BSIM4v7wfgislGiven) /* v4.7 New GIDL/GISL */ { - if (model->BSIM4wfgidlGiven) - model->BSIM4wfgisl = model->BSIM4wfgidl; + if (model->BSIM4v7wfgidlGiven) + model->BSIM4v7wfgisl = model->BSIM4v7wfgidl; } - if (!model->BSIM4waigcGiven) - model->BSIM4waigc = 0.0; - if (!model->BSIM4wbigcGiven) - model->BSIM4wbigc = 0.0; - if (!model->BSIM4wcigcGiven) - model->BSIM4wcigc = 0.0; - if (!model->BSIM4aigsdGiven && (model->BSIM4aigsGiven || model->BSIM4aigdGiven)) + if (!model->BSIM4v7waigcGiven) + model->BSIM4v7waigc = 0.0; + if (!model->BSIM4v7wbigcGiven) + model->BSIM4v7wbigc = 0.0; + if (!model->BSIM4v7wcigcGiven) + model->BSIM4v7wcigc = 0.0; + if (!model->BSIM4v7aigsdGiven && (model->BSIM4v7aigsGiven || model->BSIM4v7aigdGiven)) { - if (!model->BSIM4waigsGiven) - model->BSIM4waigs = 0.0; - if (!model->BSIM4waigdGiven) - model->BSIM4waigd = 0.0; + if (!model->BSIM4v7waigsGiven) + model->BSIM4v7waigs = 0.0; + if (!model->BSIM4v7waigdGiven) + model->BSIM4v7waigd = 0.0; } else { - if (!model->BSIM4waigsdGiven) - model->BSIM4waigsd = 0.0; - model->BSIM4waigs = model->BSIM4waigd = model->BSIM4waigsd; + if (!model->BSIM4v7waigsdGiven) + model->BSIM4v7waigsd = 0.0; + model->BSIM4v7waigs = model->BSIM4v7waigd = model->BSIM4v7waigsd; } - if (!model->BSIM4bigsdGiven && (model->BSIM4bigsGiven || model->BSIM4bigdGiven)) + if (!model->BSIM4v7bigsdGiven && (model->BSIM4v7bigsGiven || model->BSIM4v7bigdGiven)) { - if (!model->BSIM4wbigsGiven) - model->BSIM4wbigs = 0.0; - if (!model->BSIM4wbigdGiven) - model->BSIM4wbigd = 0.0; + if (!model->BSIM4v7wbigsGiven) + model->BSIM4v7wbigs = 0.0; + if (!model->BSIM4v7wbigdGiven) + model->BSIM4v7wbigd = 0.0; } else { - if (!model->BSIM4wbigsdGiven) - model->BSIM4wbigsd = 0.0; - model->BSIM4wbigs = model->BSIM4wbigd = model->BSIM4wbigsd; + if (!model->BSIM4v7wbigsdGiven) + model->BSIM4v7wbigsd = 0.0; + model->BSIM4v7wbigs = model->BSIM4v7wbigd = model->BSIM4v7wbigsd; } - if (!model->BSIM4cigsdGiven && (model->BSIM4cigsGiven || model->BSIM4cigdGiven)) + if (!model->BSIM4v7cigsdGiven && (model->BSIM4v7cigsGiven || model->BSIM4v7cigdGiven)) { - if (!model->BSIM4wcigsGiven) - model->BSIM4wcigs = 0.0; - if (!model->BSIM4wcigdGiven) - model->BSIM4wcigd = 0.0; + if (!model->BSIM4v7wcigsGiven) + model->BSIM4v7wcigs = 0.0; + if (!model->BSIM4v7wcigdGiven) + model->BSIM4v7wcigd = 0.0; } else { - if (!model->BSIM4wcigsdGiven) - model->BSIM4wcigsd = 0.0; - model->BSIM4wcigs = model->BSIM4wcigd = model->BSIM4wcigsd; + if (!model->BSIM4v7wcigsdGiven) + model->BSIM4v7wcigsd = 0.0; + model->BSIM4v7wcigs = model->BSIM4v7wcigd = model->BSIM4v7wcigsd; } - if (!model->BSIM4waigbaccGiven) - model->BSIM4waigbacc = 0.0; - if (!model->BSIM4wbigbaccGiven) - model->BSIM4wbigbacc = 0.0; - if (!model->BSIM4wcigbaccGiven) - model->BSIM4wcigbacc = 0.0; - if (!model->BSIM4waigbinvGiven) - model->BSIM4waigbinv = 0.0; - if (!model->BSIM4wbigbinvGiven) - model->BSIM4wbigbinv = 0.0; - if (!model->BSIM4wcigbinvGiven) - model->BSIM4wcigbinv = 0.0; - if (!model->BSIM4wnigcGiven) - model->BSIM4wnigc = 0.0; - if (!model->BSIM4wnigbinvGiven) - model->BSIM4wnigbinv = 0.0; - if (!model->BSIM4wnigbaccGiven) - model->BSIM4wnigbacc = 0.0; - if (!model->BSIM4wntoxGiven) - model->BSIM4wntox = 0.0; - if (!model->BSIM4weigbinvGiven) - model->BSIM4weigbinv = 0.0; - if (!model->BSIM4wpigcdGiven) - model->BSIM4wpigcd = 0.0; - if (!model->BSIM4wpoxedgeGiven) - model->BSIM4wpoxedge = 0.0; - if (!model->BSIM4wxrcrg1Given) - model->BSIM4wxrcrg1 = 0.0; - if (!model->BSIM4wxrcrg2Given) - model->BSIM4wxrcrg2 = 0.0; - if (!model->BSIM4weuGiven) - model->BSIM4weu = 0.0; - if (!model->BSIM4wucsGiven) - model->BSIM4wucs = 0.0; - if (!model->BSIM4wvfbGiven) - model->BSIM4wvfb = 0.0; - if (!model->BSIM4wlambdaGiven) - model->BSIM4wlambda = 0.0; - if (!model->BSIM4wvtlGiven) - model->BSIM4wvtl = 0.0; - if (!model->BSIM4wxnGiven) - model->BSIM4wxn = 0.0; - if (!model->BSIM4wvfbsdoffGiven) - model->BSIM4wvfbsdoff = 0.0; - if (!model->BSIM4wtvfbsdoffGiven) - model->BSIM4wtvfbsdoff = 0.0; - if (!model->BSIM4wtvoffGiven) - model->BSIM4wtvoff = 0.0; - if (!model->BSIM4wtnfactorGiven) /* v4.7 temp dep of leakage current */ - model->BSIM4wtnfactor = 0.0; - if (!model->BSIM4wteta0Given) /* v4.7 temp dep of leakage current */ - model->BSIM4wteta0 = 0.0; - if (!model->BSIM4wtvoffcvGiven) /* v4.7 temp dep of leakage current */ - model->BSIM4wtvoffcv = 0.0; + if (!model->BSIM4v7waigbaccGiven) + model->BSIM4v7waigbacc = 0.0; + if (!model->BSIM4v7wbigbaccGiven) + model->BSIM4v7wbigbacc = 0.0; + if (!model->BSIM4v7wcigbaccGiven) + model->BSIM4v7wcigbacc = 0.0; + if (!model->BSIM4v7waigbinvGiven) + model->BSIM4v7waigbinv = 0.0; + if (!model->BSIM4v7wbigbinvGiven) + model->BSIM4v7wbigbinv = 0.0; + if (!model->BSIM4v7wcigbinvGiven) + model->BSIM4v7wcigbinv = 0.0; + if (!model->BSIM4v7wnigcGiven) + model->BSIM4v7wnigc = 0.0; + if (!model->BSIM4v7wnigbinvGiven) + model->BSIM4v7wnigbinv = 0.0; + if (!model->BSIM4v7wnigbaccGiven) + model->BSIM4v7wnigbacc = 0.0; + if (!model->BSIM4v7wntoxGiven) + model->BSIM4v7wntox = 0.0; + if (!model->BSIM4v7weigbinvGiven) + model->BSIM4v7weigbinv = 0.0; + if (!model->BSIM4v7wpigcdGiven) + model->BSIM4v7wpigcd = 0.0; + if (!model->BSIM4v7wpoxedgeGiven) + model->BSIM4v7wpoxedge = 0.0; + if (!model->BSIM4v7wxrcrg1Given) + model->BSIM4v7wxrcrg1 = 0.0; + if (!model->BSIM4v7wxrcrg2Given) + model->BSIM4v7wxrcrg2 = 0.0; + if (!model->BSIM4v7weuGiven) + model->BSIM4v7weu = 0.0; + if (!model->BSIM4v7wucsGiven) + model->BSIM4v7wucs = 0.0; + if (!model->BSIM4v7wvfbGiven) + model->BSIM4v7wvfb = 0.0; + if (!model->BSIM4v7wlambdaGiven) + model->BSIM4v7wlambda = 0.0; + if (!model->BSIM4v7wvtlGiven) + model->BSIM4v7wvtl = 0.0; + if (!model->BSIM4v7wxnGiven) + model->BSIM4v7wxn = 0.0; + if (!model->BSIM4v7wvfbsdoffGiven) + model->BSIM4v7wvfbsdoff = 0.0; + if (!model->BSIM4v7wtvfbsdoffGiven) + model->BSIM4v7wtvfbsdoff = 0.0; + if (!model->BSIM4v7wtvoffGiven) + model->BSIM4v7wtvoff = 0.0; + if (!model->BSIM4v7wtnfactorGiven) /* v4.7 temp dep of leakage current */ + model->BSIM4v7wtnfactor = 0.0; + if (!model->BSIM4v7wteta0Given) /* v4.7 temp dep of leakage current */ + model->BSIM4v7wteta0 = 0.0; + if (!model->BSIM4v7wtvoffcvGiven) /* v4.7 temp dep of leakage current */ + model->BSIM4v7wtvoffcv = 0.0; - if (!model->BSIM4wcgslGiven) - model->BSIM4wcgsl = 0.0; - if (!model->BSIM4wcgdlGiven) - model->BSIM4wcgdl = 0.0; - if (!model->BSIM4wckappasGiven) - model->BSIM4wckappas = 0.0; - if (!model->BSIM4wckappadGiven) - model->BSIM4wckappad = 0.0; - if (!model->BSIM4wcfGiven) - model->BSIM4wcf = 0.0; - if (!model->BSIM4wclcGiven) - model->BSIM4wclc = 0.0; - if (!model->BSIM4wcleGiven) - model->BSIM4wcle = 0.0; - if (!model->BSIM4wvfbcvGiven) - model->BSIM4wvfbcv = 0.0; - if (!model->BSIM4wacdeGiven) - model->BSIM4wacde = 0.0; - if (!model->BSIM4wmoinGiven) - model->BSIM4wmoin = 0.0; - if (!model->BSIM4wnoffGiven) - model->BSIM4wnoff = 0.0; - if (!model->BSIM4wvoffcvGiven) - model->BSIM4wvoffcv = 0.0; + if (!model->BSIM4v7wcgslGiven) + model->BSIM4v7wcgsl = 0.0; + if (!model->BSIM4v7wcgdlGiven) + model->BSIM4v7wcgdl = 0.0; + if (!model->BSIM4v7wckappasGiven) + model->BSIM4v7wckappas = 0.0; + if (!model->BSIM4v7wckappadGiven) + model->BSIM4v7wckappad = 0.0; + if (!model->BSIM4v7wcfGiven) + model->BSIM4v7wcf = 0.0; + if (!model->BSIM4v7wclcGiven) + model->BSIM4v7wclc = 0.0; + if (!model->BSIM4v7wcleGiven) + model->BSIM4v7wcle = 0.0; + if (!model->BSIM4v7wvfbcvGiven) + model->BSIM4v7wvfbcv = 0.0; + if (!model->BSIM4v7wacdeGiven) + model->BSIM4v7wacde = 0.0; + if (!model->BSIM4v7wmoinGiven) + model->BSIM4v7wmoin = 0.0; + if (!model->BSIM4v7wnoffGiven) + model->BSIM4v7wnoff = 0.0; + if (!model->BSIM4v7wvoffcvGiven) + model->BSIM4v7wvoffcv = 0.0; /* Cross-term dependence */ - if (!model->BSIM4pcdscGiven) - model->BSIM4pcdsc = 0.0; - if (!model->BSIM4pcdscbGiven) - model->BSIM4pcdscb = 0.0; - if (!model->BSIM4pcdscdGiven) - model->BSIM4pcdscd = 0.0; - if (!model->BSIM4pcitGiven) - model->BSIM4pcit = 0.0; - if (!model->BSIM4pnfactorGiven) - model->BSIM4pnfactor = 0.0; - if (!model->BSIM4pxjGiven) - model->BSIM4pxj = 0.0; - if (!model->BSIM4pvsatGiven) - model->BSIM4pvsat = 0.0; - if (!model->BSIM4patGiven) - model->BSIM4pat = 0.0; - if (!model->BSIM4pa0Given) - model->BSIM4pa0 = 0.0; + if (!model->BSIM4v7pcdscGiven) + model->BSIM4v7pcdsc = 0.0; + if (!model->BSIM4v7pcdscbGiven) + model->BSIM4v7pcdscb = 0.0; + if (!model->BSIM4v7pcdscdGiven) + model->BSIM4v7pcdscd = 0.0; + if (!model->BSIM4v7pcitGiven) + model->BSIM4v7pcit = 0.0; + if (!model->BSIM4v7pnfactorGiven) + model->BSIM4v7pnfactor = 0.0; + if (!model->BSIM4v7pxjGiven) + model->BSIM4v7pxj = 0.0; + if (!model->BSIM4v7pvsatGiven) + model->BSIM4v7pvsat = 0.0; + if (!model->BSIM4v7patGiven) + model->BSIM4v7pat = 0.0; + if (!model->BSIM4v7pa0Given) + model->BSIM4v7pa0 = 0.0; - if (!model->BSIM4pagsGiven) - model->BSIM4pags = 0.0; - if (!model->BSIM4pa1Given) - model->BSIM4pa1 = 0.0; - if (!model->BSIM4pa2Given) - model->BSIM4pa2 = 0.0; - if (!model->BSIM4pketaGiven) - model->BSIM4pketa = 0.0; - if (!model->BSIM4pnsubGiven) - model->BSIM4pnsub = 0.0; - if (!model->BSIM4pndepGiven) - model->BSIM4pndep = 0.0; - if (!model->BSIM4pnsdGiven) - model->BSIM4pnsd = 0.0; - if (!model->BSIM4pphinGiven) - model->BSIM4pphin = 0.0; - if (!model->BSIM4pngateGiven) - model->BSIM4pngate = 0.0; - if (!model->BSIM4pvbmGiven) - model->BSIM4pvbm = 0.0; - if (!model->BSIM4pxtGiven) - model->BSIM4pxt = 0.0; - if (!model->BSIM4pkt1Given) - model->BSIM4pkt1 = 0.0; - if (!model->BSIM4pkt1lGiven) - model->BSIM4pkt1l = 0.0; - if (!model->BSIM4pkt2Given) - model->BSIM4pkt2 = 0.0; - if (!model->BSIM4pk3Given) - model->BSIM4pk3 = 0.0; - if (!model->BSIM4pk3bGiven) - model->BSIM4pk3b = 0.0; - if (!model->BSIM4pw0Given) - model->BSIM4pw0 = 0.0; - if (!model->BSIM4plpe0Given) - model->BSIM4plpe0 = 0.0; - if (!model->BSIM4plpebGiven) - model->BSIM4plpeb = 0.0; - if (!model->BSIM4pdvtp0Given) - model->BSIM4pdvtp0 = 0.0; - if (!model->BSIM4pdvtp1Given) - model->BSIM4pdvtp1 = 0.0; - if (!model->BSIM4pdvtp2Given) /* New DIBL/Rout */ - model->BSIM4pdvtp2 = 0.0; - if (!model->BSIM4pdvtp3Given) - model->BSIM4pdvtp3 = 0.0; - if (!model->BSIM4pdvtp4Given) - model->BSIM4pdvtp4 = 0.0; - if (!model->BSIM4pdvtp5Given) - model->BSIM4pdvtp5 = 0.0; - if (!model->BSIM4pdvt0Given) - model->BSIM4pdvt0 = 0.0; - if (!model->BSIM4pdvt1Given) - model->BSIM4pdvt1 = 0.0; - if (!model->BSIM4pdvt2Given) - model->BSIM4pdvt2 = 0.0; - if (!model->BSIM4pdvt0wGiven) - model->BSIM4pdvt0w = 0.0; - if (!model->BSIM4pdvt1wGiven) - model->BSIM4pdvt1w = 0.0; - if (!model->BSIM4pdvt2wGiven) - model->BSIM4pdvt2w = 0.0; - if (!model->BSIM4pdroutGiven) - model->BSIM4pdrout = 0.0; - if (!model->BSIM4pdsubGiven) - model->BSIM4pdsub = 0.0; - if (!model->BSIM4pvth0Given) - model->BSIM4pvth0 = 0.0; - if (!model->BSIM4puaGiven) - model->BSIM4pua = 0.0; - if (!model->BSIM4pua1Given) - model->BSIM4pua1 = 0.0; - if (!model->BSIM4pubGiven) - model->BSIM4pub = 0.0; - if (!model->BSIM4pub1Given) - model->BSIM4pub1 = 0.0; - if (!model->BSIM4pucGiven) - model->BSIM4puc = 0.0; - if (!model->BSIM4puc1Given) - model->BSIM4puc1 = 0.0; - if (!model->BSIM4pudGiven) - model->BSIM4pud = 0.0; - if (!model->BSIM4pud1Given) - model->BSIM4pud1 = 0.0; - if (!model->BSIM4pupGiven) - model->BSIM4pup = 0.0; - if (!model->BSIM4plpGiven) - model->BSIM4plp = 0.0; - if (!model->BSIM4pu0Given) - model->BSIM4pu0 = 0.0; - if (!model->BSIM4puteGiven) - model->BSIM4pute = 0.0; - if (!model->BSIM4pucsteGiven) - model->BSIM4pucste = 0.0; - if (!model->BSIM4pvoffGiven) - model->BSIM4pvoff = 0.0; - if (!model->BSIM4pminvGiven) - model->BSIM4pminv = 0.0; - if (!model->BSIM4pminvcvGiven) - model->BSIM4pminvcv = 0.0; - if (!model->BSIM4pfproutGiven) - model->BSIM4pfprout = 0.0; - if (!model->BSIM4ppditsGiven) - model->BSIM4ppdits = 0.0; - if (!model->BSIM4ppditsdGiven) - model->BSIM4ppditsd = 0.0; - if (!model->BSIM4pdeltaGiven) - model->BSIM4pdelta = 0.0; - if (!model->BSIM4prdswGiven) - model->BSIM4prdsw = 0.0; - if (!model->BSIM4prdwGiven) - model->BSIM4prdw = 0.0; - if (!model->BSIM4prswGiven) - model->BSIM4prsw = 0.0; - if (!model->BSIM4pprwbGiven) - model->BSIM4pprwb = 0.0; - if (!model->BSIM4pprwgGiven) - model->BSIM4pprwg = 0.0; - if (!model->BSIM4pprtGiven) - model->BSIM4pprt = 0.0; - if (!model->BSIM4peta0Given) - model->BSIM4peta0 = 0.0; - if (!model->BSIM4petabGiven) - model->BSIM4petab = 0.0; - if (!model->BSIM4ppclmGiven) - model->BSIM4ppclm = 0.0; - if (!model->BSIM4ppdibl1Given) - model->BSIM4ppdibl1 = 0.0; - if (!model->BSIM4ppdibl2Given) - model->BSIM4ppdibl2 = 0.0; - if (!model->BSIM4ppdiblbGiven) - model->BSIM4ppdiblb = 0.0; - if (!model->BSIM4ppscbe1Given) - model->BSIM4ppscbe1 = 0.0; - if (!model->BSIM4ppscbe2Given) - model->BSIM4ppscbe2 = 0.0; - if (!model->BSIM4ppvagGiven) - model->BSIM4ppvag = 0.0; - if (!model->BSIM4pwrGiven) - model->BSIM4pwr = 0.0; - if (!model->BSIM4pdwgGiven) - model->BSIM4pdwg = 0.0; - if (!model->BSIM4pdwbGiven) - model->BSIM4pdwb = 0.0; - if (!model->BSIM4pb0Given) - model->BSIM4pb0 = 0.0; - if (!model->BSIM4pb1Given) - model->BSIM4pb1 = 0.0; - if (!model->BSIM4palpha0Given) - model->BSIM4palpha0 = 0.0; - if (!model->BSIM4palpha1Given) - model->BSIM4palpha1 = 0.0; - if (!model->BSIM4pbeta0Given) - model->BSIM4pbeta0 = 0.0; - if (!model->BSIM4pagidlGiven) - model->BSIM4pagidl = 0.0; - if (!model->BSIM4pbgidlGiven) - model->BSIM4pbgidl = 0.0; - if (!model->BSIM4pcgidlGiven) - model->BSIM4pcgidl = 0.0; - if (!model->BSIM4pegidlGiven) - model->BSIM4pegidl = 0.0; - if (!model->BSIM4prgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4prgidl = 0.0; - if (!model->BSIM4pkgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4pkgidl = 0.0; - if (!model->BSIM4pfgidlGiven) /* v4.7 New GIDL/GISL */ - model->BSIM4pfgidl = 0.0; + if (!model->BSIM4v7pagsGiven) + model->BSIM4v7pags = 0.0; + if (!model->BSIM4v7pa1Given) + model->BSIM4v7pa1 = 0.0; + if (!model->BSIM4v7pa2Given) + model->BSIM4v7pa2 = 0.0; + if (!model->BSIM4v7pketaGiven) + model->BSIM4v7pketa = 0.0; + if (!model->BSIM4v7pnsubGiven) + model->BSIM4v7pnsub = 0.0; + if (!model->BSIM4v7pndepGiven) + model->BSIM4v7pndep = 0.0; + if (!model->BSIM4v7pnsdGiven) + model->BSIM4v7pnsd = 0.0; + if (!model->BSIM4v7pphinGiven) + model->BSIM4v7pphin = 0.0; + if (!model->BSIM4v7pngateGiven) + model->BSIM4v7pngate = 0.0; + if (!model->BSIM4v7pvbmGiven) + model->BSIM4v7pvbm = 0.0; + if (!model->BSIM4v7pxtGiven) + model->BSIM4v7pxt = 0.0; + if (!model->BSIM4v7pkt1Given) + model->BSIM4v7pkt1 = 0.0; + if (!model->BSIM4v7pkt1lGiven) + model->BSIM4v7pkt1l = 0.0; + if (!model->BSIM4v7pkt2Given) + model->BSIM4v7pkt2 = 0.0; + if (!model->BSIM4v7pk3Given) + model->BSIM4v7pk3 = 0.0; + if (!model->BSIM4v7pk3bGiven) + model->BSIM4v7pk3b = 0.0; + if (!model->BSIM4v7pw0Given) + model->BSIM4v7pw0 = 0.0; + if (!model->BSIM4v7plpe0Given) + model->BSIM4v7plpe0 = 0.0; + if (!model->BSIM4v7plpebGiven) + model->BSIM4v7plpeb = 0.0; + if (!model->BSIM4v7pdvtp0Given) + model->BSIM4v7pdvtp0 = 0.0; + if (!model->BSIM4v7pdvtp1Given) + model->BSIM4v7pdvtp1 = 0.0; + if (!model->BSIM4v7pdvtp2Given) /* New DIBL/Rout */ + model->BSIM4v7pdvtp2 = 0.0; + if (!model->BSIM4v7pdvtp3Given) + model->BSIM4v7pdvtp3 = 0.0; + if (!model->BSIM4v7pdvtp4Given) + model->BSIM4v7pdvtp4 = 0.0; + if (!model->BSIM4v7pdvtp5Given) + model->BSIM4v7pdvtp5 = 0.0; + if (!model->BSIM4v7pdvt0Given) + model->BSIM4v7pdvt0 = 0.0; + if (!model->BSIM4v7pdvt1Given) + model->BSIM4v7pdvt1 = 0.0; + if (!model->BSIM4v7pdvt2Given) + model->BSIM4v7pdvt2 = 0.0; + if (!model->BSIM4v7pdvt0wGiven) + model->BSIM4v7pdvt0w = 0.0; + if (!model->BSIM4v7pdvt1wGiven) + model->BSIM4v7pdvt1w = 0.0; + if (!model->BSIM4v7pdvt2wGiven) + model->BSIM4v7pdvt2w = 0.0; + if (!model->BSIM4v7pdroutGiven) + model->BSIM4v7pdrout = 0.0; + if (!model->BSIM4v7pdsubGiven) + model->BSIM4v7pdsub = 0.0; + if (!model->BSIM4v7pvth0Given) + model->BSIM4v7pvth0 = 0.0; + if (!model->BSIM4v7puaGiven) + model->BSIM4v7pua = 0.0; + if (!model->BSIM4v7pua1Given) + model->BSIM4v7pua1 = 0.0; + if (!model->BSIM4v7pubGiven) + model->BSIM4v7pub = 0.0; + if (!model->BSIM4v7pub1Given) + model->BSIM4v7pub1 = 0.0; + if (!model->BSIM4v7pucGiven) + model->BSIM4v7puc = 0.0; + if (!model->BSIM4v7puc1Given) + model->BSIM4v7puc1 = 0.0; + if (!model->BSIM4v7pudGiven) + model->BSIM4v7pud = 0.0; + if (!model->BSIM4v7pud1Given) + model->BSIM4v7pud1 = 0.0; + if (!model->BSIM4v7pupGiven) + model->BSIM4v7pup = 0.0; + if (!model->BSIM4v7plpGiven) + model->BSIM4v7plp = 0.0; + if (!model->BSIM4v7pu0Given) + model->BSIM4v7pu0 = 0.0; + if (!model->BSIM4v7puteGiven) + model->BSIM4v7pute = 0.0; + if (!model->BSIM4v7pucsteGiven) + model->BSIM4v7pucste = 0.0; + if (!model->BSIM4v7pvoffGiven) + model->BSIM4v7pvoff = 0.0; + if (!model->BSIM4v7pminvGiven) + model->BSIM4v7pminv = 0.0; + if (!model->BSIM4v7pminvcvGiven) + model->BSIM4v7pminvcv = 0.0; + if (!model->BSIM4v7pfproutGiven) + model->BSIM4v7pfprout = 0.0; + if (!model->BSIM4v7ppditsGiven) + model->BSIM4v7ppdits = 0.0; + if (!model->BSIM4v7ppditsdGiven) + model->BSIM4v7ppditsd = 0.0; + if (!model->BSIM4v7pdeltaGiven) + model->BSIM4v7pdelta = 0.0; + if (!model->BSIM4v7prdswGiven) + model->BSIM4v7prdsw = 0.0; + if (!model->BSIM4v7prdwGiven) + model->BSIM4v7prdw = 0.0; + if (!model->BSIM4v7prswGiven) + model->BSIM4v7prsw = 0.0; + if (!model->BSIM4v7pprwbGiven) + model->BSIM4v7pprwb = 0.0; + if (!model->BSIM4v7pprwgGiven) + model->BSIM4v7pprwg = 0.0; + if (!model->BSIM4v7pprtGiven) + model->BSIM4v7pprt = 0.0; + if (!model->BSIM4v7peta0Given) + model->BSIM4v7peta0 = 0.0; + if (!model->BSIM4v7petabGiven) + model->BSIM4v7petab = 0.0; + if (!model->BSIM4v7ppclmGiven) + model->BSIM4v7ppclm = 0.0; + if (!model->BSIM4v7ppdibl1Given) + model->BSIM4v7ppdibl1 = 0.0; + if (!model->BSIM4v7ppdibl2Given) + model->BSIM4v7ppdibl2 = 0.0; + if (!model->BSIM4v7ppdiblbGiven) + model->BSIM4v7ppdiblb = 0.0; + if (!model->BSIM4v7ppscbe1Given) + model->BSIM4v7ppscbe1 = 0.0; + if (!model->BSIM4v7ppscbe2Given) + model->BSIM4v7ppscbe2 = 0.0; + if (!model->BSIM4v7ppvagGiven) + model->BSIM4v7ppvag = 0.0; + if (!model->BSIM4v7pwrGiven) + model->BSIM4v7pwr = 0.0; + if (!model->BSIM4v7pdwgGiven) + model->BSIM4v7pdwg = 0.0; + if (!model->BSIM4v7pdwbGiven) + model->BSIM4v7pdwb = 0.0; + if (!model->BSIM4v7pb0Given) + model->BSIM4v7pb0 = 0.0; + if (!model->BSIM4v7pb1Given) + model->BSIM4v7pb1 = 0.0; + if (!model->BSIM4v7palpha0Given) + model->BSIM4v7palpha0 = 0.0; + if (!model->BSIM4v7palpha1Given) + model->BSIM4v7palpha1 = 0.0; + if (!model->BSIM4v7pbeta0Given) + model->BSIM4v7pbeta0 = 0.0; + if (!model->BSIM4v7pagidlGiven) + model->BSIM4v7pagidl = 0.0; + if (!model->BSIM4v7pbgidlGiven) + model->BSIM4v7pbgidl = 0.0; + if (!model->BSIM4v7pcgidlGiven) + model->BSIM4v7pcgidl = 0.0; + if (!model->BSIM4v7pegidlGiven) + model->BSIM4v7pegidl = 0.0; + if (!model->BSIM4v7prgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7prgidl = 0.0; + if (!model->BSIM4v7pkgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7pkgidl = 0.0; + if (!model->BSIM4v7pfgidlGiven) /* v4.7 New GIDL/GISL */ + model->BSIM4v7pfgidl = 0.0; - if (!model->BSIM4pagislGiven) + if (!model->BSIM4v7pagislGiven) { - if (model->BSIM4pagidlGiven) - model->BSIM4pagisl = model->BSIM4pagidl; + if (model->BSIM4v7pagidlGiven) + model->BSIM4v7pagisl = model->BSIM4v7pagidl; else - model->BSIM4pagisl = 0.0; + model->BSIM4v7pagisl = 0.0; } - if (!model->BSIM4pbgislGiven) + if (!model->BSIM4v7pbgislGiven) { - if (model->BSIM4pbgidlGiven) - model->BSIM4pbgisl = model->BSIM4pbgidl; + if (model->BSIM4v7pbgidlGiven) + model->BSIM4v7pbgisl = model->BSIM4v7pbgidl; else - model->BSIM4pbgisl = 0.0; + model->BSIM4v7pbgisl = 0.0; } - if (!model->BSIM4pcgislGiven) + if (!model->BSIM4v7pcgislGiven) { - if (model->BSIM4pcgidlGiven) - model->BSIM4pcgisl = model->BSIM4pcgidl; + if (model->BSIM4v7pcgidlGiven) + model->BSIM4v7pcgisl = model->BSIM4v7pcgidl; else - model->BSIM4pcgisl = 0.0; + model->BSIM4v7pcgisl = 0.0; } - if (!model->BSIM4pegislGiven) + if (!model->BSIM4v7pegislGiven) { - if (model->BSIM4pegidlGiven) - model->BSIM4pegisl = model->BSIM4pegidl; + if (model->BSIM4v7pegidlGiven) + model->BSIM4v7pegisl = model->BSIM4v7pegidl; else - model->BSIM4pegisl = 0.0; + model->BSIM4v7pegisl = 0.0; } - if (!model->BSIM4prgislGiven) /* v4.7 New GIDL/GISL */ + if (!model->BSIM4v7prgislGiven) /* v4.7 New GIDL/GISL */ { - if (model->BSIM4prgidlGiven) - model->BSIM4prgisl = model->BSIM4prgidl; + if (model->BSIM4v7prgidlGiven) + model->BSIM4v7prgisl = model->BSIM4v7prgidl; } - if (!model->BSIM4pkgislGiven) /* v4.7 New GIDL/GISL */ + if (!model->BSIM4v7pkgislGiven) /* v4.7 New GIDL/GISL */ { - if (model->BSIM4pkgidlGiven) - model->BSIM4pkgisl = model->BSIM4pkgidl; + if (model->BSIM4v7pkgidlGiven) + model->BSIM4v7pkgisl = model->BSIM4v7pkgidl; } - if (!model->BSIM4pfgislGiven) /* v4.7 New GIDL/GISL */ + if (!model->BSIM4v7pfgislGiven) /* v4.7 New GIDL/GISL */ { - if (model->BSIM4pfgidlGiven) - model->BSIM4pfgisl = model->BSIM4pfgidl; + if (model->BSIM4v7pfgidlGiven) + model->BSIM4v7pfgisl = model->BSIM4v7pfgidl; } - if (!model->BSIM4paigcGiven) - model->BSIM4paigc = 0.0; - if (!model->BSIM4pbigcGiven) - model->BSIM4pbigc = 0.0; - if (!model->BSIM4pcigcGiven) - model->BSIM4pcigc = 0.0; - if (!model->BSIM4aigsdGiven && (model->BSIM4aigsGiven || model->BSIM4aigdGiven)) + if (!model->BSIM4v7paigcGiven) + model->BSIM4v7paigc = 0.0; + if (!model->BSIM4v7pbigcGiven) + model->BSIM4v7pbigc = 0.0; + if (!model->BSIM4v7pcigcGiven) + model->BSIM4v7pcigc = 0.0; + if (!model->BSIM4v7aigsdGiven && (model->BSIM4v7aigsGiven || model->BSIM4v7aigdGiven)) { - if (!model->BSIM4paigsGiven) - model->BSIM4paigs = 0.0; - if (!model->BSIM4paigdGiven) - model->BSIM4paigd = 0.0; + if (!model->BSIM4v7paigsGiven) + model->BSIM4v7paigs = 0.0; + if (!model->BSIM4v7paigdGiven) + model->BSIM4v7paigd = 0.0; } else { - if (!model->BSIM4paigsdGiven) - model->BSIM4paigsd = 0.0; - model->BSIM4paigs = model->BSIM4paigd = model->BSIM4paigsd; + if (!model->BSIM4v7paigsdGiven) + model->BSIM4v7paigsd = 0.0; + model->BSIM4v7paigs = model->BSIM4v7paigd = model->BSIM4v7paigsd; } - if (!model->BSIM4bigsdGiven && (model->BSIM4bigsGiven || model->BSIM4bigdGiven)) + if (!model->BSIM4v7bigsdGiven && (model->BSIM4v7bigsGiven || model->BSIM4v7bigdGiven)) { - if (!model->BSIM4pbigsGiven) - model->BSIM4pbigs = 0.0; - if (!model->BSIM4pbigdGiven) - model->BSIM4pbigd = 0.0; + if (!model->BSIM4v7pbigsGiven) + model->BSIM4v7pbigs = 0.0; + if (!model->BSIM4v7pbigdGiven) + model->BSIM4v7pbigd = 0.0; } else { - if (!model->BSIM4pbigsdGiven) - model->BSIM4pbigsd = 0.0; - model->BSIM4pbigs = model->BSIM4pbigd = model->BSIM4pbigsd; + if (!model->BSIM4v7pbigsdGiven) + model->BSIM4v7pbigsd = 0.0; + model->BSIM4v7pbigs = model->BSIM4v7pbigd = model->BSIM4v7pbigsd; } - if (!model->BSIM4cigsdGiven && (model->BSIM4cigsGiven || model->BSIM4cigdGiven)) + if (!model->BSIM4v7cigsdGiven && (model->BSIM4v7cigsGiven || model->BSIM4v7cigdGiven)) { - if (!model->BSIM4pcigsGiven) - model->BSIM4pcigs = 0.0; - if (!model->BSIM4pcigdGiven) - model->BSIM4pcigd = 0.0; + if (!model->BSIM4v7pcigsGiven) + model->BSIM4v7pcigs = 0.0; + if (!model->BSIM4v7pcigdGiven) + model->BSIM4v7pcigd = 0.0; } else { - if (!model->BSIM4pcigsdGiven) - model->BSIM4pcigsd = 0.0; - model->BSIM4pcigs = model->BSIM4pcigd = model->BSIM4pcigsd; + if (!model->BSIM4v7pcigsdGiven) + model->BSIM4v7pcigsd = 0.0; + model->BSIM4v7pcigs = model->BSIM4v7pcigd = model->BSIM4v7pcigsd; } - if (!model->BSIM4paigbaccGiven) - model->BSIM4paigbacc = 0.0; - if (!model->BSIM4pbigbaccGiven) - model->BSIM4pbigbacc = 0.0; - if (!model->BSIM4pcigbaccGiven) - model->BSIM4pcigbacc = 0.0; - if (!model->BSIM4paigbinvGiven) - model->BSIM4paigbinv = 0.0; - if (!model->BSIM4pbigbinvGiven) - model->BSIM4pbigbinv = 0.0; - if (!model->BSIM4pcigbinvGiven) - model->BSIM4pcigbinv = 0.0; - if (!model->BSIM4pnigcGiven) - model->BSIM4pnigc = 0.0; - if (!model->BSIM4pnigbinvGiven) - model->BSIM4pnigbinv = 0.0; - if (!model->BSIM4pnigbaccGiven) - model->BSIM4pnigbacc = 0.0; - if (!model->BSIM4pntoxGiven) - model->BSIM4pntox = 0.0; - if (!model->BSIM4peigbinvGiven) - model->BSIM4peigbinv = 0.0; - if (!model->BSIM4ppigcdGiven) - model->BSIM4ppigcd = 0.0; - if (!model->BSIM4ppoxedgeGiven) - model->BSIM4ppoxedge = 0.0; - if (!model->BSIM4pxrcrg1Given) - model->BSIM4pxrcrg1 = 0.0; - if (!model->BSIM4pxrcrg2Given) - model->BSIM4pxrcrg2 = 0.0; - if (!model->BSIM4peuGiven) - model->BSIM4peu = 0.0; - if (!model->BSIM4pucsGiven) - model->BSIM4pucs = 0.0; - if (!model->BSIM4pvfbGiven) - model->BSIM4pvfb = 0.0; - if (!model->BSIM4plambdaGiven) - model->BSIM4plambda = 0.0; - if (!model->BSIM4pvtlGiven) - model->BSIM4pvtl = 0.0; - if (!model->BSIM4pxnGiven) - model->BSIM4pxn = 0.0; - if (!model->BSIM4pvfbsdoffGiven) - model->BSIM4pvfbsdoff = 0.0; - if (!model->BSIM4ptvfbsdoffGiven) - model->BSIM4ptvfbsdoff = 0.0; - if (!model->BSIM4ptvoffGiven) - model->BSIM4ptvoff = 0.0; - if (!model->BSIM4ptnfactorGiven) /* v4.7 temp dep of leakage current */ - model->BSIM4ptnfactor = 0.0; - if (!model->BSIM4pteta0Given) /* v4.7 temp dep of leakage current */ - model->BSIM4pteta0 = 0.0; - if (!model->BSIM4ptvoffcvGiven) /* v4.7 temp dep of leakage current */ - model->BSIM4ptvoffcv = 0.0; + if (!model->BSIM4v7paigbaccGiven) + model->BSIM4v7paigbacc = 0.0; + if (!model->BSIM4v7pbigbaccGiven) + model->BSIM4v7pbigbacc = 0.0; + if (!model->BSIM4v7pcigbaccGiven) + model->BSIM4v7pcigbacc = 0.0; + if (!model->BSIM4v7paigbinvGiven) + model->BSIM4v7paigbinv = 0.0; + if (!model->BSIM4v7pbigbinvGiven) + model->BSIM4v7pbigbinv = 0.0; + if (!model->BSIM4v7pcigbinvGiven) + model->BSIM4v7pcigbinv = 0.0; + if (!model->BSIM4v7pnigcGiven) + model->BSIM4v7pnigc = 0.0; + if (!model->BSIM4v7pnigbinvGiven) + model->BSIM4v7pnigbinv = 0.0; + if (!model->BSIM4v7pnigbaccGiven) + model->BSIM4v7pnigbacc = 0.0; + if (!model->BSIM4v7pntoxGiven) + model->BSIM4v7pntox = 0.0; + if (!model->BSIM4v7peigbinvGiven) + model->BSIM4v7peigbinv = 0.0; + if (!model->BSIM4v7ppigcdGiven) + model->BSIM4v7ppigcd = 0.0; + if (!model->BSIM4v7ppoxedgeGiven) + model->BSIM4v7ppoxedge = 0.0; + if (!model->BSIM4v7pxrcrg1Given) + model->BSIM4v7pxrcrg1 = 0.0; + if (!model->BSIM4v7pxrcrg2Given) + model->BSIM4v7pxrcrg2 = 0.0; + if (!model->BSIM4v7peuGiven) + model->BSIM4v7peu = 0.0; + if (!model->BSIM4v7pucsGiven) + model->BSIM4v7pucs = 0.0; + if (!model->BSIM4v7pvfbGiven) + model->BSIM4v7pvfb = 0.0; + if (!model->BSIM4v7plambdaGiven) + model->BSIM4v7plambda = 0.0; + if (!model->BSIM4v7pvtlGiven) + model->BSIM4v7pvtl = 0.0; + if (!model->BSIM4v7pxnGiven) + model->BSIM4v7pxn = 0.0; + if (!model->BSIM4v7pvfbsdoffGiven) + model->BSIM4v7pvfbsdoff = 0.0; + if (!model->BSIM4v7ptvfbsdoffGiven) + model->BSIM4v7ptvfbsdoff = 0.0; + if (!model->BSIM4v7ptvoffGiven) + model->BSIM4v7ptvoff = 0.0; + if (!model->BSIM4v7ptnfactorGiven) /* v4.7 temp dep of leakage current */ + model->BSIM4v7ptnfactor = 0.0; + if (!model->BSIM4v7pteta0Given) /* v4.7 temp dep of leakage current */ + model->BSIM4v7pteta0 = 0.0; + if (!model->BSIM4v7ptvoffcvGiven) /* v4.7 temp dep of leakage current */ + model->BSIM4v7ptvoffcv = 0.0; - if (!model->BSIM4pcgslGiven) - model->BSIM4pcgsl = 0.0; - if (!model->BSIM4pcgdlGiven) - model->BSIM4pcgdl = 0.0; - if (!model->BSIM4pckappasGiven) - model->BSIM4pckappas = 0.0; - if (!model->BSIM4pckappadGiven) - model->BSIM4pckappad = 0.0; - if (!model->BSIM4pcfGiven) - model->BSIM4pcf = 0.0; - if (!model->BSIM4pclcGiven) - model->BSIM4pclc = 0.0; - if (!model->BSIM4pcleGiven) - model->BSIM4pcle = 0.0; - if (!model->BSIM4pvfbcvGiven) - model->BSIM4pvfbcv = 0.0; - if (!model->BSIM4pacdeGiven) - model->BSIM4pacde = 0.0; - if (!model->BSIM4pmoinGiven) - model->BSIM4pmoin = 0.0; - if (!model->BSIM4pnoffGiven) - model->BSIM4pnoff = 0.0; - if (!model->BSIM4pvoffcvGiven) - model->BSIM4pvoffcv = 0.0; + if (!model->BSIM4v7pcgslGiven) + model->BSIM4v7pcgsl = 0.0; + if (!model->BSIM4v7pcgdlGiven) + model->BSIM4v7pcgdl = 0.0; + if (!model->BSIM4v7pckappasGiven) + model->BSIM4v7pckappas = 0.0; + if (!model->BSIM4v7pckappadGiven) + model->BSIM4v7pckappad = 0.0; + if (!model->BSIM4v7pcfGiven) + model->BSIM4v7pcf = 0.0; + if (!model->BSIM4v7pclcGiven) + model->BSIM4v7pclc = 0.0; + if (!model->BSIM4v7pcleGiven) + model->BSIM4v7pcle = 0.0; + if (!model->BSIM4v7pvfbcvGiven) + model->BSIM4v7pvfbcv = 0.0; + if (!model->BSIM4v7pacdeGiven) + model->BSIM4v7pacde = 0.0; + if (!model->BSIM4v7pmoinGiven) + model->BSIM4v7pmoin = 0.0; + if (!model->BSIM4v7pnoffGiven) + model->BSIM4v7pnoff = 0.0; + if (!model->BSIM4v7pvoffcvGiven) + model->BSIM4v7pvoffcv = 0.0; - if (!model->BSIM4gamma1Given) - model->BSIM4gamma1 = 0.0; - if (!model->BSIM4lgamma1Given) - model->BSIM4lgamma1 = 0.0; - if (!model->BSIM4wgamma1Given) - model->BSIM4wgamma1 = 0.0; - if (!model->BSIM4pgamma1Given) - model->BSIM4pgamma1 = 0.0; - if (!model->BSIM4gamma2Given) - model->BSIM4gamma2 = 0.0; - if (!model->BSIM4lgamma2Given) - model->BSIM4lgamma2 = 0.0; - if (!model->BSIM4wgamma2Given) - model->BSIM4wgamma2 = 0.0; - if (!model->BSIM4pgamma2Given) - model->BSIM4pgamma2 = 0.0; - if (!model->BSIM4vbxGiven) - model->BSIM4vbx = 0.0; - if (!model->BSIM4lvbxGiven) - model->BSIM4lvbx = 0.0; - if (!model->BSIM4wvbxGiven) - model->BSIM4wvbx = 0.0; - if (!model->BSIM4pvbxGiven) - model->BSIM4pvbx = 0.0; + if (!model->BSIM4v7gamma1Given) + model->BSIM4v7gamma1 = 0.0; + if (!model->BSIM4v7lgamma1Given) + model->BSIM4v7lgamma1 = 0.0; + if (!model->BSIM4v7wgamma1Given) + model->BSIM4v7wgamma1 = 0.0; + if (!model->BSIM4v7pgamma1Given) + model->BSIM4v7pgamma1 = 0.0; + if (!model->BSIM4v7gamma2Given) + model->BSIM4v7gamma2 = 0.0; + if (!model->BSIM4v7lgamma2Given) + model->BSIM4v7lgamma2 = 0.0; + if (!model->BSIM4v7wgamma2Given) + model->BSIM4v7wgamma2 = 0.0; + if (!model->BSIM4v7pgamma2Given) + model->BSIM4v7pgamma2 = 0.0; + if (!model->BSIM4v7vbxGiven) + model->BSIM4v7vbx = 0.0; + if (!model->BSIM4v7lvbxGiven) + model->BSIM4v7lvbx = 0.0; + if (!model->BSIM4v7wvbxGiven) + model->BSIM4v7wvbx = 0.0; + if (!model->BSIM4v7pvbxGiven) + model->BSIM4v7pvbx = 0.0; /* unit degree celcius */ - if (!model->BSIM4tnomGiven) - model->BSIM4tnom = ckt->CKTnomTemp; - if (!model->BSIM4LintGiven) - model->BSIM4Lint = 0.0; - if (!model->BSIM4LlGiven) - model->BSIM4Ll = 0.0; - if (!model->BSIM4LlcGiven) - model->BSIM4Llc = model->BSIM4Ll; - if (!model->BSIM4LlnGiven) - model->BSIM4Lln = 1.0; - if (!model->BSIM4LwGiven) - model->BSIM4Lw = 0.0; - if (!model->BSIM4LwcGiven) - model->BSIM4Lwc = model->BSIM4Lw; - if (!model->BSIM4LwnGiven) - model->BSIM4Lwn = 1.0; - if (!model->BSIM4LwlGiven) - model->BSIM4Lwl = 0.0; - if (!model->BSIM4LwlcGiven) - model->BSIM4Lwlc = model->BSIM4Lwl; - if (!model->BSIM4LminGiven) - model->BSIM4Lmin = 0.0; - if (!model->BSIM4LmaxGiven) - model->BSIM4Lmax = 1.0; - if (!model->BSIM4WintGiven) - model->BSIM4Wint = 0.0; - if (!model->BSIM4WlGiven) - model->BSIM4Wl = 0.0; - if (!model->BSIM4WlcGiven) - model->BSIM4Wlc = model->BSIM4Wl; - if (!model->BSIM4WlnGiven) - model->BSIM4Wln = 1.0; - if (!model->BSIM4WwGiven) - model->BSIM4Ww = 0.0; - if (!model->BSIM4WwcGiven) - model->BSIM4Wwc = model->BSIM4Ww; - if (!model->BSIM4WwnGiven) - model->BSIM4Wwn = 1.0; - if (!model->BSIM4WwlGiven) - model->BSIM4Wwl = 0.0; - if (!model->BSIM4WwlcGiven) - model->BSIM4Wwlc = model->BSIM4Wwl; - if (!model->BSIM4WminGiven) - model->BSIM4Wmin = 0.0; - if (!model->BSIM4WmaxGiven) - model->BSIM4Wmax = 1.0; - if (!model->BSIM4dwcGiven) - model->BSIM4dwc = model->BSIM4Wint; - if (!model->BSIM4dlcGiven) - model->BSIM4dlc = model->BSIM4Lint; - if (!model->BSIM4xlGiven) - model->BSIM4xl = 0.0; - if (!model->BSIM4xwGiven) - model->BSIM4xw = 0.0; - if (!model->BSIM4dlcigGiven) - model->BSIM4dlcig = model->BSIM4Lint; - if (!model->BSIM4dlcigdGiven) + if (!model->BSIM4v7tnomGiven) + model->BSIM4v7tnom = ckt->CKTnomTemp; + if (!model->BSIM4v7LintGiven) + model->BSIM4v7Lint = 0.0; + if (!model->BSIM4v7LlGiven) + model->BSIM4v7Ll = 0.0; + if (!model->BSIM4v7LlcGiven) + model->BSIM4v7Llc = model->BSIM4v7Ll; + if (!model->BSIM4v7LlnGiven) + model->BSIM4v7Lln = 1.0; + if (!model->BSIM4v7LwGiven) + model->BSIM4v7Lw = 0.0; + if (!model->BSIM4v7LwcGiven) + model->BSIM4v7Lwc = model->BSIM4v7Lw; + if (!model->BSIM4v7LwnGiven) + model->BSIM4v7Lwn = 1.0; + if (!model->BSIM4v7LwlGiven) + model->BSIM4v7Lwl = 0.0; + if (!model->BSIM4v7LwlcGiven) + model->BSIM4v7Lwlc = model->BSIM4v7Lwl; + if (!model->BSIM4v7LminGiven) + model->BSIM4v7Lmin = 0.0; + if (!model->BSIM4v7LmaxGiven) + model->BSIM4v7Lmax = 1.0; + if (!model->BSIM4v7WintGiven) + model->BSIM4v7Wint = 0.0; + if (!model->BSIM4v7WlGiven) + model->BSIM4v7Wl = 0.0; + if (!model->BSIM4v7WlcGiven) + model->BSIM4v7Wlc = model->BSIM4v7Wl; + if (!model->BSIM4v7WlnGiven) + model->BSIM4v7Wln = 1.0; + if (!model->BSIM4v7WwGiven) + model->BSIM4v7Ww = 0.0; + if (!model->BSIM4v7WwcGiven) + model->BSIM4v7Wwc = model->BSIM4v7Ww; + if (!model->BSIM4v7WwnGiven) + model->BSIM4v7Wwn = 1.0; + if (!model->BSIM4v7WwlGiven) + model->BSIM4v7Wwl = 0.0; + if (!model->BSIM4v7WwlcGiven) + model->BSIM4v7Wwlc = model->BSIM4v7Wwl; + if (!model->BSIM4v7WminGiven) + model->BSIM4v7Wmin = 0.0; + if (!model->BSIM4v7WmaxGiven) + model->BSIM4v7Wmax = 1.0; + if (!model->BSIM4v7dwcGiven) + model->BSIM4v7dwc = model->BSIM4v7Wint; + if (!model->BSIM4v7dlcGiven) + model->BSIM4v7dlc = model->BSIM4v7Lint; + if (!model->BSIM4v7xlGiven) + model->BSIM4v7xl = 0.0; + if (!model->BSIM4v7xwGiven) + model->BSIM4v7xw = 0.0; + if (!model->BSIM4v7dlcigGiven) + model->BSIM4v7dlcig = model->BSIM4v7Lint; + if (!model->BSIM4v7dlcigdGiven) { - if (model->BSIM4dlcigGiven) - model->BSIM4dlcigd = model->BSIM4dlcig; + if (model->BSIM4v7dlcigGiven) + model->BSIM4v7dlcigd = model->BSIM4v7dlcig; else - model->BSIM4dlcigd = model->BSIM4Lint; + model->BSIM4v7dlcigd = model->BSIM4v7Lint; } - if (!model->BSIM4dwjGiven) - model->BSIM4dwj = model->BSIM4dwc; - if (!model->BSIM4cfGiven) - model->BSIM4cf = 2.0 * model->BSIM4epsrox * EPS0 / PI - * log(1.0 + 0.4e-6 / model->BSIM4toxe); + if (!model->BSIM4v7dwjGiven) + model->BSIM4v7dwj = model->BSIM4v7dwc; + if (!model->BSIM4v7cfGiven) + model->BSIM4v7cf = 2.0 * model->BSIM4v7epsrox * EPS0 / PI + * log(1.0 + 0.4e-6 / model->BSIM4v7toxe); - if (!model->BSIM4xpartGiven) - model->BSIM4xpart = 0.0; - if (!model->BSIM4sheetResistanceGiven) - model->BSIM4sheetResistance = 0.0; + if (!model->BSIM4v7xpartGiven) + model->BSIM4v7xpart = 0.0; + if (!model->BSIM4v7sheetResistanceGiven) + model->BSIM4v7sheetResistance = 0.0; - if (!model->BSIM4SunitAreaJctCapGiven) - model->BSIM4SunitAreaJctCap = 5.0E-4; - if (!model->BSIM4DunitAreaJctCapGiven) - model->BSIM4DunitAreaJctCap = model->BSIM4SunitAreaJctCap; - if (!model->BSIM4SunitLengthSidewallJctCapGiven) - model->BSIM4SunitLengthSidewallJctCap = 5.0E-10; - if (!model->BSIM4DunitLengthSidewallJctCapGiven) - model->BSIM4DunitLengthSidewallJctCap = model->BSIM4SunitLengthSidewallJctCap; - if (!model->BSIM4SunitLengthGateSidewallJctCapGiven) - model->BSIM4SunitLengthGateSidewallJctCap = model->BSIM4SunitLengthSidewallJctCap ; - if (!model->BSIM4DunitLengthGateSidewallJctCapGiven) - model->BSIM4DunitLengthGateSidewallJctCap = model->BSIM4SunitLengthGateSidewallJctCap; - if (!model->BSIM4SjctSatCurDensityGiven) - model->BSIM4SjctSatCurDensity = 1.0E-4; - if (!model->BSIM4DjctSatCurDensityGiven) - model->BSIM4DjctSatCurDensity = model->BSIM4SjctSatCurDensity; - if (!model->BSIM4SjctSidewallSatCurDensityGiven) - model->BSIM4SjctSidewallSatCurDensity = 0.0; - if (!model->BSIM4DjctSidewallSatCurDensityGiven) - model->BSIM4DjctSidewallSatCurDensity = model->BSIM4SjctSidewallSatCurDensity; - if (!model->BSIM4SjctGateSidewallSatCurDensityGiven) - model->BSIM4SjctGateSidewallSatCurDensity = 0.0; - if (!model->BSIM4DjctGateSidewallSatCurDensityGiven) - model->BSIM4DjctGateSidewallSatCurDensity = model->BSIM4SjctGateSidewallSatCurDensity; - if (!model->BSIM4SbulkJctPotentialGiven) - model->BSIM4SbulkJctPotential = 1.0; - if (!model->BSIM4DbulkJctPotentialGiven) - model->BSIM4DbulkJctPotential = model->BSIM4SbulkJctPotential; - if (!model->BSIM4SsidewallJctPotentialGiven) - model->BSIM4SsidewallJctPotential = 1.0; - if (!model->BSIM4DsidewallJctPotentialGiven) - model->BSIM4DsidewallJctPotential = model->BSIM4SsidewallJctPotential; - if (!model->BSIM4SGatesidewallJctPotentialGiven) - model->BSIM4SGatesidewallJctPotential = model->BSIM4SsidewallJctPotential; - if (!model->BSIM4DGatesidewallJctPotentialGiven) - model->BSIM4DGatesidewallJctPotential = model->BSIM4SGatesidewallJctPotential; - if (!model->BSIM4SbulkJctBotGradingCoeffGiven) - model->BSIM4SbulkJctBotGradingCoeff = 0.5; - if (!model->BSIM4DbulkJctBotGradingCoeffGiven) - model->BSIM4DbulkJctBotGradingCoeff = model->BSIM4SbulkJctBotGradingCoeff; - if (!model->BSIM4SbulkJctSideGradingCoeffGiven) - model->BSIM4SbulkJctSideGradingCoeff = 0.33; - if (!model->BSIM4DbulkJctSideGradingCoeffGiven) - model->BSIM4DbulkJctSideGradingCoeff = model->BSIM4SbulkJctSideGradingCoeff; - if (!model->BSIM4SbulkJctGateSideGradingCoeffGiven) - model->BSIM4SbulkJctGateSideGradingCoeff = model->BSIM4SbulkJctSideGradingCoeff; - if (!model->BSIM4DbulkJctGateSideGradingCoeffGiven) - model->BSIM4DbulkJctGateSideGradingCoeff = model->BSIM4SbulkJctGateSideGradingCoeff; - if (!model->BSIM4SjctEmissionCoeffGiven) - model->BSIM4SjctEmissionCoeff = 1.0; - if (!model->BSIM4DjctEmissionCoeffGiven) - model->BSIM4DjctEmissionCoeff = model->BSIM4SjctEmissionCoeff; - if (!model->BSIM4SjctTempExponentGiven) - model->BSIM4SjctTempExponent = 3.0; - if (!model->BSIM4DjctTempExponentGiven) - model->BSIM4DjctTempExponent = model->BSIM4SjctTempExponent; + if (!model->BSIM4v7SunitAreaJctCapGiven) + model->BSIM4v7SunitAreaJctCap = 5.0E-4; + if (!model->BSIM4v7DunitAreaJctCapGiven) + model->BSIM4v7DunitAreaJctCap = model->BSIM4v7SunitAreaJctCap; + if (!model->BSIM4v7SunitLengthSidewallJctCapGiven) + model->BSIM4v7SunitLengthSidewallJctCap = 5.0E-10; + if (!model->BSIM4v7DunitLengthSidewallJctCapGiven) + model->BSIM4v7DunitLengthSidewallJctCap = model->BSIM4v7SunitLengthSidewallJctCap; + if (!model->BSIM4v7SunitLengthGateSidewallJctCapGiven) + model->BSIM4v7SunitLengthGateSidewallJctCap = model->BSIM4v7SunitLengthSidewallJctCap ; + if (!model->BSIM4v7DunitLengthGateSidewallJctCapGiven) + model->BSIM4v7DunitLengthGateSidewallJctCap = model->BSIM4v7SunitLengthGateSidewallJctCap; + if (!model->BSIM4v7SjctSatCurDensityGiven) + model->BSIM4v7SjctSatCurDensity = 1.0E-4; + if (!model->BSIM4v7DjctSatCurDensityGiven) + model->BSIM4v7DjctSatCurDensity = model->BSIM4v7SjctSatCurDensity; + if (!model->BSIM4v7SjctSidewallSatCurDensityGiven) + model->BSIM4v7SjctSidewallSatCurDensity = 0.0; + if (!model->BSIM4v7DjctSidewallSatCurDensityGiven) + model->BSIM4v7DjctSidewallSatCurDensity = model->BSIM4v7SjctSidewallSatCurDensity; + if (!model->BSIM4v7SjctGateSidewallSatCurDensityGiven) + model->BSIM4v7SjctGateSidewallSatCurDensity = 0.0; + if (!model->BSIM4v7DjctGateSidewallSatCurDensityGiven) + model->BSIM4v7DjctGateSidewallSatCurDensity = model->BSIM4v7SjctGateSidewallSatCurDensity; + if (!model->BSIM4v7SbulkJctPotentialGiven) + model->BSIM4v7SbulkJctPotential = 1.0; + if (!model->BSIM4v7DbulkJctPotentialGiven) + model->BSIM4v7DbulkJctPotential = model->BSIM4v7SbulkJctPotential; + if (!model->BSIM4v7SsidewallJctPotentialGiven) + model->BSIM4v7SsidewallJctPotential = 1.0; + if (!model->BSIM4v7DsidewallJctPotentialGiven) + model->BSIM4v7DsidewallJctPotential = model->BSIM4v7SsidewallJctPotential; + if (!model->BSIM4v7SGatesidewallJctPotentialGiven) + model->BSIM4v7SGatesidewallJctPotential = model->BSIM4v7SsidewallJctPotential; + if (!model->BSIM4v7DGatesidewallJctPotentialGiven) + model->BSIM4v7DGatesidewallJctPotential = model->BSIM4v7SGatesidewallJctPotential; + if (!model->BSIM4v7SbulkJctBotGradingCoeffGiven) + model->BSIM4v7SbulkJctBotGradingCoeff = 0.5; + if (!model->BSIM4v7DbulkJctBotGradingCoeffGiven) + model->BSIM4v7DbulkJctBotGradingCoeff = model->BSIM4v7SbulkJctBotGradingCoeff; + if (!model->BSIM4v7SbulkJctSideGradingCoeffGiven) + model->BSIM4v7SbulkJctSideGradingCoeff = 0.33; + if (!model->BSIM4v7DbulkJctSideGradingCoeffGiven) + model->BSIM4v7DbulkJctSideGradingCoeff = model->BSIM4v7SbulkJctSideGradingCoeff; + if (!model->BSIM4v7SbulkJctGateSideGradingCoeffGiven) + model->BSIM4v7SbulkJctGateSideGradingCoeff = model->BSIM4v7SbulkJctSideGradingCoeff; + if (!model->BSIM4v7DbulkJctGateSideGradingCoeffGiven) + model->BSIM4v7DbulkJctGateSideGradingCoeff = model->BSIM4v7SbulkJctGateSideGradingCoeff; + if (!model->BSIM4v7SjctEmissionCoeffGiven) + model->BSIM4v7SjctEmissionCoeff = 1.0; + if (!model->BSIM4v7DjctEmissionCoeffGiven) + model->BSIM4v7DjctEmissionCoeff = model->BSIM4v7SjctEmissionCoeff; + if (!model->BSIM4v7SjctTempExponentGiven) + model->BSIM4v7SjctTempExponent = 3.0; + if (!model->BSIM4v7DjctTempExponentGiven) + model->BSIM4v7DjctTempExponent = model->BSIM4v7SjctTempExponent; - if (!model->BSIM4jtssGiven) - model->BSIM4jtss = 0.0; - if (!model->BSIM4jtsdGiven) - model->BSIM4jtsd = model->BSIM4jtss; - if (!model->BSIM4jtsswsGiven) - model->BSIM4jtssws = 0.0; - if (!model->BSIM4jtsswdGiven) - model->BSIM4jtsswd = model->BSIM4jtssws; - if (!model->BSIM4jtsswgsGiven) - model->BSIM4jtsswgs = 0.0; - if (!model->BSIM4jtsswgdGiven) - model->BSIM4jtsswgd = model->BSIM4jtsswgs; - if (!model->BSIM4jtweffGiven) - model->BSIM4jtweff = 0.0; - if (!model->BSIM4njtsGiven) - model->BSIM4njts = 20.0; - if (!model->BSIM4njtsswGiven) - model->BSIM4njtssw = 20.0; - if (!model->BSIM4njtsswgGiven) - model->BSIM4njtsswg = 20.0; - if (!model->BSIM4njtsdGiven) + if (!model->BSIM4v7jtssGiven) + model->BSIM4v7jtss = 0.0; + if (!model->BSIM4v7jtsdGiven) + model->BSIM4v7jtsd = model->BSIM4v7jtss; + if (!model->BSIM4v7jtsswsGiven) + model->BSIM4v7jtssws = 0.0; + if (!model->BSIM4v7jtsswdGiven) + model->BSIM4v7jtsswd = model->BSIM4v7jtssws; + if (!model->BSIM4v7jtsswgsGiven) + model->BSIM4v7jtsswgs = 0.0; + if (!model->BSIM4v7jtsswgdGiven) + model->BSIM4v7jtsswgd = model->BSIM4v7jtsswgs; + if (!model->BSIM4v7jtweffGiven) + model->BSIM4v7jtweff = 0.0; + if (!model->BSIM4v7njtsGiven) + model->BSIM4v7njts = 20.0; + if (!model->BSIM4v7njtsswGiven) + model->BSIM4v7njtssw = 20.0; + if (!model->BSIM4v7njtsswgGiven) + model->BSIM4v7njtsswg = 20.0; + if (!model->BSIM4v7njtsdGiven) { - if (model->BSIM4njtsGiven) - model->BSIM4njtsd = model->BSIM4njts; + if (model->BSIM4v7njtsGiven) + model->BSIM4v7njtsd = model->BSIM4v7njts; else - model->BSIM4njtsd = 20.0; + model->BSIM4v7njtsd = 20.0; } - if (!model->BSIM4njtsswdGiven) + if (!model->BSIM4v7njtsswdGiven) { - if (model->BSIM4njtsswGiven) - model->BSIM4njtsswd = model->BSIM4njtssw; + if (model->BSIM4v7njtsswGiven) + model->BSIM4v7njtsswd = model->BSIM4v7njtssw; else - model->BSIM4njtsswd = 20.0; + model->BSIM4v7njtsswd = 20.0; } - if (!model->BSIM4njtsswgdGiven) + if (!model->BSIM4v7njtsswgdGiven) { - if (model->BSIM4njtsswgGiven) - model->BSIM4njtsswgd = model->BSIM4njtsswg; + if (model->BSIM4v7njtsswgGiven) + model->BSIM4v7njtsswgd = model->BSIM4v7njtsswg; else - model->BSIM4njtsswgd = 20.0; + model->BSIM4v7njtsswgd = 20.0; } - if (!model->BSIM4xtssGiven) - model->BSIM4xtss = 0.02; - if (!model->BSIM4xtsdGiven) - model->BSIM4xtsd = model->BSIM4xtss; - if (!model->BSIM4xtsswsGiven) - model->BSIM4xtssws = 0.02; - if (!model->BSIM4xtsswdGiven) - model->BSIM4xtsswd = model->BSIM4xtssws; - if (!model->BSIM4xtsswgsGiven) - model->BSIM4xtsswgs = 0.02; - if (!model->BSIM4xtsswgdGiven) - model->BSIM4xtsswgd = model->BSIM4xtsswgs; - if (!model->BSIM4tnjtsGiven) - model->BSIM4tnjts = 0.0; - if (!model->BSIM4tnjtsswGiven) - model->BSIM4tnjtssw = 0.0; - if (!model->BSIM4tnjtsswgGiven) - model->BSIM4tnjtsswg = 0.0; - if (!model->BSIM4tnjtsdGiven) + if (!model->BSIM4v7xtssGiven) + model->BSIM4v7xtss = 0.02; + if (!model->BSIM4v7xtsdGiven) + model->BSIM4v7xtsd = model->BSIM4v7xtss; + if (!model->BSIM4v7xtsswsGiven) + model->BSIM4v7xtssws = 0.02; + if (!model->BSIM4v7xtsswdGiven) + model->BSIM4v7xtsswd = model->BSIM4v7xtssws; + if (!model->BSIM4v7xtsswgsGiven) + model->BSIM4v7xtsswgs = 0.02; + if (!model->BSIM4v7xtsswgdGiven) + model->BSIM4v7xtsswgd = model->BSIM4v7xtsswgs; + if (!model->BSIM4v7tnjtsGiven) + model->BSIM4v7tnjts = 0.0; + if (!model->BSIM4v7tnjtsswGiven) + model->BSIM4v7tnjtssw = 0.0; + if (!model->BSIM4v7tnjtsswgGiven) + model->BSIM4v7tnjtsswg = 0.0; + if (!model->BSIM4v7tnjtsdGiven) { - if (model->BSIM4tnjtsGiven) - model->BSIM4tnjtsd = model->BSIM4tnjts; + if (model->BSIM4v7tnjtsGiven) + model->BSIM4v7tnjtsd = model->BSIM4v7tnjts; else - model->BSIM4tnjtsd = 0.0; + model->BSIM4v7tnjtsd = 0.0; } - if (!model->BSIM4tnjtsswdGiven) + if (!model->BSIM4v7tnjtsswdGiven) { - if (model->BSIM4tnjtsswGiven) - model->BSIM4tnjtsswd = model->BSIM4tnjtssw; + if (model->BSIM4v7tnjtsswGiven) + model->BSIM4v7tnjtsswd = model->BSIM4v7tnjtssw; else - model->BSIM4tnjtsswd = 0.0; + model->BSIM4v7tnjtsswd = 0.0; } - if (!model->BSIM4tnjtsswgdGiven) + if (!model->BSIM4v7tnjtsswgdGiven) { - if (model->BSIM4tnjtsswgGiven) - model->BSIM4tnjtsswgd = model->BSIM4tnjtsswg; + if (model->BSIM4v7tnjtsswgGiven) + model->BSIM4v7tnjtsswgd = model->BSIM4v7tnjtsswg; else - model->BSIM4tnjtsswgd = 0.0; + model->BSIM4v7tnjtsswgd = 0.0; } - if (!model->BSIM4vtssGiven) - model->BSIM4vtss = 10.0; - if (!model->BSIM4vtsdGiven) - model->BSIM4vtsd = model->BSIM4vtss; - if (!model->BSIM4vtsswsGiven) - model->BSIM4vtssws = 10.0; - if (!model->BSIM4vtsswdGiven) - model->BSIM4vtsswd = model->BSIM4vtssws; - if (!model->BSIM4vtsswgsGiven) - model->BSIM4vtsswgs = 10.0; - if (!model->BSIM4vtsswgdGiven) - model->BSIM4vtsswgd = model->BSIM4vtsswgs; + if (!model->BSIM4v7vtssGiven) + model->BSIM4v7vtss = 10.0; + if (!model->BSIM4v7vtsdGiven) + model->BSIM4v7vtsd = model->BSIM4v7vtss; + if (!model->BSIM4v7vtsswsGiven) + model->BSIM4v7vtssws = 10.0; + if (!model->BSIM4v7vtsswdGiven) + model->BSIM4v7vtsswd = model->BSIM4v7vtssws; + if (!model->BSIM4v7vtsswgsGiven) + model->BSIM4v7vtsswgs = 10.0; + if (!model->BSIM4v7vtsswgdGiven) + model->BSIM4v7vtsswgd = model->BSIM4v7vtsswgs; - if (!model->BSIM4oxideTrapDensityAGiven) - { if (model->BSIM4type == NMOS) - model->BSIM4oxideTrapDensityA = 6.25e41; + if (!model->BSIM4v7oxideTrapDensityAGiven) + { if (model->BSIM4v7type == NMOS) + model->BSIM4v7oxideTrapDensityA = 6.25e41; else - model->BSIM4oxideTrapDensityA= 6.188e40; + model->BSIM4v7oxideTrapDensityA= 6.188e40; } - if (!model->BSIM4oxideTrapDensityBGiven) - { if (model->BSIM4type == NMOS) - model->BSIM4oxideTrapDensityB = 3.125e26; + if (!model->BSIM4v7oxideTrapDensityBGiven) + { if (model->BSIM4v7type == NMOS) + model->BSIM4v7oxideTrapDensityB = 3.125e26; else - model->BSIM4oxideTrapDensityB = 1.5e25; + model->BSIM4v7oxideTrapDensityB = 1.5e25; } - if (!model->BSIM4oxideTrapDensityCGiven) - model->BSIM4oxideTrapDensityC = 8.75e9; - if (!model->BSIM4emGiven) - model->BSIM4em = 4.1e7; /* V/m */ - if (!model->BSIM4efGiven) - model->BSIM4ef = 1.0; - if (!model->BSIM4afGiven) - model->BSIM4af = 1.0; - if (!model->BSIM4kfGiven) - model->BSIM4kf = 0.0; + if (!model->BSIM4v7oxideTrapDensityCGiven) + model->BSIM4v7oxideTrapDensityC = 8.75e9; + if (!model->BSIM4v7emGiven) + model->BSIM4v7em = 4.1e7; /* V/m */ + if (!model->BSIM4v7efGiven) + model->BSIM4v7ef = 1.0; + if (!model->BSIM4v7afGiven) + model->BSIM4v7af = 1.0; + if (!model->BSIM4v7kfGiven) + model->BSIM4v7kf = 0.0; - if (!model->BSIM4vgsMaxGiven) - model->BSIM4vgsMax = 1e99; - if (!model->BSIM4vgdMaxGiven) - model->BSIM4vgdMax = 1e99; - if (!model->BSIM4vgbMaxGiven) - model->BSIM4vgbMax = 1e99; - if (!model->BSIM4vdsMaxGiven) - model->BSIM4vdsMax = 1e99; - if (!model->BSIM4vbsMaxGiven) - model->BSIM4vbsMax = 1e99; - if (!model->BSIM4vbdMaxGiven) - model->BSIM4vbdMax = 1e99; + if (!model->BSIM4v7vgsMaxGiven) + model->BSIM4v7vgsMax = 1e99; + if (!model->BSIM4v7vgdMaxGiven) + model->BSIM4v7vgdMax = 1e99; + if (!model->BSIM4v7vgbMaxGiven) + model->BSIM4v7vgbMax = 1e99; + if (!model->BSIM4v7vdsMaxGiven) + model->BSIM4v7vdsMax = 1e99; + if (!model->BSIM4v7vbsMaxGiven) + model->BSIM4v7vbsMax = 1e99; + if (!model->BSIM4v7vbdMaxGiven) + model->BSIM4v7vbdMax = 1e99; /* stress effect */ - if (!model->BSIM4sarefGiven) - model->BSIM4saref = 1e-6; /* m */ - if (!model->BSIM4sbrefGiven) - model->BSIM4sbref = 1e-6; /* m */ - if (!model->BSIM4wlodGiven) - model->BSIM4wlod = 0; /* m */ - if (!model->BSIM4ku0Given) - model->BSIM4ku0 = 0; /* 1/m */ - if (!model->BSIM4kvsatGiven) - model->BSIM4kvsat = 0; - if (!model->BSIM4kvth0Given) /* m */ - model->BSIM4kvth0 = 0; - if (!model->BSIM4tku0Given) - model->BSIM4tku0 = 0; - if (!model->BSIM4llodku0Given) - model->BSIM4llodku0 = 0; - if (!model->BSIM4wlodku0Given) - model->BSIM4wlodku0 = 0; - if (!model->BSIM4llodvthGiven) - model->BSIM4llodvth = 0; - if (!model->BSIM4wlodvthGiven) - model->BSIM4wlodvth = 0; - if (!model->BSIM4lku0Given) - model->BSIM4lku0 = 0; - if (!model->BSIM4wku0Given) - model->BSIM4wku0 = 0; - if (!model->BSIM4pku0Given) - model->BSIM4pku0 = 0; - if (!model->BSIM4lkvth0Given) - model->BSIM4lkvth0 = 0; - if (!model->BSIM4wkvth0Given) - model->BSIM4wkvth0 = 0; - if (!model->BSIM4pkvth0Given) - model->BSIM4pkvth0 = 0; - if (!model->BSIM4stk2Given) - model->BSIM4stk2 = 0; - if (!model->BSIM4lodk2Given) - model->BSIM4lodk2 = 1.0; - if (!model->BSIM4steta0Given) - model->BSIM4steta0 = 0; - if (!model->BSIM4lodeta0Given) - model->BSIM4lodeta0 = 1.0; + if (!model->BSIM4v7sarefGiven) + model->BSIM4v7saref = 1e-6; /* m */ + if (!model->BSIM4v7sbrefGiven) + model->BSIM4v7sbref = 1e-6; /* m */ + if (!model->BSIM4v7wlodGiven) + model->BSIM4v7wlod = 0; /* m */ + if (!model->BSIM4v7ku0Given) + model->BSIM4v7ku0 = 0; /* 1/m */ + if (!model->BSIM4v7kvsatGiven) + model->BSIM4v7kvsat = 0; + if (!model->BSIM4v7kvth0Given) /* m */ + model->BSIM4v7kvth0 = 0; + if (!model->BSIM4v7tku0Given) + model->BSIM4v7tku0 = 0; + if (!model->BSIM4v7llodku0Given) + model->BSIM4v7llodku0 = 0; + if (!model->BSIM4v7wlodku0Given) + model->BSIM4v7wlodku0 = 0; + if (!model->BSIM4v7llodvthGiven) + model->BSIM4v7llodvth = 0; + if (!model->BSIM4v7wlodvthGiven) + model->BSIM4v7wlodvth = 0; + if (!model->BSIM4v7lku0Given) + model->BSIM4v7lku0 = 0; + if (!model->BSIM4v7wku0Given) + model->BSIM4v7wku0 = 0; + if (!model->BSIM4v7pku0Given) + model->BSIM4v7pku0 = 0; + if (!model->BSIM4v7lkvth0Given) + model->BSIM4v7lkvth0 = 0; + if (!model->BSIM4v7wkvth0Given) + model->BSIM4v7wkvth0 = 0; + if (!model->BSIM4v7pkvth0Given) + model->BSIM4v7pkvth0 = 0; + if (!model->BSIM4v7stk2Given) + model->BSIM4v7stk2 = 0; + if (!model->BSIM4v7lodk2Given) + model->BSIM4v7lodk2 = 1.0; + if (!model->BSIM4v7steta0Given) + model->BSIM4v7steta0 = 0; + if (!model->BSIM4v7lodeta0Given) + model->BSIM4v7lodeta0 = 1.0; /* Well Proximity Effect */ - if (!model->BSIM4webGiven) - model->BSIM4web = 0.0; - if (!model->BSIM4wecGiven) - model->BSIM4wec = 0.0; - if (!model->BSIM4kvth0weGiven) - model->BSIM4kvth0we = 0.0; - if (!model->BSIM4k2weGiven) - model->BSIM4k2we = 0.0; - if (!model->BSIM4ku0weGiven) - model->BSIM4ku0we = 0.0; - if (!model->BSIM4screfGiven) - model->BSIM4scref = 1.0E-6; /* m */ - if (!model->BSIM4wpemodGiven) - model->BSIM4wpemod = 0; - else if ((model->BSIM4wpemod != 0) && (model->BSIM4wpemod != 1)) - { model->BSIM4wpemod = 0; + if (!model->BSIM4v7webGiven) + model->BSIM4v7web = 0.0; + if (!model->BSIM4v7wecGiven) + model->BSIM4v7wec = 0.0; + if (!model->BSIM4v7kvth0weGiven) + model->BSIM4v7kvth0we = 0.0; + if (!model->BSIM4v7k2weGiven) + model->BSIM4v7k2we = 0.0; + if (!model->BSIM4v7ku0weGiven) + model->BSIM4v7ku0we = 0.0; + if (!model->BSIM4v7screfGiven) + model->BSIM4v7scref = 1.0E-6; /* m */ + if (!model->BSIM4v7wpemodGiven) + model->BSIM4v7wpemod = 0; + else if ((model->BSIM4v7wpemod != 0) && (model->BSIM4v7wpemod != 1)) + { model->BSIM4v7wpemod = 0; printf("Warning: wpemod has been set to its default value: 0.\n"); } - if (!model->BSIM4lkvth0weGiven) - model->BSIM4lkvth0we = 0; - if (!model->BSIM4lk2weGiven) - model->BSIM4lk2we = 0; - if (!model->BSIM4lku0weGiven) - model->BSIM4lku0we = 0; - if (!model->BSIM4wkvth0weGiven) - model->BSIM4wkvth0we = 0; - if (!model->BSIM4wk2weGiven) - model->BSIM4wk2we = 0; - if (!model->BSIM4wku0weGiven) - model->BSIM4wku0we = 0; - if (!model->BSIM4pkvth0weGiven) - model->BSIM4pkvth0we = 0; - if (!model->BSIM4pk2weGiven) - model->BSIM4pk2we = 0; - if (!model->BSIM4pku0weGiven) - model->BSIM4pku0we = 0; + if (!model->BSIM4v7lkvth0weGiven) + model->BSIM4v7lkvth0we = 0; + if (!model->BSIM4v7lk2weGiven) + model->BSIM4v7lk2we = 0; + if (!model->BSIM4v7lku0weGiven) + model->BSIM4v7lku0we = 0; + if (!model->BSIM4v7wkvth0weGiven) + model->BSIM4v7wkvth0we = 0; + if (!model->BSIM4v7wk2weGiven) + model->BSIM4v7wk2we = 0; + if (!model->BSIM4v7wku0weGiven) + model->BSIM4v7wku0we = 0; + if (!model->BSIM4v7pkvth0weGiven) + model->BSIM4v7pkvth0we = 0; + if (!model->BSIM4v7pk2weGiven) + model->BSIM4v7pk2we = 0; + if (!model->BSIM4v7pku0weGiven) + model->BSIM4v7pku0we = 0; - DMCGeff = model->BSIM4dmcg - model->BSIM4dmcgt; - DMCIeff = model->BSIM4dmci; - DMDGeff = model->BSIM4dmdg - model->BSIM4dmcgt; + DMCGeff = model->BSIM4v7dmcg - model->BSIM4v7dmcgt; + DMCIeff = model->BSIM4v7dmci; + DMDGeff = model->BSIM4v7dmdg - model->BSIM4v7dmcgt; /* * End processing models and begin to loop * through all the instances of the model */ - for (here = model->BSIM4instances; here != NULL ; - here=here->BSIM4nextInstance) + for (here = model->BSIM4v7instances; here != NULL ; + here=here->BSIM4v7nextInstance) { /* allocate a chunk of the state vector */ - here->BSIM4states = *states; - *states += BSIM4numStates; + here->BSIM4v7states = *states; + *states += BSIM4v7numStates; /* perform the parameter defaulting */ - if (!here->BSIM4lGiven) - here->BSIM4l = 5.0e-6; - if (!here->BSIM4wGiven) - here->BSIM4w = 5.0e-6; - if (!here->BSIM4mGiven) - here->BSIM4m = 1.0; - if (!here->BSIM4nfGiven) - here->BSIM4nf = 1.0; - if (!here->BSIM4minGiven) - here->BSIM4min = 0; /* integer */ - if (!here->BSIM4icVDSGiven) - here->BSIM4icVDS = 0.0; - if (!here->BSIM4icVGSGiven) - here->BSIM4icVGS = 0.0; - if (!here->BSIM4icVBSGiven) - here->BSIM4icVBS = 0.0; - if (!here->BSIM4drainAreaGiven) - here->BSIM4drainArea = 0.0; - if (!here->BSIM4drainPerimeterGiven) - here->BSIM4drainPerimeter = 0.0; - if (!here->BSIM4drainSquaresGiven) - here->BSIM4drainSquares = 1.0; - if (!here->BSIM4sourceAreaGiven) - here->BSIM4sourceArea = 0.0; - if (!here->BSIM4sourcePerimeterGiven) - here->BSIM4sourcePerimeter = 0.0; - if (!here->BSIM4sourceSquaresGiven) - here->BSIM4sourceSquares = 1.0; + if (!here->BSIM4v7lGiven) + here->BSIM4v7l = 5.0e-6; + if (!here->BSIM4v7wGiven) + here->BSIM4v7w = 5.0e-6; + if (!here->BSIM4v7mGiven) + here->BSIM4v7m = 1.0; + if (!here->BSIM4v7nfGiven) + here->BSIM4v7nf = 1.0; + if (!here->BSIM4v7minGiven) + here->BSIM4v7min = 0; /* integer */ + if (!here->BSIM4v7icVDSGiven) + here->BSIM4v7icVDS = 0.0; + if (!here->BSIM4v7icVGSGiven) + here->BSIM4v7icVGS = 0.0; + if (!here->BSIM4v7icVBSGiven) + here->BSIM4v7icVBS = 0.0; + if (!here->BSIM4v7drainAreaGiven) + here->BSIM4v7drainArea = 0.0; + if (!here->BSIM4v7drainPerimeterGiven) + here->BSIM4v7drainPerimeter = 0.0; + if (!here->BSIM4v7drainSquaresGiven) + here->BSIM4v7drainSquares = 1.0; + if (!here->BSIM4v7sourceAreaGiven) + here->BSIM4v7sourceArea = 0.0; + if (!here->BSIM4v7sourcePerimeterGiven) + here->BSIM4v7sourcePerimeter = 0.0; + if (!here->BSIM4v7sourceSquaresGiven) + here->BSIM4v7sourceSquares = 1.0; - if (!here->BSIM4rbdbGiven) - here->BSIM4rbdb = model->BSIM4rbdb; /* in ohm */ - if (!here->BSIM4rbsbGiven) - here->BSIM4rbsb = model->BSIM4rbsb; - if (!here->BSIM4rbpbGiven) - here->BSIM4rbpb = model->BSIM4rbpb; - if (!here->BSIM4rbpsGiven) - here->BSIM4rbps = model->BSIM4rbps; - if (!here->BSIM4rbpdGiven) - here->BSIM4rbpd = model->BSIM4rbpd; - if (!here->BSIM4delvtoGiven) - here->BSIM4delvto = 0.0; - if (!here->BSIM4xgwGiven) - here->BSIM4xgw = model->BSIM4xgw; - if (!here->BSIM4ngconGiven) - here->BSIM4ngcon = model->BSIM4ngcon; + if (!here->BSIM4v7rbdbGiven) + here->BSIM4v7rbdb = model->BSIM4v7rbdb; /* in ohm */ + if (!here->BSIM4v7rbsbGiven) + here->BSIM4v7rbsb = model->BSIM4v7rbsb; + if (!here->BSIM4v7rbpbGiven) + here->BSIM4v7rbpb = model->BSIM4v7rbpb; + if (!here->BSIM4v7rbpsGiven) + here->BSIM4v7rbps = model->BSIM4v7rbps; + if (!here->BSIM4v7rbpdGiven) + here->BSIM4v7rbpd = model->BSIM4v7rbpd; + if (!here->BSIM4v7delvtoGiven) + here->BSIM4v7delvto = 0.0; + if (!here->BSIM4v7xgwGiven) + here->BSIM4v7xgw = model->BSIM4v7xgw; + if (!here->BSIM4v7ngconGiven) + here->BSIM4v7ngcon = model->BSIM4v7ngcon; /* Process instance model selectors, some * may override their global counterparts */ - if (!here->BSIM4rbodyModGiven) - here->BSIM4rbodyMod = model->BSIM4rbodyMod; - else if ((here->BSIM4rbodyMod != 0) && (here->BSIM4rbodyMod != 1) && (here->BSIM4rbodyMod != 2)) - { here->BSIM4rbodyMod = model->BSIM4rbodyMod; + if (!here->BSIM4v7rbodyModGiven) + here->BSIM4v7rbodyMod = model->BSIM4v7rbodyMod; + else if ((here->BSIM4v7rbodyMod != 0) && (here->BSIM4v7rbodyMod != 1) && (here->BSIM4v7rbodyMod != 2)) + { here->BSIM4v7rbodyMod = model->BSIM4v7rbodyMod; printf("Warning: rbodyMod has been set to its global value %d.\n", - model->BSIM4rbodyMod); + model->BSIM4v7rbodyMod); } - if (!here->BSIM4rgateModGiven) - here->BSIM4rgateMod = model->BSIM4rgateMod; - else if ((here->BSIM4rgateMod != 0) && (here->BSIM4rgateMod != 1) - && (here->BSIM4rgateMod != 2) && (here->BSIM4rgateMod != 3)) - { here->BSIM4rgateMod = model->BSIM4rgateMod; + if (!here->BSIM4v7rgateModGiven) + here->BSIM4v7rgateMod = model->BSIM4v7rgateMod; + else if ((here->BSIM4v7rgateMod != 0) && (here->BSIM4v7rgateMod != 1) + && (here->BSIM4v7rgateMod != 2) && (here->BSIM4v7rgateMod != 3)) + { here->BSIM4v7rgateMod = model->BSIM4v7rgateMod; printf("Warning: rgateMod has been set to its global value %d.\n", - model->BSIM4rgateMod); + model->BSIM4v7rgateMod); } - if (!here->BSIM4geoModGiven) - here->BSIM4geoMod = model->BSIM4geoMod; + if (!here->BSIM4v7geoModGiven) + here->BSIM4v7geoMod = model->BSIM4v7geoMod; - if (!here->BSIM4rgeoModGiven) - here->BSIM4rgeoMod = model->BSIM4rgeoMod; - else if ((here->BSIM4rgeoMod != 0) && (here->BSIM4rgeoMod != 1)) - { here->BSIM4rgeoMod = model->BSIM4rgeoMod; + if (!here->BSIM4v7rgeoModGiven) + here->BSIM4v7rgeoMod = model->BSIM4v7rgeoMod; + else if ((here->BSIM4v7rgeoMod != 0) && (here->BSIM4v7rgeoMod != 1)) + { here->BSIM4v7rgeoMod = model->BSIM4v7rgeoMod; printf("Warning: rgeoMod has been set to its global value %d.\n", - model->BSIM4rgeoMod); + model->BSIM4v7rgeoMod); } - if (!here->BSIM4trnqsModGiven) - here->BSIM4trnqsMod = model->BSIM4trnqsMod; - else if ((here->BSIM4trnqsMod != 0) && (here->BSIM4trnqsMod != 1)) - { here->BSIM4trnqsMod = model->BSIM4trnqsMod; + if (!here->BSIM4v7trnqsModGiven) + here->BSIM4v7trnqsMod = model->BSIM4v7trnqsMod; + else if ((here->BSIM4v7trnqsMod != 0) && (here->BSIM4v7trnqsMod != 1)) + { here->BSIM4v7trnqsMod = model->BSIM4v7trnqsMod; printf("Warning: trnqsMod has been set to its global value %d.\n", - model->BSIM4trnqsMod); + model->BSIM4v7trnqsMod); } - if (!here->BSIM4acnqsModGiven) - here->BSIM4acnqsMod = model->BSIM4acnqsMod; - else if ((here->BSIM4acnqsMod != 0) && (here->BSIM4acnqsMod != 1)) - { here->BSIM4acnqsMod = model->BSIM4acnqsMod; + if (!here->BSIM4v7acnqsModGiven) + here->BSIM4v7acnqsMod = model->BSIM4v7acnqsMod; + else if ((here->BSIM4v7acnqsMod != 0) && (here->BSIM4v7acnqsMod != 1)) + { here->BSIM4v7acnqsMod = model->BSIM4v7acnqsMod; printf("Warning: acnqsMod has been set to its global value %d.\n", - model->BSIM4acnqsMod); + model->BSIM4v7acnqsMod); } /* stress effect */ - if (!here->BSIM4saGiven) - here->BSIM4sa = 0.0; - if (!here->BSIM4sbGiven) - here->BSIM4sb = 0.0; - if (!here->BSIM4sdGiven) - here->BSIM4sd = 2 * model->BSIM4dmcg; + if (!here->BSIM4v7saGiven) + here->BSIM4v7sa = 0.0; + if (!here->BSIM4v7sbGiven) + here->BSIM4v7sb = 0.0; + if (!here->BSIM4v7sdGiven) + here->BSIM4v7sd = 2 * model->BSIM4v7dmcg; /* Well Proximity Effect */ - if (!here->BSIM4scaGiven) - here->BSIM4sca = 0.0; - if (!here->BSIM4scbGiven) - here->BSIM4scb = 0.0; - if (!here->BSIM4sccGiven) - here->BSIM4scc = 0.0; - if (!here->BSIM4scGiven) - here->BSIM4sc = 0.0; /* m */ + if (!here->BSIM4v7scaGiven) + here->BSIM4v7sca = 0.0; + if (!here->BSIM4v7scbGiven) + here->BSIM4v7scb = 0.0; + if (!here->BSIM4v7sccGiven) + here->BSIM4v7scc = 0.0; + if (!here->BSIM4v7scGiven) + here->BSIM4v7sc = 0.0; /* m */ /* process drain series resistance */ createNode = 0; - if ( (model->BSIM4rdsMod != 0) - || (model->BSIM4tnoiMod == 1 && noiseAnalGiven)) + if ( (model->BSIM4v7rdsMod != 0) + || (model->BSIM4v7tnoiMod == 1 && noiseAnalGiven)) { createNode = 1; - } else if (model->BSIM4sheetResistance > 0) + } else if (model->BSIM4v7sheetResistance > 0) { - if (here->BSIM4drainSquaresGiven - && here->BSIM4drainSquares > 0) + if (here->BSIM4v7drainSquaresGiven + && here->BSIM4v7drainSquares > 0) { createNode = 1; - } else if (!here->BSIM4drainSquaresGiven - && (here->BSIM4rgeoMod != 0)) + } else if (!here->BSIM4v7drainSquaresGiven + && (here->BSIM4v7rgeoMod != 0)) { - BSIM4RdseffGeo(here->BSIM4nf*here->BSIM4m, here->BSIM4geoMod, - here->BSIM4rgeoMod, here->BSIM4min, - here->BSIM4w, model->BSIM4sheetResistance, + BSIM4v7RdseffGeo(here->BSIM4v7nf*here->BSIM4v7m, here->BSIM4v7geoMod, + here->BSIM4v7rgeoMod, here->BSIM4v7min, + here->BSIM4v7w, model->BSIM4v7sheetResistance, DMCGeff, DMCIeff, DMDGeff, 0, &Rtot); if(Rtot > 0) createNode = 1; } } if ( createNode != 0 ) - { if ( here->BSIM4dNodePrime == 0 ) - { error = CKTmkVolt(ckt,&tmp,here->BSIM4name,"drain"); + { if ( here->BSIM4v7dNodePrime == 0 ) + { error = CKTmkVolt(ckt,&tmp,here->BSIM4v7name,"drain"); if(error) return(error); - here->BSIM4dNodePrime = tmp->number; + here->BSIM4v7dNodePrime = tmp->number; if (ckt->CKTcopyNodesets) { CKTnode *tmpNode; IFuid tmpName; @@ -2352,37 +2352,37 @@ BSIM4instance **InstArray; } } else - { here->BSIM4dNodePrime = here->BSIM4dNode; + { here->BSIM4v7dNodePrime = here->BSIM4v7dNode; } /* process source series resistance */ createNode = 0; - if ( (model->BSIM4rdsMod != 0) - || (model->BSIM4tnoiMod == 1 && noiseAnalGiven)) + if ( (model->BSIM4v7rdsMod != 0) + || (model->BSIM4v7tnoiMod == 1 && noiseAnalGiven)) { createNode = 1; - } else if (model->BSIM4sheetResistance > 0) + } else if (model->BSIM4v7sheetResistance > 0) { - if (here->BSIM4sourceSquaresGiven - && here->BSIM4sourceSquares > 0) + if (here->BSIM4v7sourceSquaresGiven + && here->BSIM4v7sourceSquares > 0) { createNode = 1; - } else if (!here->BSIM4sourceSquaresGiven - && (here->BSIM4rgeoMod != 0)) + } else if (!here->BSIM4v7sourceSquaresGiven + && (here->BSIM4v7rgeoMod != 0)) { - BSIM4RdseffGeo(here->BSIM4nf*here->BSIM4m, here->BSIM4geoMod, - here->BSIM4rgeoMod, here->BSIM4min, - here->BSIM4w, model->BSIM4sheetResistance, + BSIM4v7RdseffGeo(here->BSIM4v7nf*here->BSIM4v7m, here->BSIM4v7geoMod, + here->BSIM4v7rgeoMod, here->BSIM4v7min, + here->BSIM4v7w, model->BSIM4v7sheetResistance, DMCGeff, DMCIeff, DMDGeff, 1, &Rtot); if(Rtot > 0) createNode = 1; } } if ( createNode != 0 ) - { if ( here->BSIM4sNodePrime == 0 ) - { error = CKTmkVolt(ckt,&tmp,here->BSIM4name,"source"); + { if ( here->BSIM4v7sNodePrime == 0 ) + { error = CKTmkVolt(ckt,&tmp,here->BSIM4v7name,"source"); if(error) return(error); - here->BSIM4sNodePrime = tmp->number; + here->BSIM4v7sNodePrime = tmp->number; if (ckt->CKTcopyNodesets) { CKTnode *tmpNode; IFuid tmpName; @@ -2396,13 +2396,13 @@ BSIM4instance **InstArray; } } else - here->BSIM4sNodePrime = here->BSIM4sNode; + here->BSIM4v7sNodePrime = here->BSIM4v7sNode; - if ( here->BSIM4rgateMod > 0 ) - { if ( here->BSIM4gNodePrime == 0 ) - { error = CKTmkVolt(ckt,&tmp,here->BSIM4name,"gate"); + if ( here->BSIM4v7rgateMod > 0 ) + { if ( here->BSIM4v7gNodePrime == 0 ) + { error = CKTmkVolt(ckt,&tmp,here->BSIM4v7name,"gate"); if(error) return(error); - here->BSIM4gNodePrime = tmp->number; + here->BSIM4v7gNodePrime = tmp->number; if (ckt->CKTcopyNodesets) { CKTnode *tmpNode; IFuid tmpName; @@ -2416,30 +2416,30 @@ BSIM4instance **InstArray; } } else - here->BSIM4gNodePrime = here->BSIM4gNodeExt; + here->BSIM4v7gNodePrime = here->BSIM4v7gNodeExt; - if ( here->BSIM4rgateMod == 3 ) - { if ( here->BSIM4gNodeMid == 0 ) - { error = CKTmkVolt(ckt,&tmp,here->BSIM4name,"midgate"); + if ( here->BSIM4v7rgateMod == 3 ) + { if ( here->BSIM4v7gNodeMid == 0 ) + { error = CKTmkVolt(ckt,&tmp,here->BSIM4v7name,"midgate"); if(error) return(error); - here->BSIM4gNodeMid = tmp->number; + here->BSIM4v7gNodeMid = tmp->number; } } else - here->BSIM4gNodeMid = here->BSIM4gNodeExt; + here->BSIM4v7gNodeMid = here->BSIM4v7gNodeExt; /* internal body nodes for body resistance model */ - if ((here->BSIM4rbodyMod ==1) || (here->BSIM4rbodyMod ==2)) - { if (here->BSIM4dbNode == 0) - { error = CKTmkVolt(ckt,&tmp,here->BSIM4name,"dbody"); + if ((here->BSIM4v7rbodyMod ==1) || (here->BSIM4v7rbodyMod ==2)) + { if (here->BSIM4v7dbNode == 0) + { error = CKTmkVolt(ckt,&tmp,here->BSIM4v7name,"dbody"); if(error) return(error); - here->BSIM4dbNode = tmp->number; + here->BSIM4v7dbNode = tmp->number; } - if (here->BSIM4bNodePrime == 0) - { error = CKTmkVolt(ckt,&tmp,here->BSIM4name,"body"); + if (here->BSIM4v7bNodePrime == 0) + { error = CKTmkVolt(ckt,&tmp,here->BSIM4v7name,"body"); if(error) return(error); - here->BSIM4bNodePrime = tmp->number; + here->BSIM4v7bNodePrime = tmp->number; if (ckt->CKTcopyNodesets) { CKTnode *tmpNode; IFuid tmpName; @@ -2451,26 +2451,26 @@ BSIM4instance **InstArray; } } } - if (here->BSIM4sbNode == 0) - { error = CKTmkVolt(ckt,&tmp,here->BSIM4name,"sbody"); + if (here->BSIM4v7sbNode == 0) + { error = CKTmkVolt(ckt,&tmp,here->BSIM4v7name,"sbody"); if(error) return(error); - here->BSIM4sbNode = tmp->number; + here->BSIM4v7sbNode = tmp->number; } } else - here->BSIM4dbNode = here->BSIM4bNodePrime = here->BSIM4sbNode - = here->BSIM4bNode; + here->BSIM4v7dbNode = here->BSIM4v7bNodePrime = here->BSIM4v7sbNode + = here->BSIM4v7bNode; /* NQS node */ - if ( here->BSIM4trnqsMod ) - { if ( here->BSIM4qNode == 0 ) - { error = CKTmkVolt(ckt,&tmp,here->BSIM4name,"charge"); + if ( here->BSIM4v7trnqsMod ) + { if ( here->BSIM4v7qNode == 0 ) + { error = CKTmkVolt(ckt,&tmp,here->BSIM4v7name,"charge"); if(error) return(error); - here->BSIM4qNode = tmp->number; + here->BSIM4v7qNode = tmp->number; } } else - here->BSIM4qNode = 0; + here->BSIM4v7qNode = 0; /* set Sparse Matrix Pointers @@ -2480,126 +2480,126 @@ do { if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NUL return(E_NOMEM);\ } } while(0) - TSTALLOC(BSIM4DPbpPtr, BSIM4dNodePrime, BSIM4bNodePrime); - TSTALLOC(BSIM4GPbpPtr, BSIM4gNodePrime, BSIM4bNodePrime); - TSTALLOC(BSIM4SPbpPtr, BSIM4sNodePrime, BSIM4bNodePrime); + TSTALLOC(BSIM4v7DPbpPtr, BSIM4v7dNodePrime, BSIM4v7bNodePrime); + TSTALLOC(BSIM4v7GPbpPtr, BSIM4v7gNodePrime, BSIM4v7bNodePrime); + TSTALLOC(BSIM4v7SPbpPtr, BSIM4v7sNodePrime, BSIM4v7bNodePrime); - TSTALLOC(BSIM4BPdpPtr, BSIM4bNodePrime, BSIM4dNodePrime); - TSTALLOC(BSIM4BPgpPtr, BSIM4bNodePrime, BSIM4gNodePrime); - TSTALLOC(BSIM4BPspPtr, BSIM4bNodePrime, BSIM4sNodePrime); - TSTALLOC(BSIM4BPbpPtr, BSIM4bNodePrime, BSIM4bNodePrime); + TSTALLOC(BSIM4v7BPdpPtr, BSIM4v7bNodePrime, BSIM4v7dNodePrime); + TSTALLOC(BSIM4v7BPgpPtr, BSIM4v7bNodePrime, BSIM4v7gNodePrime); + TSTALLOC(BSIM4v7BPspPtr, BSIM4v7bNodePrime, BSIM4v7sNodePrime); + TSTALLOC(BSIM4v7BPbpPtr, BSIM4v7bNodePrime, BSIM4v7bNodePrime); - TSTALLOC(BSIM4DdPtr, BSIM4dNode, BSIM4dNode); - TSTALLOC(BSIM4GPgpPtr, BSIM4gNodePrime, BSIM4gNodePrime); - TSTALLOC(BSIM4SsPtr, BSIM4sNode, BSIM4sNode); - TSTALLOC(BSIM4DPdpPtr, BSIM4dNodePrime, BSIM4dNodePrime); - TSTALLOC(BSIM4SPspPtr, BSIM4sNodePrime, BSIM4sNodePrime); - TSTALLOC(BSIM4DdpPtr, BSIM4dNode, BSIM4dNodePrime); - TSTALLOC(BSIM4GPdpPtr, BSIM4gNodePrime, BSIM4dNodePrime); - TSTALLOC(BSIM4GPspPtr, BSIM4gNodePrime, BSIM4sNodePrime); - TSTALLOC(BSIM4SspPtr, BSIM4sNode, BSIM4sNodePrime); - TSTALLOC(BSIM4DPspPtr, BSIM4dNodePrime, BSIM4sNodePrime); - TSTALLOC(BSIM4DPdPtr, BSIM4dNodePrime, BSIM4dNode); - TSTALLOC(BSIM4DPgpPtr, BSIM4dNodePrime, BSIM4gNodePrime); - TSTALLOC(BSIM4SPgpPtr, BSIM4sNodePrime, BSIM4gNodePrime); - TSTALLOC(BSIM4SPsPtr, BSIM4sNodePrime, BSIM4sNode); - TSTALLOC(BSIM4SPdpPtr, BSIM4sNodePrime, BSIM4dNodePrime); + TSTALLOC(BSIM4v7DdPtr, BSIM4v7dNode, BSIM4v7dNode); + TSTALLOC(BSIM4v7GPgpPtr, BSIM4v7gNodePrime, BSIM4v7gNodePrime); + TSTALLOC(BSIM4v7SsPtr, BSIM4v7sNode, BSIM4v7sNode); + TSTALLOC(BSIM4v7DPdpPtr, BSIM4v7dNodePrime, BSIM4v7dNodePrime); + TSTALLOC(BSIM4v7SPspPtr, BSIM4v7sNodePrime, BSIM4v7sNodePrime); + TSTALLOC(BSIM4v7DdpPtr, BSIM4v7dNode, BSIM4v7dNodePrime); + TSTALLOC(BSIM4v7GPdpPtr, BSIM4v7gNodePrime, BSIM4v7dNodePrime); + TSTALLOC(BSIM4v7GPspPtr, BSIM4v7gNodePrime, BSIM4v7sNodePrime); + TSTALLOC(BSIM4v7SspPtr, BSIM4v7sNode, BSIM4v7sNodePrime); + TSTALLOC(BSIM4v7DPspPtr, BSIM4v7dNodePrime, BSIM4v7sNodePrime); + TSTALLOC(BSIM4v7DPdPtr, BSIM4v7dNodePrime, BSIM4v7dNode); + TSTALLOC(BSIM4v7DPgpPtr, BSIM4v7dNodePrime, BSIM4v7gNodePrime); + TSTALLOC(BSIM4v7SPgpPtr, BSIM4v7sNodePrime, BSIM4v7gNodePrime); + TSTALLOC(BSIM4v7SPsPtr, BSIM4v7sNodePrime, BSIM4v7sNode); + TSTALLOC(BSIM4v7SPdpPtr, BSIM4v7sNodePrime, BSIM4v7dNodePrime); - TSTALLOC(BSIM4QqPtr, BSIM4qNode, BSIM4qNode); - TSTALLOC(BSIM4QbpPtr, BSIM4qNode, BSIM4bNodePrime) ; - TSTALLOC(BSIM4QdpPtr, BSIM4qNode, BSIM4dNodePrime); - TSTALLOC(BSIM4QspPtr, BSIM4qNode, BSIM4sNodePrime); - TSTALLOC(BSIM4QgpPtr, BSIM4qNode, BSIM4gNodePrime); - TSTALLOC(BSIM4DPqPtr, BSIM4dNodePrime, BSIM4qNode); - TSTALLOC(BSIM4SPqPtr, BSIM4sNodePrime, BSIM4qNode); - TSTALLOC(BSIM4GPqPtr, BSIM4gNodePrime, BSIM4qNode); + TSTALLOC(BSIM4v7QqPtr, BSIM4v7qNode, BSIM4v7qNode); + TSTALLOC(BSIM4v7QbpPtr, BSIM4v7qNode, BSIM4v7bNodePrime) ; + TSTALLOC(BSIM4v7QdpPtr, BSIM4v7qNode, BSIM4v7dNodePrime); + TSTALLOC(BSIM4v7QspPtr, BSIM4v7qNode, BSIM4v7sNodePrime); + TSTALLOC(BSIM4v7QgpPtr, BSIM4v7qNode, BSIM4v7gNodePrime); + TSTALLOC(BSIM4v7DPqPtr, BSIM4v7dNodePrime, BSIM4v7qNode); + TSTALLOC(BSIM4v7SPqPtr, BSIM4v7sNodePrime, BSIM4v7qNode); + TSTALLOC(BSIM4v7GPqPtr, BSIM4v7gNodePrime, BSIM4v7qNode); - if (here->BSIM4rgateMod != 0) - { TSTALLOC(BSIM4GEgePtr, BSIM4gNodeExt, BSIM4gNodeExt); - TSTALLOC(BSIM4GEgpPtr, BSIM4gNodeExt, BSIM4gNodePrime); - TSTALLOC(BSIM4GPgePtr, BSIM4gNodePrime, BSIM4gNodeExt); - TSTALLOC(BSIM4GEdpPtr, BSIM4gNodeExt, BSIM4dNodePrime); - TSTALLOC(BSIM4GEspPtr, BSIM4gNodeExt, BSIM4sNodePrime); - TSTALLOC(BSIM4GEbpPtr, BSIM4gNodeExt, BSIM4bNodePrime); + if (here->BSIM4v7rgateMod != 0) + { TSTALLOC(BSIM4v7GEgePtr, BSIM4v7gNodeExt, BSIM4v7gNodeExt); + TSTALLOC(BSIM4v7GEgpPtr, BSIM4v7gNodeExt, BSIM4v7gNodePrime); + TSTALLOC(BSIM4v7GPgePtr, BSIM4v7gNodePrime, BSIM4v7gNodeExt); + TSTALLOC(BSIM4v7GEdpPtr, BSIM4v7gNodeExt, BSIM4v7dNodePrime); + TSTALLOC(BSIM4v7GEspPtr, BSIM4v7gNodeExt, BSIM4v7sNodePrime); + TSTALLOC(BSIM4v7GEbpPtr, BSIM4v7gNodeExt, BSIM4v7bNodePrime); - TSTALLOC(BSIM4GMdpPtr, BSIM4gNodeMid, BSIM4dNodePrime); - TSTALLOC(BSIM4GMgpPtr, BSIM4gNodeMid, BSIM4gNodePrime); - TSTALLOC(BSIM4GMgmPtr, BSIM4gNodeMid, BSIM4gNodeMid); - TSTALLOC(BSIM4GMgePtr, BSIM4gNodeMid, BSIM4gNodeExt); - TSTALLOC(BSIM4GMspPtr, BSIM4gNodeMid, BSIM4sNodePrime); - TSTALLOC(BSIM4GMbpPtr, BSIM4gNodeMid, BSIM4bNodePrime); - TSTALLOC(BSIM4DPgmPtr, BSIM4dNodePrime, BSIM4gNodeMid); - TSTALLOC(BSIM4GPgmPtr, BSIM4gNodePrime, BSIM4gNodeMid); - TSTALLOC(BSIM4GEgmPtr, BSIM4gNodeExt, BSIM4gNodeMid); - TSTALLOC(BSIM4SPgmPtr, BSIM4sNodePrime, BSIM4gNodeMid); - TSTALLOC(BSIM4BPgmPtr, BSIM4bNodePrime, BSIM4gNodeMid); + TSTALLOC(BSIM4v7GMdpPtr, BSIM4v7gNodeMid, BSIM4v7dNodePrime); + TSTALLOC(BSIM4v7GMgpPtr, BSIM4v7gNodeMid, BSIM4v7gNodePrime); + TSTALLOC(BSIM4v7GMgmPtr, BSIM4v7gNodeMid, BSIM4v7gNodeMid); + TSTALLOC(BSIM4v7GMgePtr, BSIM4v7gNodeMid, BSIM4v7gNodeExt); + TSTALLOC(BSIM4v7GMspPtr, BSIM4v7gNodeMid, BSIM4v7sNodePrime); + TSTALLOC(BSIM4v7GMbpPtr, BSIM4v7gNodeMid, BSIM4v7bNodePrime); + TSTALLOC(BSIM4v7DPgmPtr, BSIM4v7dNodePrime, BSIM4v7gNodeMid); + TSTALLOC(BSIM4v7GPgmPtr, BSIM4v7gNodePrime, BSIM4v7gNodeMid); + TSTALLOC(BSIM4v7GEgmPtr, BSIM4v7gNodeExt, BSIM4v7gNodeMid); + TSTALLOC(BSIM4v7SPgmPtr, BSIM4v7sNodePrime, BSIM4v7gNodeMid); + TSTALLOC(BSIM4v7BPgmPtr, BSIM4v7bNodePrime, BSIM4v7gNodeMid); } - if ((here->BSIM4rbodyMod ==1) || (here->BSIM4rbodyMod ==2)) - { TSTALLOC(BSIM4DPdbPtr, BSIM4dNodePrime, BSIM4dbNode); - TSTALLOC(BSIM4SPsbPtr, BSIM4sNodePrime, BSIM4sbNode); + if ((here->BSIM4v7rbodyMod ==1) || (here->BSIM4v7rbodyMod ==2)) + { TSTALLOC(BSIM4v7DPdbPtr, BSIM4v7dNodePrime, BSIM4v7dbNode); + TSTALLOC(BSIM4v7SPsbPtr, BSIM4v7sNodePrime, BSIM4v7sbNode); - TSTALLOC(BSIM4DBdpPtr, BSIM4dbNode, BSIM4dNodePrime); - TSTALLOC(BSIM4DBdbPtr, BSIM4dbNode, BSIM4dbNode); - TSTALLOC(BSIM4DBbpPtr, BSIM4dbNode, BSIM4bNodePrime); - TSTALLOC(BSIM4DBbPtr, BSIM4dbNode, BSIM4bNode); + TSTALLOC(BSIM4v7DBdpPtr, BSIM4v7dbNode, BSIM4v7dNodePrime); + TSTALLOC(BSIM4v7DBdbPtr, BSIM4v7dbNode, BSIM4v7dbNode); + TSTALLOC(BSIM4v7DBbpPtr, BSIM4v7dbNode, BSIM4v7bNodePrime); + TSTALLOC(BSIM4v7DBbPtr, BSIM4v7dbNode, BSIM4v7bNode); - TSTALLOC(BSIM4BPdbPtr, BSIM4bNodePrime, BSIM4dbNode); - TSTALLOC(BSIM4BPbPtr, BSIM4bNodePrime, BSIM4bNode); - TSTALLOC(BSIM4BPsbPtr, BSIM4bNodePrime, BSIM4sbNode); + TSTALLOC(BSIM4v7BPdbPtr, BSIM4v7bNodePrime, BSIM4v7dbNode); + TSTALLOC(BSIM4v7BPbPtr, BSIM4v7bNodePrime, BSIM4v7bNode); + TSTALLOC(BSIM4v7BPsbPtr, BSIM4v7bNodePrime, BSIM4v7sbNode); - TSTALLOC(BSIM4SBspPtr, BSIM4sbNode, BSIM4sNodePrime); - TSTALLOC(BSIM4SBbpPtr, BSIM4sbNode, BSIM4bNodePrime); - TSTALLOC(BSIM4SBbPtr, BSIM4sbNode, BSIM4bNode); - TSTALLOC(BSIM4SBsbPtr, BSIM4sbNode, BSIM4sbNode); + TSTALLOC(BSIM4v7SBspPtr, BSIM4v7sbNode, BSIM4v7sNodePrime); + TSTALLOC(BSIM4v7SBbpPtr, BSIM4v7sbNode, BSIM4v7bNodePrime); + TSTALLOC(BSIM4v7SBbPtr, BSIM4v7sbNode, BSIM4v7bNode); + TSTALLOC(BSIM4v7SBsbPtr, BSIM4v7sbNode, BSIM4v7sbNode); - TSTALLOC(BSIM4BdbPtr, BSIM4bNode, BSIM4dbNode); - TSTALLOC(BSIM4BbpPtr, BSIM4bNode, BSIM4bNodePrime); - TSTALLOC(BSIM4BsbPtr, BSIM4bNode, BSIM4sbNode); - TSTALLOC(BSIM4BbPtr, BSIM4bNode, BSIM4bNode); + TSTALLOC(BSIM4v7BdbPtr, BSIM4v7bNode, BSIM4v7dbNode); + TSTALLOC(BSIM4v7BbpPtr, BSIM4v7bNode, BSIM4v7bNodePrime); + TSTALLOC(BSIM4v7BsbPtr, BSIM4v7bNode, BSIM4v7sbNode); + TSTALLOC(BSIM4v7BbPtr, BSIM4v7bNode, BSIM4v7bNode); } - if (model->BSIM4rdsMod) - { TSTALLOC(BSIM4DgpPtr, BSIM4dNode, BSIM4gNodePrime); - TSTALLOC(BSIM4DspPtr, BSIM4dNode, BSIM4sNodePrime); - TSTALLOC(BSIM4DbpPtr, BSIM4dNode, BSIM4bNodePrime); - TSTALLOC(BSIM4SdpPtr, BSIM4sNode, BSIM4dNodePrime); - TSTALLOC(BSIM4SgpPtr, BSIM4sNode, BSIM4gNodePrime); - TSTALLOC(BSIM4SbpPtr, BSIM4sNode, BSIM4bNodePrime); + if (model->BSIM4v7rdsMod) + { TSTALLOC(BSIM4v7DgpPtr, BSIM4v7dNode, BSIM4v7gNodePrime); + TSTALLOC(BSIM4v7DspPtr, BSIM4v7dNode, BSIM4v7sNodePrime); + TSTALLOC(BSIM4v7DbpPtr, BSIM4v7dNode, BSIM4v7bNodePrime); + TSTALLOC(BSIM4v7SdpPtr, BSIM4v7sNode, BSIM4v7dNodePrime); + TSTALLOC(BSIM4v7SgpPtr, BSIM4v7sNode, BSIM4v7gNodePrime); + TSTALLOC(BSIM4v7SbpPtr, BSIM4v7sNode, BSIM4v7bNodePrime); } } } #ifdef USE_OMP InstCount = 0; - model = (BSIM4model*)inModel; - /* loop through all the BSIM4 device models + model = (BSIM4v7model*)inModel; + /* loop through all the BSIM4v7 device models to count the number of instances */ - for( ; model != NULL; model = model->BSIM4nextModel ) + for( ; model != NULL; model = model->BSIM4v7nextModel ) { /* loop through all the instances of the model */ - for (here = model->BSIM4instances; here != NULL ; - here=here->BSIM4nextInstance) + for (here = model->BSIM4v7instances; here != NULL ; + here=here->BSIM4v7nextInstance) { InstCount++; } } - InstArray = TMALLOC(BSIM4instance*, InstCount); - model = (BSIM4model*)inModel; + InstArray = TMALLOC(BSIM4v7instance*, InstCount); + model = (BSIM4v7model*)inModel; idx = 0; - for( ; model != NULL; model = model->BSIM4nextModel ) + for( ; model != NULL; model = model->BSIM4v7nextModel ) { /* loop through all the instances of the model */ - for (here = model->BSIM4instances; here != NULL ; - here=here->BSIM4nextInstance) + for (here = model->BSIM4v7instances; here != NULL ; + here=here->BSIM4v7nextInstance) { InstArray[idx] = here; idx++; } /* set the array pointer and instance count into each model */ - model->BSIM4InstCount = InstCount; - model->BSIM4InstanceArray = InstArray; + model->BSIM4v7InstCount = InstCount; + model->BSIM4v7InstanceArray = InstArray; } #endif @@ -2607,31 +2607,31 @@ do { if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NUL } int -BSIM4unsetup( +BSIM4v7unsetup( GENmodel *inModel, CKTcircuit *ckt) { #ifndef HAS_BATCHSIM - BSIM4model *model; - BSIM4instance *here; + BSIM4v7model *model; + BSIM4v7instance *here; - for (model = (BSIM4model *)inModel; model != NULL; - model = model->BSIM4nextModel) + for (model = (BSIM4v7model *)inModel; model != NULL; + model = model->BSIM4v7nextModel) { - for (here = model->BSIM4instances; here != NULL; - here=here->BSIM4nextInstance) + for (here = model->BSIM4v7instances; here != NULL; + here=here->BSIM4v7nextInstance) { - if (here->BSIM4dNodePrime - && here->BSIM4dNodePrime != here->BSIM4dNode) + if (here->BSIM4v7dNodePrime + && here->BSIM4v7dNodePrime != here->BSIM4v7dNode) { - CKTdltNNum(ckt, here->BSIM4dNodePrime); - here->BSIM4dNodePrime = 0; + CKTdltNNum(ckt, here->BSIM4v7dNodePrime); + here->BSIM4v7dNodePrime = 0; } - if (here->BSIM4sNodePrime - && here->BSIM4sNodePrime != here->BSIM4sNode) + if (here->BSIM4v7sNodePrime + && here->BSIM4v7sNodePrime != here->BSIM4v7sNode) { - CKTdltNNum(ckt, here->BSIM4sNodePrime); - here->BSIM4sNodePrime = 0; + CKTdltNNum(ckt, here->BSIM4v7sNodePrime); + here->BSIM4v7sNodePrime = 0; } } } diff --git a/src/spicelib/devices/bsim4v7/b4v7soachk.c b/src/spicelib/devices/bsim4v7/b4v7soachk.c index c8b0d4b2d..9cae237e5 100644 --- a/src/spicelib/devices/bsim4v7/b4v7soachk.c +++ b/src/spicelib/devices/bsim4v7/b4v7soachk.c @@ -5,7 +5,7 @@ Author: 2013 Dietmar Warning #include "ngspice/ngspice.h" #include "ngspice/cktdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/trandefs.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" @@ -13,10 +13,10 @@ Author: 2013 Dietmar Warning int -BSIM4soaCheck(CKTcircuit *ckt, GENmodel *inModel) +BSIM4v7soaCheck(CKTcircuit *ckt, GENmodel *inModel) { - BSIM4model *model = (BSIM4model *) inModel; - BSIM4instance *here; + BSIM4v7model *model = (BSIM4v7model *) inModel; + BSIM4v7instance *here; double vgs, vgd, vgb, vds, vbs, vbd; /* actual mos voltages */ int maxwarns; static int warns_vgs = 0, warns_vgd = 0, warns_vgb = 0, warns_vds = 0, warns_vbs = 0, warns_vbd = 0; @@ -33,73 +33,73 @@ BSIM4soaCheck(CKTcircuit *ckt, GENmodel *inModel) maxwarns = ckt->CKTsoaMaxWarns; - for (; model; model = model->BSIM4nextModel) { + for (; model; model = model->BSIM4v7nextModel) { - for (here = model->BSIM4instances; here; here = here->BSIM4nextInstance) { + for (here = model->BSIM4v7instances; here; here = here->BSIM4v7nextInstance) { - vgs = fabs(ckt->CKTrhsOld [here->BSIM4gNodePrime] - - ckt->CKTrhsOld [here->BSIM4sNodePrime]); + vgs = fabs(ckt->CKTrhsOld [here->BSIM4v7gNodePrime] - + ckt->CKTrhsOld [here->BSIM4v7sNodePrime]); - vgd = fabs(ckt->CKTrhsOld [here->BSIM4gNodePrime] - - ckt->CKTrhsOld [here->BSIM4dNodePrime]); + vgd = fabs(ckt->CKTrhsOld [here->BSIM4v7gNodePrime] - + ckt->CKTrhsOld [here->BSIM4v7dNodePrime]); - vgb = fabs(ckt->CKTrhsOld [here->BSIM4gNodePrime] - - ckt->CKTrhsOld [here->BSIM4bNodePrime]); + vgb = fabs(ckt->CKTrhsOld [here->BSIM4v7gNodePrime] - + ckt->CKTrhsOld [here->BSIM4v7bNodePrime]); - vds = fabs(ckt->CKTrhsOld [here->BSIM4dNodePrime] - - ckt->CKTrhsOld [here->BSIM4sNodePrime]); + vds = fabs(ckt->CKTrhsOld [here->BSIM4v7dNodePrime] - + ckt->CKTrhsOld [here->BSIM4v7sNodePrime]); - vbs = fabs(ckt->CKTrhsOld [here->BSIM4bNodePrime] - - ckt->CKTrhsOld [here->BSIM4sNodePrime]); + vbs = fabs(ckt->CKTrhsOld [here->BSIM4v7bNodePrime] - + ckt->CKTrhsOld [here->BSIM4v7sNodePrime]); - vbd = fabs(ckt->CKTrhsOld [here->BSIM4bNodePrime] - - ckt->CKTrhsOld [here->BSIM4dNodePrime]); + vbd = fabs(ckt->CKTrhsOld [here->BSIM4v7bNodePrime] - + ckt->CKTrhsOld [here->BSIM4v7dNodePrime]); - if (vgs > model->BSIM4vgsMax) + if (vgs > model->BSIM4v7vgsMax) if (warns_vgs < maxwarns) { soa_printf(ckt, (GENinstance*) here, "|Vgs|=%g has exceeded Vgs_max=%g\n", - vgs, model->BSIM4vgsMax); + vgs, model->BSIM4v7vgsMax); warns_vgs++; } - if (vgd > model->BSIM4vgdMax) + if (vgd > model->BSIM4v7vgdMax) if (warns_vgd < maxwarns) { soa_printf(ckt, (GENinstance*) here, "|Vgd|=%g has exceeded Vgd_max=%g\n", - vgd, model->BSIM4vgdMax); + vgd, model->BSIM4v7vgdMax); warns_vgd++; } - if (vgb > model->BSIM4vgbMax) + if (vgb > model->BSIM4v7vgbMax) if (warns_vgb < maxwarns) { soa_printf(ckt, (GENinstance*) here, "|Vgb|=%g has exceeded Vgb_max=%g\n", - vgb, model->BSIM4vgbMax); + vgb, model->BSIM4v7vgbMax); warns_vgb++; } - if (vds > model->BSIM4vdsMax) + if (vds > model->BSIM4v7vdsMax) if (warns_vds < maxwarns) { soa_printf(ckt, (GENinstance*) here, "|Vds|=%g has exceeded Vds_max=%g\n", - vds, model->BSIM4vdsMax); + vds, model->BSIM4v7vdsMax); warns_vds++; } - if (vbs > model->BSIM4vbsMax) + if (vbs > model->BSIM4v7vbsMax) if (warns_vbs < maxwarns) { soa_printf(ckt, (GENinstance*) here, "|Vbs|=%g has exceeded Vbs_max=%g\n", - vbs, model->BSIM4vbsMax); + vbs, model->BSIM4v7vbsMax); warns_vbs++; } - if (vbd > model->BSIM4vbdMax) + if (vbd > model->BSIM4v7vbdMax) if (warns_vbd < maxwarns) { soa_printf(ckt, (GENinstance*) here, "|Vbd|=%g has exceeded Vbd_max=%g\n", - vbd, model->BSIM4vbdMax); + vbd, model->BSIM4v7vbdMax); warns_vbd++; } diff --git a/src/spicelib/devices/bsim4v7/b4v7temp.c b/src/spicelib/devices/bsim4v7/b4v7temp.c index ba0c840f8..03a9a6a59 100644 --- a/src/spicelib/devices/bsim4v7/b4v7temp.c +++ b/src/spicelib/devices/bsim4v7/b4v7temp.c @@ -25,7 +25,7 @@ #include "ngspice/ngspice.h" #include "ngspice/smpdefs.h" #include "ngspice/cktdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/const.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" @@ -51,7 +51,7 @@ } static int -BSIM4DioIjthVjmEval( +BSIM4v7DioIjthVjmEval( double Nvtm, double Ijth, double Isb, double XExpBV, double *Vjm) { @@ -67,12 +67,12 @@ return 0; int -BSIM4temp( +BSIM4v7temp( GENmodel *inModel, CKTcircuit *ckt) { -BSIM4model *model = (BSIM4model*) inModel; -BSIM4instance *here; +BSIM4v7model *model = (BSIM4v7model*) inModel; +BSIM4v7instance *here; struct bsim4SizeDependParam *pSizeDependParamKnot, *pLastKnot, *pParam=NULL; double tmp, tmp1, tmp2, tmp3, Eg, Eg0, ni, epssub; double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Lnew=0.0, Wnew; @@ -91,111 +91,111 @@ double vtfbphi2eot, phieot, TempRatioeot, Vtm0eot, Vtmeot,vbieot; int Size_Not_Found, i; - /* loop through all the BSIM4 device models */ - for (; model != NULL; model = model->BSIM4nextModel) + /* loop through all the BSIM4v7 device models */ + for (; model != NULL; model = model->BSIM4v7nextModel) { Temp = ckt->CKTtemp; - if (model->BSIM4SbulkJctPotential < 0.1) - { model->BSIM4SbulkJctPotential = 0.1; + if (model->BSIM4v7SbulkJctPotential < 0.1) + { model->BSIM4v7SbulkJctPotential = 0.1; fprintf(stderr, "Given pbs is less than 0.1. Pbs is set to 0.1.\n"); } - if (model->BSIM4SsidewallJctPotential < 0.1) - { model->BSIM4SsidewallJctPotential = 0.1; + if (model->BSIM4v7SsidewallJctPotential < 0.1) + { model->BSIM4v7SsidewallJctPotential = 0.1; fprintf(stderr, "Given pbsws is less than 0.1. Pbsws is set to 0.1.\n"); } - if (model->BSIM4SGatesidewallJctPotential < 0.1) - { model->BSIM4SGatesidewallJctPotential = 0.1; + if (model->BSIM4v7SGatesidewallJctPotential < 0.1) + { model->BSIM4v7SGatesidewallJctPotential = 0.1; fprintf(stderr, "Given pbswgs is less than 0.1. Pbswgs is set to 0.1.\n"); } - if (model->BSIM4DbulkJctPotential < 0.1) - { model->BSIM4DbulkJctPotential = 0.1; + if (model->BSIM4v7DbulkJctPotential < 0.1) + { model->BSIM4v7DbulkJctPotential = 0.1; fprintf(stderr, "Given pbd is less than 0.1. Pbd is set to 0.1.\n"); } - if (model->BSIM4DsidewallJctPotential < 0.1) - { model->BSIM4DsidewallJctPotential = 0.1; + if (model->BSIM4v7DsidewallJctPotential < 0.1) + { model->BSIM4v7DsidewallJctPotential = 0.1; fprintf(stderr, "Given pbswd is less than 0.1. Pbswd is set to 0.1.\n"); } - if (model->BSIM4DGatesidewallJctPotential < 0.1) - { model->BSIM4DGatesidewallJctPotential = 0.1; + if (model->BSIM4v7DGatesidewallJctPotential < 0.1) + { model->BSIM4v7DGatesidewallJctPotential = 0.1; fprintf(stderr, "Given pbswgd is less than 0.1. Pbswgd is set to 0.1.\n"); } - if(model->BSIM4mtrlMod == 0) + if(model->BSIM4v7mtrlMod == 0) { - if ((model->BSIM4toxeGiven) && (model->BSIM4toxpGiven) && (model->BSIM4dtoxGiven) - && (model->BSIM4toxe != (model->BSIM4toxp + model->BSIM4dtox))) + if ((model->BSIM4v7toxeGiven) && (model->BSIM4v7toxpGiven) && (model->BSIM4v7dtoxGiven) + && (model->BSIM4v7toxe != (model->BSIM4v7toxp + model->BSIM4v7dtox))) printf("Warning: toxe, toxp and dtox all given and toxe != toxp + dtox; dtox ignored.\n"); - else if ((model->BSIM4toxeGiven) && (!model->BSIM4toxpGiven)) - model->BSIM4toxp = model->BSIM4toxe - model->BSIM4dtox; - else if ((!model->BSIM4toxeGiven) && (model->BSIM4toxpGiven)){ - model->BSIM4toxe = model->BSIM4toxp + model->BSIM4dtox; - if (!model->BSIM4toxmGiven) /* v4.7 */ - model->BSIM4toxm = model->BSIM4toxe; + else if ((model->BSIM4v7toxeGiven) && (!model->BSIM4v7toxpGiven)) + model->BSIM4v7toxp = model->BSIM4v7toxe - model->BSIM4v7dtox; + else if ((!model->BSIM4v7toxeGiven) && (model->BSIM4v7toxpGiven)){ + model->BSIM4v7toxe = model->BSIM4v7toxp + model->BSIM4v7dtox; + if (!model->BSIM4v7toxmGiven) /* v4.7 */ + model->BSIM4v7toxm = model->BSIM4v7toxe; } } - else if(model->BSIM4mtrlCompatMod != 0) /* v4.7 */ + else if(model->BSIM4v7mtrlCompatMod != 0) /* v4.7 */ { - T0 = model->BSIM4epsrox / 3.9; - if ((model->BSIM4eotGiven) && (model->BSIM4toxpGiven) && (model->BSIM4dtoxGiven) - && (ABS(model->BSIM4eot * T0 - (model->BSIM4toxp + model->BSIM4dtox)) > 1.0e-20)) + T0 = model->BSIM4v7epsrox / 3.9; + if ((model->BSIM4v7eotGiven) && (model->BSIM4v7toxpGiven) && (model->BSIM4v7dtoxGiven) + && (ABS(model->BSIM4v7eot * T0 - (model->BSIM4v7toxp + model->BSIM4v7dtox)) > 1.0e-20)) { printf("Warning: eot, toxp and dtox all given and eot * EPSROX / 3.9 != toxp + dtox; dtox ignored.\n"); } - else if ((model->BSIM4eotGiven) && (!model->BSIM4toxpGiven)) - model->BSIM4toxp = T0 * model->BSIM4eot - model->BSIM4dtox; - else if ((!model->BSIM4eotGiven) && (model->BSIM4toxpGiven)){ - model->BSIM4eot = (model->BSIM4toxp + model->BSIM4dtox) / T0; - if (!model->BSIM4toxmGiven) - model->BSIM4toxm = model->BSIM4eot; + else if ((model->BSIM4v7eotGiven) && (!model->BSIM4v7toxpGiven)) + model->BSIM4v7toxp = T0 * model->BSIM4v7eot - model->BSIM4v7dtox; + else if ((!model->BSIM4v7eotGiven) && (model->BSIM4v7toxpGiven)){ + model->BSIM4v7eot = (model->BSIM4v7toxp + model->BSIM4v7dtox) / T0; + if (!model->BSIM4v7toxmGiven) + model->BSIM4v7toxm = model->BSIM4v7eot; } } - if(model->BSIM4mtrlMod) + if(model->BSIM4v7mtrlMod) { epsrox = 3.9; - toxe = model->BSIM4eot; - epssub = EPS0 * model->BSIM4epsrsub; + toxe = model->BSIM4v7eot; + epssub = EPS0 * model->BSIM4v7epsrsub; } else { - epsrox = model->BSIM4epsrox; - toxe = model->BSIM4toxe; + epsrox = model->BSIM4v7epsrox; + toxe = model->BSIM4v7toxe; epssub = EPSSI; } - model->BSIM4coxe = epsrox * EPS0 / toxe; - if(model->BSIM4mtrlMod == 0 || model->BSIM4mtrlCompatMod != 0) - model->BSIM4coxp = model->BSIM4epsrox * EPS0 / model->BSIM4toxp; + model->BSIM4v7coxe = epsrox * EPS0 / toxe; + if(model->BSIM4v7mtrlMod == 0 || model->BSIM4v7mtrlCompatMod != 0) + model->BSIM4v7coxp = model->BSIM4v7epsrox * EPS0 / model->BSIM4v7toxp; - if (!model->BSIM4cgdoGiven) - { if (model->BSIM4dlcGiven && (model->BSIM4dlc > 0.0)) - model->BSIM4cgdo = model->BSIM4dlc * model->BSIM4coxe - - model->BSIM4cgdl ; + if (!model->BSIM4v7cgdoGiven) + { if (model->BSIM4v7dlcGiven && (model->BSIM4v7dlc > 0.0)) + model->BSIM4v7cgdo = model->BSIM4v7dlc * model->BSIM4v7coxe + - model->BSIM4v7cgdl ; else - model->BSIM4cgdo = 0.6 * model->BSIM4xj * model->BSIM4coxe; + model->BSIM4v7cgdo = 0.6 * model->BSIM4v7xj * model->BSIM4v7coxe; } - if (!model->BSIM4cgsoGiven) - { if (model->BSIM4dlcGiven && (model->BSIM4dlc > 0.0)) - model->BSIM4cgso = model->BSIM4dlc * model->BSIM4coxe - - model->BSIM4cgsl ; + if (!model->BSIM4v7cgsoGiven) + { if (model->BSIM4v7dlcGiven && (model->BSIM4v7dlc > 0.0)) + model->BSIM4v7cgso = model->BSIM4v7dlc * model->BSIM4v7coxe + - model->BSIM4v7cgsl ; else - model->BSIM4cgso = 0.6 * model->BSIM4xj * model->BSIM4coxe; + model->BSIM4v7cgso = 0.6 * model->BSIM4v7xj * model->BSIM4v7coxe; } - if (!model->BSIM4cgboGiven) - model->BSIM4cgbo = 2.0 * model->BSIM4dwc * model->BSIM4coxe; + if (!model->BSIM4v7cgboGiven) + model->BSIM4v7cgbo = 2.0 * model->BSIM4v7dwc * model->BSIM4v7coxe; model->pSizeDependParamKnot = NULL; pLastKnot = NULL; - Tnom = model->BSIM4tnom; + Tnom = model->BSIM4v7tnom; TRatio = Temp / Tnom; - model->BSIM4vcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14)); - model->BSIM4factor1 = sqrt(epssub / (epsrox * EPS0)* toxe); + model->BSIM4v7vcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14)); + model->BSIM4v7factor1 = sqrt(epssub / (epsrox * EPS0)* toxe); - Vtm0 = model->BSIM4vtm0 = KboQ * Tnom; + Vtm0 = model->BSIM4v7vtm0 = KboQ * Tnom; - if(model->BSIM4mtrlMod==0) + if(model->BSIM4v7mtrlMod==0) { Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0); ni = 1.45e10 * (Tnom / 300.15) * sqrt(Tnom / 300.15) @@ -203,218 +203,218 @@ int Size_Not_Found, i; } else { - Eg0 = model->BSIM4bg0sub - model->BSIM4tbgasub * Tnom * Tnom - / (Tnom + model->BSIM4tbgbsub); - T0 = model->BSIM4bg0sub - model->BSIM4tbgasub * 90090.0225 - / (300.15 + model->BSIM4tbgbsub); - ni = model->BSIM4ni0sub * (Tnom / 300.15) * sqrt(Tnom / 300.15) + Eg0 = model->BSIM4v7bg0sub - model->BSIM4v7tbgasub * Tnom * Tnom + / (Tnom + model->BSIM4v7tbgbsub); + T0 = model->BSIM4v7bg0sub - model->BSIM4v7tbgasub * 90090.0225 + / (300.15 + model->BSIM4v7tbgbsub); + ni = model->BSIM4v7ni0sub * (Tnom / 300.15) * sqrt(Tnom / 300.15) * exp((T0 - Eg0) / (2.0 * Vtm0)); } - model->BSIM4Eg0 = Eg0; - model->BSIM4vtm = KboQ * Temp; - if(model->BSIM4mtrlMod == 0) + model->BSIM4v7Eg0 = Eg0; + model->BSIM4v7vtm = KboQ * Temp; + if(model->BSIM4v7mtrlMod == 0) Eg = 1.16 - 7.02e-4 * Temp * Temp / (Temp + 1108.0); else - Eg = model->BSIM4bg0sub - model->BSIM4tbgasub * Temp * Temp - / (Temp + model->BSIM4tbgbsub); + Eg = model->BSIM4v7bg0sub - model->BSIM4v7tbgasub * Temp * Temp + / (Temp + model->BSIM4v7tbgbsub); if (Temp != Tnom) - { T0 = Eg0 / Vtm0 - Eg / model->BSIM4vtm; + { T0 = Eg0 / Vtm0 - Eg / model->BSIM4v7vtm; T1 = log(Temp / Tnom); - T2 = T0 + model->BSIM4SjctTempExponent * T1; - T3 = exp(T2 / model->BSIM4SjctEmissionCoeff); - model->BSIM4SjctTempSatCurDensity = model->BSIM4SjctSatCurDensity + T2 = T0 + model->BSIM4v7SjctTempExponent * T1; + T3 = exp(T2 / model->BSIM4v7SjctEmissionCoeff); + model->BSIM4v7SjctTempSatCurDensity = model->BSIM4v7SjctSatCurDensity * T3; - model->BSIM4SjctSidewallTempSatCurDensity - = model->BSIM4SjctSidewallSatCurDensity * T3; - model->BSIM4SjctGateSidewallTempSatCurDensity - = model->BSIM4SjctGateSidewallSatCurDensity * T3; + model->BSIM4v7SjctSidewallTempSatCurDensity + = model->BSIM4v7SjctSidewallSatCurDensity * T3; + model->BSIM4v7SjctGateSidewallTempSatCurDensity + = model->BSIM4v7SjctGateSidewallSatCurDensity * T3; - T2 = T0 + model->BSIM4DjctTempExponent * T1; - T3 = exp(T2 / model->BSIM4DjctEmissionCoeff); - model->BSIM4DjctTempSatCurDensity = model->BSIM4DjctSatCurDensity + T2 = T0 + model->BSIM4v7DjctTempExponent * T1; + T3 = exp(T2 / model->BSIM4v7DjctEmissionCoeff); + model->BSIM4v7DjctTempSatCurDensity = model->BSIM4v7DjctSatCurDensity * T3; - model->BSIM4DjctSidewallTempSatCurDensity - = model->BSIM4DjctSidewallSatCurDensity * T3; - model->BSIM4DjctGateSidewallTempSatCurDensity - = model->BSIM4DjctGateSidewallSatCurDensity * T3; + model->BSIM4v7DjctSidewallTempSatCurDensity + = model->BSIM4v7DjctSidewallSatCurDensity * T3; + model->BSIM4v7DjctGateSidewallTempSatCurDensity + = model->BSIM4v7DjctGateSidewallSatCurDensity * T3; } else - { model->BSIM4SjctTempSatCurDensity = model->BSIM4SjctSatCurDensity; - model->BSIM4SjctSidewallTempSatCurDensity - = model->BSIM4SjctSidewallSatCurDensity; - model->BSIM4SjctGateSidewallTempSatCurDensity - = model->BSIM4SjctGateSidewallSatCurDensity; - model->BSIM4DjctTempSatCurDensity = model->BSIM4DjctSatCurDensity; - model->BSIM4DjctSidewallTempSatCurDensity - = model->BSIM4DjctSidewallSatCurDensity; - model->BSIM4DjctGateSidewallTempSatCurDensity - = model->BSIM4DjctGateSidewallSatCurDensity; + { model->BSIM4v7SjctTempSatCurDensity = model->BSIM4v7SjctSatCurDensity; + model->BSIM4v7SjctSidewallTempSatCurDensity + = model->BSIM4v7SjctSidewallSatCurDensity; + model->BSIM4v7SjctGateSidewallTempSatCurDensity + = model->BSIM4v7SjctGateSidewallSatCurDensity; + model->BSIM4v7DjctTempSatCurDensity = model->BSIM4v7DjctSatCurDensity; + model->BSIM4v7DjctSidewallTempSatCurDensity + = model->BSIM4v7DjctSidewallSatCurDensity; + model->BSIM4v7DjctGateSidewallTempSatCurDensity + = model->BSIM4v7DjctGateSidewallSatCurDensity; } - if (model->BSIM4SjctTempSatCurDensity < 0.0) - model->BSIM4SjctTempSatCurDensity = 0.0; - if (model->BSIM4SjctSidewallTempSatCurDensity < 0.0) - model->BSIM4SjctSidewallTempSatCurDensity = 0.0; - if (model->BSIM4SjctGateSidewallTempSatCurDensity < 0.0) - model->BSIM4SjctGateSidewallTempSatCurDensity = 0.0; - if (model->BSIM4DjctTempSatCurDensity < 0.0) - model->BSIM4DjctTempSatCurDensity = 0.0; - if (model->BSIM4DjctSidewallTempSatCurDensity < 0.0) - model->BSIM4DjctSidewallTempSatCurDensity = 0.0; - if (model->BSIM4DjctGateSidewallTempSatCurDensity < 0.0) - model->BSIM4DjctGateSidewallTempSatCurDensity = 0.0; + if (model->BSIM4v7SjctTempSatCurDensity < 0.0) + model->BSIM4v7SjctTempSatCurDensity = 0.0; + if (model->BSIM4v7SjctSidewallTempSatCurDensity < 0.0) + model->BSIM4v7SjctSidewallTempSatCurDensity = 0.0; + if (model->BSIM4v7SjctGateSidewallTempSatCurDensity < 0.0) + model->BSIM4v7SjctGateSidewallTempSatCurDensity = 0.0; + if (model->BSIM4v7DjctTempSatCurDensity < 0.0) + model->BSIM4v7DjctTempSatCurDensity = 0.0; + if (model->BSIM4v7DjctSidewallTempSatCurDensity < 0.0) + model->BSIM4v7DjctSidewallTempSatCurDensity = 0.0; + if (model->BSIM4v7DjctGateSidewallTempSatCurDensity < 0.0) + model->BSIM4v7DjctGateSidewallTempSatCurDensity = 0.0; /* Temperature dependence of D/B and S/B diode capacitance begins */ - delTemp = ckt->CKTtemp - model->BSIM4tnom; - T0 = model->BSIM4tcj * delTemp; + delTemp = ckt->CKTtemp - model->BSIM4v7tnom; + T0 = model->BSIM4v7tcj * delTemp; if (T0 >= -1.0) - { model->BSIM4SunitAreaTempJctCap = model->BSIM4SunitAreaJctCap *(1.0 + T0); /*bug_fix -JX */ - model->BSIM4DunitAreaTempJctCap = model->BSIM4DunitAreaJctCap *(1.0 + T0); + { model->BSIM4v7SunitAreaTempJctCap = model->BSIM4v7SunitAreaJctCap *(1.0 + T0); /*bug_fix -JX */ + model->BSIM4v7DunitAreaTempJctCap = model->BSIM4v7DunitAreaJctCap *(1.0 + T0); } else - { if (model->BSIM4SunitAreaJctCap > 0.0) - { model->BSIM4SunitAreaTempJctCap = 0.0; + { if (model->BSIM4v7SunitAreaJctCap > 0.0) + { model->BSIM4v7SunitAreaTempJctCap = 0.0; fprintf(stderr, "Temperature effect has caused cjs to be negative. Cjs is clamped to zero.\n"); } - if (model->BSIM4DunitAreaJctCap > 0.0) - { model->BSIM4DunitAreaTempJctCap = 0.0; + if (model->BSIM4v7DunitAreaJctCap > 0.0) + { model->BSIM4v7DunitAreaTempJctCap = 0.0; fprintf(stderr, "Temperature effect has caused cjd to be negative. Cjd is clamped to zero.\n"); } } - T0 = model->BSIM4tcjsw * delTemp; - if (model->BSIM4SunitLengthSidewallJctCap < 0.0)/*4.6.2*/ - {model->BSIM4SunitLengthSidewallJctCap = 0.0; + T0 = model->BSIM4v7tcjsw * delTemp; + if (model->BSIM4v7SunitLengthSidewallJctCap < 0.0)/*4.6.2*/ + {model->BSIM4v7SunitLengthSidewallJctCap = 0.0; fprintf(stderr, "CJSWS is negative. Cjsws is clamped to zero.\n");} - if (model->BSIM4DunitLengthSidewallJctCap < 0.0) - {model->BSIM4DunitLengthSidewallJctCap = 0.0; + if (model->BSIM4v7DunitLengthSidewallJctCap < 0.0) + {model->BSIM4v7DunitLengthSidewallJctCap = 0.0; fprintf(stderr, "CJSWD is negative. Cjswd is clamped to zero.\n");} if (T0 >= -1.0) - { model->BSIM4SunitLengthSidewallTempJctCap = model->BSIM4SunitLengthSidewallJctCap *(1.0 + T0); - model->BSIM4DunitLengthSidewallTempJctCap = model->BSIM4DunitLengthSidewallJctCap *(1.0 + T0); + { model->BSIM4v7SunitLengthSidewallTempJctCap = model->BSIM4v7SunitLengthSidewallJctCap *(1.0 + T0); + model->BSIM4v7DunitLengthSidewallTempJctCap = model->BSIM4v7DunitLengthSidewallJctCap *(1.0 + T0); } else - { if (model->BSIM4SunitLengthSidewallJctCap > 0.0) - { model->BSIM4SunitLengthSidewallTempJctCap = 0.0; + { if (model->BSIM4v7SunitLengthSidewallJctCap > 0.0) + { model->BSIM4v7SunitLengthSidewallTempJctCap = 0.0; fprintf(stderr, "Temperature effect has caused cjsws to be negative. Cjsws is clamped to zero.\n"); } - if (model->BSIM4DunitLengthSidewallJctCap > 0.0) - { model->BSIM4DunitLengthSidewallTempJctCap = 0.0; + if (model->BSIM4v7DunitLengthSidewallJctCap > 0.0) + { model->BSIM4v7DunitLengthSidewallTempJctCap = 0.0; fprintf(stderr, "Temperature effect has caused cjswd to be negative. Cjswd is clamped to zero.\n"); } } - T0 = model->BSIM4tcjswg * delTemp; + T0 = model->BSIM4v7tcjswg * delTemp; if (T0 >= -1.0) - { model->BSIM4SunitLengthGateSidewallTempJctCap = model->BSIM4SunitLengthGateSidewallJctCap *(1.0 + T0); - model->BSIM4DunitLengthGateSidewallTempJctCap = model->BSIM4DunitLengthGateSidewallJctCap *(1.0 + T0); + { model->BSIM4v7SunitLengthGateSidewallTempJctCap = model->BSIM4v7SunitLengthGateSidewallJctCap *(1.0 + T0); + model->BSIM4v7DunitLengthGateSidewallTempJctCap = model->BSIM4v7DunitLengthGateSidewallJctCap *(1.0 + T0); } else - { if (model->BSIM4SunitLengthGateSidewallJctCap > 0.0) - { model->BSIM4SunitLengthGateSidewallTempJctCap = 0.0; + { if (model->BSIM4v7SunitLengthGateSidewallJctCap > 0.0) + { model->BSIM4v7SunitLengthGateSidewallTempJctCap = 0.0; fprintf(stderr, "Temperature effect has caused cjswgs to be negative. Cjswgs is clamped to zero.\n"); } - if (model->BSIM4DunitLengthGateSidewallJctCap > 0.0) - { model->BSIM4DunitLengthGateSidewallTempJctCap = 0.0; + if (model->BSIM4v7DunitLengthGateSidewallJctCap > 0.0) + { model->BSIM4v7DunitLengthGateSidewallTempJctCap = 0.0; fprintf(stderr, "Temperature effect has caused cjswgd to be negative. Cjswgd is clamped to zero.\n"); } } - model->BSIM4PhiBS = model->BSIM4SbulkJctPotential - - model->BSIM4tpb * delTemp; - if (model->BSIM4PhiBS < 0.01) - { model->BSIM4PhiBS = 0.01; + model->BSIM4v7PhiBS = model->BSIM4v7SbulkJctPotential + - model->BSIM4v7tpb * delTemp; + if (model->BSIM4v7PhiBS < 0.01) + { model->BSIM4v7PhiBS = 0.01; fprintf(stderr, "Temperature effect has caused pbs to be less than 0.01. Pbs is clamped to 0.01.\n"); } - model->BSIM4PhiBD = model->BSIM4DbulkJctPotential - - model->BSIM4tpb * delTemp; - if (model->BSIM4PhiBD < 0.01) - { model->BSIM4PhiBD = 0.01; + model->BSIM4v7PhiBD = model->BSIM4v7DbulkJctPotential + - model->BSIM4v7tpb * delTemp; + if (model->BSIM4v7PhiBD < 0.01) + { model->BSIM4v7PhiBD = 0.01; fprintf(stderr, "Temperature effect has caused pbd to be less than 0.01. Pbd is clamped to 0.01.\n"); } - model->BSIM4PhiBSWS = model->BSIM4SsidewallJctPotential - - model->BSIM4tpbsw * delTemp; - if (model->BSIM4PhiBSWS <= 0.01) - { model->BSIM4PhiBSWS = 0.01; + model->BSIM4v7PhiBSWS = model->BSIM4v7SsidewallJctPotential + - model->BSIM4v7tpbsw * delTemp; + if (model->BSIM4v7PhiBSWS <= 0.01) + { model->BSIM4v7PhiBSWS = 0.01; fprintf(stderr, "Temperature effect has caused pbsws to be less than 0.01. Pbsws is clamped to 0.01.\n"); } - model->BSIM4PhiBSWD = model->BSIM4DsidewallJctPotential - - model->BSIM4tpbsw * delTemp; - if (model->BSIM4PhiBSWD <= 0.01) - { model->BSIM4PhiBSWD = 0.01; + model->BSIM4v7PhiBSWD = model->BSIM4v7DsidewallJctPotential + - model->BSIM4v7tpbsw * delTemp; + if (model->BSIM4v7PhiBSWD <= 0.01) + { model->BSIM4v7PhiBSWD = 0.01; fprintf(stderr, "Temperature effect has caused pbswd to be less than 0.01. Pbswd is clamped to 0.01.\n"); } - model->BSIM4PhiBSWGS = model->BSIM4SGatesidewallJctPotential - - model->BSIM4tpbswg * delTemp; - if (model->BSIM4PhiBSWGS <= 0.01) - { model->BSIM4PhiBSWGS = 0.01; + model->BSIM4v7PhiBSWGS = model->BSIM4v7SGatesidewallJctPotential + - model->BSIM4v7tpbswg * delTemp; + if (model->BSIM4v7PhiBSWGS <= 0.01) + { model->BSIM4v7PhiBSWGS = 0.01; fprintf(stderr, "Temperature effect has caused pbswgs to be less than 0.01. Pbswgs is clamped to 0.01.\n"); } - model->BSIM4PhiBSWGD = model->BSIM4DGatesidewallJctPotential - - model->BSIM4tpbswg * delTemp; - if (model->BSIM4PhiBSWGD <= 0.01) - { model->BSIM4PhiBSWGD = 0.01; + model->BSIM4v7PhiBSWGD = model->BSIM4v7DGatesidewallJctPotential + - model->BSIM4v7tpbswg * delTemp; + if (model->BSIM4v7PhiBSWGD <= 0.01) + { model->BSIM4v7PhiBSWGD = 0.01; fprintf(stderr, "Temperature effect has caused pbswgd to be less than 0.01. Pbswgd is clamped to 0.01.\n"); } /* End of junction capacitance */ - if (model->BSIM4ijthdfwd <= 0.0) - { model->BSIM4ijthdfwd = 0.0; - fprintf(stderr, "Ijthdfwd reset to %g.\n", model->BSIM4ijthdfwd); + if (model->BSIM4v7ijthdfwd <= 0.0) + { model->BSIM4v7ijthdfwd = 0.0; + fprintf(stderr, "Ijthdfwd reset to %g.\n", model->BSIM4v7ijthdfwd); } - if (model->BSIM4ijthsfwd <= 0.0) - { model->BSIM4ijthsfwd = 0.0; - fprintf(stderr, "Ijthsfwd reset to %g.\n", model->BSIM4ijthsfwd); + if (model->BSIM4v7ijthsfwd <= 0.0) + { model->BSIM4v7ijthsfwd = 0.0; + fprintf(stderr, "Ijthsfwd reset to %g.\n", model->BSIM4v7ijthsfwd); } - if (model->BSIM4ijthdrev <= 0.0) - { model->BSIM4ijthdrev = 0.0; - fprintf(stderr, "Ijthdrev reset to %g.\n", model->BSIM4ijthdrev); + if (model->BSIM4v7ijthdrev <= 0.0) + { model->BSIM4v7ijthdrev = 0.0; + fprintf(stderr, "Ijthdrev reset to %g.\n", model->BSIM4v7ijthdrev); } - if (model->BSIM4ijthsrev <= 0.0) - { model->BSIM4ijthsrev = 0.0; - fprintf(stderr, "Ijthsrev reset to %g.\n", model->BSIM4ijthsrev); + if (model->BSIM4v7ijthsrev <= 0.0) + { model->BSIM4v7ijthsrev = 0.0; + fprintf(stderr, "Ijthsrev reset to %g.\n", model->BSIM4v7ijthsrev); } - if ((model->BSIM4xjbvd <= 0.0) && (model->BSIM4dioMod == 2)) - { model->BSIM4xjbvd = 0.0; - fprintf(stderr, "Xjbvd reset to %g.\n", model->BSIM4xjbvd); + if ((model->BSIM4v7xjbvd <= 0.0) && (model->BSIM4v7dioMod == 2)) + { model->BSIM4v7xjbvd = 0.0; + fprintf(stderr, "Xjbvd reset to %g.\n", model->BSIM4v7xjbvd); } - else if ((model->BSIM4xjbvd < 0.0) && (model->BSIM4dioMod == 0)) - { model->BSIM4xjbvd = 0.0; - fprintf(stderr, "Xjbvd reset to %g.\n", model->BSIM4xjbvd); + else if ((model->BSIM4v7xjbvd < 0.0) && (model->BSIM4v7dioMod == 0)) + { model->BSIM4v7xjbvd = 0.0; + fprintf(stderr, "Xjbvd reset to %g.\n", model->BSIM4v7xjbvd); } - if (model->BSIM4bvd <= 0.0) /*4.6.2*/ - { model->BSIM4bvd = 0.0; - fprintf(stderr, "BVD reset to %g.\n", model->BSIM4bvd); + if (model->BSIM4v7bvd <= 0.0) /*4.6.2*/ + { model->BSIM4v7bvd = 0.0; + fprintf(stderr, "BVD reset to %g.\n", model->BSIM4v7bvd); } - if ((model->BSIM4xjbvs <= 0.0) && (model->BSIM4dioMod == 2)) - { model->BSIM4xjbvs = 0.0; - fprintf(stderr, "Xjbvs reset to %g.\n", model->BSIM4xjbvs); + if ((model->BSIM4v7xjbvs <= 0.0) && (model->BSIM4v7dioMod == 2)) + { model->BSIM4v7xjbvs = 0.0; + fprintf(stderr, "Xjbvs reset to %g.\n", model->BSIM4v7xjbvs); } - else if ((model->BSIM4xjbvs < 0.0) && (model->BSIM4dioMod == 0)) - { model->BSIM4xjbvs = 0.0; - fprintf(stderr, "Xjbvs reset to %g.\n", model->BSIM4xjbvs); + else if ((model->BSIM4v7xjbvs < 0.0) && (model->BSIM4v7dioMod == 0)) + { model->BSIM4v7xjbvs = 0.0; + fprintf(stderr, "Xjbvs reset to %g.\n", model->BSIM4v7xjbvs); } - if (model->BSIM4bvs <= 0.0) - { model->BSIM4bvs = 0.0; - fprintf(stderr, "BVS reset to %g.\n", model->BSIM4bvs); + if (model->BSIM4v7bvs <= 0.0) + { model->BSIM4v7bvs = 0.0; + fprintf(stderr, "BVS reset to %g.\n", model->BSIM4v7bvs); } /* loop through all the instances of the model */ - for (here = model->BSIM4instances; here != NULL; - here = here->BSIM4nextInstance) + for (here = model->BSIM4v7instances; here != NULL; + here = here->BSIM4v7nextInstance) { pSizeDependParamKnot = model->pSizeDependParamKnot; Size_Not_Found = 1; while ((pSizeDependParamKnot != NULL) && Size_Not_Found) - { if ((here->BSIM4l == pSizeDependParamKnot->Length) - && (here->BSIM4w == pSizeDependParamKnot->Width) - && (here->BSIM4nf == pSizeDependParamKnot->NFinger)) + { if ((here->BSIM4v7l == pSizeDependParamKnot->Length) + && (here->BSIM4v7w == pSizeDependParamKnot->Width) + && (here->BSIM4v7nf == pSizeDependParamKnot->NFinger)) { Size_Not_Found = 0; here->pParam = pSizeDependParamKnot; pParam = here->pParam; /*bug-fix */ @@ -426,8 +426,8 @@ int Size_Not_Found, i; } /* stress effect */ - Ldrn = here->BSIM4l; - Wdrn = here->BSIM4w / here->BSIM4nf; + Ldrn = here->BSIM4v7l; + Wdrn = here->BSIM4v7w / here->BSIM4v7nf; if (Size_Not_Found) { pParam = TMALLOC(struct bsim4SizeDependParam, 1); @@ -438,782 +438,782 @@ int Size_Not_Found, i; pParam->pNext = NULL; here->pParam = pParam; - pParam->Length = here->BSIM4l; - pParam->Width = here->BSIM4w; - pParam->NFinger = here->BSIM4nf; - Lnew = here->BSIM4l + model->BSIM4xl ; - Wnew = here->BSIM4w / here->BSIM4nf + model->BSIM4xw; + pParam->Length = here->BSIM4v7l; + pParam->Width = here->BSIM4v7w; + pParam->NFinger = here->BSIM4v7nf; + Lnew = here->BSIM4v7l + model->BSIM4v7xl ; + Wnew = here->BSIM4v7w / here->BSIM4v7nf + model->BSIM4v7xw; - T0 = pow(Lnew, model->BSIM4Lln); - T1 = pow(Wnew, model->BSIM4Lwn); - tmp1 = model->BSIM4Ll / T0 + model->BSIM4Lw / T1 - + model->BSIM4Lwl / (T0 * T1); - pParam->BSIM4dl = model->BSIM4Lint + tmp1; - tmp2 = model->BSIM4Llc / T0 + model->BSIM4Lwc / T1 - + model->BSIM4Lwlc / (T0 * T1); - pParam->BSIM4dlc = model->BSIM4dlc + tmp2; + T0 = pow(Lnew, model->BSIM4v7Lln); + T1 = pow(Wnew, model->BSIM4v7Lwn); + tmp1 = model->BSIM4v7Ll / T0 + model->BSIM4v7Lw / T1 + + model->BSIM4v7Lwl / (T0 * T1); + pParam->BSIM4v7dl = model->BSIM4v7Lint + tmp1; + tmp2 = model->BSIM4v7Llc / T0 + model->BSIM4v7Lwc / T1 + + model->BSIM4v7Lwlc / (T0 * T1); + pParam->BSIM4v7dlc = model->BSIM4v7dlc + tmp2; - T2 = pow(Lnew, model->BSIM4Wln); - T3 = pow(Wnew, model->BSIM4Wwn); - tmp1 = model->BSIM4Wl / T2 + model->BSIM4Ww / T3 - + model->BSIM4Wwl / (T2 * T3); - pParam->BSIM4dw = model->BSIM4Wint + tmp1; - tmp2 = model->BSIM4Wlc / T2 + model->BSIM4Wwc / T3 - + model->BSIM4Wwlc / (T2 * T3); - pParam->BSIM4dwc = model->BSIM4dwc + tmp2; - pParam->BSIM4dwj = model->BSIM4dwj + tmp2; + T2 = pow(Lnew, model->BSIM4v7Wln); + T3 = pow(Wnew, model->BSIM4v7Wwn); + tmp1 = model->BSIM4v7Wl / T2 + model->BSIM4v7Ww / T3 + + model->BSIM4v7Wwl / (T2 * T3); + pParam->BSIM4v7dw = model->BSIM4v7Wint + tmp1; + tmp2 = model->BSIM4v7Wlc / T2 + model->BSIM4v7Wwc / T3 + + model->BSIM4v7Wwlc / (T2 * T3); + pParam->BSIM4v7dwc = model->BSIM4v7dwc + tmp2; + pParam->BSIM4v7dwj = model->BSIM4v7dwj + tmp2; - pParam->BSIM4leff = Lnew - 2.0 * pParam->BSIM4dl; - if (pParam->BSIM4leff <= 0.0) + pParam->BSIM4v7leff = Lnew - 2.0 * pParam->BSIM4v7dl; + if (pParam->BSIM4v7leff <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, - "BSIM4: mosfet %s, model %s: Effective channel length <= 0", - model->BSIM4modName, here->BSIM4name); + "BSIM4v7: mosfet %s, model %s: Effective channel length <= 0", + model->BSIM4v7modName, here->BSIM4v7name); return(E_BADPARM); } - pParam->BSIM4weff = Wnew - 2.0 * pParam->BSIM4dw; - if (pParam->BSIM4weff <= 0.0) + pParam->BSIM4v7weff = Wnew - 2.0 * pParam->BSIM4v7dw; + if (pParam->BSIM4v7weff <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, - "BSIM4: mosfet %s, model %s: Effective channel width <= 0", - model->BSIM4modName, here->BSIM4name); + "BSIM4v7: mosfet %s, model %s: Effective channel width <= 0", + model->BSIM4v7modName, here->BSIM4v7name); return(E_BADPARM); } - pParam->BSIM4leffCV = Lnew - 2.0 * pParam->BSIM4dlc; - if (pParam->BSIM4leffCV <= 0.0) + pParam->BSIM4v7leffCV = Lnew - 2.0 * pParam->BSIM4v7dlc; + if (pParam->BSIM4v7leffCV <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, - "BSIM4: mosfet %s, model %s: Effective channel length for C-V <= 0", - model->BSIM4modName, here->BSIM4name); + "BSIM4v7: mosfet %s, model %s: Effective channel length for C-V <= 0", + model->BSIM4v7modName, here->BSIM4v7name); return(E_BADPARM); } - pParam->BSIM4weffCV = Wnew - 2.0 * pParam->BSIM4dwc; - if (pParam->BSIM4weffCV <= 0.0) + pParam->BSIM4v7weffCV = Wnew - 2.0 * pParam->BSIM4v7dwc; + if (pParam->BSIM4v7weffCV <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, - "BSIM4: mosfet %s, model %s: Effective channel width for C-V <= 0", - model->BSIM4modName, here->BSIM4name); + "BSIM4v7: mosfet %s, model %s: Effective channel width for C-V <= 0", + model->BSIM4v7modName, here->BSIM4v7name); return(E_BADPARM); } - pParam->BSIM4weffCJ = Wnew - 2.0 * pParam->BSIM4dwj; - if (pParam->BSIM4weffCJ <= 0.0) + pParam->BSIM4v7weffCJ = Wnew - 2.0 * pParam->BSIM4v7dwj; + if (pParam->BSIM4v7weffCJ <= 0.0) { SPfrontEnd->IFerrorf(ERR_FATAL, - "BSIM4: mosfet %s, model %s: Effective channel width for S/D junctions <= 0", - model->BSIM4modName, here->BSIM4name); + "BSIM4v7: mosfet %s, model %s: Effective channel width for S/D junctions <= 0", + model->BSIM4v7modName, here->BSIM4v7name); return(E_BADPARM); } - if (model->BSIM4binUnit == 1) - { Inv_L = 1.0e-6 / pParam->BSIM4leff; - Inv_W = 1.0e-6 / pParam->BSIM4weff; - Inv_LW = 1.0e-12 / (pParam->BSIM4leff - * pParam->BSIM4weff); + if (model->BSIM4v7binUnit == 1) + { Inv_L = 1.0e-6 / pParam->BSIM4v7leff; + Inv_W = 1.0e-6 / pParam->BSIM4v7weff; + Inv_LW = 1.0e-12 / (pParam->BSIM4v7leff + * pParam->BSIM4v7weff); } else - { Inv_L = 1.0 / pParam->BSIM4leff; - Inv_W = 1.0 / pParam->BSIM4weff; - Inv_LW = 1.0 / (pParam->BSIM4leff - * pParam->BSIM4weff); + { Inv_L = 1.0 / pParam->BSIM4v7leff; + Inv_W = 1.0 / pParam->BSIM4v7weff; + Inv_LW = 1.0 / (pParam->BSIM4v7leff + * pParam->BSIM4v7weff); } - pParam->BSIM4cdsc = model->BSIM4cdsc - + model->BSIM4lcdsc * Inv_L - + model->BSIM4wcdsc * Inv_W - + model->BSIM4pcdsc * Inv_LW; - pParam->BSIM4cdscb = model->BSIM4cdscb - + model->BSIM4lcdscb * Inv_L - + model->BSIM4wcdscb * Inv_W - + model->BSIM4pcdscb * Inv_LW; + pParam->BSIM4v7cdsc = model->BSIM4v7cdsc + + model->BSIM4v7lcdsc * Inv_L + + model->BSIM4v7wcdsc * Inv_W + + model->BSIM4v7pcdsc * Inv_LW; + pParam->BSIM4v7cdscb = model->BSIM4v7cdscb + + model->BSIM4v7lcdscb * Inv_L + + model->BSIM4v7wcdscb * Inv_W + + model->BSIM4v7pcdscb * Inv_LW; - pParam->BSIM4cdscd = model->BSIM4cdscd - + model->BSIM4lcdscd * Inv_L - + model->BSIM4wcdscd * Inv_W - + model->BSIM4pcdscd * Inv_LW; + pParam->BSIM4v7cdscd = model->BSIM4v7cdscd + + model->BSIM4v7lcdscd * Inv_L + + model->BSIM4v7wcdscd * Inv_W + + model->BSIM4v7pcdscd * Inv_LW; - pParam->BSIM4cit = model->BSIM4cit - + model->BSIM4lcit * Inv_L - + model->BSIM4wcit * Inv_W - + model->BSIM4pcit * Inv_LW; - pParam->BSIM4nfactor = model->BSIM4nfactor - + model->BSIM4lnfactor * Inv_L - + model->BSIM4wnfactor * Inv_W - + model->BSIM4pnfactor * Inv_LW; - pParam->BSIM4tnfactor = model->BSIM4tnfactor /* v4.7 */ - + model->BSIM4ltnfactor * Inv_L - + model->BSIM4wtnfactor * Inv_W - + model->BSIM4ptnfactor * Inv_LW; - pParam->BSIM4xj = model->BSIM4xj - + model->BSIM4lxj * Inv_L - + model->BSIM4wxj * Inv_W - + model->BSIM4pxj * Inv_LW; - pParam->BSIM4vsat = model->BSIM4vsat - + model->BSIM4lvsat * Inv_L - + model->BSIM4wvsat * Inv_W - + model->BSIM4pvsat * Inv_LW; - pParam->BSIM4at = model->BSIM4at - + model->BSIM4lat * Inv_L - + model->BSIM4wat * Inv_W - + model->BSIM4pat * Inv_LW; - pParam->BSIM4a0 = model->BSIM4a0 - + model->BSIM4la0 * Inv_L - + model->BSIM4wa0 * Inv_W - + model->BSIM4pa0 * Inv_LW; + pParam->BSIM4v7cit = model->BSIM4v7cit + + model->BSIM4v7lcit * Inv_L + + model->BSIM4v7wcit * Inv_W + + model->BSIM4v7pcit * Inv_LW; + pParam->BSIM4v7nfactor = model->BSIM4v7nfactor + + model->BSIM4v7lnfactor * Inv_L + + model->BSIM4v7wnfactor * Inv_W + + model->BSIM4v7pnfactor * Inv_LW; + pParam->BSIM4v7tnfactor = model->BSIM4v7tnfactor /* v4.7 */ + + model->BSIM4v7ltnfactor * Inv_L + + model->BSIM4v7wtnfactor * Inv_W + + model->BSIM4v7ptnfactor * Inv_LW; + pParam->BSIM4v7xj = model->BSIM4v7xj + + model->BSIM4v7lxj * Inv_L + + model->BSIM4v7wxj * Inv_W + + model->BSIM4v7pxj * Inv_LW; + pParam->BSIM4v7vsat = model->BSIM4v7vsat + + model->BSIM4v7lvsat * Inv_L + + model->BSIM4v7wvsat * Inv_W + + model->BSIM4v7pvsat * Inv_LW; + pParam->BSIM4v7at = model->BSIM4v7at + + model->BSIM4v7lat * Inv_L + + model->BSIM4v7wat * Inv_W + + model->BSIM4v7pat * Inv_LW; + pParam->BSIM4v7a0 = model->BSIM4v7a0 + + model->BSIM4v7la0 * Inv_L + + model->BSIM4v7wa0 * Inv_W + + model->BSIM4v7pa0 * Inv_LW; - pParam->BSIM4ags = model->BSIM4ags - + model->BSIM4lags * Inv_L - + model->BSIM4wags * Inv_W - + model->BSIM4pags * Inv_LW; + pParam->BSIM4v7ags = model->BSIM4v7ags + + model->BSIM4v7lags * Inv_L + + model->BSIM4v7wags * Inv_W + + model->BSIM4v7pags * Inv_LW; - pParam->BSIM4a1 = model->BSIM4a1 - + model->BSIM4la1 * Inv_L - + model->BSIM4wa1 * Inv_W - + model->BSIM4pa1 * Inv_LW; - pParam->BSIM4a2 = model->BSIM4a2 - + model->BSIM4la2 * Inv_L - + model->BSIM4wa2 * Inv_W - + model->BSIM4pa2 * Inv_LW; - pParam->BSIM4keta = model->BSIM4keta - + model->BSIM4lketa * Inv_L - + model->BSIM4wketa * Inv_W - + model->BSIM4pketa * Inv_LW; - pParam->BSIM4nsub = model->BSIM4nsub - + model->BSIM4lnsub * Inv_L - + model->BSIM4wnsub * Inv_W - + model->BSIM4pnsub * Inv_LW; - pParam->BSIM4ndep = model->BSIM4ndep - + model->BSIM4lndep * Inv_L - + model->BSIM4wndep * Inv_W - + model->BSIM4pndep * Inv_LW; - pParam->BSIM4nsd = model->BSIM4nsd - + model->BSIM4lnsd * Inv_L - + model->BSIM4wnsd * Inv_W - + model->BSIM4pnsd * Inv_LW; - pParam->BSIM4phin = model->BSIM4phin - + model->BSIM4lphin * Inv_L - + model->BSIM4wphin * Inv_W - + model->BSIM4pphin * Inv_LW; - pParam->BSIM4ngate = model->BSIM4ngate - + model->BSIM4lngate * Inv_L - + model->BSIM4wngate * Inv_W - + model->BSIM4pngate * Inv_LW; - pParam->BSIM4gamma1 = model->BSIM4gamma1 - + model->BSIM4lgamma1 * Inv_L - + model->BSIM4wgamma1 * Inv_W - + model->BSIM4pgamma1 * Inv_LW; - pParam->BSIM4gamma2 = model->BSIM4gamma2 - + model->BSIM4lgamma2 * Inv_L - + model->BSIM4wgamma2 * Inv_W - + model->BSIM4pgamma2 * Inv_LW; - pParam->BSIM4vbx = model->BSIM4vbx - + model->BSIM4lvbx * Inv_L - + model->BSIM4wvbx * Inv_W - + model->BSIM4pvbx * Inv_LW; - pParam->BSIM4vbm = model->BSIM4vbm - + model->BSIM4lvbm * Inv_L - + model->BSIM4wvbm * Inv_W - + model->BSIM4pvbm * Inv_LW; - pParam->BSIM4xt = model->BSIM4xt - + model->BSIM4lxt * Inv_L - + model->BSIM4wxt * Inv_W - + model->BSIM4pxt * Inv_LW; - pParam->BSIM4vfb = model->BSIM4vfb - + model->BSIM4lvfb * Inv_L - + model->BSIM4wvfb * Inv_W - + model->BSIM4pvfb * Inv_LW; - pParam->BSIM4k1 = model->BSIM4k1 - + model->BSIM4lk1 * Inv_L - + model->BSIM4wk1 * Inv_W - + model->BSIM4pk1 * Inv_LW; - pParam->BSIM4kt1 = model->BSIM4kt1 - + model->BSIM4lkt1 * Inv_L - + model->BSIM4wkt1 * Inv_W - + model->BSIM4pkt1 * Inv_LW; - pParam->BSIM4kt1l = model->BSIM4kt1l - + model->BSIM4lkt1l * Inv_L - + model->BSIM4wkt1l * Inv_W - + model->BSIM4pkt1l * Inv_LW; - pParam->BSIM4k2 = model->BSIM4k2 - + model->BSIM4lk2 * Inv_L - + model->BSIM4wk2 * Inv_W - + model->BSIM4pk2 * Inv_LW; - pParam->BSIM4kt2 = model->BSIM4kt2 - + model->BSIM4lkt2 * Inv_L - + model->BSIM4wkt2 * Inv_W - + model->BSIM4pkt2 * Inv_LW; - pParam->BSIM4k3 = model->BSIM4k3 - + model->BSIM4lk3 * Inv_L - + model->BSIM4wk3 * Inv_W - + model->BSIM4pk3 * Inv_LW; - pParam->BSIM4k3b = model->BSIM4k3b - + model->BSIM4lk3b * Inv_L - + model->BSIM4wk3b * Inv_W - + model->BSIM4pk3b * Inv_LW; - pParam->BSIM4w0 = model->BSIM4w0 - + model->BSIM4lw0 * Inv_L - + model->BSIM4ww0 * Inv_W - + model->BSIM4pw0 * Inv_LW; - pParam->BSIM4lpe0 = model->BSIM4lpe0 - + model->BSIM4llpe0 * Inv_L - + model->BSIM4wlpe0 * Inv_W - + model->BSIM4plpe0 * Inv_LW; - pParam->BSIM4lpeb = model->BSIM4lpeb - + model->BSIM4llpeb * Inv_L - + model->BSIM4wlpeb * Inv_W - + model->BSIM4plpeb * Inv_LW; - pParam->BSIM4dvtp0 = model->BSIM4dvtp0 - + model->BSIM4ldvtp0 * Inv_L - + model->BSIM4wdvtp0 * Inv_W - + model->BSIM4pdvtp0 * Inv_LW; - pParam->BSIM4dvtp1 = model->BSIM4dvtp1 - + model->BSIM4ldvtp1 * Inv_L - + model->BSIM4wdvtp1 * Inv_W - + model->BSIM4pdvtp1 * Inv_LW; - pParam->BSIM4dvtp2 = model->BSIM4dvtp2 /* v4.7 */ - + model->BSIM4ldvtp2 * Inv_L - + model->BSIM4wdvtp2 * Inv_W - + model->BSIM4pdvtp2 * Inv_LW; - pParam->BSIM4dvtp3 = model->BSIM4dvtp3 /* v4.7 */ - + model->BSIM4ldvtp3 * Inv_L - + model->BSIM4wdvtp3 * Inv_W - + model->BSIM4pdvtp3 * Inv_LW; - pParam->BSIM4dvtp4 = model->BSIM4dvtp4 /* v4.7 */ - + model->BSIM4ldvtp4 * Inv_L - + model->BSIM4wdvtp4 * Inv_W - + model->BSIM4pdvtp4 * Inv_LW; - pParam->BSIM4dvtp5 = model->BSIM4dvtp5 /* v4.7 */ - + model->BSIM4ldvtp5 * Inv_L - + model->BSIM4wdvtp5 * Inv_W - + model->BSIM4pdvtp5 * Inv_LW; - pParam->BSIM4dvt0 = model->BSIM4dvt0 - + model->BSIM4ldvt0 * Inv_L - + model->BSIM4wdvt0 * Inv_W - + model->BSIM4pdvt0 * Inv_LW; - pParam->BSIM4dvt1 = model->BSIM4dvt1 - + model->BSIM4ldvt1 * Inv_L - + model->BSIM4wdvt1 * Inv_W - + model->BSIM4pdvt1 * Inv_LW; - pParam->BSIM4dvt2 = model->BSIM4dvt2 - + model->BSIM4ldvt2 * Inv_L - + model->BSIM4wdvt2 * Inv_W - + model->BSIM4pdvt2 * Inv_LW; - pParam->BSIM4dvt0w = model->BSIM4dvt0w - + model->BSIM4ldvt0w * Inv_L - + model->BSIM4wdvt0w * Inv_W - + model->BSIM4pdvt0w * Inv_LW; - pParam->BSIM4dvt1w = model->BSIM4dvt1w - + model->BSIM4ldvt1w * Inv_L - + model->BSIM4wdvt1w * Inv_W - + model->BSIM4pdvt1w * Inv_LW; - pParam->BSIM4dvt2w = model->BSIM4dvt2w - + model->BSIM4ldvt2w * Inv_L - + model->BSIM4wdvt2w * Inv_W - + model->BSIM4pdvt2w * Inv_LW; - pParam->BSIM4drout = model->BSIM4drout - + model->BSIM4ldrout * Inv_L - + model->BSIM4wdrout * Inv_W - + model->BSIM4pdrout * Inv_LW; - pParam->BSIM4dsub = model->BSIM4dsub - + model->BSIM4ldsub * Inv_L - + model->BSIM4wdsub * Inv_W - + model->BSIM4pdsub * Inv_LW; - pParam->BSIM4vth0 = model->BSIM4vth0 - + model->BSIM4lvth0 * Inv_L - + model->BSIM4wvth0 * Inv_W - + model->BSIM4pvth0 * Inv_LW; - pParam->BSIM4ua = model->BSIM4ua - + model->BSIM4lua * Inv_L - + model->BSIM4wua * Inv_W - + model->BSIM4pua * Inv_LW; - pParam->BSIM4ua1 = model->BSIM4ua1 - + model->BSIM4lua1 * Inv_L - + model->BSIM4wua1 * Inv_W - + model->BSIM4pua1 * Inv_LW; - pParam->BSIM4ub = model->BSIM4ub - + model->BSIM4lub * Inv_L - + model->BSIM4wub * Inv_W - + model->BSIM4pub * Inv_LW; - pParam->BSIM4ub1 = model->BSIM4ub1 - + model->BSIM4lub1 * Inv_L - + model->BSIM4wub1 * Inv_W - + model->BSIM4pub1 * Inv_LW; - pParam->BSIM4uc = model->BSIM4uc - + model->BSIM4luc * Inv_L - + model->BSIM4wuc * Inv_W - + model->BSIM4puc * Inv_LW; - pParam->BSIM4uc1 = model->BSIM4uc1 - + model->BSIM4luc1 * Inv_L - + model->BSIM4wuc1 * Inv_W - + model->BSIM4puc1 * Inv_LW; - pParam->BSIM4ud = model->BSIM4ud - + model->BSIM4lud * Inv_L - + model->BSIM4wud * Inv_W - + model->BSIM4pud * Inv_LW; - pParam->BSIM4ud1 = model->BSIM4ud1 - + model->BSIM4lud1 * Inv_L - + model->BSIM4wud1 * Inv_W - + model->BSIM4pud1 * Inv_LW; - pParam->BSIM4up = model->BSIM4up - + model->BSIM4lup * Inv_L - + model->BSIM4wup * Inv_W - + model->BSIM4pup * Inv_LW; - pParam->BSIM4lp = model->BSIM4lp - + model->BSIM4llp * Inv_L - + model->BSIM4wlp * Inv_W - + model->BSIM4plp * Inv_LW; - pParam->BSIM4eu = model->BSIM4eu - + model->BSIM4leu * Inv_L - + model->BSIM4weu * Inv_W - + model->BSIM4peu * Inv_LW; - pParam->BSIM4u0 = model->BSIM4u0 - + model->BSIM4lu0 * Inv_L - + model->BSIM4wu0 * Inv_W - + model->BSIM4pu0 * Inv_LW; - pParam->BSIM4ute = model->BSIM4ute - + model->BSIM4lute * Inv_L - + model->BSIM4wute * Inv_W - + model->BSIM4pute * Inv_LW; + pParam->BSIM4v7a1 = model->BSIM4v7a1 + + model->BSIM4v7la1 * Inv_L + + model->BSIM4v7wa1 * Inv_W + + model->BSIM4v7pa1 * Inv_LW; + pParam->BSIM4v7a2 = model->BSIM4v7a2 + + model->BSIM4v7la2 * Inv_L + + model->BSIM4v7wa2 * Inv_W + + model->BSIM4v7pa2 * Inv_LW; + pParam->BSIM4v7keta = model->BSIM4v7keta + + model->BSIM4v7lketa * Inv_L + + model->BSIM4v7wketa * Inv_W + + model->BSIM4v7pketa * Inv_LW; + pParam->BSIM4v7nsub = model->BSIM4v7nsub + + model->BSIM4v7lnsub * Inv_L + + model->BSIM4v7wnsub * Inv_W + + model->BSIM4v7pnsub * Inv_LW; + pParam->BSIM4v7ndep = model->BSIM4v7ndep + + model->BSIM4v7lndep * Inv_L + + model->BSIM4v7wndep * Inv_W + + model->BSIM4v7pndep * Inv_LW; + pParam->BSIM4v7nsd = model->BSIM4v7nsd + + model->BSIM4v7lnsd * Inv_L + + model->BSIM4v7wnsd * Inv_W + + model->BSIM4v7pnsd * Inv_LW; + pParam->BSIM4v7phin = model->BSIM4v7phin + + model->BSIM4v7lphin * Inv_L + + model->BSIM4v7wphin * Inv_W + + model->BSIM4v7pphin * Inv_LW; + pParam->BSIM4v7ngate = model->BSIM4v7ngate + + model->BSIM4v7lngate * Inv_L + + model->BSIM4v7wngate * Inv_W + + model->BSIM4v7pngate * Inv_LW; + pParam->BSIM4v7gamma1 = model->BSIM4v7gamma1 + + model->BSIM4v7lgamma1 * Inv_L + + model->BSIM4v7wgamma1 * Inv_W + + model->BSIM4v7pgamma1 * Inv_LW; + pParam->BSIM4v7gamma2 = model->BSIM4v7gamma2 + + model->BSIM4v7lgamma2 * Inv_L + + model->BSIM4v7wgamma2 * Inv_W + + model->BSIM4v7pgamma2 * Inv_LW; + pParam->BSIM4v7vbx = model->BSIM4v7vbx + + model->BSIM4v7lvbx * Inv_L + + model->BSIM4v7wvbx * Inv_W + + model->BSIM4v7pvbx * Inv_LW; + pParam->BSIM4v7vbm = model->BSIM4v7vbm + + model->BSIM4v7lvbm * Inv_L + + model->BSIM4v7wvbm * Inv_W + + model->BSIM4v7pvbm * Inv_LW; + pParam->BSIM4v7xt = model->BSIM4v7xt + + model->BSIM4v7lxt * Inv_L + + model->BSIM4v7wxt * Inv_W + + model->BSIM4v7pxt * Inv_LW; + pParam->BSIM4v7vfb = model->BSIM4v7vfb + + model->BSIM4v7lvfb * Inv_L + + model->BSIM4v7wvfb * Inv_W + + model->BSIM4v7pvfb * Inv_LW; + pParam->BSIM4v7k1 = model->BSIM4v7k1 + + model->BSIM4v7lk1 * Inv_L + + model->BSIM4v7wk1 * Inv_W + + model->BSIM4v7pk1 * Inv_LW; + pParam->BSIM4v7kt1 = model->BSIM4v7kt1 + + model->BSIM4v7lkt1 * Inv_L + + model->BSIM4v7wkt1 * Inv_W + + model->BSIM4v7pkt1 * Inv_LW; + pParam->BSIM4v7kt1l = model->BSIM4v7kt1l + + model->BSIM4v7lkt1l * Inv_L + + model->BSIM4v7wkt1l * Inv_W + + model->BSIM4v7pkt1l * Inv_LW; + pParam->BSIM4v7k2 = model->BSIM4v7k2 + + model->BSIM4v7lk2 * Inv_L + + model->BSIM4v7wk2 * Inv_W + + model->BSIM4v7pk2 * Inv_LW; + pParam->BSIM4v7kt2 = model->BSIM4v7kt2 + + model->BSIM4v7lkt2 * Inv_L + + model->BSIM4v7wkt2 * Inv_W + + model->BSIM4v7pkt2 * Inv_LW; + pParam->BSIM4v7k3 = model->BSIM4v7k3 + + model->BSIM4v7lk3 * Inv_L + + model->BSIM4v7wk3 * Inv_W + + model->BSIM4v7pk3 * Inv_LW; + pParam->BSIM4v7k3b = model->BSIM4v7k3b + + model->BSIM4v7lk3b * Inv_L + + model->BSIM4v7wk3b * Inv_W + + model->BSIM4v7pk3b * Inv_LW; + pParam->BSIM4v7w0 = model->BSIM4v7w0 + + model->BSIM4v7lw0 * Inv_L + + model->BSIM4v7ww0 * Inv_W + + model->BSIM4v7pw0 * Inv_LW; + pParam->BSIM4v7lpe0 = model->BSIM4v7lpe0 + + model->BSIM4v7llpe0 * Inv_L + + model->BSIM4v7wlpe0 * Inv_W + + model->BSIM4v7plpe0 * Inv_LW; + pParam->BSIM4v7lpeb = model->BSIM4v7lpeb + + model->BSIM4v7llpeb * Inv_L + + model->BSIM4v7wlpeb * Inv_W + + model->BSIM4v7plpeb * Inv_LW; + pParam->BSIM4v7dvtp0 = model->BSIM4v7dvtp0 + + model->BSIM4v7ldvtp0 * Inv_L + + model->BSIM4v7wdvtp0 * Inv_W + + model->BSIM4v7pdvtp0 * Inv_LW; + pParam->BSIM4v7dvtp1 = model->BSIM4v7dvtp1 + + model->BSIM4v7ldvtp1 * Inv_L + + model->BSIM4v7wdvtp1 * Inv_W + + model->BSIM4v7pdvtp1 * Inv_LW; + pParam->BSIM4v7dvtp2 = model->BSIM4v7dvtp2 /* v4.7 */ + + model->BSIM4v7ldvtp2 * Inv_L + + model->BSIM4v7wdvtp2 * Inv_W + + model->BSIM4v7pdvtp2 * Inv_LW; + pParam->BSIM4v7dvtp3 = model->BSIM4v7dvtp3 /* v4.7 */ + + model->BSIM4v7ldvtp3 * Inv_L + + model->BSIM4v7wdvtp3 * Inv_W + + model->BSIM4v7pdvtp3 * Inv_LW; + pParam->BSIM4v7dvtp4 = model->BSIM4v7dvtp4 /* v4.7 */ + + model->BSIM4v7ldvtp4 * Inv_L + + model->BSIM4v7wdvtp4 * Inv_W + + model->BSIM4v7pdvtp4 * Inv_LW; + pParam->BSIM4v7dvtp5 = model->BSIM4v7dvtp5 /* v4.7 */ + + model->BSIM4v7ldvtp5 * Inv_L + + model->BSIM4v7wdvtp5 * Inv_W + + model->BSIM4v7pdvtp5 * Inv_LW; + pParam->BSIM4v7dvt0 = model->BSIM4v7dvt0 + + model->BSIM4v7ldvt0 * Inv_L + + model->BSIM4v7wdvt0 * Inv_W + + model->BSIM4v7pdvt0 * Inv_LW; + pParam->BSIM4v7dvt1 = model->BSIM4v7dvt1 + + model->BSIM4v7ldvt1 * Inv_L + + model->BSIM4v7wdvt1 * Inv_W + + model->BSIM4v7pdvt1 * Inv_LW; + pParam->BSIM4v7dvt2 = model->BSIM4v7dvt2 + + model->BSIM4v7ldvt2 * Inv_L + + model->BSIM4v7wdvt2 * Inv_W + + model->BSIM4v7pdvt2 * Inv_LW; + pParam->BSIM4v7dvt0w = model->BSIM4v7dvt0w + + model->BSIM4v7ldvt0w * Inv_L + + model->BSIM4v7wdvt0w * Inv_W + + model->BSIM4v7pdvt0w * Inv_LW; + pParam->BSIM4v7dvt1w = model->BSIM4v7dvt1w + + model->BSIM4v7ldvt1w * Inv_L + + model->BSIM4v7wdvt1w * Inv_W + + model->BSIM4v7pdvt1w * Inv_LW; + pParam->BSIM4v7dvt2w = model->BSIM4v7dvt2w + + model->BSIM4v7ldvt2w * Inv_L + + model->BSIM4v7wdvt2w * Inv_W + + model->BSIM4v7pdvt2w * Inv_LW; + pParam->BSIM4v7drout = model->BSIM4v7drout + + model->BSIM4v7ldrout * Inv_L + + model->BSIM4v7wdrout * Inv_W + + model->BSIM4v7pdrout * Inv_LW; + pParam->BSIM4v7dsub = model->BSIM4v7dsub + + model->BSIM4v7ldsub * Inv_L + + model->BSIM4v7wdsub * Inv_W + + model->BSIM4v7pdsub * Inv_LW; + pParam->BSIM4v7vth0 = model->BSIM4v7vth0 + + model->BSIM4v7lvth0 * Inv_L + + model->BSIM4v7wvth0 * Inv_W + + model->BSIM4v7pvth0 * Inv_LW; + pParam->BSIM4v7ua = model->BSIM4v7ua + + model->BSIM4v7lua * Inv_L + + model->BSIM4v7wua * Inv_W + + model->BSIM4v7pua * Inv_LW; + pParam->BSIM4v7ua1 = model->BSIM4v7ua1 + + model->BSIM4v7lua1 * Inv_L + + model->BSIM4v7wua1 * Inv_W + + model->BSIM4v7pua1 * Inv_LW; + pParam->BSIM4v7ub = model->BSIM4v7ub + + model->BSIM4v7lub * Inv_L + + model->BSIM4v7wub * Inv_W + + model->BSIM4v7pub * Inv_LW; + pParam->BSIM4v7ub1 = model->BSIM4v7ub1 + + model->BSIM4v7lub1 * Inv_L + + model->BSIM4v7wub1 * Inv_W + + model->BSIM4v7pub1 * Inv_LW; + pParam->BSIM4v7uc = model->BSIM4v7uc + + model->BSIM4v7luc * Inv_L + + model->BSIM4v7wuc * Inv_W + + model->BSIM4v7puc * Inv_LW; + pParam->BSIM4v7uc1 = model->BSIM4v7uc1 + + model->BSIM4v7luc1 * Inv_L + + model->BSIM4v7wuc1 * Inv_W + + model->BSIM4v7puc1 * Inv_LW; + pParam->BSIM4v7ud = model->BSIM4v7ud + + model->BSIM4v7lud * Inv_L + + model->BSIM4v7wud * Inv_W + + model->BSIM4v7pud * Inv_LW; + pParam->BSIM4v7ud1 = model->BSIM4v7ud1 + + model->BSIM4v7lud1 * Inv_L + + model->BSIM4v7wud1 * Inv_W + + model->BSIM4v7pud1 * Inv_LW; + pParam->BSIM4v7up = model->BSIM4v7up + + model->BSIM4v7lup * Inv_L + + model->BSIM4v7wup * Inv_W + + model->BSIM4v7pup * Inv_LW; + pParam->BSIM4v7lp = model->BSIM4v7lp + + model->BSIM4v7llp * Inv_L + + model->BSIM4v7wlp * Inv_W + + model->BSIM4v7plp * Inv_LW; + pParam->BSIM4v7eu = model->BSIM4v7eu + + model->BSIM4v7leu * Inv_L + + model->BSIM4v7weu * Inv_W + + model->BSIM4v7peu * Inv_LW; + pParam->BSIM4v7u0 = model->BSIM4v7u0 + + model->BSIM4v7lu0 * Inv_L + + model->BSIM4v7wu0 * Inv_W + + model->BSIM4v7pu0 * Inv_LW; + pParam->BSIM4v7ute = model->BSIM4v7ute + + model->BSIM4v7lute * Inv_L + + model->BSIM4v7wute * Inv_W + + model->BSIM4v7pute * Inv_LW; /*high k mobility*/ - pParam->BSIM4ucs = model->BSIM4ucs - + model->BSIM4lucs * Inv_L - + model->BSIM4wucs * Inv_W - + model->BSIM4pucs * Inv_LW; - pParam->BSIM4ucste = model->BSIM4ucste - + model->BSIM4lucste * Inv_L - + model->BSIM4wucste * Inv_W - + model->BSIM4pucste * Inv_LW; + pParam->BSIM4v7ucs = model->BSIM4v7ucs + + model->BSIM4v7lucs * Inv_L + + model->BSIM4v7wucs * Inv_W + + model->BSIM4v7pucs * Inv_LW; + pParam->BSIM4v7ucste = model->BSIM4v7ucste + + model->BSIM4v7lucste * Inv_L + + model->BSIM4v7wucste * Inv_W + + model->BSIM4v7pucste * Inv_LW; - pParam->BSIM4voff = model->BSIM4voff - + model->BSIM4lvoff * Inv_L - + model->BSIM4wvoff * Inv_W - + model->BSIM4pvoff * Inv_LW; - pParam->BSIM4tvoff = model->BSIM4tvoff - + model->BSIM4ltvoff * Inv_L - + model->BSIM4wtvoff * Inv_W - + model->BSIM4ptvoff * Inv_LW; - pParam->BSIM4minv = model->BSIM4minv - + model->BSIM4lminv * Inv_L - + model->BSIM4wminv * Inv_W - + model->BSIM4pminv * Inv_LW; - pParam->BSIM4minvcv = model->BSIM4minvcv - + model->BSIM4lminvcv * Inv_L - + model->BSIM4wminvcv * Inv_W - + model->BSIM4pminvcv * Inv_LW; - pParam->BSIM4fprout = model->BSIM4fprout - + model->BSIM4lfprout * Inv_L - + model->BSIM4wfprout * Inv_W - + model->BSIM4pfprout * Inv_LW; - pParam->BSIM4pdits = model->BSIM4pdits - + model->BSIM4lpdits * Inv_L - + model->BSIM4wpdits * Inv_W - + model->BSIM4ppdits * Inv_LW; - pParam->BSIM4pditsd = model->BSIM4pditsd - + model->BSIM4lpditsd * Inv_L - + model->BSIM4wpditsd * Inv_W - + model->BSIM4ppditsd * Inv_LW; - pParam->BSIM4delta = model->BSIM4delta - + model->BSIM4ldelta * Inv_L - + model->BSIM4wdelta * Inv_W - + model->BSIM4pdelta * Inv_LW; - pParam->BSIM4rdsw = model->BSIM4rdsw - + model->BSIM4lrdsw * Inv_L - + model->BSIM4wrdsw * Inv_W - + model->BSIM4prdsw * Inv_LW; - pParam->BSIM4rdw = model->BSIM4rdw - + model->BSIM4lrdw * Inv_L - + model->BSIM4wrdw * Inv_W - + model->BSIM4prdw * Inv_LW; - pParam->BSIM4rsw = model->BSIM4rsw - + model->BSIM4lrsw * Inv_L - + model->BSIM4wrsw * Inv_W - + model->BSIM4prsw * Inv_LW; - pParam->BSIM4prwg = model->BSIM4prwg - + model->BSIM4lprwg * Inv_L - + model->BSIM4wprwg * Inv_W - + model->BSIM4pprwg * Inv_LW; - pParam->BSIM4prwb = model->BSIM4prwb - + model->BSIM4lprwb * Inv_L - + model->BSIM4wprwb * Inv_W - + model->BSIM4pprwb * Inv_LW; - pParam->BSIM4prt = model->BSIM4prt - + model->BSIM4lprt * Inv_L - + model->BSIM4wprt * Inv_W - + model->BSIM4pprt * Inv_LW; - pParam->BSIM4eta0 = model->BSIM4eta0 - + model->BSIM4leta0 * Inv_L - + model->BSIM4weta0 * Inv_W - + model->BSIM4peta0 * Inv_LW; - pParam->BSIM4teta0 = model->BSIM4teta0 /* v4.7 */ - + model->BSIM4lteta0 * Inv_L - + model->BSIM4wteta0 * Inv_W - + model->BSIM4pteta0 * Inv_LW; - pParam->BSIM4etab = model->BSIM4etab - + model->BSIM4letab * Inv_L - + model->BSIM4wetab * Inv_W - + model->BSIM4petab * Inv_LW; - pParam->BSIM4pclm = model->BSIM4pclm - + model->BSIM4lpclm * Inv_L - + model->BSIM4wpclm * Inv_W - + model->BSIM4ppclm * Inv_LW; - pParam->BSIM4pdibl1 = model->BSIM4pdibl1 - + model->BSIM4lpdibl1 * Inv_L - + model->BSIM4wpdibl1 * Inv_W - + model->BSIM4ppdibl1 * Inv_LW; - pParam->BSIM4pdibl2 = model->BSIM4pdibl2 - + model->BSIM4lpdibl2 * Inv_L - + model->BSIM4wpdibl2 * Inv_W - + model->BSIM4ppdibl2 * Inv_LW; - pParam->BSIM4pdiblb = model->BSIM4pdiblb - + model->BSIM4lpdiblb * Inv_L - + model->BSIM4wpdiblb * Inv_W - + model->BSIM4ppdiblb * Inv_LW; - pParam->BSIM4pscbe1 = model->BSIM4pscbe1 - + model->BSIM4lpscbe1 * Inv_L - + model->BSIM4wpscbe1 * Inv_W - + model->BSIM4ppscbe1 * Inv_LW; - pParam->BSIM4pscbe2 = model->BSIM4pscbe2 - + model->BSIM4lpscbe2 * Inv_L - + model->BSIM4wpscbe2 * Inv_W - + model->BSIM4ppscbe2 * Inv_LW; - pParam->BSIM4pvag = model->BSIM4pvag - + model->BSIM4lpvag * Inv_L - + model->BSIM4wpvag * Inv_W - + model->BSIM4ppvag * Inv_LW; - pParam->BSIM4wr = model->BSIM4wr - + model->BSIM4lwr * Inv_L - + model->BSIM4wwr * Inv_W - + model->BSIM4pwr * Inv_LW; - pParam->BSIM4dwg = model->BSIM4dwg - + model->BSIM4ldwg * Inv_L - + model->BSIM4wdwg * Inv_W - + model->BSIM4pdwg * Inv_LW; - pParam->BSIM4dwb = model->BSIM4dwb - + model->BSIM4ldwb * Inv_L - + model->BSIM4wdwb * Inv_W - + model->BSIM4pdwb * Inv_LW; - pParam->BSIM4b0 = model->BSIM4b0 - + model->BSIM4lb0 * Inv_L - + model->BSIM4wb0 * Inv_W - + model->BSIM4pb0 * Inv_LW; - pParam->BSIM4b1 = model->BSIM4b1 - + model->BSIM4lb1 * Inv_L - + model->BSIM4wb1 * Inv_W - + model->BSIM4pb1 * Inv_LW; - pParam->BSIM4alpha0 = model->BSIM4alpha0 - + model->BSIM4lalpha0 * Inv_L - + model->BSIM4walpha0 * Inv_W - + model->BSIM4palpha0 * Inv_LW; - pParam->BSIM4alpha1 = model->BSIM4alpha1 - + model->BSIM4lalpha1 * Inv_L - + model->BSIM4walpha1 * Inv_W - + model->BSIM4palpha1 * Inv_LW; - pParam->BSIM4beta0 = model->BSIM4beta0 - + model->BSIM4lbeta0 * Inv_L - + model->BSIM4wbeta0 * Inv_W - + model->BSIM4pbeta0 * Inv_LW; - pParam->BSIM4agidl = model->BSIM4agidl - + model->BSIM4lagidl * Inv_L - + model->BSIM4wagidl * Inv_W - + model->BSIM4pagidl * Inv_LW; - pParam->BSIM4bgidl = model->BSIM4bgidl - + model->BSIM4lbgidl * Inv_L - + model->BSIM4wbgidl * Inv_W - + model->BSIM4pbgidl * Inv_LW; - pParam->BSIM4cgidl = model->BSIM4cgidl - + model->BSIM4lcgidl * Inv_L - + model->BSIM4wcgidl * Inv_W - + model->BSIM4pcgidl * Inv_LW; - pParam->BSIM4egidl = model->BSIM4egidl - + model->BSIM4legidl * Inv_L - + model->BSIM4wegidl * Inv_W - + model->BSIM4pegidl * Inv_LW; - pParam->BSIM4rgidl = model->BSIM4rgidl /* v4.7 New GIDL/GISL */ - + model->BSIM4lrgidl * Inv_L - + model->BSIM4wrgidl * Inv_W - + model->BSIM4prgidl * Inv_LW; - pParam->BSIM4kgidl = model->BSIM4kgidl /* v4.7 New GIDL/GISL */ - + model->BSIM4lkgidl * Inv_L - + model->BSIM4wkgidl * Inv_W - + model->BSIM4pkgidl * Inv_LW; - pParam->BSIM4fgidl = model->BSIM4fgidl /* v4.7 New GIDL/GISL */ - + model->BSIM4lfgidl * Inv_L - + model->BSIM4wfgidl * Inv_W - + model->BSIM4pfgidl * Inv_LW; - pParam->BSIM4agisl = model->BSIM4agisl - + model->BSIM4lagisl * Inv_L - + model->BSIM4wagisl * Inv_W - + model->BSIM4pagisl * Inv_LW; - pParam->BSIM4bgisl = model->BSIM4bgisl - + model->BSIM4lbgisl * Inv_L - + model->BSIM4wbgisl * Inv_W - + model->BSIM4pbgisl * Inv_LW; - pParam->BSIM4cgisl = model->BSIM4cgisl - + model->BSIM4lcgisl * Inv_L - + model->BSIM4wcgisl * Inv_W - + model->BSIM4pcgisl * Inv_LW; - pParam->BSIM4egisl = model->BSIM4egisl - + model->BSIM4legisl * Inv_L - + model->BSIM4wegisl * Inv_W - + model->BSIM4pegisl * Inv_LW; - pParam->BSIM4rgisl = model->BSIM4rgisl /* v4.7 New GIDL/GISL */ - + model->BSIM4lrgisl * Inv_L - + model->BSIM4wrgisl * Inv_W - + model->BSIM4prgisl * Inv_LW; - pParam->BSIM4kgisl = model->BSIM4kgisl /* v4.7 New GIDL/GISL */ - + model->BSIM4lkgisl * Inv_L - + model->BSIM4wkgisl * Inv_W - + model->BSIM4pkgisl * Inv_LW; - pParam->BSIM4fgisl = model->BSIM4fgisl /* v4.7 New GIDL/GISL */ - + model->BSIM4lfgisl * Inv_L - + model->BSIM4wfgisl * Inv_W - + model->BSIM4pfgisl * Inv_LW; - pParam->BSIM4aigc = model->BSIM4aigc - + model->BSIM4laigc * Inv_L - + model->BSIM4waigc * Inv_W - + model->BSIM4paigc * Inv_LW; - pParam->BSIM4bigc = model->BSIM4bigc - + model->BSIM4lbigc * Inv_L - + model->BSIM4wbigc * Inv_W - + model->BSIM4pbigc * Inv_LW; - pParam->BSIM4cigc = model->BSIM4cigc - + model->BSIM4lcigc * Inv_L - + model->BSIM4wcigc * Inv_W - + model->BSIM4pcigc * Inv_LW; - pParam->BSIM4aigs = model->BSIM4aigs - + model->BSIM4laigs * Inv_L - + model->BSIM4waigs * Inv_W - + model->BSIM4paigs * Inv_LW; - pParam->BSIM4bigs = model->BSIM4bigs - + model->BSIM4lbigs * Inv_L - + model->BSIM4wbigs * Inv_W - + model->BSIM4pbigs * Inv_LW; - pParam->BSIM4cigs = model->BSIM4cigs - + model->BSIM4lcigs * Inv_L - + model->BSIM4wcigs * Inv_W - + model->BSIM4pcigs * Inv_LW; - pParam->BSIM4aigd = model->BSIM4aigd - + model->BSIM4laigd * Inv_L - + model->BSIM4waigd * Inv_W - + model->BSIM4paigd * Inv_LW; - pParam->BSIM4bigd = model->BSIM4bigd - + model->BSIM4lbigd * Inv_L - + model->BSIM4wbigd * Inv_W - + model->BSIM4pbigd * Inv_LW; - pParam->BSIM4cigd = model->BSIM4cigd - + model->BSIM4lcigd * Inv_L - + model->BSIM4wcigd * Inv_W - + model->BSIM4pcigd * Inv_LW; - pParam->BSIM4aigbacc = model->BSIM4aigbacc - + model->BSIM4laigbacc * Inv_L - + model->BSIM4waigbacc * Inv_W - + model->BSIM4paigbacc * Inv_LW; - pParam->BSIM4bigbacc = model->BSIM4bigbacc - + model->BSIM4lbigbacc * Inv_L - + model->BSIM4wbigbacc * Inv_W - + model->BSIM4pbigbacc * Inv_LW; - pParam->BSIM4cigbacc = model->BSIM4cigbacc - + model->BSIM4lcigbacc * Inv_L - + model->BSIM4wcigbacc * Inv_W - + model->BSIM4pcigbacc * Inv_LW; - pParam->BSIM4aigbinv = model->BSIM4aigbinv - + model->BSIM4laigbinv * Inv_L - + model->BSIM4waigbinv * Inv_W - + model->BSIM4paigbinv * Inv_LW; - pParam->BSIM4bigbinv = model->BSIM4bigbinv - + model->BSIM4lbigbinv * Inv_L - + model->BSIM4wbigbinv * Inv_W - + model->BSIM4pbigbinv * Inv_LW; - pParam->BSIM4cigbinv = model->BSIM4cigbinv - + model->BSIM4lcigbinv * Inv_L - + model->BSIM4wcigbinv * Inv_W - + model->BSIM4pcigbinv * Inv_LW; - pParam->BSIM4nigc = model->BSIM4nigc - + model->BSIM4lnigc * Inv_L - + model->BSIM4wnigc * Inv_W - + model->BSIM4pnigc * Inv_LW; - pParam->BSIM4nigbacc = model->BSIM4nigbacc - + model->BSIM4lnigbacc * Inv_L - + model->BSIM4wnigbacc * Inv_W - + model->BSIM4pnigbacc * Inv_LW; - pParam->BSIM4nigbinv = model->BSIM4nigbinv - + model->BSIM4lnigbinv * Inv_L - + model->BSIM4wnigbinv * Inv_W - + model->BSIM4pnigbinv * Inv_LW; - pParam->BSIM4ntox = model->BSIM4ntox - + model->BSIM4lntox * Inv_L - + model->BSIM4wntox * Inv_W - + model->BSIM4pntox * Inv_LW; - pParam->BSIM4eigbinv = model->BSIM4eigbinv - + model->BSIM4leigbinv * Inv_L - + model->BSIM4weigbinv * Inv_W - + model->BSIM4peigbinv * Inv_LW; - pParam->BSIM4pigcd = model->BSIM4pigcd - + model->BSIM4lpigcd * Inv_L - + model->BSIM4wpigcd * Inv_W - + model->BSIM4ppigcd * Inv_LW; - pParam->BSIM4poxedge = model->BSIM4poxedge - + model->BSIM4lpoxedge * Inv_L - + model->BSIM4wpoxedge * Inv_W - + model->BSIM4ppoxedge * Inv_LW; - pParam->BSIM4xrcrg1 = model->BSIM4xrcrg1 - + model->BSIM4lxrcrg1 * Inv_L - + model->BSIM4wxrcrg1 * Inv_W - + model->BSIM4pxrcrg1 * Inv_LW; - pParam->BSIM4xrcrg2 = model->BSIM4xrcrg2 - + model->BSIM4lxrcrg2 * Inv_L - + model->BSIM4wxrcrg2 * Inv_W - + model->BSIM4pxrcrg2 * Inv_LW; - pParam->BSIM4lambda = model->BSIM4lambda - + model->BSIM4llambda * Inv_L - + model->BSIM4wlambda * Inv_W - + model->BSIM4plambda * Inv_LW; - pParam->BSIM4vtl = model->BSIM4vtl - + model->BSIM4lvtl * Inv_L - + model->BSIM4wvtl * Inv_W - + model->BSIM4pvtl * Inv_LW; - pParam->BSIM4xn = model->BSIM4xn - + model->BSIM4lxn * Inv_L - + model->BSIM4wxn * Inv_W - + model->BSIM4pxn * Inv_LW; - pParam->BSIM4vfbsdoff = model->BSIM4vfbsdoff - + model->BSIM4lvfbsdoff * Inv_L - + model->BSIM4wvfbsdoff * Inv_W - + model->BSIM4pvfbsdoff * Inv_LW; - pParam->BSIM4tvfbsdoff = model->BSIM4tvfbsdoff - + model->BSIM4ltvfbsdoff * Inv_L - + model->BSIM4wtvfbsdoff * Inv_W - + model->BSIM4ptvfbsdoff * Inv_LW; + pParam->BSIM4v7voff = model->BSIM4v7voff + + model->BSIM4v7lvoff * Inv_L + + model->BSIM4v7wvoff * Inv_W + + model->BSIM4v7pvoff * Inv_LW; + pParam->BSIM4v7tvoff = model->BSIM4v7tvoff + + model->BSIM4v7ltvoff * Inv_L + + model->BSIM4v7wtvoff * Inv_W + + model->BSIM4v7ptvoff * Inv_LW; + pParam->BSIM4v7minv = model->BSIM4v7minv + + model->BSIM4v7lminv * Inv_L + + model->BSIM4v7wminv * Inv_W + + model->BSIM4v7pminv * Inv_LW; + pParam->BSIM4v7minvcv = model->BSIM4v7minvcv + + model->BSIM4v7lminvcv * Inv_L + + model->BSIM4v7wminvcv * Inv_W + + model->BSIM4v7pminvcv * Inv_LW; + pParam->BSIM4v7fprout = model->BSIM4v7fprout + + model->BSIM4v7lfprout * Inv_L + + model->BSIM4v7wfprout * Inv_W + + model->BSIM4v7pfprout * Inv_LW; + pParam->BSIM4v7pdits = model->BSIM4v7pdits + + model->BSIM4v7lpdits * Inv_L + + model->BSIM4v7wpdits * Inv_W + + model->BSIM4v7ppdits * Inv_LW; + pParam->BSIM4v7pditsd = model->BSIM4v7pditsd + + model->BSIM4v7lpditsd * Inv_L + + model->BSIM4v7wpditsd * Inv_W + + model->BSIM4v7ppditsd * Inv_LW; + pParam->BSIM4v7delta = model->BSIM4v7delta + + model->BSIM4v7ldelta * Inv_L + + model->BSIM4v7wdelta * Inv_W + + model->BSIM4v7pdelta * Inv_LW; + pParam->BSIM4v7rdsw = model->BSIM4v7rdsw + + model->BSIM4v7lrdsw * Inv_L + + model->BSIM4v7wrdsw * Inv_W + + model->BSIM4v7prdsw * Inv_LW; + pParam->BSIM4v7rdw = model->BSIM4v7rdw + + model->BSIM4v7lrdw * Inv_L + + model->BSIM4v7wrdw * Inv_W + + model->BSIM4v7prdw * Inv_LW; + pParam->BSIM4v7rsw = model->BSIM4v7rsw + + model->BSIM4v7lrsw * Inv_L + + model->BSIM4v7wrsw * Inv_W + + model->BSIM4v7prsw * Inv_LW; + pParam->BSIM4v7prwg = model->BSIM4v7prwg + + model->BSIM4v7lprwg * Inv_L + + model->BSIM4v7wprwg * Inv_W + + model->BSIM4v7pprwg * Inv_LW; + pParam->BSIM4v7prwb = model->BSIM4v7prwb + + model->BSIM4v7lprwb * Inv_L + + model->BSIM4v7wprwb * Inv_W + + model->BSIM4v7pprwb * Inv_LW; + pParam->BSIM4v7prt = model->BSIM4v7prt + + model->BSIM4v7lprt * Inv_L + + model->BSIM4v7wprt * Inv_W + + model->BSIM4v7pprt * Inv_LW; + pParam->BSIM4v7eta0 = model->BSIM4v7eta0 + + model->BSIM4v7leta0 * Inv_L + + model->BSIM4v7weta0 * Inv_W + + model->BSIM4v7peta0 * Inv_LW; + pParam->BSIM4v7teta0 = model->BSIM4v7teta0 /* v4.7 */ + + model->BSIM4v7lteta0 * Inv_L + + model->BSIM4v7wteta0 * Inv_W + + model->BSIM4v7pteta0 * Inv_LW; + pParam->BSIM4v7etab = model->BSIM4v7etab + + model->BSIM4v7letab * Inv_L + + model->BSIM4v7wetab * Inv_W + + model->BSIM4v7petab * Inv_LW; + pParam->BSIM4v7pclm = model->BSIM4v7pclm + + model->BSIM4v7lpclm * Inv_L + + model->BSIM4v7wpclm * Inv_W + + model->BSIM4v7ppclm * Inv_LW; + pParam->BSIM4v7pdibl1 = model->BSIM4v7pdibl1 + + model->BSIM4v7lpdibl1 * Inv_L + + model->BSIM4v7wpdibl1 * Inv_W + + model->BSIM4v7ppdibl1 * Inv_LW; + pParam->BSIM4v7pdibl2 = model->BSIM4v7pdibl2 + + model->BSIM4v7lpdibl2 * Inv_L + + model->BSIM4v7wpdibl2 * Inv_W + + model->BSIM4v7ppdibl2 * Inv_LW; + pParam->BSIM4v7pdiblb = model->BSIM4v7pdiblb + + model->BSIM4v7lpdiblb * Inv_L + + model->BSIM4v7wpdiblb * Inv_W + + model->BSIM4v7ppdiblb * Inv_LW; + pParam->BSIM4v7pscbe1 = model->BSIM4v7pscbe1 + + model->BSIM4v7lpscbe1 * Inv_L + + model->BSIM4v7wpscbe1 * Inv_W + + model->BSIM4v7ppscbe1 * Inv_LW; + pParam->BSIM4v7pscbe2 = model->BSIM4v7pscbe2 + + model->BSIM4v7lpscbe2 * Inv_L + + model->BSIM4v7wpscbe2 * Inv_W + + model->BSIM4v7ppscbe2 * Inv_LW; + pParam->BSIM4v7pvag = model->BSIM4v7pvag + + model->BSIM4v7lpvag * Inv_L + + model->BSIM4v7wpvag * Inv_W + + model->BSIM4v7ppvag * Inv_LW; + pParam->BSIM4v7wr = model->BSIM4v7wr + + model->BSIM4v7lwr * Inv_L + + model->BSIM4v7wwr * Inv_W + + model->BSIM4v7pwr * Inv_LW; + pParam->BSIM4v7dwg = model->BSIM4v7dwg + + model->BSIM4v7ldwg * Inv_L + + model->BSIM4v7wdwg * Inv_W + + model->BSIM4v7pdwg * Inv_LW; + pParam->BSIM4v7dwb = model->BSIM4v7dwb + + model->BSIM4v7ldwb * Inv_L + + model->BSIM4v7wdwb * Inv_W + + model->BSIM4v7pdwb * Inv_LW; + pParam->BSIM4v7b0 = model->BSIM4v7b0 + + model->BSIM4v7lb0 * Inv_L + + model->BSIM4v7wb0 * Inv_W + + model->BSIM4v7pb0 * Inv_LW; + pParam->BSIM4v7b1 = model->BSIM4v7b1 + + model->BSIM4v7lb1 * Inv_L + + model->BSIM4v7wb1 * Inv_W + + model->BSIM4v7pb1 * Inv_LW; + pParam->BSIM4v7alpha0 = model->BSIM4v7alpha0 + + model->BSIM4v7lalpha0 * Inv_L + + model->BSIM4v7walpha0 * Inv_W + + model->BSIM4v7palpha0 * Inv_LW; + pParam->BSIM4v7alpha1 = model->BSIM4v7alpha1 + + model->BSIM4v7lalpha1 * Inv_L + + model->BSIM4v7walpha1 * Inv_W + + model->BSIM4v7palpha1 * Inv_LW; + pParam->BSIM4v7beta0 = model->BSIM4v7beta0 + + model->BSIM4v7lbeta0 * Inv_L + + model->BSIM4v7wbeta0 * Inv_W + + model->BSIM4v7pbeta0 * Inv_LW; + pParam->BSIM4v7agidl = model->BSIM4v7agidl + + model->BSIM4v7lagidl * Inv_L + + model->BSIM4v7wagidl * Inv_W + + model->BSIM4v7pagidl * Inv_LW; + pParam->BSIM4v7bgidl = model->BSIM4v7bgidl + + model->BSIM4v7lbgidl * Inv_L + + model->BSIM4v7wbgidl * Inv_W + + model->BSIM4v7pbgidl * Inv_LW; + pParam->BSIM4v7cgidl = model->BSIM4v7cgidl + + model->BSIM4v7lcgidl * Inv_L + + model->BSIM4v7wcgidl * Inv_W + + model->BSIM4v7pcgidl * Inv_LW; + pParam->BSIM4v7egidl = model->BSIM4v7egidl + + model->BSIM4v7legidl * Inv_L + + model->BSIM4v7wegidl * Inv_W + + model->BSIM4v7pegidl * Inv_LW; + pParam->BSIM4v7rgidl = model->BSIM4v7rgidl /* v4.7 New GIDL/GISL */ + + model->BSIM4v7lrgidl * Inv_L + + model->BSIM4v7wrgidl * Inv_W + + model->BSIM4v7prgidl * Inv_LW; + pParam->BSIM4v7kgidl = model->BSIM4v7kgidl /* v4.7 New GIDL/GISL */ + + model->BSIM4v7lkgidl * Inv_L + + model->BSIM4v7wkgidl * Inv_W + + model->BSIM4v7pkgidl * Inv_LW; + pParam->BSIM4v7fgidl = model->BSIM4v7fgidl /* v4.7 New GIDL/GISL */ + + model->BSIM4v7lfgidl * Inv_L + + model->BSIM4v7wfgidl * Inv_W + + model->BSIM4v7pfgidl * Inv_LW; + pParam->BSIM4v7agisl = model->BSIM4v7agisl + + model->BSIM4v7lagisl * Inv_L + + model->BSIM4v7wagisl * Inv_W + + model->BSIM4v7pagisl * Inv_LW; + pParam->BSIM4v7bgisl = model->BSIM4v7bgisl + + model->BSIM4v7lbgisl * Inv_L + + model->BSIM4v7wbgisl * Inv_W + + model->BSIM4v7pbgisl * Inv_LW; + pParam->BSIM4v7cgisl = model->BSIM4v7cgisl + + model->BSIM4v7lcgisl * Inv_L + + model->BSIM4v7wcgisl * Inv_W + + model->BSIM4v7pcgisl * Inv_LW; + pParam->BSIM4v7egisl = model->BSIM4v7egisl + + model->BSIM4v7legisl * Inv_L + + model->BSIM4v7wegisl * Inv_W + + model->BSIM4v7pegisl * Inv_LW; + pParam->BSIM4v7rgisl = model->BSIM4v7rgisl /* v4.7 New GIDL/GISL */ + + model->BSIM4v7lrgisl * Inv_L + + model->BSIM4v7wrgisl * Inv_W + + model->BSIM4v7prgisl * Inv_LW; + pParam->BSIM4v7kgisl = model->BSIM4v7kgisl /* v4.7 New GIDL/GISL */ + + model->BSIM4v7lkgisl * Inv_L + + model->BSIM4v7wkgisl * Inv_W + + model->BSIM4v7pkgisl * Inv_LW; + pParam->BSIM4v7fgisl = model->BSIM4v7fgisl /* v4.7 New GIDL/GISL */ + + model->BSIM4v7lfgisl * Inv_L + + model->BSIM4v7wfgisl * Inv_W + + model->BSIM4v7pfgisl * Inv_LW; + pParam->BSIM4v7aigc = model->BSIM4v7aigc + + model->BSIM4v7laigc * Inv_L + + model->BSIM4v7waigc * Inv_W + + model->BSIM4v7paigc * Inv_LW; + pParam->BSIM4v7bigc = model->BSIM4v7bigc + + model->BSIM4v7lbigc * Inv_L + + model->BSIM4v7wbigc * Inv_W + + model->BSIM4v7pbigc * Inv_LW; + pParam->BSIM4v7cigc = model->BSIM4v7cigc + + model->BSIM4v7lcigc * Inv_L + + model->BSIM4v7wcigc * Inv_W + + model->BSIM4v7pcigc * Inv_LW; + pParam->BSIM4v7aigs = model->BSIM4v7aigs + + model->BSIM4v7laigs * Inv_L + + model->BSIM4v7waigs * Inv_W + + model->BSIM4v7paigs * Inv_LW; + pParam->BSIM4v7bigs = model->BSIM4v7bigs + + model->BSIM4v7lbigs * Inv_L + + model->BSIM4v7wbigs * Inv_W + + model->BSIM4v7pbigs * Inv_LW; + pParam->BSIM4v7cigs = model->BSIM4v7cigs + + model->BSIM4v7lcigs * Inv_L + + model->BSIM4v7wcigs * Inv_W + + model->BSIM4v7pcigs * Inv_LW; + pParam->BSIM4v7aigd = model->BSIM4v7aigd + + model->BSIM4v7laigd * Inv_L + + model->BSIM4v7waigd * Inv_W + + model->BSIM4v7paigd * Inv_LW; + pParam->BSIM4v7bigd = model->BSIM4v7bigd + + model->BSIM4v7lbigd * Inv_L + + model->BSIM4v7wbigd * Inv_W + + model->BSIM4v7pbigd * Inv_LW; + pParam->BSIM4v7cigd = model->BSIM4v7cigd + + model->BSIM4v7lcigd * Inv_L + + model->BSIM4v7wcigd * Inv_W + + model->BSIM4v7pcigd * Inv_LW; + pParam->BSIM4v7aigbacc = model->BSIM4v7aigbacc + + model->BSIM4v7laigbacc * Inv_L + + model->BSIM4v7waigbacc * Inv_W + + model->BSIM4v7paigbacc * Inv_LW; + pParam->BSIM4v7bigbacc = model->BSIM4v7bigbacc + + model->BSIM4v7lbigbacc * Inv_L + + model->BSIM4v7wbigbacc * Inv_W + + model->BSIM4v7pbigbacc * Inv_LW; + pParam->BSIM4v7cigbacc = model->BSIM4v7cigbacc + + model->BSIM4v7lcigbacc * Inv_L + + model->BSIM4v7wcigbacc * Inv_W + + model->BSIM4v7pcigbacc * Inv_LW; + pParam->BSIM4v7aigbinv = model->BSIM4v7aigbinv + + model->BSIM4v7laigbinv * Inv_L + + model->BSIM4v7waigbinv * Inv_W + + model->BSIM4v7paigbinv * Inv_LW; + pParam->BSIM4v7bigbinv = model->BSIM4v7bigbinv + + model->BSIM4v7lbigbinv * Inv_L + + model->BSIM4v7wbigbinv * Inv_W + + model->BSIM4v7pbigbinv * Inv_LW; + pParam->BSIM4v7cigbinv = model->BSIM4v7cigbinv + + model->BSIM4v7lcigbinv * Inv_L + + model->BSIM4v7wcigbinv * Inv_W + + model->BSIM4v7pcigbinv * Inv_LW; + pParam->BSIM4v7nigc = model->BSIM4v7nigc + + model->BSIM4v7lnigc * Inv_L + + model->BSIM4v7wnigc * Inv_W + + model->BSIM4v7pnigc * Inv_LW; + pParam->BSIM4v7nigbacc = model->BSIM4v7nigbacc + + model->BSIM4v7lnigbacc * Inv_L + + model->BSIM4v7wnigbacc * Inv_W + + model->BSIM4v7pnigbacc * Inv_LW; + pParam->BSIM4v7nigbinv = model->BSIM4v7nigbinv + + model->BSIM4v7lnigbinv * Inv_L + + model->BSIM4v7wnigbinv * Inv_W + + model->BSIM4v7pnigbinv * Inv_LW; + pParam->BSIM4v7ntox = model->BSIM4v7ntox + + model->BSIM4v7lntox * Inv_L + + model->BSIM4v7wntox * Inv_W + + model->BSIM4v7pntox * Inv_LW; + pParam->BSIM4v7eigbinv = model->BSIM4v7eigbinv + + model->BSIM4v7leigbinv * Inv_L + + model->BSIM4v7weigbinv * Inv_W + + model->BSIM4v7peigbinv * Inv_LW; + pParam->BSIM4v7pigcd = model->BSIM4v7pigcd + + model->BSIM4v7lpigcd * Inv_L + + model->BSIM4v7wpigcd * Inv_W + + model->BSIM4v7ppigcd * Inv_LW; + pParam->BSIM4v7poxedge = model->BSIM4v7poxedge + + model->BSIM4v7lpoxedge * Inv_L + + model->BSIM4v7wpoxedge * Inv_W + + model->BSIM4v7ppoxedge * Inv_LW; + pParam->BSIM4v7xrcrg1 = model->BSIM4v7xrcrg1 + + model->BSIM4v7lxrcrg1 * Inv_L + + model->BSIM4v7wxrcrg1 * Inv_W + + model->BSIM4v7pxrcrg1 * Inv_LW; + pParam->BSIM4v7xrcrg2 = model->BSIM4v7xrcrg2 + + model->BSIM4v7lxrcrg2 * Inv_L + + model->BSIM4v7wxrcrg2 * Inv_W + + model->BSIM4v7pxrcrg2 * Inv_LW; + pParam->BSIM4v7lambda = model->BSIM4v7lambda + + model->BSIM4v7llambda * Inv_L + + model->BSIM4v7wlambda * Inv_W + + model->BSIM4v7plambda * Inv_LW; + pParam->BSIM4v7vtl = model->BSIM4v7vtl + + model->BSIM4v7lvtl * Inv_L + + model->BSIM4v7wvtl * Inv_W + + model->BSIM4v7pvtl * Inv_LW; + pParam->BSIM4v7xn = model->BSIM4v7xn + + model->BSIM4v7lxn * Inv_L + + model->BSIM4v7wxn * Inv_W + + model->BSIM4v7pxn * Inv_LW; + pParam->BSIM4v7vfbsdoff = model->BSIM4v7vfbsdoff + + model->BSIM4v7lvfbsdoff * Inv_L + + model->BSIM4v7wvfbsdoff * Inv_W + + model->BSIM4v7pvfbsdoff * Inv_LW; + pParam->BSIM4v7tvfbsdoff = model->BSIM4v7tvfbsdoff + + model->BSIM4v7ltvfbsdoff * Inv_L + + model->BSIM4v7wtvfbsdoff * Inv_W + + model->BSIM4v7ptvfbsdoff * Inv_LW; - pParam->BSIM4cgsl = model->BSIM4cgsl - + model->BSIM4lcgsl * Inv_L - + model->BSIM4wcgsl * Inv_W - + model->BSIM4pcgsl * Inv_LW; - pParam->BSIM4cgdl = model->BSIM4cgdl - + model->BSIM4lcgdl * Inv_L - + model->BSIM4wcgdl * Inv_W - + model->BSIM4pcgdl * Inv_LW; - pParam->BSIM4ckappas = model->BSIM4ckappas - + model->BSIM4lckappas * Inv_L - + model->BSIM4wckappas * Inv_W - + model->BSIM4pckappas * Inv_LW; - pParam->BSIM4ckappad = model->BSIM4ckappad - + model->BSIM4lckappad * Inv_L - + model->BSIM4wckappad * Inv_W - + model->BSIM4pckappad * Inv_LW; - pParam->BSIM4cf = model->BSIM4cf - + model->BSIM4lcf * Inv_L - + model->BSIM4wcf * Inv_W - + model->BSIM4pcf * Inv_LW; - pParam->BSIM4clc = model->BSIM4clc - + model->BSIM4lclc * Inv_L - + model->BSIM4wclc * Inv_W - + model->BSIM4pclc * Inv_LW; - pParam->BSIM4cle = model->BSIM4cle - + model->BSIM4lcle * Inv_L - + model->BSIM4wcle * Inv_W - + model->BSIM4pcle * Inv_LW; - pParam->BSIM4vfbcv = model->BSIM4vfbcv - + model->BSIM4lvfbcv * Inv_L - + model->BSIM4wvfbcv * Inv_W - + model->BSIM4pvfbcv * Inv_LW; - pParam->BSIM4acde = model->BSIM4acde - + model->BSIM4lacde * Inv_L - + model->BSIM4wacde * Inv_W - + model->BSIM4pacde * Inv_LW; - pParam->BSIM4moin = model->BSIM4moin - + model->BSIM4lmoin * Inv_L - + model->BSIM4wmoin * Inv_W - + model->BSIM4pmoin * Inv_LW; - pParam->BSIM4noff = model->BSIM4noff - + model->BSIM4lnoff * Inv_L - + model->BSIM4wnoff * Inv_W - + model->BSIM4pnoff * Inv_LW; - pParam->BSIM4voffcv = model->BSIM4voffcv - + model->BSIM4lvoffcv * Inv_L - + model->BSIM4wvoffcv * Inv_W - + model->BSIM4pvoffcv * Inv_LW; - pParam->BSIM4kvth0we = model->BSIM4kvth0we - + model->BSIM4lkvth0we * Inv_L - + model->BSIM4wkvth0we * Inv_W - + model->BSIM4pkvth0we * Inv_LW; - pParam->BSIM4k2we = model->BSIM4k2we - + model->BSIM4lk2we * Inv_L - + model->BSIM4wk2we * Inv_W - + model->BSIM4pk2we * Inv_LW; - pParam->BSIM4ku0we = model->BSIM4ku0we - + model->BSIM4lku0we * Inv_L - + model->BSIM4wku0we * Inv_W - + model->BSIM4pku0we * Inv_LW; + pParam->BSIM4v7cgsl = model->BSIM4v7cgsl + + model->BSIM4v7lcgsl * Inv_L + + model->BSIM4v7wcgsl * Inv_W + + model->BSIM4v7pcgsl * Inv_LW; + pParam->BSIM4v7cgdl = model->BSIM4v7cgdl + + model->BSIM4v7lcgdl * Inv_L + + model->BSIM4v7wcgdl * Inv_W + + model->BSIM4v7pcgdl * Inv_LW; + pParam->BSIM4v7ckappas = model->BSIM4v7ckappas + + model->BSIM4v7lckappas * Inv_L + + model->BSIM4v7wckappas * Inv_W + + model->BSIM4v7pckappas * Inv_LW; + pParam->BSIM4v7ckappad = model->BSIM4v7ckappad + + model->BSIM4v7lckappad * Inv_L + + model->BSIM4v7wckappad * Inv_W + + model->BSIM4v7pckappad * Inv_LW; + pParam->BSIM4v7cf = model->BSIM4v7cf + + model->BSIM4v7lcf * Inv_L + + model->BSIM4v7wcf * Inv_W + + model->BSIM4v7pcf * Inv_LW; + pParam->BSIM4v7clc = model->BSIM4v7clc + + model->BSIM4v7lclc * Inv_L + + model->BSIM4v7wclc * Inv_W + + model->BSIM4v7pclc * Inv_LW; + pParam->BSIM4v7cle = model->BSIM4v7cle + + model->BSIM4v7lcle * Inv_L + + model->BSIM4v7wcle * Inv_W + + model->BSIM4v7pcle * Inv_LW; + pParam->BSIM4v7vfbcv = model->BSIM4v7vfbcv + + model->BSIM4v7lvfbcv * Inv_L + + model->BSIM4v7wvfbcv * Inv_W + + model->BSIM4v7pvfbcv * Inv_LW; + pParam->BSIM4v7acde = model->BSIM4v7acde + + model->BSIM4v7lacde * Inv_L + + model->BSIM4v7wacde * Inv_W + + model->BSIM4v7pacde * Inv_LW; + pParam->BSIM4v7moin = model->BSIM4v7moin + + model->BSIM4v7lmoin * Inv_L + + model->BSIM4v7wmoin * Inv_W + + model->BSIM4v7pmoin * Inv_LW; + pParam->BSIM4v7noff = model->BSIM4v7noff + + model->BSIM4v7lnoff * Inv_L + + model->BSIM4v7wnoff * Inv_W + + model->BSIM4v7pnoff * Inv_LW; + pParam->BSIM4v7voffcv = model->BSIM4v7voffcv + + model->BSIM4v7lvoffcv * Inv_L + + model->BSIM4v7wvoffcv * Inv_W + + model->BSIM4v7pvoffcv * Inv_LW; + pParam->BSIM4v7kvth0we = model->BSIM4v7kvth0we + + model->BSIM4v7lkvth0we * Inv_L + + model->BSIM4v7wkvth0we * Inv_W + + model->BSIM4v7pkvth0we * Inv_LW; + pParam->BSIM4v7k2we = model->BSIM4v7k2we + + model->BSIM4v7lk2we * Inv_L + + model->BSIM4v7wk2we * Inv_W + + model->BSIM4v7pk2we * Inv_LW; + pParam->BSIM4v7ku0we = model->BSIM4v7ku0we + + model->BSIM4v7lku0we * Inv_L + + model->BSIM4v7wku0we * Inv_W + + model->BSIM4v7pku0we * Inv_LW; - pParam->BSIM4abulkCVfactor = 1.0 + pow((pParam->BSIM4clc - / pParam->BSIM4leffCV), - pParam->BSIM4cle); + pParam->BSIM4v7abulkCVfactor = 1.0 + pow((pParam->BSIM4v7clc + / pParam->BSIM4v7leffCV), + pParam->BSIM4v7cle); T0 = (TRatio - 1.0); - PowWeffWr = pow(pParam->BSIM4weffCJ * 1.0e6, pParam->BSIM4wr) * here->BSIM4nf; + PowWeffWr = pow(pParam->BSIM4v7weffCJ * 1.0e6, pParam->BSIM4v7wr) * here->BSIM4v7nf; T1 = T2 = T3 = T4 = 0.0; - pParam->BSIM4ucs = pParam->BSIM4ucs * pow(TRatio, pParam->BSIM4ucste); - if(model->BSIM4tempMod == 0) + pParam->BSIM4v7ucs = pParam->BSIM4v7ucs * pow(TRatio, pParam->BSIM4v7ucste); + if(model->BSIM4v7tempMod == 0) { - pParam->BSIM4ua = pParam->BSIM4ua + pParam->BSIM4ua1 * T0; - pParam->BSIM4ub = pParam->BSIM4ub + pParam->BSIM4ub1 * T0; - pParam->BSIM4uc = pParam->BSIM4uc + pParam->BSIM4uc1 * T0; - pParam->BSIM4ud = pParam->BSIM4ud + pParam->BSIM4ud1 * T0; - pParam->BSIM4vsattemp = pParam->BSIM4vsat - pParam->BSIM4at * T0; - T10 = pParam->BSIM4prt * T0; - if(model->BSIM4rdsMod) + pParam->BSIM4v7ua = pParam->BSIM4v7ua + pParam->BSIM4v7ua1 * T0; + pParam->BSIM4v7ub = pParam->BSIM4v7ub + pParam->BSIM4v7ub1 * T0; + pParam->BSIM4v7uc = pParam->BSIM4v7uc + pParam->BSIM4v7uc1 * T0; + pParam->BSIM4v7ud = pParam->BSIM4v7ud + pParam->BSIM4v7ud1 * T0; + pParam->BSIM4v7vsattemp = pParam->BSIM4v7vsat - pParam->BSIM4v7at * T0; + T10 = pParam->BSIM4v7prt * T0; + if(model->BSIM4v7rdsMod) { /* External Rd(V) */ - T1 = pParam->BSIM4rdw + T10; - T2 = model->BSIM4rdwmin + T10; + T1 = pParam->BSIM4v7rdw + T10; + T2 = model->BSIM4v7rdwmin + T10; /* External Rs(V) */ - T3 = pParam->BSIM4rsw + T10; - T4 = model->BSIM4rswmin + T10; + T3 = pParam->BSIM4v7rsw + T10; + T4 = model->BSIM4v7rswmin + T10; } /* Internal Rds(V) in IV */ - pParam->BSIM4rds0 = (pParam->BSIM4rdsw + T10) - * here->BSIM4nf / PowWeffWr; - pParam->BSIM4rdswmin = (model->BSIM4rdswmin + T10) - * here->BSIM4nf / PowWeffWr; + pParam->BSIM4v7rds0 = (pParam->BSIM4v7rdsw + T10) + * here->BSIM4v7nf / PowWeffWr; + pParam->BSIM4v7rdswmin = (model->BSIM4v7rdswmin + T10) + * here->BSIM4v7nf / PowWeffWr; } else { - if (model->BSIM4tempMod == 3) + if (model->BSIM4v7tempMod == 3) { - pParam->BSIM4ua = pParam->BSIM4ua * pow(TRatio, pParam->BSIM4ua1) ; - pParam->BSIM4ub = pParam->BSIM4ub * pow(TRatio, pParam->BSIM4ub1); - pParam->BSIM4uc = pParam->BSIM4uc * pow(TRatio, pParam->BSIM4uc1); - pParam->BSIM4ud = pParam->BSIM4ud * pow(TRatio, pParam->BSIM4ud1); + pParam->BSIM4v7ua = pParam->BSIM4v7ua * pow(TRatio, pParam->BSIM4v7ua1) ; + pParam->BSIM4v7ub = pParam->BSIM4v7ub * pow(TRatio, pParam->BSIM4v7ub1); + pParam->BSIM4v7uc = pParam->BSIM4v7uc * pow(TRatio, pParam->BSIM4v7uc1); + pParam->BSIM4v7ud = pParam->BSIM4v7ud * pow(TRatio, pParam->BSIM4v7ud1); } else { /* tempMod = 1, 2 */ - pParam->BSIM4ua = pParam->BSIM4ua * (1.0 + pParam->BSIM4ua1 * delTemp) ; - pParam->BSIM4ub = pParam->BSIM4ub * (1.0 + pParam->BSIM4ub1 * delTemp); - pParam->BSIM4uc = pParam->BSIM4uc * (1.0 + pParam->BSIM4uc1 * delTemp); - pParam->BSIM4ud = pParam->BSIM4ud * (1.0 + pParam->BSIM4ud1 * delTemp); + pParam->BSIM4v7ua = pParam->BSIM4v7ua * (1.0 + pParam->BSIM4v7ua1 * delTemp) ; + pParam->BSIM4v7ub = pParam->BSIM4v7ub * (1.0 + pParam->BSIM4v7ub1 * delTemp); + pParam->BSIM4v7uc = pParam->BSIM4v7uc * (1.0 + pParam->BSIM4v7uc1 * delTemp); + pParam->BSIM4v7ud = pParam->BSIM4v7ud * (1.0 + pParam->BSIM4v7ud1 * delTemp); } - pParam->BSIM4vsattemp = pParam->BSIM4vsat * (1.0 - pParam->BSIM4at * delTemp); - T10 = 1.0 + pParam->BSIM4prt * delTemp; - if(model->BSIM4rdsMod) + pParam->BSIM4v7vsattemp = pParam->BSIM4v7vsat * (1.0 - pParam->BSIM4v7at * delTemp); + T10 = 1.0 + pParam->BSIM4v7prt * delTemp; + if(model->BSIM4v7rdsMod) { /* External Rd(V) */ - T1 = pParam->BSIM4rdw * T10; - T2 = model->BSIM4rdwmin * T10; + T1 = pParam->BSIM4v7rdw * T10; + T2 = model->BSIM4v7rdwmin * T10; /* External Rs(V) */ - T3 = pParam->BSIM4rsw * T10; - T4 = model->BSIM4rswmin * T10; + T3 = pParam->BSIM4v7rsw * T10; + T4 = model->BSIM4v7rswmin * T10; } /* Internal Rds(V) in IV */ - pParam->BSIM4rds0 = pParam->BSIM4rdsw * T10 * here->BSIM4nf / PowWeffWr; - pParam->BSIM4rdswmin = model->BSIM4rdswmin * T10 * here->BSIM4nf / PowWeffWr; + pParam->BSIM4v7rds0 = pParam->BSIM4v7rdsw * T10 * here->BSIM4v7nf / PowWeffWr; + pParam->BSIM4v7rdswmin = model->BSIM4v7rdswmin * T10 * here->BSIM4v7nf / PowWeffWr; } if (T1 < 0.0) @@ -1224,8 +1224,8 @@ int Size_Not_Found, i; { T2 = 0.0; printf("Warning: Rdwmin at current temperature is negative; set to 0.\n"); } - pParam->BSIM4rd0 = T1 / PowWeffWr; - pParam->BSIM4rdwmin = T2 / PowWeffWr; + pParam->BSIM4v7rd0 = T1 / PowWeffWr; + pParam->BSIM4v7rdwmin = T2 / PowWeffWr; if (T3 < 0.0) { T3 = 0.0; printf("Warning: Rsw at current temperature is negative; set to 0.\n"); @@ -1234,228 +1234,228 @@ int Size_Not_Found, i; { T4 = 0.0; printf("Warning: Rswmin at current temperature is negative; set to 0.\n"); } - pParam->BSIM4rs0 = T3 / PowWeffWr; - pParam->BSIM4rswmin = T4 / PowWeffWr; + pParam->BSIM4v7rs0 = T3 / PowWeffWr; + pParam->BSIM4v7rswmin = T4 / PowWeffWr; - if (pParam->BSIM4u0 > 1.0) - pParam->BSIM4u0 = pParam->BSIM4u0 / 1.0e4; + if (pParam->BSIM4v7u0 > 1.0) + pParam->BSIM4v7u0 = pParam->BSIM4v7u0 / 1.0e4; /* mobility channel length dependence */ - T5 = 1.0 - pParam->BSIM4up * exp( - pParam->BSIM4leff / pParam->BSIM4lp); - pParam->BSIM4u0temp = pParam->BSIM4u0 * T5 - * pow(TRatio, pParam->BSIM4ute); - if (pParam->BSIM4eu < 0.0) - { pParam->BSIM4eu = 0.0; + T5 = 1.0 - pParam->BSIM4v7up * exp( - pParam->BSIM4v7leff / pParam->BSIM4v7lp); + pParam->BSIM4v7u0temp = pParam->BSIM4v7u0 * T5 + * pow(TRatio, pParam->BSIM4v7ute); + if (pParam->BSIM4v7eu < 0.0) + { pParam->BSIM4v7eu = 0.0; printf("Warning: eu has been negative; reset to 0.0.\n"); } - if (pParam->BSIM4ucs < 0.0) - { pParam->BSIM4ucs = 0.0; + if (pParam->BSIM4v7ucs < 0.0) + { pParam->BSIM4v7ucs = 0.0; printf("Warning: ucs has been negative; reset to 0.0.\n"); } - pParam->BSIM4vfbsdoff = pParam->BSIM4vfbsdoff * (1.0 + pParam->BSIM4tvfbsdoff * delTemp); - pParam->BSIM4voff = pParam->BSIM4voff * (1.0 + pParam->BSIM4tvoff * delTemp); + pParam->BSIM4v7vfbsdoff = pParam->BSIM4v7vfbsdoff * (1.0 + pParam->BSIM4v7tvfbsdoff * delTemp); + pParam->BSIM4v7voff = pParam->BSIM4v7voff * (1.0 + pParam->BSIM4v7tvoff * delTemp); - pParam->BSIM4nfactor = pParam->BSIM4nfactor + pParam->BSIM4tnfactor * delTemp / Tnom; /* v4.7 temp dep of leakage currents */ - pParam->BSIM4voffcv = pParam->BSIM4voffcv * (1.0 + pParam->BSIM4tvoffcv * delTemp); /* v4.7 temp dep of leakage currents */ - pParam->BSIM4eta0 = pParam->BSIM4eta0 + pParam->BSIM4teta0 * delTemp / Tnom; /* v4.7 temp dep of leakage currents */ + pParam->BSIM4v7nfactor = pParam->BSIM4v7nfactor + pParam->BSIM4v7tnfactor * delTemp / Tnom; /* v4.7 temp dep of leakage currents */ + pParam->BSIM4v7voffcv = pParam->BSIM4v7voffcv * (1.0 + pParam->BSIM4v7tvoffcv * delTemp); /* v4.7 temp dep of leakage currents */ + pParam->BSIM4v7eta0 = pParam->BSIM4v7eta0 + pParam->BSIM4v7teta0 * delTemp / Tnom; /* v4.7 temp dep of leakage currents */ /* Source End Velocity Limit */ - if((model->BSIM4vtlGiven) && (model->BSIM4vtl > 0.0) ) + if((model->BSIM4v7vtlGiven) && (model->BSIM4v7vtl > 0.0) ) { - if(model->BSIM4lc < 0.0) pParam->BSIM4lc = 0.0; - else pParam->BSIM4lc = model->BSIM4lc ; - T0 = pParam->BSIM4leff / (pParam->BSIM4xn * pParam->BSIM4leff + pParam->BSIM4lc); - pParam->BSIM4tfactor = (1.0 - T0) / (1.0 + T0 ); + if(model->BSIM4v7lc < 0.0) pParam->BSIM4v7lc = 0.0; + else pParam->BSIM4v7lc = model->BSIM4v7lc ; + T0 = pParam->BSIM4v7leff / (pParam->BSIM4v7xn * pParam->BSIM4v7leff + pParam->BSIM4v7lc); + pParam->BSIM4v7tfactor = (1.0 - T0) / (1.0 + T0 ); } - pParam->BSIM4cgdo = (model->BSIM4cgdo + pParam->BSIM4cf) - * pParam->BSIM4weffCV; - pParam->BSIM4cgso = (model->BSIM4cgso + pParam->BSIM4cf) - * pParam->BSIM4weffCV; - pParam->BSIM4cgbo = model->BSIM4cgbo * pParam->BSIM4leffCV * here->BSIM4nf; + pParam->BSIM4v7cgdo = (model->BSIM4v7cgdo + pParam->BSIM4v7cf) + * pParam->BSIM4v7weffCV; + pParam->BSIM4v7cgso = (model->BSIM4v7cgso + pParam->BSIM4v7cf) + * pParam->BSIM4v7weffCV; + pParam->BSIM4v7cgbo = model->BSIM4v7cgbo * pParam->BSIM4v7leffCV * here->BSIM4v7nf; - if (!model->BSIM4ndepGiven && model->BSIM4gamma1Given) - { T0 = pParam->BSIM4gamma1 * model->BSIM4coxe; - pParam->BSIM4ndep = 3.01248e22 * T0 * T0; + if (!model->BSIM4v7ndepGiven && model->BSIM4v7gamma1Given) + { T0 = pParam->BSIM4v7gamma1 * model->BSIM4v7coxe; + pParam->BSIM4v7ndep = 3.01248e22 * T0 * T0; } - pParam->BSIM4phi = Vtm0 * log(pParam->BSIM4ndep / ni) - + pParam->BSIM4phin + 0.4; + pParam->BSIM4v7phi = Vtm0 * log(pParam->BSIM4v7ndep / ni) + + pParam->BSIM4v7phin + 0.4; - pParam->BSIM4sqrtPhi = sqrt(pParam->BSIM4phi); - pParam->BSIM4phis3 = pParam->BSIM4sqrtPhi * pParam->BSIM4phi; + pParam->BSIM4v7sqrtPhi = sqrt(pParam->BSIM4v7phi); + pParam->BSIM4v7phis3 = pParam->BSIM4v7sqrtPhi * pParam->BSIM4v7phi; - pParam->BSIM4Xdep0 = sqrt(2.0 * epssub / (Charge_q - * pParam->BSIM4ndep * 1.0e6)) - * pParam->BSIM4sqrtPhi; - pParam->BSIM4sqrtXdep0 = sqrt(pParam->BSIM4Xdep0); + pParam->BSIM4v7Xdep0 = sqrt(2.0 * epssub / (Charge_q + * pParam->BSIM4v7ndep * 1.0e6)) + * pParam->BSIM4v7sqrtPhi; + pParam->BSIM4v7sqrtXdep0 = sqrt(pParam->BSIM4v7Xdep0); - if(model->BSIM4mtrlMod == 0) - pParam->BSIM4litl = sqrt(3.0 * 3.9 / epsrox * pParam->BSIM4xj * toxe); + if(model->BSIM4v7mtrlMod == 0) + pParam->BSIM4v7litl = sqrt(3.0 * 3.9 / epsrox * pParam->BSIM4v7xj * toxe); else - pParam->BSIM4litl = sqrt(model->BSIM4epsrsub/epsrox * pParam->BSIM4xj * toxe); + pParam->BSIM4v7litl = sqrt(model->BSIM4v7epsrsub/epsrox * pParam->BSIM4v7xj * toxe); - pParam->BSIM4vbi = Vtm0 * log(pParam->BSIM4nsd - * pParam->BSIM4ndep / (ni * ni)); + pParam->BSIM4v7vbi = Vtm0 * log(pParam->BSIM4v7nsd + * pParam->BSIM4v7ndep / (ni * ni)); - if (model->BSIM4mtrlMod == 0) + if (model->BSIM4v7mtrlMod == 0) { - if (pParam->BSIM4ngate > 0.0) - { pParam->BSIM4vfbsd = Vtm0 * log(pParam->BSIM4ngate - / pParam->BSIM4nsd); + if (pParam->BSIM4v7ngate > 0.0) + { pParam->BSIM4v7vfbsd = Vtm0 * log(pParam->BSIM4v7ngate + / pParam->BSIM4v7nsd); } else - pParam->BSIM4vfbsd = 0.0; + pParam->BSIM4v7vfbsd = 0.0; } else { - T0 = Vtm0 * log(pParam->BSIM4nsd/ni); + T0 = Vtm0 * log(pParam->BSIM4v7nsd/ni); T1 = 0.5 * Eg0; if(T0 > T1) T0 = T1; - T2 = model->BSIM4easub + T1 - model->BSIM4type * T0; - pParam->BSIM4vfbsd = model->BSIM4phig - T2; + T2 = model->BSIM4v7easub + T1 - model->BSIM4v7type * T0; + pParam->BSIM4v7vfbsd = model->BSIM4v7phig - T2; } - pParam->BSIM4cdep0 = sqrt(Charge_q * epssub - * pParam->BSIM4ndep * 1.0e6 / 2.0 - / pParam->BSIM4phi); + pParam->BSIM4v7cdep0 = sqrt(Charge_q * epssub + * pParam->BSIM4v7ndep * 1.0e6 / 2.0 + / pParam->BSIM4v7phi); - pParam->BSIM4ToxRatio = exp(pParam->BSIM4ntox - * log(model->BSIM4toxref / toxe)) + pParam->BSIM4v7ToxRatio = exp(pParam->BSIM4v7ntox + * log(model->BSIM4v7toxref / toxe)) / toxe / toxe; - pParam->BSIM4ToxRatioEdge = exp(pParam->BSIM4ntox - * log(model->BSIM4toxref - / (toxe * pParam->BSIM4poxedge))) + pParam->BSIM4v7ToxRatioEdge = exp(pParam->BSIM4v7ntox + * log(model->BSIM4v7toxref + / (toxe * pParam->BSIM4v7poxedge))) / toxe / toxe - / pParam->BSIM4poxedge / pParam->BSIM4poxedge; - pParam->BSIM4Aechvb = (model->BSIM4type == NMOS) ? 4.97232e-7 : 3.42537e-7; - pParam->BSIM4Bechvb = (model->BSIM4type == NMOS) ? 7.45669e11 : 1.16645e12; - pParam->BSIM4AechvbEdgeS = pParam->BSIM4Aechvb * pParam->BSIM4weff - * model->BSIM4dlcig * pParam->BSIM4ToxRatioEdge; - pParam->BSIM4AechvbEdgeD = pParam->BSIM4Aechvb * pParam->BSIM4weff - * model->BSIM4dlcigd * pParam->BSIM4ToxRatioEdge; - pParam->BSIM4BechvbEdge = -pParam->BSIM4Bechvb - * toxe * pParam->BSIM4poxedge; - pParam->BSIM4Aechvb *= pParam->BSIM4weff * pParam->BSIM4leff - * pParam->BSIM4ToxRatio; - pParam->BSIM4Bechvb *= -toxe; + / pParam->BSIM4v7poxedge / pParam->BSIM4v7poxedge; + pParam->BSIM4v7Aechvb = (model->BSIM4v7type == NMOS) ? 4.97232e-7 : 3.42537e-7; + pParam->BSIM4v7Bechvb = (model->BSIM4v7type == NMOS) ? 7.45669e11 : 1.16645e12; + pParam->BSIM4v7AechvbEdgeS = pParam->BSIM4v7Aechvb * pParam->BSIM4v7weff + * model->BSIM4v7dlcig * pParam->BSIM4v7ToxRatioEdge; + pParam->BSIM4v7AechvbEdgeD = pParam->BSIM4v7Aechvb * pParam->BSIM4v7weff + * model->BSIM4v7dlcigd * pParam->BSIM4v7ToxRatioEdge; + pParam->BSIM4v7BechvbEdge = -pParam->BSIM4v7Bechvb + * toxe * pParam->BSIM4v7poxedge; + pParam->BSIM4v7Aechvb *= pParam->BSIM4v7weff * pParam->BSIM4v7leff + * pParam->BSIM4v7ToxRatio; + pParam->BSIM4v7Bechvb *= -toxe; - pParam->BSIM4mstar = 0.5 + atan(pParam->BSIM4minv) / PI; - pParam->BSIM4mstarcv = 0.5 + atan(pParam->BSIM4minvcv) / PI; - pParam->BSIM4voffcbn = pParam->BSIM4voff + model->BSIM4voffl / pParam->BSIM4leff; - pParam->BSIM4voffcbncv = pParam->BSIM4voffcv + model->BSIM4voffcvl / pParam->BSIM4leff; + pParam->BSIM4v7mstar = 0.5 + atan(pParam->BSIM4v7minv) / PI; + pParam->BSIM4v7mstarcv = 0.5 + atan(pParam->BSIM4v7minvcv) / PI; + pParam->BSIM4v7voffcbn = pParam->BSIM4v7voff + model->BSIM4v7voffl / pParam->BSIM4v7leff; + pParam->BSIM4v7voffcbncv = pParam->BSIM4v7voffcv + model->BSIM4v7voffcvl / pParam->BSIM4v7leff; - pParam->BSIM4ldeb = sqrt(epssub * Vtm0 / (Charge_q - * pParam->BSIM4ndep * 1.0e6)) / 3.0; - pParam->BSIM4acde *= pow((pParam->BSIM4ndep / 2.0e16), -0.25); + pParam->BSIM4v7ldeb = sqrt(epssub * Vtm0 / (Charge_q + * pParam->BSIM4v7ndep * 1.0e6)) / 3.0; + pParam->BSIM4v7acde *= pow((pParam->BSIM4v7ndep / 2.0e16), -0.25); - if (model->BSIM4k1Given || model->BSIM4k2Given) - { if (!model->BSIM4k1Given) + if (model->BSIM4v7k1Given || model->BSIM4v7k2Given) + { if (!model->BSIM4v7k1Given) { if ((!ckt->CKTcurJob) || (ckt->CKTcurJob->JOBtype < 9)) /* don't print in sensitivity */ fprintf(stdout, "Warning: k1 should be specified with k2.\n"); - pParam->BSIM4k1 = 0.53; + pParam->BSIM4v7k1 = 0.53; } - if (!model->BSIM4k2Given) + if (!model->BSIM4v7k2Given) { if ((!ckt->CKTcurJob) || (ckt->CKTcurJob->JOBtype < 9)) /* don't print in sensitivity */ fprintf(stdout, "Warning: k2 should be specified with k1.\n"); - pParam->BSIM4k2 = -0.0186; + pParam->BSIM4v7k2 = -0.0186; } if ((!ckt->CKTcurJob) || (ckt->CKTcurJob->JOBtype < 9)) { /* don't print in sensitivity */ - if (model->BSIM4nsubGiven) + if (model->BSIM4v7nsubGiven) fprintf(stdout, "Warning: nsub is ignored because k1 or k2 is given.\n"); - if (model->BSIM4xtGiven) + if (model->BSIM4v7xtGiven) fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n"); - if (model->BSIM4vbxGiven) + if (model->BSIM4v7vbxGiven) fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n"); - if (model->BSIM4gamma1Given) + if (model->BSIM4v7gamma1Given) fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n"); - if (model->BSIM4gamma2Given) + if (model->BSIM4v7gamma2Given) fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n"); } } else - { if (!model->BSIM4vbxGiven) - pParam->BSIM4vbx = pParam->BSIM4phi - 7.7348e-4 - * pParam->BSIM4ndep - * pParam->BSIM4xt * pParam->BSIM4xt; - if (pParam->BSIM4vbx > 0.0) - pParam->BSIM4vbx = -pParam->BSIM4vbx; - if (pParam->BSIM4vbm > 0.0) - pParam->BSIM4vbm = -pParam->BSIM4vbm; + { if (!model->BSIM4v7vbxGiven) + pParam->BSIM4v7vbx = pParam->BSIM4v7phi - 7.7348e-4 + * pParam->BSIM4v7ndep + * pParam->BSIM4v7xt * pParam->BSIM4v7xt; + if (pParam->BSIM4v7vbx > 0.0) + pParam->BSIM4v7vbx = -pParam->BSIM4v7vbx; + if (pParam->BSIM4v7vbm > 0.0) + pParam->BSIM4v7vbm = -pParam->BSIM4v7vbm; - if (!model->BSIM4gamma1Given) - pParam->BSIM4gamma1 = 5.753e-12 - * sqrt(pParam->BSIM4ndep) - / model->BSIM4coxe; - if (!model->BSIM4gamma2Given) - pParam->BSIM4gamma2 = 5.753e-12 - * sqrt(pParam->BSIM4nsub) - / model->BSIM4coxe; + if (!model->BSIM4v7gamma1Given) + pParam->BSIM4v7gamma1 = 5.753e-12 + * sqrt(pParam->BSIM4v7ndep) + / model->BSIM4v7coxe; + if (!model->BSIM4v7gamma2Given) + pParam->BSIM4v7gamma2 = 5.753e-12 + * sqrt(pParam->BSIM4v7nsub) + / model->BSIM4v7coxe; - T0 = pParam->BSIM4gamma1 - pParam->BSIM4gamma2; - T1 = sqrt(pParam->BSIM4phi - pParam->BSIM4vbx) - - pParam->BSIM4sqrtPhi; - T2 = sqrt(pParam->BSIM4phi * (pParam->BSIM4phi - - pParam->BSIM4vbm)) - pParam->BSIM4phi; - pParam->BSIM4k2 = T0 * T1 / (2.0 * T2 + pParam->BSIM4vbm); - pParam->BSIM4k1 = pParam->BSIM4gamma2 - 2.0 - * pParam->BSIM4k2 * sqrt(pParam->BSIM4phi - - pParam->BSIM4vbm); + T0 = pParam->BSIM4v7gamma1 - pParam->BSIM4v7gamma2; + T1 = sqrt(pParam->BSIM4v7phi - pParam->BSIM4v7vbx) + - pParam->BSIM4v7sqrtPhi; + T2 = sqrt(pParam->BSIM4v7phi * (pParam->BSIM4v7phi + - pParam->BSIM4v7vbm)) - pParam->BSIM4v7phi; + pParam->BSIM4v7k2 = T0 * T1 / (2.0 * T2 + pParam->BSIM4v7vbm); + pParam->BSIM4v7k1 = pParam->BSIM4v7gamma2 - 2.0 + * pParam->BSIM4v7k2 * sqrt(pParam->BSIM4v7phi + - pParam->BSIM4v7vbm); } - if (!model->BSIM4vfbGiven) + if (!model->BSIM4v7vfbGiven) { - if (model->BSIM4vth0Given) - { pParam->BSIM4vfb = model->BSIM4type * pParam->BSIM4vth0 - - pParam->BSIM4phi - pParam->BSIM4k1 - * pParam->BSIM4sqrtPhi; + if (model->BSIM4v7vth0Given) + { pParam->BSIM4v7vfb = model->BSIM4v7type * pParam->BSIM4v7vth0 + - pParam->BSIM4v7phi - pParam->BSIM4v7k1 + * pParam->BSIM4v7sqrtPhi; } else { - if ((model->BSIM4mtrlMod) && (model->BSIM4phigGiven) && - (model->BSIM4nsubGiven)) + if ((model->BSIM4v7mtrlMod) && (model->BSIM4v7phigGiven) && + (model->BSIM4v7nsubGiven)) { - T0 = Vtm0 * log(pParam->BSIM4nsub/ni); + T0 = Vtm0 * log(pParam->BSIM4v7nsub/ni); T1 = 0.5 * Eg0; if(T0 > T1) T0 = T1; - T2 = model->BSIM4easub + T1 + model->BSIM4type * T0; - pParam->BSIM4vfb = model->BSIM4phig - T2; + T2 = model->BSIM4v7easub + T1 + model->BSIM4v7type * T0; + pParam->BSIM4v7vfb = model->BSIM4v7phig - T2; } else { - pParam->BSIM4vfb = -1.0; + pParam->BSIM4v7vfb = -1.0; } } } - if (!model->BSIM4vth0Given) - { pParam->BSIM4vth0 = model->BSIM4type * (pParam->BSIM4vfb - + pParam->BSIM4phi + pParam->BSIM4k1 - * pParam->BSIM4sqrtPhi); + if (!model->BSIM4v7vth0Given) + { pParam->BSIM4v7vth0 = model->BSIM4v7type * (pParam->BSIM4v7vfb + + pParam->BSIM4v7phi + pParam->BSIM4v7k1 + * pParam->BSIM4v7sqrtPhi); } - pParam->BSIM4k1ox = pParam->BSIM4k1 * toxe - / model->BSIM4toxm; + pParam->BSIM4v7k1ox = pParam->BSIM4v7k1 * toxe + / model->BSIM4v7toxm; - tmp = sqrt(epssub / (epsrox * EPS0) * toxe * pParam->BSIM4Xdep0); - T0 = pParam->BSIM4dsub * pParam->BSIM4leff / tmp; + tmp = sqrt(epssub / (epsrox * EPS0) * toxe * pParam->BSIM4v7Xdep0); + T0 = pParam->BSIM4v7dsub * pParam->BSIM4v7leff / tmp; if (T0 < EXP_THRESHOLD) { T1 = exp(T0); T2 = T1 - 1.0; T3 = T2 * T2; T4 = T3 + 2.0 * T1 * MIN_EXP; - pParam->BSIM4theta0vb0 = T1 / T4; + pParam->BSIM4v7theta0vb0 = T1 / T4; } else - pParam->BSIM4theta0vb0 = 1.0 / (MAX_EXP - 2.0); + pParam->BSIM4v7theta0vb0 = 1.0 / (MAX_EXP - 2.0); - T0 = pParam->BSIM4drout * pParam->BSIM4leff / tmp; + T0 = pParam->BSIM4v7drout * pParam->BSIM4v7leff / tmp; if (T0 < EXP_THRESHOLD) { T1 = exp(T0); T2 = T1 - 1.0; @@ -1465,15 +1465,15 @@ int Size_Not_Found, i; } else T5 = 1.0 / (MAX_EXP - 2.0); /* 3.0 * MIN_EXP omitted */ - pParam->BSIM4thetaRout = pParam->BSIM4pdibl1 * T5 - + pParam->BSIM4pdibl2; + pParam->BSIM4v7thetaRout = pParam->BSIM4v7pdibl1 * T5 + + pParam->BSIM4v7pdibl2; - tmp = sqrt(pParam->BSIM4Xdep0); - tmp1 = pParam->BSIM4vbi - pParam->BSIM4phi; - tmp2 = model->BSIM4factor1 * tmp; + tmp = sqrt(pParam->BSIM4v7Xdep0); + tmp1 = pParam->BSIM4v7vbi - pParam->BSIM4v7phi; + tmp2 = model->BSIM4v7factor1 * tmp; - T0 = pParam->BSIM4dvt1w * pParam->BSIM4weff - * pParam->BSIM4leff / tmp2; + T0 = pParam->BSIM4v7dvt1w * pParam->BSIM4v7weff + * pParam->BSIM4v7leff / tmp2; if (T0 < EXP_THRESHOLD) { T1 = exp(T0); T2 = T1 - 1.0; @@ -1483,10 +1483,10 @@ int Size_Not_Found, i; } else T8 = 1.0 / (MAX_EXP - 2.0); - T0 = pParam->BSIM4dvt0w * T8; + T0 = pParam->BSIM4v7dvt0w * T8; T8 = T0 * tmp1; - T0 = pParam->BSIM4dvt1 * pParam->BSIM4leff / tmp2; + T0 = pParam->BSIM4v7dvt1 * pParam->BSIM4v7leff / tmp2; if (T0 < EXP_THRESHOLD) { T1 = exp(T0); T2 = T1 - 1.0; @@ -1496,290 +1496,290 @@ int Size_Not_Found, i; } else T9 = 1.0 / (MAX_EXP - 2.0); - T9 = pParam->BSIM4dvt0 * T9 * tmp1; + T9 = pParam->BSIM4v7dvt0 * T9 * tmp1; - T4 = toxe * pParam->BSIM4phi - / (pParam->BSIM4weff + pParam->BSIM4w0); + T4 = toxe * pParam->BSIM4v7phi + / (pParam->BSIM4v7weff + pParam->BSIM4v7w0); - T0 = sqrt(1.0 + pParam->BSIM4lpe0 / pParam->BSIM4leff); - if((model->BSIM4tempMod == 1) || (model->BSIM4tempMod == 0)) - T3 = (pParam->BSIM4kt1 + pParam->BSIM4kt1l / pParam->BSIM4leff) + T0 = sqrt(1.0 + pParam->BSIM4v7lpe0 / pParam->BSIM4v7leff); + if((model->BSIM4v7tempMod == 1) || (model->BSIM4v7tempMod == 0)) + T3 = (pParam->BSIM4v7kt1 + pParam->BSIM4v7kt1l / pParam->BSIM4v7leff) * (TRatio - 1.0); - if((model->BSIM4tempMod == 2)||(model->BSIM4tempMod == 3)) - T3 = - pParam->BSIM4kt1 * (TRatio - 1.0); + if((model->BSIM4v7tempMod == 2)||(model->BSIM4v7tempMod == 3)) + T3 = - pParam->BSIM4v7kt1 * (TRatio - 1.0); - T5 = pParam->BSIM4k1ox * (T0 - 1.0) * pParam->BSIM4sqrtPhi + T5 = pParam->BSIM4v7k1ox * (T0 - 1.0) * pParam->BSIM4v7sqrtPhi + T3; - pParam->BSIM4vfbzbfactor = - T8 - T9 + pParam->BSIM4k3 * T4 + T5 - - pParam->BSIM4phi - pParam->BSIM4k1 * pParam->BSIM4sqrtPhi; + pParam->BSIM4v7vfbzbfactor = - T8 - T9 + pParam->BSIM4v7k3 * T4 + T5 + - pParam->BSIM4v7phi - pParam->BSIM4v7k1 * pParam->BSIM4v7sqrtPhi; /* stress effect */ - wlod = model->BSIM4wlod; - if (model->BSIM4wlod < 0.0) - { fprintf(stderr, "Warning: WLOD = %g is less than 0. 0.0 is used\n",model->BSIM4wlod); + wlod = model->BSIM4v7wlod; + if (model->BSIM4v7wlod < 0.0) + { fprintf(stderr, "Warning: WLOD = %g is less than 0. 0.0 is used\n",model->BSIM4v7wlod); wlod = 0.0; } - T0 = pow(Lnew, model->BSIM4llodku0); + T0 = pow(Lnew, model->BSIM4v7llodku0); W_tmp = Wnew + wlod; - T1 = pow(W_tmp, model->BSIM4wlodku0); - tmp1 = model->BSIM4lku0 / T0 + model->BSIM4wku0 / T1 - + model->BSIM4pku0 / (T0 * T1); - pParam->BSIM4ku0 = 1.0 + tmp1; + T1 = pow(W_tmp, model->BSIM4v7wlodku0); + tmp1 = model->BSIM4v7lku0 / T0 + model->BSIM4v7wku0 / T1 + + model->BSIM4v7pku0 / (T0 * T1); + pParam->BSIM4v7ku0 = 1.0 + tmp1; - T0 = pow(Lnew, model->BSIM4llodvth); - T1 = pow(W_tmp, model->BSIM4wlodvth); - tmp1 = model->BSIM4lkvth0 / T0 + model->BSIM4wkvth0 / T1 - + model->BSIM4pkvth0 / (T0 * T1); - pParam->BSIM4kvth0 = 1.0 + tmp1; - pParam->BSIM4kvth0 = sqrt(pParam->BSIM4kvth0*pParam->BSIM4kvth0 + DELTA); + T0 = pow(Lnew, model->BSIM4v7llodvth); + T1 = pow(W_tmp, model->BSIM4v7wlodvth); + tmp1 = model->BSIM4v7lkvth0 / T0 + model->BSIM4v7wkvth0 / T1 + + model->BSIM4v7pkvth0 / (T0 * T1); + pParam->BSIM4v7kvth0 = 1.0 + tmp1; + pParam->BSIM4v7kvth0 = sqrt(pParam->BSIM4v7kvth0*pParam->BSIM4v7kvth0 + DELTA); T0 = (TRatio - 1.0); - pParam->BSIM4ku0temp = pParam->BSIM4ku0 * (1.0 + model->BSIM4tku0 *T0) + DELTA; + pParam->BSIM4v7ku0temp = pParam->BSIM4v7ku0 * (1.0 + model->BSIM4v7tku0 *T0) + DELTA; - Inv_saref = 1.0/(model->BSIM4saref + 0.5*Ldrn); - Inv_sbref = 1.0/(model->BSIM4sbref + 0.5*Ldrn); - pParam->BSIM4inv_od_ref = Inv_saref + Inv_sbref; - pParam->BSIM4rho_ref = model->BSIM4ku0 / pParam->BSIM4ku0temp * pParam->BSIM4inv_od_ref; + Inv_saref = 1.0/(model->BSIM4v7saref + 0.5*Ldrn); + Inv_sbref = 1.0/(model->BSIM4v7sbref + 0.5*Ldrn); + pParam->BSIM4v7inv_od_ref = Inv_saref + Inv_sbref; + pParam->BSIM4v7rho_ref = model->BSIM4v7ku0 / pParam->BSIM4v7ku0temp * pParam->BSIM4v7inv_od_ref; } /* End of SizeNotFound */ /* stress effect */ - if( (here->BSIM4sa > 0.0) && (here->BSIM4sb > 0.0) && - ((here->BSIM4nf == 1.0) || ((here->BSIM4nf > 1.0) && (here->BSIM4sd > 0.0))) ) + if( (here->BSIM4v7sa > 0.0) && (here->BSIM4v7sb > 0.0) && + ((here->BSIM4v7nf == 1.0) || ((here->BSIM4v7nf > 1.0) && (here->BSIM4v7sd > 0.0))) ) { Inv_sa = 0; Inv_sb = 0; - kvsat = model->BSIM4kvsat; - if (model->BSIM4kvsat < -1.0 ) - { fprintf(stderr, "Warning: KVSAT = %g is too small; -1.0 is used.\n",model->BSIM4kvsat); + kvsat = model->BSIM4v7kvsat; + if (model->BSIM4v7kvsat < -1.0 ) + { fprintf(stderr, "Warning: KVSAT = %g is too small; -1.0 is used.\n",model->BSIM4v7kvsat); kvsat = -1.0; } - if (model->BSIM4kvsat > 1.0) - { fprintf(stderr, "Warning: KVSAT = %g is too big; 1.0 is used.\n",model->BSIM4kvsat); + if (model->BSIM4v7kvsat > 1.0) + { fprintf(stderr, "Warning: KVSAT = %g is too big; 1.0 is used.\n",model->BSIM4v7kvsat); kvsat = 1.0; } - for(i = 0; i < here->BSIM4nf; i++){ - T0 = 1.0 / here->BSIM4nf / (here->BSIM4sa + 0.5*Ldrn + i * (here->BSIM4sd +Ldrn)); - T1 = 1.0 / here->BSIM4nf / (here->BSIM4sb + 0.5*Ldrn + i * (here->BSIM4sd +Ldrn)); + for(i = 0; i < here->BSIM4v7nf; i++){ + T0 = 1.0 / here->BSIM4v7nf / (here->BSIM4v7sa + 0.5*Ldrn + i * (here->BSIM4v7sd +Ldrn)); + T1 = 1.0 / here->BSIM4v7nf / (here->BSIM4v7sb + 0.5*Ldrn + i * (here->BSIM4v7sd +Ldrn)); Inv_sa += T0; Inv_sb += T1; } Inv_ODeff = Inv_sa + Inv_sb; - rho = model->BSIM4ku0 / pParam->BSIM4ku0temp * Inv_ODeff; - T0 = (1.0 + rho)/(1.0 + pParam->BSIM4rho_ref); - here->BSIM4u0temp = pParam->BSIM4u0temp * T0; + rho = model->BSIM4v7ku0 / pParam->BSIM4v7ku0temp * Inv_ODeff; + T0 = (1.0 + rho)/(1.0 + pParam->BSIM4v7rho_ref); + here->BSIM4v7u0temp = pParam->BSIM4v7u0temp * T0; - T1 = (1.0 + kvsat * rho)/(1.0 + kvsat * pParam->BSIM4rho_ref); - here->BSIM4vsattemp = pParam->BSIM4vsattemp * T1; + T1 = (1.0 + kvsat * rho)/(1.0 + kvsat * pParam->BSIM4v7rho_ref); + here->BSIM4v7vsattemp = pParam->BSIM4v7vsattemp * T1; - OD_offset = Inv_ODeff - pParam->BSIM4inv_od_ref; - dvth0_lod = model->BSIM4kvth0 / pParam->BSIM4kvth0 * OD_offset; - dk2_lod = model->BSIM4stk2 / pow(pParam->BSIM4kvth0, model->BSIM4lodk2) * + OD_offset = Inv_ODeff - pParam->BSIM4v7inv_od_ref; + dvth0_lod = model->BSIM4v7kvth0 / pParam->BSIM4v7kvth0 * OD_offset; + dk2_lod = model->BSIM4v7stk2 / pow(pParam->BSIM4v7kvth0, model->BSIM4v7lodk2) * OD_offset; - deta0_lod = model->BSIM4steta0 / pow(pParam->BSIM4kvth0, model->BSIM4lodeta0) * + deta0_lod = model->BSIM4v7steta0 / pow(pParam->BSIM4v7kvth0, model->BSIM4v7lodeta0) * OD_offset; - here->BSIM4vth0 = pParam->BSIM4vth0 + dvth0_lod; + here->BSIM4v7vth0 = pParam->BSIM4v7vth0 + dvth0_lod; - here->BSIM4eta0 = pParam->BSIM4eta0 + deta0_lod; - here->BSIM4k2 = pParam->BSIM4k2 + dk2_lod; + here->BSIM4v7eta0 = pParam->BSIM4v7eta0 + deta0_lod; + here->BSIM4v7k2 = pParam->BSIM4v7k2 + dk2_lod; } else { - here->BSIM4u0temp = pParam->BSIM4u0temp; - here->BSIM4vth0 = pParam->BSIM4vth0; - here->BSIM4vsattemp = pParam->BSIM4vsattemp; - here->BSIM4eta0 = pParam->BSIM4eta0; - here->BSIM4k2 = pParam->BSIM4k2; + here->BSIM4v7u0temp = pParam->BSIM4v7u0temp; + here->BSIM4v7vth0 = pParam->BSIM4v7vth0; + here->BSIM4v7vsattemp = pParam->BSIM4v7vsattemp; + here->BSIM4v7eta0 = pParam->BSIM4v7eta0; + here->BSIM4v7k2 = pParam->BSIM4v7k2; } /* Well Proximity Effect */ - if (model->BSIM4wpemod) - { if( (!here->BSIM4scaGiven) && (!here->BSIM4scbGiven) && (!here->BSIM4sccGiven) ) - { if((here->BSIM4scGiven) && (here->BSIM4sc > 0.0) ) - { T1 = here->BSIM4sc + Wdrn; - T2 = 1.0 / model->BSIM4scref; - here->BSIM4sca = model->BSIM4scref * model->BSIM4scref - / (here->BSIM4sc * T1); - here->BSIM4scb = ( (0.1 * here->BSIM4sc + 0.01 * model->BSIM4scref) - * exp(-10.0 * here->BSIM4sc * T2) - - (0.1 * T1 + 0.01 * model->BSIM4scref) + if (model->BSIM4v7wpemod) + { if( (!here->BSIM4v7scaGiven) && (!here->BSIM4v7scbGiven) && (!here->BSIM4v7sccGiven) ) + { if((here->BSIM4v7scGiven) && (here->BSIM4v7sc > 0.0) ) + { T1 = here->BSIM4v7sc + Wdrn; + T2 = 1.0 / model->BSIM4v7scref; + here->BSIM4v7sca = model->BSIM4v7scref * model->BSIM4v7scref + / (here->BSIM4v7sc * T1); + here->BSIM4v7scb = ( (0.1 * here->BSIM4v7sc + 0.01 * model->BSIM4v7scref) + * exp(-10.0 * here->BSIM4v7sc * T2) + - (0.1 * T1 + 0.01 * model->BSIM4v7scref) * exp(-10.0 * T1 * T2) ) / Wdrn; - here->BSIM4scc = ( (0.05 * here->BSIM4sc + 0.0025 * model->BSIM4scref) - * exp(-20.0 * here->BSIM4sc * T2) - - (0.05 * T1 + 0.0025 * model->BSIM4scref) + here->BSIM4v7scc = ( (0.05 * here->BSIM4v7sc + 0.0025 * model->BSIM4v7scref) + * exp(-20.0 * here->BSIM4v7sc * T2) + - (0.05 * T1 + 0.0025 * model->BSIM4v7scref) * exp(-20.0 * T1 * T2) ) / Wdrn; } else { fprintf(stderr, "Warning: No WPE as none of SCA, SCB, SCC, SC is given and/or SC not positive.\n"); } } - if (here->BSIM4sca < 0.0) + if (here->BSIM4v7sca < 0.0) { - printf("Warning: SCA = %g is negative. Set to 0.0.\n", here->BSIM4sca); - here->BSIM4sca = 0.0; + printf("Warning: SCA = %g is negative. Set to 0.0.\n", here->BSIM4v7sca); + here->BSIM4v7sca = 0.0; } - if (here->BSIM4scb < 0.0) + if (here->BSIM4v7scb < 0.0) { - printf("Warning: SCB = %g is negative. Set to 0.0.\n", here->BSIM4scb); - here->BSIM4scb = 0.0; + printf("Warning: SCB = %g is negative. Set to 0.0.\n", here->BSIM4v7scb); + here->BSIM4v7scb = 0.0; } - if (here->BSIM4scc < 0.0) + if (here->BSIM4v7scc < 0.0) { - printf("Warning: SCC = %g is negative. Set to 0.0.\n", here->BSIM4scc); - here->BSIM4scc = 0.0; + printf("Warning: SCC = %g is negative. Set to 0.0.\n", here->BSIM4v7scc); + here->BSIM4v7scc = 0.0; } - if (here->BSIM4sc < 0.0) + if (here->BSIM4v7sc < 0.0) { - printf("Warning: SC = %g is negative. Set to 0.0.\n", here->BSIM4sc); - here->BSIM4sc = 0.0; + printf("Warning: SC = %g is negative. Set to 0.0.\n", here->BSIM4v7sc); + here->BSIM4v7sc = 0.0; } /*4.6.2*/ - sceff = here->BSIM4sca + model->BSIM4web * here->BSIM4scb - + model->BSIM4wec * here->BSIM4scc; - here->BSIM4vth0 += pParam->BSIM4kvth0we * sceff; - here->BSIM4k2 += pParam->BSIM4k2we * sceff; - T3 = 1.0 + pParam->BSIM4ku0we * sceff; + sceff = here->BSIM4v7sca + model->BSIM4v7web * here->BSIM4v7scb + + model->BSIM4v7wec * here->BSIM4v7scc; + here->BSIM4v7vth0 += pParam->BSIM4v7kvth0we * sceff; + here->BSIM4v7k2 += pParam->BSIM4v7k2we * sceff; + T3 = 1.0 + pParam->BSIM4v7ku0we * sceff; if (T3 <= 0.0) { T3 = 0.0; - fprintf(stderr, "Warning: ku0we = %g is negatively too high. Negative mobility! \n", pParam->BSIM4ku0we); + fprintf(stderr, "Warning: ku0we = %g is negatively too high. Negative mobility! \n", pParam->BSIM4v7ku0we); } - here->BSIM4u0temp *= T3; + here->BSIM4v7u0temp *= T3; } /* adding delvto */ - here->BSIM4vth0 += here->BSIM4delvto; - here->BSIM4vfb = pParam->BSIM4vfb + model->BSIM4type * here->BSIM4delvto; + here->BSIM4v7vth0 += here->BSIM4v7delvto; + here->BSIM4v7vfb = pParam->BSIM4v7vfb + model->BSIM4v7type * here->BSIM4v7delvto; /* Instance variables calculation */ - T3 = model->BSIM4type * here->BSIM4vth0 - - here->BSIM4vfb - pParam->BSIM4phi; + T3 = model->BSIM4v7type * here->BSIM4v7vth0 + - here->BSIM4v7vfb - pParam->BSIM4v7phi; T4 = T3 + T3; T5 = 2.5 * T3; - here->BSIM4vtfbphi1 = (model->BSIM4type == NMOS) ? T4 : T5; - if (here->BSIM4vtfbphi1 < 0.0) - here->BSIM4vtfbphi1 = 0.0; + here->BSIM4v7vtfbphi1 = (model->BSIM4v7type == NMOS) ? T4 : T5; + if (here->BSIM4v7vtfbphi1 < 0.0) + here->BSIM4v7vtfbphi1 = 0.0; - here->BSIM4vtfbphi2 = 4.0 * T3; - if (here->BSIM4vtfbphi2 < 0.0) - here->BSIM4vtfbphi2 = 0.0; + here->BSIM4v7vtfbphi2 = 4.0 * T3; + if (here->BSIM4v7vtfbphi2 < 0.0) + here->BSIM4v7vtfbphi2 = 0.0; - if (here->BSIM4k2 < 0.0) - { T0 = 0.5 * pParam->BSIM4k1 / here->BSIM4k2; - here->BSIM4vbsc = 0.9 * (pParam->BSIM4phi - T0 * T0); - if (here->BSIM4vbsc > -3.0) - here->BSIM4vbsc = -3.0; - else if (here->BSIM4vbsc < -30.0) - here->BSIM4vbsc = -30.0; + if (here->BSIM4v7k2 < 0.0) + { T0 = 0.5 * pParam->BSIM4v7k1 / here->BSIM4v7k2; + here->BSIM4v7vbsc = 0.9 * (pParam->BSIM4v7phi - T0 * T0); + if (here->BSIM4v7vbsc > -3.0) + here->BSIM4v7vbsc = -3.0; + else if (here->BSIM4v7vbsc < -30.0) + here->BSIM4v7vbsc = -30.0; } else - here->BSIM4vbsc = -30.0; - if (here->BSIM4vbsc > pParam->BSIM4vbm) - here->BSIM4vbsc = pParam->BSIM4vbm; - here->BSIM4k2ox = here->BSIM4k2 * toxe - / model->BSIM4toxm; + here->BSIM4v7vbsc = -30.0; + if (here->BSIM4v7vbsc > pParam->BSIM4v7vbm) + here->BSIM4v7vbsc = pParam->BSIM4v7vbm; + here->BSIM4v7k2ox = here->BSIM4v7k2 * toxe + / model->BSIM4v7toxm; - here->BSIM4vfbzb = pParam->BSIM4vfbzbfactor - + model->BSIM4type * here->BSIM4vth0 ; + here->BSIM4v7vfbzb = pParam->BSIM4v7vfbzbfactor + + model->BSIM4v7type * here->BSIM4v7vth0 ; - here->BSIM4cgso = pParam->BSIM4cgso; - here->BSIM4cgdo = pParam->BSIM4cgdo; + here->BSIM4v7cgso = pParam->BSIM4v7cgso; + here->BSIM4v7cgdo = pParam->BSIM4v7cgdo; - lnl = log(pParam->BSIM4leff * 1.0e6); - lnw = log(pParam->BSIM4weff * 1.0e6); - lnnf = log(here->BSIM4nf); + lnl = log(pParam->BSIM4v7leff * 1.0e6); + lnw = log(pParam->BSIM4v7weff * 1.0e6); + lnnf = log(here->BSIM4v7nf); bodymode = 5; - if( ( !model->BSIM4rbps0Given) || - ( !model->BSIM4rbpd0Given) ) + if( ( !model->BSIM4v7rbps0Given) || + ( !model->BSIM4v7rbpd0Given) ) bodymode = 1; else - if( (!model->BSIM4rbsbx0Given && !model->BSIM4rbsby0Given) || - (!model->BSIM4rbdbx0Given && !model->BSIM4rbdby0Given) ) + if( (!model->BSIM4v7rbsbx0Given && !model->BSIM4v7rbsby0Given) || + (!model->BSIM4v7rbdbx0Given && !model->BSIM4v7rbdby0Given) ) bodymode = 3; - if(here->BSIM4rbodyMod == 2) + if(here->BSIM4v7rbodyMod == 2) { if (bodymode == 5) { - rbsbx = exp( log(model->BSIM4rbsbx0) + model->BSIM4rbsdbxl * lnl + - model->BSIM4rbsdbxw * lnw + model->BSIM4rbsdbxnf * lnnf ); - rbsby = exp( log(model->BSIM4rbsby0) + model->BSIM4rbsdbyl * lnl + - model->BSIM4rbsdbyw * lnw + model->BSIM4rbsdbynf * lnnf ); - here->BSIM4rbsb = rbsbx * rbsby / (rbsbx + rbsby); + rbsbx = exp( log(model->BSIM4v7rbsbx0) + model->BSIM4v7rbsdbxl * lnl + + model->BSIM4v7rbsdbxw * lnw + model->BSIM4v7rbsdbxnf * lnnf ); + rbsby = exp( log(model->BSIM4v7rbsby0) + model->BSIM4v7rbsdbyl * lnl + + model->BSIM4v7rbsdbyw * lnw + model->BSIM4v7rbsdbynf * lnnf ); + here->BSIM4v7rbsb = rbsbx * rbsby / (rbsbx + rbsby); - rbdbx = exp( log(model->BSIM4rbdbx0) + model->BSIM4rbsdbxl * lnl + - model->BSIM4rbsdbxw * lnw + model->BSIM4rbsdbxnf * lnnf ); - rbdby = exp( log(model->BSIM4rbdby0) + model->BSIM4rbsdbyl * lnl + - model->BSIM4rbsdbyw * lnw + model->BSIM4rbsdbynf * lnnf ); - here->BSIM4rbdb = rbdbx * rbdby / (rbdbx + rbdby); + rbdbx = exp( log(model->BSIM4v7rbdbx0) + model->BSIM4v7rbsdbxl * lnl + + model->BSIM4v7rbsdbxw * lnw + model->BSIM4v7rbsdbxnf * lnnf ); + rbdby = exp( log(model->BSIM4v7rbdby0) + model->BSIM4v7rbsdbyl * lnl + + model->BSIM4v7rbsdbyw * lnw + model->BSIM4v7rbsdbynf * lnnf ); + here->BSIM4v7rbdb = rbdbx * rbdby / (rbdbx + rbdby); } if ((bodymode == 3)|| (bodymode == 5)) { - here->BSIM4rbps = exp( log(model->BSIM4rbps0) + model->BSIM4rbpsl * lnl + - model->BSIM4rbpsw * lnw + model->BSIM4rbpsnf * lnnf ); - here->BSIM4rbpd = exp( log(model->BSIM4rbpd0) + model->BSIM4rbpdl * lnl + - model->BSIM4rbpdw * lnw + model->BSIM4rbpdnf * lnnf ); + here->BSIM4v7rbps = exp( log(model->BSIM4v7rbps0) + model->BSIM4v7rbpsl * lnl + + model->BSIM4v7rbpsw * lnw + model->BSIM4v7rbpsnf * lnnf ); + here->BSIM4v7rbpd = exp( log(model->BSIM4v7rbpd0) + model->BSIM4v7rbpdl * lnl + + model->BSIM4v7rbpdw * lnw + model->BSIM4v7rbpdnf * lnnf ); } - rbpbx = exp( log(model->BSIM4rbpbx0) + model->BSIM4rbpbxl * lnl + - model->BSIM4rbpbxw * lnw + model->BSIM4rbpbxnf * lnnf ); - rbpby = exp( log(model->BSIM4rbpby0) + model->BSIM4rbpbyl * lnl + - model->BSIM4rbpbyw * lnw + model->BSIM4rbpbynf * lnnf ); - here->BSIM4rbpb = rbpbx*rbpby/(rbpbx + rbpby); + rbpbx = exp( log(model->BSIM4v7rbpbx0) + model->BSIM4v7rbpbxl * lnl + + model->BSIM4v7rbpbxw * lnw + model->BSIM4v7rbpbxnf * lnnf ); + rbpby = exp( log(model->BSIM4v7rbpby0) + model->BSIM4v7rbpbyl * lnl + + model->BSIM4v7rbpbyw * lnw + model->BSIM4v7rbpbynf * lnnf ); + here->BSIM4v7rbpb = rbpbx*rbpby/(rbpbx + rbpby); } - if ((here->BSIM4rbodyMod == 1 ) || ((here->BSIM4rbodyMod == 2 ) && (bodymode == 5)) ) - { if (here->BSIM4rbdb < 1.0e-3) - here->BSIM4grbdb = 1.0e3; /* in mho */ + if ((here->BSIM4v7rbodyMod == 1 ) || ((here->BSIM4v7rbodyMod == 2 ) && (bodymode == 5)) ) + { if (here->BSIM4v7rbdb < 1.0e-3) + here->BSIM4v7grbdb = 1.0e3; /* in mho */ else - here->BSIM4grbdb = model->BSIM4gbmin + 1.0 / here->BSIM4rbdb; - if (here->BSIM4rbpb < 1.0e-3) - here->BSIM4grbpb = 1.0e3; + here->BSIM4v7grbdb = model->BSIM4v7gbmin + 1.0 / here->BSIM4v7rbdb; + if (here->BSIM4v7rbpb < 1.0e-3) + here->BSIM4v7grbpb = 1.0e3; else - here->BSIM4grbpb = model->BSIM4gbmin + 1.0 / here->BSIM4rbpb; - if (here->BSIM4rbps < 1.0e-3) - here->BSIM4grbps = 1.0e3; + here->BSIM4v7grbpb = model->BSIM4v7gbmin + 1.0 / here->BSIM4v7rbpb; + if (here->BSIM4v7rbps < 1.0e-3) + here->BSIM4v7grbps = 1.0e3; else - here->BSIM4grbps = model->BSIM4gbmin + 1.0 / here->BSIM4rbps; - if (here->BSIM4rbsb < 1.0e-3) - here->BSIM4grbsb = 1.0e3; + here->BSIM4v7grbps = model->BSIM4v7gbmin + 1.0 / here->BSIM4v7rbps; + if (here->BSIM4v7rbsb < 1.0e-3) + here->BSIM4v7grbsb = 1.0e3; else - here->BSIM4grbsb = model->BSIM4gbmin + 1.0 / here->BSIM4rbsb; - if (here->BSIM4rbpd < 1.0e-3) - here->BSIM4grbpd = 1.0e3; + here->BSIM4v7grbsb = model->BSIM4v7gbmin + 1.0 / here->BSIM4v7rbsb; + if (here->BSIM4v7rbpd < 1.0e-3) + here->BSIM4v7grbpd = 1.0e3; else - here->BSIM4grbpd = model->BSIM4gbmin + 1.0 / here->BSIM4rbpd; + here->BSIM4v7grbpd = model->BSIM4v7gbmin + 1.0 / here->BSIM4v7rbpd; } - if((here->BSIM4rbodyMod == 2) && (bodymode == 3)) + if((here->BSIM4v7rbodyMod == 2) && (bodymode == 3)) { - here->BSIM4grbdb = here->BSIM4grbsb = model->BSIM4gbmin; - if (here->BSIM4rbpb < 1.0e-3) - here->BSIM4grbpb = 1.0e3; + here->BSIM4v7grbdb = here->BSIM4v7grbsb = model->BSIM4v7gbmin; + if (here->BSIM4v7rbpb < 1.0e-3) + here->BSIM4v7grbpb = 1.0e3; else - here->BSIM4grbpb = model->BSIM4gbmin + 1.0 / here->BSIM4rbpb; - if (here->BSIM4rbps < 1.0e-3) - here->BSIM4grbps = 1.0e3; + here->BSIM4v7grbpb = model->BSIM4v7gbmin + 1.0 / here->BSIM4v7rbpb; + if (here->BSIM4v7rbps < 1.0e-3) + here->BSIM4v7grbps = 1.0e3; else - here->BSIM4grbps = model->BSIM4gbmin + 1.0 / here->BSIM4rbps; - if (here->BSIM4rbpd < 1.0e-3) - here->BSIM4grbpd = 1.0e3; + here->BSIM4v7grbps = model->BSIM4v7gbmin + 1.0 / here->BSIM4v7rbps; + if (here->BSIM4v7rbpd < 1.0e-3) + here->BSIM4v7grbpd = 1.0e3; else - here->BSIM4grbpd = model->BSIM4gbmin + 1.0 / here->BSIM4rbpd; + here->BSIM4v7grbpd = model->BSIM4v7gbmin + 1.0 / here->BSIM4v7rbpd; } - if((here->BSIM4rbodyMod == 2) && (bodymode == 1)) + if((here->BSIM4v7rbodyMod == 2) && (bodymode == 1)) { - here->BSIM4grbdb = here->BSIM4grbsb = model->BSIM4gbmin; - here->BSIM4grbps = here->BSIM4grbpd = 1.0e3; - if (here->BSIM4rbpb < 1.0e-3) - here->BSIM4grbpb = 1.0e3; + here->BSIM4v7grbdb = here->BSIM4v7grbsb = model->BSIM4v7gbmin; + here->BSIM4v7grbps = here->BSIM4v7grbpd = 1.0e3; + if (here->BSIM4v7rbpb < 1.0e-3) + here->BSIM4v7grbpb = 1.0e3; else - here->BSIM4grbpb = model->BSIM4gbmin + 1.0 / here->BSIM4rbpb; + here->BSIM4v7grbpb = model->BSIM4v7gbmin + 1.0 / here->BSIM4v7rbpb; } @@ -1787,351 +1787,351 @@ int Size_Not_Found, i; * Process geomertry dependent parasitics */ - here->BSIM4grgeltd = model->BSIM4rshg * (here->BSIM4xgw - + pParam->BSIM4weffCJ / 3.0 / here->BSIM4ngcon) / - (here->BSIM4ngcon * here->BSIM4nf * - (Lnew - model->BSIM4xgl)); - if (here->BSIM4grgeltd > 0.0) - here->BSIM4grgeltd = 1.0 / here->BSIM4grgeltd; + here->BSIM4v7grgeltd = model->BSIM4v7rshg * (here->BSIM4v7xgw + + pParam->BSIM4v7weffCJ / 3.0 / here->BSIM4v7ngcon) / + (here->BSIM4v7ngcon * here->BSIM4v7nf * + (Lnew - model->BSIM4v7xgl)); + if (here->BSIM4v7grgeltd > 0.0) + here->BSIM4v7grgeltd = 1.0 / here->BSIM4v7grgeltd; else - { here->BSIM4grgeltd = 1.0e3; /* mho */ - if (here->BSIM4rgateMod != 0) + { here->BSIM4v7grgeltd = 1.0e3; /* mho */ + if (here->BSIM4v7rgateMod != 0) printf("Warning: The gate conductance reset to 1.0e3 mho.\n"); } - DMCGeff = model->BSIM4dmcg - model->BSIM4dmcgt; - DMCIeff = model->BSIM4dmci; - DMDGeff = model->BSIM4dmdg - model->BSIM4dmcgt; + DMCGeff = model->BSIM4v7dmcg - model->BSIM4v7dmcgt; + DMCIeff = model->BSIM4v7dmci; + DMDGeff = model->BSIM4v7dmdg - model->BSIM4v7dmcgt; -/* if (here->BSIM4sourcePerimeterGiven) - { if (model->BSIM4perMod == 0) - here->BSIM4Pseff = here->BSIM4sourcePerimeter; +/* if (here->BSIM4v7sourcePerimeterGiven) + { if (model->BSIM4v7perMod == 0) + here->BSIM4v7Pseff = here->BSIM4v7sourcePerimeter; else - here->BSIM4Pseff = here->BSIM4sourcePerimeter - - pParam->BSIM4weffCJ * here->BSIM4nf; + here->BSIM4v7Pseff = here->BSIM4v7sourcePerimeter + - pParam->BSIM4v7weffCJ * here->BSIM4v7nf; } else - BSIM4PAeffGeo(here->BSIM4nf, here->BSIM4geoMod, here->BSIM4min, - pParam->BSIM4weffCJ, DMCGeff, DMCIeff, DMDGeff, - &(here->BSIM4Pseff), &dumPd, &dumAs, &dumAd); - if (here->BSIM4Pseff < 0.0) /4.6.2/ - here->BSIM4Pseff = 0.0; */ + BSIM4v7PAeffGeo(here->BSIM4v7nf, here->BSIM4v7geoMod, here->BSIM4v7min, + pParam->BSIM4v7weffCJ, DMCGeff, DMCIeff, DMDGeff, + &(here->BSIM4v7Pseff), &dumPd, &dumAs, &dumAd); + if (here->BSIM4v7Pseff < 0.0) /4.6.2/ + here->BSIM4v7Pseff = 0.0; */ /* New Diode Model v4.7*/ - if (here->BSIM4sourcePerimeterGiven) + if (here->BSIM4v7sourcePerimeterGiven) { /* given */ - if (here->BSIM4sourcePerimeter == 0.0) - here->BSIM4Pseff = 0.0; - else if (here->BSIM4sourcePerimeter < 0.0) + if (here->BSIM4v7sourcePerimeter == 0.0) + here->BSIM4v7Pseff = 0.0; + else if (here->BSIM4v7sourcePerimeter < 0.0) { printf("Warning: Source Perimeter is specified as negative, it is set to zero.\n"); - here->BSIM4Pseff = 0.0; + here->BSIM4v7Pseff = 0.0; } else { - if (model->BSIM4perMod == 0) - here->BSIM4Pseff = here->BSIM4sourcePerimeter; + if (model->BSIM4v7perMod == 0) + here->BSIM4v7Pseff = here->BSIM4v7sourcePerimeter; else - here->BSIM4Pseff = here->BSIM4sourcePerimeter - - pParam->BSIM4weffCJ * here->BSIM4nf; + here->BSIM4v7Pseff = here->BSIM4v7sourcePerimeter + - pParam->BSIM4v7weffCJ * here->BSIM4v7nf; } } else /* not given */ - BSIM4PAeffGeo(here->BSIM4nf, here->BSIM4geoMod, here->BSIM4min, - pParam->BSIM4weffCJ, DMCGeff, DMCIeff, DMDGeff, - &(here->BSIM4Pseff), &dumPd, &dumAs, &dumAd); + BSIM4v7PAeffGeo(here->BSIM4v7nf, here->BSIM4v7geoMod, here->BSIM4v7min, + pParam->BSIM4v7weffCJ, DMCGeff, DMCIeff, DMDGeff, + &(here->BSIM4v7Pseff), &dumPd, &dumAs, &dumAd); - if (here->BSIM4Pseff < 0.0){ /* v4.7 final check */ - here->BSIM4Pseff = 0.0; + if (here->BSIM4v7Pseff < 0.0){ /* v4.7 final check */ + here->BSIM4v7Pseff = 0.0; printf("Warning: Pseff is negative, it is set to zero.\n"); } - /* if (here->BSIM4drainPerimeterGiven) - { if (model->BSIM4perMod == 0) - here->BSIM4Pdeff = here->BSIM4drainPerimeter; + /* if (here->BSIM4v7drainPerimeterGiven) + { if (model->BSIM4v7perMod == 0) + here->BSIM4v7Pdeff = here->BSIM4v7drainPerimeter; else - here->BSIM4Pdeff = here->BSIM4drainPerimeter - - pParam->BSIM4weffCJ * here->BSIM4nf; + here->BSIM4v7Pdeff = here->BSIM4v7drainPerimeter + - pParam->BSIM4v7weffCJ * here->BSIM4v7nf; } else - BSIM4PAeffGeo(here->BSIM4nf, here->BSIM4geoMod, here->BSIM4min, - pParam->BSIM4weffCJ, DMCGeff, DMCIeff, DMDGeff, - &dumPs, &(here->BSIM4Pdeff), &dumAs, &dumAd); - if (here->BSIM4Pdeff < 0.0) /4.6.2/ - here->BSIM4Pdeff = 0.0; */ + BSIM4v7PAeffGeo(here->BSIM4v7nf, here->BSIM4v7geoMod, here->BSIM4v7min, + pParam->BSIM4v7weffCJ, DMCGeff, DMCIeff, DMDGeff, + &dumPs, &(here->BSIM4v7Pdeff), &dumAs, &dumAd); + if (here->BSIM4v7Pdeff < 0.0) /4.6.2/ + here->BSIM4v7Pdeff = 0.0; */ - if (here->BSIM4drainPerimeterGiven) + if (here->BSIM4v7drainPerimeterGiven) { /* given */ - if (here->BSIM4drainPerimeter == 0.0) - here->BSIM4Pdeff = 0.0; - else if (here->BSIM4drainPerimeter < 0.0) + if (here->BSIM4v7drainPerimeter == 0.0) + here->BSIM4v7Pdeff = 0.0; + else if (here->BSIM4v7drainPerimeter < 0.0) { printf("Warning: Drain Perimeter is specified as negative, it is set to zero.\n"); - here->BSIM4Pdeff = 0.0; + here->BSIM4v7Pdeff = 0.0; } else { - if (model->BSIM4perMod == 0) - here->BSIM4Pdeff = here->BSIM4drainPerimeter; + if (model->BSIM4v7perMod == 0) + here->BSIM4v7Pdeff = here->BSIM4v7drainPerimeter; else - here->BSIM4Pdeff = here->BSIM4drainPerimeter - - pParam->BSIM4weffCJ * here->BSIM4nf; + here->BSIM4v7Pdeff = here->BSIM4v7drainPerimeter + - pParam->BSIM4v7weffCJ * here->BSIM4v7nf; } } else /* not given */ - BSIM4PAeffGeo(here->BSIM4nf, here->BSIM4geoMod, here->BSIM4min, - pParam->BSIM4weffCJ, DMCGeff, DMCIeff, DMDGeff, - &dumPs, &(here->BSIM4Pdeff), &dumAs, &dumAd); + BSIM4v7PAeffGeo(here->BSIM4v7nf, here->BSIM4v7geoMod, here->BSIM4v7min, + pParam->BSIM4v7weffCJ, DMCGeff, DMCIeff, DMDGeff, + &dumPs, &(here->BSIM4v7Pdeff), &dumAs, &dumAd); - if (here->BSIM4Pdeff < 0.0){ - here->BSIM4Pdeff = 0.0; /*New Diode v4.7*/ + if (here->BSIM4v7Pdeff < 0.0){ + here->BSIM4v7Pdeff = 0.0; /*New Diode v4.7*/ printf("Warning: Pdeff is negative, it is set to zero.\n"); } - if (here->BSIM4sourceAreaGiven) - here->BSIM4Aseff = here->BSIM4sourceArea; + if (here->BSIM4v7sourceAreaGiven) + here->BSIM4v7Aseff = here->BSIM4v7sourceArea; else - BSIM4PAeffGeo(here->BSIM4nf, here->BSIM4geoMod, here->BSIM4min, - pParam->BSIM4weffCJ, DMCGeff, DMCIeff, DMDGeff, - &dumPs, &dumPd, &(here->BSIM4Aseff), &dumAd); - if (here->BSIM4Aseff < 0.0){ - here->BSIM4Aseff = 0.0; /* v4.7 */ + BSIM4v7PAeffGeo(here->BSIM4v7nf, here->BSIM4v7geoMod, here->BSIM4v7min, + pParam->BSIM4v7weffCJ, DMCGeff, DMCIeff, DMDGeff, + &dumPs, &dumPd, &(here->BSIM4v7Aseff), &dumAd); + if (here->BSIM4v7Aseff < 0.0){ + here->BSIM4v7Aseff = 0.0; /* v4.7 */ printf("Warning: Aseff is negative, it is set to zero.\n"); } - if (here->BSIM4drainAreaGiven) - here->BSIM4Adeff = here->BSIM4drainArea; + if (here->BSIM4v7drainAreaGiven) + here->BSIM4v7Adeff = here->BSIM4v7drainArea; else - BSIM4PAeffGeo(here->BSIM4nf, here->BSIM4geoMod, here->BSIM4min, - pParam->BSIM4weffCJ, DMCGeff, DMCIeff, DMDGeff, - &dumPs, &dumPd, &dumAs, &(here->BSIM4Adeff)); - if (here->BSIM4Adeff < 0.0){ - here->BSIM4Adeff = 0.0; /* v4.7 */ + BSIM4v7PAeffGeo(here->BSIM4v7nf, here->BSIM4v7geoMod, here->BSIM4v7min, + pParam->BSIM4v7weffCJ, DMCGeff, DMCIeff, DMDGeff, + &dumPs, &dumPd, &dumAs, &(here->BSIM4v7Adeff)); + if (here->BSIM4v7Adeff < 0.0){ + here->BSIM4v7Adeff = 0.0; /* v4.7 */ printf("Warning: Adeff is negative, it is set to zero.\n"); } /* Processing S/D resistance and conductance below */ - if(here->BSIM4sNodePrime != here->BSIM4sNode) + if(here->BSIM4v7sNodePrime != here->BSIM4v7sNode) { - here->BSIM4sourceConductance = 0.0; - if(here->BSIM4sourceSquaresGiven) + here->BSIM4v7sourceConductance = 0.0; + if(here->BSIM4v7sourceSquaresGiven) { - here->BSIM4sourceConductance = model->BSIM4sheetResistance - * here->BSIM4sourceSquares; - } else if (here->BSIM4rgeoMod > 0) + here->BSIM4v7sourceConductance = model->BSIM4v7sheetResistance + * here->BSIM4v7sourceSquares; + } else if (here->BSIM4v7rgeoMod > 0) { - BSIM4RdseffGeo(here->BSIM4nf, here->BSIM4geoMod, - here->BSIM4rgeoMod, here->BSIM4min, - pParam->BSIM4weffCJ, model->BSIM4sheetResistance, - DMCGeff, DMCIeff, DMDGeff, 1, &(here->BSIM4sourceConductance)); + BSIM4v7RdseffGeo(here->BSIM4v7nf, here->BSIM4v7geoMod, + here->BSIM4v7rgeoMod, here->BSIM4v7min, + pParam->BSIM4v7weffCJ, model->BSIM4v7sheetResistance, + DMCGeff, DMCIeff, DMDGeff, 1, &(here->BSIM4v7sourceConductance)); } else { - here->BSIM4sourceConductance = 0.0; + here->BSIM4v7sourceConductance = 0.0; } - if (here->BSIM4sourceConductance > 0.0) - here->BSIM4sourceConductance = 1.0 - / here->BSIM4sourceConductance; + if (here->BSIM4v7sourceConductance > 0.0) + here->BSIM4v7sourceConductance = 1.0 + / here->BSIM4v7sourceConductance; else { - here->BSIM4sourceConductance = 1.0e3; /* mho */ + here->BSIM4v7sourceConductance = 1.0e3; /* mho */ printf ("Warning: Source conductance reset to 1.0e3 mho.\n"); } } else { - here->BSIM4sourceConductance = 0.0; + here->BSIM4v7sourceConductance = 0.0; } - if(here->BSIM4dNodePrime != here->BSIM4dNode) + if(here->BSIM4v7dNodePrime != here->BSIM4v7dNode) { - here->BSIM4drainConductance = 0.0; - if(here->BSIM4drainSquaresGiven) + here->BSIM4v7drainConductance = 0.0; + if(here->BSIM4v7drainSquaresGiven) { - here->BSIM4drainConductance = model->BSIM4sheetResistance - * here->BSIM4drainSquares; - } else if (here->BSIM4rgeoMod > 0) + here->BSIM4v7drainConductance = model->BSIM4v7sheetResistance + * here->BSIM4v7drainSquares; + } else if (here->BSIM4v7rgeoMod > 0) { - BSIM4RdseffGeo(here->BSIM4nf, here->BSIM4geoMod, - here->BSIM4rgeoMod, here->BSIM4min, - pParam->BSIM4weffCJ, model->BSIM4sheetResistance, - DMCGeff, DMCIeff, DMDGeff, 0, &(here->BSIM4drainConductance)); + BSIM4v7RdseffGeo(here->BSIM4v7nf, here->BSIM4v7geoMod, + here->BSIM4v7rgeoMod, here->BSIM4v7min, + pParam->BSIM4v7weffCJ, model->BSIM4v7sheetResistance, + DMCGeff, DMCIeff, DMDGeff, 0, &(here->BSIM4v7drainConductance)); } else { - here->BSIM4drainConductance = 0.0; + here->BSIM4v7drainConductance = 0.0; } - if (here->BSIM4drainConductance > 0.0) - here->BSIM4drainConductance = 1.0 - / here->BSIM4drainConductance; + if (here->BSIM4v7drainConductance > 0.0) + here->BSIM4v7drainConductance = 1.0 + / here->BSIM4v7drainConductance; else { - here->BSIM4drainConductance = 1.0e3; /* mho */ + here->BSIM4v7drainConductance = 1.0e3; /* mho */ printf ("Warning: Drain conductance reset to 1.0e3 mho.\n"); } } else { - here->BSIM4drainConductance = 0.0; + here->BSIM4v7drainConductance = 0.0; } /* End of Rsd processing */ - Nvtms = model->BSIM4vtm * model->BSIM4SjctEmissionCoeff; - if ((here->BSIM4Aseff <= 0.0) && (here->BSIM4Pseff <= 0.0)) + Nvtms = model->BSIM4v7vtm * model->BSIM4v7SjctEmissionCoeff; + if ((here->BSIM4v7Aseff <= 0.0) && (here->BSIM4v7Pseff <= 0.0)) { SourceSatCurrent = 0.0; /* v4.7 */ /* SourceSatCurrent = 1.0e-14; */ } else - { SourceSatCurrent = here->BSIM4Aseff * model->BSIM4SjctTempSatCurDensity - + here->BSIM4Pseff * model->BSIM4SjctSidewallTempSatCurDensity - + pParam->BSIM4weffCJ * here->BSIM4nf - * model->BSIM4SjctGateSidewallTempSatCurDensity; + { SourceSatCurrent = here->BSIM4v7Aseff * model->BSIM4v7SjctTempSatCurDensity + + here->BSIM4v7Pseff * model->BSIM4v7SjctSidewallTempSatCurDensity + + pParam->BSIM4v7weffCJ * here->BSIM4v7nf + * model->BSIM4v7SjctGateSidewallTempSatCurDensity; } if (SourceSatCurrent > 0.0) - { switch(model->BSIM4dioMod) + { switch(model->BSIM4v7dioMod) { case 0: - if ((model->BSIM4bvs / Nvtms) > EXP_THRESHOLD) - here->BSIM4XExpBVS = model->BSIM4xjbvs * MIN_EXP; + if ((model->BSIM4v7bvs / Nvtms) > EXP_THRESHOLD) + here->BSIM4v7XExpBVS = model->BSIM4v7xjbvs * MIN_EXP; else - here->BSIM4XExpBVS = model->BSIM4xjbvs * exp(-model->BSIM4bvs / Nvtms); + here->BSIM4v7XExpBVS = model->BSIM4v7xjbvs * exp(-model->BSIM4v7bvs / Nvtms); break; case 1: - BSIM4DioIjthVjmEval(Nvtms, model->BSIM4ijthsfwd, SourceSatCurrent, - 0.0, &(here->BSIM4vjsmFwd)); - here->BSIM4IVjsmFwd = SourceSatCurrent * exp(here->BSIM4vjsmFwd / Nvtms); + BSIM4v7DioIjthVjmEval(Nvtms, model->BSIM4v7ijthsfwd, SourceSatCurrent, + 0.0, &(here->BSIM4v7vjsmFwd)); + here->BSIM4v7IVjsmFwd = SourceSatCurrent * exp(here->BSIM4v7vjsmFwd / Nvtms); break; case 2: - if ((model->BSIM4bvs / Nvtms) > EXP_THRESHOLD) - { here->BSIM4XExpBVS = model->BSIM4xjbvs * MIN_EXP; + if ((model->BSIM4v7bvs / Nvtms) > EXP_THRESHOLD) + { here->BSIM4v7XExpBVS = model->BSIM4v7xjbvs * MIN_EXP; tmp = MIN_EXP; } else - { here->BSIM4XExpBVS = exp(-model->BSIM4bvs / Nvtms); - tmp = here->BSIM4XExpBVS; - here->BSIM4XExpBVS *= model->BSIM4xjbvs; + { here->BSIM4v7XExpBVS = exp(-model->BSIM4v7bvs / Nvtms); + tmp = here->BSIM4v7XExpBVS; + here->BSIM4v7XExpBVS *= model->BSIM4v7xjbvs; } - BSIM4DioIjthVjmEval(Nvtms, model->BSIM4ijthsfwd, SourceSatCurrent, - here->BSIM4XExpBVS, &(here->BSIM4vjsmFwd)); - T0 = exp(here->BSIM4vjsmFwd / Nvtms); - here->BSIM4IVjsmFwd = SourceSatCurrent * (T0 - here->BSIM4XExpBVS / T0 - + here->BSIM4XExpBVS - 1.0); - here->BSIM4SslpFwd = SourceSatCurrent - * (T0 + here->BSIM4XExpBVS / T0) / Nvtms; + BSIM4v7DioIjthVjmEval(Nvtms, model->BSIM4v7ijthsfwd, SourceSatCurrent, + here->BSIM4v7XExpBVS, &(here->BSIM4v7vjsmFwd)); + T0 = exp(here->BSIM4v7vjsmFwd / Nvtms); + here->BSIM4v7IVjsmFwd = SourceSatCurrent * (T0 - here->BSIM4v7XExpBVS / T0 + + here->BSIM4v7XExpBVS - 1.0); + here->BSIM4v7SslpFwd = SourceSatCurrent + * (T0 + here->BSIM4v7XExpBVS / T0) / Nvtms; - T2 = model->BSIM4ijthsrev / SourceSatCurrent; + T2 = model->BSIM4v7ijthsrev / SourceSatCurrent; if (T2 < 1.0) { T2 = 10.0; fprintf(stderr, "Warning: ijthsrev too small and set to 10 times IsbSat.\n"); } - here->BSIM4vjsmRev = -model->BSIM4bvs - - Nvtms * log((T2 - 1.0) / model->BSIM4xjbvs); - T1 = model->BSIM4xjbvs * exp(-(model->BSIM4bvs - + here->BSIM4vjsmRev) / Nvtms); - here->BSIM4IVjsmRev = SourceSatCurrent * (1.0 + T1); - here->BSIM4SslpRev = -SourceSatCurrent * T1 / Nvtms; + here->BSIM4v7vjsmRev = -model->BSIM4v7bvs + - Nvtms * log((T2 - 1.0) / model->BSIM4v7xjbvs); + T1 = model->BSIM4v7xjbvs * exp(-(model->BSIM4v7bvs + + here->BSIM4v7vjsmRev) / Nvtms); + here->BSIM4v7IVjsmRev = SourceSatCurrent * (1.0 + T1); + here->BSIM4v7SslpRev = -SourceSatCurrent * T1 / Nvtms; break; default: - printf("Specified dioMod = %d not matched\n", model->BSIM4dioMod); + printf("Specified dioMod = %d not matched\n", model->BSIM4v7dioMod); } } - Nvtmd = model->BSIM4vtm * model->BSIM4DjctEmissionCoeff; - if ((here->BSIM4Adeff <= 0.0) && (here->BSIM4Pdeff <= 0.0)) + Nvtmd = model->BSIM4v7vtm * model->BSIM4v7DjctEmissionCoeff; + if ((here->BSIM4v7Adeff <= 0.0) && (here->BSIM4v7Pdeff <= 0.0)) { /* DrainSatCurrent = 1.0e-14; v4.7 */ DrainSatCurrent = 0.0; } else - { DrainSatCurrent = here->BSIM4Adeff * model->BSIM4DjctTempSatCurDensity - + here->BSIM4Pdeff * model->BSIM4DjctSidewallTempSatCurDensity - + pParam->BSIM4weffCJ * here->BSIM4nf - * model->BSIM4DjctGateSidewallTempSatCurDensity; + { DrainSatCurrent = here->BSIM4v7Adeff * model->BSIM4v7DjctTempSatCurDensity + + here->BSIM4v7Pdeff * model->BSIM4v7DjctSidewallTempSatCurDensity + + pParam->BSIM4v7weffCJ * here->BSIM4v7nf + * model->BSIM4v7DjctGateSidewallTempSatCurDensity; } if (DrainSatCurrent > 0.0) - { switch(model->BSIM4dioMod) + { switch(model->BSIM4v7dioMod) { case 0: - if ((model->BSIM4bvd / Nvtmd) > EXP_THRESHOLD) - here->BSIM4XExpBVD = model->BSIM4xjbvd * MIN_EXP; + if ((model->BSIM4v7bvd / Nvtmd) > EXP_THRESHOLD) + here->BSIM4v7XExpBVD = model->BSIM4v7xjbvd * MIN_EXP; else - here->BSIM4XExpBVD = model->BSIM4xjbvd * exp(-model->BSIM4bvd / Nvtmd); + here->BSIM4v7XExpBVD = model->BSIM4v7xjbvd * exp(-model->BSIM4v7bvd / Nvtmd); break; case 1: - BSIM4DioIjthVjmEval(Nvtmd, model->BSIM4ijthdfwd, DrainSatCurrent, - 0.0, &(here->BSIM4vjdmFwd)); - here->BSIM4IVjdmFwd = DrainSatCurrent * exp(here->BSIM4vjdmFwd / Nvtmd); + BSIM4v7DioIjthVjmEval(Nvtmd, model->BSIM4v7ijthdfwd, DrainSatCurrent, + 0.0, &(here->BSIM4v7vjdmFwd)); + here->BSIM4v7IVjdmFwd = DrainSatCurrent * exp(here->BSIM4v7vjdmFwd / Nvtmd); break; case 2: - if ((model->BSIM4bvd / Nvtmd) > EXP_THRESHOLD) - { here->BSIM4XExpBVD = model->BSIM4xjbvd * MIN_EXP; + if ((model->BSIM4v7bvd / Nvtmd) > EXP_THRESHOLD) + { here->BSIM4v7XExpBVD = model->BSIM4v7xjbvd * MIN_EXP; tmp = MIN_EXP; } else - { here->BSIM4XExpBVD = exp(-model->BSIM4bvd / Nvtmd); - tmp = here->BSIM4XExpBVD; - here->BSIM4XExpBVD *= model->BSIM4xjbvd; + { here->BSIM4v7XExpBVD = exp(-model->BSIM4v7bvd / Nvtmd); + tmp = here->BSIM4v7XExpBVD; + here->BSIM4v7XExpBVD *= model->BSIM4v7xjbvd; } - BSIM4DioIjthVjmEval(Nvtmd, model->BSIM4ijthdfwd, DrainSatCurrent, - here->BSIM4XExpBVD, &(here->BSIM4vjdmFwd)); - T0 = exp(here->BSIM4vjdmFwd / Nvtmd); - here->BSIM4IVjdmFwd = DrainSatCurrent * (T0 - here->BSIM4XExpBVD / T0 - + here->BSIM4XExpBVD - 1.0); - here->BSIM4DslpFwd = DrainSatCurrent - * (T0 + here->BSIM4XExpBVD / T0) / Nvtmd; + BSIM4v7DioIjthVjmEval(Nvtmd, model->BSIM4v7ijthdfwd, DrainSatCurrent, + here->BSIM4v7XExpBVD, &(here->BSIM4v7vjdmFwd)); + T0 = exp(here->BSIM4v7vjdmFwd / Nvtmd); + here->BSIM4v7IVjdmFwd = DrainSatCurrent * (T0 - here->BSIM4v7XExpBVD / T0 + + here->BSIM4v7XExpBVD - 1.0); + here->BSIM4v7DslpFwd = DrainSatCurrent + * (T0 + here->BSIM4v7XExpBVD / T0) / Nvtmd; - T2 = model->BSIM4ijthdrev / DrainSatCurrent; + T2 = model->BSIM4v7ijthdrev / DrainSatCurrent; if (T2 < 1.0) { T2 = 10.0; fprintf(stderr, "Warning: ijthdrev too small and set to 10 times IdbSat.\n"); } - here->BSIM4vjdmRev = -model->BSIM4bvd - - Nvtmd * log((T2 - 1.0) / model->BSIM4xjbvd); /* bugfix */ - T1 = model->BSIM4xjbvd * exp(-(model->BSIM4bvd - + here->BSIM4vjdmRev) / Nvtmd); - here->BSIM4IVjdmRev = DrainSatCurrent * (1.0 + T1); - here->BSIM4DslpRev = -DrainSatCurrent * T1 / Nvtmd; + here->BSIM4v7vjdmRev = -model->BSIM4v7bvd + - Nvtmd * log((T2 - 1.0) / model->BSIM4v7xjbvd); /* bugfix */ + T1 = model->BSIM4v7xjbvd * exp(-(model->BSIM4v7bvd + + here->BSIM4v7vjdmRev) / Nvtmd); + here->BSIM4v7IVjdmRev = DrainSatCurrent * (1.0 + T1); + here->BSIM4v7DslpRev = -DrainSatCurrent * T1 / Nvtmd; break; default: - printf("Specified dioMod = %d not matched\n", model->BSIM4dioMod); + printf("Specified dioMod = %d not matched\n", model->BSIM4v7dioMod); } } /* GEDL current reverse bias */ T0 = (TRatio - 1.0); - model->BSIM4njtsstemp = model->BSIM4njts * (1.0 + model->BSIM4tnjts * T0); - model->BSIM4njtsswstemp = model->BSIM4njtssw * (1.0 + model->BSIM4tnjtssw * T0); - model->BSIM4njtsswgstemp = model->BSIM4njtsswg * (1.0 + model->BSIM4tnjtsswg * T0); - model->BSIM4njtsdtemp = model->BSIM4njtsd * (1.0 + model->BSIM4tnjtsd * T0); - model->BSIM4njtsswdtemp = model->BSIM4njtsswd * (1.0 + model->BSIM4tnjtsswd * T0); - model->BSIM4njtsswgdtemp = model->BSIM4njtsswgd * (1.0 + model->BSIM4tnjtsswgd * T0); - T7 = Eg0 / model->BSIM4vtm * T0; - T9 = model->BSIM4xtss * T7; + model->BSIM4v7njtsstemp = model->BSIM4v7njts * (1.0 + model->BSIM4v7tnjts * T0); + model->BSIM4v7njtsswstemp = model->BSIM4v7njtssw * (1.0 + model->BSIM4v7tnjtssw * T0); + model->BSIM4v7njtsswgstemp = model->BSIM4v7njtsswg * (1.0 + model->BSIM4v7tnjtsswg * T0); + model->BSIM4v7njtsdtemp = model->BSIM4v7njtsd * (1.0 + model->BSIM4v7tnjtsd * T0); + model->BSIM4v7njtsswdtemp = model->BSIM4v7njtsswd * (1.0 + model->BSIM4v7tnjtsswd * T0); + model->BSIM4v7njtsswgdtemp = model->BSIM4v7njtsswgd * (1.0 + model->BSIM4v7tnjtsswgd * T0); + T7 = Eg0 / model->BSIM4v7vtm * T0; + T9 = model->BSIM4v7xtss * T7; DEXP(T9, T1); - T9 = model->BSIM4xtsd * T7; + T9 = model->BSIM4v7xtsd * T7; DEXP(T9, T2); - T9 = model->BSIM4xtssws * T7; + T9 = model->BSIM4v7xtssws * T7; DEXP(T9, T3); - T9 = model->BSIM4xtsswd * T7; + T9 = model->BSIM4v7xtsswd * T7; DEXP(T9, T4); - T9 = model->BSIM4xtsswgs * T7; + T9 = model->BSIM4v7xtsswgs * T7; DEXP(T9, T5); - T9 = model->BSIM4xtsswgd * T7; + T9 = model->BSIM4v7xtsswgd * T7; DEXP(T9, T6); /*IBM TAT*/ - if(model->BSIM4jtweff < 0.0) - { model->BSIM4jtweff = 0.0; + if(model->BSIM4v7jtweff < 0.0) + { model->BSIM4v7jtweff = 0.0; fprintf(stderr, "TAT width dependence effect is negative. Jtweff is clamped to zero.\n"); } - T11 = sqrt(model->BSIM4jtweff / pParam->BSIM4weffCJ) + 1.0; + T11 = sqrt(model->BSIM4v7jtweff / pParam->BSIM4v7weffCJ) + 1.0; - T10 = pParam->BSIM4weffCJ * here->BSIM4nf; - here->BSIM4SjctTempRevSatCur = T1 * here->BSIM4Aseff * model->BSIM4jtss; - here->BSIM4DjctTempRevSatCur = T2 * here->BSIM4Adeff * model->BSIM4jtsd; - here->BSIM4SswTempRevSatCur = T3 * here->BSIM4Pseff * model->BSIM4jtssws; - here->BSIM4DswTempRevSatCur = T4 * here->BSIM4Pdeff * model->BSIM4jtsswd; - here->BSIM4SswgTempRevSatCur = T5 * T10 * T11 * model->BSIM4jtsswgs; - here->BSIM4DswgTempRevSatCur = T6 * T10 * T11 * model->BSIM4jtsswgd; + T10 = pParam->BSIM4v7weffCJ * here->BSIM4v7nf; + here->BSIM4v7SjctTempRevSatCur = T1 * here->BSIM4v7Aseff * model->BSIM4v7jtss; + here->BSIM4v7DjctTempRevSatCur = T2 * here->BSIM4v7Adeff * model->BSIM4v7jtsd; + here->BSIM4v7SswTempRevSatCur = T3 * here->BSIM4v7Pseff * model->BSIM4v7jtssws; + here->BSIM4v7DswTempRevSatCur = T4 * here->BSIM4v7Pdeff * model->BSIM4v7jtsswd; + here->BSIM4v7SswgTempRevSatCur = T5 * T10 * T11 * model->BSIM4v7jtsswgs; + here->BSIM4v7DswgTempRevSatCur = T6 * T10 * T11 * model->BSIM4v7jtsswgd; /*high k*/ /*Calculate VgsteffVth for mobMod=3*/ - if(model->BSIM4mobMod==3) + if(model->BSIM4v7mobMod==3) { /*Calculate n @ Vbs=Vds=0*/ - V0 = pParam->BSIM4vbi - pParam->BSIM4phi; - lt1 = model->BSIM4factor1* pParam->BSIM4sqrtXdep0; + V0 = pParam->BSIM4v7vbi - pParam->BSIM4v7phi; + lt1 = model->BSIM4v7factor1* pParam->BSIM4v7sqrtXdep0; ltw = lt1; - T0 = pParam->BSIM4dvt1 * pParam->BSIM4leff / lt1; + T0 = pParam->BSIM4v7dvt1 * pParam->BSIM4v7leff / lt1; if (T0 < EXP_THRESHOLD) { T1 = exp(T0); @@ -2143,11 +2143,11 @@ int Size_Not_Found, i; else Theta0 = 1.0 / (MAX_EXP - 2.0); - tmp1 = epssub / pParam->BSIM4Xdep0; - here->BSIM4nstar = model->BSIM4vtm / Charge_q * - (model->BSIM4coxe + tmp1 + pParam->BSIM4cit); - tmp2 = pParam->BSIM4nfactor * tmp1; - tmp3 = (tmp2 + pParam->BSIM4cdsc * Theta0 + pParam->BSIM4cit) / model->BSIM4coxe; + tmp1 = epssub / pParam->BSIM4v7Xdep0; + here->BSIM4v7nstar = model->BSIM4v7vtm / Charge_q * + (model->BSIM4v7coxe + tmp1 + pParam->BSIM4v7cit); + tmp2 = pParam->BSIM4v7nfactor * tmp1; + tmp3 = (tmp2 + pParam->BSIM4v7cdsc * Theta0 + pParam->BSIM4v7cit) / model->BSIM4v7coxe; if (tmp3 >= -0.5) n0 = 1.0 + tmp3; else @@ -2156,48 +2156,48 @@ int Size_Not_Found, i; n0 = (1.0 + 3.0 * tmp3) * T0; } - T0 = n0 * model->BSIM4vtm; - T1 = pParam->BSIM4voffcbn; + T0 = n0 * model->BSIM4v7vtm; + T1 = pParam->BSIM4v7voffcbn; T2 = T1/T0; if (T2 < -EXP_THRESHOLD) - { T3 = model->BSIM4coxe * MIN_EXP / pParam->BSIM4cdep0; - T4 = pParam->BSIM4mstar + T3 * n0; + { T3 = model->BSIM4v7coxe * MIN_EXP / pParam->BSIM4v7cdep0; + T4 = pParam->BSIM4v7mstar + T3 * n0; } else if (T2 > EXP_THRESHOLD) - { T3 = model->BSIM4coxe * MAX_EXP / pParam->BSIM4cdep0; - T4 = pParam->BSIM4mstar + T3 * n0; + { T3 = model->BSIM4v7coxe * MAX_EXP / pParam->BSIM4v7cdep0; + T4 = pParam->BSIM4v7mstar + T3 * n0; } else - { T3 = exp(T2)* model->BSIM4coxe / pParam->BSIM4cdep0; - T4 = pParam->BSIM4mstar + T3 * n0; + { T3 = exp(T2)* model->BSIM4v7coxe / pParam->BSIM4v7cdep0; + T4 = pParam->BSIM4v7mstar + T3 * n0; } - pParam->BSIM4VgsteffVth = T0 * log(2.0)/T4; + pParam->BSIM4v7VgsteffVth = T0 * log(2.0)/T4; } /* New DITS term added in 4.7 */ - T0 = -pParam->BSIM4dvtp3 * log(pParam->BSIM4leff); + T0 = -pParam->BSIM4v7dvtp3 * log(pParam->BSIM4v7leff); DEXP(T0, T1); - pParam->BSIM4dvtp2factor = pParam->BSIM4dvtp5 + pParam->BSIM4dvtp2 * T1; + pParam->BSIM4v7dvtp2factor = pParam->BSIM4v7dvtp5 + pParam->BSIM4v7dvtp2 * T1; - if(model->BSIM4mtrlMod != 0 && model->BSIM4mtrlCompatMod == 0) + if(model->BSIM4v7mtrlMod != 0 && model->BSIM4v7mtrlCompatMod == 0) { /* Calculate TOXP from EOT */ /* Calculate Vgs_eff @ Vgs = VDD with Poly Depletion Effect */ - Vtm0eot = KboQ * model->BSIM4tempeot; + Vtm0eot = KboQ * model->BSIM4v7tempeot; Vtmeot = Vtm0eot; - vbieot = Vtm0eot * log(pParam->BSIM4nsd - * pParam->BSIM4ndep / (ni * ni)); - phieot = Vtm0eot * log(pParam->BSIM4ndep / ni) - + pParam->BSIM4phin + 0.4; - tmp2 = here->BSIM4vfb + phieot; - vddeot = model->BSIM4type * model->BSIM4vddeot; - T0 = model->BSIM4epsrgate * EPS0; - if ((pParam->BSIM4ngate > 1.0e18) && (pParam->BSIM4ngate < 1.0e25) + vbieot = Vtm0eot * log(pParam->BSIM4v7nsd + * pParam->BSIM4v7ndep / (ni * ni)); + phieot = Vtm0eot * log(pParam->BSIM4v7ndep / ni) + + pParam->BSIM4v7phin + 0.4; + tmp2 = here->BSIM4v7vfb + phieot; + vddeot = model->BSIM4v7type * model->BSIM4v7vddeot; + T0 = model->BSIM4v7epsrgate * EPS0; + if ((pParam->BSIM4v7ngate > 1.0e18) && (pParam->BSIM4v7ngate < 1.0e25) && (vddeot > tmp2) && (T0!=0)) { - T1 = 1.0e6 * CHARGE * T0 * pParam->BSIM4ngate / - (model->BSIM4coxe * model->BSIM4coxe); + T1 = 1.0e6 * CHARGE * T0 * pParam->BSIM4v7ngate / + (model->BSIM4v7coxe * model->BSIM4v7coxe); T8 = vddeot - tmp2; T4 = sqrt(1.0 + 2.0 * T8 / T1); T2 = 2.0 * T8 / (T4 + 1.0); @@ -2213,9 +2213,9 @@ int Size_Not_Found, i; /* Calculate Vth @ Vds=Vbs=0 */ V0 = vbieot - phieot; - lt1 = model->BSIM4factor1* pParam->BSIM4sqrtXdep0; + lt1 = model->BSIM4v7factor1* pParam->BSIM4v7sqrtXdep0; ltw = lt1; - T0 = pParam->BSIM4dvt1 * model->BSIM4leffeot / lt1; + T0 = pParam->BSIM4v7dvt1 * model->BSIM4v7leffeot / lt1; if (T0 < EXP_THRESHOLD) { T1 = exp(T0); @@ -2226,8 +2226,8 @@ int Size_Not_Found, i; } else Theta0 = 1.0 / (MAX_EXP - 2.0); - Delt_vth = pParam->BSIM4dvt0 * Theta0 * V0; - T0 = pParam->BSIM4dvt1w * model->BSIM4weffeot * model->BSIM4leffeot / ltw; + Delt_vth = pParam->BSIM4v7dvt0 * Theta0 * V0; + T0 = pParam->BSIM4v7dvt1w * model->BSIM4v7weffeot * model->BSIM4v7leffeot / ltw; if (T0 < EXP_THRESHOLD) { T1 = exp(T0); T2 = T1 - 1.0; @@ -2237,24 +2237,24 @@ int Size_Not_Found, i; } else T5 = 1.0 / (MAX_EXP - 2.0); /* 3.0 * MIN_EXP omitted */ - T2 = pParam->BSIM4dvt0w * T5 * V0; - TempRatioeot = model->BSIM4tempeot / model->BSIM4tnom - 1.0; - T0 = sqrt(1.0 + pParam->BSIM4lpe0 / model->BSIM4leffeot); - T1 = pParam->BSIM4k1ox * (T0 - 1.0) * sqrt(phieot) - + (pParam->BSIM4kt1 + pParam->BSIM4kt1l / model->BSIM4leffeot) * TempRatioeot; + T2 = pParam->BSIM4v7dvt0w * T5 * V0; + TempRatioeot = model->BSIM4v7tempeot / model->BSIM4v7tnom - 1.0; + T0 = sqrt(1.0 + pParam->BSIM4v7lpe0 / model->BSIM4v7leffeot); + T1 = pParam->BSIM4v7k1ox * (T0 - 1.0) * sqrt(phieot) + + (pParam->BSIM4v7kt1 + pParam->BSIM4v7kt1l / model->BSIM4v7leffeot) * TempRatioeot; Vth_NarrowW = toxe * phieot - / (model->BSIM4weffeot + pParam->BSIM4w0); - Lpe_Vb = sqrt(1.0 + pParam->BSIM4lpeb / model->BSIM4leffeot); - Vth = model->BSIM4type * here->BSIM4vth0 + - (pParam->BSIM4k1ox - pParam->BSIM4k1)*sqrt(phieot)*Lpe_Vb - - Delt_vth - T2 + pParam->BSIM4k3 * Vth_NarrowW + T1; + / (model->BSIM4v7weffeot + pParam->BSIM4v7w0); + Lpe_Vb = sqrt(1.0 + pParam->BSIM4v7lpeb / model->BSIM4v7leffeot); + Vth = model->BSIM4v7type * here->BSIM4v7vth0 + + (pParam->BSIM4v7k1ox - pParam->BSIM4v7k1)*sqrt(phieot)*Lpe_Vb + - Delt_vth - T2 + pParam->BSIM4v7k3 * Vth_NarrowW + T1; /* Calculate n */ - tmp1 = epssub / pParam->BSIM4Xdep0; - here->BSIM4nstar = Vtmeot / Charge_q * - (model->BSIM4coxe + tmp1 + pParam->BSIM4cit); - tmp2 = pParam->BSIM4nfactor * tmp1; - tmp3 = (tmp2 + pParam->BSIM4cdsc * Theta0 + pParam->BSIM4cit) / model->BSIM4coxe; + tmp1 = epssub / pParam->BSIM4v7Xdep0; + here->BSIM4v7nstar = Vtmeot / Charge_q * + (model->BSIM4v7coxe + tmp1 + pParam->BSIM4v7cit); + tmp2 = pParam->BSIM4v7nfactor * tmp1; + tmp3 = (tmp2 + pParam->BSIM4v7cdsc * Theta0 + pParam->BSIM4v7cit) / model->BSIM4v7coxe; if (tmp3 >= -0.5) n = 1.0 + tmp3; else @@ -2264,19 +2264,19 @@ int Size_Not_Found, i; } /* Vth correction for Pocket implant */ - if (pParam->BSIM4dvtp0 > 0.0) + if (pParam->BSIM4v7dvtp0 > 0.0) { - T3 = model->BSIM4leffeot + pParam->BSIM4dvtp0 * 2.0; - if (model->BSIM4tempMod < 2) - T4 = Vtmeot * log(model->BSIM4leffeot / T3); + T3 = model->BSIM4v7leffeot + pParam->BSIM4v7dvtp0 * 2.0; + if (model->BSIM4v7tempMod < 2) + T4 = Vtmeot * log(model->BSIM4v7leffeot / T3); else - T4 = Vtm0eot * log(model->BSIM4leffeot / T3); + T4 = Vtm0eot * log(model->BSIM4v7leffeot / T3); Vth -= n * T4; } Vgsteff = Vgs_eff-Vth; /* calculating Toxp */ - T3 = model->BSIM4type * here->BSIM4vth0 - - here->BSIM4vfb - phieot; + T3 = model->BSIM4v7type * here->BSIM4v7vth0 + - here->BSIM4v7vfb - phieot; T4 = T3 + T3; T5 = 2.5 * T3; @@ -2292,18 +2292,18 @@ int Size_Not_Found, i; toxpi = toxpf; tmp2 = 2.0e8 * toxpf; T0 = (Vgsteff + vtfbphi2eot) / tmp2; - T1 = 1.0 + exp(model->BSIM4bdos * 0.7 * log(T0)); - Tcen = model->BSIM4ados * 1.9e-9 / T1; - toxpf = toxe - epsrox/model->BSIM4epsrsub * Tcen; + T1 = 1.0 + exp(model->BSIM4v7bdos * 0.7 * log(T0)); + Tcen = model->BSIM4v7ados * 1.9e-9 / T1; + toxpf = toxe - epsrox/model->BSIM4v7epsrsub * Tcen; niter++; } while ((niter<=4)&&(ABS(toxpf-toxpi)>1e-12)); - model->BSIM4toxp = toxpf; - model->BSIM4coxp = epsrox * EPS0 / model->BSIM4toxp; + model->BSIM4v7toxp = toxpf; + model->BSIM4v7coxp = epsrox * EPS0 / model->BSIM4v7toxp; } - if (BSIM4checkModel(model, here, ckt)) + if (BSIM4v7checkModel(model, here, ckt)) { - SPfrontEnd->IFerrorf (ERR_FATAL, "Fatal error(s) detected during BSIM4.6.0 parameter checking for %s in model %s", model->BSIM4modName, here->BSIM4name); + SPfrontEnd->IFerrorf (ERR_FATAL, "Fatal error(s) detected during BSIM4v7.6.0 parameter checking for %s in model %s", model->BSIM4v7modName, here->BSIM4v7name); return(E_BADPARM); } } /* End instance */ diff --git a/src/spicelib/devices/bsim4v7/b4v7trunc.c b/src/spicelib/devices/bsim4v7/b4v7trunc.c index aa107ca0b..a851aaaf8 100644 --- a/src/spicelib/devices/bsim4v7/b4v7trunc.c +++ b/src/spicelib/devices/bsim4v7/b4v7trunc.c @@ -12,46 +12,46 @@ #include "ngspice/ngspice.h" #include "ngspice/cktdefs.h" -#include "bsim4def.h" +#include "bsim4v7def.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" int -BSIM4trunc( +BSIM4v7trunc( GENmodel *inModel, CKTcircuit *ckt, double *timeStep) { -BSIM4model *model = (BSIM4model*)inModel; -BSIM4instance *here; +BSIM4v7model *model = (BSIM4v7model*)inModel; +BSIM4v7instance *here; #ifdef STEPDEBUG double debugtemp; #endif /* STEPDEBUG */ - for (; model != NULL; model = model->BSIM4nextModel) - { for (here = model->BSIM4instances; here != NULL; - here = here->BSIM4nextInstance) + for (; model != NULL; model = model->BSIM4v7nextModel) + { for (here = model->BSIM4v7instances; here != NULL; + here = here->BSIM4v7nextInstance) { #ifdef STEPDEBUG debugtemp = *timeStep; #endif /* STEPDEBUG */ - CKTterr(here->BSIM4qb,ckt,timeStep); - CKTterr(here->BSIM4qg,ckt,timeStep); - CKTterr(here->BSIM4qd,ckt,timeStep); - if (here->BSIM4trnqsMod) - CKTterr(here->BSIM4qcdump,ckt,timeStep); - if (here->BSIM4rbodyMod) - { CKTterr(here->BSIM4qbs,ckt,timeStep); - CKTterr(here->BSIM4qbd,ckt,timeStep); + CKTterr(here->BSIM4v7qb,ckt,timeStep); + CKTterr(here->BSIM4v7qg,ckt,timeStep); + CKTterr(here->BSIM4v7qd,ckt,timeStep); + if (here->BSIM4v7trnqsMod) + CKTterr(here->BSIM4v7qcdump,ckt,timeStep); + if (here->BSIM4v7rbodyMod) + { CKTterr(here->BSIM4v7qbs,ckt,timeStep); + CKTterr(here->BSIM4v7qbd,ckt,timeStep); } - if (here->BSIM4rgateMod == 3) - CKTterr(here->BSIM4qgmid,ckt,timeStep); + if (here->BSIM4v7rgateMod == 3) + CKTterr(here->BSIM4v7qgmid,ckt,timeStep); #ifdef STEPDEBUG if(debugtemp != *timeStep) { printf("device %s reduces step from %g to %g\n", - here->BSIM4name,debugtemp,*timeStep); + here->BSIM4v7name,debugtemp,*timeStep); } #endif /* STEPDEBUG */ } diff --git a/src/spicelib/devices/bsim4v7/bsim4v7def.h b/src/spicelib/devices/bsim4v7/bsim4v7def.h index 87f041fd6..838644242 100644 --- a/src/spicelib/devices/bsim4v7/bsim4v7def.h +++ b/src/spicelib/devices/bsim4v7/bsim4v7def.h @@ -1,8 +1,8 @@ -/**** BSIM4.6.2 Released by Wenwei Yang 07/31/2008 ****/ +/**** BSIM4v7.6.2 Released by Wenwei Yang 07/31/2008 ****/ /********** Copyright 2006 Regents of the University of California. All rights reserved. -File: bsim4def.h +File: bsim4v7def.h Author: 2000 Weidong Liu. Authors: 2001- Xuemei Xi, Mohan Dunga, Ali Niknejad, Chenming Hu. Authors: 2006- Mohan Dunga, Ali Niknejad, Chenming Hu @@ -19,8 +19,8 @@ Modified by Wenwei Yang, 07/31/2008. * Modified by Tanvir Morshed, Darsen Lu 03/27/2011 **********/ -#ifndef BSIM4 -#define BSIM4 +#ifndef BSIM4v7 +#define BSIM4v7 #include "ngspice/ifsim.h" #include "ngspice/gendefs.h" @@ -28,548 +28,548 @@ Modified by Wenwei Yang, 07/31/2008. #include "ngspice/complex.h" #include "ngspice/noisedef.h" -typedef struct sBSIM4instance +typedef struct sBSIM4v7instance { - struct sBSIM4model *BSIM4modPtr; - struct sBSIM4instance *BSIM4nextInstance; - IFuid BSIM4name; - int BSIM4states; /* index into state table for this device */ - int BSIM4dNode; - int BSIM4gNodeExt; - int BSIM4sNode; - int BSIM4bNode; - int BSIM4dNodePrime; - int BSIM4gNodePrime; - int BSIM4gNodeMid; - int BSIM4sNodePrime; - int BSIM4bNodePrime; - int BSIM4dbNode; - int BSIM4sbNode; - int BSIM4qNode; + struct sBSIM4v7model *BSIM4v7modPtr; + struct sBSIM4v7instance *BSIM4v7nextInstance; + IFuid BSIM4v7name; + int BSIM4v7states; /* index into state table for this device */ + int BSIM4v7dNode; + int BSIM4v7gNodeExt; + int BSIM4v7sNode; + int BSIM4v7bNode; + int BSIM4v7dNodePrime; + int BSIM4v7gNodePrime; + int BSIM4v7gNodeMid; + int BSIM4v7sNodePrime; + int BSIM4v7bNodePrime; + int BSIM4v7dbNode; + int BSIM4v7sbNode; + int BSIM4v7qNode; - double BSIM4ueff; - double BSIM4thetavth; - double BSIM4von; - double BSIM4vdsat; - double BSIM4cgdo; - double BSIM4qgdo; - double BSIM4cgso; - double BSIM4qgso; - double BSIM4grbsb; - double BSIM4grbdb; - double BSIM4grbpb; - double BSIM4grbps; - double BSIM4grbpd; + double BSIM4v7ueff; + double BSIM4v7thetavth; + double BSIM4v7von; + double BSIM4v7vdsat; + double BSIM4v7cgdo; + double BSIM4v7qgdo; + double BSIM4v7cgso; + double BSIM4v7qgso; + double BSIM4v7grbsb; + double BSIM4v7grbdb; + double BSIM4v7grbpb; + double BSIM4v7grbps; + double BSIM4v7grbpd; - double BSIM4vjsmFwd; - double BSIM4vjsmRev; - double BSIM4vjdmFwd; - double BSIM4vjdmRev; - double BSIM4XExpBVS; - double BSIM4XExpBVD; - double BSIM4SslpFwd; - double BSIM4SslpRev; - double BSIM4DslpFwd; - double BSIM4DslpRev; - double BSIM4IVjsmFwd; - double BSIM4IVjsmRev; - double BSIM4IVjdmFwd; - double BSIM4IVjdmRev; + double BSIM4v7vjsmFwd; + double BSIM4v7vjsmRev; + double BSIM4v7vjdmFwd; + double BSIM4v7vjdmRev; + double BSIM4v7XExpBVS; + double BSIM4v7XExpBVD; + double BSIM4v7SslpFwd; + double BSIM4v7SslpRev; + double BSIM4v7DslpFwd; + double BSIM4v7DslpRev; + double BSIM4v7IVjsmFwd; + double BSIM4v7IVjsmRev; + double BSIM4v7IVjdmFwd; + double BSIM4v7IVjdmRev; - double BSIM4grgeltd; - double BSIM4Pseff; - double BSIM4Pdeff; - double BSIM4Aseff; - double BSIM4Adeff; + double BSIM4v7grgeltd; + double BSIM4v7Pseff; + double BSIM4v7Pdeff; + double BSIM4v7Aseff; + double BSIM4v7Adeff; - double BSIM4l; - double BSIM4w; - double BSIM4drainArea; - double BSIM4sourceArea; - double BSIM4drainSquares; - double BSIM4sourceSquares; - double BSIM4drainPerimeter; - double BSIM4sourcePerimeter; - double BSIM4sourceConductance; - double BSIM4drainConductance; + double BSIM4v7l; + double BSIM4v7w; + double BSIM4v7drainArea; + double BSIM4v7sourceArea; + double BSIM4v7drainSquares; + double BSIM4v7sourceSquares; + double BSIM4v7drainPerimeter; + double BSIM4v7sourcePerimeter; + double BSIM4v7sourceConductance; + double BSIM4v7drainConductance; /* stress effect instance param */ - double BSIM4sa; - double BSIM4sb; - double BSIM4sd; - double BSIM4sca; - double BSIM4scb; - double BSIM4scc; - double BSIM4sc; + double BSIM4v7sa; + double BSIM4v7sb; + double BSIM4v7sd; + double BSIM4v7sca; + double BSIM4v7scb; + double BSIM4v7scc; + double BSIM4v7sc; - double BSIM4rbdb; - double BSIM4rbsb; - double BSIM4rbpb; - double BSIM4rbps; - double BSIM4rbpd; + double BSIM4v7rbdb; + double BSIM4v7rbsb; + double BSIM4v7rbpb; + double BSIM4v7rbps; + double BSIM4v7rbpd; - double BSIM4delvto; - double BSIM4xgw; - double BSIM4ngcon; + double BSIM4v7delvto; + double BSIM4v7xgw; + double BSIM4v7ngcon; /* added here to account stress effect instance dependence */ - double BSIM4u0temp; - double BSIM4vsattemp; - double BSIM4vth0; - double BSIM4vfb; - double BSIM4vfbzb; - double BSIM4vtfbphi1; - double BSIM4vtfbphi2; - double BSIM4k2; - double BSIM4vbsc; - double BSIM4k2ox; - double BSIM4eta0; + double BSIM4v7u0temp; + double BSIM4v7vsattemp; + double BSIM4v7vth0; + double BSIM4v7vfb; + double BSIM4v7vfbzb; + double BSIM4v7vtfbphi1; + double BSIM4v7vtfbphi2; + double BSIM4v7k2; + double BSIM4v7vbsc; + double BSIM4v7k2ox; + double BSIM4v7eta0; - double BSIM4icVDS; - double BSIM4icVGS; - double BSIM4icVBS; - double BSIM4m; - double BSIM4nf; - int BSIM4off; - int BSIM4mode; - int BSIM4trnqsMod; - int BSIM4acnqsMod; - int BSIM4rbodyMod; - int BSIM4rgateMod; - int BSIM4geoMod; - int BSIM4rgeoMod; - int BSIM4min; + double BSIM4v7icVDS; + double BSIM4v7icVGS; + double BSIM4v7icVBS; + double BSIM4v7m; + double BSIM4v7nf; + int BSIM4v7off; + int BSIM4v7mode; + int BSIM4v7trnqsMod; + int BSIM4v7acnqsMod; + int BSIM4v7rbodyMod; + int BSIM4v7rgateMod; + int BSIM4v7geoMod; + int BSIM4v7rgeoMod; + int BSIM4v7min; /* OP point */ - double BSIM4Vgsteff; - double BSIM4vgs_eff; - double BSIM4vgd_eff; - double BSIM4dvgs_eff_dvg; - double BSIM4dvgd_eff_dvg; - double BSIM4Vdseff; - double BSIM4nstar; - double BSIM4Abulk; - double BSIM4EsatL; - double BSIM4AbovVgst2Vtm; - double BSIM4qinv; - double BSIM4cd; - double BSIM4cbs; - double BSIM4cbd; - double BSIM4csub; - double BSIM4Igidl; - double BSIM4Igisl; - double BSIM4gm; - double BSIM4gds; - double BSIM4gmbs; - double BSIM4gbd; - double BSIM4gbs; - double BSIM4noiGd0; /* tnoiMod=2 (v4.7) */ - double BSIM4Coxeff; + double BSIM4v7Vgsteff; + double BSIM4v7vgs_eff; + double BSIM4v7vgd_eff; + double BSIM4v7dvgs_eff_dvg; + double BSIM4v7dvgd_eff_dvg; + double BSIM4v7Vdseff; + double BSIM4v7nstar; + double BSIM4v7Abulk; + double BSIM4v7EsatL; + double BSIM4v7AbovVgst2Vtm; + double BSIM4v7qinv; + double BSIM4v7cd; + double BSIM4v7cbs; + double BSIM4v7cbd; + double BSIM4v7csub; + double BSIM4v7Igidl; + double BSIM4v7Igisl; + double BSIM4v7gm; + double BSIM4v7gds; + double BSIM4v7gmbs; + double BSIM4v7gbd; + double BSIM4v7gbs; + double BSIM4v7noiGd0; /* tnoiMod=2 (v4.7) */ + double BSIM4v7Coxeff; - double BSIM4gbbs; - double BSIM4gbgs; - double BSIM4gbds; - double BSIM4ggidld; - double BSIM4ggidlg; - double BSIM4ggidls; - double BSIM4ggidlb; - double BSIM4ggisld; - double BSIM4ggislg; - double BSIM4ggisls; - double BSIM4ggislb; + double BSIM4v7gbbs; + double BSIM4v7gbgs; + double BSIM4v7gbds; + double BSIM4v7ggidld; + double BSIM4v7ggidlg; + double BSIM4v7ggidls; + double BSIM4v7ggidlb; + double BSIM4v7ggisld; + double BSIM4v7ggislg; + double BSIM4v7ggisls; + double BSIM4v7ggislb; - double BSIM4Igcs; - double BSIM4gIgcsg; - double BSIM4gIgcsd; - double BSIM4gIgcss; - double BSIM4gIgcsb; - double BSIM4Igcd; - double BSIM4gIgcdg; - double BSIM4gIgcdd; - double BSIM4gIgcds; - double BSIM4gIgcdb; + double BSIM4v7Igcs; + double BSIM4v7gIgcsg; + double BSIM4v7gIgcsd; + double BSIM4v7gIgcss; + double BSIM4v7gIgcsb; + double BSIM4v7Igcd; + double BSIM4v7gIgcdg; + double BSIM4v7gIgcdd; + double BSIM4v7gIgcds; + double BSIM4v7gIgcdb; - double BSIM4Igs; - double BSIM4gIgsg; - double BSIM4gIgss; - double BSIM4Igd; - double BSIM4gIgdg; - double BSIM4gIgdd; + double BSIM4v7Igs; + double BSIM4v7gIgsg; + double BSIM4v7gIgss; + double BSIM4v7Igd; + double BSIM4v7gIgdg; + double BSIM4v7gIgdd; - double BSIM4Igb; - double BSIM4gIgbg; - double BSIM4gIgbd; - double BSIM4gIgbs; - double BSIM4gIgbb; + double BSIM4v7Igb; + double BSIM4v7gIgbg; + double BSIM4v7gIgbd; + double BSIM4v7gIgbs; + double BSIM4v7gIgbb; - double BSIM4grdsw; - double BSIM4IdovVds; - double BSIM4gcrg; - double BSIM4gcrgd; - double BSIM4gcrgg; - double BSIM4gcrgs; - double BSIM4gcrgb; + double BSIM4v7grdsw; + double BSIM4v7IdovVds; + double BSIM4v7gcrg; + double BSIM4v7gcrgd; + double BSIM4v7gcrgg; + double BSIM4v7gcrgs; + double BSIM4v7gcrgb; - double BSIM4gstot; - double BSIM4gstotd; - double BSIM4gstotg; - double BSIM4gstots; - double BSIM4gstotb; + double BSIM4v7gstot; + double BSIM4v7gstotd; + double BSIM4v7gstotg; + double BSIM4v7gstots; + double BSIM4v7gstotb; - double BSIM4gdtot; - double BSIM4gdtotd; - double BSIM4gdtotg; - double BSIM4gdtots; - double BSIM4gdtotb; + double BSIM4v7gdtot; + double BSIM4v7gdtotd; + double BSIM4v7gdtotg; + double BSIM4v7gdtots; + double BSIM4v7gdtotb; - double BSIM4cggb; - double BSIM4cgdb; - double BSIM4cgsb; - double BSIM4cbgb; - double BSIM4cbdb; - double BSIM4cbsb; - double BSIM4cdgb; - double BSIM4cddb; - double BSIM4cdsb; - double BSIM4csgb; - double BSIM4csdb; - double BSIM4cssb; - double BSIM4cgbb; - double BSIM4cdbb; - double BSIM4csbb; - double BSIM4cbbb; - double BSIM4capbd; - double BSIM4capbs; + double BSIM4v7cggb; + double BSIM4v7cgdb; + double BSIM4v7cgsb; + double BSIM4v7cbgb; + double BSIM4v7cbdb; + double BSIM4v7cbsb; + double BSIM4v7cdgb; + double BSIM4v7cddb; + double BSIM4v7cdsb; + double BSIM4v7csgb; + double BSIM4v7csdb; + double BSIM4v7cssb; + double BSIM4v7cgbb; + double BSIM4v7cdbb; + double BSIM4v7csbb; + double BSIM4v7cbbb; + double BSIM4v7capbd; + double BSIM4v7capbs; - double BSIM4cqgb; - double BSIM4cqdb; - double BSIM4cqsb; - double BSIM4cqbb; + double BSIM4v7cqgb; + double BSIM4v7cqdb; + double BSIM4v7cqsb; + double BSIM4v7cqbb; - double BSIM4qgate; - double BSIM4qbulk; - double BSIM4qdrn; - double BSIM4qsrc; - double BSIM4qdef; + double BSIM4v7qgate; + double BSIM4v7qbulk; + double BSIM4v7qdrn; + double BSIM4v7qsrc; + double BSIM4v7qdef; - double BSIM4qchqs; - double BSIM4taunet; - double BSIM4gtau; - double BSIM4gtg; - double BSIM4gtd; - double BSIM4gts; - double BSIM4gtb; - double BSIM4SjctTempRevSatCur; - double BSIM4DjctTempRevSatCur; - double BSIM4SswTempRevSatCur; - double BSIM4DswTempRevSatCur; - double BSIM4SswgTempRevSatCur; - double BSIM4DswgTempRevSatCur; + double BSIM4v7qchqs; + double BSIM4v7taunet; + double BSIM4v7gtau; + double BSIM4v7gtg; + double BSIM4v7gtd; + double BSIM4v7gts; + double BSIM4v7gtb; + double BSIM4v7SjctTempRevSatCur; + double BSIM4v7DjctTempRevSatCur; + double BSIM4v7SswTempRevSatCur; + double BSIM4v7DswTempRevSatCur; + double BSIM4v7SswgTempRevSatCur; + double BSIM4v7DswgTempRevSatCur; struct bsim4SizeDependParam *pParam; - unsigned BSIM4lGiven :1; - unsigned BSIM4wGiven :1; - unsigned BSIM4mGiven :1; - unsigned BSIM4nfGiven :1; - unsigned BSIM4minGiven :1; - unsigned BSIM4drainAreaGiven :1; - unsigned BSIM4sourceAreaGiven :1; - unsigned BSIM4drainSquaresGiven :1; - unsigned BSIM4sourceSquaresGiven :1; - unsigned BSIM4drainPerimeterGiven :1; - unsigned BSIM4sourcePerimeterGiven :1; - unsigned BSIM4saGiven :1; - unsigned BSIM4sbGiven :1; - unsigned BSIM4sdGiven :1; - unsigned BSIM4scaGiven :1; - unsigned BSIM4scbGiven :1; - unsigned BSIM4sccGiven :1; - unsigned BSIM4scGiven :1; - unsigned BSIM4rbdbGiven :1; - unsigned BSIM4rbsbGiven :1; - unsigned BSIM4rbpbGiven :1; - unsigned BSIM4rbpdGiven :1; - unsigned BSIM4rbpsGiven :1; - unsigned BSIM4delvtoGiven :1; - unsigned BSIM4xgwGiven :1; - unsigned BSIM4ngconGiven :1; - unsigned BSIM4icVDSGiven :1; - unsigned BSIM4icVGSGiven :1; - unsigned BSIM4icVBSGiven :1; - unsigned BSIM4trnqsModGiven :1; - unsigned BSIM4acnqsModGiven :1; - unsigned BSIM4rbodyModGiven :1; - unsigned BSIM4rgateModGiven :1; - unsigned BSIM4geoModGiven :1; - unsigned BSIM4rgeoModGiven :1; + unsigned BSIM4v7lGiven :1; + unsigned BSIM4v7wGiven :1; + unsigned BSIM4v7mGiven :1; + unsigned BSIM4v7nfGiven :1; + unsigned BSIM4v7minGiven :1; + unsigned BSIM4v7drainAreaGiven :1; + unsigned BSIM4v7sourceAreaGiven :1; + unsigned BSIM4v7drainSquaresGiven :1; + unsigned BSIM4v7sourceSquaresGiven :1; + unsigned BSIM4v7drainPerimeterGiven :1; + unsigned BSIM4v7sourcePerimeterGiven :1; + unsigned BSIM4v7saGiven :1; + unsigned BSIM4v7sbGiven :1; + unsigned BSIM4v7sdGiven :1; + unsigned BSIM4v7scaGiven :1; + unsigned BSIM4v7scbGiven :1; + unsigned BSIM4v7sccGiven :1; + unsigned BSIM4v7scGiven :1; + unsigned BSIM4v7rbdbGiven :1; + unsigned BSIM4v7rbsbGiven :1; + unsigned BSIM4v7rbpbGiven :1; + unsigned BSIM4v7rbpdGiven :1; + unsigned BSIM4v7rbpsGiven :1; + unsigned BSIM4v7delvtoGiven :1; + unsigned BSIM4v7xgwGiven :1; + unsigned BSIM4v7ngconGiven :1; + unsigned BSIM4v7icVDSGiven :1; + unsigned BSIM4v7icVGSGiven :1; + unsigned BSIM4v7icVBSGiven :1; + unsigned BSIM4v7trnqsModGiven :1; + unsigned BSIM4v7acnqsModGiven :1; + unsigned BSIM4v7rbodyModGiven :1; + unsigned BSIM4v7rgateModGiven :1; + unsigned BSIM4v7geoModGiven :1; + unsigned BSIM4v7rgeoModGiven :1; - double *BSIM4DPdPtr; - double *BSIM4DPdpPtr; - double *BSIM4DPgpPtr; - double *BSIM4DPgmPtr; - double *BSIM4DPspPtr; - double *BSIM4DPbpPtr; - double *BSIM4DPdbPtr; + double *BSIM4v7DPdPtr; + double *BSIM4v7DPdpPtr; + double *BSIM4v7DPgpPtr; + double *BSIM4v7DPgmPtr; + double *BSIM4v7DPspPtr; + double *BSIM4v7DPbpPtr; + double *BSIM4v7DPdbPtr; - double *BSIM4DdPtr; - double *BSIM4DdpPtr; + double *BSIM4v7DdPtr; + double *BSIM4v7DdpPtr; - double *BSIM4GPdpPtr; - double *BSIM4GPgpPtr; - double *BSIM4GPgmPtr; - double *BSIM4GPgePtr; - double *BSIM4GPspPtr; - double *BSIM4GPbpPtr; + double *BSIM4v7GPdpPtr; + double *BSIM4v7GPgpPtr; + double *BSIM4v7GPgmPtr; + double *BSIM4v7GPgePtr; + double *BSIM4v7GPspPtr; + double *BSIM4v7GPbpPtr; - double *BSIM4GMdpPtr; - double *BSIM4GMgpPtr; - double *BSIM4GMgmPtr; - double *BSIM4GMgePtr; - double *BSIM4GMspPtr; - double *BSIM4GMbpPtr; + double *BSIM4v7GMdpPtr; + double *BSIM4v7GMgpPtr; + double *BSIM4v7GMgmPtr; + double *BSIM4v7GMgePtr; + double *BSIM4v7GMspPtr; + double *BSIM4v7GMbpPtr; - double *BSIM4GEdpPtr; - double *BSIM4GEgpPtr; - double *BSIM4GEgmPtr; - double *BSIM4GEgePtr; - double *BSIM4GEspPtr; - double *BSIM4GEbpPtr; + double *BSIM4v7GEdpPtr; + double *BSIM4v7GEgpPtr; + double *BSIM4v7GEgmPtr; + double *BSIM4v7GEgePtr; + double *BSIM4v7GEspPtr; + double *BSIM4v7GEbpPtr; - double *BSIM4SPdpPtr; - double *BSIM4SPgpPtr; - double *BSIM4SPgmPtr; - double *BSIM4SPsPtr; - double *BSIM4SPspPtr; - double *BSIM4SPbpPtr; - double *BSIM4SPsbPtr; + double *BSIM4v7SPdpPtr; + double *BSIM4v7SPgpPtr; + double *BSIM4v7SPgmPtr; + double *BSIM4v7SPsPtr; + double *BSIM4v7SPspPtr; + double *BSIM4v7SPbpPtr; + double *BSIM4v7SPsbPtr; - double *BSIM4SspPtr; - double *BSIM4SsPtr; + double *BSIM4v7SspPtr; + double *BSIM4v7SsPtr; - double *BSIM4BPdpPtr; - double *BSIM4BPgpPtr; - double *BSIM4BPgmPtr; - double *BSIM4BPspPtr; - double *BSIM4BPdbPtr; - double *BSIM4BPbPtr; - double *BSIM4BPsbPtr; - double *BSIM4BPbpPtr; + double *BSIM4v7BPdpPtr; + double *BSIM4v7BPgpPtr; + double *BSIM4v7BPgmPtr; + double *BSIM4v7BPspPtr; + double *BSIM4v7BPdbPtr; + double *BSIM4v7BPbPtr; + double *BSIM4v7BPsbPtr; + double *BSIM4v7BPbpPtr; - double *BSIM4DBdpPtr; - double *BSIM4DBdbPtr; - double *BSIM4DBbpPtr; - double *BSIM4DBbPtr; + double *BSIM4v7DBdpPtr; + double *BSIM4v7DBdbPtr; + double *BSIM4v7DBbpPtr; + double *BSIM4v7DBbPtr; - double *BSIM4SBspPtr; - double *BSIM4SBbpPtr; - double *BSIM4SBbPtr; - double *BSIM4SBsbPtr; + double *BSIM4v7SBspPtr; + double *BSIM4v7SBbpPtr; + double *BSIM4v7SBbPtr; + double *BSIM4v7SBsbPtr; - double *BSIM4BdbPtr; - double *BSIM4BbpPtr; - double *BSIM4BsbPtr; - double *BSIM4BbPtr; + double *BSIM4v7BdbPtr; + double *BSIM4v7BbpPtr; + double *BSIM4v7BsbPtr; + double *BSIM4v7BbPtr; - double *BSIM4DgpPtr; - double *BSIM4DspPtr; - double *BSIM4DbpPtr; - double *BSIM4SdpPtr; - double *BSIM4SgpPtr; - double *BSIM4SbpPtr; + double *BSIM4v7DgpPtr; + double *BSIM4v7DspPtr; + double *BSIM4v7DbpPtr; + double *BSIM4v7SdpPtr; + double *BSIM4v7SgpPtr; + double *BSIM4v7SbpPtr; - double *BSIM4QdpPtr; - double *BSIM4QgpPtr; - double *BSIM4QspPtr; - double *BSIM4QbpPtr; - double *BSIM4QqPtr; - double *BSIM4DPqPtr; - double *BSIM4GPqPtr; - double *BSIM4SPqPtr; + double *BSIM4v7QdpPtr; + double *BSIM4v7QgpPtr; + double *BSIM4v7QspPtr; + double *BSIM4v7QbpPtr; + double *BSIM4v7QqPtr; + double *BSIM4v7DPqPtr; + double *BSIM4v7GPqPtr; + double *BSIM4v7SPqPtr; #ifdef USE_OMP /* per instance storage of results, to update matrix at a later stge */ - double BSIM4rhsdPrime; - double BSIM4rhsgPrime; - double BSIM4rhsgExt; - double BSIM4grhsMid; - double BSIM4rhsbPrime; - double BSIM4rhssPrime; - double BSIM4rhsdb; - double BSIM4rhssb; - double BSIM4rhsd; - double BSIM4rhss; - double BSIM4rhsq; + double BSIM4v7rhsdPrime; + double BSIM4v7rhsgPrime; + double BSIM4v7rhsgExt; + double BSIM4v7grhsMid; + double BSIM4v7rhsbPrime; + double BSIM4v7rhssPrime; + double BSIM4v7rhsdb; + double BSIM4v7rhssb; + double BSIM4v7rhsd; + double BSIM4v7rhss; + double BSIM4v7rhsq; - double BSIM4_1; - double BSIM4_2; - double BSIM4_3; - double BSIM4_4; - double BSIM4_5; - double BSIM4_6; - double BSIM4_7; - double BSIM4_8; - double BSIM4_9; - double BSIM4_10; - double BSIM4_11; - double BSIM4_12; - double BSIM4_13; - double BSIM4_14; - double BSIM4_15; - double BSIM4_16; - double BSIM4_17; - double BSIM4_18; - double BSIM4_19; - double BSIM4_20; - double BSIM4_21; - double BSIM4_22; - double BSIM4_23; - double BSIM4_24; - double BSIM4_25; - double BSIM4_26; - double BSIM4_27; - double BSIM4_28; - double BSIM4_29; - double BSIM4_30; - double BSIM4_31; - double BSIM4_32; - double BSIM4_33; - double BSIM4_34; - double BSIM4_35; - double BSIM4_36; - double BSIM4_37; - double BSIM4_38; - double BSIM4_39; - double BSIM4_40; - double BSIM4_41; - double BSIM4_42; - double BSIM4_43; - double BSIM4_44; - double BSIM4_45; - double BSIM4_46; - double BSIM4_47; - double BSIM4_48; - double BSIM4_49; - double BSIM4_50; - double BSIM4_51; - double BSIM4_52; - double BSIM4_53; - double BSIM4_54; - double BSIM4_55; - double BSIM4_56; - double BSIM4_57; - double BSIM4_58; - double BSIM4_59; - double BSIM4_60; - double BSIM4_61; - double BSIM4_62; - double BSIM4_63; - double BSIM4_64; - double BSIM4_65; - double BSIM4_66; - double BSIM4_67; - double BSIM4_68; - double BSIM4_69; - double BSIM4_70; - double BSIM4_71; - double BSIM4_72; - double BSIM4_73; - double BSIM4_74; - double BSIM4_75; - double BSIM4_76; - double BSIM4_77; - double BSIM4_78; - double BSIM4_79; - double BSIM4_80; - double BSIM4_81; - double BSIM4_82; - double BSIM4_83; - double BSIM4_84; - double BSIM4_85; - double BSIM4_86; - double BSIM4_87; - double BSIM4_88; - double BSIM4_89; - double BSIM4_90; - double BSIM4_91; - double BSIM4_92; - double BSIM4_93; - double BSIM4_94; - double BSIM4_95; - double BSIM4_96; - double BSIM4_97; - double BSIM4_98; - double BSIM4_99; - double BSIM4_100; - double BSIM4_101; - double BSIM4_102; - double BSIM4_103; + double BSIM4v7_1; + double BSIM4v7_2; + double BSIM4v7_3; + double BSIM4v7_4; + double BSIM4v7_5; + double BSIM4v7_6; + double BSIM4v7_7; + double BSIM4v7_8; + double BSIM4v7_9; + double BSIM4v7_10; + double BSIM4v7_11; + double BSIM4v7_12; + double BSIM4v7_13; + double BSIM4v7_14; + double BSIM4v7_15; + double BSIM4v7_16; + double BSIM4v7_17; + double BSIM4v7_18; + double BSIM4v7_19; + double BSIM4v7_20; + double BSIM4v7_21; + double BSIM4v7_22; + double BSIM4v7_23; + double BSIM4v7_24; + double BSIM4v7_25; + double BSIM4v7_26; + double BSIM4v7_27; + double BSIM4v7_28; + double BSIM4v7_29; + double BSIM4v7_30; + double BSIM4v7_31; + double BSIM4v7_32; + double BSIM4v7_33; + double BSIM4v7_34; + double BSIM4v7_35; + double BSIM4v7_36; + double BSIM4v7_37; + double BSIM4v7_38; + double BSIM4v7_39; + double BSIM4v7_40; + double BSIM4v7_41; + double BSIM4v7_42; + double BSIM4v7_43; + double BSIM4v7_44; + double BSIM4v7_45; + double BSIM4v7_46; + double BSIM4v7_47; + double BSIM4v7_48; + double BSIM4v7_49; + double BSIM4v7_50; + double BSIM4v7_51; + double BSIM4v7_52; + double BSIM4v7_53; + double BSIM4v7_54; + double BSIM4v7_55; + double BSIM4v7_56; + double BSIM4v7_57; + double BSIM4v7_58; + double BSIM4v7_59; + double BSIM4v7_60; + double BSIM4v7_61; + double BSIM4v7_62; + double BSIM4v7_63; + double BSIM4v7_64; + double BSIM4v7_65; + double BSIM4v7_66; + double BSIM4v7_67; + double BSIM4v7_68; + double BSIM4v7_69; + double BSIM4v7_70; + double BSIM4v7_71; + double BSIM4v7_72; + double BSIM4v7_73; + double BSIM4v7_74; + double BSIM4v7_75; + double BSIM4v7_76; + double BSIM4v7_77; + double BSIM4v7_78; + double BSIM4v7_79; + double BSIM4v7_80; + double BSIM4v7_81; + double BSIM4v7_82; + double BSIM4v7_83; + double BSIM4v7_84; + double BSIM4v7_85; + double BSIM4v7_86; + double BSIM4v7_87; + double BSIM4v7_88; + double BSIM4v7_89; + double BSIM4v7_90; + double BSIM4v7_91; + double BSIM4v7_92; + double BSIM4v7_93; + double BSIM4v7_94; + double BSIM4v7_95; + double BSIM4v7_96; + double BSIM4v7_97; + double BSIM4v7_98; + double BSIM4v7_99; + double BSIM4v7_100; + double BSIM4v7_101; + double BSIM4v7_102; + double BSIM4v7_103; #endif -#define BSIM4vbd BSIM4states+ 0 -#define BSIM4vbs BSIM4states+ 1 -#define BSIM4vgs BSIM4states+ 2 -#define BSIM4vds BSIM4states+ 3 -#define BSIM4vdbs BSIM4states+ 4 -#define BSIM4vdbd BSIM4states+ 5 -#define BSIM4vsbs BSIM4states+ 6 -#define BSIM4vges BSIM4states+ 7 -#define BSIM4vgms BSIM4states+ 8 -#define BSIM4vses BSIM4states+ 9 -#define BSIM4vdes BSIM4states+ 10 +#define BSIM4v7vbd BSIM4v7states+ 0 +#define BSIM4v7vbs BSIM4v7states+ 1 +#define BSIM4v7vgs BSIM4v7states+ 2 +#define BSIM4v7vds BSIM4v7states+ 3 +#define BSIM4v7vdbs BSIM4v7states+ 4 +#define BSIM4v7vdbd BSIM4v7states+ 5 +#define BSIM4v7vsbs BSIM4v7states+ 6 +#define BSIM4v7vges BSIM4v7states+ 7 +#define BSIM4v7vgms BSIM4v7states+ 8 +#define BSIM4v7vses BSIM4v7states+ 9 +#define BSIM4v7vdes BSIM4v7states+ 10 -#define BSIM4qb BSIM4states+ 11 -#define BSIM4cqb BSIM4states+ 12 -#define BSIM4qg BSIM4states+ 13 -#define BSIM4cqg BSIM4states+ 14 -#define BSIM4qd BSIM4states+ 15 -#define BSIM4cqd BSIM4states+ 16 -#define BSIM4qgmid BSIM4states+ 17 -#define BSIM4cqgmid BSIM4states+ 18 +#define BSIM4v7qb BSIM4v7states+ 11 +#define BSIM4v7cqb BSIM4v7states+ 12 +#define BSIM4v7qg BSIM4v7states+ 13 +#define BSIM4v7cqg BSIM4v7states+ 14 +#define BSIM4v7qd BSIM4v7states+ 15 +#define BSIM4v7cqd BSIM4v7states+ 16 +#define BSIM4v7qgmid BSIM4v7states+ 17 +#define BSIM4v7cqgmid BSIM4v7states+ 18 -#define BSIM4qbs BSIM4states+ 19 -#define BSIM4cqbs BSIM4states+ 20 -#define BSIM4qbd BSIM4states+ 21 -#define BSIM4cqbd BSIM4states+ 22 +#define BSIM4v7qbs BSIM4v7states+ 19 +#define BSIM4v7cqbs BSIM4v7states+ 20 +#define BSIM4v7qbd BSIM4v7states+ 21 +#define BSIM4v7cqbd BSIM4v7states+ 22 -#define BSIM4qcheq BSIM4states+ 23 -#define BSIM4cqcheq BSIM4states+ 24 -#define BSIM4qcdump BSIM4states+ 25 -#define BSIM4cqcdump BSIM4states+ 26 -#define BSIM4qdef BSIM4states+ 27 -#define BSIM4qs BSIM4states+ 28 +#define BSIM4v7qcheq BSIM4v7states+ 23 +#define BSIM4v7cqcheq BSIM4v7states+ 24 +#define BSIM4v7qcdump BSIM4v7states+ 25 +#define BSIM4v7cqcdump BSIM4v7states+ 26 +#define BSIM4v7qdef BSIM4v7states+ 27 +#define BSIM4v7qs BSIM4v7states+ 28 -#define BSIM4numStates 29 +#define BSIM4v7numStates 29 -/* indices to the array of BSIM4 NOISE SOURCES */ +/* indices to the array of BSIM4v7 NOISE SOURCES */ -#define BSIM4RDNOIZ 0 -#define BSIM4RSNOIZ 1 -#define BSIM4RGNOIZ 2 -#define BSIM4RBPSNOIZ 3 -#define BSIM4RBPDNOIZ 4 -#define BSIM4RBPBNOIZ 5 -#define BSIM4RBSBNOIZ 6 -#define BSIM4RBDBNOIZ 7 -#define BSIM4IDNOIZ 8 -#define BSIM4FLNOIZ 9 -#define BSIM4IGSNOIZ 10 -#define BSIM4IGDNOIZ 11 -#define BSIM4IGBNOIZ 12 -#define BSIM4CORLNOIZ 13 -#define BSIM4TOTNOIZ 14 +#define BSIM4v7RDNOIZ 0 +#define BSIM4v7RSNOIZ 1 +#define BSIM4v7RGNOIZ 2 +#define BSIM4v7RBPSNOIZ 3 +#define BSIM4v7RBPDNOIZ 4 +#define BSIM4v7RBPBNOIZ 5 +#define BSIM4v7RBSBNOIZ 6 +#define BSIM4v7RBDBNOIZ 7 +#define BSIM4v7IDNOIZ 8 +#define BSIM4v7FLNOIZ 9 +#define BSIM4v7IGSNOIZ 10 +#define BSIM4v7IGDNOIZ 11 +#define BSIM4v7IGBNOIZ 12 +#define BSIM4v7CORLNOIZ 13 +#define BSIM4v7TOTNOIZ 14 -#define BSIM4NSRCS 15 /* Number of BSIM4 noise sources */ +#define BSIM4v7NSRCS 15 /* Number of BSIM4v7 noise sources */ #ifndef NONOISE - double BSIM4nVar[NSTATVARS][BSIM4NSRCS]; + double BSIM4v7nVar[NSTATVARS][BSIM4v7NSRCS]; #else /* NONOISE */ - double **BSIM4nVar; + double **BSIM4v7nVar; #endif /* NONOISE */ -} BSIM4instance ; +} BSIM4v7instance ; struct bsim4SizeDependParam { @@ -577,2132 +577,2132 @@ struct bsim4SizeDependParam double Length; double NFinger; - double BSIM4cdsc; - double BSIM4cdscb; - double BSIM4cdscd; - double BSIM4cit; - double BSIM4nfactor; - double BSIM4xj; - double BSIM4vsat; - double BSIM4at; - double BSIM4a0; - double BSIM4ags; - double BSIM4a1; - double BSIM4a2; - double BSIM4keta; - double BSIM4nsub; - double BSIM4ndep; - double BSIM4nsd; - double BSIM4phin; - double BSIM4ngate; - double BSIM4gamma1; - double BSIM4gamma2; - double BSIM4vbx; - double BSIM4vbi; - double BSIM4vbm; - double BSIM4xt; - double BSIM4phi; - double BSIM4litl; - double BSIM4k1; - double BSIM4kt1; - double BSIM4kt1l; - double BSIM4kt2; - double BSIM4k2; - double BSIM4k3; - double BSIM4k3b; - double BSIM4w0; - double BSIM4dvtp0; - double BSIM4dvtp1; - double BSIM4dvtp2; /* New DIBL/Rout */ - double BSIM4dvtp3; - double BSIM4dvtp4; - double BSIM4dvtp5; - double BSIM4lpe0; - double BSIM4lpeb; - double BSIM4dvt0; - double BSIM4dvt1; - double BSIM4dvt2; - double BSIM4dvt0w; - double BSIM4dvt1w; - double BSIM4dvt2w; - double BSIM4drout; - double BSIM4dsub; - double BSIM4vth0; - double BSIM4ua; - double BSIM4ua1; - double BSIM4ub; - double BSIM4ub1; - double BSIM4uc; - double BSIM4uc1; - double BSIM4ud; - double BSIM4ud1; - double BSIM4up; - double BSIM4lp; - double BSIM4u0; - double BSIM4eu; - double BSIM4ucs; - double BSIM4ute; - double BSIM4ucste; - double BSIM4voff; - double BSIM4tvoff; - double BSIM4tnfactor; /* v4.7 Temp dep of leakage current */ - double BSIM4teta0; /* v4.7 temp dep of leakage current */ - double BSIM4tvoffcv; /* v4.7 temp dep of leakage current */ - double BSIM4minv; - double BSIM4minvcv; - double BSIM4vfb; - double BSIM4delta; - double BSIM4rdsw; - double BSIM4rds0; - double BSIM4rs0; - double BSIM4rd0; - double BSIM4rsw; - double BSIM4rdw; - double BSIM4prwg; - double BSIM4prwb; - double BSIM4prt; - double BSIM4eta0; - double BSIM4etab; - double BSIM4pclm; - double BSIM4pdibl1; - double BSIM4pdibl2; - double BSIM4pdiblb; - double BSIM4fprout; - double BSIM4pdits; - double BSIM4pditsd; - double BSIM4pscbe1; - double BSIM4pscbe2; - double BSIM4pvag; - double BSIM4wr; - double BSIM4dwg; - double BSIM4dwb; - double BSIM4b0; - double BSIM4b1; - double BSIM4alpha0; - double BSIM4alpha1; - double BSIM4beta0; - double BSIM4agidl; - double BSIM4bgidl; - double BSIM4cgidl; - double BSIM4egidl; - double BSIM4fgidl; /* v4.7 New GIDL/GISL */ - double BSIM4kgidl; /* v4.7 New GIDL/GISL */ - double BSIM4rgidl; /* v4.7 New GIDL/GISL */ - double BSIM4agisl; - double BSIM4bgisl; - double BSIM4cgisl; - double BSIM4egisl; - double BSIM4fgisl; /* v4.7 New GIDL/GISL */ - double BSIM4kgisl; /* v4.7 New GIDL/GISL */ - double BSIM4rgisl; /* v4.7 New GIDL/GISL */ - double BSIM4aigc; - double BSIM4bigc; - double BSIM4cigc; - double BSIM4aigs; - double BSIM4bigs; - double BSIM4cigs; - double BSIM4aigd; - double BSIM4bigd; - double BSIM4cigd; - double BSIM4aigbacc; - double BSIM4bigbacc; - double BSIM4cigbacc; - double BSIM4aigbinv; - double BSIM4bigbinv; - double BSIM4cigbinv; - double BSIM4nigc; - double BSIM4nigbacc; - double BSIM4nigbinv; - double BSIM4ntox; - double BSIM4eigbinv; - double BSIM4pigcd; - double BSIM4poxedge; - double BSIM4xrcrg1; - double BSIM4xrcrg2; - double BSIM4lambda; /* overshoot */ - double BSIM4vtl; /* thermal velocity limit */ - double BSIM4xn; /* back scattering parameter */ - double BSIM4lc; /* back scattering parameter */ - double BSIM4tfactor; /* ballistic transportation factor */ - double BSIM4vfbsdoff; /* S/D flatband offset voltage */ - double BSIM4tvfbsdoff; + double BSIM4v7cdsc; + double BSIM4v7cdscb; + double BSIM4v7cdscd; + double BSIM4v7cit; + double BSIM4v7nfactor; + double BSIM4v7xj; + double BSIM4v7vsat; + double BSIM4v7at; + double BSIM4v7a0; + double BSIM4v7ags; + double BSIM4v7a1; + double BSIM4v7a2; + double BSIM4v7keta; + double BSIM4v7nsub; + double BSIM4v7ndep; + double BSIM4v7nsd; + double BSIM4v7phin; + double BSIM4v7ngate; + double BSIM4v7gamma1; + double BSIM4v7gamma2; + double BSIM4v7vbx; + double BSIM4v7vbi; + double BSIM4v7vbm; + double BSIM4v7xt; + double BSIM4v7phi; + double BSIM4v7litl; + double BSIM4v7k1; + double BSIM4v7kt1; + double BSIM4v7kt1l; + double BSIM4v7kt2; + double BSIM4v7k2; + double BSIM4v7k3; + double BSIM4v7k3b; + double BSIM4v7w0; + double BSIM4v7dvtp0; + double BSIM4v7dvtp1; + double BSIM4v7dvtp2; /* New DIBL/Rout */ + double BSIM4v7dvtp3; + double BSIM4v7dvtp4; + double BSIM4v7dvtp5; + double BSIM4v7lpe0; + double BSIM4v7lpeb; + double BSIM4v7dvt0; + double BSIM4v7dvt1; + double BSIM4v7dvt2; + double BSIM4v7dvt0w; + double BSIM4v7dvt1w; + double BSIM4v7dvt2w; + double BSIM4v7drout; + double BSIM4v7dsub; + double BSIM4v7vth0; + double BSIM4v7ua; + double BSIM4v7ua1; + double BSIM4v7ub; + double BSIM4v7ub1; + double BSIM4v7uc; + double BSIM4v7uc1; + double BSIM4v7ud; + double BSIM4v7ud1; + double BSIM4v7up; + double BSIM4v7lp; + double BSIM4v7u0; + double BSIM4v7eu; + double BSIM4v7ucs; + double BSIM4v7ute; + double BSIM4v7ucste; + double BSIM4v7voff; + double BSIM4v7tvoff; + double BSIM4v7tnfactor; /* v4.7 Temp dep of leakage current */ + double BSIM4v7teta0; /* v4.7 temp dep of leakage current */ + double BSIM4v7tvoffcv; /* v4.7 temp dep of leakage current */ + double BSIM4v7minv; + double BSIM4v7minvcv; + double BSIM4v7vfb; + double BSIM4v7delta; + double BSIM4v7rdsw; + double BSIM4v7rds0; + double BSIM4v7rs0; + double BSIM4v7rd0; + double BSIM4v7rsw; + double BSIM4v7rdw; + double BSIM4v7prwg; + double BSIM4v7prwb; + double BSIM4v7prt; + double BSIM4v7eta0; + double BSIM4v7etab; + double BSIM4v7pclm; + double BSIM4v7pdibl1; + double BSIM4v7pdibl2; + double BSIM4v7pdiblb; + double BSIM4v7fprout; + double BSIM4v7pdits; + double BSIM4v7pditsd; + double BSIM4v7pscbe1; + double BSIM4v7pscbe2; + double BSIM4v7pvag; + double BSIM4v7wr; + double BSIM4v7dwg; + double BSIM4v7dwb; + double BSIM4v7b0; + double BSIM4v7b1; + double BSIM4v7alpha0; + double BSIM4v7alpha1; + double BSIM4v7beta0; + double BSIM4v7agidl; + double BSIM4v7bgidl; + double BSIM4v7cgidl; + double BSIM4v7egidl; + double BSIM4v7fgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7kgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7rgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7agisl; + double BSIM4v7bgisl; + double BSIM4v7cgisl; + double BSIM4v7egisl; + double BSIM4v7fgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7kgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7rgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7aigc; + double BSIM4v7bigc; + double BSIM4v7cigc; + double BSIM4v7aigs; + double BSIM4v7bigs; + double BSIM4v7cigs; + double BSIM4v7aigd; + double BSIM4v7bigd; + double BSIM4v7cigd; + double BSIM4v7aigbacc; + double BSIM4v7bigbacc; + double BSIM4v7cigbacc; + double BSIM4v7aigbinv; + double BSIM4v7bigbinv; + double BSIM4v7cigbinv; + double BSIM4v7nigc; + double BSIM4v7nigbacc; + double BSIM4v7nigbinv; + double BSIM4v7ntox; + double BSIM4v7eigbinv; + double BSIM4v7pigcd; + double BSIM4v7poxedge; + double BSIM4v7xrcrg1; + double BSIM4v7xrcrg2; + double BSIM4v7lambda; /* overshoot */ + double BSIM4v7vtl; /* thermal velocity limit */ + double BSIM4v7xn; /* back scattering parameter */ + double BSIM4v7lc; /* back scattering parameter */ + double BSIM4v7tfactor; /* ballistic transportation factor */ + double BSIM4v7vfbsdoff; /* S/D flatband offset voltage */ + double BSIM4v7tvfbsdoff; /* added for stress effect */ - double BSIM4ku0; - double BSIM4kvth0; - double BSIM4ku0temp; - double BSIM4rho_ref; - double BSIM4inv_od_ref; + double BSIM4v7ku0; + double BSIM4v7kvth0; + double BSIM4v7ku0temp; + double BSIM4v7rho_ref; + double BSIM4v7inv_od_ref; /* added for well proximity effect */ - double BSIM4kvth0we; - double BSIM4k2we; - double BSIM4ku0we; + double BSIM4v7kvth0we; + double BSIM4v7k2we; + double BSIM4v7ku0we; /* CV model */ - double BSIM4cgsl; - double BSIM4cgdl; - double BSIM4ckappas; - double BSIM4ckappad; - double BSIM4cf; - double BSIM4clc; - double BSIM4cle; - double BSIM4vfbcv; - double BSIM4noff; - double BSIM4voffcv; - double BSIM4acde; - double BSIM4moin; + double BSIM4v7cgsl; + double BSIM4v7cgdl; + double BSIM4v7ckappas; + double BSIM4v7ckappad; + double BSIM4v7cf; + double BSIM4v7clc; + double BSIM4v7cle; + double BSIM4v7vfbcv; + double BSIM4v7noff; + double BSIM4v7voffcv; + double BSIM4v7acde; + double BSIM4v7moin; /* Pre-calculated constants */ - double BSIM4dw; - double BSIM4dl; - double BSIM4leff; - double BSIM4weff; + double BSIM4v7dw; + double BSIM4v7dl; + double BSIM4v7leff; + double BSIM4v7weff; - double BSIM4dwc; - double BSIM4dlc; - double BSIM4dwj; - double BSIM4leffCV; - double BSIM4weffCV; - double BSIM4weffCJ; - double BSIM4abulkCVfactor; - double BSIM4cgso; - double BSIM4cgdo; - double BSIM4cgbo; + double BSIM4v7dwc; + double BSIM4v7dlc; + double BSIM4v7dwj; + double BSIM4v7leffCV; + double BSIM4v7weffCV; + double BSIM4v7weffCJ; + double BSIM4v7abulkCVfactor; + double BSIM4v7cgso; + double BSIM4v7cgdo; + double BSIM4v7cgbo; - double BSIM4u0temp; - double BSIM4vsattemp; - double BSIM4sqrtPhi; - double BSIM4phis3; - double BSIM4Xdep0; - double BSIM4sqrtXdep0; - double BSIM4theta0vb0; - double BSIM4thetaRout; - double BSIM4mstar; - double BSIM4VgsteffVth; - double BSIM4mstarcv; - double BSIM4voffcbn; - double BSIM4voffcbncv; - double BSIM4rdswmin; - double BSIM4rdwmin; - double BSIM4rswmin; - double BSIM4vfbsd; + double BSIM4v7u0temp; + double BSIM4v7vsattemp; + double BSIM4v7sqrtPhi; + double BSIM4v7phis3; + double BSIM4v7Xdep0; + double BSIM4v7sqrtXdep0; + double BSIM4v7theta0vb0; + double BSIM4v7thetaRout; + double BSIM4v7mstar; + double BSIM4v7VgsteffVth; + double BSIM4v7mstarcv; + double BSIM4v7voffcbn; + double BSIM4v7voffcbncv; + double BSIM4v7rdswmin; + double BSIM4v7rdwmin; + double BSIM4v7rswmin; + double BSIM4v7vfbsd; - double BSIM4cof1; - double BSIM4cof2; - double BSIM4cof3; - double BSIM4cof4; - double BSIM4cdep0; - double BSIM4ToxRatio; - double BSIM4Aechvb; - double BSIM4Bechvb; - double BSIM4ToxRatioEdge; - double BSIM4AechvbEdgeS; - double BSIM4AechvbEdgeD; - double BSIM4BechvbEdge; - double BSIM4ldeb; - double BSIM4k1ox; - double BSIM4k2ox; - double BSIM4vfbzbfactor; - double BSIM4dvtp2factor; /* v4.7 */ + double BSIM4v7cof1; + double BSIM4v7cof2; + double BSIM4v7cof3; + double BSIM4v7cof4; + double BSIM4v7cdep0; + double BSIM4v7ToxRatio; + double BSIM4v7Aechvb; + double BSIM4v7Bechvb; + double BSIM4v7ToxRatioEdge; + double BSIM4v7AechvbEdgeS; + double BSIM4v7AechvbEdgeD; + double BSIM4v7BechvbEdge; + double BSIM4v7ldeb; + double BSIM4v7k1ox; + double BSIM4v7k2ox; + double BSIM4v7vfbzbfactor; + double BSIM4v7dvtp2factor; /* v4.7 */ struct bsim4SizeDependParam *pNext; }; -typedef struct sBSIM4model +typedef struct sBSIM4v7model { - int BSIM4modType; - struct sBSIM4model *BSIM4nextModel; - BSIM4instance *BSIM4instances; - IFuid BSIM4modName; + int BSIM4v7modType; + struct sBSIM4v7model *BSIM4v7nextModel; + BSIM4v7instance *BSIM4v7instances; + IFuid BSIM4v7modName; /* --- end of generic struct GENmodel --- */ - int BSIM4type; + int BSIM4v7type; - int BSIM4mobMod; - int BSIM4cvchargeMod; - int BSIM4capMod; - int BSIM4dioMod; - int BSIM4trnqsMod; - int BSIM4acnqsMod; - int BSIM4fnoiMod; - int BSIM4tnoiMod; - int BSIM4rdsMod; - int BSIM4rbodyMod; - int BSIM4rgateMod; - int BSIM4perMod; - int BSIM4geoMod; - int BSIM4rgeoMod; - int BSIM4mtrlMod; - int BSIM4mtrlCompatMod; /* v4.7 */ - int BSIM4gidlMod; /* v4.7 New GIDL/GISL */ - int BSIM4igcMod; - int BSIM4igbMod; - int BSIM4tempMod; - int BSIM4binUnit; - int BSIM4paramChk; - char *BSIM4version; - double BSIM4eot; - double BSIM4vddeot; - double BSIM4tempeot; - double BSIM4leffeot; - double BSIM4weffeot; - double BSIM4ados; - double BSIM4bdos; - double BSIM4toxe; - double BSIM4toxp; - double BSIM4toxm; - double BSIM4dtox; - double BSIM4epsrox; - double BSIM4cdsc; - double BSIM4cdscb; - double BSIM4cdscd; - double BSIM4cit; - double BSIM4nfactor; - double BSIM4xj; - double BSIM4vsat; - double BSIM4at; - double BSIM4a0; - double BSIM4ags; - double BSIM4a1; - double BSIM4a2; - double BSIM4keta; - double BSIM4nsub; - double BSIM4phig; - double BSIM4epsrgate; - double BSIM4easub; - double BSIM4epsrsub; - double BSIM4ni0sub; - double BSIM4bg0sub; - double BSIM4tbgasub; - double BSIM4tbgbsub; - double BSIM4ndep; - double BSIM4nsd; - double BSIM4phin; - double BSIM4ngate; - double BSIM4gamma1; - double BSIM4gamma2; - double BSIM4vbx; - double BSIM4vbm; - double BSIM4xt; - double BSIM4k1; - double BSIM4kt1; - double BSIM4kt1l; - double BSIM4kt2; - double BSIM4k2; - double BSIM4k3; - double BSIM4k3b; - double BSIM4w0; - double BSIM4dvtp0; - double BSIM4dvtp1; - double BSIM4dvtp2; /* New DIBL/Rout */ - double BSIM4dvtp3; - double BSIM4dvtp4; - double BSIM4dvtp5; - double BSIM4lpe0; - double BSIM4lpeb; - double BSIM4dvt0; - double BSIM4dvt1; - double BSIM4dvt2; - double BSIM4dvt0w; - double BSIM4dvt1w; - double BSIM4dvt2w; - double BSIM4drout; - double BSIM4dsub; - double BSIM4vth0; - double BSIM4eu; - double BSIM4ucs; - double BSIM4ua; - double BSIM4ua1; - double BSIM4ub; - double BSIM4ub1; - double BSIM4uc; - double BSIM4uc1; - double BSIM4ud; - double BSIM4ud1; - double BSIM4up; - double BSIM4lp; - double BSIM4u0; - double BSIM4ute; - double BSIM4ucste; - double BSIM4voff; - double BSIM4tvoff; - double BSIM4tnfactor; /* v4.7 Temp dep of leakage current */ - double BSIM4teta0; /* v4.7 temp dep of leakage current */ - double BSIM4tvoffcv; /* v4.7 temp dep of leakage current */ - double BSIM4minv; - double BSIM4minvcv; - double BSIM4voffl; - double BSIM4voffcvl; - double BSIM4delta; - double BSIM4rdsw; - double BSIM4rdswmin; - double BSIM4rdwmin; - double BSIM4rswmin; - double BSIM4rsw; - double BSIM4rdw; - double BSIM4prwg; - double BSIM4prwb; - double BSIM4prt; - double BSIM4eta0; - double BSIM4etab; - double BSIM4pclm; - double BSIM4pdibl1; - double BSIM4pdibl2; - double BSIM4pdiblb; - double BSIM4fprout; - double BSIM4pdits; - double BSIM4pditsd; - double BSIM4pditsl; - double BSIM4pscbe1; - double BSIM4pscbe2; - double BSIM4pvag; - double BSIM4wr; - double BSIM4dwg; - double BSIM4dwb; - double BSIM4b0; - double BSIM4b1; - double BSIM4alpha0; - double BSIM4alpha1; - double BSIM4beta0; - double BSIM4agidl; - double BSIM4bgidl; - double BSIM4cgidl; - double BSIM4egidl; - double BSIM4fgidl; /* v4.7 New GIDL/GISL */ - double BSIM4kgidl; /* v4.7 New GIDL/GISL */ - double BSIM4rgidl; /* v4.7 New GIDL/GISL */ - double BSIM4agisl; - double BSIM4bgisl; - double BSIM4cgisl; - double BSIM4egisl; - double BSIM4fgisl; /* v4.7 New GIDL/GISL */ - double BSIM4kgisl; /* v4.7 New GIDL/GISL */ - double BSIM4rgisl; /* v4.7 New GIDL/GISL */ - double BSIM4aigc; - double BSIM4bigc; - double BSIM4cigc; - double BSIM4aigsd; - double BSIM4bigsd; - double BSIM4cigsd; - double BSIM4aigs; - double BSIM4bigs; - double BSIM4cigs; - double BSIM4aigd; - double BSIM4bigd; - double BSIM4cigd; - double BSIM4aigbacc; - double BSIM4bigbacc; - double BSIM4cigbacc; - double BSIM4aigbinv; - double BSIM4bigbinv; - double BSIM4cigbinv; - double BSIM4nigc; - double BSIM4nigbacc; - double BSIM4nigbinv; - double BSIM4ntox; - double BSIM4eigbinv; - double BSIM4pigcd; - double BSIM4poxedge; - double BSIM4toxref; - double BSIM4ijthdfwd; - double BSIM4ijthsfwd; - double BSIM4ijthdrev; - double BSIM4ijthsrev; - double BSIM4xjbvd; - double BSIM4xjbvs; - double BSIM4bvd; - double BSIM4bvs; + int BSIM4v7mobMod; + int BSIM4v7cvchargeMod; + int BSIM4v7capMod; + int BSIM4v7dioMod; + int BSIM4v7trnqsMod; + int BSIM4v7acnqsMod; + int BSIM4v7fnoiMod; + int BSIM4v7tnoiMod; + int BSIM4v7rdsMod; + int BSIM4v7rbodyMod; + int BSIM4v7rgateMod; + int BSIM4v7perMod; + int BSIM4v7geoMod; + int BSIM4v7rgeoMod; + int BSIM4v7mtrlMod; + int BSIM4v7mtrlCompatMod; /* v4.7 */ + int BSIM4v7gidlMod; /* v4.7 New GIDL/GISL */ + int BSIM4v7igcMod; + int BSIM4v7igbMod; + int BSIM4v7tempMod; + int BSIM4v7binUnit; + int BSIM4v7paramChk; + char *BSIM4v7version; + double BSIM4v7eot; + double BSIM4v7vddeot; + double BSIM4v7tempeot; + double BSIM4v7leffeot; + double BSIM4v7weffeot; + double BSIM4v7ados; + double BSIM4v7bdos; + double BSIM4v7toxe; + double BSIM4v7toxp; + double BSIM4v7toxm; + double BSIM4v7dtox; + double BSIM4v7epsrox; + double BSIM4v7cdsc; + double BSIM4v7cdscb; + double BSIM4v7cdscd; + double BSIM4v7cit; + double BSIM4v7nfactor; + double BSIM4v7xj; + double BSIM4v7vsat; + double BSIM4v7at; + double BSIM4v7a0; + double BSIM4v7ags; + double BSIM4v7a1; + double BSIM4v7a2; + double BSIM4v7keta; + double BSIM4v7nsub; + double BSIM4v7phig; + double BSIM4v7epsrgate; + double BSIM4v7easub; + double BSIM4v7epsrsub; + double BSIM4v7ni0sub; + double BSIM4v7bg0sub; + double BSIM4v7tbgasub; + double BSIM4v7tbgbsub; + double BSIM4v7ndep; + double BSIM4v7nsd; + double BSIM4v7phin; + double BSIM4v7ngate; + double BSIM4v7gamma1; + double BSIM4v7gamma2; + double BSIM4v7vbx; + double BSIM4v7vbm; + double BSIM4v7xt; + double BSIM4v7k1; + double BSIM4v7kt1; + double BSIM4v7kt1l; + double BSIM4v7kt2; + double BSIM4v7k2; + double BSIM4v7k3; + double BSIM4v7k3b; + double BSIM4v7w0; + double BSIM4v7dvtp0; + double BSIM4v7dvtp1; + double BSIM4v7dvtp2; /* New DIBL/Rout */ + double BSIM4v7dvtp3; + double BSIM4v7dvtp4; + double BSIM4v7dvtp5; + double BSIM4v7lpe0; + double BSIM4v7lpeb; + double BSIM4v7dvt0; + double BSIM4v7dvt1; + double BSIM4v7dvt2; + double BSIM4v7dvt0w; + double BSIM4v7dvt1w; + double BSIM4v7dvt2w; + double BSIM4v7drout; + double BSIM4v7dsub; + double BSIM4v7vth0; + double BSIM4v7eu; + double BSIM4v7ucs; + double BSIM4v7ua; + double BSIM4v7ua1; + double BSIM4v7ub; + double BSIM4v7ub1; + double BSIM4v7uc; + double BSIM4v7uc1; + double BSIM4v7ud; + double BSIM4v7ud1; + double BSIM4v7up; + double BSIM4v7lp; + double BSIM4v7u0; + double BSIM4v7ute; + double BSIM4v7ucste; + double BSIM4v7voff; + double BSIM4v7tvoff; + double BSIM4v7tnfactor; /* v4.7 Temp dep of leakage current */ + double BSIM4v7teta0; /* v4.7 temp dep of leakage current */ + double BSIM4v7tvoffcv; /* v4.7 temp dep of leakage current */ + double BSIM4v7minv; + double BSIM4v7minvcv; + double BSIM4v7voffl; + double BSIM4v7voffcvl; + double BSIM4v7delta; + double BSIM4v7rdsw; + double BSIM4v7rdswmin; + double BSIM4v7rdwmin; + double BSIM4v7rswmin; + double BSIM4v7rsw; + double BSIM4v7rdw; + double BSIM4v7prwg; + double BSIM4v7prwb; + double BSIM4v7prt; + double BSIM4v7eta0; + double BSIM4v7etab; + double BSIM4v7pclm; + double BSIM4v7pdibl1; + double BSIM4v7pdibl2; + double BSIM4v7pdiblb; + double BSIM4v7fprout; + double BSIM4v7pdits; + double BSIM4v7pditsd; + double BSIM4v7pditsl; + double BSIM4v7pscbe1; + double BSIM4v7pscbe2; + double BSIM4v7pvag; + double BSIM4v7wr; + double BSIM4v7dwg; + double BSIM4v7dwb; + double BSIM4v7b0; + double BSIM4v7b1; + double BSIM4v7alpha0; + double BSIM4v7alpha1; + double BSIM4v7beta0; + double BSIM4v7agidl; + double BSIM4v7bgidl; + double BSIM4v7cgidl; + double BSIM4v7egidl; + double BSIM4v7fgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7kgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7rgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7agisl; + double BSIM4v7bgisl; + double BSIM4v7cgisl; + double BSIM4v7egisl; + double BSIM4v7fgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7kgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7rgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7aigc; + double BSIM4v7bigc; + double BSIM4v7cigc; + double BSIM4v7aigsd; + double BSIM4v7bigsd; + double BSIM4v7cigsd; + double BSIM4v7aigs; + double BSIM4v7bigs; + double BSIM4v7cigs; + double BSIM4v7aigd; + double BSIM4v7bigd; + double BSIM4v7cigd; + double BSIM4v7aigbacc; + double BSIM4v7bigbacc; + double BSIM4v7cigbacc; + double BSIM4v7aigbinv; + double BSIM4v7bigbinv; + double BSIM4v7cigbinv; + double BSIM4v7nigc; + double BSIM4v7nigbacc; + double BSIM4v7nigbinv; + double BSIM4v7ntox; + double BSIM4v7eigbinv; + double BSIM4v7pigcd; + double BSIM4v7poxedge; + double BSIM4v7toxref; + double BSIM4v7ijthdfwd; + double BSIM4v7ijthsfwd; + double BSIM4v7ijthdrev; + double BSIM4v7ijthsrev; + double BSIM4v7xjbvd; + double BSIM4v7xjbvs; + double BSIM4v7bvd; + double BSIM4v7bvs; - double BSIM4jtss; - double BSIM4jtsd; - double BSIM4jtssws; - double BSIM4jtsswd; - double BSIM4jtsswgs; - double BSIM4jtsswgd; - double BSIM4jtweff; - double BSIM4njts; - double BSIM4njtssw; - double BSIM4njtsswg; - double BSIM4njtsd; - double BSIM4njtsswd; - double BSIM4njtsswgd; - double BSIM4xtss; - double BSIM4xtsd; - double BSIM4xtssws; - double BSIM4xtsswd; - double BSIM4xtsswgs; - double BSIM4xtsswgd; - double BSIM4tnjts; - double BSIM4tnjtssw; - double BSIM4tnjtsswg; - double BSIM4tnjtsd; - double BSIM4tnjtsswd; - double BSIM4tnjtsswgd; - double BSIM4vtss; - double BSIM4vtsd; - double BSIM4vtssws; - double BSIM4vtsswd; - double BSIM4vtsswgs; - double BSIM4vtsswgd; + double BSIM4v7jtss; + double BSIM4v7jtsd; + double BSIM4v7jtssws; + double BSIM4v7jtsswd; + double BSIM4v7jtsswgs; + double BSIM4v7jtsswgd; + double BSIM4v7jtweff; + double BSIM4v7njts; + double BSIM4v7njtssw; + double BSIM4v7njtsswg; + double BSIM4v7njtsd; + double BSIM4v7njtsswd; + double BSIM4v7njtsswgd; + double BSIM4v7xtss; + double BSIM4v7xtsd; + double BSIM4v7xtssws; + double BSIM4v7xtsswd; + double BSIM4v7xtsswgs; + double BSIM4v7xtsswgd; + double BSIM4v7tnjts; + double BSIM4v7tnjtssw; + double BSIM4v7tnjtsswg; + double BSIM4v7tnjtsd; + double BSIM4v7tnjtsswd; + double BSIM4v7tnjtsswgd; + double BSIM4v7vtss; + double BSIM4v7vtsd; + double BSIM4v7vtssws; + double BSIM4v7vtsswd; + double BSIM4v7vtsswgs; + double BSIM4v7vtsswgd; - double BSIM4xrcrg1; - double BSIM4xrcrg2; - double BSIM4lambda; - double BSIM4vtl; - double BSIM4lc; - double BSIM4xn; - double BSIM4vfbsdoff; /* S/D flatband offset voltage */ - double BSIM4lintnoi; /* lint offset for noise calculation */ - double BSIM4tvfbsdoff; + double BSIM4v7xrcrg1; + double BSIM4v7xrcrg2; + double BSIM4v7lambda; + double BSIM4v7vtl; + double BSIM4v7lc; + double BSIM4v7xn; + double BSIM4v7vfbsdoff; /* S/D flatband offset voltage */ + double BSIM4v7lintnoi; /* lint offset for noise calculation */ + double BSIM4v7tvfbsdoff; - double BSIM4vfb; - double BSIM4gbmin; - double BSIM4rbdb; - double BSIM4rbsb; - double BSIM4rbpb; - double BSIM4rbps; - double BSIM4rbpd; + double BSIM4v7vfb; + double BSIM4v7gbmin; + double BSIM4v7rbdb; + double BSIM4v7rbsb; + double BSIM4v7rbpb; + double BSIM4v7rbps; + double BSIM4v7rbpd; - double BSIM4rbps0; - double BSIM4rbpsl; - double BSIM4rbpsw; - double BSIM4rbpsnf; + double BSIM4v7rbps0; + double BSIM4v7rbpsl; + double BSIM4v7rbpsw; + double BSIM4v7rbpsnf; - double BSIM4rbpd0; - double BSIM4rbpdl; - double BSIM4rbpdw; - double BSIM4rbpdnf; + double BSIM4v7rbpd0; + double BSIM4v7rbpdl; + double BSIM4v7rbpdw; + double BSIM4v7rbpdnf; - double BSIM4rbpbx0; - double BSIM4rbpbxl; - double BSIM4rbpbxw; - double BSIM4rbpbxnf; - double BSIM4rbpby0; - double BSIM4rbpbyl; - double BSIM4rbpbyw; - double BSIM4rbpbynf; + double BSIM4v7rbpbx0; + double BSIM4v7rbpbxl; + double BSIM4v7rbpbxw; + double BSIM4v7rbpbxnf; + double BSIM4v7rbpby0; + double BSIM4v7rbpbyl; + double BSIM4v7rbpbyw; + double BSIM4v7rbpbynf; - double BSIM4rbsbx0; - double BSIM4rbsby0; - double BSIM4rbdbx0; - double BSIM4rbdby0; + double BSIM4v7rbsbx0; + double BSIM4v7rbsby0; + double BSIM4v7rbdbx0; + double BSIM4v7rbdby0; - double BSIM4rbsdbxl; - double BSIM4rbsdbxw; - double BSIM4rbsdbxnf; - double BSIM4rbsdbyl; - double BSIM4rbsdbyw; - double BSIM4rbsdbynf; + double BSIM4v7rbsdbxl; + double BSIM4v7rbsdbxw; + double BSIM4v7rbsdbxnf; + double BSIM4v7rbsdbyl; + double BSIM4v7rbsdbyw; + double BSIM4v7rbsdbynf; - double BSIM4tnoia; - double BSIM4tnoib; - double BSIM4tnoic; - double BSIM4rnoia; - double BSIM4rnoib; - double BSIM4rnoic; - double BSIM4ntnoi; + double BSIM4v7tnoia; + double BSIM4v7tnoib; + double BSIM4v7tnoic; + double BSIM4v7rnoia; + double BSIM4v7rnoib; + double BSIM4v7rnoic; + double BSIM4v7ntnoi; /* CV model and Parasitics */ - double BSIM4cgsl; - double BSIM4cgdl; - double BSIM4ckappas; - double BSIM4ckappad; - double BSIM4cf; - double BSIM4vfbcv; - double BSIM4clc; - double BSIM4cle; - double BSIM4dwc; - double BSIM4dlc; - double BSIM4xw; - double BSIM4xl; - double BSIM4dlcig; - double BSIM4dlcigd; - double BSIM4dwj; - double BSIM4noff; - double BSIM4voffcv; - double BSIM4acde; - double BSIM4moin; - double BSIM4tcj; - double BSIM4tcjsw; - double BSIM4tcjswg; - double BSIM4tpb; - double BSIM4tpbsw; - double BSIM4tpbswg; - double BSIM4dmcg; - double BSIM4dmci; - double BSIM4dmdg; - double BSIM4dmcgt; - double BSIM4xgw; - double BSIM4xgl; - double BSIM4rshg; - double BSIM4ngcon; + double BSIM4v7cgsl; + double BSIM4v7cgdl; + double BSIM4v7ckappas; + double BSIM4v7ckappad; + double BSIM4v7cf; + double BSIM4v7vfbcv; + double BSIM4v7clc; + double BSIM4v7cle; + double BSIM4v7dwc; + double BSIM4v7dlc; + double BSIM4v7xw; + double BSIM4v7xl; + double BSIM4v7dlcig; + double BSIM4v7dlcigd; + double BSIM4v7dwj; + double BSIM4v7noff; + double BSIM4v7voffcv; + double BSIM4v7acde; + double BSIM4v7moin; + double BSIM4v7tcj; + double BSIM4v7tcjsw; + double BSIM4v7tcjswg; + double BSIM4v7tpb; + double BSIM4v7tpbsw; + double BSIM4v7tpbswg; + double BSIM4v7dmcg; + double BSIM4v7dmci; + double BSIM4v7dmdg; + double BSIM4v7dmcgt; + double BSIM4v7xgw; + double BSIM4v7xgl; + double BSIM4v7rshg; + double BSIM4v7ngcon; /* Length Dependence */ - double BSIM4lcdsc; - double BSIM4lcdscb; - double BSIM4lcdscd; - double BSIM4lcit; - double BSIM4lnfactor; - double BSIM4lxj; - double BSIM4lvsat; - double BSIM4lat; - double BSIM4la0; - double BSIM4lags; - double BSIM4la1; - double BSIM4la2; - double BSIM4lketa; - double BSIM4lnsub; - double BSIM4lndep; - double BSIM4lnsd; - double BSIM4lphin; - double BSIM4lngate; - double BSIM4lgamma1; - double BSIM4lgamma2; - double BSIM4lvbx; - double BSIM4lvbm; - double BSIM4lxt; - double BSIM4lk1; - double BSIM4lkt1; - double BSIM4lkt1l; - double BSIM4lkt2; - double BSIM4lk2; - double BSIM4lk3; - double BSIM4lk3b; - double BSIM4lw0; - double BSIM4ldvtp0; - double BSIM4ldvtp1; - double BSIM4ldvtp2; /* New DIBL/Rout */ - double BSIM4ldvtp3; - double BSIM4ldvtp4; - double BSIM4ldvtp5; - double BSIM4llpe0; - double BSIM4llpeb; - double BSIM4ldvt0; - double BSIM4ldvt1; - double BSIM4ldvt2; - double BSIM4ldvt0w; - double BSIM4ldvt1w; - double BSIM4ldvt2w; - double BSIM4ldrout; - double BSIM4ldsub; - double BSIM4lvth0; - double BSIM4lua; - double BSIM4lua1; - double BSIM4lub; - double BSIM4lub1; - double BSIM4luc; - double BSIM4luc1; - double BSIM4lud; - double BSIM4lud1; - double BSIM4lup; - double BSIM4llp; - double BSIM4lu0; - double BSIM4leu; - double BSIM4lucs; - double BSIM4lute; - double BSIM4lucste; - double BSIM4lvoff; - double BSIM4ltvoff; - double BSIM4ltnfactor; /* v4.7 Temp dep of leakage current */ - double BSIM4lteta0; /* v4.7 temp dep of leakage current */ - double BSIM4ltvoffcv; /* v4.7 temp dep of leakage current */ - double BSIM4lminv; - double BSIM4lminvcv; - double BSIM4ldelta; - double BSIM4lrdsw; - double BSIM4lrsw; - double BSIM4lrdw; - double BSIM4lprwg; - double BSIM4lprwb; - double BSIM4lprt; - double BSIM4leta0; - double BSIM4letab; - double BSIM4lpclm; - double BSIM4lpdibl1; - double BSIM4lpdibl2; - double BSIM4lpdiblb; - double BSIM4lfprout; - double BSIM4lpdits; - double BSIM4lpditsd; - double BSIM4lpscbe1; - double BSIM4lpscbe2; - double BSIM4lpvag; - double BSIM4lwr; - double BSIM4ldwg; - double BSIM4ldwb; - double BSIM4lb0; - double BSIM4lb1; - double BSIM4lalpha0; - double BSIM4lalpha1; - double BSIM4lbeta0; - double BSIM4lvfb; - double BSIM4lagidl; - double BSIM4lbgidl; - double BSIM4lcgidl; - double BSIM4legidl; - double BSIM4lfgidl; /* v4.7 New GIDL/GISL */ - double BSIM4lkgidl; /* v4.7 New GIDL/GISL */ - double BSIM4lrgidl; /* v4.7 New GIDL/GISL */ - double BSIM4lagisl; - double BSIM4lbgisl; - double BSIM4lcgisl; - double BSIM4legisl; - double BSIM4lfgisl; /* v4.7 New GIDL/GISL */ - double BSIM4lkgisl; /* v4.7 New GIDL/GISL */ - double BSIM4lrgisl; /* v4.7 New GIDL/GISL */ - double BSIM4laigc; - double BSIM4lbigc; - double BSIM4lcigc; - double BSIM4laigsd; - double BSIM4lbigsd; - double BSIM4lcigsd; - double BSIM4laigs; - double BSIM4lbigs; - double BSIM4lcigs; - double BSIM4laigd; - double BSIM4lbigd; - double BSIM4lcigd; - double BSIM4laigbacc; - double BSIM4lbigbacc; - double BSIM4lcigbacc; - double BSIM4laigbinv; - double BSIM4lbigbinv; - double BSIM4lcigbinv; - double BSIM4lnigc; - double BSIM4lnigbacc; - double BSIM4lnigbinv; - double BSIM4lntox; - double BSIM4leigbinv; - double BSIM4lpigcd; - double BSIM4lpoxedge; - double BSIM4lxrcrg1; - double BSIM4lxrcrg2; - double BSIM4llambda; - double BSIM4lvtl; - double BSIM4lxn; - double BSIM4lvfbsdoff; - double BSIM4ltvfbsdoff; + double BSIM4v7lcdsc; + double BSIM4v7lcdscb; + double BSIM4v7lcdscd; + double BSIM4v7lcit; + double BSIM4v7lnfactor; + double BSIM4v7lxj; + double BSIM4v7lvsat; + double BSIM4v7lat; + double BSIM4v7la0; + double BSIM4v7lags; + double BSIM4v7la1; + double BSIM4v7la2; + double BSIM4v7lketa; + double BSIM4v7lnsub; + double BSIM4v7lndep; + double BSIM4v7lnsd; + double BSIM4v7lphin; + double BSIM4v7lngate; + double BSIM4v7lgamma1; + double BSIM4v7lgamma2; + double BSIM4v7lvbx; + double BSIM4v7lvbm; + double BSIM4v7lxt; + double BSIM4v7lk1; + double BSIM4v7lkt1; + double BSIM4v7lkt1l; + double BSIM4v7lkt2; + double BSIM4v7lk2; + double BSIM4v7lk3; + double BSIM4v7lk3b; + double BSIM4v7lw0; + double BSIM4v7ldvtp0; + double BSIM4v7ldvtp1; + double BSIM4v7ldvtp2; /* New DIBL/Rout */ + double BSIM4v7ldvtp3; + double BSIM4v7ldvtp4; + double BSIM4v7ldvtp5; + double BSIM4v7llpe0; + double BSIM4v7llpeb; + double BSIM4v7ldvt0; + double BSIM4v7ldvt1; + double BSIM4v7ldvt2; + double BSIM4v7ldvt0w; + double BSIM4v7ldvt1w; + double BSIM4v7ldvt2w; + double BSIM4v7ldrout; + double BSIM4v7ldsub; + double BSIM4v7lvth0; + double BSIM4v7lua; + double BSIM4v7lua1; + double BSIM4v7lub; + double BSIM4v7lub1; + double BSIM4v7luc; + double BSIM4v7luc1; + double BSIM4v7lud; + double BSIM4v7lud1; + double BSIM4v7lup; + double BSIM4v7llp; + double BSIM4v7lu0; + double BSIM4v7leu; + double BSIM4v7lucs; + double BSIM4v7lute; + double BSIM4v7lucste; + double BSIM4v7lvoff; + double BSIM4v7ltvoff; + double BSIM4v7ltnfactor; /* v4.7 Temp dep of leakage current */ + double BSIM4v7lteta0; /* v4.7 temp dep of leakage current */ + double BSIM4v7ltvoffcv; /* v4.7 temp dep of leakage current */ + double BSIM4v7lminv; + double BSIM4v7lminvcv; + double BSIM4v7ldelta; + double BSIM4v7lrdsw; + double BSIM4v7lrsw; + double BSIM4v7lrdw; + double BSIM4v7lprwg; + double BSIM4v7lprwb; + double BSIM4v7lprt; + double BSIM4v7leta0; + double BSIM4v7letab; + double BSIM4v7lpclm; + double BSIM4v7lpdibl1; + double BSIM4v7lpdibl2; + double BSIM4v7lpdiblb; + double BSIM4v7lfprout; + double BSIM4v7lpdits; + double BSIM4v7lpditsd; + double BSIM4v7lpscbe1; + double BSIM4v7lpscbe2; + double BSIM4v7lpvag; + double BSIM4v7lwr; + double BSIM4v7ldwg; + double BSIM4v7ldwb; + double BSIM4v7lb0; + double BSIM4v7lb1; + double BSIM4v7lalpha0; + double BSIM4v7lalpha1; + double BSIM4v7lbeta0; + double BSIM4v7lvfb; + double BSIM4v7lagidl; + double BSIM4v7lbgidl; + double BSIM4v7lcgidl; + double BSIM4v7legidl; + double BSIM4v7lfgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7lkgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7lrgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7lagisl; + double BSIM4v7lbgisl; + double BSIM4v7lcgisl; + double BSIM4v7legisl; + double BSIM4v7lfgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7lkgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7lrgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7laigc; + double BSIM4v7lbigc; + double BSIM4v7lcigc; + double BSIM4v7laigsd; + double BSIM4v7lbigsd; + double BSIM4v7lcigsd; + double BSIM4v7laigs; + double BSIM4v7lbigs; + double BSIM4v7lcigs; + double BSIM4v7laigd; + double BSIM4v7lbigd; + double BSIM4v7lcigd; + double BSIM4v7laigbacc; + double BSIM4v7lbigbacc; + double BSIM4v7lcigbacc; + double BSIM4v7laigbinv; + double BSIM4v7lbigbinv; + double BSIM4v7lcigbinv; + double BSIM4v7lnigc; + double BSIM4v7lnigbacc; + double BSIM4v7lnigbinv; + double BSIM4v7lntox; + double BSIM4v7leigbinv; + double BSIM4v7lpigcd; + double BSIM4v7lpoxedge; + double BSIM4v7lxrcrg1; + double BSIM4v7lxrcrg2; + double BSIM4v7llambda; + double BSIM4v7lvtl; + double BSIM4v7lxn; + double BSIM4v7lvfbsdoff; + double BSIM4v7ltvfbsdoff; /* CV model */ - double BSIM4lcgsl; - double BSIM4lcgdl; - double BSIM4lckappas; - double BSIM4lckappad; - double BSIM4lcf; - double BSIM4lclc; - double BSIM4lcle; - double BSIM4lvfbcv; - double BSIM4lnoff; - double BSIM4lvoffcv; - double BSIM4lacde; - double BSIM4lmoin; + double BSIM4v7lcgsl; + double BSIM4v7lcgdl; + double BSIM4v7lckappas; + double BSIM4v7lckappad; + double BSIM4v7lcf; + double BSIM4v7lclc; + double BSIM4v7lcle; + double BSIM4v7lvfbcv; + double BSIM4v7lnoff; + double BSIM4v7lvoffcv; + double BSIM4v7lacde; + double BSIM4v7lmoin; /* Width Dependence */ - double BSIM4wcdsc; - double BSIM4wcdscb; - double BSIM4wcdscd; - double BSIM4wcit; - double BSIM4wnfactor; - double BSIM4wxj; - double BSIM4wvsat; - double BSIM4wat; - double BSIM4wa0; - double BSIM4wags; - double BSIM4wa1; - double BSIM4wa2; - double BSIM4wketa; - double BSIM4wnsub; - double BSIM4wndep; - double BSIM4wnsd; - double BSIM4wphin; - double BSIM4wngate; - double BSIM4wgamma1; - double BSIM4wgamma2; - double BSIM4wvbx; - double BSIM4wvbm; - double BSIM4wxt; - double BSIM4wk1; - double BSIM4wkt1; - double BSIM4wkt1l; - double BSIM4wkt2; - double BSIM4wk2; - double BSIM4wk3; - double BSIM4wk3b; - double BSIM4ww0; - double BSIM4wdvtp0; - double BSIM4wdvtp1; - double BSIM4wdvtp2; /* New DIBL/Rout */ - double BSIM4wdvtp3; - double BSIM4wdvtp4; - double BSIM4wdvtp5; - double BSIM4wlpe0; - double BSIM4wlpeb; - double BSIM4wdvt0; - double BSIM4wdvt1; - double BSIM4wdvt2; - double BSIM4wdvt0w; - double BSIM4wdvt1w; - double BSIM4wdvt2w; - double BSIM4wdrout; - double BSIM4wdsub; - double BSIM4wvth0; - double BSIM4wua; - double BSIM4wua1; - double BSIM4wub; - double BSIM4wub1; - double BSIM4wuc; - double BSIM4wuc1; - double BSIM4wud; - double BSIM4wud1; - double BSIM4wup; - double BSIM4wlp; - double BSIM4wu0; - double BSIM4weu; - double BSIM4wucs; - double BSIM4wute; - double BSIM4wucste; - double BSIM4wvoff; - double BSIM4wtvoff; - double BSIM4wtnfactor; /* v4.7 Temp dep of leakage current */ - double BSIM4wteta0; /* v4.7 temp dep of leakage current */ - double BSIM4wtvoffcv; /* v4.7 temp dep of leakage current */ - double BSIM4wminv; - double BSIM4wminvcv; - double BSIM4wdelta; - double BSIM4wrdsw; - double BSIM4wrsw; - double BSIM4wrdw; - double BSIM4wprwg; - double BSIM4wprwb; - double BSIM4wprt; - double BSIM4weta0; - double BSIM4wetab; - double BSIM4wpclm; - double BSIM4wpdibl1; - double BSIM4wpdibl2; - double BSIM4wpdiblb; - double BSIM4wfprout; - double BSIM4wpdits; - double BSIM4wpditsd; - double BSIM4wpscbe1; - double BSIM4wpscbe2; - double BSIM4wpvag; - double BSIM4wwr; - double BSIM4wdwg; - double BSIM4wdwb; - double BSIM4wb0; - double BSIM4wb1; - double BSIM4walpha0; - double BSIM4walpha1; - double BSIM4wbeta0; - double BSIM4wvfb; - double BSIM4wagidl; - double BSIM4wbgidl; - double BSIM4wcgidl; - double BSIM4wegidl; - double BSIM4wfgidl; /* v4.7 New GIDL/GISL */ - double BSIM4wkgidl; /* v4.7 New GIDL/GISL */ - double BSIM4wrgidl; /* v4.7 New GIDL/GISL */ - double BSIM4wagisl; - double BSIM4wbgisl; - double BSIM4wcgisl; - double BSIM4wegisl; - double BSIM4wfgisl; /* v4.7 New GIDL/GISL */ - double BSIM4wkgisl; /* v4.7 New GIDL/GISL */ - double BSIM4wrgisl; /* v4.7 New GIDL/GISL */ - double BSIM4waigc; - double BSIM4wbigc; - double BSIM4wcigc; - double BSIM4waigsd; - double BSIM4wbigsd; - double BSIM4wcigsd; - double BSIM4waigs; - double BSIM4wbigs; - double BSIM4wcigs; - double BSIM4waigd; - double BSIM4wbigd; - double BSIM4wcigd; - double BSIM4waigbacc; - double BSIM4wbigbacc; - double BSIM4wcigbacc; - double BSIM4waigbinv; - double BSIM4wbigbinv; - double BSIM4wcigbinv; - double BSIM4wnigc; - double BSIM4wnigbacc; - double BSIM4wnigbinv; - double BSIM4wntox; - double BSIM4weigbinv; - double BSIM4wpigcd; - double BSIM4wpoxedge; - double BSIM4wxrcrg1; - double BSIM4wxrcrg2; - double BSIM4wlambda; - double BSIM4wvtl; - double BSIM4wxn; - double BSIM4wvfbsdoff; - double BSIM4wtvfbsdoff; + double BSIM4v7wcdsc; + double BSIM4v7wcdscb; + double BSIM4v7wcdscd; + double BSIM4v7wcit; + double BSIM4v7wnfactor; + double BSIM4v7wxj; + double BSIM4v7wvsat; + double BSIM4v7wat; + double BSIM4v7wa0; + double BSIM4v7wags; + double BSIM4v7wa1; + double BSIM4v7wa2; + double BSIM4v7wketa; + double BSIM4v7wnsub; + double BSIM4v7wndep; + double BSIM4v7wnsd; + double BSIM4v7wphin; + double BSIM4v7wngate; + double BSIM4v7wgamma1; + double BSIM4v7wgamma2; + double BSIM4v7wvbx; + double BSIM4v7wvbm; + double BSIM4v7wxt; + double BSIM4v7wk1; + double BSIM4v7wkt1; + double BSIM4v7wkt1l; + double BSIM4v7wkt2; + double BSIM4v7wk2; + double BSIM4v7wk3; + double BSIM4v7wk3b; + double BSIM4v7ww0; + double BSIM4v7wdvtp0; + double BSIM4v7wdvtp1; + double BSIM4v7wdvtp2; /* New DIBL/Rout */ + double BSIM4v7wdvtp3; + double BSIM4v7wdvtp4; + double BSIM4v7wdvtp5; + double BSIM4v7wlpe0; + double BSIM4v7wlpeb; + double BSIM4v7wdvt0; + double BSIM4v7wdvt1; + double BSIM4v7wdvt2; + double BSIM4v7wdvt0w; + double BSIM4v7wdvt1w; + double BSIM4v7wdvt2w; + double BSIM4v7wdrout; + double BSIM4v7wdsub; + double BSIM4v7wvth0; + double BSIM4v7wua; + double BSIM4v7wua1; + double BSIM4v7wub; + double BSIM4v7wub1; + double BSIM4v7wuc; + double BSIM4v7wuc1; + double BSIM4v7wud; + double BSIM4v7wud1; + double BSIM4v7wup; + double BSIM4v7wlp; + double BSIM4v7wu0; + double BSIM4v7weu; + double BSIM4v7wucs; + double BSIM4v7wute; + double BSIM4v7wucste; + double BSIM4v7wvoff; + double BSIM4v7wtvoff; + double BSIM4v7wtnfactor; /* v4.7 Temp dep of leakage current */ + double BSIM4v7wteta0; /* v4.7 temp dep of leakage current */ + double BSIM4v7wtvoffcv; /* v4.7 temp dep of leakage current */ + double BSIM4v7wminv; + double BSIM4v7wminvcv; + double BSIM4v7wdelta; + double BSIM4v7wrdsw; + double BSIM4v7wrsw; + double BSIM4v7wrdw; + double BSIM4v7wprwg; + double BSIM4v7wprwb; + double BSIM4v7wprt; + double BSIM4v7weta0; + double BSIM4v7wetab; + double BSIM4v7wpclm; + double BSIM4v7wpdibl1; + double BSIM4v7wpdibl2; + double BSIM4v7wpdiblb; + double BSIM4v7wfprout; + double BSIM4v7wpdits; + double BSIM4v7wpditsd; + double BSIM4v7wpscbe1; + double BSIM4v7wpscbe2; + double BSIM4v7wpvag; + double BSIM4v7wwr; + double BSIM4v7wdwg; + double BSIM4v7wdwb; + double BSIM4v7wb0; + double BSIM4v7wb1; + double BSIM4v7walpha0; + double BSIM4v7walpha1; + double BSIM4v7wbeta0; + double BSIM4v7wvfb; + double BSIM4v7wagidl; + double BSIM4v7wbgidl; + double BSIM4v7wcgidl; + double BSIM4v7wegidl; + double BSIM4v7wfgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7wkgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7wrgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7wagisl; + double BSIM4v7wbgisl; + double BSIM4v7wcgisl; + double BSIM4v7wegisl; + double BSIM4v7wfgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7wkgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7wrgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7waigc; + double BSIM4v7wbigc; + double BSIM4v7wcigc; + double BSIM4v7waigsd; + double BSIM4v7wbigsd; + double BSIM4v7wcigsd; + double BSIM4v7waigs; + double BSIM4v7wbigs; + double BSIM4v7wcigs; + double BSIM4v7waigd; + double BSIM4v7wbigd; + double BSIM4v7wcigd; + double BSIM4v7waigbacc; + double BSIM4v7wbigbacc; + double BSIM4v7wcigbacc; + double BSIM4v7waigbinv; + double BSIM4v7wbigbinv; + double BSIM4v7wcigbinv; + double BSIM4v7wnigc; + double BSIM4v7wnigbacc; + double BSIM4v7wnigbinv; + double BSIM4v7wntox; + double BSIM4v7weigbinv; + double BSIM4v7wpigcd; + double BSIM4v7wpoxedge; + double BSIM4v7wxrcrg1; + double BSIM4v7wxrcrg2; + double BSIM4v7wlambda; + double BSIM4v7wvtl; + double BSIM4v7wxn; + double BSIM4v7wvfbsdoff; + double BSIM4v7wtvfbsdoff; /* CV model */ - double BSIM4wcgsl; - double BSIM4wcgdl; - double BSIM4wckappas; - double BSIM4wckappad; - double BSIM4wcf; - double BSIM4wclc; - double BSIM4wcle; - double BSIM4wvfbcv; - double BSIM4wnoff; - double BSIM4wvoffcv; - double BSIM4wacde; - double BSIM4wmoin; + double BSIM4v7wcgsl; + double BSIM4v7wcgdl; + double BSIM4v7wckappas; + double BSIM4v7wckappad; + double BSIM4v7wcf; + double BSIM4v7wclc; + double BSIM4v7wcle; + double BSIM4v7wvfbcv; + double BSIM4v7wnoff; + double BSIM4v7wvoffcv; + double BSIM4v7wacde; + double BSIM4v7wmoin; /* Cross-term Dependence */ - double BSIM4pcdsc; - double BSIM4pcdscb; - double BSIM4pcdscd; - double BSIM4pcit; - double BSIM4pnfactor; - double BSIM4pxj; - double BSIM4pvsat; - double BSIM4pat; - double BSIM4pa0; - double BSIM4pags; - double BSIM4pa1; - double BSIM4pa2; - double BSIM4pketa; - double BSIM4pnsub; - double BSIM4pndep; - double BSIM4pnsd; - double BSIM4pphin; - double BSIM4pngate; - double BSIM4pgamma1; - double BSIM4pgamma2; - double BSIM4pvbx; - double BSIM4pvbm; - double BSIM4pxt; - double BSIM4pk1; - double BSIM4pkt1; - double BSIM4pkt1l; - double BSIM4pkt2; - double BSIM4pk2; - double BSIM4pk3; - double BSIM4pk3b; - double BSIM4pw0; - double BSIM4pdvtp0; - double BSIM4pdvtp1; - double BSIM4pdvtp2; /* New DIBL/Rout */ - double BSIM4pdvtp3; - double BSIM4pdvtp4; - double BSIM4pdvtp5; - double BSIM4plpe0; - double BSIM4plpeb; - double BSIM4pdvt0; - double BSIM4pdvt1; - double BSIM4pdvt2; - double BSIM4pdvt0w; - double BSIM4pdvt1w; - double BSIM4pdvt2w; - double BSIM4pdrout; - double BSIM4pdsub; - double BSIM4pvth0; - double BSIM4pua; - double BSIM4pua1; - double BSIM4pub; - double BSIM4pub1; - double BSIM4puc; - double BSIM4puc1; - double BSIM4pud; - double BSIM4pud1; - double BSIM4pup; - double BSIM4plp; - double BSIM4pu0; - double BSIM4peu; - double BSIM4pucs; - double BSIM4pute; - double BSIM4pucste; - double BSIM4pvoff; - double BSIM4ptvoff; - double BSIM4ptnfactor; /* v4.7 Temp dep of leakage current */ - double BSIM4pteta0; /* v4.7 temp dep of leakage current */ - double BSIM4ptvoffcv; /* v4.7 temp dep of leakage current */ - double BSIM4pminv; - double BSIM4pminvcv; - double BSIM4pdelta; - double BSIM4prdsw; - double BSIM4prsw; - double BSIM4prdw; - double BSIM4pprwg; - double BSIM4pprwb; - double BSIM4pprt; - double BSIM4peta0; - double BSIM4petab; - double BSIM4ppclm; - double BSIM4ppdibl1; - double BSIM4ppdibl2; - double BSIM4ppdiblb; - double BSIM4pfprout; - double BSIM4ppdits; - double BSIM4ppditsd; - double BSIM4ppscbe1; - double BSIM4ppscbe2; - double BSIM4ppvag; - double BSIM4pwr; - double BSIM4pdwg; - double BSIM4pdwb; - double BSIM4pb0; - double BSIM4pb1; - double BSIM4palpha0; - double BSIM4palpha1; - double BSIM4pbeta0; - double BSIM4pvfb; - double BSIM4pagidl; - double BSIM4pbgidl; - double BSIM4pcgidl; - double BSIM4pegidl; - double BSIM4pfgidl; /* v4.7 New GIDL/GISL */ - double BSIM4pkgidl; /* v4.7 New GIDL/GISL */ - double BSIM4prgidl; /* v4.7 New GIDL/GISL */ - double BSIM4pagisl; - double BSIM4pbgisl; - double BSIM4pcgisl; - double BSIM4pegisl; - double BSIM4pfgisl; /* v4.7 New GIDL/GISL */ - double BSIM4pkgisl; /* v4.7 New GIDL/GISL */ - double BSIM4prgisl; /* v4.7 New GIDL/GISL */ - double BSIM4paigc; - double BSIM4pbigc; - double BSIM4pcigc; - double BSIM4paigsd; - double BSIM4pbigsd; - double BSIM4pcigsd; - double BSIM4paigs; - double BSIM4pbigs; - double BSIM4pcigs; - double BSIM4paigd; - double BSIM4pbigd; - double BSIM4pcigd; - double BSIM4paigbacc; - double BSIM4pbigbacc; - double BSIM4pcigbacc; - double BSIM4paigbinv; - double BSIM4pbigbinv; - double BSIM4pcigbinv; - double BSIM4pnigc; - double BSIM4pnigbacc; - double BSIM4pnigbinv; - double BSIM4pntox; - double BSIM4peigbinv; - double BSIM4ppigcd; - double BSIM4ppoxedge; - double BSIM4pxrcrg1; - double BSIM4pxrcrg2; - double BSIM4plambda; - double BSIM4pvtl; - double BSIM4pxn; - double BSIM4pvfbsdoff; - double BSIM4ptvfbsdoff; + double BSIM4v7pcdsc; + double BSIM4v7pcdscb; + double BSIM4v7pcdscd; + double BSIM4v7pcit; + double BSIM4v7pnfactor; + double BSIM4v7pxj; + double BSIM4v7pvsat; + double BSIM4v7pat; + double BSIM4v7pa0; + double BSIM4v7pags; + double BSIM4v7pa1; + double BSIM4v7pa2; + double BSIM4v7pketa; + double BSIM4v7pnsub; + double BSIM4v7pndep; + double BSIM4v7pnsd; + double BSIM4v7pphin; + double BSIM4v7pngate; + double BSIM4v7pgamma1; + double BSIM4v7pgamma2; + double BSIM4v7pvbx; + double BSIM4v7pvbm; + double BSIM4v7pxt; + double BSIM4v7pk1; + double BSIM4v7pkt1; + double BSIM4v7pkt1l; + double BSIM4v7pkt2; + double BSIM4v7pk2; + double BSIM4v7pk3; + double BSIM4v7pk3b; + double BSIM4v7pw0; + double BSIM4v7pdvtp0; + double BSIM4v7pdvtp1; + double BSIM4v7pdvtp2; /* New DIBL/Rout */ + double BSIM4v7pdvtp3; + double BSIM4v7pdvtp4; + double BSIM4v7pdvtp5; + double BSIM4v7plpe0; + double BSIM4v7plpeb; + double BSIM4v7pdvt0; + double BSIM4v7pdvt1; + double BSIM4v7pdvt2; + double BSIM4v7pdvt0w; + double BSIM4v7pdvt1w; + double BSIM4v7pdvt2w; + double BSIM4v7pdrout; + double BSIM4v7pdsub; + double BSIM4v7pvth0; + double BSIM4v7pua; + double BSIM4v7pua1; + double BSIM4v7pub; + double BSIM4v7pub1; + double BSIM4v7puc; + double BSIM4v7puc1; + double BSIM4v7pud; + double BSIM4v7pud1; + double BSIM4v7pup; + double BSIM4v7plp; + double BSIM4v7pu0; + double BSIM4v7peu; + double BSIM4v7pucs; + double BSIM4v7pute; + double BSIM4v7pucste; + double BSIM4v7pvoff; + double BSIM4v7ptvoff; + double BSIM4v7ptnfactor; /* v4.7 Temp dep of leakage current */ + double BSIM4v7pteta0; /* v4.7 temp dep of leakage current */ + double BSIM4v7ptvoffcv; /* v4.7 temp dep of leakage current */ + double BSIM4v7pminv; + double BSIM4v7pminvcv; + double BSIM4v7pdelta; + double BSIM4v7prdsw; + double BSIM4v7prsw; + double BSIM4v7prdw; + double BSIM4v7pprwg; + double BSIM4v7pprwb; + double BSIM4v7pprt; + double BSIM4v7peta0; + double BSIM4v7petab; + double BSIM4v7ppclm; + double BSIM4v7ppdibl1; + double BSIM4v7ppdibl2; + double BSIM4v7ppdiblb; + double BSIM4v7pfprout; + double BSIM4v7ppdits; + double BSIM4v7ppditsd; + double BSIM4v7ppscbe1; + double BSIM4v7ppscbe2; + double BSIM4v7ppvag; + double BSIM4v7pwr; + double BSIM4v7pdwg; + double BSIM4v7pdwb; + double BSIM4v7pb0; + double BSIM4v7pb1; + double BSIM4v7palpha0; + double BSIM4v7palpha1; + double BSIM4v7pbeta0; + double BSIM4v7pvfb; + double BSIM4v7pagidl; + double BSIM4v7pbgidl; + double BSIM4v7pcgidl; + double BSIM4v7pegidl; + double BSIM4v7pfgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7pkgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7prgidl; /* v4.7 New GIDL/GISL */ + double BSIM4v7pagisl; + double BSIM4v7pbgisl; + double BSIM4v7pcgisl; + double BSIM4v7pegisl; + double BSIM4v7pfgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7pkgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7prgisl; /* v4.7 New GIDL/GISL */ + double BSIM4v7paigc; + double BSIM4v7pbigc; + double BSIM4v7pcigc; + double BSIM4v7paigsd; + double BSIM4v7pbigsd; + double BSIM4v7pcigsd; + double BSIM4v7paigs; + double BSIM4v7pbigs; + double BSIM4v7pcigs; + double BSIM4v7paigd; + double BSIM4v7pbigd; + double BSIM4v7pcigd; + double BSIM4v7paigbacc; + double BSIM4v7pbigbacc; + double BSIM4v7pcigbacc; + double BSIM4v7paigbinv; + double BSIM4v7pbigbinv; + double BSIM4v7pcigbinv; + double BSIM4v7pnigc; + double BSIM4v7pnigbacc; + double BSIM4v7pnigbinv; + double BSIM4v7pntox; + double BSIM4v7peigbinv; + double BSIM4v7ppigcd; + double BSIM4v7ppoxedge; + double BSIM4v7pxrcrg1; + double BSIM4v7pxrcrg2; + double BSIM4v7plambda; + double BSIM4v7pvtl; + double BSIM4v7pxn; + double BSIM4v7pvfbsdoff; + double BSIM4v7ptvfbsdoff; /* CV model */ - double BSIM4pcgsl; - double BSIM4pcgdl; - double BSIM4pckappas; - double BSIM4pckappad; - double BSIM4pcf; - double BSIM4pclc; - double BSIM4pcle; - double BSIM4pvfbcv; - double BSIM4pnoff; - double BSIM4pvoffcv; - double BSIM4pacde; - double BSIM4pmoin; + double BSIM4v7pcgsl; + double BSIM4v7pcgdl; + double BSIM4v7pckappas; + double BSIM4v7pckappad; + double BSIM4v7pcf; + double BSIM4v7pclc; + double BSIM4v7pcle; + double BSIM4v7pvfbcv; + double BSIM4v7pnoff; + double BSIM4v7pvoffcv; + double BSIM4v7pacde; + double BSIM4v7pmoin; - double BSIM4tnom; - double BSIM4cgso; - double BSIM4cgdo; - double BSIM4cgbo; - double BSIM4xpart; - double BSIM4cFringOut; - double BSIM4cFringMax; + double BSIM4v7tnom; + double BSIM4v7cgso; + double BSIM4v7cgdo; + double BSIM4v7cgbo; + double BSIM4v7xpart; + double BSIM4v7cFringOut; + double BSIM4v7cFringMax; - double BSIM4sheetResistance; - double BSIM4SjctSatCurDensity; - double BSIM4DjctSatCurDensity; - double BSIM4SjctSidewallSatCurDensity; - double BSIM4DjctSidewallSatCurDensity; - double BSIM4SjctGateSidewallSatCurDensity; - double BSIM4DjctGateSidewallSatCurDensity; - double BSIM4SbulkJctPotential; - double BSIM4DbulkJctPotential; - double BSIM4SbulkJctBotGradingCoeff; - double BSIM4DbulkJctBotGradingCoeff; - double BSIM4SbulkJctSideGradingCoeff; - double BSIM4DbulkJctSideGradingCoeff; - double BSIM4SbulkJctGateSideGradingCoeff; - double BSIM4DbulkJctGateSideGradingCoeff; - double BSIM4SsidewallJctPotential; - double BSIM4DsidewallJctPotential; - double BSIM4SGatesidewallJctPotential; - double BSIM4DGatesidewallJctPotential; - double BSIM4SunitAreaJctCap; - double BSIM4DunitAreaJctCap; - double BSIM4SunitLengthSidewallJctCap; - double BSIM4DunitLengthSidewallJctCap; - double BSIM4SunitLengthGateSidewallJctCap; - double BSIM4DunitLengthGateSidewallJctCap; - double BSIM4SjctEmissionCoeff; - double BSIM4DjctEmissionCoeff; - double BSIM4SjctTempExponent; - double BSIM4DjctTempExponent; - double BSIM4njtsstemp; - double BSIM4njtsswstemp; - double BSIM4njtsswgstemp; - double BSIM4njtsdtemp; - double BSIM4njtsswdtemp; - double BSIM4njtsswgdtemp; + double BSIM4v7sheetResistance; + double BSIM4v7SjctSatCurDensity; + double BSIM4v7DjctSatCurDensity; + double BSIM4v7SjctSidewallSatCurDensity; + double BSIM4v7DjctSidewallSatCurDensity; + double BSIM4v7SjctGateSidewallSatCurDensity; + double BSIM4v7DjctGateSidewallSatCurDensity; + double BSIM4v7SbulkJctPotential; + double BSIM4v7DbulkJctPotential; + double BSIM4v7SbulkJctBotGradingCoeff; + double BSIM4v7DbulkJctBotGradingCoeff; + double BSIM4v7SbulkJctSideGradingCoeff; + double BSIM4v7DbulkJctSideGradingCoeff; + double BSIM4v7SbulkJctGateSideGradingCoeff; + double BSIM4v7DbulkJctGateSideGradingCoeff; + double BSIM4v7SsidewallJctPotential; + double BSIM4v7DsidewallJctPotential; + double BSIM4v7SGatesidewallJctPotential; + double BSIM4v7DGatesidewallJctPotential; + double BSIM4v7SunitAreaJctCap; + double BSIM4v7DunitAreaJctCap; + double BSIM4v7SunitLengthSidewallJctCap; + double BSIM4v7DunitLengthSidewallJctCap; + double BSIM4v7SunitLengthGateSidewallJctCap; + double BSIM4v7DunitLengthGateSidewallJctCap; + double BSIM4v7SjctEmissionCoeff; + double BSIM4v7DjctEmissionCoeff; + double BSIM4v7SjctTempExponent; + double BSIM4v7DjctTempExponent; + double BSIM4v7njtsstemp; + double BSIM4v7njtsswstemp; + double BSIM4v7njtsswgstemp; + double BSIM4v7njtsdtemp; + double BSIM4v7njtsswdtemp; + double BSIM4v7njtsswgdtemp; - double BSIM4Lint; - double BSIM4Ll; - double BSIM4Llc; - double BSIM4Lln; - double BSIM4Lw; - double BSIM4Lwc; - double BSIM4Lwn; - double BSIM4Lwl; - double BSIM4Lwlc; - double BSIM4Lmin; - double BSIM4Lmax; + double BSIM4v7Lint; + double BSIM4v7Ll; + double BSIM4v7Llc; + double BSIM4v7Lln; + double BSIM4v7Lw; + double BSIM4v7Lwc; + double BSIM4v7Lwn; + double BSIM4v7Lwl; + double BSIM4v7Lwlc; + double BSIM4v7Lmin; + double BSIM4v7Lmax; - double BSIM4Wint; - double BSIM4Wl; - double BSIM4Wlc; - double BSIM4Wln; - double BSIM4Ww; - double BSIM4Wwc; - double BSIM4Wwn; - double BSIM4Wwl; - double BSIM4Wwlc; - double BSIM4Wmin; - double BSIM4Wmax; + double BSIM4v7Wint; + double BSIM4v7Wl; + double BSIM4v7Wlc; + double BSIM4v7Wln; + double BSIM4v7Ww; + double BSIM4v7Wwc; + double BSIM4v7Wwn; + double BSIM4v7Wwl; + double BSIM4v7Wwlc; + double BSIM4v7Wmin; + double BSIM4v7Wmax; /* added for stress effect */ - double BSIM4saref; - double BSIM4sbref; - double BSIM4wlod; - double BSIM4ku0; - double BSIM4kvsat; - double BSIM4kvth0; - double BSIM4tku0; - double BSIM4llodku0; - double BSIM4wlodku0; - double BSIM4llodvth; - double BSIM4wlodvth; - double BSIM4lku0; - double BSIM4wku0; - double BSIM4pku0; - double BSIM4lkvth0; - double BSIM4wkvth0; - double BSIM4pkvth0; - double BSIM4stk2; - double BSIM4lodk2; - double BSIM4steta0; - double BSIM4lodeta0; + double BSIM4v7saref; + double BSIM4v7sbref; + double BSIM4v7wlod; + double BSIM4v7ku0; + double BSIM4v7kvsat; + double BSIM4v7kvth0; + double BSIM4v7tku0; + double BSIM4v7llodku0; + double BSIM4v7wlodku0; + double BSIM4v7llodvth; + double BSIM4v7wlodvth; + double BSIM4v7lku0; + double BSIM4v7wku0; + double BSIM4v7pku0; + double BSIM4v7lkvth0; + double BSIM4v7wkvth0; + double BSIM4v7pkvth0; + double BSIM4v7stk2; + double BSIM4v7lodk2; + double BSIM4v7steta0; + double BSIM4v7lodeta0; - double BSIM4web; - double BSIM4wec; - double BSIM4kvth0we; - double BSIM4k2we; - double BSIM4ku0we; - double BSIM4scref; - double BSIM4wpemod; - double BSIM4lkvth0we; - double BSIM4lk2we; - double BSIM4lku0we; - double BSIM4wkvth0we; - double BSIM4wk2we; - double BSIM4wku0we; - double BSIM4pkvth0we; - double BSIM4pk2we; - double BSIM4pku0we; + double BSIM4v7web; + double BSIM4v7wec; + double BSIM4v7kvth0we; + double BSIM4v7k2we; + double BSIM4v7ku0we; + double BSIM4v7scref; + double BSIM4v7wpemod; + double BSIM4v7lkvth0we; + double BSIM4v7lk2we; + double BSIM4v7lku0we; + double BSIM4v7wkvth0we; + double BSIM4v7wk2we; + double BSIM4v7wku0we; + double BSIM4v7pkvth0we; + double BSIM4v7pk2we; + double BSIM4v7pku0we; /* Pre-calculated constants * move to size-dependent param */ - double BSIM4Eg0; - double BSIM4vtm; - double BSIM4vtm0; - double BSIM4coxe; - double BSIM4coxp; - double BSIM4cof1; - double BSIM4cof2; - double BSIM4cof3; - double BSIM4cof4; - double BSIM4vcrit; - double BSIM4factor1; - double BSIM4PhiBS; - double BSIM4PhiBSWS; - double BSIM4PhiBSWGS; - double BSIM4SjctTempSatCurDensity; - double BSIM4SjctSidewallTempSatCurDensity; - double BSIM4SjctGateSidewallTempSatCurDensity; - double BSIM4PhiBD; - double BSIM4PhiBSWD; - double BSIM4PhiBSWGD; - double BSIM4DjctTempSatCurDensity; - double BSIM4DjctSidewallTempSatCurDensity; - double BSIM4DjctGateSidewallTempSatCurDensity; - double BSIM4SunitAreaTempJctCap; - double BSIM4DunitAreaTempJctCap; - double BSIM4SunitLengthSidewallTempJctCap; - double BSIM4DunitLengthSidewallTempJctCap; - double BSIM4SunitLengthGateSidewallTempJctCap; - double BSIM4DunitLengthGateSidewallTempJctCap; + double BSIM4v7Eg0; + double BSIM4v7vtm; + double BSIM4v7vtm0; + double BSIM4v7coxe; + double BSIM4v7coxp; + double BSIM4v7cof1; + double BSIM4v7cof2; + double BSIM4v7cof3; + double BSIM4v7cof4; + double BSIM4v7vcrit; + double BSIM4v7factor1; + double BSIM4v7PhiBS; + double BSIM4v7PhiBSWS; + double BSIM4v7PhiBSWGS; + double BSIM4v7SjctTempSatCurDensity; + double BSIM4v7SjctSidewallTempSatCurDensity; + double BSIM4v7SjctGateSidewallTempSatCurDensity; + double BSIM4v7PhiBD; + double BSIM4v7PhiBSWD; + double BSIM4v7PhiBSWGD; + double BSIM4v7DjctTempSatCurDensity; + double BSIM4v7DjctSidewallTempSatCurDensity; + double BSIM4v7DjctGateSidewallTempSatCurDensity; + double BSIM4v7SunitAreaTempJctCap; + double BSIM4v7DunitAreaTempJctCap; + double BSIM4v7SunitLengthSidewallTempJctCap; + double BSIM4v7DunitLengthSidewallTempJctCap; + double BSIM4v7SunitLengthGateSidewallTempJctCap; + double BSIM4v7DunitLengthGateSidewallTempJctCap; - double BSIM4oxideTrapDensityA; - double BSIM4oxideTrapDensityB; - double BSIM4oxideTrapDensityC; - double BSIM4em; - double BSIM4ef; - double BSIM4af; - double BSIM4kf; + double BSIM4v7oxideTrapDensityA; + double BSIM4v7oxideTrapDensityB; + double BSIM4v7oxideTrapDensityC; + double BSIM4v7em; + double BSIM4v7ef; + double BSIM4v7af; + double BSIM4v7kf; - double BSIM4vgsMax; - double BSIM4vgdMax; - double BSIM4vgbMax; - double BSIM4vdsMax; - double BSIM4vbsMax; - double BSIM4vbdMax; + double BSIM4v7vgsMax; + double BSIM4v7vgdMax; + double BSIM4v7vgbMax; + double BSIM4v7vdsMax; + double BSIM4v7vbsMax; + double BSIM4v7vbdMax; struct bsim4SizeDependParam *pSizeDependParamKnot; #ifdef USE_OMP - int BSIM4InstCount; - struct sBSIM4instance **BSIM4InstanceArray; + int BSIM4v7InstCount; + struct sBSIM4v7instance **BSIM4v7InstanceArray; #endif /* Flags */ - unsigned BSIM4mobModGiven :1; - unsigned BSIM4binUnitGiven :1; - unsigned BSIM4cvchargeModGiven :1; - unsigned BSIM4capModGiven :1; - unsigned BSIM4dioModGiven :1; - unsigned BSIM4rdsModGiven :1; - unsigned BSIM4rbodyModGiven :1; - unsigned BSIM4rgateModGiven :1; - unsigned BSIM4perModGiven :1; - unsigned BSIM4geoModGiven :1; - unsigned BSIM4rgeoModGiven :1; - unsigned BSIM4paramChkGiven :1; - unsigned BSIM4trnqsModGiven :1; - unsigned BSIM4acnqsModGiven :1; - unsigned BSIM4fnoiModGiven :1; - unsigned BSIM4tnoiModGiven :1; - unsigned BSIM4mtrlModGiven :1; - unsigned BSIM4mtrlCompatModGiven :1; - unsigned BSIM4gidlModGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4igcModGiven :1; - unsigned BSIM4igbModGiven :1; - unsigned BSIM4tempModGiven :1; - unsigned BSIM4typeGiven :1; - unsigned BSIM4toxrefGiven :1; - unsigned BSIM4eotGiven :1; - unsigned BSIM4vddeotGiven :1; - unsigned BSIM4tempeotGiven :1; - unsigned BSIM4leffeotGiven :1; - unsigned BSIM4weffeotGiven :1; - unsigned BSIM4adosGiven :1; - unsigned BSIM4bdosGiven :1; - unsigned BSIM4toxeGiven :1; - unsigned BSIM4toxpGiven :1; - unsigned BSIM4toxmGiven :1; - unsigned BSIM4dtoxGiven :1; - unsigned BSIM4epsroxGiven :1; - unsigned BSIM4versionGiven :1; - unsigned BSIM4cdscGiven :1; - unsigned BSIM4cdscbGiven :1; - unsigned BSIM4cdscdGiven :1; - unsigned BSIM4citGiven :1; - unsigned BSIM4nfactorGiven :1; - unsigned BSIM4xjGiven :1; - unsigned BSIM4vsatGiven :1; - unsigned BSIM4atGiven :1; - unsigned BSIM4a0Given :1; - unsigned BSIM4agsGiven :1; - unsigned BSIM4a1Given :1; - unsigned BSIM4a2Given :1; - unsigned BSIM4ketaGiven :1; - unsigned BSIM4nsubGiven :1; - unsigned BSIM4phigGiven :1; - unsigned BSIM4epsrgateGiven :1; - unsigned BSIM4easubGiven :1; - unsigned BSIM4epsrsubGiven :1; - unsigned BSIM4ni0subGiven :1; - unsigned BSIM4bg0subGiven :1; - unsigned BSIM4tbgasubGiven :1; - unsigned BSIM4tbgbsubGiven :1; - unsigned BSIM4ndepGiven :1; - unsigned BSIM4nsdGiven :1; - unsigned BSIM4phinGiven :1; - unsigned BSIM4ngateGiven :1; - unsigned BSIM4gamma1Given :1; - unsigned BSIM4gamma2Given :1; - unsigned BSIM4vbxGiven :1; - unsigned BSIM4vbmGiven :1; - unsigned BSIM4xtGiven :1; - unsigned BSIM4k1Given :1; - unsigned BSIM4kt1Given :1; - unsigned BSIM4kt1lGiven :1; - unsigned BSIM4kt2Given :1; - unsigned BSIM4k2Given :1; - unsigned BSIM4k3Given :1; - unsigned BSIM4k3bGiven :1; - unsigned BSIM4w0Given :1; - unsigned BSIM4dvtp0Given :1; - unsigned BSIM4dvtp1Given :1; - unsigned BSIM4dvtp2Given :1; /* New DIBL/Rout */ - unsigned BSIM4dvtp3Given :1; - unsigned BSIM4dvtp4Given :1; - unsigned BSIM4dvtp5Given :1; - unsigned BSIM4lpe0Given :1; - unsigned BSIM4lpebGiven :1; - unsigned BSIM4dvt0Given :1; - unsigned BSIM4dvt1Given :1; - unsigned BSIM4dvt2Given :1; - unsigned BSIM4dvt0wGiven :1; - unsigned BSIM4dvt1wGiven :1; - unsigned BSIM4dvt2wGiven :1; - unsigned BSIM4droutGiven :1; - unsigned BSIM4dsubGiven :1; - unsigned BSIM4vth0Given :1; - unsigned BSIM4euGiven :1; - unsigned BSIM4ucsGiven :1; - unsigned BSIM4uaGiven :1; - unsigned BSIM4ua1Given :1; - unsigned BSIM4ubGiven :1; - unsigned BSIM4ub1Given :1; - unsigned BSIM4ucGiven :1; - unsigned BSIM4uc1Given :1; - unsigned BSIM4udGiven :1; - unsigned BSIM4ud1Given :1; - unsigned BSIM4upGiven :1; - unsigned BSIM4lpGiven :1; - unsigned BSIM4u0Given :1; - unsigned BSIM4uteGiven :1; - unsigned BSIM4ucsteGiven :1; - unsigned BSIM4voffGiven :1; - unsigned BSIM4tvoffGiven :1; - unsigned BSIM4tnfactorGiven :1; /* v4.7 Temp dep of leakage current */ - unsigned BSIM4teta0Given :1; /* v4.7 temp dep of leakage current */ - unsigned BSIM4tvoffcvGiven :1; /* v4.7 temp dep of leakage current */ - unsigned BSIM4vofflGiven :1; - unsigned BSIM4voffcvlGiven :1; - unsigned BSIM4minvGiven :1; - unsigned BSIM4minvcvGiven :1; - unsigned BSIM4rdswGiven :1; - unsigned BSIM4rdswminGiven :1; - unsigned BSIM4rdwminGiven :1; - unsigned BSIM4rswminGiven :1; - unsigned BSIM4rswGiven :1; - unsigned BSIM4rdwGiven :1; - unsigned BSIM4prwgGiven :1; - unsigned BSIM4prwbGiven :1; - unsigned BSIM4prtGiven :1; - unsigned BSIM4eta0Given :1; - unsigned BSIM4etabGiven :1; - unsigned BSIM4pclmGiven :1; - unsigned BSIM4pdibl1Given :1; - unsigned BSIM4pdibl2Given :1; - unsigned BSIM4pdiblbGiven :1; - unsigned BSIM4fproutGiven :1; - unsigned BSIM4pditsGiven :1; - unsigned BSIM4pditsdGiven :1; - unsigned BSIM4pditslGiven :1; - unsigned BSIM4pscbe1Given :1; - unsigned BSIM4pscbe2Given :1; - unsigned BSIM4pvagGiven :1; - unsigned BSIM4deltaGiven :1; - unsigned BSIM4wrGiven :1; - unsigned BSIM4dwgGiven :1; - unsigned BSIM4dwbGiven :1; - unsigned BSIM4b0Given :1; - unsigned BSIM4b1Given :1; - unsigned BSIM4alpha0Given :1; - unsigned BSIM4alpha1Given :1; - unsigned BSIM4beta0Given :1; - unsigned BSIM4agidlGiven :1; - unsigned BSIM4bgidlGiven :1; - unsigned BSIM4cgidlGiven :1; - unsigned BSIM4egidlGiven :1; - unsigned BSIM4fgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4kgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4rgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4agislGiven :1; - unsigned BSIM4bgislGiven :1; - unsigned BSIM4cgislGiven :1; - unsigned BSIM4egislGiven :1; - unsigned BSIM4fgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4kgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4rgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4aigcGiven :1; - unsigned BSIM4bigcGiven :1; - unsigned BSIM4cigcGiven :1; - unsigned BSIM4aigsdGiven :1; - unsigned BSIM4bigsdGiven :1; - unsigned BSIM4cigsdGiven :1; - unsigned BSIM4aigsGiven :1; - unsigned BSIM4bigsGiven :1; - unsigned BSIM4cigsGiven :1; - unsigned BSIM4aigdGiven :1; - unsigned BSIM4bigdGiven :1; - unsigned BSIM4cigdGiven :1; - unsigned BSIM4aigbaccGiven :1; - unsigned BSIM4bigbaccGiven :1; - unsigned BSIM4cigbaccGiven :1; - unsigned BSIM4aigbinvGiven :1; - unsigned BSIM4bigbinvGiven :1; - unsigned BSIM4cigbinvGiven :1; - unsigned BSIM4nigcGiven :1; - unsigned BSIM4nigbinvGiven :1; - unsigned BSIM4nigbaccGiven :1; - unsigned BSIM4ntoxGiven :1; - unsigned BSIM4eigbinvGiven :1; - unsigned BSIM4pigcdGiven :1; - unsigned BSIM4poxedgeGiven :1; - unsigned BSIM4ijthdfwdGiven :1; - unsigned BSIM4ijthsfwdGiven :1; - unsigned BSIM4ijthdrevGiven :1; - unsigned BSIM4ijthsrevGiven :1; - unsigned BSIM4xjbvdGiven :1; - unsigned BSIM4xjbvsGiven :1; - unsigned BSIM4bvdGiven :1; - unsigned BSIM4bvsGiven :1; + unsigned BSIM4v7mobModGiven :1; + unsigned BSIM4v7binUnitGiven :1; + unsigned BSIM4v7cvchargeModGiven :1; + unsigned BSIM4v7capModGiven :1; + unsigned BSIM4v7dioModGiven :1; + unsigned BSIM4v7rdsModGiven :1; + unsigned BSIM4v7rbodyModGiven :1; + unsigned BSIM4v7rgateModGiven :1; + unsigned BSIM4v7perModGiven :1; + unsigned BSIM4v7geoModGiven :1; + unsigned BSIM4v7rgeoModGiven :1; + unsigned BSIM4v7paramChkGiven :1; + unsigned BSIM4v7trnqsModGiven :1; + unsigned BSIM4v7acnqsModGiven :1; + unsigned BSIM4v7fnoiModGiven :1; + unsigned BSIM4v7tnoiModGiven :1; + unsigned BSIM4v7mtrlModGiven :1; + unsigned BSIM4v7mtrlCompatModGiven :1; + unsigned BSIM4v7gidlModGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7igcModGiven :1; + unsigned BSIM4v7igbModGiven :1; + unsigned BSIM4v7tempModGiven :1; + unsigned BSIM4v7typeGiven :1; + unsigned BSIM4v7toxrefGiven :1; + unsigned BSIM4v7eotGiven :1; + unsigned BSIM4v7vddeotGiven :1; + unsigned BSIM4v7tempeotGiven :1; + unsigned BSIM4v7leffeotGiven :1; + unsigned BSIM4v7weffeotGiven :1; + unsigned BSIM4v7adosGiven :1; + unsigned BSIM4v7bdosGiven :1; + unsigned BSIM4v7toxeGiven :1; + unsigned BSIM4v7toxpGiven :1; + unsigned BSIM4v7toxmGiven :1; + unsigned BSIM4v7dtoxGiven :1; + unsigned BSIM4v7epsroxGiven :1; + unsigned BSIM4v7versionGiven :1; + unsigned BSIM4v7cdscGiven :1; + unsigned BSIM4v7cdscbGiven :1; + unsigned BSIM4v7cdscdGiven :1; + unsigned BSIM4v7citGiven :1; + unsigned BSIM4v7nfactorGiven :1; + unsigned BSIM4v7xjGiven :1; + unsigned BSIM4v7vsatGiven :1; + unsigned BSIM4v7atGiven :1; + unsigned BSIM4v7a0Given :1; + unsigned BSIM4v7agsGiven :1; + unsigned BSIM4v7a1Given :1; + unsigned BSIM4v7a2Given :1; + unsigned BSIM4v7ketaGiven :1; + unsigned BSIM4v7nsubGiven :1; + unsigned BSIM4v7phigGiven :1; + unsigned BSIM4v7epsrgateGiven :1; + unsigned BSIM4v7easubGiven :1; + unsigned BSIM4v7epsrsubGiven :1; + unsigned BSIM4v7ni0subGiven :1; + unsigned BSIM4v7bg0subGiven :1; + unsigned BSIM4v7tbgasubGiven :1; + unsigned BSIM4v7tbgbsubGiven :1; + unsigned BSIM4v7ndepGiven :1; + unsigned BSIM4v7nsdGiven :1; + unsigned BSIM4v7phinGiven :1; + unsigned BSIM4v7ngateGiven :1; + unsigned BSIM4v7gamma1Given :1; + unsigned BSIM4v7gamma2Given :1; + unsigned BSIM4v7vbxGiven :1; + unsigned BSIM4v7vbmGiven :1; + unsigned BSIM4v7xtGiven :1; + unsigned BSIM4v7k1Given :1; + unsigned BSIM4v7kt1Given :1; + unsigned BSIM4v7kt1lGiven :1; + unsigned BSIM4v7kt2Given :1; + unsigned BSIM4v7k2Given :1; + unsigned BSIM4v7k3Given :1; + unsigned BSIM4v7k3bGiven :1; + unsigned BSIM4v7w0Given :1; + unsigned BSIM4v7dvtp0Given :1; + unsigned BSIM4v7dvtp1Given :1; + unsigned BSIM4v7dvtp2Given :1; /* New DIBL/Rout */ + unsigned BSIM4v7dvtp3Given :1; + unsigned BSIM4v7dvtp4Given :1; + unsigned BSIM4v7dvtp5Given :1; + unsigned BSIM4v7lpe0Given :1; + unsigned BSIM4v7lpebGiven :1; + unsigned BSIM4v7dvt0Given :1; + unsigned BSIM4v7dvt1Given :1; + unsigned BSIM4v7dvt2Given :1; + unsigned BSIM4v7dvt0wGiven :1; + unsigned BSIM4v7dvt1wGiven :1; + unsigned BSIM4v7dvt2wGiven :1; + unsigned BSIM4v7droutGiven :1; + unsigned BSIM4v7dsubGiven :1; + unsigned BSIM4v7vth0Given :1; + unsigned BSIM4v7euGiven :1; + unsigned BSIM4v7ucsGiven :1; + unsigned BSIM4v7uaGiven :1; + unsigned BSIM4v7ua1Given :1; + unsigned BSIM4v7ubGiven :1; + unsigned BSIM4v7ub1Given :1; + unsigned BSIM4v7ucGiven :1; + unsigned BSIM4v7uc1Given :1; + unsigned BSIM4v7udGiven :1; + unsigned BSIM4v7ud1Given :1; + unsigned BSIM4v7upGiven :1; + unsigned BSIM4v7lpGiven :1; + unsigned BSIM4v7u0Given :1; + unsigned BSIM4v7uteGiven :1; + unsigned BSIM4v7ucsteGiven :1; + unsigned BSIM4v7voffGiven :1; + unsigned BSIM4v7tvoffGiven :1; + unsigned BSIM4v7tnfactorGiven :1; /* v4.7 Temp dep of leakage current */ + unsigned BSIM4v7teta0Given :1; /* v4.7 temp dep of leakage current */ + unsigned BSIM4v7tvoffcvGiven :1; /* v4.7 temp dep of leakage current */ + unsigned BSIM4v7vofflGiven :1; + unsigned BSIM4v7voffcvlGiven :1; + unsigned BSIM4v7minvGiven :1; + unsigned BSIM4v7minvcvGiven :1; + unsigned BSIM4v7rdswGiven :1; + unsigned BSIM4v7rdswminGiven :1; + unsigned BSIM4v7rdwminGiven :1; + unsigned BSIM4v7rswminGiven :1; + unsigned BSIM4v7rswGiven :1; + unsigned BSIM4v7rdwGiven :1; + unsigned BSIM4v7prwgGiven :1; + unsigned BSIM4v7prwbGiven :1; + unsigned BSIM4v7prtGiven :1; + unsigned BSIM4v7eta0Given :1; + unsigned BSIM4v7etabGiven :1; + unsigned BSIM4v7pclmGiven :1; + unsigned BSIM4v7pdibl1Given :1; + unsigned BSIM4v7pdibl2Given :1; + unsigned BSIM4v7pdiblbGiven :1; + unsigned BSIM4v7fproutGiven :1; + unsigned BSIM4v7pditsGiven :1; + unsigned BSIM4v7pditsdGiven :1; + unsigned BSIM4v7pditslGiven :1; + unsigned BSIM4v7pscbe1Given :1; + unsigned BSIM4v7pscbe2Given :1; + unsigned BSIM4v7pvagGiven :1; + unsigned BSIM4v7deltaGiven :1; + unsigned BSIM4v7wrGiven :1; + unsigned BSIM4v7dwgGiven :1; + unsigned BSIM4v7dwbGiven :1; + unsigned BSIM4v7b0Given :1; + unsigned BSIM4v7b1Given :1; + unsigned BSIM4v7alpha0Given :1; + unsigned BSIM4v7alpha1Given :1; + unsigned BSIM4v7beta0Given :1; + unsigned BSIM4v7agidlGiven :1; + unsigned BSIM4v7bgidlGiven :1; + unsigned BSIM4v7cgidlGiven :1; + unsigned BSIM4v7egidlGiven :1; + unsigned BSIM4v7fgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7kgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7rgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7agislGiven :1; + unsigned BSIM4v7bgislGiven :1; + unsigned BSIM4v7cgislGiven :1; + unsigned BSIM4v7egislGiven :1; + unsigned BSIM4v7fgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7kgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7rgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7aigcGiven :1; + unsigned BSIM4v7bigcGiven :1; + unsigned BSIM4v7cigcGiven :1; + unsigned BSIM4v7aigsdGiven :1; + unsigned BSIM4v7bigsdGiven :1; + unsigned BSIM4v7cigsdGiven :1; + unsigned BSIM4v7aigsGiven :1; + unsigned BSIM4v7bigsGiven :1; + unsigned BSIM4v7cigsGiven :1; + unsigned BSIM4v7aigdGiven :1; + unsigned BSIM4v7bigdGiven :1; + unsigned BSIM4v7cigdGiven :1; + unsigned BSIM4v7aigbaccGiven :1; + unsigned BSIM4v7bigbaccGiven :1; + unsigned BSIM4v7cigbaccGiven :1; + unsigned BSIM4v7aigbinvGiven :1; + unsigned BSIM4v7bigbinvGiven :1; + unsigned BSIM4v7cigbinvGiven :1; + unsigned BSIM4v7nigcGiven :1; + unsigned BSIM4v7nigbinvGiven :1; + unsigned BSIM4v7nigbaccGiven :1; + unsigned BSIM4v7ntoxGiven :1; + unsigned BSIM4v7eigbinvGiven :1; + unsigned BSIM4v7pigcdGiven :1; + unsigned BSIM4v7poxedgeGiven :1; + unsigned BSIM4v7ijthdfwdGiven :1; + unsigned BSIM4v7ijthsfwdGiven :1; + unsigned BSIM4v7ijthdrevGiven :1; + unsigned BSIM4v7ijthsrevGiven :1; + unsigned BSIM4v7xjbvdGiven :1; + unsigned BSIM4v7xjbvsGiven :1; + unsigned BSIM4v7bvdGiven :1; + unsigned BSIM4v7bvsGiven :1; - unsigned BSIM4jtssGiven :1; - unsigned BSIM4jtsdGiven :1; - unsigned BSIM4jtsswsGiven :1; - unsigned BSIM4jtsswdGiven :1; - unsigned BSIM4jtsswgsGiven :1; - unsigned BSIM4jtsswgdGiven :1; - unsigned BSIM4jtweffGiven :1; - unsigned BSIM4njtsGiven :1; - unsigned BSIM4njtsswGiven :1; - unsigned BSIM4njtsswgGiven :1; - unsigned BSIM4njtsdGiven :1; - unsigned BSIM4njtsswdGiven :1; - unsigned BSIM4njtsswgdGiven :1; - unsigned BSIM4xtssGiven :1; - unsigned BSIM4xtsdGiven :1; - unsigned BSIM4xtsswsGiven :1; - unsigned BSIM4xtsswdGiven :1; - unsigned BSIM4xtsswgsGiven :1; - unsigned BSIM4xtsswgdGiven :1; - unsigned BSIM4tnjtsGiven :1; - unsigned BSIM4tnjtsswGiven :1; - unsigned BSIM4tnjtsswgGiven :1; - unsigned BSIM4tnjtsdGiven :1; - unsigned BSIM4tnjtsswdGiven :1; - unsigned BSIM4tnjtsswgdGiven :1; - unsigned BSIM4vtssGiven :1; - unsigned BSIM4vtsdGiven :1; - unsigned BSIM4vtsswsGiven :1; - unsigned BSIM4vtsswdGiven :1; - unsigned BSIM4vtsswgsGiven :1; - unsigned BSIM4vtsswgdGiven :1; + unsigned BSIM4v7jtssGiven :1; + unsigned BSIM4v7jtsdGiven :1; + unsigned BSIM4v7jtsswsGiven :1; + unsigned BSIM4v7jtsswdGiven :1; + unsigned BSIM4v7jtsswgsGiven :1; + unsigned BSIM4v7jtsswgdGiven :1; + unsigned BSIM4v7jtweffGiven :1; + unsigned BSIM4v7njtsGiven :1; + unsigned BSIM4v7njtsswGiven :1; + unsigned BSIM4v7njtsswgGiven :1; + unsigned BSIM4v7njtsdGiven :1; + unsigned BSIM4v7njtsswdGiven :1; + unsigned BSIM4v7njtsswgdGiven :1; + unsigned BSIM4v7xtssGiven :1; + unsigned BSIM4v7xtsdGiven :1; + unsigned BSIM4v7xtsswsGiven :1; + unsigned BSIM4v7xtsswdGiven :1; + unsigned BSIM4v7xtsswgsGiven :1; + unsigned BSIM4v7xtsswgdGiven :1; + unsigned BSIM4v7tnjtsGiven :1; + unsigned BSIM4v7tnjtsswGiven :1; + unsigned BSIM4v7tnjtsswgGiven :1; + unsigned BSIM4v7tnjtsdGiven :1; + unsigned BSIM4v7tnjtsswdGiven :1; + unsigned BSIM4v7tnjtsswgdGiven :1; + unsigned BSIM4v7vtssGiven :1; + unsigned BSIM4v7vtsdGiven :1; + unsigned BSIM4v7vtsswsGiven :1; + unsigned BSIM4v7vtsswdGiven :1; + unsigned BSIM4v7vtsswgsGiven :1; + unsigned BSIM4v7vtsswgdGiven :1; - unsigned BSIM4vfbGiven :1; - unsigned BSIM4gbminGiven :1; - unsigned BSIM4rbdbGiven :1; - unsigned BSIM4rbsbGiven :1; - unsigned BSIM4rbpsGiven :1; - unsigned BSIM4rbpdGiven :1; - unsigned BSIM4rbpbGiven :1; + unsigned BSIM4v7vfbGiven :1; + unsigned BSIM4v7gbminGiven :1; + unsigned BSIM4v7rbdbGiven :1; + unsigned BSIM4v7rbsbGiven :1; + unsigned BSIM4v7rbpsGiven :1; + unsigned BSIM4v7rbpdGiven :1; + unsigned BSIM4v7rbpbGiven :1; - unsigned BSIM4rbps0Given :1; - unsigned BSIM4rbpslGiven :1; - unsigned BSIM4rbpswGiven :1; - unsigned BSIM4rbpsnfGiven :1; + unsigned BSIM4v7rbps0Given :1; + unsigned BSIM4v7rbpslGiven :1; + unsigned BSIM4v7rbpswGiven :1; + unsigned BSIM4v7rbpsnfGiven :1; - unsigned BSIM4rbpd0Given :1; - unsigned BSIM4rbpdlGiven :1; - unsigned BSIM4rbpdwGiven :1; - unsigned BSIM4rbpdnfGiven :1; + unsigned BSIM4v7rbpd0Given :1; + unsigned BSIM4v7rbpdlGiven :1; + unsigned BSIM4v7rbpdwGiven :1; + unsigned BSIM4v7rbpdnfGiven :1; - unsigned BSIM4rbpbx0Given :1; - unsigned BSIM4rbpbxlGiven :1; - unsigned BSIM4rbpbxwGiven :1; - unsigned BSIM4rbpbxnfGiven :1; - unsigned BSIM4rbpby0Given :1; - unsigned BSIM4rbpbylGiven :1; - unsigned BSIM4rbpbywGiven :1; - unsigned BSIM4rbpbynfGiven :1; + unsigned BSIM4v7rbpbx0Given :1; + unsigned BSIM4v7rbpbxlGiven :1; + unsigned BSIM4v7rbpbxwGiven :1; + unsigned BSIM4v7rbpbxnfGiven :1; + unsigned BSIM4v7rbpby0Given :1; + unsigned BSIM4v7rbpbylGiven :1; + unsigned BSIM4v7rbpbywGiven :1; + unsigned BSIM4v7rbpbynfGiven :1; - unsigned BSIM4rbsbx0Given :1; - unsigned BSIM4rbsby0Given :1; - unsigned BSIM4rbdbx0Given :1; - unsigned BSIM4rbdby0Given :1; + unsigned BSIM4v7rbsbx0Given :1; + unsigned BSIM4v7rbsby0Given :1; + unsigned BSIM4v7rbdbx0Given :1; + unsigned BSIM4v7rbdby0Given :1; - unsigned BSIM4rbsdbxlGiven :1; - unsigned BSIM4rbsdbxwGiven :1; - unsigned BSIM4rbsdbxnfGiven :1; - unsigned BSIM4rbsdbylGiven :1; - unsigned BSIM4rbsdbywGiven :1; - unsigned BSIM4rbsdbynfGiven :1; + unsigned BSIM4v7rbsdbxlGiven :1; + unsigned BSIM4v7rbsdbxwGiven :1; + unsigned BSIM4v7rbsdbxnfGiven :1; + unsigned BSIM4v7rbsdbylGiven :1; + unsigned BSIM4v7rbsdbywGiven :1; + unsigned BSIM4v7rbsdbynfGiven :1; - unsigned BSIM4xrcrg1Given :1; - unsigned BSIM4xrcrg2Given :1; - unsigned BSIM4tnoiaGiven :1; - unsigned BSIM4tnoibGiven :1; - unsigned BSIM4tnoicGiven :1; - unsigned BSIM4rnoiaGiven :1; - unsigned BSIM4rnoibGiven :1; - unsigned BSIM4rnoicGiven :1; - unsigned BSIM4ntnoiGiven :1; + unsigned BSIM4v7xrcrg1Given :1; + unsigned BSIM4v7xrcrg2Given :1; + unsigned BSIM4v7tnoiaGiven :1; + unsigned BSIM4v7tnoibGiven :1; + unsigned BSIM4v7tnoicGiven :1; + unsigned BSIM4v7rnoiaGiven :1; + unsigned BSIM4v7rnoibGiven :1; + unsigned BSIM4v7rnoicGiven :1; + unsigned BSIM4v7ntnoiGiven :1; - unsigned BSIM4lambdaGiven :1; - unsigned BSIM4vtlGiven :1; - unsigned BSIM4lcGiven :1; - unsigned BSIM4xnGiven :1; - unsigned BSIM4vfbsdoffGiven :1; - unsigned BSIM4lintnoiGiven :1; - unsigned BSIM4tvfbsdoffGiven :1; + unsigned BSIM4v7lambdaGiven :1; + unsigned BSIM4v7vtlGiven :1; + unsigned BSIM4v7lcGiven :1; + unsigned BSIM4v7xnGiven :1; + unsigned BSIM4v7vfbsdoffGiven :1; + unsigned BSIM4v7lintnoiGiven :1; + unsigned BSIM4v7tvfbsdoffGiven :1; /* CV model and parasitics */ - unsigned BSIM4cgslGiven :1; - unsigned BSIM4cgdlGiven :1; - unsigned BSIM4ckappasGiven :1; - unsigned BSIM4ckappadGiven :1; - unsigned BSIM4cfGiven :1; - unsigned BSIM4vfbcvGiven :1; - unsigned BSIM4clcGiven :1; - unsigned BSIM4cleGiven :1; - unsigned BSIM4dwcGiven :1; - unsigned BSIM4dlcGiven :1; - unsigned BSIM4xwGiven :1; - unsigned BSIM4xlGiven :1; - unsigned BSIM4dlcigGiven :1; - unsigned BSIM4dlcigdGiven :1; - unsigned BSIM4dwjGiven :1; - unsigned BSIM4noffGiven :1; - unsigned BSIM4voffcvGiven :1; - unsigned BSIM4acdeGiven :1; - unsigned BSIM4moinGiven :1; - unsigned BSIM4tcjGiven :1; - unsigned BSIM4tcjswGiven :1; - unsigned BSIM4tcjswgGiven :1; - unsigned BSIM4tpbGiven :1; - unsigned BSIM4tpbswGiven :1; - unsigned BSIM4tpbswgGiven :1; - unsigned BSIM4dmcgGiven :1; - unsigned BSIM4dmciGiven :1; - unsigned BSIM4dmdgGiven :1; - unsigned BSIM4dmcgtGiven :1; - unsigned BSIM4xgwGiven :1; - unsigned BSIM4xglGiven :1; - unsigned BSIM4rshgGiven :1; - unsigned BSIM4ngconGiven :1; + unsigned BSIM4v7cgslGiven :1; + unsigned BSIM4v7cgdlGiven :1; + unsigned BSIM4v7ckappasGiven :1; + unsigned BSIM4v7ckappadGiven :1; + unsigned BSIM4v7cfGiven :1; + unsigned BSIM4v7vfbcvGiven :1; + unsigned BSIM4v7clcGiven :1; + unsigned BSIM4v7cleGiven :1; + unsigned BSIM4v7dwcGiven :1; + unsigned BSIM4v7dlcGiven :1; + unsigned BSIM4v7xwGiven :1; + unsigned BSIM4v7xlGiven :1; + unsigned BSIM4v7dlcigGiven :1; + unsigned BSIM4v7dlcigdGiven :1; + unsigned BSIM4v7dwjGiven :1; + unsigned BSIM4v7noffGiven :1; + unsigned BSIM4v7voffcvGiven :1; + unsigned BSIM4v7acdeGiven :1; + unsigned BSIM4v7moinGiven :1; + unsigned BSIM4v7tcjGiven :1; + unsigned BSIM4v7tcjswGiven :1; + unsigned BSIM4v7tcjswgGiven :1; + unsigned BSIM4v7tpbGiven :1; + unsigned BSIM4v7tpbswGiven :1; + unsigned BSIM4v7tpbswgGiven :1; + unsigned BSIM4v7dmcgGiven :1; + unsigned BSIM4v7dmciGiven :1; + unsigned BSIM4v7dmdgGiven :1; + unsigned BSIM4v7dmcgtGiven :1; + unsigned BSIM4v7xgwGiven :1; + unsigned BSIM4v7xglGiven :1; + unsigned BSIM4v7rshgGiven :1; + unsigned BSIM4v7ngconGiven :1; /* Length dependence */ - unsigned BSIM4lcdscGiven :1; - unsigned BSIM4lcdscbGiven :1; - unsigned BSIM4lcdscdGiven :1; - unsigned BSIM4lcitGiven :1; - unsigned BSIM4lnfactorGiven :1; - unsigned BSIM4lxjGiven :1; - unsigned BSIM4lvsatGiven :1; - unsigned BSIM4latGiven :1; - unsigned BSIM4la0Given :1; - unsigned BSIM4lagsGiven :1; - unsigned BSIM4la1Given :1; - unsigned BSIM4la2Given :1; - unsigned BSIM4lketaGiven :1; - unsigned BSIM4lnsubGiven :1; - unsigned BSIM4lndepGiven :1; - unsigned BSIM4lnsdGiven :1; - unsigned BSIM4lphinGiven :1; - unsigned BSIM4lngateGiven :1; - unsigned BSIM4lgamma1Given :1; - unsigned BSIM4lgamma2Given :1; - unsigned BSIM4lvbxGiven :1; - unsigned BSIM4lvbmGiven :1; - unsigned BSIM4lxtGiven :1; - unsigned BSIM4lk1Given :1; - unsigned BSIM4lkt1Given :1; - unsigned BSIM4lkt1lGiven :1; - unsigned BSIM4lkt2Given :1; - unsigned BSIM4lk2Given :1; - unsigned BSIM4lk3Given :1; - unsigned BSIM4lk3bGiven :1; - unsigned BSIM4lw0Given :1; - unsigned BSIM4ldvtp0Given :1; - unsigned BSIM4ldvtp1Given :1; - unsigned BSIM4ldvtp2Given :1; /* New DIBL/Rout */ - unsigned BSIM4ldvtp3Given :1; - unsigned BSIM4ldvtp4Given :1; - unsigned BSIM4ldvtp5Given :1; - unsigned BSIM4llpe0Given :1; - unsigned BSIM4llpebGiven :1; - unsigned BSIM4ldvt0Given :1; - unsigned BSIM4ldvt1Given :1; - unsigned BSIM4ldvt2Given :1; - unsigned BSIM4ldvt0wGiven :1; - unsigned BSIM4ldvt1wGiven :1; - unsigned BSIM4ldvt2wGiven :1; - unsigned BSIM4ldroutGiven :1; - unsigned BSIM4ldsubGiven :1; - unsigned BSIM4lvth0Given :1; - unsigned BSIM4luaGiven :1; - unsigned BSIM4lua1Given :1; - unsigned BSIM4lubGiven :1; - unsigned BSIM4lub1Given :1; - unsigned BSIM4lucGiven :1; - unsigned BSIM4luc1Given :1; - unsigned BSIM4ludGiven :1; - unsigned BSIM4lud1Given :1; - unsigned BSIM4lupGiven :1; - unsigned BSIM4llpGiven :1; - unsigned BSIM4lu0Given :1; - unsigned BSIM4leuGiven :1; - unsigned BSIM4lucsGiven :1; - unsigned BSIM4luteGiven :1; - unsigned BSIM4lucsteGiven :1; - unsigned BSIM4lvoffGiven :1; - unsigned BSIM4ltvoffGiven :1; - unsigned BSIM4ltnfactorGiven :1; /* v4.7 Temp dep of leakage current */ - unsigned BSIM4lteta0Given :1; /* v4.7 temp dep of leakage current */ - unsigned BSIM4ltvoffcvGiven :1; /* v4.7 temp dep of leakage current */ - unsigned BSIM4lminvGiven :1; - unsigned BSIM4lminvcvGiven :1; - unsigned BSIM4lrdswGiven :1; - unsigned BSIM4lrswGiven :1; - unsigned BSIM4lrdwGiven :1; - unsigned BSIM4lprwgGiven :1; - unsigned BSIM4lprwbGiven :1; - unsigned BSIM4lprtGiven :1; - unsigned BSIM4leta0Given :1; - unsigned BSIM4letabGiven :1; - unsigned BSIM4lpclmGiven :1; - unsigned BSIM4lpdibl1Given :1; - unsigned BSIM4lpdibl2Given :1; - unsigned BSIM4lpdiblbGiven :1; - unsigned BSIM4lfproutGiven :1; - unsigned BSIM4lpditsGiven :1; - unsigned BSIM4lpditsdGiven :1; - unsigned BSIM4lpscbe1Given :1; - unsigned BSIM4lpscbe2Given :1; - unsigned BSIM4lpvagGiven :1; - unsigned BSIM4ldeltaGiven :1; - unsigned BSIM4lwrGiven :1; - unsigned BSIM4ldwgGiven :1; - unsigned BSIM4ldwbGiven :1; - unsigned BSIM4lb0Given :1; - unsigned BSIM4lb1Given :1; - unsigned BSIM4lalpha0Given :1; - unsigned BSIM4lalpha1Given :1; - unsigned BSIM4lbeta0Given :1; - unsigned BSIM4lvfbGiven :1; - unsigned BSIM4lagidlGiven :1; - unsigned BSIM4lbgidlGiven :1; - unsigned BSIM4lcgidlGiven :1; - unsigned BSIM4legidlGiven :1; - unsigned BSIM4lfgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4lkgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4lrgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4lagislGiven :1; - unsigned BSIM4lbgislGiven :1; - unsigned BSIM4lcgislGiven :1; - unsigned BSIM4legislGiven :1; - unsigned BSIM4lfgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4lkgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4lrgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4laigcGiven :1; - unsigned BSIM4lbigcGiven :1; - unsigned BSIM4lcigcGiven :1; - unsigned BSIM4laigsdGiven :1; - unsigned BSIM4lbigsdGiven :1; - unsigned BSIM4lcigsdGiven :1; - unsigned BSIM4laigsGiven :1; - unsigned BSIM4lbigsGiven :1; - unsigned BSIM4lcigsGiven :1; - unsigned BSIM4laigdGiven :1; - unsigned BSIM4lbigdGiven :1; - unsigned BSIM4lcigdGiven :1; - unsigned BSIM4laigbaccGiven :1; - unsigned BSIM4lbigbaccGiven :1; - unsigned BSIM4lcigbaccGiven :1; - unsigned BSIM4laigbinvGiven :1; - unsigned BSIM4lbigbinvGiven :1; - unsigned BSIM4lcigbinvGiven :1; - unsigned BSIM4lnigcGiven :1; - unsigned BSIM4lnigbinvGiven :1; - unsigned BSIM4lnigbaccGiven :1; - unsigned BSIM4lntoxGiven :1; - unsigned BSIM4leigbinvGiven :1; - unsigned BSIM4lpigcdGiven :1; - unsigned BSIM4lpoxedgeGiven :1; - unsigned BSIM4lxrcrg1Given :1; - unsigned BSIM4lxrcrg2Given :1; - unsigned BSIM4llambdaGiven :1; - unsigned BSIM4lvtlGiven :1; - unsigned BSIM4lxnGiven :1; - unsigned BSIM4lvfbsdoffGiven :1; - unsigned BSIM4ltvfbsdoffGiven :1; + unsigned BSIM4v7lcdscGiven :1; + unsigned BSIM4v7lcdscbGiven :1; + unsigned BSIM4v7lcdscdGiven :1; + unsigned BSIM4v7lcitGiven :1; + unsigned BSIM4v7lnfactorGiven :1; + unsigned BSIM4v7lxjGiven :1; + unsigned BSIM4v7lvsatGiven :1; + unsigned BSIM4v7latGiven :1; + unsigned BSIM4v7la0Given :1; + unsigned BSIM4v7lagsGiven :1; + unsigned BSIM4v7la1Given :1; + unsigned BSIM4v7la2Given :1; + unsigned BSIM4v7lketaGiven :1; + unsigned BSIM4v7lnsubGiven :1; + unsigned BSIM4v7lndepGiven :1; + unsigned BSIM4v7lnsdGiven :1; + unsigned BSIM4v7lphinGiven :1; + unsigned BSIM4v7lngateGiven :1; + unsigned BSIM4v7lgamma1Given :1; + unsigned BSIM4v7lgamma2Given :1; + unsigned BSIM4v7lvbxGiven :1; + unsigned BSIM4v7lvbmGiven :1; + unsigned BSIM4v7lxtGiven :1; + unsigned BSIM4v7lk1Given :1; + unsigned BSIM4v7lkt1Given :1; + unsigned BSIM4v7lkt1lGiven :1; + unsigned BSIM4v7lkt2Given :1; + unsigned BSIM4v7lk2Given :1; + unsigned BSIM4v7lk3Given :1; + unsigned BSIM4v7lk3bGiven :1; + unsigned BSIM4v7lw0Given :1; + unsigned BSIM4v7ldvtp0Given :1; + unsigned BSIM4v7ldvtp1Given :1; + unsigned BSIM4v7ldvtp2Given :1; /* New DIBL/Rout */ + unsigned BSIM4v7ldvtp3Given :1; + unsigned BSIM4v7ldvtp4Given :1; + unsigned BSIM4v7ldvtp5Given :1; + unsigned BSIM4v7llpe0Given :1; + unsigned BSIM4v7llpebGiven :1; + unsigned BSIM4v7ldvt0Given :1; + unsigned BSIM4v7ldvt1Given :1; + unsigned BSIM4v7ldvt2Given :1; + unsigned BSIM4v7ldvt0wGiven :1; + unsigned BSIM4v7ldvt1wGiven :1; + unsigned BSIM4v7ldvt2wGiven :1; + unsigned BSIM4v7ldroutGiven :1; + unsigned BSIM4v7ldsubGiven :1; + unsigned BSIM4v7lvth0Given :1; + unsigned BSIM4v7luaGiven :1; + unsigned BSIM4v7lua1Given :1; + unsigned BSIM4v7lubGiven :1; + unsigned BSIM4v7lub1Given :1; + unsigned BSIM4v7lucGiven :1; + unsigned BSIM4v7luc1Given :1; + unsigned BSIM4v7ludGiven :1; + unsigned BSIM4v7lud1Given :1; + unsigned BSIM4v7lupGiven :1; + unsigned BSIM4v7llpGiven :1; + unsigned BSIM4v7lu0Given :1; + unsigned BSIM4v7leuGiven :1; + unsigned BSIM4v7lucsGiven :1; + unsigned BSIM4v7luteGiven :1; + unsigned BSIM4v7lucsteGiven :1; + unsigned BSIM4v7lvoffGiven :1; + unsigned BSIM4v7ltvoffGiven :1; + unsigned BSIM4v7ltnfactorGiven :1; /* v4.7 Temp dep of leakage current */ + unsigned BSIM4v7lteta0Given :1; /* v4.7 temp dep of leakage current */ + unsigned BSIM4v7ltvoffcvGiven :1; /* v4.7 temp dep of leakage current */ + unsigned BSIM4v7lminvGiven :1; + unsigned BSIM4v7lminvcvGiven :1; + unsigned BSIM4v7lrdswGiven :1; + unsigned BSIM4v7lrswGiven :1; + unsigned BSIM4v7lrdwGiven :1; + unsigned BSIM4v7lprwgGiven :1; + unsigned BSIM4v7lprwbGiven :1; + unsigned BSIM4v7lprtGiven :1; + unsigned BSIM4v7leta0Given :1; + unsigned BSIM4v7letabGiven :1; + unsigned BSIM4v7lpclmGiven :1; + unsigned BSIM4v7lpdibl1Given :1; + unsigned BSIM4v7lpdibl2Given :1; + unsigned BSIM4v7lpdiblbGiven :1; + unsigned BSIM4v7lfproutGiven :1; + unsigned BSIM4v7lpditsGiven :1; + unsigned BSIM4v7lpditsdGiven :1; + unsigned BSIM4v7lpscbe1Given :1; + unsigned BSIM4v7lpscbe2Given :1; + unsigned BSIM4v7lpvagGiven :1; + unsigned BSIM4v7ldeltaGiven :1; + unsigned BSIM4v7lwrGiven :1; + unsigned BSIM4v7ldwgGiven :1; + unsigned BSIM4v7ldwbGiven :1; + unsigned BSIM4v7lb0Given :1; + unsigned BSIM4v7lb1Given :1; + unsigned BSIM4v7lalpha0Given :1; + unsigned BSIM4v7lalpha1Given :1; + unsigned BSIM4v7lbeta0Given :1; + unsigned BSIM4v7lvfbGiven :1; + unsigned BSIM4v7lagidlGiven :1; + unsigned BSIM4v7lbgidlGiven :1; + unsigned BSIM4v7lcgidlGiven :1; + unsigned BSIM4v7legidlGiven :1; + unsigned BSIM4v7lfgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7lkgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7lrgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7lagislGiven :1; + unsigned BSIM4v7lbgislGiven :1; + unsigned BSIM4v7lcgislGiven :1; + unsigned BSIM4v7legislGiven :1; + unsigned BSIM4v7lfgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7lkgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7lrgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7laigcGiven :1; + unsigned BSIM4v7lbigcGiven :1; + unsigned BSIM4v7lcigcGiven :1; + unsigned BSIM4v7laigsdGiven :1; + unsigned BSIM4v7lbigsdGiven :1; + unsigned BSIM4v7lcigsdGiven :1; + unsigned BSIM4v7laigsGiven :1; + unsigned BSIM4v7lbigsGiven :1; + unsigned BSIM4v7lcigsGiven :1; + unsigned BSIM4v7laigdGiven :1; + unsigned BSIM4v7lbigdGiven :1; + unsigned BSIM4v7lcigdGiven :1; + unsigned BSIM4v7laigbaccGiven :1; + unsigned BSIM4v7lbigbaccGiven :1; + unsigned BSIM4v7lcigbaccGiven :1; + unsigned BSIM4v7laigbinvGiven :1; + unsigned BSIM4v7lbigbinvGiven :1; + unsigned BSIM4v7lcigbinvGiven :1; + unsigned BSIM4v7lnigcGiven :1; + unsigned BSIM4v7lnigbinvGiven :1; + unsigned BSIM4v7lnigbaccGiven :1; + unsigned BSIM4v7lntoxGiven :1; + unsigned BSIM4v7leigbinvGiven :1; + unsigned BSIM4v7lpigcdGiven :1; + unsigned BSIM4v7lpoxedgeGiven :1; + unsigned BSIM4v7lxrcrg1Given :1; + unsigned BSIM4v7lxrcrg2Given :1; + unsigned BSIM4v7llambdaGiven :1; + unsigned BSIM4v7lvtlGiven :1; + unsigned BSIM4v7lxnGiven :1; + unsigned BSIM4v7lvfbsdoffGiven :1; + unsigned BSIM4v7ltvfbsdoffGiven :1; /* CV model */ - unsigned BSIM4lcgslGiven :1; - unsigned BSIM4lcgdlGiven :1; - unsigned BSIM4lckappasGiven :1; - unsigned BSIM4lckappadGiven :1; - unsigned BSIM4lcfGiven :1; - unsigned BSIM4lclcGiven :1; - unsigned BSIM4lcleGiven :1; - unsigned BSIM4lvfbcvGiven :1; - unsigned BSIM4lnoffGiven :1; - unsigned BSIM4lvoffcvGiven :1; - unsigned BSIM4lacdeGiven :1; - unsigned BSIM4lmoinGiven :1; + unsigned BSIM4v7lcgslGiven :1; + unsigned BSIM4v7lcgdlGiven :1; + unsigned BSIM4v7lckappasGiven :1; + unsigned BSIM4v7lckappadGiven :1; + unsigned BSIM4v7lcfGiven :1; + unsigned BSIM4v7lclcGiven :1; + unsigned BSIM4v7lcleGiven :1; + unsigned BSIM4v7lvfbcvGiven :1; + unsigned BSIM4v7lnoffGiven :1; + unsigned BSIM4v7lvoffcvGiven :1; + unsigned BSIM4v7lacdeGiven :1; + unsigned BSIM4v7lmoinGiven :1; /* Width dependence */ - unsigned BSIM4wcdscGiven :1; - unsigned BSIM4wcdscbGiven :1; - unsigned BSIM4wcdscdGiven :1; - unsigned BSIM4wcitGiven :1; - unsigned BSIM4wnfactorGiven :1; - unsigned BSIM4wxjGiven :1; - unsigned BSIM4wvsatGiven :1; - unsigned BSIM4watGiven :1; - unsigned BSIM4wa0Given :1; - unsigned BSIM4wagsGiven :1; - unsigned BSIM4wa1Given :1; - unsigned BSIM4wa2Given :1; - unsigned BSIM4wketaGiven :1; - unsigned BSIM4wnsubGiven :1; - unsigned BSIM4wndepGiven :1; - unsigned BSIM4wnsdGiven :1; - unsigned BSIM4wphinGiven :1; - unsigned BSIM4wngateGiven :1; - unsigned BSIM4wgamma1Given :1; - unsigned BSIM4wgamma2Given :1; - unsigned BSIM4wvbxGiven :1; - unsigned BSIM4wvbmGiven :1; - unsigned BSIM4wxtGiven :1; - unsigned BSIM4wk1Given :1; - unsigned BSIM4wkt1Given :1; - unsigned BSIM4wkt1lGiven :1; - unsigned BSIM4wkt2Given :1; - unsigned BSIM4wk2Given :1; - unsigned BSIM4wk3Given :1; - unsigned BSIM4wk3bGiven :1; - unsigned BSIM4ww0Given :1; - unsigned BSIM4wdvtp0Given :1; - unsigned BSIM4wdvtp1Given :1; - unsigned BSIM4wdvtp2Given :1; /* New DIBL/Rout */ - unsigned BSIM4wdvtp3Given :1; - unsigned BSIM4wdvtp4Given :1; - unsigned BSIM4wdvtp5Given :1; - unsigned BSIM4wlpe0Given :1; - unsigned BSIM4wlpebGiven :1; - unsigned BSIM4wdvt0Given :1; - unsigned BSIM4wdvt1Given :1; - unsigned BSIM4wdvt2Given :1; - unsigned BSIM4wdvt0wGiven :1; - unsigned BSIM4wdvt1wGiven :1; - unsigned BSIM4wdvt2wGiven :1; - unsigned BSIM4wdroutGiven :1; - unsigned BSIM4wdsubGiven :1; - unsigned BSIM4wvth0Given :1; - unsigned BSIM4wuaGiven :1; - unsigned BSIM4wua1Given :1; - unsigned BSIM4wubGiven :1; - unsigned BSIM4wub1Given :1; - unsigned BSIM4wucGiven :1; - unsigned BSIM4wuc1Given :1; - unsigned BSIM4wudGiven :1; - unsigned BSIM4wud1Given :1; - unsigned BSIM4wupGiven :1; - unsigned BSIM4wlpGiven :1; - unsigned BSIM4wu0Given :1; - unsigned BSIM4weuGiven :1; - unsigned BSIM4wucsGiven :1; - unsigned BSIM4wuteGiven :1; - unsigned BSIM4wucsteGiven :1; - unsigned BSIM4wvoffGiven :1; - unsigned BSIM4wtvoffGiven :1; - unsigned BSIM4wtnfactorGiven :1; /* v4.7 Temp dep of leakage current */ - unsigned BSIM4wteta0Given :1; /* v4.7 temp dep of leakage current */ - unsigned BSIM4wtvoffcvGiven :1; /* v4.7 temp dep of leakage current */ - unsigned BSIM4wminvGiven :1; - unsigned BSIM4wminvcvGiven :1; - unsigned BSIM4wrdswGiven :1; - unsigned BSIM4wrswGiven :1; - unsigned BSIM4wrdwGiven :1; - unsigned BSIM4wprwgGiven :1; - unsigned BSIM4wprwbGiven :1; - unsigned BSIM4wprtGiven :1; - unsigned BSIM4weta0Given :1; - unsigned BSIM4wetabGiven :1; - unsigned BSIM4wpclmGiven :1; - unsigned BSIM4wpdibl1Given :1; - unsigned BSIM4wpdibl2Given :1; - unsigned BSIM4wpdiblbGiven :1; - unsigned BSIM4wfproutGiven :1; - unsigned BSIM4wpditsGiven :1; - unsigned BSIM4wpditsdGiven :1; - unsigned BSIM4wpscbe1Given :1; - unsigned BSIM4wpscbe2Given :1; - unsigned BSIM4wpvagGiven :1; - unsigned BSIM4wdeltaGiven :1; - unsigned BSIM4wwrGiven :1; - unsigned BSIM4wdwgGiven :1; - unsigned BSIM4wdwbGiven :1; - unsigned BSIM4wb0Given :1; - unsigned BSIM4wb1Given :1; - unsigned BSIM4walpha0Given :1; - unsigned BSIM4walpha1Given :1; - unsigned BSIM4wbeta0Given :1; - unsigned BSIM4wvfbGiven :1; - unsigned BSIM4wagidlGiven :1; - unsigned BSIM4wbgidlGiven :1; - unsigned BSIM4wcgidlGiven :1; - unsigned BSIM4wegidlGiven :1; - unsigned BSIM4wfgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4wkgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4wrgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4wagislGiven :1; - unsigned BSIM4wbgislGiven :1; - unsigned BSIM4wcgislGiven :1; - unsigned BSIM4wegislGiven :1; - unsigned BSIM4wfgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4wkgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4wrgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4waigcGiven :1; - unsigned BSIM4wbigcGiven :1; - unsigned BSIM4wcigcGiven :1; - unsigned BSIM4waigsdGiven :1; - unsigned BSIM4wbigsdGiven :1; - unsigned BSIM4wcigsdGiven :1; - unsigned BSIM4waigsGiven :1; - unsigned BSIM4wbigsGiven :1; - unsigned BSIM4wcigsGiven :1; - unsigned BSIM4waigdGiven :1; - unsigned BSIM4wbigdGiven :1; - unsigned BSIM4wcigdGiven :1; - unsigned BSIM4waigbaccGiven :1; - unsigned BSIM4wbigbaccGiven :1; - unsigned BSIM4wcigbaccGiven :1; - unsigned BSIM4waigbinvGiven :1; - unsigned BSIM4wbigbinvGiven :1; - unsigned BSIM4wcigbinvGiven :1; - unsigned BSIM4wnigcGiven :1; - unsigned BSIM4wnigbinvGiven :1; - unsigned BSIM4wnigbaccGiven :1; - unsigned BSIM4wntoxGiven :1; - unsigned BSIM4weigbinvGiven :1; - unsigned BSIM4wpigcdGiven :1; - unsigned BSIM4wpoxedgeGiven :1; - unsigned BSIM4wxrcrg1Given :1; - unsigned BSIM4wxrcrg2Given :1; - unsigned BSIM4wlambdaGiven :1; - unsigned BSIM4wvtlGiven :1; - unsigned BSIM4wxnGiven :1; - unsigned BSIM4wvfbsdoffGiven :1; - unsigned BSIM4wtvfbsdoffGiven :1; + unsigned BSIM4v7wcdscGiven :1; + unsigned BSIM4v7wcdscbGiven :1; + unsigned BSIM4v7wcdscdGiven :1; + unsigned BSIM4v7wcitGiven :1; + unsigned BSIM4v7wnfactorGiven :1; + unsigned BSIM4v7wxjGiven :1; + unsigned BSIM4v7wvsatGiven :1; + unsigned BSIM4v7watGiven :1; + unsigned BSIM4v7wa0Given :1; + unsigned BSIM4v7wagsGiven :1; + unsigned BSIM4v7wa1Given :1; + unsigned BSIM4v7wa2Given :1; + unsigned BSIM4v7wketaGiven :1; + unsigned BSIM4v7wnsubGiven :1; + unsigned BSIM4v7wndepGiven :1; + unsigned BSIM4v7wnsdGiven :1; + unsigned BSIM4v7wphinGiven :1; + unsigned BSIM4v7wngateGiven :1; + unsigned BSIM4v7wgamma1Given :1; + unsigned BSIM4v7wgamma2Given :1; + unsigned BSIM4v7wvbxGiven :1; + unsigned BSIM4v7wvbmGiven :1; + unsigned BSIM4v7wxtGiven :1; + unsigned BSIM4v7wk1Given :1; + unsigned BSIM4v7wkt1Given :1; + unsigned BSIM4v7wkt1lGiven :1; + unsigned BSIM4v7wkt2Given :1; + unsigned BSIM4v7wk2Given :1; + unsigned BSIM4v7wk3Given :1; + unsigned BSIM4v7wk3bGiven :1; + unsigned BSIM4v7ww0Given :1; + unsigned BSIM4v7wdvtp0Given :1; + unsigned BSIM4v7wdvtp1Given :1; + unsigned BSIM4v7wdvtp2Given :1; /* New DIBL/Rout */ + unsigned BSIM4v7wdvtp3Given :1; + unsigned BSIM4v7wdvtp4Given :1; + unsigned BSIM4v7wdvtp5Given :1; + unsigned BSIM4v7wlpe0Given :1; + unsigned BSIM4v7wlpebGiven :1; + unsigned BSIM4v7wdvt0Given :1; + unsigned BSIM4v7wdvt1Given :1; + unsigned BSIM4v7wdvt2Given :1; + unsigned BSIM4v7wdvt0wGiven :1; + unsigned BSIM4v7wdvt1wGiven :1; + unsigned BSIM4v7wdvt2wGiven :1; + unsigned BSIM4v7wdroutGiven :1; + unsigned BSIM4v7wdsubGiven :1; + unsigned BSIM4v7wvth0Given :1; + unsigned BSIM4v7wuaGiven :1; + unsigned BSIM4v7wua1Given :1; + unsigned BSIM4v7wubGiven :1; + unsigned BSIM4v7wub1Given :1; + unsigned BSIM4v7wucGiven :1; + unsigned BSIM4v7wuc1Given :1; + unsigned BSIM4v7wudGiven :1; + unsigned BSIM4v7wud1Given :1; + unsigned BSIM4v7wupGiven :1; + unsigned BSIM4v7wlpGiven :1; + unsigned BSIM4v7wu0Given :1; + unsigned BSIM4v7weuGiven :1; + unsigned BSIM4v7wucsGiven :1; + unsigned BSIM4v7wuteGiven :1; + unsigned BSIM4v7wucsteGiven :1; + unsigned BSIM4v7wvoffGiven :1; + unsigned BSIM4v7wtvoffGiven :1; + unsigned BSIM4v7wtnfactorGiven :1; /* v4.7 Temp dep of leakage current */ + unsigned BSIM4v7wteta0Given :1; /* v4.7 temp dep of leakage current */ + unsigned BSIM4v7wtvoffcvGiven :1; /* v4.7 temp dep of leakage current */ + unsigned BSIM4v7wminvGiven :1; + unsigned BSIM4v7wminvcvGiven :1; + unsigned BSIM4v7wrdswGiven :1; + unsigned BSIM4v7wrswGiven :1; + unsigned BSIM4v7wrdwGiven :1; + unsigned BSIM4v7wprwgGiven :1; + unsigned BSIM4v7wprwbGiven :1; + unsigned BSIM4v7wprtGiven :1; + unsigned BSIM4v7weta0Given :1; + unsigned BSIM4v7wetabGiven :1; + unsigned BSIM4v7wpclmGiven :1; + unsigned BSIM4v7wpdibl1Given :1; + unsigned BSIM4v7wpdibl2Given :1; + unsigned BSIM4v7wpdiblbGiven :1; + unsigned BSIM4v7wfproutGiven :1; + unsigned BSIM4v7wpditsGiven :1; + unsigned BSIM4v7wpditsdGiven :1; + unsigned BSIM4v7wpscbe1Given :1; + unsigned BSIM4v7wpscbe2Given :1; + unsigned BSIM4v7wpvagGiven :1; + unsigned BSIM4v7wdeltaGiven :1; + unsigned BSIM4v7wwrGiven :1; + unsigned BSIM4v7wdwgGiven :1; + unsigned BSIM4v7wdwbGiven :1; + unsigned BSIM4v7wb0Given :1; + unsigned BSIM4v7wb1Given :1; + unsigned BSIM4v7walpha0Given :1; + unsigned BSIM4v7walpha1Given :1; + unsigned BSIM4v7wbeta0Given :1; + unsigned BSIM4v7wvfbGiven :1; + unsigned BSIM4v7wagidlGiven :1; + unsigned BSIM4v7wbgidlGiven :1; + unsigned BSIM4v7wcgidlGiven :1; + unsigned BSIM4v7wegidlGiven :1; + unsigned BSIM4v7wfgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7wkgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7wrgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7wagislGiven :1; + unsigned BSIM4v7wbgislGiven :1; + unsigned BSIM4v7wcgislGiven :1; + unsigned BSIM4v7wegislGiven :1; + unsigned BSIM4v7wfgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7wkgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7wrgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7waigcGiven :1; + unsigned BSIM4v7wbigcGiven :1; + unsigned BSIM4v7wcigcGiven :1; + unsigned BSIM4v7waigsdGiven :1; + unsigned BSIM4v7wbigsdGiven :1; + unsigned BSIM4v7wcigsdGiven :1; + unsigned BSIM4v7waigsGiven :1; + unsigned BSIM4v7wbigsGiven :1; + unsigned BSIM4v7wcigsGiven :1; + unsigned BSIM4v7waigdGiven :1; + unsigned BSIM4v7wbigdGiven :1; + unsigned BSIM4v7wcigdGiven :1; + unsigned BSIM4v7waigbaccGiven :1; + unsigned BSIM4v7wbigbaccGiven :1; + unsigned BSIM4v7wcigbaccGiven :1; + unsigned BSIM4v7waigbinvGiven :1; + unsigned BSIM4v7wbigbinvGiven :1; + unsigned BSIM4v7wcigbinvGiven :1; + unsigned BSIM4v7wnigcGiven :1; + unsigned BSIM4v7wnigbinvGiven :1; + unsigned BSIM4v7wnigbaccGiven :1; + unsigned BSIM4v7wntoxGiven :1; + unsigned BSIM4v7weigbinvGiven :1; + unsigned BSIM4v7wpigcdGiven :1; + unsigned BSIM4v7wpoxedgeGiven :1; + unsigned BSIM4v7wxrcrg1Given :1; + unsigned BSIM4v7wxrcrg2Given :1; + unsigned BSIM4v7wlambdaGiven :1; + unsigned BSIM4v7wvtlGiven :1; + unsigned BSIM4v7wxnGiven :1; + unsigned BSIM4v7wvfbsdoffGiven :1; + unsigned BSIM4v7wtvfbsdoffGiven :1; /* CV model */ - unsigned BSIM4wcgslGiven :1; - unsigned BSIM4wcgdlGiven :1; - unsigned BSIM4wckappasGiven :1; - unsigned BSIM4wckappadGiven :1; - unsigned BSIM4wcfGiven :1; - unsigned BSIM4wclcGiven :1; - unsigned BSIM4wcleGiven :1; - unsigned BSIM4wvfbcvGiven :1; - unsigned BSIM4wnoffGiven :1; - unsigned BSIM4wvoffcvGiven :1; - unsigned BSIM4wacdeGiven :1; - unsigned BSIM4wmoinGiven :1; + unsigned BSIM4v7wcgslGiven :1; + unsigned BSIM4v7wcgdlGiven :1; + unsigned BSIM4v7wckappasGiven :1; + unsigned BSIM4v7wckappadGiven :1; + unsigned BSIM4v7wcfGiven :1; + unsigned BSIM4v7wclcGiven :1; + unsigned BSIM4v7wcleGiven :1; + unsigned BSIM4v7wvfbcvGiven :1; + unsigned BSIM4v7wnoffGiven :1; + unsigned BSIM4v7wvoffcvGiven :1; + unsigned BSIM4v7wacdeGiven :1; + unsigned BSIM4v7wmoinGiven :1; /* Cross-term dependence */ - unsigned BSIM4pcdscGiven :1; - unsigned BSIM4pcdscbGiven :1; - unsigned BSIM4pcdscdGiven :1; - unsigned BSIM4pcitGiven :1; - unsigned BSIM4pnfactorGiven :1; - unsigned BSIM4pxjGiven :1; - unsigned BSIM4pvsatGiven :1; - unsigned BSIM4patGiven :1; - unsigned BSIM4pa0Given :1; - unsigned BSIM4pagsGiven :1; - unsigned BSIM4pa1Given :1; - unsigned BSIM4pa2Given :1; - unsigned BSIM4pketaGiven :1; - unsigned BSIM4pnsubGiven :1; - unsigned BSIM4pndepGiven :1; - unsigned BSIM4pnsdGiven :1; - unsigned BSIM4pphinGiven :1; - unsigned BSIM4pngateGiven :1; - unsigned BSIM4pgamma1Given :1; - unsigned BSIM4pgamma2Given :1; - unsigned BSIM4pvbxGiven :1; - unsigned BSIM4pvbmGiven :1; - unsigned BSIM4pxtGiven :1; - unsigned BSIM4pk1Given :1; - unsigned BSIM4pkt1Given :1; - unsigned BSIM4pkt1lGiven :1; - unsigned BSIM4pkt2Given :1; - unsigned BSIM4pk2Given :1; - unsigned BSIM4pk3Given :1; - unsigned BSIM4pk3bGiven :1; - unsigned BSIM4pw0Given :1; - unsigned BSIM4pdvtp0Given :1; - unsigned BSIM4pdvtp1Given :1; - unsigned BSIM4pdvtp2Given :1; /* New DIBL/Rout */ - unsigned BSIM4pdvtp3Given :1; - unsigned BSIM4pdvtp4Given :1; - unsigned BSIM4pdvtp5Given :1; - unsigned BSIM4plpe0Given :1; - unsigned BSIM4plpebGiven :1; - unsigned BSIM4pdvt0Given :1; - unsigned BSIM4pdvt1Given :1; - unsigned BSIM4pdvt2Given :1; - unsigned BSIM4pdvt0wGiven :1; - unsigned BSIM4pdvt1wGiven :1; - unsigned BSIM4pdvt2wGiven :1; - unsigned BSIM4pdroutGiven :1; - unsigned BSIM4pdsubGiven :1; - unsigned BSIM4pvth0Given :1; - unsigned BSIM4puaGiven :1; - unsigned BSIM4pua1Given :1; - unsigned BSIM4pubGiven :1; - unsigned BSIM4pub1Given :1; - unsigned BSIM4pucGiven :1; - unsigned BSIM4puc1Given :1; - unsigned BSIM4pudGiven :1; - unsigned BSIM4pud1Given :1; - unsigned BSIM4pupGiven :1; - unsigned BSIM4plpGiven :1; - unsigned BSIM4pu0Given :1; - unsigned BSIM4peuGiven :1; - unsigned BSIM4pucsGiven :1; - unsigned BSIM4puteGiven :1; - unsigned BSIM4pucsteGiven :1; - unsigned BSIM4pvoffGiven :1; - unsigned BSIM4ptvoffGiven :1; - unsigned BSIM4ptnfactorGiven :1; /* v4.7 Temp dep of leakage current */ - unsigned BSIM4pteta0Given :1; /* v4.7 temp dep of leakage current */ - unsigned BSIM4ptvoffcvGiven :1; /* v4.7 temp dep of leakage current */ - unsigned BSIM4pminvGiven :1; - unsigned BSIM4pminvcvGiven :1; - unsigned BSIM4prdswGiven :1; - unsigned BSIM4prswGiven :1; - unsigned BSIM4prdwGiven :1; - unsigned BSIM4pprwgGiven :1; - unsigned BSIM4pprwbGiven :1; - unsigned BSIM4pprtGiven :1; - unsigned BSIM4peta0Given :1; - unsigned BSIM4petabGiven :1; - unsigned BSIM4ppclmGiven :1; - unsigned BSIM4ppdibl1Given :1; - unsigned BSIM4ppdibl2Given :1; - unsigned BSIM4ppdiblbGiven :1; - unsigned BSIM4pfproutGiven :1; - unsigned BSIM4ppditsGiven :1; - unsigned BSIM4ppditsdGiven :1; - unsigned BSIM4ppscbe1Given :1; - unsigned BSIM4ppscbe2Given :1; - unsigned BSIM4ppvagGiven :1; - unsigned BSIM4pdeltaGiven :1; - unsigned BSIM4pwrGiven :1; - unsigned BSIM4pdwgGiven :1; - unsigned BSIM4pdwbGiven :1; - unsigned BSIM4pb0Given :1; - unsigned BSIM4pb1Given :1; - unsigned BSIM4palpha0Given :1; - unsigned BSIM4palpha1Given :1; - unsigned BSIM4pbeta0Given :1; - unsigned BSIM4pvfbGiven :1; - unsigned BSIM4pagidlGiven :1; - unsigned BSIM4pbgidlGiven :1; - unsigned BSIM4pcgidlGiven :1; - unsigned BSIM4pegidlGiven :1; - unsigned BSIM4pfgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4pkgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4prgidlGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4pagislGiven :1; - unsigned BSIM4pbgislGiven :1; - unsigned BSIM4pcgislGiven :1; - unsigned BSIM4pegislGiven :1; - unsigned BSIM4pfgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4pkgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4prgislGiven :1; /* v4.7 New GIDL/GISL */ - unsigned BSIM4paigcGiven :1; - unsigned BSIM4pbigcGiven :1; - unsigned BSIM4pcigcGiven :1; - unsigned BSIM4paigsdGiven :1; - unsigned BSIM4pbigsdGiven :1; - unsigned BSIM4pcigsdGiven :1; - unsigned BSIM4paigsGiven :1; - unsigned BSIM4pbigsGiven :1; - unsigned BSIM4pcigsGiven :1; - unsigned BSIM4paigdGiven :1; - unsigned BSIM4pbigdGiven :1; - unsigned BSIM4pcigdGiven :1; - unsigned BSIM4paigbaccGiven :1; - unsigned BSIM4pbigbaccGiven :1; - unsigned BSIM4pcigbaccGiven :1; - unsigned BSIM4paigbinvGiven :1; - unsigned BSIM4pbigbinvGiven :1; - unsigned BSIM4pcigbinvGiven :1; - unsigned BSIM4pnigcGiven :1; - unsigned BSIM4pnigbinvGiven :1; - unsigned BSIM4pnigbaccGiven :1; - unsigned BSIM4pntoxGiven :1; - unsigned BSIM4peigbinvGiven :1; - unsigned BSIM4ppigcdGiven :1; - unsigned BSIM4ppoxedgeGiven :1; - unsigned BSIM4pxrcrg1Given :1; - unsigned BSIM4pxrcrg2Given :1; - unsigned BSIM4plambdaGiven :1; - unsigned BSIM4pvtlGiven :1; - unsigned BSIM4pxnGiven :1; - unsigned BSIM4pvfbsdoffGiven :1; - unsigned BSIM4ptvfbsdoffGiven :1; + unsigned BSIM4v7pcdscGiven :1; + unsigned BSIM4v7pcdscbGiven :1; + unsigned BSIM4v7pcdscdGiven :1; + unsigned BSIM4v7pcitGiven :1; + unsigned BSIM4v7pnfactorGiven :1; + unsigned BSIM4v7pxjGiven :1; + unsigned BSIM4v7pvsatGiven :1; + unsigned BSIM4v7patGiven :1; + unsigned BSIM4v7pa0Given :1; + unsigned BSIM4v7pagsGiven :1; + unsigned BSIM4v7pa1Given :1; + unsigned BSIM4v7pa2Given :1; + unsigned BSIM4v7pketaGiven :1; + unsigned BSIM4v7pnsubGiven :1; + unsigned BSIM4v7pndepGiven :1; + unsigned BSIM4v7pnsdGiven :1; + unsigned BSIM4v7pphinGiven :1; + unsigned BSIM4v7pngateGiven :1; + unsigned BSIM4v7pgamma1Given :1; + unsigned BSIM4v7pgamma2Given :1; + unsigned BSIM4v7pvbxGiven :1; + unsigned BSIM4v7pvbmGiven :1; + unsigned BSIM4v7pxtGiven :1; + unsigned BSIM4v7pk1Given :1; + unsigned BSIM4v7pkt1Given :1; + unsigned BSIM4v7pkt1lGiven :1; + unsigned BSIM4v7pkt2Given :1; + unsigned BSIM4v7pk2Given :1; + unsigned BSIM4v7pk3Given :1; + unsigned BSIM4v7pk3bGiven :1; + unsigned BSIM4v7pw0Given :1; + unsigned BSIM4v7pdvtp0Given :1; + unsigned BSIM4v7pdvtp1Given :1; + unsigned BSIM4v7pdvtp2Given :1; /* New DIBL/Rout */ + unsigned BSIM4v7pdvtp3Given :1; + unsigned BSIM4v7pdvtp4Given :1; + unsigned BSIM4v7pdvtp5Given :1; + unsigned BSIM4v7plpe0Given :1; + unsigned BSIM4v7plpebGiven :1; + unsigned BSIM4v7pdvt0Given :1; + unsigned BSIM4v7pdvt1Given :1; + unsigned BSIM4v7pdvt2Given :1; + unsigned BSIM4v7pdvt0wGiven :1; + unsigned BSIM4v7pdvt1wGiven :1; + unsigned BSIM4v7pdvt2wGiven :1; + unsigned BSIM4v7pdroutGiven :1; + unsigned BSIM4v7pdsubGiven :1; + unsigned BSIM4v7pvth0Given :1; + unsigned BSIM4v7puaGiven :1; + unsigned BSIM4v7pua1Given :1; + unsigned BSIM4v7pubGiven :1; + unsigned BSIM4v7pub1Given :1; + unsigned BSIM4v7pucGiven :1; + unsigned BSIM4v7puc1Given :1; + unsigned BSIM4v7pudGiven :1; + unsigned BSIM4v7pud1Given :1; + unsigned BSIM4v7pupGiven :1; + unsigned BSIM4v7plpGiven :1; + unsigned BSIM4v7pu0Given :1; + unsigned BSIM4v7peuGiven :1; + unsigned BSIM4v7pucsGiven :1; + unsigned BSIM4v7puteGiven :1; + unsigned BSIM4v7pucsteGiven :1; + unsigned BSIM4v7pvoffGiven :1; + unsigned BSIM4v7ptvoffGiven :1; + unsigned BSIM4v7ptnfactorGiven :1; /* v4.7 Temp dep of leakage current */ + unsigned BSIM4v7pteta0Given :1; /* v4.7 temp dep of leakage current */ + unsigned BSIM4v7ptvoffcvGiven :1; /* v4.7 temp dep of leakage current */ + unsigned BSIM4v7pminvGiven :1; + unsigned BSIM4v7pminvcvGiven :1; + unsigned BSIM4v7prdswGiven :1; + unsigned BSIM4v7prswGiven :1; + unsigned BSIM4v7prdwGiven :1; + unsigned BSIM4v7pprwgGiven :1; + unsigned BSIM4v7pprwbGiven :1; + unsigned BSIM4v7pprtGiven :1; + unsigned BSIM4v7peta0Given :1; + unsigned BSIM4v7petabGiven :1; + unsigned BSIM4v7ppclmGiven :1; + unsigned BSIM4v7ppdibl1Given :1; + unsigned BSIM4v7ppdibl2Given :1; + unsigned BSIM4v7ppdiblbGiven :1; + unsigned BSIM4v7pfproutGiven :1; + unsigned BSIM4v7ppditsGiven :1; + unsigned BSIM4v7ppditsdGiven :1; + unsigned BSIM4v7ppscbe1Given :1; + unsigned BSIM4v7ppscbe2Given :1; + unsigned BSIM4v7ppvagGiven :1; + unsigned BSIM4v7pdeltaGiven :1; + unsigned BSIM4v7pwrGiven :1; + unsigned BSIM4v7pdwgGiven :1; + unsigned BSIM4v7pdwbGiven :1; + unsigned BSIM4v7pb0Given :1; + unsigned BSIM4v7pb1Given :1; + unsigned BSIM4v7palpha0Given :1; + unsigned BSIM4v7palpha1Given :1; + unsigned BSIM4v7pbeta0Given :1; + unsigned BSIM4v7pvfbGiven :1; + unsigned BSIM4v7pagidlGiven :1; + unsigned BSIM4v7pbgidlGiven :1; + unsigned BSIM4v7pcgidlGiven :1; + unsigned BSIM4v7pegidlGiven :1; + unsigned BSIM4v7pfgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7pkgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7prgidlGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7pagislGiven :1; + unsigned BSIM4v7pbgislGiven :1; + unsigned BSIM4v7pcgislGiven :1; + unsigned BSIM4v7pegislGiven :1; + unsigned BSIM4v7pfgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7pkgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7prgislGiven :1; /* v4.7 New GIDL/GISL */ + unsigned BSIM4v7paigcGiven :1; + unsigned BSIM4v7pbigcGiven :1; + unsigned BSIM4v7pcigcGiven :1; + unsigned BSIM4v7paigsdGiven :1; + unsigned BSIM4v7pbigsdGiven :1; + unsigned BSIM4v7pcigsdGiven :1; + unsigned BSIM4v7paigsGiven :1; + unsigned BSIM4v7pbigsGiven :1; + unsigned BSIM4v7pcigsGiven :1; + unsigned BSIM4v7paigdGiven :1; + unsigned BSIM4v7pbigdGiven :1; + unsigned BSIM4v7pcigdGiven :1; + unsigned BSIM4v7paigbaccGiven :1; + unsigned BSIM4v7pbigbaccGiven :1; + unsigned BSIM4v7pcigbaccGiven :1; + unsigned BSIM4v7paigbinvGiven :1; + unsigned BSIM4v7pbigbinvGiven :1; + unsigned BSIM4v7pcigbinvGiven :1; + unsigned BSIM4v7pnigcGiven :1; + unsigned BSIM4v7pnigbinvGiven :1; + unsigned BSIM4v7pnigbaccGiven :1; + unsigned BSIM4v7pntoxGiven :1; + unsigned BSIM4v7peigbinvGiven :1; + unsigned BSIM4v7ppigcdGiven :1; + unsigned BSIM4v7ppoxedgeGiven :1; + unsigned BSIM4v7pxrcrg1Given :1; + unsigned BSIM4v7pxrcrg2Given :1; + unsigned BSIM4v7plambdaGiven :1; + unsigned BSIM4v7pvtlGiven :1; + unsigned BSIM4v7pxnGiven :1; + unsigned BSIM4v7pvfbsdoffGiven :1; + unsigned BSIM4v7ptvfbsdoffGiven :1; /* CV model */ - unsigned BSIM4pcgslGiven :1; - unsigned BSIM4pcgdlGiven :1; - unsigned BSIM4pckappasGiven :1; - unsigned BSIM4pckappadGiven :1; - unsigned BSIM4pcfGiven :1; - unsigned BSIM4pclcGiven :1; - unsigned BSIM4pcleGiven :1; - unsigned BSIM4pvfbcvGiven :1; - unsigned BSIM4pnoffGiven :1; - unsigned BSIM4pvoffcvGiven :1; - unsigned BSIM4pacdeGiven :1; - unsigned BSIM4pmoinGiven :1; + unsigned BSIM4v7pcgslGiven :1; + unsigned BSIM4v7pcgdlGiven :1; + unsigned BSIM4v7pckappasGiven :1; + unsigned BSIM4v7pckappadGiven :1; + unsigned BSIM4v7pcfGiven :1; + unsigned BSIM4v7pclcGiven :1; + unsigned BSIM4v7pcleGiven :1; + unsigned BSIM4v7pvfbcvGiven :1; + unsigned BSIM4v7pnoffGiven :1; + unsigned BSIM4v7pvoffcvGiven :1; + unsigned BSIM4v7pacdeGiven :1; + unsigned BSIM4v7pmoinGiven :1; - unsigned BSIM4useFringeGiven :1; + unsigned BSIM4v7useFringeGiven :1; - unsigned BSIM4tnomGiven :1; - unsigned BSIM4cgsoGiven :1; - unsigned BSIM4cgdoGiven :1; - unsigned BSIM4cgboGiven :1; - unsigned BSIM4xpartGiven :1; - unsigned BSIM4sheetResistanceGiven :1; + unsigned BSIM4v7tnomGiven :1; + unsigned BSIM4v7cgsoGiven :1; + unsigned BSIM4v7cgdoGiven :1; + unsigned BSIM4v7cgboGiven :1; + unsigned BSIM4v7xpartGiven :1; + unsigned BSIM4v7sheetResistanceGiven :1; - unsigned BSIM4SjctSatCurDensityGiven :1; - unsigned BSIM4SjctSidewallSatCurDensityGiven :1; - unsigned BSIM4SjctGateSidewallSatCurDensityGiven :1; - unsigned BSIM4SbulkJctPotentialGiven :1; - unsigned BSIM4SbulkJctBotGradingCoeffGiven :1; - unsigned BSIM4SsidewallJctPotentialGiven :1; - unsigned BSIM4SGatesidewallJctPotentialGiven :1; - unsigned BSIM4SbulkJctSideGradingCoeffGiven :1; - unsigned BSIM4SunitAreaJctCapGiven :1; - unsigned BSIM4SunitLengthSidewallJctCapGiven :1; - unsigned BSIM4SbulkJctGateSideGradingCoeffGiven :1; - unsigned BSIM4SunitLengthGateSidewallJctCapGiven :1; - unsigned BSIM4SjctEmissionCoeffGiven :1; - unsigned BSIM4SjctTempExponentGiven :1; + unsigned BSIM4v7SjctSatCurDensityGiven :1; + unsigned BSIM4v7SjctSidewallSatCurDensityGiven :1; + unsigned BSIM4v7SjctGateSidewallSatCurDensityGiven :1; + unsigned BSIM4v7SbulkJctPotentialGiven :1; + unsigned BSIM4v7SbulkJctBotGradingCoeffGiven :1; + unsigned BSIM4v7SsidewallJctPotentialGiven :1; + unsigned BSIM4v7SGatesidewallJctPotentialGiven :1; + unsigned BSIM4v7SbulkJctSideGradingCoeffGiven :1; + unsigned BSIM4v7SunitAreaJctCapGiven :1; + unsigned BSIM4v7SunitLengthSidewallJctCapGiven :1; + unsigned BSIM4v7SbulkJctGateSideGradingCoeffGiven :1; + unsigned BSIM4v7SunitLengthGateSidewallJctCapGiven :1; + unsigned BSIM4v7SjctEmissionCoeffGiven :1; + unsigned BSIM4v7SjctTempExponentGiven :1; - unsigned BSIM4DjctSatCurDensityGiven :1; - unsigned BSIM4DjctSidewallSatCurDensityGiven :1; - unsigned BSIM4DjctGateSidewallSatCurDensityGiven :1; - unsigned BSIM4DbulkJctPotentialGiven :1; - unsigned BSIM4DbulkJctBotGradingCoeffGiven :1; - unsigned BSIM4DsidewallJctPotentialGiven :1; - unsigned BSIM4DGatesidewallJctPotentialGiven :1; - unsigned BSIM4DbulkJctSideGradingCoeffGiven :1; - unsigned BSIM4DunitAreaJctCapGiven :1; - unsigned BSIM4DunitLengthSidewallJctCapGiven :1; - unsigned BSIM4DbulkJctGateSideGradingCoeffGiven :1; - unsigned BSIM4DunitLengthGateSidewallJctCapGiven :1; - unsigned BSIM4DjctEmissionCoeffGiven :1; - unsigned BSIM4DjctTempExponentGiven :1; + unsigned BSIM4v7DjctSatCurDensityGiven :1; + unsigned BSIM4v7DjctSidewallSatCurDensityGiven :1; + unsigned BSIM4v7DjctGateSidewallSatCurDensityGiven :1; + unsigned BSIM4v7DbulkJctPotentialGiven :1; + unsigned BSIM4v7DbulkJctBotGradingCoeffGiven :1; + unsigned BSIM4v7DsidewallJctPotentialGiven :1; + unsigned BSIM4v7DGatesidewallJctPotentialGiven :1; + unsigned BSIM4v7DbulkJctSideGradingCoeffGiven :1; + unsigned BSIM4v7DunitAreaJctCapGiven :1; + unsigned BSIM4v7DunitLengthSidewallJctCapGiven :1; + unsigned BSIM4v7DbulkJctGateSideGradingCoeffGiven :1; + unsigned BSIM4v7DunitLengthGateSidewallJctCapGiven :1; + unsigned BSIM4v7DjctEmissionCoeffGiven :1; + unsigned BSIM4v7DjctTempExponentGiven :1; - unsigned BSIM4oxideTrapDensityAGiven :1; - unsigned BSIM4oxideTrapDensityBGiven :1; - unsigned BSIM4oxideTrapDensityCGiven :1; - unsigned BSIM4emGiven :1; - unsigned BSIM4efGiven :1; - unsigned BSIM4afGiven :1; - unsigned BSIM4kfGiven :1; + unsigned BSIM4v7oxideTrapDensityAGiven :1; + unsigned BSIM4v7oxideTrapDensityBGiven :1; + unsigned BSIM4v7oxideTrapDensityCGiven :1; + unsigned BSIM4v7emGiven :1; + unsigned BSIM4v7efGiven :1; + unsigned BSIM4v7afGiven :1; + unsigned BSIM4v7kfGiven :1; - unsigned BSIM4vgsMaxGiven :1; - unsigned BSIM4vgdMaxGiven :1; - unsigned BSIM4vgbMaxGiven :1; - unsigned BSIM4vdsMaxGiven :1; - unsigned BSIM4vbsMaxGiven :1; - unsigned BSIM4vbdMaxGiven :1; + unsigned BSIM4v7vgsMaxGiven :1; + unsigned BSIM4v7vgdMaxGiven :1; + unsigned BSIM4v7vgbMaxGiven :1; + unsigned BSIM4v7vdsMaxGiven :1; + unsigned BSIM4v7vbsMaxGiven :1; + unsigned BSIM4v7vbdMaxGiven :1; - unsigned BSIM4LintGiven :1; - unsigned BSIM4LlGiven :1; - unsigned BSIM4LlcGiven :1; - unsigned BSIM4LlnGiven :1; - unsigned BSIM4LwGiven :1; - unsigned BSIM4LwcGiven :1; - unsigned BSIM4LwnGiven :1; - unsigned BSIM4LwlGiven :1; - unsigned BSIM4LwlcGiven :1; - unsigned BSIM4LminGiven :1; - unsigned BSIM4LmaxGiven :1; + unsigned BSIM4v7LintGiven :1; + unsigned BSIM4v7LlGiven :1; + unsigned BSIM4v7LlcGiven :1; + unsigned BSIM4v7LlnGiven :1; + unsigned BSIM4v7LwGiven :1; + unsigned BSIM4v7LwcGiven :1; + unsigned BSIM4v7LwnGiven :1; + unsigned BSIM4v7LwlGiven :1; + unsigned BSIM4v7LwlcGiven :1; + unsigned BSIM4v7LminGiven :1; + unsigned BSIM4v7LmaxGiven :1; - unsigned BSIM4WintGiven :1; - unsigned BSIM4WlGiven :1; - unsigned BSIM4WlcGiven :1; - unsigned BSIM4WlnGiven :1; - unsigned BSIM4WwGiven :1; - unsigned BSIM4WwcGiven :1; - unsigned BSIM4WwnGiven :1; - unsigned BSIM4WwlGiven :1; - unsigned BSIM4WwlcGiven :1; - unsigned BSIM4WminGiven :1; - unsigned BSIM4WmaxGiven :1; + unsigned BSIM4v7WintGiven :1; + unsigned BSIM4v7WlGiven :1; + unsigned BSIM4v7WlcGiven :1; + unsigned BSIM4v7WlnGiven :1; + unsigned BSIM4v7WwGiven :1; + unsigned BSIM4v7WwcGiven :1; + unsigned BSIM4v7WwnGiven :1; + unsigned BSIM4v7WwlGiven :1; + unsigned BSIM4v7WwlcGiven :1; + unsigned BSIM4v7WminGiven :1; + unsigned BSIM4v7WmaxGiven :1; /* added for stress effect */ - unsigned BSIM4sarefGiven :1; - unsigned BSIM4sbrefGiven :1; - unsigned BSIM4wlodGiven :1; - unsigned BSIM4ku0Given :1; - unsigned BSIM4kvsatGiven :1; - unsigned BSIM4kvth0Given :1; - unsigned BSIM4tku0Given :1; - unsigned BSIM4llodku0Given :1; - unsigned BSIM4wlodku0Given :1; - unsigned BSIM4llodvthGiven :1; - unsigned BSIM4wlodvthGiven :1; - unsigned BSIM4lku0Given :1; - unsigned BSIM4wku0Given :1; - unsigned BSIM4pku0Given :1; - unsigned BSIM4lkvth0Given :1; - unsigned BSIM4wkvth0Given :1; - unsigned BSIM4pkvth0Given :1; - unsigned BSIM4stk2Given :1; - unsigned BSIM4lodk2Given :1; - unsigned BSIM4steta0Given :1; - unsigned BSIM4lodeta0Given :1; + unsigned BSIM4v7sarefGiven :1; + unsigned BSIM4v7sbrefGiven :1; + unsigned BSIM4v7wlodGiven :1; + unsigned BSIM4v7ku0Given :1; + unsigned BSIM4v7kvsatGiven :1; + unsigned BSIM4v7kvth0Given :1; + unsigned BSIM4v7tku0Given :1; + unsigned BSIM4v7llodku0Given :1; + unsigned BSIM4v7wlodku0Given :1; + unsigned BSIM4v7llodvthGiven :1; + unsigned BSIM4v7wlodvthGiven :1; + unsigned BSIM4v7lku0Given :1; + unsigned BSIM4v7wku0Given :1; + unsigned BSIM4v7pku0Given :1; + unsigned BSIM4v7lkvth0Given :1; + unsigned BSIM4v7wkvth0Given :1; + unsigned BSIM4v7pkvth0Given :1; + unsigned BSIM4v7stk2Given :1; + unsigned BSIM4v7lodk2Given :1; + unsigned BSIM4v7steta0Given :1; + unsigned BSIM4v7lodeta0Given :1; - unsigned BSIM4webGiven :1; - unsigned BSIM4wecGiven :1; - unsigned BSIM4kvth0weGiven :1; - unsigned BSIM4k2weGiven :1; - unsigned BSIM4ku0weGiven :1; - unsigned BSIM4screfGiven :1; - unsigned BSIM4wpemodGiven :1; - unsigned BSIM4lkvth0weGiven :1; - unsigned BSIM4lk2weGiven :1; - unsigned BSIM4lku0weGiven :1; - unsigned BSIM4wkvth0weGiven :1; - unsigned BSIM4wk2weGiven :1; - unsigned BSIM4wku0weGiven :1; - unsigned BSIM4pkvth0weGiven :1; - unsigned BSIM4pk2weGiven :1; - unsigned BSIM4pku0weGiven :1; + unsigned BSIM4v7webGiven :1; + unsigned BSIM4v7wecGiven :1; + unsigned BSIM4v7kvth0weGiven :1; + unsigned BSIM4v7k2weGiven :1; + unsigned BSIM4v7ku0weGiven :1; + unsigned BSIM4v7screfGiven :1; + unsigned BSIM4v7wpemodGiven :1; + unsigned BSIM4v7lkvth0weGiven :1; + unsigned BSIM4v7lk2weGiven :1; + unsigned BSIM4v7lku0weGiven :1; + unsigned BSIM4v7wkvth0weGiven :1; + unsigned BSIM4v7wk2weGiven :1; + unsigned BSIM4v7wku0weGiven :1; + unsigned BSIM4v7pkvth0weGiven :1; + unsigned BSIM4v7pk2weGiven :1; + unsigned BSIM4v7pku0weGiven :1; -} BSIM4model; +} BSIM4v7model; #ifndef NMOS @@ -2712,1064 +2712,1064 @@ typedef struct sBSIM4model /* Instance parameters */ -#define BSIM4_W 1 -#define BSIM4_L 2 -#define BSIM4_AS 3 -#define BSIM4_AD 4 -#define BSIM4_PS 5 -#define BSIM4_PD 6 -#define BSIM4_NRS 7 -#define BSIM4_NRD 8 -#define BSIM4_OFF 9 -#define BSIM4_IC 10 -#define BSIM4_IC_VDS 11 -#define BSIM4_IC_VGS 12 -#define BSIM4_IC_VBS 13 -#define BSIM4_TRNQSMOD 14 -#define BSIM4_RBODYMOD 15 -#define BSIM4_RGATEMOD 16 -#define BSIM4_GEOMOD 17 -#define BSIM4_RGEOMOD 18 -#define BSIM4_NF 19 -#define BSIM4_MIN 20 -#define BSIM4_ACNQSMOD 22 -#define BSIM4_RBDB 23 -#define BSIM4_RBSB 24 -#define BSIM4_RBPB 25 -#define BSIM4_RBPS 26 -#define BSIM4_RBPD 27 -#define BSIM4_SA 28 -#define BSIM4_SB 29 -#define BSIM4_SD 30 -#define BSIM4_DELVTO 31 -#define BSIM4_XGW 32 -#define BSIM4_NGCON 33 -#define BSIM4_SCA 34 -#define BSIM4_SCB 35 -#define BSIM4_SCC 36 -#define BSIM4_SC 37 -#define BSIM4_M 38 +#define BSIM4v7_W 1 +#define BSIM4v7_L 2 +#define BSIM4v7_AS 3 +#define BSIM4v7_AD 4 +#define BSIM4v7_PS 5 +#define BSIM4v7_PD 6 +#define BSIM4v7_NRS 7 +#define BSIM4v7_NRD 8 +#define BSIM4v7_OFF 9 +#define BSIM4v7_IC 10 +#define BSIM4v7_IC_VDS 11 +#define BSIM4v7_IC_VGS 12 +#define BSIM4v7_IC_VBS 13 +#define BSIM4v7_TRNQSMOD 14 +#define BSIM4v7_RBODYMOD 15 +#define BSIM4v7_RGATEMOD 16 +#define BSIM4v7_GEOMOD 17 +#define BSIM4v7_RGEOMOD 18 +#define BSIM4v7_NF 19 +#define BSIM4v7_MIN 20 +#define BSIM4v7_ACNQSMOD 22 +#define BSIM4v7_RBDB 23 +#define BSIM4v7_RBSB 24 +#define BSIM4v7_RBPB 25 +#define BSIM4v7_RBPS 26 +#define BSIM4v7_RBPD 27 +#define BSIM4v7_SA 28 +#define BSIM4v7_SB 29 +#define BSIM4v7_SD 30 +#define BSIM4v7_DELVTO 31 +#define BSIM4v7_XGW 32 +#define BSIM4v7_NGCON 33 +#define BSIM4v7_SCA 34 +#define BSIM4v7_SCB 35 +#define BSIM4v7_SCC 36 +#define BSIM4v7_SC 37 +#define BSIM4v7_M 38 /* Global parameters */ -#define BSIM4_MOD_TEMPEOT 65 -#define BSIM4_MOD_LEFFEOT 66 -#define BSIM4_MOD_WEFFEOT 67 -#define BSIM4_MOD_UCSTE 68 -#define BSIM4_MOD_LUCSTE 69 -#define BSIM4_MOD_WUCSTE 70 -#define BSIM4_MOD_PUCSTE 71 -#define BSIM4_MOD_UCS 72 -#define BSIM4_MOD_LUCS 73 -#define BSIM4_MOD_WUCS 74 -#define BSIM4_MOD_PUCS 75 -#define BSIM4_MOD_CVCHARGEMOD 76 -#define BSIM4_MOD_ADOS 77 -#define BSIM4_MOD_BDOS 78 -#define BSIM4_MOD_TEMPMOD 79 -#define BSIM4_MOD_MTRLMOD 80 -#define BSIM4_MOD_IGCMOD 81 -#define BSIM4_MOD_IGBMOD 82 -#define BSIM4_MOD_ACNQSMOD 83 -#define BSIM4_MOD_FNOIMOD 84 -#define BSIM4_MOD_RDSMOD 85 -#define BSIM4_MOD_DIOMOD 86 -#define BSIM4_MOD_PERMOD 87 -#define BSIM4_MOD_GEOMOD 88 -#define BSIM4_MOD_RGEOMOD 89 -#define BSIM4_MOD_RGATEMOD 90 -#define BSIM4_MOD_RBODYMOD 91 -#define BSIM4_MOD_CAPMOD 92 -#define BSIM4_MOD_TRNQSMOD 93 -#define BSIM4_MOD_MOBMOD 94 -#define BSIM4_MOD_TNOIMOD 95 -#define BSIM4_MOD_EOT 96 -#define BSIM4_MOD_VDDEOT 97 -#define BSIM4_MOD_TOXE 98 -#define BSIM4_MOD_CDSC 99 -#define BSIM4_MOD_CDSCB 100 -#define BSIM4_MOD_CIT 101 -#define BSIM4_MOD_NFACTOR 102 -#define BSIM4_MOD_XJ 103 -#define BSIM4_MOD_VSAT 104 -#define BSIM4_MOD_AT 105 -#define BSIM4_MOD_A0 106 -#define BSIM4_MOD_A1 107 -#define BSIM4_MOD_A2 108 -#define BSIM4_MOD_KETA 109 -#define BSIM4_MOD_NSUB 110 -#define BSIM4_MOD_PHIG 111 -#define BSIM4_MOD_EPSRGATE 112 -#define BSIM4_MOD_EASUB 113 -#define BSIM4_MOD_EPSRSUB 114 -#define BSIM4_MOD_NI0SUB 115 -#define BSIM4_MOD_BG0SUB 116 -#define BSIM4_MOD_TBGASUB 117 -#define BSIM4_MOD_TBGBSUB 118 -#define BSIM4_MOD_NDEP 119 -#define BSIM4_MOD_NGATE 120 -#define BSIM4_MOD_GAMMA1 121 -#define BSIM4_MOD_GAMMA2 122 -#define BSIM4_MOD_VBX 123 -#define BSIM4_MOD_BINUNIT 124 -#define BSIM4_MOD_VBM 125 -#define BSIM4_MOD_XT 126 -#define BSIM4_MOD_K1 129 -#define BSIM4_MOD_KT1 130 -#define BSIM4_MOD_KT1L 131 -#define BSIM4_MOD_K2 132 -#define BSIM4_MOD_KT2 133 -#define BSIM4_MOD_K3 134 -#define BSIM4_MOD_K3B 135 -#define BSIM4_MOD_W0 136 -#define BSIM4_MOD_LPE0 137 -#define BSIM4_MOD_DVT0 138 -#define BSIM4_MOD_DVT1 139 -#define BSIM4_MOD_DVT2 140 -#define BSIM4_MOD_DVT0W 141 -#define BSIM4_MOD_DVT1W 142 -#define BSIM4_MOD_DVT2W 143 -#define BSIM4_MOD_DROUT 144 -#define BSIM4_MOD_DSUB 145 -#define BSIM4_MOD_VTH0 146 -#define BSIM4_MOD_UA 147 -#define BSIM4_MOD_UA1 148 -#define BSIM4_MOD_UB 149 -#define BSIM4_MOD_UB1 150 -#define BSIM4_MOD_UC 151 -#define BSIM4_MOD_UC1 152 -#define BSIM4_MOD_U0 153 -#define BSIM4_MOD_UTE 154 -#define BSIM4_MOD_VOFF 155 -#define BSIM4_MOD_DELTA 156 -#define BSIM4_MOD_RDSW 157 -#define BSIM4_MOD_PRT 158 -#define BSIM4_MOD_LDD 159 -#define BSIM4_MOD_ETA 160 -#define BSIM4_MOD_ETA0 161 -#define BSIM4_MOD_ETAB 162 -#define BSIM4_MOD_PCLM 163 -#define BSIM4_MOD_PDIBL1 164 -#define BSIM4_MOD_PDIBL2 165 -#define BSIM4_MOD_PSCBE1 166 -#define BSIM4_MOD_PSCBE2 167 -#define BSIM4_MOD_PVAG 168 -#define BSIM4_MOD_WR 169 -#define BSIM4_MOD_DWG 170 -#define BSIM4_MOD_DWB 171 -#define BSIM4_MOD_B0 172 -#define BSIM4_MOD_B1 173 -#define BSIM4_MOD_ALPHA0 174 -#define BSIM4_MOD_BETA0 175 -#define BSIM4_MOD_PDIBLB 178 -#define BSIM4_MOD_PRWG 179 -#define BSIM4_MOD_PRWB 180 -#define BSIM4_MOD_CDSCD 181 -#define BSIM4_MOD_AGS 182 -#define BSIM4_MOD_FRINGE 184 -#define BSIM4_MOD_CGSL 186 -#define BSIM4_MOD_CGDL 187 -#define BSIM4_MOD_CKAPPAS 188 -#define BSIM4_MOD_CF 189 -#define BSIM4_MOD_CLC 190 -#define BSIM4_MOD_CLE 191 -#define BSIM4_MOD_PARAMCHK 192 -#define BSIM4_MOD_VERSION 193 -#define BSIM4_MOD_VFBCV 194 -#define BSIM4_MOD_ACDE 195 -#define BSIM4_MOD_MOIN 196 -#define BSIM4_MOD_NOFF 197 -#define BSIM4_MOD_IJTHDFWD 198 -#define BSIM4_MOD_ALPHA1 199 -#define BSIM4_MOD_VFB 200 -#define BSIM4_MOD_TOXM 201 -#define BSIM4_MOD_TCJ 202 -#define BSIM4_MOD_TCJSW 203 -#define BSIM4_MOD_TCJSWG 204 -#define BSIM4_MOD_TPB 205 -#define BSIM4_MOD_TPBSW 206 -#define BSIM4_MOD_TPBSWG 207 -#define BSIM4_MOD_VOFFCV 208 -#define BSIM4_MOD_GBMIN 209 -#define BSIM4_MOD_RBDB 210 -#define BSIM4_MOD_RBSB 211 -#define BSIM4_MOD_RBPB 212 -#define BSIM4_MOD_RBPS 213 -#define BSIM4_MOD_RBPD 214 -#define BSIM4_MOD_DMCG 215 -#define BSIM4_MOD_DMCI 216 -#define BSIM4_MOD_DMDG 217 -#define BSIM4_MOD_XGW 218 -#define BSIM4_MOD_XGL 219 -#define BSIM4_MOD_RSHG 220 -#define BSIM4_MOD_NGCON 221 -#define BSIM4_MOD_AGIDL 222 -#define BSIM4_MOD_BGIDL 223 -#define BSIM4_MOD_EGIDL 224 -#define BSIM4_MOD_IJTHSFWD 225 -#define BSIM4_MOD_XJBVD 226 -#define BSIM4_MOD_XJBVS 227 -#define BSIM4_MOD_BVD 228 -#define BSIM4_MOD_BVS 229 -#define BSIM4_MOD_TOXP 230 -#define BSIM4_MOD_DTOX 231 -#define BSIM4_MOD_XRCRG1 232 -#define BSIM4_MOD_XRCRG2 233 -#define BSIM4_MOD_EU 234 -#define BSIM4_MOD_IJTHSREV 235 -#define BSIM4_MOD_IJTHDREV 236 -#define BSIM4_MOD_MINV 237 -#define BSIM4_MOD_VOFFL 238 -#define BSIM4_MOD_PDITS 239 -#define BSIM4_MOD_PDITSD 240 -#define BSIM4_MOD_PDITSL 241 -#define BSIM4_MOD_TNOIA 242 -#define BSIM4_MOD_TNOIB 243 -#define BSIM4_MOD_NTNOI 244 -#define BSIM4_MOD_FPROUT 245 -#define BSIM4_MOD_LPEB 246 -#define BSIM4_MOD_DVTP0 247 -#define BSIM4_MOD_DVTP1 248 -#define BSIM4_MOD_CGIDL 249 -#define BSIM4_MOD_PHIN 250 -#define BSIM4_MOD_RDSWMIN 251 -#define BSIM4_MOD_RSW 252 -#define BSIM4_MOD_RDW 253 -#define BSIM4_MOD_RDWMIN 254 -#define BSIM4_MOD_RSWMIN 255 -#define BSIM4_MOD_NSD 256 -#define BSIM4_MOD_CKAPPAD 257 -#define BSIM4_MOD_DMCGT 258 -#define BSIM4_MOD_AIGC 259 -#define BSIM4_MOD_BIGC 260 -#define BSIM4_MOD_CIGC 261 -#define BSIM4_MOD_AIGBACC 262 -#define BSIM4_MOD_BIGBACC 263 -#define BSIM4_MOD_CIGBACC 264 -#define BSIM4_MOD_AIGBINV 265 -#define BSIM4_MOD_BIGBINV 266 -#define BSIM4_MOD_CIGBINV 267 -#define BSIM4_MOD_NIGC 268 -#define BSIM4_MOD_NIGBACC 269 -#define BSIM4_MOD_NIGBINV 270 -#define BSIM4_MOD_NTOX 271 -#define BSIM4_MOD_TOXREF 272 -#define BSIM4_MOD_EIGBINV 273 -#define BSIM4_MOD_PIGCD 274 -#define BSIM4_MOD_POXEDGE 275 -#define BSIM4_MOD_EPSROX 276 -#define BSIM4_MOD_AIGSD 277 -#define BSIM4_MOD_BIGSD 278 -#define BSIM4_MOD_CIGSD 279 -#define BSIM4_MOD_JSWGS 280 -#define BSIM4_MOD_JSWGD 281 -#define BSIM4_MOD_LAMBDA 282 -#define BSIM4_MOD_VTL 283 -#define BSIM4_MOD_LC 284 -#define BSIM4_MOD_XN 285 -#define BSIM4_MOD_RNOIA 286 -#define BSIM4_MOD_RNOIB 287 -#define BSIM4_MOD_VFBSDOFF 288 -#define BSIM4_MOD_LINTNOI 289 -#define BSIM4_MOD_UD 290 -#define BSIM4_MOD_UD1 291 -#define BSIM4_MOD_UP 292 -#define BSIM4_MOD_LP 293 -#define BSIM4_MOD_TVOFF 294 -#define BSIM4_MOD_TVFBSDOFF 295 -#define BSIM4_MOD_MINVCV 296 -#define BSIM4_MOD_VOFFCVL 297 -#define BSIM4_MOD_MTRLCOMPATMOD 380 +#define BSIM4v7_MOD_TEMPEOT 65 +#define BSIM4v7_MOD_LEFFEOT 66 +#define BSIM4v7_MOD_WEFFEOT 67 +#define BSIM4v7_MOD_UCSTE 68 +#define BSIM4v7_MOD_LUCSTE 69 +#define BSIM4v7_MOD_WUCSTE 70 +#define BSIM4v7_MOD_PUCSTE 71 +#define BSIM4v7_MOD_UCS 72 +#define BSIM4v7_MOD_LUCS 73 +#define BSIM4v7_MOD_WUCS 74 +#define BSIM4v7_MOD_PUCS 75 +#define BSIM4v7_MOD_CVCHARGEMOD 76 +#define BSIM4v7_MOD_ADOS 77 +#define BSIM4v7_MOD_BDOS 78 +#define BSIM4v7_MOD_TEMPMOD 79 +#define BSIM4v7_MOD_MTRLMOD 80 +#define BSIM4v7_MOD_IGCMOD 81 +#define BSIM4v7_MOD_IGBMOD 82 +#define BSIM4v7_MOD_ACNQSMOD 83 +#define BSIM4v7_MOD_FNOIMOD 84 +#define BSIM4v7_MOD_RDSMOD 85 +#define BSIM4v7_MOD_DIOMOD 86 +#define BSIM4v7_MOD_PERMOD 87 +#define BSIM4v7_MOD_GEOMOD 88 +#define BSIM4v7_MOD_RGEOMOD 89 +#define BSIM4v7_MOD_RGATEMOD 90 +#define BSIM4v7_MOD_RBODYMOD 91 +#define BSIM4v7_MOD_CAPMOD 92 +#define BSIM4v7_MOD_TRNQSMOD 93 +#define BSIM4v7_MOD_MOBMOD 94 +#define BSIM4v7_MOD_TNOIMOD 95 +#define BSIM4v7_MOD_EOT 96 +#define BSIM4v7_MOD_VDDEOT 97 +#define BSIM4v7_MOD_TOXE 98 +#define BSIM4v7_MOD_CDSC 99 +#define BSIM4v7_MOD_CDSCB 100 +#define BSIM4v7_MOD_CIT 101 +#define BSIM4v7_MOD_NFACTOR 102 +#define BSIM4v7_MOD_XJ 103 +#define BSIM4v7_MOD_VSAT 104 +#define BSIM4v7_MOD_AT 105 +#define BSIM4v7_MOD_A0 106 +#define BSIM4v7_MOD_A1 107 +#define BSIM4v7_MOD_A2 108 +#define BSIM4v7_MOD_KETA 109 +#define BSIM4v7_MOD_NSUB 110 +#define BSIM4v7_MOD_PHIG 111 +#define BSIM4v7_MOD_EPSRGATE 112 +#define BSIM4v7_MOD_EASUB 113 +#define BSIM4v7_MOD_EPSRSUB 114 +#define BSIM4v7_MOD_NI0SUB 115 +#define BSIM4v7_MOD_BG0SUB 116 +#define BSIM4v7_MOD_TBGASUB 117 +#define BSIM4v7_MOD_TBGBSUB 118 +#define BSIM4v7_MOD_NDEP 119 +#define BSIM4v7_MOD_NGATE 120 +#define BSIM4v7_MOD_GAMMA1 121 +#define BSIM4v7_MOD_GAMMA2 122 +#define BSIM4v7_MOD_VBX 123 +#define BSIM4v7_MOD_BINUNIT 124 +#define BSIM4v7_MOD_VBM 125 +#define BSIM4v7_MOD_XT 126 +#define BSIM4v7_MOD_K1 129 +#define BSIM4v7_MOD_KT1 130 +#define BSIM4v7_MOD_KT1L 131 +#define BSIM4v7_MOD_K2 132 +#define BSIM4v7_MOD_KT2 133 +#define BSIM4v7_MOD_K3 134 +#define BSIM4v7_MOD_K3B 135 +#define BSIM4v7_MOD_W0 136 +#define BSIM4v7_MOD_LPE0 137 +#define BSIM4v7_MOD_DVT0 138 +#define BSIM4v7_MOD_DVT1 139 +#define BSIM4v7_MOD_DVT2 140 +#define BSIM4v7_MOD_DVT0W 141 +#define BSIM4v7_MOD_DVT1W 142 +#define BSIM4v7_MOD_DVT2W 143 +#define BSIM4v7_MOD_DROUT 144 +#define BSIM4v7_MOD_DSUB 145 +#define BSIM4v7_MOD_VTH0 146 +#define BSIM4v7_MOD_UA 147 +#define BSIM4v7_MOD_UA1 148 +#define BSIM4v7_MOD_UB 149 +#define BSIM4v7_MOD_UB1 150 +#define BSIM4v7_MOD_UC 151 +#define BSIM4v7_MOD_UC1 152 +#define BSIM4v7_MOD_U0 153 +#define BSIM4v7_MOD_UTE 154 +#define BSIM4v7_MOD_VOFF 155 +#define BSIM4v7_MOD_DELTA 156 +#define BSIM4v7_MOD_RDSW 157 +#define BSIM4v7_MOD_PRT 158 +#define BSIM4v7_MOD_LDD 159 +#define BSIM4v7_MOD_ETA 160 +#define BSIM4v7_MOD_ETA0 161 +#define BSIM4v7_MOD_ETAB 162 +#define BSIM4v7_MOD_PCLM 163 +#define BSIM4v7_MOD_PDIBL1 164 +#define BSIM4v7_MOD_PDIBL2 165 +#define BSIM4v7_MOD_PSCBE1 166 +#define BSIM4v7_MOD_PSCBE2 167 +#define BSIM4v7_MOD_PVAG 168 +#define BSIM4v7_MOD_WR 169 +#define BSIM4v7_MOD_DWG 170 +#define BSIM4v7_MOD_DWB 171 +#define BSIM4v7_MOD_B0 172 +#define BSIM4v7_MOD_B1 173 +#define BSIM4v7_MOD_ALPHA0 174 +#define BSIM4v7_MOD_BETA0 175 +#define BSIM4v7_MOD_PDIBLB 178 +#define BSIM4v7_MOD_PRWG 179 +#define BSIM4v7_MOD_PRWB 180 +#define BSIM4v7_MOD_CDSCD 181 +#define BSIM4v7_MOD_AGS 182 +#define BSIM4v7_MOD_FRINGE 184 +#define BSIM4v7_MOD_CGSL 186 +#define BSIM4v7_MOD_CGDL 187 +#define BSIM4v7_MOD_CKAPPAS 188 +#define BSIM4v7_MOD_CF 189 +#define BSIM4v7_MOD_CLC 190 +#define BSIM4v7_MOD_CLE 191 +#define BSIM4v7_MOD_PARAMCHK 192 +#define BSIM4v7_MOD_VERSION 193 +#define BSIM4v7_MOD_VFBCV 194 +#define BSIM4v7_MOD_ACDE 195 +#define BSIM4v7_MOD_MOIN 196 +#define BSIM4v7_MOD_NOFF 197 +#define BSIM4v7_MOD_IJTHDFWD 198 +#define BSIM4v7_MOD_ALPHA1 199 +#define BSIM4v7_MOD_VFB 200 +#define BSIM4v7_MOD_TOXM 201 +#define BSIM4v7_MOD_TCJ 202 +#define BSIM4v7_MOD_TCJSW 203 +#define BSIM4v7_MOD_TCJSWG 204 +#define BSIM4v7_MOD_TPB 205 +#define BSIM4v7_MOD_TPBSW 206 +#define BSIM4v7_MOD_TPBSWG 207 +#define BSIM4v7_MOD_VOFFCV 208 +#define BSIM4v7_MOD_GBMIN 209 +#define BSIM4v7_MOD_RBDB 210 +#define BSIM4v7_MOD_RBSB 211 +#define BSIM4v7_MOD_RBPB 212 +#define BSIM4v7_MOD_RBPS 213 +#define BSIM4v7_MOD_RBPD 214 +#define BSIM4v7_MOD_DMCG 215 +#define BSIM4v7_MOD_DMCI 216 +#define BSIM4v7_MOD_DMDG 217 +#define BSIM4v7_MOD_XGW 218 +#define BSIM4v7_MOD_XGL 219 +#define BSIM4v7_MOD_RSHG 220 +#define BSIM4v7_MOD_NGCON 221 +#define BSIM4v7_MOD_AGIDL 222 +#define BSIM4v7_MOD_BGIDL 223 +#define BSIM4v7_MOD_EGIDL 224 +#define BSIM4v7_MOD_IJTHSFWD 225 +#define BSIM4v7_MOD_XJBVD 226 +#define BSIM4v7_MOD_XJBVS 227 +#define BSIM4v7_MOD_BVD 228 +#define BSIM4v7_MOD_BVS 229 +#define BSIM4v7_MOD_TOXP 230 +#define BSIM4v7_MOD_DTOX 231 +#define BSIM4v7_MOD_XRCRG1 232 +#define BSIM4v7_MOD_XRCRG2 233 +#define BSIM4v7_MOD_EU 234 +#define BSIM4v7_MOD_IJTHSREV 235 +#define BSIM4v7_MOD_IJTHDREV 236 +#define BSIM4v7_MOD_MINV 237 +#define BSIM4v7_MOD_VOFFL 238 +#define BSIM4v7_MOD_PDITS 239 +#define BSIM4v7_MOD_PDITSD 240 +#define BSIM4v7_MOD_PDITSL 241 +#define BSIM4v7_MOD_TNOIA 242 +#define BSIM4v7_MOD_TNOIB 243 +#define BSIM4v7_MOD_NTNOI 244 +#define BSIM4v7_MOD_FPROUT 245 +#define BSIM4v7_MOD_LPEB 246 +#define BSIM4v7_MOD_DVTP0 247 +#define BSIM4v7_MOD_DVTP1 248 +#define BSIM4v7_MOD_CGIDL 249 +#define BSIM4v7_MOD_PHIN 250 +#define BSIM4v7_MOD_RDSWMIN 251 +#define BSIM4v7_MOD_RSW 252 +#define BSIM4v7_MOD_RDW 253 +#define BSIM4v7_MOD_RDWMIN 254 +#define BSIM4v7_MOD_RSWMIN 255 +#define BSIM4v7_MOD_NSD 256 +#define BSIM4v7_MOD_CKAPPAD 257 +#define BSIM4v7_MOD_DMCGT 258 +#define BSIM4v7_MOD_AIGC 259 +#define BSIM4v7_MOD_BIGC 260 +#define BSIM4v7_MOD_CIGC 261 +#define BSIM4v7_MOD_AIGBACC 262 +#define BSIM4v7_MOD_BIGBACC 263 +#define BSIM4v7_MOD_CIGBACC 264 +#define BSIM4v7_MOD_AIGBINV 265 +#define BSIM4v7_MOD_BIGBINV 266 +#define BSIM4v7_MOD_CIGBINV 267 +#define BSIM4v7_MOD_NIGC 268 +#define BSIM4v7_MOD_NIGBACC 269 +#define BSIM4v7_MOD_NIGBINV 270 +#define BSIM4v7_MOD_NTOX 271 +#define BSIM4v7_MOD_TOXREF 272 +#define BSIM4v7_MOD_EIGBINV 273 +#define BSIM4v7_MOD_PIGCD 274 +#define BSIM4v7_MOD_POXEDGE 275 +#define BSIM4v7_MOD_EPSROX 276 +#define BSIM4v7_MOD_AIGSD 277 +#define BSIM4v7_MOD_BIGSD 278 +#define BSIM4v7_MOD_CIGSD 279 +#define BSIM4v7_MOD_JSWGS 280 +#define BSIM4v7_MOD_JSWGD 281 +#define BSIM4v7_MOD_LAMBDA 282 +#define BSIM4v7_MOD_VTL 283 +#define BSIM4v7_MOD_LC 284 +#define BSIM4v7_MOD_XN 285 +#define BSIM4v7_MOD_RNOIA 286 +#define BSIM4v7_MOD_RNOIB 287 +#define BSIM4v7_MOD_VFBSDOFF 288 +#define BSIM4v7_MOD_LINTNOI 289 +#define BSIM4v7_MOD_UD 290 +#define BSIM4v7_MOD_UD1 291 +#define BSIM4v7_MOD_UP 292 +#define BSIM4v7_MOD_LP 293 +#define BSIM4v7_MOD_TVOFF 294 +#define BSIM4v7_MOD_TVFBSDOFF 295 +#define BSIM4v7_MOD_MINVCV 296 +#define BSIM4v7_MOD_VOFFCVL 297 +#define BSIM4v7_MOD_MTRLCOMPATMOD 380 /* Length dependence */ -#define BSIM4_MOD_LCDSC 301 -#define BSIM4_MOD_LCDSCB 302 -#define BSIM4_MOD_LCIT 303 -#define BSIM4_MOD_LNFACTOR 304 -#define BSIM4_MOD_LXJ 305 -#define BSIM4_MOD_LVSAT 306 -#define BSIM4_MOD_LAT 307 -#define BSIM4_MOD_LA0 308 -#define BSIM4_MOD_LA1 309 -#define BSIM4_MOD_LA2 310 -#define BSIM4_MOD_LKETA 311 -#define BSIM4_MOD_LNSUB 312 -#define BSIM4_MOD_LNDEP 313 -#define BSIM4_MOD_LNGATE 315 -#define BSIM4_MOD_LGAMMA1 316 -#define BSIM4_MOD_LGAMMA2 317 -#define BSIM4_MOD_LVBX 318 -#define BSIM4_MOD_LVBM 320 -#define BSIM4_MOD_LXT 322 -#define BSIM4_MOD_LK1 325 -#define BSIM4_MOD_LKT1 326 -#define BSIM4_MOD_LKT1L 327 -#define BSIM4_MOD_LK2 328 -#define BSIM4_MOD_LKT2 329 -#define BSIM4_MOD_LK3 330 -#define BSIM4_MOD_LK3B 331 -#define BSIM4_MOD_LW0 332 -#define BSIM4_MOD_LLPE0 333 -#define BSIM4_MOD_LDVT0 334 -#define BSIM4_MOD_LDVT1 335 -#define BSIM4_MOD_LDVT2 336 -#define BSIM4_MOD_LDVT0W 337 -#define BSIM4_MOD_LDVT1W 338 -#define BSIM4_MOD_LDVT2W 339 -#define BSIM4_MOD_LDROUT 340 -#define BSIM4_MOD_LDSUB 341 -#define BSIM4_MOD_LVTH0 342 -#define BSIM4_MOD_LUA 343 -#define BSIM4_MOD_LUA1 344 -#define BSIM4_MOD_LUB 345 -#define BSIM4_MOD_LUB1 346 -#define BSIM4_MOD_LUC 347 -#define BSIM4_MOD_LUC1 348 -#define BSIM4_MOD_LU0 349 -#define BSIM4_MOD_LUTE 350 -#define BSIM4_MOD_LVOFF 351 -#define BSIM4_MOD_LDELTA 352 -#define BSIM4_MOD_LRDSW 353 -#define BSIM4_MOD_LPRT 354 -#define BSIM4_MOD_LLDD 355 -#define BSIM4_MOD_LETA 356 -#define BSIM4_MOD_LETA0 357 -#define BSIM4_MOD_LETAB 358 -#define BSIM4_MOD_LPCLM 359 -#define BSIM4_MOD_LPDIBL1 360 -#define BSIM4_MOD_LPDIBL2 361 -#define BSIM4_MOD_LPSCBE1 362 -#define BSIM4_MOD_LPSCBE2 363 -#define BSIM4_MOD_LPVAG 364 -#define BSIM4_MOD_LWR 365 -#define BSIM4_MOD_LDWG 366 -#define BSIM4_MOD_LDWB 367 -#define BSIM4_MOD_LB0 368 -#define BSIM4_MOD_LB1 369 -#define BSIM4_MOD_LALPHA0 370 -#define BSIM4_MOD_LBETA0 371 -#define BSIM4_MOD_LPDIBLB 374 -#define BSIM4_MOD_LPRWG 375 -#define BSIM4_MOD_LPRWB 376 -#define BSIM4_MOD_LCDSCD 377 -#define BSIM4_MOD_LAGS 378 +#define BSIM4v7_MOD_LCDSC 301 +#define BSIM4v7_MOD_LCDSCB 302 +#define BSIM4v7_MOD_LCIT 303 +#define BSIM4v7_MOD_LNFACTOR 304 +#define BSIM4v7_MOD_LXJ 305 +#define BSIM4v7_MOD_LVSAT 306 +#define BSIM4v7_MOD_LAT 307 +#define BSIM4v7_MOD_LA0 308 +#define BSIM4v7_MOD_LA1 309 +#define BSIM4v7_MOD_LA2 310 +#define BSIM4v7_MOD_LKETA 311 +#define BSIM4v7_MOD_LNSUB 312 +#define BSIM4v7_MOD_LNDEP 313 +#define BSIM4v7_MOD_LNGATE 315 +#define BSIM4v7_MOD_LGAMMA1 316 +#define BSIM4v7_MOD_LGAMMA2 317 +#define BSIM4v7_MOD_LVBX 318 +#define BSIM4v7_MOD_LVBM 320 +#define BSIM4v7_MOD_LXT 322 +#define BSIM4v7_MOD_LK1 325 +#define BSIM4v7_MOD_LKT1 326 +#define BSIM4v7_MOD_LKT1L 327 +#define BSIM4v7_MOD_LK2 328 +#define BSIM4v7_MOD_LKT2 329 +#define BSIM4v7_MOD_LK3 330 +#define BSIM4v7_MOD_LK3B 331 +#define BSIM4v7_MOD_LW0 332 +#define BSIM4v7_MOD_LLPE0 333 +#define BSIM4v7_MOD_LDVT0 334 +#define BSIM4v7_MOD_LDVT1 335 +#define BSIM4v7_MOD_LDVT2 336 +#define BSIM4v7_MOD_LDVT0W 337 +#define BSIM4v7_MOD_LDVT1W 338 +#define BSIM4v7_MOD_LDVT2W 339 +#define BSIM4v7_MOD_LDROUT 340 +#define BSIM4v7_MOD_LDSUB 341 +#define BSIM4v7_MOD_LVTH0 342 +#define BSIM4v7_MOD_LUA 343 +#define BSIM4v7_MOD_LUA1 344 +#define BSIM4v7_MOD_LUB 345 +#define BSIM4v7_MOD_LUB1 346 +#define BSIM4v7_MOD_LUC 347 +#define BSIM4v7_MOD_LUC1 348 +#define BSIM4v7_MOD_LU0 349 +#define BSIM4v7_MOD_LUTE 350 +#define BSIM4v7_MOD_LVOFF 351 +#define BSIM4v7_MOD_LDELTA 352 +#define BSIM4v7_MOD_LRDSW 353 +#define BSIM4v7_MOD_LPRT 354 +#define BSIM4v7_MOD_LLDD 355 +#define BSIM4v7_MOD_LETA 356 +#define BSIM4v7_MOD_LETA0 357 +#define BSIM4v7_MOD_LETAB 358 +#define BSIM4v7_MOD_LPCLM 359 +#define BSIM4v7_MOD_LPDIBL1 360 +#define BSIM4v7_MOD_LPDIBL2 361 +#define BSIM4v7_MOD_LPSCBE1 362 +#define BSIM4v7_MOD_LPSCBE2 363 +#define BSIM4v7_MOD_LPVAG 364 +#define BSIM4v7_MOD_LWR 365 +#define BSIM4v7_MOD_LDWG 366 +#define BSIM4v7_MOD_LDWB 367 +#define BSIM4v7_MOD_LB0 368 +#define BSIM4v7_MOD_LB1 369 +#define BSIM4v7_MOD_LALPHA0 370 +#define BSIM4v7_MOD_LBETA0 371 +#define BSIM4v7_MOD_LPDIBLB 374 +#define BSIM4v7_MOD_LPRWG 375 +#define BSIM4v7_MOD_LPRWB 376 +#define BSIM4v7_MOD_LCDSCD 377 +#define BSIM4v7_MOD_LAGS 378 -#define BSIM4_MOD_LFRINGE 381 -#define BSIM4_MOD_LCGSL 383 -#define BSIM4_MOD_LCGDL 384 -#define BSIM4_MOD_LCKAPPAS 385 -#define BSIM4_MOD_LCF 386 -#define BSIM4_MOD_LCLC 387 -#define BSIM4_MOD_LCLE 388 -#define BSIM4_MOD_LVFBCV 389 -#define BSIM4_MOD_LACDE 390 -#define BSIM4_MOD_LMOIN 391 -#define BSIM4_MOD_LNOFF 392 -#define BSIM4_MOD_LALPHA1 394 -#define BSIM4_MOD_LVFB 395 -#define BSIM4_MOD_LVOFFCV 396 -#define BSIM4_MOD_LAGIDL 397 -#define BSIM4_MOD_LBGIDL 398 -#define BSIM4_MOD_LEGIDL 399 -#define BSIM4_MOD_LXRCRG1 400 -#define BSIM4_MOD_LXRCRG2 401 -#define BSIM4_MOD_LEU 402 -#define BSIM4_MOD_LMINV 403 -#define BSIM4_MOD_LPDITS 404 -#define BSIM4_MOD_LPDITSD 405 -#define BSIM4_MOD_LFPROUT 406 -#define BSIM4_MOD_LLPEB 407 -#define BSIM4_MOD_LDVTP0 408 -#define BSIM4_MOD_LDVTP1 409 -#define BSIM4_MOD_LCGIDL 410 -#define BSIM4_MOD_LPHIN 411 -#define BSIM4_MOD_LRSW 412 -#define BSIM4_MOD_LRDW 413 -#define BSIM4_MOD_LNSD 414 -#define BSIM4_MOD_LCKAPPAD 415 -#define BSIM4_MOD_LAIGC 416 -#define BSIM4_MOD_LBIGC 417 -#define BSIM4_MOD_LCIGC 418 -#define BSIM4_MOD_LAIGBACC 419 -#define BSIM4_MOD_LBIGBACC 420 -#define BSIM4_MOD_LCIGBACC 421 -#define BSIM4_MOD_LAIGBINV 422 -#define BSIM4_MOD_LBIGBINV 423 -#define BSIM4_MOD_LCIGBINV 424 -#define BSIM4_MOD_LNIGC 425 -#define BSIM4_MOD_LNIGBACC 426 -#define BSIM4_MOD_LNIGBINV 427 -#define BSIM4_MOD_LNTOX 428 -#define BSIM4_MOD_LEIGBINV 429 -#define BSIM4_MOD_LPIGCD 430 -#define BSIM4_MOD_LPOXEDGE 431 -#define BSIM4_MOD_LAIGSD 432 -#define BSIM4_MOD_LBIGSD 433 -#define BSIM4_MOD_LCIGSD 434 +#define BSIM4v7_MOD_LFRINGE 381 +#define BSIM4v7_MOD_LCGSL 383 +#define BSIM4v7_MOD_LCGDL 384 +#define BSIM4v7_MOD_LCKAPPAS 385 +#define BSIM4v7_MOD_LCF 386 +#define BSIM4v7_MOD_LCLC 387 +#define BSIM4v7_MOD_LCLE 388 +#define BSIM4v7_MOD_LVFBCV 389 +#define BSIM4v7_MOD_LACDE 390 +#define BSIM4v7_MOD_LMOIN 391 +#define BSIM4v7_MOD_LNOFF 392 +#define BSIM4v7_MOD_LALPHA1 394 +#define BSIM4v7_MOD_LVFB 395 +#define BSIM4v7_MOD_LVOFFCV 396 +#define BSIM4v7_MOD_LAGIDL 397 +#define BSIM4v7_MOD_LBGIDL 398 +#define BSIM4v7_MOD_LEGIDL 399 +#define BSIM4v7_MOD_LXRCRG1 400 +#define BSIM4v7_MOD_LXRCRG2 401 +#define BSIM4v7_MOD_LEU 402 +#define BSIM4v7_MOD_LMINV 403 +#define BSIM4v7_MOD_LPDITS 404 +#define BSIM4v7_MOD_LPDITSD 405 +#define BSIM4v7_MOD_LFPROUT 406 +#define BSIM4v7_MOD_LLPEB 407 +#define BSIM4v7_MOD_LDVTP0 408 +#define BSIM4v7_MOD_LDVTP1 409 +#define BSIM4v7_MOD_LCGIDL 410 +#define BSIM4v7_MOD_LPHIN 411 +#define BSIM4v7_MOD_LRSW 412 +#define BSIM4v7_MOD_LRDW 413 +#define BSIM4v7_MOD_LNSD 414 +#define BSIM4v7_MOD_LCKAPPAD 415 +#define BSIM4v7_MOD_LAIGC 416 +#define BSIM4v7_MOD_LBIGC 417 +#define BSIM4v7_MOD_LCIGC 418 +#define BSIM4v7_MOD_LAIGBACC 419 +#define BSIM4v7_MOD_LBIGBACC 420 +#define BSIM4v7_MOD_LCIGBACC 421 +#define BSIM4v7_MOD_LAIGBINV 422 +#define BSIM4v7_MOD_LBIGBINV 423 +#define BSIM4v7_MOD_LCIGBINV 424 +#define BSIM4v7_MOD_LNIGC 425 +#define BSIM4v7_MOD_LNIGBACC 426 +#define BSIM4v7_MOD_LNIGBINV 427 +#define BSIM4v7_MOD_LNTOX 428 +#define BSIM4v7_MOD_LEIGBINV 429 +#define BSIM4v7_MOD_LPIGCD 430 +#define BSIM4v7_MOD_LPOXEDGE 431 +#define BSIM4v7_MOD_LAIGSD 432 +#define BSIM4v7_MOD_LBIGSD 433 +#define BSIM4v7_MOD_LCIGSD 434 -#define BSIM4_MOD_LLAMBDA 435 -#define BSIM4_MOD_LVTL 436 -#define BSIM4_MOD_LXN 437 -#define BSIM4_MOD_LVFBSDOFF 438 -#define BSIM4_MOD_LUD 439 -#define BSIM4_MOD_LUD1 440 -#define BSIM4_MOD_LUP 441 -#define BSIM4_MOD_LLP 442 -#define BSIM4_MOD_LMINVCV 443 +#define BSIM4v7_MOD_LLAMBDA 435 +#define BSIM4v7_MOD_LVTL 436 +#define BSIM4v7_MOD_LXN 437 +#define BSIM4v7_MOD_LVFBSDOFF 438 +#define BSIM4v7_MOD_LUD 439 +#define BSIM4v7_MOD_LUD1 440 +#define BSIM4v7_MOD_LUP 441 +#define BSIM4v7_MOD_LLP 442 +#define BSIM4v7_MOD_LMINVCV 443 -#define BSIM4_MOD_FGIDL 444 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_KGIDL 445 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_RGIDL 446 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_FGISL 447 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_KGISL 448 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_RGISL 449 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_LFGIDL 450 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_LKGIDL 451 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_LRGIDL 452 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_LFGISL 453 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_LKGISL 454 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_LRGISL 455 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_WFGIDL 456 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_WKGIDL 457 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_WRGIDL 458 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_WFGISL 459 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_WKGISL 460 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_WRGISL 461 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_PFGIDL 462 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_PKGIDL 463 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_PRGIDL 464 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_PFGISL 465 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_PKGISL 466 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_PRGISL 467 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_GIDLMOD 379 /* v4.7 New GIDL/GISL*/ -#define BSIM4_MOD_DVTP2 468 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_DVTP3 469 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_DVTP4 470 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_DVTP5 471 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_LDVTP2 472 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_LDVTP3 473 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_LDVTP4 474 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_LDVTP5 475 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_WDVTP2 476 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_WDVTP3 477 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_WDVTP4 478 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_WDVTP5 479 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_PDVTP2 480 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_PDVTP3 298 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_PDVTP4 299 /* v4.7 NEW DIBL/Rout*/ -#define BSIM4_MOD_PDVTP5 300 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_FGIDL 444 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_KGIDL 445 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_RGIDL 446 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_FGISL 447 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_KGISL 448 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_RGISL 449 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_LFGIDL 450 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_LKGIDL 451 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_LRGIDL 452 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_LFGISL 453 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_LKGISL 454 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_LRGISL 455 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_WFGIDL 456 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_WKGIDL 457 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_WRGIDL 458 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_WFGISL 459 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_WKGISL 460 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_WRGISL 461 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_PFGIDL 462 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_PKGIDL 463 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_PRGIDL 464 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_PFGISL 465 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_PKGISL 466 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_PRGISL 467 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_GIDLMOD 379 /* v4.7 New GIDL/GISL*/ +#define BSIM4v7_MOD_DVTP2 468 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_DVTP3 469 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_DVTP4 470 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_DVTP5 471 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_LDVTP2 472 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_LDVTP3 473 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_LDVTP4 474 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_LDVTP5 475 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_WDVTP2 476 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_WDVTP3 477 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_WDVTP4 478 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_WDVTP5 479 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_PDVTP2 480 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_PDVTP3 298 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_PDVTP4 299 /* v4.7 NEW DIBL/Rout*/ +#define BSIM4v7_MOD_PDVTP5 300 /* v4.7 NEW DIBL/Rout*/ /* Width dependence */ -#define BSIM4_MOD_WCDSC 481 -#define BSIM4_MOD_WCDSCB 482 -#define BSIM4_MOD_WCIT 483 -#define BSIM4_MOD_WNFACTOR 484 -#define BSIM4_MOD_WXJ 485 -#define BSIM4_MOD_WVSAT 486 -#define BSIM4_MOD_WAT 487 -#define BSIM4_MOD_WA0 488 -#define BSIM4_MOD_WA1 489 -#define BSIM4_MOD_WA2 490 -#define BSIM4_MOD_WKETA 491 -#define BSIM4_MOD_WNSUB 492 -#define BSIM4_MOD_WNDEP 493 -#define BSIM4_MOD_WNGATE 495 -#define BSIM4_MOD_WGAMMA1 496 -#define BSIM4_MOD_WGAMMA2 497 -#define BSIM4_MOD_WVBX 498 -#define BSIM4_MOD_WVBM 500 -#define BSIM4_MOD_WXT 502 -#define BSIM4_MOD_WK1 505 -#define BSIM4_MOD_WKT1 506 -#define BSIM4_MOD_WKT1L 507 -#define BSIM4_MOD_WK2 508 -#define BSIM4_MOD_WKT2 509 -#define BSIM4_MOD_WK3 510 -#define BSIM4_MOD_WK3B 511 -#define BSIM4_MOD_WW0 512 -#define BSIM4_MOD_WLPE0 513 -#define BSIM4_MOD_WDVT0 514 -#define BSIM4_MOD_WDVT1 515 -#define BSIM4_MOD_WDVT2 516 -#define BSIM4_MOD_WDVT0W 517 -#define BSIM4_MOD_WDVT1W 518 -#define BSIM4_MOD_WDVT2W 519 -#define BSIM4_MOD_WDROUT 520 -#define BSIM4_MOD_WDSUB 521 -#define BSIM4_MOD_WVTH0 522 -#define BSIM4_MOD_WUA 523 -#define BSIM4_MOD_WUA1 524 -#define BSIM4_MOD_WUB 525 -#define BSIM4_MOD_WUB1 526 -#define BSIM4_MOD_WUC 527 -#define BSIM4_MOD_WUC1 528 -#define BSIM4_MOD_WU0 529 -#define BSIM4_MOD_WUTE 530 -#define BSIM4_MOD_WVOFF 531 -#define BSIM4_MOD_WDELTA 532 -#define BSIM4_MOD_WRDSW 533 -#define BSIM4_MOD_WPRT 534 -#define BSIM4_MOD_WLDD 535 -#define BSIM4_MOD_WETA 536 -#define BSIM4_MOD_WETA0 537 -#define BSIM4_MOD_WETAB 538 -#define BSIM4_MOD_WPCLM 539 -#define BSIM4_MOD_WPDIBL1 540 -#define BSIM4_MOD_WPDIBL2 541 -#define BSIM4_MOD_WPSCBE1 542 -#define BSIM4_MOD_WPSCBE2 543 -#define BSIM4_MOD_WPVAG 544 -#define BSIM4_MOD_WWR 545 -#define BSIM4_MOD_WDWG 546 -#define BSIM4_MOD_WDWB 547 -#define BSIM4_MOD_WB0 548 -#define BSIM4_MOD_WB1 549 -#define BSIM4_MOD_WALPHA0 550 -#define BSIM4_MOD_WBETA0 551 -#define BSIM4_MOD_WPDIBLB 554 -#define BSIM4_MOD_WPRWG 555 -#define BSIM4_MOD_WPRWB 556 -#define BSIM4_MOD_WCDSCD 557 -#define BSIM4_MOD_WAGS 558 +#define BSIM4v7_MOD_WCDSC 481 +#define BSIM4v7_MOD_WCDSCB 482 +#define BSIM4v7_MOD_WCIT 483 +#define BSIM4v7_MOD_WNFACTOR 484 +#define BSIM4v7_MOD_WXJ 485 +#define BSIM4v7_MOD_WVSAT 486 +#define BSIM4v7_MOD_WAT 487 +#define BSIM4v7_MOD_WA0 488 +#define BSIM4v7_MOD_WA1 489 +#define BSIM4v7_MOD_WA2 490 +#define BSIM4v7_MOD_WKETA 491 +#define BSIM4v7_MOD_WNSUB 492 +#define BSIM4v7_MOD_WNDEP 493 +#define BSIM4v7_MOD_WNGATE 495 +#define BSIM4v7_MOD_WGAMMA1 496 +#define BSIM4v7_MOD_WGAMMA2 497 +#define BSIM4v7_MOD_WVBX 498 +#define BSIM4v7_MOD_WVBM 500 +#define BSIM4v7_MOD_WXT 502 +#define BSIM4v7_MOD_WK1 505 +#define BSIM4v7_MOD_WKT1 506 +#define BSIM4v7_MOD_WKT1L 507 +#define BSIM4v7_MOD_WK2 508 +#define BSIM4v7_MOD_WKT2 509 +#define BSIM4v7_MOD_WK3 510 +#define BSIM4v7_MOD_WK3B 511 +#define BSIM4v7_MOD_WW0 512 +#define BSIM4v7_MOD_WLPE0 513 +#define BSIM4v7_MOD_WDVT0 514 +#define BSIM4v7_MOD_WDVT1 515 +#define BSIM4v7_MOD_WDVT2 516 +#define BSIM4v7_MOD_WDVT0W 517 +#define BSIM4v7_MOD_WDVT1W 518 +#define BSIM4v7_MOD_WDVT2W 519 +#define BSIM4v7_MOD_WDROUT 520 +#define BSIM4v7_MOD_WDSUB 521 +#define BSIM4v7_MOD_WVTH0 522 +#define BSIM4v7_MOD_WUA 523 +#define BSIM4v7_MOD_WUA1 524 +#define BSIM4v7_MOD_WUB 525 +#define BSIM4v7_MOD_WUB1 526 +#define BSIM4v7_MOD_WUC 527 +#define BSIM4v7_MOD_WUC1 528 +#define BSIM4v7_MOD_WU0 529 +#define BSIM4v7_MOD_WUTE 530 +#define BSIM4v7_MOD_WVOFF 531 +#define BSIM4v7_MOD_WDELTA 532 +#define BSIM4v7_MOD_WRDSW 533 +#define BSIM4v7_MOD_WPRT 534 +#define BSIM4v7_MOD_WLDD 535 +#define BSIM4v7_MOD_WETA 536 +#define BSIM4v7_MOD_WETA0 537 +#define BSIM4v7_MOD_WETAB 538 +#define BSIM4v7_MOD_WPCLM 539 +#define BSIM4v7_MOD_WPDIBL1 540 +#define BSIM4v7_MOD_WPDIBL2 541 +#define BSIM4v7_MOD_WPSCBE1 542 +#define BSIM4v7_MOD_WPSCBE2 543 +#define BSIM4v7_MOD_WPVAG 544 +#define BSIM4v7_MOD_WWR 545 +#define BSIM4v7_MOD_WDWG 546 +#define BSIM4v7_MOD_WDWB 547 +#define BSIM4v7_MOD_WB0 548 +#define BSIM4v7_MOD_WB1 549 +#define BSIM4v7_MOD_WALPHA0 550 +#define BSIM4v7_MOD_WBETA0 551 +#define BSIM4v7_MOD_WPDIBLB 554 +#define BSIM4v7_MOD_WPRWG 555 +#define BSIM4v7_MOD_WPRWB 556 +#define BSIM4v7_MOD_WCDSCD 557 +#define BSIM4v7_MOD_WAGS 558 -#define BSIM4_MOD_WFRINGE 561 -#define BSIM4_MOD_WCGSL 563 -#define BSIM4_MOD_WCGDL 564 -#define BSIM4_MOD_WCKAPPAS 565 -#define BSIM4_MOD_WCF 566 -#define BSIM4_MOD_WCLC 567 -#define BSIM4_MOD_WCLE 568 -#define BSIM4_MOD_WVFBCV 569 -#define BSIM4_MOD_WACDE 570 -#define BSIM4_MOD_WMOIN 571 -#define BSIM4_MOD_WNOFF 572 -#define BSIM4_MOD_WALPHA1 574 -#define BSIM4_MOD_WVFB 575 -#define BSIM4_MOD_WVOFFCV 576 -#define BSIM4_MOD_WAGIDL 577 -#define BSIM4_MOD_WBGIDL 578 -#define BSIM4_MOD_WEGIDL 579 -#define BSIM4_MOD_WXRCRG1 580 -#define BSIM4_MOD_WXRCRG2 581 -#define BSIM4_MOD_WEU 582 -#define BSIM4_MOD_WMINV 583 -#define BSIM4_MOD_WPDITS 584 -#define BSIM4_MOD_WPDITSD 585 -#define BSIM4_MOD_WFPROUT 586 -#define BSIM4_MOD_WLPEB 587 -#define BSIM4_MOD_WDVTP0 588 -#define BSIM4_MOD_WDVTP1 589 -#define BSIM4_MOD_WCGIDL 590 -#define BSIM4_MOD_WPHIN 591 -#define BSIM4_MOD_WRSW 592 -#define BSIM4_MOD_WRDW 593 -#define BSIM4_MOD_WNSD 594 -#define BSIM4_MOD_WCKAPPAD 595 -#define BSIM4_MOD_WAIGC 596 -#define BSIM4_MOD_WBIGC 597 -#define BSIM4_MOD_WCIGC 598 -#define BSIM4_MOD_WAIGBACC 599 -#define BSIM4_MOD_WBIGBACC 600 -#define BSIM4_MOD_WCIGBACC 601 -#define BSIM4_MOD_WAIGBINV 602 -#define BSIM4_MOD_WBIGBINV 603 -#define BSIM4_MOD_WCIGBINV 604 -#define BSIM4_MOD_WNIGC 605 -#define BSIM4_MOD_WNIGBACC 606 -#define BSIM4_MOD_WNIGBINV 607 -#define BSIM4_MOD_WNTOX 608 -#define BSIM4_MOD_WEIGBINV 609 -#define BSIM4_MOD_WPIGCD 610 -#define BSIM4_MOD_WPOXEDGE 611 -#define BSIM4_MOD_WAIGSD 612 -#define BSIM4_MOD_WBIGSD 613 -#define BSIM4_MOD_WCIGSD 614 -#define BSIM4_MOD_WLAMBDA 615 -#define BSIM4_MOD_WVTL 616 -#define BSIM4_MOD_WXN 617 -#define BSIM4_MOD_WVFBSDOFF 618 -#define BSIM4_MOD_WUD 619 -#define BSIM4_MOD_WUD1 620 -#define BSIM4_MOD_WUP 621 -#define BSIM4_MOD_WLP 622 -#define BSIM4_MOD_WMINVCV 623 +#define BSIM4v7_MOD_WFRINGE 561 +#define BSIM4v7_MOD_WCGSL 563 +#define BSIM4v7_MOD_WCGDL 564 +#define BSIM4v7_MOD_WCKAPPAS 565 +#define BSIM4v7_MOD_WCF 566 +#define BSIM4v7_MOD_WCLC 567 +#define BSIM4v7_MOD_WCLE 568 +#define BSIM4v7_MOD_WVFBCV 569 +#define BSIM4v7_MOD_WACDE 570 +#define BSIM4v7_MOD_WMOIN 571 +#define BSIM4v7_MOD_WNOFF 572 +#define BSIM4v7_MOD_WALPHA1 574 +#define BSIM4v7_MOD_WVFB 575 +#define BSIM4v7_MOD_WVOFFCV 576 +#define BSIM4v7_MOD_WAGIDL 577 +#define BSIM4v7_MOD_WBGIDL 578 +#define BSIM4v7_MOD_WEGIDL 579 +#define BSIM4v7_MOD_WXRCRG1 580 +#define BSIM4v7_MOD_WXRCRG2 581 +#define BSIM4v7_MOD_WEU 582 +#define BSIM4v7_MOD_WMINV 583 +#define BSIM4v7_MOD_WPDITS 584 +#define BSIM4v7_MOD_WPDITSD 585 +#define BSIM4v7_MOD_WFPROUT 586 +#define BSIM4v7_MOD_WLPEB 587 +#define BSIM4v7_MOD_WDVTP0 588 +#define BSIM4v7_MOD_WDVTP1 589 +#define BSIM4v7_MOD_WCGIDL 590 +#define BSIM4v7_MOD_WPHIN 591 +#define BSIM4v7_MOD_WRSW 592 +#define BSIM4v7_MOD_WRDW 593 +#define BSIM4v7_MOD_WNSD 594 +#define BSIM4v7_MOD_WCKAPPAD 595 +#define BSIM4v7_MOD_WAIGC 596 +#define BSIM4v7_MOD_WBIGC 597 +#define BSIM4v7_MOD_WCIGC 598 +#define BSIM4v7_MOD_WAIGBACC 599 +#define BSIM4v7_MOD_WBIGBACC 600 +#define BSIM4v7_MOD_WCIGBACC 601 +#define BSIM4v7_MOD_WAIGBINV 602 +#define BSIM4v7_MOD_WBIGBINV 603 +#define BSIM4v7_MOD_WCIGBINV 604 +#define BSIM4v7_MOD_WNIGC 605 +#define BSIM4v7_MOD_WNIGBACC 606 +#define BSIM4v7_MOD_WNIGBINV 607 +#define BSIM4v7_MOD_WNTOX 608 +#define BSIM4v7_MOD_WEIGBINV 609 +#define BSIM4v7_MOD_WPIGCD 610 +#define BSIM4v7_MOD_WPOXEDGE 611 +#define BSIM4v7_MOD_WAIGSD 612 +#define BSIM4v7_MOD_WBIGSD 613 +#define BSIM4v7_MOD_WCIGSD 614 +#define BSIM4v7_MOD_WLAMBDA 615 +#define BSIM4v7_MOD_WVTL 616 +#define BSIM4v7_MOD_WXN 617 +#define BSIM4v7_MOD_WVFBSDOFF 618 +#define BSIM4v7_MOD_WUD 619 +#define BSIM4v7_MOD_WUD1 620 +#define BSIM4v7_MOD_WUP 621 +#define BSIM4v7_MOD_WLP 622 +#define BSIM4v7_MOD_WMINVCV 623 /* Cross-term dependence */ -#define BSIM4_MOD_PCDSC 661 -#define BSIM4_MOD_PCDSCB 662 -#define BSIM4_MOD_PCIT 663 -#define BSIM4_MOD_PNFACTOR 664 -#define BSIM4_MOD_PXJ 665 -#define BSIM4_MOD_PVSAT 666 -#define BSIM4_MOD_PAT 667 -#define BSIM4_MOD_PA0 668 -#define BSIM4_MOD_PA1 669 -#define BSIM4_MOD_PA2 670 -#define BSIM4_MOD_PKETA 671 -#define BSIM4_MOD_PNSUB 672 -#define BSIM4_MOD_PNDEP 673 -#define BSIM4_MOD_PNGATE 675 -#define BSIM4_MOD_PGAMMA1 676 -#define BSIM4_MOD_PGAMMA2 677 -#define BSIM4_MOD_PVBX 678 +#define BSIM4v7_MOD_PCDSC 661 +#define BSIM4v7_MOD_PCDSCB 662 +#define BSIM4v7_MOD_PCIT 663 +#define BSIM4v7_MOD_PNFACTOR 664 +#define BSIM4v7_MOD_PXJ 665 +#define BSIM4v7_MOD_PVSAT 666 +#define BSIM4v7_MOD_PAT 667 +#define BSIM4v7_MOD_PA0 668 +#define BSIM4v7_MOD_PA1 669 +#define BSIM4v7_MOD_PA2 670 +#define BSIM4v7_MOD_PKETA 671 +#define BSIM4v7_MOD_PNSUB 672 +#define BSIM4v7_MOD_PNDEP 673 +#define BSIM4v7_MOD_PNGATE 675 +#define BSIM4v7_MOD_PGAMMA1 676 +#define BSIM4v7_MOD_PGAMMA2 677 +#define BSIM4v7_MOD_PVBX 678 -#define BSIM4_MOD_PVBM 680 +#define BSIM4v7_MOD_PVBM 680 -#define BSIM4_MOD_PXT 682 -#define BSIM4_MOD_PK1 685 -#define BSIM4_MOD_PKT1 686 -#define BSIM4_MOD_PKT1L 687 -#define BSIM4_MOD_PK2 688 -#define BSIM4_MOD_PKT2 689 -#define BSIM4_MOD_PK3 690 -#define BSIM4_MOD_PK3B 691 -#define BSIM4_MOD_PW0 692 -#define BSIM4_MOD_PLPE0 693 +#define BSIM4v7_MOD_PXT 682 +#define BSIM4v7_MOD_PK1 685 +#define BSIM4v7_MOD_PKT1 686 +#define BSIM4v7_MOD_PKT1L 687 +#define BSIM4v7_MOD_PK2 688 +#define BSIM4v7_MOD_PKT2 689 +#define BSIM4v7_MOD_PK3 690 +#define BSIM4v7_MOD_PK3B 691 +#define BSIM4v7_MOD_PW0 692 +#define BSIM4v7_MOD_PLPE0 693 -#define BSIM4_MOD_PDVT0 694 -#define BSIM4_MOD_PDVT1 695 -#define BSIM4_MOD_PDVT2 696 +#define BSIM4v7_MOD_PDVT0 694 +#define BSIM4v7_MOD_PDVT1 695 +#define BSIM4v7_MOD_PDVT2 696 -#define BSIM4_MOD_PDVT0W 697 -#define BSIM4_MOD_PDVT1W 698 -#define BSIM4_MOD_PDVT2W 699 +#define BSIM4v7_MOD_PDVT0W 697 +#define BSIM4v7_MOD_PDVT1W 698 +#define BSIM4v7_MOD_PDVT2W 699 -#define BSIM4_MOD_PDROUT 700 -#define BSIM4_MOD_PDSUB 701 -#define BSIM4_MOD_PVTH0 702 -#define BSIM4_MOD_PUA 703 -#define BSIM4_MOD_PUA1 704 -#define BSIM4_MOD_PUB 705 -#define BSIM4_MOD_PUB1 706 -#define BSIM4_MOD_PUC 707 -#define BSIM4_MOD_PUC1 708 -#define BSIM4_MOD_PU0 709 -#define BSIM4_MOD_PUTE 710 -#define BSIM4_MOD_PVOFF 711 -#define BSIM4_MOD_PDELTA 712 -#define BSIM4_MOD_PRDSW 713 -#define BSIM4_MOD_PPRT 714 -#define BSIM4_MOD_PLDD 715 -#define BSIM4_MOD_PETA 716 -#define BSIM4_MOD_PETA0 717 -#define BSIM4_MOD_PETAB 718 -#define BSIM4_MOD_PPCLM 719 -#define BSIM4_MOD_PPDIBL1 720 -#define BSIM4_MOD_PPDIBL2 721 -#define BSIM4_MOD_PPSCBE1 722 -#define BSIM4_MOD_PPSCBE2 723 -#define BSIM4_MOD_PPVAG 724 -#define BSIM4_MOD_PWR 725 -#define BSIM4_MOD_PDWG 726 -#define BSIM4_MOD_PDWB 727 -#define BSIM4_MOD_PB0 728 -#define BSIM4_MOD_PB1 729 -#define BSIM4_MOD_PALPHA0 730 -#define BSIM4_MOD_PBETA0 731 -#define BSIM4_MOD_PPDIBLB 734 +#define BSIM4v7_MOD_PDROUT 700 +#define BSIM4v7_MOD_PDSUB 701 +#define BSIM4v7_MOD_PVTH0 702 +#define BSIM4v7_MOD_PUA 703 +#define BSIM4v7_MOD_PUA1 704 +#define BSIM4v7_MOD_PUB 705 +#define BSIM4v7_MOD_PUB1 706 +#define BSIM4v7_MOD_PUC 707 +#define BSIM4v7_MOD_PUC1 708 +#define BSIM4v7_MOD_PU0 709 +#define BSIM4v7_MOD_PUTE 710 +#define BSIM4v7_MOD_PVOFF 711 +#define BSIM4v7_MOD_PDELTA 712 +#define BSIM4v7_MOD_PRDSW 713 +#define BSIM4v7_MOD_PPRT 714 +#define BSIM4v7_MOD_PLDD 715 +#define BSIM4v7_MOD_PETA 716 +#define BSIM4v7_MOD_PETA0 717 +#define BSIM4v7_MOD_PETAB 718 +#define BSIM4v7_MOD_PPCLM 719 +#define BSIM4v7_MOD_PPDIBL1 720 +#define BSIM4v7_MOD_PPDIBL2 721 +#define BSIM4v7_MOD_PPSCBE1 722 +#define BSIM4v7_MOD_PPSCBE2 723 +#define BSIM4v7_MOD_PPVAG 724 +#define BSIM4v7_MOD_PWR 725 +#define BSIM4v7_MOD_PDWG 726 +#define BSIM4v7_MOD_PDWB 727 +#define BSIM4v7_MOD_PB0 728 +#define BSIM4v7_MOD_PB1 729 +#define BSIM4v7_MOD_PALPHA0 730 +#define BSIM4v7_MOD_PBETA0 731 +#define BSIM4v7_MOD_PPDIBLB 734 -#define BSIM4_MOD_PPRWG 735 -#define BSIM4_MOD_PPRWB 736 +#define BSIM4v7_MOD_PPRWG 735 +#define BSIM4v7_MOD_PPRWB 736 -#define BSIM4_MOD_PCDSCD 737 -#define BSIM4_MOD_PAGS 738 +#define BSIM4v7_MOD_PCDSCD 737 +#define BSIM4v7_MOD_PAGS 738 -#define BSIM4_MOD_PFRINGE 741 -#define BSIM4_MOD_PCGSL 743 -#define BSIM4_MOD_PCGDL 744 -#define BSIM4_MOD_PCKAPPAS 745 -#define BSIM4_MOD_PCF 746 -#define BSIM4_MOD_PCLC 747 -#define BSIM4_MOD_PCLE 748 -#define BSIM4_MOD_PVFBCV 749 -#define BSIM4_MOD_PACDE 750 -#define BSIM4_MOD_PMOIN 751 -#define BSIM4_MOD_PNOFF 752 -#define BSIM4_MOD_PALPHA1 754 -#define BSIM4_MOD_PVFB 755 -#define BSIM4_MOD_PVOFFCV 756 -#define BSIM4_MOD_PAGIDL 757 -#define BSIM4_MOD_PBGIDL 758 -#define BSIM4_MOD_PEGIDL 759 -#define BSIM4_MOD_PXRCRG1 760 -#define BSIM4_MOD_PXRCRG2 761 -#define BSIM4_MOD_PEU 762 -#define BSIM4_MOD_PMINV 763 -#define BSIM4_MOD_PPDITS 764 -#define BSIM4_MOD_PPDITSD 765 -#define BSIM4_MOD_PFPROUT 766 -#define BSIM4_MOD_PLPEB 767 -#define BSIM4_MOD_PDVTP0 768 -#define BSIM4_MOD_PDVTP1 769 -#define BSIM4_MOD_PCGIDL 770 -#define BSIM4_MOD_PPHIN 771 -#define BSIM4_MOD_PRSW 772 -#define BSIM4_MOD_PRDW 773 -#define BSIM4_MOD_PNSD 774 -#define BSIM4_MOD_PCKAPPAD 775 -#define BSIM4_MOD_PAIGC 776 -#define BSIM4_MOD_PBIGC 777 -#define BSIM4_MOD_PCIGC 778 -#define BSIM4_MOD_PAIGBACC 779 -#define BSIM4_MOD_PBIGBACC 780 -#define BSIM4_MOD_PCIGBACC 781 -#define BSIM4_MOD_PAIGBINV 782 -#define BSIM4_MOD_PBIGBINV 783 -#define BSIM4_MOD_PCIGBINV 784 -#define BSIM4_MOD_PNIGC 785 -#define BSIM4_MOD_PNIGBACC 786 -#define BSIM4_MOD_PNIGBINV 787 -#define BSIM4_MOD_PNTOX 788 -#define BSIM4_MOD_PEIGBINV 789 -#define BSIM4_MOD_PPIGCD 790 -#define BSIM4_MOD_PPOXEDGE 791 -#define BSIM4_MOD_PAIGSD 792 -#define BSIM4_MOD_PBIGSD 793 -#define BSIM4_MOD_PCIGSD 794 +#define BSIM4v7_MOD_PFRINGE 741 +#define BSIM4v7_MOD_PCGSL 743 +#define BSIM4v7_MOD_PCGDL 744 +#define BSIM4v7_MOD_PCKAPPAS 745 +#define BSIM4v7_MOD_PCF 746 +#define BSIM4v7_MOD_PCLC 747 +#define BSIM4v7_MOD_PCLE 748 +#define BSIM4v7_MOD_PVFBCV 749 +#define BSIM4v7_MOD_PACDE 750 +#define BSIM4v7_MOD_PMOIN 751 +#define BSIM4v7_MOD_PNOFF 752 +#define BSIM4v7_MOD_PALPHA1 754 +#define BSIM4v7_MOD_PVFB 755 +#define BSIM4v7_MOD_PVOFFCV 756 +#define BSIM4v7_MOD_PAGIDL 757 +#define BSIM4v7_MOD_PBGIDL 758 +#define BSIM4v7_MOD_PEGIDL 759 +#define BSIM4v7_MOD_PXRCRG1 760 +#define BSIM4v7_MOD_PXRCRG2 761 +#define BSIM4v7_MOD_PEU 762 +#define BSIM4v7_MOD_PMINV 763 +#define BSIM4v7_MOD_PPDITS 764 +#define BSIM4v7_MOD_PPDITSD 765 +#define BSIM4v7_MOD_PFPROUT 766 +#define BSIM4v7_MOD_PLPEB 767 +#define BSIM4v7_MOD_PDVTP0 768 +#define BSIM4v7_MOD_PDVTP1 769 +#define BSIM4v7_MOD_PCGIDL 770 +#define BSIM4v7_MOD_PPHIN 771 +#define BSIM4v7_MOD_PRSW 772 +#define BSIM4v7_MOD_PRDW 773 +#define BSIM4v7_MOD_PNSD 774 +#define BSIM4v7_MOD_PCKAPPAD 775 +#define BSIM4v7_MOD_PAIGC 776 +#define BSIM4v7_MOD_PBIGC 777 +#define BSIM4v7_MOD_PCIGC 778 +#define BSIM4v7_MOD_PAIGBACC 779 +#define BSIM4v7_MOD_PBIGBACC 780 +#define BSIM4v7_MOD_PCIGBACC 781 +#define BSIM4v7_MOD_PAIGBINV 782 +#define BSIM4v7_MOD_PBIGBINV 783 +#define BSIM4v7_MOD_PCIGBINV 784 +#define BSIM4v7_MOD_PNIGC 785 +#define BSIM4v7_MOD_PNIGBACC 786 +#define BSIM4v7_MOD_PNIGBINV 787 +#define BSIM4v7_MOD_PNTOX 788 +#define BSIM4v7_MOD_PEIGBINV 789 +#define BSIM4v7_MOD_PPIGCD 790 +#define BSIM4v7_MOD_PPOXEDGE 791 +#define BSIM4v7_MOD_PAIGSD 792 +#define BSIM4v7_MOD_PBIGSD 793 +#define BSIM4v7_MOD_PCIGSD 794 -#define BSIM4_MOD_SAREF 795 -#define BSIM4_MOD_SBREF 796 -#define BSIM4_MOD_KU0 797 -#define BSIM4_MOD_KVSAT 798 -#define BSIM4_MOD_TKU0 799 -#define BSIM4_MOD_LLODKU0 800 -#define BSIM4_MOD_WLODKU0 801 -#define BSIM4_MOD_LLODVTH 802 -#define BSIM4_MOD_WLODVTH 803 -#define BSIM4_MOD_LKU0 804 -#define BSIM4_MOD_WKU0 805 -#define BSIM4_MOD_PKU0 806 -#define BSIM4_MOD_KVTH0 807 -#define BSIM4_MOD_LKVTH0 808 -#define BSIM4_MOD_WKVTH0 809 -#define BSIM4_MOD_PKVTH0 810 -#define BSIM4_MOD_WLOD 811 -#define BSIM4_MOD_STK2 812 -#define BSIM4_MOD_LODK2 813 -#define BSIM4_MOD_STETA0 814 -#define BSIM4_MOD_LODETA0 815 +#define BSIM4v7_MOD_SAREF 795 +#define BSIM4v7_MOD_SBREF 796 +#define BSIM4v7_MOD_KU0 797 +#define BSIM4v7_MOD_KVSAT 798 +#define BSIM4v7_MOD_TKU0 799 +#define BSIM4v7_MOD_LLODKU0 800 +#define BSIM4v7_MOD_WLODKU0 801 +#define BSIM4v7_MOD_LLODVTH 802 +#define BSIM4v7_MOD_WLODVTH 803 +#define BSIM4v7_MOD_LKU0 804 +#define BSIM4v7_MOD_WKU0 805 +#define BSIM4v7_MOD_PKU0 806 +#define BSIM4v7_MOD_KVTH0 807 +#define BSIM4v7_MOD_LKVTH0 808 +#define BSIM4v7_MOD_WKVTH0 809 +#define BSIM4v7_MOD_PKVTH0 810 +#define BSIM4v7_MOD_WLOD 811 +#define BSIM4v7_MOD_STK2 812 +#define BSIM4v7_MOD_LODK2 813 +#define BSIM4v7_MOD_STETA0 814 +#define BSIM4v7_MOD_LODETA0 815 -#define BSIM4_MOD_WEB 816 -#define BSIM4_MOD_WEC 817 -#define BSIM4_MOD_KVTH0WE 818 -#define BSIM4_MOD_K2WE 819 -#define BSIM4_MOD_KU0WE 820 -#define BSIM4_MOD_SCREF 821 -#define BSIM4_MOD_WPEMOD 822 -#define BSIM4_MOD_PMINVCV 823 +#define BSIM4v7_MOD_WEB 816 +#define BSIM4v7_MOD_WEC 817 +#define BSIM4v7_MOD_KVTH0WE 818 +#define BSIM4v7_MOD_K2WE 819 +#define BSIM4v7_MOD_KU0WE 820 +#define BSIM4v7_MOD_SCREF 821 +#define BSIM4v7_MOD_WPEMOD 822 +#define BSIM4v7_MOD_PMINVCV 823 -#define BSIM4_MOD_PLAMBDA 825 -#define BSIM4_MOD_PVTL 826 -#define BSIM4_MOD_PXN 827 -#define BSIM4_MOD_PVFBSDOFF 828 +#define BSIM4v7_MOD_PLAMBDA 825 +#define BSIM4v7_MOD_PVTL 826 +#define BSIM4v7_MOD_PXN 827 +#define BSIM4v7_MOD_PVFBSDOFF 828 -#define BSIM4_MOD_TNOM 831 -#define BSIM4_MOD_CGSO 832 -#define BSIM4_MOD_CGDO 833 -#define BSIM4_MOD_CGBO 834 -#define BSIM4_MOD_XPART 835 -#define BSIM4_MOD_RSH 836 -#define BSIM4_MOD_JSS 837 -#define BSIM4_MOD_PBS 838 -#define BSIM4_MOD_MJS 839 -#define BSIM4_MOD_PBSWS 840 -#define BSIM4_MOD_MJSWS 841 -#define BSIM4_MOD_CJS 842 -#define BSIM4_MOD_CJSWS 843 -#define BSIM4_MOD_NMOS 844 -#define BSIM4_MOD_PMOS 845 -#define BSIM4_MOD_NOIA 846 -#define BSIM4_MOD_NOIB 847 -#define BSIM4_MOD_NOIC 848 -#define BSIM4_MOD_LINT 849 -#define BSIM4_MOD_LL 850 -#define BSIM4_MOD_LLN 851 -#define BSIM4_MOD_LW 852 -#define BSIM4_MOD_LWN 853 -#define BSIM4_MOD_LWL 854 -#define BSIM4_MOD_LMIN 855 -#define BSIM4_MOD_LMAX 856 -#define BSIM4_MOD_WINT 857 -#define BSIM4_MOD_WL 858 -#define BSIM4_MOD_WLN 859 -#define BSIM4_MOD_WW 860 -#define BSIM4_MOD_WWN 861 -#define BSIM4_MOD_WWL 862 -#define BSIM4_MOD_WMIN 863 -#define BSIM4_MOD_WMAX 864 -#define BSIM4_MOD_DWC 865 -#define BSIM4_MOD_DLC 866 -#define BSIM4_MOD_XL 867 -#define BSIM4_MOD_XW 868 -#define BSIM4_MOD_EM 869 -#define BSIM4_MOD_EF 870 -#define BSIM4_MOD_AF 871 -#define BSIM4_MOD_KF 872 -#define BSIM4_MOD_NJS 873 -#define BSIM4_MOD_XTIS 874 -#define BSIM4_MOD_PBSWGS 875 -#define BSIM4_MOD_MJSWGS 876 -#define BSIM4_MOD_CJSWGS 877 -#define BSIM4_MOD_JSWS 878 -#define BSIM4_MOD_LLC 879 -#define BSIM4_MOD_LWC 880 -#define BSIM4_MOD_LWLC 881 -#define BSIM4_MOD_WLC 882 -#define BSIM4_MOD_WWC 883 -#define BSIM4_MOD_WWLC 884 -#define BSIM4_MOD_DWJ 885 -#define BSIM4_MOD_JSD 886 -#define BSIM4_MOD_PBD 887 -#define BSIM4_MOD_MJD 888 -#define BSIM4_MOD_PBSWD 889 -#define BSIM4_MOD_MJSWD 890 -#define BSIM4_MOD_CJD 891 -#define BSIM4_MOD_CJSWD 892 -#define BSIM4_MOD_NJD 893 -#define BSIM4_MOD_XTID 894 -#define BSIM4_MOD_PBSWGD 895 -#define BSIM4_MOD_MJSWGD 896 -#define BSIM4_MOD_CJSWGD 897 -#define BSIM4_MOD_JSWD 898 -#define BSIM4_MOD_DLCIG 899 +#define BSIM4v7_MOD_TNOM 831 +#define BSIM4v7_MOD_CGSO 832 +#define BSIM4v7_MOD_CGDO 833 +#define BSIM4v7_MOD_CGBO 834 +#define BSIM4v7_MOD_XPART 835 +#define BSIM4v7_MOD_RSH 836 +#define BSIM4v7_MOD_JSS 837 +#define BSIM4v7_MOD_PBS 838 +#define BSIM4v7_MOD_MJS 839 +#define BSIM4v7_MOD_PBSWS 840 +#define BSIM4v7_MOD_MJSWS 841 +#define BSIM4v7_MOD_CJS 842 +#define BSIM4v7_MOD_CJSWS 843 +#define BSIM4v7_MOD_NMOS 844 +#define BSIM4v7_MOD_PMOS 845 +#define BSIM4v7_MOD_NOIA 846 +#define BSIM4v7_MOD_NOIB 847 +#define BSIM4v7_MOD_NOIC 848 +#define BSIM4v7_MOD_LINT 849 +#define BSIM4v7_MOD_LL 850 +#define BSIM4v7_MOD_LLN 851 +#define BSIM4v7_MOD_LW 852 +#define BSIM4v7_MOD_LWN 853 +#define BSIM4v7_MOD_LWL 854 +#define BSIM4v7_MOD_LMIN 855 +#define BSIM4v7_MOD_LMAX 856 +#define BSIM4v7_MOD_WINT 857 +#define BSIM4v7_MOD_WL 858 +#define BSIM4v7_MOD_WLN 859 +#define BSIM4v7_MOD_WW 860 +#define BSIM4v7_MOD_WWN 861 +#define BSIM4v7_MOD_WWL 862 +#define BSIM4v7_MOD_WMIN 863 +#define BSIM4v7_MOD_WMAX 864 +#define BSIM4v7_MOD_DWC 865 +#define BSIM4v7_MOD_DLC 866 +#define BSIM4v7_MOD_XL 867 +#define BSIM4v7_MOD_XW 868 +#define BSIM4v7_MOD_EM 869 +#define BSIM4v7_MOD_EF 870 +#define BSIM4v7_MOD_AF 871 +#define BSIM4v7_MOD_KF 872 +#define BSIM4v7_MOD_NJS 873 +#define BSIM4v7_MOD_XTIS 874 +#define BSIM4v7_MOD_PBSWGS 875 +#define BSIM4v7_MOD_MJSWGS 876 +#define BSIM4v7_MOD_CJSWGS 877 +#define BSIM4v7_MOD_JSWS 878 +#define BSIM4v7_MOD_LLC 879 +#define BSIM4v7_MOD_LWC 880 +#define BSIM4v7_MOD_LWLC 881 +#define BSIM4v7_MOD_WLC 882 +#define BSIM4v7_MOD_WWC 883 +#define BSIM4v7_MOD_WWLC 884 +#define BSIM4v7_MOD_DWJ 885 +#define BSIM4v7_MOD_JSD 886 +#define BSIM4v7_MOD_PBD 887 +#define BSIM4v7_MOD_MJD 888 +#define BSIM4v7_MOD_PBSWD 889 +#define BSIM4v7_MOD_MJSWD 890 +#define BSIM4v7_MOD_CJD 891 +#define BSIM4v7_MOD_CJSWD 892 +#define BSIM4v7_MOD_NJD 893 +#define BSIM4v7_MOD_XTID 894 +#define BSIM4v7_MOD_PBSWGD 895 +#define BSIM4v7_MOD_MJSWGD 896 +#define BSIM4v7_MOD_CJSWGD 897 +#define BSIM4v7_MOD_JSWD 898 +#define BSIM4v7_MOD_DLCIG 899 /* trap-assisted tunneling */ -#define BSIM4_MOD_JTSS 900 -#define BSIM4_MOD_JTSD 901 -#define BSIM4_MOD_JTSSWS 902 -#define BSIM4_MOD_JTSSWD 903 -#define BSIM4_MOD_JTSSWGS 904 -#define BSIM4_MOD_JTSSWGD 905 -#define BSIM4_MOD_NJTS 906 -#define BSIM4_MOD_NJTSSW 907 -#define BSIM4_MOD_NJTSSWG 908 -#define BSIM4_MOD_XTSS 909 -#define BSIM4_MOD_XTSD 910 -#define BSIM4_MOD_XTSSWS 911 -#define BSIM4_MOD_XTSSWD 912 -#define BSIM4_MOD_XTSSWGS 913 -#define BSIM4_MOD_XTSSWGD 914 -#define BSIM4_MOD_TNJTS 915 -#define BSIM4_MOD_TNJTSSW 916 -#define BSIM4_MOD_TNJTSSWG 917 -#define BSIM4_MOD_VTSS 918 -#define BSIM4_MOD_VTSD 919 -#define BSIM4_MOD_VTSSWS 920 -#define BSIM4_MOD_VTSSWD 921 -#define BSIM4_MOD_VTSSWGS 922 -#define BSIM4_MOD_VTSSWGD 923 -#define BSIM4_MOD_PUD 924 -#define BSIM4_MOD_PUD1 925 -#define BSIM4_MOD_PUP 926 -#define BSIM4_MOD_PLP 927 -#define BSIM4_MOD_JTWEFF 928 +#define BSIM4v7_MOD_JTSS 900 +#define BSIM4v7_MOD_JTSD 901 +#define BSIM4v7_MOD_JTSSWS 902 +#define BSIM4v7_MOD_JTSSWD 903 +#define BSIM4v7_MOD_JTSSWGS 904 +#define BSIM4v7_MOD_JTSSWGD 905 +#define BSIM4v7_MOD_NJTS 906 +#define BSIM4v7_MOD_NJTSSW 907 +#define BSIM4v7_MOD_NJTSSWG 908 +#define BSIM4v7_MOD_XTSS 909 +#define BSIM4v7_MOD_XTSD 910 +#define BSIM4v7_MOD_XTSSWS 911 +#define BSIM4v7_MOD_XTSSWD 912 +#define BSIM4v7_MOD_XTSSWGS 913 +#define BSIM4v7_MOD_XTSSWGD 914 +#define BSIM4v7_MOD_TNJTS 915 +#define BSIM4v7_MOD_TNJTSSW 916 +#define BSIM4v7_MOD_TNJTSSWG 917 +#define BSIM4v7_MOD_VTSS 918 +#define BSIM4v7_MOD_VTSD 919 +#define BSIM4v7_MOD_VTSSWS 920 +#define BSIM4v7_MOD_VTSSWD 921 +#define BSIM4v7_MOD_VTSSWGS 922 +#define BSIM4v7_MOD_VTSSWGD 923 +#define BSIM4v7_MOD_PUD 924 +#define BSIM4v7_MOD_PUD1 925 +#define BSIM4v7_MOD_PUP 926 +#define BSIM4v7_MOD_PLP 927 +#define BSIM4v7_MOD_JTWEFF 928 /* device questions */ -#define BSIM4_DNODE 945 -#define BSIM4_GNODEEXT 946 -#define BSIM4_SNODE 947 -#define BSIM4_BNODE 948 -#define BSIM4_DNODEPRIME 949 -#define BSIM4_GNODEPRIME 950 -#define BSIM4_GNODEMIDE 951 -#define BSIM4_GNODEMID 952 -#define BSIM4_SNODEPRIME 953 -#define BSIM4_BNODEPRIME 954 -#define BSIM4_DBNODE 955 -#define BSIM4_SBNODE 956 -#define BSIM4_VBD 957 -#define BSIM4_VBS 958 -#define BSIM4_VGS 959 -#define BSIM4_VDS 960 -#define BSIM4_CD 961 -#define BSIM4_CBS 962 -#define BSIM4_CBD 963 -#define BSIM4_GM 964 -#define BSIM4_GDS 965 -#define BSIM4_GMBS 966 -#define BSIM4_GBD 967 -#define BSIM4_GBS 968 -#define BSIM4_QB 969 -#define BSIM4_CQB 970 -#define BSIM4_QG 971 -#define BSIM4_CQG 972 -#define BSIM4_QD 973 -#define BSIM4_CQD 974 -#define BSIM4_CGGB 975 -#define BSIM4_CGDB 976 -#define BSIM4_CGSB 977 -#define BSIM4_CBGB 978 -#define BSIM4_CAPBD 979 -#define BSIM4_CQBD 980 -#define BSIM4_CAPBS 981 -#define BSIM4_CQBS 982 -#define BSIM4_CDGB 983 -#define BSIM4_CDDB 984 -#define BSIM4_CDSB 985 -#define BSIM4_VON 986 -#define BSIM4_VDSAT 987 -#define BSIM4_QBS 988 -#define BSIM4_QBD 989 -#define BSIM4_SOURCECONDUCT 990 -#define BSIM4_DRAINCONDUCT 991 -#define BSIM4_CBDB 992 -#define BSIM4_CBSB 993 -#define BSIM4_CSUB 994 -#define BSIM4_QINV 995 -#define BSIM4_IGIDL 996 -#define BSIM4_CSGB 997 -#define BSIM4_CSDB 998 -#define BSIM4_CSSB 999 -#define BSIM4_CGBB 1000 -#define BSIM4_CDBB 1001 -#define BSIM4_CSBB 1002 -#define BSIM4_CBBB 1003 -#define BSIM4_QS 1004 -#define BSIM4_IGISL 1005 -#define BSIM4_IGS 1006 -#define BSIM4_IGD 1007 -#define BSIM4_IGB 1008 -#define BSIM4_IGCS 1009 -#define BSIM4_IGCD 1010 -#define BSIM4_QDEF 1011 -#define BSIM4_DELVT0 1012 -#define BSIM4_GCRG 1013 -#define BSIM4_GTAU 1014 +#define BSIM4v7_DNODE 945 +#define BSIM4v7_GNODEEXT 946 +#define BSIM4v7_SNODE 947 +#define BSIM4v7_BNODE 948 +#define BSIM4v7_DNODEPRIME 949 +#define BSIM4v7_GNODEPRIME 950 +#define BSIM4v7_GNODEMIDE 951 +#define BSIM4v7_GNODEMID 952 +#define BSIM4v7_SNODEPRIME 953 +#define BSIM4v7_BNODEPRIME 954 +#define BSIM4v7_DBNODE 955 +#define BSIM4v7_SBNODE 956 +#define BSIM4v7_VBD 957 +#define BSIM4v7_VBS 958 +#define BSIM4v7_VGS 959 +#define BSIM4v7_VDS 960 +#define BSIM4v7_CD 961 +#define BSIM4v7_CBS 962 +#define BSIM4v7_CBD 963 +#define BSIM4v7_GM 964 +#define BSIM4v7_GDS 965 +#define BSIM4v7_GMBS 966 +#define BSIM4v7_GBD 967 +#define BSIM4v7_GBS 968 +#define BSIM4v7_QB 969 +#define BSIM4v7_CQB 970 +#define BSIM4v7_QG 971 +#define BSIM4v7_CQG 972 +#define BSIM4v7_QD 973 +#define BSIM4v7_CQD 974 +#define BSIM4v7_CGGB 975 +#define BSIM4v7_CGDB 976 +#define BSIM4v7_CGSB 977 +#define BSIM4v7_CBGB 978 +#define BSIM4v7_CAPBD 979 +#define BSIM4v7_CQBD 980 +#define BSIM4v7_CAPBS 981 +#define BSIM4v7_CQBS 982 +#define BSIM4v7_CDGB 983 +#define BSIM4v7_CDDB 984 +#define BSIM4v7_CDSB 985 +#define BSIM4v7_VON 986 +#define BSIM4v7_VDSAT 987 +#define BSIM4v7_QBS 988 +#define BSIM4v7_QBD 989 +#define BSIM4v7_SOURCECONDUCT 990 +#define BSIM4v7_DRAINCONDUCT 991 +#define BSIM4v7_CBDB 992 +#define BSIM4v7_CBSB 993 +#define BSIM4v7_CSUB 994 +#define BSIM4v7_QINV 995 +#define BSIM4v7_IGIDL 996 +#define BSIM4v7_CSGB 997 +#define BSIM4v7_CSDB 998 +#define BSIM4v7_CSSB 999 +#define BSIM4v7_CGBB 1000 +#define BSIM4v7_CDBB 1001 +#define BSIM4v7_CSBB 1002 +#define BSIM4v7_CBBB 1003 +#define BSIM4v7_QS 1004 +#define BSIM4v7_IGISL 1005 +#define BSIM4v7_IGS 1006 +#define BSIM4v7_IGD 1007 +#define BSIM4v7_IGB 1008 +#define BSIM4v7_IGCS 1009 +#define BSIM4v7_IGCD 1010 +#define BSIM4v7_QDEF 1011 +#define BSIM4v7_DELVT0 1012 +#define BSIM4v7_GCRG 1013 +#define BSIM4v7_GTAU 1014 -#define BSIM4_MOD_LTVOFF 1051 -#define BSIM4_MOD_LTVFBSDOFF 1052 -#define BSIM4_MOD_WTVOFF 1053 -#define BSIM4_MOD_WTVFBSDOFF 1054 -#define BSIM4_MOD_PTVOFF 1055 -#define BSIM4_MOD_PTVFBSDOFF 1056 +#define BSIM4v7_MOD_LTVOFF 1051 +#define BSIM4v7_MOD_LTVFBSDOFF 1052 +#define BSIM4v7_MOD_WTVOFF 1053 +#define BSIM4v7_MOD_WTVFBSDOFF 1054 +#define BSIM4v7_MOD_PTVOFF 1055 +#define BSIM4v7_MOD_PTVFBSDOFF 1056 -#define BSIM4_MOD_LKVTH0WE 1061 -#define BSIM4_MOD_LK2WE 1062 -#define BSIM4_MOD_LKU0WE 1063 -#define BSIM4_MOD_WKVTH0WE 1064 -#define BSIM4_MOD_WK2WE 1065 -#define BSIM4_MOD_WKU0WE 1066 -#define BSIM4_MOD_PKVTH0WE 1067 -#define BSIM4_MOD_PK2WE 1068 -#define BSIM4_MOD_PKU0WE 1069 +#define BSIM4v7_MOD_LKVTH0WE 1061 +#define BSIM4v7_MOD_LK2WE 1062 +#define BSIM4v7_MOD_LKU0WE 1063 +#define BSIM4v7_MOD_WKVTH0WE 1064 +#define BSIM4v7_MOD_WK2WE 1065 +#define BSIM4v7_MOD_WKU0WE 1066 +#define BSIM4v7_MOD_PKVTH0WE 1067 +#define BSIM4v7_MOD_PK2WE 1068 +#define BSIM4v7_MOD_PKU0WE 1069 -#define BSIM4_MOD_RBPS0 1101 -#define BSIM4_MOD_RBPSL 1102 -#define BSIM4_MOD_RBPSW 1103 -#define BSIM4_MOD_RBPSNF 1104 -#define BSIM4_MOD_RBPD0 1105 -#define BSIM4_MOD_RBPDL 1106 -#define BSIM4_MOD_RBPDW 1107 -#define BSIM4_MOD_RBPDNF 1108 +#define BSIM4v7_MOD_RBPS0 1101 +#define BSIM4v7_MOD_RBPSL 1102 +#define BSIM4v7_MOD_RBPSW 1103 +#define BSIM4v7_MOD_RBPSNF 1104 +#define BSIM4v7_MOD_RBPD0 1105 +#define BSIM4v7_MOD_RBPDL 1106 +#define BSIM4v7_MOD_RBPDW 1107 +#define BSIM4v7_MOD_RBPDNF 1108 -#define BSIM4_MOD_RBPBX0 1109 -#define BSIM4_MOD_RBPBXL 1110 -#define BSIM4_MOD_RBPBXW 1111 -#define BSIM4_MOD_RBPBXNF 1112 -#define BSIM4_MOD_RBPBY0 1113 -#define BSIM4_MOD_RBPBYL 1114 -#define BSIM4_MOD_RBPBYW 1115 -#define BSIM4_MOD_RBPBYNF 1116 +#define BSIM4v7_MOD_RBPBX0 1109 +#define BSIM4v7_MOD_RBPBXL 1110 +#define BSIM4v7_MOD_RBPBXW 1111 +#define BSIM4v7_MOD_RBPBXNF 1112 +#define BSIM4v7_MOD_RBPBY0 1113 +#define BSIM4v7_MOD_RBPBYL 1114 +#define BSIM4v7_MOD_RBPBYW 1115 +#define BSIM4v7_MOD_RBPBYNF 1116 -#define BSIM4_MOD_RBSBX0 1117 -#define BSIM4_MOD_RBSBY0 1118 -#define BSIM4_MOD_RBDBX0 1119 -#define BSIM4_MOD_RBDBY0 1120 +#define BSIM4v7_MOD_RBSBX0 1117 +#define BSIM4v7_MOD_RBSBY0 1118 +#define BSIM4v7_MOD_RBDBX0 1119 +#define BSIM4v7_MOD_RBDBY0 1120 -#define BSIM4_MOD_RBSDBXL 1121 -#define BSIM4_MOD_RBSDBXW 1122 -#define BSIM4_MOD_RBSDBXNF 1123 -#define BSIM4_MOD_RBSDBYL 1124 -#define BSIM4_MOD_RBSDBYW 1125 -#define BSIM4_MOD_RBSDBYNF 1126 +#define BSIM4v7_MOD_RBSDBXL 1121 +#define BSIM4v7_MOD_RBSDBXW 1122 +#define BSIM4v7_MOD_RBSDBXNF 1123 +#define BSIM4v7_MOD_RBSDBYL 1124 +#define BSIM4v7_MOD_RBSDBYW 1125 +#define BSIM4v7_MOD_RBSDBYNF 1126 -#define BSIM4_MOD_AGISL 1200 -#define BSIM4_MOD_BGISL 1201 -#define BSIM4_MOD_EGISL 1202 -#define BSIM4_MOD_CGISL 1203 -#define BSIM4_MOD_LAGISL 1204 -#define BSIM4_MOD_LBGISL 1205 -#define BSIM4_MOD_LEGISL 1206 -#define BSIM4_MOD_LCGISL 1207 -#define BSIM4_MOD_WAGISL 1208 -#define BSIM4_MOD_WBGISL 1209 -#define BSIM4_MOD_WEGISL 1210 -#define BSIM4_MOD_WCGISL 1211 -#define BSIM4_MOD_PAGISL 1212 -#define BSIM4_MOD_PBGISL 1213 -#define BSIM4_MOD_PEGISL 1214 -#define BSIM4_MOD_PCGISL 1215 +#define BSIM4v7_MOD_AGISL 1200 +#define BSIM4v7_MOD_BGISL 1201 +#define BSIM4v7_MOD_EGISL 1202 +#define BSIM4v7_MOD_CGISL 1203 +#define BSIM4v7_MOD_LAGISL 1204 +#define BSIM4v7_MOD_LBGISL 1205 +#define BSIM4v7_MOD_LEGISL 1206 +#define BSIM4v7_MOD_LCGISL 1207 +#define BSIM4v7_MOD_WAGISL 1208 +#define BSIM4v7_MOD_WBGISL 1209 +#define BSIM4v7_MOD_WEGISL 1210 +#define BSIM4v7_MOD_WCGISL 1211 +#define BSIM4v7_MOD_PAGISL 1212 +#define BSIM4v7_MOD_PBGISL 1213 +#define BSIM4v7_MOD_PEGISL 1214 +#define BSIM4v7_MOD_PCGISL 1215 -#define BSIM4_MOD_AIGS 1220 -#define BSIM4_MOD_BIGS 1221 -#define BSIM4_MOD_CIGS 1222 -#define BSIM4_MOD_LAIGS 1223 -#define BSIM4_MOD_LBIGS 1224 -#define BSIM4_MOD_LCIGS 1225 -#define BSIM4_MOD_WAIGS 1226 -#define BSIM4_MOD_WBIGS 1227 -#define BSIM4_MOD_WCIGS 1228 -#define BSIM4_MOD_PAIGS 1229 -#define BSIM4_MOD_PBIGS 1230 -#define BSIM4_MOD_PCIGS 1231 -#define BSIM4_MOD_AIGD 1232 -#define BSIM4_MOD_BIGD 1233 -#define BSIM4_MOD_CIGD 1234 -#define BSIM4_MOD_LAIGD 1235 -#define BSIM4_MOD_LBIGD 1236 -#define BSIM4_MOD_LCIGD 1237 -#define BSIM4_MOD_WAIGD 1238 -#define BSIM4_MOD_WBIGD 1239 -#define BSIM4_MOD_WCIGD 1240 -#define BSIM4_MOD_PAIGD 1241 -#define BSIM4_MOD_PBIGD 1242 -#define BSIM4_MOD_PCIGD 1243 -#define BSIM4_MOD_DLCIGD 1244 +#define BSIM4v7_MOD_AIGS 1220 +#define BSIM4v7_MOD_BIGS 1221 +#define BSIM4v7_MOD_CIGS 1222 +#define BSIM4v7_MOD_LAIGS 1223 +#define BSIM4v7_MOD_LBIGS 1224 +#define BSIM4v7_MOD_LCIGS 1225 +#define BSIM4v7_MOD_WAIGS 1226 +#define BSIM4v7_MOD_WBIGS 1227 +#define BSIM4v7_MOD_WCIGS 1228 +#define BSIM4v7_MOD_PAIGS 1229 +#define BSIM4v7_MOD_PBIGS 1230 +#define BSIM4v7_MOD_PCIGS 1231 +#define BSIM4v7_MOD_AIGD 1232 +#define BSIM4v7_MOD_BIGD 1233 +#define BSIM4v7_MOD_CIGD 1234 +#define BSIM4v7_MOD_LAIGD 1235 +#define BSIM4v7_MOD_LBIGD 1236 +#define BSIM4v7_MOD_LCIGD 1237 +#define BSIM4v7_MOD_WAIGD 1238 +#define BSIM4v7_MOD_WBIGD 1239 +#define BSIM4v7_MOD_WCIGD 1240 +#define BSIM4v7_MOD_PAIGD 1241 +#define BSIM4v7_MOD_PBIGD 1242 +#define BSIM4v7_MOD_PCIGD 1243 +#define BSIM4v7_MOD_DLCIGD 1244 -#define BSIM4_MOD_NJTSD 1250 -#define BSIM4_MOD_NJTSSWD 1251 -#define BSIM4_MOD_NJTSSWGD 1252 -#define BSIM4_MOD_TNJTSD 1253 -#define BSIM4_MOD_TNJTSSWD 1254 -#define BSIM4_MOD_TNJTSSWGD 1255 +#define BSIM4v7_MOD_NJTSD 1250 +#define BSIM4v7_MOD_NJTSSWD 1251 +#define BSIM4v7_MOD_NJTSSWGD 1252 +#define BSIM4v7_MOD_TNJTSD 1253 +#define BSIM4v7_MOD_TNJTSSWD 1254 +#define BSIM4v7_MOD_TNJTSSWGD 1255 /* v4.7 temp dep of leakage current */ -#define BSIM4_MOD_TNFACTOR 1256 -#define BSIM4_MOD_TETA0 1257 -#define BSIM4_MOD_TVOFFCV 1258 -#define BSIM4_MOD_LTNFACTOR 1260 -#define BSIM4_MOD_LTETA0 1261 -#define BSIM4_MOD_LTVOFFCV 1262 -#define BSIM4_MOD_WTNFACTOR 1264 -#define BSIM4_MOD_WTETA0 1265 -#define BSIM4_MOD_WTVOFFCV 1266 -#define BSIM4_MOD_PTNFACTOR 1268 -#define BSIM4_MOD_PTETA0 1269 -#define BSIM4_MOD_PTVOFFCV 1270 +#define BSIM4v7_MOD_TNFACTOR 1256 +#define BSIM4v7_MOD_TETA0 1257 +#define BSIM4v7_MOD_TVOFFCV 1258 +#define BSIM4v7_MOD_LTNFACTOR 1260 +#define BSIM4v7_MOD_LTETA0 1261 +#define BSIM4v7_MOD_LTVOFFCV 1262 +#define BSIM4v7_MOD_WTNFACTOR 1264 +#define BSIM4v7_MOD_WTETA0 1265 +#define BSIM4v7_MOD_WTVOFFCV 1266 +#define BSIM4v7_MOD_PTNFACTOR 1268 +#define BSIM4v7_MOD_PTETA0 1269 +#define BSIM4v7_MOD_PTVOFFCV 1270 /* tnoiMod=2 (v4.7) */ -#define BSIM4_MOD_TNOIC 1272 -#define BSIM4_MOD_RNOIC 1273 +#define BSIM4v7_MOD_TNOIC 1272 +#define BSIM4v7_MOD_RNOIC 1273 -#define BSIM4_MOD_VGS_MAX 1301 -#define BSIM4_MOD_VGD_MAX 1302 -#define BSIM4_MOD_VGB_MAX 1303 -#define BSIM4_MOD_VDS_MAX 1304 -#define BSIM4_MOD_VBS_MAX 1305 -#define BSIM4_MOD_VBD_MAX 1306 +#define BSIM4v7_MOD_VGS_MAX 1301 +#define BSIM4v7_MOD_VGD_MAX 1302 +#define BSIM4v7_MOD_VGB_MAX 1303 +#define BSIM4v7_MOD_VDS_MAX 1304 +#define BSIM4v7_MOD_VBS_MAX 1305 +#define BSIM4v7_MOD_VBD_MAX 1306 -#include "bsim4ext.h" +#include "bsim4v7ext.h" -extern void BSIM4evaluate(double,double,double,BSIM4instance*,BSIM4model*, +extern void BSIM4v7evaluate(double,double,double,BSIM4v7instance*,BSIM4v7model*, double*,double*,double*, double*, double*, double*, double*, double*, double*, double*, double*, double*, double*, double*, double*, double*, double*, double*, CKTcircuit*); -extern int BSIM4debug(BSIM4model*, BSIM4instance*, CKTcircuit*, int); -extern int BSIM4checkModel(BSIM4model*, BSIM4instance*, CKTcircuit*); -extern int BSIM4PAeffGeo(double, int, int, double, double, double, double, double *, double *, double *, double *); -extern int BSIM4RdseffGeo(double, int, int, int, double, double, double, double, double, int, double *); -extern int BSIM4RdsEndIso(double, double, double, double, double, double, int, int, double *); -extern int BSIM4RdsEndSha(double, double, double, double, double, double, int, int, double *); +extern int BSIM4v7debug(BSIM4v7model*, BSIM4v7instance*, CKTcircuit*, int); +extern int BSIM4v7checkModel(BSIM4v7model*, BSIM4v7instance*, CKTcircuit*); +extern int BSIM4v7PAeffGeo(double, int, int, double, double, double, double, double *, double *, double *, double *); +extern int BSIM4v7RdseffGeo(double, int, int, int, double, double, double, double, double, int, double *); +extern int BSIM4v7RdsEndIso(double, double, double, double, double, double, int, int, double *); +extern int BSIM4v7RdsEndSha(double, double, double, double, double, double, int, int, double *); -#endif /*BSIM4*/ +#endif /*BSIM4v7*/ diff --git a/src/spicelib/devices/bsim4v7/bsim4v7ext.h b/src/spicelib/devices/bsim4v7/bsim4v7ext.h index 4d3a93f0e..e6e863087 100644 --- a/src/spicelib/devices/bsim4v7/bsim4v7ext.h +++ b/src/spicelib/devices/bsim4v7/bsim4v7ext.h @@ -2,30 +2,30 @@ Copyright 2004 Regents of the University of California. All rights reserved. Author: 2000 Weidong Liu Author: 2001- Xuemei Xi -File: bsim4ext.h +File: bsim4v7ext.h **********/ -extern int BSIM4acLoad(GENmodel *,CKTcircuit*); -extern int BSIM4ask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*); -extern int BSIM4convTest(GENmodel *,CKTcircuit*); -extern int BSIM4delete(GENmodel*,IFuid,GENinstance**); -extern void BSIM4destroy(GENmodel**); -extern int BSIM4getic(GENmodel*,CKTcircuit*); -extern int BSIM4load(GENmodel*,CKTcircuit*); -extern int BSIM4mAsk(CKTcircuit*,GENmodel *,int, IFvalue*); -extern int BSIM4mDelete(GENmodel**,IFuid,GENmodel*); -extern int BSIM4mParam(int,IFvalue*,GENmodel*); -extern void BSIM4mosCap(CKTcircuit*, double, double, double, double, +extern int BSIM4v7acLoad(GENmodel *,CKTcircuit*); +extern int BSIM4v7ask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*); +extern int BSIM4v7convTest(GENmodel *,CKTcircuit*); +extern int BSIM4v7delete(GENmodel*,IFuid,GENinstance**); +extern void BSIM4v7destroy(GENmodel**); +extern int BSIM4v7getic(GENmodel*,CKTcircuit*); +extern int BSIM4v7load(GENmodel*,CKTcircuit*); +extern int BSIM4v7mAsk(CKTcircuit*,GENmodel *,int, IFvalue*); +extern int BSIM4v7mDelete(GENmodel**,IFuid,GENmodel*); +extern int BSIM4v7mParam(int,IFvalue*,GENmodel*); +extern void BSIM4v7mosCap(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 BSIM4param(int,IFvalue*,GENinstance*,IFvalue*); -extern int BSIM4pzLoad(GENmodel*,CKTcircuit*,SPcomplex*); -extern int BSIM4setup(SMPmatrix*,GENmodel*,CKTcircuit*,int*); -extern int BSIM4temp(GENmodel*,CKTcircuit*); -extern int BSIM4trunc(GENmodel*,CKTcircuit*,double*); -extern int BSIM4noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*); -extern int BSIM4unsetup(GENmodel*,CKTcircuit*); -extern int BSIM4soaCheck(CKTcircuit *, GENmodel *); +extern int BSIM4v7param(int,IFvalue*,GENinstance*,IFvalue*); +extern int BSIM4v7pzLoad(GENmodel*,CKTcircuit*,SPcomplex*); +extern int BSIM4v7setup(SMPmatrix*,GENmodel*,CKTcircuit*,int*); +extern int BSIM4v7temp(GENmodel*,CKTcircuit*); +extern int BSIM4v7trunc(GENmodel*,CKTcircuit*,double*); +extern int BSIM4v7noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*); +extern int BSIM4v7unsetup(GENmodel*,CKTcircuit*); +extern int BSIM4v7soaCheck(CKTcircuit *, GENmodel *); diff --git a/src/spicelib/devices/bsim4v7/bsim4v7init.c b/src/spicelib/devices/bsim4v7/bsim4v7init.c index e9d13577d..519fbf6ed 100644 --- a/src/spicelib/devices/bsim4v7/bsim4v7init.c +++ b/src/spicelib/devices/bsim4v7/bsim4v7init.c @@ -2,25 +2,25 @@ #include "ngspice/devdefs.h" -#include "bsim4itf.h" -#include "bsim4ext.h" -#include "bsim4init.h" +#include "bsim4v7itf.h" +#include "bsim4v7ext.h" +#include "bsim4v7init.h" -SPICEdev BSIM4info = { +SPICEdev BSIM4v7info = { { - "BSIM4", + "BSIM4v7", "Berkeley Short Channel IGFET Model-4", - &BSIM4nSize, - &BSIM4nSize, - BSIM4names, + &BSIM4v7nSize, + &BSIM4v7nSize, + BSIM4v7names, - &BSIM4pTSize, - BSIM4pTable, + &BSIM4v7pTSize, + BSIM4v7pTable, - &BSIM4mPTSize, - BSIM4mPTable, + &BSIM4v7mPTSize, + BSIM4v7mPTable, #ifdef XSPICE /*---- Fixed by SDB 5.2.2003 to enable XSPICE/tclspice integration -----*/ @@ -40,25 +40,25 @@ SPICEdev BSIM4info = { DEV_DEFAULT }, - BSIM4param, /* DEVparam */ - BSIM4mParam, /* DEVmodParam */ - BSIM4load, /* DEVload */ - BSIM4setup, /* DEVsetup */ - BSIM4unsetup, /* DEVunsetup */ - BSIM4setup, /* DEVpzSetup */ - BSIM4temp, /* DEVtemperature */ - BSIM4trunc, /* DEVtrunc */ + BSIM4v7param, /* DEVparam */ + BSIM4v7mParam, /* DEVmodParam */ + BSIM4v7load, /* DEVload */ + BSIM4v7setup, /* DEVsetup */ + BSIM4v7unsetup, /* DEVunsetup */ + BSIM4v7setup, /* DEVpzSetup */ + BSIM4v7temp, /* DEVtemperature */ + BSIM4v7trunc, /* DEVtrunc */ NULL, /* DEVfindBranch */ - BSIM4acLoad, /* DEVacLoad */ + BSIM4v7acLoad, /* DEVacLoad */ NULL, /* DEVaccept */ - BSIM4destroy, /* DEVdestroy */ - BSIM4mDelete, /* DEVmodDelete */ - BSIM4delete, /* DEVdelete */ - BSIM4getic, /* DEVsetic */ - BSIM4ask, /* DEVask */ - BSIM4mAsk, /* DEVmodAsk */ - BSIM4pzLoad, /* DEVpzLoad */ - BSIM4convTest, /* DEVconvTest */ + BSIM4v7destroy, /* DEVdestroy */ + BSIM4v7mDelete, /* DEVmodDelete */ + BSIM4v7delete, /* DEVdelete */ + BSIM4v7getic, /* DEVsetic */ + BSIM4v7ask, /* DEVask */ + BSIM4v7mAsk, /* DEVmodAsk */ + BSIM4v7pzLoad, /* DEVpzLoad */ + BSIM4v7convTest, /* DEVconvTest */ NULL, /* DEVsenSetup */ NULL, /* DEVsenLoad */ NULL, /* DEVsenUpdate */ @@ -66,19 +66,19 @@ SPICEdev BSIM4info = { NULL, /* DEVsenPrint */ NULL, /* DEVsenTrunc */ NULL, /* DEVdisto */ - BSIM4noise, /* DEVnoise */ - BSIM4soaCheck, /* DEVsoaCheck */ + BSIM4v7noise, /* DEVnoise */ + BSIM4v7soaCheck, /* DEVsoaCheck */ #ifdef CIDER NULL, /* DEVdump */ NULL, /* DEVacct */ #endif - &BSIM4iSize, /* DEVinstSize */ - &BSIM4mSize /* DEVmodSize */ + &BSIM4v7iSize, /* DEVinstSize */ + &BSIM4v7mSize /* DEVmodSize */ }; SPICEdev * -get_bsim4_info(void) +get_bsim4v7_info(void) { - return &BSIM4info; + return &BSIM4v7info; } diff --git a/src/spicelib/devices/bsim4v7/bsim4v7init.h b/src/spicelib/devices/bsim4v7/bsim4v7init.h index 11faee141..f8dbc8af1 100644 --- a/src/spicelib/devices/bsim4v7/bsim4v7init.h +++ b/src/spicelib/devices/bsim4v7/bsim4v7init.h @@ -1,13 +1,13 @@ -#ifndef _BSIM4INIT_H -#define _BSIM4INIT_H +#ifndef _BSIM4v7INIT_H +#define _BSIM4v7INIT_H -extern IFparm BSIM4pTable[ ]; -extern IFparm BSIM4mPTable[ ]; -extern char *BSIM4names[ ]; -extern int BSIM4pTSize; -extern int BSIM4mPTSize; -extern int BSIM4nSize; -extern int BSIM4iSize; -extern int BSIM4mSize; +extern IFparm BSIM4v7pTable[ ]; +extern IFparm BSIM4v7mPTable[ ]; +extern char *BSIM4v7names[ ]; +extern int BSIM4v7pTSize; +extern int BSIM4v7mPTSize; +extern int BSIM4v7nSize; +extern int BSIM4v7iSize; +extern int BSIM4v7mSize; #endif diff --git a/src/spicelib/devices/bsim4v7/bsim4v7itf.h b/src/spicelib/devices/bsim4v7/bsim4v7itf.h index b4dc51e7e..a067ded37 100644 --- a/src/spicelib/devices/bsim4v7/bsim4v7itf.h +++ b/src/spicelib/devices/bsim4v7/bsim4v7itf.h @@ -2,12 +2,12 @@ Copyright 2004 Regents of the University of California. All rights reserved. Author: 2000 Weidong Liu. Author: 2001- Xuemei Xi -File: bsim4itf.h +File: bsim4v7itf.h **********/ -#ifndef DEV_BSIM4 -#define DEV_BSIM4 +#ifndef DEV_BSIM4v7 +#define DEV_BSIM4v7 -SPICEdev *get_bsim4_info(void); +SPICEdev *get_bsim4v7_info(void); #endif