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

Added bsim3soi FD (Fully Depleted) model and added test files

This commit is contained in:
pnenzi 2000-12-09 18:18:43 +00:00
parent 97e77a523e
commit 5496e592ce
47 changed files with 26528 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/spicelib/devices/bsim3soi_fd/BsimTerms_use Normal file
View File

@ -0,0 +1,29 @@
The terms under which the software is provided  are as the following.
Software is distributed as is, completely without warranty or service
support. The University of California and its employees are not liable
for the condition or performance of the software.
The University owns the copyright but shall not be liable for any
infringement of copyright or other proprietary rights brought by third
parties against the users of the software.
The University of California hereby disclaims all implied warranties.
The University of California grants the users the right to modify, copy,
and redistribute the software and documentation, both within the user's
organization and externally, subject to the following restrictions
1. The users agree not to charge for the University of California code
   itself but may charge for additions, extensions, or support.
2. In any product based on the software, the users agree to acknowledge
   the UC Berkeley BSIM Research Group that developed the software. This
   acknowledgment shall appear in the product documentation.
3. The users agree to obey all U.S. Government restrictions governing
   redistribution or export of the software.
4. The users agree to reproduce any copyright notice which appears on
   the software on any copy or modification of such made available
   to others.

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

@ -0,0 +1,34 @@
## Process this file with automake to produce Makefile.in
pkglib_LTLIBRARIES = libbsim3soifd.la
libbsim3soifd_la_SOURCES = \
b3soifd.c \
b3soifdacld.c \
b3soifdask.c \
b3soifdcheck.c \
b3soifdcvtest.c \
b3soifddel.c \
b3soifddest.c \
b3soifdgetic.c \
b3soifdld.c \
b3soifdmask.c \
b3soifdmdel.c \
b3soifdmpar.c \
b3soifdnoi.c \
b3soifdpar.c \
b3soifdpzld.c \
b3soifdset.c \
b3soifdtemp.c \
b3soifdtrunc.c \
b3soifddef.h \
b3soifdext.h \
b3soifdinit.c \
b3soifdinit.h \
b3soifditf.h
INCLUDES = -I$(top_srcdir)/src/include
MAINTAINERCLEANFILES = Makefile.in

479
src/spicelib/devices/bsim3soi_fd/b3soifd.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
Modified by Wei Jin 99/9/27
File: b3soifd.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "devdefs.h"
#include "b3soifddef.h"
#include "suffix.h"
IFparm B3SOIFDpTable[] = { /* parameters */
IOP( "l", B3SOIFD_L, IF_REAL , "Length"),
IOP( "w", B3SOIFD_W, IF_REAL , "Width"),
IOP( "ad", B3SOIFD_AD, IF_REAL , "Drain area"),
IOP( "as", B3SOIFD_AS, IF_REAL , "Source area"),
IOP( "pd", B3SOIFD_PD, IF_REAL , "Drain perimeter"),
IOP( "ps", B3SOIFD_PS, IF_REAL , "Source perimeter"),
IOP( "nrd", B3SOIFD_NRD, IF_REAL , "Number of squares in drain"),
IOP( "nrs", B3SOIFD_NRS, IF_REAL , "Number of squares in source"),
IOP( "off", B3SOIFD_OFF, IF_FLAG , "Device is initially off"),
IP( "ic", B3SOIFD_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"),
OP( "gmbs", B3SOIFD_GMBS, IF_REAL, "Gmb"),
OP( "gm", B3SOIFD_GM, IF_REAL, "Gm"),
OP( "gm/ids", B3SOIFD_GMID, IF_REAL, "Gm/Ids"),
OP( "gds", B3SOIFD_GDS, IF_REAL, "Gds"),
OP( "vdsat", B3SOIFD_VDSAT, IF_REAL, "Vdsat"),
OP( "vth", B3SOIFD_VON, IF_REAL, "Vth"),
OP( "ids", B3SOIFD_CD, IF_REAL, "Ids"),
OP( "vbs", B3SOIFD_VBS, IF_REAL, "Vbs"),
OP( "vgs", B3SOIFD_VGS, IF_REAL, "Vgs"),
OP( "vds", B3SOIFD_VDS, IF_REAL, "Vds"),
OP( "ves", B3SOIFD_VES, IF_REAL, "Ves"),
IOP( "bjtoff", B3SOIFD_BJTOFF, IF_INTEGER, "BJT on/off flag"),
IOP( "debug", B3SOIFD_DEBUG, IF_INTEGER, "BJT on/off flag"),
IOP( "rth0", B3SOIFD_RTH0, IF_REAL, "Instance Thermal Resistance"),
IOP( "cth0", B3SOIFD_CTH0, IF_REAL, "Instance Thermal Capacitance"),
IOP( "nrb", B3SOIFD_NRB, IF_REAL, "Number of squares in body"),
};
IFparm B3SOIFDmPTable[] = { /* model parameters */
IOP( "capmod", B3SOIFD_MOD_CAPMOD, IF_INTEGER, "Capacitance model selector"),
IOP( "mobmod", B3SOIFD_MOD_MOBMOD, IF_INTEGER, "Mobility model selector"),
IOP( "noimod", B3SOIFD_MOD_NOIMOD, IF_INTEGER, "Noise model selector"),
IOP( "paramchk", B3SOIFD_MOD_PARAMCHK, IF_INTEGER, "Model parameter checking selector"),
IOP( "binunit", B3SOIFD_MOD_BINUNIT, IF_INTEGER, "Bin unit selector"),
IOP( "version", B3SOIFD_MOD_VERSION, IF_REAL, " parameter for model version"),
IOP( "tox", B3SOIFD_MOD_TOX, IF_REAL, "Gate oxide thickness in meters"),
IOP( "cdsc", B3SOIFD_MOD_CDSC, IF_REAL, "Drain/Source and channel coupling capacitance"),
IOP( "cdscb", B3SOIFD_MOD_CDSCB, IF_REAL, "Body-bias dependence of cdsc"),
IOP( "cdscd", B3SOIFD_MOD_CDSCD, IF_REAL, "Drain-bias dependence of cdsc"),
IOP( "cit", B3SOIFD_MOD_CIT, IF_REAL, "Interface state capacitance"),
IOP( "nfactor", B3SOIFD_MOD_NFACTOR, IF_REAL, "Subthreshold swing Coefficient"),
IOP( "vsat", B3SOIFD_MOD_VSAT, IF_REAL, "Saturation velocity at tnom"),
IOP( "at", B3SOIFD_MOD_AT, IF_REAL, "Temperature coefficient of vsat"),
IOP( "a0", B3SOIFD_MOD_A0, IF_REAL, "Non-uniform depletion width effect coefficient."),
IOP( "ags", B3SOIFD_MOD_AGS, IF_REAL, "Gate bias coefficient of Abulk."),
IOP( "a1", B3SOIFD_MOD_A1, IF_REAL, "Non-saturation effect coefficient"),
IOP( "a2", B3SOIFD_MOD_A2, IF_REAL, "Non-saturation effect coefficient"),
IOP( "keta", B3SOIFD_MOD_KETA, IF_REAL, "Body-bias coefficient of non-uniform depletion width effect."),
IOP( "nsub", B3SOIFD_MOD_NSUB, IF_REAL, "Substrate doping concentration with polarity"),
IOP( "nch", B3SOIFD_MOD_NPEAK, IF_REAL, "Channel doping concentration"),
IOP( "ngate", B3SOIFD_MOD_NGATE, IF_REAL, "Poly-gate doping concentration"),
IOP( "gamma1", B3SOIFD_MOD_GAMMA1, IF_REAL, "Vth body coefficient"),
IOP( "gamma2", B3SOIFD_MOD_GAMMA2, IF_REAL, "Vth body coefficient"),
IOP( "vbx", B3SOIFD_MOD_VBX, IF_REAL, "Vth transition body Voltage"),
IOP( "vbm", B3SOIFD_MOD_VBM, IF_REAL, "Maximum body voltage"),
IOP( "xt", B3SOIFD_MOD_XT, IF_REAL, "Doping depth"),
IOP( "k1", B3SOIFD_MOD_K1, IF_REAL, "Bulk effect coefficient 1"),
IOP( "kt1", B3SOIFD_MOD_KT1, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt1l", B3SOIFD_MOD_KT1L, IF_REAL, "Temperature coefficient of Vth"),
IOP( "kt2", B3SOIFD_MOD_KT2, IF_REAL, "Body-coefficient of kt1"),
IOP( "k2", B3SOIFD_MOD_K2, IF_REAL, "Bulk effect coefficient 2"),
IOP( "k3", B3SOIFD_MOD_K3, IF_REAL, "Narrow width effect coefficient"),
IOP( "k3b", B3SOIFD_MOD_K3B, IF_REAL, "Body effect coefficient of k3"),
IOP( "w0", B3SOIFD_MOD_W0, IF_REAL, "Narrow width effect parameter"),
IOP( "nlx", B3SOIFD_MOD_NLX, IF_REAL, "Lateral non-uniform doping effect"),
IOP( "dvt0", B3SOIFD_MOD_DVT0, IF_REAL, "Short channel effect coeff. 0"),
IOP( "dvt1", B3SOIFD_MOD_DVT1, IF_REAL, "Short channel effect coeff. 1"),
IOP( "dvt2", B3SOIFD_MOD_DVT2, IF_REAL, "Short channel effect coeff. 2"),
IOP( "dvt0w", B3SOIFD_MOD_DVT0W, IF_REAL, "Narrow Width coeff. 0"),
IOP( "dvt1w", B3SOIFD_MOD_DVT1W, IF_REAL, "Narrow Width effect coeff. 1"),
IOP( "dvt2w", B3SOIFD_MOD_DVT2W, IF_REAL, "Narrow Width effect coeff. 2"),
IOP( "drout", B3SOIFD_MOD_DROUT, IF_REAL, "DIBL coefficient of output resistance"),
IOP( "dsub", B3SOIFD_MOD_DSUB, IF_REAL, "DIBL coefficient in the subthreshold region"),
IOP( "vth0", B3SOIFD_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "vtho", B3SOIFD_MOD_VTH0, IF_REAL,"Threshold voltage"),
IOP( "ua", B3SOIFD_MOD_UA, IF_REAL, "Linear gate dependence of mobility"),
IOP( "ua1", B3SOIFD_MOD_UA1, IF_REAL, "Temperature coefficient of ua"),
IOP( "ub", B3SOIFD_MOD_UB, IF_REAL, "Quadratic gate dependence of mobility"),
IOP( "ub1", B3SOIFD_MOD_UB1, IF_REAL, "Temperature coefficient of ub"),
IOP( "uc", B3SOIFD_MOD_UC, IF_REAL, "Body-bias dependence of mobility"),
IOP( "uc1", B3SOIFD_MOD_UC1, IF_REAL, "Temperature coefficient of uc"),
IOP( "u0", B3SOIFD_MOD_U0, IF_REAL, "Low-field mobility at Tnom"),
IOP( "ute", B3SOIFD_MOD_UTE, IF_REAL, "Temperature coefficient of mobility"),
IOP( "voff", B3SOIFD_MOD_VOFF, IF_REAL, "Threshold voltage offset"),
IOP( "tnom", B3SOIFD_MOD_TNOM, IF_REAL, "Parameter measurement temperature"),
IOP( "cgso", B3SOIFD_MOD_CGSO, IF_REAL, "Gate-source overlap capacitance per width"),
IOP( "cgdo", B3SOIFD_MOD_CGDO, IF_REAL, "Gate-drain overlap capacitance per width"),
IOP( "cgeo", B3SOIFD_MOD_CGEO, IF_REAL, "Gate-substrate overlap capacitance"),
IOP( "xpart", B3SOIFD_MOD_XPART, IF_REAL, "Channel charge partitioning"),
IOP( "delta", B3SOIFD_MOD_DELTA, IF_REAL, "Effective Vds parameter"),
IOP( "rsh", B3SOIFD_MOD_RSH, IF_REAL, "Source-drain sheet resistance"),
IOP( "rdsw", B3SOIFD_MOD_RDSW, IF_REAL, "Source-drain resistance per width"),
IOP( "prwg", B3SOIFD_MOD_PRWG, IF_REAL, "Gate-bias effect on parasitic resistance "),
IOP( "prwb", B3SOIFD_MOD_PRWB, IF_REAL, "Body-effect on parasitic resistance "),
IOP( "prt", B3SOIFD_MOD_PRT, IF_REAL, "Temperature coefficient of parasitic resistance "),
IOP( "eta0", B3SOIFD_MOD_ETA0, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "etab", B3SOIFD_MOD_ETAB, IF_REAL, "Subthreshold region DIBL coefficient"),
IOP( "pclm", B3SOIFD_MOD_PCLM, IF_REAL, "Channel length modulation Coefficient"),
IOP( "pdiblc1", B3SOIFD_MOD_PDIBL1, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblc2", B3SOIFD_MOD_PDIBL2, IF_REAL, "Drain-induced barrier lowering coefficient"),
IOP( "pdiblcb", B3SOIFD_MOD_PDIBLB, IF_REAL, "Body-effect on drain-induced barrier lowering"),
IOP( "pvag", B3SOIFD_MOD_PVAG, IF_REAL, "Gate dependence of output resistance parameter"),
IOP( "shmod", B3SOIFD_MOD_SHMOD, IF_INTEGER, "Self heating mode selector"),
IOP( "tbox", B3SOIFD_MOD_TBOX, IF_REAL, "Back gate oxide thickness in meters"),
IOP( "tsi", B3SOIFD_MOD_TSI, IF_REAL, "Silicon-on-insulator thickness in meters"),
IOP( "xj", B3SOIFD_MOD_XJ, IF_REAL, "Junction Depth"),
IOP( "kb1", B3SOIFD_MOD_KB1, IF_REAL, "Backgate coupling coefficient at strong inversion"),
IOP( "kb3", B3SOIFD_MOD_KB3, IF_REAL, "Backgate coupling coefficient at subthreshold"),
IOP( "dvbd0", B3SOIFD_MOD_DVBD0, IF_REAL, "First coefficient of short-channel effect on Vbs0t"),
IOP( "dvbd1", B3SOIFD_MOD_DVBD1, IF_REAL, "Second coefficient of short-channel effect on Vbs0t"),
IOP( "vbsa", B3SOIFD_MOD_VBSA, IF_REAL, "Vbs0t offset voltage"),
IOP( "delp", B3SOIFD_MOD_DELP, IF_REAL, "Offset constant for limiting Vbseff to Phis"),
IOP( "rbody", B3SOIFD_MOD_RBODY, IF_REAL, "Intrinsic body contact sheet resistance"),
IOP( "rbsh", B3SOIFD_MOD_RBSH, IF_REAL, "Extrinsic body contact sheet resistance"),
IOP( "adice0", B3SOIFD_MOD_ADICE0, IF_REAL, "DICE constant for bulk charge effect"),
IOP( "abp", B3SOIFD_MOD_ABP, IF_REAL, "Gate bias coefficient for Xcsat calculation"),
IOP( "mxc", B3SOIFD_MOD_MXC, IF_REAL, "A smoothing parameter for Xcsat calculation"),
IOP( "rth0", B3SOIFD_MOD_RTH0, IF_REAL, "Self-heating thermal resistance"),
IOP( "cth0", B3SOIFD_MOD_CTH0, IF_REAL, "Self-heating thermal capacitance"),
IOP( "aii", B3SOIFD_MOD_AII, IF_REAL, "1st Vdsatii parameter"),
IOP( "bii", B3SOIFD_MOD_BII, IF_REAL, "2nd Vdsatii parameter"),
IOP( "cii", B3SOIFD_MOD_CII, IF_REAL, "3rd Vdsatii parameter"),
IOP( "dii", B3SOIFD_MOD_DII, IF_REAL, "4th Vdsatii parameter"),
IOP( "ngidl", B3SOIFD_MOD_NGIDL, IF_REAL, "GIDL first parameter"),
IOP( "agidl", B3SOIFD_MOD_AGIDL, IF_REAL, "GIDL second parameter"),
IOP( "bgidl", B3SOIFD_MOD_BGIDL, IF_REAL, "GIDL third parameter"),
IOP( "ndiode", B3SOIFD_MOD_NDIODE, IF_REAL, "Diode non-ideality factor"),
IOP( "ntun", B3SOIFD_MOD_NTUN, IF_REAL, "Reverse tunneling non-ideality factor"),
IOP( "isbjt", B3SOIFD_MOD_ISBJT, IF_REAL, "BJT emitter injection constant"),
IOP( "isdif", B3SOIFD_MOD_ISDIF, IF_REAL, "Body to S/D injection constant"),
IOP( "isrec", B3SOIFD_MOD_ISREC, IF_REAL, "Recombination in depletion constant"),
IOP( "istun", B3SOIFD_MOD_ISTUN, IF_REAL, "Tunneling diode constant"),
IOP( "xbjt", B3SOIFD_MOD_XBJT, IF_REAL, "Temperature coefficient for Isbjt"),
IOP( "xdif", B3SOIFD_MOD_XBJT, IF_REAL, "Temperature coefficient for Isdif"),
IOP( "xrec", B3SOIFD_MOD_XREC, IF_REAL, "Temperature coefficient for Isrec"),
IOP( "xtun", B3SOIFD_MOD_XTUN, IF_REAL, "Temperature coefficient for Istun"),
IOP( "edl", B3SOIFD_MOD_EDL, IF_REAL, "Electron diffusion length"),
IOP( "kbjt1", B3SOIFD_MOD_KBJT1, IF_REAL, "Vds dependency on BJT base width"),
IOP( "tt", B3SOIFD_MOD_TT, IF_REAL, "Diffusion capacitance transit time coefficient"),
IOP( "vsdth", B3SOIFD_MOD_VSDTH, IF_REAL, "Source/Drain diffusion threshold voltage"),
IOP( "vsdfb", B3SOIFD_MOD_VSDFB, IF_REAL, "Source/Drain diffusion flatband voltage"),
IOP( "csdmin", B3SOIFD_MOD_CSDMIN, IF_REAL, "Source/Drain diffusion bottom minimum capacitance"),
IOP( "asd", B3SOIFD_MOD_ASD, IF_REAL, "Source/Drain diffusion smoothing parameter"),
IOP( "pbswg", B3SOIFD_MOD_PBSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance built in potential"),
IOP( "mjswg", B3SOIFD_MOD_MJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance grading coefficient"),
IOP( "cjswg", B3SOIFD_MOD_CJSWG, IF_REAL, "Source/drain (gate side) sidewall junction capacitance per unit width"),
IOP( "csdesw", B3SOIFD_MOD_CSDESW, IF_REAL, "Source/drain sidewall fringing constant"),
IOP( "lint", B3SOIFD_MOD_LINT, IF_REAL, "Length reduction parameter"),
IOP( "ll", B3SOIFD_MOD_LL, IF_REAL, "Length reduction parameter"),
IOP( "lln", B3SOIFD_MOD_LLN, IF_REAL, "Length reduction parameter"),
IOP( "lw", B3SOIFD_MOD_LW, IF_REAL, "Length reduction parameter"),
IOP( "lwn", B3SOIFD_MOD_LWN, IF_REAL, "Length reduction parameter"),
IOP( "lwl", B3SOIFD_MOD_LWL, IF_REAL, "Length reduction parameter"),
IOP( "wr", B3SOIFD_MOD_WR, IF_REAL, "Width dependence of rds"),
IOP( "wint", B3SOIFD_MOD_WINT, IF_REAL, "Width reduction parameter"),
IOP( "dwg", B3SOIFD_MOD_DWG, IF_REAL, "Width reduction parameter"),
IOP( "dwb", B3SOIFD_MOD_DWB, IF_REAL, "Width reduction parameter"),
IOP( "wl", B3SOIFD_MOD_WL, IF_REAL, "Width reduction parameter"),
IOP( "wln", B3SOIFD_MOD_WLN, IF_REAL, "Width reduction parameter"),
IOP( "ww", B3SOIFD_MOD_WW, IF_REAL, "Width reduction parameter"),
IOP( "wwn", B3SOIFD_MOD_WWN, IF_REAL, "Width reduction parameter"),
IOP( "wwl", B3SOIFD_MOD_WWL, IF_REAL, "Width reduction parameter"),
IOP( "b0", B3SOIFD_MOD_B0, IF_REAL, "Abulk narrow width parameter"),
IOP( "b1", B3SOIFD_MOD_B1, IF_REAL, "Abulk narrow width parameter"),
IOP( "cgsl", B3SOIFD_MOD_CGSL, IF_REAL, "New C-V model parameter"),
IOP( "cgdl", B3SOIFD_MOD_CGDL, IF_REAL, "New C-V model parameter"),
IOP( "ckappa", B3SOIFD_MOD_CKAPPA, IF_REAL, "New C-V model parameter"),
IOP( "cf", B3SOIFD_MOD_CF, IF_REAL, "Fringe capacitance parameter"),
IOP( "clc", B3SOIFD_MOD_CLC, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "cle", B3SOIFD_MOD_CLE, IF_REAL, "Vdsat parameter for C-V model"),
IOP( "dwc", B3SOIFD_MOD_DWC, IF_REAL, "Delta W for C-V model"),
IOP( "dlc", B3SOIFD_MOD_DLC, IF_REAL, "Delta L for C-V model"),
IOP( "alpha0", B3SOIFD_MOD_ALPHA0, IF_REAL, "substrate current model parameter"),
IOP( "alpha1", B3SOIFD_MOD_ALPHA1, IF_REAL, "substrate current model parameter"),
IOP( "beta0", B3SOIFD_MOD_BETA0, IF_REAL, "substrate current model parameter"),
IOP( "noia", B3SOIFD_MOD_NOIA, IF_REAL, "Flicker noise parameter"),
IOP( "noib", B3SOIFD_MOD_NOIB, IF_REAL, "Flicker noise parameter"),
IOP( "noic", B3SOIFD_MOD_NOIC, IF_REAL, "Flicker noise parameter"),
IOP( "em", B3SOIFD_MOD_EM, IF_REAL, "Flicker noise parameter"),
IOP( "ef", B3SOIFD_MOD_EF, IF_REAL, "Flicker noise frequency exponent"),
IOP( "af", B3SOIFD_MOD_AF, IF_REAL, "Flicker noise exponent"),
IOP( "kf", B3SOIFD_MOD_KF, IF_REAL, "Flicker noise coefficient"),
IOP( "noif", B3SOIFD_MOD_NOIF, IF_REAL, "Floating body excess noise ideality factor"),
/* Added for binning - START */
/* Length Dependence */
IOP( "lnch", B3SOIFD_MOD_LNPEAK, IF_REAL, "Length dependence of nch"),
IOP( "lnsub", B3SOIFD_MOD_LNSUB, IF_REAL, "Length dependence of nsub"),
IOP( "lngate", B3SOIFD_MOD_LNGATE, IF_REAL, "Length dependence of ngate"),
IOP( "lvth0", B3SOIFD_MOD_LVTH0, IF_REAL,"Length dependence of vto"),
IOP( "lk1", B3SOIFD_MOD_LK1, IF_REAL, "Length dependence of k1"),
IOP( "lk2", B3SOIFD_MOD_LK2, IF_REAL, "Length dependence of k2"),
IOP( "lk3", B3SOIFD_MOD_LK3, IF_REAL, "Length dependence of k3"),
IOP( "lk3b", B3SOIFD_MOD_LK3B, IF_REAL, "Length dependence of k3b"),
IOP( "lvbsa", B3SOIFD_MOD_LVBSA, IF_REAL, "Length dependence of vbsa"),
IOP( "ldelp", B3SOIFD_MOD_LDELP, IF_REAL, "Length dependence of delp"),
IOP( "lkb1", B3SOIFD_MOD_LKB1, IF_REAL, "Length dependence of kb1"),
IOP( "lkb3", B3SOIFD_MOD_LKB3, IF_REAL, "Length dependence of kb3"),
IOP( "ldvbd0", B3SOIFD_MOD_LDVBD0, IF_REAL, "Length dependence of dvbd0"),
IOP( "ldvbd1", B3SOIFD_MOD_LDVBD1, IF_REAL, "Length dependence of dvbd1"),
IOP( "lw0", B3SOIFD_MOD_LW0, IF_REAL, "Length dependence of w0"),
IOP( "lnlx", B3SOIFD_MOD_LNLX, IF_REAL, "Length dependence of nlx"),
IOP( "ldvt0", B3SOIFD_MOD_LDVT0, IF_REAL, "Length dependence of dvt0"),
IOP( "ldvt1", B3SOIFD_MOD_LDVT1, IF_REAL, "Length dependence of dvt1"),
IOP( "ldvt2", B3SOIFD_MOD_LDVT2, IF_REAL, "Length dependence of dvt2"),
IOP( "ldvt0w", B3SOIFD_MOD_LDVT0W, IF_REAL, "Length dependence of dvt0w"),
IOP( "ldvt1w", B3SOIFD_MOD_LDVT1W, IF_REAL, "Length dependence of dvt1w"),
IOP( "ldvt2w", B3SOIFD_MOD_LDVT2W, IF_REAL, "Length dependence of dvt2w"),
IOP( "lu0", B3SOIFD_MOD_LU0, IF_REAL, "Length dependence of u0"),
IOP( "lua", B3SOIFD_MOD_LUA, IF_REAL, "Length dependence of ua"),
IOP( "lub", B3SOIFD_MOD_LUB, IF_REAL, "Length dependence of ub"),
IOP( "luc", B3SOIFD_MOD_LUC, IF_REAL, "Length dependence of uc"),
IOP( "lvsat", B3SOIFD_MOD_LVSAT, IF_REAL, "Length dependence of vsat"),
IOP( "la0", B3SOIFD_MOD_LA0, IF_REAL, "Length dependence of a0"),
IOP( "lags", B3SOIFD_MOD_LAGS, IF_REAL, "Length dependence of ags"),
IOP( "lb0", B3SOIFD_MOD_LB0, IF_REAL, "Length dependence of b0"),
IOP( "lb1", B3SOIFD_MOD_LB1, IF_REAL, "Length dependence of b1"),
IOP( "lketa", B3SOIFD_MOD_LKETA, IF_REAL, "Length dependence of keta"),
IOP( "labp", B3SOIFD_MOD_LABP, IF_REAL, "Length dependence of abp"),
IOP( "lmxc", B3SOIFD_MOD_LMXC, IF_REAL, "Length dependence of mxc"),
IOP( "ladice0", B3SOIFD_MOD_LADICE0, IF_REAL, "Length dependence of adice0"),
IOP( "la1", B3SOIFD_MOD_LA1, IF_REAL, "Length dependence of a1"),
IOP( "la2", B3SOIFD_MOD_LA2, IF_REAL, "Length dependence of a2"),
IOP( "lrdsw", B3SOIFD_MOD_LRDSW, IF_REAL, "Length dependence of rdsw "),
IOP( "lprwb", B3SOIFD_MOD_LPRWB, IF_REAL, "Length dependence of prwb "),
IOP( "lprwg", B3SOIFD_MOD_LPRWG, IF_REAL, "Length dependence of prwg "),
IOP( "lwr", B3SOIFD_MOD_LWR, IF_REAL, "Length dependence of wr"),
IOP( "lnfactor", B3SOIFD_MOD_LNFACTOR, IF_REAL, "Length dependence of nfactor"),
IOP( "ldwg", B3SOIFD_MOD_LDWG, IF_REAL, "Length dependence of dwg"),
IOP( "ldwb", B3SOIFD_MOD_LDWB, IF_REAL, "Length dependence of dwb"),
IOP( "lvoff", B3SOIFD_MOD_LVOFF, IF_REAL, "Length dependence of voff"),
IOP( "leta0", B3SOIFD_MOD_LETA0, IF_REAL, "Length dependence of eta0"),
IOP( "letab", B3SOIFD_MOD_LETAB, IF_REAL, "Length dependence of etab"),
IOP( "ldsub", B3SOIFD_MOD_LDSUB, IF_REAL, "Length dependence of dsub"),
IOP( "lcit", B3SOIFD_MOD_LCIT, IF_REAL, "Length dependence of cit"),
IOP( "lcdsc", B3SOIFD_MOD_LCDSC, IF_REAL, "Length dependence of cdsc"),
IOP( "lcdscb", B3SOIFD_MOD_LCDSCB, IF_REAL, "Length dependence of cdscb"),
IOP( "lcdscd", B3SOIFD_MOD_LCDSCD, IF_REAL, "Length dependence of cdscd"),
IOP( "lpclm", B3SOIFD_MOD_LPCLM, IF_REAL, "Length dependence of pclm"),
IOP( "lpdiblc1", B3SOIFD_MOD_LPDIBL1, IF_REAL, "Length dependence of pdiblc1"),
IOP( "lpdiblc2", B3SOIFD_MOD_LPDIBL2, IF_REAL, "Length dependence of pdiblc2"),
IOP( "lpdiblcb", B3SOIFD_MOD_LPDIBLB, IF_REAL, "Length dependence of pdiblcb"),
IOP( "ldrout", B3SOIFD_MOD_LDROUT, IF_REAL, "Length dependence of drout"),
IOP( "lpvag", B3SOIFD_MOD_LPVAG, IF_REAL, "Length dependence of pvag"),
IOP( "ldelta", B3SOIFD_MOD_LDELTA, IF_REAL, "Length dependence of delta"),
IOP( "laii", B3SOIFD_MOD_LAII, IF_REAL, "Length dependence of aii"),
IOP( "lbii", B3SOIFD_MOD_LBII, IF_REAL, "Length dependence of bii"),
IOP( "lcii", B3SOIFD_MOD_LCII, IF_REAL, "Length dependence of cii"),
IOP( "ldii", B3SOIFD_MOD_LDII, IF_REAL, "Length dependence of dii"),
IOP( "lalpha0", B3SOIFD_MOD_LALPHA0, IF_REAL, "Length dependence of alpha0"),
IOP( "lalpha1", B3SOIFD_MOD_LALPHA1, IF_REAL, "Length dependence of alpha1"),
IOP( "lbeta0", B3SOIFD_MOD_LBETA0, IF_REAL, "Length dependence of beta0"),
IOP( "lagidl", B3SOIFD_MOD_LAGIDL, IF_REAL, "Length dependence of agidl"),
IOP( "lbgidl", B3SOIFD_MOD_LBGIDL, IF_REAL, "Length dependence of bgidl"),
IOP( "lngidl", B3SOIFD_MOD_LNGIDL, IF_REAL, "Length dependence of ngidl"),
IOP( "lntun", B3SOIFD_MOD_LNTUN, IF_REAL, "Length dependence of ntun"),
IOP( "lndiode", B3SOIFD_MOD_LNDIODE, IF_REAL, "Length dependence of ndiode"),
IOP( "lisbjt", B3SOIFD_MOD_LISBJT, IF_REAL, "Length dependence of isbjt"),
IOP( "lisdif", B3SOIFD_MOD_LISDIF, IF_REAL, "Length dependence of isdif"),
IOP( "lisrec", B3SOIFD_MOD_LISREC, IF_REAL, "Length dependence of isrec"),
IOP( "listun", B3SOIFD_MOD_LISTUN, IF_REAL, "Length dependence of istun"),
IOP( "ledl", B3SOIFD_MOD_LEDL, IF_REAL, "Length dependence of edl"),
IOP( "lkbjt1", B3SOIFD_MOD_LKBJT1, IF_REAL, "Length dependence of kbjt1"),
IOP( "lvsdfb", B3SOIFD_MOD_LVSDFB, IF_REAL, "Length dependence of vsdfb"),
IOP( "lvsdth", B3SOIFD_MOD_LVSDTH, IF_REAL, "Length dependence of vsdth"),
/* Width Dependence */
IOP( "wnch", B3SOIFD_MOD_WNPEAK, IF_REAL, "Width dependence of nch"),
IOP( "wnsub", B3SOIFD_MOD_WNSUB, IF_REAL, "Width dependence of nsub"),
IOP( "wngate", B3SOIFD_MOD_WNGATE, IF_REAL, "Width dependence of ngate"),
IOP( "wvth0", B3SOIFD_MOD_WVTH0, IF_REAL,"Width dependence of vto"),
IOP( "wk1", B3SOIFD_MOD_WK1, IF_REAL, "Width dependence of k1"),
IOP( "wk2", B3SOIFD_MOD_WK2, IF_REAL, "Width dependence of k2"),
IOP( "wk3", B3SOIFD_MOD_WK3, IF_REAL, "Width dependence of k3"),
IOP( "wk3b", B3SOIFD_MOD_WK3B, IF_REAL, "Width dependence of k3b"),
IOP( "wvbsa", B3SOIFD_MOD_WVBSA, IF_REAL, "Width dependence of vbsa"),
IOP( "wdelp", B3SOIFD_MOD_WDELP, IF_REAL, "Width dependence of delp"),
IOP( "wkb1", B3SOIFD_MOD_WKB1, IF_REAL, "Width dependence of kb1"),
IOP( "wkb3", B3SOIFD_MOD_WKB3, IF_REAL, "Width dependence of kb3"),
IOP( "wdvbd0", B3SOIFD_MOD_WDVBD0, IF_REAL, "Width dependence of dvbd0"),
IOP( "wdvbd1", B3SOIFD_MOD_WDVBD1, IF_REAL, "Width dependence of dvbd1"),
IOP( "ww0", B3SOIFD_MOD_WW0, IF_REAL, "Width dependence of w0"),
IOP( "wnlx", B3SOIFD_MOD_WNLX, IF_REAL, "Width dependence of nlx"),
IOP( "wdvt0", B3SOIFD_MOD_WDVT0, IF_REAL, "Width dependence of dvt0"),
IOP( "wdvt1", B3SOIFD_MOD_WDVT1, IF_REAL, "Width dependence of dvt1"),
IOP( "wdvt2", B3SOIFD_MOD_WDVT2, IF_REAL, "Width dependence of dvt2"),
IOP( "wdvt0w", B3SOIFD_MOD_WDVT0W, IF_REAL, "Width dependence of dvt0w"),
IOP( "wdvt1w", B3SOIFD_MOD_WDVT1W, IF_REAL, "Width dependence of dvt1w"),
IOP( "wdvt2w", B3SOIFD_MOD_WDVT2W, IF_REAL, "Width dependence of dvt2w"),
IOP( "wu0", B3SOIFD_MOD_WU0, IF_REAL, "Width dependence of u0"),
IOP( "wua", B3SOIFD_MOD_WUA, IF_REAL, "Width dependence of ua"),
IOP( "wub", B3SOIFD_MOD_WUB, IF_REAL, "Width dependence of ub"),
IOP( "wuc", B3SOIFD_MOD_WUC, IF_REAL, "Width dependence of uc"),
IOP( "wvsat", B3SOIFD_MOD_WVSAT, IF_REAL, "Width dependence of vsat"),
IOP( "wa0", B3SOIFD_MOD_WA0, IF_REAL, "Width dependence of a0"),
IOP( "wags", B3SOIFD_MOD_WAGS, IF_REAL, "Width dependence of ags"),
IOP( "wb0", B3SOIFD_MOD_WB0, IF_REAL, "Width dependence of b0"),
IOP( "wb1", B3SOIFD_MOD_WB1, IF_REAL, "Width dependence of b1"),
IOP( "wketa", B3SOIFD_MOD_WKETA, IF_REAL, "Width dependence of keta"),
IOP( "wabp", B3SOIFD_MOD_WABP, IF_REAL, "Width dependence of abp"),
IOP( "wmxc", B3SOIFD_MOD_WMXC, IF_REAL, "Width dependence of mxc"),
IOP( "wadice0", B3SOIFD_MOD_WADICE0, IF_REAL, "Width dependence of adice0"),
IOP( "wa1", B3SOIFD_MOD_WA1, IF_REAL, "Width dependence of a1"),
IOP( "wa2", B3SOIFD_MOD_WA2, IF_REAL, "Width dependence of a2"),
IOP( "wrdsw", B3SOIFD_MOD_WRDSW, IF_REAL, "Width dependence of rdsw "),
IOP( "wprwb", B3SOIFD_MOD_WPRWB, IF_REAL, "Width dependence of prwb "),
IOP( "wprwg", B3SOIFD_MOD_WPRWG, IF_REAL, "Width dependence of prwg "),
IOP( "wwr", B3SOIFD_MOD_WWR, IF_REAL, "Width dependence of wr"),
IOP( "wnfactor", B3SOIFD_MOD_WNFACTOR, IF_REAL, "Width dependence of nfactor"),
IOP( "wdwg", B3SOIFD_MOD_WDWG, IF_REAL, "Width dependence of dwg"),
IOP( "wdwb", B3SOIFD_MOD_WDWB, IF_REAL, "Width dependence of dwb"),
IOP( "wvoff", B3SOIFD_MOD_WVOFF, IF_REAL, "Width dependence of voff"),
IOP( "weta0", B3SOIFD_MOD_WETA0, IF_REAL, "Width dependence of eta0"),
IOP( "wetab", B3SOIFD_MOD_WETAB, IF_REAL, "Width dependence of etab"),
IOP( "wdsub", B3SOIFD_MOD_WDSUB, IF_REAL, "Width dependence of dsub"),
IOP( "wcit", B3SOIFD_MOD_WCIT, IF_REAL, "Width dependence of cit"),
IOP( "wcdsc", B3SOIFD_MOD_WCDSC, IF_REAL, "Width dependence of cdsc"),
IOP( "wcdscb", B3SOIFD_MOD_WCDSCB, IF_REAL, "Width dependence of cdscb"),
IOP( "wcdscd", B3SOIFD_MOD_WCDSCD, IF_REAL, "Width dependence of cdscd"),
IOP( "wpclm", B3SOIFD_MOD_WPCLM, IF_REAL, "Width dependence of pclm"),
IOP( "wpdiblc1", B3SOIFD_MOD_WPDIBL1, IF_REAL, "Width dependence of pdiblc1"),
IOP( "wpdiblc2", B3SOIFD_MOD_WPDIBL2, IF_REAL, "Width dependence of pdiblc2"),
IOP( "wpdiblcb", B3SOIFD_MOD_WPDIBLB, IF_REAL, "Width dependence of pdiblcb"),
IOP( "wdrout", B3SOIFD_MOD_WDROUT, IF_REAL, "Width dependence of drout"),
IOP( "wpvag", B3SOIFD_MOD_WPVAG, IF_REAL, "Width dependence of pvag"),
IOP( "wdelta", B3SOIFD_MOD_WDELTA, IF_REAL, "Width dependence of delta"),
IOP( "waii", B3SOIFD_MOD_WAII, IF_REAL, "Width dependence of aii"),
IOP( "wbii", B3SOIFD_MOD_WBII, IF_REAL, "Width dependence of bii"),
IOP( "wcii", B3SOIFD_MOD_WCII, IF_REAL, "Width dependence of cii"),
IOP( "wdii", B3SOIFD_MOD_WDII, IF_REAL, "Width dependence of dii"),
IOP( "walpha0", B3SOIFD_MOD_WALPHA0, IF_REAL, "Width dependence of alpha0"),
IOP( "walpha1", B3SOIFD_MOD_WALPHA1, IF_REAL, "Width dependence of alpha1"),
IOP( "wbeta0", B3SOIFD_MOD_WBETA0, IF_REAL, "Width dependence of beta0"),
IOP( "wagidl", B3SOIFD_MOD_WAGIDL, IF_REAL, "Width dependence of agidl"),
IOP( "wbgidl", B3SOIFD_MOD_WBGIDL, IF_REAL, "Width dependence of bgidl"),
IOP( "wngidl", B3SOIFD_MOD_WNGIDL, IF_REAL, "Width dependence of ngidl"),
IOP( "wntun", B3SOIFD_MOD_WNTUN, IF_REAL, "Width dependence of ntun"),
IOP( "wndiode", B3SOIFD_MOD_WNDIODE, IF_REAL, "Width dependence of ndiode"),
IOP( "wisbjt", B3SOIFD_MOD_WISBJT, IF_REAL, "Width dependence of isbjt"),
IOP( "wisdif", B3SOIFD_MOD_WISDIF, IF_REAL, "Width dependence of isdif"),
IOP( "wisrec", B3SOIFD_MOD_WISREC, IF_REAL, "Width dependence of isrec"),
IOP( "wistun", B3SOIFD_MOD_WISTUN, IF_REAL, "Width dependence of istun"),
IOP( "wedl", B3SOIFD_MOD_WEDL, IF_REAL, "Width dependence of edl"),
IOP( "wkbjt1", B3SOIFD_MOD_WKBJT1, IF_REAL, "Width dependence of kbjt1"),
IOP( "wvsdfb", B3SOIFD_MOD_WVSDFB, IF_REAL, "Width dependence of vsdfb"),
IOP( "wvsdth", B3SOIFD_MOD_WVSDTH, IF_REAL, "Width dependence of vsdth"),
/* Cross-term Dependence */
IOP( "pnch", B3SOIFD_MOD_PNPEAK, IF_REAL, "Cross-term dependence of nch"),
IOP( "pnsub", B3SOIFD_MOD_PNSUB, IF_REAL, "Cross-term dependence of nsub"),
IOP( "pngate", B3SOIFD_MOD_PNGATE, IF_REAL, "Cross-term dependence of ngate"),
IOP( "pvth0", B3SOIFD_MOD_PVTH0, IF_REAL,"Cross-term dependence of vto"),
IOP( "pk1", B3SOIFD_MOD_PK1, IF_REAL, "Cross-term dependence of k1"),
IOP( "pk2", B3SOIFD_MOD_PK2, IF_REAL, "Cross-term dependence of k2"),
IOP( "pk3", B3SOIFD_MOD_PK3, IF_REAL, "Cross-term dependence of k3"),
IOP( "pk3b", B3SOIFD_MOD_PK3B, IF_REAL, "Cross-term dependence of k3b"),
IOP( "pvbsa", B3SOIFD_MOD_PVBSA, IF_REAL, "Cross-term dependence of vbsa"),
IOP( "pdelp", B3SOIFD_MOD_PDELP, IF_REAL, "Cross-term dependence of delp"),
IOP( "pkb1", B3SOIFD_MOD_PKB1, IF_REAL, "Cross-term dependence of kb1"),
IOP( "pkb3", B3SOIFD_MOD_PKB3, IF_REAL, "Cross-term dependence of kb3"),
IOP( "pdvbd0", B3SOIFD_MOD_PDVBD0, IF_REAL, "Cross-term dependence of dvbd0"),
IOP( "pdvbd1", B3SOIFD_MOD_PDVBD1, IF_REAL, "Cross-term dependence of dvbd1"),
IOP( "pw0", B3SOIFD_MOD_PW0, IF_REAL, "Cross-term dependence of w0"),
IOP( "pnlx", B3SOIFD_MOD_PNLX, IF_REAL, "Cross-term dependence of nlx"),
IOP( "pdvt0", B3SOIFD_MOD_PDVT0, IF_REAL, "Cross-term dependence of dvt0"),
IOP( "pdvt1", B3SOIFD_MOD_PDVT1, IF_REAL, "Cross-term dependence of dvt1"),
IOP( "pdvt2", B3SOIFD_MOD_PDVT2, IF_REAL, "Cross-term dependence of dvt2"),
IOP( "pdvt0w", B3SOIFD_MOD_PDVT0W, IF_REAL, "Cross-term dependence of dvt0w"),
IOP( "pdvt1w", B3SOIFD_MOD_PDVT1W, IF_REAL, "Cross-term dependence of dvt1w"),
IOP( "pdvt2w", B3SOIFD_MOD_PDVT2W, IF_REAL, "Cross-term dependence of dvt2w"),
IOP( "pu0", B3SOIFD_MOD_PU0, IF_REAL, "Cross-term dependence of u0"),
IOP( "pua", B3SOIFD_MOD_PUA, IF_REAL, "Cross-term dependence of ua"),
IOP( "pub", B3SOIFD_MOD_PUB, IF_REAL, "Cross-term dependence of ub"),
IOP( "puc", B3SOIFD_MOD_PUC, IF_REAL, "Cross-term dependence of uc"),
IOP( "pvsat", B3SOIFD_MOD_PVSAT, IF_REAL, "Cross-term dependence of vsat"),
IOP( "pa0", B3SOIFD_MOD_PA0, IF_REAL, "Cross-term dependence of a0"),
IOP( "pags", B3SOIFD_MOD_PAGS, IF_REAL, "Cross-term dependence of ags"),
IOP( "pb0", B3SOIFD_MOD_PB0, IF_REAL, "Cross-term dependence of b0"),
IOP( "pb1", B3SOIFD_MOD_PB1, IF_REAL, "Cross-term dependence of b1"),
IOP( "pketa", B3SOIFD_MOD_PKETA, IF_REAL, "Cross-term dependence of keta"),
IOP( "pabp", B3SOIFD_MOD_PABP, IF_REAL, "Cross-term dependence of abp"),
IOP( "pmxc", B3SOIFD_MOD_PMXC, IF_REAL, "Cross-term dependence of mxc"),
IOP( "padice0", B3SOIFD_MOD_PADICE0, IF_REAL, "Cross-term dependence of adice0"),
IOP( "pa1", B3SOIFD_MOD_PA1, IF_REAL, "Cross-term dependence of a1"),
IOP( "pa2", B3SOIFD_MOD_PA2, IF_REAL, "Cross-term dependence of a2"),
IOP( "prdsw", B3SOIFD_MOD_PRDSW, IF_REAL, "Cross-term dependence of rdsw "),
IOP( "pprwb", B3SOIFD_MOD_PPRWB, IF_REAL, "Cross-term dependence of prwb "),
IOP( "pprwg", B3SOIFD_MOD_PPRWG, IF_REAL, "Cross-term dependence of prwg "),
IOP( "pwr", B3SOIFD_MOD_PWR, IF_REAL, "Cross-term dependence of wr"),
IOP( "pnfactor", B3SOIFD_MOD_PNFACTOR, IF_REAL, "Cross-term dependence of nfactor"),
IOP( "pdwg", B3SOIFD_MOD_PDWG, IF_REAL, "Cross-term dependence of dwg"),
IOP( "pdwb", B3SOIFD_MOD_PDWB, IF_REAL, "Cross-term dependence of dwb"),
IOP( "pvoff", B3SOIFD_MOD_PVOFF, IF_REAL, "Cross-term dependence of voff"),
IOP( "peta0", B3SOIFD_MOD_PETA0, IF_REAL, "Cross-term dependence of eta0"),
IOP( "petab", B3SOIFD_MOD_PETAB, IF_REAL, "Cross-term dependence of etab"),
IOP( "pdsub", B3SOIFD_MOD_PDSUB, IF_REAL, "Cross-term dependence of dsub"),
IOP( "pcit", B3SOIFD_MOD_PCIT, IF_REAL, "Cross-term dependence of cit"),
IOP( "pcdsc", B3SOIFD_MOD_PCDSC, IF_REAL, "Cross-term dependence of cdsc"),
IOP( "pcdscb", B3SOIFD_MOD_PCDSCB, IF_REAL, "Cross-term dependence of cdscb"),
IOP( "pcdscd", B3SOIFD_MOD_PCDSCD, IF_REAL, "Cross-term dependence of cdscd"),
IOP( "ppclm", B3SOIFD_MOD_PPCLM, IF_REAL, "Cross-term dependence of pclm"),
IOP( "ppdiblc1", B3SOIFD_MOD_PPDIBL1, IF_REAL, "Cross-term dependence of pdiblc1"),
IOP( "ppdiblc2", B3SOIFD_MOD_PPDIBL2, IF_REAL, "Cross-term dependence of pdiblc2"),
IOP( "ppdiblcb", B3SOIFD_MOD_PPDIBLB, IF_REAL, "Cross-term dependence of pdiblcb"),
IOP( "pdrout", B3SOIFD_MOD_PDROUT, IF_REAL, "Cross-term dependence of drout"),
IOP( "ppvag", B3SOIFD_MOD_PPVAG, IF_REAL, "Cross-term dependence of pvag"),
IOP( "pdelta", B3SOIFD_MOD_PDELTA, IF_REAL, "Cross-term dependence of delta"),
IOP( "paii", B3SOIFD_MOD_PAII, IF_REAL, "Cross-term dependence of aii"),
IOP( "pbii", B3SOIFD_MOD_PBII, IF_REAL, "Cross-term dependence of bii"),
IOP( "pcii", B3SOIFD_MOD_PCII, IF_REAL, "Cross-term dependence of cii"),
IOP( "pdii", B3SOIFD_MOD_PDII, IF_REAL, "Cross-term dependence of dii"),
IOP( "palpha0", B3SOIFD_MOD_PALPHA0, IF_REAL, "Cross-term dependence of alpha0"),
IOP( "palpha1", B3SOIFD_MOD_PALPHA1, IF_REAL, "Cross-term dependence of alpha1"),
IOP( "pbeta0", B3SOIFD_MOD_PBETA0, IF_REAL, "Cross-term dependence of beta0"),
IOP( "pagidl", B3SOIFD_MOD_PAGIDL, IF_REAL, "Cross-term dependence of agidl"),
IOP( "pbgidl", B3SOIFD_MOD_PBGIDL, IF_REAL, "Cross-term dependence of bgidl"),
IOP( "pngidl", B3SOIFD_MOD_PNGIDL, IF_REAL, "Cross-term dependence of ngidl"),
IOP( "pntun", B3SOIFD_MOD_PNTUN, IF_REAL, "Cross-term dependence of ntun"),
IOP( "pndiode", B3SOIFD_MOD_PNDIODE, IF_REAL, "Cross-term dependence of ndiode"),
IOP( "pisbjt", B3SOIFD_MOD_PISBJT, IF_REAL, "Cross-term dependence of isbjt"),
IOP( "pisdif", B3SOIFD_MOD_PISDIF, IF_REAL, "Cross-term dependence of isdif"),
IOP( "pisrec", B3SOIFD_MOD_PISREC, IF_REAL, "Cross-term dependence of isrec"),
IOP( "pistun", B3SOIFD_MOD_PISTUN, IF_REAL, "Cross-term dependence of istun"),
IOP( "pedl", B3SOIFD_MOD_PEDL, IF_REAL, "Cross-term dependence of edl"),
IOP( "pkbjt1", B3SOIFD_MOD_PKBJT1, IF_REAL, "Cross-term dependence of kbjt1"),
IOP( "pvsdfb", B3SOIFD_MOD_PVSDFB, IF_REAL, "Cross-term dependence of vsdfb"),
IOP( "pvsdth", B3SOIFD_MOD_PVSDTH, IF_REAL, "Cross-term dependence of vsdth"),
/* Added for binning - END */
IP( "nmos", B3SOIFD_MOD_NMOS, IF_FLAG, "Flag to indicate NMOS"),
IP( "pmos", B3SOIFD_MOD_PMOS, IF_FLAG, "Flag to indicate PMOS"),
};
char *B3SOIFDnames[] = {
"Drain",
"Gate",
"Source",
"Backgate",
"",
"Body",
"Temp",
"Charge",
};
int B3SOIFDnSize = NUMELEMS(B3SOIFDnames);
int B3SOIFDpTSize = NUMELEMS(B3SOIFDpTable);
int B3SOIFDmPTSize = NUMELEMS(B3SOIFDmPTable);
int B3SOIFDiSize = sizeof(B3SOIFDinstance);
int B3SOIFDmSize = sizeof(B3SOIFDmodel);

443
src/spicelib/devices/bsim3soi_fd/b3soifdacld.c Normal file
View File

@ -0,0 +1,443 @@
/**********
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 99/9/27
File: b3soifdacld.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "b3soifddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIFDacLoad(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
B3SOIFDmodel *model = (B3SOIFDmodel*)inModel;
B3SOIFDinstance *here;
int selfheat;
double xcggb, xcgdb, xcgsb, xcgeb, xcgT;
double xcdgb, xcddb, xcdsb, xcdeb, xcdT;
double xcsgb, xcsdb, xcssb, xcseb, xcsT;
double xcbgb, xcbdb, xcbsb, xcbeb, xcbT;
double xcegb, 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->B3SOIFDnextModel)
{
for (here = model->B3SOIFDinstances; here!= NULL;
here = here->B3SOIFDnextInstance)
{
selfheat = (model->B3SOIFDshMod == 1) && (here->B3SOIFDrth0 != 0.0);
if (here->B3SOIFDdebugMod > 2)
{
fpdebug = fopen("b3soifdac.log", "a");
fprintf(fpdebug, ".......omega=%.5e\n", omega);
}
if (here->B3SOIFDmode >= 0)
{ Gm = here->B3SOIFDgm;
Gmbs = here->B3SOIFDgmbs;
Gme = here->B3SOIFDgme;
GmT = model->B3SOIFDtype * here->B3SOIFDgmT;
FwdSum = Gm + Gmbs + Gme;
RevSum = 0.0;
cbgb = here->B3SOIFDcbgb;
cbsb = here->B3SOIFDcbsb;
cbdb = here->B3SOIFDcbdb;
cbeb = here->B3SOIFDcbeb;
cbT = model->B3SOIFDtype * here->B3SOIFDcbT;
cegb = here->B3SOIFDcegb;
cesb = here->B3SOIFDcesb;
cedb = here->B3SOIFDcedb;
ceeb = here->B3SOIFDceeb;
ceT = model->B3SOIFDtype * here->B3SOIFDceT;
cggb = here->B3SOIFDcggb;
cgsb = here->B3SOIFDcgsb;
cgdb = here->B3SOIFDcgdb;
cgeb = here->B3SOIFDcgeb;
cgT = model->B3SOIFDtype * here->B3SOIFDcgT;
cdgb = here->B3SOIFDcdgb;
cdsb = here->B3SOIFDcdsb;
cddb = here->B3SOIFDcddb;
cdeb = here->B3SOIFDcdeb;
cdT = model->B3SOIFDtype * here->B3SOIFDcdT;
cTt = here->pParam->B3SOIFDcth;
gbbg = -here->B3SOIFDgbgs;
gbbdp = -here->B3SOIFDgbds;
gbbb = -here->B3SOIFDgbbs;
gbbe = -here->B3SOIFDgbes;
gbbp = -here->B3SOIFDgbps;
gbbT = -model->B3SOIFDtype * here->B3SOIFDgbT;
gbbsp = - ( gbbg + gbbdp + gbbb + gbbe + gbbp);
gddpg = -here->B3SOIFDgjdg;
gddpdp = -here->B3SOIFDgjdd;
gddpb = -here->B3SOIFDgjdb;
gddpe = -here->B3SOIFDgjde;
gddpT = -model->B3SOIFDtype * here->B3SOIFDgjdT;
gddpsp = - ( gddpg + gddpdp + gddpb + gddpe);
gsspg = -here->B3SOIFDgjsg;
gsspdp = -here->B3SOIFDgjsd;
gsspb = -here->B3SOIFDgjsb;
gsspe = 0.0;
gsspT = -model->B3SOIFDtype * here->B3SOIFDgjsT;
gsspsp = - (gsspg + gsspdp + gsspb + gsspe);
gppg = -here->B3SOIFDgbpgs;
gppdp = -here->B3SOIFDgbpds;
gppb = -here->B3SOIFDgbpbs;
gppe = -here->B3SOIFDgbpes;
gppp = -here->B3SOIFDgbpps;
gppT = -model->B3SOIFDtype * here->B3SOIFDgbpT;
gppsp = - (gppg + gppdp + gppb + gppe + gppp);
gTtg = here->B3SOIFDgtempg;
gTtb = here->B3SOIFDgtempb;
gTte = here->B3SOIFDgtempe;
gTtdp = here->B3SOIFDgtempd;
gTtt = here->B3SOIFDgtempT;
gTtsp = - (gTtg + gTtb + gTte + gTtdp);
sxpart = 0.6;
dxpart = 0.4;
}
else
{ Gm = -here->B3SOIFDgm;
Gmbs = -here->B3SOIFDgmbs;
Gme = -here->B3SOIFDgme;
GmT = -model->B3SOIFDtype * here->B3SOIFDgmT;
FwdSum = 0.0;
RevSum = -Gm - Gmbs - Gme;
cdgb = - (here->B3SOIFDcdgb + here->B3SOIFDcggb + here->B3SOIFDcbgb
+ here->B3SOIFDcegb);
cdsb = - (here->B3SOIFDcddb + here->B3SOIFDcgdb + here->B3SOIFDcbdb
+ here->B3SOIFDcedb);
cddb = - (here->B3SOIFDcdsb + here->B3SOIFDcgsb + here->B3SOIFDcbsb
+ here->B3SOIFDcesb);
cdeb = - (here->B3SOIFDcdeb + here->B3SOIFDcgeb + here->B3SOIFDcbeb
+ here->B3SOIFDceeb);
cdT = - model->B3SOIFDtype * (here->B3SOIFDcgT + here->B3SOIFDcbT
+ here->B3SOIFDcdT + here->B3SOIFDceT);
cegb = here->B3SOIFDcegb;
cesb = here->B3SOIFDcedb;
cedb = here->B3SOIFDcesb;
ceeb = here->B3SOIFDceeb;
ceT = model->B3SOIFDtype * here->B3SOIFDceT;
cggb = here->B3SOIFDcggb;
cgsb = here->B3SOIFDcgdb;
cgdb = here->B3SOIFDcgsb;
cgeb = here->B3SOIFDcgeb;
cgT = model->B3SOIFDtype * here->B3SOIFDcgT;
cbgb = here->B3SOIFDcbgb;
cbsb = here->B3SOIFDcbdb;
cbdb = here->B3SOIFDcbsb;
cbeb = here->B3SOIFDcbeb;
cbT = model->B3SOIFDtype * here->B3SOIFDcbT;
cTt = here->pParam->B3SOIFDcth;
gbbg = -here->B3SOIFDgbgs;
gbbb = -here->B3SOIFDgbbs;
gbbe = -here->B3SOIFDgbes;
gbbp = -here->B3SOIFDgbps;
gbbsp = -here->B3SOIFDgbds;
gbbT = -model->B3SOIFDtype * here->B3SOIFDgbT;
gbbdp = - ( gbbg + gbbsp + gbbb + gbbe + gbbp);
gddpg = -here->B3SOIFDgjsg;
gddpsp = -here->B3SOIFDgjsd;
gddpb = -here->B3SOIFDgjsb;
gddpe = 0.0;
gddpT = -model->B3SOIFDtype * here->B3SOIFDgjsT;
gddpdp = - (gddpg + gddpsp + gddpb + gddpe);
gsspg = -here->B3SOIFDgjdg;
gsspsp = -here->B3SOIFDgjdd;
gsspb = -here->B3SOIFDgjdb;
gsspe = -here->B3SOIFDgjde;
gsspT = -model->B3SOIFDtype * here->B3SOIFDgjdT;
gsspdp = - ( gsspg + gsspsp + gsspb + gsspe);
gppg = -here->B3SOIFDgbpgs;
gppsp = -here->B3SOIFDgbpds;
gppb = -here->B3SOIFDgbpbs;
gppe = -here->B3SOIFDgbpes;
gppp = -here->B3SOIFDgbpps;
gppT = -model->B3SOIFDtype * here->B3SOIFDgbpT;
gppdp = - (gppg + gppsp + gppb + gppe + gppp);
gTtt = here->B3SOIFDgtempT;
gTtg = here->B3SOIFDgtempg;
gTtb = here->B3SOIFDgtempb;
gTte = here->B3SOIFDgtempe;
gTtdp = here->B3SOIFDgtempd;
gTtsp = - (gTtt + gTtg + gTtb + gTte + gTtdp);
gTtg = here->B3SOIFDgtempg;
gTtb = here->B3SOIFDgtempb;
gTte = here->B3SOIFDgtempe;
gTtsp = here->B3SOIFDgtempd;
gTtt = here->B3SOIFDgtempT;
gTtdp = - (gTtg + gTtb + gTte + gTtsp);
sxpart = 0.6;
sxpart = 0.4;
dxpart = 0.6;
}
gdpr=here->B3SOIFDdrainConductance;
gspr=here->B3SOIFDsourceConductance;
gds= here->B3SOIFDgds;
GSoverlapCap = here->B3SOIFDcgso;
GDoverlapCap = here->B3SOIFDcgdo;
GEoverlapCap = here->pParam->B3SOIFDcgeo;
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->B3SOIFDEgPtr +1) += xcegb;
*(here->B3SOIFDEdpPtr +1) += xcedb;
*(here->B3SOIFDEspPtr +1) += xcesb;
*(here->B3SOIFDGePtr +1) += xcgeb;
*(here->B3SOIFDDPePtr +1) += xcdeb;
*(here->B3SOIFDSPePtr +1) += xcseb;
*(here->B3SOIFDEePtr +1) += xceeb;
*(here->B3SOIFDGgPtr +1) += xcggb;
*(here->B3SOIFDGdpPtr +1) += xcgdb;
*(here->B3SOIFDGspPtr +1) += xcgsb;
*(here->B3SOIFDDPgPtr +1) += xcdgb;
*(here->B3SOIFDDPdpPtr +1) += xcddb;
*(here->B3SOIFDDPspPtr +1) += xcdsb;
*(here->B3SOIFDSPgPtr +1) += xcsgb;
*(here->B3SOIFDSPdpPtr +1) += xcsdb;
*(here->B3SOIFDSPspPtr +1) += xcssb;
if (selfheat)
{
*(here->B3SOIFDTemptempPtr + 1) += xcTt;
*(here->B3SOIFDDPtempPtr + 1) += xcdT;
*(here->B3SOIFDSPtempPtr + 1) += xcsT;
*(here->B3SOIFDBtempPtr + 1) += xcbT;
*(here->B3SOIFDEtempPtr + 1) += xceT;
*(here->B3SOIFDGtempPtr + 1) += xcgT;
}
if (here->B3SOIFDdebugMod > 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->B3SOIFDEgPtr) += 0.0;
*(here->B3SOIFDEdpPtr) += 0.0;
*(here->B3SOIFDEspPtr) += 0.0;
*(here->B3SOIFDGePtr) -= 0.0;
*(here->B3SOIFDDPePtr) += Gme + gddpe;
*(here->B3SOIFDSPePtr) += gsspe - Gme;
*(here->B3SOIFDEePtr) += 0.0;
*(here->B3SOIFDDPgPtr) += Gm + gddpg;
*(here->B3SOIFDDPdpPtr) += gdpr + gds + gddpdp + RevSum ;
*(here->B3SOIFDDPspPtr) -= gds + FwdSum - gddpsp;
*(here->B3SOIFDDPdPtr) -= gdpr;
*(here->B3SOIFDSPgPtr) -= Gm - gsspg;
*(here->B3SOIFDSPdpPtr) -= gds + RevSum - gsspdp;
*(here->B3SOIFDSPspPtr) += gspr + gds + FwdSum + gsspsp;
*(here->B3SOIFDSPsPtr) -= gspr;
if (selfheat)
{
*(here->B3SOIFDDPtempPtr) += GmT + gddpT;
*(here->B3SOIFDSPtempPtr) += -GmT + gsspT;
*(here->B3SOIFDBtempPtr) += gbbT;
if (here->B3SOIFDbodyMod == 1) {
(*(here->B3SOIFDPtempPtr) += gppT);
}
*(here->B3SOIFDTemptempPtr) += gTtt + 1/here->pParam->B3SOIFDrth;
*(here->B3SOIFDTempgPtr) += gTtg;
*(here->B3SOIFDTempbPtr) += gTtb;
*(here->B3SOIFDTempePtr) += gTte;
*(here->B3SOIFDTempdpPtr) += gTtdp;
*(here->B3SOIFDTempspPtr) += gTtsp;
}
if (here->B3SOIFDdebugMod > 3)
{
fprintf(fpdebug, "Static condunctance...\n");
fprintf(fpdebug, "Gg=%.5e; Gdp=%.5e; Gsp=%.5e;\nGb=%.5e; Ge=%.5e\n",
*(here->B3SOIFDGgPtr), *(here->B3SOIFDGdpPtr),
*(here->B3SOIFDGspPtr), *(here->B3SOIFDGbPtr),
*(here->B3SOIFDGePtr));
fprintf(fpdebug, "DPg=%.5e; DPdp=%.5e; DPsp=%.5e;\nDPb=%.5e; DPe=%.5e\n",
*(here->B3SOIFDDPgPtr), *(here->B3SOIFDDPdpPtr),
*(here->B3SOIFDDPspPtr), *(here->B3SOIFDDPbPtr),
*(here->B3SOIFDDPePtr));
fprintf(fpdebug, "SPg=%.5e; SPdp=%.5e; SPsp=%.5e;\nSPb=%.5e; SPe=%.5e\n",
*(here->B3SOIFDSPgPtr), *(here->B3SOIFDSPdpPtr),
*(here->B3SOIFDSPspPtr), *(here->B3SOIFDSPbPtr),
*(here->B3SOIFDSPePtr));
fprintf(fpdebug, "Bg=%.5e; Bdp=%.5e; Bsp=%.5e;\nBb=%.5e; Be=%.5e\n",
gbbg, gbbdp, gbbsp, gbbb, gbbe);
}
*(here->B3SOIFDDdPtr) += gdpr;
*(here->B3SOIFDDdpPtr) -= gdpr;
*(here->B3SOIFDSsPtr) += gspr;
*(here->B3SOIFDSspPtr) -= gspr;
if (here->B3SOIFDbodyMod == 1) {
(*(here->B3SOIFDBpPtr) -= gppp);
(*(here->B3SOIFDPbPtr) += gppb);
(*(here->B3SOIFDPpPtr) += gppp);
(*(here->B3SOIFDPgPtr) += gppg);
(*(here->B3SOIFDPdpPtr) += gppdp);
(*(here->B3SOIFDPspPtr) += gppsp);
(*(here->B3SOIFDPePtr) += gppe);
}
if (here->B3SOIFDdebugMod > 1)
{
*(here->B3SOIFDVbsPtr) += 1;
*(here->B3SOIFDIdsPtr) += 1;
*(here->B3SOIFDIcPtr) += 1;
*(here->B3SOIFDIbsPtr) += 1;
*(here->B3SOIFDIbdPtr) += 1;
*(here->B3SOIFDIiiPtr) += 1;
*(here->B3SOIFDIgidlPtr) += 1;
*(here->B3SOIFDItunPtr) += 1;
*(here->B3SOIFDIbpPtr) += 1;
*(here->B3SOIFDAbeffPtr) += 1;
*(here->B3SOIFDVbs0effPtr) += 1;
*(here->B3SOIFDVbseffPtr) += 1;
*(here->B3SOIFDXcPtr) += 1;
*(here->B3SOIFDCbgPtr) += 1;
*(here->B3SOIFDCbbPtr) += 1;
*(here->B3SOIFDCbdPtr) += 1;
*(here->B3SOIFDqbPtr) += 1;
*(here->B3SOIFDQbfPtr) += 1;
*(here->B3SOIFDQjsPtr) += 1;
*(here->B3SOIFDQjdPtr) += 1;
/* clean up last */
*(here->B3SOIFDGmPtr) += 1;
*(here->B3SOIFDGmbsPtr) += 1;
*(here->B3SOIFDGdsPtr) += 1;
*(here->B3SOIFDGmePtr) += 1;
*(here->B3SOIFDVbs0teffPtr) += 1;
*(here->B3SOIFDVgsteffPtr) += 1;
*(here->B3SOIFDCbePtr) += 1;
*(here->B3SOIFDVthPtr) += 1;
*(here->B3SOIFDXcsatPtr) += 1;
*(here->B3SOIFDVdscvPtr) += 1;
*(here->B3SOIFDVcscvPtr) += 1;
*(here->B3SOIFDQaccPtr) += 1;
*(here->B3SOIFDQsub0Ptr) += 1;
*(here->B3SOIFDQsubs1Ptr) += 1;
*(here->B3SOIFDQsubs2Ptr) += 1;
*(here->B3SOIFDqgPtr) += 1;
*(here->B3SOIFDqdPtr) += 1;
*(here->B3SOIFDqePtr) += 1;
*(here->B3SOIFDDum1Ptr) += 1;
*(here->B3SOIFDDum2Ptr) += 1;
*(here->B3SOIFDDum3Ptr) += 1;
*(here->B3SOIFDDum4Ptr) += 1;
*(here->B3SOIFDDum5Ptr) += 1;
}
if (here->B3SOIFDdebugMod > 2)
fclose(fpdebug);
}
}
return(OK);
}

214
src/spicelib/devices/bsim3soi_fd/b3soifdask.c Normal file
View File

@ -0,0 +1,214 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soifdask.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "ifsim.h"
#include "cktdefs.h"
#include "devdefs.h"
#include "b3soifddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIFDask(ckt,inst,which,value,select)
CKTcircuit *ckt;
GENinstance *inst;
int which;
IFvalue *value;
IFvalue *select;
{
B3SOIFDinstance *here = (B3SOIFDinstance*)inst;
switch(which)
{ case B3SOIFD_L:
value->rValue = here->B3SOIFDl;
return(OK);
case B3SOIFD_W:
value->rValue = here->B3SOIFDw;
return(OK);
case B3SOIFD_AS:
value->rValue = here->B3SOIFDsourceArea;
return(OK);
case B3SOIFD_AD:
value->rValue = here->B3SOIFDdrainArea;
return(OK);
case B3SOIFD_PS:
value->rValue = here->B3SOIFDsourcePerimeter;
return(OK);
case B3SOIFD_PD:
value->rValue = here->B3SOIFDdrainPerimeter;
return(OK);
case B3SOIFD_NRS:
value->rValue = here->B3SOIFDsourceSquares;
return(OK);
case B3SOIFD_NRD:
value->rValue = here->B3SOIFDdrainSquares;
return(OK);
case B3SOIFD_OFF:
value->rValue = here->B3SOIFDoff;
return(OK);
case B3SOIFD_BJTOFF:
value->iValue = here->B3SOIFDbjtoff;
return(OK);
case B3SOIFD_RTH0:
value->rValue = here->B3SOIFDrth0;
return(OK);
case B3SOIFD_CTH0:
value->rValue = here->B3SOIFDcth0;
return(OK);
case B3SOIFD_NRB:
value->rValue = here->B3SOIFDbodySquares;
return(OK);
case B3SOIFD_IC_VBS:
value->rValue = here->B3SOIFDicVBS;
return(OK);
case B3SOIFD_IC_VDS:
value->rValue = here->B3SOIFDicVDS;
return(OK);
case B3SOIFD_IC_VGS:
value->rValue = here->B3SOIFDicVGS;
return(OK);
case B3SOIFD_IC_VES:
value->rValue = here->B3SOIFDicVES;
return(OK);
case B3SOIFD_IC_VPS:
value->rValue = here->B3SOIFDicVPS;
return(OK);
case B3SOIFD_DNODE:
value->iValue = here->B3SOIFDdNode;
return(OK);
case B3SOIFD_GNODE:
value->iValue = here->B3SOIFDgNode;
return(OK);
case B3SOIFD_SNODE:
value->iValue = here->B3SOIFDsNode;
return(OK);
case B3SOIFD_BNODE:
value->iValue = here->B3SOIFDbNode;
return(OK);
case B3SOIFD_ENODE:
value->iValue = here->B3SOIFDeNode;
return(OK);
case B3SOIFD_DNODEPRIME:
value->iValue = here->B3SOIFDdNodePrime;
return(OK);
case B3SOIFD_SNODEPRIME:
value->iValue = here->B3SOIFDsNodePrime;
return(OK);
case B3SOIFD_SOURCECONDUCT:
value->rValue = here->B3SOIFDsourceConductance;
return(OK);
case B3SOIFD_DRAINCONDUCT:
value->rValue = here->B3SOIFDdrainConductance;
return(OK);
case B3SOIFD_VBD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDvbd);
return(OK);
case B3SOIFD_VBS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDvbs);
return(OK);
case B3SOIFD_VGS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDvgs);
return(OK);
case B3SOIFD_VES:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDves);
return(OK);
case B3SOIFD_VDS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDvds);
return(OK);
case B3SOIFD_CD:
value->rValue = here->B3SOIFDcd;
return(OK);
case B3SOIFD_CBS:
value->rValue = here->B3SOIFDcjs;
return(OK);
case B3SOIFD_CBD:
value->rValue = here->B3SOIFDcjd;
return(OK);
case B3SOIFD_GM:
value->rValue = here->B3SOIFDgm;
return(OK);
case B3SOIFD_GMID:
value->rValue = here->B3SOIFDgm/here->B3SOIFDcd;
return(OK);
case B3SOIFD_GDS:
value->rValue = here->B3SOIFDgds;
return(OK);
case B3SOIFD_GMBS:
value->rValue = here->B3SOIFDgmbs;
return(OK);
case B3SOIFD_GBD:
value->rValue = here->B3SOIFDgjdb;
return(OK);
case B3SOIFD_GBS:
value->rValue = here->B3SOIFDgjsb;
return(OK);
case B3SOIFD_QB:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDqb);
return(OK);
case B3SOIFD_CQB:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDcqb);
return(OK);
case B3SOIFD_QG:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDqg);
return(OK);
case B3SOIFD_CQG:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDcqg);
return(OK);
case B3SOIFD_QD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDqd);
return(OK);
case B3SOIFD_CQD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDcqd);
return(OK);
case B3SOIFD_CGG:
value->rValue = here->B3SOIFDcggb;
return(OK);
case B3SOIFD_CGD:
value->rValue = here->B3SOIFDcgdb;
return(OK);
case B3SOIFD_CGS:
value->rValue = here->B3SOIFDcgsb;
return(OK);
case B3SOIFD_CDG:
value->rValue = here->B3SOIFDcdgb;
return(OK);
case B3SOIFD_CDD:
value->rValue = here->B3SOIFDcddb;
return(OK);
case B3SOIFD_CDS:
value->rValue = here->B3SOIFDcdsb;
return(OK);
case B3SOIFD_CBG:
value->rValue = here->B3SOIFDcbgb;
return(OK);
case B3SOIFD_CBDB:
value->rValue = here->B3SOIFDcbdb;
return(OK);
case B3SOIFD_CBSB:
value->rValue = here->B3SOIFDcbsb;
return(OK);
case B3SOIFD_VON:
value->rValue = here->B3SOIFDvon;
return(OK);
case B3SOIFD_VDSAT:
value->rValue = here->B3SOIFDvdsat;
return(OK);
case B3SOIFD_QBS:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDqbs);
return(OK);
case B3SOIFD_QBD:
value->rValue = *(ckt->CKTstate0 + here->B3SOIFDqbd);
return(OK);
default:
return(E_BADPARM);
}
/* NOTREACHED */
}

504
src/spicelib/devices/bsim3soi_fd/b3soifdcheck.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: b3soifdcheck.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "b3soifddef.h"
#include "trandefs.h"
#include "const.h"
#include "sperror.h"
#include "devdefs.h"
#include "suffix.h"
int
B3SOIFDcheckModel(model, here, ckt)
B3SOIFDmodel *model;
B3SOIFDinstance *here;
CKTcircuit *ckt;
{
struct b3soifdSizeDependParam *pParam;
int Fatal_Flag = 0;
FILE *fplog;
if ((fplog = fopen("b3soifdv1check.log", "w")) != NULL)
{ pParam = here->pParam;
fprintf(fplog, "B3SOIFDV3 Parameter Check\n");
fprintf(fplog, "Model = %s\n", model->B3SOIFDmodName);
fprintf(fplog, "W = %g, L = %g\n", here->B3SOIFDw, here->B3SOIFDl);
if (pParam->B3SOIFDnlx < -pParam->B3SOIFDleff)
{ fprintf(fplog, "Fatal: Nlx = %g is less than -Leff.\n",
pParam->B3SOIFDnlx);
printf("Fatal: Nlx = %g is less than -Leff.\n",
pParam->B3SOIFDnlx);
Fatal_Flag = 1;
}
if (model->B3SOIFDtox <= 0.0)
{ fprintf(fplog, "Fatal: Tox = %g is not positive.\n",
model->B3SOIFDtox);
printf("Fatal: Tox = %g is not positive.\n", model->B3SOIFDtox);
Fatal_Flag = 1;
}
if (model->B3SOIFDtbox <= 0.0)
{ fprintf(fplog, "Fatal: Tbox = %g is not positive.\n",
model->B3SOIFDtbox);
printf("Fatal: Tbox = %g is not positive.\n", model->B3SOIFDtbox);
Fatal_Flag = 1;
}
if (pParam->B3SOIFDnpeak <= 0.0)
{ fprintf(fplog, "Fatal: Nch = %g is not positive.\n",
pParam->B3SOIFDnpeak);
printf("Fatal: Nch = %g is not positive.\n",
pParam->B3SOIFDnpeak);
Fatal_Flag = 1;
}
if (pParam->B3SOIFDngate < 0.0)
{ fprintf(fplog, "Fatal: Ngate = %g is not positive.\n",
pParam->B3SOIFDngate);
printf("Fatal: Ngate = %g Ngate is not positive.\n",
pParam->B3SOIFDngate);
Fatal_Flag = 1;
}
if (pParam->B3SOIFDngate > 1.e25)
{ fprintf(fplog, "Fatal: Ngate = %g is too high.\n",
pParam->B3SOIFDngate);
printf("Fatal: Ngate = %g Ngate is too high\n",
pParam->B3SOIFDngate);
Fatal_Flag = 1;
}
if (model->B3SOIFDdvbd1 < 0.0)
{ fprintf(fplog, "Fatal: Dvbd1 = %g is negative.\n",
model->B3SOIFDdvbd1);
printf("Fatal: Dvbd1 = %g is negative.\n", model->B3SOIFDdvbd1);
Fatal_Flag = 1;
}
if (pParam->B3SOIFDdvt1 < 0.0)
{ fprintf(fplog, "Fatal: Dvt1 = %g is negative.\n",
pParam->B3SOIFDdvt1);
printf("Fatal: Dvt1 = %g is negative.\n", pParam->B3SOIFDdvt1);
Fatal_Flag = 1;
}
if (pParam->B3SOIFDdvt1w < 0.0)
{ fprintf(fplog, "Fatal: Dvt1w = %g is negative.\n",
pParam->B3SOIFDdvt1w);
printf("Fatal: Dvt1w = %g is negative.\n", pParam->B3SOIFDdvt1w);
Fatal_Flag = 1;
}
if (pParam->B3SOIFDw0 == -pParam->B3SOIFDweff)
{ 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->B3SOIFDdsub < 0.0)
{ fprintf(fplog, "Fatal: Dsub = %g is negative.\n", pParam->B3SOIFDdsub);
printf("Fatal: Dsub = %g is negative.\n", pParam->B3SOIFDdsub);
Fatal_Flag = 1;
}
if (pParam->B3SOIFDb1 == -pParam->B3SOIFDweff)
{ 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->B3SOIFDu0temp <= 0.0)
{ fprintf(fplog, "Fatal: u0 at current temperature = %g is not positive.\n", pParam->B3SOIFDu0temp);
printf("Fatal: u0 at current temperature = %g is not positive.\n",
pParam->B3SOIFDu0temp);
Fatal_Flag = 1;
}
/* Check delta parameter */
if (pParam->B3SOIFDdelta < 0.0)
{ fprintf(fplog, "Fatal: Delta = %g is less than zero.\n",
pParam->B3SOIFDdelta);
printf("Fatal: Delta = %g is less than zero.\n", pParam->B3SOIFDdelta);
Fatal_Flag = 1;
}
if (pParam->B3SOIFDvsattemp <= 0.0)
{ fprintf(fplog, "Fatal: Vsat at current temperature = %g is not positive.\n", pParam->B3SOIFDvsattemp);
printf("Fatal: Vsat at current temperature = %g is not positive.\n",
pParam->B3SOIFDvsattemp);
Fatal_Flag = 1;
}
/* Check Rout parameters */
if (pParam->B3SOIFDpclm <= 0.0)
{ fprintf(fplog, "Fatal: Pclm = %g is not positive.\n", pParam->B3SOIFDpclm);
printf("Fatal: Pclm = %g is not positive.\n", pParam->B3SOIFDpclm);
Fatal_Flag = 1;
}
if (pParam->B3SOIFDdrout < 0.0)
{ fprintf(fplog, "Fatal: Drout = %g is negative.\n", pParam->B3SOIFDdrout);
printf("Fatal: Drout = %g is negative.\n", pParam->B3SOIFDdrout);
Fatal_Flag = 1;
}
if ( model->B3SOIFDunitLengthGateSidewallJctCap > 0.0)
{
if (here->B3SOIFDdrainPerimeter < pParam->B3SOIFDweff)
{ fprintf(fplog, "Warning: Pd = %g is less than W.\n",
here->B3SOIFDdrainPerimeter);
printf("Warning: Pd = %g is less than W.\n",
here->B3SOIFDdrainPerimeter);
here->B3SOIFDdrainPerimeter =pParam->B3SOIFDweff;
}
if (here->B3SOIFDsourcePerimeter < pParam->B3SOIFDweff)
{ fprintf(fplog, "Warning: Ps = %g is less than W.\n",
here->B3SOIFDsourcePerimeter);
printf("Warning: Ps = %g is less than W.\n",
here->B3SOIFDsourcePerimeter);
here->B3SOIFDsourcePerimeter =pParam->B3SOIFDweff;
}
}
/* Check capacitance parameters */
if (pParam->B3SOIFDclc < 0.0)
{ fprintf(fplog, "Fatal: Clc = %g is negative.\n", pParam->B3SOIFDclc);
printf("Fatal: Clc = %g is negative.\n", pParam->B3SOIFDclc);
Fatal_Flag = 1;
}
if (model->B3SOIFDparamChk ==1)
{
/* Check L and W parameters */
if (pParam->B3SOIFDleff <= 5.0e-8)
{ fprintf(fplog, "Warning: Leff = %g may be too small.\n",
pParam->B3SOIFDleff);
printf("Warning: Leff = %g may be too small.\n",
pParam->B3SOIFDleff);
}
if (pParam->B3SOIFDleffCV <= 5.0e-8)
{ fprintf(fplog, "Warning: Leff for CV = %g may be too small.\n",
pParam->B3SOIFDleffCV);
printf("Warning: Leff for CV = %g may be too small.\n",
pParam->B3SOIFDleffCV);
}
if (pParam->B3SOIFDweff <= 1.0e-7)
{ fprintf(fplog, "Warning: Weff = %g may be too small.\n",
pParam->B3SOIFDweff);
printf("Warning: Weff = %g may be too small.\n",
pParam->B3SOIFDweff);
}
if (pParam->B3SOIFDweffCV <= 1.0e-7)
{ fprintf(fplog, "Warning: Weff for CV = %g may be too small.\n",
pParam->B3SOIFDweffCV);
printf("Warning: Weff for CV = %g may be too small.\n",
pParam->B3SOIFDweffCV);
}
/* Check threshold voltage parameters */
if (pParam->B3SOIFDnlx < 0.0)
{ fprintf(fplog, "Warning: Nlx = %g is negative.\n", pParam->B3SOIFDnlx);
printf("Warning: Nlx = %g is negative.\n", pParam->B3SOIFDnlx);
}
if (model->B3SOIFDtox < 1.0e-9)
{ fprintf(fplog, "Warning: Tox = %g is less than 10A.\n",
model->B3SOIFDtox);
printf("Warning: Tox = %g is less than 10A.\n", model->B3SOIFDtox);
}
if (pParam->B3SOIFDnpeak <= 1.0e15)
{ fprintf(fplog, "Warning: Nch = %g may be too small.\n",
pParam->B3SOIFDnpeak);
printf("Warning: Nch = %g may be too small.\n",
pParam->B3SOIFDnpeak);
}
else if (pParam->B3SOIFDnpeak >= 1.0e21)
{ fprintf(fplog, "Warning: Nch = %g may be too large.\n",
pParam->B3SOIFDnpeak);
printf("Warning: Nch = %g may be too large.\n",
pParam->B3SOIFDnpeak);
}
if (fabs(pParam->B3SOIFDnsub) >= 1.0e21)
{ fprintf(fplog, "Warning: Nsub = %g may be too large.\n",
pParam->B3SOIFDnsub);
printf("Warning: Nsub = %g may be too large.\n",
pParam->B3SOIFDnsub);
}
if ((pParam->B3SOIFDngate > 0.0) &&
(pParam->B3SOIFDngate <= 1.e18))
{ fprintf(fplog, "Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->B3SOIFDngate);
printf("Warning: Ngate = %g is less than 1.E18cm^-3.\n",
pParam->B3SOIFDngate);
}
if (model->B3SOIFDdvbd0 < 0.0)
{ fprintf(fplog, "Warning: Dvbd0 = %g is negative.\n",
model->B3SOIFDdvbd0);
printf("Warning: Dvbd0 = %g is negative.\n", model->B3SOIFDdvbd0);
}
if (pParam->B3SOIFDdvt0 < 0.0)
{ fprintf(fplog, "Warning: Dvt0 = %g is negative.\n",
pParam->B3SOIFDdvt0);
printf("Warning: Dvt0 = %g is negative.\n", pParam->B3SOIFDdvt0);
}
if (fabs(1.0e-6 / (pParam->B3SOIFDw0 + pParam->B3SOIFDweff)) > 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->B3SOIFDnfactor < 0.0)
{ fprintf(fplog, "Warning: Nfactor = %g is negative.\n",
pParam->B3SOIFDnfactor);
printf("Warning: Nfactor = %g is negative.\n", pParam->B3SOIFDnfactor);
}
if (model->B3SOIFDkb3 < 0.0)
{ fprintf(fplog, "Warning: Kb3 = %g is negative.\n",
model->B3SOIFDkb3);
printf("Warning: Kb3 = %g is negative.\n", model->B3SOIFDkb3);
}
if (pParam->B3SOIFDcdsc < 0.0)
{ fprintf(fplog, "Warning: Cdsc = %g is negative.\n",
pParam->B3SOIFDcdsc);
printf("Warning: Cdsc = %g is negative.\n", pParam->B3SOIFDcdsc);
}
if (pParam->B3SOIFDcdscd < 0.0)
{ fprintf(fplog, "Warning: Cdscd = %g is negative.\n",
pParam->B3SOIFDcdscd);
printf("Warning: Cdscd = %g is negative.\n", pParam->B3SOIFDcdscd);
}
/* Check DIBL parameters */
if (pParam->B3SOIFDeta0 < 0.0)
{ fprintf(fplog, "Warning: Eta0 = %g is negative.\n",
pParam->B3SOIFDeta0);
printf("Warning: Eta0 = %g is negative.\n", pParam->B3SOIFDeta0);
}
/* Check Abulk parameters */
if (fabs(1.0e-6 / (pParam->B3SOIFDb1 + pParam->B3SOIFDweff)) > 10.0)
{ fprintf(fplog, "Warning: (B1 + Weff) may be too small.\n");
printf("Warning: (B1 + Weff) may be too small.\n");
}
if (model->B3SOIFDadice0 > 1.0)
{ fprintf(fplog, "Warning: Adice0 = %g should be smaller than 1.\n",
model->B3SOIFDadice0);
printf("Warning: Adice0 = %g should be smaller than 1.\n", model->B3SOIFDadice0);
}
if (model->B3SOIFDabp < 0.2)
{ fprintf(fplog, "Warning: Abp = %g is too small.\n",
model->B3SOIFDabp);
printf("Warning: Abp = %g is too small.\n", model->B3SOIFDabp);
}
if ((model->B3SOIFDmxc < -1.0) || (model->B3SOIFDmxc > 1.0))
{ fprintf(fplog, "Warning: Mxc = %g should be within (-1, 1).\n",
model->B3SOIFDmxc);
printf("Warning: Mxc = %g should be within (-1, 1).\n", model->B3SOIFDmxc);
}
/* Check Saturation parameters */
if (pParam->B3SOIFDa2 < 0.01)
{ fprintf(fplog, "Warning: A2 = %g is too small. Set to 0.01.\n", pParam->B3SOIFDa2);
printf("Warning: A2 = %g is too small. Set to 0.01.\n",
pParam->B3SOIFDa2);
pParam->B3SOIFDa2 = 0.01;
}
else if (pParam->B3SOIFDa2 > 1.0)
{ fprintf(fplog, "Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->B3SOIFDa2);
printf("Warning: A2 = %g is larger than 1. A2 is set to 1 and A1 is set to 0.\n",
pParam->B3SOIFDa2);
pParam->B3SOIFDa2 = 1.0;
pParam->B3SOIFDa1 = 0.0;
}
if (pParam->B3SOIFDrdsw < 0.0)
{ fprintf(fplog, "Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->B3SOIFDrdsw);
printf("Warning: Rdsw = %g is negative. Set to zero.\n",
pParam->B3SOIFDrdsw);
pParam->B3SOIFDrdsw = 0.0;
pParam->B3SOIFDrds0 = 0.0;
}
else if ((pParam->B3SOIFDrds0 > 0.0) && (pParam->B3SOIFDrds0 < 0.001))
{ fprintf(fplog, "Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n",
pParam->B3SOIFDrds0);
printf("Warning: Rds at current temperature = %g is less than 0.001 ohm. Set to zero.\n",
pParam->B3SOIFDrds0);
pParam->B3SOIFDrds0 = 0.0;
}
if (pParam->B3SOIFDvsattemp < 1.0e3)
{ fprintf(fplog, "Warning: Vsat at current temperature = %g may be too small.\n", pParam->B3SOIFDvsattemp);
printf("Warning: Vsat at current temperature = %g may be too small.\n", pParam->B3SOIFDvsattemp);
}
if (pParam->B3SOIFDpdibl1 < 0.0)
{ fprintf(fplog, "Warning: Pdibl1 = %g is negative.\n",
pParam->B3SOIFDpdibl1);
printf("Warning: Pdibl1 = %g is negative.\n", pParam->B3SOIFDpdibl1);
}
if (pParam->B3SOIFDpdibl2 < 0.0)
{ fprintf(fplog, "Warning: Pdibl2 = %g is negative.\n",
pParam->B3SOIFDpdibl2);
printf("Warning: Pdibl2 = %g is negative.\n", pParam->B3SOIFDpdibl2);
}
/* Check overlap capacitance parameters */
if (model->B3SOIFDcgdo < 0.0)
{ fprintf(fplog, "Warning: cgdo = %g is negative. Set to zero.\n", model->B3SOIFDcgdo);
printf("Warning: cgdo = %g is negative. Set to zero.\n", model->B3SOIFDcgdo);
model->B3SOIFDcgdo = 0.0;
}
if (model->B3SOIFDcgso < 0.0)
{ fprintf(fplog, "Warning: cgso = %g is negative. Set to zero.\n", model->B3SOIFDcgso);
printf("Warning: cgso = %g is negative. Set to zero.\n", model->B3SOIFDcgso);
model->B3SOIFDcgso = 0.0;
}
if (model->B3SOIFDcgeo < 0.0)
{ fprintf(fplog, "Warning: cgeo = %g is negative. Set to zero.\n", model->B3SOIFDcgeo);
printf("Warning: cgeo = %g is negative. Set to zero.\n", model->B3SOIFDcgeo);
model->B3SOIFDcgeo = 0.0;
}
if (model->B3SOIFDntun < 0.0)
{ fprintf(fplog, "Warning: Ntun = %g is negative.\n",
model->B3SOIFDntun);
printf("Warning: Ntun = %g is negative.\n", model->B3SOIFDntun);
}
if (model->B3SOIFDndiode < 0.0)
{ fprintf(fplog, "Warning: Ndiode = %g is negative.\n",
model->B3SOIFDndiode);
printf("Warning: Ndiode = %g is negative.\n", model->B3SOIFDndiode);
}
if (model->B3SOIFDisbjt < 0.0)
{ fprintf(fplog, "Warning: Isbjt = %g is negative.\n",
model->B3SOIFDisbjt);
printf("Warning: Isbjt = %g is negative.\n", model->B3SOIFDisbjt);
}
if (model->B3SOIFDisdif < 0.0)
{ fprintf(fplog, "Warning: Isdif = %g is negative.\n",
model->B3SOIFDisdif);
printf("Warning: Isdif = %g is negative.\n", model->B3SOIFDisdif);
}
if (model->B3SOIFDisrec < 0.0)
{ fprintf(fplog, "Warning: Isrec = %g is negative.\n",
model->B3SOIFDisrec);
printf("Warning: Isrec = %g is negative.\n", model->B3SOIFDisrec);
}
if (model->B3SOIFDistun < 0.0)
{ fprintf(fplog, "Warning: Istun = %g is negative.\n",
model->B3SOIFDistun);
printf("Warning: Istun = %g is negative.\n", model->B3SOIFDistun);
}
if (model->B3SOIFDedl < 0.0)
{ fprintf(fplog, "Warning: Edl = %g is negative.\n",
model->B3SOIFDedl);
printf("Warning: Edl = %g is negative.\n", model->B3SOIFDedl);
}
if (model->B3SOIFDkbjt1 < 0.0)
{ fprintf(fplog, "Warning: Kbjt1 = %g is negative.\n",
model->B3SOIFDkbjt1);
printf("Warning: kbjt1 = %g is negative.\n", model->B3SOIFDkbjt1);
}
if (model->B3SOIFDtt < 0.0)
{ fprintf(fplog, "Warning: Tt = %g is negative.\n",
model->B3SOIFDtt);
printf("Warning: Tt = %g is negative.\n", model->B3SOIFDtt);
}
if (model->B3SOIFDcsdmin < 0.0)
{ fprintf(fplog, "Warning: Csdmin = %g is negative.\n",
model->B3SOIFDcsdmin);
printf("Warning: Csdmin = %g is negative.\n", model->B3SOIFDcsdmin);
}
if (model->B3SOIFDcsdesw < 0.0)
{ fprintf(fplog, "Warning: Csdesw = %g is negative.\n",
model->B3SOIFDcsdesw);
printf("Warning: Csdesw = %g is negative.\n", model->B3SOIFDcsdesw);
}
if ((model->B3SOIFDasd < 0.0) || (model->B3SOIFDmxc > 1.0))
{ fprintf(fplog, "Warning: Asd = %g should be within (0, 1).\n",
model->B3SOIFDasd);
printf("Warning: Asd = %g should be within (0, 1).\n", model->B3SOIFDasd);
}
if (model->B3SOIFDrth0 < 0.0)
{ fprintf(fplog, "Warning: Rth0 = %g is negative.\n",
model->B3SOIFDrth0);
printf("Warning: Rth0 = %g is negative.\n", model->B3SOIFDrth0);
}
if (model->B3SOIFDcth0 < 0.0)
{ fprintf(fplog, "Warning: Cth0 = %g is negative.\n",
model->B3SOIFDcth0);
printf("Warning: Cth0 = %g is negative.\n", model->B3SOIFDcth0);
}
if (model->B3SOIFDrbody < 0.0)
{ fprintf(fplog, "Warning: Rbody = %g is negative.\n",
model->B3SOIFDrbody);
printf("Warning: Rbody = %g is negative.\n", model->B3SOIFDrbody);
}
if (model->B3SOIFDrbsh < 0.0)
{ fprintf(fplog, "Warning: Rbsh = %g is negative.\n",
model->B3SOIFDrbsh);
printf("Warning: Rbsh = %g is negative.\n", model->B3SOIFDrbsh);
}
if (model->B3SOIFDxj > model->B3SOIFDtsi)
{ fprintf(fplog, "Warning: Xj = %g is thicker than Tsi = %g.\n",
model->B3SOIFDxj, model->B3SOIFDtsi);
printf("Warning: Xj = %g is thicker than Tsi = %g.\n",
model->B3SOIFDxj, model->B3SOIFDtsi);
}
if (model->B3SOIFDcapMod < 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->B3SOIFDcii > 2.0)
{ fprintf(fplog, "Warning: Cii = %g is larger than 2.0.\n", model->B3SOIFDcii);
printf("Warning: Cii = %g is larger than 2.0.\n", model->B3SOIFDcii);
}
if (model->B3SOIFDdii > 1.5)
{ fprintf(fplog, "Warning: Dii = %g is larger than 1.5.\n", model->B3SOIFDcii);
printf("Warning: Dii = %g is too larger than 1.5.\n", model->B3SOIFDcii);
}
}/* 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_fd/b3soifdcvtest.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: b3soifdcvtest.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "b3soifddef.h"
#include "trandefs.h"
#include "const.h"
#include "devdefs.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIFDconvTest(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
B3SOIFDmodel *model = (B3SOIFDmodel*)inModel;
B3SOIFDinstance *here;
double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds;
double cbd, cbhat, cbs, cd, cdhat, tol, vgd, vgdo, vgs;
/* loop through all the B3SOIFD device models */
for (; model != NULL; model = model->B3SOIFDnextModel)
{ /* loop through all the instances of the model */
for (here = model->B3SOIFDinstances; here != NULL ;
here=here->B3SOIFDnextInstance)
{ vbs = model->B3SOIFDtype
* (*(ckt->CKTrhsOld+here->B3SOIFDbNode)
- *(ckt->CKTrhsOld+here->B3SOIFDsNodePrime));
vgs = model->B3SOIFDtype
* (*(ckt->CKTrhsOld+here->B3SOIFDgNode)
- *(ckt->CKTrhsOld+here->B3SOIFDsNodePrime));
vds = model->B3SOIFDtype
* (*(ckt->CKTrhsOld+here->B3SOIFDdNodePrime)
- *(ckt->CKTrhsOld+here->B3SOIFDsNodePrime));
vbd = vbs - vds;
vgd = vgs - vds;
vgdo = *(ckt->CKTstate0 + here->B3SOIFDvgs)
- *(ckt->CKTstate0 + here->B3SOIFDvds);
delvbs = vbs - *(ckt->CKTstate0 + here->B3SOIFDvbs);
delvbd = vbd - *(ckt->CKTstate0 + here->B3SOIFDvbd);
delvgs = vgs - *(ckt->CKTstate0 + here->B3SOIFDvgs);
delvds = vds - *(ckt->CKTstate0 + here->B3SOIFDvds);
delvgd = vgd-vgdo;
cd = here->B3SOIFDcd;
if (here->B3SOIFDmode >= 0)
{ cdhat = cd - here->B3SOIFDgjdb * delvbd
+ here->B3SOIFDgmbs * delvbs + here->B3SOIFDgm * delvgs
+ here->B3SOIFDgds * delvds;
}
else
{ cdhat = cd - (here->B3SOIFDgjdb - here->B3SOIFDgmbs) * delvbd
- here->B3SOIFDgm * delvgd + here->B3SOIFDgds * delvds;
}
/*
* check convergence
*/
if ((here->B3SOIFDoff == 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->B3SOIFDcjs;
cbd = here->B3SOIFDcjd;
cbhat = cbs + cbd + here->B3SOIFDgjdb * delvbd
+ here->B3SOIFDgjsb * delvbs;
tol = ckt->CKTreltol * MAX(fabs(cbhat), fabs(cbs + cbd))
+ ckt->CKTabstol;
if (fabs(cbhat - (cbs + cbd)) > tol)
{ ckt->CKTnoncon++;
return(OK);
}
}
}
}
return(OK);
}

1990
src/spicelib/devices/bsim3soi_fd/b3soifddef.h Normal file
View File

File diff suppressed because it is too large Load Diff

41
src/spicelib/devices/bsim3soi_fd/b3soifddel.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: b3soifddel.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "b3soifddef.h"
#include "sperror.h"
#include "gendefs.h"
#include "suffix.h"
int
B3SOIFDdelete(inModel,name,inInst)
GENmodel *inModel;
IFuid name;
GENinstance **inInst;
{
B3SOIFDinstance **fast = (B3SOIFDinstance**)inInst;
B3SOIFDmodel *model = (B3SOIFDmodel*)inModel;
B3SOIFDinstance **prev = NULL;
B3SOIFDinstance *here;
for (; model ; model = model->B3SOIFDnextModel)
{ prev = &(model->B3SOIFDinstances);
for (here = *prev; here ; here = *prev)
{ if (here->B3SOIFDname == name || (fast && here==*fast))
{ *prev= here->B3SOIFDnextInstance;
FREE(here);
return(OK);
}
prev = &(here->B3SOIFDnextInstance);
}
}
return(E_NODEV);
}

39
src/spicelib/devices/bsim3soi_fd/b3soifddest.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: b3soifddest.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "b3soifddef.h"
#include "suffix.h"
void
B3SOIFDdestroy(inModel)
GENmodel **inModel;
{
B3SOIFDmodel **model = (B3SOIFDmodel**)inModel;
B3SOIFDinstance *here;
B3SOIFDinstance *prev = NULL;
B3SOIFDmodel *mod = *model;
B3SOIFDmodel *oldmod = NULL;
for (; mod ; mod = mod->B3SOIFDnextModel)
{ if(oldmod) FREE(oldmod);
oldmod = mod;
prev = (B3SOIFDinstance *)NULL;
for (here = mod->B3SOIFDinstances; here; here = here->B3SOIFDnextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
}
if(oldmod) FREE(oldmod);
*model = NULL;
return;
}

53
src/spicelib/devices/bsim3soi_fd/b3soifdext.h Normal file
View File

@ -0,0 +1,53 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung
File: b3soifdext.h
**********/
#ifdef __STDC__
extern int B3SOIFDacLoad(GENmodel *,CKTcircuit*);
extern int B3SOIFDask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*);
extern int B3SOIFDconvTest(GENmodel *,CKTcircuit*);
extern int B3SOIFDdelete(GENmodel*,IFuid,GENinstance**);
extern void B3SOIFDdestroy(GENmodel**);
extern int B3SOIFDgetic(GENmodel*,CKTcircuit*);
extern int B3SOIFDload(GENmodel*,CKTcircuit*);
extern int B3SOIFDmAsk(CKTcircuit*,GENmodel *,int, IFvalue*);
extern int B3SOIFDmDelete(GENmodel**,IFuid,GENmodel*);
extern int B3SOIFDmParam(int,IFvalue*,GENmodel*);
extern void B3SOIFDmosCap(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 B3SOIFDparam(int,IFvalue*,GENinstance*,IFvalue*);
extern int B3SOIFDpzLoad(GENmodel*,CKTcircuit*,SPcomplex*);
extern int B3SOIFDsetup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
extern int B3SOIFDtemp(GENmodel*,CKTcircuit*);
extern int B3SOIFDtrunc(GENmodel*,CKTcircuit*,double*);
extern int B3SOIFDnoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
extern int B3SOIFDunsetup(GENmodel*,CKTcircuit*);
#else /* stdc */
extern int B3SOIFDacLoad();
extern int B3SOIFDdelete();
extern void B3SOIFDdestroy();
extern int B3SOIFDgetic();
extern int B3SOIFDload();
extern int B3SOIFDmDelete();
extern int B3SOIFDask();
extern int B3SOIFDmAsk();
extern int B3SOIFDconvTest();
extern int B3SOIFDtemp();
extern int B3SOIFDmParam();
extern void B3SOIFDmosCap();
extern int B3SOIFDparam();
extern int B3SOIFDpzLoad();
extern int B3SOIFDsetup();
extern int B3SOIFDtrunc();
extern int B3SOIFDnoise();
extern int B3SOIFDunsetup();
#endif /* stdc */

51
src/spicelib/devices/bsim3soi_fd/b3soifdgetic.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: b3soifdgetic.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "b3soifddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIFDgetic(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
B3SOIFDmodel *model = (B3SOIFDmodel*)inModel;
B3SOIFDinstance *here;
for (; model ; model = model->B3SOIFDnextModel)
{ for (here = model->B3SOIFDinstances; here; here = here->B3SOIFDnextInstance)
{ if(!here->B3SOIFDicVBSGiven)
{ here->B3SOIFDicVBS = *(ckt->CKTrhs + here->B3SOIFDbNode)
- *(ckt->CKTrhs + here->B3SOIFDsNode);
}
if (!here->B3SOIFDicVDSGiven)
{ here->B3SOIFDicVDS = *(ckt->CKTrhs + here->B3SOIFDdNode)
- *(ckt->CKTrhs + here->B3SOIFDsNode);
}
if (!here->B3SOIFDicVGSGiven)
{ here->B3SOIFDicVGS = *(ckt->CKTrhs + here->B3SOIFDgNode)
- *(ckt->CKTrhs + here->B3SOIFDsNode);
}
if (!here->B3SOIFDicVESGiven)
{ here->B3SOIFDicVES = *(ckt->CKTrhs + here->B3SOIFDeNode)
- *(ckt->CKTrhs + here->B3SOIFDsNode);
}
if (!here->B3SOIFDicVPSGiven)
{ here->B3SOIFDicVPS = *(ckt->CKTrhs + here->B3SOIFDpNode)
- *(ckt->CKTrhs + here->B3SOIFDsNode);
}
}
}
return(OK);
}

65
src/spicelib/devices/bsim3soi_fd/b3soifdinit.c Normal file
View File

@ -0,0 +1,65 @@
#include <config.h>
#include <devdefs.h>
#include "b3soifditf.h"
#include "b3soifdext.h"
#include "b3soifdinit.h"
SPICEdev B3SOIFDinfo = {
{ "B3SOIFD",
"Berkeley SOI MOSFET (FD) model version 1.0",
&B3SOIFDnSize,
&B3SOIFDnSize,
B3SOIFDnames,
&B3SOIFDpTSize,
B3SOIFDpTable,
&B3SOIFDmPTSize,
B3SOIFDmPTable,
DEV_DEFAULT}
,
DEVparam: B3SOIFDparam,
DEVmodParam: B3SOIFDmParam,
DEVload: B3SOIFDload,
DEVsetup: B3SOIFDsetup,
DEVunsetup: B3SOIFDunsetup,
DEVpzSetup: B3SOIFDsetup,
DEVtemperature:B3SOIFDtemp,
DEVtrunc: B3SOIFDtrunc,
DEVfindBranch: NULL,
DEVacLoad: B3SOIFDacLoad,
DEVaccept: NULL,
DEVdestroy: B3SOIFDdestroy,
DEVmodDelete: B3SOIFDmDelete,
DEVdelete: B3SOIFDdelete,
DEVsetic: B3SOIFDgetic,
DEVask: B3SOIFDask,
DEVmodAsk: B3SOIFDmAsk,
DEVpzLoad: B3SOIFDpzLoad,
DEVconvTest: B3SOIFDconvTest,
DEVsenSetup: NULL,
DEVsenLoad: NULL,
DEVsenUpdate: NULL,
DEVsenAcLoad: NULL,
DEVsenPrint: NULL,
DEVsenTrunc: NULL,
DEVdisto: NULL,
DEVnoise: B3SOIFDnoise,
DEVinstSize: &B3SOIFDiSize,
DEVmodSize: &B3SOIFDmSize
};
SPICEdev *
get_b3soifd_info (void)
{
return &B3SOIFDinfo;
}

13
src/spicelib/devices/bsim3soi_fd/b3soifdinit.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef _B3SOIFDINIT_H
#define _B3SOIFDINIT_H
extern IFparm B3SOIFDpTable[];
extern IFparm B3SOIFDmPTable[];
extern char *B3SOIFDnames[];
extern int B3SOIFDpTSize;
extern int B3SOIFDmPTSize;
extern int B3SOIFDnSize;
extern int B3SOIFDiSize;
extern int B3SOIFDmSize;
#endif

14
src/spicelib/devices/bsim3soi_fd/b3soifditf.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: b3soifditf.h
**********/
#ifndef DEV_B3SOIFD
#define DEV_B3SOIFD
#include "b3soifdext.h"
SPICEdev *get_b3soifd_info (void);
#endif

3593
src/spicelib/devices/bsim3soi_fd/b3soifdld.c Normal file
View File

File diff suppressed because it is too large Load Diff

1207
src/spicelib/devices/bsim3soi_fd/b3soifdmask.c Normal file
View File

File diff suppressed because it is too large Load Diff

47
src/spicelib/devices/bsim3soi_fd/b3soifdmdel.c Normal file
View File

@ -0,0 +1,47 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soifdmdel.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "b3soifddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIFDmDelete(inModel,modname,kill)
GENmodel **inModel;
IFuid modname;
GENmodel *kill;
{
B3SOIFDmodel **model = (B3SOIFDmodel**)inModel;
B3SOIFDmodel *modfast = (B3SOIFDmodel*)kill;
B3SOIFDinstance *here;
B3SOIFDinstance *prev = NULL;
B3SOIFDmodel **oldmod;
oldmod = model;
for (; *model ; model = &((*model)->B3SOIFDnextModel))
{ if ((*model)->B3SOIFDmodName == modname ||
(modfast && *model == modfast))
goto delgot;
oldmod = model;
}
return(E_NOMOD);
delgot:
*oldmod = (*model)->B3SOIFDnextModel; /* cut deleted device out of list */
for (here = (*model)->B3SOIFDinstances; here; here = here->B3SOIFDnextInstance)
{ if(prev) FREE(prev);
prev = here;
}
if(prev) FREE(prev);
FREE(*model);
return(OK);
}

1625
src/spicelib/devices/bsim3soi_fd/b3soifdmpar.c Normal file
View File

File diff suppressed because it is too large Load Diff

392
src/spicelib/devices/bsim3soi_fd/b3soifdnoi.c Normal file
View File

@ -0,0 +1,392 @@
/**********
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: b3soifdnoi.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "b3soifddef.h"
#include "cktdefs.h"
#include "iferrmsg.h"
#include "noisedef.h"
#include "suffix.h"
#include "const.h" /* jwan */
/*
* B3SOIFDnoise (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->B3SOIFDnoiMod.
If model->B3SOIFDnoiMod = 1,
Channel thermal noise = SPICE2 model
Flicker noise = SPICE2 model
If model->B3SOIFDnoiMod = 2,
Channel thermal noise = B3SOIFD model
Flicker noise = B3SOIFD model
If model->B3SOIFDnoiMod = 3,
Channel thermal noise = SPICE2 model
Flicker noise = B3SOIFD model
If model->B3SOIFDnoiMod = 4,
Channel thermal noise = B3SOIFD model
Flicker noise = SPICE2 model
*/
extern void NevalSrc();
extern double Nintegrate();
double
B3SOIFDStrongInversionNoiseEval(vgs, vds, model, here, freq, temp)
double vgs, vds, freq, temp;
B3SOIFDmodel *model;
B3SOIFDinstance *here;
{
struct b3soifdSizeDependParam *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->B3SOIFDcd);
if (vds > here->B3SOIFDvdsat)
{ esat = 2.0 * pParam->B3SOIFDvsattemp / here->B3SOIFDueff;
T0 = ((((vds - here->B3SOIFDvdsat) / pParam->B3SOIFDlitl) + model->B3SOIFDem)
/ esat);
DelClm = pParam->B3SOIFDlitl * log (MAX(T0, N_MINLOG));
}
else
DelClm = 0.0;
EffFreq = pow(freq, model->B3SOIFDef);
T1 = CHARGE * CHARGE * 8.62e-5 * cd * temp * here->B3SOIFDueff;
T2 = 1.0e8 * EffFreq * model->B3SOIFDcox
* pParam->B3SOIFDleff * pParam->B3SOIFDleff;
Vgst = vgs - here->B3SOIFDvon;
N0 = model->B3SOIFDcox * Vgst / CHARGE;
if (N0 < 0.0)
N0 = 0.0;
Nl = model->B3SOIFDcox * (Vgst - MIN(vds, here->B3SOIFDvdsat)) / CHARGE;
if (Nl < 0.0)
Nl = 0.0;
T3 = model->B3SOIFDoxideTrapDensityA
* log(MAX(((N0 + 2.0e14) / (Nl + 2.0e14)), N_MINLOG));
T4 = model->B3SOIFDoxideTrapDensityB * (N0 - Nl);
T5 = model->B3SOIFDoxideTrapDensityC * 0.5 * (N0 * N0 - Nl * Nl);
T6 = 8.62e-5 * temp * cd * cd;
T7 = 1.0e8 * EffFreq * pParam->B3SOIFDleff
* pParam->B3SOIFDleff * pParam->B3SOIFDweff;
T8 = model->B3SOIFDoxideTrapDensityA + model->B3SOIFDoxideTrapDensityB * Nl
+ model->B3SOIFDoxideTrapDensityC * Nl * Nl;
T9 = (Nl + 2.0e14) * (Nl + 2.0e14);
Ssi = T1 / T2 * (T3 + T4 + T5) + T6 / T7 * DelClm * T8 / T9;
return Ssi;
}
int
B3SOIFDnoise (mode, operation, inModel, ckt, data, OnDens)
int mode, operation;
GENmodel *inModel;
CKTcircuit *ckt;
Ndata *data;
double *OnDens;
{
B3SOIFDmodel *model = (B3SOIFDmodel *)inModel;
B3SOIFDinstance *here;
struct b3soifdSizeDependParam *pParam;
char name[N_MXVLNTH];
double tempOnoise;
double tempInoise;
double noizDens[B3SOIFDNSRCS];
double lnNdens[B3SOIFDNSRCS];
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 *B3SOIFDnNames[B3SOIFDNSRCS] =
{ /* Note that we have to keep the order */
".rd", /* noise due to rd */
/* consistent with the index definitions */
".rs", /* noise due to rs */
/* in B3SOIFDdefs.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->B3SOIFDnextModel)
{ for (here = model->B3SOIFDinstances; here != NULL;
here = here->B3SOIFDnextInstance)
{ 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 < B3SOIFDNSRCS; i++)
{ (void) sprintf(name, "onoise.%s%s",
here->B3SOIFDname,
B3SOIFDnNames[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 < B3SOIFDNSRCS; i++)
{ (void) sprintf(name, "onoise_total.%s%s",
here->B3SOIFDname,
B3SOIFDnNames[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->B3SOIFDname,
B3SOIFDnNames[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[B3SOIFDRDNOIZ],
&lnNdens[B3SOIFDRDNOIZ], ckt, THERMNOISE,
here->B3SOIFDdNodePrime, here->B3SOIFDdNode,
here->B3SOIFDdrainConductance);
NevalSrc(&noizDens[B3SOIFDRSNOIZ],
&lnNdens[B3SOIFDRSNOIZ], ckt, THERMNOISE,
here->B3SOIFDsNodePrime, here->B3SOIFDsNode,
here->B3SOIFDsourceConductance);
switch( model->B3SOIFDnoiMod )
{ case 1:
case 3:
NevalSrc(&noizDens[B3SOIFDIDNOIZ],
&lnNdens[B3SOIFDIDNOIZ], ckt,
THERMNOISE, here->B3SOIFDdNodePrime,
here->B3SOIFDsNodePrime,
(2.0 / 3.0 * fabs(here->B3SOIFDgm
+ here->B3SOIFDgds
+ here->B3SOIFDgmbs)));
break;
case 2:
case 4:
NevalSrc(&noizDens[B3SOIFDIDNOIZ],
&lnNdens[B3SOIFDIDNOIZ], ckt,
THERMNOISE, here->B3SOIFDdNodePrime,
here->B3SOIFDsNodePrime,
(here->B3SOIFDueff
* fabs(here->B3SOIFDqinv
/ (pParam->B3SOIFDleff
* pParam->B3SOIFDleff))));
break;
}
NevalSrc(&noizDens[B3SOIFDFLNOIZ], (double*) NULL,
ckt, N_GAIN, here->B3SOIFDdNodePrime,
here->B3SOIFDsNodePrime, (double) 0.0);
switch( model->B3SOIFDnoiMod )
{ case 1:
case 4:
noizDens[B3SOIFDFLNOIZ] *= model->B3SOIFDkf
* exp(model->B3SOIFDaf
* log(MAX(fabs(here->B3SOIFDcd),
N_MINLOG)))
/ (pow(data->freq, model->B3SOIFDef)
* pParam->B3SOIFDleff
* pParam->B3SOIFDleff
* model->B3SOIFDcox);
break;
case 2:
case 3:
vgs = *(ckt->CKTstates[0] + here->B3SOIFDvgs);
vds = *(ckt->CKTstates[0] + here->B3SOIFDvds);
if (vds < 0.0)
{ vds = -vds;
vgs = vgs + vds;
}
if (vgs >= here->B3SOIFDvon + 0.1)
{ Ssi = B3SOIFDStrongInversionNoiseEval(vgs,
vds, model, here, data->freq,
ckt->CKTtemp);
noizDens[B3SOIFDFLNOIZ] *= Ssi;
}
else
{ pParam = here->pParam;
T10 = model->B3SOIFDoxideTrapDensityA
* 8.62e-5 * ckt->CKTtemp;
T11 = pParam->B3SOIFDweff
* pParam->B3SOIFDleff
* pow(data->freq, model->B3SOIFDef)
* 4.0e36;
Swi = T10 / T11 * here->B3SOIFDcd
* here->B3SOIFDcd;
Slimit = B3SOIFDStrongInversionNoiseEval(
here->B3SOIFDvon + 0.1, vds, model,
here, data->freq, ckt->CKTtemp);
T1 = Swi + Slimit;
if (T1 > 0.0)
noizDens[B3SOIFDFLNOIZ] *= (Slimit
* Swi) / T1;
else
noizDens[B3SOIFDFLNOIZ] *= 0.0;
}
break;
}
lnNdens[B3SOIFDFLNOIZ] =
log(MAX(noizDens[B3SOIFDFLNOIZ], N_MINLOG));
/* Low frequency excess noise due to FBE */
noizDens[B3SOIFDFBNOIZ] = 0.0;
noizDens[B3SOIFDTOTNOIZ] = noizDens[B3SOIFDRDNOIZ]
+ noizDens[B3SOIFDRSNOIZ]
+ noizDens[B3SOIFDIDNOIZ]
+ noizDens[B3SOIFDFLNOIZ]
+ noizDens[B3SOIFDFBNOIZ];
lnNdens[B3SOIFDTOTNOIZ] =
log(MAX(noizDens[B3SOIFDTOTNOIZ], N_MINLOG));
*OnDens += noizDens[B3SOIFDTOTNOIZ];
if (data->delFreq == 0.0)
{ /* if we haven't done any previous
integration, we need to initialize our
"history" variables.
*/
for (i = 0; i < B3SOIFDNSRCS; i++)
{ here->B3SOIFDnVar[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 < B3SOIFDNSRCS; i++)
{ here->B3SOIFDnVar[OUTNOIZ][i] = 0.0;
here->B3SOIFDnVar[INNOIZ][i] = 0.0;
}
}
}
else
{ /* data->delFreq != 0.0,
we have to integrate.
*/
for (i = 0; i < B3SOIFDNSRCS; i++)
{ if (i != B3SOIFDTOTNOIZ)
{ tempOnoise = Nintegrate(noizDens[i],
lnNdens[i],
here->B3SOIFDnVar[LNLSTDENS][i],
data);
tempInoise = Nintegrate(noizDens[i]
* data->GainSqInv, lnNdens[i]
+ data->lnGainInv,
here->B3SOIFDnVar[LNLSTDENS][i]
+ data->lnGainInv, data);
here->B3SOIFDnVar[LNLSTDENS][i] =
lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if (((NOISEAN*)
ckt->CKTcurJob)->NStpsSm != 0)
{ here->B3SOIFDnVar[OUTNOIZ][i]
+= tempOnoise;
here->B3SOIFDnVar[OUTNOIZ][B3SOIFDTOTNOIZ]
+= tempOnoise;
here->B3SOIFDnVar[INNOIZ][i]
+= tempInoise;
here->B3SOIFDnVar[INNOIZ][B3SOIFDTOTNOIZ]
+= tempInoise;
}
}
}
}
if (data->prtSummary)
{ for (i = 0; i < B3SOIFDNSRCS; 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 < B3SOIFDNSRCS; i++)
{ data->outpVector[data->outNumber++]
= here->B3SOIFDnVar[OUTNOIZ][i];
data->outpVector[data->outNumber++]
= here->B3SOIFDnVar[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_fd/b3soifdpar.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: b3soifdpar.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "ifsim.h"
#include "b3soifddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIFDparam(param,value,inst,select)
int param;
IFvalue *value;
GENinstance *inst;
IFvalue *select;
{
B3SOIFDinstance *here = (B3SOIFDinstance*)inst;
switch(param)
{ case B3SOIFD_W:
here->B3SOIFDw = value->rValue;
here->B3SOIFDwGiven = TRUE;
break;
case B3SOIFD_L:
here->B3SOIFDl = value->rValue;
here->B3SOIFDlGiven = TRUE;
break;
case B3SOIFD_AS:
here->B3SOIFDsourceArea = value->rValue;
here->B3SOIFDsourceAreaGiven = TRUE;
break;
case B3SOIFD_AD:
here->B3SOIFDdrainArea = value->rValue;
here->B3SOIFDdrainAreaGiven = TRUE;
break;
case B3SOIFD_PS:
here->B3SOIFDsourcePerimeter = value->rValue;
here->B3SOIFDsourcePerimeterGiven = TRUE;
break;
case B3SOIFD_PD:
here->B3SOIFDdrainPerimeter = value->rValue;
here->B3SOIFDdrainPerimeterGiven = TRUE;
break;
case B3SOIFD_NRS:
here->B3SOIFDsourceSquares = value->rValue;
here->B3SOIFDsourceSquaresGiven = TRUE;
break;
case B3SOIFD_NRD:
here->B3SOIFDdrainSquares = value->rValue;
here->B3SOIFDdrainSquaresGiven = TRUE;
break;
case B3SOIFD_OFF:
here->B3SOIFDoff = value->iValue;
break;
case B3SOIFD_IC_VBS:
here->B3SOIFDicVBS = value->rValue;
here->B3SOIFDicVBSGiven = TRUE;
break;
case B3SOIFD_IC_VDS:
here->B3SOIFDicVDS = value->rValue;
here->B3SOIFDicVDSGiven = TRUE;
break;
case B3SOIFD_IC_VGS:
here->B3SOIFDicVGS = value->rValue;
here->B3SOIFDicVGSGiven = TRUE;
break;
case B3SOIFD_IC_VES:
here->B3SOIFDicVES = value->rValue;
here->B3SOIFDicVESGiven = TRUE;
break;
case B3SOIFD_IC_VPS:
here->B3SOIFDicVPS = value->rValue;
here->B3SOIFDicVPSGiven = TRUE;
break;
case B3SOIFD_BJTOFF:
here->B3SOIFDbjtoff = value->iValue;
here->B3SOIFDbjtoffGiven= TRUE;
break;
case B3SOIFD_DEBUG:
here->B3SOIFDdebugMod = value->iValue;
here->B3SOIFDdebugModGiven= TRUE;
break;
case B3SOIFD_RTH0:
here->B3SOIFDrth0= value->rValue;
here->B3SOIFDrth0Given = TRUE;
break;
case B3SOIFD_CTH0:
here->B3SOIFDcth0= value->rValue;
here->B3SOIFDcth0Given = TRUE;
break;
case B3SOIFD_NRB:
here->B3SOIFDbodySquares = value->rValue;
here->B3SOIFDbodySquaresGiven = TRUE;
break;
case B3SOIFD_IC:
switch(value->v.numValue){
case 5:
here->B3SOIFDicVPS = *(value->v.vec.rVec+4);
here->B3SOIFDicVPSGiven = TRUE;
case 4:
here->B3SOIFDicVES = *(value->v.vec.rVec+3);
here->B3SOIFDicVESGiven = TRUE;
case 3:
here->B3SOIFDicVBS = *(value->v.vec.rVec+2);
here->B3SOIFDicVBSGiven = TRUE;
case 2:
here->B3SOIFDicVGS = *(value->v.vec.rVec+1);
here->B3SOIFDicVGSGiven = TRUE;
case 1:
here->B3SOIFDicVDS = *(value->v.vec.rVec);
here->B3SOIFDicVDSGiven = TRUE;
break;
default:
return(E_BADPARM);
}
break;
default:
return(E_BADPARM);
}
return(OK);
}

152
src/spicelib/devices/bsim3soi_fd/b3soifdpzld.c Normal file
View File

@ -0,0 +1,152 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soifdpzld.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "complex.h"
#include "sperror.h"
#include "b3soifddef.h"
#include "suffix.h"
int
B3SOIFDpzLoad(inModel,ckt,s)
GENmodel *inModel;
CKTcircuit *ckt;
SPcomplex *s;
{
B3SOIFDmodel *model = (B3SOIFDmodel*)inModel;
B3SOIFDinstance *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->B3SOIFDnextModel)
{ for (here = model->B3SOIFDinstances; here!= NULL;
here = here->B3SOIFDnextInstance)
{
if (here->B3SOIFDmode >= 0)
{ Gm = here->B3SOIFDgm;
Gmbs = here->B3SOIFDgmbs;
FwdSum = Gm + Gmbs;
RevSum = 0.0;
cggb = here->B3SOIFDcggb;
cgsb = here->B3SOIFDcgsb;
cgdb = here->B3SOIFDcgdb;
cbgb = here->B3SOIFDcbgb;
cbsb = here->B3SOIFDcbsb;
cbdb = here->B3SOIFDcbdb;
cdgb = here->B3SOIFDcdgb;
cdsb = here->B3SOIFDcdsb;
cddb = here->B3SOIFDcddb;
}
else
{ Gm = -here->B3SOIFDgm;
Gmbs = -here->B3SOIFDgmbs;
FwdSum = 0.0;
RevSum = -Gm - Gmbs;
cggb = here->B3SOIFDcggb;
cgsb = here->B3SOIFDcgdb;
cgdb = here->B3SOIFDcgsb;
cbgb = here->B3SOIFDcbgb;
cbsb = here->B3SOIFDcbdb;
cbdb = here->B3SOIFDcbsb;
cdgb = -(here->B3SOIFDcdgb + cggb + cbgb);
cdsb = -(here->B3SOIFDcddb + cgsb + cbsb);
cddb = -(here->B3SOIFDcdsb + cgdb + cbdb);
}
gdpr=here->B3SOIFDdrainConductance;
gspr=here->B3SOIFDsourceConductance;
gds= here->B3SOIFDgds;
gbd= here->B3SOIFDgjdb;
gbs= here->B3SOIFDgjsb;
#ifdef BULKCODE
capbd= here->B3SOIFDcapbd;
capbs= here->B3SOIFDcapbs;
#endif
GSoverlapCap = here->B3SOIFDcgso;
GDoverlapCap = here->B3SOIFDcgdo;
#ifdef BULKCODE
GBoverlapCap = here->pParam->B3SOIFDcgbo;
#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->B3SOIFDGgPtr ) += xcggb * s->real;
*(here->B3SOIFDGgPtr +1) += xcggb * s->imag;
*(here->B3SOIFDBbPtr ) += (-xcbgb-xcbdb-xcbsb) * s->real;
*(here->B3SOIFDBbPtr +1) += (-xcbgb-xcbdb-xcbsb) * s->imag;
*(here->B3SOIFDDPdpPtr ) += xcddb * s->real;
*(here->B3SOIFDDPdpPtr +1) += xcddb * s->imag;
*(here->B3SOIFDSPspPtr ) += xcssb * s->real;
*(here->B3SOIFDSPspPtr +1) += xcssb * s->imag;
*(here->B3SOIFDGbPtr ) += (-xcggb-xcgdb-xcgsb) * s->real;
*(here->B3SOIFDGbPtr +1) += (-xcggb-xcgdb-xcgsb) * s->imag;
*(here->B3SOIFDGdpPtr ) += xcgdb * s->real;
*(here->B3SOIFDGdpPtr +1) += xcgdb * s->imag;
*(here->B3SOIFDGspPtr ) += xcgsb * s->real;
*(here->B3SOIFDGspPtr +1) += xcgsb * s->imag;
*(here->B3SOIFDBgPtr ) += xcbgb * s->real;
*(here->B3SOIFDBgPtr +1) += xcbgb * s->imag;
*(here->B3SOIFDBdpPtr ) += xcbdb * s->real;
*(here->B3SOIFDBdpPtr +1) += xcbdb * s->imag;
*(here->B3SOIFDBspPtr ) += xcbsb * s->real;
*(here->B3SOIFDBspPtr +1) += xcbsb * s->imag;
*(here->B3SOIFDDPgPtr ) += xcdgb * s->real;
*(here->B3SOIFDDPgPtr +1) += xcdgb * s->imag;
*(here->B3SOIFDDPbPtr ) += (-xcdgb-xcddb-xcdsb) * s->real;
*(here->B3SOIFDDPbPtr +1) += (-xcdgb-xcddb-xcdsb) * s->imag;
*(here->B3SOIFDDPspPtr ) += xcdsb * s->real;
*(here->B3SOIFDDPspPtr +1) += xcdsb * s->imag;
*(here->B3SOIFDSPgPtr ) += xcsgb * s->real;
*(here->B3SOIFDSPgPtr +1) += xcsgb * s->imag;
*(here->B3SOIFDSPbPtr ) += (-xcsgb-xcsdb-xcssb) * s->real;
*(here->B3SOIFDSPbPtr +1) += (-xcsgb-xcsdb-xcssb) * s->imag;
*(here->B3SOIFDSPdpPtr ) += xcsdb * s->real;
*(here->B3SOIFDSPdpPtr +1) += xcsdb * s->imag;
*(here->B3SOIFDDdPtr) += gdpr;
*(here->B3SOIFDSsPtr) += gspr;
*(here->B3SOIFDBbPtr) += gbd+gbs;
*(here->B3SOIFDDPdpPtr) += gdpr+gds+gbd+RevSum;
*(here->B3SOIFDSPspPtr) += gspr+gds+gbs+FwdSum;
*(here->B3SOIFDDdpPtr) -= gdpr;
*(here->B3SOIFDSspPtr) -= gspr;
*(here->B3SOIFDBdpPtr) -= gbd;
*(here->B3SOIFDBspPtr) -= gbs;
*(here->B3SOIFDDPdPtr) -= gdpr;
*(here->B3SOIFDDPgPtr) += Gm;
*(here->B3SOIFDDPbPtr) -= gbd - Gmbs;
*(here->B3SOIFDDPspPtr) -= gds + FwdSum;
*(here->B3SOIFDSPgPtr) -= Gm;
*(here->B3SOIFDSPsPtr) -= gspr;
*(here->B3SOIFDSPbPtr) -= gbs + Gmbs;
*(here->B3SOIFDSPdpPtr) -= gds + RevSum;
}
}
return(OK);
}

1341
src/spicelib/devices/bsim3soi_fd/b3soifdset.c Normal file
View File

File diff suppressed because it is too large Load Diff

815
src/spicelib/devices/bsim3soi_fd/b3soifdtemp.c Normal file
View File

@ -0,0 +1,815 @@
/**********
Copyright 1999 Regents of the University of California. All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soifdtemp.c 98/5/01
Modified by Pin Su, Wei Jin 99/9/27
**********/
/* Lmin, Lmax, Wmin, Wmax */
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "smpdefs.h"
#include "cktdefs.h"
#include "b3soifddef.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
B3SOIFDtemp(inModel,ckt)
GENmodel *inModel;
CKTcircuit *ckt;
{
B3SOIFDmodel *model = (B3SOIFDmodel*) inModel;
B3SOIFDinstance *here;
struct b3soifdSizeDependParam *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 B3SOIFD device models */
for (; model != NULL; model = model->B3SOIFDnextModel)
{ Temp = ckt->CKTtemp;
if (model->B3SOIFDGatesidewallJctPotential < 0.1)
model->B3SOIFDGatesidewallJctPotential = 0.1;
model->pSizeDependParamKnot = NULL;
pLastKnot = NULL;
Tnom = model->B3SOIFDtnom;
TRatio = Temp / Tnom;
model->B3SOIFDvcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14));
model->B3SOIFDfactor1 = sqrt(EPSSI / EPSOX * model->B3SOIFDtox);
Vtm0 = KboQ * Tnom;
Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0);
model->B3SOIFDeg0 = Eg0;
model->B3SOIFDvtm = 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->B3SOIFDvtm));
/* loop through all the instances of the model */
/* MCJ: Length and Width not initialized */
for (here = model->B3SOIFDinstances; here != NULL;
here = here->B3SOIFDnextInstance)
{
here->B3SOIFDrbodyext = here->B3SOIFDbodySquares *
model->B3SOIFDrbsh;
pSizeDependParamKnot = model->pSizeDependParamKnot;
Size_Not_Found = 1;
while ((pSizeDependParamKnot != NULL) && Size_Not_Found)
{ if ((here->B3SOIFDl == pSizeDependParamKnot->Length)
&& (here->B3SOIFDw == pSizeDependParamKnot->Width)
&& (here->B3SOIFDrth0 == pSizeDependParamKnot->Rth0)
&& (here->B3SOIFDcth0 == pSizeDependParamKnot->Cth0))
{ Size_Not_Found = 0;
here->pParam = pSizeDependParamKnot;
}
else
{ pLastKnot = pSizeDependParamKnot;
pSizeDependParamKnot = pSizeDependParamKnot->pNext;
}
}
if (Size_Not_Found)
{ pParam = (struct b3soifdSizeDependParam *)malloc(
sizeof(struct b3soifdSizeDependParam));
if (pLastKnot == NULL)
model->pSizeDependParamKnot = pParam;
else
pLastKnot->pNext = pParam;
pParam->pNext = NULL;
here->pParam = pParam;
Ldrn = here->B3SOIFDl;
Wdrn = here->B3SOIFDw;
pParam->Length = Ldrn;
pParam->Width = Wdrn;
pParam->Rth0 = here->B3SOIFDrth0;
pParam->Cth0 = here->B3SOIFDcth0;
T0 = pow(Ldrn, model->B3SOIFDLln);
T1 = pow(Wdrn, model->B3SOIFDLwn);
tmp1 = model->B3SOIFDLl / T0 + model->B3SOIFDLw / T1
+ model->B3SOIFDLwl / (T0 * T1);
pParam->B3SOIFDdl = model->B3SOIFDLint + tmp1;
pParam->B3SOIFDdlc = model->B3SOIFDdlc + tmp1;
T2 = pow(Ldrn, model->B3SOIFDWln);
T3 = pow(Wdrn, model->B3SOIFDWwn);
tmp2 = model->B3SOIFDWl / T2 + model->B3SOIFDWw / T3
+ model->B3SOIFDWwl / (T2 * T3);
pParam->B3SOIFDdw = model->B3SOIFDWint + tmp2;
pParam->B3SOIFDdwc = model->B3SOIFDdwc + tmp2;
pParam->B3SOIFDleff = here->B3SOIFDl - 2.0 * pParam->B3SOIFDdl;
if (pParam->B3SOIFDleff <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->B3SOIFDmodName;
namarray[1] = here->B3SOIFDname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"B3SOIFD: mosfet %s, model %s: Effective channel length <= 0",
namarray);
return(E_BADPARM);
}
pParam->B3SOIFDweff = here->B3SOIFDw - 2.0 * pParam->B3SOIFDdw;
if (pParam->B3SOIFDweff <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->B3SOIFDmodName;
namarray[1] = here->B3SOIFDname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"B3SOIFD: mosfet %s, model %s: Effective channel width <= 0",
namarray);
return(E_BADPARM);
}
pParam->B3SOIFDleffCV = here->B3SOIFDl - 2.0 * pParam->B3SOIFDdlc;
if (pParam->B3SOIFDleffCV <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->B3SOIFDmodName;
namarray[1] = here->B3SOIFDname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"B3SOIFD: mosfet %s, model %s: Effective channel length for C-V <= 0",
namarray);
return(E_BADPARM);
}
pParam->B3SOIFDweffCV = here->B3SOIFDw - 2.0 * pParam->B3SOIFDdwc;
if (pParam->B3SOIFDweffCV <= 0.0)
{ IFuid namarray[2];
namarray[0] = model->B3SOIFDmodName;
namarray[1] = here->B3SOIFDname;
(*(SPfrontEnd->IFerror))(ERR_FATAL,
"B3SOIFD: mosfet %s, model %s: Effective channel width for C-V <= 0",
namarray);
return(E_BADPARM);
}
/* Not binned - START */
pParam->B3SOIFDat = model->B3SOIFDat;
pParam->B3SOIFDgamma1 = model->B3SOIFDgamma1;
pParam->B3SOIFDgamma2 = model->B3SOIFDgamma2;
pParam->B3SOIFDvbx = model->B3SOIFDvbx;
pParam->B3SOIFDvbm = model->B3SOIFDvbm;
pParam->B3SOIFDxt = model->B3SOIFDxt;
pParam->B3SOIFDkt1 = model->B3SOIFDkt1;
pParam->B3SOIFDkt1l = model->B3SOIFDkt1l;
pParam->B3SOIFDkt2 = model->B3SOIFDkt2;
pParam->B3SOIFDua1 = model->B3SOIFDua1;
pParam->B3SOIFDub1 = model->B3SOIFDub1;
pParam->B3SOIFDuc1 = model->B3SOIFDuc1;
pParam->B3SOIFDute = model->B3SOIFDute;
pParam->B3SOIFDprt = model->B3SOIFDprt;
/* Not binned - END */
/* CV model */
pParam->B3SOIFDcgsl = model->B3SOIFDcgsl;
pParam->B3SOIFDcgdl = model->B3SOIFDcgdl;
pParam->B3SOIFDckappa = model->B3SOIFDckappa;
pParam->B3SOIFDcf = model->B3SOIFDcf;
pParam->B3SOIFDclc = model->B3SOIFDclc;
pParam->B3SOIFDcle = model->B3SOIFDcle;
pParam->B3SOIFDabulkCVfactor = pow(1.0+(pParam->B3SOIFDclc
/ pParam->B3SOIFDleff),
pParam->B3SOIFDcle);
/* Added for binning - START */
if (model->B3SOIFDbinUnit == 1)
{ Inv_L = 1.0e-6 / pParam->B3SOIFDleff;
Inv_W = 1.0e-6 / pParam->B3SOIFDweff;
Inv_LW = 1.0e-12 / (pParam->B3SOIFDleff
* pParam->B3SOIFDweff);
}
else
{ Inv_L = 1.0 / pParam->B3SOIFDleff;
Inv_W = 1.0 / pParam->B3SOIFDweff;
Inv_LW = 1.0 / (pParam->B3SOIFDleff
* pParam->B3SOIFDweff);
}
pParam->B3SOIFDnpeak = model->B3SOIFDnpeak
+ model->B3SOIFDlnpeak * Inv_L
+ model->B3SOIFDwnpeak * Inv_W
+ model->B3SOIFDpnpeak * Inv_LW;
pParam->B3SOIFDnsub = model->B3SOIFDnsub
+ model->B3SOIFDlnsub * Inv_L
+ model->B3SOIFDwnsub * Inv_W
+ model->B3SOIFDpnsub * Inv_LW;
pParam->B3SOIFDngate = model->B3SOIFDngate
+ model->B3SOIFDlngate * Inv_L
+ model->B3SOIFDwngate * Inv_W
+ model->B3SOIFDpngate * Inv_LW;
pParam->B3SOIFDvth0 = model->B3SOIFDvth0
+ model->B3SOIFDlvth0 * Inv_L
+ model->B3SOIFDwvth0 * Inv_W
+ model->B3SOIFDpvth0 * Inv_LW;
pParam->B3SOIFDk1 = model->B3SOIFDk1
+ model->B3SOIFDlk1 * Inv_L
+ model->B3SOIFDwk1 * Inv_W
+ model->B3SOIFDpk1 * Inv_LW;
pParam->B3SOIFDk2 = model->B3SOIFDk2
+ model->B3SOIFDlk2 * Inv_L
+ model->B3SOIFDwk2 * Inv_W
+ model->B3SOIFDpk2 * Inv_LW;
pParam->B3SOIFDk3 = model->B3SOIFDk3
+ model->B3SOIFDlk3 * Inv_L
+ model->B3SOIFDwk3 * Inv_W
+ model->B3SOIFDpk3 * Inv_LW;
pParam->B3SOIFDk3b = model->B3SOIFDk3b
+ model->B3SOIFDlk3b * Inv_L
+ model->B3SOIFDwk3b * Inv_W
+ model->B3SOIFDpk3b * Inv_LW;
pParam->B3SOIFDvbsa = model->B3SOIFDvbsa
+ model->B3SOIFDlvbsa * Inv_L
+ model->B3SOIFDwvbsa * Inv_W
+ model->B3SOIFDpvbsa * Inv_LW;
pParam->B3SOIFDdelp = model->B3SOIFDdelp
+ model->B3SOIFDldelp * Inv_L
+ model->B3SOIFDwdelp * Inv_W
+ model->B3SOIFDpdelp * Inv_LW;
pParam->B3SOIFDkb1 = model->B3SOIFDkb1
+ model->B3SOIFDlkb1 * Inv_L
+ model->B3SOIFDwkb1 * Inv_W
+ model->B3SOIFDpkb1 * Inv_LW;
pParam->B3SOIFDkb3 = model->B3SOIFDkb3
+ model->B3SOIFDlkb3 * Inv_L
+ model->B3SOIFDwkb3 * Inv_W
+ model->B3SOIFDpkb3 * Inv_LW;
pParam->B3SOIFDdvbd0 = model->B3SOIFDdvbd0
+ model->B3SOIFDldvbd0 * Inv_L
+ model->B3SOIFDwdvbd0 * Inv_W
+ model->B3SOIFDpdvbd0 * Inv_LW;
pParam->B3SOIFDdvbd1 = model->B3SOIFDdvbd1
+ model->B3SOIFDldvbd1 * Inv_L
+ model->B3SOIFDwdvbd1 * Inv_W
+ model->B3SOIFDpdvbd1 * Inv_LW;
pParam->B3SOIFDw0 = model->B3SOIFDw0
+ model->B3SOIFDlw0 * Inv_L
+ model->B3SOIFDww0 * Inv_W
+ model->B3SOIFDpw0 * Inv_LW;
pParam->B3SOIFDnlx = model->B3SOIFDnlx
+ model->B3SOIFDlnlx * Inv_L
+ model->B3SOIFDwnlx * Inv_W
+ model->B3SOIFDpnlx * Inv_LW;
pParam->B3SOIFDdvt0 = model->B3SOIFDdvt0
+ model->B3SOIFDldvt0 * Inv_L
+ model->B3SOIFDwdvt0 * Inv_W
+ model->B3SOIFDpdvt0 * Inv_LW;
pParam->B3SOIFDdvt1 = model->B3SOIFDdvt1
+ model->B3SOIFDldvt1 * Inv_L
+ model->B3SOIFDwdvt1 * Inv_W
+ model->B3SOIFDpdvt1 * Inv_LW;
pParam->B3SOIFDdvt2 = model->B3SOIFDdvt2
+ model->B3SOIFDldvt2 * Inv_L
+ model->B3SOIFDwdvt2 * Inv_W
+ model->B3SOIFDpdvt2 * Inv_LW;
pParam->B3SOIFDdvt0w = model->B3SOIFDdvt0w
+ model->B3SOIFDldvt0w * Inv_L
+ model->B3SOIFDwdvt0w * Inv_W
+ model->B3SOIFDpdvt0w * Inv_LW;
pParam->B3SOIFDdvt1w = model->B3SOIFDdvt1w
+ model->B3SOIFDldvt1w * Inv_L
+ model->B3SOIFDwdvt1w * Inv_W
+ model->B3SOIFDpdvt1w * Inv_LW;
pParam->B3SOIFDdvt2w = model->B3SOIFDdvt2w
+ model->B3SOIFDldvt2w * Inv_L
+ model->B3SOIFDwdvt2w * Inv_W
+ model->B3SOIFDpdvt2w * Inv_LW;
pParam->B3SOIFDu0 = model->B3SOIFDu0
+ model->B3SOIFDlu0 * Inv_L
+ model->B3SOIFDwu0 * Inv_W
+ model->B3SOIFDpu0 * Inv_LW;
pParam->B3SOIFDua = model->B3SOIFDua
+ model->B3SOIFDlua * Inv_L
+ model->B3SOIFDwua * Inv_W
+ model->B3SOIFDpua * Inv_LW;
pParam->B3SOIFDub = model->B3SOIFDub
+ model->B3SOIFDlub * Inv_L
+ model->B3SOIFDwub * Inv_W
+ model->B3SOIFDpub * Inv_LW;
pParam->B3SOIFDuc = model->B3SOIFDuc
+ model->B3SOIFDluc * Inv_L
+ model->B3SOIFDwuc * Inv_W
+ model->B3SOIFDpuc * Inv_LW;
pParam->B3SOIFDvsat = model->B3SOIFDvsat
+ model->B3SOIFDlvsat * Inv_L
+ model->B3SOIFDwvsat * Inv_W
+ model->B3SOIFDpvsat * Inv_LW;
pParam->B3SOIFDa0 = model->B3SOIFDa0
+ model->B3SOIFDla0 * Inv_L
+ model->B3SOIFDwa0 * Inv_W
+ model->B3SOIFDpa0 * Inv_LW;
pParam->B3SOIFDags = model->B3SOIFDags
+ model->B3SOIFDlags * Inv_L
+ model->B3SOIFDwags * Inv_W
+ model->B3SOIFDpags * Inv_LW;
pParam->B3SOIFDb0 = model->B3SOIFDb0
+ model->B3SOIFDlb0 * Inv_L
+ model->B3SOIFDwb0 * Inv_W
+ model->B3SOIFDpb0 * Inv_LW;
pParam->B3SOIFDb1 = model->B3SOIFDb1
+ model->B3SOIFDlb1 * Inv_L
+ model->B3SOIFDwb1 * Inv_W
+ model->B3SOIFDpb1 * Inv_LW;
pParam->B3SOIFDketa = model->B3SOIFDketa
+ model->B3SOIFDlketa * Inv_L
+ model->B3SOIFDwketa * Inv_W
+ model->B3SOIFDpketa * Inv_LW;
pParam->B3SOIFDabp = model->B3SOIFDabp
+ model->B3SOIFDlabp * Inv_L
+ model->B3SOIFDwabp * Inv_W
+ model->B3SOIFDpabp * Inv_LW;
pParam->B3SOIFDmxc = model->B3SOIFDmxc
+ model->B3SOIFDlmxc * Inv_L
+ model->B3SOIFDwmxc * Inv_W
+ model->B3SOIFDpmxc * Inv_LW;
pParam->B3SOIFDadice0 = model->B3SOIFDadice0
+ model->B3SOIFDladice0 * Inv_L
+ model->B3SOIFDwadice0 * Inv_W
+ model->B3SOIFDpadice0 * Inv_LW;
pParam->B3SOIFDa1 = model->B3SOIFDa1
+ model->B3SOIFDla1 * Inv_L
+ model->B3SOIFDwa1 * Inv_W
+ model->B3SOIFDpa1 * Inv_LW;
pParam->B3SOIFDa2 = model->B3SOIFDa2
+ model->B3SOIFDla2 * Inv_L
+ model->B3SOIFDwa2 * Inv_W
+ model->B3SOIFDpa2 * Inv_LW;
pParam->B3SOIFDrdsw = model->B3SOIFDrdsw
+ model->B3SOIFDlrdsw * Inv_L
+ model->B3SOIFDwrdsw * Inv_W
+ model->B3SOIFDprdsw * Inv_LW;
pParam->B3SOIFDprwb = model->B3SOIFDprwb
+ model->B3SOIFDlprwb * Inv_L
+ model->B3SOIFDwprwb * Inv_W
+ model->B3SOIFDpprwb * Inv_LW;
pParam->B3SOIFDprwg = model->B3SOIFDprwg
+ model->B3SOIFDlprwg * Inv_L
+ model->B3SOIFDwprwg * Inv_W
+ model->B3SOIFDpprwg * Inv_LW;
pParam->B3SOIFDwr = model->B3SOIFDwr
+ model->B3SOIFDlwr * Inv_L
+ model->B3SOIFDwwr * Inv_W
+ model->B3SOIFDpwr * Inv_LW;
pParam->B3SOIFDnfactor = model->B3SOIFDnfactor
+ model->B3SOIFDlnfactor * Inv_L
+ model->B3SOIFDwnfactor * Inv_W
+ model->B3SOIFDpnfactor * Inv_LW;
pParam->B3SOIFDdwg = model->B3SOIFDdwg
+ model->B3SOIFDldwg * Inv_L
+ model->B3SOIFDwdwg * Inv_W
+ model->B3SOIFDpdwg * Inv_LW;
pParam->B3SOIFDdwb = model->B3SOIFDdwb
+ model->B3SOIFDldwb * Inv_L
+ model->B3SOIFDwdwb * Inv_W
+ model->B3SOIFDpdwb * Inv_LW;
pParam->B3SOIFDvoff = model->B3SOIFDvoff
+ model->B3SOIFDlvoff * Inv_L
+ model->B3SOIFDwvoff * Inv_W
+ model->B3SOIFDpvoff * Inv_LW;
pParam->B3SOIFDeta0 = model->B3SOIFDeta0
+ model->B3SOIFDleta0 * Inv_L
+ model->B3SOIFDweta0 * Inv_W
+ model->B3SOIFDpeta0 * Inv_LW;
pParam->B3SOIFDetab = model->B3SOIFDetab
+ model->B3SOIFDletab * Inv_L
+ model->B3SOIFDwetab * Inv_W
+ model->B3SOIFDpetab * Inv_LW;
pParam->B3SOIFDdsub = model->B3SOIFDdsub
+ model->B3SOIFDldsub * Inv_L
+ model->B3SOIFDwdsub * Inv_W
+ model->B3SOIFDpdsub * Inv_LW;
pParam->B3SOIFDcit = model->B3SOIFDcit
+ model->B3SOIFDlcit * Inv_L
+ model->B3SOIFDwcit * Inv_W
+ model->B3SOIFDpcit * Inv_LW;
pParam->B3SOIFDcdsc = model->B3SOIFDcdsc
+ model->B3SOIFDlcdsc * Inv_L
+ model->B3SOIFDwcdsc * Inv_W
+ model->B3SOIFDpcdsc * Inv_LW;
pParam->B3SOIFDcdscb = model->B3SOIFDcdscb
+ model->B3SOIFDlcdscb * Inv_L
+ model->B3SOIFDwcdscb * Inv_W
+ model->B3SOIFDpcdscb * Inv_LW;
pParam->B3SOIFDcdscd = model->B3SOIFDcdscd
+ model->B3SOIFDlcdscd * Inv_L
+ model->B3SOIFDwcdscd * Inv_W
+ model->B3SOIFDpcdscd * Inv_LW;
pParam->B3SOIFDpclm = model->B3SOIFDpclm
+ model->B3SOIFDlpclm * Inv_L
+ model->B3SOIFDwpclm * Inv_W
+ model->B3SOIFDppclm * Inv_LW;
pParam->B3SOIFDpdibl1 = model->B3SOIFDpdibl1
+ model->B3SOIFDlpdibl1 * Inv_L
+ model->B3SOIFDwpdibl1 * Inv_W
+ model->B3SOIFDppdibl1 * Inv_LW;
pParam->B3SOIFDpdibl2 = model->B3SOIFDpdibl2
+ model->B3SOIFDlpdibl2 * Inv_L
+ model->B3SOIFDwpdibl2 * Inv_W
+ model->B3SOIFDppdibl2 * Inv_LW;
pParam->B3SOIFDpdiblb = model->B3SOIFDpdiblb
+ model->B3SOIFDlpdiblb * Inv_L
+ model->B3SOIFDwpdiblb * Inv_W
+ model->B3SOIFDppdiblb * Inv_LW;
pParam->B3SOIFDdrout = model->B3SOIFDdrout
+ model->B3SOIFDldrout * Inv_L
+ model->B3SOIFDwdrout * Inv_W
+ model->B3SOIFDpdrout * Inv_LW;
pParam->B3SOIFDpvag = model->B3SOIFDpvag
+ model->B3SOIFDlpvag * Inv_L
+ model->B3SOIFDwpvag * Inv_W
+ model->B3SOIFDppvag * Inv_LW;
pParam->B3SOIFDdelta = model->B3SOIFDdelta
+ model->B3SOIFDldelta * Inv_L
+ model->B3SOIFDwdelta * Inv_W
+ model->B3SOIFDpdelta * Inv_LW;
pParam->B3SOIFDaii = model->B3SOIFDaii
+ model->B3SOIFDlaii * Inv_L
+ model->B3SOIFDwaii * Inv_W
+ model->B3SOIFDpaii * Inv_LW;
pParam->B3SOIFDbii = model->B3SOIFDbii
+ model->B3SOIFDlbii * Inv_L
+ model->B3SOIFDwbii * Inv_W
+ model->B3SOIFDpbii * Inv_LW;
pParam->B3SOIFDcii = model->B3SOIFDcii
+ model->B3SOIFDlcii * Inv_L
+ model->B3SOIFDwcii * Inv_W
+ model->B3SOIFDpcii * Inv_LW;
pParam->B3SOIFDdii = model->B3SOIFDdii
+ model->B3SOIFDldii * Inv_L
+ model->B3SOIFDwdii * Inv_W
+ model->B3SOIFDpdii * Inv_LW;
pParam->B3SOIFDalpha0 = model->B3SOIFDalpha0
+ model->B3SOIFDlalpha0 * Inv_L
+ model->B3SOIFDwalpha0 * Inv_W
+ model->B3SOIFDpalpha0 * Inv_LW;
pParam->B3SOIFDalpha1 = model->B3SOIFDalpha1
+ model->B3SOIFDlalpha1 * Inv_L
+ model->B3SOIFDwalpha1 * Inv_W
+ model->B3SOIFDpalpha1 * Inv_LW;
pParam->B3SOIFDbeta0 = model->B3SOIFDbeta0
+ model->B3SOIFDlbeta0 * Inv_L
+ model->B3SOIFDwbeta0 * Inv_W
+ model->B3SOIFDpbeta0 * Inv_LW;
pParam->B3SOIFDagidl = model->B3SOIFDagidl
+ model->B3SOIFDlagidl * Inv_L
+ model->B3SOIFDwagidl * Inv_W
+ model->B3SOIFDpagidl * Inv_LW;
pParam->B3SOIFDbgidl = model->B3SOIFDbgidl
+ model->B3SOIFDlbgidl * Inv_L
+ model->B3SOIFDwbgidl * Inv_W
+ model->B3SOIFDpbgidl * Inv_LW;
pParam->B3SOIFDngidl = model->B3SOIFDngidl
+ model->B3SOIFDlngidl * Inv_L
+ model->B3SOIFDwngidl * Inv_W
+ model->B3SOIFDpngidl * Inv_LW;
pParam->B3SOIFDntun = model->B3SOIFDntun
+ model->B3SOIFDlntun * Inv_L
+ model->B3SOIFDwntun * Inv_W
+ model->B3SOIFDpntun * Inv_LW;
pParam->B3SOIFDndiode = model->B3SOIFDndiode
+ model->B3SOIFDlndiode * Inv_L
+ model->B3SOIFDwndiode * Inv_W
+ model->B3SOIFDpndiode * Inv_LW;
pParam->B3SOIFDisbjt = model->B3SOIFDisbjt
+ model->B3SOIFDlisbjt * Inv_L
+ model->B3SOIFDwisbjt * Inv_W
+ model->B3SOIFDpisbjt * Inv_LW;
pParam->B3SOIFDisdif = model->B3SOIFDisdif
+ model->B3SOIFDlisdif * Inv_L
+ model->B3SOIFDwisdif * Inv_W
+ model->B3SOIFDpisdif * Inv_LW;
pParam->B3SOIFDisrec = model->B3SOIFDisrec
+ model->B3SOIFDlisrec * Inv_L
+ model->B3SOIFDwisrec * Inv_W
+ model->B3SOIFDpisrec * Inv_LW;
pParam->B3SOIFDistun = model->B3SOIFDistun
+ model->B3SOIFDlistun * Inv_L
+ model->B3SOIFDwistun * Inv_W
+ model->B3SOIFDpistun * Inv_LW;
pParam->B3SOIFDedl = model->B3SOIFDedl
+ model->B3SOIFDledl * Inv_L
+ model->B3SOIFDwedl * Inv_W
+ model->B3SOIFDpedl * Inv_LW;
pParam->B3SOIFDkbjt1 = model->B3SOIFDkbjt1
+ model->B3SOIFDlkbjt1 * Inv_L
+ model->B3SOIFDwkbjt1 * Inv_W
+ model->B3SOIFDpkbjt1 * Inv_LW;
/* CV model */
pParam->B3SOIFDvsdfb = model->B3SOIFDvsdfb
+ model->B3SOIFDlvsdfb * Inv_L
+ model->B3SOIFDwvsdfb * Inv_W
+ model->B3SOIFDpvsdfb * Inv_LW;
pParam->B3SOIFDvsdth = model->B3SOIFDvsdth
+ model->B3SOIFDlvsdth * Inv_L
+ model->B3SOIFDwvsdth * Inv_W
+ model->B3SOIFDpvsdth * Inv_LW;
/* Added for binning - END */
T0 = (TRatio - 1.0);
pParam->B3SOIFDuatemp = pParam->B3SOIFDua; /* save ua, ub, and uc for b3soifdld.c */
pParam->B3SOIFDubtemp = pParam->B3SOIFDub;
pParam->B3SOIFDuctemp = pParam->B3SOIFDuc;
pParam->B3SOIFDrds0denom = pow(pParam->B3SOIFDweff * 1E6, pParam->B3SOIFDwr);
pParam->B3SOIFDrth = here->B3SOIFDrth0 * sqrt(model->B3SOIFDtbox
/ model->B3SOIFDtsi) / pParam->B3SOIFDweff;
pParam->B3SOIFDcth = here->B3SOIFDcth0 * model->B3SOIFDtsi;
pParam->B3SOIFDrbody = model->B3SOIFDrbody *
pParam->B3SOIFDweff / pParam->B3SOIFDleff;
pParam->B3SOIFDua = pParam->B3SOIFDua + pParam->B3SOIFDua1 * T0;
pParam->B3SOIFDub = pParam->B3SOIFDub + pParam->B3SOIFDub1 * T0;
pParam->B3SOIFDuc = pParam->B3SOIFDuc + pParam->B3SOIFDuc1 * T0;
if (pParam->B3SOIFDu0 > 1.0)
pParam->B3SOIFDu0 = pParam->B3SOIFDu0 / 1.0e4;
pParam->B3SOIFDu0temp = pParam->B3SOIFDu0
* pow(TRatio, pParam->B3SOIFDute);
pParam->B3SOIFDvsattemp = pParam->B3SOIFDvsat - pParam->B3SOIFDat
* T0;
pParam->B3SOIFDrds0 = (pParam->B3SOIFDrdsw + pParam->B3SOIFDprt * T0)
/ pow(pParam->B3SOIFDweff * 1E6, pParam->B3SOIFDwr);
if (B3SOIFDcheckModel(model, here, ckt))
{ IFuid namarray[2];
namarray[0] = model->B3SOIFDmodName;
namarray[1] = here->B3SOIFDname;
(*(SPfrontEnd->IFerror)) (ERR_FATAL, "Fatal error(s) detected during B3SOIFDV3 parameter checking for %s in model %s", namarray);
return(E_BADPARM);
}
pParam->B3SOIFDcgdo = (model->B3SOIFDcgdo + pParam->B3SOIFDcf)
* pParam->B3SOIFDweffCV;
pParam->B3SOIFDcgso = (model->B3SOIFDcgso + pParam->B3SOIFDcf)
* pParam->B3SOIFDweffCV;
pParam->B3SOIFDcgeo = model->B3SOIFDcgeo * pParam->B3SOIFDleffCV;
if (!model->B3SOIFDnpeakGiven && model->B3SOIFDgamma1Given)
{ T0 = pParam->B3SOIFDgamma1 * model->B3SOIFDcox;
pParam->B3SOIFDnpeak = 3.021E22 * T0 * T0;
}
T0 = pow(TRatio, model->B3SOIFDxbjt / pParam->B3SOIFDndiode);
T1 = pow(TRatio, model->B3SOIFDxdif / pParam->B3SOIFDndiode);
T2 = pow(TRatio, model->B3SOIFDxrec / pParam->B3SOIFDndiode / 2);
T4 = -Eg0 / pParam->B3SOIFDndiode / model->B3SOIFDvtm * (1 - TRatio);
T5 = exp(T4);
T6 = sqrt(T5);
pParam->B3SOIFDjbjt = pParam->B3SOIFDisbjt * T0 * T5;
pParam->B3SOIFDjdif = pParam->B3SOIFDisdif * T1 * T5;
pParam->B3SOIFDjrec = pParam->B3SOIFDisrec * T2 * T6;
T0 = pow(TRatio, model->B3SOIFDxtun / pParam->B3SOIFDntun);
pParam->B3SOIFDjtun = pParam->B3SOIFDistun * T0 ;
if (pParam->B3SOIFDnsub > 0)
pParam->B3SOIFDvfbb = -model->B3SOIFDtype * model->B3SOIFDvtm *
log(pParam->B3SOIFDnpeak/ pParam->B3SOIFDnsub);
else
pParam->B3SOIFDvfbb = -model->B3SOIFDtype * model->B3SOIFDvtm *
log(-pParam->B3SOIFDnpeak* pParam->B3SOIFDnsub/ni/ni);
if (!model->B3SOIFDvsdfbGiven)
{
if (pParam->B3SOIFDnsub > 0)
pParam->B3SOIFDvsdfb = -model->B3SOIFDtype * (model->B3SOIFDvtm*log(1e20 *
pParam->B3SOIFDnsub / ni /ni) - 0.3);
else if (pParam->B3SOIFDnsub < 0)
pParam->B3SOIFDvsdfb = -model->B3SOIFDtype * (model->B3SOIFDvtm*log(-1e20 /
pParam->B3SOIFDnsub) + 0.3);
}
/* Phi & Gamma */
SDphi = 2.0*model->B3SOIFDvtm*log(fabs(pParam->B3SOIFDnsub) / ni);
SDgamma = 5.753e-12 * sqrt(fabs(pParam->B3SOIFDnsub)) / model->B3SOIFDcbox;
if (!model->B3SOIFDvsdthGiven)
{
if ( ((pParam->B3SOIFDnsub > 0) && (model->B3SOIFDtype > 0)) ||
((pParam->B3SOIFDnsub < 0) && (model->B3SOIFDtype < 0)) )
pParam->B3SOIFDvsdth = pParam->B3SOIFDvsdfb + SDphi +
SDgamma * sqrt(SDphi);
else
pParam->B3SOIFDvsdth = pParam->B3SOIFDvsdfb - SDphi -
SDgamma * sqrt(SDphi);
}
if (!model->B3SOIFDcsdminGiven)
{
/* Cdmin */
tmp = sqrt(2.0 * EPSSI * SDphi / (Charge_q *
fabs(pParam->B3SOIFDnsub) * 1.0e6));
tmp1 = EPSSI / tmp;
model->B3SOIFDcsdmin = tmp1 * model->B3SOIFDcbox /
(tmp1 + model->B3SOIFDcbox);
}
T0 = model->B3SOIFDcsdesw * log(1 + model->B3SOIFDtsi /
model->B3SOIFDtbox);
T1 = here->B3SOIFDsourcePerimeter - pParam->B3SOIFDweff;
if (T1 > 0.0)
pParam->B3SOIFDcsesw = T0 * T1;
else
pParam->B3SOIFDcsesw = 0.0;
T1 = here->B3SOIFDdrainPerimeter - pParam->B3SOIFDweff;
if (T1 > 0.0)
pParam->B3SOIFDcdesw = T0 * T1;
else
pParam->B3SOIFDcdesw = 0.0;
pParam->B3SOIFDphi = 2.0 * model->B3SOIFDvtm
* log(pParam->B3SOIFDnpeak / ni);
pParam->B3SOIFDsqrtPhi = sqrt(pParam->B3SOIFDphi);
pParam->B3SOIFDphis3 = pParam->B3SOIFDsqrtPhi * pParam->B3SOIFDphi;
pParam->B3SOIFDXdep0 = sqrt(2.0 * EPSSI / (Charge_q
* pParam->B3SOIFDnpeak * 1.0e6))
* pParam->B3SOIFDsqrtPhi;
pParam->B3SOIFDsqrtXdep0 = sqrt(pParam->B3SOIFDXdep0);
pParam->B3SOIFDlitl = sqrt(3.0 * model->B3SOIFDxj
* model->B3SOIFDtox);
pParam->B3SOIFDvbi = model->B3SOIFDvtm * log(1.0e20
* pParam->B3SOIFDnpeak / (ni * ni));
pParam->B3SOIFDcdep0 = sqrt(Charge_q * EPSSI
* pParam->B3SOIFDnpeak * 1.0e6 / 2.0
/ pParam->B3SOIFDphi);
if (model->B3SOIFDk1Given || model->B3SOIFDk2Given)
{ if (!model->B3SOIFDk1Given)
{ fprintf(stdout, "Warning: k1 should be specified with k2.\n");
pParam->B3SOIFDk1 = 0.53;
}
if (!model->B3SOIFDk2Given)
{ fprintf(stdout, "Warning: k2 should be specified with k1.\n");
pParam->B3SOIFDk2 = -0.0186;
}
if (model->B3SOIFDxtGiven)
fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n");
if (model->B3SOIFDvbxGiven)
fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n");
if (model->B3SOIFDvbmGiven)
fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n");
if (model->B3SOIFDgamma1Given)
fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n");
if (model->B3SOIFDgamma2Given)
fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n");
}
else
{ if (!model->B3SOIFDvbxGiven)
pParam->B3SOIFDvbx = pParam->B3SOIFDphi - 7.7348e-4
* pParam->B3SOIFDnpeak
* pParam->B3SOIFDxt * pParam->B3SOIFDxt;
if (pParam->B3SOIFDvbx > 0.0)
pParam->B3SOIFDvbx = -pParam->B3SOIFDvbx;
if (pParam->B3SOIFDvbm > 0.0)
pParam->B3SOIFDvbm = -pParam->B3SOIFDvbm;
if (!model->B3SOIFDgamma1Given)
pParam->B3SOIFDgamma1 = 5.753e-12
* sqrt(pParam->B3SOIFDnpeak)
/ model->B3SOIFDcox;
if (!model->B3SOIFDgamma2Given)
pParam->B3SOIFDgamma2 = 5.753e-12
* sqrt(pParam->B3SOIFDnsub)
/ model->B3SOIFDcox;
T0 = pParam->B3SOIFDgamma1 - pParam->B3SOIFDgamma2;
T1 = sqrt(pParam->B3SOIFDphi - pParam->B3SOIFDvbx)
- pParam->B3SOIFDsqrtPhi;
T2 = sqrt(pParam->B3SOIFDphi * (pParam->B3SOIFDphi
- pParam->B3SOIFDvbm)) - pParam->B3SOIFDphi;
pParam->B3SOIFDk2 = T0 * T1 / (2.0 * T2 + pParam->B3SOIFDvbm);
pParam->B3SOIFDk1 = pParam->B3SOIFDgamma2 - 2.0
* pParam->B3SOIFDk2 * sqrt(pParam->B3SOIFDphi
- pParam->B3SOIFDvbm);
}
if (pParam->B3SOIFDk2 < 0.0)
{ T0 = 0.5 * pParam->B3SOIFDk1 / pParam->B3SOIFDk2;
pParam->B3SOIFDvbsc = 0.9 * (pParam->B3SOIFDphi - T0 * T0);
if (pParam->B3SOIFDvbsc > -3.0)
pParam->B3SOIFDvbsc = -3.0;
else if (pParam->B3SOIFDvbsc < -30.0)
pParam->B3SOIFDvbsc = -30.0;
}
else
{ pParam->B3SOIFDvbsc = -30.0;
}
if (pParam->B3SOIFDvbsc > pParam->B3SOIFDvbm)
pParam->B3SOIFDvbsc = pParam->B3SOIFDvbm;
if (model->B3SOIFDvth0Given)
{ pParam->B3SOIFDvfb = model->B3SOIFDtype * pParam->B3SOIFDvth0
- pParam->B3SOIFDphi - pParam->B3SOIFDk1
* pParam->B3SOIFDsqrtPhi;
}
else
{ pParam->B3SOIFDvfb = -1.0;
pParam->B3SOIFDvth0 = model->B3SOIFDtype * (pParam->B3SOIFDvfb
+ pParam->B3SOIFDphi + pParam->B3SOIFDk1
* pParam->B3SOIFDsqrtPhi);
}
T1 = sqrt(EPSSI / EPSOX * model->B3SOIFDtox
* pParam->B3SOIFDXdep0);
T0 = exp(-0.5 * pParam->B3SOIFDdsub * pParam->B3SOIFDleff / T1);
pParam->B3SOIFDtheta0vb0 = (T0 + 2.0 * T0 * T0);
T0 = exp(-0.5 * pParam->B3SOIFDdrout * pParam->B3SOIFDleff / T1);
T2 = (T0 + 2.0 * T0 * T0);
pParam->B3SOIFDthetaRout = pParam->B3SOIFDpdibl1 * T2
+ pParam->B3SOIFDpdibl2;
here->B3SOIFDminIsub = 5.0e-2 * pParam->B3SOIFDweff * model->B3SOIFDtsi
* MAX(pParam->B3SOIFDisdif, pParam->B3SOIFDisrec);
}
here->B3SOIFDcsbox = model->B3SOIFDcbox*here->B3SOIFDsourceArea;
here->B3SOIFDcsmin = model->B3SOIFDcsdmin*here->B3SOIFDsourceArea;
here->B3SOIFDcdbox = model->B3SOIFDcbox*here->B3SOIFDdrainArea;
here->B3SOIFDcdmin = model->B3SOIFDcsdmin*here->B3SOIFDdrainArea;
if ( ((pParam->B3SOIFDnsub > 0) && (model->B3SOIFDtype > 0)) ||
((pParam->B3SOIFDnsub < 0) && (model->B3SOIFDtype < 0)) )
{
T0 = pParam->B3SOIFDvsdth - pParam->B3SOIFDvsdfb;
pParam->B3SOIFDsdt1 = pParam->B3SOIFDvsdfb + model->B3SOIFDasd * T0;
T1 = here->B3SOIFDcsbox - here->B3SOIFDcsmin;
T2 = T1 / T0 / T0;
pParam->B3SOIFDst2 = T2 / model->B3SOIFDasd;
pParam->B3SOIFDst3 = T2 /( 1 - model->B3SOIFDasd);
here->B3SOIFDst4 = T0 * T1 * (1 + model->B3SOIFDasd) / 3
- here->B3SOIFDcsmin * pParam->B3SOIFDvsdfb;
T1 = here->B3SOIFDcdbox - here->B3SOIFDcdmin;
T2 = T1 / T0 / T0;
pParam->B3SOIFDdt2 = T2 / model->B3SOIFDasd;
pParam->B3SOIFDdt3 = T2 /( 1 - model->B3SOIFDasd);
here->B3SOIFDdt4 = T0 * T1 * (1 + model->B3SOIFDasd) / 3
- here->B3SOIFDcdmin * pParam->B3SOIFDvsdfb;
} else
{
T0 = pParam->B3SOIFDvsdfb - pParam->B3SOIFDvsdth;
pParam->B3SOIFDsdt1 = pParam->B3SOIFDvsdth + model->B3SOIFDasd * T0;
T1 = here->B3SOIFDcsmin - here->B3SOIFDcsbox;
T2 = T1 / T0 / T0;
pParam->B3SOIFDst2 = T2 / model->B3SOIFDasd;
pParam->B3SOIFDst3 = T2 /( 1 - model->B3SOIFDasd);
here->B3SOIFDst4 = T0 * T1 * (1 + model->B3SOIFDasd) / 3
- here->B3SOIFDcsbox * pParam->B3SOIFDvsdth;
T1 = here->B3SOIFDcdmin - here->B3SOIFDcdbox;
T2 = T1 / T0 / T0;
pParam->B3SOIFDdt2 = T2 / model->B3SOIFDasd;
pParam->B3SOIFDdt3 = T2 /( 1 - model->B3SOIFDasd);
here->B3SOIFDdt4 = T0 * T1 * (1 + model->B3SOIFDasd) / 3
- here->B3SOIFDcdbox * pParam->B3SOIFDvsdth;
}
here->B3SOIFDphi = pParam->B3SOIFDphi;
/* process source/drain series resistance */
here->B3SOIFDdrainConductance = model->B3SOIFDsheetResistance
* here->B3SOIFDdrainSquares;
if (here->B3SOIFDdrainConductance > 0.0)
here->B3SOIFDdrainConductance = 1.0
/ here->B3SOIFDdrainConductance;
else
here->B3SOIFDdrainConductance = 0.0;
here->B3SOIFDsourceConductance = model->B3SOIFDsheetResistance
* here->B3SOIFDsourceSquares;
if (here->B3SOIFDsourceConductance > 0.0)
here->B3SOIFDsourceConductance = 1.0
/ here->B3SOIFDsourceConductance;
else
here->B3SOIFDsourceConductance = 0.0;
here->B3SOIFDcgso = pParam->B3SOIFDcgso;
here->B3SOIFDcgdo = pParam->B3SOIFDcgdo;
}
}
return(OK);
}

52
src/spicelib/devices/bsim3soi_fd/b3soifdtrunc.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: b3soifdtrunc.c 98/5/01
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "b3soifddef.h"
#include "sperror.h"
#include "suffix.h"
int
B3SOIFDtrunc(inModel,ckt,timeStep)
GENmodel *inModel;
CKTcircuit *ckt;
double *timeStep;
{
B3SOIFDmodel *model = (B3SOIFDmodel*)inModel;
B3SOIFDinstance *here;
#ifdef STEPDEBUG
double debugtemp;
#endif /* STEPDEBUG */
for (; model != NULL; model = model->B3SOIFDnextModel)
{ for (here = model->B3SOIFDinstances; here != NULL;
here = here->B3SOIFDnextInstance)
{
#ifdef STEPDEBUG
debugtemp = *timeStep;
#endif /* STEPDEBUG */
CKTterr(here->B3SOIFDqb,ckt,timeStep);
CKTterr(here->B3SOIFDqg,ckt,timeStep);
CKTterr(here->B3SOIFDqd,ckt,timeStep);
#ifdef STEPDEBUG
if(debugtemp != *timeStep)
{ printf("device %s reduces step from %g to %g\n",
here->B3SOIFDname,debugtemp,*timeStep);
}
#endif /* STEPDEBUG */
}
}
return(OK);
}

23
src/spicelib/parser/inp2m.c
View File

@ -85,10 +85,12 @@ INP2M (void *ckt, INPtables * tab, card * current)
INPgetMod (ckt, model, &thismodel, tab); /* get pointer to the model */
if (thismodel != NULL)
{
if (thismodel->INPmodType != INPtypelook ("B3SOIPD"))
if ((thismodel->INPmodType != INPtypelook ("B3SOIPD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIFD"))
)
{
/* if model is not variable node B3SOIPD model, error! */
LITERR ("only level 9 B3SOIPD can have 7 nodes") return;
LITERR ("only level 9-10 B3SOI(PD | FD) can have 7 nodes") return;
}
else
{ /* if looking at B3SOIPD model, allocate the 7th node */
@ -100,10 +102,12 @@ INP2M (void *ckt, INPtables * tab, card * current)
}
else
{ /* 7th token is a model - only have 6 terminal device */
if (thismodel->INPmodType != INPtypelook ("B3SOIPD"))
if ((thismodel->INPmodType != INPtypelook ("B3SOIPD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIFD"))
)
{
/* if model is not variable node B3SOIPD model, error! */
LITERR ("only level 9 B3SOIPD can have 6 nodes") return;
LITERR ("only level 9-10 B3SOI(PD | FD) can have 6 nodes") return;
}
else
{ /* if looking at B3SOIPD model, allocate the 6th node */
@ -115,10 +119,12 @@ INP2M (void *ckt, INPtables * tab, card * current)
}
else
{ /* 6th token is a model - only have 5 terminal device */
if (thismodel->INPmodType != INPtypelook ("B3SOIPD"))
if ((thismodel->INPmodType != INPtypelook ("B3SOIPD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIFD"))
)
{
/* if model is not variable node B3SOIPD model, error! */
LITERR ("only level 9 B3SOIPD can have 5 nodes") return;
LITERR ("only level 9-10 B3SOI(PD | FD) can have 5 nodes") return;
}
else
{ /* if looking at B3SOIPD model, allocate the 5th node */
@ -150,6 +156,7 @@ INP2M (void *ckt, INPtables * tab, card * current)
&& thismodel->INPmodType != INPtypelook ("BSIM2")
&& thismodel->INPmodType != INPtypelook ("BSIM3")
&& thismodel->INPmodType != INPtypelook ("B3SOIPD")
&& thismodel->INPmodType != INPtypelook ("B3SOIFD")
&& thismodel->INPmodType != INPtypelook ("BSIM4")
&& thismodel->INPmodType != INPtypelook ("BSIM3V1")
&& thismodel->INPmodType != INPtypelook ("BSIM3V2"))
@ -181,7 +188,9 @@ INP2M (void *ckt, INPtables * tab, card * current)
IFC (bindNode, (ckt, fast, 2, node2));
IFC (bindNode, (ckt, fast, 3, node3));
IFC (bindNode, (ckt, fast, 4, node4));
if (thismodel->INPmodType == INPtypelook ("B3SOIPD"))
if ((thismodel->INPmodType == INPtypelook ("B3SOIPD")) ||
(thismodel->INPmodType == INPtypelook ("B3SOIFD"))
)
{
switch (nodeflag)
{

16
tests/bsim3soifd/Makefile.am Normal file
View File

@ -0,0 +1,16 @@
## Process this file with automake to produce Makefile.in
TESTS = \
t3.cir \
t4.cir \
t5.cir \
inv2.cir \
RampVg2.cir
TESTS_ENVIRONMENT = $(SHELL) $(srcdir)/../check.sh $(top_builddir)/src/ngspice
EXTRA_DIST = \
$(TESTS) \
$(TESTS:.cir=.out)
MAINTAINERCLEANFILES = Makefile.in

19
tests/bsim3soifd/RampVg2.cir Normal file
View File

@ -0,0 +1,19 @@
* BSIMSOI example
*
* SOI, Ramp Vg
Vd d 0 1.5
Vg g 0 0.0 PULSE 0V 2V .02n .1n .1n .2n .6n
Ve e 0 0.0
Vs s 0 0.0
Vb b 0 0.0
m1 d g s e n1 w=10u l=0.25u debug=-1
.option gmin=1e-20 itl1=200 itl2=200 abstol=1e-9
.tran 1p 1.0ns
.print m1#Vbs, V(g)/10
.include nmosfd.mod
.end

13
tests/bsim3soifd/RampVg2.out Normal file
View File

@ -0,0 +1,13 @@
Error: no data saved for Transient analysis; analysis not run
doAnalyses: not found
run simulation(s) aborted
Error: .print: no m1#vbs analysis found.
Circuit: * BSIMSOI example
Warning: Pd = 0 is less than W.
Warning: Ps = 0 is less than W.

17
tests/bsim3soifd/inv2.cir Normal file
View File

@ -0,0 +1,17 @@
* model = BSIMSOI (FD)
*
*
* SOI Inverter - floating body
vin in 0 dc 2.5
vdd dd 0 dc 2.5
vss ss 0 dc 0
ve e 0 dc 1.25
m1 out in dd e p1 w=20u l=0.25u
m2 out in ss e n1 w=10u l=0.25u
.option itl1=500 gmin=1e-25
.dc vin 0 2.5 0.01
.print v(in), v(out)
.include nmosfd.mod
.include pmosfd.mod

15
tests/bsim3soifd/inv2.out Normal file
View File

@ -0,0 +1,15 @@
Error: no data saved for D.C. Transfer curve analysis; analysis not run
doAnalyses: not found
run simulation(s) aborted
Error: .print: no v(in) analysis found.
Circuit: * model = BSIMSOI (FD)
Warning: Pd = 0 is less than W.
Warning: Ps = 0 is less than W.
Warning: Pd = 0 is less than W.
Warning: Ps = 0 is less than W.

110
tests/bsim3soifd/lib.h Normal file
View File

@ -0,0 +1,110 @@
.subckt dum ss
mn1 ss ss ss ss ss n1 w=4u l=0.15u debug=1 AS=6p AD=6p PS=7u PD=7u
.ends dum
* XOR2
.subckt xnor2 dd ss sub A B out
mn1 T1 A C1 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn2 C1 B ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn3 out A C2 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn4 out B C2 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn5 C2 T1 ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mp1 T1 A dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp2 T1 B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp3 out A C3 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp4 C3 B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp5 out T1 dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
.ends xnor2
.subckt nor2 dd ss sub A B out
mn1 out A ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn2 out B ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mp1 out A C1 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp2 C1 B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
.ends nor2
.subckt nand2 dd ss sub A B out
mn1 out A C1 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn2 C1 B ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mp1 out A dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp2 out B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
.ends nand2
.subckt nor3 dd ss sub A B C out
mn1 out A ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn2 out B ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn3 out C ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mp1 out A C1 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp2 C1 B C2 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp3 C2 C dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
.ends nor3
.subckt nand3 dd ss sub A B C out
mn1 out A C1 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn2 C1 B C2 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn3 C2 C ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mp1 out A dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp2 out B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp3 out C dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
.ends nand3
.subckt nor4 dd ss sub A B C D out
mn1 out A ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn2 out B ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn3 out C ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn4 out C ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mp1 out A C1 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp2 C1 B C2 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp3 C2 C C3 sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp4 C3 C dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
.ends nor4
.subckt nand4 dd ss sub A B C D out
mn1 out A C1 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn2 C1 B C2 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn3 C2 C C3 sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mn4 C3 C ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mp1 out A dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp2 out B dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp3 out C dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
mp4 out C dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
.ends nand4
.subckt inv1 dd ss sub in out
mn1 out in ss sub n1 w=4u l=0.15u AS=6p AD=6p PS=7u PD=7u
mp1 out in dd sub p1 w=10u l=0.15u AS=15p AD=15p PS=13u PD=13u
.ends inv1
.subckt inv5 dd ss sub in out
xinv1 dd ss sub in 1 inv1
xinv2 dd ss sub 1 2 inv1
xinv3 dd ss sub 2 3 inv1
xinv4 dd ss sub 3 4 inv1
xinv5 dd ss sub 4 out inv1
.ends inv5
.subckt inv25 dd ss sub in out
xinv1 dd ss sub in 1 inv5
xinv2 dd ss sub 1 2 inv5
xinv3 dd ss sub 2 3 inv5
xinv4 dd ss sub 3 4 inv5
xinv5 dd ss sub 4 out inv5
.ends inv25
.subckt inv125 dd ss sub in out
xinv1 dd ss sub in 1 inv25
xinv2 dd ss sub 1 2 inv25
xinv3 dd ss sub 2 3 inv25
xinv4 dd ss sub 3 4 inv25
xinv5 dd ss sub 4 out inv25
.ends inv125
.subckt inv625 dd ss sub in out
xinv1 dd ss sub in 1 inv125
xinv2 dd ss sub 1 2 inv125
xinv3 dd ss sub 2 3 inv125
xinv4 dd ss sub 3 4 inv125
xinv5 dd ss sub 4 out inv125
.ends inv625

39
tests/bsim3soifd/nmosfd.mod Normal file
View File

@ -0,0 +1,39 @@
*Model Card for BSIMFD2.0, floating body FD SOI NMOS
*Released on 2/15/99
.Model N1 NMOS Level= 10
+TNOM = 27 TOX = 4.5E-09 TSI = 5e-8 TBOX = 8E-08
+MOBMOD = 0 CAPMOD = 3 SHMOD = 0
+PARAMCHK=0 WINT = 0 LINT = -2E-08
+VTH0 = .52 K1 = .39 K2 = .1 K3 = 0
+KB1 = .95 K3B = 2.2 NLX = 7.2E-08
+DVT0 = .55 DVT1 = .28 DVT2 = -1.4
+DVT0W = 0 DVT1W = 0 DVT2W = 0
+NCH = 3.3E+17 NSUB = 1E+15 NGATE = 1E+20
+DVBD0 = 60.0 DVBD1 = 1.1 VBSA = 0.0
+KB3 = 2.2 DELP = 0.02
+ABP = 0.9 MXC = 0.9 ADICE0 = 0.93
+KBJT1 = 1.0E-08 EDL = .0000005
+NDIODE = 1.13 NTUN = 14.0
+ISBJT = 2e-6 ISDIF = 1e-6 ISTUN = 0.0 ISREC = 1e-5
+XBJT = 0.01 XDIF = 0.01 XREC = 0.01 XTUN = 0.001
+U0 = 352 UA = 1.3E-11 UB = 1.7E-18 UC = -4E-10
+W0 = 1.16E-06 AGS = .25 A1 = 0 A2 = 1
+B0 = .01 B1 = 10
+RDSW = 700 PRWG = 0 PRWB = -.2 WR = 1
+RBODY = 0.0 RBSH = 0.0
+A0 = 1.4 KETA = -.67 VSAT = 135000
+DWG = 0 DWB = 0
+ALPHA0 = 0.0 ALPHA1 = 1.5 BETA0 = 20.5
+AII = 1.2 BII = 0.1e-7 CII = 0.8 DII = 0.6
+VOFF = -.14 NFACTOR = .7 CDSC = .00002 CDSCB = 0
+CDSCD = 0 CIT = 0
+PCLM = 2.9 PVAG = 12 PDIBLC1 = .18 PDIBLC2 = .004
+PDIBLCB = -.234 DROUT = .2
+DELTA = .01 ETA0 = .01 ETAB = 0
+DSUB = .3 RTH0 = .006
+CLC = .0000001 CLE = .6 CF = 1E-20 CKAPPA = .6
+CGDL = 1E-20 CGSL = 1E-20 KT1 = -.3 KT1L = 0
+KT2 = .022 UTE = -1.5 UA1 = 4.31E-09 UB1 = -7.61E-18
+UC1 = -5.6E-11 PRT = 760 AT = 22400
+CGSO = 1e-10 CGDO = 1e-10 CJSWG = 5e-10 TT=3e-10
+ASD = 0.3 CSDESW = 1e-12

39
tests/bsim3soifd/pmosfd.mod Normal file
View File

@ -0,0 +1,39 @@
*Model Card for BSIMFD2.0, floating body FD SOI PMOS
*Released on 2/15/99
.Model P1 PMOS Level= 10
+TNOM = 27 TOX = 4.5E-09 TSI = 5e-8 TBOX = 8E-08
+MOBMOD = 2 CAPMOD = 3 SHMOD = 0
+WINT = 0 LINT = -2E-08
+VTH0 = -.52 K1 = .39 K2 = .1 K3 = 0
+KB1 = .95 K3B = 2.2 NLX = 7.2E-08
+DVT0 = .55 DVT1 = .28 DVT2 = -1.4
+DVT0W = 0 DVT1W = 0 DVT2W = 0
+NCH = 3.0E+17 NSUB = 1E+15 NGATE = 1E+20
+DVBD0 = 60.0 DVBD1 = 1.1 VBSA = -0.2
+KB3 = 2.2 DELP = 0.02
+ABP = 0.9 MXC = 0.9 ADICE0 = 0.93
+KBJT1 = 1.0E-08 EDL = .0000005
+NDIODE = 1.13 NTUN = 14.0
+ISBJT = 0.0 ISDIF = 1e-6 ISTUN = 0.0 ISREC = 0.0
+XBJT = 0.01 XDIF = 0.01 XREC = 0.01 XTUN = 0.001
+U0 = 145 UA = 1.3E-11 UB = 1.7E-18 UC = -4E-10
+W0 = 1.16E-06 AGS = .25 A1 = 0 A2 = 1
+B0 = .01 B1 = 10
+RDSW = 700 PRWG = 0 PRWB = -.2 WR = 1
+RBODY = 0.0 RBSH = 0.0
+A0 = 1.4 KETA = -.67 VSAT = 75000
+DWG = 0 DWB = 0
+ALPHA0 = 0.0 ALPHA1 = 1e-4 BETA0 = 19
+AII = 1.25 BII = 0.1e-7 CII = 0.8 DII = 0.6
+VOFF = -.14 NFACTOR = .7 CDSC = .00002 CDSCB = 0
+CDSCD = 0 CIT = 0
+PCLM = 2.9 PVAG = 12 PDIBLC1 = .18 PDIBLC2 = .004
+PDIBLCB = -.234 DROUT = .2
+DELTA = .01 ETA0 = .01 ETAB = 0
+DSUB = .3 RTH0 = .006
+CLC = .0000001 CLE = .6 CF = 1E-20 CKAPPA = .6
+CGDL = 1E-20 CGSL = 1E-20 KT1 = -.3 KT1L = 0
+KT2 = .022 UTE = -1.5 UA1 = 4.31E-09 UB1 = -7.61E-18
+UC1 = -5.6E-11 PRT = 760 AT = 22400
+CGSO = 1e-10 CGDO = 1e-10 CJSWG = 5e-10 TT=3e-10
+ASD = 0.3 CSDESW = 1e-12

23
tests/bsim3soifd/ring51.cir Normal file
View File

@ -0,0 +1,23 @@
* 51 stage Ring-Osc.
vin in out 2 pulse 2 0 0.1n 5n 1 1 1
vdd dd 0 dc 0 pulse 0 2 0 1n 1 1 1
vss ss 0 dc 0
ve sub 0 dc 0
xinv1 dd ss sub in out25 inv25
xinv2 dd ss sub out25 out50 inv25
xinv5 dd ss sub out50 out inv1
xinv11 dd ss sub out buf inv1
cout buf ss 1pF
xdum ss dum
.option itl1=500 gmin=1e-15 itl4=10
*.dc vdd 0 2 0.01
.tran 0.2n 50n
.include nmosfd.mod
.include pmosfd.mod
.include lib.h
.end

18
tests/bsim3soifd/t3.cir Normal file
View File

@ -0,0 +1,18 @@
*model = BSIMSOI
*Berkeley Spice Compatibility
*
* SOI NMOSFET, floating body simulation
vd d 0 dc 1.5
vs s 0 dc 0
ve e 0 dc 0
vg g 0 dc 3
m1 d g s e n1 w=10u l=0.25u
.option gmin=1e-25 itl1=500
.dc vd 0 3 0.01 vg 0.5 3 0.5
.print v(g), i(vs)
.include nmosfd.mod

13
tests/bsim3soifd/t3.out Normal file
View File

@ -0,0 +1,13 @@
Error: no data saved for D.C. Transfer curve analysis; analysis not run
doAnalyses: not found
run simulation(s) aborted
Error: .print: no v(g) analysis found.
Circuit: *model = BSIMSOI
Warning: Pd = 0 is less than W.
Warning: Ps = 0 is less than W.

16
tests/bsim3soifd/t4.cir Normal file
View File

@ -0,0 +1,16 @@
*model = BSIMSOI
*Berkeley Spice Compatibility
*
* SOI NMOSFET, tied body simulation
vd d 0 dc 0.05
vs s 0 dc 0
ve e 0 dc 0
vg g 0 dc 3
vb b 0 dc 0
m1 d g s e b n1 w=10u l=0.25u
.option gmin=1e-25 itl1=500
.dc vg 0 1.5 0.01 vb -0.3 0.5 0.1
.include nmosfd.mod

4
tests/bsim3soifd/t4.out Normal file
View File

@ -0,0 +1,4 @@
Warning: premature EOF
Circuit: *model = BSIMSOI

15
tests/bsim3soifd/t5.cir Normal file
View File

@ -0,0 +1,15 @@
*model = BSIMSOI
*Berkeley Spice Compatibility
*
* SOI NMOSFET, floating body simulation
vd d 0 dc 0.05
vs s 0 dc 0
ve e 0 dc 0
vg g 0 dc 3
m1 d g s e n1 w=10u l=0.25u
.option gmin=1e-25 itl1=500
.dc vg 0 1.5 0.01 ve -4 4 1
.include nmosfd.mod

4
tests/bsim3soifd/t5.out Normal file
View File

@ -0,0 +1,4 @@
Warning: premature EOF
Circuit: *model = BSIMSOI

172
tests/bsim3soipd/RampVg2.out Normal file
View File

@ -0,0 +1,172 @@
Circuit: * BSIMSOI (PD) example
Warning: Pd = 0 is less than W.
Warning: Ps = 0 is less than W.
Initial Transient Solution
--------------------------
Node Voltage
---- -------
d 1.5
g 0
e 0
s 0
b 0
vb#branch 0
vs#branch 1.17881e-09
ve#branch 0
vg#branch 1.5e-20
vd#branch -1.17881e-09
* BSIMSOI (PD) example
--------------------------------------------------------------------------------
Index time v(g)/10
--------------------------------------------------------------------------------
0 0.000000e+00 0.000000e+00
1 1.000000e-14 0.000000e+00
2 2.000000e-14 0.000000e+00
3 4.000000e-14 0.000000e+00
4 8.000000e-14 0.000000e+00
5 1.600000e-13 0.000000e+00
6 3.200000e-13 0.000000e+00
7 6.400000e-13 0.000000e+00
8 1.280000e-12 0.000000e+00
9 2.560000e-12 0.000000e+00
10 5.120000e-12 0.000000e+00
11 1.024000e-11 0.000000e+00
12 2.000000e-11 0.000000e+00
13 2.100000e-11 2.000000e-03
14 2.300000e-11 6.000000e-03
15 2.700000e-11 1.400000e-02
16 2.800000e-11 1.600000e-02
17 3.000000e-11 2.000000e-02
18 3.400000e-11 2.800000e-02
19 4.200000e-11 4.400000e-02
20 5.200000e-11 6.400000e-02
21 6.200000e-11 8.400000e-02
22 7.200000e-11 1.040000e-01
23 8.200000e-11 1.240000e-01
24 9.200000e-11 1.440000e-01
25 1.020000e-10 1.640000e-01
26 1.120000e-10 1.840000e-01
27 1.200000e-10 2.000000e-01
28 1.210000e-10 2.000000e-01
29 1.230000e-10 2.000000e-01
30 1.270000e-10 2.000000e-01
31 1.350000e-10 2.000000e-01
32 1.450000e-10 2.000000e-01
33 1.550000e-10 2.000000e-01
34 1.650000e-10 2.000000e-01
35 1.750000e-10 2.000000e-01
36 1.850000e-10 2.000000e-01
37 1.950000e-10 2.000000e-01
38 2.050000e-10 2.000000e-01
39 2.150000e-10 2.000000e-01
40 2.250000e-10 2.000000e-01
41 2.350000e-10 2.000000e-01
42 2.450000e-10 2.000000e-01
43 2.550000e-10 2.000000e-01
44 2.650000e-10 2.000000e-01
45 2.750000e-10 2.000000e-01
46 2.850000e-10 2.000000e-01
47 2.950000e-10 2.000000e-01
48 3.050000e-10 2.000000e-01
49 3.150000e-10 2.000000e-01
50 3.200000e-10 2.000000e-01
51 3.210000e-10 1.980000e-01
52 3.230000e-10 1.940000e-01
53 3.270000e-10 1.860000e-01
54 3.350000e-10 1.700000e-01
Index time v(g)/10
--------------------------------------------------------------------------------
55 3.450000e-10 1.500000e-01
56 3.550000e-10 1.300000e-01
57 3.650000e-10 1.100000e-01
58 3.750000e-10 9.000000e-02
59 3.850000e-10 7.000000e-02
60 3.950000e-10 5.000000e-02
61 4.050000e-10 3.000000e-02
62 4.150000e-10 1.000000e-02
63 4.200000e-10 0.000000e+00
64 4.210000e-10 0.000000e+00
65 4.230000e-10 0.000000e+00
66 4.270000e-10 0.000000e+00
67 4.350000e-10 0.000000e+00
68 4.450000e-10 0.000000e+00
69 4.550000e-10 0.000000e+00
70 4.650000e-10 0.000000e+00
71 4.750000e-10 0.000000e+00
72 4.850000e-10 0.000000e+00
73 4.950000e-10 0.000000e+00
74 5.050000e-10 0.000000e+00
75 5.150000e-10 0.000000e+00
76 5.250000e-10 0.000000e+00
77 5.350000e-10 0.000000e+00
78 5.450000e-10 0.000000e+00
79 5.550000e-10 0.000000e+00
80 5.650000e-10 0.000000e+00
81 5.750000e-10 0.000000e+00
82 5.850000e-10 0.000000e+00
83 5.950000e-10 0.000000e+00
84 6.050000e-10 0.000000e+00
85 6.150000e-10 0.000000e+00
86 6.200000e-10 4.523644e-17
87 6.210000e-10 2.000000e-03
88 6.230000e-10 6.000000e-03
89 6.270000e-10 1.400000e-02
90 6.280000e-10 1.600000e-02
91 6.300000e-10 2.000000e-02
92 6.340000e-10 2.800000e-02
93 6.420000e-10 4.400000e-02
94 6.520000e-10 6.400000e-02
95 6.620000e-10 8.400000e-02
96 6.720000e-10 1.040000e-01
97 6.820000e-10 1.240000e-01
98 6.920000e-10 1.440000e-01
99 7.020000e-10 1.640000e-01
100 7.120000e-10 1.840000e-01
101 7.200000e-10 2.000000e-01
102 7.210000e-10 2.000000e-01
103 7.230000e-10 2.000000e-01
104 7.270000e-10 2.000000e-01
105 7.350000e-10 2.000000e-01
106 7.450000e-10 2.000000e-01
107 7.550000e-10 2.000000e-01
108 7.650000e-10 2.000000e-01
109 7.750000e-10 2.000000e-01
110 7.850000e-10 2.000000e-01
111 7.950000e-10 2.000000e-01
112 8.050000e-10 2.000000e-01
Index time v(g)/10
--------------------------------------------------------------------------------
113 8.150000e-10 2.000000e-01
114 8.250000e-10 2.000000e-01
115 8.350000e-10 2.000000e-01
116 8.450000e-10 2.000000e-01
117 8.550000e-10 2.000000e-01
118 8.650000e-10 2.000000e-01
119 8.750000e-10 2.000000e-01
120 8.850000e-10 2.000000e-01
121 8.950000e-10 2.000000e-01
122 9.050000e-10 2.000000e-01
123 9.150000e-10 2.000000e-01
124 9.200000e-10 2.000000e-01
125 9.210000e-10 1.980000e-01
126 9.230000e-10 1.940000e-01
127 9.270000e-10 1.860000e-01
128 9.350000e-10 1.700000e-01
129 9.450000e-10 1.500000e-01
130 9.550000e-10 1.300000e-01
131 9.650000e-10 1.100000e-01
132 9.750000e-10 9.000000e-02
133 9.850000e-10 7.000000e-02
134 9.950000e-10 5.000000e-02
135 1.000000e-09 4.000000e-02

279
tests/bsim3soipd/inv2.out Normal file
View File

@ -0,0 +1,279 @@
Circuit: * model = BSIMSOI (PD)
Warning: Pd = 0 is less than W.
Warning: Ps = 0 is less than W.
Warning: Pd = 0 is less than W.
Warning: Ps = 0 is less than W.
* model = BSIMSOI (PD)
DC transfer characteristic Sat Dec 9 18:04:21 2000
--------------------------------------------------------------------------------
Index v-sweep v(in) v(out)
--------------------------------------------------------------------------------
0 0.000000e+00 0.000000e+00 2.499999e+00
1 1.000000e-02 1.000000e-02 2.499998e+00
2 2.000000e-02 2.000000e-02 2.499998e+00
3 3.000000e-02 3.000000e-02 2.499997e+00
4 4.000000e-02 4.000000e-02 2.499996e+00
5 5.000000e-02 5.000000e-02 2.499994e+00
6 6.000000e-02 6.000000e-02 2.499991e+00
7 7.000000e-02 7.000000e-02 2.499986e+00
8 8.000000e-02 8.000000e-02 2.499980e+00
9 9.000000e-02 9.000000e-02 2.499970e+00
10 1.000000e-01 1.000000e-01 2.499955e+00
11 1.100000e-01 1.100000e-01 2.499934e+00
12 1.200000e-01 1.200000e-01 2.499903e+00
13 1.300000e-01 1.300000e-01 2.499859e+00
14 1.400000e-01 1.400000e-01 2.499799e+00
15 1.500000e-01 1.500000e-01 2.499717e+00
16 1.600000e-01 1.600000e-01 2.499607e+00
17 1.700000e-01 1.700000e-01 2.499461e+00
18 1.800000e-01 1.800000e-01 2.499270e+00
19 1.900000e-01 1.900000e-01 2.499024e+00
20 2.000000e-01 2.000000e-01 2.498710e+00
21 2.100000e-01 2.100000e-01 2.498318e+00
22 2.200000e-01 2.200000e-01 2.497836e+00
23 2.300000e-01 2.300000e-01 2.497253e+00
24 2.400000e-01 2.400000e-01 2.496562e+00
25 2.500000e-01 2.500000e-01 2.495756e+00
26 2.600000e-01 2.600000e-01 2.494834e+00
27 2.700000e-01 2.700000e-01 2.493792e+00
28 2.800000e-01 2.800000e-01 2.492633e+00
29 2.900000e-01 2.900000e-01 2.491358e+00
30 3.000000e-01 3.000000e-01 2.489971e+00
31 3.100000e-01 3.100000e-01 2.488475e+00
32 3.200000e-01 3.200000e-01 2.486875e+00
33 3.300000e-01 3.300000e-01 2.485175e+00
34 3.400000e-01 3.400000e-01 2.483378e+00
35 3.500000e-01 3.500000e-01 2.481488e+00
36 3.600000e-01 3.600000e-01 2.479508e+00
37 3.700000e-01 3.700000e-01 2.477441e+00
38 3.800000e-01 3.800000e-01 2.475290e+00
39 3.900000e-01 3.900000e-01 2.473056e+00
40 4.000000e-01 4.000000e-01 2.470741e+00
41 4.100000e-01 4.100000e-01 2.468347e+00
42 4.200000e-01 4.200000e-01 2.465873e+00
43 4.300000e-01 4.300000e-01 2.463322e+00
44 4.400000e-01 4.400000e-01 2.460692e+00
45 4.500000e-01 4.500000e-01 2.457984e+00
46 4.600000e-01 4.600000e-01 2.455198e+00
47 4.700000e-01 4.700000e-01 2.452333e+00
48 4.800000e-01 4.800000e-01 2.449390e+00
49 4.900000e-01 4.900000e-01 2.446366e+00
50 5.000000e-01 5.000000e-01 2.443261e+00
51 5.100000e-01 5.100000e-01 2.440073e+00
52 5.200000e-01 5.200000e-01 2.436803e+00
53 5.300000e-01 5.300000e-01 2.433447e+00
54 5.400000e-01 5.400000e-01 2.430005e+00
Index v-sweep v(in) v(out)
--------------------------------------------------------------------------------
55 5.500000e-01 5.500000e-01 2.426475e+00
56 5.600000e-01 5.600000e-01 2.422854e+00
57 5.700000e-01 5.700000e-01 2.419142e+00
58 5.800000e-01 5.800000e-01 2.415335e+00
59 5.900000e-01 5.900000e-01 2.411431e+00
60 6.000000e-01 6.000000e-01 2.407429e+00
61 6.100000e-01 6.100000e-01 2.403324e+00
62 6.200000e-01 6.200000e-01 2.399115e+00
63 6.300000e-01 6.300000e-01 2.394799e+00
64 6.400000e-01 6.400000e-01 2.390372e+00
65 6.500000e-01 6.500000e-01 2.385830e+00
66 6.600000e-01 6.600000e-01 2.381171e+00
67 6.700000e-01 6.700000e-01 2.376391e+00
68 6.800000e-01 6.800000e-01 2.371484e+00
69 6.900000e-01 6.900000e-01 2.366448e+00
70 7.000000e-01 7.000000e-01 2.361277e+00
71 7.100000e-01 7.100000e-01 2.355966e+00
72 7.200000e-01 7.200000e-01 2.350511e+00
73 7.300000e-01 7.300000e-01 2.344905e+00
74 7.400000e-01 7.400000e-01 2.339142e+00
75 7.500000e-01 7.500000e-01 2.333216e+00
76 7.600000e-01 7.600000e-01 2.327120e+00
77 7.700000e-01 7.700000e-01 2.320847e+00
78 7.800000e-01 7.800000e-01 2.314387e+00
79 7.900000e-01 7.900000e-01 2.307733e+00
80 8.000000e-01 8.000000e-01 2.300875e+00
81 8.100000e-01 8.100000e-01 2.293803e+00
82 8.200000e-01 8.200000e-01 2.286504e+00
83 8.300000e-01 8.300000e-01 2.278969e+00
84 8.400000e-01 8.400000e-01 2.271182e+00
85 8.500000e-01 8.500000e-01 2.263129e+00
86 8.600000e-01 8.600000e-01 2.254795e+00
87 8.700000e-01 8.700000e-01 2.246161e+00
88 8.800000e-01 8.800000e-01 2.237209e+00
89 8.900000e-01 8.900000e-01 2.227915e+00
90 9.000000e-01 9.000000e-01 2.218257e+00
91 9.100000e-01 9.100000e-01 2.208207e+00
92 9.200000e-01 9.200000e-01 2.197734e+00
93 9.300000e-01 9.300000e-01 2.186804e+00
94 9.400000e-01 9.400000e-01 2.175378e+00
95 9.500000e-01 9.500000e-01 2.163410e+00
96 9.600000e-01 9.600000e-01 2.150849e+00
97 9.700000e-01 9.700000e-01 2.137634e+00
98 9.800000e-01 9.800000e-01 2.123693e+00
99 9.900000e-01 9.900000e-01 2.108943e+00
100 1.000000e+00 1.000000e+00 2.093281e+00
101 1.010000e+00 1.010000e+00 2.076586e+00
102 1.020000e+00 1.020000e+00 2.058704e+00
103 1.030000e+00 1.030000e+00 2.039444e+00
104 1.040000e+00 1.040000e+00 2.018561e+00
105 1.050000e+00 1.050000e+00 1.995734e+00
106 1.060000e+00 1.060000e+00 1.970535e+00
107 1.070000e+00 1.070000e+00 1.942381e+00
108 1.080000e+00 1.080000e+00 1.910487e+00
109 1.090000e+00 1.090000e+00 1.873861e+00
110 1.100000e+00 1.100000e+00 1.831526e+00
111 1.110000e+00 1.110000e+00 1.783131e+00
112 1.120000e+00 1.120000e+00 1.729465e+00
Index v-sweep v(in) v(out)
--------------------------------------------------------------------------------
113 1.130000e+00 1.130000e+00 1.672104e+00
114 1.140000e+00 1.140000e+00 1.612635e+00
115 1.150000e+00 1.150000e+00 1.552288e+00
116 1.160000e+00 1.160000e+00 1.491955e+00
117 1.170000e+00 1.170000e+00 1.432304e+00
118 1.180000e+00 1.180000e+00 1.373879e+00
119 1.190000e+00 1.190000e+00 1.317159e+00
120 1.200000e+00 1.200000e+00 1.262589e+00
121 1.210000e+00 1.210000e+00 1.210557e+00
122 1.220000e+00 1.220000e+00 1.161309e+00
123 1.230000e+00 1.230000e+00 1.114785e+00
124 1.240000e+00 1.240000e+00 1.070348e+00
125 1.250000e+00 1.250000e+00 1.026313e+00
126 1.260000e+00 1.260000e+00 9.804248e-01
127 1.270000e+00 1.270000e+00 9.294193e-01
128 1.280000e+00 1.280000e+00 8.694365e-01
129 1.290000e+00 1.290000e+00 8.002731e-01
130 1.300000e+00 1.300000e+00 7.294810e-01
131 1.310000e+00 1.310000e+00 6.657313e-01
132 1.320000e+00 1.320000e+00 6.123845e-01
133 1.330000e+00 1.330000e+00 5.687190e-01
134 1.340000e+00 1.340000e+00 5.326058e-01
135 1.350000e+00 1.350000e+00 5.020053e-01
136 1.360000e+00 1.360000e+00 4.754247e-01
137 1.370000e+00 1.370000e+00 4.518624e-01
138 1.380000e+00 1.380000e+00 4.306482e-01
139 1.390000e+00 1.390000e+00 4.113201e-01
140 1.400000e+00 1.400000e+00 3.935479e-01
141 1.410000e+00 1.410000e+00 3.770868e-01
142 1.420000e+00 1.420000e+00 3.617495e-01
143 1.430000e+00 1.430000e+00 3.473891e-01
144 1.440000e+00 1.440000e+00 3.338880e-01
145 1.450000e+00 1.450000e+00 3.211499e-01
146 1.460000e+00 1.460000e+00 3.090947e-01
147 1.470000e+00 1.470000e+00 2.976554e-01
148 1.480000e+00 1.480000e+00 2.867748e-01
149 1.490000e+00 1.490000e+00 2.764038e-01
150 1.500000e+00 1.500000e+00 2.664999e-01
151 1.510000e+00 1.510000e+00 2.570258e-01
152 1.520000e+00 1.520000e+00 2.479490e-01
153 1.530000e+00 1.530000e+00 2.392405e-01
154 1.540000e+00 1.540000e+00 2.308747e-01
155 1.550000e+00 1.550000e+00 2.228285e-01
156 1.560000e+00 1.560000e+00 2.150815e-01
157 1.570000e+00 1.570000e+00 2.076149e-01
158 1.580000e+00 1.580000e+00 2.004121e-01
159 1.590000e+00 1.590000e+00 1.934577e-01
160 1.600000e+00 1.600000e+00 1.867378e-01
161 1.610000e+00 1.610000e+00 1.802398e-01
162 1.620000e+00 1.620000e+00 1.739520e-01
163 1.630000e+00 1.630000e+00 1.678637e-01
164 1.640000e+00 1.640000e+00 1.619651e-01
165 1.650000e+00 1.650000e+00 1.562472e-01
166 1.660000e+00 1.660000e+00 1.507015e-01
167 1.670000e+00 1.670000e+00 1.453203e-01
168 1.680000e+00 1.680000e+00 1.400964e-01
169 1.690000e+00 1.690000e+00 1.350231e-01
170 1.700000e+00 1.700000e+00 1.300941e-01
Index v-sweep v(in) v(out)
--------------------------------------------------------------------------------
171 1.710000e+00 1.710000e+00 1.253037e-01
172 1.720000e+00 1.720000e+00 1.206465e-01
173 1.730000e+00 1.730000e+00 1.161173e-01
174 1.740000e+00 1.740000e+00 1.117114e-01
175 1.750000e+00 1.750000e+00 1.074244e-01
176 1.760000e+00 1.760000e+00 1.032521e-01
177 1.770000e+00 1.770000e+00 9.919058e-02
178 1.780000e+00 1.780000e+00 9.523620e-02
179 1.790000e+00 1.790000e+00 9.138549e-02
180 1.800000e+00 1.800000e+00 8.763521e-02
181 1.810000e+00 1.810000e+00 8.398230e-02
182 1.820000e+00 1.820000e+00 8.042391e-02
183 1.830000e+00 1.830000e+00 7.695733e-02
184 1.840000e+00 1.840000e+00 7.358002e-02
185 1.850000e+00 1.850000e+00 7.028961e-02
186 1.860000e+00 1.860000e+00 6.708387e-02
187 1.870000e+00 1.870000e+00 6.396070e-02
188 1.880000e+00 1.880000e+00 6.091816e-02
189 1.890000e+00 1.890000e+00 5.795442e-02
190 1.900000e+00 1.900000e+00 5.506780e-02
191 1.910000e+00 1.910000e+00 5.225674e-02
192 1.920000e+00 1.920000e+00 4.951983e-02
193 1.930000e+00 1.930000e+00 4.685577e-02
194 1.940000e+00 1.940000e+00 4.426340e-02
195 1.950000e+00 1.950000e+00 4.174171e-02
196 1.960000e+00 1.960000e+00 3.928983e-02
197 1.970000e+00 1.970000e+00 3.690704e-02
198 1.980000e+00 1.980000e+00 3.459279e-02
199 1.990000e+00 1.990000e+00 3.234669e-02
200 2.000000e+00 2.000000e+00 3.016853e-02
201 2.010000e+00 2.010000e+00 2.805831e-02
202 2.020000e+00 2.020000e+00 2.601623e-02
203 2.030000e+00 2.030000e+00 2.404272e-02
204 2.040000e+00 2.040000e+00 2.213847e-02
205 2.050000e+00 2.050000e+00 2.030439e-02
206 2.060000e+00 2.060000e+00 1.854169e-02
207 2.070000e+00 2.070000e+00 1.685185e-02
208 2.080000e+00 2.080000e+00 1.523663e-02
209 2.090000e+00 2.090000e+00 1.369807e-02
210 2.100000e+00 2.100000e+00 1.223844e-02
211 2.110000e+00 2.110000e+00 1.086023e-02
212 2.120000e+00 2.120000e+00 9.566064e-03
213 2.130000e+00 2.130000e+00 8.358590e-03
214 2.140000e+00 2.140000e+00 7.240340e-03
215 2.150000e+00 2.150000e+00 6.213542e-03
216 2.160000e+00 2.160000e+00 5.279884e-03
217 2.170000e+00 2.170000e+00 4.440246e-03
218 2.180000e+00 2.180000e+00 3.694423e-03
219 2.190000e+00 2.190000e+00 3.040853e-03
220 2.200000e+00 2.200000e+00 2.476425e-03
221 2.210000e+00 2.210000e+00 1.996391e-03
222 2.220000e+00 2.220000e+00 1.594448e-03
223 2.230000e+00 2.230000e+00 1.262999e-03
224 2.240000e+00 2.240000e+00 9.935716e-04
225 2.250000e+00 2.250000e+00 7.773425e-04
226 2.260000e+00 2.260000e+00 6.056627e-04
227 2.270000e+00 2.270000e+00 4.705014e-04
228 2.280000e+00 2.280000e+00 3.647455e-04
Index v-sweep v(in) v(out)
--------------------------------------------------------------------------------
229 2.290000e+00 2.290000e+00 2.823398e-04
230 2.300000e+00 2.300000e+00 2.182915e-04
231 2.310000e+00 2.310000e+00 1.685819e-04
232 2.320000e+00 2.320000e+00 1.300315e-04
233 2.330000e+00 2.330000e+00 1.001518e-04
234 2.340000e+00 2.340000e+00 7.700730e-05
235 2.350000e+00 2.350000e+00 5.909602e-05
236 2.360000e+00 2.360000e+00 4.525240e-05
237 2.370000e+00 2.370000e+00 3.457075e-05
238 2.380000e+00 2.380000e+00 2.634594e-05
239 2.390000e+00 2.390000e+00 2.002815e-05
240 2.400000e+00 2.400000e+00 1.518814e-05
241 2.410000e+00 2.410000e+00 1.149079e-05
242 2.420000e+00 2.420000e+00 8.674634e-06
243 2.430000e+00 2.430000e+00 6.536017e-06
244 2.440000e+00 2.440000e+00 4.916669e-06
245 2.450000e+00 2.450000e+00 3.693987e-06
246 2.460000e+00 2.460000e+00 2.773298e-06
247 2.470000e+00 2.470000e+00 2.081773e-06
248 2.480000e+00 2.480000e+00 1.563599e-06
249 2.490000e+00 2.490000e+00 1.176165e-06
250 2.500000e+00 2.500000e+00 8.870574e-07

7492
tests/bsim3soipd/ring51.out Normal file
View File

File diff suppressed because it is too large Load Diff

1913
tests/bsim3soipd/t3.out Normal file
View File

File diff suppressed because it is too large Load Diff

1442
tests/bsim3soipd/t4.out Normal file
View File

File diff suppressed because it is too large Load Diff

1442
tests/bsim3soipd/t5.out Normal file
View File

File diff suppressed because it is too large Load Diff