diff --git a/DEVICES b/DEVICES index 3eb00f420..580e618a5 100644 --- a/DEVICES +++ b/DEVICES @@ -168,4 +168,9 @@ BSIM3SOI_FD - SOI model (fully depleted devices) NOT YET IMPLEMENTED. BSIM3SOI_PD - SOI model (partially depleted devices) - NOT YET IMPLEMENTED. + Initial Release Ver: 2.2.1. TO BE TESTED + There is a bsim3soipd directory under the test + hierarchy. The tests come from the bsim3soi + web site at: + http://www-device.eecs.berkeley.edu/~bsim3soi + diff --git a/configure.in b/configure.in index eada4f71c..f2643ab2b 100644 --- a/configure.in +++ b/configure.in @@ -173,7 +173,7 @@ else fi AC_DEFINE_UNQUOTED(NGSPICEBINDIR, "`echo $dprefix/bin`" ) -AC_DEFINE_UNQUOTED(NGSPICEDATADIR, "`echo $dprefix/share/ng-spice-rework`" ) +AC_DEFINE_UNQUOTED(NGSPICEDATADIR, "`echo $dprefix/share/ng-spice`" ) AC_DEFINE_UNQUOTED(NGSPICEBUILDDATE, "`date`" ) @@ -214,6 +214,7 @@ src/spicelib/devices/bsim3v1/Makefile \ src/spicelib/devices/bsim3/Makefile \ src/spicelib/devices/bsim4/Makefile \ src/spicelib/devices/bsim3v2/Makefile \ +src/spicelib/devices/bsim3soi_pd/Makefile \ src/spicelib/devices/cap/Makefile \ src/spicelib/devices/cccs/Makefile \ src/spicelib/devices/ccvs/Makefile \ diff --git a/src/Makefile.am b/src/Makefile.am index 4bb4b9afa..14f94b7b5 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -22,6 +22,7 @@ DYNAMIC_DEVICELIBS = \ spicelib/devices/bsim3v2/libbsim3v2.la \ spicelib/devices/bsim4/libbsim4.la \ spicelib/devices/cap/libcap.la \ + spicelib/devices/bsim3soi_pd/libbsim3soipd.la \ spicelib/devices/cccs/libcccs.la \ spicelib/devices/ccvs/libccvs.la \ spicelib/devices/ccvs/libccvs.la \ diff --git a/src/include/gendefs.h b/src/include/gendefs.h index 805ec2243..9e9c3c486 100644 --- a/src/include/gendefs.h +++ b/src/include/gendefs.h @@ -24,6 +24,8 @@ typedef struct sGENinstance { int GENnode3; /* appropriate node numbers */ int GENnode4; /* appropriate node numbers */ int GENnode5; /* appropriate node numbers */ + int GENnode6; /* added to create body node 01/06/99 */ + int GENnode7; /* added to create temp node 2/03/99 */ } GENinstance ; diff --git a/src/spicelib/devices/Makefile.am b/src/spicelib/devices/Makefile.am index c50e19f72..29aa0b6cb 100644 --- a/src/spicelib/devices/Makefile.am +++ b/src/spicelib/devices/Makefile.am @@ -9,6 +9,7 @@ SUBDIRS = \ bsim4 \ bsim3v1 \ bsim3v2 \ + bsim3soi_pd \ cap \ cccs \ ccvs \ diff --git a/src/spicelib/devices/bsim3soi_pd/BsimTerms_use b/src/spicelib/devices/bsim3soi_pd/BsimTerms_use new file mode 100644 index 000000000..3cf683b6f --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/BsimTerms_use @@ -0,0 +1,29 @@ +The terms under which the software is provided  are as the following. + +Software is distributed as is, completely without warranty or service +support. The University of California and its employees are not liable +for the condition or performance of the software. + +The University owns the copyright but shall not be liable for any +infringement of copyright or other proprietary rights brought by third +parties against the users of the software. + +The University of California hereby disclaims all implied warranties. + +The University of California grants the users the right to modify, copy, +and redistribute the software and documentation, both within the user's +organization and externally, subject to the following restrictions + +1. The users agree not to charge for the University of California code +   itself but may charge for additions, extensions, or support. + +2. In any product based on the software, the users agree to acknowledge +   the UC Berkeley BSIM Research Group that developed the software. This +   acknowledgment shall appear in the product documentation. + +3. The users agree to obey all U.S. Government restrictions governing +   redistribution or export of the software. + +4. The users agree to reproduce any copyright notice which appears on +   the software on any copy or modification of such made available +   to others. diff --git a/src/spicelib/devices/bsim3soi_pd/ChangeLog b/src/spicelib/devices/bsim3soi_pd/ChangeLog new file mode 100644 index 000000000..684410234 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/ChangeLog @@ -0,0 +1,4 @@ +2000-11-14 Paolo Nenzi + + * Initial release + diff --git a/src/spicelib/devices/bsim3soi_pd/Makefile.am b/src/spicelib/devices/bsim3soi_pd/Makefile.am new file mode 100644 index 000000000..23ff43e8a --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/Makefile.am @@ -0,0 +1,34 @@ +## Process this file with automake to produce Makefile.in + +pkglib_LTLIBRARIES = libbsim3soipd.la + +libbsim3soipd_la_SOURCES = \ + b3soipd.c \ + b3soipdacld.c \ + b3soipdask.c \ + b3soipdcheck.c \ + b3soipdcvtest.c \ + b3soipddel.c \ + b3soipddest.c \ + b3soipdgetic.c \ + b3soipdld.c \ + b3soipdmask.c \ + b3soipdmdel.c \ + b3soipdmpar.c \ + b3soipdnoi.c \ + b3soipdpar.c \ + b3soipdpzld.c \ + b3soipdset.c \ + b3soipdtemp.c \ + b3soipdtrunc.c \ + b3soipddef.h \ + b3soipdext.h \ + b3soipdinit.c \ + b3soipdinit.h \ + b3soipditf.h + + + +INCLUDES = -I$(top_srcdir)/src/include + +MAINTAINERCLEANFILES = Makefile.in diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipd.c b/src/spicelib/devices/bsim3soi_pd/b3soipd.c new file mode 100644 index 000000000..7fef7faa8 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipd.c @@ -0,0 +1,730 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipd.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 +**********/ + + +#include "ngspice.h" +#include +#include "devdefs.h" +#include "b3soipddef.h" +#include "suffix.h" + +IFparm B3SOIPDpTable[] = { /* parameters */ + IOP ("l", B3SOIPD_L, IF_REAL, "Length"), + IOP ("w", B3SOIPD_W, IF_REAL, "Width"), + IOP ("ad", B3SOIPD_AD, IF_REAL, "Drain area"), + IOP ("as", B3SOIPD_AS, IF_REAL, "Source area"), + IOP ("pd", B3SOIPD_PD, IF_REAL, "Drain perimeter"), + IOP ("ps", B3SOIPD_PS, IF_REAL, "Source perimeter"), + IOP ("nrd", B3SOIPD_NRD, IF_REAL, "Number of squares in drain"), + IOP ("nrs", B3SOIPD_NRS, IF_REAL, "Number of squares in source"), + IOP ("off", B3SOIPD_OFF, IF_FLAG, "Device is initially off"), + IP ("ic", B3SOIPD_IC, IF_REALVEC, "Vector of DS,GS,BS initial voltages"), + OP ("gmbs", B3SOIPD_GMBS, IF_REAL, "Gmb"), + OP ("gm", B3SOIPD_GM, IF_REAL, "Gm"), + OP ("gm/ids", B3SOIPD_GMID, IF_REAL, "Gm/Ids"), + OP ("gds", B3SOIPD_GDS, IF_REAL, "Gds"), + OP ("vdsat", B3SOIPD_VDSAT, IF_REAL, "Vdsat"), + OP ("vth", B3SOIPD_VON, IF_REAL, "Vth"), + OP ("ids", B3SOIPD_CD, IF_REAL, "Ids"), + OP ("vbs", B3SOIPD_VBS, IF_REAL, "Vbs"), + OP ("vgs", B3SOIPD_VGS, IF_REAL, "Vgs"), + OP ("vds", B3SOIPD_VDS, IF_REAL, "Vds"), + OP ("ves", B3SOIPD_VES, IF_REAL, "Ves"), + IOP ("bjtoff", B3SOIPD_BJTOFF, IF_INTEGER, "BJT on/off flag"), + IOP ("debug", B3SOIPD_DEBUG, IF_INTEGER, "BJT on/off flag"), + IOP ("rth0", B3SOIPD_RTH0, IF_REAL, "Instance Thermal Resistance"), + IOP ("cth0", B3SOIPD_CTH0, IF_REAL, "Instance Thermal Capacitance"), + IOP ("nrb", B3SOIPD_NRB, IF_REAL, "Number of squares in body"), + + +/* v2.0 release */ + IOP ("nbc", B3SOIPD_NBC, IF_REAL, "Number of body contact isolation edge"), + IOP ("nseg", B3SOIPD_NSEG, IF_REAL, + "Number segments for width partitioning"), + IOP ("pdbcp", B3SOIPD_PDBCP, IF_REAL, + "Perimeter length for bc parasitics at drain side"), + IOP ("psbcp", B3SOIPD_PSBCP, IF_REAL, + "Perimeter length for bc parasitics at source side"), + IOP ("agbcp", B3SOIPD_AGBCP, IF_REAL, + "Gate to body overlap area for bc parasitics"), + IOP ("aebcp", B3SOIPD_AEBCP, IF_REAL, + "Substrate to body overlap area for bc prasitics"), + IOP ("vbsusr", B3SOIPD_VBSUSR, IF_REAL, "Vbs specified by user"), + IOP ("tnodeout", B3SOIPD_TNODEOUT, IF_FLAG, + "Flag indicating external temp node") +}; + +IFparm B3SOIPDmPTable[] = { /* model parameters */ + IOP ("capmod", B3SOIPD_MOD_CAPMOD, IF_INTEGER, + "Capacitance model selector"), + IOP ("mobmod", B3SOIPD_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"), + IOP ("noimod", B3SOIPD_MOD_NOIMOD, IF_INTEGER, "Noise model selector"), + IOP ("paramchk", B3SOIPD_MOD_PARAMCHK, IF_INTEGER, + "Model parameter checking selector"), + IOP ("binunit", B3SOIPD_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"), + IOP ("version", B3SOIPD_MOD_VERSION, IF_REAL, + " parameter for model version"), + IOP ("tox", B3SOIPD_MOD_TOX, IF_REAL, "Gate oxide thickness in meters"), + + IOP ("cdsc", B3SOIPD_MOD_CDSC, IF_REAL, + "Drain/Source and channel coupling capacitance"), + IOP ("cdscb", B3SOIPD_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"), + IOP ("cdscd", B3SOIPD_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"), + IOP ("cit", B3SOIPD_MOD_CIT, IF_REAL, "Interface state capacitance"), + IOP ("nfactor", B3SOIPD_MOD_NFACTOR, IF_REAL, + "Subthreshold swing Coefficient"), + IOP ("vsat", B3SOIPD_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"), + IOP ("at", B3SOIPD_MOD_AT, IF_REAL, "Temperature coefficient of vsat"), + IOP ("a0", B3SOIPD_MOD_A0, IF_REAL, + "Non-uniform depletion width effect coefficient."), + IOP ("ags", B3SOIPD_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."), + IOP ("a1", B3SOIPD_MOD_A1, IF_REAL, "Non-saturation effect coefficient"), + IOP ("a2", B3SOIPD_MOD_A2, IF_REAL, "Non-saturation effect coefficient"), + IOP ("keta", B3SOIPD_MOD_KETA, IF_REAL, + "Body-bias coefficient of non-uniform depletion width effect."), + IOP ("nsub", B3SOIPD_MOD_NSUB, IF_REAL, + "Substrate doping concentration with polarity"), + IOP ("nch", B3SOIPD_MOD_NPEAK, IF_REAL, "Channel doping concentration"), + IOP ("ngate", B3SOIPD_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"), + IOP ("gamma1", B3SOIPD_MOD_GAMMA1, IF_REAL, "Vth body coefficient"), + IOP ("gamma2", B3SOIPD_MOD_GAMMA2, IF_REAL, "Vth body coefficient"), + IOP ("vbx", B3SOIPD_MOD_VBX, IF_REAL, "Vth transition body Voltage"), + IOP ("vbm", B3SOIPD_MOD_VBM, IF_REAL, "Maximum body voltage"), + + IOP ("xt", B3SOIPD_MOD_XT, IF_REAL, "Doping depth"), + IOP ("k1", B3SOIPD_MOD_K1, IF_REAL, "Bulk effect coefficient 1"), + IOP ("kt1", B3SOIPD_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"), + IOP ("kt1l", B3SOIPD_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"), + IOP ("kt2", B3SOIPD_MOD_KT2, IF_REAL, "Body-coefficient of kt1"), + IOP ("k2", B3SOIPD_MOD_K2, IF_REAL, "Bulk effect coefficient 2"), + IOP ("k3", B3SOIPD_MOD_K3, IF_REAL, "Narrow width effect coefficient"), + IOP ("k3b", B3SOIPD_MOD_K3B, IF_REAL, "Body effect coefficient of k3"), + IOP ("w0", B3SOIPD_MOD_W0, IF_REAL, "Narrow width effect parameter"), + IOP ("nlx", B3SOIPD_MOD_NLX, IF_REAL, "Lateral non-uniform doping effect"), + IOP ("dvt0", B3SOIPD_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"), + IOP ("dvt1", B3SOIPD_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"), + IOP ("dvt2", B3SOIPD_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"), + IOP ("dvt0w", B3SOIPD_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"), + IOP ("dvt1w", B3SOIPD_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"), + IOP ("dvt2w", B3SOIPD_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"), + IOP ("drout", B3SOIPD_MOD_DROUT, IF_REAL, + "DIBL coefficient of output resistance"), + IOP ("dsub", B3SOIPD_MOD_DSUB, IF_REAL, + "DIBL coefficient in the subthreshold region"), + IOP ("vth0", B3SOIPD_MOD_VTH0, IF_REAL, "Threshold voltage"), + IOP ("vtho", B3SOIPD_MOD_VTH0, IF_REAL, "Threshold voltage"), + IOP ("ua", B3SOIPD_MOD_UA, IF_REAL, "Linear gate dependence of mobility"), + IOP ("ua1", B3SOIPD_MOD_UA1, IF_REAL, "Temperature coefficient of ua"), + IOP ("ub", B3SOIPD_MOD_UB, IF_REAL, + "Quadratic gate dependence of mobility"), + IOP ("ub1", B3SOIPD_MOD_UB1, IF_REAL, "Temperature coefficient of ub"), + IOP ("uc", B3SOIPD_MOD_UC, IF_REAL, "Body-bias dependence of mobility"), + IOP ("uc1", B3SOIPD_MOD_UC1, IF_REAL, "Temperature coefficient of uc"), + IOP ("u0", B3SOIPD_MOD_U0, IF_REAL, "Low-field mobility at Tnom"), + IOP ("ute", B3SOIPD_MOD_UTE, IF_REAL, + "Temperature coefficient of mobility"), + IOP ("voff", B3SOIPD_MOD_VOFF, IF_REAL, "Threshold voltage offset"), + IOP ("tnom", B3SOIPD_MOD_TNOM, IF_REAL, + "Parameter measurement temperature"), + IOP ("cgso", B3SOIPD_MOD_CGSO, IF_REAL, + "Gate-source overlap capacitance per width"), + IOP ("cgdo", B3SOIPD_MOD_CGDO, IF_REAL, + "Gate-drain overlap capacitance per width"), + IOP ("xpart", B3SOIPD_MOD_XPART, IF_REAL, "Channel charge partitioning"), + IOP ("delta", B3SOIPD_MOD_DELTA, IF_REAL, "Effective Vds parameter"), + IOP ("rsh", B3SOIPD_MOD_RSH, IF_REAL, "Source-drain sheet resistance"), + IOP ("rdsw", B3SOIPD_MOD_RDSW, IF_REAL, + "Source-drain resistance per width"), + + IOP ("prwg", B3SOIPD_MOD_PRWG, IF_REAL, + "Gate-bias effect on parasitic resistance "), + IOP ("prwb", B3SOIPD_MOD_PRWB, IF_REAL, + "Body-effect on parasitic resistance "), + + IOP ("prt", B3SOIPD_MOD_PRT, IF_REAL, + "Temperature coefficient of parasitic resistance "), + IOP ("eta0", B3SOIPD_MOD_ETA0, IF_REAL, + "Subthreshold region DIBL coefficient"), + IOP ("etab", B3SOIPD_MOD_ETAB, IF_REAL, + "Subthreshold region DIBL coefficient"), + IOP ("pclm", B3SOIPD_MOD_PCLM, IF_REAL, + "Channel length modulation Coefficient"), + IOP ("pdiblc1", B3SOIPD_MOD_PDIBL1, IF_REAL, + "Drain-induced barrier lowering coefficient"), + IOP ("pdiblc2", B3SOIPD_MOD_PDIBL2, IF_REAL, + "Drain-induced barrier lowering coefficient"), + IOP ("pdiblcb", B3SOIPD_MOD_PDIBLB, IF_REAL, + "Body-effect on drain-induced barrier lowering"), + + IOP ("pvag", B3SOIPD_MOD_PVAG, IF_REAL, + "Gate dependence of output resistance parameter"), + + IOP ("shmod", B3SOIPD_MOD_SHMOD, IF_INTEGER, "Self heating mode selector"), + IOP ("ddmod", B3SOIPD_MOD_DDMOD, IF_INTEGER, + "Dynamic depletion mode selector"), + IOP ("tbox", B3SOIPD_MOD_TBOX, IF_REAL, + "Back gate oxide thickness in meters"), + IOP ("tsi", B3SOIPD_MOD_TSI, IF_REAL, + "Silicon-on-insulator thickness in meters"), + IOP ("xj", B3SOIPD_MOD_XJ, IF_REAL, "Junction Depth"), + IOP ("rth0", B3SOIPD_MOD_RTH0, IF_REAL, "Self-heating thermal resistance"), + IOP ("cth0", B3SOIPD_MOD_CTH0, IF_REAL, "Self-heating thermal capacitance"), + IOP ("ngidl", B3SOIPD_MOD_NGIDL, IF_REAL, "GIDL first parameter"), + IOP ("agidl", B3SOIPD_MOD_AGIDL, IF_REAL, "GIDL second parameter"), + IOP ("bgidl", B3SOIPD_MOD_BGIDL, IF_REAL, "GIDL third parameter"), + IOP ("ndiode", B3SOIPD_MOD_NDIODE, IF_REAL, "Diode non-ideality factor"), + IOP ("xbjt", B3SOIPD_MOD_XBJT, IF_REAL, + "Temperature coefficient for Isbjt"), + + IOP ("xdif", B3SOIPD_MOD_XDIF, IF_REAL, + "Temperature coefficient for Isdif"), + + IOP ("xrec", B3SOIPD_MOD_XREC, IF_REAL, + "Temperature coefficient for Isrec"), + IOP ("xtun", B3SOIPD_MOD_XTUN, IF_REAL, + "Temperature coefficient for Istun"), + + IOP ("pbswg", B3SOIPD_MOD_PBSWG, IF_REAL, + "Source/drain (gate side) sidewall junction capacitance built in potential"), + IOP ("mjswg", B3SOIPD_MOD_MJSWG, IF_REAL, + "Source/drain (gate side) sidewall junction capacitance grading coefficient"), + + IOP ("cjswg", B3SOIPD_MOD_CJSWG, IF_REAL, + "Source/drain (gate side) sidewall junction capacitance per unit width"), + IOP ("lint", B3SOIPD_MOD_LINT, IF_REAL, "Length reduction parameter"), + IOP ("ll", B3SOIPD_MOD_LL, IF_REAL, "Length reduction parameter"), + IOP ("lln", B3SOIPD_MOD_LLN, IF_REAL, "Length reduction parameter"), + IOP ("lw", B3SOIPD_MOD_LW, IF_REAL, "Length reduction parameter"), + IOP ("lwn", B3SOIPD_MOD_LWN, IF_REAL, "Length reduction parameter"), + IOP ("lwl", B3SOIPD_MOD_LWL, IF_REAL, "Length reduction parameter"), + + IOP ("wr", B3SOIPD_MOD_WR, IF_REAL, "Width dependence of rds"), + IOP ("wint", B3SOIPD_MOD_WINT, IF_REAL, "Width reduction parameter"), + IOP ("dwg", B3SOIPD_MOD_DWG, IF_REAL, "Width reduction parameter"), + IOP ("dwb", B3SOIPD_MOD_DWB, IF_REAL, "Width reduction parameter"), + + IOP ("wl", B3SOIPD_MOD_WL, IF_REAL, "Width reduction parameter"), + IOP ("wln", B3SOIPD_MOD_WLN, IF_REAL, "Width reduction parameter"), + IOP ("ww", B3SOIPD_MOD_WW, IF_REAL, "Width reduction parameter"), + IOP ("wwn", B3SOIPD_MOD_WWN, IF_REAL, "Width reduction parameter"), + IOP ("wwl", B3SOIPD_MOD_WWL, IF_REAL, "Width reduction parameter"), + + IOP ("b0", B3SOIPD_MOD_B0, IF_REAL, "Abulk narrow width parameter"), + IOP ("b1", B3SOIPD_MOD_B1, IF_REAL, "Abulk narrow width parameter"), + + IOP ("cgsl", B3SOIPD_MOD_CGSL, IF_REAL, "New C-V model parameter"), + IOP ("cgdl", B3SOIPD_MOD_CGDL, IF_REAL, "New C-V model parameter"), + IOP ("ckappa", B3SOIPD_MOD_CKAPPA, IF_REAL, "New C-V model parameter"), + IOP ("cf", B3SOIPD_MOD_CF, IF_REAL, "Fringe capacitance parameter"), + IOP ("clc", B3SOIPD_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"), + IOP ("cle", B3SOIPD_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"), + IOP ("dwc", B3SOIPD_MOD_DWC, IF_REAL, "Delta W for C-V model"), + IOP ("dlc", B3SOIPD_MOD_DLC, IF_REAL, "Delta L for C-V model"), + + IOP ("alpha0", B3SOIPD_MOD_ALPHA0, IF_REAL, + "substrate current model parameter"), + + IOP ("noia", B3SOIPD_MOD_NOIA, IF_REAL, "Flicker noise parameter"), + IOP ("noib", B3SOIPD_MOD_NOIB, IF_REAL, "Flicker noise parameter"), + IOP ("noic", B3SOIPD_MOD_NOIC, IF_REAL, "Flicker noise parameter"), + IOP ("em", B3SOIPD_MOD_EM, IF_REAL, "Flicker noise parameter"), + IOP ("ef", B3SOIPD_MOD_EF, IF_REAL, "Flicker noise frequency exponent"), + IOP ("af", B3SOIPD_MOD_AF, IF_REAL, "Flicker noise exponent"), + IOP ("kf", B3SOIPD_MOD_KF, IF_REAL, "Flicker noise coefficient"), + IOP ("noif", B3SOIPD_MOD_NOIF, IF_REAL, + "Floating body excess noise ideality factor"), + + +/* v2.0 release */ + IOP ("k1w1", B3SOIPD_MOD_K1W1, IF_REAL, + "First Body effect width dependent parameter"), + IOP ("k1w2", B3SOIPD_MOD_K1W2, IF_REAL, + "Second Boby effect width dependent parameter"), + IOP ("ketas", B3SOIPD_MOD_KETAS, IF_REAL, + "Surface potential adjustment for bulk charge effect"), + IOP ("dwbc", B3SOIPD_MOD_DWBC, IF_REAL, + "Width offset for body contact isolation edge"), + IOP ("beta0", B3SOIPD_MOD_BETA0, IF_REAL, + "First Vds dependent parameter of impact ionizition current"), + IOP ("beta1", B3SOIPD_MOD_BETA1, IF_REAL, + "Second Vds dependent parameter of impact ionizition current"), + IOP ("beta2", B3SOIPD_MOD_BETA2, IF_REAL, + "Third Vds dependent parameter of impact ionizition current"), + IOP ("vdsatii0", B3SOIPD_MOD_VDSATII0, IF_REAL, + "Nominal drain saturation voltage at threshold for impact ionizition current"), + IOP ("tii", B3SOIPD_MOD_TII, IF_REAL, + "Temperature dependent parameter for impact ionizition"), + IOP ("lii", B3SOIPD_MOD_LII, IF_REAL, + "Channel length dependent parameter at threshold for impact ionizition current"), + IOP ("sii0", B3SOIPD_MOD_SII0, IF_REAL, + "First Vgs dependent parameter for impact ionizition current"), + IOP ("sii1", B3SOIPD_MOD_SII1, IF_REAL, + "Second Vgs dependent parameter for impact ionizition current"), + IOP ("sii2", B3SOIPD_MOD_SII2, IF_REAL, + "Third Vgs dependent parameter for impact ionizition current"), + IOP ("siid", B3SOIPD_MOD_SIID, IF_REAL, + "Vds dependent parameter of drain saturation voltage for impact ionizition current"), + IOP ("fbjtii", B3SOIPD_MOD_FBJTII, IF_REAL, + "Fraction of bipolar current affecting the impact ionization"), + IOP ("esatii", B3SOIPD_MOD_ESATII, IF_REAL, + "Saturation electric field for impact ionization"), + IOP ("ntun", B3SOIPD_MOD_NTUN, IF_REAL, + "Reverse tunneling non-ideality factor"), + IOP ("nrecf0", B3SOIPD_MOD_NRECF0, IF_REAL, + "Recombination non-ideality factor at forward bias"), + IOP ("nrecr0", B3SOIPD_MOD_NRECR0, IF_REAL, + "Recombination non-ideality factor at reversed bias"), + IOP ("isbjt", B3SOIPD_MOD_ISBJT, IF_REAL, + "BJT injection saturation current"), + IOP ("isdif", B3SOIPD_MOD_ISDIF, IF_REAL, + "Body to source/drain injection saturation current"), + IOP ("isrec", B3SOIPD_MOD_ISREC, IF_REAL, + "Recombination in depletion saturation current"), + IOP ("istun", B3SOIPD_MOD_ISTUN, IF_REAL, + "Reverse tunneling saturation current"), + IOP ("ln", B3SOIPD_MOD_LN, IF_REAL, "Electron/hole diffusion length"), + IOP ("vrec0", B3SOIPD_MOD_VREC0, IF_REAL, + "Voltage dependent parameter for recombination current"), + IOP ("vtun0", B3SOIPD_MOD_VTUN0, IF_REAL, + "Voltage dependent parameter for tunneling current"), + IOP ("nbjt", B3SOIPD_MOD_NBJT, IF_REAL, + "Power coefficient of channel length dependency for bipolar current"), + IOP ("lbjt0", B3SOIPD_MOD_LBJT0, IF_REAL, + "Refferenc channel length for bipolar cuurent"), + IOP ("ldif0", B3SOIPD_MOD_LDIF0, IF_REAL, + "Channel-length dependency coefficient of diffusion cap"), + IOP ("vabjt", B3SOIPD_MOD_VABJT, IF_REAL, + "Early voltage for bipolar current"), + IOP ("aely", B3SOIPD_MOD_AELY, IF_REAL, + "Channel length dependency of early voltage for bipolar cuurent"), + IOP ("ahli", B3SOIPD_MOD_AHLI, IF_REAL, + "High level injection parameter for bipolar current"), + IOP ("rbody", B3SOIPD_MOD_RBODY, IF_REAL, + "Intrinsic body contact sheet resistance"), + IOP ("rbsh", B3SOIPD_MOD_RBSH, IF_REAL, + "Extrinsic body contact sheet resistance"), + IOP ("cgeo", B3SOIPD_MOD_CGEO, IF_REAL, + "Gate substrate overlap capacitance per unit channel length"), + IOP ("tt", B3SOIPD_MOD_TT, IF_REAL, + "Diffusion capacitance transit time coefficient"), + IOP ("ndif", B3SOIPD_MOD_NDIF, IF_REAL, + "Power coefficient of channel length dependency for diffusion capacitance"), + IOP ("vsdfb", B3SOIPD_MOD_VSDFB, IF_REAL, + "Source/drain bottom diffusion capacitance flatband voltage"), + IOP ("vsdth", B3SOIPD_MOD_VSDTH, IF_REAL, + "Source/drain bottom diffusion capacitance threshold voltage"), + IOP ("csdmin", B3SOIPD_MOD_CSDMIN, IF_REAL, + "Source/drain bottom diffusion minimum capacitance"), + IOP ("asd", B3SOIPD_MOD_ASD, IF_REAL, + "Source/drain bottom diffusion smoothing parameter"), + IOP ("csdesw", B3SOIPD_MOD_CSDESW, IF_REAL, + "Source/drain sidewall fringing capacitance per unit length"), + IOP ("ntrecf", B3SOIPD_MOD_NTRECF, IF_REAL, + "Temperature coefficient for Nrecf"), + IOP ("ntrecr", B3SOIPD_MOD_NTRECR, IF_REAL, + "Temperature coefficient for Nrecr"), + IOP ("dlcb", B3SOIPD_MOD_DLCB, IF_REAL, + "Length offset fitting parameter for body charge"), + IOP ("fbody", B3SOIPD_MOD_FBODY, IF_REAL, "Scaling factor for body charge"), + IOP ("tcjswg", B3SOIPD_MOD_TCJSWG, IF_REAL, + "Temperature coefficient of Cjswg"), + IOP ("tpbswg", B3SOIPD_MOD_TPBSWG, IF_REAL, + "Temperature coefficient of Pbswg"), + IOP ("acde", B3SOIPD_MOD_ACDE, IF_REAL, + "Exponential coefficient for charge thickness in capMod=3 for accumulation and depletion regions"), + IOP ("moin", B3SOIPD_MOD_MOIN, IF_REAL, + "Coefficient for the gate-bias dependent surface potential"), + IOP ("delvt", B3SOIPD_MOD_DELVT, IF_REAL, + "Threshold voltage adjust for CV"), + IOP ("kb1", B3SOIPD_MOD_KB1, IF_REAL, + "Coefficient of Vbs0 dependency on Ves"), + IOP ("dlbg", B3SOIPD_MOD_DLBG, IF_REAL, + "Length offset fitting parameter for backgate charge"), + + +/* v2.2 release */ + IOP ("igmod", B3SOIPD_MOD_IGMOD, IF_INTEGER, "gate current model selector"), + IOP ("toxqm", B3SOIPD_MOD_TOXQM, IF_REAL, + "effective oxide thickness considering quantum effect"), + IOP ("wth0", B3SOIPD_MOD_WTH0, IF_REAL, + "Minimum width for thermal resistance calculation"), + IOP ("rhalo", B3SOIPD_MOD_RHALO, IF_REAL, "body halo sheet resistance"), + IOP ("ntox", B3SOIPD_MOD_NTOX, IF_REAL, "power term of gate current"), + IOP ("toxref", B3SOIPD_MOD_TOXREF, IF_REAL, "target oxide thickness"), + IOP ("ebg", B3SOIPD_MOD_EBG, IF_REAL, + "effective bandgap in gate current calcula."), + IOP ("nevb", B3SOIPD_MOD_NEVB, IF_REAL, + "valence-band electron non-ideality factor"), + IOP ("alphagb1", B3SOIPD_MOD_ALPHAGB1, IF_REAL, + "First Vox dependent parameter for gate curent in inversion"), + IOP ("betagb1", B3SOIPD_MOD_BETAGB1, IF_REAL, + "Second Vox dependent parameter for gate currnt in inversion"), + IOP ("vgb1", B3SOIPD_MOD_VGB1, IF_REAL, + "Third Vox dependent parameter for gate current in inversion"), + IOP ("necb", B3SOIPD_MOD_NECB, IF_REAL, + "conduction-band electron non-ideality factor"), + IOP ("alphagb2", B3SOIPD_MOD_ALPHAGB2, IF_REAL, + "First Vox dependent parameter for gate current in accumulation"), + IOP ("betagb2", B3SOIPD_MOD_BETAGB2, IF_REAL, + "Second Vox dependent parameter for gate current in accumulation"), + IOP ("vgb2", B3SOIPD_MOD_VGB2, IF_REAL, + "Third Vox dependent parameter for gate current in accumulation"), + IOP ("voxh", B3SOIPD_MOD_VOXH, IF_REAL, + "the limit of Vox in gate current calculation"), + IOP ("deltavox", B3SOIPD_MOD_DELTAVOX, IF_REAL, + "the smoothing parameter in the Vox smoothing function"), + + +/* Added for binning - START */ +/* Length Dependence */ + IOP ("lnch", B3SOIPD_MOD_LNPEAK, IF_REAL, "Length dependence of nch"), + IOP ("lnsub", B3SOIPD_MOD_LNSUB, IF_REAL, "Length dependence of nsub"), + IOP ("lngate", B3SOIPD_MOD_LNGATE, IF_REAL, "Length dependence of ngate"), + IOP ("lvth0", B3SOIPD_MOD_LVTH0, IF_REAL, "Length dependence of vto"), + IOP ("lk1", B3SOIPD_MOD_LK1, IF_REAL, "Length dependence of k1"), + IOP ("lk1w1", B3SOIPD_MOD_LK1W1, IF_REAL, "Length dependence of k1w1"), + IOP ("lk1w2", B3SOIPD_MOD_LK1W2, IF_REAL, "Length dependence of k1w2"), + IOP ("lk2", B3SOIPD_MOD_LK2, IF_REAL, "Length dependence of k2"), + IOP ("lk3", B3SOIPD_MOD_LK3, IF_REAL, "Length dependence of k3"), + IOP ("lk3b", B3SOIPD_MOD_LK3B, IF_REAL, "Length dependence of k3b"), + IOP ("lkb1", B3SOIPD_MOD_LKB1, IF_REAL, "Length dependence of kb1"), + IOP ("lw0", B3SOIPD_MOD_LW0, IF_REAL, "Length dependence of w0"), + IOP ("lnlx", B3SOIPD_MOD_LNLX, IF_REAL, "Length dependence of nlx"), + IOP ("ldvt0", B3SOIPD_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"), + IOP ("ldvt1", B3SOIPD_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"), + IOP ("ldvt2", B3SOIPD_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"), + IOP ("ldvt0w", B3SOIPD_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"), + IOP ("ldvt1w", B3SOIPD_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"), + IOP ("ldvt2w", B3SOIPD_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"), + IOP ("lu0", B3SOIPD_MOD_LU0, IF_REAL, "Length dependence of u0"), + IOP ("lua", B3SOIPD_MOD_LUA, IF_REAL, "Length dependence of ua"), + IOP ("lub", B3SOIPD_MOD_LUB, IF_REAL, "Length dependence of ub"), + IOP ("luc", B3SOIPD_MOD_LUC, IF_REAL, "Length dependence of uc"), + IOP ("lvsat", B3SOIPD_MOD_LVSAT, IF_REAL, "Length dependence of vsat"), + IOP ("la0", B3SOIPD_MOD_LA0, IF_REAL, "Length dependence of a0"), + IOP ("lags", B3SOIPD_MOD_LAGS, IF_REAL, "Length dependence of ags"), + IOP ("lb0", B3SOIPD_MOD_LB0, IF_REAL, "Length dependence of b0"), + IOP ("lb1", B3SOIPD_MOD_LB1, IF_REAL, "Length dependence of b1"), + IOP ("lketa", B3SOIPD_MOD_LKETA, IF_REAL, "Length dependence of keta"), + IOP ("lketas", B3SOIPD_MOD_LKETAS, IF_REAL, "Length dependence of ketas"), + IOP ("la1", B3SOIPD_MOD_LA1, IF_REAL, "Length dependence of a1"), + IOP ("la2", B3SOIPD_MOD_LA2, IF_REAL, "Length dependence of a2"), + IOP ("lrdsw", B3SOIPD_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "), + IOP ("lprwb", B3SOIPD_MOD_LPRWB, IF_REAL, "Length dependence of prwb "), + IOP ("lprwg", B3SOIPD_MOD_LPRWG, IF_REAL, "Length dependence of prwg "), + IOP ("lwr", B3SOIPD_MOD_LWR, IF_REAL, "Length dependence of wr"), + IOP ("lnfactor", B3SOIPD_MOD_LNFACTOR, IF_REAL, + "Length dependence of nfactor"), + IOP ("ldwg", B3SOIPD_MOD_LDWG, IF_REAL, "Length dependence of dwg"), + IOP ("ldwb", B3SOIPD_MOD_LDWB, IF_REAL, "Length dependence of dwb"), + IOP ("lvoff", B3SOIPD_MOD_LVOFF, IF_REAL, "Length dependence of voff"), + IOP ("leta0", B3SOIPD_MOD_LETA0, IF_REAL, "Length dependence of eta0"), + IOP ("letab", B3SOIPD_MOD_LETAB, IF_REAL, "Length dependence of etab"), + IOP ("ldsub", B3SOIPD_MOD_LDSUB, IF_REAL, "Length dependence of dsub"), + IOP ("lcit", B3SOIPD_MOD_LCIT, IF_REAL, "Length dependence of cit"), + IOP ("lcdsc", B3SOIPD_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"), + IOP ("lcdscb", B3SOIPD_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"), + IOP ("lcdscd", B3SOIPD_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"), + IOP ("lpclm", B3SOIPD_MOD_LPCLM, IF_REAL, "Length dependence of pclm"), + IOP ("lpdiblc1", B3SOIPD_MOD_LPDIBL1, IF_REAL, + "Length dependence of pdiblc1"), + IOP ("lpdiblc2", B3SOIPD_MOD_LPDIBL2, IF_REAL, + "Length dependence of pdiblc2"), + IOP ("lpdiblcb", B3SOIPD_MOD_LPDIBLB, IF_REAL, + "Length dependence of pdiblcb"), + IOP ("ldrout", B3SOIPD_MOD_LDROUT, IF_REAL, "Length dependence of drout"), + IOP ("lpvag", B3SOIPD_MOD_LPVAG, IF_REAL, "Length dependence of pvag"), + IOP ("ldelta", B3SOIPD_MOD_LDELTA, IF_REAL, "Length dependence of delta"), + IOP ("lalpha0", B3SOIPD_MOD_LALPHA0, IF_REAL, + "Length dependence of alpha0"), + IOP ("lfbjtii", B3SOIPD_MOD_LFBJTII, IF_REAL, + "Length dependence of fbjtii"), + IOP ("lbeta0", B3SOIPD_MOD_LBETA0, IF_REAL, "Length dependence of beta0"), + IOP ("lbeta1", B3SOIPD_MOD_LBETA1, IF_REAL, "Length dependence of beta1"), + IOP ("lbeta2", B3SOIPD_MOD_LBETA2, IF_REAL, "Length dependence of beta2"), + IOP ("lvdsatii0", B3SOIPD_MOD_LVDSATII0, IF_REAL, + "Length dependence of vdsatii0"), + IOP ("llii", B3SOIPD_MOD_LLII, IF_REAL, "Length dependence of lii"), + IOP ("lesatii", B3SOIPD_MOD_LESATII, IF_REAL, + "Length dependence of esatii"), + IOP ("lsii0", B3SOIPD_MOD_LSII0, IF_REAL, "Length dependence of sii0"), + IOP ("lsii1", B3SOIPD_MOD_LSII1, IF_REAL, "Length dependence of sii1"), + IOP ("lsii2", B3SOIPD_MOD_LSII2, IF_REAL, "Length dependence of sii2"), + IOP ("lsiid", B3SOIPD_MOD_LSIID, IF_REAL, "Length dependence of siid"), + IOP ("lagidl", B3SOIPD_MOD_LAGIDL, IF_REAL, "Length dependence of agidl"), + IOP ("lbgidl", B3SOIPD_MOD_LBGIDL, IF_REAL, "Length dependence of bgidl"), + IOP ("lngidl", B3SOIPD_MOD_LNGIDL, IF_REAL, "Length dependence of ngidl"), + IOP ("lntun", B3SOIPD_MOD_LNTUN, IF_REAL, "Length dependence of ntun"), + IOP ("lndiode", B3SOIPD_MOD_LNDIODE, IF_REAL, + "Length dependence of ndiode"), + IOP ("lnrecf0", B3SOIPD_MOD_LNRECF0, IF_REAL, + "Length dependence of nrecf0"), + IOP ("lnrecr0", B3SOIPD_MOD_LNRECR0, IF_REAL, + "Length dependence of nrecr0"), + IOP ("lisbjt", B3SOIPD_MOD_LISBJT, IF_REAL, "Length dependence of isbjt"), + IOP ("lisdif", B3SOIPD_MOD_LISDIF, IF_REAL, "Length dependence of isdif"), + IOP ("lisrec", B3SOIPD_MOD_LISREC, IF_REAL, "Length dependence of isrec"), + IOP ("listun", B3SOIPD_MOD_LISTUN, IF_REAL, "Length dependence of istun"), + IOP ("lvrec0", B3SOIPD_MOD_LVREC0, IF_REAL, "Length dependence of vrec0"), + IOP ("lvtun0", B3SOIPD_MOD_LVTUN0, IF_REAL, "Length dependence of vtun0"), + IOP ("lnbjt", B3SOIPD_MOD_LNBJT, IF_REAL, "Length dependence of nbjt"), + IOP ("llbjt0", B3SOIPD_MOD_LLBJT0, IF_REAL, "Length dependence of lbjt0"), + IOP ("lvabjt", B3SOIPD_MOD_LVABJT, IF_REAL, "Length dependence of vabjt"), + IOP ("laely", B3SOIPD_MOD_LAELY, IF_REAL, "Length dependence of aely"), + IOP ("lahli", B3SOIPD_MOD_LAHLI, IF_REAL, "Length dependence of ahli"), + IOP ("lvsdfb", B3SOIPD_MOD_LVSDFB, IF_REAL, "Length dependence of vsdfb"), + IOP ("lvsdth", B3SOIPD_MOD_LVSDTH, IF_REAL, "Length dependence of vsdth"), + IOP ("ldelvt", B3SOIPD_MOD_LDELVT, IF_REAL, "Length dependence of delvt"), + IOP ("lacde", B3SOIPD_MOD_LACDE, IF_REAL, "Length dependence of acde"), + IOP ("lmoin", B3SOIPD_MOD_LMOIN, IF_REAL, "Length dependence of amoin"), +/* Width Dependence */ + IOP ("wnch", B3SOIPD_MOD_WNPEAK, IF_REAL, "Width dependence of nch"), + IOP ("wnsub", B3SOIPD_MOD_WNSUB, IF_REAL, "Width dependence of nsub"), + IOP ("wngate", B3SOIPD_MOD_WNGATE, IF_REAL, "Width dependence of ngate"), + IOP ("wvth0", B3SOIPD_MOD_WVTH0, IF_REAL, "Width dependence of vto"), + IOP ("wk1", B3SOIPD_MOD_WK1, IF_REAL, "Width dependence of k1"), + IOP ("wk1w1", B3SOIPD_MOD_WK1W1, IF_REAL, "Width dependence of k1w1"), + IOP ("wk1w2", B3SOIPD_MOD_WK1W2, IF_REAL, "Width dependence of k1w2"), + IOP ("wk2", B3SOIPD_MOD_WK2, IF_REAL, "Width dependence of k2"), + IOP ("wk3", B3SOIPD_MOD_WK3, IF_REAL, "Width dependence of k3"), + IOP ("wk3b", B3SOIPD_MOD_WK3B, IF_REAL, "Width dependence of k3b"), + IOP ("wkb1", B3SOIPD_MOD_WKB1, IF_REAL, "Width dependence of kb1"), + IOP ("ww0", B3SOIPD_MOD_WW0, IF_REAL, "Width dependence of w0"), + IOP ("wnlx", B3SOIPD_MOD_WNLX, IF_REAL, "Width dependence of nlx"), + IOP ("wdvt0", B3SOIPD_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"), + IOP ("wdvt1", B3SOIPD_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"), + IOP ("wdvt2", B3SOIPD_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"), + IOP ("wdvt0w", B3SOIPD_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"), + IOP ("wdvt1w", B3SOIPD_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"), + IOP ("wdvt2w", B3SOIPD_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"), + IOP ("wu0", B3SOIPD_MOD_WU0, IF_REAL, "Width dependence of u0"), + IOP ("wua", B3SOIPD_MOD_WUA, IF_REAL, "Width dependence of ua"), + IOP ("wub", B3SOIPD_MOD_WUB, IF_REAL, "Width dependence of ub"), + IOP ("wuc", B3SOIPD_MOD_WUC, IF_REAL, "Width dependence of uc"), + IOP ("wvsat", B3SOIPD_MOD_WVSAT, IF_REAL, "Width dependence of vsat"), + IOP ("wa0", B3SOIPD_MOD_WA0, IF_REAL, "Width dependence of a0"), + IOP ("wags", B3SOIPD_MOD_WAGS, IF_REAL, "Width dependence of ags"), + IOP ("wb0", B3SOIPD_MOD_WB0, IF_REAL, "Width dependence of b0"), + IOP ("wb1", B3SOIPD_MOD_WB1, IF_REAL, "Width dependence of b1"), + IOP ("wketa", B3SOIPD_MOD_WKETA, IF_REAL, "Width dependence of keta"), + IOP ("wketas", B3SOIPD_MOD_WKETAS, IF_REAL, "Width dependence of ketas"), + IOP ("wa1", B3SOIPD_MOD_WA1, IF_REAL, "Width dependence of a1"), + IOP ("wa2", B3SOIPD_MOD_WA2, IF_REAL, "Width dependence of a2"), + IOP ("wrdsw", B3SOIPD_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "), + IOP ("wprwb", B3SOIPD_MOD_WPRWB, IF_REAL, "Width dependence of prwb "), + IOP ("wprwg", B3SOIPD_MOD_WPRWG, IF_REAL, "Width dependence of prwg "), + IOP ("wwr", B3SOIPD_MOD_WWR, IF_REAL, "Width dependence of wr"), + IOP ("wnfactor", B3SOIPD_MOD_WNFACTOR, IF_REAL, + "Width dependence of nfactor"), + IOP ("wdwg", B3SOIPD_MOD_WDWG, IF_REAL, "Width dependence of dwg"), + IOP ("wdwb", B3SOIPD_MOD_WDWB, IF_REAL, "Width dependence of dwb"), + IOP ("wvoff", B3SOIPD_MOD_WVOFF, IF_REAL, "Width dependence of voff"), + IOP ("weta0", B3SOIPD_MOD_WETA0, IF_REAL, "Width dependence of eta0"), + IOP ("wetab", B3SOIPD_MOD_WETAB, IF_REAL, "Width dependence of etab"), + IOP ("wdsub", B3SOIPD_MOD_WDSUB, IF_REAL, "Width dependence of dsub"), + IOP ("wcit", B3SOIPD_MOD_WCIT, IF_REAL, "Width dependence of cit"), + IOP ("wcdsc", B3SOIPD_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"), + IOP ("wcdscb", B3SOIPD_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"), + IOP ("wcdscd", B3SOIPD_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"), + IOP ("wpclm", B3SOIPD_MOD_WPCLM, IF_REAL, "Width dependence of pclm"), + IOP ("wpdiblc1", B3SOIPD_MOD_WPDIBL1, IF_REAL, + "Width dependence of pdiblc1"), + IOP ("wpdiblc2", B3SOIPD_MOD_WPDIBL2, IF_REAL, + "Width dependence of pdiblc2"), + IOP ("wpdiblcb", B3SOIPD_MOD_WPDIBLB, IF_REAL, + "Width dependence of pdiblcb"), + IOP ("wdrout", B3SOIPD_MOD_WDROUT, IF_REAL, "Width dependence of drout"), + IOP ("wpvag", B3SOIPD_MOD_WPVAG, IF_REAL, "Width dependence of pvag"), + IOP ("wdelta", B3SOIPD_MOD_WDELTA, IF_REAL, "Width dependence of delta"), + IOP ("walpha0", B3SOIPD_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"), + IOP ("wfbjtii", B3SOIPD_MOD_WFBJTII, IF_REAL, "Width dependence of fbjtii"), + IOP ("wbeta0", B3SOIPD_MOD_WBETA0, IF_REAL, "Width dependence of beta0"), + IOP ("wbeta1", B3SOIPD_MOD_WBETA1, IF_REAL, "Width dependence of beta1"), + IOP ("wbeta2", B3SOIPD_MOD_WBETA2, IF_REAL, "Width dependence of beta2"), + IOP ("wvdsatii0", B3SOIPD_MOD_WVDSATII0, IF_REAL, + "Width dependence of vdsatii0"), + IOP ("wlii", B3SOIPD_MOD_WLII, IF_REAL, "Width dependence of lii"), + IOP ("wesatii", B3SOIPD_MOD_WESATII, IF_REAL, "Width dependence of esatii"), + IOP ("wsii0", B3SOIPD_MOD_WSII0, IF_REAL, "Width dependence of sii0"), + IOP ("wsii1", B3SOIPD_MOD_WSII1, IF_REAL, "Width dependence of sii1"), + IOP ("wsii2", B3SOIPD_MOD_WSII2, IF_REAL, "Width dependence of sii2"), + IOP ("wsiid", B3SOIPD_MOD_WSIID, IF_REAL, "Width dependence of siid"), + IOP ("wagidl", B3SOIPD_MOD_WAGIDL, IF_REAL, "Width dependence of agidl"), + IOP ("wbgidl", B3SOIPD_MOD_WBGIDL, IF_REAL, "Width dependence of bgidl"), + IOP ("wngidl", B3SOIPD_MOD_WNGIDL, IF_REAL, "Width dependence of ngidl"), + IOP ("wntun", B3SOIPD_MOD_WNTUN, IF_REAL, "Width dependence of ntun"), + IOP ("wndiode", B3SOIPD_MOD_WNDIODE, IF_REAL, "Width dependence of ndiode"), + IOP ("wnrecf0", B3SOIPD_MOD_WNRECF0, IF_REAL, "Width dependence of nrecf0"), + IOP ("wnrecr0", B3SOIPD_MOD_WNRECR0, IF_REAL, "Width dependence of nrecr0"), + IOP ("wisbjt", B3SOIPD_MOD_WISBJT, IF_REAL, "Width dependence of isbjt"), + IOP ("wisdif", B3SOIPD_MOD_WISDIF, IF_REAL, "Width dependence of isdif"), + IOP ("wisrec", B3SOIPD_MOD_WISREC, IF_REAL, "Width dependence of isrec"), + IOP ("wistun", B3SOIPD_MOD_WISTUN, IF_REAL, "Width dependence of istun"), + IOP ("wvrec0", B3SOIPD_MOD_WVREC0, IF_REAL, "Width dependence of vrec0"), + IOP ("wvtun0", B3SOIPD_MOD_WVTUN0, IF_REAL, "Width dependence of vtun0"), + IOP ("wnbjt", B3SOIPD_MOD_WNBJT, IF_REAL, "Width dependence of nbjt"), + IOP ("wlbjt0", B3SOIPD_MOD_WLBJT0, IF_REAL, "Width dependence of lbjt0"), + IOP ("wvabjt", B3SOIPD_MOD_WVABJT, IF_REAL, "Width dependence of vabjt"), + IOP ("waely", B3SOIPD_MOD_WAELY, IF_REAL, "Width dependence of aely"), + IOP ("wahli", B3SOIPD_MOD_WAHLI, IF_REAL, "Width dependence of ahli"), + IOP ("wvsdfb", B3SOIPD_MOD_WVSDFB, IF_REAL, "Width dependence of vsdfb"), + IOP ("wvsdth", B3SOIPD_MOD_WVSDTH, IF_REAL, "Width dependence of vsdth"), + IOP ("wdelvt", B3SOIPD_MOD_WDELVT, IF_REAL, "Width dependence of delvt"), + IOP ("wacde", B3SOIPD_MOD_WACDE, IF_REAL, "Width dependence of acde"), + IOP ("wmoin", B3SOIPD_MOD_WMOIN, IF_REAL, "Width dependence of amoin"), +/* Cross-term Dependence */ + IOP ("pnch", B3SOIPD_MOD_PNPEAK, IF_REAL, "Cross-term dependence of nch"), + IOP ("pnsub", B3SOIPD_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"), + IOP ("pngate", B3SOIPD_MOD_PNGATE, IF_REAL, + "Cross-term dependence of ngate"), + IOP ("pvth0", B3SOIPD_MOD_PVTH0, IF_REAL, "Cross-term dependence of vto"), + IOP ("pk1", B3SOIPD_MOD_PK1, IF_REAL, "Cross-term dependence of k1"), + IOP ("pk1w1", B3SOIPD_MOD_PK1W1, IF_REAL, "Cross-term dependence of k1w1"), + IOP ("pk1w2", B3SOIPD_MOD_PK1W2, IF_REAL, "Cross-term dependence of k1w2"), + IOP ("pk2", B3SOIPD_MOD_PK2, IF_REAL, "Cross-term dependence of k2"), + IOP ("pk3", B3SOIPD_MOD_PK3, IF_REAL, "Cross-term dependence of k3"), + IOP ("pk3b", B3SOIPD_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"), + IOP ("pkb1", B3SOIPD_MOD_PKB1, IF_REAL, "Cross-term dependence of kb1"), + IOP ("pw0", B3SOIPD_MOD_PW0, IF_REAL, "Cross-term dependence of w0"), + IOP ("pnlx", B3SOIPD_MOD_PNLX, IF_REAL, "Cross-term dependence of nlx"), + IOP ("pdvt0", B3SOIPD_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"), + IOP ("pdvt1", B3SOIPD_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"), + IOP ("pdvt2", B3SOIPD_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"), + IOP ("pdvt0w", B3SOIPD_MOD_PDVT0W, IF_REAL, + "Cross-term dependence of dvt0w"), + IOP ("pdvt1w", B3SOIPD_MOD_PDVT1W, IF_REAL, + "Cross-term dependence of dvt1w"), + IOP ("pdvt2w", B3SOIPD_MOD_PDVT2W, IF_REAL, + "Cross-term dependence of dvt2w"), + IOP ("pu0", B3SOIPD_MOD_PU0, IF_REAL, "Cross-term dependence of u0"), + IOP ("pua", B3SOIPD_MOD_PUA, IF_REAL, "Cross-term dependence of ua"), + IOP ("pub", B3SOIPD_MOD_PUB, IF_REAL, "Cross-term dependence of ub"), + IOP ("puc", B3SOIPD_MOD_PUC, IF_REAL, "Cross-term dependence of uc"), + IOP ("pvsat", B3SOIPD_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"), + IOP ("pa0", B3SOIPD_MOD_PA0, IF_REAL, "Cross-term dependence of a0"), + IOP ("pags", B3SOIPD_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"), + IOP ("pb0", B3SOIPD_MOD_PB0, IF_REAL, "Cross-term dependence of b0"), + IOP ("pb1", B3SOIPD_MOD_PB1, IF_REAL, "Cross-term dependence of b1"), + IOP ("pketa", B3SOIPD_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"), + IOP ("pketas", B3SOIPD_MOD_PKETAS, IF_REAL, + "Cross-term dependence of ketas"), + IOP ("pa1", B3SOIPD_MOD_PA1, IF_REAL, "Cross-term dependence of a1"), + IOP ("pa2", B3SOIPD_MOD_PA2, IF_REAL, "Cross-term dependence of a2"), + IOP ("prdsw", B3SOIPD_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "), + IOP ("pprwb", B3SOIPD_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "), + IOP ("pprwg", B3SOIPD_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "), + IOP ("pwr", B3SOIPD_MOD_PWR, IF_REAL, "Cross-term dependence of wr"), + IOP ("pnfactor", B3SOIPD_MOD_PNFACTOR, IF_REAL, + "Cross-term dependence of nfactor"), + IOP ("pdwg", B3SOIPD_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"), + IOP ("pdwb", B3SOIPD_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"), + IOP ("pvoff", B3SOIPD_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"), + IOP ("peta0", B3SOIPD_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"), + IOP ("petab", B3SOIPD_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"), + IOP ("pdsub", B3SOIPD_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"), + IOP ("pcit", B3SOIPD_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"), + IOP ("pcdsc", B3SOIPD_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"), + IOP ("pcdscb", B3SOIPD_MOD_PCDSCB, IF_REAL, + "Cross-term dependence of cdscb"), + IOP ("pcdscd", B3SOIPD_MOD_PCDSCD, IF_REAL, + "Cross-term dependence of cdscd"), + IOP ("ppclm", B3SOIPD_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"), + IOP ("ppdiblc1", B3SOIPD_MOD_PPDIBL1, IF_REAL, + "Cross-term dependence of pdiblc1"), + IOP ("ppdiblc2", B3SOIPD_MOD_PPDIBL2, IF_REAL, + "Cross-term dependence of pdiblc2"), + IOP ("ppdiblcb", B3SOIPD_MOD_PPDIBLB, IF_REAL, + "Cross-term dependence of pdiblcb"), + IOP ("pdrout", B3SOIPD_MOD_PDROUT, IF_REAL, + "Cross-term dependence of drout"), + IOP ("ppvag", B3SOIPD_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"), + IOP ("pdelta", B3SOIPD_MOD_PDELTA, IF_REAL, + "Cross-term dependence of delta"), + IOP ("palpha0", B3SOIPD_MOD_PALPHA0, IF_REAL, + "Cross-term dependence of alpha0"), + IOP ("pfbjtii", B3SOIPD_MOD_PFBJTII, IF_REAL, + "Cross-term dependence of fbjtii"), + IOP ("pbeta0", B3SOIPD_MOD_PBETA0, IF_REAL, + "Cross-term dependence of beta0"), + IOP ("pbeta1", B3SOIPD_MOD_PBETA1, IF_REAL, + "Cross-term dependence of beta1"), + IOP ("pbeta2", B3SOIPD_MOD_PBETA2, IF_REAL, + "Cross-term dependence of beta2"), + IOP ("pvdsatii0", B3SOIPD_MOD_PVDSATII0, IF_REAL, + "Cross-term dependence of vdsatii0"), + IOP ("plii", B3SOIPD_MOD_PLII, IF_REAL, "Cross-term dependence of lii"), + IOP ("pesatii", B3SOIPD_MOD_PESATII, IF_REAL, + "Cross-term dependence of esatii"), + IOP ("psii0", B3SOIPD_MOD_PSII0, IF_REAL, "Cross-term dependence of sii0"), + IOP ("psii1", B3SOIPD_MOD_PSII1, IF_REAL, "Cross-term dependence of sii1"), + IOP ("psii2", B3SOIPD_MOD_PSII2, IF_REAL, "Cross-term dependence of sii2"), + IOP ("psiid", B3SOIPD_MOD_PSIID, IF_REAL, "Cross-term dependence of siid"), + IOP ("pagidl", B3SOIPD_MOD_PAGIDL, IF_REAL, + "Cross-term dependence of agidl"), + IOP ("pbgidl", B3SOIPD_MOD_PBGIDL, IF_REAL, + "Cross-term dependence of bgidl"), + IOP ("pngidl", B3SOIPD_MOD_PNGIDL, IF_REAL, + "Cross-term dependence of ngidl"), + IOP ("pntun", B3SOIPD_MOD_PNTUN, IF_REAL, "Cross-term dependence of ntun"), + IOP ("pndiode", B3SOIPD_MOD_PNDIODE, IF_REAL, + "Cross-term dependence of ndiode"), + IOP ("pnrecf0", B3SOIPD_MOD_PNRECF0, IF_REAL, + "Cross-term dependence of nrecf0"), + IOP ("pnrecr0", B3SOIPD_MOD_PNRECR0, IF_REAL, + "Cross-term dependence of nrecr0"), + IOP ("pisbjt", B3SOIPD_MOD_PISBJT, IF_REAL, + "Cross-term dependence of isbjt"), + IOP ("pisdif", B3SOIPD_MOD_PISDIF, IF_REAL, + "Cross-term dependence of isdif"), + IOP ("pisrec", B3SOIPD_MOD_PISREC, IF_REAL, + "Cross-term dependence of isrec"), + IOP ("pistun", B3SOIPD_MOD_PISTUN, IF_REAL, + "Cross-term dependence of istun"), + IOP ("pvrec0", B3SOIPD_MOD_PVREC0, IF_REAL, + "Cross-term dependence of vrec0"), + IOP ("pvtun0", B3SOIPD_MOD_PVTUN0, IF_REAL, + "Cross-term dependence of vtun0"), + IOP ("pnbjt", B3SOIPD_MOD_PNBJT, IF_REAL, "Cross-term dependence of nbjt"), + IOP ("plbjt0", B3SOIPD_MOD_PLBJT0, IF_REAL, + "Cross-term dependence of lbjt0"), + IOP ("pvabjt", B3SOIPD_MOD_PVABJT, IF_REAL, + "Cross-term dependence of vabjt"), + IOP ("paely", B3SOIPD_MOD_PAELY, IF_REAL, "Cross-term dependence of aely"), + IOP ("pahli", B3SOIPD_MOD_PAHLI, IF_REAL, "Cross-term dependence of ahli"), + IOP ("pvsdfb", B3SOIPD_MOD_PVSDFB, IF_REAL, + "Cross-term dependence of vsdfb"), + IOP ("pvsdth", B3SOIPD_MOD_PVSDTH, IF_REAL, + "Cross-term dependence of vsdth"), + IOP ("pdelvt", B3SOIPD_MOD_PDELVT, IF_REAL, + "Cross-term dependence of delvt"), + IOP ("pacde", B3SOIPD_MOD_PACDE, IF_REAL, "Cross-term dependence of acde"), + IOP ("pmoin", B3SOIPD_MOD_PMOIN, IF_REAL, "Cross-term dependence of amoin"), +/* Added for binning - END */ + + IP ("nmos", B3SOIPD_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"), + IP ("pmos", B3SOIPD_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"), +}; + +char *B3SOIPDnames[] = { + "Drain", + "Gate", + "Source", + "Backgate", + "", + "Body", + "Temp", + "Charge", +}; + +int B3SOIPDnSize = NUMELEMS (B3SOIPDnames); +int B3SOIPDpTSize = NUMELEMS (B3SOIPDpTable); +int B3SOIPDmPTSize = NUMELEMS (B3SOIPDmPTable); +int B3SOIPDiSize = sizeof (B3SOIPDinstance); +int B3SOIPDmSize = sizeof (B3SOIPDmodel); diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdacld.c b/src/spicelib/devices/bsim3soi_pd/b3soipdacld.c new file mode 100644 index 000000000..8e5a62b28 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdacld.c @@ -0,0 +1,358 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdacld.c 98/5/01 +Modified by Pin Su 99/4/30 +Modified by Pin Su 99/9/27 +**********/ + +#include "ngspice.h" +#include +#include "cktdefs.h" +#include "b3soipddef.h" +#include "sperror.h" +#include "suffix.h" + + +int +B3SOIPDacLoad (inModel, ckt) + GENmodel *inModel; + register CKTcircuit *ckt; +{ + register B3SOIPDmodel *model = (B3SOIPDmodel *) inModel; + register B3SOIPDinstance *here; + register int selfheat; + double xcggb, xcgdb, xcgsb, xcgeb, xcgT; + double xcdgb, xcddb, xcdsb, xcdeb, xcdT; + double xcsgb, xcsdb, xcssb, xcseb, xcsT; + double xcbgb, xcbdb, xcbsb, xcbeb, xcbT; + double xcegb, xceeb, xceT; + double gdpr, gspr, gds; + double cggb, cgdb, cgsb, cgT; + double cdgb, cddb, cdsb, cdeb, cdT; + double cbgb, cbdb, cbsb, cbeb, cbT; + double ceeb, ceT; + double GSoverlapCap, GDoverlapCap, GEoverlapCap, FwdSum, RevSum, Gm, Gmbs, + GmT; + double omega; + double dxpart, sxpart; + double gbbg, gbbdp, gbbb, gbbp, gbbsp, gbbT; + double gddpg, gddpdp, gddpsp, gddpb, gddpT; + double gsspg, gsspdp, gsspsp, gsspb, gsspT; + double gppdp, gppb, gppp, gppT; + double xcTt, cTt, gcTt, gTtt, gTtg, gTtb, gTtdp, gTtsp; + double EDextrinsicCap, ESextrinsicCap; + double xcedb, xcesb; + + + omega = ckt->CKTomega; + for (; model != NULL; model = model->B3SOIPDnextModel) + { + + for (here = model->B3SOIPDinstances; here != NULL; + here = here->B3SOIPDnextInstance) + { + selfheat = (model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0 != 0.0); + if (here->B3SOIPDmode >= 0) + { + Gm = here->B3SOIPDgm; + Gmbs = here->B3SOIPDgmbs; + GmT = model->B3SOIPDtype * here->B3SOIPDgmT; + FwdSum = Gm + Gmbs; + RevSum = 0.0; + + cbgb = here->B3SOIPDcbgb; + cbsb = here->B3SOIPDcbsb; + cbdb = here->B3SOIPDcbdb; + cbeb = here->B3SOIPDcbeb; + cbT = model->B3SOIPDtype * here->B3SOIPDcbT; + + ceeb = here->B3SOIPDceeb; + ceT = model->B3SOIPDtype * here->B3SOIPDceT; + + cggb = here->B3SOIPDcggb; + cgsb = here->B3SOIPDcgsb; + cgdb = here->B3SOIPDcgdb; + cgT = model->B3SOIPDtype * here->B3SOIPDcgT; + + cdgb = here->B3SOIPDcdgb; + cdsb = here->B3SOIPDcdsb; + cddb = here->B3SOIPDcddb; + cdeb = here->B3SOIPDcdeb; + cdT = model->B3SOIPDtype * here->B3SOIPDcdT; + + cTt = here->pParam->B3SOIPDcth; + + gbbg = -here->B3SOIPDgbgs; + gbbdp = -here->B3SOIPDgbds; + gbbb = -here->B3SOIPDgbbs; + gbbp = -here->B3SOIPDgbps; + gbbT = -model->B3SOIPDtype * here->B3SOIPDgbT; + gbbsp = -(gbbg + gbbdp + gbbb + gbbp); + + gddpg = -here->B3SOIPDgjdg; + gddpdp = -here->B3SOIPDgjdd; + gddpb = -here->B3SOIPDgjdb; + gddpT = -model->B3SOIPDtype * here->B3SOIPDgjdT; + gddpsp = -(gddpg + gddpdp + gddpb); + + gsspg = -here->B3SOIPDgjsg; + gsspdp = -here->B3SOIPDgjsd; + gsspb = -here->B3SOIPDgjsb; + gsspT = -model->B3SOIPDtype * here->B3SOIPDgjsT; + gsspsp = -(gsspg + gsspdp + gsspb); + + gppdp = 0; + gppb = -here->B3SOIPDgbpbs; + gppp = -here->B3SOIPDgbpps; + gppT = -model->B3SOIPDtype * here->B3SOIPDgbpT; + + gTtg = here->B3SOIPDgtempg; + gTtb = here->B3SOIPDgtempb; + gTtdp = here->B3SOIPDgtempd; + gTtt = here->B3SOIPDgtempT; + gTtsp = -(gTtg + gTtb + gTtdp); + + sxpart = 0.6; + dxpart = 0.4; + + } + else + { + Gm = -here->B3SOIPDgm; + Gmbs = -here->B3SOIPDgmbs; + GmT = -model->B3SOIPDtype * here->B3SOIPDgmT; + FwdSum = 0.0; + RevSum = -Gm - Gmbs; + + cdgb = + -(here->B3SOIPDcdgb + here->B3SOIPDcggb + here->B3SOIPDcbgb); + cdsb = + -(here->B3SOIPDcddb + here->B3SOIPDcgdb + here->B3SOIPDcbdb); + cddb = + -(here->B3SOIPDcdsb + here->B3SOIPDcgsb + here->B3SOIPDcbsb); + cdeb = + -(here->B3SOIPDcdeb + here->B3SOIPDcbeb + here->B3SOIPDceeb); + cdT = + -model->B3SOIPDtype * (here->B3SOIPDcgT + here->B3SOIPDcbT + + here->B3SOIPDcdT + here->B3SOIPDceT); + + ceeb = here->B3SOIPDceeb; + ceT = model->B3SOIPDtype * here->B3SOIPDceT; + + cggb = here->B3SOIPDcggb; + cgsb = here->B3SOIPDcgdb; + cgdb = here->B3SOIPDcgsb; + cgT = model->B3SOIPDtype * here->B3SOIPDcgT; + + cbgb = here->B3SOIPDcbgb; + cbsb = here->B3SOIPDcbdb; + cbdb = here->B3SOIPDcbsb; + cbeb = here->B3SOIPDcbeb; + cbT = model->B3SOIPDtype * here->B3SOIPDcbT; + + cTt = here->pParam->B3SOIPDcth; + + gbbg = -here->B3SOIPDgbgs; + gbbb = -here->B3SOIPDgbbs; + gbbp = -here->B3SOIPDgbps; + gbbsp = -here->B3SOIPDgbds; + gbbT = -model->B3SOIPDtype * here->B3SOIPDgbT; + gbbdp = -(gbbg + gbbsp + gbbb + gbbp); + + gddpg = -here->B3SOIPDgjsg; + gddpsp = -here->B3SOIPDgjsd; + gddpb = -here->B3SOIPDgjsb; + gddpT = -model->B3SOIPDtype * here->B3SOIPDgjsT; + gddpdp = -(gddpg + gddpsp + gddpb); + + gsspg = -here->B3SOIPDgjdg; + gsspsp = -here->B3SOIPDgjdd; + gsspb = -here->B3SOIPDgjdb; + gsspT = -model->B3SOIPDtype * here->B3SOIPDgjdT; + gsspdp = -(gsspg + gsspsp + gsspb); + + gppb = -here->B3SOIPDgbpbs; + gppp = -here->B3SOIPDgbpps; + gppT = -model->B3SOIPDtype * here->B3SOIPDgbpT; + gppdp = -(gppb + gppp); + + gTtt = here->B3SOIPDgtempT; + gTtg = here->B3SOIPDgtempg; + gTtb = here->B3SOIPDgtempb; + gTtdp = here->B3SOIPDgtempd; + gTtsp = -(gTtt + gTtg + gTtb + gTtdp); + + gTtg = here->B3SOIPDgtempg; + gTtb = here->B3SOIPDgtempb; + gTtsp = here->B3SOIPDgtempd; + gTtt = here->B3SOIPDgtempT; + gTtdp = -(gTtg + gTtb + gTtsp); + + sxpart = 0.6; + sxpart = 0.4; + dxpart = 0.6; + } + + gdpr = here->B3SOIPDdrainConductance; + gspr = here->B3SOIPDsourceConductance; + gds = here->B3SOIPDgds; + + GSoverlapCap = here->B3SOIPDcgso; + GDoverlapCap = here->B3SOIPDcgdo; + GEoverlapCap = here->pParam->B3SOIPDcgeo; + + EDextrinsicCap = here->B3SOIPDgcde; + ESextrinsicCap = here->B3SOIPDgcse; + 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; + + *(here->B3SOIPDEdpPtr + 1) += xcedb; + *(here->B3SOIPDEspPtr + 1) += xcesb; + *(here->B3SOIPDDPePtr + 1) += xcdeb; + *(here->B3SOIPDSPePtr + 1) += xcseb; + *(here->B3SOIPDEgPtr + 1) += xcegb; + *(here->B3SOIPDGePtr + 1) += xcgeb; + + *(here->B3SOIPDEePtr + 1) += xceeb; + + *(here->B3SOIPDGgPtr + 1) += xcggb; + *(here->B3SOIPDGdpPtr + 1) += xcgdb; + *(here->B3SOIPDGspPtr + 1) += xcgsb; + + *(here->B3SOIPDDPgPtr + 1) += xcdgb; + *(here->B3SOIPDDPdpPtr + 1) += xcddb; + *(here->B3SOIPDDPspPtr + 1) += xcdsb; + + *(here->B3SOIPDSPgPtr + 1) += xcsgb; + *(here->B3SOIPDSPdpPtr + 1) += xcsdb; + *(here->B3SOIPDSPspPtr + 1) += xcssb; + + *(here->B3SOIPDBePtr + 1) += xcbeb; + *(here->B3SOIPDBgPtr + 1) += xcbgb; + *(here->B3SOIPDBdpPtr + 1) += xcbdb; + *(here->B3SOIPDBspPtr + 1) += xcbsb; + + *(here->B3SOIPDEbPtr + 1) -= xcegb + xceeb + xcedb + xcesb; + + *(here->B3SOIPDGbPtr + 1) -= xcggb + xcgdb + xcgsb + xcgeb; + *(here->B3SOIPDDPbPtr + 1) -= xcdgb + xcddb + xcdsb + xcdeb; + *(here->B3SOIPDSPbPtr + 1) -= xcsgb + xcsdb + xcssb + xcseb; + *(here->B3SOIPDBbPtr + 1) -= xcbgb + xcbdb + xcbsb + xcbeb; + + if (selfheat) + { + *(here->B3SOIPDTemptempPtr + 1) += xcTt; + *(here->B3SOIPDDPtempPtr + 1) += xcdT; + *(here->B3SOIPDSPtempPtr + 1) += xcsT; + *(here->B3SOIPDBtempPtr + 1) += xcbT; + *(here->B3SOIPDEtempPtr + 1) += xceT; + *(here->B3SOIPDGtempPtr + 1) += xcgT; + } + + + + *(here->B3SOIPDEePtr) += 0.0; + + *(here->B3SOIPDDPgPtr) += Gm + gddpg; + *(here->B3SOIPDDPdpPtr) += gdpr + gds + gddpdp + RevSum; + *(here->B3SOIPDDPspPtr) -= gds + FwdSum - gddpsp; + *(here->B3SOIPDDPdPtr) -= gdpr; + + *(here->B3SOIPDSPgPtr) -= Gm - gsspg; + *(here->B3SOIPDSPdpPtr) -= gds + RevSum - gsspdp; + *(here->B3SOIPDSPspPtr) += gspr + gds + FwdSum + gsspsp; + *(here->B3SOIPDSPsPtr) -= gspr; + + *(here->B3SOIPDBePtr) += 0; + *(here->B3SOIPDBgPtr) += gbbg; + *(here->B3SOIPDBdpPtr) += gbbdp; + *(here->B3SOIPDBspPtr) += gbbsp; + *(here->B3SOIPDBbPtr) += gbbb; + *(here->B3SOIPDEbPtr) += 0.0; + *(here->B3SOIPDSPbPtr) -= Gmbs - gsspb; + *(here->B3SOIPDDPbPtr) -= (-gddpb - Gmbs); + + if (selfheat) + { + *(here->B3SOIPDDPtempPtr) += GmT + gddpT; + *(here->B3SOIPDSPtempPtr) += -GmT + gsspT; + *(here->B3SOIPDBtempPtr) += gbbT; + + *(here->B3SOIPDTemptempPtr) += + gTtt + 1 / here->pParam->B3SOIPDrth; + *(here->B3SOIPDTempgPtr) += gTtg; + *(here->B3SOIPDTempbPtr) += gTtb; + *(here->B3SOIPDTempdpPtr) += gTtdp; + *(here->B3SOIPDTempspPtr) += gTtsp; + } + + + *(here->B3SOIPDDdPtr) += gdpr; + *(here->B3SOIPDDdpPtr) -= gdpr; + *(here->B3SOIPDSsPtr) += gspr; + *(here->B3SOIPDSspPtr) -= gspr; + + + if (here->B3SOIPDbodyMod == 1) + { + (*(here->B3SOIPDBpPtr) -= gppp); + (*(here->B3SOIPDPbPtr) += gppb); + (*(here->B3SOIPDPpPtr) += gppp); + } + if (here->B3SOIPDdebugMod != 0) + { + *(here->B3SOIPDVbsPtr) += 1; + *(here->B3SOIPDIdsPtr) += 1; + *(here->B3SOIPDIcPtr) += 1; + *(here->B3SOIPDIbsPtr) += 1; + *(here->B3SOIPDIbdPtr) += 1; + *(here->B3SOIPDIiiPtr) += 1; + *(here->B3SOIPDIgidlPtr) += 1; + *(here->B3SOIPDItunPtr) += 1; + *(here->B3SOIPDIbpPtr) += 1; + *(here->B3SOIPDCbgPtr) += 1; + *(here->B3SOIPDCbbPtr) += 1; + *(here->B3SOIPDCbdPtr) += 1; + *(here->B3SOIPDQbfPtr) += 1; + *(here->B3SOIPDQjsPtr) += 1; + *(here->B3SOIPDQjdPtr) += 1; + + } + + } + } + return (OK); +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdask.c b/src/spicelib/devices/bsim3soi_pd/b3soipdask.c new file mode 100644 index 000000000..21e466787 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdask.c @@ -0,0 +1,244 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdask.c 98/5/01 +Modified by Pin Su 99/4/30 +**********/ + + +#include "ngspice.h" +#include +#include +#include "ifsim.h" +#include "cktdefs.h" +#include "devdefs.h" +#include "b3soipddef.h" +#include "sperror.h" +#include "suffix.h" + +int +B3SOIPDask (ckt, inst, which, value, select) + CKTcircuit *ckt; + GENinstance *inst; + int which; + IFvalue *value; + IFvalue *select; +{ + B3SOIPDinstance *here = (B3SOIPDinstance *) inst; + + switch (which) + { + case B3SOIPD_L: + value->rValue = here->B3SOIPDl; + return (OK); + case B3SOIPD_W: + value->rValue = here->B3SOIPDw; + return (OK); + case B3SOIPD_AS: + value->rValue = here->B3SOIPDsourceArea; + return (OK); + case B3SOIPD_AD: + value->rValue = here->B3SOIPDdrainArea; + return (OK); + case B3SOIPD_PS: + value->rValue = here->B3SOIPDsourcePerimeter; + return (OK); + case B3SOIPD_PD: + value->rValue = here->B3SOIPDdrainPerimeter; + return (OK); + case B3SOIPD_NRS: + value->rValue = here->B3SOIPDsourceSquares; + return (OK); + case B3SOIPD_NRD: + value->rValue = here->B3SOIPDdrainSquares; + return (OK); + case B3SOIPD_OFF: + value->iValue = here->B3SOIPDoff; + return (OK); + case B3SOIPD_BJTOFF: + value->iValue = here->B3SOIPDbjtoff; + return (OK); + case B3SOIPD_RTH0: + value->rValue = here->B3SOIPDrth0; + return (OK); + case B3SOIPD_CTH0: + value->rValue = here->B3SOIPDcth0; + return (OK); + case B3SOIPD_NRB: + value->rValue = here->B3SOIPDbodySquares; + return (OK); + + +/* v2.0 release */ + case B3SOIPD_NBC: + value->rValue = here->B3SOIPDnbc; + return (OK); + case B3SOIPD_NSEG: + value->rValue = here->B3SOIPDnseg; + return (OK); + case B3SOIPD_PDBCP: + value->rValue = here->B3SOIPDpdbcp; + return (OK); + case B3SOIPD_PSBCP: + value->rValue = here->B3SOIPDpsbcp; + return (OK); + case B3SOIPD_AGBCP: + value->rValue = here->B3SOIPDagbcp; + return (OK); + case B3SOIPD_AEBCP: + value->rValue = here->B3SOIPDaebcp; + return (OK); + case B3SOIPD_VBSUSR: + value->rValue = here->B3SOIPDvbsusr; + return (OK); + case B3SOIPD_TNODEOUT: + value->iValue = here->B3SOIPDtnodeout; + return (OK); + + + case B3SOIPD_IC_VBS: + value->rValue = here->B3SOIPDicVBS; + return (OK); + case B3SOIPD_IC_VDS: + value->rValue = here->B3SOIPDicVDS; + return (OK); + case B3SOIPD_IC_VGS: + value->rValue = here->B3SOIPDicVGS; + return (OK); + case B3SOIPD_IC_VES: + value->rValue = here->B3SOIPDicVES; + return (OK); + case B3SOIPD_IC_VPS: + value->rValue = here->B3SOIPDicVPS; + return (OK); + case B3SOIPD_DNODE: + value->iValue = here->B3SOIPDdNode; + return (OK); + case B3SOIPD_GNODE: + value->iValue = here->B3SOIPDgNode; + return (OK); + case B3SOIPD_SNODE: + value->iValue = here->B3SOIPDsNode; + return (OK); + case B3SOIPD_BNODE: + value->iValue = here->B3SOIPDbNode; + return (OK); + case B3SOIPD_ENODE: + value->iValue = here->B3SOIPDeNode; + return (OK); + case B3SOIPD_DNODEPRIME: + value->iValue = here->B3SOIPDdNodePrime; + return (OK); + case B3SOIPD_SNODEPRIME: + value->iValue = here->B3SOIPDsNodePrime; + return (OK); + case B3SOIPD_SOURCECONDUCT: + value->rValue = here->B3SOIPDsourceConductance; + return (OK); + case B3SOIPD_DRAINCONDUCT: + value->rValue = here->B3SOIPDdrainConductance; + return (OK); + case B3SOIPD_VBD: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDvbd); + return (OK); + case B3SOIPD_VBS: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDvbs); + return (OK); + case B3SOIPD_VGS: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDvgs); + return (OK); + case B3SOIPD_VES: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDves); + return (OK); + case B3SOIPD_VDS: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDvds); + return (OK); + case B3SOIPD_CD: + value->rValue = here->B3SOIPDcd; + return (OK); + case B3SOIPD_CBS: + value->rValue = here->B3SOIPDcjs; + return (OK); + case B3SOIPD_CBD: + value->rValue = here->B3SOIPDcjd; + return (OK); + case B3SOIPD_GM: + value->rValue = here->B3SOIPDgm; + return (OK); + case B3SOIPD_GMID: + value->rValue = here->B3SOIPDgm / here->B3SOIPDcd; + return (OK); + case B3SOIPD_GDS: + value->rValue = here->B3SOIPDgds; + return (OK); + case B3SOIPD_GMBS: + value->rValue = here->B3SOIPDgmbs; + return (OK); + case B3SOIPD_GBD: + value->rValue = here->B3SOIPDgjdb; + return (OK); + case B3SOIPD_GBS: + value->rValue = here->B3SOIPDgjsb; + return (OK); + case B3SOIPD_QB: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDqb); + return (OK); + case B3SOIPD_CQB: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDcqb); + return (OK); + case B3SOIPD_QG: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDqg); + return (OK); + case B3SOIPD_CQG: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDcqg); + return (OK); + case B3SOIPD_QD: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDqd); + return (OK); + case B3SOIPD_CQD: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDcqd); + return (OK); + case B3SOIPD_CGG: + value->rValue = here->B3SOIPDcggb; + return (OK); + case B3SOIPD_CGD: + value->rValue = here->B3SOIPDcgdb; + return (OK); + case B3SOIPD_CGS: + value->rValue = here->B3SOIPDcgsb; + return (OK); + case B3SOIPD_CDG: + value->rValue = here->B3SOIPDcdgb; + return (OK); + case B3SOIPD_CDD: + value->rValue = here->B3SOIPDcddb; + return (OK); + case B3SOIPD_CDS: + value->rValue = here->B3SOIPDcdsb; + return (OK); + case B3SOIPD_CBG: + value->rValue = here->B3SOIPDcbgb; + return (OK); + case B3SOIPD_CBDB: + value->rValue = here->B3SOIPDcbdb; + return (OK); + case B3SOIPD_CBSB: + value->rValue = here->B3SOIPDcbsb; + return (OK); + case B3SOIPD_VON: + value->rValue = here->B3SOIPDvon; + return (OK); + case B3SOIPD_VDSAT: + value->rValue = here->B3SOIPDvdsat; + return (OK); + case B3SOIPD_QBS: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDqbs); + return (OK); + case B3SOIPD_QBD: + value->rValue = *(ckt->CKTstate0 + here->B3SOIPDqbd); + return (OK); + default: + return (E_BADPARM); + } + /* NOTREACHED */ +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdcheck.c b/src/spicelib/devices/bsim3soi_pd/b3soipdcheck.c new file mode 100644 index 000000000..2af4f1879 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdcheck.c @@ -0,0 +1,913 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdcheck.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 +**********/ + + +#include "ngspice.h" +#include +#include +#include "cktdefs.h" +#include "b3soipddef.h" +#include "trandefs.h" +#include "const.h" +#include "sperror.h" +#include "devdefs.h" +#include "suffix.h" + +int +B3SOIPDcheckModel (model, here, ckt) + register B3SOIPDmodel *model; + register B3SOIPDinstance *here; + CKTcircuit *ckt; +{ + struct b3soipdSizeDependParam *pParam; + int Fatal_Flag = 0; + FILE *fplog; + + if ((fplog = fopen ("b3soipdv1check.log", "w")) != NULL) + { + pParam = here->pParam; + fprintf (fplog, "B3SOIPDV3 Parameter Check\n"); + fprintf (fplog, "Model = %s\n", model->B3SOIPDmodName); + fprintf (fplog, "W = %g, L = %g\n", here->B3SOIPDw, here->B3SOIPDl); + + + if (pParam->B3SOIPDnlx < -pParam->B3SOIPDleff) + { + fprintf (fplog, "Fatal: Nlx = %g is less than -Leff.\n", + pParam->B3SOIPDnlx); + printf ("Fatal: Nlx = %g is less than -Leff.\n", + pParam->B3SOIPDnlx); + Fatal_Flag = 1; + } + + if (model->B3SOIPDtox <= 0.0) + { + fprintf (fplog, "Fatal: Tox = %g is not positive.\n", + model->B3SOIPDtox); + printf ("Fatal: Tox = %g is not positive.\n", model->B3SOIPDtox); + Fatal_Flag = 1; + } + + if (model->B3SOIPDtbox <= 0.0) + { + fprintf (fplog, "Fatal: Tbox = %g is not positive.\n", + model->B3SOIPDtbox); + printf ("Fatal: Tbox = %g is not positive.\n", model->B3SOIPDtbox); + Fatal_Flag = 1; + } + + if (pParam->B3SOIPDnpeak <= 0.0) + { + fprintf (fplog, "Fatal: Nch = %g is not positive.\n", + pParam->B3SOIPDnpeak); + printf ("Fatal: Nch = %g is not positive.\n", pParam->B3SOIPDnpeak); + Fatal_Flag = 1; + } + if (pParam->B3SOIPDngate < 0.0) + { + fprintf (fplog, "Fatal: Ngate = %g is not positive.\n", + pParam->B3SOIPDngate); + printf ("Fatal: Ngate = %g Ngate is not positive.\n", + pParam->B3SOIPDngate); + Fatal_Flag = 1; + } + if (pParam->B3SOIPDngate > 1.e25) + { + fprintf (fplog, "Fatal: Ngate = %g is too high.\n", + pParam->B3SOIPDngate); + printf ("Fatal: Ngate = %g Ngate is too high\n", + pParam->B3SOIPDngate); + Fatal_Flag = 1; + } + + if (pParam->B3SOIPDdvt1 < 0.0) + { + fprintf (fplog, "Fatal: Dvt1 = %g is negative.\n", + pParam->B3SOIPDdvt1); + printf ("Fatal: Dvt1 = %g is negative.\n", pParam->B3SOIPDdvt1); + Fatal_Flag = 1; + } + + if (pParam->B3SOIPDdvt1w < 0.0) + { + fprintf (fplog, "Fatal: Dvt1w = %g is negative.\n", + pParam->B3SOIPDdvt1w); + printf ("Fatal: Dvt1w = %g is negative.\n", pParam->B3SOIPDdvt1w); + Fatal_Flag = 1; + } + + if (pParam->B3SOIPDw0 == -pParam->B3SOIPDweff) + { + 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->B3SOIPDdsub < 0.0) + { + fprintf (fplog, "Fatal: Dsub = %g is negative.\n", + pParam->B3SOIPDdsub); + printf ("Fatal: Dsub = %g is negative.\n", pParam->B3SOIPDdsub); + Fatal_Flag = 1; + } + if (pParam->B3SOIPDb1 == -pParam->B3SOIPDweff) + { + 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->B3SOIPDu0temp <= 0.0) + { + fprintf (fplog, + "Fatal: u0 at current temperature = %g is not positive.\n", + pParam->B3SOIPDu0temp); + printf ("Fatal: u0 at current temperature = %g is not positive.\n", + pParam->B3SOIPDu0temp); + Fatal_Flag = 1; + } + +/* Check delta parameter */ + if (pParam->B3SOIPDdelta < 0.0) + { + fprintf (fplog, "Fatal: Delta = %g is less than zero.\n", + pParam->B3SOIPDdelta); + printf ("Fatal: Delta = %g is less than zero.\n", + pParam->B3SOIPDdelta); + Fatal_Flag = 1; + } + + if (pParam->B3SOIPDvsattemp <= 0.0) + { + fprintf (fplog, + "Fatal: Vsat at current temperature = %g is not positive.\n", + pParam->B3SOIPDvsattemp); + printf + ("Fatal: Vsat at current temperature = %g is not positive.\n", + pParam->B3SOIPDvsattemp); + Fatal_Flag = 1; + } +/* Check Rout parameters */ + if (pParam->B3SOIPDpclm <= 0.0) + { + fprintf (fplog, "Fatal: Pclm = %g is not positive.\n", + pParam->B3SOIPDpclm); + printf ("Fatal: Pclm = %g is not positive.\n", pParam->B3SOIPDpclm); + Fatal_Flag = 1; + } + + if (pParam->B3SOIPDdrout < 0.0) + { + fprintf (fplog, "Fatal: Drout = %g is negative.\n", + pParam->B3SOIPDdrout); + printf ("Fatal: Drout = %g is negative.\n", pParam->B3SOIPDdrout); + Fatal_Flag = 1; + } + if (model->B3SOIPDunitLengthGateSidewallJctCap > 0.0) + { + if (here->B3SOIPDdrainPerimeter < pParam->B3SOIPDweff) + { + fprintf (fplog, "Warning: Pd = %g is less than W.\n", + here->B3SOIPDdrainPerimeter); + printf ("Warning: Pd = %g is less than W.\n", + here->B3SOIPDdrainPerimeter); + here->B3SOIPDdrainPerimeter = pParam->B3SOIPDweff; + } + if (here->B3SOIPDsourcePerimeter < pParam->B3SOIPDweff) + { + fprintf (fplog, "Warning: Ps = %g is less than W.\n", + here->B3SOIPDsourcePerimeter); + printf ("Warning: Ps = %g is less than W.\n", + here->B3SOIPDsourcePerimeter); + here->B3SOIPDsourcePerimeter = pParam->B3SOIPDweff; + } + } +/* Check capacitance parameters */ + if (pParam->B3SOIPDclc < 0.0) + { + fprintf (fplog, "Fatal: Clc = %g is negative.\n", + pParam->B3SOIPDclc); + printf ("Fatal: Clc = %g is negative.\n", pParam->B3SOIPDclc); + Fatal_Flag = 1; + } + if (model->B3SOIPDparamChk == 1) + { +/* Check L and W parameters */ + if (pParam->B3SOIPDleff <= 5.0e-8) + { + fprintf (fplog, "Warning: Leff = %g may be too small.\n", + pParam->B3SOIPDleff); + printf ("Warning: Leff = %g may be too small.\n", + pParam->B3SOIPDleff); + } + + if (pParam->B3SOIPDleffCV <= 5.0e-8) + { + fprintf (fplog, "Warning: Leff for CV = %g may be too small.\n", + pParam->B3SOIPDleffCV); + printf ("Warning: Leff for CV = %g may be too small.\n", + pParam->B3SOIPDleffCV); + } + + if (pParam->B3SOIPDweff <= 1.0e-7) + { + fprintf (fplog, "Warning: Weff = %g may be too small.\n", + pParam->B3SOIPDweff); + printf ("Warning: Weff = %g may be too small.\n", + pParam->B3SOIPDweff); + } + + if (pParam->B3SOIPDweffCV <= 1.0e-7) + { + fprintf (fplog, "Warning: Weff for CV = %g may be too small.\n", + pParam->B3SOIPDweffCV); + printf ("Warning: Weff for CV = %g may be too small.\n", + pParam->B3SOIPDweffCV); + } + +/* Check threshold voltage parameters */ + if (pParam->B3SOIPDnlx < 0.0) + { + fprintf (fplog, "Warning: Nlx = %g is negative.\n", + pParam->B3SOIPDnlx); + printf ("Warning: Nlx = %g is negative.\n", pParam->B3SOIPDnlx); + } + if (model->B3SOIPDtox < 1.0e-9) + { + fprintf (fplog, "Warning: Tox = %g is less than 10A.\n", + model->B3SOIPDtox); + printf ("Warning: Tox = %g is less than 10A.\n", + model->B3SOIPDtox); + } + + if (pParam->B3SOIPDnpeak <= 1.0e15) + { + fprintf (fplog, "Warning: Nch = %g may be too small.\n", + pParam->B3SOIPDnpeak); + printf ("Warning: Nch = %g may be too small.\n", + pParam->B3SOIPDnpeak); + } + else if (pParam->B3SOIPDnpeak >= 1.0e21) + { + fprintf (fplog, "Warning: Nch = %g may be too large.\n", + pParam->B3SOIPDnpeak); + printf ("Warning: Nch = %g may be too large.\n", + pParam->B3SOIPDnpeak); + } + + if (fabs (pParam->B3SOIPDnsub) >= 1.0e21) + { + fprintf (fplog, "Warning: Nsub = %g may be too large.\n", + pParam->B3SOIPDnsub); + printf ("Warning: Nsub = %g may be too large.\n", + pParam->B3SOIPDnsub); + } + + if ((pParam->B3SOIPDngate > 0.0) && (pParam->B3SOIPDngate <= 1.e18)) + { + fprintf (fplog, + "Warning: Ngate = %g is less than 1.E18cm^-3.\n", + pParam->B3SOIPDngate); + printf ("Warning: Ngate = %g is less than 1.E18cm^-3.\n", + pParam->B3SOIPDngate); + } + + if (pParam->B3SOIPDdvt0 < 0.0) + { + fprintf (fplog, "Warning: Dvt0 = %g is negative.\n", + pParam->B3SOIPDdvt0); + printf ("Warning: Dvt0 = %g is negative.\n", + pParam->B3SOIPDdvt0); + } + + if (fabs (1.0e-6 / (pParam->B3SOIPDw0 + pParam->B3SOIPDweff)) > + 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->B3SOIPDnfactor < 0.0) + { + fprintf (fplog, "Warning: Nfactor = %g is negative.\n", + pParam->B3SOIPDnfactor); + printf ("Warning: Nfactor = %g is negative.\n", + pParam->B3SOIPDnfactor); + } + if (pParam->B3SOIPDcdsc < 0.0) + { + fprintf (fplog, "Warning: Cdsc = %g is negative.\n", + pParam->B3SOIPDcdsc); + printf ("Warning: Cdsc = %g is negative.\n", + pParam->B3SOIPDcdsc); + } + if (pParam->B3SOIPDcdscd < 0.0) + { + fprintf (fplog, "Warning: Cdscd = %g is negative.\n", + pParam->B3SOIPDcdscd); + printf ("Warning: Cdscd = %g is negative.\n", + pParam->B3SOIPDcdscd); + } +/* Check DIBL parameters */ + if (pParam->B3SOIPDeta0 < 0.0) + { + fprintf (fplog, "Warning: Eta0 = %g is negative.\n", + pParam->B3SOIPDeta0); + printf ("Warning: Eta0 = %g is negative.\n", + pParam->B3SOIPDeta0); + } + +/* Check Abulk parameters */ + if (fabs (1.0e-6 / (pParam->B3SOIPDb1 + pParam->B3SOIPDweff)) > + 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->B3SOIPDa2 < 0.01) + { + fprintf (fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", + pParam->B3SOIPDa2); + printf ("Warning: A2 = %g is too small. Set to 0.01.\n", + pParam->B3SOIPDa2); + pParam->B3SOIPDa2 = 0.01; + } + else if (pParam->B3SOIPDa2 > 1.0) + { + fprintf (fplog, + "Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n", + pParam->B3SOIPDa2); + printf + ("Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n", + pParam->B3SOIPDa2); + pParam->B3SOIPDa2 = 1.0; + pParam->B3SOIPDa1 = 0.0; + + } + + if (pParam->B3SOIPDrdsw < 0.0) + { + fprintf (fplog, + "Warning: Rdsw = %g is negative. Set to zero.\n", + pParam->B3SOIPDrdsw); + printf ("Warning: Rdsw = %g is negative. Set to zero.\n", + pParam->B3SOIPDrdsw); + pParam->B3SOIPDrdsw = 0.0; + pParam->B3SOIPDrds0 = 0.0; + } + else if ((pParam->B3SOIPDrds0 > 0.0) + && (pParam->B3SOIPDrds0 < 0.001)) + { + fprintf (fplog, + "Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n", + pParam->B3SOIPDrds0); + printf + ("Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n", + pParam->B3SOIPDrds0); + pParam->B3SOIPDrds0 = 0.0; + } + if (pParam->B3SOIPDvsattemp < 1.0e3) + { + fprintf (fplog, + "Warning: Vsat at current temperature = %g may be too small.\n", + pParam->B3SOIPDvsattemp); + printf + ("Warning: Vsat at current temperature = %g may be too small.\n", + pParam->B3SOIPDvsattemp); + } + + if (pParam->B3SOIPDpdibl1 < 0.0) + { + fprintf (fplog, "Warning: Pdibl1 = %g is negative.\n", + pParam->B3SOIPDpdibl1); + printf ("Warning: Pdibl1 = %g is negative.\n", + pParam->B3SOIPDpdibl1); + } + if (pParam->B3SOIPDpdibl2 < 0.0) + { + fprintf (fplog, "Warning: Pdibl2 = %g is negative.\n", + pParam->B3SOIPDpdibl2); + printf ("Warning: Pdibl2 = %g is negative.\n", + pParam->B3SOIPDpdibl2); + } +/* Check overlap capacitance parameters */ + if (model->B3SOIPDcgdo < 0.0) + { + fprintf (fplog, + "Warning: cgdo = %g is negative. Set to zero.\n", + model->B3SOIPDcgdo); + printf ("Warning: cgdo = %g is negative. Set to zero.\n", + model->B3SOIPDcgdo); + model->B3SOIPDcgdo = 0.0; + } + if (model->B3SOIPDcgso < 0.0) + { + fprintf (fplog, + "Warning: cgso = %g is negative. Set to zero.\n", + model->B3SOIPDcgso); + printf ("Warning: cgso = %g is negative. Set to zero.\n", + model->B3SOIPDcgso); + model->B3SOIPDcgso = 0.0; + } + if (model->B3SOIPDcgeo < 0.0) + { + fprintf (fplog, + "Warning: cgeo = %g is negative. Set to zero.\n", + model->B3SOIPDcgeo); + printf ("Warning: cgeo = %g is negative. Set to zero.\n", + model->B3SOIPDcgeo); + model->B3SOIPDcgeo = 0.0; + } + + if (model->B3SOIPDntun < 0.0) + { + fprintf (fplog, "Warning: Ntun = %g is negative.\n", + model->B3SOIPDntun); + printf ("Warning: Ntun = %g is negative.\n", + model->B3SOIPDntun); + } + + if (model->B3SOIPDndiode < 0.0) + { + fprintf (fplog, "Warning: Ndiode = %g is negative.\n", + model->B3SOIPDndiode); + printf ("Warning: Ndiode = %g is negative.\n", + model->B3SOIPDndiode); + } + + if (model->B3SOIPDisbjt < 0.0) + { + fprintf (fplog, "Warning: Isbjt = %g is negative.\n", + model->B3SOIPDisbjt); + printf ("Warning: Isbjt = %g is negative.\n", + model->B3SOIPDisbjt); + } + + if (model->B3SOIPDisdif < 0.0) + { + fprintf (fplog, "Warning: Isdif = %g is negative.\n", + model->B3SOIPDisdif); + printf ("Warning: Isdif = %g is negative.\n", + model->B3SOIPDisdif); + } + + if (model->B3SOIPDisrec < 0.0) + { + fprintf (fplog, "Warning: Isrec = %g is negative.\n", + model->B3SOIPDisrec); + printf ("Warning: Isrec = %g is negative.\n", + model->B3SOIPDisrec); + } + + if (model->B3SOIPDistun < 0.0) + { + fprintf (fplog, "Warning: Istun = %g is negative.\n", + model->B3SOIPDistun); + printf ("Warning: Istun = %g is negative.\n", + model->B3SOIPDistun); + } + + if (model->B3SOIPDtt < 0.0) + { + fprintf (fplog, "Warning: Tt = %g is negative.\n", + model->B3SOIPDtt); + printf ("Warning: Tt = %g is negative.\n", model->B3SOIPDtt); + } + + if (model->B3SOIPDcsdmin < 0.0) + { + fprintf (fplog, "Warning: Csdmin = %g is negative.\n", + model->B3SOIPDcsdmin); + printf ("Warning: Csdmin = %g is negative.\n", + model->B3SOIPDcsdmin); + } + + if (model->B3SOIPDcsdesw < 0.0) + { + fprintf (fplog, "Warning: Csdesw = %g is negative.\n", + model->B3SOIPDcsdesw); + printf ("Warning: Csdesw = %g is negative.\n", + model->B3SOIPDcsdesw); + } + + if (model->B3SOIPDasd < 0.0) + { + fprintf (fplog, "Warning: Asd = %g should be within (0, 1).\n", + model->B3SOIPDasd); + printf ("Warning: Asd = %g should be within (0, 1).\n", + model->B3SOIPDasd); + } + + if (model->B3SOIPDrth0 < 0.0) + { + fprintf (fplog, "Warning: Rth0 = %g is negative.\n", + model->B3SOIPDrth0); + printf ("Warning: Rth0 = %g is negative.\n", + model->B3SOIPDrth0); + } + + if (model->B3SOIPDcth0 < 0.0) + { + fprintf (fplog, "Warning: Cth0 = %g is negative.\n", + model->B3SOIPDcth0); + printf ("Warning: Cth0 = %g is negative.\n", + model->B3SOIPDcth0); + } + + if (model->B3SOIPDrbody < 0.0) + { + fprintf (fplog, "Warning: Rbody = %g is negative.\n", + model->B3SOIPDrbody); + printf ("Warning: Rbody = %g is negative.\n", + model->B3SOIPDrbody); + } + + if (model->B3SOIPDrbsh < 0.0) + { + fprintf (fplog, "Warning: Rbsh = %g is negative.\n", + model->B3SOIPDrbsh); + printf ("Warning: Rbsh = %g is negative.\n", + model->B3SOIPDrbsh); + } + + +/* v2.2 release */ + if (model->B3SOIPDwth0 < 0.0) + { + fprintf (fplog, "Warning: WTH0 = %g is negative.\n", + model->B3SOIPDwth0); + printf ("Warning: Wth0 = %g is negative.\n", + model->B3SOIPDwth0); + } + if (model->B3SOIPDrhalo < 0.0) + { + fprintf (fplog, "Warning: RHALO = %g is negative.\n", + model->B3SOIPDrhalo); + printf ("Warning: Rhalo = %g is negative.\n", + model->B3SOIPDrhalo); + } + if (model->B3SOIPDntox < 0.0) + { + fprintf (fplog, "Warning: NTOX = %g is negative.\n", + model->B3SOIPDntox); + printf ("Warning: Ntox = %g is negative.\n", + model->B3SOIPDntox); + } + if (model->B3SOIPDtoxref < 0.0) + { + fprintf (fplog, "Warning: TOXREF = %g is negative.\n", + model->B3SOIPDtoxref); + printf ("Warning: Toxref = %g is negative.\n", + model->B3SOIPDtoxref); + Fatal_Flag = 1; + } + if (model->B3SOIPDebg < 0.0) + { + fprintf (fplog, "Warning: EBG = %g is negative.\n", + model->B3SOIPDebg); + printf ("Warning: Ebg = %g is negative.\n", model->B3SOIPDebg); + } + if (model->B3SOIPDnevb < 0.0) + { + fprintf (fplog, "Warning: NEVB = %g is negative.\n", + model->B3SOIPDnevb); + printf ("Warning: Nevb = %g is negative.\n", + model->B3SOIPDnevb); + } + if (model->B3SOIPDalphaGB1 < 0.0) + { + fprintf (fplog, "Warning: ALPHAGB1 = %g is negative.\n", + model->B3SOIPDalphaGB1); + printf ("Warning: AlphaGB1 = %g is negative.\n", + model->B3SOIPDalphaGB1); + } + if (model->B3SOIPDbetaGB1 < 0.0) + { + fprintf (fplog, "Warning: BETAGB1 = %g is negative.\n", + model->B3SOIPDbetaGB1); + printf ("Warning: BetaGB1 = %g is negative.\n", + model->B3SOIPDbetaGB1); + } + if (model->B3SOIPDvgb1 < 0.0) + { + fprintf (fplog, "Warning: VGB1 = %g is negative.\n", + model->B3SOIPDvgb1); + printf ("Warning: Vgb1 = %g is negative.\n", + model->B3SOIPDvgb1); + } + if (model->B3SOIPDnecb < 0.0) + { + fprintf (fplog, "Warning: NECB = %g is negative.\n", + model->B3SOIPDnecb); + printf ("Warning: Necb = %g is negative.\n", + model->B3SOIPDnecb); + } + if (model->B3SOIPDalphaGB2 < 0.0) + { + fprintf (fplog, "Warning: ALPHAGB2 = %g is negative.\n", + model->B3SOIPDalphaGB2); + printf ("Warning: AlphaGB2 = %g is negative.\n", + model->B3SOIPDalphaGB2); + } + if (model->B3SOIPDbetaGB2 < 0.0) + { + fprintf (fplog, "Warning: BETAGB2 = %g is negative.\n", + model->B3SOIPDbetaGB2); + printf ("Warning: BetaGB2 = %g is negative.\n", + model->B3SOIPDbetaGB2); + } + if (model->B3SOIPDvgb2 < 0.0) + { + fprintf (fplog, "Warning: VGB2 = %g is negative.\n", + model->B3SOIPDvgb2); + printf ("Warning: Vgb2 = %g is negative.\n", + model->B3SOIPDvgb2); + } + if (model->B3SOIPDtoxqm <= 0.0) + { + fprintf (fplog, "Fatal: Toxqm = %g is not positive.\n", + model->B3SOIPDtoxqm); + printf ("Fatal: Toxqm = %g is not positive.\n", + model->B3SOIPDtoxqm); + Fatal_Flag = 1; + } + if (model->B3SOIPDvoxh < 0.0) + { + fprintf (fplog, "Warning: Voxh = %g is negative.\n", + model->B3SOIPDvoxh); + printf ("Warning: Voxh = %g is negative.\n", + model->B3SOIPDvoxh); + } + if (model->B3SOIPDdeltavox <= 0.0) + { + fprintf (fplog, "Fatal: Deltavox = %g is not positive.\n", + model->B3SOIPDdeltavox); + printf ("Fatal: Deltavox = %g is not positive.\n", + model->B3SOIPDdeltavox); + } + + +/* v2.0 release */ + if (model->B3SOIPDk1w1 < 0.0) + { + fprintf (fplog, "Warning: K1W1 = %g is negative.\n", + model->B3SOIPDk1w1); + printf ("Warning: K1w1 = %g is negative.\n", + model->B3SOIPDk1w1); + } + if (model->B3SOIPDk1w2 < 0.0) + { + fprintf (fplog, "Warning: K1W2 = %g is negative.\n", + model->B3SOIPDk1w2); + printf ("Warning: K1w2 = %g is negative.\n", + model->B3SOIPDk1w2); + } + if (model->B3SOIPDketas < 0.0) + { + fprintf (fplog, "Warning: KETAS = %g is negative.\n", + model->B3SOIPDketas); + printf ("Warning: Ketas = %g is negative.\n", + model->B3SOIPDketas); + } + if (model->B3SOIPDdwbc < 0.0) + { + fprintf (fplog, "Warning: DWBC = %g is negative.\n", + model->B3SOIPDdwbc); + printf ("Warning: Dwbc = %g is negative.\n", + model->B3SOIPDdwbc); + } + if (model->B3SOIPDbeta0 < 0.0) + { + fprintf (fplog, "Warning: BETA0 = %g is negative.\n", + model->B3SOIPDbeta0); + printf ("Warning: Beta0 = %g is negative.\n", + model->B3SOIPDbeta0); + } + if (model->B3SOIPDbeta1 < 0.0) + { + fprintf (fplog, "Warning: BETA1 = %g is negative.\n", + model->B3SOIPDbeta1); + printf ("Warning: Beta1 = %g is negative.\n", + model->B3SOIPDbeta1); + } + if (model->B3SOIPDbeta2 < 0.0) + { + fprintf (fplog, "Warning: BETA2 = %g is negative.\n", + model->B3SOIPDbeta2); + printf ("Warning: Beta2 = %g is negative.\n", + model->B3SOIPDbeta2); + } + if (model->B3SOIPDtii < 0.0) + { + fprintf (fplog, "Warning: TII = %g is negative.\n", + model->B3SOIPDtii); + printf ("Warning: Tii = %g is negative.\n", model->B3SOIPDtii); + } + if (model->B3SOIPDlii < 0.0) + { + fprintf (fplog, "Warning: LII = %g is negative.\n", + model->B3SOIPDlii); + printf ("Warning: Lii = %g is negative.\n", model->B3SOIPDlii); + } + if (model->B3SOIPDsii1 < 0.0) + { + fprintf (fplog, "Warning: SII1 = %g is negative.\n", + model->B3SOIPDsii1); + printf ("Warning: Sii1 = %g is negative.\n", + model->B3SOIPDsii1); + } + if (model->B3SOIPDsii2 < 0.0) + { + fprintf (fplog, "Warning: SII2 = %g is negative.\n", + model->B3SOIPDsii2); + printf ("Warning: Sii2 = %g is negative.\n", + model->B3SOIPDsii1); + } + if (model->B3SOIPDsiid < 0.0) + { + fprintf (fplog, "Warning: SIID = %g is negative.\n", + model->B3SOIPDsiid); + printf ("Warning: Siid = %g is negative.\n", + model->B3SOIPDsiid); + } + if (model->B3SOIPDfbjtii < 0.0) + { + fprintf (fplog, "Warning: FBJTII = %g is negative.\n", + model->B3SOIPDfbjtii); + printf ("Warning: fbjtii = %g is negative.\n", + model->B3SOIPDfbjtii); + } + if (model->B3SOIPDvrec0 < 0.0) + { + fprintf (fplog, "Warning: VREC0 = %g is negative.\n", + model->B3SOIPDvrec0); + printf ("Warning: Vrec0 = %g is negative.\n", + model->B3SOIPDvrec0); + } + if (model->B3SOIPDvtun0 < 0.0) + { + fprintf (fplog, "Warning: VTUN0 = %g is negative.\n", + model->B3SOIPDvtun0); + printf ("Warning: Vtun0 = %g is negative.\n", + model->B3SOIPDvtun0); + } + if (model->B3SOIPDnbjt < 0.0) + { + fprintf (fplog, "Warning: NBJT = %g is negative.\n", + model->B3SOIPDnbjt); + printf ("Warning: Nbjt = %g is negative.\n", + model->B3SOIPDnbjt); + } + if (model->B3SOIPDaely < 0.0) + { + fprintf (fplog, "Warning: AELY = %g is negative.\n", + model->B3SOIPDaely); + printf ("Warning: Aely = %g is negative.\n", + model->B3SOIPDaely); + } + if (model->B3SOIPDahli < 0.0) + { + fprintf (fplog, "Warning: AHLI = %g is negative.\n", + model->B3SOIPDahli); + printf ("Warning: Ahli = %g is negative.\n", + model->B3SOIPDahli); + } + if (model->B3SOIPDrbody < 0.0) + { + fprintf (fplog, "Warning: RBODY = %g is negative.\n", + model->B3SOIPDrbody); + printf ("Warning: Rbody = %g is negative.\n", + model->B3SOIPDrbody); + } + if (model->B3SOIPDrbsh < 0.0) + { + fprintf (fplog, "Warning: RBSH = %g is negative.\n", + model->B3SOIPDrbsh); + printf ("Warning: Rbsh = %g is negative.\n", + model->B3SOIPDrbsh); + } + if (model->B3SOIPDntrecf < 0.0) + { + fprintf (fplog, "Warning: NTRECF = %g is negative.\n", + model->B3SOIPDntrecf); + printf ("Warning: Ntrecf = %g is negative.\n", + model->B3SOIPDntrecf); + } + if (model->B3SOIPDntrecr < 0.0) + { + fprintf (fplog, "Warning: NTRECR = %g is negative.\n", + model->B3SOIPDntrecr); + printf ("Warning: Ntrecr = %g is negative.\n", + model->B3SOIPDntrecr); + } + if (model->B3SOIPDndif < 0.0) + { + fprintf (fplog, "Warning: NDIF = %g is negative.\n", + model->B3SOIPDndif); + printf ("Warning: Ndif = %g is negative.\n", + model->B3SOIPDndif); + } + if (model->B3SOIPDtcjswg < 0.0) + { + fprintf (fplog, "Warning: TCJSWG = %g is negative.\n", + model->B3SOIPDtcjswg); + printf ("Warning: Tcjswg = %g is negative.\n", + model->B3SOIPDtcjswg); + } + if (model->B3SOIPDtpbswg < 0.0) + { + fprintf (fplog, "Warning: TPBSWG = %g is negative.\n", + model->B3SOIPDtpbswg); + printf ("Warning: Tpbswg = %g is negative.\n", + model->B3SOIPDtpbswg); + } + if ((model->B3SOIPDacde < 0.4) || (model->B3SOIPDacde > 1.6)) + { + fprintf (fplog, "Warning: ACDE = %g is out of range.\n", + model->B3SOIPDacde); + printf ("Warning: Acde = %g is out of range.\n", + model->B3SOIPDacde); + } + if ((model->B3SOIPDmoin < 5.0) || (model->B3SOIPDmoin > 25.0)) + { + fprintf (fplog, "Warning: MOIN = %g is out of range.\n", + model->B3SOIPDmoin); + printf ("Warning: Moin = %g is out of range.\n", + model->B3SOIPDmoin); + } + if (model->B3SOIPDdlbg < 0.0) + { + fprintf (fplog, "Warning: DLBG = %g is negative.\n", + model->B3SOIPDdlbg); + printf ("Warning: dlbg = %g is negative.\n", + model->B3SOIPDdlbg); + } + + + if (model->B3SOIPDagidl < 0.0) + { + fprintf (fplog, "Warning: AGIDL = %g is negative.\n", + model->B3SOIPDagidl); + printf ("Warning: Agidl = %g is negative.\n", + model->B3SOIPDagidl); + } + if (model->B3SOIPDbgidl < 0.0) + { + fprintf (fplog, "Warning: BGIDL = %g is negative.\n", + model->B3SOIPDbgidl); + printf ("Warning: Bgidl = %g is negative.\n", + model->B3SOIPDbgidl); + } + if (model->B3SOIPDngidl < 0.0) + { + fprintf (fplog, "Warning: NGIDL = %g is negative.\n", + model->B3SOIPDngidl); + printf ("Warning: Ngidl = %g is negative.\n", + model->B3SOIPDngidl); + } + if (model->B3SOIPDesatii < 0.0) + { + fprintf (fplog, + "Warning: Esatii = %g should be within positive.\n", + model->B3SOIPDesatii); + printf ("Warning: Esatii = %g should be within (0, 1).\n", + model->B3SOIPDesatii); + } + + + if (model->B3SOIPDxj > model->B3SOIPDtsi) + { + fprintf (fplog, "Warning: Xj = %g is thicker than Tsi = %g.\n", + model->B3SOIPDxj, model->B3SOIPDtsi); + printf ("Warning: Xj = %g is thicker than Tsi = %g.\n", + model->B3SOIPDxj, model->B3SOIPDtsi); + } + + if (model->B3SOIPDcapMod < 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_pd/b3soipdcvtest.c b/src/spicelib/devices/bsim3soi_pd/b3soipdcvtest.c new file mode 100644 index 000000000..ebac25f76 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdcvtest.c @@ -0,0 +1,95 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdcvtest.c 98/5/01 +**********/ + + +#include "ngspice.h" +#include +#include +#include "cktdefs.h" +#include "b3soipddef.h" +#include "trandefs.h" +#include "const.h" +#include "devdefs.h" +#include "sperror.h" +#include "suffix.h" + + +int +B3SOIPDconvTest (inModel, ckt) + GENmodel *inModel; + register CKTcircuit *ckt; +{ + register B3SOIPDmodel *model = (B3SOIPDmodel *) inModel; + register B3SOIPDinstance *here; + double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds; + double cbd, cbhat, cbs, cd, cdhat, tol, vgd, vgdo, vgs; + + /* loop through all the B3SOIPD device models */ + for (; model != NULL; model = model->B3SOIPDnextModel) + { /* loop through all the instances of the model */ + for (here = model->B3SOIPDinstances; here != NULL; + here = here->B3SOIPDnextInstance) + { + vbs = model->B3SOIPDtype + * (*(ckt->CKTrhsOld + here->B3SOIPDbNode) + - *(ckt->CKTrhsOld + here->B3SOIPDsNodePrime)); + vgs = model->B3SOIPDtype + * (*(ckt->CKTrhsOld + here->B3SOIPDgNode) + - *(ckt->CKTrhsOld + here->B3SOIPDsNodePrime)); + vds = model->B3SOIPDtype + * (*(ckt->CKTrhsOld + here->B3SOIPDdNodePrime) + - *(ckt->CKTrhsOld + here->B3SOIPDsNodePrime)); + vbd = vbs - vds; + vgd = vgs - vds; + vgdo = *(ckt->CKTstate0 + here->B3SOIPDvgs) + - *(ckt->CKTstate0 + here->B3SOIPDvds); + delvbs = vbs - *(ckt->CKTstate0 + here->B3SOIPDvbs); + delvbd = vbd - *(ckt->CKTstate0 + here->B3SOIPDvbd); + delvgs = vgs - *(ckt->CKTstate0 + here->B3SOIPDvgs); + delvds = vds - *(ckt->CKTstate0 + here->B3SOIPDvds); + delvgd = vgd - vgdo; + + cd = here->B3SOIPDcd; + if (here->B3SOIPDmode >= 0) + { + cdhat = cd - here->B3SOIPDgjdb * delvbd + + here->B3SOIPDgmbs * delvbs + here->B3SOIPDgm * delvgs + + here->B3SOIPDgds * delvds; + } + else + { + cdhat = cd - (here->B3SOIPDgjdb - here->B3SOIPDgmbs) * delvbd + - here->B3SOIPDgm * delvgd + here->B3SOIPDgds * delvds; + } + + /* + * check convergence + */ + if ((here->B3SOIPDoff == 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->B3SOIPDcjs; + cbd = here->B3SOIPDcjd; + cbhat = cbs + cbd + here->B3SOIPDgjdb * delvbd + + here->B3SOIPDgjsb * 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_pd/b3soipddef.h b/src/spicelib/devices/bsim3soi_pd/b3soipddef.h new file mode 100644 index 000000000..608e967d9 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipddef.h @@ -0,0 +1,2185 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung +File: b3soipddef.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 +**********/ + +#ifndef B3SOIPD +#define B3SOIPD + +#define SOICODE +/* #define BULKCODE */ + +#include "ifsim.h" +#include "gendefs.h" +#include "cktdefs.h" +#include "complex.h" +#include "noisedef.h" + +typedef struct sB3SOIPDinstance +{ + struct sB3SOIPDmodel *B3SOIPDmodPtr; + struct sB3SOIPDinstance *B3SOIPDnextInstance; + IFuid B3SOIPDname; + int B3SOIPDstates; /* index into state table for this device */ + int B3SOIPDowner; + int B3SOIPDdNode; + int B3SOIPDgNode; + int B3SOIPDsNode; + int B3SOIPDeNode; + int B3SOIPDpNode; + int B3SOIPDbNode; + int B3SOIPDtempNode; + int B3SOIPDdNodePrime; + int B3SOIPDsNodePrime; + + int B3SOIPDvbsNode; + /* for Debug */ + int B3SOIPDidsNode; + int B3SOIPDicNode; + int B3SOIPDibsNode; + int B3SOIPDibdNode; + int B3SOIPDiiiNode; + int B3SOIPDigNode; + int B3SOIPDgiggNode; + int B3SOIPDgigdNode; + int B3SOIPDgigbNode; + int B3SOIPDigidlNode; + int B3SOIPDitunNode; + int B3SOIPDibpNode; + int B3SOIPDcbbNode; + int B3SOIPDcbdNode; + int B3SOIPDcbgNode; + + int B3SOIPDqbfNode; + int B3SOIPDqjsNode; + int B3SOIPDqjdNode; + + + double B3SOIPDphi; + double B3SOIPDvtm; + double B3SOIPDni; + double B3SOIPDueff; + double B3SOIPDthetavth; + double B3SOIPDvon; + double B3SOIPDvdsat; + double B3SOIPDcgdo; + double B3SOIPDcgso; + double B3SOIPDcgeo; + + double B3SOIPDids; + double B3SOIPDic; + double B3SOIPDibs; + double B3SOIPDibd; + double B3SOIPDiii; + double B3SOIPDig; + double B3SOIPDgigg; + double B3SOIPDgigd; + double B3SOIPDgigb; + double B3SOIPDigidl; + double B3SOIPDitun; + double B3SOIPDibp; + double B3SOIPDabeff; + double B3SOIPDvbseff; + double B3SOIPDcbg; + double B3SOIPDcbb; + double B3SOIPDcbs; /* XXX PN */ + double B3SOIPDcbd; + double B3SOIPDqb; + double B3SOIPDqbf; + double B3SOIPDqjs; + double B3SOIPDqjd; + int B3SOIPDfloat; + + + double B3SOIPDl; + double B3SOIPDw; + double B3SOIPDdrainArea; + double B3SOIPDsourceArea; + double B3SOIPDdrainSquares; + double B3SOIPDsourceSquares; + double B3SOIPDdrainPerimeter; + double B3SOIPDsourcePerimeter; + double B3SOIPDsourceConductance; + double B3SOIPDdrainConductance; + + double B3SOIPDicVBS; + double B3SOIPDicVDS; + double B3SOIPDicVGS; + double B3SOIPDicVES; + double B3SOIPDicVPS; + int B3SOIPDbjtoff; + int B3SOIPDbodyMod; + int B3SOIPDdebugMod; + double B3SOIPDrth0; + double B3SOIPDcth0; + double B3SOIPDbodySquares; + double B3SOIPDrbodyext; + + +/* v2.0 release */ + double B3SOIPDnbc; + double B3SOIPDnseg; + double B3SOIPDpdbcp; + double B3SOIPDpsbcp; + double B3SOIPDagbcp; + double B3SOIPDaebcp; + double B3SOIPDvbsusr; + int B3SOIPDtnodeout; + +/* Deleted from pParam and moved to here */ + double B3SOIPDcsbox; + double B3SOIPDcdbox; + double B3SOIPDcsmin; + double B3SOIPDcdmin; + double B3SOIPDst4; + double B3SOIPDdt4; + + int B3SOIPDoff; + int B3SOIPDmode; + + /* OP point */ + double B3SOIPDqinv; + double B3SOIPDcd; + double B3SOIPDcjs; + double B3SOIPDcjd; + double B3SOIPDcbody; +/* v2.2 release */ + double B3SOIPDcgate; + double B3SOIPDgigs; + double B3SOIPDgigT; + + double B3SOIPDcbodcon; + double B3SOIPDcth; + double B3SOIPDcsubstrate; + + double B3SOIPDgm; + double B3SOIPDcb; + double B3SOIPDcdrain; + double B3SOIPDgds; + double B3SOIPDgmbs; + double B3SOIPDgmT; + + double B3SOIPDgbbs; + double B3SOIPDgbgs; + double B3SOIPDgbds; + double B3SOIPDgbps; + double B3SOIPDgbT; + + double B3SOIPDgjsd; + double B3SOIPDgjsb; + double B3SOIPDgjsg; + double B3SOIPDgjsT; + + double B3SOIPDgjdb; + double B3SOIPDgjdd; + double B3SOIPDgjdg; + double B3SOIPDgjdT; + + double B3SOIPDgbpbs; + double B3SOIPDgbpps; + double B3SOIPDgbpT; + + double B3SOIPDgtempb; + double B3SOIPDgtempg; + double B3SOIPDgtempd; + double B3SOIPDgtempT; + + double B3SOIPDcggb; + double B3SOIPDcgdb; + double B3SOIPDcgsb; + double B3SOIPDcgT; + + double B3SOIPDcbgb; + double B3SOIPDcbdb; + double B3SOIPDcbsb; + double B3SOIPDcbeb; + double B3SOIPDcbT; + + double B3SOIPDcdgb; + double B3SOIPDcddb; + double B3SOIPDcdsb; + double B3SOIPDcdeb; + double B3SOIPDcdT; + + double B3SOIPDceeb; + double B3SOIPDceT; + + double B3SOIPDqse; + double B3SOIPDgcse; + double B3SOIPDqde; + double B3SOIPDgcde; + + struct b3soipdSizeDependParam *pParam; + + unsigned B3SOIPDlGiven:1; + unsigned B3SOIPDwGiven:1; + unsigned B3SOIPDdrainAreaGiven:1; + unsigned B3SOIPDsourceAreaGiven:1; + unsigned B3SOIPDdrainSquaresGiven:1; + unsigned B3SOIPDsourceSquaresGiven:1; + unsigned B3SOIPDdrainPerimeterGiven:1; + unsigned B3SOIPDsourcePerimeterGiven:1; + unsigned B3SOIPDdNodePrimeSet:1; + unsigned B3SOIPDsNodePrimeSet:1; + unsigned B3SOIPDicVBSGiven:1; + unsigned B3SOIPDicVDSGiven:1; + unsigned B3SOIPDicVGSGiven:1; + unsigned B3SOIPDicVESGiven:1; + unsigned B3SOIPDicVPSGiven:1; + unsigned B3SOIPDbjtoffGiven:1; + unsigned B3SOIPDdebugModGiven:1; + unsigned B3SOIPDrth0Given:1; + unsigned B3SOIPDcth0Given:1; + unsigned B3SOIPDbodySquaresGiven:1; + + +/* v2.0 release */ + unsigned B3SOIPDnbcGiven:1; + unsigned B3SOIPDnsegGiven:1; + unsigned B3SOIPDpdbcpGiven:1; + unsigned B3SOIPDpsbcpGiven:1; + unsigned B3SOIPDagbcpGiven:1; + unsigned B3SOIPDaebcpGiven:1; + unsigned B3SOIPDvbsusrGiven:1; + unsigned B3SOIPDtnodeoutGiven:1; + unsigned B3SOIPDoffGiven:1; + + double *B3SOIPDGePtr; + double *B3SOIPDDPePtr; + double *B3SOIPDSPePtr; + + double *B3SOIPDEePtr; + double *B3SOIPDEbPtr; + double *B3SOIPDBePtr; + double *B3SOIPDEgPtr; + double *B3SOIPDEdpPtr; + double *B3SOIPDEspPtr; + double *B3SOIPDTemptempPtr; + double *B3SOIPDTempdpPtr; + double *B3SOIPDTempspPtr; + double *B3SOIPDTempgPtr; + double *B3SOIPDTempbPtr; + double *B3SOIPDGtempPtr; + double *B3SOIPDDPtempPtr; + double *B3SOIPDSPtempPtr; + double *B3SOIPDEtempPtr; + double *B3SOIPDBtempPtr; + double *B3SOIPDPtempPtr; + double *B3SOIPDBpPtr; + double *B3SOIPDPbPtr; + double *B3SOIPDPpPtr; + double *B3SOIPDDdPtr; + double *B3SOIPDGgPtr; + double *B3SOIPDSsPtr; + double *B3SOIPDBbPtr; + double *B3SOIPDDPdpPtr; + double *B3SOIPDSPspPtr; + double *B3SOIPDDdpPtr; + double *B3SOIPDGbPtr; + double *B3SOIPDGdpPtr; + double *B3SOIPDGspPtr; + double *B3SOIPDSspPtr; + double *B3SOIPDBdpPtr; + double *B3SOIPDBspPtr; + double *B3SOIPDDPspPtr; + double *B3SOIPDDPdPtr; + double *B3SOIPDBgPtr; + double *B3SOIPDDPgPtr; + double *B3SOIPDSPgPtr; + double *B3SOIPDSPsPtr; + double *B3SOIPDDPbPtr; + double *B3SOIPDSPbPtr; + double *B3SOIPDSPdpPtr; + + double *B3SOIPDVbsPtr; + /* Debug */ + double *B3SOIPDIdsPtr; + double *B3SOIPDIcPtr; + double *B3SOIPDIbsPtr; + double *B3SOIPDIbdPtr; + double *B3SOIPDIiiPtr; + double *B3SOIPDIgPtr; + double *B3SOIPDGiggPtr; + double *B3SOIPDGigdPtr; + double *B3SOIPDGigbPtr; + double *B3SOIPDIgidlPtr; + double *B3SOIPDItunPtr; + double *B3SOIPDIbpPtr; + double *B3SOIPDCbbPtr; + double *B3SOIPDCbdPtr; + double *B3SOIPDCbgPtr; + double *B3SOIPDqbPtr; + double *B3SOIPDQbfPtr; + double *B3SOIPDQjsPtr; + double *B3SOIPDQjdPtr; + + + +#define B3SOIPDvbd B3SOIPDstates+ 0 +#define B3SOIPDvbs B3SOIPDstates+ 1 +#define B3SOIPDvgs B3SOIPDstates+ 2 +#define B3SOIPDvds B3SOIPDstates+ 3 +#define B3SOIPDves B3SOIPDstates+ 4 +#define B3SOIPDvps B3SOIPDstates+ 5 + +#define B3SOIPDvg B3SOIPDstates+ 6 +#define B3SOIPDvd B3SOIPDstates+ 7 +#define B3SOIPDvs B3SOIPDstates+ 8 +#define B3SOIPDvp B3SOIPDstates+ 9 +#define B3SOIPDve B3SOIPDstates+ 10 +#define B3SOIPDdeltemp B3SOIPDstates+ 11 + +#define B3SOIPDqb B3SOIPDstates+ 12 +#define B3SOIPDcqb B3SOIPDstates+ 13 +#define B3SOIPDqg B3SOIPDstates+ 14 +#define B3SOIPDcqg B3SOIPDstates+ 15 +#define B3SOIPDqd B3SOIPDstates+ 16 +#define B3SOIPDcqd B3SOIPDstates+ 17 +#define B3SOIPDqe B3SOIPDstates+ 18 +#define B3SOIPDcqe B3SOIPDstates+ 19 + +#define B3SOIPDqbs B3SOIPDstates+ 20 +#define B3SOIPDqbd B3SOIPDstates+ 21 +#define B3SOIPDqbe B3SOIPDstates+ 22 + +#define B3SOIPDqth B3SOIPDstates+ 23 +#define B3SOIPDcqth B3SOIPDstates+ 24 + +#define B3SOIPDnumStates 25 + + +/* indices to the array of B3SOIPD NOISE SOURCES */ + +#define B3SOIPDRDNOIZ 0 +#define B3SOIPDRSNOIZ 1 +#define B3SOIPDIDNOIZ 2 +#define B3SOIPDFLNOIZ 3 +#define B3SOIPDFBNOIZ 4 +#define B3SOIPDTOTNOIZ 5 + +#define B3SOIPDNSRCS 6 /* the number of MOSFET(3) noise sources */ + +#ifndef NONOISE + double B3SOIPDnVar[NSTATVARS][B3SOIPDNSRCS]; +#else /* NONOISE */ + double **B3SOIPDnVar; +#endif /* NONOISE */ + +} +B3SOIPDinstance; + +struct b3soipdSizeDependParam +{ + double Width; + double Length; + double Rth0; + double Cth0; + + double B3SOIPDcdsc; + double B3SOIPDcdscb; + double B3SOIPDcdscd; + double B3SOIPDcit; + double B3SOIPDnfactor; + double B3SOIPDvsat; + double B3SOIPDat; + double B3SOIPDa0; + double B3SOIPDags; + double B3SOIPDa1; + double B3SOIPDa2; + double B3SOIPDketa; + double B3SOIPDnpeak; + double B3SOIPDnsub; + double B3SOIPDngate; + double B3SOIPDgamma1; + double B3SOIPDgamma2; + double B3SOIPDvbx; + double B3SOIPDvbi; + double B3SOIPDvbm; + double B3SOIPDvbsc; + double B3SOIPDxt; + double B3SOIPDphi; + double B3SOIPDlitl; + double B3SOIPDk1; + double B3SOIPDkt1; + double B3SOIPDkt1l; + double B3SOIPDkt2; + double B3SOIPDk2; + double B3SOIPDk3; + double B3SOIPDk3b; + double B3SOIPDw0; + double B3SOIPDnlx; + double B3SOIPDdvt0; + double B3SOIPDdvt1; + double B3SOIPDdvt2; + double B3SOIPDdvt0w; + double B3SOIPDdvt1w; + double B3SOIPDdvt2w; + double B3SOIPDdrout; + double B3SOIPDdsub; + double B3SOIPDvth0; + double B3SOIPDua; + double B3SOIPDua1; + double B3SOIPDub; + double B3SOIPDub1; + double B3SOIPDuc; + double B3SOIPDuc1; + double B3SOIPDu0; + double B3SOIPDute; + double B3SOIPDvoff; + double B3SOIPDvfb; + double B3SOIPDuatemp; + double B3SOIPDubtemp; + double B3SOIPDuctemp; + double B3SOIPDrbody; + double B3SOIPDrth; + double B3SOIPDcth; + double B3SOIPDrds0denom; + double B3SOIPDvfbb; + double B3SOIPDjbjt; + double B3SOIPDjdif; + double B3SOIPDjrec; + double B3SOIPDjtun; + double B3SOIPDcsesw; + double B3SOIPDcdesw; + double B3SOIPDsdt1; + double B3SOIPDst2; + double B3SOIPDst3; + double B3SOIPDdt2; + double B3SOIPDdt3; + double B3SOIPDdelta; + double B3SOIPDrdsw; + double B3SOIPDrds0; + double B3SOIPDprwg; + double B3SOIPDprwb; + double B3SOIPDprt; + double B3SOIPDeta0; + double B3SOIPDetab; + double B3SOIPDpclm; + double B3SOIPDpdibl1; + double B3SOIPDpdibl2; + double B3SOIPDpdiblb; + double B3SOIPDpvag; + double B3SOIPDwr; + double B3SOIPDdwg; + double B3SOIPDdwb; + double B3SOIPDb0; + double B3SOIPDb1; + double B3SOIPDalpha0; + double B3SOIPDbeta0; + + + /* CV model */ + double B3SOIPDcgsl; + double B3SOIPDcgdl; + double B3SOIPDckappa; + double B3SOIPDcf; + double B3SOIPDclc; + double B3SOIPDcle; + +/* Added for binning - START0 */ + double B3SOIPDkb1; + double B3SOIPDk1w1; + double B3SOIPDk1w2; + double B3SOIPDketas; + double B3SOIPDfbjtii; + double B3SOIPDbeta1; + double B3SOIPDbeta2; + double B3SOIPDvdsatii0; + double B3SOIPDlii; + double B3SOIPDesatii; + double B3SOIPDsii0; + double B3SOIPDsii1; + double B3SOIPDsii2; + double B3SOIPDsiid; + double B3SOIPDagidl; + double B3SOIPDbgidl; + double B3SOIPDngidl; + double B3SOIPDntun; + double B3SOIPDndiode; + double B3SOIPDnrecf0; + double B3SOIPDnrecr0; + double B3SOIPDisbjt; + double B3SOIPDisdif; + double B3SOIPDisrec; + double B3SOIPDistun; + double B3SOIPDvrec0; + double B3SOIPDvtun0; + double B3SOIPDnbjt; + double B3SOIPDlbjt0; + double B3SOIPDvabjt; + double B3SOIPDaely; + double B3SOIPDvsdfb; + double B3SOIPDvsdth; + double B3SOIPDdelvt; +/* Added by binning - END0 */ + +/* Pre-calculated constants */ + + double B3SOIPDdw; + double B3SOIPDdl; + double B3SOIPDleff; + double B3SOIPDweff; + + double B3SOIPDdwc; + double B3SOIPDdlc; + double B3SOIPDleffCV; + double B3SOIPDweffCV; + double B3SOIPDabulkCVfactor; + double B3SOIPDcgso; + double B3SOIPDcgdo; + double B3SOIPDcgeo; + + double B3SOIPDu0temp; + double B3SOIPDvsattemp; + double B3SOIPDsqrtPhi; + double B3SOIPDphis3; + double B3SOIPDXdep0; + double B3SOIPDsqrtXdep0; + double B3SOIPDtheta0vb0; + double B3SOIPDthetaRout; + + +/* v2.2 release */ + double B3SOIPDoxideRatio; + + +/* v2.0 release */ + double B3SOIPDk1eff; + double B3SOIPDwdios; + double B3SOIPDwdiod; + double B3SOIPDwdiodCV; + double B3SOIPDwdiosCV; + double B3SOIPDarfabjt; + double B3SOIPDlratio; + double B3SOIPDlratiodif; + double B3SOIPDvearly; + double B3SOIPDahli; + double B3SOIPDvfbzb; + double B3SOIPDldeb; + double B3SOIPDacde; + double B3SOIPDmoin; + double B3SOIPDleffCVb; + double B3SOIPDleffCVbg; + + double B3SOIPDcof1; + double B3SOIPDcof2; + double B3SOIPDcof3; + double B3SOIPDcof4; + double B3SOIPDcdep0; + struct b3soipdSizeDependParam *pNext; +}; + + +typedef struct sB3SOIPDmodel +{ + int B3SOIPDmodType; + struct sB3SOIPDmodel *B3SOIPDnextModel; + B3SOIPDinstance *B3SOIPDinstances; + IFuid B3SOIPDmodName; + int B3SOIPDtype; + + int B3SOIPDmobMod; + int B3SOIPDcapMod; + int B3SOIPDnoiMod; + int B3SOIPDshMod; + int B3SOIPDbinUnit; + int B3SOIPDparamChk; + double B3SOIPDversion; + double B3SOIPDtox; + double B3SOIPDcdsc; + double B3SOIPDcdscb; + double B3SOIPDcdscd; + double B3SOIPDcit; + double B3SOIPDnfactor; + double B3SOIPDvsat; + double B3SOIPDat; + double B3SOIPDa0; + double B3SOIPDags; + double B3SOIPDa1; + double B3SOIPDa2; + double B3SOIPDketa; + double B3SOIPDnsub; + double B3SOIPDnpeak; + double B3SOIPDngate; + double B3SOIPDgamma1; + double B3SOIPDgamma2; + double B3SOIPDvbx; + double B3SOIPDvbm; + double B3SOIPDxt; + double B3SOIPDk1; + double B3SOIPDkt1; + double B3SOIPDkt1l; + double B3SOIPDkt2; + double B3SOIPDk2; + double B3SOIPDk3; + double B3SOIPDk3b; + double B3SOIPDw0; + double B3SOIPDnlx; + double B3SOIPDdvt0; + double B3SOIPDdvt1; + double B3SOIPDdvt2; + double B3SOIPDdvt0w; + double B3SOIPDdvt1w; + double B3SOIPDdvt2w; + double B3SOIPDdrout; + double B3SOIPDdsub; + double B3SOIPDvth0; + double B3SOIPDua; + double B3SOIPDua1; + double B3SOIPDub; + double B3SOIPDub1; + double B3SOIPDuc; + double B3SOIPDuc1; + double B3SOIPDu0; + double B3SOIPDute; + double B3SOIPDvoff; + double B3SOIPDdelta; + double B3SOIPDrdsw; + double B3SOIPDprwg; + double B3SOIPDprwb; + double B3SOIPDprt; + double B3SOIPDeta0; + double B3SOIPDetab; + double B3SOIPDpclm; + double B3SOIPDpdibl1; + double B3SOIPDpdibl2; + double B3SOIPDpdiblb; + double B3SOIPDpvag; + double B3SOIPDwr; + double B3SOIPDdwg; + double B3SOIPDdwb; + double B3SOIPDb0; + double B3SOIPDb1; + double B3SOIPDalpha0; + double B3SOIPDtbox; + double B3SOIPDtsi; + double B3SOIPDxj; + double B3SOIPDkb1; + double B3SOIPDrth0; + double B3SOIPDcth0; + double B3SOIPDngidl; + double B3SOIPDagidl; + double B3SOIPDbgidl; + double B3SOIPDndiode; + double B3SOIPDistun; + double B3SOIPDxbjt; + double B3SOIPDxdif; + double B3SOIPDxrec; + double B3SOIPDxtun; + + +/* v2.2 release */ + double B3SOIPDwth0; + double B3SOIPDrhalo; + double B3SOIPDntox; + double B3SOIPDtoxref; + double B3SOIPDebg; + double B3SOIPDnevb; + double B3SOIPDalphaGB1; + double B3SOIPDbetaGB1; + double B3SOIPDvgb1; + double B3SOIPDnecb; + double B3SOIPDalphaGB2; + double B3SOIPDbetaGB2; + double B3SOIPDvgb2; + double B3SOIPDtoxqm; + double B3SOIPDvoxh; + double B3SOIPDdeltavox; + int B3SOIPDigMod; + + +/* v2.0 release */ + double B3SOIPDk1w1; + double B3SOIPDk1w2; + double B3SOIPDketas; + double B3SOIPDdwbc; + double B3SOIPDbeta0; + double B3SOIPDbeta1; + double B3SOIPDbeta2; + double B3SOIPDvdsatii0; + double B3SOIPDtii; + double B3SOIPDlii; + double B3SOIPDsii0; + double B3SOIPDsii1; + double B3SOIPDsii2; + double B3SOIPDsiid; + double B3SOIPDfbjtii; + double B3SOIPDesatii; + double B3SOIPDntun; + double B3SOIPDnrecf0; + double B3SOIPDnrecr0; + double B3SOIPDisbjt; + double B3SOIPDisdif; + double B3SOIPDisrec; + double B3SOIPDln; + double B3SOIPDvrec0; + double B3SOIPDvtun0; + double B3SOIPDnbjt; + double B3SOIPDlbjt0; + double B3SOIPDldif0; + double B3SOIPDvabjt; + double B3SOIPDaely; + double B3SOIPDahli; + double B3SOIPDrbody; + double B3SOIPDrbsh; + double B3SOIPDtt; + double B3SOIPDndif; + double B3SOIPDvsdfb; + double B3SOIPDvsdth; + double B3SOIPDcsdmin; + double B3SOIPDasd; + double B3SOIPDntrecf; + double B3SOIPDntrecr; + double B3SOIPDdlcb; + double B3SOIPDfbody; + double B3SOIPDtcjswg; + double B3SOIPDtpbswg; + double B3SOIPDacde; + double B3SOIPDmoin; + double B3SOIPDdelvt; + double B3SOIPDdlbg; + + /* CV model */ + double B3SOIPDcgsl; + double B3SOIPDcgdl; + double B3SOIPDckappa; + double B3SOIPDcf; + double B3SOIPDclc; + double B3SOIPDcle; + double B3SOIPDdwc; + double B3SOIPDdlc; + + double B3SOIPDtnom; + double B3SOIPDcgso; + double B3SOIPDcgdo; + double B3SOIPDcgeo; + double B3SOIPDxpart; + double B3SOIPDcFringOut; + double B3SOIPDcFringMax; + + double B3SOIPDsheetResistance; + double B3SOIPDbodyJctGateSideGradingCoeff; + double B3SOIPDGatesidewallJctPotential; + double B3SOIPDunitLengthGateSidewallJctCap; + double B3SOIPDcsdesw; + + double B3SOIPDLint; + double B3SOIPDLl; + double B3SOIPDLln; + double B3SOIPDLw; + double B3SOIPDLwn; + double B3SOIPDLwl; + double B3SOIPDLmin; + double B3SOIPDLmax; + + double B3SOIPDWint; + double B3SOIPDWl; + double B3SOIPDWln; + double B3SOIPDWw; + double B3SOIPDWwn; + double B3SOIPDWwl; + double B3SOIPDWmin; + double B3SOIPDWmax; + +/* Added for binning - START1 */ + /* Length Dependence */ + double B3SOIPDlnpeak; + double B3SOIPDlnsub; + double B3SOIPDlngate; + double B3SOIPDlvth0; + double B3SOIPDlk1; + double B3SOIPDlk1w1; + double B3SOIPDlk1w2; + double B3SOIPDlk2; + double B3SOIPDlk3; + double B3SOIPDlk3b; + double B3SOIPDlkb1; + double B3SOIPDlw0; + double B3SOIPDlnlx; + double B3SOIPDldvt0; + double B3SOIPDldvt1; + double B3SOIPDldvt2; + double B3SOIPDldvt0w; + double B3SOIPDldvt1w; + double B3SOIPDldvt2w; + double B3SOIPDlu0; + double B3SOIPDlua; + double B3SOIPDlub; + double B3SOIPDluc; + double B3SOIPDlvsat; + double B3SOIPDla0; + double B3SOIPDlags; + double B3SOIPDlb0; + double B3SOIPDlb1; + double B3SOIPDlketa; + double B3SOIPDlketas; + double B3SOIPDla1; + double B3SOIPDla2; + double B3SOIPDlrdsw; + double B3SOIPDlprwb; + double B3SOIPDlprwg; + double B3SOIPDlwr; + double B3SOIPDlnfactor; + double B3SOIPDldwg; + double B3SOIPDldwb; + double B3SOIPDlvoff; + double B3SOIPDleta0; + double B3SOIPDletab; + double B3SOIPDldsub; + double B3SOIPDlcit; + double B3SOIPDlcdsc; + double B3SOIPDlcdscb; + double B3SOIPDlcdscd; + double B3SOIPDlpclm; + double B3SOIPDlpdibl1; + double B3SOIPDlpdibl2; + double B3SOIPDlpdiblb; + double B3SOIPDldrout; + double B3SOIPDlpvag; + double B3SOIPDldelta; + double B3SOIPDlalpha0; + double B3SOIPDlfbjtii; + double B3SOIPDlbeta0; + double B3SOIPDlbeta1; + double B3SOIPDlbeta2; + double B3SOIPDlvdsatii0; + double B3SOIPDllii; + double B3SOIPDlesatii; + double B3SOIPDlsii0; + double B3SOIPDlsii1; + double B3SOIPDlsii2; + double B3SOIPDlsiid; + double B3SOIPDlagidl; + double B3SOIPDlbgidl; + double B3SOIPDlngidl; + double B3SOIPDlntun; + double B3SOIPDlndiode; + double B3SOIPDlnrecf0; + double B3SOIPDlnrecr0; + double B3SOIPDlisbjt; + double B3SOIPDlisdif; + double B3SOIPDlisrec; + double B3SOIPDlistun; + double B3SOIPDlvrec0; + double B3SOIPDlvtun0; + double B3SOIPDlnbjt; + double B3SOIPDllbjt0; + double B3SOIPDlvabjt; + double B3SOIPDlaely; + double B3SOIPDlahli; + /* CV model */ + double B3SOIPDlvsdfb; + double B3SOIPDlvsdth; + double B3SOIPDldelvt; + double B3SOIPDlacde; + double B3SOIPDlmoin; + + /* Width Dependence */ + double B3SOIPDwnpeak; + double B3SOIPDwnsub; + double B3SOIPDwngate; + double B3SOIPDwvth0; + double B3SOIPDwk1; + double B3SOIPDwk1w1; + double B3SOIPDwk1w2; + double B3SOIPDwk2; + double B3SOIPDwk3; + double B3SOIPDwk3b; + double B3SOIPDwkb1; + double B3SOIPDww0; + double B3SOIPDwnlx; + double B3SOIPDwdvt0; + double B3SOIPDwdvt1; + double B3SOIPDwdvt2; + double B3SOIPDwdvt0w; + double B3SOIPDwdvt1w; + double B3SOIPDwdvt2w; + double B3SOIPDwu0; + double B3SOIPDwua; + double B3SOIPDwub; + double B3SOIPDwuc; + double B3SOIPDwvsat; + double B3SOIPDwa0; + double B3SOIPDwags; + double B3SOIPDwb0; + double B3SOIPDwb1; + double B3SOIPDwketa; + double B3SOIPDwketas; + double B3SOIPDwa1; + double B3SOIPDwa2; + double B3SOIPDwrdsw; + double B3SOIPDwprwb; + double B3SOIPDwprwg; + double B3SOIPDwwr; + double B3SOIPDwnfactor; + double B3SOIPDwdwg; + double B3SOIPDwdwb; + double B3SOIPDwvoff; + double B3SOIPDweta0; + double B3SOIPDwetab; + double B3SOIPDwdsub; + double B3SOIPDwcit; + double B3SOIPDwcdsc; + double B3SOIPDwcdscb; + double B3SOIPDwcdscd; + double B3SOIPDwpclm; + double B3SOIPDwpdibl1; + double B3SOIPDwpdibl2; + double B3SOIPDwpdiblb; + double B3SOIPDwdrout; + double B3SOIPDwpvag; + double B3SOIPDwdelta; + double B3SOIPDwalpha0; + double B3SOIPDwfbjtii; + double B3SOIPDwbeta0; + double B3SOIPDwbeta1; + double B3SOIPDwbeta2; + double B3SOIPDwvdsatii0; + double B3SOIPDwlii; + double B3SOIPDwesatii; + double B3SOIPDwsii0; + double B3SOIPDwsii1; + double B3SOIPDwsii2; + double B3SOIPDwsiid; + double B3SOIPDwagidl; + double B3SOIPDwbgidl; + double B3SOIPDwngidl; + double B3SOIPDwntun; + double B3SOIPDwndiode; + double B3SOIPDwnrecf0; + double B3SOIPDwnrecr0; + double B3SOIPDwisbjt; + double B3SOIPDwisdif; + double B3SOIPDwisrec; + double B3SOIPDwistun; + double B3SOIPDwvrec0; + double B3SOIPDwvtun0; + double B3SOIPDwnbjt; + double B3SOIPDwlbjt0; + double B3SOIPDwvabjt; + double B3SOIPDwaely; + double B3SOIPDwahli; + /* CV model */ + double B3SOIPDwvsdfb; + double B3SOIPDwvsdth; + double B3SOIPDwdelvt; + double B3SOIPDwacde; + double B3SOIPDwmoin; + + /* Cross-term Dependence */ + double B3SOIPDpnpeak; + double B3SOIPDpnsub; + double B3SOIPDpngate; + double B3SOIPDpvth0; + double B3SOIPDpk1; + double B3SOIPDpk1w1; + double B3SOIPDpk1w2; + double B3SOIPDpk2; + double B3SOIPDpk3; + double B3SOIPDpk3b; + double B3SOIPDpkb1; + double B3SOIPDpw0; + double B3SOIPDpnlx; + double B3SOIPDpdvt0; + double B3SOIPDpdvt1; + double B3SOIPDpdvt2; + double B3SOIPDpdvt0w; + double B3SOIPDpdvt1w; + double B3SOIPDpdvt2w; + double B3SOIPDpu0; + double B3SOIPDpua; + double B3SOIPDpub; + double B3SOIPDpuc; + double B3SOIPDpvsat; + double B3SOIPDpa0; + double B3SOIPDpags; + double B3SOIPDpb0; + double B3SOIPDpb1; + double B3SOIPDpketa; + double B3SOIPDpketas; + double B3SOIPDpa1; + double B3SOIPDpa2; + double B3SOIPDprdsw; + double B3SOIPDpprwb; + double B3SOIPDpprwg; + double B3SOIPDpwr; + double B3SOIPDpnfactor; + double B3SOIPDpdwg; + double B3SOIPDpdwb; + double B3SOIPDpvoff; + double B3SOIPDpeta0; + double B3SOIPDpetab; + double B3SOIPDpdsub; + double B3SOIPDpcit; + double B3SOIPDpcdsc; + double B3SOIPDpcdscb; + double B3SOIPDpcdscd; + double B3SOIPDppclm; + double B3SOIPDppdibl1; + double B3SOIPDppdibl2; + double B3SOIPDppdiblb; + double B3SOIPDpdrout; + double B3SOIPDppvag; + double B3SOIPDpdelta; + double B3SOIPDpalpha0; + double B3SOIPDpfbjtii; + double B3SOIPDpbeta0; + double B3SOIPDpbeta1; + double B3SOIPDpbeta2; + double B3SOIPDpvdsatii0; + double B3SOIPDplii; + double B3SOIPDpesatii; + double B3SOIPDpsii0; + double B3SOIPDpsii1; + double B3SOIPDpsii2; + double B3SOIPDpsiid; + double B3SOIPDpagidl; + double B3SOIPDpbgidl; + double B3SOIPDpngidl; + double B3SOIPDpntun; + double B3SOIPDpndiode; + double B3SOIPDpnrecf0; + double B3SOIPDpnrecr0; + double B3SOIPDpisbjt; + double B3SOIPDpisdif; + double B3SOIPDpisrec; + double B3SOIPDpistun; + double B3SOIPDpvrec0; + double B3SOIPDpvtun0; + double B3SOIPDpnbjt; + double B3SOIPDplbjt0; + double B3SOIPDpvabjt; + double B3SOIPDpaely; + double B3SOIPDpahli; + /* CV model */ + double B3SOIPDpvsdfb; + double B3SOIPDpvsdth; + double B3SOIPDpdelvt; + double B3SOIPDpacde; + double B3SOIPDpmoin; +/* Added for binning - END1 */ + +/* Pre-calculated constants */ + double B3SOIPDcbox; + double B3SOIPDcsi; + double B3SOIPDcsieff; + double B3SOIPDcoxt; + double B3SOIPDnfb; + double B3SOIPDadice; + double B3SOIPDqsi; + double B3SOIPDqsieff; + double B3SOIPDeg0; + + /* MCJ: move to size-dependent param. */ + double B3SOIPDvtm; + double B3SOIPDcox; + double B3SOIPDcof1; + double B3SOIPDcof2; + double B3SOIPDcof3; + double B3SOIPDcof4; + double B3SOIPDvcrit; + double B3SOIPDfactor1; + + double B3SOIPDoxideTrapDensityA; + double B3SOIPDoxideTrapDensityB; + double B3SOIPDoxideTrapDensityC; + double B3SOIPDem; + double B3SOIPDef; + double B3SOIPDaf; + double B3SOIPDkf; + double B3SOIPDnoif; + + struct b3soipdSizeDependParam *pSizeDependParamKnot; + + /* Flags */ + + unsigned B3SOIPDtboxGiven:1; + unsigned B3SOIPDtsiGiven:1; + unsigned B3SOIPDxjGiven:1; + unsigned B3SOIPDkb1Given:1; + unsigned B3SOIPDrth0Given:1; + unsigned B3SOIPDcth0Given:1; + unsigned B3SOIPDngidlGiven:1; + unsigned B3SOIPDagidlGiven:1; + unsigned B3SOIPDbgidlGiven:1; + unsigned B3SOIPDndiodeGiven:1; + unsigned B3SOIPDxbjtGiven:1; + unsigned B3SOIPDxdifGiven:1; + unsigned B3SOIPDxrecGiven:1; + unsigned B3SOIPDxtunGiven:1; + unsigned B3SOIPDttGiven:1; + unsigned B3SOIPDvsdfbGiven:1; + unsigned B3SOIPDvsdthGiven:1; + unsigned B3SOIPDasdGiven:1; + unsigned B3SOIPDcsdminGiven:1; + + unsigned B3SOIPDmobModGiven:1; + unsigned B3SOIPDbinUnitGiven:1; + unsigned B3SOIPDcapModGiven:1; + unsigned B3SOIPDparamChkGiven:1; + unsigned B3SOIPDnoiModGiven:1; + unsigned B3SOIPDshModGiven:1; + unsigned B3SOIPDtypeGiven:1; + unsigned B3SOIPDtoxGiven:1; + unsigned B3SOIPDversionGiven:1; + + unsigned B3SOIPDcdscGiven:1; + unsigned B3SOIPDcdscbGiven:1; + unsigned B3SOIPDcdscdGiven:1; + unsigned B3SOIPDcitGiven:1; + unsigned B3SOIPDnfactorGiven:1; + unsigned B3SOIPDvsatGiven:1; + unsigned B3SOIPDatGiven:1; + unsigned B3SOIPDa0Given:1; + unsigned B3SOIPDagsGiven:1; + unsigned B3SOIPDa1Given:1; + unsigned B3SOIPDa2Given:1; + unsigned B3SOIPDketaGiven:1; + unsigned B3SOIPDnsubGiven:1; + unsigned B3SOIPDnpeakGiven:1; + unsigned B3SOIPDngateGiven:1; + unsigned B3SOIPDgamma1Given:1; + unsigned B3SOIPDgamma2Given:1; + unsigned B3SOIPDvbxGiven:1; + unsigned B3SOIPDvbmGiven:1; + unsigned B3SOIPDxtGiven:1; + unsigned B3SOIPDk1Given:1; + unsigned B3SOIPDkt1Given:1; + unsigned B3SOIPDkt1lGiven:1; + unsigned B3SOIPDkt2Given:1; + unsigned B3SOIPDk2Given:1; + unsigned B3SOIPDk3Given:1; + unsigned B3SOIPDk3bGiven:1; + unsigned B3SOIPDw0Given:1; + unsigned B3SOIPDnlxGiven:1; + unsigned B3SOIPDdvt0Given:1; + unsigned B3SOIPDdvt1Given:1; + unsigned B3SOIPDdvt2Given:1; + unsigned B3SOIPDdvt0wGiven:1; + unsigned B3SOIPDdvt1wGiven:1; + unsigned B3SOIPDdvt2wGiven:1; + unsigned B3SOIPDdroutGiven:1; + unsigned B3SOIPDdsubGiven:1; + unsigned B3SOIPDvth0Given:1; + unsigned B3SOIPDuaGiven:1; + unsigned B3SOIPDua1Given:1; + unsigned B3SOIPDubGiven:1; + unsigned B3SOIPDub1Given:1; + unsigned B3SOIPDucGiven:1; + unsigned B3SOIPDuc1Given:1; + unsigned B3SOIPDu0Given:1; + unsigned B3SOIPDuteGiven:1; + unsigned B3SOIPDvoffGiven:1; + unsigned B3SOIPDrdswGiven:1; + unsigned B3SOIPDprwgGiven:1; + unsigned B3SOIPDprwbGiven:1; + unsigned B3SOIPDprtGiven:1; + unsigned B3SOIPDeta0Given:1; + unsigned B3SOIPDetabGiven:1; + unsigned B3SOIPDpclmGiven:1; + unsigned B3SOIPDpdibl1Given:1; + unsigned B3SOIPDpdibl2Given:1; + unsigned B3SOIPDpdiblbGiven:1; + unsigned B3SOIPDpvagGiven:1; + unsigned B3SOIPDdeltaGiven:1; + unsigned B3SOIPDwrGiven:1; + unsigned B3SOIPDdwgGiven:1; + unsigned B3SOIPDdwbGiven:1; + unsigned B3SOIPDb0Given:1; + unsigned B3SOIPDb1Given:1; + unsigned B3SOIPDalpha0Given:1; + + +/* v2.2 release */ + unsigned B3SOIPDwth0Given:1; + unsigned B3SOIPDrhaloGiven:1; + unsigned B3SOIPDntoxGiven:1; + unsigned B3SOIPDtoxrefGiven:1; + unsigned B3SOIPDebgGiven:1; + unsigned B3SOIPDnevbGiven:1; + unsigned B3SOIPDalphaGB1Given:1; + unsigned B3SOIPDbetaGB1Given:1; + unsigned B3SOIPDvgb1Given:1; + unsigned B3SOIPDnecbGiven:1; + unsigned B3SOIPDalphaGB2Given:1; + unsigned B3SOIPDbetaGB2Given:1; + unsigned B3SOIPDvgb2Given:1; + unsigned B3SOIPDtoxqmGiven:1; + unsigned B3SOIPDigModGiven:1; + unsigned B3SOIPDvoxhGiven:1; + unsigned B3SOIPDdeltavoxGiven:1; + + +/* v2.0 release */ + unsigned B3SOIPDk1w1Given:1; + unsigned B3SOIPDk1w2Given:1; + unsigned B3SOIPDketasGiven:1; + unsigned B3SOIPDdwbcGiven:1; + unsigned B3SOIPDbeta0Given:1; + unsigned B3SOIPDbeta1Given:1; + unsigned B3SOIPDbeta2Given:1; + unsigned B3SOIPDvdsatii0Given:1; + unsigned B3SOIPDtiiGiven:1; + unsigned B3SOIPDliiGiven:1; + unsigned B3SOIPDsii0Given:1; + unsigned B3SOIPDsii1Given:1; + unsigned B3SOIPDsii2Given:1; + unsigned B3SOIPDsiidGiven:1; + unsigned B3SOIPDfbjtiiGiven:1; + unsigned B3SOIPDesatiiGiven:1; + unsigned B3SOIPDntunGiven:1; + unsigned B3SOIPDnrecf0Given:1; + unsigned B3SOIPDnrecr0Given:1; + unsigned B3SOIPDisbjtGiven:1; + unsigned B3SOIPDisdifGiven:1; + unsigned B3SOIPDisrecGiven:1; + unsigned B3SOIPDistunGiven:1; + unsigned B3SOIPDlnGiven:1; + unsigned B3SOIPDvrec0Given:1; + unsigned B3SOIPDvtun0Given:1; + unsigned B3SOIPDnbjtGiven:1; + unsigned B3SOIPDlbjt0Given:1; + unsigned B3SOIPDldif0Given:1; + unsigned B3SOIPDvabjtGiven:1; + unsigned B3SOIPDaelyGiven:1; + unsigned B3SOIPDahliGiven:1; + unsigned B3SOIPDrbodyGiven:1; + unsigned B3SOIPDrbshGiven:1; + unsigned B3SOIPDndifGiven:1; + unsigned B3SOIPDntrecfGiven:1; + unsigned B3SOIPDntrecrGiven:1; + unsigned B3SOIPDdlcbGiven:1; + unsigned B3SOIPDfbodyGiven:1; + unsigned B3SOIPDtcjswgGiven:1; + unsigned B3SOIPDtpbswgGiven:1; + unsigned B3SOIPDacdeGiven:1; + unsigned B3SOIPDmoinGiven:1; + unsigned B3SOIPDdelvtGiven:1; + unsigned B3SOIPDdlbgGiven:1; + + + /* CV model */ + unsigned B3SOIPDcgslGiven:1; + unsigned B3SOIPDcgdlGiven:1; + unsigned B3SOIPDckappaGiven:1; + unsigned B3SOIPDcfGiven:1; + unsigned B3SOIPDclcGiven:1; + unsigned B3SOIPDcleGiven:1; + unsigned B3SOIPDdwcGiven:1; + unsigned B3SOIPDdlcGiven:1; + +/* Added for binning - START2 */ + /* Length Dependence */ + unsigned B3SOIPDlnpeakGiven:1; + unsigned B3SOIPDlnsubGiven:1; + unsigned B3SOIPDlngateGiven:1; + unsigned B3SOIPDlvth0Given:1; + unsigned B3SOIPDlk1Given:1; + unsigned B3SOIPDlk1w1Given:1; + unsigned B3SOIPDlk1w2Given:1; + unsigned B3SOIPDlk2Given:1; + unsigned B3SOIPDlk3Given:1; + unsigned B3SOIPDlk3bGiven:1; + unsigned B3SOIPDlkb1Given:1; + unsigned B3SOIPDlw0Given:1; + unsigned B3SOIPDlnlxGiven:1; + unsigned B3SOIPDldvt0Given:1; + unsigned B3SOIPDldvt1Given:1; + unsigned B3SOIPDldvt2Given:1; + unsigned B3SOIPDldvt0wGiven:1; + unsigned B3SOIPDldvt1wGiven:1; + unsigned B3SOIPDldvt2wGiven:1; + unsigned B3SOIPDlu0Given:1; + unsigned B3SOIPDluaGiven:1; + unsigned B3SOIPDlubGiven:1; + unsigned B3SOIPDlucGiven:1; + unsigned B3SOIPDlvsatGiven:1; + unsigned B3SOIPDla0Given:1; + unsigned B3SOIPDlagsGiven:1; + unsigned B3SOIPDlb0Given:1; + unsigned B3SOIPDlb1Given:1; + unsigned B3SOIPDlketaGiven:1; + unsigned B3SOIPDlketasGiven:1; + unsigned B3SOIPDla1Given:1; + unsigned B3SOIPDla2Given:1; + unsigned B3SOIPDlrdswGiven:1; + unsigned B3SOIPDlprwbGiven:1; + unsigned B3SOIPDlprwgGiven:1; + unsigned B3SOIPDlwrGiven:1; + unsigned B3SOIPDlnfactorGiven:1; + unsigned B3SOIPDldwgGiven:1; + unsigned B3SOIPDldwbGiven:1; + unsigned B3SOIPDlvoffGiven:1; + unsigned B3SOIPDleta0Given:1; + unsigned B3SOIPDletabGiven:1; + unsigned B3SOIPDldsubGiven:1; + unsigned B3SOIPDlcitGiven:1; + unsigned B3SOIPDlcdscGiven:1; + unsigned B3SOIPDlcdscbGiven:1; + unsigned B3SOIPDlcdscdGiven:1; + unsigned B3SOIPDlpclmGiven:1; + unsigned B3SOIPDlpdibl1Given:1; + unsigned B3SOIPDlpdibl2Given:1; + unsigned B3SOIPDlpdiblbGiven:1; + unsigned B3SOIPDldroutGiven:1; + unsigned B3SOIPDlpvagGiven:1; + unsigned B3SOIPDldeltaGiven:1; + unsigned B3SOIPDlalpha0Given:1; + unsigned B3SOIPDlfbjtiiGiven:1; + unsigned B3SOIPDlbeta0Given:1; + unsigned B3SOIPDlbeta1Given:1; + unsigned B3SOIPDlbeta2Given:1; + unsigned B3SOIPDlvdsatii0Given:1; + unsigned B3SOIPDlliiGiven:1; + unsigned B3SOIPDlesatiiGiven:1; + unsigned B3SOIPDlsii0Given:1; + unsigned B3SOIPDlsii1Given:1; + unsigned B3SOIPDlsii2Given:1; + unsigned B3SOIPDlsiidGiven:1; + unsigned B3SOIPDlagidlGiven:1; + unsigned B3SOIPDlbgidlGiven:1; + unsigned B3SOIPDlngidlGiven:1; + unsigned B3SOIPDlntunGiven:1; + unsigned B3SOIPDlndiodeGiven:1; + unsigned B3SOIPDlnrecf0Given:1; + unsigned B3SOIPDlnrecr0Given:1; + unsigned B3SOIPDlisbjtGiven:1; + unsigned B3SOIPDlisdifGiven:1; + unsigned B3SOIPDlisrecGiven:1; + unsigned B3SOIPDlistunGiven:1; + unsigned B3SOIPDlvrec0Given:1; + unsigned B3SOIPDlvtun0Given:1; + unsigned B3SOIPDlnbjtGiven:1; + unsigned B3SOIPDllbjt0Given:1; + unsigned B3SOIPDlvabjtGiven:1; + unsigned B3SOIPDlaelyGiven:1; + unsigned B3SOIPDlahliGiven:1; + /* CV model */ + unsigned B3SOIPDlvsdfbGiven:1; + unsigned B3SOIPDlvsdthGiven:1; + unsigned B3SOIPDldelvtGiven:1; + unsigned B3SOIPDlacdeGiven:1; + unsigned B3SOIPDlmoinGiven:1; + + /* Width Dependence */ + unsigned B3SOIPDwnpeakGiven:1; + unsigned B3SOIPDwnsubGiven:1; + unsigned B3SOIPDwngateGiven:1; + unsigned B3SOIPDwvth0Given:1; + unsigned B3SOIPDwk1Given:1; + unsigned B3SOIPDwk1w1Given:1; + unsigned B3SOIPDwk1w2Given:1; + unsigned B3SOIPDwk2Given:1; + unsigned B3SOIPDwk3Given:1; + unsigned B3SOIPDwk3bGiven:1; + unsigned B3SOIPDwkb1Given:1; + unsigned B3SOIPDww0Given:1; + unsigned B3SOIPDwnlxGiven:1; + unsigned B3SOIPDwdvt0Given:1; + unsigned B3SOIPDwdvt1Given:1; + unsigned B3SOIPDwdvt2Given:1; + unsigned B3SOIPDwdvt0wGiven:1; + unsigned B3SOIPDwdvt1wGiven:1; + unsigned B3SOIPDwdvt2wGiven:1; + unsigned B3SOIPDwu0Given:1; + unsigned B3SOIPDwuaGiven:1; + unsigned B3SOIPDwubGiven:1; + unsigned B3SOIPDwucGiven:1; + unsigned B3SOIPDwvsatGiven:1; + unsigned B3SOIPDwa0Given:1; + unsigned B3SOIPDwagsGiven:1; + unsigned B3SOIPDwb0Given:1; + unsigned B3SOIPDwb1Given:1; + unsigned B3SOIPDwketaGiven:1; + unsigned B3SOIPDwketasGiven:1; + unsigned B3SOIPDwa1Given:1; + unsigned B3SOIPDwa2Given:1; + unsigned B3SOIPDwrdswGiven:1; + unsigned B3SOIPDwprwbGiven:1; + unsigned B3SOIPDwprwgGiven:1; + unsigned B3SOIPDwwrGiven:1; + unsigned B3SOIPDwnfactorGiven:1; + unsigned B3SOIPDwdwgGiven:1; + unsigned B3SOIPDwdwbGiven:1; + unsigned B3SOIPDwvoffGiven:1; + unsigned B3SOIPDweta0Given:1; + unsigned B3SOIPDwetabGiven:1; + unsigned B3SOIPDwdsubGiven:1; + unsigned B3SOIPDwcitGiven:1; + unsigned B3SOIPDwcdscGiven:1; + unsigned B3SOIPDwcdscbGiven:1; + unsigned B3SOIPDwcdscdGiven:1; + unsigned B3SOIPDwpclmGiven:1; + unsigned B3SOIPDwpdibl1Given:1; + unsigned B3SOIPDwpdibl2Given:1; + unsigned B3SOIPDwpdiblbGiven:1; + unsigned B3SOIPDwdroutGiven:1; + unsigned B3SOIPDwpvagGiven:1; + unsigned B3SOIPDwdeltaGiven:1; + unsigned B3SOIPDwalpha0Given:1; + unsigned B3SOIPDwfbjtiiGiven:1; + unsigned B3SOIPDwbeta0Given:1; + unsigned B3SOIPDwbeta1Given:1; + unsigned B3SOIPDwbeta2Given:1; + unsigned B3SOIPDwvdsatii0Given:1; + unsigned B3SOIPDwliiGiven:1; + unsigned B3SOIPDwesatiiGiven:1; + unsigned B3SOIPDwsii0Given:1; + unsigned B3SOIPDwsii1Given:1; + unsigned B3SOIPDwsii2Given:1; + unsigned B3SOIPDwsiidGiven:1; + unsigned B3SOIPDwagidlGiven:1; + unsigned B3SOIPDwbgidlGiven:1; + unsigned B3SOIPDwngidlGiven:1; + unsigned B3SOIPDwntunGiven:1; + unsigned B3SOIPDwndiodeGiven:1; + unsigned B3SOIPDwnrecf0Given:1; + unsigned B3SOIPDwnrecr0Given:1; + unsigned B3SOIPDwisbjtGiven:1; + unsigned B3SOIPDwisdifGiven:1; + unsigned B3SOIPDwisrecGiven:1; + unsigned B3SOIPDwistunGiven:1; + unsigned B3SOIPDwvrec0Given:1; + unsigned B3SOIPDwvtun0Given:1; + unsigned B3SOIPDwnbjtGiven:1; + unsigned B3SOIPDwlbjt0Given:1; + unsigned B3SOIPDwvabjtGiven:1; + unsigned B3SOIPDwaelyGiven:1; + unsigned B3SOIPDwahliGiven:1; + /* CV model */ + unsigned B3SOIPDwvsdfbGiven:1; + unsigned B3SOIPDwvsdthGiven:1; + unsigned B3SOIPDwdelvtGiven:1; + unsigned B3SOIPDwacdeGiven:1; + unsigned B3SOIPDwmoinGiven:1; + + /* Cross-term Dependence */ + unsigned B3SOIPDpnpeakGiven:1; + unsigned B3SOIPDpnsubGiven:1; + unsigned B3SOIPDpngateGiven:1; + unsigned B3SOIPDpvth0Given:1; + unsigned B3SOIPDpk1Given:1; + unsigned B3SOIPDpk1w1Given:1; + unsigned B3SOIPDpk1w2Given:1; + unsigned B3SOIPDpk2Given:1; + unsigned B3SOIPDpk3Given:1; + unsigned B3SOIPDpk3bGiven:1; + unsigned B3SOIPDpkb1Given:1; + unsigned B3SOIPDpw0Given:1; + unsigned B3SOIPDpnlxGiven:1; + unsigned B3SOIPDpdvt0Given:1; + unsigned B3SOIPDpdvt1Given:1; + unsigned B3SOIPDpdvt2Given:1; + unsigned B3SOIPDpdvt0wGiven:1; + unsigned B3SOIPDpdvt1wGiven:1; + unsigned B3SOIPDpdvt2wGiven:1; + unsigned B3SOIPDpu0Given:1; + unsigned B3SOIPDpuaGiven:1; + unsigned B3SOIPDpubGiven:1; + unsigned B3SOIPDpucGiven:1; + unsigned B3SOIPDpvsatGiven:1; + unsigned B3SOIPDpa0Given:1; + unsigned B3SOIPDpagsGiven:1; + unsigned B3SOIPDpb0Given:1; + unsigned B3SOIPDpb1Given:1; + unsigned B3SOIPDpketaGiven:1; + unsigned B3SOIPDpketasGiven:1; + unsigned B3SOIPDpa1Given:1; + unsigned B3SOIPDpa2Given:1; + unsigned B3SOIPDprdswGiven:1; + unsigned B3SOIPDpprwbGiven:1; + unsigned B3SOIPDpprwgGiven:1; + unsigned B3SOIPDpwrGiven:1; + unsigned B3SOIPDpnfactorGiven:1; + unsigned B3SOIPDpdwgGiven:1; + unsigned B3SOIPDpdwbGiven:1; + unsigned B3SOIPDpvoffGiven:1; + unsigned B3SOIPDpeta0Given:1; + unsigned B3SOIPDpetabGiven:1; + unsigned B3SOIPDpdsubGiven:1; + unsigned B3SOIPDpcitGiven:1; + unsigned B3SOIPDpcdscGiven:1; + unsigned B3SOIPDpcdscbGiven:1; + unsigned B3SOIPDpcdscdGiven:1; + unsigned B3SOIPDppclmGiven:1; + unsigned B3SOIPDppdibl1Given:1; + unsigned B3SOIPDppdibl2Given:1; + unsigned B3SOIPDppdiblbGiven:1; + unsigned B3SOIPDpdroutGiven:1; + unsigned B3SOIPDppvagGiven:1; + unsigned B3SOIPDpdeltaGiven:1; + unsigned B3SOIPDpalpha0Given:1; + unsigned B3SOIPDpfbjtiiGiven:1; + unsigned B3SOIPDpbeta0Given:1; + unsigned B3SOIPDpbeta1Given:1; + unsigned B3SOIPDpbeta2Given:1; + unsigned B3SOIPDpvdsatii0Given:1; + unsigned B3SOIPDpliiGiven:1; + unsigned B3SOIPDpesatiiGiven:1; + unsigned B3SOIPDpsii0Given:1; + unsigned B3SOIPDpsii1Given:1; + unsigned B3SOIPDpsii2Given:1; + unsigned B3SOIPDpsiidGiven:1; + unsigned B3SOIPDpagidlGiven:1; + unsigned B3SOIPDpbgidlGiven:1; + unsigned B3SOIPDpngidlGiven:1; + unsigned B3SOIPDpntunGiven:1; + unsigned B3SOIPDpndiodeGiven:1; + unsigned B3SOIPDpnrecf0Given:1; + unsigned B3SOIPDpnrecr0Given:1; + unsigned B3SOIPDpisbjtGiven:1; + unsigned B3SOIPDpisdifGiven:1; + unsigned B3SOIPDpisrecGiven:1; + unsigned B3SOIPDpistunGiven:1; + unsigned B3SOIPDpvrec0Given:1; + unsigned B3SOIPDpvtun0Given:1; + unsigned B3SOIPDpnbjtGiven:1; + unsigned B3SOIPDplbjt0Given:1; + unsigned B3SOIPDpvabjtGiven:1; + unsigned B3SOIPDpaelyGiven:1; + unsigned B3SOIPDpahliGiven:1; + /* CV model */ + unsigned B3SOIPDpvsdfbGiven:1; + unsigned B3SOIPDpvsdthGiven:1; + unsigned B3SOIPDpdelvtGiven:1; + unsigned B3SOIPDpacdeGiven:1; + unsigned B3SOIPDpmoinGiven:1; +/* Added for binning - END2 */ + + unsigned B3SOIPDuseFringeGiven:1; + + unsigned B3SOIPDtnomGiven:1; + unsigned B3SOIPDcgsoGiven:1; + unsigned B3SOIPDcgdoGiven:1; + unsigned B3SOIPDcgeoGiven:1; + unsigned B3SOIPDxpartGiven:1; + unsigned B3SOIPDsheetResistanceGiven:1; + unsigned B3SOIPDGatesidewallJctPotentialGiven:1; + unsigned B3SOIPDbodyJctGateSideGradingCoeffGiven:1; + unsigned B3SOIPDunitLengthGateSidewallJctCapGiven:1; + unsigned B3SOIPDcsdeswGiven:1; + + unsigned B3SOIPDoxideTrapDensityAGiven:1; + unsigned B3SOIPDoxideTrapDensityBGiven:1; + unsigned B3SOIPDoxideTrapDensityCGiven:1; + unsigned B3SOIPDemGiven:1; + unsigned B3SOIPDefGiven:1; + unsigned B3SOIPDafGiven:1; + unsigned B3SOIPDkfGiven:1; + unsigned B3SOIPDnoifGiven:1; + + unsigned B3SOIPDLintGiven:1; + unsigned B3SOIPDLlGiven:1; + unsigned B3SOIPDLlnGiven:1; + unsigned B3SOIPDLwGiven:1; + unsigned B3SOIPDLwnGiven:1; + unsigned B3SOIPDLwlGiven:1; + unsigned B3SOIPDLminGiven:1; + unsigned B3SOIPDLmaxGiven:1; + + unsigned B3SOIPDWintGiven:1; + unsigned B3SOIPDWlGiven:1; + unsigned B3SOIPDWlnGiven:1; + unsigned B3SOIPDWwGiven:1; + unsigned B3SOIPDWwnGiven:1; + unsigned B3SOIPDWwlGiven:1; + unsigned B3SOIPDWminGiven:1; + unsigned B3SOIPDWmaxGiven:1; + +} +B3SOIPDmodel; + + +#ifndef NMOS +#define NMOS 1 +#define PMOS -1 +#endif /*NMOS*/ +/* device parameters */ +#define B3SOIPD_W 1 +#define B3SOIPD_L 2 +#define B3SOIPD_AS 3 +#define B3SOIPD_AD 4 +#define B3SOIPD_PS 5 +#define B3SOIPD_PD 6 +#define B3SOIPD_NRS 7 +#define B3SOIPD_NRD 8 +#define B3SOIPD_OFF 9 +#define B3SOIPD_IC_VBS 10 +#define B3SOIPD_IC_VDS 11 +#define B3SOIPD_IC_VGS 12 +#define B3SOIPD_IC_VES 13 +#define B3SOIPD_IC_VPS 14 +#define B3SOIPD_BJTOFF 15 +#define B3SOIPD_RTH0 16 +#define B3SOIPD_CTH0 17 +#define B3SOIPD_NRB 18 +#define B3SOIPD_IC 19 +#define B3SOIPD_NQSMOD 20 +#define B3SOIPD_DEBUG 21 +/* v2.0 release */ +#define B3SOIPD_NBC 22 +#define B3SOIPD_NSEG 23 +#define B3SOIPD_PDBCP 24 +#define B3SOIPD_PSBCP 25 +#define B3SOIPD_AGBCP 26 +#define B3SOIPD_AEBCP 27 +#define B3SOIPD_VBSUSR 28 +#define B3SOIPD_TNODEOUT 29 +/* model parameters */ +#define B3SOIPD_MOD_CAPMOD 101 +#define B3SOIPD_MOD_NQSMOD 102 +#define B3SOIPD_MOD_MOBMOD 103 +#define B3SOIPD_MOD_NOIMOD 104 +#define B3SOIPD_MOD_SHMOD 105 +#define B3SOIPD_MOD_DDMOD 106 +#define B3SOIPD_MOD_TOX 107 +#define B3SOIPD_MOD_CDSC 108 +#define B3SOIPD_MOD_CDSCB 109 +#define B3SOIPD_MOD_CIT 110 +#define B3SOIPD_MOD_NFACTOR 111 +#define B3SOIPD_MOD_XJ 112 +#define B3SOIPD_MOD_VSAT 113 +#define B3SOIPD_MOD_AT 114 +#define B3SOIPD_MOD_A0 115 +#define B3SOIPD_MOD_A1 116 +#define B3SOIPD_MOD_A2 117 +#define B3SOIPD_MOD_KETA 118 +#define B3SOIPD_MOD_NSUB 119 +#define B3SOIPD_MOD_NPEAK 120 +#define B3SOIPD_MOD_NGATE 121 +#define B3SOIPD_MOD_GAMMA1 122 +#define B3SOIPD_MOD_GAMMA2 123 +#define B3SOIPD_MOD_VBX 124 +#define B3SOIPD_MOD_BINUNIT 125 +#define B3SOIPD_MOD_VBM 126 +#define B3SOIPD_MOD_XT 127 +#define B3SOIPD_MOD_K1 129 +#define B3SOIPD_MOD_KT1 130 +#define B3SOIPD_MOD_KT1L 131 +#define B3SOIPD_MOD_K2 132 +#define B3SOIPD_MOD_KT2 133 +#define B3SOIPD_MOD_K3 134 +#define B3SOIPD_MOD_K3B 135 +#define B3SOIPD_MOD_W0 136 +#define B3SOIPD_MOD_NLX 137 +#define B3SOIPD_MOD_DVT0 138 +#define B3SOIPD_MOD_DVT1 139 +#define B3SOIPD_MOD_DVT2 140 +#define B3SOIPD_MOD_DVT0W 141 +#define B3SOIPD_MOD_DVT1W 142 +#define B3SOIPD_MOD_DVT2W 143 +#define B3SOIPD_MOD_DROUT 144 +#define B3SOIPD_MOD_DSUB 145 +#define B3SOIPD_MOD_VTH0 146 +#define B3SOIPD_MOD_UA 147 +#define B3SOIPD_MOD_UA1 148 +#define B3SOIPD_MOD_UB 149 +#define B3SOIPD_MOD_UB1 150 +#define B3SOIPD_MOD_UC 151 +#define B3SOIPD_MOD_UC1 152 +#define B3SOIPD_MOD_U0 153 +#define B3SOIPD_MOD_UTE 154 +#define B3SOIPD_MOD_VOFF 155 +#define B3SOIPD_MOD_DELTA 156 +#define B3SOIPD_MOD_RDSW 157 +#define B3SOIPD_MOD_PRT 158 +#define B3SOIPD_MOD_LDD 159 +#define B3SOIPD_MOD_ETA 160 +#define B3SOIPD_MOD_ETA0 161 +#define B3SOIPD_MOD_ETAB 162 +#define B3SOIPD_MOD_PCLM 163 +#define B3SOIPD_MOD_PDIBL1 164 +#define B3SOIPD_MOD_PDIBL2 165 +#define B3SOIPD_MOD_PSCBE1 166 +#define B3SOIPD_MOD_PSCBE2 167 +#define B3SOIPD_MOD_PVAG 168 +#define B3SOIPD_MOD_WR 169 +#define B3SOIPD_MOD_DWG 170 +#define B3SOIPD_MOD_DWB 171 +#define B3SOIPD_MOD_B0 172 +#define B3SOIPD_MOD_B1 173 +#define B3SOIPD_MOD_ALPHA0 174 +#define B3SOIPD_MOD_PDIBLB 178 +#define B3SOIPD_MOD_PRWG 179 +#define B3SOIPD_MOD_PRWB 180 +#define B3SOIPD_MOD_CDSCD 181 +#define B3SOIPD_MOD_AGS 182 +#define B3SOIPD_MOD_FRINGE 184 +#define B3SOIPD_MOD_CGSL 186 +#define B3SOIPD_MOD_CGDL 187 +#define B3SOIPD_MOD_CKAPPA 188 +#define B3SOIPD_MOD_CF 189 +#define B3SOIPD_MOD_CLC 190 +#define B3SOIPD_MOD_CLE 191 +#define B3SOIPD_MOD_PARAMCHK 192 +#define B3SOIPD_MOD_VERSION 193 +#define B3SOIPD_MOD_TBOX 195 +#define B3SOIPD_MOD_TSI 196 +#define B3SOIPD_MOD_KB1 197 +#define B3SOIPD_MOD_KB3 198 +#define B3SOIPD_MOD_DVBD0 199 +#define B3SOIPD_MOD_DVBD1 200 +#define B3SOIPD_MOD_DELP 201 +#define B3SOIPD_MOD_VBSA 202 +#define B3SOIPD_MOD_RBODY 204 +#define B3SOIPD_MOD_ADICE0 205 +#define B3SOIPD_MOD_ABP 206 +#define B3SOIPD_MOD_MXC 207 +#define B3SOIPD_MOD_RTH0 208 +#define B3SOIPD_MOD_CTH0 209 +#define B3SOIPD_MOD_ALPHA1 214 +#define B3SOIPD_MOD_NGIDL 215 +#define B3SOIPD_MOD_AGIDL 216 +#define B3SOIPD_MOD_BGIDL 217 +#define B3SOIPD_MOD_NDIODE 218 +#define B3SOIPD_MOD_LDIOF 219 +#define B3SOIPD_MOD_LDIOR 220 +#define B3SOIPD_MOD_NTUN 221 +#define B3SOIPD_MOD_ISBJT 222 +#define B3SOIPD_MOD_ISDIF 223 +#define B3SOIPD_MOD_ISREC 224 +#define B3SOIPD_MOD_ISTUN 225 +#define B3SOIPD_MOD_XBJT 226 +#define B3SOIPD_MOD_XDIF 227 +#define B3SOIPD_MOD_XREC 228 +#define B3SOIPD_MOD_XTUN 229 +#define B3SOIPD_MOD_TT 232 +#define B3SOIPD_MOD_VSDTH 233 +#define B3SOIPD_MOD_VSDFB 234 +#define B3SOIPD_MOD_ASD 235 +#define B3SOIPD_MOD_CSDMIN 236 +#define B3SOIPD_MOD_RBSH 237 +#define B3SOIPD_MOD_ESATII 238 +/* v2.0 release */ +#define B3SOIPD_MOD_K1W1 239 +#define B3SOIPD_MOD_K1W2 240 +#define B3SOIPD_MOD_KETAS 241 +#define B3SOIPD_MOD_DWBC 242 +#define B3SOIPD_MOD_BETA0 243 +#define B3SOIPD_MOD_BETA1 244 +#define B3SOIPD_MOD_BETA2 245 +#define B3SOIPD_MOD_VDSATII0 246 +#define B3SOIPD_MOD_TII 247 +#define B3SOIPD_MOD_LII 248 +#define B3SOIPD_MOD_SII0 249 +#define B3SOIPD_MOD_SII1 250 +#define B3SOIPD_MOD_SII2 251 +#define B3SOIPD_MOD_SIID 252 +#define B3SOIPD_MOD_FBJTII 253 +#define B3SOIPD_MOD_NRECF0 255 +#define B3SOIPD_MOD_NRECR0 256 +#define B3SOIPD_MOD_LN 257 +#define B3SOIPD_MOD_VREC0 258 +#define B3SOIPD_MOD_VTUN0 259 +#define B3SOIPD_MOD_NBJT 260 +#define B3SOIPD_MOD_LBJT0 261 +#define B3SOIPD_MOD_VABJT 262 +#define B3SOIPD_MOD_AELY 263 +#define B3SOIPD_MOD_AHLI 264 +#define B3SOIPD_MOD_NTRECF 265 +#define B3SOIPD_MOD_NTRECR 266 +#define B3SOIPD_MOD_DLCB 267 +#define B3SOIPD_MOD_FBODY 268 +#define B3SOIPD_MOD_NDIF 269 +#define B3SOIPD_MOD_TCJSWG 270 +#define B3SOIPD_MOD_TPBSWG 271 +#define B3SOIPD_MOD_ACDE 272 +#define B3SOIPD_MOD_MOIN 273 +#define B3SOIPD_MOD_DELVT 274 +#define B3SOIPD_MOD_DLBG 275 +#define B3SOIPD_MOD_LDIF0 276 +/* v2.2 release */ +#define B3SOIPD_MOD_WTH0 277 +#define B3SOIPD_MOD_RHALO 278 +#define B3SOIPD_MOD_NTOX 279 +#define B3SOIPD_MOD_TOXREF 280 +#define B3SOIPD_MOD_EBG 281 +#define B3SOIPD_MOD_NEVB 282 +#define B3SOIPD_MOD_ALPHAGB1 283 +#define B3SOIPD_MOD_BETAGB1 284 +#define B3SOIPD_MOD_VGB1 285 +#define B3SOIPD_MOD_NECB 286 +#define B3SOIPD_MOD_ALPHAGB2 287 +#define B3SOIPD_MOD_BETAGB2 288 +#define B3SOIPD_MOD_VGB2 289 +#define B3SOIPD_MOD_TOXQM 290 +#define B3SOIPD_MOD_IGMOD 291 +#define B3SOIPD_MOD_VOXH 292 +#define B3SOIPD_MOD_DELTAVOX 293 +/* Added for binning - START3 */ +/* Length dependence */ +#define B3SOIPD_MOD_LNPEAK 301 +#define B3SOIPD_MOD_LNSUB 302 +#define B3SOIPD_MOD_LNGATE 303 +#define B3SOIPD_MOD_LVTH0 304 +#define B3SOIPD_MOD_LK1 305 +#define B3SOIPD_MOD_LK1W1 306 +#define B3SOIPD_MOD_LK1W2 307 +#define B3SOIPD_MOD_LK2 308 +#define B3SOIPD_MOD_LK3 309 +#define B3SOIPD_MOD_LK3B 310 +#define B3SOIPD_MOD_LKB1 311 +#define B3SOIPD_MOD_LW0 312 +#define B3SOIPD_MOD_LNLX 313 +#define B3SOIPD_MOD_LDVT0 314 +#define B3SOIPD_MOD_LDVT1 315 +#define B3SOIPD_MOD_LDVT2 316 +#define B3SOIPD_MOD_LDVT0W 317 +#define B3SOIPD_MOD_LDVT1W 318 +#define B3SOIPD_MOD_LDVT2W 319 +#define B3SOIPD_MOD_LU0 320 +#define B3SOIPD_MOD_LUA 321 +#define B3SOIPD_MOD_LUB 322 +#define B3SOIPD_MOD_LUC 323 +#define B3SOIPD_MOD_LVSAT 324 +#define B3SOIPD_MOD_LA0 325 +#define B3SOIPD_MOD_LAGS 326 +#define B3SOIPD_MOD_LB0 327 +#define B3SOIPD_MOD_LB1 328 +#define B3SOIPD_MOD_LKETA 329 +#define B3SOIPD_MOD_LKETAS 330 +#define B3SOIPD_MOD_LA1 331 +#define B3SOIPD_MOD_LA2 332 +#define B3SOIPD_MOD_LRDSW 333 +#define B3SOIPD_MOD_LPRWB 334 +#define B3SOIPD_MOD_LPRWG 335 +#define B3SOIPD_MOD_LWR 336 +#define B3SOIPD_MOD_LNFACTOR 337 +#define B3SOIPD_MOD_LDWG 338 +#define B3SOIPD_MOD_LDWB 339 +#define B3SOIPD_MOD_LVOFF 340 +#define B3SOIPD_MOD_LETA0 341 +#define B3SOIPD_MOD_LETAB 342 +#define B3SOIPD_MOD_LDSUB 343 +#define B3SOIPD_MOD_LCIT 344 +#define B3SOIPD_MOD_LCDSC 345 +#define B3SOIPD_MOD_LCDSCB 346 +#define B3SOIPD_MOD_LCDSCD 347 +#define B3SOIPD_MOD_LPCLM 348 +#define B3SOIPD_MOD_LPDIBL1 349 +#define B3SOIPD_MOD_LPDIBL2 350 +#define B3SOIPD_MOD_LPDIBLB 351 +#define B3SOIPD_MOD_LDROUT 352 +#define B3SOIPD_MOD_LPVAG 353 +#define B3SOIPD_MOD_LDELTA 354 +#define B3SOIPD_MOD_LALPHA0 355 +#define B3SOIPD_MOD_LFBJTII 356 +#define B3SOIPD_MOD_LBETA0 357 +#define B3SOIPD_MOD_LBETA1 358 +#define B3SOIPD_MOD_LBETA2 359 +#define B3SOIPD_MOD_LVDSATII0 360 +#define B3SOIPD_MOD_LLII 361 +#define B3SOIPD_MOD_LESATII 362 +#define B3SOIPD_MOD_LSII0 363 +#define B3SOIPD_MOD_LSII1 364 +#define B3SOIPD_MOD_LSII2 365 +#define B3SOIPD_MOD_LSIID 366 +#define B3SOIPD_MOD_LAGIDL 367 +#define B3SOIPD_MOD_LBGIDL 368 +#define B3SOIPD_MOD_LNGIDL 369 +#define B3SOIPD_MOD_LNTUN 370 +#define B3SOIPD_MOD_LNDIODE 371 +#define B3SOIPD_MOD_LNRECF0 372 +#define B3SOIPD_MOD_LNRECR0 373 +#define B3SOIPD_MOD_LISBJT 374 +#define B3SOIPD_MOD_LISDIF 375 +#define B3SOIPD_MOD_LISREC 376 +#define B3SOIPD_MOD_LISTUN 377 +#define B3SOIPD_MOD_LVREC0 378 +#define B3SOIPD_MOD_LVTUN0 379 +#define B3SOIPD_MOD_LNBJT 380 +#define B3SOIPD_MOD_LLBJT0 381 +#define B3SOIPD_MOD_LVABJT 382 +#define B3SOIPD_MOD_LAELY 383 +#define B3SOIPD_MOD_LAHLI 384 +#define B3SOIPD_MOD_LVSDFB 385 +#define B3SOIPD_MOD_LVSDTH 386 +#define B3SOIPD_MOD_LDELVT 387 +#define B3SOIPD_MOD_LACDE 388 +#define B3SOIPD_MOD_LMOIN 389 +/* Width dependence */ +#define B3SOIPD_MOD_WNPEAK 401 +#define B3SOIPD_MOD_WNSUB 402 +#define B3SOIPD_MOD_WNGATE 403 +#define B3SOIPD_MOD_WVTH0 404 +#define B3SOIPD_MOD_WK1 405 +#define B3SOIPD_MOD_WK1W1 406 +#define B3SOIPD_MOD_WK1W2 407 +#define B3SOIPD_MOD_WK2 408 +#define B3SOIPD_MOD_WK3 409 +#define B3SOIPD_MOD_WK3B 410 +#define B3SOIPD_MOD_WKB1 411 +#define B3SOIPD_MOD_WW0 412 +#define B3SOIPD_MOD_WNLX 413 +#define B3SOIPD_MOD_WDVT0 414 +#define B3SOIPD_MOD_WDVT1 415 +#define B3SOIPD_MOD_WDVT2 416 +#define B3SOIPD_MOD_WDVT0W 417 +#define B3SOIPD_MOD_WDVT1W 418 +#define B3SOIPD_MOD_WDVT2W 419 +#define B3SOIPD_MOD_WU0 420 +#define B3SOIPD_MOD_WUA 421 +#define B3SOIPD_MOD_WUB 422 +#define B3SOIPD_MOD_WUC 423 +#define B3SOIPD_MOD_WVSAT 424 +#define B3SOIPD_MOD_WA0 425 +#define B3SOIPD_MOD_WAGS 426 +#define B3SOIPD_MOD_WB0 427 +#define B3SOIPD_MOD_WB1 428 +#define B3SOIPD_MOD_WKETA 429 +#define B3SOIPD_MOD_WKETAS 430 +#define B3SOIPD_MOD_WA1 431 +#define B3SOIPD_MOD_WA2 432 +#define B3SOIPD_MOD_WRDSW 433 +#define B3SOIPD_MOD_WPRWB 434 +#define B3SOIPD_MOD_WPRWG 435 +#define B3SOIPD_MOD_WWR 436 +#define B3SOIPD_MOD_WNFACTOR 437 +#define B3SOIPD_MOD_WDWG 438 +#define B3SOIPD_MOD_WDWB 439 +#define B3SOIPD_MOD_WVOFF 440 +#define B3SOIPD_MOD_WETA0 441 +#define B3SOIPD_MOD_WETAB 442 +#define B3SOIPD_MOD_WDSUB 443 +#define B3SOIPD_MOD_WCIT 444 +#define B3SOIPD_MOD_WCDSC 445 +#define B3SOIPD_MOD_WCDSCB 446 +#define B3SOIPD_MOD_WCDSCD 447 +#define B3SOIPD_MOD_WPCLM 448 +#define B3SOIPD_MOD_WPDIBL1 449 +#define B3SOIPD_MOD_WPDIBL2 450 +#define B3SOIPD_MOD_WPDIBLB 451 +#define B3SOIPD_MOD_WDROUT 452 +#define B3SOIPD_MOD_WPVAG 453 +#define B3SOIPD_MOD_WDELTA 454 +#define B3SOIPD_MOD_WALPHA0 455 +#define B3SOIPD_MOD_WFBJTII 456 +#define B3SOIPD_MOD_WBETA0 457 +#define B3SOIPD_MOD_WBETA1 458 +#define B3SOIPD_MOD_WBETA2 459 +#define B3SOIPD_MOD_WVDSATII0 460 +#define B3SOIPD_MOD_WLII 461 +#define B3SOIPD_MOD_WESATII 462 +#define B3SOIPD_MOD_WSII0 463 +#define B3SOIPD_MOD_WSII1 464 +#define B3SOIPD_MOD_WSII2 465 +#define B3SOIPD_MOD_WSIID 466 +#define B3SOIPD_MOD_WAGIDL 467 +#define B3SOIPD_MOD_WBGIDL 468 +#define B3SOIPD_MOD_WNGIDL 469 +#define B3SOIPD_MOD_WNTUN 470 +#define B3SOIPD_MOD_WNDIODE 471 +#define B3SOIPD_MOD_WNRECF0 472 +#define B3SOIPD_MOD_WNRECR0 473 +#define B3SOIPD_MOD_WISBJT 474 +#define B3SOIPD_MOD_WISDIF 475 +#define B3SOIPD_MOD_WISREC 476 +#define B3SOIPD_MOD_WISTUN 477 +#define B3SOIPD_MOD_WVREC0 478 +#define B3SOIPD_MOD_WVTUN0 479 +#define B3SOIPD_MOD_WNBJT 480 +#define B3SOIPD_MOD_WLBJT0 481 +#define B3SOIPD_MOD_WVABJT 482 +#define B3SOIPD_MOD_WAELY 483 +#define B3SOIPD_MOD_WAHLI 484 +#define B3SOIPD_MOD_WVSDFB 485 +#define B3SOIPD_MOD_WVSDTH 486 +#define B3SOIPD_MOD_WDELVT 487 +#define B3SOIPD_MOD_WACDE 488 +#define B3SOIPD_MOD_WMOIN 489 +/* Cross-term dependence */ +#define B3SOIPD_MOD_PNPEAK 501 +#define B3SOIPD_MOD_PNSUB 502 +#define B3SOIPD_MOD_PNGATE 503 +#define B3SOIPD_MOD_PVTH0 504 +#define B3SOIPD_MOD_PK1 505 +#define B3SOIPD_MOD_PK1W1 506 +#define B3SOIPD_MOD_PK1W2 507 +#define B3SOIPD_MOD_PK2 508 +#define B3SOIPD_MOD_PK3 509 +#define B3SOIPD_MOD_PK3B 510 +#define B3SOIPD_MOD_PKB1 511 +#define B3SOIPD_MOD_PW0 512 +#define B3SOIPD_MOD_PNLX 513 +#define B3SOIPD_MOD_PDVT0 514 +#define B3SOIPD_MOD_PDVT1 515 +#define B3SOIPD_MOD_PDVT2 516 +#define B3SOIPD_MOD_PDVT0W 517 +#define B3SOIPD_MOD_PDVT1W 518 +#define B3SOIPD_MOD_PDVT2W 519 +#define B3SOIPD_MOD_PU0 520 +#define B3SOIPD_MOD_PUA 521 +#define B3SOIPD_MOD_PUB 522 +#define B3SOIPD_MOD_PUC 523 +#define B3SOIPD_MOD_PVSAT 524 +#define B3SOIPD_MOD_PA0 525 +#define B3SOIPD_MOD_PAGS 526 +#define B3SOIPD_MOD_PB0 527 +#define B3SOIPD_MOD_PB1 528 +#define B3SOIPD_MOD_PKETA 529 +#define B3SOIPD_MOD_PKETAS 530 +#define B3SOIPD_MOD_PA1 531 +#define B3SOIPD_MOD_PA2 532 +#define B3SOIPD_MOD_PRDSW 533 +#define B3SOIPD_MOD_PPRWB 534 +#define B3SOIPD_MOD_PPRWG 535 +#define B3SOIPD_MOD_PWR 536 +#define B3SOIPD_MOD_PNFACTOR 537 +#define B3SOIPD_MOD_PDWG 538 +#define B3SOIPD_MOD_PDWB 539 +#define B3SOIPD_MOD_PVOFF 540 +#define B3SOIPD_MOD_PETA0 541 +#define B3SOIPD_MOD_PETAB 542 +#define B3SOIPD_MOD_PDSUB 543 +#define B3SOIPD_MOD_PCIT 544 +#define B3SOIPD_MOD_PCDSC 545 +#define B3SOIPD_MOD_PCDSCB 546 +#define B3SOIPD_MOD_PCDSCD 547 +#define B3SOIPD_MOD_PPCLM 548 +#define B3SOIPD_MOD_PPDIBL1 549 +#define B3SOIPD_MOD_PPDIBL2 550 +#define B3SOIPD_MOD_PPDIBLB 551 +#define B3SOIPD_MOD_PDROUT 552 +#define B3SOIPD_MOD_PPVAG 553 +#define B3SOIPD_MOD_PDELTA 554 +#define B3SOIPD_MOD_PALPHA0 555 +#define B3SOIPD_MOD_PFBJTII 556 +#define B3SOIPD_MOD_PBETA0 557 +#define B3SOIPD_MOD_PBETA1 558 +#define B3SOIPD_MOD_PBETA2 559 +#define B3SOIPD_MOD_PVDSATII0 560 +#define B3SOIPD_MOD_PLII 561 +#define B3SOIPD_MOD_PESATII 562 +#define B3SOIPD_MOD_PSII0 563 +#define B3SOIPD_MOD_PSII1 564 +#define B3SOIPD_MOD_PSII2 565 +#define B3SOIPD_MOD_PSIID 566 +#define B3SOIPD_MOD_PAGIDL 567 +#define B3SOIPD_MOD_PBGIDL 568 +#define B3SOIPD_MOD_PNGIDL 569 +#define B3SOIPD_MOD_PNTUN 570 +#define B3SOIPD_MOD_PNDIODE 571 +#define B3SOIPD_MOD_PNRECF0 572 +#define B3SOIPD_MOD_PNRECR0 573 +#define B3SOIPD_MOD_PISBJT 574 +#define B3SOIPD_MOD_PISDIF 575 +#define B3SOIPD_MOD_PISREC 576 +#define B3SOIPD_MOD_PISTUN 577 +#define B3SOIPD_MOD_PVREC0 578 +#define B3SOIPD_MOD_PVTUN0 579 +#define B3SOIPD_MOD_PNBJT 580 +#define B3SOIPD_MOD_PLBJT0 581 +#define B3SOIPD_MOD_PVABJT 582 +#define B3SOIPD_MOD_PAELY 583 +#define B3SOIPD_MOD_PAHLI 584 +#define B3SOIPD_MOD_PVSDFB 585 +#define B3SOIPD_MOD_PVSDTH 586 +#define B3SOIPD_MOD_PDELVT 587 +#define B3SOIPD_MOD_PACDE 588 +#define B3SOIPD_MOD_PMOIN 589 +/* Added for binning - END3 */ +#define B3SOIPD_MOD_TNOM 701 +#define B3SOIPD_MOD_CGSO 702 +#define B3SOIPD_MOD_CGDO 703 +#define B3SOIPD_MOD_CGEO 704 +#define B3SOIPD_MOD_XPART 705 +#define B3SOIPD_MOD_RSH 706 +#define B3SOIPD_MOD_NMOS 814 +#define B3SOIPD_MOD_PMOS 815 +#define B3SOIPD_MOD_NOIA 816 +#define B3SOIPD_MOD_NOIB 817 +#define B3SOIPD_MOD_NOIC 818 +#define B3SOIPD_MOD_LINT 819 +#define B3SOIPD_MOD_LL 820 +#define B3SOIPD_MOD_LLN 821 +#define B3SOIPD_MOD_LW 822 +#define B3SOIPD_MOD_LWN 823 +#define B3SOIPD_MOD_LWL 824 +#define B3SOIPD_MOD_WINT 827 +#define B3SOIPD_MOD_WL 828 +#define B3SOIPD_MOD_WLN 829 +#define B3SOIPD_MOD_WW 830 +#define B3SOIPD_MOD_WWN 831 +#define B3SOIPD_MOD_WWL 832 +#define B3SOIPD_MOD_DWC 835 +#define B3SOIPD_MOD_DLC 836 +#define B3SOIPD_MOD_EM 837 +#define B3SOIPD_MOD_EF 838 +#define B3SOIPD_MOD_AF 839 +#define B3SOIPD_MOD_KF 840 +#define B3SOIPD_MOD_NOIF 841 +#define B3SOIPD_MOD_PBSWG 843 +#define B3SOIPD_MOD_MJSWG 844 +#define B3SOIPD_MOD_CJSWG 845 +#define B3SOIPD_MOD_CSDESW 846 +/* device questions */ +#define B3SOIPD_DNODE 901 +#define B3SOIPD_GNODE 902 +#define B3SOIPD_SNODE 903 +#define B3SOIPD_BNODE 904 +#define B3SOIPD_ENODE 905 +#define B3SOIPD_DNODEPRIME 906 +#define B3SOIPD_SNODEPRIME 907 +#define B3SOIPD_VBD 908 +#define B3SOIPD_VBS 909 +#define B3SOIPD_VGS 910 +#define B3SOIPD_VES 911 +#define B3SOIPD_VDS 912 +#define B3SOIPD_CD 913 +#define B3SOIPD_CBS 914 +#define B3SOIPD_CBD 915 +#define B3SOIPD_GM 916 +#define B3SOIPD_GDS 917 +#define B3SOIPD_GMBS 918 +#define B3SOIPD_GBD 919 +#define B3SOIPD_GBS 920 +#define B3SOIPD_QB 921 +#define B3SOIPD_CQB 922 +#define B3SOIPD_QG 923 +#define B3SOIPD_CQG 924 +#define B3SOIPD_QD 925 +#define B3SOIPD_CQD 926 +#define B3SOIPD_CGG 927 +#define B3SOIPD_CGD 928 +#define B3SOIPD_CGS 929 +#define B3SOIPD_CBG 930 +#define B3SOIPD_CAPBD 931 +#define B3SOIPD_CQBD 932 +#define B3SOIPD_CAPBS 933 +#define B3SOIPD_CQBS 934 +#define B3SOIPD_CDG 935 +#define B3SOIPD_CDD 936 +#define B3SOIPD_CDS 937 +#define B3SOIPD_VON 938 +#define B3SOIPD_VDSAT 939 +#define B3SOIPD_QBS 940 +#define B3SOIPD_QBD 941 +#define B3SOIPD_SOURCECONDUCT 942 +#define B3SOIPD_DRAINCONDUCT 943 +#define B3SOIPD_CBDB 944 +#define B3SOIPD_CBSB 945 +#define B3SOIPD_GMID 946 +#include "b3soipdext.h" +#ifdef __STDC__ +extern void B3SOIPDevaluate (double, double, double, B3SOIPDinstance *, + B3SOIPDmodel *, double *, double *, double *, + double *, double *, double *, double *, double *, + double *, double *, double *, double *, double *, + double *, double *, double *, double *, double *, + CKTcircuit *); +extern int B3SOIPDdebug (B3SOIPDmodel *, B3SOIPDinstance *, CKTcircuit *, + int); +extern int B3SOIPDcheckModel (B3SOIPDmodel *, B3SOIPDinstance *, + CKTcircuit *); +#else /* stdc */ +extern void B3SOIPDevaluate (); +extern int B3SOIPDdebug (); +extern int B3SOIPDcheckModel (); +#endif /* stdc */ + +#endif /*B3SOIPD */ diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipddel.c b/src/spicelib/devices/bsim3soi_pd/b3soipddel.c new file mode 100644 index 000000000..4d646cbc6 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipddel.c @@ -0,0 +1,42 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipddel.c 98/5/01 +**********/ + + +#include "ngspice.h" +#include +#include "b3soipddef.h" +#include "sperror.h" +#include "gendefs.h" +#include "suffix.h" + + +int +B3SOIPDdelete (inModel, name, inInst) + GENmodel *inModel; + IFuid name; + GENinstance **inInst; +{ + B3SOIPDinstance **fast = (B3SOIPDinstance **) inInst; + B3SOIPDmodel *model = (B3SOIPDmodel *) inModel; + B3SOIPDinstance **prev = NULL; + B3SOIPDinstance *here; + + for (; model; model = model->B3SOIPDnextModel) + { + prev = &(model->B3SOIPDinstances); + for (here = *prev; here; here = *prev) + { + if (here->B3SOIPDname == name || (fast && here == *fast)) + { + *prev = here->B3SOIPDnextInstance; + FREE (here); + return (OK); + } + prev = &(here->B3SOIPDnextInstance); + } + } + return (E_NODEV); +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipddest.c b/src/spicelib/devices/bsim3soi_pd/b3soipddest.c new file mode 100644 index 000000000..47ea96a96 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipddest.c @@ -0,0 +1,43 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipddest.c 98/5/01 +**********/ + + +#include "ngspice.h" +#include +#include "b3soipddef.h" +#include "suffix.h" + +void +B3SOIPDdestroy (inModel) + GENmodel **inModel; +{ + B3SOIPDmodel **model = (B3SOIPDmodel **) inModel; + B3SOIPDinstance *here; + B3SOIPDinstance *prev = NULL; + B3SOIPDmodel *mod = *model; + B3SOIPDmodel *oldmod = NULL; + + for (; mod; mod = mod->B3SOIPDnextModel) + { + if (oldmod) + FREE (oldmod); + oldmod = mod; + prev = (B3SOIPDinstance *) NULL; + for (here = mod->B3SOIPDinstances; here; + here = here->B3SOIPDnextInstance) + { + if (prev) + FREE (prev); + prev = here; + } + if (prev) + FREE (prev); + } + if (oldmod) + FREE (oldmod); + *model = NULL; + return; +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdext.h b/src/spicelib/devices/bsim3soi_pd/b3soipdext.h new file mode 100644 index 000000000..874bff3cf --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdext.h @@ -0,0 +1,55 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung +File: b3soipdext.h +**********/ + +#ifdef __STDC__ +extern int B3SOIPDacLoad (GENmodel *, CKTcircuit *); +extern int B3SOIPDask (CKTcircuit *, GENinstance *, int, IFvalue *, + IFvalue *); +extern int B3SOIPDconvTest (GENmodel *, CKTcircuit *); +extern int B3SOIPDdelete (GENmodel *, IFuid, GENinstance **); +extern void B3SOIPDdestroy (GENmodel **); +extern int B3SOIPDgetic (GENmodel *, CKTcircuit *); +extern int B3SOIPDload (GENmodel *, CKTcircuit *); +extern int B3SOIPDmAsk (CKTcircuit *, GENmodel *, int, IFvalue *); +extern int B3SOIPDmDelete (GENmodel **, IFuid, GENmodel *); +extern int B3SOIPDmParam (int, IFvalue *, GENmodel *); +extern void B3SOIPDmosCap (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 B3SOIPDparam (int, IFvalue *, GENinstance *, IFvalue *); +extern int B3SOIPDpzLoad (GENmodel *, CKTcircuit *, SPcomplex *); +extern int B3SOIPDsetup (SMPmatrix *, GENmodel *, CKTcircuit *, int *); +extern int B3SOIPDtemp (GENmodel *, CKTcircuit *); +extern int B3SOIPDtrunc (GENmodel *, CKTcircuit *, double *); +extern int B3SOIPDnoise (int, int, GENmodel *, CKTcircuit *, Ndata *, + double *); +extern int B3SOIPDunsetup (GENmodel *, CKTcircuit *); + +#else /* stdc */ +extern int B3SOIPDacLoad (); +extern int B3SOIPDdelete (); +extern void B3SOIPDdestroy (); +extern int B3SOIPDgetic (); +extern int B3SOIPDload (); +extern int B3SOIPDmDelete (); +extern int B3SOIPDask (); +extern int B3SOIPDmAsk (); +extern int B3SOIPDconvTest (); +extern int B3SOIPDtemp (); +extern int B3SOIPDmParam (); +extern void B3SOIPDmosCap (); +extern int B3SOIPDparam (); +extern int B3SOIPDpzLoad (); +extern int B3SOIPDsetup (); +extern int B3SOIPDtrunc (); +extern int B3SOIPDnoise (); +extern int B3SOIPDunsetup (); + +#endif /* stdc */ diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdgetic.c b/src/spicelib/devices/bsim3soi_pd/b3soipdgetic.c new file mode 100644 index 000000000..56df0e12f --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdgetic.c @@ -0,0 +1,57 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdgetic.c 98/5/01 +**********/ + + +#include "ngspice.h" +#include +#include "cktdefs.h" +#include "b3soipddef.h" +#include "sperror.h" +#include "suffix.h" + + +int +B3SOIPDgetic (inModel, ckt) + GENmodel *inModel; + CKTcircuit *ckt; +{ + B3SOIPDmodel *model = (B3SOIPDmodel *) inModel; + B3SOIPDinstance *here; + + for (; model; model = model->B3SOIPDnextModel) + { + for (here = model->B3SOIPDinstances; here; + here = here->B3SOIPDnextInstance) + { + if (!here->B3SOIPDicVBSGiven) + { + here->B3SOIPDicVBS = *(ckt->CKTrhs + here->B3SOIPDbNode) + - *(ckt->CKTrhs + here->B3SOIPDsNode); + } + if (!here->B3SOIPDicVDSGiven) + { + here->B3SOIPDicVDS = *(ckt->CKTrhs + here->B3SOIPDdNode) + - *(ckt->CKTrhs + here->B3SOIPDsNode); + } + if (!here->B3SOIPDicVGSGiven) + { + here->B3SOIPDicVGS = *(ckt->CKTrhs + here->B3SOIPDgNode) + - *(ckt->CKTrhs + here->B3SOIPDsNode); + } + if (!here->B3SOIPDicVESGiven) + { + here->B3SOIPDicVES = *(ckt->CKTrhs + here->B3SOIPDeNode) + - *(ckt->CKTrhs + here->B3SOIPDsNode); + } + if (!here->B3SOIPDicVPSGiven) + { + here->B3SOIPDicVPS = *(ckt->CKTrhs + here->B3SOIPDpNode) + - *(ckt->CKTrhs + here->B3SOIPDsNode); + } + } + } + return (OK); +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdinit.c b/src/spicelib/devices/bsim3soi_pd/b3soipdinit.c new file mode 100644 index 000000000..b9fdc4606 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdinit.c @@ -0,0 +1,62 @@ +#include + +#include + +#include "b3soipditf.h" +#include "b3soipdext.h" +#include "b3soipdinit.h" + + +SPICEdev B3SOIPDinfo = { + {"B3SOIPD", + "Berkeley SOI (PD) MOSFET model version 2.0", + + &B3SOIPDnSize, + &B3SOIPDnSize, + B3SOIPDnames, + + &B3SOIPDpTSize, + B3SOIPDpTable, + + &B3SOIPDmPTSize, + B3SOIPDmPTable, + DEV_DEFAULT} + , + +DEVparam:B3SOIPDparam, +DEVmodParam:B3SOIPDmParam, +DEVload:B3SOIPDload, +DEVsetup:B3SOIPDsetup, +DEVunsetup:B3SOIPDunsetup, +DEVpzSetup:B3SOIPDsetup, +DEVtemperature:B3SOIPDtemp, +DEVtrunc:B3SOIPDtrunc, +DEVfindBranch:NULL, +DEVacLoad:B3SOIPDacLoad, +DEVaccept:NULL, +DEVdestroy:B3SOIPDdestroy, +DEVmodDelete:B3SOIPDmDelete, +DEVdelete:B3SOIPDdelete, +DEVsetic:B3SOIPDgetic, +DEVask:B3SOIPDask, +DEVmodAsk:B3SOIPDmAsk, +DEVpzLoad:B3SOIPDpzLoad, +DEVconvTest:B3SOIPDconvTest, +DEVsenSetup:NULL, +DEVsenLoad:NULL, +DEVsenUpdate:NULL, +DEVsenAcLoad:NULL, +DEVsenPrint:NULL, +DEVsenTrunc:NULL, +DEVdisto:NULL, +DEVnoise:B3SOIPDnoise, + +DEVinstSize:&B3SOIPDiSize, +DEVmodSize:&B3SOIPDmSize +}; + +SPICEdev * +get_b3soipd_info (void) +{ + return &B3SOIPDinfo; +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdinit.h b/src/spicelib/devices/bsim3soi_pd/b3soipdinit.h new file mode 100644 index 000000000..2a487074e --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdinit.h @@ -0,0 +1,13 @@ +#ifndef _B3SOIPDINIT_H +#define _B3SOIPDINIT_H + +extern IFparm B3SOIPDpTable[]; +extern IFparm B3SOIPDmPTable[]; +extern char *B3SOIPDnames[]; +extern int B3SOIPDpTSize; +extern int B3SOIPDmPTSize; +extern int B3SOIPDnSize; +extern int B3SOIPDiSize; +extern int B3SOIPDmSize; + +#endif diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipditf.h b/src/spicelib/devices/bsim3soi_pd/b3soipditf.h new file mode 100644 index 000000000..2f5ce892f --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipditf.h @@ -0,0 +1,13 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung +File: b3soipditf.h +**********/ +#ifndef DEV_B3SOIPD +#define DEV_B3SOIPD + +#include "b3soipdext.h" + +SPICEdev *get_b3soipd_info (void); + +#endif diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdld.c b/src/spicelib/devices/bsim3soi_pd/b3soipdld.c new file mode 100644 index 000000000..b0fe76304 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdld.c @@ -0,0 +1,4661 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdld.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 +**********/ + + +#include "ngspice.h" +#include +#include +#include "cktdefs.h" +#include "b3soipddef.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 + + + /* B3SOIPDlimit(vnew,vold) + * limits the per-iteration change of any absolute voltage value + */ + +double +B3SOIPDlimit (vnew, vold, limit, check) + 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 +B3SOIPDload (inModel, ckt) + GENmodel *inModel; + register CKTcircuit *ckt; +{ + register B3SOIPDmodel *model = (B3SOIPDmodel *) inModel; + register B3SOIPDinstance *here; + register 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 b3soipdSizeDependParam *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, gppT; + 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; + + +/* 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; + + + for (; model != NULL; model = model->B3SOIPDnextModel) + { + for (here = model->B3SOIPDinstances; here != NULL; + here = here->B3SOIPDnextInstance) + { + Check = 0; + ByPass = 0; + selfheat = (model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0 != 0.0); + pParam = here->pParam; + + + if ((ckt->CKTmode & MODEINITSMSIG)) + { + vs = *(ckt->CKTrhsOld + here->B3SOIPDsNodePrime); + if (!here->B3SOIPDvbsusrGiven) + { + vbs = *(ckt->CKTstate0 + here->B3SOIPDvbs); + vb = *(ckt->CKTrhsOld + here->B3SOIPDbNode); + } + else + { + vbs = here->B3SOIPDvbsusr; + vb = here->B3SOIPDvbsusr + vs; + } + vgs = *(ckt->CKTstate0 + here->B3SOIPDvgs); + ves = *(ckt->CKTstate0 + here->B3SOIPDves); + vps = *(ckt->CKTstate0 + here->B3SOIPDvps); + vds = *(ckt->CKTstate0 + here->B3SOIPDvds); + delTemp = *(ckt->CKTstate0 + here->B3SOIPDdeltemp); + + vg = *(ckt->CKTrhsOld + here->B3SOIPDgNode); + vd = *(ckt->CKTrhsOld + here->B3SOIPDdNodePrime); + vp = *(ckt->CKTrhsOld + here->B3SOIPDpNode); + ve = *(ckt->CKTrhsOld + here->B3SOIPDeNode); + + } + else if ((ckt->CKTmode & MODEINITTRAN)) + { + vs = *(ckt->CKTrhsOld + here->B3SOIPDsNodePrime); + if (!here->B3SOIPDvbsusrGiven) + { + vbs = *(ckt->CKTstate1 + here->B3SOIPDvbs); + vb = *(ckt->CKTrhsOld + here->B3SOIPDbNode); + } + else + { + vbs = here->B3SOIPDvbsusr; + vb = here->B3SOIPDvbsusr + vs; + } + vgs = *(ckt->CKTstate1 + here->B3SOIPDvgs); + ves = *(ckt->CKTstate1 + here->B3SOIPDves); + vps = *(ckt->CKTstate1 + here->B3SOIPDvps); + vds = *(ckt->CKTstate1 + here->B3SOIPDvds); + delTemp = *(ckt->CKTstate1 + here->B3SOIPDdeltemp); + + vg = *(ckt->CKTrhsOld + here->B3SOIPDgNode); + vd = *(ckt->CKTrhsOld + here->B3SOIPDdNodePrime); + vp = *(ckt->CKTrhsOld + here->B3SOIPDpNode); + ve = *(ckt->CKTrhsOld + here->B3SOIPDeNode); + + } + else if ((ckt->CKTmode & MODEINITJCT) && !here->B3SOIPDoff) + { + vds = model->B3SOIPDtype * here->B3SOIPDicVDS; + vgs = model->B3SOIPDtype * here->B3SOIPDicVGS; + ves = model->B3SOIPDtype * here->B3SOIPDicVES; + vbs = model->B3SOIPDtype * here->B3SOIPDicVBS; + vps = model->B3SOIPDtype * here->B3SOIPDicVPS; + + vg = vd = vs = vp = ve = 0.0; + + + delTemp = 0.0; + here->B3SOIPDphi = pParam->B3SOIPDphi; + + + + if ((vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) && + ((ckt->CKTmode & (MODETRAN | MODEAC | MODEDCOP | + MODEDCTRANCURVE)) + || (!(ckt->CKTmode & MODEUIC)))) + { + vbs = 0.0; + vgs = model->B3SOIPDtype * 0.1 + pParam->B3SOIPDvth0; + vds = 0.0; + ves = 0.0; + vps = 0.0; + } + } + else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) && + (here->B3SOIPDoff)) + { + 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->B3SOIPDvbs) = + *(ckt->CKTstate1 + here->B3SOIPDvbs); + vbs = (1.0 + xfact) * (*(ckt->CKTstate1 + here->B3SOIPDvbs)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDvbs))); + *(ckt->CKTstate0 + here->B3SOIPDvgs) = + *(ckt->CKTstate1 + here->B3SOIPDvgs); + vgs = (1.0 + xfact) * (*(ckt->CKTstate1 + here->B3SOIPDvgs)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDvgs))); + *(ckt->CKTstate0 + here->B3SOIPDves) = + *(ckt->CKTstate1 + here->B3SOIPDves); + ves = (1.0 + xfact) * (*(ckt->CKTstate1 + here->B3SOIPDves)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDves))); + *(ckt->CKTstate0 + here->B3SOIPDvps) = + *(ckt->CKTstate1 + here->B3SOIPDvps); + vps = (1.0 + xfact) * (*(ckt->CKTstate1 + here->B3SOIPDvps)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDvps))); + *(ckt->CKTstate0 + here->B3SOIPDvds) = + *(ckt->CKTstate1 + here->B3SOIPDvds); + vds = (1.0 + xfact) * (*(ckt->CKTstate1 + here->B3SOIPDvds)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDvds))); + *(ckt->CKTstate0 + here->B3SOIPDvbd) = + *(ckt->CKTstate0 + here->B3SOIPDvbs) + - *(ckt->CKTstate0 + here->B3SOIPDvds); + + *(ckt->CKTstate0 + here->B3SOIPDvg) = + *(ckt->CKTstate1 + here->B3SOIPDvg); + *(ckt->CKTstate0 + here->B3SOIPDvd) = + *(ckt->CKTstate1 + here->B3SOIPDvd); + *(ckt->CKTstate0 + here->B3SOIPDvs) = + *(ckt->CKTstate1 + here->B3SOIPDvs); + *(ckt->CKTstate0 + here->B3SOIPDvp) = + *(ckt->CKTstate1 + here->B3SOIPDvp); + *(ckt->CKTstate0 + here->B3SOIPDve) = + *(ckt->CKTstate1 + here->B3SOIPDve); + + /* Only predict ve */ + ve = (1.0 + xfact) * (*(ckt->CKTstate1 + here->B3SOIPDve)) + - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDve))); + /* Then update vg, vs, vb, vd, vp base on ve */ + vs = ve - model->B3SOIPDtype * ves; + vg = model->B3SOIPDtype * vgs + vs; + vd = model->B3SOIPDtype * vds + vs; + vb = model->B3SOIPDtype * vbs + vs; + vp = model->B3SOIPDtype * vps + vs; + + delTemp = (1.0 + xfact) * (*(ckt->CKTstate1 + + here->B3SOIPDdeltemp)) - + (xfact * (*(ckt->CKTstate2 + here->B3SOIPDdeltemp))); + + if (selfheat) + { + here->B3SOIPDphi = 2.0 * here->B3SOIPDvtm + * log (pParam->B3SOIPDnpeak / here->B3SOIPDni); + } + + } + else + { +#endif /* PREDICTOR */ + + vg = B3SOIPDlimit (*(ckt->CKTrhsOld + here->B3SOIPDgNode), + *(ckt->CKTstate0 + here->B3SOIPDvg), 3.0, + &Check); + vd = + B3SOIPDlimit (*(ckt->CKTrhsOld + here->B3SOIPDdNodePrime), + *(ckt->CKTstate0 + here->B3SOIPDvd), 3.0, + &Check); + vs = + B3SOIPDlimit (*(ckt->CKTrhsOld + here->B3SOIPDsNodePrime), + *(ckt->CKTstate0 + here->B3SOIPDvs), 3.0, + &Check); + vp = + B3SOIPDlimit (*(ckt->CKTrhsOld + here->B3SOIPDpNode), + *(ckt->CKTstate0 + here->B3SOIPDvp), 3.0, + &Check); + ve = + B3SOIPDlimit (*(ckt->CKTrhsOld + here->B3SOIPDeNode), + *(ckt->CKTstate0 + here->B3SOIPDve), 3.0, + &Check); + delTemp = *(ckt->CKTrhsOld + here->B3SOIPDtempNode); + + vbs = + model->B3SOIPDtype * + (*(ckt->CKTrhsOld + here->B3SOIPDbNode) - + *(ckt->CKTrhsOld + here->B3SOIPDsNodePrime)); + + vps = model->B3SOIPDtype * (vp - vs); + vgs = model->B3SOIPDtype * (vg - vs); + ves = model->B3SOIPDtype * (ve - vs); + vds = model->B3SOIPDtype * (vd - vs); + + +#ifndef PREDICTOR + } +#endif /* PREDICTOR */ + + vbd = vbs - vds; + vgd = vgs - vds; + ved = ves - vds; + vgdo = *(ckt->CKTstate0 + here->B3SOIPDvgs) + - *(ckt->CKTstate0 + here->B3SOIPDvds); + vedo = *(ckt->CKTstate0 + here->B3SOIPDves) + - *(ckt->CKTstate0 + here->B3SOIPDvds); + delvbs = vbs - *(ckt->CKTstate0 + here->B3SOIPDvbs); + delvbd = vbd - *(ckt->CKTstate0 + here->B3SOIPDvbd); + delvgs = vgs - *(ckt->CKTstate0 + here->B3SOIPDvgs); + delves = ves - *(ckt->CKTstate0 + here->B3SOIPDves); + delvps = vps - *(ckt->CKTstate0 + here->B3SOIPDvps); + deldelTemp = delTemp - *(ckt->CKTstate0 + here->B3SOIPDdeltemp); + delvds = vds - *(ckt->CKTstate0 + here->B3SOIPDvds); + delvgd = vgd - vgdo; + delved = ved - vedo; + + if (here->B3SOIPDmode >= 0) + { + cdhat = + here->B3SOIPDcd + (here->B3SOIPDgm - + here->B3SOIPDgjdg) * delvgs + + (here->B3SOIPDgds - here->B3SOIPDgjdd) * delvds + + (here->B3SOIPDgmbs - here->B3SOIPDgjdb) * delvbs + + (here->B3SOIPDgmT - here->B3SOIPDgjdT) * deldelTemp; + } + else + { + cdhat = + here->B3SOIPDcd + (here->B3SOIPDgm - + here->B3SOIPDgjdg) * delvgd - + (here->B3SOIPDgds - here->B3SOIPDgjdd) * delvds + + (here->B3SOIPDgmbs - here->B3SOIPDgjdb) * delvbd + + (here->B3SOIPDgmT - here->B3SOIPDgjdT) * deldelTemp; + + } + cbhat = here->B3SOIPDcb + here->B3SOIPDgbgs * delvgs + + here->B3SOIPDgbbs * delvbs + + here->B3SOIPDgbds * delvds + + here->B3SOIPDgbps * delvps + here->B3SOIPDgbT * deldelTemp; + +#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->B3SOIPDvbs))) + + ckt->CKTvoltTol))) + if ( + (fabs (delvbd) < + (ckt->CKTreltol * + MAX (fabs (vbd), + fabs (*(ckt->CKTstate0 + here->B3SOIPDvbd))) + + ckt->CKTvoltTol))) + if ( + (fabs (delvgs) < + (ckt->CKTreltol * + MAX (fabs (vgs), + fabs (*(ckt->CKTstate0 + here->B3SOIPDvgs))) + + ckt->CKTvoltTol))) + if ( + (fabs (delves) < + (ckt->CKTreltol * + MAX (fabs (ves), + fabs (*(ckt->CKTstate0 + here->B3SOIPDves))) + + ckt->CKTvoltTol))) + if ((here->B3SOIPDbodyMod == 0) + || (here->B3SOIPDbodyMod == 2) + || (fabs (delvps) < + (ckt->CKTreltol * + MAX (fabs (vps), + fabs (* + (ckt->CKTstate0 + + here->B3SOIPDvps))) + + ckt->CKTvoltTol))) + if ((here->B3SOIPDtempNode == 0) + || (fabs (deldelTemp) < + (ckt->CKTreltol * + MAX (fabs (delTemp), + fabs (* + (ckt->CKTstate0 + + here->B3SOIPDdeltemp))) + + ckt->CKTvoltTol * 1e4))) + if ( + (fabs (delvds) < + (ckt->CKTreltol * + MAX (fabs (vds), + fabs (* + (ckt->CKTstate0 + + here->B3SOIPDvds))) + + ckt->CKTvoltTol))) + if ( + (fabs (cdhat - here->B3SOIPDcd) < + ckt->CKTreltol * MAX (fabs (cdhat), + fabs (here-> + B3SOIPDcd)) + + ckt->CKTabstol)) + if ( + (fabs (cbhat - here->B3SOIPDcb) < + ckt->CKTreltol * MAX (fabs (cbhat), + fabs (here-> + B3SOIPDcb)) + + ckt->CKTabstol)) + { /* bypass code */ + vbs = + *(ckt->CKTstate0 + here->B3SOIPDvbs); + vbd = + *(ckt->CKTstate0 + here->B3SOIPDvbd); + vgs = + *(ckt->CKTstate0 + here->B3SOIPDvgs); + ves = + *(ckt->CKTstate0 + here->B3SOIPDves); + vps = + *(ckt->CKTstate0 + here->B3SOIPDvps); + vds = + *(ckt->CKTstate0 + here->B3SOIPDvds); + delTemp = + *(ckt->CKTstate0 + + here->B3SOIPDdeltemp); + + /* calculate Vds for temperature conductance calculation + in bypass (used later when filling Temp node matrix) */ + Vds = here->B3SOIPDmode > 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->B3SOIPDvon; + + + if (*(ckt->CKTstate0 + here->B3SOIPDvds) >= 0.0) + T0 = *(ckt->CKTstate0 + here->B3SOIPDvbs); + else + T0 = *(ckt->CKTstate0 + here->B3SOIPDvbd); + + + if (vds >= 0.0) + { + vbs = B3SOIPDlimit (vbs, T0, 0.2, &Check); + vbd = vbs - vds; + vb = model->B3SOIPDtype * vbs + vs; + } + else + { + vbd = B3SOIPDlimit (vbd, T0, 0.2, &Check); + vbs = vbd + vds; + vb = model->B3SOIPDtype * vbs + vd; + } + + delTemp = + B3SOIPDlimit (delTemp, + *(ckt->CKTstate0 + here->B3SOIPDdeltemp), 5.0, + &Check); + + } + +/* Calculate temperature dependent values for self-heating effect */ + Temp = delTemp + ckt->CKTtemp; + dTempRatio_dT = 1 / model->B3SOIPDtnom; + 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->B3SOIPDnpeak / (ni * ni)); + vbi = Vtm * T0; + dvbi_dT = KboQ * T0 + Vtm * (-2.0 * dni_dT / ni); + + if (pParam->B3SOIPDnsub > 0) + { + T0 = log (pParam->B3SOIPDnpeak / pParam->B3SOIPDnsub); + vfbb = -model->B3SOIPDtype * Vtm * T0; + dvfbb_dT = -model->B3SOIPDtype * KboQ * T0; + } + else + { + T0 = + log (-pParam->B3SOIPDnpeak * pParam->B3SOIPDnsub / ni / + ni); + vfbb = -model->B3SOIPDtype * Vtm * T0; + dvfbb_dT = -model->B3SOIPDtype * + (KboQ * T0 - Vtm * 2.0 * dni_dT / ni); + } + +/* phi = 2.0 * Vtm * log(pParam->B3SOIPDnpeak / ni); */ + phi = here->B3SOIPDphi; + sqrtPhi = sqrt (phi); + Xdep0 = sqrt (2.0 * EPSSI / (Charge_q + * pParam->B3SOIPDnpeak * 1.0e6)) + * sqrtPhi; + /* Save the values below for phi calculation in B3SOIPDaccept() */ + here->B3SOIPDvtm = Vtm; + here->B3SOIPDni = ni; + + T3 = TempRatio - 1.0; + T8 = 1 / model->B3SOIPDtnom; + T4 = Eg300 / Vtm * T3; + dT4_dT = Eg300 / Vtm / Vtm * (Vtm * T8 - T3 * KboQ); + + T7 = model->B3SOIPDxbjt * T4 / pParam->B3SOIPDndiode; + dT7_dT = model->B3SOIPDxbjt * dT4_dT / pParam->B3SOIPDndiode; + DEXP (T7, T0, dT0_dT7); + dT0_dT = dT0_dT7 * dT7_dT; + + if (model->B3SOIPDxbjt == model->B3SOIPDxdif) + { + T1 = T0; + dT1_dT = dT0_dT; + } + else + { + T7 = model->B3SOIPDxdif * T4 / pParam->B3SOIPDndiode; + dT7_dT = + model->B3SOIPDxdif * dT4_dT / pParam->B3SOIPDndiode; + DEXP (T7, T1, dT1_dT7); + dT1_dT = dT1_dT7 * dT7_dT; + } + + T7 = model->B3SOIPDxrec * T4 / pParam->B3SOIPDnrecf0; + dT7_dT = model->B3SOIPDxrec * dT4_dT / pParam->B3SOIPDnrecf0; + DEXP (T7, T2, dT2_dT7); + dT2_dT = dT2_dT7 * dT7_dT; + + /* high level injection */ + Ahli = pParam->B3SOIPDahli * T0; + dAhli_dT = pParam->B3SOIPDahli * dT0_dT; + + jbjt = pParam->B3SOIPDisbjt * T0; + jdif = pParam->B3SOIPDisdif * T1; + jrec = pParam->B3SOIPDisrec * T2; + djbjt_dT = pParam->B3SOIPDisbjt * dT0_dT; + djdif_dT = pParam->B3SOIPDisdif * dT1_dT; + djrec_dT = pParam->B3SOIPDisrec * dT2_dT; + + T7 = model->B3SOIPDxtun * T3; + dT7_dT = model->B3SOIPDxtun * T8; + DEXP (T7, T0, dT0_dT7); + dT0_dT = dT0_dT7 * dT7_dT; + jtun = pParam->B3SOIPDistun * T0; + djtun_dT = pParam->B3SOIPDistun * dT0_dT; + + u0temp = + pParam->B3SOIPDu0 * pow (TempRatio, pParam->B3SOIPDute); + du0temp_dT = + pParam->B3SOIPDu0 * pParam->B3SOIPDute * pow (TempRatio, + pParam-> + B3SOIPDute - + 1.0) * T8; + + vsattemp = pParam->B3SOIPDvsat - pParam->B3SOIPDat * T3; + dvsattemp_dT = -pParam->B3SOIPDat * T8; + + rds0 = (pParam->B3SOIPDrdsw + pParam->B3SOIPDprt + * T3) / pParam->B3SOIPDrds0denom; + drds0_dT = pParam->B3SOIPDprt / pParam->B3SOIPDrds0denom * T8; + + ua = pParam->B3SOIPDuatemp + pParam->B3SOIPDua1 * T3; + ub = pParam->B3SOIPDubtemp + pParam->B3SOIPDub1 * T3; + uc = pParam->B3SOIPDuctemp + pParam->B3SOIPDuc1 * T3; + dua_dT = pParam->B3SOIPDua1 * T8; + dub_dT = pParam->B3SOIPDub1 * T8; + duc_dT = pParam->B3SOIPDuc1 * T8; + } + else + { + vbi = pParam->B3SOIPDvbi; + vfbb = pParam->B3SOIPDvfbb; + phi = pParam->B3SOIPDphi; + sqrtPhi = pParam->B3SOIPDsqrtPhi; + Xdep0 = pParam->B3SOIPDXdep0; + jbjt = pParam->B3SOIPDjbjt; + jdif = pParam->B3SOIPDjdif; + jrec = pParam->B3SOIPDjrec; + jtun = pParam->B3SOIPDjtun; + Ahli = pParam->B3SOIPDahli; + u0temp = pParam->B3SOIPDu0temp; + vsattemp = pParam->B3SOIPDvsattemp; + rds0 = pParam->B3SOIPDrds0; + ua = pParam->B3SOIPDua; + ub = pParam->B3SOIPDub; + uc = pParam->B3SOIPDuc; + 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->B3SOIPDtnom - 1.0; + } + else + { + TempRatioMinus1 = ckt->CKTtemp / model->B3SOIPDtnom - 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->B3SOIPDmode = 1; + Vds = vds; + Vgs = vgs; + Vbs = vbs; + Vbd = vbd; + Ves = ves; + Vps = vps; + + wdios = pParam->B3SOIPDwdios; + wdiod = pParam->B3SOIPDwdiod; + wdiosCV = pParam->B3SOIPDwdiosCV; + wdiodCV = pParam->B3SOIPDwdiodCV; + + } + else + { /* inverse mode */ + here->B3SOIPDmode = -1; + Vds = -vds; + Vgs = vgd; + Vbs = vbd; + Vbd = vbs; + Ves = ved; + Vps = vpd; + + wdios = pParam->B3SOIPDwdiod; + wdiod = pParam->B3SOIPDwdios; + wdiosCV = pParam->B3SOIPDwdiodCV; + wdiodCV = pParam->B3SOIPDwdiosCV; + + } + + Vesfb = Ves - vfbb; + Cbox = model->B3SOIPDcbox; + K1 = pParam->B3SOIPDk1eff; + + ChargeComputationNeeded = + ((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) || + ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC))) + ? 1 : 0; + + if (here->B3SOIPDdebugMod < 0) + ChargeComputationNeeded = 1; + + + + +/* Poly Gate Si Depletion Effect */ + T0 = pParam->B3SOIPDvfb + phi; + if ((pParam->B3SOIPDngate > 1.e18) && (pParam->B3SOIPDngate < 1.e25) + && (Vgs > T0)) + /* added to avoid the problem caused by ngate */ + { + T1 = 1.0e6 * Charge_q * EPSSI * pParam->B3SOIPDngate + / (model->B3SOIPDcox * model->B3SOIPDcox); + 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->B3SOIPDleff; + + if (selfheat) + { + Vtm = KboQ * Temp; + dVtm_dT = KboQ; + } + else + { + Vtm = model->B3SOIPDvtm; + dVtm_dT = 0.0; + } + + V0 = vbi - phi; + + Vbp = Vbs - Vps; + dVbp_dVb = 1; + + + /* T2 is Vbs limited above Vbsc=-5 */ + T0 = Vbs + 5 - 0.001; + T1 = sqrt (T0 * T0 - 0.004 * (-5)); + T2 = (-5) + 0.5 * (T0 + T1); + dT2_dVb = 0.5 * (1.0 + T0 / T1); + + /* 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; + + /* 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; + here->B3SOIPDvbseff = Vbs; + + /* 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->B3SOIPDdvt2 * Vbseff; + if (T0 >= -0.5) + { + T1 = 1.0 + T0; + T2 = pParam->B3SOIPDdvt2; + } + 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->B3SOIPDdvt2 * T4 * T4; + } + lt1 = model->B3SOIPDfactor1 * T3 * T1; + dlt1_dVb = + model->B3SOIPDfactor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + + T0 = pParam->B3SOIPDdvt2w * Vbseff; + if (T0 >= -0.5) + { + T1 = 1.0 + T0; + T2 = pParam->B3SOIPDdvt2w; + } + 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->B3SOIPDdvt2w * T4 * T4; + } + ltw = model->B3SOIPDfactor1 * T3 * T1; + dltw_dVb = + model->B3SOIPDfactor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2); + + T0 = -0.5 * pParam->B3SOIPDdvt1 * 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->B3SOIPDthetavth = pParam->B3SOIPDdvt0 * Theta0; + Delt_vth = here->B3SOIPDthetavth * V0; + dDelt_vth_dVb = pParam->B3SOIPDdvt0 * dTheta0_dVb * V0; + if (selfheat) + dDelt_vth_dT = here->B3SOIPDthetavth * dvbi_dT; + else + dDelt_vth_dT = 0.0; + + T0 = -0.5 * pParam->B3SOIPDdvt1w * pParam->B3SOIPDweff * 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->B3SOIPDdvt0w * T2; + DeltVthw = T0 * V0; + dDeltVthw_dVb = pParam->B3SOIPDdvt0w * dT2_dVb * V0; + if (selfheat) + dDeltVthw_dT = T0 * dvbi_dT; + else + dDeltVthw_dT = 0.0; + + T0 = sqrt (1.0 + pParam->B3SOIPDnlx / Leff); + T1 = (pParam->B3SOIPDkt1 + pParam->B3SOIPDkt1l / Leff + + pParam->B3SOIPDkt2 * Vbseff); + DeltVthtemp = + pParam->B3SOIPDk1eff * (T0 - 1.0) * sqrtPhi + + T1 * TempRatioMinus1; + if (selfheat) + dDeltVthtemp_dT = T1 / model->B3SOIPDtnom; + else + dDeltVthtemp_dT = 0.0; + + tmp2 = model->B3SOIPDtox * phi + / (pParam->B3SOIPDweff + pParam->B3SOIPDw0); + + T3 = pParam->B3SOIPDeta0 + pParam->B3SOIPDetab * 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->B3SOIPDetab; + dT3_dVb = T4; + } + else + { + dT3_dVb = pParam->B3SOIPDetab; + } + DIBL_Sft = T3 * pParam->B3SOIPDtheta0vb0 * Vds; + dDIBL_Sft_dVd = pParam->B3SOIPDtheta0vb0 * T3; + dDIBL_Sft_dVb = pParam->B3SOIPDtheta0vb0 * Vds * dT3_dVb; + + T9 = 2.2361 / sqrtPhi; + sqrtPhisExt = sqrtPhis - T9 * (Vbsh - Vbseff); + dsqrtPhisExt_dVb = dsqrtPhis_dVb - T9 * (dVbsh_dVb - 1); + + Vth = + model->B3SOIPDtype * pParam->B3SOIPDvth0 + + pParam->B3SOIPDk1eff * (sqrtPhisExt - sqrtPhi) - + pParam->B3SOIPDk2 * Vbseff - Delt_vth - DeltVthw + + (pParam->B3SOIPDk3 + pParam->B3SOIPDk3b * Vbseff) * tmp2 + + DeltVthtemp - DIBL_Sft; + here->B3SOIPDvon = Vth; + + T6 = pParam->B3SOIPDk3b * tmp2 - pParam->B3SOIPDk2 + + pParam->B3SOIPDkt2 * TempRatioMinus1; + dVth_dVb = pParam->B3SOIPDk1eff * 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->B3SOIPDcapMod == 3) && (selfheat == 1)) + { + T3zb = sqrt (Xdep0); + ltwzb = lt1zb = model->B3SOIPDfactor1 * T3zb; + + T0 = -0.5 * pParam->B3SOIPDdvt1 * 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->B3SOIPDdvt0 * Theta0zb * V0; + dDelt_vthzb_dT = pParam->B3SOIPDdvt0 * Theta0zb * dvbi_dT; + + T0 = + -0.5 * pParam->B3SOIPDdvt1w * pParam->B3SOIPDweff * 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->B3SOIPDdvt0w * T2; + DeltVthwzb = T0 * V0; + dDeltVthwzb_dT = T0 * dvbi_dT; + + T0 = sqrt (1.0 + pParam->B3SOIPDnlx / Leff); + T1 = (pParam->B3SOIPDkt1 + pParam->B3SOIPDkt1l / Leff); + DeltVthtempzb = pParam->B3SOIPDk1eff * (T0 - 1.0) * sqrtPhi + + T1 * TempRatioMinus1; + dDeltVthtempzb_dT = T1 / model->B3SOIPDtnom; + + Vthzb = model->B3SOIPDtype * pParam->B3SOIPDvth0 + - Delt_vthzb - DeltVthwzb + pParam->B3SOIPDk3 * tmp2 + + DeltVthtempzb; + dVthzb_dT = dDeltVthtempzb_dT - dDelt_vthzb_dT - dDeltVthwzb_dT; + } + +/* Calculate n */ + T2 = pParam->B3SOIPDnfactor * EPSSI / Xdep; + dT2_dVb = -T2 / Xdep * dXdep_dVb; + + T3 = pParam->B3SOIPDcdsc + pParam->B3SOIPDcdscb * Vbseff + + pParam->B3SOIPDcdscd * Vds; + dT3_dVb = pParam->B3SOIPDcdscb; + dT3_dVd = pParam->B3SOIPDcdscd; + + T4 = (T2 + T3 * Theta0 + pParam->B3SOIPDcit) / model->B3SOIPDcox; + dT4_dVb = (dT2_dVb + Theta0 * dT3_dVb + dTheta0_dVb * T3) + / model->B3SOIPDcox; + dT4_dVd = Theta0 * dT3_dVd / model->B3SOIPDcox; + + 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->B3SOIPDvoff - Vgst) / T10; + + /* MCJ: Very small Vgst */ + if (VgstNVt > EXPL_THRESHOLD) + { + Vgsteff = Vgst; + /* T0 is dVgsteff_dVbseff */ + T0 = -dVth_dVb; + dVgsteff_dVg = dVgs_eff_dVg; + dVgsteff_dVd = -dVth_dVd; + dVgsteff_dVb = T0 * dVbseff_dVb; + if (selfheat) + dVgsteff_dT = -dVth_dT; + else + dVgsteff_dT = 0.0; + } + else if (ExpArg > EXPL_THRESHOLD) + { + T0 = (Vgst - pParam->B3SOIPDvoff) / (n * Vtm); + ExpVgst = exp (T0); + Vgsteff = + Vtm * pParam->B3SOIPDcdep0 / model->B3SOIPDcox * ExpVgst; + T3 = Vgsteff / (n * Vtm); + /* T1 is dVgsteff_dVbseff */ + T1 = -T3 * (dVth_dVb + T0 * Vtm * dn_dVb); + dVgsteff_dVg = T3 * dVgs_eff_dVg; + dVgsteff_dVd = -T3 * (dVth_dVd + T0 * Vtm * dn_dVd); + dVgsteff_dVb = T1 * dVbseff_dVb; + if (selfheat) + dVgsteff_dT = -T3 * (dVth_dT + T0 * dVtm_dT * n) + + Vgsteff / Temp; + 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->B3SOIPDcox / (Vtm * pParam->B3SOIPDcdep0) + * 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_dVg = + (T2 * dT1_dVg - T1 * dT2_dVg) / T3 * dVgs_eff_dVg; + dVgsteff_dVd = (T2 * dT1_dVd - T1 * dT2_dVd) / T3; + if (selfheat) + dVgsteff_dT = (T2 * dT1_dT - T1 * dT2_dT) / T3; + else + dVgsteff_dT = 0.0; + } + Vgst2Vtm = Vgsteff + 2.0 * Vtm; + if (selfheat) + dVgst2Vtm_dT = 2.0 * dVtm_dT; + else + dVgst2Vtm_dT = 0.0; + +/* Calculate Effective Channel Geometry */ + T9 = sqrtPhis - sqrtPhi; + Weff = + pParam->B3SOIPDweff - (2.0 - + here->B3SOIPDnbc) * (pParam->B3SOIPDdwg * + Vgsteff + + pParam->B3SOIPDdwb * + T9); + dWeff_dVg = -(2.0 - here->B3SOIPDnbc) * pParam->B3SOIPDdwg; + dWeff_dVb = + -(2.0 - here->B3SOIPDnbc) * pParam->B3SOIPDdwb * 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->B3SOIPDprwg * Vgsteff + pParam->B3SOIPDprwb * T9; + if (T0 >= -0.9) + { + Rds = rds0 * (1.0 + T0); + dRds_dVg = rds0 * pParam->B3SOIPDprwg; + dRds_dVb = rds0 * pParam->B3SOIPDprwb * 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->B3SOIPDprwg * T1; + dRds_dVb = rds0 * pParam->B3SOIPDprwb * dsqrtPhis_dVb * T1; + + if (selfheat && (Rds != 0.0)) + dRds_dT = (0.8 + T0) * T1 * drds0_dT; + else + dRds_dT = 0.0; + + } + +/* Calculate Abulk */ + if (pParam->B3SOIPDa0 == 0.0) + { + + Abulk0 = Abulk = 1.0; + + dAbulk0_dVb = dAbulk_dVg = dAbulk_dVb = 0.0; + } + else + { + T10 = pParam->B3SOIPDketa * Vbsh; + if (T10 >= -0.9) + { + T11 = 1.0 / (1.0 + T10); + dT11_dVb = -pParam->B3SOIPDketa * 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->B3SOIPDketa * T12 * T12 * dVbsh_dVb; + } + + T10 = pParam->B3SOIPDphi + pParam->B3SOIPDketas; + 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; + } + + T10 = 0.5 * pParam->B3SOIPDk1eff + / sqrt (pParam->B3SOIPDphi + pParam->B3SOIPDketas); + T1 = T10 * T14; + dT1_dVb = T10 * dT14_dVb; + + T9 = sqrt (model->B3SOIPDxj * Xdep); + tmp1 = Leff + 2.0 * T9; + T5 = Leff / tmp1; + tmp2 = pParam->B3SOIPDa0 * T5; + tmp3 = pParam->B3SOIPDweff + pParam->B3SOIPDb1; + tmp4 = pParam->B3SOIPDb0 / 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->B3SOIPDags * pParam->B3SOIPDa0 * 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->B3SOIPDmobMod == 1) + { + T0 = Vgsteff + Vth + Vth; + T2 = ua + uc * Vbseff; + T3 = T0 / model->B3SOIPDtox; + T5 = T3 * (T2 + ub * T3); + dDenomi_dVg = (T2 + 2.0 * ub * T3) / model->B3SOIPDtox; + 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->B3SOIPDmobMod == 2) + { + T5 = Vgsteff / model->B3SOIPDtox * (ua + + uc * Vbseff + ub * Vgsteff + / model->B3SOIPDtox); + dDenomi_dVg = (ua + uc * Vbseff + + 2.0 * ub * Vgsteff / model->B3SOIPDtox) + / model->B3SOIPDtox; + dDenomi_dVd = 0.0; + dDenomi_dVb = Vgsteff * uc / model->B3SOIPDtox; + if (selfheat) + dDenomi_dT = Vgsteff / model->B3SOIPDtox + * (dua_dT + Vbseff * duc_dT + dub_dT + * Vgsteff / model->B3SOIPDtox); + else + dDenomi_dT = 0.0; + } + else /* mobMod == 3 */ + { + T0 = Vgsteff + Vth + Vth; + T2 = 1.0 + uc * Vbseff; + T3 = T0 / model->B3SOIPDtox; + T4 = T3 * (ua + ub * T3); + T5 = T4 * T2; + dDenomi_dVg = (ua + 2.0 * ub * T3) * T2 / model->B3SOIPDtox; + 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->B3SOIPDueff = 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->B3SOIPDcox; + WVCoxRds = WVCox * Rds; + +/* dWVCoxRds_dT = WVCox * dRds_dT + + Weff * model->B3SOIPDcox * 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->B3SOIPDa1; + if (a1 == 0.0) + { + Lambda = pParam->B3SOIPDa2; + 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->B3SOIPDa2; + T1 = T0 - pParam->B3SOIPDa1 * Vgsteff - 0.0001; + T2 = sqrt (T1 * T1 + 0.0004 * T0); + Lambda = pParam->B3SOIPDa2 + T0 - 0.5 * (T1 + T2); + dLambda_dVg = 0.5 * pParam->B3SOIPDa1 * (1.0 + T1 / T2); + } + else + { + T1 = pParam->B3SOIPDa2 + pParam->B3SOIPDa1 * Vgsteff - 0.0001; + T2 = sqrt (T1 * T1 + 0.0004 * pParam->B3SOIPDa2); + Lambda = 0.5 * (T1 + T2); + dLambda_dVg = 0.5 * pParam->B3SOIPDa1 * (1.0 + T1 / T2); + } + + 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->B3SOIPDvdsat = Vdsat; + + +/* Effective Vds (Vdseff) Calculation */ + T1 = Vdsat - Vds - pParam->B3SOIPDdelta; + 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->B3SOIPDdelta * Vdsat); + T0 = T1 / T2; + T3 = 2.0 * pParam->B3SOIPDdelta / 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; + + +/* 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->B3SOIPDpclm > 0.0) && (diffVds > 1.0e-10)) + { + T0 = 1.0 / (pParam->B3SOIPDpclm * Abulk * pParam->B3SOIPDlitl); + 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->B3SOIPDthetaRout > 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->B3SOIPDthetaRout; + 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->B3SOIPDpdiblb * Vbseff; + if (T7 >= -0.9) + { + T3 = 1.0 / (1.0 + T7); + VADIBL *= T3; + dVADIBL_dVg *= T3; + dVADIBL_dVb = (dVADIBL_dVb - VADIBL * pParam->B3SOIPDpdiblb) + * 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->B3SOIPDpdiblb * 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->B3SOIPDpvag / 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->B3SOIPDcox * 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->B3SOIPDids = Ids = Idl * T0 / here->B3SOIPDnseg; + + 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 / here->B3SOIPDnseg; + Gmb = (Gm0 * dVgsteff_dVb + Gmb0 * dVbseff_dVb) / here->B3SOIPDnseg; + Gds = (Gm0 * dVgsteff_dVd + Gds0) / here->B3SOIPDnseg; + if (selfheat) + GmT = (Gm0 * dVgsteff_dT + GmT0) / here->B3SOIPDnseg; + else + GmT = 0.0; + +/* calculate GIDL current */ + T0 = 3 * model->B3SOIPDtox; + /* For drain side */ + T1 = (Vds - Vgs_eff - pParam->B3SOIPDngidl) / T0; + if ((pParam->B3SOIPDagidl <= 0.0) || (pParam->B3SOIPDbgidl <= 0.0) + || (T1 <= 0.0)) + { + Idgidl = Gdgidld = Gdgidlg = 0.0; + } + else + { + dT1_dVd = 1 / T0; + dT1_dVg = -dT1_dVd * dVgs_eff_dVg; + T2 = pParam->B3SOIPDbgidl / T1; + if (T2 < EXPL_THRESHOLD) + { + Idgidl = wdiod * pParam->B3SOIPDagidl * T1 * exp (-T2); + T3 = Idgidl / T1 * (T2 + 1); + Gdgidld = T3 * dT1_dVd; + Gdgidlg = T3 * dT1_dVg; + } + else + { + T3 = wdiod * pParam->B3SOIPDagidl * MIN_EXPL; + Idgidl = T3 * T1; + Gdgidld = T3 * dT1_dVd; + Gdgidlg = T3 * dT1_dVg; + } + } + here->B3SOIPDigidl = Idgidl; + + /* For source side */ + T1 = (-Vgs_eff - pParam->B3SOIPDngidl) / T0; + if ((pParam->B3SOIPDagidl <= 0.0) || (pParam->B3SOIPDbgidl <= 0.0) + || (T1 <= 0.0)) + { + Isgidl = Gsgidlg = 0; + } + else + { + dT1_dVg = -dVgs_eff_dVg / T0; + T2 = pParam->B3SOIPDbgidl / T1; + if (T2 < EXPL_THRESHOLD) + { + Isgidl = wdios * pParam->B3SOIPDagidl * T1 * exp (-T2); + T3 = Isgidl / T1 * (T2 + 1); + Gsgidlg = T3 * dT1_dVg; + } + else + { + T3 = wdios * pParam->B3SOIPDagidl * MIN_EXPL; + Isgidl = T3 * T1; + Gsgidlg = T3 * dT1_dVg; + } + } + +/* calculate diode and BJT current */ + WsTsi = wdios * model->B3SOIPDtsi; + WdTsi = wdiod * model->B3SOIPDtsi; + + NVtm1 = Vtm * pParam->B3SOIPDndiode; + if (selfheat) + dNVtm1_dT = pParam->B3SOIPDndiode * 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->B3SOIPDnrecf0 + * (1 + model->B3SOIPDntrecf * (TempRatio - 1)); + NVtmr = 0.026 * model->B3SOIPDnrecr0 + * (1 + model->B3SOIPDntrecr * (TempRatio - 1)); + if (selfheat) + { + dNVtmf_dT = pParam->B3SOIPDnrecf0 * 0.026 + * model->B3SOIPDntrecf * dTempRatio_dT; + dNVtmr_dT = model->B3SOIPDnrecr0 * 0.026 + * model->B3SOIPDntrecr * 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->B3SOIPDvrec0 - Vbs) < 1e-3) + { + T11 = -1.0; + dT11_dVb = dT11_dT = 0; + } + else + { + T1 = 1 / (pParam->B3SOIPDvrec0 - Vbs); + T0 = -Vbs / NVtmr * pParam->B3SOIPDvrec0 * T1; + dT0_dVb = + -pParam->B3SOIPDvrec0 / 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->B3SOIPDvrec0 - Vbd) < 1e-3) + { + T11 = -1.0; + dT11_dVb = dT11_dT = 0; + } + else + { + T1 = 1 / (pParam->B3SOIPDvrec0 - Vbd); + T0 = -Vbd / NVtmr * pParam->B3SOIPDvrec0 * T1; + dT0_dVb = + -pParam->B3SOIPDvrec0 / 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->B3SOIPDweff / here->B3SOIPDnseg * model->B3SOIPDtsi; + 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->B3SOIPDic = Ic = Gcd = Gcb = GcT = 0.0; + } + else + { + Ien = WTsi * jbjt * pParam->B3SOIPDlratio; + if (selfheat) + dIen_dT = WTsi * djbjt_dT * pParam->B3SOIPDlratio; + 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->B3SOIPDarfabjt)) < 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->B3SOIPDlratiodif; + if (selfheat) + dIendif_dT = WTsi * djbjt_dT * pParam->B3SOIPDlratiodif; + 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->B3SOIPDbjtoff == 1) || (Vds == 0.0)) + { + here->B3SOIPDic = Ic = Gcd = Gcb = GcT = 0.0; + } + else + { + /* second order effects */ + T0 = 1 + (Vbs + Vbd) / pParam->B3SOIPDvearly; + dT0_dVb = 2.0 / pParam->B3SOIPDvearly; + dT0_dVd = -1.0 / pParam->B3SOIPDvearly; + + 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->B3SOIPDarfabjt * Ien; + if (selfheat) + dT0_dT = pParam->B3SOIPDarfabjt * dIen_dT; + else + dT0_dT = 0; + here->B3SOIPDic = 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->B3SOIPDntun; + if (jtun == 0) + { + Ibs4 = Ibd4 = dIbs4_dVb = dIbs4_dT = dIbd4_dVb = dIbd4_dVd = + dIbd4_dT = 0; + } + else + { + if ((pParam->B3SOIPDvtun0 - Vbs) < 1e-3) + Ibs4 = dIbs4_dVb = dIbs4_dT = 0; + else + { + T1 = 1 / (pParam->B3SOIPDvtun0 - Vbs); + T0 = -Vbs / NVtm2 * pParam->B3SOIPDvtun0 * T1; + dT0_dVb = + -pParam->B3SOIPDvtun0 / 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->B3SOIPDvtun0 - Vbd) < 1e-3) + { + Ibd4 = dIbd4_dVb = dIbd4_dT = 0; + + dIbd4_dVd = 0; + + } + else + { + T1 = 1 / (pParam->B3SOIPDvtun0 - Vbd); + T0 = -Vbd / NVtm2 * pParam->B3SOIPDvtun0 * T1; + dT0_dVb = + -pParam->B3SOIPDvtun0 / 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->B3SOIPDitun = -Ibd3 - Ibd4; + here->B3SOIPDibs = Ibs = Ibs1 + Ibs2 + Ibs3 + Ibs4; + here->B3SOIPDibd = 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; + + +/* v2.2: calculate gate-tunneling-to-body current */ + + if (model->B3SOIPDigMod >= 1) + { + Vgb = Vgs_eff - Vbs; + dVgb_dVg = dVgs_eff_dVg; + dVgb_dVb = -1; + + /* Calculate Vox first */ + Vfb = + model->B3SOIPDtype * pParam->B3SOIPDvth0 - phi - + pParam->B3SOIPDk1eff * 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; + dT0_dVd = -dVgsteff_dVd; + dT0_dVb = -dVgsteff_dVb - dVfbeff_dVb - dVbseff_dVb; + if (selfheat) + dT0_dT = -dVgsteff_dT; + + if (pParam->B3SOIPDk1eff == 0.0) + { + Voxdepinv = dVoxdepinv_dVg = dVoxdepinv_dVd = dVoxdepinv_dVb + = dVoxdepinv_dT = 0.0; + } + else + { + if (T0 < 0.0) + { + T1 = T0 / pParam->B3SOIPDk1eff; + dT1_dVg = dT0_dVg / pParam->B3SOIPDk1eff; + dT1_dVd = dT0_dVd / pParam->B3SOIPDk1eff; + dT1_dVb = dT0_dVb / pParam->B3SOIPDk1eff; + if (selfheat) + dT1_dT = dT0_dT / pParam->B3SOIPDk1eff; + } + else + { + T1 = pParam->B3SOIPDk1eff / 2 * (-1 + sqrt (1 + + 4 * T0 / + pParam-> + B3SOIPDk1eff + / + pParam-> + B3SOIPDk1eff)); + T2 = + pParam->B3SOIPDk1eff / 2 * 0.5 / sqrt (1 + + 4 * T0 / + pParam-> + B3SOIPDk1eff / + pParam-> + B3SOIPDk1eff) * + 4 / pParam->B3SOIPDk1eff / pParam->B3SOIPDk1eff; + dT1_dVg = T2 * dT0_dVg; + dT1_dVd = T2 * dT0_dVd; + dT1_dVb = T2 * dT0_dVb; + 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); + if (selfheat) + dVoxdepinv_dT = -(2.0 * T1 * dT1_dT); + } + + + OxideRatio = pParam->B3SOIPDoxideRatio; + + Vox = Voxdepinv; + /* Voxeff is Vox limited below Voxh */ + T0 = model->B3SOIPDvoxh; + T1 = T0 - Vox - model->B3SOIPDdeltavox; + T3 = sqrt (T1 * T1 + 4 * model->B3SOIPDdeltavox * 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_dT = dVoxdepinv_dT * dVoxeff_dVox; + + + T0 = (Vox - model->B3SOIPDebg) / model->B3SOIPDnevb / Vtm; + if (selfheat) + dT0_dT = + (dVox_dT / Vtm - + (Vox - + model->B3SOIPDebg) / Vtm / Vtm * dVtm_dT) / + model->B3SOIPDnevb; + + DEXP (T0, T1, T2); /* T1=exp(T0), T2=dT1_dT0 */ + if (selfheat) + dT1_dT = T2 * dT0_dT; + + Vaux = model->B3SOIPDnevb * Vtm * log (1 + T1); + dVaux_dVg = T2 / (1 + T1) * dVox_dVg; + dVaux_dVd = T2 / (1 + T1) * dVox_dVd; + dVaux_dVb = T2 / (1 + T1) * dVox_dVb; + if (selfheat) + dVaux_dT = model->B3SOIPDnevb * (dVtm_dT * log (1 + T1) + + Vtm * dT1_dT / (1 + T1)); + + if (model->B3SOIPDvgb1 != 0) + { + T0 = 1 - Vox / model->B3SOIPDvgb1; + dT0_dVox = -1.0 / model->B3SOIPDvgb1; + if (selfheat) + dT0_dT = -dVox_dT / model->B3SOIPDvgb1; + } + else + { + T0 = 1; + dT0_dVox = dT0_dT = 0.0; + } + + if (T0 < 0.01) + { + T0 = 0.01; + dT0_dVox = dT0_dT = 0.0; + } + + T1 = Leff * Weff * 3.7622e-7 * OxideRatio; + T2 = -3.1051e10 * model->B3SOIPDtoxqm; + T3 = model->B3SOIPDalphaGB1; + T4 = model->B3SOIPDbetaGB1; + + 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; + + 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); + 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->B3SOIPDvoxh; + T1 = T0 - Vox - model->B3SOIPDdeltavox; + T3 = sqrt (T1 * T1 + 4 * model->B3SOIPDdeltavox * 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->B3SOIPDnecb / Vtm; + if (selfheat) + dT0_dT = -T0 / Vtm * dVtm_dT; + + DEXP (T0, T1, T2); /* T1=exp(T0), T2=dT1_dT0 */ + if (selfheat) + dT1_dT = T2 * dT0_dT; + + Vaux = model->B3SOIPDnecb * Vtm * log (1 + T1); + dVaux_dVg = -T2 / (1 + T1); + dVaux_dVd = 0; + dVaux_dVb = -dVaux_dVg; + if (selfheat) + dVaux_dT = model->B3SOIPDnecb * (dVtm_dT * log (1 + T1) + + Vtm * dT1_dT / (1 + T1)); + + if (model->B3SOIPDvgb2 != 0) + { + T0 = 1 - Vox / model->B3SOIPDvgb2; + dT0_dVox = -1.0 / model->B3SOIPDvgb2; + if (selfheat) + dT0_dT = -dVox_dT / model->B3SOIPDvgb2; + } + else + { + T0 = 1; + dT0_dVox = dT0_dT = 0.0; + } + + if (T0 < 0.01) + { + T0 = 0.01; + dT0_dVox = dT0_dT = 0.0; + } + + T1 = Leff * Weff * 4.9758e-7 * OxideRatio; + T2 = -2.357e10 * model->B3SOIPDtoxqm; + T3 = model->B3SOIPDalphaGB2; + T4 = model->B3SOIPDbetaGB2; + + 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; + + + Igb = Igb1 + Igb2; + /* Igb1 dominates in inversion region, while Igb2 doninates in accumulation */ + dIgb_dVg = dIgb1_dVg + dIgb2_dVg; + dIgb_dVd = dIgb1_dVd + dIgb2_dVd; + dIgb_dVb = dIgb1_dVb + dIgb2_dVb; + dIgb_dT = dIgb1_dT + dIgb2_dT; + + } + else + { + Igb = 0.0; + dIgb_dVg = 0.0; + dIgb_dVd = 0.0; + dIgb_dVb = 0.0; + dIgb_dT = 0.0; + } + + here->B3SOIPDig = Igb; + here->B3SOIPDgigg = dIgb_dVg; + here->B3SOIPDgigd = dIgb_dVd; + here->B3SOIPDgigb = dIgb_dVb; + here->B3SOIPDgigs = -(dIgb_dVg + dIgb_dVd + dIgb_dVb); + here->B3SOIPDgigT = dIgb_dT; +/* end of v2.2 gate current */ + + + +/* calculate substrate current Iii */ + + if (pParam->B3SOIPDalpha0 <= 0.0) + { + Giig = Giib = Giid = GiiT = 0.0; + here->B3SOIPDiii = Iii = 0.0; + } + else + { + Vdsatii0 = + pParam->B3SOIPDvdsatii0 * (1 + + model->B3SOIPDtii * (TempRatio - + 1.0)) - + pParam->B3SOIPDlii / Leff; + if (selfheat) + dVdsatii0_dT = + pParam->B3SOIPDvdsatii0 * model->B3SOIPDtii * dTempRatio_dT; + else + dVdsatii0_dT = 0; + + /* Calculate VgsStep */ + T0 = pParam->B3SOIPDesatii * Leff; + T1 = pParam->B3SOIPDsii0 * T0 / (1.0 + T0); + + T0 = 1 / (1 + pParam->B3SOIPDsii1 * Vgsteff); + if (selfheat) + dT0_dT = -pParam->B3SOIPDsii1 * T0 * T0 * dVgsteff_dT; + else + dT0_dT = 0; + T3 = T0 + pParam->B3SOIPDsii2; + T4 = Vgst * pParam->B3SOIPDsii1 * T0 * T0; + T2 = Vgst * T3; + dT2_dVg = T3 * dVgst_dVg - T4 * dVgsteff_dVg; + dT2_dVb = T3 * dVgst_dVb * dVbseff_dVb - T4 * dVgsteff_dVb; + dT2_dVd = T3 * dVgst_dVd - T4 * dVgsteff_dVd; + if (selfheat) + dT2_dT = -dVth_dT * T3 + Vgst * dT0_dT; + else + dT2_dT = 0; + + T3 = 1 / (1 + pParam->B3SOIPDsiid * Vds); + dT3_dVd = -pParam->B3SOIPDsiid * 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_dVd = 1.0 - T1 * (T3 * dT2_dVd + T2 * dT3_dVd); + if (selfheat) + dVdiff_dT = -(dVdsatii0_dT + dVgsStep_dT); + else + dVdiff_dT = 0; + + T0 = pParam->B3SOIPDbeta2 + pParam->B3SOIPDbeta1 * Vdiff + + pParam->B3SOIPDbeta0 * Vdiff * Vdiff; + if (T0 < 1e-5) + { + T0 = 1e-5; + dT0_dVg = dT0_dVd = dT0_dVb = dT0_dT = 0.0; + } + else + { + T1 = + pParam->B3SOIPDbeta1 + 2 * pParam->B3SOIPDbeta0 * Vdiff; + dT0_dVg = T1 * dVdiff_dVg; + dT0_dVb = T1 * dVdiff_dVb; + dT0_dVd = T1 * dVdiff_dVd; + if (selfheat) + dT0_dT = T1 * dVdiff_dT; + else + dT0_dT = 0; + } + + if ((T0 < Vdiff / EXPL_THRESHOLD) && (Vdiff > 0.0)) + { + Ratio = pParam->B3SOIPDalpha0 * MAX_EXPL; + dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0; + } + else if ((T0 < -Vdiff / EXPL_THRESHOLD) && (Vdiff < 0.0)) + { + Ratio = pParam->B3SOIPDalpha0 * MIN_EXPL; + dRatio_dVg = dRatio_dVb = dRatio_dVd = dRatio_dT = 0.0; + } + else + { + Ratio = pParam->B3SOIPDalpha0 * 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); + 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; + } + + T0 = Ids + pParam->B3SOIPDfbjtii * Ic; + here->B3SOIPDiii = Iii = Ratio * T0; + Giig = Ratio * Gm + T0 * dRatio_dVg; + Giib = Ratio * (Gmb + pParam->B3SOIPDfbjtii * Gcb) + + T0 * dRatio_dVb; + Giid = Ratio * (Gds + pParam->B3SOIPDfbjtii * Gcd) + + T0 * dRatio_dVd; + + if (selfheat) + GiiT = Ratio * (GmT + pParam->B3SOIPDfbjtii * GcT) + + T0 * dRatio_dT; + else + GiiT = 0.0; + + } + + /* Current through body resistor */ + /* Current going out is +ve */ + if ((here->B3SOIPDbodyMod == 0) || (here->B3SOIPDbodyMod == 2)) + { + Ibp = Gbpbs = Gbpps = 0.0; + } + else + { /* here->B3SOIPDbodyMod == 1 */ + if (pParam->B3SOIPDrbody < 1e-30) + { + if (here->B3SOIPDrbodyext <= 1e-30) + T0 = 1.0 / 1e-30; + else + T0 = 1.0 / here->B3SOIPDrbodyext; + Ibp = Vbp * T0; + Gbpbs = T0 * dVbp_dVb; + Gbpps = -T0 * dVbp_dVb; + } + else + { + Gbpbs = + 1.0 / (pParam->B3SOIPDrbody + here->B3SOIPDrbodyext); + Ibp = Vbp * Gbpbs; + Gbpps = -Gbpbs; + } + } + + here->B3SOIPDibp = Ibp; + here->B3SOIPDgbpbs = Gbpbs; + here->B3SOIPDgbpps = Gbpps; + here->B3SOIPDgbpT = 0.0; + here->B3SOIPDcbodcon = Ibp - (Gbpbs * Vbs + Gbpps * Vps); + + + + /* Current going out of drainprime node into the drain of device */ + /* "node" means the SPICE circuit node */ + + here->B3SOIPDcdrain = Ids + Ic; + here->B3SOIPDcd = Ids + Ic - Ibd + Iii + Idgidl; + here->B3SOIPDcb = Ibs + Ibd + Ibp - Iii - Idgidl - Isgidl - Igb; + + here->B3SOIPDgds = Gds + Gcd; + here->B3SOIPDgm = Gm; + here->B3SOIPDgmbs = Gmb + Gcb; + if (selfheat) + here->B3SOIPDgmT = GmT + GcT; + else + here->B3SOIPDgmT = 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->B3SOIPDgtempg = -Gm * Vds; + here->B3SOIPDgtempb = -Gmb * Vds; + here->B3SOIPDgtempT = -GmT * Vds; + here->B3SOIPDgtempd = -Gds * Vds - Ids; + here->B3SOIPDcth = -Ids * Vds - model->B3SOIPDtype * + (here->B3SOIPDgtempg * Vgs + here->B3SOIPDgtempb * Vbs + + here->B3SOIPDgtempd * Vds) - here->B3SOIPDgtempT * delTemp; + + /* Body current which flows into drainprime node from the drain of device */ + + here->B3SOIPDgjdb = Gjdb - Giib; + here->B3SOIPDgjdd = Gjdd - (Giid + Gdgidld); + here->B3SOIPDgjdg = -(Giig + Gdgidlg); + if (selfheat) + here->B3SOIPDgjdT = GjdT - GiiT; + else + here->B3SOIPDgjdT = 0.0; + here->B3SOIPDcjd = Ibd - Iii - Idgidl + - (here->B3SOIPDgjdb * Vbs + here->B3SOIPDgjdd * Vds + + here->B3SOIPDgjdg * Vgs + here->B3SOIPDgjdT * delTemp); + + /* Body current which flows into sourceprime node from the source of device */ + + here->B3SOIPDgjsb = Gjsb; + here->B3SOIPDgjsd = Gjsd; + here->B3SOIPDgjsg = -Gsgidlg; + if (selfheat) + here->B3SOIPDgjsT = GjsT; + else + here->B3SOIPDgjsT = 0.0; + here->B3SOIPDcjs = Ibs - Isgidl + - (here->B3SOIPDgjsb * Vbs + here->B3SOIPDgjsd * Vds + + here->B3SOIPDgjsg * Vgs + here->B3SOIPDgjsT * delTemp); + + /* Current flowing into body node */ + + here->B3SOIPDgbbs = Giib - Gjsb - Gjdb - Gbpbs; + here->B3SOIPDgbgs = Giig + Gdgidlg + Gsgidlg; + here->B3SOIPDgbds = Giid + Gdgidld - Gjsd - Gjdd; + here->B3SOIPDgbps = -Gbpps; + if (selfheat) + here->B3SOIPDgbT = GiiT - GjsT - GjdT; + else + here->B3SOIPDgbT = 0.0; + + + here->B3SOIPDcbody = Iii + Idgidl + Isgidl - Ibs - Ibd - Ibp + Igb + - ((here->B3SOIPDgbbs + dIgb_dVb) * Vbs + + (here->B3SOIPDgbgs + dIgb_dVg) * Vgs + + (here->B3SOIPDgbds + dIgb_dVd) * Vds + + here->B3SOIPDgbps * Vps + + (here->B3SOIPDgbT + dIgb_dT) * delTemp); + + + here->B3SOIPDcgate = Igb + - (dIgb_dVb * Vbs + dIgb_dVg * Vgs + dIgb_dVd * Vds + + dIgb_dT * delTemp); + + + /* Calculate Qinv for Noise analysis */ + + T1 = Vgsteff * (1.0 - 0.5 * Abulk * Vdseff / Vgst2Vtm); + here->B3SOIPDqinv = + -model->B3SOIPDcox * pParam->B3SOIPDweff * Leff * T1; + + + /* Begin CV (charge) model */ + + if ((model->B3SOIPDxpart < 0) || (!ChargeComputationNeeded)) + { + qgate = qdrn = qsrc = qbody = 0.0; + here->B3SOIPDcggb = here->B3SOIPDcgsb = here->B3SOIPDcgdb = 0.0; + here->B3SOIPDcdgb = here->B3SOIPDcdsb = here->B3SOIPDcddb = 0.0; + here->B3SOIPDcbgb = here->B3SOIPDcbsb = here->B3SOIPDcbdb = 0.0; + goto finished; + } + else + { + CoxWL = + model->B3SOIPDcox * (pParam->B3SOIPDweffCV / + here->B3SOIPDnseg * + pParam->B3SOIPDleffCV + + here->B3SOIPDagbcp); + CoxWLb = + model->B3SOIPDfbody * model->B3SOIPDcox * + (pParam->B3SOIPDweffCV / here->B3SOIPDnseg * + pParam->B3SOIPDleffCVb + here->B3SOIPDagbcp); + + /* 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->B3SOIPDdelvt / (n * Vtm))); + Vgsteff = n * Vtm * log (1.0 + ExpVgst); + T0 = ExpVgst / (1.0 + ExpVgst); + T1 = + -T0 * (dVth_dVb + Vgst / n * dn_dVb) + + Vgsteff / n * dn_dVb; + dVgsteff_dVd = + -T0 * (dVth_dVd + Vgst / n * dn_dVd) + + Vgsteff / n * dn_dVd; + dVgsteff_dVg = T0 * dVgs_eff_dVg; + dVgsteff_dVb = T1 * dVbseff_dVb; + if (selfheat) + dVgsteff_dT = + -T0 * (dVth_dT + (Vgst - pParam->B3SOIPDdelvt) / Temp) + + Vgsteff / Temp; + else + dVgsteff_dT = 0.0; + } + + if (model->B3SOIPDcapMod == 2) + { + Vfb = + Vth - phi - pParam->B3SOIPDk1eff * sqrtPhis + + pParam->B3SOIPDdelvt; + dVfb_dVb = dVth_dVb - pParam->B3SOIPDk1eff * 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->B3SOIPDk1eff == 0.0) + { + T1 = 0.0; + T2 = 0.0; + } + else if (T3 < 0.0) + { + T1 = T0 + T3 / pParam->B3SOIPDk1eff; + 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->B3SOIPDabulkCVfactor; + dAbulkCV_dVb = pParam->B3SOIPDabulkCVfactor * 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->B3SOIPDxpart > 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->B3SOIPDxpart < 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->B3SOIPDkb1 * model->B3SOIPDfbody * Cbox + * (pParam->B3SOIPDweffCV / here->B3SOIPDnseg + * pParam->B3SOIPDleffCVbg + here->B3SOIPDaebcp); + 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->B3SOIPDcggb = Cgg; + here->B3SOIPDcgsb = -(Cgg + Cgd + Cgb); + here->B3SOIPDcgdb = Cgd; + here->B3SOIPDcgT = CgT; + + here->B3SOIPDcbgb = Cbg; + here->B3SOIPDcbsb = -(Cbg + Cbd + Cbb) + Ce1e; + here->B3SOIPDcbdb = Cbd; + here->B3SOIPDcbeb = -Ce1e; + here->B3SOIPDcbT = CbT; + + here->B3SOIPDceeb = Ce1e; + here->B3SOIPDceT = dQe1_dT; + + here->B3SOIPDcdgb = -(Cgg + Cbg + Csg); + here->B3SOIPDcddb = -(Cgd + Cbd + Csd); + here->B3SOIPDcdeb = 0; + here->B3SOIPDcdT = -(CgT + CbT + CsT) - dQe1_dT; + here->B3SOIPDcdsb = (Cgg + Cgd + Cgb + + Cbg + Cbd + Cbb + + Csg + Csd + Csb) + Ce1b; + } /* End of if capMod == 2 */ + + else if (model->B3SOIPDcapMod == 3) + { + dVgsteff_dVb /= dVbseff_dVb; + + if (selfheat) + { + Vfbzb = Vthzb - phi - pParam->B3SOIPDk1eff * sqrtPhi + + pParam->B3SOIPDdelvt; + dVfbzb_dT = dVthzb_dT; + } + else + { + Vfbzb = pParam->B3SOIPDvfbzb + pParam->B3SOIPDdelvt; + 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; + + Cox = model->B3SOIPDcox; + Tox = 1.0e8 * model->B3SOIPDtox; + T0 = (Vgs_eff - Vbseff - Vfbzb) / Tox; + dT0_dVg = dVgs_eff_dVg / Tox; + dT0_dVb = -1.0 / Tox; + + tmp = T0 * pParam->B3SOIPDacde; + if ((-EXPL_THRESHOLD < tmp) && (tmp < EXPL_THRESHOLD)) + { + Tcen = pParam->B3SOIPDldeb * exp (tmp); + dTcen_dVg = pParam->B3SOIPDacde * Tcen; + dTcen_dVb = dTcen_dVg * dT0_dVb; + dTcen_dVg *= dT0_dVg; + if (selfheat) + dTcen_dT = + -Tcen * pParam->B3SOIPDacde * dVfbzb_dT / Tox; + else + dTcen_dT = 0; + } + else if (tmp <= -EXPL_THRESHOLD) + { + Tcen = pParam->B3SOIPDldeb * MIN_EXPL; + dTcen_dVg = dTcen_dVb = dTcen_dT = 0.0; + } + else + { + Tcen = pParam->B3SOIPDldeb * MAX_EXPL; + dTcen_dVg = dTcen_dVb = dTcen_dT = 0.0; + } + + LINK = 1.0e-3 * model->B3SOIPDtox; + V3 = pParam->B3SOIPDldeb - Tcen - LINK; + V4 = sqrt (V3 * V3 + 4.0 * LINK * pParam->B3SOIPDldeb); + Tcen = pParam->B3SOIPDldeb - 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->B3SOIPDk1eff; + T3 = Vgs_eff - Vfbeff - Vbseff - Vgsteff; + if (pParam->B3SOIPDk1eff == 0.0) + { + T1 = 0.0; + T2 = 0.0; + } + else if (T3 < 0.0) + { + T1 = T0 + T3 / pParam->B3SOIPDk1eff; + T2 = CoxWLcenb; + } + else + { + T1 = sqrt (T0 * T0 + T3); + T2 = CoxWLcenb * T0 / T1; + } + + Qsub0 = CoxWLcenb * pParam->B3SOIPDk1eff * (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->B3SOIPDk1eff * (T1 - T0); + else + dQsub0_dT = 0.0; + + /* Gate-bias dependent delta Phis begins */ + if (pParam->B3SOIPDk1eff <= 0.0) + { + Denomi = 0.25 * pParam->B3SOIPDmoin * Vtm; + T0 = 0.5 * pParam->B3SOIPDsqrtPhi; + } + else + { + Denomi = pParam->B3SOIPDmoin * Vtm + * pParam->B3SOIPDk1eff * pParam->B3SOIPDk1eff; + T0 = pParam->B3SOIPDk1eff * pParam->B3SOIPDsqrtPhi; + } + 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->B3SOIPDabulkCVfactor; + dAbulkCV_dVb = pParam->B3SOIPDabulkCVfactor * 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->B3SOIPDxpart > 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->B3SOIPDxpart < 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->B3SOIPDkb1 * model->B3SOIPDfbody * Cbox + * (pParam->B3SOIPDweffCV / here->B3SOIPDnseg + * pParam->B3SOIPDleffCVbg + here->B3SOIPDaebcp); + 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->B3SOIPDcggb = Cgg; + here->B3SOIPDcgsb = -(Cgg + Cgd + Cgb); + here->B3SOIPDcgdb = Cgd; + here->B3SOIPDcgT = CgT; + + here->B3SOIPDcbgb = Cbg; + here->B3SOIPDcbsb = -(Cbg + Cbd + Cbb) + Ce1e; + here->B3SOIPDcbdb = Cbd; + here->B3SOIPDcbeb = -Ce1e; + here->B3SOIPDcbT = CbT; + + here->B3SOIPDceT = Ce1T; + here->B3SOIPDceeb = Ce1e; + + here->B3SOIPDcdgb = -(Cgg + Cbg + Csg); + here->B3SOIPDcddb = -(Cgd + Cbd + Csd); + here->B3SOIPDcdeb = 0; + here->B3SOIPDcdT = -(CgT + CbT + CsT) - Ce1T; + here->B3SOIPDcdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb + + Csg + Csd + Csb) + Ce1b; + here->B3SOIPDqinv = -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->B3SOIPDGatesidewallJctPotential; + dPhiBSWG_dT = -model->B3SOIPDtpbswg; + PhiBSWG += dPhiBSWG_dT * (Temp - model->B3SOIPDtnom); + MJSWG = model->B3SOIPDbodyJctGateSideGradingCoeff; + + cjsbs = model->B3SOIPDunitLengthGateSidewallJctCap + * wdiosCV * model->B3SOIPDtsi / 1e-7; + dcjsbs_dT = cjsbs * model->B3SOIPDtcjswg; + cjsbs += dcjsbs_dT * (Temp - model->B3SOIPDtnom); + + cjdbs = model->B3SOIPDunitLengthGateSidewallJctCap + * wdiodCV * model->B3SOIPDtsi / 1e-7; + dcjdbs_dT = cjdbs * model->B3SOIPDtcjswg; + cjdbs += dcjdbs_dT * (Temp - model->B3SOIPDtnom); + + 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->B3SOIPDtt * Ibsdif; + gcjsbs = cjsbs * dT3_dVb + model->B3SOIPDtt * dIbsdif_dVb; + + if (selfheat) + gcjsT = + model->B3SOIPDtt * 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->B3SOIPDtt * Ibddif; + gcjdbs = cjdbs * dT3_dVb + model->B3SOIPDtt * dIbddif_dVb; + gcjdds = cjdbs * dT3_dVd + model->B3SOIPDtt * dIbddif_dVd; + + if (selfheat) + gcjdT = + model->B3SOIPDtt * 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->B3SOIPDcddb -= gcjdds; + here->B3SOIPDcdT -= gcjdT; + here->B3SOIPDcdsb += gcjdds + gcjdbs; + + here->B3SOIPDcbdb += (gcjdds); + here->B3SOIPDcbT += (gcjdT + gcjsT); + here->B3SOIPDcbsb -= (gcjdds + gcjdbs + gcjsbs); + + + /* Extrinsic Bottom S/D to substrate charge */ + T10 = -model->B3SOIPDtype * ves; + /* T10 is vse without type conversion */ + T11 = model->B3SOIPDtype * (vds - ves); + /* T11 is vde without type conversion */ + + if (model->B3SOIPDcsdmin != 0.0) + { + if (((pParam->B3SOIPDnsub > 0) && (model->B3SOIPDtype > 0)) + || ((pParam->B3SOIPDnsub < 0) + && (model->B3SOIPDtype < 0))) + { + if (T10 < pParam->B3SOIPDvsdfb) + { + here->B3SOIPDqse = + here->B3SOIPDcsbox * (T10 - pParam->B3SOIPDvsdfb); + here->B3SOIPDgcse = here->B3SOIPDcsbox; + } + else if (T10 < pParam->B3SOIPDsdt1) + { + T0 = T10 - pParam->B3SOIPDvsdfb; + T1 = T0 * T0; + here->B3SOIPDqse = T0 * (here->B3SOIPDcsbox - + pParam->B3SOIPDst2 / 3 * + T1); + here->B3SOIPDgcse = + here->B3SOIPDcsbox - pParam->B3SOIPDst2 * T1; + } + else if (T10 < pParam->B3SOIPDvsdth) + { + T0 = T10 - pParam->B3SOIPDvsdth; + T1 = T0 * T0; + here->B3SOIPDqse = + here->B3SOIPDcsmin * T10 + here->B3SOIPDst4 + + pParam->B3SOIPDst3 / 3 * T0 * T1; + here->B3SOIPDgcse = + here->B3SOIPDcsmin + pParam->B3SOIPDst3 * T1; + } + else + { + here->B3SOIPDqse = + here->B3SOIPDcsmin * T10 + here->B3SOIPDst4; + here->B3SOIPDgcse = here->B3SOIPDcsmin; + } + } + else + { + if (T10 < pParam->B3SOIPDvsdth) + { + here->B3SOIPDqse = + here->B3SOIPDcsmin * (T10 - pParam->B3SOIPDvsdth); + here->B3SOIPDgcse = here->B3SOIPDcsmin; + } + else if (T10 < pParam->B3SOIPDsdt1) + { + T0 = T10 - pParam->B3SOIPDvsdth; + T1 = T0 * T0; + here->B3SOIPDqse = + T0 * (here->B3SOIPDcsmin - + pParam->B3SOIPDst2 / 3 * T1); + here->B3SOIPDgcse = + here->B3SOIPDcsmin - pParam->B3SOIPDst2 * T1; + } + else if (T10 < pParam->B3SOIPDvsdfb) + { + T0 = T10 - pParam->B3SOIPDvsdfb; + T1 = T0 * T0; + here->B3SOIPDqse = + here->B3SOIPDcsbox * T10 + here->B3SOIPDst4 + + pParam->B3SOIPDst3 / 3 * T0 * T1; + here->B3SOIPDgcse = + here->B3SOIPDcsbox + pParam->B3SOIPDst3 * T1; + } + else + { + here->B3SOIPDqse = + here->B3SOIPDcsbox * T10 + here->B3SOIPDst4; + here->B3SOIPDgcse = here->B3SOIPDcsbox; + } + } + + if (((pParam->B3SOIPDnsub > 0) && (model->B3SOIPDtype > 0)) + || ((pParam->B3SOIPDnsub < 0) + && (model->B3SOIPDtype < 0))) + { + if (T11 < pParam->B3SOIPDvsdfb) + { + here->B3SOIPDqde = + here->B3SOIPDcdbox * (T11 - pParam->B3SOIPDvsdfb); + here->B3SOIPDgcde = here->B3SOIPDcdbox; + } + else if (T11 < pParam->B3SOIPDsdt1) + { + T0 = T11 - pParam->B3SOIPDvsdfb; + T1 = T0 * T0; + here->B3SOIPDqde = + T0 * (here->B3SOIPDcdbox - + pParam->B3SOIPDdt2 / 3 * T1); + here->B3SOIPDgcde = + here->B3SOIPDcdbox - pParam->B3SOIPDdt2 * T1; + } + else if (T11 < pParam->B3SOIPDvsdth) + { + T0 = T11 - pParam->B3SOIPDvsdth; + T1 = T0 * T0; + here->B3SOIPDqde = + here->B3SOIPDcdmin * T11 + here->B3SOIPDdt4 + + pParam->B3SOIPDdt3 / 3 * T0 * T1; + here->B3SOIPDgcde = + here->B3SOIPDcdmin + pParam->B3SOIPDdt3 * T1; + } + else + { + here->B3SOIPDqde = + here->B3SOIPDcdmin * T11 + here->B3SOIPDdt4; + here->B3SOIPDgcde = here->B3SOIPDcdmin; + } + } + else + { + if (T11 < pParam->B3SOIPDvsdth) + { + here->B3SOIPDqde = + here->B3SOIPDcdmin * (T11 - pParam->B3SOIPDvsdth); + here->B3SOIPDgcde = here->B3SOIPDcdmin; + } + else if (T11 < pParam->B3SOIPDsdt1) + { + T0 = T11 - pParam->B3SOIPDvsdth; + T1 = T0 * T0; + here->B3SOIPDqde = + T0 * (here->B3SOIPDcdmin - + pParam->B3SOIPDdt2 / 3 * T1); + here->B3SOIPDgcde = + here->B3SOIPDcdmin - pParam->B3SOIPDdt2 * T1; + } + else if (T11 < pParam->B3SOIPDvsdfb) + { + T0 = T11 - pParam->B3SOIPDvsdfb; + T1 = T0 * T0; + here->B3SOIPDqde = + here->B3SOIPDcdbox * T11 + here->B3SOIPDdt4 + + pParam->B3SOIPDdt3 / 3 * T0 * T1; + here->B3SOIPDgcde = + here->B3SOIPDcdbox + pParam->B3SOIPDdt3 * T1; + } + else + { + here->B3SOIPDqde = + here->B3SOIPDcdbox * T11 + here->B3SOIPDdt4; + here->B3SOIPDgcde = here->B3SOIPDcdbox; + } + } + } + else + { + here->B3SOIPDqse = here->B3SOIPDcsbox * T10; + here->B3SOIPDgcse = here->B3SOIPDcsbox; + here->B3SOIPDqde = here->B3SOIPDcdbox * T11; + here->B3SOIPDgcde = here->B3SOIPDcdbox; + } + + /* Extrinsic : Sidewall fringing S/D charge */ + here->B3SOIPDqse += pParam->B3SOIPDcsesw * T10; + here->B3SOIPDgcse += pParam->B3SOIPDcsesw; + here->B3SOIPDqde += pParam->B3SOIPDcdesw * T11; + here->B3SOIPDgcde += pParam->B3SOIPDcdesw; + + /* All charge are mutliplied with type at the end, but qse and qde + have true polarity => so pre-mutliplied with type */ + here->B3SOIPDqse *= model->B3SOIPDtype; + here->B3SOIPDqde *= model->B3SOIPDtype; + } + + + here->B3SOIPDcbb = Cbb; + here->B3SOIPDcbd = Cbd; + here->B3SOIPDcbg = Cbg; + here->B3SOIPDqbf = -Qsub0 - Qac0; + here->B3SOIPDqjs = qjs; + here->B3SOIPDqjd = qjd; + + /* + * check convergence + */ + if ((here->B3SOIPDoff == 0) || (!(ckt->CKTmode & MODEINITFIX))) + { + if (Check == 1) + { + ckt->CKTnoncon++; +#ifndef NEWCONV + } + else + { + tol = + ckt->CKTreltol * MAX (fabs (cdhat), + fabs (here->B3SOIPDcd)) + + ckt->CKTabstol; + if (fabs (cdhat - here->B3SOIPDcd) >= tol) + { + ckt->CKTnoncon++; + } + else + { + tol = ckt->CKTreltol * MAX (fabs (cbhat), + fabs (here->B3SOIPDcbs + + here->B3SOIPDcbd)) + + ckt->CKTabstol; + if (fabs (cbhat - (here->B3SOIPDcbs + here->B3SOIPDcbd)) + > tol) + { + ckt->CKTnoncon++; + } + } +#endif /* NEWCONV */ + } + } + + *(ckt->CKTstate0 + here->B3SOIPDvg) = vg; + *(ckt->CKTstate0 + here->B3SOIPDvd) = vd; + *(ckt->CKTstate0 + here->B3SOIPDvs) = vs; + *(ckt->CKTstate0 + here->B3SOIPDvp) = vp; + *(ckt->CKTstate0 + here->B3SOIPDve) = ve; + + *(ckt->CKTstate0 + here->B3SOIPDvbs) = vbs; + *(ckt->CKTstate0 + here->B3SOIPDvbd) = vbd; + *(ckt->CKTstate0 + here->B3SOIPDvgs) = vgs; + *(ckt->CKTstate0 + here->B3SOIPDvds) = vds; + *(ckt->CKTstate0 + here->B3SOIPDves) = ves; + *(ckt->CKTstate0 + here->B3SOIPDvps) = vps; + *(ckt->CKTstate0 + here->B3SOIPDdeltemp) = 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); + + T3 = wdiodCV * pParam->B3SOIPDcgdl; + T4 = sqrt (1.0 - 4.0 * T2 / pParam->B3SOIPDckappa); + cgdo = pParam->B3SOIPDcgdo + T3 - T3 * (1.0 - 1.0 / T4) + * (0.5 - 0.5 * T0 / T1); + qgdo = (pParam->B3SOIPDcgdo + T3) * vgd - T3 * (T2 + + + 0.5 * + pParam-> + B3SOIPDckappa * + (T4 - 1.0)); + + T0 = vgs + DELTA_1; + T1 = sqrt (T0 * T0 + 4.0 * DELTA_1); + T2 = 0.5 * (T0 - T1); + T3 = wdiosCV * pParam->B3SOIPDcgsl; + T4 = sqrt (1.0 - 4.0 * T2 / pParam->B3SOIPDckappa); + cgso = pParam->B3SOIPDcgso + T3 - T3 * (1.0 - 1.0 / T4) + * (0.5 - 0.5 * T0 / T1); + qgso = (pParam->B3SOIPDcgso + T3) * vgs - T3 * (T2 + + + 0.5 * + pParam-> + B3SOIPDckappa * + (T4 - 1.0)); + + + + if (here->B3SOIPDdebugMod < 0) + goto line850; + + + if (here->B3SOIPDmode > 0) + { + gcdgb = (here->B3SOIPDcdgb - cgdo) * ag0; + gcddb = (here->B3SOIPDcddb + cgdo + here->B3SOIPDgcde) * ag0; + gcdsb = here->B3SOIPDcdsb * ag0; + gcdeb = (here->B3SOIPDcdeb - here->B3SOIPDgcde) * ag0; + gcdT = model->B3SOIPDtype * here->B3SOIPDcdT * ag0; + + gcsgb = + -(here->B3SOIPDcggb + here->B3SOIPDcbgb + here->B3SOIPDcdgb + + cgso) * ag0; + gcsdb = + -(here->B3SOIPDcgdb + here->B3SOIPDcbdb + + here->B3SOIPDcddb) * ag0; + gcssb = + (cgso + here->B3SOIPDgcse - + (here->B3SOIPDcgsb + here->B3SOIPDcbsb + + here->B3SOIPDcdsb)) * ag0; + gcseb = + -(here->B3SOIPDgcse + here->B3SOIPDcbeb + here->B3SOIPDcdeb + + here->B3SOIPDceeb) * ag0; + gcsT = + -model->B3SOIPDtype * (here->B3SOIPDcgT + here->B3SOIPDcbT + + here->B3SOIPDcdT + + here->B3SOIPDceT) * ag0; + + gcggb = + (here->B3SOIPDcggb + cgdo + cgso + pParam->B3SOIPDcgeo) * ag0; + gcgdb = (here->B3SOIPDcgdb - cgdo) * ag0; + gcgsb = (here->B3SOIPDcgsb - cgso) * ag0; + gcgeb = (-pParam->B3SOIPDcgeo) * ag0; + gcgT = model->B3SOIPDtype * here->B3SOIPDcgT * ag0; + + gcbgb = here->B3SOIPDcbgb * ag0; + gcbdb = here->B3SOIPDcbdb * ag0; + gcbsb = here->B3SOIPDcbsb * ag0; + gcbeb = here->B3SOIPDcbeb * ag0; + gcbT = model->B3SOIPDtype * here->B3SOIPDcbT * ag0; + + gcegb = (-pParam->B3SOIPDcgeo) * ag0; + gcedb = (-here->B3SOIPDgcde) * ag0; + gcesb = (-here->B3SOIPDgcse) * ag0; + gceeb = (here->B3SOIPDgcse + here->B3SOIPDgcde + + here->B3SOIPDceeb + pParam->B3SOIPDcgeo) * ag0; + + gceT = model->B3SOIPDtype * here->B3SOIPDceT * ag0; + + gcTt = pParam->B3SOIPDcth * ag0; + + sxpart = 0.6; + dxpart = 0.4; + + /* Lump the overlap capacitance and S/D parasitics */ + qgd = qgdo; + qgs = qgso; + qge = pParam->B3SOIPDcgeo * vge; + qgate += qgd + qgs + qge; + qdrn += here->B3SOIPDqde - qgd; + qsub -= qge + here->B3SOIPDqse + here->B3SOIPDqde; + qsrc = -(qgate + qbody + qdrn + qsub); + } + else + { + gcsgb = (here->B3SOIPDcdgb - cgso) * ag0; + gcssb = (here->B3SOIPDcddb + cgso + here->B3SOIPDgcse) * ag0; + gcsdb = here->B3SOIPDcdsb * ag0; + gcseb = (here->B3SOIPDcdeb - here->B3SOIPDgcse) * ag0; + gcsT = model->B3SOIPDtype * here->B3SOIPDcdT * ag0; + + gcdgb = + -(here->B3SOIPDcggb + here->B3SOIPDcbgb + here->B3SOIPDcdgb + + cgdo) * ag0; + gcdsb = + -(here->B3SOIPDcgdb + here->B3SOIPDcbdb + + here->B3SOIPDcddb) * ag0; + gcddb = + (cgdo + here->B3SOIPDgcde - + (here->B3SOIPDcgsb + here->B3SOIPDcbsb + + here->B3SOIPDcdsb)) * ag0; + gcdeb = + -(here->B3SOIPDgcde + here->B3SOIPDcbeb + here->B3SOIPDcdeb + + here->B3SOIPDceeb) * ag0; + gcdT = + -model->B3SOIPDtype * (here->B3SOIPDcgT + here->B3SOIPDcbT + + here->B3SOIPDcdT + + here->B3SOIPDceT) * ag0; + + gcggb = + (here->B3SOIPDcggb + cgdo + cgso + pParam->B3SOIPDcgeo) * ag0; + gcgsb = (here->B3SOIPDcgdb - cgso) * ag0; + gcgdb = (here->B3SOIPDcgsb - cgdo) * ag0; + gcgeb = (-pParam->B3SOIPDcgeo) * ag0; + gcgT = model->B3SOIPDtype * here->B3SOIPDcgT * ag0; + + gcbgb = here->B3SOIPDcbgb * ag0; + gcbsb = here->B3SOIPDcbdb * ag0; + gcbdb = here->B3SOIPDcbsb * ag0; + gcbeb = here->B3SOIPDcbeb * ag0; + gcbT = model->B3SOIPDtype * here->B3SOIPDcbT * ag0; + + gcegb = (-pParam->B3SOIPDcgeo) * ag0; + gcesb = (-here->B3SOIPDgcse) * ag0; + gcedb = (-here->B3SOIPDgcde) * ag0; + gceeb = (here->B3SOIPDceeb + pParam->B3SOIPDcgeo + + here->B3SOIPDgcse + here->B3SOIPDgcde) * ag0; + gceT = model->B3SOIPDtype * here->B3SOIPDceT * ag0; + + gcTt = pParam->B3SOIPDcth * ag0; + + dxpart = 0.6; + sxpart = 0.4; + + /* Lump the overlap capacitance */ + qgd = qgdo; + qgs = qgso; + qge = pParam->B3SOIPDcgeo * vge; + qgate += qgd + qgs + qge; + qsrc = qdrn - qgs + here->B3SOIPDqse; + qsub -= qge + here->B3SOIPDqse + here->B3SOIPDqde; + qdrn = -(qgate + qbody + qsrc + qsub); + } + + here->B3SOIPDcgdo = cgdo; + here->B3SOIPDcgso = cgso; + + if (ByPass) + goto line860; + + *(ckt->CKTstate0 + here->B3SOIPDqe) = qsub; + *(ckt->CKTstate0 + here->B3SOIPDqg) = qgate; + *(ckt->CKTstate0 + here->B3SOIPDqd) = qdrn; + *(ckt->CKTstate0 + here->B3SOIPDqb) = qbody; + if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0 != 0.0)) + *(ckt->CKTstate0 + here->B3SOIPDqth) = + pParam->B3SOIPDcth * delTemp; + + + /* store small signal parameters */ + if (ckt->CKTmode & MODEINITSMSIG) + { + goto line1000; + } + if (!ChargeComputationNeeded) + goto line850; + + + if (ckt->CKTmode & MODEINITTRAN) + { + *(ckt->CKTstate1 + here->B3SOIPDqb) = + *(ckt->CKTstate0 + here->B3SOIPDqb); + *(ckt->CKTstate1 + here->B3SOIPDqg) = + *(ckt->CKTstate0 + here->B3SOIPDqg); + *(ckt->CKTstate1 + here->B3SOIPDqd) = + *(ckt->CKTstate0 + here->B3SOIPDqd); + *(ckt->CKTstate1 + here->B3SOIPDqe) = + *(ckt->CKTstate0 + here->B3SOIPDqe); + *(ckt->CKTstate1 + here->B3SOIPDqth) = + *(ckt->CKTstate0 + here->B3SOIPDqth); + } + + error = NIintegrate (ckt, &geq, &ceq, 0.0, here->B3SOIPDqb); + if (error) + return (error); + error = NIintegrate (ckt, &geq, &ceq, 0.0, here->B3SOIPDqg); + if (error) + return (error); + error = NIintegrate (ckt, &geq, &ceq, 0.0, here->B3SOIPDqd); + if (error) + return (error); + error = NIintegrate (ckt, &geq, &ceq, 0.0, here->B3SOIPDqe); + if (error) + return (error); + if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0 != 0.0)) + { + error = NIintegrate (ckt, &geq, &ceq, 0.0, here->B3SOIPDqth); + 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->B3SOIPDmode > 0) ? 0.4 : 0.6)); + + goto line900; + + line860: + /* evaluate equivalent charge current */ + + cqgate = *(ckt->CKTstate0 + here->B3SOIPDcqg); + cqbody = *(ckt->CKTstate0 + here->B3SOIPDcqb); + cqdrn = *(ckt->CKTstate0 + here->B3SOIPDcqd); + cqsub = *(ckt->CKTstate0 + here->B3SOIPDcqe); + cqtemp = *(ckt->CKTstate0 + here->B3SOIPDcqth); + + here->B3SOIPDcb += cqbody; + here->B3SOIPDcd += 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->B3SOIPDcqe) = + *(ckt->CKTstate0 + here->B3SOIPDcqe); + *(ckt->CKTstate1 + here->B3SOIPDcqb) = + *(ckt->CKTstate0 + here->B3SOIPDcqb); + *(ckt->CKTstate1 + here->B3SOIPDcqg) = + *(ckt->CKTstate0 + here->B3SOIPDcqg); + *(ckt->CKTstate1 + here->B3SOIPDcqd) = + *(ckt->CKTstate0 + here->B3SOIPDcqd); + *(ckt->CKTstate1 + here->B3SOIPDcqth) = + *(ckt->CKTstate0 + here->B3SOIPDcqth); + } + + /* + * load current vector + */ + line900: + + if (here->B3SOIPDmode >= 0) + { + Gm = here->B3SOIPDgm; + Gmbs = here->B3SOIPDgmbs; + GmT = model->B3SOIPDtype * here->B3SOIPDgmT; + FwdSum = Gm + Gmbs; + RevSum = 0.0; + cdreq = + model->B3SOIPDtype * (here->B3SOIPDcdrain - + here->B3SOIPDgds * vds - Gm * vgs - + Gmbs * vbs - GmT * delTemp); + /* ceqbs now is compatible with cdreq, ie. going in is +ve */ + /* Equivalent current source from the diode */ + ceqbs = here->B3SOIPDcjs; + ceqbd = here->B3SOIPDcjd; + /* Current going in is +ve */ + ceqbody = -here->B3SOIPDcbody; + + + ceqgate = here->B3SOIPDcgate; + gigg = here->B3SOIPDgigg; + gigb = here->B3SOIPDgigb; + gigs = here->B3SOIPDgigs; + gigd = here->B3SOIPDgigd; + gigT = model->B3SOIPDtype * here->B3SOIPDgigT; + + ceqth = here->B3SOIPDcth; + ceqbodcon = here->B3SOIPDcbodcon; + + gbbg = -here->B3SOIPDgbgs; + gbbdp = -here->B3SOIPDgbds; + gbbb = -here->B3SOIPDgbbs; + gbbp = -here->B3SOIPDgbps; + gbbT = -model->B3SOIPDtype * here->B3SOIPDgbT; + gbbsp = -(gbbg + gbbdp + gbbb + gbbp); + + gddpg = -here->B3SOIPDgjdg; + gddpdp = -here->B3SOIPDgjdd; + gddpb = -here->B3SOIPDgjdb; + gddpT = -model->B3SOIPDtype * here->B3SOIPDgjdT; + gddpsp = -(gddpg + gddpdp + gddpb); + + gsspg = -here->B3SOIPDgjsg; + gsspdp = -here->B3SOIPDgjsd; + gsspb = -here->B3SOIPDgjsb; + gsspT = -model->B3SOIPDtype * here->B3SOIPDgjsT; + gsspsp = -(gsspg + gsspdp + gsspb); + + gppb = -here->B3SOIPDgbpbs; + gppp = -here->B3SOIPDgbpps; + gppT = -model->B3SOIPDtype * here->B3SOIPDgbpT; + + gTtg = here->B3SOIPDgtempg; + gTtb = here->B3SOIPDgtempb; + gTtdp = here->B3SOIPDgtempd; + gTtt = here->B3SOIPDgtempT; + gTtsp = -(gTtg + gTtb + gTtdp); + } + else + { + Gm = -here->B3SOIPDgm; + Gmbs = -here->B3SOIPDgmbs; + GmT = -model->B3SOIPDtype * here->B3SOIPDgmT; + FwdSum = 0.0; + RevSum = -(Gm + Gmbs); + cdreq = + -model->B3SOIPDtype * (here->B3SOIPDcdrain + + here->B3SOIPDgds * vds + Gm * vgd + + Gmbs * vbd + GmT * delTemp); + ceqbs = here->B3SOIPDcjd; + ceqbd = here->B3SOIPDcjs; + /* Current going in is +ve */ + ceqbody = -here->B3SOIPDcbody; + + + ceqgate = here->B3SOIPDcgate; + gigg = here->B3SOIPDgigg; + gigb = here->B3SOIPDgigb; + gigs = here->B3SOIPDgigd; + gigd = here->B3SOIPDgigs; + gigT = model->B3SOIPDtype * here->B3SOIPDgigT; + + ceqth = here->B3SOIPDcth; + ceqbodcon = here->B3SOIPDcbodcon; + + gbbg = -here->B3SOIPDgbgs; + gbbb = -here->B3SOIPDgbbs; + gbbp = -here->B3SOIPDgbps; + gbbsp = -here->B3SOIPDgbds; + gbbT = -model->B3SOIPDtype * here->B3SOIPDgbT; + gbbdp = -(gbbg + gbbsp + gbbb + gbbp); + + gddpg = -here->B3SOIPDgjsg; + gddpsp = -here->B3SOIPDgjsd; + gddpb = -here->B3SOIPDgjsb; + gddpT = -model->B3SOIPDtype * here->B3SOIPDgjsT; + gddpdp = -(gddpg + gddpsp + gddpb); + + gsspg = -here->B3SOIPDgjdg; + gsspsp = -here->B3SOIPDgjdd; + gsspb = -here->B3SOIPDgjdb; + gsspT = -model->B3SOIPDtype * here->B3SOIPDgjdT; + gsspdp = -(gsspg + gsspsp + gsspb); + + gppb = -here->B3SOIPDgbpbs; + gppp = -here->B3SOIPDgbpps; + gppT = -model->B3SOIPDtype * here->B3SOIPDgbpT; + + gTtg = here->B3SOIPDgtempg; + gTtb = here->B3SOIPDgtempb; + gTtsp = here->B3SOIPDgtempd; + gTtt = here->B3SOIPDgtempT; + gTtdp = -(gTtg + gTtb + gTtsp); + } + + if (model->B3SOIPDtype > 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; + } + + (*(ckt->CKTrhs + here->B3SOIPDbNode) -= (ceqbody + ceqqb)); + + (*(ckt->CKTrhs + here->B3SOIPDgNode) -= (ceqgate + ceqqg)); + (*(ckt->CKTrhs + here->B3SOIPDdNodePrime) += (ceqbd - cdreq - ceqqd)); + (*(ckt->CKTrhs + here->B3SOIPDsNodePrime) += (cdreq + ceqbs + ceqqg + + ceqqb + ceqqd + + ceqqe)); + (*(ckt->CKTrhs + here->B3SOIPDeNode) -= ceqqe); + + if (here->B3SOIPDbodyMod == 1) + { + (*(ckt->CKTrhs + here->B3SOIPDpNode) += ceqbodcon); + } + + if (selfheat) + { + (*(ckt->CKTrhs + here->B3SOIPDtempNode) -= ceqth + ceqqth); + } + + + + if (here->B3SOIPDdebugMod != 0) + { + *(ckt->CKTrhs + here->B3SOIPDvbsNode) = here->B3SOIPDvbseff; + *(ckt->CKTrhs + here->B3SOIPDidsNode) = FLOG (here->B3SOIPDids); + *(ckt->CKTrhs + here->B3SOIPDicNode) = FLOG (here->B3SOIPDic); + *(ckt->CKTrhs + here->B3SOIPDibsNode) = FLOG (here->B3SOIPDibs); + *(ckt->CKTrhs + here->B3SOIPDibdNode) = FLOG (here->B3SOIPDibd); + *(ckt->CKTrhs + here->B3SOIPDiiiNode) = FLOG (here->B3SOIPDiii); + *(ckt->CKTrhs + here->B3SOIPDigNode) = here->B3SOIPDig; + *(ckt->CKTrhs + here->B3SOIPDgiggNode) = here->B3SOIPDgigg; + *(ckt->CKTrhs + here->B3SOIPDgigdNode) = here->B3SOIPDgigd; + *(ckt->CKTrhs + here->B3SOIPDgigbNode) = here->B3SOIPDgigb; + *(ckt->CKTrhs + here->B3SOIPDigidlNode) = here->B3SOIPDigidl; + *(ckt->CKTrhs + here->B3SOIPDitunNode) = here->B3SOIPDitun; + *(ckt->CKTrhs + here->B3SOIPDibpNode) = here->B3SOIPDibp; + *(ckt->CKTrhs + here->B3SOIPDcbbNode) = here->B3SOIPDcbb; + *(ckt->CKTrhs + here->B3SOIPDcbdNode) = here->B3SOIPDcbd; + *(ckt->CKTrhs + here->B3SOIPDcbgNode) = here->B3SOIPDcbg; + *(ckt->CKTrhs + here->B3SOIPDqbfNode) = here->B3SOIPDqbf; + *(ckt->CKTrhs + here->B3SOIPDqjsNode) = here->B3SOIPDqjs; + *(ckt->CKTrhs + here->B3SOIPDqjdNode) = here->B3SOIPDqjd; + } + + + /* + * load y matrix + */ + Gmin = ckt->CKTgmin * 1e-6; + + *(here->B3SOIPDEdpPtr) += gcedb; + *(here->B3SOIPDEspPtr) += gcesb; + *(here->B3SOIPDDPePtr) += gcdeb; + *(here->B3SOIPDSPePtr) += gcseb; + *(here->B3SOIPDEgPtr) += gcegb; + *(here->B3SOIPDGePtr) += gcgeb; + + (*(here->B3SOIPDEbPtr) -= gcegb + gcedb + gcesb + gceeb); + (*(here->B3SOIPDGbPtr) -= -gigb + gcggb + gcgdb + gcgsb + gcgeb); + (*(here->B3SOIPDDPbPtr) -= (-gddpb - Gmbs + gcdgb + gcddb + gcdeb + gcdsb)); + + + (*(here->B3SOIPDSPbPtr) -= + (-gsspb + Gmbs + gcsgb + gcsdb + gcseb + gcssb)) + Gmin; + + + (*(here->B3SOIPDBePtr) += gcbeb); + (*(here->B3SOIPDBgPtr) += -gigg + gcbgb + gbbg); + (*(here->B3SOIPDBdpPtr) += -gigd + gcbdb + gbbdp); + (*(here->B3SOIPDBspPtr) += gcbsb + gbbsp - Gmin - gigs); + + (*(here->B3SOIPDBbPtr) += + -gigb + gbbb - gcbgb - gcbdb - gcbsb - gcbeb + Gmin); + (*(here->B3SOIPDEePtr) += gceeb); + + (*(here->B3SOIPDGgPtr) += gigg + gcggb + ckt->CKTgmin); + (*(here->B3SOIPDGdpPtr) += gigd + gcgdb - ckt->CKTgmin); + (*(here->B3SOIPDGspPtr) += gcgsb + gigs); + + (*(here->B3SOIPDDPgPtr) += (Gm + gcdgb) + gddpg - ckt->CKTgmin); + (*(here->B3SOIPDDPdpPtr) += (here->B3SOIPDdrainConductance + + here->B3SOIPDgds + gddpdp + + RevSum + gcddb) + ckt->CKTgmin); + (*(here->B3SOIPDDPspPtr) -= (-gddpsp + here->B3SOIPDgds + FwdSum - gcdsb)); + + (*(here->B3SOIPDDPdPtr) -= here->B3SOIPDdrainConductance); + + (*(here->B3SOIPDSPgPtr) += gcsgb - Gm + gsspg); + (*(here->B3SOIPDSPdpPtr) -= (here->B3SOIPDgds - gsspdp + RevSum - gcsdb)); + + (*(here->B3SOIPDSPspPtr) += (here->B3SOIPDsourceConductance + + here->B3SOIPDgds + gsspsp + + FwdSum + gcssb)) + Gmin; + + + (*(here->B3SOIPDSPsPtr) -= here->B3SOIPDsourceConductance); + + + (*(here->B3SOIPDDdPtr) += here->B3SOIPDdrainConductance); + (*(here->B3SOIPDDdpPtr) -= here->B3SOIPDdrainConductance); + + + (*(here->B3SOIPDSsPtr) += here->B3SOIPDsourceConductance); + (*(here->B3SOIPDSspPtr) -= here->B3SOIPDsourceConductance); + + if (here->B3SOIPDbodyMod == 1) + { + (*(here->B3SOIPDBpPtr) -= gppp); + (*(here->B3SOIPDPbPtr) += gppb); + (*(here->B3SOIPDPpPtr) += gppp); + } + + if (selfheat) + { + (*(here->B3SOIPDDPtempPtr) += GmT + gddpT + gcdT); + (*(here->B3SOIPDSPtempPtr) += -GmT + gsspT + gcsT); + (*(here->B3SOIPDBtempPtr) += gbbT + gcbT - gigT); + (*(here->B3SOIPDEtempPtr) += gceT); + (*(here->B3SOIPDGtempPtr) += gcgT + gigT); + (*(here->B3SOIPDTemptempPtr) += gTtt + 1 / pParam->B3SOIPDrth + gcTt); + (*(here->B3SOIPDTempgPtr) += gTtg); + (*(here->B3SOIPDTempbPtr) += gTtb); + (*(here->B3SOIPDTempdpPtr) += gTtdp); + (*(here->B3SOIPDTempspPtr) += gTtsp); + } + + if (here->B3SOIPDdebugMod != 0) + { + *(here->B3SOIPDVbsPtr) += 1; + *(here->B3SOIPDIdsPtr) += 1; + *(here->B3SOIPDIcPtr) += 1; + *(here->B3SOIPDIbsPtr) += 1; + *(here->B3SOIPDIbdPtr) += 1; + *(here->B3SOIPDIiiPtr) += 1; + *(here->B3SOIPDIgPtr) += 1; + *(here->B3SOIPDGiggPtr) += 1; + *(here->B3SOIPDGigdPtr) += 1; + *(here->B3SOIPDGigbPtr) += 1; + *(here->B3SOIPDIgidlPtr) += 1; + *(here->B3SOIPDItunPtr) += 1; + *(here->B3SOIPDIbpPtr) += 1; + *(here->B3SOIPDCbgPtr) += 1; + *(here->B3SOIPDCbbPtr) += 1; + *(here->B3SOIPDCbdPtr) += 1; + *(here->B3SOIPDQbfPtr) += 1; + *(here->B3SOIPDQjsPtr) += 1; + *(here->B3SOIPDQjdPtr) += 1; + + } + + line1000:; + + + } /* End of Mosfet Instance */ + } /* End of Model Instance */ + + + return (OK); +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdmask.c b/src/spicelib/devices/bsim3soi_pd/b3soipdmask.c new file mode 100644 index 000000000..28e9032f0 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdmask.c @@ -0,0 +1,1438 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdmask.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 +**********/ + + +#include "ngspice.h" +#include +#include "ifsim.h" +#include "cktdefs.h" +#include "devdefs.h" +#include "b3soipddef.h" +#include "sperror.h" +#include "suffix.h" + +int +B3SOIPDmAsk (ckt, inst, which, value) + CKTcircuit *ckt; + GENmodel *inst; + int which; + IFvalue *value; +{ + B3SOIPDmodel *model = (B3SOIPDmodel *) inst; + switch (which) + { + case B3SOIPD_MOD_MOBMOD: + value->iValue = model->B3SOIPDmobMod; + return (OK); + case B3SOIPD_MOD_PARAMCHK: + value->iValue = model->B3SOIPDparamChk; + return (OK); + case B3SOIPD_MOD_BINUNIT: + value->iValue = model->B3SOIPDbinUnit; + return (OK); + case B3SOIPD_MOD_CAPMOD: + value->iValue = model->B3SOIPDcapMod; + return (OK); + case B3SOIPD_MOD_SHMOD: + value->iValue = model->B3SOIPDshMod; + return (OK); + case B3SOIPD_MOD_NOIMOD: + value->iValue = model->B3SOIPDnoiMod; + return (OK); + case B3SOIPD_MOD_VERSION: + value->rValue = model->B3SOIPDversion; + return (OK); + case B3SOIPD_MOD_TOX: + value->rValue = model->B3SOIPDtox; + return (OK); + case B3SOIPD_MOD_CDSC: + value->rValue = model->B3SOIPDcdsc; + return (OK); + case B3SOIPD_MOD_CDSCB: + value->rValue = model->B3SOIPDcdscb; + return (OK); + + case B3SOIPD_MOD_CDSCD: + value->rValue = model->B3SOIPDcdscd; + return (OK); + + case B3SOIPD_MOD_CIT: + value->rValue = model->B3SOIPDcit; + return (OK); + case B3SOIPD_MOD_NFACTOR: + value->rValue = model->B3SOIPDnfactor; + return (OK); + case B3SOIPD_MOD_VSAT: + value->rValue = model->B3SOIPDvsat; + return (OK); + case B3SOIPD_MOD_AT: + value->rValue = model->B3SOIPDat; + return (OK); + case B3SOIPD_MOD_A0: + value->rValue = model->B3SOIPDa0; + return (OK); + + case B3SOIPD_MOD_AGS: + value->rValue = model->B3SOIPDags; + return (OK); + + case B3SOIPD_MOD_A1: + value->rValue = model->B3SOIPDa1; + return (OK); + case B3SOIPD_MOD_A2: + value->rValue = model->B3SOIPDa2; + return (OK); + case B3SOIPD_MOD_KETA: + value->rValue = model->B3SOIPDketa; + return (OK); + case B3SOIPD_MOD_NSUB: + value->rValue = model->B3SOIPDnsub; + return (OK); + case B3SOIPD_MOD_NPEAK: + value->rValue = model->B3SOIPDnpeak; + return (OK); + case B3SOIPD_MOD_NGATE: + value->rValue = model->B3SOIPDngate; + return (OK); + case B3SOIPD_MOD_GAMMA1: + value->rValue = model->B3SOIPDgamma1; + return (OK); + case B3SOIPD_MOD_GAMMA2: + value->rValue = model->B3SOIPDgamma2; + return (OK); + case B3SOIPD_MOD_VBX: + value->rValue = model->B3SOIPDvbx; + return (OK); + case B3SOIPD_MOD_VBM: + value->rValue = model->B3SOIPDvbm; + return (OK); + case B3SOIPD_MOD_XT: + value->rValue = model->B3SOIPDxt; + return (OK); + case B3SOIPD_MOD_K1: + value->rValue = model->B3SOIPDk1; + return (OK); + case B3SOIPD_MOD_KT1: + value->rValue = model->B3SOIPDkt1; + return (OK); + case B3SOIPD_MOD_KT1L: + value->rValue = model->B3SOIPDkt1l; + return (OK); + case B3SOIPD_MOD_KT2: + value->rValue = model->B3SOIPDkt2; + return (OK); + case B3SOIPD_MOD_K2: + value->rValue = model->B3SOIPDk2; + return (OK); + case B3SOIPD_MOD_K3: + value->rValue = model->B3SOIPDk3; + return (OK); + case B3SOIPD_MOD_K3B: + value->rValue = model->B3SOIPDk3b; + return (OK); + case B3SOIPD_MOD_W0: + value->rValue = model->B3SOIPDw0; + return (OK); + case B3SOIPD_MOD_NLX: + value->rValue = model->B3SOIPDnlx; + return (OK); + case B3SOIPD_MOD_DVT0: + value->rValue = model->B3SOIPDdvt0; + return (OK); + case B3SOIPD_MOD_DVT1: + value->rValue = model->B3SOIPDdvt1; + return (OK); + case B3SOIPD_MOD_DVT2: + value->rValue = model->B3SOIPDdvt2; + return (OK); + case B3SOIPD_MOD_DVT0W: + value->rValue = model->B3SOIPDdvt0w; + return (OK); + case B3SOIPD_MOD_DVT1W: + value->rValue = model->B3SOIPDdvt1w; + return (OK); + case B3SOIPD_MOD_DVT2W: + value->rValue = model->B3SOIPDdvt2w; + return (OK); + case B3SOIPD_MOD_DROUT: + value->rValue = model->B3SOIPDdrout; + return (OK); + case B3SOIPD_MOD_DSUB: + value->rValue = model->B3SOIPDdsub; + return (OK); + case B3SOIPD_MOD_VTH0: + value->rValue = model->B3SOIPDvth0; + return (OK); + case B3SOIPD_MOD_UA: + value->rValue = model->B3SOIPDua; + return (OK); + case B3SOIPD_MOD_UA1: + value->rValue = model->B3SOIPDua1; + return (OK); + case B3SOIPD_MOD_UB: + value->rValue = model->B3SOIPDub; + return (OK); + case B3SOIPD_MOD_UB1: + value->rValue = model->B3SOIPDub1; + return (OK); + case B3SOIPD_MOD_UC: + value->rValue = model->B3SOIPDuc; + return (OK); + case B3SOIPD_MOD_UC1: + value->rValue = model->B3SOIPDuc1; + return (OK); + case B3SOIPD_MOD_U0: + value->rValue = model->B3SOIPDu0; + return (OK); + case B3SOIPD_MOD_UTE: + value->rValue = model->B3SOIPDute; + return (OK); + case B3SOIPD_MOD_VOFF: + value->rValue = model->B3SOIPDvoff; + return (OK); + case B3SOIPD_MOD_DELTA: + value->rValue = model->B3SOIPDdelta; + return (OK); + case B3SOIPD_MOD_RDSW: + value->rValue = model->B3SOIPDrdsw; + return (OK); + case B3SOIPD_MOD_PRWG: + value->rValue = model->B3SOIPDprwg; + return (OK); + case B3SOIPD_MOD_PRWB: + value->rValue = model->B3SOIPDprwb; + return (OK); + case B3SOIPD_MOD_PRT: + value->rValue = model->B3SOIPDprt; + return (OK); + case B3SOIPD_MOD_ETA0: + value->rValue = model->B3SOIPDeta0; + return (OK); + case B3SOIPD_MOD_ETAB: + value->rValue = model->B3SOIPDetab; + return (OK); + case B3SOIPD_MOD_PCLM: + value->rValue = model->B3SOIPDpclm; + return (OK); + case B3SOIPD_MOD_PDIBL1: + value->rValue = model->B3SOIPDpdibl1; + return (OK); + case B3SOIPD_MOD_PDIBL2: + value->rValue = model->B3SOIPDpdibl2; + return (OK); + case B3SOIPD_MOD_PDIBLB: + value->rValue = model->B3SOIPDpdiblb; + return (OK); + case B3SOIPD_MOD_PVAG: + value->rValue = model->B3SOIPDpvag; + return (OK); + case B3SOIPD_MOD_WR: + value->rValue = model->B3SOIPDwr; + return (OK); + case B3SOIPD_MOD_DWG: + value->rValue = model->B3SOIPDdwg; + return (OK); + case B3SOIPD_MOD_DWB: + value->rValue = model->B3SOIPDdwb; + return (OK); + case B3SOIPD_MOD_B0: + value->rValue = model->B3SOIPDb0; + return (OK); + case B3SOIPD_MOD_B1: + value->rValue = model->B3SOIPDb1; + return (OK); + case B3SOIPD_MOD_ALPHA0: + value->rValue = model->B3SOIPDalpha0; + return (OK); + + case B3SOIPD_MOD_CGSL: + value->rValue = model->B3SOIPDcgsl; + return (OK); + case B3SOIPD_MOD_CGDL: + value->rValue = model->B3SOIPDcgdl; + return (OK); + case B3SOIPD_MOD_CKAPPA: + value->rValue = model->B3SOIPDckappa; + return (OK); + case B3SOIPD_MOD_CF: + value->rValue = model->B3SOIPDcf; + return (OK); + case B3SOIPD_MOD_CLC: + value->rValue = model->B3SOIPDclc; + return (OK); + case B3SOIPD_MOD_CLE: + value->rValue = model->B3SOIPDcle; + return (OK); + case B3SOIPD_MOD_DWC: + value->rValue = model->B3SOIPDdwc; + return (OK); + case B3SOIPD_MOD_DLC: + value->rValue = model->B3SOIPDdlc; + return (OK); + + case B3SOIPD_MOD_TBOX: + value->rValue = model->B3SOIPDtbox; + return (OK); + case B3SOIPD_MOD_TSI: + value->rValue = model->B3SOIPDtsi; + return (OK); + case B3SOIPD_MOD_RTH0: + value->rValue = model->B3SOIPDrth0; + return (OK); + case B3SOIPD_MOD_CTH0: + value->rValue = model->B3SOIPDcth0; + return (OK); + case B3SOIPD_MOD_NDIODE: + value->rValue = model->B3SOIPDndiode; + return (OK); + case B3SOIPD_MOD_XBJT: + value->rValue = model->B3SOIPDxbjt; + return (OK); + + case B3SOIPD_MOD_XDIF: + value->rValue = model->B3SOIPDxdif; + return (OK); + + case B3SOIPD_MOD_XREC: + value->rValue = model->B3SOIPDxrec; + return (OK); + case B3SOIPD_MOD_XTUN: + value->rValue = model->B3SOIPDxtun; + return (OK); + case B3SOIPD_MOD_TT: + value->rValue = model->B3SOIPDtt; + return (OK); + case B3SOIPD_MOD_VSDTH: + value->rValue = model->B3SOIPDvsdth; + return (OK); + case B3SOIPD_MOD_VSDFB: + value->rValue = model->B3SOIPDvsdfb; + return (OK); + case B3SOIPD_MOD_CSDMIN: + value->rValue = model->B3SOIPDcsdmin; + return (OK); + case B3SOIPD_MOD_ASD: + value->rValue = model->B3SOIPDasd; + return (OK); + + case B3SOIPD_MOD_TNOM: + value->rValue = model->B3SOIPDtnom; + return (OK); + case B3SOIPD_MOD_CGSO: + value->rValue = model->B3SOIPDcgso; + return (OK); + case B3SOIPD_MOD_CGDO: + value->rValue = model->B3SOIPDcgdo; + return (OK); + case B3SOIPD_MOD_CGEO: + value->rValue = model->B3SOIPDcgeo; + return (OK); + case B3SOIPD_MOD_XPART: + value->rValue = model->B3SOIPDxpart; + return (OK); + case B3SOIPD_MOD_RSH: + value->rValue = model->B3SOIPDsheetResistance; + return (OK); + case B3SOIPD_MOD_PBSWG: + value->rValue = model->B3SOIPDGatesidewallJctPotential; + return (OK); + case B3SOIPD_MOD_MJSWG: + value->rValue = model->B3SOIPDbodyJctGateSideGradingCoeff; + return (OK); + case B3SOIPD_MOD_CJSWG: + value->rValue = model->B3SOIPDunitLengthGateSidewallJctCap; + return (OK); + case B3SOIPD_MOD_CSDESW: + value->rValue = model->B3SOIPDcsdesw; + return (OK); + case B3SOIPD_MOD_LINT: + value->rValue = model->B3SOIPDLint; + return (OK); + case B3SOIPD_MOD_LL: + value->rValue = model->B3SOIPDLl; + return (OK); + case B3SOIPD_MOD_LLN: + value->rValue = model->B3SOIPDLln; + return (OK); + case B3SOIPD_MOD_LW: + value->rValue = model->B3SOIPDLw; + return (OK); + case B3SOIPD_MOD_LWN: + value->rValue = model->B3SOIPDLwn; + return (OK); + case B3SOIPD_MOD_LWL: + value->rValue = model->B3SOIPDLwl; + return (OK); + case B3SOIPD_MOD_WINT: + value->rValue = model->B3SOIPDWint; + return (OK); + case B3SOIPD_MOD_WL: + value->rValue = model->B3SOIPDWl; + return (OK); + case B3SOIPD_MOD_WLN: + value->rValue = model->B3SOIPDWln; + return (OK); + case B3SOIPD_MOD_WW: + value->rValue = model->B3SOIPDWw; + return (OK); + case B3SOIPD_MOD_WWN: + value->rValue = model->B3SOIPDWwn; + return (OK); + case B3SOIPD_MOD_WWL: + value->rValue = model->B3SOIPDWwl; + return (OK); + case B3SOIPD_MOD_NOIA: + value->rValue = model->B3SOIPDoxideTrapDensityA; + return (OK); + case B3SOIPD_MOD_NOIB: + value->rValue = model->B3SOIPDoxideTrapDensityB; + return (OK); + case B3SOIPD_MOD_NOIC: + value->rValue = model->B3SOIPDoxideTrapDensityC; + return (OK); + case B3SOIPD_MOD_NOIF: + value->rValue = model->B3SOIPDnoif; + return (OK); + case B3SOIPD_MOD_EM: + value->rValue = model->B3SOIPDem; + return (OK); + case B3SOIPD_MOD_EF: + value->rValue = model->B3SOIPDef; + return (OK); + case B3SOIPD_MOD_AF: + value->rValue = model->B3SOIPDaf; + return (OK); + case B3SOIPD_MOD_KF: + value->rValue = model->B3SOIPDkf; + return (OK); + + +/* v2.0 release */ + case B3SOIPD_MOD_K1W1: + value->rValue = model->B3SOIPDk1w1; + return (OK); + case B3SOIPD_MOD_K1W2: + value->rValue = model->B3SOIPDk1w2; + return (OK); + case B3SOIPD_MOD_KETAS: + value->rValue = model->B3SOIPDketas; + return (OK); + case B3SOIPD_MOD_DWBC: + value->rValue = model->B3SOIPDdwbc; + return (OK); + case B3SOIPD_MOD_BETA0: + value->rValue = model->B3SOIPDbeta0; + return (OK); + case B3SOIPD_MOD_BETA1: + value->rValue = model->B3SOIPDbeta1; + return (OK); + case B3SOIPD_MOD_BETA2: + value->rValue = model->B3SOIPDbeta2; + return (OK); + case B3SOIPD_MOD_VDSATII0: + value->rValue = model->B3SOIPDvdsatii0; + return (OK); + case B3SOIPD_MOD_TII: + value->rValue = model->B3SOIPDtii; + return (OK); + case B3SOIPD_MOD_LII: + value->rValue = model->B3SOIPDlii; + return (OK); + case B3SOIPD_MOD_SII0: + value->rValue = model->B3SOIPDsii0; + return (OK); + case B3SOIPD_MOD_SII1: + value->rValue = model->B3SOIPDsii1; + return (OK); + case B3SOIPD_MOD_SII2: + value->rValue = model->B3SOIPDsii2; + return (OK); + case B3SOIPD_MOD_SIID: + value->rValue = model->B3SOIPDsiid; + return (OK); + case B3SOIPD_MOD_FBJTII: + value->rValue = model->B3SOIPDfbjtii; + return (OK); + case B3SOIPD_MOD_ESATII: + value->rValue = model->B3SOIPDesatii; + return (OK); + case B3SOIPD_MOD_NTUN: + value->rValue = model->B3SOIPDntun; + return (OK); + case B3SOIPD_MOD_NRECF0: + value->rValue = model->B3SOIPDnrecf0; + return (OK); + case B3SOIPD_MOD_NRECR0: + value->rValue = model->B3SOIPDnrecr0; + return (OK); + case B3SOIPD_MOD_ISBJT: + value->rValue = model->B3SOIPDisbjt; + return (OK); + case B3SOIPD_MOD_ISDIF: + value->rValue = model->B3SOIPDisdif; + return (OK); + case B3SOIPD_MOD_ISREC: + value->rValue = model->B3SOIPDisrec; + return (OK); + case B3SOIPD_MOD_ISTUN: + value->rValue = model->B3SOIPDistun; + return (OK); + case B3SOIPD_MOD_LN: + value->rValue = model->B3SOIPDln; + return (OK); + case B3SOIPD_MOD_VREC0: + value->rValue = model->B3SOIPDvrec0; + return (OK); + case B3SOIPD_MOD_VTUN0: + value->rValue = model->B3SOIPDvtun0; + return (OK); + case B3SOIPD_MOD_NBJT: + value->rValue = model->B3SOIPDnbjt; + return (OK); + case B3SOIPD_MOD_LBJT0: + value->rValue = model->B3SOIPDlbjt0; + return (OK); + case B3SOIPD_MOD_LDIF0: + value->rValue = model->B3SOIPDldif0; + return (OK); + case B3SOIPD_MOD_VABJT: + value->rValue = model->B3SOIPDvabjt; + return (OK); + case B3SOIPD_MOD_AELY: + value->rValue = model->B3SOIPDaely; + return (OK); + case B3SOIPD_MOD_AHLI: + value->rValue = model->B3SOIPDahli; + return (OK); + case B3SOIPD_MOD_RBODY: + value->rValue = model->B3SOIPDrbody; + return (OK); + case B3SOIPD_MOD_RBSH: + value->rValue = model->B3SOIPDrbsh; + return (OK); + case B3SOIPD_MOD_NTRECF: + value->rValue = model->B3SOIPDntrecf; + return (OK); + case B3SOIPD_MOD_NTRECR: + value->rValue = model->B3SOIPDntrecr; + return (OK); + case B3SOIPD_MOD_NDIF: + value->rValue = model->B3SOIPDndif; + return (OK); + case B3SOIPD_MOD_DLCB: + value->rValue = model->B3SOIPDdlcb; + return (OK); + case B3SOIPD_MOD_FBODY: + value->rValue = model->B3SOIPDfbody; + return (OK); + case B3SOIPD_MOD_TCJSWG: + value->rValue = model->B3SOIPDtcjswg; + return (OK); + case B3SOIPD_MOD_TPBSWG: + value->rValue = model->B3SOIPDtpbswg; + return (OK); + case B3SOIPD_MOD_ACDE: + value->rValue = model->B3SOIPDacde; + return (OK); + case B3SOIPD_MOD_MOIN: + value->rValue = model->B3SOIPDmoin; + return (OK); + case B3SOIPD_MOD_DELVT: + value->rValue = model->B3SOIPDdelvt; + return (OK); + case B3SOIPD_MOD_KB1: + value->rValue = model->B3SOIPDkb1; + return (OK); + case B3SOIPD_MOD_DLBG: + value->rValue = model->B3SOIPDdlbg; + return (OK); + + case B3SOIPD_MOD_NGIDL: + value->rValue = model->B3SOIPDngidl; + return (OK); + case B3SOIPD_MOD_AGIDL: + value->rValue = model->B3SOIPDagidl; + return (OK); + case B3SOIPD_MOD_BGIDL: + value->rValue = model->B3SOIPDbgidl; + return (OK); + + +/* v2.2 release */ + case B3SOIPD_MOD_WTH0: + value->rValue = model->B3SOIPDwth0; + return (OK); + case B3SOIPD_MOD_RHALO: + value->rValue = model->B3SOIPDrhalo; + return (OK); + case B3SOIPD_MOD_NTOX: + value->rValue = model->B3SOIPDntox; + return (OK); + case B3SOIPD_MOD_TOXREF: + value->rValue = model->B3SOIPDtoxref; + return (OK); + case B3SOIPD_MOD_EBG: + value->rValue = model->B3SOIPDebg; + return (OK); + case B3SOIPD_MOD_NEVB: + value->rValue = model->B3SOIPDnevb; + return (OK); + case B3SOIPD_MOD_ALPHAGB1: + value->rValue = model->B3SOIPDalphaGB1; + return (OK); + case B3SOIPD_MOD_BETAGB1: + value->rValue = model->B3SOIPDbetaGB1; + return (OK); + case B3SOIPD_MOD_VGB1: + value->rValue = model->B3SOIPDvgb1; + return (OK); + case B3SOIPD_MOD_NECB: + value->rValue = model->B3SOIPDnecb; + return (OK); + case B3SOIPD_MOD_ALPHAGB2: + value->rValue = model->B3SOIPDalphaGB2; + return (OK); + case B3SOIPD_MOD_BETAGB2: + value->rValue = model->B3SOIPDbetaGB2; + return (OK); + case B3SOIPD_MOD_VGB2: + value->rValue = model->B3SOIPDvgb2; + return (OK); + case B3SOIPD_MOD_TOXQM: + value->rValue = model->B3SOIPDtoxqm; + return (OK); + case B3SOIPD_MOD_VOXH: + value->rValue = model->B3SOIPDvoxh; + return (OK); + case B3SOIPD_MOD_DELTAVOX: + value->rValue = model->B3SOIPDdeltavox; + return (OK); + case B3SOIPD_MOD_IGMOD: + value->iValue = model->B3SOIPDigMod; + return (OK); + + +/* Added for binning - START */ + /* Length Dependence */ + case B3SOIPD_MOD_LNPEAK: + value->rValue = model->B3SOIPDlnpeak; + return (OK); + case B3SOIPD_MOD_LNSUB: + value->rValue = model->B3SOIPDlnsub; + return (OK); + case B3SOIPD_MOD_LNGATE: + value->rValue = model->B3SOIPDlngate; + return (OK); + case B3SOIPD_MOD_LVTH0: + value->rValue = model->B3SOIPDlvth0; + return (OK); + case B3SOIPD_MOD_LK1: + value->rValue = model->B3SOIPDlk1; + return (OK); + case B3SOIPD_MOD_LK1W1: + value->rValue = model->B3SOIPDlk1w1; + return (OK); + case B3SOIPD_MOD_LK1W2: + value->rValue = model->B3SOIPDlk1w2; + return (OK); + case B3SOIPD_MOD_LK2: + value->rValue = model->B3SOIPDlk2; + return (OK); + case B3SOIPD_MOD_LK3: + value->rValue = model->B3SOIPDlk3; + return (OK); + case B3SOIPD_MOD_LK3B: + value->rValue = model->B3SOIPDlk3b; + return (OK); + case B3SOIPD_MOD_LKB1: + value->rValue = model->B3SOIPDlkb1; + return (OK); + case B3SOIPD_MOD_LW0: + value->rValue = model->B3SOIPDlw0; + return (OK); + case B3SOIPD_MOD_LNLX: + value->rValue = model->B3SOIPDlnlx; + return (OK); + case B3SOIPD_MOD_LDVT0: + value->rValue = model->B3SOIPDldvt0; + return (OK); + case B3SOIPD_MOD_LDVT1: + value->rValue = model->B3SOIPDldvt1; + return (OK); + case B3SOIPD_MOD_LDVT2: + value->rValue = model->B3SOIPDldvt2; + return (OK); + case B3SOIPD_MOD_LDVT0W: + value->rValue = model->B3SOIPDldvt0w; + return (OK); + case B3SOIPD_MOD_LDVT1W: + value->rValue = model->B3SOIPDldvt1w; + return (OK); + case B3SOIPD_MOD_LDVT2W: + value->rValue = model->B3SOIPDldvt2w; + return (OK); + case B3SOIPD_MOD_LU0: + value->rValue = model->B3SOIPDlu0; + return (OK); + case B3SOIPD_MOD_LUA: + value->rValue = model->B3SOIPDlua; + return (OK); + case B3SOIPD_MOD_LUB: + value->rValue = model->B3SOIPDlub; + return (OK); + case B3SOIPD_MOD_LUC: + value->rValue = model->B3SOIPDluc; + return (OK); + case B3SOIPD_MOD_LVSAT: + value->rValue = model->B3SOIPDlvsat; + return (OK); + case B3SOIPD_MOD_LA0: + value->rValue = model->B3SOIPDla0; + return (OK); + case B3SOIPD_MOD_LAGS: + value->rValue = model->B3SOIPDlags; + return (OK); + case B3SOIPD_MOD_LB0: + value->rValue = model->B3SOIPDlb0; + return (OK); + case B3SOIPD_MOD_LB1: + value->rValue = model->B3SOIPDlb1; + return (OK); + case B3SOIPD_MOD_LKETA: + value->rValue = model->B3SOIPDlketa; + return (OK); + case B3SOIPD_MOD_LKETAS: + value->rValue = model->B3SOIPDlketas; + return (OK); + case B3SOIPD_MOD_LA1: + value->rValue = model->B3SOIPDla1; + return (OK); + case B3SOIPD_MOD_LA2: + value->rValue = model->B3SOIPDla2; + return (OK); + case B3SOIPD_MOD_LRDSW: + value->rValue = model->B3SOIPDlrdsw; + return (OK); + case B3SOIPD_MOD_LPRWB: + value->rValue = model->B3SOIPDlprwb; + return (OK); + case B3SOIPD_MOD_LPRWG: + value->rValue = model->B3SOIPDlprwg; + return (OK); + case B3SOIPD_MOD_LWR: + value->rValue = model->B3SOIPDlwr; + return (OK); + case B3SOIPD_MOD_LNFACTOR: + value->rValue = model->B3SOIPDlnfactor; + return (OK); + case B3SOIPD_MOD_LDWG: + value->rValue = model->B3SOIPDldwg; + return (OK); + case B3SOIPD_MOD_LDWB: + value->rValue = model->B3SOIPDldwb; + return (OK); + case B3SOIPD_MOD_LVOFF: + value->rValue = model->B3SOIPDlvoff; + return (OK); + case B3SOIPD_MOD_LETA0: + value->rValue = model->B3SOIPDleta0; + return (OK); + case B3SOIPD_MOD_LETAB: + value->rValue = model->B3SOIPDletab; + return (OK); + case B3SOIPD_MOD_LDSUB: + value->rValue = model->B3SOIPDldsub; + return (OK); + case B3SOIPD_MOD_LCIT: + value->rValue = model->B3SOIPDlcit; + return (OK); + case B3SOIPD_MOD_LCDSC: + value->rValue = model->B3SOIPDlcdsc; + return (OK); + case B3SOIPD_MOD_LCDSCB: + value->rValue = model->B3SOIPDlcdscb; + return (OK); + case B3SOIPD_MOD_LCDSCD: + value->rValue = model->B3SOIPDlcdscd; + return (OK); + case B3SOIPD_MOD_LPCLM: + value->rValue = model->B3SOIPDlpclm; + return (OK); + case B3SOIPD_MOD_LPDIBL1: + value->rValue = model->B3SOIPDlpdibl1; + return (OK); + case B3SOIPD_MOD_LPDIBL2: + value->rValue = model->B3SOIPDlpdibl2; + return (OK); + case B3SOIPD_MOD_LPDIBLB: + value->rValue = model->B3SOIPDlpdiblb; + return (OK); + case B3SOIPD_MOD_LDROUT: + value->rValue = model->B3SOIPDldrout; + return (OK); + case B3SOIPD_MOD_LPVAG: + value->rValue = model->B3SOIPDlpvag; + return (OK); + case B3SOIPD_MOD_LDELTA: + value->rValue = model->B3SOIPDldelta; + return (OK); + case B3SOIPD_MOD_LALPHA0: + value->rValue = model->B3SOIPDlalpha0; + return (OK); + case B3SOIPD_MOD_LFBJTII: + value->rValue = model->B3SOIPDlfbjtii; + return (OK); + case B3SOIPD_MOD_LBETA0: + value->rValue = model->B3SOIPDlbeta0; + return (OK); + case B3SOIPD_MOD_LBETA1: + value->rValue = model->B3SOIPDlbeta1; + return (OK); + case B3SOIPD_MOD_LBETA2: + value->rValue = model->B3SOIPDlbeta2; + return (OK); + case B3SOIPD_MOD_LVDSATII0: + value->rValue = model->B3SOIPDlvdsatii0; + return (OK); + case B3SOIPD_MOD_LLII: + value->rValue = model->B3SOIPDllii; + return (OK); + case B3SOIPD_MOD_LESATII: + value->rValue = model->B3SOIPDlesatii; + return (OK); + case B3SOIPD_MOD_LSII0: + value->rValue = model->B3SOIPDlsii0; + return (OK); + case B3SOIPD_MOD_LSII1: + value->rValue = model->B3SOIPDlsii1; + return (OK); + case B3SOIPD_MOD_LSII2: + value->rValue = model->B3SOIPDlsii2; + return (OK); + case B3SOIPD_MOD_LSIID: + value->rValue = model->B3SOIPDlsiid; + return (OK); + case B3SOIPD_MOD_LAGIDL: + value->rValue = model->B3SOIPDlagidl; + return (OK); + case B3SOIPD_MOD_LBGIDL: + value->rValue = model->B3SOIPDlbgidl; + return (OK); + case B3SOIPD_MOD_LNGIDL: + value->rValue = model->B3SOIPDlngidl; + return (OK); + case B3SOIPD_MOD_LNTUN: + value->rValue = model->B3SOIPDlntun; + return (OK); + case B3SOIPD_MOD_LNDIODE: + value->rValue = model->B3SOIPDlndiode; + return (OK); + case B3SOIPD_MOD_LNRECF0: + value->rValue = model->B3SOIPDlnrecf0; + return (OK); + case B3SOIPD_MOD_LNRECR0: + value->rValue = model->B3SOIPDlnrecr0; + return (OK); + case B3SOIPD_MOD_LISBJT: + value->rValue = model->B3SOIPDlisbjt; + return (OK); + case B3SOIPD_MOD_LISDIF: + value->rValue = model->B3SOIPDlisdif; + return (OK); + case B3SOIPD_MOD_LISREC: + value->rValue = model->B3SOIPDlisrec; + return (OK); + case B3SOIPD_MOD_LISTUN: + value->rValue = model->B3SOIPDlistun; + return (OK); + case B3SOIPD_MOD_LVREC0: + value->rValue = model->B3SOIPDlvrec0; + return (OK); + case B3SOIPD_MOD_LVTUN0: + value->rValue = model->B3SOIPDlvtun0; + return (OK); + case B3SOIPD_MOD_LNBJT: + value->rValue = model->B3SOIPDlnbjt; + return (OK); + case B3SOIPD_MOD_LLBJT0: + value->rValue = model->B3SOIPDllbjt0; + return (OK); + case B3SOIPD_MOD_LVABJT: + value->rValue = model->B3SOIPDlvabjt; + return (OK); + case B3SOIPD_MOD_LAELY: + value->rValue = model->B3SOIPDlaely; + return (OK); + case B3SOIPD_MOD_LAHLI: + value->rValue = model->B3SOIPDlahli; + return (OK); + /* CV Model */ + case B3SOIPD_MOD_LVSDFB: + value->rValue = model->B3SOIPDlvsdfb; + return (OK); + case B3SOIPD_MOD_LVSDTH: + value->rValue = model->B3SOIPDlvsdth; + return (OK); + case B3SOIPD_MOD_LDELVT: + value->rValue = model->B3SOIPDldelvt; + return (OK); + case B3SOIPD_MOD_LACDE: + value->rValue = model->B3SOIPDlacde; + return (OK); + case B3SOIPD_MOD_LMOIN: + value->rValue = model->B3SOIPDlmoin; + return (OK); + + /* Width Dependence */ + case B3SOIPD_MOD_WNPEAK: + value->rValue = model->B3SOIPDwnpeak; + return (OK); + case B3SOIPD_MOD_WNSUB: + value->rValue = model->B3SOIPDwnsub; + return (OK); + case B3SOIPD_MOD_WNGATE: + value->rValue = model->B3SOIPDwngate; + return (OK); + case B3SOIPD_MOD_WVTH0: + value->rValue = model->B3SOIPDwvth0; + return (OK); + case B3SOIPD_MOD_WK1: + value->rValue = model->B3SOIPDwk1; + return (OK); + case B3SOIPD_MOD_WK1W1: + value->rValue = model->B3SOIPDwk1w1; + return (OK); + case B3SOIPD_MOD_WK1W2: + value->rValue = model->B3SOIPDwk1w2; + return (OK); + case B3SOIPD_MOD_WK2: + value->rValue = model->B3SOIPDwk2; + return (OK); + case B3SOIPD_MOD_WK3: + value->rValue = model->B3SOIPDwk3; + return (OK); + case B3SOIPD_MOD_WK3B: + value->rValue = model->B3SOIPDwk3b; + return (OK); + case B3SOIPD_MOD_WKB1: + value->rValue = model->B3SOIPDwkb1; + return (OK); + case B3SOIPD_MOD_WW0: + value->rValue = model->B3SOIPDww0; + return (OK); + case B3SOIPD_MOD_WNLX: + value->rValue = model->B3SOIPDwnlx; + return (OK); + case B3SOIPD_MOD_WDVT0: + value->rValue = model->B3SOIPDwdvt0; + return (OK); + case B3SOIPD_MOD_WDVT1: + value->rValue = model->B3SOIPDwdvt1; + return (OK); + case B3SOIPD_MOD_WDVT2: + value->rValue = model->B3SOIPDwdvt2; + return (OK); + case B3SOIPD_MOD_WDVT0W: + value->rValue = model->B3SOIPDwdvt0w; + return (OK); + case B3SOIPD_MOD_WDVT1W: + value->rValue = model->B3SOIPDwdvt1w; + return (OK); + case B3SOIPD_MOD_WDVT2W: + value->rValue = model->B3SOIPDwdvt2w; + return (OK); + case B3SOIPD_MOD_WU0: + value->rValue = model->B3SOIPDwu0; + return (OK); + case B3SOIPD_MOD_WUA: + value->rValue = model->B3SOIPDwua; + return (OK); + case B3SOIPD_MOD_WUB: + value->rValue = model->B3SOIPDwub; + return (OK); + case B3SOIPD_MOD_WUC: + value->rValue = model->B3SOIPDwuc; + return (OK); + case B3SOIPD_MOD_WVSAT: + value->rValue = model->B3SOIPDwvsat; + return (OK); + case B3SOIPD_MOD_WA0: + value->rValue = model->B3SOIPDwa0; + return (OK); + case B3SOIPD_MOD_WAGS: + value->rValue = model->B3SOIPDwags; + return (OK); + case B3SOIPD_MOD_WB0: + value->rValue = model->B3SOIPDwb0; + return (OK); + case B3SOIPD_MOD_WB1: + value->rValue = model->B3SOIPDwb1; + return (OK); + case B3SOIPD_MOD_WKETA: + value->rValue = model->B3SOIPDwketa; + return (OK); + case B3SOIPD_MOD_WKETAS: + value->rValue = model->B3SOIPDwketas; + return (OK); + case B3SOIPD_MOD_WA1: + value->rValue = model->B3SOIPDwa1; + return (OK); + case B3SOIPD_MOD_WA2: + value->rValue = model->B3SOIPDwa2; + return (OK); + case B3SOIPD_MOD_WRDSW: + value->rValue = model->B3SOIPDwrdsw; + return (OK); + case B3SOIPD_MOD_WPRWB: + value->rValue = model->B3SOIPDwprwb; + return (OK); + case B3SOIPD_MOD_WPRWG: + value->rValue = model->B3SOIPDwprwg; + return (OK); + case B3SOIPD_MOD_WWR: + value->rValue = model->B3SOIPDwwr; + return (OK); + case B3SOIPD_MOD_WNFACTOR: + value->rValue = model->B3SOIPDwnfactor; + return (OK); + case B3SOIPD_MOD_WDWG: + value->rValue = model->B3SOIPDwdwg; + return (OK); + case B3SOIPD_MOD_WDWB: + value->rValue = model->B3SOIPDwdwb; + return (OK); + case B3SOIPD_MOD_WVOFF: + value->rValue = model->B3SOIPDwvoff; + return (OK); + case B3SOIPD_MOD_WETA0: + value->rValue = model->B3SOIPDweta0; + return (OK); + case B3SOIPD_MOD_WETAB: + value->rValue = model->B3SOIPDwetab; + return (OK); + case B3SOIPD_MOD_WDSUB: + value->rValue = model->B3SOIPDwdsub; + return (OK); + case B3SOIPD_MOD_WCIT: + value->rValue = model->B3SOIPDwcit; + return (OK); + case B3SOIPD_MOD_WCDSC: + value->rValue = model->B3SOIPDwcdsc; + return (OK); + case B3SOIPD_MOD_WCDSCB: + value->rValue = model->B3SOIPDwcdscb; + return (OK); + case B3SOIPD_MOD_WCDSCD: + value->rValue = model->B3SOIPDwcdscd; + return (OK); + case B3SOIPD_MOD_WPCLM: + value->rValue = model->B3SOIPDwpclm; + return (OK); + case B3SOIPD_MOD_WPDIBL1: + value->rValue = model->B3SOIPDwpdibl1; + return (OK); + case B3SOIPD_MOD_WPDIBL2: + value->rValue = model->B3SOIPDwpdibl2; + return (OK); + case B3SOIPD_MOD_WPDIBLB: + value->rValue = model->B3SOIPDwpdiblb; + return (OK); + case B3SOIPD_MOD_WDROUT: + value->rValue = model->B3SOIPDwdrout; + return (OK); + case B3SOIPD_MOD_WPVAG: + value->rValue = model->B3SOIPDwpvag; + return (OK); + case B3SOIPD_MOD_WDELTA: + value->rValue = model->B3SOIPDwdelta; + return (OK); + case B3SOIPD_MOD_WALPHA0: + value->rValue = model->B3SOIPDwalpha0; + return (OK); + case B3SOIPD_MOD_WFBJTII: + value->rValue = model->B3SOIPDwfbjtii; + return (OK); + case B3SOIPD_MOD_WBETA0: + value->rValue = model->B3SOIPDwbeta0; + return (OK); + case B3SOIPD_MOD_WBETA1: + value->rValue = model->B3SOIPDwbeta1; + return (OK); + case B3SOIPD_MOD_WBETA2: + value->rValue = model->B3SOIPDwbeta2; + return (OK); + case B3SOIPD_MOD_WVDSATII0: + value->rValue = model->B3SOIPDwvdsatii0; + return (OK); + case B3SOIPD_MOD_WLII: + value->rValue = model->B3SOIPDwlii; + return (OK); + case B3SOIPD_MOD_WESATII: + value->rValue = model->B3SOIPDwesatii; + return (OK); + case B3SOIPD_MOD_WSII0: + value->rValue = model->B3SOIPDwsii0; + return (OK); + case B3SOIPD_MOD_WSII1: + value->rValue = model->B3SOIPDwsii1; + return (OK); + case B3SOIPD_MOD_WSII2: + value->rValue = model->B3SOIPDwsii2; + return (OK); + case B3SOIPD_MOD_WSIID: + value->rValue = model->B3SOIPDwsiid; + return (OK); + case B3SOIPD_MOD_WAGIDL: + value->rValue = model->B3SOIPDwagidl; + return (OK); + case B3SOIPD_MOD_WBGIDL: + value->rValue = model->B3SOIPDwbgidl; + return (OK); + case B3SOIPD_MOD_WNGIDL: + value->rValue = model->B3SOIPDwngidl; + return (OK); + case B3SOIPD_MOD_WNTUN: + value->rValue = model->B3SOIPDwntun; + return (OK); + case B3SOIPD_MOD_WNDIODE: + value->rValue = model->B3SOIPDwndiode; + return (OK); + case B3SOIPD_MOD_WNRECF0: + value->rValue = model->B3SOIPDwnrecf0; + return (OK); + case B3SOIPD_MOD_WNRECR0: + value->rValue = model->B3SOIPDwnrecr0; + return (OK); + case B3SOIPD_MOD_WISBJT: + value->rValue = model->B3SOIPDwisbjt; + return (OK); + case B3SOIPD_MOD_WISDIF: + value->rValue = model->B3SOIPDwisdif; + return (OK); + case B3SOIPD_MOD_WISREC: + value->rValue = model->B3SOIPDwisrec; + return (OK); + case B3SOIPD_MOD_WISTUN: + value->rValue = model->B3SOIPDwistun; + return (OK); + case B3SOIPD_MOD_WVREC0: + value->rValue = model->B3SOIPDwvrec0; + return (OK); + case B3SOIPD_MOD_WVTUN0: + value->rValue = model->B3SOIPDwvtun0; + return (OK); + case B3SOIPD_MOD_WNBJT: + value->rValue = model->B3SOIPDwnbjt; + return (OK); + case B3SOIPD_MOD_WLBJT0: + value->rValue = model->B3SOIPDwlbjt0; + return (OK); + case B3SOIPD_MOD_WVABJT: + value->rValue = model->B3SOIPDwvabjt; + return (OK); + case B3SOIPD_MOD_WAELY: + value->rValue = model->B3SOIPDwaely; + return (OK); + case B3SOIPD_MOD_WAHLI: + value->rValue = model->B3SOIPDwahli; + return (OK); + /* CV Model */ + case B3SOIPD_MOD_WVSDFB: + value->rValue = model->B3SOIPDwvsdfb; + return (OK); + case B3SOIPD_MOD_WVSDTH: + value->rValue = model->B3SOIPDwvsdth; + return (OK); + case B3SOIPD_MOD_WDELVT: + value->rValue = model->B3SOIPDwdelvt; + return (OK); + case B3SOIPD_MOD_WACDE: + value->rValue = model->B3SOIPDwacde; + return (OK); + case B3SOIPD_MOD_WMOIN: + value->rValue = model->B3SOIPDwmoin; + return (OK); + + /* Cross-term Dependence */ + case B3SOIPD_MOD_PNPEAK: + value->rValue = model->B3SOIPDpnpeak; + return (OK); + case B3SOIPD_MOD_PNSUB: + value->rValue = model->B3SOIPDpnsub; + return (OK); + case B3SOIPD_MOD_PNGATE: + value->rValue = model->B3SOIPDpngate; + return (OK); + case B3SOIPD_MOD_PVTH0: + value->rValue = model->B3SOIPDpvth0; + return (OK); + case B3SOIPD_MOD_PK1: + value->rValue = model->B3SOIPDpk1; + return (OK); + case B3SOIPD_MOD_PK1W1: + value->rValue = model->B3SOIPDpk1w1; + return (OK); + case B3SOIPD_MOD_PK1W2: + value->rValue = model->B3SOIPDpk1w2; + return (OK); + case B3SOIPD_MOD_PK2: + value->rValue = model->B3SOIPDpk2; + return (OK); + case B3SOIPD_MOD_PK3: + value->rValue = model->B3SOIPDpk3; + return (OK); + case B3SOIPD_MOD_PK3B: + value->rValue = model->B3SOIPDpk3b; + return (OK); + case B3SOIPD_MOD_PKB1: + value->rValue = model->B3SOIPDpkb1; + return (OK); + case B3SOIPD_MOD_PW0: + value->rValue = model->B3SOIPDpw0; + return (OK); + case B3SOIPD_MOD_PNLX: + value->rValue = model->B3SOIPDpnlx; + return (OK); + case B3SOIPD_MOD_PDVT0: + value->rValue = model->B3SOIPDpdvt0; + return (OK); + case B3SOIPD_MOD_PDVT1: + value->rValue = model->B3SOIPDpdvt1; + return (OK); + case B3SOIPD_MOD_PDVT2: + value->rValue = model->B3SOIPDpdvt2; + return (OK); + case B3SOIPD_MOD_PDVT0W: + value->rValue = model->B3SOIPDpdvt0w; + return (OK); + case B3SOIPD_MOD_PDVT1W: + value->rValue = model->B3SOIPDpdvt1w; + return (OK); + case B3SOIPD_MOD_PDVT2W: + value->rValue = model->B3SOIPDpdvt2w; + return (OK); + case B3SOIPD_MOD_PU0: + value->rValue = model->B3SOIPDpu0; + return (OK); + case B3SOIPD_MOD_PUA: + value->rValue = model->B3SOIPDpua; + return (OK); + case B3SOIPD_MOD_PUB: + value->rValue = model->B3SOIPDpub; + return (OK); + case B3SOIPD_MOD_PUC: + value->rValue = model->B3SOIPDpuc; + return (OK); + case B3SOIPD_MOD_PVSAT: + value->rValue = model->B3SOIPDpvsat; + return (OK); + case B3SOIPD_MOD_PA0: + value->rValue = model->B3SOIPDpa0; + return (OK); + case B3SOIPD_MOD_PAGS: + value->rValue = model->B3SOIPDpags; + return (OK); + case B3SOIPD_MOD_PB0: + value->rValue = model->B3SOIPDpb0; + return (OK); + case B3SOIPD_MOD_PB1: + value->rValue = model->B3SOIPDpb1; + return (OK); + case B3SOIPD_MOD_PKETA: + value->rValue = model->B3SOIPDpketa; + return (OK); + case B3SOIPD_MOD_PKETAS: + value->rValue = model->B3SOIPDpketas; + return (OK); + case B3SOIPD_MOD_PA1: + value->rValue = model->B3SOIPDpa1; + return (OK); + case B3SOIPD_MOD_PA2: + value->rValue = model->B3SOIPDpa2; + return (OK); + case B3SOIPD_MOD_PRDSW: + value->rValue = model->B3SOIPDprdsw; + return (OK); + case B3SOIPD_MOD_PPRWB: + value->rValue = model->B3SOIPDpprwb; + return (OK); + case B3SOIPD_MOD_PPRWG: + value->rValue = model->B3SOIPDpprwg; + return (OK); + case B3SOIPD_MOD_PWR: + value->rValue = model->B3SOIPDpwr; + return (OK); + case B3SOIPD_MOD_PNFACTOR: + value->rValue = model->B3SOIPDpnfactor; + return (OK); + case B3SOIPD_MOD_PDWG: + value->rValue = model->B3SOIPDpdwg; + return (OK); + case B3SOIPD_MOD_PDWB: + value->rValue = model->B3SOIPDpdwb; + return (OK); + case B3SOIPD_MOD_PVOFF: + value->rValue = model->B3SOIPDpvoff; + return (OK); + case B3SOIPD_MOD_PETA0: + value->rValue = model->B3SOIPDpeta0; + return (OK); + case B3SOIPD_MOD_PETAB: + value->rValue = model->B3SOIPDpetab; + return (OK); + case B3SOIPD_MOD_PDSUB: + value->rValue = model->B3SOIPDpdsub; + return (OK); + case B3SOIPD_MOD_PCIT: + value->rValue = model->B3SOIPDpcit; + return (OK); + case B3SOIPD_MOD_PCDSC: + value->rValue = model->B3SOIPDpcdsc; + return (OK); + case B3SOIPD_MOD_PCDSCB: + value->rValue = model->B3SOIPDpcdscb; + return (OK); + case B3SOIPD_MOD_PCDSCD: + value->rValue = model->B3SOIPDpcdscd; + return (OK); + case B3SOIPD_MOD_PPCLM: + value->rValue = model->B3SOIPDppclm; + return (OK); + case B3SOIPD_MOD_PPDIBL1: + value->rValue = model->B3SOIPDppdibl1; + return (OK); + case B3SOIPD_MOD_PPDIBL2: + value->rValue = model->B3SOIPDppdibl2; + return (OK); + case B3SOIPD_MOD_PPDIBLB: + value->rValue = model->B3SOIPDppdiblb; + return (OK); + case B3SOIPD_MOD_PDROUT: + value->rValue = model->B3SOIPDpdrout; + return (OK); + case B3SOIPD_MOD_PPVAG: + value->rValue = model->B3SOIPDppvag; + return (OK); + case B3SOIPD_MOD_PDELTA: + value->rValue = model->B3SOIPDpdelta; + return (OK); + case B3SOIPD_MOD_PALPHA0: + value->rValue = model->B3SOIPDpalpha0; + return (OK); + case B3SOIPD_MOD_PFBJTII: + value->rValue = model->B3SOIPDpfbjtii; + return (OK); + case B3SOIPD_MOD_PBETA0: + value->rValue = model->B3SOIPDpbeta0; + return (OK); + case B3SOIPD_MOD_PBETA1: + value->rValue = model->B3SOIPDpbeta1; + return (OK); + case B3SOIPD_MOD_PBETA2: + value->rValue = model->B3SOIPDpbeta2; + return (OK); + case B3SOIPD_MOD_PVDSATII0: + value->rValue = model->B3SOIPDpvdsatii0; + return (OK); + case B3SOIPD_MOD_PLII: + value->rValue = model->B3SOIPDplii; + return (OK); + case B3SOIPD_MOD_PESATII: + value->rValue = model->B3SOIPDpesatii; + return (OK); + case B3SOIPD_MOD_PSII0: + value->rValue = model->B3SOIPDpsii0; + return (OK); + case B3SOIPD_MOD_PSII1: + value->rValue = model->B3SOIPDpsii1; + return (OK); + case B3SOIPD_MOD_PSII2: + value->rValue = model->B3SOIPDpsii2; + return (OK); + case B3SOIPD_MOD_PSIID: + value->rValue = model->B3SOIPDpsiid; + return (OK); + case B3SOIPD_MOD_PAGIDL: + value->rValue = model->B3SOIPDpagidl; + return (OK); + case B3SOIPD_MOD_PBGIDL: + value->rValue = model->B3SOIPDpbgidl; + return (OK); + case B3SOIPD_MOD_PNGIDL: + value->rValue = model->B3SOIPDpngidl; + return (OK); + case B3SOIPD_MOD_PNTUN: + value->rValue = model->B3SOIPDpntun; + return (OK); + case B3SOIPD_MOD_PNDIODE: + value->rValue = model->B3SOIPDpndiode; + return (OK); + case B3SOIPD_MOD_PNRECF0: + value->rValue = model->B3SOIPDpnrecf0; + return (OK); + case B3SOIPD_MOD_PNRECR0: + value->rValue = model->B3SOIPDpnrecr0; + return (OK); + case B3SOIPD_MOD_PISBJT: + value->rValue = model->B3SOIPDpisbjt; + return (OK); + case B3SOIPD_MOD_PISDIF: + value->rValue = model->B3SOIPDpisdif; + return (OK); + case B3SOIPD_MOD_PISREC: + value->rValue = model->B3SOIPDpisrec; + return (OK); + case B3SOIPD_MOD_PISTUN: + value->rValue = model->B3SOIPDpistun; + return (OK); + case B3SOIPD_MOD_PVREC0: + value->rValue = model->B3SOIPDpvrec0; + return (OK); + case B3SOIPD_MOD_PVTUN0: + value->rValue = model->B3SOIPDpvtun0; + return (OK); + case B3SOIPD_MOD_PNBJT: + value->rValue = model->B3SOIPDpnbjt; + return (OK); + case B3SOIPD_MOD_PLBJT0: + value->rValue = model->B3SOIPDplbjt0; + return (OK); + case B3SOIPD_MOD_PVABJT: + value->rValue = model->B3SOIPDpvabjt; + return (OK); + case B3SOIPD_MOD_PAELY: + value->rValue = model->B3SOIPDpaely; + return (OK); + case B3SOIPD_MOD_PAHLI: + value->rValue = model->B3SOIPDpahli; + return (OK); + /* CV Model */ + case B3SOIPD_MOD_PVSDFB: + value->rValue = model->B3SOIPDpvsdfb; + return (OK); + case B3SOIPD_MOD_PVSDTH: + value->rValue = model->B3SOIPDpvsdth; + return (OK); + case B3SOIPD_MOD_PDELVT: + value->rValue = model->B3SOIPDpdelvt; + return (OK); + case B3SOIPD_MOD_PACDE: + value->rValue = model->B3SOIPDpacde; + return (OK); + case B3SOIPD_MOD_PMOIN: + value->rValue = model->B3SOIPDpmoin; + return (OK); +/* Added for binning - END */ + + default: + return (E_BADPARM); + } + /* NOTREACHED */ +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdmdel.c b/src/spicelib/devices/bsim3soi_pd/b3soipdmdel.c new file mode 100644 index 000000000..8e4b62c43 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdmdel.c @@ -0,0 +1,49 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdmdel.c 98/5/01 +**********/ + + +#include "ngspice.h" +#include +#include "b3soipddef.h" +#include "sperror.h" +#include "suffix.h" + +int +B3SOIPDmDelete (inModel, modname, kill) + GENmodel **inModel; + IFuid modname; + GENmodel *kill; +{ + B3SOIPDmodel **model = (B3SOIPDmodel **) inModel; + B3SOIPDmodel *modfast = (B3SOIPDmodel *) kill; + B3SOIPDinstance *here; + B3SOIPDinstance *prev = NULL; + B3SOIPDmodel **oldmod; + + oldmod = model; + for (; *model; model = &((*model)->B3SOIPDnextModel)) + { + if ((*model)->B3SOIPDmodName == modname || + (modfast && *model == modfast)) + goto delgot; + oldmod = model; + } + return (E_NOMOD); + +delgot: + *oldmod = (*model)->B3SOIPDnextModel; /* cut deleted device out of list */ + for (here = (*model)->B3SOIPDinstances; here; + here = here->B3SOIPDnextInstance) + { + if (prev) + FREE (prev); + prev = here; + } + if (prev) + FREE (prev); + FREE (*model); + return (OK); +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdmpar.c b/src/spicelib/devices/bsim3soi_pd/b3soipdmpar.c new file mode 100644 index 000000000..6913d7665 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdmpar.c @@ -0,0 +1,1917 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdmpar.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 +**********/ + + +#include "ngspice.h" +#include +#include "b3soipddef.h" +#include "ifsim.h" +#include "sperror.h" +#include "suffix.h" + + +int +B3SOIPDmParam (param, value, inMod) + int param; + IFvalue *value; + GENmodel *inMod; +{ + B3SOIPDmodel *mod = (B3SOIPDmodel *) inMod; + switch (param) + { + + case B3SOIPD_MOD_MOBMOD: + mod->B3SOIPDmobMod = value->iValue; + mod->B3SOIPDmobModGiven = TRUE; + break; + case B3SOIPD_MOD_BINUNIT: + mod->B3SOIPDbinUnit = value->iValue; + mod->B3SOIPDbinUnitGiven = TRUE; + break; + case B3SOIPD_MOD_PARAMCHK: + mod->B3SOIPDparamChk = value->iValue; + mod->B3SOIPDparamChkGiven = TRUE; + break; + case B3SOIPD_MOD_CAPMOD: + mod->B3SOIPDcapMod = value->iValue; + mod->B3SOIPDcapModGiven = TRUE; + break; + case B3SOIPD_MOD_SHMOD: + mod->B3SOIPDshMod = value->iValue; + mod->B3SOIPDshModGiven = TRUE; + break; + case B3SOIPD_MOD_NOIMOD: + mod->B3SOIPDnoiMod = value->iValue; + mod->B3SOIPDnoiModGiven = TRUE; + break; + case B3SOIPD_MOD_VERSION: + mod->B3SOIPDversion = value->rValue; + mod->B3SOIPDversionGiven = TRUE; + break; + case B3SOIPD_MOD_TOX: + mod->B3SOIPDtox = value->rValue; + mod->B3SOIPDtoxGiven = TRUE; + break; + + case B3SOIPD_MOD_CDSC: + mod->B3SOIPDcdsc = value->rValue; + mod->B3SOIPDcdscGiven = TRUE; + break; + case B3SOIPD_MOD_CDSCB: + mod->B3SOIPDcdscb = value->rValue; + mod->B3SOIPDcdscbGiven = TRUE; + break; + + case B3SOIPD_MOD_CDSCD: + mod->B3SOIPDcdscd = value->rValue; + mod->B3SOIPDcdscdGiven = TRUE; + break; + + case B3SOIPD_MOD_CIT: + mod->B3SOIPDcit = value->rValue; + mod->B3SOIPDcitGiven = TRUE; + break; + case B3SOIPD_MOD_NFACTOR: + mod->B3SOIPDnfactor = value->rValue; + mod->B3SOIPDnfactorGiven = TRUE; + break; + case B3SOIPD_MOD_VSAT: + mod->B3SOIPDvsat = value->rValue; + mod->B3SOIPDvsatGiven = TRUE; + break; + case B3SOIPD_MOD_A0: + mod->B3SOIPDa0 = value->rValue; + mod->B3SOIPDa0Given = TRUE; + break; + + case B3SOIPD_MOD_AGS: + mod->B3SOIPDags = value->rValue; + mod->B3SOIPDagsGiven = TRUE; + break; + + case B3SOIPD_MOD_A1: + mod->B3SOIPDa1 = value->rValue; + mod->B3SOIPDa1Given = TRUE; + break; + case B3SOIPD_MOD_A2: + mod->B3SOIPDa2 = value->rValue; + mod->B3SOIPDa2Given = TRUE; + break; + case B3SOIPD_MOD_AT: + mod->B3SOIPDat = value->rValue; + mod->B3SOIPDatGiven = TRUE; + break; + case B3SOIPD_MOD_KETA: + mod->B3SOIPDketa = value->rValue; + mod->B3SOIPDketaGiven = TRUE; + break; + case B3SOIPD_MOD_NSUB: + mod->B3SOIPDnsub = value->rValue; + mod->B3SOIPDnsubGiven = TRUE; + break; + case B3SOIPD_MOD_NPEAK: + mod->B3SOIPDnpeak = value->rValue; + mod->B3SOIPDnpeakGiven = TRUE; + if (mod->B3SOIPDnpeak > 1.0e20) + mod->B3SOIPDnpeak *= 1.0e-6; + break; + case B3SOIPD_MOD_NGATE: + mod->B3SOIPDngate = value->rValue; + mod->B3SOIPDngateGiven = TRUE; + if (mod->B3SOIPDngate > 1.0e23) + mod->B3SOIPDngate *= 1.0e-6; + break; + case B3SOIPD_MOD_GAMMA1: + mod->B3SOIPDgamma1 = value->rValue; + mod->B3SOIPDgamma1Given = TRUE; + break; + case B3SOIPD_MOD_GAMMA2: + mod->B3SOIPDgamma2 = value->rValue; + mod->B3SOIPDgamma2Given = TRUE; + break; + case B3SOIPD_MOD_VBX: + mod->B3SOIPDvbx = value->rValue; + mod->B3SOIPDvbxGiven = TRUE; + break; + case B3SOIPD_MOD_VBM: + mod->B3SOIPDvbm = value->rValue; + mod->B3SOIPDvbmGiven = TRUE; + break; + case B3SOIPD_MOD_XT: + mod->B3SOIPDxt = value->rValue; + mod->B3SOIPDxtGiven = TRUE; + break; + case B3SOIPD_MOD_K1: + mod->B3SOIPDk1 = value->rValue; + mod->B3SOIPDk1Given = TRUE; + break; + case B3SOIPD_MOD_KT1: + mod->B3SOIPDkt1 = value->rValue; + mod->B3SOIPDkt1Given = TRUE; + break; + case B3SOIPD_MOD_KT1L: + mod->B3SOIPDkt1l = value->rValue; + mod->B3SOIPDkt1lGiven = TRUE; + break; + case B3SOIPD_MOD_KT2: + mod->B3SOIPDkt2 = value->rValue; + mod->B3SOIPDkt2Given = TRUE; + break; + case B3SOIPD_MOD_K2: + mod->B3SOIPDk2 = value->rValue; + mod->B3SOIPDk2Given = TRUE; + break; + case B3SOIPD_MOD_K3: + mod->B3SOIPDk3 = value->rValue; + mod->B3SOIPDk3Given = TRUE; + break; + case B3SOIPD_MOD_K3B: + mod->B3SOIPDk3b = value->rValue; + mod->B3SOIPDk3bGiven = TRUE; + break; + case B3SOIPD_MOD_NLX: + mod->B3SOIPDnlx = value->rValue; + mod->B3SOIPDnlxGiven = TRUE; + break; + case B3SOIPD_MOD_W0: + mod->B3SOIPDw0 = value->rValue; + mod->B3SOIPDw0Given = TRUE; + break; + case B3SOIPD_MOD_DVT0: + mod->B3SOIPDdvt0 = value->rValue; + mod->B3SOIPDdvt0Given = TRUE; + break; + case B3SOIPD_MOD_DVT1: + mod->B3SOIPDdvt1 = value->rValue; + mod->B3SOIPDdvt1Given = TRUE; + break; + case B3SOIPD_MOD_DVT2: + mod->B3SOIPDdvt2 = value->rValue; + mod->B3SOIPDdvt2Given = TRUE; + break; + case B3SOIPD_MOD_DVT0W: + mod->B3SOIPDdvt0w = value->rValue; + mod->B3SOIPDdvt0wGiven = TRUE; + break; + case B3SOIPD_MOD_DVT1W: + mod->B3SOIPDdvt1w = value->rValue; + mod->B3SOIPDdvt1wGiven = TRUE; + break; + case B3SOIPD_MOD_DVT2W: + mod->B3SOIPDdvt2w = value->rValue; + mod->B3SOIPDdvt2wGiven = TRUE; + break; + case B3SOIPD_MOD_DROUT: + mod->B3SOIPDdrout = value->rValue; + mod->B3SOIPDdroutGiven = TRUE; + break; + case B3SOIPD_MOD_DSUB: + mod->B3SOIPDdsub = value->rValue; + mod->B3SOIPDdsubGiven = TRUE; + break; + case B3SOIPD_MOD_VTH0: + mod->B3SOIPDvth0 = value->rValue; + mod->B3SOIPDvth0Given = TRUE; + break; + case B3SOIPD_MOD_UA: + mod->B3SOIPDua = value->rValue; + mod->B3SOIPDuaGiven = TRUE; + break; + case B3SOIPD_MOD_UA1: + mod->B3SOIPDua1 = value->rValue; + mod->B3SOIPDua1Given = TRUE; + break; + case B3SOIPD_MOD_UB: + mod->B3SOIPDub = value->rValue; + mod->B3SOIPDubGiven = TRUE; + break; + case B3SOIPD_MOD_UB1: + mod->B3SOIPDub1 = value->rValue; + mod->B3SOIPDub1Given = TRUE; + break; + case B3SOIPD_MOD_UC: + mod->B3SOIPDuc = value->rValue; + mod->B3SOIPDucGiven = TRUE; + break; + case B3SOIPD_MOD_UC1: + mod->B3SOIPDuc1 = value->rValue; + mod->B3SOIPDuc1Given = TRUE; + break; + case B3SOIPD_MOD_U0: + mod->B3SOIPDu0 = value->rValue; + mod->B3SOIPDu0Given = TRUE; + break; + case B3SOIPD_MOD_UTE: + mod->B3SOIPDute = value->rValue; + mod->B3SOIPDuteGiven = TRUE; + break; + case B3SOIPD_MOD_VOFF: + mod->B3SOIPDvoff = value->rValue; + mod->B3SOIPDvoffGiven = TRUE; + break; + case B3SOIPD_MOD_DELTA: + mod->B3SOIPDdelta = value->rValue; + mod->B3SOIPDdeltaGiven = TRUE; + break; + case B3SOIPD_MOD_RDSW: + mod->B3SOIPDrdsw = value->rValue; + mod->B3SOIPDrdswGiven = TRUE; + break; + case B3SOIPD_MOD_PRWG: + mod->B3SOIPDprwg = value->rValue; + mod->B3SOIPDprwgGiven = TRUE; + break; + case B3SOIPD_MOD_PRWB: + mod->B3SOIPDprwb = value->rValue; + mod->B3SOIPDprwbGiven = TRUE; + break; + case B3SOIPD_MOD_PRT: + mod->B3SOIPDprt = value->rValue; + mod->B3SOIPDprtGiven = TRUE; + break; + case B3SOIPD_MOD_ETA0: + mod->B3SOIPDeta0 = value->rValue; + mod->B3SOIPDeta0Given = TRUE; + break; + case B3SOIPD_MOD_ETAB: + mod->B3SOIPDetab = value->rValue; + mod->B3SOIPDetabGiven = TRUE; + break; + case B3SOIPD_MOD_PCLM: + mod->B3SOIPDpclm = value->rValue; + mod->B3SOIPDpclmGiven = TRUE; + break; + case B3SOIPD_MOD_PDIBL1: + mod->B3SOIPDpdibl1 = value->rValue; + mod->B3SOIPDpdibl1Given = TRUE; + break; + case B3SOIPD_MOD_PDIBL2: + mod->B3SOIPDpdibl2 = value->rValue; + mod->B3SOIPDpdibl2Given = TRUE; + break; + case B3SOIPD_MOD_PDIBLB: + mod->B3SOIPDpdiblb = value->rValue; + mod->B3SOIPDpdiblbGiven = TRUE; + break; + case B3SOIPD_MOD_PVAG: + mod->B3SOIPDpvag = value->rValue; + mod->B3SOIPDpvagGiven = TRUE; + break; + case B3SOIPD_MOD_WR: + mod->B3SOIPDwr = value->rValue; + mod->B3SOIPDwrGiven = TRUE; + break; + case B3SOIPD_MOD_DWG: + mod->B3SOIPDdwg = value->rValue; + mod->B3SOIPDdwgGiven = TRUE; + break; + case B3SOIPD_MOD_DWB: + mod->B3SOIPDdwb = value->rValue; + mod->B3SOIPDdwbGiven = TRUE; + break; + case B3SOIPD_MOD_B0: + mod->B3SOIPDb0 = value->rValue; + mod->B3SOIPDb0Given = TRUE; + break; + case B3SOIPD_MOD_B1: + mod->B3SOIPDb1 = value->rValue; + mod->B3SOIPDb1Given = TRUE; + break; + case B3SOIPD_MOD_ALPHA0: + mod->B3SOIPDalpha0 = value->rValue; + mod->B3SOIPDalpha0Given = TRUE; + break; + + case B3SOIPD_MOD_CGSL: + mod->B3SOIPDcgsl = value->rValue; + mod->B3SOIPDcgslGiven = TRUE; + break; + case B3SOIPD_MOD_CGDL: + mod->B3SOIPDcgdl = value->rValue; + mod->B3SOIPDcgdlGiven = TRUE; + break; + case B3SOIPD_MOD_CKAPPA: + mod->B3SOIPDckappa = value->rValue; + mod->B3SOIPDckappaGiven = TRUE; + break; + case B3SOIPD_MOD_CF: + mod->B3SOIPDcf = value->rValue; + mod->B3SOIPDcfGiven = TRUE; + break; + case B3SOIPD_MOD_CLC: + mod->B3SOIPDclc = value->rValue; + mod->B3SOIPDclcGiven = TRUE; + break; + case B3SOIPD_MOD_CLE: + mod->B3SOIPDcle = value->rValue; + mod->B3SOIPDcleGiven = TRUE; + break; + case B3SOIPD_MOD_DWC: + mod->B3SOIPDdwc = value->rValue; + mod->B3SOIPDdwcGiven = TRUE; + break; + case B3SOIPD_MOD_DLC: + mod->B3SOIPDdlc = value->rValue; + mod->B3SOIPDdlcGiven = TRUE; + break; + case B3SOIPD_MOD_TBOX: + mod->B3SOIPDtbox = value->rValue; + mod->B3SOIPDtboxGiven = TRUE; + break; + case B3SOIPD_MOD_TSI: + mod->B3SOIPDtsi = value->rValue; + mod->B3SOIPDtsiGiven = TRUE; + break; + case B3SOIPD_MOD_XJ: + mod->B3SOIPDxj = value->rValue; + mod->B3SOIPDxjGiven = TRUE; + break; + case B3SOIPD_MOD_RBODY: + mod->B3SOIPDrbody = value->rValue; + mod->B3SOIPDrbodyGiven = TRUE; + break; + case B3SOIPD_MOD_RBSH: + mod->B3SOIPDrbsh = value->rValue; + mod->B3SOIPDrbshGiven = TRUE; + break; + case B3SOIPD_MOD_RTH0: + mod->B3SOIPDrth0 = value->rValue; + mod->B3SOIPDrth0Given = TRUE; + break; + case B3SOIPD_MOD_CTH0: + mod->B3SOIPDcth0 = value->rValue; + mod->B3SOIPDcth0Given = TRUE; + break; + case B3SOIPD_MOD_NGIDL: + mod->B3SOIPDngidl = value->rValue; + mod->B3SOIPDngidlGiven = TRUE; + break; + case B3SOIPD_MOD_AGIDL: + mod->B3SOIPDagidl = value->rValue; + mod->B3SOIPDagidlGiven = TRUE; + break; + case B3SOIPD_MOD_BGIDL: + mod->B3SOIPDbgidl = value->rValue; + mod->B3SOIPDbgidlGiven = TRUE; + break; + case B3SOIPD_MOD_NDIODE: + mod->B3SOIPDndiode = value->rValue; + mod->B3SOIPDndiodeGiven = TRUE; + break; + case B3SOIPD_MOD_XBJT: + mod->B3SOIPDxbjt = value->rValue; + mod->B3SOIPDxbjtGiven = TRUE; + break; + + case B3SOIPD_MOD_XDIF: + mod->B3SOIPDxdif = value->rValue; + mod->B3SOIPDxdifGiven = TRUE; + break; + + case B3SOIPD_MOD_XREC: + mod->B3SOIPDxrec = value->rValue; + mod->B3SOIPDxrecGiven = TRUE; + break; + case B3SOIPD_MOD_XTUN: + mod->B3SOIPDxtun = value->rValue; + mod->B3SOIPDxtunGiven = TRUE; + break; + case B3SOIPD_MOD_TT: + mod->B3SOIPDtt = value->rValue; + mod->B3SOIPDttGiven = TRUE; + break; + case B3SOIPD_MOD_VSDTH: + mod->B3SOIPDvsdth = value->rValue; + mod->B3SOIPDvsdthGiven = TRUE; + break; + case B3SOIPD_MOD_VSDFB: + mod->B3SOIPDvsdfb = value->rValue; + mod->B3SOIPDvsdfbGiven = TRUE; + break; + case B3SOIPD_MOD_CSDMIN: + mod->B3SOIPDcsdmin = value->rValue; + mod->B3SOIPDcsdminGiven = TRUE; + break; + case B3SOIPD_MOD_ASD: + mod->B3SOIPDasd = value->rValue; + mod->B3SOIPDasdGiven = TRUE; + break; + + + case B3SOIPD_MOD_TNOM: + mod->B3SOIPDtnom = value->rValue + 273.15; + mod->B3SOIPDtnomGiven = TRUE; + break; + case B3SOIPD_MOD_CGSO: + mod->B3SOIPDcgso = value->rValue; + mod->B3SOIPDcgsoGiven = TRUE; + break; + case B3SOIPD_MOD_CGDO: + mod->B3SOIPDcgdo = value->rValue; + mod->B3SOIPDcgdoGiven = TRUE; + break; + case B3SOIPD_MOD_CGEO: + mod->B3SOIPDcgeo = value->rValue; + mod->B3SOIPDcgeoGiven = TRUE; + break; + case B3SOIPD_MOD_XPART: + mod->B3SOIPDxpart = value->rValue; + mod->B3SOIPDxpartGiven = TRUE; + break; + case B3SOIPD_MOD_RSH: + mod->B3SOIPDsheetResistance = value->rValue; + mod->B3SOIPDsheetResistanceGiven = TRUE; + break; + case B3SOIPD_MOD_PBSWG: + mod->B3SOIPDGatesidewallJctPotential = value->rValue; + mod->B3SOIPDGatesidewallJctPotentialGiven = TRUE; + break; + case B3SOIPD_MOD_MJSWG: + mod->B3SOIPDbodyJctGateSideGradingCoeff = value->rValue; + mod->B3SOIPDbodyJctGateSideGradingCoeffGiven = TRUE; + break; + case B3SOIPD_MOD_CJSWG: + mod->B3SOIPDunitLengthGateSidewallJctCap = value->rValue; + mod->B3SOIPDunitLengthGateSidewallJctCapGiven = TRUE; + break; + case B3SOIPD_MOD_CSDESW: + mod->B3SOIPDcsdesw = value->rValue; + mod->B3SOIPDcsdeswGiven = TRUE; + break; + case B3SOIPD_MOD_LINT: + mod->B3SOIPDLint = value->rValue; + mod->B3SOIPDLintGiven = TRUE; + break; + case B3SOIPD_MOD_LL: + mod->B3SOIPDLl = value->rValue; + mod->B3SOIPDLlGiven = TRUE; + break; + case B3SOIPD_MOD_LLN: + mod->B3SOIPDLln = value->rValue; + mod->B3SOIPDLlnGiven = TRUE; + break; + case B3SOIPD_MOD_LW: + mod->B3SOIPDLw = value->rValue; + mod->B3SOIPDLwGiven = TRUE; + break; + case B3SOIPD_MOD_LWN: + mod->B3SOIPDLwn = value->rValue; + mod->B3SOIPDLwnGiven = TRUE; + break; + case B3SOIPD_MOD_LWL: + mod->B3SOIPDLwl = value->rValue; + mod->B3SOIPDLwlGiven = TRUE; + break; + case B3SOIPD_MOD_WINT: + mod->B3SOIPDWint = value->rValue; + mod->B3SOIPDWintGiven = TRUE; + break; + case B3SOIPD_MOD_WL: + mod->B3SOIPDWl = value->rValue; + mod->B3SOIPDWlGiven = TRUE; + break; + case B3SOIPD_MOD_WLN: + mod->B3SOIPDWln = value->rValue; + mod->B3SOIPDWlnGiven = TRUE; + break; + case B3SOIPD_MOD_WW: + mod->B3SOIPDWw = value->rValue; + mod->B3SOIPDWwGiven = TRUE; + break; + case B3SOIPD_MOD_WWN: + mod->B3SOIPDWwn = value->rValue; + mod->B3SOIPDWwnGiven = TRUE; + break; + case B3SOIPD_MOD_WWL: + mod->B3SOIPDWwl = value->rValue; + mod->B3SOIPDWwlGiven = TRUE; + break; + + case B3SOIPD_MOD_NOIA: + mod->B3SOIPDoxideTrapDensityA = value->rValue; + mod->B3SOIPDoxideTrapDensityAGiven = TRUE; + break; + case B3SOIPD_MOD_NOIB: + mod->B3SOIPDoxideTrapDensityB = value->rValue; + mod->B3SOIPDoxideTrapDensityBGiven = TRUE; + break; + case B3SOIPD_MOD_NOIC: + mod->B3SOIPDoxideTrapDensityC = value->rValue; + mod->B3SOIPDoxideTrapDensityCGiven = TRUE; + break; + case B3SOIPD_MOD_NOIF: + mod->B3SOIPDnoif = value->rValue; + mod->B3SOIPDnoifGiven = TRUE; + break; + case B3SOIPD_MOD_EM: + mod->B3SOIPDem = value->rValue; + mod->B3SOIPDemGiven = TRUE; + break; + case B3SOIPD_MOD_EF: + mod->B3SOIPDef = value->rValue; + mod->B3SOIPDefGiven = TRUE; + break; + case B3SOIPD_MOD_AF: + mod->B3SOIPDaf = value->rValue; + mod->B3SOIPDafGiven = TRUE; + break; + case B3SOIPD_MOD_KF: + mod->B3SOIPDkf = value->rValue; + mod->B3SOIPDkfGiven = TRUE; + break; + + +/* v2.2 release */ + case B3SOIPD_MOD_WTH0: + mod->B3SOIPDwth0 = value->rValue; + mod->B3SOIPDwth0Given = TRUE; + break; + case B3SOIPD_MOD_RHALO: + mod->B3SOIPDrhalo = value->rValue; + mod->B3SOIPDrhaloGiven = TRUE; + break; + case B3SOIPD_MOD_NTOX: + mod->B3SOIPDntox = value->rValue; + mod->B3SOIPDntoxGiven = TRUE; + break; + case B3SOIPD_MOD_TOXREF: + mod->B3SOIPDtoxref = value->rValue; + mod->B3SOIPDtoxrefGiven = TRUE; + break; + case B3SOIPD_MOD_EBG: + mod->B3SOIPDebg = value->rValue; + mod->B3SOIPDebgGiven = TRUE; + break; + case B3SOIPD_MOD_NEVB: + mod->B3SOIPDnevb = value->rValue; + mod->B3SOIPDnevbGiven = TRUE; + break; + case B3SOIPD_MOD_ALPHAGB1: + mod->B3SOIPDalphaGB1 = value->rValue; + mod->B3SOIPDalphaGB1Given = TRUE; + break; + case B3SOIPD_MOD_BETAGB1: + mod->B3SOIPDbetaGB1 = value->rValue; + mod->B3SOIPDbetaGB1Given = TRUE; + break; + case B3SOIPD_MOD_VGB1: + mod->B3SOIPDvgb1 = value->rValue; + mod->B3SOIPDvgb1Given = TRUE; + break; + case B3SOIPD_MOD_NECB: + mod->B3SOIPDnecb = value->rValue; + mod->B3SOIPDnecbGiven = TRUE; + break; + case B3SOIPD_MOD_ALPHAGB2: + mod->B3SOIPDalphaGB2 = value->rValue; + mod->B3SOIPDalphaGB2Given = TRUE; + break; + case B3SOIPD_MOD_BETAGB2: + mod->B3SOIPDbetaGB2 = value->rValue; + mod->B3SOIPDbetaGB2Given = TRUE; + break; + case B3SOIPD_MOD_VGB2: + mod->B3SOIPDvgb2 = value->rValue; + mod->B3SOIPDvgb2Given = TRUE; + break; + case B3SOIPD_MOD_TOXQM: + mod->B3SOIPDtoxqm = value->rValue; + mod->B3SOIPDtoxqmGiven = TRUE; + break; + case B3SOIPD_MOD_VOXH: + mod->B3SOIPDvoxh = value->rValue; + mod->B3SOIPDvoxhGiven = TRUE; + break; + case B3SOIPD_MOD_DELTAVOX: + mod->B3SOIPDdeltavox = value->rValue; + mod->B3SOIPDdeltavoxGiven = TRUE; + break; + case B3SOIPD_MOD_IGMOD: + mod->B3SOIPDigMod = value->iValue; + mod->B3SOIPDigModGiven = TRUE; + break; + + +/* v2.0 release */ + case B3SOIPD_MOD_K1W1: + mod->B3SOIPDk1w1 = value->rValue; + mod->B3SOIPDk1w1Given = TRUE; + break; + case B3SOIPD_MOD_K1W2: + mod->B3SOIPDk1w2 = value->rValue; + mod->B3SOIPDk1w2Given = TRUE; + break; + case B3SOIPD_MOD_KETAS: + mod->B3SOIPDketas = value->rValue; + mod->B3SOIPDketasGiven = TRUE; + break; + case B3SOIPD_MOD_DWBC: + mod->B3SOIPDdwbc = value->rValue; + mod->B3SOIPDdwbcGiven = TRUE; + break; + case B3SOIPD_MOD_BETA0: + mod->B3SOIPDbeta0 = value->rValue; + mod->B3SOIPDbeta0Given = TRUE; + break; + case B3SOIPD_MOD_BETA1: + mod->B3SOIPDbeta1 = value->rValue; + mod->B3SOIPDbeta1Given = TRUE; + break; + case B3SOIPD_MOD_BETA2: + mod->B3SOIPDbeta2 = value->rValue; + mod->B3SOIPDbeta2Given = TRUE; + break; + case B3SOIPD_MOD_VDSATII0: + mod->B3SOIPDvdsatii0 = value->rValue; + mod->B3SOIPDvdsatii0Given = TRUE; + break; + case B3SOIPD_MOD_TII: + mod->B3SOIPDtii = value->rValue; + mod->B3SOIPDtiiGiven = TRUE; + break; + case B3SOIPD_MOD_LII: + mod->B3SOIPDlii = value->rValue; + mod->B3SOIPDliiGiven = TRUE; + break; + case B3SOIPD_MOD_SII0: + mod->B3SOIPDsii0 = value->rValue; + mod->B3SOIPDsii0Given = TRUE; + break; + case B3SOIPD_MOD_SII1: + mod->B3SOIPDsii1 = value->rValue; + mod->B3SOIPDsii1Given = TRUE; + break; + case B3SOIPD_MOD_SII2: + mod->B3SOIPDsii2 = value->rValue; + mod->B3SOIPDsii2Given = TRUE; + break; + case B3SOIPD_MOD_SIID: + mod->B3SOIPDsiid = value->rValue; + mod->B3SOIPDsiidGiven = TRUE; + break; + case B3SOIPD_MOD_FBJTII: + mod->B3SOIPDfbjtii = value->rValue; + mod->B3SOIPDfbjtiiGiven = TRUE; + break; + case B3SOIPD_MOD_ESATII: + mod->B3SOIPDesatii = value->rValue; + mod->B3SOIPDesatiiGiven = TRUE; + break; + case B3SOIPD_MOD_NTUN: + mod->B3SOIPDntun = value->rValue; + mod->B3SOIPDntunGiven = TRUE; + break; + case B3SOIPD_MOD_NRECF0: + mod->B3SOIPDnrecf0 = value->rValue; + mod->B3SOIPDnrecf0Given = TRUE; + break; + case B3SOIPD_MOD_NRECR0: + mod->B3SOIPDnrecr0 = value->rValue; + mod->B3SOIPDnrecr0Given = TRUE; + break; + case B3SOIPD_MOD_ISBJT: + mod->B3SOIPDisbjt = value->rValue; + mod->B3SOIPDisbjtGiven = TRUE; + break; + case B3SOIPD_MOD_ISDIF: + mod->B3SOIPDisdif = value->rValue; + mod->B3SOIPDisdifGiven = TRUE; + break; + case B3SOIPD_MOD_ISREC: + mod->B3SOIPDisrec = value->rValue; + mod->B3SOIPDisrecGiven = TRUE; + break; + case B3SOIPD_MOD_ISTUN: + mod->B3SOIPDistun = value->rValue; + mod->B3SOIPDistunGiven = TRUE; + break; + case B3SOIPD_MOD_LN: + mod->B3SOIPDln = value->rValue; + mod->B3SOIPDlnGiven = TRUE; + break; + case B3SOIPD_MOD_VREC0: + mod->B3SOIPDvrec0 = value->rValue; + mod->B3SOIPDvrec0Given = TRUE; + break; + case B3SOIPD_MOD_VTUN0: + mod->B3SOIPDvtun0 = value->rValue; + mod->B3SOIPDvtun0Given = TRUE; + break; + case B3SOIPD_MOD_NBJT: + mod->B3SOIPDnbjt = value->rValue; + mod->B3SOIPDnbjtGiven = TRUE; + break; + case B3SOIPD_MOD_LBJT0: + mod->B3SOIPDlbjt0 = value->rValue; + mod->B3SOIPDlbjt0Given = TRUE; + break; + case B3SOIPD_MOD_LDIF0: + mod->B3SOIPDldif0 = value->rValue; + mod->B3SOIPDldif0Given = TRUE; + break; + case B3SOIPD_MOD_VABJT: + mod->B3SOIPDvabjt = value->rValue; + mod->B3SOIPDvabjtGiven = TRUE; + break; + case B3SOIPD_MOD_AELY: + mod->B3SOIPDaely = value->rValue; + mod->B3SOIPDaelyGiven = TRUE; + break; + case B3SOIPD_MOD_AHLI: + mod->B3SOIPDahli = value->rValue; + mod->B3SOIPDahliGiven = TRUE; + break; + case B3SOIPD_MOD_NDIF: + mod->B3SOIPDndif = value->rValue; + mod->B3SOIPDndifGiven = TRUE; + break; + case B3SOIPD_MOD_NTRECF: + mod->B3SOIPDntrecf = value->rValue; + mod->B3SOIPDntrecfGiven = TRUE; + break; + case B3SOIPD_MOD_NTRECR: + mod->B3SOIPDntrecr = value->rValue; + mod->B3SOIPDntrecrGiven = TRUE; + break; + case B3SOIPD_MOD_DLCB: + mod->B3SOIPDdlcb = value->rValue; + mod->B3SOIPDdlcbGiven = TRUE; + break; + case B3SOIPD_MOD_FBODY: + mod->B3SOIPDfbody = value->rValue; + mod->B3SOIPDfbodyGiven = TRUE; + break; + case B3SOIPD_MOD_TCJSWG: + mod->B3SOIPDtcjswg = value->rValue; + mod->B3SOIPDtcjswgGiven = TRUE; + break; + case B3SOIPD_MOD_TPBSWG: + mod->B3SOIPDtpbswg = value->rValue; + mod->B3SOIPDtpbswgGiven = TRUE; + break; + case B3SOIPD_MOD_ACDE: + mod->B3SOIPDacde = value->rValue; + mod->B3SOIPDacdeGiven = TRUE; + break; + case B3SOIPD_MOD_MOIN: + mod->B3SOIPDmoin = value->rValue; + mod->B3SOIPDmoinGiven = TRUE; + break; + case B3SOIPD_MOD_DELVT: + mod->B3SOIPDdelvt = value->rValue; + mod->B3SOIPDdelvtGiven = TRUE; + break; + case B3SOIPD_MOD_KB1: + mod->B3SOIPDkb1 = value->rValue; + mod->B3SOIPDkb1Given = TRUE; + break; + case B3SOIPD_MOD_DLBG: + mod->B3SOIPDdlbg = value->rValue; + mod->B3SOIPDdlbgGiven = TRUE; + break; + +/* Added for binning - START */ + /* Length Dependence */ + case B3SOIPD_MOD_LNPEAK: + mod->B3SOIPDlnpeak = value->rValue; + mod->B3SOIPDlnpeakGiven = TRUE; + break; + case B3SOIPD_MOD_LNSUB: + mod->B3SOIPDlnsub = value->rValue; + mod->B3SOIPDlnsubGiven = TRUE; + break; + case B3SOIPD_MOD_LNGATE: + mod->B3SOIPDlngate = value->rValue; + mod->B3SOIPDlngateGiven = TRUE; + break; + case B3SOIPD_MOD_LVTH0: + mod->B3SOIPDlvth0 = value->rValue; + mod->B3SOIPDlvth0Given = TRUE; + break; + case B3SOIPD_MOD_LK1: + mod->B3SOIPDlk1 = value->rValue; + mod->B3SOIPDlk1Given = TRUE; + break; + case B3SOIPD_MOD_LK1W1: + mod->B3SOIPDlk1w1 = value->rValue; + mod->B3SOIPDlk1w1Given = TRUE; + break; + case B3SOIPD_MOD_LK1W2: + mod->B3SOIPDlk1w2 = value->rValue; + mod->B3SOIPDlk1w2Given = TRUE; + break; + case B3SOIPD_MOD_LK2: + mod->B3SOIPDlk2 = value->rValue; + mod->B3SOIPDlk2Given = TRUE; + break; + case B3SOIPD_MOD_LK3: + mod->B3SOIPDlk3 = value->rValue; + mod->B3SOIPDlk3Given = TRUE; + break; + case B3SOIPD_MOD_LK3B: + mod->B3SOIPDlk3b = value->rValue; + mod->B3SOIPDlk3bGiven = TRUE; + break; + case B3SOIPD_MOD_LKB1: + mod->B3SOIPDlkb1 = value->rValue; + mod->B3SOIPDlkb1Given = TRUE; + break; + case B3SOIPD_MOD_LW0: + mod->B3SOIPDlw0 = value->rValue; + mod->B3SOIPDlw0Given = TRUE; + break; + case B3SOIPD_MOD_LNLX: + mod->B3SOIPDlnlx = value->rValue; + mod->B3SOIPDlnlxGiven = TRUE; + break; + case B3SOIPD_MOD_LDVT0: + mod->B3SOIPDldvt0 = value->rValue; + mod->B3SOIPDldvt0Given = TRUE; + break; + case B3SOIPD_MOD_LDVT1: + mod->B3SOIPDldvt1 = value->rValue; + mod->B3SOIPDldvt1Given = TRUE; + break; + case B3SOIPD_MOD_LDVT2: + mod->B3SOIPDldvt2 = value->rValue; + mod->B3SOIPDldvt2Given = TRUE; + break; + case B3SOIPD_MOD_LDVT0W: + mod->B3SOIPDldvt0w = value->rValue; + mod->B3SOIPDldvt0wGiven = TRUE; + break; + case B3SOIPD_MOD_LDVT1W: + mod->B3SOIPDldvt1w = value->rValue; + mod->B3SOIPDldvt1wGiven = TRUE; + break; + case B3SOIPD_MOD_LDVT2W: + mod->B3SOIPDldvt2w = value->rValue; + mod->B3SOIPDldvt2wGiven = TRUE; + break; + case B3SOIPD_MOD_LU0: + mod->B3SOIPDlu0 = value->rValue; + mod->B3SOIPDlu0Given = TRUE; + break; + case B3SOIPD_MOD_LUA: + mod->B3SOIPDlua = value->rValue; + mod->B3SOIPDluaGiven = TRUE; + break; + case B3SOIPD_MOD_LUB: + mod->B3SOIPDlub = value->rValue; + mod->B3SOIPDlubGiven = TRUE; + break; + case B3SOIPD_MOD_LUC: + mod->B3SOIPDluc = value->rValue; + mod->B3SOIPDlucGiven = TRUE; + break; + case B3SOIPD_MOD_LVSAT: + mod->B3SOIPDlvsat = value->rValue; + mod->B3SOIPDlvsatGiven = TRUE; + break; + case B3SOIPD_MOD_LA0: + mod->B3SOIPDla0 = value->rValue; + mod->B3SOIPDla0Given = TRUE; + break; + case B3SOIPD_MOD_LAGS: + mod->B3SOIPDlags = value->rValue; + mod->B3SOIPDlagsGiven = TRUE; + break; + case B3SOIPD_MOD_LB0: + mod->B3SOIPDlb0 = value->rValue; + mod->B3SOIPDlb0Given = TRUE; + break; + case B3SOIPD_MOD_LB1: + mod->B3SOIPDlb1 = value->rValue; + mod->B3SOIPDlb1Given = TRUE; + break; + case B3SOIPD_MOD_LKETA: + mod->B3SOIPDlketa = value->rValue; + mod->B3SOIPDlketaGiven = TRUE; + break; + case B3SOIPD_MOD_LKETAS: + mod->B3SOIPDlketas = value->rValue; + mod->B3SOIPDlketasGiven = TRUE; + break; + case B3SOIPD_MOD_LA1: + mod->B3SOIPDla1 = value->rValue; + mod->B3SOIPDla1Given = TRUE; + break; + case B3SOIPD_MOD_LA2: + mod->B3SOIPDla2 = value->rValue; + mod->B3SOIPDla2Given = TRUE; + break; + case B3SOIPD_MOD_LRDSW: + mod->B3SOIPDlrdsw = value->rValue; + mod->B3SOIPDlrdswGiven = TRUE; + break; + case B3SOIPD_MOD_LPRWB: + mod->B3SOIPDlprwb = value->rValue; + mod->B3SOIPDlprwbGiven = TRUE; + break; + case B3SOIPD_MOD_LPRWG: + mod->B3SOIPDlprwg = value->rValue; + mod->B3SOIPDlprwgGiven = TRUE; + break; + case B3SOIPD_MOD_LWR: + mod->B3SOIPDlwr = value->rValue; + mod->B3SOIPDlwrGiven = TRUE; + break; + case B3SOIPD_MOD_LNFACTOR: + mod->B3SOIPDlnfactor = value->rValue; + mod->B3SOIPDlnfactorGiven = TRUE; + break; + case B3SOIPD_MOD_LDWG: + mod->B3SOIPDldwg = value->rValue; + mod->B3SOIPDldwgGiven = TRUE; + break; + case B3SOIPD_MOD_LDWB: + mod->B3SOIPDldwb = value->rValue; + mod->B3SOIPDldwbGiven = TRUE; + break; + case B3SOIPD_MOD_LVOFF: + mod->B3SOIPDlvoff = value->rValue; + mod->B3SOIPDlvoffGiven = TRUE; + break; + case B3SOIPD_MOD_LETA0: + mod->B3SOIPDleta0 = value->rValue; + mod->B3SOIPDleta0Given = TRUE; + break; + case B3SOIPD_MOD_LETAB: + mod->B3SOIPDletab = value->rValue; + mod->B3SOIPDletabGiven = TRUE; + break; + case B3SOIPD_MOD_LDSUB: + mod->B3SOIPDldsub = value->rValue; + mod->B3SOIPDldsubGiven = TRUE; + break; + case B3SOIPD_MOD_LCIT: + mod->B3SOIPDlcit = value->rValue; + mod->B3SOIPDlcitGiven = TRUE; + break; + case B3SOIPD_MOD_LCDSC: + mod->B3SOIPDlcdsc = value->rValue; + mod->B3SOIPDlcdscGiven = TRUE; + break; + case B3SOIPD_MOD_LCDSCB: + mod->B3SOIPDlcdscb = value->rValue; + mod->B3SOIPDlcdscbGiven = TRUE; + break; + case B3SOIPD_MOD_LCDSCD: + mod->B3SOIPDlcdscd = value->rValue; + mod->B3SOIPDlcdscdGiven = TRUE; + break; + case B3SOIPD_MOD_LPCLM: + mod->B3SOIPDlpclm = value->rValue; + mod->B3SOIPDlpclmGiven = TRUE; + break; + case B3SOIPD_MOD_LPDIBL1: + mod->B3SOIPDlpdibl1 = value->rValue; + mod->B3SOIPDlpdibl1Given = TRUE; + break; + case B3SOIPD_MOD_LPDIBL2: + mod->B3SOIPDlpdibl2 = value->rValue; + mod->B3SOIPDlpdibl2Given = TRUE; + break; + case B3SOIPD_MOD_LPDIBLB: + mod->B3SOIPDlpdiblb = value->rValue; + mod->B3SOIPDlpdiblbGiven = TRUE; + break; + case B3SOIPD_MOD_LDROUT: + mod->B3SOIPDldrout = value->rValue; + mod->B3SOIPDldroutGiven = TRUE; + break; + case B3SOIPD_MOD_LPVAG: + mod->B3SOIPDlpvag = value->rValue; + mod->B3SOIPDlpvagGiven = TRUE; + break; + case B3SOIPD_MOD_LDELTA: + mod->B3SOIPDldelta = value->rValue; + mod->B3SOIPDldeltaGiven = TRUE; + break; + case B3SOIPD_MOD_LALPHA0: + mod->B3SOIPDlalpha0 = value->rValue; + mod->B3SOIPDlalpha0Given = TRUE; + break; + case B3SOIPD_MOD_LFBJTII: + mod->B3SOIPDlfbjtii = value->rValue; + mod->B3SOIPDlfbjtiiGiven = TRUE; + break; + case B3SOIPD_MOD_LBETA0: + mod->B3SOIPDlbeta0 = value->rValue; + mod->B3SOIPDlbeta0Given = TRUE; + break; + case B3SOIPD_MOD_LBETA1: + mod->B3SOIPDlbeta1 = value->rValue; + mod->B3SOIPDlbeta1Given = TRUE; + break; + case B3SOIPD_MOD_LBETA2: + mod->B3SOIPDlbeta2 = value->rValue; + mod->B3SOIPDlbeta2Given = TRUE; + break; + case B3SOIPD_MOD_LVDSATII0: + mod->B3SOIPDlvdsatii0 = value->rValue; + mod->B3SOIPDlvdsatii0Given = TRUE; + break; + case B3SOIPD_MOD_LLII: + mod->B3SOIPDllii = value->rValue; + mod->B3SOIPDlliiGiven = TRUE; + break; + case B3SOIPD_MOD_LESATII: + mod->B3SOIPDlesatii = value->rValue; + mod->B3SOIPDlesatiiGiven = TRUE; + break; + case B3SOIPD_MOD_LSII0: + mod->B3SOIPDlsii0 = value->rValue; + mod->B3SOIPDlsii0Given = TRUE; + break; + case B3SOIPD_MOD_LSII1: + mod->B3SOIPDlsii1 = value->rValue; + mod->B3SOIPDlsii1Given = TRUE; + break; + case B3SOIPD_MOD_LSII2: + mod->B3SOIPDlsii2 = value->rValue; + mod->B3SOIPDlsii2Given = TRUE; + break; + case B3SOIPD_MOD_LSIID: + mod->B3SOIPDlsiid = value->rValue; + mod->B3SOIPDlsiidGiven = TRUE; + break; + case B3SOIPD_MOD_LAGIDL: + mod->B3SOIPDlagidl = value->rValue; + mod->B3SOIPDlagidlGiven = TRUE; + break; + case B3SOIPD_MOD_LBGIDL: + mod->B3SOIPDlbgidl = value->rValue; + mod->B3SOIPDlbgidlGiven = TRUE; + break; + case B3SOIPD_MOD_LNGIDL: + mod->B3SOIPDlngidl = value->rValue; + mod->B3SOIPDlngidlGiven = TRUE; + break; + case B3SOIPD_MOD_LNTUN: + mod->B3SOIPDlntun = value->rValue; + mod->B3SOIPDlntunGiven = TRUE; + break; + case B3SOIPD_MOD_LNDIODE: + mod->B3SOIPDlndiode = value->rValue; + mod->B3SOIPDlndiodeGiven = TRUE; + break; + case B3SOIPD_MOD_LNRECF0: + mod->B3SOIPDlnrecf0 = value->rValue; + mod->B3SOIPDlnrecf0Given = TRUE; + break; + case B3SOIPD_MOD_LNRECR0: + mod->B3SOIPDlnrecr0 = value->rValue; + mod->B3SOIPDlnrecr0Given = TRUE; + break; + case B3SOIPD_MOD_LISBJT: + mod->B3SOIPDlisbjt = value->rValue; + mod->B3SOIPDlisbjtGiven = TRUE; + break; + case B3SOIPD_MOD_LISDIF: + mod->B3SOIPDlisdif = value->rValue; + mod->B3SOIPDlisdifGiven = TRUE; + break; + case B3SOIPD_MOD_LISREC: + mod->B3SOIPDlisrec = value->rValue; + mod->B3SOIPDlisrecGiven = TRUE; + break; + case B3SOIPD_MOD_LISTUN: + mod->B3SOIPDlistun = value->rValue; + mod->B3SOIPDlistunGiven = TRUE; + break; + case B3SOIPD_MOD_LVREC0: + mod->B3SOIPDlvrec0 = value->rValue; + mod->B3SOIPDlvrec0Given = TRUE; + break; + case B3SOIPD_MOD_LVTUN0: + mod->B3SOIPDlvtun0 = value->rValue; + mod->B3SOIPDlvtun0Given = TRUE; + break; + case B3SOIPD_MOD_LNBJT: + mod->B3SOIPDlnbjt = value->rValue; + mod->B3SOIPDlnbjtGiven = TRUE; + break; + case B3SOIPD_MOD_LLBJT0: + mod->B3SOIPDllbjt0 = value->rValue; + mod->B3SOIPDllbjt0Given = TRUE; + break; + case B3SOIPD_MOD_LVABJT: + mod->B3SOIPDlvabjt = value->rValue; + mod->B3SOIPDlvabjtGiven = TRUE; + break; + case B3SOIPD_MOD_LAELY: + mod->B3SOIPDlaely = value->rValue; + mod->B3SOIPDlaelyGiven = TRUE; + break; + case B3SOIPD_MOD_LAHLI: + mod->B3SOIPDlahli = value->rValue; + mod->B3SOIPDlahliGiven = TRUE; + break; + /* CV Model */ + case B3SOIPD_MOD_LVSDFB: + mod->B3SOIPDlvsdfb = value->rValue; + mod->B3SOIPDlvsdfbGiven = TRUE; + break; + case B3SOIPD_MOD_LVSDTH: + mod->B3SOIPDlvsdth = value->rValue; + mod->B3SOIPDlvsdthGiven = TRUE; + break; + case B3SOIPD_MOD_LDELVT: + mod->B3SOIPDldelvt = value->rValue; + mod->B3SOIPDldelvtGiven = TRUE; + break; + case B3SOIPD_MOD_LACDE: + mod->B3SOIPDlacde = value->rValue; + mod->B3SOIPDlacdeGiven = TRUE; + break; + case B3SOIPD_MOD_LMOIN: + mod->B3SOIPDlmoin = value->rValue; + mod->B3SOIPDlmoinGiven = TRUE; + break; + + /* Width Dependence */ + case B3SOIPD_MOD_WNPEAK: + mod->B3SOIPDwnpeak = value->rValue; + mod->B3SOIPDwnpeakGiven = TRUE; + break; + case B3SOIPD_MOD_WNSUB: + mod->B3SOIPDwnsub = value->rValue; + mod->B3SOIPDwnsubGiven = TRUE; + break; + case B3SOIPD_MOD_WNGATE: + mod->B3SOIPDwngate = value->rValue; + mod->B3SOIPDwngateGiven = TRUE; + break; + case B3SOIPD_MOD_WVTH0: + mod->B3SOIPDwvth0 = value->rValue; + mod->B3SOIPDwvth0Given = TRUE; + break; + case B3SOIPD_MOD_WK1: + mod->B3SOIPDwk1 = value->rValue; + mod->B3SOIPDwk1Given = TRUE; + break; + case B3SOIPD_MOD_WK1W1: + mod->B3SOIPDwk1w1 = value->rValue; + mod->B3SOIPDwk1w1Given = TRUE; + break; + case B3SOIPD_MOD_WK1W2: + mod->B3SOIPDwk1w2 = value->rValue; + mod->B3SOIPDwk1w2Given = TRUE; + break; + case B3SOIPD_MOD_WK2: + mod->B3SOIPDwk2 = value->rValue; + mod->B3SOIPDwk2Given = TRUE; + break; + case B3SOIPD_MOD_WK3: + mod->B3SOIPDwk3 = value->rValue; + mod->B3SOIPDwk3Given = TRUE; + break; + case B3SOIPD_MOD_WK3B: + mod->B3SOIPDwk3b = value->rValue; + mod->B3SOIPDwk3bGiven = TRUE; + break; + case B3SOIPD_MOD_WKB1: + mod->B3SOIPDwkb1 = value->rValue; + mod->B3SOIPDwkb1Given = TRUE; + break; + case B3SOIPD_MOD_WW0: + mod->B3SOIPDww0 = value->rValue; + mod->B3SOIPDww0Given = TRUE; + break; + case B3SOIPD_MOD_WNLX: + mod->B3SOIPDwnlx = value->rValue; + mod->B3SOIPDwnlxGiven = TRUE; + break; + case B3SOIPD_MOD_WDVT0: + mod->B3SOIPDwdvt0 = value->rValue; + mod->B3SOIPDwdvt0Given = TRUE; + break; + case B3SOIPD_MOD_WDVT1: + mod->B3SOIPDwdvt1 = value->rValue; + mod->B3SOIPDwdvt1Given = TRUE; + break; + case B3SOIPD_MOD_WDVT2: + mod->B3SOIPDwdvt2 = value->rValue; + mod->B3SOIPDwdvt2Given = TRUE; + break; + case B3SOIPD_MOD_WDVT0W: + mod->B3SOIPDwdvt0w = value->rValue; + mod->B3SOIPDwdvt0wGiven = TRUE; + break; + case B3SOIPD_MOD_WDVT1W: + mod->B3SOIPDwdvt1w = value->rValue; + mod->B3SOIPDwdvt1wGiven = TRUE; + break; + case B3SOIPD_MOD_WDVT2W: + mod->B3SOIPDwdvt2w = value->rValue; + mod->B3SOIPDwdvt2wGiven = TRUE; + break; + case B3SOIPD_MOD_WU0: + mod->B3SOIPDwu0 = value->rValue; + mod->B3SOIPDwu0Given = TRUE; + break; + case B3SOIPD_MOD_WUA: + mod->B3SOIPDwua = value->rValue; + mod->B3SOIPDwuaGiven = TRUE; + break; + case B3SOIPD_MOD_WUB: + mod->B3SOIPDwub = value->rValue; + mod->B3SOIPDwubGiven = TRUE; + break; + case B3SOIPD_MOD_WUC: + mod->B3SOIPDwuc = value->rValue; + mod->B3SOIPDwucGiven = TRUE; + break; + case B3SOIPD_MOD_WVSAT: + mod->B3SOIPDwvsat = value->rValue; + mod->B3SOIPDwvsatGiven = TRUE; + break; + case B3SOIPD_MOD_WA0: + mod->B3SOIPDwa0 = value->rValue; + mod->B3SOIPDwa0Given = TRUE; + break; + case B3SOIPD_MOD_WAGS: + mod->B3SOIPDwags = value->rValue; + mod->B3SOIPDwagsGiven = TRUE; + break; + case B3SOIPD_MOD_WB0: + mod->B3SOIPDwb0 = value->rValue; + mod->B3SOIPDwb0Given = TRUE; + break; + case B3SOIPD_MOD_WB1: + mod->B3SOIPDwb1 = value->rValue; + mod->B3SOIPDwb1Given = TRUE; + break; + case B3SOIPD_MOD_WKETA: + mod->B3SOIPDwketa = value->rValue; + mod->B3SOIPDwketaGiven = TRUE; + break; + case B3SOIPD_MOD_WKETAS: + mod->B3SOIPDwketas = value->rValue; + mod->B3SOIPDwketasGiven = TRUE; + break; + case B3SOIPD_MOD_WA1: + mod->B3SOIPDwa1 = value->rValue; + mod->B3SOIPDwa1Given = TRUE; + break; + case B3SOIPD_MOD_WA2: + mod->B3SOIPDwa2 = value->rValue; + mod->B3SOIPDwa2Given = TRUE; + break; + case B3SOIPD_MOD_WRDSW: + mod->B3SOIPDwrdsw = value->rValue; + mod->B3SOIPDwrdswGiven = TRUE; + break; + case B3SOIPD_MOD_WPRWB: + mod->B3SOIPDwprwb = value->rValue; + mod->B3SOIPDwprwbGiven = TRUE; + break; + case B3SOIPD_MOD_WPRWG: + mod->B3SOIPDwprwg = value->rValue; + mod->B3SOIPDwprwgGiven = TRUE; + break; + case B3SOIPD_MOD_WWR: + mod->B3SOIPDwwr = value->rValue; + mod->B3SOIPDwwrGiven = TRUE; + break; + case B3SOIPD_MOD_WNFACTOR: + mod->B3SOIPDwnfactor = value->rValue; + mod->B3SOIPDwnfactorGiven = TRUE; + break; + case B3SOIPD_MOD_WDWG: + mod->B3SOIPDwdwg = value->rValue; + mod->B3SOIPDwdwgGiven = TRUE; + break; + case B3SOIPD_MOD_WDWB: + mod->B3SOIPDwdwb = value->rValue; + mod->B3SOIPDwdwbGiven = TRUE; + break; + case B3SOIPD_MOD_WVOFF: + mod->B3SOIPDwvoff = value->rValue; + mod->B3SOIPDwvoffGiven = TRUE; + break; + case B3SOIPD_MOD_WETA0: + mod->B3SOIPDweta0 = value->rValue; + mod->B3SOIPDweta0Given = TRUE; + break; + case B3SOIPD_MOD_WETAB: + mod->B3SOIPDwetab = value->rValue; + mod->B3SOIPDwetabGiven = TRUE; + break; + case B3SOIPD_MOD_WDSUB: + mod->B3SOIPDwdsub = value->rValue; + mod->B3SOIPDwdsubGiven = TRUE; + break; + case B3SOIPD_MOD_WCIT: + mod->B3SOIPDwcit = value->rValue; + mod->B3SOIPDwcitGiven = TRUE; + break; + case B3SOIPD_MOD_WCDSC: + mod->B3SOIPDwcdsc = value->rValue; + mod->B3SOIPDwcdscGiven = TRUE; + break; + case B3SOIPD_MOD_WCDSCB: + mod->B3SOIPDwcdscb = value->rValue; + mod->B3SOIPDwcdscbGiven = TRUE; + break; + case B3SOIPD_MOD_WCDSCD: + mod->B3SOIPDwcdscd = value->rValue; + mod->B3SOIPDwcdscdGiven = TRUE; + break; + case B3SOIPD_MOD_WPCLM: + mod->B3SOIPDwpclm = value->rValue; + mod->B3SOIPDwpclmGiven = TRUE; + break; + case B3SOIPD_MOD_WPDIBL1: + mod->B3SOIPDwpdibl1 = value->rValue; + mod->B3SOIPDwpdibl1Given = TRUE; + break; + case B3SOIPD_MOD_WPDIBL2: + mod->B3SOIPDwpdibl2 = value->rValue; + mod->B3SOIPDwpdibl2Given = TRUE; + break; + case B3SOIPD_MOD_WPDIBLB: + mod->B3SOIPDwpdiblb = value->rValue; + mod->B3SOIPDwpdiblbGiven = TRUE; + break; + case B3SOIPD_MOD_WDROUT: + mod->B3SOIPDwdrout = value->rValue; + mod->B3SOIPDwdroutGiven = TRUE; + break; + case B3SOIPD_MOD_WPVAG: + mod->B3SOIPDwpvag = value->rValue; + mod->B3SOIPDwpvagGiven = TRUE; + break; + case B3SOIPD_MOD_WDELTA: + mod->B3SOIPDwdelta = value->rValue; + mod->B3SOIPDwdeltaGiven = TRUE; + break; + case B3SOIPD_MOD_WALPHA0: + mod->B3SOIPDwalpha0 = value->rValue; + mod->B3SOIPDwalpha0Given = TRUE; + break; + case B3SOIPD_MOD_WFBJTII: + mod->B3SOIPDwfbjtii = value->rValue; + mod->B3SOIPDwfbjtiiGiven = TRUE; + break; + case B3SOIPD_MOD_WBETA0: + mod->B3SOIPDwbeta0 = value->rValue; + mod->B3SOIPDwbeta0Given = TRUE; + break; + case B3SOIPD_MOD_WBETA1: + mod->B3SOIPDwbeta1 = value->rValue; + mod->B3SOIPDwbeta1Given = TRUE; + break; + case B3SOIPD_MOD_WBETA2: + mod->B3SOIPDwbeta2 = value->rValue; + mod->B3SOIPDwbeta2Given = TRUE; + break; + case B3SOIPD_MOD_WVDSATII0: + mod->B3SOIPDwvdsatii0 = value->rValue; + mod->B3SOIPDwvdsatii0Given = TRUE; + break; + case B3SOIPD_MOD_WLII: + mod->B3SOIPDwlii = value->rValue; + mod->B3SOIPDwliiGiven = TRUE; + break; + case B3SOIPD_MOD_WESATII: + mod->B3SOIPDwesatii = value->rValue; + mod->B3SOIPDwesatiiGiven = TRUE; + break; + case B3SOIPD_MOD_WSII0: + mod->B3SOIPDwsii0 = value->rValue; + mod->B3SOIPDwsii0Given = TRUE; + break; + case B3SOIPD_MOD_WSII1: + mod->B3SOIPDwsii1 = value->rValue; + mod->B3SOIPDwsii1Given = TRUE; + break; + case B3SOIPD_MOD_WSII2: + mod->B3SOIPDwsii2 = value->rValue; + mod->B3SOIPDwsii2Given = TRUE; + break; + case B3SOIPD_MOD_WSIID: + mod->B3SOIPDwsiid = value->rValue; + mod->B3SOIPDwsiidGiven = TRUE; + break; + case B3SOIPD_MOD_WAGIDL: + mod->B3SOIPDwagidl = value->rValue; + mod->B3SOIPDwagidlGiven = TRUE; + break; + case B3SOIPD_MOD_WBGIDL: + mod->B3SOIPDwbgidl = value->rValue; + mod->B3SOIPDwbgidlGiven = TRUE; + break; + case B3SOIPD_MOD_WNGIDL: + mod->B3SOIPDwngidl = value->rValue; + mod->B3SOIPDwngidlGiven = TRUE; + break; + case B3SOIPD_MOD_WNTUN: + mod->B3SOIPDwntun = value->rValue; + mod->B3SOIPDwntunGiven = TRUE; + break; + case B3SOIPD_MOD_WNDIODE: + mod->B3SOIPDwndiode = value->rValue; + mod->B3SOIPDwndiodeGiven = TRUE; + break; + case B3SOIPD_MOD_WNRECF0: + mod->B3SOIPDwnrecf0 = value->rValue; + mod->B3SOIPDwnrecf0Given = TRUE; + break; + case B3SOIPD_MOD_WNRECR0: + mod->B3SOIPDwnrecr0 = value->rValue; + mod->B3SOIPDwnrecr0Given = TRUE; + break; + case B3SOIPD_MOD_WISBJT: + mod->B3SOIPDwisbjt = value->rValue; + mod->B3SOIPDwisbjtGiven = TRUE; + break; + case B3SOIPD_MOD_WISDIF: + mod->B3SOIPDwisdif = value->rValue; + mod->B3SOIPDwisdifGiven = TRUE; + break; + case B3SOIPD_MOD_WISREC: + mod->B3SOIPDwisrec = value->rValue; + mod->B3SOIPDwisrecGiven = TRUE; + break; + case B3SOIPD_MOD_WISTUN: + mod->B3SOIPDwistun = value->rValue; + mod->B3SOIPDwistunGiven = TRUE; + break; + case B3SOIPD_MOD_WVREC0: + mod->B3SOIPDwvrec0 = value->rValue; + mod->B3SOIPDwvrec0Given = TRUE; + break; + case B3SOIPD_MOD_WVTUN0: + mod->B3SOIPDwvtun0 = value->rValue; + mod->B3SOIPDwvtun0Given = TRUE; + break; + case B3SOIPD_MOD_WNBJT: + mod->B3SOIPDwnbjt = value->rValue; + mod->B3SOIPDwnbjtGiven = TRUE; + break; + case B3SOIPD_MOD_WLBJT0: + mod->B3SOIPDwlbjt0 = value->rValue; + mod->B3SOIPDwlbjt0Given = TRUE; + break; + case B3SOIPD_MOD_WVABJT: + mod->B3SOIPDwvabjt = value->rValue; + mod->B3SOIPDwvabjtGiven = TRUE; + break; + case B3SOIPD_MOD_WAELY: + mod->B3SOIPDwaely = value->rValue; + mod->B3SOIPDwaelyGiven = TRUE; + break; + case B3SOIPD_MOD_WAHLI: + mod->B3SOIPDwahli = value->rValue; + mod->B3SOIPDwahliGiven = TRUE; + break; + /* CV Model */ + case B3SOIPD_MOD_WVSDFB: + mod->B3SOIPDwvsdfb = value->rValue; + mod->B3SOIPDwvsdfbGiven = TRUE; + break; + case B3SOIPD_MOD_WVSDTH: + mod->B3SOIPDwvsdth = value->rValue; + mod->B3SOIPDwvsdthGiven = TRUE; + break; + case B3SOIPD_MOD_WDELVT: + mod->B3SOIPDwdelvt = value->rValue; + mod->B3SOIPDwdelvtGiven = TRUE; + break; + case B3SOIPD_MOD_WACDE: + mod->B3SOIPDwacde = value->rValue; + mod->B3SOIPDwacdeGiven = TRUE; + break; + case B3SOIPD_MOD_WMOIN: + mod->B3SOIPDwmoin = value->rValue; + mod->B3SOIPDwmoinGiven = TRUE; + break; + + /* Cross-term Dependence */ + case B3SOIPD_MOD_PNPEAK: + mod->B3SOIPDpnpeak = value->rValue; + mod->B3SOIPDpnpeakGiven = TRUE; + break; + case B3SOIPD_MOD_PNSUB: + mod->B3SOIPDpnsub = value->rValue; + mod->B3SOIPDpnsubGiven = TRUE; + break; + case B3SOIPD_MOD_PNGATE: + mod->B3SOIPDpngate = value->rValue; + mod->B3SOIPDpngateGiven = TRUE; + break; + case B3SOIPD_MOD_PVTH0: + mod->B3SOIPDpvth0 = value->rValue; + mod->B3SOIPDpvth0Given = TRUE; + break; + case B3SOIPD_MOD_PK1: + mod->B3SOIPDpk1 = value->rValue; + mod->B3SOIPDpk1Given = TRUE; + break; + case B3SOIPD_MOD_PK1W1: + mod->B3SOIPDpk1w1 = value->rValue; + mod->B3SOIPDpk1w1Given = TRUE; + break; + case B3SOIPD_MOD_PK1W2: + mod->B3SOIPDpk1w2 = value->rValue; + mod->B3SOIPDpk1w2Given = TRUE; + break; + case B3SOIPD_MOD_PK2: + mod->B3SOIPDpk2 = value->rValue; + mod->B3SOIPDpk2Given = TRUE; + break; + case B3SOIPD_MOD_PK3: + mod->B3SOIPDpk3 = value->rValue; + mod->B3SOIPDpk3Given = TRUE; + break; + case B3SOIPD_MOD_PK3B: + mod->B3SOIPDpk3b = value->rValue; + mod->B3SOIPDpk3bGiven = TRUE; + break; + case B3SOIPD_MOD_PKB1: + mod->B3SOIPDpkb1 = value->rValue; + mod->B3SOIPDpkb1Given = TRUE; + break; + case B3SOIPD_MOD_PW0: + mod->B3SOIPDpw0 = value->rValue; + mod->B3SOIPDpw0Given = TRUE; + break; + case B3SOIPD_MOD_PNLX: + mod->B3SOIPDpnlx = value->rValue; + mod->B3SOIPDpnlxGiven = TRUE; + break; + case B3SOIPD_MOD_PDVT0: + mod->B3SOIPDpdvt0 = value->rValue; + mod->B3SOIPDpdvt0Given = TRUE; + break; + case B3SOIPD_MOD_PDVT1: + mod->B3SOIPDpdvt1 = value->rValue; + mod->B3SOIPDpdvt1Given = TRUE; + break; + case B3SOIPD_MOD_PDVT2: + mod->B3SOIPDpdvt2 = value->rValue; + mod->B3SOIPDpdvt2Given = TRUE; + break; + case B3SOIPD_MOD_PDVT0W: + mod->B3SOIPDpdvt0w = value->rValue; + mod->B3SOIPDpdvt0wGiven = TRUE; + break; + case B3SOIPD_MOD_PDVT1W: + mod->B3SOIPDpdvt1w = value->rValue; + mod->B3SOIPDpdvt1wGiven = TRUE; + break; + case B3SOIPD_MOD_PDVT2W: + mod->B3SOIPDpdvt2w = value->rValue; + mod->B3SOIPDpdvt2wGiven = TRUE; + break; + case B3SOIPD_MOD_PU0: + mod->B3SOIPDpu0 = value->rValue; + mod->B3SOIPDpu0Given = TRUE; + break; + case B3SOIPD_MOD_PUA: + mod->B3SOIPDpua = value->rValue; + mod->B3SOIPDpuaGiven = TRUE; + break; + case B3SOIPD_MOD_PUB: + mod->B3SOIPDpub = value->rValue; + mod->B3SOIPDpubGiven = TRUE; + break; + case B3SOIPD_MOD_PUC: + mod->B3SOIPDpuc = value->rValue; + mod->B3SOIPDpucGiven = TRUE; + break; + case B3SOIPD_MOD_PVSAT: + mod->B3SOIPDpvsat = value->rValue; + mod->B3SOIPDpvsatGiven = TRUE; + break; + case B3SOIPD_MOD_PA0: + mod->B3SOIPDpa0 = value->rValue; + mod->B3SOIPDpa0Given = TRUE; + break; + case B3SOIPD_MOD_PAGS: + mod->B3SOIPDpags = value->rValue; + mod->B3SOIPDpagsGiven = TRUE; + break; + case B3SOIPD_MOD_PB0: + mod->B3SOIPDpb0 = value->rValue; + mod->B3SOIPDpb0Given = TRUE; + break; + case B3SOIPD_MOD_PB1: + mod->B3SOIPDpb1 = value->rValue; + mod->B3SOIPDpb1Given = TRUE; + break; + case B3SOIPD_MOD_PKETA: + mod->B3SOIPDpketa = value->rValue; + mod->B3SOIPDpketaGiven = TRUE; + break; + case B3SOIPD_MOD_PKETAS: + mod->B3SOIPDpketas = value->rValue; + mod->B3SOIPDpketasGiven = TRUE; + break; + case B3SOIPD_MOD_PA1: + mod->B3SOIPDpa1 = value->rValue; + mod->B3SOIPDpa1Given = TRUE; + break; + case B3SOIPD_MOD_PA2: + mod->B3SOIPDpa2 = value->rValue; + mod->B3SOIPDpa2Given = TRUE; + break; + case B3SOIPD_MOD_PRDSW: + mod->B3SOIPDprdsw = value->rValue; + mod->B3SOIPDprdswGiven = TRUE; + break; + case B3SOIPD_MOD_PPRWB: + mod->B3SOIPDpprwb = value->rValue; + mod->B3SOIPDpprwbGiven = TRUE; + break; + case B3SOIPD_MOD_PPRWG: + mod->B3SOIPDpprwg = value->rValue; + mod->B3SOIPDpprwgGiven = TRUE; + break; + case B3SOIPD_MOD_PWR: + mod->B3SOIPDpwr = value->rValue; + mod->B3SOIPDpwrGiven = TRUE; + break; + case B3SOIPD_MOD_PNFACTOR: + mod->B3SOIPDpnfactor = value->rValue; + mod->B3SOIPDpnfactorGiven = TRUE; + break; + case B3SOIPD_MOD_PDWG: + mod->B3SOIPDpdwg = value->rValue; + mod->B3SOIPDpdwgGiven = TRUE; + break; + case B3SOIPD_MOD_PDWB: + mod->B3SOIPDpdwb = value->rValue; + mod->B3SOIPDpdwbGiven = TRUE; + break; + case B3SOIPD_MOD_PVOFF: + mod->B3SOIPDpvoff = value->rValue; + mod->B3SOIPDpvoffGiven = TRUE; + break; + case B3SOIPD_MOD_PETA0: + mod->B3SOIPDpeta0 = value->rValue; + mod->B3SOIPDpeta0Given = TRUE; + break; + case B3SOIPD_MOD_PETAB: + mod->B3SOIPDpetab = value->rValue; + mod->B3SOIPDpetabGiven = TRUE; + break; + case B3SOIPD_MOD_PDSUB: + mod->B3SOIPDpdsub = value->rValue; + mod->B3SOIPDpdsubGiven = TRUE; + break; + case B3SOIPD_MOD_PCIT: + mod->B3SOIPDpcit = value->rValue; + mod->B3SOIPDpcitGiven = TRUE; + break; + case B3SOIPD_MOD_PCDSC: + mod->B3SOIPDpcdsc = value->rValue; + mod->B3SOIPDpcdscGiven = TRUE; + break; + case B3SOIPD_MOD_PCDSCB: + mod->B3SOIPDpcdscb = value->rValue; + mod->B3SOIPDpcdscbGiven = TRUE; + break; + case B3SOIPD_MOD_PCDSCD: + mod->B3SOIPDpcdscd = value->rValue; + mod->B3SOIPDpcdscdGiven = TRUE; + break; + case B3SOIPD_MOD_PPCLM: + mod->B3SOIPDppclm = value->rValue; + mod->B3SOIPDppclmGiven = TRUE; + break; + case B3SOIPD_MOD_PPDIBL1: + mod->B3SOIPDppdibl1 = value->rValue; + mod->B3SOIPDppdibl1Given = TRUE; + break; + case B3SOIPD_MOD_PPDIBL2: + mod->B3SOIPDppdibl2 = value->rValue; + mod->B3SOIPDppdibl2Given = TRUE; + break; + case B3SOIPD_MOD_PPDIBLB: + mod->B3SOIPDppdiblb = value->rValue; + mod->B3SOIPDppdiblbGiven = TRUE; + break; + case B3SOIPD_MOD_PDROUT: + mod->B3SOIPDpdrout = value->rValue; + mod->B3SOIPDpdroutGiven = TRUE; + break; + case B3SOIPD_MOD_PPVAG: + mod->B3SOIPDppvag = value->rValue; + mod->B3SOIPDppvagGiven = TRUE; + break; + case B3SOIPD_MOD_PDELTA: + mod->B3SOIPDpdelta = value->rValue; + mod->B3SOIPDpdeltaGiven = TRUE; + break; + case B3SOIPD_MOD_PALPHA0: + mod->B3SOIPDpalpha0 = value->rValue; + mod->B3SOIPDpalpha0Given = TRUE; + break; + case B3SOIPD_MOD_PFBJTII: + mod->B3SOIPDpfbjtii = value->rValue; + mod->B3SOIPDpfbjtiiGiven = TRUE; + break; + case B3SOIPD_MOD_PBETA0: + mod->B3SOIPDpbeta0 = value->rValue; + mod->B3SOIPDpbeta0Given = TRUE; + break; + case B3SOIPD_MOD_PBETA1: + mod->B3SOIPDpbeta1 = value->rValue; + mod->B3SOIPDpbeta1Given = TRUE; + break; + case B3SOIPD_MOD_PBETA2: + mod->B3SOIPDpbeta2 = value->rValue; + mod->B3SOIPDpbeta2Given = TRUE; + break; + case B3SOIPD_MOD_PVDSATII0: + mod->B3SOIPDpvdsatii0 = value->rValue; + mod->B3SOIPDpvdsatii0Given = TRUE; + break; + case B3SOIPD_MOD_PLII: + mod->B3SOIPDplii = value->rValue; + mod->B3SOIPDpliiGiven = TRUE; + break; + case B3SOIPD_MOD_PESATII: + mod->B3SOIPDpesatii = value->rValue; + mod->B3SOIPDpesatiiGiven = TRUE; + break; + case B3SOIPD_MOD_PSII0: + mod->B3SOIPDpsii0 = value->rValue; + mod->B3SOIPDpsii0Given = TRUE; + break; + case B3SOIPD_MOD_PSII1: + mod->B3SOIPDpsii1 = value->rValue; + mod->B3SOIPDpsii1Given = TRUE; + break; + case B3SOIPD_MOD_PSII2: + mod->B3SOIPDpsii2 = value->rValue; + mod->B3SOIPDpsii2Given = TRUE; + break; + case B3SOIPD_MOD_PSIID: + mod->B3SOIPDpsiid = value->rValue; + mod->B3SOIPDpsiidGiven = TRUE; + break; + case B3SOIPD_MOD_PAGIDL: + mod->B3SOIPDpagidl = value->rValue; + mod->B3SOIPDpagidlGiven = TRUE; + break; + case B3SOIPD_MOD_PBGIDL: + mod->B3SOIPDpbgidl = value->rValue; + mod->B3SOIPDpbgidlGiven = TRUE; + break; + case B3SOIPD_MOD_PNGIDL: + mod->B3SOIPDpngidl = value->rValue; + mod->B3SOIPDpngidlGiven = TRUE; + break; + case B3SOIPD_MOD_PNTUN: + mod->B3SOIPDpntun = value->rValue; + mod->B3SOIPDpntunGiven = TRUE; + break; + case B3SOIPD_MOD_PNDIODE: + mod->B3SOIPDpndiode = value->rValue; + mod->B3SOIPDpndiodeGiven = TRUE; + break; + case B3SOIPD_MOD_PNRECF0: + mod->B3SOIPDpnrecf0 = value->rValue; + mod->B3SOIPDpnrecf0Given = TRUE; + break; + case B3SOIPD_MOD_PNRECR0: + mod->B3SOIPDpnrecr0 = value->rValue; + mod->B3SOIPDpnrecr0Given = TRUE; + break; + case B3SOIPD_MOD_PISBJT: + mod->B3SOIPDpisbjt = value->rValue; + mod->B3SOIPDpisbjtGiven = TRUE; + break; + case B3SOIPD_MOD_PISDIF: + mod->B3SOIPDpisdif = value->rValue; + mod->B3SOIPDpisdifGiven = TRUE; + break; + case B3SOIPD_MOD_PISREC: + mod->B3SOIPDpisrec = value->rValue; + mod->B3SOIPDpisrecGiven = TRUE; + break; + case B3SOIPD_MOD_PISTUN: + mod->B3SOIPDpistun = value->rValue; + mod->B3SOIPDpistunGiven = TRUE; + break; + case B3SOIPD_MOD_PVREC0: + mod->B3SOIPDpvrec0 = value->rValue; + mod->B3SOIPDpvrec0Given = TRUE; + break; + case B3SOIPD_MOD_PVTUN0: + mod->B3SOIPDpvtun0 = value->rValue; + mod->B3SOIPDpvtun0Given = TRUE; + break; + case B3SOIPD_MOD_PNBJT: + mod->B3SOIPDpnbjt = value->rValue; + mod->B3SOIPDpnbjtGiven = TRUE; + break; + case B3SOIPD_MOD_PLBJT0: + mod->B3SOIPDplbjt0 = value->rValue; + mod->B3SOIPDplbjt0Given = TRUE; + break; + case B3SOIPD_MOD_PVABJT: + mod->B3SOIPDpvabjt = value->rValue; + mod->B3SOIPDpvabjtGiven = TRUE; + break; + case B3SOIPD_MOD_PAELY: + mod->B3SOIPDpaely = value->rValue; + mod->B3SOIPDpaelyGiven = TRUE; + break; + case B3SOIPD_MOD_PAHLI: + mod->B3SOIPDpahli = value->rValue; + mod->B3SOIPDpahliGiven = TRUE; + break; + /* CV Model */ + case B3SOIPD_MOD_PVSDFB: + mod->B3SOIPDpvsdfb = value->rValue; + mod->B3SOIPDpvsdfbGiven = TRUE; + break; + case B3SOIPD_MOD_PVSDTH: + mod->B3SOIPDpvsdth = value->rValue; + mod->B3SOIPDpvsdthGiven = TRUE; + break; + case B3SOIPD_MOD_PDELVT: + mod->B3SOIPDpdelvt = value->rValue; + mod->B3SOIPDpdelvtGiven = TRUE; + break; + case B3SOIPD_MOD_PACDE: + mod->B3SOIPDpacde = value->rValue; + mod->B3SOIPDpacdeGiven = TRUE; + break; + case B3SOIPD_MOD_PMOIN: + mod->B3SOIPDpmoin = value->rValue; + mod->B3SOIPDpmoinGiven = TRUE; + break; +/* Added for binning - END */ + + case B3SOIPD_MOD_NMOS: + if (value->iValue) + { + mod->B3SOIPDtype = 1; + mod->B3SOIPDtypeGiven = TRUE; + } + break; + case B3SOIPD_MOD_PMOS: + if (value->iValue) + { + mod->B3SOIPDtype = -1; + mod->B3SOIPDtypeGiven = TRUE; + } + break; + default: + return (E_BADPARM); + } + return (OK); +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdnoi.c b/src/spicelib/devices/bsim3soi_pd/b3soipdnoi.c new file mode 100644 index 000000000..e67d3b37c --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdnoi.c @@ -0,0 +1,432 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdnoi.c 98/5/01 +**********/ + +#include "ngspice.h" +#include +#include +#include "b3soipddef.h" +#include "cktdefs.h" +#include "iferrmsg.h" +#include "noisedef.h" +#include "suffix.h" +#include "const.h" /* jwan */ + +/* + * B3SOIPDnoise (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->B3SOIPDnoiMod. + If model->B3SOIPDnoiMod = 1, + Channel thermal noise = SPICE2 model + Flicker noise = SPICE2 model + If model->B3SOIPDnoiMod = 2, + Channel thermal noise = B3SOIPD model + Flicker noise = B3SOIPD model + If model->B3SOIPDnoiMod = 3, + Channel thermal noise = SPICE2 model + Flicker noise = B3SOIPD model + If model->B3SOIPDnoiMod = 4, + Channel thermal noise = B3SOIPD model + Flicker noise = SPICE2 model + */ + +extern void NevalSrc (); +extern double Nintegrate (); + +double +B3SOIPDStrongInversionNoiseEval (vgs, vds, model, here, freq, temp) + double vgs, vds, freq, temp; + B3SOIPDmodel *model; + B3SOIPDinstance *here; +{ + struct b3soipdSizeDependParam *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->B3SOIPDcd); + if (vds > here->B3SOIPDvdsat) + { + esat = 2.0 * pParam->B3SOIPDvsattemp / here->B3SOIPDueff; + T0 = + ((((vds + - here->B3SOIPDvdsat) / pParam->B3SOIPDlitl) + + model->B3SOIPDem) / esat); + DelClm = pParam->B3SOIPDlitl * log (MAX (T0, N_MINLOG)); + } + else + DelClm = 0.0; + EffFreq = pow (freq, model->B3SOIPDef); + T1 = CHARGE * CHARGE * 8.62e-5 * cd * temp * here->B3SOIPDueff; + T2 = 1.0e8 * EffFreq * model->B3SOIPDcox + * pParam->B3SOIPDleff * pParam->B3SOIPDleff; + Vgst = vgs - here->B3SOIPDvon; + N0 = model->B3SOIPDcox * Vgst / CHARGE; + if (N0 < 0.0) + N0 = 0.0; + Nl = model->B3SOIPDcox * (Vgst - MIN (vds, here->B3SOIPDvdsat)) / CHARGE; + if (Nl < 0.0) + Nl = 0.0; + + T3 = model->B3SOIPDoxideTrapDensityA + * log (MAX (((N0 + 2.0e14) / (Nl + 2.0e14)), N_MINLOG)); + T4 = model->B3SOIPDoxideTrapDensityB * (N0 - Nl); + T5 = model->B3SOIPDoxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl); + + T6 = 8.62e-5 * temp * cd * cd; + T7 = 1.0e8 * EffFreq * pParam->B3SOIPDleff + * pParam->B3SOIPDleff * pParam->B3SOIPDweff; + T8 = model->B3SOIPDoxideTrapDensityA + model->B3SOIPDoxideTrapDensityB * Nl + + model->B3SOIPDoxideTrapDensityC * Nl * Nl; + T9 = (Nl + 2.0e14) * (Nl + 2.0e14); + + Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9; + + return Ssi; +} + +int +B3SOIPDnoise (mode, operation, inModel, ckt, data, OnDens) + int mode, operation; + GENmodel *inModel; + CKTcircuit *ckt; + register Ndata *data; + double *OnDens; +{ + register B3SOIPDmodel *model = (B3SOIPDmodel *) inModel; + register B3SOIPDinstance *here; + struct b3soipdSizeDependParam *pParam; + char name[N_MXVLNTH]; + double tempOnoise; + double tempInoise; + double noizDens[B3SOIPDNSRCS]; + double lnNdens[B3SOIPDNSRCS]; + + 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 *B3SOIPDnNames[B3SOIPDNSRCS] = { /* Note that we have to keep the order */ + ".rd", /* noise due to rd */ + /* consistent with the index definitions */ + ".rs", /* noise due to rs */ + /* in B3SOIPDdefs.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->B3SOIPDnextModel) + { + for (here = model->B3SOIPDinstances; here != NULL; + here = here->B3SOIPDnextInstance) + { + 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 < B3SOIPDNSRCS; i++) + { + (void) sprintf (name, "onoise.%s%s", + here->B3SOIPDname, + B3SOIPDnNames[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 < B3SOIPDNSRCS; i++) + { + (void) sprintf (name, "onoise_total.%s%s", + here->B3SOIPDname, + B3SOIPDnNames[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->B3SOIPDname, + B3SOIPDnNames[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[B3SOIPDRDNOIZ], + &lnNdens[B3SOIPDRDNOIZ], ckt, THERMNOISE, + here->B3SOIPDdNodePrime, here->B3SOIPDdNode, + here->B3SOIPDdrainConductance); + + NevalSrc (&noizDens[B3SOIPDRSNOIZ], + &lnNdens[B3SOIPDRSNOIZ], ckt, THERMNOISE, + here->B3SOIPDsNodePrime, here->B3SOIPDsNode, + here->B3SOIPDsourceConductance); + + switch (model->B3SOIPDnoiMod) + { + case 1: + case 3: + NevalSrc (&noizDens[B3SOIPDIDNOIZ], + &lnNdens[B3SOIPDIDNOIZ], ckt, + THERMNOISE, here->B3SOIPDdNodePrime, + here->B3SOIPDsNodePrime, + (2.0 / 3.0 * fabs (here->B3SOIPDgm + + here->B3SOIPDgds + + here->B3SOIPDgmbs))); + break; + case 2: + case 4: + NevalSrc (&noizDens[B3SOIPDIDNOIZ], + &lnNdens[B3SOIPDIDNOIZ], ckt, + THERMNOISE, here->B3SOIPDdNodePrime, + here->B3SOIPDsNodePrime, + (here->B3SOIPDueff + * fabs (here->B3SOIPDqinv + / (pParam->B3SOIPDleff + * pParam->B3SOIPDleff)))); + break; + } + NevalSrc (&noizDens[B3SOIPDFLNOIZ], (double *) NULL, + ckt, N_GAIN, here->B3SOIPDdNodePrime, + here->B3SOIPDsNodePrime, (double) 0.0); + + switch (model->B3SOIPDnoiMod) + { + case 1: + case 4: + noizDens[B3SOIPDFLNOIZ] *= model->B3SOIPDkf + * exp (model->B3SOIPDaf + * log (MAX (fabs (here->B3SOIPDcd), + N_MINLOG))) + / (pow (data->freq, model->B3SOIPDef) + * pParam->B3SOIPDleff + * pParam->B3SOIPDleff * model->B3SOIPDcox); + break; + case 2: + case 3: + vgs = *(ckt->CKTstates[0] + here->B3SOIPDvgs); + vds = *(ckt->CKTstates[0] + here->B3SOIPDvds); + if (vds < 0.0) + { + vds = -vds; + vgs = vgs + vds; + } + if (vgs >= here->B3SOIPDvon + 0.1) + { + Ssi = B3SOIPDStrongInversionNoiseEval (vgs, + vds, model, + here, + data->freq, + ckt-> + CKTtemp); + noizDens[B3SOIPDFLNOIZ] *= Ssi; + } + else + { + pParam = here->pParam; + T10 = model->B3SOIPDoxideTrapDensityA + * 8.62e-5 * ckt->CKTtemp; + T11 = pParam->B3SOIPDweff + * pParam->B3SOIPDleff + * pow (data->freq, model->B3SOIPDef) * 4.0e36; + Swi = T10 / T11 * here->B3SOIPDcd * here->B3SOIPDcd; + Slimit = + B3SOIPDStrongInversionNoiseEval (here-> + B3SOIPDvon + 0.1, + vds, model, here, + data->freq, + ckt->CKTtemp); + T1 = Swi + Slimit; + if (T1 > 0.0) + noizDens[B3SOIPDFLNOIZ] *= (Slimit * Swi) / T1; + else + noizDens[B3SOIPDFLNOIZ] *= 0.0; + } + break; + } + + lnNdens[B3SOIPDFLNOIZ] = + log (MAX (noizDens[B3SOIPDFLNOIZ], N_MINLOG)); + + /* Low frequency excess noise due to FBE */ + NevalSrc (&noizDens[B3SOIPDFBNOIZ], &lnNdens[B3SOIPDFBNOIZ], + ckt, SHOTNOISE, here->B3SOIPDsNodePrime, + here->B3SOIPDbNode, + 2.0 * model->B3SOIPDnoif * here->B3SOIPDibs); + + noizDens[B3SOIPDTOTNOIZ] = noizDens[B3SOIPDRDNOIZ] + + noizDens[B3SOIPDRSNOIZ] + + noizDens[B3SOIPDIDNOIZ] + + noizDens[B3SOIPDFLNOIZ] + noizDens[B3SOIPDFBNOIZ]; + lnNdens[B3SOIPDTOTNOIZ] = + log (MAX (noizDens[B3SOIPDTOTNOIZ], N_MINLOG)); + + *OnDens += noizDens[B3SOIPDTOTNOIZ]; + + if (data->delFreq == 0.0) + { /* if we haven't done any previous + integration, we need to initialize our + "history" variables. + */ + + for (i = 0; i < B3SOIPDNSRCS; i++) + { + here->B3SOIPDnVar[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 < B3SOIPDNSRCS; i++) + { + here->B3SOIPDnVar[OUTNOIZ][i] = 0.0; + here->B3SOIPDnVar[INNOIZ][i] = 0.0; + } + } + } + else + { /* data->delFreq != 0.0, + we have to integrate. + */ + for (i = 0; i < B3SOIPDNSRCS; i++) + { + if (i != B3SOIPDTOTNOIZ) + { + tempOnoise = Nintegrate (noizDens[i], + lnNdens[i], + here-> + B3SOIPDnVar[LNLSTDENS] + [i], data); + tempInoise = + Nintegrate (noizDens[i] * data->GainSqInv, + lnNdens[i] + data->lnGainInv, + here->B3SOIPDnVar[LNLSTDENS][i] + + data->lnGainInv, data); + here->B3SOIPDnVar[LNLSTDENS][i] = lnNdens[i]; + data->outNoiz += tempOnoise; + data->inNoise += tempInoise; + if (((NOISEAN *) ckt->CKTcurJob)->NStpsSm != 0) + { + here->B3SOIPDnVar[OUTNOIZ][i] += tempOnoise; + here->B3SOIPDnVar[OUTNOIZ][B3SOIPDTOTNOIZ] + += tempOnoise; + here->B3SOIPDnVar[INNOIZ][i] += tempInoise; + here->B3SOIPDnVar[INNOIZ][B3SOIPDTOTNOIZ] + += tempInoise; + } + } + } + } + if (data->prtSummary) + { + for (i = 0; i < B3SOIPDNSRCS; 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 < B3SOIPDNSRCS; i++) + { + data->outpVector[data->outNumber++] + = here->B3SOIPDnVar[OUTNOIZ][i]; + data->outpVector[data->outNumber++] + = here->B3SOIPDnVar[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_pd/b3soipdpar.c b/src/spicelib/devices/bsim3soi_pd/b3soipdpar.c new file mode 100644 index 000000000..44f300b1b --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdpar.c @@ -0,0 +1,166 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdpar.c 98/5/01 +Modified by Pin Su 99/2/15 +**********/ + + +#include "ngspice.h" +#include +#include "ifsim.h" +#include "b3soipddef.h" +#include "sperror.h" +#include "suffix.h" + +int +B3SOIPDparam (param, value, inst, select) + int param; + IFvalue *value; + GENinstance *inst; + IFvalue *select; +{ + B3SOIPDinstance *here = (B3SOIPDinstance *) inst; + switch (param) + { + case B3SOIPD_W: + here->B3SOIPDw = value->rValue; + here->B3SOIPDwGiven = TRUE; + break; + case B3SOIPD_L: + here->B3SOIPDl = value->rValue; + here->B3SOIPDlGiven = TRUE; + break; + case B3SOIPD_AS: + here->B3SOIPDsourceArea = value->rValue; + here->B3SOIPDsourceAreaGiven = TRUE; + break; + case B3SOIPD_AD: + here->B3SOIPDdrainArea = value->rValue; + here->B3SOIPDdrainAreaGiven = TRUE; + break; + case B3SOIPD_PS: + here->B3SOIPDsourcePerimeter = value->rValue; + here->B3SOIPDsourcePerimeterGiven = TRUE; + break; + case B3SOIPD_PD: + here->B3SOIPDdrainPerimeter = value->rValue; + here->B3SOIPDdrainPerimeterGiven = TRUE; + break; + case B3SOIPD_NRS: + here->B3SOIPDsourceSquares = value->rValue; + here->B3SOIPDsourceSquaresGiven = TRUE; + break; + case B3SOIPD_NRD: + here->B3SOIPDdrainSquares = value->rValue; + here->B3SOIPDdrainSquaresGiven = TRUE; + break; + case B3SOIPD_OFF: + here->B3SOIPDoff = value->iValue; + here->B3SOIPDoffGiven = TRUE; + break; + case B3SOIPD_IC_VBS: + here->B3SOIPDicVBS = value->rValue; + here->B3SOIPDicVBSGiven = TRUE; + break; + case B3SOIPD_IC_VDS: + here->B3SOIPDicVDS = value->rValue; + here->B3SOIPDicVDSGiven = TRUE; + break; + case B3SOIPD_IC_VGS: + here->B3SOIPDicVGS = value->rValue; + here->B3SOIPDicVGSGiven = TRUE; + break; + case B3SOIPD_IC_VES: + here->B3SOIPDicVES = value->rValue; + here->B3SOIPDicVESGiven = TRUE; + break; + case B3SOIPD_IC_VPS: + here->B3SOIPDicVPS = value->rValue; + here->B3SOIPDicVPSGiven = TRUE; + break; + case B3SOIPD_BJTOFF: + here->B3SOIPDbjtoff = value->iValue; + here->B3SOIPDbjtoffGiven = TRUE; + break; + case B3SOIPD_DEBUG: + here->B3SOIPDdebugMod = value->iValue; + here->B3SOIPDdebugModGiven = TRUE; + break; + case B3SOIPD_RTH0: + here->B3SOIPDrth0 = value->rValue; + here->B3SOIPDrth0Given = TRUE; + break; + case B3SOIPD_CTH0: + here->B3SOIPDcth0 = value->rValue; + here->B3SOIPDcth0Given = TRUE; + break; + case B3SOIPD_NRB: + here->B3SOIPDbodySquares = value->rValue; + here->B3SOIPDbodySquaresGiven = TRUE; + break; + + +/* v2.0 release */ + case B3SOIPD_NBC: + here->B3SOIPDnbc = value->rValue; + here->B3SOIPDnbcGiven = TRUE; + break; + case B3SOIPD_NSEG: + here->B3SOIPDnseg = value->rValue; + here->B3SOIPDnsegGiven = TRUE; + break; + case B3SOIPD_PDBCP: + here->B3SOIPDpdbcp = value->rValue; + here->B3SOIPDpdbcpGiven = TRUE; + break; + case B3SOIPD_PSBCP: + here->B3SOIPDpsbcp = value->rValue; + here->B3SOIPDpsbcpGiven = TRUE; + break; + case B3SOIPD_AGBCP: + here->B3SOIPDagbcp = value->rValue; + here->B3SOIPDagbcpGiven = TRUE; + break; + case B3SOIPD_AEBCP: + here->B3SOIPDaebcp = value->rValue; + here->B3SOIPDaebcpGiven = TRUE; + break; + case B3SOIPD_VBSUSR: + here->B3SOIPDvbsusr = value->rValue; + here->B3SOIPDvbsusrGiven = TRUE; + break; + case B3SOIPD_TNODEOUT: + here->B3SOIPDtnodeout = value->iValue; + here->B3SOIPDtnodeoutGiven = TRUE; + break; + + + case B3SOIPD_IC: + switch (value->v.numValue) + { + case 5: + here->B3SOIPDicVPS = *(value->v.vec.rVec + 4); + here->B3SOIPDicVPSGiven = TRUE; + case 4: + here->B3SOIPDicVES = *(value->v.vec.rVec + 3); + here->B3SOIPDicVESGiven = TRUE; + case 3: + here->B3SOIPDicVBS = *(value->v.vec.rVec + 2); + here->B3SOIPDicVBSGiven = TRUE; + case 2: + here->B3SOIPDicVGS = *(value->v.vec.rVec + 1); + here->B3SOIPDicVGSGiven = TRUE; + case 1: + here->B3SOIPDicVDS = *(value->v.vec.rVec); + here->B3SOIPDicVDSGiven = TRUE; + break; + default: + return (E_BADPARM); + } + break; + default: + return (E_BADPARM); + } + return (OK); +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdpzld.c b/src/spicelib/devices/bsim3soi_pd/b3soipdpzld.c new file mode 100644 index 000000000..a7c473401 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdpzld.c @@ -0,0 +1,153 @@ +/********** +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 +**********/ + + +#include "ngspice.h" +#include +#include "cktdefs.h" +#include "complex.h" +#include "sperror.h" +#include "b3soipddef.h" +#include "suffix.h" + +int +B3SOIPDpzLoad (inModel, ckt, s) + GENmodel *inModel; + register CKTcircuit *ckt; + register SPcomplex *s; +{ + register B3SOIPDmodel *model = (B3SOIPDmodel *) inModel; + register B3SOIPDinstance *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; + + for (; model != NULL; model = model->B3SOIPDnextModel) + { + for (here = model->B3SOIPDinstances; here != NULL; + here = here->B3SOIPDnextInstance) + { + if (here->B3SOIPDmode >= 0) + { + Gm = here->B3SOIPDgm; + Gmbs = here->B3SOIPDgmbs; + FwdSum = Gm + Gmbs; + RevSum = 0.0; + cggb = here->B3SOIPDcggb; + cgsb = here->B3SOIPDcgsb; + cgdb = here->B3SOIPDcgdb; + + cbgb = here->B3SOIPDcbgb; + cbsb = here->B3SOIPDcbsb; + cbdb = here->B3SOIPDcbdb; + + cdgb = here->B3SOIPDcdgb; + cdsb = here->B3SOIPDcdsb; + cddb = here->B3SOIPDcddb; + } + else + { + Gm = -here->B3SOIPDgm; + Gmbs = -here->B3SOIPDgmbs; + FwdSum = 0.0; + RevSum = -Gm - Gmbs; + cggb = here->B3SOIPDcggb; + cgsb = here->B3SOIPDcgdb; + cgdb = here->B3SOIPDcgsb; + + cbgb = here->B3SOIPDcbgb; + cbsb = here->B3SOIPDcbdb; + cbdb = here->B3SOIPDcbsb; + + cdgb = -(here->B3SOIPDcdgb + cggb + cbgb); + cdsb = -(here->B3SOIPDcddb + cgsb + cbsb); + cddb = -(here->B3SOIPDcdsb + cgdb + cbdb); + } + gdpr = here->B3SOIPDdrainConductance; + gspr = here->B3SOIPDsourceConductance; + gds = here->B3SOIPDgds; + gbd = here->B3SOIPDgjdb; + gbs = here->B3SOIPDgjsb; +#ifdef BULKCODE + capbd = here->B3SOIPDcapbd; + capbs = here->B3SOIPDcapbs; +#endif + GSoverlapCap = here->B3SOIPDcgso; + GDoverlapCap = here->B3SOIPDcgdo; +#ifdef BULKCODE + GBoverlapCap = here->pParam->B3SOIPDcgbo; +#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); + + + *(here->B3SOIPDGgPtr) += xcggb * s->real; + *(here->B3SOIPDGgPtr + 1) += xcggb * s->imag; + *(here->B3SOIPDBbPtr) += (-xcbgb - xcbdb - xcbsb) * s->real; + *(here->B3SOIPDBbPtr + 1) += (-xcbgb - xcbdb - xcbsb) * s->imag; + *(here->B3SOIPDDPdpPtr) += xcddb * s->real; + *(here->B3SOIPDDPdpPtr + 1) += xcddb * s->imag; + *(here->B3SOIPDSPspPtr) += xcssb * s->real; + *(here->B3SOIPDSPspPtr + 1) += xcssb * s->imag; + *(here->B3SOIPDGbPtr) += (-xcggb - xcgdb - xcgsb) * s->real; + *(here->B3SOIPDGbPtr + 1) += (-xcggb - xcgdb - xcgsb) * s->imag; + *(here->B3SOIPDGdpPtr) += xcgdb * s->real; + *(here->B3SOIPDGdpPtr + 1) += xcgdb * s->imag; + *(here->B3SOIPDGspPtr) += xcgsb * s->real; + *(here->B3SOIPDGspPtr + 1) += xcgsb * s->imag; + *(here->B3SOIPDBgPtr) += xcbgb * s->real; + *(here->B3SOIPDBgPtr + 1) += xcbgb * s->imag; + *(here->B3SOIPDBdpPtr) += xcbdb * s->real; + *(here->B3SOIPDBdpPtr + 1) += xcbdb * s->imag; + *(here->B3SOIPDBspPtr) += xcbsb * s->real; + *(here->B3SOIPDBspPtr + 1) += xcbsb * s->imag; + *(here->B3SOIPDDPgPtr) += xcdgb * s->real; + *(here->B3SOIPDDPgPtr + 1) += xcdgb * s->imag; + *(here->B3SOIPDDPbPtr) += (-xcdgb - xcddb - xcdsb) * s->real; + *(here->B3SOIPDDPbPtr + 1) += (-xcdgb - xcddb - xcdsb) * s->imag; + *(here->B3SOIPDDPspPtr) += xcdsb * s->real; + *(here->B3SOIPDDPspPtr + 1) += xcdsb * s->imag; + *(here->B3SOIPDSPgPtr) += xcsgb * s->real; + *(here->B3SOIPDSPgPtr + 1) += xcsgb * s->imag; + *(here->B3SOIPDSPbPtr) += (-xcsgb - xcsdb - xcssb) * s->real; + *(here->B3SOIPDSPbPtr + 1) += (-xcsgb - xcsdb - xcssb) * s->imag; + *(here->B3SOIPDSPdpPtr) += xcsdb * s->real; + *(here->B3SOIPDSPdpPtr + 1) += xcsdb * s->imag; + *(here->B3SOIPDDdPtr) += gdpr; + *(here->B3SOIPDSsPtr) += gspr; + *(here->B3SOIPDBbPtr) += gbd + gbs; + *(here->B3SOIPDDPdpPtr) += gdpr + gds + gbd + RevSum; + *(here->B3SOIPDSPspPtr) += gspr + gds + gbs + FwdSum; + *(here->B3SOIPDDdpPtr) -= gdpr; + *(here->B3SOIPDSspPtr) -= gspr; + *(here->B3SOIPDBdpPtr) -= gbd; + *(here->B3SOIPDBspPtr) -= gbs; + *(here->B3SOIPDDPdPtr) -= gdpr; + *(here->B3SOIPDDPgPtr) += Gm; + *(here->B3SOIPDDPbPtr) -= gbd - Gmbs; + *(here->B3SOIPDDPspPtr) -= gds + FwdSum; + *(here->B3SOIPDSPgPtr) -= Gm; + *(here->B3SOIPDSPsPtr) -= gspr; + *(here->B3SOIPDSPbPtr) -= gbs + Gmbs; + *(here->B3SOIPDSPdpPtr) -= gds + RevSum; + + } + } + return (OK); +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdset.c b/src/spicelib/devices/bsim3soi_pd/b3soipdset.c new file mode 100644 index 000000000..f538f3f57 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdset.c @@ -0,0 +1,1498 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdset.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 +**********/ + + +#include "ngspice.h" +#include +#include +#include "smpdefs.h" +#include "cktdefs.h" +#include "b3soipddef.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 +B3SOIPDsetup (matrix, inModel, ckt, states) + register SMPmatrix *matrix; + register GENmodel *inModel; + register CKTcircuit *ckt; + int *states; +{ + register B3SOIPDmodel *model = (B3SOIPDmodel *) inModel; + register B3SOIPDinstance *here; + int error; + CKTnode *tmp; + + double tmp1, tmp2; + double nfb0, Cboxt; + int itmp1; + + /* loop through all the B3SOIPD device models */ + for (; model != NULL; model = model->B3SOIPDnextModel) + { +/* Default value Processing for B3SOIPD MOSFET Models */ + + if (!model->B3SOIPDtypeGiven) + model->B3SOIPDtype = NMOS; + if (!model->B3SOIPDmobModGiven) + model->B3SOIPDmobMod = 1; + if (!model->B3SOIPDbinUnitGiven) + model->B3SOIPDbinUnit = 1; + if (!model->B3SOIPDparamChkGiven) + model->B3SOIPDparamChk = 0; + if (!model->B3SOIPDcapModGiven) + model->B3SOIPDcapMod = 2; + if (!model->B3SOIPDnoiModGiven) + model->B3SOIPDnoiMod = 1; + if (!model->B3SOIPDshModGiven) + model->B3SOIPDshMod = 0; + if (!model->B3SOIPDversionGiven) + model->B3SOIPDversion = 2.0; + if (!model->B3SOIPDtoxGiven) + model->B3SOIPDtox = 100.0e-10; + model->B3SOIPDcox = 3.453133e-11 / model->B3SOIPDtox; + + if (!model->B3SOIPDcdscGiven) + model->B3SOIPDcdsc = 2.4e-4; /* unit Q/V/m^2 */ + if (!model->B3SOIPDcdscbGiven) + model->B3SOIPDcdscb = 0.0; /* unit Q/V/m^2 */ + if (!model->B3SOIPDcdscdGiven) + model->B3SOIPDcdscd = 0.0; /* unit Q/V/m^2 */ + if (!model->B3SOIPDcitGiven) + model->B3SOIPDcit = 0.0; /* unit Q/V/m^2 */ + if (!model->B3SOIPDnfactorGiven) + model->B3SOIPDnfactor = 1; + if (!model->B3SOIPDvsatGiven) + model->B3SOIPDvsat = 8.0e4; /* unit m/s */ + if (!model->B3SOIPDatGiven) + model->B3SOIPDat = 3.3e4; /* unit m/s */ + if (!model->B3SOIPDa0Given) + model->B3SOIPDa0 = 1.0; + if (!model->B3SOIPDagsGiven) + model->B3SOIPDags = 0.0; + if (!model->B3SOIPDa1Given) + model->B3SOIPDa1 = 0.0; + if (!model->B3SOIPDa2Given) + model->B3SOIPDa2 = 1.0; + if (!model->B3SOIPDketaGiven) + model->B3SOIPDketa = -0.6; /* unit / V */ + if (!model->B3SOIPDnsubGiven) + model->B3SOIPDnsub = 6.0e16; /* unit 1/cm3 */ + if (!model->B3SOIPDnpeakGiven) + model->B3SOIPDnpeak = 1.7e17; /* unit 1/cm3 */ + if (!model->B3SOIPDngateGiven) + model->B3SOIPDngate = 0; /* unit 1/cm3 */ + if (!model->B3SOIPDvbmGiven) + model->B3SOIPDvbm = -3.0; + if (!model->B3SOIPDxtGiven) + model->B3SOIPDxt = 1.55e-7; + if (!model->B3SOIPDkt1Given) + model->B3SOIPDkt1 = -0.11; /* unit V */ + if (!model->B3SOIPDkt1lGiven) + model->B3SOIPDkt1l = 0.0; /* unit V*m */ + if (!model->B3SOIPDkt2Given) + model->B3SOIPDkt2 = 0.022; /* No unit */ + if (!model->B3SOIPDk3Given) + model->B3SOIPDk3 = 0.0; + if (!model->B3SOIPDk3bGiven) + model->B3SOIPDk3b = 0.0; + if (!model->B3SOIPDw0Given) + model->B3SOIPDw0 = 2.5e-6; + if (!model->B3SOIPDnlxGiven) + model->B3SOIPDnlx = 1.74e-7; + if (!model->B3SOIPDdvt0Given) + model->B3SOIPDdvt0 = 2.2; + if (!model->B3SOIPDdvt1Given) + model->B3SOIPDdvt1 = 0.53; + if (!model->B3SOIPDdvt2Given) + model->B3SOIPDdvt2 = -0.032; /* unit 1 / V */ + + if (!model->B3SOIPDdvt0wGiven) + model->B3SOIPDdvt0w = 0.0; + if (!model->B3SOIPDdvt1wGiven) + model->B3SOIPDdvt1w = 5.3e6; + if (!model->B3SOIPDdvt2wGiven) + model->B3SOIPDdvt2w = -0.032; + + if (!model->B3SOIPDdroutGiven) + model->B3SOIPDdrout = 0.56; + if (!model->B3SOIPDdsubGiven) + model->B3SOIPDdsub = model->B3SOIPDdrout; + if (!model->B3SOIPDvth0Given) + model->B3SOIPDvth0 = (model->B3SOIPDtype == NMOS) ? 0.7 : -0.7; + if (!model->B3SOIPDuaGiven) + model->B3SOIPDua = 2.25e-9; /* unit m/V */ + if (!model->B3SOIPDua1Given) + model->B3SOIPDua1 = 4.31e-9; /* unit m/V */ + if (!model->B3SOIPDubGiven) + model->B3SOIPDub = 5.87e-19; /* unit (m/V)**2 */ + if (!model->B3SOIPDub1Given) + model->B3SOIPDub1 = -7.61e-18; /* unit (m/V)**2 */ + if (!model->B3SOIPDucGiven) + model->B3SOIPDuc = (model->B3SOIPDmobMod == 3) ? -0.0465 : -0.0465e-9; + if (!model->B3SOIPDuc1Given) + model->B3SOIPDuc1 = (model->B3SOIPDmobMod == 3) ? -0.056 : -0.056e-9; + if (!model->B3SOIPDu0Given) + model->B3SOIPDu0 = (model->B3SOIPDtype == NMOS) ? 0.067 : 0.025; + if (!model->B3SOIPDuteGiven) + model->B3SOIPDute = -1.5; + if (!model->B3SOIPDvoffGiven) + model->B3SOIPDvoff = -0.08; + if (!model->B3SOIPDdeltaGiven) + model->B3SOIPDdelta = 0.01; + if (!model->B3SOIPDrdswGiven) + model->B3SOIPDrdsw = 100; + if (!model->B3SOIPDprwgGiven) + model->B3SOIPDprwg = 0.0; /* unit 1/V */ + if (!model->B3SOIPDprwbGiven) + model->B3SOIPDprwb = 0.0; + if (!model->B3SOIPDprtGiven) + if (!model->B3SOIPDprtGiven) + model->B3SOIPDprt = 0.0; + if (!model->B3SOIPDeta0Given) + model->B3SOIPDeta0 = 0.08; /* no unit */ + if (!model->B3SOIPDetabGiven) + model->B3SOIPDetab = -0.07; /* unit 1/V */ + if (!model->B3SOIPDpclmGiven) + model->B3SOIPDpclm = 1.3; /* no unit */ + if (!model->B3SOIPDpdibl1Given) + model->B3SOIPDpdibl1 = .39; /* no unit */ + if (!model->B3SOIPDpdibl2Given) + model->B3SOIPDpdibl2 = 0.0086; /* no unit */ + if (!model->B3SOIPDpdiblbGiven) + model->B3SOIPDpdiblb = 0.0; /* 1/V */ + if (!model->B3SOIPDpvagGiven) + model->B3SOIPDpvag = 0.0; + if (!model->B3SOIPDwrGiven) + model->B3SOIPDwr = 1.0; + if (!model->B3SOIPDdwgGiven) + model->B3SOIPDdwg = 0.0; + if (!model->B3SOIPDdwbGiven) + model->B3SOIPDdwb = 0.0; + if (!model->B3SOIPDb0Given) + model->B3SOIPDb0 = 0.0; + if (!model->B3SOIPDb1Given) + model->B3SOIPDb1 = 0.0; + if (!model->B3SOIPDalpha0Given) + model->B3SOIPDalpha0 = 0.0; + + if (!model->B3SOIPDcgslGiven) + model->B3SOIPDcgsl = 0.0; + if (!model->B3SOIPDcgdlGiven) + model->B3SOIPDcgdl = 0.0; + if (!model->B3SOIPDckappaGiven) + model->B3SOIPDckappa = 0.6; + if (!model->B3SOIPDclcGiven) + model->B3SOIPDclc = 0.1e-7; + if (!model->B3SOIPDcleGiven) + model->B3SOIPDcle = 0.0; + if (!model->B3SOIPDtboxGiven) + model->B3SOIPDtbox = 3e-7; + if (!model->B3SOIPDtsiGiven) + model->B3SOIPDtsi = 1e-7; + if (!model->B3SOIPDxjGiven) + model->B3SOIPDxj = model->B3SOIPDtsi; + if (!model->B3SOIPDrbodyGiven) + model->B3SOIPDrbody = 0.0; + if (!model->B3SOIPDrbshGiven) + model->B3SOIPDrbsh = 0.0; + if (!model->B3SOIPDrth0Given) + model->B3SOIPDrth0 = 0; + + if (!model->B3SOIPDcth0Given) + model->B3SOIPDcth0 = 0; + + if (!model->B3SOIPDagidlGiven) + model->B3SOIPDagidl = 0.0; + if (!model->B3SOIPDbgidlGiven) + model->B3SOIPDbgidl = 0.0; + if (!model->B3SOIPDngidlGiven) + model->B3SOIPDngidl = 1.2; + if (!model->B3SOIPDndiodeGiven) + model->B3SOIPDndiode = 1.0; + if (!model->B3SOIPDntunGiven) + model->B3SOIPDntun = 10.0; + + if (!model->B3SOIPDnrecf0Given) + model->B3SOIPDnrecf0 = 2.0; + if (!model->B3SOIPDnrecr0Given) + model->B3SOIPDnrecr0 = 10.0; + + if (!model->B3SOIPDisbjtGiven) + model->B3SOIPDisbjt = 1e-6; + if (!model->B3SOIPDisdifGiven) + model->B3SOIPDisdif = 0.0; + if (!model->B3SOIPDisrecGiven) + model->B3SOIPDisrec = 1e-5; + if (!model->B3SOIPDistunGiven) + model->B3SOIPDistun = 0.0; + if (!model->B3SOIPDxbjtGiven) + model->B3SOIPDxbjt = 1; +/* + if (!model->B3SOIPDxdifGiven) + model->B3SOIPDxdif = 1; +*/ + if (!model->B3SOIPDxdifGiven) + model->B3SOIPDxdif = model->B3SOIPDxbjt; + + if (!model->B3SOIPDxrecGiven) + model->B3SOIPDxrec = 1; + if (!model->B3SOIPDxtunGiven) + model->B3SOIPDxtun = 0; + if (!model->B3SOIPDttGiven) + model->B3SOIPDtt = 1e-12; + if (!model->B3SOIPDasdGiven) + model->B3SOIPDasd = 0.3; + + /* unit degree celcius */ + if (!model->B3SOIPDtnomGiven) + model->B3SOIPDtnom = ckt->CKTnomTemp; + if (!model->B3SOIPDLintGiven) + model->B3SOIPDLint = 0.0; + if (!model->B3SOIPDLlGiven) + model->B3SOIPDLl = 0.0; + if (!model->B3SOIPDLlnGiven) + model->B3SOIPDLln = 1.0; + if (!model->B3SOIPDLwGiven) + model->B3SOIPDLw = 0.0; + if (!model->B3SOIPDLwnGiven) + model->B3SOIPDLwn = 1.0; + if (!model->B3SOIPDLwlGiven) + model->B3SOIPDLwl = 0.0; + if (!model->B3SOIPDLminGiven) + model->B3SOIPDLmin = 0.0; + if (!model->B3SOIPDLmaxGiven) + model->B3SOIPDLmax = 1.0; + if (!model->B3SOIPDWintGiven) + model->B3SOIPDWint = 0.0; + if (!model->B3SOIPDWlGiven) + model->B3SOIPDWl = 0.0; + if (!model->B3SOIPDWlnGiven) + model->B3SOIPDWln = 1.0; + if (!model->B3SOIPDWwGiven) + model->B3SOIPDWw = 0.0; + if (!model->B3SOIPDWwnGiven) + model->B3SOIPDWwn = 1.0; + if (!model->B3SOIPDWwlGiven) + model->B3SOIPDWwl = 0.0; + if (!model->B3SOIPDWminGiven) + model->B3SOIPDWmin = 0.0; + if (!model->B3SOIPDWmaxGiven) + model->B3SOIPDWmax = 1.0; + if (!model->B3SOIPDdwcGiven) + model->B3SOIPDdwc = model->B3SOIPDWint; + if (!model->B3SOIPDdlcGiven) + model->B3SOIPDdlc = model->B3SOIPDLint; + + +/* v2.2 release */ + if (!model->B3SOIPDwth0Given) + model->B3SOIPDwth0 = 0.0; + if (!model->B3SOIPDrhaloGiven) + model->B3SOIPDrhalo = 1e15; + if (!model->B3SOIPDntoxGiven) + model->B3SOIPDntox = 1; + if (!model->B3SOIPDtoxrefGiven) + model->B3SOIPDtoxref = 2.5e-9; + if (!model->B3SOIPDebgGiven) + model->B3SOIPDebg = 1.2; + if (!model->B3SOIPDnevbGiven) + model->B3SOIPDnevb = 3; + if (!model->B3SOIPDalphaGB1Given) + model->B3SOIPDalphaGB1 = 0.35; + if (!model->B3SOIPDbetaGB1Given) + model->B3SOIPDbetaGB1 = 0.03; + if (!model->B3SOIPDvgb1Given) + model->B3SOIPDvgb1 = 300; + if (!model->B3SOIPDalphaGB2Given) + model->B3SOIPDalphaGB2 = 0.43; + if (!model->B3SOIPDbetaGB2Given) + model->B3SOIPDbetaGB2 = 0.05; + if (!model->B3SOIPDnecbGiven) + model->B3SOIPDnecb = 1; + if (!model->B3SOIPDvgb2Given) + model->B3SOIPDvgb2 = 17; + if (!model->B3SOIPDtoxqmGiven) + model->B3SOIPDtoxqm = model->B3SOIPDtox; + if (!model->B3SOIPDvoxhGiven) + model->B3SOIPDvoxh = 5.0; + if (!model->B3SOIPDdeltavoxGiven) + model->B3SOIPDdeltavox = 0.005; + if (!model->B3SOIPDigModGiven) + model->B3SOIPDigMod = 0; + + +/* v2.0 release */ + if (!model->B3SOIPDk1w1Given) + model->B3SOIPDk1w1 = 0.0; + if (!model->B3SOIPDk1w2Given) + model->B3SOIPDk1w2 = 0.0; + if (!model->B3SOIPDketasGiven) + model->B3SOIPDketas = 0.0; + if (!model->B3SOIPDdwbcGiven) + model->B3SOIPDdwbc = 0.0; + if (!model->B3SOIPDbeta0Given) + model->B3SOIPDbeta0 = 0.0; + if (!model->B3SOIPDbeta1Given) + model->B3SOIPDbeta1 = 0.0; + if (!model->B3SOIPDbeta2Given) + model->B3SOIPDbeta2 = 0.1; + if (!model->B3SOIPDvdsatii0Given) + model->B3SOIPDvdsatii0 = 0.9; + if (!model->B3SOIPDtiiGiven) + model->B3SOIPDtii = 0.0; + if (!model->B3SOIPDliiGiven) + model->B3SOIPDlii = 0.0; + if (!model->B3SOIPDsii0Given) + model->B3SOIPDsii0 = 0.5; + if (!model->B3SOIPDsii1Given) + model->B3SOIPDsii1 = 0.1; + if (!model->B3SOIPDsii2Given) + model->B3SOIPDsii2 = 0.0; + if (!model->B3SOIPDsiidGiven) + model->B3SOIPDsiid = 0.0; + if (!model->B3SOIPDfbjtiiGiven) + model->B3SOIPDfbjtii = 0.0; + if (!model->B3SOIPDesatiiGiven) + model->B3SOIPDesatii = 1e7; + if (!model->B3SOIPDlnGiven) + model->B3SOIPDln = 2e-6; + if (!model->B3SOIPDvrec0Given) + model->B3SOIPDvrec0 = 0; + if (!model->B3SOIPDvtun0Given) + model->B3SOIPDvtun0 = 0; + if (!model->B3SOIPDnbjtGiven) + model->B3SOIPDnbjt = 1.0; + if (!model->B3SOIPDlbjt0Given) + model->B3SOIPDlbjt0 = 0.20e-6; + if (!model->B3SOIPDldif0Given) + model->B3SOIPDldif0 = 1.0; + if (!model->B3SOIPDvabjtGiven) + model->B3SOIPDvabjt = 10.0; + if (!model->B3SOIPDaelyGiven) + model->B3SOIPDaely = 0; + if (!model->B3SOIPDahliGiven) + model->B3SOIPDahli = 0; + if (!model->B3SOIPDrbodyGiven) + model->B3SOIPDrbody = 0.0; + if (!model->B3SOIPDrbshGiven) + model->B3SOIPDrbsh = 0.0; + if (!model->B3SOIPDntrecfGiven) + model->B3SOIPDntrecf = 0.0; + if (!model->B3SOIPDntrecrGiven) + model->B3SOIPDntrecr = 0.0; + if (!model->B3SOIPDndifGiven) + model->B3SOIPDndif = -1.0; + if (!model->B3SOIPDdlcbGiven) + model->B3SOIPDdlcb = 0.0; + if (!model->B3SOIPDfbodyGiven) + model->B3SOIPDfbody = 1.0; + if (!model->B3SOIPDtcjswgGiven) + model->B3SOIPDtcjswg = 0.0; + if (!model->B3SOIPDtpbswgGiven) + model->B3SOIPDtpbswg = 0.0; + if (!model->B3SOIPDacdeGiven) + model->B3SOIPDacde = 1.0; + if (!model->B3SOIPDmoinGiven) + model->B3SOIPDmoin = 15.0; + if (!model->B3SOIPDdelvtGiven) + model->B3SOIPDdelvt = 0.0; + if (!model->B3SOIPDkb1Given) + model->B3SOIPDkb1 = 1.0; + if (!model->B3SOIPDdlbgGiven) + model->B3SOIPDdlbg = 0.0; + +/* Added for binning - START */ + /* Length dependence */ + if (!model->B3SOIPDlnpeakGiven) + model->B3SOIPDlnpeak = 0.0; + if (!model->B3SOIPDlnsubGiven) + model->B3SOIPDlnsub = 0.0; + if (!model->B3SOIPDlngateGiven) + model->B3SOIPDlngate = 0.0; + if (!model->B3SOIPDlvth0Given) + model->B3SOIPDlvth0 = 0.0; + if (!model->B3SOIPDlk1Given) + model->B3SOIPDlk1 = 0.0; + if (!model->B3SOIPDlk1w1Given) + model->B3SOIPDlk1w1 = 0.0; + if (!model->B3SOIPDlk1w2Given) + model->B3SOIPDlk1w2 = 0.0; + if (!model->B3SOIPDlk2Given) + model->B3SOIPDlk2 = 0.0; + if (!model->B3SOIPDlk3Given) + model->B3SOIPDlk3 = 0.0; + if (!model->B3SOIPDlk3bGiven) + model->B3SOIPDlk3b = 0.0; + if (!model->B3SOIPDlkb1Given) + model->B3SOIPDlkb1 = 0.0; + if (!model->B3SOIPDlw0Given) + model->B3SOIPDlw0 = 0.0; + if (!model->B3SOIPDlnlxGiven) + model->B3SOIPDlnlx = 0.0; + if (!model->B3SOIPDldvt0Given) + model->B3SOIPDldvt0 = 0.0; + if (!model->B3SOIPDldvt1Given) + model->B3SOIPDldvt1 = 0.0; + if (!model->B3SOIPDldvt2Given) + model->B3SOIPDldvt2 = 0.0; + if (!model->B3SOIPDldvt0wGiven) + model->B3SOIPDldvt0w = 0.0; + if (!model->B3SOIPDldvt1wGiven) + model->B3SOIPDldvt1w = 0.0; + if (!model->B3SOIPDldvt2wGiven) + model->B3SOIPDldvt2w = 0.0; + if (!model->B3SOIPDlu0Given) + model->B3SOIPDlu0 = 0.0; + if (!model->B3SOIPDluaGiven) + model->B3SOIPDlua = 0.0; + if (!model->B3SOIPDlubGiven) + model->B3SOIPDlub = 0.0; + if (!model->B3SOIPDlucGiven) + model->B3SOIPDluc = 0.0; + if (!model->B3SOIPDlvsatGiven) + model->B3SOIPDlvsat = 0.0; + if (!model->B3SOIPDla0Given) + model->B3SOIPDla0 = 0.0; + if (!model->B3SOIPDlagsGiven) + model->B3SOIPDlags = 0.0; + if (!model->B3SOIPDlb0Given) + model->B3SOIPDlb0 = 0.0; + if (!model->B3SOIPDlb1Given) + model->B3SOIPDlb1 = 0.0; + if (!model->B3SOIPDlketaGiven) + model->B3SOIPDlketa = 0.0; + if (!model->B3SOIPDlketasGiven) + model->B3SOIPDlketas = 0.0; + if (!model->B3SOIPDla1Given) + model->B3SOIPDla1 = 0.0; + if (!model->B3SOIPDla2Given) + model->B3SOIPDla2 = 0.0; + if (!model->B3SOIPDlrdswGiven) + model->B3SOIPDlrdsw = 0.0; + if (!model->B3SOIPDlprwbGiven) + model->B3SOIPDlprwb = 0.0; + if (!model->B3SOIPDlprwgGiven) + model->B3SOIPDlprwg = 0.0; + if (!model->B3SOIPDlwrGiven) + model->B3SOIPDlwr = 0.0; + if (!model->B3SOIPDlnfactorGiven) + model->B3SOIPDlnfactor = 0.0; + if (!model->B3SOIPDldwgGiven) + model->B3SOIPDldwg = 0.0; + if (!model->B3SOIPDldwbGiven) + model->B3SOIPDldwb = 0.0; + if (!model->B3SOIPDlvoffGiven) + model->B3SOIPDlvoff = 0.0; + if (!model->B3SOIPDleta0Given) + model->B3SOIPDleta0 = 0.0; + if (!model->B3SOIPDletabGiven) + model->B3SOIPDletab = 0.0; + if (!model->B3SOIPDldsubGiven) + model->B3SOIPDldsub = 0.0; + if (!model->B3SOIPDlcitGiven) + model->B3SOIPDlcit = 0.0; + if (!model->B3SOIPDlcdscGiven) + model->B3SOIPDlcdsc = 0.0; + if (!model->B3SOIPDlcdscbGiven) + model->B3SOIPDlcdscb = 0.0; + if (!model->B3SOIPDlcdscdGiven) + model->B3SOIPDlcdscd = 0.0; + if (!model->B3SOIPDlpclmGiven) + model->B3SOIPDlpclm = 0.0; + if (!model->B3SOIPDlpdibl1Given) + model->B3SOIPDlpdibl1 = 0.0; + if (!model->B3SOIPDlpdibl2Given) + model->B3SOIPDlpdibl2 = 0.0; + if (!model->B3SOIPDlpdiblbGiven) + model->B3SOIPDlpdiblb = 0.0; + if (!model->B3SOIPDldroutGiven) + model->B3SOIPDldrout = 0.0; + if (!model->B3SOIPDlpvagGiven) + model->B3SOIPDlpvag = 0.0; + if (!model->B3SOIPDldeltaGiven) + model->B3SOIPDldelta = 0.0; + if (!model->B3SOIPDlalpha0Given) + model->B3SOIPDlalpha0 = 0.0; + if (!model->B3SOIPDlfbjtiiGiven) + model->B3SOIPDlfbjtii = 0.0; + if (!model->B3SOIPDlbeta0Given) + model->B3SOIPDlbeta0 = 0.0; + if (!model->B3SOIPDlbeta1Given) + model->B3SOIPDlbeta1 = 0.0; + if (!model->B3SOIPDlbeta2Given) + model->B3SOIPDlbeta2 = 0.0; + if (!model->B3SOIPDlvdsatii0Given) + model->B3SOIPDlvdsatii0 = 0.0; + if (!model->B3SOIPDlliiGiven) + model->B3SOIPDllii = 0.0; + if (!model->B3SOIPDlesatiiGiven) + model->B3SOIPDlesatii = 0.0; + if (!model->B3SOIPDlsii0Given) + model->B3SOIPDlsii0 = 0.0; + if (!model->B3SOIPDlsii1Given) + model->B3SOIPDlsii1 = 0.0; + if (!model->B3SOIPDlsii2Given) + model->B3SOIPDlsii2 = 0.0; + if (!model->B3SOIPDlsiidGiven) + model->B3SOIPDlsiid = 0.0; + if (!model->B3SOIPDlagidlGiven) + model->B3SOIPDlagidl = 0.0; + if (!model->B3SOIPDlbgidlGiven) + model->B3SOIPDlbgidl = 0.0; + if (!model->B3SOIPDlngidlGiven) + model->B3SOIPDlngidl = 0.0; + if (!model->B3SOIPDlntunGiven) + model->B3SOIPDlntun = 0.0; + if (!model->B3SOIPDlndiodeGiven) + model->B3SOIPDlndiode = 0.0; + if (!model->B3SOIPDlnrecf0Given) + model->B3SOIPDlnrecf0 = 0.0; + if (!model->B3SOIPDlnrecr0Given) + model->B3SOIPDlnrecr0 = 0.0; + if (!model->B3SOIPDlisbjtGiven) + model->B3SOIPDlisbjt = 0.0; + if (!model->B3SOIPDlisdifGiven) + model->B3SOIPDlisdif = 0.0; + if (!model->B3SOIPDlisrecGiven) + model->B3SOIPDlisrec = 0.0; + if (!model->B3SOIPDlistunGiven) + model->B3SOIPDlistun = 0.0; + if (!model->B3SOIPDlvrec0Given) + model->B3SOIPDlvrec0 = 0.0; + if (!model->B3SOIPDlvtun0Given) + model->B3SOIPDlvtun0 = 0.0; + if (!model->B3SOIPDlnbjtGiven) + model->B3SOIPDlnbjt = 0.0; + if (!model->B3SOIPDllbjt0Given) + model->B3SOIPDllbjt0 = 0.0; + if (!model->B3SOIPDlvabjtGiven) + model->B3SOIPDlvabjt = 0.0; + if (!model->B3SOIPDlaelyGiven) + model->B3SOIPDlaely = 0.0; + if (!model->B3SOIPDlahliGiven) + model->B3SOIPDlahli = 0.0; + /* CV Model */ + if (!model->B3SOIPDlvsdfbGiven) + model->B3SOIPDlvsdfb = 0.0; + if (!model->B3SOIPDlvsdthGiven) + model->B3SOIPDlvsdth = 0.0; + if (!model->B3SOIPDldelvtGiven) + model->B3SOIPDldelvt = 0.0; + if (!model->B3SOIPDlacdeGiven) + model->B3SOIPDlacde = 0.0; + if (!model->B3SOIPDlmoinGiven) + model->B3SOIPDlmoin = 0.0; + + /* Width dependence */ + if (!model->B3SOIPDwnpeakGiven) + model->B3SOIPDwnpeak = 0.0; + if (!model->B3SOIPDwnsubGiven) + model->B3SOIPDwnsub = 0.0; + if (!model->B3SOIPDwngateGiven) + model->B3SOIPDwngate = 0.0; + if (!model->B3SOIPDwvth0Given) + model->B3SOIPDwvth0 = 0.0; + if (!model->B3SOIPDwk1Given) + model->B3SOIPDwk1 = 0.0; + if (!model->B3SOIPDwk1w1Given) + model->B3SOIPDwk1w1 = 0.0; + if (!model->B3SOIPDwk1w2Given) + model->B3SOIPDwk1w2 = 0.0; + if (!model->B3SOIPDwk2Given) + model->B3SOIPDwk2 = 0.0; + if (!model->B3SOIPDwk3Given) + model->B3SOIPDwk3 = 0.0; + if (!model->B3SOIPDwk3bGiven) + model->B3SOIPDwk3b = 0.0; + if (!model->B3SOIPDwkb1Given) + model->B3SOIPDwkb1 = 0.0; + if (!model->B3SOIPDww0Given) + model->B3SOIPDww0 = 0.0; + if (!model->B3SOIPDwnlxGiven) + model->B3SOIPDwnlx = 0.0; + if (!model->B3SOIPDwdvt0Given) + model->B3SOIPDwdvt0 = 0.0; + if (!model->B3SOIPDwdvt1Given) + model->B3SOIPDwdvt1 = 0.0; + if (!model->B3SOIPDwdvt2Given) + model->B3SOIPDwdvt2 = 0.0; + if (!model->B3SOIPDwdvt0wGiven) + model->B3SOIPDwdvt0w = 0.0; + if (!model->B3SOIPDwdvt1wGiven) + model->B3SOIPDwdvt1w = 0.0; + if (!model->B3SOIPDwdvt2wGiven) + model->B3SOIPDwdvt2w = 0.0; + if (!model->B3SOIPDwu0Given) + model->B3SOIPDwu0 = 0.0; + if (!model->B3SOIPDwuaGiven) + model->B3SOIPDwua = 0.0; + if (!model->B3SOIPDwubGiven) + model->B3SOIPDwub = 0.0; + if (!model->B3SOIPDwucGiven) + model->B3SOIPDwuc = 0.0; + if (!model->B3SOIPDwvsatGiven) + model->B3SOIPDwvsat = 0.0; + if (!model->B3SOIPDwa0Given) + model->B3SOIPDwa0 = 0.0; + if (!model->B3SOIPDwagsGiven) + model->B3SOIPDwags = 0.0; + if (!model->B3SOIPDwb0Given) + model->B3SOIPDwb0 = 0.0; + if (!model->B3SOIPDwb1Given) + model->B3SOIPDwb1 = 0.0; + if (!model->B3SOIPDwketaGiven) + model->B3SOIPDwketa = 0.0; + if (!model->B3SOIPDwketasGiven) + model->B3SOIPDwketas = 0.0; + if (!model->B3SOIPDwa1Given) + model->B3SOIPDwa1 = 0.0; + if (!model->B3SOIPDwa2Given) + model->B3SOIPDwa2 = 0.0; + if (!model->B3SOIPDwrdswGiven) + model->B3SOIPDwrdsw = 0.0; + if (!model->B3SOIPDwprwbGiven) + model->B3SOIPDwprwb = 0.0; + if (!model->B3SOIPDwprwgGiven) + model->B3SOIPDwprwg = 0.0; + if (!model->B3SOIPDwwrGiven) + model->B3SOIPDwwr = 0.0; + if (!model->B3SOIPDwnfactorGiven) + model->B3SOIPDwnfactor = 0.0; + if (!model->B3SOIPDwdwgGiven) + model->B3SOIPDwdwg = 0.0; + if (!model->B3SOIPDwdwbGiven) + model->B3SOIPDwdwb = 0.0; + if (!model->B3SOIPDwvoffGiven) + model->B3SOIPDwvoff = 0.0; + if (!model->B3SOIPDweta0Given) + model->B3SOIPDweta0 = 0.0; + if (!model->B3SOIPDwetabGiven) + model->B3SOIPDwetab = 0.0; + if (!model->B3SOIPDwdsubGiven) + model->B3SOIPDwdsub = 0.0; + if (!model->B3SOIPDwcitGiven) + model->B3SOIPDwcit = 0.0; + if (!model->B3SOIPDwcdscGiven) + model->B3SOIPDwcdsc = 0.0; + if (!model->B3SOIPDwcdscbGiven) + model->B3SOIPDwcdscb = 0.0; + if (!model->B3SOIPDwcdscdGiven) + model->B3SOIPDwcdscd = 0.0; + if (!model->B3SOIPDwpclmGiven) + model->B3SOIPDwpclm = 0.0; + if (!model->B3SOIPDwpdibl1Given) + model->B3SOIPDwpdibl1 = 0.0; + if (!model->B3SOIPDwpdibl2Given) + model->B3SOIPDwpdibl2 = 0.0; + if (!model->B3SOIPDwpdiblbGiven) + model->B3SOIPDwpdiblb = 0.0; + if (!model->B3SOIPDwdroutGiven) + model->B3SOIPDwdrout = 0.0; + if (!model->B3SOIPDwpvagGiven) + model->B3SOIPDwpvag = 0.0; + if (!model->B3SOIPDwdeltaGiven) + model->B3SOIPDwdelta = 0.0; + if (!model->B3SOIPDwalpha0Given) + model->B3SOIPDwalpha0 = 0.0; + if (!model->B3SOIPDwfbjtiiGiven) + model->B3SOIPDwfbjtii = 0.0; + if (!model->B3SOIPDwbeta0Given) + model->B3SOIPDwbeta0 = 0.0; + if (!model->B3SOIPDwbeta1Given) + model->B3SOIPDwbeta1 = 0.0; + if (!model->B3SOIPDwbeta2Given) + model->B3SOIPDwbeta2 = 0.0; + if (!model->B3SOIPDwvdsatii0Given) + model->B3SOIPDwvdsatii0 = 0.0; + if (!model->B3SOIPDwliiGiven) + model->B3SOIPDwlii = 0.0; + if (!model->B3SOIPDwesatiiGiven) + model->B3SOIPDwesatii = 0.0; + if (!model->B3SOIPDwsii0Given) + model->B3SOIPDwsii0 = 0.0; + if (!model->B3SOIPDwsii1Given) + model->B3SOIPDwsii1 = 0.0; + if (!model->B3SOIPDwsii2Given) + model->B3SOIPDwsii2 = 0.0; + if (!model->B3SOIPDwsiidGiven) + model->B3SOIPDwsiid = 0.0; + if (!model->B3SOIPDwagidlGiven) + model->B3SOIPDwagidl = 0.0; + if (!model->B3SOIPDwbgidlGiven) + model->B3SOIPDwbgidl = 0.0; + if (!model->B3SOIPDwngidlGiven) + model->B3SOIPDwngidl = 0.0; + if (!model->B3SOIPDwntunGiven) + model->B3SOIPDwntun = 0.0; + if (!model->B3SOIPDwndiodeGiven) + model->B3SOIPDwndiode = 0.0; + if (!model->B3SOIPDwnrecf0Given) + model->B3SOIPDwnrecf0 = 0.0; + if (!model->B3SOIPDwnrecr0Given) + model->B3SOIPDwnrecr0 = 0.0; + if (!model->B3SOIPDwisbjtGiven) + model->B3SOIPDwisbjt = 0.0; + if (!model->B3SOIPDwisdifGiven) + model->B3SOIPDwisdif = 0.0; + if (!model->B3SOIPDwisrecGiven) + model->B3SOIPDwisrec = 0.0; + if (!model->B3SOIPDwistunGiven) + model->B3SOIPDwistun = 0.0; + if (!model->B3SOIPDwvrec0Given) + model->B3SOIPDwvrec0 = 0.0; + if (!model->B3SOIPDwvtun0Given) + model->B3SOIPDwvtun0 = 0.0; + if (!model->B3SOIPDwnbjtGiven) + model->B3SOIPDwnbjt = 0.0; + if (!model->B3SOIPDwlbjt0Given) + model->B3SOIPDwlbjt0 = 0.0; + if (!model->B3SOIPDwvabjtGiven) + model->B3SOIPDwvabjt = 0.0; + if (!model->B3SOIPDwaelyGiven) + model->B3SOIPDwaely = 0.0; + if (!model->B3SOIPDwahliGiven) + model->B3SOIPDwahli = 0.0; + /* CV Model */ + if (!model->B3SOIPDwvsdfbGiven) + model->B3SOIPDwvsdfb = 0.0; + if (!model->B3SOIPDwvsdthGiven) + model->B3SOIPDwvsdth = 0.0; + if (!model->B3SOIPDwdelvtGiven) + model->B3SOIPDwdelvt = 0.0; + if (!model->B3SOIPDwacdeGiven) + model->B3SOIPDwacde = 0.0; + if (!model->B3SOIPDwmoinGiven) + model->B3SOIPDwmoin = 0.0; + + /* Cross-term dependence */ + if (!model->B3SOIPDpnpeakGiven) + model->B3SOIPDpnpeak = 0.0; + if (!model->B3SOIPDpnsubGiven) + model->B3SOIPDpnsub = 0.0; + if (!model->B3SOIPDpngateGiven) + model->B3SOIPDpngate = 0.0; + if (!model->B3SOIPDpvth0Given) + model->B3SOIPDpvth0 = 0.0; + if (!model->B3SOIPDpk1Given) + model->B3SOIPDpk1 = 0.0; + if (!model->B3SOIPDpk1w1Given) + model->B3SOIPDpk1w1 = 0.0; + if (!model->B3SOIPDpk1w2Given) + model->B3SOIPDpk1w2 = 0.0; + if (!model->B3SOIPDpk2Given) + model->B3SOIPDpk2 = 0.0; + if (!model->B3SOIPDpk3Given) + model->B3SOIPDpk3 = 0.0; + if (!model->B3SOIPDpk3bGiven) + model->B3SOIPDpk3b = 0.0; + if (!model->B3SOIPDpkb1Given) + model->B3SOIPDpkb1 = 0.0; + if (!model->B3SOIPDpw0Given) + model->B3SOIPDpw0 = 0.0; + if (!model->B3SOIPDpnlxGiven) + model->B3SOIPDpnlx = 0.0; + if (!model->B3SOIPDpdvt0Given) + model->B3SOIPDpdvt0 = 0.0; + if (!model->B3SOIPDpdvt1Given) + model->B3SOIPDpdvt1 = 0.0; + if (!model->B3SOIPDpdvt2Given) + model->B3SOIPDpdvt2 = 0.0; + if (!model->B3SOIPDpdvt0wGiven) + model->B3SOIPDpdvt0w = 0.0; + if (!model->B3SOIPDpdvt1wGiven) + model->B3SOIPDpdvt1w = 0.0; + if (!model->B3SOIPDpdvt2wGiven) + model->B3SOIPDpdvt2w = 0.0; + if (!model->B3SOIPDpu0Given) + model->B3SOIPDpu0 = 0.0; + if (!model->B3SOIPDpuaGiven) + model->B3SOIPDpua = 0.0; + if (!model->B3SOIPDpubGiven) + model->B3SOIPDpub = 0.0; + if (!model->B3SOIPDpucGiven) + model->B3SOIPDpuc = 0.0; + if (!model->B3SOIPDpvsatGiven) + model->B3SOIPDpvsat = 0.0; + if (!model->B3SOIPDpa0Given) + model->B3SOIPDpa0 = 0.0; + if (!model->B3SOIPDpagsGiven) + model->B3SOIPDpags = 0.0; + if (!model->B3SOIPDpb0Given) + model->B3SOIPDpb0 = 0.0; + if (!model->B3SOIPDpb1Given) + model->B3SOIPDpb1 = 0.0; + if (!model->B3SOIPDpketaGiven) + model->B3SOIPDpketa = 0.0; + if (!model->B3SOIPDpketasGiven) + model->B3SOIPDpketas = 0.0; + if (!model->B3SOIPDpa1Given) + model->B3SOIPDpa1 = 0.0; + if (!model->B3SOIPDpa2Given) + model->B3SOIPDpa2 = 0.0; + if (!model->B3SOIPDprdswGiven) + model->B3SOIPDprdsw = 0.0; + if (!model->B3SOIPDpprwbGiven) + model->B3SOIPDpprwb = 0.0; + if (!model->B3SOIPDpprwgGiven) + model->B3SOIPDpprwg = 0.0; + if (!model->B3SOIPDpwrGiven) + model->B3SOIPDpwr = 0.0; + if (!model->B3SOIPDpnfactorGiven) + model->B3SOIPDpnfactor = 0.0; + if (!model->B3SOIPDpdwgGiven) + model->B3SOIPDpdwg = 0.0; + if (!model->B3SOIPDpdwbGiven) + model->B3SOIPDpdwb = 0.0; + if (!model->B3SOIPDpvoffGiven) + model->B3SOIPDpvoff = 0.0; + if (!model->B3SOIPDpeta0Given) + model->B3SOIPDpeta0 = 0.0; + if (!model->B3SOIPDpetabGiven) + model->B3SOIPDpetab = 0.0; + if (!model->B3SOIPDpdsubGiven) + model->B3SOIPDpdsub = 0.0; + if (!model->B3SOIPDpcitGiven) + model->B3SOIPDpcit = 0.0; + if (!model->B3SOIPDpcdscGiven) + model->B3SOIPDpcdsc = 0.0; + if (!model->B3SOIPDpcdscbGiven) + model->B3SOIPDpcdscb = 0.0; + if (!model->B3SOIPDpcdscdGiven) + model->B3SOIPDpcdscd = 0.0; + if (!model->B3SOIPDppclmGiven) + model->B3SOIPDppclm = 0.0; + if (!model->B3SOIPDppdibl1Given) + model->B3SOIPDppdibl1 = 0.0; + if (!model->B3SOIPDppdibl2Given) + model->B3SOIPDppdibl2 = 0.0; + if (!model->B3SOIPDppdiblbGiven) + model->B3SOIPDppdiblb = 0.0; + if (!model->B3SOIPDpdroutGiven) + model->B3SOIPDpdrout = 0.0; + if (!model->B3SOIPDppvagGiven) + model->B3SOIPDppvag = 0.0; + if (!model->B3SOIPDpdeltaGiven) + model->B3SOIPDpdelta = 0.0; + if (!model->B3SOIPDpalpha0Given) + model->B3SOIPDpalpha0 = 0.0; + if (!model->B3SOIPDpfbjtiiGiven) + model->B3SOIPDpfbjtii = 0.0; + if (!model->B3SOIPDpbeta0Given) + model->B3SOIPDpbeta0 = 0.0; + if (!model->B3SOIPDpbeta1Given) + model->B3SOIPDpbeta1 = 0.0; + if (!model->B3SOIPDpbeta2Given) + model->B3SOIPDpbeta2 = 0.0; + if (!model->B3SOIPDpvdsatii0Given) + model->B3SOIPDpvdsatii0 = 0.0; + if (!model->B3SOIPDpliiGiven) + model->B3SOIPDplii = 0.0; + if (!model->B3SOIPDpesatiiGiven) + model->B3SOIPDpesatii = 0.0; + if (!model->B3SOIPDpsii0Given) + model->B3SOIPDpsii0 = 0.0; + if (!model->B3SOIPDpsii1Given) + model->B3SOIPDpsii1 = 0.0; + if (!model->B3SOIPDpsii2Given) + model->B3SOIPDpsii2 = 0.0; + if (!model->B3SOIPDpsiidGiven) + model->B3SOIPDpsiid = 0.0; + if (!model->B3SOIPDpagidlGiven) + model->B3SOIPDpagidl = 0.0; + if (!model->B3SOIPDpbgidlGiven) + model->B3SOIPDpbgidl = 0.0; + if (!model->B3SOIPDpngidlGiven) + model->B3SOIPDpngidl = 0.0; + if (!model->B3SOIPDpntunGiven) + model->B3SOIPDpntun = 0.0; + if (!model->B3SOIPDpndiodeGiven) + model->B3SOIPDpndiode = 0.0; + if (!model->B3SOIPDpnrecf0Given) + model->B3SOIPDpnrecf0 = 0.0; + if (!model->B3SOIPDpnrecr0Given) + model->B3SOIPDpnrecr0 = 0.0; + if (!model->B3SOIPDpisbjtGiven) + model->B3SOIPDpisbjt = 0.0; + if (!model->B3SOIPDpisdifGiven) + model->B3SOIPDpisdif = 0.0; + if (!model->B3SOIPDpisrecGiven) + model->B3SOIPDpisrec = 0.0; + if (!model->B3SOIPDpistunGiven) + model->B3SOIPDpistun = 0.0; + if (!model->B3SOIPDpvrec0Given) + model->B3SOIPDpvrec0 = 0.0; + if (!model->B3SOIPDpvtun0Given) + model->B3SOIPDpvtun0 = 0.0; + if (!model->B3SOIPDpnbjtGiven) + model->B3SOIPDpnbjt = 0.0; + if (!model->B3SOIPDplbjt0Given) + model->B3SOIPDplbjt0 = 0.0; + if (!model->B3SOIPDpvabjtGiven) + model->B3SOIPDpvabjt = 0.0; + if (!model->B3SOIPDpaelyGiven) + model->B3SOIPDpaely = 0.0; + if (!model->B3SOIPDpahliGiven) + model->B3SOIPDpahli = 0.0; + /* CV Model */ + if (!model->B3SOIPDpvsdfbGiven) + model->B3SOIPDpvsdfb = 0.0; + if (!model->B3SOIPDpvsdthGiven) + model->B3SOIPDpvsdth = 0.0; + if (!model->B3SOIPDpdelvtGiven) + model->B3SOIPDpdelvt = 0.0; + if (!model->B3SOIPDpacdeGiven) + model->B3SOIPDpacde = 0.0; + if (!model->B3SOIPDpmoinGiven) + model->B3SOIPDpmoin = 0.0; +/* Added for binning - END */ + + if (!model->B3SOIPDcfGiven) + model->B3SOIPDcf = 2.0 * EPSOX / PI + * log (1.0 + 0.4e-6 / model->B3SOIPDtox); + if (!model->B3SOIPDcgdoGiven) + { + if (model->B3SOIPDdlcGiven && (model->B3SOIPDdlc > 0.0)) + { + model->B3SOIPDcgdo = model->B3SOIPDdlc * model->B3SOIPDcox + - model->B3SOIPDcgdl; + } + else + model->B3SOIPDcgdo = 0.6 * model->B3SOIPDxj * model->B3SOIPDcox; + } + if (!model->B3SOIPDcgsoGiven) + { + if (model->B3SOIPDdlcGiven && (model->B3SOIPDdlc > 0.0)) + { + model->B3SOIPDcgso = model->B3SOIPDdlc * model->B3SOIPDcox + - model->B3SOIPDcgsl; + } + else + model->B3SOIPDcgso = 0.6 * model->B3SOIPDxj * model->B3SOIPDcox; + } + + if (!model->B3SOIPDcgeoGiven) + { + model->B3SOIPDcgeo = 0.0; + } + if (!model->B3SOIPDxpartGiven) + model->B3SOIPDxpart = 0.0; + if (!model->B3SOIPDsheetResistanceGiven) + model->B3SOIPDsheetResistance = 0.0; + if (!model->B3SOIPDcsdeswGiven) + model->B3SOIPDcsdesw = 0.0; + if (!model->B3SOIPDunitLengthGateSidewallJctCapGiven) + model->B3SOIPDunitLengthGateSidewallJctCap = 1e-10; + if (!model->B3SOIPDGatesidewallJctPotentialGiven) + model->B3SOIPDGatesidewallJctPotential = 0.7; + if (!model->B3SOIPDbodyJctGateSideGradingCoeffGiven) + model->B3SOIPDbodyJctGateSideGradingCoeff = 0.5; + if (!model->B3SOIPDoxideTrapDensityAGiven) + { + if (model->B3SOIPDtype == NMOS) + model->B3SOIPDoxideTrapDensityA = 1e20; + else + model->B3SOIPDoxideTrapDensityA = 9.9e18; + } + if (!model->B3SOIPDoxideTrapDensityBGiven) + { + if (model->B3SOIPDtype == NMOS) + model->B3SOIPDoxideTrapDensityB = 5e4; + else + model->B3SOIPDoxideTrapDensityB = 2.4e3; + } + if (!model->B3SOIPDoxideTrapDensityCGiven) + { + if (model->B3SOIPDtype == NMOS) + model->B3SOIPDoxideTrapDensityC = -1.4e-12; + else + model->B3SOIPDoxideTrapDensityC = 1.4e-12; + + } + if (!model->B3SOIPDemGiven) + model->B3SOIPDem = 4.1e7; /* V/m */ + if (!model->B3SOIPDefGiven) + model->B3SOIPDef = 1.0; + if (!model->B3SOIPDafGiven) + model->B3SOIPDaf = 1.0; + if (!model->B3SOIPDkfGiven) + model->B3SOIPDkf = 0.0; + if (!model->B3SOIPDnoifGiven) + model->B3SOIPDnoif = 1.0; + + /* loop through all the instances of the model */ + for (here = model->B3SOIPDinstances; here != NULL; + here = here->B3SOIPDnextInstance) + { /* allocate a chunk of the state vector */ + here->B3SOIPDstates = *states; + *states += B3SOIPDnumStates; + /* perform the parameter defaulting */ + if (!here->B3SOIPDdrainAreaGiven) + here->B3SOIPDdrainArea = 0.0; + if (!here->B3SOIPDdrainPerimeterGiven) + here->B3SOIPDdrainPerimeter = 0.0; + if (!here->B3SOIPDdrainSquaresGiven) + here->B3SOIPDdrainSquares = 1.0; + if (!here->B3SOIPDicVBSGiven) + here->B3SOIPDicVBS = 0; + if (!here->B3SOIPDicVDSGiven) + here->B3SOIPDicVDS = 0; + if (!here->B3SOIPDicVGSGiven) + here->B3SOIPDicVGS = 0; + if (!here->B3SOIPDicVESGiven) + here->B3SOIPDicVES = 0; + if (!here->B3SOIPDicVPSGiven) + here->B3SOIPDicVPS = 0; + if (!here->B3SOIPDbjtoffGiven) + here->B3SOIPDbjtoff = 0; + if (!here->B3SOIPDdebugModGiven) + here->B3SOIPDdebugMod = 0; + if (!here->B3SOIPDrth0Given) + here->B3SOIPDrth0 = model->B3SOIPDrth0; + if (!here->B3SOIPDcth0Given) + here->B3SOIPDcth0 = model->B3SOIPDcth0; + if (!here->B3SOIPDbodySquaresGiven) + here->B3SOIPDbodySquares = 1.0; + if (!here->B3SOIPDlGiven) + here->B3SOIPDl = 5e-6; + if (!here->B3SOIPDsourceAreaGiven) + here->B3SOIPDsourceArea = 0; + if (!here->B3SOIPDsourcePerimeterGiven) + here->B3SOIPDsourcePerimeter = 0; + if (!here->B3SOIPDsourceSquaresGiven) + here->B3SOIPDsourceSquares = 1; + if (!here->B3SOIPDwGiven) + here->B3SOIPDw = 5e-6; + + +/* v2.0 release */ + if (!here->B3SOIPDnbcGiven) + here->B3SOIPDnbc = 0; + if (!here->B3SOIPDnsegGiven) + here->B3SOIPDnseg = 1; + if (!here->B3SOIPDpdbcpGiven) + here->B3SOIPDpdbcp = 0; + if (!here->B3SOIPDpsbcpGiven) + here->B3SOIPDpsbcp = 0; + if (!here->B3SOIPDagbcpGiven) + here->B3SOIPDagbcp = 0; + if (!here->B3SOIPDaebcpGiven) + here->B3SOIPDaebcp = 0; + + if (!here->B3SOIPDoffGiven) + here->B3SOIPDoff = 0; + + /* process drain series resistance */ + if ((model->B3SOIPDsheetResistance > 0.0) && + (here->B3SOIPDdrainSquares > 0.0) && + (here->B3SOIPDdNodePrime == 0)) + { + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "drain"); + if (error) + return (error); + here->B3SOIPDdNodePrime = tmp->number; + } + else + { + here->B3SOIPDdNodePrime = here->B3SOIPDdNode; + } + + /* process source series resistance */ + if ((model->B3SOIPDsheetResistance > 0.0) && + (here->B3SOIPDsourceSquares > 0.0) && + (here->B3SOIPDsNodePrime == 0)) + { + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "source"); + if (error) + return (error); + here->B3SOIPDsNodePrime = tmp->number; + } + else + { + here->B3SOIPDsNodePrime = here->B3SOIPDsNode; + } + + /* process effective silicon film thickness */ + model->B3SOIPDcbox = 3.453133e-11 / model->B3SOIPDtbox; + model->B3SOIPDcsi = 1.03594e-10 / model->B3SOIPDtsi; + Cboxt = + model->B3SOIPDcbox * model->B3SOIPDcsi / (model->B3SOIPDcbox + + model->B3SOIPDcsi); + model->B3SOIPDqsi = + Charge_q * model->B3SOIPDnpeak * 1e6 * model->B3SOIPDtsi; + + + here->B3SOIPDfloat = 0; + if (here->B3SOIPDpNode == -1) + { /* floating body case -- 4-node */ + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Body"); + if (error) + return (error); + here->B3SOIPDbNode = tmp->number; + here->B3SOIPDpNode = 0; + here->B3SOIPDfloat = 1; + here->B3SOIPDbodyMod = 0; + } + else /* the 5th Node has been assigned */ + { + if (!here->B3SOIPDtnodeoutGiven) + { /* if t-node not assigned */ + if (here->B3SOIPDbNode == -1) + { /* 5-node body tie, bNode has not been assigned */ + if ((model->B3SOIPDrbody == 0.0) + && (model->B3SOIPDrbsh == 0.0)) + { /* ideal body tie, pNode is not used */ + here->B3SOIPDbNode = here->B3SOIPDpNode; + here->B3SOIPDbodyMod = 2; + } + else + { /* nonideal body tie */ + error = + CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Body"); + if (error) + return (error); + here->B3SOIPDbNode = tmp->number; + here->B3SOIPDbodyMod = 1; + } + } + else + { /* 6-node body tie, bNode has been assigned */ + if ((model->B3SOIPDrbody == 0.0) + && (model->B3SOIPDrbsh == 0.0)) + { + printf + ("\n Warning: model parameter rbody=0!\n"); + model->B3SOIPDrbody = 1e0; + here->B3SOIPDbodyMod = 1; + } + else + { /* nonideal body tie */ + here->B3SOIPDbodyMod = 1; + } + } + } + else + { /* t-node assigned */ + if (here->B3SOIPDbNode == -1) + { /* 4 nodes & t-node, floating body */ + error = + CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Body"); + if (error) + return (error); + here->B3SOIPDbNode = tmp->number; + here->B3SOIPDtempNode = here->B3SOIPDpNode; + here->B3SOIPDpNode = 0; + here->B3SOIPDfloat = 1; + here->B3SOIPDbodyMod = 0; + } + else + { /* 5 or 6 nodes & t-node, body-contact device */ + if (here->B3SOIPDtempNode == -1) + { /* 5 nodes & tnode */ + if ((model->B3SOIPDrbody == 0.0) + && (model->B3SOIPDrbsh == 0.0)) + { /* ideal body tie, pNode is not used */ + here->B3SOIPDtempNode = here->B3SOIPDbNode; + here->B3SOIPDbNode = here->B3SOIPDpNode; + here->B3SOIPDbodyMod = 2; + } + else + { /* nonideal body tie */ + here->B3SOIPDtempNode = here->B3SOIPDbNode; + error = + CKTmkVolt (ckt, &tmp, here->B3SOIPDname, + "Body"); + if (error) + return (error); + here->B3SOIPDbNode = tmp->number; + here->B3SOIPDbodyMod = 1; + } + } + else + { /* 6 nodes & t-node */ + if ((model->B3SOIPDrbody == 0.0) + && (model->B3SOIPDrbsh == 0.0)) + { + printf + ("\n Warning: model parameter rbody=0!\n"); + model->B3SOIPDrbody = 1e0; + here->B3SOIPDbodyMod = 1; + } + else + { /* nonideal body tie */ + here->B3SOIPDbodyMod = 1; + } + } + } + } + } + + + if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0 != 0)) + { + if (here->B3SOIPDtempNode == -1) + { + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Temp"); + if (error) + return (error); + here->B3SOIPDtempNode = tmp->number; + } + + } + else + { + here->B3SOIPDtempNode = 0; + } + +/* here for debugging purpose only */ + if (here->B3SOIPDdebugMod != 0) + { + /* The real Vbs value */ + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Vbs"); + if (error) + return (error); + here->B3SOIPDvbsNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Ids"); + if (error) + return (error); + here->B3SOIPDidsNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Ic"); + if (error) + return (error); + here->B3SOIPDicNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Ibs"); + if (error) + return (error); + here->B3SOIPDibsNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Ibd"); + if (error) + return (error); + here->B3SOIPDibdNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Iii"); + if (error) + return (error); + here->B3SOIPDiiiNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Ig"); + if (error) + return (error); + here->B3SOIPDigNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Gigg"); + if (error) + return (error); + here->B3SOIPDgiggNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Gigd"); + if (error) + return (error); + here->B3SOIPDgigdNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Gigb"); + if (error) + return (error); + here->B3SOIPDgigbNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Igidl"); + if (error) + return (error); + here->B3SOIPDigidlNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Itun"); + if (error) + return (error); + here->B3SOIPDitunNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Ibp"); + if (error) + return (error); + here->B3SOIPDibpNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Cbb"); + if (error) + return (error); + here->B3SOIPDcbbNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Cbd"); + if (error) + return (error); + here->B3SOIPDcbdNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Cbg"); + if (error) + return (error); + here->B3SOIPDcbgNode = tmp->number; + + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Qbf"); + if (error) + return (error); + here->B3SOIPDqbfNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Qjs"); + if (error) + return (error); + here->B3SOIPDqjsNode = tmp->number; + + error = CKTmkVolt (ckt, &tmp, here->B3SOIPDname, "Qjd"); + if (error) + return (error); + here->B3SOIPDqjdNode = 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->B3SOIPDshMod == 1) && (here->B3SOIPDrth0 != 0.0)) + { + TSTALLOC (B3SOIPDTemptempPtr, B3SOIPDtempNode, B3SOIPDtempNode) + TSTALLOC (B3SOIPDTempdpPtr, B3SOIPDtempNode, + B3SOIPDdNodePrime) TSTALLOC (B3SOIPDTempspPtr, + B3SOIPDtempNode, + B3SOIPDsNodePrime) + TSTALLOC (B3SOIPDTempgPtr, B3SOIPDtempNode, + B3SOIPDgNode) TSTALLOC (B3SOIPDTempbPtr, + B3SOIPDtempNode, + B3SOIPDbNode) + TSTALLOC (B3SOIPDGtempPtr, B3SOIPDgNode, + B3SOIPDtempNode) TSTALLOC (B3SOIPDDPtempPtr, + B3SOIPDdNodePrime, + B3SOIPDtempNode) + TSTALLOC (B3SOIPDSPtempPtr, B3SOIPDsNodePrime, + B3SOIPDtempNode) TSTALLOC (B3SOIPDEtempPtr, + B3SOIPDeNode, + B3SOIPDtempNode) + TSTALLOC (B3SOIPDBtempPtr, B3SOIPDbNode, + B3SOIPDtempNode) if (here->B3SOIPDbodyMod == 1) + { + TSTALLOC (B3SOIPDPtempPtr, B3SOIPDpNode, B3SOIPDtempNode)} + } + if (here->B3SOIPDbodyMod == 2) + { + /* Don't create any Jacobian entry for pNode */ + } + else if (here->B3SOIPDbodyMod == 1) + { + TSTALLOC (B3SOIPDBpPtr, B3SOIPDbNode, B3SOIPDpNode) + TSTALLOC (B3SOIPDPbPtr, B3SOIPDpNode, B3SOIPDbNode) + TSTALLOC (B3SOIPDPpPtr, B3SOIPDpNode, B3SOIPDpNode)} + + TSTALLOC (B3SOIPDEbPtr, B3SOIPDeNode, B3SOIPDbNode) + TSTALLOC (B3SOIPDGbPtr, B3SOIPDgNode, B3SOIPDbNode) + TSTALLOC (B3SOIPDDPbPtr, B3SOIPDdNodePrime, B3SOIPDbNode) + TSTALLOC (B3SOIPDSPbPtr, B3SOIPDsNodePrime, B3SOIPDbNode) + TSTALLOC (B3SOIPDBePtr, B3SOIPDbNode, B3SOIPDeNode) + TSTALLOC (B3SOIPDBgPtr, B3SOIPDbNode, B3SOIPDgNode) + TSTALLOC (B3SOIPDBdpPtr, B3SOIPDbNode, B3SOIPDdNodePrime) + TSTALLOC (B3SOIPDBspPtr, B3SOIPDbNode, B3SOIPDsNodePrime) + TSTALLOC (B3SOIPDBbPtr, B3SOIPDbNode, B3SOIPDbNode) + TSTALLOC (B3SOIPDEgPtr, B3SOIPDeNode, B3SOIPDgNode) + TSTALLOC (B3SOIPDEdpPtr, B3SOIPDeNode, B3SOIPDdNodePrime) + TSTALLOC (B3SOIPDEspPtr, B3SOIPDeNode, B3SOIPDsNodePrime) + TSTALLOC (B3SOIPDGePtr, B3SOIPDgNode, B3SOIPDeNode) + TSTALLOC (B3SOIPDDPePtr, B3SOIPDdNodePrime, B3SOIPDeNode) + TSTALLOC (B3SOIPDSPePtr, B3SOIPDsNodePrime, B3SOIPDeNode) + TSTALLOC (B3SOIPDEbPtr, B3SOIPDeNode, B3SOIPDbNode) + TSTALLOC (B3SOIPDEePtr, B3SOIPDeNode, B3SOIPDeNode) + TSTALLOC (B3SOIPDGgPtr, B3SOIPDgNode, B3SOIPDgNode) + TSTALLOC (B3SOIPDGdpPtr, B3SOIPDgNode, B3SOIPDdNodePrime) + TSTALLOC (B3SOIPDGspPtr, B3SOIPDgNode, B3SOIPDsNodePrime) + TSTALLOC (B3SOIPDDPgPtr, B3SOIPDdNodePrime, B3SOIPDgNode) + TSTALLOC (B3SOIPDDPdpPtr, B3SOIPDdNodePrime, B3SOIPDdNodePrime) + TSTALLOC (B3SOIPDDPspPtr, B3SOIPDdNodePrime, B3SOIPDsNodePrime) + TSTALLOC (B3SOIPDDPdPtr, B3SOIPDdNodePrime, B3SOIPDdNode) + TSTALLOC (B3SOIPDSPgPtr, B3SOIPDsNodePrime, B3SOIPDgNode) + TSTALLOC (B3SOIPDSPdpPtr, B3SOIPDsNodePrime, B3SOIPDdNodePrime) + TSTALLOC (B3SOIPDSPspPtr, B3SOIPDsNodePrime, B3SOIPDsNodePrime) + TSTALLOC (B3SOIPDSPsPtr, B3SOIPDsNodePrime, B3SOIPDsNode) + TSTALLOC (B3SOIPDDdPtr, B3SOIPDdNode, B3SOIPDdNode) + TSTALLOC (B3SOIPDDdpPtr, B3SOIPDdNode, B3SOIPDdNodePrime) + TSTALLOC (B3SOIPDSsPtr, B3SOIPDsNode, B3SOIPDsNode) + TSTALLOC (B3SOIPDSspPtr, B3SOIPDsNode, B3SOIPDsNodePrime) +/* here for debugging purpose only */ + if (here->B3SOIPDdebugMod != 0) + { + TSTALLOC (B3SOIPDVbsPtr, B3SOIPDvbsNode, B3SOIPDvbsNode) + TSTALLOC (B3SOIPDIdsPtr, B3SOIPDidsNode, B3SOIPDidsNode) + TSTALLOC (B3SOIPDIcPtr, B3SOIPDicNode, B3SOIPDicNode) + TSTALLOC (B3SOIPDIbsPtr, B3SOIPDibsNode, B3SOIPDibsNode) + TSTALLOC (B3SOIPDIbdPtr, B3SOIPDibdNode, B3SOIPDibdNode) + TSTALLOC (B3SOIPDIiiPtr, B3SOIPDiiiNode, B3SOIPDiiiNode) + TSTALLOC (B3SOIPDIgPtr, B3SOIPDigNode, B3SOIPDigNode) + TSTALLOC (B3SOIPDGiggPtr, B3SOIPDgiggNode, B3SOIPDgiggNode) + TSTALLOC (B3SOIPDGigdPtr, B3SOIPDgigdNode, B3SOIPDgigdNode) + TSTALLOC (B3SOIPDGigbPtr, B3SOIPDgigbNode, B3SOIPDgigbNode) + TSTALLOC (B3SOIPDIgidlPtr, B3SOIPDigidlNode, B3SOIPDigidlNode) + TSTALLOC (B3SOIPDItunPtr, B3SOIPDitunNode, B3SOIPDitunNode) + TSTALLOC (B3SOIPDIbpPtr, B3SOIPDibpNode, B3SOIPDibpNode) + TSTALLOC (B3SOIPDCbbPtr, B3SOIPDcbbNode, B3SOIPDcbbNode) + TSTALLOC (B3SOIPDCbdPtr, B3SOIPDcbdNode, B3SOIPDcbdNode) + TSTALLOC (B3SOIPDCbgPtr, B3SOIPDcbgNode, B3SOIPDcbgNode) + TSTALLOC (B3SOIPDQbfPtr, B3SOIPDqbfNode, B3SOIPDqbfNode) + TSTALLOC (B3SOIPDQjsPtr, B3SOIPDqjsNode, B3SOIPDqjsNode) + TSTALLOC (B3SOIPDQjdPtr, B3SOIPDqjdNode, B3SOIPDqjdNode)} + + } + } + return (OK); +} + +int +B3SOIPDunsetup (inModel, ckt) + GENmodel *inModel; + CKTcircuit *ckt; +{ +#ifndef HAS_BATCHSIM + B3SOIPDmodel *model; + B3SOIPDinstance *here; + + for (model = (B3SOIPDmodel *) inModel; model != NULL; + model = model->B3SOIPDnextModel) + { + for (here = model->B3SOIPDinstances; here != NULL; + here = here->B3SOIPDnextInstance) + { + if (here->B3SOIPDdNodePrime + && here->B3SOIPDdNodePrime != here->B3SOIPDdNode) + { + CKTdltNNum (ckt, here->B3SOIPDdNodePrime); + here->B3SOIPDdNodePrime = 0; + } + if (here->B3SOIPDsNodePrime + && here->B3SOIPDsNodePrime != here->B3SOIPDsNode) + { + CKTdltNNum (ckt, here->B3SOIPDsNodePrime); + here->B3SOIPDsNodePrime = 0; + } + } + } +#endif + return OK; +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdtemp.c b/src/spicelib/devices/bsim3soi_pd/b3soipdtemp.c new file mode 100644 index 000000000..2b51a1879 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdtemp.c @@ -0,0 +1,1037 @@ +/********** +Copyright 1990 Regents of the University of California. All rights reserved. +Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang +File: b3soipdtemp.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 +**********/ + +/* Lmin, Lmax, Wmin, Wmax */ + +#include "ngspice.h" +#include +#include +#include "smpdefs.h" +#include "cktdefs.h" +#include "b3soipddef.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 +B3SOIPDtemp (inModel, ckt) + GENmodel *inModel; + CKTcircuit *ckt; +{ + register B3SOIPDmodel *model = (B3SOIPDmodel *) inModel; + register B3SOIPDinstance *here; + struct b3soipdSizeDependParam *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 B3SOIPD device models */ + for (; model != NULL; model = model->B3SOIPDnextModel) + { + Temp = ckt->CKTtemp; + if (model->B3SOIPDGatesidewallJctPotential < 0.1) + model->B3SOIPDGatesidewallJctPotential = 0.1; + model->pSizeDependParamKnot = NULL; + pLastKnot = NULL; + + Tnom = model->B3SOIPDtnom; + TempRatio = Temp / Tnom; + + model->B3SOIPDvcrit = + CONSTvt0 * log (CONSTvt0 / (CONSTroot2 * 1.0e-14)); + model->B3SOIPDfactor1 = sqrt (EPSSI / EPSOX * model->B3SOIPDtox); + + Vtm0 = KboQ * Tnom; + Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0); + model->B3SOIPDeg0 = Eg0; + model->B3SOIPDvtm = 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->B3SOIPDvtm)); + + + /* loop through all the instances of the model */ + /* MCJ: Length and Width not initialized */ + for (here = model->B3SOIPDinstances; here != NULL; + here = here->B3SOIPDnextInstance) + { + here->B3SOIPDrbodyext = here->B3SOIPDbodySquares * + model->B3SOIPDrbsh; + pSizeDependParamKnot = model->pSizeDependParamKnot; + Size_Not_Found = 1; + while ((pSizeDependParamKnot != NULL) && Size_Not_Found) + { + if ((here->B3SOIPDl == pSizeDependParamKnot->Length) + && (here->B3SOIPDw == pSizeDependParamKnot->Width) + && (here->B3SOIPDrth0 == pSizeDependParamKnot->Rth0) + && (here->B3SOIPDcth0 == pSizeDependParamKnot->Cth0)) + { + Size_Not_Found = 0; + here->pParam = pSizeDependParamKnot; + } + else + { + pLastKnot = pSizeDependParamKnot; + pSizeDependParamKnot = pSizeDependParamKnot->pNext; + } + } + + if (Size_Not_Found) + { + pParam = + (struct b3soipdSizeDependParam *) + malloc (sizeof (struct b3soipdSizeDependParam)); + if (pLastKnot == NULL) + model->pSizeDependParamKnot = pParam; + else + pLastKnot->pNext = pParam; + pParam->pNext = NULL; + here->pParam = pParam; + + Ldrn = here->B3SOIPDl; + Wdrn = here->B3SOIPDw; + pParam->Length = Ldrn; + pParam->Width = Wdrn; + pParam->Rth0 = here->B3SOIPDrth0; + pParam->Cth0 = here->B3SOIPDcth0; + + T0 = pow (Ldrn, model->B3SOIPDLln); + T1 = pow (Wdrn, model->B3SOIPDLwn); + tmp1 = model->B3SOIPDLl / T0 + model->B3SOIPDLw / T1 + + model->B3SOIPDLwl / (T0 * T1); + pParam->B3SOIPDdl = model->B3SOIPDLint + tmp1; + pParam->B3SOIPDdlc = model->B3SOIPDdlc + tmp1; + + T2 = pow (Ldrn, model->B3SOIPDWln); + T3 = pow (Wdrn, model->B3SOIPDWwn); + tmp2 = model->B3SOIPDWl / T2 + model->B3SOIPDWw / T3 + + model->B3SOIPDWwl / (T2 * T3); + pParam->B3SOIPDdw = model->B3SOIPDWint + tmp2; + pParam->B3SOIPDdwc = model->B3SOIPDdwc + tmp2; + + pParam->B3SOIPDleff = here->B3SOIPDl - 2.0 * pParam->B3SOIPDdl; + if (pParam->B3SOIPDleff <= 0.0) + { + IFuid namarray[2]; + namarray[0] = model->B3SOIPDmodName; + namarray[1] = here->B3SOIPDname; + (*(SPfrontEnd->IFerror)) (ERR_FATAL, + "B3SOIPD: mosfet %s, model %s: Effective channel length <= 0", + namarray); + return (E_BADPARM); + } + + pParam->B3SOIPDweff = + here->B3SOIPDw - here->B3SOIPDnbc * model->B3SOIPDdwbc - + (2.0 - here->B3SOIPDnbc) * pParam->B3SOIPDdw; + if (pParam->B3SOIPDweff <= 0.0) + { + IFuid namarray[2]; + namarray[0] = model->B3SOIPDmodName; + namarray[1] = here->B3SOIPDname; + (*(SPfrontEnd->IFerror)) (ERR_FATAL, + "B3SOIPD: mosfet %s, model %s: Effective channel width <= 0", + namarray); + return (E_BADPARM); + } + + pParam->B3SOIPDwdiod = + pParam->B3SOIPDweff / here->B3SOIPDnseg + here->B3SOIPDpdbcp; + pParam->B3SOIPDwdios = + pParam->B3SOIPDweff / here->B3SOIPDnseg + here->B3SOIPDpsbcp; + + pParam->B3SOIPDleffCV = + here->B3SOIPDl - 2.0 * pParam->B3SOIPDdlc; + if (pParam->B3SOIPDleffCV <= 0.0) + { + IFuid namarray[2]; + namarray[0] = model->B3SOIPDmodName; + namarray[1] = here->B3SOIPDname; + (*(SPfrontEnd->IFerror)) (ERR_FATAL, + "B3SOIPD: mosfet %s, model %s: Effective channel length for C-V <= 0", + namarray); + return (E_BADPARM); + } + + pParam->B3SOIPDweffCV = + here->B3SOIPDw - here->B3SOIPDnbc * model->B3SOIPDdwbc - + (2.0 - here->B3SOIPDnbc) * pParam->B3SOIPDdwc; + if (pParam->B3SOIPDweffCV <= 0.0) + { + IFuid namarray[2]; + namarray[0] = model->B3SOIPDmodName; + namarray[1] = here->B3SOIPDname; + (*(SPfrontEnd->IFerror)) (ERR_FATAL, + "B3SOIPD: mosfet %s, model %s: Effective channel width for C-V <= 0", + namarray); + return (E_BADPARM); + } + + pParam->B3SOIPDwdiodCV = + pParam->B3SOIPDweffCV / here->B3SOIPDnseg + + here->B3SOIPDpdbcp; + pParam->B3SOIPDwdiosCV = + pParam->B3SOIPDweffCV / here->B3SOIPDnseg + + here->B3SOIPDpsbcp; + + pParam->B3SOIPDleffCVb = + here->B3SOIPDl - 2.0 * pParam->B3SOIPDdlc - + model->B3SOIPDdlcb; + if (pParam->B3SOIPDleffCVb <= 0.0) + { + IFuid namarray[2]; + namarray[0] = model->B3SOIPDmodName; + namarray[1] = here->B3SOIPDname; + (*(SPfrontEnd->IFerror)) (ERR_FATAL, + "B3SOIPD: mosfet %s, model %s: Effective channel length for C-V (body) <= 0", + namarray); + return (E_BADPARM); + } + + pParam->B3SOIPDleffCVbg = + pParam->B3SOIPDleffCVb + 2 * model->B3SOIPDdlbg; + if (pParam->B3SOIPDleffCVbg <= 0.0) + { + IFuid namarray[2]; + namarray[0] = model->B3SOIPDmodName; + namarray[1] = here->B3SOIPDname; + (*(SPfrontEnd->IFerror)) (ERR_FATAL, + "B3SOIPD: mosfet %s, model %s: Effective channel length for C-V (backgate) <= 0", + namarray); + return (E_BADPARM); + } + + /* Not binned - START */ + pParam->B3SOIPDat = model->B3SOIPDat; + pParam->B3SOIPDgamma1 = model->B3SOIPDgamma1; + pParam->B3SOIPDgamma2 = model->B3SOIPDgamma2; + pParam->B3SOIPDvbx = model->B3SOIPDvbx; + pParam->B3SOIPDvbm = model->B3SOIPDvbm; + pParam->B3SOIPDxt = model->B3SOIPDxt; + pParam->B3SOIPDkt1 = model->B3SOIPDkt1; + pParam->B3SOIPDkt1l = model->B3SOIPDkt1l; + pParam->B3SOIPDkt2 = model->B3SOIPDkt2; + pParam->B3SOIPDua1 = model->B3SOIPDua1; + pParam->B3SOIPDub1 = model->B3SOIPDub1; + pParam->B3SOIPDuc1 = model->B3SOIPDuc1; + pParam->B3SOIPDute = model->B3SOIPDute; + pParam->B3SOIPDprt = model->B3SOIPDprt; + /* Not binned - END */ + + /* CV model */ + pParam->B3SOIPDcgsl = model->B3SOIPDcgsl; + pParam->B3SOIPDcgdl = model->B3SOIPDcgdl; + pParam->B3SOIPDckappa = model->B3SOIPDckappa; + pParam->B3SOIPDcf = model->B3SOIPDcf; + pParam->B3SOIPDclc = model->B3SOIPDclc; + pParam->B3SOIPDcle = model->B3SOIPDcle; + + pParam->B3SOIPDabulkCVfactor = + 1.0 + pow ((pParam->B3SOIPDclc / pParam->B3SOIPDleff), + pParam->B3SOIPDcle); + + /* Added for binning - START */ + if (model->B3SOIPDbinUnit == 1) + { + Inv_L = 1.0e-6 / pParam->B3SOIPDleff; + Inv_W = 1.0e-6 / pParam->B3SOIPDweff; + Inv_LW = 1.0e-12 / (pParam->B3SOIPDleff + * pParam->B3SOIPDweff); + } + else + { + Inv_L = 1.0 / pParam->B3SOIPDleff; + Inv_W = 1.0 / pParam->B3SOIPDweff; + Inv_LW = 1.0 / (pParam->B3SOIPDleff * pParam->B3SOIPDweff); + } + pParam->B3SOIPDnpeak = model->B3SOIPDnpeak + + model->B3SOIPDlnpeak * Inv_L + + model->B3SOIPDwnpeak * Inv_W + + model->B3SOIPDpnpeak * Inv_LW; + pParam->B3SOIPDnsub = model->B3SOIPDnsub + + model->B3SOIPDlnsub * Inv_L + + model->B3SOIPDwnsub * Inv_W + model->B3SOIPDpnsub * Inv_LW; + pParam->B3SOIPDngate = model->B3SOIPDngate + + model->B3SOIPDlngate * Inv_L + + model->B3SOIPDwngate * Inv_W + + model->B3SOIPDpngate * Inv_LW; + pParam->B3SOIPDvth0 = model->B3SOIPDvth0 + + model->B3SOIPDlvth0 * Inv_L + + model->B3SOIPDwvth0 * Inv_W + model->B3SOIPDpvth0 * Inv_LW; + pParam->B3SOIPDk1 = model->B3SOIPDk1 + + model->B3SOIPDlk1 * Inv_L + + model->B3SOIPDwk1 * Inv_W + model->B3SOIPDpk1 * Inv_LW; + pParam->B3SOIPDk2 = model->B3SOIPDk2 + + model->B3SOIPDlk2 * Inv_L + + model->B3SOIPDwk2 * Inv_W + model->B3SOIPDpk2 * Inv_LW; + pParam->B3SOIPDk1w1 = model->B3SOIPDk1w1 + + model->B3SOIPDlk1w1 * Inv_L + + model->B3SOIPDwk1w1 * Inv_W + model->B3SOIPDpk1w1 * Inv_LW; + pParam->B3SOIPDk1w2 = model->B3SOIPDk1w2 + + model->B3SOIPDlk1w2 * Inv_L + + model->B3SOIPDwk1w2 * Inv_W + model->B3SOIPDpk1w2 * Inv_LW; + pParam->B3SOIPDk3 = model->B3SOIPDk3 + + model->B3SOIPDlk3 * Inv_L + + model->B3SOIPDwk3 * Inv_W + model->B3SOIPDpk3 * Inv_LW; + pParam->B3SOIPDk3b = model->B3SOIPDk3b + + model->B3SOIPDlk3b * Inv_L + + model->B3SOIPDwk3b * Inv_W + model->B3SOIPDpk3b * Inv_LW; + pParam->B3SOIPDkb1 = model->B3SOIPDkb1 + + model->B3SOIPDlkb1 * Inv_L + + model->B3SOIPDwkb1 * Inv_W + model->B3SOIPDpkb1 * Inv_LW; + pParam->B3SOIPDw0 = model->B3SOIPDw0 + + model->B3SOIPDlw0 * Inv_L + + model->B3SOIPDww0 * Inv_W + model->B3SOIPDpw0 * Inv_LW; + pParam->B3SOIPDnlx = model->B3SOIPDnlx + + model->B3SOIPDlnlx * Inv_L + + model->B3SOIPDwnlx * Inv_W + model->B3SOIPDpnlx * Inv_LW; + pParam->B3SOIPDdvt0 = model->B3SOIPDdvt0 + + model->B3SOIPDldvt0 * Inv_L + + model->B3SOIPDwdvt0 * Inv_W + model->B3SOIPDpdvt0 * Inv_LW; + pParam->B3SOIPDdvt1 = model->B3SOIPDdvt1 + + model->B3SOIPDldvt1 * Inv_L + + model->B3SOIPDwdvt1 * Inv_W + model->B3SOIPDpdvt1 * Inv_LW; + pParam->B3SOIPDdvt2 = model->B3SOIPDdvt2 + + model->B3SOIPDldvt2 * Inv_L + + model->B3SOIPDwdvt2 * Inv_W + model->B3SOIPDpdvt2 * Inv_LW; + pParam->B3SOIPDdvt0w = model->B3SOIPDdvt0w + + model->B3SOIPDldvt0w * Inv_L + + model->B3SOIPDwdvt0w * Inv_W + + model->B3SOIPDpdvt0w * Inv_LW; + pParam->B3SOIPDdvt1w = model->B3SOIPDdvt1w + + model->B3SOIPDldvt1w * Inv_L + + model->B3SOIPDwdvt1w * Inv_W + + model->B3SOIPDpdvt1w * Inv_LW; + pParam->B3SOIPDdvt2w = model->B3SOIPDdvt2w + + model->B3SOIPDldvt2w * Inv_L + + model->B3SOIPDwdvt2w * Inv_W + + model->B3SOIPDpdvt2w * Inv_LW; + pParam->B3SOIPDu0 = model->B3SOIPDu0 + + model->B3SOIPDlu0 * Inv_L + + model->B3SOIPDwu0 * Inv_W + model->B3SOIPDpu0 * Inv_LW; + pParam->B3SOIPDua = model->B3SOIPDua + + model->B3SOIPDlua * Inv_L + + model->B3SOIPDwua * Inv_W + model->B3SOIPDpua * Inv_LW; + pParam->B3SOIPDub = model->B3SOIPDub + + model->B3SOIPDlub * Inv_L + + model->B3SOIPDwub * Inv_W + model->B3SOIPDpub * Inv_LW; + pParam->B3SOIPDuc = model->B3SOIPDuc + + model->B3SOIPDluc * Inv_L + + model->B3SOIPDwuc * Inv_W + model->B3SOIPDpuc * Inv_LW; + pParam->B3SOIPDvsat = model->B3SOIPDvsat + + model->B3SOIPDlvsat * Inv_L + + model->B3SOIPDwvsat * Inv_W + model->B3SOIPDpvsat * Inv_LW; + pParam->B3SOIPDa0 = model->B3SOIPDa0 + + model->B3SOIPDla0 * Inv_L + + model->B3SOIPDwa0 * Inv_W + model->B3SOIPDpa0 * Inv_LW; + pParam->B3SOIPDags = model->B3SOIPDags + + model->B3SOIPDlags * Inv_L + + model->B3SOIPDwags * Inv_W + model->B3SOIPDpags * Inv_LW; + pParam->B3SOIPDb0 = model->B3SOIPDb0 + + model->B3SOIPDlb0 * Inv_L + + model->B3SOIPDwb0 * Inv_W + model->B3SOIPDpb0 * Inv_LW; + pParam->B3SOIPDb1 = model->B3SOIPDb1 + + model->B3SOIPDlb1 * Inv_L + + model->B3SOIPDwb1 * Inv_W + model->B3SOIPDpb1 * Inv_LW; + pParam->B3SOIPDketa = model->B3SOIPDketa + + model->B3SOIPDlketa * Inv_L + + model->B3SOIPDwketa * Inv_W + model->B3SOIPDpketa * Inv_LW; + pParam->B3SOIPDketas = model->B3SOIPDketas + + model->B3SOIPDlketas * Inv_L + + model->B3SOIPDwketas * Inv_W + + model->B3SOIPDpketas * Inv_LW; + pParam->B3SOIPDa1 = model->B3SOIPDa1 + + model->B3SOIPDla1 * Inv_L + + model->B3SOIPDwa1 * Inv_W + model->B3SOIPDpa1 * Inv_LW; + pParam->B3SOIPDa2 = model->B3SOIPDa2 + + model->B3SOIPDla2 * Inv_L + + model->B3SOIPDwa2 * Inv_W + model->B3SOIPDpa2 * Inv_LW; + pParam->B3SOIPDrdsw = model->B3SOIPDrdsw + + model->B3SOIPDlrdsw * Inv_L + + model->B3SOIPDwrdsw * Inv_W + model->B3SOIPDprdsw * Inv_LW; + pParam->B3SOIPDprwb = model->B3SOIPDprwb + + model->B3SOIPDlprwb * Inv_L + + model->B3SOIPDwprwb * Inv_W + model->B3SOIPDpprwb * Inv_LW; + pParam->B3SOIPDprwg = model->B3SOIPDprwg + + model->B3SOIPDlprwg * Inv_L + + model->B3SOIPDwprwg * Inv_W + model->B3SOIPDpprwg * Inv_LW; + pParam->B3SOIPDwr = model->B3SOIPDwr + + model->B3SOIPDlwr * Inv_L + + model->B3SOIPDwwr * Inv_W + model->B3SOIPDpwr * Inv_LW; + pParam->B3SOIPDnfactor = model->B3SOIPDnfactor + + model->B3SOIPDlnfactor * Inv_L + + model->B3SOIPDwnfactor * Inv_W + + model->B3SOIPDpnfactor * Inv_LW; + pParam->B3SOIPDdwg = model->B3SOIPDdwg + + model->B3SOIPDldwg * Inv_L + + model->B3SOIPDwdwg * Inv_W + model->B3SOIPDpdwg * Inv_LW; + pParam->B3SOIPDdwb = model->B3SOIPDdwb + + model->B3SOIPDldwb * Inv_L + + model->B3SOIPDwdwb * Inv_W + model->B3SOIPDpdwb * Inv_LW; + pParam->B3SOIPDvoff = model->B3SOIPDvoff + + model->B3SOIPDlvoff * Inv_L + + model->B3SOIPDwvoff * Inv_W + model->B3SOIPDpvoff * Inv_LW; + pParam->B3SOIPDeta0 = model->B3SOIPDeta0 + + model->B3SOIPDleta0 * Inv_L + + model->B3SOIPDweta0 * Inv_W + model->B3SOIPDpeta0 * Inv_LW; + pParam->B3SOIPDetab = model->B3SOIPDetab + + model->B3SOIPDletab * Inv_L + + model->B3SOIPDwetab * Inv_W + model->B3SOIPDpetab * Inv_LW; + pParam->B3SOIPDdsub = model->B3SOIPDdsub + + model->B3SOIPDldsub * Inv_L + + model->B3SOIPDwdsub * Inv_W + model->B3SOIPDpdsub * Inv_LW; + pParam->B3SOIPDcit = model->B3SOIPDcit + + model->B3SOIPDlcit * Inv_L + + model->B3SOIPDwcit * Inv_W + model->B3SOIPDpcit * Inv_LW; + pParam->B3SOIPDcdsc = model->B3SOIPDcdsc + + model->B3SOIPDlcdsc * Inv_L + + model->B3SOIPDwcdsc * Inv_W + model->B3SOIPDpcdsc * Inv_LW; + pParam->B3SOIPDcdscb = model->B3SOIPDcdscb + + model->B3SOIPDlcdscb * Inv_L + + model->B3SOIPDwcdscb * Inv_W + + model->B3SOIPDpcdscb * Inv_LW; + pParam->B3SOIPDcdscd = model->B3SOIPDcdscd + + model->B3SOIPDlcdscd * Inv_L + + model->B3SOIPDwcdscd * Inv_W + + model->B3SOIPDpcdscd * Inv_LW; + pParam->B3SOIPDpclm = model->B3SOIPDpclm + + model->B3SOIPDlpclm * Inv_L + + model->B3SOIPDwpclm * Inv_W + model->B3SOIPDppclm * Inv_LW; + pParam->B3SOIPDpdibl1 = model->B3SOIPDpdibl1 + + model->B3SOIPDlpdibl1 * Inv_L + + model->B3SOIPDwpdibl1 * Inv_W + + model->B3SOIPDppdibl1 * Inv_LW; + pParam->B3SOIPDpdibl2 = model->B3SOIPDpdibl2 + + model->B3SOIPDlpdibl2 * Inv_L + + model->B3SOIPDwpdibl2 * Inv_W + + model->B3SOIPDppdibl2 * Inv_LW; + pParam->B3SOIPDpdiblb = model->B3SOIPDpdiblb + + model->B3SOIPDlpdiblb * Inv_L + + model->B3SOIPDwpdiblb * Inv_W + + model->B3SOIPDppdiblb * Inv_LW; + pParam->B3SOIPDdrout = model->B3SOIPDdrout + + model->B3SOIPDldrout * Inv_L + + model->B3SOIPDwdrout * Inv_W + + model->B3SOIPDpdrout * Inv_LW; + pParam->B3SOIPDpvag = model->B3SOIPDpvag + + model->B3SOIPDlpvag * Inv_L + + model->B3SOIPDwpvag * Inv_W + model->B3SOIPDppvag * Inv_LW; + pParam->B3SOIPDdelta = model->B3SOIPDdelta + + model->B3SOIPDldelta * Inv_L + + model->B3SOIPDwdelta * Inv_W + + model->B3SOIPDpdelta * Inv_LW; + pParam->B3SOIPDalpha0 = model->B3SOIPDalpha0 + + model->B3SOIPDlalpha0 * Inv_L + + model->B3SOIPDwalpha0 * Inv_W + + model->B3SOIPDpalpha0 * Inv_LW; + pParam->B3SOIPDfbjtii = model->B3SOIPDfbjtii + + model->B3SOIPDlfbjtii * Inv_L + + model->B3SOIPDwfbjtii * Inv_W + + model->B3SOIPDpfbjtii * Inv_LW; + pParam->B3SOIPDbeta0 = model->B3SOIPDbeta0 + + model->B3SOIPDlbeta0 * Inv_L + + model->B3SOIPDwbeta0 * Inv_W + + model->B3SOIPDpbeta0 * Inv_LW; + pParam->B3SOIPDbeta1 = model->B3SOIPDbeta1 + + model->B3SOIPDlbeta1 * Inv_L + + model->B3SOIPDwbeta1 * Inv_W + + model->B3SOIPDpbeta1 * Inv_LW; + pParam->B3SOIPDbeta2 = model->B3SOIPDbeta2 + + model->B3SOIPDlbeta2 * Inv_L + + model->B3SOIPDwbeta2 * Inv_W + + model->B3SOIPDpbeta2 * Inv_LW; + pParam->B3SOIPDvdsatii0 = model->B3SOIPDvdsatii0 + + model->B3SOIPDlvdsatii0 * Inv_L + + model->B3SOIPDwvdsatii0 * Inv_W + + model->B3SOIPDpvdsatii0 * Inv_LW; + pParam->B3SOIPDlii = model->B3SOIPDlii + + model->B3SOIPDllii * Inv_L + + model->B3SOIPDwlii * Inv_W + model->B3SOIPDplii * Inv_LW; + pParam->B3SOIPDesatii = model->B3SOIPDesatii + + model->B3SOIPDlesatii * Inv_L + + model->B3SOIPDwesatii * Inv_W + + model->B3SOIPDpesatii * Inv_LW; + pParam->B3SOIPDsii0 = model->B3SOIPDsii0 + + model->B3SOIPDlsii0 * Inv_L + + model->B3SOIPDwsii0 * Inv_W + model->B3SOIPDpsii0 * Inv_LW; + pParam->B3SOIPDsii1 = model->B3SOIPDsii1 + + model->B3SOIPDlsii1 * Inv_L + + model->B3SOIPDwsii1 * Inv_W + model->B3SOIPDpsii1 * Inv_LW; + pParam->B3SOIPDsii2 = model->B3SOIPDsii2 + + model->B3SOIPDlsii2 * Inv_L + + model->B3SOIPDwsii2 * Inv_W + model->B3SOIPDpsii2 * Inv_LW; + pParam->B3SOIPDsiid = model->B3SOIPDsiid + + model->B3SOIPDlsiid * Inv_L + + model->B3SOIPDwsiid * Inv_W + model->B3SOIPDpsiid * Inv_LW; + pParam->B3SOIPDagidl = model->B3SOIPDagidl + + model->B3SOIPDlagidl * Inv_L + + model->B3SOIPDwagidl * Inv_W + + model->B3SOIPDpagidl * Inv_LW; + pParam->B3SOIPDbgidl = model->B3SOIPDbgidl + + model->B3SOIPDlbgidl * Inv_L + + model->B3SOIPDwbgidl * Inv_W + + model->B3SOIPDpbgidl * Inv_LW; + pParam->B3SOIPDngidl = model->B3SOIPDngidl + + model->B3SOIPDlngidl * Inv_L + + model->B3SOIPDwngidl * Inv_W + + model->B3SOIPDpngidl * Inv_LW; + pParam->B3SOIPDntun = model->B3SOIPDntun + + model->B3SOIPDlntun * Inv_L + + model->B3SOIPDwntun * Inv_W + model->B3SOIPDpntun * Inv_LW; + pParam->B3SOIPDndiode = model->B3SOIPDndiode + + model->B3SOIPDlndiode * Inv_L + + model->B3SOIPDwndiode * Inv_W + + model->B3SOIPDpndiode * Inv_LW; + pParam->B3SOIPDnrecf0 = model->B3SOIPDnrecf0 + + model->B3SOIPDlnrecf0 * Inv_L + + model->B3SOIPDwnrecf0 * Inv_W + + model->B3SOIPDpnrecf0 * Inv_LW; + pParam->B3SOIPDnrecr0 = model->B3SOIPDnrecr0 + + model->B3SOIPDlnrecr0 * Inv_L + + model->B3SOIPDwnrecr0 * Inv_W + + model->B3SOIPDpnrecr0 * Inv_LW; + pParam->B3SOIPDisbjt = model->B3SOIPDisbjt + + model->B3SOIPDlisbjt * Inv_L + + model->B3SOIPDwisbjt * Inv_W + + model->B3SOIPDpisbjt * Inv_LW; + pParam->B3SOIPDisdif = model->B3SOIPDisdif + + model->B3SOIPDlisdif * Inv_L + + model->B3SOIPDwisdif * Inv_W + + model->B3SOIPDpisdif * Inv_LW; + pParam->B3SOIPDisrec = model->B3SOIPDisrec + + model->B3SOIPDlisrec * Inv_L + + model->B3SOIPDwisrec * Inv_W + + model->B3SOIPDpisrec * Inv_LW; + pParam->B3SOIPDistun = model->B3SOIPDistun + + model->B3SOIPDlistun * Inv_L + + model->B3SOIPDwistun * Inv_W + + model->B3SOIPDpistun * Inv_LW; + pParam->B3SOIPDvrec0 = model->B3SOIPDvrec0 + + model->B3SOIPDlvrec0 * Inv_L + + model->B3SOIPDwvrec0 * Inv_W + + model->B3SOIPDpvrec0 * Inv_LW; + pParam->B3SOIPDvtun0 = model->B3SOIPDvtun0 + + model->B3SOIPDlvtun0 * Inv_L + + model->B3SOIPDwvtun0 * Inv_W + + model->B3SOIPDpvtun0 * Inv_LW; + pParam->B3SOIPDnbjt = model->B3SOIPDnbjt + + model->B3SOIPDlnbjt * Inv_L + + model->B3SOIPDwnbjt * Inv_W + model->B3SOIPDpnbjt * Inv_LW; + pParam->B3SOIPDlbjt0 = model->B3SOIPDlbjt0 + + model->B3SOIPDllbjt0 * Inv_L + + model->B3SOIPDwlbjt0 * Inv_W + + model->B3SOIPDplbjt0 * Inv_LW; + pParam->B3SOIPDvabjt = model->B3SOIPDvabjt + + model->B3SOIPDlvabjt * Inv_L + + model->B3SOIPDwvabjt * Inv_W + + model->B3SOIPDpvabjt * Inv_LW; + pParam->B3SOIPDaely = model->B3SOIPDaely + + model->B3SOIPDlaely * Inv_L + + model->B3SOIPDwaely * Inv_W + model->B3SOIPDpaely * Inv_LW; + pParam->B3SOIPDahli = model->B3SOIPDahli + + model->B3SOIPDlahli * Inv_L + + model->B3SOIPDwahli * Inv_W + model->B3SOIPDpahli * Inv_LW; + /* CV model */ + pParam->B3SOIPDvsdfb = model->B3SOIPDvsdfb + + model->B3SOIPDlvsdfb * Inv_L + + model->B3SOIPDwvsdfb * Inv_W + + model->B3SOIPDpvsdfb * Inv_LW; + pParam->B3SOIPDvsdth = model->B3SOIPDvsdth + + model->B3SOIPDlvsdth * Inv_L + + model->B3SOIPDwvsdth * Inv_W + + model->B3SOIPDpvsdth * Inv_LW; + pParam->B3SOIPDdelvt = model->B3SOIPDdelvt + + model->B3SOIPDldelvt * Inv_L + + model->B3SOIPDwdelvt * Inv_W + + model->B3SOIPDpdelvt * Inv_LW; + pParam->B3SOIPDacde = model->B3SOIPDacde + + model->B3SOIPDlacde * Inv_L + + model->B3SOIPDwacde * Inv_W + model->B3SOIPDpacde * Inv_LW; + pParam->B3SOIPDmoin = model->B3SOIPDmoin + + model->B3SOIPDlmoin * Inv_L + + model->B3SOIPDwmoin * Inv_W + model->B3SOIPDpmoin * Inv_LW; + /* Added for binning - END */ + + T0 = (TempRatio - 1.0); + + pParam->B3SOIPDuatemp = pParam->B3SOIPDua; /* save ua, ub, and uc for b3soild.c */ + pParam->B3SOIPDubtemp = pParam->B3SOIPDub; + pParam->B3SOIPDuctemp = pParam->B3SOIPDuc; + pParam->B3SOIPDrds0denom = + pow (pParam->B3SOIPDweff * 1E6, pParam->B3SOIPDwr); + + +/* v2.2 release */ + pParam->B3SOIPDrth = + here->B3SOIPDrth0 / (pParam->B3SOIPDweff + + model->B3SOIPDwth0) * here->B3SOIPDnseg; + pParam->B3SOIPDcth = + here->B3SOIPDcth0 * (pParam->B3SOIPDweff + + model->B3SOIPDwth0) / here->B3SOIPDnseg; + pParam->B3SOIPDrbody = + model->B3SOIPDrbody * model->B3SOIPDrhalo / (2 * + model-> + B3SOIPDrbody + + model-> + B3SOIPDrhalo * + pParam-> + B3SOIPDleff) * + pParam->B3SOIPDweff / here->B3SOIPDnseg; + + pParam->B3SOIPDoxideRatio = + pow (model->B3SOIPDtoxref / model->B3SOIPDtoxqm, + model->B3SOIPDntox) / model->B3SOIPDtoxqm / + model->B3SOIPDtoxqm; +/* v2.2 release */ + + + pParam->B3SOIPDua = pParam->B3SOIPDua + pParam->B3SOIPDua1 * T0; + pParam->B3SOIPDub = pParam->B3SOIPDub + pParam->B3SOIPDub1 * T0; + pParam->B3SOIPDuc = pParam->B3SOIPDuc + pParam->B3SOIPDuc1 * T0; + if (pParam->B3SOIPDu0 > 1.0) + pParam->B3SOIPDu0 = pParam->B3SOIPDu0 / 1.0e4; + + pParam->B3SOIPDu0temp = pParam->B3SOIPDu0 + * pow (TempRatio, pParam->B3SOIPDute); + pParam->B3SOIPDvsattemp = + pParam->B3SOIPDvsat - pParam->B3SOIPDat * T0; + pParam->B3SOIPDrds0 = + (pParam->B3SOIPDrdsw + + pParam->B3SOIPDprt * T0) / pow (pParam->B3SOIPDweff * 1E6, + pParam->B3SOIPDwr); + + if (B3SOIPDcheckModel (model, here, ckt)) + { + IFuid namarray[2]; + namarray[0] = model->B3SOIPDmodName; + namarray[1] = here->B3SOIPDname; + + (*(SPfrontEnd->IFerror)) (ERR_FATAL, + "Fatal error(s) detected during B3SOIPDV3 parameter checking for %s in model %s", + namarray); + return (E_BADPARM); + } + + + pParam->B3SOIPDcgdo = (model->B3SOIPDcgdo + pParam->B3SOIPDcf) + * pParam->B3SOIPDwdiodCV; + pParam->B3SOIPDcgso = (model->B3SOIPDcgso + pParam->B3SOIPDcf) + * pParam->B3SOIPDwdiosCV; + + pParam->B3SOIPDcgeo = model->B3SOIPDcgeo + * pParam->B3SOIPDleffCV; + + + if (!model->B3SOIPDnpeakGiven && model->B3SOIPDgamma1Given) + { + T0 = pParam->B3SOIPDgamma1 * model->B3SOIPDcox; + pParam->B3SOIPDnpeak = 3.021E22 * T0 * T0; + } + + + T4 = Eg300 / model->B3SOIPDvtm * (TempRatio - 1.0); + T7 = model->B3SOIPDxbjt * T4 / pParam->B3SOIPDndiode; + DEXP (T7, T0); + T7 = model->B3SOIPDxdif * T4 / pParam->B3SOIPDndiode; + DEXP (T7, T1); + T7 = model->B3SOIPDxrec * T4 / pParam->B3SOIPDnrecf0; + DEXP (T7, T2); + + pParam->B3SOIPDahli = pParam->B3SOIPDahli * T0; + + pParam->B3SOIPDjbjt = pParam->B3SOIPDisbjt * T0; + pParam->B3SOIPDjdif = pParam->B3SOIPDisdif * T1; + pParam->B3SOIPDjrec = pParam->B3SOIPDisrec * T2; + + T7 = model->B3SOIPDxtun * (TempRatio - 1); + DEXP (T7, T0); + pParam->B3SOIPDjtun = pParam->B3SOIPDistun * T0; + + + if (pParam->B3SOIPDnsub > 0) + pParam->B3SOIPDvfbb = + -model->B3SOIPDtype * model->B3SOIPDvtm * + log (pParam->B3SOIPDnpeak / pParam->B3SOIPDnsub); + else + pParam->B3SOIPDvfbb = + -model->B3SOIPDtype * model->B3SOIPDvtm * + log (-pParam->B3SOIPDnpeak * pParam->B3SOIPDnsub / ni / ni); + + if (!model->B3SOIPDvsdfbGiven) + { + if (pParam->B3SOIPDnsub > 0) + pParam->B3SOIPDvsdfb = + -model->B3SOIPDtype * (model->B3SOIPDvtm * + log (1e20 * pParam->B3SOIPDnsub / + ni / ni) - 0.3); + else if (pParam->B3SOIPDnsub < 0) + pParam->B3SOIPDvsdfb = + -model->B3SOIPDtype * (model->B3SOIPDvtm * + log (-1e20 / + pParam->B3SOIPDnsub) + 0.3); + } + + /* Phi & Gamma */ + SDphi = + 2.0 * model->B3SOIPDvtm * log (fabs (pParam->B3SOIPDnsub) / + ni); + SDgamma = + 5.753e-12 * sqrt (fabs (pParam->B3SOIPDnsub)) / + model->B3SOIPDcbox; + + if (!model->B3SOIPDvsdthGiven) + { + if (((pParam->B3SOIPDnsub > 0) && (model->B3SOIPDtype > 0)) + || ((pParam->B3SOIPDnsub < 0) + && (model->B3SOIPDtype < 0))) + pParam->B3SOIPDvsdth = + pParam->B3SOIPDvsdfb + SDphi + SDgamma * sqrt (SDphi); + else + pParam->B3SOIPDvsdth = + pParam->B3SOIPDvsdfb - SDphi - SDgamma * sqrt (SDphi); + } + + if (!model->B3SOIPDcsdminGiven) + { + /* Cdmin */ + tmp = sqrt (2.0 * EPSSI * SDphi / (Charge_q * + fabs (pParam-> + B3SOIPDnsub) * + 1.0e6)); + tmp1 = EPSSI / tmp; + model->B3SOIPDcsdmin = tmp1 * model->B3SOIPDcbox / + (tmp1 + model->B3SOIPDcbox); + } + + T0 = model->B3SOIPDcsdesw * log (1 + model->B3SOIPDtsi / + model->B3SOIPDtbox); + T1 = here->B3SOIPDsourcePerimeter - here->B3SOIPDw; + if (T1 > 0.0) + pParam->B3SOIPDcsesw = T0 * T1; + else + pParam->B3SOIPDcsesw = 0.0; + T1 = here->B3SOIPDdrainPerimeter - here->B3SOIPDw; + if (T1 > 0.0) + pParam->B3SOIPDcdesw = T0 * T1; + else + pParam->B3SOIPDcdesw = 0.0; + + pParam->B3SOIPDphi = 2.0 * model->B3SOIPDvtm + * log (pParam->B3SOIPDnpeak / ni); + + pParam->B3SOIPDsqrtPhi = sqrt (pParam->B3SOIPDphi); + pParam->B3SOIPDphis3 = + pParam->B3SOIPDsqrtPhi * pParam->B3SOIPDphi; + + pParam->B3SOIPDXdep0 = sqrt (2.0 * EPSSI / (Charge_q + * + pParam-> + B3SOIPDnpeak * + 1.0e6)) * + pParam->B3SOIPDsqrtPhi; + pParam->B3SOIPDsqrtXdep0 = sqrt (pParam->B3SOIPDXdep0); + pParam->B3SOIPDlitl = sqrt (3.0 * model->B3SOIPDxj + * model->B3SOIPDtox); + pParam->B3SOIPDvbi = model->B3SOIPDvtm * log (1.0e20 + * + pParam-> + B3SOIPDnpeak / + (ni * ni)); + pParam->B3SOIPDcdep0 = + sqrt (Charge_q * EPSSI * pParam->B3SOIPDnpeak * 1.0e6 / 2.0 / + pParam->B3SOIPDphi); + + if (model->B3SOIPDk1Given || model->B3SOIPDk2Given) + { + if (!model->B3SOIPDk1Given) + { + fprintf (stdout, + "Warning: k1 should be specified with k2.\n"); + pParam->B3SOIPDk1 = 0.53; + } + if (!model->B3SOIPDk2Given) + { + fprintf (stdout, + "Warning: k2 should be specified with k1.\n"); + pParam->B3SOIPDk2 = -0.0186; + } + if (model->B3SOIPDxtGiven) + fprintf (stdout, + "Warning: xt is ignored because k1 or k2 is given.\n"); + if (model->B3SOIPDvbxGiven) + fprintf (stdout, + "Warning: vbx is ignored because k1 or k2 is given.\n"); + if (model->B3SOIPDvbmGiven) + fprintf (stdout, + "Warning: vbm is ignored because k1 or k2 is given.\n"); + if (model->B3SOIPDgamma1Given) + fprintf (stdout, + "Warning: gamma1 is ignored because k1 or k2 is given.\n"); + if (model->B3SOIPDgamma2Given) + fprintf (stdout, + "Warning: gamma2 is ignored because k1 or k2 is given.\n"); + } + else + { + if (!model->B3SOIPDvbxGiven) + pParam->B3SOIPDvbx = pParam->B3SOIPDphi - 7.7348e-4 + * pParam->B3SOIPDnpeak + * pParam->B3SOIPDxt * pParam->B3SOIPDxt; + if (pParam->B3SOIPDvbx > 0.0) + pParam->B3SOIPDvbx = -pParam->B3SOIPDvbx; + if (pParam->B3SOIPDvbm > 0.0) + pParam->B3SOIPDvbm = -pParam->B3SOIPDvbm; + + if (!model->B3SOIPDgamma1Given) + pParam->B3SOIPDgamma1 = 5.753e-12 + * sqrt (pParam->B3SOIPDnpeak) / model->B3SOIPDcox; + if (!model->B3SOIPDgamma2Given) + pParam->B3SOIPDgamma2 = 5.753e-12 + * sqrt (pParam->B3SOIPDnsub) / model->B3SOIPDcox; + + T0 = pParam->B3SOIPDgamma1 - pParam->B3SOIPDgamma2; + T1 = sqrt (pParam->B3SOIPDphi - pParam->B3SOIPDvbx) + - pParam->B3SOIPDsqrtPhi; + T2 = sqrt (pParam->B3SOIPDphi * (pParam->B3SOIPDphi + - pParam->B3SOIPDvbm)) - + pParam->B3SOIPDphi; + pParam->B3SOIPDk2 = + T0 * T1 / (2.0 * T2 + pParam->B3SOIPDvbm); + pParam->B3SOIPDk1 = + pParam->B3SOIPDgamma2 - + 2.0 * pParam->B3SOIPDk2 * sqrt (pParam->B3SOIPDphi - + pParam->B3SOIPDvbm); + } + + if (pParam->B3SOIPDk2 < 0.0) + { + T0 = 0.5 * pParam->B3SOIPDk1 / pParam->B3SOIPDk2; + pParam->B3SOIPDvbsc = 0.9 * (pParam->B3SOIPDphi - T0 * T0); + if (pParam->B3SOIPDvbsc > -3.0) + pParam->B3SOIPDvbsc = -3.0; + else if (pParam->B3SOIPDvbsc < -30.0) + pParam->B3SOIPDvbsc = -30.0; + } + else + { + pParam->B3SOIPDvbsc = -30.0; + } + if (pParam->B3SOIPDvbsc > pParam->B3SOIPDvbm) + pParam->B3SOIPDvbsc = pParam->B3SOIPDvbm; + + if ((T0 = pParam->B3SOIPDweff + pParam->B3SOIPDk1w2) < 1e-8) + T0 = 1e-8; + pParam->B3SOIPDk1eff = + pParam->B3SOIPDk1 * (1 + pParam->B3SOIPDk1w1 / T0); + + if (model->B3SOIPDvth0Given) + { + pParam->B3SOIPDvfb = + model->B3SOIPDtype * pParam->B3SOIPDvth0 - + pParam->B3SOIPDphi - + pParam->B3SOIPDk1eff * pParam->B3SOIPDsqrtPhi; + } + else + { + pParam->B3SOIPDvfb = -1.0; + pParam->B3SOIPDvth0 = + model->B3SOIPDtype * (pParam->B3SOIPDvfb + + pParam->B3SOIPDphi + + pParam->B3SOIPDk1eff * + pParam->B3SOIPDsqrtPhi); + } + T1 = sqrt (EPSSI / EPSOX * model->B3SOIPDtox + * pParam->B3SOIPDXdep0); + T0 = + exp (-0.5 * pParam->B3SOIPDdsub * pParam->B3SOIPDleff / T1); + pParam->B3SOIPDtheta0vb0 = (T0 + 2.0 * T0 * T0); + + T0 = + exp (-0.5 * pParam->B3SOIPDdrout * pParam->B3SOIPDleff / T1); + T2 = (T0 + 2.0 * T0 * T0); + pParam->B3SOIPDthetaRout = pParam->B3SOIPDpdibl1 * T2 + + pParam->B3SOIPDpdibl2; + } + + here->B3SOIPDcsbox = model->B3SOIPDcbox * here->B3SOIPDsourceArea; + here->B3SOIPDcsmin = model->B3SOIPDcsdmin * here->B3SOIPDsourceArea; + here->B3SOIPDcdbox = model->B3SOIPDcbox * here->B3SOIPDdrainArea; + here->B3SOIPDcdmin = model->B3SOIPDcsdmin * here->B3SOIPDdrainArea; + + if (((pParam->B3SOIPDnsub > 0) && (model->B3SOIPDtype > 0)) || + ((pParam->B3SOIPDnsub < 0) && (model->B3SOIPDtype < 0))) + { + T0 = pParam->B3SOIPDvsdth - pParam->B3SOIPDvsdfb; + pParam->B3SOIPDsdt1 = + pParam->B3SOIPDvsdfb + model->B3SOIPDasd * T0; + T1 = here->B3SOIPDcsbox - here->B3SOIPDcsmin; + T2 = T1 / T0 / T0; + pParam->B3SOIPDst2 = T2 / model->B3SOIPDasd; + pParam->B3SOIPDst3 = T2 / (1 - model->B3SOIPDasd); + here->B3SOIPDst4 = T0 * T1 * (1 + model->B3SOIPDasd) / 3 + - here->B3SOIPDcsmin * pParam->B3SOIPDvsdfb; + + T1 = here->B3SOIPDcdbox - here->B3SOIPDcdmin; + T2 = T1 / T0 / T0; + pParam->B3SOIPDdt2 = T2 / model->B3SOIPDasd; + pParam->B3SOIPDdt3 = T2 / (1 - model->B3SOIPDasd); + here->B3SOIPDdt4 = T0 * T1 * (1 + model->B3SOIPDasd) / 3 + - here->B3SOIPDcdmin * pParam->B3SOIPDvsdfb; + } + else + { + T0 = pParam->B3SOIPDvsdfb - pParam->B3SOIPDvsdth; + pParam->B3SOIPDsdt1 = + pParam->B3SOIPDvsdth + model->B3SOIPDasd * T0; + T1 = here->B3SOIPDcsmin - here->B3SOIPDcsbox; + T2 = T1 / T0 / T0; + pParam->B3SOIPDst2 = T2 / model->B3SOIPDasd; + pParam->B3SOIPDst3 = T2 / (1 - model->B3SOIPDasd); + here->B3SOIPDst4 = T0 * T1 * (1 + model->B3SOIPDasd) / 3 + - here->B3SOIPDcsbox * pParam->B3SOIPDvsdth; + + T1 = here->B3SOIPDcdmin - here->B3SOIPDcdbox; + T2 = T1 / T0 / T0; + pParam->B3SOIPDdt2 = T2 / model->B3SOIPDasd; + pParam->B3SOIPDdt3 = T2 / (1 - model->B3SOIPDasd); + here->B3SOIPDdt4 = T0 * T1 * (1 + model->B3SOIPDasd) / 3 + - here->B3SOIPDcdbox * pParam->B3SOIPDvsdth; + } + + here->B3SOIPDphi = pParam->B3SOIPDphi; + /* process source/drain series resistance */ + here->B3SOIPDdrainConductance = model->B3SOIPDsheetResistance + * here->B3SOIPDdrainSquares; + if (here->B3SOIPDdrainConductance > 0.0) + here->B3SOIPDdrainConductance = 1.0 + / here->B3SOIPDdrainConductance; + else + here->B3SOIPDdrainConductance = 0.0; + + here->B3SOIPDsourceConductance = model->B3SOIPDsheetResistance + * here->B3SOIPDsourceSquares; + if (here->B3SOIPDsourceConductance > 0.0) + here->B3SOIPDsourceConductance = 1.0 + / here->B3SOIPDsourceConductance; + else + here->B3SOIPDsourceConductance = 0.0; + here->B3SOIPDcgso = pParam->B3SOIPDcgso; + here->B3SOIPDcgdo = pParam->B3SOIPDcgdo; + + +/* v2.0 release */ + if (model->B3SOIPDln < 1e-15) + model->B3SOIPDln = 1e-15; + T0 = + -0.5 * pParam->B3SOIPDleff * pParam->B3SOIPDleff / + model->B3SOIPDln / model->B3SOIPDln; + DEXP (T0, T1); + pParam->B3SOIPDarfabjt = T1; + + T0 = + pParam->B3SOIPDlbjt0 * (1.0 / pParam->B3SOIPDleff + + 1.0 / model->B3SOIPDln); + pParam->B3SOIPDlratio = pow (T0, pParam->B3SOIPDnbjt); + pParam->B3SOIPDlratiodif = + 1.0 + model->B3SOIPDldif0 * pow (T0, model->B3SOIPDndif); + + if ( + (pParam->B3SOIPDvearly = + pParam->B3SOIPDvabjt + + pParam->B3SOIPDaely * pParam->B3SOIPDleff) < 1) + pParam->B3SOIPDvearly = 1; + + /* vfbzb calculation for capMod 3 */ + tmp = sqrt (pParam->B3SOIPDXdep0); + tmp1 = pParam->B3SOIPDvbi - pParam->B3SOIPDphi; + tmp2 = model->B3SOIPDfactor1 * tmp; + + T0 = -0.5 * pParam->B3SOIPDdvt1w * pParam->B3SOIPDweff + * pParam->B3SOIPDleff / 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->B3SOIPDdvt0w * T2; + T2 = T0 * tmp1; + + T0 = -0.5 * pParam->B3SOIPDdvt1 * pParam->B3SOIPDleff / 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->B3SOIPDdvt0 * T3 * tmp1; + + T4 = model->B3SOIPDtox * pParam->B3SOIPDphi + / (pParam->B3SOIPDweff + pParam->B3SOIPDw0); + + T0 = sqrt (1.0 + pParam->B3SOIPDnlx / pParam->B3SOIPDleff); + T5 = pParam->B3SOIPDk1eff * (T0 - 1.0) * pParam->B3SOIPDsqrtPhi + + (pParam->B3SOIPDkt1 + pParam->B3SOIPDkt1l / pParam->B3SOIPDleff) + * (TempRatio - 1.0); + + tmp3 = model->B3SOIPDtype * pParam->B3SOIPDvth0 + - T2 - T3 + pParam->B3SOIPDk3 * T4 + T5; + pParam->B3SOIPDvfbzb = + tmp3 - pParam->B3SOIPDphi - + pParam->B3SOIPDk1eff * pParam->B3SOIPDsqrtPhi; + /* End of vfbzb */ + + pParam->B3SOIPDldeb = + sqrt (EPSSI * Vtm0 / (Charge_q * pParam->B3SOIPDnpeak * 1.0e6)) / + 3.0; + pParam->B3SOIPDacde = + pParam->B3SOIPDacde * pow ((pParam->B3SOIPDnpeak / 2.0e16), + -0.25); + } + } + return (OK); +} diff --git a/src/spicelib/devices/bsim3soi_pd/b3soipdtrunc.c b/src/spicelib/devices/bsim3soi_pd/b3soipdtrunc.c new file mode 100644 index 000000000..2524326e4 --- /dev/null +++ b/src/spicelib/devices/bsim3soi_pd/b3soipdtrunc.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: b3soipdtrunc.c 98/5/01 +**********/ + + +#include "ngspice.h" +#include +#include +#include "cktdefs.h" +#include "b3soipddef.h" +#include "sperror.h" +#include "suffix.h" + + +int +B3SOIPDtrunc (inModel, ckt, timeStep) + GENmodel *inModel; + register CKTcircuit *ckt; + double *timeStep; +{ + register B3SOIPDmodel *model = (B3SOIPDmodel *) inModel; + register B3SOIPDinstance *here; + +#ifdef STEPDEBUG + double debugtemp; +#endif /* STEPDEBUG */ + + for (; model != NULL; model = model->B3SOIPDnextModel) + { + for (here = model->B3SOIPDinstances; here != NULL; + here = here->B3SOIPDnextInstance) + { +#ifdef STEPDEBUG + debugtemp = *timeStep; +#endif /* STEPDEBUG */ + CKTterr (here->B3SOIPDqb, ckt, timeStep); + CKTterr (here->B3SOIPDqg, ckt, timeStep); + CKTterr (here->B3SOIPDqd, ckt, timeStep); +#ifdef STEPDEBUG + if (debugtemp != *timeStep) + { + printf ("device %s reduces step from %g to %g\n", + here->B3SOIPDname, debugtemp, *timeStep); + } +#endif /* STEPDEBUG */ + } + } + return (OK); +} diff --git a/src/spicelib/devices/cktbindnode.c b/src/spicelib/devices/cktbindnode.c index 65d306343..5b9e2c7d1 100644 --- a/src/spicelib/devices/cktbindnode.c +++ b/src/spicelib/devices/cktbindnode.c @@ -45,6 +45,12 @@ CKTbindNode(void *ckt, void *fast, int term, void *node) case 5: instance->GENnode5 = mappednode; break; + case 6:/* added to consider the body node 01/06/99 */ + instance->GENnode6 = mappednode; + break; + case 7:/* added to consider the temp node 02/03/99 */ + instance->GENnode7 = mappednode; + break; } return OK; } else { diff --git a/src/spicelib/devices/dev.c b/src/spicelib/devices/dev.c index 36f941e58..1423a8ffe 100644 --- a/src/spicelib/devices/dev.c +++ b/src/spicelib/devices/dev.c @@ -35,7 +35,7 @@ #include "dev.h" -#define DEVICES_USED "asrc bjt bsim1 bsim2 bsim3 bsim3v2 bsim3v1 cap cccs ccvs csw dio ind isrc jfet ltra mes mos1 mos2 mos3 mos6 res sw tra urc vccs vcvs vsrc" +#define DEVICES_USED "asrc bjt bsim1 bsim2 bsim3 bsim3v2 bsim3v1 bsim4 bsim3soipd cap cccs ccvs csw dio ind isrc jfet ltra mes mos1 mos2 mos3 mos6 res sw tra urc vccs vcvs vsrc" /* * Analyses @@ -61,6 +61,7 @@ #include "bsim3v1/bsim3v1itf.h" #include "bsim3v2/bsim3v2itf.h" #include "bsim4/bsim4itf.h" +#include "bsim3soi_pd/b3soipditf.h" #include "cap/capitf.h" #include "cccs/cccsitf.h" #include "ccvs/ccvsitf.h" @@ -85,7 +86,7 @@ #include "vsrc/vsrcitf.h" -#define DEVNUM 31 +#define DEVNUM 32 SPICEdev *DEVices[DEVNUM]; @@ -103,29 +104,30 @@ spice_init_devices(void) DEVices[ 6] = get_bsim3v1_info(); DEVices[ 7] = get_bsim3v2_info(); DEVices[ 8] = get_bsim4_info(); - DEVices[ 9] = get_cap_info(); - DEVices[10] = get_cccs_info(); - DEVices[11] = get_ccvs_info(); - DEVices[12] = get_csw_info(); - DEVices[13] = get_dio_info(); - DEVices[14] = get_ind_info(); - DEVices[15] = get_mut_info(); - DEVices[16] = get_isrc_info(); - DEVices[17] = get_jfet_info(); - DEVices[18] = get_jfet2_info(); - DEVices[19] = get_ltra_info(); - DEVices[20] = get_mes_info(); - DEVices[21] = get_mos1_info(); - DEVices[22] = get_mos2_info(); - DEVices[23] = get_mos3_info(); - DEVices[24] = get_mos6_info(); - DEVices[25] = get_res_info(); - DEVices[26] = get_sw_info(); - DEVices[27] = get_tra_info(); - DEVices[28] = get_vccs_info(); - DEVices[29] = get_vcvs_info(); - DEVices[30] = get_vsrc_info(); - assert(31 == DEVNUM); + DEVices[ 9] = get_b3soipd_info(); + DEVices[10] = get_cap_info(); + DEVices[11] = get_cccs_info(); + DEVices[12] = get_ccvs_info(); + DEVices[13] = get_csw_info(); + DEVices[14] = get_dio_info(); + DEVices[15] = get_ind_info(); + DEVices[16] = get_mut_info(); + DEVices[17] = get_isrc_info(); + DEVices[18] = get_jfet_info(); + DEVices[19] = get_jfet2_info(); + DEVices[20] = get_ltra_info(); + DEVices[21] = get_mes_info(); + DEVices[22] = get_mos1_info(); + DEVices[23] = get_mos2_info(); + DEVices[24] = get_mos3_info(); + DEVices[25] = get_mos6_info(); + DEVices[26] = get_res_info(); + DEVices[27] = get_sw_info(); + DEVices[28] = get_tra_info(); + DEVices[29] = get_vccs_info(); + DEVices[30] = get_vcvs_info(); + DEVices[31] = get_vsrc_info(); + assert(32 == DEVNUM); } diff --git a/src/spicelib/parser/inp2m.c b/src/spicelib/parser/inp2m.c index 145d2402e..89a8a948f 100644 --- a/src/spicelib/parser/inp2m.c +++ b/src/spicelib/parser/inp2m.c @@ -11,90 +11,208 @@ Author: 1988 Thomas L. Quarles #include "fteext.h" #include "inp.h" -void INP2M(void *ckt, INPtables * tab, card * current) +void +INP2M (void *ckt, INPtables * tab, card * current) { - /* Mname [L=] - * [W=] [AD=] [AS=] [PD=] - * [PS=] [NRD=] [NRS=] [OFF] - * [IC=,,] - */ + /* Mname [L=] + * [W=] [AD=] [AS=] [PD=] + * [PS=] [NRD=] [NRS=] [OFF] + * [IC=,,] + */ - int type; /* the type the model says it is */ - char *line; /* the part of the current line left to parse */ - char *name; /* the resistor's name */ - char *nname1; /* the first node's name */ - char *nname2; /* the second node's name */ - char *nname3; /* the third node's name */ - char *nname4; /* the fourth node's name */ - void *node1; /* the first node's node pointer */ - void *node2; /* the second node's node pointer */ - void *node3; /* the third node's node pointer */ - void *node4; /* the fourth node's node pointer */ - int error; /* error code temporary */ - void *fast; /* pointer to the actual instance */ - int waslead; /* flag to indicate that funny unlabeled number was found */ - double leadval; /* actual value of unlabeled number */ - char *model; /* the name of the model */ - INPmodel *thismodel; /* pointer to model description for user's model */ - void *mdfast; /* pointer to the actual model */ - IFuid uid; /* uid for default model */ + int type; /* the type the model says it is */ + char *line; /* the part of the current line left to parse */ + char *name; /* the resistor's name */ + char *nname1; /* the first node's name */ + char *nname2; /* the second node's name */ + char *nname3; /* the third node's name */ + char *nname4; /* the fourth node's name */ + char *nname5; /* the fifth node's name */ + char *nname6; /* the sixt node's name */ + char *nname7; /* the seventh node's name */ + void *node1; /* the first node's node pointer */ + void *node2; /* the second node's node pointer */ + void *node3; /* the third node's node pointer */ + void *node4; /* the fourth node's node pointer */ + void *node5; /* the fifth node's node pointer */ + void *node6; /* the sixth node's node pointer */ + void *node7; /* the seventh node's node pointer */ + int error; /* error code temporary */ + int nodeflag; /* flag indicating 4 or 5 (or 6 or 7) nodes */ + void *fast; /* pointer to the actual instance */ + int waslead; /* flag to indicate that funny unlabeled number was found */ + double leadval; /* actual value of unlabeled number */ + char *model; /* the name of the model */ + INPmodel *thismodel; /* pointer to model description for user's model */ + void *mdfast; /* pointer to the actual model */ + IFuid uid; /* uid for default model */ - line = current->line; - INPgetTok(&line, &name, 1); - INPinsert(&name, tab); - INPgetTok(&line, &nname1, 1); - INPtermInsert(ckt, &nname1, tab, &node1); - INPgetTok(&line, &nname2, 1); - INPtermInsert(ckt, &nname2, tab, &node2); - INPgetTok(&line, &nname3, 1); - INPtermInsert(ckt, &nname3, tab, &node3); - INPgetTok(&line, &nname4, 1); - INPtermInsert(ckt, &nname4, tab, &node4); - INPgetTok(&line, &model, 1); - INPinsert(&model, tab); - thismodel = (INPmodel *) NULL; - current->error = INPgetMod(ckt, model, &thismodel, tab); - if (thismodel != NULL) { - if (thismodel->INPmodType != INPtypelook("Mos1") - && thismodel->INPmodType != INPtypelook("Mos2") - && thismodel->INPmodType != INPtypelook("Mos3") - && thismodel->INPmodType != INPtypelook("Mos5") - && thismodel->INPmodType != INPtypelook("Mos6") - && thismodel->INPmodType != INPtypelook("Mos8") - && thismodel->INPmodType != INPtypelook("BSIM1") - && thismodel->INPmodType != INPtypelook("BSIM2") - && thismodel->INPmodType != INPtypelook("BSIM3") - && thismodel->INPmodType != INPtypelook("BSIM4") - && thismodel->INPmodType != INPtypelook("BSIM3V1") - && thismodel->INPmodType != INPtypelook("BSIM3V2") - ) { - LITERR("incorrect model type"); - return; + nodeflag = 0; /* initially specify a 4 terminal device */ + line = current->line; + INPgetTok (&line, &name, 1); + INPinsert (&name, tab); + INPgetTok (&line, &nname1, 1); + INPtermInsert (ckt, &nname1, tab, &node1); + INPgetTok (&line, &nname2, 1); + INPtermInsert (ckt, &nname2, tab, &node2); + INPgetTok (&line, &nname3, 1); + INPtermInsert (ckt, &nname3, tab, &node3); + INPgetTok (&line, &nname4, 1); + INPtermInsert (ckt, &nname4, tab, &node4); + + /* See if 5th token after device specification is a model name */ + + INPgetTok (&line, &nname5, 1); /* get 5th token */ + thismodel = (INPmodel *) NULL; + INPgetMod (ckt, nname5, &thismodel, tab); + printf("Model=%x",thismodel); + if (thismodel == NULL) + { /* 5th token is not a model in the table */ + nodeflag = 1; /* now specify a 5 node device */ + INPgetTok (&line, &nname6, 1); /* get next token */ + thismodel = (INPmodel *) NULL; + INPgetMod (ckt, nname6, &thismodel, tab); + if (thismodel == NULL) + { /* 6th token is not a model in the table */ + nodeflag = 2; /* now specify a 6 node device */ + INPgetTok (&line, &nname7, 1); /* get next token */ + thismodel = (INPmodel *) NULL; + INPgetMod (ckt, nname7, &thismodel, tab); + if (thismodel == NULL) + { /* 7th token is not a model in the table */ + nodeflag = 3; /* now specify a 7 node device */ + INPgetTok (&line, &model, 1); /* get model name */ + INPgetMod (ckt, model, &thismodel, tab); /* get pointer to the model */ + if (thismodel != NULL) + { + if (thismodel->INPmodType != INPtypelook ("B3SOIPD")) + { + /* if model is not variable node B3SOIPD model, error! */ + LITERR ("only level 9 B3SOIPD can have 7 nodes") return; + } + else + { /* if looking at B3SOIPD model, allocate the 7th node */ + INPtermInsert (ckt, &nname5, tab, &node5); + INPtermInsert (ckt, &nname6, tab, &node6); + INPtermInsert (ckt, &nname7, tab, &node7); + } + } + } + else + { /* 7th token is a model - only have 6 terminal device */ + if (thismodel->INPmodType != INPtypelook ("B3SOIPD")) + { + /* if model is not variable node B3SOIPD model, error! */ + LITERR ("only level 9 B3SOIPD can have 6 nodes") return; + } + else + { /* if looking at B3SOIPD model, allocate the 6th node */ + INPtermInsert (ckt, &nname5, tab, &node5); + INPtermInsert (ckt, &nname6, tab, &node6); + model = nname7; + } + } } - type = thismodel->INPmodType; - mdfast = (thismodel->INPmodfast); - } else { - type = INPtypelook("Mos1"); - if (type < 0) { - LITERR("Device type MOS1 not supported by this binary\n"); - return; + else + { /* 6th token is a model - only have 5 terminal device */ + if (thismodel->INPmodType != INPtypelook ("B3SOIPD")) + { + /* if model is not variable node B3SOIPD model, error! */ + LITERR ("only level 9 B3SOIPD can have 5 nodes") return; + } + else + { /* if looking at B3SOIPD model, allocate the 5th node */ + INPtermInsert (ckt, &nname5, tab, &node5); + model = nname6; /* make model point to the correct token */ + } } - if (!tab->defMmod) { - /* create default M model */ - IFnewUid(ckt, &uid, (IFuid) NULL, "M", UID_MODEL, - (void **) NULL); - IFC(newModel, (ckt, type, &(tab->defMmod), uid)); - } - mdfast = tab->defMmod; } - IFC(newInstance, (ckt, mdfast, &fast, name)); - IFC(bindNode, (ckt, fast, 1, node1)); - IFC(bindNode, (ckt, fast, 2, node2)); - IFC(bindNode, (ckt, fast, 3, node3)); - IFC(bindNode, (ckt, fast, 4, node4)); - PARSECALL((&line, ckt, type, fast, &leadval, &waslead, tab)); - if (waslead) { - LITERR(" error: no unlabeled parameter permitted on mosfet\n"); + + else + { /* 5th token is a model - only have 4 terminal device */ + model = nname5; /* make model point to the correct token */ + } + + + + INPinsert (&model, tab); + thismodel = (INPmodel *) NULL; + current->error = INPgetMod (ckt, model, &thismodel, tab); + if (thismodel != NULL) + { + if (thismodel->INPmodType != INPtypelook ("Mos1") + && thismodel->INPmodType != INPtypelook ("Mos2") + && thismodel->INPmodType != INPtypelook ("Mos3") + && thismodel->INPmodType != INPtypelook ("Mos5") + && thismodel->INPmodType != INPtypelook ("Mos6") + && thismodel->INPmodType != INPtypelook ("Mos8") + && thismodel->INPmodType != INPtypelook ("BSIM1") + && thismodel->INPmodType != INPtypelook ("BSIM2") + && thismodel->INPmodType != INPtypelook ("BSIM3") + && thismodel->INPmodType != INPtypelook ("B3SOIPD") + && thismodel->INPmodType != INPtypelook ("BSIM4") + && thismodel->INPmodType != INPtypelook ("BSIM3V1") + && thismodel->INPmodType != INPtypelook ("BSIM3V2")) + { + LITERR ("incorrect model type"); + return; + } + type = thismodel->INPmodType; + mdfast = (thismodel->INPmodfast); + } + else + { + type = INPtypelook ("Mos1"); + if (type < 0) + { + LITERR ("Device type MOS1 not supported by this binary\n"); + return; + } + if (!tab->defMmod) + { + /* create default M model */ + IFnewUid (ckt, &uid, (IFuid) NULL, "M", UID_MODEL, (void **) NULL); + IFC (newModel, (ckt, type, &(tab->defMmod), uid)); + } + mdfast = tab->defMmod; + } + IFC (newInstance, (ckt, mdfast, &fast, name)); + IFC (bindNode, (ckt, fast, 1, node1)); + IFC (bindNode, (ckt, fast, 2, node2)); + IFC (bindNode, (ckt, fast, 3, node3)); + IFC (bindNode, (ckt, fast, 4, node4)); + if (thismodel->INPmodType == INPtypelook ("B3SOIPD")) + { + switch (nodeflag) + { + case 0: + ((GENinstance *) fast)->GENnode5 = -1; + ((GENinstance *) fast)->GENnode6 = -1; + ((GENinstance *) fast)->GENnode7 = -1; + break; + case 1: + IFC (bindNode, (ckt, fast, 5, node5)) + ((GENinstance *) fast)->GENnode6 = -1; + ((GENinstance *) fast)->GENnode7 = -1; + break; + case 2: + IFC (bindNode, (ckt, fast, 5, node5)) + IFC (bindNode, (ckt, fast, 6, node6)) + ((GENinstance *) fast)->GENnode7 = -1; + break; + case 3: + IFC (bindNode, (ckt, fast, 5, node5)) + IFC (bindNode, (ckt, fast, 6, node6)) + IFC (bindNode, (ckt, fast, 7, node7)) break; + default: + break; + } + } + + PARSECALL ((&line, ckt, type, fast, &leadval, &waslead, tab)); + if (waslead) + { + LITERR (" error: no unlabeled parameter permitted on mosfet\n"); } } diff --git a/src/spicelib/parser/inpdomod.c b/src/spicelib/parser/inpdomod.c index 8db3fe9da..ae6973817 100644 --- a/src/spicelib/parser/inpdomod.c +++ b/src/spicelib/parser/inpdomod.c @@ -156,11 +156,11 @@ char *INPdomodel(void *ckt, card * image, INPtables * tab) } break; case 9: - type = INPtypelook("BSIMsoi"); + type = INPtypelook("B3SOIPD"); if (type < 0) { err = INPmkTemp - ("Device type BSIMsoi not available in this binary\n"); + ("Device type B3SOIPD not available in this binary\n"); } break; case 14: diff --git a/tests/bsim3soipd/lib.h b/tests/bsim3soipd/lib.h new file mode 100644 index 000000000..310aa396b --- /dev/null +++ b/tests/bsim3soipd/lib.h @@ -0,0 +1,110 @@ + + +.subckt dum ss +mn1 ss ss ss ss ss n1 w=4u l=0.15u debug=1 AS=6p AD=6p PS=7u PD=7u +.ends dum + +* XOR2 +.subckt xnor2 dd ss sub A B out +mn1 T1 A C1 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn2 C1 B ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn3 out A C2 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn4 out B C2 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn5 C2 T1 ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mp1 T1 A dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp2 T1 B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp3 out A C3 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp4 C3 B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp5 out T1 dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +.ends xnor2 + +.subckt nor2 dd ss sub A B out +mn1 out A ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn2 out B ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mp1 out A C1 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp2 C1 B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +.ends nor2 + +.subckt nand2 dd ss sub A B out +mn1 out A C1 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn2 C1 B ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mp1 out A dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp2 out B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +.ends nand2 + +.subckt nor3 dd ss sub A B C out +mn1 out A ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn2 out B ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn3 out C ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mp1 out A C1 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp2 C1 B C2 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp3 C2 C dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +.ends nor3 + +.subckt nand3 dd ss sub A B C out +mn1 out A C1 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn2 C1 B C2 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn3 C2 C ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mp1 out A dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp2 out B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp3 out C dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +.ends nand3 + +.subckt nor4 dd ss sub A B C D out +mn1 out A ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn2 out B ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn3 out C ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn4 out C ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mp1 out A C1 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp2 C1 B C2 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp3 C2 C C3 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp4 C3 C dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +.ends nor4 + +.subckt nand4 dd ss sub A B C D out +mn1 out A C1 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn2 C1 B C2 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn3 C2 C C3 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mn4 C3 C ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mp1 out A dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp2 out B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp3 out C dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +mp4 out C dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +.ends nand4 + +.subckt inv1 dd ss sub in out +mn1 out in ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u +mp1 out in dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u +.ends inv1 + +.subckt inv5 dd ss sub in out +xinv1 dd ss sub in 1 inv1 +xinv2 dd ss sub 1 2 inv1 +xinv3 dd ss sub 2 3 inv1 +xinv4 dd ss sub 3 4 inv1 +xinv5 dd ss sub 4 out inv1 +.ends inv5 + +.subckt inv25 dd ss sub in out +xinv1 dd ss sub in 1 inv5 +xinv2 dd ss sub 1 2 inv5 +xinv3 dd ss sub 2 3 inv5 +xinv4 dd ss sub 3 4 inv5 +xinv5 dd ss sub 4 out inv5 +.ends inv25 + +.subckt inv125 dd ss sub in out +xinv1 dd ss sub in 1 inv25 +xinv2 dd ss sub 1 2 inv25 +xinv3 dd ss sub 2 3 inv25 +xinv4 dd ss sub 3 4 inv25 +xinv5 dd ss sub 4 out inv25 +.ends inv125 + +.subckt inv625 dd ss sub in out +xinv1 dd ss sub in 1 inv125 +xinv2 dd ss sub 1 2 inv125 +xinv3 dd ss sub 2 3 inv125 +xinv4 dd ss sub 3 4 inv125 +xinv5 dd ss sub 4 out inv125 +.ends inv625 diff --git a/tests/bsim3soipd/nmospd.mod b/tests/bsim3soipd/nmospd.mod new file mode 100644 index 000000000..861569ae8 --- /dev/null +++ b/tests/bsim3soipd/nmospd.mod @@ -0,0 +1,40 @@ +*Model Card for BSIMPD2.0 +* Lmin= .2 Lmax= .8 Wmin= 2.8 Wmax= 2.8 +.Model N1 NMOS Level= 9 ++TNOM = 27 TOX = 4.5E-09 TSI = .0000001 TBOX = 8E-08 ++MOBMOD = 0 CAPMOD = 2 SHMOD =0 ++PARAMCHK=0 WINT = 0 LINT = -2E-08 ++VTH0 = .42 K1 = .49 K2 = .1 K3 = 0 ++K3B = 2.2 NLX = 2E-7 ++DVT0 = 10 DVT1 = .55 DVT2 = -1.4 ++DVT0W = 0 DVT1W = 0 DVT2W = 0 ++NCH = 4.7E+17 NSUB = -1E+15 NGATE = 1E+20 ++AGIDL=1e-15 BGIDL=1e9 NGIDL=1.1 ++NDIODE = 1.13 NTUN = 14.0 NRECF0=2.5 NRECR0=4 ++VREC0=1.2 NTRECF=.1 NTRECR=.2 ++ISBJT = 1e-4 ISDIF = 1e-5 ISTUN = 2e-5 ISREC = 4e-2 ++XBJT = .9 XDIF = .9 XREC = .9 XTUN = 0.01 ++AHLI=1e-9 LBJT0=0.2e-6 LN=2e-6 ++NBJT=.8 NDIF=-1 AELY=1e8 VABJT=0 ++U0 = 352 UA = 1.3E-11 UB = 1.7E-18 UC = -4E-10 ++W0 = 1.16E-06 AGS = .25 A1 = 0 A2 = 1 ++B0 = .01 B1 = 10 ++RDSW = 0 PRWG = 0 PRWB = -.2 WR = 1 ++RBODY = 1e0 RBSH = 0.0 ++A0 = 1.4 KETA = 0.1 KETAS = 0.2 VSAT = 135000 ++DWG = 0 DWB = 0 ++ALPHA0 = 1e-8 BETA0 = 0 BETA1 = 0.05 BETA2 = 0.07 ++VDSATII0 = .8 ESATII = 1e7 ++VOFF = -.14 NFACTOR = .7 CDSC = .00002 CDSCB = 0 ++CDSCD = 0 CIT = 0 ++PCLM = 2.9 PVAG = 12 PDIBLC1 = .18 PDIBLC2 = .004 ++PDIBLCB = -.234 DROUT = .2 ++DELTA = .01 ETA0 = .05 ETAB = 0 ++DSUB = .2 RTH0 = .005 ++CLC = .0000001 CLE = .6 CF = 1E-20 CKAPPA = .6 ++CGDL = 1E-20 CGSL = 1E-20 KT1 = -.3 KT1L = 0 ++KT2 = .022 UTE = -1.5 UA1 = 4.31E-09 UB1 = -7.61E-18 ++UC1 = -5.6E-11 PRT = 760 AT = 22400 ++CGSO = 1e-10 CGDO = 1e-10 CJSWG = 1e-12 TT=3e-10 ++ASD = 0.3 CSDESW = 1e-12 ++TCJSWG=1e-4 MJSWG=.5 PBSWG=1 diff --git a/tests/bsim3soipd/pmospd.mod b/tests/bsim3soipd/pmospd.mod new file mode 100644 index 000000000..b77685e60 --- /dev/null +++ b/tests/bsim3soipd/pmospd.mod @@ -0,0 +1,40 @@ +*Model Card for BSIMPD2.0 +* Lmin= .2 Lmax= .8 Wmin= 2.8 Wmax= 2.8 +.Model P1 PMOS Level= 9 ++TNOM = 27 TOX = 4.5E-09 TSI = .0000001 TBOX = 8E-08 ++MOBMOD = 2 CAPMOD = 2 SHMOD = 0 ++WINT = 0 LINT = -2E-08 ++VTH0 = -.42 K1 = .49 K2 = .1 K3 = 0 ++K3B = 2.2 NLX = 2E-07 ++DVT0 = 10 DVT1 = .55 DVT2 = -1.4 ++DVT0W = 0 DVT1W = 0 DVT2W = 0 ++NCH = 4.7E+17 NSUB = -1E+15 NGATE = 1E+20 ++AGIDL=1e-16 BGIDL=1e9 NGIDL=1.1 ++NDIODE = 1.13 NTUN = 14.0 NRECF0=2.5 NRECR0=4 ++VREC0=1.2 NTRECF=.1 NTRECR=.2 ++ISBJT = 1e-4 ISDIF = 1e-5 ISTUN = 2e-5 ISREC = 4e-2 ++XBJT = .9 XDIF = .9 XREC = .9 XTUN = 0.01 ++AHLI=1e-9 LBJT0=0.2e-6 LN=2e-6 ++NBJT=.8 NDIF=-1 AELY=1e8 VABJT=0 ++U0 = 145 UA = 1.3E-11 UB = 1.7E-18 UC = -4E-10 ++W0 = 1.16E-06 AGS = .25 A1 = 0 A2 = 1 ++B0 = .01 B1 = 10 ++RDSW = 350 PRWG = 0 PRWB = -.2 WR = 1 ++RBODY = 1e0 RBSH = 0.0 ++A0 = 1.4 KETA = 0.1 KETAS = 0.2 VSAT = 75000 ++DWG = 0 DWB = 0 ++ALPHA0 = 1e-8 BETA0 = 0 BETA1 = 0.05 BETA2 = 0.07 ++VDSATII0 = 1.6 ESATII = 1e7 ++VOFF = -.14 NFACTOR = .7 CDSC = .00002 CDSCB = 0 ++CDSCD = 0 CIT = 0 ++PCLM = 2.9 PVAG = 12 PDIBLC1 = .18 PDIBLC2 = .004 ++PDIBLCB = -.234 DROUT = .2 ++DELTA = .01 ETA0 = .05 ETAB = 0 ++DSUB = .2 RTH0 = .005 ++CLC = .0000001 CLE = .6 CF = 1E-20 CKAPPA = .6 ++CGDL = 1E-20 CGSL = 1E-20 KT1 = -.3 KT1L = 0 ++KT2 = .022 UTE = -1.5 UA1 = 4.31E-09 UB1 = -7.61E-18 ++UC1 = -5.6E-11 PRT = 760 AT = 22400 ++CGSO = 1e-10 CGDO = 1e-10 CJSWG = 1e-12 TT=3e-10 ++ASD = 0.3 CSDESW = 1e-12 ++TCJSWG=1e-4 MJSWG=.5 PBSWG=1 diff --git a/tests/bsim3soipd/ring51.cir b/tests/bsim3soipd/ring51.cir new file mode 100644 index 000000000..81d3cb2f0 --- /dev/null +++ b/tests/bsim3soipd/ring51.cir @@ -0,0 +1,23 @@ +* 51 stage Ring-Osc. + +vin in out 2 pulse 2 0 0.1n 5n 1 1 1 +vdd dd 0 dc 0 pulse 0 2 0 1n 1 1 1 +vss ss 0 dc 0 +ve sub 0 dc 0 + +xinv1 dd ss sub in out25 inv25 +xinv2 dd ss sub out25 out50 inv25 +xinv5 dd ss sub out50 out inv1 +xinv11 dd ss sub out buf inv1 +cout buf ss 1pF + +xdum ss dum + +.option itl1=500 gmin=1e-15 itl4=10 +*.dc vdd 0 2 0.01 +.tran 0.2n 50n + +.include nmospd.mod +.include pmospd.mod +.include lib.h +.end diff --git a/tests/bsim3soipd/t5.cir b/tests/bsim3soipd/t5.cir new file mode 100644 index 000000000..eb7dbe929 --- /dev/null +++ b/tests/bsim3soipd/t5.cir @@ -0,0 +1,18 @@ +*model = BSIMSOI +*Berkeley Spice Compatibility +* +* SOI NMOSFET, floating body simulation + +vd d 0 dc 0.05 +vs s 0 dc 0 +ve e 0 dc 0 +vg g 0 dc 3 + +m1 d g s e n1 w=10u l=0.25u + +.option gmin=1e-25 itl1=500 +.dc vg 0 1.5 0.01 ve -4 4 1 +.include nmospd.mod + +* For PD, the command '.include nmosfd.mod ' should +* be replaced with '.include nmospd.mod'.