diff --git a/src/spicelib/devices/bsim3soi/BsimTerms_use b/src/spicelib/devices/bsim3soi/BsimTerms_use new file mode 100644 index 000000000..938ec7b36 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/BsimTerms_use @@ -0,0 +1,29 @@ +The terms under which the software is provided  are as the following. + +Software is distributed as is, completely without warranty or service +support. The University of California and its employees are not liable +for the condition or performance of the software. + +The University owns the copyright but shall not be liable for any +infringement of copyright or other proprietary rights brought by third +parties against the users of the software. + +The University of California hereby disclaims all implied warranties. + +The University of California grants the users the right to modify, copy, +and redistribute the software and documentation, both within the user's +organization and externally, subject to the following restrictions + +1. The users agree not to charge for the University of California code +   itself but may charge for additions, extensions, or support. + +2. In any product based on the software, the users agree to acknowledge +   the UC Berkeley BSIM Research Group that developed the software. This +   acknowledgment shall appear in the product documentation. + +3. The users agree to obey all U.S. Government restrictions governing +   redistribution or export of the software. + +4. The users agree to reproduce any copyright notice which appears on +   the software on any copy or modification of such made available +   to others. diff --git a/src/spicelib/devices/bsim3soi/Makefile.am b/src/spicelib/devices/bsim3soi/Makefile.am index 900bc5a3e..f17cc0306 100644 --- a/src/spicelib/devices/bsim3soi/Makefile.am +++ b/src/spicelib/devices/bsim3soi/Makefile.am @@ -3,29 +3,29 @@ noinst_LIBRARIES = libbsim3soi.a libbsim3soi_a_SOURCES = \ - b3soi.c \ - b3soiacld.c \ - b3soiask.c \ - b3soicheck.c \ - b3soicvtest.c \ - b3soidel.c \ - b3soidest.c \ - b3soigetic.c \ - b3soild.c \ - b3soimask.c \ - b3soimdel.c \ - b3soimpar.c \ - b3soinoi.c \ - b3soipar.c \ - b3soipzld.c \ - b3soiset.c \ - b3soitemp.c \ - b3soitrunc.c \ - b3soidef.h \ - b3soiext.h \ - b3soiinit.c \ - b3soiinit.h \ - b3soiitf.h + b4soi.c \ + b4soiacld.c \ + b4soiask.c \ + b4soicheck.c \ + b4soicvtest.c \ + b4soidel.c \ + b4soidest.c \ + b4soigetic.c \ + b4soild.c \ + b4soimask.c \ + b4soimdel.c \ + b4soimpar.c \ + b4soinoi.c \ + b4soipar.c \ + b4soipzld.c \ + b4soiset.c \ + b4soitemp.c \ + b4soitrunc.c \ + b4soidef.h \ + b4soiext.h \ + b4soiinit.c \ + b4soiinit.h \ + b4soiitf.h diff --git a/src/spicelib/devices/bsim3soi/b4soi.c b/src/spicelib/devices/bsim3soi/b4soi.c new file mode 100644 index 000000000..3cfad384b --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soi.c @@ -0,0 +1,958 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soi.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soi.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + + +#include "ngspice.h" +#include "devdefs.h" +#include "b4soidef.h" +#include "suffix.h" + +IFparm B4SOIpTable[] = { /* parameters */ +IOP( "l", B4SOI_L, IF_REAL , "Length"), +IOP( "w", B4SOI_W, IF_REAL , "Width"), +IOP( "m", B4SOI_M, IF_REAL , "Parallel Multiplier"), +IOP( "nf", B4SOI_NF, IF_REAL , "Number of fingers"), +IOP( "sa", B4SOI_SA, IF_REAL , "distance between OD edge to poly of one side "), +IOP( "sb", B4SOI_SB, IF_REAL , "distance between OD edge to poly of the other side"), +IOP( "sd", B4SOI_SD, IF_REAL , "distance between neighbour fingers"), +IOP( "ad", B4SOI_AD, IF_REAL , "Drain area"), +IOP( "as", B4SOI_AS, IF_REAL , "Source area"), +IOP( "pd", B4SOI_PD, IF_REAL , "Drain perimeter"), +IOP( "ps", B4SOI_PS, IF_REAL , "Source perimeter"), +IOP( "nrd", B4SOI_NRD, IF_REAL , "Number of squares in drain"), +IOP( "nrs", B4SOI_NRS, IF_REAL , "Number of squares in source"), +IOP( "off", B4SOI_OFF, IF_FLAG , "Device is initially off"), +IP( "ic", B4SOI_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"), +OP( "gmbs", B4SOI_GMBS, IF_REAL, "Gmb"), +OP( "gm", B4SOI_GM, IF_REAL, "Gm"), +OP( "gmids", B4SOI_GMID, IF_REAL, "Gm/Ids"), +OP( "gds", B4SOI_GDS, IF_REAL, "Gds"), +OP( "vdsat", B4SOI_VDSAT, IF_REAL, "Vdsat"), +OP( "vth", B4SOI_VON, IF_REAL, "Vth"), +OP( "ids", B4SOI_CD, IF_REAL, "Ids"), +OP( "vbs", B4SOI_VBS, IF_REAL, "Vbs"), +OP( "vgs", B4SOI_VGS, IF_REAL, "Vgs"), +OP( "vds", B4SOI_VDS, IF_REAL, "Vds"), +OP( "ves", B4SOI_VES, IF_REAL, "Ves"), +OP( "ibd", B4SOI_IBD, IF_REAL, "Ibd"), +OP( "ibs", B4SOI_IBS, IF_REAL, "Ibs"), +OP( "isub", B4SOI_ISUB, IF_REAL, "Isub"), +OP( "igidl", B4SOI_IGIDL, IF_REAL, "Igidl"), +OP( "igs", B4SOI_IGS, IF_REAL, "Igs"), +OP( "igd", B4SOI_IGD, IF_REAL, "Igd"), +OP( "igb", B4SOI_IGB, IF_REAL, "Igb"), +OP( "igcs", B4SOI_IGCS, IF_REAL, "Igcs"), +OP( "igcd", B4SOI_IGCD, IF_REAL, "Igcd"), +OP( "cgg", B4SOI_CGG, IF_REAL, "Cggb"), +OP( "cgs", B4SOI_CGS, IF_REAL, "Cgsb"), +OP( "cgd", B4SOI_CGD, IF_REAL, "Cgdb"), +OP( "cbg", B4SOI_CBG, IF_REAL, "Cbgb"), +OP( "cbd", B4SOI_CBD, IF_REAL, "Cbdb"), +OP( "cbs", B4SOI_CBS, IF_REAL, "Cbsb"), +OP( "cdg", B4SOI_CDG, IF_REAL, "Cdgb"), +OP( "cdd", B4SOI_CDD, IF_REAL, "Cddb"), +OP( "cds", B4SOI_CDS, IF_REAL, "Cdsb"), +OP( "capbd", B4SOI_CAPBD, IF_REAL, "Capbd"), +OP( "capbs", B4SOI_CAPBS, IF_REAL, "Capbs"), +OP( "qg", B4SOI_QG, IF_REAL, "Qgate"), +OP( "qb", B4SOI_QB, IF_REAL, "Qbulk"), +OP( "qd", B4SOI_QD, IF_REAL, "Qdrain"), +OP( "qs", B4SOI_QS, IF_REAL, "Qsource"), + +IOP( "bjtoff", B4SOI_BJTOFF, IF_INTEGER, "BJT on/off flag"), +IOP( "debug", B4SOI_DEBUG, IF_INTEGER, "BJT on/off flag"), +IOP( "rth0", B4SOI_RTH0, IF_REAL, "Instance Thermal Resistance"), +IOP( "cth0", B4SOI_CTH0, IF_REAL, "Instance Thermal Capacitance"), +IOP( "nrb", B4SOI_NRB, IF_REAL, "Number of squares in body"), +IOP( "frbody", B4SOI_FRBODY, IF_REAL, "layout dependent body-resistance coefficient"), + +/* v4.0 */ +IOP( "nf", B4SOI_NF, IF_REAL , "Number of fingers"), +IOP( "rbdb", B4SOI_RBDB, IF_REAL , "Body resistance"), +IOP( "rbsb", B4SOI_RBSB, IF_REAL , "Body resistance"), +IOP( "delvto", B4SOI_DELVTO, IF_REAL, "Zero bias threshold voltage variation"), +/* v4.0 end */ + +IOP( "soimod", B4SOI_SOIMOD, IF_INTEGER, "Instance model selector for PD/FD operation"), /* v3.2 */ + +/* v2.0 release */ +IOP( "nbc", B4SOI_NBC, IF_REAL, "Number of body contact isolation edge"), +IOP( "nseg", B4SOI_NSEG, IF_REAL, "Number segments for width partitioning"), +IOP( "pdbcp", B4SOI_PDBCP, IF_REAL, "Perimeter length for bc parasitics at drain side"), +IOP( "psbcp", B4SOI_PSBCP, IF_REAL, "Perimeter length for bc parasitics at source side"), +IOP( "agbcp", B4SOI_AGBCP, IF_REAL, "Gate to body overlap area for bc parasitics"), +IOP( "agbcpd", B4SOI_AGBCPD, IF_REAL, "Gate to body overlap area for bc parasitics in DC"), +IOP( "aebcp", B4SOI_AEBCP, IF_REAL, "Substrate to body overlap area for bc prasitics"), +IOP( "vbsusr", B4SOI_VBSUSR, IF_REAL, "Vbs specified by user"), +IOP( "tnodeout", B4SOI_TNODEOUT, IF_FLAG, "Flag indicating external temp node"), + +/*v3.1 added rgatemod */ +IOP( "rgatemod", B4SOI_RGATEMOD, IF_INTEGER, "Gate resistance model selector"), +/*v3.1 added rgatemod */ +IOP( "rbodymod", B4SOI_RBODYMOD, IF_INTEGER, "Body R model selector"),/* v4.0 */ +}; + +IFparm B4SOImPTable[] = { /* model parameters */ +IOP( "capmod", B4SOI_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"), +IOP( "mobmod", B4SOI_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"), +/*IOP( "noimod", B4SOI_MOD_NOIMOD, IF_INTEGER, "Noise model selector"), v3.2 */ +IOP( "paramchk", B4SOI_MOD_PARAMCHK, IF_INTEGER, "Model parameter checking selector"), +IOP( "binunit", B4SOI_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"), +IOP( "version", B4SOI_MOD_VERSION, IF_REAL, " parameter for model version"), +IOP( "tox", B4SOI_MOD_TOX, IF_REAL, "Gate oxide thickness in meters"), +IOP( "toxm", B4SOI_MOD_TOXM, IF_REAL, "Gate oxide thickness used in extraction"), /* v3.2 */ +IOP( "dtoxcv", B4SOI_MOD_DTOXCV, IF_REAL, "Delta oxide thickness in meters in CapMod3"), /* v2.2.3 */ + +IOP( "cdsc", B4SOI_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"), +IOP( "cdscb", B4SOI_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"), +IOP( "cdscd", B4SOI_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"), +IOP( "cit", B4SOI_MOD_CIT, IF_REAL, "Interface state capacitance"), +IOP( "nfactor", B4SOI_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"), +IOP( "vsat", B4SOI_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"), +IOP( "at", B4SOI_MOD_AT, IF_REAL, "Temperature coefficient of vsat"), +IOP( "a0", B4SOI_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."), +IOP( "ags", B4SOI_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."), +IOP( "a1", B4SOI_MOD_A1, IF_REAL, "Non-saturation effect coefficient"), +IOP( "a2", B4SOI_MOD_A2, IF_REAL, "Non-saturation effect coefficient"), +IOP( "keta", B4SOI_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."), +IOP( "nsub", B4SOI_MOD_NSUB, IF_REAL, "Substrate doping concentration with polarity"), +IOP( "nch", B4SOI_MOD_NPEAK, IF_REAL, "Channel doping concentration"), +IOP( "ngate", B4SOI_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"), +IOP( "gamma1", B4SOI_MOD_GAMMA1, IF_REAL, "Vth body coefficient"), +IOP( "gamma2", B4SOI_MOD_GAMMA2, IF_REAL, "Vth body coefficient"), +IOP( "vbx", B4SOI_MOD_VBX, IF_REAL, "Vth transition body Voltage"), +IOP( "vbm", B4SOI_MOD_VBM, IF_REAL, "Maximum body voltage"), + +IOP( "xt", B4SOI_MOD_XT, IF_REAL, "Doping depth"), +IOP( "k1", B4SOI_MOD_K1, IF_REAL, "Bulk effect coefficient 1"), +IOP( "kt1", B4SOI_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"), +IOP( "kt1l", B4SOI_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"), +IOP( "kt2", B4SOI_MOD_KT2, IF_REAL, "Body-coefficient of kt1"), +IOP( "k2", B4SOI_MOD_K2, IF_REAL, "Bulk effect coefficient 2"), +IOP( "k3", B4SOI_MOD_K3, IF_REAL, "Narrow width effect coefficient"), +IOP( "k3b", B4SOI_MOD_K3B, IF_REAL, "Body effect coefficient of k3"), +IOP( "w0", B4SOI_MOD_W0, IF_REAL, "Narrow width effect parameter"), +IOP( "lpe0", B4SOI_MOD_LPE0, IF_REAL, "Lateral non-uniform doping effect"), +IOP( "lpeb", B4SOI_MOD_LPEB, IF_REAL, "Lateral non-uniform doping effect for body bias"), +IOP( "dvt0", B4SOI_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"), +IOP( "dvt1", B4SOI_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"), +IOP( "dvt2", B4SOI_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"), +IOP( "dvt0w", B4SOI_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"), +IOP( "dvt1w", B4SOI_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"), +IOP( "dvt2w", B4SOI_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"), +IOP( "drout", B4SOI_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"), +IOP( "dsub", B4SOI_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"), +IOP( "vth0", B4SOI_MOD_VTH0, IF_REAL,"Threshold voltage"), +IOP( "vtho", B4SOI_MOD_VTH0, IF_REAL,"Threshold voltage"), +IOP( "ua", B4SOI_MOD_UA, IF_REAL, "Linear gate dependence of mobility"), +IOP( "ua1", B4SOI_MOD_UA1, IF_REAL, "Temperature coefficient of ua"), +IOP( "ub", B4SOI_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"), +IOP( "ub1", B4SOI_MOD_UB1, IF_REAL, "Temperature coefficient of ub"), +IOP( "uc", B4SOI_MOD_UC, IF_REAL, "Body-bias dependence of mobility"), +IOP( "uc1", B4SOI_MOD_UC1, IF_REAL, "Temperature coefficient of uc"), +IOP( "u0", B4SOI_MOD_U0, IF_REAL, "Low-field mobility at Tnom"), +IOP( "ute", B4SOI_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"), +IOP( "voff", B4SOI_MOD_VOFF, IF_REAL, "Threshold voltage offset"), +IOP( "tnom", B4SOI_MOD_TNOM, IF_REAL, "Parameter measurement temperature"), +IOP( "cgso", B4SOI_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"), +IOP( "cgdo", B4SOI_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"), +IOP( "xpart", B4SOI_MOD_XPART, IF_REAL, "Channel charge partitioning"), +IOP( "delta", B4SOI_MOD_DELTA, IF_REAL, "Effective Vds parameter"), +IOP( "rsh", B4SOI_MOD_RSH, IF_REAL, "Source-drain sheet resistance"), +IOP( "rdsw", B4SOI_MOD_RDSW, IF_REAL, "Source-drain resistance per width"), +IOP( "rsw", B4SOI_MOD_RSW, IF_REAL, "Source resistance per width"), /* v4.0 */ +IOP( "rdw", B4SOI_MOD_RDW, IF_REAL, "Drain resistance per width"), /* v4.0 */ +IOP( "rswmin", B4SOI_MOD_RSWMIN, IF_REAL, "Source resistance per width at high Vg"), +IOP( "rdwmin", B4SOI_MOD_RDWMIN, IF_REAL, "Drain resistance per width at hight Vg"), + +IOP( "prwg", B4SOI_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "), +IOP( "prwb", B4SOI_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "), + +IOP( "prt", B4SOI_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "), +IOP( "eta0", B4SOI_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"), +IOP( "etab", B4SOI_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"), +IOP( "pclm", B4SOI_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"), +IOP( "pdiblc1", B4SOI_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"), +IOP( "pdiblc2", B4SOI_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"), +IOP( "pdiblcb", B4SOI_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"), + +IOP( "pvag", B4SOI_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"), + +IOP( "shmod", B4SOI_MOD_SHMOD, IF_INTEGER, "Self heating mode selector"), +IOP( "ddmod", B4SOI_MOD_DDMOD, IF_INTEGER, "Dynamic depletion mode selector"), +IOP( "tbox", B4SOI_MOD_TBOX, IF_REAL, "Back gate oxide thickness in meters"), +IOP( "tsi", B4SOI_MOD_TSI, IF_REAL, "Silicon-on-insulator thickness in meters"), +IOP( "xj", B4SOI_MOD_XJ, IF_REAL, "Junction Depth"), +IOP( "rth0", B4SOI_MOD_RTH0, IF_REAL, "Self-heating thermal resistance"), +IOP( "cth0", B4SOI_MOD_CTH0, IF_REAL, "Self-heating thermal capacitance"), +IOP( "egidl", B4SOI_MOD_EGIDL, IF_REAL, "GIDL first parameter"), +IOP( "agidl", B4SOI_MOD_AGIDL, IF_REAL, "GIDL second parameter"), +IOP( "bgidl", B4SOI_MOD_BGIDL, IF_REAL, "GIDL third parameter"), +IOP( "cgidl", B4SOI_MOD_CGIDL, IF_REAL, "GIDL vb parameter"), +IOP( "ndiode", B4SOI_MOD_NDIODES, IF_REAL,"Diode non-ideality factor"),/*v4.0*/ +IOP( "ndioded", B4SOI_MOD_NDIODED, IF_REAL,"Diode non-ideality factor"),/*v4.0*/ +IOP( "xbjt", B4SOI_MOD_XBJT, IF_REAL, "Temperature coefficient for Isbjt"), + +IOP( "xdif", B4SOI_MOD_XDIFS, IF_REAL, "Temperature coefficient for Isdif"), +IOP( "xrec", B4SOI_MOD_XRECS, IF_REAL, "Temperature coefficient for Isrec"), +IOP( "xtun", B4SOI_MOD_XTUNS, IF_REAL, "Temperature coefficient for Istun"), +IOP( "xdifd", B4SOI_MOD_XDIFD, IF_REAL, "Temperature coefficient for Iddif"), +IOP( "xrecd", B4SOI_MOD_XRECD, IF_REAL, "Temperature coefficient for Idrec"), +IOP( "xtund", B4SOI_MOD_XTUND, IF_REAL, "Temperature coefficient for Idtun"), + +IOP( "pbswg", B4SOI_MOD_PBSWGS, IF_REAL, "Source(gate side) sidewall junction capacitance built in potential"), /* v4.0 */ +IOP( "pbswgd", B4SOI_MOD_PBSWGD, IF_REAL, "Drain(gate side) sidewall junction capacitance built in potential"), /* v4.0 */ +IOP( "mjswg", B4SOI_MOD_MJSWGS, IF_REAL, "Source (gate side) sidewall junction capacitance grading coefficient"), /* v4.0 */ +IOP( "mjswgd", B4SOI_MOD_MJSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance grading coefficient"), /* v4.0 */ +IOP( "cjswg", B4SOI_MOD_CJSWGS, IF_REAL, "Source(gate side) sidewall junction capacitance per unit width"), /* v4.0 */ +IOP( "cjswgd", B4SOI_MOD_CJSWGD, IF_REAL, "Drain (gate side) sidewall junction capacitance per unit width"), /* v4.0 */ +IOP( "lint", B4SOI_MOD_LINT, IF_REAL, "Length reduction parameter"), +IOP( "ll", B4SOI_MOD_LL, IF_REAL, "Length reduction parameter"), +IOP( "llc", B4SOI_MOD_LLC, IF_REAL, "Length reduction parameter"), /* v2.2.3 */ +IOP( "lln", B4SOI_MOD_LLN, IF_REAL, "Length reduction parameter"), +IOP( "lw", B4SOI_MOD_LW, IF_REAL, "Length reduction parameter"), +IOP( "lwc", B4SOI_MOD_LWC, IF_REAL, "Length reduction parameter"), /* v2.2.3 */ +IOP( "lwn", B4SOI_MOD_LWN, IF_REAL, "Length reduction parameter"), +IOP( "lwl", B4SOI_MOD_LWL, IF_REAL, "Length reduction parameter"), +IOP( "lwlc", B4SOI_MOD_LWLC, IF_REAL, "Length reduction parameter"), /* v2.2.3 */ + +IOP( "wr", B4SOI_MOD_WR, IF_REAL, "Width dependence of rds"), +IOP( "wint", B4SOI_MOD_WINT, IF_REAL, "Width reduction parameter"), +IOP( "dwg", B4SOI_MOD_DWG, IF_REAL, "Width reduction parameter"), +IOP( "dwb", B4SOI_MOD_DWB, IF_REAL, "Width reduction parameter"), + +IOP( "wl", B4SOI_MOD_WL, IF_REAL, "Width reduction parameter"), +IOP( "wlc", B4SOI_MOD_WLC, IF_REAL, "Width reduction parameter"), /* v2.2.3 */ +IOP( "wln", B4SOI_MOD_WLN, IF_REAL, "Width reduction parameter"), +IOP( "ww", B4SOI_MOD_WW, IF_REAL, "Width reduction parameter"), +IOP( "wwc", B4SOI_MOD_WWC, IF_REAL, "Width reduction parameter"), /* v2.2.3 */ +IOP( "wwn", B4SOI_MOD_WWN, IF_REAL, "Width reduction parameter"), +IOP( "wwl", B4SOI_MOD_WWL, IF_REAL, "Width reduction parameter"), +IOP( "wwlc", B4SOI_MOD_WWLC, IF_REAL, "Width reduction parameter"), /* v2.2.3 */ + +IOP( "b0", B4SOI_MOD_B0, IF_REAL, "Abulk narrow width parameter"), +IOP( "b1", B4SOI_MOD_B1, IF_REAL, "Abulk narrow width parameter"), + +IOP( "cgsl", B4SOI_MOD_CGSL, IF_REAL, "New C-V model parameter"), +IOP( "cgdl", B4SOI_MOD_CGDL, IF_REAL, "New C-V model parameter"), +IOP( "ckappa", B4SOI_MOD_CKAPPA, IF_REAL, "New C-V model parameter"), +IOP( "cf", B4SOI_MOD_CF, IF_REAL, "Fringe capacitance parameter"), +IOP( "clc", B4SOI_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"), +IOP( "cle", B4SOI_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"), +IOP( "dwc", B4SOI_MOD_DWC, IF_REAL, "Delta W for C-V model"), +IOP( "dlc", B4SOI_MOD_DLC, IF_REAL, "Delta L for C-V model"), + +IOP( "alpha0", B4SOI_MOD_ALPHA0, IF_REAL, "substrate current model parameter"), + +IOP( "noia", B4SOI_MOD_NOIA, IF_REAL, "Flicker noise parameter"), +IOP( "noib", B4SOI_MOD_NOIB, IF_REAL, "Flicker noise parameter"), +IOP( "noic", B4SOI_MOD_NOIC, IF_REAL, "Flicker noise parameter"), + +/* v3.2 */ +IOP( "fnoimod", B4SOI_MOD_FNOIMOD, IF_INTEGER, "Flicker noise model selector"), +IOP( "tnoimod", B4SOI_MOD_TNOIMOD, IF_INTEGER, "Thermal noise model selector"), +IOP( "tnoia", B4SOI_MOD_TNOIA, IF_REAL, "Thermal noise parameter"), +IOP( "tnoib", B4SOI_MOD_TNOIB, IF_REAL, "Thermal noise parameter"), +IOP( "rnoia", B4SOI_MOD_RNOIA, IF_REAL, "Thermal noise coefficient"), +IOP( "rnoib", B4SOI_MOD_RNOIB, IF_REAL, "Thermal noise coefficient"), +IOP( "ntnoi", B4SOI_MOD_NTNOI, IF_REAL, "Thermal noise parameter"), +/* v3.2 */ + +/* v4.0 stress effect*/ +IOP( "saref", B4SOI_MOD_SAREF, IF_REAL, "Reference distance between OD edge to poly of one side"), +IOP( "sbref", B4SOI_MOD_SBREF, IF_REAL, "Reference distance between OD edge to poly of the other side"), +IOP( "wlod", B4SOI_MOD_WLOD, IF_REAL, "Width parameter for stress effect"), +IOP( "ku0", B4SOI_MOD_KU0, IF_REAL, "Mobility degradation/enhancement coefficient for LOD"), +IOP( "kvsat", B4SOI_MOD_KVSAT, IF_REAL, "Saturation velocity degradation/enhancement parameter for LOD"), +IOP( "kvth0", B4SOI_MOD_KVTH0, IF_REAL, "Threshold degradation/enhancement parameter for LOD"), +IOP( "tku0", B4SOI_MOD_TKU0, IF_REAL, "Temperature coefficient of KU0"), +IOP( "llodku0", B4SOI_MOD_LLODKU0, IF_REAL, "Length parameter for u0 LOD effect"), +IOP( "wlodku0", B4SOI_MOD_WLODKU0, IF_REAL, "Width parameter for u0 LOD effect"), +IOP( "llodvth", B4SOI_MOD_LLODVTH, IF_REAL, "Length parameter for vth LOD effect"), +IOP( "wlodvth", B4SOI_MOD_WLODVTH, IF_REAL, "Width parameter for vth LOD effect"), +IOP( "lku0", B4SOI_MOD_LKU0, IF_REAL, "Length dependence of ku0"), +IOP( "wku0", B4SOI_MOD_WKU0, IF_REAL, "Width dependence of ku0"), +IOP( "pku0", B4SOI_MOD_PKU0, IF_REAL, "Cross-term dependence of ku0"), +IOP( "lkvth0", B4SOI_MOD_LKVTH0, IF_REAL, "Length dependence of kvth0"), +IOP( "wkvth0", B4SOI_MOD_WKVTH0, IF_REAL, "Width dependence of kvth0"), +IOP( "pkvth0", B4SOI_MOD_PKVTH0, IF_REAL, "Cross-term dependence of kvth0"), +IOP( "stk2", B4SOI_MOD_STK2, IF_REAL, "K2 shift factor related to stress effect on vth"), +IOP( "lodk2", B4SOI_MOD_LODK2, IF_REAL, "K2 shift modification factor for stress effect"), +IOP( "steta0", B4SOI_MOD_STETA0, IF_REAL, "eta0 shift factor related to stress effect on vth"), +IOP( "lodeta0", B4SOI_MOD_LODETA0, IF_REAL, "eta0 shift modification factor for stress effect"), +/* v4.0 stress effect end */ + +/* v4.0 */ +IOP( "gbmin", B4SOI_MOD_GBMIN, IF_REAL, "Minimum body conductance"), +IOP( "rbdb", B4SOI_MOD_RBDB, IF_REAL, "Resistance between bNode and dbNode"), +IOP( "rbsb", B4SOI_MOD_RBSB, IF_REAL, "Resistance between bNode and sbNode"), +IOP( "bf", B4SOI_MOD_BF, IF_REAL, "Flicker noise length dependence exponent"), +IOP( "w0flk", B4SOI_MOD_W0FLK, IF_REAL, "Flicker noise width dependence"), +IOP( "frbody", B4SOI_MOD_FRBODY,IF_REAL, "Layout dependent rbody multiplier "), +IOP( "dvtp0", B4SOI_MOD_DVTP0, IF_REAL, "First parameter for Vth shift due to pocket"), +IOP( "ldvtp0", B4SOI_MOD_LDVTP0, IF_REAL, "Length dependence of dvtp0"), +IOP( "wdvtp0", B4SOI_MOD_WDVTP0, IF_REAL, "Width dependence of dvtp0"), +IOP( "pdvtp0", B4SOI_MOD_PDVTP0, IF_REAL, "Cross-term dependence of dvtp0"), +IOP( "dvtp1", B4SOI_MOD_DVTP1, IF_REAL, "Second parameter for Vth shift due to pocket"), +IOP( "ldvtp1", B4SOI_MOD_LDVTP1, IF_REAL, "Length dependence of dvtp1"), +IOP( "wdvtp1", B4SOI_MOD_WDVTP1, IF_REAL, "Width dependence of dvtp1"), +IOP( "pdvtp1", B4SOI_MOD_PDVTP1, IF_REAL, "Cross-term dependence of dvtp1"), +IOP( "minv", B4SOI_MOD_MINV, IF_REAL, "For moderate invversion in Vgsteff"), +IOP( "lminv", B4SOI_MOD_LMINV, IF_REAL, "Length dependence of minv"), +IOP( "wminv", B4SOI_MOD_WMINV, IF_REAL, "width dependence of minv"), +IOP( "pminv", B4SOI_MOD_PMINV, IF_REAL, "Cross-term dependence of minv"), +IOP( "pdits", B4SOI_MOD_PDITS, IF_REAL, "Coefficient for drain-induced Vth shifts"), +IOP( "pditsl", B4SOI_MOD_PDITSL, IF_REAL, "Length dependence of drain-induced Vth shifts"), +IOP( "pditsd", B4SOI_MOD_PDITSD, IF_REAL, "Vds dependence of drain-induced Vth shifts"), +IOP( "fprout", B4SOI_MOD_FPROUT, IF_REAL, "Rout degradation coefficient for pocket devices"), +IOP( "lfprout", B4SOI_MOD_LFPROUT, IF_REAL, "Length dependence of pdiblcb"), +IOP( "lpdits", B4SOI_MOD_LPDITS, IF_REAL, "Length dependence of pdits"), +IOP( "lpditsd", B4SOI_MOD_LPDITSD, IF_REAL, "Length dependence of pditsd"), +IOP( "wfprout", B4SOI_MOD_WFPROUT, IF_REAL, "Width dependence of pdiblcb"), +IOP( "wpdits", B4SOI_MOD_WPDITS, IF_REAL, "Width dependence of pdits"), +IOP( "wpditsd", B4SOI_MOD_WPDITSD, IF_REAL, "Width dependence of pditsd"), +IOP( "pfprout", B4SOI_MOD_PFPROUT, IF_REAL, "Cross-term dependence of pdiblcb"), +IOP( "ppdits", B4SOI_MOD_PPDITS, IF_REAL, "Cross-term dependence of pdits"), +IOP( "ppditsd", B4SOI_MOD_PPDITSD, IF_REAL, "Cross-term dependence of pditsd"), + +/* v4.0 */ + +IOP( "em", B4SOI_MOD_EM, IF_REAL, "Flicker noise parameter"), +IOP( "ef", B4SOI_MOD_EF, IF_REAL, "Flicker noise frequency exponent"), +IOP( "af", B4SOI_MOD_AF, IF_REAL, "Flicker noise exponent"), +IOP( "kf", B4SOI_MOD_KF, IF_REAL, "Flicker noise coefficient"), +IOP( "noif", B4SOI_MOD_NOIF, IF_REAL, "Floating body excess noise ideality factor"), + +/* v2.0 release */ +IOP( "k1w1", B4SOI_MOD_K1W1, IF_REAL, "First Body effect width dependent parameter"), +IOP( "k1w2", B4SOI_MOD_K1W2, IF_REAL, "Second Boby effect width dependent parameter"), +IOP( "ketas", B4SOI_MOD_KETAS, IF_REAL, "Surface potential adjustment for bulk charge effect"), +IOP( "dwbc", B4SOI_MOD_DWBC, IF_REAL, "Width offset for body contact isolation edge"), +IOP( "beta0", B4SOI_MOD_BETA0, IF_REAL, "First Vds dependent parameter of impact ionizition current"), +IOP( "beta1", B4SOI_MOD_BETA1, IF_REAL, "Second Vds dependent parameter of impact ionizition current"), +IOP( "beta2", B4SOI_MOD_BETA2, IF_REAL, "Third Vds dependent parameter of impact ionizition current"), +IOP( "vdsatii0", B4SOI_MOD_VDSATII0, IF_REAL, "Nominal drain saturation voltage at threshold for impact ionizition current"), +IOP( "tii", B4SOI_MOD_TII, IF_REAL, "Temperature dependent parameter for impact ionizition"), +IOP( "lii", B4SOI_MOD_LII, IF_REAL, "Channel length dependent parameter at threshold for impact ionizition current"), +IOP( "sii0", B4SOI_MOD_SII0, IF_REAL, "First Vgs dependent parameter for impact ionizition current"), +IOP( "sii1", B4SOI_MOD_SII1, IF_REAL, "Second Vgs dependent parameter for impact ionizition current"), +IOP( "sii2", B4SOI_MOD_SII2, IF_REAL, "Third Vgs dependent parameter for impact ionizition current"), +IOP( "siid", B4SOI_MOD_SIID, IF_REAL, "Vds dependent parameter of drain saturation voltage for impact ionizition current"), +IOP( "fbjtii", B4SOI_MOD_FBJTII, IF_REAL, "Fraction of bipolar current affecting the impact ionization"), +IOP( "esatii", B4SOI_MOD_ESATII, IF_REAL, "Saturation electric field for impact ionization"), +IOP( "ntun", B4SOI_MOD_NTUNS, IF_REAL,"Reverse tunneling non-ideality factor"), +IOP( "ntund", B4SOI_MOD_NTUND, IF_REAL,"Reverse tunneling non-ideality factor"), +IOP( "nrecf0", B4SOI_MOD_NRECF0S, IF_REAL, "Recombination non-ideality factor at forward bias"), +IOP( "nrecf0d", B4SOI_MOD_NRECF0D, IF_REAL, "Recombination non-ideality factor at forward bias"), +IOP( "nrecr0", B4SOI_MOD_NRECR0S, IF_REAL, "Recombination non-ideality factor at reversed bias"), +IOP( "nrecr0d", B4SOI_MOD_NRECR0D, IF_REAL, "Recombination non-ideality factor at reversed bias"), +IOP( "isbjt", B4SOI_MOD_ISBJT, IF_REAL, "BJT injection saturation current"), +IOP( "idbjt", B4SOI_MOD_IDBJT, IF_REAL, "BJT injection saturation current"), +IOP( "isdif", B4SOI_MOD_ISDIF, IF_REAL, "Body to source/drain injection saturation current"), +IOP( "iddif", B4SOI_MOD_IDDIF, IF_REAL, "Body to source/drain injection saturation current"), /* v4.0 */ +IOP( "isrec", B4SOI_MOD_ISREC, IF_REAL, "Recombination in depletion saturation current"), +IOP( "idrec", B4SOI_MOD_IDREC, IF_REAL, "Recombination in depletion saturation current"), +IOP( "istun", B4SOI_MOD_ISTUN, IF_REAL, "Reverse tunneling saturation current"), +IOP( "idtun", B4SOI_MOD_IDTUN, IF_REAL, "Reverse tunneling saturation current"), +IOP( "ln", B4SOI_MOD_LN, IF_REAL, "Electron/hole diffusion length"), +IOP( "vrec0", B4SOI_MOD_VREC0S, IF_REAL, "Voltage dependent parameter for recombination current"), +IOP( "vrec0d", B4SOI_MOD_VREC0D, IF_REAL, "Voltage dependent parameter for recombination current"), +IOP( "vtun0", B4SOI_MOD_VTUN0S, IF_REAL, "Voltage dependent parameter for tunneling current"), +IOP( "vtun0d", B4SOI_MOD_VTUN0D, IF_REAL, "Voltage dependent parameter for tunneling current"), +IOP( "nbjt", B4SOI_MOD_NBJT, IF_REAL, "Power coefficient of channel length dependency for bipolar current"), +IOP( "lbjt0", B4SOI_MOD_LBJT0, IF_REAL, "Refferenc channel length for bipolar cuurent"), +IOP( "ldif0", B4SOI_MOD_LDIF0, IF_REAL, "Channel-length dependency coefficient of diffusion cap"), +IOP( "vabjt", B4SOI_MOD_VABJT, IF_REAL, "Early voltage for bipolar current"), +IOP( "aely", B4SOI_MOD_AELY, IF_REAL, "Channel length dependency of early voltage for bipolar cuurent"), +IOP( "ahli", B4SOI_MOD_AHLIS, IF_REAL, "High level injection parameter for bipolar current"), /* v4.0 */ +IOP( "ahlid", B4SOI_MOD_AHLID, IF_REAL, "High level injection parameter for bipolar current"), /* v4.0 */ +IOP( "rbody", B4SOI_MOD_RBODY, IF_REAL, "Intrinsic body contact sheet resistance"), +IOP( "rbsh", B4SOI_MOD_RBSH, IF_REAL, "Extrinsic body contact sheet resistance"), +IOP( "cgeo", B4SOI_MOD_CGEO, IF_REAL, "Gate substrate overlap capacitance per unit channel length"), +IOP( "tt", B4SOI_MOD_TT, IF_REAL, "Diffusion capacitance transit time coefficient"), +IOP( "ndif", B4SOI_MOD_NDIF, IF_REAL, "Power coefficient of channel length dependency for diffusion capacitance"), +IOP( "vsdfb", B4SOI_MOD_VSDFB, IF_REAL, "Source/drain bottom diffusion capacitance flatband voltage"), +IOP( "vsdth", B4SOI_MOD_VSDTH, IF_REAL, "Source/drain bottom diffusion capacitance threshold voltage"), +IOP( "csdmin", B4SOI_MOD_CSDMIN, IF_REAL, "Source/drain bottom diffusion minimum capacitance"), +IOP( "asd", B4SOI_MOD_ASD, IF_REAL, "Source/drain bottom diffusion smoothing parameter"), +IOP( "csdesw", B4SOI_MOD_CSDESW, IF_REAL, "Source/drain sidewall fringing capacitance per unit length"), +IOP( "ntrecf", B4SOI_MOD_NTRECF, IF_REAL, "Temperature coefficient for Nrecf"), +IOP( "ntrecr", B4SOI_MOD_NTRECR, IF_REAL, "Temperature coefficient for Nrecr"), +IOP( "dlcb", B4SOI_MOD_DLCB, IF_REAL, "Length offset fitting parameter for body charge"), +IOP( "fbody", B4SOI_MOD_FBODY, IF_REAL, "Scaling factor for body charge"), +IOP( "tcjswg", B4SOI_MOD_TCJSWGS, IF_REAL, "Temperature coefficient of Cjswgs"), +IOP( "tpbswg", B4SOI_MOD_TPBSWGS, IF_REAL, "Temperature coefficient of Pbswgs"), +IOP( "tcjswgd", B4SOI_MOD_TCJSWGD, IF_REAL, "Temperature coefficient of Cjswgd"), +IOP( "tpbswgd", B4SOI_MOD_TPBSWGD, IF_REAL, "Temperature coefficient of Pbswgd"), +IOP( "acde", B4SOI_MOD_ACDE, IF_REAL, "Exponential coefficient for charge thickness in capMod=3 for accumulation and depletion regions"), +IOP( "moin", B4SOI_MOD_MOIN, IF_REAL, "Coefficient for the gate-bias dependent surface potential"), +IOP( "noff", B4SOI_MOD_NOFF, IF_REAL, "C-V turn-on/off parameter"), /* v3.2 */ +IOP( "delvt", B4SOI_MOD_DELVT, IF_REAL, "Threshold voltage adjust for CV"), +IOP( "kb1", B4SOI_MOD_KB1, IF_REAL, "Scaling factor for backgate charge"), +IOP( "dlbg", B4SOI_MOD_DLBG, IF_REAL, "Length offset fitting parameter for backgate charge"), + + +/* v2.2 release */ +IOP( "igmod", B4SOI_MOD_IGBMOD, IF_INTEGER, "gate-body tunneling current model selector"), /* v3.1.1 */ +IOP( "igbmod", B4SOI_MOD_IGBMOD, IF_INTEGER, "gate-body tunneling current model selector"), /* v3.0 */ +IOP( "igcmod", B4SOI_MOD_IGCMOD, IF_INTEGER, "gate-channel tunneling current model selector"), /* v3.0 */ +IOP( "toxqm", B4SOI_MOD_TOXQM, IF_REAL, "effective oxide thickness considering quantum effect"), +IOP( "wth0", B4SOI_MOD_WTH0, IF_REAL, "Minimum width for thermal resistance calculation"), +IOP( "rhalo", B4SOI_MOD_RHALO, IF_REAL, "body halo sheet resistance"), +IOP( "ntox", B4SOI_MOD_NTOX, IF_REAL, "power term of gate current"), +IOP( "toxref", B4SOI_MOD_TOXREF, IF_REAL, "target oxide thickness"), +IOP( "ebg", B4SOI_MOD_EBG, IF_REAL, "effective bandgap in gate current calcula."), +IOP( "vevb", B4SOI_MOD_VEVB, IF_REAL, "Vaux parameter for valence-band electron tunneling"), +IOP( "alphagb1", B4SOI_MOD_ALPHAGB1, IF_REAL, "First Vox dependent parameter for gate curent in inversion"), +IOP( "betagb1", B4SOI_MOD_BETAGB1, IF_REAL, "Second Vox dependent parameter for gate currnt in inversion"), +IOP( "vgb1", B4SOI_MOD_VGB1, IF_REAL, "Third Vox dependent parameter for gate current in inversion"), +IOP( "vecb", B4SOI_MOD_VECB, IF_REAL, "Vaux parameter for conduction-band electron tunneling"), +IOP( "alphagb2", B4SOI_MOD_ALPHAGB2, IF_REAL, "First Vox dependent parameter for gate current in accumulation"), +IOP( "betagb2", B4SOI_MOD_BETAGB2, IF_REAL, "Second Vox dependent parameter for gate current in accumulation"), +IOP( "vgb2", B4SOI_MOD_VGB2, IF_REAL, "Third Vox dependent parameter for gate current in accumulation"), +IOP( "voxh", B4SOI_MOD_VOXH, IF_REAL, "the limit of Vox in gate current calculation"), +IOP( "deltavox", B4SOI_MOD_DELTAVOX, IF_REAL, "the smoothing parameter in the Vox smoothing function"), + +/* v3.0 */ +IOP( "aigc", B4SOI_MOD_AIGC, IF_REAL, "Parameter for Igc"), +IOP( "bigc", B4SOI_MOD_BIGC, IF_REAL, "Parameter for Igc"), +IOP( "cigc", B4SOI_MOD_CIGC, IF_REAL, "Parameter for Igc"), +IOP( "aigsd", B4SOI_MOD_AIGSD, IF_REAL, "Parameter for Igs,d"), +IOP( "bigsd", B4SOI_MOD_BIGSD, IF_REAL, "Parameter for Igs,d"), +IOP( "cigsd", B4SOI_MOD_CIGSD, IF_REAL, "Parameter for Igs,d"), +IOP( "nigc", B4SOI_MOD_NIGC, IF_REAL, "Parameter for Igc slope"), +IOP( "pigcd", B4SOI_MOD_PIGCD, IF_REAL, "Parameter for Igc partition"), +IOP( "poxedge", B4SOI_MOD_POXEDGE, IF_REAL, "Factor for the gate edge Tox"), +IOP( "dlcig", B4SOI_MOD_DLCIG, IF_REAL, "Delta L for Ig model"), + +/* v3.0 */ +IOP( "soimod", B4SOI_MOD_SOIMOD, IF_INTEGER, "model selector for SOI technology"), /* v3.2 bug fix */ +IOP( "vbs0pd", B4SOI_MOD_VBS0PD, IF_REAL, "Upper bound of built-in potential lowering for PD operation"), /* v3.2 */ +IOP( "vbs0fd", B4SOI_MOD_VBS0FD, IF_REAL, "Lower bound of built-in potential lowering for FD operation"), /* v3.2 */ +IOP( "vbsa", B4SOI_MOD_VBSA, IF_REAL, "Vbs0t offset voltage"), +IOP( "nofffd", B4SOI_MOD_NOFFFD,IF_REAL, "smoothing parameter in FD module"), +IOP( "vofffd", B4SOI_MOD_VOFFFD,IF_REAL, "smoothing parameter in FD module"), +IOP( "k1b", B4SOI_MOD_K1B, IF_REAL, "first backgate body effect parameter"), +IOP( "k2b", B4SOI_MOD_K2B, IF_REAL, "second backgate body effect parameter for short channel effect"), +IOP( "dk2b", B4SOI_MOD_DK2B, IF_REAL, "third backgate body effect parameter for short channel effect"), +IOP( "dvbd0", B4SOI_MOD_DVBD0, IF_REAL, "first short-channel effect parameter in FD module"), +IOP( "dvbd1", B4SOI_MOD_DVBD1, IF_REAL, "second short-channel effect parameter in FD module"), +IOP( "moinfd", B4SOI_MOD_MOINFD, IF_REAL, "Coefficient for the gate-bias dependent surface potential in FD"), +/* v3.0 */ + + +/* v3.1 added for RF */ +IOP( "rgatemod", B4SOI_MOD_RGATEMOD, IF_INTEGER, "Gate R model selector"), +IOP("xrcrg1", B4SOI_MOD_XRCRG1, IF_REAL, "First fitting parameter the bias-dependent Rg"), +IOP("xrcrg2", B4SOI_MOD_XRCRG2, IF_REAL, "Second fitting parameter the bias-dependent Rg"), +IOP("rshg", B4SOI_MOD_RSHG, IF_REAL, "Gate sheet resistance"), +IOP("ngcon", B4SOI_MOD_NGCON, IF_REAL, "Number of gate contacts"), +IOP( "xgw", B4SOI_MOD_XGW, IF_REAL, "Distance from gate contact center to device edge"), +IOP( "xgl", B4SOI_MOD_XGL, IF_REAL, "Variation in Ldrawn"), +/* v3.1 added for RF end */ + +/* 4.0 */ +IOP( "rbodymod", B4SOI_MOD_RBODYMOD, IF_INTEGER, "Body R model selector"), +/* 4.0 */ +IOP( "rdsmod", B4SOI_MOD_RDSMOD, IF_INTEGER, "Bias-dependent S/D resistance model selector"), /* v4.0 */ + +/* Added for binning - START */ +/* Length Dependence */ +/* v3.1 */ +IOP( "lxj", B4SOI_MOD_LXJ, IF_REAL, "Length dependence of xj"), +IOP( "lalphagb1", B4SOI_MOD_LALPHAGB1, IF_REAL, "Length dependence of alphagb1"), +IOP( "lbetagb1", B4SOI_MOD_LBETAGB1, IF_REAL, "Length dependence of betagb1"), +IOP( "lalphagb2", B4SOI_MOD_LALPHAGB2, IF_REAL, "Length dependence of alphagb2"), +IOP( "lbetagb2", B4SOI_MOD_LBETAGB2, IF_REAL, "Length dependence of betagb2"), +IOP( "lcgsl", B4SOI_MOD_LCGSL, IF_REAL, "Length dependence of cgsl"), +IOP( "lcgdl", B4SOI_MOD_LCGDL, IF_REAL, "Length dependence of cgdl"), +IOP( "lckappa", B4SOI_MOD_LCKAPPA, IF_REAL, "Length dependence of ckappa"), +IOP( "lndif", B4SOI_MOD_LNDIF, IF_REAL, "Length dependence of ndif"), +IOP( "lute", B4SOI_MOD_LUTE, IF_REAL, "Length dependence of ute"), +IOP( "lkt1", B4SOI_MOD_LKT1, IF_REAL, "Length dependence of kt1"), +IOP( "lkt1l", B4SOI_MOD_LKT1L, IF_REAL, "Length dependence of kt1l"), +IOP( "lkt2", B4SOI_MOD_LKT2, IF_REAL, "Length dependence of kt2"), +IOP( "lua1", B4SOI_MOD_LUA1, IF_REAL, "Length dependence of ua1"), +IOP( "lub1", B4SOI_MOD_LUB1, IF_REAL, "Length dependence of ub1"), +IOP( "luc1", B4SOI_MOD_LUC1, IF_REAL, "Length dependence of uc1"), +IOP( "lat", B4SOI_MOD_LAT, IF_REAL, "Length dependence of at"), +IOP( "lprt", B4SOI_MOD_LPRT, IF_REAL, "Length dependence of prt "), +IOP( "lntrecf", B4SOI_MOD_LNTRECF, IF_REAL, "Length dependence of ntrecf"), +IOP( "lntrecr", B4SOI_MOD_LNTRECR, IF_REAL, "Length dependence of ntrecr"), +IOP( "lxbjt", B4SOI_MOD_LXBJT, IF_REAL, "Length dependence of xbjt"), +IOP( "lxdif", B4SOI_MOD_LXDIFS, IF_REAL, "Length dependence of xdif"), +IOP( "lxrec", B4SOI_MOD_LXRECS, IF_REAL, "Length dependence of xrec"), +IOP( "lxtun", B4SOI_MOD_LXTUNS, IF_REAL, "Length dependence of xtun"), +IOP( "lxdifd", B4SOI_MOD_LXDIFD, IF_REAL, "Length dependence of xdifd"), +IOP( "lxrecd", B4SOI_MOD_LXRECD, IF_REAL, "Length dependence of xrecd"), +IOP( "lxtund", B4SOI_MOD_LXTUND, IF_REAL, "Length dependence of xtund"), + +/* v3.0 */ +IOP( "laigc", B4SOI_MOD_LAIGC, IF_REAL, "Length dependence of aigc"), +IOP( "lbigc", B4SOI_MOD_LBIGC, IF_REAL, "Length dependence of bigc"), +IOP( "lcigc", B4SOI_MOD_LCIGC, IF_REAL, "Length dependence of cigc"), +IOP( "laigsd", B4SOI_MOD_LAIGSD, IF_REAL, "Length dependence of aigsd"), +IOP( "lbigsd", B4SOI_MOD_LBIGSD, IF_REAL, "Length dependence of bigsd"), +IOP( "lcigsd", B4SOI_MOD_LCIGSD, IF_REAL, "Length dependence of cigsd"), +IOP( "lnigc", B4SOI_MOD_LNIGC, IF_REAL, "Length dependence of nigc"), +IOP( "lpigcd", B4SOI_MOD_LPIGCD, IF_REAL, "Length dependence for pigcd"), +IOP( "lpoxedge", B4SOI_MOD_LPOXEDGE, IF_REAL, "Length dependence for poxedge"), + +IOP( "lnch", B4SOI_MOD_LNPEAK, IF_REAL, "Length dependence of nch"), +IOP( "lnsub", B4SOI_MOD_LNSUB, IF_REAL, "Length dependence of nsub"), +IOP( "lngate", B4SOI_MOD_LNGATE, IF_REAL, "Length dependence of ngate"), +IOP( "lvth0", B4SOI_MOD_LVTH0, IF_REAL,"Length dependence of vto"), +IOP( "lk1", B4SOI_MOD_LK1, IF_REAL, "Length dependence of k1"), +IOP( "lk1w1", B4SOI_MOD_LK1W1, IF_REAL, "Length dependence of k1w1"), +IOP( "lk1w2", B4SOI_MOD_LK1W2, IF_REAL, "Length dependence of k1w2"), +IOP( "lk2", B4SOI_MOD_LK2, IF_REAL, "Length dependence of k2"), +IOP( "lk3", B4SOI_MOD_LK3, IF_REAL, "Length dependence of k3"), +IOP( "lk3b", B4SOI_MOD_LK3B, IF_REAL, "Length dependence of k3b"), +IOP( "lkb1", B4SOI_MOD_LKB1, IF_REAL, "Length dependence of kb1"), +IOP( "lw0", B4SOI_MOD_LW0, IF_REAL, "Length dependence of w0"), +IOP( "llpe0", B4SOI_MOD_LLPE0, IF_REAL, "Length dependence of lpe0"), +IOP( "llpeb", B4SOI_MOD_LLPEB, IF_REAL, "Length dependence of lpeb"), +IOP( "ldvt0", B4SOI_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"), +IOP( "ldvt1", B4SOI_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"), +IOP( "ldvt2", B4SOI_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"), +IOP( "ldvt0w", B4SOI_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"), +IOP( "ldvt1w", B4SOI_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"), +IOP( "ldvt2w", B4SOI_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"), +IOP( "lu0", B4SOI_MOD_LU0, IF_REAL, "Length dependence of u0"), +IOP( "lua", B4SOI_MOD_LUA, IF_REAL, "Length dependence of ua"), +IOP( "lub", B4SOI_MOD_LUB, IF_REAL, "Length dependence of ub"), +IOP( "luc", B4SOI_MOD_LUC, IF_REAL, "Length dependence of uc"), +IOP( "lvsat", B4SOI_MOD_LVSAT, IF_REAL, "Length dependence of vsat"), +IOP( "la0", B4SOI_MOD_LA0, IF_REAL, "Length dependence of a0"), +IOP( "lags", B4SOI_MOD_LAGS, IF_REAL, "Length dependence of ags"), +IOP( "lb0", B4SOI_MOD_LB0, IF_REAL, "Length dependence of b0"), +IOP( "lb1", B4SOI_MOD_LB1, IF_REAL, "Length dependence of b1"), +IOP( "lketa", B4SOI_MOD_LKETA, IF_REAL, "Length dependence of keta"), +IOP( "lketas", B4SOI_MOD_LKETAS, IF_REAL, "Length dependence of ketas"), +IOP( "la1", B4SOI_MOD_LA1, IF_REAL, "Length dependence of a1"), +IOP( "la2", B4SOI_MOD_LA2, IF_REAL, "Length dependence of a2"), +IOP( "lrdsw", B4SOI_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "), +IOP( "lrsw", B4SOI_MOD_LRSW, IF_REAL, "Length dependence of rsw"), /* v4.0 */ +IOP( "lrdw", B4SOI_MOD_LRDW, IF_REAL, "Length dependence of rdw"), /* v4.0 */ +IOP( "lprwb", B4SOI_MOD_LPRWB, IF_REAL, "Length dependence of prwb "), +IOP( "lprwg", B4SOI_MOD_LPRWG, IF_REAL, "Length dependence of prwg "), +IOP( "lwr", B4SOI_MOD_LWR, IF_REAL, "Length dependence of wr"), +IOP( "lnfactor", B4SOI_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"), +IOP( "ldwg", B4SOI_MOD_LDWG, IF_REAL, "Length dependence of dwg"), +IOP( "ldwb", B4SOI_MOD_LDWB, IF_REAL, "Length dependence of dwb"), +IOP( "lvoff", B4SOI_MOD_LVOFF, IF_REAL, "Length dependence of voff"), +IOP( "leta0", B4SOI_MOD_LETA0, IF_REAL, "Length dependence of eta0"), +IOP( "letab", B4SOI_MOD_LETAB, IF_REAL, "Length dependence of etab"), +IOP( "ldsub", B4SOI_MOD_LDSUB, IF_REAL, "Length dependence of dsub"), +IOP( "lcit", B4SOI_MOD_LCIT, IF_REAL, "Length dependence of cit"), +IOP( "lcdsc", B4SOI_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"), +IOP( "lcdscb", B4SOI_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"), +IOP( "lcdscd", B4SOI_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"), +IOP( "lpclm", B4SOI_MOD_LPCLM, IF_REAL, "Length dependence of pclm"), +IOP( "lpdiblc1", B4SOI_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"), +IOP( "lpdiblc2", B4SOI_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"), +IOP( "lpdiblcb", B4SOI_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"), +IOP( "ldrout", B4SOI_MOD_LDROUT, IF_REAL, "Length dependence of drout"), +IOP( "lpvag", B4SOI_MOD_LPVAG, IF_REAL, "Length dependence of pvag"), +IOP( "ldelta", B4SOI_MOD_LDELTA, IF_REAL, "Length dependence of delta"), +IOP( "lalpha0", B4SOI_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"), +IOP( "lfbjtii", B4SOI_MOD_LFBJTII, IF_REAL, "Length dependence of fbjtii"), +IOP( "lbeta0", B4SOI_MOD_LBETA0, IF_REAL, "Length dependence of beta0"), +IOP( "lbeta1", B4SOI_MOD_LBETA1, IF_REAL, "Length dependence of beta1"), +IOP( "lbeta2", B4SOI_MOD_LBETA2, IF_REAL, "Length dependence of beta2"), +IOP( "lvdsatii0", B4SOI_MOD_LVDSATII0, IF_REAL, "Length dependence of vdsatii0"), +IOP( "llii", B4SOI_MOD_LLII, IF_REAL, "Length dependence of lii"), +IOP( "lesatii", B4SOI_MOD_LESATII, IF_REAL, "Length dependence of esatii"), +IOP( "lsii0", B4SOI_MOD_LSII0, IF_REAL, "Length dependence of sii0"), +IOP( "lsii1", B4SOI_MOD_LSII1, IF_REAL, "Length dependence of sii1"), +IOP( "lsii2", B4SOI_MOD_LSII2, IF_REAL, "Length dependence of sii2"), +IOP( "lsiid", B4SOI_MOD_LSIID, IF_REAL, "Length dependence of siid"), +IOP( "lagidl", B4SOI_MOD_LAGIDL, IF_REAL, "Length dependence of agidl"), +IOP( "lbgidl", B4SOI_MOD_LBGIDL, IF_REAL, "Length dependence of bgidl"), +IOP( "lcgidl", B4SOI_MOD_LCGIDL, IF_REAL, "Length dependence of cgidl"), +IOP( "legidl", B4SOI_MOD_LEGIDL, IF_REAL, "Length dependence of egidl"), +IOP( "lntun", B4SOI_MOD_LNTUNS, IF_REAL, "Length dependence of ntun"), +IOP( "lntund", B4SOI_MOD_LNTUND, IF_REAL, "Length dependence of ntund"), +IOP( "lndiode", B4SOI_MOD_LNDIODES, IF_REAL, "Length dependence of ndiode"), +IOP( "lndioded", B4SOI_MOD_LNDIODED, IF_REAL, "Length dependence of ndioded"), +IOP( "lnrecf0", B4SOI_MOD_LNRECF0S, IF_REAL, "Length dependence of nrecf0"), +IOP( "lnrecf0d", B4SOI_MOD_LNRECF0D, IF_REAL, "Length dependence of nrecf0d"), +IOP( "lnrecr0", B4SOI_MOD_LNRECR0S, IF_REAL, "Length dependence of nrecr0"), +IOP( "lnrecr0d", B4SOI_MOD_LNRECR0D, IF_REAL, "Length dependence of nrecr0d"), +IOP( "lisbjt", B4SOI_MOD_LISBJT, IF_REAL, "Length dependence of isbjt"), +IOP( "lidbjt", B4SOI_MOD_LIDBJT, IF_REAL, "Length dependence of idbjt"), +IOP( "lisdif", B4SOI_MOD_LISDIF, IF_REAL, "Length dependence of isdif"), +IOP( "liddif", B4SOI_MOD_LIDDIF, IF_REAL, "Length dependence of iddif"), +IOP( "lisrec", B4SOI_MOD_LISREC, IF_REAL, "Length dependence of isrec"), +IOP( "lidrec", B4SOI_MOD_LIDREC, IF_REAL, "Length dependence of idrec"), +IOP( "listun", B4SOI_MOD_LISTUN, IF_REAL, "Length dependence of istun"), +IOP( "lidtun", B4SOI_MOD_LIDTUN, IF_REAL, "Length dependence of idtun"), +IOP( "lvrec0", B4SOI_MOD_LVREC0S, IF_REAL, "Length dependence of vrec0"), +IOP( "lvrec0d", B4SOI_MOD_LVREC0D, IF_REAL, "Length dependence of vrec0d"), +IOP( "lvtun0", B4SOI_MOD_LVTUN0S, IF_REAL, "Length dependence of vtun0"), +IOP( "lvtun0d", B4SOI_MOD_LVTUN0D, IF_REAL, "Length dependence of vtun0d"), +IOP( "lnbjt", B4SOI_MOD_LNBJT, IF_REAL, "Length dependence of nbjt"), +IOP( "llbjt0", B4SOI_MOD_LLBJT0, IF_REAL, "Length dependence of lbjt0"), +IOP( "lvabjt", B4SOI_MOD_LVABJT, IF_REAL, "Length dependence of vabjt"), +IOP( "laely", B4SOI_MOD_LAELY, IF_REAL, "Length dependence of aely"), +IOP( "lahli", B4SOI_MOD_LAHLIS, IF_REAL, "Length dependence of ahli"),/*v4.0*/ +IOP( "lahlid", B4SOI_MOD_LAHLID, IF_REAL, "Length dependence of ahlid"),/*v4.0*/ +IOP( "lvsdfb", B4SOI_MOD_LVSDFB, IF_REAL, "Length dependence of vsdfb"), +IOP( "lvsdth", B4SOI_MOD_LVSDTH, IF_REAL, "Length dependence of vsdth"), +IOP( "ldelvt", B4SOI_MOD_LDELVT, IF_REAL, "Length dependence of delvt"), +IOP( "lacde", B4SOI_MOD_LACDE, IF_REAL, "Length dependence of acde"), +IOP( "lmoin", B4SOI_MOD_LMOIN, IF_REAL, "Length dependence of amoin"), +IOP( "lnoff", B4SOI_MOD_LNOFF, IF_REAL, "Length dependence of noff"), /* v3.2 */ + +/* v3.1 added for RF */ +IOP("lxrcrg1", B4SOI_MOD_LXRCRG1, IF_REAL, "Length dependence of xrcrg1"), +IOP("lxrcrg2", B4SOI_MOD_LXRCRG2, IF_REAL, "Length dependence of xrcrg2"), +/* v3.1 added for RF end*/ + +/* Width Dependence */ +/* v3.1 */ +IOP( "wxj", B4SOI_MOD_WXJ, IF_REAL, "Width dependence of xj"), +IOP( "walphagb1", B4SOI_MOD_WALPHAGB1, IF_REAL, "Width dependence of alphagb1"), +IOP( "wbetagb1", B4SOI_MOD_WBETAGB1, IF_REAL, "Width dependence of betagb1"), +IOP( "walphagb2", B4SOI_MOD_WALPHAGB2, IF_REAL, "Width dependence of alphagb2"), +IOP( "wbetagb2", B4SOI_MOD_WBETAGB2, IF_REAL, "Width dependence of betagb2"), +IOP( "wcgsl", B4SOI_MOD_WCGSL, IF_REAL, "Width dependence of cgsl"), +IOP( "wcgdl", B4SOI_MOD_WCGDL, IF_REAL, "Width dependence of cgdl"), +IOP( "wckappa", B4SOI_MOD_WCKAPPA, IF_REAL, "Width dependence of ckappa"), +IOP( "wndif", B4SOI_MOD_WNDIF, IF_REAL, "Width dependence of ndif"), +IOP( "wute", B4SOI_MOD_WUTE, IF_REAL, "Width dependence of ute"), +IOP( "wkt1", B4SOI_MOD_WKT1, IF_REAL, "Width dependence of kt1"), +IOP( "wkt1l", B4SOI_MOD_WKT1L, IF_REAL, "Width dependence of kt1l"), +IOP( "wkt2", B4SOI_MOD_WKT2, IF_REAL, "Width dependence of kt2"), +IOP( "wua1", B4SOI_MOD_WUA1, IF_REAL, "Width dependence of ua1"), +IOP( "wub1", B4SOI_MOD_WUB1, IF_REAL, "Width dependence of ub1"), +IOP( "wuc1", B4SOI_MOD_WUC1, IF_REAL, "Width dependence of uc1"), +IOP( "wat", B4SOI_MOD_WAT, IF_REAL, "Width dependence of at"), +IOP( "wprt", B4SOI_MOD_WPRT, IF_REAL, "Width dependence of prt "), +IOP( "wntrecf", B4SOI_MOD_WNTRECF, IF_REAL, "Width dependence of ntrecf"), +IOP( "wntrecr", B4SOI_MOD_WNTRECR, IF_REAL, "Width dependence of ntrecr"), +IOP( "wxbjt", B4SOI_MOD_WXBJT, IF_REAL, "Width dependence of xbjt"), +IOP( "wxdif", B4SOI_MOD_WXDIFS, IF_REAL, "Width dependence of xdif"), +IOP( "wxrec", B4SOI_MOD_WXRECS, IF_REAL, "Width dependence of xrec"), +IOP( "wxtun", B4SOI_MOD_WXTUNS, IF_REAL, "Width dependence of xtun"), +IOP( "wxdifd", B4SOI_MOD_WXDIFD, IF_REAL, "Width dependence of xdifd"), +IOP( "wxrecd", B4SOI_MOD_WXRECD, IF_REAL, "Width dependence of xrecd"), +IOP( "wxtund", B4SOI_MOD_WXTUND, IF_REAL, "Width dependence of xtund"), + +/* v3.0 */ +IOP( "waigc", B4SOI_MOD_WAIGC, IF_REAL, "Width dependence of aigc"), +IOP( "wbigc", B4SOI_MOD_WBIGC, IF_REAL, "Width dependence of bigc"), +IOP( "wcigc", B4SOI_MOD_WCIGC, IF_REAL, "Width dependence of cigc"), +IOP( "waigsd", B4SOI_MOD_WAIGSD, IF_REAL, "Width dependence of aigsd"), +IOP( "wbigsd", B4SOI_MOD_WBIGSD, IF_REAL, "Width dependence of bigsd"), +IOP( "wcigsd", B4SOI_MOD_WCIGSD, IF_REAL, "Width dependence of cigsd"), +IOP( "wnigc", B4SOI_MOD_WNIGC, IF_REAL, "Width dependence of nigc"), +IOP( "wpigcd", B4SOI_MOD_WPIGCD, IF_REAL, "Width dependence for pigcd"), +IOP( "wpoxedge", B4SOI_MOD_WPOXEDGE, IF_REAL, "Width dependence for poxedge"), + +IOP( "wnch", B4SOI_MOD_WNPEAK, IF_REAL, "Width dependence of nch"), +IOP( "wnsub", B4SOI_MOD_WNSUB, IF_REAL, "Width dependence of nsub"), +IOP( "wngate", B4SOI_MOD_WNGATE, IF_REAL, "Width dependence of ngate"), +IOP( "wvth0", B4SOI_MOD_WVTH0, IF_REAL,"Width dependence of vto"), +IOP( "wk1", B4SOI_MOD_WK1, IF_REAL, "Width dependence of k1"), +IOP( "wk1w1", B4SOI_MOD_WK1W1, IF_REAL, "Width dependence of k1w1"), +IOP( "wk1w2", B4SOI_MOD_WK1W2, IF_REAL, "Width dependence of k1w2"), +IOP( "wk2", B4SOI_MOD_WK2, IF_REAL, "Width dependence of k2"), +IOP( "wk3", B4SOI_MOD_WK3, IF_REAL, "Width dependence of k3"), +IOP( "wk3b", B4SOI_MOD_WK3B, IF_REAL, "Width dependence of k3b"), +IOP( "wkb1", B4SOI_MOD_WKB1, IF_REAL, "Width dependence of kb1"), +IOP( "ww0", B4SOI_MOD_WW0, IF_REAL, "Width dependence of w0"), +IOP( "wlpe0", B4SOI_MOD_WLPE0, IF_REAL, "Width dependence of lpe0"), +IOP( "wlpeb", B4SOI_MOD_WLPEB, IF_REAL, "Width dependence of lpeb"), +IOP( "wdvt0", B4SOI_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"), +IOP( "wdvt1", B4SOI_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"), +IOP( "wdvt2", B4SOI_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"), +IOP( "wdvt0w", B4SOI_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"), +IOP( "wdvt1w", B4SOI_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"), +IOP( "wdvt2w", B4SOI_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"), +IOP( "wu0", B4SOI_MOD_WU0, IF_REAL, "Width dependence of u0"), +IOP( "wua", B4SOI_MOD_WUA, IF_REAL, "Width dependence of ua"), +IOP( "wub", B4SOI_MOD_WUB, IF_REAL, "Width dependence of ub"), +IOP( "wuc", B4SOI_MOD_WUC, IF_REAL, "Width dependence of uc"), +IOP( "wvsat", B4SOI_MOD_WVSAT, IF_REAL, "Width dependence of vsat"), +IOP( "wa0", B4SOI_MOD_WA0, IF_REAL, "Width dependence of a0"), +IOP( "wags", B4SOI_MOD_WAGS, IF_REAL, "Width dependence of ags"), +IOP( "wb0", B4SOI_MOD_WB0, IF_REAL, "Width dependence of b0"), +IOP( "wb1", B4SOI_MOD_WB1, IF_REAL, "Width dependence of b1"), +IOP( "wketa", B4SOI_MOD_WKETA, IF_REAL, "Width dependence of keta"), +IOP( "wketas", B4SOI_MOD_WKETAS, IF_REAL, "Width dependence of ketas"), +IOP( "wa1", B4SOI_MOD_WA1, IF_REAL, "Width dependence of a1"), +IOP( "wa2", B4SOI_MOD_WA2, IF_REAL, "Width dependence of a2"), +IOP( "wrdsw", B4SOI_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "), +IOP( "wrsw", B4SOI_MOD_WRSW, IF_REAL, "Width dependence of rsw"), /* v4.0 */ +IOP( "wrdw", B4SOI_MOD_WRDW, IF_REAL, "Width dependence of rdw"), /* v4.0 */ +IOP( "wprwb", B4SOI_MOD_WPRWB, IF_REAL, "Width dependence of prwb "), +IOP( "wprwg", B4SOI_MOD_WPRWG, IF_REAL, "Width dependence of prwg "), +IOP( "wwr", B4SOI_MOD_WWR, IF_REAL, "Width dependence of wr"), +IOP( "wnfactor", B4SOI_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"), +IOP( "wdwg", B4SOI_MOD_WDWG, IF_REAL, "Width dependence of dwg"), +IOP( "wdwb", B4SOI_MOD_WDWB, IF_REAL, "Width dependence of dwb"), +IOP( "wvoff", B4SOI_MOD_WVOFF, IF_REAL, "Width dependence of voff"), +IOP( "weta0", B4SOI_MOD_WETA0, IF_REAL, "Width dependence of eta0"), +IOP( "wetab", B4SOI_MOD_WETAB, IF_REAL, "Width dependence of etab"), +IOP( "wdsub", B4SOI_MOD_WDSUB, IF_REAL, "Width dependence of dsub"), +IOP( "wcit", B4SOI_MOD_WCIT, IF_REAL, "Width dependence of cit"), +IOP( "wcdsc", B4SOI_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"), +IOP( "wcdscb", B4SOI_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"), +IOP( "wcdscd", B4SOI_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"), +IOP( "wpclm", B4SOI_MOD_WPCLM, IF_REAL, "Width dependence of pclm"), +IOP( "wpdiblc1", B4SOI_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"), +IOP( "wpdiblc2", B4SOI_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"), +IOP( "wpdiblcb", B4SOI_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"), +IOP( "wdrout", B4SOI_MOD_WDROUT, IF_REAL, "Width dependence of drout"), +IOP( "wpvag", B4SOI_MOD_WPVAG, IF_REAL, "Width dependence of pvag"), +IOP( "wdelta", B4SOI_MOD_WDELTA, IF_REAL, "Width dependence of delta"), +IOP( "walpha0", B4SOI_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"), +IOP( "wfbjtii", B4SOI_MOD_WFBJTII, IF_REAL, "Width dependence of fbjtii"), +IOP( "wbeta0", B4SOI_MOD_WBETA0, IF_REAL, "Width dependence of beta0"), +IOP( "wbeta1", B4SOI_MOD_WBETA1, IF_REAL, "Width dependence of beta1"), +IOP( "wbeta2", B4SOI_MOD_WBETA2, IF_REAL, "Width dependence of beta2"), +IOP( "wvdsatii0", B4SOI_MOD_WVDSATII0, IF_REAL, "Width dependence of vdsatii0"), +IOP( "wlii", B4SOI_MOD_WLII, IF_REAL, "Width dependence of lii"), +IOP( "wesatii", B4SOI_MOD_WESATII, IF_REAL, "Width dependence of esatii"), +IOP( "wsii0", B4SOI_MOD_WSII0, IF_REAL, "Width dependence of sii0"), +IOP( "wsii1", B4SOI_MOD_WSII1, IF_REAL, "Width dependence of sii1"), +IOP( "wsii2", B4SOI_MOD_WSII2, IF_REAL, "Width dependence of sii2"), +IOP( "wsiid", B4SOI_MOD_WSIID, IF_REAL, "Width dependence of siid"), +IOP( "wagidl", B4SOI_MOD_WAGIDL, IF_REAL, "Width dependence of agidl"), +IOP( "wbgidl", B4SOI_MOD_WBGIDL, IF_REAL, "Width dependence of bgidl"), +IOP( "wcgidl", B4SOI_MOD_WCGIDL, IF_REAL, "Width dependence of cgidl"), +IOP( "wegidl", B4SOI_MOD_WEGIDL, IF_REAL, "Width dependence of egidl"), +IOP( "wntun", B4SOI_MOD_WNTUNS, IF_REAL, "Width dependence of ntun"), +IOP( "wntund", B4SOI_MOD_WNTUND, IF_REAL, "Width dependence of ntund"), +IOP( "wndiode", B4SOI_MOD_WNDIODES, IF_REAL, "Width dependence of ndiode"), +IOP( "wndioded", B4SOI_MOD_WNDIODED, IF_REAL, "Width dependence of ndioded"), +IOP( "wnrecf0", B4SOI_MOD_WNRECF0S, IF_REAL, "Width dependence of nrecf0"), +IOP( "wnrecf0d", B4SOI_MOD_WNRECF0D, IF_REAL, "Width dependence of nrecf0d"), +IOP( "wnrecr0", B4SOI_MOD_WNRECR0S, IF_REAL, "Width dependence of nrecr0"), +IOP( "wnrecr0d", B4SOI_MOD_WNRECR0D, IF_REAL, "Width dependence of nrecr0d"), +IOP( "wisbjt", B4SOI_MOD_WISBJT, IF_REAL, "Width dependence of isbjt"), +IOP( "widbjt", B4SOI_MOD_WIDBJT, IF_REAL, "Width dependence of idbjt"), +IOP( "wisdif", B4SOI_MOD_WISDIF, IF_REAL, "Width dependence of isdif"), +IOP( "widdif", B4SOI_MOD_WIDDIF, IF_REAL, "Width dependence of iddif"), +IOP( "wisrec", B4SOI_MOD_WISREC, IF_REAL, "Width dependence of isrec"), +IOP( "widrec", B4SOI_MOD_WIDREC, IF_REAL, "Width dependence of idrec"), +IOP( "wistun", B4SOI_MOD_WISTUN, IF_REAL, "Width dependence of istun"), +IOP( "widtun", B4SOI_MOD_WIDTUN, IF_REAL, "Width dependence of idtun"), +IOP( "wvrec0", B4SOI_MOD_WVREC0S, IF_REAL, "Width dependence of vrec0"), +IOP( "wvrec0d", B4SOI_MOD_WVREC0D, IF_REAL, "Width dependence of vrec0d"), +IOP( "wvtun0", B4SOI_MOD_WVTUN0S, IF_REAL, "Width dependence of vtun0"), +IOP( "wvtun0d", B4SOI_MOD_WVTUN0D, IF_REAL, "Width dependence of vtun0d"), +IOP( "wnbjt", B4SOI_MOD_WNBJT, IF_REAL, "Width dependence of nbjt"), +IOP( "wlbjt0", B4SOI_MOD_WLBJT0, IF_REAL, "Width dependence of lbjt0"), +IOP( "wvabjt", B4SOI_MOD_WVABJT, IF_REAL, "Width dependence of vabjt"), +IOP( "waely", B4SOI_MOD_WAELY, IF_REAL, "Width dependence of aely"), +IOP( "wahli", B4SOI_MOD_WAHLIS,IF_REAL, "Width dependence of ahli"),/* v4.0 */ +IOP( "wahlid", B4SOI_MOD_WAHLID,IF_REAL, "Width dependence of ahlid"),/* v4.0 */ +IOP( "wvsdfb", B4SOI_MOD_WVSDFB, IF_REAL, "Width dependence of vsdfb"), +IOP( "wvsdth", B4SOI_MOD_WVSDTH, IF_REAL, "Width dependence of vsdth"), +IOP( "wdelvt", B4SOI_MOD_WDELVT, IF_REAL, "Width dependence of delvt"), +IOP( "wacde", B4SOI_MOD_WACDE, IF_REAL, "Width dependence of acde"), +IOP( "wmoin", B4SOI_MOD_WMOIN, IF_REAL, "Width dependence of amoin"), +IOP( "wnoff", B4SOI_MOD_WNOFF, IF_REAL, "Width dependence of noff"), /* v3.2 */ + +/* v3.1 added for RF */ +IOP("wxrcrg1", B4SOI_MOD_WXRCRG1, IF_REAL, "Width dependence of xrcrg1"), +IOP("Wxrcrg2", B4SOI_MOD_WXRCRG2, IF_REAL, "Width dependence of xrcrg2"), +/* added for RF model end*/ + + +/* Cross-term Dependence */ +/* v3.1 */ +IOP( "pxj", B4SOI_MOD_PXJ, IF_REAL, "Cross-term dependence of xj"), +IOP( "palphagb1", B4SOI_MOD_PALPHAGB1, IF_REAL, "Cross-term dependence of alphagb1"), +IOP( "pbetagb1", B4SOI_MOD_PBETAGB1, IF_REAL, "Cross-term dependence of betagb1"), +IOP( "palphagb2", B4SOI_MOD_PALPHAGB2, IF_REAL, "Cross-term dependence of alphagb2"), +IOP( "pbetagb2", B4SOI_MOD_PBETAGB2, IF_REAL, "Cross-term dependence of betagb2"), +IOP( "pcgsl", B4SOI_MOD_PCGSL, IF_REAL, "Cross-term dependence of cgsl"), +IOP( "pcgdl", B4SOI_MOD_PCGDL, IF_REAL, "Cross-term dependence of cgdl"), +IOP( "pckappa", B4SOI_MOD_PCKAPPA, IF_REAL, "Cross-term dependence of ckappa"), +IOP( "pndif", B4SOI_MOD_PNDIF, IF_REAL, "Cross-term dependence of ndif"), +IOP( "pute", B4SOI_MOD_PUTE, IF_REAL, "Cross-term dependence of ute"), +IOP( "pkt1", B4SOI_MOD_PKT1, IF_REAL, "Cross-term dependence of kt1"), +IOP( "pkt1l", B4SOI_MOD_PKT1L, IF_REAL, "Cross-term dependence of kt1l"), +IOP( "pkt2", B4SOI_MOD_PKT2, IF_REAL, "Cross-term dependence of kt2"), +IOP( "pua1", B4SOI_MOD_PUA1, IF_REAL, "Cross-term dependence of ua1"), +IOP( "pub1", B4SOI_MOD_PUB1, IF_REAL, "Cross-term dependence of ub1"), +IOP( "puc1", B4SOI_MOD_PUC1, IF_REAL, "Cross-term dependence of uc1"), +IOP( "pat", B4SOI_MOD_PAT, IF_REAL, "Cross-term dependence of at"), +IOP( "pprt", B4SOI_MOD_PPRT, IF_REAL, "Cross-term dependence of prt "), +IOP( "pntrecf", B4SOI_MOD_PNTRECF, IF_REAL, "Cross-term dependence of ntrecf"), +IOP( "pntrecr", B4SOI_MOD_PNTRECR, IF_REAL, "Cross-term dependence of ntrecr"), +IOP( "pxbjt", B4SOI_MOD_PXBJT, IF_REAL, "Cross-term dependence of xbjt"), +IOP( "pxdif", B4SOI_MOD_PXDIFS, IF_REAL, "Cross-term dependence of xdif"), +IOP( "pxrec", B4SOI_MOD_PXRECS, IF_REAL, "Cross-term dependence of xrec"), +IOP( "pxtun", B4SOI_MOD_PXTUNS, IF_REAL, "Cross-term dependence of xtun"), +IOP( "pxdifd", B4SOI_MOD_PXDIFD, IF_REAL, "Cross-term dependence of xdifd"), +IOP( "pxrecd", B4SOI_MOD_PXRECD, IF_REAL, "Cross-term dependence of xrecd"), +IOP( "pxtund", B4SOI_MOD_PXTUND, IF_REAL, "Cross-term dependence of xtund"), + +/* v3.0 */ +IOP( "paigc", B4SOI_MOD_PAIGC, IF_REAL, "Cross-term dependence of aigc"), +IOP( "pbigc", B4SOI_MOD_PBIGC, IF_REAL, "Cross-term dependence of bigc"), +IOP( "pcigc", B4SOI_MOD_PCIGC, IF_REAL, "Cross-term dependence of cigc"), +IOP( "paigsd", B4SOI_MOD_PAIGSD, IF_REAL, "Cross-term dependence of aigsd"), +IOP( "pbigsd", B4SOI_MOD_PBIGSD, IF_REAL, "Cross-term dependence of bigsd"), +IOP( "pcigsd", B4SOI_MOD_PCIGSD, IF_REAL, "Cross-term dependence of cigsd"), +IOP( "pnigc", B4SOI_MOD_PNIGC, IF_REAL, "Cross-term dependence of nigc"), +IOP( "ppigcd", B4SOI_MOD_PPIGCD, IF_REAL, "Cross-term dependence for pigcd"), +IOP( "ppoxedge", B4SOI_MOD_PPOXEDGE, IF_REAL, "Cross-term dependence for poxedge"), + +IOP( "pnch", B4SOI_MOD_PNPEAK, IF_REAL, "Cross-term dependence of nch"), +IOP( "pnsub", B4SOI_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"), +IOP( "pngate", B4SOI_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"), +IOP( "pvth0", B4SOI_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"), +IOP( "pk1", B4SOI_MOD_PK1, IF_REAL, "Cross-term dependence of k1"), +IOP( "pk1w1", B4SOI_MOD_PK1W1, IF_REAL, "Cross-term dependence of k1w1"), +IOP( "pk1w2", B4SOI_MOD_PK1W2, IF_REAL, "Cross-term dependence of k1w2"), +IOP( "pk2", B4SOI_MOD_PK2, IF_REAL, "Cross-term dependence of k2"), +IOP( "pk3", B4SOI_MOD_PK3, IF_REAL, "Cross-term dependence of k3"), +IOP( "pk3b", B4SOI_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"), +IOP( "pkb1", B4SOI_MOD_PKB1, IF_REAL, "Cross-term dependence of kb1"), +IOP( "pw0", B4SOI_MOD_PW0, IF_REAL, "Cross-term dependence of w0"), +IOP( "plpe0", B4SOI_MOD_PLPE0, IF_REAL, "Cross-term dependence of lpe0"), +IOP( "plpeb", B4SOI_MOD_PLPEB, IF_REAL, "Cross-term dependence of lpeb"), +IOP( "pdvt0", B4SOI_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"), +IOP( "pdvt1", B4SOI_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"), +IOP( "pdvt2", B4SOI_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"), +IOP( "pdvt0w", B4SOI_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"), +IOP( "pdvt1w", B4SOI_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"), +IOP( "pdvt2w", B4SOI_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"), +IOP( "pu0", B4SOI_MOD_PU0, IF_REAL, "Cross-term dependence of u0"), +IOP( "pua", B4SOI_MOD_PUA, IF_REAL, "Cross-term dependence of ua"), +IOP( "pub", B4SOI_MOD_PUB, IF_REAL, "Cross-term dependence of ub"), +IOP( "puc", B4SOI_MOD_PUC, IF_REAL, "Cross-term dependence of uc"), +IOP( "pvsat", B4SOI_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"), +IOP( "pa0", B4SOI_MOD_PA0, IF_REAL, "Cross-term dependence of a0"), +IOP( "pags", B4SOI_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"), +IOP( "pb0", B4SOI_MOD_PB0, IF_REAL, "Cross-term dependence of b0"), +IOP( "pb1", B4SOI_MOD_PB1, IF_REAL, "Cross-term dependence of b1"), +IOP( "pketa", B4SOI_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"), +IOP( "pketas", B4SOI_MOD_PKETAS, IF_REAL, "Cross-term dependence of ketas"), +IOP( "pa1", B4SOI_MOD_PA1, IF_REAL, "Cross-term dependence of a1"), +IOP( "pa2", B4SOI_MOD_PA2, IF_REAL, "Cross-term dependence of a2"), +IOP( "prdsw", B4SOI_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "), +IOP( "prsw", B4SOI_MOD_PRSW, IF_REAL, "Cross-term dependence of rsw "),/*v4.0*/ +IOP( "prdw", B4SOI_MOD_PRDW, IF_REAL, "Cross-term dependence of rdw "),/*v4.0*/ +IOP( "pprwb", B4SOI_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "), +IOP( "pprwg", B4SOI_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "), +IOP( "pwr", B4SOI_MOD_PWR, IF_REAL, "Cross-term dependence of wr"), +IOP( "pnfactor", B4SOI_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"), +IOP( "pdwg", B4SOI_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"), +IOP( "pdwb", B4SOI_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"), +IOP( "pvoff", B4SOI_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"), +IOP( "peta0", B4SOI_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"), +IOP( "petab", B4SOI_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"), +IOP( "pdsub", B4SOI_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"), +IOP( "pcit", B4SOI_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"), +IOP( "pcdsc", B4SOI_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"), +IOP( "pcdscb", B4SOI_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"), +IOP( "pcdscd", B4SOI_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"), +IOP( "ppclm", B4SOI_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"), +IOP( "ppdiblc1", B4SOI_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"), +IOP( "ppdiblc2", B4SOI_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"), +IOP( "ppdiblcb", B4SOI_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"), +IOP( "pdrout", B4SOI_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"), +IOP( "ppvag", B4SOI_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"), +IOP( "pdelta", B4SOI_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"), +IOP( "palpha0", B4SOI_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"), +IOP( "pfbjtii", B4SOI_MOD_PFBJTII, IF_REAL, "Cross-term dependence of fbjtii"), +IOP( "pbeta0", B4SOI_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"), +IOP( "pbeta1", B4SOI_MOD_PBETA1, IF_REAL, "Cross-term dependence of beta1"), +IOP( "pbeta2", B4SOI_MOD_PBETA2, IF_REAL, "Cross-term dependence of beta2"), +IOP( "pvdsatii0", B4SOI_MOD_PVDSATII0, IF_REAL, "Cross-term dependence of vdsatii0"), +IOP( "plii", B4SOI_MOD_PLII, IF_REAL, "Cross-term dependence of lii"), +IOP( "pesatii", B4SOI_MOD_PESATII, IF_REAL, "Cross-term dependence of esatii"), +IOP( "psii0", B4SOI_MOD_PSII0, IF_REAL, "Cross-term dependence of sii0"), +IOP( "psii1", B4SOI_MOD_PSII1, IF_REAL, "Cross-term dependence of sii1"), +IOP( "psii2", B4SOI_MOD_PSII2, IF_REAL, "Cross-term dependence of sii2"), +IOP( "psiid", B4SOI_MOD_PSIID, IF_REAL, "Cross-term dependence of siid"), +IOP( "pagidl", B4SOI_MOD_PAGIDL, IF_REAL, "Cross-term dependence of agidl"), +IOP( "pbgidl", B4SOI_MOD_PBGIDL, IF_REAL, "Cross-term dependence of bgidl"), +IOP( "pcgidl", B4SOI_MOD_PCGIDL, IF_REAL, "Cross-term dependence of cgidl"), +IOP( "pegidl", B4SOI_MOD_PEGIDL, IF_REAL, "Cross-term dependence of egidl"), +IOP( "pntun", B4SOI_MOD_PNTUNS, IF_REAL, "Cross-term dependence of ntun"), +IOP( "pntund", B4SOI_MOD_PNTUND, IF_REAL, "Cross-term dependence of ntund"), +IOP( "pndiode", B4SOI_MOD_PNDIODES, IF_REAL,"Cross-term dependence of ndiode"), +IOP( "pndioded", B4SOI_MOD_PNDIODED, IF_REAL,"Cross-term dependence of ndiode"), +IOP( "pnrecf0", B4SOI_MOD_PNRECF0S, IF_REAL,"Cross-term dependence of nrecf0"), +IOP( "pnrecf0d", B4SOI_MOD_PNRECF0D, IF_REAL,"Cross-term dependence of nrecf0"), +IOP( "pnrecr0", B4SOI_MOD_PNRECR0S, IF_REAL,"Cross-term dependence of nrecr0"), +IOP( "pnrecr0d", B4SOI_MOD_PNRECR0D, IF_REAL,"Cross-term dependence of nrecr0"), +IOP( "pisbjt", B4SOI_MOD_PISBJT, IF_REAL, "Cross-term dependence of isbjt"), +IOP( "pidbjt", B4SOI_MOD_PIDBJT, IF_REAL, "Cross-term dependence of idbjt"), +IOP( "pisdif", B4SOI_MOD_PISDIF, IF_REAL, "Cross-term dependence of isdif"), +IOP( "piddif", B4SOI_MOD_PIDDIF, IF_REAL, "Cross-term dependence of iddif"), +IOP( "pisrec", B4SOI_MOD_PISREC, IF_REAL, "Cross-term dependence of isrec"), +IOP( "pidrec", B4SOI_MOD_PIDREC, IF_REAL, "Cross-term dependence of idrec"), +IOP( "pistun", B4SOI_MOD_PISTUN, IF_REAL, "Cross-term dependence of istun"), +IOP( "pidtun", B4SOI_MOD_PIDTUN, IF_REAL, "Cross-term dependence of idtun"), +IOP( "pvrec0", B4SOI_MOD_PVREC0S, IF_REAL, "Cross-term dependence of vrec0"), +IOP( "pvrec0d", B4SOI_MOD_PVREC0D, IF_REAL, "Cross-term dependence of vrec0d"), +IOP( "pvtun0", B4SOI_MOD_PVTUN0S, IF_REAL, "Cross-term dependence of vtun0"), +IOP( "pvtun0d", B4SOI_MOD_PVTUN0D, IF_REAL, "Cross-term dependence of vtun0d"), +IOP( "pnbjt", B4SOI_MOD_PNBJT, IF_REAL, "Cross-term dependence of nbjt"), +IOP( "plbjt0", B4SOI_MOD_PLBJT0, IF_REAL, "Cross-term dependence of lbjt0"), +IOP( "pvabjt", B4SOI_MOD_PVABJT, IF_REAL, "Cross-term dependence of vabjt"), +IOP( "paely", B4SOI_MOD_PAELY, IF_REAL, "Cross-term dependence of aely"), +IOP( "pahli",B4SOI_MOD_PAHLIS,IF_REAL, "X-term dependence of ahli"),/* v4.0 */ +IOP( "pahlid",B4SOI_MOD_PAHLID,IF_REAL, "X-term dependence of ahlid"),/* v4.0 */ +IOP( "pvsdfb", B4SOI_MOD_PVSDFB, IF_REAL, "Cross-term dependence of vsdfb"), +IOP( "pvsdth", B4SOI_MOD_PVSDTH, IF_REAL, "Cross-term dependence of vsdth"), +IOP( "pdelvt", B4SOI_MOD_PDELVT, IF_REAL, "Cross-term dependence of delvt"), +IOP( "pacde", B4SOI_MOD_PACDE, IF_REAL, "Cross-term dependence of acde"), +IOP( "pmoin", B4SOI_MOD_PMOIN, IF_REAL, "Cross-term dependence of amoin"), +IOP( "pnoff", B4SOI_MOD_PNOFF, IF_REAL, "Cross-term dependence of noff"), /* v3.2 */ + +/* v3.1 added for RF */ +IOP("pxrcrg1", B4SOI_MOD_PXRCRG1, IF_REAL, "Cross-term dependence of xrcrg1"), +IOP("pxrcrg2", B4SOI_MOD_PXRCRG2, IF_REAL, "Cross-term dependence of xrcrg2"), +/* v3.1 added for RF end */ + +/* v4.0 backward compatibility */ +IOP( "nlx", B4SOI_MOD_NLX, IF_REAL, "Lateral non-uniform doping effect"), +IOP( "lnlx", B4SOI_MOD_LNLX, IF_REAL, "Length dependence of nlx"), +IOP( "wnlx", B4SOI_MOD_WNLX, IF_REAL, "Width dependence of nlx"), +IOP( "pnlx", B4SOI_MOD_PNLX, IF_REAL, "Cross-term dependence of nlx"), +IOP( "ngidl", B4SOI_MOD_NGIDL, IF_REAL, "GIDL first parameter"), +IOP( "lngidl", B4SOI_MOD_LNGIDL, IF_REAL, "Length dependence of ngidl"), +IOP( "wngidl", B4SOI_MOD_WNGIDL, IF_REAL, "Width dependence of ngidl"), +IOP( "pngidl", B4SOI_MOD_PNGIDL, IF_REAL, "Cross-term dependence of ngidl"), + +/* Added for binning - END */ + +IP( "nmos", B4SOI_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"), +IP( "pmos", B4SOI_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"), +}; + +char *B4SOInames[] = { + "Drain", + "Gate", + "Source", + "Backgate", + "", + "Body", + "Temp", + "Charge", +}; + +int B4SOInSize = NUMELEMS(B4SOInames); +int B4SOIpTSize = NUMELEMS(B4SOIpTable); +int B4SOImPTSize = NUMELEMS(B4SOImPTable); +int B4SOIiSize = sizeof(B4SOIinstance); +int B4SOImSize = sizeof(B4SOImodel); + + diff --git a/src/spicelib/devices/bsim3soi/b4soiacld.c b/src/spicelib/devices/bsim3soi/b4soiacld.c new file mode 100644 index 000000000..cdeeb9f12 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soiacld.c @@ -0,0 +1,812 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soiacld.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soiacld.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "cktdefs.h" +#include "b4soidef.h" +#include "sperror.h" +#include "suffix.h" + + +int +B4SOIacLoad(GENmodel *inModel, CKTcircuit *ckt) +{ +register B4SOImodel *model = (B4SOImodel*)inModel; +register B4SOIinstance *here; +register int selfheat; +double xcggb, xcgdb, xcgsb, xcgeb, xcgT; +double xcdgb, xcddb, xcdsb, xcdeb, xcdT; +double xcsgb, xcsdb, xcssb, xcseb, xcsT; +double xcbgb, xcbdb, xcbsb, xcbeb, xcbT; +double xcegb, xceeb, xceT; +double gdpr, gspr, gds; +double cggb, cgdb, cgsb, cgT; +double cdgb, cddb, cdsb, cdeb, cdT; +double cbgb, cbdb, cbsb, cbeb, cbT; +double ceeb, ceT; +double GSoverlapCap, GDoverlapCap, GEoverlapCap, FwdSum, RevSum, Gm, Gmbs, GmT; +double omega; +double dxpart, sxpart; +double gbbg, gbbdp, gbbb, gbbp, gbbsp, gbbT; +double gddpg, gddpdp, gddpsp, gddpb, gddpT; +double gsspg, gsspdp, gsspsp, gsspb, gsspT; +double gppb, gppp; +double xcTt, cTt, gTtt, gTtg, gTtb, gTtdp, gTtsp; +double EDextrinsicCap, ESextrinsicCap; +double xcedb, xcesb; + +/* v3.0 */ +double Gme, gddpe, gsspe, gbbe, gTte; + +/* v3.1 added variables for RF */ +double T0; +double gcrgd, gcrgg, gcrgs, gcrgb, gcrg; +double xcgmgmb, xcgmdb, xcgmsb, xcgmeb, xcdgmb, xcsgmb, xcegmb; +double geltd; +double gigg, gigd, gigs, gigb, gige, gigT; + +/* v3.1.1 bug fix */ +double gIstotg, gIstotd, gIstotb, gIstots; +double gIdtotg, gIdtotd, gIdtotb, gIdtots; +double gIgtotg, gIgtotd, gIgtotb, gIgtots; + +/* v4.0 */ +double xcdbb, xcsbb, xcdbdb, xcsbsb, xcjdbdp, xcjsbsp; +double gstot, gstotd, gstotg, gstots, gstotb; +double gdtot, gdtotd, gdtotg, gdtots, gdtotb; + +double m; + + omega = ckt->CKTomega; + for (; model != NULL; model = model->B4SOInextModel) + { + + for (here = model->B4SOIinstances; here!= NULL; + here = here->B4SOInextInstance) + { + if (here->B4SOIowner != ARCHme) + continue; + + selfheat = (model->B4SOIshMod == 1) && (here->B4SOIrth0 != 0.0); + if (here->B4SOImode >= 0) + { Gm = here->B4SOIgm; + Gmbs = here->B4SOIgmbs; + +/* v3.0 */ + Gme = here->B4SOIgme; + + GmT = model->B4SOItype * here->B4SOIgmT; + FwdSum = Gm + Gmbs + Gme; /* v3.0 */ + RevSum = 0.0; + + cbgb = here->B4SOIcbgb; + cbsb = here->B4SOIcbsb; + cbdb = here->B4SOIcbdb; + cbeb = here->B4SOIcbeb; + cbT = model->B4SOItype * here->B4SOIcbT; + + ceeb = here->B4SOIceeb; + ceT = model->B4SOItype * here->B4SOIceT; + + cggb = here->B4SOIcggb; + cgsb = here->B4SOIcgsb; + cgdb = here->B4SOIcgdb; + cgT = model->B4SOItype * here->B4SOIcgT; + + cdgb = here->B4SOIcdgb; + cdsb = here->B4SOIcdsb; + cddb = here->B4SOIcddb; + cdeb = here->B4SOIcdeb; + cdT = model->B4SOItype * here->B4SOIcdT; + + cTt = here->pParam->B4SOIcth; + + +/* v3.1 bug fix */ + gigg = here->B4SOIgigg; + gigb = here->B4SOIgigb; + gige = here->B4SOIgige; + gigs = here->B4SOIgigs; + gigd = here->B4SOIgigd; + gigT = model->B4SOItype * here->B4SOIgigT; + + gbbg = -here->B4SOIgbgs; + gbbdp = -here->B4SOIgbds; + gbbb = -here->B4SOIgbbs; + gbbp = -here->B4SOIgbps; + gbbT = -model->B4SOItype * here->B4SOIgbT; + gbbe = -here->B4SOIgbes; + + if (here->B4SOIrbodyMod) { /* v4.0 */ + gbbdp = -here->B4SOIgiigidld; + gbbb = -here->B4SOIgbgiigbpb; + } + + gbbsp = - ( gbbg + gbbdp + gbbb + gbbp + gbbe); + + gddpg = -here->B4SOIgjdg; + gddpdp = -here->B4SOIgjdd; + if (!here->B4SOIrbodyMod) /* v4.0 */ + gddpb = -here->B4SOIgjdb; + else + gddpb = here->B4SOIgiigidlb; + + gddpT = -model->B4SOItype * here->B4SOIgjdT; + +/* v3.0 */ + gddpe = -here->B4SOIgjde; + gddpsp = - ( gddpg + gddpdp + gddpb + gddpe); + + gsspg = -here->B4SOIgjsg; + gsspdp = -here->B4SOIgjsd; + if (!here->B4SOIrbodyMod) /* v4.0 */ + gsspb = -here->B4SOIgjsb; + else + gsspb = 0.0; + gsspT = -model->B4SOItype * here->B4SOIgjsT; + + gsspe = 0.0; + gsspsp = - (gsspg + gsspdp + gsspb + gsspe); + + gppb = -here->B4SOIgbpbs; + gppp = -here->B4SOIgbpps; + + gTtg = here->B4SOIgtempg; + gTtb = here->B4SOIgtempb; + gTtdp = here->B4SOIgtempd; + gTtt = here->B4SOIgtempT; + +/* v3.0 */ + gTte = here->B4SOIgtempe; + gTtsp = - (gTtg + gTtb + gTtdp + gTte); + + +/* v3.1.1 bug fix */ + if (model->B4SOIigcMod) + { + gIstotg = here->B4SOIgIgsg + here->B4SOIgIgcsg; + gIstotd = here->B4SOIgIgcsd; + gIstots = here->B4SOIgIgss + here->B4SOIgIgcss; + gIstotb = here->B4SOIgIgcsb; + + gIdtotg = here->B4SOIgIgdg + here->B4SOIgIgcdg; + gIdtotd = here->B4SOIgIgdd + here->B4SOIgIgcdd; + gIdtots = here->B4SOIgIgcds; + gIdtotb = here->B4SOIgIgcdb; + + gIgtotg = gIstotg + gIdtotg; + gIgtotd = gIstotd + gIdtotd; + gIgtots = gIstots + gIdtots; + gIgtotb = gIstotb + gIdtotb; + } + else + { + gIstotg = gIstotd = gIstots = gIstotb = 0.0; + gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0; + gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0; + } + + + sxpart = 0.6; + dxpart = 0.4; + + /* v3.1 for RF */ + if (here->B4SOIrgateMod == 2) + T0 = *(ckt->CKTstates[0] + here->B4SOIvges) + - *(ckt->CKTstates[0] + here->B4SOIvgs); + else if (here->B4SOIrgateMod == 3) + T0 = *(ckt->CKTstates[0] + here->B4SOIvgms) + - *(ckt->CKTstates[0] + here->B4SOIvgs); + if (here->B4SOIrgateMod > 1) + { gcrgd = here->B4SOIgcrgd * T0; + gcrgg = here->B4SOIgcrgg * T0; + gcrgs = here->B4SOIgcrgs * T0; + gcrgb = here->B4SOIgcrgb * T0; + gcrgg -= here->B4SOIgcrg; + gcrg = here->B4SOIgcrg; + } + else + gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0; + /* v3.1 for RF end*/ + + } + else + { Gm = -here->B4SOIgm; + Gmbs = -here->B4SOIgmbs; + +/* v3.0 */ + Gme = -here->B4SOIgme; + + GmT = -model->B4SOItype * here->B4SOIgmT; + FwdSum = 0.0; + RevSum = -Gm - Gmbs - Gme; /* v3.0 */ + + cdgb = - (here->B4SOIcdgb + here->B4SOIcggb + here->B4SOIcbgb); + cdsb = - (here->B4SOIcddb + here->B4SOIcgdb + here->B4SOIcbdb); + cddb = - (here->B4SOIcdsb + here->B4SOIcgsb + here->B4SOIcbsb); + cdeb = - (here->B4SOIcdeb + here->B4SOIcbeb + here->B4SOIceeb); + cdT = - model->B4SOItype * (here->B4SOIcgT + here->B4SOIcbT + + here->B4SOIcdT + here->B4SOIceT); + + ceeb = here->B4SOIceeb; + ceT = model->B4SOItype * here->B4SOIceT; + + cggb = here->B4SOIcggb; + cgsb = here->B4SOIcgdb; + cgdb = here->B4SOIcgsb; + cgT = model->B4SOItype * here->B4SOIcgT; + + cbgb = here->B4SOIcbgb; + cbsb = here->B4SOIcbdb; + cbdb = here->B4SOIcbsb; + cbeb = here->B4SOIcbeb; + cbT = model->B4SOItype * here->B4SOIcbT; + + cTt = here->pParam->B4SOIcth; + + +/* v3.1 bug fix */ + gigg = here->B4SOIgigg; + gigb = here->B4SOIgigb; + gige = here->B4SOIgige; + gigs = here->B4SOIgigd; /* v3.1.1 bug fix */ + gigd = here->B4SOIgigs; /* v3.1.1 bug fix */ + gigT = model->B4SOItype * here->B4SOIgigT; + + gbbg = -here->B4SOIgbgs; + gbbb = -here->B4SOIgbbs; + gbbp = -here->B4SOIgbps; + gbbsp = -here->B4SOIgbds; + gbbT = -model->B4SOItype * here->B4SOIgbT; +/* v3.0 */ + gbbe = -here->B4SOIgbes; + + if (here->B4SOIrbodyMod) { /* v4.0 */ + gbbsp = -here->B4SOIgiigidld; + gbbb = -here->B4SOIgbgiigbpb; + } + + gbbdp = - ( gbbg + gbbsp + gbbb + gbbp + gbbe); + + gddpg = -here->B4SOIgjsg; + gddpsp = -here->B4SOIgjsd; + if (!here->B4SOIrbodyMod) /* v4.0 */ + gddpb = -here->B4SOIgjsb; + else + gddpb = 0.0; + + gddpT = -model->B4SOItype * here->B4SOIgjsT; + +/* v3.0 */ + gddpe = 0.0; + gddpdp = - (gddpg + gddpsp + gddpb + gddpe ); + + gsspg = -here->B4SOIgjdg; + gsspsp = -here->B4SOIgjdd; + if (!here->B4SOIrbodyMod) /* v4.0 */ + gsspb = -here->B4SOIgjdb; + else + gsspb = here->B4SOIgiigidlb; + + gsspT = -model->B4SOItype * here->B4SOIgjdT; + +/* v3.0 */ + gsspe = -here->B4SOIgjde; + gsspdp = - ( gsspg + gsspsp + gsspb + gsspe ); + + gppb = -here->B4SOIgbpbs; + gppp = -here->B4SOIgbpps; + + gTtg = here->B4SOIgtempg; + gTtb = here->B4SOIgtempb; + gTtsp = here->B4SOIgtempd; + gTtt = here->B4SOIgtempT; + +/* v3.0 */ + gTte = here->B4SOIgtempe; + gTtdp = - (gTtg + gTtb + gTtsp + gTte); + + +/* v3.1.1 bug fix */ + if (model->B4SOIigcMod) + { + gIstotg = here->B4SOIgIgsg + here->B4SOIgIgcdg; + gIstotd = here->B4SOIgIgcds; + gIstots = here->B4SOIgIgss + here->B4SOIgIgcdd; + gIstotb = here->B4SOIgIgcdb; + + gIdtotg = here->B4SOIgIgdg + here->B4SOIgIgcsg; + gIdtotd = here->B4SOIgIgdd + here->B4SOIgIgcss; + gIdtots = here->B4SOIgIgcsd; + gIdtotb = here->B4SOIgIgcsb; + + gIgtotg = gIstotg + gIdtotg; + gIgtotd = gIstotd + gIdtotd; + gIgtots = gIstots + gIdtots; + gIgtotb = gIstotb + gIdtotb; + } + else + { + gIstotg = gIstotd = gIstots = gIstotb = 0.0; + gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0; + gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0; + } + + + sxpart = 0.4; + dxpart = 0.6; + + /* v3.1 for RF */ + if (here->B4SOIrgateMod == 2) + T0 = *(ckt->CKTstates[0] + here->B4SOIvges) + - *(ckt->CKTstates[0] + here->B4SOIvgs); + else if (here->B4SOIrgateMod == 3) + T0 = *(ckt->CKTstates[0] + here->B4SOIvgms) + - *(ckt->CKTstates[0] + here->B4SOIvgs); + if (here->B4SOIrgateMod > 1) + { gcrgd = here->B4SOIgcrgs * T0; + gcrgg = here->B4SOIgcrgg * T0; + gcrgs = here->B4SOIgcrgd * T0; + gcrgb = here->B4SOIgcrgb * T0; + gcrgg -= here->B4SOIgcrg; + gcrg = here->B4SOIgcrg; + } + else + gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0; + + /* v3.1 RF end*/ + + } + + if (!model->B4SOIrdsMod) { + gdpr=here->B4SOIdrainConductance; + gspr=here->B4SOIsourceConductance; + } + else gdpr = gspr = 0.0; + + + gds= here->B4SOIgds; + + GSoverlapCap = here->B4SOIcgso; + GDoverlapCap = here->B4SOIcgdo; + GEoverlapCap = here->pParam->B4SOIcgeo; + + EDextrinsicCap = here->B4SOIgcde; + ESextrinsicCap = here->B4SOIgcse; + + + /* v3.1 added for RF */ + if (here->B4SOIrgateMod == 3) + { + xcgmgmb = (GDoverlapCap + GSoverlapCap + GEoverlapCap ) * omega; + xcgmdb = -GDoverlapCap * omega; + xcgmsb = -GSoverlapCap * omega; + xcgmeb = -GEoverlapCap * omega; + + xcdgmb = xcgmdb; + xcsgmb = xcgmsb; + xcegmb = xcgmeb; + + xcedb = -EDextrinsicCap * omega; + xcdeb = (cdeb - EDextrinsicCap) * omega; + xcddb = (cddb + GDoverlapCap + EDextrinsicCap) * omega; + xceeb = (ceeb + GEoverlapCap + EDextrinsicCap + ESextrinsicCap) + * omega; + xcesb = -ESextrinsicCap * omega; + xcssb = (GSoverlapCap + ESextrinsicCap - (cgsb + cbsb + cdsb)) + * omega; + + xcseb = -(cbeb + cdeb + ceeb + ESextrinsicCap) * omega; + + xcegb = 0; /* v3.1 change for RF */ + xceT = ceT * omega; + xcggb = here->B4SOIcggb * omega; + xcgdb = cgdb * omega; + xcgsb = cgsb * omega; + xcgeb = 0; + xcgT = cgT * omega; + + xcdgb = cdgb * omega; + xcdsb = cdsb * omega; + xcdT = cdT * omega; + + xcsgb = -(cggb + cbgb + cdgb) * omega; + xcsdb = -(cgdb + cbdb + cddb) * omega; + xcsT = -(cgT + cbT + cdT + ceT) * omega; + + xcbgb = cbgb * omega; + xcbdb = cbdb * omega; + xcbsb = cbsb * omega; + xcbeb = cbeb * omega; + xcbT = cbT * omega; + + xcTt = cTt * omega; + } + + else + { + xcedb = -EDextrinsicCap * omega; + xcdeb = (cdeb - EDextrinsicCap) * omega; + xcddb = (cddb + GDoverlapCap + EDextrinsicCap) * omega; + xceeb = (ceeb + GEoverlapCap + EDextrinsicCap + ESextrinsicCap) + * omega; + xcesb = -ESextrinsicCap * omega; + xcssb = (GSoverlapCap + ESextrinsicCap - (cgsb + cbsb + cdsb)) + * omega; + + xcseb = -(cbeb + cdeb + ceeb + ESextrinsicCap) * omega; + + xcegb = (- GEoverlapCap) * omega; + xceT = ceT * omega; + xcggb = (cggb + GDoverlapCap + GSoverlapCap + GEoverlapCap) + * omega; + xcgdb = (cgdb - GDoverlapCap ) * omega; + xcgsb = (cgsb - GSoverlapCap) * omega; + xcgeb = (- GEoverlapCap) * omega; + xcgT = cgT * omega; + + xcdgb = (cdgb - GDoverlapCap) * omega; + xcdsb = cdsb * omega; + xcdT = cdT * omega; + + xcsgb = -(cggb + cbgb + cdgb + GSoverlapCap) * omega; + xcsdb = -(cgdb + cbdb + cddb) * omega; + xcsT = -(cgT + cbT + cdT + ceT) * omega; + + xcbgb = cbgb * omega; + xcbdb = cbdb * omega; + xcbsb = cbsb * omega; + xcbeb = cbeb * omega; + xcbT = cbT * omega; + + xcTt = cTt * omega; + + /* v3.1 */ + xcdgmb = xcsgmb = xcegmb = 0.0; + xcgmgmb = xcgmdb = xcgmsb = xcgmeb =0.0; + } + + if (here->B4SOImode >= 0) { /* v4.0 */ + if (!here->B4SOIrbodyMod) { + xcjdbdp = xcjsbsp = 0.0; + xcdbb = -(xcdgb + xcddb + xcdsb + xcdgmb + xcdeb); + xcsbb = -(xcsgb + xcsdb + xcssb + xcsgmb + xcseb); + xcdbdb = 0.0; xcsbsb = 0.0; + xcbdb = here->B4SOIcbdb * omega; + xcbsb = here->B4SOIcbsb * omega; + } + else { + xcjdbdp = here->B4SOIcjdb * omega; + xcjsbsp = here->B4SOIcjsb * omega; + xcdbb = -(xcdgb + xcddb + xcdsb + xcdgmb + xcdeb) + + xcjdbdp; + xcsbb = -(xcsgb + xcsdb + xcssb + xcsgmb + xcseb) + + xcjsbsp; + xcdbdb = -here->B4SOIcjdb * omega; + xcsbsb = -here->B4SOIcjsb * omega; + xcbdb = here->B4SOIcbdb * omega - xcdbdb; + xcbsb = here->B4SOIcbsb * omega - xcsbsb; + } + } + else { + if (!here->B4SOIrbodyMod) { + xcjdbdp = xcjsbsp = 0.0; + xcdbb = -(xcdgb + xcddb + xcdsb + xcdgmb + xcdeb); + xcsbb = -(xcsgb + xcsdb + xcssb + xcsgmb + xcseb); + xcdbdb = 0.0; xcsbsb = 0.0; + xcbdb = here->B4SOIcbsb * omega; + xcbsb = here->B4SOIcbdb * omega; + } + else { + xcjdbdp = here->B4SOIcjsb * omega; + xcjsbsp = here->B4SOIcjdb * omega; + xcdbb = -(xcdgb + xcddb + xcdsb + xcdgmb + xcdeb) + + xcjdbdp; + xcsbb = -(xcsgb + xcsdb + xcssb + xcsgmb + xcseb) + + xcjsbsp; + xcdbdb = -here->B4SOIcjsb * omega; + xcsbsb = -here->B4SOIcjdb * omega; + xcbdb = here->B4SOIcbsb * omega - xcdbdb; + xcbsb = here->B4SOIcbdb * omega - xcsbsb; + } + + } + + if (model->B4SOIrdsMod == 1) + { gstot = here->B4SOIgstot; + gstotd = here->B4SOIgstotd; + gstotg = here->B4SOIgstotg; + gstots = here->B4SOIgstots - gstot; + gstotb = here->B4SOIgstotb; + + gdtot = here->B4SOIgdtot; + gdtotd = here->B4SOIgdtotd - gdtot; + gdtotg = here->B4SOIgdtotg; + gdtots = here->B4SOIgdtots; + gdtotb = here->B4SOIgdtotb; + } + else + { gstot = gstotd = gstotg = gstots = gstotb = 0.0; + gdtot = gdtotd = gdtotg = gdtots = gdtotb = 0.0; + } + + m = here->B4SOIm; + + /* v3.1 for RF */ + geltd = here->B4SOIgrgeltd; + if (here->B4SOIrgateMod == 1) + { + *(here->B4SOIGEgePtr) += m * geltd; + *(here->B4SOIGgePtr) -= m * geltd; + *(here->B4SOIGEgPtr) -= m * geltd; + *(here->B4SOIGgPtr) += m * (geltd + gigg + gIgtotg); /* v3.1.1 bug fix */ + *(here->B4SOIGdpPtr) += m * (gigd + gIgtotd); /* v3.1.1 bug fix */ + *(here->B4SOIGspPtr) += m * (gigs + gIgtots); /* v3.1.1 bug fix */ + if (here->B4SOIsoiMod != 2) /* v3.2 */ + *(here->B4SOIGbPtr) -= m * (-gigb - gIgtotb); /* v3.1.1 bug fix */ + } + + else if (here->B4SOIrgateMod == 2) + { + *(here->B4SOIGEgePtr) += m * gcrg; + *(here->B4SOIGEgPtr) += m * gcrgg; + *(here->B4SOIGEdpPtr) += m * gcrgd; + *(here->B4SOIGEspPtr) += m * gcrgs; + if (here->B4SOIsoiMod != 2) /* v3.2 */ + *(here->B4SOIGEbPtr) += m * gcrgb; + + *(here->B4SOIGgePtr) -= m * gcrg; + *(here->B4SOIGgPtr) -= m * (gcrgg - gigg - gIgtotg); /* v3.1.1 bug fix */ + *(here->B4SOIGdpPtr) -= m * (gcrgd - gigd - gIgtotd); /* v3.1.1 bug fix */ + *(here->B4SOIGspPtr) -= m * (gcrgs - gigs - gIgtots); /* v3.1.1 bug fix */ + if (here->B4SOIsoiMod != 2) /* v3.2 */ + *(here->B4SOIGbPtr) -= m * (gcrgb - gigb - gIgtotb); /* v3.1.1 bug fix */ + } + + else if (here->B4SOIrgateMod == 3) + { + *(here->B4SOIGEgePtr) += m * geltd; + *(here->B4SOIGEgmPtr) -= m * geltd; + *(here->B4SOIGMgePtr) -= m * geltd; + *(here->B4SOIGMgmPtr) += m * (geltd + gcrg); + *(here->B4SOIGMgmPtr +1) += m * xcgmgmb; + + *(here->B4SOIGMdpPtr) += m * gcrgd; + *(here->B4SOIGMdpPtr +1) += m * xcgmdb; + *(here->B4SOIGMgPtr) += m * gcrgg; + *(here->B4SOIGMspPtr) += m * gcrgs; + *(here->B4SOIGMspPtr +1) += m * xcgmsb; + if (here->B4SOIsoiMod != 2) /* v3.2 */ + *(here->B4SOIGMbPtr) += m * gcrgb; + *(here->B4SOIGMePtr +1) += m * xcgmeb; + + *(here->B4SOIDPgmPtr +1) += m * xcdgmb; + *(here->B4SOIGgmPtr) -= m * gcrg; + *(here->B4SOISPgmPtr +1) += m * xcsgmb; + *(here->B4SOIEgmPtr +1) += m * xcegmb; + + *(here->B4SOIGgPtr) -= m * (gcrgg - gigg - gIgtotg); /* v3.1.1 bug fix */ + *(here->B4SOIGdpPtr) -= m * (gcrgd - gigd - gIgtotd); /* v3.1.1 bug fix */ + *(here->B4SOIGspPtr) -= m * (gcrgs - gigs - gIgtots); /* v3.1.1 bug fix */ + if (here->B4SOIsoiMod != 2) /* v3.2 */ + *(here->B4SOIGbPtr) -= m * (gcrgb - gigb - gIgtotb); /* v3.1.1 bug fix */ + } + else + { + *(here->B4SOIGgPtr) += m * (gigg + gIgtotg); /* v3.1.1 bug fix */ + *(here->B4SOIGdpPtr) += m * (gigd + gIgtotd); /* v3.1.1 bug fix */ + *(here->B4SOIGspPtr) += m * (gigs + gIgtots); /* v3.1.1 bug fix */ + if (here->B4SOIsoiMod != 2) /* v3.2 */ + *(here->B4SOIGbPtr) += m * (gigb + gIgtotb); /* v3.1.1 bug fix */ + } + /* v3.1 for RF end*/ + + if (model->B4SOIrdsMod) + { (*(here->B4SOIDgPtr) += m * gdtotg); + (*(here->B4SOIDspPtr) += m * gdtots); + (*(here->B4SOISdpPtr) += m * gstotd); + (*(here->B4SOISgPtr) += m * gstotg); + if (here->B4SOIsoiMod != 2) { + (*(here->B4SOIDbPtr) += m * gdtotb); + (*(here->B4SOISbPtr) += m * gstotb); + } + } + + *(here->B4SOIEdpPtr +1) += m * xcedb; + *(here->B4SOIEspPtr +1) += m * xcesb; + *(here->B4SOIDPePtr +1) += m * xcdeb; + *(here->B4SOISPePtr +1) += m * xcseb; + *(here->B4SOIEgPtr +1) += m * xcegb; + *(here->B4SOIGePtr +1) += m * xcgeb; + + *(here->B4SOIEePtr +1) += m * xceeb; + + *(here->B4SOIGgPtr +1) += m * xcggb; + *(here->B4SOIGdpPtr +1) += m * xcgdb; + *(here->B4SOIGspPtr +1) += m * xcgsb; + + *(here->B4SOIDPgPtr +1) += m * xcdgb; + *(here->B4SOIDPdpPtr +1) += m * xcddb; + *(here->B4SOIDPspPtr +1) += m * xcdsb; + + *(here->B4SOISPgPtr +1) += m * xcsgb; + *(here->B4SOISPdpPtr +1) += m * xcsdb; + *(here->B4SOISPspPtr +1) += m * xcssb; + +/* v3.1 */ + if (here->B4SOIsoiMod != 2) /* v3.2 */ + { + *(here->B4SOIBePtr +1) += m * xcbeb; + *(here->B4SOIBgPtr +1) += m * xcbgb; + *(here->B4SOIBdpPtr +1) += m * xcbdb; + *(here->B4SOIBspPtr +1) += m * xcbsb; + + *(here->B4SOIEbPtr +1) -= m * (xcegb + xceeb + xcedb + xcesb); + *(here->B4SOIGbPtr +1) -= m * (xcggb + xcgdb + xcgsb + xcgeb); +/* *(here->B4SOIDPbPtr +1) -= xcdgb + xcddb + xcdsb + xcdeb; + + xcdgmb; */ + + *(here->B4SOIDPbPtr +1) -= m * -xcdbb; /* v4.0 */ + +/* *(here->B4SOISPbPtr +1) -= xcsgb + xcsdb + xcssb + xcseb + + xcsgmb; */ + *(here->B4SOISPbPtr +1) -= m * -xcsbb; /* v4.0 */ + *(here->B4SOIBbPtr +1) -= m * (xcbgb + xcbdb + xcbsb + xcbeb); + } +/* v3.1 */ + + + if (selfheat) + { + *(here->B4SOITemptempPtr + 1) += m * xcTt; + *(here->B4SOIDPtempPtr + 1) += m * xcdT; + *(here->B4SOISPtempPtr + 1) += m * xcsT; + *(here->B4SOIBtempPtr + 1) += m * xcbT; + *(here->B4SOIEtempPtr + 1) += m * xceT; + *(here->B4SOIGtempPtr + 1) += m * xcgT; + } + + +/* v3.0 */ + if (here->B4SOIsoiMod != 0) /* v3.2 */ + { + *(here->B4SOIDPePtr) += m * (Gme + gddpe); + *(here->B4SOISPePtr) += m * (gsspe - Gme); + + if (here->B4SOIsoiMod != 2) /* v3.2 */ + { + *(here->B4SOIGePtr) += m * gige; + *(here->B4SOIBePtr) -= m * gige; + } + } + + *(here->B4SOIEePtr) += 0.0; + + *(here->B4SOIDPgPtr) += m * (Gm + gddpg - gIdtotg -gdtotg); /* v4.0 */ + *(here->B4SOIDPdpPtr) += m * (gdpr + gds + gddpdp + RevSum - gIdtotd + - gdtotd); /* v4.0 */ + + *(here->B4SOIDPspPtr) -= m * (gds + FwdSum - gddpsp + gIdtots + + gdtots); /* v4.0 */ + *(here->B4SOIDPdPtr) -= m * (gdpr + gdtot); + + *(here->B4SOISPgPtr) -= m * (Gm - gsspg + gIstotg + gstotg); /* v4.0 */ + *(here->B4SOISPdpPtr) -= m * (gds + RevSum - gsspdp + gIstotd + + gstotd); /* v4.0 */ + *(here->B4SOISPspPtr) += m * (gspr + gds + FwdSum + gsspsp - gIstots + - gstots); /* v4.0 */ + *(here->B4SOISPsPtr) -= m * (gspr + gstot); + + +/* v3.1 */ + if (here->B4SOIsoiMod != 2) /* v3.2 */ + { + *(here->B4SOIBePtr) += m * gbbe; /* v3.0 */ + *(here->B4SOIBgPtr) += m * (gbbg - gigg); /* v3.1 bug fix */ + *(here->B4SOIBdpPtr) += m * (gbbdp - gigd); /* v3.1 bug fix */ + *(here->B4SOIBspPtr) += m * (gbbsp - gigs); /* v3.1 bug fix */ + *(here->B4SOIBbPtr) += m * (gbbb - gigb); /* v3.1 bug fix */ + *(here->B4SOISPbPtr) -= m * (Gmbs - gsspb + gIstotb + gstotb); + /* v4.0 */ + *(here->B4SOIDPbPtr) -= m * ((-gddpb - Gmbs) + gIdtotb + gdtotb); + /* v4.0 */ + } +/* v3.1 */ + + + + if (selfheat) + { + *(here->B4SOIDPtempPtr) += m * (GmT + gddpT); + *(here->B4SOISPtempPtr) += m * (-GmT + gsspT); + *(here->B4SOIBtempPtr) += m * (gbbT - gigT); /* v3.1 bug fix */ + *(here->B4SOIGtempPtr) += m * gigT; /* v3.1 bug fix */ + *(here->B4SOITemptempPtr) += m * (gTtt + 1/here->pParam->B4SOIrth); + *(here->B4SOITempgPtr) += m * gTtg; + *(here->B4SOITempbPtr) += m * gTtb; + *(here->B4SOITempdpPtr) += m * gTtdp; + *(here->B4SOITempspPtr) += m * gTtsp; + +/* v3.0 */ + if (here->B4SOIsoiMod != 0) /* v3.2 */ + *(here->B4SOITempePtr) += m * gTte; + } + + + *(here->B4SOIDdPtr) += m * (gdpr + gdtot); + *(here->B4SOIDdpPtr) -= m * (gdpr - gdtotd); + *(here->B4SOISsPtr) += m * (gspr + gstot); + *(here->B4SOISspPtr) -= m * (gspr -gstots); + + + if (here->B4SOIbodyMod == 1) { + (*(here->B4SOIBpPtr) -= m * gppp); + (*(here->B4SOIPbPtr) += m * gppb); + (*(here->B4SOIPpPtr) += m * gppp); + } + + + /* v4.0 */ + if (here->B4SOIrbodyMod) + { + (*(here->B4SOIDPdbPtr + 1) -= m * xcjdbdp); + (*(here->B4SOIDPdbPtr) -= m * here->B4SOIGGjdb); + (*(here->B4SOISPsbPtr + 1) -= m * xcjsbsp); + (*(here->B4SOISPsbPtr) -= m * here->B4SOIGGjsb); + + (*(here->B4SOIDBdpPtr + 1) -= m * xcjdbdp); + (*(here->B4SOIDBdpPtr) -= m * here->B4SOIGGjdb); + (*(here->B4SOIDBdbPtr + 1) += m * xcjdbdp); + (*(here->B4SOIDBdbPtr) += m * (here->B4SOIGGjdb + + here->B4SOIgrbdb)); + + (*(here->B4SOIDBbPtr) -= m * here->B4SOIgrbdb); + (*(here->B4SOISBbPtr) -= m * here->B4SOIgrbsb); + + (*(here->B4SOISBspPtr + 1) -= m * xcjsbsp); + (*(here->B4SOISBspPtr) -= m * here->B4SOIGGjsb); + (*(here->B4SOISBsbPtr + 1) += m * xcjsbsp); + (*(here->B4SOISBsbPtr) += m * (here->B4SOIGGjsb + + here->B4SOIgrbsb)); + + (*(here->B4SOIBdbPtr) -= m * here->B4SOIgrbdb); + (*(here->B4SOIBsbPtr) -= m * here->B4SOIgrbsb); + (*(here->B4SOIBbPtr) += m * (here->B4SOIgrbsb + + here->B4SOIgrbdb)); + + + } + + if (here->B4SOIdebugMod != 0) + { + *(here->B4SOIVbsPtr) += 1; + *(here->B4SOIIdsPtr) += 1; + *(here->B4SOIIcPtr) += 1; + *(here->B4SOIIbsPtr) += 1; + *(here->B4SOIIbdPtr) += 1; + *(here->B4SOIIiiPtr) += 1; + *(here->B4SOIIgidlPtr) += 1; + *(here->B4SOIItunPtr) += 1; + *(here->B4SOIIbpPtr) += 1; + *(here->B4SOICbgPtr) += 1; + *(here->B4SOICbbPtr) += 1; + *(here->B4SOICbdPtr) += 1; + *(here->B4SOIQbfPtr) += 1; + *(here->B4SOIQjsPtr) += 1; + *(here->B4SOIQjdPtr) += 1; + + } + + } + } + return(OK); +} + diff --git a/src/spicelib/devices/bsim3soi/b4soiask.c b/src/spicelib/devices/bsim3soi/b4soiask.c new file mode 100644 index 000000000..d3fdcafe2 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soiask.c @@ -0,0 +1,337 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soiask.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soiask.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "ifsim.h" +#include "cktdefs.h" +#include "devdefs.h" +#include "b4soidef.h" +#include "sperror.h" +#include "suffix.h" + +int +B4SOIask(CKTcircuit *ckt, GENinstance *inst, int which, IFvalue *value, + IFvalue *select) +{ +B4SOIinstance *here = (B4SOIinstance*)inst; + + switch(which) + { case B4SOI_L: + value->rValue = here->B4SOIl; + return(OK); + case B4SOI_W: + value->rValue = here->B4SOIw; + return(OK); + + case B4SOI_AS: + value->rValue = here->B4SOIsourceArea; + return(OK); + case B4SOI_AD: + value->rValue = here->B4SOIdrainArea; + return(OK); + case B4SOI_PS: + value->rValue = here->B4SOIsourcePerimeter; + return(OK); + case B4SOI_PD: + value->rValue = here->B4SOIdrainPerimeter; + return(OK); + case B4SOI_NRS: + value->rValue = here->B4SOIsourceSquares; + return(OK); + case B4SOI_NRD: + value->rValue = here->B4SOIdrainSquares; + return(OK); + case B4SOI_OFF: + value->iValue = here->B4SOIoff; + return(OK); + case B4SOI_BJTOFF: + value->iValue = here->B4SOIbjtoff; + return(OK); + case B4SOI_RTH0: + value->rValue = here->B4SOIrth0; + return(OK); + case B4SOI_CTH0: + value->rValue = here->B4SOIcth0; + return(OK); + case B4SOI_NRB: + value->rValue = here->B4SOIbodySquares; + return(OK); + case B4SOI_FRBODY: + value->rValue = here->B4SOIfrbody; + return(OK); + + case B4SOI_QB: + value->rValue = here->B4SOIqbulk; + return(OK); + case B4SOI_QD: + value->rValue = here->B4SOIqdrn; + return(OK); + case B4SOI_QS: + value->rValue = here->B4SOIqsrc; + return(OK); + case B4SOI_CGG: + value->rValue = here->B4SOIcggb; + return(OK); + case B4SOI_CGD: + value->rValue = here->B4SOIcgdb; + return(OK); + case B4SOI_CGS: + value->rValue = here->B4SOIcgsb; + return(OK); + case B4SOI_CDG: + value->rValue = here->B4SOIcdgb; + return(OK); + case B4SOI_CDD: + value->rValue = here->B4SOIcddb; + return(OK); + case B4SOI_CDS: + value->rValue = here->B4SOIcdsb; + return(OK); + case B4SOI_CBG: + value->rValue = here->B4SOIcbgb; + return(OK); + case B4SOI_CBD: + value->rValue = here->B4SOIcbdb; + return(OK); + case B4SOI_CBS: + value->rValue = here->B4SOIcbsb; + return(OK); + case B4SOI_CAPBD: + value->rValue = here->B4SOIcapbd; + return(OK); + case B4SOI_CAPBS: + value->rValue = here->B4SOIcapbs; + return(OK); + +/* v4.0 */ + case B4SOI_RBSB: + value->rValue = here->B4SOIrbsb; + return(OK); + case B4SOI_RBDB: + value->rValue = here->B4SOIrbdb; + return(OK); + case B4SOI_CJSB: + value->rValue = here->B4SOIcjsb; + return(OK); + case B4SOI_CJDB: + value->rValue = here->B4SOIcjdb; + return(OK); + case B4SOI_SA: + value->rValue = here->B4SOIsa ; + return(OK); + case B4SOI_SB: + value->rValue = here->B4SOIsb ; + return(OK); + case B4SOI_SD: + value->rValue = here->B4SOIsd ; + return(OK); + case B4SOI_RBODYMOD: + value->iValue = here->B4SOIrbodyMod; + return(OK); + case B4SOI_NF: + value->rValue = here->B4SOInf; + return(OK); + case B4SOI_DELVTO: + value->rValue = here->B4SOIdelvto; + return(OK); + +/* v4.0 end */ + +/* v3.2 */ + case B4SOI_SOIMOD: + value->iValue = here->B4SOIsoiMod; + return(OK); + +/* v3.1 added rgate */ + case B4SOI_RGATEMOD: + value->iValue = here->B4SOIrgateMod; + return(OK); +/* v3.1 added rgate end */ + +/* v2.0 release */ + case B4SOI_NBC: + value->rValue = here->B4SOInbc; + return(OK); + case B4SOI_NSEG: + value->rValue = here->B4SOInseg; + return(OK); + case B4SOI_PDBCP: + value->rValue = here->B4SOIpdbcp; + return(OK); + case B4SOI_PSBCP: + value->rValue = here->B4SOIpsbcp; + return(OK); + case B4SOI_AGBCP: + value->rValue = here->B4SOIagbcp; + return(OK); + case B4SOI_AGBCPD: /* v4.0 */ + value->rValue = here->B4SOIagbcpd; + return(OK); + case B4SOI_AEBCP: + value->rValue = here->B4SOIaebcp; + return(OK); + case B4SOI_VBSUSR: + value->rValue = here->B4SOIvbsusr; + return(OK); + case B4SOI_TNODEOUT: + value->iValue = here->B4SOItnodeout; + return(OK); + + + case B4SOI_IC_VBS: + value->rValue = here->B4SOIicVBS; + return(OK); + case B4SOI_IC_VDS: + value->rValue = here->B4SOIicVDS; + return(OK); + case B4SOI_IC_VGS: + value->rValue = here->B4SOIicVGS; + return(OK); + case B4SOI_IC_VES: + value->rValue = here->B4SOIicVES; + return(OK); + case B4SOI_IC_VPS: + value->rValue = here->B4SOIicVPS; + return(OK); + case B4SOI_DNODE: + value->iValue = here->B4SOIdNode; + return(OK); + case B4SOI_GNODE: + value->iValue = here->B4SOIgNode; + return(OK); + case B4SOI_SNODE: + value->iValue = here->B4SOIsNode; + return(OK); + case B4SOI_BNODE: + value->iValue = here->B4SOIbNode; + return(OK); + case B4SOI_ENODE: + value->iValue = here->B4SOIeNode; + return(OK); + case B4SOI_DNODEPRIME: + value->iValue = here->B4SOIdNodePrime; + return(OK); + case B4SOI_SNODEPRIME: + value->iValue = here->B4SOIsNodePrime; + return(OK); + +/* v3.1 added for RF */ + case B4SOI_GNODEEXT: + value->iValue = here->B4SOIgNodeExt; + return(OK); + case B4SOI_GNODEMID: + value->iValue = here->B4SOIgNodeMid; + return(OK); +/* added for RF end*/ + + + case B4SOI_SOURCECONDUCT: + value->rValue = here->B4SOIsourceConductance; + return(OK); + case B4SOI_DRAINCONDUCT: + value->rValue = here->B4SOIdrainConductance; + return(OK); + case B4SOI_VBD: + value->rValue = *(ckt->CKTstate0 + here->B4SOIvbd); + return(OK); + case B4SOI_VBS: + value->rValue = *(ckt->CKTstate0 + here->B4SOIvbs); + return(OK); + case B4SOI_VGS: + value->rValue = *(ckt->CKTstate0 + here->B4SOIvgs); + return(OK); + case B4SOI_VES: + value->rValue = *(ckt->CKTstate0 + here->B4SOIves); + return(OK); + case B4SOI_VDS: + value->rValue = *(ckt->CKTstate0 + here->B4SOIvds); + return(OK); + case B4SOI_CD: + value->rValue = here->B4SOIcdrain; + return(OK); + case B4SOI_IBS: + value->rValue = here->B4SOIibs; + return(OK); + case B4SOI_IBD: + value->rValue = here->B4SOIibd; + return(OK); + case B4SOI_ISUB: + value->rValue = here->B4SOIiii; + return(OK); + case B4SOI_IGIDL: + value->rValue = here->B4SOIigidl; + return(OK); + case B4SOI_IGS: + value->rValue = here->B4SOIIgs; + return(OK); + case B4SOI_IGD: + value->rValue = here->B4SOIIgd; + return(OK); + case B4SOI_IGB: + value->rValue = here->B4SOIIgb; + return(OK); + case B4SOI_IGCS: + value->rValue = here->B4SOIIgcs; + return(OK); + case B4SOI_IGCD: + value->rValue = here->B4SOIIgcd; + return(OK); + case B4SOI_GM: + value->rValue = here->B4SOIgm; + return(OK); + case B4SOI_GMID: + value->rValue = here->B4SOIgm/here->B4SOIcd; + return(OK); + case B4SOI_GDS: + value->rValue = here->B4SOIgds; + return(OK); + case B4SOI_GMBS: + value->rValue = here->B4SOIgmbs; + return(OK); + case B4SOI_GBD: + value->rValue = here->B4SOIgjdb; + return(OK); + case B4SOI_GBS: + value->rValue = here->B4SOIgjsb; + return(OK); + case B4SOI_CQB: + value->rValue = *(ckt->CKTstate0 + here->B4SOIcqb); + return(OK); + case B4SOI_CQG: + value->rValue = *(ckt->CKTstate0 + here->B4SOIcqg); + return(OK); + case B4SOI_CQD: + value->rValue = *(ckt->CKTstate0 + here->B4SOIcqd); + return(OK); + case B4SOI_CBDB: + value->rValue = here->B4SOIcbdb; + return(OK); + case B4SOI_CBSB: + value->rValue = here->B4SOIcbsb; + return(OK); + case B4SOI_VON: + value->rValue = here->B4SOIvon; + return(OK); + case B4SOI_VDSAT: + value->rValue = here->B4SOIvdsat; + return(OK); + case B4SOI_QBS: + value->rValue = *(ckt->CKTstate0 + here->B4SOIqbs); + return(OK); + case B4SOI_QBD: + value->rValue = *(ckt->CKTstate0 + here->B4SOIqbd); + return(OK); + default: + return(E_BADPARM); + } + /* NOTREACHED */ +} + diff --git a/src/spicelib/devices/bsim3soi/b4soicheck.c b/src/spicelib/devices/bsim3soi/b4soicheck.c new file mode 100644 index 000000000..3e09e2b47 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soicheck.c @@ -0,0 +1,924 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soicheck.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soicheck.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "cktdefs.h" +#include "b4soidef.h" +#include "trandefs.h" +#include "const.h" +#include "sperror.h" +#include "devdefs.h" +#include "suffix.h" + +int +B4SOIcheckModel(B4SOImodel *model, B4SOIinstance *here, CKTcircuit *ckt) +{ +struct b4soiSizeDependParam *pParam; +int Fatal_Flag = 0; +FILE *fplog; + + if ((fplog = fopen("b4soiv1check.log", "w")) != NULL) + { pParam = here->pParam; + fprintf(fplog, "B4SOIV3 Parameter Check\n"); + fprintf(fplog, "Model = %s\n", model->B4SOImodName); + fprintf(fplog, "W = %g, L = %g\n", here->B4SOIw, here->B4SOIl); + + if (pParam->B4SOIlpe0 < -pParam->B4SOIleff) + { fprintf(fplog, "Fatal: Lpe0 = %g is less than -Leff.\n", + pParam->B4SOIlpe0); + printf("Fatal: Lpe0 = %g is less than -Leff.\n", + pParam->B4SOIlpe0); + Fatal_Flag = 1; + } + + if((here->B4SOIsa > 0.0) && (here->B4SOIsb > 0.0) && + ((here->B4SOInf == 1.0) || ((here->B4SOInf > 1.0) && + (here->B4SOIsd > 0.0))) ) + { if (model->B4SOIsaref <= 0.0) + { fprintf(fplog, "Fatal: SAref = %g is not positive.\n", + model->B4SOIsaref); + printf("Fatal: SAref = %g is not positive.\n", + model->B4SOIsaref); + Fatal_Flag = 1; + } + if (model->B4SOIsbref <= 0.0) + { fprintf(fplog, "Fatal: SBref = %g is not positive.\n", + model->B4SOIsbref); + printf("Fatal: SBref = %g is not positive.\n", + model->B4SOIsbref); + Fatal_Flag = 1; + } + } + + if (pParam->B4SOIlpeb < -pParam->B4SOIleff) /* v4.0 for Vth */ + { fprintf(fplog, "Fatal: Lpeb = %g is less than -Leff.\n", + pParam->B4SOIlpeb); + printf("Fatal: Lpeb = %g is less than -Leff.\n", + pParam->B4SOIlpeb); + Fatal_Flag = 1; + } + + if (pParam->B4SOIfprout < 0.0) /* v4.0 for DITS */ + { fprintf(fplog, "Fatal: fprout = %g is negative.\n", + pParam->B4SOIfprout); + printf("Fatal: fprout = %g is negative.\n", pParam->B4SOIfprout); + Fatal_Flag = 1; + } + if (pParam->B4SOIpdits < 0.0) /* v4.0 for DITS */ + { fprintf(fplog, "Fatal: pdits = %g is negative.\n", + pParam->B4SOIpdits); + printf("Fatal: pdits = %g is negative.\n", pParam->B4SOIpdits); + Fatal_Flag = 1; + } + if (model->B4SOIpditsl < 0.0) /* v4.0 for DITS */ + { fprintf(fplog, "Fatal: pditsl = %g is negative.\n", + model->B4SOIpditsl); + printf("Fatal: pditsl = %g is negative.\n", model->B4SOIpditsl); + Fatal_Flag = 1; + } + + if (model->B4SOItox <= 0.0) + { fprintf(fplog, "Fatal: Tox = %g is not positive.\n", + model->B4SOItox); + printf("Fatal: Tox = %g is not positive.\n", model->B4SOItox); + Fatal_Flag = 1; + } + + + if (model->B4SOItoxm <= 0.0) + { fprintf(fplog, "Fatal: Toxm = %g is not positive.\n", + model->B4SOItoxm); + printf("Fatal: Toxm = %g is not positive.\n", model->B4SOItoxm); + Fatal_Flag = 1; + } /* v3.2 */ + + if (here->B4SOInf < 1.0) + { fprintf(fplog, "Fatal: Number of finger = %g is smaller than one.\n", here->B4SOInf); + printf("Fatal: Number of finger = %g is smaller than one.\n", here->B4SOInf); + Fatal_Flag = 1; + } + + +/* v2.2.3 */ + if (model->B4SOItox - model->B4SOIdtoxcv <= 0.0) + { fprintf(fplog, "Fatal: Tox - dtoxcv = %g is not positive.\n", + model->B4SOItox - model->B4SOIdtoxcv); + printf("Fatal: Tox - dtoxcv = %g is not positive.\n", model->B4SOItox - model->B4SOIdtoxcv); + Fatal_Flag = 1; + } + + + if (model->B4SOItbox <= 0.0) + { fprintf(fplog, "Fatal: Tbox = %g is not positive.\n", + model->B4SOItbox); + printf("Fatal: Tbox = %g is not positive.\n", model->B4SOItbox); + Fatal_Flag = 1; + } + + if (pParam->B4SOInpeak <= 0.0) + { fprintf(fplog, "Fatal: Nch = %g is not positive.\n", + pParam->B4SOInpeak); + printf("Fatal: Nch = %g is not positive.\n", + pParam->B4SOInpeak); + Fatal_Flag = 1; + } + if (pParam->B4SOIngate < 0.0) + { fprintf(fplog, "Fatal: Ngate = %g is not positive.\n", + pParam->B4SOIngate); + printf("Fatal: Ngate = %g Ngate is not positive.\n", + pParam->B4SOIngate); + Fatal_Flag = 1; + } + if (pParam->B4SOIngate > 1.e25) + { fprintf(fplog, "Fatal: Ngate = %g is too high.\n", + pParam->B4SOIngate); + printf("Fatal: Ngate = %g Ngate is too high\n", + pParam->B4SOIngate); + Fatal_Flag = 1; + } + + if (pParam->B4SOIdvt1 < 0.0) + { fprintf(fplog, "Fatal: Dvt1 = %g is negative.\n", + pParam->B4SOIdvt1); + printf("Fatal: Dvt1 = %g is negative.\n", pParam->B4SOIdvt1); + Fatal_Flag = 1; + } + + if (pParam->B4SOIdvt1w < 0.0) + { fprintf(fplog, "Fatal: Dvt1w = %g is negative.\n", + pParam->B4SOIdvt1w); + printf("Fatal: Dvt1w = %g is negative.\n", pParam->B4SOIdvt1w); + Fatal_Flag = 1; + } + + if (pParam->B4SOIw0 == -pParam->B4SOIweff) + { fprintf(fplog, "Fatal: (W0 + Weff) = 0 cauing divided-by-zero.\n"); + printf("Fatal: (W0 + Weff) = 0 cauing divided-by-zero.\n"); + Fatal_Flag = 1; + } + + if (pParam->B4SOIdsub < 0.0) + { fprintf(fplog, "Fatal: Dsub = %g is negative.\n", pParam->B4SOIdsub); + printf("Fatal: Dsub = %g is negative.\n", pParam->B4SOIdsub); + Fatal_Flag = 1; + } + if (pParam->B4SOIb1 == -pParam->B4SOIweff) + { fprintf(fplog, "Fatal: (B1 + Weff) = 0 causing divided-by-zero.\n"); + printf("Fatal: (B1 + Weff) = 0 causing divided-by-zero.\n"); + Fatal_Flag = 1; + } + if (pParam->B4SOIu0temp <= 0.0) + { fprintf(fplog, "Fatal: u0 at current temperature = %g is not positive.\n", pParam->B4SOIu0temp); + printf("Fatal: u0 at current temperature = %g is not positive.\n", + pParam->B4SOIu0temp); + Fatal_Flag = 1; + } + +/* Check delta parameter */ + if (pParam->B4SOIdelta < 0.0) + { fprintf(fplog, "Fatal: Delta = %g is less than zero.\n", + pParam->B4SOIdelta); + printf("Fatal: Delta = %g is less than zero.\n", pParam->B4SOIdelta); + Fatal_Flag = 1; + } + + if (pParam->B4SOIvsattemp <= 0.0) + { fprintf(fplog, "Fatal: Vsat at current temperature = %g is not positive.\n", pParam->B4SOIvsattemp); + printf("Fatal: Vsat at current temperature = %g is not positive.\n", + pParam->B4SOIvsattemp); + Fatal_Flag = 1; + } +/* Check Rout parameters */ + if (pParam->B4SOIpclm <= 0.0) + { fprintf(fplog, "Fatal: Pclm = %g is not positive.\n", pParam->B4SOIpclm); + printf("Fatal: Pclm = %g is not positive.\n", pParam->B4SOIpclm); + Fatal_Flag = 1; + } + + if (pParam->B4SOIdrout < 0.0) + { fprintf(fplog, "Fatal: Drout = %g is negative.\n", pParam->B4SOIdrout); + printf("Fatal: Drout = %g is negative.\n", pParam->B4SOIdrout); + Fatal_Flag = 1; + } + if ( model->B4SOIunitLengthGateSidewallJctCapD > 0.0) /* v4.0 */ + { + if (here->B4SOIdrainPerimeter < pParam->B4SOIweff) + { fprintf(fplog, "Warning: Pd = %g is less than W.\n", + here->B4SOIdrainPerimeter); + printf("Warning: Pd = %g is less than W.\n", + here->B4SOIdrainPerimeter); + here->B4SOIdrainPerimeter =pParam->B4SOIweff; + } + } + if ( model->B4SOIunitLengthGateSidewallJctCapS > 0.0) /* v4.0 */ + { + if (here->B4SOIsourcePerimeter < pParam->B4SOIweff) + { fprintf(fplog, "Warning: Ps = %g is less than W.\n", + here->B4SOIsourcePerimeter); + printf("Warning: Ps = %g is less than W.\n", + here->B4SOIsourcePerimeter); + here->B4SOIsourcePerimeter =pParam->B4SOIweff; + } + } +/* Check capacitance parameters */ + if (pParam->B4SOIclc < 0.0) + { fprintf(fplog, "Fatal: Clc = %g is negative.\n", pParam->B4SOIclc); + printf("Fatal: Clc = %g is negative.\n", pParam->B4SOIclc); + Fatal_Flag = 1; + } + + +/* v3.2 */ + if (pParam->B4SOInoff < 0.1) + { fprintf(fplog, "Warning: Noff = %g is too small.\n", + pParam->B4SOInoff); + printf("Warning: Noff = %g is too small.\n", pParam->B4SOInoff); + } + if (pParam->B4SOInoff > 4.0) + { fprintf(fplog, "Warning: Noff = %g is too large.\n", + pParam->B4SOInoff); + printf("Warning: Noff = %g is too large.\n", pParam->B4SOInoff); + } + +/* added for stress */ + +/* Check stress effect parameters */ + if( (here->B4SOIsa > 0.0) && (here->B4SOIsb > 0.0) && + ((here->B4SOInf == 1.0) || ((here->B4SOInf > 1.0) && + (here->B4SOIsd > 0.0))) ) + { if (model->B4SOIlodk2 <= 0.0) + { fprintf(fplog, "Warning: LODK2 = %g is not positive.\n",model->B4SOIlodk2); + printf("Warning: LODK2 = %g is not positive.\n",model->B4SOIlodk2); + } + if (model->B4SOIlodeta0 <= 0.0) + { fprintf(fplog, "Warning: LODETA0 = %g is not positive.\n",model->B4SOIlodeta0); + printf("Warning: LODETA0 = %g is not positive.\n",model->B4SOIlodeta0); + } + } + +/* added for stress end */ + +/* v2.2.3 */ + if (pParam->B4SOImoin < 5.0) + { fprintf(fplog, "Warning: Moin = %g is too small.\n", + pParam->B4SOImoin); + printf("Warning: Moin = %g is too small.\n", pParam->B4SOImoin); + } + if (pParam->B4SOImoin > 25.0) + { fprintf(fplog, "Warning: Moin = %g is too large.\n", + pParam->B4SOImoin); + printf("Warning: Moin = %g is too large.\n", pParam->B4SOImoin); + } + +/* v3.0 */ + if (model->B4SOImoinFD < 5.0) + { fprintf(fplog, "Warning: MoinFD = %g is too small.\n", + model->B4SOImoinFD); + printf("Warning: MoinFD = %g is too small.\n", model->B4SOImoinFD); + } + + + if (model->B4SOIcapMod == 3) { + if (pParam->B4SOIacde < 0.1) /* v3.1.1 */ + { fprintf (fplog, "Warning: Acde = %g is too small.\n", + pParam->B4SOIacde); + printf ("Warning: Acde = %g is too small.\n", + pParam->B4SOIacde); + } + if (pParam->B4SOIacde > 1.6) + { fprintf (fplog, "Warning: Acde = %g is too large.\n", + pParam->B4SOIacde); + printf ("Warning: Acde = %g is too large.\n", + pParam->B4SOIacde); + } + } +/* v2.2.3 */ + + if (model->B4SOIparamChk ==1) + { +/* Check L and W parameters */ + if (pParam->B4SOIleff <= 5.0e-8) + { fprintf(fplog, "Warning: Leff = %g may be too small.\n", + pParam->B4SOIleff); + printf("Warning: Leff = %g may be too small.\n", + pParam->B4SOIleff); + } + + if (pParam->B4SOIleffCV <= 5.0e-8) + { fprintf(fplog, "Warning: Leff for CV = %g may be too small.\n", + pParam->B4SOIleffCV); + printf("Warning: Leff for CV = %g may be too small.\n", + pParam->B4SOIleffCV); + } + + if (pParam->B4SOIweff <= 1.0e-7) + { fprintf(fplog, "Warning: Weff = %g may be too small.\n", + pParam->B4SOIweff); + printf("Warning: Weff = %g may be too small.\n", + pParam->B4SOIweff); + } + + if (pParam->B4SOIweffCV <= 1.0e-7) + { fprintf(fplog, "Warning: Weff for CV = %g may be too small.\n", + pParam->B4SOIweffCV); + printf("Warning: Weff for CV = %g may be too small.\n", + pParam->B4SOIweffCV); + } + +/* Check threshold voltage parameters */ + if (pParam->B4SOIlpe0 < 0.0) + { fprintf(fplog, "Warning: Lpe0 = %g is negative.\n", pParam->B4SOIlpe0); + printf("Warning: Lpe0 = %g is negative.\n", pParam->B4SOIlpe0); + } + if (model->B4SOItox < 1.0e-9) + { fprintf(fplog, "Warning: Tox = %g is less than 10A.\n", + model->B4SOItox); + printf("Warning: Tox = %g is less than 10A.\n", model->B4SOItox); + } + + if (pParam->B4SOInpeak <= 1.0e15) + { fprintf(fplog, "Warning: Nch = %g may be too small.\n", + pParam->B4SOInpeak); + printf("Warning: Nch = %g may be too small.\n", + pParam->B4SOInpeak); + } + else if (pParam->B4SOInpeak >= 1.0e21) + { fprintf(fplog, "Warning: Nch = %g may be too large.\n", + pParam->B4SOInpeak); + printf("Warning: Nch = %g may be too large.\n", + pParam->B4SOInpeak); + } + + if (fabs(pParam->B4SOInsub) >= 1.0e21) + { fprintf(fplog, "Warning: Nsub = %g may be too large.\n", + pParam->B4SOInsub); + printf("Warning: Nsub = %g may be too large.\n", + pParam->B4SOInsub); + } + + if ((pParam->B4SOIngate > 0.0) && + (pParam->B4SOIngate <= 1.e18)) + { fprintf(fplog, "Warning: Ngate = %g is less than 1.E18cm^-3.\n", + pParam->B4SOIngate); + printf("Warning: Ngate = %g is less than 1.E18cm^-3.\n", + pParam->B4SOIngate); + } + + if (pParam->B4SOIdvt0 < 0.0) + { fprintf(fplog, "Warning: Dvt0 = %g is negative.\n", + pParam->B4SOIdvt0); + printf("Warning: Dvt0 = %g is negative.\n", pParam->B4SOIdvt0); + } + + if (fabs(1.0e-6 / (pParam->B4SOIw0 + pParam->B4SOIweff)) > 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->B4SOInfactor < 0.0) + { fprintf(fplog, "Warning: Nfactor = %g is negative.\n", + pParam->B4SOInfactor); + printf("Warning: Nfactor = %g is negative.\n", pParam->B4SOInfactor); + } + if (pParam->B4SOIcdsc < 0.0) + { fprintf(fplog, "Warning: Cdsc = %g is negative.\n", + pParam->B4SOIcdsc); + printf("Warning: Cdsc = %g is negative.\n", pParam->B4SOIcdsc); + } + if (pParam->B4SOIcdscd < 0.0) + { fprintf(fplog, "Warning: Cdscd = %g is negative.\n", + pParam->B4SOIcdscd); + printf("Warning: Cdscd = %g is negative.\n", pParam->B4SOIcdscd); + } +/* Check DIBL parameters */ + if (pParam->B4SOIeta0 < 0.0) + { fprintf(fplog, "Warning: Eta0 = %g is negative.\n", + pParam->B4SOIeta0); + printf("Warning: Eta0 = %g is negative.\n", pParam->B4SOIeta0); + } + +/* Check Abulk parameters */ + if (fabs(1.0e-6 / (pParam->B4SOIb1 + pParam->B4SOIweff)) > 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->B4SOIa2 < 0.01) + { fprintf(fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", pParam->B4SOIa2); + printf("Warning: A2 = %g is too small. Set to 0.01.\n", + pParam->B4SOIa2); + pParam->B4SOIa2 = 0.01; + } + else if (pParam->B4SOIa2 > 1.0) + { fprintf(fplog, "Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n", + pParam->B4SOIa2); + printf("Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n", + pParam->B4SOIa2); + pParam->B4SOIa2 = 1.0; + pParam->B4SOIa1 = 0.0; + + } + + if (pParam->B4SOIrdsw < 0.0) + { fprintf(fplog, "Warning: Rdsw = %g is negative. Set to zero.\n", + pParam->B4SOIrdsw); + printf("Warning: Rdsw = %g is negative. Set to zero.\n", + pParam->B4SOIrdsw); + pParam->B4SOIrdsw = 0.0; + pParam->B4SOIrds0 = 0.0; + } + else if (pParam->B4SOIrds0 < 0.001) + { fprintf(fplog, "Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n", + pParam->B4SOIrds0); + printf("Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n", + pParam->B4SOIrds0); + pParam->B4SOIrds0 = 0.0; + } + if (pParam->B4SOIvsattemp < 1.0e3) + { fprintf(fplog, "Warning: Vsat at current temperature = %g may be too small.\n", pParam->B4SOIvsattemp); + printf("Warning: Vsat at current temperature = %g may be too small.\n", pParam->B4SOIvsattemp); + } + + if (pParam->B4SOIpdibl1 < 0.0) + { fprintf(fplog, "Warning: Pdibl1 = %g is negative.\n", + pParam->B4SOIpdibl1); + printf("Warning: Pdibl1 = %g is negative.\n", pParam->B4SOIpdibl1); + } + if (pParam->B4SOIpdibl2 < 0.0) + { fprintf(fplog, "Warning: Pdibl2 = %g is negative.\n", + pParam->B4SOIpdibl2); + printf("Warning: Pdibl2 = %g is negative.\n", pParam->B4SOIpdibl2); + } +/* Check overlap capacitance parameters */ + if (model->B4SOIcgdo < 0.0) + { fprintf(fplog, "Warning: cgdo = %g is negative. Set to zero.\n", model->B4SOIcgdo); + printf("Warning: cgdo = %g is negative. Set to zero.\n", model->B4SOIcgdo); + model->B4SOIcgdo = 0.0; + } + if (model->B4SOIcgso < 0.0) + { fprintf(fplog, "Warning: cgso = %g is negative. Set to zero.\n", model->B4SOIcgso); + printf("Warning: cgso = %g is negative. Set to zero.\n", model->B4SOIcgso); + model->B4SOIcgso = 0.0; + } + if (model->B4SOIcgeo < 0.0) + { fprintf(fplog, "Warning: cgeo = %g is negative. Set to zero.\n", model->B4SOIcgeo); + printf("Warning: cgeo = %g is negative. Set to zero.\n", model->B4SOIcgeo); + model->B4SOIcgeo = 0.0; + } + + if (model->B4SOIntun < 0.0) + { fprintf(fplog, "Warning: Ntuns = %g is negative.\n", + model->B4SOIntun); + printf("Warning: Ntuns = %g is negative.\n", model->B4SOIntun); + } + + if (model->B4SOIntund < 0.0) + { fprintf(fplog, "Warning: Ntund = %g is negative.\n", + model->B4SOIntund); + printf("Warning: Ntund = %g is negative.\n", model->B4SOIntund); + } + + if (model->B4SOIndiode < 0.0) + { fprintf(fplog, "Warning: Ndiode = %g is negative.\n", + model->B4SOIndiode); + printf("Warning: Ndiode = %g is negative.\n", model->B4SOIndiode); + } + + if (model->B4SOIndioded < 0.0) + { fprintf(fplog, "Warning: Ndioded = %g is negative.\n", + model->B4SOIndioded); + printf("Warning: Ndioded = %g is negative.\n", model->B4SOIndioded); + } + + if (model->B4SOIisbjt < 0.0) + { fprintf(fplog, "Warning: Isbjt = %g is negative.\n", + model->B4SOIisbjt); + printf("Warning: Isbjt = %g is negative.\n", model->B4SOIisbjt); + } + if (model->B4SOIidbjt < 0.0) + { fprintf(fplog, "Warning: Idbjt = %g is negative.\n", + model->B4SOIidbjt); + printf("Warning: Idbjt = %g is negative.\n", model->B4SOIidbjt); + } + + if (model->B4SOIisdif < 0.0) + { fprintf(fplog, "Warning: Isdif = %g is negative.\n", + model->B4SOIisdif); + printf("Warning: Isdif = %g is negative.\n", model->B4SOIisdif); + } + if (model->B4SOIiddif < 0.0) + { fprintf(fplog, "Warning: Iddif = %g is negative.\n", + model->B4SOIiddif); + printf("Warning: Iddif = %g is negative.\n", model->B4SOIiddif); + } + + if (model->B4SOIisrec < 0.0) + { fprintf(fplog, "Warning: Isrec = %g is negative.\n", + model->B4SOIisrec); + printf("Warning: Isrec = %g is negative.\n", model->B4SOIisrec); + } + if (model->B4SOIidrec < 0.0) + { fprintf(fplog, "Warning: Idrec = %g is negative.\n", + model->B4SOIidrec); + printf("Warning: Idrec = %g is negative.\n", model->B4SOIidrec); + } + + if (model->B4SOIistun < 0.0) + { fprintf(fplog, "Warning: Istun = %g is negative.\n", + model->B4SOIistun); + printf("Warning: Istun = %g is negative.\n", model->B4SOIistun); + } + if (model->B4SOIidtun < 0.0) + { fprintf(fplog, "Warning: Idtun = %g is negative.\n", + model->B4SOIidtun); + printf("Warning: Idtun = %g is negative.\n", model->B4SOIidtun); + } + + if (model->B4SOItt < 0.0) + { fprintf(fplog, "Warning: Tt = %g is negative.\n", + model->B4SOItt); + printf("Warning: Tt = %g is negative.\n", model->B4SOItt); + } + + if (model->B4SOIcsdmin < 0.0) + { fprintf(fplog, "Warning: Csdmin = %g is negative.\n", + model->B4SOIcsdmin); + printf("Warning: Csdmin = %g is negative.\n", model->B4SOIcsdmin); + } + + if (model->B4SOIcsdesw < 0.0) + { fprintf(fplog, "Warning: Csdesw = %g is negative.\n", + model->B4SOIcsdesw); + printf("Warning: Csdesw = %g is negative.\n", model->B4SOIcsdesw); + } + + if (model->B4SOIasd < 0.0) + { fprintf(fplog, "Warning: Asd = %g should be within (0, 1).\n", + model->B4SOIasd); + printf("Warning: Asd = %g should be within (0, 1).\n", model->B4SOIasd); + } + + if (model->B4SOIrth0 < 0.0) + { fprintf(fplog, "Warning: Rth0 = %g is negative.\n", + model->B4SOIrth0); + printf("Warning: Rth0 = %g is negative.\n", model->B4SOIrth0); + } + + if (model->B4SOIcth0 < 0.0) + { fprintf(fplog, "Warning: Cth0 = %g is negative.\n", + model->B4SOIcth0); + printf("Warning: Cth0 = %g is negative.\n", model->B4SOIcth0); + } + + if (model->B4SOIrbody < 0.0) + { fprintf(fplog, "Warning: Rbody = %g is negative.\n", + model->B4SOIrbody); + printf("Warning: Rbody = %g is negative.\n", model->B4SOIrbody); + } + + if (model->B4SOIrbsh < 0.0) + { fprintf(fplog, "Warning: Rbsh = %g is negative.\n", + model->B4SOIrbsh); + printf("Warning: Rbsh = %g is negative.\n", model->B4SOIrbsh); + } + + +/* v3.0 */ + if (pParam->B4SOInigc <= 0.0) + { fprintf(fplog, "Fatal: nigc = %g is non-positive.\n", + pParam->B4SOInigc); + printf("Fatal: nigc = %g is non-positive.\n", pParam->B4SOInigc); + Fatal_Flag = 1; + } + if (pParam->B4SOIpoxedge <= 0.0) + { fprintf(fplog, "Fatal: poxedge = %g is non-positive.\n", + pParam->B4SOIpoxedge); + printf("Fatal: poxedge = %g is non-positive.\n", pParam->B4SOIpoxedge); + Fatal_Flag = 1; + } + if (pParam->B4SOIpigcd <= 0.0) + { fprintf(fplog, "Fatal: pigcd = %g is non-positive.\n", + pParam->B4SOIpigcd); + printf("Fatal: pigcd = %g is non-positive.\n", pParam->B4SOIpigcd); + Fatal_Flag = 1; + } + + +/* v2.2 release */ + if (model->B4SOIwth0 < 0.0) + { fprintf(fplog, "Warning: WTH0 = %g is negative.\n", + model->B4SOIwth0); + printf("Warning: Wth0 = %g is negative.\n", model->B4SOIwth0); + } + if (model->B4SOIrhalo < 0.0) + { fprintf(fplog, "Warning: RHALO = %g is negative.\n", + model->B4SOIrhalo); + printf("Warning: Rhalo = %g is negative.\n", model->B4SOIrhalo); + } + if (model->B4SOIntox < 0.0) + { fprintf(fplog, "Warning: NTOX = %g is negative.\n", + model->B4SOIntox); + printf("Warning: Ntox = %g is negative.\n", model->B4SOIntox); + } + if (model->B4SOItoxref < 0.0) + { fprintf(fplog, "Warning: TOXREF = %g is negative.\n", + model->B4SOItoxref); + printf("Warning: Toxref = %g is negative.\n", model->B4SOItoxref); + Fatal_Flag = 1; + } + if (model->B4SOIebg < 0.0) + { fprintf(fplog, "Warning: EBG = %g is negative.\n", + model->B4SOIebg); + printf("Warning: Ebg = %g is negative.\n", model->B4SOIebg); + } + if (model->B4SOIvevb < 0.0) + { fprintf(fplog, "Warning: VEVB = %g is negative.\n", + model->B4SOIvevb); + printf("Warning: Vevb = %g is negative.\n", model->B4SOIvevb); + } + if (pParam->B4SOIalphaGB1 < 0.0) + { fprintf(fplog, "Warning: ALPHAGB1 = %g is negative.\n", + pParam->B4SOIalphaGB1); + printf("Warning: AlphaGB1 = %g is negative.\n", pParam->B4SOIalphaGB1); + } + if (pParam->B4SOIbetaGB1 < 0.0) + { fprintf(fplog, "Warning: BETAGB1 = %g is negative.\n", + pParam->B4SOIbetaGB1); + printf("Warning: BetaGB1 = %g is negative.\n", pParam->B4SOIbetaGB1); + } + if (model->B4SOIvgb1 < 0.0) + { fprintf(fplog, "Warning: VGB1 = %g is negative.\n", + model->B4SOIvgb1); + printf("Warning: Vgb1 = %g is negative.\n", model->B4SOIvgb1); + } + if (model->B4SOIvecb < 0.0) + { fprintf(fplog, "Warning: VECB = %g is negative.\n", + model->B4SOIvecb); + printf("Warning: Vecb = %g is negative.\n", model->B4SOIvecb); + } + if (pParam->B4SOIalphaGB2 < 0.0) + { fprintf(fplog, "Warning: ALPHAGB2 = %g is negative.\n", + pParam->B4SOIalphaGB2); + printf("Warning: AlphaGB2 = %g is negative.\n", pParam->B4SOIalphaGB2); + } + if (pParam->B4SOIbetaGB2 < 0.0) + { fprintf(fplog, "Warning: BETAGB2 = %g is negative.\n", + pParam->B4SOIbetaGB2); + printf("Warning: BetaGB2 = %g is negative.\n", pParam->B4SOIbetaGB2); + } + if (model->B4SOIvgb2 < 0.0) + { fprintf(fplog, "Warning: VGB2 = %g is negative.\n", + model->B4SOIvgb2); + printf("Warning: Vgb2 = %g is negative.\n", model->B4SOIvgb2); + } + if (model->B4SOItoxqm <= 0.0) + { fprintf(fplog, "Fatal: Toxqm = %g is not positive.\n", + model->B4SOItoxqm); + printf("Fatal: Toxqm = %g is not positive.\n", model->B4SOItoxqm); + Fatal_Flag = 1; + } + if (model->B4SOIvoxh < 0.0) + { fprintf(fplog, "Warning: Voxh = %g is negative.\n", + model->B4SOIvoxh); + printf("Warning: Voxh = %g is negative.\n", model->B4SOIvoxh); + } + if (model->B4SOIdeltavox <= 0.0) + { fprintf(fplog, "Fatal: Deltavox = %g is not positive.\n", + model->B4SOIdeltavox); + printf("Fatal: Deltavox = %g is not positive.\n", model->B4SOIdeltavox); + } + + +/* v2.0 release */ + if (model->B4SOIk1w1 < 0.0) + { fprintf(fplog, "Warning: K1W1 = %g is negative.\n", + model->B4SOIk1w1); + printf("Warning: K1w1 = %g is negative.\n", model->B4SOIk1w1); + } + if (model->B4SOIk1w2 < 0.0) + { fprintf(fplog, "Warning: K1W2 = %g is negative.\n", + model->B4SOIk1w2); + printf("Warning: K1w2 = %g is negative.\n", model->B4SOIk1w2); + } + if (model->B4SOIketas < 0.0) + { fprintf(fplog, "Warning: KETAS = %g is negative.\n", + model->B4SOIketas); + printf("Warning: Ketas = %g is negative.\n", model->B4SOIketas); + } + if (model->B4SOIdwbc < 0.0) + { fprintf(fplog, "Warning: DWBC = %g is negative.\n", + model->B4SOIdwbc); + printf("Warning: Dwbc = %g is negative.\n", model->B4SOIdwbc); + } + if (model->B4SOIbeta0 < 0.0) + { fprintf(fplog, "Warning: BETA0 = %g is negative.\n", + model->B4SOIbeta0); + printf("Warning: Beta0 = %g is negative.\n", model->B4SOIbeta0); + } + if (model->B4SOIbeta1 < 0.0) + { fprintf(fplog, "Warning: BETA1 = %g is negative.\n", + model->B4SOIbeta1); + printf("Warning: Beta1 = %g is negative.\n", model->B4SOIbeta1); + } + if (model->B4SOIbeta2 < 0.0) + { fprintf(fplog, "Warning: BETA2 = %g is negative.\n", + model->B4SOIbeta2); + printf("Warning: Beta2 = %g is negative.\n", model->B4SOIbeta2); + } + if (model->B4SOItii < 0.0) + { fprintf(fplog, "Warning: TII = %g is negative.\n", + model->B4SOItii); + printf("Warning: Tii = %g is negative.\n", model->B4SOItii); + } + if (model->B4SOIlii < 0.0) + { fprintf(fplog, "Warning: LII = %g is negative.\n", + model->B4SOIlii); + printf("Warning: Lii = %g is negative.\n", model->B4SOIlii); + } + if (model->B4SOIsii1 < 0.0) + { fprintf(fplog, "Warning: SII1 = %g is negative.\n", + model->B4SOIsii1); + printf("Warning: Sii1 = %g is negative.\n", model->B4SOIsii1); + } + if (model->B4SOIsii2 < 0.0) + { fprintf(fplog, "Warning: SII2 = %g is negative.\n", + model->B4SOIsii2); + printf("Warning: Sii2 = %g is negative.\n", model->B4SOIsii1); + } + if (model->B4SOIsiid < 0.0) + { fprintf(fplog, "Warning: SIID = %g is negative.\n", + model->B4SOIsiid); + printf("Warning: Siid = %g is negative.\n", model->B4SOIsiid); + } + if (model->B4SOIfbjtii < 0.0) + { fprintf(fplog, "Warning: FBJTII = %g is negative.\n", + model->B4SOIfbjtii); + printf("Warning: fbjtii = %g is negative.\n", model->B4SOIfbjtii); + } + if (model->B4SOIvrec0 < 0.0) /* v4.0 */ + { fprintf(fplog, "Warning: VREC0S = %g is negative.\n", + model->B4SOIvrec0); + printf("Warning: Vrec0s = %g is negative.\n", model->B4SOIvrec0); + } + if (model->B4SOIvrec0d < 0.0) /* v4.0 */ + { fprintf(fplog, "Warning: VREC0D = %g is negative.\n", + model->B4SOIvrec0d); + printf("Warning: Vrec0d = %g is negative.\n", model->B4SOIvrec0d); + } + if (model->B4SOIvtun0 < 0.0) /* v4.0 */ + { fprintf(fplog, "Warning: VTUN0S = %g is negative.\n", + model->B4SOIvtun0); + printf("Warning: Vtun0s = %g is negative.\n", model->B4SOIvtun0); + } + if (model->B4SOIvtun0d < 0.0) /* v4.0 */ + { fprintf(fplog, "Warning: VTUN0D = %g is negative.\n", + model->B4SOIvtun0d); + printf("Warning: Vtun0d = %g is negative.\n", model->B4SOIvtun0d); + } + if (model->B4SOInbjt < 0.0) + { fprintf(fplog, "Warning: NBJT = %g is negative.\n", + model->B4SOInbjt); + printf("Warning: Nbjt = %g is negative.\n", model->B4SOInbjt); + } + if (model->B4SOIaely < 0.0) + { fprintf(fplog, "Warning: AELY = %g is negative.\n", + model->B4SOIaely); + printf("Warning: Aely = %g is negative.\n", model->B4SOIaely); + } + if (model->B4SOIahli < 0.0) + { fprintf(fplog, "Warning: AHLIS = %g is negative.\n", + model->B4SOIahli); + printf("Warning: Ahlis = %g is negative.\n", model->B4SOIahli); + } + if (model->B4SOIahlid < 0.0) + { fprintf(fplog, "Warning: AHLID = %g is negative.\n", + model->B4SOIahlid); + printf("Warning: Ahlid = %g is negative.\n", model->B4SOIahlid); + } + if (model->B4SOIrbody < 0.0) + { fprintf(fplog, "Warning: RBODY = %g is negative.\n", + model->B4SOIrbody); + printf("Warning: Rbody = %g is negative.\n", model->B4SOIrbody); + } + if (model->B4SOIrbsh < 0.0) + { fprintf(fplog, "Warning: RBSH = %g is negative.\n", + model->B4SOIrbsh); + printf("Warning: Rbsh = %g is negative.\n", model->B4SOIrbsh); + } + if (pParam->B4SOIntrecf < 0.0) + { fprintf(fplog, "Warning: NTRECF = %g is negative.\n", + pParam->B4SOIntrecf); + printf("Warning: Ntrecf = %g is negative.\n", pParam->B4SOIntrecf); + } + if (pParam->B4SOIntrecr < 0.0) + { fprintf(fplog, "Warning: NTRECR = %g is negative.\n", + pParam->B4SOIntrecr); + printf("Warning: Ntrecr = %g is negative.\n", pParam->B4SOIntrecr); + } + +/* v3.0 bug fix */ +/* + if (model->B4SOIndif < 0.0) + { fprintf(fplog, "Warning: NDIF = %g is negative.\n", + model->B4SOIndif); + printf("Warning: Ndif = %g is negative.\n", model->B4SOIndif); + } +*/ + + if (model->B4SOItcjswg < 0.0) + { fprintf(fplog, "Warning: TCJSWGS = %g is negative.\n", + model->B4SOItcjswg); + printf("Warning: Tcjswg = %g is negative.\n", model->B4SOItcjswg); + } + if (model->B4SOItpbswg < 0.0) + { fprintf(fplog, "Warning: TPBSWGS = %g is negative.\n", + model->B4SOItpbswg); + printf("Warning: Tpbswg = %g is negative.\n", model->B4SOItpbswg); + } + if (model->B4SOItcjswgd < 0.0) + { fprintf(fplog, "Warning: TCJSWGD = %g is negative.\n", + model->B4SOItcjswgd); + printf("Warning: Tcjswgd = %g is negative.\n", model->B4SOItcjswgd); + } + if (model->B4SOItpbswgd < 0.0) + { fprintf(fplog, "Warning: TPBSWGD = %g is negative.\n", + model->B4SOItpbswgd); + printf("Warning: Tpbswgd = %g is negative.\n", model->B4SOItpbswgd); + } + if ((model->B4SOIacde < 0.1) || (model->B4SOIacde > 1.6)) + { fprintf(fplog, "Warning: ACDE = %g is out of range.\n", + model->B4SOIacde); + printf("Warning: Acde = %g is out of range.\n", model->B4SOIacde); + } + if ((model->B4SOImoin < 5.0)||(model->B4SOImoin > 25.0)) + { fprintf(fplog, "Warning: MOIN = %g is out of range.\n", + model->B4SOImoin); + printf("Warning: Moin = %g is out of range.\n", model->B4SOImoin); + } + if (model->B4SOIdlbg < 0.0) + { fprintf(fplog, "Warning: DLBG = %g is negative.\n", + model->B4SOIdlbg); + printf("Warning: dlbg = %g is negative.\n", model->B4SOIdlbg); + } + + + if (model->B4SOIagidl < 0.0) + { fprintf(fplog, "Warning: AGIDL = %g is negative.\n", + model->B4SOIagidl); + printf("Warning: Agidl = %g is negative.\n", model->B4SOIagidl); + } + if (model->B4SOIbgidl < 0.0) + { fprintf(fplog, "Warning: BGIDL = %g is negative.\n", + model->B4SOIbgidl); + printf("Warning: Bgidl = %g is negative.\n", model->B4SOIbgidl); + } + if (fabs(model->B4SOIcgidl) < 1e-9) + { fprintf(fplog, "Warning: CGIDL = %g is smaller than 1e-9.\n", + model->B4SOIcgidl); + printf("Warning: Cgidl = %g is smaller than 1e-9.\n", + model->B4SOIcgidl); + } + if (model->B4SOIegidl < 0.0) + { fprintf(fplog, "Warning: EGIDL = %g is negative.\n", + model->B4SOIegidl); + printf("Warning: Egidl = %g is negative.\n", model->B4SOIegidl); + } + if (model->B4SOIesatii < 0.0) + { fprintf(fplog, "Warning: Esatii = %g should be within positive.\n", + model->B4SOIesatii); + printf("Warning: Esatii = %g should be within (0, 1).\n", model->B4SOIesatii); + } + + + if (pParam->B4SOIxj > model->B4SOItsi) + { fprintf(fplog, "Warning: Xj = %g is thicker than Tsi = %g.\n", + pParam->B4SOIxj, model->B4SOItsi); + printf("Warning: Xj = %g is thicker than Tsi = %g.\n", + pParam->B4SOIxj, model->B4SOItsi); + } + + if (model->B4SOIcapMod < 2) + { fprintf(fplog, "Warning: capMod < 2 is not supported by BSIM3SOI.\n"); + printf("Warning: Warning: capMod < 2 is not supported by BSIM3SOI.\n"); + } + + }/* loop for the parameter check for warning messages */ + fclose(fplog); + } + else + { fprintf(stderr, "Warning: Can't open log file. Parameter checking skipped.\n"); + } + + return(Fatal_Flag); +} + diff --git a/src/spicelib/devices/bsim3soi/b4soicvtest.c b/src/spicelib/devices/bsim3soi/b4soicvtest.c new file mode 100644 index 000000000..11a1cd877 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soicvtest.c @@ -0,0 +1,95 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soicvtest.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soicvtest.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "cktdefs.h" +#include "b4soidef.h" +#include "trandefs.h" +#include "const.h" +#include "devdefs.h" +#include "sperror.h" +#include "suffix.h" + + +int +B4SOIconvTest(GENmodel *inModel, CKTcircuit *ckt) +{ +register B4SOImodel *model = (B4SOImodel*)inModel; +register B4SOIinstance *here; +double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds; +double cbd, cbhat, cbs, cd, cdhat, tol, vgd, vgdo, vgs; + + /* loop through all the B4SOI device models */ + for (; model != NULL; model = model->B4SOInextModel) + { /* loop through all the instances of the model */ + for (here = model->B4SOIinstances; here != NULL ; + here=here->B4SOInextInstance) + { + + if (here->B4SOIowner != ARCHme) + continue; + + vbs = model->B4SOItype + * (*(ckt->CKTrhsOld+here->B4SOIbNode) + - *(ckt->CKTrhsOld+here->B4SOIsNodePrime)); + vgs = model->B4SOItype + * (*(ckt->CKTrhsOld+here->B4SOIgNode) + - *(ckt->CKTrhsOld+here->B4SOIsNodePrime)); + vds = model->B4SOItype + * (*(ckt->CKTrhsOld+here->B4SOIdNodePrime) + - *(ckt->CKTrhsOld+here->B4SOIsNodePrime)); + vbd = vbs - vds; + vgd = vgs - vds; + vgdo = *(ckt->CKTstate0 + here->B4SOIvgs) + - *(ckt->CKTstate0 + here->B4SOIvds); + delvbs = vbs - *(ckt->CKTstate0 + here->B4SOIvbs); + delvbd = vbd - *(ckt->CKTstate0 + here->B4SOIvbd); + delvgs = vgs - *(ckt->CKTstate0 + here->B4SOIvgs); + delvds = vds - *(ckt->CKTstate0 + here->B4SOIvds); + delvgd = vgd-vgdo; + + cd = here->B4SOIcd; + if (here->B4SOImode >= 0) + { cdhat = cd - here->B4SOIgjdb * delvbd + + here->B4SOIgmbs * delvbs + here->B4SOIgm * delvgs + + here->B4SOIgds * delvds; + } + else + { cdhat = cd - (here->B4SOIgjdb - here->B4SOIgmbs) * delvbd + - here->B4SOIgm * delvgd + here->B4SOIgds * delvds; + } + + /* + * check convergence + */ + if ((here->B4SOIoff == 0) || (!(ckt->CKTmode & MODEINITFIX))) + { tol = ckt->CKTreltol * MAX(fabs(cdhat), fabs(cd)) + + ckt->CKTabstol; + if (fabs(cdhat - cd) >= tol) + { ckt->CKTnoncon++; + return(OK); + } + cbs = here->B4SOIcjs; + cbd = here->B4SOIcjd; + cbhat = cbs + cbd + here->B4SOIgjdb * delvbd + + here->B4SOIgjsb * delvbs; + tol = ckt->CKTreltol * MAX(fabs(cbhat), fabs(cbs + cbd)) + + ckt->CKTabstol; + if (fabs(cbhat - (cbs + cbd)) > tol) + { ckt->CKTnoncon++; + return(OK); + } + } + } + } + return(OK); +} + diff --git a/src/spicelib/devices/bsim3soi/b4soidef.h b/src/spicelib/devices/bsim3soi/b4soidef.h new file mode 100644 index 000000000..c252b9c3b --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soidef.h @@ -0,0 +1,3556 @@ +/********** +Copyright 2005 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung +authors:1999-2004 Pin Su, Hui Wan b3soidef.h +Authors:2005- Hui Wan, Jane Xi +File: b4soidef.h +**********/ + +#ifndef B4SOI +#define B4SOI + +#define SOICODE +/* #define BULKCODE */ + +#include "ifsim.h" +#include "gendefs.h" +#include "cktdefs.h" +#include "complex.h" +#include "noisedef.h" + +typedef struct sB4SOIinstance +{ + struct sB4SOImodel *B4SOImodPtr; + struct sB4SOIinstance *B4SOInextInstance; + IFuid B4SOIname; + int B4SOIowner; /* number of owner process */ + int B4SOIstates; /* index into state table for this device */ + + int B4SOIdNode; + int B4SOIgNodeExt; /* v3.1 changed gNode to gNodeExt */ + int B4SOIsNode; + int B4SOIeNode; + int B4SOIpNode; + int B4SOIbNode; + int B4SOItempNode; + int B4SOIdNodePrime; + int B4SOIsNodePrime; + int B4SOIgNode; /* v3.1 */ + int B4SOIgNodeMid; /* v3.1 */ + int B4SOIdbNode; /* v4.0 */ + int B4SOIsbNode; /* v4.0 */ + + int B4SOIvbsNode; + /* for Debug */ + int B4SOIidsNode; + int B4SOIicNode; + int B4SOIibsNode; + int B4SOIibdNode; + int B4SOIiiiNode; + int B4SOIigNode; + int B4SOIgiggNode; + int B4SOIgigdNode; + int B4SOIgigbNode; + int B4SOIigidlNode; + int B4SOIitunNode; + int B4SOIibpNode; + int B4SOIcbbNode; + int B4SOIcbdNode; + int B4SOIcbgNode; + + int B4SOIqbfNode; + int B4SOIqjsNode; + int B4SOIqjdNode; + + double B4SOIphi; + double B4SOIvtm; + double B4SOIni; + double B4SOIueff; + double B4SOIthetavth; + double B4SOIvon; + double B4SOIvdsat; + double B4SOIcgdo; + double B4SOIcgso; + double B4SOIcgeo; + + double B4SOIids; + double B4SOIic; + double B4SOIibs; + double B4SOIibd; + double B4SOIiii; + double B4SOIig; + double B4SOIgigg; + double B4SOIgigd; + double B4SOIgigb; + double B4SOIgige; /* v3.0 */ +/* v3.1 added for RF */ + double B4SOIgcrg; + double B4SOIgcrgd; + double B4SOIgcrgg; + double B4SOIgcrgs; + double B4SOIgcrgb; +/* v3.1 added for end */ + + double B4SOIInv_ODeff; /* v4.0 */ + double B4SOIkvsat; /* v4.0 */ + double B4SOIgrbsb; /* v4.0 */ + double B4SOIgrbdb; /* v4.0 */ + double B4SOIrbsb; /* v4.0 */ + double B4SOIrbdb; /* v4.0 */ + double B4SOIGGjdb; /* v4.0 */ + double B4SOIGGjsb; /* v4.0 */ + double B4SOIgbgiigbpb; /* v4.0 */ + double B4SOIgiigidlb; /* v4.0 */ + double B4SOIgiigidld; /* v4.0 */ + double B4SOIdelvto; /* v4.0 */ + double B4SOIgstot; /* v4.0 for rdsmod */ + double B4SOIgstotd; /* v4.0 for rdsmod */ + double B4SOIgstotg; /* v4.0 for rdsmod */ + double B4SOIgstots; /* v4.0 for rdsmod */ + double B4SOIgstotb; /* v4.0 for rdsmod */ + + double B4SOIgdtot; /* v4.0 for rdsmod */ + double B4SOIgdtotd; /* v4.0 for rdsmod */ + double B4SOIgdtotg; /* v4.0 for rdsmod */ + double B4SOIgdtots; /* v4.0 for rdsmod */ + double B4SOIgdtotb; /* v4.0 for rdsmod */ + + double B4SOIigidl; + double B4SOIitun; + double B4SOIibp; + double B4SOIabeff; + double B4SOIvbseff; + double B4SOIcbg; + double B4SOIcbb; + double B4SOIcbd; + double B4SOIqb; + double B4SOIqbf; + double B4SOIqjs; + double B4SOIqjd; + int B4SOIfloat; + +/* v3.1 for RF */ + double B4SOIgrgeltd; +/* v3.1 for RF end */ + + double B4SOIl; + double B4SOIw; + double B4SOIm; + double B4SOIdrainArea; + double B4SOIsourceArea; + double B4SOIdrainSquares; + double B4SOIsourceSquares; + double B4SOIdrainPerimeter; + double B4SOIsourcePerimeter; + double B4SOIsourceConductance; + double B4SOIdrainConductance; + +/* v4.0 stress effect instance param */ + double B4SOIsa; + double B4SOIsb; + double B4SOIsd; + double B4SOIu0temp; + double B4SOIvsattemp; + double B4SOIvth0; + double B4SOIvfb; + double B4SOIvfbzb; + double B4SOIk2; + double B4SOIk2ox; + double B4SOIeta0; +/* end of v4.0 stress effect instance param */ + + double B4SOIicVBS; + double B4SOIicVDS; + double B4SOIicVGS; + double B4SOIicVES; + double B4SOIicVPS; + + int B4SOIbjtoff; + int B4SOIbodyMod; + int B4SOIdebugMod; + double B4SOIrth0; + double B4SOIcth0; + double B4SOIbodySquares; + double B4SOIrbodyext; + double B4SOIfrbody; + +/* v2.0 release */ + double B4SOInbc; + double B4SOInseg; + double B4SOIpdbcp; + double B4SOIpsbcp; + double B4SOIagbcp; + double B4SOIagbcpd; /* v4.0 */ + double B4SOIaebcp; + double B4SOIvbsusr; + int B4SOItnodeout; + +/* Deleted from pParam and moved to here */ + double B4SOIcsesw; + double B4SOIcdesw; + double B4SOIcsbox; + double B4SOIcdbox; + double B4SOIcsmin; + double B4SOIcdmin; + double B4SOIst4; + double B4SOIdt4; + + int B4SOIoff; + int B4SOImode; + +/* v4.0 added */ + double B4SOInf; +/* v4.0 added end */ + +/* v3.2 added */ + double B4SOInstar; + double B4SOIAbulk; +/* v3.2 added end */ + int B4SOIsoiMod; /* v3.2 */ + +/* v3.1 for RF */ + int B4SOIrgateMod; +/* v3.1 for RF end */ +/* v4.0 */ + int B4SOIrbodyMod; +/* v4.0 end */ + + /* OP point */ + double B4SOIqinv; + double B4SOIcd; + double B4SOIcjs; + double B4SOIcjd; + double B4SOIcbody; + double B4SOIcbs; + double B4SOIIgb; + + +/* v2.2 release */ + double B4SOIcgate; + double B4SOIgigs; + double B4SOIgigT; + + double B4SOIcbodcon; + double B4SOIcth; + double B4SOIcsubstrate; + + double B4SOIgm; + double B4SOIgme; /* v3.0 */ + double B4SOIcb; + double B4SOIcdrain; + double B4SOIgds; + double B4SOIgmbs; + double B4SOIgmT; + + double B4SOIgbbs; + double B4SOIgbgs; + double B4SOIgbds; + double B4SOIgbes; /* v3.0 */ + double B4SOIgbps; + double B4SOIgbT; + +/* v3.0 */ + double B4SOIIgcs; + double B4SOIgIgcsg; + double B4SOIgIgcsd; + double B4SOIgIgcss; + double B4SOIgIgcsb; + double B4SOIIgcd; + double B4SOIgIgcdg; + double B4SOIgIgcdd; + double B4SOIgIgcds; + double B4SOIgIgcdb; + + double B4SOIIgs; + double B4SOIgIgsg; + double B4SOIgIgss; + double B4SOIIgd; + double B4SOIgIgdg; + double B4SOIgIgdd; + + + double B4SOIgjsd; + double B4SOIgjsb; + double B4SOIgjsg; + double B4SOIgjsT; + + double B4SOIgjdb; + double B4SOIgjdd; + double B4SOIgjdg; + double B4SOIgjde; /* v3.0 */ + double B4SOIgjdT; + + double B4SOIgbpbs; + double B4SOIgbpps; + double B4SOIgbpT; + + double B4SOIgtempb; + double B4SOIgtempg; + double B4SOIgtempd; + double B4SOIgtempe; /* v3.0 */ + double B4SOIgtempT; + + double B4SOIqgate; + double B4SOIqdrn; + double B4SOIqsrc; + double B4SOIqbulk; + double B4SOIcapbd; + double B4SOIcapbs; + + + double B4SOIcggb; + double B4SOIcgdb; + double B4SOIcgsb; + double B4SOIcgT; + + double B4SOIcbgb; + double B4SOIcbdb; + double B4SOIcbsb; + double B4SOIcbeb; + double B4SOIcbT; + + double B4SOIcdgb; + double B4SOIcddb; + double B4SOIcdsb; + double B4SOIcdeb; + double B4SOIcdT; + + double B4SOIceeb; + double B4SOIceT; + + double B4SOIqse; + double B4SOIgcse; + double B4SOIqde; + double B4SOIgcde; + double B4SOIrds; /* v2.2.3 */ + double B4SOIVgsteff; /* v2.2.3 */ + double B4SOIVdseff; /* v2.2.3 */ + double B4SOIAbovVgst2Vtm; /* v2.2.3 */ + +/* 4.0 */ + double B4SOIidovVds; + double B4SOIcjsb; + double B4SOIcjdb; + +/* 4.0 end */ + + struct b4soiSizeDependParam *pParam; + + unsigned B4SOIlGiven :1; + unsigned B4SOIwGiven :1; + unsigned B4SOImGiven :1; + unsigned B4SOIdrainAreaGiven :1; + unsigned B4SOIsourceAreaGiven :1; + unsigned B4SOIdrainSquaresGiven :1; + unsigned B4SOIsourceSquaresGiven :1; + unsigned B4SOIdrainPerimeterGiven :1; + unsigned B4SOIsourcePerimeterGiven :1; + unsigned B4SOIdNodePrimeSet :1; + unsigned B4SOIsNodePrimeSet :1; + unsigned B4SOIsaGiven :1; /* v4.0 for stress */ + unsigned B4SOIsbGiven :1; /* v4.0 for stress */ + unsigned B4SOIsdGiven :1; /* v4.0 for stress */ + unsigned B4SOIrbdbGiven :1; /* v4.0 for rbody network */ + unsigned B4SOIrbsbGiven :1; /* v4.0 for rbody network */ + + unsigned B4SOIicVBSGiven :1; + unsigned B4SOIicVDSGiven :1; + unsigned B4SOIicVGSGiven :1; + unsigned B4SOIicVESGiven :1; + unsigned B4SOIicVPSGiven :1; + unsigned B4SOIbjtoffGiven :1; + unsigned B4SOIdebugModGiven :1; + unsigned B4SOIrth0Given :1; + unsigned B4SOIcth0Given :1; + unsigned B4SOIbodySquaresGiven :1; + unsigned B4SOIfrbodyGiven: 1; + +/* v2.0 release */ + unsigned B4SOInbcGiven :1; + unsigned B4SOInsegGiven :1; + unsigned B4SOIpdbcpGiven :1; + unsigned B4SOIpsbcpGiven :1; + unsigned B4SOIagbcpGiven :1; + unsigned B4SOIagbcpdGiven :1; /* v4.0 */ + unsigned B4SOIaebcpGiven :1; + unsigned B4SOIvbsusrGiven :1; + unsigned B4SOItnodeoutGiven :1; + unsigned B4SOIoffGiven :1; + + unsigned B4SOIrgateModGiven :1; /* v3.1 */ + unsigned B4SOIsoiModGiven :1; /* v3.2 */ + +/* v4.0 added */ + unsigned B4SOInfGiven :1; + unsigned B4SOIrbodyModGiven :1; + unsigned B4SOIdelvtoGiven :1; +/* v4.0 added end */ + +/* v4.0 */ + double *B4SOIDBdpPtr; + double *B4SOIDBdbPtr; + double *B4SOIDBbPtr; + double *B4SOIDPdbPtr; + + double *B4SOISBspPtr; + double *B4SOISBbPtr; + double *B4SOISBsbPtr; + double *B4SOISPsbPtr; + + double *B4SOIBsbPtr; + double *B4SOIBdbPtr; + + double *B4SOIDgPtr; /* v4.0 for rdsMod =1 */ + double *B4SOIDspPtr; /* v4.0 for rdsMod =1 */ + double *B4SOIDbPtr; /* v4.0 for rdsMod =1 */ + double *B4SOISdpPtr; /* v4.0 for rdsMod =1 */ + double *B4SOISgPtr; /* v4.0 for rdsMod =1 */ + double *B4SOISbPtr; /* v4.0 for rdsMod =1 */ +/* v4.0 end */ + +/* v3.1 added for RF */ + double *B4SOIGgmPtr; + double *B4SOIGgePtr; + + double *B4SOIGMdpPtr; + double *B4SOIGMgPtr; + double *B4SOIGMspPtr; + double *B4SOIGMgmPtr; + double *B4SOIGMgePtr; + double *B4SOIGMePtr; + double *B4SOIGMbPtr; + + double *B4SOISPgmPtr; + double *B4SOIDPgmPtr; + double *B4SOIEgmPtr; + + double *B4SOIGEdpPtr; + double *B4SOIGEgPtr; + double *B4SOIGEgmPtr; + double *B4SOIGEgePtr; + double *B4SOIGEspPtr; + double *B4SOIGEbPtr; +/* v3.1 added for RF end */ + + double *B4SOIGePtr; + double *B4SOIDPePtr; + double *B4SOISPePtr; + + double *B4SOIEePtr; + double *B4SOIEbPtr; + double *B4SOIBePtr; + double *B4SOIEgPtr; + double *B4SOIEdpPtr; + double *B4SOIEspPtr; + double *B4SOITemptempPtr; + double *B4SOITempdpPtr; + double *B4SOITempspPtr; + double *B4SOITempgPtr; + double *B4SOITempbPtr; + double *B4SOITempePtr; /* v3.0 */ + double *B4SOIGtempPtr; + double *B4SOIDPtempPtr; + double *B4SOISPtempPtr; + double *B4SOIEtempPtr; + double *B4SOIBtempPtr; + double *B4SOIPtempPtr; + double *B4SOIBpPtr; + double *B4SOIPbPtr; + double *B4SOIPpPtr; + double *B4SOIDdPtr; + double *B4SOIGgPtr; + double *B4SOISsPtr; + double *B4SOIBbPtr; + double *B4SOIDPdpPtr; + double *B4SOISPspPtr; + double *B4SOIDdpPtr; + double *B4SOIGbPtr; + double *B4SOIGdpPtr; + double *B4SOIGspPtr; + double *B4SOISspPtr; + double *B4SOIBdpPtr; + double *B4SOIBspPtr; + double *B4SOIDPspPtr; + double *B4SOIDPdPtr; + double *B4SOIBgPtr; + double *B4SOIDPgPtr; + double *B4SOISPgPtr; + double *B4SOISPsPtr; + double *B4SOIDPbPtr; + double *B4SOISPbPtr; + double *B4SOISPdpPtr; + + double *B4SOIVbsPtr; + /* Debug */ + double *B4SOIIdsPtr; + double *B4SOIIcPtr; + double *B4SOIIbsPtr; + double *B4SOIIbdPtr; + double *B4SOIIiiPtr; + double *B4SOIIgPtr; + double *B4SOIGiggPtr; + double *B4SOIGigdPtr; + double *B4SOIGigbPtr; + double *B4SOIIgidlPtr; + double *B4SOIItunPtr; + double *B4SOIIbpPtr; + double *B4SOICbbPtr; + double *B4SOICbdPtr; + double *B4SOICbgPtr; + double *B4SOIqbPtr; + double *B4SOIQbfPtr; + double *B4SOIQjsPtr; + double *B4SOIQjdPtr; + + +#define B4SOIvbd B4SOIstates+ 0 +#define B4SOIvbs B4SOIstates+ 1 +#define B4SOIvgs B4SOIstates+ 2 +#define B4SOIvds B4SOIstates+ 3 +#define B4SOIves B4SOIstates+ 4 +#define B4SOIvps B4SOIstates+ 5 + +#define B4SOIvg B4SOIstates+ 6 +#define B4SOIvd B4SOIstates+ 7 +#define B4SOIvs B4SOIstates+ 8 +#define B4SOIvp B4SOIstates+ 9 +#define B4SOIve B4SOIstates+ 10 +#define B4SOIdeltemp B4SOIstates+ 11 + +#define B4SOIqb B4SOIstates+ 12 +#define B4SOIcqb B4SOIstates+ 13 +#define B4SOIqg B4SOIstates+ 14 +#define B4SOIcqg B4SOIstates+ 15 +#define B4SOIqd B4SOIstates+ 16 +#define B4SOIcqd B4SOIstates+ 17 +#define B4SOIqe B4SOIstates+ 18 +#define B4SOIcqe B4SOIstates+ 19 + +#define B4SOIqbs B4SOIstates+ 20 +#define B4SOIcqbs B4SOIstates+ 21 /* v4.0 */ +#define B4SOIqbd B4SOIstates+ 22 +#define B4SOIcqbd B4SOIstates+ 23 /* v4.0 */ +#define B4SOIqbe B4SOIstates+ 24 + +#define B4SOIqth B4SOIstates+ 25 +#define B4SOIcqth B4SOIstates+ 26 + +/* v3.1 added or changed for RF */ +#define B4SOIvges B4SOIstates+ 27 +#define B4SOIvgms B4SOIstates+ 28 +#define B4SOIvgge B4SOIstates+ 29 +#define B4SOIvggm B4SOIstates+ 30 +#define B4SOIcqgmid B4SOIstates+ 31 +#define B4SOIqgmid B4SOIstates + 32 +/* v3.1 added or changed for RF end */ + +/* v4.0 */ +#define B4SOIvdbs B4SOIstates + 33 +#define B4SOIvdbd B4SOIstates + 34 +#define B4SOIvsbs B4SOIstates + 35 +#define B4SOIvses B4SOIstates + 36 +#define B4SOIvdes B4SOIstates + 37 +/* v4.0 end */ + +#define B4SOInumStates 38 + +/* indices to the array of B4SOI NOISE SOURCES */ + +#define B4SOIRDNOIZ 0 +#define B4SOIRSNOIZ 1 +#define B4SOIRGNOIZ 2 +#define B4SOIIDNOIZ 3 +#define B4SOIFLNOIZ 4 +#define B4SOIFB_IBSNOIZ 5 /* v4.0 */ +#define B4SOIFB_IBDNOIZ 6 /* v4.0 */ +#define B4SOIIGSNOIZ 7 +#define B4SOIIGDNOIZ 8 +#define B4SOIIGBNOIZ 9 +#define B4SOIRBSBNOIZ 10 /* v4.0 */ +#define B4SOIRBDBNOIZ 11 /* v4.0 */ +#define B4SOIRBODYNOIZ 12 /* v4.0 */ +#define B4SOITOTNOIZ 13 /* v4.0 */ + +#define B4SOINSRCS 14 /* Number of MOSFET(3) noise sources v3.2 */ + +#ifndef NONOISE + double B4SOInVar[NSTATVARS][B4SOINSRCS]; +#else /* NONOISE */ + double **B4SOInVar; +#endif /* NONOISE */ + +} B4SOIinstance ; + +struct b4soiSizeDependParam +{ + double Width; + double Length; + double Rth0; + double Cth0; + + double B4SOIcdsc; + double B4SOIcdscb; + double B4SOIcdscd; + double B4SOIcit; + double B4SOInfactor; + double B4SOIvsat; + double B4SOIat; + double B4SOIa0; + double B4SOIags; + double B4SOIa1; + double B4SOIa2; + double B4SOIketa; + double B4SOInpeak; + double B4SOInsub; + double B4SOIngate; + double B4SOIgamma1; + double B4SOIgamma2; + double B4SOIvbx; + double B4SOIvbi; + double B4SOIvbm; + double B4SOIvbsc; + double B4SOIxt; + double B4SOIphi; + double B4SOIlitl; + double B4SOIk1; + double B4SOIkt1; + double B4SOIkt1l; + double B4SOIkt2; + double B4SOIk2; + double B4SOIk3; + double B4SOIk3b; + double B4SOIw0; + double B4SOIlpe0; + double B4SOIdvt0; + double B4SOIdvt1; + double B4SOIdvt2; + double B4SOIdvt0w; + double B4SOIdvt1w; + double B4SOIdvt2w; + double B4SOIdrout; + double B4SOIdsub; + double B4SOIvth0; + double B4SOIua; + double B4SOIua1; + double B4SOIub; + double B4SOIub1; + double B4SOIuc; + double B4SOIuc1; + double B4SOIu0; + double B4SOIute; + double B4SOIvoff; + double B4SOIvfb; + double B4SOIuatemp; + double B4SOIubtemp; + double B4SOIuctemp; + double B4SOIrbody; + double B4SOIrth; + double B4SOIcth; + double B4SOIrds0denom; + double B4SOIvfbb; + double B4SOIjbjts; /* v4.0 */ + double B4SOIjbjtd; /* v4.0 */ + double B4SOIjdifs; /* v4.0 */ + double B4SOIjdifd; /* v4.0 */ + double B4SOIjrecs; /* v4.0 */ + double B4SOIjrecd; /* v4.0 */ + double B4SOIjtuns; /* v4.0 */ + double B4SOIjtund; /* v4.0 */ + double B4SOIrdw; /* v4.0 for rdsMod = 1 */ + double B4SOIrsw; /* v4.0 for rdsMod = 1 */ + double B4SOIrdwmin; /* v4.0 for rdsMod = 1 */ + double B4SOIrswmin; /* v4.0 for rdsMod = 1 */ + double B4SOIrd0; /* v4.0 for rdsMod = 1 */ + double B4SOIrs0; /* v4.0 for rdsMod = 1 */ + double B4SOIsdt1; + double B4SOIst2; + double B4SOIst3; + double B4SOIdt2; + double B4SOIdt3; + double B4SOIdelta; + double B4SOIrdsw; + double B4SOIrds0; + double B4SOIprwg; + double B4SOIprwb; + double B4SOIprt; + double B4SOIeta0; + double B4SOIetab; + double B4SOIpclm; + double B4SOIpdibl1; + double B4SOIpdibl2; + double B4SOIpdiblb; + double B4SOIpvag; + double B4SOIwr; + double B4SOIdwg; + double B4SOIdwb; + double B4SOIb0; + double B4SOIb1; + double B4SOIalpha0; + double B4SOIbeta0; + +/* v3.0 */ + double B4SOIaigc; + double B4SOIbigc; + double B4SOIcigc; + double B4SOIaigsd; + double B4SOIbigsd; + double B4SOIcigsd; + double B4SOInigc; + double B4SOIpigcd; + double B4SOIpoxedge; + double B4SOIdlcig; + +/* v3.1 added for RF */ + double B4SOIxrcrg1; + double B4SOIxrcrg2; +/* v3.1 added for RF end */ + +/* v4.0 */ + /* added for stress effect */ + double B4SOIku0; + double B4SOIkvth0; + double B4SOIku0temp; + double B4SOIrho_ref; + double B4SOIinv_od_ref; + /* added for stress effect end */ + double NFinger; +/* v4.0 end */ + + + /* CV model */ + double B4SOIcgsl; + double B4SOIcgdl; + double B4SOIckappa; + double B4SOIcf; + double B4SOIclc; + double B4SOIcle; + + +/* Added for binning - START0 */ +/* v3.1 */ + double B4SOIxj; + double B4SOIalphaGB1; + double B4SOIbetaGB1; + double B4SOIalphaGB2; + double B4SOIbetaGB2; + double B4SOIndif; + double B4SOIntrecf; + double B4SOIntrecr; + double B4SOIxbjt; + double B4SOIxdif; + double B4SOIxrec; + double B4SOIxtun; + double B4SOIxdifd; + double B4SOIxrecd; + double B4SOIxtund; + + double B4SOIkb1; + double B4SOIk1w1; + double B4SOIk1w2; + double B4SOIketas; + double B4SOIfbjtii; + double B4SOIbeta1; + double B4SOIbeta2; + double B4SOIvdsatii0; + double B4SOIlii; + double B4SOIesatii; + double B4SOIsii0; + double B4SOIsii1; + double B4SOIsii2; + double B4SOIsiid; + double B4SOIagidl; + double B4SOIbgidl; + double B4SOIcgidl; /* v4.0 */ + double B4SOIegidl; + double B4SOIntun; /* v4.0 */ + double B4SOIntund; /* v4.0 */ + double B4SOIndiode; /* v4.0 */ + double B4SOIndioded; /* v4.0 */ + double B4SOInrecf0; /* v4.0 */ + double B4SOInrecf0d; /* v4.0 */ + double B4SOInrecr0; /* v4.0 */ + double B4SOInrecr0d; /* v4.0 */ + double B4SOIisbjt; + double B4SOIidbjt; /* v4.0 */ + double B4SOIisdif; + double B4SOIiddif; /* v4.0 */ + double B4SOIisrec; + double B4SOIidrec; /* v4.0 */ + double B4SOIistun; + double B4SOIidtun; /* v4.0 */ + double B4SOIvrec0; /* v4.0 */ + double B4SOIvrec0d; /* v4.0 */ + double B4SOIvtun0; /* v4.0 */ + double B4SOIvtun0d; /* v4.0 */ + double B4SOInbjt; + double B4SOIlbjt0; + double B4SOIvabjt; + double B4SOIaely; + double B4SOIvsdfb; + double B4SOIvsdth; + double B4SOIdelvt; +/* Added by binning - END0 */ + +/* Pre-calculated constants */ + + double B4SOIdw; + double B4SOIdl; + double B4SOIleff; + double B4SOIweff; + + double B4SOIdwc; + double B4SOIdlc; + double B4SOIleffCV; + double B4SOIweffCV; + + double B4SOIabulkCVfactor; + double B4SOIcgso; + double B4SOIcgdo; + double B4SOIcgeo; + + double B4SOIu0temp; + double B4SOIvsattemp; + double B4SOIsqrtPhi; + double B4SOIphis3; + double B4SOIXdep0; + double B4SOIsqrtXdep0; + double B4SOItheta0vb0; + double B4SOIthetaRout; + + +/* v3.2 */ + double B4SOIqsi; + +/* v2.2 release */ + double B4SOIoxideRatio; + + +/* v2.0 release */ + double B4SOIk1eff; + double B4SOIwdios; + double B4SOIwdiod; + double B4SOIwdiodCV; + double B4SOIwdiosCV; + double B4SOIarfabjt; + double B4SOIlratio; + double B4SOIlratiodif; + double B4SOIvearly; + double B4SOIahli; /* v4.0 */ + double B4SOIahlid; /* v4.0 */ + double B4SOIahli0s; /* v4.0 */ + double B4SOIahli0d; /* v4.0 */ + double B4SOIvfbzb; + double B4SOIldeb; + double B4SOIacde; + double B4SOImoin; + double B4SOInoff; /* v3.2 */ + double B4SOIleffCVb; + double B4SOIleffCVbg; + + double B4SOIcof1; + double B4SOIcof2; + double B4SOIcof3; + double B4SOIcof4; + double B4SOIcdep0; +/* v3.0 */ + double B4SOIToxRatio; + double B4SOIAechvb; + double B4SOIBechvb; + double B4SOIToxRatioEdge; + double B4SOIAechvbEdge; + double B4SOIBechvbEdge; + double B4SOIvfbsd; +/* v4.0 */ + double B4SOIk1ox; /* v4.0 for Vth */ + double B4SOIk2ox; /* v4.0 for Vth */ + double B4SOIlpeb; /* v4.0 for Vth */ + double B4SOIdvtp0; /* v4.0 for Vth */ + double B4SOIdvtp1; /* v4.0 for Vth */ + double B4SOIminv; /* v4.0 for Vgsteff */ + double B4SOImstar; /* v4.0 for Vgsteff */ + double B4SOIfprout; /* v4.0 for DITS in Id */ + double B4SOIpdits; /* v4.0 for DITS in Id */ + double B4SOIpditsd; /* v4.0 for DITS in Id */ + + struct b4soiSizeDependParam *pNext; +}; + + +typedef struct sB4SOImodel +{ + int B4SOImodType; + struct sB4SOImodel *B4SOInextModel; + B4SOIinstance *B4SOIinstances; + IFuid B4SOImodName; + int B4SOItype; + + int B4SOImobMod; + int B4SOIcapMod; + int B4SOIfnoiMod; /* v3.2 */ + int B4SOItnoiMod; /* v3.2 */ + int B4SOIshMod; + int B4SOIbinUnit; + int B4SOIparamChk; + double B4SOIversion; + double B4SOItox; + double B4SOItoxm; /* v3.2 */ + double B4SOIdtoxcv; /* v2.2.3 */ + double B4SOIcdsc; + double B4SOIcdscb; + double B4SOIcdscd; + double B4SOIcit; + double B4SOInfactor; + double B4SOIvsat; + double B4SOIat; + double B4SOIa0; + double B4SOIags; + double B4SOIa1; + double B4SOIa2; + double B4SOIketa; + double B4SOInsub; + double B4SOInpeak; + double B4SOIngate; + double B4SOIgamma1; + double B4SOIgamma2; + double B4SOIvbx; + double B4SOIvbm; + double B4SOIxt; + double B4SOIk1; + double B4SOIkt1; + double B4SOIkt1l; + double B4SOIkt2; + double B4SOIk2; + double B4SOIk3; + double B4SOIk3b; + double B4SOIw0; + double B4SOIlpe0; + double B4SOIdvt0; + double B4SOIdvt1; + double B4SOIdvt2; + double B4SOIdvt0w; + double B4SOIdvt1w; + double B4SOIdvt2w; + double B4SOIdrout; + double B4SOIdsub; + double B4SOIvth0; + double B4SOIua; + double B4SOIua1; + double B4SOIub; + double B4SOIub1; + double B4SOIuc; + double B4SOIuc1; + double B4SOIu0; + double B4SOIute; + double B4SOIvoff; + double B4SOIdelta; + double B4SOIrdsw; + double B4SOIrdw; /* v4.0 for rdsMod = 1 */ + double B4SOIrsw; /* v4.0 for rdsMod = 1 */ + double B4SOIrdwmin; /* v4.0 for rdsMod = 1 */ + double B4SOIrswmin; /* v4.0 for rdsMod = 1 */ + double B4SOIprwg; + double B4SOIprwb; + double B4SOIprt; + double B4SOIeta0; + double B4SOIetab; + double B4SOIpclm; + double B4SOIpdibl1; + double B4SOIpdibl2; + double B4SOIpdiblb; + double B4SOIpvag; + double B4SOIwr; + double B4SOIdwg; + double B4SOIdwb; + double B4SOIb0; + double B4SOIb1; + double B4SOIalpha0; + double B4SOItbox; + double B4SOItsi; + double B4SOIxj; + double B4SOIkb1; + double B4SOIrth0; + double B4SOIcth0; + double B4SOIegidl; + double B4SOIagidl; + double B4SOIbgidl; + double B4SOIcgidl; /* v4.0 */ + double B4SOIndiode; /* v4.0 */ + double B4SOIndioded; /* v4.0 */ + double B4SOIistun; + double B4SOIidtun; /* v4.0 */ + double B4SOIxbjt; + double B4SOIxdif; + double B4SOIxrec; + double B4SOIxtun; + double B4SOIxdifd; + double B4SOIxrecd; + double B4SOIxtund; + + +/* v3.0 */ + int B4SOIsoiMod; /* v3.2 bug fix */ + double B4SOIvbs0pd; /* v3.2 */ + double B4SOIvbs0fd; /* v3.2 */ + double B4SOIvbsa; + double B4SOInofffd; + double B4SOIvofffd; + double B4SOIk1b; + double B4SOIk2b; + double B4SOIdk2b; + double B4SOIdvbd0; + double B4SOIdvbd1; + double B4SOImoinFD; + +/* v3.0 */ + int B4SOIigbMod; + int B4SOIigcMod; + double B4SOIaigc; + double B4SOIbigc; + double B4SOIcigc; + double B4SOIaigsd; + double B4SOIbigsd; + double B4SOIcigsd; + double B4SOInigc; + double B4SOIpigcd; + double B4SOIpoxedge; + double B4SOIdlcig; + +/* v3.1 added for RF */ + int B4SOIrgateMod; + double B4SOIxrcrg1; + double B4SOIxrcrg2; + double B4SOIrshg; + double B4SOIngcon; + double B4SOIxgw; + double B4SOIxgl; + /* v3.1 added for RF end */ + + /* v3.2 for noise */ + double B4SOItnoia; + double B4SOItnoib; + double B4SOIrnoia; + double B4SOIrnoib; + double B4SOIntnoi; + /* v3.2 for noise end */ + + /* v4.0 */ + int B4SOIrbodyMod; + double B4SOIrbdb; + double B4SOIrbsb; + double B4SOIgbmin; + double B4SOIfrbody; + + int B4SOIrdsMod; /* v4.0 */ + + /* v4.0 end */ + + /* vfb added */ + double B4SOIvfb; + /* added end */ + +/* v2.2 release */ + double B4SOIwth0; + double B4SOIrhalo; + double B4SOIntox; + double B4SOItoxref; + double B4SOIebg; + double B4SOIvevb; + double B4SOIalphaGB1; + double B4SOIbetaGB1; + double B4SOIvgb1; + double B4SOIvecb; + double B4SOIalphaGB2; + double B4SOIbetaGB2; + double B4SOIvgb2; + double B4SOItoxqm; + double B4SOIvoxh; + double B4SOIdeltavox; + + +/* v2.0 release */ + double B4SOIk1w1; + double B4SOIk1w2; + double B4SOIketas; + double B4SOIdwbc; + double B4SOIbeta0; + double B4SOIbeta1; + double B4SOIbeta2; + double B4SOIvdsatii0; + double B4SOItii; + double B4SOIlii; + double B4SOIsii0; + double B4SOIsii1; + double B4SOIsii2; + double B4SOIsiid; + double B4SOIfbjtii; + double B4SOIesatii; + double B4SOIntun; /* v4.0 */ + double B4SOIntund; /* v4.0 */ + double B4SOInrecf0; /* v4.0 */ + double B4SOInrecf0d; /* v4.0 */ + double B4SOInrecr0; /* v4.0 */ + double B4SOInrecr0d; /* v4.0 */ + double B4SOIisbjt; + double B4SOIidbjt; /* v4.0 */ + double B4SOIisdif; + double B4SOIiddif; /* v4.0 */ + double B4SOIisrec; + double B4SOIidrec; /* v4.0 */ + double B4SOIln; + double B4SOIvrec0; /* v4.0 */ + double B4SOIvrec0d; /* v4.0 */ + double B4SOIvtun0; /* v4.0 */ + double B4SOIvtun0d; /* v4.0 */ + double B4SOInbjt; + double B4SOIlbjt0; + double B4SOIldif0; + double B4SOIvabjt; + double B4SOIaely; + double B4SOIahli; /* v4.0 */ + double B4SOIahlid; /* v4.0 */ + double B4SOIrbody; + double B4SOIrbsh; + double B4SOItt; + double B4SOIndif; + double B4SOIvsdfb; + double B4SOIvsdth; + double B4SOIcsdmin; + double B4SOIasd; + double B4SOIntrecf; + double B4SOIntrecr; + double B4SOIdlcb; + double B4SOIfbody; + double B4SOItcjswg; + double B4SOItpbswg; + double B4SOItcjswgd; + double B4SOItpbswgd; + double B4SOIacde; + double B4SOImoin; + double B4SOInoff; /* v3.2 */ + double B4SOIdelvt; + double B4SOIdlbg; + + /* CV model */ + double B4SOIcgsl; + double B4SOIcgdl; + double B4SOIckappa; + double B4SOIcf; + double B4SOIclc; + double B4SOIcle; + double B4SOIdwc; + double B4SOIdlc; + + + double B4SOItnom; + double B4SOIcgso; + double B4SOIcgdo; + double B4SOIcgeo; + + double B4SOIxpart; + double B4SOIcFringOut; + double B4SOIcFringMax; + + double B4SOIsheetResistance; + double B4SOIbodyJctGateSideSGradingCoeff; /* v4.0 */ + double B4SOIbodyJctGateSideDGradingCoeff; /* v4.0 */ + double B4SOIGatesidewallJctSPotential; /* v4.0 */ + double B4SOIGatesidewallJctDPotential; /* v4.0 */ + double B4SOIunitLengthGateSidewallJctCapS; /* v4.0 */ + double B4SOIunitLengthGateSidewallJctCapD; /* v4.0 */ + double B4SOIcsdesw; + + double B4SOILint; + double B4SOILl; + double B4SOILlc; /* v2.2.3 */ + double B4SOILln; + double B4SOILw; + double B4SOILwc; /* v2.2.3 */ + double B4SOILwn; + double B4SOILwl; + double B4SOILwlc; /* v2.2.3 */ + double B4SOILmin; + double B4SOILmax; + + double B4SOIWint; + double B4SOIWl; + double B4SOIWlc; /* v2.2.3 */ + double B4SOIWln; + double B4SOIWw; + double B4SOIWwc; /* v2.2.3 */ + double B4SOIWwn; + double B4SOIWwl; + double B4SOIWwlc; /* v2.2.3 */ + double B4SOIWmin; + double B4SOIWmax; + +/* Added for binning - START1 */ + /* Length Dependence */ +/* v3.1 */ + double B4SOIlxj; + double B4SOIlalphaGB1; + double B4SOIlbetaGB1; + double B4SOIlalphaGB2; + double B4SOIlbetaGB2; + double B4SOIlndif; + double B4SOIlntrecf; + double B4SOIlntrecr; + double B4SOIlxbjt; + double B4SOIlxdif; + double B4SOIlxrec; + double B4SOIlxtun; + double B4SOIlxdifd; + double B4SOIlxrecd; + double B4SOIlxtund; + double B4SOIlcgsl; + double B4SOIlcgdl; + double B4SOIlckappa; + double B4SOIlua1; + double B4SOIlub1; + double B4SOIluc1; + double B4SOIlute; + double B4SOIlkt1; + double B4SOIlkt1l; + double B4SOIlkt2; + double B4SOIlat; + double B4SOIlprt; + +/* v3.0 */ + double B4SOIlaigc; + double B4SOIlbigc; + double B4SOIlcigc; + double B4SOIlaigsd; + double B4SOIlbigsd; + double B4SOIlcigsd; + double B4SOIlnigc; + double B4SOIlpigcd; + double B4SOIlpoxedge; + + double B4SOIlnpeak; + double B4SOIlnsub; + double B4SOIlngate; + double B4SOIlvth0; + double B4SOIlk1; + double B4SOIlk1w1; + double B4SOIlk1w2; + double B4SOIlk2; + double B4SOIlk3; + double B4SOIlk3b; + double B4SOIlkb1; + double B4SOIlw0; + double B4SOIllpe0; + double B4SOIldvt0; + double B4SOIldvt1; + double B4SOIldvt2; + double B4SOIldvt0w; + double B4SOIldvt1w; + double B4SOIldvt2w; + double B4SOIlu0; + double B4SOIlua; + double B4SOIlub; + double B4SOIluc; + double B4SOIlvsat; + double B4SOIla0; + double B4SOIlags; + double B4SOIlb0; + double B4SOIlb1; + double B4SOIlketa; + double B4SOIlketas; + double B4SOIla1; + double B4SOIla2; + double B4SOIlrdsw; + double B4SOIlrdw; /* v4.0 for rdsMod = 1 */ + double B4SOIlrsw; /* v4.0 for rdsMod = 1 */ + double B4SOIlprwb; + double B4SOIlprwg; + double B4SOIlwr; + double B4SOIlnfactor; + double B4SOIldwg; + double B4SOIldwb; + double B4SOIlvoff; + double B4SOIleta0; + double B4SOIletab; + double B4SOIldsub; + double B4SOIlcit; + double B4SOIlcdsc; + double B4SOIlcdscb; + double B4SOIlcdscd; + double B4SOIlpclm; + double B4SOIlpdibl1; + double B4SOIlpdibl2; + double B4SOIlpdiblb; + double B4SOIldrout; + double B4SOIlpvag; + double B4SOIldelta; + double B4SOIlalpha0; + double B4SOIlfbjtii; + double B4SOIlbeta0; + double B4SOIlbeta1; + double B4SOIlbeta2; + double B4SOIlvdsatii0; + double B4SOIllii; + double B4SOIlesatii; + double B4SOIlsii0; + double B4SOIlsii1; + double B4SOIlsii2; + double B4SOIlsiid; + double B4SOIlagidl; + double B4SOIlbgidl; + double B4SOIlcgidl; + double B4SOIlegidl; + double B4SOIlntun; /* v4.0 */ + double B4SOIlntund; /* v4.0 */ + double B4SOIlndiode; /* v4.0 */ + double B4SOIlndioded; /* v4.0 */ + double B4SOIlnrecf0; /* v4.0 */ + double B4SOIlnrecf0d; /* v4.0 */ + double B4SOIlnrecr0; /* v4.0 */ + double B4SOIlnrecr0d; /* v4.0 */ + double B4SOIlisbjt; + double B4SOIlidbjt; /* v4.0 */ + double B4SOIlisdif; + double B4SOIliddif; /* v4.0 */ + double B4SOIlisrec; + double B4SOIlidrec; /* v4.0 */ + double B4SOIlistun; + double B4SOIlidtun; /* v4.0 */ + double B4SOIlvrec0; /* v4.0 */ + double B4SOIlvrec0d; /* v4.0 */ + double B4SOIlvtun0; /* v4.0 */ + double B4SOIlvtun0d; /* v4.0 */ + double B4SOIlnbjt; + double B4SOIllbjt0; + double B4SOIlvabjt; + double B4SOIlaely; + double B4SOIlahli; /* v4.0 */ + double B4SOIlahlid; /* v4.0 */ + +/* v3.1 added for RF */ + double B4SOIlxrcrg1; + double B4SOIlxrcrg2; +/* v3.1 added for RF end */ + + /* CV model */ + double B4SOIlvsdfb; + double B4SOIlvsdth; + double B4SOIldelvt; + double B4SOIlacde; + double B4SOIlmoin; + double B4SOIlnoff; /* v3.2 */ + + /* Width Dependence */ +/* v3.1 */ + double B4SOIwxj; + double B4SOIwalphaGB1; + double B4SOIwbetaGB1; + double B4SOIwalphaGB2; + double B4SOIwbetaGB2; + double B4SOIwndif; + double B4SOIwntrecf; + double B4SOIwntrecr; + double B4SOIwxbjt; + double B4SOIwxdif; + double B4SOIwxrec; + double B4SOIwxtun; + double B4SOIwxdifd; + double B4SOIwxrecd; + double B4SOIwxtund; + double B4SOIwcgsl; + double B4SOIwcgdl; + double B4SOIwckappa; + double B4SOIwua1; + double B4SOIwub1; + double B4SOIwuc1; + double B4SOIwute; + double B4SOIwkt1; + double B4SOIwkt1l; + double B4SOIwkt2; + double B4SOIwat; + double B4SOIwprt; + +/* v3.0 */ + double B4SOIwaigc; + double B4SOIwbigc; + double B4SOIwcigc; + double B4SOIwaigsd; + double B4SOIwbigsd; + double B4SOIwcigsd; + double B4SOIwnigc; + double B4SOIwpigcd; + double B4SOIwpoxedge; + + double B4SOIwnpeak; + double B4SOIwnsub; + double B4SOIwngate; + double B4SOIwvth0; + double B4SOIwk1; + double B4SOIwk1w1; + double B4SOIwk1w2; + double B4SOIwk2; + double B4SOIwk3; + double B4SOIwk3b; + double B4SOIwkb1; + double B4SOIww0; + double B4SOIwlpe0; + double B4SOIwdvt0; + double B4SOIwdvt1; + double B4SOIwdvt2; + double B4SOIwdvt0w; + double B4SOIwdvt1w; + double B4SOIwdvt2w; + double B4SOIwu0; + double B4SOIwua; + double B4SOIwub; + double B4SOIwuc; + double B4SOIwvsat; + double B4SOIwa0; + double B4SOIwags; + double B4SOIwb0; + double B4SOIwb1; + double B4SOIwketa; + double B4SOIwketas; + double B4SOIwa1; + double B4SOIwa2; + double B4SOIwrdsw; + double B4SOIwrdw; /* v4.0 for rdsMod = 1 */ + double B4SOIwrsw; /* v4.0 for rdsMod = 1 */ + double B4SOIwprwb; + double B4SOIwprwg; + double B4SOIwwr; + double B4SOIwnfactor; + double B4SOIwdwg; + double B4SOIwdwb; + double B4SOIwvoff; + double B4SOIweta0; + double B4SOIwetab; + double B4SOIwdsub; + double B4SOIwcit; + double B4SOIwcdsc; + double B4SOIwcdscb; + double B4SOIwcdscd; + double B4SOIwpclm; + double B4SOIwpdibl1; + double B4SOIwpdibl2; + double B4SOIwpdiblb; + double B4SOIwdrout; + double B4SOIwpvag; + double B4SOIwdelta; + double B4SOIwalpha0; + double B4SOIwfbjtii; + double B4SOIwbeta0; + double B4SOIwbeta1; + double B4SOIwbeta2; + double B4SOIwvdsatii0; + double B4SOIwlii; + double B4SOIwesatii; + double B4SOIwsii0; + double B4SOIwsii1; + double B4SOIwsii2; + double B4SOIwsiid; + double B4SOIwagidl; + double B4SOIwbgidl; + double B4SOIwcgidl; + double B4SOIwegidl; + double B4SOIwntun; /* v4.0 */ + double B4SOIwntund; /* v4.0 */ + double B4SOIwndiode; /* v4.0 */ + double B4SOIwndioded; /* v4.0 */ + double B4SOIwnrecf0; /* v4.0 */ + double B4SOIwnrecf0d; /* v4.0 */ + double B4SOIwnrecr0; /* v4.0 */ + double B4SOIwnrecr0d; /* v4.0 */ + double B4SOIwisbjt; + double B4SOIwidbjt; /* v4.0 */ + double B4SOIwisdif; + double B4SOIwiddif; /* v4.0 */ + double B4SOIwisrec; + double B4SOIwidrec; /* v4.0 */ + double B4SOIwistun; + double B4SOIwidtun; /* v4.0 */ + double B4SOIwvrec0; /* v4.0 */ + double B4SOIwvrec0d; /* v4.0 */ + double B4SOIwvtun0; /* v4.0 */ + double B4SOIwvtun0d; /* v4.0 */ + double B4SOIwnbjt; + double B4SOIwlbjt0; + double B4SOIwvabjt; + double B4SOIwaely; + double B4SOIwahli; /* v4.0 */ + double B4SOIwahlid; /* v4.0 */ + +/* v3.1 added for RF */ + double B4SOIwxrcrg1; + double B4SOIwxrcrg2; +/* v3.1 added for RF end */ + + /* CV model */ + double B4SOIwvsdfb; + double B4SOIwvsdth; + double B4SOIwdelvt; + double B4SOIwacde; + double B4SOIwmoin; + double B4SOIwnoff; /* v3.2 */ + + /* Cross-term Dependence */ +/* v3.1 */ + double B4SOIpxj; + double B4SOIpalphaGB1; + double B4SOIpbetaGB1; + double B4SOIpalphaGB2; + double B4SOIpbetaGB2; + double B4SOIpndif; + double B4SOIpntrecf; + double B4SOIpntrecr; + double B4SOIpxbjt; + double B4SOIpxdif; + double B4SOIpxrec; + double B4SOIpxtun; + double B4SOIpxdifd; + double B4SOIpxrecd; + double B4SOIpxtund; + double B4SOIpcgsl; + double B4SOIpcgdl; + double B4SOIpckappa; + double B4SOIpua1; + double B4SOIpub1; + double B4SOIpuc1; + double B4SOIpute; + double B4SOIpkt1; + double B4SOIpkt1l; + double B4SOIpkt2; + double B4SOIpat; + double B4SOIpprt; + +/* v3.0 */ + double B4SOIpaigc; + double B4SOIpbigc; + double B4SOIpcigc; + double B4SOIpaigsd; + double B4SOIpbigsd; + double B4SOIpcigsd; + double B4SOIpnigc; + double B4SOIppigcd; + double B4SOIppoxedge; + + double B4SOIpnpeak; + double B4SOIpnsub; + double B4SOIpngate; + double B4SOIpvth0; + double B4SOIpk1; + double B4SOIpk1w1; + double B4SOIpk1w2; + double B4SOIpk2; + double B4SOIpk3; + double B4SOIpk3b; + double B4SOIpkb1; + double B4SOIpw0; + double B4SOIplpe0; + double B4SOIpdvt0; + double B4SOIpdvt1; + double B4SOIpdvt2; + double B4SOIpdvt0w; + double B4SOIpdvt1w; + double B4SOIpdvt2w; + double B4SOIpu0; + double B4SOIpua; + double B4SOIpub; + double B4SOIpuc; + double B4SOIpvsat; + double B4SOIpa0; + double B4SOIpags; + double B4SOIpb0; + double B4SOIpb1; + double B4SOIpketa; + double B4SOIpketas; + double B4SOIpa1; + double B4SOIpa2; + double B4SOIprdsw; + double B4SOIprdw; /* v4.0 for rdsMod = 1 */ + double B4SOIprsw; /* v4.0 for rdsMod = 1 */ + double B4SOIpprwb; + double B4SOIpprwg; + double B4SOIpwr; + double B4SOIpnfactor; + double B4SOIpdwg; + double B4SOIpdwb; + double B4SOIpvoff; + double B4SOIpeta0; + double B4SOIpetab; + double B4SOIpdsub; + double B4SOIpcit; + double B4SOIpcdsc; + double B4SOIpcdscb; + double B4SOIpcdscd; + double B4SOIppclm; + double B4SOIppdibl1; + double B4SOIppdibl2; + double B4SOIppdiblb; + double B4SOIpdrout; + double B4SOIppvag; + double B4SOIpdelta; + double B4SOIpalpha0; + double B4SOIpfbjtii; + double B4SOIpbeta0; + double B4SOIpbeta1; + double B4SOIpbeta2; + double B4SOIpvdsatii0; + double B4SOIplii; + double B4SOIpesatii; + double B4SOIpsii0; + double B4SOIpsii1; + double B4SOIpsii2; + double B4SOIpsiid; + double B4SOIpagidl; + double B4SOIpbgidl; + double B4SOIpcgidl; + double B4SOIpegidl; + double B4SOIpntun; /* v4.0 */ + double B4SOIpntund; /* v4.0 */ + double B4SOIpndiode; /* v4.0 */ + double B4SOIpndioded; /* v4.0 */ + double B4SOIpnrecf0; /* v4.0 */ + double B4SOIpnrecf0d; /* v4.0 */ + double B4SOIpnrecr0; /* v4.0 */ + double B4SOIpnrecr0d; /* v4.0 */ + double B4SOIpisbjt; + double B4SOIpidbjt; /* v4.0 */ + double B4SOIpisdif; + double B4SOIpiddif; /* v4.0 */ + double B4SOIpisrec; + double B4SOIpidrec; /* v4.0 */ + double B4SOIpistun; + double B4SOIpidtun; /* v4.0 */ + double B4SOIpvrec0; /* v4.0 */ + double B4SOIpvrec0d; /* v4.0 */ + double B4SOIpvtun0; /* v4.0 */ + double B4SOIpvtun0d; /* v4.0 */ + double B4SOIpnbjt; + double B4SOIplbjt0; + double B4SOIpvabjt; + double B4SOIpaely; + double B4SOIpahli; /* v4.0 */ + double B4SOIpahlid; /* v4.0 */ +/* v3.1 added for RF */ + double B4SOIpxrcrg1; + double B4SOIpxrcrg2; +/* v3.1 added for RF end */ + + /* CV model */ + double B4SOIpvsdfb; + double B4SOIpvsdth; + double B4SOIpdelvt; + double B4SOIpacde; + double B4SOIpmoin; + double B4SOIpnoff; /* v3.2 */ +/* Added for binning - END1 */ + +/* Pre-calculated constants */ + double B4SOIcbox; + double B4SOIcsi; + double B4SOIcsieff; + double B4SOIcoxt; + double B4SOInfb; + double B4SOIadice; + double B4SOIeg0; + + /* v4.0 added for stress effect */ + double B4SOIsaref; + double B4SOIsbref; + double B4SOIwlod; + double B4SOIku0; + double B4SOIkvsat; + double B4SOIkvth0; + double B4SOItku0; + double B4SOIllodku0; + double B4SOIwlodku0; + double B4SOIllodvth; + double B4SOIwlodvth; + double B4SOIlku0; + double B4SOIwku0; + double B4SOIpku0; + double B4SOIlkvth0; + double B4SOIwkvth0; + double B4SOIpkvth0; + double B4SOIstk2; + double B4SOIlodk2; + double B4SOIsteta0; + double B4SOIlodeta0; + /* v4.0 added for stress effect end */ + + /* MCJ: move to size-dependent param. */ + double B4SOIvtm; + double B4SOIcox; + double B4SOIcof1; + double B4SOIcof2; + double B4SOIcof3; + double B4SOIcof4; + double B4SOIvcrit; + double B4SOIfactor1; + + double B4SOIoxideTrapDensityA; + double B4SOIoxideTrapDensityB; + double B4SOIoxideTrapDensityC; + double B4SOIem; + double B4SOIef; + double B4SOIaf; + double B4SOIkf; + double B4SOInoif; + double B4SOIbf; /* v4.0 for noise */ + double B4SOIw0flk; /* v4.0 for noise */ + double B4SOIlpeb; /* v4.0 for Vth */ + double B4SOIllpeb; /* v4.0 for Vth */ + double B4SOIwlpeb; /* v4.0 for Vth */ + double B4SOIplpeb; /* v4.0 for Vth */ + double B4SOIdvtp0; /* v4.0 for Vth */ + double B4SOIldvtp0; /* v4.0 for Vth */ + double B4SOIwdvtp0; /* v4.0 for Vth */ + double B4SOIpdvtp0; /* v4.0 for Vth */ + double B4SOIdvtp1; /* v4.0 for Vth */ + double B4SOIldvtp1; /* v4.0 for Vth */ + double B4SOIwdvtp1; /* v4.0 for Vth */ + double B4SOIpdvtp1; /* v4.0 for Vth */ + double B4SOIminv; /* v4.0 for Vgsteff */ + double B4SOIlminv; /* v4.0 for Vgsteff */ + double B4SOIwminv; /* v4.0 for Vgsteff */ + double B4SOIpminv; /* v4.0 for Vgsteff */ + double B4SOIfprout; /* v4.0 for DITS in Id */ + double B4SOIlfprout; /* v4.0 for DITS in Id */ + double B4SOIwfprout; /* v4.0 for DITS in Id */ + double B4SOIpfprout; /* v4.0 for DITS in Id */ + double B4SOIpdits; /* v4.0 for DITS in Id */ + double B4SOIlpdits; /* v4.0 for DITS in Id */ + double B4SOIwpdits; /* v4.0 for DITS in Id */ + double B4SOIppdits; /* v4.0 for DITS in Id */ + double B4SOIpditsd; /* v4.0 for DITS in Id */ + double B4SOIlpditsd; /* v4.0 for DITS in Id */ + double B4SOIwpditsd; /* v4.0 for DITS in Id */ + double B4SOIppditsd; /* v4.0 for DITS in Id */ + double B4SOIpditsl; /* v4.0 for DITS in Id */ + /* 4.0 backward compatibility */ + double B4SOInlx; + double B4SOIlnlx; + double B4SOIwnlx; + double B4SOIpnlx; + unsigned B4SOInlxGiven :1; + unsigned B4SOIlnlxGiven :1; + unsigned B4SOIwnlxGiven :1; + unsigned B4SOIpnlxGiven :1; + double B4SOIngidl; + double B4SOIlngidl; + double B4SOIwngidl; + double B4SOIpngidl; + unsigned B4SOIngidlGiven :1; + unsigned B4SOIlngidlGiven :1; + unsigned B4SOIwngidlGiven :1; + unsigned B4SOIpngidlGiven :1; + + struct b4soiSizeDependParam *pSizeDependParamKnot; + + /* Flags */ + + unsigned B4SOIrdsModGiven :1; /* v4.0 */ + unsigned B4SOIrbodyModGiven :1; /* v4.0 */ + unsigned B4SOIrgateModGiven :1; /* v3.1 */ + +/* v3.0 */ + unsigned B4SOIsoiModGiven: 1; + unsigned B4SOIvbs0pdGiven: 1; /* v3.2 */ + unsigned B4SOIvbs0fdGiven: 1; /* v3.2 */ + unsigned B4SOIvbsaGiven : 1; + unsigned B4SOInofffdGiven: 1; + unsigned B4SOIvofffdGiven: 1; + unsigned B4SOIk1bGiven: 1; + unsigned B4SOIk2bGiven: 1; + unsigned B4SOIdk2bGiven: 1; + unsigned B4SOIdvbd0Given: 1; + unsigned B4SOIdvbd1Given: 1; + unsigned B4SOImoinFDGiven: 1; + + + unsigned B4SOItboxGiven:1; + unsigned B4SOItsiGiven :1; + unsigned B4SOIxjGiven :1; + unsigned B4SOIkb1Given :1; + unsigned B4SOIrth0Given :1; + unsigned B4SOIcth0Given :1; + unsigned B4SOIegidlGiven :1; + unsigned B4SOIagidlGiven :1; + unsigned B4SOIbgidlGiven :1; + unsigned B4SOIcgidlGiven :1; + unsigned B4SOIndiodeGiven :1; /* v4.0 */ + unsigned B4SOIndiodedGiven :1; /* v4.0 */ + unsigned B4SOIxbjtGiven :1; + unsigned B4SOIxdifGiven :1; + unsigned B4SOIxrecGiven :1; + unsigned B4SOIxtunGiven :1; + unsigned B4SOIxdifdGiven :1; + unsigned B4SOIxrecdGiven :1; + unsigned B4SOIxtundGiven :1; + unsigned B4SOIttGiven :1; + unsigned B4SOIvsdfbGiven :1; + unsigned B4SOIvsdthGiven :1; + unsigned B4SOIasdGiven :1; + unsigned B4SOIcsdminGiven :1; + + unsigned B4SOImobModGiven :1; + unsigned B4SOIbinUnitGiven :1; + unsigned B4SOIcapModGiven :1; + unsigned B4SOIparamChkGiven :1; +/* unsigned B4SOInoiModGiven :1; v3.2 */ + unsigned B4SOIshModGiven :1; + unsigned B4SOItypeGiven :1; + unsigned B4SOItoxGiven :1; + unsigned B4SOItoxmGiven :1; /* v3.2 */ + unsigned B4SOIdtoxcvGiven :1; /* v2.2.3 */ + unsigned B4SOIversionGiven :1; + + unsigned B4SOIcdscGiven :1; + unsigned B4SOIcdscbGiven :1; + unsigned B4SOIcdscdGiven :1; + unsigned B4SOIcitGiven :1; + unsigned B4SOInfactorGiven :1; + unsigned B4SOIvsatGiven :1; + unsigned B4SOIatGiven :1; + unsigned B4SOIa0Given :1; + unsigned B4SOIagsGiven :1; + unsigned B4SOIa1Given :1; + unsigned B4SOIa2Given :1; + unsigned B4SOIketaGiven :1; + unsigned B4SOInsubGiven :1; + unsigned B4SOInpeakGiven :1; + unsigned B4SOIngateGiven :1; + unsigned B4SOIgamma1Given :1; + unsigned B4SOIgamma2Given :1; + unsigned B4SOIvbxGiven :1; + unsigned B4SOIvbmGiven :1; + unsigned B4SOIxtGiven :1; + unsigned B4SOIk1Given :1; + unsigned B4SOIkt1Given :1; + unsigned B4SOIkt1lGiven :1; + unsigned B4SOIkt2Given :1; + unsigned B4SOIk2Given :1; + unsigned B4SOIk3Given :1; + unsigned B4SOIk3bGiven :1; + unsigned B4SOIw0Given :1; + unsigned B4SOIlpe0Given :1; + unsigned B4SOIdvt0Given :1; + unsigned B4SOIdvt1Given :1; + unsigned B4SOIdvt2Given :1; + unsigned B4SOIdvt0wGiven :1; + unsigned B4SOIdvt1wGiven :1; + unsigned B4SOIdvt2wGiven :1; + unsigned B4SOIdroutGiven :1; + unsigned B4SOIdsubGiven :1; + unsigned B4SOIvth0Given :1; + unsigned B4SOIuaGiven :1; + unsigned B4SOIua1Given :1; + unsigned B4SOIubGiven :1; + unsigned B4SOIub1Given :1; + unsigned B4SOIucGiven :1; + unsigned B4SOIuc1Given :1; + unsigned B4SOIu0Given :1; + unsigned B4SOIuteGiven :1; + unsigned B4SOIvoffGiven :1; + unsigned B4SOIrdswGiven :1; + unsigned B4SOIrdwGiven :1; /* v4.0 for rdsMod = 1 */ + unsigned B4SOIrswGiven :1; /* v4.0 for rdsMod = 1 */ + unsigned B4SOIrdwminGiven :1; /* v4.0 for rdsMod = 1 */ + unsigned B4SOIrswminGiven :1; /* v4.0 for rdsMod = 1 */ + unsigned B4SOIprwgGiven :1; + unsigned B4SOIprwbGiven :1; + unsigned B4SOIprtGiven :1; + unsigned B4SOIeta0Given :1; + unsigned B4SOIetabGiven :1; + unsigned B4SOIpclmGiven :1; + unsigned B4SOIpdibl1Given :1; + unsigned B4SOIpdibl2Given :1; + unsigned B4SOIpdiblbGiven :1; + unsigned B4SOIpvagGiven :1; + unsigned B4SOIdeltaGiven :1; + unsigned B4SOIwrGiven :1; + unsigned B4SOIdwgGiven :1; + unsigned B4SOIdwbGiven :1; + unsigned B4SOIb0Given :1; + unsigned B4SOIb1Given :1; + unsigned B4SOIalpha0Given :1; + + + /* v3.1 added for RF */ + unsigned B4SOIxrcrg1Given :1; + unsigned B4SOIxrcrg2Given :1; + unsigned B4SOIrshgGiven :1; + unsigned B4SOIngconGiven :1; + unsigned B4SOIxgwGiven :1; + unsigned B4SOIxglGiven :1; + /* v3.1 added for RF end */ + + /* v3.2 */ + unsigned B4SOIfnoiModGiven :1; + unsigned B4SOItnoiModGiven :1; + unsigned B4SOItnoiaGiven :1; + unsigned B4SOItnoibGiven :1; + unsigned B4SOIrnoiaGiven :1; + unsigned B4SOIrnoibGiven :1; + unsigned B4SOIntnoiGiven :1; + /* v3.2 end */ + + /* v4.0 */ + unsigned B4SOIvfbGiven :1; + unsigned B4SOIgbminGiven :1; + unsigned B4SOIrbdbGiven :1; + unsigned B4SOIrbsbGiven :1; + /* v4.0 end */ + + +/* v2.2 release */ + unsigned B4SOIwth0Given :1; + unsigned B4SOIrhaloGiven :1; + unsigned B4SOIntoxGiven :1; + unsigned B4SOItoxrefGiven :1; + unsigned B4SOIebgGiven :1; + unsigned B4SOIvevbGiven :1; + unsigned B4SOIalphaGB1Given :1; + unsigned B4SOIbetaGB1Given :1; + unsigned B4SOIvgb1Given :1; + unsigned B4SOIvecbGiven :1; + unsigned B4SOIalphaGB2Given :1; + unsigned B4SOIbetaGB2Given :1; + unsigned B4SOIvgb2Given :1; + unsigned B4SOItoxqmGiven :1; + unsigned B4SOIigbModGiven :1; /* v3.0 */ + unsigned B4SOIvoxhGiven :1; + unsigned B4SOIdeltavoxGiven :1; + unsigned B4SOIigcModGiven :1; /* v3.0 */ +/* v3.0 */ + unsigned B4SOIaigcGiven :1; + unsigned B4SOIbigcGiven :1; + unsigned B4SOIcigcGiven :1; + unsigned B4SOIaigsdGiven :1; + unsigned B4SOIbigsdGiven :1; + unsigned B4SOIcigsdGiven :1; + unsigned B4SOInigcGiven :1; + unsigned B4SOIpigcdGiven :1; + unsigned B4SOIpoxedgeGiven :1; + unsigned B4SOIdlcigGiven :1; + + +/* v2.0 release */ + unsigned B4SOIk1w1Given :1; + unsigned B4SOIk1w2Given :1; + unsigned B4SOIketasGiven :1; + unsigned B4SOIdwbcGiven :1; + unsigned B4SOIbeta0Given :1; + unsigned B4SOIbeta1Given :1; + unsigned B4SOIbeta2Given :1; + unsigned B4SOIvdsatii0Given :1; + unsigned B4SOItiiGiven :1; + unsigned B4SOIliiGiven :1; + unsigned B4SOIsii0Given :1; + unsigned B4SOIsii1Given :1; + unsigned B4SOIsii2Given :1; + unsigned B4SOIsiidGiven :1; + unsigned B4SOIfbjtiiGiven :1; + unsigned B4SOIesatiiGiven :1; + unsigned B4SOIntunGiven :1; /* v4.0 */ + unsigned B4SOIntundGiven :1; /* v4.0 */ + unsigned B4SOInrecf0Given :1; /* v4.0 */ + unsigned B4SOInrecf0dGiven :1; /* v4.0 */ + unsigned B4SOInrecr0Given :1; /* v4.0 */ + unsigned B4SOInrecr0dGiven :1; /* v4.0 */ + unsigned B4SOIisbjtGiven :1; + unsigned B4SOIidbjtGiven :1; /* v4.0 */ + unsigned B4SOIisdifGiven :1; + unsigned B4SOIiddifGiven :1; /* v4.0 */ + unsigned B4SOIisrecGiven :1; + unsigned B4SOIidrecGiven :1; /* v4.0 */ + unsigned B4SOIistunGiven :1; + unsigned B4SOIidtunGiven :1; /* v4.0 */ + unsigned B4SOIlnGiven :1; + unsigned B4SOIvrec0Given :1; /* v4.0 */ + unsigned B4SOIvrec0dGiven :1; /* v4.0 */ + unsigned B4SOIvtun0Given :1; /* v4.0 */ + unsigned B4SOIvtun0dGiven :1; /* v4.0 */ + unsigned B4SOInbjtGiven :1; + unsigned B4SOIlbjt0Given :1; + unsigned B4SOIldif0Given :1; + unsigned B4SOIvabjtGiven :1; + unsigned B4SOIaelyGiven :1; + unsigned B4SOIahliGiven :1; /* v4.0 */ + unsigned B4SOIahlidGiven :1; /* v4.0 */ + unsigned B4SOIrbodyGiven :1; + unsigned B4SOIrbshGiven :1; + unsigned B4SOIndifGiven :1; + unsigned B4SOIntrecfGiven :1; + unsigned B4SOIntrecrGiven :1; + unsigned B4SOIdlcbGiven :1; + unsigned B4SOIfbodyGiven :1; + unsigned B4SOItcjswgGiven :1; + unsigned B4SOItpbswgGiven :1; + unsigned B4SOItcjswgdGiven :1; + unsigned B4SOItpbswgdGiven :1; + unsigned B4SOIacdeGiven :1; + unsigned B4SOImoinGiven :1; + unsigned B4SOInoffGiven: 1; /* v3.2 */ + unsigned B4SOIdelvtGiven :1; + unsigned B4SOIdlbgGiven :1; + + + /* CV model */ + unsigned B4SOIcgslGiven :1; + unsigned B4SOIcgdlGiven :1; + unsigned B4SOIckappaGiven :1; + unsigned B4SOIcfGiven :1; + unsigned B4SOIclcGiven :1; + unsigned B4SOIcleGiven :1; + unsigned B4SOIdwcGiven :1; + unsigned B4SOIdlcGiven :1; + +/* Added for binning - START2 */ + /* Length Dependence */ +/* v3.1 */ + unsigned B4SOIlxjGiven :1; + unsigned B4SOIlalphaGB1Given :1; + unsigned B4SOIlbetaGB1Given :1; + unsigned B4SOIlalphaGB2Given :1; + unsigned B4SOIlbetaGB2Given :1; + unsigned B4SOIlndifGiven :1; + unsigned B4SOIlntrecfGiven :1; + unsigned B4SOIlntrecrGiven :1; + unsigned B4SOIlxbjtGiven :1; + unsigned B4SOIlxdifGiven :1; + unsigned B4SOIlxrecGiven :1; + unsigned B4SOIlxtunGiven :1; + unsigned B4SOIlxdifdGiven :1; + unsigned B4SOIlxrecdGiven :1; + unsigned B4SOIlxtundGiven :1; + unsigned B4SOIlcgslGiven :1; + unsigned B4SOIlcgdlGiven :1; + unsigned B4SOIlckappaGiven :1; + unsigned B4SOIlua1Given :1; + unsigned B4SOIlub1Given :1; + unsigned B4SOIluc1Given :1; + unsigned B4SOIluteGiven :1; + unsigned B4SOIlkt1Given :1; + unsigned B4SOIlkt1lGiven :1; + unsigned B4SOIlkt2Given :1; + unsigned B4SOIlatGiven :1; + unsigned B4SOIlprtGiven :1; + +/* v3.0 */ + unsigned B4SOIlaigcGiven :1; + unsigned B4SOIlbigcGiven :1; + unsigned B4SOIlcigcGiven :1; + unsigned B4SOIlaigsdGiven :1; + unsigned B4SOIlbigsdGiven :1; + unsigned B4SOIlcigsdGiven :1; + unsigned B4SOIlnigcGiven :1; + unsigned B4SOIlpigcdGiven :1; + unsigned B4SOIlpoxedgeGiven :1; + + unsigned B4SOIlnpeakGiven :1; + unsigned B4SOIlnsubGiven :1; + unsigned B4SOIlngateGiven :1; + unsigned B4SOIlvth0Given :1; + unsigned B4SOIlk1Given :1; + unsigned B4SOIlk1w1Given :1; + unsigned B4SOIlk1w2Given :1; + unsigned B4SOIlk2Given :1; + unsigned B4SOIlk3Given :1; + unsigned B4SOIlk3bGiven :1; + unsigned B4SOIlkb1Given :1; + unsigned B4SOIlw0Given :1; + unsigned B4SOIllpe0Given :1; + unsigned B4SOIldvt0Given :1; + unsigned B4SOIldvt1Given :1; + unsigned B4SOIldvt2Given :1; + unsigned B4SOIldvt0wGiven :1; + unsigned B4SOIldvt1wGiven :1; + unsigned B4SOIldvt2wGiven :1; + unsigned B4SOIlu0Given :1; + unsigned B4SOIluaGiven :1; + unsigned B4SOIlubGiven :1; + unsigned B4SOIlucGiven :1; + unsigned B4SOIlvsatGiven :1; + unsigned B4SOIla0Given :1; + unsigned B4SOIlagsGiven :1; + unsigned B4SOIlb0Given :1; + unsigned B4SOIlb1Given :1; + unsigned B4SOIlketaGiven :1; + unsigned B4SOIlketasGiven :1; + unsigned B4SOIla1Given :1; + unsigned B4SOIla2Given :1; + unsigned B4SOIlrdswGiven :1; + unsigned B4SOIlrdwGiven :1; /* v4.0 for rdsMod = 1 */ + unsigned B4SOIlrswGiven :1; /* v4.0 for rdsMod = 1 */ + unsigned B4SOIlprwbGiven :1; + unsigned B4SOIlprwgGiven :1; + unsigned B4SOIlwrGiven :1; + unsigned B4SOIlnfactorGiven :1; + unsigned B4SOIldwgGiven :1; + unsigned B4SOIldwbGiven :1; + unsigned B4SOIlvoffGiven :1; + unsigned B4SOIleta0Given :1; + unsigned B4SOIletabGiven :1; + unsigned B4SOIldsubGiven :1; + unsigned B4SOIlcitGiven :1; + unsigned B4SOIlcdscGiven :1; + unsigned B4SOIlcdscbGiven :1; + unsigned B4SOIlcdscdGiven :1; + unsigned B4SOIlpclmGiven :1; + unsigned B4SOIlpdibl1Given :1; + unsigned B4SOIlpdibl2Given :1; + unsigned B4SOIlpdiblbGiven :1; + unsigned B4SOIldroutGiven :1; + unsigned B4SOIlpvagGiven :1; + unsigned B4SOIldeltaGiven :1; + unsigned B4SOIlalpha0Given :1; + unsigned B4SOIlfbjtiiGiven :1; + unsigned B4SOIlbeta0Given :1; + unsigned B4SOIlbeta1Given :1; + unsigned B4SOIlbeta2Given :1; + unsigned B4SOIlvdsatii0Given :1; + unsigned B4SOIlliiGiven :1; + unsigned B4SOIlesatiiGiven :1; + unsigned B4SOIlsii0Given :1; + unsigned B4SOIlsii1Given :1; + unsigned B4SOIlsii2Given :1; + unsigned B4SOIlsiidGiven :1; + unsigned B4SOIlagidlGiven :1; + unsigned B4SOIlbgidlGiven :1; + unsigned B4SOIlcgidlGiven :1; + unsigned B4SOIlegidlGiven :1; + unsigned B4SOIlntunGiven :1; /* v4.0 */ + unsigned B4SOIlntundGiven :1; /* v4.0 */ + unsigned B4SOIlndiodeGiven :1; /* v4.0 */ + unsigned B4SOIlndiodedGiven :1; /* v4.0 */ + unsigned B4SOIlnrecf0Given :1; /* v4.0 */ + unsigned B4SOIlnrecf0dGiven :1; /* v4.0 */ + unsigned B4SOIlnrecr0Given :1; /* v4.0 */ + unsigned B4SOIlnrecr0dGiven :1; /* v4.0 */ + unsigned B4SOIlisbjtGiven :1; + unsigned B4SOIlidbjtGiven :1; /* v4.0 */ + unsigned B4SOIlisdifGiven :1; + unsigned B4SOIliddifGiven :1; /* v4.0 */ + unsigned B4SOIlisrecGiven :1; + unsigned B4SOIlidrecGiven :1; /* v4.0 */ + unsigned B4SOIlistunGiven :1; + unsigned B4SOIlidtunGiven :1; /* v4.0 */ + unsigned B4SOIlvrec0Given :1; /* v4.0 */ + unsigned B4SOIlvrec0dGiven :1; /* v4.0 */ + unsigned B4SOIlvtun0Given :1; /* v4.0 */ + unsigned B4SOIlvtun0dGiven :1; /* v4.0 */ + unsigned B4SOIlnbjtGiven :1; + unsigned B4SOIllbjt0Given :1; + unsigned B4SOIlvabjtGiven :1; + unsigned B4SOIlaelyGiven :1; + unsigned B4SOIlahliGiven :1; /* v4.0 */ + unsigned B4SOIlahlidGiven :1; /* v4.0 */ +/* v3.1 added for RF */ + unsigned B4SOIlxrcrg1Given :1; + unsigned B4SOIlxrcrg2Given :1; +/* v3.1 added for RF end */ + + /* CV model */ + unsigned B4SOIlvsdfbGiven :1; + unsigned B4SOIlvsdthGiven :1; + unsigned B4SOIldelvtGiven :1; + unsigned B4SOIlacdeGiven :1; + unsigned B4SOIlmoinGiven :1; + unsigned B4SOIlnoffGiven :1; /* v3.2 */ + + /* Width Dependence */ +/* v3.1 */ + unsigned B4SOIwxjGiven :1; + unsigned B4SOIwalphaGB1Given :1; + unsigned B4SOIwbetaGB1Given :1; + unsigned B4SOIwalphaGB2Given :1; + unsigned B4SOIwbetaGB2Given :1; + unsigned B4SOIwndifGiven :1; + unsigned B4SOIwntrecfGiven :1; + unsigned B4SOIwntrecrGiven :1; + unsigned B4SOIwxbjtGiven :1; + unsigned B4SOIwxdifGiven :1; + unsigned B4SOIwxrecGiven :1; + unsigned B4SOIwxtunGiven :1; + unsigned B4SOIwxdifdGiven :1; + unsigned B4SOIwxrecdGiven :1; + unsigned B4SOIwxtundGiven :1; + unsigned B4SOIwcgslGiven :1; + unsigned B4SOIwcgdlGiven :1; + unsigned B4SOIwckappaGiven :1; + unsigned B4SOIwua1Given :1; + unsigned B4SOIwub1Given :1; + unsigned B4SOIwuc1Given :1; + unsigned B4SOIwuteGiven :1; + unsigned B4SOIwkt1Given :1; + unsigned B4SOIwkt1lGiven :1; + unsigned B4SOIwkt2Given :1; + unsigned B4SOIwatGiven :1; + unsigned B4SOIwprtGiven :1; + +/* v3.0 */ + unsigned B4SOIwaigcGiven :1; + unsigned B4SOIwbigcGiven :1; + unsigned B4SOIwcigcGiven :1; + unsigned B4SOIwaigsdGiven :1; + unsigned B4SOIwbigsdGiven :1; + unsigned B4SOIwcigsdGiven :1; + unsigned B4SOIwnigcGiven :1; + unsigned B4SOIwpigcdGiven :1; + unsigned B4SOIwpoxedgeGiven :1; + + unsigned B4SOIwnpeakGiven :1; + unsigned B4SOIwnsubGiven :1; + unsigned B4SOIwngateGiven :1; + unsigned B4SOIwvth0Given :1; + unsigned B4SOIwk1Given :1; + unsigned B4SOIwk1w1Given :1; + unsigned B4SOIwk1w2Given :1; + unsigned B4SOIwk2Given :1; + unsigned B4SOIwk3Given :1; + unsigned B4SOIwk3bGiven :1; + unsigned B4SOIwkb1Given :1; + unsigned B4SOIww0Given :1; + unsigned B4SOIwlpe0Given :1; + unsigned B4SOIwdvt0Given :1; + unsigned B4SOIwdvt1Given :1; + unsigned B4SOIwdvt2Given :1; + unsigned B4SOIwdvt0wGiven :1; + unsigned B4SOIwdvt1wGiven :1; + unsigned B4SOIwdvt2wGiven :1; + unsigned B4SOIwu0Given :1; + unsigned B4SOIwuaGiven :1; + unsigned B4SOIwubGiven :1; + unsigned B4SOIwucGiven :1; + unsigned B4SOIwvsatGiven :1; + unsigned B4SOIwa0Given :1; + unsigned B4SOIwagsGiven :1; + unsigned B4SOIwb0Given :1; + unsigned B4SOIwb1Given :1; + unsigned B4SOIwketaGiven :1; + unsigned B4SOIwketasGiven :1; + unsigned B4SOIwa1Given :1; + unsigned B4SOIwa2Given :1; + unsigned B4SOIwrdswGiven :1; + unsigned B4SOIwrdwGiven :1; /* v4.0 for rdsMod = 1 */ + unsigned B4SOIwrswGiven :1; /* v4.0 for rdsMod = 1 */ + unsigned B4SOIwprwbGiven :1; + unsigned B4SOIwprwgGiven :1; + unsigned B4SOIwwrGiven :1; + unsigned B4SOIwnfactorGiven :1; + unsigned B4SOIwdwgGiven :1; + unsigned B4SOIwdwbGiven :1; + unsigned B4SOIwvoffGiven :1; + unsigned B4SOIweta0Given :1; + unsigned B4SOIwetabGiven :1; + unsigned B4SOIwdsubGiven :1; + unsigned B4SOIwcitGiven :1; + unsigned B4SOIwcdscGiven :1; + unsigned B4SOIwcdscbGiven :1; + unsigned B4SOIwcdscdGiven :1; + unsigned B4SOIwpclmGiven :1; + unsigned B4SOIwpdibl1Given :1; + unsigned B4SOIwpdibl2Given :1; + unsigned B4SOIwpdiblbGiven :1; + unsigned B4SOIwdroutGiven :1; + unsigned B4SOIwpvagGiven :1; + unsigned B4SOIwdeltaGiven :1; + unsigned B4SOIwalpha0Given :1; + unsigned B4SOIwfbjtiiGiven :1; + unsigned B4SOIwbeta0Given :1; + unsigned B4SOIwbeta1Given :1; + unsigned B4SOIwbeta2Given :1; + unsigned B4SOIwvdsatii0Given :1; + unsigned B4SOIwliiGiven :1; + unsigned B4SOIwesatiiGiven :1; + unsigned B4SOIwsii0Given :1; + unsigned B4SOIwsii1Given :1; + unsigned B4SOIwsii2Given :1; + unsigned B4SOIwsiidGiven :1; + unsigned B4SOIwagidlGiven :1; + unsigned B4SOIwbgidlGiven :1; + unsigned B4SOIwcgidlGiven :1; + unsigned B4SOIwegidlGiven :1; + unsigned B4SOIwntunGiven :1; /* v4.0 */ + unsigned B4SOIwntundGiven :1; /* v4.0 */ + unsigned B4SOIwndiodeGiven :1; /* v4.0 */ + unsigned B4SOIwndiodedGiven :1; /* v4.0 */ + unsigned B4SOIwnrecf0Given :1; /* v4.0 */ + unsigned B4SOIwnrecf0dGiven :1; /* v4.0 */ + unsigned B4SOIwnrecr0Given :1; /* v4.0 */ + unsigned B4SOIwnrecr0dGiven :1; /* v4.0 */ + unsigned B4SOIwisbjtGiven :1; + unsigned B4SOIwidbjtGiven :1; /* v4.0 */ + unsigned B4SOIwisdifGiven :1; + unsigned B4SOIwiddifGiven :1; /* v4.0 */ + unsigned B4SOIwisrecGiven :1; + unsigned B4SOIwidrecGiven :1; /* v4.0 */ + unsigned B4SOIwistunGiven :1; + unsigned B4SOIwidtunGiven :1; /* v4.0 */ + unsigned B4SOIwvrec0Given :1; /* v4.0 */ + unsigned B4SOIwvrec0dGiven :1; /* v4.0 */ + unsigned B4SOIwvtun0Given :1; /* v4.0 */ + unsigned B4SOIwvtun0dGiven :1; /* v4.0 */ + unsigned B4SOIwnbjtGiven :1; + unsigned B4SOIwlbjt0Given :1; + unsigned B4SOIwvabjtGiven :1; + unsigned B4SOIwaelyGiven :1; + unsigned B4SOIwahliGiven :1; /* v4.0 */ + unsigned B4SOIwahlidGiven :1; /* v4.0 */ +/* v3.1 added for RF */ + unsigned B4SOIwxrcrg1Given :1; + unsigned B4SOIwxrcrg2Given :1; +/* v3.1 added for RF end */ + + /* CV model */ + unsigned B4SOIwvsdfbGiven :1; + unsigned B4SOIwvsdthGiven :1; + unsigned B4SOIwdelvtGiven :1; + unsigned B4SOIwacdeGiven :1; + unsigned B4SOIwmoinGiven :1; + unsigned B4SOIwnoffGiven :1; /* v3.2 */ + + /* Cross-term Dependence */ +/* v3.1 */ + unsigned B4SOIpxjGiven :1; + unsigned B4SOIpalphaGB1Given :1; + unsigned B4SOIpbetaGB1Given :1; + unsigned B4SOIpalphaGB2Given :1; + unsigned B4SOIpbetaGB2Given :1; + unsigned B4SOIpndifGiven :1; + unsigned B4SOIpntrecfGiven :1; + unsigned B4SOIpntrecrGiven :1; + unsigned B4SOIpxbjtGiven :1; + unsigned B4SOIpxdifGiven :1; + unsigned B4SOIpxrecGiven :1; + unsigned B4SOIpxtunGiven :1; + unsigned B4SOIpxdifdGiven :1; + unsigned B4SOIpxrecdGiven :1; + unsigned B4SOIpxtundGiven :1; + unsigned B4SOIpcgslGiven :1; + unsigned B4SOIpcgdlGiven :1; + unsigned B4SOIpckappaGiven :1; + unsigned B4SOIpua1Given :1; + unsigned B4SOIpub1Given :1; + unsigned B4SOIpuc1Given :1; + unsigned B4SOIputeGiven :1; + unsigned B4SOIpkt1Given :1; + unsigned B4SOIpkt1lGiven :1; + unsigned B4SOIpkt2Given :1; + unsigned B4SOIpatGiven :1; + unsigned B4SOIpprtGiven :1; + +/* v3.0 */ + unsigned B4SOIpaigcGiven :1; + unsigned B4SOIpbigcGiven :1; + unsigned B4SOIpcigcGiven :1; + unsigned B4SOIpaigsdGiven :1; + unsigned B4SOIpbigsdGiven :1; + unsigned B4SOIpcigsdGiven :1; + unsigned B4SOIpnigcGiven :1; + unsigned B4SOIppigcdGiven :1; + unsigned B4SOIppoxedgeGiven :1; + + unsigned B4SOIpnpeakGiven :1; + unsigned B4SOIpnsubGiven :1; + unsigned B4SOIpngateGiven :1; + unsigned B4SOIpvth0Given :1; + unsigned B4SOIpk1Given :1; + unsigned B4SOIpk1w1Given :1; + unsigned B4SOIpk1w2Given :1; + unsigned B4SOIpk2Given :1; + unsigned B4SOIpk3Given :1; + unsigned B4SOIpk3bGiven :1; + unsigned B4SOIpkb1Given :1; + unsigned B4SOIpw0Given :1; + unsigned B4SOIplpe0Given :1; + unsigned B4SOIpdvt0Given :1; + unsigned B4SOIpdvt1Given :1; + unsigned B4SOIpdvt2Given :1; + unsigned B4SOIpdvt0wGiven :1; + unsigned B4SOIpdvt1wGiven :1; + unsigned B4SOIpdvt2wGiven :1; + unsigned B4SOIpu0Given :1; + unsigned B4SOIpuaGiven :1; + unsigned B4SOIpubGiven :1; + unsigned B4SOIpucGiven :1; + unsigned B4SOIpvsatGiven :1; + unsigned B4SOIpa0Given :1; + unsigned B4SOIpagsGiven :1; + unsigned B4SOIpb0Given :1; + unsigned B4SOIpb1Given :1; + unsigned B4SOIpketaGiven :1; + unsigned B4SOIpketasGiven :1; + unsigned B4SOIpa1Given :1; + unsigned B4SOIpa2Given :1; + unsigned B4SOIprdswGiven :1; + unsigned B4SOIprdwGiven :1; /* v4.0 for rdsMod = 1 */ + unsigned B4SOIprswGiven :1; /* v4.0 for rdsMod = 1 */ + unsigned B4SOIpprwbGiven :1; + unsigned B4SOIpprwgGiven :1; + unsigned B4SOIpwrGiven :1; + unsigned B4SOIpnfactorGiven :1; + unsigned B4SOIpdwgGiven :1; + unsigned B4SOIpdwbGiven :1; + unsigned B4SOIpvoffGiven :1; + unsigned B4SOIpeta0Given :1; + unsigned B4SOIpetabGiven :1; + unsigned B4SOIpdsubGiven :1; + unsigned B4SOIpcitGiven :1; + unsigned B4SOIpcdscGiven :1; + unsigned B4SOIpcdscbGiven :1; + unsigned B4SOIpcdscdGiven :1; + unsigned B4SOIppclmGiven :1; + unsigned B4SOIppdibl1Given :1; + unsigned B4SOIppdibl2Given :1; + unsigned B4SOIppdiblbGiven :1; + unsigned B4SOIpdroutGiven :1; + unsigned B4SOIppvagGiven :1; + unsigned B4SOIpdeltaGiven :1; + unsigned B4SOIpalpha0Given :1; + unsigned B4SOIpfbjtiiGiven :1; + unsigned B4SOIpbeta0Given :1; + unsigned B4SOIpbeta1Given :1; + unsigned B4SOIpbeta2Given :1; + unsigned B4SOIpvdsatii0Given :1; + unsigned B4SOIpliiGiven :1; + unsigned B4SOIpesatiiGiven :1; + unsigned B4SOIpsii0Given :1; + unsigned B4SOIpsii1Given :1; + unsigned B4SOIpsii2Given :1; + unsigned B4SOIpsiidGiven :1; + unsigned B4SOIpagidlGiven :1; + unsigned B4SOIpbgidlGiven :1; + unsigned B4SOIpcgidlGiven :1; + unsigned B4SOIpegidlGiven :1; + unsigned B4SOIpntunGiven :1; /* v4.0 */ + unsigned B4SOIpntundGiven :1; /* v4.0 */ + unsigned B4SOIpndiodeGiven :1; /* v4.0 */ + unsigned B4SOIpndiodedGiven :1; /* v4.0 */ + unsigned B4SOIpnrecf0Given :1; /* v4.0 */ + unsigned B4SOIpnrecf0dGiven :1; /* v4.0 */ + unsigned B4SOIpnrecr0Given :1; /* v4.0 */ + unsigned B4SOIpnrecr0dGiven :1; /* v4.0 */ + unsigned B4SOIpisbjtGiven :1; + unsigned B4SOIpidbjtGiven :1; /* v4.0 */ + unsigned B4SOIpisdifGiven :1; + unsigned B4SOIpiddifGiven :1; /* v4.0 */ + unsigned B4SOIpisrecGiven :1; + unsigned B4SOIpidrecGiven :1; /* v4.0 */ + unsigned B4SOIpistunGiven :1; + unsigned B4SOIpidtunGiven :1; /* v4.0 */ + unsigned B4SOIpvrec0Given :1; /* v4.0 */ + unsigned B4SOIpvrec0dGiven :1; /* v4.0 */ + unsigned B4SOIpvtun0Given :1; /* v4.0 */ + unsigned B4SOIpvtun0dGiven :1; /* v4.0 */ + unsigned B4SOIpnbjtGiven :1; + unsigned B4SOIplbjt0Given :1; + unsigned B4SOIpvabjtGiven :1; + unsigned B4SOIpaelyGiven :1; + unsigned B4SOIpahliGiven :1; /* v4.0 */ + unsigned B4SOIpahlidGiven :1; /* v4.0 */ +/* v3.1 added for RF */ + unsigned B4SOIpxrcrg1Given :1; + unsigned B4SOIpxrcrg2Given :1; +/* v3.1 added for RF end */ + + /* CV model */ + unsigned B4SOIpvsdfbGiven :1; + unsigned B4SOIpvsdthGiven :1; + unsigned B4SOIpdelvtGiven :1; + unsigned B4SOIpacdeGiven :1; + unsigned B4SOIpmoinGiven :1; + unsigned B4SOIpnoffGiven :1;/* v3.2 */ + +/* Added for binning - END2 */ + + unsigned B4SOIuseFringeGiven :1; + + unsigned B4SOItnomGiven :1; + unsigned B4SOIcgsoGiven :1; + unsigned B4SOIcgdoGiven :1; + unsigned B4SOIcgeoGiven :1; + + unsigned B4SOIxpartGiven :1; + unsigned B4SOIsheetResistanceGiven :1; + unsigned B4SOIGatesidewallJctSPotentialGiven :1; /* v4.0 */ + unsigned B4SOIGatesidewallJctDPotentialGiven :1; /* v4.0 */ + unsigned B4SOIbodyJctGateSideSGradingCoeffGiven :1; /* v4.0 */ + unsigned B4SOIbodyJctGateSideDGradingCoeffGiven :1; /* v4.0 */ + unsigned B4SOIunitLengthGateSidewallJctCapSGiven :1; /* v4.0 */ + unsigned B4SOIunitLengthGateSidewallJctCapDGiven :1; /* v4.0 */ + unsigned B4SOIcsdeswGiven :1; + + unsigned B4SOIoxideTrapDensityAGiven :1; + unsigned B4SOIoxideTrapDensityBGiven :1; + unsigned B4SOIoxideTrapDensityCGiven :1; + unsigned B4SOIemGiven :1; + unsigned B4SOIefGiven :1; + unsigned B4SOIafGiven :1; + unsigned B4SOIkfGiven :1; + unsigned B4SOInoifGiven :1; + unsigned B4SOIbfGiven :1; /* v4.0 */ + unsigned B4SOIw0flkGiven :1; /* v4.0 */ + unsigned B4SOIfrbodyGiven :1; /* v4.0 */ + + unsigned B4SOILintGiven :1; + unsigned B4SOILlGiven :1; + unsigned B4SOILlcGiven :1; /* v2.2.3 */ + unsigned B4SOILlnGiven :1; + unsigned B4SOILwGiven :1; + unsigned B4SOILwcGiven :1; /* v2.2.3 */ + unsigned B4SOILwnGiven :1; + unsigned B4SOILwlGiven :1; + unsigned B4SOILwlcGiven :1; /* v2.2.3 */ + unsigned B4SOILminGiven :1; + unsigned B4SOILmaxGiven :1; + + unsigned B4SOIWintGiven :1; + unsigned B4SOIWlGiven :1; + unsigned B4SOIWlcGiven :1; /* v2.2.3 */ + unsigned B4SOIWlnGiven :1; + unsigned B4SOIWwGiven :1; + unsigned B4SOIWwcGiven :1; /* v2.2.3 */ + unsigned B4SOIWwnGiven :1; + unsigned B4SOIWwlGiven :1; + unsigned B4SOIWwlcGiven :1; /* v2.2.3 */ + unsigned B4SOIWminGiven :1; + unsigned B4SOIWmaxGiven :1; + + /* added for stress effect */ + unsigned B4SOIsarefGiven :1; + unsigned B4SOIsbrefGiven :1; + unsigned B4SOIwlodGiven :1; + unsigned B4SOIku0Given :1; + unsigned B4SOIkvsatGiven :1; + unsigned B4SOIkvth0Given :1; + unsigned B4SOItku0Given :1; + unsigned B4SOIllodku0Given :1; + unsigned B4SOIwlodku0Given :1; + unsigned B4SOIllodvthGiven :1; + unsigned B4SOIwlodvthGiven :1; + unsigned B4SOIlku0Given :1; + unsigned B4SOIwku0Given :1; + unsigned B4SOIpku0Given :1; + unsigned B4SOIlkvth0Given :1; + unsigned B4SOIwkvth0Given :1; + unsigned B4SOIpkvth0Given :1; + unsigned B4SOIstk2Given :1; + unsigned B4SOIlodk2Given :1; + unsigned B4SOIsteta0Given :1; + unsigned B4SOIlodeta0Given :1; + /* v4.0 added for stress effect end */ + unsigned B4SOIlpebGiven :1; /* v4.0 for vth */ + unsigned B4SOIllpebGiven :1; /* v4.0 for vth */ + unsigned B4SOIwlpebGiven :1; /* v4.0 for vth */ + unsigned B4SOIplpebGiven :1; /* v4.0 for vth */ + unsigned B4SOIdvtp0Given :1; /* v4.0 for vth */ + unsigned B4SOIldvtp0Given :1; /* v4.0 for vth */ + unsigned B4SOIwdvtp0Given :1; /* v4.0 for vth */ + unsigned B4SOIpdvtp0Given :1; /* v4.0 for vth */ + unsigned B4SOIdvtp1Given :1; /* v4.0 for vth */ + unsigned B4SOIldvtp1Given :1; /* v4.0 for vth */ + unsigned B4SOIwdvtp1Given :1; /* v4.0 for vth */ + unsigned B4SOIpdvtp1Given :1; /* v4.0 for vth */ + unsigned B4SOIminvGiven :1; /* v4.0 for Vgsteff */ + unsigned B4SOIlminvGiven :1; /* v4.0 for Vgsteff */ + unsigned B4SOIwminvGiven :1; /* v4.0 for Vgsteff */ + unsigned B4SOIpminvGiven :1; /* v4.0 for Vgsteff */ + unsigned B4SOIfproutGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIlfproutGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIwfproutGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIpfproutGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIpditsGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIlpditsGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIwpditsGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIppditsGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIpditsdGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIlpditsdGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIwpditsdGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIppditsdGiven :1; /* v4.0 for DITS in ID */ + unsigned B4SOIpditslGiven :1; /* v4.0 for DITS in ID */ + +} B4SOImodel; + + +#ifndef NMOS +#define NMOS 1 +#define PMOS -1 +#endif /*NMOS*/ + + +/* device parameters */ +#define B4SOI_W 1 +#define B4SOI_L 2 +#define B4SOI_M 46 +#define B4SOI_AS 3 +#define B4SOI_AD 4 +#define B4SOI_PS 5 +#define B4SOI_PD 6 +#define B4SOI_NRS 7 +#define B4SOI_NRD 8 +#define B4SOI_OFF 9 +#define B4SOI_IC_VBS 10 +#define B4SOI_IC_VDS 11 +#define B4SOI_IC_VGS 12 +#define B4SOI_IC_VES 13 +#define B4SOI_IC_VPS 14 +#define B4SOI_BJTOFF 15 +#define B4SOI_RTH0 16 +#define B4SOI_CTH0 17 +#define B4SOI_NRB 18 +#define B4SOI_IC 19 +#define B4SOI_NQSMOD 20 +#define B4SOI_DEBUG 21 + +/* v2.0 release */ +#define B4SOI_NBC 22 +#define B4SOI_NSEG 23 +#define B4SOI_PDBCP 24 +#define B4SOI_PSBCP 25 +#define B4SOI_AGBCP 26 +#define B4SOI_AEBCP 27 +#define B4SOI_VBSUSR 28 +#define B4SOI_TNODEOUT 29 +#define B4SOI_FRBODY 30 /* v2.2.2 */ +#define B4SOI_RGATEMOD 31 /* v3.1 */ +#define B4SOI_SOIMOD 32 /* v3.2 */ +#define B4SOI_NF 33 /* v4.0 */ +#define B4SOI_RBODYMOD 34 /* v4.0 */ +#define B4SOI_RBDB 35 /* v4.0 */ +#define B4SOI_RBSB 36 /* v4.0 */ +#define B4SOI_CJSB 37 /* v4.0 */ +#define B4SOI_CJDB 38 /* v4.0 */ +#define B4SOI_SA 41 /* v4.0 */ +#define B4SOI_SB 42 /* v4.0 */ +#define B4SOI_SD 43 /* v4.0 */ +#define B4SOI_DELVTO 44 /* v4.0 */ +#define B4SOI_AGBCPD 45 /* v4.0 */ + + +/* model parameters */ +#define B4SOI_MOD_CAPMOD 101 +#define B4SOI_MOD_NQSMOD 102 +#define B4SOI_MOD_MOBMOD 103 +/*#define B4SOI_MOD_NOIMOD 104 v3.2 */ +#define B4SOI_MOD_RDSMOD 104 /* v4.0 */ +#define B4SOI_MOD_SHMOD 105 +#define B4SOI_MOD_DDMOD 106 +#define B4SOI_MOD_TOX 107 + +#define B4SOI_MOD_CDSC 108 +#define B4SOI_MOD_CDSCB 109 +#define B4SOI_MOD_CIT 110 +#define B4SOI_MOD_NFACTOR 111 +#define B4SOI_MOD_XJ 112 +#define B4SOI_MOD_VSAT 113 +#define B4SOI_MOD_AT 114 +#define B4SOI_MOD_A0 115 +#define B4SOI_MOD_A1 116 +#define B4SOI_MOD_A2 117 +#define B4SOI_MOD_KETA 118 +#define B4SOI_MOD_NSUB 119 +#define B4SOI_MOD_NPEAK 120 +#define B4SOI_MOD_NGATE 121 +#define B4SOI_MOD_GAMMA1 122 +#define B4SOI_MOD_GAMMA2 123 +#define B4SOI_MOD_VBX 124 +#define B4SOI_MOD_BINUNIT 125 + +#define B4SOI_MOD_VBM 126 + +#define B4SOI_MOD_XT 127 +#define B4SOI_MOD_K1 129 +#define B4SOI_MOD_KT1 130 +#define B4SOI_MOD_KT1L 131 +#define B4SOI_MOD_K2 132 +#define B4SOI_MOD_KT2 133 +#define B4SOI_MOD_K3 134 +#define B4SOI_MOD_K3B 135 +#define B4SOI_MOD_W0 136 +#define B4SOI_MOD_LPE0 137 + +#define B4SOI_MOD_DVT0 138 +#define B4SOI_MOD_DVT1 139 +#define B4SOI_MOD_DVT2 140 + +#define B4SOI_MOD_DVT0W 141 +#define B4SOI_MOD_DVT1W 142 +#define B4SOI_MOD_DVT2W 143 + +#define B4SOI_MOD_DROUT 144 +#define B4SOI_MOD_DSUB 145 +#define B4SOI_MOD_VTH0 146 +#define B4SOI_MOD_UA 147 +#define B4SOI_MOD_UA1 148 +#define B4SOI_MOD_UB 149 +#define B4SOI_MOD_UB1 150 +#define B4SOI_MOD_UC 151 +#define B4SOI_MOD_UC1 152 +#define B4SOI_MOD_U0 153 +#define B4SOI_MOD_UTE 154 +#define B4SOI_MOD_VOFF 155 +#define B4SOI_MOD_DELTA 156 +#define B4SOI_MOD_RDSW 157 +#define B4SOI_MOD_PRT 158 +#define B4SOI_MOD_LDD 159 +#define B4SOI_MOD_ETA 160 +#define B4SOI_MOD_ETA0 161 +#define B4SOI_MOD_ETAB 162 +#define B4SOI_MOD_PCLM 163 +#define B4SOI_MOD_PDIBL1 164 +#define B4SOI_MOD_PDIBL2 165 +#define B4SOI_MOD_PSCBE1 166 +#define B4SOI_MOD_PSCBE2 167 +#define B4SOI_MOD_PVAG 168 +#define B4SOI_MOD_WR 169 +#define B4SOI_MOD_DWG 170 +#define B4SOI_MOD_DWB 171 +#define B4SOI_MOD_B0 172 +#define B4SOI_MOD_B1 173 +#define B4SOI_MOD_ALPHA0 174 +#define B4SOI_MOD_PDIBLB 178 + +#define B4SOI_MOD_PRWG 179 +#define B4SOI_MOD_PRWB 180 + +#define B4SOI_MOD_CDSCD 181 +#define B4SOI_MOD_AGS 182 + +#define B4SOI_MOD_FRINGE 184 +#define B4SOI_MOD_CGSL 186 +#define B4SOI_MOD_CGDL 187 +#define B4SOI_MOD_CKAPPA 188 +#define B4SOI_MOD_CF 189 +#define B4SOI_MOD_CLC 190 +#define B4SOI_MOD_CLE 191 +#define B4SOI_MOD_PARAMCHK 192 +#define B4SOI_MOD_VERSION 193 + +#define B4SOI_MOD_TBOX 195 +#define B4SOI_MOD_TSI 196 +#define B4SOI_MOD_KB1 197 +#define B4SOI_MOD_KB3 198 +#define B4SOI_MOD_DELP 201 +#define B4SOI_MOD_RBODY 204 +#define B4SOI_MOD_ADICE0 205 +#define B4SOI_MOD_ABP 206 +#define B4SOI_MOD_MXC 207 +#define B4SOI_MOD_RTH0 208 +#define B4SOI_MOD_CTH0 209 +#define B4SOI_MOD_ALPHA1 214 +#define B4SOI_MOD_EGIDL 215 +#define B4SOI_MOD_AGIDL 216 +#define B4SOI_MOD_BGIDL 217 +#define B4SOI_MOD_NDIODES 218 /* v4.0 */ +#define B4SOI_MOD_LDIOF 219 +#define B4SOI_MOD_LDIOR 220 +#define B4SOI_MOD_NTUNS 221 /* v4.0 */ +#define B4SOI_MOD_ISBJT 222 +#define B4SOI_MOD_ISDIF 223 +#define B4SOI_MOD_ISREC 224 +#define B4SOI_MOD_ISTUN 225 +#define B4SOI_MOD_XBJT 226 +#define B4SOI_MOD_TT 232 +#define B4SOI_MOD_VSDTH 233 +#define B4SOI_MOD_VSDFB 234 +#define B4SOI_MOD_ASD 235 +#define B4SOI_MOD_CSDMIN 236 +#define B4SOI_MOD_RBSH 237 +#define B4SOI_MOD_ESATII 238 + + +/* v2.0 release */ +#define B4SOI_MOD_K1W1 239 +#define B4SOI_MOD_K1W2 240 +#define B4SOI_MOD_KETAS 241 +#define B4SOI_MOD_DWBC 242 +#define B4SOI_MOD_BETA0 243 +#define B4SOI_MOD_BETA1 244 +#define B4SOI_MOD_BETA2 245 +#define B4SOI_MOD_VDSATII0 246 +#define B4SOI_MOD_TII 247 +#define B4SOI_MOD_LII 248 +#define B4SOI_MOD_SII0 249 +#define B4SOI_MOD_SII1 250 +#define B4SOI_MOD_SII2 251 +#define B4SOI_MOD_SIID 252 +#define B4SOI_MOD_FBJTII 253 +#define B4SOI_MOD_NRECF0S 255 +#define B4SOI_MOD_NRECR0S 256 +#define B4SOI_MOD_LN 257 +#define B4SOI_MOD_VREC0S 258 +#define B4SOI_MOD_VTUN0S 259 +#define B4SOI_MOD_NBJT 260 +#define B4SOI_MOD_LBJT0 261 +#define B4SOI_MOD_VABJT 262 +#define B4SOI_MOD_AELY 263 +#define B4SOI_MOD_AHLIS 264 /* v4.0 */ +#define B4SOI_MOD_NTRECF 265 +#define B4SOI_MOD_NTRECR 266 +#define B4SOI_MOD_DLCB 267 +#define B4SOI_MOD_FBODY 268 +#define B4SOI_MOD_NDIF 269 +#define B4SOI_MOD_ACDE 272 +#define B4SOI_MOD_MOIN 273 +#define B4SOI_MOD_DELVT 274 +#define B4SOI_MOD_DLBG 275 +#define B4SOI_MOD_LDIF0 276 + + +/* v2.2 release */ +#define B4SOI_MOD_WTH0 277 +#define B4SOI_MOD_RHALO 278 +#define B4SOI_MOD_NTOX 279 +#define B4SOI_MOD_TOXREF 280 +#define B4SOI_MOD_EBG 281 +#define B4SOI_MOD_VEVB 282 +#define B4SOI_MOD_ALPHAGB1 283 +#define B4SOI_MOD_BETAGB1 284 +#define B4SOI_MOD_VGB1 285 +#define B4SOI_MOD_VECB 286 +#define B4SOI_MOD_ALPHAGB2 287 +#define B4SOI_MOD_BETAGB2 288 +#define B4SOI_MOD_VGB2 289 +#define B4SOI_MOD_TOXQM 290 +#define B4SOI_MOD_IGBMOD 291 /* v3.0 */ +#define B4SOI_MOD_VOXH 292 +#define B4SOI_MOD_DELTAVOX 293 +#define B4SOI_MOD_IGCMOD 294 /* v3.0 */ + +/* v3.1 added for RF */ +#define B4SOI_MOD_RGATEMOD 295 +#define B4SOI_MOD_XRCRG1 296 +#define B4SOI_MOD_XRCRG2 297 +#define B4SOI_MOD_RSHG 298 +#define B4SOI_MOD_NGCON 299 +/* v3.1 added for RF end */ + +#define B4SOI_MOD_RBODYMOD 300 /* v4.0 */ + + +/* Added for binning - START3 */ +/* Length dependence */ +#define B4SOI_MOD_LNPEAK 301 +#define B4SOI_MOD_LNSUB 302 +#define B4SOI_MOD_LNGATE 303 +#define B4SOI_MOD_LVTH0 304 +#define B4SOI_MOD_LK1 305 +#define B4SOI_MOD_LK1W1 306 +#define B4SOI_MOD_LK1W2 307 +#define B4SOI_MOD_LK2 308 +#define B4SOI_MOD_LK3 309 +#define B4SOI_MOD_LK3B 310 +#define B4SOI_MOD_LKB1 311 +#define B4SOI_MOD_LW0 312 +#define B4SOI_MOD_LLPE0 313 +#define B4SOI_MOD_LDVT0 314 +#define B4SOI_MOD_LDVT1 315 +#define B4SOI_MOD_LDVT2 316 +#define B4SOI_MOD_LDVT0W 317 +#define B4SOI_MOD_LDVT1W 318 +#define B4SOI_MOD_LDVT2W 319 +#define B4SOI_MOD_LU0 320 +#define B4SOI_MOD_LUA 321 +#define B4SOI_MOD_LUB 322 +#define B4SOI_MOD_LUC 323 +#define B4SOI_MOD_LVSAT 324 +#define B4SOI_MOD_LA0 325 +#define B4SOI_MOD_LAGS 326 +#define B4SOI_MOD_LB0 327 +#define B4SOI_MOD_LB1 328 +#define B4SOI_MOD_LKETA 329 +#define B4SOI_MOD_LKETAS 330 +#define B4SOI_MOD_LA1 331 +#define B4SOI_MOD_LA2 332 +#define B4SOI_MOD_LRDSW 333 +#define B4SOI_MOD_LPRWB 334 +#define B4SOI_MOD_LPRWG 335 +#define B4SOI_MOD_LWR 336 +#define B4SOI_MOD_LNFACTOR 337 +#define B4SOI_MOD_LDWG 338 +#define B4SOI_MOD_LDWB 339 +#define B4SOI_MOD_LVOFF 340 +#define B4SOI_MOD_LETA0 341 +#define B4SOI_MOD_LETAB 342 +#define B4SOI_MOD_LDSUB 343 +#define B4SOI_MOD_LCIT 344 +#define B4SOI_MOD_LCDSC 345 +#define B4SOI_MOD_LCDSCB 346 +#define B4SOI_MOD_LCDSCD 347 +#define B4SOI_MOD_LPCLM 348 +#define B4SOI_MOD_LPDIBL1 349 +#define B4SOI_MOD_LPDIBL2 350 +#define B4SOI_MOD_LPDIBLB 351 +#define B4SOI_MOD_LDROUT 352 +#define B4SOI_MOD_LPVAG 353 +#define B4SOI_MOD_LDELTA 354 +#define B4SOI_MOD_LALPHA0 355 +#define B4SOI_MOD_LFBJTII 356 +#define B4SOI_MOD_LBETA0 357 +#define B4SOI_MOD_LBETA1 358 +#define B4SOI_MOD_LBETA2 359 +#define B4SOI_MOD_LVDSATII0 360 +#define B4SOI_MOD_LLII 361 +#define B4SOI_MOD_LESATII 362 +#define B4SOI_MOD_LSII0 363 +#define B4SOI_MOD_LSII1 364 +#define B4SOI_MOD_LSII2 365 +#define B4SOI_MOD_LSIID 366 +#define B4SOI_MOD_LAGIDL 367 +#define B4SOI_MOD_LBGIDL 368 +#define B4SOI_MOD_LEGIDL 369 +#define B4SOI_MOD_LNTUNS 370 /* v4.0 */ +#define B4SOI_MOD_LNDIODES 371 +#define B4SOI_MOD_LNRECF0S 372 +#define B4SOI_MOD_LNRECR0S 373 +#define B4SOI_MOD_LISBJT 374 +#define B4SOI_MOD_LISDIF 375 +#define B4SOI_MOD_LISREC 376 +#define B4SOI_MOD_LISTUN 377 +#define B4SOI_MOD_LVREC0S 378 +#define B4SOI_MOD_LVTUN0S 379 +#define B4SOI_MOD_LNBJT 380 +#define B4SOI_MOD_LLBJT0 381 +#define B4SOI_MOD_LVABJT 382 +#define B4SOI_MOD_LAELY 383 +#define B4SOI_MOD_LAHLIS 384 /* v4.0 */ +#define B4SOI_MOD_LVSDFB 385 +#define B4SOI_MOD_LVSDTH 386 +#define B4SOI_MOD_LDELVT 387 +#define B4SOI_MOD_LACDE 388 +#define B4SOI_MOD_LMOIN 389 + +/* v3.1 added for RF */ +#define B4SOI_MOD_LXRCRG1 390 +#define B4SOI_MOD_LXRCRG2 391 +#define B4SOI_MOD_XGW 392 +#define B4SOI_MOD_XGL 393 +/* v3.1 added for RF end */ + +/* Width dependence */ +#define B4SOI_MOD_WNPEAK 401 +#define B4SOI_MOD_WNSUB 402 +#define B4SOI_MOD_WNGATE 403 +#define B4SOI_MOD_WVTH0 404 +#define B4SOI_MOD_WK1 405 +#define B4SOI_MOD_WK1W1 406 +#define B4SOI_MOD_WK1W2 407 +#define B4SOI_MOD_WK2 408 +#define B4SOI_MOD_WK3 409 +#define B4SOI_MOD_WK3B 410 +#define B4SOI_MOD_WKB1 411 +#define B4SOI_MOD_WW0 412 +#define B4SOI_MOD_WLPE0 413 +#define B4SOI_MOD_WDVT0 414 +#define B4SOI_MOD_WDVT1 415 +#define B4SOI_MOD_WDVT2 416 +#define B4SOI_MOD_WDVT0W 417 +#define B4SOI_MOD_WDVT1W 418 +#define B4SOI_MOD_WDVT2W 419 +#define B4SOI_MOD_WU0 420 +#define B4SOI_MOD_WUA 421 +#define B4SOI_MOD_WUB 422 +#define B4SOI_MOD_WUC 423 +#define B4SOI_MOD_WVSAT 424 +#define B4SOI_MOD_WA0 425 +#define B4SOI_MOD_WAGS 426 +#define B4SOI_MOD_WB0 427 +#define B4SOI_MOD_WB1 428 +#define B4SOI_MOD_WKETA 429 +#define B4SOI_MOD_WKETAS 430 +#define B4SOI_MOD_WA1 431 +#define B4SOI_MOD_WA2 432 +#define B4SOI_MOD_WRDSW 433 +#define B4SOI_MOD_WPRWB 434 +#define B4SOI_MOD_WPRWG 435 +#define B4SOI_MOD_WWR 436 +#define B4SOI_MOD_WNFACTOR 437 +#define B4SOI_MOD_WDWG 438 +#define B4SOI_MOD_WDWB 439 +#define B4SOI_MOD_WVOFF 440 +#define B4SOI_MOD_WETA0 441 +#define B4SOI_MOD_WETAB 442 +#define B4SOI_MOD_WDSUB 443 +#define B4SOI_MOD_WCIT 444 +#define B4SOI_MOD_WCDSC 445 +#define B4SOI_MOD_WCDSCB 446 +#define B4SOI_MOD_WCDSCD 447 +#define B4SOI_MOD_WPCLM 448 +#define B4SOI_MOD_WPDIBL1 449 +#define B4SOI_MOD_WPDIBL2 450 +#define B4SOI_MOD_WPDIBLB 451 +#define B4SOI_MOD_WDROUT 452 +#define B4SOI_MOD_WPVAG 453 +#define B4SOI_MOD_WDELTA 454 +#define B4SOI_MOD_WALPHA0 455 +#define B4SOI_MOD_WFBJTII 456 +#define B4SOI_MOD_WBETA0 457 +#define B4SOI_MOD_WBETA1 458 +#define B4SOI_MOD_WBETA2 459 +#define B4SOI_MOD_WVDSATII0 460 +#define B4SOI_MOD_WLII 461 +#define B4SOI_MOD_WESATII 462 +#define B4SOI_MOD_WSII0 463 +#define B4SOI_MOD_WSII1 464 +#define B4SOI_MOD_WSII2 465 +#define B4SOI_MOD_WSIID 466 +#define B4SOI_MOD_WAGIDL 467 +#define B4SOI_MOD_WBGIDL 468 +#define B4SOI_MOD_WEGIDL 469 +#define B4SOI_MOD_WNTUNS 470 /* v4.0 */ +#define B4SOI_MOD_WNDIODES 471 +#define B4SOI_MOD_WNRECF0S 472 +#define B4SOI_MOD_WNRECR0S 473 +#define B4SOI_MOD_WISBJT 474 +#define B4SOI_MOD_WISDIF 475 +#define B4SOI_MOD_WISREC 476 +#define B4SOI_MOD_WISTUN 477 +#define B4SOI_MOD_WVREC0S 478 +#define B4SOI_MOD_WVTUN0S 479 +#define B4SOI_MOD_WNBJT 480 +#define B4SOI_MOD_WLBJT0 481 +#define B4SOI_MOD_WVABJT 482 +#define B4SOI_MOD_WAELY 483 +#define B4SOI_MOD_WAHLIS 484 /* v4.0 */ +#define B4SOI_MOD_WVSDFB 485 +#define B4SOI_MOD_WVSDTH 486 +#define B4SOI_MOD_WDELVT 487 +#define B4SOI_MOD_WACDE 488 +#define B4SOI_MOD_WMOIN 489 + +/* v3.1 added for RF */ +#define B4SOI_MOD_WXRCRG1 490 +#define B4SOI_MOD_WXRCRG2 491 +/* v3.1 added for RF end */ + +/* Cross-term dependence */ +#define B4SOI_MOD_PNPEAK 501 +#define B4SOI_MOD_PNSUB 502 +#define B4SOI_MOD_PNGATE 503 +#define B4SOI_MOD_PVTH0 504 +#define B4SOI_MOD_PK1 505 +#define B4SOI_MOD_PK1W1 506 +#define B4SOI_MOD_PK1W2 507 +#define B4SOI_MOD_PK2 508 +#define B4SOI_MOD_PK3 509 +#define B4SOI_MOD_PK3B 510 +#define B4SOI_MOD_PKB1 511 +#define B4SOI_MOD_PW0 512 +#define B4SOI_MOD_PLPE0 513 +#define B4SOI_MOD_PDVT0 514 +#define B4SOI_MOD_PDVT1 515 +#define B4SOI_MOD_PDVT2 516 +#define B4SOI_MOD_PDVT0W 517 +#define B4SOI_MOD_PDVT1W 518 +#define B4SOI_MOD_PDVT2W 519 +#define B4SOI_MOD_PU0 520 +#define B4SOI_MOD_PUA 521 +#define B4SOI_MOD_PUB 522 +#define B4SOI_MOD_PUC 523 +#define B4SOI_MOD_PVSAT 524 +#define B4SOI_MOD_PA0 525 +#define B4SOI_MOD_PAGS 526 +#define B4SOI_MOD_PB0 527 +#define B4SOI_MOD_PB1 528 +#define B4SOI_MOD_PKETA 529 +#define B4SOI_MOD_PKETAS 530 +#define B4SOI_MOD_PA1 531 +#define B4SOI_MOD_PA2 532 +#define B4SOI_MOD_PRDSW 533 +#define B4SOI_MOD_PPRWB 534 +#define B4SOI_MOD_PPRWG 535 +#define B4SOI_MOD_PWR 536 +#define B4SOI_MOD_PNFACTOR 537 +#define B4SOI_MOD_PDWG 538 +#define B4SOI_MOD_PDWB 539 +#define B4SOI_MOD_PVOFF 540 +#define B4SOI_MOD_PETA0 541 +#define B4SOI_MOD_PETAB 542 +#define B4SOI_MOD_PDSUB 543 +#define B4SOI_MOD_PCIT 544 +#define B4SOI_MOD_PCDSC 545 +#define B4SOI_MOD_PCDSCB 546 +#define B4SOI_MOD_PCDSCD 547 +#define B4SOI_MOD_PPCLM 548 +#define B4SOI_MOD_PPDIBL1 549 +#define B4SOI_MOD_PPDIBL2 550 +#define B4SOI_MOD_PPDIBLB 551 +#define B4SOI_MOD_PDROUT 552 +#define B4SOI_MOD_PPVAG 553 +#define B4SOI_MOD_PDELTA 554 +#define B4SOI_MOD_PALPHA0 555 +#define B4SOI_MOD_PFBJTII 556 +#define B4SOI_MOD_PBETA0 557 +#define B4SOI_MOD_PBETA1 558 +#define B4SOI_MOD_PBETA2 559 +#define B4SOI_MOD_PVDSATII0 560 +#define B4SOI_MOD_PLII 561 +#define B4SOI_MOD_PESATII 562 +#define B4SOI_MOD_PSII0 563 +#define B4SOI_MOD_PSII1 564 +#define B4SOI_MOD_PSII2 565 +#define B4SOI_MOD_PSIID 566 +#define B4SOI_MOD_PAGIDL 567 +#define B4SOI_MOD_PBGIDL 568 +#define B4SOI_MOD_PEGIDL 569 +#define B4SOI_MOD_PNTUNS 570 /* v4.0 */ +#define B4SOI_MOD_PNDIODES 571 +#define B4SOI_MOD_PNRECF0S 572 +#define B4SOI_MOD_PNRECR0S 573 +#define B4SOI_MOD_PISBJT 574 +#define B4SOI_MOD_PISDIF 575 +#define B4SOI_MOD_PISREC 576 +#define B4SOI_MOD_PISTUN 577 +#define B4SOI_MOD_PVREC0S 578 +#define B4SOI_MOD_PVTUN0S 579 +#define B4SOI_MOD_PNBJT 580 +#define B4SOI_MOD_PLBJT0 581 +#define B4SOI_MOD_PVABJT 582 +#define B4SOI_MOD_PAELY 583 +#define B4SOI_MOD_PAHLIS 584 /* v4.0 */ +#define B4SOI_MOD_PVSDFB 585 +#define B4SOI_MOD_PVSDTH 586 +#define B4SOI_MOD_PDELVT 587 +#define B4SOI_MOD_PACDE 588 +#define B4SOI_MOD_PMOIN 589 +#define B4SOI_MOD_PXRCRG1 590 /* v3.1 for RF */ +#define B4SOI_MOD_PXRCRG2 591 /* v3.1 for RF */ +#define B4SOI_MOD_EM 592 /* v3.2 for noise */ +#define B4SOI_MOD_EF 593 /* v3.2 for noise */ +#define B4SOI_MOD_AF 594 /* v3.2 for noise */ +#define B4SOI_MOD_KF 595 /* v3.2 for noise */ +#define B4SOI_MOD_NOIF 596 /* v3.2 for noise */ +#define B4SOI_MOD_BF 597 /* v4.0 for noise */ +#define B4SOI_MOD_W0FLK 598 /* v4.0 for noise */ +#define B4SOI_MOD_FRBODY 599 /* v4.0 for Rbody */ +#define B4SOI_MOD_CGIDL 600 /* v4.0 for gidl */ +#define B4SOI_MOD_LCGIDL 601 /* v4.0 for gidl */ +#define B4SOI_MOD_WCGIDL 602 /* v4.0 for gidl */ +#define B4SOI_MOD_PCGIDL 603 /* v4.0 for gidl */ +#define B4SOI_MOD_LPEB 604 /* v4.0 for Vth */ +#define B4SOI_MOD_LLPEB 605 /* v4.0 for Vth */ +#define B4SOI_MOD_WLPEB 606 /* v4.0 for Vth */ +#define B4SOI_MOD_PLPEB 607 /* v4.0 for Vth */ +#define B4SOI_MOD_DVTP0 608 /* v4.0 for Vth */ +#define B4SOI_MOD_LDVTP0 609 /* v4.0 for Vth */ +#define B4SOI_MOD_WDVTP0 610 /* v4.0 for Vth */ +#define B4SOI_MOD_PDVTP0 611 /* v4.0 for Vth */ +#define B4SOI_MOD_DVTP1 612 /* v4.0 for Vth */ +#define B4SOI_MOD_LDVTP1 613 /* v4.0 for Vth */ +#define B4SOI_MOD_WDVTP1 614 /* v4.0 for Vth */ +#define B4SOI_MOD_PDVTP1 615 /* v4.0 for Vth */ +#define B4SOI_MOD_MINV 616 /* v4.0 for Vgsteff */ +#define B4SOI_MOD_LMINV 617 /* v4.0 for Vgsteff */ +#define B4SOI_MOD_WMINV 618 /* v4.0 for Vgsteff */ +#define B4SOI_MOD_PMINV 619 /* v4.0 for Vgsteff */ +#define B4SOI_MOD_FPROUT 620 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_LFPROUT 621 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_WFPROUT 622 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_PFPROUT 623 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_PDITS 624 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_LPDITS 625 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_WPDITS 626 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_PPDITS 627 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_PDITSD 628 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_LPDITSD 629 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_WPDITSD 630 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_PPDITSD 631 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_PDITSL 632 /* v4.0 for DITS in Id */ +#define B4SOI_MOD_NDIODED 633 /* v4.0 */ +#define B4SOI_MOD_LNDIODED 634 /* v4.0 */ +#define B4SOI_MOD_WNDIODED 635 /* v4.0 */ +#define B4SOI_MOD_PNDIODED 636 /* v4.0 */ +#define B4SOI_MOD_IDDIF 637 /* v4.0 */ +#define B4SOI_MOD_LIDDIF 638 /* v4.0 */ +#define B4SOI_MOD_WIDDIF 639 /* v4.0 */ +#define B4SOI_MOD_PIDDIF 640 /* v4.0 */ +#define B4SOI_MOD_IDBJT 641 /* v4.0 */ +#define B4SOI_MOD_LIDBJT 642 /* v4.0 */ +#define B4SOI_MOD_WIDBJT 643 /* v4.0 */ +#define B4SOI_MOD_PIDBJT 644 /* v4.0 */ +#define B4SOI_MOD_IDREC 645 /* v4.0 */ +#define B4SOI_MOD_LIDREC 646 /* v4.0 */ +#define B4SOI_MOD_WIDREC 647 /* v4.0 */ +#define B4SOI_MOD_PIDREC 648 /* v4.0 */ +#define B4SOI_MOD_IDTUN 649 /* v4.0 */ +#define B4SOI_MOD_LIDTUN 650 /* v4.0 */ +#define B4SOI_MOD_WIDTUN 651 /* v4.0 */ +#define B4SOI_MOD_PIDTUN 652 /* v4.0 */ +#define B4SOI_MOD_NRECF0D 653 /* v4.0 */ +#define B4SOI_MOD_LNRECF0D 654 /* v4.0 */ +#define B4SOI_MOD_WNRECF0D 655 /* v4.0 */ +#define B4SOI_MOD_PNRECF0D 656 /* v4.0 */ +#define B4SOI_MOD_NRECR0D 657 /* v4.0 */ +#define B4SOI_MOD_LNRECR0D 658 /* v4.0 */ +#define B4SOI_MOD_WNRECR0D 659 /* v4.0 */ +#define B4SOI_MOD_PNRECR0D 660 /* v4.0 */ +#define B4SOI_MOD_VREC0D 661 /* v4.0 */ +#define B4SOI_MOD_LVREC0D 662 /* v4.0 */ +#define B4SOI_MOD_WVREC0D 663 /* v4.0 */ +#define B4SOI_MOD_PVREC0D 664 /* v4.0 */ +#define B4SOI_MOD_VTUN0D 665 /* v4.0 */ +#define B4SOI_MOD_LVTUN0D 666 /* v4.0 */ +#define B4SOI_MOD_WVTUN0D 667 /* v4.0 */ +#define B4SOI_MOD_PVTUN0D 668 /* v4.0 */ +#define B4SOI_MOD_NTUND 669 /* v4.0 */ +#define B4SOI_MOD_LNTUND 670 /* v4.0 */ +#define B4SOI_MOD_WNTUND 671 /* v4.0 */ +#define B4SOI_MOD_PNTUND 672 /* v4.0 */ +#define B4SOI_MOD_RDW 673 /* v4.0 for rdsMod =1 */ +#define B4SOI_MOD_LRDW 674 /* v4.0 for rdsMod =1 */ +#define B4SOI_MOD_WRDW 675 /* v4.0 for rdsMod =1 */ +#define B4SOI_MOD_PRDW 676 /* v4.0 for rdsMod =1 */ +#define B4SOI_MOD_RSW 677 /* v4.0 for rdsMod =1 */ +#define B4SOI_MOD_LRSW 678 /* v4.0 for rdsMod =1 */ +#define B4SOI_MOD_WRSW 679 /* v4.0 for rdsMod =1 */ +#define B4SOI_MOD_PRSW 680 /* v4.0 for rdsMod =1 */ +#define B4SOI_MOD_RDWMIN 681 /* v4.0 for rdsMod =1 */ +#define B4SOI_MOD_RSWMIN 682 /* v4.0 for rdsMod =1 */ +#define B4SOI_MOD_AHLID 683 /* v4.0 */ +#define B4SOI_MOD_LAHLID 684 /* v4.0 */ +#define B4SOI_MOD_WAHLID 685 /* v4.0 */ +#define B4SOI_MOD_PAHLID 686 /* v4.0 */ + +/* Added for binning - END3 */ + +#define B4SOI_MOD_TNOM 701 +#define B4SOI_MOD_CGSO 702 +#define B4SOI_MOD_CGDO 703 +#define B4SOI_MOD_CGEO 704 +#define B4SOI_MOD_XPART 705 +#define B4SOI_MOD_RSH 706 + + +#define B4SOI_MOD_NMOS 814 +#define B4SOI_MOD_PMOS 815 + +#define B4SOI_MOD_NOIA 816 +#define B4SOI_MOD_NOIB 817 +#define B4SOI_MOD_NOIC 818 + +#define B4SOI_MOD_LINT 819 +#define B4SOI_MOD_LL 820 +#define B4SOI_MOD_LLN 821 +#define B4SOI_MOD_LW 822 +#define B4SOI_MOD_LWN 823 +#define B4SOI_MOD_LWL 824 + +#define B4SOI_MOD_WINT 827 +#define B4SOI_MOD_WL 828 +#define B4SOI_MOD_WLN 829 +#define B4SOI_MOD_WW 830 +#define B4SOI_MOD_WWN 831 +#define B4SOI_MOD_WWL 832 + +/* v2.2.3 */ +#define B4SOI_MOD_LWLC 841 +#define B4SOI_MOD_LLC 842 +#define B4SOI_MOD_LWC 843 +#define B4SOI_MOD_WWLC 844 +#define B4SOI_MOD_WLC 845 +#define B4SOI_MOD_WWC 846 +#define B4SOI_MOD_DTOXCV 847 + +#define B4SOI_MOD_DWC 848 +#define B4SOI_MOD_DLC 849 + + + +#define B4SOI_MOD_PBSWGS 860 /* v4.0 */ +#define B4SOI_MOD_MJSWGS 861 /* v4.0 */ +#define B4SOI_MOD_CJSWGS 862 /* v4.0 */ +#define B4SOI_MOD_CSDESW 863 + +#define B4SOI_MOD_XDIFS 870 +#define B4SOI_MOD_XRECS 871 +#define B4SOI_MOD_XTUNS 872 +#define B4SOI_MOD_XDIFD 873 +#define B4SOI_MOD_XRECD 874 +#define B4SOI_MOD_XTUND 875 +#define B4SOI_MOD_LXDIFS 876 +#define B4SOI_MOD_LXRECS 877 +#define B4SOI_MOD_LXTUNS 878 +#define B4SOI_MOD_LXDIFD 879 +#define B4SOI_MOD_LXRECD 880 +#define B4SOI_MOD_LXTUND 881 +#define B4SOI_MOD_WXDIFS 882 +#define B4SOI_MOD_WXRECS 883 +#define B4SOI_MOD_WXTUNS 884 +#define B4SOI_MOD_WXDIFD 885 +#define B4SOI_MOD_WXRECD 886 +#define B4SOI_MOD_WXTUND 887 +#define B4SOI_MOD_PXDIFS 888 +#define B4SOI_MOD_PXRECS 889 +#define B4SOI_MOD_PXTUNS 890 +#define B4SOI_MOD_PXDIFD 891 +#define B4SOI_MOD_PXRECD 892 +#define B4SOI_MOD_PXTUND 893 +#define B4SOI_MOD_TCJSWGS 894 +#define B4SOI_MOD_TPBSWGS 895 +#define B4SOI_MOD_TCJSWGD 896 +#define B4SOI_MOD_TPBSWGD 897 + +/* device questions */ +#define B4SOI_DNODE 901 +#define B4SOI_GNODE 902 +#define B4SOI_SNODE 903 +#define B4SOI_BNODE 904 +#define B4SOI_ENODE 905 +#define B4SOI_DNODEPRIME 906 +#define B4SOI_SNODEPRIME 907 +#define B4SOI_VBD 908 +#define B4SOI_VBS 909 +#define B4SOI_VGS 910 +#define B4SOI_VES 911 +#define B4SOI_VDS 912 +#define B4SOI_CD 913 +#define B4SOI_CBS 914 +#define B4SOI_CBD 915 +#define B4SOI_GM 916 +#define B4SOI_GDS 917 +#define B4SOI_GMBS 918 +#define B4SOI_GBD 919 +#define B4SOI_GBS 920 +#define B4SOI_QB 921 +#define B4SOI_CQB 922 +#define B4SOI_QG 923 +#define B4SOI_CQG 924 +#define B4SOI_QD 925 +#define B4SOI_CQD 926 +#define B4SOI_CGG 927 +#define B4SOI_CGD 928 +#define B4SOI_CGS 929 +#define B4SOI_CBG 930 +#define B4SOI_CAPBD 931 +#define B4SOI_CQBD 932 +#define B4SOI_CAPBS 933 +#define B4SOI_CQBS 934 +#define B4SOI_CDG 935 +#define B4SOI_CDD 936 +#define B4SOI_CDS 937 +#define B4SOI_VON 938 +#define B4SOI_VDSAT 939 +#define B4SOI_QBS 940 +#define B4SOI_QBD 941 +#define B4SOI_SOURCECONDUCT 942 +#define B4SOI_DRAINCONDUCT 943 +#define B4SOI_CBDB 944 +#define B4SOI_CBSB 945 +#define B4SOI_GMID 946 +#define B4SOI_QS 955 + +/* v3.1 added for RF */ +#define B4SOI_GNODEEXT 947 +#define B4SOI_GNODEMID 948 +/* v3.1 added for RF end */ + +/* v4.0 */ +#define B4SOI_DBNODE 949 +#define B4SOI_SBNODE 950 +/* v4.0 end */ +#define B4SOI_IBS 3002 +#define B4SOI_IBD 3003 +#define B4SOI_ISUB 3004 +#define B4SOI_IGIDL 3005 +#define B4SOI_IGS 3006 +#define B4SOI_IGD 3007 +#define B4SOI_IGB 3008 +#define B4SOI_IGCS 3009 +#define B4SOI_IGCD 3010 + +/* v3.2 */ +#define B4SOI_MOD_TNOIA 951 +#define B4SOI_MOD_TNOIB 952 +#define B4SOI_MOD_RNOIA 953 +#define B4SOI_MOD_RNOIB 954 +#define B4SOI_MOD_NTNOI 955 +#define B4SOI_MOD_FNOIMOD 956 +#define B4SOI_MOD_TNOIMOD 957 +#define B4SOI_MOD_NOFF 958 +#define B4SOI_MOD_LNOFF 959 +#define B4SOI_MOD_WNOFF 960 +#define B4SOI_MOD_PNOFF 961 +#define B4SOI_MOD_TOXM 962 +#define B4SOI_MOD_VBS0PD 963 +#define B4SOI_MOD_VBS0FD 964 +/* v3.2 */ + +/* v4.0 added for stress */ +#define B4SOI_MOD_SAREF 965 +#define B4SOI_MOD_SBREF 966 +#define B4SOI_MOD_KU0 967 +#define B4SOI_MOD_KVSAT 968 +#define B4SOI_MOD_TKU0 969 +#define B4SOI_MOD_LLODKU0 970 +#define B4SOI_MOD_WLODKU0 971 +#define B4SOI_MOD_LLODVTH 972 +#define B4SOI_MOD_WLODVTH 973 +#define B4SOI_MOD_LKU0 974 +#define B4SOI_MOD_WKU0 975 +#define B4SOI_MOD_PKU0 976 +#define B4SOI_MOD_KVTH0 977 +#define B4SOI_MOD_LKVTH0 978 +#define B4SOI_MOD_WKVTH0 979 +#define B4SOI_MOD_PKVTH0 980 +#define B4SOI_MOD_WLOD 981 +#define B4SOI_MOD_STK2 982 +#define B4SOI_MOD_LODK2 983 +#define B4SOI_MOD_STETA0 984 +#define B4SOI_MOD_LODETA0 985 +/* v4.0 added for stress end */ +#define B4SOI_MOD_GBMIN 986 /* v4.0 */ +#define B4SOI_MOD_RBDB 987 /* v4.0 */ +#define B4SOI_MOD_RBSB 988 /* v4.0 */ +#define B4SOI_MOD_MJSWGD 989 /* v4.0 */ +#define B4SOI_MOD_CJSWGD 990 /* v4.0 */ +#define B4SOI_MOD_PBSWGD 991 /* v4.0 */ + + +/* v3.0 */ +#define B4SOI_MOD_SOIMOD 1001 +#define B4SOI_MOD_VBSA 1002 +#define B4SOI_MOD_NOFFFD 1003 +#define B4SOI_MOD_VOFFFD 1004 +#define B4SOI_MOD_K1B 1005 +#define B4SOI_MOD_K2B 1006 +#define B4SOI_MOD_DK2B 1007 +#define B4SOI_MOD_DVBD0 1008 +#define B4SOI_MOD_DVBD1 1009 +#define B4SOI_MOD_MOINFD 1010 + +/* v3.0 */ +#define B4SOI_MOD_AIGC 1021 +#define B4SOI_MOD_BIGC 1022 +#define B4SOI_MOD_CIGC 1023 +#define B4SOI_MOD_AIGSD 1024 +#define B4SOI_MOD_BIGSD 1025 +#define B4SOI_MOD_CIGSD 1026 +#define B4SOI_MOD_NIGC 1027 +#define B4SOI_MOD_PIGCD 1028 +#define B4SOI_MOD_POXEDGE 1029 +#define B4SOI_MOD_DLCIG 1030 + +#define B4SOI_MOD_LAIGC 1031 +#define B4SOI_MOD_LBIGC 1032 +#define B4SOI_MOD_LCIGC 1033 +#define B4SOI_MOD_LAIGSD 1034 +#define B4SOI_MOD_LBIGSD 1035 +#define B4SOI_MOD_LCIGSD 1036 +#define B4SOI_MOD_LNIGC 1037 +#define B4SOI_MOD_LPIGCD 1038 +#define B4SOI_MOD_LPOXEDGE 1039 + +#define B4SOI_MOD_WAIGC 1041 +#define B4SOI_MOD_WBIGC 1042 +#define B4SOI_MOD_WCIGC 1043 +#define B4SOI_MOD_WAIGSD 1044 +#define B4SOI_MOD_WBIGSD 1045 +#define B4SOI_MOD_WCIGSD 1046 +#define B4SOI_MOD_WNIGC 1047 +#define B4SOI_MOD_WPIGCD 1048 +#define B4SOI_MOD_WPOXEDGE 1049 + +#define B4SOI_MOD_PAIGC 1051 +#define B4SOI_MOD_PBIGC 1052 +#define B4SOI_MOD_PCIGC 1053 +#define B4SOI_MOD_PAIGSD 1054 +#define B4SOI_MOD_PBIGSD 1055 +#define B4SOI_MOD_PCIGSD 1056 +#define B4SOI_MOD_PNIGC 1057 +#define B4SOI_MOD_PPIGCD 1058 +#define B4SOI_MOD_PPOXEDGE 1059 + +/* v3.1 */ +#define B4SOI_MOD_LXJ 1061 +#define B4SOI_MOD_LALPHAGB1 1062 +#define B4SOI_MOD_LALPHAGB2 1063 +#define B4SOI_MOD_LBETAGB1 1064 +#define B4SOI_MOD_LBETAGB2 1065 +#define B4SOI_MOD_LNDIF 1066 +#define B4SOI_MOD_LNTRECF 1067 +#define B4SOI_MOD_LNTRECR 1068 +#define B4SOI_MOD_LXBJT 1069 +#define B4SOI_MOD_LCGDL 1073 +#define B4SOI_MOD_LCGSL 1074 +#define B4SOI_MOD_LCKAPPA 1075 +#define B4SOI_MOD_LUTE 1078 +#define B4SOI_MOD_LKT1 1079 +#define B4SOI_MOD_LKT2 1080 +#define B4SOI_MOD_LKT1L 1081 +#define B4SOI_MOD_LUA1 1082 +#define B4SOI_MOD_LUB1 1083 +#define B4SOI_MOD_LUC1 1084 +#define B4SOI_MOD_LAT 1085 +#define B4SOI_MOD_LPRT 1086 + +#define B4SOI_MOD_WXJ 1091 +#define B4SOI_MOD_WALPHAGB1 1092 +#define B4SOI_MOD_WALPHAGB2 1093 +#define B4SOI_MOD_WBETAGB1 1094 +#define B4SOI_MOD_WBETAGB2 1095 +#define B4SOI_MOD_WNDIF 1096 +#define B4SOI_MOD_WNTRECF 1097 +#define B4SOI_MOD_WNTRECR 1098 +#define B4SOI_MOD_WXBJT 1099 +#define B4SOI_MOD_WCGDL 2003 +#define B4SOI_MOD_WCGSL 2004 +#define B4SOI_MOD_WCKAPPA 2005 +#define B4SOI_MOD_WUTE 2008 +#define B4SOI_MOD_WKT1 2009 +#define B4SOI_MOD_WKT2 2010 +#define B4SOI_MOD_WKT1L 2011 +#define B4SOI_MOD_WUA1 2012 +#define B4SOI_MOD_WUB1 2013 +#define B4SOI_MOD_WUC1 2014 +#define B4SOI_MOD_WAT 2015 +#define B4SOI_MOD_WPRT 2016 + +#define B4SOI_MOD_PXJ 2021 +#define B4SOI_MOD_PALPHAGB1 2022 +#define B4SOI_MOD_PALPHAGB2 2023 +#define B4SOI_MOD_PBETAGB1 2024 +#define B4SOI_MOD_PBETAGB2 2025 +#define B4SOI_MOD_PNDIF 2026 +#define B4SOI_MOD_PNTRECF 2027 +#define B4SOI_MOD_PNTRECR 2028 +#define B4SOI_MOD_PXBJT 2029 +#define B4SOI_MOD_PCGDL 2033 +#define B4SOI_MOD_PCGSL 2034 +#define B4SOI_MOD_PCKAPPA 2035 +#define B4SOI_MOD_PUTE 2038 +#define B4SOI_MOD_PKT1 2039 +#define B4SOI_MOD_PKT2 2040 +#define B4SOI_MOD_PKT1L 2041 +#define B4SOI_MOD_PUA1 2042 +#define B4SOI_MOD_PUB1 2043 +#define B4SOI_MOD_PUC1 2044 +#define B4SOI_MOD_PAT 2045 +#define B4SOI_MOD_PPRT 2046 + +/* 4.0 backward compatibility */ +#define B4SOI_MOD_NGIDL 2100 +#define B4SOI_MOD_LNGIDL 2101 +#define B4SOI_MOD_WNGIDL 2102 +#define B4SOI_MOD_PNGIDL 2103 +#define B4SOI_MOD_NLX 2104 +#define B4SOI_MOD_LNLX 2105 +#define B4SOI_MOD_WNLX 2106 +#define B4SOI_MOD_PNLX 2107 + +#include "b4soiext.h" + +#ifdef __STDC__ +extern void B4SOIevaluate(double,double,double,B4SOIinstance*,B4SOImodel*, + double*,double*,double*, double*, double*, double*, double*, + double*, double*, double*, double*, double*, double*, double*, + double*, double*, double*, double*, CKTcircuit*); +extern int B4SOIdebug(B4SOImodel*, B4SOIinstance*, CKTcircuit*, int); +extern int B4SOIcheckModel(B4SOImodel*, B4SOIinstance*, CKTcircuit*); +#else /* stdc */ +extern void B4SOIevaluate(); +extern int B4SOIdebug(); +extern int B4SOIcheckModel(); +#endif /* stdc */ + +#endif /*B4SOI*/ + diff --git a/src/spicelib/devices/bsim3soi/b4soidel.c b/src/spicelib/devices/bsim3soi/b4soidel.c new file mode 100644 index 000000000..961f76a69 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soidel.c @@ -0,0 +1,41 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soidel.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soidel.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "b4soidef.h" +#include "sperror.h" +#include "gendefs.h" +#include "suffix.h" + + +int +B4SOIdelete(GENmodel *inModel, IFuid name, GENinstance **inInst) +{ +B4SOIinstance **fast = (B4SOIinstance**)inInst; +B4SOImodel *model = (B4SOImodel*)inModel; +B4SOIinstance **prev = NULL; +B4SOIinstance *here; + + for (; model ; model = model->B4SOInextModel) + { prev = &(model->B4SOIinstances); + for (here = *prev; here ; here = *prev) + { if (here->B4SOIname == name || (fast && here==*fast)) + { *prev= here->B4SOInextInstance; + FREE(here); + return(OK); + } + prev = &(here->B4SOInextInstance); + } + } + return(E_NODEV); +} + + diff --git a/src/spicelib/devices/bsim3soi/b4soidest.c b/src/spicelib/devices/bsim3soi/b4soidest.c new file mode 100644 index 000000000..5769afaa2 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soidest.c @@ -0,0 +1,41 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soidest.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soidest.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "b4soidef.h" +#include "suffix.h" + +void +B4SOIdestroy(GENmodel **inModel) +{ +B4SOImodel **model = (B4SOImodel**)inModel; +B4SOIinstance *here; +B4SOIinstance *prev = NULL; +B4SOImodel *mod = *model; +B4SOImodel *oldmod = NULL; + + for (; mod ; mod = mod->B4SOInextModel) + { if(oldmod) FREE(oldmod); + oldmod = mod; + prev = (B4SOIinstance *)NULL; + for (here = mod->B4SOIinstances; here; here = here->B4SOInextInstance) + { if(prev) FREE(prev); + prev = here; + } + if(prev) FREE(prev); + } + if(oldmod) FREE(oldmod); + *model = NULL; + return; +} + + + diff --git a/src/spicelib/devices/bsim3soi/b4soiext.h b/src/spicelib/devices/bsim3soi/b4soiext.h new file mode 100644 index 000000000..dcdb8bcf1 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soiext.h @@ -0,0 +1,53 @@ +/********** +Copyright 2005 Regents of the University of California. All rights reserved. +Author: 2005 Hui Wan (based on Samuel Fung's b3soiext.h) +File: b4soiext.h +**********/ + +#ifdef __STDC__ +extern int B4SOIacLoad(GENmodel *,CKTcircuit*); +extern int B4SOIask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*); +extern int B4SOIconvTest(GENmodel *,CKTcircuit*); +extern int B4SOIdelete(GENmodel*,IFuid,GENinstance**); +extern void B4SOIdestroy(GENmodel**); +extern int B4SOIgetic(GENmodel*,CKTcircuit*); +extern int B4SOIload(GENmodel*,CKTcircuit*); +extern int B4SOImAsk(CKTcircuit*,GENmodel *,int, IFvalue*); +extern int B4SOImDelete(GENmodel**,IFuid,GENmodel*); +extern int B4SOImParam(int,IFvalue*,GENmodel*); +extern void B4SOImosCap(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 B4SOIparam(int,IFvalue*,GENinstance*,IFvalue*); +extern int B4SOIpzLoad(GENmodel*,CKTcircuit*,SPcomplex*); +extern int B4SOIsetup(SMPmatrix*,GENmodel*,CKTcircuit*,int*); +extern int B4SOItemp(GENmodel*,CKTcircuit*); +extern int B4SOItrunc(GENmodel*,CKTcircuit*,double*); +extern int B4SOInoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*); +extern int B4SOIunsetup(GENmodel*,CKTcircuit*); + +#else /* stdc */ +extern int B4SOIacLoad(); +extern int B4SOIdelete(); +extern void B4SOIdestroy(); +extern int B4SOIgetic(); +extern int B4SOIload(); +extern int B4SOImDelete(); +extern int B4SOIask(); +extern int B4SOImAsk(); +extern int B4SOIconvTest(); +extern int B4SOItemp(); +extern int B4SOImParam(); +extern void B4SOImosCap(); +extern int B4SOIparam(); +extern int B4SOIpzLoad(); +extern int B4SOIsetup(); +extern int B4SOItrunc(); +extern int B4SOInoise(); +extern int B4SOIunsetup(); + +#endif /* stdc */ + diff --git a/src/spicelib/devices/bsim3soi/b4soigetic.c b/src/spicelib/devices/bsim3soi/b4soigetic.c new file mode 100644 index 000000000..2bd5b322c --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soigetic.c @@ -0,0 +1,57 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soigetic.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soigetic.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "cktdefs.h" +#include "b4soidef.h" +#include "sperror.h" +#include "suffix.h" + + +int +B4SOIgetic(GENmodel *inModel, CKTcircuit *ckt) +{ +B4SOImodel *model = (B4SOImodel*)inModel; +B4SOIinstance *here; + + for (; model ; model = model->B4SOInextModel) + { for (here = model->B4SOIinstances; here; here = here->B4SOInextInstance) + { + + if (here->B4SOIowner != ARCHme) + continue; + + if(!here->B4SOIicVBSGiven) + { here->B4SOIicVBS = *(ckt->CKTrhs + here->B4SOIbNode) + - *(ckt->CKTrhs + here->B4SOIsNode); + } + if (!here->B4SOIicVDSGiven) + { here->B4SOIicVDS = *(ckt->CKTrhs + here->B4SOIdNode) + - *(ckt->CKTrhs + here->B4SOIsNode); + } + if (!here->B4SOIicVGSGiven) + { here->B4SOIicVGS = *(ckt->CKTrhs + here->B4SOIgNode) + - *(ckt->CKTrhs + here->B4SOIsNode); + } + if (!here->B4SOIicVESGiven) + { here->B4SOIicVES = *(ckt->CKTrhs + here->B4SOIeNode) + - *(ckt->CKTrhs + here->B4SOIsNode); + } + if (!here->B4SOIicVPSGiven) + { here->B4SOIicVPS = *(ckt->CKTrhs + here->B4SOIpNode) + - *(ckt->CKTrhs + here->B4SOIsNode); + } + } + } + return(OK); +} + + diff --git a/src/spicelib/devices/bsim3soi/b4soiinit.c b/src/spicelib/devices/bsim3soi/b4soiinit.c new file mode 100644 index 000000000..e272ee202 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soiinit.c @@ -0,0 +1,83 @@ +#include "config.h" + +#include "devdefs.h" + +#include "b4soiitf.h" +#include "b4soiext.h" +#include "b4soiinit.h" + +SPICEdev B4SOIinfo = { + { "B4SOI", + "Berkeley SOI MOSFET model version 4.0", + + &B4SOInSize, + &B4SOInSize, + B4SOInames, + + &B4SOIpTSize, + B4SOIpTable, + + &B4SOImPTSize, + B4SOImPTable, + +#ifdef XSPICE +/*---- Fixed by SDB 5.2.2003 to enable XSPICE/tclspice integration -----*/ + NULL, /* This is a SPICE device, it has no MIF info data */ + + 0, /* This is a SPICE device, it has no MIF info data */ + NULL, /* This is a SPICE device, it has no MIF info data */ + + 0, /* This is a SPICE device, it has no MIF info data */ + NULL, /* This is a SPICE device, it has no MIF info data */ + + 0, /* This is a SPICE device, it has no MIF info data */ + NULL, /* This is a SPICE device, it has no MIF info data */ +/*--------------------------- End of SDB fix -------------------------*/ +#endif + + DEV_DEFAULT + + }, + + /* DEVparam */ B4SOIparam, + /* DEVmodParam */ B4SOImParam, + /* DEVload */ B4SOIload, + /* DEVsetup */ B4SOIsetup, + /* DEVunsetup */ B4SOIunsetup, + /* DEVpzSetup */ B4SOIsetup, + /* DEVtemperature*/ B4SOItemp, + /* DEVtrunc */ B4SOItrunc, + /* DEVfindBranch */ NULL, + /* DEVacLoad */ B4SOIacLoad, + /* DEVaccept */ NULL, + /* DEVdestroy */ B4SOIdestroy, + /* DEVmodDelete */ B4SOImDelete, + /* DEVdelete */ B4SOIdelete, + /* DEVsetic */ B4SOIgetic, + /* DEVask */ B4SOIask, + /* DEVmodAsk */ B4SOImAsk, + /* DEVpzLoad */ B4SOIpzLoad, + /* DEVconvTest */ B4SOIconvTest, + /* DEVsenSetup */ NULL, + /* DEVsenLoad */ NULL, + /* DEVsenUpdate */ NULL, + /* DEVsenAcLoad */ NULL, + /* DEVsenPrint */ NULL, + /* DEVsenTrunc */ NULL, + /* DEVdisto */ NULL, + /* DEVnoise */ B4SOInoise, +#ifdef CIDER + /* DEVdump */ NULL, + /* DEVacct */ NULL, +#endif + /* DEVinstSize */ &B4SOIiSize, + /* DEVmodSize */ &B4SOImSize +}; + +SPICEdev * +get_b4soi_info (void) +{ + return &B4SOIinfo; +} + + diff --git a/src/spicelib/devices/bsim3soi/b4soiinit.h b/src/spicelib/devices/bsim3soi/b4soiinit.h new file mode 100644 index 000000000..716b21937 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soiinit.h @@ -0,0 +1,13 @@ +#ifndef _B4SOIINIT_H +#define _B4SOIINIT_H + +extern IFparm B4SOIpTable[]; +extern IFparm B4SOImPTable[]; +extern char *B4SOInames[]; +extern int B4SOIpTSize; +extern int B4SOImPTSize; +extern int B4SOInSize; +extern int B4SOIiSize; +extern int B4SOImSize; + +#endif diff --git a/src/spicelib/devices/bsim3soi/b4soiitf.h b/src/spicelib/devices/bsim3soi/b4soiitf.h new file mode 100644 index 000000000..35908da4f --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soiitf.h @@ -0,0 +1,15 @@ +/********** +Copyright 2005 Regents of the University of California. All rights reserved. +Author: 2005 Hui Wan (based on Samuel Fung's b3soiitf.h) +File: b4soiitf.h +**********/ + +#ifndef DEV_B4SOI +#define DEV_B4SOI + +#include "b4soiext.h" + +SPICEdev *get_b4soi_info (void); + +#endif + diff --git a/src/spicelib/devices/bsim3soi/b4soild.c b/src/spicelib/devices/bsim3soi/b4soild.c new file mode 100644 index 000000000..44d0687b9 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soild.c @@ -0,0 +1,6573 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soild.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soild.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "cktdefs.h" +#include "b4soidef.h" +#include "trandefs.h" +#include "const.h" +#include "sperror.h" +#include "devdefs.h" +#include "suffix.h" + +#define EPSOX 3.453133e-11 +#define EPSSI 1.03594e-10 +#define Charge_q 1.60219e-19 +#define KboQ 8.617087e-5 /* Kb / q */ +#define Eg300 1.115 /* energy gap at 300K */ +#define DELTA 1.0E-9 /* v4.0 */ +#define DELTA_1 0.02 +#define DELTA_2 0.02 +#define DELTA_3 0.02 +/* Original is 0.02, for matching IBM model, change to 0.08 */ +#define DELTA_3_SOI 0.08 +#define DELTA_4 0.02 +#define DELT_Vbseff 0.005 +#define DELTA_VFB 0.02 +#define OFF_Vbsitf 0.02 /* v3.1*/ +#define CONST_2OV3 0.6666666666 + +#define MAX_EXPL 2.688117142e+43 +#define MIN_EXPL 3.720075976e-44 +#define EXPL_THRESHOLD 100.0 +#define DEXP(A,B,C) { \ + if (A > EXPL_THRESHOLD) { \ + B = MAX_EXPL*(1.0+(A)-EXPL_THRESHOLD); \ + C = MAX_EXPL; \ + } else if (A < -EXPL_THRESHOLD) { \ + B = MIN_EXPL; \ + C = 0; \ + } else { \ + B = exp(A); \ + C = B; \ + } \ + } + +#define FLOG(A) fabs(A) + 1e-14 + + + /* B4SOIlimit(vnew,vold) + * limits the per-iteration change of any absolute voltage value + */ + +double +B4SOIlimit(double vnew, double vold, double limit, int *check) +{ + double T0, T1; + + if (isnan (vnew) || isnan (vold)) + { + fprintf(stderr, "Alberto says: YOU TURKEY! The limiting function received NaN.\n"); + fprintf(stderr, "New prediction returns to 0.0!\n"); + vnew = 0.0; + *check = 1; + } + T0 = vnew - vold; + T1 = fabs(T0); + if (T1 > limit) { + if (T0 > 0.0) + vnew = vold + limit; + else + vnew = vold - limit; + *check = 1; + } + return vnew; +} + + + +int +B4SOIload(GENmodel *inModel, CKTcircuit *ckt) +{ +register B4SOImodel *model = (B4SOImodel*)inModel; +register B4SOIinstance *here; +register int selfheat; + +double Gmin; +double ag0, qgd, qgs, von, cbhat, VgstNVt, ExpVgst; +double cdhat, cdreq, ceqbd, ceqbs, ceqqb, ceqqd, ceqqg, ceq, geq; +double arg; +double delvbd, delvbs, delvds, delvgd, delvgs; +double Vfbeff, dVfbeff_dVg, dVfbeff_dVd, dVfbeff_dVb, V3, V4; +#ifndef NEWCONV +double tol; +#endif +double PhiBSWG, MJSWG; +double gcgdb, gcggb, gcgsb, gcgeb, gcgT; +double gcsdb, gcsgb, gcssb, gcseb, gcsT; +double gcddb, gcdgb, gcdsb, gcdeb, gcdT; +double gcbdb, gcbgb, gcbsb, gcbeb, gcbT; +double gcedb, gcegb, gcesb, gceeb, gceT; +double gcTt, gTtg, gTtb, gTtdp, gTtt, gTtsp; +double vbd, vbs, vds, vgb, vgd, vgs, vgdo, xfact; +double vg, vd, vs, vp, ve, vb; +double Vds, Vgs, Vbs, Gmbs, FwdSum, RevSum; +double Vgs_eff, Vfb, dVfb_dVb, dVfb_dVd, dVfb_dT; +double Phis, dPhis_dVb, sqrtPhis, dsqrtPhis_dVb, Vth, dVth_dVb, dVth_dVd, dVth_dT; +double Vgst, dVgst_dVg, dVgst_dVb, dVgs_eff_dVg; +double n, dn_dVb, Vtm; +double ExpArg, V0; +double ueff, dueff_dVg, dueff_dVd, dueff_dVb, dueff_dT; +double Esat, Vdsat; +double EsatL, dEsatL_dVg, dEsatL_dVd, dEsatL_dVb, dEsatL_dT; +double dVdsat_dVg, dVdsat_dVb, dVdsat_dVd, dVdsat_dT, Vasat; +double dVasat_dVg, dVasat_dVb, dVasat_dVd, dVasat_dT; +double Va, dVa_dVd, dVa_dVg, dVa_dVb, dVa_dT; +double Vbseff, dVbseff_dVb; +double CoxWL; +double T0, dT0_dVg, dT0_dVd, dT0_dVb, dT0_dT; +double T1, dT1_dVg, dT1_dVd, dT1_dVb, dT1_dT; +double T2, dT2_dVg, dT2_dVd, dT2_dVb, dT2_dT; +double T3, dT3_dVg, dT3_dVd, dT3_dVb, dT3_dT; +double T4, dT4_dVd, dT4_dVb, dT4_dT; +double T5, dT5_dVg, dT5_dVd, dT5_dVb, dT5_dT; +double T6, dT6_dVg, dT6_dVd, dT6_dVb, dT6_dT; +double T7; +double T8, dT8_dVd; +double T9, dT9_dVd; +double T10, dT10_dVb, dT10_dVd; +double T11, T12; +double tmp, Abulk, dAbulk_dVb, Abulk0, dAbulk0_dVb; +double VACLM, dVACLM_dVg, dVACLM_dVd, dVACLM_dVb, dVACLM_dT; +double VADIBL, dVADIBL_dVg, dVADIBL_dVd, dVADIBL_dVb, dVADIBL_dT; +double Xdep, dXdep_dVb, lt1, dlt1_dVb, ltw, dltw_dVb; +double Delt_vth, dDelt_vth_dVb, dDelt_vth_dT; +double Theta0, dTheta0_dVb; +double TempRatio, tmp1, tmp2, tmp3, tmp4; +double DIBL_Sft, dDIBL_Sft_dVd, Lambda, dLambda_dVg; +double a1; + +double Vgsteff, dVgsteff_dVg, dVgsteff_dVd, dVgsteff_dVb, dVgsteff_dT; +double Vdseff, dVdseff_dVg, dVdseff_dVd, dVdseff_dVb, dVdseff_dT; +double VdseffCV, dVdseffCV_dVg, dVdseffCV_dVd, dVdseffCV_dVb; +double diffVds; +double dAbulk_dVg, dn_dVd ; +double beta, dbeta_dVg, dbeta_dVd, dbeta_dVb, dbeta_dT; +double gche, dgche_dVg, dgche_dVd, dgche_dVb, dgche_dT; +double fgche1, dfgche1_dVg, dfgche1_dVd, dfgche1_dVb, dfgche1_dT; +double fgche2, dfgche2_dVg, dfgche2_dVd, dfgche2_dVb, dfgche2_dT; +double Idl, dIdl_dVg, dIdl_dVd, dIdl_dVb, dIdl_dT; +double Ids, Gm, Gds, Gmb; +double CoxWovL; +double Rds, dRds_dVg, dRds_dVb, dRds_dT, WVCox, WVCoxRds; +double Vgst2Vtm, dVgst2Vtm_dT, VdsatCV, dVdsatCV_dVg, dVdsatCV_dVb; +double Leff, Weff, dWeff_dVg, dWeff_dVb; +double AbulkCV, dAbulkCV_dVb; +double qgdo, qgso, cgdo, cgso; + +double dxpart, sxpart; + +struct b4soiSizeDependParam *pParam; +int ByPass, Check, ChargeComputationNeeded, error; + +double gbbsp, gbbdp, gbbg, gbbb, gbbp, gbbT; +double gddpsp, gddpdp, gddpg, gddpb, gddpT; +double gsspsp, gsspdp, gsspg, gsspb, gsspT; +double Gbpbs, Gbpps; +double ves, ved, veb, vge, delves, vedo, delved; +double vps, vpd, Vps, delvps; +double Vbd, Ves, Vesfb, DeltVthtemp, dDeltVthtemp_dT; +double Vbp, dVbp_dVb; +double DeltVthw, dDeltVthw_dVb, dDeltVthw_dT; +double Gm0, Gds0, Gmb0, GmT0, Gmc, GmT; +double dDIBL_Sft_dVb; +double Igidl, Ggidld, Ggidlg, Ggidlb; +double Gjsd, Gjsb, GjsT, Gjdd, Gjdb, GjdT; +double Ibp, Iii, Giid, Giig, Giib, GiiT, Gcd, Gcb, GcT, ceqbody, ceqbodcon; +double gppb, gppp; +double delTemp, deldelTemp, Temp; +double ceqth, ceqqth; +double K1; +double qjs, gcjsbs, gcjsT; +double qjd, gcjdbs, gcjdds, gcjdT; +double qge; +double ceqqe; +double ni, Eg, Cbox, CboxWL; +double cjsbs; +double dVfbeff_dVrg; +double qinv, qgate, qbody, qdrn, qsrc, qsub, cqgate, cqbody, cqdrn, cqsub, cqtemp; +double Cgg, Cgd, Cgb; +double Csg, Csd, Csb, Cbg, Cbd, Cbb; +double Cgg1, Cgb1, Cgd1, Cbg1, Cbb1, Cbd1, Csg1, Csd1, Csb1; +double Vdsatii; +double Ibs1 ,dIbs1_dVb ,dIbs1_dT; +double Ibs2 ,dIbs2_dVb ,dIbs2_dT; +double Ibs3 ,dIbs3_dVb ,dIbs3_dVd, dIbs3_dT; +double Ibs4 ,dIbs4_dVb ,dIbs4_dT; +double Ibd1 ,dIbd1_dVb ,dIbd1_dVd ,dIbd1_dT; +double Ibd2 ,dIbd2_dVb ,dIbd2_dVd ,dIbd2_dT; +double Ibd3 ,dIbd3_dVb ,dIbd3_dVd ,dIbd3_dT; +double Ibd4 ,dIbd4_dVb ,dIbd4_dVd ,dIbd4_dT; +double WTsi, NVtm1, NVtm2; +double Ic ,dIc_dVb ,dIc_dVd; +double Ibs; +double Ibd; +double Denomi ,dDenomi_dVg ,dDenomi_dVd ,dDenomi_dVb ,dDenomi_dT; +double Qsub0 ,dQsub0_dVg ,dQsub0_dVb ,dQsub0_dVd ; +double Qac0 ,dQac0_dVb ,dQac0_dVd; +double Qe1 , dQe1_dVb, dQe1_dVe, dQe1_dT; +double Ce1b ,Ce1e, Ce1T; +double dQac0_dVrg, dQsub0_dVrg; + +/* for self-heating */ +double vbi, vfbb, phi, sqrtPhi, Xdep0, u0temp, vsattemp; +double jdifs, jdifd, djdifs_dT, djdifd_dT; +double jbjts, jbjtd, djbjts_dT, djbjtd_dT; +double jrecs, jrecd, djrecs_dT, djrecd_dT; +double jtuns, jtund, djtuns_dT, djtund_dT; +double rds0, ua, ub, uc; +double dvbi_dT, dvfbb_dT, du0temp_dT; +double dvsattemp_dT, drds0_dT, dua_dT, dub_dT, duc_dT, dni_dT, dVtm_dT; +double dVfbeff_dT, dQac0_dT, dQsub0_dT; +double CbT, CsT, CgT; +double rho, rho_ref, ku0temp; /* v4.0 */ +double drho_dT, drho_ref_dT, dku0temp_dT; /* v4.0 */ + +/* v2.0 release */ +double Vbsh, dVbsh_dVb; +double sqrtPhisExt, dsqrtPhisExt_dVb; +double T13, T14; +double dT11_dVb, dT13_dVb, dT14_dVb; +double dVgst_dVd; +double Vdsatii0, dVdsatii0_dT; +double VgsStep, dVgsStep_dT, Ratio, dRatio_dVg, dRatio_dVb, dRatio_dVd, dRatio_dT, dTempRatio_dT; +double Vdiff, dVdiff_dVg, dVdiff_dVb, dVdiff_dVd, dVdiff_dT; +double dNVtm1_dT; +double NVtmf, NVtmr, dNVtmf_dT, dNVtmr_dT; +double TempRatioMinus1; +double Ahlis, dAhlis_dT, Ahlid, dAhlid_dT ; +double WsTsi, WdTsi; +double dPhiBSWG_dT, dcjsbs_dT, darg_dT, ddT3_dVb_dT; +double dT7_dT, dT0_dT7, dT1_dT7, dT2_dT7; +double CoxWLb, CoxWLcenb; +double ExpVbsNVtm, dExpVbsNVtm_dVb, dExpVbsNVtm_dT; +double ExpVbdNVtm, dExpVbdNVtm_dVb, dExpVbdNVtm_dVd, dExpVbdNVtm_dT; +double Ien, dIen_dT, Iendif, dIendif_dT; +double Ibsdif, dIbsdif_dVb, dIbsdif_dT; +double Ibddif, dIbddif_dVb, dIbddif_dVd, dIbddif_dT; +double Ehlis, dEhlis_dVb, dEhlis_dT; +double EhlisFactor, dEhlisFactor_dVb, dEhlisFactor_dT; +double Ehlid, dEhlid_dVb, dEhlid_dVd, dEhlid_dT; +double EhlidFactor, dEhlidFactor_dVb, dEhlidFactor_dVd, dEhlidFactor_dT; +double E2ndFactor, dE2ndFactor_dVb, dE2ndFactor_dVd, dE2ndFactor_dT; +double dT10_dT, dT11_dT, DioMax; +double cjdbs, dcjdbs_dT; +double wdios, wdiod, wdiosCV, wdiodCV; + +/* for capMod3 */ +double Cox, Tox, Tcen, dTcen_dVg, dTcen_dVb, LINK, Ccen, Coxeff, dCoxeff_dVg, dCoxeff_dVb; +double CoxWLcen, QovCox, dQac0_dVg, DeltaPhi, dDeltaPhi_dVg, dDeltaPhi_dVd, dDeltaPhi_dVb; +double dTcen_dVd, dTcen_dT, dCoxeff_dVd, dCoxeff_dT, dCoxWLcenb_dT, qinoi, qbulk; +double T3zb, lt1zb, ltwzb, Theta0zb; +double Delt_vthzb, dDelt_vthzb_dT; +double DeltVthwzb, dDeltVthwzb_dT; +double DeltVthtempzb, dDeltVthtempzb_dT; +double Vthzb, dVthzb_dT, Vfbzb, dVfbzb_dT; + +/* v3.2 */ +double noff, dnoff_dVd, dnoff_dVb; +double vgmb; + +/* v3.1 added for RF */ +double geltd, gcrg, gcrgg, gcrgd, gcrgs, gcrgb, ceqgcrg; +double vges, vgms, vgedo, vgmdo, vged, vgmd, delvged, delvgmd; +double delvges, delvgms, vgme; +double gcgmgmb, gcgmdb, gcgmsb, gcdgmb, gcsgmb; +double gcgmeb, gcegmb, qgme, qgmid, ceqqgmid; +double gcgbb; +double vgge, vggm; +double wdiosCV_NoSwap, wdiodCV_NoSwap; + +/* v3.0 */ +double Igc, dIgc_dVg, dIgc_dVd, dIgc_dVb, Igs, dIgs_dVg, dIgs_dVs, Igd, dIgd_dVg, dIgd_dVd; +double Igcs, dIgcs_dVg, dIgcs_dVd, dIgcs_dVb, Igcd, dIgcd_dVg, dIgcd_dVd, dIgcd_dVb; +double vgs_eff, dvgs_eff_dvg, vgd_eff, dvgd_eff_dvg; +double VxNVt, ExpVxNVt; +double gIstotg, gIstotd, gIstotb, gIstots, Istoteq; +double gIdtotg, gIdtotd, gIdtotb, gIdtots, Idtoteq; +double gIgtotg, gIgtotd, gIgtotb, gIgtots, Igtoteq; + +/* v3.0 */ +double Vbsitf, dVbsitf_dVg, dVbsitf_dVd, dVbsitf_dVb, dVbsitf_dVe, dVbsitf_dT; +double dIgb1_dVe, gige, Giie, dT0_dVe, dRatio_dVe, dVdiff_dVe; +double dT1_dVe, dT5_dVe, dIgb_dVe, dVox_dVe, dVoxdepinv_dVe, dVaux_dVe; +double Gme, gTte, gbbe, gddpe, gsspe; +double Vbs0, dVbs0_dVg, dVbs0_dVd, dVbs0_dVe, dVbs0_dT; +double Vbs0mos, dVbs0mos_dVe, dVbs0mos_dT; +double Vbsmos, dVbsmos_dVg, dVbsmos_dVd, dVbsmos_dVb, dVbsmos_dVe, dVbsmos_dT; +double PhiON, dPhiON_dVg, dPhiON_dVd, dPhiON_dVe, dPhiON_dT; +double PhiFD, dPhiFD_dVg, dPhiFD_dVd, dPhiFD_dVe, dPhiFD_dT; +double Vbs0t, dVbs0t_dVg, dVbs0t_dVd, dVbs0t_dVe, dVbs0t_dT; +double VthFD, dVthFD_dVd, dVthFD_dVb, dVthFD_dVe, dVthFD_dT; +double VtgsFD, ExpVtgsFD, VgstFD, ExpVgstFD; +double VtgseffFD, dVtgseffFD_dVd, dVtgseffFD_dVg, dVtgseffFD_dVe, dVtgseffFD_dT; +double VgsteffFD, dVgsteffFD_dVd, dVgsteffFD_dVg, dVgsteffFD_dVe, dVgsteffFD_dT; +double dT2_dVe, dVbsh_dVg, dVbsh_dVd, dVbsh_dVe, dVbsh_dT; +double dVgsteff_dVe, dVbseff_dVg, dVbseff_dVd, dVbseff_dVe, dVbseff_dT; + +/* v2.2 release */ +double Vgb, dVgb_dVg, dVgb_dVb, Vox, dVox_dVg, dVox_dVd, dVox_dVb; +double OxideRatio, Vaux, dVaux_dVg, dVaux_dVd, dVaux_dVb; +double Igb, dIgb_dVg, dIgb_dVd, dIgb_dVb; +double ceqgate; +double dT0_dVox, Voxeff, dVoxeff_dVox; +double dVox_dT, dVaux_dT, dIgb_dT; +double Voxacc, dVoxacc_dVg, dVoxacc_dVd, dVoxacc_dVb; +double Voxdepinv, dVoxdepinv_dVg, dVoxdepinv_dVb, dVoxdepinv_dVd, dVoxdepinv_dT; +double Igb1, dIgb1_dVg, dIgb1_dVd, dIgb1_dVb, dIgb1_dT; +double Igb2, dIgb2_dVg, dIgb2_dVd, dIgb2_dVb, dIgb2_dT; +double gigs, gigd, gigb, gigg; +double gigT; + +/* v4.0 */ +double IdlovVdseff, dIdlovVdseff_dVg, dIdlovVdseff_dVd, dIdlovVdseff_dVb; +double IdovVds; +double vdbs, vsbs, vdbd, vsbd, vsbdo, vbs_jct, vbd_jct; +double Vsbs, Vdbd, Vdbs; +double delvdbd, delvsbs, delvdbs, delvbd_jct, delvbs_jct; +double gcdbdb, gcsbsb, gcsbb, gcdbb; +double ceqqjd, ceqqjs; +double Lpe_Vb; /* v4.0 for Vth */ +double DITS_Sft, dDITS_Sft_dVb, dDITS_Sft_dVd, dDITS_Sft_dT; +double FP, dFP_dT, dFP_dVg; +double VADITS, dVADITS_dVg, dVADITS_dVd, dVADITS_dT; /* for DITS */ +double Iii_Igidl, Giigidl_b, Giigidl_d, Giigidl_g, Giigidl_e, Giigidl_T; +double gjsdb; +double Idbdp, Isbsp, cdbdp, csbsp, gcjdbdp, gcjsbsp, GGjdb, GGjsb; +double vdes, vses, vdedo, delvdes, delvses, delvded, Isestot, cseshat, Idedtot, cdedhat; +double PowWeffWr, rd0, rs0, rdwmin, rswmin, drs0_dT, drd0_dT, drswmin_dT, + drdwmin_dT, Rd, dRd_dVg, dRd_dVb, dRd_dT, Rs, dRs_dVg, dRs_dVb, dRs_dT; +double dgstot_dvd, dgstot_dvg, dgstot_dvs, dgstot_dvb, dgstot_dve, dgstot_dT; +double dgdtot_dvd, dgdtot_dvg, dgdtot_dvs, dgdtot_dvb, dgdtot_dve, dgdtot_dT; +double gstot, gstotd, gstotg, gstots, gstotb, ceqgstot; +double gdtot, gdtotd, gdtotg, gdtots, gdtotb, ceqgdtot; +double gdpr, gspr; + +double m; + +for (; model != NULL; model = model->B4SOInextModel) +{ for (here = model->B4SOIinstances; here != NULL; + here = here->B4SOInextInstance) + { + + if (here->B4SOIowner != ARCHme) + continue; + + Check = 0; + ByPass = 0; + selfheat = (model->B4SOIshMod == 1) && (here->B4SOIrth0 != 0.0); + pParam = here->pParam; + + + if ((ckt->CKTmode & MODEINITSMSIG)) + { + vs = *(ckt->CKTrhsOld + here->B4SOIsNodePrime); + if (!here->B4SOIvbsusrGiven) { + vbs = *(ckt->CKTstate0 + here->B4SOIvbs); + vb = *(ckt->CKTrhsOld + here->B4SOIbNode); + } + else { + vbs = here->B4SOIvbsusr; + vb = here->B4SOIvbsusr + vs; + } + vgs = *(ckt->CKTstate0 + here->B4SOIvgs); + ves = *(ckt->CKTstate0 + here->B4SOIves); + vps = *(ckt->CKTstate0 + here->B4SOIvps); + vds = *(ckt->CKTstate0 + here->B4SOIvds); + delTemp = *(ckt->CKTstate0 + here->B4SOIdeltemp); + /* v4.0 */ + vdbs = *(ckt->CKTstate0 + here->B4SOIvdbs); /* v4.0 for rbody */ + vsbs = *(ckt->CKTstate0 + here->B4SOIvsbs); /* v4.0 for rbody */ + vses = *(ckt->CKTstate0 + here->B4SOIvses); /* v4.0 for rdsmod*/ + vdes = *(ckt->CKTstate0 + here->B4SOIvdes); /* v4.0 for rdsmod*/ + + /* v4.0 end */ + + vg = *(ckt->CKTrhsOld + here->B4SOIgNode); + vd = *(ckt->CKTrhsOld + here->B4SOIdNodePrime); + vp = *(ckt->CKTrhsOld + here->B4SOIpNode); + ve = *(ckt->CKTrhsOld + here->B4SOIeNode); + + /* v3.1 added for RF */ + vgge = *(ckt->CKTrhsOld + here->B4SOIgNodeExt); + vggm = *(ckt->CKTrhsOld + here->B4SOIgNodeMid); + + vges = *(ckt->CKTstate0 + here->B4SOIvges); + vgms = *(ckt->CKTstate0 + here->B4SOIvgms); + /* v3.1 added for RF end*/ + } + else if ((ckt->CKTmode & MODEINITTRAN)) + { + vs = *(ckt->CKTrhsOld + here->B4SOIsNodePrime); + if (!here->B4SOIvbsusrGiven) { + vbs = *(ckt->CKTstate1 + here->B4SOIvbs); + vb = *(ckt->CKTrhsOld + here->B4SOIbNode); + } + else { + vbs = here->B4SOIvbsusr; + vb = here->B4SOIvbsusr + vs; + } + vgs = *(ckt->CKTstate1 + here->B4SOIvgs); + ves = *(ckt->CKTstate1 + here->B4SOIves); + vps = *(ckt->CKTstate1 + here->B4SOIvps); + vds = *(ckt->CKTstate1 + here->B4SOIvds); + delTemp = *(ckt->CKTstate1 + here->B4SOIdeltemp); + + /* v4.0 */ + vdbs = *(ckt->CKTstate1 + here->B4SOIvdbs); /* v4.0 for rbody */ + vsbs = *(ckt->CKTstate1 + here->B4SOIvsbs); /* v4.0 for rbody */ + vses = *(ckt->CKTstate1 + here->B4SOIvses); /* v4.0 for rdsmod */ + vdes = *(ckt->CKTstate1 + here->B4SOIvdes); /* v4.0 for rdsmod */ + /* v4.0 end */ + + vg = *(ckt->CKTrhsOld + here->B4SOIgNode); + vd = *(ckt->CKTrhsOld + here->B4SOIdNodePrime); + vp = *(ckt->CKTrhsOld + here->B4SOIpNode); + ve = *(ckt->CKTrhsOld + here->B4SOIeNode); + + /* v3.1 added for RF */ + vgge = *(ckt->CKTrhsOld + here->B4SOIgNodeExt); + vggm = *(ckt->CKTrhsOld + here->B4SOIgNodeMid); + vges = *(ckt->CKTstate1 + here->B4SOIvges); + vgms = *(ckt->CKTstate1 + here->B4SOIvgms); + /* v3.1 added for RF end*/ + + } + else if ((ckt->CKTmode & MODEINITJCT) && !here->B4SOIoff) + { vds = model->B4SOItype * here->B4SOIicVDS; + vgs = model->B4SOItype * here->B4SOIicVGS; + ves = model->B4SOItype * here->B4SOIicVES; + vbs = model->B4SOItype * here->B4SOIicVBS; + vps = model->B4SOItype * here->B4SOIicVPS; + vdbs = vsbs = vbs; /* v4.0 */ + + vg = vd = vs = vp = ve = 0.0; + + /* v3.1 added for RF */ + vges = vgms = vgs; + vgge = vggm =0.0; + /* v3.1 added for RF end*/ + + if (vds > 0.0) /* v4.0 */ + { vdes = vds + 0.01; + vses = -0.01; + } + else if (vds < 0.0) + { vdes = vds - 0.01; + vses = 0.01; + } + else + vdes = vses = 0.0; + + delTemp = 0.0; + here->B4SOIphi = pParam->B4SOIphi; + + + + if ((vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) && + ((ckt->CKTmode & (MODETRAN | MODEAC|MODEDCOP | + MODEDCTRANCURVE)) || (!(ckt->CKTmode & MODEUIC)))) + { vbs = 0.0; +/* vgs = model->B4SOItype*0.1 + here->B4SOIvth0; */ + vgs = model->B4SOItype * here->B4SOIvth0 + 0.1; /* v4.0 */ + vds = 0.0; + ves = 0.0; + vps = 0.0; + vges = vgms = vgs; /* v3.1 */ + vbs = vdbs = vsbs = 0.0; /* v4.0 */ + vdes = 0.01; /* v4.0 for rdsmod */ + vses = -0.01; /* v4.0 for rdsmod */ + } + } + else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) && + (here->B4SOIoff)) + { delTemp = vps = vbs = vgs = vds = ves = 0.0; + vg = vd = vs = vp = ve = 0.0; + vgge = vggm = 0.0; /* v3.1 */ + vges = vgms =0.0; /* v3.1 */ + vdbs = vsbs = vdes = vses = 0.0; /* v4.0 */ + } + else + { +#ifndef PREDICTOR + + if ((ckt->CKTmode & MODEINITPRED)) + { xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1]; + *(ckt->CKTstate0 + here->B4SOIvbs) = + *(ckt->CKTstate1 + here->B4SOIvbs); + vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvbs)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIvbs))); + *(ckt->CKTstate0 + here->B4SOIvgs) = + *(ckt->CKTstate1 + here->B4SOIvgs); + vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvgs)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIvgs))); + *(ckt->CKTstate0 + here->B4SOIves) = + *(ckt->CKTstate1 + here->B4SOIves); + ves = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIves)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIves))); + *(ckt->CKTstate0 + here->B4SOIvps) = + *(ckt->CKTstate1 + here->B4SOIvps); + vps = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvps)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIvps))); + *(ckt->CKTstate0 + here->B4SOIvds) = + *(ckt->CKTstate1 + here->B4SOIvds); + vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvds)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIvds))); + *(ckt->CKTstate0 + here->B4SOIvbd) = + *(ckt->CKTstate0 + here->B4SOIvbs) + - *(ckt->CKTstate0 + here->B4SOIvds); + /* v4.0 */ + *(ckt->CKTstate0 + here->B4SOIvdbs) = + *(ckt->CKTstate1 + here->B4SOIvdbs); + vdbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvdbs)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIvdbs))); + *(ckt->CKTstate0 + here->B4SOIvdbd) = + *(ckt->CKTstate0 + here->B4SOIvdbs) + - *(ckt->CKTstate0 + here->B4SOIvds); + *(ckt->CKTstate0 + here->B4SOIvsbs) = + *(ckt->CKTstate1 + here->B4SOIvsbs); + vsbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvsbs)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIvsbs))); + *(ckt->CKTstate0 + here->B4SOIvses) = + *(ckt->CKTstate1 + here->B4SOIvses); + vses = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvses)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIvses))); + *(ckt->CKTstate0 + here->B4SOIvdes) = + *(ckt->CKTstate1 + here->B4SOIvdes); + vdes = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvdes)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIvdes))); + /* v4.0 end */ + + *(ckt->CKTstate0 + here->B4SOIvg) = *(ckt->CKTstate1 + here->B4SOIvg); + *(ckt->CKTstate0 + here->B4SOIvd) = *(ckt->CKTstate1 + here->B4SOIvd); + *(ckt->CKTstate0 + here->B4SOIvs) = *(ckt->CKTstate1 + here->B4SOIvs); + *(ckt->CKTstate0 + here->B4SOIvp) = *(ckt->CKTstate1 + here->B4SOIvp); + *(ckt->CKTstate0 + here->B4SOIve) = *(ckt->CKTstate1 + here->B4SOIve); + + /* v3.1 added for RF */ + *(ckt->CKTstate0 + here->B4SOIvgge) = *(ckt->CKTstate1 + here->B4SOIvgge); + *(ckt->CKTstate0 + here->B4SOIvggm) = *(ckt->CKTstate1 + here->B4SOIvggm); + *(ckt->CKTstate0 + here->B4SOIvges) = + *(ckt->CKTstate1 + here->B4SOIvges); + vges = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvges)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIvges))); + *(ckt->CKTstate0 + here->B4SOIvgms) = + *(ckt->CKTstate1 + here->B4SOIvgms); + vgms = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIvgms)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIvgms))); + /* v3.1 added for RF end */ + + /* Only predict ve */ + ve = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B4SOIve)) + - (xfact * (*(ckt->CKTstate2 + here->B4SOIve))); + /* Then update vg, vs, vb, vd, vp base on ve */ + vs = ve - model->B4SOItype * ves; + vg = model->B4SOItype * vgs + vs; + vd = model->B4SOItype * vds + vs; + vb = model->B4SOItype * vbs + vs; + vp = model->B4SOItype * vps + vs; + + vgge = model->B4SOItype * vges + vs; /* v3.1 */ + vggm = model->B4SOItype * vgms + vs; /* v3.1 */ + + delTemp = (1.0 + xfact)* (*(ckt->CKTstate1 + + here->B4SOIdeltemp))-(xfact * (*(ckt->CKTstate2 + + here->B4SOIdeltemp))); + +/* v2.2.3 bug fix */ + *(ckt->CKTstate0 + here->B4SOIdeltemp) = + *(ckt->CKTstate1 + here->B4SOIdeltemp); + + if (selfheat) + { + here->B4SOIphi = 2.0 * here->B4SOIvtm + * log(pParam->B4SOInpeak / + here->B4SOIni); + } + + } + else + { +#endif /* PREDICTOR */ + + vg = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIgNode), + *(ckt->CKTstate0 + here->B4SOIvg), 3.0, &Check); + vd = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIdNodePrime), + *(ckt->CKTstate0 + here->B4SOIvd), 3.0, &Check); + vs = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIsNodePrime), + *(ckt->CKTstate0 + here->B4SOIvs), 3.0, &Check); + vp = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIpNode), + *(ckt->CKTstate0 + here->B4SOIvp), 3.0, &Check); + ve = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIeNode), + *(ckt->CKTstate0 + here->B4SOIve), 3.0, &Check); + /* v3.1 added for RF */ + vgge = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIgNodeExt), + *(ckt->CKTstate0 + here->B4SOIvgge), 3.0, &Check); + + vggm = B4SOIlimit(*(ckt->CKTrhsOld + here->B4SOIgNodeMid), + *(ckt->CKTstate0 + here->B4SOIvggm), 3.0, &Check); + /* v3.1 added for RF end */ + + delTemp = *(ckt->CKTrhsOld + here->B4SOItempNode); + + vbs = model->B4SOItype * (*(ckt->CKTrhsOld+here->B4SOIbNode) + - *(ckt->CKTrhsOld+here->B4SOIsNodePrime)); + + vps = model->B4SOItype * (vp - vs); + vgs = model->B4SOItype * (vg - vs); + ves = model->B4SOItype * (ve - vs); + vds = model->B4SOItype * (vd - vs); + + vges = model->B4SOItype * (vgge - vs); /* v3.1 */ + vgms = model->B4SOItype * (vggm - vs); /* v3.1 */ + + /* v4.0 */ + vdbs = model->B4SOItype + * (*(ckt->CKTrhsOld + here->B4SOIdbNode) + - *(ckt->CKTrhsOld + here->B4SOIsNodePrime)); + vsbs = model->B4SOItype + * (*(ckt->CKTrhsOld + here->B4SOIsbNode) + - *(ckt->CKTrhsOld + here->B4SOIsNodePrime)); + vses = model->B4SOItype + * (*(ckt->CKTrhsOld + here->B4SOIsNode) + - *(ckt->CKTrhsOld + here->B4SOIsNodePrime)); + vdes = model->B4SOItype + * (*(ckt->CKTrhsOld + here->B4SOIdNode) + - *(ckt->CKTrhsOld + here->B4SOIsNodePrime)); + /* v4.0 end */ + +#ifndef PREDICTOR + } +#endif /* PREDICTOR */ + + vbd = vbs - vds; + vdbd = vdbs - vds; /* v4.0 */ + + vgd = vgs - vds; + ved = ves - vds; + vgdo = *(ckt->CKTstate0 + here->B4SOIvgs) + - *(ckt->CKTstate0 + here->B4SOIvds); + vedo = *(ckt->CKTstate0 + here->B4SOIves) + - *(ckt->CKTstate0 + here->B4SOIvds); + + /* v3.1 for RF */ + vgedo = *(ckt->CKTstate0 + here->B4SOIvges) + - *(ckt->CKTstate0 + here->B4SOIvds); + vgmdo = *(ckt->CKTstate0 + here->B4SOIvgms) + - *(ckt->CKTstate0 + here->B4SOIvds); + vged = vges - vds; + vgmd = vgms - vds; + delvged = vged - vgedo; + delvgmd = vgmd - vgmdo; + /* v3.1 for RF end*/ + + delvbs = vbs - *(ckt->CKTstate0 + here->B4SOIvbs); + delvbd = vbd - *(ckt->CKTstate0 + here->B4SOIvbd); + delvgs = vgs - *(ckt->CKTstate0 + here->B4SOIvgs); + delves = ves - *(ckt->CKTstate0 + here->B4SOIves); + delvps = vps - *(ckt->CKTstate0 + here->B4SOIvps); + deldelTemp = delTemp - *(ckt->CKTstate0 + here->B4SOIdeltemp); + delvds = vds - *(ckt->CKTstate0 + here->B4SOIvds); + delvgd = vgd - vgdo; + delved = ved - vedo; + delvges = vges - *(ckt->CKTstate0 + here->B4SOIvges); /* v3.1 */ + delvgms = vgms - *(ckt->CKTstate0 + here->B4SOIvgms); /* v3.1 */ + delvdbd = vdbd - *(ckt->CKTstate0 + here->B4SOIvdbd); /* v4.0 */ + delvdbs = vdbs - *(ckt->CKTstate0 + here->B4SOIvdbs); /* v4.0 */ + delvsbs = vsbs - *(ckt->CKTstate0 + here->B4SOIvsbs); /* v4.0 */ + + delvbd_jct = (!here->B4SOIrbodyMod) ? delvbd : delvdbd; /*v4.0*/ + delvbs_jct = (!here->B4SOIrbodyMod) ? delvbs : delvsbs; /*v4.0*/ + + delvses = vses - *(ckt->CKTstate0 + here->B4SOIvses);/*v4.0*/ + vdedo = *(ckt->CKTstate0 + here->B4SOIvdes) + - *(ckt->CKTstate0 + here->B4SOIvds); /* v4.0 */ + delvdes = vdes - *(ckt->CKTstate0 + here->B4SOIvdes); /* v4.0 */ + delvded = vdes - vds - vdedo; /* v4.0 */ + + if (here->B4SOImode >= 0) + { + cdhat = here->B4SOIcd + + (here->B4SOIgm-here->B4SOIgjdg) * delvgs + + (here->B4SOIgds - here->B4SOIgjdd) * delvds + + (here->B4SOIgmbs * delvbs + - here->B4SOIgjdb * delvbs_jct ) /* v4.0 */ + + (here->B4SOIgme - here->B4SOIgjde) * delves + + (here->B4SOIgmT - here->B4SOIgjdT) * deldelTemp; /* v3.0 */ + } + else + { + cdhat = here->B4SOIcd + + (here->B4SOIgm-here->B4SOIgjdg) * delvgd + - (here->B4SOIgds - here->B4SOIgjdd) * delvds + + (here->B4SOIgmbs * delvbd + - here->B4SOIgjdb * delvbd_jct ) /*v4.0 */ + + (here->B4SOIgme - here->B4SOIgjde) * delved + + (here->B4SOIgmT - here->B4SOIgjdT) * deldelTemp; /* v3.0 */ + + } + cbhat = here->B4SOIcb + here->B4SOIgbgs * delvgs + + here->B4SOIgbbs * delvbs + + here->B4SOIgbds * delvds + + here->B4SOIgbes * delves + + here->B4SOIgbps * delvps + + here->B4SOIgbT * deldelTemp; /* v3.0 */ + + Isestot = here->B4SOIgstot * (*(ckt->CKTstate0 + here->B4SOIvses)); + cseshat = Isestot + here->B4SOIgstot * delvses + + here->B4SOIgstotd * delvds + here->B4SOIgstotg * delvgs + + here->B4SOIgstotb * delvbs; + + Idedtot = here->B4SOIgdtot * vdedo; + cdedhat = Idedtot + here->B4SOIgdtot * delvded + + here->B4SOIgdtotd * delvds + here->B4SOIgdtotg * delvgs + + here->B4SOIgdtotb * delvbs; + +#ifndef NOBYPASS + /* following should be one big if connected by && all over + * the place, but some C compilers can't handle that, so + * we split it up here to let them digest it in stages + */ + + if ((!(ckt->CKTmode & MODEINITPRED)) && (ckt->CKTbypass) && Check == 0) + if ((here->B4SOIsoiMod == 2) || /* v3.2 */ + (fabs(delvbs) < (ckt->CKTreltol * MAX(fabs(vbs), + fabs(*(ckt->CKTstate0+here->B4SOIvbs))) + ckt->CKTvoltTol)) ) + if ((here->B4SOIsoiMod == 2) || /* v3.2 */ + (fabs(delvbd) < (ckt->CKTreltol * MAX(fabs(vbd), + fabs(*(ckt->CKTstate0+here->B4SOIvbd))) + ckt->CKTvoltTol)) ) + if ((fabs(delvgs) < (ckt->CKTreltol * MAX(fabs(vgs), + fabs(*(ckt->CKTstate0+here->B4SOIvgs))) + ckt->CKTvoltTol))) + if ((fabs(delves) < (ckt->CKTreltol * MAX(fabs(ves), + fabs(*(ckt->CKTstate0+here->B4SOIves))) + ckt->CKTvoltTol))) + if ( (here->B4SOIbodyMod == 0) || (here->B4SOIbodyMod == 2) || + (fabs(delvps) < (ckt->CKTreltol * MAX(fabs(vps), + fabs(*(ckt->CKTstate0+here->B4SOIvps))) + ckt->CKTvoltTol)) ) + if ( (here->B4SOItempNode == 0) || + (fabs(deldelTemp) < (ckt->CKTreltol * MAX(fabs(delTemp), + fabs(*(ckt->CKTstate0+here->B4SOIdeltemp))) + + ckt->CKTvoltTol*1e4))) + + /* v3.1 added for RF */ + if ((here->B4SOIrgateMod == 0) || (here->B4SOIrgateMod == 1) + || (fabs(delvges) < (ckt->CKTreltol * MAX(fabs(vges), + fabs(*(ckt->CKTstate0 + here->B4SOIvges))) + ckt->CKTvoltTol))) + if ((here->B4SOIrgateMod != 3) || (fabs(delvgms) < (ckt->CKTreltol + * MAX(fabs(vgms), fabs(*(ckt->CKTstate0 + here->B4SOIvgms))) + + ckt->CKTvoltTol))) + /* v3.1 added for RF end */ + /* v4.0 */ + if ((!here->B4SOIrbodyMod) || (fabs(delvdbs) < (ckt->CKTreltol + * MAX(fabs(vdbs), fabs(*(ckt->CKTstate0 + here->B4SOIvdbs))) + + ckt->CKTvoltTol))) + if ((!here->B4SOIrbodyMod) || (fabs(delvdbd) < (ckt->CKTreltol + * MAX(fabs(vdbd), fabs(*(ckt->CKTstate0 + here->B4SOIvdbd))) + + ckt->CKTvoltTol))) + if ((!here->B4SOIrbodyMod) || (fabs(delvsbs) < (ckt->CKTreltol + * MAX(fabs(vsbs), fabs(*(ckt->CKTstate0 + here->B4SOIvsbs))) + + ckt->CKTvoltTol))) + if ((!model->B4SOIrdsMod) || (fabs(delvses) < (ckt->CKTreltol + * MAX(fabs(vses), fabs(*(ckt->CKTstate0 + here->B4SOIvses))) + + ckt->CKTvoltTol))) + if ((!model->B4SOIrdsMod) || (fabs(delvdes) < (ckt->CKTreltol + * MAX(fabs(vdes), fabs(*(ckt->CKTstate0 + here->B4SOIvdes))) + + ckt->CKTvoltTol))) + if ((!model->B4SOIrdsMod) || ((fabs(cseshat - Isestot) < ckt->CKTreltol + * MAX(fabs(cseshat), fabs(Isestot)) + ckt->CKTabstol))) + if ((!model->B4SOIrdsMod) || ((fabs(cdedhat - Idedtot) < ckt->CKTreltol + * MAX(fabs(cdedhat), fabs(Idedtot)) + ckt->CKTabstol))) + /* v4.0 end */ + + if ((fabs(delvds) < (ckt->CKTreltol * MAX(fabs(vds), + fabs(*(ckt->CKTstate0+here->B4SOIvds))) + ckt->CKTvoltTol))) + if ((fabs(cdhat - here->B4SOIcd) < ckt->CKTreltol + * MAX(fabs(cdhat),fabs(here->B4SOIcd)) + ckt->CKTabstol)) + if ((here->B4SOIsoiMod == 2) || /* v3.2 */ + (fabs(cbhat - here->B4SOIcb) < ckt->CKTreltol + * MAX(fabs(cbhat),fabs(here->B4SOIcb)) + ckt->CKTabstol) ) + { /* bypass code */ + vbs = *(ckt->CKTstate0 + here->B4SOIvbs); + vbd = *(ckt->CKTstate0 + here->B4SOIvbd); + vgs = *(ckt->CKTstate0 + here->B4SOIvgs); + ves = *(ckt->CKTstate0 + here->B4SOIves); + vps = *(ckt->CKTstate0 + here->B4SOIvps); + vds = *(ckt->CKTstate0 + here->B4SOIvds); + + /* v3.1 added for RF */ + vges = *(ckt->CKTstate0 + here->B4SOIvges); + vgms = *(ckt->CKTstate0 + here->B4SOIvgms); + vged = vges - vds; + vgmd = vgms - vds; + vgme = vgms - ves; + /* v3.1 added for RF end */ + vgmb = vgms - vbs; /* v3.2 bug fix */ + + /* v4.0 */ + vdbs = *(ckt->CKTstate0 + here->B4SOIvdbs); + vdbd = *(ckt->CKTstate0 + here->B4SOIvdbd); + vsbs = *(ckt->CKTstate0 + here->B4SOIvsbs); + vbs_jct = (!here->B4SOIrbodyMod) ? vbs : vsbs; + vbd_jct = (!here->B4SOIrbodyMod) ? vbd : vdbd; + vses = *(ckt->CKTstate0 + here->B4SOIvses); + vdes = *(ckt->CKTstate0 + here->B4SOIvdes); + /* v4.0 end */ + + delTemp = *(ckt->CKTstate0 + here->B4SOIdeltemp); + /* calculate Vds for temperature conductance calculation + in bypass (used later when filling Temp node matrix) */ + Vds = here->B4SOImode > 0 ? vds : -vds; + + vgd = vgs - vds; + vgb = vgs - vbs; + veb = ves - vbs; + + if ((ckt->CKTmode & (MODETRAN | MODEAC)) || + ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC))) + { ByPass = 1; + goto line755; + } + else + { goto line850; + } + } + +#endif /*NOBYPASS*/ + von = here->B4SOIvon; + + + if (*(ckt->CKTstate0 + here->B4SOIvds) >= 0.0) + { T0 = *(ckt->CKTstate0 + here->B4SOIvbs); + + /* v3.1 added for RF */ + if (here->B4SOIrgateMod == 3) + { + vged = vges - vds; + vgmd = vgms - vds; + } + else if ((here->B4SOIrgateMod == 1) || (here->B4SOIrgateMod == 2)) + { + vged = vges - vds; + } + /* v3.1 added for RF end*/ + + } + else + { T0 = *(ckt->CKTstate0 + here->B4SOIvbd); + + /* added for RF */ + if (here->B4SOIrgateMod == 3) + { + vges = vged + vds; + vgms = vgmd + vds; + } + if ((here->B4SOIrgateMod == 1) || (here->B4SOIrgateMod == 2)) + { + vges = vged + vds; + } + /* added for RF end*/ + + } + + if (vds >= 0.0) + { + vbs = B4SOIlimit(vbs, T0, 0.2, &Check); + vbd = vbs - vds; + vb = model->B4SOItype * vbs + vs; + + if (here->B4SOIrbodyMod) /* v4.0 */ + { vdbs = B4SOIlimit(vdbs, + *(ckt->CKTstate0 + here->B4SOIvdbs), 0.2, &Check); + vdbd = vdbs - vds; + vsbs = B4SOIlimit(vsbs, + *(ckt->CKTstate0 + here->B4SOIvsbs), 0.2, &Check); + } + } + else + { + vbd = B4SOIlimit(vbd, T0, 0.2, &Check); + vbs = vbd + vds; + vb = model->B4SOItype * vbs + vd; + /* v4.0 */ + if (here->B4SOIrbodyMod) + { vdbd = B4SOIlimit(vdbd, + *(ckt->CKTstate0 + here->B4SOIvdbd), 0.2, &Check); + vdbs = vdbd + vds; + vsbdo = *(ckt->CKTstate0 + here->B4SOIvsbs) + - *(ckt->CKTstate0 + here->B4SOIvds); + vsbd = vsbs - vds; + vsbd = B4SOIlimit(vsbd, vsbdo, 0.2, &Check); + vsbs = vsbd + vds; + } + /* v4.0 end */ + } + + delTemp =B4SOIlimit(delTemp, + *(ckt->CKTstate0 + here->B4SOIdeltemp),5.0,&Check); + + } + +/* Calculate temperature dependent values for self-heating effect */ + Temp = delTemp + ckt->CKTtemp; + dTempRatio_dT = 1 / model->B4SOItnom; + TempRatio = Temp * dTempRatio_dT; + + if (selfheat) { + Vtm = KboQ * Temp; + + T0 = 1108.0 + Temp; + T5 = Temp * Temp; + Eg = 1.16 - 7.02e-4 * T5 / T0; + T1 = ((7.02e-4 * T5) - T0 * (14.04e-4 * Temp)) / T0 / T0; + /* T1 = dEg / dT */ + + T2 = 1.9230584e-4; /* T2 = 1 / 300.15^(3/2) */ + T5 = sqrt(Temp); + T3 = 1.45e10 * Temp * T5 * T2; + T4 = exp(21.5565981 - Eg / (2.0 * Vtm)); + ni = T3 * T4; + dni_dT = 2.175e10 * T2 * T5 * T4 + T3 * T4 * + (-Vtm * T1 + Eg * KboQ) / (2.0 * Vtm * Vtm); + + T0 = log(1.0e20 * pParam->B4SOInpeak / (ni * ni)); + vbi = Vtm * T0; + dvbi_dT = KboQ * T0 + Vtm * (-2.0 * dni_dT / ni); + + if (pParam->B4SOInsub > 0) { + T0 = log(pParam->B4SOInpeak / pParam->B4SOInsub); + vfbb = -model->B4SOItype * Vtm * T0; + dvfbb_dT = -model->B4SOItype * KboQ * T0; + } + else { + T0 = log(-pParam->B4SOInpeak * pParam->B4SOInsub / ni / ni); + vfbb = -model->B4SOItype * Vtm * T0; + dvfbb_dT = -model->B4SOItype * + (KboQ * T0 - Vtm * 2.0 * dni_dT / ni); + } + + /* V4.0 changed phi */ + phi = 2.0 * Vtm * log(pParam->B4SOInpeak / ni); +/* phi = here->B4SOIphi; */ + sqrtPhi = sqrt(phi); + Xdep0 = sqrt(2.0 * EPSSI / (Charge_q + * pParam->B4SOInpeak * 1.0e6)) + * sqrtPhi; + /* Save the values below for phi calculation in B4SOIaccept() */ + here->B4SOIvtm = Vtm; + here->B4SOIni = ni; + + T3 = TempRatio - 1.0; + T8 = 1/ model->B4SOItnom; + T4 = Eg300 / Vtm * T3; + dT4_dT = Eg300 / Vtm / Vtm * (Vtm * T8 - T3 * KboQ); + + T7 = pParam->B4SOIxbjt * T4 / pParam->B4SOIndiode; + dT7_dT = pParam->B4SOIxbjt * dT4_dT + / pParam->B4SOIndiode; + DEXP(T7, T0, dT0_dT7); + dT0_dT = dT0_dT7 * dT7_dT; + + if (pParam->B4SOIxbjt == pParam->B4SOIxdif) { + T1 = T0; + dT1_dT = dT0_dT; + } + else { + T7 = pParam->B4SOIxdif * T4 / pParam->B4SOIndiode; + dT7_dT = pParam->B4SOIxdif * dT4_dT / pParam->B4SOIndiode; + DEXP(T7, T1, dT1_dT7); + dT1_dT = dT1_dT7 * dT7_dT; + } + + T7 = pParam->B4SOIxrec * T4 / pParam->B4SOInrecf0; + dT7_dT = pParam->B4SOIxrec * dT4_dT + / pParam->B4SOInrecf0; + DEXP(T7, T2, dT2_dT7); + dT2_dT = dT2_dT7 * dT7_dT; + + /* high level injection */ + Ahlis = pParam->B4SOIahli * T0; + dAhlis_dT = pParam->B4SOIahli * dT0_dT; + + jbjts = pParam->B4SOIisbjt * T0; + jdifs = pParam->B4SOIisdif * T1; + jrecs = pParam->B4SOIisrec * T2; + djbjts_dT = pParam->B4SOIisbjt * dT0_dT; + djdifs_dT = pParam->B4SOIisdif * dT1_dT; + djrecs_dT = pParam->B4SOIisrec * dT2_dT; + + T7 = pParam->B4SOIxtun * T3; + dT7_dT = pParam->B4SOIxtun * T8; + DEXP(T7, T0, dT0_dT7); + dT0_dT = dT0_dT7 * dT7_dT; + jtuns = pParam->B4SOIistun * T0; + djtuns_dT = pParam->B4SOIistun * dT0_dT; + +/* drain side */ + T7 = pParam->B4SOIxbjt * T4 / pParam->B4SOIndioded; + dT7_dT = pParam->B4SOIxbjt * dT4_dT / pParam->B4SOIndioded; + DEXP(T7, T0, dT0_dT7); + dT0_dT = dT0_dT7 * dT7_dT; + + if (pParam->B4SOIxbjt == pParam->B4SOIxdifd) { + T1 = T0; + dT1_dT = dT0_dT; + } + else { + T7 = pParam->B4SOIxdifd * T4 / pParam->B4SOIndioded; + dT7_dT = pParam->B4SOIxdifd * dT4_dT / pParam->B4SOIndioded; + DEXP(T7, T1, dT1_dT7); + dT1_dT = dT1_dT7 * dT7_dT; + } + + T7 = pParam->B4SOIxrecd * T4 / pParam->B4SOInrecf0d; + dT7_dT = pParam->B4SOIxrecd * dT4_dT / pParam->B4SOInrecf0d; + DEXP(T7, T2, dT2_dT7); + dT2_dT = dT2_dT7 * dT7_dT; + + /* high level injection */ + Ahlid = pParam->B4SOIahlid * T0; + dAhlid_dT = pParam->B4SOIahlid * dT0_dT; + + jbjtd = pParam->B4SOIidbjt * T0; + jdifd = pParam->B4SOIiddif * T1; + + jrecd = pParam->B4SOIidrec * T2; + djbjtd_dT = pParam->B4SOIidbjt * dT0_dT; + djdifd_dT = pParam->B4SOIiddif * dT1_dT; + djrecd_dT = pParam->B4SOIidrec * dT2_dT; + + T7 = pParam->B4SOIxtund * T3; + dT7_dT = pParam->B4SOIxtund * T8; + DEXP(T7, T0, dT0_dT7); + dT0_dT = dT0_dT7 * dT7_dT; + jtund = pParam->B4SOIidtun * T0; + djtund_dT = pParam->B4SOIidtun * dT0_dT; + + + u0temp = pParam->B4SOIu0 + * pow(TempRatio, pParam->B4SOIute); + du0temp_dT = pParam->B4SOIu0 * pParam->B4SOIute * + pow(TempRatio, pParam->B4SOIute - 1.0) * T8; + ku0temp = pParam->B4SOIku0 * (1.0 + + model->B4SOItku0 * TempRatio) + DELTA; + dku0temp_dT = pParam->B4SOIku0 * model->B4SOItku0 * T8; + T2 = ku0temp * ku0temp; + T7 = model->B4SOIku0 * pParam->B4SOIinv_od_ref; + rho_ref = T7 / ku0temp; + drho_ref_dT = -T7 / T2 * dku0temp_dT; + T4 = model->B4SOIku0 * here->B4SOIInv_ODeff; + rho = T4 / ku0temp; + drho_dT = -T4 / T2 * dku0temp_dT; + T2 = (1.0 + rho); + T7 = (1.0 + rho_ref); + T0 = T2 / T7; + dT0_dT = (drho_dT * T7 - drho_ref_dT * T2 ) / T7 / T7; + du0temp_dT = T0 * du0temp_dT + u0temp * dT0_dT; + u0temp *= T0; + + vsattemp = pParam->B4SOIvsat - pParam->B4SOIat * T3; + dvsattemp_dT = -pParam->B4SOIat * T8; + T2 = (1.0 + here->B4SOIkvsat * rho); + T7 = (1.0 + here->B4SOIkvsat * rho_ref); + T0 = T2 / T7; + dT0_dT = (here->B4SOIkvsat * drho_dT * T7 - + here->B4SOIkvsat * drho_ref_dT * T2) + / T7 / T7; + dvsattemp_dT = dvsattemp_dT * T0 + vsattemp * dT0_dT; + vsattemp *= T0; + + if (!model->B4SOIrdsMod) { + rds0 = (pParam->B4SOIrdsw + pParam->B4SOIprt * T3) + / pParam->B4SOIrds0denom; + drds0_dT = pParam->B4SOIprt / pParam->B4SOIrds0denom + * T8; + } + else { /* v4.0 */ + PowWeffWr = pParam->B4SOIrds0denom * here->B4SOInf; + T10 = pParam->B4SOIprt * T3; + + /* External Rd(V) */ + T1 = pParam->B4SOIrdw + T10; + T2 = model->B4SOIrdwmin + T10; + rd0 = T1 / PowWeffWr; + rdwmin = T2 / PowWeffWr; + drd0_dT = pParam->B4SOIprt / PowWeffWr * T8; + drdwmin_dT = drd0_dT; + + /* External Rs(V) */ + T7 = pParam->B4SOIrsw + T10; + T4 = model->B4SOIrswmin + T10; + rs0 = T7 / PowWeffWr; + rswmin = T4 / PowWeffWr; + drs0_dT = drswmin_dT = drd0_dT; + } + + ua = pParam->B4SOIuatemp + pParam->B4SOIua1 * T3; + ub = pParam->B4SOIubtemp + pParam->B4SOIub1 * T3; + uc = pParam->B4SOIuctemp + pParam->B4SOIuc1 * T3; + dua_dT = pParam->B4SOIua1 * T8; + dub_dT = pParam->B4SOIub1 * T8; + duc_dT = pParam->B4SOIuc1 * T8; + } + else { + vbi = pParam->B4SOIvbi; + vfbb = pParam->B4SOIvfbb; + phi = pParam->B4SOIphi; + sqrtPhi = pParam->B4SOIsqrtPhi; + Xdep0 = pParam->B4SOIXdep0; + jbjts = pParam->B4SOIjbjts; /* v4.0 */ + jbjtd = pParam->B4SOIjbjtd; + jdifs = pParam->B4SOIjdifs; + jdifd = pParam->B4SOIjdifd; + jrecs = pParam->B4SOIjrecs; + jrecd = pParam->B4SOIjrecd; + jtuns = pParam->B4SOIjtuns; + jtund = pParam->B4SOIjtund; + + /* v2.2.2 bug fix */ + Ahlis = pParam->B4SOIahli0s; + Ahlid = pParam->B4SOIahli0d; + + u0temp = here->B4SOIu0temp; + vsattemp = here->B4SOIvsattemp; + ua = pParam->B4SOIua; + ub = pParam->B4SOIub; + uc = pParam->B4SOIuc; + dni_dT = dvbi_dT = dvfbb_dT = 0.0; + djbjts_dT = djdifs_dT = djrecs_dT = djtuns_dT = 0.0; + djbjtd_dT = djdifd_dT = djrecd_dT = djtund_dT = 0.0; + du0temp_dT = dvsattemp_dT = 0.0; + dua_dT = dub_dT = duc_dT = 0.0; + + if (!model->B4SOIrdsMod) { + rds0 = pParam->B4SOIrds0; + drds0_dT = 0.0; + } + else { + rd0 = pParam->B4SOIrd0; + rs0 = pParam->B4SOIrs0; + rdwmin = pParam->B4SOIrdwmin; + rswmin = pParam->B4SOIrswmin; + drd0_dT = drs0_dT = drdwmin_dT = drswmin_dT = 0.0; + } + dAhlis_dT = dAhlid_dT = 0; + } + + /* TempRatio used for Vth and mobility */ + if (selfheat) { + TempRatioMinus1 = Temp / model->B4SOItnom - 1.0; + } + else { + TempRatioMinus1 = ckt->CKTtemp / model->B4SOItnom - 1.0; + } + + /* determine DC current and derivatives */ + vbd = vbs - vds; + vgd = vgs - vds; + vgb = vgs - vbs; + ved = ves - vds; + veb = ves - vbs; + vge = vgs - ves; + vpd = vps - vds; + + /* v3.1 added for RF */ + vged = vges - vds; + vgmd = vgms - vds; + vgme = vgms - ves; + /* v3.1 added for RF end */ + vgmb = vgms - vbs; /* v3.2 bug fix */ + +/* v3.1 bug fix */ + wdiosCV_NoSwap = pParam->B4SOIwdiosCV; + wdiodCV_NoSwap = pParam->B4SOIwdiodCV; + + + if (vds >= 0.0) + { /* normal mode */ + here->B4SOImode = 1; + Vds = vds; + Vgs = vgs; + Vbs = vbs; + Vbd = vbd; + Ves = ves; + Vps = vps; + Vsbs = vsbs; /* v4.0 */ + Vdbs = vdbs; /* v4.0 */ + Vdbd = Vdbs - Vds; /* v4.0 */ + + wdios = pParam->B4SOIwdios; + wdiod = pParam->B4SOIwdiod; + wdiosCV = pParam->B4SOIwdiosCV; + wdiodCV = pParam->B4SOIwdiodCV; + + } + else + { /* inverse mode */ + here->B4SOImode = -1; + Vds = -vds; + Vgs = vgd; + Vbs = vbd; + Vbd = vbs; + Ves = ved; + Vps = vpd; + Vsbs = vdbd; /* v4.0 */ + Vdbd = vsbs; /* v4.0 */ + Vdbs = Vdbd + Vds; /* v4.0 */ + + wdios = pParam->B4SOIwdiod; + wdiod = pParam->B4SOIwdios; + wdiosCV = pParam->B4SOIwdiodCV; + wdiodCV = pParam->B4SOIwdiosCV; + + } + vbs_jct = (!here->B4SOIrbodyMod) ? Vbs : Vsbs; /* v4.0 */ + vbd_jct = (!here->B4SOIrbodyMod) ? Vbd : Vdbd; /* v4.0 */ + + Vesfb = Ves - vfbb; + Cbox = model->B4SOIcbox; + K1 = pParam->B4SOIk1eff; + + ChargeComputationNeeded = + ((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) || + ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC))) + ? 1 : 0; + + if (here->B4SOIdebugMod <0) + ChargeComputationNeeded = 1; + + + + +/* Poly Gate Si Depletion Effect */ + T0 = here->B4SOIvfb + phi; + if ((pParam->B4SOIngate > 1.e18) && (pParam->B4SOIngate < 1.e25) + && (Vgs > T0)) + /* added to avoid the problem caused by ngate */ + { T1 = 1.0e6 * Charge_q * EPSSI * pParam->B4SOIngate + / (model->B4SOIcox * model->B4SOIcox); + T4 = sqrt(1.0 + 2.0 * (Vgs - T0) / T1); + T2 = T1 * (T4 - 1.0); + T3 = 0.5 * T2 * T2 / T1; /* T3 = Vpoly */ + T7 = 1.12 - T3 - 0.05; + T6 = sqrt(T7 * T7 + 0.224); + T5 = 1.12 - 0.5 * (T7 + T6); + Vgs_eff = Vgs - T5; + dVgs_eff_dVg = 1.0 - (0.5 - 0.5 / T4) * (1.0 + T7 / T6); + } + else + { Vgs_eff = Vgs; + dVgs_eff_dVg = 1.0; + } + + + Leff = pParam->B4SOIleff; + + if (selfheat) { + Vtm = KboQ * Temp; + dVtm_dT = KboQ; + } + else { + Vtm = model->B4SOIvtm; + dVtm_dT = 0.0; + } + + V0 = vbi - phi; + + +/* begin of v3.0 block addition */ +/* B/S built-in potential lowering calculation */ + if (here->B4SOIsoiMod == 0) /* BSIMPD */ /* v3.2 */ + { + Vbsmos = Vbs; + dVbsmos_dVg = 0.0; + dVbsmos_dVd = 0.0; + dVbsmos_dVb = 1.0; + dVbsmos_dVe = 0.0; + if (selfheat) dVbsmos_dT = 0.0; + else dVbsmos_dT = 0.0; + + Vbp = Vbs - Vps; + dVbp_dVb = 1; + } + else /* soiMod = 1 or 2: adding FD module on top of BSIMPD */ + { + /* prepare Vbs0 & Vbs0mos for VthFD calculation */ + T0 = -model->B4SOIdvbd1 * pParam->B4SOIleff / pParam->B4SOIlitl; + T1 = model->B4SOIdvbd0 * (exp(0.5*T0) + 2*exp(T0)); + T2 = T1 * (vbi - phi); + T3 = 0.5 * pParam->B4SOIqsi / model->B4SOIcsi; /* v3.2 */ + Vbs0t = phi - T3 + model->B4SOIvbsa + T2; + if (selfheat) + dVbs0t_dT = T1 * dvbi_dT; + else + dVbs0t_dT = 0.0; + + T0 = 1 + model->B4SOIcsi / Cbox; + T3 = -model->B4SOIdk2b * pParam->B4SOIleff / pParam->B4SOIlitl; + T5 = model->B4SOIk2b * (exp(0.5*T3) + 2*exp(T3)); + T1 = (model->B4SOIk1b - T5) / T0; + T2 = T1 * Vesfb; + T4 = 1.0/(1 + Cbox / model->B4SOIcsi); + Vbs0 = T4 * Vbs0t + T2; + dVbs0_dVe = T1; + if (selfheat) + dVbs0_dT = T4 * dVbs0t_dT - T1 * dvfbb_dT; + else + dVbs0_dT = 0.0; + + + /* zero field body potential cal. */ + T1 = Vbs0t - Vbs0 - 0.005; + T2 = sqrt(T1 * T1 + (2.5e-5)); + T3 = 0.5 * (T1 + T2); + T4 = T3 * model->B4SOIcsi / pParam->B4SOIqsi; /* v3.2 */ + Vbs0mos = Vbs0 - 0.5 * T3 * T4; + T5 = 0.5 * T4 * (1 + T1 / T2); + dVbs0mos_dVe = dVbs0_dVe * (1 + T5); + if (selfheat) + dVbs0mos_dT = dVbs0_dT * (1 + T5) - T5 * dVbs0t_dT; + else + dVbs0mos_dT = 0.0; + + + /* set the upperbound of Vbs0mos to be phi for square root calc. */ + T1 = phi - 0.02; + T2 = T1 - Vbs0mos - 0.005; + T3 = sqrt(T2 * T2 + 4.0 * 0.005); + Vbs0mos = T1 - 0.5 * (T2 + T3); + T4 = 0.5 * (1 + T2 / T3); + dVbs0mos_dVe = T4 * dVbs0mos_dVe; + if (selfheat) + dVbs0mos_dT = T4 * dVbs0mos_dT; + else dVbs0mos_dT = 0.0; + + + /* VthFD calculation */ + Phis = phi - Vbs0mos; + dPhis_dVb = -1; /* w.r.t Vbs0mos */ + sqrtPhis = sqrt(Phis); + dsqrtPhis_dVb = -0.5 / sqrtPhis; + Xdep = Xdep0 * sqrtPhis / sqrtPhi; + dXdep_dVb = (Xdep0 / sqrtPhi) * dsqrtPhis_dVb; + + T3 = sqrt(Xdep); + T0 = pParam->B4SOIdvt2 * Vbs0mos; + if (T0 >= - 0.5) + { T1 = 1.0 + T0; + T2 = pParam->B4SOIdvt2 ; + } + else /* Added to avoid any discontinuity problems caused by dvt2 */ + { T4 = 1.0 / (3.0 + 8.0 * T0); + T1 = (1.0 + 3.0 * T0) * T4; + T2 = pParam->B4SOIdvt2 * T4 * T4 ; + } + lt1 = model->B4SOIfactor1 * T3 * T1; + dlt1_dVb =model->B4SOIfactor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + + T0 = pParam->B4SOIdvt2w * Vbs0mos; + if (T0 >= - 0.5) + { T1 = 1.0 + T0; + T2 = pParam->B4SOIdvt2w ; + } + else /* Added to avoid any discontinuity problems caused by dvt2w */ + { T4 = 1.0 / (3.0 + 8.0 * T0); + T1 = (1.0 + 3.0 * T0) * T4; + T2 = pParam->B4SOIdvt2w * T4 * T4 ; + } + ltw= model->B4SOIfactor1 * T3 * T1; + dltw_dVb=model->B4SOIfactor1*(0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + + T0 = -0.5 * pParam->B4SOIdvt1 * Leff / lt1; + if (T0 > -EXPL_THRESHOLD) + { T1 = exp(T0); + Theta0 = T1 * (1.0 + 2.0 * T1); + dT1_dVb = -T0 / lt1 * T1 * dlt1_dVb; + dTheta0_dVb = (1.0 + 4.0 * T1) * dT1_dVb; + } + else + { T1 = MIN_EXPL; + Theta0 = T1 * (1.0 + 2.0 * T1); + dTheta0_dVb = 0.0; + } + + T2 = pParam->B4SOInfactor * EPSSI / Xdep; + dT2_dVb = - T2 / Xdep * dXdep_dVb; + + T3 = pParam->B4SOIcdsc + pParam->B4SOIcdscb * Vbseff + + pParam->B4SOIcdscd * Vds; + dT3_dVb = pParam->B4SOIcdscb; + dT3_dVd = pParam->B4SOIcdscd; + T4 = (T2 + T3 * Theta0 + pParam->B4SOIcit) + / model->B4SOIcox; + dT4_dVb = (dT2_dVb + Theta0 * dT3_dVb + + dTheta0_dVb * T3) / model->B4SOIcox; + dT4_dVd = Theta0 * dT3_dVd / model->B4SOIcox; + + if (T4 >= -0.5) { + n = 1.0 + T4; + dn_dVb = dT4_dVb; + dn_dVd = dT4_dVd; + } + else { /* avoid discontinuity problems caused by T4 */ + T0 = 1.0 / (3.0 + 8.0 * T4); + n = (1.0 + 3.0 * T4) * T0; + T0 *= T0; + dn_dVb = T0 * dT4_dVb; + dn_dVd = T0 * dT4_dVd; + } + + if (pParam->B4SOIdvtp0 > 0.0) { /* v4.0 */ + T0 = -pParam->B4SOIdvtp1 * Vds; + if (T0 < -EXPL_THRESHOLD) { + T2 = MIN_EXPL; + dT2_dVd = 0.0; + } + else { + T2 = exp(T0); + dT2_dVd = -pParam->B4SOIdvtp1 * T2; + } + + T3 = Leff + pParam->B4SOIdvtp0 * (1.0 + T2); + dT3_dVd = pParam->B4SOIdvtp0 * dT2_dVd; + T4 = Vtm * log(Leff / T3); + dT4_dVd = -Vtm * dT3_dVd / T3; + DITS_Sft = n * T4; + dDITS_Sft_dVd = dn_dVd * T4 + n * dT4_dVd; + dDITS_Sft_dVb = T4 * dn_dVb; + if (selfheat) { + dDITS_Sft_dT = n * KboQ * log(Leff / T3); + } + else + dDITS_Sft_dT = 0.0; + } + else { + DITS_Sft = dDITS_Sft_dVd = dDITS_Sft_dVb = 0.0; + dDITS_Sft_dT = 0.0; + } + + here->B4SOIthetavth = pParam->B4SOIdvt0 * Theta0; + Delt_vth = here->B4SOIthetavth * V0; + dDelt_vth_dVb = pParam->B4SOIdvt0 * dTheta0_dVb * V0; + if (selfheat) dDelt_vth_dT = here->B4SOIthetavth * dvbi_dT; + else dDelt_vth_dT = 0.0; + + T0 = -0.5 * pParam->B4SOIdvt1w * pParam->B4SOIweff * Leff / ltw; + if (T0 > -EXPL_THRESHOLD) + { T1 = exp(T0); + T2 = T1 * (1.0 + 2.0 * T1); + dT1_dVb = -T0 / ltw * T1 * dltw_dVb; + dT2_dVb = (1.0 + 4.0 * T1) * dT1_dVb; + } + else + { T1 = MIN_EXPL; + T2 = T1 * (1.0 + 2.0 * T1); + dT2_dVb = 0.0; + } + + T0 = pParam->B4SOIdvt0w * T2; + DeltVthw = T0 * V0; + dDeltVthw_dVb = pParam->B4SOIdvt0w * dT2_dVb * V0; + if (selfheat) dDeltVthw_dT = T0 * dvbi_dT; + else dDeltVthw_dT = 0.0; + + T0 = sqrt(1.0 + pParam->B4SOIlpe0 / Leff); + T1 = (pParam->B4SOIkt1 + pParam->B4SOIkt1l / Leff + + pParam->B4SOIkt2 * Vbs0mos); + + /* v4.0 */ +/* DeltVthtemp = pParam->B4SOIk1eff * (T0 - 1.0) * sqrtPhi + T1 * TempRatioMinus1; */ + DeltVthtemp = pParam->B4SOIk1ox * (T0 - 1.0) * sqrtPhi + + T1 * TempRatioMinus1; + /* v4.0 end */ + + if (selfheat) + dDeltVthtemp_dT = T1 / model->B4SOItnom; + else + dDeltVthtemp_dT = 0.0; + + tmp2 = model->B4SOItox * phi + / (pParam->B4SOIweff + pParam->B4SOIw0); + + T3 = here->B4SOIeta0 + pParam->B4SOIetab * Vbs0mos;/*v4.0*/ + if (T3 < 1.0e-4) /* avoid discontinuity problems caused by etab */ + { T9 = 1.0 / (3.0 - 2.0e4 * T3); + T3 = (2.0e-4 - T3) * T9; + T4 = T9 * T9 * pParam->B4SOIetab; + dT3_dVb = T4 ; + } + else + { + dT3_dVb = pParam->B4SOIetab ; + } + DIBL_Sft = T3 * pParam->B4SOItheta0vb0 * Vds; + dDIBL_Sft_dVd = pParam->B4SOItheta0vb0 * T3; + dDIBL_Sft_dVb = pParam->B4SOItheta0vb0 * Vds * dT3_dVb; + + Lpe_Vb = sqrt(1.0 + pParam->B4SOIlpeb / Leff); + + VthFD = model->B4SOItype * here->B4SOIvth0 + + (pParam->B4SOIk1ox * sqrtPhis + - pParam->B4SOIk1eff * sqrtPhi) * Lpe_Vb + - here->B4SOIk2ox * Vbs0mos- Delt_vth - DeltVthw + + (pParam->B4SOIk3 + pParam->B4SOIk3b * Vbs0mos) + * tmp2 + DeltVthtemp - DIBL_Sft - DITS_Sft; + + T6 = pParam->B4SOIk3b * tmp2 - here->B4SOIk2ox + + pParam->B4SOIkt2 * TempRatioMinus1; + dVthFD_dVb = Lpe_Vb * pParam->B4SOIk1ox * dsqrtPhis_dVb + - dDelt_vth_dVb - dDeltVthw_dVb + + T6 - dDIBL_Sft_dVb - dDITS_Sft_dVb; /* v4.0 */ + /* this is actually dVth_dVbs0mos */ + + dVthFD_dVe = dVthFD_dVb * dVbs0mos_dVe; + dVthFD_dVd = -dDIBL_Sft_dVd -dDITS_Sft_dVd; /*v4.0 */ + if (selfheat) + dVthFD_dT = dDeltVthtemp_dT - dDelt_vth_dT + - dDeltVthw_dT + dVthFD_dVb * dVbs0mos_dT + - dDITS_Sft_dT ; + else dVthFD_dT = 0.0; + + + /* VtgseffFD calculation for PhiFD */ + VtgsFD = VthFD - Vgs_eff; + T10 = model->B4SOInofffd * Vtm; + DEXP((VtgsFD - model->B4SOIvofffd)/ T10, ExpVtgsFD, T0); + VtgseffFD = T10 * log(1.0 + ExpVtgsFD); + T0 /= (1.0 + ExpVtgsFD); + dVtgseffFD_dVd = T0 * dVthFD_dVd; + dVtgseffFD_dVg = -T0 * dVgs_eff_dVg; + dVtgseffFD_dVe = T0 * dVthFD_dVe; + if (selfheat) + dVtgseffFD_dT = T0 * (dVthFD_dT - (VtgsFD - model->B4SOIvofffd)/Temp) + + VtgseffFD/Temp; + else dVtgseffFD_dT = 0.0; + + + /* surface potential modeling at strong inversion: PhiON */ + VgstFD = Vgs_eff - VthFD; + DEXP((VgstFD - model->B4SOIvofffd)/ T10, ExpVgstFD, T0); + VgsteffFD = T10 * log(1.0 + ExpVgstFD); + T0 /= (1.0 + ExpVgstFD); + dVgsteffFD_dVd = -T0 * dVthFD_dVd; + dVgsteffFD_dVg = T0 * dVgs_eff_dVg; + dVgsteffFD_dVe = -T0 * dVthFD_dVe; + if (selfheat) + dVgsteffFD_dT = T0 * (-dVthFD_dT + - (VgstFD - model->B4SOIvofffd)/Temp) + + VgsteffFD/Temp; + else dVgsteffFD_dT = 0.0; + + +/* T1 = model->B4SOImoinFD*pParam->B4SOIk1eff*Vtm*Vtm; */ + T1 = model->B4SOImoinFD*pParam->B4SOIk1ox*Vtm*Vtm; + if (selfheat) dT1_dT = 2*T1/Temp; + else dT1_dT=0.0; + + T2 = VgsteffFD+ 2*pParam->B4SOIk1eff*sqrt(phi); + dT2_dVg = dVgsteffFD_dVg; + dT2_dVd = dVgsteffFD_dVd; + dT2_dVe = dVgsteffFD_dVe; + if (selfheat) dT2_dT = dVgsteffFD_dT; + else dT2_dT = 0.0; + + T0 = 1+ VgsteffFD * T2 / T1; + dT0_dVg = (VgsteffFD * dT2_dVg + T2 * dVgsteffFD_dVg) / T1; + dT0_dVd = (VgsteffFD * dT2_dVd + T2 * dVgsteffFD_dVd) / T1; + dT0_dVe = (VgsteffFD * dT2_dVe + T2 * dVgsteffFD_dVe) / T1; + if (selfheat) + dT0_dT = (VgsteffFD * (dT2_dT - T2/T1 * dT1_dT) + T2 * dVgsteffFD_dT) / T1; + else dT0_dT = 0.0; + + + PhiON = phi + Vtm* log(T0) ; + dPhiON_dVg = Vtm* dT0_dVg/T0 ; + dPhiON_dVd = Vtm* dT0_dVd/T0 ; + dPhiON_dVe = Vtm* dT0_dVe/T0 ; + if (selfheat) + dPhiON_dT = Vtm* dT0_dT/T0 + (PhiON-phi)/Temp ; + else dPhiON_dT = 0.0; + + + /* surface potential from subthreshold to inversion: PhiFD */ + T0 = model->B4SOIcox / (model->B4SOIcox + 1.0/(1.0/model->B4SOIcsi + 1.0/Cbox)); + PhiFD = PhiON - T0 * VtgseffFD; + dPhiFD_dVg = dPhiON_dVg - T0 * dVtgseffFD_dVg; + dPhiFD_dVd = dPhiON_dVd - T0 * dVtgseffFD_dVd; + dPhiFD_dVe = dPhiON_dVe - T0 * dVtgseffFD_dVe; + if (selfheat) + dPhiFD_dT = dPhiON_dT - T0 * dVtgseffFD_dT; + else dPhiFD_dT = 0; + + + /* built-in potential lowering: Vbs0 */ + T0 = -model->B4SOIdvbd1 * pParam->B4SOIleff / pParam->B4SOIlitl; + T1 = model->B4SOIdvbd0 * (exp(0.5*T0) + 2*exp(T0)); + T2 = T1 * (vbi - phi); + T3 = 0.5 * pParam->B4SOIqsi / model->B4SOIcsi; /* v3.2 */ + Vbs0t = PhiFD - T3 + model->B4SOIvbsa + T2; + dVbs0t_dVg = dPhiFD_dVg; + dVbs0t_dVd = dPhiFD_dVd; + dVbs0t_dVe = dPhiFD_dVe; + if (selfheat) + dVbs0t_dT = dPhiFD_dT + T1 * dvbi_dT; + else dVbs0t_dT = 0; + + + T0 = 1 + model->B4SOIcsi / Cbox; + T3 = -model->B4SOIdk2b * pParam->B4SOIleff / pParam->B4SOIlitl; + T5 = model->B4SOIk2b * (exp(0.5*T3) + 2*exp(T3)); + T1 = (model->B4SOIk1b - T5) / T0; + T2 = T1 * Vesfb; + T0 = 1.0/(1 + Cbox / model->B4SOIcsi); + Vbs0 = T0 * Vbs0t + T2; + dVbs0_dVg = T0 * dVbs0t_dVg; + dVbs0_dVd = T0 * dVbs0t_dVd; + dVbs0_dVe = T0 * dVbs0t_dVe + T1; + if (selfheat) + dVbs0_dT = T0 * dVbs0t_dT - T1 * dvfbb_dT; + else + dVbs0_dT = 0.0; + + + /* set lowerbound of Vbs (from SPICE) to Vbs0: Vbsitf (Vbs at back interface) */ + if (here->B4SOIsoiMod == 2) /* v3.2 */ /* v3.1 ideal FD: Vbsitf is pinned at Vbs0 */ + { + Vbs = Vbsitf = Vbs0 + OFF_Vbsitf; + dVbsitf_dVg = dVbs0_dVg; + dVbsitf_dVd = dVbs0_dVd; + dVbsitf_dVe = dVbs0_dVe; + dVbsitf_dVb = 0.0; + if (selfheat) dVbsitf_dT = dVbs0_dT; + else dVbsitf_dT = 0; + } + else /* soiMod = 1 */ + { + T1 = Vbs - (Vbs0 + OFF_Vbsitf) - 0.01; + T2 = sqrt(T1*T1 + 0.0001); + T3 = 0.5 * (1 + T1/T2); + Vbsitf = (Vbs0 + OFF_Vbsitf) + 0.5 * (T1 + T2); + dVbsitf_dVg = (1 - T3) * dVbs0_dVg; + dVbsitf_dVd = (1 - T3) * dVbs0_dVd; + dVbsitf_dVe = (1 - T3) * dVbs0_dVe; + dVbsitf_dVb = T3 ; + if (selfheat) dVbsitf_dT = (1 - T3) * dVbs0_dT; + else dVbsitf_dT = 0.0; + } + + /* Based on Vbsitf, calculate zero-field body potential for MOS: Vbsmos */ + T1 = Vbs0t - Vbsitf - 0.005; + T2 = sqrt(T1 * T1 + (2.5e-5)); + T3 = 0.5 * (T1 + T2); + T4 = T3 * model->B4SOIcsi / pParam->B4SOIqsi; /* v3.2 */ + Vbsmos = Vbsitf - 0.5 * T3 * T4; + T5 = 0.5 * T4 * (1 + T1 / T2); + dVbsmos_dVg = dVbsitf_dVg * (1 + T5) - T5 * dVbs0t_dVg; + dVbsmos_dVd = dVbsitf_dVd * (1 + T5) - T5 * dVbs0t_dVd; + dVbsmos_dVb = dVbsitf_dVb * (1 + T5); + dVbsmos_dVe = dVbsitf_dVe * (1 + T5) - T5 * dVbs0t_dVe; + if (selfheat) + dVbsmos_dT = dVbsitf_dT * (1 + T5) - T5 * dVbs0t_dT; + else + dVbsmos_dT = 0.0; + /* Vbsmos should be used in MOS after some limiting (Vbseff) */ + + + Vbp = Vbs - Vps; + dVbp_dVb = 1; + } +/* end of v3.0 block edition */ + + +/* v3.0 modification */ + /* T2 is Vbsmos limited above Vbsc=-5 */ + T0 = Vbsmos + 5 - 0.001; + T1 = sqrt(T0 * T0 - 0.004 * (-5)); + T2 = (-5) + 0.5 * (T0 + T1); + dT2_dVb = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVb; + dT2_dVg = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVg; + dT2_dVd = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVd; + dT2_dVe = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVe; + if (selfheat) dT2_dT = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dT; + else dT2_dT = 0.0; + + /* Vbsh is T2 limited below 1.5 */ + T0 = 1.5; + T1 = T0 - T2 - 0.002; + T3 = sqrt(T1 * T1 + 0.008 * T0); + Vbsh = T0 - 0.5 * (T1 + T3); + dVbsh_dVb = 0.5 * (1.0 + T1 / T3) * dT2_dVb; + dVbsh_dVg = 0.5 * (1.0 + T1 / T3) * dT2_dVg; + dVbsh_dVd = 0.5 * (1.0 + T1 / T3) * dT2_dVd; + dVbsh_dVe = 0.5 * (1.0 + T1 / T3) * dT2_dVe; + if (selfheat) dVbsh_dT = 0.5 * (1.0 + T1 / T3) * dT2_dT; + else dVbsh_dT = 0.0; + + + /* Vbseff is Vbsh limited to 0.95*phi */ + T0 = 0.95 * phi; + T1 = T0 - Vbsh - 0.002; + T2 = sqrt(T1 * T1 + 0.008 * T0); + Vbseff = T0 - 0.5 * (T1 + T2); + dVbseff_dVb = 0.5 * (1.0 + T1 / T2) * dVbsh_dVb; + dVbseff_dVg = 0.5 * (1.0 + T1 / T2) * dVbsh_dVg; + dVbseff_dVd = 0.5 * (1.0 + T1 / T2) * dVbsh_dVd; + dVbseff_dVe = 0.5 * (1.0 + T1 / T2) * dVbsh_dVe; + if (selfheat) dVbseff_dT = 0.5 * (1.0 + T1 / T2) * dVbsh_dT; + else dVbseff_dT = 0.0; + here->B4SOIvbseff = Vbseff; /* SPICE sol. */ +/* end of v3.0 modification */ + + + /* Below all the variables refer to Vbseff */ + if (dVbseff_dVb < 1e-20) { + dVbseff_dVb = 1e-20; + dVbsh_dVb *= 1e20; + } + else + dVbsh_dVb /= dVbseff_dVb; + + Phis = phi - Vbseff; + dPhis_dVb = -1; + sqrtPhis = sqrt(Phis); + dsqrtPhis_dVb = -0.5 / sqrtPhis; + + Xdep = Xdep0 * sqrtPhis / sqrtPhi; + dXdep_dVb = (Xdep0 / sqrtPhi) * dsqrtPhis_dVb; + + /* Calculate nstar v3.2 */ + here->B4SOInstar = model->B4SOIvtm / Charge_q * + (model->B4SOIcox + EPSSI / Xdep + pParam->B4SOIcit); + +/* Vth Calculation */ + T3 = sqrt(Xdep); + + T0 = pParam->B4SOIdvt2 * Vbseff; + if (T0 >= - 0.5) + { T1 = 1.0 + T0; + T2 = pParam->B4SOIdvt2 ; + } + else /* Added to avoid any discontinuity problems caused by dvt2 */ + { T4 = 1.0 / (3.0 + 8.0 * T0); + T1 = (1.0 + 3.0 * T0) * T4; + T2 = pParam->B4SOIdvt2 * T4 * T4 ; + } + lt1 = model->B4SOIfactor1 * T3 * T1; + dlt1_dVb =model->B4SOIfactor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + + T0 = pParam->B4SOIdvt2w * Vbseff; + if (T0 >= - 0.5) + { T1 = 1.0 + T0; + T2 = pParam->B4SOIdvt2w ; + } + else /* Added to avoid any discontinuity problems caused by dvt2w */ + { T4 = 1.0 / (3.0 + 8.0 * T0); + T1 = (1.0 + 3.0 * T0) * T4; + T2 = pParam->B4SOIdvt2w * T4 * T4 ; + } + ltw= model->B4SOIfactor1 * T3 * T1; + dltw_dVb=model->B4SOIfactor1*(0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + + T0 = -0.5 * pParam->B4SOIdvt1 * Leff / lt1; + if (T0 > -EXPL_THRESHOLD) + { T1 = exp(T0); + Theta0 = T1 * (1.0 + 2.0 * T1); + dT1_dVb = -T0 / lt1 * T1 * dlt1_dVb; + dTheta0_dVb = (1.0 + 4.0 * T1) * dT1_dVb; + } + else + { T1 = MIN_EXPL; + Theta0 = T1 * (1.0 + 2.0 * T1); + dTheta0_dVb = 0.0; + } + + /* Calculate n */ + T2 = pParam->B4SOInfactor * EPSSI / Xdep; + dT2_dVb = - T2 / Xdep * dXdep_dVb; + + T3 = pParam->B4SOIcdsc + pParam->B4SOIcdscb * Vbseff + + pParam->B4SOIcdscd * Vds; + dT3_dVb = pParam->B4SOIcdscb; + dT3_dVd = pParam->B4SOIcdscd; + + T4 = (T2 + T3 * Theta0 + pParam->B4SOIcit) / model->B4SOIcox; + dT4_dVb = (dT2_dVb + Theta0 * dT3_dVb + dTheta0_dVb * T3) + / model->B4SOIcox; + dT4_dVd = Theta0 * dT3_dVd / model->B4SOIcox; + + if (T4 >= -0.5) + { n = 1.0 + T4; + dn_dVb = dT4_dVb; + dn_dVd = dT4_dVd; + } + else + /* avoid discontinuity problems caused by T4 */ + { T0 = 1.0 / (3.0 + 8.0 * T4); + n = (1.0 + 3.0 * T4) * T0; + T0 *= T0; + dn_dVb = T0 * dT4_dVb; + dn_dVd = T0 * dT4_dVd; + } + + /* v4.0 DITS */ + if (pParam->B4SOIdvtp0 > 0.0) { + T0 = -pParam->B4SOIdvtp1 * Vds; + if (T0 < -EXPL_THRESHOLD) { + T2 = MIN_EXPL; + dT2_dVd = 0.0; + } + else { + T2 = exp(T0); + dT2_dVd = -pParam->B4SOIdvtp1 * T2; + } + + T3 = Leff + pParam->B4SOIdvtp0 * (1.0 + T2); + dT3_dVd = pParam->B4SOIdvtp0 * dT2_dVd; + T4 = Vtm * log(Leff / T3); + dT4_dVd = -Vtm * dT3_dVd / T3; + DITS_Sft = n * T4; + dDITS_Sft_dVd = dn_dVd * T4 + n * dT4_dVd; + dDITS_Sft_dVb = T4 * dn_dVb; + if (selfheat) { + dDITS_Sft_dT = n * KboQ * log(Leff / T3); + } + else + dDITS_Sft_dT = 0.0; + } + else { + DITS_Sft = dDITS_Sft_dVd = dDITS_Sft_dVb = 0.0; + dDITS_Sft_dT = 0.0; + } + + here->B4SOIthetavth = pParam->B4SOIdvt0 * Theta0; + Delt_vth = here->B4SOIthetavth * V0; + dDelt_vth_dVb = pParam->B4SOIdvt0 * dTheta0_dVb * V0; + if (selfheat) dDelt_vth_dT = here->B4SOIthetavth * dvbi_dT; + else dDelt_vth_dT = 0.0; + + T0 = -0.5 * pParam->B4SOIdvt1w * pParam->B4SOIweff + * Leff / ltw; + if (T0 > -EXPL_THRESHOLD) + { T1 = exp(T0); + T2 = T1 * (1.0 + 2.0 * T1); + dT1_dVb = -T0 / ltw * T1 * dltw_dVb; + dT2_dVb = (1.0 + 4.0 * T1) * dT1_dVb; + } + else + { T1 = MIN_EXPL; + T2 = T1 * (1.0 + 2.0 * T1); + dT2_dVb = 0.0; + } + + T0 = pParam->B4SOIdvt0w * T2; + DeltVthw = T0 * V0; + dDeltVthw_dVb = pParam->B4SOIdvt0w * dT2_dVb * V0; + if (selfheat) dDeltVthw_dT = T0 * dvbi_dT; + else dDeltVthw_dT = 0.0; + + T0 = sqrt(1.0 + pParam->B4SOIlpe0 / Leff); + T1 = (pParam->B4SOIkt1 + pParam->B4SOIkt1l / Leff + + pParam->B4SOIkt2 * Vbseff); + DeltVthtemp = pParam->B4SOIk1ox * (T0 - 1.0) * sqrtPhi + + T1 * TempRatioMinus1; /* v4.0 */ + if (selfheat) + dDeltVthtemp_dT = T1 / model->B4SOItnom; + else + dDeltVthtemp_dT = 0.0; + + tmp2 = model->B4SOItox * phi + / (pParam->B4SOIweff + pParam->B4SOIw0); + + T3 = here->B4SOIeta0 + pParam->B4SOIetab * Vbseff; + if (T3 < 1.0e-4) /* avoid discontinuity problems caused by etab */ + { T9 = 1.0 / (3.0 - 2.0e4 * T3); + T3 = (2.0e-4 - T3) * T9; + T4 = T9 * T9 * pParam->B4SOIetab; + dT3_dVb = T4 ; + } + else + { + dT3_dVb = pParam->B4SOIetab ; + } + DIBL_Sft = T3 * pParam->B4SOItheta0vb0 * Vds; + dDIBL_Sft_dVd = pParam->B4SOItheta0vb0 * T3; + dDIBL_Sft_dVb = pParam->B4SOItheta0vb0 * Vds * dT3_dVb; + + Lpe_Vb = sqrt(1.0 + pParam->B4SOIlpeb / Leff); + + T9 = 2.2361 / sqrtPhi; + sqrtPhisExt = sqrtPhis - T9 * (Vbsh - Vbseff); + dsqrtPhisExt_dVb = dsqrtPhis_dVb - T9 * (dVbsh_dVb - 1); + + Vth = model->B4SOItype * here->B4SOIvth0 + + (pParam->B4SOIk1ox * sqrtPhisExt + - pParam->B4SOIk1eff * sqrtPhi) * Lpe_Vb + - here->B4SOIk2ox * Vbseff- Delt_vth - DeltVthw + +(pParam->B4SOIk3 + pParam->B4SOIk3b * Vbseff) * tmp2 + + DeltVthtemp - DIBL_Sft -DITS_Sft; + + here->B4SOIvon = Vth; + + T6 = pParam->B4SOIk3b * tmp2 - here->B4SOIk2ox + + pParam->B4SOIkt2 * TempRatioMinus1; + dVth_dVb = Lpe_Vb * pParam->B4SOIk1ox * dsqrtPhisExt_dVb + - dDelt_vth_dVb - dDeltVthw_dVb + + T6 - dDIBL_Sft_dVb - dDITS_Sft_dVb; + /* this is actually dVth_dVbseff */ + + dVth_dVd = -dDIBL_Sft_dVd - dDITS_Sft_dVd; + if (selfheat) + dVth_dT = dDeltVthtemp_dT - dDelt_vth_dT - dDeltVthw_dT + - dDITS_Sft_dT; + else dVth_dT = 0.0; + + + /* dVthzb_dT calculation */ + if ((model->B4SOIcapMod == 3) && (selfheat == 1)) { + T3zb = sqrt(Xdep0); + ltwzb = lt1zb = model->B4SOIfactor1 * T3zb; + + T0 = -0.5 * pParam->B4SOIdvt1 * Leff / lt1zb; + if (T0 > -EXPL_THRESHOLD) + { T1 = exp(T0); + Theta0zb = T1 * (1.0 + 2.0 * T1); + } + else + { T1 = MIN_EXPL; + Theta0zb = T1 * (1.0 + 2.0 * T1); + } + Delt_vthzb = pParam->B4SOIdvt0 * Theta0zb * V0; + dDelt_vthzb_dT = pParam->B4SOIdvt0 * Theta0zb * dvbi_dT; + + T0 = -0.5 * pParam->B4SOIdvt1w * pParam->B4SOIweff * Leff / ltwzb; + if (T0 > -EXPL_THRESHOLD) + { T1 = exp(T0); + T2 = T1 * (1.0 + 2.0 * T1); + } + else + { T1 = MIN_EXPL; + T2 = T1 * (1.0 + 2.0 * T1); + } + T0 = pParam->B4SOIdvt0w * T2; + DeltVthwzb = T0 * V0; + dDeltVthwzb_dT = T0 * dvbi_dT; + + T0 = sqrt(1.0 + pParam->B4SOIlpe0 / Leff); + T1 = (pParam->B4SOIkt1 + pParam->B4SOIkt1l / Leff); + DeltVthtempzb = pParam->B4SOIk1ox * (T0 - 1.0) * sqrtPhi + + T1 * TempRatioMinus1; + dDeltVthtempzb_dT = T1 / model->B4SOItnom; + + Vthzb = model->B4SOItype * here->B4SOIvth0 + - Delt_vthzb - DeltVthwzb + pParam->B4SOIk3 * tmp2 + + DeltVthtempzb; + dVthzb_dT = dDeltVthtempzb_dT - dDelt_vthzb_dT - dDeltVthwzb_dT; + } + +/* Effective Vgst (Vgsteff) Calculation */ + + Vgst = Vgs_eff - Vth; + dVgst_dVg = dVgs_eff_dVg; + dVgst_dVd = -dVth_dVd; + dVgst_dVb = -dVth_dVb; + + T10 = n * Vtm; /* v4.0 */ + VgstNVt = pParam->B4SOImstar * Vgst / T10; /* v4.0 */ + ExpArg = (pParam->B4SOIvoff - (1- pParam->B4SOImstar) * Vgst) + / T10; /* v4.0 */ + + /* MCJ: Very small Vgst */ + if (VgstNVt > EXPL_THRESHOLD) + { Vgsteff = Vgst; + /* T0 is dVgsteff_dVbseff */ + T0 = -dVth_dVb; + dVgsteff_dVg = dVgs_eff_dVg + T0 * dVbseff_dVg; /* v3.0 */ + dVgsteff_dVd = -dVth_dVd + T0 * dVbseff_dVd; /* v3.0 */ + dVgsteff_dVb = T0 * dVbseff_dVb; + dVgsteff_dVe = T0 * dVbseff_dVe; /* v3.0 */ + if (selfheat) + dVgsteff_dT = -dVth_dT + T0 * dVbseff_dT; /* v3.0 */ + else + dVgsteff_dT = 0.0; + } + else if (ExpArg > EXPL_THRESHOLD) + { T0 = (Vgst - pParam->B4SOIvoff) / (n * Vtm); + ExpVgst = exp(T0); + Vgsteff = Vtm * pParam->B4SOIcdep0 / model->B4SOIcox * ExpVgst; + T3 = Vgsteff / (n * Vtm) ; + /* T1 is dVgsteff_dVbseff */ + T1 = -T3 * (dVth_dVb + T0 * Vtm * dn_dVb); + dVgsteff_dVg = T3 * dVgs_eff_dVg+ T1 * dVbseff_dVg; /* v3.0 */ + dVgsteff_dVd = -T3 * (dVth_dVd + T0 * Vtm * dn_dVd)+ T1 * dVbseff_dVd; /* v3.0 */ + dVgsteff_dVe = T1 * dVbseff_dVe; /* v3.0 */ + dVgsteff_dVb = T1 * dVbseff_dVb; + if (selfheat) + dVgsteff_dT = -T3 * (dVth_dT + T0 * dVtm_dT * n) + + Vgsteff / Temp+ T1 * dVbseff_dT; /* v3.0 */ + else + dVgsteff_dT = 0.0; + } + else + { ExpVgst = exp(VgstNVt); + T1 = T10 * log(1.0 + ExpVgst); + dT1_dVg = ExpVgst / (1.0 + ExpVgst) * pParam->B4SOImstar; + dT1_dVb = -dT1_dVg * (dVth_dVb + Vgst / n * dn_dVb) + + T1 / n * dn_dVb; + dT1_dVd = -dT1_dVg * (dVth_dVd + Vgst / n * dn_dVd) + + T1 / n * dn_dVd; + T3 = (1.0 / Temp); + if (selfheat) + dT1_dT = -dT1_dVg * (dVth_dT + Vgst * T3) + T1 * T3; + else + dT1_dT = 0.0; + + dT2_dVg = -model->B4SOIcox / (Vtm * pParam->B4SOIcdep0) + * exp(ExpArg) * (1 - pParam->B4SOImstar); + T2 = pParam->B4SOImstar - T10 * dT2_dVg + / (1.0 - pParam->B4SOImstar); + dT2_dVd = -dT2_dVg * (dVth_dVd - Vtm * ExpArg * dn_dVd + / (1.0 - pParam->B4SOImstar)) + + (T2 - pParam->B4SOImstar) / n * dn_dVd; + dT2_dVb = -dT2_dVg * (dVth_dVb - Vtm * ExpArg * dn_dVb + / (1.0 - pParam->B4SOImstar)) + + (T2 - pParam->B4SOImstar) / n * dn_dVb; + if (selfheat) + dT2_dT = -dT2_dVg * ( dVth_dT - ExpArg * T10 * T3 + / (1.0 - pParam->B4SOImstar) ); + else + dT2_dT = 0.0; + + Vgsteff = T1 / T2; + T3 = T2 * T2; + /* T4 is dVgsteff_dVbseff */ + T4 = (T2 * dT1_dVb - T1 * dT2_dVb) / T3; + dVgsteff_dVb = T4 * dVbseff_dVb; + dVgsteff_dVe = T4 * dVbseff_dVe; /* v3.0 */ + dVgsteff_dVg = (T2 * dT1_dVg - T1 * dT2_dVg) + / T3 * dVgs_eff_dVg + + T4 * dVbseff_dVg; /* v3.0 */ + dVgsteff_dVd = (T2 * dT1_dVd - T1 * dT2_dVd) + / T3+ T4 * dVbseff_dVd; /* v3.0 */ + if (selfheat) + dVgsteff_dT = (T2 * dT1_dT - T1 * dT2_dT) + / T3+ T4 * dVbseff_dT; /* v3.0 */ + else + dVgsteff_dT = 0.0; + } + Vgst2Vtm = Vgsteff + 2.0 * Vtm; + if (selfheat) dVgst2Vtm_dT = dVgsteff_dT + 2.0 * dVtm_dT; /* v3.1.1 bug fix */ + else dVgst2Vtm_dT = 0.0; + here->B4SOIVgsteff = Vgsteff; /* v2.2.3 bug fix */ + + /* v4.0 F-factor (degradation factor due to pocket implant) */ + if (pParam->B4SOIfprout <= 0.0) + { FP = 1.0; + dFP_dVg = dFP_dT = 0.0; + } + else + { T9 = pParam->B4SOIfprout * sqrt(Leff) / Vgst2Vtm; + FP = 1.0 / (1.0 + T9); + dFP_dVg = FP * FP * T9 / Vgst2Vtm; + if (selfheat) dFP_dT = dFP_dVg * dVgst2Vtm_dT; + else dFP_dT = 0.0; + } + +/* Calculate Effective Channel Geometry */ + T9 = sqrtPhis - sqrtPhi; + Weff = pParam->B4SOIweff - (2.0 - here->B4SOInbc) + * (pParam->B4SOIdwg * Vgsteff + pParam->B4SOIdwb * T9); + dWeff_dVg = -(2.0 - here->B4SOInbc) * pParam->B4SOIdwg; + dWeff_dVb = -(2.0 - here->B4SOInbc) * pParam->B4SOIdwb + * dsqrtPhis_dVb; + + if (Weff < 2.0e-8) /* to avoid the discontinuity problem due to Weff*/ + { T0 = 1.0 / (6.0e-8 - 2.0 * Weff); + Weff = 2.0e-8 * (4.0e-8 - Weff) * T0; + T0 *= T0 * 4.0e-16; + dWeff_dVg *= T0; + dWeff_dVb *= T0; + } + + if (model->B4SOIrdsMod == 1) /* v4.0 */ + Rds = dRds_dVg = dRds_dVb = dRds_dT = 0.0; + else { + T0 = pParam->B4SOIprwg * Vgsteff + + pParam->B4SOIprwb * T9; + if (T0 >= -0.9) + { Rds = rds0 * (1.0 + T0); + dRds_dVg = rds0 * pParam->B4SOIprwg; + dRds_dVb = rds0 * pParam->B4SOIprwb * dsqrtPhis_dVb; + + if (selfheat && (Rds!=0.0)) + dRds_dT = (1.0 + T0) * drds0_dT; + else dRds_dT = 0.0; + + } + else + /* to avoid the discontinuity problem due to prwg and prwb*/ + { T1 = 1.0 / (17.0 + 20.0 * T0); + Rds = rds0 * (0.8 + T0) * T1; + T1 *= T1; + dRds_dVg = rds0 * pParam->B4SOIprwg * T1; + dRds_dVb = rds0 * pParam->B4SOIprwb * dsqrtPhis_dVb + * T1; + + if (selfheat && (Rds!=0.0)) + dRds_dT = (0.8 + T0) * T1 * drds0_dT; + else dRds_dT = 0.0; + + } + here->B4SOIrds = Rds; /* v2.2.3 bug fix */ + } + +/* Calculate Abulk */ + if (pParam->B4SOIa0 == 0.0) { + + Abulk0 = Abulk = 1.0; + + dAbulk0_dVb = dAbulk_dVg = dAbulk_dVb = 0.0; + } + else { + T10 = pParam->B4SOIketa * Vbsh; + if (T10 >= -0.9) { + T11 = 1.0 / (1.0 + T10); + dT11_dVb = -pParam->B4SOIketa * T11 * T11 * dVbsh_dVb; + } + else { /* added to avoid the problems caused by Keta */ + T12 = 1.0 / (0.8 + T10); + T11 = (17.0 + 20.0 * T10) * T12; + dT11_dVb = -pParam->B4SOIketa * T12 * T12 * dVbsh_dVb; + } + +/* v3.0 bug fix */ + T10 = phi + pParam->B4SOIketas; + + T13 = (Vbsh * T11) / T10; + dT13_dVb = (Vbsh * dT11_dVb + T11 * dVbsh_dVb) / T10; + + /* limit 1/sqrt(1-T13) to 6, starting at T13=0.96 */ + if (T13 < 0.96) { + T14 = 1 / sqrt(1-T13); + T10 = 0.5 * T14 / (1-T13); + dT14_dVb = T10 * dT13_dVb; + } + else { + T11 = 1.0 / (1.0 - 1.043406 * T13); + T14 = (6.00167 - 6.26044 * T13) * T11; + T10 = 0.001742 * T11 * T11; + dT14_dVb = T10 * dT13_dVb; + } + +/* v3.0 bug fix */ +/* T10 = 0.5 * pParam->B4SOIk1eff + / sqrt(phi + pParam->B4SOIketas); */ + T10 = 0.5 * pParam->B4SOIk1ox * Lpe_Vb + / sqrt(phi + pParam->B4SOIketas); /* v4.0 */ + + T1 = T10 * T14; + dT1_dVb = T10 * dT14_dVb; + + T9 = sqrt(pParam->B4SOIxj * Xdep); + tmp1 = Leff + 2.0 * T9; + T5 = Leff / tmp1; + tmp2 = pParam->B4SOIa0 * T5; + tmp3 = pParam->B4SOIweff + pParam->B4SOIb1; + tmp4 = pParam->B4SOIb0 / tmp3; + T2 = tmp2 + tmp4; + dT2_dVb = -T9 * tmp2 / tmp1 / Xdep * dXdep_dVb; + T6 = T5 * T5; + T7 = T5 * T6; + + Abulk0 = 1 + T1 * T2; + dAbulk0_dVb = T1 * dT2_dVb + T2 * dT1_dVb; + + T8 = pParam->B4SOIags * pParam->B4SOIa0 * T7; + dAbulk_dVg = -T1 * T8; + Abulk = Abulk0 + dAbulk_dVg * Vgsteff; + + dAbulk_dVb = dAbulk0_dVb + - T8 * Vgsteff * (dT1_dVb + 3.0 * T1 * dT2_dVb / tmp2); + } + + if (Abulk0 < 0.01) + { + T9 = 1.0 / (3.0 - 200.0 * Abulk0); + Abulk0 = (0.02 - Abulk0) * T9; + dAbulk0_dVb *= T9 * T9; + } + + if (Abulk < 0.01) + { + T9 = 1.0 / (3.0 - 200.0 * Abulk); + Abulk = (0.02 - Abulk) * T9; + dAbulk_dVb *= T9 * T9; + T10 = T9 * T9; /* 3.2 bug fix */ + dAbulk_dVg *= T10; /* 3.2 bug fix */ + } + + here->B4SOIAbulk = Abulk; /*v3.2 for noise */ + +/* Mobility calculation */ + if (model->B4SOImobMod == 1) + { T0 = Vgsteff + Vth + Vth; + T2 = ua + uc * Vbseff; + T3 = T0 / model->B4SOItox; + T5 = T3 * (T2 + ub * T3); + dDenomi_dVg = (T2 + 2.0 * ub * T3) / model->B4SOItox; + dDenomi_dVd = dDenomi_dVg * 2 * dVth_dVd; + dDenomi_dVb = dDenomi_dVg * 2 * dVth_dVb + uc * T3 ; + if (selfheat) + dDenomi_dT = dDenomi_dVg * 2 * dVth_dT + + (dua_dT + Vbseff * duc_dT + + dub_dT * T3 ) * T3; + else + dDenomi_dT = 0.0; + } + else if (model->B4SOImobMod == 2) + { T5 = Vgsteff / model->B4SOItox * (ua + + uc * Vbseff + ub * Vgsteff + / model->B4SOItox); + dDenomi_dVg = (ua + uc * Vbseff + + 2.0 * ub * Vgsteff / model->B4SOItox) + / model->B4SOItox; + dDenomi_dVd = 0.0; + dDenomi_dVb = Vgsteff * uc / model->B4SOItox ; + if (selfheat) + dDenomi_dT = Vgsteff / model->B4SOItox + * (dua_dT + Vbseff * duc_dT + dub_dT + * Vgsteff / model->B4SOItox); + else + dDenomi_dT = 0.0; + } + else /* mobMod == 3 */ + { T0 = Vgsteff + Vth + Vth; + T2 = 1.0 + uc * Vbseff; + T3 = T0 / model->B4SOItox; + T4 = T3 * (ua + ub * T3); + T5 = T4 * T2; + dDenomi_dVg = (ua + 2.0 * ub * T3) * T2 + / model->B4SOItox; + dDenomi_dVd = dDenomi_dVg * 2.0 * dVth_dVd; + dDenomi_dVb = dDenomi_dVg * 2.0 * dVth_dVb + + uc * T4 ; + if (selfheat) + dDenomi_dT = dDenomi_dVg * 2.0 * dVth_dT + + (dua_dT + dub_dT * T3) * T3 * T2 + + T4 * Vbseff * duc_dT; + else + dDenomi_dT = 0.0; + } + + if (T5 >= -0.8) + { Denomi = 1.0 + T5; + } + else /* Added to avoid the discontinuity problem caused by ua and ub*/ + { T9 = 1.0 / (7.0 + 10.0 * T5); + Denomi = (0.6 + T5) * T9; + T9 *= T9; + dDenomi_dVg *= T9; + dDenomi_dVd *= T9; + dDenomi_dVb *= T9; + if (selfheat) dDenomi_dT *= T9; + else dDenomi_dT = 0.0; + } + + here->B4SOIueff = ueff = u0temp / Denomi; + T9 = -ueff / Denomi; + dueff_dVg = T9 * dDenomi_dVg; + dueff_dVd = T9 * dDenomi_dVd; + dueff_dVb = T9 * dDenomi_dVb; + if (selfheat) dueff_dT = T9 * dDenomi_dT + du0temp_dT / Denomi; + else dueff_dT = 0.0; + +/* Saturation Drain Voltage Vdsat */ + WVCox = Weff * vsattemp * model->B4SOIcox; + WVCoxRds = WVCox * Rds; + +/* dWVCoxRds_dT = WVCox * dRds_dT + + Weff * model->B4SOIcox * Rds * dvsattemp_dT; */ + + Esat = 2.0 * vsattemp / ueff; + EsatL = Esat * Leff; + T0 = -EsatL /ueff; + dEsatL_dVg = T0 * dueff_dVg; + dEsatL_dVd = T0 * dueff_dVd; + dEsatL_dVb = T0 * dueff_dVb; + if (selfheat) + dEsatL_dT = T0 * dueff_dT + EsatL / vsattemp * dvsattemp_dT; + else + dEsatL_dT = 0.0; + + /* Sqrt() */ + a1 = pParam->B4SOIa1; + if (a1 == 0.0) + { Lambda = pParam->B4SOIa2; + dLambda_dVg = 0.0; + } + else if (a1 > 0.0) +/* Added to avoid the discontinuity problem caused by a1 and a2 (Lambda) */ + { T0 = 1.0 - pParam->B4SOIa2; + T1 = T0 - pParam->B4SOIa1 * Vgsteff - 0.0001; + T2 = sqrt(T1 * T1 + 0.0004 * T0); + Lambda = pParam->B4SOIa2 + T0 - 0.5 * (T1 + T2); + dLambda_dVg = 0.5 * pParam->B4SOIa1 * (1.0 + T1 / T2); + } + else + { T1 = pParam->B4SOIa2 + pParam->B4SOIa1 * Vgsteff - 0.0001; + T2 = sqrt(T1 * T1 + 0.0004 * pParam->B4SOIa2); + Lambda = 0.5 * (T1 + T2); + dLambda_dVg = 0.5 * pParam->B4SOIa1 * (1.0 + T1 / T2); + } + + here->B4SOIAbovVgst2Vtm = Abulk /Vgst2Vtm; /* v2.2.3 bug fix */ + + if (Rds > 0) + { tmp2 = dRds_dVg / Rds + dWeff_dVg / Weff; + tmp3 = dRds_dVb / Rds + dWeff_dVb / Weff; + } + else + { tmp2 = dWeff_dVg / Weff; + tmp3 = dWeff_dVb / Weff; + } + if ((Rds == 0.0) && (Lambda == 1.0)) + { T0 = 1.0 / (Abulk * EsatL + Vgst2Vtm); + tmp1 = 0.0; + T1 = T0 * T0; + T2 = Vgst2Vtm * T0; + T3 = EsatL * Vgst2Vtm; + Vdsat = T3 * T0; + + dT0_dVg = -(Abulk * dEsatL_dVg + EsatL * dAbulk_dVg + 1.0) * T1; + dT0_dVd = -(Abulk * dEsatL_dVd) * T1; + dT0_dVb = -(Abulk * dEsatL_dVb + EsatL * dAbulk_dVb) * T1; + if (selfheat) + dT0_dT = -(Abulk * dEsatL_dT + dVgst2Vtm_dT) * T1; + else dT0_dT = 0.0; + + dVdsat_dVg = T3 * dT0_dVg + T2 * dEsatL_dVg + EsatL * T0; + dVdsat_dVd = T3 * dT0_dVd + T2 * dEsatL_dVd; + dVdsat_dVb = T3 * dT0_dVb + T2 * dEsatL_dVb; + if (selfheat) + dVdsat_dT = T3 * dT0_dT + T2 * dEsatL_dT + + EsatL * T0 * dVgst2Vtm_dT; + else dVdsat_dT = 0.0; + } + else + { tmp1 = dLambda_dVg / (Lambda * Lambda); + T9 = Abulk * WVCoxRds; + T8 = Abulk * T9; + T7 = Vgst2Vtm * T9; + T6 = Vgst2Vtm * WVCoxRds; + T0 = 2.0 * Abulk * (T9 - 1.0 + 1.0 / Lambda); + dT0_dVg = 2.0 * (T8 * tmp2 - Abulk * tmp1 + + (2.0 * T9 + 1.0 / Lambda - 1.0) * dAbulk_dVg); +/* dT0_dVb = 2.0 * (T8 * tmp3 this is equivalent to one below, but simpler + + (2.0 * T9 + 1.0 / Lambda - 1.0) * dAbulk_dVg); */ + dT0_dVb = 2.0 * (T8 * (2.0 / Abulk * dAbulk_dVb + tmp3) + + (1.0 / Lambda - 1.0) * dAbulk_dVb); + dT0_dVd = 0.0; + + if (selfheat) + { + + if (Rds!=0.0) + tmp4 = dRds_dT / Rds + dvsattemp_dT / vsattemp; + else + tmp4 = dvsattemp_dT / vsattemp; + + dT0_dT = 2.0 * T8 * tmp4; + } else tmp4 = dT0_dT = 0.0; + + T1 = Vgst2Vtm * (2.0 / Lambda - 1.0) + Abulk * EsatL + + 3.0 * T7; + + dT1_dVg = (2.0 / Lambda - 1.0) - 2.0 * Vgst2Vtm * tmp1 + + Abulk * dEsatL_dVg + EsatL * dAbulk_dVg + + 3.0 * (T9 + T7 * tmp2 + T6 * dAbulk_dVg); + dT1_dVb = Abulk * dEsatL_dVb + EsatL * dAbulk_dVb + + 3.0 * (T6 * dAbulk_dVb + T7 * tmp3); + dT1_dVd = Abulk * dEsatL_dVd; + + + if (selfheat) + { + tmp4 += dVgst2Vtm_dT / Vgst2Vtm; + dT1_dT = (2.0 / Lambda - 1.0) * dVgst2Vtm_dT + + Abulk * dEsatL_dT + 3.0 * T7 * tmp4; + } else dT1_dT = 0.0; + + T2 = Vgst2Vtm * (EsatL + 2.0 * T6); + dT2_dVg = EsatL + Vgst2Vtm * dEsatL_dVg + + T6 * (4.0 + 2.0 * Vgst2Vtm * tmp2); + dT2_dVb = Vgst2Vtm * (dEsatL_dVb + 2.0 * T6 * tmp3); + dT2_dVd = Vgst2Vtm * dEsatL_dVd; + if (selfheat) + dT2_dT = Vgst2Vtm * dEsatL_dT + EsatL * dVgst2Vtm_dT + + 2.0 * T6 * (dVgst2Vtm_dT + Vgst2Vtm * tmp4); + else + dT2_dT = 0.0; + + T3 = sqrt(T1 * T1 - 2.0 * T0 * T2); + Vdsat = (T1 - T3) / T0; + + dVdsat_dVg = (dT1_dVg - (T1 * dT1_dVg - dT0_dVg * T2 + - T0 * dT2_dVg) / T3 - Vdsat * dT0_dVg) / T0; + dVdsat_dVb = (dT1_dVb - (T1 * dT1_dVb - dT0_dVb * T2 + - T0 * dT2_dVb) / T3 - Vdsat * dT0_dVb) / T0; + dVdsat_dVd = (dT1_dVd - (T1 * dT1_dVd - T0 * dT2_dVd) / T3) / T0; + if (selfheat) + dVdsat_dT = (dT1_dT - (T1 * dT1_dT - dT0_dT * T2 + - T0 * dT2_dT) / T3 - Vdsat * dT0_dT) / T0; + else dVdsat_dT = 0.0; + } + here->B4SOIvdsat = Vdsat; + + +/* Effective Vds (Vdseff) Calculation */ + T1 = Vdsat - Vds - pParam->B4SOIdelta; + dT1_dVg = dVdsat_dVg; + dT1_dVd = dVdsat_dVd - 1.0; + dT1_dVb = dVdsat_dVb; + dT1_dT = dVdsat_dT; + + T2 = sqrt(T1 * T1 + 4.0 * pParam->B4SOIdelta * Vdsat); + T0 = T1 / T2; + T3 = 2.0 * pParam->B4SOIdelta / T2; + dT2_dVg = T0 * dT1_dVg + T3 * dVdsat_dVg; + dT2_dVd = T0 * dT1_dVd + T3 * dVdsat_dVd; + dT2_dVb = T0 * dT1_dVb + T3 * dVdsat_dVb; + if (selfheat) + dT2_dT = T0 * dT1_dT + T3 * dVdsat_dT; + else dT2_dT = 0.0; + + Vdseff = Vdsat - 0.5 * (T1 + T2); + dVdseff_dVg = dVdsat_dVg - 0.5 * (dT1_dVg + dT2_dVg); + dVdseff_dVd = dVdsat_dVd - 0.5 * (dT1_dVd + dT2_dVd); + dVdseff_dVb = dVdsat_dVb - 0.5 * (dT1_dVb + dT2_dVb); + if (selfheat) + dVdseff_dT = dVdsat_dT - 0.5 * (dT1_dT + dT2_dT); + else dVdseff_dT = 0.0; + + if (Vdseff > Vds) + Vdseff = Vds; /* This code is added to fixed the problem + caused by computer precision when + Vds is very close to Vdseff. */ + diffVds = Vds - Vdseff; + here->B4SOIVdseff = Vdseff; /* v2.2.3 bug fix */ + +/* Calculate VAsat */ + tmp4 = 1.0 - 0.5 * Abulk * Vdsat / Vgst2Vtm; + T9 = WVCoxRds * Vgsteff; + T8 = T9 / Vgst2Vtm; + T0 = EsatL + Vdsat + 2.0 * T9 * tmp4; + + T7 = 2.0 * WVCoxRds * tmp4; + dT0_dVg = dEsatL_dVg + dVdsat_dVg + T7 * (1.0 + tmp2 * Vgsteff) + - T8 * (Abulk * dVdsat_dVg - Abulk * Vdsat / Vgst2Vtm + + Vdsat * dAbulk_dVg); + + dT0_dVb = dEsatL_dVb + dVdsat_dVb + T7 * tmp3 * Vgsteff + - T8 * (dAbulk_dVb * Vdsat + Abulk * dVdsat_dVb); + dT0_dVd = dEsatL_dVd + dVdsat_dVd - T8 * Abulk * dVdsat_dVd; + + if (selfheat) + { + + if (Rds!=0.0) + tmp4 = dRds_dT / Rds + dvsattemp_dT / vsattemp; + else tmp4 = dvsattemp_dT / vsattemp; + + dT0_dT = dEsatL_dT + dVdsat_dT + T7 * tmp4 * Vgsteff + - T8 * (Abulk * dVdsat_dT - Abulk * Vdsat * dVgst2Vtm_dT + / Vgst2Vtm); + } else + dT0_dT = 0.0; + + T9 = WVCoxRds * Abulk; + T1 = 2.0 / Lambda - 1.0 + T9; + dT1_dVg = -2.0 * tmp1 + WVCoxRds * (Abulk * tmp2 + dAbulk_dVg); + dT1_dVb = dAbulk_dVb * WVCoxRds + T9 * tmp3; + if (selfheat) + dT1_dT = T9 * tmp4; + else + dT1_dT = 0.0; + + Vasat = T0 / T1; + dVasat_dVg = (dT0_dVg - Vasat * dT1_dVg) / T1; + dVasat_dVb = (dT0_dVb - Vasat * dT1_dVb) / T1; + dVasat_dVd = dT0_dVd / T1; + if (selfheat) dVasat_dT = (dT0_dT - Vasat * dT1_dT) / T1; + else dVasat_dT = 0.0; + +/* Calculate VACLM */ + if ((pParam->B4SOIpclm > 0.0) && (diffVds > 1.0e-10)) + { T0 = 1.0 / (pParam->B4SOIpclm * Abulk * pParam->B4SOIlitl); + dT0_dVb = -T0 / Abulk * dAbulk_dVb; + dT0_dVg = -T0 / Abulk * dAbulk_dVg; + + T2 = Vgsteff / EsatL; + T1 = Leff * (Abulk + T2); + dT1_dVg = Leff * ((1.0 - T2 * dEsatL_dVg) / EsatL + dAbulk_dVg); + dT1_dVb = Leff * (dAbulk_dVb - T2 * dEsatL_dVb / EsatL); + dT1_dVd = -T2 * dEsatL_dVd / Esat; + if (selfheat) dT1_dT = -T2 * dEsatL_dT / Esat; + else dT1_dT = 0.0; + + T9 = T0 * T1; + VACLM = T9 * diffVds; + dVACLM_dVg = T0 * dT1_dVg * diffVds - T9 * dVdseff_dVg + + T1 * diffVds * dT0_dVg; + dVACLM_dVb = (dT0_dVb * T1 + T0 * dT1_dVb) * diffVds + - T9 * dVdseff_dVb; + dVACLM_dVd = T0 * dT1_dVd * diffVds + T9 * (1.0 - dVdseff_dVd); + if (selfheat) + dVACLM_dT = T0 * dT1_dT * diffVds - T9 * dVdseff_dT; + else dVACLM_dT = 0.0; + + } + else + { VACLM = MAX_EXPL; + dVACLM_dVd = dVACLM_dVg = dVACLM_dVb = dVACLM_dT = 0.0; + } + + +/* Calculate VADIBL */ + if (pParam->B4SOIthetaRout > 0.0) + { T8 = Abulk * Vdsat; + T0 = Vgst2Vtm * T8; + T1 = Vgst2Vtm + T8; + dT0_dVg = Vgst2Vtm * Abulk * dVdsat_dVg + T8 + + Vgst2Vtm * Vdsat * dAbulk_dVg; + dT1_dVg = 1.0 + Abulk * dVdsat_dVg + Vdsat * dAbulk_dVg; + dT1_dVb = dAbulk_dVb * Vdsat + Abulk * dVdsat_dVb; + dT0_dVb = Vgst2Vtm * dT1_dVb; + dT1_dVd = Abulk * dVdsat_dVd; + dT0_dVd = Vgst2Vtm * dT1_dVd; + if (selfheat) + { + dT0_dT = dVgst2Vtm_dT * T8 + Abulk * Vgst2Vtm * dVdsat_dT; + dT1_dT = dVgst2Vtm_dT + Abulk * dVdsat_dT; + } else + dT0_dT = dT1_dT = 0.0; + + T9 = T1 * T1; + T2 = pParam->B4SOIthetaRout; + 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; + if (selfheat) + dVADIBL_dT = (dVgst2Vtm_dT - dT0_dT/T1 + T0*dT1_dT/T9) / T2; + else dVADIBL_dT = 0.0; + + T7 = pParam->B4SOIpdiblb * Vbseff; + if (T7 >= -0.9) + { T3 = 1.0 / (1.0 + T7); + VADIBL *= T3; + dVADIBL_dVg *= T3; + dVADIBL_dVb = (dVADIBL_dVb - VADIBL * pParam->B4SOIpdiblb) + * T3; + dVADIBL_dVd *= T3; + if (selfheat) dVADIBL_dT *= T3; + else dVADIBL_dT = 0.0; + } + else +/* Added to avoid the discontinuity problem caused by pdiblcb */ + { T4 = 1.0 / (0.8 + T7); + T3 = (17.0 + 20.0 * T7) * T4; + dVADIBL_dVg *= T3; + dVADIBL_dVb = dVADIBL_dVb * T3 + - VADIBL * pParam->B4SOIpdiblb * T4 * T4; + dVADIBL_dVd *= T3; + if (selfheat) dVADIBL_dT *= T3; + else dVADIBL_dT = 0.0; + VADIBL *= T3; + } + } + else + { VADIBL = MAX_EXPL; + dVADIBL_dVd = dVADIBL_dVg = dVADIBL_dVb = dVADIBL_dT = 0.0; + } + +/* v4.0 DITS */ + T0 = pParam->B4SOIpditsd * Vds; + if (T0 > EXPL_THRESHOLD) + { T1 = MAX_EXPL; + dT1_dVd = 0; + } + else + { T1 = exp(T0); + dT1_dVd = T1 * pParam->B4SOIpditsd; + } + if (pParam->B4SOIpdits > MIN_EXPL) + { T2 = 1.0 + model->B4SOIpditsl * Leff; + VADITS = (1.0 + T2 * T1) / pParam->B4SOIpdits; + dVADITS_dVg = VADITS * dFP_dVg; + dVADITS_dVd = FP * T2 * dT1_dVd / pParam->B4SOIpdits; + VADITS *= FP; + if (selfheat) dVADITS_dT = VADITS * dFP_dT / FP; + else dVADITS_dT = 0.0; + } + else + { VADITS = MAX_EXPL; + dVADITS_dVg = dVADITS_dVd = dVADITS_dT = 0; + } + +/* Calculate VA */ + + T8 = pParam->B4SOIpvag / EsatL; + T9 = T8 * Vgsteff; + if (T9 > -0.9) + { T0 = 1.0 + T9; + dT0_dVg = T8 * (1.0 - Vgsteff * dEsatL_dVg / EsatL); + dT0_dVb = -T9 * dEsatL_dVb / EsatL; + dT0_dVd = -T9 * dEsatL_dVd / EsatL; + if (selfheat) + dT0_dT = -T9 * dEsatL_dT / EsatL; + else + dT0_dT = 0.0; + } + else /* Added to avoid the discontinuity problems caused by pvag */ + { T1 = 1.0 / (17.0 + 20.0 * T9); + T0 = (0.8 + T9) * T1; + T1 *= T1; + dT0_dVg = T8 * (1.0 - Vgsteff * dEsatL_dVg / EsatL) * T1; + + T9 *= T1 / EsatL; + dT0_dVb = -T9 * dEsatL_dVb; + dT0_dVd = -T9 * dEsatL_dVd; + if (selfheat) + dT0_dT = -T9 * dEsatL_dT; + else + dT0_dT = 0.0; + } + + tmp1 = VACLM * VACLM; + tmp2 = VADIBL * VADIBL; + tmp3 = VACLM + VADIBL; + + T1 = VACLM * VADIBL / tmp3; + tmp3 *= tmp3; + dT1_dVg = (tmp1 * dVADIBL_dVg + tmp2 * dVACLM_dVg) / tmp3; + dT1_dVd = (tmp1 * dVADIBL_dVd + tmp2 * dVACLM_dVd) / tmp3; + dT1_dVb = (tmp1 * dVADIBL_dVb + tmp2 * dVACLM_dVb) / tmp3; + if (selfheat) + dT1_dT = (tmp1 * dVADIBL_dT + tmp2 * dVACLM_dT ) / tmp3; + else dT1_dT = 0.0; + + /* v4.0 adding DITS */ + tmp1 = T1 * T1; + tmp2 = VADITS * VADITS; + tmp3 = T1 + VADITS; + T2 = T1 * VADITS / tmp3; + tmp3 *= tmp3; + dT2_dVg = (tmp1 * dVADITS_dVg + tmp2 * dT1_dVg) / tmp3; + dT2_dVd = (tmp1 * dVADITS_dVd + tmp2 * dT1_dVd) / tmp3; + dT2_dVb = ( tmp2 * dT1_dVb) / tmp3; + if (selfheat) + dT2_dT = (tmp1 * dVADITS_dT + tmp2 * dT1_dT ) / tmp3; + else dT2_dT = 0.0; + +/* + Va = Vasat + T0 * T1; + dVa_dVg = dVasat_dVg + T1 * dT0_dVg + T0 * dT1_dVg; + dVa_dVd = dVasat_dVd + T1 * dT0_dVd + T0 * dT1_dVd; + dVa_dVb = dVasat_dVb + T1 * dT0_dVb + T0 * dT1_dVb; + if (selfheat) + dVa_dT = dVasat_dT + T1 * dT0_dT + T0 * dT1_dT; + else dVa_dT = 0.0; +*/ +/* v4.0 */ + Va = Vasat + T0 * T2; + dVa_dVg = dVasat_dVg + T2 * dT0_dVg + T0 * dT2_dVg; + dVa_dVd = dVasat_dVd + T2 * dT0_dVd + T0 * dT2_dVd; + dVa_dVb = dVasat_dVb + T2 * dT0_dVb + T0 * dT2_dVb; + if (selfheat) + dVa_dT = dVasat_dT + T2 * dT0_dT + T0 * dT2_dT; + else dVa_dT = 0.0; + +/* Calculate Ids */ + CoxWovL = model->B4SOIcox * Weff / Leff; + beta = ueff * CoxWovL; + dbeta_dVg = CoxWovL * dueff_dVg + beta * dWeff_dVg / Weff ; + dbeta_dVd = CoxWovL * dueff_dVd; + dbeta_dVb = CoxWovL * dueff_dVb + beta * dWeff_dVb / Weff ; + if (selfheat) dbeta_dT = CoxWovL * dueff_dT; + else dbeta_dT = 0.0; + + T0 = 1.0 - 0.5 * Abulk * Vdseff / Vgst2Vtm; + dT0_dVg = -0.5 * (Abulk * dVdseff_dVg + - Abulk * Vdseff / Vgst2Vtm + Vdseff * dAbulk_dVg) / Vgst2Vtm; + dT0_dVd = -0.5 * Abulk * dVdseff_dVd / Vgst2Vtm; + dT0_dVb = -0.5 * (Abulk * dVdseff_dVb + dAbulk_dVb * Vdseff) + / Vgst2Vtm; + if (selfheat) + dT0_dT = -0.5 * (Abulk * dVdseff_dT + - Abulk * Vdseff / Vgst2Vtm * dVgst2Vtm_dT) + / Vgst2Vtm; + else dT0_dT = 0.0; + + fgche1 = Vgsteff * T0; + dfgche1_dVg = Vgsteff * dT0_dVg + T0; + dfgche1_dVd = Vgsteff * dT0_dVd; + dfgche1_dVb = Vgsteff * dT0_dVb; + if (selfheat) dfgche1_dT = Vgsteff * dT0_dT; + else dfgche1_dT = 0.0; + + T9 = Vdseff / EsatL; + fgche2 = 1.0 + T9; + dfgche2_dVg = (dVdseff_dVg - T9 * dEsatL_dVg) / EsatL; + dfgche2_dVd = (dVdseff_dVd - T9 * dEsatL_dVd) / EsatL; + dfgche2_dVb = (dVdseff_dVb - T9 * dEsatL_dVb) / EsatL; + if (selfheat) dfgche2_dT = (dVdseff_dT - T9 * dEsatL_dT) / EsatL; + else dfgche2_dT = 0.0; + + gche = beta * fgche1 / fgche2; + dgche_dVg = (beta * dfgche1_dVg + fgche1 * dbeta_dVg + - gche * dfgche2_dVg) / fgche2; + dgche_dVd = (beta * dfgche1_dVd + fgche1 * dbeta_dVd + - gche * dfgche2_dVd) / fgche2; + dgche_dVb = (beta * dfgche1_dVb + fgche1 * dbeta_dVb + - gche * dfgche2_dVb) / fgche2; + if (selfheat) + dgche_dT = (beta * dfgche1_dT + fgche1 * dbeta_dT + - gche * dfgche2_dT) / fgche2; + else dgche_dT = 0.0; + + T0 = 1.0 + gche * Rds; + T9 = Vdseff / T0; + Idl = gche * T9; + IdlovVdseff = gche / T0; + +/* Whoa, these formulas for the derivatives of Idl are convoluted, but I + verified them to be correct */ + + dIdl_dVg = (gche * dVdseff_dVg + T9 * dgche_dVg) / T0 + - Idl * gche / T0 * dRds_dVg ; + dIdl_dVd = (gche * dVdseff_dVd + T9 * dgche_dVd) / T0; + dIdl_dVb = (gche * dVdseff_dVb + T9 * dgche_dVb + - Idl * dRds_dVb * gche) / T0; + if (selfheat) + dIdl_dT = (gche * dVdseff_dT + T9 * dgche_dT + - Idl * dRds_dT * gche) / T0; + else dIdl_dT = 0.0; + + T9 = diffVds / Va; + T0 = 1.0 + T9; + here->B4SOIids = Ids = Idl * T0 / here->B4SOInseg; + + here->B4SOIidovVds = IdlovVdseff * T0 / here->B4SOInseg; + /* v4.0 bug fix */ + IdovVds = IdlovVdseff * T0 / here->B4SOInseg; /* v4.0 */ + + Gm0 = T0 * dIdl_dVg - Idl * (dVdseff_dVg + T9 * dVa_dVg) / Va; + Gds0 = T0 * dIdl_dVd + Idl * (1.0 - dVdseff_dVd + - T9 * dVa_dVd) / Va; + Gmb0 = T0 * dIdl_dVb - Idl * (dVdseff_dVb + T9 * dVa_dVb) / Va; + Gmc = 0.0; + + if (selfheat) + GmT0 = T0 * dIdl_dT - Idl * (dVdseff_dT + T9 * dVa_dT) / Va; + else GmT0 = 0.0; + +/* This includes all dependencies from Vgsteff, Vbseff */ + + Gm = (Gm0 * dVgsteff_dVg+ Gmb0 * dVbseff_dVg) / here->B4SOInseg; /* v3.0 */ + Gmb = (Gm0 * dVgsteff_dVb + Gmb0 * dVbseff_dVb) / here->B4SOInseg; + Gds = (Gm0 * dVgsteff_dVd+ Gmb0 * dVbseff_dVd + Gds0) / here->B4SOInseg; /* v3.0 */ + Gme = (Gm0 * dVgsteff_dVe + Gmb0 * dVbseff_dVe) / here->B4SOInseg; /* v3.0 */ + if (selfheat) + GmT = (Gm0 * dVgsteff_dT + Gmb0 * dVbseff_dT + GmT0) / here->B4SOInseg; /* v3.0 */ + else GmT = 0.0; + + +/* v3.1 */ + if (here->B4SOIsoiMod != 2) /* v3.2 */ + { + /* calculate GIDL current */ + T0 = 3 * model->B4SOItox; + /* For drain side */ + T1 = (Vds - Vgs_eff - pParam->B4SOIegidl) / T0; + if ((pParam->B4SOIagidl <= 0.0) || + (pParam->B4SOIbgidl <= 0.0) || (T1 <= 0.0) || + (pParam->B4SOIcgidl < 0.0) || (Vbd > 0.0) ) + Igidl = Ggidld = Ggidlg = Ggidlb = 0.0; + + else { + dT1_dVd = 1 / T0; + dT1_dVg = - dT1_dVd * dVgs_eff_dVg; + T2 = pParam->B4SOIbgidl / T1; + if (T2 < EXPL_THRESHOLD) + { + Igidl = wdiod * pParam->B4SOIagidl * T1 * exp(-T2); + T3 = Igidl / T1 * (T2 + 1); + Ggidld = T3 * dT1_dVd; + Ggidlg = T3 * dT1_dVg; + } else + { + T3 = wdiod * pParam->B4SOIagidl * MIN_EXPL; + Igidl = T3 * T1 ; + Ggidld = T3 * dT1_dVd; + Ggidlg = T3 * dT1_dVg; + } + if(pParam->B4SOIcgidl >= MIN_EXPL) { + T4 = Vbd * Vbd; + T5 = -Vbd * T4; + T6 = pParam->B4SOIcgidl + T5; + T7 = T5 / T6; + T8 = 3.0 * pParam->B4SOIcgidl * T4 / T6 / T6; + Ggidld = Ggidld * T7 + Igidl * T8; + Ggidlg = Ggidlg * T7; + Ggidlb = -Igidl * T8; + Igidl *= T7; + } else + Ggidlb = 0.0; + } + here->B4SOIigidl = Igidl; + + /* calculate diode and BJT current */ + WsTsi = wdios * model->B4SOItsi; + WdTsi = wdiod * model->B4SOItsi; + + NVtm1 = Vtm * pParam->B4SOIndiode; + if (selfheat) + dNVtm1_dT = pParam->B4SOIndiode * dVtm_dT; + else + dNVtm1_dT = 0; + + T0 = vbs_jct / NVtm1; /* v4.0 */ + dT0_dVb = 1.0 / NVtm1; + if (selfheat) + dT0_dT = -vbs_jct / NVtm1 / NVtm1 * dNVtm1_dT; + else + dT0_dT = 0; + DEXP(T0, ExpVbsNVtm, T1); + dExpVbsNVtm_dVb = T1 * dT0_dVb; + if (selfheat) + dExpVbsNVtm_dT = T1 * dT0_dT; + else + dExpVbsNVtm_dT = 0; + + NVtm1 = Vtm * pParam->B4SOIndioded; /* v4.0 drain side */ + if (selfheat) + dNVtm1_dT = pParam->B4SOIndioded* dVtm_dT; + else + dNVtm1_dT = 0; + T0 = vbd_jct / NVtm1; /* v4.0 */ + + dT0_dVb = 1.0 / NVtm1; + dT0_dVd = -dT0_dVb; + if (selfheat) + dT0_dT = -vbd_jct / NVtm1 / NVtm1 * dNVtm1_dT; + else + dT0_dT = 0; + DEXP(T0, ExpVbdNVtm, T1); + dExpVbdNVtm_dVb = T1 * dT0_dVb; + dExpVbdNVtm_dVd = -dExpVbdNVtm_dVb; + if (selfheat) + dExpVbdNVtm_dT = T1 * dT0_dT; + else + dExpVbdNVtm_dT = 0; + + /* Ibs1: diffusion current */ + if (jdifs == 0) { + Ibs1 = dIbs1_dVb = dIbs1_dT = 0; + } + else { + T0 = WsTsi * jdifs; + if (selfheat) + dT0_dT = WsTsi * djdifs_dT; + else + dT0_dT = 0; + Ibs1 = T0 * (ExpVbsNVtm - 1); + dIbs1_dVb = T0 * dExpVbsNVtm_dVb; + if (selfheat) + dIbs1_dT = T0 * dExpVbsNVtm_dT + (ExpVbsNVtm - 1) * dT0_dT; + else + dIbs1_dT = 0; + } + + /* Ibd1: diffusion current */ + if (jdifd == 0) { + Ibd1 = dIbd1_dVb = dIbd1_dVd = dIbd1_dT = 0; + } + else { + T0 = WdTsi * jdifd; + + if (selfheat) + dT0_dT = WdTsi * djdifd_dT; + else + dT0_dT = 0; + Ibd1 = T0 * (ExpVbdNVtm - 1); + dIbd1_dVb = T0 * dExpVbdNVtm_dVb; + dIbd1_dVd = -dIbd1_dVb; + if (selfheat) + dIbd1_dT = T0 * dExpVbdNVtm_dT + (ExpVbdNVtm -1) + * dT0_dT; + else + dIbd1_dT = 0; + } + + + /* Ibs2:recombination/trap-assisted tunneling current */ + + if (jrecs == 0) { + Ibs2 = dIbs2_dVb = dIbs2_dT = 0; + } + else { + /* forward bias */ + NVtmf = 0.026 * pParam->B4SOInrecf0 + * (1 + pParam->B4SOIntrecf * (TempRatio - 1)); + NVtmr = 0.026 * pParam->B4SOInrecr0 + * (1 + pParam->B4SOIntrecr * (TempRatio - 1)); + if (selfheat) { + dNVtmf_dT = pParam->B4SOInrecf0 * 0.026 + * pParam->B4SOIntrecf * dTempRatio_dT; + dNVtmr_dT = pParam->B4SOInrecr0 * 0.026 + * pParam->B4SOIntrecr * dTempRatio_dT; + } + else + dNVtmf_dT = dNVtmr_dT = 0; + + T0 = vbs_jct / NVtmf; /* v4.0 */ + DEXP(T0,T10,T2); + T4 = 1 / NVtmf; + dT10_dVb = T4 * T2; + if (selfheat) + dT10_dT = - T4 * T2 * vbs_jct / NVtmf * dNVtmf_dT ; + else dT10_dT = 0.0; + + /* reverse bias */ + if ((pParam->B4SOIvrec0 - vbs_jct) < 1e-3) { + + /* v2.2.3 bug fix */ + T1 = 1e3; + T0 = -vbs_jct / NVtmr * pParam->B4SOIvrec0 * T1; + T11 = -exp(T0); + + dT11_dVb = dT11_dT = 0; + } + else { + T1 = 1 / (pParam->B4SOIvrec0 - vbs_jct); + T0 = -vbs_jct / NVtmr * pParam->B4SOIvrec0 * T1; + dT0_dVb = -pParam->B4SOIvrec0 / NVtmr * + (T1 + vbs_jct * T1 * T1) ; + if (selfheat) + dT0_dT = -T0 / NVtmr * dNVtmr_dT; + else dT0_dT = 0; + + DEXP(T0, T11, T2); + T11 = -T11; + dT11_dVb = -T2 * dT0_dVb; + if (selfheat) + dT11_dT = -T2 * dT0_dT; + else dT11_dT = 0; + } + T3 = WsTsi * jrecs; + Ibs2 = T3 * (T10 + T11); + dIbs2_dVb = T3 * (dT10_dVb + dT11_dVb); + if (selfheat) + dIbs2_dT = T3 * (dT10_dT + dT11_dT) + + WsTsi * (T10 + T11) * djrecs_dT; + else dIbs2_dT = 0; + + } + + if (jrecd == 0) { + Ibd2 = dIbd2_dVb = dIbd2_dVd = dIbd2_dT = 0; + } + else { + NVtmf = 0.026 * pParam->B4SOInrecf0d + * (1 + pParam->B4SOIntrecf * (TempRatio - 1)); + NVtmr = 0.026 * pParam->B4SOInrecr0d + * (1 + pParam->B4SOIntrecr * (TempRatio - 1)); + if (selfheat) { + dNVtmf_dT = pParam->B4SOInrecf0d * 0.026 + * pParam->B4SOIntrecf * dTempRatio_dT; + dNVtmr_dT = pParam->B4SOInrecr0d * 0.026 + * pParam->B4SOIntrecr * dTempRatio_dT; + } + else + dNVtmf_dT = dNVtmr_dT = 0; + + T0 = vbd_jct / NVtmf; + DEXP(T0,T10,T2); + T4 = 1 / NVtmf; + dT10_dVb = T4 * T2; + if (selfheat) + dT10_dT = - T4 * T2 * vbd_jct / NVtmf * dNVtmf_dT ; + else dT10_dT = 0.0; + + if ((pParam->B4SOIvrec0d - vbd_jct) < 1e-3) { + + /* v2.2.3 bug fix */ + T1 = 1e3; + T0 = -vbd_jct / NVtmr * pParam->B4SOIvrec0d * T1; + T11 = -exp(T0); + + dT11_dVb = dT11_dT = 0; + } + else { + T1 = 1 / (pParam->B4SOIvrec0d - vbd_jct); + T0 = -vbd_jct / NVtmr * pParam->B4SOIvrec0d * T1; + dT0_dVb = -pParam->B4SOIvrec0d / NVtmr + * (T1 + vbd_jct * T1 * T1) ; + if (selfheat) + dT0_dT = -T0 / NVtmr * dNVtmr_dT; + else + dT0_dT = 0; + DEXP(T0, T11, T2); + T11 = - T11; + dT11_dVb = -T2 * dT0_dVb; + if (selfheat) + dT11_dT = -T2 * dT0_dT; + else + dT11_dT = 0; + } + T3 = WdTsi * jrecd; + Ibd2 = T3 * (T10 + T11); + dIbd2_dVb = T3 * (dT10_dVb + dT11_dVb); + dIbd2_dVd = -dIbd2_dVb; + if (selfheat) + dIbd2_dT = T3 * (dT10_dT + dT11_dT) + + WdTsi * (T10 + T11) * djrecd_dT; + else + dIbd2_dT = 0; + } + + /* Ibs3/Ibd3: recombination current in neutral body */ + WTsi = pParam->B4SOIweff / here->B4SOInseg * model->B4SOItsi; + if (jbjts == 0.0 && jbjtd == 0.0) + { + Ibs3 = dIbs3_dVb = dIbs3_dVd = dIbs3_dT = 0.0; + Ibd3 = dIbd3_dVb = dIbd3_dVd = dIbd3_dT = 0.0; + Ibsdif = dIbsdif_dVb = dIbsdif_dT = 0; + Ibddif = dIbddif_dVb = dIbddif_dVd = dIbddif_dT = 0; + here->B4SOIic = Ic = Gcd = Gcb = GcT = 0.0; + } + else { + Ien = WTsi * jbjts * pParam->B4SOIlratio; + if (selfheat) + dIen_dT = WTsi * djbjts_dT * pParam->B4SOIlratio; + else + dIen_dT = 0; + + /* high level injection of source side */ + if ((Ehlis = Ahlis * (ExpVbsNVtm - 1)) < 1e-5) { + Ehlis = dEhlis_dVb = dEhlis_dT = 0; + EhlisFactor = 1; + dEhlisFactor_dVb = dEhlisFactor_dT = 0; + } + else { + dEhlis_dVb = Ahlis * dExpVbsNVtm_dVb; + if (selfheat) + dEhlis_dT = Ahlis * dExpVbsNVtm_dT + (ExpVbsNVtm - 1) * dAhlis_dT; + else + dEhlis_dT = 0; + EhlisFactor = 1.0 / sqrt(1 + Ehlis); + T0 = -0.5 * EhlisFactor / (1 + Ehlis); + dEhlisFactor_dVb = T0 * dEhlis_dVb; + if (selfheat) + dEhlisFactor_dT = T0 * dEhlis_dT; + else + dEhlisFactor_dT = 0; + } + + /* high level injection of drain side */ + if ((Ehlid = Ahlid * (ExpVbdNVtm - 1)) < 1e-5) { + Ehlid = dEhlid_dVb = dEhlid_dVd = dEhlid_dT = 0; + EhlidFactor = 1; + dEhlidFactor_dVb = dEhlidFactor_dVd = dEhlidFactor_dT = 0; + } + else { + dEhlid_dVb = Ahlid * dExpVbdNVtm_dVb; + dEhlid_dVd = -dEhlid_dVb; + if (selfheat) + dEhlid_dT = Ahlid * dExpVbdNVtm_dT + (ExpVbdNVtm - 1) * dAhlid_dT; + else + dEhlid_dT = 0; + EhlidFactor = 1.0 / sqrt(1 + Ehlid); + T0 = -0.5 * EhlidFactor / (1 + Ehlid); + dEhlidFactor_dVb = T0 * dEhlid_dVb; + dEhlidFactor_dVd = -dEhlidFactor_dVb; + if (selfheat) + dEhlidFactor_dT = T0 * dEhlid_dT; + else + dEhlidFactor_dT = 0; + } + + +/* v3.1.1 bug fix for Ibjt(L) discontinuity */ + T0 = 1 - pParam->B4SOIarfabjt; + T1 = T0 * Ien; + if (selfheat) + dT1_dT = T0 * dIen_dT; + else + dT1_dT = 0; + + Ibs3 = T1 * (ExpVbsNVtm - 1) * EhlisFactor; + dIbs3_dVb = T1 * (dExpVbsNVtm_dVb * EhlisFactor + + (ExpVbsNVtm - 1) * dEhlisFactor_dVb); + dIbs3_dVd = 0; + if (selfheat) + dIbs3_dT = dT1_dT * (ExpVbsNVtm - 1) * EhlisFactor + + T1 * (dExpVbsNVtm_dT * EhlisFactor + + (ExpVbsNVtm - 1) * dEhlisFactor_dT); + else + dIbs3_dT = 0.0; + + Ien = WTsi * jbjtd * pParam->B4SOIlratio; + if (selfheat) + dIen_dT = WTsi * djbjtd_dT * pParam->B4SOIlratio; + else + dIen_dT = 0; + + T1 = T0 * Ien; + if (selfheat) + dT1_dT = T0 * dIen_dT; + else + dT1_dT = 0; + + Ibd3 = T1 * (ExpVbdNVtm - 1) * EhlidFactor; + dIbd3_dVb = T1 * (dExpVbdNVtm_dVb * EhlidFactor + + (ExpVbdNVtm - 1) * dEhlidFactor_dVb); + dIbd3_dVd = -dIbd3_dVb; + if (selfheat) + dIbd3_dT = dT1_dT * (ExpVbdNVtm - 1) * EhlidFactor + + T1 * (dExpVbdNVtm_dT * EhlidFactor + + (ExpVbdNVtm - 1) * dEhlidFactor_dT); + else + dIbd3_dT = 0.0; + + + /* effective diffusion current for capacitance calcu. */ + Iendif = WTsi * jbjts * pParam->B4SOIlratiodif; + if (selfheat) + dIendif_dT = WTsi * djbjts_dT * pParam->B4SOIlratiodif; + else + dIendif_dT = 0; + + Ibsdif = Iendif * (ExpVbsNVtm - 1) * EhlisFactor; + dIbsdif_dVb = Iendif * (dExpVbsNVtm_dVb * EhlisFactor + + (ExpVbsNVtm - 1) * dEhlisFactor_dVb); + if (selfheat) + dIbsdif_dT = dIendif_dT * (ExpVbsNVtm - 1) * EhlisFactor + + Iendif * (dExpVbsNVtm_dT * EhlisFactor + + (ExpVbsNVtm - 1) * dEhlisFactor_dT); + else + dIbsdif_dT = 0; + + Iendif = WTsi * jbjtd * pParam->B4SOIlratiodif; + if (selfheat) + dIendif_dT = WTsi * djbjtd_dT * pParam->B4SOIlratiodif; + else + dIendif_dT = 0; + + Ibddif = Iendif * (ExpVbdNVtm - 1) * EhlidFactor; + dIbddif_dVb = Iendif * (dExpVbdNVtm_dVb * EhlidFactor + + (ExpVbdNVtm - 1) * dEhlidFactor_dVb); + dIbddif_dVd = -dIbddif_dVb; + if (selfheat) + dIbddif_dT = dIendif_dT * (ExpVbdNVtm - 1) * EhlidFactor + + Iendif * (dExpVbdNVtm_dT * EhlidFactor + + (ExpVbdNVtm - 1) * dEhlidFactor_dT); + else + dIbddif_dT = 0; + + /* Ic: Bjt collector current */ + if ((here->B4SOIbjtoff == 1) || (Vds == 0.0)) { + here->B4SOIic = Ic = Gcd = Gcb = GcT = 0.0; + } + else { + /* second order effects */ + T0 = 1 + (Vbs + Vbd) / pParam->B4SOIvearly; + dT0_dVb = 2.0 / pParam->B4SOIvearly; + dT0_dVd = -1.0 / pParam->B4SOIvearly; + + T1 = Ehlis + Ehlid; + dT1_dVb = dEhlis_dVb + dEhlid_dVb; + dT1_dVd = dEhlid_dVd; + if (selfheat) + dT1_dT = dEhlis_dT + dEhlid_dT; + else + dT1_dT = 0; + + T3 = sqrt(T0 * T0 + 4 * T1); + dT3_dVb = 0.5 / T3 * (2 * T0 * dT0_dVb + 4 * dT1_dVb); + dT3_dVd = 0.5 / T3 * (2 * T0 * dT0_dVd + 4 * dT1_dVd); + if (selfheat) + dT3_dT = 2 * dT1_dT / T3; + else + dT3_dT = 0; + + T2 = (T0 + T3) / 2.0; + dT2_dVb = (dT0_dVb + dT3_dVb) / 2.0; + dT2_dVd = (dT0_dVd + dT3_dVd) / 2.0; + if (selfheat) + dT2_dT = dT3_dT /2.0; + else + dT2_dT = 0; + + if (T2 < .1) + { + E2ndFactor = 10.0; + dE2ndFactor_dVb = dE2ndFactor_dVd = dE2ndFactor_dT = 0; + } + + else { + E2ndFactor = 1.0 / T2; + dE2ndFactor_dVb = -E2ndFactor / T2 * dT2_dVb; + dE2ndFactor_dVd = -E2ndFactor / T2 * dT2_dVd; + if (selfheat) + dE2ndFactor_dT = -E2ndFactor / T2 * dT2_dT; + else + dE2ndFactor_dT = 0; + } + + T0 = pParam->B4SOIarfabjt * Ien; /* here Ien refers to the drain side to simplify the code */ + if (selfheat) + dT0_dT = pParam->B4SOIarfabjt * dIen_dT; + else + dT0_dT = 0; + here->B4SOIic = Ic + = T0 * (ExpVbsNVtm - ExpVbdNVtm) * E2ndFactor; + Gcb = dIc_dVb + = T0 * ((dExpVbsNVtm_dVb - dExpVbdNVtm_dVb) * E2ndFactor + + (ExpVbsNVtm - ExpVbdNVtm) * dE2ndFactor_dVb); + Gcd = dIc_dVd + = T0 * (-dExpVbdNVtm_dVd * E2ndFactor + + (ExpVbsNVtm - ExpVbdNVtm) * dE2ndFactor_dVd); + if (selfheat) + GcT = T0 * (dExpVbsNVtm_dT - dExpVbdNVtm_dT) * E2ndFactor + + dT0_dT * (ExpVbsNVtm - ExpVbdNVtm) * E2ndFactor + + T0 * (ExpVbsNVtm - ExpVbdNVtm) * dE2ndFactor_dT; + else + GcT = 0; + } + } + + /* Ibs4/Ibd4 : tunneling */ + if (jtuns == 0 && jtund == 0) + { Ibs4 = Ibd4 = dIbs4_dVb = dIbs4_dT = dIbd4_dVb = dIbd4_dVd = dIbd4_dT = 0; + } else + { + NVtm2 = 0.026 * pParam->B4SOIntun; + if ((pParam->B4SOIvtun0 - vbs_jct) < 1e-3) + { + /* v2.2.3 bug fix */ + T1=1e3; + T0 = -vbs_jct / NVtm2 * pParam->B4SOIvtun0 * T1; + T1 = exp(T0); + T3 = WsTsi * jtuns; + Ibs4 = T3 * (1- T1); + + dIbs4_dVb = dIbs4_dT = 0; + } + else { + T1 = 1 / (pParam->B4SOIvtun0 - vbs_jct); + T0 = -vbs_jct / NVtm2 * pParam->B4SOIvtun0 * T1; + dT0_dVb = -pParam->B4SOIvtun0 / NVtm2 * (T1 + vbs_jct * T1 * T1) ; + + DEXP(T0, T1, T2); + T3 = WsTsi * jtuns; + Ibs4 = T3 * (1- T1); + dIbs4_dVb = -T3 * T2 * dT0_dVb; + if (selfheat) + dIbs4_dT = (1 - T1) * WsTsi * djtuns_dT; + else dIbs4_dT = 0; + } + + NVtm2 = 0.026 * pParam->B4SOIntund; + if ((pParam->B4SOIvtun0d - vbd_jct) < 1e-3) { + + /* v2.2.3 bug fix */ + T1=1e3; + T0 = -vbd_jct / NVtm2 * pParam->B4SOIvtun0d * T1; + T1 = exp(T0); + T3 = WdTsi * jtund; + Ibd4 = T3 * (1- T1); + + dIbd4_dVb = dIbd4_dT = 0; + dIbd4_dVd = 0; + + } + else { + T1 = 1 / (pParam->B4SOIvtun0d - vbd_jct); + T0 = -vbd_jct / NVtm2 * pParam->B4SOIvtun0d * T1; + dT0_dVb = -pParam->B4SOIvtun0d / NVtm2 * (T1 + vbd_jct * T1 * T1) ; + + DEXP(T0, T1, T2); + T3 = WdTsi * jtund; + Ibd4 = T3 * (1- T1); + dIbd4_dVb = -T3 * T2 * dT0_dVb; + + dIbd4_dVd = -dIbd4_dVb; + + if (selfheat) + dIbd4_dT = (1 - T1) * WdTsi * djtund_dT; + else dIbd4_dT = 0; + } + } + + here->B4SOIitun = - Ibd3 - Ibd4; + here->B4SOIibs = Ibs = Ibs1 + Ibs2 + Ibs3 + Ibs4; + here->B4SOIibd = Ibd = Ibd1 + Ibd2 + Ibd3 + Ibd4; + + Gjsb = dIbs1_dVb + dIbs2_dVb + dIbs3_dVb + dIbs4_dVb; + Gjsd = dIbs3_dVd; + if (selfheat) GjsT = dIbs1_dT + dIbs2_dT + dIbs3_dT + dIbs4_dT; + else GjsT = 0.0; + + Gjdb = dIbd1_dVb + dIbd2_dVb + dIbd3_dVb + dIbd4_dVb; + Gjdd = dIbd1_dVd + dIbd2_dVd + dIbd3_dVd + dIbd4_dVd; + if (selfheat) GjdT = dIbd1_dT + dIbd2_dT + dIbd3_dT + dIbd4_dT; + else GjdT = 0.0; + } + else /* v3.1 soiMod=2: ideal FD */ + { + here->B4SOIigidl= Igidl + = Ggidld = Ggidlg = Ggidlb = 0.0; + + here->B4SOIitun = 0; + here->B4SOIibs = Ibs = 0; + here->B4SOIibd = Ibd = 0; + here->B4SOIic = Ic = Gcd = Gcb = GcT = 0.0; + + Gjsb = 0; + Gjsd = 0; + GjsT = 0; + + Gjdb = 0; + Gjdd = 0; + GjdT = 0; + } + +/* v3.0: gate-tunneling */ + if ((model->B4SOIigbMod != 0) || (model->B4SOIigcMod != 0)) { + Vgb = Vgs_eff - Vbs; + dVgb_dVg = dVgs_eff_dVg; + dVgb_dVb = -1; + + /* Calculate Vox first */ + Vfb = model->B4SOItype * here->B4SOIvth0 /* v4.0 */ + - phi - pParam->B4SOIk1eff * sqrtPhi; + + T3 = Vfb - Vgs_eff + Vbs - DELTA_3; + dT3_dVg = -dVgs_eff_dVg; + dT3_dVd = 0; + dT3_dVb = 1; + + if (Vfb <= 0.0) { + T0 = sqrt(T3 * T3 - 4.0 * DELTA_3 * Vfb); + dT0_dVg = 1.0/(2.0 * T0) * 2.0*T3 * dT3_dVg; + dT0_dVb = 0.5*(1.0/T0) * 2.0*T3 * dT3_dVb; + } + else { + T0 = sqrt(T3 * T3 + 4.0 * DELTA_3 * Vfb); + dT0_dVg = 1.0/(2.0 * T0) * 2.0*T3 * dT3_dVg; + dT0_dVb = 0.5*(1.0/T0) * 2.0*T3 * dT3_dVb; + } + + Vfbeff = Vfb - 0.5 * (T3 + T0); + dVfbeff_dVg = -0.5 * (dT3_dVg + dT0_dVg); + dVfbeff_dVb = -0.5 * (dT3_dVb + dT0_dVb); + + Voxacc = Vfb - Vfbeff; + dVoxacc_dVg = -dVfbeff_dVg; + dVoxacc_dVd = 0.0; + dVoxacc_dVb = -dVfbeff_dVb; + if (Voxacc < 0.0) + Voxacc = dVoxacc_dVg = dVoxacc_dVb = 0.0; + + T0 = Vgs_eff - Vgsteff - Vfbeff - Vbseff; + dT0_dVg = dVgs_eff_dVg - dVgsteff_dVg - dVfbeff_dVg - dVbseff_dVg; /* v3.0 */ + dT0_dVd = -dVgsteff_dVd - dVbseff_dVd; /* v3.0 */ + dT0_dVb = -dVgsteff_dVb - dVfbeff_dVb - dVbseff_dVb; + dT0_dVe = -dVgsteff_dVe - dVbseff_dVe; + + if (selfheat) + dT0_dT = -dVgsteff_dT - dVbseff_dT; /* v3.0 */ + + if (pParam->B4SOIk1ox == 0.0) /* v4.0 */ { + Voxdepinv = dVoxdepinv_dVg = dVoxdepinv_dVd = dVoxdepinv_dVb + = dVoxdepinv_dT = 0.0; + } else { + if (T0 < 0.0) { + T1 = T0/pParam->B4SOIk1ox; + dT1_dVg = dT0_dVg/pParam->B4SOIk1ox; + dT1_dVd = dT0_dVd/pParam->B4SOIk1ox; + dT1_dVb = dT0_dVb/pParam->B4SOIk1ox; + dT1_dVe = dT0_dVe/pParam->B4SOIk1ox; /* v3.0 */ + if (selfheat) dT1_dT = dT0_dT/pParam->B4SOIk1ox; + } + else { + T1 = pParam->B4SOIk1ox/2*(-1 + sqrt(1 + + 4*T0/pParam->B4SOIk1ox/pParam->B4SOIk1ox)); + T2 = pParam->B4SOIk1ox/2 * + 0.5/sqrt(1 + 4*T0/pParam->B4SOIk1ox/pParam->B4SOIk1ox) * + 4/pParam->B4SOIk1ox/pParam->B4SOIk1ox; + dT1_dVg = T2 * dT0_dVg; + dT1_dVd = T2 * dT0_dVd; + dT1_dVb = T2 * dT0_dVb; + dT1_dVe = T2 * dT0_dVe; /* v3.0 */ + if (selfheat) + dT1_dT = T2 * dT0_dT; + } + + Voxdepinv = Vgs_eff - (T1*T1 + Vbs) - Vfb; + dVoxdepinv_dVg = dVgs_eff_dVg - (2.0*T1*dT1_dVg); + dVoxdepinv_dVd = -(2.0*T1*dT1_dVd); + dVoxdepinv_dVb = -(2.0*T1*dT1_dVb + 1); + dVoxdepinv_dVe = -(2.0*T1*dT1_dVe); /* v3.0 */ + if (selfheat) + dVoxdepinv_dT = -(2.0*T1*dT1_dT); + } + } + + + /* gate-channel tunneling component */ + if (model->B4SOIigcMod) + { T0 = Vtm * pParam->B4SOInigc; + VxNVt = (Vgs_eff - model->B4SOItype * here->B4SOIvth0) + / T0; /* Vth instead of Vth0 may be used */ + if (VxNVt > EXPL_THRESHOLD) + { Vaux = Vgs_eff - model->B4SOItype * here->B4SOIvth0; + dVaux_dVg = dVgs_eff_dVg; + dVaux_dVd = 0.0; + dVaux_dVb = 0.0; + } + else if (VxNVt < -EXPL_THRESHOLD) + { Vaux = T0 * log(1.0 + MIN_EXPL); + dVaux_dVg = dVaux_dVd = dVaux_dVb = 0.0; + } + else + { ExpVxNVt = exp(VxNVt); + Vaux = T0 * log(1.0 + ExpVxNVt); + dVaux_dVg = ExpVxNVt / (1.0 + ExpVxNVt); + dVaux_dVd = -dVaux_dVg * 0.0; + dVaux_dVb = -dVaux_dVg * 0.0; + dVaux_dVg *= dVgs_eff_dVg; + } + + T2 = Vgs_eff * Vaux; + dT2_dVg = dVgs_eff_dVg * Vaux + Vgs_eff * dVaux_dVg; + dT2_dVd = Vgs_eff * dVaux_dVd; + dT2_dVb = Vgs_eff * dVaux_dVb; + + T11 = pParam->B4SOIAechvb; + T12 = pParam->B4SOIBechvb; + T3 = pParam->B4SOIaigc * pParam->B4SOIcigc + - pParam->B4SOIbigc; + T4 = pParam->B4SOIbigc * pParam->B4SOIcigc; + T5 = T12 * (pParam->B4SOIaigc + T3 * Voxdepinv + - T4 * Voxdepinv * Voxdepinv); + + if (T5 > EXPL_THRESHOLD) + { T6 = MAX_EXPL; + dT6_dVg = dT6_dVd = dT6_dVb = 0.0; + } + else if (T5 < -EXPL_THRESHOLD) + { T6 = MIN_EXPL; + dT6_dVg = dT6_dVd = dT6_dVb = 0.0; + } + else + { T6 = exp(T5); + dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * Voxdepinv); + dT6_dVd = dT6_dVg * dVoxdepinv_dVd; + dT6_dVb = dT6_dVg * dVoxdepinv_dVb; + dT6_dVg *= dVoxdepinv_dVg; + } + + Igc = T11 * T2 * T6; + dIgc_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg); + dIgc_dVd = T11 * (T2 * dT6_dVd + T6 * dT2_dVd); + dIgc_dVb = T11 * (T2 * dT6_dVb + T6 * dT2_dVb); + + T7 = -pParam->B4SOIpigcd * Vds; + T8 = T7 * T7 + 2.0e-4; + dT8_dVd = -2.0 * pParam->B4SOIpigcd * T7; + if (T7 > EXPL_THRESHOLD) + { T9 = MAX_EXPL; + dT9_dVd = 0.0; + } + else if (T7 < -EXPL_THRESHOLD) + { T9 = MIN_EXPL; + dT9_dVd = 0.0; + } + else + { T9 = exp(T7); + dT9_dVd = -T9 * pParam->B4SOIpigcd; + } + + T0 = T8 * T8; + T1 = T9 - 1.0 + 1.0e-4; + T10 = (T1 - T7) / T8; + dT10_dVd = ((pParam->B4SOIpigcd + dT9_dVd) * T8 + - (T1 - T7) * dT8_dVd) / T0; + Igcs = Igc * T10; + dIgcs_dVg = dIgc_dVg * T10; + dIgcs_dVd = dIgc_dVd * T10 + Igc * dT10_dVd; + dIgcs_dVb = dIgc_dVb * T10; + + T1 = T9 - 1.0 - 1.0e-4; + T10 = (T7 * T9 - T1) / T8; + dT10_dVd = (-pParam->B4SOIpigcd * T9 + (T7 - 1.0) + * dT9_dVd - T10 * dT8_dVd) / T8; + Igcd = Igc * T10; + dIgcd_dVg = dIgc_dVg * T10; + dIgcd_dVd = dIgc_dVd * T10 + Igc * dT10_dVd; + dIgcd_dVb = dIgc_dVb * T10; + + here->B4SOIIgcs = Igcs; + here->B4SOIgIgcsg = dIgcs_dVg; + here->B4SOIgIgcsd = dIgcs_dVd; + here->B4SOIgIgcsb = dIgcs_dVb * dVbseff_dVb; + here->B4SOIIgcd = Igcd; + here->B4SOIgIgcdg = dIgcd_dVg; + here->B4SOIgIgcdd = dIgcd_dVd; + here->B4SOIgIgcdb = dIgcd_dVb * dVbseff_dVb; + + + T0 = vgs - pParam->B4SOIvfbsd; + 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->B4SOIAechvbEdge; + T12 = pParam->B4SOIBechvbEdge; + T3 = pParam->B4SOIaigsd * pParam->B4SOIcigsd + - pParam->B4SOIbigsd; + T4 = pParam->B4SOIbigsd * pParam->B4SOIcigsd; + T5 = T12 * (pParam->B4SOIaigsd + T3 * vgs_eff + - T4 * vgs_eff * vgs_eff); + if (T5 > EXPL_THRESHOLD) + { T6 = MAX_EXPL; + dT6_dVg = 0.0; + } + else if (T5 < -EXPL_THRESHOLD) + { T6 = MIN_EXPL; + dT6_dVg = 0.0; + } + else + { T6 = exp(T5); + dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * vgs_eff) + * dvgs_eff_dvg; + } + Igs = T11 * T2 * T6; + dIgs_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg); + dIgs_dVs = -dIgs_dVg; + + + T0 = vgd - pParam->B4SOIvfbsd; + 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; + T5 = T12 * (pParam->B4SOIaigsd + T3 * vgd_eff + - T4 * vgd_eff * vgd_eff); + if (T5 > EXPL_THRESHOLD) + { T6 = MAX_EXPL; + dT6_dVg = 0.0; + } + else if (T5 < -EXPL_THRESHOLD) + { T6 = MIN_EXPL; + dT6_dVg = 0.0; + } + else + { T6 = exp(T5); + dT6_dVg = T6 * T12 * (T3 - 2.0 * T4 * vgd_eff) + * dvgd_eff_dvg; + } + Igd = T11 * T2 * T6; + dIgd_dVg = T11 * (T2 * dT6_dVg + T6 * dT2_dVg); + dIgd_dVd = -dIgd_dVg; + + here->B4SOIIgs = Igs; + here->B4SOIgIgsg = dIgs_dVg; + here->B4SOIgIgss = dIgs_dVs; + here->B4SOIIgd = Igd; + here->B4SOIgIgdg = dIgd_dVg; + here->B4SOIgIgdd = dIgd_dVd; + } + else + { here->B4SOIIgcs = here->B4SOIgIgcsg = here->B4SOIgIgcsd + = here->B4SOIgIgcsb = 0.0; + here->B4SOIIgcd = here->B4SOIgIgcdg = here->B4SOIgIgcdd + = here->B4SOIgIgcdb = 0.0; + here->B4SOIIgs = here->B4SOIgIgsg = here->B4SOIgIgss = 0.0; + here->B4SOIIgd = here->B4SOIgIgdg = here->B4SOIgIgdd = 0.0; + } + + here->B4SOIgIgcss = -(here->B4SOIgIgcsg + here->B4SOIgIgcsd + + here->B4SOIgIgcsb); + here->B4SOIgIgcds = -(here->B4SOIgIgcdg + here->B4SOIgIgcdd + + here->B4SOIgIgcdb); + + + /* gate-body tunneling component */ + if ((model->B4SOIigbMod!= 0) && (here->B4SOIsoiMod != 2)) /* v3.2 */ + /* v3.1: the Igb calculation is skipped for the ideal FD mode */ + { + OxideRatio = pParam->B4SOIoxideRatio; + + Vox = Voxdepinv; + /* Voxeff is Vox limited below Voxh */ + T0 = model->B4SOIvoxh; + T1 = T0 - Vox - model->B4SOIdeltavox; + T3 = sqrt(T1 * T1 + 4*model->B4SOIdeltavox * T0); + Voxeff = T0 - 0.5 * (T1 + T3); + dVoxeff_dVox = 0.5 * (1.0 + T1 / T3); + + Vox = Voxeff; + dVox_dVg = dVoxdepinv_dVg * dVoxeff_dVox; + dVox_dVd = dVoxdepinv_dVd * dVoxeff_dVox; + dVox_dVb = dVoxdepinv_dVb * dVoxeff_dVox; + dVox_dVe = dVoxdepinv_dVe * dVoxeff_dVox; /* v3.0 */ + dVox_dT = dVoxdepinv_dT * dVoxeff_dVox; + + + T0 = (Vox - model->B4SOIebg)/model->B4SOIvevb; + if (selfheat) + dT0_dT = dVox_dT /model->B4SOIvevb; + + DEXP(T0, T1, T2); /* T1=exp(T0), T2=dT1_dT0 */ + if (selfheat) + dT1_dT = T2 * dT0_dT; + + Vaux = model->B4SOIvevb * log(1 + T1); + dVaux_dVg = T2 / (1 + T1) * dVox_dVg; + dVaux_dVd = T2 / (1 + T1) * dVox_dVd; + dVaux_dVb = T2 / (1 + T1) * dVox_dVb; + dVaux_dVe = T2 / (1 + T1) * dVox_dVe; /* v3.0 */ + if (selfheat) + dVaux_dT = T2 / (1 + T1) * dVox_dT; + + if (model->B4SOIvgb1 != 0) { + T0 = 1 - Vox / model->B4SOIvgb1; + dT0_dVox = -1.0/model->B4SOIvgb1; + if (selfheat) + dT0_dT = -dVox_dT / model->B4SOIvgb1; + } else { + T0 = 1; + dT0_dVox = dT0_dT = 0.0; + } + + if (T0 < 0.01) { + T0 = 0.01; + dT0_dVox = dT0_dT = 0.0; + } + +/* v2.2.3 bug fix */ + T1 = Leff * Weff * 3.7622e-7 * OxideRatio + / here->B4SOInseg + here->B4SOIagbcpd /* v4.0 */; + + T2 = -3.1051e10 * model->B4SOItoxqm; + T3 = pParam->B4SOIalphaGB1; + T4 = pParam->B4SOIbetaGB1; + + T6 = T2*(T3 - T4 * Vox) / T0; + if (selfheat) dT6_dT = -T2 * T4 * dVox_dT / T0 - T6/T0 * dT0_dT; + + DEXP(T6, T5, T7); /* T5=exp(T6), T7=dT5_dT6 */ + dT5_dVg = -T7 * dVox_dVg * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox); + dT5_dVd = -T7 * dVox_dVd * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox); + dT5_dVb = -T7 * dVox_dVb * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox); + dT5_dVe = -T7 * dVox_dVe * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox); /* v3.0 */ + if (selfheat) + dT5_dT = T7 * dT6_dT; + + Igb1 = T1 * Vgb * Vaux * T5; + dIgb1_dVg = T1 * (Vgb*Vaux*dT5_dVg + dVgb_dVg*Vaux*T5 + + Vgb*T5*dVaux_dVg); + dIgb1_dVd = T1 * (Vgb*Vaux*dT5_dVd + Vgb*T5*dVaux_dVd); + dIgb1_dVb = T1 * (Vgb*Vaux*dT5_dVb + dVgb_dVb*Vaux*T5 + + Vgb*T5*dVaux_dVb); + dIgb1_dVe = T1 * (Vgb*Vaux*dT5_dVe + Vgb*T5*dVaux_dVe); /* v3.0 */ + if (selfheat) + dIgb1_dT = T1 * Vgb * (Vaux*dT5_dT + T5*dVaux_dT); + else dIgb1_dT = 0.0; + + + Vox = Voxacc; + /* Voxeff is Vox limited below Voxh */ + T0 = model->B4SOIvoxh; + T1 = T0 - Vox - model->B4SOIdeltavox; + T3 = sqrt(T1 * T1 + 4*model->B4SOIdeltavox * T0); + Voxeff = T0 - 0.5 * (T1 + T3); + dVoxeff_dVox = 0.5 * (1.0 + T1 / T3); + + Vox = Voxeff; + dVox_dVg = dVoxacc_dVg * dVoxeff_dVox; + dVox_dVd = dVoxacc_dVd * dVoxeff_dVox; + dVox_dVb = dVoxacc_dVb * dVoxeff_dVox; + dVox_dT = 0; + + T0 = (-Vgb+(Vfb))/model->B4SOIvecb; + if (selfheat) + dT0_dT = 0; + + DEXP(T0, T1, T2); /* T1=exp(T0), T2=dT1_dT0 */ + if (selfheat) + dT1_dT = 0; + + Vaux = model->B4SOIvecb* log(1 + T1); + dVaux_dVg = -T2 / (1 + T1); + dVaux_dVd = 0; + dVaux_dVb = -dVaux_dVg; + if (selfheat) + dVaux_dT = 0; + + if (model->B4SOIvgb2 != 0) { + T0 = 1 - Vox / model->B4SOIvgb2; + dT0_dVox = -1.0/model->B4SOIvgb2; + if (selfheat) dT0_dT = -dVox_dT / model->B4SOIvgb2; + } else { + T0 = 1; + dT0_dVox = dT0_dT =0.0; + } + + if (T0 < 0.01) { + T0 = 0.01; + dT0_dVox = dT0_dT =0.0; + } + +/* v2.2.3 bug fix */ + T1 = Leff * Weff * 4.9758e-7 * OxideRatio + / here->B4SOInseg + here->B4SOIagbcpd /* v4.0 */; + + T2 = -2.357e10 * model->B4SOItoxqm; + T3 = pParam->B4SOIalphaGB2; + T4 = pParam->B4SOIbetaGB2; + + T6 = T2*(T3 - T4 * Vox) / T0; + if (selfheat) dT6_dT = -T2 * T4 * dVox_dT / T0 - T6/T0 * dT0_dT; + + DEXP(T6, T5, T7); /* T5=exp(T6), T7=dT5_dT6 */ + dT5_dVg = -T7 * dVox_dVg * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox); + dT5_dVd = -T7 * dVox_dVd * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox); + dT5_dVb = -T7 * dVox_dVb * T2 / T0 * (T4 + (T3 - T4 * Vox) / T0 * dT0_dVox); + if (selfheat) + dT5_dT = T7 * dT6_dT; + + Igb2 = T1 * Vgb * Vaux * T5; + dIgb2_dVg = T1 * (Vgb*Vaux*dT5_dVg + dVgb_dVg*Vaux*T5 + + Vgb*T5*dVaux_dVg); + dIgb2_dVd = T1 * (Vgb*Vaux*dT5_dVd + Vgb*T5*dVaux_dVd); + dIgb2_dVb = T1 * (Vgb*Vaux*dT5_dVb + dVgb_dVb*Vaux*T5 + + Vgb*T5*dVaux_dVb); + if (selfheat) + dIgb2_dT = T1 * Vgb * (Vaux*dT5_dT + T5*dVaux_dT); + else dIgb2_dT = 0.0; + + +/* Igb1 dominates in inversion region, while Igb2 doninates in accumulation */ +/* v2.2.3 bug fix for residue at low Vgb */ + if (Vgb >= 0) + { + Igb = Igb1; + dIgb_dVg = dIgb1_dVg; + dIgb_dVd = dIgb1_dVd; + dIgb_dVb = dIgb1_dVb; + dIgb_dVe = dIgb1_dVe; /* v3.0 */ + dIgb_dT = dIgb1_dT; + } + else + { + Igb = Igb2; + dIgb_dVg = dIgb2_dVg; + dIgb_dVd = dIgb2_dVd; + dIgb_dVb = dIgb2_dVb; + dIgb_dVe = 0; /* v3.0 */ + dIgb_dT = dIgb2_dT; + } + + } + else { + Igb = 0.0; + dIgb_dVg = 0.0; + dIgb_dVd = 0.0; + dIgb_dVb = 0.0; + dIgb_dVe = 0.0; /* v3.0 */ + dIgb_dT = 0.0; + } + + here->B4SOIig = Igb; + here->B4SOIgigg = dIgb_dVg; + here->B4SOIgigd = dIgb_dVd; + here->B4SOIgigb = dIgb_dVb; + here->B4SOIgige = dIgb_dVe; /* v3.0 */ + here->B4SOIgigs = -(dIgb_dVg + dIgb_dVd + dIgb_dVb + dIgb_dVe); /* v3.0 */ + here->B4SOIgigT = dIgb_dT; + /* end of gate-body tunneling */ +/* end of v3.0 gate-tunneling */ + + + +/* v3.1 */ + if (here->B4SOIsoiMod != 2) /* v3.2 */ + { + /* calculate substrate current Iii */ + if (pParam->B4SOIalpha0 <= 0.0) { + Giig = Giib = Giid = GiiT = 0.0; + Giie = 0; /* v3.0 */ + here->B4SOIiii = Iii = 0.0; + } + else { + Vdsatii0 = pParam->B4SOIvdsatii0 * (1 + model->B4SOItii * (TempRatio-1.0)) + - pParam->B4SOIlii / Leff; + if (selfheat) + dVdsatii0_dT = pParam->B4SOIvdsatii0 * model->B4SOItii * dTempRatio_dT; + else + dVdsatii0_dT = 0; + + /* Calculate VgsStep */ + T0 = pParam->B4SOIesatii * Leff; /* v3.0 bug fix: T0 is dimentionless (i.e., scaled by 1V) */ + T1 = pParam->B4SOIsii0 * T0 / (1.0 + T0); + + T0 = 1 / (1 + pParam->B4SOIsii1 * Vgsteff); + if (selfheat) + dT0_dT = - pParam->B4SOIsii1 * T0 * T0 *dVgsteff_dT; + else + dT0_dT = 0; + T3 = T0 + pParam->B4SOIsii2; + T4 = Vgst * pParam->B4SOIsii1 * T0 * T0; + T2 = Vgst * T3; + dT2_dVg = T3 * (dVgst_dVg - dVth_dVb * dVbseff_dVg) - T4 * dVgsteff_dVg; /* v3.0 */ + dT2_dVb = T3 * dVgst_dVb * dVbseff_dVb - T4 * dVgsteff_dVb; + dT2_dVe = T3 * dVgst_dVb * dVbseff_dVe - T4 * dVgsteff_dVe; /* v3.0 */ + dT2_dVd = T3 * (dVgst_dVd - dVth_dVb * dVbseff_dVd) - T4 * dVgsteff_dVd; /* v3.0 */ + if (selfheat) + dT2_dT = -(dVth_dT + dVth_dVb * dVbseff_dT) * T3 + Vgst * dT0_dT; /* v3.0 */ + else dT2_dT = 0; + + + T3 = 1 / (1 + pParam->B4SOIsiid * Vds); + dT3_dVd = - pParam->B4SOIsiid * T3 * T3; + + VgsStep = T1 * T2 * T3; + if (selfheat) + dVgsStep_dT = T1 * T3 * dT2_dT; + else dVgsStep_dT = 0; + Vdsatii = Vdsatii0 + VgsStep; + Vdiff = Vds - Vdsatii; + dVdiff_dVg = - T1 * T3 * dT2_dVg; + dVdiff_dVb = - T1 * T3 * dT2_dVb; + dVdiff_dVe = - T1 * T3 * dT2_dVe; /* v3.0 */ + dVdiff_dVd = 1.0 - T1 * (T3 * dT2_dVd + T2 * dT3_dVd); + if (selfheat) + dVdiff_dT = -(dVdsatii0_dT + dVgsStep_dT); + else dVdiff_dT = 0; + + T0 = pParam->B4SOIbeta2 + pParam->B4SOIbeta1 * Vdiff + + pParam->B4SOIbeta0 * Vdiff * Vdiff; + if (T0 < 1e-5) + { + T0 = 1e-5; + dT0_dVg = dT0_dVd = dT0_dVb = dT0_dT = 0.0; + dT0_dVe = 0; /* v3.0 */ + } + else + { + T1 = pParam->B4SOIbeta1 + 2 * pParam->B4SOIbeta0 * Vdiff; + dT0_dVg = T1 * dVdiff_dVg; + dT0_dVb = T1 * dVdiff_dVb; + dT0_dVd = T1 * dVdiff_dVd; + dT0_dVe = T1 * dVdiff_dVe; /* v3.0 */ + if (selfheat) + dT0_dT = T1 * dVdiff_dT; + else + dT0_dT = 0; + } + + if ((T0 < Vdiff / EXPL_THRESHOLD) && (Vdiff > 0.0)) { + Ratio = pParam->B4SOIalpha0 * MAX_EXPL; + dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0; + dRatio_dVe = 0; /* v3.0 */ + } + else if ((T0 < -Vdiff / EXPL_THRESHOLD) && (Vdiff < 0.0)) { + Ratio = pParam->B4SOIalpha0 * MIN_EXPL; + dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0; + dRatio_dVe = 0; /* v3.0 */ + } + else { + Ratio = pParam->B4SOIalpha0 * exp(Vdiff / T0); + T1 = Ratio / T0 / T0; + dRatio_dVg = T1 * (T0 * dVdiff_dVg - Vdiff * dT0_dVg); + dRatio_dVb = T1 * (T0 * dVdiff_dVb - Vdiff * dT0_dVb); + dRatio_dVd = T1 * (T0 * dVdiff_dVd - Vdiff * dT0_dVd); + /* v3.0 */ + dRatio_dVe = T1 * (T0 * dVdiff_dVe - Vdiff * dT0_dVe); + + if (selfheat) + dRatio_dT = T1 * (T0 * dVdiff_dT - Vdiff * dT0_dT); + else + dRatio_dT = 0; + } + + /* Avoid too high ratio */ + if (Ratio > 10.0) { + Ratio = 10.0; + dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0; + dRatio_dVe = 0; /* v3.0 */ + } + + T0 = Ids + pParam->B4SOIfbjtii * Ic; + here->B4SOIiii = Iii = Ratio * T0; + Giig = Ratio * Gm + T0 * dRatio_dVg; + Giib = Ratio * (Gmb + pParam->B4SOIfbjtii * Gcb) + + T0 * dRatio_dVb; + Giid = Ratio * (Gds + pParam->B4SOIfbjtii * Gcd) + + T0 * dRatio_dVd; + /* v3.0 */ + Giie = Ratio * Gme + T0 * dRatio_dVe; + + if (selfheat) + GiiT = Ratio * (GmT + pParam->B4SOIfbjtii * GcT) + + T0 * dRatio_dT; + else + GiiT = 0.0; + + } + + + /* Current through body resistor */ + /* Current going out is +ve */ + if ((here->B4SOIbodyMod == 0) || (here->B4SOIbodyMod == 2)) + { + Ibp = Gbpbs = Gbpps = 0.0; + } + else { /* here->B4SOIbodyMod == 1 */ + if (pParam->B4SOIrbody < 1e-3) /* 3.2 bug fix */ + { + if (here->B4SOIrbodyext <= 1e-3) /* 3.2 bug fix */ + T0 = 1.0 / 1e-3; /* 3.2 bug fix */ + else + T0 = 1.0 / here->B4SOIrbodyext; + Ibp = Vbp * T0; + Gbpbs = T0 * dVbp_dVb; + Gbpps = -T0 * dVbp_dVb; + } else + { + Gbpbs = 1.0 / (pParam->B4SOIrbody + here->B4SOIrbodyext); + Ibp = Vbp * Gbpbs; + Gbpps = - Gbpbs; + } + } + + here->B4SOIibp = Ibp; + here->B4SOIgbpbs = Gbpbs; + here->B4SOIgbpps = Gbpps; + here->B4SOIgbpT = 0.0; + here->B4SOIcbodcon = Ibp - (Gbpbs * Vbs + Gbpps * Vps); + + } + + else /* v3.1 soiMod=2: ideal FD */ + { + Giig = Giib = Giid = Giie = GiiT = 0.0; + here->B4SOIiii = Iii = 0.0; + + here->B4SOIibp = Ibp = 0.0; + here->B4SOIgbpbs = 0.0; + here->B4SOIgbpps = here->B4SOIgbpT = here->B4SOIcbodcon = 0.0; + Gbpbs = Gbpps = 0.0; + } +/* v3.1 */ + + + + /* Current going out of drainprime node into the drain of device */ + /* "node" means the SPICE circuit node */ + + here->B4SOIcdrain = Ids + Ic; + here->B4SOIcd = Ids + Ic - Ibd + Iii + Igidl; + here->B4SOIcb = Ibs + Ibd + Ibp - Iii - Igidl - Igb; + here->B4SOIgds = Gds + Gcd; + here->B4SOIgm = Gm; + here->B4SOIgmbs = Gmb + Gcb; + /* v3.0 */ + here->B4SOIgme = Gme; + + /* v3.1 for RF */ + /* Calculate Rg */ + if (here->B4SOIrgateMod >1) + { T9 = pParam->B4SOIxrcrg2 * model->B4SOIvtm; + 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; + T1 = 1 + gche * Rds; + T2 = 1 / T1; + + here->B4SOIgcrg = pParam->B4SOIxrcrg1 + * (T0 + here->B4SOIidovVds); + dIdlovVdseff_dVg = (T2 * dgche_dVg + - IdlovVdseff * gche * dRds_dVg) / T1; + dIdlovVdseff_dVd = T2 * dgche_dVd / T1; + dIdlovVdseff_dVb = (T2 * dgche_dVb + - IdlovVdseff * gche * dRds_dVb) / T1; + + T9 = diffVds / Va; + T3 = 1.0 + T9; + + T4 = T3 * dIdlovVdseff_dVg + - IdlovVdseff * (dVdseff_dVg + T9 * dVa_dVg) / Va; + T5 = T3 * dIdlovVdseff_dVd + IdlovVdseff + * (1.0 - dVdseff_dVd - T9 * dVa_dVd) / Va; + T6 = T3 * dIdlovVdseff_dVb + - IdlovVdseff * (dVdseff_dVb + T9 * dVa_dVb) / Va; + + tmp1 = (T4 * dVgsteff_dVd + T6 * dVbseff_dVd + T5) + / here->B4SOInseg; + tmp2 = (T4 * dVgsteff_dVg + T6 * dVbseff_dVg) + / here->B4SOInseg; + tmp3 = (T4 * dVgsteff_dVb + T6 * dVbseff_dVb) + / here->B4SOInseg; + + here->B4SOIgcrgd = pParam->B4SOIxrcrg1 * (dT0_dVd +tmp1); + here->B4SOIgcrgg = pParam->B4SOIxrcrg1 + * (dT0_dVg * dVgsteff_dVg + tmp2); + here->B4SOIgcrgb = pParam->B4SOIxrcrg1 + * (dT0_dVb * dVbseff_dVb + tmp3); + + if (here->B4SOInf != 1.0) + { here->B4SOIgcrg *= here->B4SOInf; + here->B4SOIgcrgg *= here->B4SOInf; + here->B4SOIgcrgd *= here->B4SOInf; + here->B4SOIgcrgb *= here->B4SOInf; + } + + if (here->B4SOIrgateMod == 2) + { T10 = here->B4SOIgrgeltd * here->B4SOIgrgeltd; + T11 = here->B4SOIgrgeltd + here->B4SOIgcrg; + here->B4SOIgcrg = here->B4SOIgrgeltd + * here->B4SOIgcrg / T11; + T12 = T10 / T11 /T11; + here->B4SOIgcrgg *= T12; + here->B4SOIgcrgd *= T12; + here->B4SOIgcrgb *= T12; + } + + here->B4SOIgcrgs = -(here->B4SOIgcrgg + here->B4SOIgcrgd + + here->B4SOIgcrgb); + } /* v3.1 added Rg for RF end */ + + /* v4.0 Calculate bias-dependent external S/D resistance */ + if (model->B4SOIrdsMod) + { /* Rs(V) */ + T0 = vgs - pParam->B4SOIvfbsd; + T1 = sqrt(T0 * T0 + 1.0e-4); + vgs_eff = 0.5 * (T0 + T1); + dvgs_eff_dvg = vgs_eff / T1; + + T0 = 1.0 + pParam->B4SOIprwg * vgs_eff; + dT0_dVg = -pParam->B4SOIprwg / T0 / T0 * dvgs_eff_dvg; + T1 = -pParam->B4SOIprwb * vbs; + dT1_dVb = -pParam->B4SOIprwb; + + T2 = 1.0 / T0 + T1; + T3 = T2 + sqrt(T2 * T2 + 0.01); + dT3_dVg = T3 / (T3 - T2); + dT3_dVb = dT3_dVg * dT1_dVb; + dT3_dVg *= dT0_dVg; + + T4 = rs0 * 0.5; + Rs = rswmin + T3 * T4; + dRs_dVg = T4 * dT3_dVg; + dRs_dVb = T4 * dT3_dVb; + + T0 = 1.0 + here->B4SOIsourceConductance * Rs; + here->B4SOIgstot = here->B4SOIsourceConductance / T0; + T0 = -here->B4SOIgstot * here->B4SOIgstot; + dgstot_dvd = 0.0; /* place holder */ + dgstot_dve = 0.0; /* place holder */ + dgstot_dvg = T0 * dRs_dVg; + dgstot_dvb = T0 * dRs_dVb; + dgstot_dvs = -(dgstot_dvg + dgstot_dvb + dgstot_dvd + + dgstot_dve); + if (selfheat) { + dRs_dT = drswmin_dT + T3 * 0.5 * drs0_dT; + dgstot_dT = T0 * dRs_dT; + } + else dRs_dT = dgstot_dT = 0.0; + + /* Rd(V) */ + T0 = vgd - pParam->B4SOIvfbsd; + T1 = sqrt(T0 * T0 + 1.0e-4); + vgd_eff = 0.5 * (T0 + T1); + dvgd_eff_dvg = vgd_eff / T1; + + T0 = 1.0 + pParam->B4SOIprwg * vgd_eff; + dT0_dVg = -pParam->B4SOIprwg / T0 / T0 * dvgd_eff_dvg; + T1 = -pParam->B4SOIprwb * vbd; + dT1_dVb = -pParam->B4SOIprwb; + + T2 = 1.0 / T0 + T1; + T3 = T2 + sqrt(T2 * T2 + 0.01); + dT3_dVg = T3 / (T3 - T2); + dT3_dVb = dT3_dVg * dT1_dVb; + dT3_dVg *= dT0_dVg; + + T4 = pParam->B4SOIrd0 * 0.5; + Rd = pParam->B4SOIrdwmin + T3 * T4; + dRd_dVg = T4 * dT3_dVg; + dRd_dVb = T4 * dT3_dVb; + T0 = 1.0 + here->B4SOIdrainConductance * Rd; + here->B4SOIgdtot = here->B4SOIdrainConductance / T0; + T0 = -here->B4SOIgdtot * here->B4SOIgdtot; + dgdtot_dvs = 0.0; + dgdtot_dve = 0.0; + dgdtot_dvg = T0 * dRd_dVg; + dgdtot_dvb = T0 * dRd_dVb; + dgdtot_dvd = -(dgdtot_dvg + dgdtot_dvb + dgdtot_dvs + + dgdtot_dve); + if (selfheat) { + dRd_dT = drdwmin_dT + T3 * 0.5 * drd0_dT; + dgdtot_dT = T0 * dRd_dT; + } + else dRd_dT = dgdtot_dT = 0.0; + + here->B4SOIgstotd = vses * dgstot_dvd; + here->B4SOIgstotg = vses * dgstot_dvg; + here->B4SOIgstots = vses * dgstot_dvs; + here->B4SOIgstotb = vses * dgstot_dvb; + + T2 = vdes - vds; + here->B4SOIgdtotd = T2 * dgdtot_dvd; + here->B4SOIgdtotg = T2 * dgdtot_dvg; + here->B4SOIgdtots = T2 * dgdtot_dvs; + here->B4SOIgdtotb = T2 * dgdtot_dvb; + } + else + { here->B4SOIgstot = here->B4SOIgstotd = here->B4SOIgstotg + = here->B4SOIgstots = here->B4SOIgstotb + = 0.0; + here->B4SOIgdtot = here->B4SOIgdtotd = here->B4SOIgdtotg + = here->B4SOIgdtots = here->B4SOIgdtotb + = 0.0; + } + + if (selfheat) + here->B4SOIgmT = GmT + GcT; + else + here->B4SOIgmT = 0.0; + + /* note that sign is switched because power flows out + of device into the temperature node. + Currently ommit self-heating due to bipolar current + because it can cause convergence problem*/ + + here->B4SOIgtempg = -Gm * Vds; + here->B4SOIgtempb = -Gmb * Vds; + /* v3.0 */ + here->B4SOIgtempe = -Gme * Vds; + + here->B4SOIgtempT = -GmT * Vds; + here->B4SOIgtempd = -Gds * Vds - Ids; + here->B4SOIcth = - Ids * Vds - model->B4SOItype * + (here->B4SOIgtempg * Vgs + here->B4SOIgtempb * Vbs + + here->B4SOIgtempe * Ves + + here->B4SOIgtempd * Vds) + - here->B4SOIgtempT * delTemp; /* v3.0 */ + + + /* Body current which flows into drainprime node from the drain of device */ + + here->B4SOIgjdb = Gjdb - Giib -Ggidlb; /* v4.0 */ + here->B4SOIgjdd = Gjdd - (Giid + Ggidld); + here->B4SOIgjdg = - (Giig + Ggidlg); + here->B4SOIgjde = - Giie; + if (selfheat) here->B4SOIgjdT = GjdT - GiiT; + else here->B4SOIgjdT = 0.0; + here->B4SOIcjd = Ibd - Iii - Igidl + - (here->B4SOIgjdb * Vbs + + here->B4SOIgjdd * Vds + + here->B4SOIgjdg * Vgs + + here->B4SOIgjde * Ves + + here->B4SOIgjdT * delTemp); /* v3.0 */ + + if (!here->B4SOIrbodyMod) + { + Giigidl_b = Giigidl_d = Giigidl_g = Giigidl_e + = Giigidl_T = Iii_Igidl = 0.0; + } + else + { + here->B4SOIgiigidlb = Giib + Ggidlb; + here->B4SOIgiigidld = Giid + Ggidld; + Giigidl_b = - Giib -Ggidlb; + Giigidl_d = - Giid -Ggidld; + Giigidl_g = - Giig -Ggidlg; + Giigidl_e = - Giie; + if (selfheat) Giigidl_T = -GiiT; + else GiiT = Giigidl_T = 0.0; + + Idbdp = Ibd - ( Gjdb * vbs_jct + Gjdd * Vds + + GjdT * delTemp); +/* Iii_Igidl = - Iii - Igidl + + Giigidl_b * Vbs + Giigidl_d * Vds + + Giigidl_g * Vgs + Giigidl_e * Ves + + Giigidl_T * delTemp ; */ + } + + + /* Body current which flows into sourceprime node from the source of device */ + + here->B4SOIgjsg = 0.0; + here->B4SOIgjsd = Gjsd; + here->B4SOIgjsb = Gjsb; /* v4.0 */ + if (selfheat) here->B4SOIgjsT = GjsT; + else here->B4SOIgjsT = 0.0; + here->B4SOIcjs = Ibs + -( here->B4SOIgjsb * Vbs + + here->B4SOIgjsd * Vds + + here->B4SOIgjsg * Vgs + + here->B4SOIgjsT * delTemp); + + if (here->B4SOIrbodyMod) { + Isbsp = Ibs - ( Gjsb * vbs_jct + Gjsd * Vds + + GjsT * delTemp ); + } + + /* Current flowing into body node */ + + here->B4SOIgbbs = Giib - Gjsb - Gjdb - Gbpbs; + here->B4SOIgbgs = Giig + Ggidlg ; + here->B4SOIgbds = Giid + Ggidld - Gjsd - Gjdd; + here->B4SOIgbes = Giie; + here->B4SOIgbps = - Gbpps; + if (selfheat) here->B4SOIgbT = GiiT - GjsT - GjdT; + else here->B4SOIgbT = 0.0; + + if (!here->B4SOIrbodyMod) + { + here->B4SOIcbody = Iii + Igidl - Ibs - Ibd + - Ibp + Igb + - ( (here->B4SOIgbbs + dIgb_dVb) * Vbs + + (here->B4SOIgbgs + dIgb_dVg) * Vgs + + (here->B4SOIgbds + dIgb_dVd) * Vds + + here->B4SOIgbps * Vps + + (here->B4SOIgbes + dIgb_dVe) * Ves + + (here->B4SOIgbT + dIgb_dT) * delTemp); + } + + if (here->B4SOIrbodyMod) + { + here->B4SOIgbgiigbpb = Giib - Gbpbs; + here->B4SOIcbody = Iii + Igidl - Ibp + Igb + - ( (Giib - Gbpbs + dIgb_dVb) * Vbs + + (here->B4SOIgbgs + dIgb_dVg) * Vgs + + (Giid + Ggidld + dIgb_dVd) * Vds + + here->B4SOIgbps * Vps + + (here->B4SOIgbes + dIgb_dVe) * Ves + + (GiiT + dIgb_dT) * delTemp ); + } + + here->B4SOIcgate = Igb + - (dIgb_dVb * Vbs + dIgb_dVe * Ves + dIgb_dVg * Vgs + + dIgb_dVd * Vds + dIgb_dT * delTemp); /* v3.0 */ + + /* Calculate Qinv for Noise analysis */ + + T1 = Vgsteff * (1.0 - 0.5 * Abulk * Vdseff / Vgst2Vtm); + here->B4SOIqinv = -model->B4SOIcox * pParam->B4SOIweff + * here->B4SOInf * Leff * T1; /* v4.0 */ + + if (here->B4SOInf != 1) { + here->B4SOIcdrain *= here->B4SOInf; + here->B4SOIcd *= here->B4SOInf; + here->B4SOIcb *= here->B4SOInf; + here->B4SOIgds *= here->B4SOInf; + here->B4SOIgm *= here->B4SOInf; + here->B4SOIgmbs *= here->B4SOInf; + here->B4SOIgme *= here->B4SOInf; + + here->B4SOIcbody *= here->B4SOInf; + here->B4SOIcgate *= here->B4SOInf; + + here->B4SOIIgcs *= here->B4SOInf; + here->B4SOIgIgcsg *= here->B4SOInf; + here->B4SOIgIgcsd *= here->B4SOInf; + here->B4SOIgIgcsb *= here->B4SOInf; + here->B4SOIIgcd *= here->B4SOInf; + here->B4SOIgIgcdg *= here->B4SOInf; + here->B4SOIgIgcdd *= here->B4SOInf; + here->B4SOIgIgcdb *= here->B4SOInf; + + here->B4SOIIgs *= here->B4SOInf; + here->B4SOIgIgsg *= here->B4SOInf; + here->B4SOIgIgss *= here->B4SOInf; + here->B4SOIIgd *= here->B4SOInf; + here->B4SOIgIgdg *= here->B4SOInf; + here->B4SOIgIgdd *= here->B4SOInf; + + here->B4SOIig *= here->B4SOInf; + here->B4SOIgigg *= here->B4SOInf; + here->B4SOIgigd *= here->B4SOInf; + here->B4SOIgigb *= here->B4SOInf; + here->B4SOIgige *= here->B4SOInf; + here->B4SOIgigT *= here->B4SOInf; + + here->B4SOIcjs *= here->B4SOInf; + here->B4SOIcjd *= here->B4SOInf; + here->B4SOIibs *= here->B4SOInf; + here->B4SOIibd *= here->B4SOInf; + + here->B4SOIgbbs *= here->B4SOInf; + here->B4SOIgbgs *= here->B4SOInf; + here->B4SOIgbds *= here->B4SOInf; + here->B4SOIgbes *= here->B4SOInf; + here->B4SOIgbps *= here->B4SOInf; + here->B4SOIgbT *= here->B4SOInf; + + here->B4SOIigidl *= here->B4SOInf; + + } + here->B4SOIgigs = -(here->B4SOIgigg + here->B4SOIgigd + + here->B4SOIgigb + here->B4SOIgige); + here->B4SOIgIgcss = -(here->B4SOIgIgcsg + here->B4SOIgIgcsd + + here->B4SOIgIgcsb); + here->B4SOIgIgcds = -(here->B4SOIgIgcdg + here->B4SOIgIgcdd + + here->B4SOIgIgcdb); + + + /* Begin CV (charge) model */ + + if ((model->B4SOIxpart < 0) || (!ChargeComputationNeeded)) + { qgate = qdrn = qsrc = qbody = qsub = 0.0; /* v2.2.3 bug fix */ + here->B4SOIcggb = here->B4SOIcgsb = here->B4SOIcgdb = 0.0; + here->B4SOIcdgb = here->B4SOIcdsb = here->B4SOIcddb = 0.0; + here->B4SOIcbgb = here->B4SOIcbsb = here->B4SOIcbdb = 0.0; + goto finished; + } + else + { + CoxWL = model->B4SOIcox * (pParam->B4SOIweffCV + / here->B4SOInseg * here->B4SOInf /* v4.0 */ + * pParam->B4SOIleffCV + here->B4SOIagbcp); + CoxWLb = model->B4SOIfbody * model->B4SOIcox + * (pParam->B4SOIweffCV / here->B4SOInseg + * here->B4SOInf /* v4.0 */ + * pParam->B4SOIleffCVb + here->B4SOIagbcp); + + +/* v3.2 Seperate VgsteffCV with noff */ + noff = n * pParam->B4SOInoff; + dnoff_dVd = pParam->B4SOInoff * dn_dVd; + dnoff_dVb = pParam->B4SOInoff * dn_dVb; + + if ((VgstNVt > -EXPL_THRESHOLD) && (VgstNVt < EXPL_THRESHOLD)) + { ExpVgst *= ExpVgst; + ExpVgst *= exp( -(pParam->B4SOIdelvt / (noff * Vtm))); + Vgsteff = noff * Vtm * log(1.0 + ExpVgst); + T0 = ExpVgst / (1.0 + ExpVgst); + T1 = -T0 * (dVth_dVb + (Vgst-pParam->B4SOIdelvt) / noff * dnoff_dVb) + + Vgsteff / noff * dnoff_dVb; + dVgsteff_dVd = -T0 * (dVth_dVd + dVth_dVb*dVbseff_dVd + Vgst / noff * dnoff_dVd) + + Vgsteff / noff * dnoff_dVd; + dVgsteff_dVg = T0 * (dVgs_eff_dVg - dVth_dVb*dVbseff_dVg); + dVgsteff_dVb = T1 * dVbseff_dVb; + dVgsteff_dVe = T1 * dVbseff_dVe; + if (selfheat) + dVgsteff_dT = -T0 * (dVth_dT+dVth_dVb*dVbseff_dT + + (Vgst - pParam->B4SOIdelvt) / Temp) + + Vgsteff / Temp; + else dVgsteff_dT = 0.0; + } +/* v3.2 */ + + + if (model->B4SOIcapMod == 2) + { + +/* v3.1 */ + if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */ + { + Qac0 = dQac0_dVrg = dQac0_dVd = dQac0_dVb = dQac0_dT = 0.0; + Qsub0 = dQsub0_dVrg = dQsub0_dVg = dQsub0_dVd = dQsub0_dVb = dQsub0_dT = 0.0; + } + else /* soiMod = 0 or 1 */ + { + Vfb = Vth - phi - pParam->B4SOIk1eff * sqrtPhis + pParam->B4SOIdelvt; + dVfb_dVb = dVth_dVb - pParam->B4SOIk1eff * dsqrtPhis_dVb; + dVfb_dVd = dVth_dVd; + dVfb_dT = dVth_dT; + + V3 = Vfb - Vgs_eff + Vbseff - DELTA_3_SOI; + if (Vfb <= 0.0) + { T0 = sqrt(V3 * V3 - 4.0 * DELTA_3_SOI * Vfb); + T2 = -DELTA_3_SOI / T0; + } + else + { T0 = sqrt(V3 * V3 + 4.0 * DELTA_3_SOI * Vfb); + T2 = DELTA_3_SOI / T0; + } + + T1 = 0.5 * (1.0 + V3 / T0); + Vfbeff = Vfb - 0.5 * (V3 + T0); + dVfbeff_dVd = (1.0 - T1 - T2) * dVfb_dVd; + dVfbeff_dVb = (1.0 - T1 - T2) * dVfb_dVb - T1; + dVfbeff_dVrg = T1 * dVgs_eff_dVg; + if (selfheat) dVfbeff_dT = (1.0 - T1 - T2) * dVfb_dT; + else dVfbeff_dT = 0.0; + + Qac0 = CoxWLb * (Vfbeff - Vfb); + dQac0_dVrg = CoxWLb * dVfbeff_dVrg; + dQac0_dVd = CoxWLb * (dVfbeff_dVd - dVfb_dVd); + dQac0_dVb = CoxWLb * (dVfbeff_dVb - dVfb_dVb); + if (selfheat) dQac0_dT = CoxWLb * (dVfbeff_dT - dVfb_dT); + else dQac0_dT = 0.0; + + T0 = 0.5 * pParam->B4SOIk1ox; + T3 = Vgs_eff - Vfbeff - Vbseff - Vgsteff; + if (pParam->B4SOIk1ox == 0.0) + { T1 = 0.0; + T2 = 0.0; + } + else if (T3 < 0.0) + { T1 = T0 + T3 / pParam->B4SOIk1ox; + T2 = CoxWLb; + } + else + { T1 = sqrt(T0 * T0 + T3); + T2 = CoxWLb * T0 / T1; + } + + Qsub0 = CoxWLb * K1 * (T1 - T0); + dQsub0_dVrg = T2 * (dVgs_eff_dVg - dVfbeff_dVrg); + dQsub0_dVg = -T2; + dQsub0_dVd = -T2 * dVfbeff_dVd; + dQsub0_dVb = -T2 * (dVfbeff_dVb + 1); + if (selfheat) dQsub0_dT = -T2 * dVfbeff_dT; + else dQsub0_dT = 0.0; + } +/* v3.1 */ + + + + AbulkCV = Abulk0 * pParam->B4SOIabulkCVfactor; + dAbulkCV_dVb = pParam->B4SOIabulkCVfactor * dAbulk0_dVb; + + VdsatCV = Vgsteff / AbulkCV; + dVdsatCV_dVg = 1.0 / AbulkCV; + dVdsatCV_dVb = -VdsatCV * dAbulkCV_dVb / AbulkCV; + + V4 = VdsatCV - Vds - DELTA_4; + T0 = sqrt(V4 * V4 + 4.0 * DELTA_4 * VdsatCV); + VdseffCV = VdsatCV - 0.5 * (V4 + T0); + T1 = 0.5 * (1.0 + V4 / T0); + T2 = DELTA_4 / T0; + T3 = (1.0 - T1 - T2) / AbulkCV; + dVdseffCV_dVg = T3; + dVdseffCV_dVd = T1; + dVdseffCV_dVb = -T3 * VdsatCV * dAbulkCV_dVb; + + + +/* v3.1 */ + if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */ + { + qbulk = Cbg1 = Cbd1 = Cbb1 = 0; + } + else + { + T0 = AbulkCV * VdseffCV; + T1 = 12.0 * (Vgsteff - 0.5 * T0 + 1e-20); + T2 = VdseffCV / T1; + T3 = T0 * T2; + T4 = (1.0 - 12.0 * T2 * T2 * AbulkCV); + T5 = (6.0 * T0 * (4.0 * Vgsteff- T0) / (T1 * T1) - 0.5); + T6 = 12.0 * T2 * T2 * Vgsteff; + + T7 = 1.0 - AbulkCV; + qbulk = CoxWLb * T7 * (0.5 * VdseffCV - T3); + T4 = -T7 * (T4 - 1.0); + T5 = -T7 * T5; + T6 = -(T7 * T6 + (0.5 * VdseffCV - T3)); + + Cbg1 = CoxWLb * (T4 + T5 * dVdseffCV_dVg); + Cbd1 = CoxWLb * T5 * dVdseffCV_dVd ; + Cbb1 = CoxWLb * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb); + } +/* v3.1 */ + + + + /* Total inversion charge */ + T0 = AbulkCV * VdseffCV; + T1 = 12.0 * (Vgsteff - 0.5 * T0 + 1e-20); +/* T2 = VdseffCV / T1; +*/ + T2 = T0 / T1; + T3 = T0 * T2; + +/* T4 = (1.0 - 12.0 * T2 * T2 * AbulkCV); + T5 = (6.0 * T0 * (4.0 * Vgsteff - T0) / (T1 * T1) - 0.5); + T6 = 12.0 * T2 * T2 * Vgsteff; +*/ + T4 = (1.0 - 12.0 * T2 * T2);/*bug fix */ + T7 = T2 * (2.0 + 6.0 * T2) - 0.5; /*bug fix */ + + T5 = T7 * AbulkCV; + T6 = T7 * VdseffCV; + +/* qinv = CoxWL * (Vgsteff - 0.5 * VdseffCV + T3); +*/ + qinv = CoxWL * (Vgsteff - 0.5 * T0 + T3); + + here->B4SOIqinv = -qinv; /* for noise v3.2 */ + + Cgg1 = CoxWL * (T4 + T5 * dVdseffCV_dVg); + Cgd1 = CoxWL * T5 * dVdseffCV_dVd; + Cgb1 = CoxWL * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb); + + /* Inversion charge partitioning into S / D */ + if (model->B4SOIxpart > 0.5) + { /* 0/100 Charge partition model */ + T1 = T1 + T1; + qsrc = -CoxWL * (0.5 * Vgsteff + 0.25 * T0 + - T0 * T0 / T1); + T7 = (4.0 * Vgsteff - T0) / (T1 * T1); + T4 = -(0.5 + 24.0 * T0 * T0 / (T1 * T1)); + T5 = -(0.25 * AbulkCV - 12.0 * AbulkCV * T0 * T7); + T6 = -(0.25 * VdseffCV - 12.0 * T0 * VdseffCV * T7); + Csg1 = CoxWL * (T4 + T5 * dVdseffCV_dVg); + Csd1 = CoxWL * T5 * dVdseffCV_dVd; + Csb1 = CoxWL * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb); + + } + else if (model->B4SOIxpart < 0.5) + { /* 40/60 Charge partition model */ + T1 = T1 / 12.0; + T2 = 0.5 * CoxWL / (T1 * T1); + T3 = Vgsteff * (2.0 * T0 * T0 / 3.0 + Vgsteff + * (Vgsteff - 4.0 * T0 / 3.0)) + - 2.0 * T0 * T0 * T0 / 15.0; + qsrc = -T2 * T3; + T7 = 4.0 / 3.0 * Vgsteff * (Vgsteff - T0) + + 0.4 * T0 * T0; + T4 = -2.0 * qsrc / T1 - T2 * (Vgsteff * (3.0 + * Vgsteff - 8.0 * T0 / 3.0) + + 2.0 * T0 * T0 / 3.0); + T5 = (qsrc / T1 + T2 * T7) * AbulkCV; + T6 = (qsrc / T1 * VdseffCV + T2 * T7 * VdseffCV); + Csg1 = T4 + T5 * dVdseffCV_dVg; + Csd1 = T5 * dVdseffCV_dVd; + Csb1 = T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb; + } + else + { /* 50/50 Charge partition model */ + qsrc = - 0.5 * (qinv + qbulk); + Csg1 = - 0.5 * (Cgg1 + Cbg1); + Csb1 = - 0.5 * (Cgb1 + Cbb1); + Csd1 = - 0.5 * (Cgd1 + Cbd1); + } + + + + /* Backgate charge */ +/* v3.1 */ + if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */ + { + Qe1 = dQe1_dVb = dQe1_dVe = dQe1_dT = 0; + } + else /* soiMod = 0 or 1 */ + { + CboxWL = pParam->B4SOIkb1 * model->B4SOIfbody * Cbox + * (pParam->B4SOIweffCV / here->B4SOInseg + * pParam->B4SOIleffCVbg + here->B4SOIaebcp); + Qe1 = CboxWL * (Vesfb - Vbs); + dQe1_dVb = -CboxWL; + dQe1_dVe = CboxWL; + if (selfheat) dQe1_dT = -CboxWL * dvfbb_dT; + else dQe1_dT = 0; + } +/* v3.1 */ + + + qgate = qinv + Qac0 + Qsub0; + qbody = (qbulk - Qac0 - Qsub0 - Qe1); + qsub = Qe1; + qdrn = -(qgate + qsrc + qbody + qsub); + + /* This transform all the dependency on Vgsteff, Vbseff + into real ones */ + Ce1b = dQe1_dVb; + Ce1e = dQe1_dVe; + + Csg = Csg1 * dVgsteff_dVg; + Csd = Csd1 + Csg1 * dVgsteff_dVd; + Csb = Csg1 * dVgsteff_dVb + Csb1 * dVbseff_dVb; + if (selfheat) CsT = Csg1 * dVgsteff_dT; + else CsT = 0.0; + + Cgg = (Cgg1 + dQsub0_dVg) * dVgsteff_dVg + + dQac0_dVrg + dQsub0_dVrg; + Cgd = (Cgg1 + dQsub0_dVg) * dVgsteff_dVd + Cgd1 + + dQac0_dVd + dQsub0_dVd; + Cgb = (Cgg1 + dQsub0_dVg) * dVgsteff_dVb + + (Cgb1 + dQsub0_dVb + dQac0_dVb) * dVbseff_dVb; + if (selfheat) + CgT = (Cgg1 + dQsub0_dVg) * dVgsteff_dT + + dQac0_dT + dQsub0_dT; + else CgT = 0.0; + + Cbg = (Cbg1 - dQsub0_dVg) * dVgsteff_dVg + - dQac0_dVrg - dQsub0_dVrg; + Cbd = (Cbg1 - dQsub0_dVg) * dVgsteff_dVd + Cbd1 + - dQac0_dVd - dQsub0_dVd; + Cbb = (Cbg1 - dQsub0_dVg) * dVgsteff_dVb - dQe1_dVb + + (Cbb1 - dQsub0_dVb - dQac0_dVb) * dVbseff_dVb; + if (selfheat) + CbT = (Cbg1 - dQsub0_dVg) * dVgsteff_dT + - dQac0_dT - dQsub0_dT - dQe1_dT; + else CbT = 0.0; + + + here->B4SOIcggb = Cgg ; + here->B4SOIcgsb = - (Cgg + Cgd + Cgb); + here->B4SOIcgdb = Cgd; + here->B4SOIcgT = CgT; + + here->B4SOIcbgb = Cbg; + here->B4SOIcbsb = -(Cbg + Cbd + Cbb) + + Ce1e; + here->B4SOIcbdb = Cbd; + here->B4SOIcbeb = - Ce1e ; + here->B4SOIcbT = CbT; + + here->B4SOIceeb = Ce1e ; + here->B4SOIceT = dQe1_dT; + + here->B4SOIcdgb = -(Cgg + Cbg + Csg); + here->B4SOIcddb = -(Cgd + Cbd + Csd); + here->B4SOIcdeb = 0; + here->B4SOIcdT = -(CgT + CbT + CsT) - dQe1_dT; + here->B4SOIcdsb = (Cgg + Cgd + Cgb + + Cbg + Cbd + Cbb + + Csg + Csd + Csb) + Ce1b; + } /* End of if capMod == 2 */ + + else if (model->B4SOIcapMod == 3) + { + + dVgsteff_dVb /= dVbseff_dVb; + Cox = 3.453133e-11 / (model->B4SOItox - model->B4SOIdtoxcv); /* v2.2.3 */ + CoxWL *= model->B4SOItox/ (model->B4SOItox - model->B4SOIdtoxcv); + CoxWLb *= model->B4SOItox/ (model->B4SOItox - model->B4SOIdtoxcv); + Tox = 1.0e8 * (model->B4SOItox - model->B4SOIdtoxcv); + + +/* v3.1 */ + if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */ + { + Qac0 = dQac0_dVg = dQac0_dVb = dQac0_dT = 0.0; + Qsub0 = dQsub0_dVg = dQsub0_dVd = dQsub0_dVb = dQsub0_dT = 0.0; + } + else /* soiMod = 0 or 1 */ + { + if (selfheat) { + Vfbzb = Vthzb - phi - pParam->B4SOIk1eff * sqrtPhi + + pParam->B4SOIdelvt; + dVfbzb_dT = dVthzb_dT; + } + else { + Vfbzb = here->B4SOIvfbzb + pParam->B4SOIdelvt; + dVfbzb_dT = 0; + } + + V3 = Vfbzb - Vgs_eff + Vbseff - DELTA_3; + if (Vfbzb <= 0.0) + { T0 = sqrt(V3 * V3 - 4.0 * DELTA_3 * Vfbzb); + T2 = -DELTA_3 / T0; + } + else + { T0 = sqrt(V3 * V3 + 4.0 * DELTA_3 * Vfbzb); + T2 = DELTA_3 / T0; + } + + T1 = 0.5 * (1.0 + V3 / T0); + Vfbeff = Vfbzb - 0.5 * (V3 + T0); + dVfbeff_dVg = T1 * dVgs_eff_dVg; + dVfbeff_dVb = -T1; + if (selfheat) dVfbeff_dT = (1.0 - T1 - T2) * dVfbzb_dT; + else dVfbeff_dT = 0.0; + + + T0 = (Vgs_eff - Vbseff - Vfbzb) / Tox; + dT0_dVg = dVgs_eff_dVg / Tox; + dT0_dVb = -1.0 / Tox; + + tmp = T0 * pParam->B4SOIacde; + if ((-EXPL_THRESHOLD < tmp) && (tmp < EXPL_THRESHOLD)) + { Tcen = pParam->B4SOIldeb * exp(tmp); + dTcen_dVg = pParam->B4SOIacde * Tcen; + dTcen_dVb = dTcen_dVg * dT0_dVb; + dTcen_dVg *= dT0_dVg; + if (selfheat) + dTcen_dT = -Tcen * pParam->B4SOIacde * dVfbzb_dT / Tox; + else dTcen_dT = 0; + } + else if (tmp <= -EXPL_THRESHOLD) + { Tcen = pParam->B4SOIldeb * MIN_EXPL; + dTcen_dVg = dTcen_dVb = dTcen_dT = 0.0; + } + else + { Tcen = pParam->B4SOIldeb * MAX_EXPL; + dTcen_dVg = dTcen_dVb = dTcen_dT = 0.0; + } + + LINK = 1.0e-3 * (model->B4SOItox - model->B4SOIdtoxcv); /* v2.2.3 */ + V3 = pParam->B4SOIldeb - Tcen - LINK; + V4 = sqrt(V3 * V3 + 4.0 * LINK * pParam->B4SOIldeb); + Tcen = pParam->B4SOIldeb - 0.5 * (V3 + V4); + T1 = 0.5 * (1.0 + V3 / V4); + dTcen_dVg *= T1; + dTcen_dVb *= T1; + if (selfheat) + dTcen_dT *= T1; + else dTcen_dT = 0; + + Ccen = EPSSI / Tcen; + T2 = Cox / (Cox + Ccen); + Coxeff = T2 * Ccen; + T3 = -Ccen / Tcen; + dCoxeff_dVg = T2 * T2 * T3; + dCoxeff_dVb = dCoxeff_dVg * dTcen_dVb; + dCoxeff_dVg *= dTcen_dVg; + if (selfheat) + dCoxeff_dT = T3 * dTcen_dT * (T2 - Coxeff / (Cox + Ccen)); + else dCoxeff_dT = 0; + CoxWLcenb = CoxWLb * Coxeff / Cox; + if (selfheat) + dCoxWLcenb_dT = CoxWLb * dCoxeff_dT / Cox; + else dCoxWLcenb_dT = 0; + + Qac0 = CoxWLcenb * (Vfbeff - Vfbzb); + QovCox = Qac0 / Coxeff; + dQac0_dVg = CoxWLcenb * dVfbeff_dVg + + QovCox * dCoxeff_dVg; + dQac0_dVb = CoxWLcenb * dVfbeff_dVb + + QovCox * dCoxeff_dVb; + if (selfheat) dQac0_dT = CoxWLcenb * (dVfbeff_dT - dVfbzb_dT) + + dCoxWLcenb_dT * (Vfbeff - Vfbzb); + else dQac0_dT = 0.0; + + T0 = 0.5 * pParam->B4SOIk1ox; + T3 = Vgs_eff - Vfbeff - Vbseff - Vgsteff; + if (pParam->B4SOIk1ox == 0.0) + { T1 = 0.0; + T2 = 0.0; + } + else if (T3 < 0.0) + { T1 = T0 + T3 / pParam->B4SOIk1ox; + T2 = CoxWLcenb; + } + else + { T1 = sqrt(T0 * T0 + T3); + T2 = CoxWLcenb * T0 / T1; + } + + Qsub0 = CoxWLcenb * pParam->B4SOIk1ox * (T1 - T0); + QovCox = Qsub0 / Coxeff; + dQsub0_dVg = T2 * (dVgs_eff_dVg - dVfbeff_dVg - dVgsteff_dVg) + + QovCox * dCoxeff_dVg; + dQsub0_dVd = -T2 * dVgsteff_dVd; + dQsub0_dVb = -T2 * (dVfbeff_dVb + 1 + dVgsteff_dVb) + + QovCox * dCoxeff_dVb; + if (selfheat) + dQsub0_dT = -T2 * (dVfbeff_dT + dVgsteff_dT) + + dCoxWLcenb_dT * pParam->B4SOIk1ox * (T1 - T0); + else dQsub0_dT = 0.0; + } +/* v3.1 */ + + + /* Gate-bias dependent delta Phis begins */ + if (pParam->B4SOIk1ox <= 0.0) + { Denomi = 0.25 * pParam->B4SOImoin * Vtm; + T0 = 0.5 * pParam->B4SOIsqrtPhi; + } + else + { Denomi = pParam->B4SOImoin * Vtm + * pParam->B4SOIk1ox * pParam->B4SOIk1ox; + T0 = pParam->B4SOIk1ox * pParam->B4SOIsqrtPhi; + } + T1 = 2.0 * T0 + Vgsteff; + + DeltaPhi = Vtm * log(1.0 + T1 * Vgsteff / Denomi); + dDeltaPhi_dVg = 2.0 * Vtm * (T1 -T0) / (Denomi + T1 * Vgsteff); + dDeltaPhi_dVd = dDeltaPhi_dVg * dVgsteff_dVd; + dDeltaPhi_dVb = dDeltaPhi_dVg * dVgsteff_dVb; + /* End of delta Phis */ + + +/* v3.1.1 bug fix for discontinuity */ + T3 = 4.0 * (Vth - Vfbzb - phi); + T2 = sqrt(T3*T3 + 0.0001); + T5 = 0.5 * (1 + T3/T2); + T4 = 0.5 * (T3 + T2); + + Tox += Tox; + T0 = (Vgsteff + T4) / Tox; + tmp = exp(0.7 * log(T0)); + T1 = 1.0 + tmp; + T2 = 0.7 * tmp / (T0 * Tox); + Tcen = 1.9e-9 / T1; + dTcen_dVg = -Tcen * T2 / T1; + dTcen_dVd = dTcen_dVg * (T5 * 4.0 * dVth_dVd + dVgsteff_dVd); + dTcen_dVb = dTcen_dVg * (T5 * 4.0 * dVth_dVb + dVgsteff_dVb); + dTcen_dVg *= dVgsteff_dVg; + if (selfheat) + dTcen_dT = -Tcen * T2 / T1 + * (T5 * 4.0 * (dVth_dT - dVfbzb_dT) + dVgsteff_dT); + else dTcen_dT = 0; + + + Ccen = EPSSI / Tcen; + T0 = Cox / (Cox + Ccen); + Coxeff = T0 * Ccen; + T1 = -Ccen / Tcen; + dCoxeff_dVg = T0 * T0 * T1; + dCoxeff_dVd = dCoxeff_dVg * dTcen_dVd; + dCoxeff_dVb = dCoxeff_dVg * dTcen_dVb; + dCoxeff_dVg *= dTcen_dVg; + if (selfheat) + dCoxeff_dT = T1 * dTcen_dT * (T0 - Coxeff / (Cox + Ccen)); + else dCoxeff_dT = 0; + CoxWLcen = CoxWL * Coxeff / Cox; + CoxWLcenb = CoxWLb * Coxeff / Cox; + + AbulkCV = Abulk0 * pParam->B4SOIabulkCVfactor; + dAbulkCV_dVb = pParam->B4SOIabulkCVfactor * dAbulk0_dVb; + VdsatCV = (Vgsteff - DeltaPhi) / AbulkCV; + V4 = VdsatCV - Vds - DELTA_4; + T0 = sqrt(V4 * V4 + 4.0 * DELTA_4 * VdsatCV); + VdseffCV = VdsatCV - 0.5 * (V4 + T0); + T1 = 0.5 * (1.0 + V4 / T0); + T2 = DELTA_4 / T0; + T3 = (1.0 - T1 - T2) / AbulkCV; + T4 = T3 * ( 1.0 - dDeltaPhi_dVg); + dVdseffCV_dVg = T4; + dVdseffCV_dVd = T1; + dVdseffCV_dVb = -T3 * VdsatCV * dAbulkCV_dVb; + + T0 = AbulkCV * VdseffCV; + T1 = Vgsteff - DeltaPhi; + T2 = 12.0 * (T1 - 0.5 * T0 + 1.0e-20); + T3 = T0 / T2; + T4 = 1.0 - 12.0 * T3 * T3; + T5 = AbulkCV * (6.0 * T0 * (4.0 * T1 - T0) / (T2 * T2) - 0.5); + T6 = T5 * VdseffCV / AbulkCV; + + qinv = qgate = qinoi = CoxWLcen * (T1 - T0 * (0.5 - T3)); + QovCox = qgate / Coxeff; + Cgg1 = CoxWLcen * (T4 * (1.0 - dDeltaPhi_dVg) + + T5 * dVdseffCV_dVg); + Cgd1 = CoxWLcen * T5 * dVdseffCV_dVd + Cgg1 + * dVgsteff_dVd + QovCox * dCoxeff_dVd; + Cgb1 = CoxWLcen * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb) + + Cgg1 * dVgsteff_dVb + QovCox * dCoxeff_dVb; + Cgg1 = Cgg1 * dVgsteff_dVg + QovCox * dCoxeff_dVg; + + +/* v3.1 */ + if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */ + { + qbulk = Cbg1 = Cbd1 = Cbb1 = 0; + } + else /* soiMod = 0 or 1 */ + { + T7 = 1.0 - AbulkCV; + T8 = T2 * T2; + T9 = 12.0 * T7 * T0 * T0 / (T8 * AbulkCV); + T10 = T9 * (1.0 - dDeltaPhi_dVg); + T11 = -T7 * T5 / AbulkCV; + T12 = -(T9 * T1 / AbulkCV + VdseffCV * (0.5 - T0 / T2)); + + qbulk = CoxWLcenb * T7 * (0.5 * VdseffCV - T0 * VdseffCV / T2); + QovCox = qbulk / Coxeff; + Cbg1 = CoxWLcenb * (T10 + T11 * dVdseffCV_dVg); + Cbd1 = CoxWLcenb * T11 * dVdseffCV_dVd + Cbg1 + * dVgsteff_dVd + QovCox * dCoxeff_dVd; + Cbb1 = CoxWLcenb * (T11 * dVdseffCV_dVb + T12 * dAbulkCV_dVb) + + Cbg1 * dVgsteff_dVb + QovCox * dCoxeff_dVb; + Cbg1 = Cbg1 * dVgsteff_dVg + QovCox * dCoxeff_dVg; + } +/* v3.1 */ + + + if (model->B4SOIxpart > 0.5) + { /* 0/100 partition */ + qsrc = -CoxWLcen * (T1 / 2.0 + T0 / 4.0 + - 0.5 * T0 * T0 / T2); + QovCox = qsrc / Coxeff; + T2 += T2; + T3 = T2 * T2; + T7 = -(0.25 - 12.0 * T0 * (4.0 * T1 - T0) / T3); + T4 = -(0.5 + 24.0 * T0 * T0 / T3) * (1.0 - dDeltaPhi_dVg); + T5 = T7 * AbulkCV; + T6 = T7 * VdseffCV; + + Csg = CoxWLcen * (T4 + T5 * dVdseffCV_dVg); + Csd = CoxWLcen * T5 * dVdseffCV_dVd + Csg * dVgsteff_dVd + + QovCox * dCoxeff_dVd; + Csb = CoxWLcen * (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb) + + Csg * dVgsteff_dVb + QovCox * dCoxeff_dVb; + Csg = Csg * dVgsteff_dVg + QovCox * dCoxeff_dVg; + } + else if (model->B4SOIxpart < 0.5) + { /* 40/60 partition */ + T2 = T2 / 12.0; + T3 = 0.5 * CoxWLcen / (T2 * T2); + T4 = T1 * (2.0 * T0 * T0 / 3.0 + T1 * (T1 - 4.0 + * T0 / 3.0)) - 2.0 * T0 * T0 * T0 / 15.0; + qsrc = -T3 * T4; + QovCox = qsrc / Coxeff; + T8 = 4.0 / 3.0 * T1 * (T1 - T0) + 0.4 * T0 * T0; + T5 = -2.0 * qsrc / T2 - T3 * (T1 * (3.0 * T1 - 8.0 + * T0 / 3.0) + 2.0 * T0 * T0 / 3.0); + T6 = AbulkCV * (qsrc / T2 + T3 * T8); + T7 = T6 * VdseffCV / AbulkCV; + + Csg = T5 * (1.0 - dDeltaPhi_dVg) + T6 * dVdseffCV_dVg; + Csd = Csg * dVgsteff_dVd + T6 * dVdseffCV_dVd + + QovCox * dCoxeff_dVd; + Csb = Csg * dVgsteff_dVb + T6 * dVdseffCV_dVb + + T7 * dAbulkCV_dVb + QovCox * dCoxeff_dVb; + Csg = Csg * dVgsteff_dVg + QovCox * dCoxeff_dVg; + } + else + { /* 50/50 partition */ + qsrc = -0.5 * qgate; + Csg = -0.5 * Cgg1; + Csd = -0.5 * Cgd1; + Csb = -0.5 * Cgb1; + } + + + /* Backgate charge */ +/* v3.1 */ + if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */ + { + Qe1 = Ce1b = Ce1e = Ce1T = dQe1_dT = 0; + } + else /* soiMod = 0 or 1 */ + { + CboxWL = pParam->B4SOIkb1 * model->B4SOIfbody * Cbox + * (pParam->B4SOIweffCV / here->B4SOInseg + * pParam->B4SOIleffCVbg + here->B4SOIaebcp); + Qe1 = CboxWL * (Vesfb - Vbs); + Ce1b = dQe1_dVb = -CboxWL; + Ce1e = dQe1_dVe = CboxWL; + if (selfheat) Ce1T = dQe1_dT = -CboxWL * dvfbb_dT; + else Ce1T = dQe1_dT = 0.0; + } +/* v3.1 */ + + + qgate += Qac0 + Qsub0 - qbulk; + qbody = qbulk - Qac0 - Qsub0 - Qe1; + qsub = Qe1; + qdrn = -(qgate + qbody + qsub + qsrc); + + Cbg = Cbg1 - dQac0_dVg - dQsub0_dVg; + Cbd = Cbd1 - dQsub0_dVd; + Cbb = Cbb1 - dQac0_dVb - dQsub0_dVb - Ce1b / dVbseff_dVb; + if (selfheat) + CbT = Cbg1 * dVgsteff_dT - dQac0_dT + - dQsub0_dT - dQe1_dT; + else CbT = 0.0; + + Cgg = Cgg1 - Cbg; + Cgd = Cgd1 - Cbd; + Cgb = Cgb1 - Cbb - Ce1b / dVbseff_dVb; + if (selfheat) + CgT = Cgg1 * dVgsteff_dT + dQac0_dT + + dQsub0_dT; + else CgT = 0.0; + + Cgb *= dVbseff_dVb; + Cbb *= dVbseff_dVb; + Csb *= dVbseff_dVb; + if (selfheat) CsT = Csg * dVgsteff_dT; + else CsT = 0.0; + + here->B4SOIcggb = Cgg; + here->B4SOIcgsb = -(Cgg + Cgd + Cgb); + here->B4SOIcgdb = Cgd; + here->B4SOIcgT = CgT; + + here->B4SOIcbgb = Cbg; + here->B4SOIcbsb = -(Cbg + Cbd + Cbb) + + Ce1e; + here->B4SOIcbdb = Cbd; + here->B4SOIcbeb = -Ce1e; + here->B4SOIcbT = CbT; + + here->B4SOIceT = Ce1T; + here->B4SOIceeb = Ce1e ; + + here->B4SOIcdgb = -(Cgg + Cbg + Csg); + here->B4SOIcddb = -(Cgd + Cbd + Csd); + here->B4SOIcdeb = 0; + here->B4SOIcdT = -(CgT+CbT+CsT) - Ce1T; + here->B4SOIcdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb + + Csg + Csd + Csb) + Ce1b; + here->B4SOIqinv = -qinoi; + + } /* End of if capMod ==3 */ + else { /* v4.0 */ + Qsub0 = Qac0 = 0.0; + qgate = qdrn = qsrc = qbody = qsub = 0.0; + Cbg = Cbd = Cbb = 0.0; + here->B4SOIcggb = here->B4SOIcgsb + = here->B4SOIcgdb = 0.0; + here->B4SOIcdgb = here->B4SOIcdsb + = here->B4SOIcddb = 0.0; + here->B4SOIcbgb = here->B4SOIcbsb + = here->B4SOIcbdb = 0.0; + } + } + here->B4SOIqgate = qgate; + here->B4SOIqdrn = qdrn; + here->B4SOIqbulk = qbody; + here->B4SOIqsrc = qsrc; + + + + finished: /* returning Values to Calling Routine */ + /* + * COMPUTE EQUIVALENT DRAIN CURRENT SOURCE + */ + if (ChargeComputationNeeded) + { + /* Intrinsic S/D junction charge */ + +/* v3.1 */ + if (here->B4SOIsoiMod == 2) /* v3.2 */ /* ideal FD */ + { + qjs = qjd = 0.0; + gcjdds = gcjdbs = gcjdT = 0.0; + gcjsbs = gcjsT = 0.0; + here->B4SOIcjsb = here->B4SOIcjdb = 0.0 /*v4.0*/; + + } + else /* soiMod = 0 or 1 */ + { + PhiBSWG = model->B4SOIGatesidewallJctSPotential; + dPhiBSWG_dT = -model->B4SOItpbswg; + PhiBSWG += dPhiBSWG_dT * (Temp - model->B4SOItnom); + MJSWG = model->B4SOIbodyJctGateSideSGradingCoeff; + + cjsbs = model->B4SOIunitLengthGateSidewallJctCapS + * wdiosCV * model->B4SOItsi / 1e-7; + dcjsbs_dT = cjsbs * model->B4SOItcjswg; + cjsbs += dcjsbs_dT * (Temp - model->B4SOItnom); + + cjdbs = model->B4SOIunitLengthGateSidewallJctCapD + * wdiodCV * model->B4SOItsi / 1e-7; + dcjdbs_dT = cjdbs * model->B4SOItcjswgd; + cjdbs += dcjdbs_dT * (Temp - model->B4SOItnom); + + DioMax = 0.9 * (PhiBSWG); + + arg = 1.0 - (Vbs > DioMax ? DioMax : Vbs) / PhiBSWG; + + if (selfheat) + darg_dT = (1 - arg) / PhiBSWG * dPhiBSWG_dT; + + if (MJSWG == 0.5) { + dT3_dVb = 1.0 / sqrt(arg); + + if (selfheat) ddT3_dVb_dT = -0.5 * dT3_dVb / arg * darg_dT; + } + else { + dT3_dVb = exp(-MJSWG * log(arg)); + + if (selfheat) ddT3_dVb_dT = -MJSWG * dT3_dVb / arg * darg_dT; + } + T3 = (1.0 - arg * dT3_dVb) * PhiBSWG / (1.0 - MJSWG); + + if (selfheat) + dT3_dT = (1.0 - arg * dT3_dVb) * dPhiBSWG_dT / (1.0 - MJSWG) + - (arg * ddT3_dVb_dT + darg_dT * dT3_dVb) * PhiBSWG / (1.0 - MJSWG); + + if (Vbs > DioMax) + T3 += dT3_dVb * (Vbs - DioMax); + + qjs = cjsbs * T3 + model->B4SOItt * Ibsdif; + gcjsbs = cjsbs * dT3_dVb + model->B4SOItt * dIbsdif_dVb; + + if (selfheat) + gcjsT = model->B4SOItt * dIbsdif_dT + dcjsbs_dT * T3 + dT3_dT * cjsbs; + else gcjsT = 0.0; + + PhiBSWG = model->B4SOIGatesidewallJctDPotential; + dPhiBSWG_dT = -model->B4SOItpbswgd; + PhiBSWG += dPhiBSWG_dT * (Temp - model->B4SOItnom); + MJSWG = model->B4SOIbodyJctGateSideDGradingCoeff; + + DioMax = 0.9 * (PhiBSWG); + + arg = 1.0 - (Vbd > DioMax ? DioMax : Vbd) / PhiBSWG; + + if (selfheat) + darg_dT = (1 - arg) / PhiBSWG * dPhiBSWG_dT; + + if (MJSWG == 0.5) { + dT3_dVb = 1.0 / sqrt(arg); + + if (selfheat) ddT3_dVb_dT = -0.5 * dT3_dVb / arg * darg_dT; + } + else { + dT3_dVb = exp(-MJSWG * log(arg)); + + if (selfheat) ddT3_dVb_dT = -MJSWG * dT3_dVb / arg * darg_dT; + } + T3 = (1.0 - arg * dT3_dVb) * PhiBSWG / (1.0 - MJSWG); + + if (selfheat) + dT3_dT = (1.0 - arg * dT3_dVb) * dPhiBSWG_dT / (1.0 - MJSWG) + - (arg * ddT3_dVb_dT + darg_dT * dT3_dVb) * PhiBSWG / (1.0 - MJSWG); + + if (Vbd > DioMax) + T3 += dT3_dVb * (Vbd - DioMax); + + dT3_dVd = -dT3_dVb; + + qjd = cjdbs * T3 + model->B4SOItt * Ibddif; + gcjdbs = cjdbs * dT3_dVb + model->B4SOItt * dIbddif_dVb; + gcjdds = cjdbs * dT3_dVd + model->B4SOItt * dIbddif_dVd; + if (selfheat) + gcjdT = model->B4SOItt * dIbddif_dT + dcjdbs_dT * T3 + dT3_dT * cjdbs; + else gcjdT = 0.0; + } +/* v3.1 */ + + /* v4.0 */ +/* qdrn -= qjd; + qbody += (qjs + qjd); + qsrc = -(qgate + qbody + qdrn + qsub); +*/ + + /* Update the conductance */ + here->B4SOIcddb -= gcjdds; + here->B4SOIcdT -= gcjdT; + here->B4SOIcdsb += gcjdds + gcjdbs; + + + here->B4SOIcbdb += (gcjdds); + here->B4SOIcbT += (gcjdT + gcjsT); + here->B4SOIcbsb -= (gcjdds + gcjdbs + gcjsbs); + + here->B4SOIcjsb = (gcjdds + gcjdbs + gcjsbs); /* v4.0 */ + here->B4SOIcjdb = -gcjdds; /* v4.0 */ + + /* Extrinsic Bottom S/D to substrate charge */ + T10 = -model->B4SOItype * ves; + /* T10 is vse without type conversion */ + T11 = model->B4SOItype * (vds - ves); + /* T11 is vde without type conversion */ + + if (model->B4SOIcsdmin != 0.0) + { + if ( ((pParam->B4SOInsub > 0) && (model->B4SOItype > 0)) || + ((pParam->B4SOInsub < 0) && (model->B4SOItype < 0)) ) + { + if (T10 < pParam->B4SOIvsdfb) + { here->B4SOIqse = here->B4SOIcsbox * (T10 - pParam->B4SOIvsdfb); + here->B4SOIgcse = here->B4SOIcsbox; + } + else if (T10 < pParam->B4SOIsdt1) + { T0 = T10 - pParam->B4SOIvsdfb; + T1 = T0 * T0; + here->B4SOIqse = T0 * (here->B4SOIcsbox - + pParam->B4SOIst2 / 3 * T1) ; + here->B4SOIgcse = here->B4SOIcsbox - pParam->B4SOIst2 * T1; + } + else if (T10 < pParam->B4SOIvsdth) + { T0 = T10 - pParam->B4SOIvsdth; + T1 = T0 * T0; + here->B4SOIqse = here->B4SOIcsmin * T10 + here->B4SOIst4 + + pParam->B4SOIst3 / 3 * T0 * T1; + here->B4SOIgcse = here->B4SOIcsmin + pParam->B4SOIst3 * T1; + } + else + { here->B4SOIqse = here->B4SOIcsmin * T10 + here->B4SOIst4; + here->B4SOIgcse = here->B4SOIcsmin; + } + } else + { + if (T10 < pParam->B4SOIvsdth) + { here->B4SOIqse = here->B4SOIcsmin * (T10 - pParam->B4SOIvsdth); + here->B4SOIgcse = here->B4SOIcsmin; + } + else if (T10 < pParam->B4SOIsdt1) + { T0 = T10 - pParam->B4SOIvsdth; + T1 = T0 * T0; + here->B4SOIqse = T0 * (here->B4SOIcsmin - pParam->B4SOIst2 / 3 * T1) ; + here->B4SOIgcse = here->B4SOIcsmin - pParam->B4SOIst2 * T1; + } + else if (T10 < pParam->B4SOIvsdfb) + { T0 = T10 - pParam->B4SOIvsdfb; + T1 = T0 * T0; + here->B4SOIqse = here->B4SOIcsbox * T10 + here->B4SOIst4 + + pParam->B4SOIst3 / 3 * T0 * T1; + here->B4SOIgcse = here->B4SOIcsbox + pParam->B4SOIst3 * T1; + } + else + { here->B4SOIqse = here->B4SOIcsbox * T10 + here->B4SOIst4; + here->B4SOIgcse = here->B4SOIcsbox; + } + } + + if ( ((pParam->B4SOInsub > 0) && (model->B4SOItype > 0)) || + ((pParam->B4SOInsub < 0) && (model->B4SOItype < 0)) ) + { + if (T11 < pParam->B4SOIvsdfb) + { here->B4SOIqde = here->B4SOIcdbox * (T11 - pParam->B4SOIvsdfb); + here->B4SOIgcde = here->B4SOIcdbox; + } + else if (T11 < pParam->B4SOIsdt1) + { T0 = T11 - pParam->B4SOIvsdfb; + T1 = T0 * T0; + here->B4SOIqde = T0 * (here->B4SOIcdbox - pParam->B4SOIdt2 / 3 * T1) ; + here->B4SOIgcde = here->B4SOIcdbox - pParam->B4SOIdt2 * T1; + } + else if (T11 < pParam->B4SOIvsdth) + { T0 = T11 - pParam->B4SOIvsdth; + T1 = T0 * T0; + here->B4SOIqde = here->B4SOIcdmin * T11 + here->B4SOIdt4 + + pParam->B4SOIdt3 / 3 * T0 * T1; + here->B4SOIgcde = here->B4SOIcdmin + pParam->B4SOIdt3 * T1; + } + else + { here->B4SOIqde = here->B4SOIcdmin * T11 + here->B4SOIdt4; + here->B4SOIgcde = here->B4SOIcdmin; + } + } else + { + if (T11 < pParam->B4SOIvsdth) + { here->B4SOIqde = here->B4SOIcdmin * (T11 - pParam->B4SOIvsdth); + here->B4SOIgcde = here->B4SOIcdmin; + } + else if (T11 < pParam->B4SOIsdt1) + { T0 = T11 - pParam->B4SOIvsdth; + T1 = T0 * T0; + here->B4SOIqde = T0 * (here->B4SOIcdmin - pParam->B4SOIdt2 / 3 * T1) ; + here->B4SOIgcde = here->B4SOIcdmin - pParam->B4SOIdt2 * T1; + } + else if (T11 < pParam->B4SOIvsdfb) + { T0 = T11 - pParam->B4SOIvsdfb; + T1 = T0 * T0; + here->B4SOIqde = here->B4SOIcdbox * T11 + here->B4SOIdt4 + + pParam->B4SOIdt3 / 3 * T0 * T1; + here->B4SOIgcde = here->B4SOIcdbox + pParam->B4SOIdt3 * T1; + } + else + { here->B4SOIqde = here->B4SOIcdbox * T11 + here->B4SOIdt4; + here->B4SOIgcde = here->B4SOIcdbox; + } + } + } + else { + here->B4SOIqse = here->B4SOIcsbox * T10; + here->B4SOIgcse = here->B4SOIcsbox; + here->B4SOIqde = here->B4SOIcdbox * T11; + here->B4SOIgcde = here->B4SOIcdbox; + } + + /* Extrinsic : Sidewall fringing S/D charge */ + here->B4SOIqse += here->B4SOIcsesw * T10; + here->B4SOIgcse += here->B4SOIcsesw; + here->B4SOIqde += here->B4SOIcdesw * T11; + here->B4SOIgcde += here->B4SOIcdesw; + + /* All charge are mutliplied with type at the end, but qse and qde + have true polarity => so pre-mutliplied with type */ + here->B4SOIqse *= model->B4SOItype; + here->B4SOIqde *= model->B4SOItype; + } + else { /* v4.0 */ + qjs = qjd = 0.0; + here->B4SOIqse = here->B4SOIqde = 0.0; + here->B4SOIgcse = here->B4SOIgcde = 0.0; + } + + here->B4SOIcbb = Cbb; + here->B4SOIcbd = Cbd; + here->B4SOIcbg = Cbg; + here->B4SOIqbf = -Qsub0 - Qac0; + here->B4SOIqjs = qjs; + here->B4SOIqjd = qjd; + *(ckt->CKTstate0 + here->B4SOIqbs) = qjs; /* v4.0 */ + *(ckt->CKTstate0 + here->B4SOIqbd) = qjd; /* v4.0 */ + + /* + * check convergence + */ + if ((here->B4SOIoff == 0) || (!(ckt->CKTmode & MODEINITFIX))) + { if (Check == 1) + { ckt->CKTnoncon++; +#ifndef NEWCONV + } + else + { tol = ckt->CKTreltol * MAX(fabs(cdhat), fabs(here->B4SOIcd)) + + ckt->CKTabstol; + if (fabs(cdhat - here->B4SOIcd) >= tol) + { ckt->CKTnoncon++; + } + else + { tol = ckt->CKTreltol * MAX(fabs(cbhat), + fabs(here->B4SOIcbs + here->B4SOIcbd)) + + ckt->CKTabstol; + if (fabs(cbhat - (here->B4SOIcbs + here->B4SOIcbd)) + > tol) + { ckt->CKTnoncon++; + } + } +#endif /* NEWCONV */ + } + } + + *(ckt->CKTstate0 + here->B4SOIvg) = vg; + *(ckt->CKTstate0 + here->B4SOIvd) = vd; + *(ckt->CKTstate0 + here->B4SOIvs) = vs; + *(ckt->CKTstate0 + here->B4SOIvp) = vp; + *(ckt->CKTstate0 + here->B4SOIve) = ve; + + *(ckt->CKTstate0 + here->B4SOIvbs) = vbs; + *(ckt->CKTstate0 + here->B4SOIvbd) = vbd; + *(ckt->CKTstate0 + here->B4SOIvgs) = vgs; + *(ckt->CKTstate0 + here->B4SOIvds) = vds; + *(ckt->CKTstate0 + here->B4SOIves) = ves; + *(ckt->CKTstate0 + here->B4SOIvps) = vps; + *(ckt->CKTstate0 + here->B4SOIdeltemp) = delTemp; + + /* v3.1 added for RF */ + *(ckt->CKTstate0 + here->B4SOIvgge) = vgge; + *(ckt->CKTstate0 + here->B4SOIvggm) = vggm; + *(ckt->CKTstate0 + here->B4SOIvges) = vges; + *(ckt->CKTstate0 + here->B4SOIvgms) = vgms; + /* v3.1 added for RF end*/ + *(ckt->CKTstate0 + here->B4SOIvdbs) = vdbs; /* v4.0 */ + *(ckt->CKTstate0 + here->B4SOIvdbd) = vdbd; /* v4.0 */ + *(ckt->CKTstate0 + here->B4SOIvsbs) = vsbs; /* v4.0 */ + *(ckt->CKTstate0 + here->B4SOIvses) = vses; + *(ckt->CKTstate0 + here->B4SOIvdes) = vdes; + + /* bulk and channel charge plus overlaps */ + + if (!ChargeComputationNeeded) + goto line850; + + line755: + ag0 = ckt->CKTag[0]; + + T0 = vgd + DELTA_1; + if (here->B4SOIrgateMod == 3) T0 = vgmd + DELTA_1; /* v3.2 bug fix */ + T1 = sqrt(T0 * T0 + 4.0 * DELTA_1); + T2 = 0.5 * (T0 - T1); + +/* v2.2.3 bug fix */ + T3 = wdiodCV_NoSwap * pParam->B4SOIcgdl; /* v3.1 bug fix */ + + T4 = sqrt(1.0 - 4.0 * T2 / pParam->B4SOIckappa); + cgdo = pParam->B4SOIcgdo + T3 - T3 * (1.0 - 1.0 / T4) + * (0.5 - 0.5 * T0 / T1); + qgdo = (pParam->B4SOIcgdo + T3) * vgd - T3 * (T2 + + 0.5 * pParam->B4SOIckappa * (T4 - 1.0)); + + if (here->B4SOIrgateMod == 3) { + qgdo = (pParam->B4SOIcgdo + T3) * vgmd - T3 * (T2 + + 0.5 * pParam->B4SOIckappa * (T4 - 1.0)); + } /* v3.2 bug fix */ + + T0 = vgs + DELTA_1; + if (here->B4SOIrgateMod == 3) T0 = vgms + DELTA_1; /* v3.2 bug fix */ + T1 = sqrt(T0 * T0 + 4.0 * DELTA_1); + T2 = 0.5 * (T0 - T1); + +/* v2.2.3 bug fix */ + T3 = wdiosCV_NoSwap * pParam->B4SOIcgsl; /* v3.1 bug fix */ + + T4 = sqrt(1.0 - 4.0 * T2 / pParam->B4SOIckappa); + cgso = pParam->B4SOIcgso + T3 - T3 * (1.0 - 1.0 / T4) + * (0.5 - 0.5 * T0 / T1); + qgso = (pParam->B4SOIcgso + T3) * vgs - T3 * (T2 + + 0.5 * pParam->B4SOIckappa * (T4 - 1.0)); + + if (here->B4SOIrgateMod == 3) { + qgso = (pParam->B4SOIcgso + T3) * vgms - T3 * (T2 + + 0.5 * pParam->B4SOIckappa * (T4 - 1.0)); + } /* v3.2 bug fix */ + + if (here->B4SOInf != 1.0) + { cgdo *= here->B4SOInf; + cgso *= here->B4SOInf; + qgdo *= here->B4SOInf; + qgso *= here->B4SOInf; + } +/* here->B4SOIcgdo = cgdo; + here->B4SOIcgso = cgso; +*/ + if (here->B4SOIdebugMod < 0) + goto line850; + + + if (here->B4SOImode > 0) + { + + /* v3.1 added for RF */ + if (here->B4SOIrgateMod == 3) + { + gcgmgmb = (cgdo + cgso + pParam->B4SOIcgeo) * ag0; + + gcgmdb = -cgdo * ag0; + gcgmsb = -cgso * ag0; + gcgmeb = -pParam->B4SOIcgeo * ag0; + gcdgmb = gcgmdb; + gcsgmb = gcgmsb; + gcegmb = gcgmeb; + + gcggb = here->B4SOIcggb * ag0; + gcgdb = here->B4SOIcgdb * ag0; + gcgsb = here->B4SOIcgsb * ag0; + gcgeb = 0 ;/*v3.1 changed*/ + gcgbb = -(gcggb + gcgdb + gcgsb + gcgeb); + + gcdgb = here->B4SOIcdgb * ag0; + gcegb = gcgeb; /*v3.1 added*/ + gcsgb = -(here->B4SOIcggb + here->B4SOIcbgb + + here->B4SOIcdgb) * ag0 - gcegb; + gcbgb = here->B4SOIcbgb * ag0; + + qgd = qgdo; + qgs = qgso; + qge = 0; /* v3.1 change */ + + qgme = pParam->B4SOIcgeo * vgme; + qgmid = qgdo + qgso + qgme; + qdrn += here->B4SOIqde - qgd; + qsub -= qgme + here->B4SOIqse + here->B4SOIqde; + qsrc = -(qgate + qgmid + qbody + qdrn + qsub) - qjs; + qdrn -= qjd; + if (!here->B4SOIrbodyMod) qbody += qjd + qjs; + + } + else + { + gcggb = (here->B4SOIcggb + cgdo + cgso + + pParam->B4SOIcgeo) * ag0; + gcgdb = (here->B4SOIcgdb - cgdo) * ag0; + gcgsb = (here->B4SOIcgsb - cgso) * ag0; + gcgeb = (-pParam->B4SOIcgeo) *ag0; + gcgbb = -(gcggb + gcgdb + gcgsb + gcgeb); + + gcegb = (- pParam->B4SOIcgeo) * ag0; + gcdgb = (here->B4SOIcdgb - cgdo) * ag0; + gcsgb = -(here->B4SOIcggb + here->B4SOIcbgb + + here->B4SOIcdgb + cgso) * ag0; + gcbgb = here->B4SOIcbgb * ag0; + + gcdgmb = gcsgmb = gcegmb = 0.0; + gcgmdb = gcgmsb = gcgmeb = 0.0; + + /* Lump the overlap capacitance and S/D parasitics */ + qgd = qgdo; + qgs = qgso; + qge = pParam->B4SOIcgeo * vge; + qgate += qgd + qgs + qge; + qdrn += here->B4SOIqde - qgd; + qsub -= qge + here->B4SOIqse + here->B4SOIqde; + qsrc = -(qgate + qbody + qdrn + qsub) - qjs; + qdrn -= qjd; + if (!here->B4SOIrbodyMod) qbody += qjd + qjs; + } + + gcddb = (here->B4SOIcddb + cgdo + here->B4SOIgcde) * ag0; + gcdsb = here->B4SOIcdsb * ag0; + gcdeb = (here->B4SOIcdeb - here->B4SOIgcde) * ag0; + gcdT = model->B4SOItype * here->B4SOIcdT * ag0; + + gcsdb = -(here->B4SOIcgdb + here->B4SOIcbdb + + here->B4SOIcddb) * ag0; + gcssb = (cgso + here->B4SOIgcse - (here->B4SOIcgsb + + here->B4SOIcbsb + here->B4SOIcdsb)) * ag0; + gcseb = -(here->B4SOIgcse + here->B4SOIcbeb + + here->B4SOIcdeb + here->B4SOIceeb) * ag0; + gcsT = - model->B4SOItype * (here->B4SOIcgT + + here->B4SOIcbT + here->B4SOIcdT + here->B4SOIceT) + * ag0; + + gcgT = model->B4SOItype * here->B4SOIcgT * ag0; + +/* gcbdb = here->B4SOIcbdb * ag0; + gcbsb = here->B4SOIcbsb * ag0; +*/ + gcbeb = here->B4SOIcbeb * ag0; + gcbT = model->B4SOItype * here->B4SOIcbT * ag0; + + /* v4.0 */ + if (!here->B4SOIrbodyMod) + { + gcjdbdp = gcjsbsp = 0.0; + gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb + gcdeb); + gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb + gcseb); + gcdbdb = gcsbsb = 0.0; + gcbdb = here->B4SOIcbdb * ag0; + gcbsb = here->B4SOIcbsb * ag0; + here->B4SOIGGjdb = GGjdb = 0.0; + here->B4SOIGGjsb = GGjsb = 0.0; + } + else + { + gcjdbdp = gcjdbs * ag0; + gcjsbsp = gcjsbs * ag0; + gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb + gcdeb) + + gcjdbdp; + gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb + gcseb) + + gcjsbsp; + gcdbdb = gcjdds * ag0; + gcsbsb = -(gcjdds + gcjdbs + gcjsbs) * ag0; + gcbdb = here->B4SOIcbdb * ag0 - gcdbdb; + gcbsb = here->B4SOIcbsb * ag0 - gcsbsb; + here->B4SOIGGjdb = GGjdb = Gjdb; + here->B4SOIGGjsb = GGjsb = Gjsb; + } + /* v4.0 end */ + + gcedb = (- here->B4SOIgcde) * ag0; + gcesb = (- here->B4SOIgcse) * ag0; + gceeb = (here->B4SOIgcse + here->B4SOIgcde + + here->B4SOIceeb + pParam->B4SOIcgeo) * ag0; + + gceT = model->B4SOItype * here->B4SOIceT * ag0; + + gcTt = pParam->B4SOIcth * ag0; + + sxpart = 0.6; + dxpart = 0.4; + + +/* v3.1 moved the following original code ahead */ + /* Lump the overlap capacitance and S/D parasitics */ +/* qgd = qgdo; + qgs = qgso; + qge = pParam->B4SOIcgeo * vge; + qgate += qgd + qgs + qge; + qdrn += here->B4SOIqde - qgd; + qsub -= qge + here->B4SOIqse + here->B4SOIqde; + qsrc = -(qgate + qbody + qdrn + qsub); +*/ +/* v3.1 end */ + + } + + else + { + if (here->B4SOIrgateMod == 3) + { + gcgmgmb = (cgdo + cgso + pParam->B4SOIcgeo) * ag0; + gcgmdb = -cgdo * ag0; + gcgmsb = -cgso * ag0; + gcgmeb = -pParam->B4SOIcgeo * ag0; + gcdgmb = gcgmdb; + gcsgmb = gcgmsb; + gcegmb = gcgmeb; + + gcggb = here->B4SOIcggb * ag0; + gcgsb = here->B4SOIcgdb * ag0; + gcgdb = here->B4SOIcgsb * ag0; + gcgeb = 0; /* v3.1 */ + gcgbb = -(gcggb + gcgdb + gcgsb + gcgeb); /* v3.1 added gcgeb */ + + gcsgb = here->B4SOIcdgb * ag0; + gcegb = gcgeb; /* v3.1 added */ + gcdgb = -(here->B4SOIcggb + here->B4SOIcbgb + + here->B4SOIcdgb) * ag0 - gcegb; /*v3.1 added gcegb*/ + gcbgb = here->B4SOIcbgb * ag0; + + qgd = qgdo; + qgs = qgso; + qge = 0; /* v3.1 */ + qgme = pParam->B4SOIcgeo * vgme; + qgmid = qgdo + qgso + qgme; + qgate += qge; + qbody -= 0; + qsrc = qdrn - qgs + here->B4SOIqse; + qsub -= qgme + here->B4SOIqse + here->B4SOIqde; + qdrn = -(qgate + qgmid + qbody + qsrc + qsub) -qjd; + qsrc -= qjs; + if (!here->B4SOIrbodyMod) qbody += qjs + qjd; + } + else + { + gcggb = (here->B4SOIcggb + cgdo + cgso + pParam->B4SOIcgeo) * ag0; + gcgdb = (here->B4SOIcgsb - cgdo) * ag0; + gcgsb = (here->B4SOIcgdb - cgso) * ag0; + gcgeb = (- pParam->B4SOIcgeo) * ag0; + gcgbb = -(gcggb + gcgdb + gcgsb + gcgeb); /*added gcgbb*/ + + gcegb = gcgeb; /* v3.1 added */ + gcsgb = (here->B4SOIcdgb - cgso) * ag0; + gcdgb = -(here->B4SOIcggb + here->B4SOIcbgb + here->B4SOIcdgb + cgdo) * ag0; + gcbgb = here->B4SOIcbgb * ag0; + + gcdgmb = gcsgmb = gcegmb = 0.0; + gcgmdb = gcgmsb = gcgmeb = 0.0; + + /* Lump the overlap capacitance and S/D parasitics */ + qgd = qgdo; + qgs = qgso; + qge = pParam->B4SOIcgeo * vge; + qgate += qgd + qgs + qge; + qsrc = qdrn - qgs + here->B4SOIqse; + qsub -= qge + here->B4SOIqse + here->B4SOIqde; + qdrn = -(qgate + qbody + qsrc + qsub) - qjd; + qsrc -= qjs; + if (!here->B4SOIrbodyMod) qbody += qjs + qjd; + } + + gcssb = (here->B4SOIcddb + cgso + here->B4SOIgcse) * ag0; + gcsdb = here->B4SOIcdsb * ag0; + gcseb = (here->B4SOIcdeb - here->B4SOIgcse) * ag0; + gcsT = model->B4SOItype * here->B4SOIcdT * ag0; + + gcdsb = -(here->B4SOIcgdb + here->B4SOIcbdb + + here->B4SOIcddb) * ag0; + gcddb = (cgdo + here->B4SOIgcde - (here->B4SOIcgsb + + here->B4SOIcbsb + here->B4SOIcdsb)) * ag0; + gcdeb = -(here->B4SOIgcde + here->B4SOIcbeb + + here->B4SOIcdeb + here->B4SOIceeb) * ag0; + gcdT = - model->B4SOItype * (here->B4SOIcgT + + here->B4SOIcbT + here->B4SOIcdT + here->B4SOIceT) + * ag0; + + gcgT = model->B4SOItype * here->B4SOIcgT * ag0; + + gcbeb = here->B4SOIcbeb * ag0; + gcbT = model->B4SOItype * here->B4SOIcbT * ag0; +/* v4.0 gcbsb = here->B4SOIcbdb * ag0; + gcbdb = here->B4SOIcbsb * ag0; +*/ + + /* v4.0 */ + if (!here->B4SOIrbodyMod) + { + gcjdbdp = gcjsbsp = 0.0; + gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb + gcdeb); + gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb + gcseb); + gcdbdb = gcsbsb = 0.0; + gcbdb = here->B4SOIcbsb * ag0; + gcbsb = here->B4SOIcbdb * ag0; + here->B4SOIGGjdb = GGjdb = 0.0; + here->B4SOIGGjsb = GGjsb = 0.0; + } + else + { + gcjdbdp = gcjsbs * ag0; + gcjsbsp = gcjdbs * ag0; + gcdbb = -(gcdgb + gcddb + gcdsb + gcdgmb + gcdeb) + + gcjdbdp; + gcsbb = -(gcsgb + gcsdb + gcssb + gcsgmb + gcseb) + + gcjsbsp; + gcsbsb = gcjdds * ag0; + gcdbdb = -(gcjdds + gcjdbs + gcjsbs) * ag0; + gcbdb = here->B4SOIcbsb * ag0 - gcdbdb; + gcbsb = here->B4SOIcbdb * ag0 - gcsbsb; + here->B4SOIGGjdb = GGjdb = Gjsb; + here->B4SOIGGjsb = GGjsb = Gjdb; + } + /* v4.0 end */ + +/* gcegb = (-pParam->B4SOIcgeo) * ag0; V3.2 bug fix */ + gcesb = (- here->B4SOIgcse) * ag0; + gcedb = (- here->B4SOIgcde) * ag0; + gceeb = (here->B4SOIceeb + pParam->B4SOIcgeo + + here->B4SOIgcse + here->B4SOIgcde) * ag0; + gceT = model->B4SOItype * here->B4SOIceT * ag0; + + gcTt = pParam->B4SOIcth * ag0; + + dxpart = 0.6; + sxpart = 0.4; + + + /* v3.1 moved the following code ahead */ + /* Lump the overlap capacitance */ + /* + qgd = qgdo; + gs = qgso; + qge = pParam->B4SOIcgeo * vge; + qgate += qgd + qgs + qge; + qsrc = qdrn - qgs + here->B4SOIqse; + qsub -= qge + here->B4SOIqse + here->B4SOIqde; + qdrn = -(qgate + qbody + qsrc + qsub); + */ + /* v3.1 end */ + + + } + + here->B4SOIcgdo = cgdo; + here->B4SOIcgso = cgso; + + if (ByPass) goto line860; + + *(ckt->CKTstate0 + here->B4SOIqe) = qsub; + *(ckt->CKTstate0 + here->B4SOIqg) = qgate; + *(ckt->CKTstate0 + here->B4SOIqd) = qdrn; + *(ckt->CKTstate0 + here->B4SOIqb) = qbody; + if ((model->B4SOIshMod == 1) && (here->B4SOIrth0!=0.0)) + *(ckt->CKTstate0 + here->B4SOIqth) = pParam->B4SOIcth * delTemp; + if (here->B4SOIrgateMod == 3) /* 3.1 bug fix */ + *(ckt->CKTstate0 + here->B4SOIqgmid) = qgmid; + + + /* store small signal parameters */ + if (ckt->CKTmode & MODEINITSMSIG) + { goto line1000; + } + if (!ChargeComputationNeeded) + goto line850; + + + if (ckt->CKTmode & MODEINITTRAN) + { *(ckt->CKTstate1 + here->B4SOIqb) = + *(ckt->CKTstate0 + here->B4SOIqb); + *(ckt->CKTstate1 + here->B4SOIqg) = + *(ckt->CKTstate0 + here->B4SOIqg); + *(ckt->CKTstate1 + here->B4SOIqd) = + *(ckt->CKTstate0 + here->B4SOIqd); + *(ckt->CKTstate1 + here->B4SOIqe) = + *(ckt->CKTstate0 + here->B4SOIqe); + *(ckt->CKTstate1 + here->B4SOIqth) = + *(ckt->CKTstate0 + here->B4SOIqth); + if (here->B4SOIrgateMod == 3) + *(ckt->CKTstate1 + here->B4SOIqgmid) = + *(ckt->CKTstate0 + here->B4SOIqgmid); + if (here->B4SOIrbodyMod) /* v4.0 */ + { *(ckt->CKTstate1 + here->B4SOIqbs) = + *(ckt->CKTstate0 + here->B4SOIqbs); + *(ckt->CKTstate1 + here->B4SOIqbd) = + *(ckt->CKTstate0 + here->B4SOIqbd); + } + + } + + error = NIintegrate(ckt, &geq, &ceq,0.0,here->B4SOIqb); + if (error) return(error); + error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B4SOIqg); + if (error) return(error); + error = NIintegrate(ckt,&geq, &ceq, 0.0, here->B4SOIqd); + if (error) return(error); + error = NIintegrate(ckt,&geq, &ceq, 0.0, here->B4SOIqe); + if (error) return(error); + if ((model->B4SOIshMod == 1) && (here->B4SOIrth0!=0.0)) + { + error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B4SOIqth); + if (error) return (error); + } + + if (here->B4SOIrgateMod == 3) + { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B4SOIqgmid); + if (error) return(error); + } /*3.1 bug fix*/ + + if (here->B4SOIrbodyMod) /* v4.0 */ + { error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B4SOIqbs); + if (error) return(error); + error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B4SOIqbd); + if (error) return(error); + } + + goto line860; + + line850: + /* initialize to zero charge conductance and current */ + ceqqe = ceqqg = ceqqb = ceqqd = ceqqth= 0.0; + + gcdgb = gcddb = gcdsb = gcdeb = gcdT = 0.0; + gcsgb = gcsdb = gcssb = gcseb = gcsT = 0.0; + gcggb = gcgdb = gcgsb = gcgeb = gcgT = 0.0; + gcbgb = gcbdb = gcbsb = gcbeb = gcbT = 0.0; + gcegb = gcedb = gceeb = gcesb = gceT = 0.0; + gcTt = 0.0; + + /* v3.1 added for RF */ + gcgmgmb = gcgmdb = gcgmsb = gcgmeb = 0.0; + gcdgmb = gcsgmb = gcegmb = ceqqgmid = 0.0; + gcgbb = 0.0; + /* v3.1 added for RF end */ + + gcdbdb = gcsbsb = gcjdbdp = gcjsbsp = 0.0; /* v4.0 */ + ceqqjd = ceqqjs = 0.0; /* v4.0 */ + GGjdb = GGjsb = 0.0; /* v4.0 */ + + sxpart = (1.0 - (dxpart = (here->B4SOImode > 0) ? 0.4 : 0.6)); + + goto line900; + + line860: + /* evaluate equivalent charge current */ + + cqgate = *(ckt->CKTstate0 + here->B4SOIcqg); + cqbody = *(ckt->CKTstate0 + here->B4SOIcqb); + cqdrn = *(ckt->CKTstate0 + here->B4SOIcqd); + cqsub = *(ckt->CKTstate0 + here->B4SOIcqe); + cqtemp = *(ckt->CKTstate0 + here->B4SOIcqth); + + here->B4SOIcb += cqbody; + here->B4SOIcd += cqdrn; + + ceqqg = cqgate - gcggb * vgb + gcgdb * vbd + gcgsb * vbs + - gcgeb * veb - gcgT * delTemp; + + ceqqb = cqbody - gcbgb * vgb + gcbdb * vbd + gcbsb * vbs + - gcbeb * veb - gcbT * delTemp; /* v3.2 bug fix */ + ceqqd = cqdrn - gcdgb * vgb + (gcddb + gcdbdb) * vbd + + gcdsb * vbs - gcdeb * veb - gcdT * delTemp + - gcdbdb * vbd_jct - gcdgmb * vgmb;/* v4.0 */ + + ceqqe = cqsub - gcegb * vgb + gcedb * vbd + gcesb * vbs + - gceeb * veb - gceT * delTemp - gcegmb * vgmb; /* 3.2 bug fix */ + ceqqth = cqtemp - gcTt * delTemp; + + /* v3.1 added for RF */ + if (here->B4SOIrgateMod == 3) + ceqqgmid = *(ckt->CKTstate0 + here->B4SOIcqgmid) + + gcgmdb * vbd + gcgmsb * vbs - gcgmgmb * vgmb;/* 3.2 bug fix */ + else + ceqqgmid = 0.0; + /* v3.1 added for RF end */ + + if (here->B4SOIrbodyMod) /* v4.0 */ + { ceqqjs = *(ckt->CKTstate0 + here->B4SOIcqbs) + + gcsbsb * vbs_jct; + ceqqjd = *(ckt->CKTstate0 + here->B4SOIcqbd) + + gcdbdb * vbd_jct; + } + + if (ckt->CKTmode & MODEINITTRAN) + { *(ckt->CKTstate1 + here->B4SOIcqe) = + *(ckt->CKTstate0 + here->B4SOIcqe); + *(ckt->CKTstate1 + here->B4SOIcqb) = + *(ckt->CKTstate0 + here->B4SOIcqb); + *(ckt->CKTstate1 + here->B4SOIcqg) = + *(ckt->CKTstate0 + here->B4SOIcqg); + *(ckt->CKTstate1 + here->B4SOIcqd) = + *(ckt->CKTstate0 + here->B4SOIcqd); + *(ckt->CKTstate1 + here->B4SOIcqth) = + *(ckt->CKTstate0 + here->B4SOIcqth); + + if (here->B4SOIrgateMod == 3) /* v3.1 */ + *(ckt->CKTstate1 + here->B4SOIcqgmid) = + *(ckt->CKTstate0 + here->B4SOIcqgmid); + + if (here->B4SOIrbodyMod) /* v4.0 */ + { *(ckt->CKTstate1 + here->B4SOIcqbs) = + *(ckt->CKTstate0 + here->B4SOIcqbs); + *(ckt->CKTstate1 + here->B4SOIcqbd) = + *(ckt->CKTstate0 + here->B4SOIcqbd); + } + + } + + /* + * load current vector + */ + line900: + + if (here->B4SOImode >= 0) + { Gm = here->B4SOIgm; + Gmbs = here->B4SOIgmbs; +/* v3.0 */ + Gme = here->B4SOIgme; + + GmT = model->B4SOItype * here->B4SOIgmT; + FwdSum = Gm + Gmbs + Gme; /* v3.0 */ + RevSum = 0.0; + + /* v2.2.2 bug fix */ + cdreq = model->B4SOItype * (here->B4SOIcdrain + - here->B4SOIgds * vds - Gm * vgs - Gmbs * vbs + - Gme * ves) - GmT * delTemp; /* v3.0 */ + + /* ceqbs now is compatible with cdreq, ie. going in is +ve */ + /* Equivalent current source from the diode */ + ceqbs = here->B4SOIcjs; + ceqbd = here->B4SOIcjd; + cdbdp = Idbdp; + csbsp = Isbsp; + + /* Current going in is +ve */ + ceqbody = -here->B4SOIcbody; + + + ceqgate = here->B4SOIcgate; + gigg = here->B4SOIgigg; + gigb = here->B4SOIgigb; + gige = here->B4SOIgige; /* v3.0 */ + gigs = here->B4SOIgigs; + gigd = here->B4SOIgigd; + gigT = model->B4SOItype * here->B4SOIgigT; + + ceqth = here->B4SOIcth; + ceqbodcon = here->B4SOIcbodcon; + + gbbg = -here->B4SOIgbgs; + gbbdp = -here->B4SOIgbds; + gbbb = -here->B4SOIgbbs; + gbbp = -here->B4SOIgbps; + gbbT = -model->B4SOItype * here->B4SOIgbT; +/* v3.0 */ + gbbe = -here->B4SOIgbes; + + if (here->B4SOIrbodyMod) { /* v4.0 */ + gbbdp = -Giid - Ggidld; + gbbb = -Giib + Gbpbs; + gjsdb = Gjsb + Gjdb; + } + + gbbsp = - ( gbbg + gbbdp + gbbb + gbbp + gbbe); + + gddpg = -here->B4SOIgjdg; + gddpdp = -here->B4SOIgjdd; + if (!here->B4SOIrbodyMod) /* v4.0 */ + gddpb = -here->B4SOIgjdb; + else + gddpb = Giib + Ggidlb; + gddpT = -model->B4SOItype * here->B4SOIgjdT; +/* v3.0 */ + gddpe = -here->B4SOIgjde; + gddpsp = - ( gddpg + gddpdp + gddpb + gddpe); + + gsspg = -here->B4SOIgjsg; + gsspdp = -here->B4SOIgjsd; + if (!here->B4SOIrbodyMod) + gsspb = -here->B4SOIgjsb; + else + gsspb = 0.0; + gsspT = -model->B4SOItype * here->B4SOIgjsT; +/* v3.0 */ + gsspe = 0.0; + gsspsp = - (gsspg + gsspdp + gsspb + gsspe); + + gppb = -here->B4SOIgbpbs; + gppp = -here->B4SOIgbpps; + + gTtg = here->B4SOIgtempg; + gTtb = here->B4SOIgtempb; + gTtdp = here->B4SOIgtempd; + gTtt = here->B4SOIgtempT; + +/* v3.0 */ + gTte = here->B4SOIgtempe; + gTtsp = - (gTtg + gTtb + gTtdp + gTte); + + +/* v3.0 */ + if (model->B4SOIigcMod) + { gIstotg = here->B4SOIgIgsg + here->B4SOIgIgcsg; + gIstotd = here->B4SOIgIgcsd; + gIstots = here->B4SOIgIgss + here->B4SOIgIgcss; + gIstotb = here->B4SOIgIgcsb; + Istoteq = model->B4SOItype * (here->B4SOIIgs + here->B4SOIIgcs + - gIstotg * vgs - here->B4SOIgIgcsd * vds + - here->B4SOIgIgcsb * vbs); + + gIdtotg = here->B4SOIgIgdg + here->B4SOIgIgcdg; + gIdtotd = here->B4SOIgIgdd + here->B4SOIgIgcdd; + gIdtots = here->B4SOIgIgcds; + gIdtotb = here->B4SOIgIgcdb; + Idtoteq = model->B4SOItype * (here->B4SOIIgd + here->B4SOIIgcd + - here->B4SOIgIgdg * vgd - here->B4SOIgIgcdg * vgs + - here->B4SOIgIgcdd * vds - here->B4SOIgIgcdb * vbs); + + gIgtotg = gIstotg + gIdtotg; + gIgtotd = gIstotd + gIdtotd; + gIgtots = gIstots + gIdtots; + gIgtotb = gIstotb + gIdtotb; + Igtoteq = Istoteq + Idtoteq; + } + else + { gIstotg = gIstotd = gIstots = gIstotb = Istoteq = 0.0; + gIdtotg = gIdtotd = gIdtots = gIdtotb = Idtoteq = 0.0; + + gIgtotg = gIgtotd = gIgtots = gIgtotb = Igtoteq = 0.0; + } + + /* v3.1 added for RF */ + if (here->B4SOIrgateMod == 2) + T0 = vges - vgs; + else if (here->B4SOIrgateMod == 3) + T0 = vgms - vgs; + if (here->B4SOIrgateMod > 1) + { + gcrgd = here->B4SOIgcrgd * T0; + gcrgg = here->B4SOIgcrgg * T0; + gcrgs = here->B4SOIgcrgs * T0; + gcrgb = here->B4SOIgcrgb * T0; + + ceqgcrg = -(gcrgd * vds + gcrgg * vgs + + gcrgb * vbs); + gcrgg -= here->B4SOIgcrg; + gcrg = here->B4SOIgcrg; + } + else + ceqgcrg = gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0; + /* v3.1 added for RF end */ + + } /* end of soimod>=0 */ + + else + { Gm = -here->B4SOIgm; + Gmbs = -here->B4SOIgmbs; +/* v3.0 */ + Gme = -here->B4SOIgme; + + GmT = -model->B4SOItype * here->B4SOIgmT; + FwdSum = 0.0; + RevSum = -(Gm + Gmbs + Gme); /* v3.0 */ + + +/* v3.1 bug fix */ + cdreq = -model->B4SOItype * (here->B4SOIcdrain + here->B4SOIgds*vds + + Gm * vgd + Gmbs * vbd + Gme * (ves - vds)) + - GmT * delTemp; + + + ceqbs = here->B4SOIcjd; + ceqbd = here->B4SOIcjs; + csbsp = Idbdp; + cdbdp = Isbsp; + + /* Current going in is +ve */ + ceqbody = -here->B4SOIcbody; + + + ceqgate = here->B4SOIcgate; + gigg = here->B4SOIgigg; + gigb = here->B4SOIgigb; + gige = here->B4SOIgige; /* v3.0 */ + gigs = here->B4SOIgigd; + gigd = here->B4SOIgigs; + gigT = model->B4SOItype * here->B4SOIgigT; + + ceqth = here->B4SOIcth; + ceqbodcon = here->B4SOIcbodcon; + + gbbg = -here->B4SOIgbgs; + gbbb = -here->B4SOIgbbs; + gbbp = -here->B4SOIgbps; + gbbsp = -here->B4SOIgbds; + gbbT = -model->B4SOItype * here->B4SOIgbT; +/* v3.0 */ + gbbe = -here->B4SOIgbes; + + if (here->B4SOIrbodyMod) { /* v4.0 */ + gbbsp = -Giid - Ggidld; + gbbb = -Giib + Gbpbs; + gjsdb = Gjsb + Gjdb; + } + gbbdp = - ( gbbg + gbbsp + gbbb + gbbp + gbbe); + + gddpg = -here->B4SOIgjsg; + gddpsp = -here->B4SOIgjsd; + if (!here->B4SOIrbodyMod) + gddpb = -here->B4SOIgjsb; + else + gddpb = 0.0; + gddpT = -model->B4SOItype * here->B4SOIgjsT; +/* v3.0 */ + gddpe = 0.0; + gddpdp = - (gddpg + gddpsp + gddpb + gddpe); + + gsspg = -here->B4SOIgjdg; + gsspsp = -here->B4SOIgjdd; + if (!here->B4SOIrbodyMod) + gsspb = -here->B4SOIgjdb; + else + gsspb = Giib + Ggidlb; + gsspT = -model->B4SOItype * here->B4SOIgjdT; +/* v3.0 */ + gsspe = -here->B4SOIgjde; + gsspdp = - ( gsspg + gsspsp + gsspb + gsspe); + + gppb = -here->B4SOIgbpbs; + gppp = -here->B4SOIgbpps; + + gTtg = here->B4SOIgtempg; + gTtb = here->B4SOIgtempb; + gTtsp = here->B4SOIgtempd; + gTtt = here->B4SOIgtempT; + +/* v3.0 */ + gTte = here->B4SOIgtempe; + gTtdp = - (gTtg + gTtb + gTtsp + gTte); + +/* v3.0 */ + if (model->B4SOIigcMod) + { gIstotg = here->B4SOIgIgsg + here->B4SOIgIgcdg; + gIstotd = here->B4SOIgIgcds; + gIstots = here->B4SOIgIgss + here->B4SOIgIgcdd; + gIstotb = here->B4SOIgIgcdb; + Istoteq = model->B4SOItype * (here->B4SOIIgs + here->B4SOIIgcd + - here->B4SOIgIgsg * vgs - here->B4SOIgIgcdg * vgd + + here->B4SOIgIgcdd * vds - here->B4SOIgIgcdb * vbd); + + gIdtotg = here->B4SOIgIgdg + here->B4SOIgIgcsg; + gIdtotd = here->B4SOIgIgdd + here->B4SOIgIgcss; + gIdtots = here->B4SOIgIgcsd; + gIdtotb = here->B4SOIgIgcsb; + Idtoteq = model->B4SOItype * (here->B4SOIIgd + here->B4SOIIgcs + - (here->B4SOIgIgdg + here->B4SOIgIgcsg) * vgd + + here->B4SOIgIgcsd * vds - here->B4SOIgIgcsb * vbd); + + gIgtotg = gIstotg + gIdtotg; + gIgtotd = gIstotd + gIdtotd; + gIgtots = gIstots + gIdtots; + gIgtotb = gIstotb + gIdtotb; + Igtoteq = Istoteq + Idtoteq; + + } + else + { gIstotg = gIstotd = gIstots = gIstotb = Istoteq = 0.0; + gIdtotg = gIdtotd = gIdtots = gIdtotb = Idtoteq = 0.0; + + gIgtotg = gIgtotd = gIgtots = gIgtotb = Igtoteq = 0.0; + } + + /* v3.1 added for RF */ + if (here->B4SOIrgateMod == 2) + T0 = vges - vgs; + else if (here->B4SOIrgateMod == 3) + T0 = vgms - vgs; + if (here->B4SOIrgateMod > 1) + { + gcrgd = here->B4SOIgcrgs * T0; + gcrgg = here->B4SOIgcrgg * T0; + gcrgs = here->B4SOIgcrgd * T0; + gcrgb = here->B4SOIgcrgb * T0; + ceqgcrg = -(gcrgg * vgd - gcrgs * vds + + gcrgb * vbd); + gcrgg -= here->B4SOIgcrg; + gcrg = here->B4SOIgcrg; + } + else + ceqgcrg = gcrg = gcrgd = gcrgg = gcrgs = gcrgb = 0.0; + /* v3.1 added for RF end */ + + } /* end of soimod<0 */ + + + if (model->B4SOIrdsMod == 1) + { ceqgstot = model->B4SOItype * (here->B4SOIgstotd * vds + + here->B4SOIgstotg * vgs + here->B4SOIgstotb * vbs); + /* ceqgstot flowing away from sNodePrime */ + gstot = here->B4SOIgstot; + gstotd = here->B4SOIgstotd; + gstotg = here->B4SOIgstotg; + gstots = here->B4SOIgstots - gstot; + gstotb = here->B4SOIgstotb; + + ceqgdtot = -model->B4SOItype * (here->B4SOIgdtotd * vds + + here->B4SOIgdtotg * vgs + here->B4SOIgdtotb * vbs); + /* ceqgdtot defined as flowing into dNodePrime */ + gdtot = here->B4SOIgdtot; + gdtotd = here->B4SOIgdtotd - gdtot; + gdtotg = here->B4SOIgdtotg; + gdtots = here->B4SOIgdtots; + gdtotb = here->B4SOIgdtotb; + } + else + { gstot = gstotd = gstotg = gstots + = gstotb = ceqgstot = 0.0; + gdtot = gdtotd = gdtotg = gdtots + = gdtotb = ceqgdtot = 0.0; + } + + if (model->B4SOItype > 0) + { + ceqqg = ceqqg; + ceqqb = ceqqb; + ceqqe = ceqqe; + ceqqd = ceqqd; + } + else + { + ceqbodcon = -ceqbodcon; + ceqbody = -ceqbody; + ceqgate = -ceqgate; + ceqbs = -ceqbs; + ceqbd = -ceqbd; + ceqqg = -ceqqg; + ceqqb = -ceqqb; + ceqqd = -ceqqd; + ceqqe = -ceqqe; + cdbdp = - cdbdp; /* v4.0 */ + csbsp = - csbsp; /* v4.0 */ + + + ceqgcrg = -ceqgcrg; /* v3.1 */ + if (here->B4SOIrgateMod == 3) + ceqqgmid = -ceqqgmid; + + if (here->B4SOIrbodyMod) /* v4.0 */ + { ceqqjs = -ceqqjs; + ceqqjd = -ceqqjd; + } + + } + + m = here->B4SOIm; + +/* v3.1 */ + + /* v3.1 added ceqgcrg for RF */ + (*(ckt->CKTrhs + here->B4SOIgNode) -= m * ((ceqgate + ceqqg) + + Igtoteq - ceqgcrg)); + /* v3.1 added ceqgcrg for RF end */ + + (*(ckt->CKTrhs + here->B4SOIdNodePrime) += m * ((ceqbd - cdreq + - ceqqd) + Idtoteq + /* v4.0 */ + ceqgdtot)); + if (!here->B4SOIrbodyMod) { + (*(ckt->CKTrhs + here->B4SOIsNodePrime) += m * ((cdreq + ceqbs + + ceqqg + ceqqb + ceqqd + ceqqe) + Istoteq + + ceqqgmid - ceqgstot)); /* v4.0 */ + } + else { /* v4.0 */ + (*(ckt->CKTrhs + here->B4SOIsNodePrime) += m * ((cdreq + ceqbs + + ceqqg + ceqqb + ceqqd + ceqqe) + Istoteq + + ceqqgmid + ceqqjd + ceqqjs - ceqgstot)); + } + + (*(ckt->CKTrhs + here->B4SOIeNode) -= m * ceqqe); + + if (here->B4SOIrgateMod == 2) + (*(ckt->CKTrhs + here->B4SOIgNodeExt) -= m * ceqgcrg); + else if (here->B4SOIrgateMod == 3) + (*(ckt->CKTrhs + here->B4SOIgNodeMid) -= m * (ceqqgmid + + ceqgcrg)); + + if (here->B4SOIbodyMod == 1) { + (*(ckt->CKTrhs + here->B4SOIpNode) += m * ceqbodcon); + } + + if ( here->B4SOIsoiMod != 2 ) + {if (!here->B4SOIrbodyMod) + (*(ckt->CKTrhs + here->B4SOIbNode) -= m * (ceqbody + ceqqb)); + else /* v4.0 */ + { (*(ckt->CKTrhs + here->B4SOIdbNode) -= m * (cdbdp + ceqqjd)); + (*(ckt->CKTrhs + here->B4SOIbNode) -= m * (ceqbody + ceqqb)); + (*(ckt->CKTrhs + here->B4SOIsbNode) -= m * (csbsp + ceqqjs)); + } + } + + if (selfheat) { + (*(ckt->CKTrhs + here->B4SOItempNode) -= m * (ceqth + ceqqth)); + } + + if (model->B4SOIrdsMod) + { (*(ckt->CKTrhs + here->B4SOIdNode) -= m * ceqgdtot); + (*(ckt->CKTrhs + here->B4SOIsNode) += m * ceqgstot); + } + + if (here->B4SOIdebugMod != 0) + { + *(ckt->CKTrhs + here->B4SOIvbsNode) = here->B4SOIvbseff; + *(ckt->CKTrhs + here->B4SOIidsNode) = FLOG(here->B4SOIids); + *(ckt->CKTrhs + here->B4SOIicNode) = FLOG(here->B4SOIic); + *(ckt->CKTrhs + here->B4SOIibsNode) = FLOG(here->B4SOIibs); + *(ckt->CKTrhs + here->B4SOIibdNode) = FLOG(here->B4SOIibd); + *(ckt->CKTrhs + here->B4SOIiiiNode) = FLOG(here->B4SOIiii); + *(ckt->CKTrhs + here->B4SOIigNode) = here->B4SOIig; + *(ckt->CKTrhs + here->B4SOIgiggNode) = here->B4SOIgigg; + *(ckt->CKTrhs + here->B4SOIgigdNode) = here->B4SOIgigd; + *(ckt->CKTrhs + here->B4SOIgigbNode) = here->B4SOIgigb; + *(ckt->CKTrhs + here->B4SOIigidlNode) = here->B4SOIigidl; + *(ckt->CKTrhs + here->B4SOIitunNode) = here->B4SOIitun; + *(ckt->CKTrhs + here->B4SOIibpNode) = here->B4SOIibp; + *(ckt->CKTrhs + here->B4SOIcbbNode) = here->B4SOIcbb; + *(ckt->CKTrhs + here->B4SOIcbdNode) = here->B4SOIcbd; + *(ckt->CKTrhs + here->B4SOIcbgNode) = here->B4SOIcbg; + *(ckt->CKTrhs + here->B4SOIqbfNode) = here->B4SOIqbf; + *(ckt->CKTrhs + here->B4SOIqjsNode) = here->B4SOIqjs; + *(ckt->CKTrhs + here->B4SOIqjdNode) = here->B4SOIqjd; + + } + + if (!model->B4SOIrdsMod) + { gdpr = here->B4SOIdrainConductance; + gspr = here->B4SOIsourceConductance; + } + else + gdpr = gspr = 0.0; /* v4.0 */ + + /* + * load y matrix + */ + Gmin = ckt->CKTgmin * 1e-6; + + /* v3.1 added for RF */ + geltd = here->B4SOIgrgeltd; + if (here->B4SOIrgateMod == 1) + { + *(here->B4SOIGEgePtr) += m * geltd; + *(here->B4SOIGgePtr) -= m * geltd; + *(here->B4SOIGEgPtr) -= m * geltd; + } + else if (here->B4SOIrgateMod == 2) + { + *(here->B4SOIGEgePtr) += m * gcrg; + *(here->B4SOIGEgPtr) += m * gcrgg; + *(here->B4SOIGEdpPtr) += m * gcrgd; + *(here->B4SOIGEspPtr) += m * gcrgs; + *(here->B4SOIGgePtr) -= m * gcrg; + if (here->B4SOIsoiMod !=2) /* v3.2 */ + *(here->B4SOIGEbPtr) += m * gcrgb; + } + else if (here->B4SOIrgateMod == 3) + { + *(here->B4SOIGEgePtr) += m * geltd; + *(here->B4SOIGEgmPtr) -= m * geltd; + *(here->B4SOIGMgePtr) -= m * geltd; + *(here->B4SOIGMgmPtr) += m * (geltd + gcrg + gcgmgmb); + + *(here->B4SOIGMdpPtr) += m * (gcrgd + gcgmdb); + *(here->B4SOIGMgPtr) += m * gcrgg; + *(here->B4SOIGMspPtr) += m * (gcrgs + gcgmsb); + *(here->B4SOIGMePtr) += m * gcgmeb; + if (here->B4SOIsoiMod !=2) /* v3.2 */ + *(here->B4SOIGMbPtr) += m * gcrgb; + + *(here->B4SOIDPgmPtr) += m * gcdgmb; + *(here->B4SOIGgmPtr) -= m * gcrg; + *(here->B4SOISPgmPtr) += m * gcsgmb; + *(here->B4SOIEgmPtr) += m * gcegmb; + } + /* v3.1 added for RF end*/ + + +/* v3.0 */ + if (here->B4SOIsoiMod != 0) /* v3.2 */ + { + (*(here->B4SOIDPePtr) += m * (Gme + gddpe)); + (*(here->B4SOISPePtr) += m * (gsspe - Gme)); + + if (here->B4SOIsoiMod != 2) /* v3.2 */ + { + *(here->B4SOIGePtr) += m * gige; + *(here->B4SOIBePtr) -= m * gige; + } + } + + *(here->B4SOIEdpPtr) += m * gcedb; + *(here->B4SOIEspPtr) += m * gcesb; + *(here->B4SOIDPePtr) += m * gcdeb; + *(here->B4SOISPePtr) += m * gcseb; + *(here->B4SOIEgPtr) += m * gcegb; + *(here->B4SOIGePtr) += m * gcgeb; + +/* v3.1 */ + if (here->B4SOIsoiMod != 2) /* v3.2 */ + { + (*(here->B4SOIEbPtr) -= m * (gcegb + gcedb + gcesb + gceeb + gcegmb)); /* 3.2 bug fix */ + + /* v3.1 changed GbPtr for RF */ + if ((here->B4SOIrgateMod == 0) || (here->B4SOIrgateMod == 1)) + (*(here->B4SOIGbPtr) -= m * (-gigb + gcggb + gcgdb + gcgsb + + gcgeb - gIgtotb)); + else /* v3.1 for rgateMod = 2 or 3 */ + *(here->B4SOIGbPtr) += m * (gigb + gcgbb +gIgtotb - gcrgb); + + + (*(here->B4SOIDPbPtr) -= m * (-gddpb - Gmbs - gcdbb + gdtotb + + gIdtotb)); /* v4.0 */ + +/* (*(here->B4SOIDPbPtr) -= (-gddpb - Gmbs + gcdgb + gcddb + + gcdeb + gcdsb) + gcdgmb + + gIdtotb ); +*/ + + (*(here->B4SOISPbPtr) -= m * (-gsspb + Gmbs - gcsbb + gstotb + + Gmin + gIstotb)); /* v4.0 */ + +/* (*(here->B4SOISPbPtr) -= (-gsspb + Gmbs + gcsgb + gcsdb + + gcseb + gcssb) + gcsgmb + + Gmin + gIstotb); +*/ + (*(here->B4SOIBePtr) += m * (gbbe + gcbeb)); /* v3.0 */ + (*(here->B4SOIBgPtr) += m * (-gigg + gcbgb + gbbg)); + (*(here->B4SOIBdpPtr) += m * (-gigd + gcbdb + gbbdp)); + + (*(here->B4SOIBspPtr) += m * (gcbsb + gbbsp - Gmin + - gigs)); +/* if (!here->B4SOIrbodyMod) +*/ + (*(here->B4SOIBbPtr) += m * (-gigb + gbbb - gcbgb - gcbdb + - gcbsb - gcbeb + Gmin)) ; +/* else + (*(here->B4SOIBbPtr) += -gigb - (Giib - Gbpbs) - gcbgb + - gcbdb - gcbsb - gcbeb + Gmin) ; +*/ + /* v4.0 */ + if (here->B4SOIrbodyMod) { + (*(here->B4SOIDPdbPtr) += m * (-gcjdbdp - GGjdb)); + (*(here->B4SOISPsbPtr) += m * (-gcjsbsp - GGjsb)); + (*(here->B4SOIDBdpPtr) += m * (-gcjdbdp - GGjdb)); + (*(here->B4SOIDBdbPtr) += m * (gcjdbdp + GGjdb + + here->B4SOIgrbdb)); + (*(here->B4SOIDBbPtr) -= m * here->B4SOIgrbdb); + (*(here->B4SOISBspPtr) += m * (-gcjsbsp - GGjsb)); + (*(here->B4SOISBbPtr) -= m * here->B4SOIgrbsb); + (*(here->B4SOISBsbPtr) += m * (gcjsbsp + GGjsb + + here->B4SOIgrbsb)); + (*(here->B4SOIBdbPtr) -= m * here->B4SOIgrbdb); + (*(here->B4SOIBsbPtr) -= m * here->B4SOIgrbsb); + (*(here->B4SOIBbPtr) += m * (here->B4SOIgrbsb + + here->B4SOIgrbdb)); + } + if (model->B4SOIrdsMod) + { + (*(here->B4SOIDbPtr) += m * gdtotb); + (*(here->B4SOISbPtr) += m * gstotb); + } + + } +/* v3.1 */ + if (model->B4SOIrdsMod) + { (*(here->B4SOIDgPtr) += m * gdtotg); + (*(here->B4SOIDspPtr) += m * gdtots); + (*(here->B4SOISdpPtr) += m * gstotd); + (*(here->B4SOISgPtr) += m * gstotg); + } + + (*(here->B4SOIEePtr) += m * gceeb); + + if (here->B4SOIrgateMod == 0) + { + (*(here->B4SOIGgPtr) += m * (gigg + gcggb + Gmin + + gIgtotg)); + (*(here->B4SOIGdpPtr) += m * (gigd + gcgdb - Gmin + + gIgtotd)); + (*(here->B4SOIGspPtr) += m * (gcgsb + gigs + gIgtots)); + } + else if (here->B4SOIrgateMod == 1) /* v3.1 for RF */ + { + *(here->B4SOIGgPtr) += m * (gigg + gcggb + Gmin + + gIgtotg + geltd); + *(here->B4SOIGdpPtr) += m * (gigd + gcgdb - Gmin + + gIgtotd); + *(here->B4SOIGspPtr) += m * (gcgsb + gigs + gIgtots); + } + else /* v3.1 for RF rgateMod == 2 or 3 */ + { + *(here->B4SOIGgPtr) += m * (gigg + gcggb + Gmin + + gIgtotg - gcrgg); + *(here->B4SOIGdpPtr) += m * (gigd + gcgdb - Gmin + + gIgtotd - gcrgd); + *(here->B4SOIGspPtr) += m * (gcgsb + gigs + gIgtots - gcrgs); + } + + + (*(here->B4SOIDPgPtr) += m * ((Gm + gcdgb) + gddpg - Gmin + - gIdtotg - gdtotg)); /* v4.0 */ + (*(here->B4SOIDPdpPtr) += m * ((gdpr + here->B4SOIgds + gddpdp + + RevSum + gcddb) + Gmin + - gIdtotd - gdtotd)); /* v4.0 */ + (*(here->B4SOIDPspPtr) -= m * ((-gddpsp + here->B4SOIgds + FwdSum + - gcdsb) + gIdtots + gdtots)); + + (*(here->B4SOIDPdPtr) -= m * (gdpr + gdtot)); + + (*(here->B4SOISPgPtr) += m * (gcsgb - Gm + gsspg - gIstotg + - gstotg)); /* v4.0 */ + (*(here->B4SOISPdpPtr) -= m * ((here->B4SOIgds - gsspdp + RevSum + - gcsdb + gIstotd) + gstotd)); /* v4.0 */ + + (*(here->B4SOISPspPtr) += m * ((gspr - gstots + + here->B4SOIgds + gsspsp + + FwdSum + gcssb) + + Gmin - gIstots)); /* v4.0 */ + + (*(here->B4SOISPsPtr) -= m * (gspr + gstot)); + + + (*(here->B4SOIDdPtr) += m * (gdpr + gdtot)); + (*(here->B4SOIDdpPtr) -= m * (gdpr - gdtotd)); + + + (*(here->B4SOISsPtr) += m * (gspr + gstot)); + (*(here->B4SOISspPtr) -= m * (gspr - gstots)); + + + if (here->B4SOIbodyMod == 1) { + (*(here->B4SOIBpPtr) -= m * gppp); + (*(here->B4SOIPbPtr) += m * gppb); + (*(here->B4SOIPpPtr) += m * gppp); + } + + + if (selfheat) + { + (*(here->B4SOIDPtempPtr) += m * (GmT + gddpT + gcdT)); + (*(here->B4SOISPtempPtr) += m * (-GmT + gsspT + gcsT)); + (*(here->B4SOIBtempPtr) += m * (gbbT + gcbT - gigT)); + (*(here->B4SOIEtempPtr) += m * gceT); + (*(here->B4SOIGtempPtr) += m * (gcgT + gigT)); + (*(here->B4SOITemptempPtr) += m * (gTtt + 1/pParam->B4SOIrth + gcTt)); + (*(here->B4SOITempgPtr) += m * gTtg); + (*(here->B4SOITempbPtr) += m * gTtb); + (*(here->B4SOITempdpPtr) += m * gTtdp); + (*(here->B4SOITempspPtr) += m * gTtsp); + +/* v3.0 */ + if (here->B4SOIsoiMod != 0) /* v3.2 */ + (*(here->B4SOITempePtr) += m * gTte); + + } + + if (here->B4SOIdebugMod != 0) + { + *(here->B4SOIVbsPtr) += 1; + *(here->B4SOIIdsPtr) += 1; + *(here->B4SOIIcPtr) += 1; + *(here->B4SOIIbsPtr) += 1; + *(here->B4SOIIbdPtr) += 1; + *(here->B4SOIIiiPtr) += 1; + *(here->B4SOIIgPtr) += 1; + *(here->B4SOIGiggPtr) += 1; + *(here->B4SOIGigdPtr) += 1; + *(here->B4SOIGigbPtr) += 1; + *(here->B4SOIIgidlPtr) += 1; + *(here->B4SOIItunPtr) += 1; + *(here->B4SOIIbpPtr) += 1; + *(here->B4SOICbgPtr) += 1; + *(here->B4SOICbbPtr) += 1; + *(here->B4SOICbdPtr) += 1; + *(here->B4SOIQbfPtr) += 1; + *(here->B4SOIQjsPtr) += 1; + *(here->B4SOIQjdPtr) += 1; + } + + line1000: ; + + + } /* End of Mosfet Instance */ +} /* End of Model Instance */ + + +return(OK); +} diff --git a/src/spicelib/devices/bsim3soi/b4soimask.c b/src/spicelib/devices/bsim3soi/b4soimask.c new file mode 100644 index 000000000..4ccf3a07d --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soimask.c @@ -0,0 +1,2332 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soimask.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soimask.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "ifsim.h" +#include "cktdefs.h" +#include "devdefs.h" +#include "b4soidef.h" +#include "sperror.h" +#include "suffix.h" + +int +B4SOImAsk(CKTcircuit *ckt, GENmodel *inst, int which, IFvalue *value) +{ + B4SOImodel *model = (B4SOImodel *)inst; + switch(which) + { case B4SOI_MOD_MOBMOD: + value->iValue = model->B4SOImobMod; + return(OK); + case B4SOI_MOD_PARAMCHK: + value->iValue = model->B4SOIparamChk; + return(OK); + case B4SOI_MOD_BINUNIT: + value->iValue = model->B4SOIbinUnit; + return(OK); + case B4SOI_MOD_CAPMOD: + value->iValue = model->B4SOIcapMod; + return(OK); + case B4SOI_MOD_SHMOD: + value->iValue = model->B4SOIshMod; + return(OK); + +/* case B4SOI_MOD_NOIMOD: + value->iValue = model->B4SOInoiMod; + return(OK); v3.2 */ + + case B4SOI_MOD_VERSION : + value->rValue = model->B4SOIversion; + return(OK); + case B4SOI_MOD_TOX : + value->rValue = model->B4SOItox; + return(OK); + + case B4SOI_MOD_TOXM : + value->rValue = model->B4SOItoxm; + return(OK); /* v3.2 */ + +/* v2.2.3 */ + case B4SOI_MOD_DTOXCV : + value->rValue = model->B4SOIdtoxcv; + return(OK); + + case B4SOI_MOD_CDSC : + value->rValue = model->B4SOIcdsc; + return(OK); + case B4SOI_MOD_CDSCB : + value->rValue = model->B4SOIcdscb; + return(OK); + + case B4SOI_MOD_CDSCD : + value->rValue = model->B4SOIcdscd; + return(OK); + + case B4SOI_MOD_CIT : + value->rValue = model->B4SOIcit; + return(OK); + case B4SOI_MOD_NFACTOR : + value->rValue = model->B4SOInfactor; + return(OK); + case B4SOI_MOD_VSAT: + value->rValue = model->B4SOIvsat; + return(OK); + case B4SOI_MOD_AT: + value->rValue = model->B4SOIat; + return(OK); + case B4SOI_MOD_A0: + value->rValue = model->B4SOIa0; + return(OK); + + case B4SOI_MOD_AGS: + value->rValue = model->B4SOIags; + return(OK); + + case B4SOI_MOD_A1: + value->rValue = model->B4SOIa1; + return(OK); + case B4SOI_MOD_A2: + value->rValue = model->B4SOIa2; + return(OK); + case B4SOI_MOD_KETA: + value->rValue = model->B4SOIketa; + return(OK); + case B4SOI_MOD_NSUB: + value->rValue = model->B4SOInsub; + return(OK); + case B4SOI_MOD_NPEAK: + value->rValue = model->B4SOInpeak; + return(OK); + case B4SOI_MOD_NGATE: + value->rValue = model->B4SOIngate; + return(OK); + case B4SOI_MOD_GAMMA1: + value->rValue = model->B4SOIgamma1; + return(OK); + case B4SOI_MOD_GAMMA2: + value->rValue = model->B4SOIgamma2; + return(OK); + case B4SOI_MOD_VBX: + value->rValue = model->B4SOIvbx; + return(OK); + case B4SOI_MOD_VBM: + value->rValue = model->B4SOIvbm; + return(OK); + case B4SOI_MOD_XT: + value->rValue = model->B4SOIxt; + return(OK); + case B4SOI_MOD_K1: + value->rValue = model->B4SOIk1; + return(OK); + case B4SOI_MOD_KT1: + value->rValue = model->B4SOIkt1; + return(OK); + case B4SOI_MOD_KT1L: + value->rValue = model->B4SOIkt1l; + return(OK); + case B4SOI_MOD_KT2 : + value->rValue = model->B4SOIkt2; + return(OK); + case B4SOI_MOD_K2 : + value->rValue = model->B4SOIk2; + return(OK); + case B4SOI_MOD_K3: + value->rValue = model->B4SOIk3; + return(OK); + case B4SOI_MOD_K3B: + value->rValue = model->B4SOIk3b; + return(OK); + case B4SOI_MOD_W0: + value->rValue = model->B4SOIw0; + return(OK); + case B4SOI_MOD_LPE0: + value->rValue = model->B4SOIlpe0; + return(OK); + case B4SOI_MOD_LPEB: /* v4.0 for Vth */ + value->rValue = model->B4SOIlpeb; + return(OK); + case B4SOI_MOD_DVT0 : + value->rValue = model->B4SOIdvt0; + return(OK); + case B4SOI_MOD_DVT1 : + value->rValue = model->B4SOIdvt1; + return(OK); + case B4SOI_MOD_DVT2 : + value->rValue = model->B4SOIdvt2; + return(OK); + case B4SOI_MOD_DVT0W : + value->rValue = model->B4SOIdvt0w; + return(OK); + case B4SOI_MOD_DVT1W : + value->rValue = model->B4SOIdvt1w; + return(OK); + case B4SOI_MOD_DVT2W : + value->rValue = model->B4SOIdvt2w; + return(OK); + case B4SOI_MOD_DROUT : + value->rValue = model->B4SOIdrout; + return(OK); + case B4SOI_MOD_DSUB : + value->rValue = model->B4SOIdsub; + return(OK); + case B4SOI_MOD_VTH0: + value->rValue = model->B4SOIvth0; + return(OK); + case B4SOI_MOD_UA: + value->rValue = model->B4SOIua; + return(OK); + case B4SOI_MOD_UA1: + value->rValue = model->B4SOIua1; + return(OK); + case B4SOI_MOD_UB: + value->rValue = model->B4SOIub; + return(OK); + case B4SOI_MOD_UB1: + value->rValue = model->B4SOIub1; + return(OK); + case B4SOI_MOD_UC: + value->rValue = model->B4SOIuc; + return(OK); + case B4SOI_MOD_UC1: + value->rValue = model->B4SOIuc1; + return(OK); + case B4SOI_MOD_U0: + value->rValue = model->B4SOIu0; + return(OK); + case B4SOI_MOD_UTE: + value->rValue = model->B4SOIute; + return(OK); + case B4SOI_MOD_VOFF: + value->rValue = model->B4SOIvoff; + return(OK); + case B4SOI_MOD_DELTA: + value->rValue = model->B4SOIdelta; + return(OK); + case B4SOI_MOD_RDSW: + value->rValue = model->B4SOIrdsw; + return(OK); + case B4SOI_MOD_RDWMIN: + value->rValue = model->B4SOIrdwmin; + return(OK); + case B4SOI_MOD_RSWMIN: + value->rValue = model->B4SOIrswmin; + return(OK); + case B4SOI_MOD_RDW: + value->rValue = model->B4SOIrdw; + return(OK); + case B4SOI_MOD_RSW: + value->rValue = model->B4SOIrsw; + return(OK); + case B4SOI_MOD_PRWG: + value->rValue = model->B4SOIprwg; + return(OK); + case B4SOI_MOD_PRWB: + value->rValue = model->B4SOIprwb; + return(OK); + case B4SOI_MOD_PRT: + value->rValue = model->B4SOIprt; + return(OK); + case B4SOI_MOD_ETA0: + value->rValue = model->B4SOIeta0; + return(OK); + case B4SOI_MOD_ETAB: + value->rValue = model->B4SOIetab; + return(OK); + case B4SOI_MOD_PCLM: + value->rValue = model->B4SOIpclm; + return(OK); + case B4SOI_MOD_PDIBL1: + value->rValue = model->B4SOIpdibl1; + return(OK); + case B4SOI_MOD_PDIBL2: + value->rValue = model->B4SOIpdibl2; + return(OK); + case B4SOI_MOD_PDIBLB: + value->rValue = model->B4SOIpdiblb; + return(OK); + case B4SOI_MOD_PVAG: + value->rValue = model->B4SOIpvag; + return(OK); + case B4SOI_MOD_WR: + value->rValue = model->B4SOIwr; + return(OK); + case B4SOI_MOD_DWG: + value->rValue = model->B4SOIdwg; + return(OK); + case B4SOI_MOD_DWB: + value->rValue = model->B4SOIdwb; + return(OK); + case B4SOI_MOD_B0: + value->rValue = model->B4SOIb0; + return(OK); + case B4SOI_MOD_B1: + value->rValue = model->B4SOIb1; + return(OK); + case B4SOI_MOD_ALPHA0: + value->rValue = model->B4SOIalpha0; + return(OK); + + case B4SOI_MOD_CGSL: + value->rValue = model->B4SOIcgsl; + return(OK); + case B4SOI_MOD_CGDL: + value->rValue = model->B4SOIcgdl; + return(OK); + case B4SOI_MOD_CKAPPA: + value->rValue = model->B4SOIckappa; + return(OK); + case B4SOI_MOD_CF: + value->rValue = model->B4SOIcf; + return(OK); + case B4SOI_MOD_CLC: + value->rValue = model->B4SOIclc; + return(OK); + case B4SOI_MOD_CLE: + value->rValue = model->B4SOIcle; + return(OK); + case B4SOI_MOD_DWC: + value->rValue = model->B4SOIdwc; + return(OK); + case B4SOI_MOD_DLC: + value->rValue = model->B4SOIdlc; + return(OK); + + + case B4SOI_MOD_TBOX: + value->rValue = model->B4SOItbox; + return(OK); + case B4SOI_MOD_TSI: + value->rValue = model->B4SOItsi; + return(OK); + case B4SOI_MOD_RTH0: + value->rValue = model->B4SOIrth0; + return(OK); + case B4SOI_MOD_CTH0: + value->rValue = model->B4SOIcth0; + return(OK); + case B4SOI_MOD_NDIODES: /* v4.0 */ + value->rValue = model->B4SOIndiode; + return(OK); + case B4SOI_MOD_NDIODED: /* v4.0 */ + value->rValue = model->B4SOIndioded; + return(OK); + case B4SOI_MOD_XBJT: + value->rValue = model->B4SOIxbjt; + return(OK); + case B4SOI_MOD_XDIFS: + value->rValue = model->B4SOIxdif; + return(OK); + case B4SOI_MOD_XRECS: + value->rValue = model->B4SOIxrec; + return(OK); + case B4SOI_MOD_XTUNS: + value->rValue = model->B4SOIxtun; + return(OK); + case B4SOI_MOD_XDIFD: + value->rValue = model->B4SOIxdifd; + return(OK); + case B4SOI_MOD_XRECD: + value->rValue = model->B4SOIxrecd; + return(OK); + case B4SOI_MOD_XTUND: + value->rValue = model->B4SOIxtund; + return(OK); + + case B4SOI_MOD_TT: + value->rValue = model->B4SOItt; + return(OK); + case B4SOI_MOD_VSDTH: + value->rValue = model->B4SOIvsdth; + return(OK); + case B4SOI_MOD_VSDFB: + value->rValue = model->B4SOIvsdfb; + return(OK); + case B4SOI_MOD_CSDMIN: + value->rValue = model->B4SOIcsdmin; + return(OK); + case B4SOI_MOD_ASD: + value->rValue = model->B4SOIasd; + return(OK); + + case B4SOI_MOD_TNOM : + value->rValue = model->B4SOItnom; + return(OK); + case B4SOI_MOD_CGSO: + value->rValue = model->B4SOIcgso; + return(OK); + case B4SOI_MOD_CGDO: + value->rValue = model->B4SOIcgdo; + return(OK); + case B4SOI_MOD_CGEO: + value->rValue = model->B4SOIcgeo; + return(OK); + + + case B4SOI_MOD_XPART: + value->rValue = model->B4SOIxpart; + return(OK); + case B4SOI_MOD_RSH: + value->rValue = model->B4SOIsheetResistance; + return(OK); + case B4SOI_MOD_PBSWGS: /* v4.0 */ + value->rValue = model->B4SOIGatesidewallJctSPotential; + return(OK); + case B4SOI_MOD_PBSWGD: /* v4.0 */ + value->rValue = model->B4SOIGatesidewallJctDPotential; + return(OK); + case B4SOI_MOD_MJSWGS: /* v4.0 */ + value->rValue = model->B4SOIbodyJctGateSideSGradingCoeff; + return(OK); + case B4SOI_MOD_MJSWGD: /* v4.0 */ + value->rValue = model->B4SOIbodyJctGateSideDGradingCoeff; + return(OK); + case B4SOI_MOD_CJSWGS: /* v4.0 */ + value->rValue = model->B4SOIunitLengthGateSidewallJctCapS; + return(OK); + case B4SOI_MOD_CJSWGD: /* v4.0 */ + value->rValue = model->B4SOIunitLengthGateSidewallJctCapD; + return(OK); + case B4SOI_MOD_CSDESW: + value->rValue = model->B4SOIcsdesw; + return(OK); + case B4SOI_MOD_LINT: + value->rValue = model->B4SOILint; + return(OK); + case B4SOI_MOD_LL: + value->rValue = model->B4SOILl; + return(OK); +/* v2.2.3 */ + case B4SOI_MOD_LLC: + value->rValue = model->B4SOILlc; + return(OK); + + case B4SOI_MOD_LLN: + value->rValue = model->B4SOILln; + return(OK); + case B4SOI_MOD_LW: + value->rValue = model->B4SOILw; + return(OK); +/* v2.2.3 */ + case B4SOI_MOD_LWC: + value->rValue = model->B4SOILwc; + return(OK); + + case B4SOI_MOD_LWN: + value->rValue = model->B4SOILwn; + return(OK); + case B4SOI_MOD_LWL: + value->rValue = model->B4SOILwl; + return(OK); +/* v2.2.3 */ + case B4SOI_MOD_LWLC: + value->rValue = model->B4SOILwlc; + return(OK); + + case B4SOI_MOD_WINT: + value->rValue = model->B4SOIWint; + return(OK); + case B4SOI_MOD_WL: + value->rValue = model->B4SOIWl; + return(OK); +/* v2.2.3 */ + case B4SOI_MOD_WLC: + value->rValue = model->B4SOIWlc; + return(OK); + + case B4SOI_MOD_WLN: + value->rValue = model->B4SOIWln; + return(OK); + case B4SOI_MOD_WW: + value->rValue = model->B4SOIWw; + return(OK); +/* v2.2.3 */ + case B4SOI_MOD_WWC: + value->rValue = model->B4SOIWwc; + return(OK); + + case B4SOI_MOD_WWN: + value->rValue = model->B4SOIWwn; + return(OK); + case B4SOI_MOD_WWL: + value->rValue = model->B4SOIWwl; + return(OK); +/* v2.2.3 */ + case B4SOI_MOD_WWLC: + value->rValue = model->B4SOIWwlc; + return(OK); + + /* stress effect */ + case B4SOI_MOD_SAREF: + value->rValue = model->B4SOIsaref; + return(OK); + case B4SOI_MOD_SBREF: + value->rValue = model->B4SOIsbref; + return(OK); + case B4SOI_MOD_WLOD: + value->rValue = model->B4SOIwlod; + return(OK); + case B4SOI_MOD_KU0: + value->rValue = model->B4SOIku0; + return(OK); + case B4SOI_MOD_KVSAT: + value->rValue = model->B4SOIkvsat; + return(OK); + case B4SOI_MOD_KVTH0: + value->rValue = model->B4SOIkvth0; + return(OK); + case B4SOI_MOD_TKU0: + value->rValue = model->B4SOItku0; + return(OK); + case B4SOI_MOD_LLODKU0: + value->rValue = model->B4SOIllodku0; + return(OK); + case B4SOI_MOD_WLODKU0: + value->rValue = model->B4SOIwlodku0; + return(OK); + case B4SOI_MOD_LLODVTH: + value->rValue = model->B4SOIllodvth; + return(OK); + case B4SOI_MOD_WLODVTH: + value->rValue = model->B4SOIwlodvth; + return(OK); + case B4SOI_MOD_LKU0: + value->rValue = model->B4SOIlku0; + return(OK); + case B4SOI_MOD_WKU0: + value->rValue = model->B4SOIwku0; + return(OK); + case B4SOI_MOD_PKU0: + value->rValue = model->B4SOIpku0; + return(OK); + case B4SOI_MOD_LKVTH0: + value->rValue = model->B4SOIlkvth0; + return(OK); + case B4SOI_MOD_WKVTH0: + value->rValue = model->B4SOIwkvth0; + return(OK); + case B4SOI_MOD_PKVTH0: + value->rValue = model->B4SOIpkvth0; + return(OK); + case B4SOI_MOD_STK2: + value->rValue = model->B4SOIstk2; + return(OK); + case B4SOI_MOD_LODK2: + value->rValue = model->B4SOIlodk2; + return(OK); + case B4SOI_MOD_STETA0: + value->rValue = model->B4SOIsteta0; + return(OK); + case B4SOI_MOD_LODETA0: + value->rValue = model->B4SOIlodeta0; + return(OK); + +/* added for stress end */ + + + + case B4SOI_MOD_NOIA: + value->rValue = model->B4SOIoxideTrapDensityA; + return(OK); + case B4SOI_MOD_NOIB: + value->rValue = model->B4SOIoxideTrapDensityB; + return(OK); + case B4SOI_MOD_NOIC: + value->rValue = model->B4SOIoxideTrapDensityC; + return(OK); + case B4SOI_MOD_NOIF: + value->rValue = model->B4SOInoif; + return(OK); + case B4SOI_MOD_EM: + value->rValue = model->B4SOIem; + return(OK); + case B4SOI_MOD_EF: + value->rValue = model->B4SOIef; + return(OK); + case B4SOI_MOD_AF: + value->rValue = model->B4SOIaf; + return(OK); + case B4SOI_MOD_KF: + value->rValue = model->B4SOIkf; + return(OK); + case B4SOI_MOD_BF: + value->rValue = model->B4SOIbf; + return(OK); + case B4SOI_MOD_W0FLK: + value->rValue = model->B4SOIw0flk; + return(OK); + + +/* v2.0 release */ + case B4SOI_MOD_K1W1: + value->rValue = model->B4SOIk1w1; + return(OK); + case B4SOI_MOD_K1W2: + value->rValue = model->B4SOIk1w2; + return(OK); + case B4SOI_MOD_KETAS: + value->rValue = model->B4SOIketas; + return(OK); + case B4SOI_MOD_DWBC: + value->rValue = model->B4SOIdwbc; + return(OK); + case B4SOI_MOD_BETA0: + value->rValue = model->B4SOIbeta0; + return(OK); + case B4SOI_MOD_BETA1: + value->rValue = model->B4SOIbeta1; + return(OK); + case B4SOI_MOD_BETA2: + value->rValue = model->B4SOIbeta2; + return(OK); + case B4SOI_MOD_VDSATII0: + value->rValue = model->B4SOIvdsatii0; + return(OK); + case B4SOI_MOD_TII: + value->rValue = model->B4SOItii; + return(OK); + case B4SOI_MOD_LII: + value->rValue = model->B4SOIlii; + return(OK); + case B4SOI_MOD_SII0: + value->rValue = model->B4SOIsii0; + return(OK); + case B4SOI_MOD_SII1: + value->rValue = model->B4SOIsii1; + return(OK); + case B4SOI_MOD_SII2: + value->rValue = model->B4SOIsii2; + return(OK); + case B4SOI_MOD_SIID: + value->rValue = model->B4SOIsiid; + return(OK); + case B4SOI_MOD_FBJTII: + value->rValue = model->B4SOIfbjtii; + return(OK); + case B4SOI_MOD_ESATII: + value->rValue = model->B4SOIesatii; + return(OK); + case B4SOI_MOD_NTUNS: /* v4.0 */ + value->rValue = model->B4SOIntun; + return(OK); + case B4SOI_MOD_NTUND: /* v4.0 */ + value->rValue = model->B4SOIntund; + return(OK); + case B4SOI_MOD_NRECF0S: /* v4.0 */ + value->rValue = model->B4SOInrecf0; + return(OK); + case B4SOI_MOD_NRECF0D: /* v4.0 */ + value->rValue = model->B4SOInrecf0d; + return(OK); + case B4SOI_MOD_NRECR0S: /* v4.0 */ + value->rValue = model->B4SOInrecr0; + return(OK); + case B4SOI_MOD_NRECR0D: /* v4.0 */ + value->rValue = model->B4SOInrecr0d; + return(OK); + case B4SOI_MOD_ISBJT: + value->rValue = model->B4SOIisbjt; + return(OK); + case B4SOI_MOD_IDBJT: /* v4.0 */ + value->rValue = model->B4SOIidbjt; + return(OK); + case B4SOI_MOD_ISDIF: + value->rValue = model->B4SOIisdif; + return(OK); + case B4SOI_MOD_IDDIF: /* v4.0 */ + value->rValue = model->B4SOIiddif; + return(OK); + case B4SOI_MOD_ISREC: + value->rValue = model->B4SOIisrec; + return(OK); + case B4SOI_MOD_IDREC: /* v4.0 */ + value->rValue = model->B4SOIidrec; + return(OK); + case B4SOI_MOD_ISTUN: + value->rValue = model->B4SOIistun; + return(OK); + case B4SOI_MOD_IDTUN: /* v4.0 */ + value->rValue = model->B4SOIidtun; + return(OK); + case B4SOI_MOD_LN: + value->rValue = model->B4SOIln; + return(OK); + case B4SOI_MOD_VREC0S: /* v4.0 */ + value->rValue = model->B4SOIvrec0; + return(OK); + case B4SOI_MOD_VREC0D: /* v4.0 */ + value->rValue = model->B4SOIvrec0d; + return(OK); + case B4SOI_MOD_VTUN0S: /* v4.0 */ + value->rValue = model->B4SOIvtun0; + return(OK); + case B4SOI_MOD_VTUN0D: /* v4.0 */ + value->rValue = model->B4SOIvtun0d; + return(OK); + case B4SOI_MOD_NBJT: + value->rValue = model->B4SOInbjt; + return(OK); + case B4SOI_MOD_LBJT0: + value->rValue = model->B4SOIlbjt0; + return(OK); + case B4SOI_MOD_LDIF0: + value->rValue = model->B4SOIldif0; + return(OK); + case B4SOI_MOD_VABJT: + value->rValue = model->B4SOIvabjt; + return(OK); + case B4SOI_MOD_AELY: + value->rValue = model->B4SOIaely; + return(OK); + case B4SOI_MOD_AHLIS: /* v4.0 */ + value->rValue = model->B4SOIahli; + return(OK); + case B4SOI_MOD_AHLID: /* v4.0 */ + value->rValue = model->B4SOIahlid; + return(OK); + case B4SOI_MOD_RBODY: + value->rValue = model->B4SOIrbody; + return(OK); + case B4SOI_MOD_RBSH: + value->rValue = model->B4SOIrbsh; + return(OK); + case B4SOI_MOD_NTRECF: + value->rValue = model->B4SOIntrecf; + return(OK); + case B4SOI_MOD_NTRECR: + value->rValue = model->B4SOIntrecr; + return(OK); + case B4SOI_MOD_NDIF: + value->rValue = model->B4SOIndif; + return(OK); + case B4SOI_MOD_DLCB: + value->rValue = model->B4SOIdlcb; + return(OK); + case B4SOI_MOD_FBODY: + value->rValue = model->B4SOIfbody; + return(OK); + case B4SOI_MOD_TCJSWGS: + value->rValue = model->B4SOItcjswg; + return(OK); + case B4SOI_MOD_TPBSWGS: + value->rValue = model->B4SOItpbswg; + return(OK); + case B4SOI_MOD_TCJSWGD: + value->rValue = model->B4SOItcjswgd; + return(OK); + case B4SOI_MOD_TPBSWGD: + value->rValue = model->B4SOItpbswgd; + return(OK); + case B4SOI_MOD_ACDE: + value->rValue = model->B4SOIacde; + return(OK); + case B4SOI_MOD_MOIN: + value->rValue = model->B4SOImoin; + return(OK); + case B4SOI_MOD_NOFF: + value->rValue = model->B4SOInoff; + return(OK); /* v3.2 */ + case B4SOI_MOD_DELVT: + value->rValue = model->B4SOIdelvt; + return(OK); + case B4SOI_MOD_KB1: + value->rValue = model->B4SOIkb1; + return(OK); + case B4SOI_MOD_DLBG: + value->rValue = model->B4SOIdlbg; + return(OK); + + case B4SOI_MOD_EGIDL: + value->rValue = model->B4SOIegidl; + return(OK); + case B4SOI_MOD_AGIDL: + value->rValue = model->B4SOIagidl; + return(OK); + case B4SOI_MOD_BGIDL: + value->rValue = model->B4SOIbgidl; + return(OK); + case B4SOI_MOD_CGIDL: + value->rValue = model->B4SOIcgidl; + return(OK); + +/* v3.0 */ + case B4SOI_MOD_SOIMOD: + value->iValue = model->B4SOIsoiMod; + return(OK); /* v3.2 bug fix */ + case B4SOI_MOD_VBS0PD: + value->rValue = model->B4SOIvbs0pd; + return(OK); /* v3.2 */ + case B4SOI_MOD_VBS0FD: + value->rValue = model->B4SOIvbs0fd; + return(OK); /* v3.2 */ + case B4SOI_MOD_VBSA: + value->rValue = model->B4SOIvbsa; + return(OK); + case B4SOI_MOD_NOFFFD: + value->rValue = model->B4SOInofffd; + return(OK); + case B4SOI_MOD_VOFFFD: + value->rValue = model->B4SOIvofffd; + return(OK); + case B4SOI_MOD_K1B: + value->rValue = model->B4SOIk1b; + return(OK); + case B4SOI_MOD_K2B: + value->rValue = model->B4SOIk2b; + return(OK); + case B4SOI_MOD_DK2B: + value->rValue = model->B4SOIdk2b; + return(OK); + case B4SOI_MOD_DVBD0: + value->rValue = model->B4SOIdvbd0; + return(OK); + case B4SOI_MOD_DVBD1: + value->rValue = model->B4SOIdvbd1; + return(OK); + case B4SOI_MOD_MOINFD: + value->rValue = model->B4SOImoinFD; + return(OK); + + + +/* v2.2 release */ + case B4SOI_MOD_WTH0: + value->rValue = model->B4SOIwth0; + return(OK); + case B4SOI_MOD_RHALO: + value->rValue = model->B4SOIrhalo; + return(OK); + case B4SOI_MOD_NTOX: + value->rValue = model->B4SOIntox; + return(OK); + case B4SOI_MOD_TOXREF: + value->rValue = model->B4SOItoxref; + return(OK); + case B4SOI_MOD_EBG: + value->rValue = model->B4SOIebg; + return(OK); + case B4SOI_MOD_VEVB: + value->rValue = model->B4SOIvevb; + return(OK); + case B4SOI_MOD_ALPHAGB1: + value->rValue = model->B4SOIalphaGB1; + return(OK); + case B4SOI_MOD_BETAGB1: + value->rValue = model->B4SOIbetaGB1; + return(OK); + case B4SOI_MOD_VGB1: + value->rValue = model->B4SOIvgb1; + return(OK); + case B4SOI_MOD_VECB: + value->rValue = model->B4SOIvecb; + return(OK); + case B4SOI_MOD_ALPHAGB2: + value->rValue = model->B4SOIalphaGB2; + return(OK); + case B4SOI_MOD_BETAGB2: + value->rValue = model->B4SOIbetaGB2; + return(OK); + case B4SOI_MOD_VGB2: + value->rValue = model->B4SOIvgb2; + return(OK); + case B4SOI_MOD_TOXQM: + value->rValue = model->B4SOItoxqm; + return(OK); + case B4SOI_MOD_VOXH: + value->rValue = model->B4SOIvoxh; + return(OK); + case B4SOI_MOD_DELTAVOX: + value->rValue = model->B4SOIdeltavox; + return(OK); +/* v4.0 */ + case B4SOI_MOD_RDSMOD : + value->iValue = model->B4SOIrdsMod; + return(OK); + case B4SOI_MOD_RBODYMOD : + value->iValue = model->B4SOIrbodyMod; + return(OK); + case B4SOI_MOD_GBMIN: + value->rValue = model->B4SOIgbmin; + return(OK); + case B4SOI_MOD_RBDB: + value->rValue = model->B4SOIrbdb; + return(OK); + case B4SOI_MOD_RBSB: + value->rValue = model->B4SOIrbsb; + return(OK); + case B4SOI_MOD_FRBODY: + value->rValue = model->B4SOIfrbody; + return(OK); + case B4SOI_MOD_DVTP0: + value->rValue = model->B4SOIdvtp0; + return(OK); + case B4SOI_MOD_DVTP1: + value->rValue = model->B4SOIdvtp1; + return(OK); + case B4SOI_MOD_LDVTP0: + value->rValue = model->B4SOIldvtp0; + return(OK); + case B4SOI_MOD_LDVTP1: + value->rValue = model->B4SOIldvtp1; + return(OK); + case B4SOI_MOD_WDVTP0: + value->rValue = model->B4SOIwdvtp0; + return(OK); + case B4SOI_MOD_WDVTP1: + value->rValue = model->B4SOIwdvtp1; + return(OK); + case B4SOI_MOD_PDVTP0: + value->rValue = model->B4SOIpdvtp0; + return(OK); + case B4SOI_MOD_PDVTP1: + value->rValue = model->B4SOIpdvtp1; + return(OK); + case B4SOI_MOD_MINV: + value->rValue = model->B4SOIminv; + return(OK); + case B4SOI_MOD_LMINV: + value->rValue = model->B4SOIlminv; + return(OK); + case B4SOI_MOD_WMINV: + value->rValue = model->B4SOIwminv; + return(OK); + case B4SOI_MOD_PMINV: + value->rValue = model->B4SOIpminv; + return(OK); + case B4SOI_MOD_FPROUT: + value->rValue = model->B4SOIfprout; + return(OK); + case B4SOI_MOD_PDITS: + value->rValue = model->B4SOIpdits; + return(OK); + case B4SOI_MOD_PDITSD: + value->rValue = model->B4SOIpditsd; + return(OK); + case B4SOI_MOD_PDITSL: + value->rValue = model->B4SOIpditsl; + return(OK); + case B4SOI_MOD_LFPROUT: + value->rValue = model->B4SOIlfprout; + return(OK); + case B4SOI_MOD_LPDITS: + value->rValue = model->B4SOIlpdits; + return(OK); + case B4SOI_MOD_LPDITSD: + value->rValue = model->B4SOIlpditsd; + return(OK); + case B4SOI_MOD_WFPROUT: + value->rValue = model->B4SOIwfprout; + return(OK); + case B4SOI_MOD_WPDITS: + value->rValue = model->B4SOIwpdits; + return(OK); + case B4SOI_MOD_WPDITSD: + value->rValue = model->B4SOIwpditsd; + return(OK); + case B4SOI_MOD_PFPROUT: + value->rValue = model->B4SOIpfprout; + return(OK); + case B4SOI_MOD_PPDITS: + value->rValue = model->B4SOIppdits; + return(OK); + case B4SOI_MOD_PPDITSD: + value->rValue = model->B4SOIppditsd; + return(OK); + +/* v4.0 end */ + +/* v3.2 */ + case B4SOI_MOD_FNOIMOD : + value->iValue = model->B4SOIfnoiMod; + return(OK); + case B4SOI_MOD_TNOIMOD : + value->iValue = model->B4SOItnoiMod; + case B4SOI_MOD_TNOIA: + value->rValue = model->B4SOItnoia; + return(OK); + case B4SOI_MOD_TNOIB: + value->rValue = model->B4SOItnoib; + return(OK); + case B4SOI_MOD_RNOIA: + value->rValue = model->B4SOIrnoia; + return(OK); + case B4SOI_MOD_RNOIB: + value->rValue = model->B4SOIrnoib; + return(OK); + case B4SOI_MOD_NTNOI: + value->rValue = model->B4SOIntnoi; + return(OK); +/* v3.2 */ + +/* v3.1 added for RF */ + case B4SOI_MOD_RGATEMOD : + value->iValue = model->B4SOIrgateMod; + return(OK); + case B4SOI_MOD_XRCRG1: + value->iValue = model->B4SOIxrcrg1; + return(OK); + case B4SOI_MOD_XRCRG2: + value->iValue = model->B4SOIxrcrg2; + return(OK); + case B4SOI_MOD_RSHG: + value->rValue = model->B4SOIrshg; + return(OK); + case B4SOI_MOD_NGCON: + value->rValue = model->B4SOIngcon; + return(OK); + case B4SOI_MOD_XGW: + value->rValue = model->B4SOIxgw; + return(OK); + case B4SOI_MOD_XGL: + value->rValue = model->B4SOIxgl; + return(OK); +/* v3.1 added for RF end */ + +/* v3.0 */ + case B4SOI_MOD_IGBMOD: + value->iValue = model->B4SOIigbMod; + return(OK); + case B4SOI_MOD_IGCMOD: + value->iValue = model->B4SOIigcMod; + return(OK); + case B4SOI_MOD_AIGC: + value->rValue = model->B4SOIaigc; + return(OK); + case B4SOI_MOD_BIGC: + value->rValue = model->B4SOIbigc; + return(OK); + case B4SOI_MOD_CIGC: + value->rValue = model->B4SOIcigc; + return(OK); + case B4SOI_MOD_AIGSD: + value->rValue = model->B4SOIaigsd; + return(OK); + case B4SOI_MOD_BIGSD: + value->rValue = model->B4SOIbigsd; + return(OK); + case B4SOI_MOD_CIGSD: + value->rValue = model->B4SOIcigsd; + return(OK); + case B4SOI_MOD_NIGC: + value->rValue = model->B4SOInigc; + return(OK); + case B4SOI_MOD_PIGCD: + value->rValue = model->B4SOIpigcd; + return(OK); + case B4SOI_MOD_POXEDGE: + value->rValue = model->B4SOIpoxedge; + return(OK); + case B4SOI_MOD_DLCIG: + value->rValue = model->B4SOIdlcig; + return(OK); + + + +/* Added for binning - START */ + /* Length Dependence */ +/* v3.1 */ + case B4SOI_MOD_LXJ: + value->rValue = model->B4SOIlxj; + return(OK); + case B4SOI_MOD_LALPHAGB1: + value->rValue = model->B4SOIlalphaGB1; + return(OK); + case B4SOI_MOD_LALPHAGB2: + value->rValue = model->B4SOIlalphaGB2; + return(OK); + case B4SOI_MOD_LBETAGB1: + value->rValue = model->B4SOIlbetaGB1; + return(OK); + case B4SOI_MOD_LBETAGB2: + value->rValue = model->B4SOIlbetaGB2; + return(OK); + case B4SOI_MOD_LNDIF: + value->rValue = model->B4SOIlndif; + return(OK); + case B4SOI_MOD_LNTRECF: + value->rValue = model->B4SOIlntrecf; + return(OK); + case B4SOI_MOD_LNTRECR: + value->rValue = model->B4SOIlntrecr; + return(OK); + case B4SOI_MOD_LXBJT: + value->rValue = model->B4SOIlxbjt; + return(OK); + case B4SOI_MOD_LXDIFS: + value->rValue = model->B4SOIlxdif; + return(OK); + case B4SOI_MOD_LXRECS: + value->rValue = model->B4SOIlxrec; + return(OK); + case B4SOI_MOD_LXTUNS: + value->rValue = model->B4SOIlxtun; + return(OK); + case B4SOI_MOD_LXDIFD: + value->rValue = model->B4SOIlxdifd; + return(OK); + case B4SOI_MOD_LXRECD: + value->rValue = model->B4SOIlxrecd; + return(OK); + case B4SOI_MOD_LXTUND: + value->rValue = model->B4SOIlxtund; + return(OK); + case B4SOI_MOD_LCGDL: + value->rValue = model->B4SOIlcgdl; + return(OK); + case B4SOI_MOD_LCGSL: + value->rValue = model->B4SOIlcgsl; + return(OK); + case B4SOI_MOD_LCKAPPA: + value->rValue = model->B4SOIlckappa; + return(OK); + case B4SOI_MOD_LUTE: + value->rValue = model->B4SOIlute; + return(OK); + case B4SOI_MOD_LKT1: + value->rValue = model->B4SOIlkt1; + return(OK); + case B4SOI_MOD_LKT2: + value->rValue = model->B4SOIlkt2; + return(OK); + case B4SOI_MOD_LKT1L: + value->rValue = model->B4SOIlkt1l; + return(OK); + case B4SOI_MOD_LUA1: + value->rValue = model->B4SOIlua1; + return(OK); + case B4SOI_MOD_LUB1: + value->rValue = model->B4SOIlub1; + return(OK); + case B4SOI_MOD_LUC1: + value->rValue = model->B4SOIluc1; + return(OK); + case B4SOI_MOD_LAT: + value->rValue = model->B4SOIlat; + return(OK); + case B4SOI_MOD_LPRT: + value->rValue = model->B4SOIlprt; + return(OK); + + +/* v3.0 */ + case B4SOI_MOD_LAIGC: + value->rValue = model->B4SOIlaigc; + return(OK); + case B4SOI_MOD_LBIGC: + value->rValue = model->B4SOIlbigc; + return(OK); + case B4SOI_MOD_LCIGC: + value->rValue = model->B4SOIlcigc; + return(OK); + case B4SOI_MOD_LAIGSD: + value->rValue = model->B4SOIlaigsd; + return(OK); + case B4SOI_MOD_LBIGSD: + value->rValue = model->B4SOIlbigsd; + return(OK); + case B4SOI_MOD_LCIGSD: + value->rValue = model->B4SOIlcigsd; + return(OK); + case B4SOI_MOD_LNIGC: + value->rValue = model->B4SOIlnigc; + return(OK); + case B4SOI_MOD_LPIGCD: + value->rValue = model->B4SOIlpigcd; + return(OK); + case B4SOI_MOD_LPOXEDGE: + value->rValue = model->B4SOIlpoxedge; + return(OK); + + case B4SOI_MOD_LNPEAK: + value->rValue = model->B4SOIlnpeak; + return(OK); + case B4SOI_MOD_LNSUB: + value->rValue = model->B4SOIlnsub; + return(OK); + case B4SOI_MOD_LNGATE: + value->rValue = model->B4SOIlngate; + return(OK); + case B4SOI_MOD_LVTH0: + value->rValue = model->B4SOIlvth0; + return(OK); + case B4SOI_MOD_LK1: + value->rValue = model->B4SOIlk1; + return(OK); + case B4SOI_MOD_LK1W1: + value->rValue = model->B4SOIlk1w1; + return(OK); + case B4SOI_MOD_LK1W2: + value->rValue = model->B4SOIlk1w2; + return(OK); + case B4SOI_MOD_LK2: + value->rValue = model->B4SOIlk2; + return(OK); + case B4SOI_MOD_LK3: + value->rValue = model->B4SOIlk3; + return(OK); + case B4SOI_MOD_LK3B: + value->rValue = model->B4SOIlk3b; + return(OK); + case B4SOI_MOD_LKB1: + value->rValue = model->B4SOIlkb1; + return(OK); + case B4SOI_MOD_LW0: + value->rValue = model->B4SOIlw0; + return(OK); + case B4SOI_MOD_LLPE0: + value->rValue = model->B4SOIllpe0; + return(OK); + case B4SOI_MOD_LLPEB: /* v4.0 for Vth */ + value->rValue = model->B4SOIllpeb; + return(OK); + case B4SOI_MOD_LDVT0 : + value->rValue = model->B4SOIldvt0; + return(OK); + case B4SOI_MOD_LDVT1 : + value->rValue = model->B4SOIldvt1; + return(OK); + case B4SOI_MOD_LDVT2 : + value->rValue = model->B4SOIldvt2; + return(OK); + case B4SOI_MOD_LDVT0W : + value->rValue = model->B4SOIldvt0w; + return(OK); + case B4SOI_MOD_LDVT1W : + value->rValue = model->B4SOIldvt1w; + return(OK); + case B4SOI_MOD_LDVT2W : + value->rValue = model->B4SOIldvt2w; + return(OK); + case B4SOI_MOD_LU0: + value->rValue = model->B4SOIlu0; + return(OK); + case B4SOI_MOD_LUA: + value->rValue = model->B4SOIlua; + return(OK); + case B4SOI_MOD_LUB: + value->rValue = model->B4SOIlub; + return(OK); + case B4SOI_MOD_LUC: + value->rValue = model->B4SOIluc; + return(OK); + case B4SOI_MOD_LVSAT: + value->rValue = model->B4SOIlvsat; + return(OK); + case B4SOI_MOD_LA0: + value->rValue = model->B4SOIla0; + return(OK); + case B4SOI_MOD_LAGS: + value->rValue = model->B4SOIlags; + return(OK); + case B4SOI_MOD_LB0: + value->rValue = model->B4SOIlb0; + return(OK); + case B4SOI_MOD_LB1: + value->rValue = model->B4SOIlb1; + return(OK); + case B4SOI_MOD_LKETA: + value->rValue = model->B4SOIlketa; + return(OK); + case B4SOI_MOD_LKETAS: + value->rValue = model->B4SOIlketas; + return(OK); + case B4SOI_MOD_LA1: + value->rValue = model->B4SOIla1; + return(OK); + case B4SOI_MOD_LA2: + value->rValue = model->B4SOIla2; + return(OK); + case B4SOI_MOD_LRDSW: + value->rValue = model->B4SOIlrdsw; + return(OK); + case B4SOI_MOD_LRDW: + value->rValue = model->B4SOIlrdw; + return(OK); + case B4SOI_MOD_LRSW: + value->rValue = model->B4SOIlrsw; + return(OK); + case B4SOI_MOD_LPRWB: + value->rValue = model->B4SOIlprwb; + return(OK); + case B4SOI_MOD_LPRWG: + value->rValue = model->B4SOIlprwg; + return(OK); + case B4SOI_MOD_LWR: + value->rValue = model->B4SOIlwr; + return(OK); + case B4SOI_MOD_LNFACTOR : + value->rValue = model->B4SOIlnfactor; + return(OK); + case B4SOI_MOD_LDWG: + value->rValue = model->B4SOIldwg; + return(OK); + case B4SOI_MOD_LDWB: + value->rValue = model->B4SOIldwb; + return(OK); + case B4SOI_MOD_LVOFF: + value->rValue = model->B4SOIlvoff; + return(OK); + case B4SOI_MOD_LETA0: + value->rValue = model->B4SOIleta0; + return(OK); + case B4SOI_MOD_LETAB: + value->rValue = model->B4SOIletab; + return(OK); + case B4SOI_MOD_LDSUB : + value->rValue = model->B4SOIldsub; + return(OK); + case B4SOI_MOD_LCIT : + value->rValue = model->B4SOIlcit; + return(OK); + case B4SOI_MOD_LCDSC : + value->rValue = model->B4SOIlcdsc; + return(OK); + case B4SOI_MOD_LCDSCB : + value->rValue = model->B4SOIlcdscb; + return(OK); + case B4SOI_MOD_LCDSCD : + value->rValue = model->B4SOIlcdscd; + return(OK); + case B4SOI_MOD_LPCLM: + value->rValue = model->B4SOIlpclm; + return(OK); + case B4SOI_MOD_LPDIBL1: + value->rValue = model->B4SOIlpdibl1; + return(OK); + case B4SOI_MOD_LPDIBL2: + value->rValue = model->B4SOIlpdibl2; + return(OK); + case B4SOI_MOD_LPDIBLB: + value->rValue = model->B4SOIlpdiblb; + return(OK); + case B4SOI_MOD_LDROUT : + value->rValue = model->B4SOIldrout; + return(OK); + case B4SOI_MOD_LPVAG: + value->rValue = model->B4SOIlpvag; + return(OK); + case B4SOI_MOD_LDELTA: + value->rValue = model->B4SOIldelta; + return(OK); + case B4SOI_MOD_LALPHA0: + value->rValue = model->B4SOIlalpha0; + return(OK); + case B4SOI_MOD_LFBJTII: + value->rValue = model->B4SOIlfbjtii; + return(OK); + case B4SOI_MOD_LBETA0: + value->rValue = model->B4SOIlbeta0; + return(OK); + case B4SOI_MOD_LBETA1: + value->rValue = model->B4SOIlbeta1; + return(OK); + case B4SOI_MOD_LBETA2: + value->rValue = model->B4SOIlbeta2; + return(OK); + case B4SOI_MOD_LVDSATII0: + value->rValue = model->B4SOIlvdsatii0; + return(OK); + case B4SOI_MOD_LLII: + value->rValue = model->B4SOIllii; + return(OK); + case B4SOI_MOD_LESATII: + value->rValue = model->B4SOIlesatii; + return(OK); + case B4SOI_MOD_LSII0: + value->rValue = model->B4SOIlsii0; + return(OK); + case B4SOI_MOD_LSII1: + value->rValue = model->B4SOIlsii1; + return(OK); + case B4SOI_MOD_LSII2: + value->rValue = model->B4SOIlsii2; + return(OK); + case B4SOI_MOD_LSIID: + value->rValue = model->B4SOIlsiid; + return(OK); + case B4SOI_MOD_LAGIDL: + value->rValue = model->B4SOIlagidl; + return(OK); + case B4SOI_MOD_LBGIDL: + value->rValue = model->B4SOIlbgidl; + return(OK); + case B4SOI_MOD_LCGIDL: + value->rValue = model->B4SOIlcgidl; + return(OK); + case B4SOI_MOD_LEGIDL: + value->rValue = model->B4SOIlegidl; + return(OK); + case B4SOI_MOD_LNTUNS: /* v4.0 */ + value->rValue = model->B4SOIlntun; + return(OK); + case B4SOI_MOD_LNTUND: /* v4.0 */ + value->rValue = model->B4SOIlntund; + return(OK); + case B4SOI_MOD_LNDIODES: /* v4.0 */ + value->rValue = model->B4SOIlndiode; + return(OK); + case B4SOI_MOD_LNDIODED: /* v4.0 */ + value->rValue = model->B4SOIlndioded; + return(OK); + case B4SOI_MOD_LNRECF0S: /* v4.0 */ + value->rValue = model->B4SOIlnrecf0; + return(OK); + case B4SOI_MOD_LNRECF0D: /* v4.0 */ + value->rValue = model->B4SOIlnrecf0d; + return(OK); + case B4SOI_MOD_LNRECR0S: /* v4.0 */ + value->rValue = model->B4SOIlnrecr0; + return(OK); + case B4SOI_MOD_LNRECR0D: /* v4.0 */ + value->rValue = model->B4SOIlnrecr0d; + return(OK); + case B4SOI_MOD_LISBJT: + value->rValue = model->B4SOIlisbjt; + return(OK); + case B4SOI_MOD_LIDBJT: /* v4.0 */ + value->rValue = model->B4SOIlidbjt; + return(OK); + case B4SOI_MOD_LISDIF: + value->rValue = model->B4SOIlisdif; + return(OK); + case B4SOI_MOD_LIDDIF: /* v4.0 */ + value->rValue = model->B4SOIliddif; + return(OK); + case B4SOI_MOD_LISREC: + value->rValue = model->B4SOIlisrec; + return(OK); + case B4SOI_MOD_LIDREC: /* v4.0 */ + value->rValue = model->B4SOIlidrec; + return(OK); + case B4SOI_MOD_LISTUN: + value->rValue = model->B4SOIlistun; + return(OK); + case B4SOI_MOD_LIDTUN: /* v4.0 */ + value->rValue = model->B4SOIlidtun; + return(OK); + case B4SOI_MOD_LVREC0S: /* v4.0 */ + value->rValue = model->B4SOIlvrec0; + return(OK); + case B4SOI_MOD_LVREC0D: /* v4.0 */ + value->rValue = model->B4SOIlvrec0d; + return(OK); + case B4SOI_MOD_LVTUN0S: /* v4.0 */ + value->rValue = model->B4SOIlvtun0; + return(OK); + case B4SOI_MOD_LVTUN0D: /* v4.0 */ + value->rValue = model->B4SOIlvtun0d; + return(OK); + case B4SOI_MOD_LNBJT: + value->rValue = model->B4SOIlnbjt; + return(OK); + case B4SOI_MOD_LLBJT0: + value->rValue = model->B4SOIllbjt0; + return(OK); + case B4SOI_MOD_LVABJT: + value->rValue = model->B4SOIlvabjt; + return(OK); + case B4SOI_MOD_LAELY: + value->rValue = model->B4SOIlaely; + return(OK); + case B4SOI_MOD_LAHLIS: /* v4.0 */ + value->rValue = model->B4SOIlahli; + return(OK); + case B4SOI_MOD_LAHLID: /* v4.0 */ + value->rValue = model->B4SOIlahlid; + return(OK); + /* CV Model */ + case B4SOI_MOD_LVSDFB: + value->rValue = model->B4SOIlvsdfb; + return(OK); + case B4SOI_MOD_LVSDTH: + value->rValue = model->B4SOIlvsdth; + return(OK); + case B4SOI_MOD_LDELVT: + value->rValue = model->B4SOIldelvt; + return(OK); + case B4SOI_MOD_LACDE: + value->rValue = model->B4SOIlacde; + return(OK); + case B4SOI_MOD_LMOIN: + value->rValue = model->B4SOIlmoin; + return(OK); + case B4SOI_MOD_LNOFF: + value->rValue = model->B4SOIlnoff; + return(OK); /* v3.2 */ + + /* Width Dependence */ +/* v3.1 */ + case B4SOI_MOD_WXJ: + value->rValue = model->B4SOIwxj; + return(OK); + case B4SOI_MOD_WALPHAGB1: + value->rValue = model->B4SOIwalphaGB1; + return(OK); + case B4SOI_MOD_WALPHAGB2: + value->rValue = model->B4SOIwalphaGB2; + return(OK); + case B4SOI_MOD_WBETAGB1: + value->rValue = model->B4SOIwbetaGB1; + return(OK); + case B4SOI_MOD_WBETAGB2: + value->rValue = model->B4SOIwbetaGB2; + return(OK); + case B4SOI_MOD_WNDIF: + value->rValue = model->B4SOIwndif; + return(OK); + case B4SOI_MOD_WNTRECF: + value->rValue = model->B4SOIwntrecf; + return(OK); + case B4SOI_MOD_WNTRECR: + value->rValue = model->B4SOIwntrecr; + return(OK); + case B4SOI_MOD_WXBJT: + value->rValue = model->B4SOIwxbjt; + return(OK); + case B4SOI_MOD_WXDIFS: + value->rValue = model->B4SOIwxdif; + return(OK); + case B4SOI_MOD_WXRECS: + value->rValue = model->B4SOIwxrec; + return(OK); + case B4SOI_MOD_WXTUNS: + value->rValue = model->B4SOIwxtun; + return(OK); + case B4SOI_MOD_WXDIFD: + value->rValue = model->B4SOIwxdifd; + return(OK); + case B4SOI_MOD_WXRECD: + value->rValue = model->B4SOIwxrecd; + return(OK); + case B4SOI_MOD_WXTUND: + value->rValue = model->B4SOIwxtund; + return(OK); + case B4SOI_MOD_WCGDL: + value->rValue = model->B4SOIwcgdl; + return(OK); + case B4SOI_MOD_WCGSL: + value->rValue = model->B4SOIwcgsl; + return(OK); + case B4SOI_MOD_WCKAPPA: + value->rValue = model->B4SOIwckappa; + return(OK); + case B4SOI_MOD_WUTE: + value->rValue = model->B4SOIwute; + return(OK); + case B4SOI_MOD_WKT1: + value->rValue = model->B4SOIwkt1; + return(OK); + case B4SOI_MOD_WKT2: + value->rValue = model->B4SOIwkt2; + return(OK); + case B4SOI_MOD_WKT1L: + value->rValue = model->B4SOIwkt1l; + return(OK); + case B4SOI_MOD_WUA1: + value->rValue = model->B4SOIwua1; + return(OK); + case B4SOI_MOD_WUB1: + value->rValue = model->B4SOIwub1; + return(OK); + case B4SOI_MOD_WUC1: + value->rValue = model->B4SOIwuc1; + return(OK); + case B4SOI_MOD_WAT: + value->rValue = model->B4SOIwat; + return(OK); + case B4SOI_MOD_WPRT: + value->rValue = model->B4SOIwprt; + return(OK); + +/* v3.0 */ + case B4SOI_MOD_WAIGC: + value->rValue = model->B4SOIwaigc; + return(OK); + case B4SOI_MOD_WBIGC: + value->rValue = model->B4SOIwbigc; + return(OK); + case B4SOI_MOD_WCIGC: + value->rValue = model->B4SOIwcigc; + return(OK); + case B4SOI_MOD_WAIGSD: + value->rValue = model->B4SOIwaigsd; + return(OK); + case B4SOI_MOD_WBIGSD: + value->rValue = model->B4SOIwbigsd; + return(OK); + case B4SOI_MOD_WCIGSD: + value->rValue = model->B4SOIwcigsd; + return(OK); + case B4SOI_MOD_WNIGC: + value->rValue = model->B4SOIwnigc; + return(OK); + case B4SOI_MOD_WPIGCD: + value->rValue = model->B4SOIwpigcd; + return(OK); + case B4SOI_MOD_WPOXEDGE: + value->rValue = model->B4SOIwpoxedge; + return(OK); + + case B4SOI_MOD_WNPEAK: + value->rValue = model->B4SOIwnpeak; + return(OK); + case B4SOI_MOD_WNSUB: + value->rValue = model->B4SOIwnsub; + return(OK); + case B4SOI_MOD_WNGATE: + value->rValue = model->B4SOIwngate; + return(OK); + case B4SOI_MOD_WVTH0: + value->rValue = model->B4SOIwvth0; + return(OK); + case B4SOI_MOD_WK1: + value->rValue = model->B4SOIwk1; + return(OK); + case B4SOI_MOD_WK1W1: + value->rValue = model->B4SOIwk1w1; + return(OK); + case B4SOI_MOD_WK1W2: + value->rValue = model->B4SOIwk1w2; + return(OK); + case B4SOI_MOD_WK2: + value->rValue = model->B4SOIwk2; + return(OK); + case B4SOI_MOD_WK3: + value->rValue = model->B4SOIwk3; + return(OK); + case B4SOI_MOD_WK3B: + value->rValue = model->B4SOIwk3b; + return(OK); + case B4SOI_MOD_WKB1: + value->rValue = model->B4SOIwkb1; + return(OK); + case B4SOI_MOD_WW0: + value->rValue = model->B4SOIww0; + return(OK); + case B4SOI_MOD_WLPE0: + value->rValue = model->B4SOIwlpe0; + return(OK); + case B4SOI_MOD_WLPEB: /* v4.0 for Vth */ + value->rValue = model->B4SOIwlpeb; + return(OK); + case B4SOI_MOD_WDVT0 : + value->rValue = model->B4SOIwdvt0; + return(OK); + case B4SOI_MOD_WDVT1 : + value->rValue = model->B4SOIwdvt1; + return(OK); + case B4SOI_MOD_WDVT2 : + value->rValue = model->B4SOIwdvt2; + return(OK); + case B4SOI_MOD_WDVT0W : + value->rValue = model->B4SOIwdvt0w; + return(OK); + case B4SOI_MOD_WDVT1W : + value->rValue = model->B4SOIwdvt1w; + return(OK); + case B4SOI_MOD_WDVT2W : + value->rValue = model->B4SOIwdvt2w; + return(OK); + case B4SOI_MOD_WU0: + value->rValue = model->B4SOIwu0; + return(OK); + case B4SOI_MOD_WUA: + value->rValue = model->B4SOIwua; + return(OK); + case B4SOI_MOD_WUB: + value->rValue = model->B4SOIwub; + return(OK); + case B4SOI_MOD_WUC: + value->rValue = model->B4SOIwuc; + return(OK); + case B4SOI_MOD_WVSAT: + value->rValue = model->B4SOIwvsat; + return(OK); + case B4SOI_MOD_WA0: + value->rValue = model->B4SOIwa0; + return(OK); + case B4SOI_MOD_WAGS: + value->rValue = model->B4SOIwags; + return(OK); + case B4SOI_MOD_WB0: + value->rValue = model->B4SOIwb0; + return(OK); + case B4SOI_MOD_WB1: + value->rValue = model->B4SOIwb1; + return(OK); + case B4SOI_MOD_WKETA: + value->rValue = model->B4SOIwketa; + return(OK); + case B4SOI_MOD_WKETAS: + value->rValue = model->B4SOIwketas; + return(OK); + case B4SOI_MOD_WA1: + value->rValue = model->B4SOIwa1; + return(OK); + case B4SOI_MOD_WA2: + value->rValue = model->B4SOIwa2; + return(OK); + case B4SOI_MOD_WRDSW: + value->rValue = model->B4SOIwrdsw; + return(OK); + case B4SOI_MOD_WRDW: + value->rValue = model->B4SOIwrdw; + return(OK); + case B4SOI_MOD_WRSW: + value->rValue = model->B4SOIwrsw; + return(OK); + case B4SOI_MOD_WPRWB: + value->rValue = model->B4SOIwprwb; + return(OK); + case B4SOI_MOD_WPRWG: + value->rValue = model->B4SOIwprwg; + return(OK); + case B4SOI_MOD_WWR: + value->rValue = model->B4SOIwwr; + return(OK); + case B4SOI_MOD_WNFACTOR : + value->rValue = model->B4SOIwnfactor; + return(OK); + case B4SOI_MOD_WDWG: + value->rValue = model->B4SOIwdwg; + return(OK); + case B4SOI_MOD_WDWB: + value->rValue = model->B4SOIwdwb; + return(OK); + case B4SOI_MOD_WVOFF: + value->rValue = model->B4SOIwvoff; + return(OK); + case B4SOI_MOD_WETA0: + value->rValue = model->B4SOIweta0; + return(OK); + case B4SOI_MOD_WETAB: + value->rValue = model->B4SOIwetab; + return(OK); + case B4SOI_MOD_WDSUB : + value->rValue = model->B4SOIwdsub; + return(OK); + case B4SOI_MOD_WCIT : + value->rValue = model->B4SOIwcit; + return(OK); + case B4SOI_MOD_WCDSC : + value->rValue = model->B4SOIwcdsc; + return(OK); + case B4SOI_MOD_WCDSCB : + value->rValue = model->B4SOIwcdscb; + return(OK); + case B4SOI_MOD_WCDSCD : + value->rValue = model->B4SOIwcdscd; + return(OK); + case B4SOI_MOD_WPCLM: + value->rValue = model->B4SOIwpclm; + return(OK); + case B4SOI_MOD_WPDIBL1: + value->rValue = model->B4SOIwpdibl1; + return(OK); + case B4SOI_MOD_WPDIBL2: + value->rValue = model->B4SOIwpdibl2; + return(OK); + case B4SOI_MOD_WPDIBLB: + value->rValue = model->B4SOIwpdiblb; + return(OK); + case B4SOI_MOD_WDROUT : + value->rValue = model->B4SOIwdrout; + return(OK); + case B4SOI_MOD_WPVAG: + value->rValue = model->B4SOIwpvag; + return(OK); + case B4SOI_MOD_WDELTA: + value->rValue = model->B4SOIwdelta; + return(OK); + case B4SOI_MOD_WALPHA0: + value->rValue = model->B4SOIwalpha0; + return(OK); + case B4SOI_MOD_WFBJTII: + value->rValue = model->B4SOIwfbjtii; + return(OK); + case B4SOI_MOD_WBETA0: + value->rValue = model->B4SOIwbeta0; + return(OK); + case B4SOI_MOD_WBETA1: + value->rValue = model->B4SOIwbeta1; + return(OK); + case B4SOI_MOD_WBETA2: + value->rValue = model->B4SOIwbeta2; + return(OK); + case B4SOI_MOD_WVDSATII0: + value->rValue = model->B4SOIwvdsatii0; + return(OK); + case B4SOI_MOD_WLII: + value->rValue = model->B4SOIwlii; + return(OK); + case B4SOI_MOD_WESATII: + value->rValue = model->B4SOIwesatii; + return(OK); + case B4SOI_MOD_WSII0: + value->rValue = model->B4SOIwsii0; + return(OK); + case B4SOI_MOD_WSII1: + value->rValue = model->B4SOIwsii1; + return(OK); + case B4SOI_MOD_WSII2: + value->rValue = model->B4SOIwsii2; + return(OK); + case B4SOI_MOD_WSIID: + value->rValue = model->B4SOIwsiid; + return(OK); + case B4SOI_MOD_WAGIDL: + value->rValue = model->B4SOIwagidl; + return(OK); + case B4SOI_MOD_WBGIDL: + value->rValue = model->B4SOIwbgidl; + return(OK); + case B4SOI_MOD_WCGIDL: + value->rValue = model->B4SOIwcgidl; + return(OK); + case B4SOI_MOD_WEGIDL: + value->rValue = model->B4SOIwegidl; + return(OK); + case B4SOI_MOD_WNTUNS: /* v4.0 */ + value->rValue = model->B4SOIwntun; + return(OK); + case B4SOI_MOD_WNTUND: /* v4.0 */ + value->rValue = model->B4SOIwntund; + return(OK); + case B4SOI_MOD_WNDIODES: /* v4.0 */ + value->rValue = model->B4SOIwndiode; + return(OK); + case B4SOI_MOD_WNDIODED: /* v4.0 */ + value->rValue = model->B4SOIwndioded; + return(OK); + case B4SOI_MOD_WNRECF0S: /* v4.0 */ + value->rValue = model->B4SOIwnrecf0; + return(OK); + case B4SOI_MOD_WNRECF0D: /* v4.0 */ + value->rValue = model->B4SOIwnrecf0d; + return(OK); + case B4SOI_MOD_WNRECR0S: /* v4.0 */ + value->rValue = model->B4SOIwnrecr0; + return(OK); + case B4SOI_MOD_WNRECR0D: /* v4.0 */ + value->rValue = model->B4SOIwnrecr0d; + return(OK); + case B4SOI_MOD_WISBJT: + value->rValue = model->B4SOIwisbjt; + return(OK); + case B4SOI_MOD_WIDBJT: /* v4.0 */ + value->rValue = model->B4SOIwidbjt; + return(OK); + case B4SOI_MOD_WISDIF: + value->rValue = model->B4SOIwisdif; + return(OK); + case B4SOI_MOD_WIDDIF: /* v4.0 */ + value->rValue = model->B4SOIwiddif; + return(OK); + case B4SOI_MOD_WISREC: + value->rValue = model->B4SOIwisrec; + return(OK); + case B4SOI_MOD_WIDREC: /* v4.0 */ + value->rValue = model->B4SOIwidrec; + return(OK); + case B4SOI_MOD_WISTUN: + value->rValue = model->B4SOIwistun; + return(OK); + case B4SOI_MOD_WIDTUN: /* v4.0 */ + value->rValue = model->B4SOIwidtun; + return(OK); + case B4SOI_MOD_WVREC0S: /* v4.0 */ + value->rValue = model->B4SOIwvrec0; + return(OK); + case B4SOI_MOD_WVREC0D: /* v4.0 */ + value->rValue = model->B4SOIwvrec0d; + return(OK); + case B4SOI_MOD_WVTUN0S: /* v4.0 */ + value->rValue = model->B4SOIwvtun0; + return(OK); + case B4SOI_MOD_WVTUN0D: /* v4.0 */ + value->rValue = model->B4SOIwvtun0d; + return(OK); + case B4SOI_MOD_WNBJT: + value->rValue = model->B4SOIwnbjt; + return(OK); + case B4SOI_MOD_WLBJT0: + value->rValue = model->B4SOIwlbjt0; + return(OK); + case B4SOI_MOD_WVABJT: + value->rValue = model->B4SOIwvabjt; + return(OK); + case B4SOI_MOD_WAELY: + value->rValue = model->B4SOIwaely; + return(OK); + case B4SOI_MOD_WAHLIS: /* v4.0 */ + value->rValue = model->B4SOIwahli; + return(OK); + case B4SOI_MOD_WAHLID: /* v4.0 */ + value->rValue = model->B4SOIwahlid; + return(OK); + /* CV Model */ + case B4SOI_MOD_WVSDFB: + value->rValue = model->B4SOIwvsdfb; + return(OK); + case B4SOI_MOD_WVSDTH: + value->rValue = model->B4SOIwvsdth; + return(OK); + case B4SOI_MOD_WDELVT: + value->rValue = model->B4SOIwdelvt; + return(OK); + case B4SOI_MOD_WACDE: + value->rValue = model->B4SOIwacde; + return(OK); + case B4SOI_MOD_WMOIN: + value->rValue = model->B4SOIwmoin; + return(OK); + case B4SOI_MOD_WNOFF: + value->rValue = model->B4SOIwnoff; + return(OK); /* v3.2 */ + + /* Cross-term Dependence */ +/* v3.1 */ + case B4SOI_MOD_PXJ: + value->rValue = model->B4SOIpxj; + return(OK); + case B4SOI_MOD_PALPHAGB1: + value->rValue = model->B4SOIpalphaGB1; + return(OK); + case B4SOI_MOD_PALPHAGB2: + value->rValue = model->B4SOIpalphaGB2; + return(OK); + case B4SOI_MOD_PBETAGB1: + value->rValue = model->B4SOIpbetaGB1; + return(OK); + case B4SOI_MOD_PBETAGB2: + value->rValue = model->B4SOIpbetaGB2; + return(OK); + case B4SOI_MOD_PNDIF: + value->rValue = model->B4SOIpndif; + return(OK); + case B4SOI_MOD_PNTRECF: + value->rValue = model->B4SOIpntrecf; + return(OK); + case B4SOI_MOD_PNTRECR: + value->rValue = model->B4SOIpntrecr; + return(OK); + case B4SOI_MOD_PXBJT: + value->rValue = model->B4SOIpxbjt; + return(OK); + case B4SOI_MOD_PXDIFS: + value->rValue = model->B4SOIpxdif; + return(OK); + case B4SOI_MOD_PXRECS: + value->rValue = model->B4SOIpxrec; + return(OK); + case B4SOI_MOD_PXTUNS: + value->rValue = model->B4SOIpxtun; + return(OK); + case B4SOI_MOD_PXDIFD: + value->rValue = model->B4SOIpxdifd; + return(OK); + case B4SOI_MOD_PXRECD: + value->rValue = model->B4SOIpxrecd; + return(OK); + case B4SOI_MOD_PXTUND: + value->rValue = model->B4SOIpxtund; + return(OK); + case B4SOI_MOD_PCGDL: + value->rValue = model->B4SOIpcgdl; + return(OK); + case B4SOI_MOD_PCGSL: + value->rValue = model->B4SOIpcgsl; + return(OK); + case B4SOI_MOD_PCKAPPA: + value->rValue = model->B4SOIpckappa; + return(OK); + case B4SOI_MOD_PUTE: + value->rValue = model->B4SOIpute; + return(OK); + case B4SOI_MOD_PKT1: + value->rValue = model->B4SOIpkt1; + return(OK); + case B4SOI_MOD_PKT2: + value->rValue = model->B4SOIpkt2; + return(OK); + case B4SOI_MOD_PKT1L: + value->rValue = model->B4SOIpkt1l; + return(OK); + case B4SOI_MOD_PUA1: + value->rValue = model->B4SOIpua1; + return(OK); + case B4SOI_MOD_PUB1: + value->rValue = model->B4SOIpub1; + return(OK); + case B4SOI_MOD_PUC1: + value->rValue = model->B4SOIpuc1; + return(OK); + case B4SOI_MOD_PAT: + value->rValue = model->B4SOIpat; + return(OK); + case B4SOI_MOD_PPRT: + value->rValue = model->B4SOIpprt; + return(OK); + + +/* v3.0 */ + case B4SOI_MOD_PAIGC: + value->rValue = model->B4SOIpaigc; + return(OK); + case B4SOI_MOD_PBIGC: + value->rValue = model->B4SOIpbigc; + return(OK); + case B4SOI_MOD_PCIGC: + value->rValue = model->B4SOIpcigc; + return(OK); + case B4SOI_MOD_PAIGSD: + value->rValue = model->B4SOIpaigsd; + return(OK); + case B4SOI_MOD_PBIGSD: + value->rValue = model->B4SOIpbigsd; + return(OK); + case B4SOI_MOD_PCIGSD: + value->rValue = model->B4SOIpcigsd; + return(OK); + case B4SOI_MOD_PNIGC: + value->rValue = model->B4SOIpnigc; + return(OK); + case B4SOI_MOD_PPIGCD: + value->rValue = model->B4SOIppigcd; + return(OK); + case B4SOI_MOD_PPOXEDGE: + value->rValue = model->B4SOIppoxedge; + return(OK); + + case B4SOI_MOD_PNPEAK: + value->rValue = model->B4SOIpnpeak; + return(OK); + case B4SOI_MOD_PNSUB: + value->rValue = model->B4SOIpnsub; + return(OK); + case B4SOI_MOD_PNGATE: + value->rValue = model->B4SOIpngate; + return(OK); + case B4SOI_MOD_PVTH0: + value->rValue = model->B4SOIpvth0; + return(OK); + case B4SOI_MOD_PK1: + value->rValue = model->B4SOIpk1; + return(OK); + case B4SOI_MOD_PK1W1: + value->rValue = model->B4SOIpk1w1; + return(OK); + case B4SOI_MOD_PK1W2: + value->rValue = model->B4SOIpk1w2; + return(OK); + case B4SOI_MOD_PK2: + value->rValue = model->B4SOIpk2; + return(OK); + case B4SOI_MOD_PK3: + value->rValue = model->B4SOIpk3; + return(OK); + case B4SOI_MOD_PK3B: + value->rValue = model->B4SOIpk3b; + return(OK); + case B4SOI_MOD_PKB1: + value->rValue = model->B4SOIpkb1; + return(OK); + case B4SOI_MOD_PW0: + value->rValue = model->B4SOIpw0; + return(OK); + case B4SOI_MOD_PLPE0: + value->rValue = model->B4SOIplpe0; + return(OK); + case B4SOI_MOD_PLPEB: /* v4.0 for Vth */ + value->rValue = model->B4SOIplpeb; + return(OK); + case B4SOI_MOD_PDVT0 : + value->rValue = model->B4SOIpdvt0; + return(OK); + case B4SOI_MOD_PDVT1 : + value->rValue = model->B4SOIpdvt1; + return(OK); + case B4SOI_MOD_PDVT2 : + value->rValue = model->B4SOIpdvt2; + return(OK); + case B4SOI_MOD_PDVT0W : + value->rValue = model->B4SOIpdvt0w; + return(OK); + case B4SOI_MOD_PDVT1W : + value->rValue = model->B4SOIpdvt1w; + return(OK); + case B4SOI_MOD_PDVT2W : + value->rValue = model->B4SOIpdvt2w; + return(OK); + case B4SOI_MOD_PU0: + value->rValue = model->B4SOIpu0; + return(OK); + case B4SOI_MOD_PUA: + value->rValue = model->B4SOIpua; + return(OK); + case B4SOI_MOD_PUB: + value->rValue = model->B4SOIpub; + return(OK); + case B4SOI_MOD_PUC: + value->rValue = model->B4SOIpuc; + return(OK); + case B4SOI_MOD_PVSAT: + value->rValue = model->B4SOIpvsat; + return(OK); + case B4SOI_MOD_PA0: + value->rValue = model->B4SOIpa0; + return(OK); + case B4SOI_MOD_PAGS: + value->rValue = model->B4SOIpags; + return(OK); + case B4SOI_MOD_PB0: + value->rValue = model->B4SOIpb0; + return(OK); + case B4SOI_MOD_PB1: + value->rValue = model->B4SOIpb1; + return(OK); + case B4SOI_MOD_PKETA: + value->rValue = model->B4SOIpketa; + return(OK); + case B4SOI_MOD_PKETAS: + value->rValue = model->B4SOIpketas; + return(OK); + case B4SOI_MOD_PA1: + value->rValue = model->B4SOIpa1; + return(OK); + case B4SOI_MOD_PA2: + value->rValue = model->B4SOIpa2; + return(OK); + case B4SOI_MOD_PRDSW: + value->rValue = model->B4SOIprdsw; + return(OK); + case B4SOI_MOD_PRDW: + value->rValue = model->B4SOIprdw; + return(OK); + case B4SOI_MOD_PRSW: + value->rValue = model->B4SOIprsw; + return(OK); + case B4SOI_MOD_PPRWB: + value->rValue = model->B4SOIpprwb; + return(OK); + case B4SOI_MOD_PPRWG: + value->rValue = model->B4SOIpprwg; + return(OK); + case B4SOI_MOD_PWR: + value->rValue = model->B4SOIpwr; + return(OK); + case B4SOI_MOD_PNFACTOR : + value->rValue = model->B4SOIpnfactor; + return(OK); + case B4SOI_MOD_PDWG: + value->rValue = model->B4SOIpdwg; + return(OK); + case B4SOI_MOD_PDWB: + value->rValue = model->B4SOIpdwb; + return(OK); + case B4SOI_MOD_PVOFF: + value->rValue = model->B4SOIpvoff; + return(OK); + case B4SOI_MOD_PETA0: + value->rValue = model->B4SOIpeta0; + return(OK); + case B4SOI_MOD_PETAB: + value->rValue = model->B4SOIpetab; + return(OK); + case B4SOI_MOD_PDSUB : + value->rValue = model->B4SOIpdsub; + return(OK); + case B4SOI_MOD_PCIT : + value->rValue = model->B4SOIpcit; + return(OK); + case B4SOI_MOD_PCDSC : + value->rValue = model->B4SOIpcdsc; + return(OK); + case B4SOI_MOD_PCDSCB : + value->rValue = model->B4SOIpcdscb; + return(OK); + case B4SOI_MOD_PCDSCD : + value->rValue = model->B4SOIpcdscd; + return(OK); + case B4SOI_MOD_PPCLM: + value->rValue = model->B4SOIppclm; + return(OK); + case B4SOI_MOD_PPDIBL1: + value->rValue = model->B4SOIppdibl1; + return(OK); + case B4SOI_MOD_PPDIBL2: + value->rValue = model->B4SOIppdibl2; + return(OK); + case B4SOI_MOD_PPDIBLB: + value->rValue = model->B4SOIppdiblb; + return(OK); + case B4SOI_MOD_PDROUT : + value->rValue = model->B4SOIpdrout; + return(OK); + case B4SOI_MOD_PPVAG: + value->rValue = model->B4SOIppvag; + return(OK); + case B4SOI_MOD_PDELTA: + value->rValue = model->B4SOIpdelta; + return(OK); + case B4SOI_MOD_PALPHA0: + value->rValue = model->B4SOIpalpha0; + return(OK); + case B4SOI_MOD_PFBJTII: + value->rValue = model->B4SOIpfbjtii; + return(OK); + case B4SOI_MOD_PBETA0: + value->rValue = model->B4SOIpbeta0; + return(OK); + case B4SOI_MOD_PBETA1: + value->rValue = model->B4SOIpbeta1; + return(OK); + case B4SOI_MOD_PBETA2: + value->rValue = model->B4SOIpbeta2; + return(OK); + case B4SOI_MOD_PVDSATII0: + value->rValue = model->B4SOIpvdsatii0; + return(OK); + case B4SOI_MOD_PLII: + value->rValue = model->B4SOIplii; + return(OK); + case B4SOI_MOD_PESATII: + value->rValue = model->B4SOIpesatii; + return(OK); + case B4SOI_MOD_PSII0: + value->rValue = model->B4SOIpsii0; + return(OK); + case B4SOI_MOD_PSII1: + value->rValue = model->B4SOIpsii1; + return(OK); + case B4SOI_MOD_PSII2: + value->rValue = model->B4SOIpsii2; + return(OK); + case B4SOI_MOD_PSIID: + value->rValue = model->B4SOIpsiid; + return(OK); + case B4SOI_MOD_PAGIDL: + value->rValue = model->B4SOIpagidl; + return(OK); + case B4SOI_MOD_PBGIDL: + value->rValue = model->B4SOIpbgidl; + return(OK); + case B4SOI_MOD_PCGIDL: + value->rValue = model->B4SOIpcgidl; + return(OK); + case B4SOI_MOD_PEGIDL: + value->rValue = model->B4SOIpegidl; + return(OK); + case B4SOI_MOD_PNTUNS: /* v4.0 */ + value->rValue = model->B4SOIpntun; + return(OK); + case B4SOI_MOD_PNTUND: /* v4.0 */ + value->rValue = model->B4SOIpntund; + return(OK); + case B4SOI_MOD_PNDIODES: /* v4.0 */ + value->rValue = model->B4SOIpndiode; + return(OK); + case B4SOI_MOD_PNDIODED: /* v4.0 */ + value->rValue = model->B4SOIpndioded; + return(OK); + case B4SOI_MOD_PNRECF0S: /* v4.0 */ + value->rValue = model->B4SOIpnrecf0; + return(OK); + case B4SOI_MOD_PNRECF0D: /* v4.0 */ + value->rValue = model->B4SOIpnrecf0d; + return(OK); + case B4SOI_MOD_PNRECR0S: /* v4.0 */ + value->rValue = model->B4SOIpnrecr0; + return(OK); + case B4SOI_MOD_PNRECR0D: /* v4.0 */ + value->rValue = model->B4SOIpnrecr0d; + return(OK); + case B4SOI_MOD_PISBJT: + value->rValue = model->B4SOIpisbjt; + return(OK); + case B4SOI_MOD_PIDBJT: /* v4.0 */ + value->rValue = model->B4SOIpidbjt; + return(OK); + case B4SOI_MOD_PISDIF: + value->rValue = model->B4SOIpisdif; + return(OK); + case B4SOI_MOD_PIDDIF: /* v4.0 */ + value->rValue = model->B4SOIpiddif; + return(OK); + case B4SOI_MOD_PISREC: + value->rValue = model->B4SOIpisrec; + return(OK); + case B4SOI_MOD_PIDREC: /* v4.0 */ + value->rValue = model->B4SOIpidrec; + return(OK); + case B4SOI_MOD_PISTUN: + value->rValue = model->B4SOIpistun; + return(OK); + case B4SOI_MOD_PIDTUN: /* v4.0 */ + value->rValue = model->B4SOIpidtun; + return(OK); + case B4SOI_MOD_PVREC0S: /* v4.0 */ + value->rValue = model->B4SOIpvrec0; + return(OK); + case B4SOI_MOD_PVREC0D: /* v4.0 */ + value->rValue = model->B4SOIpvrec0d; + return(OK); + case B4SOI_MOD_PVTUN0S: /* v4.0 */ + value->rValue = model->B4SOIpvtun0; + return(OK); + case B4SOI_MOD_PVTUN0D: /* v4.0 */ + value->rValue = model->B4SOIpvtun0d; + return(OK); + case B4SOI_MOD_PNBJT: + value->rValue = model->B4SOIpnbjt; + return(OK); + case B4SOI_MOD_PLBJT0: + value->rValue = model->B4SOIplbjt0; + return(OK); + case B4SOI_MOD_PVABJT: + value->rValue = model->B4SOIpvabjt; + return(OK); + case B4SOI_MOD_PAELY: + value->rValue = model->B4SOIpaely; + return(OK); + case B4SOI_MOD_PAHLIS: /* v4.0 */ + value->rValue = model->B4SOIpahli; + return(OK); + case B4SOI_MOD_PAHLID: /* v4.0 */ + value->rValue = model->B4SOIpahlid; + return(OK); + /* CV Model */ + case B4SOI_MOD_PVSDFB: + value->rValue = model->B4SOIpvsdfb; + return(OK); + case B4SOI_MOD_PVSDTH: + value->rValue = model->B4SOIpvsdth; + return(OK); + case B4SOI_MOD_PDELVT: + value->rValue = model->B4SOIpdelvt; + return(OK); + case B4SOI_MOD_PACDE: + value->rValue = model->B4SOIpacde; + return(OK); + case B4SOI_MOD_PMOIN: + value->rValue = model->B4SOIpmoin; + return(OK); + case B4SOI_MOD_PNOFF: + value->rValue = model->B4SOIpnoff; + return(OK); /* v3.2 */ +/* Added for binning - END */ + + default: + return(E_BADPARM); + } + /* NOTREACHED */ +} + + + diff --git a/src/spicelib/devices/bsim3soi/b4soimdel.c b/src/spicelib/devices/bsim3soi/b4soimdel.c new file mode 100644 index 000000000..499961c08 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soimdel.c @@ -0,0 +1,47 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soimdel.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soimdel.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "b4soidef.h" +#include "sperror.h" +#include "suffix.h" + +int +B4SOImDelete(GENmodel **inModel, IFuid modname, GENmodel *kill) +{ +B4SOImodel **model = (B4SOImodel**)inModel; +B4SOImodel *modfast = (B4SOImodel*)kill; +B4SOIinstance *here; +B4SOIinstance *prev = NULL; +B4SOImodel **oldmod; + + oldmod = model; + for (; *model ; model = &((*model)->B4SOInextModel)) + { if ((*model)->B4SOImodName == modname || + (modfast && *model == modfast)) + goto delgot; + oldmod = model; + } + return(E_NOMOD); + +delgot: + *oldmod = (*model)->B4SOInextModel; /* cut deleted device out of list */ + for (here = (*model)->B4SOIinstances; here; here = here->B4SOInextInstance) + { if(prev) FREE(prev); + prev = here; + } + if(prev) FREE(prev); + FREE(*model); + return(OK); +} + + + diff --git a/src/spicelib/devices/bsim3soi/b4soimpar.c b/src/spicelib/devices/bsim3soi/b4soimpar.c new file mode 100644 index 000000000..a135e15ee --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soimpar.c @@ -0,0 +1,3154 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soimpar.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soimpar.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "b4soidef.h" +#include "ifsim.h" +#include "sperror.h" +#include "suffix.h" + + +int +B4SOImParam(int param, IFvalue *value, GENmodel *inMod) +{ + B4SOImodel *mod = (B4SOImodel*)inMod; + switch(param) + { + + case B4SOI_MOD_MOBMOD : + mod->B4SOImobMod = value->iValue; + mod->B4SOImobModGiven = TRUE; + break; + case B4SOI_MOD_BINUNIT : + mod->B4SOIbinUnit = value->iValue; + mod->B4SOIbinUnitGiven = TRUE; + break; + case B4SOI_MOD_PARAMCHK : + mod->B4SOIparamChk = value->iValue; + mod->B4SOIparamChkGiven = TRUE; + break; + case B4SOI_MOD_CAPMOD : + mod->B4SOIcapMod = value->iValue; + mod->B4SOIcapModGiven = TRUE; + break; + case B4SOI_MOD_SHMOD : + mod->B4SOIshMod = value->iValue; + mod->B4SOIshModGiven = TRUE; + break; + +/* case B4SOI_MOD_NOIMOD : + mod->B4SOInoiMod = value->iValue; + mod->B4SOInoiModGiven = TRUE; + break; v3.2 */ + + case B4SOI_MOD_VERSION : + mod->B4SOIversion = value->rValue; + mod->B4SOIversionGiven = TRUE; + break; + case B4SOI_MOD_TOX : + mod->B4SOItox = value->rValue; + mod->B4SOItoxGiven = TRUE; + break; + + case B4SOI_MOD_TOXM : + mod->B4SOItoxm = value->rValue; + mod->B4SOItoxmGiven = TRUE; + break; /* v3.2 */ + +/* v2.2.3 */ + case B4SOI_MOD_DTOXCV : + mod->B4SOIdtoxcv = value->rValue; + mod->B4SOIdtoxcvGiven = TRUE; + break; + + case B4SOI_MOD_CDSC : + mod->B4SOIcdsc = value->rValue; + mod->B4SOIcdscGiven = TRUE; + break; + case B4SOI_MOD_CDSCB : + mod->B4SOIcdscb = value->rValue; + mod->B4SOIcdscbGiven = TRUE; + break; + + case B4SOI_MOD_CDSCD : + mod->B4SOIcdscd = value->rValue; + mod->B4SOIcdscdGiven = TRUE; + break; + + case B4SOI_MOD_CIT : + mod->B4SOIcit = value->rValue; + mod->B4SOIcitGiven = TRUE; + break; + case B4SOI_MOD_NFACTOR : + mod->B4SOInfactor = value->rValue; + mod->B4SOInfactorGiven = TRUE; + break; + case B4SOI_MOD_VSAT: + mod->B4SOIvsat = value->rValue; + mod->B4SOIvsatGiven = TRUE; + break; + case B4SOI_MOD_A0: + mod->B4SOIa0 = value->rValue; + mod->B4SOIa0Given = TRUE; + break; + + case B4SOI_MOD_AGS: + mod->B4SOIags= value->rValue; + mod->B4SOIagsGiven = TRUE; + break; + + case B4SOI_MOD_A1: + mod->B4SOIa1 = value->rValue; + mod->B4SOIa1Given = TRUE; + break; + case B4SOI_MOD_A2: + mod->B4SOIa2 = value->rValue; + mod->B4SOIa2Given = TRUE; + break; + case B4SOI_MOD_AT: + mod->B4SOIat = value->rValue; + mod->B4SOIatGiven = TRUE; + break; + case B4SOI_MOD_KETA: + mod->B4SOIketa = value->rValue; + mod->B4SOIketaGiven = TRUE; + break; + case B4SOI_MOD_NSUB: + mod->B4SOInsub = value->rValue; + mod->B4SOInsubGiven = TRUE; + break; + case B4SOI_MOD_NPEAK: + mod->B4SOInpeak = value->rValue; + mod->B4SOInpeakGiven = TRUE; + if (mod->B4SOInpeak > 1.0e20) + mod->B4SOInpeak *= 1.0e-6; + break; + case B4SOI_MOD_NGATE: + mod->B4SOIngate = value->rValue; + mod->B4SOIngateGiven = TRUE; + if (mod->B4SOIngate > 1.0e23) + mod->B4SOIngate *= 1.0e-6; + break; + case B4SOI_MOD_GAMMA1: + mod->B4SOIgamma1 = value->rValue; + mod->B4SOIgamma1Given = TRUE; + break; + case B4SOI_MOD_GAMMA2: + mod->B4SOIgamma2 = value->rValue; + mod->B4SOIgamma2Given = TRUE; + break; + case B4SOI_MOD_VBX: + mod->B4SOIvbx = value->rValue; + mod->B4SOIvbxGiven = TRUE; + break; + case B4SOI_MOD_VBM: + mod->B4SOIvbm = value->rValue; + mod->B4SOIvbmGiven = TRUE; + break; + case B4SOI_MOD_XT: + mod->B4SOIxt = value->rValue; + mod->B4SOIxtGiven = TRUE; + break; + case B4SOI_MOD_K1: + mod->B4SOIk1 = value->rValue; + mod->B4SOIk1Given = TRUE; + break; + case B4SOI_MOD_KT1: + mod->B4SOIkt1 = value->rValue; + mod->B4SOIkt1Given = TRUE; + break; + case B4SOI_MOD_KT1L: + mod->B4SOIkt1l = value->rValue; + mod->B4SOIkt1lGiven = TRUE; + break; + case B4SOI_MOD_KT2: + mod->B4SOIkt2 = value->rValue; + mod->B4SOIkt2Given = TRUE; + break; + case B4SOI_MOD_K2: + mod->B4SOIk2 = value->rValue; + mod->B4SOIk2Given = TRUE; + break; + case B4SOI_MOD_K3: + mod->B4SOIk3 = value->rValue; + mod->B4SOIk3Given = TRUE; + break; + case B4SOI_MOD_K3B: + mod->B4SOIk3b = value->rValue; + mod->B4SOIk3bGiven = TRUE; + break; + case B4SOI_MOD_LPE0: + mod->B4SOIlpe0 = value->rValue; + mod->B4SOIlpe0Given = TRUE; + break; + case B4SOI_MOD_LPEB: /* v4.0 for Vth */ + mod->B4SOIlpeb = value->rValue; + mod->B4SOIlpebGiven = TRUE; + break; + case B4SOI_MOD_W0: + mod->B4SOIw0 = value->rValue; + mod->B4SOIw0Given = TRUE; + break; + case B4SOI_MOD_DVT0: + mod->B4SOIdvt0 = value->rValue; + mod->B4SOIdvt0Given = TRUE; + break; + case B4SOI_MOD_DVT1: + mod->B4SOIdvt1 = value->rValue; + mod->B4SOIdvt1Given = TRUE; + break; + case B4SOI_MOD_DVT2: + mod->B4SOIdvt2 = value->rValue; + mod->B4SOIdvt2Given = TRUE; + break; + case B4SOI_MOD_DVT0W: + mod->B4SOIdvt0w = value->rValue; + mod->B4SOIdvt0wGiven = TRUE; + break; + case B4SOI_MOD_DVT1W: + mod->B4SOIdvt1w = value->rValue; + mod->B4SOIdvt1wGiven = TRUE; + break; + case B4SOI_MOD_DVT2W: + mod->B4SOIdvt2w = value->rValue; + mod->B4SOIdvt2wGiven = TRUE; + break; + case B4SOI_MOD_DROUT: + mod->B4SOIdrout = value->rValue; + mod->B4SOIdroutGiven = TRUE; + break; + case B4SOI_MOD_DSUB: + mod->B4SOIdsub = value->rValue; + mod->B4SOIdsubGiven = TRUE; + break; + case B4SOI_MOD_VTH0: + mod->B4SOIvth0 = value->rValue; + mod->B4SOIvth0Given = TRUE; + break; + case B4SOI_MOD_UA: + mod->B4SOIua = value->rValue; + mod->B4SOIuaGiven = TRUE; + break; + case B4SOI_MOD_UA1: + mod->B4SOIua1 = value->rValue; + mod->B4SOIua1Given = TRUE; + break; + case B4SOI_MOD_UB: + mod->B4SOIub = value->rValue; + mod->B4SOIubGiven = TRUE; + break; + case B4SOI_MOD_UB1: + mod->B4SOIub1 = value->rValue; + mod->B4SOIub1Given = TRUE; + break; + case B4SOI_MOD_UC: + mod->B4SOIuc = value->rValue; + mod->B4SOIucGiven = TRUE; + break; + case B4SOI_MOD_UC1: + mod->B4SOIuc1 = value->rValue; + mod->B4SOIuc1Given = TRUE; + break; + case B4SOI_MOD_U0 : + mod->B4SOIu0 = value->rValue; + mod->B4SOIu0Given = TRUE; + break; + case B4SOI_MOD_UTE : + mod->B4SOIute = value->rValue; + mod->B4SOIuteGiven = TRUE; + break; + case B4SOI_MOD_VOFF: + mod->B4SOIvoff = value->rValue; + mod->B4SOIvoffGiven = TRUE; + break; + case B4SOI_MOD_DELTA : + mod->B4SOIdelta = value->rValue; + mod->B4SOIdeltaGiven = TRUE; + break; + case B4SOI_MOD_RDSW: + mod->B4SOIrdsw = value->rValue; + mod->B4SOIrdswGiven = TRUE; + break; + case B4SOI_MOD_RSW: + mod->B4SOIrsw = value->rValue; + mod->B4SOIrswGiven = TRUE; + break; + case B4SOI_MOD_RDW: + mod->B4SOIrdw = value->rValue; + mod->B4SOIrdwGiven = TRUE; + break; + case B4SOI_MOD_RSWMIN: + mod->B4SOIrswmin = value->rValue; + mod->B4SOIrswminGiven = TRUE; + break; + case B4SOI_MOD_RDWMIN: + mod->B4SOIrdwmin = value->rValue; + mod->B4SOIrdwminGiven = TRUE; + break; + case B4SOI_MOD_PRWG: + mod->B4SOIprwg = value->rValue; + mod->B4SOIprwgGiven = TRUE; + break; + case B4SOI_MOD_PRWB: + mod->B4SOIprwb = value->rValue; + mod->B4SOIprwbGiven = TRUE; + break; + case B4SOI_MOD_PRT: + mod->B4SOIprt = value->rValue; + mod->B4SOIprtGiven = TRUE; + break; + case B4SOI_MOD_ETA0: + mod->B4SOIeta0 = value->rValue; + mod->B4SOIeta0Given = TRUE; + break; + case B4SOI_MOD_ETAB: + mod->B4SOIetab = value->rValue; + mod->B4SOIetabGiven = TRUE; + break; + case B4SOI_MOD_PCLM: + mod->B4SOIpclm = value->rValue; + mod->B4SOIpclmGiven = TRUE; + break; + case B4SOI_MOD_PDIBL1: + mod->B4SOIpdibl1 = value->rValue; + mod->B4SOIpdibl1Given = TRUE; + break; + case B4SOI_MOD_PDIBL2: + mod->B4SOIpdibl2 = value->rValue; + mod->B4SOIpdibl2Given = TRUE; + break; + case B4SOI_MOD_PDIBLB: + mod->B4SOIpdiblb = value->rValue; + mod->B4SOIpdiblbGiven = TRUE; + break; + case B4SOI_MOD_PVAG: + mod->B4SOIpvag = value->rValue; + mod->B4SOIpvagGiven = TRUE; + break; + case B4SOI_MOD_WR : + mod->B4SOIwr = value->rValue; + mod->B4SOIwrGiven = TRUE; + break; + case B4SOI_MOD_DWG : + mod->B4SOIdwg = value->rValue; + mod->B4SOIdwgGiven = TRUE; + break; + case B4SOI_MOD_DWB : + mod->B4SOIdwb = value->rValue; + mod->B4SOIdwbGiven = TRUE; + break; + case B4SOI_MOD_B0 : + mod->B4SOIb0 = value->rValue; + mod->B4SOIb0Given = TRUE; + break; + case B4SOI_MOD_B1 : + mod->B4SOIb1 = value->rValue; + mod->B4SOIb1Given = TRUE; + break; + case B4SOI_MOD_ALPHA0 : + mod->B4SOIalpha0 = value->rValue; + mod->B4SOIalpha0Given = TRUE; + break; + + case B4SOI_MOD_CGSL : + mod->B4SOIcgsl = value->rValue; + mod->B4SOIcgslGiven = TRUE; + break; + case B4SOI_MOD_CGDL : + mod->B4SOIcgdl = value->rValue; + mod->B4SOIcgdlGiven = TRUE; + break; + case B4SOI_MOD_CKAPPA : + mod->B4SOIckappa = value->rValue; + mod->B4SOIckappaGiven = TRUE; + break; + case B4SOI_MOD_CF : + mod->B4SOIcf = value->rValue; + mod->B4SOIcfGiven = TRUE; + break; + case B4SOI_MOD_CLC : + mod->B4SOIclc = value->rValue; + mod->B4SOIclcGiven = TRUE; + break; + case B4SOI_MOD_CLE : + mod->B4SOIcle = value->rValue; + mod->B4SOIcleGiven = TRUE; + break; + case B4SOI_MOD_DWC : + mod->B4SOIdwc = value->rValue; + mod->B4SOIdwcGiven = TRUE; + break; + case B4SOI_MOD_DLC : + mod->B4SOIdlc = value->rValue; + mod->B4SOIdlcGiven = TRUE; + break; + case B4SOI_MOD_TBOX : + mod->B4SOItbox = value->rValue; + mod->B4SOItboxGiven = TRUE; + break; + case B4SOI_MOD_TSI : + mod->B4SOItsi = value->rValue; + mod->B4SOItsiGiven = TRUE; + break; + case B4SOI_MOD_XJ : + mod->B4SOIxj = value->rValue; + mod->B4SOIxjGiven = TRUE; + break; + case B4SOI_MOD_RBODY : + mod->B4SOIrbody = value->rValue; + mod->B4SOIrbodyGiven = TRUE; + break; + case B4SOI_MOD_RBSH : + mod->B4SOIrbsh = value->rValue; + mod->B4SOIrbshGiven = TRUE; + break; + case B4SOI_MOD_RTH0 : + mod->B4SOIrth0 = value->rValue; + mod->B4SOIrth0Given = TRUE; + break; + case B4SOI_MOD_CTH0 : + mod->B4SOIcth0 = value->rValue; + mod->B4SOIcth0Given = TRUE; + break; + case B4SOI_MOD_EGIDL : + mod->B4SOIegidl = value->rValue; + mod->B4SOIegidlGiven = TRUE; + break; + case B4SOI_MOD_AGIDL : + mod->B4SOIagidl = value->rValue; + mod->B4SOIagidlGiven = TRUE; + break; + case B4SOI_MOD_BGIDL : + mod->B4SOIbgidl = value->rValue; + mod->B4SOIbgidlGiven = TRUE; + break; + case B4SOI_MOD_CGIDL : + mod->B4SOIcgidl = value->rValue; + mod->B4SOIcgidlGiven = TRUE; + break; + case B4SOI_MOD_NDIODES : /* v4.0 */ + mod->B4SOIndiode = value->rValue; + mod->B4SOIndiodeGiven = TRUE; + break; + case B4SOI_MOD_NDIODED : /* v4.0 */ + mod->B4SOIndioded = value->rValue; + mod->B4SOIndiodedGiven = TRUE; + break; + case B4SOI_MOD_XBJT : + mod->B4SOIxbjt = value->rValue; + mod->B4SOIxbjtGiven = TRUE; + break; + + case B4SOI_MOD_XDIFS : + mod->B4SOIxdif = value->rValue; + mod->B4SOIxdifGiven = TRUE; + break; + case B4SOI_MOD_XRECS : + mod->B4SOIxrec = value->rValue; + mod->B4SOIxrecGiven = TRUE; + break; + case B4SOI_MOD_XTUNS : + mod->B4SOIxtun = value->rValue; + mod->B4SOIxtunGiven = TRUE; + break; + case B4SOI_MOD_XDIFD : + mod->B4SOIxdifd = value->rValue; + mod->B4SOIxdifdGiven = TRUE; + break; + case B4SOI_MOD_XRECD : + mod->B4SOIxrecd = value->rValue; + mod->B4SOIxrecdGiven = TRUE; + break; + case B4SOI_MOD_XTUND : + mod->B4SOIxtund = value->rValue; + mod->B4SOIxtundGiven = TRUE; + break; + case B4SOI_MOD_TT : + mod->B4SOItt = value->rValue; + mod->B4SOIttGiven = TRUE; + break; + case B4SOI_MOD_VSDTH : + mod->B4SOIvsdth = value->rValue; + mod->B4SOIvsdthGiven = TRUE; + break; + case B4SOI_MOD_VSDFB : + mod->B4SOIvsdfb = value->rValue; + mod->B4SOIvsdfbGiven = TRUE; + break; + case B4SOI_MOD_CSDMIN : + mod->B4SOIcsdmin = value->rValue; + mod->B4SOIcsdminGiven = TRUE; + break; + case B4SOI_MOD_ASD : + mod->B4SOIasd = value->rValue; + mod->B4SOIasdGiven = TRUE; + break; + + + case B4SOI_MOD_TNOM : + mod->B4SOItnom = value->rValue + 273.15; + mod->B4SOItnomGiven = TRUE; + break; + case B4SOI_MOD_CGSO : + mod->B4SOIcgso = value->rValue; + mod->B4SOIcgsoGiven = TRUE; + break; + case B4SOI_MOD_CGDO : + mod->B4SOIcgdo = value->rValue; + mod->B4SOIcgdoGiven = TRUE; + break; + case B4SOI_MOD_CGEO : + mod->B4SOIcgeo = value->rValue; + mod->B4SOIcgeoGiven = TRUE; + break; + + + case B4SOI_MOD_XPART : + mod->B4SOIxpart = value->rValue; + mod->B4SOIxpartGiven = TRUE; + break; + case B4SOI_MOD_RSH : + mod->B4SOIsheetResistance = value->rValue; + mod->B4SOIsheetResistanceGiven = TRUE; + break; + case B4SOI_MOD_PBSWGS : /* v4.0 */ + mod->B4SOIGatesidewallJctSPotential = value->rValue; + mod->B4SOIGatesidewallJctSPotentialGiven = TRUE; + break; + case B4SOI_MOD_PBSWGD : /* v4.0 */ + mod->B4SOIGatesidewallJctDPotential = value->rValue; + mod->B4SOIGatesidewallJctDPotentialGiven = TRUE; + break; + case B4SOI_MOD_MJSWGS : /* v4.0 */ + mod->B4SOIbodyJctGateSideSGradingCoeff = value->rValue; + mod->B4SOIbodyJctGateSideSGradingCoeffGiven = TRUE; + break; + case B4SOI_MOD_MJSWGD : /* v4.0 */ + mod->B4SOIbodyJctGateSideDGradingCoeff = value->rValue; + mod->B4SOIbodyJctGateSideDGradingCoeffGiven = TRUE; + break; + case B4SOI_MOD_CJSWGS : /* v4.0 */ + mod->B4SOIunitLengthGateSidewallJctCapS = value->rValue; + mod->B4SOIunitLengthGateSidewallJctCapSGiven = TRUE; + break; + case B4SOI_MOD_CJSWGD : /* v4.0 */ + mod->B4SOIunitLengthGateSidewallJctCapD = value->rValue; + mod->B4SOIunitLengthGateSidewallJctCapDGiven = TRUE; + break; + case B4SOI_MOD_CSDESW : + mod->B4SOIcsdesw = value->rValue; + mod->B4SOIcsdeswGiven = TRUE; + break; + case B4SOI_MOD_LINT : + mod->B4SOILint = value->rValue; + mod->B4SOILintGiven = TRUE; + break; + case B4SOI_MOD_LL : + mod->B4SOILl = value->rValue; + mod->B4SOILlGiven = TRUE; + break; +/* v2.2.3 */ + case B4SOI_MOD_LLC : + mod->B4SOILlc = value->rValue; + mod->B4SOILlcGiven = TRUE; + break; + + case B4SOI_MOD_LLN : + mod->B4SOILln = value->rValue; + mod->B4SOILlnGiven = TRUE; + break; + case B4SOI_MOD_LW : + mod->B4SOILw = value->rValue; + mod->B4SOILwGiven = TRUE; + break; +/* v2.2.3 */ + case B4SOI_MOD_LWC : + mod->B4SOILwc = value->rValue; + mod->B4SOILwcGiven = TRUE; + break; + + case B4SOI_MOD_LWN : + mod->B4SOILwn = value->rValue; + mod->B4SOILwnGiven = TRUE; + break; + case B4SOI_MOD_LWL : + mod->B4SOILwl = value->rValue; + mod->B4SOILwlGiven = TRUE; + break; +/* v2.2.3 */ + case B4SOI_MOD_LWLC : + mod->B4SOILwlc = value->rValue; + mod->B4SOILwlcGiven = TRUE; + break; + + case B4SOI_MOD_WINT : + mod->B4SOIWint = value->rValue; + mod->B4SOIWintGiven = TRUE; + break; + case B4SOI_MOD_WL : + mod->B4SOIWl = value->rValue; + mod->B4SOIWlGiven = TRUE; + break; +/* v2.2.3 */ + case B4SOI_MOD_WLC : + mod->B4SOIWlc = value->rValue; + mod->B4SOIWlcGiven = TRUE; + break; + + case B4SOI_MOD_WLN : + mod->B4SOIWln = value->rValue; + mod->B4SOIWlnGiven = TRUE; + break; + case B4SOI_MOD_WW : + mod->B4SOIWw = value->rValue; + mod->B4SOIWwGiven = TRUE; + break; +/* v2.2.3 */ + case B4SOI_MOD_WWC : + mod->B4SOIWwc = value->rValue; + mod->B4SOIWwcGiven = TRUE; + break; + + case B4SOI_MOD_WWN : + mod->B4SOIWwn = value->rValue; + mod->B4SOIWwnGiven = TRUE; + break; + case B4SOI_MOD_WWL : + mod->B4SOIWwl = value->rValue; + mod->B4SOIWwlGiven = TRUE; + break; +/* v2.2.3 */ + case B4SOI_MOD_WWLC : + mod->B4SOIWwlc = value->rValue; + mod->B4SOIWwlcGiven = TRUE; + break; + + case B4SOI_MOD_NOIA : + mod->B4SOIoxideTrapDensityA = value->rValue; + mod->B4SOIoxideTrapDensityAGiven = TRUE; + break; + case B4SOI_MOD_NOIB : + mod->B4SOIoxideTrapDensityB = value->rValue; + mod->B4SOIoxideTrapDensityBGiven = TRUE; + break; + case B4SOI_MOD_NOIC : + mod->B4SOIoxideTrapDensityC = value->rValue; + mod->B4SOIoxideTrapDensityCGiven = TRUE; + break; + case B4SOI_MOD_NOIF : + mod->B4SOInoif = value->rValue; + mod->B4SOInoifGiven = TRUE; + break; + case B4SOI_MOD_EM : + mod->B4SOIem = value->rValue; + mod->B4SOIemGiven = TRUE; + break; + case B4SOI_MOD_EF : + mod->B4SOIef = value->rValue; + mod->B4SOIefGiven = TRUE; + break; + case B4SOI_MOD_AF : + mod->B4SOIaf = value->rValue; + mod->B4SOIafGiven = TRUE; + break; + case B4SOI_MOD_KF : + mod->B4SOIkf = value->rValue; + mod->B4SOIkfGiven = TRUE; + break; + case B4SOI_MOD_BF : + mod->B4SOIbf = value->rValue; + mod->B4SOIbfGiven = TRUE; + break; + case B4SOI_MOD_W0FLK : + mod->B4SOIw0flk = value->rValue; + mod->B4SOIw0flkGiven = TRUE; + break; + +/* v3.0 */ + case B4SOI_MOD_SOIMOD: + mod->B4SOIsoiMod = value->iValue; + mod->B4SOIsoiModGiven = TRUE; + break; /* v3.2 bug fix */ + case B4SOI_MOD_VBS0PD: + mod->B4SOIvbs0pd = value->rValue; + mod->B4SOIvbs0pdGiven = TRUE; + break; /* v3.2 */ + case B4SOI_MOD_VBS0FD: + mod->B4SOIvbs0fd = value->rValue; + mod->B4SOIvbs0fdGiven = TRUE; + break; /* v3.2 */ + case B4SOI_MOD_VBSA: + mod->B4SOIvbsa = value->rValue; + mod->B4SOIvbsaGiven = TRUE; + break; + case B4SOI_MOD_NOFFFD : + mod->B4SOInofffd = value->rValue; + mod->B4SOInofffdGiven = TRUE; + break; + case B4SOI_MOD_VOFFFD: + mod->B4SOIvofffd = value->rValue; + mod->B4SOIvofffdGiven = TRUE; + break; + case B4SOI_MOD_K1B: + mod->B4SOIk1b = value->rValue; + mod->B4SOIk1bGiven = TRUE; + break; + case B4SOI_MOD_K2B: + mod->B4SOIk2b = value->rValue; + mod->B4SOIk2bGiven = TRUE; + break; + case B4SOI_MOD_DK2B: + mod->B4SOIdk2b = value->rValue; + mod->B4SOIdk2bGiven = TRUE; + break; + case B4SOI_MOD_DVBD0: + mod->B4SOIdvbd0 = value->rValue; + mod->B4SOIdvbd0Given = TRUE; + break; + case B4SOI_MOD_DVBD1: + mod->B4SOIdvbd1 = value->rValue; + mod->B4SOIdvbd1Given = TRUE; + break; + case B4SOI_MOD_MOINFD: + mod->B4SOImoinFD = value->rValue; + mod->B4SOImoinFDGiven = TRUE; + break; + + +/* v2.2 release */ + case B4SOI_MOD_WTH0 : + mod->B4SOIwth0 = value->rValue; + mod->B4SOIwth0Given = TRUE; + break; + case B4SOI_MOD_RHALO : + mod->B4SOIrhalo = value->rValue; + mod->B4SOIrhaloGiven = TRUE; + break; + case B4SOI_MOD_NTOX : + mod->B4SOIntox = value->rValue; + mod->B4SOIntoxGiven = TRUE; + break; + case B4SOI_MOD_TOXREF : + mod->B4SOItoxref = value->rValue; + mod->B4SOItoxrefGiven = TRUE; + break; + case B4SOI_MOD_EBG : + mod->B4SOIebg = value->rValue; + mod->B4SOIebgGiven = TRUE; + break; + case B4SOI_MOD_VEVB : + mod->B4SOIvevb = value->rValue; + mod->B4SOIvevbGiven = TRUE; + break; + case B4SOI_MOD_ALPHAGB1 : + mod->B4SOIalphaGB1 = value->rValue; + mod->B4SOIalphaGB1Given = TRUE; + break; + case B4SOI_MOD_BETAGB1 : + mod->B4SOIbetaGB1 = value->rValue; + mod->B4SOIbetaGB1Given = TRUE; + break; + case B4SOI_MOD_VGB1 : + mod->B4SOIvgb1 = value->rValue; + mod->B4SOIvgb1Given = TRUE; + break; + case B4SOI_MOD_VECB : + mod->B4SOIvecb = value->rValue; + mod->B4SOIvecbGiven = TRUE; + break; + case B4SOI_MOD_ALPHAGB2 : + mod->B4SOIalphaGB2 = value->rValue; + mod->B4SOIalphaGB2Given = TRUE; + break; + case B4SOI_MOD_BETAGB2 : + mod->B4SOIbetaGB2 = value->rValue; + mod->B4SOIbetaGB2Given = TRUE; + break; + case B4SOI_MOD_VGB2 : + mod->B4SOIvgb2 = value->rValue; + mod->B4SOIvgb2Given = TRUE; + break; + case B4SOI_MOD_TOXQM : + mod->B4SOItoxqm = value->rValue; + mod->B4SOItoxqmGiven = TRUE; + break; + case B4SOI_MOD_VOXH : + mod->B4SOIvoxh = value->rValue; + mod->B4SOIvoxhGiven = TRUE; + break; + case B4SOI_MOD_DELTAVOX : + mod->B4SOIdeltavox = value->rValue; + mod->B4SOIdeltavoxGiven = TRUE; + break; + +/* v3.0 */ + case B4SOI_MOD_IGBMOD : + mod->B4SOIigbMod = value->iValue; + mod->B4SOIigbModGiven = TRUE; + break; + case B4SOI_MOD_IGCMOD : + mod->B4SOIigcMod = value->iValue; + mod->B4SOIigcModGiven = TRUE; + break; + case B4SOI_MOD_AIGC : + mod->B4SOIaigc = value->rValue; + mod->B4SOIaigcGiven = TRUE; + break; + case B4SOI_MOD_BIGC : + mod->B4SOIbigc = value->rValue; + mod->B4SOIbigcGiven = TRUE; + break; + case B4SOI_MOD_CIGC : + mod->B4SOIcigc = value->rValue; + mod->B4SOIcigcGiven = TRUE; + break; + case B4SOI_MOD_AIGSD : + mod->B4SOIaigsd = value->rValue; + mod->B4SOIaigsdGiven = TRUE; + break; + case B4SOI_MOD_BIGSD : + mod->B4SOIbigsd = value->rValue; + mod->B4SOIbigsdGiven = TRUE; + break; + case B4SOI_MOD_CIGSD : + mod->B4SOIcigsd = value->rValue; + mod->B4SOIcigsdGiven = TRUE; + break; + case B4SOI_MOD_NIGC : + mod->B4SOInigc = value->rValue; + mod->B4SOInigcGiven = TRUE; + break; + case B4SOI_MOD_PIGCD : + mod->B4SOIpigcd = value->rValue; + mod->B4SOIpigcdGiven = TRUE; + break; + case B4SOI_MOD_POXEDGE : + mod->B4SOIpoxedge = value->rValue; + mod->B4SOIpoxedgeGiven = TRUE; + break; + case B4SOI_MOD_DLCIG : + mod->B4SOIdlcig = value->rValue; + mod->B4SOIdlcigGiven = TRUE; + break; + + /* v3.1 added for RF */ + case B4SOI_MOD_RGATEMOD : + mod->B4SOIrgateMod = value->iValue; + mod->B4SOIrgateModGiven = TRUE; + break; + case B4SOI_MOD_XRCRG1 : + mod->B4SOIxrcrg1 = value->rValue; + mod->B4SOIxrcrg1Given = TRUE; + break; + case B4SOI_MOD_XRCRG2 : + mod->B4SOIxrcrg2 = value->rValue; + mod->B4SOIxrcrg2Given = TRUE; + break; + case B4SOI_MOD_RSHG : + mod->B4SOIrshg = value->rValue; + mod->B4SOIrshgGiven = TRUE; + break; + case B4SOI_MOD_NGCON : + mod->B4SOIngcon = value->rValue; + mod->B4SOIngconGiven = TRUE; + break; + case B4SOI_MOD_XGW : + mod->B4SOIxgw = value->rValue; + mod->B4SOIxgwGiven = TRUE; + break; + case B4SOI_MOD_XGL : + mod->B4SOIxgl = value->rValue; + mod->B4SOIxglGiven = TRUE; + break; + /* v3.1 added RF end */ + + /* v4.0 */ + case B4SOI_MOD_RDSMOD : + mod->B4SOIrdsMod = value->iValue; + mod->B4SOIrdsModGiven = TRUE; + break; + case B4SOI_MOD_GBMIN : + mod->B4SOIgbmin = value->rValue; + mod->B4SOIgbminGiven = TRUE; + break; + case B4SOI_MOD_RBODYMOD : + mod->B4SOIrbodyMod = value->iValue; + mod->B4SOIrbodyModGiven = TRUE; + break; + case B4SOI_MOD_RBDB : + mod->B4SOIrbdb = value->rValue; + mod->B4SOIrbdbGiven = TRUE; + case B4SOI_MOD_RBSB : + mod->B4SOIrbsb = value->rValue; + mod->B4SOIrbsbGiven = TRUE; + break; + case B4SOI_MOD_FRBODY : + mod->B4SOIfrbody = value->rValue; + mod->B4SOIfrbodyGiven = TRUE; + break; + case B4SOI_MOD_DVTP0: + mod->B4SOIdvtp0 = value->rValue; + mod->B4SOIdvtp0Given = TRUE; + break; + case B4SOI_MOD_DVTP1: + mod->B4SOIdvtp1 = value->rValue; + mod->B4SOIdvtp1Given = TRUE; + break; + case B4SOI_MOD_LDVTP0: + mod->B4SOIldvtp0 = value->rValue; + mod->B4SOIldvtp0Given = TRUE; + break; + case B4SOI_MOD_LDVTP1: + mod->B4SOIldvtp1 = value->rValue; + mod->B4SOIldvtp1Given = TRUE; + break; + case B4SOI_MOD_WDVTP0: + mod->B4SOIwdvtp0 = value->rValue; + mod->B4SOIwdvtp0Given = TRUE; + break; + case B4SOI_MOD_WDVTP1: + mod->B4SOIwdvtp1 = value->rValue; + mod->B4SOIwdvtp1Given = TRUE; + break; + case B4SOI_MOD_PDVTP0: + mod->B4SOIpdvtp0 = value->rValue; + mod->B4SOIpdvtp0Given = TRUE; + break; + case B4SOI_MOD_PDVTP1: + mod->B4SOIpdvtp1 = value->rValue; + mod->B4SOIpdvtp1Given = TRUE; + break; + case B4SOI_MOD_MINV: + mod->B4SOIminv = value->rValue; + mod->B4SOIminvGiven = TRUE; + break; + case B4SOI_MOD_LMINV: + mod->B4SOIlminv = value->rValue; + mod->B4SOIlminvGiven = TRUE; + break; + case B4SOI_MOD_WMINV: + mod->B4SOIwminv = value->rValue; + mod->B4SOIwminvGiven = TRUE; + break; + case B4SOI_MOD_PMINV: + mod->B4SOIpminv = value->rValue; + mod->B4SOIpminvGiven = TRUE; + break; + case B4SOI_MOD_FPROUT: + mod->B4SOIfprout = value->rValue; + mod->B4SOIfproutGiven = TRUE; + break; + case B4SOI_MOD_PDITS: + mod->B4SOIpdits = value->rValue; + mod->B4SOIpditsGiven = TRUE; + break; + case B4SOI_MOD_PDITSD: + mod->B4SOIpditsd = value->rValue; + mod->B4SOIpditsdGiven = TRUE; + break; + case B4SOI_MOD_PDITSL: + mod->B4SOIpditsl = value->rValue; + mod->B4SOIpditslGiven = TRUE; + break; + case B4SOI_MOD_LFPROUT: + mod->B4SOIlfprout = value->rValue; + mod->B4SOIlfproutGiven = TRUE; + break; + case B4SOI_MOD_LPDITS: + mod->B4SOIlpdits = value->rValue; + mod->B4SOIlpditsGiven = TRUE; + break; + case B4SOI_MOD_LPDITSD: + mod->B4SOIlpditsd = value->rValue; + mod->B4SOIlpditsdGiven = TRUE; + break; + case B4SOI_MOD_WFPROUT: + mod->B4SOIwfprout = value->rValue; + mod->B4SOIwfproutGiven = TRUE; + break; + case B4SOI_MOD_WPDITS: + mod->B4SOIwpdits = value->rValue; + mod->B4SOIwpditsGiven = TRUE; + break; + case B4SOI_MOD_WPDITSD: + mod->B4SOIwpditsd = value->rValue; + mod->B4SOIwpditsdGiven = TRUE; + break; + case B4SOI_MOD_PFPROUT: + mod->B4SOIpfprout = value->rValue; + mod->B4SOIpfproutGiven = TRUE; + break; + case B4SOI_MOD_PPDITS: + mod->B4SOIppdits = value->rValue; + mod->B4SOIppditsGiven = TRUE; + break; + case B4SOI_MOD_PPDITSD: + mod->B4SOIppditsd = value->rValue; + mod->B4SOIppditsdGiven = TRUE; + break; + + /* v4.0 */ + + /* v4.0 stress effect */ + case B4SOI_MOD_SAREF : + mod->B4SOIsaref = value->rValue; + mod->B4SOIsarefGiven = TRUE; + break; + case B4SOI_MOD_SBREF : + mod->B4SOIsbref = value->rValue; + mod->B4SOIsbrefGiven = TRUE; + break; + case B4SOI_MOD_WLOD : + mod->B4SOIwlod = value->rValue; + mod->B4SOIwlodGiven = TRUE; + break; + case B4SOI_MOD_KU0 : + mod->B4SOIku0 = value->rValue; + mod->B4SOIku0Given = TRUE; + break; + case B4SOI_MOD_KVSAT : + mod->B4SOIkvsat = value->rValue; + mod->B4SOIkvsatGiven = TRUE; + break; + case B4SOI_MOD_KVTH0 : + mod->B4SOIkvth0 = value->rValue; + mod->B4SOIkvth0Given = TRUE; + break; + case B4SOI_MOD_TKU0 : + mod->B4SOItku0 = value->rValue; + mod->B4SOItku0Given = TRUE; + break; + case B4SOI_MOD_LLODKU0 : + mod->B4SOIllodku0 = value->rValue; + mod->B4SOIllodku0Given = TRUE; + break; + case B4SOI_MOD_WLODKU0 : + mod->B4SOIwlodku0 = value->rValue; + mod->B4SOIwlodku0Given = TRUE; + break; + case B4SOI_MOD_LLODVTH : + mod->B4SOIllodvth = value->rValue; + mod->B4SOIllodvthGiven = TRUE; + break; + case B4SOI_MOD_WLODVTH : + mod->B4SOIwlodvth = value->rValue; + mod->B4SOIwlodvthGiven = TRUE; + break; + case B4SOI_MOD_LKU0 : + mod->B4SOIlku0 = value->rValue; + mod->B4SOIlku0Given = TRUE; + break; + case B4SOI_MOD_WKU0 : + mod->B4SOIwku0 = value->rValue; + mod->B4SOIwku0Given = TRUE; + break; + case B4SOI_MOD_PKU0 : + mod->B4SOIpku0 = value->rValue; + mod->B4SOIpku0Given = TRUE; + break; + case B4SOI_MOD_LKVTH0 : + mod->B4SOIlkvth0 = value->rValue; + mod->B4SOIlkvth0Given = TRUE; + break; + case B4SOI_MOD_WKVTH0 : + mod->B4SOIwkvth0 = value->rValue; + mod->B4SOIwkvth0Given = TRUE; + break; + case B4SOI_MOD_PKVTH0 : + mod->B4SOIpkvth0 = value->rValue; + mod->B4SOIpkvth0Given = TRUE; + break; + case B4SOI_MOD_STK2 : + mod->B4SOIstk2 = value->rValue; + mod->B4SOIstk2Given = TRUE; + break; + case B4SOI_MOD_LODK2 : + mod->B4SOIlodk2 = value->rValue; + mod->B4SOIlodk2Given = TRUE; + case B4SOI_MOD_STETA0 : + mod->B4SOIsteta0 = value->rValue; + mod->B4SOIsteta0Given = TRUE; + break; + case B4SOI_MOD_LODETA0 : + mod->B4SOIlodeta0 = value->rValue; + mod->B4SOIlodeta0Given = TRUE; + break; + + /* v4.0 stress effect end */ + + /* v3.2 */ + case B4SOI_MOD_FNOIMOD : + mod->B4SOIfnoiMod = value->iValue; + mod->B4SOIfnoiModGiven = TRUE; + break; + case B4SOI_MOD_TNOIMOD : + mod->B4SOItnoiMod = value->iValue; + mod->B4SOItnoiModGiven = TRUE; + break; + case B4SOI_MOD_TNOIA : + mod->B4SOItnoia = value->rValue; + mod->B4SOItnoiaGiven = TRUE; + break; + case B4SOI_MOD_TNOIB : + mod->B4SOItnoib = value->rValue; + mod->B4SOItnoibGiven = TRUE; + break; + case B4SOI_MOD_RNOIA : + mod->B4SOIrnoia = value->rValue; + mod->B4SOIrnoiaGiven = TRUE; + break; + case B4SOI_MOD_RNOIB : + mod->B4SOIrnoib = value->rValue; + mod->B4SOIrnoibGiven = TRUE; + break; + case B4SOI_MOD_NTNOI : + mod->B4SOIntnoi = value->rValue; + mod->B4SOIntnoiGiven = TRUE; + break; + + /* v3.2 end */ + +/* v2.0 release */ + case B4SOI_MOD_K1W1 : + mod->B4SOIk1w1 = value->rValue; + mod->B4SOIk1w1Given = TRUE; + break; + case B4SOI_MOD_K1W2 : + mod->B4SOIk1w2 = value->rValue; + mod->B4SOIk1w2Given = TRUE; + break; + case B4SOI_MOD_KETAS : + mod->B4SOIketas = value->rValue; + mod->B4SOIketasGiven = TRUE; + break; + case B4SOI_MOD_DWBC : + mod->B4SOIdwbc = value->rValue; + mod->B4SOIdwbcGiven = TRUE; + break; + case B4SOI_MOD_BETA0 : + mod->B4SOIbeta0 = value->rValue; + mod->B4SOIbeta0Given = TRUE; + break; + case B4SOI_MOD_BETA1 : + mod->B4SOIbeta1 = value->rValue; + mod->B4SOIbeta1Given = TRUE; + break; + case B4SOI_MOD_BETA2 : + mod->B4SOIbeta2 = value->rValue; + mod->B4SOIbeta2Given = TRUE; + break; + case B4SOI_MOD_VDSATII0 : + mod->B4SOIvdsatii0 = value->rValue; + mod->B4SOIvdsatii0Given = TRUE; + break; + case B4SOI_MOD_TII : + mod->B4SOItii = value->rValue; + mod->B4SOItiiGiven = TRUE; + break; + case B4SOI_MOD_LII : + mod->B4SOIlii = value->rValue; + mod->B4SOIliiGiven = TRUE; + break; + case B4SOI_MOD_SII0 : + mod->B4SOIsii0 = value->rValue; + mod->B4SOIsii0Given = TRUE; + break; + case B4SOI_MOD_SII1 : + mod->B4SOIsii1 = value->rValue; + mod->B4SOIsii1Given = TRUE; + break; + case B4SOI_MOD_SII2 : + mod->B4SOIsii2 = value->rValue; + mod->B4SOIsii2Given = TRUE; + break; + case B4SOI_MOD_SIID : + mod->B4SOIsiid = value->rValue; + mod->B4SOIsiidGiven = TRUE; + break; + case B4SOI_MOD_FBJTII : + mod->B4SOIfbjtii = value->rValue; + mod->B4SOIfbjtiiGiven = TRUE; + break; + case B4SOI_MOD_ESATII : + mod->B4SOIesatii = value->rValue; + mod->B4SOIesatiiGiven = TRUE; + break; + case B4SOI_MOD_NTUNS : /* v4.0 */ + mod->B4SOIntun = value->rValue; + mod->B4SOIntunGiven = TRUE; + break; + case B4SOI_MOD_NTUND : /* v4.0 */ + mod->B4SOIntund = value->rValue; + mod->B4SOIntundGiven = TRUE; + break; + case B4SOI_MOD_NRECF0S : /* v4.0 */ + mod->B4SOInrecf0 = value->rValue; + mod->B4SOInrecf0Given = TRUE; + break; + case B4SOI_MOD_NRECF0D : /* v4.0 */ + mod->B4SOInrecf0d = value->rValue; + mod->B4SOInrecf0dGiven = TRUE; + break; + case B4SOI_MOD_NRECR0S : /* v4.0 */ + mod->B4SOInrecr0 = value->rValue; + mod->B4SOInrecr0Given = TRUE; + break; + case B4SOI_MOD_NRECR0D : /* v4.0 */ + mod->B4SOInrecr0d = value->rValue; + mod->B4SOInrecr0dGiven = TRUE; + break; + case B4SOI_MOD_ISBJT : + mod->B4SOIisbjt = value->rValue; + mod->B4SOIisbjtGiven = TRUE; + break; + case B4SOI_MOD_IDBJT : /* v4.0 */ + mod->B4SOIidbjt = value->rValue; + mod->B4SOIidbjtGiven = TRUE; + break; + case B4SOI_MOD_ISDIF : + mod->B4SOIisdif = value->rValue; + mod->B4SOIisdifGiven = TRUE; + break; + case B4SOI_MOD_IDDIF : /* v4.0 */ + mod->B4SOIiddif = value->rValue; + mod->B4SOIiddifGiven = TRUE; + break; + case B4SOI_MOD_ISREC : + mod->B4SOIisrec = value->rValue; + mod->B4SOIisrecGiven = TRUE; + break; + case B4SOI_MOD_IDREC : /* v4.0 */ + mod->B4SOIidrec = value->rValue; + mod->B4SOIidrecGiven = TRUE; + break; + case B4SOI_MOD_ISTUN : + mod->B4SOIistun = value->rValue; + mod->B4SOIistunGiven = TRUE; + break; + case B4SOI_MOD_IDTUN : /* v4.0 */ + mod->B4SOIidtun = value->rValue; + mod->B4SOIidtunGiven = TRUE; + break; + case B4SOI_MOD_LN : + mod->B4SOIln = value->rValue; + mod->B4SOIlnGiven = TRUE; + break; + case B4SOI_MOD_VREC0S : /* v4.0 */ + mod->B4SOIvrec0 = value->rValue; + mod->B4SOIvrec0Given = TRUE; + break; + case B4SOI_MOD_VREC0D : /* v4.0 */ + mod->B4SOIvrec0d = value->rValue; + mod->B4SOIvrec0dGiven = TRUE; + break; + case B4SOI_MOD_VTUN0S : /* v4.0 */ + mod->B4SOIvtun0 = value->rValue; + mod->B4SOIvtun0Given = TRUE; + break; + case B4SOI_MOD_VTUN0D : /* v4.0 */ + mod->B4SOIvtun0d = value->rValue; + mod->B4SOIvtun0dGiven = TRUE; + break; + case B4SOI_MOD_NBJT : + mod->B4SOInbjt = value->rValue; + mod->B4SOInbjtGiven = TRUE; + break; + case B4SOI_MOD_LBJT0 : + mod->B4SOIlbjt0 = value->rValue; + mod->B4SOIlbjt0Given = TRUE; + break; + case B4SOI_MOD_LDIF0 : + mod->B4SOIldif0 = value->rValue; + mod->B4SOIldif0Given = TRUE; + break; + case B4SOI_MOD_VABJT : + mod->B4SOIvabjt = value->rValue; + mod->B4SOIvabjtGiven = TRUE; + break; + case B4SOI_MOD_AELY : + mod->B4SOIaely = value->rValue; + mod->B4SOIaelyGiven = TRUE; + break; + case B4SOI_MOD_AHLIS : /* v4.0 */ + mod->B4SOIahli = value->rValue; + mod->B4SOIahliGiven = TRUE; + break; + case B4SOI_MOD_AHLID : /* v4.0 */ + mod->B4SOIahlid = value->rValue; + mod->B4SOIahlidGiven = TRUE; + break; + case B4SOI_MOD_NDIF : + mod->B4SOIndif = value->rValue; + mod->B4SOIndifGiven = TRUE; + break; + case B4SOI_MOD_NTRECF : + mod->B4SOIntrecf = value->rValue; + mod->B4SOIntrecfGiven = TRUE; + break; + case B4SOI_MOD_NTRECR : + mod->B4SOIntrecr = value->rValue; + mod->B4SOIntrecrGiven = TRUE; + break; + case B4SOI_MOD_DLCB : + mod->B4SOIdlcb = value->rValue; + mod->B4SOIdlcbGiven = TRUE; + break; + case B4SOI_MOD_FBODY : + mod->B4SOIfbody = value->rValue; + mod->B4SOIfbodyGiven = TRUE; + break; + case B4SOI_MOD_TCJSWGS : + mod->B4SOItcjswg = value->rValue; + mod->B4SOItcjswgGiven = TRUE; + break; + case B4SOI_MOD_TPBSWGS : + mod->B4SOItpbswg = value->rValue; + mod->B4SOItpbswgGiven = TRUE; + break; + case B4SOI_MOD_TCJSWGD : + mod->B4SOItcjswgd = value->rValue; + mod->B4SOItcjswgdGiven = TRUE; + break; + case B4SOI_MOD_TPBSWGD : + mod->B4SOItpbswgd = value->rValue; + mod->B4SOItpbswgdGiven = TRUE; + break; + + + case B4SOI_MOD_ACDE : + mod->B4SOIacde = value->rValue; + mod->B4SOIacdeGiven = TRUE; + break; + case B4SOI_MOD_MOIN : + mod->B4SOImoin = value->rValue; + mod->B4SOImoinGiven = TRUE; + break; + case B4SOI_MOD_NOFF : + mod->B4SOInoff = value->rValue; + mod->B4SOInoffGiven = TRUE; + break; /* v3.2 */ + case B4SOI_MOD_DELVT : + mod->B4SOIdelvt = value->rValue; + mod->B4SOIdelvtGiven = TRUE; + break; + case B4SOI_MOD_KB1 : + mod->B4SOIkb1 = value->rValue; + mod->B4SOIkb1Given = TRUE; + break; + case B4SOI_MOD_DLBG : + mod->B4SOIdlbg = value->rValue; + mod->B4SOIdlbgGiven = TRUE; + break; + +/* Added for binning - START */ + /* Length Dependence */ +/* v3.1 */ + case B4SOI_MOD_LXJ : + mod->B4SOIlxj = value->rValue; + mod->B4SOIlxjGiven = TRUE; + break; + case B4SOI_MOD_LALPHAGB1 : + mod->B4SOIlalphaGB1 = value->rValue; + mod->B4SOIlalphaGB1Given = TRUE; + break; + case B4SOI_MOD_LALPHAGB2 : + mod->B4SOIlalphaGB2 = value->rValue; + mod->B4SOIlalphaGB2Given = TRUE; + break; + case B4SOI_MOD_LBETAGB1 : + mod->B4SOIlbetaGB1 = value->rValue; + mod->B4SOIlbetaGB1Given = TRUE; + break; + case B4SOI_MOD_LBETAGB2 : + mod->B4SOIlbetaGB2 = value->rValue; + mod->B4SOIlbetaGB2Given = TRUE; + break; + case B4SOI_MOD_LNDIF : + mod->B4SOIlndif = value->rValue; + mod->B4SOIlndifGiven = TRUE; + break; + case B4SOI_MOD_LNTRECF : + mod->B4SOIlntrecf = value->rValue; + mod->B4SOIlntrecfGiven = TRUE; + break; + case B4SOI_MOD_LNTRECR : + mod->B4SOIlntrecr = value->rValue; + mod->B4SOIlntrecrGiven = TRUE; + break; + case B4SOI_MOD_LXBJT : + mod->B4SOIlxbjt = value->rValue; + mod->B4SOIlxbjtGiven = TRUE; + break; + case B4SOI_MOD_LXDIFS : + mod->B4SOIlxdif = value->rValue; + mod->B4SOIlxdifGiven = TRUE; + break; + case B4SOI_MOD_LXRECS : + mod->B4SOIlxrec = value->rValue; + mod->B4SOIlxrecGiven = TRUE; + break; + case B4SOI_MOD_LXTUNS : + mod->B4SOIlxtun = value->rValue; + mod->B4SOIlxtunGiven = TRUE; + break; + case B4SOI_MOD_LXDIFD : + mod->B4SOIlxdifd = value->rValue; + mod->B4SOIlxdifdGiven = TRUE; + break; + case B4SOI_MOD_LXRECD : + mod->B4SOIlxrecd = value->rValue; + mod->B4SOIlxrecdGiven = TRUE; + break; + case B4SOI_MOD_LXTUND : + mod->B4SOIlxtund = value->rValue; + mod->B4SOIlxtundGiven = TRUE; + break; + case B4SOI_MOD_LCGDL : + mod->B4SOIlcgdl = value->rValue; + mod->B4SOIlcgdlGiven = TRUE; + break; + case B4SOI_MOD_LCGSL : + mod->B4SOIlcgsl = value->rValue; + mod->B4SOIlcgslGiven = TRUE; + break; + case B4SOI_MOD_LCKAPPA : + mod->B4SOIlckappa = value->rValue; + mod->B4SOIlckappaGiven = TRUE; + break; + case B4SOI_MOD_LUTE : + mod->B4SOIlute = value->rValue; + mod->B4SOIluteGiven = TRUE; + break; + case B4SOI_MOD_LKT1 : + mod->B4SOIlkt1 = value->rValue; + mod->B4SOIlkt1Given = TRUE; + break; + case B4SOI_MOD_LKT2 : + mod->B4SOIlkt2 = value->rValue; + mod->B4SOIlkt2Given = TRUE; + break; + case B4SOI_MOD_LKT1L : + mod->B4SOIlkt1l = value->rValue; + mod->B4SOIlkt1lGiven = TRUE; + break; + case B4SOI_MOD_LUA1 : + mod->B4SOIlua1 = value->rValue; + mod->B4SOIlua1Given = TRUE; + break; + case B4SOI_MOD_LUB1 : + mod->B4SOIlub1 = value->rValue; + mod->B4SOIlub1Given = TRUE; + break; + case B4SOI_MOD_LUC1 : + mod->B4SOIluc1 = value->rValue; + mod->B4SOIluc1Given = TRUE; + break; + case B4SOI_MOD_LAT : + mod->B4SOIlat = value->rValue; + mod->B4SOIlatGiven = TRUE; + break; + case B4SOI_MOD_LPRT : + mod->B4SOIlprt = value->rValue; + mod->B4SOIlprtGiven = TRUE; + break; + + +/* v3.0 */ + case B4SOI_MOD_LAIGC : + mod->B4SOIlaigc = value->rValue; + mod->B4SOIlaigcGiven = TRUE; + break; + case B4SOI_MOD_LBIGC : + mod->B4SOIlbigc = value->rValue; + mod->B4SOIlbigcGiven = TRUE; + break; + case B4SOI_MOD_LCIGC : + mod->B4SOIlcigc = value->rValue; + mod->B4SOIlcigcGiven = TRUE; + break; + case B4SOI_MOD_LAIGSD : + mod->B4SOIlaigsd = value->rValue; + mod->B4SOIlaigsdGiven = TRUE; + break; + case B4SOI_MOD_LBIGSD : + mod->B4SOIlbigsd = value->rValue; + mod->B4SOIlbigsdGiven = TRUE; + break; + case B4SOI_MOD_LCIGSD : + mod->B4SOIlcigsd = value->rValue; + mod->B4SOIlcigsdGiven = TRUE; + break; + case B4SOI_MOD_LNIGC : + mod->B4SOIlnigc = value->rValue; + mod->B4SOIlnigcGiven = TRUE; + break; + case B4SOI_MOD_LPIGCD : + mod->B4SOIlpigcd = value->rValue; + mod->B4SOIlpigcdGiven = TRUE; + break; + case B4SOI_MOD_LPOXEDGE : + mod->B4SOIlpoxedge = value->rValue; + mod->B4SOIlpoxedgeGiven = TRUE; + break; + + case B4SOI_MOD_LNPEAK: + mod->B4SOIlnpeak = value->rValue; + mod->B4SOIlnpeakGiven = TRUE; + break; + case B4SOI_MOD_LNSUB: + mod->B4SOIlnsub = value->rValue; + mod->B4SOIlnsubGiven = TRUE; + break; + case B4SOI_MOD_LNGATE: + mod->B4SOIlngate = value->rValue; + mod->B4SOIlngateGiven = TRUE; + break; + case B4SOI_MOD_LVTH0: + mod->B4SOIlvth0 = value->rValue; + mod->B4SOIlvth0Given = TRUE; + break; + case B4SOI_MOD_LK1: + mod->B4SOIlk1 = value->rValue; + mod->B4SOIlk1Given = TRUE; + break; + case B4SOI_MOD_LK1W1: + mod->B4SOIlk1w1 = value->rValue; + mod->B4SOIlk1w1Given = TRUE; + break; + case B4SOI_MOD_LK1W2: + mod->B4SOIlk1w2 = value->rValue; + mod->B4SOIlk1w2Given = TRUE; + break; + case B4SOI_MOD_LK2: + mod->B4SOIlk2 = value->rValue; + mod->B4SOIlk2Given = TRUE; + break; + case B4SOI_MOD_LK3: + mod->B4SOIlk3 = value->rValue; + mod->B4SOIlk3Given = TRUE; + break; + case B4SOI_MOD_LK3B: + mod->B4SOIlk3b = value->rValue; + mod->B4SOIlk3bGiven = TRUE; + break; + case B4SOI_MOD_LKB1 : + mod->B4SOIlkb1 = value->rValue; + mod->B4SOIlkb1Given = TRUE; + break; + case B4SOI_MOD_LW0: + mod->B4SOIlw0 = value->rValue; + mod->B4SOIlw0Given = TRUE; + break; + case B4SOI_MOD_LLPE0: + mod->B4SOIllpe0 = value->rValue; + mod->B4SOIllpe0Given = TRUE; + break; + case B4SOI_MOD_LLPEB: /* v4.0 for Vth */ + mod->B4SOIllpeb = value->rValue; + mod->B4SOIllpebGiven = TRUE; + break; + case B4SOI_MOD_LDVT0: + mod->B4SOIldvt0 = value->rValue; + mod->B4SOIldvt0Given = TRUE; + break; + case B4SOI_MOD_LDVT1: + mod->B4SOIldvt1 = value->rValue; + mod->B4SOIldvt1Given = TRUE; + break; + case B4SOI_MOD_LDVT2: + mod->B4SOIldvt2 = value->rValue; + mod->B4SOIldvt2Given = TRUE; + break; + case B4SOI_MOD_LDVT0W: + mod->B4SOIldvt0w = value->rValue; + mod->B4SOIldvt0wGiven = TRUE; + break; + case B4SOI_MOD_LDVT1W: + mod->B4SOIldvt1w = value->rValue; + mod->B4SOIldvt1wGiven = TRUE; + break; + case B4SOI_MOD_LDVT2W: + mod->B4SOIldvt2w = value->rValue; + mod->B4SOIldvt2wGiven = TRUE; + break; + case B4SOI_MOD_LU0 : + mod->B4SOIlu0 = value->rValue; + mod->B4SOIlu0Given = TRUE; + break; + case B4SOI_MOD_LUA: + mod->B4SOIlua = value->rValue; + mod->B4SOIluaGiven = TRUE; + break; + case B4SOI_MOD_LUB: + mod->B4SOIlub = value->rValue; + mod->B4SOIlubGiven = TRUE; + break; + case B4SOI_MOD_LUC: + mod->B4SOIluc = value->rValue; + mod->B4SOIlucGiven = TRUE; + break; + case B4SOI_MOD_LVSAT: + mod->B4SOIlvsat = value->rValue; + mod->B4SOIlvsatGiven = TRUE; + break; + case B4SOI_MOD_LA0: + mod->B4SOIla0 = value->rValue; + mod->B4SOIla0Given = TRUE; + break; + case B4SOI_MOD_LAGS: + mod->B4SOIlags= value->rValue; + mod->B4SOIlagsGiven = TRUE; + break; + case B4SOI_MOD_LB0 : + mod->B4SOIlb0 = value->rValue; + mod->B4SOIlb0Given = TRUE; + break; + case B4SOI_MOD_LB1 : + mod->B4SOIlb1 = value->rValue; + mod->B4SOIlb1Given = TRUE; + break; + case B4SOI_MOD_LKETA: + mod->B4SOIlketa = value->rValue; + mod->B4SOIlketaGiven = TRUE; + break; + case B4SOI_MOD_LKETAS: + mod->B4SOIlketas = value->rValue; + mod->B4SOIlketasGiven = TRUE; + break; + case B4SOI_MOD_LA1: + mod->B4SOIla1 = value->rValue; + mod->B4SOIla1Given = TRUE; + break; + case B4SOI_MOD_LA2: + mod->B4SOIla2 = value->rValue; + mod->B4SOIla2Given = TRUE; + break; + case B4SOI_MOD_LRDSW: + mod->B4SOIlrdsw = value->rValue; + mod->B4SOIlrdswGiven = TRUE; + break; + case B4SOI_MOD_LRSW: + mod->B4SOIlrsw = value->rValue; + mod->B4SOIlrswGiven = TRUE; + break; + case B4SOI_MOD_LRDW: + mod->B4SOIlrdw = value->rValue; + mod->B4SOIlrdwGiven = TRUE; + break; + case B4SOI_MOD_LPRWB: + mod->B4SOIlprwb = value->rValue; + mod->B4SOIlprwbGiven = TRUE; + break; + case B4SOI_MOD_LPRWG: + mod->B4SOIlprwg = value->rValue; + mod->B4SOIlprwgGiven = TRUE; + break; + case B4SOI_MOD_LWR : + mod->B4SOIlwr = value->rValue; + mod->B4SOIlwrGiven = TRUE; + break; + case B4SOI_MOD_LNFACTOR : + mod->B4SOIlnfactor = value->rValue; + mod->B4SOIlnfactorGiven = TRUE; + break; + case B4SOI_MOD_LDWG : + mod->B4SOIldwg = value->rValue; + mod->B4SOIldwgGiven = TRUE; + break; + case B4SOI_MOD_LDWB : + mod->B4SOIldwb = value->rValue; + mod->B4SOIldwbGiven = TRUE; + break; + case B4SOI_MOD_LVOFF: + mod->B4SOIlvoff = value->rValue; + mod->B4SOIlvoffGiven = TRUE; + break; + case B4SOI_MOD_LETA0: + mod->B4SOIleta0 = value->rValue; + mod->B4SOIleta0Given = TRUE; + break; + case B4SOI_MOD_LETAB: + mod->B4SOIletab = value->rValue; + mod->B4SOIletabGiven = TRUE; + break; + case B4SOI_MOD_LDSUB: + mod->B4SOIldsub = value->rValue; + mod->B4SOIldsubGiven = TRUE; + break; + case B4SOI_MOD_LCIT : + mod->B4SOIlcit = value->rValue; + mod->B4SOIlcitGiven = TRUE; + break; + case B4SOI_MOD_LCDSC : + mod->B4SOIlcdsc = value->rValue; + mod->B4SOIlcdscGiven = TRUE; + break; + case B4SOI_MOD_LCDSCB : + mod->B4SOIlcdscb = value->rValue; + mod->B4SOIlcdscbGiven = TRUE; + break; + case B4SOI_MOD_LCDSCD : + mod->B4SOIlcdscd = value->rValue; + mod->B4SOIlcdscdGiven = TRUE; + break; + case B4SOI_MOD_LPCLM: + mod->B4SOIlpclm = value->rValue; + mod->B4SOIlpclmGiven = TRUE; + break; + case B4SOI_MOD_LPDIBL1: + mod->B4SOIlpdibl1 = value->rValue; + mod->B4SOIlpdibl1Given = TRUE; + break; + case B4SOI_MOD_LPDIBL2: + mod->B4SOIlpdibl2 = value->rValue; + mod->B4SOIlpdibl2Given = TRUE; + break; + case B4SOI_MOD_LPDIBLB: + mod->B4SOIlpdiblb = value->rValue; + mod->B4SOIlpdiblbGiven = TRUE; + break; + case B4SOI_MOD_LDROUT: + mod->B4SOIldrout = value->rValue; + mod->B4SOIldroutGiven = TRUE; + break; + case B4SOI_MOD_LPVAG: + mod->B4SOIlpvag = value->rValue; + mod->B4SOIlpvagGiven = TRUE; + break; + case B4SOI_MOD_LDELTA : + mod->B4SOIldelta = value->rValue; + mod->B4SOIldeltaGiven = TRUE; + break; + case B4SOI_MOD_LALPHA0 : + mod->B4SOIlalpha0 = value->rValue; + mod->B4SOIlalpha0Given = TRUE; + break; + case B4SOI_MOD_LFBJTII : + mod->B4SOIlfbjtii = value->rValue; + mod->B4SOIlfbjtiiGiven = TRUE; + break; + case B4SOI_MOD_LBETA0 : + mod->B4SOIlbeta0 = value->rValue; + mod->B4SOIlbeta0Given = TRUE; + break; + case B4SOI_MOD_LBETA1 : + mod->B4SOIlbeta1 = value->rValue; + mod->B4SOIlbeta1Given = TRUE; + break; + case B4SOI_MOD_LBETA2 : + mod->B4SOIlbeta2 = value->rValue; + mod->B4SOIlbeta2Given = TRUE; + break; + case B4SOI_MOD_LVDSATII0 : + mod->B4SOIlvdsatii0 = value->rValue; + mod->B4SOIlvdsatii0Given = TRUE; + break; + case B4SOI_MOD_LLII : + mod->B4SOIllii = value->rValue; + mod->B4SOIlliiGiven = TRUE; + break; + case B4SOI_MOD_LESATII : + mod->B4SOIlesatii = value->rValue; + mod->B4SOIlesatiiGiven = TRUE; + break; + case B4SOI_MOD_LSII0 : + mod->B4SOIlsii0 = value->rValue; + mod->B4SOIlsii0Given = TRUE; + break; + case B4SOI_MOD_LSII1 : + mod->B4SOIlsii1 = value->rValue; + mod->B4SOIlsii1Given = TRUE; + break; + case B4SOI_MOD_LSII2 : + mod->B4SOIlsii2 = value->rValue; + mod->B4SOIlsii2Given = TRUE; + break; + case B4SOI_MOD_LSIID : + mod->B4SOIlsiid = value->rValue; + mod->B4SOIlsiidGiven = TRUE; + break; + case B4SOI_MOD_LAGIDL : + mod->B4SOIlagidl = value->rValue; + mod->B4SOIlagidlGiven = TRUE; + break; + case B4SOI_MOD_LBGIDL : + mod->B4SOIlbgidl = value->rValue; + mod->B4SOIlbgidlGiven = TRUE; + break; + case B4SOI_MOD_LCGIDL : + mod->B4SOIlcgidl = value->rValue; + mod->B4SOIlcgidlGiven = TRUE; + break; + case B4SOI_MOD_LEGIDL : + mod->B4SOIlegidl = value->rValue; + mod->B4SOIlegidlGiven = TRUE; + break; + case B4SOI_MOD_LNTUNS : /* v4.0 */ + mod->B4SOIlntun = value->rValue; + mod->B4SOIlntunGiven = TRUE; + break; + case B4SOI_MOD_LNTUND : /* v4.0 */ + mod->B4SOIlntund = value->rValue; + mod->B4SOIlntundGiven = TRUE; + break; + case B4SOI_MOD_LNDIODES : /* v4.0 */ + mod->B4SOIlndiode = value->rValue; + mod->B4SOIlndiodeGiven = TRUE; + break; + case B4SOI_MOD_LNDIODED : /* v4.0 */ + mod->B4SOIlndioded = value->rValue; + mod->B4SOIlndiodedGiven = TRUE; + break; + case B4SOI_MOD_LNRECF0S : /* v4.0 */ + mod->B4SOIlnrecf0 = value->rValue; + mod->B4SOIlnrecf0Given = TRUE; + break; + case B4SOI_MOD_LNRECF0D : /* v4.0 */ + mod->B4SOIlnrecf0d = value->rValue; + mod->B4SOIlnrecf0dGiven = TRUE; + break; + case B4SOI_MOD_LNRECR0S : /* v4.0 */ + mod->B4SOIlnrecr0 = value->rValue; + mod->B4SOIlnrecr0Given = TRUE; + break; + case B4SOI_MOD_LNRECR0D : /* v4.0 */ + mod->B4SOIlnrecr0d = value->rValue; + mod->B4SOIlnrecr0dGiven = TRUE; + break; + case B4SOI_MOD_LISBJT : + mod->B4SOIlisbjt = value->rValue; + mod->B4SOIlisbjtGiven = TRUE; + break; + case B4SOI_MOD_LIDBJT : /* v4.0 */ + mod->B4SOIlidbjt = value->rValue; + mod->B4SOIlidbjtGiven = TRUE; + break; + case B4SOI_MOD_LISDIF : + mod->B4SOIlisdif = value->rValue; + mod->B4SOIlisdifGiven = TRUE; + break; + case B4SOI_MOD_LIDDIF : /* v4.0 */ + mod->B4SOIliddif = value->rValue; + mod->B4SOIliddifGiven = TRUE; + break; + case B4SOI_MOD_LISREC : + mod->B4SOIlisrec = value->rValue; + mod->B4SOIlisrecGiven = TRUE; + break; + case B4SOI_MOD_LIDREC : /* v4.0 */ + mod->B4SOIlidrec = value->rValue; + mod->B4SOIlidrecGiven = TRUE; + break; + case B4SOI_MOD_LISTUN : + mod->B4SOIlistun = value->rValue; + mod->B4SOIlistunGiven = TRUE; + break; + case B4SOI_MOD_LIDTUN : /* v4.0 */ + mod->B4SOIlidtun = value->rValue; + mod->B4SOIlidtunGiven = TRUE; + break; + case B4SOI_MOD_LVREC0S : /* v4.0 */ + mod->B4SOIlvrec0 = value->rValue; + mod->B4SOIlvrec0Given = TRUE; + break; + case B4SOI_MOD_LVREC0D : /* v4.0 */ + mod->B4SOIlvrec0d = value->rValue; + mod->B4SOIlvrec0dGiven = TRUE; + break; + case B4SOI_MOD_LVTUN0S : /* v4.0 */ + mod->B4SOIlvtun0 = value->rValue; + mod->B4SOIlvtun0Given = TRUE; + break; + case B4SOI_MOD_LVTUN0D : /* v4.0 */ + mod->B4SOIlvtun0d = value->rValue; + mod->B4SOIlvtun0dGiven = TRUE; + break; + case B4SOI_MOD_LNBJT : + mod->B4SOIlnbjt = value->rValue; + mod->B4SOIlnbjtGiven = TRUE; + break; + case B4SOI_MOD_LLBJT0 : + mod->B4SOIllbjt0 = value->rValue; + mod->B4SOIllbjt0Given = TRUE; + break; + case B4SOI_MOD_LVABJT : + mod->B4SOIlvabjt = value->rValue; + mod->B4SOIlvabjtGiven = TRUE; + break; + case B4SOI_MOD_LAELY : + mod->B4SOIlaely = value->rValue; + mod->B4SOIlaelyGiven = TRUE; + break; + case B4SOI_MOD_LAHLIS : /* v4.0 */ + mod->B4SOIlahli = value->rValue; + mod->B4SOIlahliGiven = TRUE; + break; + case B4SOI_MOD_LAHLID : /* v4.0 */ + mod->B4SOIlahlid = value->rValue; + mod->B4SOIlahlidGiven = TRUE; + break; + +/* v3.1 for RF */ + case B4SOI_MOD_LXRCRG1 : + mod->B4SOIlxrcrg1 = value->rValue; + mod->B4SOIlxrcrg1Given = TRUE; + break; + case B4SOI_MOD_LXRCRG2 : + mod->B4SOIlxrcrg2 = value->rValue; + mod->B4SOIlxrcrg2Given = TRUE; + break; +/* v3.1 for RF end */ + + /* CV Model */ + case B4SOI_MOD_LVSDFB : + mod->B4SOIlvsdfb = value->rValue; + mod->B4SOIlvsdfbGiven = TRUE; + break; + case B4SOI_MOD_LVSDTH : + mod->B4SOIlvsdth = value->rValue; + mod->B4SOIlvsdthGiven = TRUE; + break; + case B4SOI_MOD_LDELVT : + mod->B4SOIldelvt = value->rValue; + mod->B4SOIldelvtGiven = TRUE; + break; + case B4SOI_MOD_LACDE : + mod->B4SOIlacde = value->rValue; + mod->B4SOIlacdeGiven = TRUE; + break; + case B4SOI_MOD_LMOIN : + mod->B4SOIlmoin = value->rValue; + mod->B4SOIlmoinGiven = TRUE; + break; + case B4SOI_MOD_LNOFF : + mod->B4SOIlnoff = value->rValue; + mod->B4SOIlnoffGiven = TRUE; + break; /* v3.2 */ + + /* Width Dependence */ +/* v3.1 */ + case B4SOI_MOD_WXJ : + mod->B4SOIwxj = value->rValue; + mod->B4SOIwxjGiven = TRUE; + break; + case B4SOI_MOD_WALPHAGB1 : + mod->B4SOIwalphaGB1 = value->rValue; + mod->B4SOIwalphaGB1Given = TRUE; + break; + case B4SOI_MOD_WALPHAGB2 : + mod->B4SOIwalphaGB2 = value->rValue; + mod->B4SOIwalphaGB2Given = TRUE; + break; + case B4SOI_MOD_WBETAGB1 : + mod->B4SOIwbetaGB1 = value->rValue; + mod->B4SOIwbetaGB1Given = TRUE; + break; + case B4SOI_MOD_WBETAGB2 : + mod->B4SOIwbetaGB2 = value->rValue; + mod->B4SOIwbetaGB2Given = TRUE; + break; + case B4SOI_MOD_WNDIF : + mod->B4SOIwndif = value->rValue; + mod->B4SOIwndifGiven = TRUE; + break; + case B4SOI_MOD_WNTRECF : + mod->B4SOIwntrecf = value->rValue; + mod->B4SOIwntrecfGiven = TRUE; + break; + case B4SOI_MOD_WNTRECR : + mod->B4SOIwntrecr = value->rValue; + mod->B4SOIwntrecrGiven = TRUE; + break; + case B4SOI_MOD_WXBJT : + mod->B4SOIwxbjt = value->rValue; + mod->B4SOIwxbjtGiven = TRUE; + break; + case B4SOI_MOD_WXDIFS : + mod->B4SOIwxdif = value->rValue; + mod->B4SOIwxdifGiven = TRUE; + break; + case B4SOI_MOD_WXRECS : + mod->B4SOIwxrec = value->rValue; + mod->B4SOIwxrecGiven = TRUE; + break; + case B4SOI_MOD_WXTUNS : + mod->B4SOIwxtun = value->rValue; + mod->B4SOIwxtunGiven = TRUE; + break; + case B4SOI_MOD_WXDIFD : + mod->B4SOIwxdifd = value->rValue; + mod->B4SOIwxdifdGiven = TRUE; + break; + case B4SOI_MOD_WXRECD : + mod->B4SOIwxrecd = value->rValue; + mod->B4SOIwxrecdGiven = TRUE; + break; + case B4SOI_MOD_WXTUND : + mod->B4SOIwxtund = value->rValue; + mod->B4SOIwxtundGiven = TRUE; + break; + case B4SOI_MOD_WCGDL : + mod->B4SOIwcgdl = value->rValue; + mod->B4SOIwcgdlGiven = TRUE; + break; + case B4SOI_MOD_WCGSL : + mod->B4SOIwcgsl = value->rValue; + mod->B4SOIwcgslGiven = TRUE; + break; + case B4SOI_MOD_WCKAPPA : + mod->B4SOIwckappa = value->rValue; + mod->B4SOIwckappaGiven = TRUE; + break; + case B4SOI_MOD_WUTE : + mod->B4SOIwute = value->rValue; + mod->B4SOIwuteGiven = TRUE; + break; + case B4SOI_MOD_WKT1 : + mod->B4SOIwkt1 = value->rValue; + mod->B4SOIwkt1Given = TRUE; + break; + case B4SOI_MOD_WKT2 : + mod->B4SOIwkt2 = value->rValue; + mod->B4SOIwkt2Given = TRUE; + break; + case B4SOI_MOD_WKT1L : + mod->B4SOIwkt1l = value->rValue; + mod->B4SOIwkt1lGiven = TRUE; + break; + case B4SOI_MOD_WUA1 : + mod->B4SOIwua1 = value->rValue; + mod->B4SOIwua1Given = TRUE; + break; + case B4SOI_MOD_WUB1 : + mod->B4SOIwub1 = value->rValue; + mod->B4SOIwub1Given = TRUE; + break; + case B4SOI_MOD_WUC1 : + mod->B4SOIwuc1 = value->rValue; + mod->B4SOIwuc1Given = TRUE; + break; + case B4SOI_MOD_WAT : + mod->B4SOIwat = value->rValue; + mod->B4SOIwatGiven = TRUE; + break; + case B4SOI_MOD_WPRT : + mod->B4SOIwprt = value->rValue; + mod->B4SOIwprtGiven = TRUE; + break; + +/* v3.0 */ + case B4SOI_MOD_WAIGC : + mod->B4SOIwaigc = value->rValue; + mod->B4SOIwaigcGiven = TRUE; + break; + case B4SOI_MOD_WBIGC : + mod->B4SOIwbigc = value->rValue; + mod->B4SOIwbigcGiven = TRUE; + break; + case B4SOI_MOD_WCIGC : + mod->B4SOIwcigc = value->rValue; + mod->B4SOIwcigcGiven = TRUE; + break; + case B4SOI_MOD_WAIGSD : + mod->B4SOIwaigsd = value->rValue; + mod->B4SOIwaigsdGiven = TRUE; + break; + case B4SOI_MOD_WBIGSD : + mod->B4SOIwbigsd = value->rValue; + mod->B4SOIwbigsdGiven = TRUE; + break; + case B4SOI_MOD_WCIGSD : + mod->B4SOIwcigsd = value->rValue; + mod->B4SOIwcigsdGiven = TRUE; + break; + case B4SOI_MOD_WNIGC : + mod->B4SOIwnigc = value->rValue; + mod->B4SOIwnigcGiven = TRUE; + break; + case B4SOI_MOD_WPIGCD : + mod->B4SOIwpigcd = value->rValue; + mod->B4SOIwpigcdGiven = TRUE; + break; + case B4SOI_MOD_WPOXEDGE : + mod->B4SOIwpoxedge = value->rValue; + mod->B4SOIwpoxedgeGiven = TRUE; + break; + + case B4SOI_MOD_WNPEAK: + mod->B4SOIwnpeak = value->rValue; + mod->B4SOIwnpeakGiven = TRUE; + break; + case B4SOI_MOD_WNSUB: + mod->B4SOIwnsub = value->rValue; + mod->B4SOIwnsubGiven = TRUE; + break; + case B4SOI_MOD_WNGATE: + mod->B4SOIwngate = value->rValue; + mod->B4SOIwngateGiven = TRUE; + break; + case B4SOI_MOD_WVTH0: + mod->B4SOIwvth0 = value->rValue; + mod->B4SOIwvth0Given = TRUE; + break; + case B4SOI_MOD_WK1: + mod->B4SOIwk1 = value->rValue; + mod->B4SOIwk1Given = TRUE; + break; + case B4SOI_MOD_WK1W1: + mod->B4SOIwk1w1 = value->rValue; + mod->B4SOIwk1w1Given = TRUE; + break; + case B4SOI_MOD_WK1W2: + mod->B4SOIwk1w2 = value->rValue; + mod->B4SOIwk1w2Given = TRUE; + break; + case B4SOI_MOD_WK2: + mod->B4SOIwk2 = value->rValue; + mod->B4SOIwk2Given = TRUE; + break; + case B4SOI_MOD_WK3: + mod->B4SOIwk3 = value->rValue; + mod->B4SOIwk3Given = TRUE; + break; + case B4SOI_MOD_WK3B: + mod->B4SOIwk3b = value->rValue; + mod->B4SOIwk3bGiven = TRUE; + break; + case B4SOI_MOD_WKB1 : + mod->B4SOIwkb1 = value->rValue; + mod->B4SOIwkb1Given = TRUE; + break; + case B4SOI_MOD_WW0: + mod->B4SOIww0 = value->rValue; + mod->B4SOIww0Given = TRUE; + break; + case B4SOI_MOD_WLPE0: + mod->B4SOIwlpe0 = value->rValue; + mod->B4SOIwlpe0Given = TRUE; + break; + case B4SOI_MOD_WLPEB: /* v4.0 for Vth */ + mod->B4SOIwlpeb = value->rValue; + mod->B4SOIwlpebGiven = TRUE; + break; + case B4SOI_MOD_WDVT0: + mod->B4SOIwdvt0 = value->rValue; + mod->B4SOIwdvt0Given = TRUE; + break; + case B4SOI_MOD_WDVT1: + mod->B4SOIwdvt1 = value->rValue; + mod->B4SOIwdvt1Given = TRUE; + break; + case B4SOI_MOD_WDVT2: + mod->B4SOIwdvt2 = value->rValue; + mod->B4SOIwdvt2Given = TRUE; + break; + case B4SOI_MOD_WDVT0W: + mod->B4SOIwdvt0w = value->rValue; + mod->B4SOIwdvt0wGiven = TRUE; + break; + case B4SOI_MOD_WDVT1W: + mod->B4SOIwdvt1w = value->rValue; + mod->B4SOIwdvt1wGiven = TRUE; + break; + case B4SOI_MOD_WDVT2W: + mod->B4SOIwdvt2w = value->rValue; + mod->B4SOIwdvt2wGiven = TRUE; + break; + case B4SOI_MOD_WU0 : + mod->B4SOIwu0 = value->rValue; + mod->B4SOIwu0Given = TRUE; + break; + case B4SOI_MOD_WUA: + mod->B4SOIwua = value->rValue; + mod->B4SOIwuaGiven = TRUE; + break; + case B4SOI_MOD_WUB: + mod->B4SOIwub = value->rValue; + mod->B4SOIwubGiven = TRUE; + break; + case B4SOI_MOD_WUC: + mod->B4SOIwuc = value->rValue; + mod->B4SOIwucGiven = TRUE; + break; + case B4SOI_MOD_WVSAT: + mod->B4SOIwvsat = value->rValue; + mod->B4SOIwvsatGiven = TRUE; + break; + case B4SOI_MOD_WA0: + mod->B4SOIwa0 = value->rValue; + mod->B4SOIwa0Given = TRUE; + break; + case B4SOI_MOD_WAGS: + mod->B4SOIwags= value->rValue; + mod->B4SOIwagsGiven = TRUE; + break; + case B4SOI_MOD_WB0 : + mod->B4SOIwb0 = value->rValue; + mod->B4SOIwb0Given = TRUE; + break; + case B4SOI_MOD_WB1 : + mod->B4SOIwb1 = value->rValue; + mod->B4SOIwb1Given = TRUE; + break; + case B4SOI_MOD_WKETA: + mod->B4SOIwketa = value->rValue; + mod->B4SOIwketaGiven = TRUE; + break; + case B4SOI_MOD_WKETAS: + mod->B4SOIwketas = value->rValue; + mod->B4SOIwketasGiven = TRUE; + break; + case B4SOI_MOD_WA1: + mod->B4SOIwa1 = value->rValue; + mod->B4SOIwa1Given = TRUE; + break; + case B4SOI_MOD_WA2: + mod->B4SOIwa2 = value->rValue; + mod->B4SOIwa2Given = TRUE; + break; + case B4SOI_MOD_WRDSW: + mod->B4SOIwrdsw = value->rValue; + mod->B4SOIwrdswGiven = TRUE; + break; + case B4SOI_MOD_WRSW: + mod->B4SOIwrsw = value->rValue; + mod->B4SOIwrswGiven = TRUE; + break; + case B4SOI_MOD_WRDW: + mod->B4SOIwrdw = value->rValue; + mod->B4SOIwrdwGiven = TRUE; + break; + case B4SOI_MOD_WPRWB: + mod->B4SOIwprwb = value->rValue; + mod->B4SOIwprwbGiven = TRUE; + break; + case B4SOI_MOD_WPRWG: + mod->B4SOIwprwg = value->rValue; + mod->B4SOIwprwgGiven = TRUE; + break; + case B4SOI_MOD_WWR : + mod->B4SOIwwr = value->rValue; + mod->B4SOIwwrGiven = TRUE; + break; + case B4SOI_MOD_WNFACTOR : + mod->B4SOIwnfactor = value->rValue; + mod->B4SOIwnfactorGiven = TRUE; + break; + case B4SOI_MOD_WDWG : + mod->B4SOIwdwg = value->rValue; + mod->B4SOIwdwgGiven = TRUE; + break; + case B4SOI_MOD_WDWB : + mod->B4SOIwdwb = value->rValue; + mod->B4SOIwdwbGiven = TRUE; + break; + case B4SOI_MOD_WVOFF: + mod->B4SOIwvoff = value->rValue; + mod->B4SOIwvoffGiven = TRUE; + break; + case B4SOI_MOD_WETA0: + mod->B4SOIweta0 = value->rValue; + mod->B4SOIweta0Given = TRUE; + break; + case B4SOI_MOD_WETAB: + mod->B4SOIwetab = value->rValue; + mod->B4SOIwetabGiven = TRUE; + break; + case B4SOI_MOD_WDSUB: + mod->B4SOIwdsub = value->rValue; + mod->B4SOIwdsubGiven = TRUE; + break; + case B4SOI_MOD_WCIT : + mod->B4SOIwcit = value->rValue; + mod->B4SOIwcitGiven = TRUE; + break; + case B4SOI_MOD_WCDSC : + mod->B4SOIwcdsc = value->rValue; + mod->B4SOIwcdscGiven = TRUE; + break; + case B4SOI_MOD_WCDSCB : + mod->B4SOIwcdscb = value->rValue; + mod->B4SOIwcdscbGiven = TRUE; + break; + case B4SOI_MOD_WCDSCD : + mod->B4SOIwcdscd = value->rValue; + mod->B4SOIwcdscdGiven = TRUE; + break; + case B4SOI_MOD_WPCLM: + mod->B4SOIwpclm = value->rValue; + mod->B4SOIwpclmGiven = TRUE; + break; + case B4SOI_MOD_WPDIBL1: + mod->B4SOIwpdibl1 = value->rValue; + mod->B4SOIwpdibl1Given = TRUE; + break; + case B4SOI_MOD_WPDIBL2: + mod->B4SOIwpdibl2 = value->rValue; + mod->B4SOIwpdibl2Given = TRUE; + break; + case B4SOI_MOD_WPDIBLB: + mod->B4SOIwpdiblb = value->rValue; + mod->B4SOIwpdiblbGiven = TRUE; + break; + case B4SOI_MOD_WDROUT: + mod->B4SOIwdrout = value->rValue; + mod->B4SOIwdroutGiven = TRUE; + break; + case B4SOI_MOD_WPVAG: + mod->B4SOIwpvag = value->rValue; + mod->B4SOIwpvagGiven = TRUE; + break; + case B4SOI_MOD_WDELTA : + mod->B4SOIwdelta = value->rValue; + mod->B4SOIwdeltaGiven = TRUE; + break; + case B4SOI_MOD_WALPHA0 : + mod->B4SOIwalpha0 = value->rValue; + mod->B4SOIwalpha0Given = TRUE; + break; + case B4SOI_MOD_WFBJTII : + mod->B4SOIwfbjtii = value->rValue; + mod->B4SOIwfbjtiiGiven = TRUE; + break; + case B4SOI_MOD_WBETA0 : + mod->B4SOIwbeta0 = value->rValue; + mod->B4SOIwbeta0Given = TRUE; + break; + case B4SOI_MOD_WBETA1 : + mod->B4SOIwbeta1 = value->rValue; + mod->B4SOIwbeta1Given = TRUE; + break; + case B4SOI_MOD_WBETA2 : + mod->B4SOIwbeta2 = value->rValue; + mod->B4SOIwbeta2Given = TRUE; + break; + case B4SOI_MOD_WVDSATII0 : + mod->B4SOIwvdsatii0 = value->rValue; + mod->B4SOIwvdsatii0Given = TRUE; + break; + case B4SOI_MOD_WLII : + mod->B4SOIwlii = value->rValue; + mod->B4SOIwliiGiven = TRUE; + break; + case B4SOI_MOD_WESATII : + mod->B4SOIwesatii = value->rValue; + mod->B4SOIwesatiiGiven = TRUE; + break; + case B4SOI_MOD_WSII0 : + mod->B4SOIwsii0 = value->rValue; + mod->B4SOIwsii0Given = TRUE; + break; + case B4SOI_MOD_WSII1 : + mod->B4SOIwsii1 = value->rValue; + mod->B4SOIwsii1Given = TRUE; + break; + case B4SOI_MOD_WSII2 : + mod->B4SOIwsii2 = value->rValue; + mod->B4SOIwsii2Given = TRUE; + break; + case B4SOI_MOD_WSIID : + mod->B4SOIwsiid = value->rValue; + mod->B4SOIwsiidGiven = TRUE; + break; + case B4SOI_MOD_WAGIDL : + mod->B4SOIwagidl = value->rValue; + mod->B4SOIwagidlGiven = TRUE; + break; + case B4SOI_MOD_WBGIDL : + mod->B4SOIwbgidl = value->rValue; + mod->B4SOIwbgidlGiven = TRUE; + break; + case B4SOI_MOD_WCGIDL : + mod->B4SOIwcgidl = value->rValue; + mod->B4SOIwcgidlGiven = TRUE; + break; + case B4SOI_MOD_WEGIDL : + mod->B4SOIwegidl = value->rValue; + mod->B4SOIwegidlGiven = TRUE; + break; + case B4SOI_MOD_WNTUNS : /* v4.0 */ + mod->B4SOIwntun = value->rValue; + mod->B4SOIwntunGiven = TRUE; + break; + case B4SOI_MOD_WNTUND : /* v4.0 */ + mod->B4SOIwntund = value->rValue; + mod->B4SOIwntundGiven = TRUE; + break; + case B4SOI_MOD_WNDIODES : /* v4.0 */ + mod->B4SOIwndiode = value->rValue; + mod->B4SOIwndiodeGiven = TRUE; + break; + case B4SOI_MOD_WNDIODED : /* v4.0 */ + mod->B4SOIwndioded = value->rValue; + mod->B4SOIwndiodedGiven = TRUE; + break; + case B4SOI_MOD_WNRECF0S : /* v4.0 */ + mod->B4SOIwnrecf0 = value->rValue; + mod->B4SOIwnrecf0Given = TRUE; + break; + case B4SOI_MOD_WNRECF0D : /* v4.0 */ + mod->B4SOIwnrecf0d = value->rValue; + mod->B4SOIwnrecf0dGiven = TRUE; + break; + case B4SOI_MOD_WNRECR0S : /* v4.0 */ + mod->B4SOIwnrecr0 = value->rValue; + mod->B4SOIwnrecr0Given = TRUE; + break; + case B4SOI_MOD_WNRECR0D : /* v4.0 */ + mod->B4SOIwnrecr0d = value->rValue; + mod->B4SOIwnrecr0dGiven = TRUE; + break; + case B4SOI_MOD_WISBJT : + mod->B4SOIwisbjt = value->rValue; + mod->B4SOIwisbjtGiven = TRUE; + break; + case B4SOI_MOD_WIDBJT : /* v4.0 */ + mod->B4SOIwidbjt = value->rValue; + mod->B4SOIwidbjtGiven = TRUE; + break; + case B4SOI_MOD_WISDIF : + mod->B4SOIwisdif = value->rValue; + mod->B4SOIwisdifGiven = TRUE; + break; + case B4SOI_MOD_WIDDIF : /* v4.0 */ + mod->B4SOIwiddif = value->rValue; + mod->B4SOIwiddifGiven = TRUE; + break; + case B4SOI_MOD_WISREC : + mod->B4SOIwisrec = value->rValue; + mod->B4SOIwisrecGiven = TRUE; + break; + case B4SOI_MOD_WIDREC : /* v4.0 */ + mod->B4SOIwidrec = value->rValue; + mod->B4SOIwidrecGiven = TRUE; + break; + case B4SOI_MOD_WISTUN : + mod->B4SOIwistun = value->rValue; + mod->B4SOIwistunGiven = TRUE; + break; + case B4SOI_MOD_WIDTUN : /* v4.0 */ + mod->B4SOIwidtun = value->rValue; + mod->B4SOIwidtunGiven = TRUE; + break; + case B4SOI_MOD_WVREC0S : /* v4.0 */ + mod->B4SOIwvrec0 = value->rValue; + mod->B4SOIwvrec0Given = TRUE; + break; + case B4SOI_MOD_WVREC0D : /* v4.0 */ + mod->B4SOIwvrec0d = value->rValue; + mod->B4SOIwvrec0dGiven = TRUE; + break; + case B4SOI_MOD_WVTUN0S : /* v4.0 */ + mod->B4SOIwvtun0 = value->rValue; + mod->B4SOIwvtun0Given = TRUE; + break; + case B4SOI_MOD_WVTUN0D : /* v4.0 */ + mod->B4SOIwvtun0d = value->rValue; + mod->B4SOIwvtun0dGiven = TRUE; + break; + case B4SOI_MOD_WNBJT : + mod->B4SOIwnbjt = value->rValue; + mod->B4SOIwnbjtGiven = TRUE; + break; + case B4SOI_MOD_WLBJT0 : + mod->B4SOIwlbjt0 = value->rValue; + mod->B4SOIwlbjt0Given = TRUE; + break; + case B4SOI_MOD_WVABJT : + mod->B4SOIwvabjt = value->rValue; + mod->B4SOIwvabjtGiven = TRUE; + break; + case B4SOI_MOD_WAELY : + mod->B4SOIwaely = value->rValue; + mod->B4SOIwaelyGiven = TRUE; + break; + case B4SOI_MOD_WAHLIS : /* v4.0 */ + mod->B4SOIwahli = value->rValue; + mod->B4SOIwahliGiven = TRUE; + break; + case B4SOI_MOD_WAHLID : /* v4.0 */ + mod->B4SOIwahlid = value->rValue; + mod->B4SOIwahlidGiven = TRUE; + break; + +/* v3.1 for RF */ + case B4SOI_MOD_WXRCRG1 : + mod->B4SOIwxrcrg1 = value->rValue; + mod->B4SOIwxrcrg1Given = TRUE; + break; + case B4SOI_MOD_WXRCRG2 : + mod->B4SOIwxrcrg2 = value->rValue; + mod->B4SOIwxrcrg2Given = TRUE; + break; +/* v3.1 for RF end */ + + /* CV Model */ + case B4SOI_MOD_WVSDFB : + mod->B4SOIwvsdfb = value->rValue; + mod->B4SOIwvsdfbGiven = TRUE; + break; + case B4SOI_MOD_WVSDTH : + mod->B4SOIwvsdth = value->rValue; + mod->B4SOIwvsdthGiven = TRUE; + break; + case B4SOI_MOD_WDELVT : + mod->B4SOIwdelvt = value->rValue; + mod->B4SOIwdelvtGiven = TRUE; + break; + case B4SOI_MOD_WACDE : + mod->B4SOIwacde = value->rValue; + mod->B4SOIwacdeGiven = TRUE; + break; + case B4SOI_MOD_WMOIN : + mod->B4SOIwmoin = value->rValue; + mod->B4SOIwmoinGiven = TRUE; + break; + case B4SOI_MOD_WNOFF : + mod->B4SOIwnoff = value->rValue; + mod->B4SOIwnoffGiven = TRUE; + break; /* v3.2 */ + + /* Cross-term Dependence */ +/* v3.1 */ + case B4SOI_MOD_PXJ : + mod->B4SOIpxj = value->rValue; + mod->B4SOIpxjGiven = TRUE; + break; + case B4SOI_MOD_PALPHAGB1 : + mod->B4SOIpalphaGB1 = value->rValue; + mod->B4SOIpalphaGB1Given = TRUE; + break; + case B4SOI_MOD_PALPHAGB2 : + mod->B4SOIpalphaGB2 = value->rValue; + mod->B4SOIpalphaGB2Given = TRUE; + break; + case B4SOI_MOD_PBETAGB1 : + mod->B4SOIpbetaGB1 = value->rValue; + mod->B4SOIpbetaGB1Given = TRUE; + break; + case B4SOI_MOD_PBETAGB2 : + mod->B4SOIpbetaGB2 = value->rValue; + mod->B4SOIpbetaGB2Given = TRUE; + break; + case B4SOI_MOD_PNDIF : + mod->B4SOIpndif = value->rValue; + mod->B4SOIpndifGiven = TRUE; + break; + case B4SOI_MOD_PNTRECF : + mod->B4SOIpntrecf = value->rValue; + mod->B4SOIpntrecfGiven = TRUE; + break; + case B4SOI_MOD_PNTRECR : + mod->B4SOIpntrecr = value->rValue; + mod->B4SOIpntrecrGiven = TRUE; + break; + case B4SOI_MOD_PXBJT : + mod->B4SOIpxbjt = value->rValue; + mod->B4SOIpxbjtGiven = TRUE; + break; + case B4SOI_MOD_PXDIFS : + mod->B4SOIpxdif = value->rValue; + mod->B4SOIpxdifGiven = TRUE; + break; + case B4SOI_MOD_PXRECS : + mod->B4SOIpxrec = value->rValue; + mod->B4SOIpxrecGiven = TRUE; + break; + case B4SOI_MOD_PXTUNS : + mod->B4SOIpxtun = value->rValue; + mod->B4SOIpxtunGiven = TRUE; + break; + case B4SOI_MOD_PXDIFD : + mod->B4SOIpxdifd = value->rValue; + mod->B4SOIpxdifdGiven = TRUE; + break; + case B4SOI_MOD_PXRECD : + mod->B4SOIpxrecd = value->rValue; + mod->B4SOIpxrecdGiven = TRUE; + break; + case B4SOI_MOD_PXTUND : + mod->B4SOIpxtund = value->rValue; + mod->B4SOIpxtundGiven = TRUE; + break; + case B4SOI_MOD_PCGDL : + mod->B4SOIpcgdl = value->rValue; + mod->B4SOIpcgdlGiven = TRUE; + break; + case B4SOI_MOD_PCGSL : + mod->B4SOIpcgsl = value->rValue; + mod->B4SOIpcgslGiven = TRUE; + break; + case B4SOI_MOD_PCKAPPA : + mod->B4SOIpckappa = value->rValue; + mod->B4SOIpckappaGiven = TRUE; + break; + case B4SOI_MOD_PUTE : + mod->B4SOIpute = value->rValue; + mod->B4SOIputeGiven = TRUE; + break; + case B4SOI_MOD_PKT1 : + mod->B4SOIpkt1 = value->rValue; + mod->B4SOIpkt1Given = TRUE; + break; + case B4SOI_MOD_PKT2 : + mod->B4SOIpkt2 = value->rValue; + mod->B4SOIpkt2Given = TRUE; + break; + case B4SOI_MOD_PKT1L : + mod->B4SOIpkt1l = value->rValue; + mod->B4SOIpkt1lGiven = TRUE; + break; + case B4SOI_MOD_PUA1 : + mod->B4SOIpua1 = value->rValue; + mod->B4SOIpua1Given = TRUE; + break; + case B4SOI_MOD_PUB1 : + mod->B4SOIpub1 = value->rValue; + mod->B4SOIpub1Given = TRUE; + break; + case B4SOI_MOD_PUC1 : + mod->B4SOIpuc1 = value->rValue; + mod->B4SOIpuc1Given = TRUE; + break; + case B4SOI_MOD_PAT : + mod->B4SOIpat = value->rValue; + mod->B4SOIpatGiven = TRUE; + break; + case B4SOI_MOD_PPRT : + mod->B4SOIpprt = value->rValue; + mod->B4SOIpprtGiven = TRUE; + break; + +/* v3.0 */ + case B4SOI_MOD_PAIGC : + mod->B4SOIpaigc = value->rValue; + mod->B4SOIpaigcGiven = TRUE; + break; + case B4SOI_MOD_PBIGC : + mod->B4SOIpbigc = value->rValue; + mod->B4SOIpbigcGiven = TRUE; + break; + case B4SOI_MOD_PCIGC : + mod->B4SOIpcigc = value->rValue; + mod->B4SOIpcigcGiven = TRUE; + break; + case B4SOI_MOD_PAIGSD : + mod->B4SOIpaigsd = value->rValue; + mod->B4SOIpaigsdGiven = TRUE; + break; + case B4SOI_MOD_PBIGSD : + mod->B4SOIpbigsd = value->rValue; + mod->B4SOIpbigsdGiven = TRUE; + break; + case B4SOI_MOD_PCIGSD : + mod->B4SOIpcigsd = value->rValue; + mod->B4SOIpcigsdGiven = TRUE; + break; + case B4SOI_MOD_PNIGC : + mod->B4SOIpnigc = value->rValue; + mod->B4SOIpnigcGiven = TRUE; + break; + case B4SOI_MOD_PPIGCD : + mod->B4SOIppigcd = value->rValue; + mod->B4SOIppigcdGiven = TRUE; + break; + case B4SOI_MOD_PPOXEDGE : + mod->B4SOIppoxedge = value->rValue; + mod->B4SOIppoxedgeGiven = TRUE; + break; + + case B4SOI_MOD_PNPEAK: + mod->B4SOIpnpeak = value->rValue; + mod->B4SOIpnpeakGiven = TRUE; + break; + case B4SOI_MOD_PNSUB: + mod->B4SOIpnsub = value->rValue; + mod->B4SOIpnsubGiven = TRUE; + break; + case B4SOI_MOD_PNGATE: + mod->B4SOIpngate = value->rValue; + mod->B4SOIpngateGiven = TRUE; + break; + case B4SOI_MOD_PVTH0: + mod->B4SOIpvth0 = value->rValue; + mod->B4SOIpvth0Given = TRUE; + break; + case B4SOI_MOD_PK1: + mod->B4SOIpk1 = value->rValue; + mod->B4SOIpk1Given = TRUE; + break; + case B4SOI_MOD_PK1W1: + mod->B4SOIpk1w1 = value->rValue; + mod->B4SOIpk1w1Given = TRUE; + break; + case B4SOI_MOD_PK1W2: + mod->B4SOIpk1w2 = value->rValue; + mod->B4SOIpk1w2Given = TRUE; + break; + case B4SOI_MOD_PK2: + mod->B4SOIpk2 = value->rValue; + mod->B4SOIpk2Given = TRUE; + break; + case B4SOI_MOD_PK3: + mod->B4SOIpk3 = value->rValue; + mod->B4SOIpk3Given = TRUE; + break; + case B4SOI_MOD_PK3B: + mod->B4SOIpk3b = value->rValue; + mod->B4SOIpk3bGiven = TRUE; + break; + case B4SOI_MOD_PKB1 : + mod->B4SOIpkb1 = value->rValue; + mod->B4SOIpkb1Given = TRUE; + break; + case B4SOI_MOD_PW0: + mod->B4SOIpw0 = value->rValue; + mod->B4SOIpw0Given = TRUE; + break; + case B4SOI_MOD_PLPE0: + mod->B4SOIplpe0 = value->rValue; + mod->B4SOIplpe0Given = TRUE; + break; + case B4SOI_MOD_PLPEB: /* v4.0 for Vth */ + mod->B4SOIplpeb = value->rValue; + mod->B4SOIplpebGiven = TRUE; + break; + case B4SOI_MOD_PDVT0: + mod->B4SOIpdvt0 = value->rValue; + mod->B4SOIpdvt0Given = TRUE; + break; + case B4SOI_MOD_PDVT1: + mod->B4SOIpdvt1 = value->rValue; + mod->B4SOIpdvt1Given = TRUE; + break; + case B4SOI_MOD_PDVT2: + mod->B4SOIpdvt2 = value->rValue; + mod->B4SOIpdvt2Given = TRUE; + break; + case B4SOI_MOD_PDVT0W: + mod->B4SOIpdvt0w = value->rValue; + mod->B4SOIpdvt0wGiven = TRUE; + break; + case B4SOI_MOD_PDVT1W: + mod->B4SOIpdvt1w = value->rValue; + mod->B4SOIpdvt1wGiven = TRUE; + break; + case B4SOI_MOD_PDVT2W: + mod->B4SOIpdvt2w = value->rValue; + mod->B4SOIpdvt2wGiven = TRUE; + break; + case B4SOI_MOD_PU0 : + mod->B4SOIpu0 = value->rValue; + mod->B4SOIpu0Given = TRUE; + break; + case B4SOI_MOD_PUA: + mod->B4SOIpua = value->rValue; + mod->B4SOIpuaGiven = TRUE; + break; + case B4SOI_MOD_PUB: + mod->B4SOIpub = value->rValue; + mod->B4SOIpubGiven = TRUE; + break; + case B4SOI_MOD_PUC: + mod->B4SOIpuc = value->rValue; + mod->B4SOIpucGiven = TRUE; + break; + case B4SOI_MOD_PVSAT: + mod->B4SOIpvsat = value->rValue; + mod->B4SOIpvsatGiven = TRUE; + break; + case B4SOI_MOD_PA0: + mod->B4SOIpa0 = value->rValue; + mod->B4SOIpa0Given = TRUE; + break; + case B4SOI_MOD_PAGS: + mod->B4SOIpags= value->rValue; + mod->B4SOIpagsGiven = TRUE; + break; + case B4SOI_MOD_PB0 : + mod->B4SOIpb0 = value->rValue; + mod->B4SOIpb0Given = TRUE; + break; + case B4SOI_MOD_PB1 : + mod->B4SOIpb1 = value->rValue; + mod->B4SOIpb1Given = TRUE; + break; + case B4SOI_MOD_PKETA: + mod->B4SOIpketa = value->rValue; + mod->B4SOIpketaGiven = TRUE; + break; + case B4SOI_MOD_PKETAS: + mod->B4SOIpketas = value->rValue; + mod->B4SOIpketasGiven = TRUE; + break; + case B4SOI_MOD_PA1: + mod->B4SOIpa1 = value->rValue; + mod->B4SOIpa1Given = TRUE; + break; + case B4SOI_MOD_PA2: + mod->B4SOIpa2 = value->rValue; + mod->B4SOIpa2Given = TRUE; + break; + case B4SOI_MOD_PRDSW: + mod->B4SOIprdsw = value->rValue; + mod->B4SOIprdswGiven = TRUE; + break; + case B4SOI_MOD_PRSW: + mod->B4SOIprsw = value->rValue; + mod->B4SOIprswGiven = TRUE; + break; + case B4SOI_MOD_PRDW: + mod->B4SOIprdw = value->rValue; + mod->B4SOIprdwGiven = TRUE; + break; + case B4SOI_MOD_PPRWB: + mod->B4SOIpprwb = value->rValue; + mod->B4SOIpprwbGiven = TRUE; + break; + case B4SOI_MOD_PPRWG: + mod->B4SOIpprwg = value->rValue; + mod->B4SOIpprwgGiven = TRUE; + break; + case B4SOI_MOD_PWR : + mod->B4SOIpwr = value->rValue; + mod->B4SOIpwrGiven = TRUE; + break; + case B4SOI_MOD_PNFACTOR : + mod->B4SOIpnfactor = value->rValue; + mod->B4SOIpnfactorGiven = TRUE; + break; + case B4SOI_MOD_PDWG : + mod->B4SOIpdwg = value->rValue; + mod->B4SOIpdwgGiven = TRUE; + break; + case B4SOI_MOD_PDWB : + mod->B4SOIpdwb = value->rValue; + mod->B4SOIpdwbGiven = TRUE; + break; + case B4SOI_MOD_PVOFF: + mod->B4SOIpvoff = value->rValue; + mod->B4SOIpvoffGiven = TRUE; + break; + case B4SOI_MOD_PETA0: + mod->B4SOIpeta0 = value->rValue; + mod->B4SOIpeta0Given = TRUE; + break; + case B4SOI_MOD_PETAB: + mod->B4SOIpetab = value->rValue; + mod->B4SOIpetabGiven = TRUE; + break; + case B4SOI_MOD_PDSUB: + mod->B4SOIpdsub = value->rValue; + mod->B4SOIpdsubGiven = TRUE; + break; + case B4SOI_MOD_PCIT : + mod->B4SOIpcit = value->rValue; + mod->B4SOIpcitGiven = TRUE; + break; + case B4SOI_MOD_PCDSC : + mod->B4SOIpcdsc = value->rValue; + mod->B4SOIpcdscGiven = TRUE; + break; + case B4SOI_MOD_PCDSCB : + mod->B4SOIpcdscb = value->rValue; + mod->B4SOIpcdscbGiven = TRUE; + break; + case B4SOI_MOD_PCDSCD : + mod->B4SOIpcdscd = value->rValue; + mod->B4SOIpcdscdGiven = TRUE; + break; + case B4SOI_MOD_PPCLM: + mod->B4SOIppclm = value->rValue; + mod->B4SOIppclmGiven = TRUE; + break; + case B4SOI_MOD_PPDIBL1: + mod->B4SOIppdibl1 = value->rValue; + mod->B4SOIppdibl1Given = TRUE; + break; + case B4SOI_MOD_PPDIBL2: + mod->B4SOIppdibl2 = value->rValue; + mod->B4SOIppdibl2Given = TRUE; + break; + case B4SOI_MOD_PPDIBLB: + mod->B4SOIppdiblb = value->rValue; + mod->B4SOIppdiblbGiven = TRUE; + break; + case B4SOI_MOD_PDROUT: + mod->B4SOIpdrout = value->rValue; + mod->B4SOIpdroutGiven = TRUE; + break; + case B4SOI_MOD_PPVAG: + mod->B4SOIppvag = value->rValue; + mod->B4SOIppvagGiven = TRUE; + break; + case B4SOI_MOD_PDELTA : + mod->B4SOIpdelta = value->rValue; + mod->B4SOIpdeltaGiven = TRUE; + break; + case B4SOI_MOD_PALPHA0 : + mod->B4SOIpalpha0 = value->rValue; + mod->B4SOIpalpha0Given = TRUE; + break; + case B4SOI_MOD_PFBJTII : + mod->B4SOIpfbjtii = value->rValue; + mod->B4SOIpfbjtiiGiven = TRUE; + break; + case B4SOI_MOD_PBETA0 : + mod->B4SOIpbeta0 = value->rValue; + mod->B4SOIpbeta0Given = TRUE; + break; + case B4SOI_MOD_PBETA1 : + mod->B4SOIpbeta1 = value->rValue; + mod->B4SOIpbeta1Given = TRUE; + break; + case B4SOI_MOD_PBETA2 : + mod->B4SOIpbeta2 = value->rValue; + mod->B4SOIpbeta2Given = TRUE; + break; + case B4SOI_MOD_PVDSATII0 : + mod->B4SOIpvdsatii0 = value->rValue; + mod->B4SOIpvdsatii0Given = TRUE; + break; + case B4SOI_MOD_PLII : + mod->B4SOIplii = value->rValue; + mod->B4SOIpliiGiven = TRUE; + break; + case B4SOI_MOD_PESATII : + mod->B4SOIpesatii = value->rValue; + mod->B4SOIpesatiiGiven = TRUE; + break; + case B4SOI_MOD_PSII0 : + mod->B4SOIpsii0 = value->rValue; + mod->B4SOIpsii0Given = TRUE; + break; + case B4SOI_MOD_PSII1 : + mod->B4SOIpsii1 = value->rValue; + mod->B4SOIpsii1Given = TRUE; + break; + case B4SOI_MOD_PSII2 : + mod->B4SOIpsii2 = value->rValue; + mod->B4SOIpsii2Given = TRUE; + break; + case B4SOI_MOD_PSIID : + mod->B4SOIpsiid = value->rValue; + mod->B4SOIpsiidGiven = TRUE; + break; + case B4SOI_MOD_PAGIDL : + mod->B4SOIpagidl = value->rValue; + mod->B4SOIpagidlGiven = TRUE; + break; + case B4SOI_MOD_PBGIDL : + mod->B4SOIpbgidl = value->rValue; + mod->B4SOIpbgidlGiven = TRUE; + break; + case B4SOI_MOD_PCGIDL : + mod->B4SOIpcgidl = value->rValue; + mod->B4SOIpcgidlGiven = TRUE; + break; + case B4SOI_MOD_PEGIDL : + mod->B4SOIpegidl = value->rValue; + mod->B4SOIpegidlGiven = TRUE; + break; + case B4SOI_MOD_PNTUNS : /* v4.0 */ + mod->B4SOIpntun = value->rValue; + mod->B4SOIpntunGiven = TRUE; + break; + case B4SOI_MOD_PNTUND : /* v4.0 */ + mod->B4SOIpntund = value->rValue; + mod->B4SOIpntundGiven = TRUE; + break; + case B4SOI_MOD_PNDIODES : /* v4.0 */ + mod->B4SOIpndiode = value->rValue; + mod->B4SOIpndiodeGiven = TRUE; + break; + case B4SOI_MOD_PNDIODED : /* v4.0 */ + mod->B4SOIpndioded = value->rValue; + mod->B4SOIpndiodedGiven = TRUE; + break; + case B4SOI_MOD_PNRECF0S : /* v4.0 */ + mod->B4SOIpnrecf0 = value->rValue; + mod->B4SOIpnrecf0Given = TRUE; + break; + case B4SOI_MOD_PNRECF0D : /* v4.0 */ + mod->B4SOIpnrecf0d = value->rValue; + mod->B4SOIpnrecf0dGiven = TRUE; + break; + case B4SOI_MOD_PNRECR0S : /* v4.0 */ + mod->B4SOIpnrecr0 = value->rValue; + mod->B4SOIpnrecr0Given = TRUE; + break; + case B4SOI_MOD_PNRECR0D : /* v4.0 */ + mod->B4SOIpnrecr0d = value->rValue; + mod->B4SOIpnrecr0dGiven = TRUE; + break; + case B4SOI_MOD_PISBJT : + mod->B4SOIpisbjt = value->rValue; + mod->B4SOIpisbjtGiven = TRUE; + break; + case B4SOI_MOD_PIDBJT : /* v4.0 */ + mod->B4SOIpidbjt = value->rValue; + mod->B4SOIpidbjtGiven = TRUE; + break; + case B4SOI_MOD_PISDIF : + mod->B4SOIpisdif = value->rValue; + mod->B4SOIpisdifGiven = TRUE; + break; + case B4SOI_MOD_PIDDIF : /* v4.0 */ + mod->B4SOIpiddif = value->rValue; + mod->B4SOIpiddifGiven = TRUE; + break; + case B4SOI_MOD_PISREC : + mod->B4SOIpisrec = value->rValue; + mod->B4SOIpisrecGiven = TRUE; + break; + case B4SOI_MOD_PIDREC : /* v4.0 */ + mod->B4SOIpidrec = value->rValue; + mod->B4SOIpidrecGiven = TRUE; + break; + case B4SOI_MOD_PISTUN : + mod->B4SOIpistun = value->rValue; + mod->B4SOIpistunGiven = TRUE; + break; + case B4SOI_MOD_PIDTUN : /* v4.0 */ + mod->B4SOIpidtun = value->rValue; + mod->B4SOIpidtunGiven = TRUE; + break; + case B4SOI_MOD_PVREC0S : /* v4.0 */ + mod->B4SOIpvrec0 = value->rValue; + mod->B4SOIpvrec0Given = TRUE; + break; + case B4SOI_MOD_PVREC0D : /* v4.0 */ + mod->B4SOIpvrec0d = value->rValue; + mod->B4SOIpvrec0dGiven = TRUE; + break; + case B4SOI_MOD_PVTUN0S : /* v4.0 */ + mod->B4SOIpvtun0 = value->rValue; + mod->B4SOIpvtun0Given = TRUE; + break; + case B4SOI_MOD_PVTUN0D : /* v4.0 */ + mod->B4SOIpvtun0d = value->rValue; + mod->B4SOIpvtun0dGiven = TRUE; + break; + case B4SOI_MOD_PNBJT : + mod->B4SOIpnbjt = value->rValue; + mod->B4SOIpnbjtGiven = TRUE; + break; + case B4SOI_MOD_PLBJT0 : + mod->B4SOIplbjt0 = value->rValue; + mod->B4SOIplbjt0Given = TRUE; + break; + case B4SOI_MOD_PVABJT : + mod->B4SOIpvabjt = value->rValue; + mod->B4SOIpvabjtGiven = TRUE; + break; + case B4SOI_MOD_PAELY : + mod->B4SOIpaely = value->rValue; + mod->B4SOIpaelyGiven = TRUE; + break; + case B4SOI_MOD_PAHLIS : /* v4.0 */ + mod->B4SOIpahli = value->rValue; + mod->B4SOIpahliGiven = TRUE; + break; + case B4SOI_MOD_PAHLID : /* v4.0 */ + mod->B4SOIpahlid = value->rValue; + mod->B4SOIpahlidGiven = TRUE; + break; + +/* v3.1 for RF */ + case B4SOI_MOD_PXRCRG1 : + mod->B4SOIpxrcrg1 = value->rValue; + mod->B4SOIpxrcrg1Given = TRUE; + break; + case B4SOI_MOD_PXRCRG2 : + mod->B4SOIpxrcrg2 = value->rValue; + mod->B4SOIpxrcrg2Given = TRUE; + break; +/* v3.1 for RF end */ + + /* CV Model */ + case B4SOI_MOD_PVSDFB : + mod->B4SOIpvsdfb = value->rValue; + mod->B4SOIpvsdfbGiven = TRUE; + break; + case B4SOI_MOD_PVSDTH : + mod->B4SOIpvsdth = value->rValue; + mod->B4SOIpvsdthGiven = TRUE; + break; + case B4SOI_MOD_PDELVT : + mod->B4SOIpdelvt = value->rValue; + mod->B4SOIpdelvtGiven = TRUE; + break; + case B4SOI_MOD_PACDE : + mod->B4SOIpacde = value->rValue; + mod->B4SOIpacdeGiven = TRUE; + break; + case B4SOI_MOD_PMOIN : + mod->B4SOIpmoin = value->rValue; + mod->B4SOIpmoinGiven = TRUE; + break; + case B4SOI_MOD_PNOFF : + mod->B4SOIpnoff = value->rValue; + mod->B4SOIpnoffGiven = TRUE; + break; /* v3.2 */ +/* Added for binning - END */ + + /* 4.0 backward compatibility */ + case B4SOI_MOD_NLX: + mod->B4SOInlx = value->rValue; + mod->B4SOInlxGiven = TRUE; + break; + case B4SOI_MOD_LNLX: + mod->B4SOIlnlx = value->rValue; + mod->B4SOIlnlxGiven = TRUE; + break; + case B4SOI_MOD_WNLX: + mod->B4SOIwnlx = value->rValue; + mod->B4SOIwnlxGiven = TRUE; + break; + case B4SOI_MOD_PNLX: + mod->B4SOIpnlx = value->rValue; + mod->B4SOIpnlxGiven = TRUE; + break; + case B4SOI_MOD_NGIDL: + mod->B4SOIngidl = value->rValue; + mod->B4SOIngidlGiven = TRUE; + break; + case B4SOI_MOD_LNGIDL: + mod->B4SOIlngidl = value->rValue; + mod->B4SOIlngidlGiven = TRUE; + break; + case B4SOI_MOD_WNGIDL: + mod->B4SOIwngidl = value->rValue; + mod->B4SOIwngidlGiven = TRUE; + break; + case B4SOI_MOD_PNGIDL: + mod->B4SOIpngidl = value->rValue; + mod->B4SOIpngidlGiven = TRUE; + break; + case B4SOI_MOD_NMOS : + if(value->iValue) { + mod->B4SOItype = 1; + mod->B4SOItypeGiven = TRUE; + } + break; + case B4SOI_MOD_PMOS : + if(value->iValue) { + mod->B4SOItype = - 1; + mod->B4SOItypeGiven = TRUE; + } + break; + default: + return(E_BADPARM); + } + return(OK); +} + + diff --git a/src/spicelib/devices/bsim3soi/b4soinoi.c b/src/spicelib/devices/bsim3soi/b4soinoi.c new file mode 100644 index 000000000..77f7b39a7 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soinoi.c @@ -0,0 +1,579 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soinoi.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soinoi.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "b4soidef.h" +#include "cktdefs.h" +#include "iferrmsg.h" +#include "noisedef.h" +#include "suffix.h" +#include "const.h" /* jwan */ + +/* + * B4SOInoise (mode, operation, firstModel, ckt, data, OnDens) + * This routine names and evaluates all of the noise sources + * associated with MOSFET's. It starts with the model *firstModel and + * traverses all of its insts. It then proceeds to any other models + * on the linked list. The total output noise density generated by + * all of the MOSFET's is summed with the variable "OnDens". + */ + +/* + Channel thermal and flicker noises are calculated based on the value + of model->B4SOItnoiMod and model->B4SOIfnoiMod + If model->B4SOItnoiMod = 0, + Channel thermal noise = Charge based model + If model->B4SOItnoiMod = 1, + Channel thermal noise = Holistic noise model + If model->B4SOItnoiMod = 2, + Channel thermal noise = SPICE2 model + If model->B4SOIfnoiMod = 0, + Flicker noise = Simple model + If model->B4SOIfnoiMod = 1, + Flicker noise = Unified model +*/ + +extern void NevalSrc(); +extern double Nintegrate(); + +double +B4SOIEval1ovFNoise(double vds, B4SOImodel *model, B4SOIinstance *here, double freq, double temp) +{ +struct b4soiSizeDependParam *pParam; +double cd, esat, DelClm, EffFreq, N0, Nl; +double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ssi; + + pParam = here->pParam; + cd = fabs(here->B4SOIcd); + esat = 2.0 * pParam->B4SOIvsattemp / here->B4SOIueff; +/* v2.2.3 bug fix */ + if(model->B4SOIem<=0.0) DelClm = 0.0; + else { + T0 = ((((vds - here->B4SOIVdseff) / pParam->B4SOIlitl) + + model->B4SOIem) / esat); + DelClm = pParam->B4SOIlitl * log (MAX(T0, N_MINLOG)); + } + + EffFreq = pow(freq, model->B4SOIef); + T1 = CHARGE * CHARGE * CONSTboltz * cd * temp * here->B4SOIueff; + T2 = 1.0e10 * EffFreq * here->B4SOIAbulk * model->B4SOIcox + * pParam->B4SOIleff * pParam->B4SOIleff; + +/* v2.2.3 bug fix */ + N0 = model->B4SOIcox * here->B4SOIVgsteff / CHARGE; + Nl = model->B4SOIcox * here->B4SOIVgsteff + * (1.0 - here->B4SOIAbovVgst2Vtm * here->B4SOIVdseff) / CHARGE; + + + T3 = model->B4SOIoxideTrapDensityA + * log(MAX(((N0 + here->B4SOInstar) / (Nl + here->B4SOInstar)), N_MINLOG)); + T4 = model->B4SOIoxideTrapDensityB * (N0 - Nl); + T5 = model->B4SOIoxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl); + + T6 = CONSTboltz * temp * cd * cd; + T7 = 1.0e10 * EffFreq * pParam->B4SOIleff + * pParam->B4SOIleff * pParam->B4SOIweff * here->B4SOInf; + T8 = model->B4SOIoxideTrapDensityA + model->B4SOIoxideTrapDensityB * Nl + + model->B4SOIoxideTrapDensityC * Nl * Nl; + T9 = (Nl + here->B4SOInstar) * (Nl + here->B4SOInstar); + + Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9; + + return Ssi; +} + +int +B4SOInoise (int mode, int operation, GENmodel *inModel, CKTcircuit *ckt, + Ndata *data, double *OnDens) +{ +register B4SOImodel *model = (B4SOImodel *)inModel; +register B4SOIinstance *here; +struct b4soiSizeDependParam *pParam; +char name[N_MXVLNTH]; +double tempOnoise; +double tempInoise; +double noizDens[B4SOINSRCS]; +double lnNdens[B4SOINSRCS]; + +double vgs, vds; +double T0, T1, T2, T5, T10, T11; +double Ssi, Swi; + +/* v3.2 */ +double npart_theta, npart_beta, igsquare, esat; +/* v3.2 end */ +double gspr, gdpr; + +int i; + + /* define the names of the noise sources */ + static char *B4SOInNames[B4SOINSRCS] = + { /* Note that we have to keep the order */ + ".rd", /* noise due to rd */ + /* consistent with the index definitions */ + ".rs", /* noise due to rs */ + /* in B4SOIdefs.h */ + ".rg", /* noise due to rgeltd, v3.2 */ + ".id", /* noise due to id */ + ".1overf", /* flicker (1/f) noise */ + ".fb_ibs", /* noise due to floating body by ibs */ + ".fb_ibd", /* noise due to floating body by ibd */ + ".igs", /* shot noise due to IGS, v3.2 */ + ".igd", /* shot noise due to IGD, v3.2 */ + ".igb", /* shot noise due to IGB, v3.2 */ + ".rbsb", /* noise due to rbsb v4.0 */ + ".rbdb", /* noise due to rbdb v4.0 */ + ".rbody", /* noise due to body contact v4.0 */ + + "" /* total transistor noise */ + }; + + for (; model != NULL; model = model->B4SOInextModel) + { for (here = model->B4SOIinstances; here != NULL; + here = here->B4SOInextInstance) + { + if (here->B4SOIowner != ARCHme) + continue; + + pParam = here->pParam; + switch (operation) + { case N_OPEN: + /* see if we have to to produce a summary report */ + /* if so, name all the noise generators */ + + if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0) + { switch (mode) + { case N_DENS: + for (i = 0; i < B4SOINSRCS; i++) + { (void) sprintf(name, "onoise.%s%s", + here->B4SOIname, + B4SOInNames[i]); + data->namelist = (IFuid *) trealloc( + (char *) data->namelist, + (data->numPlots + 1) + * sizeof(IFuid)); + if (!data->namelist) + return(E_NOMEM); + (*(SPfrontEnd->IFnewUid)) (ckt, + &(data->namelist[data->numPlots++]), + (IFuid) NULL, name, UID_OTHER, + (void **) NULL); + /* we've added one more plot */ + } + break; + case INT_NOIZ: + for (i = 0; i < B4SOINSRCS; i++) + { (void) sprintf(name, "onoise_total.%s%s", + here->B4SOIname, + B4SOInNames[i]); + data->namelist = (IFuid *) trealloc( + (char *) data->namelist, + (data->numPlots + 1) + * sizeof(IFuid)); + if (!data->namelist) + return(E_NOMEM); + (*(SPfrontEnd->IFnewUid)) (ckt, + &(data->namelist[data->numPlots++]), + (IFuid) NULL, name, UID_OTHER, + (void **) NULL); + /* we've added one more plot */ + + (void) sprintf(name, "inoise_total.%s%s", + here->B4SOIname, + B4SOInNames[i]); + data->namelist = (IFuid *) trealloc( + (char *) data->namelist, + (data->numPlots + 1) + * sizeof(IFuid)); + if (!data->namelist) + return(E_NOMEM); + (*(SPfrontEnd->IFnewUid)) (ckt, + &(data->namelist[data->numPlots++]), + (IFuid) NULL, name, UID_OTHER, + (void **)NULL); + /* we've added one more plot */ + } + break; + } + } + break; + case N_CALC: + switch (mode) + { case N_DENS: + if (model->B4SOItnoiMod == 0) /* v4.0 */ + { if (model->B4SOIrdsMod == 0) + { gspr = here->B4SOIsourceConductance; + gdpr = here->B4SOIdrainConductance; + } + else + { gspr = here->B4SOIgstot; + gdpr = here->B4SOIgdtot; + } + } + else + { T5 = here->B4SOIVgsteff / esat + / pParam->B4SOIleff; + T5 *= T5; + npart_beta = model->B4SOIrnoia * (1.0 + + T5 * model->B4SOItnoia * + pParam->B4SOIleff); + npart_theta = model->B4SOIrnoib * (1.0 + + T5 * model->B4SOItnoib * + pParam->B4SOIleff); + + if (model->B4SOIrdsMod == 0) + { gspr = here->B4SOIsourceConductance; + gdpr = here->B4SOIdrainConductance; + } + else + { gspr = here->B4SOIgstot; + gdpr = here->B4SOIgdtot; + } + if ( (*(ckt->CKTstates[0] + here->B4SOIvds)) + >= 0.0 ) + gspr = gspr / (1.0 + npart_theta + * npart_theta * gspr + / here->B4SOIidovVds); + else + gdpr = gdpr / (1.0 + npart_theta + * npart_theta * gdpr + / here->B4SOIidovVds); + } + + NevalSrc(&noizDens[B4SOIRDNOIZ], + &lnNdens[B4SOIRDNOIZ], ckt, THERMNOISE, + here->B4SOIdNodePrime, here->B4SOIdNode, + gdpr * here->B4SOIm); + + NevalSrc(&noizDens[B4SOIRSNOIZ], + &lnNdens[B4SOIRSNOIZ], ckt, THERMNOISE, + here->B4SOIsNodePrime, here->B4SOIsNode, + gspr * here->B4SOIm); + + if ((here->B4SOIrgateMod == 1) || + (here->B4SOIrgateMod == 2)) + { NevalSrc(&noizDens[B4SOIRGNOIZ], + &lnNdens[B4SOIRGNOIZ], ckt, THERMNOISE, + here->B4SOIgNode, + here->B4SOIgNodeExt, + here->B4SOIgrgeltd); + } + else if (here->B4SOIrgateMod == 3) + { NevalSrc(&noizDens[B4SOIRGNOIZ], + &lnNdens[B4SOIRGNOIZ], ckt, THERMNOISE, + here->B4SOIgNodeMid, + here->B4SOIgNodeExt, + here->B4SOIgrgeltd); + } + else + { noizDens[B4SOIRGNOIZ] = 0.0; + lnNdens[B4SOIRGNOIZ] = + log(MAX(noizDens[B4SOIRGNOIZ], + N_MINLOG)); + } + + if (here->B4SOIrbodyMod) + { + NevalSrc(&noizDens[B4SOIRBSBNOIZ], + &lnNdens[B4SOIRBSBNOIZ], ckt, THERMNOISE, + here->B4SOIbNode, here->B4SOIsbNode, + here->B4SOIgrbsb); + NevalSrc(&noizDens[B4SOIRBDBNOIZ], + &lnNdens[B4SOIRBDBNOIZ], ckt, THERMNOISE, + here->B4SOIbNode, here->B4SOIdbNode, + here->B4SOIgrbdb); + } + else + { noizDens[B4SOIRBSBNOIZ] = 0.0; + noizDens[B4SOIRBDBNOIZ] = 0.0; + lnNdens[B4SOIRBSBNOIZ] = + log(MAX(noizDens[B4SOIRBSBNOIZ], N_MINLOG)); + lnNdens[B4SOIRBDBNOIZ] = + log(MAX(noizDens[B4SOIRBDBNOIZ], N_MINLOG)); + } + + if (here->B4SOIbodyMod == 1) + { + NevalSrc(&noizDens[B4SOIRBODYNOIZ], + &lnNdens[B4SOIRBODYNOIZ], ckt, THERMNOISE, + here->B4SOIbNode, here->B4SOIpNode, + 1/ here->B4SOIrbodyext + + 1/ pParam->B4SOIrbody); + } + else + { noizDens[B4SOIRBODYNOIZ] = 0.0; + lnNdens[B4SOIRBODYNOIZ] = + log(MAX(noizDens[B4SOIRBODYNOIZ], N_MINLOG)); + } + + switch( model->B4SOItnoiMod ) + { + case 0: + NevalSrc(&noizDens[B4SOIIDNOIZ], + &lnNdens[B4SOIIDNOIZ], ckt, + THERMNOISE, + here->B4SOIdNodePrime, + here->B4SOIsNodePrime, + (here->B4SOIueff + * fabs(here->B4SOIqinv + / (pParam->B4SOIleff + * pParam->B4SOIleff + + here->B4SOIueff*fabs + (here->B4SOIqinv) + * here->B4SOIrds))) + * model->B4SOIntnoi ); + break; + +/* v2.2.3 bug fix */ + case 1: + T0 = here->B4SOIgm + here->B4SOIgmbs + + here->B4SOIgds; + T0 *= T0; + esat = 2.0 * pParam->B4SOIvsattemp / + here->B4SOIueff; + T5 = here->B4SOIVgsteff / esat / + pParam->B4SOIleff; + T5 *= T5; + npart_beta = model->B4SOIrnoia * (1.0 + + T5 * model->B4SOItnoia * + pParam->B4SOIleff); + npart_theta = model->B4SOIrnoib * (1.0 + + T5 * model->B4SOItnoib * + pParam->B4SOIleff); + igsquare = npart_theta * npart_theta * + T0 * here->B4SOIVdseff / + here->B4SOIcd; + T1 = npart_beta * (here->B4SOIgm + + here->B4SOIgmbs) + here->B4SOIgds; + T2 = T1 * T1 * here->B4SOIVdseff / + here->B4SOIcd; + + NevalSrc(&noizDens[B4SOIIDNOIZ], + &lnNdens[B4SOIIDNOIZ], ckt, + THERMNOISE, + here->B4SOIdNodePrime, + here->B4SOIsNodePrime, + (T2 - igsquare)); + break; + + case 2: + NevalSrc(&noizDens[B4SOIIDNOIZ], + &lnNdens[B4SOIIDNOIZ], ckt, + THERMNOISE, + here->B4SOIdNodePrime, + here->B4SOIsNodePrime, + model->B4SOIntnoi * + (2.0 / 3.0 * fabs(here->B4SOIgm + + here->B4SOIgds + + here->B4SOIgmbs))); + break; + } + + NevalSrc(&noizDens[B4SOIFLNOIZ], (double*) NULL, + ckt, N_GAIN, here->B4SOIdNodePrime, + here->B4SOIsNodePrime, (double) 0.0); + + switch( model->B4SOIfnoiMod ) + { case 0: + if (model->B4SOIw0flk > 0) { /* v4.0 */ + noizDens[B4SOIFLNOIZ] *= here->B4SOInf + * pParam->B4SOIweff/model->B4SOIw0flk + * model->B4SOIkf * exp(model->B4SOIaf + * log(MAX(fabs(here->B4SOIcd + / pParam->B4SOIweff / here->B4SOInf + * model->B4SOIw0flk), N_MINLOG))) + / (pow(data->freq, model->B4SOIef) + * pow(pParam->B4SOIleff, + model->B4SOIbf) * model->B4SOIcox); + break; + } + else { + noizDens[B4SOIFLNOIZ] *= + model->B4SOIkf * exp(model->B4SOIaf + * log(MAX(fabs(here->B4SOIcd), N_MINLOG))) + / (pow(data->freq, model->B4SOIef) + * pow(pParam->B4SOIleff, + model->B4SOIbf) * model->B4SOIcox); + break; + } + case 1: + vgs = *(ckt->CKTstates[0] + here->B4SOIvgs); + vds = *(ckt->CKTstates[0] + here->B4SOIvds); + if (vds < 0.0) + { vds = -vds; + vgs = vgs + vds; + } + + Ssi = B4SOIEval1ovFNoise(vds, model, here, + data->freq, ckt->CKTtemp); + + T10 = model->B4SOIoxideTrapDensityA + * CONSTboltz * ckt->CKTtemp; + T11 = pParam->B4SOIweff * here->B4SOInf + * pParam->B4SOIleff + * pow(data->freq, model->B4SOIef) + * 1.0e10 * here->B4SOInstar + * here->B4SOInstar ; + Swi = T10 / T11 * here->B4SOIcd + * here->B4SOIcd; + T1 = Swi + Ssi; + if (T1 > 0.0) + noizDens[B4SOIFLNOIZ] *= (Ssi + * Swi) / T1; + else + noizDens[B4SOIFLNOIZ] *= 0.0; + break; + } + + lnNdens[B4SOIFLNOIZ] = + log(MAX(noizDens[B4SOIFLNOIZ], N_MINLOG)); + + /* v3.2 for gate tunneling shot noise */ + NevalSrc(&noizDens[B4SOIIGSNOIZ], + &lnNdens[B4SOIIGSNOIZ], ckt, SHOTNOISE, + here->B4SOIgNode, here->B4SOIsNodePrime, + (here->B4SOIIgs + here->B4SOIIgcs) * here->B4SOIm); + + NevalSrc(&noizDens[B4SOIIGDNOIZ], + &lnNdens[B4SOIIGDNOIZ], ckt, SHOTNOISE, + here->B4SOIgNode, here->B4SOIdNodePrime, + (here->B4SOIIgd + here->B4SOIIgcd) * here->B4SOIm); + + NevalSrc(&noizDens[B4SOIIGBNOIZ], + &lnNdens[B4SOIIGBNOIZ], ckt, SHOTNOISE, + here->B4SOIgNode, here->B4SOIbNode, + here->B4SOIig * here->B4SOIm); + /* v3.2 for gate tunneling shot noise end */ + + /* Low frequency excess noise due to FBE */ +/* NevalSrc(&noizDens[B4SOIFBNOIZ], + &lnNdens[B4SOIFBNOIZ], ckt, SHOTNOISE, + here->B4SOIsNodePrime, here->B4SOIbNode, + 2.0 * model->B4SOInoif * here->B4SOIibs); */ +/* v4.0 */ + NevalSrc(&noizDens[B4SOIFB_IBSNOIZ], + &lnNdens[B4SOIFB_IBSNOIZ], ckt, SHOTNOISE, + here->B4SOIsNodePrime, here->B4SOIbNode, + model->B4SOInoif * here->B4SOIibs * here->B4SOIm); + + NevalSrc(&noizDens[B4SOIFB_IBDNOIZ], + &lnNdens[B4SOIFB_IBDNOIZ], ckt, SHOTNOISE, + here->B4SOIdNodePrime, here->B4SOIbNode, + model->B4SOInoif * fabs(here->B4SOIibd) * here->B4SOIm); + + noizDens[B4SOITOTNOIZ] = noizDens[B4SOIRDNOIZ] + + noizDens[B4SOIRSNOIZ] + + noizDens[B4SOIRGNOIZ] + + noizDens[B4SOIIDNOIZ] + + noizDens[B4SOIFLNOIZ] + /* + noizDens[B4SOIFBNOIZ] */ + + noizDens[B4SOIFB_IBSNOIZ] + + noizDens[B4SOIFB_IBDNOIZ] + + noizDens[B4SOIIGSNOIZ] + + noizDens[B4SOIIGDNOIZ] + + noizDens[B4SOIIGBNOIZ] + + noizDens[B4SOIRBSBNOIZ] + + noizDens[B4SOIRBDBNOIZ] + + noizDens[B4SOIRBODYNOIZ]; + lnNdens[B4SOITOTNOIZ] = + log(MAX(noizDens[B4SOITOTNOIZ], N_MINLOG)); + + *OnDens += noizDens[B4SOITOTNOIZ]; + + if (data->delFreq == 0.0) + { /* if we haven't done any previous + integration, we need to initialize our + "history" variables. + */ + + for (i = 0; i < B4SOINSRCS; i++) + { here->B4SOInVar[LNLSTDENS][i] = + lnNdens[i]; + } + + /* clear out our integration variables + if it's the first pass + */ + if (data->freq == + ((NOISEAN*) ckt->CKTcurJob)->NstartFreq) + { for (i = 0; i < B4SOINSRCS; i++) + { here->B4SOInVar[OUTNOIZ][i] = 0.0; + here->B4SOInVar[INNOIZ][i] = 0.0; + } + } + } + else + { /* data->delFreq != 0.0, + we have to integrate. + */ + for (i = 0; i < B4SOINSRCS; i++) + { if (i != B4SOITOTNOIZ) + { tempOnoise = Nintegrate(noizDens[i], + lnNdens[i], + here->B4SOInVar[LNLSTDENS][i], + data); + tempInoise = Nintegrate(noizDens[i] + * data->GainSqInv, lnNdens[i] + + data->lnGainInv, + here->B4SOInVar[LNLSTDENS][i] + + data->lnGainInv, data); + here->B4SOInVar[LNLSTDENS][i] = + lnNdens[i]; + data->outNoiz += tempOnoise; + data->inNoise += tempInoise; + if (((NOISEAN*) + ckt->CKTcurJob)->NStpsSm != 0) + { here->B4SOInVar[OUTNOIZ][i] + += tempOnoise; + here->B4SOInVar[OUTNOIZ][B4SOITOTNOIZ] + += tempOnoise; + here->B4SOInVar[INNOIZ][i] + += tempInoise; + here->B4SOInVar[INNOIZ][B4SOITOTNOIZ] + += tempInoise; + } + } + } + } + if (data->prtSummary) + { for (i = 0; i < B4SOINSRCS; i++) + { /* print a summary report */ + data->outpVector[data->outNumber++] + = noizDens[i]; + } + } + break; + case INT_NOIZ: + /* already calculated, just output */ + if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0) + { for (i = 0; i < B4SOINSRCS; i++) + { data->outpVector[data->outNumber++] + = here->B4SOInVar[OUTNOIZ][i]; + data->outpVector[data->outNumber++] + = here->B4SOInVar[INNOIZ][i]; + } + } + break; + } + break; + case N_CLOSE: + /* do nothing, the main calling routine will close */ + return (OK); + break; /* the plots */ + } /* switch (operation) */ + } /* for here */ + } /* for model */ + + return(OK); +} + + + diff --git a/src/spicelib/devices/bsim3soi/b4soipar.c b/src/spicelib/devices/bsim3soi/b4soipar.c new file mode 100644 index 000000000..e89a67705 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soipar.c @@ -0,0 +1,225 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soipar.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soipar.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "ifsim.h" +#include "b4soidef.h" +#include "sperror.h" +#include "suffix.h" + +int +B4SOIparam(int param, IFvalue *value, GENinstance *inst, IFvalue *select) +{ + B4SOIinstance *here = (B4SOIinstance*)inst; + switch(param) + { case B4SOI_W: + here->B4SOIw = value->rValue; + here->B4SOIwGiven = TRUE; + break; + case B4SOI_L: + here->B4SOIl = value->rValue; + here->B4SOIlGiven = TRUE; + break; + case B4SOI_M: + here->B4SOIm = value->rValue; + here->B4SOImGiven = TRUE; + break; + case B4SOI_AS: + here->B4SOIsourceArea = value->rValue; + here->B4SOIsourceAreaGiven = TRUE; + break; + case B4SOI_AD: + here->B4SOIdrainArea = value->rValue; + here->B4SOIdrainAreaGiven = TRUE; + break; + case B4SOI_PS: + here->B4SOIsourcePerimeter = value->rValue; + here->B4SOIsourcePerimeterGiven = TRUE; + break; + case B4SOI_PD: + here->B4SOIdrainPerimeter = value->rValue; + here->B4SOIdrainPerimeterGiven = TRUE; + break; + case B4SOI_NRS: + here->B4SOIsourceSquares = value->rValue; + here->B4SOIsourceSquaresGiven = TRUE; + break; + case B4SOI_NRD: + here->B4SOIdrainSquares = value->rValue; + here->B4SOIdrainSquaresGiven = TRUE; + break; + case B4SOI_OFF: + here->B4SOIoff = value->iValue; + here->B4SOIoffGiven = TRUE; + break; + case B4SOI_IC_VBS: + here->B4SOIicVBS = value->rValue; + here->B4SOIicVBSGiven = TRUE; + break; + case B4SOI_IC_VDS: + here->B4SOIicVDS = value->rValue; + here->B4SOIicVDSGiven = TRUE; + break; + case B4SOI_IC_VGS: + here->B4SOIicVGS = value->rValue; + here->B4SOIicVGSGiven = TRUE; + break; + case B4SOI_IC_VES: + here->B4SOIicVES = value->rValue; + here->B4SOIicVESGiven = TRUE; + break; + case B4SOI_IC_VPS: + here->B4SOIicVPS = value->rValue; + here->B4SOIicVPSGiven = TRUE; + break; + case B4SOI_BJTOFF: + here->B4SOIbjtoff = value->iValue; + here->B4SOIbjtoffGiven= TRUE; + break; + case B4SOI_DEBUG: + here->B4SOIdebugMod = value->iValue; + here->B4SOIdebugModGiven= TRUE; + break; + case B4SOI_RTH0: + here->B4SOIrth0= value->rValue; + here->B4SOIrth0Given = TRUE; + break; + case B4SOI_CTH0: + here->B4SOIcth0= value->rValue; + here->B4SOIcth0Given = TRUE; + break; + case B4SOI_NRB: + here->B4SOIbodySquares = value->rValue; + here->B4SOIbodySquaresGiven = TRUE; + break; + case B4SOI_FRBODY: + here->B4SOIfrbody = value->rValue; + here->B4SOIfrbodyGiven = TRUE; + break; + +/* v4.0 added */ + case B4SOI_RBSB: + here->B4SOIrbsb = value->rValue; + here->B4SOIrbsbGiven = TRUE; + break; + case B4SOI_RBDB: + here->B4SOIrbdb = value->rValue; + here->B4SOIrbdbGiven = TRUE; + break; + case B4SOI_SA: + here->B4SOIsa = value->rValue; + here->B4SOIsaGiven = TRUE; + break; + case B4SOI_SB: + here->B4SOIsb = value->rValue; + here->B4SOIsbGiven = TRUE; + break; + case B4SOI_SD: + here->B4SOIsd = value->rValue; + here->B4SOIsdGiven = TRUE; + break; + case B4SOI_RBODYMOD: + here->B4SOIrbodyMod = value->iValue; + here->B4SOIrbodyModGiven = TRUE; + break; + case B4SOI_NF: + here->B4SOInf = value->rValue; + here->B4SOInfGiven = TRUE; + break; + case B4SOI_DELVTO: + here->B4SOIdelvto = value->rValue; + here->B4SOIdelvtoGiven = TRUE; + break; + +/* v4.0 added end */ + + case B4SOI_SOIMOD: + here->B4SOIsoiMod = value->iValue; + here->B4SOIsoiModGiven = TRUE; + break; /* v3.2 */ + +/* v3.1 added rgate */ + case B4SOI_RGATEMOD: + here->B4SOIrgateMod = value->iValue; + here->B4SOIrgateModGiven = TRUE; + break; +/* v3.1 added rgate end */ + + +/* v2.0 release */ + case B4SOI_NBC: + here->B4SOInbc = value->rValue; + here->B4SOInbcGiven = TRUE; + break; + case B4SOI_NSEG: + here->B4SOInseg = value->rValue; + here->B4SOInsegGiven = TRUE; + break; + case B4SOI_PDBCP: + here->B4SOIpdbcp = value->rValue; + here->B4SOIpdbcpGiven = TRUE; + break; + case B4SOI_PSBCP: + here->B4SOIpsbcp = value->rValue; + here->B4SOIpsbcpGiven = TRUE; + break; + case B4SOI_AGBCP: + here->B4SOIagbcp = value->rValue; + here->B4SOIagbcpGiven = TRUE; + break; + case B4SOI_AGBCPD: + here->B4SOIagbcpd = value->rValue; + here->B4SOIagbcpdGiven = TRUE; + break; + case B4SOI_AEBCP: + here->B4SOIaebcp = value->rValue; + here->B4SOIaebcpGiven = TRUE; + break; + case B4SOI_VBSUSR: + here->B4SOIvbsusr = value->rValue; + here->B4SOIvbsusrGiven = TRUE; + break; + case B4SOI_TNODEOUT: + here->B4SOItnodeout = value->iValue; + here->B4SOItnodeoutGiven = TRUE; + break; + + + case B4SOI_IC: + switch(value->v.numValue){ + case 5: + here->B4SOIicVPS = *(value->v.vec.rVec+4); + here->B4SOIicVPSGiven = TRUE; + case 4: + here->B4SOIicVES = *(value->v.vec.rVec+3); + here->B4SOIicVESGiven = TRUE; + case 3: + here->B4SOIicVBS = *(value->v.vec.rVec+2); + here->B4SOIicVBSGiven = TRUE; + case 2: + here->B4SOIicVGS = *(value->v.vec.rVec+1); + here->B4SOIicVGSGiven = TRUE; + case 1: + here->B4SOIicVDS = *(value->v.vec.rVec); + here->B4SOIicVDSGiven = TRUE; + break; + default: + return(E_BADPARM); + } + break; + default: + return(E_BADPARM); + } + return(OK); +} + + + diff --git a/src/spicelib/devices/bsim3soi/b4soipzld.c b/src/spicelib/devices/bsim3soi/b4soipzld.c new file mode 100644 index 000000000..b70664fdc --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soipzld.c @@ -0,0 +1,158 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soipzld.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soipzld.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "cktdefs.h" +#include "complex.h" +#include "sperror.h" +#include "b4soidef.h" +#include "suffix.h" + +int +B4SOIpzLoad(GENmodel *inModel, CKTcircuit *ckt, SPcomplex *s) +{ +register B4SOImodel *model = (B4SOImodel*)inModel; +register B4SOIinstance *here; +double xcggb, xcgdb, xcgsb, xcbgb, xcbdb, xcbsb, xcddb, xcssb, xcdgb; +double gdpr, gspr, gds, gbd, gbs, capbd = 0.0, capbs = 0.0, xcsgb, xcdsb, xcsdb; +double cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cddb, cdgb, cdsb; +double GSoverlapCap, GDoverlapCap, GBoverlapCap = 0.0; +double FwdSum, RevSum, Gm, Gmbs; + +double m; + + for (; model != NULL; model = model->B4SOInextModel) + { for (here = model->B4SOIinstances; here!= NULL; + here = here->B4SOInextInstance) + { + if (here->B4SOIowner != ARCHme) + continue; + + if (here->B4SOImode >= 0) + { Gm = here->B4SOIgm; + Gmbs = here->B4SOIgmbs; + FwdSum = Gm + Gmbs; + RevSum = 0.0; + cggb = here->B4SOIcggb; + cgsb = here->B4SOIcgsb; + cgdb = here->B4SOIcgdb; + + cbgb = here->B4SOIcbgb; + cbsb = here->B4SOIcbsb; + cbdb = here->B4SOIcbdb; + + cdgb = here->B4SOIcdgb; + cdsb = here->B4SOIcdsb; + cddb = here->B4SOIcddb; + } + else + { Gm = -here->B4SOIgm; + Gmbs = -here->B4SOIgmbs; + FwdSum = 0.0; + RevSum = -Gm - Gmbs; + cggb = here->B4SOIcggb; + cgsb = here->B4SOIcgdb; + cgdb = here->B4SOIcgsb; + + cbgb = here->B4SOIcbgb; + cbsb = here->B4SOIcbdb; + cbdb = here->B4SOIcbsb; + + cdgb = -(here->B4SOIcdgb + cggb + cbgb); + cdsb = -(here->B4SOIcddb + cgsb + cbsb); + cddb = -(here->B4SOIcdsb + cgdb + cbdb); + } + gdpr=here->B4SOIdrainConductance; + gspr=here->B4SOIsourceConductance; + gds= here->B4SOIgds; + gbd= here->B4SOIgjdb; + gbs= here->B4SOIgjsb; +#ifdef BULKCODE + capbd= here->B4SOIcapbd; + capbs= here->B4SOIcapbs; +#endif + GSoverlapCap = here->B4SOIcgso; + GDoverlapCap = here->B4SOIcgdo; +#ifdef BULKCODE + GBoverlapCap = here->pParam->B4SOIcgbo; +#endif + + xcdgb = (cdgb - GDoverlapCap); + xcddb = (cddb + capbd + GDoverlapCap); + xcdsb = cdsb; + xcsgb = -(cggb + cbgb + cdgb + GSoverlapCap); + xcsdb = -(cgdb + cbdb + cddb); + xcssb = (capbs + GSoverlapCap - (cgsb+cbsb+cdsb)); + xcggb = (cggb + GDoverlapCap + GSoverlapCap + GBoverlapCap); + xcgdb = (cgdb - GDoverlapCap); + xcgsb = (cgsb - GSoverlapCap); + xcbgb = (cbgb - GBoverlapCap); + xcbdb = (cbdb - capbd); + xcbsb = (cbsb - capbs); + + m = here->B4SOIm; + + *(here->B4SOIGgPtr ) += m * xcggb * s->real; + *(here->B4SOIGgPtr +1) += m * xcggb * s->imag; + *(here->B4SOIBbPtr ) += m * (-xcbgb-xcbdb-xcbsb) * s->real; + *(here->B4SOIBbPtr +1) += m * (-xcbgb-xcbdb-xcbsb) * s->imag; + *(here->B4SOIDPdpPtr ) += m * xcddb * s->real; + *(here->B4SOIDPdpPtr +1) += m * xcddb * s->imag; + *(here->B4SOISPspPtr ) += m * xcssb * s->real; + *(here->B4SOISPspPtr +1) += m * xcssb * s->imag; + *(here->B4SOIGbPtr ) += m * (-xcggb-xcgdb-xcgsb) * s->real; + *(here->B4SOIGbPtr +1) += m * (-xcggb-xcgdb-xcgsb) * s->imag; + *(here->B4SOIGdpPtr ) += m * xcgdb * s->real; + *(here->B4SOIGdpPtr +1) += m * xcgdb * s->imag; + *(here->B4SOIGspPtr ) += m * xcgsb * s->real; + *(here->B4SOIGspPtr +1) += m * xcgsb * s->imag; + *(here->B4SOIBgPtr ) += m * xcbgb * s->real; + *(here->B4SOIBgPtr +1) += m * xcbgb * s->imag; + *(here->B4SOIBdpPtr ) += m * xcbdb * s->real; + *(here->B4SOIBdpPtr +1) += m * xcbdb * s->imag; + *(here->B4SOIBspPtr ) += m * xcbsb * s->real; + *(here->B4SOIBspPtr +1) += m * xcbsb * s->imag; + *(here->B4SOIDPgPtr ) += m * xcdgb * s->real; + *(here->B4SOIDPgPtr +1) += m * xcdgb * s->imag; + *(here->B4SOIDPbPtr ) += m * (-xcdgb-xcddb-xcdsb) * s->real; + *(here->B4SOIDPbPtr +1) += m * (-xcdgb-xcddb-xcdsb) * s->imag; + *(here->B4SOIDPspPtr ) += m * xcdsb * s->real; + *(here->B4SOIDPspPtr +1) += m * xcdsb * s->imag; + *(here->B4SOISPgPtr ) += m * xcsgb * s->real; + *(here->B4SOISPgPtr +1) += m * xcsgb * s->imag; + *(here->B4SOISPbPtr ) += m * (-xcsgb-xcsdb-xcssb) * s->real; + *(here->B4SOISPbPtr +1) += m * (-xcsgb-xcsdb-xcssb) * s->imag; + *(here->B4SOISPdpPtr ) += m * xcsdb * s->real; + *(here->B4SOISPdpPtr +1) += m * xcsdb * s->imag; + *(here->B4SOIDdPtr) += m * gdpr; + *(here->B4SOISsPtr) += m * gspr; + *(here->B4SOIBbPtr) += m * (gbd+gbs); + *(here->B4SOIDPdpPtr) += m * (gdpr+gds+gbd+RevSum); + *(here->B4SOISPspPtr) += m * (gspr+gds+gbs+FwdSum); + *(here->B4SOIDdpPtr) -= m * gdpr; + *(here->B4SOISspPtr) -= m * gspr; + *(here->B4SOIBdpPtr) -= m * gbd; + *(here->B4SOIBspPtr) -= m * gbs; + *(here->B4SOIDPdPtr) -= m * gdpr; + *(here->B4SOIDPgPtr) += m * Gm; + *(here->B4SOIDPbPtr) -= m * (gbd - Gmbs); + *(here->B4SOIDPspPtr) -= m * (gds + FwdSum); + *(here->B4SOISPgPtr) -= m * Gm; + *(here->B4SOISPsPtr) -= m * gspr; + *(here->B4SOISPbPtr) -= m * (gbs + Gmbs); + *(here->B4SOISPdpPtr) -= m * (gds + RevSum); + + } + } + return(OK); +} + + diff --git a/src/spicelib/devices/bsim3soi/b4soiset.c b/src/spicelib/devices/bsim3soi/b4soiset.c new file mode 100644 index 000000000..d46ac7bb6 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soiset.c @@ -0,0 +1,2350 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soiset.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soiset.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "smpdefs.h" +#include "cktdefs.h" +#include "b4soidef.h" +#include "const.h" +#include "sperror.h" +#include "suffix.h" + +#define SMOOTHFACTOR 0.1 +#define EPSOX 3.453133e-11 +#define EPSSI 1.03594e-10 +#define PI 3.141592654 +#define Charge_q 1.60219e-19 +#define Meter2Micron 1.0e6 + +int +B4SOIsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states) +{ +register B4SOImodel *model = (B4SOImodel*)inModel; +register B4SOIinstance *here; +int error; +CKTnode *tmp; + +double Cboxt; + +/* v3.2 */ +double Vbs0t, Qsi; + +/* Alan's Nodeset Fix */ +CKTnode *tmpNode; +IFuid tmpName; + + /* loop through all the B4SOI device models */ + for( ; model != NULL; model = model->B4SOInextModel ) + { +/* Default value Processing for B4SOI MOSFET Models */ + + if (!model->B4SOItypeGiven) + model->B4SOItype = NMOS; + if (!model->B4SOImobModGiven) + model->B4SOImobMod = 1; + if (!model->B4SOIbinUnitGiven) + model->B4SOIbinUnit = 1; + if (!model->B4SOIparamChkGiven) + model->B4SOIparamChk = 0; + if (!model->B4SOIcapModGiven) + model->B4SOIcapMod = 2; +/* if (!model->B4SOInoiModGiven) + model->B4SOInoiMod = 1; v3.2 */ + if (!model->B4SOIshModGiven) + model->B4SOIshMod = 0; + if (!model->B4SOIversionGiven) + model->B4SOIversion = 4.00; + if (!model->B4SOItoxGiven) + model->B4SOItox = 100.0e-10; + model->B4SOIcox = 3.453133e-11 / model->B4SOItox; + + if (!model->B4SOItoxmGiven) + model->B4SOItoxm = model->B4SOItox; /* v3.2 */ + +/* v3.2 */ + if (!model->B4SOIsoiModGiven) + model->B4SOIsoiMod = 0; + else if ((model->B4SOIsoiMod != 0) && (model->B4SOIsoiMod != 1) + && (model->B4SOIsoiMod != 2) && (model->B4SOIsoiMod != 3)) + { model->B4SOIsoiMod = 0; + printf("Warning: soiMod has been set to its default value: 0.\n"); + } + + /* v3.1 added for RF */ + if (!model->B4SOIrgateModGiven) + model->B4SOIrgateMod = 0; + else if ((model->B4SOIrgateMod != 0) && (model->B4SOIrgateMod != 1) + && (model->B4SOIrgateMod != 2) && (model->B4SOIrgateMod != 3)) + { model->B4SOIrgateMod = 0; + printf("Warning: rgateMod has been set to its default value: 0.\n"); + } + /* v3.1 added for RF end */ + + /* v3.2 for noise */ + if (!model->B4SOIfnoiModGiven) + model->B4SOIfnoiMod = 1; + else if ((model->B4SOIfnoiMod != 0) && (model->B4SOIfnoiMod != 1)) + { model->B4SOIfnoiMod = 1; + printf("Waring: fnoiMod has been set to default value:1.\n"); + } + + if (!model->B4SOItnoiModGiven) + model->B4SOItnoiMod = 0; + else if ((model->B4SOItnoiMod != 0) && (model->B4SOItnoiMod != 1)) + { model->B4SOItnoiMod = 0; + printf("Waring: tnoiMod has been set to default value:0.\n"); + } + + if (!model->B4SOItnoiaGiven) + model->B4SOItnoia = 1.5; + if (!model->B4SOItnoibGiven) + model->B4SOItnoib = 3.5; + if (!model->B4SOIrnoiaGiven) + model->B4SOIrnoia = 0.577; + if (!model->B4SOIrnoibGiven) + model->B4SOIrnoib = 0.37; + if (!model->B4SOIntnoiGiven) + model->B4SOIntnoi = 1.0; + /* v3.2 for noise end */ + + /* v4.0 */ + if (!model->B4SOIrdsModGiven) + model->B4SOIrdsMod = 0; + else if ((model->B4SOIrdsMod != 0) && (model->B4SOIrdsMod != 1)) + { model->B4SOIrdsMod = 0; + printf("Warning: rdsMod has been set to its default value: 0.\n"); + } + + if (!model->B4SOIrbodyModGiven) + model->B4SOIrbodyMod = 0; + else if ((model->B4SOIrbodyMod != 0) && (model->B4SOIrbodyMod != 1)) + { model->B4SOIrbodyMod = 0; + printf("Warning: rbodyMod has been set to its default value: 0.\n"); + } + if (!model->B4SOIgbminGiven) + model->B4SOIgbmin = 1.0e-12; /* in mho */ + if (!model->B4SOIrbdbGiven) + model->B4SOIrbdb = 50.0; /* in ohm */ + if (!model->B4SOIrbsbGiven) + model->B4SOIrbsb = 50.0; /* in ohm */ + + /* v4.0 end */ + + +/* v2.2.3 */ + if (!model->B4SOIdtoxcvGiven) + model->B4SOIdtoxcv = 0.0; + + if (!model->B4SOIcdscGiven) + model->B4SOIcdsc = 2.4e-4; /* unit Q/V/m^2 */ + if (!model->B4SOIcdscbGiven) + model->B4SOIcdscb = 0.0; /* unit Q/V/m^2 */ + if (!model->B4SOIcdscdGiven) + model->B4SOIcdscd = 0.0; /* unit Q/V/m^2 */ + if (!model->B4SOIcitGiven) + model->B4SOIcit = 0.0; /* unit Q/V/m^2 */ + if (!model->B4SOInfactorGiven) + model->B4SOInfactor = 1; + if (!model->B4SOIvsatGiven) + model->B4SOIvsat = 8.0e4; /* unit m/s */ + if (!model->B4SOIatGiven) + model->B4SOIat = 3.3e4; /* unit m/s */ + if (!model->B4SOIa0Given) + model->B4SOIa0 = 1.0; + if (!model->B4SOIagsGiven) + model->B4SOIags = 0.0; + if (!model->B4SOIa1Given) + model->B4SOIa1 = 0.0; + if (!model->B4SOIa2Given) + model->B4SOIa2 = 1.0; + if (!model->B4SOIketaGiven) + model->B4SOIketa = -0.6; /* unit / V */ + if (!model->B4SOInsubGiven) + model->B4SOInsub = 6.0e16; /* unit 1/cm3 */ + if (!model->B4SOInpeakGiven) + model->B4SOInpeak = 1.7e17; /* unit 1/cm3 */ + if (!model->B4SOIngateGiven) + model->B4SOIngate = 0; /* unit 1/cm3 */ + if (!model->B4SOIvbmGiven) + model->B4SOIvbm = -3.0; + if (!model->B4SOIxtGiven) + model->B4SOIxt = 1.55e-7; + if (!model->B4SOIkt1Given) + model->B4SOIkt1 = -0.11; /* unit V */ + if (!model->B4SOIkt1lGiven) + model->B4SOIkt1l = 0.0; /* unit V*m */ + if (!model->B4SOIkt2Given) + model->B4SOIkt2 = 0.022; /* No unit */ + if (!model->B4SOIk3Given) + model->B4SOIk3 = 0.0; + if (!model->B4SOIk3bGiven) + model->B4SOIk3b = 0.0; + if (!model->B4SOIw0Given) + model->B4SOIw0 = 2.5e-6; + if (!model->B4SOIlpebGiven) + model->B4SOIlpeb = 0.0; + if (!model->B4SOIdvt0Given) + model->B4SOIdvt0 = 2.2; + if (!model->B4SOIdvt1Given) + model->B4SOIdvt1 = 0.53; + if (!model->B4SOIdvt2Given) + model->B4SOIdvt2 = -0.032; /* unit 1 / V */ + + if (!model->B4SOIdvt0wGiven) + model->B4SOIdvt0w = 0.0; + if (!model->B4SOIdvt1wGiven) + model->B4SOIdvt1w = 5.3e6; + if (!model->B4SOIdvt2wGiven) + model->B4SOIdvt2w = -0.032; + + if (!model->B4SOIdroutGiven) + model->B4SOIdrout = 0.56; + if (!model->B4SOIdsubGiven) + model->B4SOIdsub = model->B4SOIdrout; + if (!model->B4SOIvth0Given) + model->B4SOIvth0 = (model->B4SOItype == NMOS) ? 0.7 : -0.7; + if (!model->B4SOIuaGiven) + model->B4SOIua = 2.25e-9; /* unit m/V */ + if (!model->B4SOIua1Given) + model->B4SOIua1 = 4.31e-9; /* unit m/V */ + if (!model->B4SOIubGiven) + model->B4SOIub = 5.87e-19; /* unit (m/V)**2 */ + if (!model->B4SOIub1Given) + model->B4SOIub1 = -7.61e-18; /* unit (m/V)**2 */ + if (!model->B4SOIucGiven) + model->B4SOIuc = (model->B4SOImobMod == 3) ? -0.0465 : -0.0465e-9; + if (!model->B4SOIuc1Given) + model->B4SOIuc1 = (model->B4SOImobMod == 3) ? -0.056 : -0.056e-9; + if (!model->B4SOIu0Given) + model->B4SOIu0 = (model->B4SOItype == NMOS) ? 0.067 : 0.025; + if (!model->B4SOIuteGiven) + model->B4SOIute = -1.5; + if (!model->B4SOIvoffGiven) + model->B4SOIvoff = -0.08; + if (!model->B4SOIdeltaGiven) + model->B4SOIdelta = 0.01; + if (!model->B4SOIrdswGiven) + model->B4SOIrdsw = 100; + if (!model->B4SOIrswGiven) /* v4.0 */ + model->B4SOIrsw = 50; + if (!model->B4SOIrdwGiven) /* v4.0 */ + model->B4SOIrdw = 50; + if (!model->B4SOIrswminGiven) /* v4.0 */ + model->B4SOIrswmin = 0.0; + if (!model->B4SOIrdwminGiven) /* v4.0 */ + model->B4SOIrdwmin = 0.0; + if (!model->B4SOIprwgGiven) + model->B4SOIprwg = 0.0; /* unit 1/V */ + if (!model->B4SOIprwbGiven) + model->B4SOIprwb = 0.0; + if (!model->B4SOIprtGiven) + model->B4SOIprt = 0.0; + if (!model->B4SOIeta0Given) + model->B4SOIeta0 = 0.08; /* no unit */ + if (!model->B4SOIetabGiven) + model->B4SOIetab = -0.07; /* unit 1/V */ + if (!model->B4SOIpclmGiven) + model->B4SOIpclm = 1.3; /* no unit */ + if (!model->B4SOIpdibl1Given) + model->B4SOIpdibl1 = .39; /* no unit */ + if (!model->B4SOIpdibl2Given) + model->B4SOIpdibl2 = 0.0086; /* no unit */ + if (!model->B4SOIpdiblbGiven) + model->B4SOIpdiblb = 0.0; /* 1/V */ + if (!model->B4SOIpvagGiven) + model->B4SOIpvag = 0.0; + if (!model->B4SOIwrGiven) + model->B4SOIwr = 1.0; + if (!model->B4SOIdwgGiven) + model->B4SOIdwg = 0.0; + if (!model->B4SOIdwbGiven) + model->B4SOIdwb = 0.0; + if (!model->B4SOIb0Given) + model->B4SOIb0 = 0.0; + if (!model->B4SOIb1Given) + model->B4SOIb1 = 0.0; + if (!model->B4SOIalpha0Given) + model->B4SOIalpha0 = 0.0; + + if (!model->B4SOIcgslGiven) + model->B4SOIcgsl = 0.0; + if (!model->B4SOIcgdlGiven) + model->B4SOIcgdl = 0.0; + if (!model->B4SOIckappaGiven) + model->B4SOIckappa = 0.6; + if (!model->B4SOIclcGiven) + model->B4SOIclc = 0.1e-7; + if (!model->B4SOIcleGiven) + model->B4SOIcle = 0.0; + if (!model->B4SOItboxGiven) + model->B4SOItbox = 3e-7; + if (!model->B4SOItsiGiven) + model->B4SOItsi = 1e-7; + if (!model->B4SOIxjGiven) + model->B4SOIxj = model->B4SOItsi; + if (!model->B4SOIrbodyGiven) + model->B4SOIrbody = 0.0; + if (!model->B4SOIrbshGiven) + model->B4SOIrbsh = 0.0; + if (!model->B4SOIrth0Given) + model->B4SOIrth0 = 0; + +/* v3.0 bug fix */ + if (!model->B4SOIcth0Given) + model->B4SOIcth0 = 1e-5; + + if (!model->B4SOIagidlGiven) + model->B4SOIagidl = 0.0; + if (!model->B4SOIbgidlGiven) + model->B4SOIbgidl = 2.3e9; /* v4.0 */ + if (!model->B4SOIcgidlGiven) /* v4.0 */ + model->B4SOIcgidl = 0.0; + if (!model->B4SOIndiodeGiven) /* v4.0 */ + model->B4SOIndiode = 1.0; + if (!model->B4SOIndiodedGiven) /* v4.0 */ + model->B4SOIndioded = model->B4SOIndiode; + if (!model->B4SOIntunGiven) /* v4.0 */ + model->B4SOIntun = 10.0; + if (!model->B4SOIntundGiven) /* v4.0 */ + model->B4SOIntund = model->B4SOIntun; + + if (!model->B4SOInrecf0Given) + model->B4SOInrecf0 = 2.0; + if (!model->B4SOInrecf0dGiven) + model->B4SOInrecf0d = model->B4SOInrecf0; + if (!model->B4SOInrecr0Given) + model->B4SOInrecr0 = 10.0; + if (!model->B4SOInrecr0dGiven) + model->B4SOInrecr0d = model->B4SOInrecr0; + + if (!model->B4SOIisbjtGiven) + model->B4SOIisbjt = 1e-6; + if (!model->B4SOIidbjtGiven) + model->B4SOIidbjt = model->B4SOIisbjt; + if (!model->B4SOIisdifGiven) + model->B4SOIisdif = 0.0; + if (!model->B4SOIiddifGiven) + model->B4SOIiddif = model->B4SOIisdif; /* v4.0 */ + if (!model->B4SOIisrecGiven) + model->B4SOIisrec = 1e-5; + if (!model->B4SOIidrecGiven) + model->B4SOIidrec = model->B4SOIisrec; + if (!model->B4SOIistunGiven) + model->B4SOIistun = 0.0; + if (!model->B4SOIidtunGiven) + model->B4SOIidtun = model->B4SOIistun; + if (!model->B4SOIxbjtGiven) + model->B4SOIxbjt = 1.0; + if (!model->B4SOIxdifGiven) + model->B4SOIxdif = model->B4SOIxbjt; + if (!model->B4SOIxdifdGiven) + model->B4SOIxdifd = model->B4SOIxdif; + if (!model->B4SOIxrecGiven) + model->B4SOIxrec = 1.0; + if (!model->B4SOIxrecdGiven) + model->B4SOIxrecd = model->B4SOIxrec; + if (!model->B4SOIxtunGiven) + model->B4SOIxtun = 0.0; + if (!model->B4SOIxtundGiven) + model->B4SOIxtund = model->B4SOIxtun; + if (!model->B4SOIttGiven) + model->B4SOItt = 1e-12; + if (!model->B4SOIasdGiven) + model->B4SOIasd = 0.3; + + /* 4.0 backward compatibility */ + if (!model->B4SOIlpe0Given) { + if(!model->B4SOInlxGiven) + model->B4SOIlpe0 = 1.74e-7; + else + model->B4SOIlpe0 = model->B4SOInlx; + } + if(model->B4SOIlpe0Given && model->B4SOInlxGiven) + printf("Warning: both lpe0 and nlx are given. Lpe0 value is taken \n"); + if (!model->B4SOIllpe0Given) { + if(!model->B4SOIlnlxGiven) + model->B4SOIllpe0 = 0.0; + else + model->B4SOIllpe0 = model->B4SOIlnlx; + } + if(model->B4SOIllpe0Given && model->B4SOIlnlxGiven) + printf("Warning: both llpe0 and lnlx are given. Llpe0 value is taken \n"); + if (!model->B4SOIwlpe0Given) { + if(!model->B4SOIwnlxGiven) + model->B4SOIwlpe0 = 0.0; + else + model->B4SOIwlpe0 = model->B4SOIwnlx; + } + if(model->B4SOIwlpe0Given && model->B4SOIwnlxGiven) + printf("Warning: both wlpe0 and wnlx are given. Wlpe0 value is taken \n"); + if (!model->B4SOIplpe0Given) { + if(!model->B4SOIpnlxGiven) + model->B4SOIplpe0 = 0.0; + else + model->B4SOIplpe0 = model->B4SOIpnlx; + } + if(model->B4SOIplpe0Given && model->B4SOIpnlxGiven) + printf("Warning: both plpe0 and pnlx are given. Plpe0 value is taken \n"); + + if (!model->B4SOIegidlGiven) { + if(!model->B4SOIngidlGiven) + model->B4SOIegidl = 1.2; + else + model->B4SOIegidl = model->B4SOIngidl; + } + if(model->B4SOIegidlGiven && model->B4SOIngidlGiven) + printf("Warning: both egidl and ngidl are given. Egidl value is taken \n"); + if (!model->B4SOIlegidlGiven) { + if(!model->B4SOIlngidlGiven) + model->B4SOIlegidl = 0.0; + else + model->B4SOIlegidl = model->B4SOIlngidl; + } + if(model->B4SOIlegidlGiven && model->B4SOIlngidlGiven) + printf("Warning: both legidl and lngidl are given. Legidl value is taken \n"); + if (!model->B4SOIwegidlGiven) { + if(!model->B4SOIwngidlGiven) + model->B4SOIwegidl = 0.0; + else + model->B4SOIwegidl = model->B4SOIwngidl; + } + if(model->B4SOIwegidlGiven && model->B4SOIwngidlGiven) + printf("Warning: both wegidl and wngidl are given. Wegidl value is taken \n"); + if (!model->B4SOIpegidlGiven) { + if(!model->B4SOIpngidlGiven) + model->B4SOIpegidl = 0.0; + else + model->B4SOIpegidl = model->B4SOIpngidl; + } + if(model->B4SOIpegidlGiven && model->B4SOIpngidlGiven) + printf("Warning: both pegidl and pngidl are given. Pegidl value is taken \n"); + + /* unit degree celcius */ + if (!model->B4SOItnomGiven) + model->B4SOItnom = ckt->CKTnomTemp; + if (!model->B4SOILintGiven) + model->B4SOILint = 0.0; + if (!model->B4SOILlGiven) + model->B4SOILl = 0.0; + if (!model->B4SOILlcGiven) + model->B4SOILlc = 0.0; /* v2.2.3 */ + if (!model->B4SOILlnGiven) + model->B4SOILln = 1.0; + if (!model->B4SOILwGiven) + model->B4SOILw = 0.0; + if (!model->B4SOILwcGiven) + model->B4SOILwc = 0.0; /* v2.2.3 */ + if (!model->B4SOILwnGiven) + model->B4SOILwn = 1.0; + if (!model->B4SOILwlGiven) + model->B4SOILwl = 0.0; + if (!model->B4SOILwlcGiven) + model->B4SOILwlc = 0.0; /* v2.2.3 */ + if (!model->B4SOILminGiven) + model->B4SOILmin = 0.0; + if (!model->B4SOILmaxGiven) + model->B4SOILmax = 1.0; + if (!model->B4SOIWintGiven) + model->B4SOIWint = 0.0; + if (!model->B4SOIWlGiven) + model->B4SOIWl = 0.0; + if (!model->B4SOIWlcGiven) + model->B4SOIWlc = 0.0; /* v2.2.3 */ + if (!model->B4SOIWlnGiven) + model->B4SOIWln = 1.0; + if (!model->B4SOIWwGiven) + model->B4SOIWw = 0.0; + if (!model->B4SOIWwcGiven) + model->B4SOIWwc = 0.0; /* v2.2.3 */ + if (!model->B4SOIWwnGiven) + model->B4SOIWwn = 1.0; + if (!model->B4SOIWwlGiven) + model->B4SOIWwl = 0.0; + if (!model->B4SOIWwlcGiven) + model->B4SOIWwlc = 0.0; /* v2.2.3 */ + if (!model->B4SOIWminGiven) + model->B4SOIWmin = 0.0; + if (!model->B4SOIWmaxGiven) + model->B4SOIWmax = 1.0; + if (!model->B4SOIdwcGiven) + model->B4SOIdwc = model->B4SOIWint; + if (!model->B4SOIdlcGiven) + model->B4SOIdlc = model->B4SOILint; + if (!model->B4SOIdlcigGiven) + model->B4SOIdlcig = model->B4SOILint; /* v3.0 */ + + +/* v3.0 */ + if (!model->B4SOIvbs0pdGiven) + model->B4SOIvbs0pd = 0.0; /* v3.2 */ + if (!model->B4SOIvbs0fdGiven) + model->B4SOIvbs0fd = 0.5; /* v3.2 */ + if (!model->B4SOIvbsaGiven) + model->B4SOIvbsa = 0.0; + if (!model->B4SOInofffdGiven) + model->B4SOInofffd = 1.0; + if (!model->B4SOIvofffdGiven) + model->B4SOIvofffd = 0.0; + if (!model->B4SOIk1bGiven) + model->B4SOIk1b = 1.0; + if (!model->B4SOIk2bGiven) + model->B4SOIk2b = 0.0; + if (!model->B4SOIdk2bGiven) + model->B4SOIdk2b = 0.0; + if (!model->B4SOIdvbd0Given) + model->B4SOIdvbd0 = 0.0; + if (!model->B4SOIdvbd1Given) + model->B4SOIdvbd1 = 0.0; + if (!model->B4SOImoinFDGiven) + model->B4SOImoinFD = 1e3; + +/* v3.1 added for RF */ + if (!model->B4SOIxrcrg1Given) + model->B4SOIxrcrg1 =12.0; + if (!model->B4SOIxrcrg2Given) + model->B4SOIxrcrg2 =1.0; + if (!model->B4SOIrshgGiven) + model->B4SOIrshg =0.1; + if (!model->B4SOIngconGiven) + model->B4SOIngcon =1.0; + if (!model->B4SOIxgwGiven) + model->B4SOIxgw = 0.0; + if (!model->B4SOIxglGiven) + model->B4SOIxgl = 0.0; +/* v3.1 added for RF end */ + +/* v2.2 release */ + if (!model->B4SOIwth0Given) + model->B4SOIwth0 = 0.0; + if (!model->B4SOIrhaloGiven) + model->B4SOIrhalo = 1e15; + if (!model->B4SOIntoxGiven) + model->B4SOIntox = 1; + if (!model->B4SOItoxrefGiven) + model->B4SOItoxref = 2.5e-9; + if (!model->B4SOIebgGiven) + model->B4SOIebg = 1.2; + if (!model->B4SOIvevbGiven) + model->B4SOIvevb = 0.075; + if (!model->B4SOIalphaGB1Given) + model->B4SOIalphaGB1 = 0.35; + if (!model->B4SOIbetaGB1Given) + model->B4SOIbetaGB1 = 0.03; + if (!model->B4SOIvgb1Given) + model->B4SOIvgb1 = 300; + if (!model->B4SOIalphaGB2Given) + model->B4SOIalphaGB2 = 0.43; + if (!model->B4SOIbetaGB2Given) + model->B4SOIbetaGB2 = 0.05; + if (!model->B4SOIvecbGiven) + model->B4SOIvecb = 0.026; + if (!model->B4SOIvgb2Given) + model->B4SOIvgb2 = 17; + if (!model->B4SOItoxqmGiven) + model->B4SOItoxqm = model->B4SOItox; + if (!model->B4SOIvoxhGiven) + model->B4SOIvoxh = 5.0; + if (!model->B4SOIdeltavoxGiven) + model->B4SOIdeltavox = 0.005; + +/* v3.0 */ + if (!model->B4SOIigbModGiven) + model->B4SOIigbMod = 0; + if (!model->B4SOIigcModGiven) + model->B4SOIigcMod = 0; + if (!model->B4SOInigcGiven) + model->B4SOInigc = 1.0; + if (!model->B4SOIaigcGiven) + model->B4SOIaigc = (model->B4SOItype == NMOS) ? 0.43 : 0.31; + if (!model->B4SOIbigcGiven) + model->B4SOIbigc = (model->B4SOItype == NMOS) ? 0.054 : 0.024; + if (!model->B4SOIcigcGiven) + model->B4SOIcigc = (model->B4SOItype == NMOS) ? 0.075 : 0.03; + if (!model->B4SOIaigsdGiven) + model->B4SOIaigsd = (model->B4SOItype == NMOS) ? 0.43 : 0.31; + if (!model->B4SOIbigsdGiven) + model->B4SOIbigsd = (model->B4SOItype == NMOS) ? 0.054 : 0.024; + if (!model->B4SOIcigsdGiven) + model->B4SOIcigsd = (model->B4SOItype == NMOS) ? 0.075 : 0.03; + if (!model->B4SOIpigcdGiven) + model->B4SOIpigcd = 1.0; + if (!model->B4SOIpoxedgeGiven) + model->B4SOIpoxedge = 1.0; + + + +/* v2.0 release */ + if (!model->B4SOIk1w1Given) + model->B4SOIk1w1 = 0.0; + if (!model->B4SOIk1w2Given) + model->B4SOIk1w2 = 0.0; + if (!model->B4SOIketasGiven) + model->B4SOIketas = 0.0; + if (!model->B4SOIdwbcGiven) + model->B4SOIdwbc = 0.0; + if (!model->B4SOIbeta0Given) + model->B4SOIbeta0 = 0.0; + if (!model->B4SOIbeta1Given) + model->B4SOIbeta1 = 0.0; + if (!model->B4SOIbeta2Given) + model->B4SOIbeta2 = 0.1; + if (!model->B4SOIvdsatii0Given) + model->B4SOIvdsatii0 = 0.9; + if (!model->B4SOItiiGiven) + model->B4SOItii = 0.0; + if (!model->B4SOIliiGiven) + model->B4SOIlii = 0.0; + if (!model->B4SOIsii0Given) + model->B4SOIsii0 = 0.5; + if (!model->B4SOIsii1Given) + model->B4SOIsii1 = 0.1; + if (!model->B4SOIsii2Given) + model->B4SOIsii2 = 0.0; + if (!model->B4SOIsiidGiven) + model->B4SOIsiid = 0.0; + if (!model->B4SOIfbjtiiGiven) + model->B4SOIfbjtii = 0.0; + if (!model->B4SOIesatiiGiven) + model->B4SOIesatii = 1e7; + if (!model->B4SOIlnGiven) + model->B4SOIln = 2e-6; + if (!model->B4SOIvrec0Given) /* v4.0 */ + model->B4SOIvrec0 = 0; + if (!model->B4SOIvrec0dGiven) /* v4.0 */ + model->B4SOIvrec0d = model->B4SOIvrec0; + if (!model->B4SOIvtun0Given) /* v4.0 */ + model->B4SOIvtun0 = 0; + if (!model->B4SOIvtun0dGiven) /* v4.0 */ + model->B4SOIvtun0d = model->B4SOIvtun0; + if (!model->B4SOInbjtGiven) + model->B4SOInbjt = 1.0; + if (!model->B4SOIlbjt0Given) + model->B4SOIlbjt0 = 0.20e-6; + if (!model->B4SOIldif0Given) + model->B4SOIldif0 = 1.0; + if (!model->B4SOIvabjtGiven) + model->B4SOIvabjt = 10.0; + if (!model->B4SOIaelyGiven) + model->B4SOIaely = 0; + if (!model->B4SOIahliGiven) /* v4.0 */ + model->B4SOIahli = 0; + if (!model->B4SOIahlidGiven) /* v4.0 */ + model->B4SOIahlid = model->B4SOIahli; + if (!model->B4SOIrbodyGiven) + model->B4SOIrbody = 0.0; + if (!model->B4SOIrbshGiven) + model->B4SOIrbsh = 0.0; + if (!model->B4SOIntrecfGiven) + model->B4SOIntrecf = 0.0; + if (!model->B4SOIntrecrGiven) + model->B4SOIntrecr = 0.0; + if (!model->B4SOIndifGiven) + model->B4SOIndif = -1.0; + if (!model->B4SOIdlcbGiven) + model->B4SOIdlcb = 0.0; + if (!model->B4SOIfbodyGiven) + model->B4SOIfbody = 1.0; + if (!model->B4SOItcjswgGiven) + model->B4SOItcjswg = 0.0; + if (!model->B4SOItpbswgGiven) + model->B4SOItpbswg = 0.0; + if (!model->B4SOItcjswgdGiven) + model->B4SOItcjswgd = model->B4SOItcjswg; + if (!model->B4SOItpbswgdGiven) + model->B4SOItpbswgd = model->B4SOItpbswg; + if (!model->B4SOIacdeGiven) + model->B4SOIacde = 1.0; + if (!model->B4SOImoinGiven) + model->B4SOImoin = 15.0; + if (!model->B4SOInoffGiven) + model->B4SOInoff = 1.0; /* v3.2 */ + if (!model->B4SOIdelvtGiven) + model->B4SOIdelvt = 0.0; + if (!model->B4SOIkb1Given) + model->B4SOIkb1 = 1.0; + if (!model->B4SOIdlbgGiven) + model->B4SOIdlbg = 0.0; + +/* Added for binning - START */ + /* Length dependence */ +/* v3.1 */ + if (!model->B4SOIlxjGiven) + model->B4SOIlxj = 0.0; + if (!model->B4SOIlalphaGB1Given) + model->B4SOIlalphaGB1 = 0.0; + if (!model->B4SOIlalphaGB2Given) + model->B4SOIlalphaGB2 = 0.0; + if (!model->B4SOIlbetaGB1Given) + model->B4SOIlbetaGB1 = 0.0; + if (!model->B4SOIlbetaGB2Given) + model->B4SOIlbetaGB2 = 0.0; + if (!model->B4SOIlndifGiven) + model->B4SOIlndif = 0.0; + if (!model->B4SOIlntrecfGiven) + model->B4SOIlntrecf = 0.0; + if (!model->B4SOIlntrecrGiven) + model->B4SOIlntrecr = 0.0; + if (!model->B4SOIlxbjtGiven) + model->B4SOIlxbjt = 0.0; + if (!model->B4SOIlxdifGiven) + model->B4SOIlxdif = 0.0; + if (!model->B4SOIlxrecGiven) + model->B4SOIlxrec = 0.0; + if (!model->B4SOIlxtunGiven) + model->B4SOIlxtun = 0.0; + if (!model->B4SOIlxdifdGiven) + model->B4SOIlxdifd = model->B4SOIlxdif; + if (!model->B4SOIlxrecdGiven) + model->B4SOIlxrecd = model->B4SOIlxrec; + if (!model->B4SOIlxtundGiven) + model->B4SOIlxtund = model->B4SOIlxtun; + if (!model->B4SOIlcgdlGiven) + model->B4SOIlcgdl = 0.0; + if (!model->B4SOIlcgslGiven) + model->B4SOIlcgsl = 0.0; + if (!model->B4SOIlckappaGiven) + model->B4SOIlckappa = 0.0; + if (!model->B4SOIluteGiven) + model->B4SOIlute = 0.0; + if (!model->B4SOIlkt1Given) + model->B4SOIlkt1 = 0.0; + if (!model->B4SOIlkt2Given) + model->B4SOIlkt2 = 0.0; + if (!model->B4SOIlkt1lGiven) + model->B4SOIlkt1l = 0.0; + if (!model->B4SOIlua1Given) + model->B4SOIlua1 = 0.0; + if (!model->B4SOIlub1Given) + model->B4SOIlub1 = 0.0; + if (!model->B4SOIluc1Given) + model->B4SOIluc1 = 0.0; + if (!model->B4SOIlatGiven) + model->B4SOIlat = 0.0; + if (!model->B4SOIlprtGiven) + model->B4SOIlprt = 0.0; + +/* v3.0 */ + if (!model->B4SOIlnigcGiven) + model->B4SOIlnigc = 0.0; + if (!model->B4SOIlpigcdGiven) + model->B4SOIlpigcd = 0.0; + if (!model->B4SOIlpoxedgeGiven) + model->B4SOIlpoxedge = 0.0; + if (!model->B4SOIlaigcGiven) + model->B4SOIlaigc = 0.0; + if (!model->B4SOIlbigcGiven) + model->B4SOIlbigc = 0.0; + if (!model->B4SOIlcigcGiven) + model->B4SOIlcigc = 0.0; + if (!model->B4SOIlaigsdGiven) + model->B4SOIlaigsd = 0.0; + if (!model->B4SOIlbigsdGiven) + model->B4SOIlbigsd = 0.0; + if (!model->B4SOIlcigsdGiven) + model->B4SOIlcigsd = 0.0; + + if (!model->B4SOIlnpeakGiven) + model->B4SOIlnpeak = 0.0; + if (!model->B4SOIlnsubGiven) + model->B4SOIlnsub = 0.0; + if (!model->B4SOIlngateGiven) + model->B4SOIlngate = 0.0; + if (!model->B4SOIlvth0Given) + model->B4SOIlvth0 = 0.0; + if (!model->B4SOIlk1Given) + model->B4SOIlk1 = 0.0; + if (!model->B4SOIlk1w1Given) + model->B4SOIlk1w1 = 0.0; + if (!model->B4SOIlk1w2Given) + model->B4SOIlk1w2 = 0.0; + if (!model->B4SOIlk2Given) + model->B4SOIlk2 = 0.0; + if (!model->B4SOIlk3Given) + model->B4SOIlk3 = 0.0; + if (!model->B4SOIlk3bGiven) + model->B4SOIlk3b = 0.0; + if (!model->B4SOIlkb1Given) + model->B4SOIlkb1 = 0.0; + if (!model->B4SOIlw0Given) + model->B4SOIlw0 = 0.0; + if (!model->B4SOIllpebGiven) + model->B4SOIllpeb = 0.0; + if (!model->B4SOIldvt0Given) + model->B4SOIldvt0 = 0.0; + if (!model->B4SOIldvt1Given) + model->B4SOIldvt1 = 0.0; + if (!model->B4SOIldvt2Given) + model->B4SOIldvt2 = 0.0; + if (!model->B4SOIldvt0wGiven) + model->B4SOIldvt0w = 0.0; + if (!model->B4SOIldvt1wGiven) + model->B4SOIldvt1w = 0.0; + if (!model->B4SOIldvt2wGiven) + model->B4SOIldvt2w = 0.0; + if (!model->B4SOIlu0Given) + model->B4SOIlu0 = 0.0; + if (!model->B4SOIluaGiven) + model->B4SOIlua = 0.0; + if (!model->B4SOIlubGiven) + model->B4SOIlub = 0.0; + if (!model->B4SOIlucGiven) + model->B4SOIluc = 0.0; + if (!model->B4SOIlvsatGiven) + model->B4SOIlvsat = 0.0; + if (!model->B4SOIla0Given) + model->B4SOIla0 = 0.0; + if (!model->B4SOIlagsGiven) + model->B4SOIlags = 0.0; + if (!model->B4SOIlb0Given) + model->B4SOIlb0 = 0.0; + if (!model->B4SOIlb1Given) + model->B4SOIlb1 = 0.0; + if (!model->B4SOIlketaGiven) + model->B4SOIlketa = 0.0; + if (!model->B4SOIlketasGiven) + model->B4SOIlketas = 0.0; + if (!model->B4SOIla1Given) + model->B4SOIla1 = 0.0; + if (!model->B4SOIla2Given) + model->B4SOIla2 = 0.0; + if (!model->B4SOIlrdswGiven) + model->B4SOIlrdsw = 0.0; + if (!model->B4SOIlrswGiven) /* v4.0 */ + model->B4SOIlrsw = 0.0; + if (!model->B4SOIlrdwGiven) /* v4.0 */ + model->B4SOIlrdw = 0.0; + if (!model->B4SOIlprwbGiven) + model->B4SOIlprwb = 0.0; + if (!model->B4SOIlprwgGiven) + model->B4SOIlprwg = 0.0; + if (!model->B4SOIlwrGiven) + model->B4SOIlwr = 0.0; + if (!model->B4SOIlnfactorGiven) + model->B4SOIlnfactor = 0.0; + if (!model->B4SOIldwgGiven) + model->B4SOIldwg = 0.0; + if (!model->B4SOIldwbGiven) + model->B4SOIldwb = 0.0; + if (!model->B4SOIlvoffGiven) + model->B4SOIlvoff = 0.0; + if (!model->B4SOIleta0Given) + model->B4SOIleta0 = 0.0; + if (!model->B4SOIletabGiven) + model->B4SOIletab = 0.0; + if (!model->B4SOIldsubGiven) + model->B4SOIldsub = 0.0; + if (!model->B4SOIlcitGiven) + model->B4SOIlcit = 0.0; + if (!model->B4SOIlcdscGiven) + model->B4SOIlcdsc = 0.0; + if (!model->B4SOIlcdscbGiven) + model->B4SOIlcdscb = 0.0; + if (!model->B4SOIlcdscdGiven) + model->B4SOIlcdscd = 0.0; + if (!model->B4SOIlpclmGiven) + model->B4SOIlpclm = 0.0; + if (!model->B4SOIlpdibl1Given) + model->B4SOIlpdibl1 = 0.0; + if (!model->B4SOIlpdibl2Given) + model->B4SOIlpdibl2 = 0.0; + if (!model->B4SOIlpdiblbGiven) + model->B4SOIlpdiblb = 0.0; + if (!model->B4SOIldroutGiven) + model->B4SOIldrout = 0.0; + if (!model->B4SOIlpvagGiven) + model->B4SOIlpvag = 0.0; + if (!model->B4SOIldeltaGiven) + model->B4SOIldelta = 0.0; + if (!model->B4SOIlalpha0Given) + model->B4SOIlalpha0 = 0.0; + if (!model->B4SOIlfbjtiiGiven) + model->B4SOIlfbjtii = 0.0; + if (!model->B4SOIlbeta0Given) + model->B4SOIlbeta0 = 0.0; + if (!model->B4SOIlbeta1Given) + model->B4SOIlbeta1 = 0.0; + if (!model->B4SOIlbeta2Given) + model->B4SOIlbeta2 = 0.0; + if (!model->B4SOIlvdsatii0Given) + model->B4SOIlvdsatii0 = 0.0; + if (!model->B4SOIlliiGiven) + model->B4SOIllii = 0.0; + if (!model->B4SOIlesatiiGiven) + model->B4SOIlesatii = 0.0; + if (!model->B4SOIlsii0Given) + model->B4SOIlsii0 = 0.0; + if (!model->B4SOIlsii1Given) + model->B4SOIlsii1 = 0.0; + if (!model->B4SOIlsii2Given) + model->B4SOIlsii2 = 0.0; + if (!model->B4SOIlsiidGiven) + model->B4SOIlsiid = 0.0; + if (!model->B4SOIlagidlGiven) + model->B4SOIlagidl = 0.0; + if (!model->B4SOIlbgidlGiven) + model->B4SOIlbgidl = 0.0; + if (!model->B4SOIlcgidlGiven) + model->B4SOIlcgidl = 0.0; + if (!model->B4SOIlntunGiven) /* v4.0 */ + model->B4SOIlntun = 0.0; + if (!model->B4SOIlntundGiven) /* v4.0 */ + model->B4SOIlntund = model->B4SOIlntun; + if (!model->B4SOIlndiodeGiven) /* v4.0 */ + model->B4SOIlndiode = 0.0; + if (!model->B4SOIlndiodedGiven) /* v4.0 */ + model->B4SOIlndioded = model->B4SOIlndiode; + if (!model->B4SOIlnrecf0Given) /* v4.0 */ + model->B4SOIlnrecf0 = 0.0; + if (!model->B4SOIlnrecf0dGiven) /* v4.0 */ + model->B4SOIlnrecf0d = model->B4SOIlnrecf0; + if (!model->B4SOIlnrecr0Given) /* v4.0 */ + model->B4SOIlnrecr0 = 0.0; + if (!model->B4SOIlnrecr0dGiven) /* v4.0 */ + model->B4SOIlnrecr0d = model->B4SOIlnrecr0; + if (!model->B4SOIlisbjtGiven) + model->B4SOIlisbjt = 0.0; + if (!model->B4SOIlidbjtGiven) + model->B4SOIlidbjt = model->B4SOIlisbjt; + if (!model->B4SOIlisdifGiven) + model->B4SOIlisdif = 0.0; + if (!model->B4SOIliddifGiven) + model->B4SOIliddif = model->B4SOIlisdif; /* v4.0 */ + if (!model->B4SOIlisrecGiven) + model->B4SOIlisrec = 0.0; + if (!model->B4SOIlidrecGiven) + model->B4SOIlidrec = model->B4SOIlisrec; + if (!model->B4SOIlistunGiven) + model->B4SOIlistun = 0.0; + if (!model->B4SOIlidtunGiven) + model->B4SOIlidtun = model->B4SOIlistun; + if (!model->B4SOIlvrec0Given) /* v4.0 */ + model->B4SOIlvrec0 = 0; + if (!model->B4SOIlvrec0dGiven) /* v4.0 */ + model->B4SOIlvrec0d = model->B4SOIlvrec0; + if (!model->B4SOIlvtun0Given) /* v4.0 */ + model->B4SOIlvtun0 = 0; + if (!model->B4SOIlvtun0dGiven) /* v4.0 */ + model->B4SOIlvtun0d = model->B4SOIlvtun0; + if (!model->B4SOIlnbjtGiven) + model->B4SOIlnbjt = 0.0; + if (!model->B4SOIllbjt0Given) + model->B4SOIllbjt0 = 0.0; + if (!model->B4SOIlvabjtGiven) + model->B4SOIlvabjt = 0.0; + if (!model->B4SOIlaelyGiven) + model->B4SOIlaely = 0.0; + if (!model->B4SOIlahliGiven) /* v4.0 */ + model->B4SOIlahli = 0.0; + if (!model->B4SOIlahlidGiven) /* v4.0 */ + model->B4SOIlahlid = model->B4SOIlahli; + /* CV Model */ + if (!model->B4SOIlvsdfbGiven) + model->B4SOIlvsdfb = 0.0; + if (!model->B4SOIlvsdthGiven) + model->B4SOIlvsdth = 0.0; + if (!model->B4SOIldelvtGiven) + model->B4SOIldelvt = 0.0; + if (!model->B4SOIlacdeGiven) + model->B4SOIlacde = 0.0; + if (!model->B4SOIlmoinGiven) + model->B4SOIlmoin = 0.0; + if (!model->B4SOIlnoffGiven) + model->B4SOIlnoff = 0.0; /* v3.2 */ + +/* v3.1 added for RF */ + if (!model->B4SOIlxrcrg1Given) + model->B4SOIlxrcrg1 =0.0; + if (!model->B4SOIlxrcrg2Given) + model->B4SOIlxrcrg2 =0.0; +/* v3.1 added for RF end */ + + /* Width dependence */ +/* v3.1 */ + if (!model->B4SOIwxjGiven) + model->B4SOIwxj = 0.0; + if (!model->B4SOIwalphaGB1Given) + model->B4SOIwalphaGB1 = 0.0; + if (!model->B4SOIwalphaGB2Given) + model->B4SOIwalphaGB2 = 0.0; + if (!model->B4SOIwbetaGB1Given) + model->B4SOIwbetaGB1 = 0.0; + if (!model->B4SOIwbetaGB2Given) + model->B4SOIwbetaGB2 = 0.0; + if (!model->B4SOIwndifGiven) + model->B4SOIwndif = 0.0; + if (!model->B4SOIwntrecfGiven) + model->B4SOIwntrecf = 0.0; + if (!model->B4SOIwntrecrGiven) + model->B4SOIwntrecr = 0.0; + if (!model->B4SOIwxbjtGiven) + model->B4SOIwxbjt = 0.0; + if (!model->B4SOIwxdifGiven) + model->B4SOIwxdif = 0.0; + if (!model->B4SOIwxrecGiven) + model->B4SOIwxrec = 0.0; + if (!model->B4SOIwxtunGiven) + model->B4SOIwxtun = 0.0; + if (!model->B4SOIwxdifdGiven) + model->B4SOIwxdifd = model->B4SOIwxdif; + if (!model->B4SOIwxrecdGiven) + model->B4SOIwxrecd = model->B4SOIwxrec; + if (!model->B4SOIwxtundGiven) + model->B4SOIwxtund = model->B4SOIwxtun; + if (!model->B4SOIwcgdlGiven) + model->B4SOIwcgdl = 0.0; + if (!model->B4SOIwcgslGiven) + model->B4SOIwcgsl = 0.0; + if (!model->B4SOIwckappaGiven) + model->B4SOIwckappa = 0.0; + if (!model->B4SOIwuteGiven) + model->B4SOIwute = 0.0; + if (!model->B4SOIwkt1Given) + model->B4SOIwkt1 = 0.0; + if (!model->B4SOIwkt2Given) + model->B4SOIwkt2 = 0.0; + if (!model->B4SOIwkt1lGiven) + model->B4SOIwkt1l = 0.0; + if (!model->B4SOIwua1Given) + model->B4SOIwua1 = 0.0; + if (!model->B4SOIwub1Given) + model->B4SOIwub1 = 0.0; + if (!model->B4SOIwuc1Given) + model->B4SOIwuc1 = 0.0; + if (!model->B4SOIwatGiven) + model->B4SOIwat = 0.0; + if (!model->B4SOIwprtGiven) + model->B4SOIwprt = 0.0; + + +/* v3.0 */ + if (!model->B4SOIwnigcGiven) + model->B4SOIwnigc = 0.0; + if (!model->B4SOIwpigcdGiven) + model->B4SOIwpigcd = 0.0; + if (!model->B4SOIwpoxedgeGiven) + model->B4SOIwpoxedge = 0.0; + if (!model->B4SOIwaigcGiven) + model->B4SOIwaigc = 0.0; + if (!model->B4SOIwbigcGiven) + model->B4SOIwbigc = 0.0; + if (!model->B4SOIwcigcGiven) + model->B4SOIwcigc = 0.0; + if (!model->B4SOIwaigsdGiven) + model->B4SOIwaigsd = 0.0; + if (!model->B4SOIwbigsdGiven) + model->B4SOIwbigsd = 0.0; + if (!model->B4SOIwcigsdGiven) + model->B4SOIwcigsd = 0.0; + + if (!model->B4SOIwnpeakGiven) + model->B4SOIwnpeak = 0.0; + if (!model->B4SOIwnsubGiven) + model->B4SOIwnsub = 0.0; + if (!model->B4SOIwngateGiven) + model->B4SOIwngate = 0.0; + if (!model->B4SOIwvth0Given) + model->B4SOIwvth0 = 0.0; + if (!model->B4SOIwk1Given) + model->B4SOIwk1 = 0.0; + if (!model->B4SOIwk1w1Given) + model->B4SOIwk1w1 = 0.0; + if (!model->B4SOIwk1w2Given) + model->B4SOIwk1w2 = 0.0; + if (!model->B4SOIwk2Given) + model->B4SOIwk2 = 0.0; + if (!model->B4SOIwk3Given) + model->B4SOIwk3 = 0.0; + if (!model->B4SOIwk3bGiven) + model->B4SOIwk3b = 0.0; + if (!model->B4SOIwkb1Given) + model->B4SOIwkb1 = 0.0; + if (!model->B4SOIww0Given) + model->B4SOIww0 = 0.0; + if (!model->B4SOIwlpebGiven) + model->B4SOIwlpeb = 0.0; + if (!model->B4SOIwdvt0Given) + model->B4SOIwdvt0 = 0.0; + if (!model->B4SOIwdvt1Given) + model->B4SOIwdvt1 = 0.0; + if (!model->B4SOIwdvt2Given) + model->B4SOIwdvt2 = 0.0; + if (!model->B4SOIwdvt0wGiven) + model->B4SOIwdvt0w = 0.0; + if (!model->B4SOIwdvt1wGiven) + model->B4SOIwdvt1w = 0.0; + if (!model->B4SOIwdvt2wGiven) + model->B4SOIwdvt2w = 0.0; + if (!model->B4SOIwu0Given) + model->B4SOIwu0 = 0.0; + if (!model->B4SOIwuaGiven) + model->B4SOIwua = 0.0; + if (!model->B4SOIwubGiven) + model->B4SOIwub = 0.0; + if (!model->B4SOIwucGiven) + model->B4SOIwuc = 0.0; + if (!model->B4SOIwvsatGiven) + model->B4SOIwvsat = 0.0; + if (!model->B4SOIwa0Given) + model->B4SOIwa0 = 0.0; + if (!model->B4SOIwagsGiven) + model->B4SOIwags = 0.0; + if (!model->B4SOIwb0Given) + model->B4SOIwb0 = 0.0; + if (!model->B4SOIwb1Given) + model->B4SOIwb1 = 0.0; + if (!model->B4SOIwketaGiven) + model->B4SOIwketa = 0.0; + if (!model->B4SOIwketasGiven) + model->B4SOIwketas = 0.0; + if (!model->B4SOIwa1Given) + model->B4SOIwa1 = 0.0; + if (!model->B4SOIwa2Given) + model->B4SOIwa2 = 0.0; + if (!model->B4SOIwrdswGiven) + model->B4SOIwrdsw = 0.0; + if (!model->B4SOIwrswGiven) /* v4.0 */ + model->B4SOIwrsw = 0.0; + if (!model->B4SOIwrdwGiven) /* v4.0 */ + model->B4SOIwrdw = 0.0; + if (!model->B4SOIwprwbGiven) + model->B4SOIwprwb = 0.0; + if (!model->B4SOIwprwgGiven) + model->B4SOIwprwg = 0.0; + if (!model->B4SOIwwrGiven) + model->B4SOIwwr = 0.0; + if (!model->B4SOIwnfactorGiven) + model->B4SOIwnfactor = 0.0; + if (!model->B4SOIwdwgGiven) + model->B4SOIwdwg = 0.0; + if (!model->B4SOIwdwbGiven) + model->B4SOIwdwb = 0.0; + if (!model->B4SOIwvoffGiven) + model->B4SOIwvoff = 0.0; + if (!model->B4SOIweta0Given) + model->B4SOIweta0 = 0.0; + if (!model->B4SOIwetabGiven) + model->B4SOIwetab = 0.0; + if (!model->B4SOIwdsubGiven) + model->B4SOIwdsub = 0.0; + if (!model->B4SOIwcitGiven) + model->B4SOIwcit = 0.0; + if (!model->B4SOIwcdscGiven) + model->B4SOIwcdsc = 0.0; + if (!model->B4SOIwcdscbGiven) + model->B4SOIwcdscb = 0.0; + if (!model->B4SOIwcdscdGiven) + model->B4SOIwcdscd = 0.0; + if (!model->B4SOIwpclmGiven) + model->B4SOIwpclm = 0.0; + if (!model->B4SOIwpdibl1Given) + model->B4SOIwpdibl1 = 0.0; + if (!model->B4SOIwpdibl2Given) + model->B4SOIwpdibl2 = 0.0; + if (!model->B4SOIwpdiblbGiven) + model->B4SOIwpdiblb = 0.0; + if (!model->B4SOIwdroutGiven) + model->B4SOIwdrout = 0.0; + if (!model->B4SOIwpvagGiven) + model->B4SOIwpvag = 0.0; + if (!model->B4SOIwdeltaGiven) + model->B4SOIwdelta = 0.0; + if (!model->B4SOIwalpha0Given) + model->B4SOIwalpha0 = 0.0; + if (!model->B4SOIwfbjtiiGiven) + model->B4SOIwfbjtii = 0.0; + if (!model->B4SOIwbeta0Given) + model->B4SOIwbeta0 = 0.0; + if (!model->B4SOIwbeta1Given) + model->B4SOIwbeta1 = 0.0; + if (!model->B4SOIwbeta2Given) + model->B4SOIwbeta2 = 0.0; + if (!model->B4SOIwvdsatii0Given) + model->B4SOIwvdsatii0 = 0.0; + if (!model->B4SOIwliiGiven) + model->B4SOIwlii = 0.0; + if (!model->B4SOIwesatiiGiven) + model->B4SOIwesatii = 0.0; + if (!model->B4SOIwsii0Given) + model->B4SOIwsii0 = 0.0; + if (!model->B4SOIwsii1Given) + model->B4SOIwsii1 = 0.0; + if (!model->B4SOIwsii2Given) + model->B4SOIwsii2 = 0.0; + if (!model->B4SOIwsiidGiven) + model->B4SOIwsiid = 0.0; + if (!model->B4SOIwagidlGiven) + model->B4SOIwagidl = 0.0; + if (!model->B4SOIwbgidlGiven) + model->B4SOIwbgidl = 0.0; + if (!model->B4SOIwcgidlGiven) + model->B4SOIwcgidl = 0.0; + if (!model->B4SOIwntunGiven) /* v4.0 */ + model->B4SOIwntun = 0.0; + if (!model->B4SOIwntundGiven) /* v4.0 */ + model->B4SOIwntund = model->B4SOIwntun; + if (!model->B4SOIwndiodeGiven) /* v4.0 */ + model->B4SOIwndiode = 0.0; + if (!model->B4SOIwndiodedGiven) /* v4.0 */ + model->B4SOIwndioded = model->B4SOIwndiode; + if (!model->B4SOIwnrecf0Given) /* v4.0 */ + model->B4SOIwnrecf0 = 0.0; + if (!model->B4SOIwnrecf0dGiven) /* v4.0 */ + model->B4SOIwnrecf0d = model->B4SOIwnrecf0; + if (!model->B4SOIwnrecr0Given) /* v4.0 */ + model->B4SOIwnrecr0 = 0.0; + if (!model->B4SOIwnrecr0dGiven) /* v4.0 */ + model->B4SOIwnrecr0d = model->B4SOIwnrecr0; + if (!model->B4SOIwisbjtGiven) + model->B4SOIwisbjt = 0.0; + if (!model->B4SOIwidbjtGiven) + model->B4SOIwidbjt = model->B4SOIwisbjt; + if (!model->B4SOIwisdifGiven) + model->B4SOIwisdif = 0.0; + if (!model->B4SOIwiddifGiven) + model->B4SOIwiddif = model->B4SOIwisdif; /* v4.0 */ + if (!model->B4SOIwisrecGiven) + model->B4SOIwisrec = 0.0; + if (!model->B4SOIwidrecGiven) + model->B4SOIwidrec = model->B4SOIwisrec; + if (!model->B4SOIwistunGiven) + model->B4SOIwistun = 0.0; + if (!model->B4SOIwidtunGiven) + model->B4SOIwidtun = model->B4SOIwistun; + if (!model->B4SOIwvrec0Given) /* v4.0 */ + model->B4SOIwvrec0 = 0; + if (!model->B4SOIwvrec0dGiven) /* v4.0 */ + model->B4SOIwvrec0d = model->B4SOIwvrec0; + if (!model->B4SOIwvtun0Given) /* v4.0 */ + model->B4SOIwvtun0 = 0; + if (!model->B4SOIwvtun0dGiven) /* v4.0 */ + model->B4SOIwvtun0d = model->B4SOIwvtun0; + if (!model->B4SOIwnbjtGiven) + model->B4SOIwnbjt = 0.0; + if (!model->B4SOIwlbjt0Given) + model->B4SOIwlbjt0 = 0.0; + if (!model->B4SOIwvabjtGiven) + model->B4SOIwvabjt = 0.0; + if (!model->B4SOIwaelyGiven) + model->B4SOIwaely = 0.0; + if (!model->B4SOIwahliGiven) /* v4.0 */ + model->B4SOIwahli = 0.0; + if (!model->B4SOIwahlidGiven) /* v4.0 */ + model->B4SOIwahlid = model->B4SOIwahli; + +/* v3.1 added for RF */ + if (!model->B4SOIwxrcrg1Given) + model->B4SOIwxrcrg1 =0.0; + if (!model->B4SOIwxrcrg2Given) + model->B4SOIwxrcrg2 =0.0; +/* v3.1 added for RF end */ + + /* CV Model */ + if (!model->B4SOIwvsdfbGiven) + model->B4SOIwvsdfb = 0.0; + if (!model->B4SOIwvsdthGiven) + model->B4SOIwvsdth = 0.0; + if (!model->B4SOIwdelvtGiven) + model->B4SOIwdelvt = 0.0; + if (!model->B4SOIwacdeGiven) + model->B4SOIwacde = 0.0; + if (!model->B4SOIwmoinGiven) + model->B4SOIwmoin = 0.0; + if (!model->B4SOIwnoffGiven) + model->B4SOIwnoff = 0.0; /* v3.2 */ + + /* Cross-term dependence */ +/* v3.1 */ + if (!model->B4SOIpxjGiven) + model->B4SOIpxj = 0.0; + if (!model->B4SOIpalphaGB1Given) + model->B4SOIpalphaGB1 = 0.0; + if (!model->B4SOIpalphaGB2Given) + model->B4SOIpalphaGB2 = 0.0; + if (!model->B4SOIpbetaGB1Given) + model->B4SOIpbetaGB1 = 0.0; + if (!model->B4SOIpbetaGB2Given) + model->B4SOIpbetaGB2 = 0.0; + if (!model->B4SOIpndifGiven) + model->B4SOIpndif = 0.0; + if (!model->B4SOIpntrecfGiven) + model->B4SOIpntrecf = 0.0; + if (!model->B4SOIpntrecrGiven) + model->B4SOIpntrecr = 0.0; + if (!model->B4SOIpxbjtGiven) + model->B4SOIpxbjt = 0.0; + if (!model->B4SOIpxdifGiven) + model->B4SOIpxdif = 0.0; + if (!model->B4SOIpxrecGiven) + model->B4SOIpxrec = 0.0; + if (!model->B4SOIpxtunGiven) + model->B4SOIpxtun = 0.0; + if (!model->B4SOIpxdifdGiven) + model->B4SOIpxdifd = model->B4SOIpxdif; + if (!model->B4SOIpxrecdGiven) + model->B4SOIpxrecd = model->B4SOIpxrec; + if (!model->B4SOIpxtundGiven) + model->B4SOIpxtund = model->B4SOIpxtun; + if (!model->B4SOIpcgdlGiven) + model->B4SOIpcgdl = 0.0; + if (!model->B4SOIpcgslGiven) + model->B4SOIpcgsl = 0.0; + if (!model->B4SOIpckappaGiven) + model->B4SOIpckappa = 0.0; + if (!model->B4SOIputeGiven) + model->B4SOIpute = 0.0; + if (!model->B4SOIpkt1Given) + model->B4SOIpkt1 = 0.0; + if (!model->B4SOIpkt2Given) + model->B4SOIpkt2 = 0.0; + if (!model->B4SOIpkt1lGiven) + model->B4SOIpkt1l = 0.0; + if (!model->B4SOIpua1Given) + model->B4SOIpua1 = 0.0; + if (!model->B4SOIpub1Given) + model->B4SOIpub1 = 0.0; + if (!model->B4SOIpuc1Given) + model->B4SOIpuc1 = 0.0; + if (!model->B4SOIpatGiven) + model->B4SOIpat = 0.0; + if (!model->B4SOIpprtGiven) + model->B4SOIpprt = 0.0; + + +/* v3.0 */ + if (!model->B4SOIpnigcGiven) + model->B4SOIpnigc = 0.0; + if (!model->B4SOIppigcdGiven) + model->B4SOIppigcd = 0.0; + if (!model->B4SOIppoxedgeGiven) + model->B4SOIppoxedge = 0.0; + if (!model->B4SOIpaigcGiven) + model->B4SOIpaigc = 0.0; + if (!model->B4SOIpbigcGiven) + model->B4SOIpbigc = 0.0; + if (!model->B4SOIpcigcGiven) + model->B4SOIpcigc = 0.0; + if (!model->B4SOIpaigsdGiven) + model->B4SOIpaigsd = 0.0; + if (!model->B4SOIpbigsdGiven) + model->B4SOIpbigsd = 0.0; + if (!model->B4SOIpcigsdGiven) + model->B4SOIpcigsd = 0.0; + + if (!model->B4SOIpnpeakGiven) + model->B4SOIpnpeak = 0.0; + if (!model->B4SOIpnsubGiven) + model->B4SOIpnsub = 0.0; + if (!model->B4SOIpngateGiven) + model->B4SOIpngate = 0.0; + if (!model->B4SOIpvth0Given) + model->B4SOIpvth0 = 0.0; + if (!model->B4SOIpk1Given) + model->B4SOIpk1 = 0.0; + if (!model->B4SOIpk1w1Given) + model->B4SOIpk1w1 = 0.0; + if (!model->B4SOIpk1w2Given) + model->B4SOIpk1w2 = 0.0; + if (!model->B4SOIpk2Given) + model->B4SOIpk2 = 0.0; + if (!model->B4SOIpk3Given) + model->B4SOIpk3 = 0.0; + if (!model->B4SOIpk3bGiven) + model->B4SOIpk3b = 0.0; + if (!model->B4SOIpkb1Given) + model->B4SOIpkb1 = 0.0; + if (!model->B4SOIpw0Given) + model->B4SOIpw0 = 0.0; + if (!model->B4SOIplpebGiven) + model->B4SOIplpeb = 0.0; + if (!model->B4SOIpdvt0Given) + model->B4SOIpdvt0 = 0.0; + if (!model->B4SOIpdvt1Given) + model->B4SOIpdvt1 = 0.0; + if (!model->B4SOIpdvt2Given) + model->B4SOIpdvt2 = 0.0; + if (!model->B4SOIpdvt0wGiven) + model->B4SOIpdvt0w = 0.0; + if (!model->B4SOIpdvt1wGiven) + model->B4SOIpdvt1w = 0.0; + if (!model->B4SOIpdvt2wGiven) + model->B4SOIpdvt2w = 0.0; + if (!model->B4SOIpu0Given) + model->B4SOIpu0 = 0.0; + if (!model->B4SOIpuaGiven) + model->B4SOIpua = 0.0; + if (!model->B4SOIpubGiven) + model->B4SOIpub = 0.0; + if (!model->B4SOIpucGiven) + model->B4SOIpuc = 0.0; + if (!model->B4SOIpvsatGiven) + model->B4SOIpvsat = 0.0; + if (!model->B4SOIpa0Given) + model->B4SOIpa0 = 0.0; + if (!model->B4SOIpagsGiven) + model->B4SOIpags = 0.0; + if (!model->B4SOIpb0Given) + model->B4SOIpb0 = 0.0; + if (!model->B4SOIpb1Given) + model->B4SOIpb1 = 0.0; + if (!model->B4SOIpketaGiven) + model->B4SOIpketa = 0.0; + if (!model->B4SOIpketasGiven) + model->B4SOIpketas = 0.0; + if (!model->B4SOIpa1Given) + model->B4SOIpa1 = 0.0; + if (!model->B4SOIpa2Given) + model->B4SOIpa2 = 0.0; + if (!model->B4SOIprdswGiven) + model->B4SOIprdsw = 0.0; + if (!model->B4SOIprswGiven) /* v4.0 */ + model->B4SOIprsw = 0.0; + if (!model->B4SOIprdwGiven) /* v4.0 */ + model->B4SOIprdw = 0.0; + if (!model->B4SOIpprwbGiven) + model->B4SOIpprwb = 0.0; + if (!model->B4SOIpprwgGiven) + model->B4SOIpprwg = 0.0; + if (!model->B4SOIpwrGiven) + model->B4SOIpwr = 0.0; + if (!model->B4SOIpnfactorGiven) + model->B4SOIpnfactor = 0.0; + if (!model->B4SOIpdwgGiven) + model->B4SOIpdwg = 0.0; + if (!model->B4SOIpdwbGiven) + model->B4SOIpdwb = 0.0; + if (!model->B4SOIpvoffGiven) + model->B4SOIpvoff = 0.0; + if (!model->B4SOIpeta0Given) + model->B4SOIpeta0 = 0.0; + if (!model->B4SOIpetabGiven) + model->B4SOIpetab = 0.0; + if (!model->B4SOIpdsubGiven) + model->B4SOIpdsub = 0.0; + if (!model->B4SOIpcitGiven) + model->B4SOIpcit = 0.0; + if (!model->B4SOIpcdscGiven) + model->B4SOIpcdsc = 0.0; + if (!model->B4SOIpcdscbGiven) + model->B4SOIpcdscb = 0.0; + if (!model->B4SOIpcdscdGiven) + model->B4SOIpcdscd = 0.0; + if (!model->B4SOIppclmGiven) + model->B4SOIppclm = 0.0; + if (!model->B4SOIppdibl1Given) + model->B4SOIppdibl1 = 0.0; + if (!model->B4SOIppdibl2Given) + model->B4SOIppdibl2 = 0.0; + if (!model->B4SOIppdiblbGiven) + model->B4SOIppdiblb = 0.0; + if (!model->B4SOIpdroutGiven) + model->B4SOIpdrout = 0.0; + if (!model->B4SOIppvagGiven) + model->B4SOIppvag = 0.0; + if (!model->B4SOIpdeltaGiven) + model->B4SOIpdelta = 0.0; + if (!model->B4SOIpalpha0Given) + model->B4SOIpalpha0 = 0.0; + if (!model->B4SOIpfbjtiiGiven) + model->B4SOIpfbjtii = 0.0; + if (!model->B4SOIpbeta0Given) + model->B4SOIpbeta0 = 0.0; + if (!model->B4SOIpbeta1Given) + model->B4SOIpbeta1 = 0.0; + if (!model->B4SOIpbeta2Given) + model->B4SOIpbeta2 = 0.0; + if (!model->B4SOIpvdsatii0Given) + model->B4SOIpvdsatii0 = 0.0; + if (!model->B4SOIpliiGiven) + model->B4SOIplii = 0.0; + if (!model->B4SOIpesatiiGiven) + model->B4SOIpesatii = 0.0; + if (!model->B4SOIpsii0Given) + model->B4SOIpsii0 = 0.0; + if (!model->B4SOIpsii1Given) + model->B4SOIpsii1 = 0.0; + if (!model->B4SOIpsii2Given) + model->B4SOIpsii2 = 0.0; + if (!model->B4SOIpsiidGiven) + model->B4SOIpsiid = 0.0; + if (!model->B4SOIpagidlGiven) + model->B4SOIpagidl = 0.0; + if (!model->B4SOIpbgidlGiven) + model->B4SOIpbgidl = 0.0; + if (!model->B4SOIpcgidlGiven) + model->B4SOIpcgidl = 0.0; + if (!model->B4SOIpntunGiven) /* v4.0 */ + model->B4SOIpntun = 0.0; + if (!model->B4SOIpntundGiven) /* v4.0 */ + model->B4SOIpntund = model->B4SOIpntun; + if (!model->B4SOIpndiodeGiven) /* v4.0 */ + model->B4SOIpndiode = 0.0; + if (!model->B4SOIpndiodedGiven) /* v4.0 */ + model->B4SOIpndioded = model->B4SOIpndiode; + if (!model->B4SOIpnrecf0Given) /* v4.0 */ + model->B4SOIpnrecf0 = 0.0; + if (!model->B4SOIpnrecf0dGiven) /* v4.0 */ + model->B4SOIpnrecf0d = model->B4SOIpnrecf0; + if (!model->B4SOIpnrecr0Given) /* v4.0 */ + model->B4SOIpnrecr0 = 0.0; + if (!model->B4SOIpnrecr0dGiven) /* v4.0 */ + model->B4SOIpnrecr0d = model->B4SOIpnrecr0; + if (!model->B4SOIpisbjtGiven) + model->B4SOIpisbjt = 0.0; + if (!model->B4SOIpidbjtGiven) + model->B4SOIpidbjt = model->B4SOIpisbjt; + if (!model->B4SOIpisdifGiven) + model->B4SOIpisdif = 0.0; + if (!model->B4SOIpiddifGiven) + model->B4SOIpiddif = model->B4SOIpisdif; /* v4.0 */ + if (!model->B4SOIpisrecGiven) + model->B4SOIpisrec = 0.0; + if (!model->B4SOIpidrecGiven) + model->B4SOIpidrec = model->B4SOIpisrec; + if (!model->B4SOIpistunGiven) + model->B4SOIpistun = 0.0; + if (!model->B4SOIpidtunGiven) + model->B4SOIpidtun = model->B4SOIpistun; + if (!model->B4SOIpvrec0Given) /* v4.0 */ + model->B4SOIpvrec0 = 0.0; + if (!model->B4SOIpvrec0dGiven) /* v4.0 */ + model->B4SOIpvrec0d = model->B4SOIpvrec0; + if (!model->B4SOIpvtun0Given) /* v4.0 */ + model->B4SOIpvtun0 = 0.0; + if (!model->B4SOIpvtun0dGiven) /* v4.0 */ + model->B4SOIpvtun0d = model->B4SOIpvtun0; + if (!model->B4SOIpnbjtGiven) + model->B4SOIpnbjt = 0.0; + if (!model->B4SOIplbjt0Given) + model->B4SOIplbjt0 = 0.0; + if (!model->B4SOIpvabjtGiven) + model->B4SOIpvabjt = 0.0; + if (!model->B4SOIpaelyGiven) + model->B4SOIpaely = 0.0; + if (!model->B4SOIpahliGiven) /* v4.0 */ + model->B4SOIpahli = 0.0; + if (!model->B4SOIpahlidGiven) /* v4.0 */ + model->B4SOIpahlid = model->B4SOIpahli; + +/* v3.1 for RF */ + if (!model->B4SOIpxrcrg1Given) + model->B4SOIpxrcrg1 =0.0; + if (!model->B4SOIpxrcrg2Given) + model->B4SOIpxrcrg2 =0.0; +/* v3.1 for RF end */ + + /* CV Model */ + if (!model->B4SOIpvsdfbGiven) + model->B4SOIpvsdfb = 0.0; + if (!model->B4SOIpvsdthGiven) + model->B4SOIpvsdth = 0.0; + if (!model->B4SOIpdelvtGiven) + model->B4SOIpdelvt = 0.0; + if (!model->B4SOIpacdeGiven) + model->B4SOIpacde = 0.0; + if (!model->B4SOIpmoinGiven) + model->B4SOIpmoin = 0.0; + if (!model->B4SOIpnoffGiven) + model->B4SOIpnoff = 0.0; /* v3.2 */ +/* Added for binning - END */ + + if (!model->B4SOIcfGiven) + model->B4SOIcf = 2.0 * EPSOX / PI + * log(1.0 + 0.4e-6 / model->B4SOItox); + if (!model->B4SOIcgdoGiven) + { if (model->B4SOIdlcGiven && (model->B4SOIdlc > 0.0)) + { model->B4SOIcgdo = model->B4SOIdlc * model->B4SOIcox + - model->B4SOIcgdl ; + } + else + model->B4SOIcgdo = 0.6 * model->B4SOIxj * model->B4SOIcox; + } + if (!model->B4SOIcgsoGiven) + { if (model->B4SOIdlcGiven && (model->B4SOIdlc > 0.0)) + { model->B4SOIcgso = model->B4SOIdlc * model->B4SOIcox + - model->B4SOIcgsl ; + } + else + model->B4SOIcgso = 0.6 * model->B4SOIxj * model->B4SOIcox; + } + + if (!model->B4SOIcgeoGiven) + { model->B4SOIcgeo = 0.0; + } + if (!model->B4SOIxpartGiven) + model->B4SOIxpart = 0.0; + if (!model->B4SOIsheetResistanceGiven) + model->B4SOIsheetResistance = 0.0; + if (!model->B4SOIcsdeswGiven) + model->B4SOIcsdesw = 0.0; + if (!model->B4SOIunitLengthGateSidewallJctCapSGiven) /* v4.0 */ + model->B4SOIunitLengthGateSidewallJctCapS = 1e-10; + if (!model->B4SOIunitLengthGateSidewallJctCapDGiven) /* v4.0 */ + model->B4SOIunitLengthGateSidewallJctCapD = model->B4SOIunitLengthGateSidewallJctCapS; + if (!model->B4SOIGatesidewallJctSPotentialGiven) /* v4.0 */ + model->B4SOIGatesidewallJctSPotential = 0.7; + if (!model->B4SOIGatesidewallJctDPotentialGiven) /* v4.0 */ + model->B4SOIGatesidewallJctDPotential = model->B4SOIGatesidewallJctSPotential; + if (!model->B4SOIbodyJctGateSideSGradingCoeffGiven) /* v4.0 */ + model->B4SOIbodyJctGateSideSGradingCoeff = 0.5; + if (!model->B4SOIbodyJctGateSideDGradingCoeffGiven) /* v4.0 */ + model->B4SOIbodyJctGateSideDGradingCoeff = model->B4SOIbodyJctGateSideSGradingCoeff; + if (!model->B4SOIoxideTrapDensityAGiven) + { if (model->B4SOItype == NMOS) + model->B4SOIoxideTrapDensityA = 6.25e41; + else + model->B4SOIoxideTrapDensityA=6.188e40; + } + if (!model->B4SOIoxideTrapDensityBGiven) + { if (model->B4SOItype == NMOS) + model->B4SOIoxideTrapDensityB = 3.125e26; + else + model->B4SOIoxideTrapDensityB = 1.5e25; + } + if (!model->B4SOIoxideTrapDensityCGiven) + model->B4SOIoxideTrapDensityC = 8.75e9; + + if (!model->B4SOIemGiven) + model->B4SOIem = 4.1e7; /* V/m */ + if (!model->B4SOIefGiven) + model->B4SOIef = 1.0; + if (!model->B4SOIafGiven) + model->B4SOIaf = 1.0; + if (!model->B4SOIkfGiven) + model->B4SOIkf = 0.0; + if (!model->B4SOInoifGiven) + model->B4SOInoif = 1.0; + if (!model->B4SOIbfGiven) /* v4.0 */ + model->B4SOIbf = 2.0; + if (!model->B4SOIw0flkGiven) /* v4.0 */ + model->B4SOIw0flk = 10.0e-6; + if (!model->B4SOIfrbodyGiven) /* v4.0 */ + model->B4SOIfrbody = 1; + if (!model->B4SOIdvtp0Given) /* v4.0 for Vth */ + model->B4SOIdvtp0 = 0.0; + if (!model->B4SOIdvtp1Given) /* v4.0 for Vth */ + model->B4SOIdvtp1 = 0.0; + if (!model->B4SOIldvtp0Given) /* v4.0 for Vth */ + model->B4SOIldvtp0 = 0.0; + if (!model->B4SOIldvtp1Given) /* v4.0 for Vth */ + model->B4SOIldvtp1 = 0.0; + if (!model->B4SOIwdvtp0Given) /* v4.0 for Vth */ + model->B4SOIwdvtp0 = 0.0; + if (!model->B4SOIwdvtp1Given) /* v4.0 for Vth */ + model->B4SOIwdvtp1 = 0.0; + if (!model->B4SOIpdvtp0Given) /* v4.0 for Vth */ + model->B4SOIpdvtp0 = 0.0; + if (!model->B4SOIpdvtp1Given) /* v4.0 for Vth */ + model->B4SOIpdvtp1 = 0.0; + if (!model->B4SOIminvGiven) /* v4.0 for Vgsteff */ + model->B4SOIminv = 0.0; + if (!model->B4SOIlminvGiven) /* v4.0 for Vgsteff */ + model->B4SOIlminv = 0.0; + if (!model->B4SOIwminvGiven) /* v4.0 for Vgsteff */ + model->B4SOIwminv = 0.0; + if (!model->B4SOIpminvGiven) /* v4.0 for Vgsteff */ + model->B4SOIpminv = 0.0; + if (!model->B4SOIfproutGiven) /* v4.0 for DITS in Id */ + model->B4SOIfprout = 0.0; + if (!model->B4SOIpditsGiven) + model->B4SOIpdits = 1e-20; + if (!model->B4SOIpditsdGiven) + model->B4SOIpditsd = 0.0; + if (!model->B4SOIpditslGiven) + model->B4SOIpditsl = 0.0; + if (!model->B4SOIlfproutGiven) + model->B4SOIlfprout = 0.0; + if (!model->B4SOIlpditsGiven) + model->B4SOIlpdits = 0.0; + if (!model->B4SOIlpditsdGiven) + model->B4SOIlpditsd = 0.0; + if (!model->B4SOIwfproutGiven) + model->B4SOIwfprout = 0.0; + if (!model->B4SOIwpditsGiven) + model->B4SOIwpdits = 0.0; + if (!model->B4SOIwpditsdGiven) + model->B4SOIwpditsd = 0.0; + if (!model->B4SOIpfproutGiven) + model->B4SOIpfprout = 0.0; + if (!model->B4SOIppditsGiven) + model->B4SOIppdits = 0.0; + if (!model->B4SOIppditsdGiven) + model->B4SOIppditsd = 0.0; + +/* v4.0 stress effect */ + if (!model->B4SOIsarefGiven) + model->B4SOIsaref = 1e-6; /* m */ + if (!model->B4SOIsbrefGiven) + model->B4SOIsbref = 1e-6; /* m */ + if (!model->B4SOIwlodGiven) + model->B4SOIwlod = 0; /* m */ + if (!model->B4SOIku0Given) + model->B4SOIku0 = 0; /* 1/m */ + if (!model->B4SOIkvsatGiven) + model->B4SOIkvsat = 0; + if (!model->B4SOIkvth0Given) /* m */ + model->B4SOIkvth0 = 0; + if (!model->B4SOItku0Given) + model->B4SOItku0 = 0; + if (!model->B4SOIllodku0Given) + model->B4SOIllodku0 = 0; + if (!model->B4SOIwlodku0Given) + model->B4SOIwlodku0 = 0; + if (!model->B4SOIllodvthGiven) + model->B4SOIllodvth = 0; + if (!model->B4SOIwlodvthGiven) + model->B4SOIwlodvth = 0; + if (!model->B4SOIlku0Given) + model->B4SOIlku0 = 0; + if (!model->B4SOIwku0Given) + model->B4SOIwku0 = 0; + if (!model->B4SOIpku0Given) + model->B4SOIpku0 = 0; + if (!model->B4SOIlkvth0Given) + model->B4SOIlkvth0 = 0; + if (!model->B4SOIwkvth0Given) + model->B4SOIwkvth0 = 0; + if (!model->B4SOIpkvth0Given) + model->B4SOIpkvth0 = 0; + if (!model->B4SOIstk2Given) + model->B4SOIstk2 = 0; + if (!model->B4SOIlodk2Given) + model->B4SOIlodk2 = 1.0; + if (!model->B4SOIsteta0Given) + model->B4SOIsteta0 = 0; + if (!model->B4SOIlodeta0Given) + model->B4SOIlodeta0 = 1.0; +/* stress effect end */ + + /* loop through all the instances of the model */ + for (here = model->B4SOIinstances; here != NULL ; + here=here->B4SOInextInstance) + { + if (here->B4SOIowner == ARCHme) + { + /* allocate a chunk of the state vector */ + here->B4SOIstates = *states; + *states += B4SOInumStates; + } + /* perform the parameter defaulting */ + if (!here->B4SOIdrainAreaGiven) + here->B4SOIdrainArea = 0.0; + if (!here->B4SOIdrainPerimeterGiven) + here->B4SOIdrainPerimeter = 0.0; + if (!here->B4SOIdrainSquaresGiven) + here->B4SOIdrainSquares = 1.0; + if (!here->B4SOIicVBSGiven) + here->B4SOIicVBS = 0; + if (!here->B4SOIicVDSGiven) + here->B4SOIicVDS = 0; + if (!here->B4SOIicVGSGiven) + here->B4SOIicVGS = 0; + if (!here->B4SOIicVESGiven) + here->B4SOIicVES = 0; + if (!here->B4SOIicVPSGiven) + here->B4SOIicVPS = 0; + if (!here->B4SOIbjtoffGiven) + here->B4SOIbjtoff = 0; + if (!here->B4SOIdebugModGiven) + here->B4SOIdebugMod = 0; + if (!here->B4SOIrth0Given) + here->B4SOIrth0 = model->B4SOIrth0; + if (!here->B4SOIcth0Given) + here->B4SOIcth0 = model->B4SOIcth0; + if (!here->B4SOIbodySquaresGiven) + here->B4SOIbodySquares = 1.0; + if (!here->B4SOIfrbodyGiven) + here->B4SOIfrbody = model->B4SOIfrbody; /* v4.0 */ + if (!here->B4SOIlGiven) + here->B4SOIl = 5e-6; + if (!here->B4SOIsourceAreaGiven) + here->B4SOIsourceArea = 0; + if (!here->B4SOIsourcePerimeterGiven) + here->B4SOIsourcePerimeter = 0; + if (!here->B4SOIsourceSquaresGiven) + here->B4SOIsourceSquares = 1; + if (!here->B4SOIwGiven) + here->B4SOIw = 5e-6; + if (!here->B4SOImGiven) + here->B4SOIm = 1; + +/* v2.0 release */ + if (!here->B4SOInbcGiven) + here->B4SOInbc = 0; + if (!here->B4SOInsegGiven) + here->B4SOInseg = 1; + if (!here->B4SOIpdbcpGiven) + here->B4SOIpdbcp = 0; + if (!here->B4SOIpsbcpGiven) + here->B4SOIpsbcp = 0; + if (!here->B4SOIagbcpGiven) + here->B4SOIagbcp = 0; + if (!here->B4SOIagbcpdGiven) + here->B4SOIagbcpd = here->B4SOIagbcp; + if (!here->B4SOIaebcpGiven) + here->B4SOIaebcp = 0; + + if (!here->B4SOIoffGiven) + here->B4SOIoff = 0; + + /* process drain series resistance */ + if ( ((model->B4SOIsheetResistance > 0.0) && + (here->B4SOIdrainSquares > 0.0 ) && + (here->B4SOIdNodePrime == 0)) ) + { error = CKTmkVolt(ckt,&tmp,here->B4SOIname,"drain"); + if(error) return(error); + here->B4SOIdNodePrime = tmp->number; + if (ckt->CKTcopyNodesets) { + if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) { + if (tmpNode->nsGiven) { + tmp->nodeset=tmpNode->nodeset; + tmp->nsGiven=tmpNode->nsGiven; + } + } + } + } + else + { here->B4SOIdNodePrime = here->B4SOIdNode; + } + + /* process source series resistance */ + if ( ((model->B4SOIsheetResistance > 0.0) && + (here->B4SOIsourceSquares > 0.0 ) && + (here->B4SOIsNodePrime == 0)) ) + { error = CKTmkVolt(ckt,&tmp,here->B4SOIname,"source"); + if(error) return(error); + here->B4SOIsNodePrime = tmp->number; + if (ckt->CKTcopyNodesets) { + if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) { + if (tmpNode->nsGiven) { + tmp->nodeset=tmpNode->nodeset; + tmp->nsGiven=tmpNode->nsGiven; + } + } + } + } + else + { here->B4SOIsNodePrime = here->B4SOIsNode; + } + + /* process effective silicon film thickness */ + model->B4SOIcbox = 3.453133e-11 / model->B4SOItbox; + model->B4SOIcsi = 1.03594e-10 / model->B4SOItsi; + Cboxt = model->B4SOIcbox * model->B4SOIcsi / (model->B4SOIcbox + model->B4SOIcsi); + + +/* v3.2 */ + Qsi = Charge_q * model->B4SOInpeak + * (1.0 + model->B4SOIlpe0 / here->B4SOIl) * 1e6 * model->B4SOItsi; + Vbs0t = 0.8 - 0.5 * Qsi / model->B4SOIcsi + model->B4SOIvbsa; + + if (!here->B4SOIsoiModGiven) + here->B4SOIsoiMod = model->B4SOIsoiMod; + else if ((here->B4SOIsoiMod != 0) && (here->B4SOIsoiMod != 1) + && (here->B4SOIsoiMod != 2) && (here->B4SOIsoiMod != 3)) + { here->B4SOIsoiMod = model->B4SOIsoiMod; + printf("Warning: soiMod has been set to its global value %d.\n", model->B4SOIsoiMod); + } + + if (here->B4SOIsoiMod == 3) /* auto selection */ + if (Vbs0t > model->B4SOIvbs0fd) + here->B4SOIsoiMod = 2; /* ideal FD mode */ + else + if (Vbs0t < model->B4SOIvbs0pd) + here->B4SOIsoiMod = 0; /* BSIMPD */ + else + here->B4SOIsoiMod = 1; + + + here->B4SOIfloat = 0; + if (here->B4SOIsoiMod == 2) /* v3.2 */ + { + here->B4SOIbNode = here->B4SOIpNode = 0; + here->B4SOIbodyMod = 0; + } /* For ideal FD, body contact is disabled and no body node */ + else + { + if (here->B4SOIpNode == -1) { /* floating body case -- 4-node */ + error = CKTmkVolt(ckt,&tmp,here->B4SOIname,"Body"); + if (error) return(error); + here->B4SOIbNode = tmp->number; + here->B4SOIpNode = 0; + here->B4SOIfloat = 1; + here->B4SOIbodyMod = 0; + + } + else /* the 5th Node has been assigned */ + { + if (!here->B4SOItnodeoutGiven) { /* if t-node not assigned */ + if (here->B4SOIbNode == -1) + { /* 5-node body tie, bNode has not been assigned */ + if ((model->B4SOIrbody == 0.0) && (model->B4SOIrbsh == 0.0)) + { /* ideal body tie, pNode is not used */ + here->B4SOIbNode = here->B4SOIpNode; + here->B4SOIbodyMod = 2; + } + else { /* nonideal body tie */ + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Body"); + if (error) return(error); + here->B4SOIbNode = tmp->number; + here->B4SOIbodyMod = 1; + } + } + else { /* 6-node body tie, bNode has been assigned */ + if ((model->B4SOIrbody == 0.0) && (model->B4SOIrbsh == 0.0)) + { + printf("\n Warning: model parameter rbody=0!\n"); + model->B4SOIrbody = 1e0; + here->B4SOIbodyMod = 1; + } + else { /* nonideal body tie */ + here->B4SOIbodyMod = 1; + } + } + } + else { /* t-node assigned */ + if (here->B4SOIbNode == -1) + { /* 4 nodes & t-node, floating body */ + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Body"); + if (error) return(error); + here->B4SOIbNode = tmp->number; + here->B4SOItempNode = here->B4SOIpNode; + here->B4SOIpNode = 0; + here->B4SOIfloat = 1; + here->B4SOIbodyMod = 0; + } + else { /* 5 or 6 nodes & t-node, body-contact device */ + if (here->B4SOItempNode == -1) { /* 5 nodes & tnode */ + if ((model->B4SOIrbody == 0.0) && (model->B4SOIrbsh == 0.0)) + { /* ideal body tie, pNode is not used */ + here->B4SOItempNode = here->B4SOIbNode; + here->B4SOIbNode = here->B4SOIpNode; + here->B4SOIbodyMod = 2; + } + else { /* nonideal body tie */ + here->B4SOItempNode = here->B4SOIbNode; + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Body"); + if (error) return(error); + here->B4SOIbNode = tmp->number; + here->B4SOIbodyMod = 1; + } + } + else { /* 6 nodes & t-node */ + if ((model->B4SOIrbody == 0.0) && (model->B4SOIrbsh == 0.0)) + { + printf("\n Warning: model parameter rbody=0!\n"); + model->B4SOIrbody = 1e0; + here->B4SOIbodyMod = 1; + } + else { /* nonideal body tie */ + here->B4SOIbodyMod = 1; + } + } + } + } + } + } + + + if ((model->B4SOIshMod == 1) && (here->B4SOIrth0!=0)) + { + if (here->B4SOItempNode == -1) { + error = CKTmkVolt(ckt,&tmp,here->B4SOIname,"Temp"); + if (error) return(error); + here->B4SOItempNode = tmp->number; + } + + } else { + here->B4SOItempNode = 0; + } + +/* v3.1 added for RF */ + if (!here->B4SOIrgateModGiven) + here->B4SOIrgateMod = model->B4SOIrgateMod; + else if ((here->B4SOIrgateMod != 0) && (here->B4SOIrgateMod != 1) + && (here->B4SOIrgateMod != 2) && (here->B4SOIrgateMod != 3)) + { here->B4SOIrgateMod = model->B4SOIrgateMod; + printf("Warning: rgateMod has been set to its global value %d.\n", model->B4SOIrgateMod); + } + + if (here->B4SOIrgateMod > 0) + { error = CKTmkVolt(ckt,&tmp,here->B4SOIname,"gate"); + if(error) return(error); + here->B4SOIgNode = tmp->number; + if (here->B4SOIrgateMod == 1) + { if (model->B4SOIrshg <= 0.0) + printf("Warning: rshg should be positive for rgateMod = 1.\n"); + } + else if (here->B4SOIrgateMod == 2) + { if (model->B4SOIrshg <= 0.0) + printf("Warning: rshg <= 0.0 for rgateMod = 2!!!\n"); + else if (model->B4SOIxrcrg1 <= 0.0) + printf("Warning: xrcrg1 <= 0.0 for rgateMod = 2!!!\n"); + } + } + else + { + here->B4SOIgNode = here->B4SOIgNodeExt; + } + + if (here->B4SOIrgateMod == 3) + { error = CKTmkVolt(ckt,&tmp,here->B4SOIname,"midgate"); + if(error) return(error); + here->B4SOIgNodeMid = tmp->number; + if (model->B4SOIrshg <= 0.0) + printf("Warning: rshg should be positive for rgateMod = 3.\n"); + else if (model->B4SOIxrcrg1 <= 0.0) + printf("Warning: xrcrg1 should be positive for rgateMod = 3. \n"); + } + else + here->B4SOIgNodeMid = here->B4SOIgNodeExt; +/* v3.1 added for RF end */ + +/* v4.0 */ + if (!here->B4SOIrbodyModGiven) + here->B4SOIrbodyMod = model->B4SOIrbodyMod; + else if ((here->B4SOIrbodyMod != 0) && (here->B4SOIrbodyMod != 1)) + { here->B4SOIrbodyMod = model->B4SOIrbodyMod; + printf("Warning: rbodyMod has been set to its global value %d. \n", model->B4SOIrbodyMod); + } + + if (here->B4SOIrbodyMod ==1 && here->B4SOIsoiMod == 2) /* v4.0 */ + here->B4SOIrbodyMod = 0; + + if (here->B4SOIrbodyMod == 1) + { if (here->B4SOIdbNode == 0) + { error = CKTmkVolt(ckt,&tmp,here->B4SOIname,"dbody"); + if(error) return(error); + here->B4SOIdbNode = tmp->number; + } + if (here->B4SOIsbNode == 0) + { error = CKTmkVolt(ckt,&tmp,here->B4SOIname,"sbody"); + if(error) return(error); + here->B4SOIsbNode = tmp->number; + } + } + else + here->B4SOIdbNode = here->B4SOIsbNode + = here->B4SOIbNode; + +/* v4.0 end */ + + /* v4.0 added */ + if (!here->B4SOIsaGiven) /* stress */ + here->B4SOIsa = 0.0; + if (!here->B4SOIsbGiven) + here->B4SOIsb = 0.0; + if (!here->B4SOIsdGiven) + here->B4SOIsd = 0.0; + if (!here->B4SOInfGiven) + here->B4SOInf = 1.0; + if (!here->B4SOIrbdbGiven) + here->B4SOIrbdb = model->B4SOIrbdb; /* in ohm */ + if (!here->B4SOIrbsbGiven) + here->B4SOIrbsb = model->B4SOIrbsb; + if (!here->B4SOIdelvtoGiven) + here->B4SOIdelvto = 0.0; + + /* v4.0 added end */ + + +/* here for debugging purpose only */ + if (here->B4SOIdebugMod != 0) + { + /* The real Vbs value */ + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Vbs"); + if(error) return(error); + here->B4SOIvbsNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Ids"); + if(error) return(error); + here->B4SOIidsNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Ic"); + if(error) return(error); + here->B4SOIicNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Ibs"); + if(error) return(error); + here->B4SOIibsNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Ibd"); + if(error) return(error); + here->B4SOIibdNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Iii"); + if(error) return(error); + here->B4SOIiiiNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Ig"); + if(error) return(error); + here->B4SOIigNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Gigg"); + if(error) return(error); + here->B4SOIgiggNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Gigd"); + if(error) return(error); + here->B4SOIgigdNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Gigb"); + if(error) return(error); + here->B4SOIgigbNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Igidl"); + if(error) return(error); + here->B4SOIigidlNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Itun"); + if(error) return(error); + here->B4SOIitunNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Ibp"); + if(error) return(error); + here->B4SOIibpNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Cbb"); + if(error) return(error); + here->B4SOIcbbNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Cbd"); + if(error) return(error); + here->B4SOIcbdNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Cbg"); + if(error) return(error); + here->B4SOIcbgNode = tmp->number; + + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Qbf"); + if(error) return(error); + here->B4SOIqbfNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Qjs"); + if(error) return(error); + here->B4SOIqjsNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B4SOIname, "Qjd"); + if(error) return(error); + here->B4SOIqjdNode = tmp->number; + + + } + + /* set Sparse Matrix Pointers */ + +/* macro to make elements with built in test for out of memory */ +#define TSTALLOC(ptr,first,second) \ +if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\ + return(E_NOMEM);\ +} + + + if ((model->B4SOIshMod == 1) && (here->B4SOIrth0!=0.0)) { + TSTALLOC(B4SOITemptempPtr, B4SOItempNode, B4SOItempNode) + TSTALLOC(B4SOITempdpPtr, B4SOItempNode, B4SOIdNodePrime) + TSTALLOC(B4SOITempspPtr, B4SOItempNode, B4SOIsNodePrime) + TSTALLOC(B4SOITempgPtr, B4SOItempNode, B4SOIgNode) + TSTALLOC(B4SOITempbPtr, B4SOItempNode, B4SOIbNode) + + TSTALLOC(B4SOIGtempPtr, B4SOIgNode, B4SOItempNode) + + TSTALLOC(B4SOIDPtempPtr, B4SOIdNodePrime, B4SOItempNode) + TSTALLOC(B4SOISPtempPtr, B4SOIsNodePrime, B4SOItempNode) + TSTALLOC(B4SOIEtempPtr, B4SOIeNode, B4SOItempNode) + TSTALLOC(B4SOIBtempPtr, B4SOIbNode, B4SOItempNode) + + if (here->B4SOIbodyMod == 1) { + TSTALLOC(B4SOIPtempPtr, B4SOIpNode, B4SOItempNode) + } + +/* v3.0 */ + if (here->B4SOIsoiMod != 0) { /* v3.2 */ + TSTALLOC(B4SOITempePtr, B4SOItempNode, B4SOIeNode) + } + + } + if (here->B4SOIbodyMod == 2) { + /* Don't create any Jacobian entry for pNode */ + } + else if (here->B4SOIbodyMod == 1) { + TSTALLOC(B4SOIBpPtr, B4SOIbNode, B4SOIpNode) + TSTALLOC(B4SOIPbPtr, B4SOIpNode, B4SOIbNode) + TSTALLOC(B4SOIPpPtr, B4SOIpNode, B4SOIpNode) + } + +/* v3.1 added for RF */ + if (here->B4SOIrgateMod != 0) + { TSTALLOC(B4SOIGEgePtr, B4SOIgNodeExt, B4SOIgNodeExt) + TSTALLOC(B4SOIGEgPtr, B4SOIgNodeExt, B4SOIgNode) + TSTALLOC(B4SOIGgePtr, B4SOIgNode, B4SOIgNodeExt) + TSTALLOC(B4SOIGEdpPtr, B4SOIgNodeExt, B4SOIdNodePrime) + TSTALLOC(B4SOIGEspPtr, B4SOIgNodeExt, B4SOIsNodePrime) + if (here->B4SOIsoiMod !=2) /* v3.2 */ + TSTALLOC(B4SOIGEbPtr, B4SOIgNodeExt, B4SOIbNode) + + TSTALLOC(B4SOIGMdpPtr, B4SOIgNodeMid, B4SOIdNodePrime) + TSTALLOC(B4SOIGMgPtr, B4SOIgNodeMid, B4SOIgNode) + TSTALLOC(B4SOIGMgmPtr, B4SOIgNodeMid, B4SOIgNodeMid) + TSTALLOC(B4SOIGMgePtr, B4SOIgNodeMid, B4SOIgNodeExt) + TSTALLOC(B4SOIGMspPtr, B4SOIgNodeMid, B4SOIsNodePrime) + if (here->B4SOIsoiMod !=2) /* v3.2 */ + TSTALLOC(B4SOIGMbPtr, B4SOIgNodeMid, B4SOIbNode) + + TSTALLOC(B4SOIGMePtr, B4SOIgNodeMid, B4SOIeNode) + TSTALLOC(B4SOIDPgmPtr, B4SOIdNodePrime, B4SOIgNodeMid) + TSTALLOC(B4SOIGgmPtr, B4SOIgNode, B4SOIgNodeMid) + TSTALLOC(B4SOIGEgmPtr, B4SOIgNodeExt, B4SOIgNodeMid) + TSTALLOC(B4SOISPgmPtr, B4SOIsNodePrime, B4SOIgNodeMid) + TSTALLOC(B4SOIEgmPtr, B4SOIeNode, B4SOIgNodeMid) + } +/* v3.1 added for RF end */ + + +/* v3.1 */ + if (here->B4SOIsoiMod != 2) /* v3.2 */ + { + TSTALLOC(B4SOIEbPtr, B4SOIeNode, B4SOIbNode) + TSTALLOC(B4SOIGbPtr, B4SOIgNode, B4SOIbNode) + TSTALLOC(B4SOIDPbPtr, B4SOIdNodePrime, B4SOIbNode) + TSTALLOC(B4SOISPbPtr, B4SOIsNodePrime, B4SOIbNode) + TSTALLOC(B4SOIBePtr, B4SOIbNode, B4SOIeNode) + TSTALLOC(B4SOIBgPtr, B4SOIbNode, B4SOIgNode) + TSTALLOC(B4SOIBdpPtr, B4SOIbNode, B4SOIdNodePrime) + TSTALLOC(B4SOIBspPtr, B4SOIbNode, B4SOIsNodePrime) + TSTALLOC(B4SOIBbPtr, B4SOIbNode, B4SOIbNode) + } +/* v3.1 */ + + + TSTALLOC(B4SOIEgPtr, B4SOIeNode, B4SOIgNode) + TSTALLOC(B4SOIEdpPtr, B4SOIeNode, B4SOIdNodePrime) + TSTALLOC(B4SOIEspPtr, B4SOIeNode, B4SOIsNodePrime) + TSTALLOC(B4SOIGePtr, B4SOIgNode, B4SOIeNode) + TSTALLOC(B4SOIDPePtr, B4SOIdNodePrime, B4SOIeNode) + TSTALLOC(B4SOISPePtr, B4SOIsNodePrime, B4SOIeNode) + + TSTALLOC(B4SOIEbPtr, B4SOIeNode, B4SOIbNode) + TSTALLOC(B4SOIEePtr, B4SOIeNode, B4SOIeNode) + + TSTALLOC(B4SOIGgPtr, B4SOIgNode, B4SOIgNode) + TSTALLOC(B4SOIGdpPtr, B4SOIgNode, B4SOIdNodePrime) + TSTALLOC(B4SOIGspPtr, B4SOIgNode, B4SOIsNodePrime) + + TSTALLOC(B4SOIDPgPtr, B4SOIdNodePrime, B4SOIgNode) + TSTALLOC(B4SOIDPdpPtr, B4SOIdNodePrime, B4SOIdNodePrime) + TSTALLOC(B4SOIDPspPtr, B4SOIdNodePrime, B4SOIsNodePrime) + TSTALLOC(B4SOIDPdPtr, B4SOIdNodePrime, B4SOIdNode) + + TSTALLOC(B4SOISPgPtr, B4SOIsNodePrime, B4SOIgNode) + TSTALLOC(B4SOISPdpPtr, B4SOIsNodePrime, B4SOIdNodePrime) + TSTALLOC(B4SOISPspPtr, B4SOIsNodePrime, B4SOIsNodePrime) + TSTALLOC(B4SOISPsPtr, B4SOIsNodePrime, B4SOIsNode) + + TSTALLOC(B4SOIDdPtr, B4SOIdNode, B4SOIdNode) + TSTALLOC(B4SOIDdpPtr, B4SOIdNode, B4SOIdNodePrime) + + TSTALLOC(B4SOISsPtr, B4SOIsNode, B4SOIsNode) + TSTALLOC(B4SOISspPtr, B4SOIsNode, B4SOIsNodePrime) + +/* v4.0 */ + if (here->B4SOIrbodyMod == 1) + { TSTALLOC(B4SOIDPdbPtr, B4SOIdNodePrime, B4SOIdbNode) + TSTALLOC(B4SOISPsbPtr, B4SOIsNodePrime, B4SOIsbNode) + + TSTALLOC(B4SOIDBdpPtr, B4SOIdbNode, B4SOIdNodePrime) + TSTALLOC(B4SOIDBdbPtr, B4SOIdbNode, B4SOIdbNode) + TSTALLOC(B4SOIDBbPtr, B4SOIdbNode, B4SOIbNode) + + TSTALLOC(B4SOISBspPtr, B4SOIsbNode, B4SOIsNodePrime) + TSTALLOC(B4SOISBsbPtr, B4SOIsbNode, B4SOIsbNode) + TSTALLOC(B4SOISBbPtr, B4SOIsbNode, B4SOIbNode) + + TSTALLOC(B4SOIBdbPtr, B4SOIbNode, B4SOIdbNode) + TSTALLOC(B4SOIBsbPtr, B4SOIbNode, B4SOIsbNode) + } + + if (model->B4SOIrdsMod) + { TSTALLOC(B4SOIDgPtr, B4SOIdNode, B4SOIgNode) + TSTALLOC(B4SOIDspPtr, B4SOIdNode, B4SOIsNodePrime) + TSTALLOC(B4SOISdpPtr, B4SOIsNode, B4SOIdNodePrime) + TSTALLOC(B4SOISgPtr, B4SOIsNode, B4SOIgNode) + if (model->B4SOIsoiMod != 2) { + TSTALLOC(B4SOIDbPtr, B4SOIdNode, B4SOIbNode) + TSTALLOC(B4SOISbPtr, B4SOIsNode, B4SOIbNode) + } + } + + +/* v4.0 end*/ + +/* here for debugging purpose only */ + if (here->B4SOIdebugMod != 0) + { + TSTALLOC(B4SOIVbsPtr, B4SOIvbsNode, B4SOIvbsNode) + TSTALLOC(B4SOIIdsPtr, B4SOIidsNode, B4SOIidsNode) + TSTALLOC(B4SOIIcPtr, B4SOIicNode, B4SOIicNode) + TSTALLOC(B4SOIIbsPtr, B4SOIibsNode, B4SOIibsNode) + TSTALLOC(B4SOIIbdPtr, B4SOIibdNode, B4SOIibdNode) + TSTALLOC(B4SOIIiiPtr, B4SOIiiiNode, B4SOIiiiNode) + TSTALLOC(B4SOIIgPtr, B4SOIigNode, B4SOIigNode) + TSTALLOC(B4SOIGiggPtr, B4SOIgiggNode, B4SOIgiggNode) + TSTALLOC(B4SOIGigdPtr, B4SOIgigdNode, B4SOIgigdNode) + TSTALLOC(B4SOIGigbPtr, B4SOIgigbNode, B4SOIgigbNode) + TSTALLOC(B4SOIIgidlPtr, B4SOIigidlNode, B4SOIigidlNode) + TSTALLOC(B4SOIItunPtr, B4SOIitunNode, B4SOIitunNode) + TSTALLOC(B4SOIIbpPtr, B4SOIibpNode, B4SOIibpNode) + TSTALLOC(B4SOICbbPtr, B4SOIcbbNode, B4SOIcbbNode) + TSTALLOC(B4SOICbdPtr, B4SOIcbdNode, B4SOIcbdNode) + TSTALLOC(B4SOICbgPtr, B4SOIcbgNode, B4SOIcbgNode) + TSTALLOC(B4SOIQbfPtr, B4SOIqbfNode, B4SOIqbfNode) + TSTALLOC(B4SOIQjsPtr, B4SOIqjsNode, B4SOIqjsNode) + TSTALLOC(B4SOIQjdPtr, B4SOIqjdNode, B4SOIqjdNode) + + + } + + } + } + return(OK); +} + +int +B4SOIunsetup(GENmodel *inModel, CKTcircuit *ckt) +{ +#ifndef HAS_BATCHSIM + B4SOImodel *model; + B4SOIinstance *here; + + for (model = (B4SOImodel *)inModel; model != NULL; + model = model->B4SOInextModel) + { + for (here = model->B4SOIinstances; here != NULL; + here=here->B4SOInextInstance) + { + if (here->B4SOIdNodePrime + && here->B4SOIdNodePrime != here->B4SOIdNode) + { + CKTdltNNum(ckt, here->B4SOIdNodePrime); + here->B4SOIdNodePrime = 0; + } + if (here->B4SOIsNodePrime + && here->B4SOIsNodePrime != here->B4SOIsNode) + { + CKTdltNNum(ckt, here->B4SOIsNodePrime); + here->B4SOIsNodePrime = 0; + } + } + } +#endif + return OK; +} + diff --git a/src/spicelib/devices/bsim3soi/b4soitemp.c b/src/spicelib/devices/bsim3soi/b4soitemp.c new file mode 100644 index 000000000..f49e9a8c9 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soitemp.c @@ -0,0 +1,1506 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soitemp.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soitemp.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +/* Lmin, Lmax, Wmin, Wmax */ + +#include "ngspice.h" +#include "smpdefs.h" +#include "cktdefs.h" +#include "b4soidef.h" +#include "const.h" +#include "sperror.h" +#include "suffix.h" + +#define Kb 1.3806226e-23 +#define KboQ 8.617087e-5 /* Kb / q where q = 1.60219e-19 */ +#define EPSOX 3.453133e-11 +#define EPSSI 1.03594e-10 +#define PI 3.141592654 +#define Charge_q 1.60219e-19 +#define Eg300 1.115 /* energy gap at 300K */ + +#define MAX_EXPL 2.688117142e+43 +#define MIN_EXPL 3.720075976e-44 +#define EXPL_THRESHOLD 100.0 +#define DELTA 1.0E-9 +#define DEXP(A,B) { \ + if (A > EXPL_THRESHOLD) { \ + B = MAX_EXPL*(1.0+(A)-EXPL_THRESHOLD); \ + } else if (A < -EXPL_THRESHOLD) { \ + B = MIN_EXPL; \ + } else { \ + B = exp(A); \ + } \ + } + +/* ARGSUSED */ +int +B4SOItemp(GENmodel *inModel, CKTcircuit *ckt) +{ +register B4SOImodel *model = (B4SOImodel*) inModel; +register B4SOIinstance *here; +struct b4soiSizeDependParam *pSizeDependParamKnot, *pLastKnot, *pParam; +double tmp, tmp1, tmp2, Eg, Eg0, ni, T0, T1, T2, T3, T4, T5; +double Ldrn, Wdrn; +double Temp, TempRatio, Inv_L, Inv_W, Inv_LW, Vtm0, Tnom, TRatio; +double SDphi, SDgamma; +double Inv_saref, Inv_sbref, Inv_sa, Inv_sb, rho, dvth0_lod; +double W_tmp, Inv_ODeff, OD_offset, dk2_lod, deta0_lod, kvsat; +int Size_Not_Found, i; +double PowWeffWr, T10; /*v4.0 */ + + + +/* v2.0 release */ +double tmp3, T7; + + + /* loop through all the B4SOI device models */ + for (; model != NULL; model = model->B4SOInextModel) + { Temp = ckt->CKTtemp; + if (model->B4SOIGatesidewallJctSPotential < 0.1) /* v4.0 */ + model->B4SOIGatesidewallJctSPotential = 0.1; + if (model->B4SOIGatesidewallJctDPotential < 0.1) /* v4.0 */ + model->B4SOIGatesidewallJctDPotential = 0.1; + model->pSizeDependParamKnot = NULL; + pLastKnot = NULL; + + Tnom = model->B4SOItnom; + TempRatio = Temp / Tnom; + + model->B4SOIvcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14)); + model->B4SOIfactor1 = sqrt(EPSSI / EPSOX * model->B4SOItox); + + Vtm0 = KboQ * Tnom; + Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0); + model->B4SOIeg0 = Eg0; + model->B4SOIvtm = KboQ * Temp; + + Eg = 1.16 - 7.02e-4 * Temp * Temp / (Temp + 1108.0); + /* ni is in cm^-3 */ + ni = 1.45e10 * (Temp / 300.15) * sqrt(Temp / 300.15) + * exp(21.5565981 - Eg / (2.0 * model->B4SOIvtm)); + + + /* loop through all the instances of the model */ + /* MCJ: Length and Width not initialized */ + for (here = model->B4SOIinstances; here != NULL; + here = here->B4SOInextInstance) + { + if (here->B4SOIowner != ARCHme) + continue; + + here->B4SOIrbodyext = here->B4SOIbodySquares * + model->B4SOIrbsh; + pSizeDependParamKnot = model->pSizeDependParamKnot; + Size_Not_Found = 1; + while ((pSizeDependParamKnot != NULL) && Size_Not_Found) + { if ((here->B4SOIl == pSizeDependParamKnot->Length) + && (here->B4SOIw == pSizeDependParamKnot->Width) + && (here->B4SOIrth0 == pSizeDependParamKnot->Rth0) + && (here->B4SOIcth0 == pSizeDependParamKnot->Cth0) + && (here->B4SOInf == pSizeDependParamKnot->NFinger)) /*4.0*/ + { Size_Not_Found = 0; + here->pParam = pSizeDependParamKnot; + pParam = here->pParam; /* v2.2.3 bug fix */ + } + else + { pLastKnot = pSizeDependParamKnot; + pSizeDependParamKnot = pSizeDependParamKnot->pNext; + } + } + + if (Size_Not_Found) + { pParam = (struct b4soiSizeDependParam *)malloc( + sizeof(struct b4soiSizeDependParam)); + if (pLastKnot == NULL) + model->pSizeDependParamKnot = pParam; + else + pLastKnot->pNext = pParam; + pParam->pNext = NULL; + here->pParam = pParam; + + Ldrn = here->B4SOIl; + Wdrn = here->B4SOIw / here->B4SOInf; /* v4.0 */ + pParam->Length = here->B4SOIl; + pParam->Width = here->B4SOIw; + pParam->NFinger = here->B4SOInf; /* v4.0 */ + pParam->Rth0 = here->B4SOIrth0; + pParam->Cth0 = here->B4SOIcth0; + + T0 = pow(Ldrn, model->B4SOILln); + T1 = pow(Wdrn, model->B4SOILwn); + tmp1 = model->B4SOILl / T0 + model->B4SOILw / T1 + + model->B4SOILwl / (T0 * T1); + pParam->B4SOIdl = model->B4SOILint + tmp1; + +/* v2.2.3 */ + tmp1 = model->B4SOILlc / T0 + model->B4SOILwc / T1 + + model->B4SOILwlc / (T0 * T1); + pParam->B4SOIdlc = model->B4SOIdlc + tmp1; + +/* v3.0 */ + pParam->B4SOIdlcig = model->B4SOIdlcig + tmp1; + + + T2 = pow(Ldrn, model->B4SOIWln); + T3 = pow(Wdrn, model->B4SOIWwn); + tmp2 = model->B4SOIWl / T2 + model->B4SOIWw / T3 + + model->B4SOIWwl / (T2 * T3); + pParam->B4SOIdw = model->B4SOIWint + tmp2; + +/* v2.2.3 */ + tmp2 = model->B4SOIWlc / T2 + model->B4SOIWwc / T3 + + model->B4SOIWwlc / (T2 * T3); + pParam->B4SOIdwc = model->B4SOIdwc + tmp2; + + + pParam->B4SOIleff = here->B4SOIl - 2.0 * pParam->B4SOIdl; + if (pParam->B4SOIleff <= 0.0) + { IFuid namarray[2]; + namarray[0] = model->B4SOImodName; + namarray[1] = here->B4SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B4SOI: mosfet %s, model %s: Effective channel length <= 0", + namarray); + return(E_BADPARM); + } + + pParam->B4SOIweff = here->B4SOIw / here->B4SOInf /* v4.0 */ + - here->B4SOInbc * model->B4SOIdwbc + - (2.0 - here->B4SOInbc) * pParam->B4SOIdw; + if (pParam->B4SOIweff <= 0.0) + { IFuid namarray[2]; + namarray[0] = model->B4SOImodName; + namarray[1] = here->B4SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B4SOI: mosfet %s, model %s: Effective channel width <= 0", + namarray); + return(E_BADPARM); + } + + pParam->B4SOIwdiod = pParam->B4SOIweff / here->B4SOInseg + + here->B4SOIpdbcp; + pParam->B4SOIwdios = pParam->B4SOIweff / here->B4SOInseg + + here->B4SOIpsbcp; + + pParam->B4SOIleffCV = here->B4SOIl - 2.0 * pParam->B4SOIdlc; + if (pParam->B4SOIleffCV <= 0.0) + { IFuid namarray[2]; + namarray[0] = model->B4SOImodName; + namarray[1] = here->B4SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B4SOI: mosfet %s, model %s: Effective channel length for C-V <= 0", + namarray); + return(E_BADPARM); + } + + pParam->B4SOIweffCV = here->B4SOIw /here->B4SOInf /* v4.0 */ + - here->B4SOInbc * model->B4SOIdwbc + - (2.0 - here->B4SOInbc) * pParam->B4SOIdwc; + if (pParam->B4SOIweffCV <= 0.0) + { IFuid namarray[2]; + namarray[0] = model->B4SOImodName; + namarray[1] = here->B4SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B4SOI: mosfet %s, model %s: Effective channel width for C-V <= 0", + namarray); + return(E_BADPARM); + } + + pParam->B4SOIwdiodCV = pParam->B4SOIweffCV / here->B4SOInseg + + here->B4SOIpdbcp; + pParam->B4SOIwdiosCV = pParam->B4SOIweffCV / here->B4SOInseg + + here->B4SOIpsbcp; + + pParam->B4SOIleffCVb = here->B4SOIl - 2.0 * pParam->B4SOIdlc + - model->B4SOIdlcb; + if (pParam->B4SOIleffCVb <= 0.0) + { + IFuid namarray[2]; + namarray[0] = model->B4SOImodName; + namarray[1] = here->B4SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B4SOI: mosfet %s, model %s: Effective channel length for C-V (body) <= 0", + namarray); + return(E_BADPARM); + } + + pParam->B4SOIleffCVbg = pParam->B4SOIleffCVb + 2 * model->B4SOIdlbg; + if (pParam->B4SOIleffCVbg <= 0.0) + { + IFuid namarray[2]; + namarray[0] = model->B4SOImodName; + namarray[1] = here->B4SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B4SOI: mosfet %s, model %s: Effective channel length for C-V (backgate) <= 0", + namarray); + return(E_BADPARM); + } + + + /* Not binned - START */ + pParam->B4SOIgamma1 = model->B4SOIgamma1; + pParam->B4SOIgamma2 = model->B4SOIgamma2; + pParam->B4SOIvbx = model->B4SOIvbx; + pParam->B4SOIvbm = model->B4SOIvbm; + pParam->B4SOIxt = model->B4SOIxt; + /* Not binned - END */ + + /* CV model */ + pParam->B4SOIcf = model->B4SOIcf; + pParam->B4SOIclc = model->B4SOIclc; + pParam->B4SOIcle = model->B4SOIcle; + + pParam->B4SOIabulkCVfactor = 1.0 + pow((pParam->B4SOIclc + / pParam->B4SOIleff), + pParam->B4SOIcle); + + /* Added for binning - START */ + if (model->B4SOIbinUnit == 1) + { Inv_L = 1.0e-6 / pParam->B4SOIleff; + Inv_W = 1.0e-6 / pParam->B4SOIweff; + Inv_LW = 1.0e-12 / (pParam->B4SOIleff + * pParam->B4SOIweff); + } + else + { Inv_L = 1.0 / pParam->B4SOIleff; + Inv_W = 1.0 / pParam->B4SOIweff; + Inv_LW = 1.0 / (pParam->B4SOIleff + * pParam->B4SOIweff); + } + pParam->B4SOInpeak = model->B4SOInpeak + + model->B4SOIlnpeak * Inv_L + + model->B4SOIwnpeak * Inv_W + + model->B4SOIpnpeak * Inv_LW; + pParam->B4SOInsub = model->B4SOInsub + + model->B4SOIlnsub * Inv_L + + model->B4SOIwnsub * Inv_W + + model->B4SOIpnsub * Inv_LW; + pParam->B4SOIngate = model->B4SOIngate + + model->B4SOIlngate * Inv_L + + model->B4SOIwngate * Inv_W + + model->B4SOIpngate * Inv_LW; + pParam->B4SOIvth0 = model->B4SOIvth0 + + model->B4SOIlvth0 * Inv_L + + model->B4SOIwvth0 * Inv_W + + model->B4SOIpvth0 * Inv_LW; + pParam->B4SOIk1 = model->B4SOIk1 + + model->B4SOIlk1 * Inv_L + + model->B4SOIwk1 * Inv_W + + model->B4SOIpk1 * Inv_LW; + pParam->B4SOIk2 = model->B4SOIk2 + + model->B4SOIlk2 * Inv_L + + model->B4SOIwk2 * Inv_W + + model->B4SOIpk2 * Inv_LW; + pParam->B4SOIk1w1 = model->B4SOIk1w1 + + model->B4SOIlk1w1 * Inv_L + + model->B4SOIwk1w1 * Inv_W + + model->B4SOIpk1w1 * Inv_LW; + pParam->B4SOIk1w2 = model->B4SOIk1w2 + + model->B4SOIlk1w2 * Inv_L + + model->B4SOIwk1w2 * Inv_W + + model->B4SOIpk1w2 * Inv_LW; + pParam->B4SOIk3 = model->B4SOIk3 + + model->B4SOIlk3 * Inv_L + + model->B4SOIwk3 * Inv_W + + model->B4SOIpk3 * Inv_LW; + pParam->B4SOIk3b = model->B4SOIk3b + + model->B4SOIlk3b * Inv_L + + model->B4SOIwk3b * Inv_W + + model->B4SOIpk3b * Inv_LW; + pParam->B4SOIkb1 = model->B4SOIkb1 + + model->B4SOIlkb1 * Inv_L + + model->B4SOIwkb1 * Inv_W + + model->B4SOIpkb1 * Inv_LW; + pParam->B4SOIw0 = model->B4SOIw0 + + model->B4SOIlw0 * Inv_L + + model->B4SOIww0 * Inv_W + + model->B4SOIpw0 * Inv_LW; + pParam->B4SOIlpe0 = model->B4SOIlpe0 + + model->B4SOIllpe0 * Inv_L + + model->B4SOIwlpe0 * Inv_W + + model->B4SOIplpe0 * Inv_LW; + pParam->B4SOIlpeb = model->B4SOIlpeb + + model->B4SOIllpeb * Inv_L + + model->B4SOIwlpeb * Inv_W + + model->B4SOIplpeb * Inv_LW; /* v4.0 */ + pParam->B4SOIdvt0 = model->B4SOIdvt0 + + model->B4SOIldvt0 * Inv_L + + model->B4SOIwdvt0 * Inv_W + + model->B4SOIpdvt0 * Inv_LW; + pParam->B4SOIdvt1 = model->B4SOIdvt1 + + model->B4SOIldvt1 * Inv_L + + model->B4SOIwdvt1 * Inv_W + + model->B4SOIpdvt1 * Inv_LW; + pParam->B4SOIdvt2 = model->B4SOIdvt2 + + model->B4SOIldvt2 * Inv_L + + model->B4SOIwdvt2 * Inv_W + + model->B4SOIpdvt2 * Inv_LW; + pParam->B4SOIdvt0w = model->B4SOIdvt0w + + model->B4SOIldvt0w * Inv_L + + model->B4SOIwdvt0w * Inv_W + + model->B4SOIpdvt0w * Inv_LW; + pParam->B4SOIdvt1w = model->B4SOIdvt1w + + model->B4SOIldvt1w * Inv_L + + model->B4SOIwdvt1w * Inv_W + + model->B4SOIpdvt1w * Inv_LW; + pParam->B4SOIdvt2w = model->B4SOIdvt2w + + model->B4SOIldvt2w * Inv_L + + model->B4SOIwdvt2w * Inv_W + + model->B4SOIpdvt2w * Inv_LW; + pParam->B4SOIu0 = model->B4SOIu0 + + model->B4SOIlu0 * Inv_L + + model->B4SOIwu0 * Inv_W + + model->B4SOIpu0 * Inv_LW; + pParam->B4SOIua = model->B4SOIua + + model->B4SOIlua * Inv_L + + model->B4SOIwua * Inv_W + + model->B4SOIpua * Inv_LW; + pParam->B4SOIub = model->B4SOIub + + model->B4SOIlub * Inv_L + + model->B4SOIwub * Inv_W + + model->B4SOIpub * Inv_LW; + pParam->B4SOIuc = model->B4SOIuc + + model->B4SOIluc * Inv_L + + model->B4SOIwuc * Inv_W + + model->B4SOIpuc * Inv_LW; + pParam->B4SOIvsat = model->B4SOIvsat + + model->B4SOIlvsat * Inv_L + + model->B4SOIwvsat * Inv_W + + model->B4SOIpvsat * Inv_LW; + pParam->B4SOIa0 = model->B4SOIa0 + + model->B4SOIla0 * Inv_L + + model->B4SOIwa0 * Inv_W + + model->B4SOIpa0 * Inv_LW; + pParam->B4SOIags = model->B4SOIags + + model->B4SOIlags * Inv_L + + model->B4SOIwags * Inv_W + + model->B4SOIpags * Inv_LW; + pParam->B4SOIb0 = model->B4SOIb0 + + model->B4SOIlb0 * Inv_L + + model->B4SOIwb0 * Inv_W + + model->B4SOIpb0 * Inv_LW; + pParam->B4SOIb1 = model->B4SOIb1 + + model->B4SOIlb1 * Inv_L + + model->B4SOIwb1 * Inv_W + + model->B4SOIpb1 * Inv_LW; + pParam->B4SOIketa = model->B4SOIketa + + model->B4SOIlketa * Inv_L + + model->B4SOIwketa * Inv_W + + model->B4SOIpketa * Inv_LW; + pParam->B4SOIketas = model->B4SOIketas + + model->B4SOIlketas * Inv_L + + model->B4SOIwketas * Inv_W + + model->B4SOIpketas * Inv_LW; + pParam->B4SOIa1 = model->B4SOIa1 + + model->B4SOIla1 * Inv_L + + model->B4SOIwa1 * Inv_W + + model->B4SOIpa1 * Inv_LW; + pParam->B4SOIa2 = model->B4SOIa2 + + model->B4SOIla2 * Inv_L + + model->B4SOIwa2 * Inv_W + + model->B4SOIpa2 * Inv_LW; + pParam->B4SOIrdsw = model->B4SOIrdsw + + model->B4SOIlrdsw * Inv_L + + model->B4SOIwrdsw * Inv_W + + model->B4SOIprdsw * Inv_LW; + pParam->B4SOIrsw = model->B4SOIrsw /* v4.0 */ + + model->B4SOIlrsw * Inv_L + + model->B4SOIwrsw * Inv_W + + model->B4SOIprsw * Inv_LW; + pParam->B4SOIrdw = model->B4SOIrdw /* v4.0 */ + + model->B4SOIlrdw * Inv_L + + model->B4SOIwrdw * Inv_W + + model->B4SOIprdw * Inv_LW; + pParam->B4SOIprwb = model->B4SOIprwb + + model->B4SOIlprwb * Inv_L + + model->B4SOIwprwb * Inv_W + + model->B4SOIpprwb * Inv_LW; + pParam->B4SOIprwg = model->B4SOIprwg + + model->B4SOIlprwg * Inv_L + + model->B4SOIwprwg * Inv_W + + model->B4SOIpprwg * Inv_LW; + pParam->B4SOIwr = model->B4SOIwr + + model->B4SOIlwr * Inv_L + + model->B4SOIwwr * Inv_W + + model->B4SOIpwr * Inv_LW; + pParam->B4SOInfactor = model->B4SOInfactor + + model->B4SOIlnfactor * Inv_L + + model->B4SOIwnfactor * Inv_W + + model->B4SOIpnfactor * Inv_LW; + pParam->B4SOIdwg = model->B4SOIdwg + + model->B4SOIldwg * Inv_L + + model->B4SOIwdwg * Inv_W + + model->B4SOIpdwg * Inv_LW; + pParam->B4SOIdwb = model->B4SOIdwb + + model->B4SOIldwb * Inv_L + + model->B4SOIwdwb * Inv_W + + model->B4SOIpdwb * Inv_LW; + pParam->B4SOIvoff = model->B4SOIvoff + + model->B4SOIlvoff * Inv_L + + model->B4SOIwvoff * Inv_W + + model->B4SOIpvoff * Inv_LW; + pParam->B4SOIeta0 = model->B4SOIeta0 + + model->B4SOIleta0 * Inv_L + + model->B4SOIweta0 * Inv_W + + model->B4SOIpeta0 * Inv_LW; + pParam->B4SOIetab = model->B4SOIetab + + model->B4SOIletab * Inv_L + + model->B4SOIwetab * Inv_W + + model->B4SOIpetab * Inv_LW; + pParam->B4SOIdsub = model->B4SOIdsub + + model->B4SOIldsub * Inv_L + + model->B4SOIwdsub * Inv_W + + model->B4SOIpdsub * Inv_LW; + pParam->B4SOIcit = model->B4SOIcit + + model->B4SOIlcit * Inv_L + + model->B4SOIwcit * Inv_W + + model->B4SOIpcit * Inv_LW; + pParam->B4SOIcdsc = model->B4SOIcdsc + + model->B4SOIlcdsc * Inv_L + + model->B4SOIwcdsc * Inv_W + + model->B4SOIpcdsc * Inv_LW; + pParam->B4SOIcdscb = model->B4SOIcdscb + + model->B4SOIlcdscb * Inv_L + + model->B4SOIwcdscb * Inv_W + + model->B4SOIpcdscb * Inv_LW; + pParam->B4SOIcdscd = model->B4SOIcdscd + + model->B4SOIlcdscd * Inv_L + + model->B4SOIwcdscd * Inv_W + + model->B4SOIpcdscd * Inv_LW; + pParam->B4SOIpclm = model->B4SOIpclm + + model->B4SOIlpclm * Inv_L + + model->B4SOIwpclm * Inv_W + + model->B4SOIppclm * Inv_LW; + pParam->B4SOIpdibl1 = model->B4SOIpdibl1 + + model->B4SOIlpdibl1 * Inv_L + + model->B4SOIwpdibl1 * Inv_W + + model->B4SOIppdibl1 * Inv_LW; + pParam->B4SOIpdibl2 = model->B4SOIpdibl2 + + model->B4SOIlpdibl2 * Inv_L + + model->B4SOIwpdibl2 * Inv_W + + model->B4SOIppdibl2 * Inv_LW; + pParam->B4SOIpdiblb = model->B4SOIpdiblb + + model->B4SOIlpdiblb * Inv_L + + model->B4SOIwpdiblb * Inv_W + + model->B4SOIppdiblb * Inv_LW; + pParam->B4SOIdrout = model->B4SOIdrout + + model->B4SOIldrout * Inv_L + + model->B4SOIwdrout * Inv_W + + model->B4SOIpdrout * Inv_LW; + pParam->B4SOIpvag = model->B4SOIpvag + + model->B4SOIlpvag * Inv_L + + model->B4SOIwpvag * Inv_W + + model->B4SOIppvag * Inv_LW; + pParam->B4SOIdelta = model->B4SOIdelta + + model->B4SOIldelta * Inv_L + + model->B4SOIwdelta * Inv_W + + model->B4SOIpdelta * Inv_LW; + pParam->B4SOIalpha0 = model->B4SOIalpha0 + + model->B4SOIlalpha0 * Inv_L + + model->B4SOIwalpha0 * Inv_W + + model->B4SOIpalpha0 * Inv_LW; + pParam->B4SOIfbjtii = model->B4SOIfbjtii + + model->B4SOIlfbjtii * Inv_L + + model->B4SOIwfbjtii * Inv_W + + model->B4SOIpfbjtii * Inv_LW; + pParam->B4SOIbeta0 = model->B4SOIbeta0 + + model->B4SOIlbeta0 * Inv_L + + model->B4SOIwbeta0 * Inv_W + + model->B4SOIpbeta0 * Inv_LW; + pParam->B4SOIbeta1 = model->B4SOIbeta1 + + model->B4SOIlbeta1 * Inv_L + + model->B4SOIwbeta1 * Inv_W + + model->B4SOIpbeta1 * Inv_LW; + pParam->B4SOIbeta2 = model->B4SOIbeta2 + + model->B4SOIlbeta2 * Inv_L + + model->B4SOIwbeta2 * Inv_W + + model->B4SOIpbeta2 * Inv_LW; + pParam->B4SOIvdsatii0 = model->B4SOIvdsatii0 + + model->B4SOIlvdsatii0 * Inv_L + + model->B4SOIwvdsatii0 * Inv_W + + model->B4SOIpvdsatii0 * Inv_LW; + pParam->B4SOIlii = model->B4SOIlii + + model->B4SOIllii * Inv_L + + model->B4SOIwlii * Inv_W + + model->B4SOIplii * Inv_LW; + pParam->B4SOIesatii = model->B4SOIesatii + + model->B4SOIlesatii * Inv_L + + model->B4SOIwesatii * Inv_W + + model->B4SOIpesatii * Inv_LW; + pParam->B4SOIsii0 = model->B4SOIsii0 + + model->B4SOIlsii0 * Inv_L + + model->B4SOIwsii0 * Inv_W + + model->B4SOIpsii0 * Inv_LW; + pParam->B4SOIsii1 = model->B4SOIsii1 + + model->B4SOIlsii1 * Inv_L + + model->B4SOIwsii1 * Inv_W + + model->B4SOIpsii1 * Inv_LW; + pParam->B4SOIsii2 = model->B4SOIsii2 + + model->B4SOIlsii2 * Inv_L + + model->B4SOIwsii2 * Inv_W + + model->B4SOIpsii2 * Inv_LW; + pParam->B4SOIsiid = model->B4SOIsiid + + model->B4SOIlsiid * Inv_L + + model->B4SOIwsiid * Inv_W + + model->B4SOIpsiid * Inv_LW; + pParam->B4SOIagidl = model->B4SOIagidl + + model->B4SOIlagidl * Inv_L + + model->B4SOIwagidl * Inv_W + + model->B4SOIpagidl * Inv_LW; + pParam->B4SOIbgidl = model->B4SOIbgidl + + model->B4SOIlbgidl * Inv_L + + model->B4SOIwbgidl * Inv_W + + model->B4SOIpbgidl * Inv_LW; + pParam->B4SOIcgidl = model->B4SOIcgidl + + model->B4SOIlcgidl * Inv_L + + model->B4SOIwcgidl * Inv_W + + model->B4SOIpcgidl * Inv_LW; + pParam->B4SOIegidl = model->B4SOIegidl + + model->B4SOIlegidl * Inv_L + + model->B4SOIwegidl * Inv_W + + model->B4SOIpegidl * Inv_LW; + pParam->B4SOIntun = model->B4SOIntun /* v4.0 */ + + model->B4SOIlntun * Inv_L + + model->B4SOIwntun * Inv_W + + model->B4SOIpntun * Inv_LW; + pParam->B4SOIntund = model->B4SOIntund /* v4.0 */ + + model->B4SOIlntund * Inv_L + + model->B4SOIwntund * Inv_W + + model->B4SOIpntund * Inv_LW; + pParam->B4SOIndiode = model->B4SOIndiode /* v4.0 */ + + model->B4SOIlndiode * Inv_L + + model->B4SOIwndiode * Inv_W + + model->B4SOIpndiode * Inv_LW; + pParam->B4SOIndioded = model->B4SOIndioded /* v4.0 */ + + model->B4SOIlndioded * Inv_L + + model->B4SOIwndioded * Inv_W + + model->B4SOIpndioded * Inv_LW; + pParam->B4SOInrecf0 = model->B4SOInrecf0 /* v4.0 */ + + model->B4SOIlnrecf0 * Inv_L + + model->B4SOIwnrecf0 * Inv_W + + model->B4SOIpnrecf0 * Inv_LW; + pParam->B4SOInrecf0d = model->B4SOInrecf0d /* v4.0 */ + + model->B4SOIlnrecf0d * Inv_L + + model->B4SOIwnrecf0d * Inv_W + + model->B4SOIpnrecf0d * Inv_LW; + pParam->B4SOInrecr0 = model->B4SOInrecr0 /* v4.0 */ + + model->B4SOIlnrecr0 * Inv_L + + model->B4SOIwnrecr0 * Inv_W + + model->B4SOIpnrecr0 * Inv_LW; + pParam->B4SOInrecr0d = model->B4SOInrecr0d /* v4.0 */ + + model->B4SOIlnrecr0d * Inv_L + + model->B4SOIwnrecr0d * Inv_W + + model->B4SOIpnrecr0d * Inv_LW; + pParam->B4SOIisbjt = model->B4SOIisbjt + + model->B4SOIlisbjt * Inv_L + + model->B4SOIwisbjt * Inv_W + + model->B4SOIpisbjt * Inv_LW; + pParam->B4SOIidbjt = model->B4SOIidbjt + + model->B4SOIlidbjt * Inv_L + + model->B4SOIwidbjt * Inv_W + + model->B4SOIpidbjt * Inv_LW; + pParam->B4SOIisdif = model->B4SOIisdif + + model->B4SOIlisdif * Inv_L + + model->B4SOIwisdif * Inv_W + + model->B4SOIpisdif * Inv_LW; + pParam->B4SOIiddif = model->B4SOIiddif + + model->B4SOIliddif * Inv_L + + model->B4SOIwiddif * Inv_W + + model->B4SOIpiddif * Inv_LW; + pParam->B4SOIisrec = model->B4SOIisrec + + model->B4SOIlisrec * Inv_L + + model->B4SOIwisrec * Inv_W + + model->B4SOIpisrec * Inv_LW; + pParam->B4SOIistun = model->B4SOIistun + + model->B4SOIlistun * Inv_L + + model->B4SOIwistun * Inv_W + + model->B4SOIpistun * Inv_LW; + pParam->B4SOIidrec = model->B4SOIidrec + + model->B4SOIlidrec * Inv_L + + model->B4SOIwidrec * Inv_W + + model->B4SOIpidrec * Inv_LW; + pParam->B4SOIidtun = model->B4SOIidtun + + model->B4SOIlidtun * Inv_L + + model->B4SOIwidtun * Inv_W + + model->B4SOIpidtun * Inv_LW; + pParam->B4SOIvrec0 = model->B4SOIvrec0 /* v4.0 */ + + model->B4SOIlvrec0 * Inv_L + + model->B4SOIwvrec0 * Inv_W + + model->B4SOIpvrec0 * Inv_LW; + pParam->B4SOIvrec0d = model->B4SOIvrec0d /* v4.0 */ + + model->B4SOIlvrec0d * Inv_L + + model->B4SOIwvrec0d * Inv_W + + model->B4SOIpvrec0d * Inv_LW; + pParam->B4SOIvtun0 = model->B4SOIvtun0 /* v4.0 */ + + model->B4SOIlvtun0 * Inv_L + + model->B4SOIwvtun0 * Inv_W + + model->B4SOIpvtun0 * Inv_LW; + pParam->B4SOIvtun0d = model->B4SOIvtun0d /* v4.0 */ + + model->B4SOIlvtun0d * Inv_L + + model->B4SOIwvtun0d * Inv_W + + model->B4SOIpvtun0d * Inv_LW; + pParam->B4SOInbjt = model->B4SOInbjt + + model->B4SOIlnbjt * Inv_L + + model->B4SOIwnbjt * Inv_W + + model->B4SOIpnbjt * Inv_LW; + pParam->B4SOIlbjt0 = model->B4SOIlbjt0 + + model->B4SOIllbjt0 * Inv_L + + model->B4SOIwlbjt0 * Inv_W + + model->B4SOIplbjt0 * Inv_LW; + pParam->B4SOIvabjt = model->B4SOIvabjt + + model->B4SOIlvabjt * Inv_L + + model->B4SOIwvabjt * Inv_W + + model->B4SOIpvabjt * Inv_LW; + pParam->B4SOIaely = model->B4SOIaely + + model->B4SOIlaely * Inv_L + + model->B4SOIwaely * Inv_W + + model->B4SOIpaely * Inv_LW; + pParam->B4SOIahli = model->B4SOIahli /* v4.0 */ + + model->B4SOIlahli * Inv_L + + model->B4SOIwahli * Inv_W + + model->B4SOIpahli * Inv_LW; + pParam->B4SOIahlid = model->B4SOIahlid /* v4.0 */ + + model->B4SOIlahlid * Inv_L + + model->B4SOIwahlid * Inv_W + + model->B4SOIpahlid * Inv_LW; + + +/* v3.1 */ + pParam->B4SOIxj = model->B4SOIxj + + model->B4SOIlxj * Inv_L + + model->B4SOIwxj * Inv_W + + model->B4SOIpxj * Inv_LW; + pParam->B4SOIalphaGB1 = model->B4SOIalphaGB1 + + model->B4SOIlalphaGB1 * Inv_L + + model->B4SOIwalphaGB1 * Inv_W + + model->B4SOIpalphaGB1 * Inv_LW; + pParam->B4SOIalphaGB2 = model->B4SOIalphaGB2 + + model->B4SOIlalphaGB2 * Inv_L + + model->B4SOIwalphaGB2 * Inv_W + + model->B4SOIpalphaGB2 * Inv_LW; + pParam->B4SOIbetaGB1 = model->B4SOIbetaGB1 + + model->B4SOIlbetaGB1* Inv_L + + model->B4SOIwbetaGB1 * Inv_W + + model->B4SOIpbetaGB1 * Inv_LW; + pParam->B4SOIbetaGB2 = model->B4SOIbetaGB2 + + model->B4SOIlbetaGB2 * Inv_L + + model->B4SOIwbetaGB2 * Inv_W + + model->B4SOIpbetaGB2 * Inv_LW; + pParam->B4SOIndif = model->B4SOIndif + + model->B4SOIlndif * Inv_L + + model->B4SOIwndif * Inv_W + + model->B4SOIpndif * Inv_LW; + pParam->B4SOIntrecf = model->B4SOIntrecf + + model->B4SOIlntrecf* Inv_L + + model->B4SOIwntrecf * Inv_W + + model->B4SOIpntrecf * Inv_LW; + pParam->B4SOIntrecr = model->B4SOIntrecr + + model->B4SOIlntrecr * Inv_L + + model->B4SOIwntrecr * Inv_W + + model->B4SOIpntrecr * Inv_LW; + pParam->B4SOIxbjt = model->B4SOIxbjt + + model->B4SOIlxbjt * Inv_L + + model->B4SOIwxbjt * Inv_W + + model->B4SOIpxbjt * Inv_LW; + pParam->B4SOIxdif = model->B4SOIxdif + + model->B4SOIlxdif* Inv_L + + model->B4SOIwxdif * Inv_W + + model->B4SOIpxdif * Inv_LW; + pParam->B4SOIxrec = model->B4SOIxrec + + model->B4SOIlxrec * Inv_L + + model->B4SOIwxrec * Inv_W + + model->B4SOIpxrec * Inv_LW; + pParam->B4SOIxtun = model->B4SOIxtun + + model->B4SOIlxtun * Inv_L + + model->B4SOIwxtun * Inv_W + + model->B4SOIpxtun * Inv_LW; + pParam->B4SOIxdifd = model->B4SOIxdifd + + model->B4SOIlxdifd* Inv_L + + model->B4SOIwxdifd * Inv_W + + model->B4SOIpxdifd * Inv_LW; + pParam->B4SOIxrecd = model->B4SOIxrecd + + model->B4SOIlxrecd * Inv_L + + model->B4SOIwxrecd * Inv_W + + model->B4SOIpxrecd * Inv_LW; + pParam->B4SOIxtund = model->B4SOIxtund + + model->B4SOIlxtund * Inv_L + + model->B4SOIwxtund * Inv_W + + model->B4SOIpxtund * Inv_LW; + pParam->B4SOIcgdl = model->B4SOIcgdl + + model->B4SOIlcgdl * Inv_L + + model->B4SOIwcgdl * Inv_W + + model->B4SOIpcgdl * Inv_LW; + pParam->B4SOIcgsl = model->B4SOIcgsl + + model->B4SOIlcgsl * Inv_L + + model->B4SOIwcgsl * Inv_W + + model->B4SOIpcgsl * Inv_LW; + pParam->B4SOIckappa = model->B4SOIckappa + + model->B4SOIlckappa * Inv_L + + model->B4SOIwckappa * Inv_W + + model->B4SOIpckappa * Inv_LW; + pParam->B4SOIute = model->B4SOIute + + model->B4SOIlute * Inv_L + + model->B4SOIwute * Inv_W + + model->B4SOIpute * Inv_LW; + pParam->B4SOIkt1 = model->B4SOIkt1 + + model->B4SOIlkt1 * Inv_L + + model->B4SOIwkt1 * Inv_W + + model->B4SOIpkt1 * Inv_LW; + pParam->B4SOIkt2 = model->B4SOIkt2 + + model->B4SOIlkt2 * Inv_L + + model->B4SOIwkt2 * Inv_W + + model->B4SOIpkt2 * Inv_LW; + pParam->B4SOIkt1l = model->B4SOIkt1l + + model->B4SOIlkt1l * Inv_L + + model->B4SOIwkt1l * Inv_W + + model->B4SOIpkt1l * Inv_LW; + pParam->B4SOIua1 = model->B4SOIua1 + + model->B4SOIlua1 * Inv_L + + model->B4SOIwua1 * Inv_W + + model->B4SOIpua1 * Inv_LW; + pParam->B4SOIub1 = model->B4SOIub1 + + model->B4SOIlub1* Inv_L + + model->B4SOIwub1 * Inv_W + + model->B4SOIpub1 * Inv_LW; + pParam->B4SOIuc1 = model->B4SOIuc1 + + model->B4SOIluc1 * Inv_L + + model->B4SOIwuc1 * Inv_W + + model->B4SOIpuc1 * Inv_LW; + pParam->B4SOIat = model->B4SOIat + + model->B4SOIlat * Inv_L + + model->B4SOIwat * Inv_W + + model->B4SOIpat * Inv_LW; + pParam->B4SOIprt = model->B4SOIprt + + model->B4SOIlprt * Inv_L + + model->B4SOIwprt * Inv_W + + model->B4SOIpprt * Inv_LW; + + +/* v3.0 */ + pParam->B4SOInigc = model->B4SOInigc + + model->B4SOIlnigc * Inv_L + + model->B4SOIwnigc * Inv_W + + model->B4SOIpnigc * Inv_LW; + pParam->B4SOIaigc = model->B4SOIaigc + + model->B4SOIlaigc * Inv_L + + model->B4SOIwaigc * Inv_W + + model->B4SOIpaigc * Inv_LW; + pParam->B4SOIbigc = model->B4SOIbigc + + model->B4SOIlbigc * Inv_L + + model->B4SOIwbigc * Inv_W + + model->B4SOIpbigc * Inv_LW; + pParam->B4SOIcigc = model->B4SOIcigc + + model->B4SOIlcigc * Inv_L + + model->B4SOIwcigc * Inv_W + + model->B4SOIpcigc * Inv_LW; + pParam->B4SOIaigsd = model->B4SOIaigsd + + model->B4SOIlaigsd * Inv_L + + model->B4SOIwaigsd * Inv_W + + model->B4SOIpaigsd * Inv_LW; + pParam->B4SOIbigsd = model->B4SOIbigsd + + model->B4SOIlbigsd * Inv_L + + model->B4SOIwbigsd * Inv_W + + model->B4SOIpbigsd * Inv_LW; + pParam->B4SOIcigsd = model->B4SOIcigsd + + model->B4SOIlcigsd * Inv_L + + model->B4SOIwcigsd * Inv_W + + model->B4SOIpcigsd * Inv_LW; + pParam->B4SOIpigcd = model->B4SOIpigcd + + model->B4SOIlpigcd * Inv_L + + model->B4SOIwpigcd * Inv_W + + model->B4SOIppigcd * Inv_LW; + pParam->B4SOIpoxedge = model->B4SOIpoxedge + + model->B4SOIlpoxedge * Inv_L + + model->B4SOIwpoxedge * Inv_W + + model->B4SOIppoxedge * Inv_LW; +/* v3.0 */ + + /* v3.1 added for RF */ + pParam->B4SOIxrcrg1 = model->B4SOIxrcrg1 + + model->B4SOIlxrcrg1 * Inv_L + + model->B4SOIwxrcrg1 * Inv_W + + model->B4SOIpxrcrg1 * Inv_LW; + pParam->B4SOIxrcrg2 = model->B4SOIxrcrg2 + + model->B4SOIlxrcrg2 * Inv_L + + model->B4SOIwxrcrg2 * Inv_W + + model->B4SOIpxrcrg2 * Inv_LW; + /* v3.1 added for RF end */ + + + /* CV model */ + pParam->B4SOIvsdfb = model->B4SOIvsdfb + + model->B4SOIlvsdfb * Inv_L + + model->B4SOIwvsdfb * Inv_W + + model->B4SOIpvsdfb * Inv_LW; + pParam->B4SOIvsdth = model->B4SOIvsdth + + model->B4SOIlvsdth * Inv_L + + model->B4SOIwvsdth * Inv_W + + model->B4SOIpvsdth * Inv_LW; + pParam->B4SOIdelvt = model->B4SOIdelvt + + model->B4SOIldelvt * Inv_L + + model->B4SOIwdelvt * Inv_W + + model->B4SOIpdelvt * Inv_LW; + pParam->B4SOIacde = model->B4SOIacde + + model->B4SOIlacde * Inv_L + + model->B4SOIwacde * Inv_W + + model->B4SOIpacde * Inv_LW; + pParam->B4SOIacde = pParam->B4SOIacde * + pow((pParam->B4SOInpeak / 2.0e16), -0.25); + /* v3.2 bug fix */ + + pParam->B4SOImoin = model->B4SOImoin + + model->B4SOIlmoin * Inv_L + + model->B4SOIwmoin * Inv_W + + model->B4SOIpmoin * Inv_LW; + pParam->B4SOInoff = model->B4SOInoff + + model->B4SOIlnoff * Inv_L + + model->B4SOIwnoff * Inv_W + + model->B4SOIpnoff * Inv_LW; /* v3.2 */ + + pParam->B4SOIdvtp0 = model->B4SOIdvtp0 + + model->B4SOIldvtp0 * Inv_L + + model->B4SOIwdvtp0 * Inv_W + + model->B4SOIpdvtp0 * Inv_LW; /* v4.0 */ + pParam->B4SOIdvtp1 = model->B4SOIdvtp1 + + model->B4SOIldvtp1 * Inv_L + + model->B4SOIwdvtp1 * Inv_W + + model->B4SOIpdvtp1 * Inv_LW; /* v4.0 */ + pParam->B4SOIminv = model->B4SOIminv + + model->B4SOIlminv * Inv_L + + model->B4SOIwminv * Inv_W + + model->B4SOIpminv * Inv_LW; /* v4.0 */ + pParam->B4SOIfprout = model->B4SOIfprout + + model->B4SOIlfprout * Inv_L + + model->B4SOIwfprout * Inv_W + + model->B4SOIpfprout * Inv_LW; /* v4.0 */ + pParam->B4SOIpdits = model->B4SOIpdits + + model->B4SOIlpdits * Inv_L + + model->B4SOIwpdits * Inv_W + + model->B4SOIppdits * Inv_LW; /* v4.0 */ + pParam->B4SOIpditsd = model->B4SOIpditsd + + model->B4SOIlpditsd * Inv_L + + model->B4SOIwpditsd * Inv_W + + model->B4SOIppditsd * Inv_LW; /* v4.0 */ + + /* Added for binning - END */ + + /* v4.0 add mstar for Vgsteff */ + pParam->B4SOImstar = 0.5 + atan(pParam->B4SOIminv) / PI; + + T0 = (TempRatio - 1.0); + + pParam->B4SOIuatemp = pParam->B4SOIua; /* save ua, ub, and uc for b4soild.c */ + pParam->B4SOIubtemp = pParam->B4SOIub; + pParam->B4SOIuctemp = pParam->B4SOIuc; + pParam->B4SOIrds0denom = pow(pParam->B4SOIweff * 1E6, pParam->B4SOIwr); + + +/* v2.2 release */ + pParam->B4SOIrth = here->B4SOIrth0 + / (pParam->B4SOIweff + model->B4SOIwth0) + * here->B4SOInseg; + pParam->B4SOIcth = here->B4SOIcth0 + * (pParam->B4SOIweff + model->B4SOIwth0) + / here->B4SOInseg; + +/* v2.2.2 adding layout-dependent Frbody multiplier */ + pParam->B4SOIrbody = here->B4SOIfrbody *model->B4SOIrbody + * model->B4SOIrhalo + / (2 * model->B4SOIrbody + + model->B4SOIrhalo * pParam->B4SOIleff) + * pParam->B4SOIweff / here->B4SOInseg + / here->B4SOInf /* v4.0 */; + + pParam->B4SOIoxideRatio = pow(model->B4SOItoxref + /model->B4SOItoxqm, model->B4SOIntox) + /model->B4SOItoxqm/model->B4SOItoxqm; +/* v2.2 release */ + + + pParam->B4SOIua = pParam->B4SOIua + pParam->B4SOIua1 * T0; + pParam->B4SOIub = pParam->B4SOIub + pParam->B4SOIub1 * T0; + pParam->B4SOIuc = pParam->B4SOIuc + pParam->B4SOIuc1 * T0; + if (pParam->B4SOIu0 > 1.0) + pParam->B4SOIu0 = pParam->B4SOIu0 / 1.0e4; + + pParam->B4SOIu0temp = pParam->B4SOIu0 + * pow(TempRatio, pParam->B4SOIute); + pParam->B4SOIvsattemp = pParam->B4SOIvsat - pParam->B4SOIat + * T0; + pParam->B4SOIrds0 = (pParam->B4SOIrdsw + + pParam->B4SOIprt * T0) + / pow(pParam->B4SOIweff * 1E6, + pParam->B4SOIwr); + + if(model->B4SOIrdsMod) { /* v4.0 */ + PowWeffWr = pParam->B4SOIrds0denom * here->B4SOInf; + T10 = pParam->B4SOIprt * T0; + /* External Rd(V) */ + T1 = pParam->B4SOIrdw + T10; + T2 = model->B4SOIrdwmin + T10; + if (T1 < 0.0) + { T1 = 0.0; + printf("Warning: Rdw at current temperature is negative; set to 0.\n"); + } + if (T2 < 0.0) + { T2 = 0.0; + printf("Warning: Rdwmin at current temperature is negative; set to 0.\n"); + } + + pParam->B4SOIrd0 = T1 / PowWeffWr; + pParam->B4SOIrdwmin = T2 / PowWeffWr; + + /* External Rs(V) */ + T3 = pParam->B4SOIrsw + T10; + T4 = model->B4SOIrswmin + T10; + if (T3 < 0.0) + { T3 = 0.0; + printf("Warning: Rsw at current temperature is negative; set to 0.\n"); + } + if (T4 < 0.0) + { T4 = 0.0; + printf("Warning: Rswmin at current temperature is negative; set to 0.\n"); + } + pParam->B4SOIrs0 = T3 / PowWeffWr; + pParam->B4SOIrswmin = T4 / PowWeffWr; + } + + if (B4SOIcheckModel(model, here, ckt)) + { IFuid namarray[2]; + namarray[0] = model->B4SOImodName; + namarray[1] = here->B4SOIname; + (*(SPfrontEnd->IFerror)) (ERR_FATAL, "Fatal error(s) detected during B4SOIV3 parameter checking for %s in model %s", namarray); + return(E_BADPARM); + } + + + pParam->B4SOIcgdo = (model->B4SOIcgdo + pParam->B4SOIcf) + * pParam->B4SOIwdiodCV; + pParam->B4SOIcgso = (model->B4SOIcgso + pParam->B4SOIcf) + * pParam->B4SOIwdiosCV; + + pParam->B4SOIcgeo = model->B4SOIcgeo * pParam->B4SOIleffCV + * here->B4SOInf; /* v4.0 */ + + + if (!model->B4SOInpeakGiven && model->B4SOIgamma1Given) + { T0 = pParam->B4SOIgamma1 * model->B4SOIcox; + pParam->B4SOInpeak = 3.021E22 * T0 * T0; + } + + + T4 = Eg300 / model->B4SOIvtm * (TempRatio - 1.0); +/* source side */ + T7 = pParam->B4SOIxbjt * T4 / pParam->B4SOIndiode; + DEXP(T7, T0); + T7 = pParam->B4SOIxdif * T4 / pParam->B4SOIndiode; + DEXP(T7, T1); + T7 = pParam->B4SOIxrec * T4 / pParam->B4SOInrecf0; + DEXP(T7, T2); + + pParam->B4SOIahli0s = pParam->B4SOIahli * T0; + pParam->B4SOIjbjts = pParam->B4SOIisbjt * T0; + pParam->B4SOIjdifs = pParam->B4SOIisdif * T1; + pParam->B4SOIjrecs = pParam->B4SOIisrec * T2; + T7 = pParam->B4SOIxtun * (TempRatio - 1); + DEXP(T7, T0); + pParam->B4SOIjtuns = pParam->B4SOIistun * T0; + +/* drain side */ + pParam->B4SOIjtund = pParam->B4SOIidtun * T0; + + T7 = pParam->B4SOIxbjt * T4 / pParam->B4SOIndioded; + DEXP(T7, T0); + T7 = pParam->B4SOIxdifd * T4 / pParam->B4SOIndioded; + DEXP(T7, T1); + T7 = pParam->B4SOIxrecd * T4 / pParam->B4SOInrecf0d; + DEXP(T7, T2); + + pParam->B4SOIahli0d = pParam->B4SOIahlid * T0; + pParam->B4SOIjbjtd = pParam->B4SOIidbjt * T0; + pParam->B4SOIjdifd = pParam->B4SOIiddif * T1; + pParam->B4SOIjrecd = pParam->B4SOIidrec * T2; + T7 = pParam->B4SOIxtund * (TempRatio - 1); + DEXP(T7, T0); + pParam->B4SOIjtund = pParam->B4SOIistun * T0; + + if (pParam->B4SOInsub > 0) + pParam->B4SOIvfbb = -model->B4SOItype * model->B4SOIvtm * + log(pParam->B4SOInpeak/ pParam->B4SOInsub); + else + pParam->B4SOIvfbb = -model->B4SOItype * model->B4SOIvtm * + log(-pParam->B4SOInpeak* pParam->B4SOInsub/ni/ni); + + if (!model->B4SOIvsdfbGiven) + { + if (pParam->B4SOInsub > 0) + pParam->B4SOIvsdfb = -model->B4SOItype * + (model->B4SOIvtm*log(1e20 * + pParam->B4SOInsub / ni /ni) - 0.3); + else if (pParam->B4SOInsub < 0) + pParam->B4SOIvsdfb = -model->B4SOItype * + (model->B4SOIvtm*log(-1e20 / + pParam->B4SOInsub) + 0.3); + } + + /* Phi & Gamma */ + SDphi = 2.0*model->B4SOIvtm*log(fabs(pParam->B4SOInsub) / ni); + SDgamma = 5.753e-12 * sqrt(fabs(pParam->B4SOInsub)) + / model->B4SOIcbox; + + if (!model->B4SOIvsdthGiven) + { + if ( ((pParam->B4SOInsub > 0) && (model->B4SOItype > 0)) || + ((pParam->B4SOInsub < 0) && (model->B4SOItype < 0)) ) + pParam->B4SOIvsdth = pParam->B4SOIvsdfb + SDphi + + SDgamma * sqrt(SDphi); + else + pParam->B4SOIvsdth = pParam->B4SOIvsdfb - SDphi - + SDgamma * sqrt(SDphi); + } + + if (!model->B4SOIcsdminGiven) { + /* Cdmin */ + tmp = sqrt(2.0 * EPSSI * SDphi / (Charge_q * + fabs(pParam->B4SOInsub) * 1.0e6)); + tmp1 = EPSSI / tmp; + model->B4SOIcsdmin = tmp1 * model->B4SOIcbox / + (tmp1 + model->B4SOIcbox); + } + + + pParam->B4SOIphi = 2.0 * model->B4SOIvtm + * log(pParam->B4SOInpeak / ni); + + pParam->B4SOIsqrtPhi = sqrt(pParam->B4SOIphi); + pParam->B4SOIphis3 = pParam->B4SOIsqrtPhi * pParam->B4SOIphi; + + pParam->B4SOIXdep0 = sqrt(2.0 * EPSSI / (Charge_q + * pParam->B4SOInpeak * 1.0e6)) + * pParam->B4SOIsqrtPhi; + pParam->B4SOIsqrtXdep0 = sqrt(pParam->B4SOIXdep0); + pParam->B4SOIlitl = sqrt(3.0 * pParam->B4SOIxj + * model->B4SOItox); + pParam->B4SOIvbi = model->B4SOIvtm * log(1.0e20 + * pParam->B4SOInpeak / (ni * ni)); + pParam->B4SOIcdep0 = sqrt(Charge_q * EPSSI + * pParam->B4SOInpeak * 1.0e6 / 2.0 + / pParam->B4SOIphi); + +/* v3.0 */ + if (pParam->B4SOIngate > 0.0) + { pParam->B4SOIvfbsd = Vtm0 * log(pParam->B4SOIngate + / 1.0e20); + } + else + pParam->B4SOIvfbsd = 0.0; + + pParam->B4SOIToxRatio = exp(model->B4SOIntox + * log(model->B4SOItoxref /model->B4SOItoxqm)) + /model->B4SOItoxqm /model->B4SOItoxqm; + pParam->B4SOIToxRatioEdge = exp(model->B4SOIntox + * log(model->B4SOItoxref + / (model->B4SOItoxqm * pParam->B4SOIpoxedge))) + / model->B4SOItoxqm / model->B4SOItoxqm + / pParam->B4SOIpoxedge / pParam->B4SOIpoxedge; + pParam->B4SOIAechvb = (model->B4SOItype == NMOS) ? 4.97232e-7 : 3.42537e-7; + pParam->B4SOIBechvb = (model->B4SOItype == NMOS) ? 7.45669e11 : 1.16645e12; + pParam->B4SOIAechvbEdge = pParam->B4SOIAechvb * pParam->B4SOIweff/here->B4SOInseg + * pParam->B4SOIdlcig * pParam->B4SOIToxRatioEdge; /* v3.1 bug fix */ + pParam->B4SOIBechvbEdge = -pParam->B4SOIBechvb + * model->B4SOItoxqm * pParam->B4SOIpoxedge; + pParam->B4SOIAechvb *= pParam->B4SOIweff/here->B4SOInseg + * pParam->B4SOIleff + * pParam->B4SOIToxRatio + + here->B4SOIagbcpd; /* v4.0 */ + + pParam->B4SOIBechvb *= -model->B4SOItoxqm; +/* v3.0 */ + + + if (model->B4SOIk1Given || model->B4SOIk2Given) + { if (!model->B4SOIk1Given) + { fprintf(stdout, "Warning: k1 should be specified with k2.\n"); + pParam->B4SOIk1 = 0.53; + } + if (!model->B4SOIk2Given) + { fprintf(stdout, "Warning: k2 should be specified with k1.\n"); + pParam->B4SOIk2 = -0.0186; + } + if (model->B4SOIxtGiven) + fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n"); + if (model->B4SOIvbxGiven) + fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n"); + if (model->B4SOIvbmGiven) + fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n"); + if (model->B4SOIgamma1Given) + fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n"); + if (model->B4SOIgamma2Given) + fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n"); + } + else + { if (!model->B4SOIvbxGiven) + pParam->B4SOIvbx = pParam->B4SOIphi - 7.7348e-4 + * pParam->B4SOInpeak + * pParam->B4SOIxt * pParam->B4SOIxt; + if (pParam->B4SOIvbx > 0.0) + pParam->B4SOIvbx = -pParam->B4SOIvbx; + if (pParam->B4SOIvbm > 0.0) + pParam->B4SOIvbm = -pParam->B4SOIvbm; + + if (!model->B4SOIgamma1Given) + pParam->B4SOIgamma1 = 5.753e-12 + * sqrt(pParam->B4SOInpeak) + / model->B4SOIcox; + if (!model->B4SOIgamma2Given) + pParam->B4SOIgamma2 = 5.753e-12 + * sqrt(pParam->B4SOInsub) + / model->B4SOIcox; + + T0 = pParam->B4SOIgamma1 - pParam->B4SOIgamma2; + T1 = sqrt(pParam->B4SOIphi - pParam->B4SOIvbx) + - pParam->B4SOIsqrtPhi; + T2 = sqrt(pParam->B4SOIphi * (pParam->B4SOIphi + - pParam->B4SOIvbm)) - pParam->B4SOIphi; + pParam->B4SOIk2 = T0 * T1 / (2.0 * T2 + pParam->B4SOIvbm); + pParam->B4SOIk1 = pParam->B4SOIgamma2 - 2.0 + * pParam->B4SOIk2 * sqrt(pParam->B4SOIphi + - pParam->B4SOIvbm); + } + + if (pParam->B4SOIk2 < 0.0) + { T0 = 0.5 * pParam->B4SOIk1 / pParam->B4SOIk2; + pParam->B4SOIvbsc = 0.9 * (pParam->B4SOIphi - T0 * T0); + if (pParam->B4SOIvbsc > -3.0) + pParam->B4SOIvbsc = -3.0; + else if (pParam->B4SOIvbsc < -30.0) + pParam->B4SOIvbsc = -30.0; + } + else + { pParam->B4SOIvbsc = -30.0; + } + if (pParam->B4SOIvbsc > pParam->B4SOIvbm) + pParam->B4SOIvbsc = pParam->B4SOIvbm; + + if ((T0 = pParam->B4SOIweff + pParam->B4SOIk1w2) < 1e-8) + T0 = 1e-8; + pParam->B4SOIk1eff = pParam->B4SOIk1 * (1 + pParam->B4SOIk1w1/T0); + + if (model->B4SOIvth0Given) + { pParam->B4SOIvfb = model->B4SOItype * pParam->B4SOIvth0 + - pParam->B4SOIphi - pParam->B4SOIk1eff + * pParam->B4SOIsqrtPhi; + } + else + { pParam->B4SOIvfb = -1.0; + pParam->B4SOIvth0 = model->B4SOItype * (pParam->B4SOIvfb + + pParam->B4SOIphi + pParam->B4SOIk1eff + * pParam->B4SOIsqrtPhi); + } + +/* v4.0 */ + pParam->B4SOIk1ox = pParam->B4SOIk1eff * model->B4SOItox + / model->B4SOItoxm; + + T1 = sqrt(EPSSI / EPSOX * model->B4SOItox + * pParam->B4SOIXdep0); + T0 = exp(-0.5 * pParam->B4SOIdsub * pParam->B4SOIleff / T1); + pParam->B4SOItheta0vb0 = (T0 + 2.0 * T0 * T0); + + T0 = exp(-0.5 * pParam->B4SOIdrout * pParam->B4SOIleff / T1); + T2 = (T0 + 2.0 * T0 * T0); + pParam->B4SOIthetaRout = pParam->B4SOIpdibl1 * T2 + + pParam->B4SOIpdibl2; + +/* stress effect */ + T0 = pow(Ldrn, model->B4SOIllodku0); + W_tmp = Wdrn + model->B4SOIwlod; + T1 = pow(W_tmp, model->B4SOIwlodku0); + tmp1 = model->B4SOIlku0 / T0 + model->B4SOIwku0 / T1 + + model->B4SOIpku0 / (T0 * T1); + pParam->B4SOIku0 = 1.0 + tmp1; + + T0 = pow(Ldrn, model->B4SOIllodvth); + T1 = pow(W_tmp, model->B4SOIwlodvth); + tmp1 = model->B4SOIlkvth0 / T0 + model->B4SOIwkvth0 / T1 + + model->B4SOIpkvth0 / (T0 * T1); + pParam->B4SOIkvth0 = 1.0 + tmp1; + pParam->B4SOIkvth0 = sqrt( pParam->B4SOIkvth0 + * pParam->B4SOIkvth0 + DELTA); + +/*dw init of TRatio is missing */ +TRatio = TempRatio; + T0 = (TRatio - 1.0); + pParam->B4SOIku0temp = pParam->B4SOIku0 * (1.0 + + model->B4SOItku0 * T0) + DELTA; + + Inv_saref = 1.0 / (model->B4SOIsaref + 0.5 * Ldrn); + Inv_sbref = 1.0 / (model->B4SOIsbref + 0.5 * Ldrn); + pParam->B4SOIinv_od_ref = Inv_saref + Inv_sbref; + pParam->B4SOIrho_ref = model->B4SOIku0 / pParam->B4SOIku0temp + * pParam->B4SOIinv_od_ref; +/* stress effect end */ + + } + + here->B4SOIcsbox = model->B4SOIcbox*here->B4SOIsourceArea; + here->B4SOIcsmin = model->B4SOIcsdmin*here->B4SOIsourceArea; + here->B4SOIcdbox = model->B4SOIcbox*here->B4SOIdrainArea; + here->B4SOIcdmin = model->B4SOIcsdmin*here->B4SOIdrainArea; + + if ( ((pParam->B4SOInsub > 0) && (model->B4SOItype > 0)) || + ((pParam->B4SOInsub < 0) && (model->B4SOItype < 0)) ) + { + T0 = pParam->B4SOIvsdth - pParam->B4SOIvsdfb; + pParam->B4SOIsdt1 = pParam->B4SOIvsdfb + model->B4SOIasd * T0; + T1 = here->B4SOIcsbox - here->B4SOIcsmin; + T2 = T1 / T0 / T0; + pParam->B4SOIst2 = T2 / model->B4SOIasd; + pParam->B4SOIst3 = T2 /( 1 - model->B4SOIasd); + here->B4SOIst4 = T0 * T1 * (1 + model->B4SOIasd) / 3 + - here->B4SOIcsmin * pParam->B4SOIvsdfb; + + T1 = here->B4SOIcdbox - here->B4SOIcdmin; + T2 = T1 / T0 / T0; + pParam->B4SOIdt2 = T2 / model->B4SOIasd; + pParam->B4SOIdt3 = T2 /( 1 - model->B4SOIasd); + here->B4SOIdt4 = T0 * T1 * (1 + model->B4SOIasd) / 3 + - here->B4SOIcdmin * pParam->B4SOIvsdfb; + } else + { + T0 = pParam->B4SOIvsdfb - pParam->B4SOIvsdth; + pParam->B4SOIsdt1 = pParam->B4SOIvsdth + model->B4SOIasd * T0; + T1 = here->B4SOIcsmin - here->B4SOIcsbox; + T2 = T1 / T0 / T0; + pParam->B4SOIst2 = T2 / model->B4SOIasd; + pParam->B4SOIst3 = T2 /( 1 - model->B4SOIasd); + here->B4SOIst4 = T0 * T1 * (1 + model->B4SOIasd) / 3 + - here->B4SOIcsbox * pParam->B4SOIvsdth; + + T1 = here->B4SOIcdmin - here->B4SOIcdbox; + T2 = T1 / T0 / T0; + pParam->B4SOIdt2 = T2 / model->B4SOIasd; + pParam->B4SOIdt3 = T2 /( 1 - model->B4SOIasd); + here->B4SOIdt4 = T0 * T1 * (1 + model->B4SOIasd) / 3 + - here->B4SOIcdbox * pParam->B4SOIvsdth; + } + + /* v2.2.2 bug fix */ + T0 = model->B4SOIcsdesw * log(1 + model->B4SOItsi / + model->B4SOItbox); + T1 = here->B4SOIsourcePerimeter - here->B4SOIw; + if (T1 > 0.0) + here->B4SOIcsesw = T0 * T1; + else + here->B4SOIcsesw = 0.0; + T1 = here->B4SOIdrainPerimeter - here->B4SOIw; + if (T1 > 0.0) + here->B4SOIcdesw = T0 * T1; + else + here->B4SOIcdesw = 0.0; + + + here->B4SOIphi = pParam->B4SOIphi; + /* process source/drain series resistance */ + here->B4SOIdrainConductance = model->B4SOIsheetResistance + * here->B4SOIdrainSquares; + if (here->B4SOIdrainConductance > 0.0) + here->B4SOIdrainConductance = 1.0 + / here->B4SOIdrainConductance; + else + here->B4SOIdrainConductance = 0.0; + + here->B4SOIsourceConductance = model->B4SOIsheetResistance + * here->B4SOIsourceSquares; + if (here->B4SOIsourceConductance > 0.0) + here->B4SOIsourceConductance = 1.0 + / here->B4SOIsourceConductance; + else + here->B4SOIsourceConductance = 0.0; + here->B4SOIcgso = pParam->B4SOIcgso; + here->B4SOIcgdo = pParam->B4SOIcgdo; + + +/* v2.0 release */ + if (model->B4SOIln < 1e-15) model->B4SOIln = 1e-15; + T0 = -0.5 * pParam->B4SOIleff * pParam->B4SOIleff / model->B4SOIln / model->B4SOIln; + DEXP(T0,T1); + pParam->B4SOIarfabjt = T1; + + T0 = pParam->B4SOIlbjt0 * (1.0 / pParam->B4SOIleff + 1.0 / model->B4SOIln); + pParam->B4SOIlratio = pow(T0,pParam->B4SOInbjt); + pParam->B4SOIlratiodif = 1.0 + model->B4SOIldif0 * pow(T0,pParam->B4SOIndif); + + if ((pParam->B4SOIvearly = pParam->B4SOIvabjt + pParam->B4SOIaely * pParam->B4SOIleff) < 1) + pParam->B4SOIvearly = 1; + + /* vfbzb calculation for capMod 3 */ + tmp = sqrt(pParam->B4SOIXdep0); + tmp1 = pParam->B4SOIvbi - pParam->B4SOIphi; + tmp2 = model->B4SOIfactor1 * tmp; + + T0 = -0.5 * pParam->B4SOIdvt1w * pParam->B4SOIweff + * pParam->B4SOIleff / tmp2; + if (T0 > -EXPL_THRESHOLD) + { T1 = exp(T0); + T2 = T1 * (1.0 + 2.0 * T1); + } + else + { T1 = MIN_EXPL; + T2 = T1 * (1.0 + 2.0 * T1); + } + T0 = pParam->B4SOIdvt0w * T2; + T2 = T0 * tmp1; + + T0 = -0.5 * pParam->B4SOIdvt1 * pParam->B4SOIleff / tmp2; + if (T0 > -EXPL_THRESHOLD) + { T1 = exp(T0); + T3 = T1 * (1.0 + 2.0 * T1); + } + else + { T1 = MIN_EXPL; + T3 = T1 * (1.0 + 2.0 * T1); + } + T3 = pParam->B4SOIdvt0 * T3 * tmp1; + +/* v2.2.3 */ + T4 = (model->B4SOItox - model->B4SOIdtoxcv) * pParam->B4SOIphi + / (pParam->B4SOIweff + pParam->B4SOIw0); + + T0 = sqrt(1.0 + pParam->B4SOIlpe0 / pParam->B4SOIleff); /*v4.0*/ + T5 = pParam->B4SOIk1ox * (T0 - 1.0) * pParam->B4SOIsqrtPhi + + (pParam->B4SOIkt1 + pParam->B4SOIkt1l / pParam->B4SOIleff) + * (TempRatio - 1.0); /* v4.0 */ + + tmp3 = model->B4SOItype * pParam->B4SOIvth0 + - T2 - T3 + pParam->B4SOIk3 * T4 + T5; + pParam->B4SOIvfbzb = tmp3 - pParam->B4SOIphi - pParam->B4SOIk1 + * pParam->B4SOIsqrtPhi; + /* End of vfbzb */ + + + /* v3.2 */ + pParam->B4SOIqsi = Charge_q * model->B4SOInpeak + * (1.0 + pParam->B4SOIlpe0 / pParam->B4SOIleff) + * 1e6 * model->B4SOItsi; + + + /* v3.1 added for RF */ + here->B4SOIgrgeltd = model->B4SOIrshg * (model->B4SOIxgw + + pParam->B4SOIweff / here->B4SOInseg + / 3.0 / model->B4SOIngcon) / + (model->B4SOIngcon * here->B4SOInf * + (here->B4SOIl - model->B4SOIxgl)); + if (here->B4SOIgrgeltd > 0.0) + here->B4SOIgrgeltd = 1.0 / here->B4SOIgrgeltd; + else + { here->B4SOIgrgeltd = 1.0e3; /* mho */ + if (here->B4SOIrgateMod !=0) + printf("Warning: The gate conductance reset to 1.0e3 mho.\n"); + } + /* v3.1 added for RF end */ + + /* v4.0 rbodyMod */ + if (here->B4SOIrbodyMod) + { if (here->B4SOIrbdb < 1.0e-3) + here->B4SOIgrbdb = 1.0e3; /* in mho */ + else + here->B4SOIgrbdb = model->B4SOIgbmin + + 1.0 / here->B4SOIrbdb; + if (here->B4SOIrbsb < 1.0e-3) + here->B4SOIgrbsb = 1.0e3; + else + here->B4SOIgrbsb = model->B4SOIgbmin + + 1.0 / here->B4SOIrbsb; + } + /* v4.0 rbodyMod end */ + + /* v4.0 stress effect */ + if( (here->B4SOIsa > 0.0) && (here->B4SOIsb > 0.0) && + ( (here->B4SOInf == 1.0) || + ((here->B4SOInf > 1.0) && (here->B4SOIsd > 0.0)) + ) + ) + { Inv_sa = 0; + Inv_sb = 0; + + if (model->B4SOIwlod < 0.0) + { fprintf(stderr, "Warning: WLOD = %g is less than 0. Set to 0.0\n",model->B4SOIwlod); + model->B4SOIwlod = 0.0; + } + + if (model->B4SOIkvsat < -1.0 ) + { fprintf(stderr, "Warning: KVSAT = %g is too small; Reset to -1.0.\n",model->B4SOIkvsat); + here->B4SOIkvsat = kvsat = -1.0; + } + else if (model->B4SOIkvsat > 1.0) + { fprintf(stderr, "Warning: KVSAT = %g is too big; Reset to 1.0.\n",model->B4SOIkvsat); + here->B4SOIkvsat = kvsat = 1.0; + } + else here->B4SOIkvsat = model->B4SOIkvsat; + + for(i = 0; i < here->B4SOInf; i++) { + T0 = 1.0 / here->B4SOInf / (here->B4SOIsa + + 0.5*Ldrn + i * (here->B4SOIsd +Ldrn)); + T1 = 1.0 / here->B4SOInf / (here->B4SOIsb + + 0.5*Ldrn + i * (here->B4SOIsd +Ldrn)); + Inv_sa += T0; + Inv_sb += T1; + } + + Inv_ODeff = Inv_sa + Inv_sb; + here->B4SOIInv_ODeff = Inv_ODeff; + rho = model->B4SOIku0 / pParam->B4SOIku0temp * Inv_ODeff; + T0 = (1.0 + rho)/(1.0 + pParam->B4SOIrho_ref); + here->B4SOIu0temp = pParam->B4SOIu0temp * T0; + + T1 = (1.0 + kvsat * rho)/(1.0 + kvsat * pParam->B4SOIrho_ref); + here->B4SOIvsattemp = pParam->B4SOIvsattemp * T1; + + OD_offset = Inv_ODeff - pParam->B4SOIinv_od_ref; + dvth0_lod = model->B4SOIkvth0 + / pParam->B4SOIkvth0 * OD_offset; + dk2_lod = model->B4SOIstk2 + / pow(pParam->B4SOIkvth0, model->B4SOIlodk2) + * OD_offset; + deta0_lod = model->B4SOIsteta0 + / pow(pParam->B4SOIkvth0, model->B4SOIlodeta0) + * OD_offset; + here->B4SOIvth0 = pParam->B4SOIvth0 + dvth0_lod; + + here->B4SOIk2 = pParam->B4SOIk2 + dk2_lod; + + here->B4SOIeta0 = pParam->B4SOIeta0 + deta0_lod; + } + else { + here->B4SOIu0temp = pParam->B4SOIu0temp; + here->B4SOIvth0 = pParam->B4SOIvth0; + here->B4SOIvsattemp = pParam->B4SOIvsattemp; + here->B4SOIk2 = pParam->B4SOIk2; + here->B4SOIeta0 = pParam->B4SOIeta0; + here->B4SOIInv_ODeff = 0; + } /* v4.0 stress effect end */ + + here->B4SOIk2ox = here->B4SOIk2 * model->B4SOItox + / model->B4SOItoxm; /* v4.0 */ + here->B4SOIvth0 += here->B4SOIdelvto; /* v4.0 */ + here->B4SOIvfb = pParam->B4SOIvfb + model->B4SOItype * here->B4SOIdelvto; + here->B4SOIvfbzb = pParam->B4SOIvfbzb + model->B4SOItype * here->B4SOIdelvto; + + pParam->B4SOIldeb = sqrt(EPSSI * Vtm0 / + (Charge_q * pParam->B4SOInpeak * 1.0e6)) / 3.0; + } + } + return(OK); +} + diff --git a/src/spicelib/devices/bsim3soi/b4soitrunc.c b/src/spicelib/devices/bsim3soi/b4soitrunc.c new file mode 100644 index 000000000..a9a2d96ed --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b4soitrunc.c @@ -0,0 +1,53 @@ +/*** B4SOI 11/30/2005 Xuemei (Jane) Xi Release ***/ + +/********** + * Copyright 2005 Regents of the University of California. All rights reserved. + * Authors: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang + * Authors: 1999-2004 Pin Su, Hui Wan, Wei Jin, b3soitrunc.c + * Authors: 2005- Hui Wan, Xuemei Xi, Ali Niknejad, Chenming Hu. + * File: b4soitrunc.c + * Modified by Hui Wan, Xuemei Xi 11/30/2005 + **********/ + +#include "ngspice.h" +#include "cktdefs.h" +#include "b4soidef.h" +#include "sperror.h" +#include "suffix.h" + + +int +B4SOItrunc(GENmodel *inModel, CKTcircuit *ckt, double *timeStep) +{ +register B4SOImodel *model = (B4SOImodel*)inModel; +register B4SOIinstance *here; + +#ifdef STEPDEBUG + double debugtemp; +#endif /* STEPDEBUG */ + + for (; model != NULL; model = model->B4SOInextModel) + { for (here = model->B4SOIinstances; here != NULL; + here = here->B4SOInextInstance) + { + if (here->B4SOIowner != ARCHme) + continue; +#ifdef STEPDEBUG + debugtemp = *timeStep; +#endif /* STEPDEBUG */ + CKTterr(here->B4SOIqb,ckt,timeStep); + CKTterr(here->B4SOIqg,ckt,timeStep); + CKTterr(here->B4SOIqd,ckt,timeStep); +#ifdef STEPDEBUG + if(debugtemp != *timeStep) + { printf("device %s reduces step from %g to %g\n", + here->B4SOIname,debugtemp,*timeStep); + } +#endif /* STEPDEBUG */ + } + } + return(OK); +} + + + diff --git a/src/spicelib/devices/dev.c b/src/spicelib/devices/dev.c index eb973b6e5..fb2fe0339 100644 --- a/src/spicelib/devices/dev.c +++ b/src/spicelib/devices/dev.c @@ -89,7 +89,7 @@ int add_udn(int,Evt_Udn_Info_t **); #include "bsim4v3/bsim4v3itf.h" #include "bsim4v4/bsim4v4itf.h" #include "bsim4v5/bsim4v5itf.h" -#include "bsim3soi/b3soiitf.h" +#include "bsim3soi/b4soiitf.h" #include "bsim3soi_pd/b3soipditf.h" #include "bsim3soi_fd/b3soifditf.h" #include "bsim3soi_dd/b3soidditf.h" @@ -195,7 +195,7 @@ spice_init_devices(void) DEVices[ 9] = get_bsim3v1a_info(); DEVices[10] = get_bsim3v1s_info(); DEVices[11] = get_bsim3v32_info(); - DEVices[12] = get_b3soi_info(); + DEVices[12] = get_b4soi_info(); DEVices[13] = get_bsim4_info(); DEVices[14] = get_bsim4v2_info(); DEVices[15] = get_bsim4v3_info(); @@ -294,12 +294,12 @@ SPICEdev ** devices(void) #ifdef ADMS #define DEVICES_USED {"asrc", "bjt", "bjt2", "vbic", "bsim1", "bsim2", "bsim3", "bsim3v32", "bsim3v2", "bsim3v1", "bsim4", "bsim4v2", "bsim4v3", "bsim4v4", "bsim4v5", \ - "bsim3soipd", "bsim3soifd", "bsim3soidd", \ + "bsim4soi", "bsim3soipd", "bsim3soifd", "bsim3soidd", \ "cap", "cccs", "ccvs", "csw", "dio", "hfet", "hfet2", "ind", "isrc", "jfet", "ltra", "mes", "mesa" ,"mos1", "mos2", "mos3", \ "mos6", "mos9", "res", "soi3", "sw", "tra", "urc", "vccs", "vcvs", "vsrc", "hicum0", "hicum2", "mextram", "ekv", "psp102"} #else #define DEVICES_USED {"asrc", "bjt", "bjt2", "vbic", "bsim1", "bsim2", "bsim3", "bsim3v32", "bsim3v2", "bsim3v1", "bsim4", "bsim4v4", "bsim4v2", "bsim4v3", "bsim4v4", "bsim4v5", \ - "bsim3soipd", "bsim3soifd", "bsim3soidd", \ + "bsim4soi", "bsim3soipd", "bsim3soifd", "bsim3soidd", \ "cap", "cccs", "ccvs", "csw", "dio", "hfet", "hfet2", "ind", "isrc", "jfet", "ltra", "mes", "mesa" ,"mos1", "mos2", "mos3", \ "mos6", "mos9", "res", "soi3", "sw", "tra", "urc", "vccs", "vcvs", "vsrc"} #endif diff --git a/src/spicelib/parser/inp2m.c b/src/spicelib/parser/inp2m.c index dfcfecc86..d42a0511f 100644 --- a/src/spicelib/parser/inp2m.c +++ b/src/spicelib/parser/inp2m.c @@ -113,14 +113,14 @@ INP2M (void *ckt, INPtables * tab, card * current) INPgetMod (ckt, model, &thismodel, tab); /* get pointer to the model */ if (thismodel != NULL) { - if ((thismodel->INPmodType != INPtypelook ("B3SOI")) && + if ((thismodel->INPmodType != INPtypelook ("B4SOI")) && (thismodel->INPmodType != INPtypelook ("B3SOIPD")) && (thismodel->INPmodType != INPtypelook ("B3SOIFD")) && (thismodel->INPmodType != INPtypelook ("B3SOIDD")) ) { /* if model is not variable node B3SOIPD/FD/DD model, error! */ - LITERR ("only level 9, 29-31 B3SOI(PD | FD | DD) can have 7 nodes") return; + LITERR ("only level 55-58: B3SOI(PD|FD|DD) and B4SOI can have 7 nodes") return; } else { /* if looking at B3SOIPD/FD/DD model, allocate the 7th node */ @@ -140,8 +140,8 @@ INP2M (void *ckt, INPtables * tab, card * current) /*saj*/ } else - { /* 7th token is a model - only have 6 terminal device */ - if ((thismodel->INPmodType != INPtypelook ("B3SOI")) && + { /* 7th token is a model - only have 6 terminal device */ + if ((thismodel->INPmodType != INPtypelook ("B4SOI")) && (thismodel->INPmodType != INPtypelook ("B3SOIPD")) && (thismodel->INPmodType != INPtypelook ("B3SOIFD")) && (thismodel->INPmodType != INPtypelook ("B3SOIDD")) && @@ -149,10 +149,10 @@ INP2M (void *ckt, INPtables * tab, card * current) ) { /* if model is not variable node B3SOIPD/FD/DD or STAG model, error! */ - LITERR ("only level 9, 29-31 B3SOI(PD | FD | DD) and STAG (SOI3) can have 6 nodes") return; + LITERR ("only level 55-58,60: B3SOI(PD|FD|DD), B4SOI and STAG (SOI3) can have 6 nodes") return; } else - { /* if looking at B3SOIPD/FD/DD or STAG (SOI3) model, allocate the 6th node */ + { /* if looking at B3SOIPD/FD/DD or STAG (SOI3) model, allocate the 6th node */ INPtermInsert (ckt, &nname5, tab, &node5); INPtermInsert (ckt, &nname6, tab, &node6); model = nname7; @@ -160,8 +160,8 @@ INP2M (void *ckt, INPtables * tab, card * current) } } else - { /* 6th token is a model - only have 5 terminal device */ - if ((thismodel->INPmodType != INPtypelook ("B3SOI")) && + { /* 6th token is a model - only have 5 terminal device */ + if ((thismodel->INPmodType != INPtypelook ("B4SOI")) && (thismodel->INPmodType != INPtypelook ("B3SOIPD")) && (thismodel->INPmodType != INPtypelook ("B3SOIFD")) && (thismodel->INPmodType != INPtypelook ("B3SOIDD")) && @@ -169,10 +169,10 @@ INP2M (void *ckt, INPtables * tab, card * current) ) { /* if model is not variable node B3SOIPD/FD/DD model, error! */ - LITERR ("only level 9, 29-31 B3SOI(PD | FD | DD) and STAG (SOI3) can have 5 nodes") return; + LITERR ("only level 55-58,60: B3SOI(PD|FD|DD), B4SOI and STAG (SOI3) can have 5 nodes") return; } else - { /* if looking at B3SOIPD/FD/DD or STAG (SOI3) model, allocate the 5th node */ + { /* if looking at B3SOIPD/FD/DD or STAG (SOI3) model, allocate the 5th node */ INPtermInsert (ckt, &nname5, tab, &node5); model = nname6; /* make model point to the correct token */ } @@ -211,7 +211,7 @@ INP2M (void *ckt, INPtables * tab, card * current) && thismodel->INPmodType != INPtypelook ("BSIM2") && thismodel->INPmodType != INPtypelook ("BSIM3") && thismodel->INPmodType != INPtypelook ("BSIM3v32") - && thismodel->INPmodType != INPtypelook ("B3SOI") + && thismodel->INPmodType != INPtypelook ("B4SOI") && thismodel->INPmodType != INPtypelook ("B3SOIPD") && thismodel->INPmodType != INPtypelook ("B3SOIFD") && thismodel->INPmodType != INPtypelook ("B3SOIDD") @@ -263,7 +263,7 @@ INP2M (void *ckt, INPtables * tab, card * current) IFC (bindNode, (ckt, fast, 3, node3)); IFC (bindNode, (ckt, fast, 4, node4)); /*use type not thismodel->INPmodType as it might not exist!*/ - if ((type == INPtypelook ("B3SOI")) || + if ((type == INPtypelook ("B4SOI")) || (type == INPtypelook ("B3SOIPD")) || (type == INPtypelook ("B3SOIFD")) || (type == INPtypelook ("B3SOIDD")) || diff --git a/src/spicelib/parser/inpdomod.c b/src/spicelib/parser/inpdomod.c index 686d01d89..b26dbfeae 100644 --- a/src/spicelib/parser/inpdomod.c +++ b/src/spicelib/parser/inpdomod.c @@ -391,11 +391,11 @@ char *INPdomodel(void *ckt, card * image, INPtables * tab) } break; case 58: - type = INPtypelook("B3SOI"); + type = INPtypelook("B4SOI"); if (type < 0) { err = INPmkTemp - ("Device type B3SOI V3.0 not available in this binary\n"); + ("Device type B4SOI V4.0 not available in this binary\n"); } break; case 60: