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

Added support fot bsim3soi dynamic depletion device (initial commit)

This commit is contained in:
pnenzi 2001-01-21 17:07:40 +00:00
parent d7e8cc99e5
commit 504ab3b0f9
24 changed files with 14301 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/spicelib/devices/bsim3soi_dd/Makefile.am Normal file
View File

@ -0,0 +1,34 @@
## Process this file with automake to produce Makefile.in
pkglib_LTLIBRARIES = libbsim3soidd.la
libbsim3soidd_la_SOURCES = \
b3soidd.c \
b3soiddacld.c \
b3soiddask.c \
b3soiddcheck.c \
b3soiddcvtest.c \
b3soidddel.c \
b3soidddest.c \
b3soiddgetic.c \
b3soiddld.c \
b3soiddmask.c \
b3soiddmdel.c \
b3soiddmpar.c \
b3soiddnoi.c \
b3soiddpar.c \
b3soiddpzld.c \
b3soiddset.c \
b3soiddtemp.c \
b3soiddtrunc.c \
b3soidddef.h \
b3soiddext.h \
b3soiddinit.c \
b3soiddinit.h \
b3soidditf.h
INCLUDES = -I$(top_srcdir)/src/include
MAINTAINERCLEANFILES = Makefile.in

479
src/spicelib/devices/bsim3soi_dd/b3soidd.c Normal file
View File

@ -0,0 +1,479 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: Weidong Liu and Pin Su Feb 1999
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soidd.c 98/5/01
Modified by Wei Jin 99/9/27
**********/
#include "ngspice.h"
#include <stdio.h>
#include "devdefs.h"
#include "b3soidddef.h"
#include "suffix.h"
IFparm B3SOIDDpTable[] = { /* parameters */
IOP( "l", B3SOIDD_L, IF_REAL , "Length"),
IOP( "w", B3SOIDD_W, IF_REAL , "Width"),
IOP( "ad", B3SOIDD_AD, IF_REAL , "Drain area"),
IOP( "as", B3SOIDD_AS, IF_REAL , "Source area"),
IOP( "pd", B3SOIDD_PD, IF_REAL , "Drain perimeter"),
IOP( "ps", B3SOIDD_PS, IF_REAL , "Source perimeter"),
IOP( "nrd", B3SOIDD_NRD, IF_REAL , "Number of squares in drain"),
IOP( "nrs", B3SOIDD_NRS, IF_REAL , "Number of squares in source"),
IOP( "off", B3SOIDD_OFF, IF_FLAG , "Device is initially off"),
IP( "ic", B3SOIDD_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"),
OP( "gmbs", B3SOIDD_GMBS, IF_REAL, "Gmb"),
OP( "gm", B3SOIDD_GM, IF_REAL, "Gm"),
OP( "gm/ids", B3SOIDD_GMID, IF_REAL, "Gm/Ids"),
OP( "gds", B3SOIDD_GDS, IF_REAL, "Gds"),
OP( "vdsat", B3SOIDD_VDSAT, IF_REAL, "Vdsat"),
OP( "vth", B3SOIDD_VON, IF_REAL, "Vth"),
OP( "ids", B3SOIDD_CD, IF_REAL, "Ids"),
OP( "vbs", B3SOIDD_VBS, IF_REAL, "Vbs"),
OP( "vgs", B3SOIDD_VGS, IF_REAL, "Vgs"),
OP( "vds", B3SOIDD_VDS, IF_REAL, "Vds"),
OP( "ves", B3SOIDD_VES, IF_REAL, "Ves"),
IOP( "bjtoff", B3SOIDD_BJTOFF, IF_INTEGER, "BJT on/off flag"),
IOP( "debug", B3SOIDD_DEBUG, IF_INTEGER, "BJT on/off flag"),
IOP( "rth0", B3SOIDD_RTH0, IF_REAL, "Instance Thermal Resistance"),
IOP( "cth0", B3SOIDD_CTH0, IF_REAL, "Instance Thermal Capacitance"),
IOP( "nrb", B3SOIDD_NRB, IF_REAL, "Number of squares in body"),
};
IFparm B3SOIDDmPTable[] = { /* model parameters */
IOP( "capmod", B3SOIDD_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"),
IOP( "mobmod", B3SOIDD_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"),
IOP( "noimod", B3SOIDD_MOD_NOIMOD, IF_INTEGER, "Noise model selector"),
IOP( "paramchk", B3SOIDD_MOD_PARAMCHK, IF_INTEGER, "Model parameter checking selector"),
IOP( "binunit", B3SOIDD_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"),
IOP( "version", B3SOIDD_MOD_VERSION, IF_REAL, " parameter for model version"),
IOP( "tox", B3SOIDD_MOD_TOX, IF_REAL, "Gate oxide thickness in meters"),
IOP( "cdsc", B3SOIDD_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"),
IOP( "cdscb", B3SOIDD_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"),
IOP( "cdscd", B3SOIDD_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"),
IOP( "cit", B3SOIDD_MOD_CIT, IF_REAL, "Interface state capacitance"),
IOP( "nfactor", B3SOIDD_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"),
IOP( "vsat", B3SOIDD_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"),
IOP( "at", B3SOIDD_MOD_AT, IF_REAL, "Temperature coefficient of vsat"),
IOP( "a0", B3SOIDD_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."),
IOP( "ags", B3SOIDD_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."),
IOP( "a1", B3SOIDD_MOD_A1, IF_REAL, "Non-saturation effect coefficient"),
IOP( "a2", B3SOIDD_MOD_A2, IF_REAL, "Non-saturation effect coefficient"),
IOP( "keta", B3SOIDD_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."),
IOP( "nsub", B3SOIDD_MOD_NSUB, IF_REAL, "Substrate doping concentration with polarity"),
IOP( "nch", B3SOIDD_MOD_NPEAK, IF_REAL, "Channel doping concentration"),
IOP( "ngate", B3SOIDD_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"),
IOP( "gamma1", B3SOIDD_MOD_GAMMA1, IF_REAL, "Vth body coefficient"),
IOP( "gamma2", B3SOIDD_MOD_GAMMA2, IF_REAL, "Vth body coefficient"),
IOP( "vbx", B3SOIDD_MOD_VBX, IF_REAL, "Vth transition body Voltage"),
IOP( "vbm", B3SOIDD_MOD_VBM, IF_REAL, "Maximum body voltage"),
IOP( "xt", B3SOIDD_MOD_XT, IF_REAL, "Doping depth"),
IOP( "k1", B3SOIDD_MOD_K1, IF_REAL, "Bulk effect coefficient 1"),
IOP( "kt1", B3SOIDD_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt1l", B3SOIDD_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt2", B3SOIDD_MOD_KT2, IF_REAL, "Body-coefficient of kt1"),
IOP( "k2", B3SOIDD_MOD_K2, IF_REAL, "Bulk effect coefficient 2"),
IOP( "k3", B3SOIDD_MOD_K3, IF_REAL, "Narrow width effect coefficient"),
IOP( "k3b", B3SOIDD_MOD_K3B, IF_REAL, "Body effect coefficient of k3"),
IOP( "w0", B3SOIDD_MOD_W0, IF_REAL, "Narrow width effect parameter"),
IOP( "nlx", B3SOIDD_MOD_NLX, IF_REAL, "Lateral non-uniform doping effect"),
IOP( "dvt0", B3SOIDD_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"),
IOP( "dvt1", B3SOIDD_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"),
IOP( "dvt2", B3SOIDD_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"),
IOP( "dvt0w", B3SOIDD_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"),
IOP( "dvt1w", B3SOIDD_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"),
IOP( "dvt2w", B3SOIDD_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"),
IOP( "drout", B3SOIDD_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"),
IOP( "dsub", B3SOIDD_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"),
IOP( "vth0", B3SOIDD_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "vtho", B3SOIDD_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "ua", B3SOIDD_MOD_UA, IF_REAL, "Linear gate dependence of mobility"),
IOP( "ua1", B3SOIDD_MOD_UA1, IF_REAL, "Temperature coefficient of ua"),
IOP( "ub", B3SOIDD_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"),
IOP( "ub1", B3SOIDD_MOD_UB1, IF_REAL, "Temperature coefficient of ub"),
IOP( "uc", B3SOIDD_MOD_UC, IF_REAL, "Body-bias dependence of mobility"),
IOP( "uc1", B3SOIDD_MOD_UC1, IF_REAL, "Temperature coefficient of uc"),
IOP( "u0", B3SOIDD_MOD_U0, IF_REAL, "Low-field mobility at Tnom"),
IOP( "ute", B3SOIDD_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"),
IOP( "voff", B3SOIDD_MOD_VOFF, IF_REAL, "Threshold voltage offset"),
IOP( "tnom", B3SOIDD_MOD_TNOM, IF_REAL, "Parameter measurement temperature"),
IOP( "cgso", B3SOIDD_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"),
IOP( "cgdo", B3SOIDD_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"),
IOP( "cgeo", B3SOIDD_MOD_CGEO, IF_REAL, "Gate-substrate overlap capacitance"),
IOP( "xpart", B3SOIDD_MOD_XPART, IF_REAL, "Channel charge partitioning"),
IOP( "delta", B3SOIDD_MOD_DELTA, IF_REAL, "Effective Vds parameter"),
IOP( "rsh", B3SOIDD_MOD_RSH, IF_REAL, "Source-drain sheet resistance"),
IOP( "rdsw", B3SOIDD_MOD_RDSW, IF_REAL, "Source-drain resistance per width"),
IOP( "prwg", B3SOIDD_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "),
IOP( "prwb", B3SOIDD_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "),
IOP( "prt", B3SOIDD_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "),
IOP( "eta0", B3SOIDD_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "etab", B3SOIDD_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "pclm", B3SOIDD_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"),
IOP( "pdiblc1", B3SOIDD_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblc2", B3SOIDD_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblcb", B3SOIDD_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"),
IOP( "pvag", B3SOIDD_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"),
IOP( "shmod", B3SOIDD_MOD_SHMOD, IF_INTEGER, "Self heating mode selector"),
IOP( "tbox", B3SOIDD_MOD_TBOX, IF_REAL, "Back gate oxide thickness in meters"),
IOP( "tsi", B3SOIDD_MOD_TSI, IF_REAL, "Silicon-on-insulator thickness in meters"),
IOP( "xj", B3SOIDD_MOD_XJ, IF_REAL, "Junction Depth"),
IOP( "kb1", B3SOIDD_MOD_KB1, IF_REAL, "Backgate coupling coefficient at strong inversion"),
IOP( "kb3", B3SOIDD_MOD_KB3, IF_REAL, "Backgate coupling coefficient at subthreshold"),
IOP( "dvbd0", B3SOIDD_MOD_DVBD0, IF_REAL, "First coefficient of short-channel effect on Vbs0t"),
IOP( "dvbd1", B3SOIDD_MOD_DVBD1, IF_REAL, "Second coefficient of short-channel effect on Vbs0t"),
IOP( "vbsa", B3SOIDD_MOD_VBSA, IF_REAL, "Vbs0t offset voltage"),
IOP( "delp", B3SOIDD_MOD_DELP, IF_REAL, "Offset constant for limiting Vbseff to Phis"),
IOP( "rbody", B3SOIDD_MOD_RBODY, IF_REAL, "Intrinsic body contact sheet resistance"),
IOP( "rbsh", B3SOIDD_MOD_RBSH, IF_REAL, "Extrinsic body contact sheet resistance"),
IOP( "adice0", B3SOIDD_MOD_ADICE0, IF_REAL, "DICE constant for bulk charge effect"),
IOP( "abp", B3SOIDD_MOD_ABP, IF_REAL, "Gate bias coefficient for Xcsat calculation"),
IOP( "mxc", B3SOIDD_MOD_MXC, IF_REAL, "A smoothing parameter for Xcsat calculation"),
IOP( "rth0", B3SOIDD_MOD_RTH0, IF_REAL, "Self-heating thermal resistance"),
IOP( "cth0", B3SOIDD_MOD_CTH0, IF_REAL, "Self-heating thermal capacitance"),
IOP( "aii", B3SOIDD_MOD_AII, IF_REAL, "1st Vdsatii parameter"),
IOP( "bii", B3SOIDD_MOD_BII, IF_REAL, "2nd Vdsatii parameter"),
IOP( "cii", B3SOIDD_MOD_CII, IF_REAL, "3rd Vdsatii parameter"),
IOP( "dii", B3SOIDD_MOD_DII, IF_REAL, "4th Vdsatii parameter"),
IOP( "ngidl", B3SOIDD_MOD_NGIDL, IF_REAL, "GIDL first parameter"),
IOP( "agidl", B3SOIDD_MOD_AGIDL, IF_REAL, "GIDL second parameter"),
IOP( "bgidl", B3SOIDD_MOD_BGIDL, IF_REAL, "GIDL third parameter"),
IOP( "ndiode", B3SOIDD_MOD_NDIODE, IF_REAL, "Diode non-ideality factor"),
IOP( "ntun", B3SOIDD_MOD_NTUN, IF_REAL, "Reverse tunneling non-ideality factor"),
IOP( "isbjt", B3SOIDD_MOD_ISBJT, IF_REAL, "BJT emitter injection constant"),
IOP( "isdif", B3SOIDD_MOD_ISDIF, IF_REAL, "Body to S/D injection constant"),
IOP( "isrec", B3SOIDD_MOD_ISREC, IF_REAL, "Recombination in depletion constant"),
IOP( "istun", B3SOIDD_MOD_ISTUN, IF_REAL, "Tunneling diode constant"),
IOP( "xbjt", B3SOIDD_MOD_XBJT, IF_REAL, "Temperature coefficient for Isbjt"),
IOP( "xdif", B3SOIDD_MOD_XBJT, IF_REAL, "Temperature coefficient for Isdif"),
IOP( "xrec", B3SOIDD_MOD_XREC, IF_REAL, "Temperature coefficient for Isrec"),
IOP( "xtun", B3SOIDD_MOD_XTUN, IF_REAL, "Temperature coefficient for Istun"),
IOP( "edl", B3SOIDD_MOD_EDL, IF_REAL, "Electron diffusion length"),
IOP( "kbjt1", B3SOIDD_MOD_KBJT1, IF_REAL, "Vds dependency on BJT base width"),
IOP( "tt", B3SOIDD_MOD_TT, IF_REAL, "Diffusion capacitance transit time coefficient"),
IOP( "vsdth", B3SOIDD_MOD_VSDTH, IF_REAL, "Source/Drain diffusion threshold voltage"),
IOP( "vsdfb", B3SOIDD_MOD_VSDFB, IF_REAL, "Source/Drain diffusion flatband voltage"),
IOP( "csdmin", B3SOIDD_MOD_CSDMIN, IF_REAL, "Source/Drain diffusion bottom minimum capacitance"),
IOP( "asd", B3SOIDD_MOD_ASD, IF_REAL, "Source/Drain diffusion smoothing parameter"),
IOP( "pbswg", B3SOIDD_MOD_PBSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance built in potential"),
IOP( "mjswg", B3SOIDD_MOD_MJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance grading coefficient"),
IOP( "cjswg", B3SOIDD_MOD_CJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance per unit width"),
IOP( "csdesw", B3SOIDD_MOD_CSDESW, IF_REAL, "Source/drain sidewall fringing constant"),
IOP( "lint", B3SOIDD_MOD_LINT, IF_REAL, "Length reduction parameter"),
IOP( "ll", B3SOIDD_MOD_LL, IF_REAL, "Length reduction parameter"),
IOP( "lln", B3SOIDD_MOD_LLN, IF_REAL, "Length reduction parameter"),
IOP( "lw", B3SOIDD_MOD_LW, IF_REAL, "Length reduction parameter"),
IOP( "lwn", B3SOIDD_MOD_LWN, IF_REAL, "Length reduction parameter"),
IOP( "lwl", B3SOIDD_MOD_LWL, IF_REAL, "Length reduction parameter"),
IOP( "wr", B3SOIDD_MOD_WR, IF_REAL, "Width dependence of rds"),
IOP( "wint", B3SOIDD_MOD_WINT, IF_REAL, "Width reduction parameter"),
IOP( "dwg", B3SOIDD_MOD_DWG, IF_REAL, "Width reduction parameter"),
IOP( "dwb", B3SOIDD_MOD_DWB, IF_REAL, "Width reduction parameter"),
IOP( "wl", B3SOIDD_MOD_WL, IF_REAL, "Width reduction parameter"),
IOP( "wln", B3SOIDD_MOD_WLN, IF_REAL, "Width reduction parameter"),
IOP( "ww", B3SOIDD_MOD_WW, IF_REAL, "Width reduction parameter"),
IOP( "wwn", B3SOIDD_MOD_WWN, IF_REAL, "Width reduction parameter"),
IOP( "wwl", B3SOIDD_MOD_WWL, IF_REAL, "Width reduction parameter"),
IOP( "b0", B3SOIDD_MOD_B0, IF_REAL, "Abulk narrow width parameter"),
IOP( "b1", B3SOIDD_MOD_B1, IF_REAL, "Abulk narrow width parameter"),
IOP( "cgsl", B3SOIDD_MOD_CGSL, IF_REAL, "New C-V model parameter"),
IOP( "cgdl", B3SOIDD_MOD_CGDL, IF_REAL, "New C-V model parameter"),
IOP( "ckappa", B3SOIDD_MOD_CKAPPA, IF_REAL, "New C-V model parameter"),
IOP( "cf", B3SOIDD_MOD_CF, IF_REAL, "Fringe capacitance parameter"),
IOP( "clc", B3SOIDD_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "cle", B3SOIDD_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "dwc", B3SOIDD_MOD_DWC, IF_REAL, "Delta W for C-V model"),
IOP( "dlc", B3SOIDD_MOD_DLC, IF_REAL, "Delta L for C-V model"),
IOP( "alpha0", B3SOIDD_MOD_ALPHA0, IF_REAL, "substrate current model parameter"),
IOP( "alpha1", B3SOIDD_MOD_ALPHA1, IF_REAL, "substrate current model parameter"),
IOP( "beta0", B3SOIDD_MOD_BETA0, IF_REAL, "substrate current model parameter"),
IOP( "noia", B3SOIDD_MOD_NOIA, IF_REAL, "Flicker noise parameter"),
IOP( "noib", B3SOIDD_MOD_NOIB, IF_REAL, "Flicker noise parameter"),
IOP( "noic", B3SOIDD_MOD_NOIC, IF_REAL, "Flicker noise parameter"),
IOP( "em", B3SOIDD_MOD_EM, IF_REAL, "Flicker noise parameter"),
IOP( "ef", B3SOIDD_MOD_EF, IF_REAL, "Flicker noise frequency exponent"),
IOP( "af", B3SOIDD_MOD_AF, IF_REAL, "Flicker noise exponent"),
IOP( "kf", B3SOIDD_MOD_KF, IF_REAL, "Flicker noise coefficient"),
IOP( "noif", B3SOIDD_MOD_NOIF, IF_REAL, "Floating body excess noise ideality factor"),
/* Added for binning - START */
/* Length Dependence */
IOP( "lnch", B3SOIDD_MOD_LNPEAK, IF_REAL, "Length dependence of nch"),
IOP( "lnsub", B3SOIDD_MOD_LNSUB, IF_REAL, "Length dependence of nsub"),
IOP( "lngate", B3SOIDD_MOD_LNGATE, IF_REAL, "Length dependence of ngate"),
IOP( "lvth0", B3SOIDD_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOP( "lk1", B3SOIDD_MOD_LK1, IF_REAL, "Length dependence of k1"),
IOP( "lk2", B3SOIDD_MOD_LK2, IF_REAL, "Length dependence of k2"),
IOP( "lk3", B3SOIDD_MOD_LK3, IF_REAL, "Length dependence of k3"),
IOP( "lk3b", B3SOIDD_MOD_LK3B, IF_REAL, "Length dependence of k3b"),
IOP( "lvbsa", B3SOIDD_MOD_LVBSA, IF_REAL, "Length dependence of vbsa"),
IOP( "ldelp", B3SOIDD_MOD_LDELP, IF_REAL, "Length dependence of delp"),
IOP( "lkb1", B3SOIDD_MOD_LKB1, IF_REAL, "Length dependence of kb1"),
IOP( "lkb3", B3SOIDD_MOD_LKB3, IF_REAL, "Length dependence of kb3"),
IOP( "ldvbd0", B3SOIDD_MOD_LDVBD0, IF_REAL, "Length dependence of dvbd0"),
IOP( "ldvbd1", B3SOIDD_MOD_LDVBD1, IF_REAL, "Length dependence of dvbd1"),
IOP( "lw0", B3SOIDD_MOD_LW0, IF_REAL, "Length dependence of w0"),
IOP( "lnlx", B3SOIDD_MOD_LNLX, IF_REAL, "Length dependence of nlx"),
IOP( "ldvt0", B3SOIDD_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"),
IOP( "ldvt1", B3SOIDD_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"),
IOP( "ldvt2", B3SOIDD_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"),
IOP( "ldvt0w", B3SOIDD_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"),
IOP( "ldvt1w", B3SOIDD_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"),
IOP( "ldvt2w", B3SOIDD_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"),
IOP( "lu0", B3SOIDD_MOD_LU0, IF_REAL, "Length dependence of u0"),
IOP( "lua", B3SOIDD_MOD_LUA, IF_REAL, "Length dependence of ua"),
IOP( "lub", B3SOIDD_MOD_LUB, IF_REAL, "Length dependence of ub"),
IOP( "luc", B3SOIDD_MOD_LUC, IF_REAL, "Length dependence of uc"),
IOP( "lvsat", B3SOIDD_MOD_LVSAT, IF_REAL, "Length dependence of vsat"),
IOP( "la0", B3SOIDD_MOD_LA0, IF_REAL, "Length dependence of a0"),
IOP( "lags", B3SOIDD_MOD_LAGS, IF_REAL, "Length dependence of ags"),
IOP( "lb0", B3SOIDD_MOD_LB0, IF_REAL, "Length dependence of b0"),
IOP( "lb1", B3SOIDD_MOD_LB1, IF_REAL, "Length dependence of b1"),
IOP( "lketa", B3SOIDD_MOD_LKETA, IF_REAL, "Length dependence of keta"),
IOP( "labp", B3SOIDD_MOD_LABP, IF_REAL, "Length dependence of abp"),
IOP( "lmxc", B3SOIDD_MOD_LMXC, IF_REAL, "Length dependence of mxc"),
IOP( "ladice0", B3SOIDD_MOD_LADICE0, IF_REAL, "Length dependence of adice0"),
IOP( "la1", B3SOIDD_MOD_LA1, IF_REAL, "Length dependence of a1"),
IOP( "la2", B3SOIDD_MOD_LA2, IF_REAL, "Length dependence of a2"),
IOP( "lrdsw", B3SOIDD_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "),
IOP( "lprwb", B3SOIDD_MOD_LPRWB, IF_REAL, "Length dependence of prwb "),
IOP( "lprwg", B3SOIDD_MOD_LPRWG, IF_REAL, "Length dependence of prwg "),
IOP( "lwr", B3SOIDD_MOD_LWR, IF_REAL, "Length dependence of wr"),
IOP( "lnfactor", B3SOIDD_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"),
IOP( "ldwg", B3SOIDD_MOD_LDWG, IF_REAL, "Length dependence of dwg"),
IOP( "ldwb", B3SOIDD_MOD_LDWB, IF_REAL, "Length dependence of dwb"),
IOP( "lvoff", B3SOIDD_MOD_LVOFF, IF_REAL, "Length dependence of voff"),
IOP( "leta0", B3SOIDD_MOD_LETA0, IF_REAL, "Length dependence of eta0"),
IOP( "letab", B3SOIDD_MOD_LETAB, IF_REAL, "Length dependence of etab"),
IOP( "ldsub", B3SOIDD_MOD_LDSUB, IF_REAL, "Length dependence of dsub"),
IOP( "lcit", B3SOIDD_MOD_LCIT, IF_REAL, "Length dependence of cit"),
IOP( "lcdsc", B3SOIDD_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"),
IOP( "lcdscb", B3SOIDD_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"),
IOP( "lcdscd", B3SOIDD_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"),
IOP( "lpclm", B3SOIDD_MOD_LPCLM, IF_REAL, "Length dependence of pclm"),
IOP( "lpdiblc1", B3SOIDD_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"),
IOP( "lpdiblc2", B3SOIDD_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"),
IOP( "lpdiblcb", B3SOIDD_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"),
IOP( "ldrout", B3SOIDD_MOD_LDROUT, IF_REAL, "Length dependence of drout"),
IOP( "lpvag", B3SOIDD_MOD_LPVAG, IF_REAL, "Length dependence of pvag"),
IOP( "ldelta", B3SOIDD_MOD_LDELTA, IF_REAL, "Length dependence of delta"),
IOP( "laii", B3SOIDD_MOD_LAII, IF_REAL, "Length dependence of aii"),
IOP( "lbii", B3SOIDD_MOD_LBII, IF_REAL, "Length dependence of bii"),
IOP( "lcii", B3SOIDD_MOD_LCII, IF_REAL, "Length dependence of cii"),
IOP( "ldii", B3SOIDD_MOD_LDII, IF_REAL, "Length dependence of dii"),
IOP( "lalpha0", B3SOIDD_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"),
IOP( "lalpha1", B3SOIDD_MOD_LALPHA1, IF_REAL, "Length dependence of alpha1"),
IOP( "lbeta0", B3SOIDD_MOD_LBETA0, IF_REAL, "Length dependence of beta0"),
IOP( "lagidl", B3SOIDD_MOD_LAGIDL, IF_REAL, "Length dependence of agidl"),
IOP( "lbgidl", B3SOIDD_MOD_LBGIDL, IF_REAL, "Length dependence of bgidl"),
IOP( "lngidl", B3SOIDD_MOD_LNGIDL, IF_REAL, "Length dependence of ngidl"),
IOP( "lntun", B3SOIDD_MOD_LNTUN, IF_REAL, "Length dependence of ntun"),
IOP( "lndiode", B3SOIDD_MOD_LNDIODE, IF_REAL, "Length dependence of ndiode"),
IOP( "lisbjt", B3SOIDD_MOD_LISBJT, IF_REAL, "Length dependence of isbjt"),
IOP( "lisdif", B3SOIDD_MOD_LISDIF, IF_REAL, "Length dependence of isdif"),
IOP( "lisrec", B3SOIDD_MOD_LISREC, IF_REAL, "Length dependence of isrec"),
IOP( "listun", B3SOIDD_MOD_LISTUN, IF_REAL, "Length dependence of istun"),
IOP( "ledl", B3SOIDD_MOD_LEDL, IF_REAL, "Length dependence of edl"),
IOP( "lkbjt1", B3SOIDD_MOD_LKBJT1, IF_REAL, "Length dependence of kbjt1"),
IOP( "lvsdfb", B3SOIDD_MOD_LVSDFB, IF_REAL, "Length dependence of vsdfb"),
IOP( "lvsdth", B3SOIDD_MOD_LVSDTH, IF_REAL, "Length dependence of vsdth"),
/* Width Dependence */
IOP( "wnch", B3SOIDD_MOD_WNPEAK, IF_REAL, "Width dependence of nch"),
IOP( "wnsub", B3SOIDD_MOD_WNSUB, IF_REAL, "Width dependence of nsub"),
IOP( "wngate", B3SOIDD_MOD_WNGATE, IF_REAL, "Width dependence of ngate"),
IOP( "wvth0", B3SOIDD_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOP( "wk1", B3SOIDD_MOD_WK1, IF_REAL, "Width dependence of k1"),
IOP( "wk2", B3SOIDD_MOD_WK2, IF_REAL, "Width dependence of k2"),
IOP( "wk3", B3SOIDD_MOD_WK3, IF_REAL, "Width dependence of k3"),
IOP( "wk3b", B3SOIDD_MOD_WK3B, IF_REAL, "Width dependence of k3b"),
IOP( "wvbsa", B3SOIDD_MOD_WVBSA, IF_REAL, "Width dependence of vbsa"),
IOP( "wdelp", B3SOIDD_MOD_WDELP, IF_REAL, "Width dependence of delp"),
IOP( "wkb1", B3SOIDD_MOD_WKB1, IF_REAL, "Width dependence of kb1"),
IOP( "wkb3", B3SOIDD_MOD_WKB3, IF_REAL, "Width dependence of kb3"),
IOP( "wdvbd0", B3SOIDD_MOD_WDVBD0, IF_REAL, "Width dependence of dvbd0"),
IOP( "wdvbd1", B3SOIDD_MOD_WDVBD1, IF_REAL, "Width dependence of dvbd1"),
IOP( "ww0", B3SOIDD_MOD_WW0, IF_REAL, "Width dependence of w0"),
IOP( "wnlx", B3SOIDD_MOD_WNLX, IF_REAL, "Width dependence of nlx"),
IOP( "wdvt0", B3SOIDD_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"),
IOP( "wdvt1", B3SOIDD_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"),
IOP( "wdvt2", B3SOIDD_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"),
IOP( "wdvt0w", B3SOIDD_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"),
IOP( "wdvt1w", B3SOIDD_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"),
IOP( "wdvt2w", B3SOIDD_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"),
IOP( "wu0", B3SOIDD_MOD_WU0, IF_REAL, "Width dependence of u0"),
IOP( "wua", B3SOIDD_MOD_WUA, IF_REAL, "Width dependence of ua"),
IOP( "wub", B3SOIDD_MOD_WUB, IF_REAL, "Width dependence of ub"),
IOP( "wuc", B3SOIDD_MOD_WUC, IF_REAL, "Width dependence of uc"),
IOP( "wvsat", B3SOIDD_MOD_WVSAT, IF_REAL, "Width dependence of vsat"),
IOP( "wa0", B3SOIDD_MOD_WA0, IF_REAL, "Width dependence of a0"),
IOP( "wags", B3SOIDD_MOD_WAGS, IF_REAL, "Width dependence of ags"),
IOP( "wb0", B3SOIDD_MOD_WB0, IF_REAL, "Width dependence of b0"),
IOP( "wb1", B3SOIDD_MOD_WB1, IF_REAL, "Width dependence of b1"),
IOP( "wketa", B3SOIDD_MOD_WKETA, IF_REAL, "Width dependence of keta"),
IOP( "wabp", B3SOIDD_MOD_WABP, IF_REAL, "Width dependence of abp"),
IOP( "wmxc", B3SOIDD_MOD_WMXC, IF_REAL, "Width dependence of mxc"),
IOP( "wadice0", B3SOIDD_MOD_WADICE0, IF_REAL, "Width dependence of adice0"),
IOP( "wa1", B3SOIDD_MOD_WA1, IF_REAL, "Width dependence of a1"),
IOP( "wa2", B3SOIDD_MOD_WA2, IF_REAL, "Width dependence of a2"),
IOP( "wrdsw", B3SOIDD_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "),
IOP( "wprwb", B3SOIDD_MOD_WPRWB, IF_REAL, "Width dependence of prwb "),
IOP( "wprwg", B3SOIDD_MOD_WPRWG, IF_REAL, "Width dependence of prwg "),
IOP( "wwr", B3SOIDD_MOD_WWR, IF_REAL, "Width dependence of wr"),
IOP( "wnfactor", B3SOIDD_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"),
IOP( "wdwg", B3SOIDD_MOD_WDWG, IF_REAL, "Width dependence of dwg"),
IOP( "wdwb", B3SOIDD_MOD_WDWB, IF_REAL, "Width dependence of dwb"),
IOP( "wvoff", B3SOIDD_MOD_WVOFF, IF_REAL, "Width dependence of voff"),
IOP( "weta0", B3SOIDD_MOD_WETA0, IF_REAL, "Width dependence of eta0"),
IOP( "wetab", B3SOIDD_MOD_WETAB, IF_REAL, "Width dependence of etab"),
IOP( "wdsub", B3SOIDD_MOD_WDSUB, IF_REAL, "Width dependence of dsub"),
IOP( "wcit", B3SOIDD_MOD_WCIT, IF_REAL, "Width dependence of cit"),
IOP( "wcdsc", B3SOIDD_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"),
IOP( "wcdscb", B3SOIDD_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"),
IOP( "wcdscd", B3SOIDD_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"),
IOP( "wpclm", B3SOIDD_MOD_WPCLM, IF_REAL, "Width dependence of pclm"),
IOP( "wpdiblc1", B3SOIDD_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"),
IOP( "wpdiblc2", B3SOIDD_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"),
IOP( "wpdiblcb", B3SOIDD_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"),
IOP( "wdrout", B3SOIDD_MOD_WDROUT, IF_REAL, "Width dependence of drout"),
IOP( "wpvag", B3SOIDD_MOD_WPVAG, IF_REAL, "Width dependence of pvag"),
IOP( "wdelta", B3SOIDD_MOD_WDELTA, IF_REAL, "Width dependence of delta"),
IOP( "waii", B3SOIDD_MOD_WAII, IF_REAL, "Width dependence of aii"),
IOP( "wbii", B3SOIDD_MOD_WBII, IF_REAL, "Width dependence of bii"),
IOP( "wcii", B3SOIDD_MOD_WCII, IF_REAL, "Width dependence of cii"),
IOP( "wdii", B3SOIDD_MOD_WDII, IF_REAL, "Width dependence of dii"),
IOP( "walpha0", B3SOIDD_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"),
IOP( "walpha1", B3SOIDD_MOD_WALPHA1, IF_REAL, "Width dependence of alpha1"),
IOP( "wbeta0", B3SOIDD_MOD_WBETA0, IF_REAL, "Width dependence of beta0"),
IOP( "wagidl", B3SOIDD_MOD_WAGIDL, IF_REAL, "Width dependence of agidl"),
IOP( "wbgidl", B3SOIDD_MOD_WBGIDL, IF_REAL, "Width dependence of bgidl"),
IOP( "wngidl", B3SOIDD_MOD_WNGIDL, IF_REAL, "Width dependence of ngidl"),
IOP( "wntun", B3SOIDD_MOD_WNTUN, IF_REAL, "Width dependence of ntun"),
IOP( "wndiode", B3SOIDD_MOD_WNDIODE, IF_REAL, "Width dependence of ndiode"),
IOP( "wisbjt", B3SOIDD_MOD_WISBJT, IF_REAL, "Width dependence of isbjt"),
IOP( "wisdif", B3SOIDD_MOD_WISDIF, IF_REAL, "Width dependence of isdif"),
IOP( "wisrec", B3SOIDD_MOD_WISREC, IF_REAL, "Width dependence of isrec"),
IOP( "wistun", B3SOIDD_MOD_WISTUN, IF_REAL, "Width dependence of istun"),
IOP( "wedl", B3SOIDD_MOD_WEDL, IF_REAL, "Width dependence of edl"),
IOP( "wkbjt1", B3SOIDD_MOD_WKBJT1, IF_REAL, "Width dependence of kbjt1"),
IOP( "wvsdfb", B3SOIDD_MOD_WVSDFB, IF_REAL, "Width dependence of vsdfb"),
IOP( "wvsdth", B3SOIDD_MOD_WVSDTH, IF_REAL, "Width dependence of vsdth"),
/* Cross-term Dependence */
IOP( "pnch", B3SOIDD_MOD_PNPEAK, IF_REAL, "Cross-term dependence of nch"),
IOP( "pnsub", B3SOIDD_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"),
IOP( "pngate", B3SOIDD_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"),
IOP( "pvth0", B3SOIDD_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOP( "pk1", B3SOIDD_MOD_PK1, IF_REAL, "Cross-term dependence of k1"),
IOP( "pk2", B3SOIDD_MOD_PK2, IF_REAL, "Cross-term dependence of k2"),
IOP( "pk3", B3SOIDD_MOD_PK3, IF_REAL, "Cross-term dependence of k3"),
IOP( "pk3b", B3SOIDD_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"),
IOP( "pvbsa", B3SOIDD_MOD_PVBSA, IF_REAL, "Cross-term dependence of vbsa"),
IOP( "pdelp", B3SOIDD_MOD_PDELP, IF_REAL, "Cross-term dependence of delp"),
IOP( "pkb1", B3SOIDD_MOD_PKB1, IF_REAL, "Cross-term dependence of kb1"),
IOP( "pkb3", B3SOIDD_MOD_PKB3, IF_REAL, "Cross-term dependence of kb3"),
IOP( "pdvbd0", B3SOIDD_MOD_PDVBD0, IF_REAL, "Cross-term dependence of dvbd0"),
IOP( "pdvbd1", B3SOIDD_MOD_PDVBD1, IF_REAL, "Cross-term dependence of dvbd1"),
IOP( "pw0", B3SOIDD_MOD_PW0, IF_REAL, "Cross-term dependence of w0"),
IOP( "pnlx", B3SOIDD_MOD_PNLX, IF_REAL, "Cross-term dependence of nlx"),
IOP( "pdvt0", B3SOIDD_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"),
IOP( "pdvt1", B3SOIDD_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"),
IOP( "pdvt2", B3SOIDD_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"),
IOP( "pdvt0w", B3SOIDD_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"),
IOP( "pdvt1w", B3SOIDD_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"),
IOP( "pdvt2w", B3SOIDD_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"),
IOP( "pu0", B3SOIDD_MOD_PU0, IF_REAL, "Cross-term dependence of u0"),
IOP( "pua", B3SOIDD_MOD_PUA, IF_REAL, "Cross-term dependence of ua"),
IOP( "pub", B3SOIDD_MOD_PUB, IF_REAL, "Cross-term dependence of ub"),
IOP( "puc", B3SOIDD_MOD_PUC, IF_REAL, "Cross-term dependence of uc"),
IOP( "pvsat", B3SOIDD_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"),
IOP( "pa0", B3SOIDD_MOD_PA0, IF_REAL, "Cross-term dependence of a0"),
IOP( "pags", B3SOIDD_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"),
IOP( "pb0", B3SOIDD_MOD_PB0, IF_REAL, "Cross-term dependence of b0"),
IOP( "pb1", B3SOIDD_MOD_PB1, IF_REAL, "Cross-term dependence of b1"),
IOP( "pketa", B3SOIDD_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"),
IOP( "pabp", B3SOIDD_MOD_PABP, IF_REAL, "Cross-term dependence of abp"),
IOP( "pmxc", B3SOIDD_MOD_PMXC, IF_REAL, "Cross-term dependence of mxc"),
IOP( "padice0", B3SOIDD_MOD_PADICE0, IF_REAL, "Cross-term dependence of adice0"),
IOP( "pa1", B3SOIDD_MOD_PA1, IF_REAL, "Cross-term dependence of a1"),
IOP( "pa2", B3SOIDD_MOD_PA2, IF_REAL, "Cross-term dependence of a2"),
IOP( "prdsw", B3SOIDD_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "),
IOP( "pprwb", B3SOIDD_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "),
IOP( "pprwg", B3SOIDD_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "),
IOP( "pwr", B3SOIDD_MOD_PWR, IF_REAL, "Cross-term dependence of wr"),
IOP( "pnfactor", B3SOIDD_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"),
IOP( "pdwg", B3SOIDD_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"),
IOP( "pdwb", B3SOIDD_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"),
IOP( "pvoff", B3SOIDD_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"),
IOP( "peta0", B3SOIDD_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"),
IOP( "petab", B3SOIDD_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"),
IOP( "pdsub", B3SOIDD_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"),
IOP( "pcit", B3SOIDD_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"),
IOP( "pcdsc", B3SOIDD_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"),
IOP( "pcdscb", B3SOIDD_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"),
IOP( "pcdscd", B3SOIDD_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"),
IOP( "ppclm", B3SOIDD_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"),
IOP( "ppdiblc1", B3SOIDD_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"),
IOP( "ppdiblc2", B3SOIDD_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"),
IOP( "ppdiblcb", B3SOIDD_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"),
IOP( "pdrout", B3SOIDD_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"),
IOP( "ppvag", B3SOIDD_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"),
IOP( "pdelta", B3SOIDD_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"),
IOP( "paii", B3SOIDD_MOD_PAII, IF_REAL, "Cross-term dependence of aii"),
IOP( "pbii", B3SOIDD_MOD_PBII, IF_REAL, "Cross-term dependence of bii"),
IOP( "pcii", B3SOIDD_MOD_PCII, IF_REAL, "Cross-term dependence of cii"),
IOP( "pdii", B3SOIDD_MOD_PDII, IF_REAL, "Cross-term dependence of dii"),
IOP( "palpha0", B3SOIDD_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"),
IOP( "palpha1", B3SOIDD_MOD_PALPHA1, IF_REAL, "Cross-term dependence of alpha1"),
IOP( "pbeta0", B3SOIDD_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"),
IOP( "pagidl", B3SOIDD_MOD_PAGIDL, IF_REAL, "Cross-term dependence of agidl"),
IOP( "pbgidl", B3SOIDD_MOD_PBGIDL, IF_REAL, "Cross-term dependence of bgidl"),
IOP( "pngidl", B3SOIDD_MOD_PNGIDL, IF_REAL, "Cross-term dependence of ngidl"),
IOP( "pntun", B3SOIDD_MOD_PNTUN, IF_REAL, "Cross-term dependence of ntun"),
IOP( "pndiode", B3SOIDD_MOD_PNDIODE, IF_REAL, "Cross-term dependence of ndiode"),
IOP( "pisbjt", B3SOIDD_MOD_PISBJT, IF_REAL, "Cross-term dependence of isbjt"),
IOP( "pisdif", B3SOIDD_MOD_PISDIF, IF_REAL, "Cross-term dependence of isdif"),
IOP( "pisrec", B3SOIDD_MOD_PISREC, IF_REAL, "Cross-term dependence of isrec"),
IOP( "pistun", B3SOIDD_MOD_PISTUN, IF_REAL, "Cross-term dependence of istun"),
IOP( "pedl", B3SOIDD_MOD_PEDL, IF_REAL, "Cross-term dependence of edl"),
IOP( "pkbjt1", B3SOIDD_MOD_PKBJT1, IF_REAL, "Cross-term dependence of kbjt1"),
IOP( "pvsdfb", B3SOIDD_MOD_PVSDFB, IF_REAL, "Cross-term dependence of vsdfb"),
IOP( "pvsdth", B3SOIDD_MOD_PVSDTH, IF_REAL, "Cross-term dependence of vsdth"),
/* Added for binning - END */
IP( "nmos", B3SOIDD_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"),
IP( "pmos", B3SOIDD_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"),
};
char *B3SOIDDnames[] = {
"Drain",
"Gate",
"Source",
"Backgate",
"",
"Body",
"Temp",
"Charge",
};
int B3SOIDDnSize = NUMELEMS(B3SOIDDnames);
int B3SOIDDpTSize = NUMELEMS(B3SOIDDpTable);
int B3SOIDDmPTSize = NUMELEMS(B3SOIDDmPTable);
int B3SOIDDiSize = sizeof(B3SOIDDinstance);
int B3SOIDDmSize = sizeof(B3SOIDDmodel);

462
src/spicelib/devices/bsim3soi_dd/b3soiddacld.c Normal file
View File

@ -0,0 +1,462 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: Weidong Liu and Pin Su Feb 1999
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiddacld.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "b3soidddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIDDacLoad(inModel,ckt)
GENmodel *inModel;
register CKTcircuit *ckt;
{
register B3SOIDDmodel *model = (B3SOIDDmodel*)inModel;
register B3SOIDDinstance *here;
register int selfheat;
double xcggb, xcgdb, xcgsb, xcgeb, xcgT;
double xcdgb, xcddb, xcdsb, xcdeb, xcdT;
double xcsgb, xcsdb, xcssb, xcseb, xcsT;
double xcbgb, xcbdb, xcbsb, xcbeb, xcbT;
double xcegb, xcedb, xcesb, xceeb, xceT;
double gdpr, gspr, gds;
double cggb, cgdb, cgsb, cgeb, cgT;
double cdgb, cddb, cdsb, cdeb, cdT;
double cbgb, cbdb, cbsb, cbeb, cbT;
double cegb, cedb, cesb, ceeb, ceT;
double GSoverlapCap, GDoverlapCap, GEoverlapCap, FwdSum, RevSum, Gm, Gmbs, Gme, GmT;
double omega;
double dxpart, sxpart;
double gbbg, gbbdp, gbbb, gbbe, gbbp, gbbsp, gbbT;
double gddpg, gddpdp, gddpsp, gddpb, gddpe, gddpT;
double gsspg, gsspdp, gsspsp, gsspb, gsspe, gsspT;
double gppg, gppdp, gppb, gppe, gppp, gppsp, gppT;
double xcTt, cTt, gcTt, gTtt, gTtg, gTtb, gTte, gTtdp, gTtsp;
double Dum1, Dum2, Dum3, Dum4, Dum5;
FILE *fpdebug;
omega = ckt->CKTomega;
for (; model != NULL; model = model->B3SOIDDnextModel)
{
for (here = model->B3SOIDDinstances; here!= NULL;
here = here->B3SOIDDnextInstance)
{
selfheat = (model->B3SOIDDshMod == 1) && (here->B3SOIDDrth0 != 0.0);
if (here->B3SOIDDdebugMod > 2)
{
fpdebug = fopen("b3soiDDac.log", "a");
fprintf(fpdebug, ".......omega=%.5e\n", omega);
}
if (here->B3SOIDDmode >= 0)
{ Gm = here->B3SOIDDgm;
Gmbs = here->B3SOIDDgmbs;
Gme = here->B3SOIDDgme;
GmT = model->B3SOIDDtype * here->B3SOIDDgmT;
FwdSum = Gm + Gmbs + Gme;
RevSum = 0.0;
cbgb = here->B3SOIDDcbgb;
cbsb = here->B3SOIDDcbsb;
cbdb = here->B3SOIDDcbdb;
cbeb = here->B3SOIDDcbeb;
cbT = model->B3SOIDDtype * here->B3SOIDDcbT;
cegb = here->B3SOIDDcegb;
cesb = here->B3SOIDDcesb;
cedb = here->B3SOIDDcedb;
ceeb = here->B3SOIDDceeb;
ceT = model->B3SOIDDtype * here->B3SOIDDceT;
cggb = here->B3SOIDDcggb;
cgsb = here->B3SOIDDcgsb;
cgdb = here->B3SOIDDcgdb;
cgeb = here->B3SOIDDcgeb;
cgT = model->B3SOIDDtype * here->B3SOIDDcgT;
cdgb = here->B3SOIDDcdgb;
cdsb = here->B3SOIDDcdsb;
cddb = here->B3SOIDDcddb;
cdeb = here->B3SOIDDcdeb;
cdT = model->B3SOIDDtype * here->B3SOIDDcdT;
cTt = here->pParam->B3SOIDDcth;
gbbg = -here->B3SOIDDgbgs;
gbbdp = -here->B3SOIDDgbds;
gbbb = -here->B3SOIDDgbbs;
gbbe = -here->B3SOIDDgbes;
gbbp = -here->B3SOIDDgbps;
gbbT = -model->B3SOIDDtype * here->B3SOIDDgbT;
gbbsp = - ( gbbg + gbbdp + gbbb + gbbe + gbbp);
gddpg = -here->B3SOIDDgjdg;
gddpdp = -here->B3SOIDDgjdd;
gddpb = -here->B3SOIDDgjdb;
gddpe = -here->B3SOIDDgjde;
gddpT = -model->B3SOIDDtype * here->B3SOIDDgjdT;
gddpsp = - ( gddpg + gddpdp + gddpb + gddpe);
gsspg = -here->B3SOIDDgjsg;
gsspdp = -here->B3SOIDDgjsd;
gsspb = -here->B3SOIDDgjsb;
gsspe = 0.0;
gsspT = -model->B3SOIDDtype * here->B3SOIDDgjsT;
gsspsp = - (gsspg + gsspdp + gsspb + gsspe);
gppg = -here->B3SOIDDgbpgs;
gppdp = -here->B3SOIDDgbpds;
gppb = -here->B3SOIDDgbpbs;
gppe = -here->B3SOIDDgbpes;
gppp = -here->B3SOIDDgbpps;
gppT = -model->B3SOIDDtype * here->B3SOIDDgbpT;
gppsp = - (gppg + gppdp + gppb + gppe + gppp);
gTtg = here->B3SOIDDgtempg;
gTtb = here->B3SOIDDgtempb;
gTte = here->B3SOIDDgtempe;
gTtdp = here->B3SOIDDgtempd;
gTtt = here->B3SOIDDgtempT;
gTtsp = - (gTtg + gTtb + gTte + gTtdp);
sxpart = 0.6;
dxpart = 0.4;
}
else
{ Gm = -here->B3SOIDDgm;
Gmbs = -here->B3SOIDDgmbs;
Gme = -here->B3SOIDDgme;
GmT = -model->B3SOIDDtype * here->B3SOIDDgmT;
FwdSum = 0.0;
RevSum = -Gm - Gmbs - Gme;
cdgb = - (here->B3SOIDDcdgb + here->B3SOIDDcggb + here->B3SOIDDcbgb
+ here->B3SOIDDcegb);
cdsb = - (here->B3SOIDDcddb + here->B3SOIDDcgdb + here->B3SOIDDcbdb
+ here->B3SOIDDcedb);
cddb = - (here->B3SOIDDcdsb + here->B3SOIDDcgsb + here->B3SOIDDcbsb
+ here->B3SOIDDcesb);
cdeb = - (here->B3SOIDDcdeb + here->B3SOIDDcgeb + here->B3SOIDDcbeb
+ here->B3SOIDDceeb);
cdT = - model->B3SOIDDtype * (here->B3SOIDDcgT + here->B3SOIDDcbT
+ here->B3SOIDDcdT + here->B3SOIDDceT);
cegb = here->B3SOIDDcegb;
cesb = here->B3SOIDDcedb;
cedb = here->B3SOIDDcesb;
ceeb = here->B3SOIDDceeb;
ceT = model->B3SOIDDtype * here->B3SOIDDceT;
cggb = here->B3SOIDDcggb;
cgsb = here->B3SOIDDcgdb;
cgdb = here->B3SOIDDcgsb;
cgeb = here->B3SOIDDcgeb;
cgT = model->B3SOIDDtype * here->B3SOIDDcgT;
cbgb = here->B3SOIDDcbgb;
cbsb = here->B3SOIDDcbdb;
cbdb = here->B3SOIDDcbsb;
cbeb = here->B3SOIDDcbeb;
cbT = model->B3SOIDDtype * here->B3SOIDDcbT;
cTt = here->pParam->B3SOIDDcth;
gbbg = -here->B3SOIDDgbgs;
gbbb = -here->B3SOIDDgbbs;
gbbe = -here->B3SOIDDgbes;
gbbp = -here->B3SOIDDgbps;
gbbsp = -here->B3SOIDDgbds;
gbbT = -model->B3SOIDDtype * here->B3SOIDDgbT;
gbbdp = - ( gbbg + gbbsp + gbbb + gbbe + gbbp);
gddpg = -here->B3SOIDDgjsg;
gddpsp = -here->B3SOIDDgjsd;
gddpb = -here->B3SOIDDgjsb;
gddpe = 0.0;
gddpT = -model->B3SOIDDtype * here->B3SOIDDgjsT;
gddpdp = - (gddpg + gddpsp + gddpb + gddpe);
gsspg = -here->B3SOIDDgjdg;
gsspsp = -here->B3SOIDDgjdd;
gsspb = -here->B3SOIDDgjdb;
gsspe = -here->B3SOIDDgjde;
gsspT = -model->B3SOIDDtype * here->B3SOIDDgjdT;
gsspdp = - ( gsspg + gsspsp + gsspb + gsspe);
gppg = -here->B3SOIDDgbpgs;
gppsp = -here->B3SOIDDgbpds;
gppb = -here->B3SOIDDgbpbs;
gppe = -here->B3SOIDDgbpes;
gppp = -here->B3SOIDDgbpps;
gppT = -model->B3SOIDDtype * here->B3SOIDDgbpT;
gppdp = - (gppg + gppsp + gppb + gppe + gppp);
gTtt = here->B3SOIDDgtempT;
gTtg = here->B3SOIDDgtempg;
gTtb = here->B3SOIDDgtempb;
gTte = here->B3SOIDDgtempe;
gTtdp = here->B3SOIDDgtempd;
gTtsp = - (gTtt + gTtg + gTtb + gTte + gTtdp);
gTtg = here->B3SOIDDgtempg;
gTtb = here->B3SOIDDgtempb;
gTte = here->B3SOIDDgtempe;
gTtsp = here->B3SOIDDgtempd;
gTtt = here->B3SOIDDgtempT;
gTtdp = - (gTtg + gTtb + gTte + gTtsp);
sxpart = 0.6;
sxpart = 0.4;
dxpart = 0.6;
}
gdpr=here->B3SOIDDdrainConductance;
gspr=here->B3SOIDDsourceConductance;
gds= here->B3SOIDDgds;
GSoverlapCap = here->B3SOIDDcgso;
GDoverlapCap = here->B3SOIDDcgdo;
GEoverlapCap = here->pParam->B3SOIDDcgeo;
xcegb = (cegb - GEoverlapCap) * omega;
xcedb = cedb * omega;
xcesb = cesb * omega;
xceeb = (ceeb + GEoverlapCap) * omega;
xceT = ceT * omega;
xcggb = (cggb + GDoverlapCap + GSoverlapCap + GEoverlapCap)
* omega;
xcgdb = (cgdb - GDoverlapCap ) * omega;
xcgsb = (cgsb - GSoverlapCap) * omega;
xcgeb = (cgeb - GEoverlapCap) * omega;
xcgT = cgT * omega;
xcdgb = (cdgb - GDoverlapCap) * omega;
xcddb = (cddb + GDoverlapCap) * omega;
xcdsb = cdsb * omega;
xcdeb = cdeb * omega;
xcdT = cdT * omega;
xcsgb = -(cggb + cbgb + cdgb + cegb + GSoverlapCap) * omega;
xcsdb = -(cgdb + cbdb + cddb + cedb) * omega;
xcssb = (GSoverlapCap - (cgsb + cbsb + cdsb + cesb)) * omega;
xcseb = -(cgeb + cbeb + cdeb + ceeb) * omega;
xcsT = -(cgT + cbT + cdT + ceT) * omega;
xcbgb = cbgb * omega;
xcbdb = cbdb * omega;
xcbsb = cbsb * omega;
xcbeb = cbeb * omega;
xcbT = cbT * omega;
xcTt = cTt * omega;
*(here->B3SOIDDEgPtr +1) += xcegb;
*(here->B3SOIDDEdpPtr +1) += xcedb;
*(here->B3SOIDDEspPtr +1) += xcesb;
*(here->B3SOIDDGePtr +1) += xcgeb;
*(here->B3SOIDDDPePtr +1) += xcdeb;
*(here->B3SOIDDSPePtr +1) += xcseb;
*(here->B3SOIDDEePtr +1) += xceeb;
*(here->B3SOIDDGgPtr +1) += xcggb;
*(here->B3SOIDDGdpPtr +1) += xcgdb;
*(here->B3SOIDDGspPtr +1) += xcgsb;
*(here->B3SOIDDDPgPtr +1) += xcdgb;
*(here->B3SOIDDDPdpPtr +1) += xcddb;
*(here->B3SOIDDDPspPtr +1) += xcdsb;
*(here->B3SOIDDSPgPtr +1) += xcsgb;
*(here->B3SOIDDSPdpPtr +1) += xcsdb;
*(here->B3SOIDDSPspPtr +1) += xcssb;
*(here->B3SOIDDBePtr +1) += xcbeb;
*(here->B3SOIDDBgPtr +1) += xcbgb;
*(here->B3SOIDDBdpPtr +1) += xcbdb;
*(here->B3SOIDDBspPtr +1) += xcbsb;
*(here->B3SOIDDEbPtr +1) -= xcegb + xcedb + xcesb + xceeb;
*(here->B3SOIDDGbPtr +1) -= xcggb + xcgdb + xcgsb + xcgeb;
*(here->B3SOIDDDPbPtr +1) -= xcdgb + xcddb + xcdsb + xcdeb;
*(here->B3SOIDDSPbPtr +1) -= xcsgb + xcsdb + xcssb + xcseb;
*(here->B3SOIDDBbPtr +1) -= xcbgb + xcbdb + xcbsb + xcbeb;
if (selfheat)
{
*(here->B3SOIDDTemptempPtr + 1) += xcTt;
*(here->B3SOIDDDPtempPtr + 1) += xcdT;
*(here->B3SOIDDSPtempPtr + 1) += xcsT;
*(here->B3SOIDDBtempPtr + 1) += xcbT;
*(here->B3SOIDDEtempPtr + 1) += xceT;
*(here->B3SOIDDGtempPtr + 1) += xcgT;
}
if (here->B3SOIDDdebugMod > 3)
{
fprintf(fpdebug, "Cbg+Cbs+Cbe = %.5e; Cbd = %.5e;\n",
(xcbgb+xcbsb+xcbeb)/omega, xcbdb/omega);
fprintf(fpdebug, "gbs = %.5e; gbd = %.5e\n", gbbsp, gbbdp);
fprintf(fpdebug, "AC condunctance...\n");
fprintf(fpdebug, "Eg=%.5e; Edp=%.5e; Esp=%.5e;\nEb=%.5e; Ee=%.5e\n",
xcegb, xcedb, xcesb, -(xcegb+xcedb+xcesb+xceeb), xceeb);
fprintf(fpdebug, "Gg=%.5e; Gdp=%.5e; Gsp=%.5e;\nGb=%.5e; Ge=%.5e\n",
xcggb, xcgdb, xcgsb, -(xcggb+xcgdb+xcgsb+xcgeb), xcgeb);
fprintf(fpdebug, "Bg=%.5e; Bdp=%.5e; Bsp=%.5e;\nBb=%.5e; Be=%.5e\n",
xcbgb, xcbdb, xcbsb, -(xcbgb+xcbdb+xcbsb+xcbeb), xcbeb);
fprintf(fpdebug, "DPg=%.5e; DPdp=%.5e; DPsp=%.5e;\nDPb=%.5e; DPe=%.5e\n",
xcdgb, xcddb, xcdsb, -(xcdgb+xcddb+xcdsb+xcdeb), xcdeb);
fprintf(fpdebug, "SPg=%.5e; SPdp=%.5e; SPsp=%.5e;\nSPb=%.5e; SPe=%.5e\n",
xcsgb, xcsdb, xcssb, -(xcsgb+xcsdb+xcssb+xcseb), xcseb);
}
*(here->B3SOIDDEgPtr) += 0.0;
*(here->B3SOIDDEdpPtr) += 0.0;
*(here->B3SOIDDEspPtr) += 0.0;
*(here->B3SOIDDGePtr) -= 0.0;
*(here->B3SOIDDDPePtr) += Gme + gddpe;
*(here->B3SOIDDSPePtr) += gsspe - Gme;
*(here->B3SOIDDEePtr) += 0.0;
*(here->B3SOIDDDPgPtr) += Gm + gddpg;
*(here->B3SOIDDDPdpPtr) += gdpr + gds + gddpdp + RevSum ;
*(here->B3SOIDDDPspPtr) -= gds + FwdSum - gddpsp;
*(here->B3SOIDDDPdPtr) -= gdpr;
*(here->B3SOIDDSPgPtr) -= Gm - gsspg;
*(here->B3SOIDDSPdpPtr) -= gds + RevSum - gsspdp;
*(here->B3SOIDDSPspPtr) += gspr + gds + FwdSum + gsspsp;
*(here->B3SOIDDSPsPtr) -= gspr;
*(here->B3SOIDDBePtr) += gbbe;
*(here->B3SOIDDBgPtr) += gbbg;
*(here->B3SOIDDBdpPtr) += gbbdp;
*(here->B3SOIDDBspPtr) += gbbsp;
*(here->B3SOIDDBbPtr) += gbbb;
*(here->B3SOIDDEbPtr) += 0.0;
*(here->B3SOIDDSPbPtr) -= Gmbs - gsspb;
*(here->B3SOIDDDPbPtr) -= (-gddpb - Gmbs);
if (selfheat)
{
*(here->B3SOIDDDPtempPtr) += GmT + gddpT;
*(here->B3SOIDDSPtempPtr) += -GmT + gsspT;
*(here->B3SOIDDBtempPtr) += gbbT;
if (here->B3SOIDDbodyMod == 1) {
(*(here->B3SOIDDPtempPtr) += gppT);
}
*(here->B3SOIDDTemptempPtr) += gTtt + 1/here->pParam->B3SOIDDrth;
*(here->B3SOIDDTempgPtr) += gTtg;
*(here->B3SOIDDTempbPtr) += gTtb;
*(here->B3SOIDDTempePtr) += gTte;
*(here->B3SOIDDTempdpPtr) += gTtdp;
*(here->B3SOIDDTempspPtr) += gTtsp;
}
if (here->B3SOIDDdebugMod > 3)
{
fprintf(fpdebug, "Static condunctance...\n");
fprintf(fpdebug, "Gg=%.5e; Gdp=%.5e; Gsp=%.5e;\nGb=%.5e; Ge=%.5e\n",
*(here->B3SOIDDGgPtr), *(here->B3SOIDDGdpPtr),
*(here->B3SOIDDGspPtr), *(here->B3SOIDDGbPtr),
*(here->B3SOIDDGePtr));
fprintf(fpdebug, "DPg=%.5e; DPdp=%.5e; DPsp=%.5e;\nDPb=%.5e; DPe=%.5e\n",
*(here->B3SOIDDDPgPtr), *(here->B3SOIDDDPdpPtr),
*(here->B3SOIDDDPspPtr), *(here->B3SOIDDDPbPtr),
*(here->B3SOIDDDPePtr));
fprintf(fpdebug, "SPg=%.5e; SPdp=%.5e; SPsp=%.5e;\nSPb=%.5e; SPe=%.5e\n",
*(here->B3SOIDDSPgPtr), *(here->B3SOIDDSPdpPtr),
*(here->B3SOIDDSPspPtr), *(here->B3SOIDDSPbPtr),
*(here->B3SOIDDSPePtr));
fprintf(fpdebug, "Bg=%.5e; Bdp=%.5e; Bsp=%.5e;\nBb=%.5e; Be=%.5e\n",
gbbg, gbbdp, gbbsp, gbbb, gbbe);
}
*(here->B3SOIDDDdPtr) += gdpr;
*(here->B3SOIDDDdpPtr) -= gdpr;
*(here->B3SOIDDSsPtr) += gspr;
*(here->B3SOIDDSspPtr) -= gspr;
if (here->B3SOIDDbodyMod == 1) {
(*(here->B3SOIDDBpPtr) -= gppp);
(*(here->B3SOIDDPbPtr) += gppb);
(*(here->B3SOIDDPpPtr) += gppp);
(*(here->B3SOIDDPgPtr) += gppg);
(*(here->B3SOIDDPdpPtr) += gppdp);
(*(here->B3SOIDDPspPtr) += gppsp);
(*(here->B3SOIDDPePtr) += gppe);
}
if (here->B3SOIDDdebugMod > 1)
{
*(here->B3SOIDDVbsPtr) += 1;
*(here->B3SOIDDIdsPtr) += 1;
*(here->B3SOIDDIcPtr) += 1;
*(here->B3SOIDDIbsPtr) += 1;
*(here->B3SOIDDIbdPtr) += 1;
*(here->B3SOIDDIiiPtr) += 1;
*(here->B3SOIDDIgidlPtr) += 1;
*(here->B3SOIDDItunPtr) += 1;
*(here->B3SOIDDIbpPtr) += 1;
*(here->B3SOIDDAbeffPtr) += 1;
*(here->B3SOIDDVbs0effPtr) += 1;
*(here->B3SOIDDVbseffPtr) += 1;
*(here->B3SOIDDXcPtr) += 1;
*(here->B3SOIDDCbgPtr) += 1;
*(here->B3SOIDDCbbPtr) += 1;
*(here->B3SOIDDCbdPtr) += 1;
*(here->B3SOIDDqbPtr) += 1;
*(here->B3SOIDDQbfPtr) += 1;
*(here->B3SOIDDQjsPtr) += 1;
*(here->B3SOIDDQjdPtr) += 1;
/* clean up last */
*(here->B3SOIDDGmPtr) += 1;
*(here->B3SOIDDGmbsPtr) += 1;
*(here->B3SOIDDGdsPtr) += 1;
*(here->B3SOIDDGmePtr) += 1;
*(here->B3SOIDDVbs0teffPtr) += 1;
*(here->B3SOIDDVgsteffPtr) += 1;
*(here->B3SOIDDCbePtr) += 1;
*(here->B3SOIDDVthPtr) += 1;
*(here->B3SOIDDXcsatPtr) += 1;
*(here->B3SOIDDVdscvPtr) += 1;
*(here->B3SOIDDVcscvPtr) += 1;
*(here->B3SOIDDQaccPtr) += 1;
*(here->B3SOIDDQsub0Ptr) += 1;
*(here->B3SOIDDQsubs1Ptr) += 1;
*(here->B3SOIDDQsubs2Ptr) += 1;
*(here->B3SOIDDqgPtr) += 1;
*(here->B3SOIDDqdPtr) += 1;
*(here->B3SOIDDqePtr) += 1;
*(here->B3SOIDDDum1Ptr) += 1;
*(here->B3SOIDDDum2Ptr) += 1;
*(here->B3SOIDDDum3Ptr) += 1;
*(here->B3SOIDDDum4Ptr) += 1;
*(here->B3SOIDDDum5Ptr) += 1;
}
if (here->B3SOIDDdebugMod > 2)
fclose(fpdebug);
}
}
return(OK);
}

215
src/spicelib/devices/bsim3soi_dd/b3soiddask.c Normal file
View File

@ -0,0 +1,215 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: Weidong Liu and Pin Su Feb 1999
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiask.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "ifsim.h"
#include "cktdefs.h"
#include "devdefs.h"
#include "b3soidddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIDDask(ckt,inst,which,value,select)
CKTcircuit *ckt;
GENinstance *inst;
int which;
IFvalue *value;
IFvalue *select;
{
B3SOIDDinstance *here = (B3SOIDDinstance*)inst;
switch(which)
{ case B3SOIDD_L:
value->rValue = here->B3SOIDDl;
return(OK);
case B3SOIDD_W:
value->rValue = here->B3SOIDDw;
return(OK);
case B3SOIDD_AS:
value->rValue = here->B3SOIDDsourceArea;
return(OK);
case B3SOIDD_AD:
value->rValue = here->B3SOIDDdrainArea;
return(OK);
case B3SOIDD_PS:
value->rValue = here->B3SOIDDsourcePerimeter;
return(OK);
case B3SOIDD_PD:
value->rValue = here->B3SOIDDdrainPerimeter;
return(OK);
case B3SOIDD_NRS:
value->rValue = here->B3SOIDDsourceSquares;
return(OK);
case B3SOIDD_NRD:
value->rValue = here->B3SOIDDdrainSquares;
return(OK);
case B3SOIDD_OFF:
value->rValue = here->B3SOIDDoff;
return(OK);
case B3SOIDD_BJTOFF:
value->iValue = here->B3SOIDDbjtoff;
return(OK);
case B3SOIDD_RTH0:
value->rValue = here->B3SOIDDrth0;
return(OK);
case B3SOIDD_CTH0:
value->rValue = here->B3SOIDDcth0;
return(OK);
case B3SOIDD_NRB:
value->rValue = here->B3SOIDDbodySquares;
return(OK);
case B3SOIDD_IC_VBS:
value->rValue = here->B3SOIDDicVBS;
return(OK);
case B3SOIDD_IC_VDS:
value->rValue = here->B3SOIDDicVDS;
return(OK);
case B3SOIDD_IC_VGS:
value->rValue = here->B3SOIDDicVGS;
return(OK);
case B3SOIDD_IC_VES:
value->rValue = here->B3SOIDDicVES;
return(OK);
case B3SOIDD_IC_VPS:
value->rValue = here->B3SOIDDicVPS;
return(OK);
case B3SOIDD_DNODE:
value->iValue = here->B3SOIDDdNode;
return(OK);
case B3SOIDD_GNODE:
value->iValue = here->B3SOIDDgNode;
return(OK);
case B3SOIDD_SNODE:
value->iValue = here->B3SOIDDsNode;
return(OK);
case B3SOIDD_BNODE:
value->iValue = here->B3SOIDDbNode;
return(OK);
case B3SOIDD_ENODE:
value->iValue = here->B3SOIDDeNode;
return(OK);
case B3SOIDD_DNODEPRIME:
value->iValue = here->B3SOIDDdNodePrime;
return(OK);
case B3SOIDD_SNODEPRIME:
value->iValue = here->B3SOIDDsNodePrime;
return(OK);
case B3SOIDD_SOURCECONDUCT:
value->rValue = here->B3SOIDDsourceConductance;
return(OK);
case B3SOIDD_DRAINCONDUCT:
value->rValue = here->B3SOIDDdrainConductance;
return(OK);
case B3SOIDD_VBD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDvbd);
return(OK);
case B3SOIDD_VBS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDvbs);
return(OK);
case B3SOIDD_VGS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDvgs);
return(OK);
case B3SOIDD_VES:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDves);
return(OK);
case B3SOIDD_VDS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDvds);
return(OK);
case B3SOIDD_CD:
value->rValue = here->B3SOIDDcd;
return(OK);
case B3SOIDD_CBS:
value->rValue = here->B3SOIDDcjs;
return(OK);
case B3SOIDD_CBD:
value->rValue = here->B3SOIDDcjd;
return(OK);
case B3SOIDD_GM:
value->rValue = here->B3SOIDDgm;
return(OK);
case B3SOIDD_GMID:
value->rValue = here->B3SOIDDgm/here->B3SOIDDcd;
return(OK);
case B3SOIDD_GDS:
value->rValue = here->B3SOIDDgds;
return(OK);
case B3SOIDD_GMBS:
value->rValue = here->B3SOIDDgmbs;
return(OK);
case B3SOIDD_GBD:
value->rValue = here->B3SOIDDgjdb;
return(OK);
case B3SOIDD_GBS:
value->rValue = here->B3SOIDDgjsb;
return(OK);
case B3SOIDD_QB:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDqb);
return(OK);
case B3SOIDD_CQB:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDcqb);
return(OK);
case B3SOIDD_QG:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDqg);
return(OK);
case B3SOIDD_CQG:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDcqg);
return(OK);
case B3SOIDD_QD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDqd);
return(OK);
case B3SOIDD_CQD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDcqd);
return(OK);
case B3SOIDD_CGG:
value->rValue = here->B3SOIDDcggb;
return(OK);
case B3SOIDD_CGD:
value->rValue = here->B3SOIDDcgdb;
return(OK);
case B3SOIDD_CGS:
value->rValue = here->B3SOIDDcgsb;
return(OK);
case B3SOIDD_CDG:
value->rValue = here->B3SOIDDcdgb;
return(OK);
case B3SOIDD_CDD:
value->rValue = here->B3SOIDDcddb;
return(OK);
case B3SOIDD_CDS:
value->rValue = here->B3SOIDDcdsb;
return(OK);
case B3SOIDD_CBG:
value->rValue = here->B3SOIDDcbgb;
return(OK);
case B3SOIDD_CBDB:
value->rValue = here->B3SOIDDcbdb;
return(OK);
case B3SOIDD_CBSB:
value->rValue = here->B3SOIDDcbsb;
return(OK);
case B3SOIDD_VON:
value->rValue = here->B3SOIDDvon;
return(OK);
case B3SOIDD_VDSAT:
value->rValue = here->B3SOIDDvdsat;
return(OK);
case B3SOIDD_QBS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDqbs);
return(OK);
case B3SOIDD_QBD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIDDqbd);
return(OK);
default:
return(E_BADPARM);
}
/* NOTREACHED */
}

504
src/spicelib/devices/bsim3soi_dd/b3soiddcheck.c Normal file
View File

@ -0,0 +1,504 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiddcheck.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "b3soidddef.h"
#include "trandefs.h"
#include "const.h"
#include "sperror.h"
#include "devdefs.h"
#include "suffix.h"
int
B3SOIDDcheckModel(model, here, ckt)
register B3SOIDDmodel *model;
register B3SOIDDinstance *here;
CKTcircuit *ckt;
{
struct b3soiddSizeDependParam *pParam;
int Fatal_Flag = 0;
FILE *fplog;
if ((fplog = fopen("b3soiddv1check.log", "w")) != NULL)
{ pParam = here->pParam;
fprintf(fplog, "B3SOIDDV3 Parameter Check\n");
fprintf(fplog, "Model = %s\n", model->B3SOIDDmodName);
fprintf(fplog, "W = %g, L = %g\n", here->B3SOIDDw, here->B3SOIDDl);
if (pParam->B3SOIDDnlx < -pParam->B3SOIDDleff)
{ fprintf(fplog, "Fatal: Nlx = %g is less than -Leff.\n",
pParam->B3SOIDDnlx);
printf("Fatal: Nlx = %g is less than -Leff.\n",
pParam->B3SOIDDnlx);
Fatal_Flag = 1;
}
if (model->B3SOIDDtox <= 0.0)
{ fprintf(fplog, "Fatal: Tox = %g is not positive.\n",
model->B3SOIDDtox);
printf("Fatal: Tox = %g is not positive.\n", model->B3SOIDDtox);
Fatal_Flag = 1;
}
if (model->B3SOIDDtbox <= 0.0)
{ fprintf(fplog, "Fatal: Tbox = %g is not positive.\n",
model->B3SOIDDtbox);
printf("Fatal: Tbox = %g is not positive.\n", model->B3SOIDDtbox);
Fatal_Flag = 1;
}
if (pParam->B3SOIDDnpeak <= 0.0)
{ fprintf(fplog, "Fatal: Nch = %g is not positive.\n",
pParam->B3SOIDDnpeak);
printf("Fatal: Nch = %g is not positive.\n",
pParam->B3SOIDDnpeak);
Fatal_Flag = 1;
}
if (pParam->B3SOIDDngate < 0.0)
{ fprintf(fplog, "Fatal: Ngate = %g is not positive.\n",
pParam->B3SOIDDngate);
printf("Fatal: Ngate = %g Ngate is not positive.\n",
pParam->B3SOIDDngate);
Fatal_Flag = 1;
}
if (pParam->B3SOIDDngate > 1.e25)
{ fprintf(fplog, "Fatal: Ngate = %g is too high.\n",
pParam->B3SOIDDngate);
printf("Fatal: Ngate = %g Ngate is too high\n",
pParam->B3SOIDDngate);
Fatal_Flag = 1;
}
if (model->B3SOIDDdvbd1 < 0.0)
{ fprintf(fplog, "Fatal: Dvbd1 = %g is negative.\n",
model->B3SOIDDdvbd1);
printf("Fatal: Dvbd1 = %g is negative.\n", model->B3SOIDDdvbd1);
Fatal_Flag = 1;
}
if (pParam->B3SOIDDdvt1 < 0.0)
{ fprintf(fplog, "Fatal: Dvt1 = %g is negative.\n",
pParam->B3SOIDDdvt1);
printf("Fatal: Dvt1 = %g is negative.\n", pParam->B3SOIDDdvt1);
Fatal_Flag = 1;
}
if (pParam->B3SOIDDdvt1w < 0.0)
{ fprintf(fplog, "Fatal: Dvt1w = %g is negative.\n",
pParam->B3SOIDDdvt1w);
printf("Fatal: Dvt1w = %g is negative.\n", pParam->B3SOIDDdvt1w);
Fatal_Flag = 1;
}
if (pParam->B3SOIDDw0 == -pParam->B3SOIDDweff)
{ 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->B3SOIDDdsub < 0.0)
{ fprintf(fplog, "Fatal: Dsub = %g is negative.\n", pParam->B3SOIDDdsub);
printf("Fatal: Dsub = %g is negative.\n", pParam->B3SOIDDdsub);
Fatal_Flag = 1;
}
if (pParam->B3SOIDDb1 == -pParam->B3SOIDDweff)
{ 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->B3SOIDDu0temp <= 0.0)
{ fprintf(fplog, "Fatal: u0 at current temperature = %g is not positive.\n", pParam->B3SOIDDu0temp);
printf("Fatal: u0 at current temperature = %g is not positive.\n",
pParam->B3SOIDDu0temp);
Fatal_Flag = 1;
}
/* Check delta parameter */
if (pParam->B3SOIDDdelta < 0.0)
{ fprintf(fplog, "Fatal: Delta = %g is less than zero.\n",
pParam->B3SOIDDdelta);
printf("Fatal: Delta = %g is less than zero.\n", pParam->B3SOIDDdelta);
Fatal_Flag = 1;
}
if (pParam->B3SOIDDvsattemp <= 0.0)
{ fprintf(fplog, "Fatal: Vsat at current temperature = %g is not positive.\n", pParam->B3SOIDDvsattemp);
printf("Fatal: Vsat at current temperature = %g is not positive.\n",
pParam->B3SOIDDvsattemp);
Fatal_Flag = 1;
}
/* Check Rout parameters */
if (pParam->B3SOIDDpclm <= 0.0)
{ fprintf(fplog, "Fatal: Pclm = %g is not positive.\n", pParam->B3SOIDDpclm);
printf("Fatal: Pclm = %g is not positive.\n", pParam->B3SOIDDpclm);
Fatal_Flag = 1;
}
if (pParam->B3SOIDDdrout < 0.0)
{ fprintf(fplog, "Fatal: Drout = %g is negative.\n", pParam->B3SOIDDdrout);
printf("Fatal: Drout = %g is negative.\n", pParam->B3SOIDDdrout);
Fatal_Flag = 1;
}
if ( model->B3SOIDDunitLengthGateSidewallJctCap > 0.0)
{
if (here->B3SOIDDdrainPerimeter < pParam->B3SOIDDweff)
{ fprintf(fplog, "Warning: Pd = %g is less than W.\n",
here->B3SOIDDdrainPerimeter);
printf("Warning: Pd = %g is less than W.\n",
here->B3SOIDDdrainPerimeter);
here->B3SOIDDdrainPerimeter =pParam->B3SOIDDweff;
}
if (here->B3SOIDDsourcePerimeter < pParam->B3SOIDDweff)
{ fprintf(fplog, "Warning: Ps = %g is less than W.\n",
here->B3SOIDDsourcePerimeter);
printf("Warning: Ps = %g is less than W.\n",
here->B3SOIDDsourcePerimeter);
here->B3SOIDDsourcePerimeter =pParam->B3SOIDDweff;
}
}
/* Check capacitance parameters */
if (pParam->B3SOIDDclc < 0.0)
{ fprintf(fplog, "Fatal: Clc = %g is negative.\n", pParam->B3SOIDDclc);
printf("Fatal: Clc = %g is negative.\n", pParam->B3SOIDDclc);
Fatal_Flag = 1;
}
if (model->B3SOIDDparamChk ==1)
{
/* Check L and W parameters */
if (pParam->B3SOIDDleff <= 5.0e-8)
{ fprintf(fplog, "Warning: Leff = %g may be too small.\n",
pParam->B3SOIDDleff);
printf("Warning: Leff = %g may be too small.\n",
pParam->B3SOIDDleff);
}
if (pParam->B3SOIDDleffCV <= 5.0e-8)
{ fprintf(fplog, "Warning: Leff for CV = %g may be too small.\n",
pParam->B3SOIDDleffCV);
printf("Warning: Leff for CV = %g may be too small.\n",
pParam->B3SOIDDleffCV);
}
if (pParam->B3SOIDDweff <= 1.0e-7)
{ fprintf(fplog, "Warning: Weff = %g may be too small.\n",
pParam->B3SOIDDweff);
printf("Warning: Weff = %g may be too small.\n",
pParam->B3SOIDDweff);
}
if (pParam->B3SOIDDweffCV <= 1.0e-7)
{ fprintf(fplog, "Warning: Weff for CV = %g may be too small.\n",
pParam->B3SOIDDweffCV);
printf("Warning: Weff for CV = %g may be too small.\n",
pParam->B3SOIDDweffCV);
}
/* Check threshold voltage parameters */
if (pParam->B3SOIDDnlx < 0.0)
{ fprintf(fplog, "Warning: Nlx = %g is negative.\n", pParam->B3SOIDDnlx);
printf("Warning: Nlx = %g is negative.\n", pParam->B3SOIDDnlx);
}
if (model->B3SOIDDtox < 1.0e-9)
{ fprintf(fplog, "Warning: Tox = %g is less than 10A.\n",
model->B3SOIDDtox);
printf("Warning: Tox = %g is less than 10A.\n", model->B3SOIDDtox);
}
if (pParam->B3SOIDDnpeak <= 1.0e15)
{ fprintf(fplog, "Warning: Nch = %g may be too small.\n",
pParam->B3SOIDDnpeak);
printf("Warning: Nch = %g may be too small.\n",
pParam->B3SOIDDnpeak);
}
else if (pParam->B3SOIDDnpeak >= 1.0e21)
{ fprintf(fplog, "Warning: Nch = %g may be too large.\n",
pParam->B3SOIDDnpeak);
printf("Warning: Nch = %g may be too large.\n",
pParam->B3SOIDDnpeak);
}
if (fabs(pParam->B3SOIDDnsub) >= 1.0e21)
{ fprintf(fplog, "Warning: Nsub = %g may be too large.\n",
pParam->B3SOIDDnsub);
printf("Warning: Nsub = %g may be too large.\n",
pParam->B3SOIDDnsub);
}
if ((pParam->B3SOIDDngate > 0.0) &&
(pParam->B3SOIDDngate <= 1.e18))
{ fprintf(fplog, "Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->B3SOIDDngate);
printf("Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->B3SOIDDngate);
}
if (model->B3SOIDDdvbd0 < 0.0)
{ fprintf(fplog, "Warning: Dvbd0 = %g is negative.\n",
model->B3SOIDDdvbd0);
printf("Warning: Dvbd0 = %g is negative.\n", model->B3SOIDDdvbd0);
}
if (pParam->B3SOIDDdvt0 < 0.0)
{ fprintf(fplog, "Warning: Dvt0 = %g is negative.\n",
pParam->B3SOIDDdvt0);
printf("Warning: Dvt0 = %g is negative.\n", pParam->B3SOIDDdvt0);
}
if (fabs(1.0e-6 / (pParam->B3SOIDDw0 + pParam->B3SOIDDweff)) > 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->B3SOIDDnfactor < 0.0)
{ fprintf(fplog, "Warning: Nfactor = %g is negative.\n",
pParam->B3SOIDDnfactor);
printf("Warning: Nfactor = %g is negative.\n", pParam->B3SOIDDnfactor);
}
if (model->B3SOIDDkb3 < 0.0)
{ fprintf(fplog, "Warning: Kb3 = %g is negative.\n",
model->B3SOIDDkb3);
printf("Warning: Kb3 = %g is negative.\n", model->B3SOIDDkb3);
}
if (pParam->B3SOIDDcdsc < 0.0)
{ fprintf(fplog, "Warning: Cdsc = %g is negative.\n",
pParam->B3SOIDDcdsc);
printf("Warning: Cdsc = %g is negative.\n", pParam->B3SOIDDcdsc);
}
if (pParam->B3SOIDDcdscd < 0.0)
{ fprintf(fplog, "Warning: Cdscd = %g is negative.\n",
pParam->B3SOIDDcdscd);
printf("Warning: Cdscd = %g is negative.\n", pParam->B3SOIDDcdscd);
}
/* Check DIBL parameters */
if (pParam->B3SOIDDeta0 < 0.0)
{ fprintf(fplog, "Warning: Eta0 = %g is negative.\n",
pParam->B3SOIDDeta0);
printf("Warning: Eta0 = %g is negative.\n", pParam->B3SOIDDeta0);
}
/* Check Abulk parameters */
if (fabs(1.0e-6 / (pParam->B3SOIDDb1 + pParam->B3SOIDDweff)) > 10.0)
{ fprintf(fplog, "Warning: (B1 + Weff) may be too small.\n");
printf("Warning: (B1 + Weff) may be too small.\n");
}
if (model->B3SOIDDadice0 > 1.0)
{ fprintf(fplog, "Warning: Adice0 = %g should be smaller than 1.\n",
model->B3SOIDDadice0);
printf("Warning: Adice0 = %g should be smaller than 1.\n", model->B3SOIDDadice0);
}
if (model->B3SOIDDabp < 0.2)
{ fprintf(fplog, "Warning: Abp = %g is too small.\n",
model->B3SOIDDabp);
printf("Warning: Abp = %g is too small.\n", model->B3SOIDDabp);
}
if ((model->B3SOIDDmxc < -1.0) || (model->B3SOIDDmxc > 1.0))
{ fprintf(fplog, "Warning: Mxc = %g should be within (-1, 1).\n",
model->B3SOIDDmxc);
printf("Warning: Mxc = %g should be within (-1, 1).\n", model->B3SOIDDmxc);
}
/* Check Saturation parameters */
if (pParam->B3SOIDDa2 < 0.01)
{ fprintf(fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", pParam->B3SOIDDa2);
printf("Warning: A2 = %g is too small. Set to 0.01.\n",
pParam->B3SOIDDa2);
pParam->B3SOIDDa2 = 0.01;
}
else if (pParam->B3SOIDDa2 > 1.0)
{ fprintf(fplog, "Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->B3SOIDDa2);
printf("Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->B3SOIDDa2);
pParam->B3SOIDDa2 = 1.0;
pParam->B3SOIDDa1 = 0.0;
}
if (pParam->B3SOIDDrdsw < 0.0)
{ fprintf(fplog, "Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->B3SOIDDrdsw);
printf("Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->B3SOIDDrdsw);
pParam->B3SOIDDrdsw = 0.0;
pParam->B3SOIDDrds0 = 0.0;
}
else if ((pParam->B3SOIDDrds0 > 0.0) && (pParam->B3SOIDDrds0 < 0.001))
{ fprintf(fplog, "Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n",
pParam->B3SOIDDrds0);
printf("Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n",
pParam->B3SOIDDrds0);
pParam->B3SOIDDrds0 = 0.0;
}
if (pParam->B3SOIDDvsattemp < 1.0e3)
{ fprintf(fplog, "Warning: Vsat at current temperature = %g may be too small.\n", pParam->B3SOIDDvsattemp);
printf("Warning: Vsat at current temperature = %g may be too small.\n", pParam->B3SOIDDvsattemp);
}
if (pParam->B3SOIDDpdibl1 < 0.0)
{ fprintf(fplog, "Warning: Pdibl1 = %g is negative.\n",
pParam->B3SOIDDpdibl1);
printf("Warning: Pdibl1 = %g is negative.\n", pParam->B3SOIDDpdibl1);
}
if (pParam->B3SOIDDpdibl2 < 0.0)
{ fprintf(fplog, "Warning: Pdibl2 = %g is negative.\n",
pParam->B3SOIDDpdibl2);
printf("Warning: Pdibl2 = %g is negative.\n", pParam->B3SOIDDpdibl2);
}
/* Check overlap capacitance parameters */
if (model->B3SOIDDcgdo < 0.0)
{ fprintf(fplog, "Warning: cgdo = %g is negative. Set to zero.\n", model->B3SOIDDcgdo);
printf("Warning: cgdo = %g is negative. Set to zero.\n", model->B3SOIDDcgdo);
model->B3SOIDDcgdo = 0.0;
}
if (model->B3SOIDDcgso < 0.0)
{ fprintf(fplog, "Warning: cgso = %g is negative. Set to zero.\n", model->B3SOIDDcgso);
printf("Warning: cgso = %g is negative. Set to zero.\n", model->B3SOIDDcgso);
model->B3SOIDDcgso = 0.0;
}
if (model->B3SOIDDcgeo < 0.0)
{ fprintf(fplog, "Warning: cgeo = %g is negative. Set to zero.\n", model->B3SOIDDcgeo);
printf("Warning: cgeo = %g is negative. Set to zero.\n", model->B3SOIDDcgeo);
model->B3SOIDDcgeo = 0.0;
}
if (model->B3SOIDDntun < 0.0)
{ fprintf(fplog, "Warning: Ntun = %g is negative.\n",
model->B3SOIDDntun);
printf("Warning: Ntun = %g is negative.\n", model->B3SOIDDntun);
}
if (model->B3SOIDDndiode < 0.0)
{ fprintf(fplog, "Warning: Ndiode = %g is negative.\n",
model->B3SOIDDndiode);
printf("Warning: Ndiode = %g is negative.\n", model->B3SOIDDndiode);
}
if (model->B3SOIDDisbjt < 0.0)
{ fprintf(fplog, "Warning: Isbjt = %g is negative.\n",
model->B3SOIDDisbjt);
printf("Warning: Isbjt = %g is negative.\n", model->B3SOIDDisbjt);
}
if (model->B3SOIDDisdif < 0.0)
{ fprintf(fplog, "Warning: Isdif = %g is negative.\n",
model->B3SOIDDisdif);
printf("Warning: Isdif = %g is negative.\n", model->B3SOIDDisdif);
}
if (model->B3SOIDDisrec < 0.0)
{ fprintf(fplog, "Warning: Isrec = %g is negative.\n",
model->B3SOIDDisrec);
printf("Warning: Isrec = %g is negative.\n", model->B3SOIDDisrec);
}
if (model->B3SOIDDistun < 0.0)
{ fprintf(fplog, "Warning: Istun = %g is negative.\n",
model->B3SOIDDistun);
printf("Warning: Istun = %g is negative.\n", model->B3SOIDDistun);
}
if (model->B3SOIDDedl < 0.0)
{ fprintf(fplog, "Warning: Edl = %g is negative.\n",
model->B3SOIDDedl);
printf("Warning: Edl = %g is negative.\n", model->B3SOIDDedl);
}
if (model->B3SOIDDkbjt1 < 0.0)
{ fprintf(fplog, "Warning: Kbjt1 = %g is negative.\n",
model->B3SOIDDkbjt1);
printf("Warning: kbjt1 = %g is negative.\n", model->B3SOIDDkbjt1);
}
if (model->B3SOIDDtt < 0.0)
{ fprintf(fplog, "Warning: Tt = %g is negative.\n",
model->B3SOIDDtt);
printf("Warning: Tt = %g is negative.\n", model->B3SOIDDtt);
}
if (model->B3SOIDDcsdmin < 0.0)
{ fprintf(fplog, "Warning: Csdmin = %g is negative.\n",
model->B3SOIDDcsdmin);
printf("Warning: Csdmin = %g is negative.\n", model->B3SOIDDcsdmin);
}
if (model->B3SOIDDcsdesw < 0.0)
{ fprintf(fplog, "Warning: Csdesw = %g is negative.\n",
model->B3SOIDDcsdesw);
printf("Warning: Csdesw = %g is negative.\n", model->B3SOIDDcsdesw);
}
if ((model->B3SOIDDasd < 0.0) || (model->B3SOIDDmxc > 1.0))
{ fprintf(fplog, "Warning: Asd = %g should be within (0, 1).\n",
model->B3SOIDDasd);
printf("Warning: Asd = %g should be within (0, 1).\n", model->B3SOIDDasd);
}
if (model->B3SOIDDrth0 < 0.0)
{ fprintf(fplog, "Warning: Rth0 = %g is negative.\n",
model->B3SOIDDrth0);
printf("Warning: Rth0 = %g is negative.\n", model->B3SOIDDrth0);
}
if (model->B3SOIDDcth0 < 0.0)
{ fprintf(fplog, "Warning: Cth0 = %g is negative.\n",
model->B3SOIDDcth0);
printf("Warning: Cth0 = %g is negative.\n", model->B3SOIDDcth0);
}
if (model->B3SOIDDrbody < 0.0)
{ fprintf(fplog, "Warning: Rbody = %g is negative.\n",
model->B3SOIDDrbody);
printf("Warning: Rbody = %g is negative.\n", model->B3SOIDDrbody);
}
if (model->B3SOIDDrbsh < 0.0)
{ fprintf(fplog, "Warning: Rbsh = %g is negative.\n",
model->B3SOIDDrbsh);
printf("Warning: Rbsh = %g is negative.\n", model->B3SOIDDrbsh);
}
if (model->B3SOIDDxj > model->B3SOIDDtsi)
{ fprintf(fplog, "Warning: Xj = %g is thicker than Tsi = %g.\n",
model->B3SOIDDxj, model->B3SOIDDtsi);
printf("Warning: Xj = %g is thicker than Tsi = %g.\n",
model->B3SOIDDxj, model->B3SOIDDtsi);
}
if (model->B3SOIDDcapMod < 2)
{ fprintf(fplog, "Warning: capMod < 2 is not supported by BSIM3SOI.\n");
printf("Warning: Warning: capMod < 2 is not supported by BSIM3SOI.\n");
}
if (model->B3SOIDDcii > 2.0)
{ fprintf(fplog, "Warning: Cii = %g is larger than 2.0.\n", model->B3SOIDDcii);
printf("Warning: Cii = %g is larger than 2.0.\n", model->B3SOIDDcii);
}
if (model->B3SOIDDdii > 1.5)
{ fprintf(fplog, "Warning: Dii = %g is larger than 1.5.\n", model->B3SOIDDcii);
printf("Warning: Dii = %g is too larger than 1.5.\n", model->B3SOIDDcii);
}
}/* 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);
}

90
src/spicelib/devices/bsim3soi_dd/b3soiddcvtest.c Normal file
View File

@ -0,0 +1,90 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiddcvtest.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "b3soidddef.h"
#include "trandefs.h"
#include "const.h"
#include "devdefs.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIDDconvTest(inModel,ckt)
GENmodel *inModel;
register CKTcircuit *ckt;
{
register B3SOIDDmodel *model = (B3SOIDDmodel*)inModel;
register B3SOIDDinstance *here;
double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds;
double cbd, cbhat, cbs, cd, cdhat, tol, vgd, vgdo, vgs;
/* loop through all the B3SOIDD device models */
for (; model != NULL; model = model->B3SOIDDnextModel)
{ /* loop through all the instances of the model */
for (here = model->B3SOIDDinstances; here != NULL ;
here=here->B3SOIDDnextInstance)
{ vbs = model->B3SOIDDtype
* (*(ckt->CKTrhsOld+here->B3SOIDDbNode)
- *(ckt->CKTrhsOld+here->B3SOIDDsNodePrime));
vgs = model->B3SOIDDtype
* (*(ckt->CKTrhsOld+here->B3SOIDDgNode)
- *(ckt->CKTrhsOld+here->B3SOIDDsNodePrime));
vds = model->B3SOIDDtype
* (*(ckt->CKTrhsOld+here->B3SOIDDdNodePrime)
- *(ckt->CKTrhsOld+here->B3SOIDDsNodePrime));
vbd = vbs - vds;
vgd = vgs - vds;
vgdo = *(ckt->CKTstate0 + here->B3SOIDDvgs)
- *(ckt->CKTstate0 + here->B3SOIDDvds);
delvbs = vbs - *(ckt->CKTstate0 + here->B3SOIDDvbs);
delvbd = vbd - *(ckt->CKTstate0 + here->B3SOIDDvbd);
delvgs = vgs - *(ckt->CKTstate0 + here->B3SOIDDvgs);
delvds = vds - *(ckt->CKTstate0 + here->B3SOIDDvds);
delvgd = vgd-vgdo;
cd = here->B3SOIDDcd;
if (here->B3SOIDDmode >= 0)
{ cdhat = cd - here->B3SOIDDgjdb * delvbd
+ here->B3SOIDDgmbs * delvbs + here->B3SOIDDgm * delvgs
+ here->B3SOIDDgds * delvds;
}
else
{ cdhat = cd - (here->B3SOIDDgjdb - here->B3SOIDDgmbs) * delvbd
- here->B3SOIDDgm * delvgd + here->B3SOIDDgds * delvds;
}
/*
* check convergence
*/
if ((here->B3SOIDDoff == 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->B3SOIDDcjs;
cbd = here->B3SOIDDcjd;
cbhat = cbs + cbd + here->B3SOIDDgjdb * delvbd
+ here->B3SOIDDgjsb * delvbs;
tol = ckt->CKTreltol * MAX(fabs(cbhat), fabs(cbs + cbd))
+ ckt->CKTabstol;
if (fabs(cbhat - (cbs + cbd)) > tol)
{ ckt->CKTnoncon++;
return(OK);
}
}
}
}
return(OK);
}

1991
src/spicelib/devices/bsim3soi_dd/b3soidddef.h Normal file
View File

File diff suppressed because it is too large Load Diff

41
src/spicelib/devices/bsim3soi_dd/b3soidddel.c Normal file
View File

@ -0,0 +1,41 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soidddel.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "b3soidddef.h"
#include "sperror.h"
#include "gendefs.h"
#include "suffix.h"
int
B3SOIDDdelete(inModel,name,inInst)
GENmodel *inModel;
IFuid name;
GENinstance **inInst;
{
B3SOIDDinstance **fast = (B3SOIDDinstance**)inInst;
B3SOIDDmodel *model = (B3SOIDDmodel*)inModel;
B3SOIDDinstance **prev = NULL;
B3SOIDDinstance *here;
for (; model ; model = model->B3SOIDDnextModel)
{ prev = &(model->B3SOIDDinstances);
for (here = *prev; here ; here = *prev)
{ if (here->B3SOIDDname == name || (fast && here==*fast))
{ *prev= here->B3SOIDDnextInstance;
FREE(here);
return(OK);
}
prev = &(here->B3SOIDDnextInstance);
}
}
return(E_NODEV);
}

39
src/spicelib/devices/bsim3soi_dd/b3soidddest.c Normal file
View File

@ -0,0 +1,39 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soidddest.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "b3soidddef.h"
#include "suffix.h"
void
B3SOIDDdestroy(inModel)
GENmodel **inModel;
{
B3SOIDDmodel **model = (B3SOIDDmodel**)inModel;
B3SOIDDinstance *here;
B3SOIDDinstance *prev = NULL;
B3SOIDDmodel *mod = *model;
B3SOIDDmodel *oldmod = NULL;
for (; mod ; mod = mod->B3SOIDDnextModel)
{ if(oldmod) FREE(oldmod);
oldmod = mod;
prev = (B3SOIDDinstance *)NULL;
for (here = mod->B3SOIDDinstances; here; here = here->B3SOIDDnextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
}
if(oldmod) FREE(oldmod);
*model = NULL;
return;
}

54
src/spicelib/devices/bsim3soi_dd/b3soiddext.h Normal file
View File

@ -0,0 +1,54 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung
File: b3soiddext.h
**********/
#ifdef __STDC__
extern int B3SOIDDacLoad(GENmodel *,CKTcircuit*);
extern int B3SOIDDask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*);
extern int B3SOIDDconvTest(GENmodel *,CKTcircuit*);
extern int B3SOIDDdelete(GENmodel*,IFuid,GENinstance**);
extern void B3SOIDDdestroy(GENmodel**);
extern int B3SOIDDgetic(GENmodel*,CKTcircuit*);
extern int B3SOIDDload(GENmodel*,CKTcircuit*);
extern int B3SOIDDmAsk(CKTcircuit*,GENmodel *,int, IFvalue*);
extern int B3SOIDDmDelete(GENmodel**,IFuid,GENmodel*);
extern int B3SOIDDmParam(int,IFvalue*,GENmodel*);
extern void B3SOIDDmosCap(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 B3SOIDDparam(int,IFvalue*,GENinstance*,IFvalue*);
extern int B3SOIDDpzLoad(GENmodel*,CKTcircuit*,SPcomplex*);
extern int B3SOIDDsetup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
extern int B3SOIDDtemp(GENmodel*,CKTcircuit*);
extern int B3SOIDDtrunc(GENmodel*,CKTcircuit*,double*);
extern int B3SOIDDnoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
extern int B3SOIDDunsetup(GENmodel*,CKTcircuit*);
#else /* stdc */
extern int B3SOIDDacLoad();
extern int B3SOIDDdelete();
extern void B3SOIDDdestroy();
extern int B3SOIDDgetic();
extern int B3SOIDDload();
extern int B3SOIDDmDelete();
extern int B3SOIDDask();
extern int B3SOIDDmAsk();
extern int B3SOIDDconvTest();
extern int B3SOIDDtemp();
extern int B3SOIDDmParam();
extern void B3SOIDDmosCap();
extern int B3SOIDDparam();
extern int B3SOIDDpzLoad();
extern int B3SOIDDsetup();
extern int B3SOIDDtrunc();
extern int B3SOIDDnoise();
extern int B3SOIDDunsetup();
#endif /* stdc */

51
src/spicelib/devices/bsim3soi_dd/b3soiddgetic.c Normal file
View File

@ -0,0 +1,51 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiddgetic.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "b3soidddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIDDgetic(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
B3SOIDDmodel *model = (B3SOIDDmodel*)inModel;
B3SOIDDinstance *here;
for (; model ; model = model->B3SOIDDnextModel)
{ for (here = model->B3SOIDDinstances; here; here = here->B3SOIDDnextInstance)
{ if(!here->B3SOIDDicVBSGiven)
{ here->B3SOIDDicVBS = *(ckt->CKTrhs + here->B3SOIDDbNode)
- *(ckt->CKTrhs + here->B3SOIDDsNode);
}
if (!here->B3SOIDDicVDSGiven)
{ here->B3SOIDDicVDS = *(ckt->CKTrhs + here->B3SOIDDdNode)
- *(ckt->CKTrhs + here->B3SOIDDsNode);
}
if (!here->B3SOIDDicVGSGiven)
{ here->B3SOIDDicVGS = *(ckt->CKTrhs + here->B3SOIDDgNode)
- *(ckt->CKTrhs + here->B3SOIDDsNode);
}
if (!here->B3SOIDDicVESGiven)
{ here->B3SOIDDicVES = *(ckt->CKTrhs + here->B3SOIDDeNode)
- *(ckt->CKTrhs + here->B3SOIDDsNode);
}
if (!here->B3SOIDDicVPSGiven)
{ here->B3SOIDDicVPS = *(ckt->CKTrhs + here->B3SOIDDpNode)
- *(ckt->CKTrhs + here->B3SOIDDsNode);
}
}
}
return(OK);
}

62
src/spicelib/devices/bsim3soi_dd/b3soiddinit.c Normal file
View File

@ -0,0 +1,62 @@
#include <config.h>
#include <devdefs.h>
#include "b3soidditf.h"
#include "b3soiddext.h"
#include "b3soiddinit.h"
SPICEdev B3SOIDDinfo = {
{ "B3SOIDD",
"Berkeley SOI MOSFET (DD) model version 1.0",
&B3SOIDDnSize,
&B3SOIDDnSize,
B3SOIDDnames,
&B3SOIDDpTSize,
B3SOIDDpTable,
&B3SOIDDmPTSize,
B3SOIDDmPTable,
DEV_DEFAULT}
,
DEVparam: B3SOIDDparam,
DEVmodParam: B3SOIDDmParam,
DEVload: B3SOIDDload,
DEVsetup: B3SOIDDsetup,
DEVunsetup: B3SOIDDunsetup,
DEVpzSetup: B3SOIDDsetup,
DEVtemperature:B3SOIDDtemp,
DEVtrunc: B3SOIDDtrunc,
DEVfindBranch: NULL,
DEVacLoad: B3SOIDDacLoad,
DEVaccept: NULL,
DEVdestroy: B3SOIDDdestroy,
DEVmodDelete: B3SOIDDmDelete,
DEVdelete: B3SOIDDdelete,
DEVsetic: B3SOIDDgetic,
DEVask: B3SOIDDask,
DEVmodAsk: B3SOIDDmAsk,
DEVpzLoad: B3SOIDDpzLoad,
DEVconvTest: B3SOIDDconvTest,
DEVsenSetup: NULL,
DEVsenLoad: NULL,
DEVsenUpdate: NULL,
DEVsenAcLoad: NULL,
DEVsenPrint: NULL,
DEVsenTrunc: NULL,
DEVdisto: NULL,
DEVnoise: B3SOIDDnoise,
DEVinstSize: &B3SOIDDiSize,
DEVmodSize: &B3SOIDDmSize
};
SPICEdev *
get_b3soidd_info (void)
{
return &B3SOIDDinfo;
}

13
src/spicelib/devices/bsim3soi_dd/b3soiddinit.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef _B3SOIDDINIT_H
#define _B3SOIDDINIT_H
extern IFparm B3SOIDDpTable[];
extern IFparm B3SOIDDmPTable[];
extern char *B3SOIDDnames[];
extern int B3SOIDDpTSize;
extern int B3SOIDDmPTSize;
extern int B3SOIDDnSize;
extern int B3SOIDDiSize;
extern int B3SOIDDmSize;
#endif

14
src/spicelib/devices/bsim3soi_dd/b3soidditf.h Normal file
View File

@ -0,0 +1,14 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung
File: b3soidditf.h
**********/
#ifndef DEV_B3SOIDD
#define DEV_B3SOIDD
#include "b3soiddext.h"
SPICEdev *get_b3soidd_info (void);
#endif

4475
src/spicelib/devices/bsim3soi_dd/b3soiddld.c Normal file
View File

File diff suppressed because it is too large Load Diff

1207
src/spicelib/devices/bsim3soi_dd/b3soiddmask.c Normal file
View File

File diff suppressed because it is too large Load Diff

48
src/spicelib/devices/bsim3soi_dd/b3soiddmdel.c Normal file
View File

@ -0,0 +1,48 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: Weidong Liu and Pin Su Feb 1999
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiddmdel.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "b3soidddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIDDmDelete(inModel,modname,kill)
GENmodel **inModel;
IFuid modname;
GENmodel *kill;
{
B3SOIDDmodel **model = (B3SOIDDmodel**)inModel;
B3SOIDDmodel *modfast = (B3SOIDDmodel*)kill;
B3SOIDDinstance *here;
B3SOIDDinstance *prev = NULL;
B3SOIDDmodel **oldmod;
oldmod = model;
for (; *model ; model = &((*model)->B3SOIDDnextModel))
{ if ((*model)->B3SOIDDmodName == modname ||
(modfast && *model == modfast))
goto delgot;
oldmod = model;
}
return(E_NOMOD);
delgot:
*oldmod = (*model)->B3SOIDDnextModel; /* cut deleted device out of list */
for (here = (*model)->B3SOIDDinstances; here; here = here->B3SOIDDnextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
FREE(*model);
return(OK);
}

1625
src/spicelib/devices/bsim3soi_dd/b3soiddmpar.c Normal file
View File

File diff suppressed because it is too large Load Diff

395
src/spicelib/devices/bsim3soi_dd/b3soiddnoi.c Normal file
View File

@ -0,0 +1,395 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: Weidong Liu and Pin Su Feb 1999
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiddnoi.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "b3soidddef.h"
#include "cktdefs.h"
#include "iferrmsg.h"
#include "noisedef.h"
#include "suffix.h"
#include "const.h" /* jwan */
/*
* B3SOIDDnoise (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->B3SOIDDnoiMod.
If model->B3SOIDDnoiMod = 1,
Channel thermal noise = SPICE2 model
Flicker noise = SPICE2 model
If model->B3SOIDDnoiMod = 2,
Channel thermal noise = B3SOIDD model
Flicker noise = B3SOIDD model
If model->B3SOIDDnoiMod = 3,
Channel thermal noise = SPICE2 model
Flicker noise = B3SOIDD model
If model->B3SOIDDnoiMod = 4,
Channel thermal noise = B3SOIDD model
Flicker noise = SPICE2 model
*/
extern void NevalSrc();
extern double Nintegrate();
double
B3SOIDDStrongInversionNoiseEval(vgs, vds, model, here, freq, temp)
double vgs, vds, freq, temp;
B3SOIDDmodel *model;
B3SOIDDinstance *here;
{
struct b3soiddSizeDependParam *pParam;
double cd, esat, DelClm, EffFreq, N0, Nl, Vgst;
double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Ssi;
double req, ceq;
pParam = here->pParam;
cd = fabs(here->B3SOIDDcd);
if (vds > here->B3SOIDDvdsat)
{ esat = 2.0 * pParam->B3SOIDDvsattemp / here->B3SOIDDueff;
T0 = ((((vds - here->B3SOIDDvdsat) / pParam->B3SOIDDlitl) + model->B3SOIDDem)
/ esat);
DelClm = pParam->B3SOIDDlitl * log (MAX(T0, N_MINLOG));
}
else
DelClm = 0.0;
EffFreq = pow(freq, model->B3SOIDDef);
T1 = CHARGE * CHARGE * 8.62e-5 * cd * temp * here->B3SOIDDueff;
T2 = 1.0e8 * EffFreq * model->B3SOIDDcox
* pParam->B3SOIDDleff * pParam->B3SOIDDleff;
Vgst = vgs - here->B3SOIDDvon;
N0 = model->B3SOIDDcox * Vgst / CHARGE;
if (N0 < 0.0)
N0 = 0.0;
Nl = model->B3SOIDDcox * (Vgst - MIN(vds, here->B3SOIDDvdsat)) / CHARGE;
if (Nl < 0.0)
Nl = 0.0;
T3 = model->B3SOIDDoxideTrapDensityA
* log(MAX(((N0 + 2.0e14) / (Nl + 2.0e14)), N_MINLOG));
T4 = model->B3SOIDDoxideTrapDensityB * (N0 - Nl);
T5 = model->B3SOIDDoxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl);
T6 = 8.62e-5 * temp * cd * cd;
T7 = 1.0e8 * EffFreq * pParam->B3SOIDDleff
* pParam->B3SOIDDleff * pParam->B3SOIDDweff;
T8 = model->B3SOIDDoxideTrapDensityA + model->B3SOIDDoxideTrapDensityB * Nl
+ model->B3SOIDDoxideTrapDensityC * Nl * Nl;
T9 = (Nl + 2.0e14) * (Nl + 2.0e14);
Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9;
return Ssi;
}
int
B3SOIDDnoise (mode, operation, inModel, ckt, data, OnDens)
int mode, operation;
GENmodel *inModel;
CKTcircuit *ckt;
register Ndata *data;
double *OnDens;
{
register B3SOIDDmodel *model = (B3SOIDDmodel *)inModel;
register B3SOIDDinstance *here;
struct b3soiddSizeDependParam *pParam;
char name[N_MXVLNTH];
double tempOnoise;
double tempInoise;
double noizDens[B3SOIDDNSRCS];
double lnNdens[B3SOIDDNSRCS];
double vgs, vds, Slimit;
double N0, Nl;
double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13;
double n, ExpArg, Ssi, Swi;
int error, i;
/* define the names of the noise sources */
static char *B3SOIDDnNames[B3SOIDDNSRCS] =
{ /* Note that we have to keep the order */
".rd", /* noise due to rd */
/* consistent with the index definitions */
".rs", /* noise due to rs */
/* in B3SOIDDdefs.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->B3SOIDDnextModel)
{ for (here = model->B3SOIDDinstances; here != NULL;
here = here->B3SOIDDnextInstance)
{ 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 < B3SOIDDNSRCS; i++)
{ (void) sprintf(name, "onoise.%s%s",
here->B3SOIDDname,
B3SOIDDnNames[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 < B3SOIDDNSRCS; i++)
{ (void) sprintf(name, "onoise_total.%s%s",
here->B3SOIDDname,
B3SOIDDnNames[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->B3SOIDDname,
B3SOIDDnNames[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[B3SOIDDRDNOIZ],
&lnNdens[B3SOIDDRDNOIZ], ckt, THERMNOISE,
here->B3SOIDDdNodePrime, here->B3SOIDDdNode,
here->B3SOIDDdrainConductance);
NevalSrc(&noizDens[B3SOIDDRSNOIZ],
&lnNdens[B3SOIDDRSNOIZ], ckt, THERMNOISE,
here->B3SOIDDsNodePrime, here->B3SOIDDsNode,
here->B3SOIDDsourceConductance);
switch( model->B3SOIDDnoiMod )
{ case 1:
case 3:
NevalSrc(&noizDens[B3SOIDDIDNOIZ],
&lnNdens[B3SOIDDIDNOIZ], ckt,
THERMNOISE, here->B3SOIDDdNodePrime,
here->B3SOIDDsNodePrime,
(2.0 / 3.0 * fabs(here->B3SOIDDgm
+ here->B3SOIDDgds
+ here->B3SOIDDgmbs)));
break;
case 2:
case 4:
NevalSrc(&noizDens[B3SOIDDIDNOIZ],
&lnNdens[B3SOIDDIDNOIZ], ckt,
THERMNOISE, here->B3SOIDDdNodePrime,
here->B3SOIDDsNodePrime,
(here->B3SOIDDueff
* fabs(here->B3SOIDDqinv
/ (pParam->B3SOIDDleff
* pParam->B3SOIDDleff))));
break;
}
NevalSrc(&noizDens[B3SOIDDFLNOIZ], (double*) NULL,
ckt, N_GAIN, here->B3SOIDDdNodePrime,
here->B3SOIDDsNodePrime, (double) 0.0);
switch( model->B3SOIDDnoiMod )
{ case 1:
case 4:
noizDens[B3SOIDDFLNOIZ] *= model->B3SOIDDkf
* exp(model->B3SOIDDaf
* log(MAX(fabs(here->B3SOIDDcd),
N_MINLOG)))
/ (pow(data->freq, model->B3SOIDDef)
* pParam->B3SOIDDleff
* pParam->B3SOIDDleff
* model->B3SOIDDcox);
break;
case 2:
case 3:
vgs = *(ckt->CKTstates[0] + here->B3SOIDDvgs);
vds = *(ckt->CKTstates[0] + here->B3SOIDDvds);
if (vds < 0.0)
{ vds = -vds;
vgs = vgs + vds;
}
if (vgs >= here->B3SOIDDvon + 0.1)
{ Ssi = B3SOIDDStrongInversionNoiseEval(vgs,
vds, model, here, data->freq,
ckt->CKTtemp);
noizDens[B3SOIDDFLNOIZ] *= Ssi;
}
else
{ pParam = here->pParam;
T10 = model->B3SOIDDoxideTrapDensityA
* 8.62e-5 * ckt->CKTtemp;
T11 = pParam->B3SOIDDweff
* pParam->B3SOIDDleff
* pow(data->freq, model->B3SOIDDef)
* 4.0e36;
Swi = T10 / T11 * here->B3SOIDDcd
* here->B3SOIDDcd;
Slimit = B3SOIDDStrongInversionNoiseEval(
here->B3SOIDDvon + 0.1, vds, model,
here, data->freq, ckt->CKTtemp);
T1 = Swi + Slimit;
if (T1 > 0.0)
noizDens[B3SOIDDFLNOIZ] *= (Slimit
* Swi) / T1;
else
noizDens[B3SOIDDFLNOIZ] *= 0.0;
}
break;
}
lnNdens[B3SOIDDFLNOIZ] =
log(MAX(noizDens[B3SOIDDFLNOIZ], N_MINLOG));
/* Low frequency excess noise due to FBE */
NevalSrc(&noizDens[B3SOIDDFBNOIZ], &lnNdens[B3SOIDDFBNOIZ],
ckt, SHOTNOISE, here->B3SOIDDsNodePrime,
here->B3SOIDDbNode,
2.0 * model->B3SOIDDnoif * here->B3SOIDDibs);
noizDens[B3SOIDDTOTNOIZ] = noizDens[B3SOIDDRDNOIZ]
+ noizDens[B3SOIDDRSNOIZ]
+ noizDens[B3SOIDDIDNOIZ]
+ noizDens[B3SOIDDFLNOIZ]
+ noizDens[B3SOIDDFBNOIZ];
lnNdens[B3SOIDDTOTNOIZ] =
log(MAX(noizDens[B3SOIDDTOTNOIZ], N_MINLOG));
*OnDens += noizDens[B3SOIDDTOTNOIZ];
if (data->delFreq == 0.0)
{ /* if we haven't done any previous
integration, we need to initialize our
"history" variables.
*/
for (i = 0; i < B3SOIDDNSRCS; i++)
{ here->B3SOIDDnVar[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 < B3SOIDDNSRCS; i++)
{ here->B3SOIDDnVar[OUTNOIZ][i] = 0.0;
here->B3SOIDDnVar[INNOIZ][i] = 0.0;
}
}
}
else
{ /* data->delFreq != 0.0,
we have to integrate.
*/
for (i = 0; i < B3SOIDDNSRCS; i++)
{ if (i != B3SOIDDTOTNOIZ)
{ tempOnoise = Nintegrate(noizDens[i],
lnNdens[i],
here->B3SOIDDnVar[LNLSTDENS][i],
data);
tempInoise = Nintegrate(noizDens[i]
* data->GainSqInv, lnNdens[i]
+ data->lnGainInv,
here->B3SOIDDnVar[LNLSTDENS][i]
+ data->lnGainInv, data);
here->B3SOIDDnVar[LNLSTDENS][i] =
lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if (((NOISEAN*)
ckt->CKTcurJob)->NStpsSm != 0)
{ here->B3SOIDDnVar[OUTNOIZ][i]
+= tempOnoise;
here->B3SOIDDnVar[OUTNOIZ][B3SOIDDTOTNOIZ]
+= tempOnoise;
here->B3SOIDDnVar[INNOIZ][i]
+= tempInoise;
here->B3SOIDDnVar[INNOIZ][B3SOIDDTOTNOIZ]
+= tempInoise;
}
}
}
}
if (data->prtSummary)
{ for (i = 0; i < B3SOIDDNSRCS; 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 < B3SOIDDNSRCS; i++)
{ data->outpVector[data->outNumber++]
= here->B3SOIDDnVar[OUTNOIZ][i];
data->outpVector[data->outNumber++]
= here->B3SOIDDnVar[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);
}

128
src/spicelib/devices/bsim3soi_dd/b3soiddpar.c Normal file
View File

@ -0,0 +1,128 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiddpar.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "ifsim.h"
#include "b3soidddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIDDparam(param,value,inst,select)
int param;
IFvalue *value;
GENinstance *inst;
IFvalue *select;
{
B3SOIDDinstance *here = (B3SOIDDinstance*)inst;
switch(param)
{ case B3SOIDD_W:
here->B3SOIDDw = value->rValue;
here->B3SOIDDwGiven = TRUE;
break;
case B3SOIDD_L:
here->B3SOIDDl = value->rValue;
here->B3SOIDDlGiven = TRUE;
break;
case B3SOIDD_AS:
here->B3SOIDDsourceArea = value->rValue;
here->B3SOIDDsourceAreaGiven = TRUE;
break;
case B3SOIDD_AD:
here->B3SOIDDdrainArea = value->rValue;
here->B3SOIDDdrainAreaGiven = TRUE;
break;
case B3SOIDD_PS:
here->B3SOIDDsourcePerimeter = value->rValue;
here->B3SOIDDsourcePerimeterGiven = TRUE;
break;
case B3SOIDD_PD:
here->B3SOIDDdrainPerimeter = value->rValue;
here->B3SOIDDdrainPerimeterGiven = TRUE;
break;
case B3SOIDD_NRS:
here->B3SOIDDsourceSquares = value->rValue;
here->B3SOIDDsourceSquaresGiven = TRUE;
break;
case B3SOIDD_NRD:
here->B3SOIDDdrainSquares = value->rValue;
here->B3SOIDDdrainSquaresGiven = TRUE;
break;
case B3SOIDD_OFF:
here->B3SOIDDoff = value->iValue;
break;
case B3SOIDD_IC_VBS:
here->B3SOIDDicVBS = value->rValue;
here->B3SOIDDicVBSGiven = TRUE;
break;
case B3SOIDD_IC_VDS:
here->B3SOIDDicVDS = value->rValue;
here->B3SOIDDicVDSGiven = TRUE;
break;
case B3SOIDD_IC_VGS:
here->B3SOIDDicVGS = value->rValue;
here->B3SOIDDicVGSGiven = TRUE;
break;
case B3SOIDD_IC_VES:
here->B3SOIDDicVES = value->rValue;
here->B3SOIDDicVESGiven = TRUE;
break;
case B3SOIDD_IC_VPS:
here->B3SOIDDicVPS = value->rValue;
here->B3SOIDDicVPSGiven = TRUE;
break;
case B3SOIDD_BJTOFF:
here->B3SOIDDbjtoff = value->iValue;
here->B3SOIDDbjtoffGiven= TRUE;
break;
case B3SOIDD_DEBUG:
here->B3SOIDDdebugMod = value->iValue;
here->B3SOIDDdebugModGiven= TRUE;
break;
case B3SOIDD_RTH0:
here->B3SOIDDrth0= value->rValue;
here->B3SOIDDrth0Given = TRUE;
break;
case B3SOIDD_CTH0:
here->B3SOIDDcth0= value->rValue;
here->B3SOIDDcth0Given = TRUE;
break;
case B3SOIDD_NRB:
here->B3SOIDDbodySquares = value->rValue;
here->B3SOIDDbodySquaresGiven = TRUE;
break;
case B3SOIDD_IC:
switch(value->v.numValue){
case 5:
here->B3SOIDDicVPS = *(value->v.vec.rVec+4);
here->B3SOIDDicVPSGiven = TRUE;
case 4:
here->B3SOIDDicVES = *(value->v.vec.rVec+3);
here->B3SOIDDicVESGiven = TRUE;
case 3:
here->B3SOIDDicVBS = *(value->v.vec.rVec+2);
here->B3SOIDDicVBSGiven = TRUE;
case 2:
here->B3SOIDDicVGS = *(value->v.vec.rVec+1);
here->B3SOIDDicVGSGiven = TRUE;
case 1:
here->B3SOIDDicVDS = *(value->v.vec.rVec);
here->B3SOIDDicVDSGiven = TRUE;
break;
default:
return(E_BADPARM);
}
break;
default:
return(E_BADPARM);
}
return(OK);
}

153
src/spicelib/devices/bsim3soi_dd/b3soiddpzld.c Normal file
View File

@ -0,0 +1,153 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: Weidong Liu and Pin Su Feb 1999
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiddpzld.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "complex.h"
#include "sperror.h"
#include "b3soidddef.h"
#include "suffix.h"
int
B3SOIDDpzLoad(inModel,ckt,s)
GENmodel *inModel;
register CKTcircuit *ckt;
register SPcomplex *s;
{
register B3SOIDDmodel *model = (B3SOIDDmodel*)inModel;
register B3SOIDDinstance *here;
double xcggb, xcgdb, xcgsb, xcbgb, xcbdb, xcbsb, xcddb, xcssb, xcdgb;
double gdpr, gspr, gds, gbd, gbs, capbd, capbs, xcsgb, xcdsb, xcsdb;
double cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cddb, cdgb, cdsb;
double GSoverlapCap, GDoverlapCap, GBoverlapCap;
double FwdSum, RevSum, Gm, Gmbs;
for (; model != NULL; model = model->B3SOIDDnextModel)
{ for (here = model->B3SOIDDinstances; here!= NULL;
here = here->B3SOIDDnextInstance)
{
if (here->B3SOIDDmode >= 0)
{ Gm = here->B3SOIDDgm;
Gmbs = here->B3SOIDDgmbs;
FwdSum = Gm + Gmbs;
RevSum = 0.0;
cggb = here->B3SOIDDcggb;
cgsb = here->B3SOIDDcgsb;
cgdb = here->B3SOIDDcgdb;
cbgb = here->B3SOIDDcbgb;
cbsb = here->B3SOIDDcbsb;
cbdb = here->B3SOIDDcbdb;
cdgb = here->B3SOIDDcdgb;
cdsb = here->B3SOIDDcdsb;
cddb = here->B3SOIDDcddb;
}
else
{ Gm = -here->B3SOIDDgm;
Gmbs = -here->B3SOIDDgmbs;
FwdSum = 0.0;
RevSum = -Gm - Gmbs;
cggb = here->B3SOIDDcggb;
cgsb = here->B3SOIDDcgdb;
cgdb = here->B3SOIDDcgsb;
cbgb = here->B3SOIDDcbgb;
cbsb = here->B3SOIDDcbdb;
cbdb = here->B3SOIDDcbsb;
cdgb = -(here->B3SOIDDcdgb + cggb + cbgb);
cdsb = -(here->B3SOIDDcddb + cgsb + cbsb);
cddb = -(here->B3SOIDDcdsb + cgdb + cbdb);
}
gdpr=here->B3SOIDDdrainConductance;
gspr=here->B3SOIDDsourceConductance;
gds= here->B3SOIDDgds;
gbd= here->B3SOIDDgjdb;
gbs= here->B3SOIDDgjsb;
#ifdef BULKCODE
capbd= here->B3SOIDDcapbd;
capbs= here->B3SOIDDcapbs;
#endif
GSoverlapCap = here->B3SOIDDcgso;
GDoverlapCap = here->B3SOIDDcgdo;
#ifdef BULKCODE
GBoverlapCap = here->pParam->B3SOIDDcgbo;
#endif
xcdgb = (cdgb - GDoverlapCap);
xcddb = (cddb + capbd + GDoverlapCap);
xcdsb = cdsb;
xcsgb = -(cggb + cbgb + cdgb + GSoverlapCap);
xcsdb = -(cgdb + cbdb + cddb);
xcssb = (capbs + GSoverlapCap - (cgsb+cbsb+cdsb));
xcggb = (cggb + GDoverlapCap + GSoverlapCap + GBoverlapCap);
xcgdb = (cgdb - GDoverlapCap);
xcgsb = (cgsb - GSoverlapCap);
xcbgb = (cbgb - GBoverlapCap);
xcbdb = (cbdb - capbd);
xcbsb = (cbsb - capbs);
*(here->B3SOIDDGgPtr ) += xcggb * s->real;
*(here->B3SOIDDGgPtr +1) += xcggb * s->imag;
*(here->B3SOIDDBbPtr ) += (-xcbgb-xcbdb-xcbsb) * s->real;
*(here->B3SOIDDBbPtr +1) += (-xcbgb-xcbdb-xcbsb) * s->imag;
*(here->B3SOIDDDPdpPtr ) += xcddb * s->real;
*(here->B3SOIDDDPdpPtr +1) += xcddb * s->imag;
*(here->B3SOIDDSPspPtr ) += xcssb * s->real;
*(here->B3SOIDDSPspPtr +1) += xcssb * s->imag;
*(here->B3SOIDDGbPtr ) += (-xcggb-xcgdb-xcgsb) * s->real;
*(here->B3SOIDDGbPtr +1) += (-xcggb-xcgdb-xcgsb) * s->imag;
*(here->B3SOIDDGdpPtr ) += xcgdb * s->real;
*(here->B3SOIDDGdpPtr +1) += xcgdb * s->imag;
*(here->B3SOIDDGspPtr ) += xcgsb * s->real;
*(here->B3SOIDDGspPtr +1) += xcgsb * s->imag;
*(here->B3SOIDDBgPtr ) += xcbgb * s->real;
*(here->B3SOIDDBgPtr +1) += xcbgb * s->imag;
*(here->B3SOIDDBdpPtr ) += xcbdb * s->real;
*(here->B3SOIDDBdpPtr +1) += xcbdb * s->imag;
*(here->B3SOIDDBspPtr ) += xcbsb * s->real;
*(here->B3SOIDDBspPtr +1) += xcbsb * s->imag;
*(here->B3SOIDDDPgPtr ) += xcdgb * s->real;
*(here->B3SOIDDDPgPtr +1) += xcdgb * s->imag;
*(here->B3SOIDDDPbPtr ) += (-xcdgb-xcddb-xcdsb) * s->real;
*(here->B3SOIDDDPbPtr +1) += (-xcdgb-xcddb-xcdsb) * s->imag;
*(here->B3SOIDDDPspPtr ) += xcdsb * s->real;
*(here->B3SOIDDDPspPtr +1) += xcdsb * s->imag;
*(here->B3SOIDDSPgPtr ) += xcsgb * s->real;
*(here->B3SOIDDSPgPtr +1) += xcsgb * s->imag;
*(here->B3SOIDDSPbPtr ) += (-xcsgb-xcsdb-xcssb) * s->real;
*(here->B3SOIDDSPbPtr +1) += (-xcsgb-xcsdb-xcssb) * s->imag;
*(here->B3SOIDDSPdpPtr ) += xcsdb * s->real;
*(here->B3SOIDDSPdpPtr +1) += xcsdb * s->imag;
*(here->B3SOIDDDdPtr) += gdpr;
*(here->B3SOIDDSsPtr) += gspr;
*(here->B3SOIDDBbPtr) += gbd+gbs;
*(here->B3SOIDDDPdpPtr) += gdpr+gds+gbd+RevSum;
*(here->B3SOIDDSPspPtr) += gspr+gds+gbs+FwdSum;
*(here->B3SOIDDDdpPtr) -= gdpr;
*(here->B3SOIDDSspPtr) -= gspr;
*(here->B3SOIDDBdpPtr) -= gbd;
*(here->B3SOIDDBspPtr) -= gbs;
*(here->B3SOIDDDPdPtr) -= gdpr;
*(here->B3SOIDDDPgPtr) += Gm;
*(here->B3SOIDDDPbPtr) -= gbd - Gmbs;
*(here->B3SOIDDDPspPtr) -= gds + FwdSum;
*(here->B3SOIDDSPgPtr) -= Gm;
*(here->B3SOIDDSPsPtr) -= gspr;
*(here->B3SOIDDSPbPtr) -= gbs + Gmbs;
*(here->B3SOIDDSPdpPtr) -= gds + RevSum;
}
}
return(OK);
}

1353
src/spicelib/devices/bsim3soi_dd/b3soiddset.c Normal file
View File

File diff suppressed because it is too large Load Diff

816
src/spicelib/devices/bsim3soi_dd/b3soiddtemp.c Normal file
View File

@ -0,0 +1,816 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: Weidong Liu and Pin Su Feb 1999
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
Modified by Pin Su, Wei Jin 99/9/27
File: b3soiddtemp.c 98/5/01
**********/
/* Lmin, Lmax, Wmin, Wmax */
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "smpdefs.h"
#include "cktdefs.h"
#include "b3soidddef.h"
#include "const.h"
#include "sperror.h"
#include "suffix.h"
#define Kb 1.3806226e-23
#define KboQ 8.617087e-5 /* Kb / q where q = 1.60219e-19 */
#define EPSOX 3.453133e-11
#define EPSSI 1.03594e-10
#define PI 3.141592654
#define MAX_EXP 5.834617425e14
#define MIN_EXP 1.713908431e-15
#define EXP_THRESHOLD 34.0
#define Charge_q 1.60219e-19
/* ARGSUSED */
int
B3SOIDDtemp(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
register B3SOIDDmodel *model = (B3SOIDDmodel*) inModel;
register B3SOIDDinstance *here;
struct b3soiddSizeDependParam *pSizeDependParamKnot, *pLastKnot, *pParam;
double tmp, tmp1, tmp2, Eg, Eg0, ni, T0, T1, T2, T3, T4, T5, T6, Ldrn, Wdrn;
double Temp, TRatio, Inv_L, Inv_W, Inv_LW, Dw, Dl, Vtm0, Tnom;
double SDphi, SDgamma;
int Size_Not_Found;
/* loop through all the B3SOIDD device models */
for (; model != NULL; model = model->B3SOIDDnextModel)
{ Temp = ckt->CKTtemp;
if (model->B3SOIDDGatesidewallJctPotential < 0.1)
model->B3SOIDDGatesidewallJctPotential = 0.1;
model->pSizeDependParamKnot = NULL;
pLastKnot = NULL;
Tnom = model->B3SOIDDtnom;
TRatio = Temp / Tnom;
model->B3SOIDDvcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14));
model->B3SOIDDfactor1 = sqrt(EPSSI / EPSOX * model->B3SOIDDtox);
Vtm0 = KboQ * Tnom;
Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0);
model->B3SOIDDeg0 = Eg0;
model->B3SOIDDvtm = KboQ * Temp;
Eg = 1.16 - 7.02e-4 * Temp * Temp / (Temp + 1108.0);
/* ni is in cm^-3 */
ni = 1.45e10 * (Temp / 300.15) * sqrt(Temp / 300.15)
* exp(21.5565981 - Eg / (2.0 * model->B3SOIDDvtm));
/* loop through all the instances of the model */
/* MCJ: Length and Width not initialized */
for (here = model->B3SOIDDinstances; here != NULL;
here = here->B3SOIDDnextInstance)
{
here->B3SOIDDrbodyext = here->B3SOIDDbodySquares *
model->B3SOIDDrbsh;
pSizeDependParamKnot = model->pSizeDependParamKnot;
Size_Not_Found = 1;
while ((pSizeDependParamKnot != NULL) && Size_Not_Found)
{ if ((here->B3SOIDDl == pSizeDependParamKnot->Length)
&& (here->B3SOIDDw == pSizeDependParamKnot->Width)
&& (here->B3SOIDDrth0 == pSizeDependParamKnot->Rth0)
&& (here->B3SOIDDcth0 == pSizeDependParamKnot->Cth0))
{ Size_Not_Found = 0;
here->pParam = pSizeDependParamKnot;
}
else
{ pLastKnot = pSizeDependParamKnot;
pSizeDependParamKnot = pSizeDependParamKnot->pNext;
}
}
if (Size_Not_Found)
{ pParam = (struct b3soiddSizeDependParam *)malloc(
sizeof(struct b3soiddSizeDependParam));
if (pLastKnot == NULL)
model->pSizeDependParamKnot = pParam;
else
pLastKnot->pNext = pParam;
pParam->pNext = NULL;
here->pParam = pParam;
Ldrn = here->B3SOIDDl;
Wdrn = here->B3SOIDDw;
pParam->Length = Ldrn;
pParam->Width = Wdrn;
pParam->Rth0 = here->B3SOIDDrth0;
pParam->Cth0 = here->B3SOIDDcth0;
T0 = pow(Ldrn, model->B3SOIDDLln);
T1 = pow(Wdrn, model->B3SOIDDLwn);
tmp1 = model->B3SOIDDLl / T0 + model->B3SOIDDLw / T1
+ model->B3SOIDDLwl / (T0 * T1);
pParam->B3SOIDDdl = model->B3SOIDDLint + tmp1;
pParam->B3SOIDDdlc = model->B3SOIDDdlc + tmp1;
T2 = pow(Ldrn, model->B3SOIDDWln);
T3 = pow(Wdrn, model->B3SOIDDWwn);
tmp2 = model->B3SOIDDWl / T2 + model->B3SOIDDWw / T3
+ model->B3SOIDDWwl / (T2 * T3);
pParam->B3SOIDDdw = model->B3SOIDDWint + tmp2;
pParam->B3SOIDDdwc = model->B3SOIDDdwc + tmp2;
pParam->B3SOIDDleff = here->B3SOIDDl - 2.0 * pParam->B3SOIDDdl;
if (pParam->B3SOIDDleff <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->B3SOIDDmodName;
namarray[1] = here->B3SOIDDname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"B3SOIDD: mosfet %s, model %s: Effective channel length <= 0",
namarray);
return(E_BADPARM);
}
pParam->B3SOIDDweff = here->B3SOIDDw - 2.0 * pParam->B3SOIDDdw;
if (pParam->B3SOIDDweff <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->B3SOIDDmodName;
namarray[1] = here->B3SOIDDname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"B3SOIDD: mosfet %s, model %s: Effective channel width <= 0",
namarray);
return(E_BADPARM);
}
pParam->B3SOIDDleffCV = here->B3SOIDDl - 2.0 * pParam->B3SOIDDdlc;
if (pParam->B3SOIDDleffCV <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->B3SOIDDmodName;
namarray[1] = here->B3SOIDDname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"B3SOIDD: mosfet %s, model %s: Effective channel length for C-V <= 0",
namarray);
return(E_BADPARM);
}
pParam->B3SOIDDweffCV = here->B3SOIDDw - 2.0 * pParam->B3SOIDDdwc;
if (pParam->B3SOIDDweffCV <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->B3SOIDDmodName;
namarray[1] = here->B3SOIDDname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"B3SOIDD: mosfet %s, model %s: Effective channel width for C-V <= 0",
namarray);
return(E_BADPARM);
}
/* Not binned - START */
pParam->B3SOIDDat = model->B3SOIDDat;
pParam->B3SOIDDgamma1 = model->B3SOIDDgamma1;
pParam->B3SOIDDgamma2 = model->B3SOIDDgamma2;
pParam->B3SOIDDvbx = model->B3SOIDDvbx;
pParam->B3SOIDDvbm = model->B3SOIDDvbm;
pParam->B3SOIDDxt = model->B3SOIDDxt;
pParam->B3SOIDDkt1 = model->B3SOIDDkt1;
pParam->B3SOIDDkt1l = model->B3SOIDDkt1l;
pParam->B3SOIDDkt2 = model->B3SOIDDkt2;
pParam->B3SOIDDua1 = model->B3SOIDDua1;
pParam->B3SOIDDub1 = model->B3SOIDDub1;
pParam->B3SOIDDuc1 = model->B3SOIDDuc1;
pParam->B3SOIDDute = model->B3SOIDDute;
pParam->B3SOIDDprt = model->B3SOIDDprt;
/* Not binned - END */
/* CV model */
pParam->B3SOIDDcgsl = model->B3SOIDDcgsl;
pParam->B3SOIDDcgdl = model->B3SOIDDcgdl;
pParam->B3SOIDDckappa = model->B3SOIDDckappa;
pParam->B3SOIDDcf = model->B3SOIDDcf;
pParam->B3SOIDDclc = model->B3SOIDDclc;
pParam->B3SOIDDcle = model->B3SOIDDcle;
pParam->B3SOIDDabulkCVfactor = pow(1.0+(pParam->B3SOIDDclc
/ pParam->B3SOIDDleff),
pParam->B3SOIDDcle);
/* Added for binning - START */
if (model->B3SOIDDbinUnit == 1)
{ Inv_L = 1.0e-6 / pParam->B3SOIDDleff;
Inv_W = 1.0e-6 / pParam->B3SOIDDweff;
Inv_LW = 1.0e-12 / (pParam->B3SOIDDleff
* pParam->B3SOIDDweff);
}
else
{ Inv_L = 1.0 / pParam->B3SOIDDleff;
Inv_W = 1.0 / pParam->B3SOIDDweff;
Inv_LW = 1.0 / (pParam->B3SOIDDleff
* pParam->B3SOIDDweff);
}
pParam->B3SOIDDnpeak = model->B3SOIDDnpeak
+ model->B3SOIDDlnpeak * Inv_L
+ model->B3SOIDDwnpeak * Inv_W
+ model->B3SOIDDpnpeak * Inv_LW;
pParam->B3SOIDDnsub = model->B3SOIDDnsub
+ model->B3SOIDDlnsub * Inv_L
+ model->B3SOIDDwnsub * Inv_W
+ model->B3SOIDDpnsub * Inv_LW;
pParam->B3SOIDDngate = model->B3SOIDDngate
+ model->B3SOIDDlngate * Inv_L
+ model->B3SOIDDwngate * Inv_W
+ model->B3SOIDDpngate * Inv_LW;
pParam->B3SOIDDvth0 = model->B3SOIDDvth0
+ model->B3SOIDDlvth0 * Inv_L
+ model->B3SOIDDwvth0 * Inv_W
+ model->B3SOIDDpvth0 * Inv_LW;
pParam->B3SOIDDk1 = model->B3SOIDDk1
+ model->B3SOIDDlk1 * Inv_L
+ model->B3SOIDDwk1 * Inv_W
+ model->B3SOIDDpk1 * Inv_LW;
pParam->B3SOIDDk2 = model->B3SOIDDk2
+ model->B3SOIDDlk2 * Inv_L
+ model->B3SOIDDwk2 * Inv_W
+ model->B3SOIDDpk2 * Inv_LW;
pParam->B3SOIDDk3 = model->B3SOIDDk3
+ model->B3SOIDDlk3 * Inv_L
+ model->B3SOIDDwk3 * Inv_W
+ model->B3SOIDDpk3 * Inv_LW;
pParam->B3SOIDDk3b = model->B3SOIDDk3b
+ model->B3SOIDDlk3b * Inv_L
+ model->B3SOIDDwk3b * Inv_W
+ model->B3SOIDDpk3b * Inv_LW;
pParam->B3SOIDDvbsa = model->B3SOIDDvbsa
+ model->B3SOIDDlvbsa * Inv_L
+ model->B3SOIDDwvbsa * Inv_W
+ model->B3SOIDDpvbsa * Inv_LW;
pParam->B3SOIDDdelp = model->B3SOIDDdelp
+ model->B3SOIDDldelp * Inv_L
+ model->B3SOIDDwdelp * Inv_W
+ model->B3SOIDDpdelp * Inv_LW;
pParam->B3SOIDDkb1 = model->B3SOIDDkb1
+ model->B3SOIDDlkb1 * Inv_L
+ model->B3SOIDDwkb1 * Inv_W
+ model->B3SOIDDpkb1 * Inv_LW;
pParam->B3SOIDDkb3 = model->B3SOIDDkb3
+ model->B3SOIDDlkb3 * Inv_L
+ model->B3SOIDDwkb3 * Inv_W
+ model->B3SOIDDpkb3 * Inv_LW;
pParam->B3SOIDDdvbd0 = model->B3SOIDDdvbd0
+ model->B3SOIDDldvbd0 * Inv_L
+ model->B3SOIDDwdvbd0 * Inv_W
+ model->B3SOIDDpdvbd0 * Inv_LW;
pParam->B3SOIDDdvbd1 = model->B3SOIDDdvbd1
+ model->B3SOIDDldvbd1 * Inv_L
+ model->B3SOIDDwdvbd1 * Inv_W
+ model->B3SOIDDpdvbd1 * Inv_LW;
pParam->B3SOIDDw0 = model->B3SOIDDw0
+ model->B3SOIDDlw0 * Inv_L
+ model->B3SOIDDww0 * Inv_W
+ model->B3SOIDDpw0 * Inv_LW;
pParam->B3SOIDDnlx = model->B3SOIDDnlx
+ model->B3SOIDDlnlx * Inv_L
+ model->B3SOIDDwnlx * Inv_W
+ model->B3SOIDDpnlx * Inv_LW;
pParam->B3SOIDDdvt0 = model->B3SOIDDdvt0
+ model->B3SOIDDldvt0 * Inv_L
+ model->B3SOIDDwdvt0 * Inv_W
+ model->B3SOIDDpdvt0 * Inv_LW;
pParam->B3SOIDDdvt1 = model->B3SOIDDdvt1
+ model->B3SOIDDldvt1 * Inv_L
+ model->B3SOIDDwdvt1 * Inv_W
+ model->B3SOIDDpdvt1 * Inv_LW;
pParam->B3SOIDDdvt2 = model->B3SOIDDdvt2
+ model->B3SOIDDldvt2 * Inv_L
+ model->B3SOIDDwdvt2 * Inv_W
+ model->B3SOIDDpdvt2 * Inv_LW;
pParam->B3SOIDDdvt0w = model->B3SOIDDdvt0w
+ model->B3SOIDDldvt0w * Inv_L
+ model->B3SOIDDwdvt0w * Inv_W
+ model->B3SOIDDpdvt0w * Inv_LW;
pParam->B3SOIDDdvt1w = model->B3SOIDDdvt1w
+ model->B3SOIDDldvt1w * Inv_L
+ model->B3SOIDDwdvt1w * Inv_W
+ model->B3SOIDDpdvt1w * Inv_LW;
pParam->B3SOIDDdvt2w = model->B3SOIDDdvt2w
+ model->B3SOIDDldvt2w * Inv_L
+ model->B3SOIDDwdvt2w * Inv_W
+ model->B3SOIDDpdvt2w * Inv_LW;
pParam->B3SOIDDu0 = model->B3SOIDDu0
+ model->B3SOIDDlu0 * Inv_L
+ model->B3SOIDDwu0 * Inv_W
+ model->B3SOIDDpu0 * Inv_LW;
pParam->B3SOIDDua = model->B3SOIDDua
+ model->B3SOIDDlua * Inv_L
+ model->B3SOIDDwua * Inv_W
+ model->B3SOIDDpua * Inv_LW;
pParam->B3SOIDDub = model->B3SOIDDub
+ model->B3SOIDDlub * Inv_L
+ model->B3SOIDDwub * Inv_W
+ model->B3SOIDDpub * Inv_LW;
pParam->B3SOIDDuc = model->B3SOIDDuc
+ model->B3SOIDDluc * Inv_L
+ model->B3SOIDDwuc * Inv_W
+ model->B3SOIDDpuc * Inv_LW;
pParam->B3SOIDDvsat = model->B3SOIDDvsat
+ model->B3SOIDDlvsat * Inv_L
+ model->B3SOIDDwvsat * Inv_W
+ model->B3SOIDDpvsat * Inv_LW;
pParam->B3SOIDDa0 = model->B3SOIDDa0
+ model->B3SOIDDla0 * Inv_L
+ model->B3SOIDDwa0 * Inv_W
+ model->B3SOIDDpa0 * Inv_LW;
pParam->B3SOIDDags = model->B3SOIDDags
+ model->B3SOIDDlags * Inv_L
+ model->B3SOIDDwags * Inv_W
+ model->B3SOIDDpags * Inv_LW;
pParam->B3SOIDDb0 = model->B3SOIDDb0
+ model->B3SOIDDlb0 * Inv_L
+ model->B3SOIDDwb0 * Inv_W
+ model->B3SOIDDpb0 * Inv_LW;
pParam->B3SOIDDb1 = model->B3SOIDDb1
+ model->B3SOIDDlb1 * Inv_L
+ model->B3SOIDDwb1 * Inv_W
+ model->B3SOIDDpb1 * Inv_LW;
pParam->B3SOIDDketa = model->B3SOIDDketa
+ model->B3SOIDDlketa * Inv_L
+ model->B3SOIDDwketa * Inv_W
+ model->B3SOIDDpketa * Inv_LW;
pParam->B3SOIDDabp = model->B3SOIDDabp
+ model->B3SOIDDlabp * Inv_L
+ model->B3SOIDDwabp * Inv_W
+ model->B3SOIDDpabp * Inv_LW;
pParam->B3SOIDDmxc = model->B3SOIDDmxc
+ model->B3SOIDDlmxc * Inv_L
+ model->B3SOIDDwmxc * Inv_W
+ model->B3SOIDDpmxc * Inv_LW;
pParam->B3SOIDDadice0 = model->B3SOIDDadice0
+ model->B3SOIDDladice0 * Inv_L
+ model->B3SOIDDwadice0 * Inv_W
+ model->B3SOIDDpadice0 * Inv_LW;
pParam->B3SOIDDa1 = model->B3SOIDDa1
+ model->B3SOIDDla1 * Inv_L
+ model->B3SOIDDwa1 * Inv_W
+ model->B3SOIDDpa1 * Inv_LW;
pParam->B3SOIDDa2 = model->B3SOIDDa2
+ model->B3SOIDDla2 * Inv_L
+ model->B3SOIDDwa2 * Inv_W
+ model->B3SOIDDpa2 * Inv_LW;
pParam->B3SOIDDrdsw = model->B3SOIDDrdsw
+ model->B3SOIDDlrdsw * Inv_L
+ model->B3SOIDDwrdsw * Inv_W
+ model->B3SOIDDprdsw * Inv_LW;
pParam->B3SOIDDprwb = model->B3SOIDDprwb
+ model->B3SOIDDlprwb * Inv_L
+ model->B3SOIDDwprwb * Inv_W
+ model->B3SOIDDpprwb * Inv_LW;
pParam->B3SOIDDprwg = model->B3SOIDDprwg
+ model->B3SOIDDlprwg * Inv_L
+ model->B3SOIDDwprwg * Inv_W
+ model->B3SOIDDpprwg * Inv_LW;
pParam->B3SOIDDwr = model->B3SOIDDwr
+ model->B3SOIDDlwr * Inv_L
+ model->B3SOIDDwwr * Inv_W
+ model->B3SOIDDpwr * Inv_LW;
pParam->B3SOIDDnfactor = model->B3SOIDDnfactor
+ model->B3SOIDDlnfactor * Inv_L
+ model->B3SOIDDwnfactor * Inv_W
+ model->B3SOIDDpnfactor * Inv_LW;
pParam->B3SOIDDdwg = model->B3SOIDDdwg
+ model->B3SOIDDldwg * Inv_L
+ model->B3SOIDDwdwg * Inv_W
+ model->B3SOIDDpdwg * Inv_LW;
pParam->B3SOIDDdwb = model->B3SOIDDdwb
+ model->B3SOIDDldwb * Inv_L
+ model->B3SOIDDwdwb * Inv_W
+ model->B3SOIDDpdwb * Inv_LW;
pParam->B3SOIDDvoff = model->B3SOIDDvoff
+ model->B3SOIDDlvoff * Inv_L
+ model->B3SOIDDwvoff * Inv_W
+ model->B3SOIDDpvoff * Inv_LW;
pParam->B3SOIDDeta0 = model->B3SOIDDeta0
+ model->B3SOIDDleta0 * Inv_L
+ model->B3SOIDDweta0 * Inv_W
+ model->B3SOIDDpeta0 * Inv_LW;
pParam->B3SOIDDetab = model->B3SOIDDetab
+ model->B3SOIDDletab * Inv_L
+ model->B3SOIDDwetab * Inv_W
+ model->B3SOIDDpetab * Inv_LW;
pParam->B3SOIDDdsub = model->B3SOIDDdsub
+ model->B3SOIDDldsub * Inv_L
+ model->B3SOIDDwdsub * Inv_W
+ model->B3SOIDDpdsub * Inv_LW;
pParam->B3SOIDDcit = model->B3SOIDDcit
+ model->B3SOIDDlcit * Inv_L
+ model->B3SOIDDwcit * Inv_W
+ model->B3SOIDDpcit * Inv_LW;
pParam->B3SOIDDcdsc = model->B3SOIDDcdsc
+ model->B3SOIDDlcdsc * Inv_L
+ model->B3SOIDDwcdsc * Inv_W
+ model->B3SOIDDpcdsc * Inv_LW;
pParam->B3SOIDDcdscb = model->B3SOIDDcdscb
+ model->B3SOIDDlcdscb * Inv_L
+ model->B3SOIDDwcdscb * Inv_W
+ model->B3SOIDDpcdscb * Inv_LW;
pParam->B3SOIDDcdscd = model->B3SOIDDcdscd
+ model->B3SOIDDlcdscd * Inv_L
+ model->B3SOIDDwcdscd * Inv_W
+ model->B3SOIDDpcdscd * Inv_LW;
pParam->B3SOIDDpclm = model->B3SOIDDpclm
+ model->B3SOIDDlpclm * Inv_L
+ model->B3SOIDDwpclm * Inv_W
+ model->B3SOIDDppclm * Inv_LW;
pParam->B3SOIDDpdibl1 = model->B3SOIDDpdibl1
+ model->B3SOIDDlpdibl1 * Inv_L
+ model->B3SOIDDwpdibl1 * Inv_W
+ model->B3SOIDDppdibl1 * Inv_LW;
pParam->B3SOIDDpdibl2 = model->B3SOIDDpdibl2
+ model->B3SOIDDlpdibl2 * Inv_L
+ model->B3SOIDDwpdibl2 * Inv_W
+ model->B3SOIDDppdibl2 * Inv_LW;
pParam->B3SOIDDpdiblb = model->B3SOIDDpdiblb
+ model->B3SOIDDlpdiblb * Inv_L
+ model->B3SOIDDwpdiblb * Inv_W
+ model->B3SOIDDppdiblb * Inv_LW;
pParam->B3SOIDDdrout = model->B3SOIDDdrout
+ model->B3SOIDDldrout * Inv_L
+ model->B3SOIDDwdrout * Inv_W
+ model->B3SOIDDpdrout * Inv_LW;
pParam->B3SOIDDpvag = model->B3SOIDDpvag
+ model->B3SOIDDlpvag * Inv_L
+ model->B3SOIDDwpvag * Inv_W
+ model->B3SOIDDppvag * Inv_LW;
pParam->B3SOIDDdelta = model->B3SOIDDdelta
+ model->B3SOIDDldelta * Inv_L
+ model->B3SOIDDwdelta * Inv_W
+ model->B3SOIDDpdelta * Inv_LW;
pParam->B3SOIDDaii = model->B3SOIDDaii
+ model->B3SOIDDlaii * Inv_L
+ model->B3SOIDDwaii * Inv_W
+ model->B3SOIDDpaii * Inv_LW;
pParam->B3SOIDDbii = model->B3SOIDDbii
+ model->B3SOIDDlbii * Inv_L
+ model->B3SOIDDwbii * Inv_W
+ model->B3SOIDDpbii * Inv_LW;
pParam->B3SOIDDcii = model->B3SOIDDcii
+ model->B3SOIDDlcii * Inv_L
+ model->B3SOIDDwcii * Inv_W
+ model->B3SOIDDpcii * Inv_LW;
pParam->B3SOIDDdii = model->B3SOIDDdii
+ model->B3SOIDDldii * Inv_L
+ model->B3SOIDDwdii * Inv_W
+ model->B3SOIDDpdii * Inv_LW;
pParam->B3SOIDDalpha0 = model->B3SOIDDalpha0
+ model->B3SOIDDlalpha0 * Inv_L
+ model->B3SOIDDwalpha0 * Inv_W
+ model->B3SOIDDpalpha0 * Inv_LW;
pParam->B3SOIDDalpha1 = model->B3SOIDDalpha1
+ model->B3SOIDDlalpha1 * Inv_L
+ model->B3SOIDDwalpha1 * Inv_W
+ model->B3SOIDDpalpha1 * Inv_LW;
pParam->B3SOIDDbeta0 = model->B3SOIDDbeta0
+ model->B3SOIDDlbeta0 * Inv_L
+ model->B3SOIDDwbeta0 * Inv_W
+ model->B3SOIDDpbeta0 * Inv_LW;
pParam->B3SOIDDagidl = model->B3SOIDDagidl
+ model->B3SOIDDlagidl * Inv_L
+ model->B3SOIDDwagidl * Inv_W
+ model->B3SOIDDpagidl * Inv_LW;
pParam->B3SOIDDbgidl = model->B3SOIDDbgidl
+ model->B3SOIDDlbgidl * Inv_L
+ model->B3SOIDDwbgidl * Inv_W
+ model->B3SOIDDpbgidl * Inv_LW;
pParam->B3SOIDDngidl = model->B3SOIDDngidl
+ model->B3SOIDDlngidl * Inv_L
+ model->B3SOIDDwngidl * Inv_W
+ model->B3SOIDDpngidl * Inv_LW;
pParam->B3SOIDDntun = model->B3SOIDDntun
+ model->B3SOIDDlntun * Inv_L
+ model->B3SOIDDwntun * Inv_W
+ model->B3SOIDDpntun * Inv_LW;
pParam->B3SOIDDndiode = model->B3SOIDDndiode
+ model->B3SOIDDlndiode * Inv_L
+ model->B3SOIDDwndiode * Inv_W
+ model->B3SOIDDpndiode * Inv_LW;
pParam->B3SOIDDisbjt = model->B3SOIDDisbjt
+ model->B3SOIDDlisbjt * Inv_L
+ model->B3SOIDDwisbjt * Inv_W
+ model->B3SOIDDpisbjt * Inv_LW;
pParam->B3SOIDDisdif = model->B3SOIDDisdif
+ model->B3SOIDDlisdif * Inv_L
+ model->B3SOIDDwisdif * Inv_W
+ model->B3SOIDDpisdif * Inv_LW;
pParam->B3SOIDDisrec = model->B3SOIDDisrec
+ model->B3SOIDDlisrec * Inv_L
+ model->B3SOIDDwisrec * Inv_W
+ model->B3SOIDDpisrec * Inv_LW;
pParam->B3SOIDDistun = model->B3SOIDDistun
+ model->B3SOIDDlistun * Inv_L
+ model->B3SOIDDwistun * Inv_W
+ model->B3SOIDDpistun * Inv_LW;
pParam->B3SOIDDedl = model->B3SOIDDedl
+ model->B3SOIDDledl * Inv_L
+ model->B3SOIDDwedl * Inv_W
+ model->B3SOIDDpedl * Inv_LW;
pParam->B3SOIDDkbjt1 = model->B3SOIDDkbjt1
+ model->B3SOIDDlkbjt1 * Inv_L
+ model->B3SOIDDwkbjt1 * Inv_W
+ model->B3SOIDDpkbjt1 * Inv_LW;
/* CV model */
pParam->B3SOIDDvsdfb = model->B3SOIDDvsdfb
+ model->B3SOIDDlvsdfb * Inv_L
+ model->B3SOIDDwvsdfb * Inv_W
+ model->B3SOIDDpvsdfb * Inv_LW;
pParam->B3SOIDDvsdth = model->B3SOIDDvsdth
+ model->B3SOIDDlvsdth * Inv_L
+ model->B3SOIDDwvsdth * Inv_W
+ model->B3SOIDDpvsdth * Inv_LW;
/* Added for binning - END */
T0 = (TRatio - 1.0);
pParam->B3SOIDDuatemp = pParam->B3SOIDDua; /* save ua, ub, and uc for b3soild.c */
pParam->B3SOIDDubtemp = pParam->B3SOIDDub;
pParam->B3SOIDDuctemp = pParam->B3SOIDDuc;
pParam->B3SOIDDrds0denom = pow(pParam->B3SOIDDweff * 1E6, pParam->B3SOIDDwr);
pParam->B3SOIDDrth = here->B3SOIDDrth0 * sqrt(model->B3SOIDDtbox
/ model->B3SOIDDtsi) / pParam->B3SOIDDweff;
pParam->B3SOIDDcth = here->B3SOIDDcth0 * model->B3SOIDDtsi;
pParam->B3SOIDDrbody = model->B3SOIDDrbody *
pParam->B3SOIDDweff / pParam->B3SOIDDleff;
pParam->B3SOIDDua = pParam->B3SOIDDua + pParam->B3SOIDDua1 * T0;
pParam->B3SOIDDub = pParam->B3SOIDDub + pParam->B3SOIDDub1 * T0;
pParam->B3SOIDDuc = pParam->B3SOIDDuc + pParam->B3SOIDDuc1 * T0;
if (pParam->B3SOIDDu0 > 1.0)
pParam->B3SOIDDu0 = pParam->B3SOIDDu0 / 1.0e4;
pParam->B3SOIDDu0temp = pParam->B3SOIDDu0
* pow(TRatio, pParam->B3SOIDDute);
pParam->B3SOIDDvsattemp = pParam->B3SOIDDvsat - pParam->B3SOIDDat
* T0;
pParam->B3SOIDDrds0 = (pParam->B3SOIDDrdsw + pParam->B3SOIDDprt * T0)
/ pow(pParam->B3SOIDDweff * 1E6, pParam->B3SOIDDwr);
if (B3SOIDDcheckModel(model, here, ckt))
{ IFuid namarray[2];
namarray[0] = model->B3SOIDDmodName;
namarray[1] = here->B3SOIDDname;
(*(SPfrontEnd->IFerror)) (ERR_FATAL, "Fatal error(s) detected during B3SOIDDV3 parameter checking for %s in model %s", namarray);
return(E_BADPARM);
}
pParam->B3SOIDDcgdo = (model->B3SOIDDcgdo + pParam->B3SOIDDcf)
* pParam->B3SOIDDweffCV;
pParam->B3SOIDDcgso = (model->B3SOIDDcgso + pParam->B3SOIDDcf)
* pParam->B3SOIDDweffCV;
pParam->B3SOIDDcgeo = model->B3SOIDDcgeo
* pParam->B3SOIDDleffCV;
if (!model->B3SOIDDnpeakGiven && model->B3SOIDDgamma1Given)
{ T0 = pParam->B3SOIDDgamma1 * model->B3SOIDDcox;
pParam->B3SOIDDnpeak = 3.021E22 * T0 * T0;
}
T0 = pow(TRatio, model->B3SOIDDxbjt / pParam->B3SOIDDndiode);
T1 = pow(TRatio, model->B3SOIDDxdif / pParam->B3SOIDDndiode);
T2 = pow(TRatio, model->B3SOIDDxrec / pParam->B3SOIDDndiode / 2);
T4 = -Eg0 / pParam->B3SOIDDndiode / model->B3SOIDDvtm * (1 - TRatio);
T5 = exp(T4);
T6 = sqrt(T5);
pParam->B3SOIDDjbjt = pParam->B3SOIDDisbjt * T0 * T5;
pParam->B3SOIDDjdif = pParam->B3SOIDDisdif * T1 * T5;
pParam->B3SOIDDjrec = pParam->B3SOIDDisrec * T2 * T6;
T0 = pow(TRatio, model->B3SOIDDxtun / pParam->B3SOIDDntun);
pParam->B3SOIDDjtun = pParam->B3SOIDDistun * T0 ;
if (pParam->B3SOIDDnsub > 0)
pParam->B3SOIDDvfbb = -model->B3SOIDDtype * model->B3SOIDDvtm *
log(pParam->B3SOIDDnpeak/ pParam->B3SOIDDnsub);
else
pParam->B3SOIDDvfbb = -model->B3SOIDDtype * model->B3SOIDDvtm *
log(-pParam->B3SOIDDnpeak* pParam->B3SOIDDnsub/ni/ni);
if (!model->B3SOIDDvsdfbGiven)
{
if (pParam->B3SOIDDnsub > 0)
pParam->B3SOIDDvsdfb = -model->B3SOIDDtype * (model->B3SOIDDvtm*log(1e20 *
pParam->B3SOIDDnsub / ni /ni) - 0.3);
else if (pParam->B3SOIDDnsub < 0)
pParam->B3SOIDDvsdfb = -model->B3SOIDDtype * (model->B3SOIDDvtm*log(-1e20 /
pParam->B3SOIDDnsub) + 0.3);
}
/* Phi & Gamma */
SDphi = 2.0*model->B3SOIDDvtm*log(fabs(pParam->B3SOIDDnsub) / ni);
SDgamma = 5.753e-12 * sqrt(fabs(pParam->B3SOIDDnsub)) / model->B3SOIDDcbox;
if (!model->B3SOIDDvsdthGiven)
{
if ( ((pParam->B3SOIDDnsub > 0) && (model->B3SOIDDtype > 0)) ||
((pParam->B3SOIDDnsub < 0) && (model->B3SOIDDtype < 0)) )
pParam->B3SOIDDvsdth = pParam->B3SOIDDvsdfb + SDphi +
SDgamma * sqrt(SDphi);
else
pParam->B3SOIDDvsdth = pParam->B3SOIDDvsdfb - SDphi -
SDgamma * sqrt(SDphi);
}
if (!model->B3SOIDDcsdminGiven)
{
/* Cdmin */
tmp = sqrt(2.0 * EPSSI * SDphi / (Charge_q *
fabs(pParam->B3SOIDDnsub) * 1.0e6));
tmp1 = EPSSI / tmp;
model->B3SOIDDcsdmin = tmp1 * model->B3SOIDDcbox /
(tmp1 + model->B3SOIDDcbox);
}
T0 = model->B3SOIDDcsdesw * log(1 + model->B3SOIDDtsi /
model->B3SOIDDtbox);
T1 = here->B3SOIDDsourcePerimeter - pParam->B3SOIDDweff;
if (T1 > 0.0)
pParam->B3SOIDDcsesw = T0 * T1;
else
pParam->B3SOIDDcsesw = 0.0;
T1 = here->B3SOIDDdrainPerimeter - pParam->B3SOIDDweff;
if (T1 > 0.0)
pParam->B3SOIDDcdesw = T0 * T1;
else
pParam->B3SOIDDcdesw = 0.0;
pParam->B3SOIDDphi = 2.0 * model->B3SOIDDvtm
* log(pParam->B3SOIDDnpeak / ni);
pParam->B3SOIDDsqrtPhi = sqrt(pParam->B3SOIDDphi);
pParam->B3SOIDDphis3 = pParam->B3SOIDDsqrtPhi * pParam->B3SOIDDphi;
pParam->B3SOIDDXdep0 = sqrt(2.0 * EPSSI / (Charge_q
* pParam->B3SOIDDnpeak * 1.0e6))
* pParam->B3SOIDDsqrtPhi;
pParam->B3SOIDDsqrtXdep0 = sqrt(pParam->B3SOIDDXdep0);
pParam->B3SOIDDlitl = sqrt(3.0 * model->B3SOIDDxj
* model->B3SOIDDtox);
pParam->B3SOIDDvbi = model->B3SOIDDvtm * log(1.0e20
* pParam->B3SOIDDnpeak / (ni * ni));
pParam->B3SOIDDcdep0 = sqrt(Charge_q * EPSSI
* pParam->B3SOIDDnpeak * 1.0e6 / 2.0
/ pParam->B3SOIDDphi);
if (model->B3SOIDDk1Given || model->B3SOIDDk2Given)
{ if (!model->B3SOIDDk1Given)
{ fprintf(stdout, "Warning: k1 should be specified with k2.\n");
pParam->B3SOIDDk1 = 0.53;
}
if (!model->B3SOIDDk2Given)
{ fprintf(stdout, "Warning: k2 should be specified with k1.\n");
pParam->B3SOIDDk2 = -0.0186;
}
if (model->B3SOIDDxtGiven)
fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n");
if (model->B3SOIDDvbxGiven)
fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n");
if (model->B3SOIDDvbmGiven)
fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n");
if (model->B3SOIDDgamma1Given)
fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n");
if (model->B3SOIDDgamma2Given)
fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n");
}
else
{ if (!model->B3SOIDDvbxGiven)
pParam->B3SOIDDvbx = pParam->B3SOIDDphi - 7.7348e-4
* pParam->B3SOIDDnpeak
* pParam->B3SOIDDxt * pParam->B3SOIDDxt;
if (pParam->B3SOIDDvbx > 0.0)
pParam->B3SOIDDvbx = -pParam->B3SOIDDvbx;
if (pParam->B3SOIDDvbm > 0.0)
pParam->B3SOIDDvbm = -pParam->B3SOIDDvbm;
if (!model->B3SOIDDgamma1Given)
pParam->B3SOIDDgamma1 = 5.753e-12
* sqrt(pParam->B3SOIDDnpeak)
/ model->B3SOIDDcox;
if (!model->B3SOIDDgamma2Given)
pParam->B3SOIDDgamma2 = 5.753e-12
* sqrt(pParam->B3SOIDDnsub)
/ model->B3SOIDDcox;
T0 = pParam->B3SOIDDgamma1 - pParam->B3SOIDDgamma2;
T1 = sqrt(pParam->B3SOIDDphi - pParam->B3SOIDDvbx)
- pParam->B3SOIDDsqrtPhi;
T2 = sqrt(pParam->B3SOIDDphi * (pParam->B3SOIDDphi
- pParam->B3SOIDDvbm)) - pParam->B3SOIDDphi;
pParam->B3SOIDDk2 = T0 * T1 / (2.0 * T2 + pParam->B3SOIDDvbm);
pParam->B3SOIDDk1 = pParam->B3SOIDDgamma2 - 2.0
* pParam->B3SOIDDk2 * sqrt(pParam->B3SOIDDphi
- pParam->B3SOIDDvbm);
}
if (pParam->B3SOIDDk2 < 0.0)
{ T0 = 0.5 * pParam->B3SOIDDk1 / pParam->B3SOIDDk2;
pParam->B3SOIDDvbsc = 0.9 * (pParam->B3SOIDDphi - T0 * T0);
if (pParam->B3SOIDDvbsc > -3.0)
pParam->B3SOIDDvbsc = -3.0;
else if (pParam->B3SOIDDvbsc < -30.0)
pParam->B3SOIDDvbsc = -30.0;
}
else
{ pParam->B3SOIDDvbsc = -30.0;
}
if (pParam->B3SOIDDvbsc > pParam->B3SOIDDvbm)
pParam->B3SOIDDvbsc = pParam->B3SOIDDvbm;
if (model->B3SOIDDvth0Given)
{ pParam->B3SOIDDvfb = model->B3SOIDDtype * pParam->B3SOIDDvth0
- pParam->B3SOIDDphi - pParam->B3SOIDDk1
* pParam->B3SOIDDsqrtPhi;
}
else
{ pParam->B3SOIDDvfb = -1.0;
pParam->B3SOIDDvth0 = model->B3SOIDDtype * (pParam->B3SOIDDvfb
+ pParam->B3SOIDDphi + pParam->B3SOIDDk1
* pParam->B3SOIDDsqrtPhi);
}
T1 = sqrt(EPSSI / EPSOX * model->B3SOIDDtox
* pParam->B3SOIDDXdep0);
T0 = exp(-0.5 * pParam->B3SOIDDdsub * pParam->B3SOIDDleff / T1);
pParam->B3SOIDDtheta0vb0 = (T0 + 2.0 * T0 * T0);
T0 = exp(-0.5 * pParam->B3SOIDDdrout * pParam->B3SOIDDleff / T1);
T2 = (T0 + 2.0 * T0 * T0);
pParam->B3SOIDDthetaRout = pParam->B3SOIDDpdibl1 * T2
+ pParam->B3SOIDDpdibl2;
here->B3SOIDDminIsub = 5.0e-2 * pParam->B3SOIDDweff * model->B3SOIDDtsi
* MAX(pParam->B3SOIDDisdif, pParam->B3SOIDDisrec);
}
here->B3SOIDDcsbox = model->B3SOIDDcbox*here->B3SOIDDsourceArea;
here->B3SOIDDcsmin = model->B3SOIDDcsdmin*here->B3SOIDDsourceArea;
here->B3SOIDDcdbox = model->B3SOIDDcbox*here->B3SOIDDdrainArea;
here->B3SOIDDcdmin = model->B3SOIDDcsdmin*here->B3SOIDDdrainArea;
if ( ((pParam->B3SOIDDnsub > 0) && (model->B3SOIDDtype > 0)) ||
((pParam->B3SOIDDnsub < 0) && (model->B3SOIDDtype < 0)) )
{
T0 = pParam->B3SOIDDvsdth - pParam->B3SOIDDvsdfb;
pParam->B3SOIDDsdt1 = pParam->B3SOIDDvsdfb + model->B3SOIDDasd * T0;
T1 = here->B3SOIDDcsbox - here->B3SOIDDcsmin;
T2 = T1 / T0 / T0;
pParam->B3SOIDDst2 = T2 / model->B3SOIDDasd;
pParam->B3SOIDDst3 = T2 /( 1 - model->B3SOIDDasd);
here->B3SOIDDst4 = T0 * T1 * (1 + model->B3SOIDDasd) / 3
- here->B3SOIDDcsmin * pParam->B3SOIDDvsdfb;
T1 = here->B3SOIDDcdbox - here->B3SOIDDcdmin;
T2 = T1 / T0 / T0;
pParam->B3SOIDDdt2 = T2 / model->B3SOIDDasd;
pParam->B3SOIDDdt3 = T2 /( 1 - model->B3SOIDDasd);
here->B3SOIDDdt4 = T0 * T1 * (1 + model->B3SOIDDasd) / 3
- here->B3SOIDDcdmin * pParam->B3SOIDDvsdfb;
} else
{
T0 = pParam->B3SOIDDvsdfb - pParam->B3SOIDDvsdth;
pParam->B3SOIDDsdt1 = pParam->B3SOIDDvsdth + model->B3SOIDDasd * T0;
T1 = here->B3SOIDDcsmin - here->B3SOIDDcsbox;
T2 = T1 / T0 / T0;
pParam->B3SOIDDst2 = T2 / model->B3SOIDDasd;
pParam->B3SOIDDst3 = T2 /( 1 - model->B3SOIDDasd);
here->B3SOIDDst4 = T0 * T1 * (1 + model->B3SOIDDasd) / 3
- here->B3SOIDDcsbox * pParam->B3SOIDDvsdth;
T1 = here->B3SOIDDcdmin - here->B3SOIDDcdbox;
T2 = T1 / T0 / T0;
pParam->B3SOIDDdt2 = T2 / model->B3SOIDDasd;
pParam->B3SOIDDdt3 = T2 /( 1 - model->B3SOIDDasd);
here->B3SOIDDdt4 = T0 * T1 * (1 + model->B3SOIDDasd) / 3
- here->B3SOIDDcdbox * pParam->B3SOIDDvsdth;
}
here->B3SOIDDphi = pParam->B3SOIDDphi;
/* process source/drain series resistance */
here->B3SOIDDdrainConductance = model->B3SOIDDsheetResistance
* here->B3SOIDDdrainSquares;
if (here->B3SOIDDdrainConductance > 0.0)
here->B3SOIDDdrainConductance = 1.0
/ here->B3SOIDDdrainConductance;
else
here->B3SOIDDdrainConductance = 0.0;
here->B3SOIDDsourceConductance = model->B3SOIDDsheetResistance
* here->B3SOIDDsourceSquares;
if (here->B3SOIDDsourceConductance > 0.0)
here->B3SOIDDsourceConductance = 1.0
/ here->B3SOIDDsourceConductance;
else
here->B3SOIDDsourceConductance = 0.0;
here->B3SOIDDcgso = pParam->B3SOIDDcgso;
here->B3SOIDDcgdo = pParam->B3SOIDDcgdo;
}
}
return(OK);
}

52
src/spicelib/devices/bsim3soi_dd/b3soiddtrunc.c Normal file
View File

@ -0,0 +1,52 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soiddtrunc.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "b3soidddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIDDtrunc(inModel,ckt,timeStep)
GENmodel *inModel;
register CKTcircuit *ckt;
double *timeStep;
{
register B3SOIDDmodel *model = (B3SOIDDmodel*)inModel;
register B3SOIDDinstance *here;
#ifdef STEPDEBUG
double debugtemp;
#endif /* STEPDEBUG */
for (; model != NULL; model = model->B3SOIDDnextModel)
{ for (here = model->B3SOIDDinstances; here != NULL;
here = here->B3SOIDDnextInstance)
{
#ifdef STEPDEBUG
debugtemp = *timeStep;
#endif /* STEPDEBUG */
CKTterr(here->B3SOIDDqb,ckt,timeStep);
CKTterr(here->B3SOIDDqg,ckt,timeStep);
CKTterr(here->B3SOIDDqd,ckt,timeStep);
#ifdef STEPDEBUG
if(debugtemp != *timeStep)
{ printf("device %s reduces step from %g to %g\n",
here->B3SOIDDname,debugtemp,*timeStep);
}
#endif /* STEPDEBUG */
}
}
return(OK);
}