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

src/spicelib/devices/bsim3soi_fd/BsimTerms_use

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

src/spicelib/devices/bsim3soi_fd/Makefile.am

@@ -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

src/spicelib/devices/bsim3soi_fd/b3soifd.c

@@ -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);
+
+

src/spicelib/devices/bsim3soi_fd/b3soifdacld.c

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

src/spicelib/devices/bsim3soi_fd/b3soifdask.c

@@ -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 */
+}
+

src/spicelib/devices/bsim3soi_fd/b3soifdcheck.c

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

src/spicelib/devices/bsim3soi_fd/b3soifdcvtest.c

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

src/spicelib/devices/bsim3soi_fd/b3soifddel.c

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

src/spicelib/devices/bsim3soi_fd/b3soifddest.c

@@ -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;
+}
+
+
+

src/spicelib/devices/bsim3soi_fd/b3soifdext.h

@@ -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 */
+

src/spicelib/devices/bsim3soi_fd/b3soifdgetic.c

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

src/spicelib/devices/bsim3soi_fd/b3soifdinit.c

@@ -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;
+}

src/spicelib/devices/bsim3soi_fd/b3soifdinit.h

@@ -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

src/spicelib/devices/bsim3soi_fd/b3soifditf.h

@@ -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
+

src/spicelib/devices/bsim3soi_fd/b3soifdmdel.c

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

src/spicelib/devices/bsim3soi_fd/b3soifdnoi.c

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

src/spicelib/devices/bsim3soi_fd/b3soifdpar.c

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

src/spicelib/devices/bsim3soi_fd/b3soifdpzld.c

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

src/spicelib/devices/bsim3soi_fd/b3soifdtemp.c

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

src/spicelib/devices/bsim3soi_fd/b3soifdtrunc.c

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

src/spicelib/parser/inp2m.c

@@ -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)
 	{

tests/bsim3soifd/Makefile.am

@@ -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

tests/bsim3soifd/RampVg2.cir

@@ -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
+

tests/bsim3soifd/RampVg2.out

@@ -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.
+
+
+

tests/bsim3soifd/inv2.cir

@@ -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

tests/bsim3soifd/inv2.out

@@ -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.
+
+
+

tests/bsim3soifd/lib.h

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

tests/bsim3soifd/nmosfd.mod

@@ -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   

tests/bsim3soifd/pmosfd.mod

@@ -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

tests/bsim3soifd/ring51.cir

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

tests/bsim3soifd/t3.cir

@@ -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
+

tests/bsim3soifd/t3.out

@@ -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.
+
+
+

tests/bsim3soifd/t4.cir

@@ -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

tests/bsim3soifd/t4.out

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

tests/bsim3soifd/t5.cir

@@ -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

tests/bsim3soifd/t5.out

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

tests/bsim3soipd/RampVg2.out

@@ -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	
+
+
+
+

tests/bsim3soipd/inv2.out

@@ -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	
+
+
+
+