epilectrik
/
pyNgSpice
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

old version

pre-master-46
dwarning 18 years ago
parent
c6f5b60101
commit
ecd45d7ce3
23 changed files with 0 additions and 17084 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 645
      src/spicelib/devices/bsim3soi/b3soi.c
  2. 402
      src/spicelib/devices/bsim3soi/b3soiacld.c
  3. 274
      src/spicelib/devices/bsim3soi/b3soiask.c
  4. 769
      src/spicelib/devices/bsim3soi/b3soicheck.c
  5. 92
      src/spicelib/devices/bsim3soi/b3soicvtest.c
  6. 2462
      src/spicelib/devices/bsim3soi/b3soidef.h
  7. 38
      src/spicelib/devices/bsim3soi/b3soidel.c
  8. 38
      src/spicelib/devices/bsim3soi/b3soidest.c
  9. 30
      src/spicelib/devices/bsim3soi/b3soiext.h
  10. 54
      src/spicelib/devices/bsim3soi/b3soigetic.c
  11. 83
      src/spicelib/devices/bsim3soi/b3soiinit.c
  12. 13
      src/spicelib/devices/bsim3soi/b3soiinit.h
  13. 16
      src/spicelib/devices/bsim3soi/b3soiitf.h
  14. 4884
      src/spicelib/devices/bsim3soi/b3soild.c
  15. 1630
      src/spicelib/devices/bsim3soi/b3soimask.c
  16. 44
      src/spicelib/devices/bsim3soi/b3soimdel.c
  17. 2158
      src/spicelib/devices/bsim3soi/b3soimpar.c
  18. 400
      src/spicelib/devices/bsim3soi/b3soinoi.c
  19. 172
      src/spicelib/devices/bsim3soi/b3soipar.c
  20. 158
      src/spicelib/devices/bsim3soi/b3soipzld.c
  21. 1595
      src/spicelib/devices/bsim3soi/b3soiset.c
  22. 1076
      src/spicelib/devices/bsim3soi/b3soitemp.c
  23. 51
      src/spicelib/devices/bsim3soi/b3soitrunc.c

645
src/spicelib/devices/bsim3soi/b3soi.c
View File

@ -1,645 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soi.c 98/5/01
Modified by Pin Su and Jan Feng 99/2/15
Modified by Pin Su 99/4/30
Modified by Wei Jin 99/9/27
Modified by Pin Su 00/3/1
Modified by Pin Su 01/2/15
Modified by Pin Su 02/3/5
Modified by Pin Su 02/5/20
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "devdefs.h"
#include "b3soidef.h"
#include "suffix.h"
IFparm B3SOIpTable[] = { /* parameters */
IOP( "l", B3SOI_L, IF_REAL , "Length"),
IOP( "w", B3SOI_W, IF_REAL , "Width"),
IOP( "m", B3SOI_M, IF_REAL , "Parallel Multiplier"),
IOP( "ad", B3SOI_AD, IF_REAL , "Drain area"),
IOP( "as", B3SOI_AS, IF_REAL , "Source area"),
IOP( "pd", B3SOI_PD, IF_REAL , "Drain perimeter"),
IOP( "ps", B3SOI_PS, IF_REAL , "Source perimeter"),
IOP( "nrd", B3SOI_NRD, IF_REAL , "Number of squares in drain"),
IOP( "nrs", B3SOI_NRS, IF_REAL , "Number of squares in source"),
IOP( "off", B3SOI_OFF, IF_FLAG , "Device is initially off"),
IP( "ic", B3SOI_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"),
OP( "gmbs", B3SOI_GMBS, IF_REAL, "Gmb"),
OP( "gm", B3SOI_GM, IF_REAL, "Gm"),
OP( "gm/ids", B3SOI_GMID, IF_REAL, "Gm/Ids"),
OP( "gds", B3SOI_GDS, IF_REAL, "Gds"),
OP( "vdsat", B3SOI_VDSAT, IF_REAL, "Vdsat"),
OP( "vth", B3SOI_VON, IF_REAL, "Vth"),
OP( "ids", B3SOI_CD, IF_REAL, "Ids"),
OP( "vbs", B3SOI_VBS, IF_REAL, "Vbs"),
OP( "vgs", B3SOI_VGS, IF_REAL, "Vgs"),
OP( "vds", B3SOI_VDS, IF_REAL, "Vds"),
OP( "ves", B3SOI_VES, IF_REAL, "Ves"),
IOP( "bjtoff", B3SOI_BJTOFF, IF_INTEGER, "BJT on/off flag"),
IOP( "debug", B3SOI_DEBUG, IF_INTEGER, "BJT on/off flag"),
IOP( "rth0", B3SOI_RTH0, IF_REAL, "Instance Thermal Resistance"),
IOP( "cth0", B3SOI_CTH0, IF_REAL, "Instance Thermal Capacitance"),
IOP( "nrb", B3SOI_NRB, IF_REAL, "Number of squares in body"),
IOP( "frbody", B3SOI_FRBODY, IF_REAL, "layout dependent body-resistance coefficient"),
/* v2.0 release */
IOP( "nbc", B3SOI_NBC, IF_REAL, "Number of body contact isolation edge"),
IOP( "nseg", B3SOI_NSEG, IF_REAL, "Number segments for width partitioning"),
IOP( "pdbcp", B3SOI_PDBCP, IF_REAL, "Perimeter length for bc parasitics at drain side"),
IOP( "psbcp", B3SOI_PSBCP, IF_REAL, "Perimeter length for bc parasitics at source side"),
IOP( "agbcp", B3SOI_AGBCP, IF_REAL, "Gate to body overlap area for bc parasitics"),
IOP( "aebcp", B3SOI_AEBCP, IF_REAL, "Substrate to body overlap area for bc prasitics"),
IOP( "vbsusr", B3SOI_VBSUSR, IF_REAL, "Vbs specified by user"),
IOP( "tnodeout", B3SOI_TNODEOUT, IF_FLAG, "Flag indicating external temp node")
};
IFparm B3SOImPTable[] = { /* model parameters */
IOP( "capmod", B3SOI_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"),
IOP( "mobmod", B3SOI_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"),
IOP( "noimod", B3SOI_MOD_NOIMOD, IF_INTEGER, "Noise model selector"),
IOP( "paramchk", B3SOI_MOD_PARAMCHK, IF_INTEGER, "Model parameter checking selector"),
IOP( "binunit", B3SOI_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"),
IOP( "version", B3SOI_MOD_VERSION, IF_REAL, " parameter for model version"),
IOP( "tox", B3SOI_MOD_TOX, IF_REAL, "Gate oxide thickness in meters"),
IOP( "dtoxcv", B3SOI_MOD_DTOXCV, IF_REAL, "Delta oxide thickness in meters in CapMod3"), /* v2.2.3 */
IOP( "cdsc", B3SOI_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"),
IOP( "cdscb", B3SOI_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"),
IOP( "cdscd", B3SOI_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"),
IOP( "cit", B3SOI_MOD_CIT, IF_REAL, "Interface state capacitance"),
IOP( "nfactor", B3SOI_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"),
IOP( "vsat", B3SOI_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"),
IOP( "at", B3SOI_MOD_AT, IF_REAL, "Temperature coefficient of vsat"),
IOP( "a0", B3SOI_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."),
IOP( "ags", B3SOI_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."),
IOP( "a1", B3SOI_MOD_A1, IF_REAL, "Non-saturation effect coefficient"),
IOP( "a2", B3SOI_MOD_A2, IF_REAL, "Non-saturation effect coefficient"),
IOP( "keta", B3SOI_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."),
IOP( "nsub", B3SOI_MOD_NSUB, IF_REAL, "Substrate doping concentration with polarity"),
IOP( "nch", B3SOI_MOD_NPEAK, IF_REAL, "Channel doping concentration"),
IOP( "ngate", B3SOI_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"),
IOP( "gamma1", B3SOI_MOD_GAMMA1, IF_REAL, "Vth body coefficient"),
IOP( "gamma2", B3SOI_MOD_GAMMA2, IF_REAL, "Vth body coefficient"),
IOP( "vbx", B3SOI_MOD_VBX, IF_REAL, "Vth transition body Voltage"),
IOP( "vbm", B3SOI_MOD_VBM, IF_REAL, "Maximum body voltage"),
IOP( "xt", B3SOI_MOD_XT, IF_REAL, "Doping depth"),
IOP( "k1", B3SOI_MOD_K1, IF_REAL, "Bulk effect coefficient 1"),
IOP( "kt1", B3SOI_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt1l", B3SOI_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt2", B3SOI_MOD_KT2, IF_REAL, "Body-coefficient of kt1"),
IOP( "k2", B3SOI_MOD_K2, IF_REAL, "Bulk effect coefficient 2"),
IOP( "k3", B3SOI_MOD_K3, IF_REAL, "Narrow width effect coefficient"),
IOP( "k3b", B3SOI_MOD_K3B, IF_REAL, "Body effect coefficient of k3"),
IOP( "w0", B3SOI_MOD_W0, IF_REAL, "Narrow width effect parameter"),
IOP( "nlx", B3SOI_MOD_NLX, IF_REAL, "Lateral non-uniform doping effect"),
IOP( "dvt0", B3SOI_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"),
IOP( "dvt1", B3SOI_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"),
IOP( "dvt2", B3SOI_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"),
IOP( "dvt0w", B3SOI_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"),
IOP( "dvt1w", B3SOI_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"),
IOP( "dvt2w", B3SOI_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"),
IOP( "drout", B3SOI_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"),
IOP( "dsub", B3SOI_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"),
IOP( "vth0", B3SOI_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "vtho", B3SOI_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "ua", B3SOI_MOD_UA, IF_REAL, "Linear gate dependence of mobility"),
IOP( "ua1", B3SOI_MOD_UA1, IF_REAL, "Temperature coefficient of ua"),
IOP( "ub", B3SOI_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"),
IOP( "ub1", B3SOI_MOD_UB1, IF_REAL, "Temperature coefficient of ub"),
IOP( "uc", B3SOI_MOD_UC, IF_REAL, "Body-bias dependence of mobility"),
IOP( "uc1", B3SOI_MOD_UC1, IF_REAL, "Temperature coefficient of uc"),
IOP( "u0", B3SOI_MOD_U0, IF_REAL, "Low-field mobility at Tnom"),
IOP( "ute", B3SOI_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"),
IOP( "voff", B3SOI_MOD_VOFF, IF_REAL, "Threshold voltage offset"),
IOP( "tnom", B3SOI_MOD_TNOM, IF_REAL, "Parameter measurement temperature"),
IOP( "cgso", B3SOI_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"),
IOP( "cgdo", B3SOI_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"),
IOP( "xpart", B3SOI_MOD_XPART, IF_REAL, "Channel charge partitioning"),
IOP( "delta", B3SOI_MOD_DELTA, IF_REAL, "Effective Vds parameter"),
IOP( "rsh", B3SOI_MOD_RSH, IF_REAL, "Source-drain sheet resistance"),
IOP( "rdsw", B3SOI_MOD_RDSW, IF_REAL, "Source-drain resistance per width"),
IOP( "prwg", B3SOI_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "),
IOP( "prwb", B3SOI_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "),
IOP( "prt", B3SOI_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "),
IOP( "eta0", B3SOI_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "etab", B3SOI_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "pclm", B3SOI_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"),
IOP( "pdiblc1", B3SOI_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblc2", B3SOI_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblcb", B3SOI_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"),
IOP( "pvag", B3SOI_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"),
IOP( "shmod", B3SOI_MOD_SHMOD, IF_INTEGER, "Self heating mode selector"),
IOP( "ddmod", B3SOI_MOD_DDMOD, IF_INTEGER, "Dynamic depletion mode selector"),
IOP( "tbox", B3SOI_MOD_TBOX, IF_REAL, "Back gate oxide thickness in meters"),
IOP( "tsi", B3SOI_MOD_TSI, IF_REAL, "Silicon-on-insulator thickness in meters"),
IOP( "xj", B3SOI_MOD_XJ, IF_REAL, "Junction Depth"),
IOP( "rth0", B3SOI_MOD_RTH0, IF_REAL, "Self-heating thermal resistance"),
IOP( "cth0", B3SOI_MOD_CTH0, IF_REAL, "Self-heating thermal capacitance"),
IOP( "ngidl", B3SOI_MOD_NGIDL, IF_REAL, "GIDL first parameter"),
IOP( "agidl", B3SOI_MOD_AGIDL, IF_REAL, "GIDL second parameter"),
IOP( "bgidl", B3SOI_MOD_BGIDL, IF_REAL, "GIDL third parameter"),
IOP( "ndiode", B3SOI_MOD_NDIODE, IF_REAL, "Diode non-ideality factor"),
IOP( "xbjt", B3SOI_MOD_XBJT, IF_REAL, "Temperature coefficient for Isbjt"),
IOP( "xdif", B3SOI_MOD_XDIF, IF_REAL, "Temperature coefficient for Isdif"),
IOP( "xrec", B3SOI_MOD_XREC, IF_REAL, "Temperature coefficient for Isrec"),
IOP( "xtun", B3SOI_MOD_XTUN, IF_REAL, "Temperature coefficient for Istun"),
IOP( "pbswg", B3SOI_MOD_PBSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance built in potential"),
IOP( "mjswg", B3SOI_MOD_MJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance grading coefficient"),
IOP( "cjswg", B3SOI_MOD_CJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance per unit width"),
IOP( "lint", B3SOI_MOD_LINT, IF_REAL, "Length reduction parameter"),
IOP( "ll", B3SOI_MOD_LL, IF_REAL, "Length reduction parameter"),
IOP( "llc", B3SOI_MOD_LLC, IF_REAL, "Length reduction parameter"), /* v2.2.3 */
IOP( "lln", B3SOI_MOD_LLN, IF_REAL, "Length reduction parameter"),
IOP( "lw", B3SOI_MOD_LW, IF_REAL, "Length reduction parameter"),
IOP( "lwc", B3SOI_MOD_LWC, IF_REAL, "Length reduction parameter"), /* v2.2.3 */
IOP( "lwn", B3SOI_MOD_LWN, IF_REAL, "Length reduction parameter"),
IOP( "lwl", B3SOI_MOD_LWL, IF_REAL, "Length reduction parameter"),
IOP( "lwlc", B3SOI_MOD_LWLC, IF_REAL, "Length reduction parameter"), /* v2.2.3 */
IOP( "wr", B3SOI_MOD_WR, IF_REAL, "Width dependence of rds"),
IOP( "wint", B3SOI_MOD_WINT, IF_REAL, "Width reduction parameter"),
IOP( "dwg", B3SOI_MOD_DWG, IF_REAL, "Width reduction parameter"),
IOP( "dwb", B3SOI_MOD_DWB, IF_REAL, "Width reduction parameter"),
IOP( "wl", B3SOI_MOD_WL, IF_REAL, "Width reduction parameter"),
IOP( "wlc", B3SOI_MOD_WLC, IF_REAL, "Width reduction parameter"), /* v2.2.3 */
IOP( "wln", B3SOI_MOD_WLN, IF_REAL, "Width reduction parameter"),
IOP( "ww", B3SOI_MOD_WW, IF_REAL, "Width reduction parameter"),
IOP( "wwc", B3SOI_MOD_WWC, IF_REAL, "Width reduction parameter"), /* v2.2.3 */
IOP( "wwn", B3SOI_MOD_WWN, IF_REAL, "Width reduction parameter"),
IOP( "wwl", B3SOI_MOD_WWL, IF_REAL, "Width reduction parameter"),
IOP( "wwlc", B3SOI_MOD_WWLC, IF_REAL, "Width reduction parameter"), /* v2.2.3 */
IOP( "b0", B3SOI_MOD_B0, IF_REAL, "Abulk narrow width parameter"),
IOP( "b1", B3SOI_MOD_B1, IF_REAL, "Abulk narrow width parameter"),
IOP( "cgsl", B3SOI_MOD_CGSL, IF_REAL, "New C-V model parameter"),
IOP( "cgdl", B3SOI_MOD_CGDL, IF_REAL, "New C-V model parameter"),
IOP( "ckappa", B3SOI_MOD_CKAPPA, IF_REAL, "New C-V model parameter"),
IOP( "cf", B3SOI_MOD_CF, IF_REAL, "Fringe capacitance parameter"),
IOP( "clc", B3SOI_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "cle", B3SOI_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "dwc", B3SOI_MOD_DWC, IF_REAL, "Delta W for C-V model"),
IOP( "dlc", B3SOI_MOD_DLC, IF_REAL, "Delta L for C-V model"),
IOP( "alpha0", B3SOI_MOD_ALPHA0, IF_REAL, "substrate current model parameter"),
IOP( "noia", B3SOI_MOD_NOIA, IF_REAL, "Flicker noise parameter"),
IOP( "noib", B3SOI_MOD_NOIB, IF_REAL, "Flicker noise parameter"),
IOP( "noic", B3SOI_MOD_NOIC, IF_REAL, "Flicker noise parameter"),
IOP( "em", B3SOI_MOD_EM, IF_REAL, "Flicker noise parameter"),
IOP( "ef", B3SOI_MOD_EF, IF_REAL, "Flicker noise frequency exponent"),
IOP( "af", B3SOI_MOD_AF, IF_REAL, "Flicker noise exponent"),
IOP( "kf", B3SOI_MOD_KF, IF_REAL, "Flicker noise coefficient"),
IOP( "noif", B3SOI_MOD_NOIF, IF_REAL, "Floating body excess noise ideality factor"),
/* v2.0 release */
IOP( "k1w1", B3SOI_MOD_K1W1, IF_REAL, "First Body effect width dependent parameter"),
IOP( "k1w2", B3SOI_MOD_K1W2, IF_REAL, "Second Boby effect width dependent parameter"),
IOP( "ketas", B3SOI_MOD_KETAS, IF_REAL, "Surface potential adjustment for bulk charge effect"),
IOP( "dwbc", B3SOI_MOD_DWBC, IF_REAL, "Width offset for body contact isolation edge"),
IOP( "beta0", B3SOI_MOD_BETA0, IF_REAL, "First Vds dependent parameter of impact ionizition current"),
IOP( "beta1", B3SOI_MOD_BETA1, IF_REAL, "Second Vds dependent parameter of impact ionizition current"),
IOP( "beta2", B3SOI_MOD_BETA2, IF_REAL, "Third Vds dependent parameter of impact ionizition current"),
IOP( "vdsatii0", B3SOI_MOD_VDSATII0, IF_REAL, "Nominal drain saturation voltage at threshold for impact ionizition current"),
IOP( "tii", B3SOI_MOD_TII, IF_REAL, "Temperature dependent parameter for impact ionizition"),
IOP( "lii", B3SOI_MOD_LII, IF_REAL, "Channel length dependent parameter at threshold for impact ionizition current"),
IOP( "sii0", B3SOI_MOD_SII0, IF_REAL, "First Vgs dependent parameter for impact ionizition current"),
IOP( "sii1", B3SOI_MOD_SII1, IF_REAL, "Second Vgs dependent parameter for impact ionizition current"),
IOP( "sii2", B3SOI_MOD_SII2, IF_REAL, "Third Vgs dependent parameter for impact ionizition current"),
IOP( "siid", B3SOI_MOD_SIID, IF_REAL, "Vds dependent parameter of drain saturation voltage for impact ionizition current"),
IOP( "fbjtii", B3SOI_MOD_FBJTII, IF_REAL, "Fraction of bipolar current affecting the impact ionization"),
IOP( "esatii", B3SOI_MOD_ESATII, IF_REAL, "Saturation electric field for impact ionization"),
IOP( "ntun", B3SOI_MOD_NTUN, IF_REAL, "Reverse tunneling non-ideality factor"),
IOP( "nrecf0", B3SOI_MOD_NRECF0, IF_REAL, "Recombination non-ideality factor at forward bias"),
IOP( "nrecr0", B3SOI_MOD_NRECR0, IF_REAL, "Recombination non-ideality factor at reversed bias"),
IOP( "isbjt", B3SOI_MOD_ISBJT, IF_REAL, "BJT injection saturation current"),
IOP( "isdif", B3SOI_MOD_ISDIF, IF_REAL, "Body to source/drain injection saturation current"),
IOP( "isrec", B3SOI_MOD_ISREC, IF_REAL, "Recombination in depletion saturation current"),
IOP( "istun", B3SOI_MOD_ISTUN, IF_REAL, "Reverse tunneling saturation current"),
IOP( "ln", B3SOI_MOD_LN, IF_REAL, "Electron/hole diffusion length"),
IOP( "vrec0", B3SOI_MOD_VREC0, IF_REAL, "Voltage dependent parameter for recombination current"),
IOP( "vtun0", B3SOI_MOD_VTUN0, IF_REAL, "Voltage dependent parameter for tunneling current"),
IOP( "nbjt", B3SOI_MOD_NBJT, IF_REAL, "Power coefficient of channel length dependency for bipolar current"),
IOP( "lbjt0", B3SOI_MOD_LBJT0, IF_REAL, "Refferenc channel length for bipolar cuurent"),
IOP( "ldif0", B3SOI_MOD_LDIF0, IF_REAL, "Channel-length dependency coefficient of diffusion cap"),
IOP( "vabjt", B3SOI_MOD_VABJT, IF_REAL, "Early voltage for bipolar current"),
IOP( "aely", B3SOI_MOD_AELY, IF_REAL, "Channel length dependency of early voltage for bipolar cuurent"),
IOP( "ahli", B3SOI_MOD_AHLI, IF_REAL, "High level injection parameter for bipolar current"),
IOP( "rbody", B3SOI_MOD_RBODY, IF_REAL, "Intrinsic body contact sheet resistance"),
IOP( "rbsh", B3SOI_MOD_RBSH, IF_REAL, "Extrinsic body contact sheet resistance"),
IOP( "cgeo", B3SOI_MOD_CGEO, IF_REAL, "Gate substrate overlap capacitance per unit channel length"),
IOP( "tt", B3SOI_MOD_TT, IF_REAL, "Diffusion capacitance transit time coefficient"),
IOP( "ndif", B3SOI_MOD_NDIF, IF_REAL, "Power coefficient of channel length dependency for diffusion capacitance"),
IOP( "vsdfb", B3SOI_MOD_VSDFB, IF_REAL, "Source/drain bottom diffusion capacitance flatband voltage"),
IOP( "vsdth", B3SOI_MOD_VSDTH, IF_REAL, "Source/drain bottom diffusion capacitance threshold voltage"),
IOP( "csdmin", B3SOI_MOD_CSDMIN, IF_REAL, "Source/drain bottom diffusion minimum capacitance"),
IOP( "asd", B3SOI_MOD_ASD, IF_REAL, "Source/drain bottom diffusion smoothing parameter"),
IOP( "csdesw", B3SOI_MOD_CSDESW, IF_REAL, "Source/drain sidewall fringing capacitance per unit length"),
IOP( "ntrecf", B3SOI_MOD_NTRECF, IF_REAL, "Temperature coefficient for Nrecf"),
IOP( "ntrecr", B3SOI_MOD_NTRECR, IF_REAL, "Temperature coefficient for Nrecr"),
IOP( "dlcb", B3SOI_MOD_DLCB, IF_REAL, "Length offset fitting parameter for body charge"),
IOP( "fbody", B3SOI_MOD_FBODY, IF_REAL, "Scaling factor for body charge"),
IOP( "tcjswg", B3SOI_MOD_TCJSWG, IF_REAL, "Temperature coefficient of Cjswg"),
IOP( "tpbswg", B3SOI_MOD_TPBSWG, IF_REAL, "Temperature coefficient of Pbswg"),
IOP( "acde", B3SOI_MOD_ACDE, IF_REAL, "Exponential coefficient for charge thickness in capMod=3 for accumulation and depletion regions"),
IOP( "moin", B3SOI_MOD_MOIN, IF_REAL, "Coefficient for the gate-bias dependent surface potential"),
IOP( "delvt", B3SOI_MOD_DELVT, IF_REAL, "Threshold voltage adjust for CV"),
IOP( "kb1", B3SOI_MOD_KB1, IF_REAL, "Scaling factor for backgate charge"),
IOP( "dlbg", B3SOI_MOD_DLBG, IF_REAL, "Length offset fitting parameter for backgate charge"),
/* v2.2 release */
IOP( "igbmod", B3SOI_MOD_IGBMOD, IF_INTEGER, "gate-body tunneling current model selector"), /* v3.0 */
IOP( "igcmod", B3SOI_MOD_IGCMOD, IF_INTEGER, "gate-channel tunneling current model selector"), /* v3.0 */
IOP( "toxqm", B3SOI_MOD_TOXQM, IF_REAL, "effective oxide thickness considering quantum effect"),
IOP( "wth0", B3SOI_MOD_WTH0, IF_REAL, "Minimum width for thermal resistance calculation"),
IOP( "rhalo", B3SOI_MOD_RHALO, IF_REAL, "body halo sheet resistance"),
IOP( "ntox", B3SOI_MOD_NTOX, IF_REAL, "power term of gate current"),
IOP( "toxref", B3SOI_MOD_TOXREF, IF_REAL, "target oxide thickness"),
IOP( "ebg", B3SOI_MOD_EBG, IF_REAL, "effective bandgap in gate current calcula."),
IOP( "vevb", B3SOI_MOD_VEVB, IF_REAL, "Vaux parameter for valence-band electron tunneling"),
IOP( "alphagb1", B3SOI_MOD_ALPHAGB1, IF_REAL, "First Vox dependent parameter for gate curent in inversion"),
IOP( "betagb1", B3SOI_MOD_BETAGB1, IF_REAL, "Second Vox dependent parameter for gate currnt in inversion"),
IOP( "vgb1", B3SOI_MOD_VGB1, IF_REAL, "Third Vox dependent parameter for gate current in inversion"),
IOP( "vecb", B3SOI_MOD_VECB, IF_REAL, "Vaux parameter for conduction-band electron tunneling"),
IOP( "alphagb2", B3SOI_MOD_ALPHAGB2, IF_REAL, "First Vox dependent parameter for gate current in accumulation"),
IOP( "betagb2", B3SOI_MOD_BETAGB2, IF_REAL, "Second Vox dependent parameter for gate current in accumulation"),
IOP( "vgb2", B3SOI_MOD_VGB2, IF_REAL, "Third Vox dependent parameter for gate current in accumulation"),
IOP( "voxh", B3SOI_MOD_VOXH, IF_REAL, "the limit of Vox in gate current calculation"),
IOP( "deltavox", B3SOI_MOD_DELTAVOX, IF_REAL, "the smoothing parameter in the Vox smoothing function"),
/* v3.0 */
IOP( "aigc", B3SOI_MOD_AIGC, IF_REAL, "Parameter for Igc"),
IOP( "bigc", B3SOI_MOD_BIGC, IF_REAL, "Parameter for Igc"),
IOP( "cigc", B3SOI_MOD_CIGC, IF_REAL, "Parameter for Igc"),
IOP( "aigsd", B3SOI_MOD_AIGSD, IF_REAL, "Parameter for Igs,d"),
IOP( "bigsd", B3SOI_MOD_BIGSD, IF_REAL, "Parameter for Igs,d"),
IOP( "cigsd", B3SOI_MOD_CIGSD, IF_REAL, "Parameter for Igs,d"),
IOP( "nigc", B3SOI_MOD_NIGC, IF_REAL, "Parameter for Igc slope"),
IOP( "pigcd", B3SOI_MOD_PIGCD, IF_REAL, "Parameter for Igc partition"),
IOP( "poxedge", B3SOI_MOD_POXEDGE, IF_REAL, "Factor for the gate edge Tox"),
IOP( "dlcig", B3SOI_MOD_DLCIG, IF_REAL, "Delta L for Ig model"),
/* v3.0 */
IOP( "soimod", B3SOI_MOD_SOIMOD, IF_REAL, "model selector for SOI technology"),
IOP( "vbsa", B3SOI_MOD_VBSA, IF_REAL, "Vbs0t offset voltage"),
IOP( "nofffd", B3SOI_MOD_NOFFFD,IF_REAL, "smoothing parameter in FD module"),
IOP( "vofffd", B3SOI_MOD_VOFFFD,IF_REAL, "smoothing parameter in FD module"),
IOP( "k1b", B3SOI_MOD_K1B, IF_REAL, "first backgate body effect parameter"),
IOP( "k2b", B3SOI_MOD_K2B, IF_REAL, "second backgate body effect parameter for short channel effect"),
IOP( "dk2b", B3SOI_MOD_DK2B, IF_REAL, "third backgate body effect parameter for short channel effect"),
IOP( "dvbd0", B3SOI_MOD_DVBD0, IF_REAL, "first short-channel effect parameter in FD module"),
IOP( "dvbd1", B3SOI_MOD_DVBD1, IF_REAL, "second short-channel effect parameter in FD module"),
IOP( "moinfd", B3SOI_MOD_MOINFD, IF_REAL, "Coefficient for the gate-bias dependent surface potential in FD"),
/* v3.0 */
/* Added for binning - START */
/* Length Dependence */
/* v3.0 */
IOP( "laigc", B3SOI_MOD_LAIGC, IF_REAL, "Length dependence of aigc"),
IOP( "lbigc", B3SOI_MOD_LBIGC, IF_REAL, "Length dependence of bigc"),
IOP( "lcigc", B3SOI_MOD_LCIGC, IF_REAL, "Length dependence of cigc"),
IOP( "laigsd", B3SOI_MOD_LAIGSD, IF_REAL, "Length dependence of aigsd"),
IOP( "lbigsd", B3SOI_MOD_LBIGSD, IF_REAL, "Length dependence of bigsd"),
IOP( "lcigsd", B3SOI_MOD_LCIGSD, IF_REAL, "Length dependence of cigsd"),
IOP( "lnigc", B3SOI_MOD_LNIGC, IF_REAL, "Length dependence of nigc"),
IOP( "lpigcd", B3SOI_MOD_LPIGCD, IF_REAL, "Length dependence for pigcd"),
IOP( "lpoxedge", B3SOI_MOD_LPOXEDGE, IF_REAL, "Length dependence for poxedge"),
IOP( "lnch", B3SOI_MOD_LNPEAK, IF_REAL, "Length dependence of nch"),
IOP( "lnsub", B3SOI_MOD_LNSUB, IF_REAL, "Length dependence of nsub"),
IOP( "lngate", B3SOI_MOD_LNGATE, IF_REAL, "Length dependence of ngate"),
IOP( "lvth0", B3SOI_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOP( "lk1", B3SOI_MOD_LK1, IF_REAL, "Length dependence of k1"),
IOP( "lk1w1", B3SOI_MOD_LK1W1, IF_REAL, "Length dependence of k1w1"),
IOP( "lk1w2", B3SOI_MOD_LK1W2, IF_REAL, "Length dependence of k1w2"),
IOP( "lk2", B3SOI_MOD_LK2, IF_REAL, "Length dependence of k2"),
IOP( "lk3", B3SOI_MOD_LK3, IF_REAL, "Length dependence of k3"),
IOP( "lk3b", B3SOI_MOD_LK3B, IF_REAL, "Length dependence of k3b"),
IOP( "lkb1", B3SOI_MOD_LKB1, IF_REAL, "Length dependence of kb1"),
IOP( "lw0", B3SOI_MOD_LW0, IF_REAL, "Length dependence of w0"),
IOP( "lnlx", B3SOI_MOD_LNLX, IF_REAL, "Length dependence of nlx"),
IOP( "ldvt0", B3SOI_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"),
IOP( "ldvt1", B3SOI_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"),
IOP( "ldvt2", B3SOI_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"),
IOP( "ldvt0w", B3SOI_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"),
IOP( "ldvt1w", B3SOI_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"),
IOP( "ldvt2w", B3SOI_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"),
IOP( "lu0", B3SOI_MOD_LU0, IF_REAL, "Length dependence of u0"),
IOP( "lua", B3SOI_MOD_LUA, IF_REAL, "Length dependence of ua"),
IOP( "lub", B3SOI_MOD_LUB, IF_REAL, "Length dependence of ub"),
IOP( "luc", B3SOI_MOD_LUC, IF_REAL, "Length dependence of uc"),
IOP( "lvsat", B3SOI_MOD_LVSAT, IF_REAL, "Length dependence of vsat"),
IOP( "la0", B3SOI_MOD_LA0, IF_REAL, "Length dependence of a0"),
IOP( "lags", B3SOI_MOD_LAGS, IF_REAL, "Length dependence of ags"),
IOP( "lb0", B3SOI_MOD_LB0, IF_REAL, "Length dependence of b0"),
IOP( "lb1", B3SOI_MOD_LB1, IF_REAL, "Length dependence of b1"),
IOP( "lketa", B3SOI_MOD_LKETA, IF_REAL, "Length dependence of keta"),
IOP( "lketas", B3SOI_MOD_LKETAS, IF_REAL, "Length dependence of ketas"),
IOP( "la1", B3SOI_MOD_LA1, IF_REAL, "Length dependence of a1"),
IOP( "la2", B3SOI_MOD_LA2, IF_REAL, "Length dependence of a2"),
IOP( "lrdsw", B3SOI_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "),
IOP( "lprwb", B3SOI_MOD_LPRWB, IF_REAL, "Length dependence of prwb "),
IOP( "lprwg", B3SOI_MOD_LPRWG, IF_REAL, "Length dependence of prwg "),
IOP( "lwr", B3SOI_MOD_LWR, IF_REAL, "Length dependence of wr"),
IOP( "lnfactor", B3SOI_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"),
IOP( "ldwg", B3SOI_MOD_LDWG, IF_REAL, "Length dependence of dwg"),
IOP( "ldwb", B3SOI_MOD_LDWB, IF_REAL, "Length dependence of dwb"),
IOP( "lvoff", B3SOI_MOD_LVOFF, IF_REAL, "Length dependence of voff"),
IOP( "leta0", B3SOI_MOD_LETA0, IF_REAL, "Length dependence of eta0"),
IOP( "letab", B3SOI_MOD_LETAB, IF_REAL, "Length dependence of etab"),
IOP( "ldsub", B3SOI_MOD_LDSUB, IF_REAL, "Length dependence of dsub"),
IOP( "lcit", B3SOI_MOD_LCIT, IF_REAL, "Length dependence of cit"),
IOP( "lcdsc", B3SOI_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"),
IOP( "lcdscb", B3SOI_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"),
IOP( "lcdscd", B3SOI_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"),
IOP( "lpclm", B3SOI_MOD_LPCLM, IF_REAL, "Length dependence of pclm"),
IOP( "lpdiblc1", B3SOI_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"),
IOP( "lpdiblc2", B3SOI_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"),
IOP( "lpdiblcb", B3SOI_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"),
IOP( "ldrout", B3SOI_MOD_LDROUT, IF_REAL, "Length dependence of drout"),
IOP( "lpvag", B3SOI_MOD_LPVAG, IF_REAL, "Length dependence of pvag"),
IOP( "ldelta", B3SOI_MOD_LDELTA, IF_REAL, "Length dependence of delta"),
IOP( "lalpha0", B3SOI_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"),
IOP( "lfbjtii", B3SOI_MOD_LFBJTII, IF_REAL, "Length dependence of fbjtii"),
IOP( "lbeta0", B3SOI_MOD_LBETA0, IF_REAL, "Length dependence of beta0"),
IOP( "lbeta1", B3SOI_MOD_LBETA1, IF_REAL, "Length dependence of beta1"),
IOP( "lbeta2", B3SOI_MOD_LBETA2, IF_REAL, "Length dependence of beta2"),
IOP( "lvdsatii0", B3SOI_MOD_LVDSATII0, IF_REAL, "Length dependence of vdsatii0"),
IOP( "llii", B3SOI_MOD_LLII, IF_REAL, "Length dependence of lii"),
IOP( "lesatii", B3SOI_MOD_LESATII, IF_REAL, "Length dependence of esatii"),
IOP( "lsii0", B3SOI_MOD_LSII0, IF_REAL, "Length dependence of sii0"),
IOP( "lsii1", B3SOI_MOD_LSII1, IF_REAL, "Length dependence of sii1"),
IOP( "lsii2", B3SOI_MOD_LSII2, IF_REAL, "Length dependence of sii2"),
IOP( "lsiid", B3SOI_MOD_LSIID, IF_REAL, "Length dependence of siid"),
IOP( "lagidl", B3SOI_MOD_LAGIDL, IF_REAL, "Length dependence of agidl"),
IOP( "lbgidl", B3SOI_MOD_LBGIDL, IF_REAL, "Length dependence of bgidl"),
IOP( "lngidl", B3SOI_MOD_LNGIDL, IF_REAL, "Length dependence of ngidl"),
IOP( "lntun", B3SOI_MOD_LNTUN, IF_REAL, "Length dependence of ntun"),
IOP( "lndiode", B3SOI_MOD_LNDIODE, IF_REAL, "Length dependence of ndiode"),
IOP( "lnrecf0", B3SOI_MOD_LNRECF0, IF_REAL, "Length dependence of nrecf0"),
IOP( "lnrecr0", B3SOI_MOD_LNRECR0, IF_REAL, "Length dependence of nrecr0"),
IOP( "lisbjt", B3SOI_MOD_LISBJT, IF_REAL, "Length dependence of isbjt"),
IOP( "lisdif", B3SOI_MOD_LISDIF, IF_REAL, "Length dependence of isdif"),
IOP( "lisrec", B3SOI_MOD_LISREC, IF_REAL, "Length dependence of isrec"),
IOP( "listun", B3SOI_MOD_LISTUN, IF_REAL, "Length dependence of istun"),
IOP( "lvrec0", B3SOI_MOD_LVREC0, IF_REAL, "Length dependence of vrec0"),
IOP( "lvtun0", B3SOI_MOD_LVTUN0, IF_REAL, "Length dependence of vtun0"),
IOP( "lnbjt", B3SOI_MOD_LNBJT, IF_REAL, "Length dependence of nbjt"),
IOP( "llbjt0", B3SOI_MOD_LLBJT0, IF_REAL, "Length dependence of lbjt0"),
IOP( "lvabjt", B3SOI_MOD_LVABJT, IF_REAL, "Length dependence of vabjt"),
IOP( "laely", B3SOI_MOD_LAELY, IF_REAL, "Length dependence of aely"),
IOP( "lahli", B3SOI_MOD_LAHLI, IF_REAL, "Length dependence of ahli"),
IOP( "lvsdfb", B3SOI_MOD_LVSDFB, IF_REAL, "Length dependence of vsdfb"),
IOP( "lvsdth", B3SOI_MOD_LVSDTH, IF_REAL, "Length dependence of vsdth"),
IOP( "ldelvt", B3SOI_MOD_LDELVT, IF_REAL, "Length dependence of delvt"),
IOP( "lacde", B3SOI_MOD_LACDE, IF_REAL, "Length dependence of acde"),
IOP( "lmoin", B3SOI_MOD_LMOIN, IF_REAL, "Length dependence of amoin"),
/* Width Dependence */
/* v3.0 */
IOP( "waigc", B3SOI_MOD_WAIGC, IF_REAL, "Width dependence of aigc"),
IOP( "wbigc", B3SOI_MOD_WBIGC, IF_REAL, "Width dependence of bigc"),
IOP( "wcigc", B3SOI_MOD_WCIGC, IF_REAL, "Width dependence of cigc"),
IOP( "waigsd", B3SOI_MOD_WAIGSD, IF_REAL, "Width dependence of aigsd"),
IOP( "wbigsd", B3SOI_MOD_WBIGSD, IF_REAL, "Width dependence of bigsd"),
IOP( "wcigsd", B3SOI_MOD_WCIGSD, IF_REAL, "Width dependence of cigsd"),
IOP( "wnigc", B3SOI_MOD_WNIGC, IF_REAL, "Width dependence of nigc"),
IOP( "wpigcd", B3SOI_MOD_WPIGCD, IF_REAL, "Width dependence for pigcd"),
IOP( "wpoxedge", B3SOI_MOD_WPOXEDGE, IF_REAL, "Width dependence for poxedge"),
IOP( "wnch", B3SOI_MOD_WNPEAK, IF_REAL, "Width dependence of nch"),
IOP( "wnsub", B3SOI_MOD_WNSUB, IF_REAL, "Width dependence of nsub"),
IOP( "wngate", B3SOI_MOD_WNGATE, IF_REAL, "Width dependence of ngate"),
IOP( "wvth0", B3SOI_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOP( "wk1", B3SOI_MOD_WK1, IF_REAL, "Width dependence of k1"),
IOP( "wk1w1", B3SOI_MOD_WK1W1, IF_REAL, "Width dependence of k1w1"),
IOP( "wk1w2", B3SOI_MOD_WK1W2, IF_REAL, "Width dependence of k1w2"),
IOP( "wk2", B3SOI_MOD_WK2, IF_REAL, "Width dependence of k2"),
IOP( "wk3", B3SOI_MOD_WK3, IF_REAL, "Width dependence of k3"),
IOP( "wk3b", B3SOI_MOD_WK3B, IF_REAL, "Width dependence of k3b"),
IOP( "wkb1", B3SOI_MOD_WKB1, IF_REAL, "Width dependence of kb1"),
IOP( "ww0", B3SOI_MOD_WW0, IF_REAL, "Width dependence of w0"),
IOP( "wnlx", B3SOI_MOD_WNLX, IF_REAL, "Width dependence of nlx"),
IOP( "wdvt0", B3SOI_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"),
IOP( "wdvt1", B3SOI_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"),
IOP( "wdvt2", B3SOI_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"),
IOP( "wdvt0w", B3SOI_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"),
IOP( "wdvt1w", B3SOI_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"),
IOP( "wdvt2w", B3SOI_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"),
IOP( "wu0", B3SOI_MOD_WU0, IF_REAL, "Width dependence of u0"),
IOP( "wua", B3SOI_MOD_WUA, IF_REAL, "Width dependence of ua"),
IOP( "wub", B3SOI_MOD_WUB, IF_REAL, "Width dependence of ub"),
IOP( "wuc", B3SOI_MOD_WUC, IF_REAL, "Width dependence of uc"),
IOP( "wvsat", B3SOI_MOD_WVSAT, IF_REAL, "Width dependence of vsat"),
IOP( "wa0", B3SOI_MOD_WA0, IF_REAL, "Width dependence of a0"),
IOP( "wags", B3SOI_MOD_WAGS, IF_REAL, "Width dependence of ags"),
IOP( "wb0", B3SOI_MOD_WB0, IF_REAL, "Width dependence of b0"),
IOP( "wb1", B3SOI_MOD_WB1, IF_REAL, "Width dependence of b1"),
IOP( "wketa", B3SOI_MOD_WKETA, IF_REAL, "Width dependence of keta"),
IOP( "wketas", B3SOI_MOD_WKETAS, IF_REAL, "Width dependence of ketas"),
IOP( "wa1", B3SOI_MOD_WA1, IF_REAL, "Width dependence of a1"),
IOP( "wa2", B3SOI_MOD_WA2, IF_REAL, "Width dependence of a2"),
IOP( "wrdsw", B3SOI_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "),
IOP( "wprwb", B3SOI_MOD_WPRWB, IF_REAL, "Width dependence of prwb "),
IOP( "wprwg", B3SOI_MOD_WPRWG, IF_REAL, "Width dependence of prwg "),
IOP( "wwr", B3SOI_MOD_WWR, IF_REAL, "Width dependence of wr"),
IOP( "wnfactor", B3SOI_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"),
IOP( "wdwg", B3SOI_MOD_WDWG, IF_REAL, "Width dependence of dwg"),
IOP( "wdwb", B3SOI_MOD_WDWB, IF_REAL, "Width dependence of dwb"),
IOP( "wvoff", B3SOI_MOD_WVOFF, IF_REAL, "Width dependence of voff"),
IOP( "weta0", B3SOI_MOD_WETA0, IF_REAL, "Width dependence of eta0"),
IOP( "wetab", B3SOI_MOD_WETAB, IF_REAL, "Width dependence of etab"),
IOP( "wdsub", B3SOI_MOD_WDSUB, IF_REAL, "Width dependence of dsub"),
IOP( "wcit", B3SOI_MOD_WCIT, IF_REAL, "Width dependence of cit"),
IOP( "wcdsc", B3SOI_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"),
IOP( "wcdscb", B3SOI_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"),
IOP( "wcdscd", B3SOI_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"),
IOP( "wpclm", B3SOI_MOD_WPCLM, IF_REAL, "Width dependence of pclm"),
IOP( "wpdiblc1", B3SOI_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"),
IOP( "wpdiblc2", B3SOI_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"),
IOP( "wpdiblcb", B3SOI_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"),
IOP( "wdrout", B3SOI_MOD_WDROUT, IF_REAL, "Width dependence of drout"),
IOP( "wpvag", B3SOI_MOD_WPVAG, IF_REAL, "Width dependence of pvag"),
IOP( "wdelta", B3SOI_MOD_WDELTA, IF_REAL, "Width dependence of delta"),
IOP( "walpha0", B3SOI_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"),
IOP( "wfbjtii", B3SOI_MOD_WFBJTII, IF_REAL, "Width dependence of fbjtii"),
IOP( "wbeta0", B3SOI_MOD_WBETA0, IF_REAL, "Width dependence of beta0"),
IOP( "wbeta1", B3SOI_MOD_WBETA1, IF_REAL, "Width dependence of beta1"),
IOP( "wbeta2", B3SOI_MOD_WBETA2, IF_REAL, "Width dependence of beta2"),
IOP( "wvdsatii0", B3SOI_MOD_WVDSATII0, IF_REAL, "Width dependence of vdsatii0"),
IOP( "wlii", B3SOI_MOD_WLII, IF_REAL, "Width dependence of lii"),
IOP( "wesatii", B3SOI_MOD_WESATII, IF_REAL, "Width dependence of esatii"),
IOP( "wsii0", B3SOI_MOD_WSII0, IF_REAL, "Width dependence of sii0"),
IOP( "wsii1", B3SOI_MOD_WSII1, IF_REAL, "Width dependence of sii1"),
IOP( "wsii2", B3SOI_MOD_WSII2, IF_REAL, "Width dependence of sii2"),
IOP( "wsiid", B3SOI_MOD_WSIID, IF_REAL, "Width dependence of siid"),
IOP( "wagidl", B3SOI_MOD_WAGIDL, IF_REAL, "Width dependence of agidl"),
IOP( "wbgidl", B3SOI_MOD_WBGIDL, IF_REAL, "Width dependence of bgidl"),
IOP( "wngidl", B3SOI_MOD_WNGIDL, IF_REAL, "Width dependence of ngidl"),
IOP( "wntun", B3SOI_MOD_WNTUN, IF_REAL, "Width dependence of ntun"),
IOP( "wndiode", B3SOI_MOD_WNDIODE, IF_REAL, "Width dependence of ndiode"),
IOP( "wnrecf0", B3SOI_MOD_WNRECF0, IF_REAL, "Width dependence of nrecf0"),
IOP( "wnrecr0", B3SOI_MOD_WNRECR0, IF_REAL, "Width dependence of nrecr0"),
IOP( "wisbjt", B3SOI_MOD_WISBJT, IF_REAL, "Width dependence of isbjt"),
IOP( "wisdif", B3SOI_MOD_WISDIF, IF_REAL, "Width dependence of isdif"),
IOP( "wisrec", B3SOI_MOD_WISREC, IF_REAL, "Width dependence of isrec"),
IOP( "wistun", B3SOI_MOD_WISTUN, IF_REAL, "Width dependence of istun"),
IOP( "wvrec0", B3SOI_MOD_WVREC0, IF_REAL, "Width dependence of vrec0"),
IOP( "wvtun0", B3SOI_MOD_WVTUN0, IF_REAL, "Width dependence of vtun0"),
IOP( "wnbjt", B3SOI_MOD_WNBJT, IF_REAL, "Width dependence of nbjt"),
IOP( "wlbjt0", B3SOI_MOD_WLBJT0, IF_REAL, "Width dependence of lbjt0"),
IOP( "wvabjt", B3SOI_MOD_WVABJT, IF_REAL, "Width dependence of vabjt"),
IOP( "waely", B3SOI_MOD_WAELY, IF_REAL, "Width dependence of aely"),
IOP( "wahli", B3SOI_MOD_WAHLI, IF_REAL, "Width dependence of ahli"),
IOP( "wvsdfb", B3SOI_MOD_WVSDFB, IF_REAL, "Width dependence of vsdfb"),
IOP( "wvsdth", B3SOI_MOD_WVSDTH, IF_REAL, "Width dependence of vsdth"),
IOP( "wdelvt", B3SOI_MOD_WDELVT, IF_REAL, "Width dependence of delvt"),
IOP( "wacde", B3SOI_MOD_WACDE, IF_REAL, "Width dependence of acde"),
IOP( "wmoin", B3SOI_MOD_WMOIN, IF_REAL, "Width dependence of amoin"),
/* Cross-term Dependence */
/* v3.0 */
IOP( "paigc", B3SOI_MOD_PAIGC, IF_REAL, "Cross-term dependence of aigc"),
IOP( "pbigc", B3SOI_MOD_PBIGC, IF_REAL, "Cross-term dependence of bigc"),
IOP( "pcigc", B3SOI_MOD_PCIGC, IF_REAL, "Cross-term dependence of cigc"),
IOP( "paigsd", B3SOI_MOD_PAIGSD, IF_REAL, "Cross-term dependence of aigsd"),
IOP( "pbigsd", B3SOI_MOD_PBIGSD, IF_REAL, "Cross-term dependence of bigsd"),
IOP( "pcigsd", B3SOI_MOD_PCIGSD, IF_REAL, "Cross-term dependence of cigsd"),
IOP( "pnigc", B3SOI_MOD_PNIGC, IF_REAL, "Cross-term dependence of nigc"),
IOP( "ppigcd", B3SOI_MOD_PPIGCD, IF_REAL, "Cross-term dependence for pigcd"),
IOP( "ppoxedge", B3SOI_MOD_PPOXEDGE, IF_REAL, "Cross-term dependence for poxedge"),
IOP( "pnch", B3SOI_MOD_PNPEAK, IF_REAL, "Cross-term dependence of nch"),
IOP( "pnsub", B3SOI_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"),
IOP( "pngate", B3SOI_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"),
IOP( "pvth0", B3SOI_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOP( "pk1", B3SOI_MOD_PK1, IF_REAL, "Cross-term dependence of k1"),
IOP( "pk1w1", B3SOI_MOD_PK1W1, IF_REAL, "Cross-term dependence of k1w1"),
IOP( "pk1w2", B3SOI_MOD_PK1W2, IF_REAL, "Cross-term dependence of k1w2"),
IOP( "pk2", B3SOI_MOD_PK2, IF_REAL, "Cross-term dependence of k2"),
IOP( "pk3", B3SOI_MOD_PK3, IF_REAL, "Cross-term dependence of k3"),
IOP( "pk3b", B3SOI_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"),
IOP( "pkb1", B3SOI_MOD_PKB1, IF_REAL, "Cross-term dependence of kb1"),
IOP( "pw0", B3SOI_MOD_PW0, IF_REAL, "Cross-term dependence of w0"),
IOP( "pnlx", B3SOI_MOD_PNLX, IF_REAL, "Cross-term dependence of nlx"),
IOP( "pdvt0", B3SOI_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"),
IOP( "pdvt1", B3SOI_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"),
IOP( "pdvt2", B3SOI_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"),
IOP( "pdvt0w", B3SOI_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"),
IOP( "pdvt1w", B3SOI_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"),
IOP( "pdvt2w", B3SOI_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"),
IOP( "pu0", B3SOI_MOD_PU0, IF_REAL, "Cross-term dependence of u0"),
IOP( "pua", B3SOI_MOD_PUA, IF_REAL, "Cross-term dependence of ua"),
IOP( "pub", B3SOI_MOD_PUB, IF_REAL, "Cross-term dependence of ub"),
IOP( "puc", B3SOI_MOD_PUC, IF_REAL, "Cross-term dependence of uc"),
IOP( "pvsat", B3SOI_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"),
IOP( "pa0", B3SOI_MOD_PA0, IF_REAL, "Cross-term dependence of a0"),
IOP( "pags", B3SOI_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"),
IOP( "pb0", B3SOI_MOD_PB0, IF_REAL, "Cross-term dependence of b0"),
IOP( "pb1", B3SOI_MOD_PB1, IF_REAL, "Cross-term dependence of b1"),
IOP( "pketa", B3SOI_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"),
IOP( "pketas", B3SOI_MOD_PKETAS, IF_REAL, "Cross-term dependence of ketas"),
IOP( "pa1", B3SOI_MOD_PA1, IF_REAL, "Cross-term dependence of a1"),
IOP( "pa2", B3SOI_MOD_PA2, IF_REAL, "Cross-term dependence of a2"),
IOP( "prdsw", B3SOI_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "),
IOP( "pprwb", B3SOI_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "),
IOP( "pprwg", B3SOI_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "),
IOP( "pwr", B3SOI_MOD_PWR, IF_REAL, "Cross-term dependence of wr"),
IOP( "pnfactor", B3SOI_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"),
IOP( "pdwg", B3SOI_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"),
IOP( "pdwb", B3SOI_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"),
IOP( "pvoff", B3SOI_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"),
IOP( "peta0", B3SOI_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"),
IOP( "petab", B3SOI_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"),
IOP( "pdsub", B3SOI_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"),
IOP( "pcit", B3SOI_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"),
IOP( "pcdsc", B3SOI_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"),
IOP( "pcdscb", B3SOI_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"),
IOP( "pcdscd", B3SOI_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"),
IOP( "ppclm", B3SOI_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"),
IOP( "ppdiblc1", B3SOI_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"),
IOP( "ppdiblc2", B3SOI_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"),
IOP( "ppdiblcb", B3SOI_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"),
IOP( "pdrout", B3SOI_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"),
IOP( "ppvag", B3SOI_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"),
IOP( "pdelta", B3SOI_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"),
IOP( "palpha0", B3SOI_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"),
IOP( "pfbjtii", B3SOI_MOD_PFBJTII, IF_REAL, "Cross-term dependence of fbjtii"),
IOP( "pbeta0", B3SOI_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"),
IOP( "pbeta1", B3SOI_MOD_PBETA1, IF_REAL, "Cross-term dependence of beta1"),
IOP( "pbeta2", B3SOI_MOD_PBETA2, IF_REAL, "Cross-term dependence of beta2"),
IOP( "pvdsatii0", B3SOI_MOD_PVDSATII0, IF_REAL, "Cross-term dependence of vdsatii0"),
IOP( "plii", B3SOI_MOD_PLII, IF_REAL, "Cross-term dependence of lii"),
IOP( "pesatii", B3SOI_MOD_PESATII, IF_REAL, "Cross-term dependence of esatii"),
IOP( "psii0", B3SOI_MOD_PSII0, IF_REAL, "Cross-term dependence of sii0"),
IOP( "psii1", B3SOI_MOD_PSII1, IF_REAL, "Cross-term dependence of sii1"),
IOP( "psii2", B3SOI_MOD_PSII2, IF_REAL, "Cross-term dependence of sii2"),
IOP( "psiid", B3SOI_MOD_PSIID, IF_REAL, "Cross-term dependence of siid"),
IOP( "pagidl", B3SOI_MOD_PAGIDL, IF_REAL, "Cross-term dependence of agidl"),
IOP( "pbgidl", B3SOI_MOD_PBGIDL, IF_REAL, "Cross-term dependence of bgidl"),
IOP( "pngidl", B3SOI_MOD_PNGIDL, IF_REAL, "Cross-term dependence of ngidl"),
IOP( "pntun", B3SOI_MOD_PNTUN, IF_REAL, "Cross-term dependence of ntun"),
IOP( "pndiode", B3SOI_MOD_PNDIODE, IF_REAL, "Cross-term dependence of ndiode"),
IOP( "pnrecf0", B3SOI_MOD_PNRECF0, IF_REAL, "Cross-term dependence of nrecf0"),
IOP( "pnrecr0", B3SOI_MOD_PNRECR0, IF_REAL, "Cross-term dependence of nrecr0"),
IOP( "pisbjt", B3SOI_MOD_PISBJT, IF_REAL, "Cross-term dependence of isbjt"),
IOP( "pisdif", B3SOI_MOD_PISDIF, IF_REAL, "Cross-term dependence of isdif"),
IOP( "pisrec", B3SOI_MOD_PISREC, IF_REAL, "Cross-term dependence of isrec"),
IOP( "pistun", B3SOI_MOD_PISTUN, IF_REAL, "Cross-term dependence of istun"),
IOP( "pvrec0", B3SOI_MOD_PVREC0, IF_REAL, "Cross-term dependence of vrec0"),
IOP( "pvtun0", B3SOI_MOD_PVTUN0, IF_REAL, "Cross-term dependence of vtun0"),
IOP( "pnbjt", B3SOI_MOD_PNBJT, IF_REAL, "Cross-term dependence of nbjt"),
IOP( "plbjt0", B3SOI_MOD_PLBJT0, IF_REAL, "Cross-term dependence of lbjt0"),
IOP( "pvabjt", B3SOI_MOD_PVABJT, IF_REAL, "Cross-term dependence of vabjt"),
IOP( "paely", B3SOI_MOD_PAELY, IF_REAL, "Cross-term dependence of aely"),
IOP( "pahli", B3SOI_MOD_PAHLI, IF_REAL, "Cross-term dependence of ahli"),
IOP( "pvsdfb", B3SOI_MOD_PVSDFB, IF_REAL, "Cross-term dependence of vsdfb"),
IOP( "pvsdth", B3SOI_MOD_PVSDTH, IF_REAL, "Cross-term dependence of vsdth"),
IOP( "pdelvt", B3SOI_MOD_PDELVT, IF_REAL, "Cross-term dependence of delvt"),
IOP( "pacde", B3SOI_MOD_PACDE, IF_REAL, "Cross-term dependence of acde"),
IOP( "pmoin", B3SOI_MOD_PMOIN, IF_REAL, "Cross-term dependence of amoin"),
/* Added for binning - END */
IP( "nmos", B3SOI_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"),
IP( "pmos", B3SOI_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"),
};
char *B3SOInames[] = {
"Drain",
"Gate",
"Source",
"Backgate",
"",
"Body",
"Temp",
"Charge",
};
int B3SOInSize = NUMELEMS(B3SOInames);
int B3SOIpTSize = NUMELEMS(B3SOIpTable);
int B3SOImPTSize = NUMELEMS(B3SOImPTable);
int B3SOIiSize = sizeof(B3SOIinstance);
int B3SOImSize = sizeof(B3SOImodel);

402
src/spicelib/devices/bsim3soi/b3soiacld.c
View File

@ -1,402 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiacld.c 98/5/01
Modified by Pin Su 99/4/30
Modified by Pin Su 99/9/27
Modified by Pin Su 02/5/20
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "b3soidef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIacLoad(GENmodel *inModel, CKTcircuit *ckt)
{
B3SOImodel *model = (B3SOImodel*)inModel;
B3SOIinstance *here;
int selfheat;
double xcggb, xcgdb, xcgsb, xcgeb, xcgT;
double xcdgb, xcddb, xcdsb, xcdeb, xcdT;
double xcsgb, xcsdb, xcssb, xcseb, xcsT;
double xcbgb, xcbdb, xcbsb, xcbeb, xcbT;
double xcegb, xceeb, xceT;
double gdpr, gspr, gds;
double cggb, cgdb, cgsb, cgT;
double cdgb, cddb, cdsb, cdeb, cdT;
double cbgb, cbdb, cbsb, cbeb, cbT;
double ceeb, ceT;
double GSoverlapCap, GDoverlapCap, GEoverlapCap, FwdSum, RevSum, Gm, Gmbs, GmT;
double omega;
double dxpart, sxpart;
double gbbg, gbbdp, gbbb, gbbp, gbbsp, gbbT;
double gddpg, gddpdp, gddpsp, gddpb, gddpT;
double gsspg, gsspdp, gsspsp, gsspb, gsspT;
double gppb, gppp;
double xcTt, cTt, gTtt, gTtg, gTtb, gTtdp, gTtsp;
double EDextrinsicCap, ESextrinsicCap;
double xcedb, xcesb;
/* v3.0 */
double Gme, gddpe, gsspe, gbbe, gTte;
double m;
omega = ckt->CKTomega;
for (; model != NULL; model = model->B3SOInextModel)
{
for (here = model->B3SOIinstances; here!= NULL;
here = here->B3SOInextInstance)
{
if (here->B3SOIowner != ARCHme)
continue;
selfheat = (model->B3SOIshMod == 1) && (here->B3SOIrth0 != 0.0);
if (here->B3SOImode >= 0)
{ Gm = here->B3SOIgm;
Gmbs = here->B3SOIgmbs;
/* v3.0 */
Gme = here->B3SOIgme;
GmT = model->B3SOItype * here->B3SOIgmT;
FwdSum = Gm + Gmbs + Gme; /* v3.0 */
RevSum = 0.0;
cbgb = here->B3SOIcbgb;
cbsb = here->B3SOIcbsb;
cbdb = here->B3SOIcbdb;
cbeb = here->B3SOIcbeb;
cbT = model->B3SOItype * here->B3SOIcbT;
ceeb = here->B3SOIceeb;
ceT = model->B3SOItype * here->B3SOIceT;
cggb = here->B3SOIcggb;
cgsb = here->B3SOIcgsb;
cgdb = here->B3SOIcgdb;
cgT = model->B3SOItype * here->B3SOIcgT;
cdgb = here->B3SOIcdgb;
cdsb = here->B3SOIcdsb;
cddb = here->B3SOIcddb;
cdeb = here->B3SOIcdeb;
cdT = model->B3SOItype * here->B3SOIcdT;
cTt = here->pParam->B3SOIcth;
gbbg = -here->B3SOIgbgs;
gbbdp = -here->B3SOIgbds;
gbbb = -here->B3SOIgbbs;
gbbp = -here->B3SOIgbps;
gbbT = -model->B3SOItype * here->B3SOIgbT;
/* v3.0 */
gbbe = -here->B3SOIgbes;
gbbsp = - ( gbbg + gbbdp + gbbb + gbbp + gbbe);
gddpg = -here->B3SOIgjdg;
gddpdp = -here->B3SOIgjdd;
gddpb = -here->B3SOIgjdb;
gddpT = -model->B3SOItype * here->B3SOIgjdT;
/* v3.0 */
gddpe = -here->B3SOIgjde;
gddpsp = - ( gddpg + gddpdp + gddpb + gddpe);
gsspg = -here->B3SOIgjsg;
gsspdp = -here->B3SOIgjsd;
gsspb = -here->B3SOIgjsb;
gsspT = -model->B3SOItype * here->B3SOIgjsT;
/* v3.0 */
gsspe = 0.0;
gsspsp = - (gsspg + gsspdp + gsspb + gsspe);
gppb = -here->B3SOIgbpbs;
gppp = -here->B3SOIgbpps;
gTtg = here->B3SOIgtempg;
gTtb = here->B3SOIgtempb;
gTtdp = here->B3SOIgtempd;
gTtt = here->B3SOIgtempT;
/* v3.0 */
gTte = here->B3SOIgtempe;
gTtsp = - (gTtg + gTtb + gTtdp + gTte);
sxpart = 0.6;
dxpart = 0.4;
}
else
{ Gm = -here->B3SOIgm;
Gmbs = -here->B3SOIgmbs;
/* v3.0 */
Gme = -here->B3SOIgme;
GmT = -model->B3SOItype * here->B3SOIgmT;
FwdSum = 0.0;
RevSum = -Gm - Gmbs - Gme; /* v3.0 */
cdgb = - (here->B3SOIcdgb + here->B3SOIcggb + here->B3SOIcbgb);
cdsb = - (here->B3SOIcddb + here->B3SOIcgdb + here->B3SOIcbdb);
cddb = - (here->B3SOIcdsb + here->B3SOIcgsb + here->B3SOIcbsb);
cdeb = - (here->B3SOIcdeb + here->B3SOIcbeb + here->B3SOIceeb);
cdT = - model->B3SOItype * (here->B3SOIcgT + here->B3SOIcbT
+ here->B3SOIcdT + here->B3SOIceT);
ceeb = here->B3SOIceeb;
ceT = model->B3SOItype * here->B3SOIceT;
cggb = here->B3SOIcggb;
cgsb = here->B3SOIcgdb;
cgdb = here->B3SOIcgsb;
cgT = model->B3SOItype * here->B3SOIcgT;
cbgb = here->B3SOIcbgb;
cbsb = here->B3SOIcbdb;
cbdb = here->B3SOIcbsb;
cbeb = here->B3SOIcbeb;
cbT = model->B3SOItype * here->B3SOIcbT;
cTt = here->pParam->B3SOIcth;
gbbg = -here->B3SOIgbgs;
gbbb = -here->B3SOIgbbs;
gbbp = -here->B3SOIgbps;
gbbsp = -here->B3SOIgbds;
gbbT = -model->B3SOItype * here->B3SOIgbT;
/* v3.0 */
gbbe = -here->B3SOIgbes;
gbbdp = - ( gbbg + gbbsp + gbbb + gbbp + gbbe);
gddpg = -here->B3SOIgjsg;
gddpsp = -here->B3SOIgjsd;
gddpb = -here->B3SOIgjsb;
gddpT = -model->B3SOItype * here->B3SOIgjsT;
/* v3.0 */
gddpe = 0.0;
gddpdp = - (gddpg + gddpsp + gddpb + gddpe );
gsspg = -here->B3SOIgjdg;
gsspsp = -here->B3SOIgjdd;
gsspb = -here->B3SOIgjdb;
gsspT = -model->B3SOItype * here->B3SOIgjdT;
/* v3.0 */
gsspe = -here->B3SOIgjde;
gsspdp = - ( gsspg + gsspsp + gsspb + gsspe );
gppb = -here->B3SOIgbpbs;
gppp = -here->B3SOIgbpps;
gTtt = here->B3SOIgtempT;
gTtg = here->B3SOIgtempg;
gTtb = here->B3SOIgtempb;
gTtdp = here->B3SOIgtempd;
/* v3.0 */
gTte = here->B3SOIgtempe;
gTtsp = - (gTtt + gTtg + gTtb + gTtdp + gTte);
gTtg = here->B3SOIgtempg;
gTtb = here->B3SOIgtempb;
gTtsp = here->B3SOIgtempd;
gTtt = here->B3SOIgtempT;
/* v3.0 */
gTte = here->B3SOIgtempe;
gTtdp = - (gTtg + gTtb + gTtsp + gTte);
sxpart = 0.6;
sxpart = 0.4;
dxpart = 0.6;
}
gdpr=here->B3SOIdrainConductance;
gspr=here->B3SOIsourceConductance;
gds= here->B3SOIgds;
GSoverlapCap = here->B3SOIcgso;
GDoverlapCap = here->B3SOIcgdo;
GEoverlapCap = here->pParam->B3SOIcgeo;
EDextrinsicCap = here->B3SOIgcde;
ESextrinsicCap = here->B3SOIgcse;
xcedb = -EDextrinsicCap * omega;
xcdeb = (cdeb - EDextrinsicCap) * omega;
xcddb = (cddb + GDoverlapCap + EDextrinsicCap) * omega;
xceeb = (ceeb + GEoverlapCap + EDextrinsicCap + ESextrinsicCap) * omega;
xcesb = -ESextrinsicCap * omega;
xcssb = (GSoverlapCap + ESextrinsicCap - (cgsb + cbsb + cdsb)) * omega;
xcseb = -(cbeb + cdeb + ceeb + ESextrinsicCap) * omega;
xcegb = (- GEoverlapCap) * omega;
xceT = ceT * omega;
xcggb = (cggb + GDoverlapCap + GSoverlapCap + GEoverlapCap)
* omega;
xcgdb = (cgdb - GDoverlapCap ) * omega;
xcgsb = (cgsb - GSoverlapCap) * omega;
xcgeb = (- GEoverlapCap) * omega;
xcgT = cgT * omega;
xcdgb = (cdgb - GDoverlapCap) * omega;
xcdsb = cdsb * omega;
xcdT = cdT * omega;
xcsgb = -(cggb + cbgb + cdgb + GSoverlapCap) * omega;
xcsdb = -(cgdb + cbdb + cddb) * omega;
xcsT = -(cgT + cbT + cdT + ceT) * omega;
xcbgb = cbgb * omega;
xcbdb = cbdb * omega;
xcbsb = cbsb * omega;
xcbeb = cbeb * omega;
xcbT = cbT * omega;
xcTt = cTt * omega;
m = here->B3SOIm;
*(here->B3SOIEdpPtr +1) += m * xcedb;
*(here->B3SOIEspPtr +1) += m * xcesb;
*(here->B3SOIDPePtr +1) += m * xcdeb;
*(here->B3SOISPePtr +1) += m * xcseb;
*(here->B3SOIEgPtr +1) += m * xcegb;
*(here->B3SOIGePtr +1) += m * xcgeb;
*(here->B3SOIEePtr +1) += m * xceeb;
*(here->B3SOIGgPtr +1) += m * xcggb;
*(here->B3SOIGdpPtr +1) += m * xcgdb;
*(here->B3SOIGspPtr +1) += m * xcgsb;
*(here->B3SOIDPgPtr +1) += m * xcdgb;
*(here->B3SOIDPdpPtr +1) += m * xcddb;
*(here->B3SOIDPspPtr +1) += m * xcdsb;
*(here->B3SOISPgPtr +1) += m * xcsgb;
*(here->B3SOISPdpPtr +1) += m * xcsdb;
*(here->B3SOISPspPtr +1) += m * xcssb;
*(here->B3SOIBePtr +1) += m * xcbeb;
*(here->B3SOIBgPtr +1) += m * xcbgb;
*(here->B3SOIBdpPtr +1) += m * xcbdb;
*(here->B3SOIBspPtr +1) += m * xcbsb;
*(here->B3SOIEbPtr +1) -= m * (xcegb + xceeb + xcedb + xcesb);
*(here->B3SOIGbPtr +1) -= m * (xcggb + xcgdb + xcgsb + xcgeb);
*(here->B3SOIDPbPtr +1) -= m * (xcdgb + xcddb + xcdsb + xcdeb);
*(here->B3SOISPbPtr +1) -= m * (xcsgb + xcsdb + xcssb + xcseb);
*(here->B3SOIBbPtr +1) -= m * (xcbgb + xcbdb + xcbsb + xcbeb);
if (selfheat)
{
*(here->B3SOITemptempPtr + 1) += m * xcTt;
*(here->B3SOIDPtempPtr + 1) += m * xcdT;
*(here->B3SOISPtempPtr + 1) += m * xcsT;
*(here->B3SOIBtempPtr + 1) += m * xcbT;
*(here->B3SOIEtempPtr + 1) += m * xceT;
*(here->B3SOIGtempPtr + 1) += m * xcgT;
}
/* v3.0 */
if (model->B3SOIsoiMod != 0)
{
*(here->B3SOIDPePtr) += m * (Gme + gddpe);
*(here->B3SOISPePtr) += m * (gsspe - Gme);
}
*(here->B3SOIEePtr) += 0.0;
*(here->B3SOIDPgPtr) += m * (Gm + gddpg);
*(here->B3SOIDPdpPtr) += m * (gdpr + gds + gddpdp + RevSum);
*(here->B3SOIDPspPtr) -= m * (gds + FwdSum - gddpsp);
*(here->B3SOIDPdPtr) -= m * gdpr;
*(here->B3SOISPgPtr) -= m * (Gm - gsspg);
*(here->B3SOISPdpPtr) -= m * (gds + RevSum - gsspdp);
*(here->B3SOISPspPtr) += m * (gspr + gds + FwdSum + gsspsp);
*(here->B3SOISPsPtr) -= m * gspr;
*(here->B3SOIBePtr) += m * gbbe; /* v3.0 */
*(here->B3SOIBgPtr) += m * gbbg;
*(here->B3SOIBdpPtr) += m * gbbdp;
*(here->B3SOIBspPtr) += m * gbbsp;
*(here->B3SOIBbPtr) += m * gbbb;
*(here->B3SOISPbPtr) -= m * (Gmbs - gsspb);
*(here->B3SOIDPbPtr) -= m * (-gddpb - Gmbs);
if (selfheat)
{
*(here->B3SOIDPtempPtr) += m * (GmT + gddpT);
*(here->B3SOISPtempPtr) += m * (-GmT + gsspT);
*(here->B3SOIBtempPtr) += m * gbbT;
*(here->B3SOITemptempPtr) += m * (gTtt + 1/here->pParam->B3SOIrth);
*(here->B3SOITempgPtr) += m * gTtg;
*(here->B3SOITempbPtr) += m * gTtb;
*(here->B3SOITempdpPtr) += m * gTtdp;
*(here->B3SOITempspPtr) += m * gTtsp;
/* v3.0 */
if (model->B3SOIsoiMod != 0)
*(here->B3SOITempePtr) += m * gTte;
}
*(here->B3SOIDdPtr) += m * gdpr;
*(here->B3SOIDdpPtr) -= m * gdpr;
*(here->B3SOISsPtr) += m * gspr;
*(here->B3SOISspPtr) -= m * gspr;
if (here->B3SOIbodyMod == 1) {
(*(here->B3SOIBpPtr) -= m * gppp);
(*(here->B3SOIPbPtr) += m * gppb);
(*(here->B3SOIPpPtr) += m * gppp);
}
if (here->B3SOIdebugMod != 0)
{
*(here->B3SOIVbsPtr) += m * 1;
*(here->B3SOIIdsPtr) += m * 1;
*(here->B3SOIIcPtr) += m * 1;
*(here->B3SOIIbsPtr) += m * 1;
*(here->B3SOIIbdPtr) += m * 1;
*(here->B3SOIIiiPtr) += m * 1;
*(here->B3SOIIgidlPtr) += m * 1;
*(here->B3SOIItunPtr) += m * 1;
*(here->B3SOIIbpPtr) += m * 1;
*(here->B3SOICbgPtr) += m * 1;
*(here->B3SOICbbPtr) += m * 1;
*(here->B3SOICbdPtr) += m * 1;
*(here->B3SOIQbfPtr) += m * 1;
*(here->B3SOIQjsPtr) += m * 1;
*(here->B3SOIQjdPtr) += m * 1;
}
}
}
return(OK);
}

274
src/spicelib/devices/bsim3soi/b3soiask.c
View File

@ -1,274 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiask.c 98/5/01
Modified by Pin Su 99/4/30
Modified by Pin Su 01/2/15
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "ifsim.h"
#include "cktdefs.h"
#include "devdefs.h"
#include "b3soidef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIask(CKTcircuit *ckt, GENinstance *inst, int which, IFvalue *value,
IFvalue *select)
{
B3SOIinstance *here = (B3SOIinstance*)inst;
switch(which)
{ case B3SOI_L:
value->rValue = here->B3SOIl;
return(OK);
case B3SOI_W:
value->rValue = here->B3SOIw;
return(OK);
case B3SOI_AS:
value->rValue = here->B3SOIsourceArea;
return(OK);
case B3SOI_AD:
value->rValue = here->B3SOIdrainArea;
return(OK);
case B3SOI_PS:
value->rValue = here->B3SOIsourcePerimeter;
return(OK);
case B3SOI_PD:
value->rValue = here->B3SOIdrainPerimeter;
return(OK);
case B3SOI_NRS:
value->rValue = here->B3SOIsourceSquares;
return(OK);
case B3SOI_NRD:
value->rValue = here->B3SOIdrainSquares;
return(OK);
case B3SOI_OFF:
value->iValue = here->B3SOIoff;
return(OK);
case B3SOI_BJTOFF:
value->iValue = here->B3SOIbjtoff;
return(OK);
case B3SOI_RTH0:
value->rValue = here->B3SOIrth0;
value->rValue /= here->B3SOIm;
return(OK);
case B3SOI_CTH0:
value->rValue = here->B3SOIcth0;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_NRB:
value->rValue = here->B3SOIbodySquares;
return(OK);
case B3SOI_FRBODY:
value->rValue = here->B3SOIfrbody;
/* Need to scale by m ? */
return(OK);
/* v2.0 release */
case B3SOI_NBC:
value->rValue = here->B3SOInbc;
return(OK);
case B3SOI_NSEG:
value->rValue = here->B3SOInseg;
return(OK);
case B3SOI_PDBCP:
value->rValue = here->B3SOIpdbcp;
return(OK);
case B3SOI_PSBCP:
value->rValue = here->B3SOIpsbcp;
return(OK);
case B3SOI_AGBCP:
value->rValue = here->B3SOIagbcp;
return(OK);
case B3SOI_AEBCP:
value->rValue = here->B3SOIaebcp;
return(OK);
case B3SOI_VBSUSR:
value->rValue = here->B3SOIvbsusr;
return(OK);
case B3SOI_TNODEOUT:
value->iValue = here->B3SOItnodeout;
return(OK);
case B3SOI_IC_VBS:
value->rValue = here->B3SOIicVBS;
return(OK);
case B3SOI_IC_VDS:
value->rValue = here->B3SOIicVDS;
return(OK);
case B3SOI_IC_VGS:
value->rValue = here->B3SOIicVGS;
return(OK);
case B3SOI_IC_VES:
value->rValue = here->B3SOIicVES;
return(OK);
case B3SOI_IC_VPS:
value->rValue = here->B3SOIicVPS;
return(OK);
case B3SOI_DNODE:
value->iValue = here->B3SOIdNode;
return(OK);
case B3SOI_GNODE:
value->iValue = here->B3SOIgNode;
return(OK);
case B3SOI_SNODE:
value->iValue = here->B3SOIsNode;
return(OK);
case B3SOI_BNODE:
value->iValue = here->B3SOIbNode;
return(OK);
case B3SOI_ENODE:
value->iValue = here->B3SOIeNode;
return(OK);
case B3SOI_DNODEPRIME:
value->iValue = here->B3SOIdNodePrime;
return(OK);
case B3SOI_SNODEPRIME:
value->iValue = here->B3SOIsNodePrime;
return(OK);
case B3SOI_SOURCECONDUCT:
value->rValue = here->B3SOIsourceConductance;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_DRAINCONDUCT:
value->rValue = here->B3SOIdrainConductance;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_VBD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIvbd);
return(OK);
case B3SOI_VBS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIvbs);
return(OK);
case B3SOI_VGS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIvgs);
return(OK);
case B3SOI_VES:
value->rValue = *(ckt->CKTstate0 + here->B3SOIves);
return(OK);
case B3SOI_VDS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIvds);
return(OK);
case B3SOI_CD:
value->rValue = here->B3SOIcd;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CBS:
value->rValue = here->B3SOIcjs;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CBD:
value->rValue = here->B3SOIcjd;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_GM:
value->rValue = here->B3SOIgm;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_GMID:
value->rValue = here->B3SOIgm / here->B3SOIcd;
/* It's a ratio no need to scale */
return(OK);
case B3SOI_GDS:
value->rValue = here->B3SOIgds;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_GMBS:
value->rValue = here->B3SOIgmbs;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_GBD:
value->rValue = here->B3SOIgjdb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_GBS:
value->rValue = here->B3SOIgjsb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_QB:
value->rValue = *(ckt->CKTstate0 + here->B3SOIqb);
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CQB:
value->rValue = *(ckt->CKTstate0 + here->B3SOIcqb);
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_QG:
value->rValue = *(ckt->CKTstate0 + here->B3SOIqg);
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CQG:
value->rValue = *(ckt->CKTstate0 + here->B3SOIcqg);
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_QD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIqd);
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CQD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIcqd);
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CGG:
value->rValue = here->B3SOIcggb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CGD:
value->rValue = here->B3SOIcgdb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CGS:
value->rValue = here->B3SOIcgsb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CDG:
value->rValue = here->B3SOIcdgb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CDD:
value->rValue = here->B3SOIcddb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CDS:
value->rValue = here->B3SOIcdsb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CBG:
value->rValue = here->B3SOIcbgb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CBDB:
value->rValue = here->B3SOIcbdb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_CBSB:
value->rValue = here->B3SOIcbsb;
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_VON:
value->rValue = here->B3SOIvon;
return(OK);
case B3SOI_VDSAT:
value->rValue = here->B3SOIvdsat;
return(OK);
case B3SOI_QBS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIqbs);
value->rValue *= here->B3SOIm;
return(OK);
case B3SOI_QBD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIqbd);
value->rValue *= here->B3SOIm;
return(OK);
default:
return(E_BADPARM);
}
/* NOTREACHED */
}

769
src/spicelib/devices/bsim3soi/b3soicheck.c
View File

@ -1,769 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soicheck.c 98/5/01
Modified by Pin Su and Jan Feng 99/2/15
Modified by Pin Su 99/4/30
Modified by Pin Su 00/3/1
Modified by Pin Su and Hui Wan 02/3/5
Modified by Pin Su 02/5/20
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "b3soidef.h"
#include "trandefs.h"
#include "const.h"
#include "sperror.h"
#include "devdefs.h"
#include "suffix.h"
int
B3SOIcheckModel(B3SOImodel *model, B3SOIinstance *here, CKTcircuit *ckt)
{
struct b3soiSizeDependParam *pParam;
int Fatal_Flag = 0;
FILE *fplog;
if ((fplog = fopen("b3soiV3check.log", "w")) != NULL)
{ pParam = here->pParam;
fprintf(fplog, "B3SOIV3 Parameter Check\n");
fprintf(fplog, "Model = %s\n", model->B3SOImodName);
fprintf(fplog, "W = %g, L = %g\n", here->B3SOIw, here->B3SOIl);
if (pParam->B3SOInlx < -pParam->B3SOIleff)
{ fprintf(fplog, "Fatal: Nlx = %g is less than -Leff.\n",
pParam->B3SOInlx);
printf("Fatal: Nlx = %g is less than -Leff.\n",
pParam->B3SOInlx);
Fatal_Flag = 1;
}
if (model->B3SOItox <= 0.0)
{ fprintf(fplog, "Fatal: Tox = %g is not positive.\n",
model->B3SOItox);
printf("Fatal: Tox = %g is not positive.\n", model->B3SOItox);
Fatal_Flag = 1;
}
/* v2.2.3 */
if (model->B3SOItox - model->B3SOIdtoxcv <= 0.0)
{ fprintf(fplog, "Fatal: Tox - dtoxcv = %g is not positive.\n",
model->B3SOItox - model->B3SOIdtoxcv);
printf("Fatal: Tox - dtoxcv = %g is not positive.\n", model->B3SOItox - model->B3SOIdtoxcv);
Fatal_Flag = 1;
}
if (model->B3SOItbox <= 0.0)
{ fprintf(fplog, "Fatal: Tbox = %g is not positive.\n",
model->B3SOItbox);
printf("Fatal: Tbox = %g is not positive.\n", model->B3SOItbox);
Fatal_Flag = 1;
}
if (pParam->B3SOInpeak <= 0.0)
{ fprintf(fplog, "Fatal: Nch = %g is not positive.\n",
pParam->B3SOInpeak);
printf("Fatal: Nch = %g is not positive.\n",
pParam->B3SOInpeak);
Fatal_Flag = 1;
}
if (pParam->B3SOIngate < 0.0)
{ fprintf(fplog, "Fatal: Ngate = %g is not positive.\n",
pParam->B3SOIngate);
printf("Fatal: Ngate = %g Ngate is not positive.\n",
pParam->B3SOIngate);
Fatal_Flag = 1;
}
if (pParam->B3SOIngate > 1.e25)
{ fprintf(fplog, "Fatal: Ngate = %g is too high.\n",
pParam->B3SOIngate);
printf("Fatal: Ngate = %g Ngate is too high\n",
pParam->B3SOIngate);
Fatal_Flag = 1;
}
if (pParam->B3SOIdvt1 < 0.0)
{ fprintf(fplog, "Fatal: Dvt1 = %g is negative.\n",
pParam->B3SOIdvt1);
printf("Fatal: Dvt1 = %g is negative.\n", pParam->B3SOIdvt1);
Fatal_Flag = 1;
}
if (pParam->B3SOIdvt1w < 0.0)
{ fprintf(fplog, "Fatal: Dvt1w = %g is negative.\n",
pParam->B3SOIdvt1w);
printf("Fatal: Dvt1w = %g is negative.\n", pParam->B3SOIdvt1w);
Fatal_Flag = 1;
}
if (pParam->B3SOIw0 == -pParam->B3SOIweff)
{ fprintf(fplog, "Fatal: (W0 + Weff) = 0 cauing divided-by-zero.\n");
printf("Fatal: (W0 + Weff) = 0 cauing divided-by-zero.\n");
Fatal_Flag = 1;
}
if (pParam->B3SOIdsub < 0.0)
{ fprintf(fplog, "Fatal: Dsub = %g is negative.\n", pParam->B3SOIdsub);
printf("Fatal: Dsub = %g is negative.\n", pParam->B3SOIdsub);
Fatal_Flag = 1;
}
if (pParam->B3SOIb1 == -pParam->B3SOIweff)
{ fprintf(fplog, "Fatal: (B1 + Weff) = 0 causing divided-by-zero.\n");
printf("Fatal: (B1 + Weff) = 0 causing divided-by-zero.\n");
Fatal_Flag = 1;
}
if (pParam->B3SOIu0temp <= 0.0)
{ fprintf(fplog, "Fatal: u0 at current temperature = %g is not positive.\n", pParam->B3SOIu0temp);
printf("Fatal: u0 at current temperature = %g is not positive.\n",
pParam->B3SOIu0temp);
Fatal_Flag = 1;
}
/* Check delta parameter */
if (pParam->B3SOIdelta < 0.0)
{ fprintf(fplog, "Fatal: Delta = %g is less than zero.\n",
pParam->B3SOIdelta);
printf("Fatal: Delta = %g is less than zero.\n", pParam->B3SOIdelta);
Fatal_Flag = 1;
}
if (pParam->B3SOIvsattemp <= 0.0)
{ fprintf(fplog, "Fatal: Vsat at current temperature = %g is not positive.\n", pParam->B3SOIvsattemp);
printf("Fatal: Vsat at current temperature = %g is not positive.\n",
pParam->B3SOIvsattemp);
Fatal_Flag = 1;
}
/* Check Rout parameters */
if (pParam->B3SOIpclm <= 0.0)
{ fprintf(fplog, "Fatal: Pclm = %g is not positive.\n", pParam->B3SOIpclm);
printf("Fatal: Pclm = %g is not positive.\n", pParam->B3SOIpclm);
Fatal_Flag = 1;
}
if (pParam->B3SOIdrout < 0.0)
{ fprintf(fplog, "Fatal: Drout = %g is negative.\n", pParam->B3SOIdrout);
printf("Fatal: Drout = %g is negative.\n", pParam->B3SOIdrout);
Fatal_Flag = 1;
}
if ( model->B3SOIunitLengthGateSidewallJctCap > 0.0)
{
if (here->B3SOIdrainPerimeter < pParam->B3SOIweff)
{ fprintf(fplog, "Warning: Pd = %g is less than W.\n",
here->B3SOIdrainPerimeter);
printf("Warning: Pd = %g is less than W.\n",
here->B3SOIdrainPerimeter);
here->B3SOIdrainPerimeter =pParam->B3SOIweff;
}
if (here->B3SOIsourcePerimeter < pParam->B3SOIweff)
{ fprintf(fplog, "Warning: Ps = %g is less than W.\n",
here->B3SOIsourcePerimeter);
printf("Warning: Ps = %g is less than W.\n",
here->B3SOIsourcePerimeter);
here->B3SOIsourcePerimeter =pParam->B3SOIweff;
}
}
/* Check capacitance parameters */
if (pParam->B3SOIclc < 0.0)
{ fprintf(fplog, "Fatal: Clc = %g is negative.\n", pParam->B3SOIclc);
printf("Fatal: Clc = %g is negative.\n", pParam->B3SOIclc);
Fatal_Flag = 1;
}
/* v2.2.3 */
if (pParam->B3SOImoin < 5.0)
{ fprintf(fplog, "Warning: Moin = %g is too small.\n",
pParam->B3SOImoin);
printf("Warning: Moin = %g is too small.\n", pParam->B3SOImoin);
}
if (pParam->B3SOImoin > 25.0)
{ fprintf(fplog, "Warning: Moin = %g is too large.\n",
pParam->B3SOImoin);
printf("Warning: Moin = %g is too large.\n", pParam->B3SOImoin);
}
/* v3.0 */
if (model->B3SOImoinFD < 5.0)
{ fprintf(fplog, "Warning: MoinFD = %g is too small.\n",
model->B3SOImoinFD);
printf("Warning: MoinFD = %g is too small.\n", model->B3SOImoinFD);
}
if (model->B3SOIcapMod == 3) {
if (pParam->B3SOIacde < 0.4)
{ fprintf (fplog, "Warning: Acde = %g is too small.\n",
pParam->B3SOIacde);
printf ("Warning: Acde = %g is too small.\n",
pParam->B3SOIacde);
}
if (pParam->B3SOIacde > 1.6)
{ fprintf (fplog, "Warning: Acde = %g is too large.\n",
pParam->B3SOIacde);
printf ("Warning: Acde = %g is too large.\n",
pParam->B3SOIacde);
}
}
/* v2.2.3 */
if (model->B3SOIparamChk ==1)
{
/* Check L and W parameters */
if (pParam->B3SOIleff <= 5.0e-8)
{ fprintf(fplog, "Warning: Leff = %g may be too small.\n",
pParam->B3SOIleff);
printf("Warning: Leff = %g may be too small.\n",
pParam->B3SOIleff);
}
if (pParam->B3SOIleffCV <= 5.0e-8)
{ fprintf(fplog, "Warning: Leff for CV = %g may be too small.\n",
pParam->B3SOIleffCV);
printf("Warning: Leff for CV = %g may be too small.\n",
pParam->B3SOIleffCV);
}
if (pParam->B3SOIweff <= 1.0e-7)
{ fprintf(fplog, "Warning: Weff = %g may be too small.\n",
pParam->B3SOIweff);
printf("Warning: Weff = %g may be too small.\n",
pParam->B3SOIweff);
}
if (pParam->B3SOIweffCV <= 1.0e-7)
{ fprintf(fplog, "Warning: Weff for CV = %g may be too small.\n",
pParam->B3SOIweffCV);
printf("Warning: Weff for CV = %g may be too small.\n",
pParam->B3SOIweffCV);
}
/* Check threshold voltage parameters */
if (pParam->B3SOInlx < 0.0)
{ fprintf(fplog, "Warning: Nlx = %g is negative.\n", pParam->B3SOInlx);
printf("Warning: Nlx = %g is negative.\n", pParam->B3SOInlx);
}
if (model->B3SOItox < 1.0e-9)
{ fprintf(fplog, "Warning: Tox = %g is less than 10A.\n",
model->B3SOItox);
printf("Warning: Tox = %g is less than 10A.\n", model->B3SOItox);
}
if (pParam->B3SOInpeak <= 1.0e15)
{ fprintf(fplog, "Warning: Nch = %g may be too small.\n",
pParam->B3SOInpeak);
printf("Warning: Nch = %g may be too small.\n",
pParam->B3SOInpeak);
}
else if (pParam->B3SOInpeak >= 1.0e21)
{ fprintf(fplog, "Warning: Nch = %g may be too large.\n",
pParam->B3SOInpeak);
printf("Warning: Nch = %g may be too large.\n",
pParam->B3SOInpeak);
}
if (fabs(pParam->B3SOInsub) >= 1.0e21)
{ fprintf(fplog, "Warning: Nsub = %g may be too large.\n",
pParam->B3SOInsub);
printf("Warning: Nsub = %g may be too large.\n",
pParam->B3SOInsub);
}
if ((pParam->B3SOIngate > 0.0) &&
(pParam->B3SOIngate <= 1.e18))
{ fprintf(fplog, "Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->B3SOIngate);
printf("Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->B3SOIngate);
}
if (pParam->B3SOIdvt0 < 0.0)
{ fprintf(fplog, "Warning: Dvt0 = %g is negative.\n",
pParam->B3SOIdvt0);
printf("Warning: Dvt0 = %g is negative.\n", pParam->B3SOIdvt0);
}
if (fabs(1.0e-6 / (pParam->B3SOIw0 + pParam->B3SOIweff)) > 10.0)
{ fprintf(fplog, "Warning: (W0 + Weff) may be too small.\n");
printf("Warning: (W0 + Weff) may be too small.\n");
}
/* Check subthreshold parameters */
if (pParam->B3SOInfactor < 0.0)
{ fprintf(fplog, "Warning: Nfactor = %g is negative.\n",
pParam->B3SOInfactor);
printf("Warning: Nfactor = %g is negative.\n", pParam->B3SOInfactor);
}
if (pParam->B3SOIcdsc < 0.0)
{ fprintf(fplog, "Warning: Cdsc = %g is negative.\n",
pParam->B3SOIcdsc);
printf("Warning: Cdsc = %g is negative.\n", pParam->B3SOIcdsc);
}
if (pParam->B3SOIcdscd < 0.0)
{ fprintf(fplog, "Warning: Cdscd = %g is negative.\n",
pParam->B3SOIcdscd);
printf("Warning: Cdscd = %g is negative.\n", pParam->B3SOIcdscd);
}
/* Check DIBL parameters */
if (pParam->B3SOIeta0 < 0.0)
{ fprintf(fplog, "Warning: Eta0 = %g is negative.\n",
pParam->B3SOIeta0);
printf("Warning: Eta0 = %g is negative.\n", pParam->B3SOIeta0);
}
/* Check Abulk parameters */
if (fabs(1.0e-6 / (pParam->B3SOIb1 + pParam->B3SOIweff)) > 10.0)
{ fprintf(fplog, "Warning: (B1 + Weff) may be too small.\n");
printf("Warning: (B1 + Weff) may be too small.\n");
}
/* Check Saturation parameters */
if (pParam->B3SOIa2 < 0.01)
{ fprintf(fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", pParam->B3SOIa2);
printf("Warning: A2 = %g is too small. Set to 0.01.\n",
pParam->B3SOIa2);
pParam->B3SOIa2 = 0.01;
}
else if (pParam->B3SOIa2 > 1.0)
{ fprintf(fplog, "Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->B3SOIa2);
printf("Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->B3SOIa2);
pParam->B3SOIa2 = 1.0;
pParam->B3SOIa1 = 0.0;
}
if (pParam->B3SOIrdsw < 0.0)
{ fprintf(fplog, "Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->B3SOIrdsw);
printf("Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->B3SOIrdsw);
pParam->B3SOIrdsw = 0.0;
pParam->B3SOIrds0 = 0.0;
}
else if ((pParam->B3SOIrds0 > 0.0) && (pParam->B3SOIrds0 < 0.001))
{ fprintf(fplog, "Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n",
pParam->B3SOIrds0);
printf("Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n",
pParam->B3SOIrds0);
pParam->B3SOIrds0 = 0.0;
}
if (pParam->B3SOIvsattemp < 1.0e3)
{ fprintf(fplog, "Warning: Vsat at current temperature = %g may be too small.\n", pParam->B3SOIvsattemp);
printf("Warning: Vsat at current temperature = %g may be too small.\n", pParam->B3SOIvsattemp);
}
if (pParam->B3SOIpdibl1 < 0.0)
{ fprintf(fplog, "Warning: Pdibl1 = %g is negative.\n",
pParam->B3SOIpdibl1);
printf("Warning: Pdibl1 = %g is negative.\n", pParam->B3SOIpdibl1);
}
if (pParam->B3SOIpdibl2 < 0.0)
{ fprintf(fplog, "Warning: Pdibl2 = %g is negative.\n",
pParam->B3SOIpdibl2);
printf("Warning: Pdibl2 = %g is negative.\n", pParam->B3SOIpdibl2);
}
/* Check overlap capacitance parameters */
if (model->B3SOIcgdo < 0.0)
{ fprintf(fplog, "Warning: cgdo = %g is negative. Set to zero.\n", model->B3SOIcgdo);
printf("Warning: cgdo = %g is negative. Set to zero.\n", model->B3SOIcgdo);
model->B3SOIcgdo = 0.0;
}
if (model->B3SOIcgso < 0.0)
{ fprintf(fplog, "Warning: cgso = %g is negative. Set to zero.\n", model->B3SOIcgso);
printf("Warning: cgso = %g is negative. Set to zero.\n", model->B3SOIcgso);
model->B3SOIcgso = 0.0;
}
if (model->B3SOIcgeo < 0.0)
{ fprintf(fplog, "Warning: cgeo = %g is negative. Set to zero.\n", model->B3SOIcgeo);
printf("Warning: cgeo = %g is negative. Set to zero.\n", model->B3SOIcgeo);
model->B3SOIcgeo = 0.0;
}
if (model->B3SOIntun < 0.0)
{ fprintf(fplog, "Warning: Ntun = %g is negative.\n",
model->B3SOIntun);
printf("Warning: Ntun = %g is negative.\n", model->B3SOIntun);
}
if (model->B3SOIndiode < 0.0)
{ fprintf(fplog, "Warning: Ndiode = %g is negative.\n",
model->B3SOIndiode);
printf("Warning: Ndiode = %g is negative.\n", model->B3SOIndiode);
}
if (model->B3SOIisbjt < 0.0)
{ fprintf(fplog, "Warning: Isbjt = %g is negative.\n",
model->B3SOIisbjt);
printf("Warning: Isbjt = %g is negative.\n", model->B3SOIisbjt);
}
if (model->B3SOIisdif < 0.0)
{ fprintf(fplog, "Warning: Isdif = %g is negative.\n",
model->B3SOIisdif);
printf("Warning: Isdif = %g is negative.\n", model->B3SOIisdif);
}
if (model->B3SOIisrec < 0.0)
{ fprintf(fplog, "Warning: Isrec = %g is negative.\n",
model->B3SOIisrec);
printf("Warning: Isrec = %g is negative.\n", model->B3SOIisrec);
}
if (model->B3SOIistun < 0.0)
{ fprintf(fplog, "Warning: Istun = %g is negative.\n",
model->B3SOIistun);
printf("Warning: Istun = %g is negative.\n", model->B3SOIistun);
}
if (model->B3SOItt < 0.0)
{ fprintf(fplog, "Warning: Tt = %g is negative.\n",
model->B3SOItt);
printf("Warning: Tt = %g is negative.\n", model->B3SOItt);
}
if (model->B3SOIcsdmin < 0.0)
{ fprintf(fplog, "Warning: Csdmin = %g is negative.\n",
model->B3SOIcsdmin);
printf("Warning: Csdmin = %g is negative.\n", model->B3SOIcsdmin);
}
if (model->B3SOIcsdesw < 0.0)
{ fprintf(fplog, "Warning: Csdesw = %g is negative.\n",
model->B3SOIcsdesw);
printf("Warning: Csdesw = %g is negative.\n", model->B3SOIcsdesw);
}
if (model->B3SOIasd < 0.0)
{ fprintf(fplog, "Warning: Asd = %g should be within (0, 1).\n",
model->B3SOIasd);
printf("Warning: Asd = %g should be within (0, 1).\n", model->B3SOIasd);
}
if (model->B3SOIrth0 < 0.0)
{ fprintf(fplog, "Warning: Rth0 = %g is negative.\n",
model->B3SOIrth0);
printf("Warning: Rth0 = %g is negative.\n", model->B3SOIrth0);
}
if (model->B3SOIcth0 < 0.0)
{ fprintf(fplog, "Warning: Cth0 = %g is negative.\n",
model->B3SOIcth0);
printf("Warning: Cth0 = %g is negative.\n", model->B3SOIcth0);
}
if (model->B3SOIrbody < 0.0)
{ fprintf(fplog, "Warning: Rbody = %g is negative.\n",
model->B3SOIrbody);
printf("Warning: Rbody = %g is negative.\n", model->B3SOIrbody);
}
if (model->B3SOIrbsh < 0.0)
{ fprintf(fplog, "Warning: Rbsh = %g is negative.\n",
model->B3SOIrbsh);
printf("Warning: Rbsh = %g is negative.\n", model->B3SOIrbsh);
}
/* v3.0 */
if (pParam->B3SOInigc <= 0.0)
{ fprintf(fplog, "Fatal: nigc = %g is non-positive.\n",
pParam->B3SOInigc);
printf("Fatal: nigc = %g is non-positive.\n", pParam->B3SOInigc);
Fatal_Flag = 1;
}
if (pParam->B3SOIpoxedge <= 0.0)
{ fprintf(fplog, "Fatal: poxedge = %g is non-positive.\n",
pParam->B3SOIpoxedge);
printf("Fatal: poxedge = %g is non-positive.\n", pParam->B3SOIpoxedge);
Fatal_Flag = 1;
}
if (pParam->B3SOIpigcd <= 0.0)
{ fprintf(fplog, "Fatal: pigcd = %g is non-positive.\n",
pParam->B3SOIpigcd);
printf("Fatal: pigcd = %g is non-positive.\n", pParam->B3SOIpigcd);
Fatal_Flag = 1;
}
/* v2.2 release */
if (model->B3SOIwth0 < 0.0)
{ fprintf(fplog, "Warning: WTH0 = %g is negative.\n",
model->B3SOIwth0);
printf("Warning: Wth0 = %g is negative.\n", model->B3SOIwth0);
}
if (model->B3SOIrhalo < 0.0)
{ fprintf(fplog, "Warning: RHALO = %g is negative.\n",
model->B3SOIrhalo);
printf("Warning: Rhalo = %g is negative.\n", model->B3SOIrhalo);
}
if (model->B3SOIntox < 0.0)
{ fprintf(fplog, "Warning: NTOX = %g is negative.\n",
model->B3SOIntox);
printf("Warning: Ntox = %g is negative.\n", model->B3SOIntox);
}
if (model->B3SOItoxref < 0.0)
{ fprintf(fplog, "Warning: TOXREF = %g is negative.\n",
model->B3SOItoxref);
printf("Warning: Toxref = %g is negative.\n", model->B3SOItoxref);
Fatal_Flag = 1;
}
if (model->B3SOIebg < 0.0)
{ fprintf(fplog, "Warning: EBG = %g is negative.\n",
model->B3SOIebg);
printf("Warning: Ebg = %g is negative.\n", model->B3SOIebg);
}
if (model->B3SOIvevb < 0.0)
{ fprintf(fplog, "Warning: VEVB = %g is negative.\n",
model->B3SOIvevb);
printf("Warning: Vevb = %g is negative.\n", model->B3SOIvevb);
}
if (model->B3SOIalphaGB1 < 0.0)
{ fprintf(fplog, "Warning: ALPHAGB1 = %g is negative.\n",
model->B3SOIalphaGB1);
printf("Warning: AlphaGB1 = %g is negative.\n", model->B3SOIalphaGB1);
}
if (model->B3SOIbetaGB1 < 0.0)
{ fprintf(fplog, "Warning: BETAGB1 = %g is negative.\n",
model->B3SOIbetaGB1);
printf("Warning: BetaGB1 = %g is negative.\n", model->B3SOIbetaGB1);
}
if (model->B3SOIvgb1 < 0.0)
{ fprintf(fplog, "Warning: VGB1 = %g is negative.\n",
model->B3SOIvgb1);
printf("Warning: Vgb1 = %g is negative.\n", model->B3SOIvgb1);
}
if (model->B3SOIvecb < 0.0)
{ fprintf(fplog, "Warning: VECB = %g is negative.\n",
model->B3SOIvecb);
printf("Warning: Vecb = %g is negative.\n", model->B3SOIvecb);
}
if (model->B3SOIalphaGB2 < 0.0)
{ fprintf(fplog, "Warning: ALPHAGB2 = %g is negative.\n",
model->B3SOIalphaGB2);
printf("Warning: AlphaGB2 = %g is negative.\n", model->B3SOIalphaGB2);
}
if (model->B3SOIbetaGB2 < 0.0)
{ fprintf(fplog, "Warning: BETAGB2 = %g is negative.\n",
model->B3SOIbetaGB2);
printf("Warning: BetaGB2 = %g is negative.\n", model->B3SOIbetaGB2);
}
if (model->B3SOIvgb2 < 0.0)
{ fprintf(fplog, "Warning: VGB2 = %g is negative.\n",
model->B3SOIvgb2);
printf("Warning: Vgb2 = %g is negative.\n", model->B3SOIvgb2);
}
if (model->B3SOItoxqm <= 0.0)
{ fprintf(fplog, "Fatal: Toxqm = %g is not positive.\n",
model->B3SOItoxqm);
printf("Fatal: Toxqm = %g is not positive.\n", model->B3SOItoxqm);
Fatal_Flag = 1;
}
if (model->B3SOIvoxh < 0.0)
{ fprintf(fplog, "Warning: Voxh = %g is negative.\n",
model->B3SOIvoxh);
printf("Warning: Voxh = %g is negative.\n", model->B3SOIvoxh);
}
if (model->B3SOIdeltavox <= 0.0)
{ fprintf(fplog, "Fatal: Deltavox = %g is not positive.\n",
model->B3SOIdeltavox);
printf("Fatal: Deltavox = %g is not positive.\n", model->B3SOIdeltavox);
}
/* v2.0 release */
if (model->B3SOIk1w1 < 0.0)
{ fprintf(fplog, "Warning: K1W1 = %g is negative.\n",
model->B3SOIk1w1);
printf("Warning: K1w1 = %g is negative.\n", model->B3SOIk1w1);
}
if (model->B3SOIk1w2 < 0.0)
{ fprintf(fplog, "Warning: K1W2 = %g is negative.\n",
model->B3SOIk1w2);
printf("Warning: K1w2 = %g is negative.\n", model->B3SOIk1w2);
}
if (model->B3SOIketas < 0.0)
{ fprintf(fplog, "Warning: KETAS = %g is negative.\n",
model->B3SOIketas);
printf("Warning: Ketas = %g is negative.\n", model->B3SOIketas);
}
if (model->B3SOIdwbc < 0.0)
{ fprintf(fplog, "Warning: DWBC = %g is negative.\n",
model->B3SOIdwbc);
printf("Warning: Dwbc = %g is negative.\n", model->B3SOIdwbc);
}
if (model->B3SOIbeta0 < 0.0)
{ fprintf(fplog, "Warning: BETA0 = %g is negative.\n",
model->B3SOIbeta0);
printf("Warning: Beta0 = %g is negative.\n", model->B3SOIbeta0);
}
if (model->B3SOIbeta1 < 0.0)
{ fprintf(fplog, "Warning: BETA1 = %g is negative.\n",
model->B3SOIbeta1);
printf("Warning: Beta1 = %g is negative.\n", model->B3SOIbeta1);
}
if (model->B3SOIbeta2 < 0.0)
{ fprintf(fplog, "Warning: BETA2 = %g is negative.\n",
model->B3SOIbeta2);
printf("Warning: Beta2 = %g is negative.\n", model->B3SOIbeta2);
}
if (model->B3SOItii < 0.0)
{ fprintf(fplog, "Warning: TII = %g is negative.\n",
model->B3SOItii);
printf("Warning: Tii = %g is negative.\n", model->B3SOItii);
}
if (model->B3SOIlii < 0.0)
{ fprintf(fplog, "Warning: LII = %g is negative.\n",
model->B3SOIlii);
printf("Warning: Lii = %g is negative.\n", model->B3SOIlii);
}
if (model->B3SOIsii1 < 0.0)
{ fprintf(fplog, "Warning: SII1 = %g is negative.\n",
model->B3SOIsii1);
printf("Warning: Sii1 = %g is negative.\n", model->B3SOIsii1);
}
if (model->B3SOIsii2 < 0.0)
{ fprintf(fplog, "Warning: SII2 = %g is negative.\n",
model->B3SOIsii2);
printf("Warning: Sii2 = %g is negative.\n", model->B3SOIsii1);
}
if (model->B3SOIsiid < 0.0)
{ fprintf(fplog, "Warning: SIID = %g is negative.\n",
model->B3SOIsiid);
printf("Warning: Siid = %g is negative.\n", model->B3SOIsiid);
}
if (model->B3SOIfbjtii < 0.0)
{ fprintf(fplog, "Warning: FBJTII = %g is negative.\n",
model->B3SOIfbjtii);
printf("Warning: fbjtii = %g is negative.\n", model->B3SOIfbjtii);
}
if (model->B3SOIvrec0 < 0.0)
{ fprintf(fplog, "Warning: VREC0 = %g is negative.\n",
model->B3SOIvrec0);
printf("Warning: Vrec0 = %g is negative.\n", model->B3SOIvrec0);
}
if (model->B3SOIvtun0 < 0.0)
{ fprintf(fplog, "Warning: VTUN0 = %g is negative.\n",
model->B3SOIvtun0);
printf("Warning: Vtun0 = %g is negative.\n", model->B3SOIvtun0);
}
if (model->B3SOInbjt < 0.0)
{ fprintf(fplog, "Warning: NBJT = %g is negative.\n",
model->B3SOInbjt);
printf("Warning: Nbjt = %g is negative.\n", model->B3SOInbjt);
}
if (model->B3SOIaely < 0.0)
{ fprintf(fplog, "Warning: AELY = %g is negative.\n",
model->B3SOIaely);
printf("Warning: Aely = %g is negative.\n", model->B3SOIaely);
}
if (model->B3SOIahli < 0.0)
{ fprintf(fplog, "Warning: AHLI = %g is negative.\n",
model->B3SOIahli);
printf("Warning: Ahli = %g is negative.\n", model->B3SOIahli);
}
if (model->B3SOIrbody < 0.0)
{ fprintf(fplog, "Warning: RBODY = %g is negative.\n",
model->B3SOIrbody);
printf("Warning: Rbody = %g is negative.\n", model->B3SOIrbody);
}
if (model->B3SOIrbsh < 0.0)
{ fprintf(fplog, "Warning: RBSH = %g is negative.\n",
model->B3SOIrbsh);
printf("Warning: Rbsh = %g is negative.\n", model->B3SOIrbsh);
}
if (model->B3SOIntrecf < 0.0)
{ fprintf(fplog, "Warning: NTRECF = %g is negative.\n",
model->B3SOIntrecf);
printf("Warning: Ntrecf = %g is negative.\n", model->B3SOIntrecf);
}
if (model->B3SOIntrecr < 0.0)
{ fprintf(fplog, "Warning: NTRECR = %g is negative.\n",
model->B3SOIntrecr);
printf("Warning: Ntrecr = %g is negative.\n", model->B3SOIntrecr);
}
/* v3.0 bug fix */
/*
if (model->B3SOIndif < 0.0)
{ fprintf(fplog, "Warning: NDIF = %g is negative.\n",
model->B3SOIndif);
printf("Warning: Ndif = %g is negative.\n", model->B3SOIndif);
}
*/
if (model->B3SOItcjswg < 0.0)
{ fprintf(fplog, "Warning: TCJSWG = %g is negative.\n",
model->B3SOItcjswg);
printf("Warning: Tcjswg = %g is negative.\n", model->B3SOItcjswg);
}
if (model->B3SOItpbswg < 0.0)
{ fprintf(fplog, "Warning: TPBSWG = %g is negative.\n",
model->B3SOItpbswg);
printf("Warning: Tpbswg = %g is negative.\n", model->B3SOItpbswg);
}
if ((model->B3SOIacde < 0.4) || (model->B3SOIacde > 1.6))
{ fprintf(fplog, "Warning: ACDE = %g is out of range.\n",
model->B3SOIacde);
printf("Warning: Acde = %g is out of range.\n", model->B3SOIacde);
}
if ((model->B3SOImoin < 5.0)||(model->B3SOImoin > 25.0))
{ fprintf(fplog, "Warning: MOIN = %g is out of range.\n",
model->B3SOImoin);
printf("Warning: Moin = %g is out of range.\n", model->B3SOImoin);
}
if (model->B3SOIdlbg < 0.0)
{ fprintf(fplog, "Warning: DLBG = %g is negative.\n",
model->B3SOIdlbg);
printf("Warning: dlbg = %g is negative.\n", model->B3SOIdlbg);
}
if (model->B3SOIagidl < 0.0)
{ fprintf(fplog, "Warning: AGIDL = %g is negative.\n",
model->B3SOIagidl);
printf("Warning: Agidl = %g is negative.\n", model->B3SOIagidl);
}
if (model->B3SOIbgidl < 0.0)
{ fprintf(fplog, "Warning: BGIDL = %g is negative.\n",
model->B3SOIbgidl);
printf("Warning: Bgidl = %g is negative.\n", model->B3SOIbgidl);
}
if (model->B3SOIngidl < 0.0)
{ fprintf(fplog, "Warning: NGIDL = %g is negative.\n",
model->B3SOIngidl);
printf("Warning: Ngidl = %g is negative.\n", model->B3SOIngidl);
}
if (model->B3SOIesatii < 0.0)
{ fprintf(fplog, "Warning: Esatii = %g should be within positive.\n",
model->B3SOIesatii);
printf("Warning: Esatii = %g should be within (0, 1).\n", model->B3SOIesatii);
}
if (model->B3SOIxj > model->B3SOItsi)
{ fprintf(fplog, "Warning: Xj = %g is thicker than Tsi = %g.\n",
model->B3SOIxj, model->B3SOItsi);
printf("Warning: Xj = %g is thicker than Tsi = %g.\n",
model->B3SOIxj, model->B3SOItsi);
}
if (model->B3SOIcapMod < 2)
{ fprintf(fplog, "Warning: capMod < 2 is not supported by BSIM3SOI.\n");
printf("Warning: Warning: capMod < 2 is not supported by BSIM3SOI.\n");
}
}/* loop for the parameter check for warning messages */
fclose(fplog);
}
else
{ fprintf(stderr, "Warning: Can't open log file. Parameter checking skipped.\n");
}
return(Fatal_Flag);
}

92
src/spicelib/devices/bsim3soi/b3soicvtest.c
View File

@ -1,92 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soicvtest.c 98/5/01
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "b3soidef.h"
#include "trandefs.h"
#include "const.h"
#include "devdefs.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIconvTest(GENmodel *inModel, CKTcircuit *ckt)
{
B3SOImodel *model = (B3SOImodel*)inModel;
B3SOIinstance *here;
double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds;
double cbd, cbhat, cbs, cd, cdhat, tol, vgd, vgdo, vgs;
/* loop through all the B3SOI device models */
for (; model != NULL; model = model->B3SOInextModel)
{ /* loop through all the instances of the model */
for (here = model->B3SOIinstances; here != NULL ;
here=here->B3SOInextInstance)
{
if (here->B3SOIowner != ARCHme)
continue;
vbs = model->B3SOItype
* (*(ckt->CKTrhsOld+here->B3SOIbNode)
- *(ckt->CKTrhsOld+here->B3SOIsNodePrime));
vgs = model->B3SOItype
* (*(ckt->CKTrhsOld+here->B3SOIgNode)
- *(ckt->CKTrhsOld+here->B3SOIsNodePrime));
vds = model->B3SOItype
* (*(ckt->CKTrhsOld+here->B3SOIdNodePrime)
- *(ckt->CKTrhsOld+here->B3SOIsNodePrime));
vbd = vbs - vds;
vgd = vgs - vds;
vgdo = *(ckt->CKTstate0 + here->B3SOIvgs)
- *(ckt->CKTstate0 + here->B3SOIvds);
delvbs = vbs - *(ckt->CKTstate0 + here->B3SOIvbs);
delvbd = vbd - *(ckt->CKTstate0 + here->B3SOIvbd);
delvgs = vgs - *(ckt->CKTstate0 + here->B3SOIvgs);
delvds = vds - *(ckt->CKTstate0 + here->B3SOIvds);
delvgd = vgd-vgdo;
cd = here->B3SOIcd;
if (here->B3SOImode >= 0)
{ cdhat = cd - here->B3SOIgjdb * delvbd
+ here->B3SOIgmbs * delvbs + here->B3SOIgm * delvgs
+ here->B3SOIgds * delvds;
}
else
{ cdhat = cd - (here->B3SOIgjdb - here->B3SOIgmbs) * delvbd
- here->B3SOIgm * delvgd + here->B3SOIgds * delvds;
}
/*
* check convergence
*/
if ((here->B3SOIoff == 0) || (!(ckt->CKTmode & MODEINITFIX)))
{ tol = ckt->CKTreltol * MAX(fabs(cdhat), fabs(cd))
+ ckt->CKTabstol;
if (fabs(cdhat - cd) >= tol)
{ ckt->CKTnoncon++;
return(OK);
}
cbs = here->B3SOIcjs;
cbd = here->B3SOIcjd;
cbhat = cbs + cbd + here->B3SOIgjdb * delvbd
+ here->B3SOIgjsb * delvbs;
tol = ckt->CKTreltol * MAX(fabs(cbhat), fabs(cbs + cbd))
+ ckt->CKTabstol;
if (fabs(cbhat - (cbs + cbd)) > tol)
{ ckt->CKTnoncon++;
return(OK);
}
}
}
}
return(OK);
}

2462
src/spicelib/devices/bsim3soi/b3soidef.h
File diff suppressed because it is too large
View File

38
src/spicelib/devices/bsim3soi/b3soidel.c
View File

@ -1,38 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soidel.c 98/5/01
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "b3soidef.h"
#include "sperror.h"
#include "gendefs.h"
#include "suffix.h"
int
B3SOIdelete(GENmodel *inModel, IFuid name, GENinstance **inInst)
{
B3SOIinstance **fast = (B3SOIinstance**)inInst;
B3SOImodel *model = (B3SOImodel*)inModel;
B3SOIinstance **prev = NULL;
B3SOIinstance *here;
for (; model ; model = model->B3SOInextModel)
{ prev = &(model->B3SOIinstances);
for (here = *prev; here ; here = *prev)
{ if (here->B3SOIname == name || (fast && here==*fast))
{ *prev= here->B3SOInextInstance;
FREE(here);
return(OK);
}
prev = &(here->B3SOInextInstance);
}
}
return(E_NODEV);
}

38
src/spicelib/devices/bsim3soi/b3soidest.c
View File

@ -1,38 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soidest.c 98/5/01
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "b3soidef.h"
#include "suffix.h"
void
B3SOIdestroy(GENmodel **inModel)
{
B3SOImodel **model = (B3SOImodel**)inModel;
B3SOIinstance *here;
B3SOIinstance *prev = NULL;
B3SOImodel *mod = *model;
B3SOImodel *oldmod = NULL;
for (; mod ; mod = mod->B3SOInextModel)
{ if(oldmod) FREE(oldmod);
oldmod = mod;
prev = (B3SOIinstance *)NULL;
for (here = mod->B3SOIinstances; here; here = here->B3SOInextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
}
if(oldmod) FREE(oldmod);
*model = NULL;
return;
}

30
src/spicelib/devices/bsim3soi/b3soiext.h
View File

@ -1,30 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung
File: b3soiext.h
Modified by Paolo Nenzi 2002
**********/
extern int B3SOIacLoad(GENmodel *,CKTcircuit*);
extern int B3SOIask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*);
extern int B3SOIconvTest(GENmodel *,CKTcircuit*);
extern int B3SOIdelete(GENmodel*,IFuid,GENinstance**);
extern void B3SOIdestroy(GENmodel**);
extern int B3SOIgetic(GENmodel*,CKTcircuit*);
extern int B3SOIload(GENmodel*,CKTcircuit*);
extern int B3SOImAsk(CKTcircuit*,GENmodel *,int, IFvalue*);
extern int B3SOImDelete(GENmodel**,IFuid,GENmodel*);
extern int B3SOImParam(int,IFvalue*,GENmodel*);
extern void B3SOImosCap(CKTcircuit*, double, double, double, double,
double, double, double, double, double, double, double,
double, double, double, double, double, double, double*,
double*, double*, double*, double*, double*, double*, double*,
double*, double*, double*, double*, double*, double*, double*,
double*);
extern int B3SOIparam(int,IFvalue*,GENinstance*,IFvalue*);
extern int B3SOIpzLoad(GENmodel*,CKTcircuit*,SPcomplex*);
extern int B3SOIsetup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
extern int B3SOItemp(GENmodel*,CKTcircuit*);
extern int B3SOItrunc(GENmodel*,CKTcircuit*,double*);
extern int B3SOInoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
extern int B3SOIunsetup(GENmodel*,CKTcircuit*);

54
src/spicelib/devices/bsim3soi/b3soigetic.c
View File

@ -1,54 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soigetic.c 98/5/01
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "b3soidef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIgetic(GENmodel *inModel, CKTcircuit *ckt)
{
B3SOImodel *model = (B3SOImodel*)inModel;
B3SOIinstance *here;
for (; model ; model = model->B3SOInextModel)
{ for (here = model->B3SOIinstances; here; here = here->B3SOInextInstance)
{
if (here->B3SOIowner != ARCHme)
continue;
if(!here->B3SOIicVBSGiven)
{ here->B3SOIicVBS = *(ckt->CKTrhs + here->B3SOIbNode)
- *(ckt->CKTrhs + here->B3SOIsNode);
}
if (!here->B3SOIicVDSGiven)
{ here->B3SOIicVDS = *(ckt->CKTrhs + here->B3SOIdNode)
- *(ckt->CKTrhs + here->B3SOIsNode);
}
if (!here->B3SOIicVGSGiven)
{ here->B3SOIicVGS = *(ckt->CKTrhs + here->B3SOIgNode)
- *(ckt->CKTrhs + here->B3SOIsNode);
}
if (!here->B3SOIicVESGiven)
{ here->B3SOIicVES = *(ckt->CKTrhs + here->B3SOIeNode)
- *(ckt->CKTrhs + here->B3SOIsNode);
}
if (!here->B3SOIicVPSGiven)
{ here->B3SOIicVPS = *(ckt->CKTrhs + here->B3SOIpNode)
- *(ckt->CKTrhs + here->B3SOIsNode);
}
}
}
return(OK);
}

83
src/spicelib/devices/bsim3soi/b3soiinit.c
View File

@ -1,83 +0,0 @@
#include "config.h"
#include "devdefs.h"
#include "b3soiitf.h"
#include "b3soiext.h"
#include "b3soiinit.h"
SPICEdev B3SOIinfo = {
{ "B3SOI",
"Berkeley SOI MOSFET model version 3.0",
&B3SOInSize,
&B3SOInSize,
B3SOInames,
&B3SOIpTSize,
B3SOIpTable,
&B3SOImPTSize,
B3SOImPTable,
#ifdef XSPICE
/*---- Fixed by SDB 5.2.2003 to enable XSPICE/tclspice integration -----*/
NULL, /* This is a SPICE device, it has no MIF info data */
0, /* This is a SPICE device, it has no MIF info data */
NULL, /* This is a SPICE device, it has no MIF info data */
0, /* This is a SPICE device, it has no MIF info data */
NULL, /* This is a SPICE device, it has no MIF info data */
0, /* This is a SPICE device, it has no MIF info data */
NULL, /* This is a SPICE device, it has no MIF info data */
/*--------------------------- End of SDB fix -------------------------*/
#endif
DEV_DEFAULT
},
/* DEVparam */ B3SOIparam,
/* DEVmodParam */ B3SOImParam,
/* DEVload */ B3SOIload,
/* DEVsetup */ B3SOIsetup,
/* DEVunsetup */ B3SOIunsetup,
/* DEVpzSetup */ B3SOIsetup,
/* DEVtemperature*/ B3SOItemp,
/* DEVtrunc */ B3SOItrunc,
/* DEVfindBranch */ NULL,
/* DEVacLoad */ B3SOIacLoad,
/* DEVaccept */ NULL,
/* DEVdestroy */ B3SOIdestroy,
/* DEVmodDelete */ B3SOImDelete,
/* DEVdelete */ B3SOIdelete,
/* DEVsetic */ B3SOIgetic,
/* DEVask */ B3SOIask,
/* DEVmodAsk */ B3SOImAsk,
/* DEVpzLoad */ B3SOIpzLoad,
/* DEVconvTest */ B3SOIconvTest,
/* DEVsenSetup */ NULL,
/* DEVsenLoad */ NULL,
/* DEVsenUpdate */ NULL,
/* DEVsenAcLoad */ NULL,
/* DEVsenPrint */ NULL,
/* DEVsenTrunc */ NULL,
/* DEVdisto */ NULL,
/* DEVnoise */ B3SOInoise,
#ifdef CIDER
/* DEVdump */ NULL,
/* DEVacct */ NULL,
#endif
/* DEVinstSize */ &B3SOIiSize,
/* DEVmodSize */ &B3SOImSize
};
SPICEdev *
get_b3soi_info (void)
{
return &B3SOIinfo;
}

13
src/spicelib/devices/bsim3soi/b3soiinit.h
View File

@ -1,13 +0,0 @@
#ifndef _B3SOIINIT_H
#define _B3SOIINIT_H
extern IFparm B3SOIpTable[];
extern IFparm B3SOImPTable[];
extern char *B3SOInames[];
extern int B3SOIpTSize;
extern int B3SOImPTSize;
extern int B3SOInSize;
extern int B3SOIiSize;
extern int B3SOImSize;
#endif

16
src/spicelib/devices/bsim3soi/b3soiitf.h
View File

@ -1,16 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung
File: b3soiitf.h
Modified by Paolo Nenzi 2002
**********/
#ifndef DEV_B3SOI
#define DEV_B3SOI
#include "b3soiext.h"
SPICEdev *get_b3soi_info (void);
#endif

4884
src/spicelib/devices/bsim3soi/b3soild.c
File diff suppressed because it is too large
View File

1630
src/spicelib/devices/bsim3soi/b3soimask.c
File diff suppressed because it is too large
View File

44
src/spicelib/devices/bsim3soi/b3soimdel.c
View File

@ -1,44 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soimdel.c 98/5/01
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "b3soidef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOImDelete(GENmodel **inModel, IFuid modname, GENmodel *kill)
{
B3SOImodel **model = (B3SOImodel**)inModel;
B3SOImodel *modfast = (B3SOImodel*)kill;
B3SOIinstance *here;
B3SOIinstance *prev = NULL;
B3SOImodel **oldmod;
oldmod = model;
for (; *model ; model = &((*model)->B3SOInextModel))
{ if ((*model)->B3SOImodName == modname ||
(modfast && *model == modfast))
goto delgot;
oldmod = model;
}
return(E_NOMOD);
delgot:
*oldmod = (*model)->B3SOInextModel; /* cut deleted device out of list */
for (here = (*model)->B3SOIinstances; here; here = here->B3SOInextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
FREE(*model);
return(OK);
}

2158
src/spicelib/devices/bsim3soi/b3soimpar.c
File diff suppressed because it is too large
View File

400
src/spicelib/devices/bsim3soi/b3soinoi.c
View File

@ -1,400 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soinoi.c 98/5/01
Modified by Hui Wan 02/3/5
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "b3soidef.h"
#include "cktdefs.h"
#include "iferrmsg.h"
#include "noisedef.h"
#include "suffix.h"
#include "const.h" /* jwan */
/*
* B3SOInoise (mode, operation, firstModel, ckt, data, OnDens)
* This routine names and evaluates all of the noise sources
* associated with MOSFET's. It starts with the model *firstModel and
* traverses all of its insts. It then proceeds to any other models
* on the linked list. The total output noise density generated by
* all of the MOSFET's is summed with the variable "OnDens".
*/
/*
Channel thermal and flicker noises are calculated based on the value
of model->B3SOInoiMod.
If model->B3SOInoiMod = 1,
Channel thermal noise = SPICE2 model
Flicker noise = SPICE2 model
If model->B3SOInoiMod = 2,
Channel thermal noise = B3SOI model
Flicker noise = B3SOI model
If model->B3SOInoiMod = 3,
Channel thermal noise = SPICE2 model
Flicker noise = B3SOI model
If model->B3SOInoiMod = 4,
Channel thermal noise = B3SOI model
Flicker noise = SPICE2 model
*/
extern void NevalSrc();
extern double Nintegrate();
double
B3SOIStrongInversionNoiseEval(double vgs, double vds, B3SOImodel *model,
B3SOIinstance *here, double freq, double temp)
{
struct b3soiSizeDependParam *pParam;
double cd, esat, DelClm, EffFreq, N0, Nl;
double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ssi;
pParam = here->pParam;
cd = fabs(here->B3SOIcd) * here->B3SOIm;
/* v2.2.3 bug fix */
if(model->B3SOIem<=0.0) DelClm = 0.0;
else {
esat = 2.0 * pParam->B3SOIvsattemp / here->B3SOIueff;
T0 = ((((vds - here->B3SOIVdseff) / pParam->B3SOIlitl)
+ model->B3SOIem) / esat);
DelClm = pParam->B3SOIlitl * log (MAX(T0, N_MINLOG));
}
EffFreq = pow(freq, model->B3SOIef);
T1 = CHARGE * CHARGE * 8.62e-5 * cd * temp * here->B3SOIueff;
T2 = 1.0e8 * EffFreq * model->B3SOIcox
* pParam->B3SOIleff * pParam->B3SOIleff;
/* v2.2.3 bug fix */
N0 = model->B3SOIcox * here->B3SOIVgsteff / CHARGE;
Nl = model->B3SOIcox * here->B3SOIVgsteff
* (1.0 - here->B3SOIAbovVgst2Vtm * here->B3SOIVdseff) / CHARGE;
T3 = model->B3SOIoxideTrapDensityA
* log(MAX(((N0 + 2.0e14) / (Nl + 2.0e14)), N_MINLOG));
T4 = model->B3SOIoxideTrapDensityB * (N0 - Nl);
T5 = model->B3SOIoxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl);
T6 = 8.62e-5 * temp * cd * cd;
T7 = 1.0e8 * EffFreq * pParam->B3SOIleff
* pParam->B3SOIleff * pParam->B3SOIweff * here->B3SOIm;
T8 = model->B3SOIoxideTrapDensityA + model->B3SOIoxideTrapDensityB * Nl
+ model->B3SOIoxideTrapDensityC * Nl * Nl;
T9 = (Nl + 2.0e14) * (Nl + 2.0e14);
Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9;
return Ssi;
}
int
B3SOInoise (int mode, int operation, GENmodel *inModel, CKTcircuit *ckt,
Ndata *data, double *OnDens)
{
B3SOImodel *model = (B3SOImodel *)inModel;
B3SOIinstance *here;
struct b3soiSizeDependParam *pParam;
char name[N_MXVLNTH];
double tempOnoise;
double tempInoise;
double noizDens[B3SOINSRCS];
double lnNdens[B3SOINSRCS];
double vgs, vds, Slimit;
double T1, T10, T11;
double Ssi, Swi;
int i;
/* define the names of the noise sources */
static char *B3SOInNames[B3SOINSRCS] =
{ /* Note that we have to keep the order */
".rd", /* noise due to rd */
/* consistent with the index definitions */
".rs", /* noise due to rs */
/* in B3SOIdefs.h */
".id", /* noise due to id */
".1overf", /* flicker (1/f) noise */
".fb", /* noise due to floating body */
"" /* total transistor noise */
};
for (; model != NULL; model = model->B3SOInextModel)
{ for (here = model->B3SOIinstances; here != NULL;
here = here->B3SOInextInstance)
{
if (here->B3SOIowner != ARCHme)
continue;
pParam = here->pParam;
switch (operation)
{ case N_OPEN:
/* see if we have to to produce a summary report */
/* if so, name all the noise generators */
if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0)
{ switch (mode)
{ case N_DENS:
for (i = 0; i < B3SOINSRCS; i++)
{ (void) sprintf(name, "onoise.%s%s",
here->B3SOIname,
B3SOInNames[i]);
data->namelist = (IFuid *) trealloc(
(char *) data->namelist,
(data->numPlots + 1)
* sizeof(IFuid));
if (!data->namelist)
return(E_NOMEM);
(*(SPfrontEnd->IFnewUid)) (ckt,
&(data->namelist[data->numPlots++]),
(IFuid) NULL, name, UID_OTHER,
(void **) NULL);
/* we've added one more plot */
}
break;
case INT_NOIZ:
for (i = 0; i < B3SOINSRCS; i++)
{ (void) sprintf(name, "onoise_total.%s%s",
here->B3SOIname,
B3SOInNames[i]);
data->namelist = (IFuid *) trealloc(
(char *) data->namelist,
(data->numPlots + 1)
* sizeof(IFuid));
if (!data->namelist)
return(E_NOMEM);
(*(SPfrontEnd->IFnewUid)) (ckt,
&(data->namelist[data->numPlots++]),
(IFuid) NULL, name, UID_OTHER,
(void **) NULL);
/* we've added one more plot */
(void) sprintf(name, "inoise_total.%s%s",
here->B3SOIname,
B3SOInNames[i]);
data->namelist = (IFuid *) trealloc(
(char *) data->namelist,
(data->numPlots + 1)
* sizeof(IFuid));
if (!data->namelist)
return(E_NOMEM);
(*(SPfrontEnd->IFnewUid)) (ckt,
&(data->namelist[data->numPlots++]),
(IFuid) NULL, name, UID_OTHER,
(void **)NULL);
/* we've added one more plot */
}
break;
}
}
break;
case N_CALC:
switch (mode)
{ case N_DENS:
NevalSrc(&noizDens[B3SOIRDNOIZ],
&lnNdens[B3SOIRDNOIZ], ckt, THERMNOISE,
here->B3SOIdNodePrime, here->B3SOIdNode,
here->B3SOIdrainConductance * here->B3SOIm);
NevalSrc(&noizDens[B3SOIRSNOIZ],
&lnNdens[B3SOIRSNOIZ], ckt, THERMNOISE,
here->B3SOIsNodePrime, here->B3SOIsNode,
here->B3SOIsourceConductance * here->B3SOIm);
switch( model->B3SOInoiMod )
{ case 1:
case 3:
NevalSrc(&noizDens[B3SOIIDNOIZ],
&lnNdens[B3SOIIDNOIZ], ckt,
THERMNOISE, here->B3SOIdNodePrime,
here->B3SOIsNodePrime,
(2.0 / 3.0 * fabs( here->B3SOIm *
(here->B3SOIgm
+ here->B3SOIgds
+ here->B3SOIgmbs))));
break;
case 2:
/* v2.2.3 bug fix */
case 4:
NevalSrc(&noizDens[B3SOIIDNOIZ],
&lnNdens[B3SOIIDNOIZ], ckt,
THERMNOISE, here->B3SOIdNodePrime,
here->B3SOIsNodePrime,
(here->B3SOIueff
* fabs((here->B3SOIqinv * here->B3SOIm)
/ (pParam->B3SOIleff
* pParam->B3SOIleff+
here->B3SOIueff*fabs
(here->B3SOIqinv * here->B3SOIm) *
(here->B3SOIrds / here->B3SOIm)))));
break;
}
NevalSrc(&noizDens[B3SOIFLNOIZ], (double*) NULL,
ckt, N_GAIN, here->B3SOIdNodePrime,
here->B3SOIsNodePrime, (double) 0.0);
switch( model->B3SOInoiMod )
{ case 1:
case 4:
noizDens[B3SOIFLNOIZ] *= model->B3SOIkf
* exp(model->B3SOIaf
* log(MAX(fabs(here->B3SOIm * here->B3SOIcd),
N_MINLOG)))
/ (pow(data->freq, model->B3SOIef)
* pParam->B3SOIleff
* pParam->B3SOIleff
* model->B3SOIcox);
break;
case 2:
case 3:
vgs = *(ckt->CKTstates[0] + here->B3SOIvgs);
vds = *(ckt->CKTstates[0] + here->B3SOIvds);
if (vds < 0.0)
{ vds = -vds;
vgs = vgs + vds;
}
if (vgs >= here->B3SOIvon + 0.1)
{ Ssi = B3SOIStrongInversionNoiseEval(vgs,
vds, model, here, data->freq,
ckt->CKTtemp);
noizDens[B3SOIFLNOIZ] *= Ssi;
}
else
{ pParam = here->pParam;
T10 = model->B3SOIoxideTrapDensityA
* 8.62e-5 * ckt->CKTtemp;
T11 = pParam->B3SOIweff * here->B3SOIm
* pParam->B3SOIleff
* pow(data->freq, model->B3SOIef)
* 4.0e36;
Swi = T10 / T11 * here->B3SOIcd * here->B3SOIm
* here->B3SOIcd * here->B3SOIm;
Slimit = B3SOIStrongInversionNoiseEval(
here->B3SOIvon + 0.1, vds, model,
here, data->freq, ckt->CKTtemp);
T1 = Swi + Slimit;
if (T1 > 0.0)
noizDens[B3SOIFLNOIZ] *= (Slimit
* Swi) / T1;
else
noizDens[B3SOIFLNOIZ] *= 0.0;
}
break;
}
lnNdens[B3SOIFLNOIZ] =
log(MAX(noizDens[B3SOIFLNOIZ], N_MINLOG));
/* Low frequency excess noise due to FBE */
NevalSrc(&noizDens[B3SOIFBNOIZ], &lnNdens[B3SOIFBNOIZ],
ckt, SHOTNOISE, here->B3SOIsNodePrime,
here->B3SOIbNode,
2.0 * model->B3SOInoif * here->B3SOIibs * here->B3SOIm);
noizDens[B3SOITOTNOIZ] = noizDens[B3SOIRDNOIZ]
+ noizDens[B3SOIRSNOIZ]
+ noizDens[B3SOIIDNOIZ]
+ noizDens[B3SOIFLNOIZ]
+ noizDens[B3SOIFBNOIZ];
lnNdens[B3SOITOTNOIZ] =
log(MAX(noizDens[B3SOITOTNOIZ], N_MINLOG));
*OnDens += noizDens[B3SOITOTNOIZ];
if (data->delFreq == 0.0)
{ /* if we haven't done any previous
integration, we need to initialize our
"history" variables.
*/
for (i = 0; i < B3SOINSRCS; i++)
{ here->B3SOInVar[LNLSTDENS][i] =
lnNdens[i];
}
/* clear out our integration variables
if it's the first pass
*/
if (data->freq ==
((NOISEAN*) ckt->CKTcurJob)->NstartFreq)
{ for (i = 0; i < B3SOINSRCS; i++)
{ here->B3SOInVar[OUTNOIZ][i] = 0.0;
here->B3SOInVar[INNOIZ][i] = 0.0;
}
}
}
else
{ /* data->delFreq != 0.0,
we have to integrate.
*/
for (i = 0; i < B3SOINSRCS; i++)
{ if (i != B3SOITOTNOIZ)
{ tempOnoise = Nintegrate(noizDens[i],
lnNdens[i],
here->B3SOInVar[LNLSTDENS][i],
data);
tempInoise = Nintegrate(noizDens[i]
* data->GainSqInv, lnNdens[i]
+ data->lnGainInv,
here->B3SOInVar[LNLSTDENS][i]
+ data->lnGainInv, data);
here->B3SOInVar[LNLSTDENS][i] =
lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if (((NOISEAN*)
ckt->CKTcurJob)->NStpsSm != 0)
{ here->B3SOInVar[OUTNOIZ][i]
+= tempOnoise;
here->B3SOInVar[OUTNOIZ][B3SOITOTNOIZ]
+= tempOnoise;
here->B3SOInVar[INNOIZ][i]
+= tempInoise;
here->B3SOInVar[INNOIZ][B3SOITOTNOIZ]
+= tempInoise;
}
}
}
}
if (data->prtSummary)
{ for (i = 0; i < B3SOINSRCS; i++)
{ /* print a summary report */
data->outpVector[data->outNumber++]
= noizDens[i];
}
}
break;
case INT_NOIZ:
/* already calculated, just output */
if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0)
{ for (i = 0; i < B3SOINSRCS; i++)
{ data->outpVector[data->outNumber++]
= here->B3SOInVar[OUTNOIZ][i];
data->outpVector[data->outNumber++]
= here->B3SOInVar[INNOIZ][i];
}
}
break;
}
break;
case N_CLOSE:
/* do nothing, the main calling routine will close */
return (OK);
break; /* the plots */
} /* switch (operation) */
} /* for here */
} /* for model */
return(OK);
}

172
src/spicelib/devices/bsim3soi/b3soipar.c
View File

@ -1,172 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soipar.c 98/5/01
Modified by Pin Su 99/2/15
Modified by Pin Su 01/2/15
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "ifsim.h"
#include "b3soidef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIparam(int param, IFvalue *value, GENinstance *inst, IFvalue *select)
{
B3SOIinstance *here = (B3SOIinstance*)inst;
switch(param)
{ case B3SOI_W:
here->B3SOIw = value->rValue;
here->B3SOIwGiven = TRUE;
break;
case B3SOI_L:
here->B3SOIl = value->rValue;
here->B3SOIlGiven = TRUE;
break;
case B3SOI_M:
here->B3SOIm = value->rValue;
here->B3SOImGiven = TRUE;
break;
case B3SOI_AS:
here->B3SOIsourceArea = value->rValue;
here->B3SOIsourceAreaGiven = TRUE;
break;
case B3SOI_AD:
here->B3SOIdrainArea = value->rValue;
here->B3SOIdrainAreaGiven = TRUE;
break;
case B3SOI_PS:
here->B3SOIsourcePerimeter = value->rValue;
here->B3SOIsourcePerimeterGiven = TRUE;
break;
case B3SOI_PD:
here->B3SOIdrainPerimeter = value->rValue;
here->B3SOIdrainPerimeterGiven = TRUE;
break;
case B3SOI_NRS:
here->B3SOIsourceSquares = value->rValue;
here->B3SOIsourceSquaresGiven = TRUE;
break;
case B3SOI_NRD:
here->B3SOIdrainSquares = value->rValue;
here->B3SOIdrainSquaresGiven = TRUE;
break;
case B3SOI_OFF:
here->B3SOIoff = value->iValue;
here->B3SOIoffGiven = TRUE;
break;
case B3SOI_IC_VBS:
here->B3SOIicVBS = value->rValue;
here->B3SOIicVBSGiven = TRUE;
break;
case B3SOI_IC_VDS:
here->B3SOIicVDS = value->rValue;
here->B3SOIicVDSGiven = TRUE;
break;
case B3SOI_IC_VGS:
here->B3SOIicVGS = value->rValue;
here->B3SOIicVGSGiven = TRUE;
break;
case B3SOI_IC_VES:
here->B3SOIicVES = value->rValue;
here->B3SOIicVESGiven = TRUE;
break;
case B3SOI_IC_VPS:
here->B3SOIicVPS = value->rValue;
here->B3SOIicVPSGiven = TRUE;
break;
case B3SOI_BJTOFF:
here->B3SOIbjtoff = value->iValue;
here->B3SOIbjtoffGiven= TRUE;
break;
case B3SOI_DEBUG:
here->B3SOIdebugMod = value->iValue;
here->B3SOIdebugModGiven= TRUE;
break;
case B3SOI_RTH0:
here->B3SOIrth0= value->rValue;
here->B3SOIrth0Given = TRUE;
break;
case B3SOI_CTH0:
here->B3SOIcth0= value->rValue;
here->B3SOIcth0Given = TRUE;
break;
case B3SOI_NRB:
here->B3SOIbodySquares = value->rValue;
here->B3SOIbodySquaresGiven = TRUE;
break;
case B3SOI_FRBODY:
here->B3SOIfrbody = value->rValue;
here->B3SOIfrbodyGiven = TRUE;
break;
/* v2.0 release */
case B3SOI_NBC:
here->B3SOInbc = value->rValue;
here->B3SOInbcGiven = TRUE;
break;
case B3SOI_NSEG:
here->B3SOInseg = value->rValue;
here->B3SOInsegGiven = TRUE;
break;
case B3SOI_PDBCP:
here->B3SOIpdbcp = value->rValue;
here->B3SOIpdbcpGiven = TRUE;
break;
case B3SOI_PSBCP:
here->B3SOIpsbcp = value->rValue;
here->B3SOIpsbcpGiven = TRUE;
break;
case B3SOI_AGBCP:
here->B3SOIagbcp = value->rValue;
here->B3SOIagbcpGiven = TRUE;
break;
case B3SOI_AEBCP:
here->B3SOIaebcp = value->rValue;
here->B3SOIaebcpGiven = TRUE;
break;
case B3SOI_VBSUSR:
here->B3SOIvbsusr = value->rValue;
here->B3SOIvbsusrGiven = TRUE;
break;
case B3SOI_TNODEOUT:
here->B3SOItnodeout = value->iValue;
here->B3SOItnodeoutGiven = TRUE;
break;
case B3SOI_IC:
switch(value->v.numValue){
case 5:
here->B3SOIicVPS = *(value->v.vec.rVec+4);
here->B3SOIicVPSGiven = TRUE;
case 4:
here->B3SOIicVES = *(value->v.vec.rVec+3);
here->B3SOIicVESGiven = TRUE;
case 3:
here->B3SOIicVBS = *(value->v.vec.rVec+2);
here->B3SOIicVBSGiven = TRUE;
case 2:
here->B3SOIicVGS = *(value->v.vec.rVec+1);
here->B3SOIicVGSGiven = TRUE;
case 1:
here->B3SOIicVDS = *(value->v.vec.rVec);
here->B3SOIicVDSGiven = TRUE;
break;
default:
return(E_BADPARM);
}
break;
default:
return(E_BADPARM);
}
return(OK);
}

158
src/spicelib/devices/bsim3soi/b3soipzld.c
View File

@ -1,158 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soipzld.c 98/5/01
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "complex.h"
#include "sperror.h"
#include "b3soidef.h"
#include "suffix.h"
int
B3SOIpzLoad(GENmodel *inModel, CKTcircuit *ckt, SPcomplex *s)
{
B3SOImodel *model = (B3SOImodel*)inModel;
B3SOIinstance *here;
double xcggb, xcgdb, xcgsb, xcbgb, xcbdb, xcbsb, xcddb, xcssb, xcdgb;
double gdpr, gspr, gds, gbd, gbs;
double capbd = 0.0, capbs = 0.0, xcsgb, xcdsb, xcsdb;
double cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cddb, cdgb, cdsb;
double GSoverlapCap, GDoverlapCap, GBoverlapCap = 0.0;
double FwdSum, RevSum, Gm, Gmbs;
double m;
for (; model != NULL; model = model->B3SOInextModel)
{ for (here = model->B3SOIinstances; here!= NULL;
here = here->B3SOInextInstance)
{
if (here->B3SOIowner != ARCHme)
continue;
if (here->B3SOImode >= 0)
{ Gm = here->B3SOIgm;
Gmbs = here->B3SOIgmbs;
FwdSum = Gm + Gmbs;
RevSum = 0.0;
cggb = here->B3SOIcggb;
cgsb = here->B3SOIcgsb;
cgdb = here->B3SOIcgdb;
cbgb = here->B3SOIcbgb;
cbsb = here->B3SOIcbsb;
cbdb = here->B3SOIcbdb;
cdgb = here->B3SOIcdgb;
cdsb = here->B3SOIcdsb;
cddb = here->B3SOIcddb;
}
else
{ Gm = -here->B3SOIgm;
Gmbs = -here->B3SOIgmbs;
FwdSum = 0.0;
RevSum = -Gm - Gmbs;
cggb = here->B3SOIcggb;
cgsb = here->B3SOIcgdb;
cgdb = here->B3SOIcgsb;
cbgb = here->B3SOIcbgb;
cbsb = here->B3SOIcbdb;
cbdb = here->B3SOIcbsb;
cdgb = -(here->B3SOIcdgb + cggb + cbgb);
cdsb = -(here->B3SOIcddb + cgsb + cbsb);
cddb = -(here->B3SOIcdsb + cgdb + cbdb);
}
gdpr=here->B3SOIdrainConductance;
gspr=here->B3SOIsourceConductance;
gds= here->B3SOIgds;
gbd= here->B3SOIgjdb;
gbs= here->B3SOIgjsb;
#ifdef BULKCODE
capbd= here->B3SOIcapbd;
capbs= here->B3SOIcapbs;
#endif
GSoverlapCap = here->B3SOIcgso;
GDoverlapCap = here->B3SOIcgdo;
#ifdef BULKCODE
GBoverlapCap = here->pParam->B3SOIcgbo;
#endif
xcdgb = (cdgb - GDoverlapCap);
xcddb = (cddb + capbd + GDoverlapCap);
xcdsb = cdsb;
xcsgb = -(cggb + cbgb + cdgb + GSoverlapCap);
xcsdb = -(cgdb + cbdb + cddb);
xcssb = (capbs + GSoverlapCap - (cgsb+cbsb+cdsb));
xcggb = (cggb + GDoverlapCap + GSoverlapCap + GBoverlapCap);
xcgdb = (cgdb - GDoverlapCap);
xcgsb = (cgsb - GSoverlapCap);
xcbgb = (cbgb - GBoverlapCap);
xcbdb = (cbdb - capbd);
xcbsb = (cbsb - capbs);
m = here->B3SOIm;
*(here->B3SOIGgPtr ) += m * (xcggb * s->real);
*(here->B3SOIGgPtr +1) += m * (xcggb * s->imag);
*(here->B3SOIBbPtr ) += m * ((-xcbgb-xcbdb-xcbsb) * s->real);
*(here->B3SOIBbPtr +1) += m * ((-xcbgb-xcbdb-xcbsb) * s->imag);
*(here->B3SOIDPdpPtr ) += m * (xcddb * s->real);
*(here->B3SOIDPdpPtr +1) += m * (xcddb * s->imag);
*(here->B3SOISPspPtr ) += m * (xcssb * s->real);
*(here->B3SOISPspPtr +1) += m * (xcssb * s->imag);
*(here->B3SOIGbPtr ) += m * ((-xcggb-xcgdb-xcgsb) * s->real);
*(here->B3SOIGbPtr +1) += m * ((-xcggb-xcgdb-xcgsb) * s->imag);
*(here->B3SOIGdpPtr ) += m * (xcgdb * s->real);
*(here->B3SOIGdpPtr +1) += m * (xcgdb * s->imag);
*(here->B3SOIGspPtr ) += m * (xcgsb * s->real);
*(here->B3SOIGspPtr +1) += m * (xcgsb * s->imag);
*(here->B3SOIBgPtr ) += m * (xcbgb * s->real);
*(here->B3SOIBgPtr +1) += m * (xcbgb * s->imag);
*(here->B3SOIBdpPtr ) += m * (xcbdb * s->real);
*(here->B3SOIBdpPtr +1) += m * (xcbdb * s->imag);
*(here->B3SOIBspPtr ) += m * (xcbsb * s->real);
*(here->B3SOIBspPtr +1) += m * (xcbsb * s->imag);
*(here->B3SOIDPgPtr ) += m * (xcdgb * s->real);
*(here->B3SOIDPgPtr +1) += m * (xcdgb * s->imag);
*(here->B3SOIDPbPtr ) += m * ((-xcdgb-xcddb-xcdsb) * s->real);
*(here->B3SOIDPbPtr +1) += m * ((-xcdgb-xcddb-xcdsb) * s->imag);
*(here->B3SOIDPspPtr ) += m * (xcdsb * s->real);
*(here->B3SOIDPspPtr +1) += m * (xcdsb * s->imag);
*(here->B3SOISPgPtr ) += m * (xcsgb * s->real);
*(here->B3SOISPgPtr +1) += m * (xcsgb * s->imag);
*(here->B3SOISPbPtr ) += m * ((-xcsgb-xcsdb-xcssb) * s->real);
*(here->B3SOISPbPtr +1) += m * ((-xcsgb-xcsdb-xcssb) * s->imag);
*(here->B3SOISPdpPtr ) += m * (xcsdb * s->real);
*(here->B3SOISPdpPtr +1) += m * (xcsdb * s->imag);
*(here->B3SOIDdPtr) += m * gdpr;
*(here->B3SOISsPtr) += m * gspr;
*(here->B3SOIBbPtr) += m * (gbd + gbs);
*(here->B3SOIDPdpPtr) += m * (gdpr + gds + gbd + RevSum);
*(here->B3SOISPspPtr) += m * (gspr + gds + gbs + FwdSum);
*(here->B3SOIDdpPtr) -= m * gdpr;
*(here->B3SOISspPtr) -= m * gspr;
*(here->B3SOIBdpPtr) -= m * gbd;
*(here->B3SOIBspPtr) -= m * gbs;
*(here->B3SOIDPdPtr) -= m * gdpr;
*(here->B3SOIDPgPtr) += m * Gm;
*(here->B3SOIDPbPtr) -= m * (gbd - Gmbs);
*(here->B3SOIDPspPtr) -= m * (gds + FwdSum);
*(here->B3SOISPgPtr) -= m * Gm;
*(here->B3SOISPsPtr) -= m * gspr;
*(here->B3SOISPbPtr) -= m * (gbs + Gmbs);
*(here->B3SOISPdpPtr) -= m * (gds + RevSum);
}
}
return(OK);
}

1595
src/spicelib/devices/bsim3soi/b3soiset.c
File diff suppressed because it is too large
View File

1076
src/spicelib/devices/bsim3soi/b3soitemp.c
File diff suppressed because it is too large
View File

51
src/spicelib/devices/bsim3soi/b3soitrunc.c
View File

@ -1,51 +0,0 @@
/**********
Copyright 1990 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soitrunc.c 98/5/01
Modified by Paolo Nenzi 2002
**********/
#include "ngspice.h"
#include "cktdefs.h"
#include "b3soidef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOItrunc(GENmodel *inModel, CKTcircuit *ckt, double *timeStep)
{
B3SOImodel *model = (B3SOImodel*)inModel;
B3SOIinstance *here;
#ifdef STEPDEBUG
double debugtemp;
#endif /* STEPDEBUG */
for (; model != NULL; model = model->B3SOInextModel)
{ for (here = model->B3SOIinstances; here != NULL;
here = here->B3SOInextInstance)
{
if (here->B3SOIowner != ARCHme)
continue;
#ifdef STEPDEBUG
debugtemp = *timeStep;
#endif /* STEPDEBUG */
CKTterr(here->B3SOIqb,ckt,timeStep);
CKTterr(here->B3SOIqg,ckt,timeStep);
CKTterr(here->B3SOIqd,ckt,timeStep);
#ifdef STEPDEBUG
if(debugtemp != *timeStep)
{ printf("device %s reduces step from %g to %g\n",
here->B3SOIname,debugtemp,*timeStep);
}
#endif /* STEPDEBUG */
}
}
return(OK);
}
Write Preview
Loading…
Cancel
Save