diff --git a/src/spicelib/devices/bsim3soi/Makefile.am b/src/spicelib/devices/bsim3soi/Makefile.am new file mode 100644 index 000000000..900bc5a3e --- /dev/null +++ b/src/spicelib/devices/bsim3soi/Makefile.am @@ -0,0 +1,34 @@ +## Process this file with automake to produce Makefile.in + +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 + + + +INCLUDES = -I$(top_srcdir)/src/include + +MAINTAINERCLEANFILES = Makefile.in diff --git a/src/spicelib/devices/bsim3soi/b3soi.c b/src/spicelib/devices/bsim3soi/b3soi.c new file mode 100644 index 000000000..2d6aca6f1 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soi.c @@ -0,0 +1,645 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soi.c 98/5/01 +Modified by Pin Su and Jan Feng 99/2/15 +Modified by Pin Su 99/4/30 +Modified by Wei Jin 99/9/27 +Modified by Pin Su 00/3/1 +Modified by Pin Su 01/2/15 +Modified by Pin Su 02/3/5 +Modified by Pin Su 02/5/20 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "devdefs.h" +#include "b3soidef.h" +#include "suffix.h" + +IFparm B3SOIpTable[] = { /* parameters */ +IOP( "l", B3SOI_L, IF_REAL , "Length"), +IOP( "w", B3SOI_W, IF_REAL , "Width"), +IOP( "m", B3SOI_M, IF_REAL , "Parallel Multiplier"), +IOP( "ad", B3SOI_AD, IF_REAL , "Drain area"), +IOP( "as", B3SOI_AS, IF_REAL , "Source area"), +IOP( "pd", B3SOI_PD, IF_REAL , "Drain perimeter"), +IOP( "ps", B3SOI_PS, IF_REAL , "Source perimeter"), +IOP( "nrd", B3SOI_NRD, IF_REAL , "Number of squares in drain"), +IOP( "nrs", B3SOI_NRS, IF_REAL , "Number of squares in source"), +IOP( "off", B3SOI_OFF, IF_FLAG , "Device is initially off"), +IP( "ic", B3SOI_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"), +OP( "gmbs", B3SOI_GMBS, IF_REAL, "Gmb"), +OP( "gm", B3SOI_GM, IF_REAL, "Gm"), +OP( "gm/ids", B3SOI_GMID, IF_REAL, "Gm/Ids"), +OP( "gds", B3SOI_GDS, IF_REAL, "Gds"), +OP( "vdsat", B3SOI_VDSAT, IF_REAL, "Vdsat"), +OP( "vth", B3SOI_VON, IF_REAL, "Vth"), +OP( "ids", B3SOI_CD, IF_REAL, "Ids"), +OP( "vbs", B3SOI_VBS, IF_REAL, "Vbs"), +OP( "vgs", B3SOI_VGS, IF_REAL, "Vgs"), +OP( "vds", B3SOI_VDS, IF_REAL, "Vds"), +OP( "ves", B3SOI_VES, IF_REAL, "Ves"), +IOP( "bjtoff", B3SOI_BJTOFF, IF_INTEGER, "BJT on/off flag"), +IOP( "debug", B3SOI_DEBUG, IF_INTEGER, "BJT on/off flag"), +IOP( "rth0", B3SOI_RTH0, IF_REAL, "Instance Thermal Resistance"), +IOP( "cth0", B3SOI_CTH0, IF_REAL, "Instance Thermal Capacitance"), +IOP( "nrb", B3SOI_NRB, IF_REAL, "Number of squares in body"), +IOP( "frbody", B3SOI_FRBODY, IF_REAL, "layout dependent body-resistance coefficient"), + + +/* v2.0 release */ +IOP( "nbc", B3SOI_NBC, IF_REAL, "Number of body contact isolation edge"), +IOP( "nseg", B3SOI_NSEG, IF_REAL, "Number segments for width partitioning"), +IOP( "pdbcp", B3SOI_PDBCP, IF_REAL, "Perimeter length for bc parasitics at drain side"), +IOP( "psbcp", B3SOI_PSBCP, IF_REAL, "Perimeter length for bc parasitics at source side"), +IOP( "agbcp", B3SOI_AGBCP, IF_REAL, "Gate to body overlap area for bc parasitics"), +IOP( "aebcp", B3SOI_AEBCP, IF_REAL, "Substrate to body overlap area for bc prasitics"), +IOP( "vbsusr", B3SOI_VBSUSR, IF_REAL, "Vbs specified by user"), +IOP( "tnodeout", B3SOI_TNODEOUT, IF_FLAG, "Flag indicating external temp node") + +}; + +IFparm B3SOImPTable[] = { /* model parameters */ +IOP( "capmod", B3SOI_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"), +IOP( "mobmod", B3SOI_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"), +IOP( "noimod", B3SOI_MOD_NOIMOD, IF_INTEGER, "Noise model selector"), +IOP( "paramchk", B3SOI_MOD_PARAMCHK, IF_INTEGER, "Model parameter checking selector"), +IOP( "binunit", B3SOI_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"), +IOP( "version", B3SOI_MOD_VERSION, IF_REAL, " parameter for model version"), +IOP( "tox", B3SOI_MOD_TOX, IF_REAL, "Gate oxide thickness in meters"), +IOP( "dtoxcv", B3SOI_MOD_DTOXCV, IF_REAL, "Delta oxide thickness in meters in CapMod3"), /* v2.2.3 */ + +IOP( "cdsc", B3SOI_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"), +IOP( "cdscb", B3SOI_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"), +IOP( "cdscd", B3SOI_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"), +IOP( "cit", B3SOI_MOD_CIT, IF_REAL, "Interface state capacitance"), +IOP( "nfactor", B3SOI_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"), +IOP( "vsat", B3SOI_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"), +IOP( "at", B3SOI_MOD_AT, IF_REAL, "Temperature coefficient of vsat"), +IOP( "a0", B3SOI_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."), +IOP( "ags", B3SOI_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."), +IOP( "a1", B3SOI_MOD_A1, IF_REAL, "Non-saturation effect coefficient"), +IOP( "a2", B3SOI_MOD_A2, IF_REAL, "Non-saturation effect coefficient"), +IOP( "keta", B3SOI_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."), +IOP( "nsub", B3SOI_MOD_NSUB, IF_REAL, "Substrate doping concentration with polarity"), +IOP( "nch", B3SOI_MOD_NPEAK, IF_REAL, "Channel doping concentration"), +IOP( "ngate", B3SOI_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"), +IOP( "gamma1", B3SOI_MOD_GAMMA1, IF_REAL, "Vth body coefficient"), +IOP( "gamma2", B3SOI_MOD_GAMMA2, IF_REAL, "Vth body coefficient"), +IOP( "vbx", B3SOI_MOD_VBX, IF_REAL, "Vth transition body Voltage"), +IOP( "vbm", B3SOI_MOD_VBM, IF_REAL, "Maximum body voltage"), + +IOP( "xt", B3SOI_MOD_XT, IF_REAL, "Doping depth"), +IOP( "k1", B3SOI_MOD_K1, IF_REAL, "Bulk effect coefficient 1"), +IOP( "kt1", B3SOI_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"), +IOP( "kt1l", B3SOI_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"), +IOP( "kt2", B3SOI_MOD_KT2, IF_REAL, "Body-coefficient of kt1"), +IOP( "k2", B3SOI_MOD_K2, IF_REAL, "Bulk effect coefficient 2"), +IOP( "k3", B3SOI_MOD_K3, IF_REAL, "Narrow width effect coefficient"), +IOP( "k3b", B3SOI_MOD_K3B, IF_REAL, "Body effect coefficient of k3"), +IOP( "w0", B3SOI_MOD_W0, IF_REAL, "Narrow width effect parameter"), +IOP( "nlx", B3SOI_MOD_NLX, IF_REAL, "Lateral non-uniform doping effect"), +IOP( "dvt0", B3SOI_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"), +IOP( "dvt1", B3SOI_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"), +IOP( "dvt2", B3SOI_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"), +IOP( "dvt0w", B3SOI_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"), +IOP( "dvt1w", B3SOI_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"), +IOP( "dvt2w", B3SOI_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"), +IOP( "drout", B3SOI_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"), +IOP( "dsub", B3SOI_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"), +IOP( "vth0", B3SOI_MOD_VTH0, IF_REAL,"Threshold voltage"), +IOP( "vtho", B3SOI_MOD_VTH0, IF_REAL,"Threshold voltage"), +IOP( "ua", B3SOI_MOD_UA, IF_REAL, "Linear gate dependence of mobility"), +IOP( "ua1", B3SOI_MOD_UA1, IF_REAL, "Temperature coefficient of ua"), +IOP( "ub", B3SOI_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"), +IOP( "ub1", B3SOI_MOD_UB1, IF_REAL, "Temperature coefficient of ub"), +IOP( "uc", B3SOI_MOD_UC, IF_REAL, "Body-bias dependence of mobility"), +IOP( "uc1", B3SOI_MOD_UC1, IF_REAL, "Temperature coefficient of uc"), +IOP( "u0", B3SOI_MOD_U0, IF_REAL, "Low-field mobility at Tnom"), +IOP( "ute", B3SOI_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"), +IOP( "voff", B3SOI_MOD_VOFF, IF_REAL, "Threshold voltage offset"), +IOP( "tnom", B3SOI_MOD_TNOM, IF_REAL, "Parameter measurement temperature"), +IOP( "cgso", B3SOI_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"), +IOP( "cgdo", B3SOI_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"), +IOP( "xpart", B3SOI_MOD_XPART, IF_REAL, "Channel charge partitioning"), +IOP( "delta", B3SOI_MOD_DELTA, IF_REAL, "Effective Vds parameter"), +IOP( "rsh", B3SOI_MOD_RSH, IF_REAL, "Source-drain sheet resistance"), +IOP( "rdsw", B3SOI_MOD_RDSW, IF_REAL, "Source-drain resistance per width"), + +IOP( "prwg", B3SOI_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "), +IOP( "prwb", B3SOI_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "), + +IOP( "prt", B3SOI_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "), +IOP( "eta0", B3SOI_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"), +IOP( "etab", B3SOI_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"), +IOP( "pclm", B3SOI_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"), +IOP( "pdiblc1", B3SOI_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"), +IOP( "pdiblc2", B3SOI_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"), +IOP( "pdiblcb", B3SOI_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"), + +IOP( "pvag", B3SOI_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"), + +IOP( "shmod", B3SOI_MOD_SHMOD, IF_INTEGER, "Self heating mode selector"), +IOP( "ddmod", B3SOI_MOD_DDMOD, IF_INTEGER, "Dynamic depletion mode selector"), +IOP( "tbox", B3SOI_MOD_TBOX, IF_REAL, "Back gate oxide thickness in meters"), +IOP( "tsi", B3SOI_MOD_TSI, IF_REAL, "Silicon-on-insulator thickness in meters"), +IOP( "xj", B3SOI_MOD_XJ, IF_REAL, "Junction Depth"), +IOP( "rth0", B3SOI_MOD_RTH0, IF_REAL, "Self-heating thermal resistance"), +IOP( "cth0", B3SOI_MOD_CTH0, IF_REAL, "Self-heating thermal capacitance"), +IOP( "ngidl", B3SOI_MOD_NGIDL, IF_REAL, "GIDL first parameter"), +IOP( "agidl", B3SOI_MOD_AGIDL, IF_REAL, "GIDL second parameter"), +IOP( "bgidl", B3SOI_MOD_BGIDL, IF_REAL, "GIDL third parameter"), +IOP( "ndiode", B3SOI_MOD_NDIODE, IF_REAL, "Diode non-ideality factor"), +IOP( "xbjt", B3SOI_MOD_XBJT, IF_REAL, "Temperature coefficient for Isbjt"), + +IOP( "xdif", B3SOI_MOD_XDIF, IF_REAL, "Temperature coefficient for Isdif"), + +IOP( "xrec", B3SOI_MOD_XREC, IF_REAL, "Temperature coefficient for Isrec"), +IOP( "xtun", B3SOI_MOD_XTUN, IF_REAL, "Temperature coefficient for Istun"), + +IOP( "pbswg", B3SOI_MOD_PBSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance built in potential"), +IOP( "mjswg", B3SOI_MOD_MJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance grading coefficient"), + +IOP( "cjswg", B3SOI_MOD_CJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance per unit width"), +IOP( "lint", B3SOI_MOD_LINT, IF_REAL, "Length reduction parameter"), +IOP( "ll", B3SOI_MOD_LL, IF_REAL, "Length reduction parameter"), +IOP( "llc", B3SOI_MOD_LLC, IF_REAL, "Length reduction parameter"), /* v2.2.3 */ +IOP( "lln", B3SOI_MOD_LLN, IF_REAL, "Length reduction parameter"), +IOP( "lw", B3SOI_MOD_LW, IF_REAL, "Length reduction parameter"), +IOP( "lwc", B3SOI_MOD_LWC, IF_REAL, "Length reduction parameter"), /* v2.2.3 */ +IOP( "lwn", B3SOI_MOD_LWN, IF_REAL, "Length reduction parameter"), +IOP( "lwl", B3SOI_MOD_LWL, IF_REAL, "Length reduction parameter"), +IOP( "lwlc", B3SOI_MOD_LWLC, IF_REAL, "Length reduction parameter"), /* v2.2.3 */ + +IOP( "wr", B3SOI_MOD_WR, IF_REAL, "Width dependence of rds"), +IOP( "wint", B3SOI_MOD_WINT, IF_REAL, "Width reduction parameter"), +IOP( "dwg", B3SOI_MOD_DWG, IF_REAL, "Width reduction parameter"), +IOP( "dwb", B3SOI_MOD_DWB, IF_REAL, "Width reduction parameter"), + +IOP( "wl", B3SOI_MOD_WL, IF_REAL, "Width reduction parameter"), +IOP( "wlc", B3SOI_MOD_WLC, IF_REAL, "Width reduction parameter"), /* v2.2.3 */ +IOP( "wln", B3SOI_MOD_WLN, IF_REAL, "Width reduction parameter"), +IOP( "ww", B3SOI_MOD_WW, IF_REAL, "Width reduction parameter"), +IOP( "wwc", B3SOI_MOD_WWC, IF_REAL, "Width reduction parameter"), /* v2.2.3 */ +IOP( "wwn", B3SOI_MOD_WWN, IF_REAL, "Width reduction parameter"), +IOP( "wwl", B3SOI_MOD_WWL, IF_REAL, "Width reduction parameter"), +IOP( "wwlc", B3SOI_MOD_WWLC, IF_REAL, "Width reduction parameter"), /* v2.2.3 */ + +IOP( "b0", B3SOI_MOD_B0, IF_REAL, "Abulk narrow width parameter"), +IOP( "b1", B3SOI_MOD_B1, IF_REAL, "Abulk narrow width parameter"), + +IOP( "cgsl", B3SOI_MOD_CGSL, IF_REAL, "New C-V model parameter"), +IOP( "cgdl", B3SOI_MOD_CGDL, IF_REAL, "New C-V model parameter"), +IOP( "ckappa", B3SOI_MOD_CKAPPA, IF_REAL, "New C-V model parameter"), +IOP( "cf", B3SOI_MOD_CF, IF_REAL, "Fringe capacitance parameter"), +IOP( "clc", B3SOI_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"), +IOP( "cle", B3SOI_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"), +IOP( "dwc", B3SOI_MOD_DWC, IF_REAL, "Delta W for C-V model"), +IOP( "dlc", B3SOI_MOD_DLC, IF_REAL, "Delta L for C-V model"), + +IOP( "alpha0", B3SOI_MOD_ALPHA0, IF_REAL, "substrate current model parameter"), + +IOP( "noia", B3SOI_MOD_NOIA, IF_REAL, "Flicker noise parameter"), +IOP( "noib", B3SOI_MOD_NOIB, IF_REAL, "Flicker noise parameter"), +IOP( "noic", B3SOI_MOD_NOIC, IF_REAL, "Flicker noise parameter"), +IOP( "em", B3SOI_MOD_EM, IF_REAL, "Flicker noise parameter"), +IOP( "ef", B3SOI_MOD_EF, IF_REAL, "Flicker noise frequency exponent"), +IOP( "af", B3SOI_MOD_AF, IF_REAL, "Flicker noise exponent"), +IOP( "kf", B3SOI_MOD_KF, IF_REAL, "Flicker noise coefficient"), +IOP( "noif", B3SOI_MOD_NOIF, IF_REAL, "Floating body excess noise ideality factor"), + + +/* v2.0 release */ +IOP( "k1w1", B3SOI_MOD_K1W1, IF_REAL, "First Body effect width dependent parameter"), +IOP( "k1w2", B3SOI_MOD_K1W2, IF_REAL, "Second Boby effect width dependent parameter"), +IOP( "ketas", B3SOI_MOD_KETAS, IF_REAL, "Surface potential adjustment for bulk charge effect"), +IOP( "dwbc", B3SOI_MOD_DWBC, IF_REAL, "Width offset for body contact isolation edge"), +IOP( "beta0", B3SOI_MOD_BETA0, IF_REAL, "First Vds dependent parameter of impact ionizition current"), +IOP( "beta1", B3SOI_MOD_BETA1, IF_REAL, "Second Vds dependent parameter of impact ionizition current"), +IOP( "beta2", B3SOI_MOD_BETA2, IF_REAL, "Third Vds dependent parameter of impact ionizition current"), +IOP( "vdsatii0", B3SOI_MOD_VDSATII0, IF_REAL, "Nominal drain saturation voltage at threshold for impact ionizition current"), +IOP( "tii", B3SOI_MOD_TII, IF_REAL, "Temperature dependent parameter for impact ionizition"), +IOP( "lii", B3SOI_MOD_LII, IF_REAL, "Channel length dependent parameter at threshold for impact ionizition current"), +IOP( "sii0", B3SOI_MOD_SII0, IF_REAL, "First Vgs dependent parameter for impact ionizition current"), +IOP( "sii1", B3SOI_MOD_SII1, IF_REAL, "Second Vgs dependent parameter for impact ionizition current"), +IOP( "sii2", B3SOI_MOD_SII2, IF_REAL, "Third Vgs dependent parameter for impact ionizition current"), +IOP( "siid", B3SOI_MOD_SIID, IF_REAL, "Vds dependent parameter of drain saturation voltage for impact ionizition current"), +IOP( "fbjtii", B3SOI_MOD_FBJTII, IF_REAL, "Fraction of bipolar current affecting the impact ionization"), +IOP( "esatii", B3SOI_MOD_ESATII, IF_REAL, "Saturation electric field for impact ionization"), +IOP( "ntun", B3SOI_MOD_NTUN, IF_REAL, "Reverse tunneling non-ideality factor"), +IOP( "nrecf0", B3SOI_MOD_NRECF0, IF_REAL, "Recombination non-ideality factor at forward bias"), +IOP( "nrecr0", B3SOI_MOD_NRECR0, IF_REAL, "Recombination non-ideality factor at reversed bias"), +IOP( "isbjt", B3SOI_MOD_ISBJT, IF_REAL, "BJT injection saturation current"), +IOP( "isdif", B3SOI_MOD_ISDIF, IF_REAL, "Body to source/drain injection saturation current"), +IOP( "isrec", B3SOI_MOD_ISREC, IF_REAL, "Recombination in depletion saturation current"), +IOP( "istun", B3SOI_MOD_ISTUN, IF_REAL, "Reverse tunneling saturation current"), +IOP( "ln", B3SOI_MOD_LN, IF_REAL, "Electron/hole diffusion length"), +IOP( "vrec0", B3SOI_MOD_VREC0, IF_REAL, "Voltage dependent parameter for recombination current"), +IOP( "vtun0", B3SOI_MOD_VTUN0, IF_REAL, "Voltage dependent parameter for tunneling current"), +IOP( "nbjt", B3SOI_MOD_NBJT, IF_REAL, "Power coefficient of channel length dependency for bipolar current"), +IOP( "lbjt0", B3SOI_MOD_LBJT0, IF_REAL, "Refferenc channel length for bipolar cuurent"), +IOP( "ldif0", B3SOI_MOD_LDIF0, IF_REAL, "Channel-length dependency coefficient of diffusion cap"), +IOP( "vabjt", B3SOI_MOD_VABJT, IF_REAL, "Early voltage for bipolar current"), +IOP( "aely", B3SOI_MOD_AELY, IF_REAL, "Channel length dependency of early voltage for bipolar cuurent"), +IOP( "ahli", B3SOI_MOD_AHLI, IF_REAL, "High level injection parameter for bipolar current"), +IOP( "rbody", B3SOI_MOD_RBODY, IF_REAL, "Intrinsic body contact sheet resistance"), +IOP( "rbsh", B3SOI_MOD_RBSH, IF_REAL, "Extrinsic body contact sheet resistance"), +IOP( "cgeo", B3SOI_MOD_CGEO, IF_REAL, "Gate substrate overlap capacitance per unit channel length"), +IOP( "tt", B3SOI_MOD_TT, IF_REAL, "Diffusion capacitance transit time coefficient"), +IOP( "ndif", B3SOI_MOD_NDIF, IF_REAL, "Power coefficient of channel length dependency for diffusion capacitance"), +IOP( "vsdfb", B3SOI_MOD_VSDFB, IF_REAL, "Source/drain bottom diffusion capacitance flatband voltage"), +IOP( "vsdth", B3SOI_MOD_VSDTH, IF_REAL, "Source/drain bottom diffusion capacitance threshold voltage"), +IOP( "csdmin", B3SOI_MOD_CSDMIN, IF_REAL, "Source/drain bottom diffusion minimum capacitance"), +IOP( "asd", B3SOI_MOD_ASD, IF_REAL, "Source/drain bottom diffusion smoothing parameter"), +IOP( "csdesw", B3SOI_MOD_CSDESW, IF_REAL, "Source/drain sidewall fringing capacitance per unit length"), +IOP( "ntrecf", B3SOI_MOD_NTRECF, IF_REAL, "Temperature coefficient for Nrecf"), +IOP( "ntrecr", B3SOI_MOD_NTRECR, IF_REAL, "Temperature coefficient for Nrecr"), +IOP( "dlcb", B3SOI_MOD_DLCB, IF_REAL, "Length offset fitting parameter for body charge"), +IOP( "fbody", B3SOI_MOD_FBODY, IF_REAL, "Scaling factor for body charge"), +IOP( "tcjswg", B3SOI_MOD_TCJSWG, IF_REAL, "Temperature coefficient of Cjswg"), +IOP( "tpbswg", B3SOI_MOD_TPBSWG, IF_REAL, "Temperature coefficient of Pbswg"), +IOP( "acde", B3SOI_MOD_ACDE, IF_REAL, "Exponential coefficient for charge thickness in capMod=3 for accumulation and depletion regions"), +IOP( "moin", B3SOI_MOD_MOIN, IF_REAL, "Coefficient for the gate-bias dependent surface potential"), +IOP( "delvt", B3SOI_MOD_DELVT, IF_REAL, "Threshold voltage adjust for CV"), +IOP( "kb1", B3SOI_MOD_KB1, IF_REAL, "Scaling factor for backgate charge"), +IOP( "dlbg", B3SOI_MOD_DLBG, IF_REAL, "Length offset fitting parameter for backgate charge"), + + +/* v2.2 release */ +IOP( "igbmod", B3SOI_MOD_IGBMOD, IF_INTEGER, "gate-body tunneling current model selector"), /* v3.0 */ +IOP( "igcmod", B3SOI_MOD_IGCMOD, IF_INTEGER, "gate-channel tunneling current model selector"), /* v3.0 */ +IOP( "toxqm", B3SOI_MOD_TOXQM, IF_REAL, "effective oxide thickness considering quantum effect"), +IOP( "wth0", B3SOI_MOD_WTH0, IF_REAL, "Minimum width for thermal resistance calculation"), +IOP( "rhalo", B3SOI_MOD_RHALO, IF_REAL, "body halo sheet resistance"), +IOP( "ntox", B3SOI_MOD_NTOX, IF_REAL, "power term of gate current"), +IOP( "toxref", B3SOI_MOD_TOXREF, IF_REAL, "target oxide thickness"), +IOP( "ebg", B3SOI_MOD_EBG, IF_REAL, "effective bandgap in gate current calcula."), +IOP( "vevb", B3SOI_MOD_VEVB, IF_REAL, "Vaux parameter for valence-band electron tunneling"), +IOP( "alphagb1", B3SOI_MOD_ALPHAGB1, IF_REAL, "First Vox dependent parameter for gate curent in inversion"), +IOP( "betagb1", B3SOI_MOD_BETAGB1, IF_REAL, "Second Vox dependent parameter for gate currnt in inversion"), +IOP( "vgb1", B3SOI_MOD_VGB1, IF_REAL, "Third Vox dependent parameter for gate current in inversion"), +IOP( "vecb", B3SOI_MOD_VECB, IF_REAL, "Vaux parameter for conduction-band electron tunneling"), +IOP( "alphagb2", B3SOI_MOD_ALPHAGB2, IF_REAL, "First Vox dependent parameter for gate current in accumulation"), +IOP( "betagb2", B3SOI_MOD_BETAGB2, IF_REAL, "Second Vox dependent parameter for gate current in accumulation"), +IOP( "vgb2", B3SOI_MOD_VGB2, IF_REAL, "Third Vox dependent parameter for gate current in accumulation"), +IOP( "voxh", B3SOI_MOD_VOXH, IF_REAL, "the limit of Vox in gate current calculation"), +IOP( "deltavox", B3SOI_MOD_DELTAVOX, IF_REAL, "the smoothing parameter in the Vox smoothing function"), + +/* v3.0 */ +IOP( "aigc", B3SOI_MOD_AIGC, IF_REAL, "Parameter for Igc"), +IOP( "bigc", B3SOI_MOD_BIGC, IF_REAL, "Parameter for Igc"), +IOP( "cigc", B3SOI_MOD_CIGC, IF_REAL, "Parameter for Igc"), +IOP( "aigsd", B3SOI_MOD_AIGSD, IF_REAL, "Parameter for Igs,d"), +IOP( "bigsd", B3SOI_MOD_BIGSD, IF_REAL, "Parameter for Igs,d"), +IOP( "cigsd", B3SOI_MOD_CIGSD, IF_REAL, "Parameter for Igs,d"), +IOP( "nigc", B3SOI_MOD_NIGC, IF_REAL, "Parameter for Igc slope"), +IOP( "pigcd", B3SOI_MOD_PIGCD, IF_REAL, "Parameter for Igc partition"), +IOP( "poxedge", B3SOI_MOD_POXEDGE, IF_REAL, "Factor for the gate edge Tox"), +IOP( "dlcig", B3SOI_MOD_DLCIG, IF_REAL, "Delta L for Ig model"), + +/* v3.0 */ +IOP( "soimod", B3SOI_MOD_SOIMOD, IF_REAL, "model selector for SOI technology"), +IOP( "vbsa", B3SOI_MOD_VBSA, IF_REAL, "Vbs0t offset voltage"), +IOP( "nofffd", B3SOI_MOD_NOFFFD,IF_REAL, "smoothing parameter in FD module"), +IOP( "vofffd", B3SOI_MOD_VOFFFD,IF_REAL, "smoothing parameter in FD module"), +IOP( "k1b", B3SOI_MOD_K1B, IF_REAL, "first backgate body effect parameter"), +IOP( "k2b", B3SOI_MOD_K2B, IF_REAL, "second backgate body effect parameter for short channel effect"), +IOP( "dk2b", B3SOI_MOD_DK2B, IF_REAL, "third backgate body effect parameter for short channel effect"), +IOP( "dvbd0", B3SOI_MOD_DVBD0, IF_REAL, "first short-channel effect parameter in FD module"), +IOP( "dvbd1", B3SOI_MOD_DVBD1, IF_REAL, "second short-channel effect parameter in FD module"), +IOP( "moinfd", B3SOI_MOD_MOINFD, IF_REAL, "Coefficient for the gate-bias dependent surface potential in FD"), +/* v3.0 */ + + +/* Added for binning - START */ +/* Length Dependence */ +/* v3.0 */ +IOP( "laigc", B3SOI_MOD_LAIGC, IF_REAL, "Length dependence of aigc"), +IOP( "lbigc", B3SOI_MOD_LBIGC, IF_REAL, "Length dependence of bigc"), +IOP( "lcigc", B3SOI_MOD_LCIGC, IF_REAL, "Length dependence of cigc"), +IOP( "laigsd", B3SOI_MOD_LAIGSD, IF_REAL, "Length dependence of aigsd"), +IOP( "lbigsd", B3SOI_MOD_LBIGSD, IF_REAL, "Length dependence of bigsd"), +IOP( "lcigsd", B3SOI_MOD_LCIGSD, IF_REAL, "Length dependence of cigsd"), +IOP( "lnigc", B3SOI_MOD_LNIGC, IF_REAL, "Length dependence of nigc"), +IOP( "lpigcd", B3SOI_MOD_LPIGCD, IF_REAL, "Length dependence for pigcd"), +IOP( "lpoxedge", B3SOI_MOD_LPOXEDGE, IF_REAL, "Length dependence for poxedge"), + +IOP( "lnch", B3SOI_MOD_LNPEAK, IF_REAL, "Length dependence of nch"), +IOP( "lnsub", B3SOI_MOD_LNSUB, IF_REAL, "Length dependence of nsub"), +IOP( "lngate", B3SOI_MOD_LNGATE, IF_REAL, "Length dependence of ngate"), +IOP( "lvth0", B3SOI_MOD_LVTH0, IF_REAL,"Length dependence of vto"), +IOP( "lk1", B3SOI_MOD_LK1, IF_REAL, "Length dependence of k1"), +IOP( "lk1w1", B3SOI_MOD_LK1W1, IF_REAL, "Length dependence of k1w1"), +IOP( "lk1w2", B3SOI_MOD_LK1W2, IF_REAL, "Length dependence of k1w2"), +IOP( "lk2", B3SOI_MOD_LK2, IF_REAL, "Length dependence of k2"), +IOP( "lk3", B3SOI_MOD_LK3, IF_REAL, "Length dependence of k3"), +IOP( "lk3b", B3SOI_MOD_LK3B, IF_REAL, "Length dependence of k3b"), +IOP( "lkb1", B3SOI_MOD_LKB1, IF_REAL, "Length dependence of kb1"), +IOP( "lw0", B3SOI_MOD_LW0, IF_REAL, "Length dependence of w0"), +IOP( "lnlx", B3SOI_MOD_LNLX, IF_REAL, "Length dependence of nlx"), +IOP( "ldvt0", B3SOI_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"), +IOP( "ldvt1", B3SOI_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"), +IOP( "ldvt2", B3SOI_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"), +IOP( "ldvt0w", B3SOI_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"), +IOP( "ldvt1w", B3SOI_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"), +IOP( "ldvt2w", B3SOI_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"), +IOP( "lu0", B3SOI_MOD_LU0, IF_REAL, "Length dependence of u0"), +IOP( "lua", B3SOI_MOD_LUA, IF_REAL, "Length dependence of ua"), +IOP( "lub", B3SOI_MOD_LUB, IF_REAL, "Length dependence of ub"), +IOP( "luc", B3SOI_MOD_LUC, IF_REAL, "Length dependence of uc"), +IOP( "lvsat", B3SOI_MOD_LVSAT, IF_REAL, "Length dependence of vsat"), +IOP( "la0", B3SOI_MOD_LA0, IF_REAL, "Length dependence of a0"), +IOP( "lags", B3SOI_MOD_LAGS, IF_REAL, "Length dependence of ags"), +IOP( "lb0", B3SOI_MOD_LB0, IF_REAL, "Length dependence of b0"), +IOP( "lb1", B3SOI_MOD_LB1, IF_REAL, "Length dependence of b1"), +IOP( "lketa", B3SOI_MOD_LKETA, IF_REAL, "Length dependence of keta"), +IOP( "lketas", B3SOI_MOD_LKETAS, IF_REAL, "Length dependence of ketas"), +IOP( "la1", B3SOI_MOD_LA1, IF_REAL, "Length dependence of a1"), +IOP( "la2", B3SOI_MOD_LA2, IF_REAL, "Length dependence of a2"), +IOP( "lrdsw", B3SOI_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "), +IOP( "lprwb", B3SOI_MOD_LPRWB, IF_REAL, "Length dependence of prwb "), +IOP( "lprwg", B3SOI_MOD_LPRWG, IF_REAL, "Length dependence of prwg "), +IOP( "lwr", B3SOI_MOD_LWR, IF_REAL, "Length dependence of wr"), +IOP( "lnfactor", B3SOI_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"), +IOP( "ldwg", B3SOI_MOD_LDWG, IF_REAL, "Length dependence of dwg"), +IOP( "ldwb", B3SOI_MOD_LDWB, IF_REAL, "Length dependence of dwb"), +IOP( "lvoff", B3SOI_MOD_LVOFF, IF_REAL, "Length dependence of voff"), +IOP( "leta0", B3SOI_MOD_LETA0, IF_REAL, "Length dependence of eta0"), +IOP( "letab", B3SOI_MOD_LETAB, IF_REAL, "Length dependence of etab"), +IOP( "ldsub", B3SOI_MOD_LDSUB, IF_REAL, "Length dependence of dsub"), +IOP( "lcit", B3SOI_MOD_LCIT, IF_REAL, "Length dependence of cit"), +IOP( "lcdsc", B3SOI_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"), +IOP( "lcdscb", B3SOI_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"), +IOP( "lcdscd", B3SOI_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"), +IOP( "lpclm", B3SOI_MOD_LPCLM, IF_REAL, "Length dependence of pclm"), +IOP( "lpdiblc1", B3SOI_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"), +IOP( "lpdiblc2", B3SOI_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"), +IOP( "lpdiblcb", B3SOI_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"), +IOP( "ldrout", B3SOI_MOD_LDROUT, IF_REAL, "Length dependence of drout"), +IOP( "lpvag", B3SOI_MOD_LPVAG, IF_REAL, "Length dependence of pvag"), +IOP( "ldelta", B3SOI_MOD_LDELTA, IF_REAL, "Length dependence of delta"), +IOP( "lalpha0", B3SOI_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"), +IOP( "lfbjtii", B3SOI_MOD_LFBJTII, IF_REAL, "Length dependence of fbjtii"), +IOP( "lbeta0", B3SOI_MOD_LBETA0, IF_REAL, "Length dependence of beta0"), +IOP( "lbeta1", B3SOI_MOD_LBETA1, IF_REAL, "Length dependence of beta1"), +IOP( "lbeta2", B3SOI_MOD_LBETA2, IF_REAL, "Length dependence of beta2"), +IOP( "lvdsatii0", B3SOI_MOD_LVDSATII0, IF_REAL, "Length dependence of vdsatii0"), +IOP( "llii", B3SOI_MOD_LLII, IF_REAL, "Length dependence of lii"), +IOP( "lesatii", B3SOI_MOD_LESATII, IF_REAL, "Length dependence of esatii"), +IOP( "lsii0", B3SOI_MOD_LSII0, IF_REAL, "Length dependence of sii0"), +IOP( "lsii1", B3SOI_MOD_LSII1, IF_REAL, "Length dependence of sii1"), +IOP( "lsii2", B3SOI_MOD_LSII2, IF_REAL, "Length dependence of sii2"), +IOP( "lsiid", B3SOI_MOD_LSIID, IF_REAL, "Length dependence of siid"), +IOP( "lagidl", B3SOI_MOD_LAGIDL, IF_REAL, "Length dependence of agidl"), +IOP( "lbgidl", B3SOI_MOD_LBGIDL, IF_REAL, "Length dependence of bgidl"), +IOP( "lngidl", B3SOI_MOD_LNGIDL, IF_REAL, "Length dependence of ngidl"), +IOP( "lntun", B3SOI_MOD_LNTUN, IF_REAL, "Length dependence of ntun"), +IOP( "lndiode", B3SOI_MOD_LNDIODE, IF_REAL, "Length dependence of ndiode"), +IOP( "lnrecf0", B3SOI_MOD_LNRECF0, IF_REAL, "Length dependence of nrecf0"), +IOP( "lnrecr0", B3SOI_MOD_LNRECR0, IF_REAL, "Length dependence of nrecr0"), +IOP( "lisbjt", B3SOI_MOD_LISBJT, IF_REAL, "Length dependence of isbjt"), +IOP( "lisdif", B3SOI_MOD_LISDIF, IF_REAL, "Length dependence of isdif"), +IOP( "lisrec", B3SOI_MOD_LISREC, IF_REAL, "Length dependence of isrec"), +IOP( "listun", B3SOI_MOD_LISTUN, IF_REAL, "Length dependence of istun"), +IOP( "lvrec0", B3SOI_MOD_LVREC0, IF_REAL, "Length dependence of vrec0"), +IOP( "lvtun0", B3SOI_MOD_LVTUN0, IF_REAL, "Length dependence of vtun0"), +IOP( "lnbjt", B3SOI_MOD_LNBJT, IF_REAL, "Length dependence of nbjt"), +IOP( "llbjt0", B3SOI_MOD_LLBJT0, IF_REAL, "Length dependence of lbjt0"), +IOP( "lvabjt", B3SOI_MOD_LVABJT, IF_REAL, "Length dependence of vabjt"), +IOP( "laely", B3SOI_MOD_LAELY, IF_REAL, "Length dependence of aely"), +IOP( "lahli", B3SOI_MOD_LAHLI, IF_REAL, "Length dependence of ahli"), +IOP( "lvsdfb", B3SOI_MOD_LVSDFB, IF_REAL, "Length dependence of vsdfb"), +IOP( "lvsdth", B3SOI_MOD_LVSDTH, IF_REAL, "Length dependence of vsdth"), +IOP( "ldelvt", B3SOI_MOD_LDELVT, IF_REAL, "Length dependence of delvt"), +IOP( "lacde", B3SOI_MOD_LACDE, IF_REAL, "Length dependence of acde"), +IOP( "lmoin", B3SOI_MOD_LMOIN, IF_REAL, "Length dependence of amoin"), + +/* Width Dependence */ +/* v3.0 */ +IOP( "waigc", B3SOI_MOD_WAIGC, IF_REAL, "Width dependence of aigc"), +IOP( "wbigc", B3SOI_MOD_WBIGC, IF_REAL, "Width dependence of bigc"), +IOP( "wcigc", B3SOI_MOD_WCIGC, IF_REAL, "Width dependence of cigc"), +IOP( "waigsd", B3SOI_MOD_WAIGSD, IF_REAL, "Width dependence of aigsd"), +IOP( "wbigsd", B3SOI_MOD_WBIGSD, IF_REAL, "Width dependence of bigsd"), +IOP( "wcigsd", B3SOI_MOD_WCIGSD, IF_REAL, "Width dependence of cigsd"), +IOP( "wnigc", B3SOI_MOD_WNIGC, IF_REAL, "Width dependence of nigc"), +IOP( "wpigcd", B3SOI_MOD_WPIGCD, IF_REAL, "Width dependence for pigcd"), +IOP( "wpoxedge", B3SOI_MOD_WPOXEDGE, IF_REAL, "Width dependence for poxedge"), + +IOP( "wnch", B3SOI_MOD_WNPEAK, IF_REAL, "Width dependence of nch"), +IOP( "wnsub", B3SOI_MOD_WNSUB, IF_REAL, "Width dependence of nsub"), +IOP( "wngate", B3SOI_MOD_WNGATE, IF_REAL, "Width dependence of ngate"), +IOP( "wvth0", B3SOI_MOD_WVTH0, IF_REAL,"Width dependence of vto"), +IOP( "wk1", B3SOI_MOD_WK1, IF_REAL, "Width dependence of k1"), +IOP( "wk1w1", B3SOI_MOD_WK1W1, IF_REAL, "Width dependence of k1w1"), +IOP( "wk1w2", B3SOI_MOD_WK1W2, IF_REAL, "Width dependence of k1w2"), +IOP( "wk2", B3SOI_MOD_WK2, IF_REAL, "Width dependence of k2"), +IOP( "wk3", B3SOI_MOD_WK3, IF_REAL, "Width dependence of k3"), +IOP( "wk3b", B3SOI_MOD_WK3B, IF_REAL, "Width dependence of k3b"), +IOP( "wkb1", B3SOI_MOD_WKB1, IF_REAL, "Width dependence of kb1"), +IOP( "ww0", B3SOI_MOD_WW0, IF_REAL, "Width dependence of w0"), +IOP( "wnlx", B3SOI_MOD_WNLX, IF_REAL, "Width dependence of nlx"), +IOP( "wdvt0", B3SOI_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"), +IOP( "wdvt1", B3SOI_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"), +IOP( "wdvt2", B3SOI_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"), +IOP( "wdvt0w", B3SOI_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"), +IOP( "wdvt1w", B3SOI_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"), +IOP( "wdvt2w", B3SOI_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"), +IOP( "wu0", B3SOI_MOD_WU0, IF_REAL, "Width dependence of u0"), +IOP( "wua", B3SOI_MOD_WUA, IF_REAL, "Width dependence of ua"), +IOP( "wub", B3SOI_MOD_WUB, IF_REAL, "Width dependence of ub"), +IOP( "wuc", B3SOI_MOD_WUC, IF_REAL, "Width dependence of uc"), +IOP( "wvsat", B3SOI_MOD_WVSAT, IF_REAL, "Width dependence of vsat"), +IOP( "wa0", B3SOI_MOD_WA0, IF_REAL, "Width dependence of a0"), +IOP( "wags", B3SOI_MOD_WAGS, IF_REAL, "Width dependence of ags"), +IOP( "wb0", B3SOI_MOD_WB0, IF_REAL, "Width dependence of b0"), +IOP( "wb1", B3SOI_MOD_WB1, IF_REAL, "Width dependence of b1"), +IOP( "wketa", B3SOI_MOD_WKETA, IF_REAL, "Width dependence of keta"), +IOP( "wketas", B3SOI_MOD_WKETAS, IF_REAL, "Width dependence of ketas"), +IOP( "wa1", B3SOI_MOD_WA1, IF_REAL, "Width dependence of a1"), +IOP( "wa2", B3SOI_MOD_WA2, IF_REAL, "Width dependence of a2"), +IOP( "wrdsw", B3SOI_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "), +IOP( "wprwb", B3SOI_MOD_WPRWB, IF_REAL, "Width dependence of prwb "), +IOP( "wprwg", B3SOI_MOD_WPRWG, IF_REAL, "Width dependence of prwg "), +IOP( "wwr", B3SOI_MOD_WWR, IF_REAL, "Width dependence of wr"), +IOP( "wnfactor", B3SOI_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"), +IOP( "wdwg", B3SOI_MOD_WDWG, IF_REAL, "Width dependence of dwg"), +IOP( "wdwb", B3SOI_MOD_WDWB, IF_REAL, "Width dependence of dwb"), +IOP( "wvoff", B3SOI_MOD_WVOFF, IF_REAL, "Width dependence of voff"), +IOP( "weta0", B3SOI_MOD_WETA0, IF_REAL, "Width dependence of eta0"), +IOP( "wetab", B3SOI_MOD_WETAB, IF_REAL, "Width dependence of etab"), +IOP( "wdsub", B3SOI_MOD_WDSUB, IF_REAL, "Width dependence of dsub"), +IOP( "wcit", B3SOI_MOD_WCIT, IF_REAL, "Width dependence of cit"), +IOP( "wcdsc", B3SOI_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"), +IOP( "wcdscb", B3SOI_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"), +IOP( "wcdscd", B3SOI_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"), +IOP( "wpclm", B3SOI_MOD_WPCLM, IF_REAL, "Width dependence of pclm"), +IOP( "wpdiblc1", B3SOI_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"), +IOP( "wpdiblc2", B3SOI_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"), +IOP( "wpdiblcb", B3SOI_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"), +IOP( "wdrout", B3SOI_MOD_WDROUT, IF_REAL, "Width dependence of drout"), +IOP( "wpvag", B3SOI_MOD_WPVAG, IF_REAL, "Width dependence of pvag"), +IOP( "wdelta", B3SOI_MOD_WDELTA, IF_REAL, "Width dependence of delta"), +IOP( "walpha0", B3SOI_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"), +IOP( "wfbjtii", B3SOI_MOD_WFBJTII, IF_REAL, "Width dependence of fbjtii"), +IOP( "wbeta0", B3SOI_MOD_WBETA0, IF_REAL, "Width dependence of beta0"), +IOP( "wbeta1", B3SOI_MOD_WBETA1, IF_REAL, "Width dependence of beta1"), +IOP( "wbeta2", B3SOI_MOD_WBETA2, IF_REAL, "Width dependence of beta2"), +IOP( "wvdsatii0", B3SOI_MOD_WVDSATII0, IF_REAL, "Width dependence of vdsatii0"), +IOP( "wlii", B3SOI_MOD_WLII, IF_REAL, "Width dependence of lii"), +IOP( "wesatii", B3SOI_MOD_WESATII, IF_REAL, "Width dependence of esatii"), +IOP( "wsii0", B3SOI_MOD_WSII0, IF_REAL, "Width dependence of sii0"), +IOP( "wsii1", B3SOI_MOD_WSII1, IF_REAL, "Width dependence of sii1"), +IOP( "wsii2", B3SOI_MOD_WSII2, IF_REAL, "Width dependence of sii2"), +IOP( "wsiid", B3SOI_MOD_WSIID, IF_REAL, "Width dependence of siid"), +IOP( "wagidl", B3SOI_MOD_WAGIDL, IF_REAL, "Width dependence of agidl"), +IOP( "wbgidl", B3SOI_MOD_WBGIDL, IF_REAL, "Width dependence of bgidl"), +IOP( "wngidl", B3SOI_MOD_WNGIDL, IF_REAL, "Width dependence of ngidl"), +IOP( "wntun", B3SOI_MOD_WNTUN, IF_REAL, "Width dependence of ntun"), +IOP( "wndiode", B3SOI_MOD_WNDIODE, IF_REAL, "Width dependence of ndiode"), +IOP( "wnrecf0", B3SOI_MOD_WNRECF0, IF_REAL, "Width dependence of nrecf0"), +IOP( "wnrecr0", B3SOI_MOD_WNRECR0, IF_REAL, "Width dependence of nrecr0"), +IOP( "wisbjt", B3SOI_MOD_WISBJT, IF_REAL, "Width dependence of isbjt"), +IOP( "wisdif", B3SOI_MOD_WISDIF, IF_REAL, "Width dependence of isdif"), +IOP( "wisrec", B3SOI_MOD_WISREC, IF_REAL, "Width dependence of isrec"), +IOP( "wistun", B3SOI_MOD_WISTUN, IF_REAL, "Width dependence of istun"), +IOP( "wvrec0", B3SOI_MOD_WVREC0, IF_REAL, "Width dependence of vrec0"), +IOP( "wvtun0", B3SOI_MOD_WVTUN0, IF_REAL, "Width dependence of vtun0"), +IOP( "wnbjt", B3SOI_MOD_WNBJT, IF_REAL, "Width dependence of nbjt"), +IOP( "wlbjt0", B3SOI_MOD_WLBJT0, IF_REAL, "Width dependence of lbjt0"), +IOP( "wvabjt", B3SOI_MOD_WVABJT, IF_REAL, "Width dependence of vabjt"), +IOP( "waely", B3SOI_MOD_WAELY, IF_REAL, "Width dependence of aely"), +IOP( "wahli", B3SOI_MOD_WAHLI, IF_REAL, "Width dependence of ahli"), +IOP( "wvsdfb", B3SOI_MOD_WVSDFB, IF_REAL, "Width dependence of vsdfb"), +IOP( "wvsdth", B3SOI_MOD_WVSDTH, IF_REAL, "Width dependence of vsdth"), +IOP( "wdelvt", B3SOI_MOD_WDELVT, IF_REAL, "Width dependence of delvt"), +IOP( "wacde", B3SOI_MOD_WACDE, IF_REAL, "Width dependence of acde"), +IOP( "wmoin", B3SOI_MOD_WMOIN, IF_REAL, "Width dependence of amoin"), + +/* Cross-term Dependence */ +/* v3.0 */ +IOP( "paigc", B3SOI_MOD_PAIGC, IF_REAL, "Cross-term dependence of aigc"), +IOP( "pbigc", B3SOI_MOD_PBIGC, IF_REAL, "Cross-term dependence of bigc"), +IOP( "pcigc", B3SOI_MOD_PCIGC, IF_REAL, "Cross-term dependence of cigc"), +IOP( "paigsd", B3SOI_MOD_PAIGSD, IF_REAL, "Cross-term dependence of aigsd"), +IOP( "pbigsd", B3SOI_MOD_PBIGSD, IF_REAL, "Cross-term dependence of bigsd"), +IOP( "pcigsd", B3SOI_MOD_PCIGSD, IF_REAL, "Cross-term dependence of cigsd"), +IOP( "pnigc", B3SOI_MOD_PNIGC, IF_REAL, "Cross-term dependence of nigc"), +IOP( "ppigcd", B3SOI_MOD_PPIGCD, IF_REAL, "Cross-term dependence for pigcd"), +IOP( "ppoxedge", B3SOI_MOD_PPOXEDGE, IF_REAL, "Cross-term dependence for poxedge"), + +IOP( "pnch", B3SOI_MOD_PNPEAK, IF_REAL, "Cross-term dependence of nch"), +IOP( "pnsub", B3SOI_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"), +IOP( "pngate", B3SOI_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"), +IOP( "pvth0", B3SOI_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"), +IOP( "pk1", B3SOI_MOD_PK1, IF_REAL, "Cross-term dependence of k1"), +IOP( "pk1w1", B3SOI_MOD_PK1W1, IF_REAL, "Cross-term dependence of k1w1"), +IOP( "pk1w2", B3SOI_MOD_PK1W2, IF_REAL, "Cross-term dependence of k1w2"), +IOP( "pk2", B3SOI_MOD_PK2, IF_REAL, "Cross-term dependence of k2"), +IOP( "pk3", B3SOI_MOD_PK3, IF_REAL, "Cross-term dependence of k3"), +IOP( "pk3b", B3SOI_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"), +IOP( "pkb1", B3SOI_MOD_PKB1, IF_REAL, "Cross-term dependence of kb1"), +IOP( "pw0", B3SOI_MOD_PW0, IF_REAL, "Cross-term dependence of w0"), +IOP( "pnlx", B3SOI_MOD_PNLX, IF_REAL, "Cross-term dependence of nlx"), +IOP( "pdvt0", B3SOI_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"), +IOP( "pdvt1", B3SOI_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"), +IOP( "pdvt2", B3SOI_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"), +IOP( "pdvt0w", B3SOI_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"), +IOP( "pdvt1w", B3SOI_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"), +IOP( "pdvt2w", B3SOI_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"), +IOP( "pu0", B3SOI_MOD_PU0, IF_REAL, "Cross-term dependence of u0"), +IOP( "pua", B3SOI_MOD_PUA, IF_REAL, "Cross-term dependence of ua"), +IOP( "pub", B3SOI_MOD_PUB, IF_REAL, "Cross-term dependence of ub"), +IOP( "puc", B3SOI_MOD_PUC, IF_REAL, "Cross-term dependence of uc"), +IOP( "pvsat", B3SOI_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"), +IOP( "pa0", B3SOI_MOD_PA0, IF_REAL, "Cross-term dependence of a0"), +IOP( "pags", B3SOI_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"), +IOP( "pb0", B3SOI_MOD_PB0, IF_REAL, "Cross-term dependence of b0"), +IOP( "pb1", B3SOI_MOD_PB1, IF_REAL, "Cross-term dependence of b1"), +IOP( "pketa", B3SOI_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"), +IOP( "pketas", B3SOI_MOD_PKETAS, IF_REAL, "Cross-term dependence of ketas"), +IOP( "pa1", B3SOI_MOD_PA1, IF_REAL, "Cross-term dependence of a1"), +IOP( "pa2", B3SOI_MOD_PA2, IF_REAL, "Cross-term dependence of a2"), +IOP( "prdsw", B3SOI_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "), +IOP( "pprwb", B3SOI_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "), +IOP( "pprwg", B3SOI_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "), +IOP( "pwr", B3SOI_MOD_PWR, IF_REAL, "Cross-term dependence of wr"), +IOP( "pnfactor", B3SOI_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"), +IOP( "pdwg", B3SOI_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"), +IOP( "pdwb", B3SOI_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"), +IOP( "pvoff", B3SOI_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"), +IOP( "peta0", B3SOI_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"), +IOP( "petab", B3SOI_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"), +IOP( "pdsub", B3SOI_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"), +IOP( "pcit", B3SOI_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"), +IOP( "pcdsc", B3SOI_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"), +IOP( "pcdscb", B3SOI_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"), +IOP( "pcdscd", B3SOI_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"), +IOP( "ppclm", B3SOI_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"), +IOP( "ppdiblc1", B3SOI_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"), +IOP( "ppdiblc2", B3SOI_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"), +IOP( "ppdiblcb", B3SOI_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"), +IOP( "pdrout", B3SOI_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"), +IOP( "ppvag", B3SOI_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"), +IOP( "pdelta", B3SOI_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"), +IOP( "palpha0", B3SOI_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"), +IOP( "pfbjtii", B3SOI_MOD_PFBJTII, IF_REAL, "Cross-term dependence of fbjtii"), +IOP( "pbeta0", B3SOI_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"), +IOP( "pbeta1", B3SOI_MOD_PBETA1, IF_REAL, "Cross-term dependence of beta1"), +IOP( "pbeta2", B3SOI_MOD_PBETA2, IF_REAL, "Cross-term dependence of beta2"), +IOP( "pvdsatii0", B3SOI_MOD_PVDSATII0, IF_REAL, "Cross-term dependence of vdsatii0"), +IOP( "plii", B3SOI_MOD_PLII, IF_REAL, "Cross-term dependence of lii"), +IOP( "pesatii", B3SOI_MOD_PESATII, IF_REAL, "Cross-term dependence of esatii"), +IOP( "psii0", B3SOI_MOD_PSII0, IF_REAL, "Cross-term dependence of sii0"), +IOP( "psii1", B3SOI_MOD_PSII1, IF_REAL, "Cross-term dependence of sii1"), +IOP( "psii2", B3SOI_MOD_PSII2, IF_REAL, "Cross-term dependence of sii2"), +IOP( "psiid", B3SOI_MOD_PSIID, IF_REAL, "Cross-term dependence of siid"), +IOP( "pagidl", B3SOI_MOD_PAGIDL, IF_REAL, "Cross-term dependence of agidl"), +IOP( "pbgidl", B3SOI_MOD_PBGIDL, IF_REAL, "Cross-term dependence of bgidl"), +IOP( "pngidl", B3SOI_MOD_PNGIDL, IF_REAL, "Cross-term dependence of ngidl"), +IOP( "pntun", B3SOI_MOD_PNTUN, IF_REAL, "Cross-term dependence of ntun"), +IOP( "pndiode", B3SOI_MOD_PNDIODE, IF_REAL, "Cross-term dependence of ndiode"), +IOP( "pnrecf0", B3SOI_MOD_PNRECF0, IF_REAL, "Cross-term dependence of nrecf0"), +IOP( "pnrecr0", B3SOI_MOD_PNRECR0, IF_REAL, "Cross-term dependence of nrecr0"), +IOP( "pisbjt", B3SOI_MOD_PISBJT, IF_REAL, "Cross-term dependence of isbjt"), +IOP( "pisdif", B3SOI_MOD_PISDIF, IF_REAL, "Cross-term dependence of isdif"), +IOP( "pisrec", B3SOI_MOD_PISREC, IF_REAL, "Cross-term dependence of isrec"), +IOP( "pistun", B3SOI_MOD_PISTUN, IF_REAL, "Cross-term dependence of istun"), +IOP( "pvrec0", B3SOI_MOD_PVREC0, IF_REAL, "Cross-term dependence of vrec0"), +IOP( "pvtun0", B3SOI_MOD_PVTUN0, IF_REAL, "Cross-term dependence of vtun0"), +IOP( "pnbjt", B3SOI_MOD_PNBJT, IF_REAL, "Cross-term dependence of nbjt"), +IOP( "plbjt0", B3SOI_MOD_PLBJT0, IF_REAL, "Cross-term dependence of lbjt0"), +IOP( "pvabjt", B3SOI_MOD_PVABJT, IF_REAL, "Cross-term dependence of vabjt"), +IOP( "paely", B3SOI_MOD_PAELY, IF_REAL, "Cross-term dependence of aely"), +IOP( "pahli", B3SOI_MOD_PAHLI, IF_REAL, "Cross-term dependence of ahli"), +IOP( "pvsdfb", B3SOI_MOD_PVSDFB, IF_REAL, "Cross-term dependence of vsdfb"), +IOP( "pvsdth", B3SOI_MOD_PVSDTH, IF_REAL, "Cross-term dependence of vsdth"), +IOP( "pdelvt", B3SOI_MOD_PDELVT, IF_REAL, "Cross-term dependence of delvt"), +IOP( "pacde", B3SOI_MOD_PACDE, IF_REAL, "Cross-term dependence of acde"), +IOP( "pmoin", B3SOI_MOD_PMOIN, IF_REAL, "Cross-term dependence of amoin"), +/* Added for binning - END */ + +IP( "nmos", B3SOI_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"), +IP( "pmos", B3SOI_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"), +}; + +char *B3SOInames[] = { + "Drain", + "Gate", + "Source", + "Backgate", + "", + "Body", + "Temp", + "Charge", +}; + +int B3SOInSize = NUMELEMS(B3SOInames); +int B3SOIpTSize = NUMELEMS(B3SOIpTable); +int B3SOImPTSize = NUMELEMS(B3SOImPTable); +int B3SOIiSize = sizeof(B3SOIinstance); +int B3SOImSize = sizeof(B3SOImodel); + + diff --git a/src/spicelib/devices/bsim3soi/b3soiacld.c b/src/spicelib/devices/bsim3soi/b3soiacld.c new file mode 100644 index 000000000..6933db5bb --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soiacld.c @@ -0,0 +1,402 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soiacld.c 98/5/01 +Modified by Pin Su 99/4/30 +Modified by Pin Su 99/9/27 +Modified by Pin Su 02/5/20 +Modified by Paolo Nenzi 2002 +**********/ + +#include "ngspice.h" +#include "cktdefs.h" +#include "b3soidef.h" +#include "sperror.h" +#include "suffix.h" + + +int +B3SOIacLoad(GENmodel *inModel, CKTcircuit *ckt) +{ +B3SOImodel *model = (B3SOImodel*)inModel; +B3SOIinstance *here; +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, gcTt, gTtt, gTtg, gTtb, gTtdp, gTtsp; +double EDextrinsicCap, ESextrinsicCap; +double xcedb, xcesb; + +/* v3.0 */ +double Gme, gddpe, gsspe, gbbe, gTte; + +double m; + + + omega = ckt->CKTomega; + for (; model != NULL; model = model->B3SOInextModel) + { + + for (here = model->B3SOIinstances; here!= NULL; + here = here->B3SOInextInstance) + { + + if (here->B3SOIowner != ARCHme) + continue; + + + selfheat = (model->B3SOIshMod == 1) && (here->B3SOIrth0 != 0.0); + if (here->B3SOImode >= 0) + { Gm = here->B3SOIgm; + Gmbs = here->B3SOIgmbs; + +/* v3.0 */ + Gme = here->B3SOIgme; + + GmT = model->B3SOItype * here->B3SOIgmT; + FwdSum = Gm + Gmbs + Gme; /* v3.0 */ + RevSum = 0.0; + + cbgb = here->B3SOIcbgb; + cbsb = here->B3SOIcbsb; + cbdb = here->B3SOIcbdb; + cbeb = here->B3SOIcbeb; + cbT = model->B3SOItype * here->B3SOIcbT; + + ceeb = here->B3SOIceeb; + ceT = model->B3SOItype * here->B3SOIceT; + + cggb = here->B3SOIcggb; + cgsb = here->B3SOIcgsb; + cgdb = here->B3SOIcgdb; + cgT = model->B3SOItype * here->B3SOIcgT; + + cdgb = here->B3SOIcdgb; + cdsb = here->B3SOIcdsb; + cddb = here->B3SOIcddb; + cdeb = here->B3SOIcdeb; + cdT = model->B3SOItype * here->B3SOIcdT; + + cTt = here->pParam->B3SOIcth; + + gbbg = -here->B3SOIgbgs; + gbbdp = -here->B3SOIgbds; + gbbb = -here->B3SOIgbbs; + gbbp = -here->B3SOIgbps; + gbbT = -model->B3SOItype * here->B3SOIgbT; + +/* v3.0 */ + gbbe = -here->B3SOIgbes; + gbbsp = - ( gbbg + gbbdp + gbbb + gbbp + gbbe); + + gddpg = -here->B3SOIgjdg; + gddpdp = -here->B3SOIgjdd; + gddpb = -here->B3SOIgjdb; + gddpT = -model->B3SOItype * here->B3SOIgjdT; + +/* v3.0 */ + gddpe = -here->B3SOIgjde; + gddpsp = - ( gddpg + gddpdp + gddpb + gddpe); + + gsspg = -here->B3SOIgjsg; + gsspdp = -here->B3SOIgjsd; + gsspb = -here->B3SOIgjsb; + gsspT = -model->B3SOItype * here->B3SOIgjsT; + +/* v3.0 */ + gsspe = 0.0; + gsspsp = - (gsspg + gsspdp + gsspb + gsspe); + + + gppb = -here->B3SOIgbpbs; + gppp = -here->B3SOIgbpps; + + gTtg = here->B3SOIgtempg; + gTtb = here->B3SOIgtempb; + gTtdp = here->B3SOIgtempd; + gTtt = here->B3SOIgtempT; + +/* v3.0 */ + gTte = here->B3SOIgtempe; + gTtsp = - (gTtg + gTtb + gTtdp + gTte); + + sxpart = 0.6; + dxpart = 0.4; + + } + else + { Gm = -here->B3SOIgm; + Gmbs = -here->B3SOIgmbs; + +/* v3.0 */ + Gme = -here->B3SOIgme; + + GmT = -model->B3SOItype * here->B3SOIgmT; + FwdSum = 0.0; + RevSum = -Gm - Gmbs - Gme; /* v3.0 */ + + cdgb = - (here->B3SOIcdgb + here->B3SOIcggb + here->B3SOIcbgb); + cdsb = - (here->B3SOIcddb + here->B3SOIcgdb + here->B3SOIcbdb); + cddb = - (here->B3SOIcdsb + here->B3SOIcgsb + here->B3SOIcbsb); + cdeb = - (here->B3SOIcdeb + here->B3SOIcbeb + here->B3SOIceeb); + cdT = - model->B3SOItype * (here->B3SOIcgT + here->B3SOIcbT + + here->B3SOIcdT + here->B3SOIceT); + + ceeb = here->B3SOIceeb; + ceT = model->B3SOItype * here->B3SOIceT; + + cggb = here->B3SOIcggb; + cgsb = here->B3SOIcgdb; + cgdb = here->B3SOIcgsb; + cgT = model->B3SOItype * here->B3SOIcgT; + + cbgb = here->B3SOIcbgb; + cbsb = here->B3SOIcbdb; + cbdb = here->B3SOIcbsb; + cbeb = here->B3SOIcbeb; + cbT = model->B3SOItype * here->B3SOIcbT; + + cTt = here->pParam->B3SOIcth; + + gbbg = -here->B3SOIgbgs; + gbbb = -here->B3SOIgbbs; + gbbp = -here->B3SOIgbps; + gbbsp = -here->B3SOIgbds; + gbbT = -model->B3SOItype * here->B3SOIgbT; + +/* v3.0 */ + gbbe = -here->B3SOIgbes; + gbbdp = - ( gbbg + gbbsp + gbbb + gbbp + gbbe); + + gddpg = -here->B3SOIgjsg; + gddpsp = -here->B3SOIgjsd; + gddpb = -here->B3SOIgjsb; + gddpT = -model->B3SOItype * here->B3SOIgjsT; + +/* v3.0 */ + gddpe = 0.0; + gddpdp = - (gddpg + gddpsp + gddpb + gddpe ); + + gsspg = -here->B3SOIgjdg; + gsspsp = -here->B3SOIgjdd; + gsspb = -here->B3SOIgjdb; + gsspT = -model->B3SOItype * here->B3SOIgjdT; + +/* v3.0 */ + gsspe = -here->B3SOIgjde; + gsspdp = - ( gsspg + gsspsp + gsspb + gsspe ); + + + gppb = -here->B3SOIgbpbs; + gppp = -here->B3SOIgbpps; + + gTtt = here->B3SOIgtempT; + gTtg = here->B3SOIgtempg; + gTtb = here->B3SOIgtempb; + gTtdp = here->B3SOIgtempd; + +/* v3.0 */ + gTte = here->B3SOIgtempe; + gTtsp = - (gTtt + gTtg + gTtb + gTtdp + gTte); + + gTtg = here->B3SOIgtempg; + gTtb = here->B3SOIgtempb; + gTtsp = here->B3SOIgtempd; + gTtt = here->B3SOIgtempT; + +/* v3.0 */ + gTte = here->B3SOIgtempe; + gTtdp = - (gTtg + gTtb + gTtsp + gTte); + + sxpart = 0.6; + sxpart = 0.4; + dxpart = 0.6; + } + + gdpr=here->B3SOIdrainConductance; + gspr=here->B3SOIsourceConductance; + gds= here->B3SOIgds; + + GSoverlapCap = here->B3SOIcgso; + GDoverlapCap = here->B3SOIcgdo; + GEoverlapCap = here->pParam->B3SOIcgeo; + + EDextrinsicCap = here->B3SOIgcde; + ESextrinsicCap = here->B3SOIgcse; + 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; + + m = here->B3SOIm; + + *(here->B3SOIEdpPtr +1) += m * xcedb; + *(here->B3SOIEspPtr +1) += m * xcesb; + *(here->B3SOIDPePtr +1) += m * xcdeb; + *(here->B3SOISPePtr +1) += m * xcseb; + *(here->B3SOIEgPtr +1) += m * xcegb; + *(here->B3SOIGePtr +1) += m * xcgeb; + + *(here->B3SOIEePtr +1) += m * xceeb; + + *(here->B3SOIGgPtr +1) += m * xcggb; + *(here->B3SOIGdpPtr +1) += m * xcgdb; + *(here->B3SOIGspPtr +1) += m * xcgsb; + + *(here->B3SOIDPgPtr +1) += m * xcdgb; + *(here->B3SOIDPdpPtr +1) += m * xcddb; + *(here->B3SOIDPspPtr +1) += m * xcdsb; + + *(here->B3SOISPgPtr +1) += m * xcsgb; + *(here->B3SOISPdpPtr +1) += m * xcsdb; + *(here->B3SOISPspPtr +1) += m * xcssb; + + *(here->B3SOIBePtr +1) += m * xcbeb; + *(here->B3SOIBgPtr +1) += m * xcbgb; + *(here->B3SOIBdpPtr +1) += m * xcbdb; + *(here->B3SOIBspPtr +1) += m * xcbsb; + + *(here->B3SOIEbPtr +1) -= m * (xcegb + xceeb + xcedb + xcesb); + + *(here->B3SOIGbPtr +1) -= m * (xcggb + xcgdb + xcgsb + xcgeb); + *(here->B3SOIDPbPtr +1) -= m * (xcdgb + xcddb + xcdsb + xcdeb); + *(here->B3SOISPbPtr +1) -= m * (xcsgb + xcsdb + xcssb + xcseb); + *(here->B3SOIBbPtr +1) -= m * (xcbgb + xcbdb + xcbsb + xcbeb); + + if (selfheat) + { + *(here->B3SOITemptempPtr + 1) += m * xcTt; + *(here->B3SOIDPtempPtr + 1) += m * xcdT; + *(here->B3SOISPtempPtr + 1) += m * xcsT; + *(here->B3SOIBtempPtr + 1) += m * xcbT; + *(here->B3SOIEtempPtr + 1) += m * xceT; + *(here->B3SOIGtempPtr + 1) += m * xcgT; + } + + +/* v3.0 */ + if (model->B3SOIsoiMod != 0) + { + *(here->B3SOIDPePtr) += m * (Gme + gddpe); + *(here->B3SOISPePtr) += m * (gsspe - Gme); + } + + *(here->B3SOIEePtr) += 0.0; + + *(here->B3SOIDPgPtr) += m * (Gm + gddpg); + *(here->B3SOIDPdpPtr) += m * (gdpr + gds + gddpdp + RevSum); + *(here->B3SOIDPspPtr) -= m * (gds + FwdSum - gddpsp); + *(here->B3SOIDPdPtr) -= m * gdpr; + + *(here->B3SOISPgPtr) -= m * (Gm - gsspg); + *(here->B3SOISPdpPtr) -= m * (gds + RevSum - gsspdp); + *(here->B3SOISPspPtr) += m * (gspr + gds + FwdSum + gsspsp); + *(here->B3SOISPsPtr) -= m * gspr; + + *(here->B3SOIBePtr) += m * gbbe; /* v3.0 */ + *(here->B3SOIBgPtr) += m * gbbg; + *(here->B3SOIBdpPtr) += m * gbbdp; + *(here->B3SOIBspPtr) += m * gbbsp; + *(here->B3SOIBbPtr) += m * gbbb; + *(here->B3SOISPbPtr) -= m * (Gmbs - gsspb); + *(here->B3SOIDPbPtr) -= m * (-gddpb - Gmbs); + + if (selfheat) + { + *(here->B3SOIDPtempPtr) += m * (GmT + gddpT); + *(here->B3SOISPtempPtr) += m * (-GmT + gsspT); + *(here->B3SOIBtempPtr) += m * gbbT; + + *(here->B3SOITemptempPtr) += m * (gTtt + 1/here->pParam->B3SOIrth); + *(here->B3SOITempgPtr) += m * gTtg; + *(here->B3SOITempbPtr) += m * gTtb; + *(here->B3SOITempdpPtr) += m * gTtdp; + *(here->B3SOITempspPtr) += m * gTtsp; + +/* v3.0 */ + if (model->B3SOIsoiMod != 0) + *(here->B3SOITempePtr) += m * gTte; + } + + + *(here->B3SOIDdPtr) += m * gdpr; + *(here->B3SOIDdpPtr) -= m * gdpr; + *(here->B3SOISsPtr) += m * gspr; + *(here->B3SOISspPtr) -= m * gspr; + + + if (here->B3SOIbodyMod == 1) { + (*(here->B3SOIBpPtr) -= m * gppp); + (*(here->B3SOIPbPtr) += m * gppb); + (*(here->B3SOIPpPtr) += m * gppp); + } + + if (here->B3SOIdebugMod != 0) + { + *(here->B3SOIVbsPtr) += m * 1; + *(here->B3SOIIdsPtr) += m * 1; + *(here->B3SOIIcPtr) += m * 1; + *(here->B3SOIIbsPtr) += m * 1; + *(here->B3SOIIbdPtr) += m * 1; + *(here->B3SOIIiiPtr) += m * 1; + *(here->B3SOIIgidlPtr) += m * 1; + *(here->B3SOIItunPtr) += m * 1; + *(here->B3SOIIbpPtr) += m * 1; + *(here->B3SOICbgPtr) += m * 1; + *(here->B3SOICbbPtr) += m * 1; + *(here->B3SOICbdPtr) += m * 1; + *(here->B3SOIQbfPtr) += m * 1; + *(here->B3SOIQjsPtr) += m * 1; + *(here->B3SOIQjdPtr) += m * 1; + + } + + } + } + return(OK); +} + diff --git a/src/spicelib/devices/bsim3soi/b3soiask.c b/src/spicelib/devices/bsim3soi/b3soiask.c new file mode 100644 index 000000000..c3a158069 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soiask.c @@ -0,0 +1,274 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soiask.c 98/5/01 +Modified by Pin Su 99/4/30 +Modified by Pin Su 01/2/15 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "ifsim.h" +#include "cktdefs.h" +#include "devdefs.h" +#include "b3soidef.h" +#include "sperror.h" +#include "suffix.h" + +int +B3SOIask(CKTcircuit *ckt, GENinstance *inst, int which, IFvalue *value, + IFvalue *select) +{ +B3SOIinstance *here = (B3SOIinstance*)inst; + + switch(which) + { case B3SOI_L: + value->rValue = here->B3SOIl; + return(OK); + case B3SOI_W: + value->rValue = here->B3SOIw; + return(OK); + case B3SOI_AS: + value->rValue = here->B3SOIsourceArea; + return(OK); + case B3SOI_AD: + value->rValue = here->B3SOIdrainArea; + return(OK); + case B3SOI_PS: + value->rValue = here->B3SOIsourcePerimeter; + return(OK); + case B3SOI_PD: + value->rValue = here->B3SOIdrainPerimeter; + return(OK); + case B3SOI_NRS: + value->rValue = here->B3SOIsourceSquares; + return(OK); + case B3SOI_NRD: + value->rValue = here->B3SOIdrainSquares; + return(OK); + case B3SOI_OFF: + value->iValue = here->B3SOIoff; + return(OK); + case B3SOI_BJTOFF: + value->iValue = here->B3SOIbjtoff; + return(OK); + case B3SOI_RTH0: + value->rValue = here->B3SOIrth0; + value->rValue /= here->B3SOIm; + return(OK); + case B3SOI_CTH0: + value->rValue = here->B3SOIcth0; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_NRB: + value->rValue = here->B3SOIbodySquares; + return(OK); + case B3SOI_FRBODY: + value->rValue = here->B3SOIfrbody; + /* Need to scale by m ? */ + return(OK); + + +/* v2.0 release */ + case B3SOI_NBC: + value->rValue = here->B3SOInbc; + return(OK); + case B3SOI_NSEG: + value->rValue = here->B3SOInseg; + return(OK); + case B3SOI_PDBCP: + value->rValue = here->B3SOIpdbcp; + return(OK); + case B3SOI_PSBCP: + value->rValue = here->B3SOIpsbcp; + return(OK); + case B3SOI_AGBCP: + value->rValue = here->B3SOIagbcp; + return(OK); + case B3SOI_AEBCP: + value->rValue = here->B3SOIaebcp; + return(OK); + case B3SOI_VBSUSR: + value->rValue = here->B3SOIvbsusr; + return(OK); + case B3SOI_TNODEOUT: + value->iValue = here->B3SOItnodeout; + return(OK); + + + case B3SOI_IC_VBS: + value->rValue = here->B3SOIicVBS; + return(OK); + case B3SOI_IC_VDS: + value->rValue = here->B3SOIicVDS; + return(OK); + case B3SOI_IC_VGS: + value->rValue = here->B3SOIicVGS; + return(OK); + case B3SOI_IC_VES: + value->rValue = here->B3SOIicVES; + return(OK); + case B3SOI_IC_VPS: + value->rValue = here->B3SOIicVPS; + return(OK); + case B3SOI_DNODE: + value->iValue = here->B3SOIdNode; + return(OK); + case B3SOI_GNODE: + value->iValue = here->B3SOIgNode; + return(OK); + case B3SOI_SNODE: + value->iValue = here->B3SOIsNode; + return(OK); + case B3SOI_BNODE: + value->iValue = here->B3SOIbNode; + return(OK); + case B3SOI_ENODE: + value->iValue = here->B3SOIeNode; + return(OK); + case B3SOI_DNODEPRIME: + value->iValue = here->B3SOIdNodePrime; + return(OK); + case B3SOI_SNODEPRIME: + value->iValue = here->B3SOIsNodePrime; + return(OK); + case B3SOI_SOURCECONDUCT: + value->rValue = here->B3SOIsourceConductance; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_DRAINCONDUCT: + value->rValue = here->B3SOIdrainConductance; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_VBD: + value->rValue = *(ckt->CKTstate0 + here->B3SOIvbd); + return(OK); + case B3SOI_VBS: + value->rValue = *(ckt->CKTstate0 + here->B3SOIvbs); + return(OK); + case B3SOI_VGS: + value->rValue = *(ckt->CKTstate0 + here->B3SOIvgs); + return(OK); + case B3SOI_VES: + value->rValue = *(ckt->CKTstate0 + here->B3SOIves); + return(OK); + case B3SOI_VDS: + value->rValue = *(ckt->CKTstate0 + here->B3SOIvds); + return(OK); + case B3SOI_CD: + value->rValue = here->B3SOIcd; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CBS: + value->rValue = here->B3SOIcjs; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CBD: + value->rValue = here->B3SOIcjd; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_GM: + value->rValue = here->B3SOIgm; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_GMID: + value->rValue = here->B3SOIgm / here->B3SOIcd; + /* It's a ratio no need to scale */ + return(OK); + case B3SOI_GDS: + value->rValue = here->B3SOIgds; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_GMBS: + value->rValue = here->B3SOIgmbs; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_GBD: + value->rValue = here->B3SOIgjdb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_GBS: + value->rValue = here->B3SOIgjsb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_QB: + value->rValue = *(ckt->CKTstate0 + here->B3SOIqb); + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CQB: + value->rValue = *(ckt->CKTstate0 + here->B3SOIcqb); + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_QG: + value->rValue = *(ckt->CKTstate0 + here->B3SOIqg); + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CQG: + value->rValue = *(ckt->CKTstate0 + here->B3SOIcqg); + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_QD: + value->rValue = *(ckt->CKTstate0 + here->B3SOIqd); + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CQD: + value->rValue = *(ckt->CKTstate0 + here->B3SOIcqd); + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CGG: + value->rValue = here->B3SOIcggb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CGD: + value->rValue = here->B3SOIcgdb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CGS: + value->rValue = here->B3SOIcgsb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CDG: + value->rValue = here->B3SOIcdgb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CDD: + value->rValue = here->B3SOIcddb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CDS: + value->rValue = here->B3SOIcdsb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CBG: + value->rValue = here->B3SOIcbgb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CBDB: + value->rValue = here->B3SOIcbdb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_CBSB: + value->rValue = here->B3SOIcbsb; + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_VON: + value->rValue = here->B3SOIvon; + return(OK); + case B3SOI_VDSAT: + value->rValue = here->B3SOIvdsat; + return(OK); + case B3SOI_QBS: + value->rValue = *(ckt->CKTstate0 + here->B3SOIqbs); + value->rValue *= here->B3SOIm; + return(OK); + case B3SOI_QBD: + value->rValue = *(ckt->CKTstate0 + here->B3SOIqbd); + value->rValue *= here->B3SOIm; + return(OK); + default: + return(E_BADPARM); + } + /* NOTREACHED */ +} + diff --git a/src/spicelib/devices/bsim3soi/b3soicheck.c b/src/spicelib/devices/bsim3soi/b3soicheck.c new file mode 100644 index 000000000..ef6a5383e --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soicheck.c @@ -0,0 +1,769 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soicheck.c 98/5/01 +Modified by Pin Su and Jan Feng 99/2/15 +Modified by Pin Su 99/4/30 +Modified by Pin Su 00/3/1 +Modified by Pin Su and Hui Wan 02/3/5 +Modified by Pin Su 02/5/20 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "cktdefs.h" +#include "b3soidef.h" +#include "trandefs.h" +#include "const.h" +#include "sperror.h" +#include "devdefs.h" +#include "suffix.h" + +int +B3SOIcheckModel(B3SOImodel *model, B3SOIinstance *here, CKTcircuit *ckt) +{ +struct b3soiSizeDependParam *pParam; +int Fatal_Flag = 0; +FILE *fplog; + + if ((fplog = fopen("b3soiV3check.log", "w")) != NULL) + { pParam = here->pParam; + fprintf(fplog, "B3SOIV3 Parameter Check\n"); + fprintf(fplog, "Model = %s\n", model->B3SOImodName); + fprintf(fplog, "W = %g, L = %g\n", here->B3SOIw, here->B3SOIl); + + + if (pParam->B3SOInlx < -pParam->B3SOIleff) + { fprintf(fplog, "Fatal: Nlx = %g is less than -Leff.\n", + pParam->B3SOInlx); + printf("Fatal: Nlx = %g is less than -Leff.\n", + pParam->B3SOInlx); + Fatal_Flag = 1; + } + + if (model->B3SOItox <= 0.0) + { fprintf(fplog, "Fatal: Tox = %g is not positive.\n", + model->B3SOItox); + printf("Fatal: Tox = %g is not positive.\n", model->B3SOItox); + Fatal_Flag = 1; + } + +/* v2.2.3 */ + if (model->B3SOItox - model->B3SOIdtoxcv <= 0.0) + { fprintf(fplog, "Fatal: Tox - dtoxcv = %g is not positive.\n", + model->B3SOItox - model->B3SOIdtoxcv); + printf("Fatal: Tox - dtoxcv = %g is not positive.\n", model->B3SOItox - model->B3SOIdtoxcv); + Fatal_Flag = 1; + } + + + if (model->B3SOItbox <= 0.0) + { fprintf(fplog, "Fatal: Tbox = %g is not positive.\n", + model->B3SOItbox); + printf("Fatal: Tbox = %g is not positive.\n", model->B3SOItbox); + Fatal_Flag = 1; + } + + if (pParam->B3SOInpeak <= 0.0) + { fprintf(fplog, "Fatal: Nch = %g is not positive.\n", + pParam->B3SOInpeak); + printf("Fatal: Nch = %g is not positive.\n", + pParam->B3SOInpeak); + Fatal_Flag = 1; + } + if (pParam->B3SOIngate < 0.0) + { fprintf(fplog, "Fatal: Ngate = %g is not positive.\n", + pParam->B3SOIngate); + printf("Fatal: Ngate = %g Ngate is not positive.\n", + pParam->B3SOIngate); + Fatal_Flag = 1; + } + if (pParam->B3SOIngate > 1.e25) + { fprintf(fplog, "Fatal: Ngate = %g is too high.\n", + pParam->B3SOIngate); + printf("Fatal: Ngate = %g Ngate is too high\n", + pParam->B3SOIngate); + Fatal_Flag = 1; + } + + if (pParam->B3SOIdvt1 < 0.0) + { fprintf(fplog, "Fatal: Dvt1 = %g is negative.\n", + pParam->B3SOIdvt1); + printf("Fatal: Dvt1 = %g is negative.\n", pParam->B3SOIdvt1); + Fatal_Flag = 1; + } + + if (pParam->B3SOIdvt1w < 0.0) + { fprintf(fplog, "Fatal: Dvt1w = %g is negative.\n", + pParam->B3SOIdvt1w); + printf("Fatal: Dvt1w = %g is negative.\n", pParam->B3SOIdvt1w); + Fatal_Flag = 1; + } + + if (pParam->B3SOIw0 == -pParam->B3SOIweff) + { 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->B3SOIdsub < 0.0) + { fprintf(fplog, "Fatal: Dsub = %g is negative.\n", pParam->B3SOIdsub); + printf("Fatal: Dsub = %g is negative.\n", pParam->B3SOIdsub); + Fatal_Flag = 1; + } + if (pParam->B3SOIb1 == -pParam->B3SOIweff) + { 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->B3SOIu0temp <= 0.0) + { fprintf(fplog, "Fatal: u0 at current temperature = %g is not positive.\n", pParam->B3SOIu0temp); + printf("Fatal: u0 at current temperature = %g is not positive.\n", + pParam->B3SOIu0temp); + Fatal_Flag = 1; + } + +/* Check delta parameter */ + if (pParam->B3SOIdelta < 0.0) + { fprintf(fplog, "Fatal: Delta = %g is less than zero.\n", + pParam->B3SOIdelta); + printf("Fatal: Delta = %g is less than zero.\n", pParam->B3SOIdelta); + Fatal_Flag = 1; + } + + if (pParam->B3SOIvsattemp <= 0.0) + { fprintf(fplog, "Fatal: Vsat at current temperature = %g is not positive.\n", pParam->B3SOIvsattemp); + printf("Fatal: Vsat at current temperature = %g is not positive.\n", + pParam->B3SOIvsattemp); + Fatal_Flag = 1; + } +/* Check Rout parameters */ + if (pParam->B3SOIpclm <= 0.0) + { fprintf(fplog, "Fatal: Pclm = %g is not positive.\n", pParam->B3SOIpclm); + printf("Fatal: Pclm = %g is not positive.\n", pParam->B3SOIpclm); + Fatal_Flag = 1; + } + + if (pParam->B3SOIdrout < 0.0) + { fprintf(fplog, "Fatal: Drout = %g is negative.\n", pParam->B3SOIdrout); + printf("Fatal: Drout = %g is negative.\n", pParam->B3SOIdrout); + Fatal_Flag = 1; + } + if ( model->B3SOIunitLengthGateSidewallJctCap > 0.0) + { + if (here->B3SOIdrainPerimeter < pParam->B3SOIweff) + { fprintf(fplog, "Warning: Pd = %g is less than W.\n", + here->B3SOIdrainPerimeter); + printf("Warning: Pd = %g is less than W.\n", + here->B3SOIdrainPerimeter); + here->B3SOIdrainPerimeter =pParam->B3SOIweff; + } + if (here->B3SOIsourcePerimeter < pParam->B3SOIweff) + { fprintf(fplog, "Warning: Ps = %g is less than W.\n", + here->B3SOIsourcePerimeter); + printf("Warning: Ps = %g is less than W.\n", + here->B3SOIsourcePerimeter); + here->B3SOIsourcePerimeter =pParam->B3SOIweff; + } + } +/* Check capacitance parameters */ + if (pParam->B3SOIclc < 0.0) + { fprintf(fplog, "Fatal: Clc = %g is negative.\n", pParam->B3SOIclc); + printf("Fatal: Clc = %g is negative.\n", pParam->B3SOIclc); + Fatal_Flag = 1; + } + +/* v2.2.3 */ + if (pParam->B3SOImoin < 5.0) + { fprintf(fplog, "Warning: Moin = %g is too small.\n", + pParam->B3SOImoin); + printf("Warning: Moin = %g is too small.\n", pParam->B3SOImoin); + } + if (pParam->B3SOImoin > 25.0) + { fprintf(fplog, "Warning: Moin = %g is too large.\n", + pParam->B3SOImoin); + printf("Warning: Moin = %g is too large.\n", pParam->B3SOImoin); + } + +/* v3.0 */ + if (model->B3SOImoinFD < 5.0) + { fprintf(fplog, "Warning: MoinFD = %g is too small.\n", + model->B3SOImoinFD); + printf("Warning: MoinFD = %g is too small.\n", model->B3SOImoinFD); + } + + + if (model->B3SOIcapMod == 3) { + if (pParam->B3SOIacde < 0.4) + { fprintf (fplog, "Warning: Acde = %g is too small.\n", + pParam->B3SOIacde); + printf ("Warning: Acde = %g is too small.\n", + pParam->B3SOIacde); + } + if (pParam->B3SOIacde > 1.6) + { fprintf (fplog, "Warning: Acde = %g is too large.\n", + pParam->B3SOIacde); + printf ("Warning: Acde = %g is too large.\n", + pParam->B3SOIacde); + } + } +/* v2.2.3 */ + + if (model->B3SOIparamChk ==1) + { +/* Check L and W parameters */ + if (pParam->B3SOIleff <= 5.0e-8) + { fprintf(fplog, "Warning: Leff = %g may be too small.\n", + pParam->B3SOIleff); + printf("Warning: Leff = %g may be too small.\n", + pParam->B3SOIleff); + } + + if (pParam->B3SOIleffCV <= 5.0e-8) + { fprintf(fplog, "Warning: Leff for CV = %g may be too small.\n", + pParam->B3SOIleffCV); + printf("Warning: Leff for CV = %g may be too small.\n", + pParam->B3SOIleffCV); + } + + if (pParam->B3SOIweff <= 1.0e-7) + { fprintf(fplog, "Warning: Weff = %g may be too small.\n", + pParam->B3SOIweff); + printf("Warning: Weff = %g may be too small.\n", + pParam->B3SOIweff); + } + + if (pParam->B3SOIweffCV <= 1.0e-7) + { fprintf(fplog, "Warning: Weff for CV = %g may be too small.\n", + pParam->B3SOIweffCV); + printf("Warning: Weff for CV = %g may be too small.\n", + pParam->B3SOIweffCV); + } + +/* Check threshold voltage parameters */ + if (pParam->B3SOInlx < 0.0) + { fprintf(fplog, "Warning: Nlx = %g is negative.\n", pParam->B3SOInlx); + printf("Warning: Nlx = %g is negative.\n", pParam->B3SOInlx); + } + if (model->B3SOItox < 1.0e-9) + { fprintf(fplog, "Warning: Tox = %g is less than 10A.\n", + model->B3SOItox); + printf("Warning: Tox = %g is less than 10A.\n", model->B3SOItox); + } + + if (pParam->B3SOInpeak <= 1.0e15) + { fprintf(fplog, "Warning: Nch = %g may be too small.\n", + pParam->B3SOInpeak); + printf("Warning: Nch = %g may be too small.\n", + pParam->B3SOInpeak); + } + else if (pParam->B3SOInpeak >= 1.0e21) + { fprintf(fplog, "Warning: Nch = %g may be too large.\n", + pParam->B3SOInpeak); + printf("Warning: Nch = %g may be too large.\n", + pParam->B3SOInpeak); + } + + if (fabs(pParam->B3SOInsub) >= 1.0e21) + { fprintf(fplog, "Warning: Nsub = %g may be too large.\n", + pParam->B3SOInsub); + printf("Warning: Nsub = %g may be too large.\n", + pParam->B3SOInsub); + } + + if ((pParam->B3SOIngate > 0.0) && + (pParam->B3SOIngate <= 1.e18)) + { fprintf(fplog, "Warning: Ngate = %g is less than 1.E18cm^-3.\n", + pParam->B3SOIngate); + printf("Warning: Ngate = %g is less than 1.E18cm^-3.\n", + pParam->B3SOIngate); + } + + if (pParam->B3SOIdvt0 < 0.0) + { fprintf(fplog, "Warning: Dvt0 = %g is negative.\n", + pParam->B3SOIdvt0); + printf("Warning: Dvt0 = %g is negative.\n", pParam->B3SOIdvt0); + } + + if (fabs(1.0e-6 / (pParam->B3SOIw0 + pParam->B3SOIweff)) > 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->B3SOInfactor < 0.0) + { fprintf(fplog, "Warning: Nfactor = %g is negative.\n", + pParam->B3SOInfactor); + printf("Warning: Nfactor = %g is negative.\n", pParam->B3SOInfactor); + } + if (pParam->B3SOIcdsc < 0.0) + { fprintf(fplog, "Warning: Cdsc = %g is negative.\n", + pParam->B3SOIcdsc); + printf("Warning: Cdsc = %g is negative.\n", pParam->B3SOIcdsc); + } + if (pParam->B3SOIcdscd < 0.0) + { fprintf(fplog, "Warning: Cdscd = %g is negative.\n", + pParam->B3SOIcdscd); + printf("Warning: Cdscd = %g is negative.\n", pParam->B3SOIcdscd); + } +/* Check DIBL parameters */ + if (pParam->B3SOIeta0 < 0.0) + { fprintf(fplog, "Warning: Eta0 = %g is negative.\n", + pParam->B3SOIeta0); + printf("Warning: Eta0 = %g is negative.\n", pParam->B3SOIeta0); + } + +/* Check Abulk parameters */ + if (fabs(1.0e-6 / (pParam->B3SOIb1 + pParam->B3SOIweff)) > 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->B3SOIa2 < 0.01) + { fprintf(fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", pParam->B3SOIa2); + printf("Warning: A2 = %g is too small. Set to 0.01.\n", + pParam->B3SOIa2); + pParam->B3SOIa2 = 0.01; + } + else if (pParam->B3SOIa2 > 1.0) + { fprintf(fplog, "Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n", + pParam->B3SOIa2); + printf("Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n", + pParam->B3SOIa2); + pParam->B3SOIa2 = 1.0; + pParam->B3SOIa1 = 0.0; + + } + + if (pParam->B3SOIrdsw < 0.0) + { fprintf(fplog, "Warning: Rdsw = %g is negative. Set to zero.\n", + pParam->B3SOIrdsw); + printf("Warning: Rdsw = %g is negative. Set to zero.\n", + pParam->B3SOIrdsw); + pParam->B3SOIrdsw = 0.0; + pParam->B3SOIrds0 = 0.0; + } + else if ((pParam->B3SOIrds0 > 0.0) && (pParam->B3SOIrds0 < 0.001)) + { fprintf(fplog, "Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n", + pParam->B3SOIrds0); + printf("Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n", + pParam->B3SOIrds0); + pParam->B3SOIrds0 = 0.0; + } + if (pParam->B3SOIvsattemp < 1.0e3) + { fprintf(fplog, "Warning: Vsat at current temperature = %g may be too small.\n", pParam->B3SOIvsattemp); + printf("Warning: Vsat at current temperature = %g may be too small.\n", pParam->B3SOIvsattemp); + } + + if (pParam->B3SOIpdibl1 < 0.0) + { fprintf(fplog, "Warning: Pdibl1 = %g is negative.\n", + pParam->B3SOIpdibl1); + printf("Warning: Pdibl1 = %g is negative.\n", pParam->B3SOIpdibl1); + } + if (pParam->B3SOIpdibl2 < 0.0) + { fprintf(fplog, "Warning: Pdibl2 = %g is negative.\n", + pParam->B3SOIpdibl2); + printf("Warning: Pdibl2 = %g is negative.\n", pParam->B3SOIpdibl2); + } +/* Check overlap capacitance parameters */ + if (model->B3SOIcgdo < 0.0) + { fprintf(fplog, "Warning: cgdo = %g is negative. Set to zero.\n", model->B3SOIcgdo); + printf("Warning: cgdo = %g is negative. Set to zero.\n", model->B3SOIcgdo); + model->B3SOIcgdo = 0.0; + } + if (model->B3SOIcgso < 0.0) + { fprintf(fplog, "Warning: cgso = %g is negative. Set to zero.\n", model->B3SOIcgso); + printf("Warning: cgso = %g is negative. Set to zero.\n", model->B3SOIcgso); + model->B3SOIcgso = 0.0; + } + if (model->B3SOIcgeo < 0.0) + { fprintf(fplog, "Warning: cgeo = %g is negative. Set to zero.\n", model->B3SOIcgeo); + printf("Warning: cgeo = %g is negative. Set to zero.\n", model->B3SOIcgeo); + model->B3SOIcgeo = 0.0; + } + + if (model->B3SOIntun < 0.0) + { fprintf(fplog, "Warning: Ntun = %g is negative.\n", + model->B3SOIntun); + printf("Warning: Ntun = %g is negative.\n", model->B3SOIntun); + } + + if (model->B3SOIndiode < 0.0) + { fprintf(fplog, "Warning: Ndiode = %g is negative.\n", + model->B3SOIndiode); + printf("Warning: Ndiode = %g is negative.\n", model->B3SOIndiode); + } + + if (model->B3SOIisbjt < 0.0) + { fprintf(fplog, "Warning: Isbjt = %g is negative.\n", + model->B3SOIisbjt); + printf("Warning: Isbjt = %g is negative.\n", model->B3SOIisbjt); + } + + if (model->B3SOIisdif < 0.0) + { fprintf(fplog, "Warning: Isdif = %g is negative.\n", + model->B3SOIisdif); + printf("Warning: Isdif = %g is negative.\n", model->B3SOIisdif); + } + + if (model->B3SOIisrec < 0.0) + { fprintf(fplog, "Warning: Isrec = %g is negative.\n", + model->B3SOIisrec); + printf("Warning: Isrec = %g is negative.\n", model->B3SOIisrec); + } + + if (model->B3SOIistun < 0.0) + { fprintf(fplog, "Warning: Istun = %g is negative.\n", + model->B3SOIistun); + printf("Warning: Istun = %g is negative.\n", model->B3SOIistun); + } + + if (model->B3SOItt < 0.0) + { fprintf(fplog, "Warning: Tt = %g is negative.\n", + model->B3SOItt); + printf("Warning: Tt = %g is negative.\n", model->B3SOItt); + } + + if (model->B3SOIcsdmin < 0.0) + { fprintf(fplog, "Warning: Csdmin = %g is negative.\n", + model->B3SOIcsdmin); + printf("Warning: Csdmin = %g is negative.\n", model->B3SOIcsdmin); + } + + if (model->B3SOIcsdesw < 0.0) + { fprintf(fplog, "Warning: Csdesw = %g is negative.\n", + model->B3SOIcsdesw); + printf("Warning: Csdesw = %g is negative.\n", model->B3SOIcsdesw); + } + + if (model->B3SOIasd < 0.0) + { fprintf(fplog, "Warning: Asd = %g should be within (0, 1).\n", + model->B3SOIasd); + printf("Warning: Asd = %g should be within (0, 1).\n", model->B3SOIasd); + } + + if (model->B3SOIrth0 < 0.0) + { fprintf(fplog, "Warning: Rth0 = %g is negative.\n", + model->B3SOIrth0); + printf("Warning: Rth0 = %g is negative.\n", model->B3SOIrth0); + } + + if (model->B3SOIcth0 < 0.0) + { fprintf(fplog, "Warning: Cth0 = %g is negative.\n", + model->B3SOIcth0); + printf("Warning: Cth0 = %g is negative.\n", model->B3SOIcth0); + } + + if (model->B3SOIrbody < 0.0) + { fprintf(fplog, "Warning: Rbody = %g is negative.\n", + model->B3SOIrbody); + printf("Warning: Rbody = %g is negative.\n", model->B3SOIrbody); + } + + if (model->B3SOIrbsh < 0.0) + { fprintf(fplog, "Warning: Rbsh = %g is negative.\n", + model->B3SOIrbsh); + printf("Warning: Rbsh = %g is negative.\n", model->B3SOIrbsh); + } + + +/* v3.0 */ + if (pParam->B3SOInigc <= 0.0) + { fprintf(fplog, "Fatal: nigc = %g is non-positive.\n", + pParam->B3SOInigc); + printf("Fatal: nigc = %g is non-positive.\n", pParam->B3SOInigc); + Fatal_Flag = 1; + } + if (pParam->B3SOIpoxedge <= 0.0) + { fprintf(fplog, "Fatal: poxedge = %g is non-positive.\n", + pParam->B3SOIpoxedge); + printf("Fatal: poxedge = %g is non-positive.\n", pParam->B3SOIpoxedge); + Fatal_Flag = 1; + } + if (pParam->B3SOIpigcd <= 0.0) + { fprintf(fplog, "Fatal: pigcd = %g is non-positive.\n", + pParam->B3SOIpigcd); + printf("Fatal: pigcd = %g is non-positive.\n", pParam->B3SOIpigcd); + Fatal_Flag = 1; + } + + +/* v2.2 release */ + if (model->B3SOIwth0 < 0.0) + { fprintf(fplog, "Warning: WTH0 = %g is negative.\n", + model->B3SOIwth0); + printf("Warning: Wth0 = %g is negative.\n", model->B3SOIwth0); + } + if (model->B3SOIrhalo < 0.0) + { fprintf(fplog, "Warning: RHALO = %g is negative.\n", + model->B3SOIrhalo); + printf("Warning: Rhalo = %g is negative.\n", model->B3SOIrhalo); + } + if (model->B3SOIntox < 0.0) + { fprintf(fplog, "Warning: NTOX = %g is negative.\n", + model->B3SOIntox); + printf("Warning: Ntox = %g is negative.\n", model->B3SOIntox); + } + if (model->B3SOItoxref < 0.0) + { fprintf(fplog, "Warning: TOXREF = %g is negative.\n", + model->B3SOItoxref); + printf("Warning: Toxref = %g is negative.\n", model->B3SOItoxref); + Fatal_Flag = 1; + } + if (model->B3SOIebg < 0.0) + { fprintf(fplog, "Warning: EBG = %g is negative.\n", + model->B3SOIebg); + printf("Warning: Ebg = %g is negative.\n", model->B3SOIebg); + } + if (model->B3SOIvevb < 0.0) + { fprintf(fplog, "Warning: VEVB = %g is negative.\n", + model->B3SOIvevb); + printf("Warning: Vevb = %g is negative.\n", model->B3SOIvevb); + } + if (model->B3SOIalphaGB1 < 0.0) + { fprintf(fplog, "Warning: ALPHAGB1 = %g is negative.\n", + model->B3SOIalphaGB1); + printf("Warning: AlphaGB1 = %g is negative.\n", model->B3SOIalphaGB1); + } + if (model->B3SOIbetaGB1 < 0.0) + { fprintf(fplog, "Warning: BETAGB1 = %g is negative.\n", + model->B3SOIbetaGB1); + printf("Warning: BetaGB1 = %g is negative.\n", model->B3SOIbetaGB1); + } + if (model->B3SOIvgb1 < 0.0) + { fprintf(fplog, "Warning: VGB1 = %g is negative.\n", + model->B3SOIvgb1); + printf("Warning: Vgb1 = %g is negative.\n", model->B3SOIvgb1); + } + if (model->B3SOIvecb < 0.0) + { fprintf(fplog, "Warning: VECB = %g is negative.\n", + model->B3SOIvecb); + printf("Warning: Vecb = %g is negative.\n", model->B3SOIvecb); + } + if (model->B3SOIalphaGB2 < 0.0) + { fprintf(fplog, "Warning: ALPHAGB2 = %g is negative.\n", + model->B3SOIalphaGB2); + printf("Warning: AlphaGB2 = %g is negative.\n", model->B3SOIalphaGB2); + } + if (model->B3SOIbetaGB2 < 0.0) + { fprintf(fplog, "Warning: BETAGB2 = %g is negative.\n", + model->B3SOIbetaGB2); + printf("Warning: BetaGB2 = %g is negative.\n", model->B3SOIbetaGB2); + } + if (model->B3SOIvgb2 < 0.0) + { fprintf(fplog, "Warning: VGB2 = %g is negative.\n", + model->B3SOIvgb2); + printf("Warning: Vgb2 = %g is negative.\n", model->B3SOIvgb2); + } + if (model->B3SOItoxqm <= 0.0) + { fprintf(fplog, "Fatal: Toxqm = %g is not positive.\n", + model->B3SOItoxqm); + printf("Fatal: Toxqm = %g is not positive.\n", model->B3SOItoxqm); + Fatal_Flag = 1; + } + if (model->B3SOIvoxh < 0.0) + { fprintf(fplog, "Warning: Voxh = %g is negative.\n", + model->B3SOIvoxh); + printf("Warning: Voxh = %g is negative.\n", model->B3SOIvoxh); + } + if (model->B3SOIdeltavox <= 0.0) + { fprintf(fplog, "Fatal: Deltavox = %g is not positive.\n", + model->B3SOIdeltavox); + printf("Fatal: Deltavox = %g is not positive.\n", model->B3SOIdeltavox); + } + + +/* v2.0 release */ + if (model->B3SOIk1w1 < 0.0) + { fprintf(fplog, "Warning: K1W1 = %g is negative.\n", + model->B3SOIk1w1); + printf("Warning: K1w1 = %g is negative.\n", model->B3SOIk1w1); + } + if (model->B3SOIk1w2 < 0.0) + { fprintf(fplog, "Warning: K1W2 = %g is negative.\n", + model->B3SOIk1w2); + printf("Warning: K1w2 = %g is negative.\n", model->B3SOIk1w2); + } + if (model->B3SOIketas < 0.0) + { fprintf(fplog, "Warning: KETAS = %g is negative.\n", + model->B3SOIketas); + printf("Warning: Ketas = %g is negative.\n", model->B3SOIketas); + } + if (model->B3SOIdwbc < 0.0) + { fprintf(fplog, "Warning: DWBC = %g is negative.\n", + model->B3SOIdwbc); + printf("Warning: Dwbc = %g is negative.\n", model->B3SOIdwbc); + } + if (model->B3SOIbeta0 < 0.0) + { fprintf(fplog, "Warning: BETA0 = %g is negative.\n", + model->B3SOIbeta0); + printf("Warning: Beta0 = %g is negative.\n", model->B3SOIbeta0); + } + if (model->B3SOIbeta1 < 0.0) + { fprintf(fplog, "Warning: BETA1 = %g is negative.\n", + model->B3SOIbeta1); + printf("Warning: Beta1 = %g is negative.\n", model->B3SOIbeta1); + } + if (model->B3SOIbeta2 < 0.0) + { fprintf(fplog, "Warning: BETA2 = %g is negative.\n", + model->B3SOIbeta2); + printf("Warning: Beta2 = %g is negative.\n", model->B3SOIbeta2); + } + if (model->B3SOItii < 0.0) + { fprintf(fplog, "Warning: TII = %g is negative.\n", + model->B3SOItii); + printf("Warning: Tii = %g is negative.\n", model->B3SOItii); + } + if (model->B3SOIlii < 0.0) + { fprintf(fplog, "Warning: LII = %g is negative.\n", + model->B3SOIlii); + printf("Warning: Lii = %g is negative.\n", model->B3SOIlii); + } + if (model->B3SOIsii1 < 0.0) + { fprintf(fplog, "Warning: SII1 = %g is negative.\n", + model->B3SOIsii1); + printf("Warning: Sii1 = %g is negative.\n", model->B3SOIsii1); + } + if (model->B3SOIsii2 < 0.0) + { fprintf(fplog, "Warning: SII2 = %g is negative.\n", + model->B3SOIsii2); + printf("Warning: Sii2 = %g is negative.\n", model->B3SOIsii1); + } + if (model->B3SOIsiid < 0.0) + { fprintf(fplog, "Warning: SIID = %g is negative.\n", + model->B3SOIsiid); + printf("Warning: Siid = %g is negative.\n", model->B3SOIsiid); + } + if (model->B3SOIfbjtii < 0.0) + { fprintf(fplog, "Warning: FBJTII = %g is negative.\n", + model->B3SOIfbjtii); + printf("Warning: fbjtii = %g is negative.\n", model->B3SOIfbjtii); + } + if (model->B3SOIvrec0 < 0.0) + { fprintf(fplog, "Warning: VREC0 = %g is negative.\n", + model->B3SOIvrec0); + printf("Warning: Vrec0 = %g is negative.\n", model->B3SOIvrec0); + } + if (model->B3SOIvtun0 < 0.0) + { fprintf(fplog, "Warning: VTUN0 = %g is negative.\n", + model->B3SOIvtun0); + printf("Warning: Vtun0 = %g is negative.\n", model->B3SOIvtun0); + } + if (model->B3SOInbjt < 0.0) + { fprintf(fplog, "Warning: NBJT = %g is negative.\n", + model->B3SOInbjt); + printf("Warning: Nbjt = %g is negative.\n", model->B3SOInbjt); + } + if (model->B3SOIaely < 0.0) + { fprintf(fplog, "Warning: AELY = %g is negative.\n", + model->B3SOIaely); + printf("Warning: Aely = %g is negative.\n", model->B3SOIaely); + } + if (model->B3SOIahli < 0.0) + { fprintf(fplog, "Warning: AHLI = %g is negative.\n", + model->B3SOIahli); + printf("Warning: Ahli = %g is negative.\n", model->B3SOIahli); + } + if (model->B3SOIrbody < 0.0) + { fprintf(fplog, "Warning: RBODY = %g is negative.\n", + model->B3SOIrbody); + printf("Warning: Rbody = %g is negative.\n", model->B3SOIrbody); + } + if (model->B3SOIrbsh < 0.0) + { fprintf(fplog, "Warning: RBSH = %g is negative.\n", + model->B3SOIrbsh); + printf("Warning: Rbsh = %g is negative.\n", model->B3SOIrbsh); + } + if (model->B3SOIntrecf < 0.0) + { fprintf(fplog, "Warning: NTRECF = %g is negative.\n", + model->B3SOIntrecf); + printf("Warning: Ntrecf = %g is negative.\n", model->B3SOIntrecf); + } + if (model->B3SOIntrecr < 0.0) + { fprintf(fplog, "Warning: NTRECR = %g is negative.\n", + model->B3SOIntrecr); + printf("Warning: Ntrecr = %g is negative.\n", model->B3SOIntrecr); + } + +/* v3.0 bug fix */ +/* + if (model->B3SOIndif < 0.0) + { fprintf(fplog, "Warning: NDIF = %g is negative.\n", + model->B3SOIndif); + printf("Warning: Ndif = %g is negative.\n", model->B3SOIndif); + } +*/ + + if (model->B3SOItcjswg < 0.0) + { fprintf(fplog, "Warning: TCJSWG = %g is negative.\n", + model->B3SOItcjswg); + printf("Warning: Tcjswg = %g is negative.\n", model->B3SOItcjswg); + } + if (model->B3SOItpbswg < 0.0) + { fprintf(fplog, "Warning: TPBSWG = %g is negative.\n", + model->B3SOItpbswg); + printf("Warning: Tpbswg = %g is negative.\n", model->B3SOItpbswg); + } + if ((model->B3SOIacde < 0.4) || (model->B3SOIacde > 1.6)) + { fprintf(fplog, "Warning: ACDE = %g is out of range.\n", + model->B3SOIacde); + printf("Warning: Acde = %g is out of range.\n", model->B3SOIacde); + } + if ((model->B3SOImoin < 5.0)||(model->B3SOImoin > 25.0)) + { fprintf(fplog, "Warning: MOIN = %g is out of range.\n", + model->B3SOImoin); + printf("Warning: Moin = %g is out of range.\n", model->B3SOImoin); + } + if (model->B3SOIdlbg < 0.0) + { fprintf(fplog, "Warning: DLBG = %g is negative.\n", + model->B3SOIdlbg); + printf("Warning: dlbg = %g is negative.\n", model->B3SOIdlbg); + } + + + if (model->B3SOIagidl < 0.0) + { fprintf(fplog, "Warning: AGIDL = %g is negative.\n", + model->B3SOIagidl); + printf("Warning: Agidl = %g is negative.\n", model->B3SOIagidl); + } + if (model->B3SOIbgidl < 0.0) + { fprintf(fplog, "Warning: BGIDL = %g is negative.\n", + model->B3SOIbgidl); + printf("Warning: Bgidl = %g is negative.\n", model->B3SOIbgidl); + } + if (model->B3SOIngidl < 0.0) + { fprintf(fplog, "Warning: NGIDL = %g is negative.\n", + model->B3SOIngidl); + printf("Warning: Ngidl = %g is negative.\n", model->B3SOIngidl); + } + if (model->B3SOIesatii < 0.0) + { fprintf(fplog, "Warning: Esatii = %g should be within positive.\n", + model->B3SOIesatii); + printf("Warning: Esatii = %g should be within (0, 1).\n", model->B3SOIesatii); + } + + + if (model->B3SOIxj > model->B3SOItsi) + { fprintf(fplog, "Warning: Xj = %g is thicker than Tsi = %g.\n", + model->B3SOIxj, model->B3SOItsi); + printf("Warning: Xj = %g is thicker than Tsi = %g.\n", + model->B3SOIxj, model->B3SOItsi); + } + + if (model->B3SOIcapMod < 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/b3soicvtest.c b/src/spicelib/devices/bsim3soi/b3soicvtest.c new file mode 100644 index 000000000..9f637d041 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soicvtest.c @@ -0,0 +1,92 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soicvtest.c 98/5/01 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "cktdefs.h" +#include "b3soidef.h" +#include "trandefs.h" +#include "const.h" +#include "devdefs.h" +#include "sperror.h" +#include "suffix.h" + + +int +B3SOIconvTest(GENmodel *inModel, CKTcircuit *ckt) +{ +B3SOImodel *model = (B3SOImodel*)inModel; +B3SOIinstance *here; +double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds; +double cbd, cbhat, cbs, cd, cdhat, tol, vgd, vgdo, vgs; + + /* loop through all the B3SOI device models */ + for (; model != NULL; model = model->B3SOInextModel) + { /* loop through all the instances of the model */ + for (here = model->B3SOIinstances; here != NULL ; + here=here->B3SOInextInstance) + { + + if (here->B3SOIowner != ARCHme) + continue; + + vbs = model->B3SOItype + * (*(ckt->CKTrhsOld+here->B3SOIbNode) + - *(ckt->CKTrhsOld+here->B3SOIsNodePrime)); + vgs = model->B3SOItype + * (*(ckt->CKTrhsOld+here->B3SOIgNode) + - *(ckt->CKTrhsOld+here->B3SOIsNodePrime)); + vds = model->B3SOItype + * (*(ckt->CKTrhsOld+here->B3SOIdNodePrime) + - *(ckt->CKTrhsOld+here->B3SOIsNodePrime)); + vbd = vbs - vds; + vgd = vgs - vds; + vgdo = *(ckt->CKTstate0 + here->B3SOIvgs) + - *(ckt->CKTstate0 + here->B3SOIvds); + delvbs = vbs - *(ckt->CKTstate0 + here->B3SOIvbs); + delvbd = vbd - *(ckt->CKTstate0 + here->B3SOIvbd); + delvgs = vgs - *(ckt->CKTstate0 + here->B3SOIvgs); + delvds = vds - *(ckt->CKTstate0 + here->B3SOIvds); + delvgd = vgd-vgdo; + + cd = here->B3SOIcd; + if (here->B3SOImode >= 0) + { cdhat = cd - here->B3SOIgjdb * delvbd + + here->B3SOIgmbs * delvbs + here->B3SOIgm * delvgs + + here->B3SOIgds * delvds; + } + else + { cdhat = cd - (here->B3SOIgjdb - here->B3SOIgmbs) * delvbd + - here->B3SOIgm * delvgd + here->B3SOIgds * delvds; + } + + /* + * check convergence + */ + if ((here->B3SOIoff == 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->B3SOIcjs; + cbd = here->B3SOIcjd; + cbhat = cbs + cbd + here->B3SOIgjdb * delvbd + + here->B3SOIgjsb * 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/b3soidef.h b/src/spicelib/devices/bsim3soi/b3soidef.h new file mode 100644 index 000000000..6000deb6e --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soidef.h @@ -0,0 +1,2462 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung +File: b3soidef.h +Modified by Pin Su and Jan Feng 99/2/15 +Modified by Pin Su 99/4/30 +Modified by Pin Su and Wei Jin 99/9/27 +Modified by Pin Su 00/3/1 +Modified by Pin Su 01/2/15 +Modified by Pin Su and Hui Wan 02/3/5 +Modified by Pin Su 02/5/20 +Modified by Paolo Nenzi 2002 +**********/ + +#ifndef B3SOI +#define B3SOI + +#define SOICODE +/* #define BULKCODE */ + +#include "ifsim.h" +#include "gendefs.h" +#include "cktdefs.h" +#include "complex.h" +#include "noisedef.h" + +typedef struct sB3SOIinstance +{ + struct sB3SOImodel *B3SOImodPtr; + struct sB3SOIinstance *B3SOInextInstance; + IFuid B3SOIname; + int B3SOIowner; /* number of owner process */ + int B3SOIstates; /* index into state table for this device */ + + int B3SOIdNode; + int B3SOIgNode; + int B3SOIsNode; + int B3SOIeNode; + int B3SOIpNode; + int B3SOIbNode; + int B3SOItempNode; + int B3SOIdNodePrime; + int B3SOIsNodePrime; + + int B3SOIvbsNode; + /* for Debug */ + int B3SOIidsNode; + int B3SOIicNode; + int B3SOIibsNode; + int B3SOIibdNode; + int B3SOIiiiNode; + int B3SOIigNode; + int B3SOIgiggNode; + int B3SOIgigdNode; + int B3SOIgigbNode; + int B3SOIigidlNode; + int B3SOIitunNode; + int B3SOIibpNode; + int B3SOIcbbNode; + int B3SOIcbdNode; + int B3SOIcbgNode; + + int B3SOIqbfNode; + int B3SOIqjsNode; + int B3SOIqjdNode; + + double B3SOIphi; + double B3SOIvtm; + double B3SOIni; + double B3SOIueff; + double B3SOIthetavth; + double B3SOIvon; + double B3SOIvdsat; + double B3SOIcgdo; + double B3SOIcgso; + double B3SOIcgeo; + + double B3SOIids; + double B3SOIic; + double B3SOIibs; + double B3SOIibd; + double B3SOIiii; + double B3SOIig; + double B3SOIgigg; + double B3SOIgigd; + double B3SOIgigb; + double B3SOIgige; /* v3.0 */ + double B3SOIigidl; + double B3SOIitun; + double B3SOIibp; + double B3SOIabeff; + double B3SOIvbseff; + double B3SOIcbg; + double B3SOIcbb; + double B3SOIcbd; + double B3SOIqb; + double B3SOIqbf; + double B3SOIqjs; + double B3SOIqjd; + int B3SOIfloat; + + double B3SOIl; + double B3SOIw; + double B3SOIm; + double B3SOIdrainArea; + double B3SOIsourceArea; + double B3SOIdrainSquares; + double B3SOIsourceSquares; + double B3SOIdrainPerimeter; + double B3SOIsourcePerimeter; + double B3SOIsourceConductance; + double B3SOIdrainConductance; + + double B3SOIicVBS; + double B3SOIicVDS; + double B3SOIicVGS; + double B3SOIicVES; + double B3SOIicVPS; + int B3SOIbjtoff; + int B3SOIbodyMod; + int B3SOIdebugMod; + double B3SOIrth0; + double B3SOIcth0; + double B3SOIbodySquares; + double B3SOIrbodyext; + double B3SOIfrbody; + + +/* v2.0 release */ + double B3SOInbc; + double B3SOInseg; + double B3SOIpdbcp; + double B3SOIpsbcp; + double B3SOIagbcp; + double B3SOIaebcp; + double B3SOIvbsusr; + int B3SOItnodeout; + +/* Deleted from pParam and moved to here */ + double B3SOIcsesw; + double B3SOIcdesw; + double B3SOIcsbox; + double B3SOIcdbox; + double B3SOIcsmin; + double B3SOIcdmin; + double B3SOIst4; + double B3SOIdt4; + + int B3SOIoff; + int B3SOImode; + + /* OP point */ + double B3SOIqinv; + double B3SOIcd; + double B3SOIcjs; + double B3SOIcjd; + double B3SOIcbody; +/* v2.2 release */ + double B3SOIcgate; + double B3SOIgigs; + double B3SOIgigT; + + double B3SOIcbodcon; + double B3SOIcth; + double B3SOIcsubstrate; + + double B3SOIgm; + double B3SOIgme; /* v3.0 */ + double B3SOIcb; + double B3SOIcdrain; + double B3SOIgds; + double B3SOIgmbs; + double B3SOIgmT; + + double B3SOIgbbs; + double B3SOIgbgs; + double B3SOIgbds; + double B3SOIgbes; /* v3.0 */ + double B3SOIgbps; + double B3SOIgbT; + +/* v3.0 */ + double B3SOIIgcs; + double B3SOIgIgcsg; + double B3SOIgIgcsd; + double B3SOIgIgcss; + double B3SOIgIgcsb; + double B3SOIIgcd; + double B3SOIgIgcdg; + double B3SOIgIgcdd; + double B3SOIgIgcds; + double B3SOIgIgcdb; + + double B3SOIIgs; + double B3SOIgIgsg; + double B3SOIgIgss; + double B3SOIIgd; + double B3SOIgIgdg; + double B3SOIgIgdd; + + + double B3SOIgjsd; + double B3SOIgjsb; + double B3SOIgjsg; + double B3SOIgjsT; + + double B3SOIgjdb; + double B3SOIgjdd; + double B3SOIgjdg; + double B3SOIgjde; /* v3.0 */ + double B3SOIgjdT; + + double B3SOIgbpbs; + double B3SOIgbpps; + double B3SOIgbpT; + + double B3SOIgtempb; + double B3SOIgtempg; + double B3SOIgtempd; + double B3SOIgtempe; /* v3.0 */ + double B3SOIgtempT; + + double B3SOIcggb; + double B3SOIcgdb; + double B3SOIcgsb; + double B3SOIcgT; + + double B3SOIcbgb; + double B3SOIcbdb; + double B3SOIcbsb; + double B3SOIcbeb; + double B3SOIcbT; + + double B3SOIcdgb; + double B3SOIcddb; + double B3SOIcdsb; + double B3SOIcdeb; + double B3SOIcdT; + + double B3SOIceeb; + double B3SOIceT; + + double B3SOIqse; + double B3SOIgcse; + double B3SOIqde; + double B3SOIgcde; + double B3SOIrds; /* v2.2.3 */ + double B3SOIVgsteff; /* v2.2.3 */ + double B3SOIVdseff; /* v2.2.3 */ + double B3SOIAbovVgst2Vtm; /* v2.2.3 */ + + struct b3soiSizeDependParam *pParam; + + unsigned B3SOIlGiven :1; + unsigned B3SOIwGiven :1; + unsigned B3SOImGiven :1; + unsigned B3SOIdrainAreaGiven :1; + unsigned B3SOIsourceAreaGiven :1; + unsigned B3SOIdrainSquaresGiven :1; + unsigned B3SOIsourceSquaresGiven :1; + unsigned B3SOIdrainPerimeterGiven :1; + unsigned B3SOIsourcePerimeterGiven :1; + unsigned B3SOIdNodePrimeSet :1; + unsigned B3SOIsNodePrimeSet :1; + unsigned B3SOIicVBSGiven :1; + unsigned B3SOIicVDSGiven :1; + unsigned B3SOIicVGSGiven :1; + unsigned B3SOIicVESGiven :1; + unsigned B3SOIicVPSGiven :1; + unsigned B3SOIbjtoffGiven :1; + unsigned B3SOIdebugModGiven :1; + unsigned B3SOIrth0Given :1; + unsigned B3SOIcth0Given :1; + unsigned B3SOIbodySquaresGiven :1; + unsigned B3SOIfrbodyGiven: 1; + +/* v2.0 release */ + unsigned B3SOInbcGiven :1; + unsigned B3SOInsegGiven :1; + unsigned B3SOIpdbcpGiven :1; + unsigned B3SOIpsbcpGiven :1; + unsigned B3SOIagbcpGiven :1; + unsigned B3SOIaebcpGiven :1; + unsigned B3SOIvbsusrGiven :1; + unsigned B3SOItnodeoutGiven :1; + unsigned B3SOIoffGiven :1; + + double *B3SOIGePtr; + double *B3SOIDPePtr; + double *B3SOISPePtr; + + double *B3SOIEePtr; + double *B3SOIEbPtr; + double *B3SOIBePtr; + double *B3SOIEgPtr; + double *B3SOIEdpPtr; + double *B3SOIEspPtr; + double *B3SOITemptempPtr; + double *B3SOITempdpPtr; + double *B3SOITempspPtr; + double *B3SOITempgPtr; + double *B3SOITempbPtr; + double *B3SOITempePtr; /* v3.0 */ + double *B3SOIGtempPtr; + double *B3SOIDPtempPtr; + double *B3SOISPtempPtr; + double *B3SOIEtempPtr; + double *B3SOIBtempPtr; + double *B3SOIPtempPtr; + double *B3SOIBpPtr; + double *B3SOIPbPtr; + double *B3SOIPpPtr; + double *B3SOIDdPtr; + double *B3SOIGgPtr; + double *B3SOISsPtr; + double *B3SOIBbPtr; + double *B3SOIDPdpPtr; + double *B3SOISPspPtr; + double *B3SOIDdpPtr; + double *B3SOIGbPtr; + double *B3SOIGdpPtr; + double *B3SOIGspPtr; + double *B3SOISspPtr; + double *B3SOIBdpPtr; + double *B3SOIBspPtr; + double *B3SOIDPspPtr; + double *B3SOIDPdPtr; + double *B3SOIBgPtr; + double *B3SOIDPgPtr; + double *B3SOISPgPtr; + double *B3SOISPsPtr; + double *B3SOIDPbPtr; + double *B3SOISPbPtr; + double *B3SOISPdpPtr; + + double *B3SOIVbsPtr; + /* Debug */ + double *B3SOIIdsPtr; + double *B3SOIIcPtr; + double *B3SOIIbsPtr; + double *B3SOIIbdPtr; + double *B3SOIIiiPtr; + double *B3SOIIgPtr; + double *B3SOIGiggPtr; + double *B3SOIGigdPtr; + double *B3SOIGigbPtr; + double *B3SOIIgidlPtr; + double *B3SOIItunPtr; + double *B3SOIIbpPtr; + double *B3SOICbbPtr; + double *B3SOICbdPtr; + double *B3SOICbgPtr; + double *B3SOIqbPtr; + double *B3SOIQbfPtr; + double *B3SOIQjsPtr; + double *B3SOIQjdPtr; + + +#define B3SOIvbd B3SOIstates+ 0 +#define B3SOIvbs B3SOIstates+ 1 +#define B3SOIvgs B3SOIstates+ 2 +#define B3SOIvds B3SOIstates+ 3 +#define B3SOIves B3SOIstates+ 4 +#define B3SOIvps B3SOIstates+ 5 + +#define B3SOIvg B3SOIstates+ 6 +#define B3SOIvd B3SOIstates+ 7 +#define B3SOIvs B3SOIstates+ 8 +#define B3SOIvp B3SOIstates+ 9 +#define B3SOIve B3SOIstates+ 10 +#define B3SOIdeltemp B3SOIstates+ 11 + +#define B3SOIqb B3SOIstates+ 12 +#define B3SOIcqb B3SOIstates+ 13 +#define B3SOIqg B3SOIstates+ 14 +#define B3SOIcqg B3SOIstates+ 15 +#define B3SOIqd B3SOIstates+ 16 +#define B3SOIcqd B3SOIstates+ 17 +#define B3SOIqe B3SOIstates+ 18 +#define B3SOIcqe B3SOIstates+ 19 + +#define B3SOIqbs B3SOIstates+ 20 +#define B3SOIqbd B3SOIstates+ 21 +#define B3SOIqbe B3SOIstates+ 22 + +#define B3SOIqth B3SOIstates+ 23 +#define B3SOIcqth B3SOIstates+ 24 + +#define B3SOInumStates 25 + + +/* indices to the array of B3SOI NOISE SOURCES */ + +#define B3SOIRDNOIZ 0 +#define B3SOIRSNOIZ 1 +#define B3SOIIDNOIZ 2 +#define B3SOIFLNOIZ 3 +#define B3SOIFBNOIZ 4 +#define B3SOITOTNOIZ 5 + +#define B3SOINSRCS 6 /* the number of MOSFET(3) noise sources */ + +#ifndef NONOISE + double B3SOInVar[NSTATVARS][B3SOINSRCS]; +#else /* NONOISE */ + double **B3SOInVar; +#endif /* NONOISE */ + +} B3SOIinstance ; + +struct b3soiSizeDependParam +{ + double Width; + double Length; + double Rth0; + double Cth0; + + double B3SOIcdsc; + double B3SOIcdscb; + double B3SOIcdscd; + double B3SOIcit; + double B3SOInfactor; + double B3SOIvsat; + double B3SOIat; + double B3SOIa0; + double B3SOIags; + double B3SOIa1; + double B3SOIa2; + double B3SOIketa; + double B3SOInpeak; + double B3SOInsub; + double B3SOIngate; + double B3SOIgamma1; + double B3SOIgamma2; + double B3SOIvbx; + double B3SOIvbi; + double B3SOIvbm; + double B3SOIvbsc; + double B3SOIxt; + double B3SOIphi; + double B3SOIlitl; + double B3SOIk1; + double B3SOIkt1; + double B3SOIkt1l; + double B3SOIkt2; + double B3SOIk2; + double B3SOIk3; + double B3SOIk3b; + double B3SOIw0; + double B3SOInlx; + double B3SOIdvt0; + double B3SOIdvt1; + double B3SOIdvt2; + double B3SOIdvt0w; + double B3SOIdvt1w; + double B3SOIdvt2w; + double B3SOIdrout; + double B3SOIdsub; + double B3SOIvth0; + double B3SOIua; + double B3SOIua1; + double B3SOIub; + double B3SOIub1; + double B3SOIuc; + double B3SOIuc1; + double B3SOIu0; + double B3SOIute; + double B3SOIvoff; + double B3SOIvfb; + double B3SOIuatemp; + double B3SOIubtemp; + double B3SOIuctemp; + double B3SOIrbody; + double B3SOIrth; + double B3SOIcth; + double B3SOIrds0denom; + double B3SOIvfbb; + double B3SOIjbjt; + double B3SOIjdif; + double B3SOIjrec; + double B3SOIjtun; + double B3SOIsdt1; + double B3SOIst2; + double B3SOIst3; + double B3SOIdt2; + double B3SOIdt3; + double B3SOIdelta; + double B3SOIrdsw; + double B3SOIrds0; + double B3SOIprwg; + double B3SOIprwb; + double B3SOIprt; + double B3SOIeta0; + double B3SOIetab; + double B3SOIpclm; + double B3SOIpdibl1; + double B3SOIpdibl2; + double B3SOIpdiblb; + double B3SOIpvag; + double B3SOIwr; + double B3SOIdwg; + double B3SOIdwb; + double B3SOIb0; + double B3SOIb1; + double B3SOIalpha0; + double B3SOIbeta0; +/* v3.0 */ + double B3SOIaigc; + double B3SOIbigc; + double B3SOIcigc; + double B3SOIaigsd; + double B3SOIbigsd; + double B3SOIcigsd; + double B3SOInigc; + double B3SOIpigcd; + double B3SOIpoxedge; + double B3SOIdlcig; + + /* CV model */ + double B3SOIcgsl; + double B3SOIcgdl; + double B3SOIckappa; + double B3SOIcf; + double B3SOIclc; + double B3SOIcle; + + +/* Added for binning - START0 */ + double B3SOIkb1; + double B3SOIk1w1; + double B3SOIk1w2; + double B3SOIketas; + double B3SOIfbjtii; + double B3SOIbeta1; + double B3SOIbeta2; + double B3SOIvdsatii0; + double B3SOIlii; + double B3SOIesatii; + double B3SOIsii0; + double B3SOIsii1; + double B3SOIsii2; + double B3SOIsiid; + double B3SOIagidl; + double B3SOIbgidl; + double B3SOIngidl; + double B3SOIntun; + double B3SOIndiode; + double B3SOInrecf0; + double B3SOInrecr0; + double B3SOIisbjt; + double B3SOIisdif; + double B3SOIisrec; + double B3SOIistun; + double B3SOIvrec0; + double B3SOIvtun0; + double B3SOInbjt; + double B3SOIlbjt0; + double B3SOIvabjt; + double B3SOIaely; + double B3SOIvsdfb; + double B3SOIvsdth; + double B3SOIdelvt; +/* Added by binning - END0 */ + +/* Pre-calculated constants */ + + double B3SOIdw; + double B3SOIdl; + double B3SOIleff; + double B3SOIweff; + + double B3SOIdwc; + double B3SOIdlc; + double B3SOIleffCV; + double B3SOIweffCV; + double B3SOIabulkCVfactor; + double B3SOIcgso; + double B3SOIcgdo; + double B3SOIcgeo; + + double B3SOIu0temp; + double B3SOIvsattemp; + double B3SOIsqrtPhi; + double B3SOIphis3; + double B3SOIXdep0; + double B3SOIsqrtXdep0; + double B3SOItheta0vb0; + double B3SOIthetaRout; + + +/* v2.2 release */ + double B3SOIoxideRatio; + + +/* v2.0 release */ + double B3SOIk1eff; + double B3SOIwdios; + double B3SOIwdiod; + double B3SOIwdiodCV; + double B3SOIwdiosCV; + double B3SOIarfabjt; + double B3SOIlratio; + double B3SOIlratiodif; + double B3SOIvearly; + double B3SOIahli; + double B3SOIahli0; + double B3SOIvfbzb; + double B3SOIldeb; + double B3SOIacde; + double B3SOImoin; + double B3SOIleffCVb; + double B3SOIleffCVbg; + + double B3SOIcof1; + double B3SOIcof2; + double B3SOIcof3; + double B3SOIcof4; + double B3SOIcdep0; +/* v3.0 */ + double B3SOIToxRatio; + double B3SOIAechvb; + double B3SOIBechvb; + double B3SOIToxRatioEdge; + double B3SOIAechvbEdge; + double B3SOIBechvbEdge; + double B3SOIvfbsd; + + struct b3soiSizeDependParam *pNext; +}; + + +typedef struct sB3SOImodel +{ + int B3SOImodType; + struct sB3SOImodel *B3SOInextModel; + B3SOIinstance *B3SOIinstances; + IFuid B3SOImodName; + int B3SOItype; + + int B3SOImobMod; + int B3SOIcapMod; + int B3SOInoiMod; + int B3SOIshMod; + int B3SOIbinUnit; + int B3SOIparamChk; + double B3SOIversion; + double B3SOItox; + double B3SOIdtoxcv; /* v2.2.3 */ + double B3SOIcdsc; + double B3SOIcdscb; + double B3SOIcdscd; + double B3SOIcit; + double B3SOInfactor; + double B3SOIvsat; + double B3SOIat; + double B3SOIa0; + double B3SOIags; + double B3SOIa1; + double B3SOIa2; + double B3SOIketa; + double B3SOInsub; + double B3SOInpeak; + double B3SOIngate; + double B3SOIgamma1; + double B3SOIgamma2; + double B3SOIvbx; + double B3SOIvbm; + double B3SOIxt; + double B3SOIk1; + double B3SOIkt1; + double B3SOIkt1l; + double B3SOIkt2; + double B3SOIk2; + double B3SOIk3; + double B3SOIk3b; + double B3SOIw0; + double B3SOInlx; + double B3SOIdvt0; + double B3SOIdvt1; + double B3SOIdvt2; + double B3SOIdvt0w; + double B3SOIdvt1w; + double B3SOIdvt2w; + double B3SOIdrout; + double B3SOIdsub; + double B3SOIvth0; + double B3SOIua; + double B3SOIua1; + double B3SOIub; + double B3SOIub1; + double B3SOIuc; + double B3SOIuc1; + double B3SOIu0; + double B3SOIute; + double B3SOIvoff; + double B3SOIdelta; + double B3SOIrdsw; + double B3SOIprwg; + double B3SOIprwb; + double B3SOIprt; + double B3SOIeta0; + double B3SOIetab; + double B3SOIpclm; + double B3SOIpdibl1; + double B3SOIpdibl2; + double B3SOIpdiblb; + double B3SOIpvag; + double B3SOIwr; + double B3SOIdwg; + double B3SOIdwb; + double B3SOIb0; + double B3SOIb1; + double B3SOIalpha0; + double B3SOItbox; + double B3SOItsi; + double B3SOIxj; + double B3SOIkb1; + double B3SOIrth0; + double B3SOIcth0; + double B3SOIngidl; + double B3SOIagidl; + double B3SOIbgidl; + double B3SOIndiode; + double B3SOIistun; + double B3SOIxbjt; + double B3SOIxdif; + double B3SOIxrec; + double B3SOIxtun; + + +/* v3.0 */ + double B3SOIsoiMod; + double B3SOIvbsa; + double B3SOInofffd; + double B3SOIvofffd; + double B3SOIk1b; + double B3SOIk2b; + double B3SOIdk2b; + double B3SOIdvbd0; + double B3SOIdvbd1; + double B3SOImoinFD; + +/* v3.0 */ + int B3SOIigbMod; + int B3SOIigcMod; + double B3SOIaigc; + double B3SOIbigc; + double B3SOIcigc; + double B3SOIaigsd; + double B3SOIbigsd; + double B3SOIcigsd; + double B3SOInigc; + double B3SOIpigcd; + double B3SOIpoxedge; + double B3SOIdlcig; + +/* v2.2 release */ + double B3SOIwth0; + double B3SOIrhalo; + double B3SOIntox; + double B3SOItoxref; + double B3SOIebg; + double B3SOIvevb; + double B3SOIalphaGB1; + double B3SOIbetaGB1; + double B3SOIvgb1; + double B3SOIvecb; + double B3SOIalphaGB2; + double B3SOIbetaGB2; + double B3SOIvgb2; + double B3SOItoxqm; + double B3SOIvoxh; + double B3SOIdeltavox; + + +/* v2.0 release */ + double B3SOIk1w1; + double B3SOIk1w2; + double B3SOIketas; + double B3SOIdwbc; + double B3SOIbeta0; + double B3SOIbeta1; + double B3SOIbeta2; + double B3SOIvdsatii0; + double B3SOItii; + double B3SOIlii; + double B3SOIsii0; + double B3SOIsii1; + double B3SOIsii2; + double B3SOIsiid; + double B3SOIfbjtii; + double B3SOIesatii; + double B3SOIntun; + double B3SOInrecf0; + double B3SOInrecr0; + double B3SOIisbjt; + double B3SOIisdif; + double B3SOIisrec; + double B3SOIln; + double B3SOIvrec0; + double B3SOIvtun0; + double B3SOInbjt; + double B3SOIlbjt0; + double B3SOIldif0; + double B3SOIvabjt; + double B3SOIaely; + double B3SOIahli; + double B3SOIrbody; + double B3SOIrbsh; + double B3SOItt; + double B3SOIndif; + double B3SOIvsdfb; + double B3SOIvsdth; + double B3SOIcsdmin; + double B3SOIasd; + double B3SOIntrecf; + double B3SOIntrecr; + double B3SOIdlcb; + double B3SOIfbody; + double B3SOItcjswg; + double B3SOItpbswg; + double B3SOIacde; + double B3SOImoin; + double B3SOIdelvt; + double B3SOIdlbg; + + /* CV model */ + double B3SOIcgsl; + double B3SOIcgdl; + double B3SOIckappa; + double B3SOIcf; + double B3SOIclc; + double B3SOIcle; + double B3SOIdwc; + double B3SOIdlc; + + double B3SOItnom; + double B3SOIcgso; + double B3SOIcgdo; + double B3SOIcgeo; + double B3SOIxpart; + double B3SOIcFringOut; + double B3SOIcFringMax; + + double B3SOIsheetResistance; + double B3SOIbodyJctGateSideGradingCoeff; + double B3SOIGatesidewallJctPotential; + double B3SOIunitLengthGateSidewallJctCap; + double B3SOIcsdesw; + + double B3SOILint; + double B3SOILl; + double B3SOILlc; /* v2.2.3 */ + double B3SOILln; + double B3SOILw; + double B3SOILwc; /* v2.2.3 */ + double B3SOILwn; + double B3SOILwl; + double B3SOILwlc; /* v2.2.3 */ + double B3SOILmin; + double B3SOILmax; + + double B3SOIWint; + double B3SOIWl; + double B3SOIWlc; /* v2.2.3 */ + double B3SOIWln; + double B3SOIWw; + double B3SOIWwc; /* v2.2.3 */ + double B3SOIWwn; + double B3SOIWwl; + double B3SOIWwlc; /* v2.2.3 */ + double B3SOIWmin; + double B3SOIWmax; + +/* Added for binning - START1 */ + /* Length Dependence */ +/* v3.0 */ + double B3SOIlaigc; + double B3SOIlbigc; + double B3SOIlcigc; + double B3SOIlaigsd; + double B3SOIlbigsd; + double B3SOIlcigsd; + double B3SOIlnigc; + double B3SOIlpigcd; + double B3SOIlpoxedge; + + double B3SOIlnpeak; + double B3SOIlnsub; + double B3SOIlngate; + double B3SOIlvth0; + double B3SOIlk1; + double B3SOIlk1w1; + double B3SOIlk1w2; + double B3SOIlk2; + double B3SOIlk3; + double B3SOIlk3b; + double B3SOIlkb1; + double B3SOIlw0; + double B3SOIlnlx; + double B3SOIldvt0; + double B3SOIldvt1; + double B3SOIldvt2; + double B3SOIldvt0w; + double B3SOIldvt1w; + double B3SOIldvt2w; + double B3SOIlu0; + double B3SOIlua; + double B3SOIlub; + double B3SOIluc; + double B3SOIlvsat; + double B3SOIla0; + double B3SOIlags; + double B3SOIlb0; + double B3SOIlb1; + double B3SOIlketa; + double B3SOIlketas; + double B3SOIla1; + double B3SOIla2; + double B3SOIlrdsw; + double B3SOIlprwb; + double B3SOIlprwg; + double B3SOIlwr; + double B3SOIlnfactor; + double B3SOIldwg; + double B3SOIldwb; + double B3SOIlvoff; + double B3SOIleta0; + double B3SOIletab; + double B3SOIldsub; + double B3SOIlcit; + double B3SOIlcdsc; + double B3SOIlcdscb; + double B3SOIlcdscd; + double B3SOIlpclm; + double B3SOIlpdibl1; + double B3SOIlpdibl2; + double B3SOIlpdiblb; + double B3SOIldrout; + double B3SOIlpvag; + double B3SOIldelta; + double B3SOIlalpha0; + double B3SOIlfbjtii; + double B3SOIlbeta0; + double B3SOIlbeta1; + double B3SOIlbeta2; + double B3SOIlvdsatii0; + double B3SOIllii; + double B3SOIlesatii; + double B3SOIlsii0; + double B3SOIlsii1; + double B3SOIlsii2; + double B3SOIlsiid; + double B3SOIlagidl; + double B3SOIlbgidl; + double B3SOIlngidl; + double B3SOIlntun; + double B3SOIlndiode; + double B3SOIlnrecf0; + double B3SOIlnrecr0; + double B3SOIlisbjt; + double B3SOIlisdif; + double B3SOIlisrec; + double B3SOIlistun; + double B3SOIlvrec0; + double B3SOIlvtun0; + double B3SOIlnbjt; + double B3SOIllbjt0; + double B3SOIlvabjt; + double B3SOIlaely; + double B3SOIlahli; + /* CV model */ + double B3SOIlvsdfb; + double B3SOIlvsdth; + double B3SOIldelvt; + double B3SOIlacde; + double B3SOIlmoin; + + /* Width Dependence */ +/* v3.0 */ + double B3SOIwaigc; + double B3SOIwbigc; + double B3SOIwcigc; + double B3SOIwaigsd; + double B3SOIwbigsd; + double B3SOIwcigsd; + double B3SOIwnigc; + double B3SOIwpigcd; + double B3SOIwpoxedge; + + double B3SOIwnpeak; + double B3SOIwnsub; + double B3SOIwngate; + double B3SOIwvth0; + double B3SOIwk1; + double B3SOIwk1w1; + double B3SOIwk1w2; + double B3SOIwk2; + double B3SOIwk3; + double B3SOIwk3b; + double B3SOIwkb1; + double B3SOIww0; + double B3SOIwnlx; + double B3SOIwdvt0; + double B3SOIwdvt1; + double B3SOIwdvt2; + double B3SOIwdvt0w; + double B3SOIwdvt1w; + double B3SOIwdvt2w; + double B3SOIwu0; + double B3SOIwua; + double B3SOIwub; + double B3SOIwuc; + double B3SOIwvsat; + double B3SOIwa0; + double B3SOIwags; + double B3SOIwb0; + double B3SOIwb1; + double B3SOIwketa; + double B3SOIwketas; + double B3SOIwa1; + double B3SOIwa2; + double B3SOIwrdsw; + double B3SOIwprwb; + double B3SOIwprwg; + double B3SOIwwr; + double B3SOIwnfactor; + double B3SOIwdwg; + double B3SOIwdwb; + double B3SOIwvoff; + double B3SOIweta0; + double B3SOIwetab; + double B3SOIwdsub; + double B3SOIwcit; + double B3SOIwcdsc; + double B3SOIwcdscb; + double B3SOIwcdscd; + double B3SOIwpclm; + double B3SOIwpdibl1; + double B3SOIwpdibl2; + double B3SOIwpdiblb; + double B3SOIwdrout; + double B3SOIwpvag; + double B3SOIwdelta; + double B3SOIwalpha0; + double B3SOIwfbjtii; + double B3SOIwbeta0; + double B3SOIwbeta1; + double B3SOIwbeta2; + double B3SOIwvdsatii0; + double B3SOIwlii; + double B3SOIwesatii; + double B3SOIwsii0; + double B3SOIwsii1; + double B3SOIwsii2; + double B3SOIwsiid; + double B3SOIwagidl; + double B3SOIwbgidl; + double B3SOIwngidl; + double B3SOIwntun; + double B3SOIwndiode; + double B3SOIwnrecf0; + double B3SOIwnrecr0; + double B3SOIwisbjt; + double B3SOIwisdif; + double B3SOIwisrec; + double B3SOIwistun; + double B3SOIwvrec0; + double B3SOIwvtun0; + double B3SOIwnbjt; + double B3SOIwlbjt0; + double B3SOIwvabjt; + double B3SOIwaely; + double B3SOIwahli; + /* CV model */ + double B3SOIwvsdfb; + double B3SOIwvsdth; + double B3SOIwdelvt; + double B3SOIwacde; + double B3SOIwmoin; + + /* Cross-term Dependence */ +/* v3.0 */ + double B3SOIpaigc; + double B3SOIpbigc; + double B3SOIpcigc; + double B3SOIpaigsd; + double B3SOIpbigsd; + double B3SOIpcigsd; + double B3SOIpnigc; + double B3SOIppigcd; + double B3SOIppoxedge; + + double B3SOIpnpeak; + double B3SOIpnsub; + double B3SOIpngate; + double B3SOIpvth0; + double B3SOIpk1; + double B3SOIpk1w1; + double B3SOIpk1w2; + double B3SOIpk2; + double B3SOIpk3; + double B3SOIpk3b; + double B3SOIpkb1; + double B3SOIpw0; + double B3SOIpnlx; + double B3SOIpdvt0; + double B3SOIpdvt1; + double B3SOIpdvt2; + double B3SOIpdvt0w; + double B3SOIpdvt1w; + double B3SOIpdvt2w; + double B3SOIpu0; + double B3SOIpua; + double B3SOIpub; + double B3SOIpuc; + double B3SOIpvsat; + double B3SOIpa0; + double B3SOIpags; + double B3SOIpb0; + double B3SOIpb1; + double B3SOIpketa; + double B3SOIpketas; + double B3SOIpa1; + double B3SOIpa2; + double B3SOIprdsw; + double B3SOIpprwb; + double B3SOIpprwg; + double B3SOIpwr; + double B3SOIpnfactor; + double B3SOIpdwg; + double B3SOIpdwb; + double B3SOIpvoff; + double B3SOIpeta0; + double B3SOIpetab; + double B3SOIpdsub; + double B3SOIpcit; + double B3SOIpcdsc; + double B3SOIpcdscb; + double B3SOIpcdscd; + double B3SOIppclm; + double B3SOIppdibl1; + double B3SOIppdibl2; + double B3SOIppdiblb; + double B3SOIpdrout; + double B3SOIppvag; + double B3SOIpdelta; + double B3SOIpalpha0; + double B3SOIpfbjtii; + double B3SOIpbeta0; + double B3SOIpbeta1; + double B3SOIpbeta2; + double B3SOIpvdsatii0; + double B3SOIplii; + double B3SOIpesatii; + double B3SOIpsii0; + double B3SOIpsii1; + double B3SOIpsii2; + double B3SOIpsiid; + double B3SOIpagidl; + double B3SOIpbgidl; + double B3SOIpngidl; + double B3SOIpntun; + double B3SOIpndiode; + double B3SOIpnrecf0; + double B3SOIpnrecr0; + double B3SOIpisbjt; + double B3SOIpisdif; + double B3SOIpisrec; + double B3SOIpistun; + double B3SOIpvrec0; + double B3SOIpvtun0; + double B3SOIpnbjt; + double B3SOIplbjt0; + double B3SOIpvabjt; + double B3SOIpaely; + double B3SOIpahli; + /* CV model */ + double B3SOIpvsdfb; + double B3SOIpvsdth; + double B3SOIpdelvt; + double B3SOIpacde; + double B3SOIpmoin; +/* Added for binning - END1 */ + +/* Pre-calculated constants */ + double B3SOIcbox; + double B3SOIcsi; + double B3SOIcsieff; + double B3SOIcoxt; + double B3SOInfb; + double B3SOIadice; + double B3SOIqsi; + double B3SOIqsieff; + double B3SOIeg0; + + /* MCJ: move to size-dependent param. */ + double B3SOIvtm; + double B3SOIcox; + double B3SOIcof1; + double B3SOIcof2; + double B3SOIcof3; + double B3SOIcof4; + double B3SOIvcrit; + double B3SOIfactor1; + + double B3SOIoxideTrapDensityA; + double B3SOIoxideTrapDensityB; + double B3SOIoxideTrapDensityC; + double B3SOIem; + double B3SOIef; + double B3SOIaf; + double B3SOIkf; + double B3SOInoif; + + struct b3soiSizeDependParam *pSizeDependParamKnot; + + /* Flags */ + +/* v3.0 */ + unsigned B3SOIsoimodGiven: 1; + unsigned B3SOIvbsaGiven : 1; + unsigned B3SOInofffdGiven: 1; + unsigned B3SOIvofffdGiven: 1; + unsigned B3SOIk1bGiven: 1; + unsigned B3SOIk2bGiven: 1; + unsigned B3SOIdk2bGiven: 1; + unsigned B3SOIdvbd0Given: 1; + unsigned B3SOIdvbd1Given: 1; + unsigned B3SOImoinFDGiven: 1; + + + unsigned B3SOItboxGiven:1; + unsigned B3SOItsiGiven :1; + unsigned B3SOIxjGiven :1; + unsigned B3SOIkb1Given :1; + unsigned B3SOIrth0Given :1; + unsigned B3SOIcth0Given :1; + unsigned B3SOIngidlGiven :1; + unsigned B3SOIagidlGiven :1; + unsigned B3SOIbgidlGiven :1; + unsigned B3SOIndiodeGiven :1; + unsigned B3SOIxbjtGiven :1; + unsigned B3SOIxdifGiven :1; + unsigned B3SOIxrecGiven :1; + unsigned B3SOIxtunGiven :1; + unsigned B3SOIttGiven :1; + unsigned B3SOIvsdfbGiven :1; + unsigned B3SOIvsdthGiven :1; + unsigned B3SOIasdGiven :1; + unsigned B3SOIcsdminGiven :1; + + unsigned B3SOImobModGiven :1; + unsigned B3SOIbinUnitGiven :1; + unsigned B3SOIcapModGiven :1; + unsigned B3SOIparamChkGiven :1; + unsigned B3SOInoiModGiven :1; + unsigned B3SOIshModGiven :1; + unsigned B3SOItypeGiven :1; + unsigned B3SOItoxGiven :1; + unsigned B3SOIdtoxcvGiven :1; /* v2.2.3 */ + unsigned B3SOIversionGiven :1; + + unsigned B3SOIcdscGiven :1; + unsigned B3SOIcdscbGiven :1; + unsigned B3SOIcdscdGiven :1; + unsigned B3SOIcitGiven :1; + unsigned B3SOInfactorGiven :1; + unsigned B3SOIvsatGiven :1; + unsigned B3SOIatGiven :1; + unsigned B3SOIa0Given :1; + unsigned B3SOIagsGiven :1; + unsigned B3SOIa1Given :1; + unsigned B3SOIa2Given :1; + unsigned B3SOIketaGiven :1; + unsigned B3SOInsubGiven :1; + unsigned B3SOInpeakGiven :1; + unsigned B3SOIngateGiven :1; + unsigned B3SOIgamma1Given :1; + unsigned B3SOIgamma2Given :1; + unsigned B3SOIvbxGiven :1; + unsigned B3SOIvbmGiven :1; + unsigned B3SOIxtGiven :1; + unsigned B3SOIk1Given :1; + unsigned B3SOIkt1Given :1; + unsigned B3SOIkt1lGiven :1; + unsigned B3SOIkt2Given :1; + unsigned B3SOIk2Given :1; + unsigned B3SOIk3Given :1; + unsigned B3SOIk3bGiven :1; + unsigned B3SOIw0Given :1; + unsigned B3SOInlxGiven :1; + unsigned B3SOIdvt0Given :1; + unsigned B3SOIdvt1Given :1; + unsigned B3SOIdvt2Given :1; + unsigned B3SOIdvt0wGiven :1; + unsigned B3SOIdvt1wGiven :1; + unsigned B3SOIdvt2wGiven :1; + unsigned B3SOIdroutGiven :1; + unsigned B3SOIdsubGiven :1; + unsigned B3SOIvth0Given :1; + unsigned B3SOIuaGiven :1; + unsigned B3SOIua1Given :1; + unsigned B3SOIubGiven :1; + unsigned B3SOIub1Given :1; + unsigned B3SOIucGiven :1; + unsigned B3SOIuc1Given :1; + unsigned B3SOIu0Given :1; + unsigned B3SOIuteGiven :1; + unsigned B3SOIvoffGiven :1; + unsigned B3SOIrdswGiven :1; + unsigned B3SOIprwgGiven :1; + unsigned B3SOIprwbGiven :1; + unsigned B3SOIprtGiven :1; + unsigned B3SOIeta0Given :1; + unsigned B3SOIetabGiven :1; + unsigned B3SOIpclmGiven :1; + unsigned B3SOIpdibl1Given :1; + unsigned B3SOIpdibl2Given :1; + unsigned B3SOIpdiblbGiven :1; + unsigned B3SOIpvagGiven :1; + unsigned B3SOIdeltaGiven :1; + unsigned B3SOIwrGiven :1; + unsigned B3SOIdwgGiven :1; + unsigned B3SOIdwbGiven :1; + unsigned B3SOIb0Given :1; + unsigned B3SOIb1Given :1; + unsigned B3SOIalpha0Given :1; + + +/* v2.2 release */ + unsigned B3SOIwth0Given :1; + unsigned B3SOIrhaloGiven :1; + unsigned B3SOIntoxGiven :1; + unsigned B3SOItoxrefGiven :1; + unsigned B3SOIebgGiven :1; + unsigned B3SOIvevbGiven :1; + unsigned B3SOIalphaGB1Given :1; + unsigned B3SOIbetaGB1Given :1; + unsigned B3SOIvgb1Given :1; + unsigned B3SOIvecbGiven :1; + unsigned B3SOIalphaGB2Given :1; + unsigned B3SOIbetaGB2Given :1; + unsigned B3SOIvgb2Given :1; + unsigned B3SOItoxqmGiven :1; + unsigned B3SOIigbModGiven :1; /* v3.0 */ + unsigned B3SOIvoxhGiven :1; + unsigned B3SOIdeltavoxGiven :1; + unsigned B3SOIigcModGiven :1; /* v3.0 */ +/* v3.0 */ + unsigned B3SOIaigcGiven :1; + unsigned B3SOIbigcGiven :1; + unsigned B3SOIcigcGiven :1; + unsigned B3SOIaigsdGiven :1; + unsigned B3SOIbigsdGiven :1; + unsigned B3SOIcigsdGiven :1; + unsigned B3SOInigcGiven :1; + unsigned B3SOIpigcdGiven :1; + unsigned B3SOIpoxedgeGiven :1; + unsigned B3SOIdlcigGiven :1; + + +/* v2.0 release */ + unsigned B3SOIk1w1Given :1; + unsigned B3SOIk1w2Given :1; + unsigned B3SOIketasGiven :1; + unsigned B3SOIdwbcGiven :1; + unsigned B3SOIbeta0Given :1; + unsigned B3SOIbeta1Given :1; + unsigned B3SOIbeta2Given :1; + unsigned B3SOIvdsatii0Given :1; + unsigned B3SOItiiGiven :1; + unsigned B3SOIliiGiven :1; + unsigned B3SOIsii0Given :1; + unsigned B3SOIsii1Given :1; + unsigned B3SOIsii2Given :1; + unsigned B3SOIsiidGiven :1; + unsigned B3SOIfbjtiiGiven :1; + unsigned B3SOIesatiiGiven :1; + unsigned B3SOIntunGiven :1; + unsigned B3SOInrecf0Given :1; + unsigned B3SOInrecr0Given :1; + unsigned B3SOIisbjtGiven :1; + unsigned B3SOIisdifGiven :1; + unsigned B3SOIisrecGiven :1; + unsigned B3SOIistunGiven :1; + unsigned B3SOIlnGiven :1; + unsigned B3SOIvrec0Given :1; + unsigned B3SOIvtun0Given :1; + unsigned B3SOInbjtGiven :1; + unsigned B3SOIlbjt0Given :1; + unsigned B3SOIldif0Given :1; + unsigned B3SOIvabjtGiven :1; + unsigned B3SOIaelyGiven :1; + unsigned B3SOIahliGiven :1; + unsigned B3SOIrbodyGiven :1; + unsigned B3SOIrbshGiven :1; + unsigned B3SOIndifGiven :1; + unsigned B3SOIntrecfGiven :1; + unsigned B3SOIntrecrGiven :1; + unsigned B3SOIdlcbGiven :1; + unsigned B3SOIfbodyGiven :1; + unsigned B3SOItcjswgGiven :1; + unsigned B3SOItpbswgGiven :1; + unsigned B3SOIacdeGiven :1; + unsigned B3SOImoinGiven :1; + unsigned B3SOIdelvtGiven :1; + unsigned B3SOIdlbgGiven :1; + + + /* CV model */ + unsigned B3SOIcgslGiven :1; + unsigned B3SOIcgdlGiven :1; + unsigned B3SOIckappaGiven :1; + unsigned B3SOIcfGiven :1; + unsigned B3SOIclcGiven :1; + unsigned B3SOIcleGiven :1; + unsigned B3SOIdwcGiven :1; + unsigned B3SOIdlcGiven :1; + +/* Added for binning - START2 */ + /* Length Dependence */ +/* v3.0 */ + unsigned B3SOIlaigcGiven :1; + unsigned B3SOIlbigcGiven :1; + unsigned B3SOIlcigcGiven :1; + unsigned B3SOIlaigsdGiven :1; + unsigned B3SOIlbigsdGiven :1; + unsigned B3SOIlcigsdGiven :1; + unsigned B3SOIlnigcGiven :1; + unsigned B3SOIlpigcdGiven :1; + unsigned B3SOIlpoxedgeGiven :1; + + unsigned B3SOIlnpeakGiven :1; + unsigned B3SOIlnsubGiven :1; + unsigned B3SOIlngateGiven :1; + unsigned B3SOIlvth0Given :1; + unsigned B3SOIlk1Given :1; + unsigned B3SOIlk1w1Given :1; + unsigned B3SOIlk1w2Given :1; + unsigned B3SOIlk2Given :1; + unsigned B3SOIlk3Given :1; + unsigned B3SOIlk3bGiven :1; + unsigned B3SOIlkb1Given :1; + unsigned B3SOIlw0Given :1; + unsigned B3SOIlnlxGiven :1; + unsigned B3SOIldvt0Given :1; + unsigned B3SOIldvt1Given :1; + unsigned B3SOIldvt2Given :1; + unsigned B3SOIldvt0wGiven :1; + unsigned B3SOIldvt1wGiven :1; + unsigned B3SOIldvt2wGiven :1; + unsigned B3SOIlu0Given :1; + unsigned B3SOIluaGiven :1; + unsigned B3SOIlubGiven :1; + unsigned B3SOIlucGiven :1; + unsigned B3SOIlvsatGiven :1; + unsigned B3SOIla0Given :1; + unsigned B3SOIlagsGiven :1; + unsigned B3SOIlb0Given :1; + unsigned B3SOIlb1Given :1; + unsigned B3SOIlketaGiven :1; + unsigned B3SOIlketasGiven :1; + unsigned B3SOIla1Given :1; + unsigned B3SOIla2Given :1; + unsigned B3SOIlrdswGiven :1; + unsigned B3SOIlprwbGiven :1; + unsigned B3SOIlprwgGiven :1; + unsigned B3SOIlwrGiven :1; + unsigned B3SOIlnfactorGiven :1; + unsigned B3SOIldwgGiven :1; + unsigned B3SOIldwbGiven :1; + unsigned B3SOIlvoffGiven :1; + unsigned B3SOIleta0Given :1; + unsigned B3SOIletabGiven :1; + unsigned B3SOIldsubGiven :1; + unsigned B3SOIlcitGiven :1; + unsigned B3SOIlcdscGiven :1; + unsigned B3SOIlcdscbGiven :1; + unsigned B3SOIlcdscdGiven :1; + unsigned B3SOIlpclmGiven :1; + unsigned B3SOIlpdibl1Given :1; + unsigned B3SOIlpdibl2Given :1; + unsigned B3SOIlpdiblbGiven :1; + unsigned B3SOIldroutGiven :1; + unsigned B3SOIlpvagGiven :1; + unsigned B3SOIldeltaGiven :1; + unsigned B3SOIlalpha0Given :1; + unsigned B3SOIlfbjtiiGiven :1; + unsigned B3SOIlbeta0Given :1; + unsigned B3SOIlbeta1Given :1; + unsigned B3SOIlbeta2Given :1; + unsigned B3SOIlvdsatii0Given :1; + unsigned B3SOIlliiGiven :1; + unsigned B3SOIlesatiiGiven :1; + unsigned B3SOIlsii0Given :1; + unsigned B3SOIlsii1Given :1; + unsigned B3SOIlsii2Given :1; + unsigned B3SOIlsiidGiven :1; + unsigned B3SOIlagidlGiven :1; + unsigned B3SOIlbgidlGiven :1; + unsigned B3SOIlngidlGiven :1; + unsigned B3SOIlntunGiven :1; + unsigned B3SOIlndiodeGiven :1; + unsigned B3SOIlnrecf0Given :1; + unsigned B3SOIlnrecr0Given :1; + unsigned B3SOIlisbjtGiven :1; + unsigned B3SOIlisdifGiven :1; + unsigned B3SOIlisrecGiven :1; + unsigned B3SOIlistunGiven :1; + unsigned B3SOIlvrec0Given :1; + unsigned B3SOIlvtun0Given :1; + unsigned B3SOIlnbjtGiven :1; + unsigned B3SOIllbjt0Given :1; + unsigned B3SOIlvabjtGiven :1; + unsigned B3SOIlaelyGiven :1; + unsigned B3SOIlahliGiven :1; + /* CV model */ + unsigned B3SOIlvsdfbGiven :1; + unsigned B3SOIlvsdthGiven :1; + unsigned B3SOIldelvtGiven :1; + unsigned B3SOIlacdeGiven :1; + unsigned B3SOIlmoinGiven :1; + + /* Width Dependence */ +/* v3.0 */ + unsigned B3SOIwaigcGiven :1; + unsigned B3SOIwbigcGiven :1; + unsigned B3SOIwcigcGiven :1; + unsigned B3SOIwaigsdGiven :1; + unsigned B3SOIwbigsdGiven :1; + unsigned B3SOIwcigsdGiven :1; + unsigned B3SOIwnigcGiven :1; + unsigned B3SOIwpigcdGiven :1; + unsigned B3SOIwpoxedgeGiven :1; + + unsigned B3SOIwnpeakGiven :1; + unsigned B3SOIwnsubGiven :1; + unsigned B3SOIwngateGiven :1; + unsigned B3SOIwvth0Given :1; + unsigned B3SOIwk1Given :1; + unsigned B3SOIwk1w1Given :1; + unsigned B3SOIwk1w2Given :1; + unsigned B3SOIwk2Given :1; + unsigned B3SOIwk3Given :1; + unsigned B3SOIwk3bGiven :1; + unsigned B3SOIwkb1Given :1; + unsigned B3SOIww0Given :1; + unsigned B3SOIwnlxGiven :1; + unsigned B3SOIwdvt0Given :1; + unsigned B3SOIwdvt1Given :1; + unsigned B3SOIwdvt2Given :1; + unsigned B3SOIwdvt0wGiven :1; + unsigned B3SOIwdvt1wGiven :1; + unsigned B3SOIwdvt2wGiven :1; + unsigned B3SOIwu0Given :1; + unsigned B3SOIwuaGiven :1; + unsigned B3SOIwubGiven :1; + unsigned B3SOIwucGiven :1; + unsigned B3SOIwvsatGiven :1; + unsigned B3SOIwa0Given :1; + unsigned B3SOIwagsGiven :1; + unsigned B3SOIwb0Given :1; + unsigned B3SOIwb1Given :1; + unsigned B3SOIwketaGiven :1; + unsigned B3SOIwketasGiven :1; + unsigned B3SOIwa1Given :1; + unsigned B3SOIwa2Given :1; + unsigned B3SOIwrdswGiven :1; + unsigned B3SOIwprwbGiven :1; + unsigned B3SOIwprwgGiven :1; + unsigned B3SOIwwrGiven :1; + unsigned B3SOIwnfactorGiven :1; + unsigned B3SOIwdwgGiven :1; + unsigned B3SOIwdwbGiven :1; + unsigned B3SOIwvoffGiven :1; + unsigned B3SOIweta0Given :1; + unsigned B3SOIwetabGiven :1; + unsigned B3SOIwdsubGiven :1; + unsigned B3SOIwcitGiven :1; + unsigned B3SOIwcdscGiven :1; + unsigned B3SOIwcdscbGiven :1; + unsigned B3SOIwcdscdGiven :1; + unsigned B3SOIwpclmGiven :1; + unsigned B3SOIwpdibl1Given :1; + unsigned B3SOIwpdibl2Given :1; + unsigned B3SOIwpdiblbGiven :1; + unsigned B3SOIwdroutGiven :1; + unsigned B3SOIwpvagGiven :1; + unsigned B3SOIwdeltaGiven :1; + unsigned B3SOIwalpha0Given :1; + unsigned B3SOIwfbjtiiGiven :1; + unsigned B3SOIwbeta0Given :1; + unsigned B3SOIwbeta1Given :1; + unsigned B3SOIwbeta2Given :1; + unsigned B3SOIwvdsatii0Given :1; + unsigned B3SOIwliiGiven :1; + unsigned B3SOIwesatiiGiven :1; + unsigned B3SOIwsii0Given :1; + unsigned B3SOIwsii1Given :1; + unsigned B3SOIwsii2Given :1; + unsigned B3SOIwsiidGiven :1; + unsigned B3SOIwagidlGiven :1; + unsigned B3SOIwbgidlGiven :1; + unsigned B3SOIwngidlGiven :1; + unsigned B3SOIwntunGiven :1; + unsigned B3SOIwndiodeGiven :1; + unsigned B3SOIwnrecf0Given :1; + unsigned B3SOIwnrecr0Given :1; + unsigned B3SOIwisbjtGiven :1; + unsigned B3SOIwisdifGiven :1; + unsigned B3SOIwisrecGiven :1; + unsigned B3SOIwistunGiven :1; + unsigned B3SOIwvrec0Given :1; + unsigned B3SOIwvtun0Given :1; + unsigned B3SOIwnbjtGiven :1; + unsigned B3SOIwlbjt0Given :1; + unsigned B3SOIwvabjtGiven :1; + unsigned B3SOIwaelyGiven :1; + unsigned B3SOIwahliGiven :1; + /* CV model */ + unsigned B3SOIwvsdfbGiven :1; + unsigned B3SOIwvsdthGiven :1; + unsigned B3SOIwdelvtGiven :1; + unsigned B3SOIwacdeGiven :1; + unsigned B3SOIwmoinGiven :1; + + /* Cross-term Dependence */ +/* v3.0 */ + unsigned B3SOIpaigcGiven :1; + unsigned B3SOIpbigcGiven :1; + unsigned B3SOIpcigcGiven :1; + unsigned B3SOIpaigsdGiven :1; + unsigned B3SOIpbigsdGiven :1; + unsigned B3SOIpcigsdGiven :1; + unsigned B3SOIpnigcGiven :1; + unsigned B3SOIppigcdGiven :1; + unsigned B3SOIppoxedgeGiven :1; + + unsigned B3SOIpnpeakGiven :1; + unsigned B3SOIpnsubGiven :1; + unsigned B3SOIpngateGiven :1; + unsigned B3SOIpvth0Given :1; + unsigned B3SOIpk1Given :1; + unsigned B3SOIpk1w1Given :1; + unsigned B3SOIpk1w2Given :1; + unsigned B3SOIpk2Given :1; + unsigned B3SOIpk3Given :1; + unsigned B3SOIpk3bGiven :1; + unsigned B3SOIpkb1Given :1; + unsigned B3SOIpw0Given :1; + unsigned B3SOIpnlxGiven :1; + unsigned B3SOIpdvt0Given :1; + unsigned B3SOIpdvt1Given :1; + unsigned B3SOIpdvt2Given :1; + unsigned B3SOIpdvt0wGiven :1; + unsigned B3SOIpdvt1wGiven :1; + unsigned B3SOIpdvt2wGiven :1; + unsigned B3SOIpu0Given :1; + unsigned B3SOIpuaGiven :1; + unsigned B3SOIpubGiven :1; + unsigned B3SOIpucGiven :1; + unsigned B3SOIpvsatGiven :1; + unsigned B3SOIpa0Given :1; + unsigned B3SOIpagsGiven :1; + unsigned B3SOIpb0Given :1; + unsigned B3SOIpb1Given :1; + unsigned B3SOIpketaGiven :1; + unsigned B3SOIpketasGiven :1; + unsigned B3SOIpa1Given :1; + unsigned B3SOIpa2Given :1; + unsigned B3SOIprdswGiven :1; + unsigned B3SOIpprwbGiven :1; + unsigned B3SOIpprwgGiven :1; + unsigned B3SOIpwrGiven :1; + unsigned B3SOIpnfactorGiven :1; + unsigned B3SOIpdwgGiven :1; + unsigned B3SOIpdwbGiven :1; + unsigned B3SOIpvoffGiven :1; + unsigned B3SOIpeta0Given :1; + unsigned B3SOIpetabGiven :1; + unsigned B3SOIpdsubGiven :1; + unsigned B3SOIpcitGiven :1; + unsigned B3SOIpcdscGiven :1; + unsigned B3SOIpcdscbGiven :1; + unsigned B3SOIpcdscdGiven :1; + unsigned B3SOIppclmGiven :1; + unsigned B3SOIppdibl1Given :1; + unsigned B3SOIppdibl2Given :1; + unsigned B3SOIppdiblbGiven :1; + unsigned B3SOIpdroutGiven :1; + unsigned B3SOIppvagGiven :1; + unsigned B3SOIpdeltaGiven :1; + unsigned B3SOIpalpha0Given :1; + unsigned B3SOIpfbjtiiGiven :1; + unsigned B3SOIpbeta0Given :1; + unsigned B3SOIpbeta1Given :1; + unsigned B3SOIpbeta2Given :1; + unsigned B3SOIpvdsatii0Given :1; + unsigned B3SOIpliiGiven :1; + unsigned B3SOIpesatiiGiven :1; + unsigned B3SOIpsii0Given :1; + unsigned B3SOIpsii1Given :1; + unsigned B3SOIpsii2Given :1; + unsigned B3SOIpsiidGiven :1; + unsigned B3SOIpagidlGiven :1; + unsigned B3SOIpbgidlGiven :1; + unsigned B3SOIpngidlGiven :1; + unsigned B3SOIpntunGiven :1; + unsigned B3SOIpndiodeGiven :1; + unsigned B3SOIpnrecf0Given :1; + unsigned B3SOIpnrecr0Given :1; + unsigned B3SOIpisbjtGiven :1; + unsigned B3SOIpisdifGiven :1; + unsigned B3SOIpisrecGiven :1; + unsigned B3SOIpistunGiven :1; + unsigned B3SOIpvrec0Given :1; + unsigned B3SOIpvtun0Given :1; + unsigned B3SOIpnbjtGiven :1; + unsigned B3SOIplbjt0Given :1; + unsigned B3SOIpvabjtGiven :1; + unsigned B3SOIpaelyGiven :1; + unsigned B3SOIpahliGiven :1; + /* CV model */ + unsigned B3SOIpvsdfbGiven :1; + unsigned B3SOIpvsdthGiven :1; + unsigned B3SOIpdelvtGiven :1; + unsigned B3SOIpacdeGiven :1; + unsigned B3SOIpmoinGiven :1; +/* Added for binning - END2 */ + + unsigned B3SOIuseFringeGiven :1; + + unsigned B3SOItnomGiven :1; + unsigned B3SOIcgsoGiven :1; + unsigned B3SOIcgdoGiven :1; + unsigned B3SOIcgeoGiven :1; + unsigned B3SOIxpartGiven :1; + unsigned B3SOIsheetResistanceGiven :1; + unsigned B3SOIGatesidewallJctPotentialGiven :1; + unsigned B3SOIbodyJctGateSideGradingCoeffGiven :1; + unsigned B3SOIunitLengthGateSidewallJctCapGiven :1; + unsigned B3SOIcsdeswGiven :1; + + unsigned B3SOIoxideTrapDensityAGiven :1; + unsigned B3SOIoxideTrapDensityBGiven :1; + unsigned B3SOIoxideTrapDensityCGiven :1; + unsigned B3SOIemGiven :1; + unsigned B3SOIefGiven :1; + unsigned B3SOIafGiven :1; + unsigned B3SOIkfGiven :1; + unsigned B3SOInoifGiven :1; + + unsigned B3SOILintGiven :1; + unsigned B3SOILlGiven :1; + unsigned B3SOILlcGiven :1; /* v2.2.3 */ + unsigned B3SOILlnGiven :1; + unsigned B3SOILwGiven :1; + unsigned B3SOILwcGiven :1; /* v2.2.3 */ + unsigned B3SOILwnGiven :1; + unsigned B3SOILwlGiven :1; + unsigned B3SOILwlcGiven :1; /* v2.2.3 */ + unsigned B3SOILminGiven :1; + unsigned B3SOILmaxGiven :1; + + unsigned B3SOIWintGiven :1; + unsigned B3SOIWlGiven :1; + unsigned B3SOIWlcGiven :1; /* v2.2.3 */ + unsigned B3SOIWlnGiven :1; + unsigned B3SOIWwGiven :1; + unsigned B3SOIWwcGiven :1; /* v2.2.3 */ + unsigned B3SOIWwnGiven :1; + unsigned B3SOIWwlGiven :1; + unsigned B3SOIWwlcGiven :1; /* v2.2.3 */ + unsigned B3SOIWminGiven :1; + unsigned B3SOIWmaxGiven :1; + +} B3SOImodel; + + +#ifndef NMOS +#define NMOS 1 +#define PMOS -1 +#endif /*NMOS*/ + + +/* device parameters */ +#define B3SOI_W 1 +#define B3SOI_L 2 +#define B3SOI_M 31 +#define B3SOI_AS 3 +#define B3SOI_AD 4 +#define B3SOI_PS 5 +#define B3SOI_PD 6 +#define B3SOI_NRS 7 +#define B3SOI_NRD 8 +#define B3SOI_OFF 9 +#define B3SOI_IC_VBS 10 +#define B3SOI_IC_VDS 11 +#define B3SOI_IC_VGS 12 +#define B3SOI_IC_VES 13 +#define B3SOI_IC_VPS 14 +#define B3SOI_BJTOFF 15 +#define B3SOI_RTH0 16 +#define B3SOI_CTH0 17 +#define B3SOI_NRB 18 +#define B3SOI_IC 19 +#define B3SOI_NQSMOD 20 +#define B3SOI_DEBUG 21 + +/* v2.0 release */ +#define B3SOI_NBC 22 +#define B3SOI_NSEG 23 +#define B3SOI_PDBCP 24 +#define B3SOI_PSBCP 25 +#define B3SOI_AGBCP 26 +#define B3SOI_AEBCP 27 +#define B3SOI_VBSUSR 28 +#define B3SOI_TNODEOUT 29 + +/* v2.2.2 */ +#define B3SOI_FRBODY 30 + + +/* model parameters */ +#define B3SOI_MOD_CAPMOD 101 +#define B3SOI_MOD_NQSMOD 102 +#define B3SOI_MOD_MOBMOD 103 +#define B3SOI_MOD_NOIMOD 104 +#define B3SOI_MOD_SHMOD 105 +#define B3SOI_MOD_DDMOD 106 + +#define B3SOI_MOD_TOX 107 + +#define B3SOI_MOD_CDSC 108 +#define B3SOI_MOD_CDSCB 109 +#define B3SOI_MOD_CIT 110 +#define B3SOI_MOD_NFACTOR 111 +#define B3SOI_MOD_XJ 112 +#define B3SOI_MOD_VSAT 113 +#define B3SOI_MOD_AT 114 +#define B3SOI_MOD_A0 115 +#define B3SOI_MOD_A1 116 +#define B3SOI_MOD_A2 117 +#define B3SOI_MOD_KETA 118 +#define B3SOI_MOD_NSUB 119 +#define B3SOI_MOD_NPEAK 120 +#define B3SOI_MOD_NGATE 121 +#define B3SOI_MOD_GAMMA1 122 +#define B3SOI_MOD_GAMMA2 123 +#define B3SOI_MOD_VBX 124 +#define B3SOI_MOD_BINUNIT 125 + +#define B3SOI_MOD_VBM 126 + +#define B3SOI_MOD_XT 127 +#define B3SOI_MOD_K1 129 +#define B3SOI_MOD_KT1 130 +#define B3SOI_MOD_KT1L 131 +#define B3SOI_MOD_K2 132 +#define B3SOI_MOD_KT2 133 +#define B3SOI_MOD_K3 134 +#define B3SOI_MOD_K3B 135 +#define B3SOI_MOD_W0 136 +#define B3SOI_MOD_NLX 137 + +#define B3SOI_MOD_DVT0 138 +#define B3SOI_MOD_DVT1 139 +#define B3SOI_MOD_DVT2 140 + +#define B3SOI_MOD_DVT0W 141 +#define B3SOI_MOD_DVT1W 142 +#define B3SOI_MOD_DVT2W 143 + +#define B3SOI_MOD_DROUT 144 +#define B3SOI_MOD_DSUB 145 +#define B3SOI_MOD_VTH0 146 +#define B3SOI_MOD_UA 147 +#define B3SOI_MOD_UA1 148 +#define B3SOI_MOD_UB 149 +#define B3SOI_MOD_UB1 150 +#define B3SOI_MOD_UC 151 +#define B3SOI_MOD_UC1 152 +#define B3SOI_MOD_U0 153 +#define B3SOI_MOD_UTE 154 +#define B3SOI_MOD_VOFF 155 +#define B3SOI_MOD_DELTA 156 +#define B3SOI_MOD_RDSW 157 +#define B3SOI_MOD_PRT 158 +#define B3SOI_MOD_LDD 159 +#define B3SOI_MOD_ETA 160 +#define B3SOI_MOD_ETA0 161 +#define B3SOI_MOD_ETAB 162 +#define B3SOI_MOD_PCLM 163 +#define B3SOI_MOD_PDIBL1 164 +#define B3SOI_MOD_PDIBL2 165 +#define B3SOI_MOD_PSCBE1 166 +#define B3SOI_MOD_PSCBE2 167 +#define B3SOI_MOD_PVAG 168 +#define B3SOI_MOD_WR 169 +#define B3SOI_MOD_DWG 170 +#define B3SOI_MOD_DWB 171 +#define B3SOI_MOD_B0 172 +#define B3SOI_MOD_B1 173 +#define B3SOI_MOD_ALPHA0 174 +#define B3SOI_MOD_PDIBLB 178 + +#define B3SOI_MOD_PRWG 179 +#define B3SOI_MOD_PRWB 180 + +#define B3SOI_MOD_CDSCD 181 +#define B3SOI_MOD_AGS 182 + +#define B3SOI_MOD_FRINGE 184 +#define B3SOI_MOD_CGSL 186 +#define B3SOI_MOD_CGDL 187 +#define B3SOI_MOD_CKAPPA 188 +#define B3SOI_MOD_CF 189 +#define B3SOI_MOD_CLC 190 +#define B3SOI_MOD_CLE 191 +#define B3SOI_MOD_PARAMCHK 192 +#define B3SOI_MOD_VERSION 193 + +#define B3SOI_MOD_TBOX 195 +#define B3SOI_MOD_TSI 196 +#define B3SOI_MOD_KB1 197 +#define B3SOI_MOD_KB3 198 +#define B3SOI_MOD_DELP 201 +#define B3SOI_MOD_RBODY 204 +#define B3SOI_MOD_ADICE0 205 +#define B3SOI_MOD_ABP 206 +#define B3SOI_MOD_MXC 207 +#define B3SOI_MOD_RTH0 208 +#define B3SOI_MOD_CTH0 209 +#define B3SOI_MOD_ALPHA1 214 +#define B3SOI_MOD_NGIDL 215 +#define B3SOI_MOD_AGIDL 216 +#define B3SOI_MOD_BGIDL 217 +#define B3SOI_MOD_NDIODE 218 +#define B3SOI_MOD_LDIOF 219 +#define B3SOI_MOD_LDIOR 220 +#define B3SOI_MOD_NTUN 221 +#define B3SOI_MOD_ISBJT 222 +#define B3SOI_MOD_ISDIF 223 +#define B3SOI_MOD_ISREC 224 +#define B3SOI_MOD_ISTUN 225 +#define B3SOI_MOD_XBJT 226 +#define B3SOI_MOD_XDIF 227 +#define B3SOI_MOD_XREC 228 +#define B3SOI_MOD_XTUN 229 +#define B3SOI_MOD_TT 232 +#define B3SOI_MOD_VSDTH 233 +#define B3SOI_MOD_VSDFB 234 +#define B3SOI_MOD_ASD 235 +#define B3SOI_MOD_CSDMIN 236 +#define B3SOI_MOD_RBSH 237 +#define B3SOI_MOD_ESATII 238 + + +/* v2.0 release */ +#define B3SOI_MOD_K1W1 239 +#define B3SOI_MOD_K1W2 240 +#define B3SOI_MOD_KETAS 241 +#define B3SOI_MOD_DWBC 242 +#define B3SOI_MOD_BETA0 243 +#define B3SOI_MOD_BETA1 244 +#define B3SOI_MOD_BETA2 245 +#define B3SOI_MOD_VDSATII0 246 +#define B3SOI_MOD_TII 247 +#define B3SOI_MOD_LII 248 +#define B3SOI_MOD_SII0 249 +#define B3SOI_MOD_SII1 250 +#define B3SOI_MOD_SII2 251 +#define B3SOI_MOD_SIID 252 +#define B3SOI_MOD_FBJTII 253 +#define B3SOI_MOD_NRECF0 255 +#define B3SOI_MOD_NRECR0 256 +#define B3SOI_MOD_LN 257 +#define B3SOI_MOD_VREC0 258 +#define B3SOI_MOD_VTUN0 259 +#define B3SOI_MOD_NBJT 260 +#define B3SOI_MOD_LBJT0 261 +#define B3SOI_MOD_VABJT 262 +#define B3SOI_MOD_AELY 263 +#define B3SOI_MOD_AHLI 264 +#define B3SOI_MOD_NTRECF 265 +#define B3SOI_MOD_NTRECR 266 +#define B3SOI_MOD_DLCB 267 +#define B3SOI_MOD_FBODY 268 +#define B3SOI_MOD_NDIF 269 +#define B3SOI_MOD_TCJSWG 270 +#define B3SOI_MOD_TPBSWG 271 +#define B3SOI_MOD_ACDE 272 +#define B3SOI_MOD_MOIN 273 +#define B3SOI_MOD_DELVT 274 +#define B3SOI_MOD_DLBG 275 +#define B3SOI_MOD_LDIF0 276 + + +/* v2.2 release */ +#define B3SOI_MOD_WTH0 277 +#define B3SOI_MOD_RHALO 278 +#define B3SOI_MOD_NTOX 279 +#define B3SOI_MOD_TOXREF 280 +#define B3SOI_MOD_EBG 281 +#define B3SOI_MOD_VEVB 282 +#define B3SOI_MOD_ALPHAGB1 283 +#define B3SOI_MOD_BETAGB1 284 +#define B3SOI_MOD_VGB1 285 +#define B3SOI_MOD_VECB 286 +#define B3SOI_MOD_ALPHAGB2 287 +#define B3SOI_MOD_BETAGB2 288 +#define B3SOI_MOD_VGB2 289 +#define B3SOI_MOD_TOXQM 290 +#define B3SOI_MOD_IGBMOD 291 /* v3.0 */ +#define B3SOI_MOD_VOXH 292 +#define B3SOI_MOD_DELTAVOX 293 +#define B3SOI_MOD_IGCMOD 294 /* v3.0 */ + + +/* Added for binning - START3 */ +/* Length dependence */ +#define B3SOI_MOD_LNPEAK 301 +#define B3SOI_MOD_LNSUB 302 +#define B3SOI_MOD_LNGATE 303 +#define B3SOI_MOD_LVTH0 304 +#define B3SOI_MOD_LK1 305 +#define B3SOI_MOD_LK1W1 306 +#define B3SOI_MOD_LK1W2 307 +#define B3SOI_MOD_LK2 308 +#define B3SOI_MOD_LK3 309 +#define B3SOI_MOD_LK3B 310 +#define B3SOI_MOD_LKB1 311 +#define B3SOI_MOD_LW0 312 +#define B3SOI_MOD_LNLX 313 +#define B3SOI_MOD_LDVT0 314 +#define B3SOI_MOD_LDVT1 315 +#define B3SOI_MOD_LDVT2 316 +#define B3SOI_MOD_LDVT0W 317 +#define B3SOI_MOD_LDVT1W 318 +#define B3SOI_MOD_LDVT2W 319 +#define B3SOI_MOD_LU0 320 +#define B3SOI_MOD_LUA 321 +#define B3SOI_MOD_LUB 322 +#define B3SOI_MOD_LUC 323 +#define B3SOI_MOD_LVSAT 324 +#define B3SOI_MOD_LA0 325 +#define B3SOI_MOD_LAGS 326 +#define B3SOI_MOD_LB0 327 +#define B3SOI_MOD_LB1 328 +#define B3SOI_MOD_LKETA 329 +#define B3SOI_MOD_LKETAS 330 +#define B3SOI_MOD_LA1 331 +#define B3SOI_MOD_LA2 332 +#define B3SOI_MOD_LRDSW 333 +#define B3SOI_MOD_LPRWB 334 +#define B3SOI_MOD_LPRWG 335 +#define B3SOI_MOD_LWR 336 +#define B3SOI_MOD_LNFACTOR 337 +#define B3SOI_MOD_LDWG 338 +#define B3SOI_MOD_LDWB 339 +#define B3SOI_MOD_LVOFF 340 +#define B3SOI_MOD_LETA0 341 +#define B3SOI_MOD_LETAB 342 +#define B3SOI_MOD_LDSUB 343 +#define B3SOI_MOD_LCIT 344 +#define B3SOI_MOD_LCDSC 345 +#define B3SOI_MOD_LCDSCB 346 +#define B3SOI_MOD_LCDSCD 347 +#define B3SOI_MOD_LPCLM 348 +#define B3SOI_MOD_LPDIBL1 349 +#define B3SOI_MOD_LPDIBL2 350 +#define B3SOI_MOD_LPDIBLB 351 +#define B3SOI_MOD_LDROUT 352 +#define B3SOI_MOD_LPVAG 353 +#define B3SOI_MOD_LDELTA 354 +#define B3SOI_MOD_LALPHA0 355 +#define B3SOI_MOD_LFBJTII 356 +#define B3SOI_MOD_LBETA0 357 +#define B3SOI_MOD_LBETA1 358 +#define B3SOI_MOD_LBETA2 359 +#define B3SOI_MOD_LVDSATII0 360 +#define B3SOI_MOD_LLII 361 +#define B3SOI_MOD_LESATII 362 +#define B3SOI_MOD_LSII0 363 +#define B3SOI_MOD_LSII1 364 +#define B3SOI_MOD_LSII2 365 +#define B3SOI_MOD_LSIID 366 +#define B3SOI_MOD_LAGIDL 367 +#define B3SOI_MOD_LBGIDL 368 +#define B3SOI_MOD_LNGIDL 369 +#define B3SOI_MOD_LNTUN 370 +#define B3SOI_MOD_LNDIODE 371 +#define B3SOI_MOD_LNRECF0 372 +#define B3SOI_MOD_LNRECR0 373 +#define B3SOI_MOD_LISBJT 374 +#define B3SOI_MOD_LISDIF 375 +#define B3SOI_MOD_LISREC 376 +#define B3SOI_MOD_LISTUN 377 +#define B3SOI_MOD_LVREC0 378 +#define B3SOI_MOD_LVTUN0 379 +#define B3SOI_MOD_LNBJT 380 +#define B3SOI_MOD_LLBJT0 381 +#define B3SOI_MOD_LVABJT 382 +#define B3SOI_MOD_LAELY 383 +#define B3SOI_MOD_LAHLI 384 +#define B3SOI_MOD_LVSDFB 385 +#define B3SOI_MOD_LVSDTH 386 +#define B3SOI_MOD_LDELVT 387 +#define B3SOI_MOD_LACDE 388 +#define B3SOI_MOD_LMOIN 389 + +/* Width dependence */ +#define B3SOI_MOD_WNPEAK 401 +#define B3SOI_MOD_WNSUB 402 +#define B3SOI_MOD_WNGATE 403 +#define B3SOI_MOD_WVTH0 404 +#define B3SOI_MOD_WK1 405 +#define B3SOI_MOD_WK1W1 406 +#define B3SOI_MOD_WK1W2 407 +#define B3SOI_MOD_WK2 408 +#define B3SOI_MOD_WK3 409 +#define B3SOI_MOD_WK3B 410 +#define B3SOI_MOD_WKB1 411 +#define B3SOI_MOD_WW0 412 +#define B3SOI_MOD_WNLX 413 +#define B3SOI_MOD_WDVT0 414 +#define B3SOI_MOD_WDVT1 415 +#define B3SOI_MOD_WDVT2 416 +#define B3SOI_MOD_WDVT0W 417 +#define B3SOI_MOD_WDVT1W 418 +#define B3SOI_MOD_WDVT2W 419 +#define B3SOI_MOD_WU0 420 +#define B3SOI_MOD_WUA 421 +#define B3SOI_MOD_WUB 422 +#define B3SOI_MOD_WUC 423 +#define B3SOI_MOD_WVSAT 424 +#define B3SOI_MOD_WA0 425 +#define B3SOI_MOD_WAGS 426 +#define B3SOI_MOD_WB0 427 +#define B3SOI_MOD_WB1 428 +#define B3SOI_MOD_WKETA 429 +#define B3SOI_MOD_WKETAS 430 +#define B3SOI_MOD_WA1 431 +#define B3SOI_MOD_WA2 432 +#define B3SOI_MOD_WRDSW 433 +#define B3SOI_MOD_WPRWB 434 +#define B3SOI_MOD_WPRWG 435 +#define B3SOI_MOD_WWR 436 +#define B3SOI_MOD_WNFACTOR 437 +#define B3SOI_MOD_WDWG 438 +#define B3SOI_MOD_WDWB 439 +#define B3SOI_MOD_WVOFF 440 +#define B3SOI_MOD_WETA0 441 +#define B3SOI_MOD_WETAB 442 +#define B3SOI_MOD_WDSUB 443 +#define B3SOI_MOD_WCIT 444 +#define B3SOI_MOD_WCDSC 445 +#define B3SOI_MOD_WCDSCB 446 +#define B3SOI_MOD_WCDSCD 447 +#define B3SOI_MOD_WPCLM 448 +#define B3SOI_MOD_WPDIBL1 449 +#define B3SOI_MOD_WPDIBL2 450 +#define B3SOI_MOD_WPDIBLB 451 +#define B3SOI_MOD_WDROUT 452 +#define B3SOI_MOD_WPVAG 453 +#define B3SOI_MOD_WDELTA 454 +#define B3SOI_MOD_WALPHA0 455 +#define B3SOI_MOD_WFBJTII 456 +#define B3SOI_MOD_WBETA0 457 +#define B3SOI_MOD_WBETA1 458 +#define B3SOI_MOD_WBETA2 459 +#define B3SOI_MOD_WVDSATII0 460 +#define B3SOI_MOD_WLII 461 +#define B3SOI_MOD_WESATII 462 +#define B3SOI_MOD_WSII0 463 +#define B3SOI_MOD_WSII1 464 +#define B3SOI_MOD_WSII2 465 +#define B3SOI_MOD_WSIID 466 +#define B3SOI_MOD_WAGIDL 467 +#define B3SOI_MOD_WBGIDL 468 +#define B3SOI_MOD_WNGIDL 469 +#define B3SOI_MOD_WNTUN 470 +#define B3SOI_MOD_WNDIODE 471 +#define B3SOI_MOD_WNRECF0 472 +#define B3SOI_MOD_WNRECR0 473 +#define B3SOI_MOD_WISBJT 474 +#define B3SOI_MOD_WISDIF 475 +#define B3SOI_MOD_WISREC 476 +#define B3SOI_MOD_WISTUN 477 +#define B3SOI_MOD_WVREC0 478 +#define B3SOI_MOD_WVTUN0 479 +#define B3SOI_MOD_WNBJT 480 +#define B3SOI_MOD_WLBJT0 481 +#define B3SOI_MOD_WVABJT 482 +#define B3SOI_MOD_WAELY 483 +#define B3SOI_MOD_WAHLI 484 +#define B3SOI_MOD_WVSDFB 485 +#define B3SOI_MOD_WVSDTH 486 +#define B3SOI_MOD_WDELVT 487 +#define B3SOI_MOD_WACDE 488 +#define B3SOI_MOD_WMOIN 489 + +/* Cross-term dependence */ +#define B3SOI_MOD_PNPEAK 501 +#define B3SOI_MOD_PNSUB 502 +#define B3SOI_MOD_PNGATE 503 +#define B3SOI_MOD_PVTH0 504 +#define B3SOI_MOD_PK1 505 +#define B3SOI_MOD_PK1W1 506 +#define B3SOI_MOD_PK1W2 507 +#define B3SOI_MOD_PK2 508 +#define B3SOI_MOD_PK3 509 +#define B3SOI_MOD_PK3B 510 +#define B3SOI_MOD_PKB1 511 +#define B3SOI_MOD_PW0 512 +#define B3SOI_MOD_PNLX 513 +#define B3SOI_MOD_PDVT0 514 +#define B3SOI_MOD_PDVT1 515 +#define B3SOI_MOD_PDVT2 516 +#define B3SOI_MOD_PDVT0W 517 +#define B3SOI_MOD_PDVT1W 518 +#define B3SOI_MOD_PDVT2W 519 +#define B3SOI_MOD_PU0 520 +#define B3SOI_MOD_PUA 521 +#define B3SOI_MOD_PUB 522 +#define B3SOI_MOD_PUC 523 +#define B3SOI_MOD_PVSAT 524 +#define B3SOI_MOD_PA0 525 +#define B3SOI_MOD_PAGS 526 +#define B3SOI_MOD_PB0 527 +#define B3SOI_MOD_PB1 528 +#define B3SOI_MOD_PKETA 529 +#define B3SOI_MOD_PKETAS 530 +#define B3SOI_MOD_PA1 531 +#define B3SOI_MOD_PA2 532 +#define B3SOI_MOD_PRDSW 533 +#define B3SOI_MOD_PPRWB 534 +#define B3SOI_MOD_PPRWG 535 +#define B3SOI_MOD_PWR 536 +#define B3SOI_MOD_PNFACTOR 537 +#define B3SOI_MOD_PDWG 538 +#define B3SOI_MOD_PDWB 539 +#define B3SOI_MOD_PVOFF 540 +#define B3SOI_MOD_PETA0 541 +#define B3SOI_MOD_PETAB 542 +#define B3SOI_MOD_PDSUB 543 +#define B3SOI_MOD_PCIT 544 +#define B3SOI_MOD_PCDSC 545 +#define B3SOI_MOD_PCDSCB 546 +#define B3SOI_MOD_PCDSCD 547 +#define B3SOI_MOD_PPCLM 548 +#define B3SOI_MOD_PPDIBL1 549 +#define B3SOI_MOD_PPDIBL2 550 +#define B3SOI_MOD_PPDIBLB 551 +#define B3SOI_MOD_PDROUT 552 +#define B3SOI_MOD_PPVAG 553 +#define B3SOI_MOD_PDELTA 554 +#define B3SOI_MOD_PALPHA0 555 +#define B3SOI_MOD_PFBJTII 556 +#define B3SOI_MOD_PBETA0 557 +#define B3SOI_MOD_PBETA1 558 +#define B3SOI_MOD_PBETA2 559 +#define B3SOI_MOD_PVDSATII0 560 +#define B3SOI_MOD_PLII 561 +#define B3SOI_MOD_PESATII 562 +#define B3SOI_MOD_PSII0 563 +#define B3SOI_MOD_PSII1 564 +#define B3SOI_MOD_PSII2 565 +#define B3SOI_MOD_PSIID 566 +#define B3SOI_MOD_PAGIDL 567 +#define B3SOI_MOD_PBGIDL 568 +#define B3SOI_MOD_PNGIDL 569 +#define B3SOI_MOD_PNTUN 570 +#define B3SOI_MOD_PNDIODE 571 +#define B3SOI_MOD_PNRECF0 572 +#define B3SOI_MOD_PNRECR0 573 +#define B3SOI_MOD_PISBJT 574 +#define B3SOI_MOD_PISDIF 575 +#define B3SOI_MOD_PISREC 576 +#define B3SOI_MOD_PISTUN 577 +#define B3SOI_MOD_PVREC0 578 +#define B3SOI_MOD_PVTUN0 579 +#define B3SOI_MOD_PNBJT 580 +#define B3SOI_MOD_PLBJT0 581 +#define B3SOI_MOD_PVABJT 582 +#define B3SOI_MOD_PAELY 583 +#define B3SOI_MOD_PAHLI 584 +#define B3SOI_MOD_PVSDFB 585 +#define B3SOI_MOD_PVSDTH 586 +#define B3SOI_MOD_PDELVT 587 +#define B3SOI_MOD_PACDE 588 +#define B3SOI_MOD_PMOIN 589 +/* Added for binning - END3 */ + +#define B3SOI_MOD_TNOM 701 +#define B3SOI_MOD_CGSO 702 +#define B3SOI_MOD_CGDO 703 +#define B3SOI_MOD_CGEO 704 +#define B3SOI_MOD_XPART 705 + +#define B3SOI_MOD_RSH 706 +#define B3SOI_MOD_NMOS 814 +#define B3SOI_MOD_PMOS 815 + +#define B3SOI_MOD_NOIA 816 +#define B3SOI_MOD_NOIB 817 +#define B3SOI_MOD_NOIC 818 + +#define B3SOI_MOD_LINT 819 +#define B3SOI_MOD_LL 820 +#define B3SOI_MOD_LLN 821 +#define B3SOI_MOD_LW 822 +#define B3SOI_MOD_LWN 823 +#define B3SOI_MOD_LWL 824 + +#define B3SOI_MOD_WINT 827 +#define B3SOI_MOD_WL 828 +#define B3SOI_MOD_WLN 829 +#define B3SOI_MOD_WW 830 +#define B3SOI_MOD_WWN 831 +#define B3SOI_MOD_WWL 832 + +/* v2.2.3 */ +#define B3SOI_MOD_LWLC 847 +#define B3SOI_MOD_LLC 848 +#define B3SOI_MOD_LWC 849 +#define B3SOI_MOD_WWLC 850 +#define B3SOI_MOD_WLC 851 +#define B3SOI_MOD_WWC 852 +#define B3SOI_MOD_DTOXCV 853 + +#define B3SOI_MOD_DWC 835 +#define B3SOI_MOD_DLC 836 + +#define B3SOI_MOD_EM 837 +#define B3SOI_MOD_EF 838 +#define B3SOI_MOD_AF 839 +#define B3SOI_MOD_KF 840 +#define B3SOI_MOD_NOIF 841 + + +#define B3SOI_MOD_PBSWG 843 +#define B3SOI_MOD_MJSWG 844 +#define B3SOI_MOD_CJSWG 845 +#define B3SOI_MOD_CSDESW 846 + +/* device questions */ +#define B3SOI_DNODE 901 +#define B3SOI_GNODE 902 +#define B3SOI_SNODE 903 +#define B3SOI_BNODE 904 +#define B3SOI_ENODE 905 +#define B3SOI_DNODEPRIME 906 +#define B3SOI_SNODEPRIME 907 +#define B3SOI_VBD 908 +#define B3SOI_VBS 909 +#define B3SOI_VGS 910 +#define B3SOI_VES 911 +#define B3SOI_VDS 912 +#define B3SOI_CD 913 +#define B3SOI_CBS 914 +#define B3SOI_CBD 915 +#define B3SOI_GM 916 +#define B3SOI_GDS 917 +#define B3SOI_GMBS 918 +#define B3SOI_GBD 919 +#define B3SOI_GBS 920 +#define B3SOI_QB 921 +#define B3SOI_CQB 922 +#define B3SOI_QG 923 +#define B3SOI_CQG 924 +#define B3SOI_QD 925 +#define B3SOI_CQD 926 +#define B3SOI_CGG 927 +#define B3SOI_CGD 928 +#define B3SOI_CGS 929 +#define B3SOI_CBG 930 +#define B3SOI_CAPBD 931 +#define B3SOI_CQBD 932 +#define B3SOI_CAPBS 933 +#define B3SOI_CQBS 934 +#define B3SOI_CDG 935 +#define B3SOI_CDD 936 +#define B3SOI_CDS 937 +#define B3SOI_VON 938 +#define B3SOI_VDSAT 939 +#define B3SOI_QBS 940 +#define B3SOI_QBD 941 +#define B3SOI_SOURCECONDUCT 942 +#define B3SOI_DRAINCONDUCT 943 +#define B3SOI_CBDB 944 +#define B3SOI_CBSB 945 +#define B3SOI_GMID 946 + +/* v3.0 */ +#define B3SOI_MOD_SOIMOD 1001 +#define B3SOI_MOD_VBSA 1002 +#define B3SOI_MOD_NOFFFD 1003 +#define B3SOI_MOD_VOFFFD 1004 +#define B3SOI_MOD_K1B 1005 +#define B3SOI_MOD_K2B 1006 +#define B3SOI_MOD_DK2B 1007 +#define B3SOI_MOD_DVBD0 1008 +#define B3SOI_MOD_DVBD1 1009 +#define B3SOI_MOD_MOINFD 1010 + +/* v3.0 */ +#define B3SOI_MOD_AIGC 1021 +#define B3SOI_MOD_BIGC 1022 +#define B3SOI_MOD_CIGC 1023 +#define B3SOI_MOD_AIGSD 1024 +#define B3SOI_MOD_BIGSD 1025 +#define B3SOI_MOD_CIGSD 1026 +#define B3SOI_MOD_NIGC 1027 +#define B3SOI_MOD_PIGCD 1028 +#define B3SOI_MOD_POXEDGE 1029 +#define B3SOI_MOD_DLCIG 1030 + +#define B3SOI_MOD_LAIGC 1031 +#define B3SOI_MOD_LBIGC 1032 +#define B3SOI_MOD_LCIGC 1033 +#define B3SOI_MOD_LAIGSD 1034 +#define B3SOI_MOD_LBIGSD 1035 +#define B3SOI_MOD_LCIGSD 1036 +#define B3SOI_MOD_LNIGC 1037 +#define B3SOI_MOD_LPIGCD 1038 +#define B3SOI_MOD_LPOXEDGE 1039 + +#define B3SOI_MOD_WAIGC 1041 +#define B3SOI_MOD_WBIGC 1042 +#define B3SOI_MOD_WCIGC 1043 +#define B3SOI_MOD_WAIGSD 1044 +#define B3SOI_MOD_WBIGSD 1045 +#define B3SOI_MOD_WCIGSD 1046 +#define B3SOI_MOD_WNIGC 1047 +#define B3SOI_MOD_WPIGCD 1048 +#define B3SOI_MOD_WPOXEDGE 1049 + +#define B3SOI_MOD_PAIGC 1051 +#define B3SOI_MOD_PBIGC 1052 +#define B3SOI_MOD_PCIGC 1053 +#define B3SOI_MOD_PAIGSD 1054 +#define B3SOI_MOD_PBIGSD 1055 +#define B3SOI_MOD_PCIGSD 1056 +#define B3SOI_MOD_PNIGC 1057 +#define B3SOI_MOD_PPIGCD 1058 +#define B3SOI_MOD_PPOXEDGE 1059 + + + +#include "b3soiext.h" + +extern void B3SOIevaluate(double,double,double,B3SOIinstance*,B3SOImodel*, + double*,double*,double*, double*, double*, double*, double*, + double*, double*, double*, double*, double*, double*, double*, + double*, double*, double*, double*, CKTcircuit*); +extern int B3SOIdebug(B3SOImodel*, B3SOIinstance*, CKTcircuit*, int); +extern int B3SOIcheckModel(B3SOImodel*, B3SOIinstance*, CKTcircuit*); + +#endif /*B3SOI*/ + diff --git a/src/spicelib/devices/bsim3soi/b3soidel.c b/src/spicelib/devices/bsim3soi/b3soidel.c new file mode 100644 index 000000000..c75e66df7 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soidel.c @@ -0,0 +1,38 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soidel.c 98/5/01 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "b3soidef.h" +#include "sperror.h" +#include "gendefs.h" +#include "suffix.h" + + +int +B3SOIdelete(GENmodel *inModel, IFuid name, GENinstance **inInst) +{ +B3SOIinstance **fast = (B3SOIinstance**)inInst; +B3SOImodel *model = (B3SOImodel*)inModel; +B3SOIinstance **prev = NULL; +B3SOIinstance *here; + + for (; model ; model = model->B3SOInextModel) + { prev = &(model->B3SOIinstances); + for (here = *prev; here ; here = *prev) + { if (here->B3SOIname == name || (fast && here==*fast)) + { *prev= here->B3SOInextInstance; + FREE(here); + return(OK); + } + prev = &(here->B3SOInextInstance); + } + } + return(E_NODEV); +} + + diff --git a/src/spicelib/devices/bsim3soi/b3soidest.c b/src/spicelib/devices/bsim3soi/b3soidest.c new file mode 100644 index 000000000..c6101976d --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soidest.c @@ -0,0 +1,38 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soidest.c 98/5/01 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "b3soidef.h" +#include "suffix.h" + +void +B3SOIdestroy(GENmodel **inModel) +{ +B3SOImodel **model = (B3SOImodel**)inModel; +B3SOIinstance *here; +B3SOIinstance *prev = NULL; +B3SOImodel *mod = *model; +B3SOImodel *oldmod = NULL; + + for (; mod ; mod = mod->B3SOInextModel) + { if(oldmod) FREE(oldmod); + oldmod = mod; + prev = (B3SOIinstance *)NULL; + for (here = mod->B3SOIinstances; here; here = here->B3SOInextInstance) + { if(prev) FREE(prev); + prev = here; + } + if(prev) FREE(prev); + } + if(oldmod) FREE(oldmod); + *model = NULL; + return; +} + + + diff --git a/src/spicelib/devices/bsim3soi/b3soiext.h b/src/spicelib/devices/bsim3soi/b3soiext.h new file mode 100644 index 000000000..3fc0fa13c --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soiext.h @@ -0,0 +1,30 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung +File: b3soiext.h +Modified by Paolo Nenzi 2002 +**********/ + +extern int B3SOIacLoad(GENmodel *,CKTcircuit*); +extern int B3SOIask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*); +extern int B3SOIconvTest(GENmodel *,CKTcircuit*); +extern int B3SOIdelete(GENmodel*,IFuid,GENinstance**); +extern void B3SOIdestroy(GENmodel**); +extern int B3SOIgetic(GENmodel*,CKTcircuit*); +extern int B3SOIload(GENmodel*,CKTcircuit*); +extern int B3SOImAsk(CKTcircuit*,GENmodel *,int, IFvalue*); +extern int B3SOImDelete(GENmodel**,IFuid,GENmodel*); +extern int B3SOImParam(int,IFvalue*,GENmodel*); +extern void B3SOImosCap(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 B3SOIparam(int,IFvalue*,GENinstance*,IFvalue*); +extern int B3SOIpzLoad(GENmodel*,CKTcircuit*,SPcomplex*); +extern int B3SOIsetup(SMPmatrix*,GENmodel*,CKTcircuit*,int*); +extern int B3SOItemp(GENmodel*,CKTcircuit*); +extern int B3SOItrunc(GENmodel*,CKTcircuit*,double*); +extern int B3SOInoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*); +extern int B3SOIunsetup(GENmodel*,CKTcircuit*); diff --git a/src/spicelib/devices/bsim3soi/b3soigetic.c b/src/spicelib/devices/bsim3soi/b3soigetic.c new file mode 100644 index 000000000..a8d9dbb71 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soigetic.c @@ -0,0 +1,54 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soigetic.c 98/5/01 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "cktdefs.h" +#include "b3soidef.h" +#include "sperror.h" +#include "suffix.h" + + +int +B3SOIgetic(GENmodel *inModel, CKTcircuit *ckt) +{ +B3SOImodel *model = (B3SOImodel*)inModel; +B3SOIinstance *here; + + for (; model ; model = model->B3SOInextModel) + { for (here = model->B3SOIinstances; here; here = here->B3SOInextInstance) + { + + if (here->B3SOIowner != ARCHme) + continue; + + if(!here->B3SOIicVBSGiven) + { here->B3SOIicVBS = *(ckt->CKTrhs + here->B3SOIbNode) + - *(ckt->CKTrhs + here->B3SOIsNode); + } + if (!here->B3SOIicVDSGiven) + { here->B3SOIicVDS = *(ckt->CKTrhs + here->B3SOIdNode) + - *(ckt->CKTrhs + here->B3SOIsNode); + } + if (!here->B3SOIicVGSGiven) + { here->B3SOIicVGS = *(ckt->CKTrhs + here->B3SOIgNode) + - *(ckt->CKTrhs + here->B3SOIsNode); + } + if (!here->B3SOIicVESGiven) + { here->B3SOIicVES = *(ckt->CKTrhs + here->B3SOIeNode) + - *(ckt->CKTrhs + here->B3SOIsNode); + } + if (!here->B3SOIicVPSGiven) + { here->B3SOIicVPS = *(ckt->CKTrhs + here->B3SOIpNode) + - *(ckt->CKTrhs + here->B3SOIsNode); + } + } + } + return(OK); +} + + diff --git a/src/spicelib/devices/bsim3soi/b3soiinit.c b/src/spicelib/devices/bsim3soi/b3soiinit.c new file mode 100644 index 000000000..4a9db340f --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soiinit.c @@ -0,0 +1,83 @@ +#include + +#include + +#include "b3soiitf.h" +#include "b3soiext.h" +#include "b3soiinit.h" + +SPICEdev B3SOIinfo = { + { "B3SOI", + "Berkeley SOI MOSFET model version 3.0", + + &B3SOInSize, + &B3SOInSize, + B3SOInames, + + &B3SOIpTSize, + B3SOIpTable, + + &B3SOImPTSize, + B3SOImPTable, + +#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 : B3SOIparam, + DEVmodParam : B3SOImParam, + DEVload : B3SOIload, + DEVsetup : B3SOIsetup, + DEVunsetup : B3SOIunsetup, + DEVpzSetup : B3SOIsetup, + DEVtemperature: B3SOItemp, + DEVtrunc : B3SOItrunc, + DEVfindBranch : NULL, + DEVacLoad : B3SOIacLoad, + DEVaccept : NULL, + DEVdestroy : B3SOIdestroy, + DEVmodDelete : B3SOImDelete, + DEVdelete : B3SOIdelete, + DEVsetic : B3SOIgetic, + DEVask : B3SOIask, + DEVmodAsk : B3SOImAsk, + DEVpzLoad : B3SOIpzLoad, + DEVconvTest : B3SOIconvTest, + DEVsenSetup : NULL, + DEVsenLoad : NULL, + DEVsenUpdate : NULL, + DEVsenAcLoad : NULL, + DEVsenPrint : NULL, + DEVsenTrunc : NULL, + DEVdisto : NULL, + DEVnoise : B3SOInoise, +#ifdef CIDER + DEVdump : NULL, + DEVacct : NULL, +#endif + DEVinstSize : &B3SOIiSize, + DEVmodSize : &B3SOImSize +}; + +SPICEdev * +get_b3soi_info (void) +{ + return &B3SOIinfo; +} + + diff --git a/src/spicelib/devices/bsim3soi/b3soiinit.h b/src/spicelib/devices/bsim3soi/b3soiinit.h new file mode 100644 index 000000000..0178dd26b --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soiinit.h @@ -0,0 +1,13 @@ +#ifndef _B3SOIINIT_H +#define _B3SOIINIT_H + +extern IFparm B3SOIpTable[]; +extern IFparm B3SOImPTable[]; +extern char *B3SOInames[]; +extern int B3SOIpTSize; +extern int B3SOImPTSize; +extern int B3SOInSize; +extern int B3SOIiSize; +extern int B3SOImSize; + +#endif diff --git a/src/spicelib/devices/bsim3soi/b3soiitf.h b/src/spicelib/devices/bsim3soi/b3soiitf.h new file mode 100644 index 000000000..7479a9a4c --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soiitf.h @@ -0,0 +1,16 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung +File: b3soiitf.h +Modified by Paolo Nenzi 2002 +**********/ + +#ifndef DEV_B3SOI +#define DEV_B3SOI + +#include "b3soiext.h" + +SPICEdev *get_b3soi_info (void); + +#endif + diff --git a/src/spicelib/devices/bsim3soi/b3soild.c b/src/spicelib/devices/bsim3soi/b3soild.c new file mode 100644 index 000000000..cc652d339 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soild.c @@ -0,0 +1,4890 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soild.c 98/5/01 +Modified by Pin Su, Weidong Liu and Jan Feng 99/2/15 +Modified by Pin Su 99/4/30 +Modified by Pin Su, Wei Jin 99/9/27 +Modified by Pin Su 00/3/1 +Modified by Pin Su 00/8/15 +Modified by Pin Su 01/2/15 +Modified by Pin Su and Hui Wan 02/3/5 +Modified by Pin Su 02/5/20 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "cktdefs.h" +#include "b3soidef.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 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 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 + + + /* B3SOIlimit(vnew,vold) + * limits the per-iteration change of any absolute voltage value + */ + +double +B3SOIlimit(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 +B3SOIload(GENmodel *inModel, CKTcircuit *ckt) +{ +B3SOImodel *model = (B3SOImodel*)inModel; +B3SOIinstance *here; +int selfheat; + +double SourceSatCurrent, DrainSatCurrent, Gmin; +double ag0, qgd, qgs, qgb, von, cbhat, VgstNVt, ExpVgst; +double cdhat, cdreq, ceqbd, ceqbs, ceqqb, ceqqd, ceqqg, ceq, geq; +double evbd, evbs, arg, sarg; +double delvbd, delvbs, delvds, delvgd, delvgs; +double Vfbeff, dVfbeff_dVg, dVfbeff_dVd, dVfbeff_dVb, V3, V4; +double tol, PhiB, 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, Nvtm; +double Vgdt, Vgsaddvth, Vgsaddvth2, Vgsaddvth1o3, n, dn_dVb, Vtm; +double ExpArg, V0; +double ueff, dueff_dVg, dueff_dVd, dueff_dVb, dueff_dT; +double Esat, dEsat_dVg, dEsat_dVd, dEsat_dVb, Vdsat, Vdsat0; +double EsatL, dEsatL_dVg, dEsatL_dVd, dEsatL_dVb, dEsatL_dT; +double dVdsat_dVg, dVdsat_dVb, dVdsat_dVd, dVdsat_dT, Vasat, dAlphaz_dVg, dAlphaz_dVb; +double dVasat_dVg, dVasat_dVb, dVasat_dVd, dVasat_dT; +double Va, Va2, dVa_dVd, dVa_dVg, dVa_dVb, dVa_dT; +double Vbseff, dVbseff_dVb; +double Alphaz, CoxWL; +double dVgdt_dVg, dVgdt_dVd, dVgdt_dVb; +double T0, dT0_dVg, dT0_dVd, dT0_dVb, dT0_dVrg, 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_dVg, 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, dT7_dVg, dT7_dVd, dT7_dVb; +double T8, dT8_dVg, dT8_dVd, dT8_dVb, dT8_dVrg; +double T9, dT9_dVg, dT9_dVd, dT9_dVb, dT9_dVrg; +double T10, dT10_dVg, dT10_dVb, dT10_dVd; +double T11, T12; +double tmp, Abulk, dAbulk_dVb, Abulk0, dAbulk0_dVb; +double T100, T101; +double VACLM, dVACLM_dVg, dVACLM_dVd, dVACLM_dVb, dVACLM_dT; +double VADIBL, dVADIBL_dVg, dVADIBL_dVd, dVADIBL_dVb, dVADIBL_dT; +double VAHCE, dVAHCE_dVg, dVAHCE_dVd, dVAHCE_dVb; +double Xdep, dXdep_dVb, lt1, dlt1_dVb, ltw, dltw_dVb; +double Delt_vth, dDelt_vth_dVb, dDelt_vth_dT; +double Theta0, dTheta0_dVb, Theta1, dTheta1_dVb; +double Thetarout, dThetarout_dVb, TempRatio, tmp1, tmp2, tmp3, tmp4; +double DIBL_Sft, dDIBL_Sft_dVd, DIBL_fact, Lambda, dLambda_dVg; +double Rout_Vgs_factor, dRout_Vgs_factor_dVg, dRout_Vgs_factor_dVb; +double dRout_Vgs_factor_dVd; +double tempv, 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, diffVdsCV; +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_dVd, dVdsatCV_dVg, dVdsatCV_dVb; +double Leff, Weff, dWeff_dVg, dWeff_dVb; +double AbulkCV, dAbulkCV_dVb; +double qgdo, qgso, cgdo, cgso; + +double dxpart, sxpart; + +struct b3soiSizeDependParam *pParam; +int ByPass, Check, ChargeComputationNeeded, J, error, I; +double junk[50]; + +double gbbsp, gbbdp, gbbg, gbbb, gbbp, gbbT; +double gddpsp, gddpdp, gddpg, gddpb, gddpT; +double gsspsp, gsspdp, gsspg, gsspb, gsspT; +double Gbpbs, Gbpps; +double vse, vde, ves, ved, veb, vge, delves, vedo, delved; +double vps, vpd, Vps, delvps; +double Vbd, Ves, Vesfb, sqrtXdep, 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 diffVdsii ; +double Idgidl, Gdgidld, Gdgidlg, Isgidl, Gsgidlg; +double Gjsd, Gjss, 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, WL; +double qjs, gcjsbs, gcjsT; +double qjd, gcjdbs, gcjdds, gcjdT; +double qge; +double ceqqe; +double ni, Eg, Cbox, Nfb, CboxWL; +double cjsbs; +double dVfbeff_dVrg; +double qinv, qgate, qbody, qdrn, qsrc, qsub, cqgate, cqbody, cqdrn, cqsub, cqtemp; +double Cgg, Cgd, Cgs, Cgb, Cdg, Cdd, Cds, Cdb, Qg, Qd; +double Csg, Csd, Css, Csb, Cbg, Cbd, Cbs, Cbb, Qs, Qb; +double Cgg1, Cgb1, Cgd1, Cbg1, Cbb1, Cbd1, Csg1, Csd1, Csb1; +double Vbseff0; +double Vdsatii ,dVdsatii_dVg ,dVdsatii_dVd, dVdsatii_dVb, dVdsatii_dT; +double Ibjt ,dIbjt_dVb ,dIbjt_dVd ,dIbjt_dT; +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 ExpVbs1, dExpVbs1_dVb, dExpVbs1_dT; +double ExpVbs2, dExpVbs2_dVb, dExpVbs2_dT; +double ExpVbs4, dExpVbs4_dVb, dExpVbs4_dT; +double ExpVbd1, dExpVbd1_dVb, dExpVbd1_dT; +double ExpVbd2, dExpVbd2_dVb, dExpVbd2_dT; +double ExpVbd4, dExpVbd4_dVb, dExpVbd4_dT; +double WTsi, NVtm1, NVtm2; +double Ic ,dIc_dVb ,dIc_dVd; +double Ibs ,dIbs_dVb ,dIbs_dVd ; +double Ibd ,dIbd_dVb; +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 Qdep0 ,dQdep0_dVb; +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, jbjt, jdif, jrec, jtun, u0temp, vsattemp; +double rds0, ua, ub, uc; +double dvbi_dT, dvfbb_dT, djbjt_dT, djdif_dT, djrec_dT, djtun_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, CeT; + + +/* 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, dNVtm2_dT; +double NVtmf, NVtmr, dNVtmf_dT, dNVtmr_dT; +double TempRatioMinus1; +double Ahli, dAhli_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.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 Vbsdio, dVbsdio_dVg, dVbsdio_dVd, dVbsdio_dVe, dVbsdio_dVb, dVbsdio_dT; +double Vbs0, dVbs0_dVg, dVbs0_dVd, dVbs0_dVb, 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_dVb, dPhiON_dVe, dPhiON_dT; +double PhiFD, dPhiFD_dVg, dPhiFD_dVd, dPhiFD_dVb, dPhiFD_dVe, dPhiFD_dT; +double Vbs0t, dVbs0t_dVg, dVbs0t_dVd, dVbs0t_dVb, 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, dVoxacc_dT; +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; + + +double m; + +for (; model != NULL; model = model->B3SOInextModel) +{ for (here = model->B3SOIinstances; here != NULL; + here = here->B3SOInextInstance) + { + + + if (here->B3SOIowner != ARCHme) + continue; + + + Check = 0; + ByPass = 0; + selfheat = (model->B3SOIshMod == 1) && (here->B3SOIrth0 != 0.0); + pParam = here->pParam; + + + if ((ckt->CKTmode & MODEINITSMSIG)) + { + vs = *(ckt->CKTrhsOld + here->B3SOIsNodePrime); + if (!here->B3SOIvbsusrGiven) { + vbs = *(ckt->CKTstate0 + here->B3SOIvbs); + vb = *(ckt->CKTrhsOld + here->B3SOIbNode); + } + else { + vbs = here->B3SOIvbsusr; + vb = here->B3SOIvbsusr + vs; + } + vgs = *(ckt->CKTstate0 + here->B3SOIvgs); + ves = *(ckt->CKTstate0 + here->B3SOIves); + vps = *(ckt->CKTstate0 + here->B3SOIvps); + vds = *(ckt->CKTstate0 + here->B3SOIvds); + delTemp = *(ckt->CKTstate0 + here->B3SOIdeltemp); + + vg = *(ckt->CKTrhsOld + here->B3SOIgNode); + vd = *(ckt->CKTrhsOld + here->B3SOIdNodePrime); + vp = *(ckt->CKTrhsOld + here->B3SOIpNode); + ve = *(ckt->CKTrhsOld + here->B3SOIeNode); + + } + else if ((ckt->CKTmode & MODEINITTRAN)) + { + vs = *(ckt->CKTrhsOld + here->B3SOIsNodePrime); + if (!here->B3SOIvbsusrGiven) { + vbs = *(ckt->CKTstate1 + here->B3SOIvbs); + vb = *(ckt->CKTrhsOld + here->B3SOIbNode); + } + else { + vbs = here->B3SOIvbsusr; + vb = here->B3SOIvbsusr + vs; + } + vgs = *(ckt->CKTstate1 + here->B3SOIvgs); + ves = *(ckt->CKTstate1 + here->B3SOIves); + vps = *(ckt->CKTstate1 + here->B3SOIvps); + vds = *(ckt->CKTstate1 + here->B3SOIvds); + delTemp = *(ckt->CKTstate1 + here->B3SOIdeltemp); + + vg = *(ckt->CKTrhsOld + here->B3SOIgNode); + vd = *(ckt->CKTrhsOld + here->B3SOIdNodePrime); + vp = *(ckt->CKTrhsOld + here->B3SOIpNode); + ve = *(ckt->CKTrhsOld + here->B3SOIeNode); + + } + else if ((ckt->CKTmode & MODEINITJCT) && !here->B3SOIoff) + { vds = model->B3SOItype * here->B3SOIicVDS; + vgs = model->B3SOItype * here->B3SOIicVGS; + ves = model->B3SOItype * here->B3SOIicVES; + vbs = model->B3SOItype * here->B3SOIicVBS; + vps = model->B3SOItype * here->B3SOIicVPS; + + vg = vd = vs = vp = ve = 0.0; + + + delTemp = 0.0; + here->B3SOIphi = pParam->B3SOIphi; + + + + if ((vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) && + ((ckt->CKTmode & (MODETRAN | MODEAC|MODEDCOP | + MODEDCTRANCURVE)) || (!(ckt->CKTmode & MODEUIC)))) + { vbs = 0.0; + vgs = model->B3SOItype*0.1 + pParam->B3SOIvth0; + vds = 0.0; + ves = 0.0; + vps = 0.0; + } + } + else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) && + (here->B3SOIoff)) + { delTemp = vps = vbs = vgs = vds = ves = 0.0; + vg = vd = vs = vp = ve = 0.0; + } + else + { +#ifndef PREDICTOR + if ((ckt->CKTmode & MODEINITPRED)) + { xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1]; + *(ckt->CKTstate0 + here->B3SOIvbs) = + *(ckt->CKTstate1 + here->B3SOIvbs); + vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIvbs)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIvbs))); + *(ckt->CKTstate0 + here->B3SOIvgs) = + *(ckt->CKTstate1 + here->B3SOIvgs); + vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIvgs)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIvgs))); + *(ckt->CKTstate0 + here->B3SOIves) = + *(ckt->CKTstate1 + here->B3SOIves); + ves = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIves)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIves))); + *(ckt->CKTstate0 + here->B3SOIvps) = + *(ckt->CKTstate1 + here->B3SOIvps); + vps = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIvps)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIvps))); + *(ckt->CKTstate0 + here->B3SOIvds) = + *(ckt->CKTstate1 + here->B3SOIvds); + vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIvds)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIvds))); + *(ckt->CKTstate0 + here->B3SOIvbd) = + *(ckt->CKTstate0 + here->B3SOIvbs) + - *(ckt->CKTstate0 + here->B3SOIvds); + + *(ckt->CKTstate0 + here->B3SOIvg) = *(ckt->CKTstate1 + here->B3SOIvg); + *(ckt->CKTstate0 + here->B3SOIvd) = *(ckt->CKTstate1 + here->B3SOIvd); + *(ckt->CKTstate0 + here->B3SOIvs) = *(ckt->CKTstate1 + here->B3SOIvs); + *(ckt->CKTstate0 + here->B3SOIvp) = *(ckt->CKTstate1 + here->B3SOIvp); + *(ckt->CKTstate0 + here->B3SOIve) = *(ckt->CKTstate1 + here->B3SOIve); + + /* Only predict ve */ + ve = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIve)) + + - (xfact * (*(ckt->CKTstate2 + here->B3SOIve))); + /* Then update vg, vs, vb, vd, vp base on ve */ + vs = ve - model->B3SOItype * ves; + vg = model->B3SOItype * vgs + vs; + vd = model->B3SOItype * vds + vs; + vb = model->B3SOItype * vbs + vs; + vp = model->B3SOItype * vps + vs; + + delTemp = (1.0 + xfact)* (*(ckt->CKTstate1 + + here->B3SOIdeltemp))-(xfact * (*(ckt->CKTstate2 + + here->B3SOIdeltemp))); + +/* v2.2.3 bug fix */ + *(ckt->CKTstate0 + here->B3SOIdeltemp) = + *(ckt->CKTstate1 + here->B3SOIdeltemp); + + if (selfheat) + { + here->B3SOIphi = 2.0 * here->B3SOIvtm + * log(pParam->B3SOInpeak / + here->B3SOIni); + } + + } + else + { +#endif /* PREDICTOR */ + + vg = B3SOIlimit(*(ckt->CKTrhsOld + here->B3SOIgNode), + *(ckt->CKTstate0 + here->B3SOIvg), 3.0, &Check); + vd = B3SOIlimit(*(ckt->CKTrhsOld + here->B3SOIdNodePrime), + *(ckt->CKTstate0 + here->B3SOIvd), 3.0, &Check); + vs = B3SOIlimit(*(ckt->CKTrhsOld + here->B3SOIsNodePrime), + *(ckt->CKTstate0 + here->B3SOIvs), 3.0, &Check); + vp = B3SOIlimit(*(ckt->CKTrhsOld + here->B3SOIpNode), + *(ckt->CKTstate0 + here->B3SOIvp), 3.0, &Check); + ve = B3SOIlimit(*(ckt->CKTrhsOld + here->B3SOIeNode), + *(ckt->CKTstate0 + here->B3SOIve), 3.0, &Check); + delTemp = *(ckt->CKTrhsOld + here->B3SOItempNode); + + vbs = model->B3SOItype * (*(ckt->CKTrhsOld+here->B3SOIbNode) + - *(ckt->CKTrhsOld+here->B3SOIsNodePrime)); + + vps = model->B3SOItype * (vp - vs); + vgs = model->B3SOItype * (vg - vs); + ves = model->B3SOItype * (ve - vs); + vds = model->B3SOItype * (vd - vs); + + +#ifndef PREDICTOR + } +#endif /* PREDICTOR */ + + vbd = vbs - vds; + vgd = vgs - vds; + ved = ves - vds; + vgdo = *(ckt->CKTstate0 + here->B3SOIvgs) + - *(ckt->CKTstate0 + here->B3SOIvds); + vedo = *(ckt->CKTstate0 + here->B3SOIves) + - *(ckt->CKTstate0 + here->B3SOIvds); + delvbs = vbs - *(ckt->CKTstate0 + here->B3SOIvbs); + delvbd = vbd - *(ckt->CKTstate0 + here->B3SOIvbd); + delvgs = vgs - *(ckt->CKTstate0 + here->B3SOIvgs); + delves = ves - *(ckt->CKTstate0 + here->B3SOIves); + delvps = vps - *(ckt->CKTstate0 + here->B3SOIvps); + deldelTemp = delTemp - *(ckt->CKTstate0 + here->B3SOIdeltemp); + delvds = vds - *(ckt->CKTstate0 + here->B3SOIvds); + delvgd = vgd - vgdo; + delved = ved - vedo; + + if (here->B3SOImode >= 0) + { + cdhat = here->B3SOIcd + (here->B3SOIgm-here->B3SOIgjdg) * delvgs + + (here->B3SOIgds - here->B3SOIgjdd) * delvds + + (here->B3SOIgmbs - here->B3SOIgjdb) * delvbs + + (here->B3SOIgme - here->B3SOIgjde) * delves + + (here->B3SOIgmT - here->B3SOIgjdT) * deldelTemp; /* v3.0 */ + } + else + { + cdhat = here->B3SOIcd + (here->B3SOIgm-here->B3SOIgjdg) * delvgd + - (here->B3SOIgds - here->B3SOIgjdd) * delvds + + (here->B3SOIgmbs - here->B3SOIgjdb) * delvbd + + (here->B3SOIgme - here->B3SOIgjde) * delved + + (here->B3SOIgmT - here->B3SOIgjdT) * deldelTemp; /* v3.0 */ + + } + cbhat = here->B3SOIcb + here->B3SOIgbgs * delvgs + + here->B3SOIgbbs * delvbs + + here->B3SOIgbds * delvds + + here->B3SOIgbes * delves + + here->B3SOIgbps * delvps + + here->B3SOIgbT * deldelTemp; /* v3.0 */ + +#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 ((fabs(delvbs) < (ckt->CKTreltol * MAX(fabs(vbs), + fabs(*(ckt->CKTstate0+here->B3SOIvbs))) + ckt->CKTvoltTol)) ) + if ((fabs(delvbd) < (ckt->CKTreltol * MAX(fabs(vbd), + fabs(*(ckt->CKTstate0+here->B3SOIvbd))) + ckt->CKTvoltTol)) ) + if ((fabs(delvgs) < (ckt->CKTreltol * MAX(fabs(vgs), + fabs(*(ckt->CKTstate0+here->B3SOIvgs))) + ckt->CKTvoltTol))) + if ((fabs(delves) < (ckt->CKTreltol * MAX(fabs(ves), + fabs(*(ckt->CKTstate0+here->B3SOIves))) + ckt->CKTvoltTol))) + if ( (here->B3SOIbodyMod == 0) || (here->B3SOIbodyMod == 2) || + (fabs(delvps) < (ckt->CKTreltol * MAX(fabs(vps), + fabs(*(ckt->CKTstate0+here->B3SOIvps))) + ckt->CKTvoltTol)) ) + if ( (here->B3SOItempNode == 0) || + (fabs(deldelTemp) < (ckt->CKTreltol * MAX(fabs(delTemp), + fabs(*(ckt->CKTstate0+here->B3SOIdeltemp))) + + ckt->CKTvoltTol*1e4))) + if ((fabs(delvds) < (ckt->CKTreltol * MAX(fabs(vds), + fabs(*(ckt->CKTstate0+here->B3SOIvds))) + ckt->CKTvoltTol))) + if ((fabs(cdhat - here->B3SOIcd) < ckt->CKTreltol + * MAX(fabs(cdhat),fabs(here->B3SOIcd)) + ckt->CKTabstol)) + if ((fabs(cbhat - here->B3SOIcb) < ckt->CKTreltol + * MAX(fabs(cbhat),fabs(here->B3SOIcb)) + ckt->CKTabstol) ) + { /* bypass code */ + vbs = *(ckt->CKTstate0 + here->B3SOIvbs); + vbd = *(ckt->CKTstate0 + here->B3SOIvbd); + vgs = *(ckt->CKTstate0 + here->B3SOIvgs); + ves = *(ckt->CKTstate0 + here->B3SOIves); + vps = *(ckt->CKTstate0 + here->B3SOIvps); + vds = *(ckt->CKTstate0 + here->B3SOIvds); + delTemp = *(ckt->CKTstate0 + here->B3SOIdeltemp); + + /* calculate Vds for temperature conductance calculation + in bypass (used later when filling Temp node matrix) */ + Vds = here->B3SOImode > 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->B3SOIvon; + + + if (*(ckt->CKTstate0 + here->B3SOIvds) >= 0.0) + T0 = *(ckt->CKTstate0 + here->B3SOIvbs); + else + T0 = *(ckt->CKTstate0 + here->B3SOIvbd); + + + if (vds >= 0.0) + { + vbs = B3SOIlimit(vbs, T0, 0.2, &Check); + vbd = vbs - vds; + vb = model->B3SOItype * vbs + vs; + } else + { + vbd = B3SOIlimit(vbd, T0, 0.2, &Check); + vbs = vbd + vds; + vb = model->B3SOItype * vbs + vd; + } + + delTemp =B3SOIlimit(delTemp, *(ckt->CKTstate0 + here->B3SOIdeltemp),5.0,&Check); + + } + +/* Calculate temperature dependent values for self-heating effect */ + Temp = delTemp + ckt->CKTtemp; + dTempRatio_dT = 1 / model->B3SOItnom; + 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->B3SOInpeak / (ni * ni)); + vbi = Vtm * T0; + dvbi_dT = KboQ * T0 + Vtm * (-2.0 * dni_dT / ni); + + if (pParam->B3SOInsub > 0) { + T0 = log(pParam->B3SOInpeak / pParam->B3SOInsub); + vfbb = -model->B3SOItype * Vtm * T0; + dvfbb_dT = -model->B3SOItype * KboQ * T0; + } + else { + T0 = log(-pParam->B3SOInpeak * pParam->B3SOInsub / ni / ni); + vfbb = -model->B3SOItype * Vtm * T0; + dvfbb_dT = -model->B3SOItype * + (KboQ * T0 - Vtm * 2.0 * dni_dT / ni); + } + +/* phi = 2.0 * Vtm * log(pParam->B3SOInpeak / ni); */ + phi = here->B3SOIphi; + sqrtPhi = sqrt(phi); + Xdep0 = sqrt(2.0 * EPSSI / (Charge_q + * pParam->B3SOInpeak * 1.0e6)) + * sqrtPhi; + /* Save the values below for phi calculation in B3SOIaccept() */ + here->B3SOIvtm = Vtm; + here->B3SOIni = ni; + + T3 = TempRatio - 1.0; + T8 = 1/ model->B3SOItnom; + T4 = Eg300 / Vtm * T3; + dT4_dT = Eg300 / Vtm / Vtm * (Vtm * T8 - T3 * KboQ); + + T7 = model->B3SOIxbjt * T4 / pParam->B3SOIndiode; + dT7_dT = model->B3SOIxbjt * dT4_dT / pParam->B3SOIndiode; + DEXP(T7, T0, dT0_dT7); + dT0_dT = dT0_dT7 * dT7_dT; + + if (model->B3SOIxbjt == model->B3SOIxdif) { + T1 = T0; + dT1_dT = dT0_dT; + } + else { + T7 = model->B3SOIxdif * T4 / pParam->B3SOIndiode; + dT7_dT = model->B3SOIxdif * dT4_dT / pParam->B3SOIndiode; + DEXP(T7, T1, dT1_dT7); + dT1_dT = dT1_dT7 * dT7_dT; + } + + T7 = model->B3SOIxrec * T4 / pParam->B3SOInrecf0; + dT7_dT = model->B3SOIxrec * dT4_dT / pParam->B3SOInrecf0; + DEXP(T7, T2, dT2_dT7); + dT2_dT = dT2_dT7 * dT7_dT; + + /* high level injection */ + Ahli = pParam->B3SOIahli * T0; + dAhli_dT = pParam->B3SOIahli * dT0_dT; + + jbjt = pParam->B3SOIisbjt * T0; + jdif = pParam->B3SOIisdif * T1; + jrec = pParam->B3SOIisrec * T2; + djbjt_dT = pParam->B3SOIisbjt * dT0_dT; + djdif_dT = pParam->B3SOIisdif * dT1_dT; + djrec_dT = pParam->B3SOIisrec * dT2_dT; + + T7 = model->B3SOIxtun * T3; + dT7_dT = model->B3SOIxtun * T8; + DEXP(T7, T0, dT0_dT7); + dT0_dT = dT0_dT7 * dT7_dT; + jtun = pParam->B3SOIistun * T0; + djtun_dT = pParam->B3SOIistun * dT0_dT; + + u0temp = pParam->B3SOIu0 * pow(TempRatio, pParam->B3SOIute); + du0temp_dT = pParam->B3SOIu0 * pParam->B3SOIute * + pow(TempRatio, pParam->B3SOIute - 1.0) * T8; + + vsattemp = pParam->B3SOIvsat - pParam->B3SOIat * T3; + dvsattemp_dT = -pParam->B3SOIat * T8; + + rds0 = (pParam->B3SOIrdsw + pParam->B3SOIprt + * T3) / pParam->B3SOIrds0denom; + drds0_dT = pParam->B3SOIprt / pParam->B3SOIrds0denom * T8; + + ua = pParam->B3SOIuatemp + pParam->B3SOIua1 * T3; + ub = pParam->B3SOIubtemp + pParam->B3SOIub1 * T3; + uc = pParam->B3SOIuctemp + pParam->B3SOIuc1 * T3; + dua_dT = pParam->B3SOIua1 * T8; + dub_dT = pParam->B3SOIub1 * T8; + duc_dT = pParam->B3SOIuc1 * T8; + } + else { + vbi = pParam->B3SOIvbi; + vfbb = pParam->B3SOIvfbb; + phi = pParam->B3SOIphi; + sqrtPhi = pParam->B3SOIsqrtPhi; + Xdep0 = pParam->B3SOIXdep0; + jbjt = pParam->B3SOIjbjt; + jdif = pParam->B3SOIjdif; + jrec = pParam->B3SOIjrec; + jtun = pParam->B3SOIjtun; + + /* v2.2.2 bug fix */ + Ahli = pParam->B3SOIahli0; + + u0temp = pParam->B3SOIu0temp; + vsattemp = pParam->B3SOIvsattemp; + rds0 = pParam->B3SOIrds0; + ua = pParam->B3SOIua; + ub = pParam->B3SOIub; + uc = pParam->B3SOIuc; + dni_dT = dvbi_dT = dvfbb_dT = djbjt_dT = djdif_dT = 0.0; + djrec_dT = djtun_dT = du0temp_dT = dvsattemp_dT = 0.0; + drds0_dT = dua_dT = dub_dT = duc_dT = 0.0; + dAhli_dT = 0; + } + + /* TempRatio used for Vth and mobility */ + if (selfheat) { + TempRatioMinus1 = Temp / model->B3SOItnom - 1.0; + } + else { + TempRatioMinus1 = ckt->CKTtemp / model->B3SOItnom - 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; + + + if (vds >= 0.0) + { /* normal mode */ + here->B3SOImode = 1; + Vds = vds; + Vgs = vgs; + Vbs = vbs; + Vbd = vbd; + Ves = ves; + Vps = vps; + + wdios = pParam->B3SOIwdios; + wdiod = pParam->B3SOIwdiod; + wdiosCV = pParam->B3SOIwdiosCV; + wdiodCV = pParam->B3SOIwdiodCV; + + } + else + { /* inverse mode */ + here->B3SOImode = -1; + Vds = -vds; + Vgs = vgd; + Vbs = vbd; + Vbd = vbs; + Ves = ved; + Vps = vpd; + + wdios = pParam->B3SOIwdiod; + wdiod = pParam->B3SOIwdios; + wdiosCV = pParam->B3SOIwdiodCV; + wdiodCV = pParam->B3SOIwdiosCV; + + } + + Vesfb = Ves - vfbb; + Cbox = model->B3SOIcbox; + K1 = pParam->B3SOIk1eff; + + ChargeComputationNeeded = + ((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) || + ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC))) + ? 1 : 0; + + if (here->B3SOIdebugMod <0) + ChargeComputationNeeded = 1; + + + + +/* Poly Gate Si Depletion Effect */ + T0 = pParam->B3SOIvfb + phi; + if ((pParam->B3SOIngate > 1.e18) && (pParam->B3SOIngate < 1.e25) + && (Vgs > T0)) + /* added to avoid the problem caused by ngate */ + { T1 = 1.0e6 * Charge_q * EPSSI * pParam->B3SOIngate + / (model->B3SOIcox * model->B3SOIcox); + 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->B3SOIleff; + + if (selfheat) { + Vtm = KboQ * Temp; + dVtm_dT = KboQ; + } + else { + Vtm = model->B3SOIvtm; + dVtm_dT = 0.0; + } + + V0 = vbi - phi; + + +/* begin of v3.0 block addition */ +/* B/S built-in potential lowering calculation */ + if (model->B3SOIsoiMod == 0) /* BSIMPD */ + { + + 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: adding FD module on top of BSIMPD */ + { + /* prepare Vbs0 & Vbs0mos for VthFD calculation */ + T0 = -model->B3SOIdvbd1 * pParam->B3SOIleff / pParam->B3SOIlitl; + T1 = model->B3SOIdvbd0 * (exp(0.5*T0) + 2*exp(T0)); + T2 = T1 * (vbi - phi); + T3 = 0.5 * model->B3SOIqsi / model->B3SOIcsi; + Vbs0t = phi - T3 + model->B3SOIvbsa + T2; + if (selfheat) + dVbs0t_dT = T1 * dvbi_dT; + else + dVbs0t_dT = 0.0; + + T0 = 1 + model->B3SOIcsi / Cbox; + T3 = -model->B3SOIdk2b * pParam->B3SOIleff / pParam->B3SOIlitl; + T5 = model->B3SOIk2b * (exp(0.5*T3) + 2*exp(T3)); + T1 = (model->B3SOIk1b - T5) / T0; + T2 = T1 * Vesfb; + T4 = 1.0/(1 + Cbox / model->B3SOIcsi); + 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->B3SOIcsi / model->B3SOIqsi; + 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->B3SOIdvt2 * Vbs0mos; + if (T0 >= - 0.5) + { T1 = 1.0 + T0; + T2 = pParam->B3SOIdvt2 ; + } + 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->B3SOIdvt2 * T4 * T4 ; + } + lt1 = model->B3SOIfactor1 * T3 * T1; + dlt1_dVb =model->B3SOIfactor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + + T0 = pParam->B3SOIdvt2w * Vbs0mos; + if (T0 >= - 0.5) + { T1 = 1.0 + T0; + T2 = pParam->B3SOIdvt2w ; + } + 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->B3SOIdvt2w * T4 * T4 ; + } + ltw= model->B3SOIfactor1 * T3 * T1; + dltw_dVb=model->B3SOIfactor1*(0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + + T0 = -0.5 * pParam->B3SOIdvt1 * 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; + } + + here->B3SOIthetavth = pParam->B3SOIdvt0 * Theta0; + Delt_vth = here->B3SOIthetavth * V0; + dDelt_vth_dVb = pParam->B3SOIdvt0 * dTheta0_dVb * V0; + if (selfheat) dDelt_vth_dT = here->B3SOIthetavth * dvbi_dT; + else dDelt_vth_dT = 0.0; + + T0 = -0.5 * pParam->B3SOIdvt1w * pParam->B3SOIweff * 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->B3SOIdvt0w * T2; + DeltVthw = T0 * V0; + dDeltVthw_dVb = pParam->B3SOIdvt0w * dT2_dVb * V0; + if (selfheat) dDeltVthw_dT = T0 * dvbi_dT; + else dDeltVthw_dT = 0.0; + + T0 = sqrt(1.0 + pParam->B3SOInlx / Leff); + T1 = (pParam->B3SOIkt1 + pParam->B3SOIkt1l / Leff + + pParam->B3SOIkt2 * Vbs0mos); + DeltVthtemp = pParam->B3SOIk1eff * (T0 - 1.0) * sqrtPhi + T1 * TempRatioMinus1; + if (selfheat) + dDeltVthtemp_dT = T1 / model->B3SOItnom; + else + dDeltVthtemp_dT = 0.0; + + tmp2 = model->B3SOItox * phi + / (pParam->B3SOIweff + pParam->B3SOIw0); + + T3 = pParam->B3SOIeta0 + pParam->B3SOIetab * Vbs0mos; + 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->B3SOIetab; + dT3_dVb = T4 ; + } + else + { + dT3_dVb = pParam->B3SOIetab ; + } + DIBL_Sft = T3 * pParam->B3SOItheta0vb0 * Vds; + dDIBL_Sft_dVd = pParam->B3SOItheta0vb0 * T3; + dDIBL_Sft_dVb = pParam->B3SOItheta0vb0 * Vds * dT3_dVb; + + VthFD = model->B3SOItype * pParam->B3SOIvth0 + pParam->B3SOIk1eff + * (sqrtPhis - sqrtPhi) - pParam->B3SOIk2 + * Vbs0mos- Delt_vth - DeltVthw +(pParam->B3SOIk3 + pParam->B3SOIk3b + * Vbs0mos) * tmp2 + DeltVthtemp - DIBL_Sft; + + T6 = pParam->B3SOIk3b * tmp2 - pParam->B3SOIk2 + + pParam->B3SOIkt2 * TempRatioMinus1; + dVthFD_dVb = pParam->B3SOIk1eff * dsqrtPhis_dVb + - dDelt_vth_dVb - dDeltVthw_dVb + + T6 - dDIBL_Sft_dVb; /* this is actually dVth_dVbs0mos */ + dVthFD_dVe = dVthFD_dVb * dVbs0mos_dVe; + dVthFD_dVd = -dDIBL_Sft_dVd; + if (selfheat) + dVthFD_dT = dDeltVthtemp_dT - dDelt_vth_dT - dDeltVthw_dT + + dVthFD_dVb * dVbs0mos_dT; + else dVthFD_dT = 0.0; + + + /* VtgseffFD calculation for PhiFD */ + VtgsFD = VthFD - Vgs_eff; + T10 = model->B3SOInofffd * Vtm; + DEXP((VtgsFD - model->B3SOIvofffd)/ 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->B3SOIvofffd)/Temp) + + VtgseffFD/Temp; + else dVtgseffFD_dT = 0.0; + + + /* surface potential modeling at strong inversion: PhiON */ + VgstFD = Vgs_eff - VthFD; + DEXP((VgstFD - model->B3SOIvofffd)/ 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->B3SOIvofffd)/Temp) + + VgsteffFD/Temp; + else dVgsteffFD_dT = 0.0; + + + T1 = model->B3SOImoinFD*pParam->B3SOIk1eff*Vtm*Vtm; + if (selfheat) dT1_dT = 2*T1/Temp; + else dT1_dT=0.0; + + T2 = VgsteffFD+ 2*pParam->B3SOIk1eff*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->B3SOIcox / (model->B3SOIcox + 1.0/(1.0/model->B3SOIcsi + 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->B3SOIdvbd1 * pParam->B3SOIleff / pParam->B3SOIlitl; + T1 = model->B3SOIdvbd0 * (exp(0.5*T0) + 2*exp(T0)); + T2 = T1 * (vbi - phi); + T3 = 0.5 * model->B3SOIqsi / model->B3SOIcsi; + Vbs0t = PhiFD - T3 + model->B3SOIvbsa + 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->B3SOIcsi / Cbox; + T3 = -model->B3SOIdk2b * pParam->B3SOIleff / pParam->B3SOIlitl; + T5 = model->B3SOIk2b * (exp(0.5*T3) + 2*exp(T3)); + T1 = (model->B3SOIk1b - T5) / T0; + T2 = T1 * Vesfb; + T0 = 1.0/(1 + Cbox / model->B3SOIcsi); + 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) */ + T1 = Vbs - (Vbs0 + 0.02) - 0.01; + T2 = sqrt(T1*T1 + 0.0001); + T3 = 0.5 * (1 + T1/T2); + Vbsitf = Vbs0 + 0.02 + 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->B3SOIcsi / model->B3SOIqsi; + 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->B3SOIvbseff = Vbs; /* 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; + +/* Vth Calculation */ + T3 = sqrt(Xdep); + + T0 = pParam->B3SOIdvt2 * Vbseff; + if (T0 >= - 0.5) + { T1 = 1.0 + T0; + T2 = pParam->B3SOIdvt2 ; + } + 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->B3SOIdvt2 * T4 * T4 ; + } + lt1 = model->B3SOIfactor1 * T3 * T1; + dlt1_dVb =model->B3SOIfactor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + + T0 = pParam->B3SOIdvt2w * Vbseff; + if (T0 >= - 0.5) + { T1 = 1.0 + T0; + T2 = pParam->B3SOIdvt2w ; + } + 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->B3SOIdvt2w * T4 * T4 ; + } + ltw= model->B3SOIfactor1 * T3 * T1; + dltw_dVb=model->B3SOIfactor1*(0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + + T0 = -0.5 * pParam->B3SOIdvt1 * 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; + } + + here->B3SOIthetavth = pParam->B3SOIdvt0 * Theta0; + Delt_vth = here->B3SOIthetavth * V0; + dDelt_vth_dVb = pParam->B3SOIdvt0 * dTheta0_dVb * V0; + if (selfheat) dDelt_vth_dT = here->B3SOIthetavth * dvbi_dT; + else dDelt_vth_dT = 0.0; + + T0 = -0.5 * pParam->B3SOIdvt1w * pParam->B3SOIweff * 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->B3SOIdvt0w * T2; + DeltVthw = T0 * V0; + dDeltVthw_dVb = pParam->B3SOIdvt0w * dT2_dVb * V0; + if (selfheat) dDeltVthw_dT = T0 * dvbi_dT; + else dDeltVthw_dT = 0.0; + + T0 = sqrt(1.0 + pParam->B3SOInlx / Leff); + T1 = (pParam->B3SOIkt1 + pParam->B3SOIkt1l / Leff + + pParam->B3SOIkt2 * Vbseff); + DeltVthtemp = pParam->B3SOIk1eff * (T0 - 1.0) * sqrtPhi + T1 * TempRatioMinus1; + if (selfheat) + dDeltVthtemp_dT = T1 / model->B3SOItnom; + else + dDeltVthtemp_dT = 0.0; + + tmp2 = model->B3SOItox * phi + / (pParam->B3SOIweff + pParam->B3SOIw0); + + T3 = pParam->B3SOIeta0 + pParam->B3SOIetab * 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->B3SOIetab; + dT3_dVb = T4 ; + } + else + { + dT3_dVb = pParam->B3SOIetab ; + } + DIBL_Sft = T3 * pParam->B3SOItheta0vb0 * Vds; + dDIBL_Sft_dVd = pParam->B3SOItheta0vb0 * T3; + dDIBL_Sft_dVb = pParam->B3SOItheta0vb0 * Vds * dT3_dVb; + + T9 = 2.2361 / sqrtPhi; + sqrtPhisExt = sqrtPhis - T9 * (Vbsh - Vbseff); + dsqrtPhisExt_dVb = dsqrtPhis_dVb - T9 * (dVbsh_dVb - 1); + + Vth = model->B3SOItype * pParam->B3SOIvth0 + pParam->B3SOIk1eff + * (sqrtPhisExt - sqrtPhi) - pParam->B3SOIk2 + * Vbseff- Delt_vth - DeltVthw +(pParam->B3SOIk3 + pParam->B3SOIk3b + * Vbseff) * tmp2 + DeltVthtemp - DIBL_Sft; + here->B3SOIvon = Vth; + + T6 = pParam->B3SOIk3b * tmp2 - pParam->B3SOIk2 + + pParam->B3SOIkt2 * TempRatioMinus1; + dVth_dVb = pParam->B3SOIk1eff * dsqrtPhisExt_dVb + - dDelt_vth_dVb - dDeltVthw_dVb + + T6 - dDIBL_Sft_dVb; + /* this is actually dVth_dVbseff */ + + dVth_dVd = -dDIBL_Sft_dVd; + if (selfheat) + dVth_dT = dDeltVthtemp_dT - dDelt_vth_dT - dDeltVthw_dT; + else dVth_dT = 0.0; + + + /* dVthzb_dT calculation */ + if ((model->B3SOIcapMod == 3) && (selfheat == 1)) { + T3zb = sqrt(Xdep0); + ltwzb = lt1zb = model->B3SOIfactor1 * T3zb; + + T0 = -0.5 * pParam->B3SOIdvt1 * 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->B3SOIdvt0 * Theta0zb * V0; + dDelt_vthzb_dT = pParam->B3SOIdvt0 * Theta0zb * dvbi_dT; + + T0 = -0.5 * pParam->B3SOIdvt1w * pParam->B3SOIweff * 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->B3SOIdvt0w * T2; + DeltVthwzb = T0 * V0; + dDeltVthwzb_dT = T0 * dvbi_dT; + + T0 = sqrt(1.0 + pParam->B3SOInlx / Leff); + T1 = (pParam->B3SOIkt1 + pParam->B3SOIkt1l / Leff); + DeltVthtempzb = pParam->B3SOIk1eff * (T0 - 1.0) * sqrtPhi + + T1 * TempRatioMinus1; + dDeltVthtempzb_dT = T1 / model->B3SOItnom; + + Vthzb = model->B3SOItype * pParam->B3SOIvth0 + - Delt_vthzb - DeltVthwzb + pParam->B3SOIk3 * tmp2 + + DeltVthtempzb; + dVthzb_dT = dDeltVthtempzb_dT - dDelt_vthzb_dT - dDeltVthwzb_dT; + } + +/* Calculate n */ + T2 = pParam->B3SOInfactor * EPSSI / Xdep; + dT2_dVb = - T2 / Xdep * dXdep_dVb; + + T3 = pParam->B3SOIcdsc + pParam->B3SOIcdscb * Vbseff + + pParam->B3SOIcdscd * Vds; + dT3_dVb = pParam->B3SOIcdscb; + dT3_dVd = pParam->B3SOIcdscd; + + T4 = (T2 + T3 * Theta0 + pParam->B3SOIcit) / model->B3SOIcox; + dT4_dVb = (dT2_dVb + Theta0 * dT3_dVb + dTheta0_dVb * T3) + / model->B3SOIcox; + dT4_dVd = Theta0 * dT3_dVd / model->B3SOIcox; + + 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; + } + +/* Effective Vgst (Vgsteff) Calculation */ + + Vgst = Vgs_eff - Vth; + dVgst_dVg = dVgs_eff_dVg; + dVgst_dVd = -dVth_dVd; + dVgst_dVb = -dVth_dVb; + + T10 = 2.0 * n * Vtm; + VgstNVt = Vgst / T10; + ExpArg = (2.0 * pParam->B3SOIvoff - Vgst) / T10; + + /* 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->B3SOIvoff) / (n * Vtm); + ExpVgst = exp(T0); + Vgsteff = Vtm * pParam->B3SOIcdep0 / model->B3SOIcox * 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); + 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->B3SOIcox / (Vtm * pParam->B3SOIcdep0) + * exp(ExpArg); + T2 = 1.0 - T10 * dT2_dVg; + dT2_dVd = -dT2_dVg * (dVth_dVd - 2.0 * Vtm * ExpArg * dn_dVd) + + (T2 - 1.0) / n * dn_dVd; + dT2_dVb = -dT2_dVg * (dVth_dVb - 2.0 * Vtm * ExpArg * dn_dVb) + + (T2 - 1.0) / n * dn_dVb; + if (selfheat) + dT2_dT = -dT2_dVg * (dVth_dT - ExpArg * T10 * T3); + 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 = 2.0 * dVtm_dT; + else dVgst2Vtm_dT = 0.0; + here->B3SOIVgsteff = Vgsteff; /* v2.2.3 bug fix */ + + +/* Calculate Effective Channel Geometry */ + T9 = sqrtPhis - sqrtPhi; + Weff = pParam->B3SOIweff - (2.0 - here->B3SOInbc) * (pParam->B3SOIdwg * Vgsteff + + pParam->B3SOIdwb * T9); + dWeff_dVg = -(2.0 - here->B3SOInbc) * pParam->B3SOIdwg; + dWeff_dVb = -(2.0 - here->B3SOInbc) * pParam->B3SOIdwb * 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; + } + + T0 = pParam->B3SOIprwg * Vgsteff + pParam->B3SOIprwb * T9; + if (T0 >= -0.9) + { Rds = rds0 * (1.0 + T0); + dRds_dVg = rds0 * pParam->B3SOIprwg; + dRds_dVb = rds0 * pParam->B3SOIprwb * 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->B3SOIprwg * T1; + dRds_dVb = rds0 * pParam->B3SOIprwb * dsqrtPhis_dVb + * T1; + + if (selfheat && (Rds!=0.0)) dRds_dT = (0.8 + T0) * T1 * drds0_dT; + else dRds_dT = 0.0; + + } + here->B3SOIrds = Rds; /* v2.2.3 bug fix */ + +/* Calculate Abulk */ + if (pParam->B3SOIa0 == 0.0) { + + Abulk0 = Abulk = 1.0; + + dAbulk0_dVb = dAbulk_dVg = dAbulk_dVb = 0.0; + } + else { + T10 = pParam->B3SOIketa * Vbsh; + if (T10 >= -0.9) { + T11 = 1.0 / (1.0 + T10); + dT11_dVb = -pParam->B3SOIketa * 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->B3SOIketa * T12 * T12 * dVbsh_dVb; + } + +/* v3.0 bug fix */ + T10 = phi + pParam->B3SOIketas; + + 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->B3SOIk1eff + / sqrt(phi + pParam->B3SOIketas); + + T1 = T10 * T14; + dT1_dVb = T10 * dT14_dVb; + + T9 = sqrt(model->B3SOIxj * Xdep); + tmp1 = Leff + 2.0 * T9; + T5 = Leff / tmp1; + tmp2 = pParam->B3SOIa0 * T5; + tmp3 = pParam->B3SOIweff + pParam->B3SOIb1; + tmp4 = pParam->B3SOIb0 / 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->B3SOIags * pParam->B3SOIa0 * 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; + } + +/* Mobility calculation */ + if (model->B3SOImobMod == 1) + { T0 = Vgsteff + Vth + Vth; + T2 = ua + uc * Vbseff; + T3 = T0 / model->B3SOItox; + T5 = T3 * (T2 + ub * T3); + dDenomi_dVg = (T2 + 2.0 * ub * T3) / model->B3SOItox; + 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->B3SOImobMod == 2) + { T5 = Vgsteff / model->B3SOItox * (ua + + uc * Vbseff + ub * Vgsteff + / model->B3SOItox); + dDenomi_dVg = (ua + uc * Vbseff + + 2.0 * ub * Vgsteff / model->B3SOItox) + / model->B3SOItox; + dDenomi_dVd = 0.0; + dDenomi_dVb = Vgsteff * uc / model->B3SOItox ; + if (selfheat) + dDenomi_dT = Vgsteff / model->B3SOItox + * (dua_dT + Vbseff * duc_dT + dub_dT + * Vgsteff / model->B3SOItox); + else + dDenomi_dT = 0.0; + } + else /* mobMod == 3 */ + { T0 = Vgsteff + Vth + Vth; + T2 = 1.0 + uc * Vbseff; + T3 = T0 / model->B3SOItox; + T4 = T3 * (ua + ub * T3); + T5 = T4 * T2; + dDenomi_dVg = (ua + 2.0 * ub * T3) * T2 + / model->B3SOItox; + 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->B3SOIueff = 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->B3SOIcox; + WVCoxRds = WVCox * Rds; + +/* dWVCoxRds_dT = WVCox * dRds_dT + + Weff * model->B3SOIcox * 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->B3SOIa1; + if (a1 == 0.0) + { Lambda = pParam->B3SOIa2; + 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->B3SOIa2; + T1 = T0 - pParam->B3SOIa1 * Vgsteff - 0.0001; + T2 = sqrt(T1 * T1 + 0.0004 * T0); + Lambda = pParam->B3SOIa2 + T0 - 0.5 * (T1 + T2); + dLambda_dVg = 0.5 * pParam->B3SOIa1 * (1.0 + T1 / T2); + } + else + { T1 = pParam->B3SOIa2 + pParam->B3SOIa1 * Vgsteff - 0.0001; + T2 = sqrt(T1 * T1 + 0.0004 * pParam->B3SOIa2); + Lambda = 0.5 * (T1 + T2); + dLambda_dVg = 0.5 * pParam->B3SOIa1 * (1.0 + T1 / T2); + } + + here->B3SOIAbovVgst2Vtm = 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->B3SOIvdsat = Vdsat; + + +/* Effective Vds (Vdseff) Calculation */ + T1 = Vdsat - Vds - pParam->B3SOIdelta; + 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->B3SOIdelta * Vdsat); + T0 = T1 / T2; + T3 = 2.0 * pParam->B3SOIdelta / 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->B3SOIVdseff = 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->B3SOIpclm > 0.0) && (diffVds > 1.0e-10)) + { T0 = 1.0 / (pParam->B3SOIpclm * Abulk * pParam->B3SOIlitl); + 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->B3SOIthetaRout > 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->B3SOIthetaRout; + 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->B3SOIpdiblb * Vbseff; + if (T7 >= -0.9) + { T3 = 1.0 / (1.0 + T7); + VADIBL *= T3; + dVADIBL_dVg *= T3; + dVADIBL_dVb = (dVADIBL_dVb - VADIBL * pParam->B3SOIpdiblb) + * 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->B3SOIpdiblb * 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; + } + +/* Calculate VA */ + + T8 = pParam->B3SOIpvag / 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; + + 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; + +/* Calculate Ids */ + CoxWovL = model->B3SOIcox * 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; + +/* 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->B3SOIids = Ids = Idl * T0 / here->B3SOInseg; + + 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->B3SOInseg; /* v3.0 */ + Gmb = (Gm0 * dVgsteff_dVb + Gmb0 * dVbseff_dVb) / here->B3SOInseg; + Gds = (Gm0 * dVgsteff_dVd+ Gmb0 * dVbseff_dVd + Gds0) / here->B3SOInseg; /* v3.0 */ + Gme = (Gm0 * dVgsteff_dVe + Gmb0 * dVbseff_dVe) / here->B3SOInseg; /* v3.0 */ + if (selfheat) + GmT = (Gm0 * dVgsteff_dT+ Gmb0 * dVbseff_dT + GmT0) / here->B3SOInseg; /* v3.0 */ + else GmT = 0.0; + + +/* calculate GIDL current */ + T0 = 3 * model->B3SOItox; + /* For drain side */ + T1 = (Vds - Vgs_eff - pParam->B3SOIngidl) / T0; + if ((pParam->B3SOIagidl <= 0.0) || (pParam->B3SOIbgidl <= 0.0) || + (T1 <= 0.0)) + { Idgidl = Gdgidld = Gdgidlg = 0.0; + } + else { + dT1_dVd = 1 / T0; + dT1_dVg = - dT1_dVd * dVgs_eff_dVg; + T2 = pParam->B3SOIbgidl / T1; + if (T2 < EXPL_THRESHOLD) + { + Idgidl = wdiod * pParam->B3SOIagidl * T1 * exp(-T2); + T3 = Idgidl / T1 * (T2 + 1); + Gdgidld = T3 * dT1_dVd; + Gdgidlg = T3 * dT1_dVg; + } else + { + T3 = wdiod * pParam->B3SOIagidl * MIN_EXPL; + Idgidl = T3 * T1 ; + Gdgidld = T3 * dT1_dVd; + Gdgidlg = T3 * dT1_dVg; + } + } + here->B3SOIigidl = Idgidl; + + /* For source side */ + T1 = (- Vgs_eff - pParam->B3SOIngidl) / T0; + if ((pParam->B3SOIagidl <= 0.0) || (pParam->B3SOIbgidl <= 0.0) + || (T1 <= 0.0)) + { Isgidl = Gsgidlg = 0; + } + else + { + dT1_dVg = - dVgs_eff_dVg / T0; + T2 = pParam->B3SOIbgidl / T1; + if (T2 < EXPL_THRESHOLD) + { + Isgidl = wdios * pParam->B3SOIagidl * T1 * exp(-T2); + T3 = Isgidl / T1 * (T2 + 1); + Gsgidlg = T3 * dT1_dVg; + } else + { + T3 = wdios * pParam->B3SOIagidl * MIN_EXPL; + Isgidl = T3 * T1 ; + Gsgidlg = T3 * dT1_dVg; + } + } + +/* calculate diode and BJT current */ + WsTsi = wdios * model->B3SOItsi; + WdTsi = wdiod * model->B3SOItsi; + + NVtm1 = Vtm * pParam->B3SOIndiode; + if (selfheat) + dNVtm1_dT = pParam->B3SOIndiode * dVtm_dT; + else + dNVtm1_dT = 0; + + T0 = Vbs / NVtm1; + dT0_dVb = 1.0 / NVtm1; + if (selfheat) + dT0_dT = -Vbs / 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; + + T0 = Vbd / NVtm1; + dT0_dVb = 1.0 / NVtm1; + dT0_dVd = -dT0_dVb; + if (selfheat) + dT0_dT = -Vbd / 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 / Ibd1 : diffusion current */ + if (jdif == 0) { + Ibs1 = dIbs1_dVb = dIbs1_dT = Ibd1 = dIbd1_dVb = dIbd1_dVd = dIbd1_dT = 0; + } + else { + T0 = WsTsi * jdif; + if (selfheat) + dT0_dT = WsTsi * djdif_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; + + T0 = WdTsi * jdif; + if (selfheat) + dT0_dT = WdTsi * djdif_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 */ + NVtmf = 0.026 * pParam->B3SOInrecf0 + * (1 + model->B3SOIntrecf * (TempRatio - 1)); + NVtmr = 0.026 * pParam->B3SOInrecr0 /* v2.2.2 bug fix */ + * (1 + model->B3SOIntrecr * (TempRatio - 1)); + if (selfheat) { + dNVtmf_dT = pParam->B3SOInrecf0 * 0.026 + * model->B3SOIntrecf * dTempRatio_dT; + dNVtmr_dT = pParam->B3SOInrecr0 * 0.026 /* v2.2.2 bug fix */ + * model->B3SOIntrecr * dTempRatio_dT; + } + else + dNVtmf_dT = dNVtmr_dT = 0; + + if (jrec == 0) { + Ibs2 = dIbs2_dVb = dIbs2_dT = 0; + Ibd2 = dIbd2_dVb = dIbd2_dVd = dIbd2_dT = 0; + } + else { + /* forward bias */ + T0 = Vbs / NVtmf; + DEXP(T0,T10,T2); + T4 = 1 / NVtmf; + dT10_dVb = T4 * T2; + if (selfheat) + dT10_dT = - T4 * T2 * Vbs / NVtmf * dNVtmf_dT ; + else dT10_dT = 0.0; + + /* reverse bias */ + if ((pParam->B3SOIvrec0 - Vbs) < 1e-3) { + + /* v2.2.3 bug fix */ + T1 = 1e3; + T0 = -Vbs / NVtmr * pParam->B3SOIvrec0 * T1; + T11 = -exp(T0); + + dT11_dVb = dT11_dT = 0; + } + else { + T1 = 1 / (pParam->B3SOIvrec0 - Vbs); + T0 = -Vbs / NVtmr * pParam->B3SOIvrec0 * T1; + dT0_dVb = -pParam->B3SOIvrec0 / NVtmr * (T1 + Vbs * 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 * jrec; + Ibs2 = T3 * (T10 + T11); + dIbs2_dVb = T3 * (dT10_dVb + dT11_dVb); + if (selfheat) + dIbs2_dT = T3 * (dT10_dT + dT11_dT) + WsTsi * (T10 + T11) * djrec_dT; + else dIbs2_dT = 0; + + /* Ibd2 */ + T0 = Vbd / NVtmf; + DEXP(T0,T10,T2); + T4 = 1 / NVtmf; + dT10_dVb = T4 * T2; + if (selfheat) + dT10_dT = - T4 * T2 * Vbd / NVtmf * dNVtmf_dT ; + else dT10_dT = 0.0; + + if ((pParam->B3SOIvrec0 - Vbd) < 1e-3) { + + /* v2.2.3 bug fix */ + T1 = 1e3; + T0 = -Vbd / NVtmr * pParam->B3SOIvrec0 * T1; + T11 = -exp(T0); + + dT11_dVb = dT11_dT = 0; + } + else { + T1 = 1 / (pParam->B3SOIvrec0 - Vbd); + T0 = -Vbd / NVtmr * pParam->B3SOIvrec0 * T1; + dT0_dVb = -pParam->B3SOIvrec0 / NVtmr * (T1 + Vbd * 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 * jrec; + 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) * djrec_dT; + else + dIbd2_dT = 0; + } + + /* Ibs3/Ibd3: recombination current in neutral body */ + WTsi = pParam->B3SOIweff / here->B3SOInseg * model->B3SOItsi; + if (jbjt == 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->B3SOIic = Ic = Gcd = Gcb = GcT = 0.0; + } + else { + Ien = WTsi * jbjt * pParam->B3SOIlratio; + if (selfheat) + dIen_dT = WTsi * djbjt_dT * pParam->B3SOIlratio; + else + dIen_dT = 0; + + /* high level injection of source side */ + if ((Ehlis = Ahli * (ExpVbsNVtm - 1)) < 1e-5) { + Ehlis = dEhlis_dVb = dEhlis_dT = 0; + EhlisFactor = 1; + dEhlisFactor_dVb = dEhlisFactor_dT = 0; + } + else { + dEhlis_dVb = Ahli * dExpVbsNVtm_dVb; + if (selfheat) + dEhlis_dT = Ahli * dExpVbsNVtm_dT + (ExpVbsNVtm - 1) * dAhli_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 = Ahli * (ExpVbdNVtm - 1)) < 1e-5) { + Ehlid = dEhlid_dVb = dEhlid_dVd = dEhlid_dT = 0; + EhlidFactor = 1; + dEhlidFactor_dVb = dEhlidFactor_dVd = dEhlidFactor_dT = 0; + } + else { + dEhlid_dVb = Ahli * dExpVbdNVtm_dVb; + dEhlid_dVd = -dEhlid_dVb; + if (selfheat) + dEhlid_dT = Ahli * dExpVbdNVtm_dT + (ExpVbdNVtm - 1) * dAhli_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; + } + + if ((T0 = (1 - pParam->B3SOIarfabjt)) < 1e-2) { + Ibs3 = dIbs3_dVb = dIbs3_dT = 0; + + dIbs3_dVd = 0; + + Ibd3 = dIbd3_dVb = dIbd3_dVd = dIbd3_dT = 0; + } + else { + 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; + + 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 * jbjt * pParam->B3SOIlratiodif; + if (selfheat) + dIendif_dT = WTsi * djbjt_dT * pParam->B3SOIlratiodif; + 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; + + 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->B3SOIbjtoff == 1) || (Vds == 0.0)) { + here->B3SOIic = Ic = Gcd = Gcb = GcT = 0.0; + } + else { + /* second order effects */ + T0 = 1 + (Vbs + Vbd) / pParam->B3SOIvearly; + dT0_dVb = 2.0 / pParam->B3SOIvearly; + dT0_dVd = -1.0 / pParam->B3SOIvearly; + + 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->B3SOIarfabjt * Ien; + if (selfheat) + dT0_dT = pParam->B3SOIarfabjt * dIen_dT; + else + dT0_dT = 0; + here->B3SOIic = 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 */ + NVtm2 = 0.026 * pParam->B3SOIntun; + if (jtun == 0) + { Ibs4 = Ibd4 = dIbs4_dVb = dIbs4_dT = dIbd4_dVb = dIbd4_dVd = dIbd4_dT = 0; + } else + { + if ((pParam->B3SOIvtun0 - Vbs) < 1e-3) + { + /* v2.2.3 bug fix */ + T1=1e3; + T0 = -Vbs / NVtm2 * pParam->B3SOIvtun0 * T1; + T1 = exp(T0); + T3 = WsTsi * jtun; + Ibs4 = T3 * (1- T1); + + dIbs4_dVb = dIbs4_dT = 0; + } + else { + T1 = 1 / (pParam->B3SOIvtun0 - Vbs); + T0 = -Vbs / NVtm2 * pParam->B3SOIvtun0 * T1; + dT0_dVb = -pParam->B3SOIvtun0 / NVtm2 * (T1 + Vbs * T1 * T1) ; + + DEXP(T0, T1, T2); + T3 = WsTsi * jtun; + Ibs4 = T3 * (1- T1); + dIbs4_dVb = -T3 * T2 * dT0_dVb; + if (selfheat) + dIbs4_dT = (1 - T1) * WsTsi * djtun_dT; + else dIbs4_dT = 0; + } + + if ((pParam->B3SOIvtun0 - Vbd) < 1e-3) { + + /* v2.2.3 bug fix */ + T1=1e3; + T0 = -Vbd / NVtm2 * pParam->B3SOIvtun0 * T1; + T1 = exp(T0); + T3 = WdTsi * jtun; + Ibd4 = T3 * (1- T1); + + dIbd4_dVb = dIbd4_dT = 0; + dIbd4_dVd = 0; + + } + else { + T1 = 1 / (pParam->B3SOIvtun0 - Vbd); + T0 = -Vbd / NVtm2 * pParam->B3SOIvtun0 * T1; + dT0_dVb = -pParam->B3SOIvtun0 / NVtm2 * (T1 + Vbd * T1 * T1) ; + + DEXP(T0, T1, T2); + T3 = WdTsi * jtun; + Ibd4 = T3 * (1- T1); + dIbd4_dVb = -T3 * T2 * dT0_dVb; + + dIbd4_dVd = -dIbd4_dVb; + + if (selfheat) + dIbd4_dT = (1 - T1) * WdTsi * djtun_dT; + else dIbd4_dT = 0; + } + } + + here->B3SOIitun = - Ibd3 - Ibd4; + here->B3SOIibs = Ibs = Ibs1 + Ibs2 + Ibs3 + Ibs4; + here->B3SOIibd = 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; + + +/* v3.0: gate-tunneling */ + if ((model->B3SOIigbMod != 0) || (model->B3SOIigcMod != 0)) { + Vgb = Vgs_eff - Vbs; + dVgb_dVg = dVgs_eff_dVg; + dVgb_dVb = -1; + + /* Calculate Vox first */ + Vfb = model->B3SOItype * pParam->B3SOIvth0 - phi - pParam->B3SOIk1eff * 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; +/* v3.0 */ + dT0_dVe = -dVgsteff_dVe - dVbseff_dVe; + + if (selfheat) + dT0_dT = -dVgsteff_dT - dVbseff_dT; /* v3.0 */ + + if (pParam->B3SOIk1eff == 0.0) { + Voxdepinv = dVoxdepinv_dVg = dVoxdepinv_dVd = dVoxdepinv_dVb + = dVoxdepinv_dT = 0.0; + } else { + if (T0 < 0.0) { + T1 = T0/pParam->B3SOIk1eff; + dT1_dVg = dT0_dVg/pParam->B3SOIk1eff; + dT1_dVd = dT0_dVd/pParam->B3SOIk1eff; + dT1_dVb = dT0_dVb/pParam->B3SOIk1eff; + dT1_dVe = dT0_dVe/pParam->B3SOIk1eff; /* v3.0 */ + if (selfheat) dT1_dT = dT0_dT/pParam->B3SOIk1eff; + } + else { + T1 = pParam->B3SOIk1eff/2*(-1 + sqrt(1 + + 4*T0/pParam->B3SOIk1eff/pParam->B3SOIk1eff)); + T2 = pParam->B3SOIk1eff/2 * + 0.5/sqrt(1 + 4*T0/pParam->B3SOIk1eff/pParam->B3SOIk1eff) * + 4/pParam->B3SOIk1eff/pParam->B3SOIk1eff; + 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->B3SOIigcMod) + { T0 = Vtm * pParam->B3SOInigc; + VxNVt = (Vgs_eff - model->B3SOItype * pParam->B3SOIvth0) / T0; /* Vth instead of Vth0 may be used */ + if (VxNVt > EXPL_THRESHOLD) + { Vaux = Vgs_eff - model->B3SOItype * pParam->B3SOIvth0; + 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->B3SOIAechvb; + T12 = pParam->B3SOIBechvb; + T3 = pParam->B3SOIaigc * pParam->B3SOIcigc + - pParam->B3SOIbigc; + T4 = pParam->B3SOIbigc * pParam->B3SOIcigc; + T5 = T12 * (pParam->B3SOIaigc + 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->B3SOIpigcd * Vds; + T8 = T7 * T7 + 2.0e-4; + dT8_dVd = -2.0 * pParam->B3SOIpigcd * 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->B3SOIpigcd; + } + + T0 = T8 * T8; + T1 = T9 - 1.0 + 1.0e-4; + T10 = (T1 - T7) / T8; + dT10_dVd = ((pParam->B3SOIpigcd + 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->B3SOIpigcd * 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->B3SOIIgcs = Igcs; + here->B3SOIgIgcsg = dIgcs_dVg; + here->B3SOIgIgcsd = dIgcs_dVd; + here->B3SOIgIgcsb = dIgcs_dVb * dVbseff_dVb; + here->B3SOIIgcd = Igcd; + here->B3SOIgIgcdg = dIgcd_dVg; + here->B3SOIgIgcdd = dIgcd_dVd; + here->B3SOIgIgcdb = dIgcd_dVb * dVbseff_dVb; + + + T0 = vgs - pParam->B3SOIvfbsd; + 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->B3SOIAechvbEdge; + T12 = pParam->B3SOIBechvbEdge; + T3 = pParam->B3SOIaigsd * pParam->B3SOIcigsd + - pParam->B3SOIbigsd; + T4 = pParam->B3SOIbigsd * pParam->B3SOIcigsd; + T5 = T12 * (pParam->B3SOIaigsd + 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->B3SOIvfbsd; + 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->B3SOIaigsd + 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->B3SOIIgs = Igs; + here->B3SOIgIgsg = dIgs_dVg; + here->B3SOIgIgss = dIgs_dVs; + here->B3SOIIgd = Igd; + here->B3SOIgIgdg = dIgd_dVg; + here->B3SOIgIgdd = dIgd_dVd; + } + else + { here->B3SOIIgcs = here->B3SOIgIgcsg = here->B3SOIgIgcsd + = here->B3SOIgIgcsb = 0.0; + here->B3SOIIgcd = here->B3SOIgIgcdg = here->B3SOIgIgcdd + = here->B3SOIgIgcdb = 0.0; + here->B3SOIIgs = here->B3SOIgIgsg = here->B3SOIgIgss = 0.0; + here->B3SOIIgd = here->B3SOIgIgdg = here->B3SOIgIgdd = 0.0; + } + + here->B3SOIgIgcss = -(here->B3SOIgIgcsg + here->B3SOIgIgcsd + + here->B3SOIgIgcsb); + here->B3SOIgIgcds = -(here->B3SOIgIgcdg + here->B3SOIgIgcdd + + here->B3SOIgIgcdb); + + + /* gate-body tunneling component */ + if (model->B3SOIigbMod) + { + OxideRatio = pParam->B3SOIoxideRatio; + + Vox = Voxdepinv; + /* Voxeff is Vox limited below Voxh */ + T0 = model->B3SOIvoxh; + T1 = T0 - Vox - model->B3SOIdeltavox; + T3 = sqrt(T1 * T1 + 4*model->B3SOIdeltavox * 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->B3SOIebg)/model->B3SOIvevb; + if (selfheat) + dT0_dT = dVox_dT /model->B3SOIvevb; + + DEXP(T0, T1, T2); /* T1=exp(T0), T2=dT1_dT0 */ + if (selfheat) + dT1_dT = T2 * dT0_dT; + + Vaux = model->B3SOIvevb * 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->B3SOIvgb1 != 0) { + T0 = 1 - Vox / model->B3SOIvgb1; + dT0_dVox = -1.0/model->B3SOIvgb1; + if (selfheat) + dT0_dT = -dVox_dT / model->B3SOIvgb1; + } 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->B3SOInseg; + + T2 = -3.1051e10 * model->B3SOItoxqm; + T3 = model->B3SOIalphaGB1; + T4 = model->B3SOIbetaGB1; + + 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->B3SOIvoxh; + T1 = T0 - Vox - model->B3SOIdeltavox; + T3 = sqrt(T1 * T1 + 4*model->B3SOIdeltavox * 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->B3SOIvecb; + if (selfheat) + dT0_dT = 0; + + DEXP(T0, T1, T2); /* T1=exp(T0), T2=dT1_dT0 */ + if (selfheat) + dT1_dT = 0; + + Vaux = model->B3SOIvecb* log(1 + T1); + dVaux_dVg = -T2 / (1 + T1); + dVaux_dVd = 0; + dVaux_dVb = -dVaux_dVg; + if (selfheat) + dVaux_dT = 0; + + if (model->B3SOIvgb2 != 0) { + T0 = 1 - Vox / model->B3SOIvgb2; + dT0_dVox = -1.0/model->B3SOIvgb2; + if (selfheat) dT0_dT = -dVox_dT / model->B3SOIvgb2; + } 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->B3SOInseg; + + T2 = -2.357e10 * model->B3SOItoxqm; + T3 = model->B3SOIalphaGB2; + T4 = model->B3SOIbetaGB2; + + 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->B3SOIig = Igb; + here->B3SOIgigg = dIgb_dVg; + here->B3SOIgigd = dIgb_dVd; + here->B3SOIgigb = dIgb_dVb; + here->B3SOIgige = dIgb_dVe; /* v3.0 */ + here->B3SOIgigs = -(dIgb_dVg + dIgb_dVd + dIgb_dVb + dIgb_dVe); /* v3.0 */ + here->B3SOIgigT = dIgb_dT; + /* end of gate-body tunneling */ +/* end of v3.0 gate-tunneling */ + + + +/* calculate substrate current Iii */ + + if (pParam->B3SOIalpha0 <= 0.0) { + Giig = Giib = Giid = GiiT = 0.0; + Giie = 0; /* v3.0 */ + here->B3SOIiii = Iii = 0.0; + } + else { + Vdsatii0 = pParam->B3SOIvdsatii0 * (1 + model->B3SOItii * (TempRatio-1.0)) + - pParam->B3SOIlii / Leff; + if (selfheat) + dVdsatii0_dT = pParam->B3SOIvdsatii0 * model->B3SOItii * dTempRatio_dT; + else + dVdsatii0_dT = 0; + + /* Calculate VgsStep */ + T0 = pParam->B3SOIesatii * Leff; /* v3.0 bug fix: T0 is dimentionless (i.e., scaled by 1V) */ + T1 = pParam->B3SOIsii0 * T0 / (1.0 + T0); + + T0 = 1 / (1 + pParam->B3SOIsii1 * Vgsteff); + if (selfheat) + dT0_dT = - pParam->B3SOIsii1 * T0 * T0 *dVgsteff_dT; + else + dT0_dT = 0; + T3 = T0 + pParam->B3SOIsii2; + T4 = Vgst * pParam->B3SOIsii1 * 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->B3SOIsiid * Vds); + dT3_dVd = - pParam->B3SOIsiid * 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->B3SOIbeta2 + pParam->B3SOIbeta1 * Vdiff + + pParam->B3SOIbeta0 * 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->B3SOIbeta1 + 2 * pParam->B3SOIbeta0 * 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->B3SOIalpha0 * 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->B3SOIalpha0 * MIN_EXPL; + dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0; + dRatio_dVe = 0; /* v3.0 */ + } + else { + Ratio = pParam->B3SOIalpha0 * 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->B3SOIfbjtii * Ic; + here->B3SOIiii = Iii = Ratio * T0; + Giig = Ratio * Gm + T0 * dRatio_dVg; + Giib = Ratio * (Gmb + pParam->B3SOIfbjtii * Gcb) + + T0 * dRatio_dVb; + Giid = Ratio * (Gds + pParam->B3SOIfbjtii * Gcd) + + T0 * dRatio_dVd; +/* v3.0 */ + Giie = Ratio * Gme + T0 * dRatio_dVe; + + if (selfheat) + GiiT = Ratio * (GmT + pParam->B3SOIfbjtii * GcT) + + T0 * dRatio_dT; + else + GiiT = 0.0; + + } + + + /* Current through body resistor */ + /* Current going out is +ve */ + if ((here->B3SOIbodyMod == 0) || (here->B3SOIbodyMod == 2)) + { + Ibp = Gbpbs = Gbpps = 0.0; + } + else { /* here->B3SOIbodyMod == 1 */ + if (pParam->B3SOIrbody < 1e-30) + { + if (here->B3SOIrbodyext <= 1e-30) + T0 = 1.0 / 1e-30; + else + T0 = 1.0 / here->B3SOIrbodyext; + Ibp = Vbp * T0; + Gbpbs = T0 * dVbp_dVb; + Gbpps = -T0 * dVbp_dVb; + } else + { + Gbpbs = 1.0 / (pParam->B3SOIrbody + here->B3SOIrbodyext); + Ibp = Vbp * Gbpbs; + Gbpps = - Gbpbs; + } + } + + here->B3SOIibp = Ibp; + here->B3SOIgbpbs = Gbpbs; + here->B3SOIgbpps = Gbpps; + here->B3SOIgbpT = 0.0; + here->B3SOIcbodcon = Ibp - (Gbpbs * Vbs + Gbpps * Vps); + + + + /* Current going out of drainprime node into the drain of device */ + /* "node" means the SPICE circuit node */ + + here->B3SOIcdrain = Ids + Ic; + here->B3SOIcd = Ids + Ic - Ibd + Iii + Idgidl; + here->B3SOIcb = Ibs + Ibd + Ibp - Iii - Idgidl - Isgidl - Igb; + + here->B3SOIgds = Gds + Gcd; + here->B3SOIgm = Gm; + here->B3SOIgmbs = Gmb + Gcb; +/* v3.0 */ + here->B3SOIgme = Gme; + + if (selfheat) + here->B3SOIgmT = GmT + GcT; + else + here->B3SOIgmT = 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->B3SOIgtempg = -Gm * Vds; + here->B3SOIgtempb = -Gmb * Vds; +/* v3.0 */ + here->B3SOIgtempe = -Gme * Vds; + + here->B3SOIgtempT = -GmT * Vds; + here->B3SOIgtempd = -Gds * Vds - Ids; + here->B3SOIcth = - Ids * Vds - model->B3SOItype * + (here->B3SOIgtempg * Vgs + here->B3SOIgtempb * Vbs + + here->B3SOIgtempe * Ves + + here->B3SOIgtempd * Vds) + - here->B3SOIgtempT * delTemp; /* v3.0 */ + + /* Body current which flows into drainprime node from the drain of device */ + + here->B3SOIgjdb = Gjdb - Giib; + here->B3SOIgjdd = Gjdd - (Giid + Gdgidld); + here->B3SOIgjdg = - (Giig + Gdgidlg); +/* v3.0 */ + here->B3SOIgjde = - Giie; + + if (selfheat) here->B3SOIgjdT = GjdT - GiiT; + else here->B3SOIgjdT = 0.0; + here->B3SOIcjd = Ibd - Iii - Idgidl + - (here->B3SOIgjdb * Vbs + here->B3SOIgjdd * Vds + + here->B3SOIgjdg * Vgs + here->B3SOIgjde * Ves + + here->B3SOIgjdT * delTemp); /* v3.0 */ + + /* Body current which flows into sourceprime node from the source of device */ + + here->B3SOIgjsb = Gjsb; + here->B3SOIgjsd = Gjsd; + here->B3SOIgjsg = - Gsgidlg; + if (selfheat) here->B3SOIgjsT = GjsT; + else here->B3SOIgjsT = 0.0; + here->B3SOIcjs = Ibs - Isgidl + - (here->B3SOIgjsb * Vbs + here->B3SOIgjsd * Vds + + here->B3SOIgjsg * Vgs + here->B3SOIgjsT * delTemp); + + /* Current flowing into body node */ + + here->B3SOIgbbs = Giib - Gjsb - Gjdb - Gbpbs; + here->B3SOIgbgs = Giig + Gdgidlg + Gsgidlg; + here->B3SOIgbds = Giid + Gdgidld - Gjsd - Gjdd; +/* v3.0 */ + here->B3SOIgbes = Giie; + + here->B3SOIgbps = - Gbpps; + if (selfheat) here->B3SOIgbT = GiiT - GjsT - GjdT; + else here->B3SOIgbT = 0.0; + + + here->B3SOIcbody = Iii + Idgidl + Isgidl - Ibs - Ibd - Ibp + Igb + - ( (here->B3SOIgbbs + dIgb_dVb) * Vbs + + (here->B3SOIgbgs + dIgb_dVg) * Vgs + + (here->B3SOIgbds + dIgb_dVd) * Vds + + here->B3SOIgbps * Vps + + (here->B3SOIgbes + dIgb_dVe) * Ves + + (here->B3SOIgbT + dIgb_dT) * delTemp); /* v3.0 */ + + + here->B3SOIcgate = 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->B3SOIqinv = -model->B3SOIcox * pParam->B3SOIweff * Leff * T1; + + + /* Begin CV (charge) model */ + + if ((model->B3SOIxpart < 0) || (!ChargeComputationNeeded)) + { qgate = qdrn = qsrc = qbody = qsub = 0.0; /* v2.2.3 bug fix */ + here->B3SOIcggb = here->B3SOIcgsb = here->B3SOIcgdb = 0.0; + here->B3SOIcdgb = here->B3SOIcdsb = here->B3SOIcddb = 0.0; + here->B3SOIcbgb = here->B3SOIcbsb = here->B3SOIcbdb = 0.0; + goto finished; + } + else + { + CoxWL = model->B3SOIcox * (pParam->B3SOIweffCV / here->B3SOInseg + * pParam->B3SOIleffCV + here->B3SOIagbcp); + CoxWLb = model->B3SOIfbody * model->B3SOIcox + * (pParam->B3SOIweffCV / here->B3SOInseg + * pParam->B3SOIleffCVb + here->B3SOIagbcp); + + /* By using this Vgsteff,cv, discontinuity in moderate + inversion charges can be avoid. */ + + if ((VgstNVt > -EXPL_THRESHOLD) && (VgstNVt < EXPL_THRESHOLD)) + { ExpVgst *= ExpVgst; + ExpVgst *= exp( -(pParam->B3SOIdelvt / (n * Vtm))); + Vgsteff = n * Vtm * log(1.0 + ExpVgst); + T0 = ExpVgst / (1.0 + ExpVgst); + T1 = -T0 * (dVth_dVb + (Vgst-pParam->B3SOIdelvt) / n * dn_dVb) + + Vgsteff / n * dn_dVb; /* v3.0 bug fix */ + dVgsteff_dVd = -T0 * (dVth_dVd + dVth_dVb*dVbseff_dVd + Vgst / n * dn_dVd) + + Vgsteff / n * dn_dVd; /* v3.0 */ + dVgsteff_dVg = T0 * (dVgs_eff_dVg - dVth_dVb*dVbseff_dVg); /* v3.0 */ + dVgsteff_dVb = T1 * dVbseff_dVb; + dVgsteff_dVe = T1 * dVbseff_dVe; /* v3.0 */ + if (selfheat) + dVgsteff_dT = -T0 * (dVth_dT+dVth_dVb*dVbseff_dT + + (Vgst - pParam->B3SOIdelvt) / Temp) + + Vgsteff / Temp; /* v3.0 */ + else dVgsteff_dT = 0.0; + + } + + + if (model->B3SOIcapMod == 2) + { + Vfb = Vth - phi - pParam->B3SOIk1eff * sqrtPhis + pParam->B3SOIdelvt; + dVfb_dVb = dVth_dVb - pParam->B3SOIk1eff * 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 * K1; + T3 = Vgs_eff - Vfbeff - Vbseff - Vgsteff; + if (pParam->B3SOIk1eff == 0.0) + { T1 = 0.0; + T2 = 0.0; + } + else if (T3 < 0.0) + { T1 = T0 + T3 / pParam->B3SOIk1eff; + 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; + + AbulkCV = Abulk0 * pParam->B3SOIabulkCVfactor; + dAbulkCV_dVb = pParam->B3SOIabulkCVfactor * 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; + + 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); + + /* Total inversion charge */ + 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; + + qinv = CoxWL * (Vgsteff - 0.5 * VdseffCV + T3); + 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->B3SOIxpart > 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->B3SOIxpart < 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 */ + CboxWL = pParam->B3SOIkb1 * model->B3SOIfbody * Cbox + * (pParam->B3SOIweffCV / here->B3SOInseg + * pParam->B3SOIleffCVbg + here->B3SOIaebcp); + Qe1 = CboxWL * (Vesfb - Vbs); + dQe1_dVb = -CboxWL; + dQe1_dVe = CboxWL; + if (selfheat) dQe1_dT = -CboxWL * dvfbb_dT; + else dQe1_dT = 0; + + 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->B3SOIcggb = Cgg ; + here->B3SOIcgsb = - (Cgg + Cgd + Cgb); + here->B3SOIcgdb = Cgd; + here->B3SOIcgT = CgT; + + here->B3SOIcbgb = Cbg; + here->B3SOIcbsb = -(Cbg + Cbd + Cbb) + + Ce1e; + here->B3SOIcbdb = Cbd; + here->B3SOIcbeb = - Ce1e ; + here->B3SOIcbT = CbT; + + here->B3SOIceeb = Ce1e ; + here->B3SOIceT = dQe1_dT; + + here->B3SOIcdgb = -(Cgg + Cbg + Csg); + here->B3SOIcddb = -(Cgd + Cbd + Csd); + here->B3SOIcdeb = 0; + here->B3SOIcdT = -(CgT + CbT + CsT) - dQe1_dT; + here->B3SOIcdsb = (Cgg + Cgd + Cgb + + Cbg + Cbd + Cbb + + Csg + Csd + Csb) + Ce1b; + } /* End of if capMod == 2 */ + + else if (model->B3SOIcapMod == 3) + { + dVgsteff_dVb /= dVbseff_dVb; + + if (selfheat) { + Vfbzb = Vthzb - phi - pParam->B3SOIk1eff * sqrtPhi + + pParam->B3SOIdelvt; + dVfbzb_dT = dVthzb_dT; + } + else { + Vfbzb = pParam->B3SOIvfbzb + pParam->B3SOIdelvt; + 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; + +/* v2.2.3 */ + Cox = 3.453133e-11 / (model->B3SOItox - model->B3SOIdtoxcv); + CoxWL *= model->B3SOItox/ (model->B3SOItox - model->B3SOIdtoxcv); + CoxWLb *= model->B3SOItox/ (model->B3SOItox - model->B3SOIdtoxcv); + Tox = 1.0e8 * (model->B3SOItox - model->B3SOIdtoxcv); + + T0 = (Vgs_eff - Vbseff - Vfbzb) / Tox; + dT0_dVg = dVgs_eff_dVg / Tox; + dT0_dVb = -1.0 / Tox; + + tmp = T0 * pParam->B3SOIacde; + if ((-EXPL_THRESHOLD < tmp) && (tmp < EXPL_THRESHOLD)) + { Tcen = pParam->B3SOIldeb * exp(tmp); + dTcen_dVg = pParam->B3SOIacde * Tcen; + dTcen_dVb = dTcen_dVg * dT0_dVb; + dTcen_dVg *= dT0_dVg; + if (selfheat) + dTcen_dT = -Tcen * pParam->B3SOIacde * dVfbzb_dT / Tox; + else dTcen_dT = 0; + } + else if (tmp <= -EXPL_THRESHOLD) + { Tcen = pParam->B3SOIldeb * MIN_EXPL; + dTcen_dVg = dTcen_dVb = dTcen_dT = 0.0; + } + else + { Tcen = pParam->B3SOIldeb * MAX_EXPL; + dTcen_dVg = dTcen_dVb = dTcen_dT = 0.0; + } + + LINK = 1.0e-3 * (model->B3SOItox - model->B3SOIdtoxcv); /* v2.2.3 */ + V3 = pParam->B3SOIldeb - Tcen - LINK; + V4 = sqrt(V3 * V3 + 4.0 * LINK * pParam->B3SOIldeb); + Tcen = pParam->B3SOIldeb - 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->B3SOIk1eff; + T3 = Vgs_eff - Vfbeff - Vbseff - Vgsteff; + if (pParam->B3SOIk1eff == 0.0) + { T1 = 0.0; + T2 = 0.0; + } + else if (T3 < 0.0) + { T1 = T0 + T3 / pParam->B3SOIk1eff; + T2 = CoxWLcenb; + } + else + { T1 = sqrt(T0 * T0 + T3); + T2 = CoxWLcenb * T0 / T1; + } + + Qsub0 = CoxWLcenb * pParam->B3SOIk1eff * (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->B3SOIk1eff * (T1 - T0); + else dQsub0_dT = 0.0; + + /* Gate-bias dependent delta Phis begins */ + if (pParam->B3SOIk1eff <= 0.0) + { Denomi = 0.25 * pParam->B3SOImoin * Vtm; + T0 = 0.5 * pParam->B3SOIsqrtPhi; + } + else + { Denomi = pParam->B3SOImoin * Vtm + * pParam->B3SOIk1eff * pParam->B3SOIk1eff; + T0 = pParam->B3SOIk1eff * pParam->B3SOIsqrtPhi; + } + 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 */ + + T3 = 4.0 * (Vth - Vfbzb - phi); + Tox += Tox; + if ((T0 = (Vgsteff + T3) / Tox) > 1e-20) { + tmp = exp(0.7 * log(T0)); + T1 = 1.0 + tmp; + T2 = 0.7 * tmp / (T0 * Tox); + Tcen = 1.9e-9 / T1; + dTcen_dVg = -1.9e-9 * T2 / T1 /T1; + dTcen_dVd = dTcen_dVg * (4.0 * dVth_dVd + dVgsteff_dVd); + dTcen_dVb = dTcen_dVg * (4.0 * dVth_dVb + dVgsteff_dVb); + dTcen_dVg *= dVgsteff_dVg; + if (selfheat) + dTcen_dT = -Tcen * T2 / T1 + * (4.0 * (dVth_dT - dVfbzb_dT) + dVgsteff_dT); + else dTcen_dT = 0; + } + else { + T0 = 1e-20; + tmp = exp(0.7 * log(T0)); + T1 = 1.0 + tmp; + T2 = 0.7 * tmp / (T0 * Tox); + Tcen = 1.9e-9 / T1; + dTcen_dVg = 0; + dTcen_dVd = 0; + dTcen_dVb = 0; + 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->B3SOIabulkCVfactor; + dAbulkCV_dVb = pParam->B3SOIabulkCVfactor * 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; + + 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; + + if (model->B3SOIxpart > 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->B3SOIxpart < 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 */ + CboxWL = pParam->B3SOIkb1 * model->B3SOIfbody * Cbox + * (pParam->B3SOIweffCV / here->B3SOInseg + * pParam->B3SOIleffCVbg + here->B3SOIaebcp); + 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; + + 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->B3SOIcggb = Cgg; + here->B3SOIcgsb = -(Cgg + Cgd + Cgb); + here->B3SOIcgdb = Cgd; + here->B3SOIcgT = CgT; + + here->B3SOIcbgb = Cbg; + here->B3SOIcbsb = -(Cbg + Cbd + Cbb) + + Ce1e; + here->B3SOIcbdb = Cbd; + here->B3SOIcbeb = -Ce1e; + here->B3SOIcbT = CbT; + + here->B3SOIceT = Ce1T; + here->B3SOIceeb = Ce1e ; + + here->B3SOIcdgb = -(Cgg + Cbg + Csg); + here->B3SOIcddb = -(Cgd + Cbd + Csd); + here->B3SOIcdeb = 0; + here->B3SOIcdT = -(CgT+CbT+CsT) - Ce1T; + here->B3SOIcdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb + + Csg + Csd + Csb) + Ce1b; + here->B3SOIqinv = -qinoi; + + } /* End of if capMod ==3 */ + } + + + finished: /* returning Values to Calling Routine */ + /* + * COMPUTE EQUIVALENT DRAIN CURRENT SOURCE + */ + if (ChargeComputationNeeded) + { + /* Intrinsic S/D junction charge */ + PhiBSWG = model->B3SOIGatesidewallJctPotential; + dPhiBSWG_dT = -model->B3SOItpbswg; + PhiBSWG += dPhiBSWG_dT * (Temp - model->B3SOItnom); + MJSWG = model->B3SOIbodyJctGateSideGradingCoeff; + + cjsbs = model->B3SOIunitLengthGateSidewallJctCap + * wdiosCV * model->B3SOItsi / 1e-7; + dcjsbs_dT = cjsbs * model->B3SOItcjswg; + cjsbs += dcjsbs_dT * (Temp - model->B3SOItnom); + + cjdbs = model->B3SOIunitLengthGateSidewallJctCap + * wdiodCV * model->B3SOItsi / 1e-7; + dcjdbs_dT = cjdbs * model->B3SOItcjswg; + cjdbs += dcjdbs_dT * (Temp - model->B3SOItnom); + + 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->B3SOItt * Ibsdif; + gcjsbs = cjsbs * dT3_dVb + model->B3SOItt * dIbsdif_dVb; + + if (selfheat) + gcjsT = model->B3SOItt * dIbsdif_dT + dcjsbs_dT * T3 + dT3_dT * cjsbs; + else gcjsT = 0.0; + + + 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->B3SOItt * Ibddif; + gcjdbs = cjdbs * dT3_dVb + model->B3SOItt * dIbddif_dVb; + gcjdds = cjdbs * dT3_dVd + model->B3SOItt * dIbddif_dVd; + + if (selfheat) + gcjdT = model->B3SOItt * dIbddif_dT + dcjdbs_dT * T3 + dT3_dT * cjdbs; + else gcjdT = 0.0; + + + qdrn -= qjd; + qbody += (qjs + qjd); + qsrc = -(qgate + qbody + qdrn + qsub); + + /* Update the conductance */ + here->B3SOIcddb -= gcjdds; + here->B3SOIcdT -= gcjdT; + here->B3SOIcdsb += gcjdds + gcjdbs; + + here->B3SOIcbdb += (gcjdds); + here->B3SOIcbT += (gcjdT + gcjsT); + here->B3SOIcbsb -= (gcjdds + gcjdbs + gcjsbs); + + + /* Extrinsic Bottom S/D to substrate charge */ + T10 = -model->B3SOItype * ves; + /* T10 is vse without type conversion */ + T11 = model->B3SOItype * (vds - ves); + /* T11 is vde without type conversion */ + + if (model->B3SOIcsdmin != 0.0) + { + if ( ((pParam->B3SOInsub > 0) && (model->B3SOItype > 0)) || + ((pParam->B3SOInsub < 0) && (model->B3SOItype < 0)) ) + { + if (T10 < pParam->B3SOIvsdfb) + { here->B3SOIqse = here->B3SOIcsbox * (T10 - pParam->B3SOIvsdfb); + here->B3SOIgcse = here->B3SOIcsbox; + } + else if (T10 < pParam->B3SOIsdt1) + { T0 = T10 - pParam->B3SOIvsdfb; + T1 = T0 * T0; + here->B3SOIqse = T0 * (here->B3SOIcsbox - + pParam->B3SOIst2 / 3 * T1) ; + here->B3SOIgcse = here->B3SOIcsbox - pParam->B3SOIst2 * T1; + } + else if (T10 < pParam->B3SOIvsdth) + { T0 = T10 - pParam->B3SOIvsdth; + T1 = T0 * T0; + here->B3SOIqse = here->B3SOIcsmin * T10 + here->B3SOIst4 + + pParam->B3SOIst3 / 3 * T0 * T1; + here->B3SOIgcse = here->B3SOIcsmin + pParam->B3SOIst3 * T1; + } + else + { here->B3SOIqse = here->B3SOIcsmin * T10 + here->B3SOIst4; + here->B3SOIgcse = here->B3SOIcsmin; + } + } else + { + if (T10 < pParam->B3SOIvsdth) + { here->B3SOIqse = here->B3SOIcsmin * (T10 - pParam->B3SOIvsdth); + here->B3SOIgcse = here->B3SOIcsmin; + } + else if (T10 < pParam->B3SOIsdt1) + { T0 = T10 - pParam->B3SOIvsdth; + T1 = T0 * T0; + here->B3SOIqse = T0 * (here->B3SOIcsmin - pParam->B3SOIst2 / 3 * T1) ; + here->B3SOIgcse = here->B3SOIcsmin - pParam->B3SOIst2 * T1; + } + else if (T10 < pParam->B3SOIvsdfb) + { T0 = T10 - pParam->B3SOIvsdfb; + T1 = T0 * T0; + here->B3SOIqse = here->B3SOIcsbox * T10 + here->B3SOIst4 + + pParam->B3SOIst3 / 3 * T0 * T1; + here->B3SOIgcse = here->B3SOIcsbox + pParam->B3SOIst3 * T1; + } + else + { here->B3SOIqse = here->B3SOIcsbox * T10 + here->B3SOIst4; + here->B3SOIgcse = here->B3SOIcsbox; + } + } + + if ( ((pParam->B3SOInsub > 0) && (model->B3SOItype > 0)) || + ((pParam->B3SOInsub < 0) && (model->B3SOItype < 0)) ) + { + if (T11 < pParam->B3SOIvsdfb) + { here->B3SOIqde = here->B3SOIcdbox * (T11 - pParam->B3SOIvsdfb); + here->B3SOIgcde = here->B3SOIcdbox; + } + else if (T11 < pParam->B3SOIsdt1) + { T0 = T11 - pParam->B3SOIvsdfb; + T1 = T0 * T0; + here->B3SOIqde = T0 * (here->B3SOIcdbox - pParam->B3SOIdt2 / 3 * T1) ; + here->B3SOIgcde = here->B3SOIcdbox - pParam->B3SOIdt2 * T1; + } + else if (T11 < pParam->B3SOIvsdth) + { T0 = T11 - pParam->B3SOIvsdth; + T1 = T0 * T0; + here->B3SOIqde = here->B3SOIcdmin * T11 + here->B3SOIdt4 + + pParam->B3SOIdt3 / 3 * T0 * T1; + here->B3SOIgcde = here->B3SOIcdmin + pParam->B3SOIdt3 * T1; + } + else + { here->B3SOIqde = here->B3SOIcdmin * T11 + here->B3SOIdt4; + here->B3SOIgcde = here->B3SOIcdmin; + } + } else + { + if (T11 < pParam->B3SOIvsdth) + { here->B3SOIqde = here->B3SOIcdmin * (T11 - pParam->B3SOIvsdth); + here->B3SOIgcde = here->B3SOIcdmin; + } + else if (T11 < pParam->B3SOIsdt1) + { T0 = T11 - pParam->B3SOIvsdth; + T1 = T0 * T0; + here->B3SOIqde = T0 * (here->B3SOIcdmin - pParam->B3SOIdt2 / 3 * T1) ; + here->B3SOIgcde = here->B3SOIcdmin - pParam->B3SOIdt2 * T1; + } + else if (T11 < pParam->B3SOIvsdfb) + { T0 = T11 - pParam->B3SOIvsdfb; + T1 = T0 * T0; + here->B3SOIqde = here->B3SOIcdbox * T11 + here->B3SOIdt4 + + pParam->B3SOIdt3 / 3 * T0 * T1; + here->B3SOIgcde = here->B3SOIcdbox + pParam->B3SOIdt3 * T1; + } + else + { here->B3SOIqde = here->B3SOIcdbox * T11 + here->B3SOIdt4; + here->B3SOIgcde = here->B3SOIcdbox; + } + } + } + else { + here->B3SOIqse = here->B3SOIcsbox * T10; + here->B3SOIgcse = here->B3SOIcsbox; + here->B3SOIqde = here->B3SOIcdbox * T11; + here->B3SOIgcde = here->B3SOIcdbox; + } + + /* Extrinsic : Sidewall fringing S/D charge */ + here->B3SOIqse += here->B3SOIcsesw * T10; + here->B3SOIgcse += here->B3SOIcsesw; + here->B3SOIqde += here->B3SOIcdesw * T11; + here->B3SOIgcde += here->B3SOIcdesw; + + /* All charge are mutliplied with type at the end, but qse and qde + have true polarity => so pre-mutliplied with type */ + here->B3SOIqse *= model->B3SOItype; + here->B3SOIqde *= model->B3SOItype; + } + + + here->B3SOIcbb = Cbb; + here->B3SOIcbd = Cbd; + here->B3SOIcbg = Cbg; + here->B3SOIqbf = -Qsub0 - Qac0; + here->B3SOIqjs = qjs; + here->B3SOIqjd = qjd; + + /* + * check convergence + */ + if ((here->B3SOIoff == 0) || (!(ckt->CKTmode & MODEINITFIX))) + { if (Check == 1) + { ckt->CKTnoncon++; + } + } + + *(ckt->CKTstate0 + here->B3SOIvg) = vg; + *(ckt->CKTstate0 + here->B3SOIvd) = vd; + *(ckt->CKTstate0 + here->B3SOIvs) = vs; + *(ckt->CKTstate0 + here->B3SOIvp) = vp; + *(ckt->CKTstate0 + here->B3SOIve) = ve; + + *(ckt->CKTstate0 + here->B3SOIvbs) = vbs; + *(ckt->CKTstate0 + here->B3SOIvbd) = vbd; + *(ckt->CKTstate0 + here->B3SOIvgs) = vgs; + *(ckt->CKTstate0 + here->B3SOIvds) = vds; + *(ckt->CKTstate0 + here->B3SOIves) = ves; + *(ckt->CKTstate0 + here->B3SOIvps) = vps; + *(ckt->CKTstate0 + here->B3SOIdeltemp) = delTemp; + + /* bulk and channel charge plus overlaps */ + + if (!ChargeComputationNeeded) + goto line850; + + line755: + ag0 = ckt->CKTag[0]; + + T0 = vgd + DELTA_1; + T1 = sqrt(T0 * T0 + 4.0 * DELTA_1); + T2 = 0.5 * (T0 - T1); + +/* v2.2.3 bug fix */ + T3 = pParam->B3SOIwdiodCV * pParam->B3SOIcgdl; + + T4 = sqrt(1.0 - 4.0 * T2 / pParam->B3SOIckappa); + cgdo = pParam->B3SOIcgdo + T3 - T3 * (1.0 - 1.0 / T4) + * (0.5 - 0.5 * T0 / T1); + qgdo = (pParam->B3SOIcgdo + T3) * vgd - T3 * (T2 + + 0.5 * pParam->B3SOIckappa * (T4 - 1.0)); + + T0 = vgs + DELTA_1; + T1 = sqrt(T0 * T0 + 4.0 * DELTA_1); + T2 = 0.5 * (T0 - T1); + +/* v2.2.3 bug fix */ + T3 = pParam->B3SOIwdiosCV * pParam->B3SOIcgsl; + + T4 = sqrt(1.0 - 4.0 * T2 / pParam->B3SOIckappa); + cgso = pParam->B3SOIcgso + T3 - T3 * (1.0 - 1.0 / T4) + * (0.5 - 0.5 * T0 / T1); + qgso = (pParam->B3SOIcgso + T3) * vgs - T3 * (T2 + + 0.5 * pParam->B3SOIckappa * (T4 - 1.0)); + + + + if (here->B3SOIdebugMod < 0) + goto line850; + + + if (here->B3SOImode > 0) + { gcdgb = (here->B3SOIcdgb - cgdo) * ag0; + gcddb = (here->B3SOIcddb + cgdo + here->B3SOIgcde) * ag0; + gcdsb = here->B3SOIcdsb * ag0; + gcdeb = (here->B3SOIcdeb - here->B3SOIgcde) * ag0; + gcdT = model->B3SOItype * here->B3SOIcdT * ag0; + + gcsgb = -(here->B3SOIcggb + here->B3SOIcbgb + here->B3SOIcdgb + + cgso) * ag0; + gcsdb = -(here->B3SOIcgdb + here->B3SOIcbdb + here->B3SOIcddb) * ag0; + gcssb = (cgso + here->B3SOIgcse - (here->B3SOIcgsb + here->B3SOIcbsb + + here->B3SOIcdsb)) * ag0; + gcseb = -(here->B3SOIgcse + here->B3SOIcbeb + here->B3SOIcdeb + + here->B3SOIceeb) * ag0; + gcsT = - model->B3SOItype * (here->B3SOIcgT + here->B3SOIcbT + here->B3SOIcdT + + here->B3SOIceT) * ag0; + + gcggb = (here->B3SOIcggb + cgdo + cgso + pParam->B3SOIcgeo) * ag0; + gcgdb = (here->B3SOIcgdb - cgdo) * ag0; + gcgsb = (here->B3SOIcgsb - cgso) * ag0; + gcgeb = (- pParam->B3SOIcgeo) * ag0; + gcgT = model->B3SOItype * here->B3SOIcgT * ag0; + + gcbgb = here->B3SOIcbgb * ag0; + gcbdb = here->B3SOIcbdb * ag0; + gcbsb = here->B3SOIcbsb * ag0; + gcbeb = here->B3SOIcbeb * ag0; + gcbT = model->B3SOItype * here->B3SOIcbT * ag0; + + gcegb = (- pParam->B3SOIcgeo) * ag0; + gcedb = (- here->B3SOIgcde) * ag0; + gcesb = (- here->B3SOIgcse) * ag0; + gceeb = (here->B3SOIgcse + here->B3SOIgcde + + here->B3SOIceeb + pParam->B3SOIcgeo) * ag0; + + gceT = model->B3SOItype * here->B3SOIceT * ag0; + + gcTt = pParam->B3SOIcth * ag0; + + sxpart = 0.6; + dxpart = 0.4; + + /* Lump the overlap capacitance and S/D parasitics */ + qgd = qgdo; + qgs = qgso; + qge = pParam->B3SOIcgeo * vge; + qgate += qgd + qgs + qge; + qdrn += here->B3SOIqde - qgd; + qsub -= qge + here->B3SOIqse + here->B3SOIqde; + qsrc = -(qgate + qbody + qdrn + qsub); + } + else + { gcsgb = (here->B3SOIcdgb - cgso) * ag0; + gcssb = (here->B3SOIcddb + cgso + here->B3SOIgcse) * ag0; + gcsdb = here->B3SOIcdsb * ag0; + gcseb = (here->B3SOIcdeb - here->B3SOIgcse) * ag0; + gcsT = model->B3SOItype * here->B3SOIcdT * ag0; + + gcdgb = -(here->B3SOIcggb + here->B3SOIcbgb + here->B3SOIcdgb + + cgdo) * ag0; + gcdsb = -(here->B3SOIcgdb + here->B3SOIcbdb + here->B3SOIcddb) * ag0; + gcddb = (cgdo + here->B3SOIgcde - (here->B3SOIcgsb + here->B3SOIcbsb + + here->B3SOIcdsb)) * ag0; + gcdeb = -(here->B3SOIgcde + here->B3SOIcbeb + here->B3SOIcdeb + + here->B3SOIceeb) * ag0; + gcdT = - model->B3SOItype * (here->B3SOIcgT + here->B3SOIcbT + + here->B3SOIcdT + here->B3SOIceT) * ag0; + + gcggb = (here->B3SOIcggb + cgdo + cgso + pParam->B3SOIcgeo) * ag0; + gcgsb = (here->B3SOIcgdb - cgso) * ag0; + gcgdb = (here->B3SOIcgsb - cgdo) * ag0; + gcgeb = (- pParam->B3SOIcgeo) * ag0; + gcgT = model->B3SOItype * here->B3SOIcgT * ag0; + + gcbgb = here->B3SOIcbgb * ag0; + gcbsb = here->B3SOIcbdb * ag0; + gcbdb = here->B3SOIcbsb * ag0; + gcbeb = here->B3SOIcbeb * ag0; + gcbT = model->B3SOItype * here->B3SOIcbT * ag0; + + gcegb = (-pParam->B3SOIcgeo) * ag0; + gcesb = (- here->B3SOIgcse) * ag0; + gcedb = (- here->B3SOIgcde) * ag0; + gceeb = (here->B3SOIceeb + pParam->B3SOIcgeo + + here->B3SOIgcse + here->B3SOIgcde) * ag0; + gceT = model->B3SOItype * here->B3SOIceT * ag0; + + gcTt = pParam->B3SOIcth * ag0; + + dxpart = 0.6; + sxpart = 0.4; + + /* Lump the overlap capacitance */ + qgd = qgdo; + qgs = qgso; + qge = pParam->B3SOIcgeo * vge; + qgate += qgd + qgs + qge; + qsrc = qdrn - qgs + here->B3SOIqse; + qsub -= qge + here->B3SOIqse + here->B3SOIqde; + qdrn = -(qgate + qbody + qsrc + qsub); + } + + here->B3SOIcgdo = cgdo; + here->B3SOIcgso = cgso; + + if (ByPass) goto line860; + + *(ckt->CKTstate0 + here->B3SOIqe) = qsub; + *(ckt->CKTstate0 + here->B3SOIqg) = qgate; + *(ckt->CKTstate0 + here->B3SOIqd) = qdrn; + *(ckt->CKTstate0 + here->B3SOIqb) = qbody; + if ((model->B3SOIshMod == 1) && (here->B3SOIrth0!=0.0)) + *(ckt->CKTstate0 + here->B3SOIqth) = pParam->B3SOIcth * delTemp; + + + /* store small signal parameters */ + if (ckt->CKTmode & MODEINITSMSIG) + { goto line1000; + } + if (!ChargeComputationNeeded) + goto line850; + + + if (ckt->CKTmode & MODEINITTRAN) + { *(ckt->CKTstate1 + here->B3SOIqb) = + *(ckt->CKTstate0 + here->B3SOIqb); + *(ckt->CKTstate1 + here->B3SOIqg) = + *(ckt->CKTstate0 + here->B3SOIqg); + *(ckt->CKTstate1 + here->B3SOIqd) = + *(ckt->CKTstate0 + here->B3SOIqd); + *(ckt->CKTstate1 + here->B3SOIqe) = + *(ckt->CKTstate0 + here->B3SOIqe); + *(ckt->CKTstate1 + here->B3SOIqth) = + *(ckt->CKTstate0 + here->B3SOIqth); + } + + error = NIintegrate(ckt, &geq, &ceq,0.0,here->B3SOIqb); + if (error) return(error); + error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B3SOIqg); + if (error) return(error); + error = NIintegrate(ckt,&geq, &ceq, 0.0, here->B3SOIqd); + if (error) return(error); + error = NIintegrate(ckt,&geq, &ceq, 0.0, here->B3SOIqe); + if (error) return(error); + if ((model->B3SOIshMod == 1) && (here->B3SOIrth0!=0.0)) + { + error = NIintegrate(ckt, &geq, &ceq, 0.0, here->B3SOIqth); + 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; + + sxpart = (1.0 - (dxpart = (here->B3SOImode > 0) ? 0.4 : 0.6)); + + goto line900; + + line860: + /* evaluate equivalent charge current */ + + cqgate = *(ckt->CKTstate0 + here->B3SOIcqg); + cqbody = *(ckt->CKTstate0 + here->B3SOIcqb); + cqdrn = *(ckt->CKTstate0 + here->B3SOIcqd); + cqsub = *(ckt->CKTstate0 + here->B3SOIcqe); + cqtemp = *(ckt->CKTstate0 + here->B3SOIcqth); + + here->B3SOIcb += cqbody; + here->B3SOIcd += 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; + ceqqd = cqdrn - gcdgb * vgb + gcddb * vbd + gcdsb * vbs + - gcdeb * veb - gcdT * delTemp; + ceqqe = cqsub - gcegb * vgb + gcedb * vbd + gcesb * vbs + - gceeb * veb - gceT * delTemp;; + ceqqth = cqtemp - gcTt * delTemp; + + if (ckt->CKTmode & MODEINITTRAN) + { *(ckt->CKTstate1 + here->B3SOIcqe) = + *(ckt->CKTstate0 + here->B3SOIcqe); + *(ckt->CKTstate1 + here->B3SOIcqb) = + *(ckt->CKTstate0 + here->B3SOIcqb); + *(ckt->CKTstate1 + here->B3SOIcqg) = + *(ckt->CKTstate0 + here->B3SOIcqg); + *(ckt->CKTstate1 + here->B3SOIcqd) = + *(ckt->CKTstate0 + here->B3SOIcqd); + *(ckt->CKTstate1 + here->B3SOIcqth) = + *(ckt->CKTstate0 + here->B3SOIcqth); + } + + /* + * load current vector + */ + line900: + + if (here->B3SOImode >= 0) + { Gm = here->B3SOIgm; + Gmbs = here->B3SOIgmbs; +/* v3.0 */ + Gme = here->B3SOIgme; + + GmT = model->B3SOItype * here->B3SOIgmT; + FwdSum = Gm + Gmbs + Gme; /* v3.0 */ + RevSum = 0.0; + + /* v2.2.2 bug fix */ + cdreq = model->B3SOItype * (here->B3SOIcdrain - here->B3SOIgds * 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->B3SOIcjs; + ceqbd = here->B3SOIcjd; + /* Current going in is +ve */ + ceqbody = -here->B3SOIcbody; + + + ceqgate = here->B3SOIcgate; + gigg = here->B3SOIgigg; + gigb = here->B3SOIgigb; + gige = here->B3SOIgige; /* v3.0 */ + gigs = here->B3SOIgigs; + gigd = here->B3SOIgigd; + gigT = model->B3SOItype * here->B3SOIgigT; + + ceqth = here->B3SOIcth; + ceqbodcon = here->B3SOIcbodcon; + + gbbg = -here->B3SOIgbgs; + gbbdp = -here->B3SOIgbds; + gbbb = -here->B3SOIgbbs; + gbbp = -here->B3SOIgbps; + gbbT = -model->B3SOItype * here->B3SOIgbT; +/* v3.0 */ + gbbe = -here->B3SOIgbes; + gbbsp = - ( gbbg + gbbdp + gbbb + gbbp + gbbe); + + gddpg = -here->B3SOIgjdg; + gddpdp = -here->B3SOIgjdd; + gddpb = -here->B3SOIgjdb; + gddpT = -model->B3SOItype * here->B3SOIgjdT; +/* v3.0 */ + gddpe = -here->B3SOIgjde; + gddpsp = - ( gddpg + gddpdp + gddpb + gddpe); + + gsspg = -here->B3SOIgjsg; + gsspdp = -here->B3SOIgjsd; + gsspb = -here->B3SOIgjsb; + gsspT = -model->B3SOItype * here->B3SOIgjsT; +/* v3.0 */ + gsspe = 0.0; + gsspsp = - (gsspg + gsspdp + gsspb + gsspe); + + gppb = -here->B3SOIgbpbs; + gppp = -here->B3SOIgbpps; + + gTtg = here->B3SOIgtempg; + gTtb = here->B3SOIgtempb; + gTtdp = here->B3SOIgtempd; + gTtt = here->B3SOIgtempT; + +/* v3.0 */ + gTte = here->B3SOIgtempe; + gTtsp = - (gTtg + gTtb + gTtdp + gTte); + + +/* v3.0 */ + if (model->B3SOIigcMod) + { gIstotg = here->B3SOIgIgsg + here->B3SOIgIgcsg; + gIstotd = here->B3SOIgIgcsd; + gIstots = here->B3SOIgIgss + here->B3SOIgIgcss; + gIstotb = here->B3SOIgIgcsb; + Istoteq = model->B3SOItype * (here->B3SOIIgs + here->B3SOIIgcs + - gIstotg * vgs - here->B3SOIgIgcsd * vds + - here->B3SOIgIgcsb * vbs); + + gIdtotg = here->B3SOIgIgdg + here->B3SOIgIgcdg; + gIdtotd = here->B3SOIgIgdd + here->B3SOIgIgcdd; + gIdtots = here->B3SOIgIgcds; + gIdtotb = here->B3SOIgIgcdb; + Idtoteq = model->B3SOItype * (here->B3SOIIgd + here->B3SOIIgcd + - here->B3SOIgIgdg * vgd - here->B3SOIgIgcdg * vgs + - here->B3SOIgIgcdd * vds - here->B3SOIgIgcdb * 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; + } + + + } + else + { Gm = -here->B3SOIgm; + Gmbs = -here->B3SOIgmbs; +/* v3.0 */ + Gme = -here->B3SOIgme; + + GmT = -model->B3SOItype * here->B3SOIgmT; + FwdSum = 0.0; + RevSum = -(Gm + Gmbs + Gme); /* v3.0 */ + + /* v2.2.2 bug fix */ + cdreq = -model->B3SOItype * (here->B3SOIcdrain + here->B3SOIgds*vds + + Gm * vgd + Gmbs * vbd + Gme * (ves - vds)) + + GmT * delTemp; /* v3.0 */ + + ceqbs = here->B3SOIcjd; + ceqbd = here->B3SOIcjs; + /* Current going in is +ve */ + ceqbody = -here->B3SOIcbody; + + + ceqgate = here->B3SOIcgate; + gigg = here->B3SOIgigg; + gigb = here->B3SOIgigb; + gige = here->B3SOIgige; /* v3.0 */ + gigs = here->B3SOIgigd; + gigd = here->B3SOIgigs; + gigT = model->B3SOItype * here->B3SOIgigT; + + ceqth = here->B3SOIcth; + ceqbodcon = here->B3SOIcbodcon; + + gbbg = -here->B3SOIgbgs; + gbbb = -here->B3SOIgbbs; + gbbp = -here->B3SOIgbps; + gbbsp = -here->B3SOIgbds; + gbbT = -model->B3SOItype * here->B3SOIgbT; +/* v3.0 */ + gbbe = -here->B3SOIgbes; + gbbdp = - ( gbbg + gbbsp + gbbb + gbbp + gbbe); + + gddpg = -here->B3SOIgjsg; + gddpsp = -here->B3SOIgjsd; + gddpb = -here->B3SOIgjsb; + gddpT = -model->B3SOItype * here->B3SOIgjsT; +/* v3.0 */ + gddpe = 0.0; + gddpdp = - (gddpg + gddpsp + gddpb + gddpe); + + gsspg = -here->B3SOIgjdg; + gsspsp = -here->B3SOIgjdd; + gsspb = -here->B3SOIgjdb; + gsspT = -model->B3SOItype * here->B3SOIgjdT; +/* v3.0 */ + gsspe = -here->B3SOIgjde; + gsspdp = - ( gsspg + gsspsp + gsspb + gsspe); + + gppb = -here->B3SOIgbpbs; + gppp = -here->B3SOIgbpps; + + gTtg = here->B3SOIgtempg; + gTtb = here->B3SOIgtempb; + gTtsp = here->B3SOIgtempd; + gTtt = here->B3SOIgtempT; + +/* v3.0 */ + gTte = here->B3SOIgtempe; + gTtdp = - (gTtg + gTtb + gTtsp + gTte); + +/* v3.0 */ + if (model->B3SOIigcMod) + { gIstotg = here->B3SOIgIgsg + here->B3SOIgIgcdg; + gIstotd = here->B3SOIgIgcds; + gIstots = here->B3SOIgIgss + here->B3SOIgIgcdd; + gIstotb = here->B3SOIgIgcdb; + Istoteq = model->B3SOItype * (here->B3SOIIgs + here->B3SOIIgcd + - here->B3SOIgIgsg * vgs - here->B3SOIgIgcdg * vgd + + here->B3SOIgIgcdd * vds - here->B3SOIgIgcdb * vbd); + + gIdtotg = here->B3SOIgIgdg + here->B3SOIgIgcsg; + gIdtotd = here->B3SOIgIgdd + here->B3SOIgIgcss; + gIdtots = here->B3SOIgIgcsd; + gIdtotb = here->B3SOIgIgcsb; + Idtoteq = model->B3SOItype * (here->B3SOIIgd + here->B3SOIIgcs + - (here->B3SOIgIgdg + here->B3SOIgIgcsg) * vgd + + here->B3SOIgIgcsd * vds - here->B3SOIgIgcsb * 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; + } + + } + + if (model->B3SOItype > 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; + } + + m = here->B3SOIm; + + (*(ckt->CKTrhs + here->B3SOIbNode) -= m * (ceqbody + ceqqb)); + + (*(ckt->CKTrhs + here->B3SOIgNode) -= m * ((ceqgate + ceqqg) + Igtoteq)); /* v3.0 */ + (*(ckt->CKTrhs + here->B3SOIdNodePrime) += m * ((ceqbd - cdreq - ceqqd) + Idtoteq)); /* v3.0 */ + (*(ckt->CKTrhs + here->B3SOIsNodePrime) += m * ((cdreq + ceqbs + ceqqg + + ceqqb + ceqqd + ceqqe) + Istoteq)); /* v3.0 */ + (*(ckt->CKTrhs + here->B3SOIeNode) -= m * ceqqe); + + if (here->B3SOIbodyMod == 1) { + (*(ckt->CKTrhs + here->B3SOIpNode) += m * ceqbodcon); + } + + if (selfheat) { + (*(ckt->CKTrhs + here->B3SOItempNode) -= m * (ceqth + ceqqth)); + } + + + + if (here->B3SOIdebugMod != 0) + { + *(ckt->CKTrhs + here->B3SOIvbsNode) = here->B3SOIvbseff; + *(ckt->CKTrhs + here->B3SOIidsNode) = FLOG(here->B3SOIids); + *(ckt->CKTrhs + here->B3SOIicNode) = FLOG(here->B3SOIic); + *(ckt->CKTrhs + here->B3SOIibsNode) = FLOG(here->B3SOIibs); + *(ckt->CKTrhs + here->B3SOIibdNode) = FLOG(here->B3SOIibd); + *(ckt->CKTrhs + here->B3SOIiiiNode) = FLOG(here->B3SOIiii); + *(ckt->CKTrhs + here->B3SOIigNode) = here->B3SOIig; + *(ckt->CKTrhs + here->B3SOIgiggNode) = here->B3SOIgigg; + *(ckt->CKTrhs + here->B3SOIgigdNode) = here->B3SOIgigd; + *(ckt->CKTrhs + here->B3SOIgigbNode) = here->B3SOIgigb; + *(ckt->CKTrhs + here->B3SOIigidlNode) = here->B3SOIigidl; + *(ckt->CKTrhs + here->B3SOIitunNode) = here->B3SOIitun; + *(ckt->CKTrhs + here->B3SOIibpNode) = here->B3SOIibp; + *(ckt->CKTrhs + here->B3SOIcbbNode) = here->B3SOIcbb; + *(ckt->CKTrhs + here->B3SOIcbdNode) = here->B3SOIcbd; + *(ckt->CKTrhs + here->B3SOIcbgNode) = here->B3SOIcbg; + *(ckt->CKTrhs + here->B3SOIqbfNode) = here->B3SOIqbf; + *(ckt->CKTrhs + here->B3SOIqjsNode) = here->B3SOIqjs; + *(ckt->CKTrhs + here->B3SOIqjdNode) = here->B3SOIqjd; + + } + + + /* + * load y matrix + */ + Gmin = ckt->CKTgmin * 1e-6; + +/* v3.0 */ + if (model->B3SOIsoiMod != 0) + { + (*(here->B3SOIDPePtr) += m * (Gme + gddpe)); + (*(here->B3SOISPePtr) += m * (gsspe - Gme)); + *(here->B3SOIGePtr) += m * gige; + *(here->B3SOIBePtr) -= m * gige; + } + + *(here->B3SOIEdpPtr) += m * gcedb; + *(here->B3SOIEspPtr) += m * gcesb; + *(here->B3SOIDPePtr) += m * gcdeb; + *(here->B3SOISPePtr) += m * gcseb; + *(here->B3SOIEgPtr) += m * gcegb; + *(here->B3SOIGePtr) += m * gcgeb; + + (*(here->B3SOIEbPtr) -= m * (gcegb + gcedb + gcesb + gceeb)); + (*(here->B3SOIGbPtr) -= m * (-gigb + gcggb + gcgdb + gcgsb + gcgeb - gIgtotb)); /* v3.0 */ + (*(here->B3SOIDPbPtr) -= m * ((-gddpb - Gmbs + gcdgb + gcddb + gcdeb + gcdsb) + gIdtotb)); /* v3.0 */ + + (*(here->B3SOISPbPtr) -= m * ((-gsspb + Gmbs + gcsgb + gcsdb + gcseb + gcssb) + + Gmin + gIstotb)); /* v3.0 */ + + + (*(here->B3SOIBePtr) += m * (gbbe + gcbeb)); /* v3.0 */ + (*(here->B3SOIBgPtr) += m * (-gigg + gcbgb + gbbg)); + (*(here->B3SOIBdpPtr) += m * (-gigd + gcbdb + gbbdp)); + (*(here->B3SOIBspPtr) += m * (gcbsb + gbbsp - Gmin + - gigs)); + (*(here->B3SOIBbPtr) += m * (-gigb + gbbb - gcbgb - gcbdb - gcbsb - gcbeb + Gmin)) ; + (*(here->B3SOIEePtr) += m * gceeb); + + (*(here->B3SOIGgPtr) += m * (gigg + gcggb + ckt->CKTgmin + gIgtotg)); /* v3.0 */ + (*(here->B3SOIGdpPtr) += m * (gigd + gcgdb - ckt->CKTgmin + gIgtotd)); /* v3.0 */ + (*(here->B3SOIGspPtr) += m * (gcgsb + gigs + gIgtots)); /* v3.0 */ + + (*(here->B3SOIDPgPtr) += m * ((Gm + gcdgb) + gddpg - ckt->CKTgmin - gIdtotg)); /* v3.0 */ + (*(here->B3SOIDPdpPtr) += m * ((here->B3SOIdrainConductance + + here->B3SOIgds + gddpdp + + RevSum + gcddb) + ckt->CKTgmin - gIdtotd)); /* v3.0 */ + (*(here->B3SOIDPspPtr) -= m * ((-gddpsp + here->B3SOIgds + FwdSum - gcdsb) + gIdtots)); /* v3.0 */ + + (*(here->B3SOIDPdPtr) -= m * here->B3SOIdrainConductance); + + (*(here->B3SOISPgPtr) += m * (gcsgb - Gm + gsspg - gIstotg)); /* v3.0 */ + (*(here->B3SOISPdpPtr) -= m * (here->B3SOIgds - gsspdp + RevSum - gcsdb + gIstotd)); /* v3.0 */ + + (*(here->B3SOISPspPtr) += m * ((here->B3SOIsourceConductance + + here->B3SOIgds + gsspsp + + FwdSum + gcssb) + + Gmin - gIstots)); /* v3.0 */ + + + (*(here->B3SOISPsPtr) -= m * here->B3SOIsourceConductance); + + + (*(here->B3SOIDdPtr) += m * here->B3SOIdrainConductance); + (*(here->B3SOIDdpPtr) -= m * here->B3SOIdrainConductance); + + + (*(here->B3SOISsPtr) += m * here->B3SOIsourceConductance); + (*(here->B3SOISspPtr) -= m * here->B3SOIsourceConductance); + + if (here->B3SOIbodyMod == 1) { + (*(here->B3SOIBpPtr) -= m * gppp); + (*(here->B3SOIPbPtr) += m * gppb); + (*(here->B3SOIPpPtr) += m * gppp); + } + + if (selfheat) + { + (*(here->B3SOIDPtempPtr) += m * (GmT + gddpT + gcdT)); + (*(here->B3SOISPtempPtr) += m * (-GmT + gsspT + gcsT)); + (*(here->B3SOIBtempPtr) += m * (gbbT + gcbT - gigT)); + (*(here->B3SOIEtempPtr) += m * gceT); + (*(here->B3SOIGtempPtr) += m * (gcgT + gigT)); + (*(here->B3SOITemptempPtr) += m * (gTtt + 1/pParam->B3SOIrth + gcTt)); + (*(here->B3SOITempgPtr) += m * gTtg); + (*(here->B3SOITempbPtr) += m * gTtb); + (*(here->B3SOITempdpPtr) += m * gTtdp); + (*(here->B3SOITempspPtr) += m * gTtsp); + +/* v3.0 */ + if (model->B3SOIsoiMod != 0) + (*(here->B3SOITempePtr) += m * gTte); + + } + + if (here->B3SOIdebugMod != 0) + { + *(here->B3SOIVbsPtr) += m * 1; + *(here->B3SOIIdsPtr) += m * 1; + *(here->B3SOIIcPtr) += m * 1; + *(here->B3SOIIbsPtr) += m * 1; + *(here->B3SOIIbdPtr) += m * 1; + *(here->B3SOIIiiPtr) += m * 1; + *(here->B3SOIIgPtr) += m * 1; + *(here->B3SOIGiggPtr) += m * 1; + *(here->B3SOIGigdPtr) += m * 1; + *(here->B3SOIGigbPtr) += m * 1; + *(here->B3SOIIgidlPtr) += m * 1; + *(here->B3SOIItunPtr) += m * 1; + *(here->B3SOIIbpPtr) += m * 1; + *(here->B3SOICbgPtr) += m * 1; + *(here->B3SOICbbPtr) += m * 1; + *(here->B3SOICbdPtr) += m * 1; + *(here->B3SOIQbfPtr) += m * 1; + *(here->B3SOIQjsPtr) += m * 1; + *(here->B3SOIQjdPtr) += m * 1; + + } + + line1000: ; + + + } /* End of Mosfet Instance */ +} /* End of Model Instance */ + + +return(OK); +} + diff --git a/src/spicelib/devices/bsim3soi/b3soimask.c b/src/spicelib/devices/bsim3soi/b3soimask.c new file mode 100644 index 000000000..3c3e22409 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soimask.c @@ -0,0 +1,1630 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soimask.c 98/5/01 +Modified by Pin Su and Jan Feng 99/2/15 +Modified by Pin Su 99/4/30 +Modified by Wei Jin 99/9/27 +Modified by Pin Su 00/3/1 +Modified by Pin Su 01/2/15 +Modified by Pin Su 02/3/5 +Modified by Pin Su 02/5/20 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "ifsim.h" +#include "cktdefs.h" +#include "devdefs.h" +#include "b3soidef.h" +#include "sperror.h" +#include "suffix.h" + +int +B3SOImAsk(CKTcircuit *ckt, GENmodel *inst, int which, IFvalue *value) +{ + B3SOImodel *model = (B3SOImodel *)inst; + switch(which) + { case B3SOI_MOD_MOBMOD: + value->iValue = model->B3SOImobMod; + return(OK); + case B3SOI_MOD_PARAMCHK: + value->iValue = model->B3SOIparamChk; + return(OK); + case B3SOI_MOD_BINUNIT: + value->iValue = model->B3SOIbinUnit; + return(OK); + case B3SOI_MOD_CAPMOD: + value->iValue = model->B3SOIcapMod; + return(OK); + case B3SOI_MOD_SHMOD: + value->iValue = model->B3SOIshMod; + return(OK); + case B3SOI_MOD_NOIMOD: + value->iValue = model->B3SOInoiMod; + return(OK); + case B3SOI_MOD_VERSION : + value->rValue = model->B3SOIversion; + return(OK); + case B3SOI_MOD_TOX : + value->rValue = model->B3SOItox; + return(OK); +/* v2.2.3 */ + case B3SOI_MOD_DTOXCV : + value->rValue = model->B3SOIdtoxcv; + return(OK); + + case B3SOI_MOD_CDSC : + value->rValue = model->B3SOIcdsc; + return(OK); + case B3SOI_MOD_CDSCB : + value->rValue = model->B3SOIcdscb; + return(OK); + + case B3SOI_MOD_CDSCD : + value->rValue = model->B3SOIcdscd; + return(OK); + + case B3SOI_MOD_CIT : + value->rValue = model->B3SOIcit; + return(OK); + case B3SOI_MOD_NFACTOR : + value->rValue = model->B3SOInfactor; + return(OK); + case B3SOI_MOD_VSAT: + value->rValue = model->B3SOIvsat; + return(OK); + case B3SOI_MOD_AT: + value->rValue = model->B3SOIat; + return(OK); + case B3SOI_MOD_A0: + value->rValue = model->B3SOIa0; + return(OK); + + case B3SOI_MOD_AGS: + value->rValue = model->B3SOIags; + return(OK); + + case B3SOI_MOD_A1: + value->rValue = model->B3SOIa1; + return(OK); + case B3SOI_MOD_A2: + value->rValue = model->B3SOIa2; + return(OK); + case B3SOI_MOD_KETA: + value->rValue = model->B3SOIketa; + return(OK); + case B3SOI_MOD_NSUB: + value->rValue = model->B3SOInsub; + return(OK); + case B3SOI_MOD_NPEAK: + value->rValue = model->B3SOInpeak; + return(OK); + case B3SOI_MOD_NGATE: + value->rValue = model->B3SOIngate; + return(OK); + case B3SOI_MOD_GAMMA1: + value->rValue = model->B3SOIgamma1; + return(OK); + case B3SOI_MOD_GAMMA2: + value->rValue = model->B3SOIgamma2; + return(OK); + case B3SOI_MOD_VBX: + value->rValue = model->B3SOIvbx; + return(OK); + case B3SOI_MOD_VBM: + value->rValue = model->B3SOIvbm; + return(OK); + case B3SOI_MOD_XT: + value->rValue = model->B3SOIxt; + return(OK); + case B3SOI_MOD_K1: + value->rValue = model->B3SOIk1; + return(OK); + case B3SOI_MOD_KT1: + value->rValue = model->B3SOIkt1; + return(OK); + case B3SOI_MOD_KT1L: + value->rValue = model->B3SOIkt1l; + return(OK); + case B3SOI_MOD_KT2 : + value->rValue = model->B3SOIkt2; + return(OK); + case B3SOI_MOD_K2 : + value->rValue = model->B3SOIk2; + return(OK); + case B3SOI_MOD_K3: + value->rValue = model->B3SOIk3; + return(OK); + case B3SOI_MOD_K3B: + value->rValue = model->B3SOIk3b; + return(OK); + case B3SOI_MOD_W0: + value->rValue = model->B3SOIw0; + return(OK); + case B3SOI_MOD_NLX: + value->rValue = model->B3SOInlx; + return(OK); + case B3SOI_MOD_DVT0 : + value->rValue = model->B3SOIdvt0; + return(OK); + case B3SOI_MOD_DVT1 : + value->rValue = model->B3SOIdvt1; + return(OK); + case B3SOI_MOD_DVT2 : + value->rValue = model->B3SOIdvt2; + return(OK); + case B3SOI_MOD_DVT0W : + value->rValue = model->B3SOIdvt0w; + return(OK); + case B3SOI_MOD_DVT1W : + value->rValue = model->B3SOIdvt1w; + return(OK); + case B3SOI_MOD_DVT2W : + value->rValue = model->B3SOIdvt2w; + return(OK); + case B3SOI_MOD_DROUT : + value->rValue = model->B3SOIdrout; + return(OK); + case B3SOI_MOD_DSUB : + value->rValue = model->B3SOIdsub; + return(OK); + case B3SOI_MOD_VTH0: + value->rValue = model->B3SOIvth0; + return(OK); + case B3SOI_MOD_UA: + value->rValue = model->B3SOIua; + return(OK); + case B3SOI_MOD_UA1: + value->rValue = model->B3SOIua1; + return(OK); + case B3SOI_MOD_UB: + value->rValue = model->B3SOIub; + return(OK); + case B3SOI_MOD_UB1: + value->rValue = model->B3SOIub1; + return(OK); + case B3SOI_MOD_UC: + value->rValue = model->B3SOIuc; + return(OK); + case B3SOI_MOD_UC1: + value->rValue = model->B3SOIuc1; + return(OK); + case B3SOI_MOD_U0: + value->rValue = model->B3SOIu0; + return(OK); + case B3SOI_MOD_UTE: + value->rValue = model->B3SOIute; + return(OK); + case B3SOI_MOD_VOFF: + value->rValue = model->B3SOIvoff; + return(OK); + case B3SOI_MOD_DELTA: + value->rValue = model->B3SOIdelta; + return(OK); + case B3SOI_MOD_RDSW: + value->rValue = model->B3SOIrdsw; + return(OK); + case B3SOI_MOD_PRWG: + value->rValue = model->B3SOIprwg; + return(OK); + case B3SOI_MOD_PRWB: + value->rValue = model->B3SOIprwb; + return(OK); + case B3SOI_MOD_PRT: + value->rValue = model->B3SOIprt; + return(OK); + case B3SOI_MOD_ETA0: + value->rValue = model->B3SOIeta0; + return(OK); + case B3SOI_MOD_ETAB: + value->rValue = model->B3SOIetab; + return(OK); + case B3SOI_MOD_PCLM: + value->rValue = model->B3SOIpclm; + return(OK); + case B3SOI_MOD_PDIBL1: + value->rValue = model->B3SOIpdibl1; + return(OK); + case B3SOI_MOD_PDIBL2: + value->rValue = model->B3SOIpdibl2; + return(OK); + case B3SOI_MOD_PDIBLB: + value->rValue = model->B3SOIpdiblb; + return(OK); + case B3SOI_MOD_PVAG: + value->rValue = model->B3SOIpvag; + return(OK); + case B3SOI_MOD_WR: + value->rValue = model->B3SOIwr; + return(OK); + case B3SOI_MOD_DWG: + value->rValue = model->B3SOIdwg; + return(OK); + case B3SOI_MOD_DWB: + value->rValue = model->B3SOIdwb; + return(OK); + case B3SOI_MOD_B0: + value->rValue = model->B3SOIb0; + return(OK); + case B3SOI_MOD_B1: + value->rValue = model->B3SOIb1; + return(OK); + case B3SOI_MOD_ALPHA0: + value->rValue = model->B3SOIalpha0; + return(OK); + + case B3SOI_MOD_CGSL: + value->rValue = model->B3SOIcgsl; + return(OK); + case B3SOI_MOD_CGDL: + value->rValue = model->B3SOIcgdl; + return(OK); + case B3SOI_MOD_CKAPPA: + value->rValue = model->B3SOIckappa; + return(OK); + case B3SOI_MOD_CF: + value->rValue = model->B3SOIcf; + return(OK); + case B3SOI_MOD_CLC: + value->rValue = model->B3SOIclc; + return(OK); + case B3SOI_MOD_CLE: + value->rValue = model->B3SOIcle; + return(OK); + case B3SOI_MOD_DWC: + value->rValue = model->B3SOIdwc; + return(OK); + case B3SOI_MOD_DLC: + value->rValue = model->B3SOIdlc; + return(OK); + + case B3SOI_MOD_TBOX: + value->rValue = model->B3SOItbox; + return(OK); + case B3SOI_MOD_TSI: + value->rValue = model->B3SOItsi; + return(OK); + case B3SOI_MOD_RTH0: + value->rValue = model->B3SOIrth0; + return(OK); + case B3SOI_MOD_CTH0: + value->rValue = model->B3SOIcth0; + return(OK); + case B3SOI_MOD_NDIODE: + value->rValue = model->B3SOIndiode; + return(OK); + case B3SOI_MOD_XBJT: + value->rValue = model->B3SOIxbjt; + return(OK); + + case B3SOI_MOD_XDIF: + value->rValue = model->B3SOIxdif; + return(OK); + + case B3SOI_MOD_XREC: + value->rValue = model->B3SOIxrec; + return(OK); + case B3SOI_MOD_XTUN: + value->rValue = model->B3SOIxtun; + return(OK); + case B3SOI_MOD_TT: + value->rValue = model->B3SOItt; + return(OK); + case B3SOI_MOD_VSDTH: + value->rValue = model->B3SOIvsdth; + return(OK); + case B3SOI_MOD_VSDFB: + value->rValue = model->B3SOIvsdfb; + return(OK); + case B3SOI_MOD_CSDMIN: + value->rValue = model->B3SOIcsdmin; + return(OK); + case B3SOI_MOD_ASD: + value->rValue = model->B3SOIasd; + return(OK); + + case B3SOI_MOD_TNOM : + value->rValue = model->B3SOItnom; + return(OK); + case B3SOI_MOD_CGSO: + value->rValue = model->B3SOIcgso; + return(OK); + case B3SOI_MOD_CGDO: + value->rValue = model->B3SOIcgdo; + return(OK); + case B3SOI_MOD_CGEO: + value->rValue = model->B3SOIcgeo; + return(OK); + case B3SOI_MOD_XPART: + value->rValue = model->B3SOIxpart; + return(OK); + case B3SOI_MOD_RSH: + value->rValue = model->B3SOIsheetResistance; + return(OK); + case B3SOI_MOD_PBSWG: + value->rValue = model->B3SOIGatesidewallJctPotential; + return(OK); + case B3SOI_MOD_MJSWG: + value->rValue = model->B3SOIbodyJctGateSideGradingCoeff; + return(OK); + case B3SOI_MOD_CJSWG: + value->rValue = model->B3SOIunitLengthGateSidewallJctCap; + return(OK); + case B3SOI_MOD_CSDESW: + value->rValue = model->B3SOIcsdesw; + return(OK); + case B3SOI_MOD_LINT: + value->rValue = model->B3SOILint; + return(OK); + case B3SOI_MOD_LL: + value->rValue = model->B3SOILl; + return(OK); +/* v2.2.3 */ + case B3SOI_MOD_LLC: + value->rValue = model->B3SOILlc; + return(OK); + + case B3SOI_MOD_LLN: + value->rValue = model->B3SOILln; + return(OK); + case B3SOI_MOD_LW: + value->rValue = model->B3SOILw; + return(OK); +/* v2.2.3 */ + case B3SOI_MOD_LWC: + value->rValue = model->B3SOILwc; + return(OK); + + case B3SOI_MOD_LWN: + value->rValue = model->B3SOILwn; + return(OK); + case B3SOI_MOD_LWL: + value->rValue = model->B3SOILwl; + return(OK); +/* v2.2.3 */ + case B3SOI_MOD_LWLC: + value->rValue = model->B3SOILwlc; + return(OK); + + case B3SOI_MOD_WINT: + value->rValue = model->B3SOIWint; + return(OK); + case B3SOI_MOD_WL: + value->rValue = model->B3SOIWl; + return(OK); +/* v2.2.3 */ + case B3SOI_MOD_WLC: + value->rValue = model->B3SOIWlc; + return(OK); + + case B3SOI_MOD_WLN: + value->rValue = model->B3SOIWln; + return(OK); + case B3SOI_MOD_WW: + value->rValue = model->B3SOIWw; + return(OK); +/* v2.2.3 */ + case B3SOI_MOD_WWC: + value->rValue = model->B3SOIWwc; + return(OK); + + case B3SOI_MOD_WWN: + value->rValue = model->B3SOIWwn; + return(OK); + case B3SOI_MOD_WWL: + value->rValue = model->B3SOIWwl; + return(OK); +/* v2.2.3 */ + case B3SOI_MOD_WWLC: + value->rValue = model->B3SOIWwlc; + return(OK); + + case B3SOI_MOD_NOIA: + value->rValue = model->B3SOIoxideTrapDensityA; + return(OK); + case B3SOI_MOD_NOIB: + value->rValue = model->B3SOIoxideTrapDensityB; + return(OK); + case B3SOI_MOD_NOIC: + value->rValue = model->B3SOIoxideTrapDensityC; + return(OK); + case B3SOI_MOD_NOIF: + value->rValue = model->B3SOInoif; + return(OK); + case B3SOI_MOD_EM: + value->rValue = model->B3SOIem; + return(OK); + case B3SOI_MOD_EF: + value->rValue = model->B3SOIef; + return(OK); + case B3SOI_MOD_AF: + value->rValue = model->B3SOIaf; + return(OK); + case B3SOI_MOD_KF: + value->rValue = model->B3SOIkf; + return(OK); + + +/* v2.0 release */ + case B3SOI_MOD_K1W1: + value->rValue = model->B3SOIk1w1; + return(OK); + case B3SOI_MOD_K1W2: + value->rValue = model->B3SOIk1w2; + return(OK); + case B3SOI_MOD_KETAS: + value->rValue = model->B3SOIketas; + return(OK); + case B3SOI_MOD_DWBC: + value->rValue = model->B3SOIdwbc; + return(OK); + case B3SOI_MOD_BETA0: + value->rValue = model->B3SOIbeta0; + return(OK); + case B3SOI_MOD_BETA1: + value->rValue = model->B3SOIbeta1; + return(OK); + case B3SOI_MOD_BETA2: + value->rValue = model->B3SOIbeta2; + return(OK); + case B3SOI_MOD_VDSATII0: + value->rValue = model->B3SOIvdsatii0; + return(OK); + case B3SOI_MOD_TII: + value->rValue = model->B3SOItii; + return(OK); + case B3SOI_MOD_LII: + value->rValue = model->B3SOIlii; + return(OK); + case B3SOI_MOD_SII0: + value->rValue = model->B3SOIsii0; + return(OK); + case B3SOI_MOD_SII1: + value->rValue = model->B3SOIsii1; + return(OK); + case B3SOI_MOD_SII2: + value->rValue = model->B3SOIsii2; + return(OK); + case B3SOI_MOD_SIID: + value->rValue = model->B3SOIsiid; + return(OK); + case B3SOI_MOD_FBJTII: + value->rValue = model->B3SOIfbjtii; + return(OK); + case B3SOI_MOD_ESATII: + value->rValue = model->B3SOIesatii; + return(OK); + case B3SOI_MOD_NTUN: + value->rValue = model->B3SOIntun; + return(OK); + case B3SOI_MOD_NRECF0: + value->rValue = model->B3SOInrecf0; + return(OK); + case B3SOI_MOD_NRECR0: + value->rValue = model->B3SOInrecr0; + return(OK); + case B3SOI_MOD_ISBJT: + value->rValue = model->B3SOIisbjt; + return(OK); + case B3SOI_MOD_ISDIF: + value->rValue = model->B3SOIisdif; + return(OK); + case B3SOI_MOD_ISREC: + value->rValue = model->B3SOIisrec; + return(OK); + case B3SOI_MOD_ISTUN: + value->rValue = model->B3SOIistun; + return(OK); + case B3SOI_MOD_LN: + value->rValue = model->B3SOIln; + return(OK); + case B3SOI_MOD_VREC0: + value->rValue = model->B3SOIvrec0; + return(OK); + case B3SOI_MOD_VTUN0: + value->rValue = model->B3SOIvtun0; + return(OK); + case B3SOI_MOD_NBJT: + value->rValue = model->B3SOInbjt; + return(OK); + case B3SOI_MOD_LBJT0: + value->rValue = model->B3SOIlbjt0; + return(OK); + case B3SOI_MOD_LDIF0: + value->rValue = model->B3SOIldif0; + return(OK); + case B3SOI_MOD_VABJT: + value->rValue = model->B3SOIvabjt; + return(OK); + case B3SOI_MOD_AELY: + value->rValue = model->B3SOIaely; + return(OK); + case B3SOI_MOD_AHLI: + value->rValue = model->B3SOIahli; + return(OK); + case B3SOI_MOD_RBODY: + value->rValue = model->B3SOIrbody; + return(OK); + case B3SOI_MOD_RBSH: + value->rValue = model->B3SOIrbsh; + return(OK); + case B3SOI_MOD_NTRECF: + value->rValue = model->B3SOIntrecf; + return(OK); + case B3SOI_MOD_NTRECR: + value->rValue = model->B3SOIntrecr; + return(OK); + case B3SOI_MOD_NDIF: + value->rValue = model->B3SOIndif; + return(OK); + case B3SOI_MOD_DLCB: + value->rValue = model->B3SOIdlcb; + return(OK); + case B3SOI_MOD_FBODY: + value->rValue = model->B3SOIfbody; + return(OK); + case B3SOI_MOD_TCJSWG: + value->rValue = model->B3SOItcjswg; + return(OK); + case B3SOI_MOD_TPBSWG: + value->rValue = model->B3SOItpbswg; + return(OK); + case B3SOI_MOD_ACDE: + value->rValue = model->B3SOIacde; + return(OK); + case B3SOI_MOD_MOIN: + value->rValue = model->B3SOImoin; + return(OK); + case B3SOI_MOD_DELVT: + value->rValue = model->B3SOIdelvt; + return(OK); + case B3SOI_MOD_KB1: + value->rValue = model->B3SOIkb1; + return(OK); + case B3SOI_MOD_DLBG: + value->rValue = model->B3SOIdlbg; + return(OK); + + case B3SOI_MOD_NGIDL: + value->rValue = model->B3SOIngidl; + return(OK); + case B3SOI_MOD_AGIDL: + value->rValue = model->B3SOIagidl; + return(OK); + case B3SOI_MOD_BGIDL: + value->rValue = model->B3SOIbgidl; + return(OK); + +/* v3.0 */ + case B3SOI_MOD_SOIMOD: + value->rValue = model->B3SOIsoiMod; + return(OK); + case B3SOI_MOD_VBSA: + value->rValue = model->B3SOIvbsa; + return(OK); + case B3SOI_MOD_NOFFFD: + value->rValue = model->B3SOInofffd; + return(OK); + case B3SOI_MOD_VOFFFD: + value->rValue = model->B3SOIvofffd; + return(OK); + case B3SOI_MOD_K1B: + value->rValue = model->B3SOIk1b; + return(OK); + case B3SOI_MOD_K2B: + value->rValue = model->B3SOIk2b; + return(OK); + case B3SOI_MOD_DK2B: + value->rValue = model->B3SOIdk2b; + return(OK); + case B3SOI_MOD_DVBD0: + value->rValue = model->B3SOIdvbd0; + return(OK); + case B3SOI_MOD_DVBD1: + value->rValue = model->B3SOIdvbd1; + return(OK); + case B3SOI_MOD_MOINFD: + value->rValue = model->B3SOImoinFD; + return(OK); + + + +/* v2.2 release */ + case B3SOI_MOD_WTH0: + value->rValue = model->B3SOIwth0; + return(OK); + case B3SOI_MOD_RHALO: + value->rValue = model->B3SOIrhalo; + return(OK); + case B3SOI_MOD_NTOX: + value->rValue = model->B3SOIntox; + return(OK); + case B3SOI_MOD_TOXREF: + value->rValue = model->B3SOItoxref; + return(OK); + case B3SOI_MOD_EBG: + value->rValue = model->B3SOIebg; + return(OK); + case B3SOI_MOD_VEVB: + value->rValue = model->B3SOIvevb; + return(OK); + case B3SOI_MOD_ALPHAGB1: + value->rValue = model->B3SOIalphaGB1; + return(OK); + case B3SOI_MOD_BETAGB1: + value->rValue = model->B3SOIbetaGB1; + return(OK); + case B3SOI_MOD_VGB1: + value->rValue = model->B3SOIvgb1; + return(OK); + case B3SOI_MOD_VECB: + value->rValue = model->B3SOIvecb; + return(OK); + case B3SOI_MOD_ALPHAGB2: + value->rValue = model->B3SOIalphaGB2; + return(OK); + case B3SOI_MOD_BETAGB2: + value->rValue = model->B3SOIbetaGB2; + return(OK); + case B3SOI_MOD_VGB2: + value->rValue = model->B3SOIvgb2; + return(OK); + case B3SOI_MOD_TOXQM: + value->rValue = model->B3SOItoxqm; + return(OK); + case B3SOI_MOD_VOXH: + value->rValue = model->B3SOIvoxh; + return(OK); + case B3SOI_MOD_DELTAVOX: + value->rValue = model->B3SOIdeltavox; + return(OK); + +/* v3.0 */ + case B3SOI_MOD_IGBMOD: + value->iValue = model->B3SOIigbMod; + return(OK); + case B3SOI_MOD_IGCMOD: + value->iValue = model->B3SOIigcMod; + return(OK); + case B3SOI_MOD_AIGC: + value->rValue = model->B3SOIaigc; + return(OK); + case B3SOI_MOD_BIGC: + value->rValue = model->B3SOIbigc; + return(OK); + case B3SOI_MOD_CIGC: + value->rValue = model->B3SOIcigc; + return(OK); + case B3SOI_MOD_AIGSD: + value->rValue = model->B3SOIaigsd; + return(OK); + case B3SOI_MOD_BIGSD: + value->rValue = model->B3SOIbigsd; + return(OK); + case B3SOI_MOD_CIGSD: + value->rValue = model->B3SOIcigsd; + return(OK); + case B3SOI_MOD_NIGC: + value->rValue = model->B3SOInigc; + return(OK); + case B3SOI_MOD_PIGCD: + value->rValue = model->B3SOIpigcd; + return(OK); + case B3SOI_MOD_POXEDGE: + value->rValue = model->B3SOIpoxedge; + return(OK); + case B3SOI_MOD_DLCIG: + value->rValue = model->B3SOIdlcig; + return(OK); + + + +/* Added for binning - START */ + /* Length Dependence */ +/* v3.0 */ + case B3SOI_MOD_LAIGC: + value->rValue = model->B3SOIlaigc; + return(OK); + case B3SOI_MOD_LBIGC: + value->rValue = model->B3SOIlbigc; + return(OK); + case B3SOI_MOD_LCIGC: + value->rValue = model->B3SOIlcigc; + return(OK); + case B3SOI_MOD_LAIGSD: + value->rValue = model->B3SOIlaigsd; + return(OK); + case B3SOI_MOD_LBIGSD: + value->rValue = model->B3SOIlbigsd; + return(OK); + case B3SOI_MOD_LCIGSD: + value->rValue = model->B3SOIlcigsd; + return(OK); + case B3SOI_MOD_LNIGC: + value->rValue = model->B3SOIlnigc; + return(OK); + case B3SOI_MOD_LPIGCD: + value->rValue = model->B3SOIlpigcd; + return(OK); + case B3SOI_MOD_LPOXEDGE: + value->rValue = model->B3SOIlpoxedge; + return(OK); + + case B3SOI_MOD_LNPEAK: + value->rValue = model->B3SOIlnpeak; + return(OK); + case B3SOI_MOD_LNSUB: + value->rValue = model->B3SOIlnsub; + return(OK); + case B3SOI_MOD_LNGATE: + value->rValue = model->B3SOIlngate; + return(OK); + case B3SOI_MOD_LVTH0: + value->rValue = model->B3SOIlvth0; + return(OK); + case B3SOI_MOD_LK1: + value->rValue = model->B3SOIlk1; + return(OK); + case B3SOI_MOD_LK1W1: + value->rValue = model->B3SOIlk1w1; + return(OK); + case B3SOI_MOD_LK1W2: + value->rValue = model->B3SOIlk1w2; + return(OK); + case B3SOI_MOD_LK2: + value->rValue = model->B3SOIlk2; + return(OK); + case B3SOI_MOD_LK3: + value->rValue = model->B3SOIlk3; + return(OK); + case B3SOI_MOD_LK3B: + value->rValue = model->B3SOIlk3b; + return(OK); + case B3SOI_MOD_LKB1: + value->rValue = model->B3SOIlkb1; + return(OK); + case B3SOI_MOD_LW0: + value->rValue = model->B3SOIlw0; + return(OK); + case B3SOI_MOD_LNLX: + value->rValue = model->B3SOIlnlx; + return(OK); + case B3SOI_MOD_LDVT0 : + value->rValue = model->B3SOIldvt0; + return(OK); + case B3SOI_MOD_LDVT1 : + value->rValue = model->B3SOIldvt1; + return(OK); + case B3SOI_MOD_LDVT2 : + value->rValue = model->B3SOIldvt2; + return(OK); + case B3SOI_MOD_LDVT0W : + value->rValue = model->B3SOIldvt0w; + return(OK); + case B3SOI_MOD_LDVT1W : + value->rValue = model->B3SOIldvt1w; + return(OK); + case B3SOI_MOD_LDVT2W : + value->rValue = model->B3SOIldvt2w; + return(OK); + case B3SOI_MOD_LU0: + value->rValue = model->B3SOIlu0; + return(OK); + case B3SOI_MOD_LUA: + value->rValue = model->B3SOIlua; + return(OK); + case B3SOI_MOD_LUB: + value->rValue = model->B3SOIlub; + return(OK); + case B3SOI_MOD_LUC: + value->rValue = model->B3SOIluc; + return(OK); + case B3SOI_MOD_LVSAT: + value->rValue = model->B3SOIlvsat; + return(OK); + case B3SOI_MOD_LA0: + value->rValue = model->B3SOIla0; + return(OK); + case B3SOI_MOD_LAGS: + value->rValue = model->B3SOIlags; + return(OK); + case B3SOI_MOD_LB0: + value->rValue = model->B3SOIlb0; + return(OK); + case B3SOI_MOD_LB1: + value->rValue = model->B3SOIlb1; + return(OK); + case B3SOI_MOD_LKETA: + value->rValue = model->B3SOIlketa; + return(OK); + case B3SOI_MOD_LKETAS: + value->rValue = model->B3SOIlketas; + return(OK); + case B3SOI_MOD_LA1: + value->rValue = model->B3SOIla1; + return(OK); + case B3SOI_MOD_LA2: + value->rValue = model->B3SOIla2; + return(OK); + case B3SOI_MOD_LRDSW: + value->rValue = model->B3SOIlrdsw; + return(OK); + case B3SOI_MOD_LPRWB: + value->rValue = model->B3SOIlprwb; + return(OK); + case B3SOI_MOD_LPRWG: + value->rValue = model->B3SOIlprwg; + return(OK); + case B3SOI_MOD_LWR: + value->rValue = model->B3SOIlwr; + return(OK); + case B3SOI_MOD_LNFACTOR : + value->rValue = model->B3SOIlnfactor; + return(OK); + case B3SOI_MOD_LDWG: + value->rValue = model->B3SOIldwg; + return(OK); + case B3SOI_MOD_LDWB: + value->rValue = model->B3SOIldwb; + return(OK); + case B3SOI_MOD_LVOFF: + value->rValue = model->B3SOIlvoff; + return(OK); + case B3SOI_MOD_LETA0: + value->rValue = model->B3SOIleta0; + return(OK); + case B3SOI_MOD_LETAB: + value->rValue = model->B3SOIletab; + return(OK); + case B3SOI_MOD_LDSUB : + value->rValue = model->B3SOIldsub; + return(OK); + case B3SOI_MOD_LCIT : + value->rValue = model->B3SOIlcit; + return(OK); + case B3SOI_MOD_LCDSC : + value->rValue = model->B3SOIlcdsc; + return(OK); + case B3SOI_MOD_LCDSCB : + value->rValue = model->B3SOIlcdscb; + return(OK); + case B3SOI_MOD_LCDSCD : + value->rValue = model->B3SOIlcdscd; + return(OK); + case B3SOI_MOD_LPCLM: + value->rValue = model->B3SOIlpclm; + return(OK); + case B3SOI_MOD_LPDIBL1: + value->rValue = model->B3SOIlpdibl1; + return(OK); + case B3SOI_MOD_LPDIBL2: + value->rValue = model->B3SOIlpdibl2; + return(OK); + case B3SOI_MOD_LPDIBLB: + value->rValue = model->B3SOIlpdiblb; + return(OK); + case B3SOI_MOD_LDROUT : + value->rValue = model->B3SOIldrout; + return(OK); + case B3SOI_MOD_LPVAG: + value->rValue = model->B3SOIlpvag; + return(OK); + case B3SOI_MOD_LDELTA: + value->rValue = model->B3SOIldelta; + return(OK); + case B3SOI_MOD_LALPHA0: + value->rValue = model->B3SOIlalpha0; + return(OK); + case B3SOI_MOD_LFBJTII: + value->rValue = model->B3SOIlfbjtii; + return(OK); + case B3SOI_MOD_LBETA0: + value->rValue = model->B3SOIlbeta0; + return(OK); + case B3SOI_MOD_LBETA1: + value->rValue = model->B3SOIlbeta1; + return(OK); + case B3SOI_MOD_LBETA2: + value->rValue = model->B3SOIlbeta2; + return(OK); + case B3SOI_MOD_LVDSATII0: + value->rValue = model->B3SOIlvdsatii0; + return(OK); + case B3SOI_MOD_LLII: + value->rValue = model->B3SOIllii; + return(OK); + case B3SOI_MOD_LESATII: + value->rValue = model->B3SOIlesatii; + return(OK); + case B3SOI_MOD_LSII0: + value->rValue = model->B3SOIlsii0; + return(OK); + case B3SOI_MOD_LSII1: + value->rValue = model->B3SOIlsii1; + return(OK); + case B3SOI_MOD_LSII2: + value->rValue = model->B3SOIlsii2; + return(OK); + case B3SOI_MOD_LSIID: + value->rValue = model->B3SOIlsiid; + return(OK); + case B3SOI_MOD_LAGIDL: + value->rValue = model->B3SOIlagidl; + return(OK); + case B3SOI_MOD_LBGIDL: + value->rValue = model->B3SOIlbgidl; + return(OK); + case B3SOI_MOD_LNGIDL: + value->rValue = model->B3SOIlngidl; + return(OK); + case B3SOI_MOD_LNTUN: + value->rValue = model->B3SOIlntun; + return(OK); + case B3SOI_MOD_LNDIODE: + value->rValue = model->B3SOIlndiode; + return(OK); + case B3SOI_MOD_LNRECF0: + value->rValue = model->B3SOIlnrecf0; + return(OK); + case B3SOI_MOD_LNRECR0: + value->rValue = model->B3SOIlnrecr0; + return(OK); + case B3SOI_MOD_LISBJT: + value->rValue = model->B3SOIlisbjt; + return(OK); + case B3SOI_MOD_LISDIF: + value->rValue = model->B3SOIlisdif; + return(OK); + case B3SOI_MOD_LISREC: + value->rValue = model->B3SOIlisrec; + return(OK); + case B3SOI_MOD_LISTUN: + value->rValue = model->B3SOIlistun; + return(OK); + case B3SOI_MOD_LVREC0: + value->rValue = model->B3SOIlvrec0; + return(OK); + case B3SOI_MOD_LVTUN0: + value->rValue = model->B3SOIlvtun0; + return(OK); + case B3SOI_MOD_LNBJT: + value->rValue = model->B3SOIlnbjt; + return(OK); + case B3SOI_MOD_LLBJT0: + value->rValue = model->B3SOIllbjt0; + return(OK); + case B3SOI_MOD_LVABJT: + value->rValue = model->B3SOIlvabjt; + return(OK); + case B3SOI_MOD_LAELY: + value->rValue = model->B3SOIlaely; + return(OK); + case B3SOI_MOD_LAHLI: + value->rValue = model->B3SOIlahli; + return(OK); + /* CV Model */ + case B3SOI_MOD_LVSDFB: + value->rValue = model->B3SOIlvsdfb; + return(OK); + case B3SOI_MOD_LVSDTH: + value->rValue = model->B3SOIlvsdth; + return(OK); + case B3SOI_MOD_LDELVT: + value->rValue = model->B3SOIldelvt; + return(OK); + case B3SOI_MOD_LACDE: + value->rValue = model->B3SOIlacde; + return(OK); + case B3SOI_MOD_LMOIN: + value->rValue = model->B3SOIlmoin; + return(OK); + + /* Width Dependence */ +/* v3.0 */ + case B3SOI_MOD_WAIGC: + value->rValue = model->B3SOIwaigc; + return(OK); + case B3SOI_MOD_WBIGC: + value->rValue = model->B3SOIwbigc; + return(OK); + case B3SOI_MOD_WCIGC: + value->rValue = model->B3SOIwcigc; + return(OK); + case B3SOI_MOD_WAIGSD: + value->rValue = model->B3SOIwaigsd; + return(OK); + case B3SOI_MOD_WBIGSD: + value->rValue = model->B3SOIwbigsd; + return(OK); + case B3SOI_MOD_WCIGSD: + value->rValue = model->B3SOIwcigsd; + return(OK); + case B3SOI_MOD_WNIGC: + value->rValue = model->B3SOIwnigc; + return(OK); + case B3SOI_MOD_WPIGCD: + value->rValue = model->B3SOIwpigcd; + return(OK); + case B3SOI_MOD_WPOXEDGE: + value->rValue = model->B3SOIwpoxedge; + return(OK); + + case B3SOI_MOD_WNPEAK: + value->rValue = model->B3SOIwnpeak; + return(OK); + case B3SOI_MOD_WNSUB: + value->rValue = model->B3SOIwnsub; + return(OK); + case B3SOI_MOD_WNGATE: + value->rValue = model->B3SOIwngate; + return(OK); + case B3SOI_MOD_WVTH0: + value->rValue = model->B3SOIwvth0; + return(OK); + case B3SOI_MOD_WK1: + value->rValue = model->B3SOIwk1; + return(OK); + case B3SOI_MOD_WK1W1: + value->rValue = model->B3SOIwk1w1; + return(OK); + case B3SOI_MOD_WK1W2: + value->rValue = model->B3SOIwk1w2; + return(OK); + case B3SOI_MOD_WK2: + value->rValue = model->B3SOIwk2; + return(OK); + case B3SOI_MOD_WK3: + value->rValue = model->B3SOIwk3; + return(OK); + case B3SOI_MOD_WK3B: + value->rValue = model->B3SOIwk3b; + return(OK); + case B3SOI_MOD_WKB1: + value->rValue = model->B3SOIwkb1; + return(OK); + case B3SOI_MOD_WW0: + value->rValue = model->B3SOIww0; + return(OK); + case B3SOI_MOD_WNLX: + value->rValue = model->B3SOIwnlx; + return(OK); + case B3SOI_MOD_WDVT0 : + value->rValue = model->B3SOIwdvt0; + return(OK); + case B3SOI_MOD_WDVT1 : + value->rValue = model->B3SOIwdvt1; + return(OK); + case B3SOI_MOD_WDVT2 : + value->rValue = model->B3SOIwdvt2; + return(OK); + case B3SOI_MOD_WDVT0W : + value->rValue = model->B3SOIwdvt0w; + return(OK); + case B3SOI_MOD_WDVT1W : + value->rValue = model->B3SOIwdvt1w; + return(OK); + case B3SOI_MOD_WDVT2W : + value->rValue = model->B3SOIwdvt2w; + return(OK); + case B3SOI_MOD_WU0: + value->rValue = model->B3SOIwu0; + return(OK); + case B3SOI_MOD_WUA: + value->rValue = model->B3SOIwua; + return(OK); + case B3SOI_MOD_WUB: + value->rValue = model->B3SOIwub; + return(OK); + case B3SOI_MOD_WUC: + value->rValue = model->B3SOIwuc; + return(OK); + case B3SOI_MOD_WVSAT: + value->rValue = model->B3SOIwvsat; + return(OK); + case B3SOI_MOD_WA0: + value->rValue = model->B3SOIwa0; + return(OK); + case B3SOI_MOD_WAGS: + value->rValue = model->B3SOIwags; + return(OK); + case B3SOI_MOD_WB0: + value->rValue = model->B3SOIwb0; + return(OK); + case B3SOI_MOD_WB1: + value->rValue = model->B3SOIwb1; + return(OK); + case B3SOI_MOD_WKETA: + value->rValue = model->B3SOIwketa; + return(OK); + case B3SOI_MOD_WKETAS: + value->rValue = model->B3SOIwketas; + return(OK); + case B3SOI_MOD_WA1: + value->rValue = model->B3SOIwa1; + return(OK); + case B3SOI_MOD_WA2: + value->rValue = model->B3SOIwa2; + return(OK); + case B3SOI_MOD_WRDSW: + value->rValue = model->B3SOIwrdsw; + return(OK); + case B3SOI_MOD_WPRWB: + value->rValue = model->B3SOIwprwb; + return(OK); + case B3SOI_MOD_WPRWG: + value->rValue = model->B3SOIwprwg; + return(OK); + case B3SOI_MOD_WWR: + value->rValue = model->B3SOIwwr; + return(OK); + case B3SOI_MOD_WNFACTOR : + value->rValue = model->B3SOIwnfactor; + return(OK); + case B3SOI_MOD_WDWG: + value->rValue = model->B3SOIwdwg; + return(OK); + case B3SOI_MOD_WDWB: + value->rValue = model->B3SOIwdwb; + return(OK); + case B3SOI_MOD_WVOFF: + value->rValue = model->B3SOIwvoff; + return(OK); + case B3SOI_MOD_WETA0: + value->rValue = model->B3SOIweta0; + return(OK); + case B3SOI_MOD_WETAB: + value->rValue = model->B3SOIwetab; + return(OK); + case B3SOI_MOD_WDSUB : + value->rValue = model->B3SOIwdsub; + return(OK); + case B3SOI_MOD_WCIT : + value->rValue = model->B3SOIwcit; + return(OK); + case B3SOI_MOD_WCDSC : + value->rValue = model->B3SOIwcdsc; + return(OK); + case B3SOI_MOD_WCDSCB : + value->rValue = model->B3SOIwcdscb; + return(OK); + case B3SOI_MOD_WCDSCD : + value->rValue = model->B3SOIwcdscd; + return(OK); + case B3SOI_MOD_WPCLM: + value->rValue = model->B3SOIwpclm; + return(OK); + case B3SOI_MOD_WPDIBL1: + value->rValue = model->B3SOIwpdibl1; + return(OK); + case B3SOI_MOD_WPDIBL2: + value->rValue = model->B3SOIwpdibl2; + return(OK); + case B3SOI_MOD_WPDIBLB: + value->rValue = model->B3SOIwpdiblb; + return(OK); + case B3SOI_MOD_WDROUT : + value->rValue = model->B3SOIwdrout; + return(OK); + case B3SOI_MOD_WPVAG: + value->rValue = model->B3SOIwpvag; + return(OK); + case B3SOI_MOD_WDELTA: + value->rValue = model->B3SOIwdelta; + return(OK); + case B3SOI_MOD_WALPHA0: + value->rValue = model->B3SOIwalpha0; + return(OK); + case B3SOI_MOD_WFBJTII: + value->rValue = model->B3SOIwfbjtii; + return(OK); + case B3SOI_MOD_WBETA0: + value->rValue = model->B3SOIwbeta0; + return(OK); + case B3SOI_MOD_WBETA1: + value->rValue = model->B3SOIwbeta1; + return(OK); + case B3SOI_MOD_WBETA2: + value->rValue = model->B3SOIwbeta2; + return(OK); + case B3SOI_MOD_WVDSATII0: + value->rValue = model->B3SOIwvdsatii0; + return(OK); + case B3SOI_MOD_WLII: + value->rValue = model->B3SOIwlii; + return(OK); + case B3SOI_MOD_WESATII: + value->rValue = model->B3SOIwesatii; + return(OK); + case B3SOI_MOD_WSII0: + value->rValue = model->B3SOIwsii0; + return(OK); + case B3SOI_MOD_WSII1: + value->rValue = model->B3SOIwsii1; + return(OK); + case B3SOI_MOD_WSII2: + value->rValue = model->B3SOIwsii2; + return(OK); + case B3SOI_MOD_WSIID: + value->rValue = model->B3SOIwsiid; + return(OK); + case B3SOI_MOD_WAGIDL: + value->rValue = model->B3SOIwagidl; + return(OK); + case B3SOI_MOD_WBGIDL: + value->rValue = model->B3SOIwbgidl; + return(OK); + case B3SOI_MOD_WNGIDL: + value->rValue = model->B3SOIwngidl; + return(OK); + case B3SOI_MOD_WNTUN: + value->rValue = model->B3SOIwntun; + return(OK); + case B3SOI_MOD_WNDIODE: + value->rValue = model->B3SOIwndiode; + return(OK); + case B3SOI_MOD_WNRECF0: + value->rValue = model->B3SOIwnrecf0; + return(OK); + case B3SOI_MOD_WNRECR0: + value->rValue = model->B3SOIwnrecr0; + return(OK); + case B3SOI_MOD_WISBJT: + value->rValue = model->B3SOIwisbjt; + return(OK); + case B3SOI_MOD_WISDIF: + value->rValue = model->B3SOIwisdif; + return(OK); + case B3SOI_MOD_WISREC: + value->rValue = model->B3SOIwisrec; + return(OK); + case B3SOI_MOD_WISTUN: + value->rValue = model->B3SOIwistun; + return(OK); + case B3SOI_MOD_WVREC0: + value->rValue = model->B3SOIwvrec0; + return(OK); + case B3SOI_MOD_WVTUN0: + value->rValue = model->B3SOIwvtun0; + return(OK); + case B3SOI_MOD_WNBJT: + value->rValue = model->B3SOIwnbjt; + return(OK); + case B3SOI_MOD_WLBJT0: + value->rValue = model->B3SOIwlbjt0; + return(OK); + case B3SOI_MOD_WVABJT: + value->rValue = model->B3SOIwvabjt; + return(OK); + case B3SOI_MOD_WAELY: + value->rValue = model->B3SOIwaely; + return(OK); + case B3SOI_MOD_WAHLI: + value->rValue = model->B3SOIwahli; + return(OK); + /* CV Model */ + case B3SOI_MOD_WVSDFB: + value->rValue = model->B3SOIwvsdfb; + return(OK); + case B3SOI_MOD_WVSDTH: + value->rValue = model->B3SOIwvsdth; + return(OK); + case B3SOI_MOD_WDELVT: + value->rValue = model->B3SOIwdelvt; + return(OK); + case B3SOI_MOD_WACDE: + value->rValue = model->B3SOIwacde; + return(OK); + case B3SOI_MOD_WMOIN: + value->rValue = model->B3SOIwmoin; + return(OK); + + /* Cross-term Dependence */ +/* v3.0 */ + case B3SOI_MOD_PAIGC: + value->rValue = model->B3SOIpaigc; + return(OK); + case B3SOI_MOD_PBIGC: + value->rValue = model->B3SOIpbigc; + return(OK); + case B3SOI_MOD_PCIGC: + value->rValue = model->B3SOIpcigc; + return(OK); + case B3SOI_MOD_PAIGSD: + value->rValue = model->B3SOIpaigsd; + return(OK); + case B3SOI_MOD_PBIGSD: + value->rValue = model->B3SOIpbigsd; + return(OK); + case B3SOI_MOD_PCIGSD: + value->rValue = model->B3SOIpcigsd; + return(OK); + case B3SOI_MOD_PNIGC: + value->rValue = model->B3SOIpnigc; + return(OK); + case B3SOI_MOD_PPIGCD: + value->rValue = model->B3SOIppigcd; + return(OK); + case B3SOI_MOD_PPOXEDGE: + value->rValue = model->B3SOIppoxedge; + return(OK); + + case B3SOI_MOD_PNPEAK: + value->rValue = model->B3SOIpnpeak; + return(OK); + case B3SOI_MOD_PNSUB: + value->rValue = model->B3SOIpnsub; + return(OK); + case B3SOI_MOD_PNGATE: + value->rValue = model->B3SOIpngate; + return(OK); + case B3SOI_MOD_PVTH0: + value->rValue = model->B3SOIpvth0; + return(OK); + case B3SOI_MOD_PK1: + value->rValue = model->B3SOIpk1; + return(OK); + case B3SOI_MOD_PK1W1: + value->rValue = model->B3SOIpk1w1; + return(OK); + case B3SOI_MOD_PK1W2: + value->rValue = model->B3SOIpk1w2; + return(OK); + case B3SOI_MOD_PK2: + value->rValue = model->B3SOIpk2; + return(OK); + case B3SOI_MOD_PK3: + value->rValue = model->B3SOIpk3; + return(OK); + case B3SOI_MOD_PK3B: + value->rValue = model->B3SOIpk3b; + return(OK); + case B3SOI_MOD_PKB1: + value->rValue = model->B3SOIpkb1; + return(OK); + case B3SOI_MOD_PW0: + value->rValue = model->B3SOIpw0; + return(OK); + case B3SOI_MOD_PNLX: + value->rValue = model->B3SOIpnlx; + return(OK); + case B3SOI_MOD_PDVT0 : + value->rValue = model->B3SOIpdvt0; + return(OK); + case B3SOI_MOD_PDVT1 : + value->rValue = model->B3SOIpdvt1; + return(OK); + case B3SOI_MOD_PDVT2 : + value->rValue = model->B3SOIpdvt2; + return(OK); + case B3SOI_MOD_PDVT0W : + value->rValue = model->B3SOIpdvt0w; + return(OK); + case B3SOI_MOD_PDVT1W : + value->rValue = model->B3SOIpdvt1w; + return(OK); + case B3SOI_MOD_PDVT2W : + value->rValue = model->B3SOIpdvt2w; + return(OK); + case B3SOI_MOD_PU0: + value->rValue = model->B3SOIpu0; + return(OK); + case B3SOI_MOD_PUA: + value->rValue = model->B3SOIpua; + return(OK); + case B3SOI_MOD_PUB: + value->rValue = model->B3SOIpub; + return(OK); + case B3SOI_MOD_PUC: + value->rValue = model->B3SOIpuc; + return(OK); + case B3SOI_MOD_PVSAT: + value->rValue = model->B3SOIpvsat; + return(OK); + case B3SOI_MOD_PA0: + value->rValue = model->B3SOIpa0; + return(OK); + case B3SOI_MOD_PAGS: + value->rValue = model->B3SOIpags; + return(OK); + case B3SOI_MOD_PB0: + value->rValue = model->B3SOIpb0; + return(OK); + case B3SOI_MOD_PB1: + value->rValue = model->B3SOIpb1; + return(OK); + case B3SOI_MOD_PKETA: + value->rValue = model->B3SOIpketa; + return(OK); + case B3SOI_MOD_PKETAS: + value->rValue = model->B3SOIpketas; + return(OK); + case B3SOI_MOD_PA1: + value->rValue = model->B3SOIpa1; + return(OK); + case B3SOI_MOD_PA2: + value->rValue = model->B3SOIpa2; + return(OK); + case B3SOI_MOD_PRDSW: + value->rValue = model->B3SOIprdsw; + return(OK); + case B3SOI_MOD_PPRWB: + value->rValue = model->B3SOIpprwb; + return(OK); + case B3SOI_MOD_PPRWG: + value->rValue = model->B3SOIpprwg; + return(OK); + case B3SOI_MOD_PWR: + value->rValue = model->B3SOIpwr; + return(OK); + case B3SOI_MOD_PNFACTOR : + value->rValue = model->B3SOIpnfactor; + return(OK); + case B3SOI_MOD_PDWG: + value->rValue = model->B3SOIpdwg; + return(OK); + case B3SOI_MOD_PDWB: + value->rValue = model->B3SOIpdwb; + return(OK); + case B3SOI_MOD_PVOFF: + value->rValue = model->B3SOIpvoff; + return(OK); + case B3SOI_MOD_PETA0: + value->rValue = model->B3SOIpeta0; + return(OK); + case B3SOI_MOD_PETAB: + value->rValue = model->B3SOIpetab; + return(OK); + case B3SOI_MOD_PDSUB : + value->rValue = model->B3SOIpdsub; + return(OK); + case B3SOI_MOD_PCIT : + value->rValue = model->B3SOIpcit; + return(OK); + case B3SOI_MOD_PCDSC : + value->rValue = model->B3SOIpcdsc; + return(OK); + case B3SOI_MOD_PCDSCB : + value->rValue = model->B3SOIpcdscb; + return(OK); + case B3SOI_MOD_PCDSCD : + value->rValue = model->B3SOIpcdscd; + return(OK); + case B3SOI_MOD_PPCLM: + value->rValue = model->B3SOIppclm; + return(OK); + case B3SOI_MOD_PPDIBL1: + value->rValue = model->B3SOIppdibl1; + return(OK); + case B3SOI_MOD_PPDIBL2: + value->rValue = model->B3SOIppdibl2; + return(OK); + case B3SOI_MOD_PPDIBLB: + value->rValue = model->B3SOIppdiblb; + return(OK); + case B3SOI_MOD_PDROUT : + value->rValue = model->B3SOIpdrout; + return(OK); + case B3SOI_MOD_PPVAG: + value->rValue = model->B3SOIppvag; + return(OK); + case B3SOI_MOD_PDELTA: + value->rValue = model->B3SOIpdelta; + return(OK); + case B3SOI_MOD_PALPHA0: + value->rValue = model->B3SOIpalpha0; + return(OK); + case B3SOI_MOD_PFBJTII: + value->rValue = model->B3SOIpfbjtii; + return(OK); + case B3SOI_MOD_PBETA0: + value->rValue = model->B3SOIpbeta0; + return(OK); + case B3SOI_MOD_PBETA1: + value->rValue = model->B3SOIpbeta1; + return(OK); + case B3SOI_MOD_PBETA2: + value->rValue = model->B3SOIpbeta2; + return(OK); + case B3SOI_MOD_PVDSATII0: + value->rValue = model->B3SOIpvdsatii0; + return(OK); + case B3SOI_MOD_PLII: + value->rValue = model->B3SOIplii; + return(OK); + case B3SOI_MOD_PESATII: + value->rValue = model->B3SOIpesatii; + return(OK); + case B3SOI_MOD_PSII0: + value->rValue = model->B3SOIpsii0; + return(OK); + case B3SOI_MOD_PSII1: + value->rValue = model->B3SOIpsii1; + return(OK); + case B3SOI_MOD_PSII2: + value->rValue = model->B3SOIpsii2; + return(OK); + case B3SOI_MOD_PSIID: + value->rValue = model->B3SOIpsiid; + return(OK); + case B3SOI_MOD_PAGIDL: + value->rValue = model->B3SOIpagidl; + return(OK); + case B3SOI_MOD_PBGIDL: + value->rValue = model->B3SOIpbgidl; + return(OK); + case B3SOI_MOD_PNGIDL: + value->rValue = model->B3SOIpngidl; + return(OK); + case B3SOI_MOD_PNTUN: + value->rValue = model->B3SOIpntun; + return(OK); + case B3SOI_MOD_PNDIODE: + value->rValue = model->B3SOIpndiode; + return(OK); + case B3SOI_MOD_PNRECF0: + value->rValue = model->B3SOIpnrecf0; + return(OK); + case B3SOI_MOD_PNRECR0: + value->rValue = model->B3SOIpnrecr0; + return(OK); + case B3SOI_MOD_PISBJT: + value->rValue = model->B3SOIpisbjt; + return(OK); + case B3SOI_MOD_PISDIF: + value->rValue = model->B3SOIpisdif; + return(OK); + case B3SOI_MOD_PISREC: + value->rValue = model->B3SOIpisrec; + return(OK); + case B3SOI_MOD_PISTUN: + value->rValue = model->B3SOIpistun; + return(OK); + case B3SOI_MOD_PVREC0: + value->rValue = model->B3SOIpvrec0; + return(OK); + case B3SOI_MOD_PVTUN0: + value->rValue = model->B3SOIpvtun0; + return(OK); + case B3SOI_MOD_PNBJT: + value->rValue = model->B3SOIpnbjt; + return(OK); + case B3SOI_MOD_PLBJT0: + value->rValue = model->B3SOIplbjt0; + return(OK); + case B3SOI_MOD_PVABJT: + value->rValue = model->B3SOIpvabjt; + return(OK); + case B3SOI_MOD_PAELY: + value->rValue = model->B3SOIpaely; + return(OK); + case B3SOI_MOD_PAHLI: + value->rValue = model->B3SOIpahli; + return(OK); + /* CV Model */ + case B3SOI_MOD_PVSDFB: + value->rValue = model->B3SOIpvsdfb; + return(OK); + case B3SOI_MOD_PVSDTH: + value->rValue = model->B3SOIpvsdth; + return(OK); + case B3SOI_MOD_PDELVT: + value->rValue = model->B3SOIpdelvt; + return(OK); + case B3SOI_MOD_PACDE: + value->rValue = model->B3SOIpacde; + return(OK); + case B3SOI_MOD_PMOIN: + value->rValue = model->B3SOIpmoin; + return(OK); +/* Added for binning - END */ + + default: + return(E_BADPARM); + } + /* NOTREACHED */ +} + + + diff --git a/src/spicelib/devices/bsim3soi/b3soimdel.c b/src/spicelib/devices/bsim3soi/b3soimdel.c new file mode 100644 index 000000000..a9f1022dd --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soimdel.c @@ -0,0 +1,44 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soimdel.c 98/5/01 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "b3soidef.h" +#include "sperror.h" +#include "suffix.h" + +int +B3SOImDelete(GENmodel **inModel, IFuid modname, GENmodel *kill) +{ +B3SOImodel **model = (B3SOImodel**)inModel; +B3SOImodel *modfast = (B3SOImodel*)kill; +B3SOIinstance *here; +B3SOIinstance *prev = NULL; +B3SOImodel **oldmod; + + oldmod = model; + for (; *model ; model = &((*model)->B3SOInextModel)) + { if ((*model)->B3SOImodName == modname || + (modfast && *model == modfast)) + goto delgot; + oldmod = model; + } + return(E_NOMOD); + +delgot: + *oldmod = (*model)->B3SOInextModel; /* cut deleted device out of list */ + for (here = (*model)->B3SOIinstances; here; here = here->B3SOInextInstance) + { if(prev) FREE(prev); + prev = here; + } + if(prev) FREE(prev); + FREE(*model); + return(OK); +} + + + diff --git a/src/spicelib/devices/bsim3soi/b3soimpar.c b/src/spicelib/devices/bsim3soi/b3soimpar.c new file mode 100644 index 000000000..eb81c0047 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soimpar.c @@ -0,0 +1,2158 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soimpar.c 98/5/01 +Modified by Pin Su and Jan Feng 99/2/15 +Modified by Pin Su 99/4/30 +Modified by Wei Jin 99/9/27 +Modified by Pin Su 00/3/1 +Modified by Pin Su 01/2/15 +Modified by Pin Su 02/3/5 +Modified by Pin Su 02/5/20 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "b3soidef.h" +#include "ifsim.h" +#include "sperror.h" +#include "suffix.h" + + +int +B3SOImParam(int param, IFvalue *value, GENmodel *inMod) +{ + B3SOImodel *mod = (B3SOImodel*)inMod; + switch(param) + { + + case B3SOI_MOD_MOBMOD : + mod->B3SOImobMod = value->iValue; + mod->B3SOImobModGiven = TRUE; + break; + case B3SOI_MOD_BINUNIT : + mod->B3SOIbinUnit = value->iValue; + mod->B3SOIbinUnitGiven = TRUE; + break; + case B3SOI_MOD_PARAMCHK : + mod->B3SOIparamChk = value->iValue; + mod->B3SOIparamChkGiven = TRUE; + break; + case B3SOI_MOD_CAPMOD : + mod->B3SOIcapMod = value->iValue; + mod->B3SOIcapModGiven = TRUE; + break; + case B3SOI_MOD_SHMOD : + mod->B3SOIshMod = value->iValue; + mod->B3SOIshModGiven = TRUE; + break; + case B3SOI_MOD_NOIMOD : + mod->B3SOInoiMod = value->iValue; + mod->B3SOInoiModGiven = TRUE; + break; + case B3SOI_MOD_VERSION : + mod->B3SOIversion = value->rValue; + mod->B3SOIversionGiven = TRUE; + break; + case B3SOI_MOD_TOX : + mod->B3SOItox = value->rValue; + mod->B3SOItoxGiven = TRUE; + break; +/* v2.2.3 */ + case B3SOI_MOD_DTOXCV : + mod->B3SOIdtoxcv = value->rValue; + mod->B3SOIdtoxcvGiven = TRUE; + break; + + case B3SOI_MOD_CDSC : + mod->B3SOIcdsc = value->rValue; + mod->B3SOIcdscGiven = TRUE; + break; + case B3SOI_MOD_CDSCB : + mod->B3SOIcdscb = value->rValue; + mod->B3SOIcdscbGiven = TRUE; + break; + + case B3SOI_MOD_CDSCD : + mod->B3SOIcdscd = value->rValue; + mod->B3SOIcdscdGiven = TRUE; + break; + + case B3SOI_MOD_CIT : + mod->B3SOIcit = value->rValue; + mod->B3SOIcitGiven = TRUE; + break; + case B3SOI_MOD_NFACTOR : + mod->B3SOInfactor = value->rValue; + mod->B3SOInfactorGiven = TRUE; + break; + case B3SOI_MOD_VSAT: + mod->B3SOIvsat = value->rValue; + mod->B3SOIvsatGiven = TRUE; + break; + case B3SOI_MOD_A0: + mod->B3SOIa0 = value->rValue; + mod->B3SOIa0Given = TRUE; + break; + + case B3SOI_MOD_AGS: + mod->B3SOIags= value->rValue; + mod->B3SOIagsGiven = TRUE; + break; + + case B3SOI_MOD_A1: + mod->B3SOIa1 = value->rValue; + mod->B3SOIa1Given = TRUE; + break; + case B3SOI_MOD_A2: + mod->B3SOIa2 = value->rValue; + mod->B3SOIa2Given = TRUE; + break; + case B3SOI_MOD_AT: + mod->B3SOIat = value->rValue; + mod->B3SOIatGiven = TRUE; + break; + case B3SOI_MOD_KETA: + mod->B3SOIketa = value->rValue; + mod->B3SOIketaGiven = TRUE; + break; + case B3SOI_MOD_NSUB: + mod->B3SOInsub = value->rValue; + mod->B3SOInsubGiven = TRUE; + break; + case B3SOI_MOD_NPEAK: + mod->B3SOInpeak = value->rValue; + mod->B3SOInpeakGiven = TRUE; + if (mod->B3SOInpeak > 1.0e20) + mod->B3SOInpeak *= 1.0e-6; + break; + case B3SOI_MOD_NGATE: + mod->B3SOIngate = value->rValue; + mod->B3SOIngateGiven = TRUE; + if (mod->B3SOIngate > 1.0e23) + mod->B3SOIngate *= 1.0e-6; + break; + case B3SOI_MOD_GAMMA1: + mod->B3SOIgamma1 = value->rValue; + mod->B3SOIgamma1Given = TRUE; + break; + case B3SOI_MOD_GAMMA2: + mod->B3SOIgamma2 = value->rValue; + mod->B3SOIgamma2Given = TRUE; + break; + case B3SOI_MOD_VBX: + mod->B3SOIvbx = value->rValue; + mod->B3SOIvbxGiven = TRUE; + break; + case B3SOI_MOD_VBM: + mod->B3SOIvbm = value->rValue; + mod->B3SOIvbmGiven = TRUE; + break; + case B3SOI_MOD_XT: + mod->B3SOIxt = value->rValue; + mod->B3SOIxtGiven = TRUE; + break; + case B3SOI_MOD_K1: + mod->B3SOIk1 = value->rValue; + mod->B3SOIk1Given = TRUE; + break; + case B3SOI_MOD_KT1: + mod->B3SOIkt1 = value->rValue; + mod->B3SOIkt1Given = TRUE; + break; + case B3SOI_MOD_KT1L: + mod->B3SOIkt1l = value->rValue; + mod->B3SOIkt1lGiven = TRUE; + break; + case B3SOI_MOD_KT2: + mod->B3SOIkt2 = value->rValue; + mod->B3SOIkt2Given = TRUE; + break; + case B3SOI_MOD_K2: + mod->B3SOIk2 = value->rValue; + mod->B3SOIk2Given = TRUE; + break; + case B3SOI_MOD_K3: + mod->B3SOIk3 = value->rValue; + mod->B3SOIk3Given = TRUE; + break; + case B3SOI_MOD_K3B: + mod->B3SOIk3b = value->rValue; + mod->B3SOIk3bGiven = TRUE; + break; + case B3SOI_MOD_NLX: + mod->B3SOInlx = value->rValue; + mod->B3SOInlxGiven = TRUE; + break; + case B3SOI_MOD_W0: + mod->B3SOIw0 = value->rValue; + mod->B3SOIw0Given = TRUE; + break; + case B3SOI_MOD_DVT0: + mod->B3SOIdvt0 = value->rValue; + mod->B3SOIdvt0Given = TRUE; + break; + case B3SOI_MOD_DVT1: + mod->B3SOIdvt1 = value->rValue; + mod->B3SOIdvt1Given = TRUE; + break; + case B3SOI_MOD_DVT2: + mod->B3SOIdvt2 = value->rValue; + mod->B3SOIdvt2Given = TRUE; + break; + case B3SOI_MOD_DVT0W: + mod->B3SOIdvt0w = value->rValue; + mod->B3SOIdvt0wGiven = TRUE; + break; + case B3SOI_MOD_DVT1W: + mod->B3SOIdvt1w = value->rValue; + mod->B3SOIdvt1wGiven = TRUE; + break; + case B3SOI_MOD_DVT2W: + mod->B3SOIdvt2w = value->rValue; + mod->B3SOIdvt2wGiven = TRUE; + break; + case B3SOI_MOD_DROUT: + mod->B3SOIdrout = value->rValue; + mod->B3SOIdroutGiven = TRUE; + break; + case B3SOI_MOD_DSUB: + mod->B3SOIdsub = value->rValue; + mod->B3SOIdsubGiven = TRUE; + break; + case B3SOI_MOD_VTH0: + mod->B3SOIvth0 = value->rValue; + mod->B3SOIvth0Given = TRUE; + break; + case B3SOI_MOD_UA: + mod->B3SOIua = value->rValue; + mod->B3SOIuaGiven = TRUE; + break; + case B3SOI_MOD_UA1: + mod->B3SOIua1 = value->rValue; + mod->B3SOIua1Given = TRUE; + break; + case B3SOI_MOD_UB: + mod->B3SOIub = value->rValue; + mod->B3SOIubGiven = TRUE; + break; + case B3SOI_MOD_UB1: + mod->B3SOIub1 = value->rValue; + mod->B3SOIub1Given = TRUE; + break; + case B3SOI_MOD_UC: + mod->B3SOIuc = value->rValue; + mod->B3SOIucGiven = TRUE; + break; + case B3SOI_MOD_UC1: + mod->B3SOIuc1 = value->rValue; + mod->B3SOIuc1Given = TRUE; + break; + case B3SOI_MOD_U0 : + mod->B3SOIu0 = value->rValue; + mod->B3SOIu0Given = TRUE; + break; + case B3SOI_MOD_UTE : + mod->B3SOIute = value->rValue; + mod->B3SOIuteGiven = TRUE; + break; + case B3SOI_MOD_VOFF: + mod->B3SOIvoff = value->rValue; + mod->B3SOIvoffGiven = TRUE; + break; + case B3SOI_MOD_DELTA : + mod->B3SOIdelta = value->rValue; + mod->B3SOIdeltaGiven = TRUE; + break; + case B3SOI_MOD_RDSW: + mod->B3SOIrdsw = value->rValue; + mod->B3SOIrdswGiven = TRUE; + break; + case B3SOI_MOD_PRWG: + mod->B3SOIprwg = value->rValue; + mod->B3SOIprwgGiven = TRUE; + break; + case B3SOI_MOD_PRWB: + mod->B3SOIprwb = value->rValue; + mod->B3SOIprwbGiven = TRUE; + break; + case B3SOI_MOD_PRT: + mod->B3SOIprt = value->rValue; + mod->B3SOIprtGiven = TRUE; + break; + case B3SOI_MOD_ETA0: + mod->B3SOIeta0 = value->rValue; + mod->B3SOIeta0Given = TRUE; + break; + case B3SOI_MOD_ETAB: + mod->B3SOIetab = value->rValue; + mod->B3SOIetabGiven = TRUE; + break; + case B3SOI_MOD_PCLM: + mod->B3SOIpclm = value->rValue; + mod->B3SOIpclmGiven = TRUE; + break; + case B3SOI_MOD_PDIBL1: + mod->B3SOIpdibl1 = value->rValue; + mod->B3SOIpdibl1Given = TRUE; + break; + case B3SOI_MOD_PDIBL2: + mod->B3SOIpdibl2 = value->rValue; + mod->B3SOIpdibl2Given = TRUE; + break; + case B3SOI_MOD_PDIBLB: + mod->B3SOIpdiblb = value->rValue; + mod->B3SOIpdiblbGiven = TRUE; + break; + case B3SOI_MOD_PVAG: + mod->B3SOIpvag = value->rValue; + mod->B3SOIpvagGiven = TRUE; + break; + case B3SOI_MOD_WR : + mod->B3SOIwr = value->rValue; + mod->B3SOIwrGiven = TRUE; + break; + case B3SOI_MOD_DWG : + mod->B3SOIdwg = value->rValue; + mod->B3SOIdwgGiven = TRUE; + break; + case B3SOI_MOD_DWB : + mod->B3SOIdwb = value->rValue; + mod->B3SOIdwbGiven = TRUE; + break; + case B3SOI_MOD_B0 : + mod->B3SOIb0 = value->rValue; + mod->B3SOIb0Given = TRUE; + break; + case B3SOI_MOD_B1 : + mod->B3SOIb1 = value->rValue; + mod->B3SOIb1Given = TRUE; + break; + case B3SOI_MOD_ALPHA0 : + mod->B3SOIalpha0 = value->rValue; + mod->B3SOIalpha0Given = TRUE; + break; + + case B3SOI_MOD_CGSL : + mod->B3SOIcgsl = value->rValue; + mod->B3SOIcgslGiven = TRUE; + break; + case B3SOI_MOD_CGDL : + mod->B3SOIcgdl = value->rValue; + mod->B3SOIcgdlGiven = TRUE; + break; + case B3SOI_MOD_CKAPPA : + mod->B3SOIckappa = value->rValue; + mod->B3SOIckappaGiven = TRUE; + break; + case B3SOI_MOD_CF : + mod->B3SOIcf = value->rValue; + mod->B3SOIcfGiven = TRUE; + break; + case B3SOI_MOD_CLC : + mod->B3SOIclc = value->rValue; + mod->B3SOIclcGiven = TRUE; + break; + case B3SOI_MOD_CLE : + mod->B3SOIcle = value->rValue; + mod->B3SOIcleGiven = TRUE; + break; + case B3SOI_MOD_DWC : + mod->B3SOIdwc = value->rValue; + mod->B3SOIdwcGiven = TRUE; + break; + case B3SOI_MOD_DLC : + mod->B3SOIdlc = value->rValue; + mod->B3SOIdlcGiven = TRUE; + break; + case B3SOI_MOD_TBOX : + mod->B3SOItbox = value->rValue; + mod->B3SOItboxGiven = TRUE; + break; + case B3SOI_MOD_TSI : + mod->B3SOItsi = value->rValue; + mod->B3SOItsiGiven = TRUE; + break; + case B3SOI_MOD_XJ : + mod->B3SOIxj = value->rValue; + mod->B3SOIxjGiven = TRUE; + break; + case B3SOI_MOD_RBODY : + mod->B3SOIrbody = value->rValue; + mod->B3SOIrbodyGiven = TRUE; + break; + case B3SOI_MOD_RBSH : + mod->B3SOIrbsh = value->rValue; + mod->B3SOIrbshGiven = TRUE; + break; + case B3SOI_MOD_RTH0 : + mod->B3SOIrth0 = value->rValue; + mod->B3SOIrth0Given = TRUE; + break; + case B3SOI_MOD_CTH0 : + mod->B3SOIcth0 = value->rValue; + mod->B3SOIcth0Given = TRUE; + break; + case B3SOI_MOD_NGIDL : + mod->B3SOIngidl = value->rValue; + mod->B3SOIngidlGiven = TRUE; + break; + case B3SOI_MOD_AGIDL : + mod->B3SOIagidl = value->rValue; + mod->B3SOIagidlGiven = TRUE; + break; + case B3SOI_MOD_BGIDL : + mod->B3SOIbgidl = value->rValue; + mod->B3SOIbgidlGiven = TRUE; + break; + case B3SOI_MOD_NDIODE : + mod->B3SOIndiode = value->rValue; + mod->B3SOIndiodeGiven = TRUE; + break; + case B3SOI_MOD_XBJT : + mod->B3SOIxbjt = value->rValue; + mod->B3SOIxbjtGiven = TRUE; + break; + + case B3SOI_MOD_XDIF : + mod->B3SOIxdif = value->rValue; + mod->B3SOIxdifGiven = TRUE; + break; + + case B3SOI_MOD_XREC : + mod->B3SOIxrec = value->rValue; + mod->B3SOIxrecGiven = TRUE; + break; + case B3SOI_MOD_XTUN : + mod->B3SOIxtun = value->rValue; + mod->B3SOIxtunGiven = TRUE; + break; + case B3SOI_MOD_TT : + mod->B3SOItt = value->rValue; + mod->B3SOIttGiven = TRUE; + break; + case B3SOI_MOD_VSDTH : + mod->B3SOIvsdth = value->rValue; + mod->B3SOIvsdthGiven = TRUE; + break; + case B3SOI_MOD_VSDFB : + mod->B3SOIvsdfb = value->rValue; + mod->B3SOIvsdfbGiven = TRUE; + break; + case B3SOI_MOD_CSDMIN : + mod->B3SOIcsdmin = value->rValue; + mod->B3SOIcsdminGiven = TRUE; + break; + case B3SOI_MOD_ASD : + mod->B3SOIasd = value->rValue; + mod->B3SOIasdGiven = TRUE; + break; + + + case B3SOI_MOD_TNOM : + mod->B3SOItnom = value->rValue + 273.15; + mod->B3SOItnomGiven = TRUE; + break; + case B3SOI_MOD_CGSO : + mod->B3SOIcgso = value->rValue; + mod->B3SOIcgsoGiven = TRUE; + break; + case B3SOI_MOD_CGDO : + mod->B3SOIcgdo = value->rValue; + mod->B3SOIcgdoGiven = TRUE; + break; + case B3SOI_MOD_CGEO : + mod->B3SOIcgeo = value->rValue; + mod->B3SOIcgeoGiven = TRUE; + break; + case B3SOI_MOD_XPART : + mod->B3SOIxpart = value->rValue; + mod->B3SOIxpartGiven = TRUE; + break; + case B3SOI_MOD_RSH : + mod->B3SOIsheetResistance = value->rValue; + mod->B3SOIsheetResistanceGiven = TRUE; + break; + case B3SOI_MOD_PBSWG : + mod->B3SOIGatesidewallJctPotential = value->rValue; + mod->B3SOIGatesidewallJctPotentialGiven = TRUE; + break; + case B3SOI_MOD_MJSWG : + mod->B3SOIbodyJctGateSideGradingCoeff = value->rValue; + mod->B3SOIbodyJctGateSideGradingCoeffGiven = TRUE; + break; + case B3SOI_MOD_CJSWG : + mod->B3SOIunitLengthGateSidewallJctCap = value->rValue; + mod->B3SOIunitLengthGateSidewallJctCapGiven = TRUE; + break; + case B3SOI_MOD_CSDESW : + mod->B3SOIcsdesw = value->rValue; + mod->B3SOIcsdeswGiven = TRUE; + break; + case B3SOI_MOD_LINT : + mod->B3SOILint = value->rValue; + mod->B3SOILintGiven = TRUE; + break; + case B3SOI_MOD_LL : + mod->B3SOILl = value->rValue; + mod->B3SOILlGiven = TRUE; + break; +/* v2.2.3 */ + case B3SOI_MOD_LLC : + mod->B3SOILlc = value->rValue; + mod->B3SOILlcGiven = TRUE; + break; + + case B3SOI_MOD_LLN : + mod->B3SOILln = value->rValue; + mod->B3SOILlnGiven = TRUE; + break; + case B3SOI_MOD_LW : + mod->B3SOILw = value->rValue; + mod->B3SOILwGiven = TRUE; + break; +/* v2.2.3 */ + case B3SOI_MOD_LWC : + mod->B3SOILwc = value->rValue; + mod->B3SOILwcGiven = TRUE; + break; + + case B3SOI_MOD_LWN : + mod->B3SOILwn = value->rValue; + mod->B3SOILwnGiven = TRUE; + break; + case B3SOI_MOD_LWL : + mod->B3SOILwl = value->rValue; + mod->B3SOILwlGiven = TRUE; + break; +/* v2.2.3 */ + case B3SOI_MOD_LWLC : + mod->B3SOILwlc = value->rValue; + mod->B3SOILwlcGiven = TRUE; + break; + + case B3SOI_MOD_WINT : + mod->B3SOIWint = value->rValue; + mod->B3SOIWintGiven = TRUE; + break; + case B3SOI_MOD_WL : + mod->B3SOIWl = value->rValue; + mod->B3SOIWlGiven = TRUE; + break; +/* v2.2.3 */ + case B3SOI_MOD_WLC : + mod->B3SOIWlc = value->rValue; + mod->B3SOIWlcGiven = TRUE; + break; + + case B3SOI_MOD_WLN : + mod->B3SOIWln = value->rValue; + mod->B3SOIWlnGiven = TRUE; + break; + case B3SOI_MOD_WW : + mod->B3SOIWw = value->rValue; + mod->B3SOIWwGiven = TRUE; + break; +/* v2.2.3 */ + case B3SOI_MOD_WWC : + mod->B3SOIWwc = value->rValue; + mod->B3SOIWwcGiven = TRUE; + break; + + case B3SOI_MOD_WWN : + mod->B3SOIWwn = value->rValue; + mod->B3SOIWwnGiven = TRUE; + break; + case B3SOI_MOD_WWL : + mod->B3SOIWwl = value->rValue; + mod->B3SOIWwlGiven = TRUE; + break; +/* v2.2.3 */ + case B3SOI_MOD_WWLC : + mod->B3SOIWwlc = value->rValue; + mod->B3SOIWwlcGiven = TRUE; + break; + + case B3SOI_MOD_NOIA : + mod->B3SOIoxideTrapDensityA = value->rValue; + mod->B3SOIoxideTrapDensityAGiven = TRUE; + break; + case B3SOI_MOD_NOIB : + mod->B3SOIoxideTrapDensityB = value->rValue; + mod->B3SOIoxideTrapDensityBGiven = TRUE; + break; + case B3SOI_MOD_NOIC : + mod->B3SOIoxideTrapDensityC = value->rValue; + mod->B3SOIoxideTrapDensityCGiven = TRUE; + break; + case B3SOI_MOD_NOIF : + mod->B3SOInoif = value->rValue; + mod->B3SOInoifGiven = TRUE; + break; + case B3SOI_MOD_EM : + mod->B3SOIem = value->rValue; + mod->B3SOIemGiven = TRUE; + break; + case B3SOI_MOD_EF : + mod->B3SOIef = value->rValue; + mod->B3SOIefGiven = TRUE; + break; + case B3SOI_MOD_AF : + mod->B3SOIaf = value->rValue; + mod->B3SOIafGiven = TRUE; + break; + case B3SOI_MOD_KF : + mod->B3SOIkf = value->rValue; + mod->B3SOIkfGiven = TRUE; + break; + +/* v3.0 */ + case B3SOI_MOD_SOIMOD: + mod->B3SOIsoiMod = value->rValue; + mod->B3SOIsoimodGiven = TRUE; + break; + case B3SOI_MOD_VBSA: + mod->B3SOIvbsa = value->rValue; + mod->B3SOIvbsaGiven = TRUE; + break; + case B3SOI_MOD_NOFFFD : + mod->B3SOInofffd = value->rValue; + mod->B3SOInofffdGiven = TRUE; + break; + case B3SOI_MOD_VOFFFD: + mod->B3SOIvofffd = value->rValue; + mod->B3SOIvofffdGiven = TRUE; + break; + case B3SOI_MOD_K1B: + mod->B3SOIk1b = value->rValue; + mod->B3SOIk1bGiven = TRUE; + break; + case B3SOI_MOD_K2B: + mod->B3SOIk2b = value->rValue; + mod->B3SOIk2bGiven = TRUE; + break; + case B3SOI_MOD_DK2B: + mod->B3SOIdk2b = value->rValue; + mod->B3SOIdk2bGiven = TRUE; + break; + case B3SOI_MOD_DVBD0: + mod->B3SOIdvbd0 = value->rValue; + mod->B3SOIdvbd0Given = TRUE; + break; + case B3SOI_MOD_DVBD1: + mod->B3SOIdvbd1 = value->rValue; + mod->B3SOIdvbd1Given = TRUE; + break; + case B3SOI_MOD_MOINFD: + mod->B3SOImoinFD = value->rValue; + mod->B3SOImoinFDGiven = TRUE; + break; + + +/* v2.2 release */ + case B3SOI_MOD_WTH0 : + mod->B3SOIwth0 = value->rValue; + mod->B3SOIwth0Given = TRUE; + break; + case B3SOI_MOD_RHALO : + mod->B3SOIrhalo = value->rValue; + mod->B3SOIrhaloGiven = TRUE; + break; + case B3SOI_MOD_NTOX : + mod->B3SOIntox = value->rValue; + mod->B3SOIntoxGiven = TRUE; + break; + case B3SOI_MOD_TOXREF : + mod->B3SOItoxref = value->rValue; + mod->B3SOItoxrefGiven = TRUE; + break; + case B3SOI_MOD_EBG : + mod->B3SOIebg = value->rValue; + mod->B3SOIebgGiven = TRUE; + break; + case B3SOI_MOD_VEVB : + mod->B3SOIvevb = value->rValue; + mod->B3SOIvevbGiven = TRUE; + break; + case B3SOI_MOD_ALPHAGB1 : + mod->B3SOIalphaGB1 = value->rValue; + mod->B3SOIalphaGB1Given = TRUE; + break; + case B3SOI_MOD_BETAGB1 : + mod->B3SOIbetaGB1 = value->rValue; + mod->B3SOIbetaGB1Given = TRUE; + break; + case B3SOI_MOD_VGB1 : + mod->B3SOIvgb1 = value->rValue; + mod->B3SOIvgb1Given = TRUE; + break; + case B3SOI_MOD_VECB : + mod->B3SOIvecb = value->rValue; + mod->B3SOIvecbGiven = TRUE; + break; + case B3SOI_MOD_ALPHAGB2 : + mod->B3SOIalphaGB2 = value->rValue; + mod->B3SOIalphaGB2Given = TRUE; + break; + case B3SOI_MOD_BETAGB2 : + mod->B3SOIbetaGB2 = value->rValue; + mod->B3SOIbetaGB2Given = TRUE; + break; + case B3SOI_MOD_VGB2 : + mod->B3SOIvgb2 = value->rValue; + mod->B3SOIvgb2Given = TRUE; + break; + case B3SOI_MOD_TOXQM : + mod->B3SOItoxqm = value->rValue; + mod->B3SOItoxqmGiven = TRUE; + break; + case B3SOI_MOD_VOXH : + mod->B3SOIvoxh = value->rValue; + mod->B3SOIvoxhGiven = TRUE; + break; + case B3SOI_MOD_DELTAVOX : + mod->B3SOIdeltavox = value->rValue; + mod->B3SOIdeltavoxGiven = TRUE; + break; + +/* v3.0 */ + case B3SOI_MOD_IGBMOD : + mod->B3SOIigbMod = value->iValue; + mod->B3SOIigbModGiven = TRUE; + break; + case B3SOI_MOD_IGCMOD : + mod->B3SOIigcMod = value->iValue; + mod->B3SOIigcModGiven = TRUE; + break; + case B3SOI_MOD_AIGC : + mod->B3SOIaigc = value->rValue; + mod->B3SOIaigcGiven = TRUE; + break; + case B3SOI_MOD_BIGC : + mod->B3SOIbigc = value->rValue; + mod->B3SOIbigcGiven = TRUE; + break; + case B3SOI_MOD_CIGC : + mod->B3SOIcigc = value->rValue; + mod->B3SOIcigcGiven = TRUE; + break; + case B3SOI_MOD_AIGSD : + mod->B3SOIaigsd = value->rValue; + mod->B3SOIaigsdGiven = TRUE; + break; + case B3SOI_MOD_BIGSD : + mod->B3SOIbigsd = value->rValue; + mod->B3SOIbigsdGiven = TRUE; + break; + case B3SOI_MOD_CIGSD : + mod->B3SOIcigsd = value->rValue; + mod->B3SOIcigsdGiven = TRUE; + break; + case B3SOI_MOD_NIGC : + mod->B3SOInigc = value->rValue; + mod->B3SOInigcGiven = TRUE; + break; + case B3SOI_MOD_PIGCD : + mod->B3SOIpigcd = value->rValue; + mod->B3SOIpigcdGiven = TRUE; + break; + case B3SOI_MOD_POXEDGE : + mod->B3SOIpoxedge = value->rValue; + mod->B3SOIpoxedgeGiven = TRUE; + break; + case B3SOI_MOD_DLCIG : + mod->B3SOIdlcig = value->rValue; + mod->B3SOIdlcigGiven = TRUE; + break; + +/* v2.0 release */ + case B3SOI_MOD_K1W1 : + mod->B3SOIk1w1 = value->rValue; + mod->B3SOIk1w1Given = TRUE; + break; + case B3SOI_MOD_K1W2 : + mod->B3SOIk1w2 = value->rValue; + mod->B3SOIk1w2Given = TRUE; + break; + case B3SOI_MOD_KETAS : + mod->B3SOIketas = value->rValue; + mod->B3SOIketasGiven = TRUE; + break; + case B3SOI_MOD_DWBC : + mod->B3SOIdwbc = value->rValue; + mod->B3SOIdwbcGiven = TRUE; + break; + case B3SOI_MOD_BETA0 : + mod->B3SOIbeta0 = value->rValue; + mod->B3SOIbeta0Given = TRUE; + break; + case B3SOI_MOD_BETA1 : + mod->B3SOIbeta1 = value->rValue; + mod->B3SOIbeta1Given = TRUE; + break; + case B3SOI_MOD_BETA2 : + mod->B3SOIbeta2 = value->rValue; + mod->B3SOIbeta2Given = TRUE; + break; + case B3SOI_MOD_VDSATII0 : + mod->B3SOIvdsatii0 = value->rValue; + mod->B3SOIvdsatii0Given = TRUE; + break; + case B3SOI_MOD_TII : + mod->B3SOItii = value->rValue; + mod->B3SOItiiGiven = TRUE; + break; + case B3SOI_MOD_LII : + mod->B3SOIlii = value->rValue; + mod->B3SOIliiGiven = TRUE; + break; + case B3SOI_MOD_SII0 : + mod->B3SOIsii0 = value->rValue; + mod->B3SOIsii0Given = TRUE; + break; + case B3SOI_MOD_SII1 : + mod->B3SOIsii1 = value->rValue; + mod->B3SOIsii1Given = TRUE; + break; + case B3SOI_MOD_SII2 : + mod->B3SOIsii2 = value->rValue; + mod->B3SOIsii2Given = TRUE; + break; + case B3SOI_MOD_SIID : + mod->B3SOIsiid = value->rValue; + mod->B3SOIsiidGiven = TRUE; + break; + case B3SOI_MOD_FBJTII : + mod->B3SOIfbjtii = value->rValue; + mod->B3SOIfbjtiiGiven = TRUE; + break; + case B3SOI_MOD_ESATII : + mod->B3SOIesatii = value->rValue; + mod->B3SOIesatiiGiven = TRUE; + break; + case B3SOI_MOD_NTUN : + mod->B3SOIntun = value->rValue; + mod->B3SOIntunGiven = TRUE; + break; + case B3SOI_MOD_NRECF0 : + mod->B3SOInrecf0 = value->rValue; + mod->B3SOInrecf0Given = TRUE; + break; + case B3SOI_MOD_NRECR0 : + mod->B3SOInrecr0 = value->rValue; + mod->B3SOInrecr0Given = TRUE; + break; + case B3SOI_MOD_ISBJT : + mod->B3SOIisbjt = value->rValue; + mod->B3SOIisbjtGiven = TRUE; + break; + case B3SOI_MOD_ISDIF : + mod->B3SOIisdif = value->rValue; + mod->B3SOIisdifGiven = TRUE; + break; + case B3SOI_MOD_ISREC : + mod->B3SOIisrec = value->rValue; + mod->B3SOIisrecGiven = TRUE; + break; + case B3SOI_MOD_ISTUN : + mod->B3SOIistun = value->rValue; + mod->B3SOIistunGiven = TRUE; + break; + case B3SOI_MOD_LN : + mod->B3SOIln = value->rValue; + mod->B3SOIlnGiven = TRUE; + break; + case B3SOI_MOD_VREC0 : + mod->B3SOIvrec0 = value->rValue; + mod->B3SOIvrec0Given = TRUE; + break; + case B3SOI_MOD_VTUN0 : + mod->B3SOIvtun0 = value->rValue; + mod->B3SOIvtun0Given = TRUE; + break; + case B3SOI_MOD_NBJT : + mod->B3SOInbjt = value->rValue; + mod->B3SOInbjtGiven = TRUE; + break; + case B3SOI_MOD_LBJT0 : + mod->B3SOIlbjt0 = value->rValue; + mod->B3SOIlbjt0Given = TRUE; + break; + case B3SOI_MOD_LDIF0 : + mod->B3SOIldif0 = value->rValue; + mod->B3SOIldif0Given = TRUE; + break; + case B3SOI_MOD_VABJT : + mod->B3SOIvabjt = value->rValue; + mod->B3SOIvabjtGiven = TRUE; + break; + case B3SOI_MOD_AELY : + mod->B3SOIaely = value->rValue; + mod->B3SOIaelyGiven = TRUE; + break; + case B3SOI_MOD_AHLI : + mod->B3SOIahli = value->rValue; + mod->B3SOIahliGiven = TRUE; + break; + case B3SOI_MOD_NDIF : + mod->B3SOIndif = value->rValue; + mod->B3SOIndifGiven = TRUE; + break; + case B3SOI_MOD_NTRECF : + mod->B3SOIntrecf = value->rValue; + mod->B3SOIntrecfGiven = TRUE; + break; + case B3SOI_MOD_NTRECR : + mod->B3SOIntrecr = value->rValue; + mod->B3SOIntrecrGiven = TRUE; + break; + case B3SOI_MOD_DLCB : + mod->B3SOIdlcb = value->rValue; + mod->B3SOIdlcbGiven = TRUE; + break; + case B3SOI_MOD_FBODY : + mod->B3SOIfbody = value->rValue; + mod->B3SOIfbodyGiven = TRUE; + break; + case B3SOI_MOD_TCJSWG : + mod->B3SOItcjswg = value->rValue; + mod->B3SOItcjswgGiven = TRUE; + break; + case B3SOI_MOD_TPBSWG : + mod->B3SOItpbswg = value->rValue; + mod->B3SOItpbswgGiven = TRUE; + break; + case B3SOI_MOD_ACDE : + mod->B3SOIacde = value->rValue; + mod->B3SOIacdeGiven = TRUE; + break; + case B3SOI_MOD_MOIN : + mod->B3SOImoin = value->rValue; + mod->B3SOImoinGiven = TRUE; + break; + case B3SOI_MOD_DELVT : + mod->B3SOIdelvt = value->rValue; + mod->B3SOIdelvtGiven = TRUE; + break; + case B3SOI_MOD_KB1 : + mod->B3SOIkb1 = value->rValue; + mod->B3SOIkb1Given = TRUE; + break; + case B3SOI_MOD_DLBG : + mod->B3SOIdlbg = value->rValue; + mod->B3SOIdlbgGiven = TRUE; + break; + +/* Added for binning - START */ + /* Length Dependence */ +/* v3.0 */ + case B3SOI_MOD_LAIGC : + mod->B3SOIlaigc = value->rValue; + mod->B3SOIlaigcGiven = TRUE; + break; + case B3SOI_MOD_LBIGC : + mod->B3SOIlbigc = value->rValue; + mod->B3SOIlbigcGiven = TRUE; + break; + case B3SOI_MOD_LCIGC : + mod->B3SOIlcigc = value->rValue; + mod->B3SOIlcigcGiven = TRUE; + break; + case B3SOI_MOD_LAIGSD : + mod->B3SOIlaigsd = value->rValue; + mod->B3SOIlaigsdGiven = TRUE; + break; + case B3SOI_MOD_LBIGSD : + mod->B3SOIlbigsd = value->rValue; + mod->B3SOIlbigsdGiven = TRUE; + break; + case B3SOI_MOD_LCIGSD : + mod->B3SOIlcigsd = value->rValue; + mod->B3SOIlcigsdGiven = TRUE; + break; + case B3SOI_MOD_LNIGC : + mod->B3SOIlnigc = value->rValue; + mod->B3SOIlnigcGiven = TRUE; + break; + case B3SOI_MOD_LPIGCD : + mod->B3SOIlpigcd = value->rValue; + mod->B3SOIlpigcdGiven = TRUE; + break; + case B3SOI_MOD_LPOXEDGE : + mod->B3SOIlpoxedge = value->rValue; + mod->B3SOIlpoxedgeGiven = TRUE; + break; + + case B3SOI_MOD_LNPEAK: + mod->B3SOIlnpeak = value->rValue; + mod->B3SOIlnpeakGiven = TRUE; + break; + case B3SOI_MOD_LNSUB: + mod->B3SOIlnsub = value->rValue; + mod->B3SOIlnsubGiven = TRUE; + break; + case B3SOI_MOD_LNGATE: + mod->B3SOIlngate = value->rValue; + mod->B3SOIlngateGiven = TRUE; + break; + case B3SOI_MOD_LVTH0: + mod->B3SOIlvth0 = value->rValue; + mod->B3SOIlvth0Given = TRUE; + break; + case B3SOI_MOD_LK1: + mod->B3SOIlk1 = value->rValue; + mod->B3SOIlk1Given = TRUE; + break; + case B3SOI_MOD_LK1W1: + mod->B3SOIlk1w1 = value->rValue; + mod->B3SOIlk1w1Given = TRUE; + break; + case B3SOI_MOD_LK1W2: + mod->B3SOIlk1w2 = value->rValue; + mod->B3SOIlk1w2Given = TRUE; + break; + case B3SOI_MOD_LK2: + mod->B3SOIlk2 = value->rValue; + mod->B3SOIlk2Given = TRUE; + break; + case B3SOI_MOD_LK3: + mod->B3SOIlk3 = value->rValue; + mod->B3SOIlk3Given = TRUE; + break; + case B3SOI_MOD_LK3B: + mod->B3SOIlk3b = value->rValue; + mod->B3SOIlk3bGiven = TRUE; + break; + case B3SOI_MOD_LKB1 : + mod->B3SOIlkb1 = value->rValue; + mod->B3SOIlkb1Given = TRUE; + break; + case B3SOI_MOD_LW0: + mod->B3SOIlw0 = value->rValue; + mod->B3SOIlw0Given = TRUE; + break; + case B3SOI_MOD_LNLX: + mod->B3SOIlnlx = value->rValue; + mod->B3SOIlnlxGiven = TRUE; + break; + case B3SOI_MOD_LDVT0: + mod->B3SOIldvt0 = value->rValue; + mod->B3SOIldvt0Given = TRUE; + break; + case B3SOI_MOD_LDVT1: + mod->B3SOIldvt1 = value->rValue; + mod->B3SOIldvt1Given = TRUE; + break; + case B3SOI_MOD_LDVT2: + mod->B3SOIldvt2 = value->rValue; + mod->B3SOIldvt2Given = TRUE; + break; + case B3SOI_MOD_LDVT0W: + mod->B3SOIldvt0w = value->rValue; + mod->B3SOIldvt0wGiven = TRUE; + break; + case B3SOI_MOD_LDVT1W: + mod->B3SOIldvt1w = value->rValue; + mod->B3SOIldvt1wGiven = TRUE; + break; + case B3SOI_MOD_LDVT2W: + mod->B3SOIldvt2w = value->rValue; + mod->B3SOIldvt2wGiven = TRUE; + break; + case B3SOI_MOD_LU0 : + mod->B3SOIlu0 = value->rValue; + mod->B3SOIlu0Given = TRUE; + break; + case B3SOI_MOD_LUA: + mod->B3SOIlua = value->rValue; + mod->B3SOIluaGiven = TRUE; + break; + case B3SOI_MOD_LUB: + mod->B3SOIlub = value->rValue; + mod->B3SOIlubGiven = TRUE; + break; + case B3SOI_MOD_LUC: + mod->B3SOIluc = value->rValue; + mod->B3SOIlucGiven = TRUE; + break; + case B3SOI_MOD_LVSAT: + mod->B3SOIlvsat = value->rValue; + mod->B3SOIlvsatGiven = TRUE; + break; + case B3SOI_MOD_LA0: + mod->B3SOIla0 = value->rValue; + mod->B3SOIla0Given = TRUE; + break; + case B3SOI_MOD_LAGS: + mod->B3SOIlags= value->rValue; + mod->B3SOIlagsGiven = TRUE; + break; + case B3SOI_MOD_LB0 : + mod->B3SOIlb0 = value->rValue; + mod->B3SOIlb0Given = TRUE; + break; + case B3SOI_MOD_LB1 : + mod->B3SOIlb1 = value->rValue; + mod->B3SOIlb1Given = TRUE; + break; + case B3SOI_MOD_LKETA: + mod->B3SOIlketa = value->rValue; + mod->B3SOIlketaGiven = TRUE; + break; + case B3SOI_MOD_LKETAS: + mod->B3SOIlketas = value->rValue; + mod->B3SOIlketasGiven = TRUE; + break; + case B3SOI_MOD_LA1: + mod->B3SOIla1 = value->rValue; + mod->B3SOIla1Given = TRUE; + break; + case B3SOI_MOD_LA2: + mod->B3SOIla2 = value->rValue; + mod->B3SOIla2Given = TRUE; + break; + case B3SOI_MOD_LRDSW: + mod->B3SOIlrdsw = value->rValue; + mod->B3SOIlrdswGiven = TRUE; + break; + case B3SOI_MOD_LPRWB: + mod->B3SOIlprwb = value->rValue; + mod->B3SOIlprwbGiven = TRUE; + break; + case B3SOI_MOD_LPRWG: + mod->B3SOIlprwg = value->rValue; + mod->B3SOIlprwgGiven = TRUE; + break; + case B3SOI_MOD_LWR : + mod->B3SOIlwr = value->rValue; + mod->B3SOIlwrGiven = TRUE; + break; + case B3SOI_MOD_LNFACTOR : + mod->B3SOIlnfactor = value->rValue; + mod->B3SOIlnfactorGiven = TRUE; + break; + case B3SOI_MOD_LDWG : + mod->B3SOIldwg = value->rValue; + mod->B3SOIldwgGiven = TRUE; + break; + case B3SOI_MOD_LDWB : + mod->B3SOIldwb = value->rValue; + mod->B3SOIldwbGiven = TRUE; + break; + case B3SOI_MOD_LVOFF: + mod->B3SOIlvoff = value->rValue; + mod->B3SOIlvoffGiven = TRUE; + break; + case B3SOI_MOD_LETA0: + mod->B3SOIleta0 = value->rValue; + mod->B3SOIleta0Given = TRUE; + break; + case B3SOI_MOD_LETAB: + mod->B3SOIletab = value->rValue; + mod->B3SOIletabGiven = TRUE; + break; + case B3SOI_MOD_LDSUB: + mod->B3SOIldsub = value->rValue; + mod->B3SOIldsubGiven = TRUE; + break; + case B3SOI_MOD_LCIT : + mod->B3SOIlcit = value->rValue; + mod->B3SOIlcitGiven = TRUE; + break; + case B3SOI_MOD_LCDSC : + mod->B3SOIlcdsc = value->rValue; + mod->B3SOIlcdscGiven = TRUE; + break; + case B3SOI_MOD_LCDSCB : + mod->B3SOIlcdscb = value->rValue; + mod->B3SOIlcdscbGiven = TRUE; + break; + case B3SOI_MOD_LCDSCD : + mod->B3SOIlcdscd = value->rValue; + mod->B3SOIlcdscdGiven = TRUE; + break; + case B3SOI_MOD_LPCLM: + mod->B3SOIlpclm = value->rValue; + mod->B3SOIlpclmGiven = TRUE; + break; + case B3SOI_MOD_LPDIBL1: + mod->B3SOIlpdibl1 = value->rValue; + mod->B3SOIlpdibl1Given = TRUE; + break; + case B3SOI_MOD_LPDIBL2: + mod->B3SOIlpdibl2 = value->rValue; + mod->B3SOIlpdibl2Given = TRUE; + break; + case B3SOI_MOD_LPDIBLB: + mod->B3SOIlpdiblb = value->rValue; + mod->B3SOIlpdiblbGiven = TRUE; + break; + case B3SOI_MOD_LDROUT: + mod->B3SOIldrout = value->rValue; + mod->B3SOIldroutGiven = TRUE; + break; + case B3SOI_MOD_LPVAG: + mod->B3SOIlpvag = value->rValue; + mod->B3SOIlpvagGiven = TRUE; + break; + case B3SOI_MOD_LDELTA : + mod->B3SOIldelta = value->rValue; + mod->B3SOIldeltaGiven = TRUE; + break; + case B3SOI_MOD_LALPHA0 : + mod->B3SOIlalpha0 = value->rValue; + mod->B3SOIlalpha0Given = TRUE; + break; + case B3SOI_MOD_LFBJTII : + mod->B3SOIlfbjtii = value->rValue; + mod->B3SOIlfbjtiiGiven = TRUE; + break; + case B3SOI_MOD_LBETA0 : + mod->B3SOIlbeta0 = value->rValue; + mod->B3SOIlbeta0Given = TRUE; + break; + case B3SOI_MOD_LBETA1 : + mod->B3SOIlbeta1 = value->rValue; + mod->B3SOIlbeta1Given = TRUE; + break; + case B3SOI_MOD_LBETA2 : + mod->B3SOIlbeta2 = value->rValue; + mod->B3SOIlbeta2Given = TRUE; + break; + case B3SOI_MOD_LVDSATII0 : + mod->B3SOIlvdsatii0 = value->rValue; + mod->B3SOIlvdsatii0Given = TRUE; + break; + case B3SOI_MOD_LLII : + mod->B3SOIllii = value->rValue; + mod->B3SOIlliiGiven = TRUE; + break; + case B3SOI_MOD_LESATII : + mod->B3SOIlesatii = value->rValue; + mod->B3SOIlesatiiGiven = TRUE; + break; + case B3SOI_MOD_LSII0 : + mod->B3SOIlsii0 = value->rValue; + mod->B3SOIlsii0Given = TRUE; + break; + case B3SOI_MOD_LSII1 : + mod->B3SOIlsii1 = value->rValue; + mod->B3SOIlsii1Given = TRUE; + break; + case B3SOI_MOD_LSII2 : + mod->B3SOIlsii2 = value->rValue; + mod->B3SOIlsii2Given = TRUE; + break; + case B3SOI_MOD_LSIID : + mod->B3SOIlsiid = value->rValue; + mod->B3SOIlsiidGiven = TRUE; + break; + case B3SOI_MOD_LAGIDL : + mod->B3SOIlagidl = value->rValue; + mod->B3SOIlagidlGiven = TRUE; + break; + case B3SOI_MOD_LBGIDL : + mod->B3SOIlbgidl = value->rValue; + mod->B3SOIlbgidlGiven = TRUE; + break; + case B3SOI_MOD_LNGIDL : + mod->B3SOIlngidl = value->rValue; + mod->B3SOIlngidlGiven = TRUE; + break; + case B3SOI_MOD_LNTUN : + mod->B3SOIlntun = value->rValue; + mod->B3SOIlntunGiven = TRUE; + break; + case B3SOI_MOD_LNDIODE : + mod->B3SOIlndiode = value->rValue; + mod->B3SOIlndiodeGiven = TRUE; + break; + case B3SOI_MOD_LNRECF0 : + mod->B3SOIlnrecf0 = value->rValue; + mod->B3SOIlnrecf0Given = TRUE; + break; + case B3SOI_MOD_LNRECR0 : + mod->B3SOIlnrecr0 = value->rValue; + mod->B3SOIlnrecr0Given = TRUE; + break; + case B3SOI_MOD_LISBJT : + mod->B3SOIlisbjt = value->rValue; + mod->B3SOIlisbjtGiven = TRUE; + break; + case B3SOI_MOD_LISDIF : + mod->B3SOIlisdif = value->rValue; + mod->B3SOIlisdifGiven = TRUE; + break; + case B3SOI_MOD_LISREC : + mod->B3SOIlisrec = value->rValue; + mod->B3SOIlisrecGiven = TRUE; + break; + case B3SOI_MOD_LISTUN : + mod->B3SOIlistun = value->rValue; + mod->B3SOIlistunGiven = TRUE; + break; + case B3SOI_MOD_LVREC0 : + mod->B3SOIlvrec0 = value->rValue; + mod->B3SOIlvrec0Given = TRUE; + break; + case B3SOI_MOD_LVTUN0 : + mod->B3SOIlvtun0 = value->rValue; + mod->B3SOIlvtun0Given = TRUE; + break; + case B3SOI_MOD_LNBJT : + mod->B3SOIlnbjt = value->rValue; + mod->B3SOIlnbjtGiven = TRUE; + break; + case B3SOI_MOD_LLBJT0 : + mod->B3SOIllbjt0 = value->rValue; + mod->B3SOIllbjt0Given = TRUE; + break; + case B3SOI_MOD_LVABJT : + mod->B3SOIlvabjt = value->rValue; + mod->B3SOIlvabjtGiven = TRUE; + break; + case B3SOI_MOD_LAELY : + mod->B3SOIlaely = value->rValue; + mod->B3SOIlaelyGiven = TRUE; + break; + case B3SOI_MOD_LAHLI : + mod->B3SOIlahli = value->rValue; + mod->B3SOIlahliGiven = TRUE; + break; + /* CV Model */ + case B3SOI_MOD_LVSDFB : + mod->B3SOIlvsdfb = value->rValue; + mod->B3SOIlvsdfbGiven = TRUE; + break; + case B3SOI_MOD_LVSDTH : + mod->B3SOIlvsdth = value->rValue; + mod->B3SOIlvsdthGiven = TRUE; + break; + case B3SOI_MOD_LDELVT : + mod->B3SOIldelvt = value->rValue; + mod->B3SOIldelvtGiven = TRUE; + break; + case B3SOI_MOD_LACDE : + mod->B3SOIlacde = value->rValue; + mod->B3SOIlacdeGiven = TRUE; + break; + case B3SOI_MOD_LMOIN : + mod->B3SOIlmoin = value->rValue; + mod->B3SOIlmoinGiven = TRUE; + break; + + /* Width Dependence */ +/* v3.0 */ + case B3SOI_MOD_WAIGC : + mod->B3SOIwaigc = value->rValue; + mod->B3SOIwaigcGiven = TRUE; + break; + case B3SOI_MOD_WBIGC : + mod->B3SOIwbigc = value->rValue; + mod->B3SOIwbigcGiven = TRUE; + break; + case B3SOI_MOD_WCIGC : + mod->B3SOIwcigc = value->rValue; + mod->B3SOIwcigcGiven = TRUE; + break; + case B3SOI_MOD_WAIGSD : + mod->B3SOIwaigsd = value->rValue; + mod->B3SOIwaigsdGiven = TRUE; + break; + case B3SOI_MOD_WBIGSD : + mod->B3SOIwbigsd = value->rValue; + mod->B3SOIwbigsdGiven = TRUE; + break; + case B3SOI_MOD_WCIGSD : + mod->B3SOIwcigsd = value->rValue; + mod->B3SOIwcigsdGiven = TRUE; + break; + case B3SOI_MOD_WNIGC : + mod->B3SOIwnigc = value->rValue; + mod->B3SOIwnigcGiven = TRUE; + break; + case B3SOI_MOD_WPIGCD : + mod->B3SOIwpigcd = value->rValue; + mod->B3SOIwpigcdGiven = TRUE; + break; + case B3SOI_MOD_WPOXEDGE : + mod->B3SOIwpoxedge = value->rValue; + mod->B3SOIwpoxedgeGiven = TRUE; + break; + + case B3SOI_MOD_WNPEAK: + mod->B3SOIwnpeak = value->rValue; + mod->B3SOIwnpeakGiven = TRUE; + break; + case B3SOI_MOD_WNSUB: + mod->B3SOIwnsub = value->rValue; + mod->B3SOIwnsubGiven = TRUE; + break; + case B3SOI_MOD_WNGATE: + mod->B3SOIwngate = value->rValue; + mod->B3SOIwngateGiven = TRUE; + break; + case B3SOI_MOD_WVTH0: + mod->B3SOIwvth0 = value->rValue; + mod->B3SOIwvth0Given = TRUE; + break; + case B3SOI_MOD_WK1: + mod->B3SOIwk1 = value->rValue; + mod->B3SOIwk1Given = TRUE; + break; + case B3SOI_MOD_WK1W1: + mod->B3SOIwk1w1 = value->rValue; + mod->B3SOIwk1w1Given = TRUE; + break; + case B3SOI_MOD_WK1W2: + mod->B3SOIwk1w2 = value->rValue; + mod->B3SOIwk1w2Given = TRUE; + break; + case B3SOI_MOD_WK2: + mod->B3SOIwk2 = value->rValue; + mod->B3SOIwk2Given = TRUE; + break; + case B3SOI_MOD_WK3: + mod->B3SOIwk3 = value->rValue; + mod->B3SOIwk3Given = TRUE; + break; + case B3SOI_MOD_WK3B: + mod->B3SOIwk3b = value->rValue; + mod->B3SOIwk3bGiven = TRUE; + break; + case B3SOI_MOD_WKB1 : + mod->B3SOIwkb1 = value->rValue; + mod->B3SOIwkb1Given = TRUE; + break; + case B3SOI_MOD_WW0: + mod->B3SOIww0 = value->rValue; + mod->B3SOIww0Given = TRUE; + break; + case B3SOI_MOD_WNLX: + mod->B3SOIwnlx = value->rValue; + mod->B3SOIwnlxGiven = TRUE; + break; + case B3SOI_MOD_WDVT0: + mod->B3SOIwdvt0 = value->rValue; + mod->B3SOIwdvt0Given = TRUE; + break; + case B3SOI_MOD_WDVT1: + mod->B3SOIwdvt1 = value->rValue; + mod->B3SOIwdvt1Given = TRUE; + break; + case B3SOI_MOD_WDVT2: + mod->B3SOIwdvt2 = value->rValue; + mod->B3SOIwdvt2Given = TRUE; + break; + case B3SOI_MOD_WDVT0W: + mod->B3SOIwdvt0w = value->rValue; + mod->B3SOIwdvt0wGiven = TRUE; + break; + case B3SOI_MOD_WDVT1W: + mod->B3SOIwdvt1w = value->rValue; + mod->B3SOIwdvt1wGiven = TRUE; + break; + case B3SOI_MOD_WDVT2W: + mod->B3SOIwdvt2w = value->rValue; + mod->B3SOIwdvt2wGiven = TRUE; + break; + case B3SOI_MOD_WU0 : + mod->B3SOIwu0 = value->rValue; + mod->B3SOIwu0Given = TRUE; + break; + case B3SOI_MOD_WUA: + mod->B3SOIwua = value->rValue; + mod->B3SOIwuaGiven = TRUE; + break; + case B3SOI_MOD_WUB: + mod->B3SOIwub = value->rValue; + mod->B3SOIwubGiven = TRUE; + break; + case B3SOI_MOD_WUC: + mod->B3SOIwuc = value->rValue; + mod->B3SOIwucGiven = TRUE; + break; + case B3SOI_MOD_WVSAT: + mod->B3SOIwvsat = value->rValue; + mod->B3SOIwvsatGiven = TRUE; + break; + case B3SOI_MOD_WA0: + mod->B3SOIwa0 = value->rValue; + mod->B3SOIwa0Given = TRUE; + break; + case B3SOI_MOD_WAGS: + mod->B3SOIwags= value->rValue; + mod->B3SOIwagsGiven = TRUE; + break; + case B3SOI_MOD_WB0 : + mod->B3SOIwb0 = value->rValue; + mod->B3SOIwb0Given = TRUE; + break; + case B3SOI_MOD_WB1 : + mod->B3SOIwb1 = value->rValue; + mod->B3SOIwb1Given = TRUE; + break; + case B3SOI_MOD_WKETA: + mod->B3SOIwketa = value->rValue; + mod->B3SOIwketaGiven = TRUE; + break; + case B3SOI_MOD_WKETAS: + mod->B3SOIwketas = value->rValue; + mod->B3SOIwketasGiven = TRUE; + break; + case B3SOI_MOD_WA1: + mod->B3SOIwa1 = value->rValue; + mod->B3SOIwa1Given = TRUE; + break; + case B3SOI_MOD_WA2: + mod->B3SOIwa2 = value->rValue; + mod->B3SOIwa2Given = TRUE; + break; + case B3SOI_MOD_WRDSW: + mod->B3SOIwrdsw = value->rValue; + mod->B3SOIwrdswGiven = TRUE; + break; + case B3SOI_MOD_WPRWB: + mod->B3SOIwprwb = value->rValue; + mod->B3SOIwprwbGiven = TRUE; + break; + case B3SOI_MOD_WPRWG: + mod->B3SOIwprwg = value->rValue; + mod->B3SOIwprwgGiven = TRUE; + break; + case B3SOI_MOD_WWR : + mod->B3SOIwwr = value->rValue; + mod->B3SOIwwrGiven = TRUE; + break; + case B3SOI_MOD_WNFACTOR : + mod->B3SOIwnfactor = value->rValue; + mod->B3SOIwnfactorGiven = TRUE; + break; + case B3SOI_MOD_WDWG : + mod->B3SOIwdwg = value->rValue; + mod->B3SOIwdwgGiven = TRUE; + break; + case B3SOI_MOD_WDWB : + mod->B3SOIwdwb = value->rValue; + mod->B3SOIwdwbGiven = TRUE; + break; + case B3SOI_MOD_WVOFF: + mod->B3SOIwvoff = value->rValue; + mod->B3SOIwvoffGiven = TRUE; + break; + case B3SOI_MOD_WETA0: + mod->B3SOIweta0 = value->rValue; + mod->B3SOIweta0Given = TRUE; + break; + case B3SOI_MOD_WETAB: + mod->B3SOIwetab = value->rValue; + mod->B3SOIwetabGiven = TRUE; + break; + case B3SOI_MOD_WDSUB: + mod->B3SOIwdsub = value->rValue; + mod->B3SOIwdsubGiven = TRUE; + break; + case B3SOI_MOD_WCIT : + mod->B3SOIwcit = value->rValue; + mod->B3SOIwcitGiven = TRUE; + break; + case B3SOI_MOD_WCDSC : + mod->B3SOIwcdsc = value->rValue; + mod->B3SOIwcdscGiven = TRUE; + break; + case B3SOI_MOD_WCDSCB : + mod->B3SOIwcdscb = value->rValue; + mod->B3SOIwcdscbGiven = TRUE; + break; + case B3SOI_MOD_WCDSCD : + mod->B3SOIwcdscd = value->rValue; + mod->B3SOIwcdscdGiven = TRUE; + break; + case B3SOI_MOD_WPCLM: + mod->B3SOIwpclm = value->rValue; + mod->B3SOIwpclmGiven = TRUE; + break; + case B3SOI_MOD_WPDIBL1: + mod->B3SOIwpdibl1 = value->rValue; + mod->B3SOIwpdibl1Given = TRUE; + break; + case B3SOI_MOD_WPDIBL2: + mod->B3SOIwpdibl2 = value->rValue; + mod->B3SOIwpdibl2Given = TRUE; + break; + case B3SOI_MOD_WPDIBLB: + mod->B3SOIwpdiblb = value->rValue; + mod->B3SOIwpdiblbGiven = TRUE; + break; + case B3SOI_MOD_WDROUT: + mod->B3SOIwdrout = value->rValue; + mod->B3SOIwdroutGiven = TRUE; + break; + case B3SOI_MOD_WPVAG: + mod->B3SOIwpvag = value->rValue; + mod->B3SOIwpvagGiven = TRUE; + break; + case B3SOI_MOD_WDELTA : + mod->B3SOIwdelta = value->rValue; + mod->B3SOIwdeltaGiven = TRUE; + break; + case B3SOI_MOD_WALPHA0 : + mod->B3SOIwalpha0 = value->rValue; + mod->B3SOIwalpha0Given = TRUE; + break; + case B3SOI_MOD_WFBJTII : + mod->B3SOIwfbjtii = value->rValue; + mod->B3SOIwfbjtiiGiven = TRUE; + break; + case B3SOI_MOD_WBETA0 : + mod->B3SOIwbeta0 = value->rValue; + mod->B3SOIwbeta0Given = TRUE; + break; + case B3SOI_MOD_WBETA1 : + mod->B3SOIwbeta1 = value->rValue; + mod->B3SOIwbeta1Given = TRUE; + break; + case B3SOI_MOD_WBETA2 : + mod->B3SOIwbeta2 = value->rValue; + mod->B3SOIwbeta2Given = TRUE; + break; + case B3SOI_MOD_WVDSATII0 : + mod->B3SOIwvdsatii0 = value->rValue; + mod->B3SOIwvdsatii0Given = TRUE; + break; + case B3SOI_MOD_WLII : + mod->B3SOIwlii = value->rValue; + mod->B3SOIwliiGiven = TRUE; + break; + case B3SOI_MOD_WESATII : + mod->B3SOIwesatii = value->rValue; + mod->B3SOIwesatiiGiven = TRUE; + break; + case B3SOI_MOD_WSII0 : + mod->B3SOIwsii0 = value->rValue; + mod->B3SOIwsii0Given = TRUE; + break; + case B3SOI_MOD_WSII1 : + mod->B3SOIwsii1 = value->rValue; + mod->B3SOIwsii1Given = TRUE; + break; + case B3SOI_MOD_WSII2 : + mod->B3SOIwsii2 = value->rValue; + mod->B3SOIwsii2Given = TRUE; + break; + case B3SOI_MOD_WSIID : + mod->B3SOIwsiid = value->rValue; + mod->B3SOIwsiidGiven = TRUE; + break; + case B3SOI_MOD_WAGIDL : + mod->B3SOIwagidl = value->rValue; + mod->B3SOIwagidlGiven = TRUE; + break; + case B3SOI_MOD_WBGIDL : + mod->B3SOIwbgidl = value->rValue; + mod->B3SOIwbgidlGiven = TRUE; + break; + case B3SOI_MOD_WNGIDL : + mod->B3SOIwngidl = value->rValue; + mod->B3SOIwngidlGiven = TRUE; + break; + case B3SOI_MOD_WNTUN : + mod->B3SOIwntun = value->rValue; + mod->B3SOIwntunGiven = TRUE; + break; + case B3SOI_MOD_WNDIODE : + mod->B3SOIwndiode = value->rValue; + mod->B3SOIwndiodeGiven = TRUE; + break; + case B3SOI_MOD_WNRECF0 : + mod->B3SOIwnrecf0 = value->rValue; + mod->B3SOIwnrecf0Given = TRUE; + break; + case B3SOI_MOD_WNRECR0 : + mod->B3SOIwnrecr0 = value->rValue; + mod->B3SOIwnrecr0Given = TRUE; + break; + case B3SOI_MOD_WISBJT : + mod->B3SOIwisbjt = value->rValue; + mod->B3SOIwisbjtGiven = TRUE; + break; + case B3SOI_MOD_WISDIF : + mod->B3SOIwisdif = value->rValue; + mod->B3SOIwisdifGiven = TRUE; + break; + case B3SOI_MOD_WISREC : + mod->B3SOIwisrec = value->rValue; + mod->B3SOIwisrecGiven = TRUE; + break; + case B3SOI_MOD_WISTUN : + mod->B3SOIwistun = value->rValue; + mod->B3SOIwistunGiven = TRUE; + break; + case B3SOI_MOD_WVREC0 : + mod->B3SOIwvrec0 = value->rValue; + mod->B3SOIwvrec0Given = TRUE; + break; + case B3SOI_MOD_WVTUN0 : + mod->B3SOIwvtun0 = value->rValue; + mod->B3SOIwvtun0Given = TRUE; + break; + case B3SOI_MOD_WNBJT : + mod->B3SOIwnbjt = value->rValue; + mod->B3SOIwnbjtGiven = TRUE; + break; + case B3SOI_MOD_WLBJT0 : + mod->B3SOIwlbjt0 = value->rValue; + mod->B3SOIwlbjt0Given = TRUE; + break; + case B3SOI_MOD_WVABJT : + mod->B3SOIwvabjt = value->rValue; + mod->B3SOIwvabjtGiven = TRUE; + break; + case B3SOI_MOD_WAELY : + mod->B3SOIwaely = value->rValue; + mod->B3SOIwaelyGiven = TRUE; + break; + case B3SOI_MOD_WAHLI : + mod->B3SOIwahli = value->rValue; + mod->B3SOIwahliGiven = TRUE; + break; + /* CV Model */ + case B3SOI_MOD_WVSDFB : + mod->B3SOIwvsdfb = value->rValue; + mod->B3SOIwvsdfbGiven = TRUE; + break; + case B3SOI_MOD_WVSDTH : + mod->B3SOIwvsdth = value->rValue; + mod->B3SOIwvsdthGiven = TRUE; + break; + case B3SOI_MOD_WDELVT : + mod->B3SOIwdelvt = value->rValue; + mod->B3SOIwdelvtGiven = TRUE; + break; + case B3SOI_MOD_WACDE : + mod->B3SOIwacde = value->rValue; + mod->B3SOIwacdeGiven = TRUE; + break; + case B3SOI_MOD_WMOIN : + mod->B3SOIwmoin = value->rValue; + mod->B3SOIwmoinGiven = TRUE; + break; + + /* Cross-term Dependence */ +/* v3.0 */ + case B3SOI_MOD_PAIGC : + mod->B3SOIpaigc = value->rValue; + mod->B3SOIpaigcGiven = TRUE; + break; + case B3SOI_MOD_PBIGC : + mod->B3SOIpbigc = value->rValue; + mod->B3SOIpbigcGiven = TRUE; + break; + case B3SOI_MOD_PCIGC : + mod->B3SOIpcigc = value->rValue; + mod->B3SOIpcigcGiven = TRUE; + break; + case B3SOI_MOD_PAIGSD : + mod->B3SOIpaigsd = value->rValue; + mod->B3SOIpaigsdGiven = TRUE; + break; + case B3SOI_MOD_PBIGSD : + mod->B3SOIpbigsd = value->rValue; + mod->B3SOIpbigsdGiven = TRUE; + break; + case B3SOI_MOD_PCIGSD : + mod->B3SOIpcigsd = value->rValue; + mod->B3SOIpcigsdGiven = TRUE; + break; + case B3SOI_MOD_PNIGC : + mod->B3SOIpnigc = value->rValue; + mod->B3SOIpnigcGiven = TRUE; + break; + case B3SOI_MOD_PPIGCD : + mod->B3SOIppigcd = value->rValue; + mod->B3SOIppigcdGiven = TRUE; + break; + case B3SOI_MOD_PPOXEDGE : + mod->B3SOIppoxedge = value->rValue; + mod->B3SOIppoxedgeGiven = TRUE; + break; + + case B3SOI_MOD_PNPEAK: + mod->B3SOIpnpeak = value->rValue; + mod->B3SOIpnpeakGiven = TRUE; + break; + case B3SOI_MOD_PNSUB: + mod->B3SOIpnsub = value->rValue; + mod->B3SOIpnsubGiven = TRUE; + break; + case B3SOI_MOD_PNGATE: + mod->B3SOIpngate = value->rValue; + mod->B3SOIpngateGiven = TRUE; + break; + case B3SOI_MOD_PVTH0: + mod->B3SOIpvth0 = value->rValue; + mod->B3SOIpvth0Given = TRUE; + break; + case B3SOI_MOD_PK1: + mod->B3SOIpk1 = value->rValue; + mod->B3SOIpk1Given = TRUE; + break; + case B3SOI_MOD_PK1W1: + mod->B3SOIpk1w1 = value->rValue; + mod->B3SOIpk1w1Given = TRUE; + break; + case B3SOI_MOD_PK1W2: + mod->B3SOIpk1w2 = value->rValue; + mod->B3SOIpk1w2Given = TRUE; + break; + case B3SOI_MOD_PK2: + mod->B3SOIpk2 = value->rValue; + mod->B3SOIpk2Given = TRUE; + break; + case B3SOI_MOD_PK3: + mod->B3SOIpk3 = value->rValue; + mod->B3SOIpk3Given = TRUE; + break; + case B3SOI_MOD_PK3B: + mod->B3SOIpk3b = value->rValue; + mod->B3SOIpk3bGiven = TRUE; + break; + case B3SOI_MOD_PKB1 : + mod->B3SOIpkb1 = value->rValue; + mod->B3SOIpkb1Given = TRUE; + break; + case B3SOI_MOD_PW0: + mod->B3SOIpw0 = value->rValue; + mod->B3SOIpw0Given = TRUE; + break; + case B3SOI_MOD_PNLX: + mod->B3SOIpnlx = value->rValue; + mod->B3SOIpnlxGiven = TRUE; + break; + case B3SOI_MOD_PDVT0: + mod->B3SOIpdvt0 = value->rValue; + mod->B3SOIpdvt0Given = TRUE; + break; + case B3SOI_MOD_PDVT1: + mod->B3SOIpdvt1 = value->rValue; + mod->B3SOIpdvt1Given = TRUE; + break; + case B3SOI_MOD_PDVT2: + mod->B3SOIpdvt2 = value->rValue; + mod->B3SOIpdvt2Given = TRUE; + break; + case B3SOI_MOD_PDVT0W: + mod->B3SOIpdvt0w = value->rValue; + mod->B3SOIpdvt0wGiven = TRUE; + break; + case B3SOI_MOD_PDVT1W: + mod->B3SOIpdvt1w = value->rValue; + mod->B3SOIpdvt1wGiven = TRUE; + break; + case B3SOI_MOD_PDVT2W: + mod->B3SOIpdvt2w = value->rValue; + mod->B3SOIpdvt2wGiven = TRUE; + break; + case B3SOI_MOD_PU0 : + mod->B3SOIpu0 = value->rValue; + mod->B3SOIpu0Given = TRUE; + break; + case B3SOI_MOD_PUA: + mod->B3SOIpua = value->rValue; + mod->B3SOIpuaGiven = TRUE; + break; + case B3SOI_MOD_PUB: + mod->B3SOIpub = value->rValue; + mod->B3SOIpubGiven = TRUE; + break; + case B3SOI_MOD_PUC: + mod->B3SOIpuc = value->rValue; + mod->B3SOIpucGiven = TRUE; + break; + case B3SOI_MOD_PVSAT: + mod->B3SOIpvsat = value->rValue; + mod->B3SOIpvsatGiven = TRUE; + break; + case B3SOI_MOD_PA0: + mod->B3SOIpa0 = value->rValue; + mod->B3SOIpa0Given = TRUE; + break; + case B3SOI_MOD_PAGS: + mod->B3SOIpags= value->rValue; + mod->B3SOIpagsGiven = TRUE; + break; + case B3SOI_MOD_PB0 : + mod->B3SOIpb0 = value->rValue; + mod->B3SOIpb0Given = TRUE; + break; + case B3SOI_MOD_PB1 : + mod->B3SOIpb1 = value->rValue; + mod->B3SOIpb1Given = TRUE; + break; + case B3SOI_MOD_PKETA: + mod->B3SOIpketa = value->rValue; + mod->B3SOIpketaGiven = TRUE; + break; + case B3SOI_MOD_PKETAS: + mod->B3SOIpketas = value->rValue; + mod->B3SOIpketasGiven = TRUE; + break; + case B3SOI_MOD_PA1: + mod->B3SOIpa1 = value->rValue; + mod->B3SOIpa1Given = TRUE; + break; + case B3SOI_MOD_PA2: + mod->B3SOIpa2 = value->rValue; + mod->B3SOIpa2Given = TRUE; + break; + case B3SOI_MOD_PRDSW: + mod->B3SOIprdsw = value->rValue; + mod->B3SOIprdswGiven = TRUE; + break; + case B3SOI_MOD_PPRWB: + mod->B3SOIpprwb = value->rValue; + mod->B3SOIpprwbGiven = TRUE; + break; + case B3SOI_MOD_PPRWG: + mod->B3SOIpprwg = value->rValue; + mod->B3SOIpprwgGiven = TRUE; + break; + case B3SOI_MOD_PWR : + mod->B3SOIpwr = value->rValue; + mod->B3SOIpwrGiven = TRUE; + break; + case B3SOI_MOD_PNFACTOR : + mod->B3SOIpnfactor = value->rValue; + mod->B3SOIpnfactorGiven = TRUE; + break; + case B3SOI_MOD_PDWG : + mod->B3SOIpdwg = value->rValue; + mod->B3SOIpdwgGiven = TRUE; + break; + case B3SOI_MOD_PDWB : + mod->B3SOIpdwb = value->rValue; + mod->B3SOIpdwbGiven = TRUE; + break; + case B3SOI_MOD_PVOFF: + mod->B3SOIpvoff = value->rValue; + mod->B3SOIpvoffGiven = TRUE; + break; + case B3SOI_MOD_PETA0: + mod->B3SOIpeta0 = value->rValue; + mod->B3SOIpeta0Given = TRUE; + break; + case B3SOI_MOD_PETAB: + mod->B3SOIpetab = value->rValue; + mod->B3SOIpetabGiven = TRUE; + break; + case B3SOI_MOD_PDSUB: + mod->B3SOIpdsub = value->rValue; + mod->B3SOIpdsubGiven = TRUE; + break; + case B3SOI_MOD_PCIT : + mod->B3SOIpcit = value->rValue; + mod->B3SOIpcitGiven = TRUE; + break; + case B3SOI_MOD_PCDSC : + mod->B3SOIpcdsc = value->rValue; + mod->B3SOIpcdscGiven = TRUE; + break; + case B3SOI_MOD_PCDSCB : + mod->B3SOIpcdscb = value->rValue; + mod->B3SOIpcdscbGiven = TRUE; + break; + case B3SOI_MOD_PCDSCD : + mod->B3SOIpcdscd = value->rValue; + mod->B3SOIpcdscdGiven = TRUE; + break; + case B3SOI_MOD_PPCLM: + mod->B3SOIppclm = value->rValue; + mod->B3SOIppclmGiven = TRUE; + break; + case B3SOI_MOD_PPDIBL1: + mod->B3SOIppdibl1 = value->rValue; + mod->B3SOIppdibl1Given = TRUE; + break; + case B3SOI_MOD_PPDIBL2: + mod->B3SOIppdibl2 = value->rValue; + mod->B3SOIppdibl2Given = TRUE; + break; + case B3SOI_MOD_PPDIBLB: + mod->B3SOIppdiblb = value->rValue; + mod->B3SOIppdiblbGiven = TRUE; + break; + case B3SOI_MOD_PDROUT: + mod->B3SOIpdrout = value->rValue; + mod->B3SOIpdroutGiven = TRUE; + break; + case B3SOI_MOD_PPVAG: + mod->B3SOIppvag = value->rValue; + mod->B3SOIppvagGiven = TRUE; + break; + case B3SOI_MOD_PDELTA : + mod->B3SOIpdelta = value->rValue; + mod->B3SOIpdeltaGiven = TRUE; + break; + case B3SOI_MOD_PALPHA0 : + mod->B3SOIpalpha0 = value->rValue; + mod->B3SOIpalpha0Given = TRUE; + break; + case B3SOI_MOD_PFBJTII : + mod->B3SOIpfbjtii = value->rValue; + mod->B3SOIpfbjtiiGiven = TRUE; + break; + case B3SOI_MOD_PBETA0 : + mod->B3SOIpbeta0 = value->rValue; + mod->B3SOIpbeta0Given = TRUE; + break; + case B3SOI_MOD_PBETA1 : + mod->B3SOIpbeta1 = value->rValue; + mod->B3SOIpbeta1Given = TRUE; + break; + case B3SOI_MOD_PBETA2 : + mod->B3SOIpbeta2 = value->rValue; + mod->B3SOIpbeta2Given = TRUE; + break; + case B3SOI_MOD_PVDSATII0 : + mod->B3SOIpvdsatii0 = value->rValue; + mod->B3SOIpvdsatii0Given = TRUE; + break; + case B3SOI_MOD_PLII : + mod->B3SOIplii = value->rValue; + mod->B3SOIpliiGiven = TRUE; + break; + case B3SOI_MOD_PESATII : + mod->B3SOIpesatii = value->rValue; + mod->B3SOIpesatiiGiven = TRUE; + break; + case B3SOI_MOD_PSII0 : + mod->B3SOIpsii0 = value->rValue; + mod->B3SOIpsii0Given = TRUE; + break; + case B3SOI_MOD_PSII1 : + mod->B3SOIpsii1 = value->rValue; + mod->B3SOIpsii1Given = TRUE; + break; + case B3SOI_MOD_PSII2 : + mod->B3SOIpsii2 = value->rValue; + mod->B3SOIpsii2Given = TRUE; + break; + case B3SOI_MOD_PSIID : + mod->B3SOIpsiid = value->rValue; + mod->B3SOIpsiidGiven = TRUE; + break; + case B3SOI_MOD_PAGIDL : + mod->B3SOIpagidl = value->rValue; + mod->B3SOIpagidlGiven = TRUE; + break; + case B3SOI_MOD_PBGIDL : + mod->B3SOIpbgidl = value->rValue; + mod->B3SOIpbgidlGiven = TRUE; + break; + case B3SOI_MOD_PNGIDL : + mod->B3SOIpngidl = value->rValue; + mod->B3SOIpngidlGiven = TRUE; + break; + case B3SOI_MOD_PNTUN : + mod->B3SOIpntun = value->rValue; + mod->B3SOIpntunGiven = TRUE; + break; + case B3SOI_MOD_PNDIODE : + mod->B3SOIpndiode = value->rValue; + mod->B3SOIpndiodeGiven = TRUE; + break; + case B3SOI_MOD_PNRECF0 : + mod->B3SOIpnrecf0 = value->rValue; + mod->B3SOIpnrecf0Given = TRUE; + break; + case B3SOI_MOD_PNRECR0 : + mod->B3SOIpnrecr0 = value->rValue; + mod->B3SOIpnrecr0Given = TRUE; + break; + case B3SOI_MOD_PISBJT : + mod->B3SOIpisbjt = value->rValue; + mod->B3SOIpisbjtGiven = TRUE; + break; + case B3SOI_MOD_PISDIF : + mod->B3SOIpisdif = value->rValue; + mod->B3SOIpisdifGiven = TRUE; + break; + case B3SOI_MOD_PISREC : + mod->B3SOIpisrec = value->rValue; + mod->B3SOIpisrecGiven = TRUE; + break; + case B3SOI_MOD_PISTUN : + mod->B3SOIpistun = value->rValue; + mod->B3SOIpistunGiven = TRUE; + break; + case B3SOI_MOD_PVREC0 : + mod->B3SOIpvrec0 = value->rValue; + mod->B3SOIpvrec0Given = TRUE; + break; + case B3SOI_MOD_PVTUN0 : + mod->B3SOIpvtun0 = value->rValue; + mod->B3SOIpvtun0Given = TRUE; + break; + case B3SOI_MOD_PNBJT : + mod->B3SOIpnbjt = value->rValue; + mod->B3SOIpnbjtGiven = TRUE; + break; + case B3SOI_MOD_PLBJT0 : + mod->B3SOIplbjt0 = value->rValue; + mod->B3SOIplbjt0Given = TRUE; + break; + case B3SOI_MOD_PVABJT : + mod->B3SOIpvabjt = value->rValue; + mod->B3SOIpvabjtGiven = TRUE; + break; + case B3SOI_MOD_PAELY : + mod->B3SOIpaely = value->rValue; + mod->B3SOIpaelyGiven = TRUE; + break; + case B3SOI_MOD_PAHLI : + mod->B3SOIpahli = value->rValue; + mod->B3SOIpahliGiven = TRUE; + break; + /* CV Model */ + case B3SOI_MOD_PVSDFB : + mod->B3SOIpvsdfb = value->rValue; + mod->B3SOIpvsdfbGiven = TRUE; + break; + case B3SOI_MOD_PVSDTH : + mod->B3SOIpvsdth = value->rValue; + mod->B3SOIpvsdthGiven = TRUE; + break; + case B3SOI_MOD_PDELVT : + mod->B3SOIpdelvt = value->rValue; + mod->B3SOIpdelvtGiven = TRUE; + break; + case B3SOI_MOD_PACDE : + mod->B3SOIpacde = value->rValue; + mod->B3SOIpacdeGiven = TRUE; + break; + case B3SOI_MOD_PMOIN : + mod->B3SOIpmoin = value->rValue; + mod->B3SOIpmoinGiven = TRUE; + break; +/* Added for binning - END */ + + case B3SOI_MOD_NMOS : + if(value->iValue) { + mod->B3SOItype = 1; + mod->B3SOItypeGiven = TRUE; + } + break; + case B3SOI_MOD_PMOS : + if(value->iValue) { + mod->B3SOItype = - 1; + mod->B3SOItypeGiven = TRUE; + } + break; + default: + return(E_BADPARM); + } + return(OK); +} + + diff --git a/src/spicelib/devices/bsim3soi/b3soinoi.c b/src/spicelib/devices/bsim3soi/b3soinoi.c new file mode 100644 index 000000000..1883e8b4a --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soinoi.c @@ -0,0 +1,402 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soinoi.c 98/5/01 +Modified by Hui Wan 02/3/5 +Modified by Paolo Nenzi 2002 +**********/ + +#include "ngspice.h" +#include "b3soidef.h" +#include "cktdefs.h" +#include "iferrmsg.h" +#include "noisedef.h" +#include "suffix.h" +#include "const.h" /* jwan */ + +/* + * B3SOInoise (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->B3SOInoiMod. + If model->B3SOInoiMod = 1, + Channel thermal noise = SPICE2 model + Flicker noise = SPICE2 model + If model->B3SOInoiMod = 2, + Channel thermal noise = B3SOI model + Flicker noise = B3SOI model + If model->B3SOInoiMod = 3, + Channel thermal noise = SPICE2 model + Flicker noise = B3SOI model + If model->B3SOInoiMod = 4, + Channel thermal noise = B3SOI model + Flicker noise = SPICE2 model + */ + +extern void NevalSrc(); +extern double Nintegrate(); + +double +B3SOIStrongInversionNoiseEval(double vgs, double vds, B3SOImodel *model, + B3SOIinstance *here, double freq, double temp) +{ +struct b3soiSizeDependParam *pParam; +double cd, esat, DelClm, EffFreq, N0, Nl, Vgst; +double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Ssi; +double req, ceq; + + pParam = here->pParam; + cd = fabs(here->B3SOIcd) * here->B3SOIm; + +/* v2.2.3 bug fix */ + if(model->B3SOIem<=0.0) DelClm = 0.0; + else { + esat = 2.0 * pParam->B3SOIvsattemp / here->B3SOIueff; + T0 = ((((vds - here->B3SOIVdseff) / pParam->B3SOIlitl) + + model->B3SOIem) / esat); + DelClm = pParam->B3SOIlitl * log (MAX(T0, N_MINLOG)); + } + + + EffFreq = pow(freq, model->B3SOIef); + T1 = CHARGE * CHARGE * 8.62e-5 * cd * temp * here->B3SOIueff; + T2 = 1.0e8 * EffFreq * model->B3SOIcox + * pParam->B3SOIleff * pParam->B3SOIleff; + +/* v2.2.3 bug fix */ + N0 = model->B3SOIcox * here->B3SOIVgsteff / CHARGE; + Nl = model->B3SOIcox * here->B3SOIVgsteff + * (1.0 - here->B3SOIAbovVgst2Vtm * here->B3SOIVdseff) / CHARGE; + + + T3 = model->B3SOIoxideTrapDensityA + * log(MAX(((N0 + 2.0e14) / (Nl + 2.0e14)), N_MINLOG)); + T4 = model->B3SOIoxideTrapDensityB * (N0 - Nl); + T5 = model->B3SOIoxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl); + + T6 = 8.62e-5 * temp * cd * cd; + T7 = 1.0e8 * EffFreq * pParam->B3SOIleff + * pParam->B3SOIleff * pParam->B3SOIweff * here->B3SOIm; + T8 = model->B3SOIoxideTrapDensityA + model->B3SOIoxideTrapDensityB * Nl + + model->B3SOIoxideTrapDensityC * Nl * Nl; + T9 = (Nl + 2.0e14) * (Nl + 2.0e14); + + Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9; + + return Ssi; +} + +int +B3SOInoise (int mode, int operation, GENmodel *inModel, CKTcircuit *ckt, + Ndata *data, double *OnDens) +{ +B3SOImodel *model = (B3SOImodel *)inModel; +B3SOIinstance *here; +struct b3soiSizeDependParam *pParam; +char name[N_MXVLNTH]; +double tempOnoise; +double tempInoise; +double noizDens[B3SOINSRCS]; +double lnNdens[B3SOINSRCS]; + +double vgs, vds, Slimit; +double N0, Nl; +double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13; +double n, ExpArg, Ssi, Swi; + +int error, i; + + /* define the names of the noise sources */ + static char *B3SOInNames[B3SOINSRCS] = + { /* Note that we have to keep the order */ + ".rd", /* noise due to rd */ + /* consistent with the index definitions */ + ".rs", /* noise due to rs */ + /* in B3SOIdefs.h */ + ".id", /* noise due to id */ + ".1overf", /* flicker (1/f) noise */ + ".fb", /* noise due to floating body */ + "" /* total transistor noise */ + }; + + for (; model != NULL; model = model->B3SOInextModel) + { for (here = model->B3SOIinstances; here != NULL; + here = here->B3SOInextInstance) + { + + if (here->B3SOIowner != 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 < B3SOINSRCS; i++) + { (void) sprintf(name, "onoise.%s%s", + here->B3SOIname, + B3SOInNames[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 < B3SOINSRCS; i++) + { (void) sprintf(name, "onoise_total.%s%s", + here->B3SOIname, + B3SOInNames[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->B3SOIname, + B3SOInNames[i]); + data->namelist = (IFuid *) trealloc( + (char *) data->namelist, + (data->numPlots + 1) + * sizeof(IFuid)); + if (!data->namelist) + return(E_NOMEM); + (*(SPfrontEnd->IFnewUid)) (ckt, + &(data->namelist[data->numPlots++]), + (IFuid) NULL, name, UID_OTHER, + (void **)NULL); + /* we've added one more plot */ + } + break; + } + } + break; + case N_CALC: + switch (mode) + { case N_DENS: + NevalSrc(&noizDens[B3SOIRDNOIZ], + &lnNdens[B3SOIRDNOIZ], ckt, THERMNOISE, + here->B3SOIdNodePrime, here->B3SOIdNode, + here->B3SOIdrainConductance * here->B3SOIm); + + NevalSrc(&noizDens[B3SOIRSNOIZ], + &lnNdens[B3SOIRSNOIZ], ckt, THERMNOISE, + here->B3SOIsNodePrime, here->B3SOIsNode, + here->B3SOIsourceConductance * here->B3SOIm); + + switch( model->B3SOInoiMod ) + { case 1: + case 3: + NevalSrc(&noizDens[B3SOIIDNOIZ], + &lnNdens[B3SOIIDNOIZ], ckt, + THERMNOISE, here->B3SOIdNodePrime, + here->B3SOIsNodePrime, + (2.0 / 3.0 * fabs( here->B3SOIm * + (here->B3SOIgm + + here->B3SOIgds + + here->B3SOIgmbs)))); + break; + case 2: + +/* v2.2.3 bug fix */ + case 4: + NevalSrc(&noizDens[B3SOIIDNOIZ], + &lnNdens[B3SOIIDNOIZ], ckt, + THERMNOISE, here->B3SOIdNodePrime, + here->B3SOIsNodePrime, + (here->B3SOIueff + * fabs((here->B3SOIqinv * here->B3SOIm) + / (pParam->B3SOIleff + * pParam->B3SOIleff+ + here->B3SOIueff*fabs + (here->B3SOIqinv * here->B3SOIm) * + (here->B3SOIrds / here->B3SOIm))))); + break; + } + NevalSrc(&noizDens[B3SOIFLNOIZ], (double*) NULL, + ckt, N_GAIN, here->B3SOIdNodePrime, + here->B3SOIsNodePrime, (double) 0.0); + + switch( model->B3SOInoiMod ) + { case 1: + case 4: + noizDens[B3SOIFLNOIZ] *= model->B3SOIkf + * exp(model->B3SOIaf + * log(MAX(fabs(here->B3SOIm * here->B3SOIcd), + N_MINLOG))) + / (pow(data->freq, model->B3SOIef) + * pParam->B3SOIleff + * pParam->B3SOIleff + * model->B3SOIcox); + break; + case 2: + case 3: + vgs = *(ckt->CKTstates[0] + here->B3SOIvgs); + vds = *(ckt->CKTstates[0] + here->B3SOIvds); + if (vds < 0.0) + { vds = -vds; + vgs = vgs + vds; + } + if (vgs >= here->B3SOIvon + 0.1) + { Ssi = B3SOIStrongInversionNoiseEval(vgs, + vds, model, here, data->freq, + ckt->CKTtemp); + noizDens[B3SOIFLNOIZ] *= Ssi; + } + else + { pParam = here->pParam; + T10 = model->B3SOIoxideTrapDensityA + * 8.62e-5 * ckt->CKTtemp; + T11 = pParam->B3SOIweff * here->B3SOIm + * pParam->B3SOIleff + * pow(data->freq, model->B3SOIef) + * 4.0e36; + Swi = T10 / T11 * here->B3SOIcd * here->B3SOIm + * here->B3SOIcd * here->B3SOIm; + Slimit = B3SOIStrongInversionNoiseEval( + here->B3SOIvon + 0.1, vds, model, + here, data->freq, ckt->CKTtemp); + T1 = Swi + Slimit; + if (T1 > 0.0) + noizDens[B3SOIFLNOIZ] *= (Slimit + * Swi) / T1; + else + noizDens[B3SOIFLNOIZ] *= 0.0; + } + break; + } + + lnNdens[B3SOIFLNOIZ] = + log(MAX(noizDens[B3SOIFLNOIZ], N_MINLOG)); + + /* Low frequency excess noise due to FBE */ + NevalSrc(&noizDens[B3SOIFBNOIZ], &lnNdens[B3SOIFBNOIZ], + ckt, SHOTNOISE, here->B3SOIsNodePrime, + here->B3SOIbNode, + 2.0 * model->B3SOInoif * here->B3SOIibs * here->B3SOIm); + + noizDens[B3SOITOTNOIZ] = noizDens[B3SOIRDNOIZ] + + noizDens[B3SOIRSNOIZ] + + noizDens[B3SOIIDNOIZ] + + noizDens[B3SOIFLNOIZ] + + noizDens[B3SOIFBNOIZ]; + lnNdens[B3SOITOTNOIZ] = + log(MAX(noizDens[B3SOITOTNOIZ], N_MINLOG)); + + *OnDens += noizDens[B3SOITOTNOIZ]; + + if (data->delFreq == 0.0) + { /* if we haven't done any previous + integration, we need to initialize our + "history" variables. + */ + + for (i = 0; i < B3SOINSRCS; i++) + { here->B3SOInVar[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 < B3SOINSRCS; i++) + { here->B3SOInVar[OUTNOIZ][i] = 0.0; + here->B3SOInVar[INNOIZ][i] = 0.0; + } + } + } + else + { /* data->delFreq != 0.0, + we have to integrate. + */ + for (i = 0; i < B3SOINSRCS; i++) + { if (i != B3SOITOTNOIZ) + { tempOnoise = Nintegrate(noizDens[i], + lnNdens[i], + here->B3SOInVar[LNLSTDENS][i], + data); + tempInoise = Nintegrate(noizDens[i] + * data->GainSqInv, lnNdens[i] + + data->lnGainInv, + here->B3SOInVar[LNLSTDENS][i] + + data->lnGainInv, data); + here->B3SOInVar[LNLSTDENS][i] = + lnNdens[i]; + data->outNoiz += tempOnoise; + data->inNoise += tempInoise; + if (((NOISEAN*) + ckt->CKTcurJob)->NStpsSm != 0) + { here->B3SOInVar[OUTNOIZ][i] + += tempOnoise; + here->B3SOInVar[OUTNOIZ][B3SOITOTNOIZ] + += tempOnoise; + here->B3SOInVar[INNOIZ][i] + += tempInoise; + here->B3SOInVar[INNOIZ][B3SOITOTNOIZ] + += tempInoise; + } + } + } + } + if (data->prtSummary) + { for (i = 0; i < B3SOINSRCS; 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 < B3SOINSRCS; i++) + { data->outpVector[data->outNumber++] + = here->B3SOInVar[OUTNOIZ][i]; + data->outpVector[data->outNumber++] + = here->B3SOInVar[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/b3soipar.c b/src/spicelib/devices/bsim3soi/b3soipar.c new file mode 100644 index 000000000..6e9ed1d31 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soipar.c @@ -0,0 +1,172 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipar.c 98/5/01 +Modified by Pin Su 99/2/15 +Modified by Pin Su 01/2/15 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "ifsim.h" +#include "b3soidef.h" +#include "sperror.h" +#include "suffix.h" + +int +B3SOIparam(int param, IFvalue *value, GENinstance *inst, IFvalue *select) +{ + B3SOIinstance *here = (B3SOIinstance*)inst; + switch(param) + { case B3SOI_W: + here->B3SOIw = value->rValue; + here->B3SOIwGiven = TRUE; + break; + case B3SOI_L: + here->B3SOIl = value->rValue; + here->B3SOIlGiven = TRUE; + break; + case B3SOI_M: + here->B3SOIm = value->rValue; + here->B3SOImGiven = TRUE; + break; + case B3SOI_AS: + here->B3SOIsourceArea = value->rValue; + here->B3SOIsourceAreaGiven = TRUE; + break; + case B3SOI_AD: + here->B3SOIdrainArea = value->rValue; + here->B3SOIdrainAreaGiven = TRUE; + break; + case B3SOI_PS: + here->B3SOIsourcePerimeter = value->rValue; + here->B3SOIsourcePerimeterGiven = TRUE; + break; + case B3SOI_PD: + here->B3SOIdrainPerimeter = value->rValue; + here->B3SOIdrainPerimeterGiven = TRUE; + break; + case B3SOI_NRS: + here->B3SOIsourceSquares = value->rValue; + here->B3SOIsourceSquaresGiven = TRUE; + break; + case B3SOI_NRD: + here->B3SOIdrainSquares = value->rValue; + here->B3SOIdrainSquaresGiven = TRUE; + break; + case B3SOI_OFF: + here->B3SOIoff = value->iValue; + here->B3SOIoffGiven = TRUE; + break; + case B3SOI_IC_VBS: + here->B3SOIicVBS = value->rValue; + here->B3SOIicVBSGiven = TRUE; + break; + case B3SOI_IC_VDS: + here->B3SOIicVDS = value->rValue; + here->B3SOIicVDSGiven = TRUE; + break; + case B3SOI_IC_VGS: + here->B3SOIicVGS = value->rValue; + here->B3SOIicVGSGiven = TRUE; + break; + case B3SOI_IC_VES: + here->B3SOIicVES = value->rValue; + here->B3SOIicVESGiven = TRUE; + break; + case B3SOI_IC_VPS: + here->B3SOIicVPS = value->rValue; + here->B3SOIicVPSGiven = TRUE; + break; + case B3SOI_BJTOFF: + here->B3SOIbjtoff = value->iValue; + here->B3SOIbjtoffGiven= TRUE; + break; + case B3SOI_DEBUG: + here->B3SOIdebugMod = value->iValue; + here->B3SOIdebugModGiven= TRUE; + break; + case B3SOI_RTH0: + here->B3SOIrth0= value->rValue; + here->B3SOIrth0Given = TRUE; + break; + case B3SOI_CTH0: + here->B3SOIcth0= value->rValue; + here->B3SOIcth0Given = TRUE; + break; + case B3SOI_NRB: + here->B3SOIbodySquares = value->rValue; + here->B3SOIbodySquaresGiven = TRUE; + break; + case B3SOI_FRBODY: + here->B3SOIfrbody = value->rValue; + here->B3SOIfrbodyGiven = TRUE; + break; + + +/* v2.0 release */ + case B3SOI_NBC: + here->B3SOInbc = value->rValue; + here->B3SOInbcGiven = TRUE; + break; + case B3SOI_NSEG: + here->B3SOInseg = value->rValue; + here->B3SOInsegGiven = TRUE; + break; + case B3SOI_PDBCP: + here->B3SOIpdbcp = value->rValue; + here->B3SOIpdbcpGiven = TRUE; + break; + case B3SOI_PSBCP: + here->B3SOIpsbcp = value->rValue; + here->B3SOIpsbcpGiven = TRUE; + break; + case B3SOI_AGBCP: + here->B3SOIagbcp = value->rValue; + here->B3SOIagbcpGiven = TRUE; + break; + case B3SOI_AEBCP: + here->B3SOIaebcp = value->rValue; + here->B3SOIaebcpGiven = TRUE; + break; + case B3SOI_VBSUSR: + here->B3SOIvbsusr = value->rValue; + here->B3SOIvbsusrGiven = TRUE; + break; + case B3SOI_TNODEOUT: + here->B3SOItnodeout = value->iValue; + here->B3SOItnodeoutGiven = TRUE; + break; + + + case B3SOI_IC: + switch(value->v.numValue){ + case 5: + here->B3SOIicVPS = *(value->v.vec.rVec+4); + here->B3SOIicVPSGiven = TRUE; + case 4: + here->B3SOIicVES = *(value->v.vec.rVec+3); + here->B3SOIicVESGiven = TRUE; + case 3: + here->B3SOIicVBS = *(value->v.vec.rVec+2); + here->B3SOIicVBSGiven = TRUE; + case 2: + here->B3SOIicVGS = *(value->v.vec.rVec+1); + here->B3SOIicVGSGiven = TRUE; + case 1: + here->B3SOIicVDS = *(value->v.vec.rVec); + here->B3SOIicVDSGiven = TRUE; + break; + default: + return(E_BADPARM); + } + break; + default: + return(E_BADPARM); + } + return(OK); +} + + + diff --git a/src/spicelib/devices/bsim3soi/b3soipzld.c b/src/spicelib/devices/bsim3soi/b3soipzld.c new file mode 100644 index 000000000..34f6830d3 --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soipzld.c @@ -0,0 +1,157 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipzld.c 98/5/01 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "cktdefs.h" +#include "complex.h" +#include "sperror.h" +#include "b3soidef.h" +#include "suffix.h" + +int +B3SOIpzLoad(GENmodel *inModel, CKTcircuit *ckt, SPcomplex *s) +{ +B3SOImodel *model = (B3SOImodel*)inModel; +B3SOIinstance *here; +double xcggb, xcgdb, xcgsb, xcbgb, xcbdb, xcbsb, xcddb, xcssb, xcdgb; +double gdpr, gspr, gds, gbd, gbs, capbd, capbs, xcsgb, xcdsb, xcsdb; +double cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cddb, cdgb, cdsb; +double GSoverlapCap, GDoverlapCap, GBoverlapCap; +double FwdSum, RevSum, Gm, Gmbs; + +double m; + + for (; model != NULL; model = model->B3SOInextModel) + { for (here = model->B3SOIinstances; here!= NULL; + here = here->B3SOInextInstance) + { + + if (here->B3SOIowner != ARCHme) + continue; + + if (here->B3SOImode >= 0) + { Gm = here->B3SOIgm; + Gmbs = here->B3SOIgmbs; + FwdSum = Gm + Gmbs; + RevSum = 0.0; + cggb = here->B3SOIcggb; + cgsb = here->B3SOIcgsb; + cgdb = here->B3SOIcgdb; + + cbgb = here->B3SOIcbgb; + cbsb = here->B3SOIcbsb; + cbdb = here->B3SOIcbdb; + + cdgb = here->B3SOIcdgb; + cdsb = here->B3SOIcdsb; + cddb = here->B3SOIcddb; + } + else + { Gm = -here->B3SOIgm; + Gmbs = -here->B3SOIgmbs; + FwdSum = 0.0; + RevSum = -Gm - Gmbs; + cggb = here->B3SOIcggb; + cgsb = here->B3SOIcgdb; + cgdb = here->B3SOIcgsb; + + cbgb = here->B3SOIcbgb; + cbsb = here->B3SOIcbdb; + cbdb = here->B3SOIcbsb; + + cdgb = -(here->B3SOIcdgb + cggb + cbgb); + cdsb = -(here->B3SOIcddb + cgsb + cbsb); + cddb = -(here->B3SOIcdsb + cgdb + cbdb); + } + gdpr=here->B3SOIdrainConductance; + gspr=here->B3SOIsourceConductance; + gds= here->B3SOIgds; + gbd= here->B3SOIgjdb; + gbs= here->B3SOIgjsb; +#ifdef BULKCODE + capbd= here->B3SOIcapbd; + capbs= here->B3SOIcapbs; +#endif + GSoverlapCap = here->B3SOIcgso; + GDoverlapCap = here->B3SOIcgdo; +#ifdef BULKCODE + GBoverlapCap = here->pParam->B3SOIcgbo; +#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->B3SOIm; + + *(here->B3SOIGgPtr ) += m * (xcggb * s->real); + *(here->B3SOIGgPtr +1) += m * (xcggb * s->imag); + *(here->B3SOIBbPtr ) += m * ((-xcbgb-xcbdb-xcbsb) * s->real); + *(here->B3SOIBbPtr +1) += m * ((-xcbgb-xcbdb-xcbsb) * s->imag); + *(here->B3SOIDPdpPtr ) += m * (xcddb * s->real); + *(here->B3SOIDPdpPtr +1) += m * (xcddb * s->imag); + *(here->B3SOISPspPtr ) += m * (xcssb * s->real); + *(here->B3SOISPspPtr +1) += m * (xcssb * s->imag); + *(here->B3SOIGbPtr ) += m * ((-xcggb-xcgdb-xcgsb) * s->real); + *(here->B3SOIGbPtr +1) += m * ((-xcggb-xcgdb-xcgsb) * s->imag); + *(here->B3SOIGdpPtr ) += m * (xcgdb * s->real); + *(here->B3SOIGdpPtr +1) += m * (xcgdb * s->imag); + *(here->B3SOIGspPtr ) += m * (xcgsb * s->real); + *(here->B3SOIGspPtr +1) += m * (xcgsb * s->imag); + *(here->B3SOIBgPtr ) += m * (xcbgb * s->real); + *(here->B3SOIBgPtr +1) += m * (xcbgb * s->imag); + *(here->B3SOIBdpPtr ) += m * (xcbdb * s->real); + *(here->B3SOIBdpPtr +1) += m * (xcbdb * s->imag); + *(here->B3SOIBspPtr ) += m * (xcbsb * s->real); + *(here->B3SOIBspPtr +1) += m * (xcbsb * s->imag); + *(here->B3SOIDPgPtr ) += m * (xcdgb * s->real); + *(here->B3SOIDPgPtr +1) += m * (xcdgb * s->imag); + *(here->B3SOIDPbPtr ) += m * ((-xcdgb-xcddb-xcdsb) * s->real); + *(here->B3SOIDPbPtr +1) += m * ((-xcdgb-xcddb-xcdsb) * s->imag); + *(here->B3SOIDPspPtr ) += m * (xcdsb * s->real); + *(here->B3SOIDPspPtr +1) += m * (xcdsb * s->imag); + *(here->B3SOISPgPtr ) += m * (xcsgb * s->real); + *(here->B3SOISPgPtr +1) += m * (xcsgb * s->imag); + *(here->B3SOISPbPtr ) += m * ((-xcsgb-xcsdb-xcssb) * s->real); + *(here->B3SOISPbPtr +1) += m * ((-xcsgb-xcsdb-xcssb) * s->imag); + *(here->B3SOISPdpPtr ) += m * (xcsdb * s->real); + *(here->B3SOISPdpPtr +1) += m * (xcsdb * s->imag); + *(here->B3SOIDdPtr) += m * gdpr; + *(here->B3SOISsPtr) += m * gspr; + *(here->B3SOIBbPtr) += m * (gbd + gbs); + *(here->B3SOIDPdpPtr) += m * (gdpr + gds + gbd + RevSum); + *(here->B3SOISPspPtr) += m * (gspr + gds + gbs + FwdSum); + *(here->B3SOIDdpPtr) -= m * gdpr; + *(here->B3SOISspPtr) -= m * gspr; + *(here->B3SOIBdpPtr) -= m * gbd; + *(here->B3SOIBspPtr) -= m * gbs; + *(here->B3SOIDPdPtr) -= m * gdpr; + *(here->B3SOIDPgPtr) += m * Gm; + *(here->B3SOIDPbPtr) -= m * (gbd - Gmbs); + *(here->B3SOIDPspPtr) -= m * (gds + FwdSum); + *(here->B3SOISPgPtr) -= m * Gm; + *(here->B3SOISPsPtr) -= m * gspr; + *(here->B3SOISPbPtr) -= m * (gbs + Gmbs); + *(here->B3SOISPdpPtr) -= m * (gds + RevSum); + + } + } + return(OK); +} + + diff --git a/src/spicelib/devices/bsim3soi/b3soiset.c b/src/spicelib/devices/bsim3soi/b3soiset.c new file mode 100644 index 000000000..ad9b00fef --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soiset.c @@ -0,0 +1,1597 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soiset.c 98/5/01 +Modified by Pin Su and Jan Feng 99/2/15 +Modified by Pin Su 99/4/30 +Modified by Pin Su, Wei Jin 99/9/27 +Modified by Pin Su 00/3/1 +Modified by Pin Su 01/2/15 +Modified by Pin Su 02/3/5 +Modified by Pin Su 02/5/20 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "smpdefs.h" +#include "cktdefs.h" +#include "b3soidef.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 +B3SOIsetup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states) +{ +B3SOImodel *model = (B3SOImodel*)inModel; +B3SOIinstance *here; +int error; +CKTnode *tmp; + +double tmp1, tmp2; +double nfb0, Cboxt; +int itmp1; + + +/* Alan's Nodeset Fix */ +CKTnode *tmpNode; +IFuid tmpName; + + + /* loop through all the B3SOI device models */ + for( ; model != NULL; model = model->B3SOInextModel ) + { +/* Default value Processing for B3SOI MOSFET Models */ + + if (!model->B3SOItypeGiven) + model->B3SOItype = NMOS; + if (!model->B3SOImobModGiven) + model->B3SOImobMod = 1; + if (!model->B3SOIbinUnitGiven) + model->B3SOIbinUnit = 1; + if (!model->B3SOIparamChkGiven) + model->B3SOIparamChk = 0; + if (!model->B3SOIcapModGiven) + model->B3SOIcapMod = 2; + if (!model->B3SOInoiModGiven) + model->B3SOInoiMod = 1; + if (!model->B3SOIshModGiven) + model->B3SOIshMod = 0; + if (!model->B3SOIversionGiven) + model->B3SOIversion = 2.0; + if (!model->B3SOItoxGiven) + model->B3SOItox = 100.0e-10; + model->B3SOIcox = 3.453133e-11 / model->B3SOItox; + +/* v2.2.3 */ + if (!model->B3SOIdtoxcvGiven) + model->B3SOIdtoxcv = 0.0; + + if (!model->B3SOIcdscGiven) + model->B3SOIcdsc = 2.4e-4; /* unit Q/V/m^2 */ + if (!model->B3SOIcdscbGiven) + model->B3SOIcdscb = 0.0; /* unit Q/V/m^2 */ + if (!model->B3SOIcdscdGiven) + model->B3SOIcdscd = 0.0; /* unit Q/V/m^2 */ + if (!model->B3SOIcitGiven) + model->B3SOIcit = 0.0; /* unit Q/V/m^2 */ + if (!model->B3SOInfactorGiven) + model->B3SOInfactor = 1; + if (!model->B3SOIvsatGiven) + model->B3SOIvsat = 8.0e4; /* unit m/s */ + if (!model->B3SOIatGiven) + model->B3SOIat = 3.3e4; /* unit m/s */ + if (!model->B3SOIa0Given) + model->B3SOIa0 = 1.0; + if (!model->B3SOIagsGiven) + model->B3SOIags = 0.0; + if (!model->B3SOIa1Given) + model->B3SOIa1 = 0.0; + if (!model->B3SOIa2Given) + model->B3SOIa2 = 1.0; + if (!model->B3SOIketaGiven) + model->B3SOIketa = -0.6; /* unit / V */ + if (!model->B3SOInsubGiven) + model->B3SOInsub = 6.0e16; /* unit 1/cm3 */ + if (!model->B3SOInpeakGiven) + model->B3SOInpeak = 1.7e17; /* unit 1/cm3 */ + if (!model->B3SOIngateGiven) + model->B3SOIngate = 0; /* unit 1/cm3 */ + if (!model->B3SOIvbmGiven) + model->B3SOIvbm = -3.0; + if (!model->B3SOIxtGiven) + model->B3SOIxt = 1.55e-7; + if (!model->B3SOIkt1Given) + model->B3SOIkt1 = -0.11; /* unit V */ + if (!model->B3SOIkt1lGiven) + model->B3SOIkt1l = 0.0; /* unit V*m */ + if (!model->B3SOIkt2Given) + model->B3SOIkt2 = 0.022; /* No unit */ + if (!model->B3SOIk3Given) + model->B3SOIk3 = 0.0; + if (!model->B3SOIk3bGiven) + model->B3SOIk3b = 0.0; + if (!model->B3SOIw0Given) + model->B3SOIw0 = 2.5e-6; + if (!model->B3SOInlxGiven) + model->B3SOInlx = 1.74e-7; + if (!model->B3SOIdvt0Given) + model->B3SOIdvt0 = 2.2; + if (!model->B3SOIdvt1Given) + model->B3SOIdvt1 = 0.53; + if (!model->B3SOIdvt2Given) + model->B3SOIdvt2 = -0.032; /* unit 1 / V */ + + if (!model->B3SOIdvt0wGiven) + model->B3SOIdvt0w = 0.0; + if (!model->B3SOIdvt1wGiven) + model->B3SOIdvt1w = 5.3e6; + if (!model->B3SOIdvt2wGiven) + model->B3SOIdvt2w = -0.032; + + if (!model->B3SOIdroutGiven) + model->B3SOIdrout = 0.56; + if (!model->B3SOIdsubGiven) + model->B3SOIdsub = model->B3SOIdrout; + if (!model->B3SOIvth0Given) + model->B3SOIvth0 = (model->B3SOItype == NMOS) ? 0.7 : -0.7; + if (!model->B3SOIuaGiven) + model->B3SOIua = 2.25e-9; /* unit m/V */ + if (!model->B3SOIua1Given) + model->B3SOIua1 = 4.31e-9; /* unit m/V */ + if (!model->B3SOIubGiven) + model->B3SOIub = 5.87e-19; /* unit (m/V)**2 */ + if (!model->B3SOIub1Given) + model->B3SOIub1 = -7.61e-18; /* unit (m/V)**2 */ + if (!model->B3SOIucGiven) + model->B3SOIuc = (model->B3SOImobMod == 3) ? -0.0465 : -0.0465e-9; + if (!model->B3SOIuc1Given) + model->B3SOIuc1 = (model->B3SOImobMod == 3) ? -0.056 : -0.056e-9; + if (!model->B3SOIu0Given) + model->B3SOIu0 = (model->B3SOItype == NMOS) ? 0.067 : 0.025; + if (!model->B3SOIuteGiven) + model->B3SOIute = -1.5; + if (!model->B3SOIvoffGiven) + model->B3SOIvoff = -0.08; + if (!model->B3SOIdeltaGiven) + model->B3SOIdelta = 0.01; + if (!model->B3SOIrdswGiven) + model->B3SOIrdsw = 100; + if (!model->B3SOIprwgGiven) + model->B3SOIprwg = 0.0; /* unit 1/V */ + if (!model->B3SOIprwbGiven) + model->B3SOIprwb = 0.0; + if (!model->B3SOIprtGiven) + if (!model->B3SOIprtGiven) + model->B3SOIprt = 0.0; + if (!model->B3SOIeta0Given) + model->B3SOIeta0 = 0.08; /* no unit */ + if (!model->B3SOIetabGiven) + model->B3SOIetab = -0.07; /* unit 1/V */ + if (!model->B3SOIpclmGiven) + model->B3SOIpclm = 1.3; /* no unit */ + if (!model->B3SOIpdibl1Given) + model->B3SOIpdibl1 = .39; /* no unit */ + if (!model->B3SOIpdibl2Given) + model->B3SOIpdibl2 = 0.0086; /* no unit */ + if (!model->B3SOIpdiblbGiven) + model->B3SOIpdiblb = 0.0; /* 1/V */ + if (!model->B3SOIpvagGiven) + model->B3SOIpvag = 0.0; + if (!model->B3SOIwrGiven) + model->B3SOIwr = 1.0; + if (!model->B3SOIdwgGiven) + model->B3SOIdwg = 0.0; + if (!model->B3SOIdwbGiven) + model->B3SOIdwb = 0.0; + if (!model->B3SOIb0Given) + model->B3SOIb0 = 0.0; + if (!model->B3SOIb1Given) + model->B3SOIb1 = 0.0; + if (!model->B3SOIalpha0Given) + model->B3SOIalpha0 = 0.0; + + if (!model->B3SOIcgslGiven) + model->B3SOIcgsl = 0.0; + if (!model->B3SOIcgdlGiven) + model->B3SOIcgdl = 0.0; + if (!model->B3SOIckappaGiven) + model->B3SOIckappa = 0.6; + if (!model->B3SOIclcGiven) + model->B3SOIclc = 0.1e-7; + if (!model->B3SOIcleGiven) + model->B3SOIcle = 0.0; + if (!model->B3SOItboxGiven) + model->B3SOItbox = 3e-7; + if (!model->B3SOItsiGiven) + model->B3SOItsi = 1e-7; + if (!model->B3SOIxjGiven) + model->B3SOIxj = model->B3SOItsi; + if (!model->B3SOIrbodyGiven) + model->B3SOIrbody = 0.0; + if (!model->B3SOIrbshGiven) + model->B3SOIrbsh = 0.0; + if (!model->B3SOIrth0Given) + model->B3SOIrth0 = 0; + +/* v3.0 bug fix */ + if (!model->B3SOIcth0Given) + model->B3SOIcth0 = 1e-5; + + if (!model->B3SOIagidlGiven) + model->B3SOIagidl = 0.0; + if (!model->B3SOIbgidlGiven) + model->B3SOIbgidl = 0.0; + if (!model->B3SOIngidlGiven) + model->B3SOIngidl = 1.2; + if (!model->B3SOIndiodeGiven) + model->B3SOIndiode = 1.0; + if (!model->B3SOIntunGiven) + model->B3SOIntun = 10.0; + + if (!model->B3SOInrecf0Given) + model->B3SOInrecf0 = 2.0; + if (!model->B3SOInrecr0Given) + model->B3SOInrecr0 = 10.0; + + if (!model->B3SOIisbjtGiven) + model->B3SOIisbjt = 1e-6; + if (!model->B3SOIisdifGiven) + model->B3SOIisdif = 0.0; + if (!model->B3SOIisrecGiven) + model->B3SOIisrec = 1e-5; + if (!model->B3SOIistunGiven) + model->B3SOIistun = 0.0; + if (!model->B3SOIxbjtGiven) + model->B3SOIxbjt = 1; +/* + if (!model->B3SOIxdifGiven) + model->B3SOIxdif = 1; +*/ + if (!model->B3SOIxdifGiven) + model->B3SOIxdif = model->B3SOIxbjt; + + if (!model->B3SOIxrecGiven) + model->B3SOIxrec = 1; + if (!model->B3SOIxtunGiven) + model->B3SOIxtun = 0; + if (!model->B3SOIttGiven) + model->B3SOItt = 1e-12; + if (!model->B3SOIasdGiven) + model->B3SOIasd = 0.3; + + /* unit degree celcius */ + if (!model->B3SOItnomGiven) + model->B3SOItnom = ckt->CKTnomTemp; + if (!model->B3SOILintGiven) + model->B3SOILint = 0.0; + if (!model->B3SOILlGiven) + model->B3SOILl = 0.0; + if (!model->B3SOILlcGiven) + model->B3SOILlc = 0.0; /* v2.2.3 */ + if (!model->B3SOILlnGiven) + model->B3SOILln = 1.0; + if (!model->B3SOILwGiven) + model->B3SOILw = 0.0; + if (!model->B3SOILwcGiven) + model->B3SOILwc = 0.0; /* v2.2.3 */ + if (!model->B3SOILwnGiven) + model->B3SOILwn = 1.0; + if (!model->B3SOILwlGiven) + model->B3SOILwl = 0.0; + if (!model->B3SOILwlcGiven) + model->B3SOILwlc = 0.0; /* v2.2.3 */ + if (!model->B3SOILminGiven) + model->B3SOILmin = 0.0; + if (!model->B3SOILmaxGiven) + model->B3SOILmax = 1.0; + if (!model->B3SOIWintGiven) + model->B3SOIWint = 0.0; + if (!model->B3SOIWlGiven) + model->B3SOIWl = 0.0; + if (!model->B3SOIWlcGiven) + model->B3SOIWlc = 0.0; /* v2.2.3 */ + if (!model->B3SOIWlnGiven) + model->B3SOIWln = 1.0; + if (!model->B3SOIWwGiven) + model->B3SOIWw = 0.0; + if (!model->B3SOIWwcGiven) + model->B3SOIWwc = 0.0; /* v2.2.3 */ + if (!model->B3SOIWwnGiven) + model->B3SOIWwn = 1.0; + if (!model->B3SOIWwlGiven) + model->B3SOIWwl = 0.0; + if (!model->B3SOIWwlcGiven) + model->B3SOIWwlc = 0.0; /* v2.2.3 */ + if (!model->B3SOIWminGiven) + model->B3SOIWmin = 0.0; + if (!model->B3SOIWmaxGiven) + model->B3SOIWmax = 1.0; + if (!model->B3SOIdwcGiven) + model->B3SOIdwc = model->B3SOIWint; + if (!model->B3SOIdlcGiven) + model->B3SOIdlc = model->B3SOILint; + if (!model->B3SOIdlcigGiven) + model->B3SOIdlcig = model->B3SOILint; /* v3.0 */ + +/* v3.0 */ + if (!model->B3SOIsoimodGiven) + model->B3SOIsoiMod = 0; + if (!model->B3SOIvbsaGiven) + model->B3SOIvbsa = 0.0; + if (!model->B3SOInofffdGiven) + model->B3SOInofffd = 1.0; + if (!model->B3SOIvofffdGiven) + model->B3SOIvofffd = 0.0; + if (!model->B3SOIk1bGiven) + model->B3SOIk1b = 1.0; + if (!model->B3SOIk2bGiven) + model->B3SOIk2b = 0.0; + if (!model->B3SOIdk2bGiven) + model->B3SOIdk2b = 0.0; + if (!model->B3SOIdvbd0Given) + model->B3SOIdvbd0 = 0.0; + if (!model->B3SOIdvbd1Given) + model->B3SOIdvbd1 = 0.0; + if (!model->B3SOImoinFDGiven) + model->B3SOImoinFD = 1e3; + + +/* v2.2 release */ + if (!model->B3SOIwth0Given) + model->B3SOIwth0 = 0.0; + if (!model->B3SOIrhaloGiven) + model->B3SOIrhalo = 1e15; + if (!model->B3SOIntoxGiven) + model->B3SOIntox = 1; + if (!model->B3SOItoxrefGiven) + model->B3SOItoxref = 2.5e-9; + if (!model->B3SOIebgGiven) + model->B3SOIebg = 1.2; + if (!model->B3SOIvevbGiven) + model->B3SOIvevb = 0.075; + if (!model->B3SOIalphaGB1Given) + model->B3SOIalphaGB1 = 0.35; + if (!model->B3SOIbetaGB1Given) + model->B3SOIbetaGB1 = 0.03; + if (!model->B3SOIvgb1Given) + model->B3SOIvgb1 = 300; + if (!model->B3SOIalphaGB2Given) + model->B3SOIalphaGB2 = 0.43; + if (!model->B3SOIbetaGB2Given) + model->B3SOIbetaGB2 = 0.05; + if (!model->B3SOIvecbGiven) + model->B3SOIvecb = 0.026; + if (!model->B3SOIvgb2Given) + model->B3SOIvgb2 = 17; + if (!model->B3SOItoxqmGiven) + model->B3SOItoxqm = model->B3SOItox; + if (!model->B3SOIvoxhGiven) + model->B3SOIvoxh = 5.0; + if (!model->B3SOIdeltavoxGiven) + model->B3SOIdeltavox = 0.005; + +/* v3.0 */ + if (!model->B3SOIigbModGiven) + model->B3SOIigbMod = 0; + if (!model->B3SOIigcModGiven) + model->B3SOIigcMod = 0; + if (!model->B3SOInigcGiven) + model->B3SOInigc = 1.0; + if (!model->B3SOIaigcGiven) + model->B3SOIaigc = (model->B3SOItype == NMOS) ? 0.43 : 0.31; + if (!model->B3SOIbigcGiven) + model->B3SOIbigc = (model->B3SOItype == NMOS) ? 0.054 : 0.024; + if (!model->B3SOIcigcGiven) + model->B3SOIcigc = (model->B3SOItype == NMOS) ? 0.075 : 0.03; + if (!model->B3SOIaigsdGiven) + model->B3SOIaigsd = (model->B3SOItype == NMOS) ? 0.43 : 0.31; + if (!model->B3SOIbigsdGiven) + model->B3SOIbigsd = (model->B3SOItype == NMOS) ? 0.054 : 0.024; + if (!model->B3SOIcigsdGiven) + model->B3SOIcigsd = (model->B3SOItype == NMOS) ? 0.075 : 0.03; + if (!model->B3SOIpigcdGiven) + model->B3SOIpigcd = 1.0; + if (!model->B3SOIpoxedgeGiven) + model->B3SOIpoxedge = 1.0; + + + +/* v2.0 release */ + if (!model->B3SOIk1w1Given) + model->B3SOIk1w1 = 0.0; + if (!model->B3SOIk1w2Given) + model->B3SOIk1w2 = 0.0; + if (!model->B3SOIketasGiven) + model->B3SOIketas = 0.0; + if (!model->B3SOIdwbcGiven) + model->B3SOIdwbc = 0.0; + if (!model->B3SOIbeta0Given) + model->B3SOIbeta0 = 0.0; + if (!model->B3SOIbeta1Given) + model->B3SOIbeta1 = 0.0; + if (!model->B3SOIbeta2Given) + model->B3SOIbeta2 = 0.1; + if (!model->B3SOIvdsatii0Given) + model->B3SOIvdsatii0 = 0.9; + if (!model->B3SOItiiGiven) + model->B3SOItii = 0.0; + if (!model->B3SOIliiGiven) + model->B3SOIlii = 0.0; + if (!model->B3SOIsii0Given) + model->B3SOIsii0 = 0.5; + if (!model->B3SOIsii1Given) + model->B3SOIsii1 = 0.1; + if (!model->B3SOIsii2Given) + model->B3SOIsii2 = 0.0; + if (!model->B3SOIsiidGiven) + model->B3SOIsiid = 0.0; + if (!model->B3SOIfbjtiiGiven) + model->B3SOIfbjtii = 0.0; + if (!model->B3SOIesatiiGiven) + model->B3SOIesatii = 1e7; + if (!model->B3SOIlnGiven) + model->B3SOIln = 2e-6; + if (!model->B3SOIvrec0Given) + model->B3SOIvrec0 = 0; + if (!model->B3SOIvtun0Given) + model->B3SOIvtun0 = 0; + if (!model->B3SOInbjtGiven) + model->B3SOInbjt = 1.0; + if (!model->B3SOIlbjt0Given) + model->B3SOIlbjt0 = 0.20e-6; + if (!model->B3SOIldif0Given) + model->B3SOIldif0 = 1.0; + if (!model->B3SOIvabjtGiven) + model->B3SOIvabjt = 10.0; + if (!model->B3SOIaelyGiven) + model->B3SOIaely = 0; + if (!model->B3SOIahliGiven) + model->B3SOIahli = 0; + if (!model->B3SOIrbodyGiven) + model->B3SOIrbody = 0.0; + if (!model->B3SOIrbshGiven) + model->B3SOIrbsh = 0.0; + if (!model->B3SOIntrecfGiven) + model->B3SOIntrecf = 0.0; + if (!model->B3SOIntrecrGiven) + model->B3SOIntrecr = 0.0; + if (!model->B3SOIndifGiven) + model->B3SOIndif = -1.0; + if (!model->B3SOIdlcbGiven) + model->B3SOIdlcb = 0.0; + if (!model->B3SOIfbodyGiven) + model->B3SOIfbody = 1.0; + if (!model->B3SOItcjswgGiven) + model->B3SOItcjswg = 0.0; + if (!model->B3SOItpbswgGiven) + model->B3SOItpbswg = 0.0; + if (!model->B3SOIacdeGiven) + model->B3SOIacde = 1.0; + if (!model->B3SOImoinGiven) + model->B3SOImoin = 15.0; + if (!model->B3SOIdelvtGiven) + model->B3SOIdelvt = 0.0; + if (!model->B3SOIkb1Given) + model->B3SOIkb1 = 1.0; + if (!model->B3SOIdlbgGiven) + model->B3SOIdlbg = 0.0; + +/* Added for binning - START */ + /* Length dependence */ +/* v3.0 */ + if (!model->B3SOIlnigcGiven) + model->B3SOIlnigc = 0.0; + if (!model->B3SOIlpigcdGiven) + model->B3SOIlpigcd = 0.0; + if (!model->B3SOIlpoxedgeGiven) + model->B3SOIlpoxedge = 0.0; + if (!model->B3SOIlaigcGiven) + model->B3SOIlaigc = 0.0; + if (!model->B3SOIlbigcGiven) + model->B3SOIlbigc = 0.0; + if (!model->B3SOIlcigcGiven) + model->B3SOIlcigc = 0.0; + if (!model->B3SOIlaigsdGiven) + model->B3SOIlaigsd = 0.0; + if (!model->B3SOIlbigsdGiven) + model->B3SOIlbigsd = 0.0; + if (!model->B3SOIlcigsdGiven) + model->B3SOIlcigsd = 0.0; + + if (!model->B3SOIlnpeakGiven) + model->B3SOIlnpeak = 0.0; + if (!model->B3SOIlnsubGiven) + model->B3SOIlnsub = 0.0; + if (!model->B3SOIlngateGiven) + model->B3SOIlngate = 0.0; + if (!model->B3SOIlvth0Given) + model->B3SOIlvth0 = 0.0; + if (!model->B3SOIlk1Given) + model->B3SOIlk1 = 0.0; + if (!model->B3SOIlk1w1Given) + model->B3SOIlk1w1 = 0.0; + if (!model->B3SOIlk1w2Given) + model->B3SOIlk1w2 = 0.0; + if (!model->B3SOIlk2Given) + model->B3SOIlk2 = 0.0; + if (!model->B3SOIlk3Given) + model->B3SOIlk3 = 0.0; + if (!model->B3SOIlk3bGiven) + model->B3SOIlk3b = 0.0; + if (!model->B3SOIlkb1Given) + model->B3SOIlkb1 = 0.0; + if (!model->B3SOIlw0Given) + model->B3SOIlw0 = 0.0; + if (!model->B3SOIlnlxGiven) + model->B3SOIlnlx = 0.0; + if (!model->B3SOIldvt0Given) + model->B3SOIldvt0 = 0.0; + if (!model->B3SOIldvt1Given) + model->B3SOIldvt1 = 0.0; + if (!model->B3SOIldvt2Given) + model->B3SOIldvt2 = 0.0; + if (!model->B3SOIldvt0wGiven) + model->B3SOIldvt0w = 0.0; + if (!model->B3SOIldvt1wGiven) + model->B3SOIldvt1w = 0.0; + if (!model->B3SOIldvt2wGiven) + model->B3SOIldvt2w = 0.0; + if (!model->B3SOIlu0Given) + model->B3SOIlu0 = 0.0; + if (!model->B3SOIluaGiven) + model->B3SOIlua = 0.0; + if (!model->B3SOIlubGiven) + model->B3SOIlub = 0.0; + if (!model->B3SOIlucGiven) + model->B3SOIluc = 0.0; + if (!model->B3SOIlvsatGiven) + model->B3SOIlvsat = 0.0; + if (!model->B3SOIla0Given) + model->B3SOIla0 = 0.0; + if (!model->B3SOIlagsGiven) + model->B3SOIlags = 0.0; + if (!model->B3SOIlb0Given) + model->B3SOIlb0 = 0.0; + if (!model->B3SOIlb1Given) + model->B3SOIlb1 = 0.0; + if (!model->B3SOIlketaGiven) + model->B3SOIlketa = 0.0; + if (!model->B3SOIlketasGiven) + model->B3SOIlketas = 0.0; + if (!model->B3SOIla1Given) + model->B3SOIla1 = 0.0; + if (!model->B3SOIla2Given) + model->B3SOIla2 = 0.0; + if (!model->B3SOIlrdswGiven) + model->B3SOIlrdsw = 0.0; + if (!model->B3SOIlprwbGiven) + model->B3SOIlprwb = 0.0; + if (!model->B3SOIlprwgGiven) + model->B3SOIlprwg = 0.0; + if (!model->B3SOIlwrGiven) + model->B3SOIlwr = 0.0; + if (!model->B3SOIlnfactorGiven) + model->B3SOIlnfactor = 0.0; + if (!model->B3SOIldwgGiven) + model->B3SOIldwg = 0.0; + if (!model->B3SOIldwbGiven) + model->B3SOIldwb = 0.0; + if (!model->B3SOIlvoffGiven) + model->B3SOIlvoff = 0.0; + if (!model->B3SOIleta0Given) + model->B3SOIleta0 = 0.0; + if (!model->B3SOIletabGiven) + model->B3SOIletab = 0.0; + if (!model->B3SOIldsubGiven) + model->B3SOIldsub = 0.0; + if (!model->B3SOIlcitGiven) + model->B3SOIlcit = 0.0; + if (!model->B3SOIlcdscGiven) + model->B3SOIlcdsc = 0.0; + if (!model->B3SOIlcdscbGiven) + model->B3SOIlcdscb = 0.0; + if (!model->B3SOIlcdscdGiven) + model->B3SOIlcdscd = 0.0; + if (!model->B3SOIlpclmGiven) + model->B3SOIlpclm = 0.0; + if (!model->B3SOIlpdibl1Given) + model->B3SOIlpdibl1 = 0.0; + if (!model->B3SOIlpdibl2Given) + model->B3SOIlpdibl2 = 0.0; + if (!model->B3SOIlpdiblbGiven) + model->B3SOIlpdiblb = 0.0; + if (!model->B3SOIldroutGiven) + model->B3SOIldrout = 0.0; + if (!model->B3SOIlpvagGiven) + model->B3SOIlpvag = 0.0; + if (!model->B3SOIldeltaGiven) + model->B3SOIldelta = 0.0; + if (!model->B3SOIlalpha0Given) + model->B3SOIlalpha0 = 0.0; + if (!model->B3SOIlfbjtiiGiven) + model->B3SOIlfbjtii = 0.0; + if (!model->B3SOIlbeta0Given) + model->B3SOIlbeta0 = 0.0; + if (!model->B3SOIlbeta1Given) + model->B3SOIlbeta1 = 0.0; + if (!model->B3SOIlbeta2Given) + model->B3SOIlbeta2 = 0.0; + if (!model->B3SOIlvdsatii0Given) + model->B3SOIlvdsatii0 = 0.0; + if (!model->B3SOIlliiGiven) + model->B3SOIllii = 0.0; + if (!model->B3SOIlesatiiGiven) + model->B3SOIlesatii = 0.0; + if (!model->B3SOIlsii0Given) + model->B3SOIlsii0 = 0.0; + if (!model->B3SOIlsii1Given) + model->B3SOIlsii1 = 0.0; + if (!model->B3SOIlsii2Given) + model->B3SOIlsii2 = 0.0; + if (!model->B3SOIlsiidGiven) + model->B3SOIlsiid = 0.0; + if (!model->B3SOIlagidlGiven) + model->B3SOIlagidl = 0.0; + if (!model->B3SOIlbgidlGiven) + model->B3SOIlbgidl = 0.0; + if (!model->B3SOIlngidlGiven) + model->B3SOIlngidl = 0.0; + if (!model->B3SOIlntunGiven) + model->B3SOIlntun = 0.0; + if (!model->B3SOIlndiodeGiven) + model->B3SOIlndiode = 0.0; + if (!model->B3SOIlnrecf0Given) + model->B3SOIlnrecf0 = 0.0; + if (!model->B3SOIlnrecr0Given) + model->B3SOIlnrecr0 = 0.0; + if (!model->B3SOIlisbjtGiven) + model->B3SOIlisbjt = 0.0; + if (!model->B3SOIlisdifGiven) + model->B3SOIlisdif = 0.0; + if (!model->B3SOIlisrecGiven) + model->B3SOIlisrec = 0.0; + if (!model->B3SOIlistunGiven) + model->B3SOIlistun = 0.0; + if (!model->B3SOIlvrec0Given) + model->B3SOIlvrec0 = 0.0; + if (!model->B3SOIlvtun0Given) + model->B3SOIlvtun0 = 0.0; + if (!model->B3SOIlnbjtGiven) + model->B3SOIlnbjt = 0.0; + if (!model->B3SOIllbjt0Given) + model->B3SOIllbjt0 = 0.0; + if (!model->B3SOIlvabjtGiven) + model->B3SOIlvabjt = 0.0; + if (!model->B3SOIlaelyGiven) + model->B3SOIlaely = 0.0; + if (!model->B3SOIlahliGiven) + model->B3SOIlahli = 0.0; + /* CV Model */ + if (!model->B3SOIlvsdfbGiven) + model->B3SOIlvsdfb = 0.0; + if (!model->B3SOIlvsdthGiven) + model->B3SOIlvsdth = 0.0; + if (!model->B3SOIldelvtGiven) + model->B3SOIldelvt = 0.0; + if (!model->B3SOIlacdeGiven) + model->B3SOIlacde = 0.0; + if (!model->B3SOIlmoinGiven) + model->B3SOIlmoin = 0.0; + + /* Width dependence */ +/* v3.0 */ + if (!model->B3SOIwnigcGiven) + model->B3SOIwnigc = 0.0; + if (!model->B3SOIwpigcdGiven) + model->B3SOIwpigcd = 0.0; + if (!model->B3SOIwpoxedgeGiven) + model->B3SOIwpoxedge = 0.0; + if (!model->B3SOIwaigcGiven) + model->B3SOIwaigc = 0.0; + if (!model->B3SOIwbigcGiven) + model->B3SOIwbigc = 0.0; + if (!model->B3SOIwcigcGiven) + model->B3SOIwcigc = 0.0; + if (!model->B3SOIwaigsdGiven) + model->B3SOIwaigsd = 0.0; + if (!model->B3SOIwbigsdGiven) + model->B3SOIwbigsd = 0.0; + if (!model->B3SOIwcigsdGiven) + model->B3SOIwcigsd = 0.0; + + if (!model->B3SOIwnpeakGiven) + model->B3SOIwnpeak = 0.0; + if (!model->B3SOIwnsubGiven) + model->B3SOIwnsub = 0.0; + if (!model->B3SOIwngateGiven) + model->B3SOIwngate = 0.0; + if (!model->B3SOIwvth0Given) + model->B3SOIwvth0 = 0.0; + if (!model->B3SOIwk1Given) + model->B3SOIwk1 = 0.0; + if (!model->B3SOIwk1w1Given) + model->B3SOIwk1w1 = 0.0; + if (!model->B3SOIwk1w2Given) + model->B3SOIwk1w2 = 0.0; + if (!model->B3SOIwk2Given) + model->B3SOIwk2 = 0.0; + if (!model->B3SOIwk3Given) + model->B3SOIwk3 = 0.0; + if (!model->B3SOIwk3bGiven) + model->B3SOIwk3b = 0.0; + if (!model->B3SOIwkb1Given) + model->B3SOIwkb1 = 0.0; + if (!model->B3SOIww0Given) + model->B3SOIww0 = 0.0; + if (!model->B3SOIwnlxGiven) + model->B3SOIwnlx = 0.0; + if (!model->B3SOIwdvt0Given) + model->B3SOIwdvt0 = 0.0; + if (!model->B3SOIwdvt1Given) + model->B3SOIwdvt1 = 0.0; + if (!model->B3SOIwdvt2Given) + model->B3SOIwdvt2 = 0.0; + if (!model->B3SOIwdvt0wGiven) + model->B3SOIwdvt0w = 0.0; + if (!model->B3SOIwdvt1wGiven) + model->B3SOIwdvt1w = 0.0; + if (!model->B3SOIwdvt2wGiven) + model->B3SOIwdvt2w = 0.0; + if (!model->B3SOIwu0Given) + model->B3SOIwu0 = 0.0; + if (!model->B3SOIwuaGiven) + model->B3SOIwua = 0.0; + if (!model->B3SOIwubGiven) + model->B3SOIwub = 0.0; + if (!model->B3SOIwucGiven) + model->B3SOIwuc = 0.0; + if (!model->B3SOIwvsatGiven) + model->B3SOIwvsat = 0.0; + if (!model->B3SOIwa0Given) + model->B3SOIwa0 = 0.0; + if (!model->B3SOIwagsGiven) + model->B3SOIwags = 0.0; + if (!model->B3SOIwb0Given) + model->B3SOIwb0 = 0.0; + if (!model->B3SOIwb1Given) + model->B3SOIwb1 = 0.0; + if (!model->B3SOIwketaGiven) + model->B3SOIwketa = 0.0; + if (!model->B3SOIwketasGiven) + model->B3SOIwketas = 0.0; + if (!model->B3SOIwa1Given) + model->B3SOIwa1 = 0.0; + if (!model->B3SOIwa2Given) + model->B3SOIwa2 = 0.0; + if (!model->B3SOIwrdswGiven) + model->B3SOIwrdsw = 0.0; + if (!model->B3SOIwprwbGiven) + model->B3SOIwprwb = 0.0; + if (!model->B3SOIwprwgGiven) + model->B3SOIwprwg = 0.0; + if (!model->B3SOIwwrGiven) + model->B3SOIwwr = 0.0; + if (!model->B3SOIwnfactorGiven) + model->B3SOIwnfactor = 0.0; + if (!model->B3SOIwdwgGiven) + model->B3SOIwdwg = 0.0; + if (!model->B3SOIwdwbGiven) + model->B3SOIwdwb = 0.0; + if (!model->B3SOIwvoffGiven) + model->B3SOIwvoff = 0.0; + if (!model->B3SOIweta0Given) + model->B3SOIweta0 = 0.0; + if (!model->B3SOIwetabGiven) + model->B3SOIwetab = 0.0; + if (!model->B3SOIwdsubGiven) + model->B3SOIwdsub = 0.0; + if (!model->B3SOIwcitGiven) + model->B3SOIwcit = 0.0; + if (!model->B3SOIwcdscGiven) + model->B3SOIwcdsc = 0.0; + if (!model->B3SOIwcdscbGiven) + model->B3SOIwcdscb = 0.0; + if (!model->B3SOIwcdscdGiven) + model->B3SOIwcdscd = 0.0; + if (!model->B3SOIwpclmGiven) + model->B3SOIwpclm = 0.0; + if (!model->B3SOIwpdibl1Given) + model->B3SOIwpdibl1 = 0.0; + if (!model->B3SOIwpdibl2Given) + model->B3SOIwpdibl2 = 0.0; + if (!model->B3SOIwpdiblbGiven) + model->B3SOIwpdiblb = 0.0; + if (!model->B3SOIwdroutGiven) + model->B3SOIwdrout = 0.0; + if (!model->B3SOIwpvagGiven) + model->B3SOIwpvag = 0.0; + if (!model->B3SOIwdeltaGiven) + model->B3SOIwdelta = 0.0; + if (!model->B3SOIwalpha0Given) + model->B3SOIwalpha0 = 0.0; + if (!model->B3SOIwfbjtiiGiven) + model->B3SOIwfbjtii = 0.0; + if (!model->B3SOIwbeta0Given) + model->B3SOIwbeta0 = 0.0; + if (!model->B3SOIwbeta1Given) + model->B3SOIwbeta1 = 0.0; + if (!model->B3SOIwbeta2Given) + model->B3SOIwbeta2 = 0.0; + if (!model->B3SOIwvdsatii0Given) + model->B3SOIwvdsatii0 = 0.0; + if (!model->B3SOIwliiGiven) + model->B3SOIwlii = 0.0; + if (!model->B3SOIwesatiiGiven) + model->B3SOIwesatii = 0.0; + if (!model->B3SOIwsii0Given) + model->B3SOIwsii0 = 0.0; + if (!model->B3SOIwsii1Given) + model->B3SOIwsii1 = 0.0; + if (!model->B3SOIwsii2Given) + model->B3SOIwsii2 = 0.0; + if (!model->B3SOIwsiidGiven) + model->B3SOIwsiid = 0.0; + if (!model->B3SOIwagidlGiven) + model->B3SOIwagidl = 0.0; + if (!model->B3SOIwbgidlGiven) + model->B3SOIwbgidl = 0.0; + if (!model->B3SOIwngidlGiven) + model->B3SOIwngidl = 0.0; + if (!model->B3SOIwntunGiven) + model->B3SOIwntun = 0.0; + if (!model->B3SOIwndiodeGiven) + model->B3SOIwndiode = 0.0; + if (!model->B3SOIwnrecf0Given) + model->B3SOIwnrecf0 = 0.0; + if (!model->B3SOIwnrecr0Given) + model->B3SOIwnrecr0 = 0.0; + if (!model->B3SOIwisbjtGiven) + model->B3SOIwisbjt = 0.0; + if (!model->B3SOIwisdifGiven) + model->B3SOIwisdif = 0.0; + if (!model->B3SOIwisrecGiven) + model->B3SOIwisrec = 0.0; + if (!model->B3SOIwistunGiven) + model->B3SOIwistun = 0.0; + if (!model->B3SOIwvrec0Given) + model->B3SOIwvrec0 = 0.0; + if (!model->B3SOIwvtun0Given) + model->B3SOIwvtun0 = 0.0; + if (!model->B3SOIwnbjtGiven) + model->B3SOIwnbjt = 0.0; + if (!model->B3SOIwlbjt0Given) + model->B3SOIwlbjt0 = 0.0; + if (!model->B3SOIwvabjtGiven) + model->B3SOIwvabjt = 0.0; + if (!model->B3SOIwaelyGiven) + model->B3SOIwaely = 0.0; + if (!model->B3SOIwahliGiven) + model->B3SOIwahli = 0.0; + /* CV Model */ + if (!model->B3SOIwvsdfbGiven) + model->B3SOIwvsdfb = 0.0; + if (!model->B3SOIwvsdthGiven) + model->B3SOIwvsdth = 0.0; + if (!model->B3SOIwdelvtGiven) + model->B3SOIwdelvt = 0.0; + if (!model->B3SOIwacdeGiven) + model->B3SOIwacde = 0.0; + if (!model->B3SOIwmoinGiven) + model->B3SOIwmoin = 0.0; + + /* Cross-term dependence */ + if (!model->B3SOIpnigcGiven) + model->B3SOIpnigc = 0.0; + if (!model->B3SOIppigcdGiven) + model->B3SOIppigcd = 0.0; + if (!model->B3SOIppoxedgeGiven) + model->B3SOIppoxedge = 0.0; + if (!model->B3SOIpaigcGiven) + model->B3SOIpaigc = 0.0; + if (!model->B3SOIpbigcGiven) + model->B3SOIpbigc = 0.0; + if (!model->B3SOIpcigcGiven) + model->B3SOIpcigc = 0.0; + if (!model->B3SOIpaigsdGiven) + model->B3SOIpaigsd = 0.0; + if (!model->B3SOIpbigsdGiven) + model->B3SOIpbigsd = 0.0; + if (!model->B3SOIpcigsdGiven) + model->B3SOIpcigsd = 0.0; + + if (!model->B3SOIpnpeakGiven) + model->B3SOIpnpeak = 0.0; + if (!model->B3SOIpnsubGiven) + model->B3SOIpnsub = 0.0; + if (!model->B3SOIpngateGiven) + model->B3SOIpngate = 0.0; + if (!model->B3SOIpvth0Given) + model->B3SOIpvth0 = 0.0; + if (!model->B3SOIpk1Given) + model->B3SOIpk1 = 0.0; + if (!model->B3SOIpk1w1Given) + model->B3SOIpk1w1 = 0.0; + if (!model->B3SOIpk1w2Given) + model->B3SOIpk1w2 = 0.0; + if (!model->B3SOIpk2Given) + model->B3SOIpk2 = 0.0; + if (!model->B3SOIpk3Given) + model->B3SOIpk3 = 0.0; + if (!model->B3SOIpk3bGiven) + model->B3SOIpk3b = 0.0; + if (!model->B3SOIpkb1Given) + model->B3SOIpkb1 = 0.0; + if (!model->B3SOIpw0Given) + model->B3SOIpw0 = 0.0; + if (!model->B3SOIpnlxGiven) + model->B3SOIpnlx = 0.0; + if (!model->B3SOIpdvt0Given) + model->B3SOIpdvt0 = 0.0; + if (!model->B3SOIpdvt1Given) + model->B3SOIpdvt1 = 0.0; + if (!model->B3SOIpdvt2Given) + model->B3SOIpdvt2 = 0.0; + if (!model->B3SOIpdvt0wGiven) + model->B3SOIpdvt0w = 0.0; + if (!model->B3SOIpdvt1wGiven) + model->B3SOIpdvt1w = 0.0; + if (!model->B3SOIpdvt2wGiven) + model->B3SOIpdvt2w = 0.0; + if (!model->B3SOIpu0Given) + model->B3SOIpu0 = 0.0; + if (!model->B3SOIpuaGiven) + model->B3SOIpua = 0.0; + if (!model->B3SOIpubGiven) + model->B3SOIpub = 0.0; + if (!model->B3SOIpucGiven) + model->B3SOIpuc = 0.0; + if (!model->B3SOIpvsatGiven) + model->B3SOIpvsat = 0.0; + if (!model->B3SOIpa0Given) + model->B3SOIpa0 = 0.0; + if (!model->B3SOIpagsGiven) + model->B3SOIpags = 0.0; + if (!model->B3SOIpb0Given) + model->B3SOIpb0 = 0.0; + if (!model->B3SOIpb1Given) + model->B3SOIpb1 = 0.0; + if (!model->B3SOIpketaGiven) + model->B3SOIpketa = 0.0; + if (!model->B3SOIpketasGiven) + model->B3SOIpketas = 0.0; + if (!model->B3SOIpa1Given) + model->B3SOIpa1 = 0.0; + if (!model->B3SOIpa2Given) + model->B3SOIpa2 = 0.0; + if (!model->B3SOIprdswGiven) + model->B3SOIprdsw = 0.0; + if (!model->B3SOIpprwbGiven) + model->B3SOIpprwb = 0.0; + if (!model->B3SOIpprwgGiven) + model->B3SOIpprwg = 0.0; + if (!model->B3SOIpwrGiven) + model->B3SOIpwr = 0.0; + if (!model->B3SOIpnfactorGiven) + model->B3SOIpnfactor = 0.0; + if (!model->B3SOIpdwgGiven) + model->B3SOIpdwg = 0.0; + if (!model->B3SOIpdwbGiven) + model->B3SOIpdwb = 0.0; + if (!model->B3SOIpvoffGiven) + model->B3SOIpvoff = 0.0; + if (!model->B3SOIpeta0Given) + model->B3SOIpeta0 = 0.0; + if (!model->B3SOIpetabGiven) + model->B3SOIpetab = 0.0; + if (!model->B3SOIpdsubGiven) + model->B3SOIpdsub = 0.0; + if (!model->B3SOIpcitGiven) + model->B3SOIpcit = 0.0; + if (!model->B3SOIpcdscGiven) + model->B3SOIpcdsc = 0.0; + if (!model->B3SOIpcdscbGiven) + model->B3SOIpcdscb = 0.0; + if (!model->B3SOIpcdscdGiven) + model->B3SOIpcdscd = 0.0; + if (!model->B3SOIppclmGiven) + model->B3SOIppclm = 0.0; + if (!model->B3SOIppdibl1Given) + model->B3SOIppdibl1 = 0.0; + if (!model->B3SOIppdibl2Given) + model->B3SOIppdibl2 = 0.0; + if (!model->B3SOIppdiblbGiven) + model->B3SOIppdiblb = 0.0; + if (!model->B3SOIpdroutGiven) + model->B3SOIpdrout = 0.0; + if (!model->B3SOIppvagGiven) + model->B3SOIppvag = 0.0; + if (!model->B3SOIpdeltaGiven) + model->B3SOIpdelta = 0.0; + if (!model->B3SOIpalpha0Given) + model->B3SOIpalpha0 = 0.0; + if (!model->B3SOIpfbjtiiGiven) + model->B3SOIpfbjtii = 0.0; + if (!model->B3SOIpbeta0Given) + model->B3SOIpbeta0 = 0.0; + if (!model->B3SOIpbeta1Given) + model->B3SOIpbeta1 = 0.0; + if (!model->B3SOIpbeta2Given) + model->B3SOIpbeta2 = 0.0; + if (!model->B3SOIpvdsatii0Given) + model->B3SOIpvdsatii0 = 0.0; + if (!model->B3SOIpliiGiven) + model->B3SOIplii = 0.0; + if (!model->B3SOIpesatiiGiven) + model->B3SOIpesatii = 0.0; + if (!model->B3SOIpsii0Given) + model->B3SOIpsii0 = 0.0; + if (!model->B3SOIpsii1Given) + model->B3SOIpsii1 = 0.0; + if (!model->B3SOIpsii2Given) + model->B3SOIpsii2 = 0.0; + if (!model->B3SOIpsiidGiven) + model->B3SOIpsiid = 0.0; + if (!model->B3SOIpagidlGiven) + model->B3SOIpagidl = 0.0; + if (!model->B3SOIpbgidlGiven) + model->B3SOIpbgidl = 0.0; + if (!model->B3SOIpngidlGiven) + model->B3SOIpngidl = 0.0; + if (!model->B3SOIpntunGiven) + model->B3SOIpntun = 0.0; + if (!model->B3SOIpndiodeGiven) + model->B3SOIpndiode = 0.0; + if (!model->B3SOIpnrecf0Given) + model->B3SOIpnrecf0 = 0.0; + if (!model->B3SOIpnrecr0Given) + model->B3SOIpnrecr0 = 0.0; + if (!model->B3SOIpisbjtGiven) + model->B3SOIpisbjt = 0.0; + if (!model->B3SOIpisdifGiven) + model->B3SOIpisdif = 0.0; + if (!model->B3SOIpisrecGiven) + model->B3SOIpisrec = 0.0; + if (!model->B3SOIpistunGiven) + model->B3SOIpistun = 0.0; + if (!model->B3SOIpvrec0Given) + model->B3SOIpvrec0 = 0.0; + if (!model->B3SOIpvtun0Given) + model->B3SOIpvtun0 = 0.0; + if (!model->B3SOIpnbjtGiven) + model->B3SOIpnbjt = 0.0; + if (!model->B3SOIplbjt0Given) + model->B3SOIplbjt0 = 0.0; + if (!model->B3SOIpvabjtGiven) + model->B3SOIpvabjt = 0.0; + if (!model->B3SOIpaelyGiven) + model->B3SOIpaely = 0.0; + if (!model->B3SOIpahliGiven) + model->B3SOIpahli = 0.0; + /* CV Model */ + if (!model->B3SOIpvsdfbGiven) + model->B3SOIpvsdfb = 0.0; + if (!model->B3SOIpvsdthGiven) + model->B3SOIpvsdth = 0.0; + if (!model->B3SOIpdelvtGiven) + model->B3SOIpdelvt = 0.0; + if (!model->B3SOIpacdeGiven) + model->B3SOIpacde = 0.0; + if (!model->B3SOIpmoinGiven) + model->B3SOIpmoin = 0.0; +/* Added for binning - END */ + + if (!model->B3SOIcfGiven) + model->B3SOIcf = 2.0 * EPSOX / PI + * log(1.0 + 0.4e-6 / model->B3SOItox); + if (!model->B3SOIcgdoGiven) + { if (model->B3SOIdlcGiven && (model->B3SOIdlc > 0.0)) + { model->B3SOIcgdo = model->B3SOIdlc * model->B3SOIcox + - model->B3SOIcgdl ; + } + else + model->B3SOIcgdo = 0.6 * model->B3SOIxj * model->B3SOIcox; + } + if (!model->B3SOIcgsoGiven) + { if (model->B3SOIdlcGiven && (model->B3SOIdlc > 0.0)) + { model->B3SOIcgso = model->B3SOIdlc * model->B3SOIcox + - model->B3SOIcgsl ; + } + else + model->B3SOIcgso = 0.6 * model->B3SOIxj * model->B3SOIcox; + } + + if (!model->B3SOIcgeoGiven) + { model->B3SOIcgeo = 0.0; + } + if (!model->B3SOIxpartGiven) + model->B3SOIxpart = 0.0; + if (!model->B3SOIsheetResistanceGiven) + model->B3SOIsheetResistance = 0.0; + if (!model->B3SOIcsdeswGiven) + model->B3SOIcsdesw = 0.0; + if (!model->B3SOIunitLengthGateSidewallJctCapGiven) + model->B3SOIunitLengthGateSidewallJctCap = 1e-10; + if (!model->B3SOIGatesidewallJctPotentialGiven) + model->B3SOIGatesidewallJctPotential = 0.7; + if (!model->B3SOIbodyJctGateSideGradingCoeffGiven) + model->B3SOIbodyJctGateSideGradingCoeff = 0.5; + if (!model->B3SOIoxideTrapDensityAGiven) + { if (model->B3SOItype == NMOS) + model->B3SOIoxideTrapDensityA = 1e20; + else + model->B3SOIoxideTrapDensityA=9.9e18; + } + if (!model->B3SOIoxideTrapDensityBGiven) + { if (model->B3SOItype == NMOS) + model->B3SOIoxideTrapDensityB = 5e4; + else + model->B3SOIoxideTrapDensityB = 2.4e3; + } + if (!model->B3SOIoxideTrapDensityCGiven) + { if (model->B3SOItype == NMOS) + model->B3SOIoxideTrapDensityC = -1.4e-12; + else + model->B3SOIoxideTrapDensityC = 1.4e-12; + + } + if (!model->B3SOIemGiven) + model->B3SOIem = 4.1e7; /* V/m */ + if (!model->B3SOIefGiven) + model->B3SOIef = 1.0; + if (!model->B3SOIafGiven) + model->B3SOIaf = 1.0; + if (!model->B3SOIkfGiven) + model->B3SOIkf = 0.0; + if (!model->B3SOInoifGiven) + model->B3SOInoif = 1.0; + + /* loop through all the instances of the model */ + for (here = model->B3SOIinstances; here != NULL ; + here=here->B3SOInextInstance) + { + + if (here->B3SOIowner == ARCHme) + { + /* allocate a chunk of the state vector */ + here->B3SOIstates = *states; + *states += B3SOInumStates; + } + + /* perform the parameter defaulting */ + if (!here->B3SOIdrainAreaGiven) + here->B3SOIdrainArea = 0.0; + if (!here->B3SOIdrainPerimeterGiven) + here->B3SOIdrainPerimeter = 0.0; + if (!here->B3SOIdrainSquaresGiven) + here->B3SOIdrainSquares = 1.0; + if (!here->B3SOIicVBSGiven) + here->B3SOIicVBS = 0; + if (!here->B3SOIicVDSGiven) + here->B3SOIicVDS = 0; + if (!here->B3SOIicVGSGiven) + here->B3SOIicVGS = 0; + if (!here->B3SOIicVESGiven) + here->B3SOIicVES = 0; + if (!here->B3SOIicVPSGiven) + here->B3SOIicVPS = 0; + if (!here->B3SOIbjtoffGiven) + here->B3SOIbjtoff = 0; + if (!here->B3SOIdebugModGiven) + here->B3SOIdebugMod = 0; + if (!here->B3SOIrth0Given) + here->B3SOIrth0 = model->B3SOIrth0; + if (!here->B3SOIcth0Given) + here->B3SOIcth0 = model->B3SOIcth0; + if (!here->B3SOIbodySquaresGiven) + here->B3SOIbodySquares = 1.0; + if (!here->B3SOIfrbodyGiven) + here->B3SOIfrbody = 1.0; + if (!here->B3SOIlGiven) + here->B3SOIl = 5e-6; + if (!here->B3SOIsourceAreaGiven) + here->B3SOIsourceArea = 0; + if (!here->B3SOIsourcePerimeterGiven) + here->B3SOIsourcePerimeter = 0; + if (!here->B3SOIsourceSquaresGiven) + here->B3SOIsourceSquares = 1; + if (!here->B3SOIwGiven) + here->B3SOIw = 5e-6; + + if (!here->B3SOImGiven) + here->B3SOIm = 1; + + +/* v2.0 release */ + if (!here->B3SOInbcGiven) + here->B3SOInbc = 0; + if (!here->B3SOInsegGiven) + here->B3SOInseg = 1; + if (!here->B3SOIpdbcpGiven) + here->B3SOIpdbcp = 0; + if (!here->B3SOIpsbcpGiven) + here->B3SOIpsbcp = 0; + if (!here->B3SOIagbcpGiven) + here->B3SOIagbcp = 0; + if (!here->B3SOIaebcpGiven) + here->B3SOIaebcp = 0; + + if (!here->B3SOIoffGiven) + here->B3SOIoff = 0; + + /* process drain series resistance */ + if ((model->B3SOIsheetResistance > 0.0) && + (here->B3SOIdrainSquares > 0.0 ) && + (here->B3SOIdNodePrime == 0)) + { error = CKTmkVolt(ckt,&tmp,here->B3SOIname,"drain"); + if(error) return(error); + here->B3SOIdNodePrime = 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->B3SOIdNodePrime = here->B3SOIdNode; + } + + /* process source series resistance */ + if ((model->B3SOIsheetResistance > 0.0) && + (here->B3SOIsourceSquares > 0.0 ) && + (here->B3SOIsNodePrime == 0)) + { error = CKTmkVolt(ckt,&tmp,here->B3SOIname,"source"); + if(error) return(error); + here->B3SOIsNodePrime = 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->B3SOIsNodePrime = here->B3SOIsNode; + } + + /* process effective silicon film thickness */ + model->B3SOIcbox = 3.453133e-11 / model->B3SOItbox; + model->B3SOIcsi = 1.03594e-10 / model->B3SOItsi; + Cboxt = model->B3SOIcbox * model->B3SOIcsi / (model->B3SOIcbox + model->B3SOIcsi); + model->B3SOIqsi = Charge_q*model->B3SOInpeak*1e6*model->B3SOItsi; + + + here->B3SOIfloat = 0; + if (here->B3SOIpNode == -1) { /* floating body case -- 4-node */ + error = CKTmkVolt(ckt,&tmp,here->B3SOIname,"Body"); + if (error) return(error); + here->B3SOIbNode = tmp->number; + here->B3SOIpNode = 0; + here->B3SOIfloat = 1; + here->B3SOIbodyMod = 0; + } + else /* the 5th Node has been assigned */ + { + if (!here->B3SOItnodeoutGiven) { /* if t-node not assigned */ + if (here->B3SOIbNode == -1) + { /* 5-node body tie, bNode has not been assigned */ + if ((model->B3SOIrbody == 0.0) && (model->B3SOIrbsh == 0.0)) + { /* ideal body tie, pNode is not used */ + here->B3SOIbNode = here->B3SOIpNode; + here->B3SOIbodyMod = 2; + } + else { /* nonideal body tie */ + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Body"); + if (error) return(error); + here->B3SOIbNode = tmp->number; + here->B3SOIbodyMod = 1; + } + } + else { /* 6-node body tie, bNode has been assigned */ + if ((model->B3SOIrbody == 0.0) && (model->B3SOIrbsh == 0.0)) + { + printf("\n Warning: model parameter rbody=0!\n"); + model->B3SOIrbody = 1e0; + here->B3SOIbodyMod = 1; + } + else { /* nonideal body tie */ + here->B3SOIbodyMod = 1; + } + } + } + else { /* t-node assigned */ + if (here->B3SOIbNode == -1) + { /* 4 nodes & t-node, floating body */ + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Body"); + if (error) return(error); + here->B3SOIbNode = tmp->number; + here->B3SOItempNode = here->B3SOIpNode; + here->B3SOIpNode = 0; + here->B3SOIfloat = 1; + here->B3SOIbodyMod = 0; + } + else { /* 5 or 6 nodes & t-node, body-contact device */ + if (here->B3SOItempNode == -1) { /* 5 nodes & tnode */ + if ((model->B3SOIrbody == 0.0) && (model->B3SOIrbsh == 0.0)) + { /* ideal body tie, pNode is not used */ + here->B3SOItempNode = here->B3SOIbNode; + here->B3SOIbNode = here->B3SOIpNode; + here->B3SOIbodyMod = 2; + } + else { /* nonideal body tie */ + here->B3SOItempNode = here->B3SOIbNode; + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Body"); + if (error) return(error); + here->B3SOIbNode = tmp->number; + here->B3SOIbodyMod = 1; + } + } + else { /* 6 nodes & t-node */ + if ((model->B3SOIrbody == 0.0) && (model->B3SOIrbsh == 0.0)) + { + printf("\n Warning: model parameter rbody=0!\n"); + model->B3SOIrbody = 1e0; + here->B3SOIbodyMod = 1; + } + else { /* nonideal body tie */ + here->B3SOIbodyMod = 1; + } + } + } + } + } + + + if ((model->B3SOIshMod == 1) && (here->B3SOIrth0!=0)) + { + if (here->B3SOItempNode == -1) { + error = CKTmkVolt(ckt,&tmp,here->B3SOIname,"Temp"); + if (error) return(error); + here->B3SOItempNode = tmp->number; + } + + } else { + here->B3SOItempNode = 0; + } + +/* here for debugging purpose only */ + if (here->B3SOIdebugMod != 0) + { + /* The real Vbs value */ + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Vbs"); + if(error) return(error); + here->B3SOIvbsNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Ids"); + if(error) return(error); + here->B3SOIidsNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Ic"); + if(error) return(error); + here->B3SOIicNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Ibs"); + if(error) return(error); + here->B3SOIibsNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Ibd"); + if(error) return(error); + here->B3SOIibdNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Iii"); + if(error) return(error); + here->B3SOIiiiNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Ig"); + if(error) return(error); + here->B3SOIigNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Gigg"); + if(error) return(error); + here->B3SOIgiggNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Gigd"); + if(error) return(error); + here->B3SOIgigdNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Gigb"); + if(error) return(error); + here->B3SOIgigbNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Igidl"); + if(error) return(error); + here->B3SOIigidlNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Itun"); + if(error) return(error); + here->B3SOIitunNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Ibp"); + if(error) return(error); + here->B3SOIibpNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Cbb"); + if(error) return(error); + here->B3SOIcbbNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Cbd"); + if(error) return(error); + here->B3SOIcbdNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Cbg"); + if(error) return(error); + here->B3SOIcbgNode = tmp->number; + + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Qbf"); + if(error) return(error); + here->B3SOIqbfNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Qjs"); + if(error) return(error); + here->B3SOIqjsNode = tmp->number; + + error = CKTmkVolt(ckt, &tmp, here->B3SOIname, "Qjd"); + if(error) return(error); + here->B3SOIqjdNode = 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->B3SOIshMod == 1) && (here->B3SOIrth0!=0.0)) { + TSTALLOC(B3SOITemptempPtr, B3SOItempNode, B3SOItempNode) + TSTALLOC(B3SOITempdpPtr, B3SOItempNode, B3SOIdNodePrime) + TSTALLOC(B3SOITempspPtr, B3SOItempNode, B3SOIsNodePrime) + TSTALLOC(B3SOITempgPtr, B3SOItempNode, B3SOIgNode) + TSTALLOC(B3SOITempbPtr, B3SOItempNode, B3SOIbNode) + + TSTALLOC(B3SOIGtempPtr, B3SOIgNode, B3SOItempNode) + TSTALLOC(B3SOIDPtempPtr, B3SOIdNodePrime, B3SOItempNode) + TSTALLOC(B3SOISPtempPtr, B3SOIsNodePrime, B3SOItempNode) + TSTALLOC(B3SOIEtempPtr, B3SOIeNode, B3SOItempNode) + TSTALLOC(B3SOIBtempPtr, B3SOIbNode, B3SOItempNode) + + if (here->B3SOIbodyMod == 1) { + TSTALLOC(B3SOIPtempPtr, B3SOIpNode, B3SOItempNode) + } + +/* v3.0 */ + if (model->B3SOIsoiMod != 0) { + TSTALLOC(B3SOITempePtr, B3SOItempNode, B3SOIeNode) + } + + } + if (here->B3SOIbodyMod == 2) { + /* Don't create any Jacobian entry for pNode */ + } + else if (here->B3SOIbodyMod == 1) { + TSTALLOC(B3SOIBpPtr, B3SOIbNode, B3SOIpNode) + TSTALLOC(B3SOIPbPtr, B3SOIpNode, B3SOIbNode) + TSTALLOC(B3SOIPpPtr, B3SOIpNode, B3SOIpNode) + } + + TSTALLOC(B3SOIEbPtr, B3SOIeNode, B3SOIbNode) + TSTALLOC(B3SOIGbPtr, B3SOIgNode, B3SOIbNode) + TSTALLOC(B3SOIDPbPtr, B3SOIdNodePrime, B3SOIbNode) + TSTALLOC(B3SOISPbPtr, B3SOIsNodePrime, B3SOIbNode) + TSTALLOC(B3SOIBePtr, B3SOIbNode, B3SOIeNode) + TSTALLOC(B3SOIBgPtr, B3SOIbNode, B3SOIgNode) + TSTALLOC(B3SOIBdpPtr, B3SOIbNode, B3SOIdNodePrime) + TSTALLOC(B3SOIBspPtr, B3SOIbNode, B3SOIsNodePrime) + TSTALLOC(B3SOIBbPtr, B3SOIbNode, B3SOIbNode) + + TSTALLOC(B3SOIEgPtr, B3SOIeNode, B3SOIgNode) + TSTALLOC(B3SOIEdpPtr, B3SOIeNode, B3SOIdNodePrime) + TSTALLOC(B3SOIEspPtr, B3SOIeNode, B3SOIsNodePrime) + TSTALLOC(B3SOIGePtr, B3SOIgNode, B3SOIeNode) + TSTALLOC(B3SOIDPePtr, B3SOIdNodePrime, B3SOIeNode) + TSTALLOC(B3SOISPePtr, B3SOIsNodePrime, B3SOIeNode) + + TSTALLOC(B3SOIEbPtr, B3SOIeNode, B3SOIbNode) + TSTALLOC(B3SOIEePtr, B3SOIeNode, B3SOIeNode) + + TSTALLOC(B3SOIGgPtr, B3SOIgNode, B3SOIgNode) + TSTALLOC(B3SOIGdpPtr, B3SOIgNode, B3SOIdNodePrime) + TSTALLOC(B3SOIGspPtr, B3SOIgNode, B3SOIsNodePrime) + + TSTALLOC(B3SOIDPgPtr, B3SOIdNodePrime, B3SOIgNode) + TSTALLOC(B3SOIDPdpPtr, B3SOIdNodePrime, B3SOIdNodePrime) + TSTALLOC(B3SOIDPspPtr, B3SOIdNodePrime, B3SOIsNodePrime) + TSTALLOC(B3SOIDPdPtr, B3SOIdNodePrime, B3SOIdNode) + + TSTALLOC(B3SOISPgPtr, B3SOIsNodePrime, B3SOIgNode) + TSTALLOC(B3SOISPdpPtr, B3SOIsNodePrime, B3SOIdNodePrime) + TSTALLOC(B3SOISPspPtr, B3SOIsNodePrime, B3SOIsNodePrime) + TSTALLOC(B3SOISPsPtr, B3SOIsNodePrime, B3SOIsNode) + + TSTALLOC(B3SOIDdPtr, B3SOIdNode, B3SOIdNode) + TSTALLOC(B3SOIDdpPtr, B3SOIdNode, B3SOIdNodePrime) + + TSTALLOC(B3SOISsPtr, B3SOIsNode, B3SOIsNode) + TSTALLOC(B3SOISspPtr, B3SOIsNode, B3SOIsNodePrime) + +/* here for debugging purpose only */ + if (here->B3SOIdebugMod != 0) + { + TSTALLOC(B3SOIVbsPtr, B3SOIvbsNode, B3SOIvbsNode) + TSTALLOC(B3SOIIdsPtr, B3SOIidsNode, B3SOIidsNode) + TSTALLOC(B3SOIIcPtr, B3SOIicNode, B3SOIicNode) + TSTALLOC(B3SOIIbsPtr, B3SOIibsNode, B3SOIibsNode) + TSTALLOC(B3SOIIbdPtr, B3SOIibdNode, B3SOIibdNode) + TSTALLOC(B3SOIIiiPtr, B3SOIiiiNode, B3SOIiiiNode) + TSTALLOC(B3SOIIgPtr, B3SOIigNode, B3SOIigNode) + TSTALLOC(B3SOIGiggPtr, B3SOIgiggNode, B3SOIgiggNode) + TSTALLOC(B3SOIGigdPtr, B3SOIgigdNode, B3SOIgigdNode) + TSTALLOC(B3SOIGigbPtr, B3SOIgigbNode, B3SOIgigbNode) + TSTALLOC(B3SOIIgidlPtr, B3SOIigidlNode, B3SOIigidlNode) + TSTALLOC(B3SOIItunPtr, B3SOIitunNode, B3SOIitunNode) + TSTALLOC(B3SOIIbpPtr, B3SOIibpNode, B3SOIibpNode) + TSTALLOC(B3SOICbbPtr, B3SOIcbbNode, B3SOIcbbNode) + TSTALLOC(B3SOICbdPtr, B3SOIcbdNode, B3SOIcbdNode) + TSTALLOC(B3SOICbgPtr, B3SOIcbgNode, B3SOIcbgNode) + TSTALLOC(B3SOIQbfPtr, B3SOIqbfNode, B3SOIqbfNode) + TSTALLOC(B3SOIQjsPtr, B3SOIqjsNode, B3SOIqjsNode) + TSTALLOC(B3SOIQjdPtr, B3SOIqjdNode, B3SOIqjdNode) + + } + + } + } + return(OK); +} + +int +B3SOIunsetup(GENmodel *inModel, CKTcircuit *ckt) +{ + B3SOImodel *model; + B3SOIinstance *here; + + for (model = (B3SOImodel *)inModel; model != NULL; + model = model->B3SOInextModel) + { + for (here = model->B3SOIinstances; here != NULL; + here=here->B3SOInextInstance) + { + if (here->B3SOIdNodePrime + && here->B3SOIdNodePrime != here->B3SOIdNode) + { + CKTdltNNum(ckt, here->B3SOIdNodePrime); + here->B3SOIdNodePrime = 0; + } + if (here->B3SOIsNodePrime + && here->B3SOIsNodePrime != here->B3SOIsNode) + { + CKTdltNNum(ckt, here->B3SOIsNodePrime); + here->B3SOIsNodePrime = 0; + } + } + } + return OK; +} + diff --git a/src/spicelib/devices/bsim3soi/b3soitemp.c b/src/spicelib/devices/bsim3soi/b3soitemp.c new file mode 100644 index 000000000..2554c2e5c --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soitemp.c @@ -0,0 +1,1076 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soitemp.c 98/5/01 +Modified by Pin Su 99/2/15 +Modified by Pin Su 99/4/30 +Modified by Pin Su, Wei Jin 99/9/27 +Modified by Pin Su 00/3/1 +Modified by Pin Su 01/2/15 +Modified by Pin Su and Hui Wan 02/3/5 +Modified by Pin Su 02/5/20 +Modified by Paolo Nenzi 2002 +**********/ + +/* Lmin, Lmax, Wmin, Wmax */ + +#include "ngspice.h" +#include "smpdefs.h" +#include "cktdefs.h" +#include "b3soidef.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 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 +B3SOItemp(GENmodel *inModel, CKTcircuit *ckt) +{ +B3SOImodel *model = (B3SOImodel*) inModel; +B3SOIinstance *here; +struct b3soiSizeDependParam *pSizeDependParamKnot, *pLastKnot, *pParam; +double tmp, tmp1, tmp2, Eg, Eg0, ni, T0, T1, T2, T3, T4, T5, T6, Ldrn, Wdrn; +double Temp, TempRatio, Inv_L, Inv_W, Inv_LW, Dw, Dl, Vtm0, Tnom; +double SDphi, SDgamma; +int Size_Not_Found; + +/* v2.0 release */ +double tmp3, T7, T8, T9; + + + /* loop through all the B3SOI device models */ + for (; model != NULL; model = model->B3SOInextModel) + { Temp = ckt->CKTtemp; + if (model->B3SOIGatesidewallJctPotential < 0.1) + model->B3SOIGatesidewallJctPotential = 0.1; + model->pSizeDependParamKnot = NULL; + pLastKnot = NULL; + + Tnom = model->B3SOItnom; + TempRatio = Temp / Tnom; + + model->B3SOIvcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14)); + model->B3SOIfactor1 = sqrt(EPSSI / EPSOX * model->B3SOItox); + + Vtm0 = KboQ * Tnom; + Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0); + model->B3SOIeg0 = Eg0; + model->B3SOIvtm = 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->B3SOIvtm)); + + + /* loop through all the instances of the model */ + /* MCJ: Length and Width not initialized */ + for (here = model->B3SOIinstances; here != NULL; + here = here->B3SOInextInstance) + { + + if (here->B3SOIowner != ARCHme) + continue; + + here->B3SOIrbodyext = here->B3SOIbodySquares * + model->B3SOIrbsh; + pSizeDependParamKnot = model->pSizeDependParamKnot; + Size_Not_Found = 1; + while ((pSizeDependParamKnot != NULL) && Size_Not_Found) + { if ((here->B3SOIl == pSizeDependParamKnot->Length) + && (here->B3SOIw == pSizeDependParamKnot->Width) + && (here->B3SOIrth0 == pSizeDependParamKnot->Rth0) + && (here->B3SOIcth0 == pSizeDependParamKnot->Cth0)) + { 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 b3soiSizeDependParam *)tmalloc( + sizeof(struct b3soiSizeDependParam)); + if (pLastKnot == NULL) + model->pSizeDependParamKnot = pParam; + else + pLastKnot->pNext = pParam; + pParam->pNext = NULL; + here->pParam = pParam; + + Ldrn = here->B3SOIl; + Wdrn = here->B3SOIw; + pParam->Length = Ldrn; + pParam->Width = Wdrn; + pParam->Rth0 = here->B3SOIrth0; + pParam->Cth0 = here->B3SOIcth0; + + T0 = pow(Ldrn, model->B3SOILln); + T1 = pow(Wdrn, model->B3SOILwn); + tmp1 = model->B3SOILl / T0 + model->B3SOILw / T1 + + model->B3SOILwl / (T0 * T1); + pParam->B3SOIdl = model->B3SOILint + tmp1; + +/* v2.2.3 */ + tmp1 = model->B3SOILlc / T0 + model->B3SOILwc / T1 + + model->B3SOILwlc / (T0 * T1); + pParam->B3SOIdlc = model->B3SOIdlc + tmp1; + +/* v3.0 */ + pParam->B3SOIdlcig = model->B3SOIdlcig + tmp1; + + + T2 = pow(Ldrn, model->B3SOIWln); + T3 = pow(Wdrn, model->B3SOIWwn); + tmp2 = model->B3SOIWl / T2 + model->B3SOIWw / T3 + + model->B3SOIWwl / (T2 * T3); + pParam->B3SOIdw = model->B3SOIWint + tmp2; + +/* v2.2.3 */ + tmp2 = model->B3SOIWlc / T2 + model->B3SOIWwc / T3 + + model->B3SOIWwlc / (T2 * T3); + pParam->B3SOIdwc = model->B3SOIdwc + tmp2; + + + pParam->B3SOIleff = here->B3SOIl - 2.0 * pParam->B3SOIdl; + if (pParam->B3SOIleff <= 0.0) + { IFuid namarray[2]; + namarray[0] = model->B3SOImodName; + namarray[1] = here->B3SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B3SOI: mosfet %s, model %s: Effective channel length <= 0", + namarray); + return(E_BADPARM); + } + + pParam->B3SOIweff = here->B3SOIw - here->B3SOInbc * model->B3SOIdwbc + - (2.0 - here->B3SOInbc) * pParam->B3SOIdw; + if (pParam->B3SOIweff <= 0.0) + { IFuid namarray[2]; + namarray[0] = model->B3SOImodName; + namarray[1] = here->B3SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B3SOI: mosfet %s, model %s: Effective channel width <= 0", + namarray); + return(E_BADPARM); + } + + pParam->B3SOIwdiod = pParam->B3SOIweff / here->B3SOInseg + here->B3SOIpdbcp; + pParam->B3SOIwdios = pParam->B3SOIweff / here->B3SOInseg + here->B3SOIpsbcp; + + pParam->B3SOIleffCV = here->B3SOIl - 2.0 * pParam->B3SOIdlc; + if (pParam->B3SOIleffCV <= 0.0) + { IFuid namarray[2]; + namarray[0] = model->B3SOImodName; + namarray[1] = here->B3SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B3SOI: mosfet %s, model %s: Effective channel length for C-V <= 0", + namarray); + return(E_BADPARM); + } + + pParam->B3SOIweffCV = here->B3SOIw - here->B3SOInbc * model->B3SOIdwbc + - (2.0 - here->B3SOInbc) * pParam->B3SOIdwc; + if (pParam->B3SOIweffCV <= 0.0) + { IFuid namarray[2]; + namarray[0] = model->B3SOImodName; + namarray[1] = here->B3SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B3SOI: mosfet %s, model %s: Effective channel width for C-V <= 0", + namarray); + return(E_BADPARM); + } + + pParam->B3SOIwdiodCV = pParam->B3SOIweffCV / here->B3SOInseg + here->B3SOIpdbcp; + pParam->B3SOIwdiosCV = pParam->B3SOIweffCV / here->B3SOInseg + here->B3SOIpsbcp; + + pParam->B3SOIleffCVb = here->B3SOIl - 2.0 * pParam->B3SOIdlc - model->B3SOIdlcb; + if (pParam->B3SOIleffCVb <= 0.0) + { + IFuid namarray[2]; + namarray[0] = model->B3SOImodName; + namarray[1] = here->B3SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B3SOI: mosfet %s, model %s: Effective channel length for C-V (body) <= 0", + namarray); + return(E_BADPARM); + } + + pParam->B3SOIleffCVbg = pParam->B3SOIleffCVb + 2 * model->B3SOIdlbg; + if (pParam->B3SOIleffCVbg <= 0.0) + { + IFuid namarray[2]; + namarray[0] = model->B3SOImodName; + namarray[1] = here->B3SOIname; + (*(SPfrontEnd->IFerror))(ERR_FATAL, + "B3SOI: mosfet %s, model %s: Effective channel length for C-V (backgate) <= 0", + namarray); + return(E_BADPARM); + } + + /* Not binned - START */ + pParam->B3SOIat = model->B3SOIat; + pParam->B3SOIgamma1 = model->B3SOIgamma1; + pParam->B3SOIgamma2 = model->B3SOIgamma2; + pParam->B3SOIvbx = model->B3SOIvbx; + pParam->B3SOIvbm = model->B3SOIvbm; + pParam->B3SOIxt = model->B3SOIxt; + pParam->B3SOIkt1 = model->B3SOIkt1; + pParam->B3SOIkt1l = model->B3SOIkt1l; + pParam->B3SOIkt2 = model->B3SOIkt2; + pParam->B3SOIua1 = model->B3SOIua1; + pParam->B3SOIub1 = model->B3SOIub1; + pParam->B3SOIuc1 = model->B3SOIuc1; + pParam->B3SOIute = model->B3SOIute; + pParam->B3SOIprt = model->B3SOIprt; + /* Not binned - END */ + + /* CV model */ + pParam->B3SOIcgsl = model->B3SOIcgsl; + pParam->B3SOIcgdl = model->B3SOIcgdl; + pParam->B3SOIckappa = model->B3SOIckappa; + pParam->B3SOIcf = model->B3SOIcf; + pParam->B3SOIclc = model->B3SOIclc; + pParam->B3SOIcle = model->B3SOIcle; + + pParam->B3SOIabulkCVfactor = 1.0 + pow((pParam->B3SOIclc / pParam->B3SOIleff), + pParam->B3SOIcle); + + /* Added for binning - START */ + if (model->B3SOIbinUnit == 1) + { Inv_L = 1.0e-6 / pParam->B3SOIleff; + Inv_W = 1.0e-6 / pParam->B3SOIweff; + Inv_LW = 1.0e-12 / (pParam->B3SOIleff + * pParam->B3SOIweff); + } + else + { Inv_L = 1.0 / pParam->B3SOIleff; + Inv_W = 1.0 / pParam->B3SOIweff; + Inv_LW = 1.0 / (pParam->B3SOIleff + * pParam->B3SOIweff); + } + pParam->B3SOInpeak = model->B3SOInpeak + + model->B3SOIlnpeak * Inv_L + + model->B3SOIwnpeak * Inv_W + + model->B3SOIpnpeak * Inv_LW; + pParam->B3SOInsub = model->B3SOInsub + + model->B3SOIlnsub * Inv_L + + model->B3SOIwnsub * Inv_W + + model->B3SOIpnsub * Inv_LW; + pParam->B3SOIngate = model->B3SOIngate + + model->B3SOIlngate * Inv_L + + model->B3SOIwngate * Inv_W + + model->B3SOIpngate * Inv_LW; + pParam->B3SOIvth0 = model->B3SOIvth0 + + model->B3SOIlvth0 * Inv_L + + model->B3SOIwvth0 * Inv_W + + model->B3SOIpvth0 * Inv_LW; + pParam->B3SOIk1 = model->B3SOIk1 + + model->B3SOIlk1 * Inv_L + + model->B3SOIwk1 * Inv_W + + model->B3SOIpk1 * Inv_LW; + pParam->B3SOIk2 = model->B3SOIk2 + + model->B3SOIlk2 * Inv_L + + model->B3SOIwk2 * Inv_W + + model->B3SOIpk2 * Inv_LW; + pParam->B3SOIk1w1 = model->B3SOIk1w1 + + model->B3SOIlk1w1 * Inv_L + + model->B3SOIwk1w1 * Inv_W + + model->B3SOIpk1w1 * Inv_LW; + pParam->B3SOIk1w2 = model->B3SOIk1w2 + + model->B3SOIlk1w2 * Inv_L + + model->B3SOIwk1w2 * Inv_W + + model->B3SOIpk1w2 * Inv_LW; + pParam->B3SOIk3 = model->B3SOIk3 + + model->B3SOIlk3 * Inv_L + + model->B3SOIwk3 * Inv_W + + model->B3SOIpk3 * Inv_LW; + pParam->B3SOIk3b = model->B3SOIk3b + + model->B3SOIlk3b * Inv_L + + model->B3SOIwk3b * Inv_W + + model->B3SOIpk3b * Inv_LW; + pParam->B3SOIkb1 = model->B3SOIkb1 + + model->B3SOIlkb1 * Inv_L + + model->B3SOIwkb1 * Inv_W + + model->B3SOIpkb1 * Inv_LW; + pParam->B3SOIw0 = model->B3SOIw0 + + model->B3SOIlw0 * Inv_L + + model->B3SOIww0 * Inv_W + + model->B3SOIpw0 * Inv_LW; + pParam->B3SOInlx = model->B3SOInlx + + model->B3SOIlnlx * Inv_L + + model->B3SOIwnlx * Inv_W + + model->B3SOIpnlx * Inv_LW; + pParam->B3SOIdvt0 = model->B3SOIdvt0 + + model->B3SOIldvt0 * Inv_L + + model->B3SOIwdvt0 * Inv_W + + model->B3SOIpdvt0 * Inv_LW; + pParam->B3SOIdvt1 = model->B3SOIdvt1 + + model->B3SOIldvt1 * Inv_L + + model->B3SOIwdvt1 * Inv_W + + model->B3SOIpdvt1 * Inv_LW; + pParam->B3SOIdvt2 = model->B3SOIdvt2 + + model->B3SOIldvt2 * Inv_L + + model->B3SOIwdvt2 * Inv_W + + model->B3SOIpdvt2 * Inv_LW; + pParam->B3SOIdvt0w = model->B3SOIdvt0w + + model->B3SOIldvt0w * Inv_L + + model->B3SOIwdvt0w * Inv_W + + model->B3SOIpdvt0w * Inv_LW; + pParam->B3SOIdvt1w = model->B3SOIdvt1w + + model->B3SOIldvt1w * Inv_L + + model->B3SOIwdvt1w * Inv_W + + model->B3SOIpdvt1w * Inv_LW; + pParam->B3SOIdvt2w = model->B3SOIdvt2w + + model->B3SOIldvt2w * Inv_L + + model->B3SOIwdvt2w * Inv_W + + model->B3SOIpdvt2w * Inv_LW; + pParam->B3SOIu0 = model->B3SOIu0 + + model->B3SOIlu0 * Inv_L + + model->B3SOIwu0 * Inv_W + + model->B3SOIpu0 * Inv_LW; + pParam->B3SOIua = model->B3SOIua + + model->B3SOIlua * Inv_L + + model->B3SOIwua * Inv_W + + model->B3SOIpua * Inv_LW; + pParam->B3SOIub = model->B3SOIub + + model->B3SOIlub * Inv_L + + model->B3SOIwub * Inv_W + + model->B3SOIpub * Inv_LW; + pParam->B3SOIuc = model->B3SOIuc + + model->B3SOIluc * Inv_L + + model->B3SOIwuc * Inv_W + + model->B3SOIpuc * Inv_LW; + pParam->B3SOIvsat = model->B3SOIvsat + + model->B3SOIlvsat * Inv_L + + model->B3SOIwvsat * Inv_W + + model->B3SOIpvsat * Inv_LW; + pParam->B3SOIa0 = model->B3SOIa0 + + model->B3SOIla0 * Inv_L + + model->B3SOIwa0 * Inv_W + + model->B3SOIpa0 * Inv_LW; + pParam->B3SOIags = model->B3SOIags + + model->B3SOIlags * Inv_L + + model->B3SOIwags * Inv_W + + model->B3SOIpags * Inv_LW; + pParam->B3SOIb0 = model->B3SOIb0 + + model->B3SOIlb0 * Inv_L + + model->B3SOIwb0 * Inv_W + + model->B3SOIpb0 * Inv_LW; + pParam->B3SOIb1 = model->B3SOIb1 + + model->B3SOIlb1 * Inv_L + + model->B3SOIwb1 * Inv_W + + model->B3SOIpb1 * Inv_LW; + pParam->B3SOIketa = model->B3SOIketa + + model->B3SOIlketa * Inv_L + + model->B3SOIwketa * Inv_W + + model->B3SOIpketa * Inv_LW; + pParam->B3SOIketas = model->B3SOIketas + + model->B3SOIlketas * Inv_L + + model->B3SOIwketas * Inv_W + + model->B3SOIpketas * Inv_LW; + pParam->B3SOIa1 = model->B3SOIa1 + + model->B3SOIla1 * Inv_L + + model->B3SOIwa1 * Inv_W + + model->B3SOIpa1 * Inv_LW; + pParam->B3SOIa2 = model->B3SOIa2 + + model->B3SOIla2 * Inv_L + + model->B3SOIwa2 * Inv_W + + model->B3SOIpa2 * Inv_LW; + pParam->B3SOIrdsw = model->B3SOIrdsw + + model->B3SOIlrdsw * Inv_L + + model->B3SOIwrdsw * Inv_W + + model->B3SOIprdsw * Inv_LW; + pParam->B3SOIprwb = model->B3SOIprwb + + model->B3SOIlprwb * Inv_L + + model->B3SOIwprwb * Inv_W + + model->B3SOIpprwb * Inv_LW; + pParam->B3SOIprwg = model->B3SOIprwg + + model->B3SOIlprwg * Inv_L + + model->B3SOIwprwg * Inv_W + + model->B3SOIpprwg * Inv_LW; + pParam->B3SOIwr = model->B3SOIwr + + model->B3SOIlwr * Inv_L + + model->B3SOIwwr * Inv_W + + model->B3SOIpwr * Inv_LW; + pParam->B3SOInfactor = model->B3SOInfactor + + model->B3SOIlnfactor * Inv_L + + model->B3SOIwnfactor * Inv_W + + model->B3SOIpnfactor * Inv_LW; + pParam->B3SOIdwg = model->B3SOIdwg + + model->B3SOIldwg * Inv_L + + model->B3SOIwdwg * Inv_W + + model->B3SOIpdwg * Inv_LW; + pParam->B3SOIdwb = model->B3SOIdwb + + model->B3SOIldwb * Inv_L + + model->B3SOIwdwb * Inv_W + + model->B3SOIpdwb * Inv_LW; + pParam->B3SOIvoff = model->B3SOIvoff + + model->B3SOIlvoff * Inv_L + + model->B3SOIwvoff * Inv_W + + model->B3SOIpvoff * Inv_LW; + pParam->B3SOIeta0 = model->B3SOIeta0 + + model->B3SOIleta0 * Inv_L + + model->B3SOIweta0 * Inv_W + + model->B3SOIpeta0 * Inv_LW; + pParam->B3SOIetab = model->B3SOIetab + + model->B3SOIletab * Inv_L + + model->B3SOIwetab * Inv_W + + model->B3SOIpetab * Inv_LW; + pParam->B3SOIdsub = model->B3SOIdsub + + model->B3SOIldsub * Inv_L + + model->B3SOIwdsub * Inv_W + + model->B3SOIpdsub * Inv_LW; + pParam->B3SOIcit = model->B3SOIcit + + model->B3SOIlcit * Inv_L + + model->B3SOIwcit * Inv_W + + model->B3SOIpcit * Inv_LW; + pParam->B3SOIcdsc = model->B3SOIcdsc + + model->B3SOIlcdsc * Inv_L + + model->B3SOIwcdsc * Inv_W + + model->B3SOIpcdsc * Inv_LW; + pParam->B3SOIcdscb = model->B3SOIcdscb + + model->B3SOIlcdscb * Inv_L + + model->B3SOIwcdscb * Inv_W + + model->B3SOIpcdscb * Inv_LW; + pParam->B3SOIcdscd = model->B3SOIcdscd + + model->B3SOIlcdscd * Inv_L + + model->B3SOIwcdscd * Inv_W + + model->B3SOIpcdscd * Inv_LW; + pParam->B3SOIpclm = model->B3SOIpclm + + model->B3SOIlpclm * Inv_L + + model->B3SOIwpclm * Inv_W + + model->B3SOIppclm * Inv_LW; + pParam->B3SOIpdibl1 = model->B3SOIpdibl1 + + model->B3SOIlpdibl1 * Inv_L + + model->B3SOIwpdibl1 * Inv_W + + model->B3SOIppdibl1 * Inv_LW; + pParam->B3SOIpdibl2 = model->B3SOIpdibl2 + + model->B3SOIlpdibl2 * Inv_L + + model->B3SOIwpdibl2 * Inv_W + + model->B3SOIppdibl2 * Inv_LW; + pParam->B3SOIpdiblb = model->B3SOIpdiblb + + model->B3SOIlpdiblb * Inv_L + + model->B3SOIwpdiblb * Inv_W + + model->B3SOIppdiblb * Inv_LW; + pParam->B3SOIdrout = model->B3SOIdrout + + model->B3SOIldrout * Inv_L + + model->B3SOIwdrout * Inv_W + + model->B3SOIpdrout * Inv_LW; + pParam->B3SOIpvag = model->B3SOIpvag + + model->B3SOIlpvag * Inv_L + + model->B3SOIwpvag * Inv_W + + model->B3SOIppvag * Inv_LW; + pParam->B3SOIdelta = model->B3SOIdelta + + model->B3SOIldelta * Inv_L + + model->B3SOIwdelta * Inv_W + + model->B3SOIpdelta * Inv_LW; + pParam->B3SOIalpha0 = model->B3SOIalpha0 + + model->B3SOIlalpha0 * Inv_L + + model->B3SOIwalpha0 * Inv_W + + model->B3SOIpalpha0 * Inv_LW; + pParam->B3SOIfbjtii = model->B3SOIfbjtii + + model->B3SOIlfbjtii * Inv_L + + model->B3SOIwfbjtii * Inv_W + + model->B3SOIpfbjtii * Inv_LW; + pParam->B3SOIbeta0 = model->B3SOIbeta0 + + model->B3SOIlbeta0 * Inv_L + + model->B3SOIwbeta0 * Inv_W + + model->B3SOIpbeta0 * Inv_LW; + pParam->B3SOIbeta1 = model->B3SOIbeta1 + + model->B3SOIlbeta1 * Inv_L + + model->B3SOIwbeta1 * Inv_W + + model->B3SOIpbeta1 * Inv_LW; + pParam->B3SOIbeta2 = model->B3SOIbeta2 + + model->B3SOIlbeta2 * Inv_L + + model->B3SOIwbeta2 * Inv_W + + model->B3SOIpbeta2 * Inv_LW; + pParam->B3SOIvdsatii0 = model->B3SOIvdsatii0 + + model->B3SOIlvdsatii0 * Inv_L + + model->B3SOIwvdsatii0 * Inv_W + + model->B3SOIpvdsatii0 * Inv_LW; + pParam->B3SOIlii = model->B3SOIlii + + model->B3SOIllii * Inv_L + + model->B3SOIwlii * Inv_W + + model->B3SOIplii * Inv_LW; + pParam->B3SOIesatii = model->B3SOIesatii + + model->B3SOIlesatii * Inv_L + + model->B3SOIwesatii * Inv_W + + model->B3SOIpesatii * Inv_LW; + pParam->B3SOIsii0 = model->B3SOIsii0 + + model->B3SOIlsii0 * Inv_L + + model->B3SOIwsii0 * Inv_W + + model->B3SOIpsii0 * Inv_LW; + pParam->B3SOIsii1 = model->B3SOIsii1 + + model->B3SOIlsii1 * Inv_L + + model->B3SOIwsii1 * Inv_W + + model->B3SOIpsii1 * Inv_LW; + pParam->B3SOIsii2 = model->B3SOIsii2 + + model->B3SOIlsii2 * Inv_L + + model->B3SOIwsii2 * Inv_W + + model->B3SOIpsii2 * Inv_LW; + pParam->B3SOIsiid = model->B3SOIsiid + + model->B3SOIlsiid * Inv_L + + model->B3SOIwsiid * Inv_W + + model->B3SOIpsiid * Inv_LW; + pParam->B3SOIagidl = model->B3SOIagidl + + model->B3SOIlagidl * Inv_L + + model->B3SOIwagidl * Inv_W + + model->B3SOIpagidl * Inv_LW; + pParam->B3SOIbgidl = model->B3SOIbgidl + + model->B3SOIlbgidl * Inv_L + + model->B3SOIwbgidl * Inv_W + + model->B3SOIpbgidl * Inv_LW; + pParam->B3SOIngidl = model->B3SOIngidl + + model->B3SOIlngidl * Inv_L + + model->B3SOIwngidl * Inv_W + + model->B3SOIpngidl * Inv_LW; + pParam->B3SOIntun = model->B3SOIntun + + model->B3SOIlntun * Inv_L + + model->B3SOIwntun * Inv_W + + model->B3SOIpntun * Inv_LW; + pParam->B3SOIndiode = model->B3SOIndiode + + model->B3SOIlndiode * Inv_L + + model->B3SOIwndiode * Inv_W + + model->B3SOIpndiode * Inv_LW; + pParam->B3SOInrecf0 = model->B3SOInrecf0 + + model->B3SOIlnrecf0 * Inv_L + + model->B3SOIwnrecf0 * Inv_W + + model->B3SOIpnrecf0 * Inv_LW; + pParam->B3SOInrecr0 = model->B3SOInrecr0 + + model->B3SOIlnrecr0 * Inv_L + + model->B3SOIwnrecr0 * Inv_W + + model->B3SOIpnrecr0 * Inv_LW; + pParam->B3SOIisbjt = model->B3SOIisbjt + + model->B3SOIlisbjt * Inv_L + + model->B3SOIwisbjt * Inv_W + + model->B3SOIpisbjt * Inv_LW; + pParam->B3SOIisdif = model->B3SOIisdif + + model->B3SOIlisdif * Inv_L + + model->B3SOIwisdif * Inv_W + + model->B3SOIpisdif * Inv_LW; + pParam->B3SOIisrec = model->B3SOIisrec + + model->B3SOIlisrec * Inv_L + + model->B3SOIwisrec * Inv_W + + model->B3SOIpisrec * Inv_LW; + pParam->B3SOIistun = model->B3SOIistun + + model->B3SOIlistun * Inv_L + + model->B3SOIwistun * Inv_W + + model->B3SOIpistun * Inv_LW; + pParam->B3SOIvrec0 = model->B3SOIvrec0 + + model->B3SOIlvrec0 * Inv_L + + model->B3SOIwvrec0 * Inv_W + + model->B3SOIpvrec0 * Inv_LW; + pParam->B3SOIvtun0 = model->B3SOIvtun0 + + model->B3SOIlvtun0 * Inv_L + + model->B3SOIwvtun0 * Inv_W + + model->B3SOIpvtun0 * Inv_LW; + pParam->B3SOInbjt = model->B3SOInbjt + + model->B3SOIlnbjt * Inv_L + + model->B3SOIwnbjt * Inv_W + + model->B3SOIpnbjt * Inv_LW; + pParam->B3SOIlbjt0 = model->B3SOIlbjt0 + + model->B3SOIllbjt0 * Inv_L + + model->B3SOIwlbjt0 * Inv_W + + model->B3SOIplbjt0 * Inv_LW; + pParam->B3SOIvabjt = model->B3SOIvabjt + + model->B3SOIlvabjt * Inv_L + + model->B3SOIwvabjt * Inv_W + + model->B3SOIpvabjt * Inv_LW; + pParam->B3SOIaely = model->B3SOIaely + + model->B3SOIlaely * Inv_L + + model->B3SOIwaely * Inv_W + + model->B3SOIpaely * Inv_LW; + pParam->B3SOIahli = model->B3SOIahli + + model->B3SOIlahli * Inv_L + + model->B3SOIwahli * Inv_W + + model->B3SOIpahli * Inv_LW; + +/* v3.0 */ + pParam->B3SOInigc = model->B3SOInigc + + model->B3SOIlnigc * Inv_L + + model->B3SOIwnigc * Inv_W + + model->B3SOIpnigc * Inv_LW; + pParam->B3SOIaigc = model->B3SOIaigc + + model->B3SOIlaigc * Inv_L + + model->B3SOIwaigc * Inv_W + + model->B3SOIpaigc * Inv_LW; + pParam->B3SOIbigc = model->B3SOIbigc + + model->B3SOIlbigc * Inv_L + + model->B3SOIwbigc * Inv_W + + model->B3SOIpbigc * Inv_LW; + pParam->B3SOIcigc = model->B3SOIcigc + + model->B3SOIlcigc * Inv_L + + model->B3SOIwcigc * Inv_W + + model->B3SOIpcigc * Inv_LW; + pParam->B3SOIaigsd = model->B3SOIaigsd + + model->B3SOIlaigsd * Inv_L + + model->B3SOIwaigsd * Inv_W + + model->B3SOIpaigsd * Inv_LW; + pParam->B3SOIbigsd = model->B3SOIbigsd + + model->B3SOIlbigsd * Inv_L + + model->B3SOIwbigsd * Inv_W + + model->B3SOIpbigsd * Inv_LW; + pParam->B3SOIcigsd = model->B3SOIcigsd + + model->B3SOIlcigsd * Inv_L + + model->B3SOIwcigsd * Inv_W + + model->B3SOIpcigsd * Inv_LW; + pParam->B3SOIpigcd = model->B3SOIpigcd + + model->B3SOIlpigcd * Inv_L + + model->B3SOIwpigcd * Inv_W + + model->B3SOIppigcd * Inv_LW; + pParam->B3SOIpoxedge = model->B3SOIpoxedge + + model->B3SOIlpoxedge * Inv_L + + model->B3SOIwpoxedge * Inv_W + + model->B3SOIppoxedge * Inv_LW; +/* v3.0 */ + + + /* CV model */ + pParam->B3SOIvsdfb = model->B3SOIvsdfb + + model->B3SOIlvsdfb * Inv_L + + model->B3SOIwvsdfb * Inv_W + + model->B3SOIpvsdfb * Inv_LW; + pParam->B3SOIvsdth = model->B3SOIvsdth + + model->B3SOIlvsdth * Inv_L + + model->B3SOIwvsdth * Inv_W + + model->B3SOIpvsdth * Inv_LW; + pParam->B3SOIdelvt = model->B3SOIdelvt + + model->B3SOIldelvt * Inv_L + + model->B3SOIwdelvt * Inv_W + + model->B3SOIpdelvt * Inv_LW; + pParam->B3SOIacde = model->B3SOIacde + + model->B3SOIlacde * Inv_L + + model->B3SOIwacde * Inv_W + + model->B3SOIpacde * Inv_LW; + pParam->B3SOImoin = model->B3SOImoin + + model->B3SOIlmoin * Inv_L + + model->B3SOIwmoin * Inv_W + + model->B3SOIpmoin * Inv_LW; + /* Added for binning - END */ + + T0 = (TempRatio - 1.0); + + pParam->B3SOIuatemp = pParam->B3SOIua; /* save ua, ub, and uc for b3soild.c */ + pParam->B3SOIubtemp = pParam->B3SOIub; + pParam->B3SOIuctemp = pParam->B3SOIuc; + pParam->B3SOIrds0denom = pow(pParam->B3SOIweff * 1E6, pParam->B3SOIwr); + + +/* v2.2 release */ + pParam->B3SOIrth = here->B3SOIrth0 / (pParam->B3SOIweff + model->B3SOIwth0) + * here->B3SOInseg; + pParam->B3SOIcth = here->B3SOIcth0 * (pParam->B3SOIweff + model->B3SOIwth0) + / here->B3SOInseg; + +/* v2.2.2 adding layout-dependent Frbody multiplier */ + pParam->B3SOIrbody = here->B3SOIfrbody *model->B3SOIrbody * model->B3SOIrhalo + / (2 * model->B3SOIrbody + model->B3SOIrhalo * pParam->B3SOIleff) + * pParam->B3SOIweff / here->B3SOInseg; + + pParam->B3SOIoxideRatio = pow(model->B3SOItoxref/model->B3SOItoxqm, + model->B3SOIntox) /model->B3SOItoxqm/model->B3SOItoxqm; +/* v2.2 release */ + + + pParam->B3SOIua = pParam->B3SOIua + pParam->B3SOIua1 * T0; + pParam->B3SOIub = pParam->B3SOIub + pParam->B3SOIub1 * T0; + pParam->B3SOIuc = pParam->B3SOIuc + pParam->B3SOIuc1 * T0; + if (pParam->B3SOIu0 > 1.0) + pParam->B3SOIu0 = pParam->B3SOIu0 / 1.0e4; + + pParam->B3SOIu0temp = pParam->B3SOIu0 + * pow(TempRatio, pParam->B3SOIute); + pParam->B3SOIvsattemp = pParam->B3SOIvsat - pParam->B3SOIat + * T0; + pParam->B3SOIrds0 = (pParam->B3SOIrdsw + pParam->B3SOIprt * T0) + / pow(pParam->B3SOIweff * 1E6, pParam->B3SOIwr); + + if (B3SOIcheckModel(model, here, ckt)) + { IFuid namarray[2]; + namarray[0] = model->B3SOImodName; + namarray[1] = here->B3SOIname; + (*(SPfrontEnd->IFerror)) (ERR_FATAL, "Fatal error(s) detected during B3SOIV3 parameter checking for %s in model %s", namarray); + return(E_BADPARM); + } + + + pParam->B3SOIcgdo = (model->B3SOIcgdo + pParam->B3SOIcf) + * pParam->B3SOIwdiodCV; + pParam->B3SOIcgso = (model->B3SOIcgso + pParam->B3SOIcf) + * pParam->B3SOIwdiosCV; + + pParam->B3SOIcgeo = model->B3SOIcgeo + * pParam->B3SOIleffCV; + + + if (!model->B3SOInpeakGiven && model->B3SOIgamma1Given) + { T0 = pParam->B3SOIgamma1 * model->B3SOIcox; + pParam->B3SOInpeak = 3.021E22 * T0 * T0; + } + + + T4 = Eg300 / model->B3SOIvtm * (TempRatio - 1.0); + T7 = model->B3SOIxbjt * T4 / pParam->B3SOIndiode; + DEXP(T7, T0); + T7 = model->B3SOIxdif * T4 / pParam->B3SOIndiode; + DEXP(T7, T1); + T7 = model->B3SOIxrec * T4 / pParam->B3SOInrecf0; + DEXP(T7, T2); + + /* v2.2.2 bug fix */ + pParam->B3SOIahli0 = pParam->B3SOIahli * T0; + + pParam->B3SOIjbjt = pParam->B3SOIisbjt * T0; + pParam->B3SOIjdif = pParam->B3SOIisdif * T1; + pParam->B3SOIjrec = pParam->B3SOIisrec * T2; + + T7 = model->B3SOIxtun * (TempRatio - 1); + DEXP(T7, T0); + pParam->B3SOIjtun = pParam->B3SOIistun * T0; + + + if (pParam->B3SOInsub > 0) + pParam->B3SOIvfbb = -model->B3SOItype * model->B3SOIvtm * + log(pParam->B3SOInpeak/ pParam->B3SOInsub); + else + pParam->B3SOIvfbb = -model->B3SOItype * model->B3SOIvtm * + log(-pParam->B3SOInpeak* pParam->B3SOInsub/ni/ni); + + if (!model->B3SOIvsdfbGiven) + { + if (pParam->B3SOInsub > 0) + pParam->B3SOIvsdfb = -model->B3SOItype * (model->B3SOIvtm*log(1e20 * + pParam->B3SOInsub / ni /ni) - 0.3); + else if (pParam->B3SOInsub < 0) + pParam->B3SOIvsdfb = -model->B3SOItype * (model->B3SOIvtm*log(-1e20 / + pParam->B3SOInsub) + 0.3); + } + + /* Phi & Gamma */ + SDphi = 2.0*model->B3SOIvtm*log(fabs(pParam->B3SOInsub) / ni); + SDgamma = 5.753e-12 * sqrt(fabs(pParam->B3SOInsub)) / model->B3SOIcbox; + + if (!model->B3SOIvsdthGiven) + { + if ( ((pParam->B3SOInsub > 0) && (model->B3SOItype > 0)) || + ((pParam->B3SOInsub < 0) && (model->B3SOItype < 0)) ) + pParam->B3SOIvsdth = pParam->B3SOIvsdfb + SDphi + + SDgamma * sqrt(SDphi); + else + pParam->B3SOIvsdth = pParam->B3SOIvsdfb - SDphi - + SDgamma * sqrt(SDphi); + } + + if (!model->B3SOIcsdminGiven) { + /* Cdmin */ + tmp = sqrt(2.0 * EPSSI * SDphi / (Charge_q * + fabs(pParam->B3SOInsub) * 1.0e6)); + tmp1 = EPSSI / tmp; + model->B3SOIcsdmin = tmp1 * model->B3SOIcbox / + (tmp1 + model->B3SOIcbox); + } + + + pParam->B3SOIphi = 2.0 * model->B3SOIvtm + * log(pParam->B3SOInpeak / ni); + + pParam->B3SOIsqrtPhi = sqrt(pParam->B3SOIphi); + pParam->B3SOIphis3 = pParam->B3SOIsqrtPhi * pParam->B3SOIphi; + + pParam->B3SOIXdep0 = sqrt(2.0 * EPSSI / (Charge_q + * pParam->B3SOInpeak * 1.0e6)) + * pParam->B3SOIsqrtPhi; + pParam->B3SOIsqrtXdep0 = sqrt(pParam->B3SOIXdep0); + pParam->B3SOIlitl = sqrt(3.0 * model->B3SOIxj + * model->B3SOItox); + pParam->B3SOIvbi = model->B3SOIvtm * log(1.0e20 + * pParam->B3SOInpeak / (ni * ni)); + pParam->B3SOIcdep0 = sqrt(Charge_q * EPSSI + * pParam->B3SOInpeak * 1.0e6 / 2.0 + / pParam->B3SOIphi); + +/* v3.0 */ + if (pParam->B3SOIngate > 0.0) + { pParam->B3SOIvfbsd = Vtm0 * log(pParam->B3SOIngate + / 1.0e20); + } + else + pParam->B3SOIvfbsd = 0.0; + + pParam->B3SOIToxRatio = exp(model->B3SOIntox + * log(model->B3SOItoxref /model->B3SOItoxqm)) + /model->B3SOItoxqm /model->B3SOItoxqm; + pParam->B3SOIToxRatioEdge = exp(model->B3SOIntox + * log(model->B3SOItoxref + / (model->B3SOItoxqm * pParam->B3SOIpoxedge))) + / model->B3SOItoxqm / model->B3SOItoxqm + / pParam->B3SOIpoxedge / pParam->B3SOIpoxedge; + pParam->B3SOIAechvb = (model->B3SOItype == NMOS) ? 4.97232e-7 : 3.42537e-7; + pParam->B3SOIBechvb = (model->B3SOItype == NMOS) ? 7.45669e11 : 1.16645e12; + pParam->B3SOIAechvbEdge = pParam->B3SOIAechvb * pParam->B3SOIweff + * pParam->B3SOIdlcig * pParam->B3SOIToxRatioEdge; + pParam->B3SOIBechvbEdge = -pParam->B3SOIBechvb + * model->B3SOItoxqm * pParam->B3SOIpoxedge; + pParam->B3SOIAechvb *= pParam->B3SOIweff * pParam->B3SOIleff + * pParam->B3SOIToxRatio; + pParam->B3SOIBechvb *= -model->B3SOItoxqm; +/* v3.0 */ + + + if (model->B3SOIk1Given || model->B3SOIk2Given) + { if (!model->B3SOIk1Given) + { fprintf(stdout, "Warning: k1 should be specified with k2.\n"); + pParam->B3SOIk1 = 0.53; + } + if (!model->B3SOIk2Given) + { fprintf(stdout, "Warning: k2 should be specified with k1.\n"); + pParam->B3SOIk2 = -0.0186; + } + if (model->B3SOIxtGiven) + fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n"); + if (model->B3SOIvbxGiven) + fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n"); + if (model->B3SOIvbmGiven) + fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n"); + if (model->B3SOIgamma1Given) + fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n"); + if (model->B3SOIgamma2Given) + fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n"); + } + else + { if (!model->B3SOIvbxGiven) + pParam->B3SOIvbx = pParam->B3SOIphi - 7.7348e-4 + * pParam->B3SOInpeak + * pParam->B3SOIxt * pParam->B3SOIxt; + if (pParam->B3SOIvbx > 0.0) + pParam->B3SOIvbx = -pParam->B3SOIvbx; + if (pParam->B3SOIvbm > 0.0) + pParam->B3SOIvbm = -pParam->B3SOIvbm; + + if (!model->B3SOIgamma1Given) + pParam->B3SOIgamma1 = 5.753e-12 + * sqrt(pParam->B3SOInpeak) + / model->B3SOIcox; + if (!model->B3SOIgamma2Given) + pParam->B3SOIgamma2 = 5.753e-12 + * sqrt(pParam->B3SOInsub) + / model->B3SOIcox; + + T0 = pParam->B3SOIgamma1 - pParam->B3SOIgamma2; + T1 = sqrt(pParam->B3SOIphi - pParam->B3SOIvbx) + - pParam->B3SOIsqrtPhi; + T2 = sqrt(pParam->B3SOIphi * (pParam->B3SOIphi + - pParam->B3SOIvbm)) - pParam->B3SOIphi; + pParam->B3SOIk2 = T0 * T1 / (2.0 * T2 + pParam->B3SOIvbm); + pParam->B3SOIk1 = pParam->B3SOIgamma2 - 2.0 + * pParam->B3SOIk2 * sqrt(pParam->B3SOIphi + - pParam->B3SOIvbm); + } + + if (pParam->B3SOIk2 < 0.0) + { T0 = 0.5 * pParam->B3SOIk1 / pParam->B3SOIk2; + pParam->B3SOIvbsc = 0.9 * (pParam->B3SOIphi - T0 * T0); + if (pParam->B3SOIvbsc > -3.0) + pParam->B3SOIvbsc = -3.0; + else if (pParam->B3SOIvbsc < -30.0) + pParam->B3SOIvbsc = -30.0; + } + else + { pParam->B3SOIvbsc = -30.0; + } + if (pParam->B3SOIvbsc > pParam->B3SOIvbm) + pParam->B3SOIvbsc = pParam->B3SOIvbm; + + if ((T0 = pParam->B3SOIweff + pParam->B3SOIk1w2) < 1e-8) + T0 = 1e-8; + pParam->B3SOIk1eff = pParam->B3SOIk1 * (1 + pParam->B3SOIk1w1/T0); + + if (model->B3SOIvth0Given) + { pParam->B3SOIvfb = model->B3SOItype * pParam->B3SOIvth0 + - pParam->B3SOIphi - pParam->B3SOIk1eff + * pParam->B3SOIsqrtPhi; + } + else + { pParam->B3SOIvfb = -1.0; + pParam->B3SOIvth0 = model->B3SOItype * (pParam->B3SOIvfb + + pParam->B3SOIphi + pParam->B3SOIk1eff + * pParam->B3SOIsqrtPhi); + } + T1 = sqrt(EPSSI / EPSOX * model->B3SOItox + * pParam->B3SOIXdep0); + T0 = exp(-0.5 * pParam->B3SOIdsub * pParam->B3SOIleff / T1); + pParam->B3SOItheta0vb0 = (T0 + 2.0 * T0 * T0); + + T0 = exp(-0.5 * pParam->B3SOIdrout * pParam->B3SOIleff / T1); + T2 = (T0 + 2.0 * T0 * T0); + pParam->B3SOIthetaRout = pParam->B3SOIpdibl1 * T2 + + pParam->B3SOIpdibl2; + } + + here->B3SOIcsbox = model->B3SOIcbox*here->B3SOIsourceArea; + here->B3SOIcsmin = model->B3SOIcsdmin*here->B3SOIsourceArea; + here->B3SOIcdbox = model->B3SOIcbox*here->B3SOIdrainArea; + here->B3SOIcdmin = model->B3SOIcsdmin*here->B3SOIdrainArea; + + if ( ((pParam->B3SOInsub > 0) && (model->B3SOItype > 0)) || + ((pParam->B3SOInsub < 0) && (model->B3SOItype < 0)) ) + { + T0 = pParam->B3SOIvsdth - pParam->B3SOIvsdfb; + pParam->B3SOIsdt1 = pParam->B3SOIvsdfb + model->B3SOIasd * T0; + T1 = here->B3SOIcsbox - here->B3SOIcsmin; + T2 = T1 / T0 / T0; + pParam->B3SOIst2 = T2 / model->B3SOIasd; + pParam->B3SOIst3 = T2 /( 1 - model->B3SOIasd); + here->B3SOIst4 = T0 * T1 * (1 + model->B3SOIasd) / 3 + - here->B3SOIcsmin * pParam->B3SOIvsdfb; + + T1 = here->B3SOIcdbox - here->B3SOIcdmin; + T2 = T1 / T0 / T0; + pParam->B3SOIdt2 = T2 / model->B3SOIasd; + pParam->B3SOIdt3 = T2 /( 1 - model->B3SOIasd); + here->B3SOIdt4 = T0 * T1 * (1 + model->B3SOIasd) / 3 + - here->B3SOIcdmin * pParam->B3SOIvsdfb; + } else + { + T0 = pParam->B3SOIvsdfb - pParam->B3SOIvsdth; + pParam->B3SOIsdt1 = pParam->B3SOIvsdth + model->B3SOIasd * T0; + T1 = here->B3SOIcsmin - here->B3SOIcsbox; + T2 = T1 / T0 / T0; + pParam->B3SOIst2 = T2 / model->B3SOIasd; + pParam->B3SOIst3 = T2 /( 1 - model->B3SOIasd); + here->B3SOIst4 = T0 * T1 * (1 + model->B3SOIasd) / 3 + - here->B3SOIcsbox * pParam->B3SOIvsdth; + + T1 = here->B3SOIcdmin - here->B3SOIcdbox; + T2 = T1 / T0 / T0; + pParam->B3SOIdt2 = T2 / model->B3SOIasd; + pParam->B3SOIdt3 = T2 /( 1 - model->B3SOIasd); + here->B3SOIdt4 = T0 * T1 * (1 + model->B3SOIasd) / 3 + - here->B3SOIcdbox * pParam->B3SOIvsdth; + } + + /* v2.2.2 bug fix */ + T0 = model->B3SOIcsdesw * log(1 + model->B3SOItsi / + model->B3SOItbox); + T1 = here->B3SOIsourcePerimeter - here->B3SOIw; + if (T1 > 0.0) + here->B3SOIcsesw = T0 * T1; + else + here->B3SOIcsesw = 0.0; + T1 = here->B3SOIdrainPerimeter - here->B3SOIw; + if (T1 > 0.0) + here->B3SOIcdesw = T0 * T1; + else + here->B3SOIcdesw = 0.0; + + + here->B3SOIphi = pParam->B3SOIphi; + /* process source/drain series resistance */ + here->B3SOIdrainConductance = model->B3SOIsheetResistance + * here->B3SOIdrainSquares; + if (here->B3SOIdrainConductance > 0.0) + here->B3SOIdrainConductance = 1.0 + / here->B3SOIdrainConductance; + else + here->B3SOIdrainConductance = 0.0; + + here->B3SOIsourceConductance = model->B3SOIsheetResistance + * here->B3SOIsourceSquares; + if (here->B3SOIsourceConductance > 0.0) + here->B3SOIsourceConductance = 1.0 + / here->B3SOIsourceConductance; + else + here->B3SOIsourceConductance = 0.0; + here->B3SOIcgso = pParam->B3SOIcgso; + here->B3SOIcgdo = pParam->B3SOIcgdo; + + +/* v2.0 release */ + if (model->B3SOIln < 1e-15) model->B3SOIln = 1e-15; + T0 = -0.5 * pParam->B3SOIleff * pParam->B3SOIleff / model->B3SOIln / model->B3SOIln; + DEXP(T0,T1); + pParam->B3SOIarfabjt = T1; + + T0 = pParam->B3SOIlbjt0 * (1.0 / pParam->B3SOIleff + 1.0 / model->B3SOIln); + pParam->B3SOIlratio = pow(T0,pParam->B3SOInbjt); + pParam->B3SOIlratiodif = 1.0 + model->B3SOIldif0 * pow(T0,model->B3SOIndif); + + if ((pParam->B3SOIvearly = pParam->B3SOIvabjt + pParam->B3SOIaely * pParam->B3SOIleff) < 1) + pParam->B3SOIvearly = 1; + + /* vfbzb calculation for capMod 3 */ + tmp = sqrt(pParam->B3SOIXdep0); + tmp1 = pParam->B3SOIvbi - pParam->B3SOIphi; + tmp2 = model->B3SOIfactor1 * tmp; + + T0 = -0.5 * pParam->B3SOIdvt1w * pParam->B3SOIweff + * pParam->B3SOIleff / 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->B3SOIdvt0w * T2; + T2 = T0 * tmp1; + + T0 = -0.5 * pParam->B3SOIdvt1 * pParam->B3SOIleff / 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->B3SOIdvt0 * T3 * tmp1; + +/* v2.2.3 */ + T4 = (model->B3SOItox - model->B3SOIdtoxcv) * pParam->B3SOIphi + / (pParam->B3SOIweff + pParam->B3SOIw0); + + T0 = sqrt(1.0 + pParam->B3SOInlx / pParam->B3SOIleff); + T5 = pParam->B3SOIk1eff * (T0 - 1.0) * pParam->B3SOIsqrtPhi + + (pParam->B3SOIkt1 + pParam->B3SOIkt1l / pParam->B3SOIleff) + * (TempRatio - 1.0); + + tmp3 = model->B3SOItype * pParam->B3SOIvth0 + - T2 - T3 + pParam->B3SOIk3 * T4 + T5; + pParam->B3SOIvfbzb = tmp3 - pParam->B3SOIphi - pParam->B3SOIk1eff + * pParam->B3SOIsqrtPhi; + /* End of vfbzb */ + + pParam->B3SOIldeb = sqrt(EPSSI * Vtm0 / (Charge_q * pParam->B3SOInpeak * 1.0e6)) / 3.0; + pParam->B3SOIacde = pParam->B3SOIacde * pow((pParam->B3SOInpeak / 2.0e16), -0.25); + } + } + return(OK); +} + diff --git a/src/spicelib/devices/bsim3soi/b3soitrunc.c b/src/spicelib/devices/bsim3soi/b3soitrunc.c new file mode 100644 index 000000000..8f81998bd --- /dev/null +++ b/src/spicelib/devices/bsim3soi/b3soitrunc.c @@ -0,0 +1,51 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soitrunc.c 98/5/01 +Modified by Paolo Nenzi 2002 +**********/ + + +#include "ngspice.h" +#include "cktdefs.h" +#include "b3soidef.h" +#include "sperror.h" +#include "suffix.h" + + +int +B3SOItrunc(GENmodel *inModel, CKTcircuit *ckt, double *timeStep) +{ +B3SOImodel *model = (B3SOImodel*)inModel; +B3SOIinstance *here; + +#ifdef STEPDEBUG + double debugtemp; +#endif /* STEPDEBUG */ + + for (; model != NULL; model = model->B3SOInextModel) + { for (here = model->B3SOIinstances; here != NULL; + here = here->B3SOInextInstance) + { + if (here->B3SOIowner != ARCHme) + continue; + +#ifdef STEPDEBUG + debugtemp = *timeStep; +#endif /* STEPDEBUG */ + CKTterr(here->B3SOIqb,ckt,timeStep); + CKTterr(here->B3SOIqg,ckt,timeStep); + CKTterr(here->B3SOIqd,ckt,timeStep); +#ifdef STEPDEBUG + if(debugtemp != *timeStep) + { printf("device %s reduces step from %g to %g\n", + here->B3SOIname,debugtemp,*timeStep); + } +#endif /* STEPDEBUG */ + } + } + return(OK); +} + + +