luke
/
ngspice
mirror of https://git.code.sf.net/p/ngspice/ngspice
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

old version

This commit is contained in:
dwarning 2008-04-16 20:09:23 +00:00
parent c6f5b60101
commit ecd45d7ce3
23 changed files with 0 additions and 17084 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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
View File

File diff suppressed because it is too large Load Diff

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
View File

File diff suppressed because it is too large Load Diff

1630
src/spicelib/devices/bsim3soi/b3soimask.c
View File

File diff suppressed because it is too large Load Diff

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
View File

File diff suppressed because it is too large Load Diff

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
View File

File diff suppressed because it is too large Load Diff

1076
src/spicelib/devices/bsim3soi/b3soitemp.c
View File

File diff suppressed because it is too large Load Diff

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);
}