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

add the HiSIM_HV model vers. 1.2.1

This commit is contained in:
dwarning 2011-04-29 16:47:55 +00:00
parent 46da3b066e
commit 1906903fb4
36 changed files with 31387 additions and 9007 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
configure.ac
View File

@ -1033,6 +1033,7 @@ AC_CONFIG_FILES([Makefile
src/spicelib/devices/hfet1/Makefile
src/spicelib/devices/hfet2/Makefile
src/spicelib/devices/hisim/Makefile
src/spicelib/devices/hisimhv/Makefile
src/spicelib/devices/jfet/Makefile
src/spicelib/devices/jfet2/Makefile
src/spicelib/devices/ltra/Makefile

1
src/Makefile.am
View File

@ -66,6 +66,7 @@ DYNAMIC_DEVICELIBS = \
spicelib/devices/hfet1/libhfet.la \
spicelib/devices/hfet2/libhfet2.la \
spicelib/devices/hisim/libhisim.la \
spicelib/devices/hisimhv/libhisimhv.la \
spicelib/devices/jfet/libjfet.la \
spicelib/devices/jfet2/libjfet2.la \
spicelib/devices/ltra/libltra.la \

2
src/spicelib/devices/Makefile.am
View File

@ -29,6 +29,7 @@ SUBDIRS = \
hfet1 \
hfet2 \
hisim \
hisimhv \
jfet \
jfet2 \
ltra \
@ -89,6 +90,7 @@ DIST_SUBDIRS = \
hfet1 \
hfet2 \
hisim \
hisimhv \
jfet \
jfet2 \
ltra \

82
src/spicelib/devices/dev.c
View File

@ -98,6 +98,7 @@ int add_udn(int,Evt_Udn_Info_t **);
#include "hfet1/hfetitf.h"
#include "hfet2/hfet2itf.h"
#include "hisim/hsm1itf.h"
#include "hisimhv/hsmhvitf.h"
#include "ind/inditf.h"
#include "isrc/isrcitf.h"
#include "jfet/jfetitf.h"
@ -207,63 +208,64 @@ spice_init_devices(void)
DEVices[24] = get_hfeta_info();
DEVices[25] = get_hfet2_info();
DEVices[26] = get_hsm1_info();
DEVices[27] = get_ind_info();
DEVices[28] = get_mut_info();
DEVices[29] = get_isrc_info();
DEVices[30] = get_jfet_info();
DEVices[31] = get_jfet2_info();
DEVices[32] = get_ltra_info();
DEVices[33] = get_mes_info();
DEVices[34] = get_mesa_info();
DEVices[35] = get_mos1_info();
DEVices[36] = get_mos2_info();
DEVices[37] = get_mos3_info();
DEVices[38] = get_mos6_info();
DEVices[39] = get_mos9_info();
DEVices[40] = get_res_info();
DEVices[41] = get_soi3_info();
DEVices[42] = get_sw_info();
DEVices[43] = get_tra_info();
DEVices[44] = get_txl_info();
DEVices[45] = get_vbic_info();
DEVices[46] = get_vccs_info();
DEVices[47] = get_vcvs_info();
DEVices[48] = get_vsrc_info();
DEVices[27] = get_hsmhv_info();
DEVices[28] = get_ind_info();
DEVices[29] = get_mut_info();
DEVices[30] = get_isrc_info();
DEVices[31] = get_jfet_info();
DEVices[32] = get_jfet2_info();
DEVices[33] = get_ltra_info();
DEVices[34] = get_mes_info();
DEVices[35] = get_mesa_info();
DEVices[36] = get_mos1_info();
DEVices[37] = get_mos2_info();
DEVices[38] = get_mos3_info();
DEVices[39] = get_mos6_info();
DEVices[40] = get_mos9_info();
DEVices[41] = get_res_info();
DEVices[42] = get_soi3_info();
DEVices[43] = get_sw_info();
DEVices[44] = get_tra_info();
DEVices[45] = get_txl_info();
DEVices[46] = get_vbic_info();
DEVices[47] = get_vccs_info();
DEVices[48] = get_vcvs_info();
DEVices[49] = get_vsrc_info();
#ifdef CIDER
DEVices[49] = get_nbjt_info();
DEVices[50] = get_nbjt2_info();
DEVices[51] = get_numd_info();
DEVices[52] = get_numd2_info();
DEVices[53] = get_numos_info();
DEVices[50] = get_nbjt_info();
DEVices[51] = get_nbjt2_info();
DEVices[52] = get_numd_info();
DEVices[53] = get_numd2_info();
DEVices[54] = get_numos_info();
#else
DEVices[49] = NULL;
DEVices[50] = NULL;
DEVices[51] = NULL;
DEVices[52] = NULL;
DEVices[53] = NULL;
DEVices[53] = NULL;
DEVices[54] = NULL;
#endif
#ifdef ADMS
DEVices[54] = get_hicum0_info();
DEVices[55] = get_hicum2_info();
DEVices[56] = get_mextram_info();
DEVices[57] = get_ekv_info();
DEVices[58] = get_psp102_info();
DEVices[55] = get_hicum0_info();
DEVices[56] = get_hicum2_info();
DEVices[57] = get_mextram_info();
DEVices[58] = get_ekv_info();
DEVices[59] = get_psp102_info();
#else
DEVices[54] = NULL;
DEVices[55] = NULL;
DEVices[56] = NULL;
DEVices[57] = NULL;
DEVices[58] = NULL;
DEVices[59] = NULL;
#endif
#ifdef NDEV /* NDEV */
DEVices[59] = get_ndev_info();
DEVices[60] = get_ndev_info();
#else
DEVices[59] = NULL;
#endif
DEVices[60] = NULL;
#endif
DEVices[61] = NULL;
DEVices[62] = NULL;
return;
}
@ -288,12 +290,12 @@ SPICEdev ** devices(void)
#ifdef ADMS
#define DEVICES_USED {"asrc", "bjt", "vbic", "bsim1", "bsim2", "bsim3", "bsim3v32", "bsim3v2", "bsim3v1", "bsim4", "bsim4v2", "bsim4v3", "bsim4v4", "bsim4v5", \
"bsim4soi", "bsim3soipd", "bsim3soifd", "bsim3soidd", "hisim", \
"bsim4soi", "bsim3soipd", "bsim3soifd", "bsim3soidd", "hisim", "hisimhv", \
"cap", "cccs", "ccvs", "csw", "dio", "hfet", "hfet2", "ind", "isrc", "jfet", "ltra", "mes", "mesa" ,"mos1", "mos2", "mos3", \
"mos6", "mos9", "res", "soi3", "sw", "tra", "urc", "vccs", "vcvs", "vsrc", "hicum0", "hicum2", "mextram", "ekv", "psp102"}
#else
#define DEVICES_USED {"asrc", "bjt", "vbic", "bsim1", "bsim2", "bsim3", "bsim3v32", "bsim3v2", "bsim3v1", "bsim4", "bsim4v4", "bsim4v2", "bsim4v3", "bsim4v4", "bsim4v5", \
"bsim4soi", "bsim3soipd", "bsim3soifd", "bsim3soidd", "hisim", \
"bsim4soi", "bsim3soipd", "bsim3soifd", "bsim3soidd", "hisim", "hisimhv", \
"cap", "cccs", "ccvs", "csw", "dio", "hfet", "hfet2", "ind", "isrc", "jfet", "ltra", "mes", "mesa" ,"mos1", "mos2", "mos3", \
"mos6", "mos9", "res", "soi3", "sw", "tra", "urc", "vccs", "vcvs", "vsrc"}
#endif

36
src/spicelib/devices/hisimhv/Makefile.am Normal file
View File

@ -0,0 +1,36 @@
## Process this file with automake to produce Makefile.in
noinst_LTLIBRARIES = libhisimhv.la
libhisimhv_la_SOURCES = hisimhv.h \
hsmhv.c \
hsmhvacld.c \
hsmhvask.c \
hsmhvcvtest.c \
hsmhvdef.h \
hsmhvdel.c \
hsmhvdest.c \
hsmhveval.c \
hsmhveval_qover.h \
hsmhvevalenv.h \
hsmhvext.h \
hsmhvgetic.c \
hsmhvinit.c \
hsmhvinit.h \
hsmhvitf.h \
hsmhvld.c \
hsmhvld_info_eval.h \
hsmhvmask.c \
hsmhvmdel.c \
hsmhvmpar.c \
hsmhvnoi.c \
hsmhvpar.c \
hsmhvpzld.c \
hsmhvset.c \
hsmhvtemp.c \
hsmhvtemp_eval.h \
hsmhvtrunc.c
AM_CPPFLAGS = -I$(top_srcdir)/src/include
MAINTAINERCLEANFILES = Makefile.in

73
src/spicelib/devices/hisimhv/hisimhv.h Normal file
View File

@ -0,0 +1,73 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hisimhv.h
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "hsmhvdef.h"
#include "cktdefs.h"
#ifndef _HiSIMHV_H
#define _HiSIMHV_H
/* return value */
#ifndef OK
#define HiSIM_OK 0
#define HiSIM_ERROR 1
#else
#define HiSIM_OK OK
#define HiSIM_ERROR E_PANIC
#endif
/* MOS type */
#ifndef NMOS
#define NMOS 1
#define PMOS -1
#endif
/* device working mode */
#ifndef CMI_NORMAL_MODE
#define HiSIM_NORMAL_MODE 1
#define HiSIM_REVERSE_MODE -1
#else
#define HiSIM_NORMAL_MODE CMI_NORMAL_MODE
#define HiSIM_REVERSE_MODE CMI_REVERSE_MODE
#endif
/* others */
#ifndef NULL
#define NULL 0
#endif
#define HiSIM_FALSE 0
#define HiSIM_TRUE 1
extern int HSMHVevaluate
(
double ivds,
double ivgs,
double ivbs,
double ivdsi,
double ivgsi,
double ivbsi,
double vbs_jct,
double vbd_jct,
double vsubs,
double deltemp,
HSMHVinstance *here,
HSMHVmodel *model,
CKTcircuit *ckt
) ;
#endif /* _HiSIMHV_H */

740
src/spicelib/devices/hisimhv/hsmhv.c Normal file
View File

@ -0,0 +1,740 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhv.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "devdefs.h"
#include "hsmhvdef.h"
#include "suffix.h"
IFparm HSMHVpTable[] = { /* parameters */
IOP( "coselfheat", HSMHV_COSELFHEAT, IF_INTEGER, "Calculation of self heating model"),
IOP( "cosubnode", HSMHV_COSUBNODE, IF_INTEGER, "Switch tempNode to subNode"),
IOP( "l", HSMHV_L, IF_REAL , "Length"),
IOP( "w", HSMHV_W, IF_REAL , "Width"),
IOP( "ad", HSMHV_AD, IF_REAL , "Drain area"),
IOP( "as", HSMHV_AS, IF_REAL , "Source area"),
IOP( "pd", HSMHV_PD, IF_REAL , "Drain perimeter"),
IOP( "ps", HSMHV_PS, IF_REAL , "Source perimeter"),
IOP( "nrd", HSMHV_NRD, IF_REAL , "Number of squares in drain"),
IOP( "nrs", HSMHV_NRS, IF_REAL , "Number of squares in source"),
IOP( "dtemp", HSMHV_DTEMP,IF_REAL , ""),
IOP( "off", HSMHV_OFF, IF_FLAG , "Device is initially off"),
IP ( "ic", HSMHV_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages"),
IOP("corbnet", HSMHV_CORBNET, IF_INTEGER, "Activate body resistance (1) or not (0)"),
IOP("rbpb", HSMHV_RBPB, IF_REAL, ""),
IOP("rbpd", HSMHV_RBPD, IF_REAL, ""),
IOP("rbps", HSMHV_RBPS, IF_REAL, ""),
IOP("rbdb", HSMHV_RBDB, IF_REAL, ""),
IOP("rbsb", HSMHV_RBSB, IF_REAL, ""),
IOP("corg", HSMHV_CORG, IF_INTEGER, "Activate gate resistance (1) or not (0)"),
IOP("ngcon", HSMHV_NGCON, IF_REAL, "Number of gate contacts"),
IOP("xgw", HSMHV_XGW, IF_REAL, "Distance from gate contact to channel edge"),
IOP("xgl", HSMHV_XGL, IF_REAL, "Offset of gate length due to variation in patterning"),
IOP("nf", HSMHV_NF, IF_REAL, "Number of fingers"),
IOP("sa", HSMHV_SA, IF_REAL, "Distance from STI edge to Gate edge [m]"),
IOP("sb", HSMHV_SB, IF_REAL, "Distance from STI edge to Gate edge [m]"),
IOP("sd", HSMHV_SD, IF_REAL, "Distance from Gate edge to Gate edge [m]"),
IOP("nsubcdfm", HSMHV_NSUBCDFM, IF_REAL, "Constant part of Nsub for DFM [1/cm^3]"),
IOP("m", HSMHV_M, IF_REAL, "Multiplication factor [-]"),
IOP("subld1", HSMHV_SUBLD1, IF_REAL, "Parameter for impact-ionization current in the drift region [-]"),
IOP("subld2", HSMHV_SUBLD2, IF_REAL, "Parameter for impact-ionization current in the drift region [m^{-1}*V^{3/2}]"),
IOP("lover", HSMHV_LOVER, IF_REAL, "Overlap length on source side [m]"),
IOP("lovers", HSMHV_LOVERS, IF_REAL, "Overlap length on source side [m]"),
IOP("loverld", HSMHV_LOVERLD, IF_REAL, "Overlap length on drain side [m]"),
IOP("ldrift1", HSMHV_LDRIFT1, IF_REAL, "Parameter for drift region length-1 [m]"),
IOP("ldrift2", HSMHV_LDRIFT2, IF_REAL, "Parameter for drift region length-2 [m]"),
IOP("ldrift1s", HSMHV_LDRIFT1S, IF_REAL, "Parameter for drift region length-1 on source side[m]"),
IOP("ldrift2s", HSMHV_LDRIFT2S, IF_REAL, "Parameter for drift region length-2 on source side[m]"),
/* Output Physical Values: */
OP ( "ids", HSMHV_CD, IF_REAL , "Ids"), /* Drain-Source current */
OP ( "isub", HSMHV_ISUB, IF_REAL , "Isub"), /* Substrate current */
OP ( "igidl", HSMHV_IGIDL, IF_REAL , "Igidl"), /* Gate-Induced Drain Leakage current */
OP ( "igisl", HSMHV_IGISL, IF_REAL , "Igisl"), /* Gate-Induced Source Leakage current */
OP ( "igd", HSMHV_IGD, IF_REAL , "Igd"), /* Gate-Drain current */
OP ( "igs", HSMHV_IGS, IF_REAL , "Igs"), /* Gate-Source current */
OP ( "igb", HSMHV_IGB, IF_REAL , "Igb"), /* Gate-Substrate current */
OP ( "gm", HSMHV_GM, IF_REAL , "Gm"), /* Transconductance */
OP ( "gds", HSMHV_GDS, IF_REAL , "Gds"), /* Channel conductance */
OP ( "gmbs", HSMHV_GMBS, IF_REAL , "Gmbs"), /* Body effect (Back gate) transconductance */
OP ( "gmt", HSMHV_GMT, IF_REAL , "GmT"), /* Temp - transconductance ----SHE----*/
OP ( "von", HSMHV_VON, IF_REAL , "Von"), /* Threshold voltage */
OP ( "vdsat", HSMHV_VDSAT, IF_REAL , "Vdsat"), /* Saturation voltage */
OP ( "qb", HSMHV_QB, IF_REAL , "Qb"), /* Bulk charge */
OP ( "qg", HSMHV_QG, IF_REAL , "Qg"), /* Gate charge */
OP ( "qd", HSMHV_QD, IF_REAL , "Qd"), /* Drain charge */
OP ( "cgg", HSMHV_CGG, IF_REAL , "Cgg"), /* MOSFET capacitance */
OP ( "cgd", HSMHV_CGD, IF_REAL , "Cgd"), /* MOSFET capacitance */
OP ( "cgs", HSMHV_CGS, IF_REAL , "Cgs"), /* MOSFET capacitance */
OP ( "cbg", HSMHV_CBG, IF_REAL , "Cbg"), /* MOSFET capacitance */
OP ( "cbs", HSMHV_CBSB, IF_REAL , "Cbs"), /* MOSFET capacitance */
OP ( "cbd", HSMHV_CBDB, IF_REAL , "Cbd"), /* MOSFET capacitance */
OP ( "cdg", HSMHV_CDG, IF_REAL , "Cdg"), /* MOSFET capacitance */
OP ( "cdd", HSMHV_CDD, IF_REAL , "Cdd"), /* MOSFET capacitance */
OP ( "cds", HSMHV_CDS, IF_REAL , "Cds"), /* MOSFET capacitance */
OP ( "cgdo", HSMHV_CGDO, IF_REAL , "Cgdo"), /* MOSFET overlap capacitance */
OP ( "cgso", HSMHV_CGSO, IF_REAL , "Cgso"), /* MOSFET overlap capacitance */
OP ( "cgbo", HSMHV_CGBO, IF_REAL , "Cgbo"), /* MOSFET overlap capacitance */
OP ( "ibd", HSMHV_CBD, IF_REAL , "Ibd"), /* Diode current */
OP ( "ibs", HSMHV_CBS, IF_REAL , "Ibs"), /* Diode current */
OP ( "gbd", HSMHV_GBD, IF_REAL , "Gbd"), /* Diode conductance */
OP ( "gbs", HSMHV_GBS, IF_REAL , "Gbs"), /* Diode conductance */
OP ( "capbd", HSMHV_CAPBD, IF_REAL , "Capbd"), /* Diode capacitance */
OP ( "capbs", HSMHV_CAPBS, IF_REAL , "Capbs") /* Diode capacitance */
};
IFparm HSMHVmPTable[] = { /* model parameters */
IP("nmos", HSMHV_MOD_NMOS, IF_FLAG, ""),
IP("pmos", HSMHV_MOD_PMOS, IF_FLAG, ""),
IOP("level", HSMHV_MOD_LEVEL, IF_INTEGER, ""),
IOP("info", HSMHV_MOD_INFO, IF_INTEGER, "Information level (for debug, etc.)"),
IOP("noise", HSMHV_MOD_NOISE, IF_INTEGER, "Noise model selector"),
IOP("version", HSMHV_MOD_VERSION, IF_STRING, "Model version"),
IOP("show", HSMHV_MOD_SHOW, IF_INTEGER, "Show physical value"),
IOP("corsrd", HSMHV_MOD_CORSRD, IF_INTEGER, "Handling of Rs and Rd"),
IOP("corg", HSMHV_MOD_CORG, IF_INTEGER, "Activate gate resistance (1) or not (0)"),
IOP("coiprv", HSMHV_MOD_COIPRV, IF_INTEGER, "Use ids_prv as initial guess of Ids (internal flag)"),
IOP("copprv", HSMHV_MOD_COPPRV, IF_INTEGER, "Use ps{0/l}_prv as initial guess of Ps{0/l} (internal flag)"),
IOP("coadov", HSMHV_MOD_COADOV, IF_INTEGER, "Add overlap to intrisic"),
IOP("coisub", HSMHV_MOD_COISUB, IF_INTEGER, "Calculate isub"),
IOP("coiigs", HSMHV_MOD_COIIGS, IF_INTEGER, "Calculate igate"),
IOP("cogidl", HSMHV_MOD_COGIDL, IF_INTEGER, "Calculate igidl"),
IOP("coovlp", HSMHV_MOD_COOVLP, IF_INTEGER, "Calculate overlap charge on the drain side"),
IOP("coovlps", HSMHV_MOD_COOVLPS, IF_INTEGER, "Calculate overlap charge on the source side"),
IOP("coflick", HSMHV_MOD_COFLICK, IF_INTEGER, "Calculate 1/f noise"),
IOP("coisti", HSMHV_MOD_COISTI, IF_INTEGER, "Calculate STI"),
IOP("conqs", HSMHV_MOD_CONQS, IF_INTEGER, "Calculate in nqs mode or qs mode"),
IOP("corbnet", HSMHV_MOD_CORBNET, IF_INTEGER, ""),
IOP("cothrml", HSMHV_MOD_COTHRML, IF_INTEGER, "Calculate thermal noise"),
IOP("coign", HSMHV_MOD_COIGN, IF_INTEGER, "Calculate induced gate noise"),
IOP("codfm", HSMHV_MOD_CODFM, IF_INTEGER, "Calculation of model for DFM"),
IOP("coqovsm", HSMHV_MOD_COQOVSM, IF_INTEGER, "select smoothing method of Qover"),
IOP("coselfheat", HSMHV_MOD_COSELFHEAT, IF_INTEGER, "Calculation of self heating model"),
IOP("cosubnode", HSMHV_MOD_COSUBNODE, IF_INTEGER, "Switch tempNode to subNode"),
IOP("cosym", HSMHV_MOD_COSYM, IF_INTEGER, "Model selector for symmetry device"),
IOP("cotemp", HSMHV_MOD_COTEMP, IF_INTEGER, "Model flag for temperature dependence"),
IOP("coldrift", HSMHV_MOD_COLDRIFT, IF_INTEGER, "selector for Ldrift parameter"),
IOP("vbsmin", HSMHV_MOD_VBSMIN, IF_REAL, "Minimum back bias voltage to be treated in hsmhveval [V]"),
IOP("vmax", HSMHV_MOD_VMAX, IF_REAL, "Saturation velocity [cm/s]"),
IOP("vmaxt1", HSMHV_MOD_VMAXT1, IF_REAL, "Saturation velocity coeff. [-]"),
IOP("vmaxt2", HSMHV_MOD_VMAXT2, IF_REAL, "Saturation velocity coeff. [-]"),
IOP("bgtmp1", HSMHV_MOD_BGTMP1, IF_REAL, "First order temp. coeff. for band gap [V/K]"),
IOP("bgtmp2", HSMHV_MOD_BGTMP2, IF_REAL, "Second order temp. coeff. for band gap [V/K^2]"),
IOP("eg0", HSMHV_MOD_EG0, IF_REAL, ""),
IOP("tox", HSMHV_MOD_TOX, IF_REAL, "Oxide thickness [m]"),
IOP("xld", HSMHV_MOD_XLD, IF_REAL, "Lateral diffusion of S/D under the gate [m]"),
IOP("xldld", HSMHV_MOD_XLDLD, IF_REAL, "Lateral diffusion of Drain under the gate [m]"),
IOP("xwdld", HSMHV_MOD_XWDLD, IF_REAL, ""),
IOP("lover", HSMHV_MOD_LOVER, IF_REAL, "Overlap length on source side [m], alias for lovers"),
IOP("lovers", HSMHV_MOD_LOVERS, IF_REAL, "Overlap length on source side [m]"),
IOP("rdov11", HSMHV_MOD_RDOV11, IF_REAL, "Dependence coeff. for overlap length"),
IOP("rdov12", HSMHV_MOD_RDOV12, IF_REAL, "Dependence coeff. for overlap length"),
IOP("rdov13", HSMHV_MOD_RDOV13, IF_REAL, "Dependence coeff. for overlap length"),
IOP("rdslp1", HSMHV_MOD_RDSLP1, IF_REAL, "LDRIFT1 dependence of resistance for CORSRD=1,3"),
IOP("rdict1", HSMHV_MOD_RDICT1, IF_REAL, "LDRIFT1 dependence of resistance for CORSRD=1,3"),
IOP("rdslp2", HSMHV_MOD_RDSLP2, IF_REAL, "LDRIFT2 dependence of resistance for CORSRD=1,3"),
IOP("rdict2", HSMHV_MOD_RDICT2, IF_REAL, "LDRIFT2 dependence of resistance for CORSRD=1,3"),
IOP("loverld", HSMHV_MOD_LOVERLD, IF_REAL, "Overlap length on the drain side"),
IOP("ldrift1", HSMHV_MOD_LDRIFT1, IF_REAL, "Drift region length-1 on the drain side[m]"),
IOP("ldrift2", HSMHV_MOD_LDRIFT2, IF_REAL, "Drift region length-2 on the drain side[m]"),
IOP("ldrift1s", HSMHV_MOD_LDRIFT1S, IF_REAL, "Drift region length-1 on the source side[m]"),
IOP("ldrift2s", HSMHV_MOD_LDRIFT2S, IF_REAL, "Drift region length-2 on the source side[m]"),
IOP("subld1", HSMHV_MOD_SUBLD1, IF_REAL, "Impact-ionization current in the drift region [-]"),
IOP("subld2", HSMHV_MOD_SUBLD2, IF_REAL, "Impact-ionization current in the drift region [m^{-1}*V^{3/2}]"),
IOP("ddltmax", HSMHV_MOD_DDLTMAX, IF_REAL, ""), /* Vdseff */
IOP("ddltslp", HSMHV_MOD_DDLTSLP, IF_REAL, ""), /* Vdseff */
IOP("ddltict", HSMHV_MOD_DDLTICT, IF_REAL, ""), /* Vdseff */
IOP("vfbover", HSMHV_MOD_VFBOVER, IF_REAL, ""),
IOP("nover", HSMHV_MOD_NOVER, IF_REAL, ""),
IOP("novers", HSMHV_MOD_NOVERS, IF_REAL, ""),
IOP("xwd", HSMHV_MOD_XWD, IF_REAL, "Lateral diffusion along the width dir. [m]"),
IOP("xwdc", HSMHV_MOD_XWDC, IF_REAL, "Lateral diffusion along the width dir. for capacitance [m]"),
IOP("xl", HSMHV_MOD_XL, IF_REAL, "Gate length offset due to mask/etch effect [m]"),
IOP("xw", HSMHV_MOD_XW, IF_REAL, "Gate width offset due to mask/etch effect [m]"),
IOP("saref", HSMHV_MOD_SAREF, IF_REAL, "Reference distance from STI edge to Gate edge [m]"),
IOP("sbref", HSMHV_MOD_SBREF, IF_REAL, "Reference distance from STI edge to Gate edge [m]"),
IOP("ll", HSMHV_MOD_LL, IF_REAL, "Gate length parameter"),
IOP("lld", HSMHV_MOD_LLD, IF_REAL, "Gate length parameter"),
IOP("lln", HSMHV_MOD_LLN, IF_REAL, "Gate length parameter"),
IOP("wl", HSMHV_MOD_WL, IF_REAL, "Gate width parameter"),
IOP("wl1", HSMHV_MOD_WL1, IF_REAL, "Gate width parameter"),
IOP("wl1p", HSMHV_MOD_WL1P, IF_REAL, "Gate width parameter"),
IOP("wl2", HSMHV_MOD_WL2, IF_REAL, "Gate width parameter"),
IOP("wl2p", HSMHV_MOD_WL2P, IF_REAL, "Gate width parameter"),
IOP("wld", HSMHV_MOD_WLD, IF_REAL, "Gate width parameter"),
IOP("wln", HSMHV_MOD_WLN, IF_REAL, "Gate width parameter"),
IOP("xqy", HSMHV_MOD_XQY, IF_REAL, "[m]"),
IOP("xqy1", HSMHV_MOD_XQY1, IF_REAL, "[F m^{XQY2}]"),
IOP("xqy2", HSMHV_MOD_XQY2, IF_REAL, "[-]"),
IOP("rs", HSMHV_MOD_RS, IF_REAL, "Source contact resistance [ohm m]"),
IOP("rd", HSMHV_MOD_RD, IF_REAL, "Drain contact resistance [ohm m]"),
IOP("rsh", HSMHV_MOD_RSH, IF_REAL, "Source/drain diffusion sheet resistance [ohm]"),
IOP("rshg", HSMHV_MOD_RSHG, IF_REAL, "Gate-elecrode sheet resistance"),
IOP("vfbc", HSMHV_MOD_VFBC, IF_REAL, "Constant part of Vfb [V]"),
IOP("vbi", HSMHV_MOD_VBI, IF_REAL, "Built-in potential [V]"),
IOP("nsubc", HSMHV_MOD_NSUBC, IF_REAL, "Constant part of Nsub [1/cm^3]"),
IOP("parl2", HSMHV_MOD_PARL2, IF_REAL, "Under diffusion [m]"),
IOP("lp", HSMHV_MOD_LP, IF_REAL, "Length of pocket potential [m]"),
IOP("nsubp", HSMHV_MOD_NSUBP, IF_REAL, "[1/cm^3]"),
IOP("nsubp0", HSMHV_MOD_NSUBP0, IF_REAL, "Pocket implant parameter"),
IOP("nsubwp", HSMHV_MOD_NSUBWP, IF_REAL, "Pocket implant parameter"),
IOP("scp1", HSMHV_MOD_SCP1, IF_REAL, "Parameter for pocket [-]"),
IOP("scp2", HSMHV_MOD_SCP2, IF_REAL, "Parameter for pocket [1/V]"),
IOP("scp3", HSMHV_MOD_SCP3, IF_REAL, "Parameter for pocket [m/V]"),
IOP("sc1", HSMHV_MOD_SC1, IF_REAL, "Parameter for SCE [-]"),
IOP("sc2", HSMHV_MOD_SC2, IF_REAL, "Parameter for SCE [1/V]"),
IOP("sc3", HSMHV_MOD_SC3, IF_REAL, "Parameter for SCE [m/V]"),
IOP("sc4", HSMHV_MOD_SC4, IF_REAL, "Parameter for SCE [1/V]"),
IOP("pgd1", HSMHV_MOD_PGD1, IF_REAL, "Parameter for gate-poly depletion [V]"),
IOP("pgd2", HSMHV_MOD_PGD2, IF_REAL, "Parameter for gate-poly depletion [V]"),
IOP("pgd3", HSMHV_MOD_PGD3, IF_REAL, "Parameter for gate-poly depletion [-]"),
IOP("pgd4", HSMHV_MOD_PGD4, IF_REAL, "Parameter for gate-poly depletion [-]"),
IOP("ndep", HSMHV_MOD_NDEP, IF_REAL, "Coeff. of Qbm for Eeff [-]"),
IOP("ndepl", HSMHV_MOD_NDEPL, IF_REAL, "Coeff. of Qbm for Eeff [-]"),
IOP("ndeplp", HSMHV_MOD_NDEPLP, IF_REAL, "Coeff. of Qbm for Eeff [-]"),
IOP("ninv", HSMHV_MOD_NINV, IF_REAL, "Coeff. of Qnm for Eeff [-]"),
IOP("ninvd", HSMHV_MOD_NINVD, IF_REAL, "Modification of Vdse dependence on Eeff [1/V]"),
IOP("ninvdw", HSMHV_MOD_NINVDW, IF_REAL, "Coeff of modification of Vdse dependence on Eeff [-]"),
IOP("ninvdwp", HSMHV_MOD_NINVDWP, IF_REAL, "Coeff of modification of Vdse dependence on Eeff [-]"),
IOP("ninvdt1", HSMHV_MOD_NINVDT1, IF_REAL, "Coeff of modification of Vdse dependence on Eeff [-]"),
IOP("ninvdt2", HSMHV_MOD_NINVDT2, IF_REAL, "Coeff of modification of Vdse dependence on Eeff [-]"),
IOP("muecb0", HSMHV_MOD_MUECB0, IF_REAL, "Const. part of coulomb scattering [cm^2/Vs]"),
IOP("muecb1", HSMHV_MOD_MUECB1, IF_REAL, "Coeff. for coulomb scattering [cm^2/Vs]"),
IOP("mueph0", HSMHV_MOD_MUEPH0, IF_REAL, "Power of Eeff for phonon scattering [-]"),
IOP("mueph1", HSMHV_MOD_MUEPH1, IF_REAL, ""),
IOP("muephw", HSMHV_MOD_MUEPHW, IF_REAL, ""),
IOP("muepwp", HSMHV_MOD_MUEPWP, IF_REAL, "Phonon scattering parameter"),
IOP("muephl", HSMHV_MOD_MUEPHL, IF_REAL, "Phonon scattering parameter"),
IOP("mueplp", HSMHV_MOD_MUEPLP, IF_REAL, "Phonon scattering parameter"),
IOP("muephs", HSMHV_MOD_MUEPHS, IF_REAL, ""),
IOP("muepsp", HSMHV_MOD_MUEPSP, IF_REAL, ""),
IOP("vtmp", HSMHV_MOD_VTMP, IF_REAL, ""),
IOP("wvth0", HSMHV_MOD_WVTH0, IF_REAL, ""),
IOP("muesr0", HSMHV_MOD_MUESR0, IF_REAL, "Power of Eeff for S.R. scattering [-]"),
IOP("muesr1", HSMHV_MOD_MUESR1, IF_REAL, "Coeff. for S.R. scattering [-]"),
IOP("muesrl", HSMHV_MOD_MUESRL, IF_REAL, "Surface roughness parameter"),
IOP("muesrw", HSMHV_MOD_MUESRW, IF_REAL, "Change of surface roughness related mobility"),
IOP("mueswp", HSMHV_MOD_MUESWP, IF_REAL, "Change of surface roughness related mobility"),
IOP("mueslp", HSMHV_MOD_MUESLP, IF_REAL, "Surface roughness parameter"),
IOP("muetmp", HSMHV_MOD_MUETMP, IF_REAL, "Parameter for mobility [-]"),
IOP("bb", HSMHV_MOD_BB, IF_REAL, "Empirical mobility model coefficient [-]"),
IOP("sub1", HSMHV_MOD_SUB1, IF_REAL, "Parameter for Isub [1/V]"),
IOP("sub2", HSMHV_MOD_SUB2, IF_REAL, "Parameter for Isub [V]"),
IOP("svgs", HSMHV_MOD_SVGS, IF_REAL, "Coefficient for Vg of Psislsat"),
IOP("svbs", HSMHV_MOD_SVBS, IF_REAL, "Coefficient for Vbs of Psislsat"),
IOP("svbsl", HSMHV_MOD_SVBSL, IF_REAL, " "),
IOP("svds", HSMHV_MOD_SVDS, IF_REAL, " "),
IOP("slg", HSMHV_MOD_SLG, IF_REAL, " "),
IOP("sub1l", HSMHV_MOD_SUB1L, IF_REAL, " "),
IOP("sub2l", HSMHV_MOD_SUB2L, IF_REAL, " "),
IOP("fn1", HSMHV_MOD_FN1, IF_REAL, " "),
IOP("fn2", HSMHV_MOD_FN2, IF_REAL, " "),
IOP("fn3", HSMHV_MOD_FN3, IF_REAL, " "),
IOP("fvbs", HSMHV_MOD_FVBS, IF_REAL, " "),
IOP("svgsl", HSMHV_MOD_SVGSL, IF_REAL, " "),
IOP("svgslp", HSMHV_MOD_SVGSLP, IF_REAL, " "),
IOP("svgswp", HSMHV_MOD_SVGSWP, IF_REAL, " "),
IOP("svgsw", HSMHV_MOD_SVGSW, IF_REAL, " "),
IOP("svbslp", HSMHV_MOD_SVBSLP, IF_REAL, " "),
IOP("slgl", HSMHV_MOD_SLGL, IF_REAL, " "),
IOP("slglp", HSMHV_MOD_SLGLP, IF_REAL, " "),
IOP("sub1lp", HSMHV_MOD_SUB1LP, IF_REAL, " "),
IOP("nsti", HSMHV_MOD_NSTI, IF_REAL, "Parameter for STI [1/cm^3]"),
IOP("wsti", HSMHV_MOD_WSTI, IF_REAL, "Parameter for STI [m]"),
IOP("wstil", HSMHV_MOD_WSTIL, IF_REAL, "Parameter for STI [?]"),
IOP("wstilp", HSMHV_MOD_WSTILP, IF_REAL, "Parameter for STI [?]"),
IOP("wstiw", HSMHV_MOD_WSTIW, IF_REAL, "Parameter for STI [?]"),
IOP("wstiwp", HSMHV_MOD_WSTIWP, IF_REAL, "Parameter for STI [?]"),
IOP("scsti1", HSMHV_MOD_SCSTI1, IF_REAL, "Parameter for STI [-]"),
IOP("scsti2", HSMHV_MOD_SCSTI2, IF_REAL, "Parameter for STI [1/V]"),
IOP("vthsti", HSMHV_MOD_VTHSTI, IF_REAL, "Parameter for STI"),
IOP("vdsti", HSMHV_MOD_VDSTI, IF_REAL, "Parameter for STI [-]"),
IOP("muesti1", HSMHV_MOD_MUESTI1, IF_REAL, "STI Stress mobility parameter"),
IOP("muesti2", HSMHV_MOD_MUESTI2, IF_REAL, "STI Stress mobility parameter"),
IOP("muesti3", HSMHV_MOD_MUESTI3, IF_REAL, "STI Stress mobility parameter"),
IOP("nsubpsti1", HSMHV_MOD_NSUBPSTI1, IF_REAL, "STI Stress pocket implant parameter"),
IOP("nsubpsti2", HSMHV_MOD_NSUBPSTI2, IF_REAL, "STI Stress pocket implant parameter"),
IOP("nsubpsti3", HSMHV_MOD_NSUBPSTI3, IF_REAL, "STI Stress pocket implant parameter"),
IOP("lpext", HSMHV_MOD_LPEXT, IF_REAL, "Pocket extension"),
IOP("npext", HSMHV_MOD_NPEXT, IF_REAL, "Pocket extension"),
IOP("scp22", HSMHV_MOD_SCP22, IF_REAL, ""),
IOP("scp21", HSMHV_MOD_SCP21, IF_REAL, ""),
IOP("bs1", HSMHV_MOD_BS1, IF_REAL, ""),
IOP("bs2", HSMHV_MOD_BS2, IF_REAL, ""),
IOP("cgso", HSMHV_MOD_CGSO, IF_REAL, "G-S overlap capacitance per unit W [F/m]"),
IOP("cgdo", HSMHV_MOD_CGDO, IF_REAL, "G-D overlap capacitance per unit W [F/m]"),
IOP("cgbo", HSMHV_MOD_CGBO, IF_REAL, "G-B overlap capacitance per unit L [F/m]"),
IOP("tpoly", HSMHV_MOD_TPOLY, IF_REAL, "Height of poly gate on the source side[m]"),
IOP("js0", HSMHV_MOD_JS0, IF_REAL, "Saturation current density [A/m^2]"),
IOP("js0sw", HSMHV_MOD_JS0SW, IF_REAL, "Side wall saturation current density [A/m]"),
IOP("nj", HSMHV_MOD_NJ, IF_REAL, "Emission coefficient [-]"),
IOP("njsw", HSMHV_MOD_NJSW, IF_REAL, "Sidewall emission coefficient"),
IOP("xti", HSMHV_MOD_XTI, IF_REAL, "Junction current temparature exponent coefficient [-]"),
IOP("cj", HSMHV_MOD_CJ, IF_REAL, "Bottom junction capacitance per unit area at zero bias [F/m^2]"),
IOP("cjsw", HSMHV_MOD_CJSW, IF_REAL, "Source/drain sidewall junction capacitance grading coefficient per unit length at zero bias [F/m]"),
IOP("cjswg", HSMHV_MOD_CJSWG, IF_REAL, "Source/drain gate sidewall junction capacitance per unit length at zero bias [F/m]"),
IOP("mj", HSMHV_MOD_MJ, IF_REAL, "Bottom junction capacitance grading coefficient"),
IOP("mjsw", HSMHV_MOD_MJSW, IF_REAL, "Source/drain sidewall junction capacitance grading coefficient"),
IOP("mjswg", HSMHV_MOD_MJSWG, IF_REAL, "Source/drain gate sidewall junction capacitance grading coefficient"),
IOP("pb", HSMHV_MOD_PB, IF_REAL, "Bottom junction build-in potential [V]"),
IOP("pbsw", HSMHV_MOD_PBSW, IF_REAL, "Source/drain sidewall junction build-in potential [V]"),
IOP("pbswg", HSMHV_MOD_PBSWG, IF_REAL, "Source/drain gate sidewall junction build-in potential [V]"),
IOP("xti2", HSMHV_MOD_XTI2, IF_REAL, "Temperature coefficient [-]"),
IOP("cisb", HSMHV_MOD_CISB, IF_REAL, "Reverse bias saturation current [-]"),
IOP("cvb", HSMHV_MOD_CVB, IF_REAL, "Bias dependence coefficient of cisb [-]"),
IOP("ctemp", HSMHV_MOD_CTEMP, IF_REAL, "Temperature coefficient [-]"),
IOP("cisbk", HSMHV_MOD_CISBK, IF_REAL, "Reverse bias saturation current [A]"),
IOP("cvbk", HSMHV_MOD_CVBK, IF_REAL, "Bias dependence coefficient of cisb [-]"),
IOP("divx", HSMHV_MOD_DIVX, IF_REAL, " [1/V]"),
IOP("clm1", HSMHV_MOD_CLM1, IF_REAL, "Parameter for CLM [-]"),
IOP("clm2", HSMHV_MOD_CLM2, IF_REAL, "Parameter for CLM [1/m]"),
IOP("clm3", HSMHV_MOD_CLM3, IF_REAL, "Parameter for CLM [-]"),
IOP("clm5", HSMHV_MOD_CLM5, IF_REAL, "Parameter for CLM [-]"),
IOP("clm6", HSMHV_MOD_CLM6, IF_REAL, "Parameter for CLM [um^{-clm5}]"),
IOP("vover", HSMHV_MOD_VOVER, IF_REAL, "Parameter for overshoot [m^{voverp}]"),
IOP("voverp", HSMHV_MOD_VOVERP, IF_REAL, "Parameter for overshoot [-]"),
IOP("vovers", HSMHV_MOD_VOVERS, IF_REAL, "Parameter for overshoot [-]"),
IOP("voversp", HSMHV_MOD_VOVERSP, IF_REAL, "Parameter for overshoot [-]"),
IOP("wfc", HSMHV_MOD_WFC, IF_REAL, "Parameter for narrow channel effect [m*F/(cm^2)]"),
IOP("nsubcw", HSMHV_MOD_NSUBCW, IF_REAL, "Parameter for narrow channel effect "),
IOP("nsubcwp", HSMHV_MOD_NSUBCWP, IF_REAL, "Parameter for narrow channel effect "),
IOP("qme1", HSMHV_MOD_QME1, IF_REAL, "Parameter for quantum effect [mV]"),
IOP("qme2", HSMHV_MOD_QME2, IF_REAL, "Parameter for quantum effect [V]"),
IOP("qme3", HSMHV_MOD_QME3, IF_REAL, "Parameter for quantum effect [m]"),
IOP("gidl1", HSMHV_MOD_GIDL1, IF_REAL, "Parameter for GIDL [?]"),
IOP("gidl2", HSMHV_MOD_GIDL2, IF_REAL, "Parameter for GIDL [?]"),
IOP("gidl3", HSMHV_MOD_GIDL3, IF_REAL, "Parameter for GIDL [?]"),
IOP("gidl4", HSMHV_MOD_GIDL4, IF_REAL, "Parameter for GIDL [?]"),
IOP("gidl5", HSMHV_MOD_GIDL5, IF_REAL, "Parameter for GIDL [?]"),
IOP("glpart1", HSMHV_MOD_GLPART1, IF_REAL, "Parameter for gate current [-]"),
IOP("gleak1", HSMHV_MOD_GLEAK1, IF_REAL, "Parameter for gate current [A*V^(-3/2)/C]"),
IOP("gleak2", HSMHV_MOD_GLEAK2, IF_REAL, "Parameter for gate current [V^(-1/2)/m ]"),
IOP("gleak3", HSMHV_MOD_GLEAK3, IF_REAL, "Parameter for gate current [-]"),
IOP("gleak4", HSMHV_MOD_GLEAK4, IF_REAL, "Parameter for gate current [1/m]"),
IOP("gleak5", HSMHV_MOD_GLEAK5, IF_REAL, "Parameter for gate current [V/m]"),
IOP("gleak6", HSMHV_MOD_GLEAK6, IF_REAL, "Parameter for gate current [V]"),
IOP("gleak7", HSMHV_MOD_GLEAK7, IF_REAL, "Parameter for gate current [m^2]"),
IOP("glksd1", HSMHV_MOD_GLKSD1, IF_REAL, "Parameter for gate current [A*m/V^2]"),
IOP("glksd2", HSMHV_MOD_GLKSD2, IF_REAL, "Parameter for gate current [1/(V*m)]"),
IOP("glksd3", HSMHV_MOD_GLKSD3, IF_REAL, "Parameter for gate current [1/m]"),
IOP("glkb1", HSMHV_MOD_GLKB1, IF_REAL, "Parameter for gate current [A/V^2]"),
IOP("glkb2", HSMHV_MOD_GLKB2, IF_REAL, "Parameter for gate current [m/V]"),
IOP("glkb3", HSMHV_MOD_GLKB3, IF_REAL, "Parameter for gate current [V]"),
IOP("egig", HSMHV_MOD_EGIG, IF_REAL, "Parameter for gate current [V]"),
IOP("igtemp2", HSMHV_MOD_IGTEMP2, IF_REAL, "Parameter for gate current [V*k]"),
IOP("igtemp3", HSMHV_MOD_IGTEMP3, IF_REAL, "Parameter for gate current [V*k^2]"),
IOP("vzadd0", HSMHV_MOD_VZADD0, IF_REAL, "Vzadd at Vds=0 [V]"),
IOP("pzadd0", HSMHV_MOD_PZADD0, IF_REAL, "Pzadd at Vds=0 [V]"),
IOP("nftrp", HSMHV_MOD_NFTRP, IF_REAL, ""),
IOP("nfalp", HSMHV_MOD_NFALP, IF_REAL, ""),
IOP("cit", HSMHV_MOD_CIT, IF_REAL, ""),
IOP("falph", HSMHV_MOD_FALPH, IF_REAL, "Parameter for 1/f noise"),
IOP("kappa", HSMHV_MOD_KAPPA, IF_REAL, "Dielectric constant for high-k stacked gate"),
IOP("pthrou", HSMHV_MOD_PTHROU, IF_REAL, "Modify subthreshold slope [-]"),
IOP("vdiffj", HSMHV_MOD_VDIFFJ, IF_REAL, "Threshold voltage for S/D junction diode [V]"),
IOP("dly1", HSMHV_MOD_DLY1, IF_REAL, "Parameter for transit time [-]"),
IOP("dly2", HSMHV_MOD_DLY2, IF_REAL, "Parameter for transit time [-]"),
IOP("dly3", HSMHV_MOD_DLY3, IF_REAL, "Parameter for transforming bulk charge [s/F]"),
IOP("dlyov", HSMHV_MOD_DLYOV, IF_REAL, "Parameter for transforming overlap charge [s/F]"), /* not used */
IOP("tnom", HSMHV_MOD_TNOM, IF_REAL, "Nominal temperature [K]"),
IOP("ovslp", HSMHV_MOD_OVSLP, IF_REAL, ""),
IOP("ovmag", HSMHV_MOD_OVMAG, IF_REAL, ""),
IOP("gbmin", HSMHV_MOD_GBMIN, IF_REAL, ""),
IOP("rbpb", HSMHV_MOD_RBPB, IF_REAL, ""),
IOP("rbpd", HSMHV_MOD_RBPD, IF_REAL, ""), /* not used */
IOP("rbps", HSMHV_MOD_RBPS, IF_REAL, ""), /* not used */
IOP("rbdb", HSMHV_MOD_RBDB, IF_REAL, ""),
IOP("rbsb", HSMHV_MOD_RBSB, IF_REAL, ""),
IOP("ibpc1", HSMHV_MOD_IBPC1, IF_REAL, "Parameter for impact-ionization induced bulk potential change"),
IOP("ibpc2", HSMHV_MOD_IBPC2, IF_REAL, "Parameter for impact-ionization induced bulk potential change"),
IOP("mphdfm", HSMHV_MOD_MPHDFM, IF_REAL, "NSUBCDFM dependence of phonon scattering for DFM"),
IOP("rdvg11", HSMHV_MOD_RDVG11, IF_REAL, ""),
IOP("rdvg12", HSMHV_MOD_RDVG12, IF_REAL, ""),
IOP("rth0", HSMHV_MOD_RTH0, IF_REAL, "Thermal resistance"), /* Self-heating model --SHE---*/
IOP("cth0", HSMHV_MOD_CTH0, IF_REAL, "Thermal capacitance"), /* Self-heating model --SHE--- */
IOP("powrat", HSMHV_MOD_POWRAT, IF_REAL, ""), /* Self-heating model --SHE--- */
IOP("rthtemp1", HSMHV_MOD_RTHTEMP1, IF_REAL, "Thermal resistance"), /* Self-heating model --SHE---*/
IOP("rthtemp2", HSMHV_MOD_RTHTEMP2, IF_REAL, "Thermal resistance"), /* Self-heating model --SHE---*/
IOP("prattemp1", HSMHV_MOD_PRATTEMP1, IF_REAL, ""), /* Self-heating model --SHE--- */
IOP("prattemp2", HSMHV_MOD_PRATTEMP2, IF_REAL, ""), /* Self-heating model --SHE--- */
IOP("tcjbd", HSMHV_MOD_TCJBD, IF_REAL, "Temperature dependence of cjbd"), /* Self-heating model --SHE--- */
IOP("tcjbs", HSMHV_MOD_TCJBS, IF_REAL, "Temperature dependence of cjbs"), /* Self-heating model --SHE--- */
IOP("tcjbdsw", HSMHV_MOD_TCJBDSW, IF_REAL, "Temperature dependence of cjbdsw"), /* Self-heating model --SHE--- */
IOP("tcjbssw", HSMHV_MOD_TCJBSSW, IF_REAL, "Temperature dependence of cjbssw"), /* Self-heating model --SHE--- */
IOP("tcjbdswg", HSMHV_MOD_TCJBDSWG, IF_REAL, "Temperature dependence of cjbdswg"), /* Self-heating model --SHE--- */
IOP("tcjbsswg", HSMHV_MOD_TCJBSSWG, IF_REAL, "Temperature dependence of cjbsswg"), /* Self-heating model --SHE--- */
IOP("qdftvd", HSMHV_MOD_QDFTVD, IF_REAL, "Qdrift Vd dependence "),
IOP("rdvd", HSMHV_MOD_RDVD, IF_REAL, ""),
IOP("rdvb", HSMHV_MOD_RDVB, IF_REAL, ""),
IOP("rd20", HSMHV_MOD_RD20, IF_REAL, ""),
IOP("rd21", HSMHV_MOD_RD21, IF_REAL, ""),
IOP("rd22", HSMHV_MOD_RD22, IF_REAL, ""),
IOP("rd22d", HSMHV_MOD_RD22D, IF_REAL, ""),
IOP("rd23", HSMHV_MOD_RD23, IF_REAL, ""),
IOP("rd24", HSMHV_MOD_RD24, IF_REAL, ""),
IOP("rd25", HSMHV_MOD_RD25, IF_REAL, ""),
IOP("rd26", HSMHV_MOD_RD26, IF_REAL, "alias for qovsm"),
IOP("rdvdl", HSMHV_MOD_RDVDL, IF_REAL, ""),
IOP("rdvdlp", HSMHV_MOD_RDVDLP, IF_REAL, ""),
IOP("rdvds", HSMHV_MOD_RDVDS, IF_REAL, ""),
IOP("rdvdsp", HSMHV_MOD_RDVDSP, IF_REAL, ""),
IOP("rd23l", HSMHV_MOD_RD23L, IF_REAL, ""),
IOP("rd23lp", HSMHV_MOD_RD23LP, IF_REAL, ""),
IOP("rd23s", HSMHV_MOD_RD23S, IF_REAL, ""),
IOP("rd23sp", HSMHV_MOD_RD23SP, IF_REAL, ""),
IOP("rds", HSMHV_MOD_RDS, IF_REAL, ""),
IOP("rdsp", HSMHV_MOD_RDSP, IF_REAL, ""),
IOP("qovsm", HSMHV_MOD_QOVSM, IF_REAL, "Smoothing Qover at depletion/inversion transition"),
IOP("ldrift", HSMHV_MOD_LDRIFT, IF_REAL, "alias for ldrift2"),
IOP("rdtemp1", HSMHV_MOD_RDTEMP1, IF_REAL, "Temperature-dependence of Rd"),
IOP("rdtemp2", HSMHV_MOD_RDTEMP2, IF_REAL, "Temperature-dependence of Rd"),
IOP("rth0r", HSMHV_MOD_RTH0R, IF_REAL, "Heat radiation for SHE"), /* not used */
IOP("rdvdtemp1", HSMHV_MOD_RDVDTEMP1, IF_REAL, "Temperature-dependence of RDVD"),
IOP("rdvdtemp2", HSMHV_MOD_RDVDTEMP2, IF_REAL, "Temperature-dependence of RDVD"),
IOP("rth0w", HSMHV_MOD_RTH0W, IF_REAL, "Width-dependence of RTH0"),
IOP("rth0wp", HSMHV_MOD_RTH0WP, IF_REAL, "Width-dependence of RTH0"),
IOP("rth0nf", HSMHV_MOD_RTH0NF, IF_REAL, "nf-dependence of RTH0"),
IOP("cvdsover", HSMHV_MOD_CVDSOVER, IF_REAL, "vds drop along the overlap"),
IOP("rdvsub", HSMHV_MOD_RDVSUB, IF_REAL, "model parameter for the substrate effect"),
IOP("rdvdsub", HSMHV_MOD_RDVDSUB, IF_REAL, "model parameter for the substrate effect"),
IOP("ddrift", HSMHV_MOD_DDRIFT, IF_REAL, "model parameter for the substrate effect"),
IOP("vbisub", HSMHV_MOD_VBISUB, IF_REAL, "model parameter for the substrate effect"),
IOP("nsubsub", HSMHV_MOD_NSUBSUB, IF_REAL, "model parameter for the substrate effect"),
IOP("shemax", HSMHV_MOD_SHEMAX, IF_REAL, "Maximum rise temperatue for SHE [C]"),
/* binning parameters */
IOP("lmin", HSMHV_MOD_LMIN, IF_REAL, "Minimum length for the model"),
IOP("lmax", HSMHV_MOD_LMAX, IF_REAL, "Maximum length for the model"),
IOP("wmin", HSMHV_MOD_WMIN, IF_REAL, "Minimum width for the model"),
IOP("wmax", HSMHV_MOD_WMAX, IF_REAL, "Maximum width for the model"),
IOP("lbinn", HSMHV_MOD_LBINN, IF_REAL, "L modulation coefficient for binning"),
IOP("wbinn", HSMHV_MOD_WBINN, IF_REAL, "W modulation coefficient for binning"),
/* Length dependence */
IOP("lvmax", HSMHV_MOD_LVMAX, IF_REAL, "Length dependence of vmax"),
IOP("lbgtmp1", HSMHV_MOD_LBGTMP1, IF_REAL, "Length dependence of bgtmp1"),
IOP("lbgtmp2", HSMHV_MOD_LBGTMP2, IF_REAL, "Length dependence of bgtmp2"),
IOP("leg0", HSMHV_MOD_LEG0, IF_REAL, "Length dependence of eg0"),
IOP("lvfbover", HSMHV_MOD_LVFBOVER, IF_REAL, "Length dependence of vfbover"),
IOP("lnover", HSMHV_MOD_LNOVER, IF_REAL, "Length dependence of nover"),
IOP("lnovers", HSMHV_MOD_LNOVERS, IF_REAL, "Length dependence of nover on source size"),
IOP("lwl2", HSMHV_MOD_LWL2, IF_REAL, "Length dependence of wl2"),
IOP("lvfbc", HSMHV_MOD_LVFBC, IF_REAL, "Length dependence of vfbc"),
IOP("lnsubc", HSMHV_MOD_LNSUBC, IF_REAL, "Length dependence of nsubc"),
IOP("lnsubp", HSMHV_MOD_LNSUBP, IF_REAL, "Length dependence of nsubp"),
IOP("lscp1", HSMHV_MOD_LSCP1, IF_REAL, "Length dependence of scp1"),
IOP("lscp2", HSMHV_MOD_LSCP2, IF_REAL, "Length dependence of scp2"),
IOP("lscp3", HSMHV_MOD_LSCP3, IF_REAL, "Length dependence of scp3"),
IOP("lsc1", HSMHV_MOD_LSC1, IF_REAL, "Length dependence of sc1"),
IOP("lsc2", HSMHV_MOD_LSC2, IF_REAL, "Length dependence of sc2"),
IOP("lsc3", HSMHV_MOD_LSC3, IF_REAL, "Length dependence of sc3"),
IOP("lpgd1", HSMHV_MOD_LPGD1, IF_REAL, "Length dependence of pgd1"),
IOP("lpgd3", HSMHV_MOD_LPGD3, IF_REAL, "Length dependence of pgd3"),
IOP("lndep", HSMHV_MOD_LNDEP, IF_REAL, "Length dependence of ndep"),
IOP("lninv", HSMHV_MOD_LNINV, IF_REAL, "Length dependence of ninv"),
IOP("lmuecb0", HSMHV_MOD_LMUECB0, IF_REAL, "Length dependence of muecb0"),
IOP("lmuecb1", HSMHV_MOD_LMUECB1, IF_REAL, "Length dependence of muecb1"),
IOP("lmueph1", HSMHV_MOD_LMUEPH1, IF_REAL, "Length dependence of mueph1"),
IOP("lvtmp", HSMHV_MOD_LVTMP, IF_REAL, "Length dependence of vtmp"),
IOP("lwvth0", HSMHV_MOD_LWVTH0, IF_REAL, "Length dependence of wvth0"),
IOP("lmuesr1", HSMHV_MOD_LMUESR1, IF_REAL, "Length dependence of muesr1"),
IOP("lmuetmp", HSMHV_MOD_LMUETMP, IF_REAL, "Length dependence of muetmp"),
IOP("lsub1", HSMHV_MOD_LSUB1, IF_REAL, "Length dependence of sub1"),
IOP("lsub2", HSMHV_MOD_LSUB2, IF_REAL, "Length dependence of sub2"),
IOP("lsvds", HSMHV_MOD_LSVDS, IF_REAL, "Length dependence of svds"),
IOP("lsvbs", HSMHV_MOD_LSVBS, IF_REAL, "Length dependence of svbs"),
IOP("lsvgs", HSMHV_MOD_LSVGS, IF_REAL, "Length dependence of svgs"),
IOP("lfn1", HSMHV_MOD_LFN1, IF_REAL, "Length dependence of fn1"),
IOP("lfn2", HSMHV_MOD_LFN2, IF_REAL, "Length dependence of fn2"),
IOP("lfn3", HSMHV_MOD_LFN3, IF_REAL, "Length dependence of fn3"),
IOP("lfvbs", HSMHV_MOD_LFVBS, IF_REAL, "Length dependence of fvbs"),
IOP("lnsti", HSMHV_MOD_LNSTI, IF_REAL, "Length dependence of nsti"),
IOP("lwsti", HSMHV_MOD_LWSTI, IF_REAL, "Length dependence of wsti"),
IOP("lscsti1", HSMHV_MOD_LSCSTI1, IF_REAL, "Length dependence of scsti1"),
IOP("lscsti2", HSMHV_MOD_LSCSTI2, IF_REAL, "Length dependence of scsti2"),
IOP("lvthsti", HSMHV_MOD_LVTHSTI, IF_REAL, "Length dependence of vthsti"),
IOP("lmuesti1", HSMHV_MOD_LMUESTI1, IF_REAL, "Length dependence of muesti1"),
IOP("lmuesti2", HSMHV_MOD_LMUESTI2, IF_REAL, "Length dependence of muesti2"),
IOP("lmuesti3", HSMHV_MOD_LMUESTI3, IF_REAL, "Length dependence of muesti3"),
IOP("lnsubpsti1", HSMHV_MOD_LNSUBPSTI1, IF_REAL, "Length dependence of nsubpsti1"),
IOP("lnsubpsti2", HSMHV_MOD_LNSUBPSTI2, IF_REAL, "Length dependence of nsubpsti2"),
IOP("lnsubpsti3", HSMHV_MOD_LNSUBPSTI3, IF_REAL, "Length dependence of nsubpsti3"),
IOP("lcgso", HSMHV_MOD_LCGSO, IF_REAL, "Length dependence of cgso"),
IOP("lcgdo", HSMHV_MOD_LCGDO, IF_REAL, "Length dependence of cgdo"),
IOP("ljs0", HSMHV_MOD_LJS0, IF_REAL, "Length dependence of js0"),
IOP("ljs0sw", HSMHV_MOD_LJS0SW, IF_REAL, "Length dependence of js0sw"),
IOP("lnj", HSMHV_MOD_LNJ, IF_REAL, "Length dependence of nj"),
IOP("lcisbk", HSMHV_MOD_LCISBK, IF_REAL, "Length dependence of cisbk"),
IOP("lclm1", HSMHV_MOD_LCLM1, IF_REAL, "Length dependence of clm1"),
IOP("lclm2", HSMHV_MOD_LCLM2, IF_REAL, "Length dependence of clm2"),
IOP("lclm3", HSMHV_MOD_LCLM3, IF_REAL, "Length dependence of clm3"),
IOP("lwfc", HSMHV_MOD_LWFC, IF_REAL, "Length dependence of wfc"),
IOP("lgidl1", HSMHV_MOD_LGIDL1, IF_REAL, "Length dependence of gidl1"),
IOP("lgidl2", HSMHV_MOD_LGIDL2, IF_REAL, "Length dependence of gidl2"),
IOP("lgleak1", HSMHV_MOD_LGLEAK1, IF_REAL, "Length dependence of gleak1"),
IOP("lgleak2", HSMHV_MOD_LGLEAK2, IF_REAL, "Length dependence of gleak2"),
IOP("lgleak3", HSMHV_MOD_LGLEAK3, IF_REAL, "Length dependence of gleak3"),
IOP("lgleak6", HSMHV_MOD_LGLEAK6, IF_REAL, "Length dependence of gleak6"),
IOP("lglksd1", HSMHV_MOD_LGLKSD1, IF_REAL, "Length dependence of glksd1"),
IOP("lglksd2", HSMHV_MOD_LGLKSD2, IF_REAL, "Length dependence of glksd2"),
IOP("lglkb1", HSMHV_MOD_LGLKB1, IF_REAL, "Length dependence of glkb1"),
IOP("lglkb2", HSMHV_MOD_LGLKB2, IF_REAL, "Length dependence of glkb2"),
IOP("lnftrp", HSMHV_MOD_LNFTRP, IF_REAL, "Length dependence of nftrp"),
IOP("lnfalp", HSMHV_MOD_LNFALP, IF_REAL, "Length dependence of nfalp"),
IOP("lpthrou", HSMHV_MOD_LPTHROU, IF_REAL, "Length dependence of pthrou"),
IOP("lvdiffj", HSMHV_MOD_LVDIFFJ, IF_REAL, "Length dependence of vdiffj"),
IOP("libpc1", HSMHV_MOD_LIBPC1, IF_REAL, "Length dependence of ibpc1"),
IOP("libpc2", HSMHV_MOD_LIBPC2, IF_REAL, "Length dependence of ibpc2"),
IOP("lcgbo", HSMHV_MOD_LCGBO, IF_REAL, "Length dependence of cgbo"),
IOP("lcvdsover", HSMHV_MOD_LCVDSOVER, IF_REAL, "Length dependence of cvdsover"),
IOP("lfalph", HSMHV_MOD_LFALPH, IF_REAL, "Length dependence of falph"),
IOP("lnpext", HSMHV_MOD_LNPEXT, IF_REAL, "Length dependence of npext"),
IOP("lpowrat", HSMHV_MOD_LPOWRAT, IF_REAL, "Length dependence of powrat"),
IOP("lrd", HSMHV_MOD_LRD, IF_REAL, "Length dependence of rd"),
IOP("lrd22", HSMHV_MOD_LRD22, IF_REAL, "Length dependence of rd22"),
IOP("lrd23", HSMHV_MOD_LRD23, IF_REAL, "Length dependence of rd23"),
IOP("lrd24", HSMHV_MOD_LRD24, IF_REAL, "Length dependence of rd24"),
IOP("lrdict1", HSMHV_MOD_LRDICT1, IF_REAL, "Length dependence of rdict1"),
IOP("lrdov13", HSMHV_MOD_LRDOV13, IF_REAL, "Length dependence of rdov13"),
IOP("lrdslp1", HSMHV_MOD_LRDSLP1, IF_REAL, "Length dependence of rdslp1"),
IOP("lrdvb", HSMHV_MOD_LRDVB, IF_REAL, "Length dependence of rdvb"),
IOP("lrdvd", HSMHV_MOD_LRDVD, IF_REAL, "Length dependence of rdvd"),
IOP("lrdvg11", HSMHV_MOD_LRDVG11, IF_REAL, "Length dependence of rdvg11"),
IOP("lrs", HSMHV_MOD_LRS, IF_REAL, "Length dependence of rs"),
IOP("lrth0", HSMHV_MOD_LRTH0, IF_REAL, "Length dependence of rth0"),
IOP("lvover", HSMHV_MOD_LVOVER, IF_REAL, "Length dependence of vover"),
/* Width dependence */
IOP("wvmax", HSMHV_MOD_WVMAX, IF_REAL, "Width dependence of vmax"),
IOP("wbgtmp1", HSMHV_MOD_WBGTMP1, IF_REAL, "Width dependence of bgtmp1"),
IOP("wbgtmp2", HSMHV_MOD_WBGTMP2, IF_REAL, "Width dependence of bgtmp2"),
IOP("weg0", HSMHV_MOD_WEG0, IF_REAL, "Width dependence of eg0"),
IOP("wvfbover", HSMHV_MOD_WVFBOVER, IF_REAL, "Width dependence of vfbover"),
IOP("wnover", HSMHV_MOD_WNOVER, IF_REAL, "Width dependence of nover"),
IOP("wnovers", HSMHV_MOD_WNOVERS, IF_REAL, "Width dependence of novers on source size"),
IOP("wwl2", HSMHV_MOD_WWL2, IF_REAL, "Width dependence of wl2"),
IOP("wvfbc", HSMHV_MOD_WVFBC, IF_REAL, "Width dependence of vfbc"),
IOP("wnsubc", HSMHV_MOD_WNSUBC, IF_REAL, "Width dependence of nsubc"),
IOP("wnsubp", HSMHV_MOD_WNSUBP, IF_REAL, "Width dependence of nsubp"),
IOP("wscp1", HSMHV_MOD_WSCP1, IF_REAL, "Width dependence of scp1"),
IOP("wscp2", HSMHV_MOD_WSCP2, IF_REAL, "Width dependence of scp2"),
IOP("wscp3", HSMHV_MOD_WSCP3, IF_REAL, "Width dependence of scp3"),
IOP("wsc1", HSMHV_MOD_WSC1, IF_REAL, "Width dependence of sc1"),
IOP("wsc2", HSMHV_MOD_WSC2, IF_REAL, "Width dependence of sc2"),
IOP("wsc3", HSMHV_MOD_WSC3, IF_REAL, "Width dependence of sc3"),
IOP("wpgd1", HSMHV_MOD_WPGD1, IF_REAL, "Width dependence of pgd1"),
IOP("wpgd3", HSMHV_MOD_WPGD3, IF_REAL, "Width dependence of pgd3"),
IOP("wndep", HSMHV_MOD_WNDEP, IF_REAL, "Width dependence of ndep"),
IOP("wninv", HSMHV_MOD_WNINV, IF_REAL, "Width dependence of ninv"),
IOP("wmuecb0", HSMHV_MOD_WMUECB0, IF_REAL, "Width dependence of muecb0"),
IOP("wmuecb1", HSMHV_MOD_WMUECB1, IF_REAL, "Width dependence of muecb1"),
IOP("wmueph1", HSMHV_MOD_WMUEPH1, IF_REAL, "Width dependence of mueph1"),
IOP("wvtmp", HSMHV_MOD_WVTMP, IF_REAL, "Width dependence of vtmp"),
IOP("wwvth0", HSMHV_MOD_WWVTH0, IF_REAL, "Width dependence of wvth0"),
IOP("wmuesr1", HSMHV_MOD_WMUESR1, IF_REAL, "Width dependence of muesr1"),
IOP("wmuetmp", HSMHV_MOD_WMUETMP, IF_REAL, "Width dependence of muetmp"),
IOP("wsub1", HSMHV_MOD_WSUB1, IF_REAL, "Width dependence of sub1"),
IOP("wsub2", HSMHV_MOD_WSUB2, IF_REAL, "Width dependence of sub2"),
IOP("wsvds", HSMHV_MOD_WSVDS, IF_REAL, "Width dependence of svds"),
IOP("wsvbs", HSMHV_MOD_WSVBS, IF_REAL, "Width dependence of svbs"),
IOP("wsvgs", HSMHV_MOD_WSVGS, IF_REAL, "Width dependence of svgs"),
IOP("wfn1", HSMHV_MOD_WFN1, IF_REAL, "Width dependence of fn1"),
IOP("wfn2", HSMHV_MOD_WFN2, IF_REAL, "Width dependence of fn2"),
IOP("wfn3", HSMHV_MOD_WFN3, IF_REAL, "Width dependence of fn3"),
IOP("wfvbs", HSMHV_MOD_WFVBS, IF_REAL, "Width dependence of fvbs"),
IOP("wnsti", HSMHV_MOD_WNSTI, IF_REAL, "Width dependence of nsti"),
IOP("wwsti", HSMHV_MOD_WWSTI, IF_REAL, "Width dependence of wsti"),
IOP("wscsti1", HSMHV_MOD_WSCSTI1, IF_REAL, "Width dependence of scsti1"),
IOP("wscsti2", HSMHV_MOD_WSCSTI2, IF_REAL, "Width dependence of scsti2"),
IOP("wvthsti", HSMHV_MOD_WVTHSTI, IF_REAL, "Width dependence of vthsti"),
IOP("wmuesti1", HSMHV_MOD_WMUESTI1, IF_REAL, "Width dependence of muesti1"),
IOP("wmuesti2", HSMHV_MOD_WMUESTI2, IF_REAL, "Width dependence of muesti2"),
IOP("wmuesti3", HSMHV_MOD_WMUESTI3, IF_REAL, "Width dependence of muesti3"),
IOP("wnsubpsti1", HSMHV_MOD_WNSUBPSTI1, IF_REAL, "Width dependence of nsubpsti1"),
IOP("wnsubpsti2", HSMHV_MOD_WNSUBPSTI2, IF_REAL, "Width dependence of nsubpsti2"),
IOP("wnsubpsti3", HSMHV_MOD_WNSUBPSTI3, IF_REAL, "Width dependence of nsubpsti3"),
IOP("wcgso", HSMHV_MOD_WCGSO, IF_REAL, "Width dependence of cgso"),
IOP("wcgdo", HSMHV_MOD_WCGDO, IF_REAL, "Width dependence of cgdo"),
IOP("wjs0", HSMHV_MOD_WJS0, IF_REAL, "Width dependence of js0"),
IOP("wjs0sw", HSMHV_MOD_WJS0SW, IF_REAL, "Width dependence of js0sw"),
IOP("wnj", HSMHV_MOD_WNJ, IF_REAL, "Width dependence of nj"),
IOP("wcisbk", HSMHV_MOD_WCISBK, IF_REAL, "Width dependence of cisbk"),
IOP("wclm1", HSMHV_MOD_WCLM1, IF_REAL, "Width dependence of clm1"),
IOP("wclm2", HSMHV_MOD_WCLM2, IF_REAL, "Width dependence of clm2"),
IOP("wclm3", HSMHV_MOD_WCLM3, IF_REAL, "Width dependence of clm3"),
IOP("wwfc", HSMHV_MOD_WWFC, IF_REAL, "Width dependence of wfc"),
IOP("wgidl1", HSMHV_MOD_WGIDL1, IF_REAL, "Width dependence of gidl1"),
IOP("wgidl2", HSMHV_MOD_WGIDL2, IF_REAL, "Width dependence of gidl2"),
IOP("wgleak1", HSMHV_MOD_WGLEAK1, IF_REAL, "Width dependence of gleak1"),
IOP("wgleak2", HSMHV_MOD_WGLEAK2, IF_REAL, "Width dependence of gleak2"),
IOP("wgleak3", HSMHV_MOD_WGLEAK3, IF_REAL, "Width dependence of gleak3"),
IOP("wgleak6", HSMHV_MOD_WGLEAK6, IF_REAL, "Width dependence of gleak6"),
IOP("wglksd1", HSMHV_MOD_WGLKSD1, IF_REAL, "Width dependence of glksd1"),
IOP("wglksd2", HSMHV_MOD_WGLKSD2, IF_REAL, "Width dependence of glksd2"),
IOP("wglkb1", HSMHV_MOD_WGLKB1, IF_REAL, "Width dependence of glkb1"),
IOP("wglkb2", HSMHV_MOD_WGLKB2, IF_REAL, "Width dependence of glkb2"),
IOP("wnftrp", HSMHV_MOD_WNFTRP, IF_REAL, "Width dependence of nftrp"),
IOP("wnfalp", HSMHV_MOD_WNFALP, IF_REAL, "Width dependence of nfalp"),
IOP("wpthrou", HSMHV_MOD_WPTHROU, IF_REAL, "Width dependence of pthrou"),
IOP("wvdiffj", HSMHV_MOD_WVDIFFJ, IF_REAL, "Width dependence of vdiffj"),
IOP("wibpc1", HSMHV_MOD_WIBPC1, IF_REAL, "Width dependence of ibpc1"),
IOP("wibpc2", HSMHV_MOD_WIBPC2, IF_REAL, "Width dependence of ibpc2"),
IOP("wcgbo", HSMHV_MOD_WCGBO, IF_REAL, "Width dependence of cgbo"),
IOP("wcvdsover", HSMHV_MOD_WCVDSOVER, IF_REAL, "Width dependence of cvdsover"),
IOP("wfalph", HSMHV_MOD_WFALPH, IF_REAL, "Width dependence of falph"),
IOP("wnpext", HSMHV_MOD_WNPEXT, IF_REAL, "Width dependence of npext"),
IOP("wpowrat", HSMHV_MOD_WPOWRAT, IF_REAL, "Width dependence of powrat"),
IOP("wrd", HSMHV_MOD_WRD, IF_REAL, "Width dependence of rd"),
IOP("wrd22", HSMHV_MOD_WRD22, IF_REAL, "Width dependence of rd22"),
IOP("wrd23", HSMHV_MOD_WRD23, IF_REAL, "Width dependence of rd23"),
IOP("wrd24", HSMHV_MOD_WRD24, IF_REAL, "Width dependence of rd24"),
IOP("wrdict1", HSMHV_MOD_WRDICT1, IF_REAL, "Width dependence of rdict1"),
IOP("wrdov13", HSMHV_MOD_WRDOV13, IF_REAL, "Width dependence of rdov13"),
IOP("wrdslp1", HSMHV_MOD_WRDSLP1, IF_REAL, "Width dependence of rdslp1"),
IOP("wrdvb", HSMHV_MOD_WRDVB, IF_REAL, "Width dependence of rdvb"),
IOP("wrdvd", HSMHV_MOD_WRDVD, IF_REAL, "Width dependence of rdvd"),
IOP("wrdvg11", HSMHV_MOD_WRDVG11, IF_REAL, "Width dependence of rdvg11"),
IOP("wrs", HSMHV_MOD_WRS, IF_REAL, "Width dependence of rs"),
IOP("wrth0", HSMHV_MOD_WRTH0, IF_REAL, "Width dependence of rth0"),
IOP("wvover", HSMHV_MOD_WVOVER, IF_REAL, "Width dependence of vover"),
/* Cross-term dependence */
IOP("pvmax", HSMHV_MOD_PVMAX, IF_REAL, "Cross-term dependence of vmax"),
IOP("pbgtmp1", HSMHV_MOD_PBGTMP1, IF_REAL, "Cross-term dependence of bgtmp1"),
IOP("pbgtmp2", HSMHV_MOD_PBGTMP2, IF_REAL, "Cross-term dependence of bgtmp2"),
IOP("peg0", HSMHV_MOD_PEG0, IF_REAL, "Cross-term dependence of eg0"),
IOP("pvfbover", HSMHV_MOD_PVFBOVER, IF_REAL, "Cross-term dependence of vfbover"),
IOP("pnover", HSMHV_MOD_PNOVER, IF_REAL, "Cross-term dependence of nover"),
IOP("pnovers", HSMHV_MOD_PNOVERS, IF_REAL, "Cross-term dependence of nover on source size"),
IOP("pwl2", HSMHV_MOD_PWL2, IF_REAL, "Cross-term dependence of wl2"),
IOP("pvfbc", HSMHV_MOD_PVFBC, IF_REAL, "Cross-term dependence of vfbc"),
IOP("pnsubc", HSMHV_MOD_PNSUBC, IF_REAL, "Cross-term dependence of nsubc"),
IOP("pnsubp", HSMHV_MOD_PNSUBP, IF_REAL, "Cross-term dependence of nsubp"),
IOP("pscp1", HSMHV_MOD_PSCP1, IF_REAL, "Cross-term dependence of scp1"),
IOP("pscp2", HSMHV_MOD_PSCP2, IF_REAL, "Cross-term dependence of scp2"),
IOP("pscp3", HSMHV_MOD_PSCP3, IF_REAL, "Cross-term dependence of scp3"),
IOP("psc1", HSMHV_MOD_PSC1, IF_REAL, "Cross-term dependence of sc1"),
IOP("psc2", HSMHV_MOD_PSC2, IF_REAL, "Cross-term dependence of sc2"),
IOP("psc3", HSMHV_MOD_PSC3, IF_REAL, "Cross-term dependence of sc3"),
IOP("ppgd1", HSMHV_MOD_PPGD1, IF_REAL, "Cross-term dependence of pgd1"),
IOP("ppgd3", HSMHV_MOD_PPGD3, IF_REAL, "Cross-term dependence of pgd3"),
IOP("pndep", HSMHV_MOD_PNDEP, IF_REAL, "Cross-term dependence of ndep"),
IOP("pninv", HSMHV_MOD_PNINV, IF_REAL, "Cross-term dependence of ninv"),
IOP("pmuecb0", HSMHV_MOD_PMUECB0, IF_REAL, "Cross-term dependence of muecb0"),
IOP("pmuecb1", HSMHV_MOD_PMUECB1, IF_REAL, "Cross-term dependence of muecb1"),
IOP("pmueph1", HSMHV_MOD_PMUEPH1, IF_REAL, "Cross-term dependence of mueph1"),
IOP("pvtmp", HSMHV_MOD_PVTMP, IF_REAL, "Cross-term dependence of vtmp"),
IOP("pwvth0", HSMHV_MOD_PWVTH0, IF_REAL, "Cross-term dependence of wvth0"),
IOP("pmuesr1", HSMHV_MOD_PMUESR1, IF_REAL, "Cross-term dependence of muesr1"),
IOP("pmuetmp", HSMHV_MOD_PMUETMP, IF_REAL, "Cross-term dependence of muetmp"),
IOP("psub1", HSMHV_MOD_PSUB1, IF_REAL, "Cross-term dependence of sub1"),
IOP("psub2", HSMHV_MOD_PSUB2, IF_REAL, "Cross-term dependence of sub2"),
IOP("psvds", HSMHV_MOD_PSVDS, IF_REAL, "Cross-term dependence of svds"),
IOP("psvbs", HSMHV_MOD_PSVBS, IF_REAL, "Cross-term dependence of svbs"),
IOP("psvgs", HSMHV_MOD_PSVGS, IF_REAL, "Cross-term dependence of svgs"),
IOP("pfn1", HSMHV_MOD_PFN1, IF_REAL, "Cross-term dependence of fn1"),
IOP("pfn2", HSMHV_MOD_PFN2, IF_REAL, "Cross-term dependence of fn2"),
IOP("pfn3", HSMHV_MOD_PFN3, IF_REAL, "Cross-term dependence of fn3"),
IOP("pfvbs", HSMHV_MOD_PFVBS, IF_REAL, "Cross-term dependence of fvbs"),
IOP("pnsti", HSMHV_MOD_PNSTI, IF_REAL, "Cross-term dependence of nsti"),
IOP("pwsti", HSMHV_MOD_PWSTI, IF_REAL, "Cross-term dependence of wsti"),
IOP("pscsti1", HSMHV_MOD_PSCSTI1, IF_REAL, "Cross-term dependence of scsti1"),
IOP("pscsti2", HSMHV_MOD_PSCSTI2, IF_REAL, "Cross-term dependence of scsti2"),
IOP("pvthsti", HSMHV_MOD_PVTHSTI, IF_REAL, "Cross-term dependence of vthsti"),
IOP("pmuesti1", HSMHV_MOD_PMUESTI1, IF_REAL, "Cross-term dependence of muesti1"),
IOP("pmuesti2", HSMHV_MOD_PMUESTI2, IF_REAL, "Cross-term dependence of muesti2"),
IOP("pmuesti3", HSMHV_MOD_PMUESTI3, IF_REAL, "Cross-term dependence of muesti3"),
IOP("pnsubpsti1", HSMHV_MOD_PNSUBPSTI1, IF_REAL, "Cross-term dependence of nsubpsti1"),
IOP("pnsubpsti2", HSMHV_MOD_PNSUBPSTI2, IF_REAL, "Cross-term dependence of nsubpsti2"),
IOP("pnsubpsti3", HSMHV_MOD_PNSUBPSTI3, IF_REAL, "Cross-term dependence of nsubpsti3"),
IOP("pcgso", HSMHV_MOD_PCGSO, IF_REAL, "Cross-term dependence of cgso"),
IOP("pcgdo", HSMHV_MOD_PCGDO, IF_REAL, "Cross-term dependence of cgdo"),
IOP("pjs0", HSMHV_MOD_PJS0, IF_REAL, "Cross-term dependence of js0"),
IOP("pjs0sw", HSMHV_MOD_PJS0SW, IF_REAL, "Cross-term dependence of js0sw"),
IOP("pnj", HSMHV_MOD_PNJ, IF_REAL, "Cross-term dependence of nj"),
IOP("pcisbk", HSMHV_MOD_PCISBK, IF_REAL, "Cross-term dependence of cisbk"),
IOP("pclm1", HSMHV_MOD_PCLM1, IF_REAL, "Cross-term dependence of clm1"),
IOP("pclm2", HSMHV_MOD_PCLM2, IF_REAL, "Cross-term dependence of clm2"),
IOP("pclm3", HSMHV_MOD_PCLM3, IF_REAL, "Cross-term dependence of clm3"),
IOP("pwfc", HSMHV_MOD_PWFC, IF_REAL, "Cross-term dependence of wfc"),
IOP("pgidl1", HSMHV_MOD_PGIDL1, IF_REAL, "Cross-term dependence of gidl1"),
IOP("pgidl2", HSMHV_MOD_PGIDL2, IF_REAL, "Cross-term dependence of gidl2"),
IOP("pgleak1", HSMHV_MOD_PGLEAK1, IF_REAL, "Cross-term dependence of gleak1"),
IOP("pgleak2", HSMHV_MOD_PGLEAK2, IF_REAL, "Cross-term dependence of gleak2"),
IOP("pgleak3", HSMHV_MOD_PGLEAK3, IF_REAL, "Cross-term dependence of gleak3"),
IOP("pgleak6", HSMHV_MOD_PGLEAK6, IF_REAL, "Cross-term dependence of gleak6"),
IOP("pglksd1", HSMHV_MOD_PGLKSD1, IF_REAL, "Cross-term dependence of glksd1"),
IOP("pglksd2", HSMHV_MOD_PGLKSD2, IF_REAL, "Cross-term dependence of glksd2"),
IOP("pglkb1", HSMHV_MOD_PGLKB1, IF_REAL, "Cross-term dependence of glkb1"),
IOP("pglkb2", HSMHV_MOD_PGLKB2, IF_REAL, "Cross-term dependence of glkb2"),
IOP("pnftrp", HSMHV_MOD_PNFTRP, IF_REAL, "Cross-term dependence of nftrp"),
IOP("pnfalp", HSMHV_MOD_PNFALP, IF_REAL, "Cross-term dependence of nfalp"),
IOP("ppthrou", HSMHV_MOD_PPTHROU, IF_REAL, "Cross-term dependence of pthrou"),
IOP("pvdiffj", HSMHV_MOD_PVDIFFJ, IF_REAL, "Cross-term dependence of vdiffj"),
IOP("pibpc1", HSMHV_MOD_PIBPC1, IF_REAL, "Cross-term dependence of ibpc1"),
IOP("pibpc2", HSMHV_MOD_PIBPC2, IF_REAL, "Cross-term dependence of ibpc2"),
IOP("pcgbo", HSMHV_MOD_PCGBO, IF_REAL, "Cross-term dependence of cgbo"),
IOP("pcvdsover", HSMHV_MOD_PCVDSOVER, IF_REAL, "Cross-term dependence of cvdsover"),
IOP("pfalph", HSMHV_MOD_PFALPH, IF_REAL, "Cross-term dependence of falph"),
IOP("pnpext", HSMHV_MOD_PNPEXT, IF_REAL, "Cross-term dependence of npext"),
IOP("ppowrat", HSMHV_MOD_PPOWRAT, IF_REAL, "Cross-term dependence of powrat"),
IOP("prd", HSMHV_MOD_PRD, IF_REAL, "Cross-term dependence of rd"),
IOP("prd22", HSMHV_MOD_PRD22, IF_REAL, "Cross-term dependence of rd22"),
IOP("prd23", HSMHV_MOD_PRD23, IF_REAL, "Cross-term dependence of rd23"),
IOP("prd24", HSMHV_MOD_PRD24, IF_REAL, "Cross-term dependence of rd24"),
IOP("prdict1", HSMHV_MOD_PRDICT1, IF_REAL, "Cross-term dependence of rdict1"),
IOP("prdov13", HSMHV_MOD_PRDOV13, IF_REAL, "Cross-term dependence of rdov13"),
IOP("prdslp1", HSMHV_MOD_PRDSLP1, IF_REAL, "Cross-term dependence of rdslp1"),
IOP("prdvb", HSMHV_MOD_PRDVB, IF_REAL, "Cross-term dependence of rdvb"),
IOP("prdvd", HSMHV_MOD_PRDVD, IF_REAL, "Cross-term dependence of rdvd"),
IOP("prdvg11", HSMHV_MOD_PRDVG11, IF_REAL, "Cross-term dependence of rdvg11"),
IOP("prs", HSMHV_MOD_PRS, IF_REAL, "Cross-term dependence of rs"),
IOP("prth0", HSMHV_MOD_PRTH0, IF_REAL, "Cross-term dependence of rth0"),
IOP("pvover", HSMHV_MOD_PVOVER, IF_REAL, "Cross-term dependence of vover")
};
char *HSMHVnames[] = {
"Drain",
"Gate",
"Source",
"Bulk",
"Substrate",
"Temp"
};
int HSMHVnSize = NUMELEMS(HSMHVnames);
int HSMHVpTSize = NUMELEMS(HSMHVpTable);
int HSMHVmPTSize = NUMELEMS(HSMHVmPTable);
int HSMHViSize = sizeof(HSMHVinstance);
int HSMHVmSize = sizeof(HSMHVmodel);

295
src/spicelib/devices/hisimhv/hsmhvacld.c Normal file
View File

@ -0,0 +1,295 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvacld.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include <stdio.h>
#include "ngspice.h"
#include "cktdefs.h"
#include "sperror.h"
#include "suffix.h"
#include "hsmhvdef.h"
int HSMHVacLoad(
GENmodel *inModel,
register CKTcircuit *ckt)
{
register HSMHVmodel *model = (HSMHVmodel*)inModel;
register HSMHVinstance *here;
double omega=0.0 ;
int flg_nqs =0 ;
int flg_subNode = 0 ;
#define dNode 0
#define dNodePrime 1
#define gNode 2
#define gNodePrime 3
#define sNode 4
#define sNodePrime 5
#define bNodePrime 6
#define bNode 7
#define dbNode 8
#define sbNode 9
#define subNode 10
#define tempNode 11
#define qiNode 12
#define qbNode 13
omega = ckt->CKTomega;
for ( ; model != NULL; model = model->HSMHVnextModel ) {
for ( here = model->HSMHVinstances; here!= NULL; here = here->HSMHVnextInstance ) {
flg_nqs = model->HSMHV_conqs ;
flg_subNode = here->HSMHVsubNode ; /* if flg_subNode > 0, external(/internal) substrate node exists */
/* stamp matrix */
/*drain*/
*(here->HSMHVDdPtr) += here->HSMHV_ydc_d[dNode] ;
*(here->HSMHVDdPtr +1) += omega*here->HSMHV_ydyn_d[dNode] ;
*(here->HSMHVDdpPtr) += here->HSMHV_ydc_d[dNodePrime] ;
*(here->HSMHVDdpPtr +1) += omega*here->HSMHV_ydyn_d[dNodePrime];
*(here->HSMHVDgpPtr) += here->HSMHV_ydc_d[gNodePrime];
*(here->HSMHVDgpPtr +1) += omega*here->HSMHV_ydyn_d[gNodePrime];
*(here->HSMHVDsPtr) += here->HSMHV_ydc_d[sNode];
*(here->HSMHVDsPtr +1) += omega*here->HSMHV_ydyn_d[sNode];
*(here->HSMHVDbpPtr) += here->HSMHV_ydc_d[bNodePrime];
*(here->HSMHVDbpPtr +1) += omega*here->HSMHV_ydyn_d[bNodePrime];
*(here->HSMHVDdbPtr) += here->HSMHV_ydc_d[dbNode];
*(here->HSMHVDdbPtr +1) += omega*here->HSMHV_ydyn_d[dbNode];
if (flg_subNode > 0) {
*(here->HSMHVDsubPtr) += here->HSMHV_ydc_d[subNode];
}
if( here->HSMHVtempNode > 0) {
*(here->HSMHVDtempPtr) += model->HSMHV_type*here->HSMHV_ydc_d[tempNode];
*(here->HSMHVDtempPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_d[tempNode];
}
/*drain prime*/
*(here->HSMHVDPdPtr) += here->HSMHV_ydc_dP[dNode] ;
*(here->HSMHVDPdPtr +1) += omega*here->HSMHV_ydyn_dP[dNode];
*(here->HSMHVDPdpPtr) += here->HSMHV_ydc_dP[dNodePrime];
*(here->HSMHVDPdpPtr +1) += omega*here->HSMHV_ydyn_dP[dNodePrime];
*(here->HSMHVDPgpPtr) += here->HSMHV_ydc_dP[gNodePrime];
*(here->HSMHVDPgpPtr +1) += omega*here->HSMHV_ydyn_dP[gNodePrime];
*(here->HSMHVDPsPtr) += here->HSMHV_ydc_dP[sNode] ;
*(here->HSMHVDPsPtr +1) += omega*here->HSMHV_ydyn_dP[sNode];
*(here->HSMHVDPspPtr) += here->HSMHV_ydc_dP[sNodePrime] ;
*(here->HSMHVDPspPtr +1) += omega*here->HSMHV_ydyn_dP[sNodePrime];
*(here->HSMHVDPbpPtr) += here->HSMHV_ydc_dP[bNodePrime] ;
*(here->HSMHVDPbpPtr +1) += omega*here->HSMHV_ydyn_dP[bNodePrime];
if (flg_subNode > 0) {
*(here->HSMHVDPsubPtr) += here->HSMHV_ydc_dP[subNode];
}
if( here->HSMHVtempNode > 0) {
*(here->HSMHVDPtempPtr) += model->HSMHV_type*here->HSMHV_ydc_dP[tempNode];
*(here->HSMHVDPtempPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_dP[tempNode];
}
if (flg_nqs) {
*(here->HSMHVDPqiPtr) += model->HSMHV_type*here->HSMHV_ydc_dP[qiNode];
*(here->HSMHVDPqiPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_dP[qiNode];
}
/*gate*/
*(here->HSMHVGgPtr) += here->HSMHV_ydc_g[gNode] ;
*(here->HSMHVGgPtr +1) += omega*here->HSMHV_ydyn_g[gNode];
*(here->HSMHVGgpPtr) += here->HSMHV_ydc_g[gNodePrime] ;
*(here->HSMHVGgpPtr +1) += omega*here->HSMHV_ydyn_g[gNodePrime];
/*gate prime*/
*(here->HSMHVGPdPtr) += here->HSMHV_ydc_gP[dNode] ;
*(here->HSMHVGPdPtr +1) += omega*here->HSMHV_ydyn_gP[dNode];
*(here->HSMHVGPdpPtr) += here->HSMHV_ydc_gP[dNodePrime] ;
*(here->HSMHVGPdpPtr +1) += omega*here->HSMHV_ydyn_gP[dNodePrime];
*(here->HSMHVGPgPtr) += here->HSMHV_ydc_gP[gNode];
*(here->HSMHVGPgPtr +1) += omega*here->HSMHV_ydyn_gP[gNode];
*(here->HSMHVGPgpPtr) += here->HSMHV_ydc_gP[gNodePrime] ;
*(here->HSMHVGPgpPtr +1) += omega*here->HSMHV_ydyn_gP[gNodePrime];
*(here->HSMHVGPsPtr) += here->HSMHV_ydc_gP[sNode];
*(here->HSMHVGPsPtr +1) += omega*here->HSMHV_ydyn_gP[sNode];
*(here->HSMHVGPspPtr) += here->HSMHV_ydc_gP[sNodePrime] ;
*(here->HSMHVGPspPtr +1) += omega*here->HSMHV_ydyn_gP[sNodePrime];
*(here->HSMHVGPbpPtr) += here->HSMHV_ydc_gP[bNodePrime] ;
*(here->HSMHVGPbpPtr +1) += omega*here->HSMHV_ydyn_gP[bNodePrime];
if( here->HSMHVtempNode > 0) {
*(here->HSMHVGPtempPtr) += model->HSMHV_type*here->HSMHV_ydc_gP[tempNode] ;
*(here->HSMHVGPtempPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_gP[tempNode];
}
if (flg_nqs) {
*(here->HSMHVGPqiPtr) += model->HSMHV_type*here->HSMHV_ydc_gP[qiNode];
*(here->HSMHVGPqiPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_gP[qiNode];
*(here->HSMHVGPqbPtr) += model->HSMHV_type*here->HSMHV_ydc_gP[qbNode];
*(here->HSMHVGPqbPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_gP[qbNode];
}
/*source*/
*(here->HSMHVSdPtr) += here->HSMHV_ydc_s[dNode];
*(here->HSMHVSdPtr +1) += omega*here->HSMHV_ydyn_s[dNode];
*(here->HSMHVSgpPtr) += here->HSMHV_ydc_s[gNodePrime];
*(here->HSMHVSgpPtr +1) += omega*here->HSMHV_ydyn_s[gNodePrime];
*(here->HSMHVSsPtr) += here->HSMHV_ydc_s[sNode] ;
*(here->HSMHVSsPtr +1) += omega*here->HSMHV_ydyn_s[sNode];
*(here->HSMHVSspPtr) += here->HSMHV_ydc_s[sNodePrime] ;
*(here->HSMHVSspPtr +1) += omega*here->HSMHV_ydyn_s[sNodePrime];
*(here->HSMHVSbpPtr) += here->HSMHV_ydc_s[bNodePrime];
*(here->HSMHVSbpPtr +1) += omega*here->HSMHV_ydyn_s[bNodePrime];
*(here->HSMHVSsbPtr) += here->HSMHV_ydc_s[sbNode] ;
*(here->HSMHVSsbPtr +1) += omega*here->HSMHV_ydyn_s[sbNode];
if (flg_subNode > 0) {
*(here->HSMHVSsubPtr) += here->HSMHV_ydc_s[subNode];
}
if( here->HSMHVtempNode > 0) {
*(here->HSMHVStempPtr) += model->HSMHV_type*here->HSMHV_ydc_s[tempNode];
*(here->HSMHVStempPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_s[tempNode];
}
/*source prime*/
*(here->HSMHVSPdPtr) += here->HSMHV_ydc_sP[dNode] ;
*(here->HSMHVSPdPtr +1) += omega*here->HSMHV_ydyn_sP[dNode];
*(here->HSMHVSPdpPtr) += here->HSMHV_ydc_sP[dNodePrime] ;
*(here->HSMHVSPdpPtr +1) += omega*here->HSMHV_ydyn_sP[dNodePrime];
*(here->HSMHVSPgpPtr) += here->HSMHV_ydc_sP[gNodePrime] ;
*(here->HSMHVSPgpPtr +1) += omega*here->HSMHV_ydyn_sP[gNodePrime];
*(here->HSMHVSPsPtr) += here->HSMHV_ydc_sP[sNode] ;
*(here->HSMHVSPsPtr +1) += omega*here->HSMHV_ydyn_sP[sNode];
*(here->HSMHVSPspPtr) += here->HSMHV_ydc_sP[sNodePrime] ;
*(here->HSMHVSPspPtr +1) += omega*here->HSMHV_ydyn_sP[sNodePrime];
*(here->HSMHVSPbpPtr) += here->HSMHV_ydc_sP[bNodePrime];
*(here->HSMHVSPbpPtr +1) += omega*here->HSMHV_ydyn_sP[bNodePrime];
if (flg_subNode > 0) {
*(here->HSMHVSPsubPtr) += here->HSMHV_ydc_sP[subNode];
}
if( here->HSMHVtempNode > 0) {
*(here->HSMHVSPtempPtr) += model->HSMHV_type*here->HSMHV_ydc_sP[tempNode] ;
*(here->HSMHVSPtempPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_sP[tempNode];
}
if (flg_nqs) {
*(here->HSMHVSPqiPtr) += model->HSMHV_type*here->HSMHV_ydc_sP[qiNode];
*(here->HSMHVSPqiPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_sP[qiNode];
}
/*bulk prime*/
*(here->HSMHVBPdpPtr) += here->HSMHV_ydc_bP[dNodePrime];
*(here->HSMHVBPdpPtr +1) += omega*here->HSMHV_ydyn_bP[dNodePrime];
*(here->HSMHVBPgpPtr) += here->HSMHV_ydc_bP[gNodePrime] ;
*(here->HSMHVBPgpPtr +1) += omega*here->HSMHV_ydyn_bP[gNodePrime];
*(here->HSMHVBPspPtr) += here->HSMHV_ydc_bP[sNodePrime];
*(here->HSMHVBPspPtr +1) += omega*here->HSMHV_ydyn_bP[sNodePrime];
*(here->HSMHVBPbpPtr) += here->HSMHV_ydc_bP[bNodePrime];
*(here->HSMHVBPbpPtr +1) += omega*here->HSMHV_ydyn_bP[bNodePrime];
*(here->HSMHVBPbPtr) += here->HSMHV_ydc_bP[bNode];
*(here->HSMHVBPbPtr +1) += omega*here->HSMHV_ydyn_bP[bNode];
*(here->HSMHVBPdbPtr) += here->HSMHV_ydc_bP[dbNode] ;
*(here->HSMHVBPdbPtr +1) += omega*here->HSMHV_ydyn_bP[dbNode];
*(here->HSMHVBPsbPtr) += here->HSMHV_ydc_bP[sbNode] ;
*(here->HSMHVBPsbPtr +1) += omega*here->HSMHV_ydyn_bP[sbNode];
if( here->HSMHVtempNode > 0) {
*(here->HSMHVBPtempPtr) += model->HSMHV_type*here->HSMHV_ydc_bP[tempNode] ;
*(here->HSMHVBPtempPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_bP[tempNode];
}
if (flg_nqs) {
*(here->HSMHVBPqbPtr) += model->HSMHV_type*here->HSMHV_ydc_bP[qbNode];
*(here->HSMHVBPqbPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_bP[qbNode];
}
/*bulk*/
*(here->HSMHVBbpPtr) += here->HSMHV_ydc_b[bNodePrime] ;
*(here->HSMHVBbpPtr +1) += omega*here->HSMHV_ydyn_b[bNodePrime];
*(here->HSMHVBbPtr) += here->HSMHV_ydc_b[bNode] ;
*(here->HSMHVBbPtr +1) += omega*here->HSMHV_ydyn_b[bNode];
/*drain bulk*/
*(here->HSMHVDBdPtr) += here->HSMHV_ydc_db[dNode] ;
*(here->HSMHVDBdPtr +1) += omega*here->HSMHV_ydyn_db[dNode];
*(here->HSMHVDBbpPtr) += here->HSMHV_ydc_db[bNodePrime] ;
*(here->HSMHVDBbpPtr +1) += omega*here->HSMHV_ydyn_db[bNodePrime];
*(here->HSMHVDBdbPtr) += here->HSMHV_ydc_db[dbNode] ;
*(here->HSMHVDBdbPtr +1) += omega*here->HSMHV_ydyn_db[dbNode];
if( here->HSMHVtempNode > 0) {
*(here->HSMHVDBtempPtr) += model->HSMHV_type*here->HSMHV_ydc_db[tempNode] ;
*(here->HSMHVDBtempPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_db[tempNode];
}
/*source bulk*/
*(here->HSMHVSBsPtr) += here->HSMHV_ydc_sb[sNode] ;
*(here->HSMHVSBsPtr +1) += omega*here->HSMHV_ydyn_sb[sNode];
*(here->HSMHVSBbpPtr) += here->HSMHV_ydc_sb[bNodePrime];
*(here->HSMHVSBbpPtr +1) += omega*here->HSMHV_ydyn_sb[bNodePrime];
*(here->HSMHVSBsbPtr) += here->HSMHV_ydc_sb[sbNode] ;
*(here->HSMHVSBsbPtr +1) += omega*here->HSMHV_ydyn_sb[sbNode];
if( here->HSMHVtempNode > 0) {
*(here->HSMHVSBtempPtr) += model->HSMHV_type*here->HSMHV_ydc_sb[tempNode];
*(here->HSMHVSBtempPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_sb[tempNode];
}
/*temp*/
if( here->HSMHVtempNode > 0) {
*(here->HSMHVTempdPtr) += model->HSMHV_type*here->HSMHV_ydc_t[dNode] ;
*(here->HSMHVTempdPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_t[dNode];
*(here->HSMHVTempdpPtr) += model->HSMHV_type*here->HSMHV_ydc_t[dNodePrime] ;
*(here->HSMHVTempdpPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_t[dNodePrime];
*(here->HSMHVTempgpPtr) += model->HSMHV_type*here->HSMHV_ydc_t[gNodePrime];
*(here->HSMHVTempgpPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_t[gNodePrime];
*(here->HSMHVTempsPtr) += model->HSMHV_type*here->HSMHV_ydc_t[sNode] ;
*(here->HSMHVTempsPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_t[sNode];
*(here->HSMHVTempspPtr) += model->HSMHV_type*here->HSMHV_ydc_t[sNodePrime] ;
*(here->HSMHVTempspPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_t[sNodePrime];
*(here->HSMHVTempbpPtr) += model->HSMHV_type*here->HSMHV_ydc_t[bNodePrime] ;
*(here->HSMHVTempbpPtr +1) += model->HSMHV_type*omega*here->HSMHV_ydyn_t[bNodePrime];
*(here->HSMHVTemptempPtr) += here->HSMHV_ydc_t[tempNode] ;
*(here->HSMHVTemptempPtr +1) += omega*here->HSMHV_ydyn_t[tempNode];
}
/* additional entries for flat nqs handling */
if ( flg_nqs ) {
/*qi*/
*(here->HSMHVQIdpPtr) += model->HSMHV_type*here->HSMHV_ydc_qi[dNodePrime];
*(here->HSMHVQIdpPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_qi[dNodePrime];
*(here->HSMHVQIgpPtr) += model->HSMHV_type*here->HSMHV_ydc_qi[gNodePrime];
*(here->HSMHVQIgpPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_qi[gNodePrime];
*(here->HSMHVQIspPtr) += model->HSMHV_type*here->HSMHV_ydc_qi[sNodePrime];
*(here->HSMHVQIspPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_qi[sNodePrime];
*(here->HSMHVQIbpPtr) += model->HSMHV_type*here->HSMHV_ydc_qi[bNodePrime];
*(here->HSMHVQIbpPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_qi[bNodePrime];
*(here->HSMHVQIqiPtr) += here->HSMHV_ydc_qi[qiNode];
*(here->HSMHVQIqiPtr+1) += omega*here->HSMHV_ydyn_qi[qiNode];
if ( here->HSMHVtempNode > 0 ) {
*(here->HSMHVQItempPtr) += here->HSMHV_ydc_qi[tempNode];
*(here->HSMHVQItempPtr+1) += omega*here->HSMHV_ydyn_qi[tempNode];
}
/*qb*/
*(here->HSMHVQBdpPtr) += model->HSMHV_type*here->HSMHV_ydc_qb[dNodePrime];
*(here->HSMHVQBdpPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_qb[dNodePrime];
*(here->HSMHVQBgpPtr) += model->HSMHV_type*here->HSMHV_ydc_qb[gNodePrime];
*(here->HSMHVQBgpPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_qb[gNodePrime];
*(here->HSMHVQBspPtr) += model->HSMHV_type*here->HSMHV_ydc_qb[sNodePrime];
*(here->HSMHVQBspPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_qb[sNodePrime];
*(here->HSMHVQBbpPtr) += model->HSMHV_type*here->HSMHV_ydc_qb[bNodePrime];
*(here->HSMHVQBbpPtr+1) += model->HSMHV_type*omega*here->HSMHV_ydyn_qb[bNodePrime];
*(here->HSMHVQBqbPtr) += here->HSMHV_ydc_qb[qbNode];
*(here->HSMHVQBqbPtr+1) += omega*here->HSMHV_ydyn_qb[qbNode];
if ( here->HSMHVtempNode > 0 ) {
*(here->HSMHVQBtempPtr) += here->HSMHV_ydc_qb[tempNode];
*(here->HSMHVQBtempPtr+1) += omega*here->HSMHV_ydyn_qb[tempNode];
}
}
}
}
return(OK);
}

421
src/spicelib/devices/hisimhv/hsmhvask.c Normal file
View File

@ -0,0 +1,421 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvask.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "ifsim.h"
#include "cktdefs.h"
#include "devdefs.h"
#include "hsmhvdef.h"
#include "sperror.h"
#include "suffix.h"
int HSMHVask(
CKTcircuit *ckt,
GENinstance *inst,
int which,
IFvalue *value,
IFvalue *select)
{
HSMHVinstance *here = (HSMHVinstance*)inst;
int flg_nqs ;
double cggb_nqs, cgdb_nqs, cgsb_nqs, cdgb_nqs, cddb_nqs, cdsb_nqs, cbgb_nqs, cbdb_nqs, cbsb_nqs ;
double Qi_nqs, dQi_nqs_dVds, dQi_nqs_dVgs, dQi_nqs_dVbs,
dQb_nqs_dVds, dQb_nqs_dVgs, dQb_nqs_dVbs ;
double Qdrat, dQdrat_dVds, dQdrat_dVgs, dQdrat_dVbs,
dQi_dVds, dQi_dVgs, dQi_dVbs,
dQbulk_dVds, dQbulk_dVgs, dQbulk_dVbs ;
double dQd_nqs_dVds, dQd_nqs_dVgs, dQd_nqs_dVbs, dQd_nqs_dQi_nqs ;
double dQg_nqs_dQi_nqs, dQg_nqs_dQb_nqs ;
here->HSMHV_csdo = - (here->HSMHV_cddo + here->HSMHV_cgdo + here->HSMHV_cbdo) ;
here->HSMHV_csgo = - (here->HSMHV_cdgo + here->HSMHV_cggo + here->HSMHV_cbgo) ;
here->HSMHV_csbo = - (here->HSMHV_cdbo + here->HSMHV_cgbo + here->HSMHV_cbbo) ;
here->HSMHV_cdso = - (here->HSMHV_cddo + here->HSMHV_cdgo + here->HSMHV_cdbo) ;
here->HSMHV_cgso = - (here->HSMHV_cgdo + here->HSMHV_cggo + here->HSMHV_cgbo) ;
here->HSMHV_csso = - (here->HSMHV_csdo + here->HSMHV_csgo + here->HSMHV_csbo) ;
/* NQS? */
if (here->HSMHVQIqiPtr == (double *)NULL) {
flg_nqs = 0 ;
} else {
flg_nqs = 1 ;
}
/* printf("HSMHVask: flg_nqs = %d\n", flg_nqs) ; */
if (flg_nqs) { /* collect data for NQS case (DC operating point only!) */
Qi_nqs = *(ckt->CKTstate0 + here->HSMHVqi_nqs) ;
if ( here->HSMHV_mode > 0 ) { /* forward mode */
Qdrat = here->HSMHV_Xd ;
dQdrat_dVds = here->HSMHV_Xd_dVdsi ;
dQdrat_dVgs = here->HSMHV_Xd_dVgsi ;
dQdrat_dVbs = here->HSMHV_Xd_dVbsi ;
dQi_dVds = here->HSMHV_Qi_dVdsi ;
dQi_dVgs = here->HSMHV_Qi_dVgsi ;
dQi_dVbs = here->HSMHV_Qi_dVbsi ;
dQbulk_dVds = here->HSMHV_Qbulk_dVdsi ;
dQbulk_dVgs = here->HSMHV_Qbulk_dVgsi ;
dQbulk_dVbs = here->HSMHV_Qbulk_dVbsi ;
} else { /* reverse mode */
Qdrat = 1.0 - here->HSMHV_Xd ;
dQdrat_dVds = +(here->HSMHV_Xd_dVdsi + here->HSMHV_Xd_dVgsi + here->HSMHV_Xd_dVbsi) ;
dQdrat_dVgs = - here->HSMHV_Xd_dVgsi ;
dQdrat_dVbs = - here->HSMHV_Xd_dVbsi ;
dQi_dVds = -(here->HSMHV_Qi_dVdsi + here->HSMHV_Qi_dVgsi + here->HSMHV_Qi_dVbsi) ;
dQi_dVgs = here->HSMHV_Qi_dVgsi ;
dQi_dVbs = here->HSMHV_Qi_dVbsi ;
dQbulk_dVds = -(here->HSMHV_Qbulk_dVdsi + here->HSMHV_Qbulk_dVgsi + here->HSMHV_Qbulk_dVbsi) ;
dQbulk_dVgs = here->HSMHV_Qbulk_dVgsi ;
dQbulk_dVbs = here->HSMHV_Qbulk_dVbsi ;
}
/* from Qg_nqs = - Qi_nqs - Qb_nqs: */
dQg_nqs_dQi_nqs = - 1.0 ;
dQg_nqs_dQb_nqs = - 1.0 ;
/* from Qd_nqs = Qi_nqs * Qdrat: */
dQd_nqs_dVds = Qi_nqs * dQdrat_dVds ;
dQd_nqs_dVgs = Qi_nqs * dQdrat_dVgs ;
dQd_nqs_dVbs = Qi_nqs * dQdrat_dVbs ;
dQd_nqs_dQi_nqs = Qdrat ;
/* by implicit differentiation of the NQS equations (DC operating point only!): */
dQi_nqs_dVds = dQi_dVds ;
dQi_nqs_dVgs = dQi_dVgs ;
dQi_nqs_dVbs = dQi_dVbs ;
dQb_nqs_dVds = dQbulk_dVds ;
dQb_nqs_dVgs = dQbulk_dVgs ;
dQb_nqs_dVbs = dQbulk_dVbs ;
cggb_nqs = dQg_nqs_dQi_nqs * dQi_nqs_dVgs + dQg_nqs_dQb_nqs * dQb_nqs_dVgs ;
cgdb_nqs = dQg_nqs_dQi_nqs * dQi_nqs_dVds + dQg_nqs_dQb_nqs * dQb_nqs_dVds ;
cgsb_nqs = - dQg_nqs_dQi_nqs * (dQi_nqs_dVds + dQi_nqs_dVgs + dQi_nqs_dVbs)
- dQg_nqs_dQb_nqs * (dQb_nqs_dVds + dQb_nqs_dVgs + dQb_nqs_dVbs) ;
cdgb_nqs = dQd_nqs_dVgs + dQd_nqs_dQi_nqs * dQi_nqs_dVgs ;
cddb_nqs = dQd_nqs_dVds + dQd_nqs_dQi_nqs * dQi_nqs_dVds ;
cdsb_nqs = -(dQd_nqs_dVds + dQd_nqs_dVgs + dQd_nqs_dVbs) - dQd_nqs_dQi_nqs * (dQi_nqs_dVds + dQi_nqs_dVgs + dQi_nqs_dVbs) ;
cbgb_nqs = dQb_nqs_dVgs ;
cbdb_nqs = dQb_nqs_dVds ;
cbsb_nqs = -(dQb_nqs_dVds + dQb_nqs_dVgs + dQb_nqs_dVbs) ;
} else { /* QS case */
cggb_nqs = cgdb_nqs = cgsb_nqs = cdgb_nqs = cddb_nqs = cdsb_nqs = cbgb_nqs = cbdb_nqs = cbsb_nqs = 0.0 ;
}
switch (which) {
case HSMHV_COSELFHEAT:
value->iValue = here->HSMHV_coselfheat;
return(OK);
case HSMHV_COSUBNODE:
value->iValue = here->HSMHV_cosubnode;
return(OK);
case HSMHV_L:
value->rValue = here->HSMHV_l;
return(OK);
case HSMHV_W:
value->rValue = here->HSMHV_w;
return(OK);
case HSMHV_AS:
value->rValue = here->HSMHV_as;
return(OK);
case HSMHV_AD:
value->rValue = here->HSMHV_ad;
return(OK);
case HSMHV_PS:
value->rValue = here->HSMHV_ps;
return(OK);
case HSMHV_PD:
value->rValue = here->HSMHV_pd;
return(OK);
case HSMHV_NRS:
value->rValue = here->HSMHV_nrs;
return(OK);
case HSMHV_NRD:
value->rValue = here->HSMHV_nrd;
return(OK);
case HSMHV_DTEMP:
value->rValue = here->HSMHV_dtemp;
return(OK);
case HSMHV_OFF:
value->iValue = here->HSMHV_off;
return(OK);
case HSMHV_IC_VBS:
value->rValue = here->HSMHV_icVBS;
return(OK);
case HSMHV_IC_VDS:
value->rValue = here->HSMHV_icVDS;
return(OK);
case HSMHV_IC_VGS:
value->rValue = here->HSMHV_icVGS;
return(OK);
case HSMHV_DNODE:
value->iValue = here->HSMHVdNode;
return(OK);
case HSMHV_GNODE:
value->iValue = here->HSMHVgNode;
return(OK);
case HSMHV_SNODE:
value->iValue = here->HSMHVsNode;
return(OK);
case HSMHV_BNODE:
value->iValue = here->HSMHVbNode;
return(OK);
case HSMHV_DNODEPRIME:
value->iValue = here->HSMHVdNodePrime;
return(OK);
case HSMHV_SNODEPRIME:
value->iValue = here->HSMHVsNodePrime;
return(OK);
case HSMHV_SOURCECONDUCT:
value->rValue = here->HSMHVsourceConductance;
return(OK);
case HSMHV_DRAINCONDUCT:
value->rValue = here->HSMHVdrainConductance;
return(OK);
case HSMHV_VBD:
value->rValue = *(ckt->CKTstate0 + here->HSMHVvbd);
return(OK);
case HSMHV_VBS:
value->rValue = *(ckt->CKTstate0 + here->HSMHVvbs);
return(OK);
case HSMHV_VGS:
value->rValue = *(ckt->CKTstate0 + here->HSMHVvgs);
return(OK);
case HSMHV_VDS:
value->rValue = *(ckt->CKTstate0 + here->HSMHVvds);
return(OK);
case HSMHV_CD:
value->rValue = here->HSMHV_ids;
return(OK);
case HSMHV_ISUB:
value->rValue = here->HSMHV_isub;
return(OK);
case HSMHV_IGIDL:
value->rValue = here->HSMHV_igidl;
return(OK);
case HSMHV_IGISL:
value->rValue = here->HSMHV_igisl;
return(OK);
case HSMHV_IGD:
value->rValue = here->HSMHV_igd;
return(OK);
case HSMHV_IGS:
value->rValue = here->HSMHV_igs;
return(OK);
case HSMHV_IGB:
value->rValue = here->HSMHV_igb;
return(OK);
case HSMHV_CBS:
value->rValue = here->HSMHV_ibs;
return(OK);
case HSMHV_CBD:
value->rValue = here->HSMHV_ibd;
return(OK);
case HSMHV_GM:
value->rValue = here->HSMHV_dIds_dVgsi;
return(OK);
case HSMHV_GMT:
value->rValue = here->HSMHV_dIds_dTi;
return(OK);
case HSMHV_GDS:
value->rValue = here->HSMHV_dIds_dVdsi;
return(OK);
case HSMHV_GMBS:
value->rValue = here->HSMHV_dIds_dVbsi;
return(OK);
case HSMHV_GBD:
value->rValue = here->HSMHV_gbd;
return(OK);
case HSMHV_GBS:
value->rValue = here->HSMHV_gbs;
return(OK);
case HSMHV_QB:
value->rValue = *(ckt->CKTstate0 + here->HSMHVqb);
return(OK);
case HSMHV_CQB:
value->rValue = *(ckt->CKTstate0 + here->HSMHVcqb);
return(OK);
case HSMHV_QG:
value->rValue = *(ckt->CKTstate0 + here->HSMHVqg);
return(OK);
case HSMHV_CQG:
value->rValue = *(ckt->CKTstate0 + here->HSMHVcqg);
return(OK);
case HSMHV_QD:
value->rValue = *(ckt->CKTstate0 + here->HSMHVqd);
return(OK);
case HSMHV_CQD:
value->rValue = *(ckt->CKTstate0 + here->HSMHVcqd);
return(OK);
case HSMHV_CGG:
value->rValue = here->HSMHV_dQg_dVgsi - here->HSMHV_cggo;
if (flg_nqs) value->rValue += cggb_nqs;
return(OK);
case HSMHV_CGD:
value->rValue = (here->HSMHV_mode > 0) ? here->HSMHV_dQg_dVdsi - here->HSMHV_cgdo
: - (here->HSMHV_dQg_dVdsi + here->HSMHV_dQg_dVgsi + here->HSMHV_dQg_dVbsi)
- here->HSMHV_cgso;
if (flg_nqs) value->rValue += cgdb_nqs;
return(OK);
case HSMHV_CGS:
value->rValue = (here->HSMHV_mode > 0) ? - (here->HSMHV_dQg_dVdsi + here->HSMHV_dQg_dVgsi + here->HSMHV_dQg_dVbsi)
- here->HSMHV_cgso
: here->HSMHV_dQg_dVdsi - here->HSMHV_cgdo;
if (flg_nqs) value->rValue += cgsb_nqs;
return(OK);
case HSMHV_CDG:
value->rValue = (here->HSMHV_mode > 0) ? here->HSMHV_dQdi_dVgsi - here->HSMHV_cdgo
: here->HSMHV_dQsi_dVgsi - here->HSMHV_csgo;
if (flg_nqs) value->rValue += cdgb_nqs;
return(OK);
case HSMHV_CDD:
value->rValue = (here->HSMHV_mode > 0) ? here->HSMHV_dQdi_dVdsi - here->HSMHV_cddo
: - (here->HSMHV_dQsi_dVdsi + here->HSMHV_dQsi_dVgsi + here->HSMHV_dQsi_dVbsi)
- here->HSMHV_csso;
if (flg_nqs) value->rValue += cddb_nqs;
return(OK);
case HSMHV_CDS:
value->rValue = (here->HSMHV_mode > 0) ? - (here->HSMHV_dQdi_dVdsi + here->HSMHV_dQdi_dVgsi + here->HSMHV_dQdi_dVbsi)
- here->HSMHV_cdso
: here->HSMHV_dQsi_dVdsi - here->HSMHV_csdo;
if (flg_nqs) value->rValue += cdsb_nqs;
return(OK);
case HSMHV_CBG:
value->rValue = here->HSMHV_dQb_dVgsi - here->HSMHV_cbgo;
if (flg_nqs) value->rValue += cbgb_nqs;
return(OK);
case HSMHV_CBDB:
value->rValue = (here->HSMHV_mode > 0) ? here->HSMHV_dQb_dVdsi - here->HSMHV_cbdo
: - (here->HSMHV_dQb_dVdsi + here->HSMHV_dQb_dVgsi + here->HSMHV_dQb_dVbsi)
+ (here->HSMHV_cbdo+here->HSMHV_cbgo+here->HSMHV_cbbo);
if (flg_nqs) value->rValue += cbdb_nqs;
return(OK);
case HSMHV_CBSB:
value->rValue = (here->HSMHV_mode > 0) ? - (here->HSMHV_dQb_dVdsi + here->HSMHV_dQb_dVgsi + here->HSMHV_dQb_dVbsi)
+ (here->HSMHV_cbdo + here->HSMHV_cbgo + here->HSMHV_cbbo)
: here->HSMHV_dQb_dVdsi - here->HSMHV_cbdo;
if (flg_nqs) value->rValue += cbsb_nqs;
return(OK);
case HSMHV_CGDO:
value->rValue = (here->HSMHV_mode > 0) ? here->HSMHV_cgdo : here->HSMHV_cgso;
return(OK);
case HSMHV_CGSO:
value->rValue = (here->HSMHV_mode > 0) ? here->HSMHV_cgso : here->HSMHV_cgdo;
return(OK);
case HSMHV_CGBO:
value->rValue = here->HSMHV_cgbo;
return(OK);
case HSMHV_CAPBD:
value->rValue = here->HSMHV_capbd;
return(OK);
case HSMHV_CAPBS:
value->rValue = here->HSMHV_capbs;
return(OK);
case HSMHV_VON:
value->rValue = here->HSMHV_von;
return(OK);
case HSMHV_VDSAT:
value->rValue = here->HSMHV_vdsat;
return(OK);
case HSMHV_QBS:
value->rValue = *(ckt->CKTstate0 + here->HSMHVqbs);
return(OK);
case HSMHV_QBD:
value->rValue = *(ckt->CKTstate0 + here->HSMHVqbd);
return(OK);
case HSMHV_CORBNET:
value->iValue = here->HSMHV_corbnet;
return(OK);
case HSMHV_RBPB:
value->rValue = here->HSMHV_rbpb;
return (OK);
case HSMHV_RBPD:
value->rValue = here->HSMHV_rbpd;
return(OK);
case HSMHV_RBPS:
value->rValue = here->HSMHV_rbps;
return(OK);
case HSMHV_RBDB:
value->rValue = here->HSMHV_rbdb;
return(OK);
case HSMHV_RBSB:
value->rValue = here->HSMHV_rbsb;
return(OK);
case HSMHV_CORG:
value->iValue = here->HSMHV_corg;
return(OK);
case HSMHV_NGCON:
value->rValue = here->HSMHV_ngcon;
return(OK);
case HSMHV_XGW:
value->rValue = here->HSMHV_xgw;
return(OK);
case HSMHV_XGL:
value->rValue = here->HSMHV_xgl;
return(OK);
case HSMHV_NF:
value->rValue = here->HSMHV_nf;
return(OK);
case HSMHV_SA:
value->rValue = here->HSMHV_sa;
return(OK);
case HSMHV_SB:
value->rValue = here->HSMHV_sb;
return(OK);
case HSMHV_SD:
value->rValue = here->HSMHV_sd;
return(OK);
case HSMHV_NSUBCDFM:
value->rValue = here->HSMHV_nsubcdfm;
return(OK);
case HSMHV_M:
value->rValue = here->HSMHV_m;
return(OK);
case HSMHV_SUBLD1:
value->rValue = here->HSMHV_subld1;
return(OK);
case HSMHV_SUBLD2:
value->rValue = here->HSMHV_subld2;
return(OK);
case HSMHV_LOVER:
value->rValue = here->HSMHV_lover;
return(OK);
case HSMHV_LOVERS:
value->rValue = here->HSMHV_lovers;
return(OK);
case HSMHV_LOVERLD:
value->rValue = here->HSMHV_loverld;
return(OK);
case HSMHV_LDRIFT1:
value->rValue = here->HSMHV_ldrift1;
return(OK);
case HSMHV_LDRIFT2:
value->rValue = here->HSMHV_ldrift2;
return(OK);
case HSMHV_LDRIFT1S:
value->rValue = here->HSMHV_ldrift1s;
return(OK);
case HSMHV_LDRIFT2S:
value->rValue = here->HSMHV_ldrift2s;
return(OK);
default:
return(E_BADPARM);
}
/* NOTREACHED */
}

254
src/spicelib/devices/hisimhv/hsmhvcvtest.c Normal file
View File

@ -0,0 +1,254 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvcvtest.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "hsmhvdef.h"
#include "trandefs.h"
#include "const.h"
#include "devdefs.h"
#include "sperror.h"
#include "suffix.h"
int HSMHVconvTest(
GENmodel *inModel,
register CKTcircuit *ckt)
{
register HSMHVmodel *model = (HSMHVmodel*)inModel;
register HSMHVinstance *here;
double vds=0.0, vgs=0.0, vbs=0.0, vdse=0.0, vgse=0.0, vbse=0.0, vdbd=0.0, vsbs=0.0, deltemp =0.0 ;
double delvds=0.0, delvgs=0.0, delvbs=0.0, delvdse=0.0, delvgse=0.0, delvbse=0.0, delvdbd=0.0, delvsbs=0.0, deldeltemp =0.0 ;
double Ids=0.0, gds=0.0, gm=0.0, gmbs=0.0, gmT=0.0, gmbs_ext=0.0, gds_ext=0.0, gm_ext=0.0,
Isub=0.0, dIsub_dVds=0.0, dIsub_dVgs=0.0, dIsub_dVbs=0.0, dIsub_dT=0.0,
Isubs=0.0, dIsubs_dVds=0.0, dIsubs_dVgs=0.0, dIsubs_dVbs=0.0, dIsubs_dT=0.0,
Igidl=0.0, dIgidl_dVds=0.0, dIgidl_dVgs=0.0, dIgidl_dVbs=0.0, dIgidl_dT=0.0,
Igisl=0.0, dIgisl_dVds=0.0, dIgisl_dVgs=0.0, dIgisl_dVbs=0.0, dIgisl_dT=0.0,
Igd=0.0, dIgd_dVd=0.0, dIgd_dVg=0.0, dIgd_dVb=0.0, dIgd_dT=0.0,
Igs=0.0, dIgs_dVd=0.0, dIgs_dVg=0.0, dIgs_dVb=0.0, dIgs_dT=0.0,
Igb=0.0, dIgb_dVd=0.0, dIgb_dVg=0.0, dIgb_dVb=0.0, dIgb_dT=0.0,
Ibd=0.0, Gbd=0.0, Gbdt=0.0,
Ibs=0.0, Gbs=0.0, Gbst =0.0 ;
double i_dP=0.0, i_gP=0.0, i_sP=0.0, i_db=0.0, i_sb=0.0,
i_dP_hat=0.0, i_gP_hat=0.0, i_sP_hat=0.0, i_db_hat=0.0, i_sb_hat =0.0 ;
double tol0=0.0, tol1=0.0, tol2=0.0, tol3=0.0, tol4 =0.0 ;
/* loop through all the HSMHV device models */
for ( ; model != NULL; model = model->HSMHVnextModel ) {
/* loop through all the instances of the model */
for ( here = model->HSMHVinstances; here != NULL ;
here = here->HSMHVnextInstance ) {
vds = model->HSMHV_type *
(*(ckt->CKTrhsOld+here->HSMHVdNodePrime) -
*(ckt->CKTrhsOld+here->HSMHVsNodePrime));
vgs = model->HSMHV_type *
(*(ckt->CKTrhsOld+here->HSMHVgNodePrime) -
*(ckt->CKTrhsOld+here->HSMHVsNodePrime));
vbs = model->HSMHV_type *
(*(ckt->CKTrhsOld+here->HSMHVbNodePrime) -
*(ckt->CKTrhsOld+here->HSMHVsNodePrime));
vdse = model->HSMHV_type *
(*(ckt->CKTrhsOld+here->HSMHVdNode) -
*(ckt->CKTrhsOld+here->HSMHVsNode));
vgse = model->HSMHV_type *
(*(ckt->CKTrhsOld+here->HSMHVgNodePrime) -
*(ckt->CKTrhsOld+here->HSMHVsNode));
vbse = model->HSMHV_type *
(*(ckt->CKTrhsOld+here->HSMHVbNodePrime) -
*(ckt->CKTrhsOld+here->HSMHVsNode));
vdbd = model->HSMHV_type
* (*(ckt->CKTrhsOld + here->HSMHVdbNode)
- *(ckt->CKTrhsOld + here->HSMHVdNode));
vsbs = model->HSMHV_type
* (*(ckt->CKTrhsOld + here->HSMHVsbNode)
- *(ckt->CKTrhsOld + here->HSMHVsNode));
if( here->HSMHVtempNode > 0 ){
deltemp = *(ckt->CKTrhsOld + here->HSMHVtempNode);
} else {
deltemp = 0.0 ;
}
delvds = vds - *(ckt->CKTstate0 + here->HSMHVvds) ;
delvgs = vgs - *(ckt->CKTstate0 + here->HSMHVvgs) ;
delvbs = vbs - *(ckt->CKTstate0 + here->HSMHVvbs) ;
delvdse = vdse - *(ckt->CKTstate0 + here->HSMHVvdse) ;
delvgse = vgse - *(ckt->CKTstate0 + here->HSMHVvgse) ;
delvbse = vbse - *(ckt->CKTstate0 + here->HSMHVvbse) ;
delvdbd = vdbd - *(ckt->CKTstate0 + here->HSMHVvdbd) ;
delvsbs = vsbs - *(ckt->CKTstate0 + here->HSMHVvsbs) ;
if( here->HSMHVtempNode > 0 ){
deldeltemp = deltemp - *(ckt->CKTstate0 + here->HSMHVdeltemp) ;
} else {
deldeltemp = 0.0 ;
}
if ( here->HSMHV_mode > 0 ) { /* forward mode */
Ids = here->HSMHV_ids ;
gds = here->HSMHV_dIds_dVdsi ;
gm = here->HSMHV_dIds_dVgsi ;
gmbs = here->HSMHV_dIds_dVbsi ;
gmT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIds_dTi : 0.0 ;
gmbs_ext = here->HSMHV_dIds_dVbse;
gds_ext = here->HSMHV_dIds_dVdse ;
gm_ext = here->HSMHV_dIds_dVgse;
Isub = here->HSMHV_isub ;
dIsub_dVds = here->HSMHV_dIsub_dVdsi ;
dIsub_dVgs = here->HSMHV_dIsub_dVgsi ;
dIsub_dVbs = here->HSMHV_dIsub_dVbsi ;
dIsub_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIsub_dTi : 0.0 ;
Isubs = 0.0 ;
dIsubs_dVds = 0.0 ;
dIsubs_dVgs = 0.0 ;
dIsubs_dVbs = 0.0 ;
dIsubs_dT = 0.0 ;
Igidl = here->HSMHV_igidl ;
dIgidl_dVds = here->HSMHV_dIgidl_dVdsi ;
dIgidl_dVgs = here->HSMHV_dIgidl_dVgsi ;
dIgidl_dVbs = here->HSMHV_dIgidl_dVbsi ;
dIgidl_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIgidl_dTi : 0.0 ;
Igisl = here->HSMHV_igisl ;
dIgisl_dVds = here->HSMHV_dIgisl_dVdsi ;
dIgisl_dVgs = here->HSMHV_dIgisl_dVgsi ;
dIgisl_dVbs = here->HSMHV_dIgisl_dVbsi ;
dIgisl_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIgisl_dTi : 0.0 ;
Igd = here->HSMHV_igd ;
dIgd_dVd = here->HSMHV_dIgd_dVdsi ;
dIgd_dVg = here->HSMHV_dIgd_dVgsi ;
dIgd_dVb = here->HSMHV_dIgd_dVbsi ;
dIgd_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIgd_dTi : 0.0 ;
Igs = here->HSMHV_igs ;
dIgs_dVd = here->HSMHV_dIgs_dVdsi ;
dIgs_dVg = here->HSMHV_dIgs_dVgsi ;
dIgs_dVb = here->HSMHV_dIgs_dVbsi ;
dIgs_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIgs_dTi : 0.0 ;
Igb = here->HSMHV_igb ;
dIgb_dVd = here->HSMHV_dIgb_dVdsi ;
dIgb_dVg = here->HSMHV_dIgb_dVgsi ;
dIgb_dVb = here->HSMHV_dIgb_dVbsi ;
dIgb_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIgb_dTi : 0.0 ;
Ibd = here->HSMHV_ibd ;
Gbd = here->HSMHV_gbd ;
Gbdt = (here->HSMHVtempNode > 0) ? here->HSMHV_gbdT : 0.0 ;
Ibs = here->HSMHV_ibs ;
Gbs = here->HSMHV_gbs ;
Gbst = (here->HSMHVtempNode > 0) ? here->HSMHV_gbsT : 0.0 ;
} else { /* reverse mode */
Ids = - here->HSMHV_ids ;
gds = + (here->HSMHV_dIds_dVdsi + here->HSMHV_dIds_dVgsi + here->HSMHV_dIds_dVbsi) ;
gm = - here->HSMHV_dIds_dVgsi ;
gmbs = - here->HSMHV_dIds_dVbsi ;
gmT = (here->HSMHVtempNode > 0) ? - here->HSMHV_dIds_dTi : 0.0 ;
gds_ext = + (here->HSMHV_dIds_dVdse + here->HSMHV_dIds_dVgse + here->HSMHV_dIds_dVbse) ;
gm_ext = - here->HSMHV_dIds_dVgse;
gmbs_ext = - here->HSMHV_dIds_dVbse;
Isub = 0.0 ;
dIsub_dVds = 0.0 ;
dIsub_dVgs = 0.0 ;
dIsub_dVbs = 0.0 ;
dIsub_dT = 0.0 ;
Isubs = here->HSMHV_isub ;
dIsubs_dVds = - (here->HSMHV_dIsub_dVdsi + here->HSMHV_dIsub_dVgsi + here->HSMHV_dIsub_dVbsi) ;
dIsubs_dVgs = here->HSMHV_dIsub_dVgsi ;
dIsubs_dVbs = here->HSMHV_dIsub_dVbsi ;
dIsubs_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIsub_dTi : 0.0 ;
Igidl = here->HSMHV_igisl ;
dIgidl_dVds = - (here->HSMHV_dIgisl_dVdsi + here->HSMHV_dIgisl_dVgsi + here->HSMHV_dIgisl_dVbsi) ;
dIgidl_dVgs = here->HSMHV_dIgisl_dVgsi ;
dIgidl_dVbs = here->HSMHV_dIgisl_dVbsi ;
dIgidl_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIgisl_dTi : 0.0 ;
Igisl = here->HSMHV_igidl ;
dIgisl_dVds = - (here->HSMHV_dIgidl_dVdsi + here->HSMHV_dIgidl_dVgsi + here->HSMHV_dIgidl_dVbsi) ;
dIgisl_dVgs = here->HSMHV_dIgidl_dVgsi ;
dIgisl_dVbs = here->HSMHV_dIgidl_dVbsi ;
dIgisl_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIgidl_dTi : 0.0 ;
Igd = here->HSMHV_igd ;
dIgd_dVd = - (here->HSMHV_dIgs_dVdsi + here->HSMHV_dIgs_dVgsi + here->HSMHV_dIgs_dVbsi) ;
dIgd_dVg = here->HSMHV_dIgs_dVgsi ;
dIgd_dVb = here->HSMHV_dIgs_dVbsi ;
dIgd_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIgs_dTi : 0.0 ;
Igs = here->HSMHV_igs ;
dIgs_dVd = - (here->HSMHV_dIgd_dVdsi + here->HSMHV_dIgd_dVgsi + here->HSMHV_dIgd_dVbsi) ;
dIgs_dVg = here->HSMHV_dIgd_dVgsi ;
dIgs_dVb = here->HSMHV_dIgd_dVbsi ;
dIgs_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIgd_dTi : 0.0 ;
Igb = here->HSMHV_igb ;
dIgb_dVd = - (here->HSMHV_dIgb_dVdsi + here->HSMHV_dIgb_dVgsi + here->HSMHV_dIgb_dVbsi) ;
dIgb_dVg = here->HSMHV_dIgb_dVgsi ;
dIgb_dVb = here->HSMHV_dIgb_dVbsi ;
dIgb_dT = (here->HSMHVtempNode > 0) ? here->HSMHV_dIgb_dTi : 0.0 ;
Ibd = here->HSMHV_ibd ;
Gbd = here->HSMHV_gbd ;
Gbdt = (here->HSMHVtempNode > 0) ? here->HSMHV_gbdT : 0.0 ;
Ibs = here->HSMHV_ibs ;
Gbs = here->HSMHV_gbs ;
Gbst = (here->HSMHVtempNode > 0) ? here->HSMHV_gbsT : 0.0 ;
} /* end of reverse mode */
/* for convergence control, only nonlinear static currents are considered: */
i_dP = Ids + Isub + Igidl - Igd ;
i_dP_hat = i_dP + gm *delvgs + gds *delvds + gmbs *delvbs + gmT *deldeltemp
+ dIsub_dVgs *delvgs + dIsub_dVds *delvds + dIsub_dVbs *delvbs + dIsub_dT *deldeltemp
+ dIgidl_dVgs*delvgs + dIgidl_dVds*delvds + dIgidl_dVbs*delvbs + dIgidl_dT*deldeltemp
-(dIgd_dVg *delvgs + dIgd_dVd *delvds + dIgd_dVb *delvbs + dIgd_dT *deldeltemp)
+ gm_ext *delvgse + gds_ext *delvdse + gmbs_ext *delvbse ;
i_gP = Igd + Igs + Igb ;
i_gP_hat = i_gP + dIgd_dVg *delvgs + dIgd_dVd *delvds + dIgd_dVb *delvbs + dIgd_dT *deldeltemp
+ dIgs_dVg *delvgs + dIgs_dVd *delvds + dIgs_dVb *delvbs + dIgs_dT *deldeltemp
+ dIgb_dVg *delvgs + dIgb_dVd *delvds + dIgb_dVb *delvbs + dIgb_dT *deldeltemp ;
i_sP =-Ids + Isubs + Igisl - Igs ;
i_sP_hat = i_sP -(gm *delvgs + gds *delvds + gmbs *delvbs + gmT *deldeltemp)
+ dIsubs_dVgs*delvgs + dIsubs_dVds*delvds + dIsubs_dVbs*delvbs + dIsubs_dT*deldeltemp
+ dIgisl_dVgs*delvgs + dIgisl_dVds*delvds + dIgisl_dVbs*delvbs + dIgisl_dT*deldeltemp
-(dIgs_dVg *delvgs + dIgs_dVd *delvds + dIgs_dVb *delvbs + dIgs_dT *deldeltemp)
-(gm_ext *delvgse + gds_ext *delvdse + gmbs_ext *delvbse) ;
i_db = Ibd ;
i_db_hat = i_db + Gbd*delvdbd + Gbdt*deldeltemp ;
i_sb = Ibs ;
i_sb_hat = i_sb + Gbs*delvsbs + Gbst*deldeltemp ;
/* to be added: power source for thermal network */
/*
* check convergence
*/
if ( here->HSMHV_off == 0 || !(ckt->CKTmode & MODEINITFIX) ) {
tol0 = ckt->CKTreltol * MAX(fabs(i_dP_hat), fabs(i_dP)) + ckt->CKTabstol;
tol1 = ckt->CKTreltol * MAX(fabs(i_gP_hat), fabs(i_gP)) + ckt->CKTabstol;
tol2 = ckt->CKTreltol * MAX(fabs(i_sP_hat), fabs(i_sP)) + ckt->CKTabstol;
tol3 = ckt->CKTreltol * MAX(fabs(i_db_hat), fabs(i_db)) + ckt->CKTabstol;
tol4 = ckt->CKTreltol * MAX(fabs(i_sb_hat), fabs(i_sb)) + ckt->CKTabstol;
if ( (fabs(i_dP_hat - i_dP) >= tol0)
|| (fabs(i_gP_hat - i_gP) >= tol1)
|| (fabs(i_sP_hat - i_sP) >= tol2)
|| (fabs(i_db_hat - i_db) >= tol3)
|| (fabs(i_sb_hat - i_sb) >= tol4) ) {
ckt->CKTnoncon++;
return(OK);
}
}
}
}
return(OK);
}

2912
src/spicelib/devices/hisimhv/hsmhvdef.h Normal file
View File

File diff suppressed because it is too large Load Diff

47
src/spicelib/devices/hisimhv/hsmhvdel.c Normal file
View File

@ -0,0 +1,47 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvdel.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "hsmhvdef.h"
#include "sperror.h"
#include "gendefs.h"
#include "suffix.h"
int HSMHVdelete(
GENmodel *inModel,
IFuid name,
GENinstance **inInst)
{
HSMHVinstance **fast = (HSMHVinstance**)inInst;
HSMHVmodel *model = (HSMHVmodel*)inModel;
HSMHVinstance **prev = NULL;
HSMHVinstance *here;
for( ;model ;model = model->HSMHVnextModel ) {
prev = &(model->HSMHVinstances);
for ( here = *prev ;here ;here = *prev ) {
if ( here->HSMHVname == name || (fast && here==*fast) ) {
*prev= here->HSMHVnextInstance;
FREE(here);
return(OK);
}
prev = &(here->HSMHVnextInstance);
}
}
return(E_NODEV);
}

45
src/spicelib/devices/hisimhv/hsmhvdest.c Normal file
View File

@ -0,0 +1,45 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvdest.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "hsmhvdef.h"
#include "suffix.h"
void HSMHVdestroy(
GENmodel **inModel)
{
HSMHVmodel **model = (HSMHVmodel**)inModel;
HSMHVinstance *here;
HSMHVinstance *prev = NULL;
HSMHVmodel *mod = *model;
HSMHVmodel *oldmod = NULL;
for ( ;mod ;mod = mod->HSMHVnextModel ) {
if (oldmod) FREE(oldmod);
oldmod = mod;
prev = (HSMHVinstance *)NULL;
for ( here = mod->HSMHVinstances ;here ;here = here->HSMHVnextInstance ) {
if (prev) FREE(prev);
prev = here;
}
if (prev) FREE(prev);
}
if (oldmod) FREE(oldmod);
*model = NULL;
}

6393
src/spicelib/devices/hisimhv/hsmhveval.c Normal file
View File

File diff suppressed because it is too large Load Diff

693
src/spicelib/devices/hisimhv/hsmhveval_qover.h Normal file
View File

@ -0,0 +1,693 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhveval_qover.h
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
/* Begin HSMHVevalQover */
/*---------------------------------------------------*
* Clamp -Vxbgmt.
*-----------------*/
T0 = - Vxbgmt;
if ( T0 > Vbs_bnd ) {
T1 = T0 - Vbs_bnd;
T1_dT = - Vbs_bnd_dT;
T2 = Vbs_max - Vbs_bnd;
T2_dT = Vbs_max_dT - Vbs_bnd_dT;
Fn_SUPoly4m( TY, T1, T2, T11, T0 );
TY_dT = T1_dT * T11 + T2_dT * T0;
T10 = Vbs_bnd + TY ;
T10_dT = Vbs_bnd_dT + TY_dT ;
} else {
T10 = T0 ;
T11 = 1.0 ;
T10_dT = 0.0;
}
Vxbgmtcl = - T10;
Vxbgmtcl_dVxbgmt = T11;
Vxbgmtcl_dT = - T10_dT;
fac1 = cnst0over_func * Cox0_inv ;
fac1_dVbs = 0.0; fac1_dVds = 0.0; fac1_dVgs = 0.0;
fac1_dT = cnst0over_func_dT * Cox0_inv ;
fac1p2 = fac1 * fac1 ;
fac1p2_dT = 2.0 * fac1 * fac1_dT ;
VgpLD = - Vgbgmt + pParam->HSMHV_vfbover;
VgpLD_dVgb = - 1.0e0 ;
T0 = Nover_func / here->HSMHV_nin ;
Pb2over = 2.0 / beta * log( T0 ) ;
T0_dT = - T0 / here->HSMHV_nin * Nin_dT ;
Pb2over_dT = - Pb2over / beta * beta_dT + 2.0 / beta / T0 * T0_dT ;
Vgb_fb_LD = - Vxbgmtcl ;
/*-----------------------------------*
* QsuLD: total charge = Accumulation | Depletion+inversion
*-----------------*/
if ( VgpLD < Vgb_fb_LD ){
/*---------------------------*
* Accumulation
*-----------------*/
flg_ovzone = -1 ;
T1 = 1.0 / ( beta * cnst0over_func ) ;
T1_dT = - T1 * T1 * ( beta_dT * cnst0over_func + beta * cnst0over_func_dT ) ;
TY = T1 * Cox0 ;
Ac41 = 2.0 + 3.0 * C_SQRT_2 * TY ;
Ac4 = 8.0 * Ac41 * Ac41 * Ac41 ;
TY_dT = T1_dT * Cox0 ;
Ac41_dT = 3.0 * C_SQRT_2 * TY_dT ;
Ac4_dT = 8.0 * 3.0 * Ac41 * Ac41 * Ac41_dT ;
Ps0_min = here->HSMHV_eg - Pb2over ;
Ps0_min_dT = Eg_dT - Pb2over_dT ;
TX = beta * ( VgpLD + Vxbgmtcl ) ;
TX_dVxb = beta * Vxbgmtcl_dVxbgmt ;
TX_dVgb = beta * VgpLD_dVgb ;
TX_dT = beta_dT * ( VgpLD + Vxbgmtcl ) + beta * Vxbgmtcl_dT;
Ac31 = 7.0 * C_SQRT_2 - 9.0 * TY * ( TX - 2.0 ) ;
Ac31_dVxb = - 9.0 * TY * TX_dVxb ;
Ac31_dVgb = - 9.0 * TY * TX_dVgb ;
Ac31_dT = - 9.0 * ( TY_dT * ( TX - 2.0 ) + TY * TX_dT );
Ac3 = Ac31 * Ac31 ;
T1 = 2.0 * Ac31 ;
Ac3_dVxb = T1 * Ac31_dVxb ;
Ac3_dVgb = T1 * Ac31_dVgb ;
Ac3_dT = T1 * Ac31_dT ;
Ac2 = sqrt( Ac4 + Ac3 ) ;
T1 = 0.5 / Ac2 ;
Ac2_dVxb = T1 * Ac3_dVxb ;
Ac2_dVgb = T1 * Ac3_dVgb ;
Ac2_dT = T1 * ( Ac4_dT + Ac3_dT );
Ac1 = -7.0 * C_SQRT_2 + Ac2 + 9.0 * TY * ( TX - 2.0 ) ;
Ac1_dVxb = Ac2_dVxb + 9.0 * TY * TX_dVxb ;
Ac1_dVgb = Ac2_dVgb + 9.0 * TY * TX_dVgb ;
Ac1_dT = Ac2_dT + 9.0 * ( TY_dT * ( TX - 2.0 ) + TY * TX_dT ) ;
Acd = pow( Ac1 , C_1o3 ) ;
T1 = C_1o3 / ( Acd * Acd ) ;
Acd_dVxb = Ac1_dVxb * T1 ;
Acd_dVgb = Ac1_dVgb * T1 ;
Acd_dT = Ac1_dT * T1 ;
Acn = -4.0 * C_SQRT_2 - 12.0 * TY + 2.0 * Acd + C_SQRT_2 * Acd * Acd ;
T1 = 2.0 + 2.0 * C_SQRT_2 * Acd ;
Acn_dVxb = T1 * Acd_dVxb ;
Acn_dVgb = T1 * Acd_dVgb ;
Acn_dT = - 12.0 * TY_dT + T1 * Acd_dT ;
Chi = Acn / Acd ;
T1 = 1.0 / ( Acd * Acd ) ;
Chi_dVxb = ( Acn_dVxb * Acd - Acn * Acd_dVxb ) * T1 ;
Chi_dVgb = ( Acn_dVgb * Acd - Acn * Acd_dVgb ) * T1 ;
Chi_dT = ( Acn_dT * Acd - Acn * Acd_dT ) * T1 ;
Psa = Chi * beta_inv - Vxbgmtcl ;
Psa_dVxb = Chi_dVxb * beta_inv - Vxbgmtcl_dVxbgmt ;
Psa_dVgb = Chi_dVgb * beta_inv ;
Psa_dT = Chi_dT * beta_inv + Chi * beta_inv_dT - Vxbgmtcl_dT ;
T1 = Psa + Vxbgmtcl ;
T1_dT = Psa_dT + Vxbgmtcl_dT ;
T2 = T1 / Ps0_min ;
T2_dT = ( T1_dT * Ps0_min - T1 * Ps0_min_dT ) / ( Ps0_min * Ps0_min ) ;
T3 = sqrt( 1.0 + ( T2 * T2 ) ) ;
T9 = T2 / T3 / Ps0_min ;
T3_dVd = T9 * ( Psa_dVxb + Vxbgmtcl_dVxbgmt ) ;
T3_dVg = T9 * Psa_dVgb ;
T3_dT = T2_dT * T2 / T3;
Ps0LD = T1 / T3 - Vxbgmtcl ;
T9 = 1.0 / ( T3 * T3 ) ;
Ps0LD_dVxb = T9 * ( ( Psa_dVxb + Vxbgmtcl_dVxbgmt ) * T3 - T1 * T3_dVd ) - Vxbgmtcl_dVxbgmt ;
Ps0LD_dVgb = T9 * ( Psa_dVgb * T3 - T1 * T3_dVg );
Ps0LD_dT = T9 * ( T1_dT * T3 - T1 * T3_dT ) - Vxbgmtcl_dT;
T2 = ( VgpLD - Ps0LD ) ;
QsuLD = Cox0 * T2 ;
QsuLD_dVxb = - Cox0 * Ps0LD_dVxb ;
QsuLD_dVgb = Cox0 * ( VgpLD_dVgb - Ps0LD_dVgb ) ;
QsuLD_dT = Cox0 * ( - Ps0LD_dT ) ;
QbuLD = QsuLD ;
QbuLD_dVxb = QsuLD_dVxb ;
QbuLD_dVgb = QsuLD_dVgb ;
QbuLD_dT = QsuLD_dT ;
} else {
if ( model->HSMHV_coqovsm != 1 ) { /*-- COQOVSM != 1: Analytical solution --(Original)--*/
/*---------------------------*
* Depletion and inversion
*-----------------*/
/* initial value for a few fixpoint iterations
to get Ps0_iniA from simplified Poisson equation: */
flg_ovzone = 2 ;
Chi = znbd3 ;
Chi_dVxb = beta*Vxbgmtcl_dVxbgmt;
Chi_dVgb = Chi_dT = 0.0;
Ps0_iniA= Chi/beta - Vxbgmtcl ;
Ps0_iniA_dVxb = Chi_dVxb/beta - Vxbgmtcl_dVxbgmt ;
Ps0_iniA_dVgb = Chi_dVgb/beta ;
Ps0_iniA_dT = Chi_dT/beta - Chi*beta_dT/(beta*beta) - Vxbgmtcl_dT;
/* 3 .. 5 iterations should be sufficient */
for ( lp_ld = 1; lp_ld <= 3; lp_ld ++ ) {
TY = exp(-Chi);
TY_dVxb = -Chi_dVxb * TY;
TY_dVgb = -Chi_dVgb * TY;
TY_dT = - Chi_dT * TY;
TX = 1.0e0 + 4.0e0
* ( beta * ( VgpLD + Vxbgmtcl ) - 1.0e0 + TY ) / ( fac1p2 * beta2 ) ;
TX_dVxb = 4.0e0 * ( beta * ( Vxbgmtcl_dVxbgmt ) + TY_dVxb ) / ( fac1p2 * beta2 );
TX_dVgb = 4.0e0 * ( beta * ( VgpLD_dVgb ) + TY_dVgb ) / ( fac1p2 * beta2 );
T1 = ( beta * ( VgpLD + Vxbgmtcl ) - 1.0e0 + TY );
T1_dT = beta_dT * ( VgpLD + Vxbgmtcl ) + beta * Vxbgmtcl_dT + TY_dT;
T3 = fac1p2 * beta2 ;
T3_dT = fac1p2_dT * beta2 + fac1p2 * ( 2 * beta * beta_dT ) ;
TX_dT = 4 * ( T1_dT * T3 - T1 * T3_dT ) / ( T3 * T3 );
if ( TX < epsm10) {
TX = epsm10;
TX_dVxb = TX_dVgb = TX_dT = 0.0;
}
Ps0_iniA = VgpLD + fac1p2 * beta / 2.0e0 * ( 1.0e0 - sqrt( TX ) ) ;
Ps0_iniA_dVxb = - fac1p2 * beta / 2.0e0 * TX_dVxb * 0.5 / sqrt( TX );
Ps0_iniA_dVgb = VgpLD_dVgb - fac1p2 * beta / 2.0e0 * TX_dVgb * 0.5 / sqrt( TX );
T1 = fac1p2 * beta ;
T1_dT = fac1p2_dT * beta + fac1p2 * beta_dT ;
T2 = 1.0 - sqrt( TX );
T2_dT = - 1.0e0 / ( 2.0e0 * sqrt( TX ) ) * TX_dT ;
Ps0_iniA_dT = ( T1_dT * T2 + T1 * T2_dT ) / 2.0e0 ;
Chi = beta * ( Ps0_iniA + Vxbgmtcl ) ;
Chi_dVxb = beta * ( Ps0_iniA_dVxb + Vxbgmtcl_dVxbgmt ) ;
Chi_dVgb = beta * ( Ps0_iniA_dVgb ) ;
Chi_dT = beta_dT * ( Ps0_iniA + Vxbgmtcl ) + beta * ( Ps0_iniA_dT + Vxbgmtcl_dT );
}
if ( Chi < znbd3 ) {
flg_ovzone = 1 ;
/*-----------------------------------*
* zone-D1
* - Ps0_iniA is the analytical solution of QovLD=Qb0 with
* Qb0 being approximated by 3-degree polynomial.
*
* new: Inclusion of exp(-Chi) term at right border
*-----------------*/
Tc = 0.7071067 + 1.0/(beta*fac1);
Tc_dT = - (beta_dT*fac1 + beta*fac1_dT)/(beta2*fac1p2);
Td = - (VgpLD + Vxbgmtcl) / fac1;
Td_dVxb = - Vxbgmtcl_dVxbgmt / fac1;
Td_dVgb = - VgpLD_dVgb / fac1;
Td_dT = - (Vxbgmtcl_dT*fac1 - (VgpLD+Vxbgmtcl)*fac1_dT)/fac1p2;
Tq = Tb*Tb*Tb / (27.0*Ta*Ta*Ta) - Tb*Tc/(6.0*Ta*Ta) + Td/(2.0*Ta);
Tq_dVxb = Td_dVxb/(2.0*Ta);
Tq_dVgb = Td_dVgb / (2.0*Ta);
Tq_dT = - Tb/(6.0*Ta*Ta)*Tc_dT + Td_dT/(2.0*Ta);
Tp = (3.0*Ta*Tc-Tb*Tb)/(9.0*Ta*Ta);
Tp_dT = Tc_dT/(3.0*Ta);
T5 = sqrt(Tq*Tq + Tp*Tp*Tp);
T5_dVxb = 2.0*Tq*Tq_dVxb / (2.0*T5);
T5_dVgb = 2.0*Tq*Tq_dVgb / (2.0*T5);
T5_dT = (2.0*Tq*Tq_dT + 3.0*Tp*Tp*Tp_dT) / (2.0*T5);
Tu = pow(-Tq + T5,C_1o3);
Tu_dVxb = Tu / (3.0 * (-Tq + T5)) * (-Tq_dVxb + T5_dVxb);
Tu_dVgb = Tu / (3.0 * (-Tq + T5)) * (-Tq_dVgb + T5_dVgb);
Tu_dT = Tu / (3.0 * (-Tq + T5)) * (-Tq_dT + T5_dT);
Tv = -pow(Tq + T5,C_1o3);
Tv_dVxb = Tv / (3.0 * (-Tq - T5)) * (-Tq_dVxb - T5_dVxb);
Tv_dVgb = Tv / (3.0 * (-Tq - T5)) * (-Tq_dVgb - T5_dVgb);
Tv_dT = Tv / (3.0 * (-Tq - T5)) * (-Tq_dT - T5_dT );
TX = Tu + Tv - Tb/(3.0*Ta);
TX_dVxb = Tu_dVxb + Tv_dVxb;
TX_dVgb = Tu_dVgb + Tv_dVgb;
TX_dT = Tu_dT + Tv_dT ;
Ps0_iniA = TX * beta_inv - Vxbgmtcl ;
Ps0_iniA_dVxb = TX_dVxb * beta_inv - Vxbgmtcl_dVxbgmt;
Ps0_iniA_dVgb = TX_dVgb * beta_inv;
Ps0_iniA_dT = TX_dT * beta_inv + TX * beta_inv_dT - Vxbgmtcl_dT;
Chi = beta * ( Ps0_iniA + Vxbgmtcl ) ;
Chi_dVxb = beta * ( Ps0_iniA_dVxb + Vxbgmtcl_dVxbgmt ) ;
Chi_dVgb = beta * ( Ps0_iniA_dVgb ) ;
Chi_dT = beta_dT * ( Ps0_iniA + Vxbgmtcl ) + beta * ( Ps0_iniA_dT + Vxbgmtcl_dT );
}
if ( model->HSMHV_coqovsm > 0 ) {
/*-----------------------------------*
* - Ps0_iniB : upper bound.
*-----------------*/
flg_ovzone += 2;
VgpLD_shift = VgpLD + Vxbgmtcl + 0.5;
VgpLD_shift_dVgb = VgpLD_dVgb;
VgpLD_shift_dVxb = Vxbgmtcl_dVxbgmt;
VgpLD_shift_dT = Vxbgmtcl_dT;
exp_bVbs = exp( beta * - Vxbgmtcl ) ;
exp_bVbs_dVxb = - exp_bVbs * beta * Vxbgmtcl_dVxbgmt;
exp_bVbs_dT = - exp_bVbs * (beta_dT*Vxbgmtcl + beta*Vxbgmtcl_dT);
T0 = here->HSMHV_nin / Nover_func;
T0_dT = Nin_dT / Nover_func;
cnst1over = T0 * T0;
cnst1over_dT = 2.0 * T0 * T0_dT;
gamma = cnst1over * exp_bVbs;
gamma_dVxb = cnst1over * exp_bVbs_dVxb;
gamma_dT = cnst1over_dT * exp_bVbs + cnst1over * exp_bVbs_dT;
psi = beta*VgpLD_shift;
psi_dVgb = beta*VgpLD_shift_dVgb;
psi_dVxb = beta*VgpLD_shift_dVxb;
psi_dT = beta_dT*VgpLD_shift + beta*VgpLD_shift_dT;
T0 = beta2 * fac1p2;
T0_dT = 2.0 * beta * fac1 * (beta_dT*fac1+beta*fac1_dT);
Chi_B = log (1.0 + psi*psi/(gamma*T0) );
Chi_B_dpsi = 2.0 * psi/(gamma*T0)
/ (1.0 + psi*psi/(gamma*T0) );
Chi_B_dgamma = - psi*psi/(gamma*gamma*T0)
/ (1.0 + psi*psi/(gamma*T0) );
Chi_B_dT = - psi*psi/(gamma*T0*T0)
/ (1.0 + psi*psi/(gamma*T0) );
Chi_B_dVgb = Chi_B_dpsi * psi_dVgb;
Chi_B_dVxb = Chi_B_dpsi * psi_dVxb + Chi_B_dgamma * gamma_dVxb;
Chi_B_dT = Chi_B_dpsi * psi_dT + Chi_B_dgamma * gamma_dT
+ Chi_B_dT * T0_dT;
Ps0_iniB = Chi_B/beta - Vxbgmtcl ;
Ps0_iniB_dVgb = Chi_B_dVgb/beta;
Ps0_iniB_dVxb = Chi_B_dVxb/beta- Vxbgmtcl_dVxbgmt;
Ps0_iniB_dT = Chi_B_dT/beta - Chi_B/(beta*beta)*beta_dT - Vxbgmtcl_dT;
/* construction of Ps0LD by taking Ps0_iniB as an upper limit of Ps0_iniA
*
* Limiting is done for Chi rather than for Ps0LD, to avoid shifting
* for Fn_SU2 */
Chi_A = Chi;
Chi_A_dVxb = Chi_dVxb;
Chi_A_dVgb = Chi_dVgb;
Chi_A_dT = Chi_dT;
Fn_SU2( Chi, Chi_A, Chi_B, c_ps0ini_2*100.00, T1, T2 );
Chi_dVgb = Chi_A_dVgb * T1 + Chi_B_dVgb * T2;
Chi_dVxb = Chi_A_dVxb * T1 + Chi_B_dVxb * T2;
Chi_dT = Chi_A_dT * T1 + Chi_B_dT * T2;
/* updating Ps0LD */
Ps0LD= Chi/beta - Vxbgmtcl ;
Ps0LD_dVgb = Chi_dVgb/beta;
Ps0LD_dVxb = Chi_dVxb/beta- Vxbgmtcl_dVxbgmt;
Ps0LD_dT = Chi_dT/beta - Chi/(beta*beta)*beta_dT - Vxbgmtcl_dT;
}
T1 = Chi - 1.0 + exp(-Chi);
T1_dVxb = (1.0 - exp(-Chi)) * Chi_dVxb ;
T1_dVgb = (1.0 - exp(-Chi)) * Chi_dVgb ;
T1_dT = (1.0 - exp(-Chi)) * Chi_dT ;
if (T1 < epsm10) {
T1 = epsm10;
T1_dVxb = 0.0;
T1_dVgb = 0.0;
T1_dT = 0.0;
}
T2 = sqrt(T1);
QbuLD = cnst0over_func * T2 ;
T3 = cnst0over_func * 0.5 / T2 ;
QbuLD_dVxb = T3 * T1_dVxb ;
QbuLD_dVgb = T3 * T1_dVgb ;
QbuLD_dT = T3 * T1_dT + cnst0over_func_dT * T2 ;
/*-----------------------------------------------------------*
* QsuLD : Qovs or Qovd in unit area.
* note: QsuLD = Qdep+Qinv.
*-----------------*/
QsuLD = Cox0 * ( VgpLD - Ps0LD ) ;
QsuLD_dVxb = Cox0 * ( - Ps0LD_dVxb ) ;
QsuLD_dVgb = Cox0 * ( VgpLD_dVgb - Ps0LD_dVgb ) ;
QsuLD_dT = Cox0 * ( - Ps0LD_dT ) ;
} else { /*-- COQOVSM == 1: Iterative solution ---------------*/
Fn_SZ( T1 , Pb2over + Vxbgmtcl , 1e-3 , T0 ) ;
VthLD = Pb2over + 2.0 * pParam->HSMHV_vfbover
+ sqrt( 2 * C_QE * Nover_func * C_ESI * ( T1 ) ) * Cox0_inv ;
/*-----------------------------------*
* Depletion
*-----------------*/
TX = 1.0e0 + 4.0e0
* ( beta * ( VgpLD + Vxbgmtcl ) - 1.0e0 ) / ( fac1p2 * beta2 ) ;
TX = Fn_Max( TX , epsm10 ) ;
Ps0_iniA = VgpLD + fac1p2 * beta / 2.0e0 * ( 1.0e0 - sqrt( TX ) ) ;
Chi = beta * ( Ps0_iniA + Vxbgmtcl ) ;
if ( Chi < znbd3 ) {
/*-----------------------------------*
* zone-D1/D2
* - Ps0LD is the analytical solution of Qs=Qb0 with
* Qb0 being approximated to 3-degree polynomial.
*-----------------*/
TY = beta * ( VgpLD + Vxbgmtcl ) ;
T1 = 1.0e0 / ( cn_nc3 * beta * fac1 ) ;
T2 = 81.0 + 3.0 * T1 ;
T3 = -2916.0 - 81.0 * T1 + 27.0 * T1 * TY ;
T4 = 1458.0 - 81.0 * ( 54.0 + T1 ) + 27.0 * T1 * TY ;
T4 = T4 * T4 ;
T5 = pow( T3 + sqrt( 4 * T2 * T2 * T2 + T4 ) , C_1o3 ) ;
TX = 3.0 - ( C_2p_1o3 * T2 ) / ( 3.0 * T5 )
+ 1 / ( 3.0 * C_2p_1o3 ) * T5 ;
Ps0_iniA = TX * beta_inv - Vxbgmtcl ;
Ps0_ini = Ps0_iniA ;
} else if ( - Vgbgmt <= VthLD ) {
Ps0_ini = Ps0_iniA ;
} else {
/*-----------------------------------*
* Strong inversion zone.
* - Ps0_iniB : upper bound.
*-----------------*/
T1 = ps0ldinib_func; /* (1 / cnst1 / cnstCoxi) */
T2 = T1 * VgpLD * VgpLD ;
T3 = beta + 2.0 / VgpLD ;
Ps0_iniB = log( T2 + small ) / T3 ;
Fn_SU( Ps0_ini , Ps0_iniA, Ps0_iniB, c_ps0ini_2, T1) ;
}
TX = - Vxbgmtcl + 0.5 * ps_conv ;
if ( Ps0_ini < TX ) Ps0_ini = TX ;
/*---------------------------------------------------*
* Assign initial guess.
*-----------------*/
Ps0LD = Ps0_ini ;
/*---------------------------------------------------*
* Calculation of Ps0LD. (beginning of Newton loop)
* - Fs0 : Fs0 = 0 is the equation to be solved.
* - dPs0 : correction value.
*-----------------*/
exp_bVbs = exp( beta * - Vxbgmtcl ) ;
T0 = here->HSMHV_nin / Nover_func;
cnst1over = T0 * T0;
cnst1over_dT = 2.0 * T0 * ( Nin_dT / Nover_func );
cfs1 = cnst1over * exp_bVbs ;
flg_conv = 0 ;
for ( lp_s0 = 1 ; lp_s0 <= 2*lp_s0_max + 1 ; lp_s0 ++ ) {
Chi = beta * ( Ps0LD + Vxbgmtcl ) ;
if ( Chi < znbd5 ) {
/*-------------------------------------------*
* zone-D1/D2. (Ps0LD)
*-----------------*/
fi = Chi * Chi * Chi
* ( cn_im53 + Chi * ( cn_im54 + Chi * cn_im55 ) ) ;
fi_dChi = Chi * Chi
* ( 3 * cn_im53 + Chi * ( 4 * cn_im54 + Chi * 5 * cn_im55 ) ) ;
fs01 = cfs1 * fi * fi ;
fs01_dPs0 = cfs1 * beta * 2 * fi * fi_dChi ;
fb = Chi * ( cn_nc51
+ Chi * ( cn_nc52
+ Chi * ( cn_nc53
+ Chi * ( cn_nc54 + Chi * cn_nc55 ) ) ) ) ;
fb_dChi = cn_nc51
+ Chi * ( 2 * cn_nc52
+ Chi * ( 3 * cn_nc53
+ Chi * ( 4 * cn_nc54 + Chi * 5 * cn_nc55 ) ) ) ;
fs02 = sqrt( fb * fb + fs01 + small ) ;
fs02_dPs0 = ( beta * fb_dChi * 2 * fb + fs01_dPs0 ) / ( fs02 + fs02 ) ;
} else {
/*-------------------------------------------*
* zone-D3. (Ps0LD)
*-----------------*/
if ( Chi < large_arg ) { /* avoid exp_Chi to become extremely large */
exp_Chi = exp( Chi ) ;
fs01 = cfs1 * ( exp_Chi - 1.0e0 ) ;
fs01_dPs0 = cfs1 * beta * ( exp_Chi ) ;
} else {
exp_bPs0 = exp( beta*Ps0LD ) ;
fs01 = cnst1over * ( exp_bPs0 - exp_bVbs ) ;
fs01_dPs0 = cnst1over * beta * exp_bPs0 ;
}
fs02 = sqrt( Chi - 1.0 + fs01 ) ;
fs02_dPs0 = ( beta + fs01_dPs0 ) / fs02 * 0.5 ;
} /* end of if ( Chi ... ) block */
/*-----------------------------------------------------------*
* Fs0
*-----------------*/
Fs0 = VgpLD - Ps0LD - fac1 * fs02 ;
Fs0_dPs0 = - 1.0e0 - fac1 * fs02_dPs0 ;
if ( flg_conv == 1 ) break ;
dPs0 = - Fs0 / Fs0_dPs0 ;
/*-------------------------------------------*
* Update Ps0LD .
*-----------------*/
dPlim = 0.5*dP_max*(1.0 + Fn_Max(1.e0,fabs(Ps0LD))) ;
if ( fabs( dPs0 ) > dPlim ) dPs0 = dPlim * Fn_Sgn( dPs0 ) ;
Ps0LD = Ps0LD + dPs0 ;
TX = -Vxbgmtcl + ps_conv / 2 ;
if ( Ps0LD < TX ) Ps0LD = TX ;
/*-------------------------------------------*
* Check convergence.
*-----------------*/
if ( fabs( dPs0 ) <= ps_conv && fabs( Fs0 ) <= gs_conv ) {
flg_conv = 1 ;
}
} /* end of Ps0LD Newton loop */
/*-------------------------------------------*
* Procedure for diverged case.
*-----------------*/
if ( flg_conv == 0 ) {
fprintf( stderr ,
"*** warning(HiSIM): Went Over Iteration Maximum (Ps0LD)\n" ) ;
fprintf( stderr , " -Vxbgmtcl = %e Vgbgmt = %e\n" , -Vxbgmtcl , Vgbgmt ) ;
}
/*---------------------------------------------------*
* Evaluate derivatives of Ps0LD.
*-----------------*/
Chi_dT = beta_dT * ( Ps0LD + Vxbgmtcl ) + beta * Vxbgmtcl_dT;
exp_bVbs_dT = - ( beta_dT * Vxbgmtcl + beta * Vxbgmtcl_dT ) * exp_bVbs;
cfs1_dT = exp_bVbs * cnst1over_dT + exp_bVbs_dT * cnst1over;
if ( Chi < znbd5 ) {
fs01_dVbs = cfs1 * beta * fi * ( - fi + 2 * fi_dChi ) ; /* fs01_dVxbgmtcl */
fs01_dT = cfs1 * 2 * fi * fi_dChi * Chi_dT + fi * fi * cfs1_dT ;
T2 = 1.0e0 / ( fs02 + fs02 ) ;
fs02_dVbs = ( + beta * fb_dChi * 2 * fb + fs01_dVbs ) * T2 ; /* fs02_dVxbgmtcl */
fs02_dT = ( 2 * fb * fb_dChi * Chi_dT + fs01_dT ) * T2 ;
} else {
if ( Chi < large_arg ) {
fs01_dVbs = + cfs1 * beta ; /* fs01_dVxbgmtcl */
exp_Chi_dT = exp_Chi * Chi_dT ;
fs01_dT = ( exp_Chi - 1.0e0 ) * cfs1_dT + cfs1 * exp_Chi_dT ;
} else {
fs01_dVbs = + cfs1 * beta ;
exp_bPs0_dT = exp_bPs0 * Ps0LD * beta_dT ;
fs01_dT = cnst1over_dT*(exp_bPs0-exp_bVbs) + cnst1over*(exp_bPs0_dT-exp_bVbs_dT) ;
}
T2 = 0.5e0 / fs02 ;
fs02_dVbs = ( + beta + fs01_dVbs ) * T2 ; /* fs02_dVxbgmtcl */
fs02_dT = T2 * ( Chi_dT + fs01_dT ) ;
}
T1 = 1.0 / Fs0_dPs0 ;
Ps0LD_dVxb = - ( - fac1 * fs02_dVbs ) * T1 ;
Ps0LD_dVds = 0.0 ;
Ps0LD_dVgb = - ( VgpLD_dVgb - fac1_dVgs * fs02 ) * T1 ;
Ps0LD_dT = - ( - ( fac1 * fs02_dT + fac1_dT * fs02 ) ) * T1;
Chi_dT = beta_dT * ( Ps0LD + Vxbgmtcl ) + beta * ( Ps0LD_dT + Vxbgmtcl_dT );
if ( Chi < znbd5 ) {
/*-------------------------------------------*
* zone-D1/D2. (Ps0LD)
*-----------------*/
if ( Chi < znbd3 ) { flg_ovzone = 1; }
else { flg_ovzone = 2 ; }
Xi0 = fb * fb + epsm10 ;
T1 = 2 * fb * fb_dChi * beta ;
Xi0_dVbs = T1 * ( Ps0LD_dVxb + 1.0 ) ; /* Xi0_dVxbgmtcl */
Xi0_dVds = T1 * Ps0LD_dVds ;
Xi0_dVgs = T1 * Ps0LD_dVgb ;
Xi0_dT = 2 * fb * fb_dChi * Chi_dT ;
Xi0p12 = fb + epsm10 ;
T1 = fb_dChi * beta ;
Xi0p12_dVbs = T1 * ( Ps0LD_dVxb + 1.0 ) ; /* Xi0p12_dVxbgmtcl */
Xi0p12_dVds = T1 * Ps0LD_dVds ;
Xi0p12_dVgs = T1 * Ps0LD_dVgb ;
Xi0p12_dT = fb_dChi * Chi_dT ;
Xi0p32 = fb * fb * fb + epsm10 ;
T1 = 3 * fb * fb * fb_dChi * beta ;
Xi0p32_dVbs = T1 * ( Ps0LD_dVxb + 1.0 ) ; /* Xi0p32_dVxbgmtcl */
Xi0p32_dVds = T1 * Ps0LD_dVds ;
Xi0p32_dVgs = T1 * Ps0LD_dVgb ;
Xi0p32_dT = 3 * fb * fb * fb_dChi * Chi_dT ;
fs01_dT = cfs1 * 2 * fi * fi_dChi * Chi_dT + fi * fi * cfs1_dT ;
fs02_dT = ( 2 * fb * fb_dChi * Chi_dT + fs01_dT ) * T2 ;
} else {
/*-------------------------------------------*
* zone-D3. (Ps0LD)
*-----------------*/
flg_ovzone = 3 ;
Xi0 = Chi - 1.0e0 ;
Xi0_dVbs = beta * ( Ps0LD_dVxb + 1.0e0 ) ; /* Xi0_dVxbgmtcl */
Xi0_dVds = beta * Ps0LD_dVds ;
Xi0_dVgs = beta * Ps0LD_dVgb ;
Xi0_dT = Chi_dT ;
Xi0p12 = sqrt( Xi0 ) ;
T1 = 0.5e0 / Xi0p12 ;
Xi0p12_dVbs = T1 * Xi0_dVbs ;
Xi0p12_dVds = T1 * Xi0_dVds ;
Xi0p12_dVgs = T1 * Xi0_dVgs ;
Xi0p12_dT = T1 * Xi0_dT ;
Xi0p32 = Xi0 * Xi0p12 ;
T1 = 1.5e0 * Xi0p12 ;
Xi0p32_dVbs = T1 * Xi0_dVbs ;
Xi0p32_dVds = T1 * Xi0_dVds ;
Xi0p32_dVgs = T1 * Xi0_dVgs ;
Xi0p32_dT = T1 * Xi0_dT ;
if ( Chi < large_arg ) {
exp_Chi_dT = exp_Chi * Chi_dT ;
fs01_dT = ( exp_Chi - 1.0e0 ) * cfs1_dT + cfs1 * exp_Chi_dT ;
} else {
exp_bPs0_dT = exp_bPs0 * (beta_dT * Ps0LD + beta * Ps0LD_dT) ;
fs01_dT = cnst1over_dT*(exp_bPs0-exp_bVbs) + cnst1over*(exp_bPs0_dT-exp_bVbs_dT) ;
}
fs02_dT = T2 * ( Chi_dT + fs01_dT ) ;
} /* end of if ( Chi ... ) block */
/*-----------------------------------------------------------*
* - Recalculate the derivatives of fs01 and fs02.
*-----------------*/
fs01_dVbs = Ps0LD_dVxb * fs01_dPs0 + fs01_dVbs ;
fs01_dVds = Ps0LD_dVds * fs01_dPs0 ;
fs01_dVgs = Ps0LD_dVgb * fs01_dPs0 ;
fs02_dVbs = Ps0LD_dVxb * fs02_dPs0 + fs02_dVbs ;
fs02_dVxb = Ps0LD_dVds * fs02_dPs0 ;
fs02_dVgb = Ps0LD_dVgb * fs02_dPs0 ;
/*-----------------------------------------------------------*
* QbuLD and QiuLD
*-----------------*/
QbuLD = cnst0over_func * Xi0p12 ;
QbuLD_dVxb = cnst0over_func * Xi0p12_dVbs ;
QbuLD_dVgb = cnst0over_func * Xi0p12_dVgs ;
QbuLD_dT = cnst0over_func * Xi0p12_dT + cnst0over_func_dT * Xi0p12;
T1 = 1.0 / ( fs02 + Xi0p12 ) ;
QiuLD = cnst0over_func * fs01 * T1 ;
T2 = 1.0 / ( fs01 + epsm10 ) ;
QiuLD_dVbs = QiuLD * ( fs01_dVbs * T2 - ( fs02_dVbs + Xi0p12_dVbs ) * T1 ) ;
QiuLD_dVgs = QiuLD * ( fs01_dVgs * T2 - ( fs02_dVgb + Xi0p12_dVgs ) * T1 ) ;
T1_dT = - T1 * T1 * ( fs02_dT + Xi0p12_dT );
QiuLD_dT = cnst0over_func * ( fs01 * T1_dT + T1 * fs01_dT ) + fs01 * T1 * cnst0over_func_dT;
/*-----------------------------------------------------------*
* make QiuLD=0 if VgVt <= VgVt_small
*-----------------*/
if ( QiuLD * Cox_inv <= VgVt_small ) {
flg_ovzone = 4 ;
QiuLD = 0.0 ;
QiuLD_dVbs = 0.0 ;
QiuLD_dVgs = 0.0 ;
QiuLD_dT = 0.0 ;
}
/*-----------------------------------------------------------*
* Extrapolation: X_dVxbgmt = X_dVxbgmtcl * Vxbgmtcl_dVxbgmt
*-----------------*/
QbuLD_dVxb *= Vxbgmtcl_dVxbgmt;
QiuLD_dVbs *= Vxbgmtcl_dVxbgmt;
/*-----------------------------------------------------------*
* Total overlap charge
*-----------------*/
QsuLD = QbuLD + QiuLD;
QsuLD_dVxb = QbuLD_dVxb + QiuLD_dVbs;
QsuLD_dVgb = QbuLD_dVgb + QiuLD_dVgs;
QsuLD_dT = QbuLD_dT + QiuLD_dT;
} /* end of COQOVSM branches */
} /* end of Vgbgmt region blocks */
/* convert to source ref. */
QsuLD_dVbs = QsuLD_dVxb * Vxbgmt_dVbs + QsuLD_dVgb * Vgbgmt_dVbs ;
QsuLD_dVds = QsuLD_dVxb * Vxbgmt_dVds + QsuLD_dVgb * Vgbgmt_dVds ;
QsuLD_dVgs = QsuLD_dVxb * Vxbgmt_dVgs + QsuLD_dVgb * Vgbgmt_dVgs ;
QbuLD_dVbs = QbuLD_dVxb * Vxbgmt_dVbs + QbuLD_dVgb * Vgbgmt_dVbs ;
QbuLD_dVds = QbuLD_dVxb * Vxbgmt_dVds + QbuLD_dVgb * Vgbgmt_dVds ;
QbuLD_dVgs = QbuLD_dVxb * Vxbgmt_dVgs + QbuLD_dVgb * Vgbgmt_dVgs ;
/* additional Vds dependency */
/* QsuLD += model->HSMHV_cvdsover * Cox0 * Vdsgmt ; */
/* QsuLD_dVds += model->HSMHV_cvdsover * Cox0 ; */
/* inversion charge = total - depletion */
QiuLD = QsuLD - QbuLD ;
QiuLD_dVbs = QsuLD_dVbs - QbuLD_dVbs ;
QiuLD_dVds = QsuLD_dVds - QbuLD_dVds ;
QiuLD_dVgs = QsuLD_dVgs - QbuLD_dVgs ;
QiuLD_dT = QsuLD_dT - QbuLD_dT ;
/* End HSMHVevalQover */

91
src/spicelib/devices/hisimhv/hsmhvevalenv.h Normal file
View File

@ -0,0 +1,91 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvevalenv.h
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#ifndef HSMHV_EVAL_ENV_H
#define HSMHV_EVAL_ENV_H
/* macros and constants used in hsmhveval2yz.c */
/*---------------------------------------------------*
* Numerical constants. (macro)
*-----------------*/
/* machine epsilon */
#if defined(_FLOAT_H) && defined(DBL_EPSILON)
#define C_EPS_M (DBL_EPSILON)
#else
#define C_EPS_M (2.2204460492503131e-16)
#endif
#define MAX_EXP 5.834617425e14
#define MIN_EXP 1.713908431e-15
#define EXP_THR 34.0
/* sqrt(2) */
#define C_SQRT_2 (1.414213562373095e+00)
/* 1/3 */
#define C_1o3 (3.333333333333333e-01)
/* 2/3 */
#define C_2o3 (6.666666666666667e-01)
/* 2^(1/3) */
#define C_2p_1o3 (1.259921049894873e+00)
/* Pi */
#define C_Pi (3.141592653589793)
#define C_Pio2 (1.570796326794897)
/* Unit change */
#define C_m2cm_p2 (1.0e4)
#define C_m2um (1.0e6)
/*---------------------------------------------------*
* Physical constants/properties. (macro)
*-----------------*/
/* Elemental charge */
#define C_QE (1.6021918e-19)
/* Boltzmann constant */
#define C_KB (1.3806226e-23)
/* Permitivity of Si, SiO2 and vacuum */
#define C_ESI (1.034943e-10)
#define C_EOX (3.453133e-11)
#define C_VAC (8.8541878e-12)
/* Room temperature constants */
#define C_T300 (300e+00)
#define C_b300 (3.868283e+01)
/* #define C_Eg0 (1.1785e0) */ /*changed to parameter sIN.eg0*/
/* Build-in potential */
/*#define C_Vbi (1.0e0)*/ /* changed to parameter sIN.vbi */
/* Intrinsic carrier density at 300K */
#define C_Nin0 (1.04e+16)
/*---------------------------------------------------*
* Functions. (macro) Take care of the arguments.
*-----------------*/
#define Fn_Sqr(x) ( (x)*(x) ) /* x^2 */
#define Fn_Max(x,y) ( (x) >= (y) ? (x) : (y) ) /* max[x,y] */
#define Fn_Min(x,y) ( (x) <= (y) ? (x) : (y) ) /* min[x,y] */
#define Fn_Sgn(x) ( (x) >= 0 ? (1) : (-1) ) /* sign[x] */
#endif /* HSMHV_EVAL_ENV_H */

39
src/spicelib/devices/hisimhv/hsmhvext.h Normal file
View File

@ -0,0 +1,39 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvext.h
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
extern int HSMHVacLoad(GENmodel *,CKTcircuit*);
extern int HSMHVask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*);
extern int HSMHVconvTest(GENmodel *,CKTcircuit*);
extern int HSMHVdelete(GENmodel*,IFuid,GENinstance**);
extern void HSMHVdestroy(GENmodel**);
extern int HSMHVgetic(GENmodel*,CKTcircuit*);
extern int HSMHVload(GENmodel*,CKTcircuit*);
extern int HSMHVmAsk(CKTcircuit*,GENmodel *,int, IFvalue*);
extern int HSMHVmDelete(GENmodel**,IFuid,GENmodel*);
extern int HSMHVmParam(int,IFvalue*,GENmodel*);
extern void HSMHVmosCap(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*);
extern int HSMHVparam(int,IFvalue*,GENinstance*,IFvalue*);
extern int HSMHVpzLoad(GENmodel*,CKTcircuit*,SPcomplex*);
extern int HSMHVsetup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
extern int HSMHVunsetup(GENmodel*,CKTcircuit*);
extern int HSMHVtemp(GENmodel*,CKTcircuit*);
extern int HSMHVtrunc(GENmodel*,CKTcircuit*,double*);
extern int HSMHVnoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);

57
src/spicelib/devices/hisimhv/hsmhvgetic.c Normal file
View File

@ -0,0 +1,57 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvgetic.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "hsmhvdef.h"
#include "sperror.h"
#include "suffix.h"
int HSMHVgetic(
GENmodel *inModel,
CKTcircuit *ckt)
{
HSMHVmodel *model = (HSMHVmodel*)inModel;
HSMHVinstance *here;
/*
* grab initial conditions out of rhs array. User specified, so use
* external nodes to get values
*/
for ( ;model ;model = model->HSMHVnextModel ) {
for ( here = model->HSMHVinstances; here ;here = here->HSMHVnextInstance ) {
if (!here->HSMHV_icVBS_Given) {
here->HSMHV_icVBS =
*(ckt->CKTrhs + here->HSMHVbNode) -
*(ckt->CKTrhs + here->HSMHVsNode);
}
if (!here->HSMHV_icVDS_Given) {
here->HSMHV_icVDS =
*(ckt->CKTrhs + here->HSMHVdNode) -
*(ckt->CKTrhs + here->HSMHVsNode);
}
if (!here->HSMHV_icVGS_Given) {
here->HSMHV_icVGS =
*(ckt->CKTrhs + here->HSMHVgNode) -
*(ckt->CKTrhs + here->HSMHVsNode);
}
}
}
return(OK);
}

82
src/spicelib/devices/hisimhv/hsmhvinit.c Normal file
View File

@ -0,0 +1,82 @@
#include "config.h"
#include "devdefs.h"
#include "hsmhvdef.h"
#include "hsmhvitf.h"
#include "hsmhvinit.h"
SPICEdev HSMHVinfo = {
{ "HiSIMHV",
"Hiroshima University STARC IGFET Model - HiSIM_HV",
&HSMHVnSize,
&HSMHVnSize,
HSMHVnames,
&HSMHVpTSize,
HSMHVpTable,
&HSMHVmPTSize,
HSMHVmPTable,
#ifdef XSPICE
/*---- Fixed by SDB 5.2.2003 to enable XSPICE/tclspice integration -----*/
NULL, /* This is a SPICE device, it has no MIF info data */
0, /* This is a SPICE device, it has no MIF info data */
NULL, /* This is a SPICE device, it has no MIF info data */
0, /* This is a SPICE device, it has no MIF info data */
NULL, /* This is a SPICE device, it has no MIF info data */
0, /* This is a SPICE device, it has no MIF info data */
NULL, /* This is a SPICE device, it has no MIF info data */
/*--------------------------- End of SDB fix -------------------------*/
#endif
DEV_DEFAULT
},
/* DEVparam */ HSMHVparam,
/* DEVmodParam */ HSMHVmParam,
/* DEVload */ HSMHVload,
/* DEVsetup */ HSMHVsetup,
/* DEVunsetup */ HSMHVunsetup,
/* DEVpzSetup */ HSMHVsetup,
/* DEVtemperature*/ HSMHVtemp,
/* DEVtrunc */ HSMHVtrunc,
/* DEVfindBranch */ NULL,
/* DEVacLoad */ HSMHVacLoad,
/* DEVaccept */ NULL,
/* DEVdestroy */ HSMHVdestroy,
/* DEVmodDelete */ HSMHVmDelete,
/* DEVdelete */ HSMHVdelete,
/* DEVsetic */ HSMHVgetic,
/* DEVask */ HSMHVask,
/* DEVmodAsk */ HSMHVmAsk,
/* DEVpzLoad */ HSMHVpzLoad,
/* DEVconvTest */ HSMHVconvTest,
/* DEVsenSetup */ NULL,
/* DEVsenLoad */ NULL,
/* DEVsenUpdate */ NULL,
/* DEVsenAcLoad */ NULL,
/* DEVsenPrint */ NULL,
/* DEVsenTrunc */ NULL,
/* DEVdisto */ NULL,
/* DEVnoise */ HSMHVnoise,
#ifdef CIDER
/* DEVdump */ NULL,
/* DEVacct */ NULL,
#endif
/* DEVinstSize */ &HSMHViSize,
/* DEVmodSize */ &HSMHVmSize
};
SPICEdev *
get_hsmhv_info(void)
{
return &HSMHVinfo;
}

13
src/spicelib/devices/hisimhv/hsmhvinit.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef _HISIMINIT_H
#define _HISIMINIT_H
extern IFparm HSMHVpTable[ ];
extern IFparm HSMHVmPTable[ ];
extern char *HSMHVnames[ ];
extern int HSMHVpTSize;
extern int HSMHVmPTSize;
extern int HSMHVnSize;
extern int HSMHViSize;
extern int HSMHVmSize;
#endif

23
src/spicelib/devices/hisimhv/hsmhvitf.h Normal file
View File

@ -0,0 +1,23 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvitf
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#ifndef DEV_HISIMHV
#define DEV_HISIMHV
SPICEdev *get_hsmhv_info(void);
#endif

2583
src/spicelib/devices/hisimhv/hsmhvld.c Normal file
View File

File diff suppressed because it is too large Load Diff

123
src/spicelib/devices/hisimhv/hsmhvld_info_eval.h Normal file
View File

@ -0,0 +1,123 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvld_info_eval.h
DATE : 2010.11.02
recent changes: - 2009.01.09 some bugfixes
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
/* print all outputs ------------VV */
if ( model->HSMHV_info >= 4 ) {
here->HSMHV_csdo = - (here->HSMHV_cddo + here->HSMHV_cgdo + here->HSMHV_cbdo) ;
here->HSMHV_csgo = - (here->HSMHV_cdgo + here->HSMHV_cggo + here->HSMHV_cbgo) ;
here->HSMHV_csbo = - (here->HSMHV_cdbo + here->HSMHV_cgbo + here->HSMHV_cbbo) ;
here->HSMHV_cdso = - (here->HSMHV_cddo + here->HSMHV_cdgo + here->HSMHV_cdbo) ;
here->HSMHV_cgso = - (here->HSMHV_cgdo + here->HSMHV_cggo + here->HSMHV_cgbo) ;
here->HSMHV_csso = - (here->HSMHV_csdo + here->HSMHV_csgo + here->HSMHV_csbo) ;
cgdb = dQg_dVds - ((here->HSMHV_mode > 0) ? here->HSMHV_cgdo : here->HSMHV_cgso) ;
cggb = dQg_dVgs - here->HSMHV_cggo ;
cgsb = - (dQg_dVds + dQg_dVgs + dQg_dVbs) - ((here->HSMHV_mode > 0) ? here->HSMHV_cgso : here->HSMHV_cgdo) ;
cbdb = dQb_dVds - ((here->HSMHV_mode > 0) ? here->HSMHV_cbdo :
-(here->HSMHV_cbdo+here->HSMHV_cbgo+here->HSMHV_cbbo)) ;
cbgb = dQb_dVgs - here->HSMHV_cbgo ;
cbsb = - (dQb_dVds + dQb_dVgs + dQb_dVbs) - ((here->HSMHV_mode > 0) ? -(here->HSMHV_cbdo+here->HSMHV_cbgo+here->HSMHV_cbbo)
: here->HSMHV_cbdo) ;
cddb = dQd_dVds - ((here->HSMHV_mode > 0) ? here->HSMHV_cddo : here->HSMHV_csso) ;
cdgb = dQd_dVgs - ((here->HSMHV_mode > 0) ? here->HSMHV_cdgo : here->HSMHV_csgo) ;
cdsb = - (dQd_dVds + dQd_dVgs + dQd_dVbs) - ((here->HSMHV_mode > 0) ? here->HSMHV_cdso : here->HSMHV_csdo) ;
if (flg_nqs) {
/* by implicit differentiation of the nqs equations: */
dQi_nqs_dVds = (dQi_dVds + Iqi_nqs * dtau_dVds )/(1.0 + ag0 * tau ) ;
dQi_nqs_dVgs = (dQi_dVgs + Iqi_nqs * dtau_dVgs )/(1.0 + ag0 * tau ) ;
dQi_nqs_dVbs = (dQi_dVbs + Iqi_nqs * dtau_dVbs )/(1.0 + ag0 * tau ) ;
dQb_nqs_dVds = (dQbulk_dVds + Iqb_nqs * dtaub_dVds)/(1.0 + ag0 * taub) ;
dQb_nqs_dVgs = (dQbulk_dVgs + Iqb_nqs * dtaub_dVgs)/(1.0 + ag0 * taub) ;
dQb_nqs_dVbs = (dQbulk_dVbs + Iqb_nqs * dtaub_dVbs)/(1.0 + ag0 * taub) ;
cgdb_nqs = dQg_nqs_dQi_nqs * dQi_nqs_dVds + dQg_nqs_dQb_nqs * dQb_nqs_dVds ;
cggb_nqs = dQg_nqs_dQi_nqs * dQi_nqs_dVgs + dQg_nqs_dQb_nqs * dQb_nqs_dVgs ;
cgsb_nqs = - dQg_nqs_dQi_nqs * (dQi_nqs_dVds + dQi_nqs_dVgs + dQi_nqs_dVbs)
- dQg_nqs_dQb_nqs * (dQb_nqs_dVds + dQb_nqs_dVgs + dQb_nqs_dVbs) ;
cbdb_nqs = dQb_nqs_dVds ;
cbgb_nqs = dQb_nqs_dVgs ;
cbsb_nqs = -(dQb_nqs_dVds + dQb_nqs_dVgs + dQb_nqs_dVbs) ;
cddb_nqs = dQd_nqs_dVds + dQd_nqs_dQi_nqs * dQi_nqs_dVds ;
cdgb_nqs= dQd_nqs_dVgs + dQd_nqs_dQi_nqs * dQi_nqs_dVgs ;
cdsb_nqs= -(dQd_nqs_dVds + dQd_nqs_dVgs + dQd_nqs_dVbs) - dQd_nqs_dQi_nqs * (dQi_nqs_dVds + dQi_nqs_dVgs + dQi_nqs_dVbs) ;
} else {
cgdb_nqs = cggb_nqs = cgsb_nqs = cbdb_nqs = cbgb_nqs = cbsb_nqs = cddb_nqs = cdgb_nqs = cdsb_nqs = 0.0 ;
}
printf( "--- variables returned from HSMHVevaluate() ----\n" ) ;
printf( "von = %12.5e\n" , here->HSMHV_von ) ;
printf( "vdsat = %12.5e\n" , here->HSMHV_vdsat ) ;
printf( "ids = %12.5e\n" , here->HSMHV_ids ) ;
printf( "gds = %12.5e\n" , here->HSMHV_dIds_dVdsi ) ;
printf( "gm = %12.5e\n" , here->HSMHV_dIds_dVgsi ) ;
printf( "gmbs = %12.5e\n" , here->HSMHV_dIds_dVbsi ) ;
printf( "cggo = %12.5e\n" , here->HSMHV_cggo ) ;
printf( "cgdo = %12.5e\n" , (here->HSMHV_mode > 0) ? here->HSMHV_cgdo : here->HSMHV_cgso ) ;
printf( "cgso = %12.5e\n" , (here->HSMHV_mode > 0) ? here->HSMHV_cgso : here->HSMHV_cgdo ) ;
printf( "cdgo = %12.5e\n" , (here->HSMHV_mode > 0) ? here->HSMHV_cdgo : here->HSMHV_csgo ) ;
printf( "cddo = %12.5e\n" , (here->HSMHV_mode > 0) ? here->HSMHV_cddo : here->HSMHV_csso ) ;
printf( "cdso = %12.5e\n" , (here->HSMHV_mode > 0) ? here->HSMHV_cdso : here->HSMHV_csdo ) ;
printf( "csgo = %12.5e\n" , (here->HSMHV_mode > 0) ? here->HSMHV_csgo : here->HSMHV_cdgo ) ;
printf( "csdo = %12.5e\n" , (here->HSMHV_mode > 0) ? here->HSMHV_csdo : here->HSMHV_cdso ) ;
printf( "csso = %12.5e\n" , (here->HSMHV_mode > 0) ? here->HSMHV_csso : here->HSMHV_cddo ) ;
printf( "qg = %12.5e\n" , Qg + Qg_nqs) ;
printf( "qd = %12.5e\n" , Qd + Qd_nqs) ;
printf( "qs = %12.5e\n" , Qs + Qs_nqs) ;
printf( "cggb = %12.5e\n" , cggb + cggb_nqs ) ;
printf( "cgsb = %12.5e\n" , cgsb + cgsb_nqs ) ;
printf( "cgdb = %12.5e\n" , cgdb + cgdb_nqs ) ;
printf( "cbgb = %12.5e\n" , cbgb + cbgb_nqs ) ;
printf( "cbsb = %12.5e\n" , cbsb + cbsb_nqs ) ;
printf( "cbdb = %12.5e\n" , cbdb + cbdb_nqs ) ;
printf( "cdgb = %12.5e\n" , cdgb + cdgb_nqs ) ;
printf( "cdsb = %12.5e\n" , cdsb + cdsb_nqs ) ;
printf( "cddb = %12.5e\n" , cddb + cddb_nqs ) ;
printf( "ibd = %12.5e\n" , Ibd ) ;
printf( "ibs = %12.5e\n" , Ibs ) ;
printf( "gbd = %12.5e\n" , Gbd ) ;
printf( "gbs = %12.5e\n" , Gbs ) ;
printf( "capbd = %12.5e\n" , Cbd ) ;
printf( "capbs = %12.5e\n" , Cbs ) ;
printf( "qbd = %12.5e\n" , Qbd ) ;
printf( "qbs = %12.5e\n" , Qbs ) ;
printf( "isub = %12.5e\n" , here->HSMHV_isub ) ;
printf( "gbgs = %12.5e\n" , dIsub_dVgs + dIsubs_dVgs ) ;
printf( "gbds = %12.5e\n" , dIsub_dVds + dIsubs_dVds ) ;
printf( "gbbs = %12.5e\n" , dIsub_dVbs + dIsubs_dVbs ) ;
printf( "S_flicker_noise * ( freq / gain ) = %.16e\n" , here->HSMHV_noiflick ) ;
printf( "S_thermal_noise / ( gain * 4kT ) = %.16e\n" , here->HSMHV_noithrml ) ;
printf( "S_induced_gate_noise / ( gain * freq^2 ) = %.16e\n" , here->HSMHV_noiigate ) ;
printf( "cross-correlation coefficient (= Sigid/sqrt(Sig*Sid) ) = %.16e\n" , here->HSMHV_noicross ) ;
/* print Surface Potentials */
/* printf( "ivds %e ivgs %e ivbs %e Ps0 %.16e Pds %.16e\n" , */
/* ivds, ivgs, ivbs, here->HSMHV_ps0_prv, here->HSMHV_pds_prv ) ; */
}
/* print all outputs ------------AA */
/* End of HSMHVld_info_eval.h */

1855
src/spicelib/devices/hisimhv/hsmhvmask.c Normal file
View File

File diff suppressed because it is too large Load Diff

54
src/spicelib/devices/hisimhv/hsmhvmdel.c Normal file
View File

@ -0,0 +1,54 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvmdel.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "hsmhvdef.h"
#include "sperror.h"
#include "suffix.h"
int HSMHVmDelete(
GENmodel **inModel,
IFuid modname,
GENmodel *kill)
{
HSMHVmodel **model = (HSMHVmodel**)inModel;
HSMHVmodel *modfast = (HSMHVmodel*)kill;
HSMHVinstance *here;
HSMHVinstance *prev = NULL;
HSMHVmodel **oldmod;
oldmod = model;
for ( ;*model ;model = &((*model)->HSMHVnextModel) ) {
if ( (*model)->HSMHVmodName == modname ||
(modfast && *model == modfast) ) goto delgot;
oldmod = model;
}
return(E_NOMOD);
delgot:
*oldmod = (*model)->HSMHVnextModel; /* cut deleted device out of list */
for ( here = (*model)->HSMHVinstances ;
here ;here = here->HSMHVnextInstance ) {
if (prev) FREE(prev);
prev = here;
}
if (prev) FREE(prev);
FREE(*model);
return(OK);
}

2454
src/spicelib/devices/hisimhv/hsmhvmpar.c Normal file
View File

File diff suppressed because it is too large Load Diff

279
src/spicelib/devices/hisimhv/hsmhvnoi.c Normal file
View File

@ -0,0 +1,279 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvnoi.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "hsmhvdef.h"
#include "cktdefs.h"
/* #include "fteconst.h" */
#include "iferrmsg.h"
#include "noisedef.h"
#include "suffix.h"
#include "const.h" /* jwan */
#include "hsmhvevalenv.h"
/* #include "hsmhvmacro.h" */
/*
* HSMHVnoise (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".
*/
extern void NevalSrc();
extern double Nintegrate();
int HSMHVnoise (
int mode, int operation,
GENmodel *inModel,
CKTcircuit *ckt,
register Ndata *data,
double *OnDens)
{
register HSMHVmodel *model = (HSMHVmodel *)inModel;
register HSMHVinstance *here;
char name[N_MXVLNTH];
double tempOnoise=0.0 ;
double tempInoise=0.0 ;
double noizDens[HSMHVNSRCS] ;
double lnNdens[HSMHVNSRCS] ;
register int i;
double G =0.0 ;
double TTEMP = 0.0 ;
/* define the names of the noise sources */
static char * HSMHVnNames[HSMHVNSRCS] = {
/* Note that we have to keep the order
consistent with the index definitions
in hsmhvdefs.h */
".rd", /* noise due to rd */
".rs", /* noise due to rs */
".id", /* noise due to id */
".1ovf", /* flicker (1/f) noise */
".ign", /* induced gate noise component at the drain node */
"" /* total transistor noise */
};
for ( ;model != NULL; model = model->HSMHVnextModel ) {
for ( here = model->HSMHVinstances; here != NULL;
here = here->HSMHVnextInstance ) {
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 < HSMHVNSRCS; i++ ) {
(void) sprintf(name, "onoise.%s%s",
(char *)here->HSMHVname, HSMHVnNames[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, NULL);
}
break;
case INT_NOIZ:
for ( i = 0; i < HSMHVNSRCS; i++ ) {
(void) sprintf(name, "onoise_total.%s%s",
(char *)here->HSMHVname, HSMHVnNames[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, NULL);
(void) sprintf(name, "inoise_total.%s%s",
(char *)here->HSMHVname, HSMHVnNames[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, NULL);
}
break;
}
}
break;
case N_CALC:
switch (mode) {
case N_DENS:
/* temperature */
TTEMP = ckt->CKTtemp;
if ( here->HSMHV_dtemp_Given ) { TTEMP = TTEMP + here->HSMHV_dtemp ; }
TTEMP = TTEMP + *(ckt->CKTstate0 + here->HSMHVdeltemp) ;
/* rs/rd thermal noise */
if ( model->HSMHV_corsrd == 1 || model->HSMHV_corsrd == 3 ) {
NevalSrc(&noizDens[HSMHVRDNOIZ], (double*) NULL,
ckt, N_GAIN,
here->HSMHVdNodePrime, here->HSMHVdNode,
(double) 0.0);
noizDens[HSMHVRDNOIZ] *= 4 * C_KB * TTEMP * here->HSMHVdrainConductance ;
lnNdens[HSMHVRDNOIZ] = log( MAX(noizDens[HSMHVRDNOIZ],N_MINLOG) );
NevalSrc(&noizDens[HSMHVRSNOIZ], (double*) NULL,
ckt, N_GAIN,
here->HSMHVsNodePrime, here->HSMHVsNode,
(double) 0.0);
noizDens[HSMHVRSNOIZ] *= 4 * C_KB * TTEMP * here->HSMHVsourceConductance ;
lnNdens[HSMHVRSNOIZ] = log( MAX(noizDens[HSMHVRSNOIZ],N_MINLOG) );
} else {
noizDens[HSMHVRDNOIZ] = 0e0 ;
lnNdens[HSMHVRDNOIZ] = N_MINLOG ;
noizDens[HSMHVRSNOIZ] = 0e0 ;
lnNdens[HSMHVRSNOIZ] = N_MINLOG ;
}
/* channel thermal noise */
NevalSrc(&noizDens[HSMHVIDNOIZ], (double*) NULL,
ckt, N_GAIN,
here->HSMHVdNodePrime, here->HSMHVsNodePrime,
(double) 0.0);
switch( model->HSMHV_noise ) {
case 1:
/* HiSIMHV model */
G = here->HSMHV_noithrml ;
noizDens[HSMHVIDNOIZ] *= 4 * C_KB * TTEMP * G ;
lnNdens[HSMHVIDNOIZ] = log( MAX(noizDens[HSMHVIDNOIZ],N_MINLOG) );
break;
}
/* flicker noise */
NevalSrc(&noizDens[HSMHVFLNOIZ], (double*) NULL,
ckt, N_GAIN,
here->HSMHVdNodePrime, here->HSMHVsNodePrime,
(double) 0.0);
switch ( model->HSMHV_noise ) {
case 1:
/* HiSIM model */
noizDens[HSMHVFLNOIZ] *= here->HSMHV_noiflick / pow(data->freq, model->HSMHV_falph) ;
lnNdens[HSMHVFLNOIZ] = log(MAX(noizDens[HSMHVFLNOIZ], N_MINLOG));
break;
}
/* induced gate noise */
NevalSrc(&noizDens[HSMHVIGNOIZ], (double*) NULL,
ckt, N_GAIN,
here->HSMHVdNodePrime, here->HSMHVsNodePrime,
(double) 0.0);
switch ( model->HSMHV_noise ) {
case 1:
/* HiSIM model */
noizDens[HSMHVIGNOIZ] *= here->HSMHV_noiigate * here->HSMHV_noicross * here->HSMHV_noicross * data->freq * data->freq;
lnNdens[HSMHVIGNOIZ] = log(MAX(noizDens[HSMHVIGNOIZ], N_MINLOG));
break;
}
/* total */
noizDens[HSMHVTOTNOIZ] = noizDens[HSMHVRDNOIZ] + noizDens[HSMHVRSNOIZ]
+ noizDens[HSMHVIDNOIZ] + noizDens[HSMHVFLNOIZ] + noizDens[HSMHVIGNOIZ];
lnNdens[HSMHVTOTNOIZ] = log(MAX(noizDens[HSMHVTOTNOIZ], N_MINLOG));
*OnDens += noizDens[HSMHVTOTNOIZ];
if ( data->delFreq == 0.0 ) {
/* if we haven't done any previous
integration, we need to initialize our
"history" variables.
*/
for ( i = 0; i < HSMHVNSRCS; i++ )
here->HSMHVnVar[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 < HSMHVNSRCS; i++) {
here->HSMHVnVar[OUTNOIZ][i] = 0.0;
here->HSMHVnVar[INNOIZ][i] = 0.0;
}
}
}
else {
/* data->delFreq != 0.0,
we have to integrate.
*/
for ( i = 0; i < HSMHVNSRCS; i++ ) {
if ( i != HSMHVTOTNOIZ ) {
tempOnoise =
Nintegrate(noizDens[i], lnNdens[i],
here->HSMHVnVar[LNLSTDENS][i], data);
tempInoise =
Nintegrate(noizDens[i] * data->GainSqInv,
lnNdens[i] + data->lnGainInv,
here->HSMHVnVar[LNLSTDENS][i] + data->lnGainInv,
data);
here->HSMHVnVar[LNLSTDENS][i] = lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if ( ((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0 ) {
here->HSMHVnVar[OUTNOIZ][i] += tempOnoise;
here->HSMHVnVar[OUTNOIZ][HSMHVTOTNOIZ] += tempOnoise;
here->HSMHVnVar[INNOIZ][i] += tempInoise;
here->HSMHVnVar[INNOIZ][HSMHVTOTNOIZ] += tempInoise;
}
}
}
}
if ( data->prtSummary ) {
for (i = 0; i < HSMHVNSRCS; 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 < HSMHVNSRCS; i++ ) {
data->outpVector[data->outNumber++] = here->HSMHVnVar[OUTNOIZ][i];
data->outpVector[data->outNumber++] = here->HSMHVnVar[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);
}

212
src/spicelib/devices/hisimhv/hsmhvpar.c Normal file
View File

@ -0,0 +1,212 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvpar.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "ifsim.h"
#include "hsmhvdef.h"
#include "sperror.h"
#include "suffix.h"
int HSMHVparam(
int param,
IFvalue *value,
GENinstance *inst,
IFvalue *select)
{
HSMHVinstance *here = (HSMHVinstance*)inst;
switch (param) {
case HSMHV_COSELFHEAT:
here->HSMHV_coselfheat = value->iValue;
here->HSMHV_coselfheat_Given = TRUE;
break;
case HSMHV_COSUBNODE:
here->HSMHV_cosubnode = value->iValue;
here->HSMHV_cosubnode_Given = TRUE;
break;
case HSMHV_W:
here->HSMHV_w = value->rValue;
here->HSMHV_w_Given = TRUE;
break;
case HSMHV_L:
here->HSMHV_l = value->rValue;
here->HSMHV_l_Given = TRUE;
break;
case HSMHV_AS:
here->HSMHV_as = value->rValue;
here->HSMHV_as_Given = TRUE;
break;
case HSMHV_AD:
here->HSMHV_ad = value->rValue;
here->HSMHV_ad_Given = TRUE;
break;
case HSMHV_PS:
here->HSMHV_ps = value->rValue;
here->HSMHV_ps_Given = TRUE;
break;
case HSMHV_PD:
here->HSMHV_pd = value->rValue;
here->HSMHV_pd_Given = TRUE;
break;
case HSMHV_NRS:
here->HSMHV_nrs = value->rValue;
here->HSMHV_nrs_Given = TRUE;
break;
case HSMHV_NRD:
here->HSMHV_nrd = value->rValue;
here->HSMHV_nrd_Given = TRUE;
break;
case HSMHV_DTEMP:
here->HSMHV_dtemp = value->rValue;
here->HSMHV_dtemp_Given = TRUE;
break;
case HSMHV_OFF:
here->HSMHV_off = value->iValue;
break;
case HSMHV_IC_VBS:
here->HSMHV_icVBS = value->rValue;
here->HSMHV_icVBS_Given = TRUE;
break;
case HSMHV_IC_VDS:
here->HSMHV_icVDS = value->rValue;
here->HSMHV_icVDS_Given = TRUE;
break;
case HSMHV_IC_VGS:
here->HSMHV_icVGS = value->rValue;
here->HSMHV_icVGS_Given = TRUE;
break;
case HSMHV_IC:
switch (value->v.numValue) {
case 3:
here->HSMHV_icVBS = *(value->v.vec.rVec + 2);
here->HSMHV_icVBS_Given = TRUE;
case 2:
here->HSMHV_icVGS = *(value->v.vec.rVec + 1);
here->HSMHV_icVGS_Given = TRUE;
case 1:
here->HSMHV_icVDS = *(value->v.vec.rVec);
here->HSMHV_icVDS_Given = TRUE;
break;
default:
return(E_BADPARM);
}
break;
case HSMHV_CORBNET:
here->HSMHV_corbnet = value->iValue;
here->HSMHV_corbnet_Given = TRUE;
break;
case HSMHV_RBPB:
here->HSMHV_rbpb = value->rValue;
here->HSMHV_rbpb_Given = TRUE;
break;
case HSMHV_RBPD:
here->HSMHV_rbpd = value->rValue;
here->HSMHV_rbpd_Given = TRUE;
break;
case HSMHV_RBPS:
here->HSMHV_rbps = value->rValue;
here->HSMHV_rbps_Given = TRUE;
break;
case HSMHV_RBDB:
here->HSMHV_rbdb = value->rValue;
here->HSMHV_rbdb_Given = TRUE;
break;
case HSMHV_RBSB:
here->HSMHV_rbsb = value->rValue;
here->HSMHV_rbsb_Given = TRUE;
break;
case HSMHV_CORG:
here->HSMHV_corg = value->iValue;
here->HSMHV_corg_Given = TRUE;
break;
case HSMHV_NGCON:
here->HSMHV_ngcon = value->rValue;
here->HSMHV_ngcon_Given = TRUE;
break;
case HSMHV_XGW:
here->HSMHV_xgw = value->rValue;
here->HSMHV_xgw_Given = TRUE;
break;
case HSMHV_XGL:
here->HSMHV_xgl = value->rValue;
here->HSMHV_xgl_Given = TRUE;
break;
case HSMHV_NF:
here->HSMHV_nf = value->rValue;
here->HSMHV_nf_Given = TRUE;
break;
case HSMHV_SA:
here->HSMHV_sa = value->rValue;
here->HSMHV_sa_Given = TRUE;
break;
case HSMHV_SB:
here->HSMHV_sb = value->rValue;
here->HSMHV_sb_Given = TRUE;
break;
case HSMHV_SD:
here->HSMHV_sd = value->rValue;
here->HSMHV_sd_Given = TRUE;
break;
case HSMHV_NSUBCDFM:
here->HSMHV_nsubcdfm = value->rValue;
here->HSMHV_nsubcdfm_Given = TRUE;
break;
case HSMHV_M:
here->HSMHV_m = value->rValue;
here->HSMHV_m_Given = TRUE;
break;
case HSMHV_SUBLD1:
here->HSMHV_subld1 = value->rValue;
here->HSMHV_subld1_Given = TRUE;
break;
case HSMHV_SUBLD2:
here->HSMHV_subld2 = value->rValue;
here->HSMHV_subld2_Given = TRUE;
break;
case HSMHV_LOVER:
here->HSMHV_lover = value->rValue;
here->HSMHV_lover_Given = TRUE;
break;
case HSMHV_LOVERS:
here->HSMHV_lovers = value->rValue;
here->HSMHV_lovers_Given = TRUE;
break;
case HSMHV_LOVERLD:
here->HSMHV_loverld = value->rValue;
here->HSMHV_loverld_Given = TRUE;
break;
case HSMHV_LDRIFT1:
here->HSMHV_ldrift1 = value->rValue;
here->HSMHV_ldrift1_Given = TRUE;
break;
case HSMHV_LDRIFT2:
here->HSMHV_ldrift2 = value->rValue;
here->HSMHV_ldrift2_Given = TRUE;
break;
case HSMHV_LDRIFT1S:
here->HSMHV_ldrift1s = value->rValue;
here->HSMHV_ldrift1s_Given = TRUE;
break;
case HSMHV_LDRIFT2S:
here->HSMHV_ldrift2s = value->rValue;
here->HSMHV_ldrift2s_Given = TRUE;
break;
default:
return(E_BADPARM);
}
return(OK);
}

280
src/spicelib/devices/hisimhv/hsmhvpzld.c Normal file
View File

@ -0,0 +1,280 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvpzld.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "complex.h"
#include "sperror.h"
#include "hsmhvdef.h"
#include "suffix.h"
int HSMHVpzLoad(
GENmodel *inModel,
register CKTcircuit *ckt,
register SPcomplex *s)
{
register HSMHVmodel *model = (HSMHVmodel*)inModel;
register HSMHVinstance *here;
int flg_nqs =0 ;
#define dNode 0
#define dNodePrime 1
#define gNode 2
#define gNodePrime 3
#define sNode 4
#define sNodePrime 5
#define bNodePrime 6
#define bNode 7
#define dbNode 8
#define sbNode 9
#define tempNode 10
#define qiNode 11
#define qbNode 12
for ( ;model != NULL ;model = model->HSMHVnextModel ) {
for ( here = model->HSMHVinstances ;here!= NULL ;
here = here->HSMHVnextInstance ) {
flg_nqs = model->HSMHV_conqs ;
/* stamp matrix */
/*drain*/
*(here->HSMHVDdPtr) += here->HSMHV_ydc_d[dNode] + here->HSMHV_ydyn_d[dNode] * s->real;
*(here->HSMHVDdPtr +1) += here->HSMHV_ydyn_d[dNode] * s->imag;
*(here->HSMHVDdpPtr) += here->HSMHV_ydc_d[dNodePrime] + here->HSMHV_ydyn_d[dNodePrime] * s->real;
*(here->HSMHVDdpPtr +1) += here->HSMHV_ydyn_d[dNodePrime] * s->imag;
*(here->HSMHVDgpPtr) += here->HSMHV_ydc_d[gNodePrime] + here->HSMHV_ydyn_d[gNodePrime] * s->real;
*(here->HSMHVDgpPtr +1) += here->HSMHV_ydyn_d[gNodePrime] * s->imag;
*(here->HSMHVDsPtr) += here->HSMHV_ydc_d[sNode] + here->HSMHV_ydyn_d[sNode] * s->real;
*(here->HSMHVDsPtr +1) += here->HSMHV_ydyn_d[sNode] * s->imag;
*(here->HSMHVDbpPtr) += here->HSMHV_ydc_d[bNodePrime] + here->HSMHV_ydyn_d[bNodePrime] * s->real;
*(here->HSMHVDbpPtr +1) += here->HSMHV_ydyn_d[bNodePrime] * s->imag;
*(here->HSMHVDdbPtr) += here->HSMHV_ydc_d[dbNode] + here->HSMHV_ydyn_d[dbNode] * s->real;
*(here->HSMHVDdbPtr +1) += here->HSMHV_ydyn_d[dbNode] * s->imag;
if( here->HSMHVtempNode > 0) {
*(here->HSMHVDtempPtr) += model->HSMHV_type * (here->HSMHV_ydc_d[tempNode] + here->HSMHV_ydyn_d[tempNode] * s->real);
*(here->HSMHVDtempPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_d[tempNode] * s->imag;
}
/*drain prime*/
*(here->HSMHVDPdPtr) += here->HSMHV_ydc_dP[dNode] + here->HSMHV_ydyn_dP[dNode] * s->real;
*(here->HSMHVDPdPtr +1) += here->HSMHV_ydyn_dP[dNode] * s->imag;
*(here->HSMHVDPdpPtr) += here->HSMHV_ydc_dP[dNodePrime] + here->HSMHV_ydyn_dP[dNodePrime] * s->real;
*(here->HSMHVDPdpPtr +1) += here->HSMHV_ydyn_dP[dNodePrime] * s->imag;
*(here->HSMHVDPgpPtr) += here->HSMHV_ydc_dP[gNodePrime] + here->HSMHV_ydyn_dP[gNodePrime] * s->real;
*(here->HSMHVDPgpPtr +1) += here->HSMHV_ydyn_dP[gNodePrime] * s->imag;
*(here->HSMHVDPsPtr) += here->HSMHV_ydc_dP[sNode] + here->HSMHV_ydyn_dP[sNode] * s->real;
*(here->HSMHVDPsPtr +1) += here->HSMHV_ydyn_dP[sNode] * s->imag;
*(here->HSMHVDPspPtr) += here->HSMHV_ydc_dP[sNodePrime] + here->HSMHV_ydyn_dP[sNodePrime] * s->real;
*(here->HSMHVDPspPtr +1) += here->HSMHV_ydyn_dP[sNodePrime] * s->imag;
*(here->HSMHVDPbpPtr) += here->HSMHV_ydc_dP[bNodePrime] + here->HSMHV_ydyn_dP[bNodePrime] * s->real;
*(here->HSMHVDPbpPtr +1) += here->HSMHV_ydyn_dP[bNodePrime] * s->imag;
if( here->HSMHVtempNode > 0) {
*(here->HSMHVDPtempPtr) += model->HSMHV_type * (here->HSMHV_ydc_dP[tempNode] + here->HSMHV_ydyn_dP[tempNode] * s->real);
*(here->HSMHVDPtempPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_dP[tempNode] * s->imag;
}
if (flg_nqs) {
*(here->HSMHVDPqiPtr) += model->HSMHV_type * (here->HSMHV_ydc_dP[qiNode] + here->HSMHV_ydyn_dP[qiNode] * s->real);
*(here->HSMHVDPqiPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_dP[qiNode] * s->imag;
}
/*gate*/
*(here->HSMHVGgPtr) += here->HSMHV_ydc_g[gNode] + here->HSMHV_ydyn_g[gNode] * s->real;
*(here->HSMHVGgPtr +1) += here->HSMHV_ydyn_g[gNode] * s->imag;
*(here->HSMHVGgpPtr) += here->HSMHV_ydc_g[gNodePrime] + here->HSMHV_ydyn_g[gNodePrime] * s->real;
*(here->HSMHVGgpPtr +1) += here->HSMHV_ydyn_g[gNodePrime] * s->imag;
/*gate prime*/
*(here->HSMHVGPdPtr) += here->HSMHV_ydc_gP[dNode] + here->HSMHV_ydyn_gP[dNode] * s->real;
*(here->HSMHVGPdPtr +1) += here->HSMHV_ydyn_gP[dNode] * s->imag;
*(here->HSMHVGPdpPtr) += here->HSMHV_ydc_gP[dNodePrime] + here->HSMHV_ydyn_gP[dNodePrime] * s->real;
*(here->HSMHVGPdpPtr +1) += here->HSMHV_ydyn_gP[dNodePrime] * s->imag;
*(here->HSMHVGPgPtr) += here->HSMHV_ydc_gP[gNode] + here->HSMHV_ydyn_gP[gNode] * s->real;
*(here->HSMHVGPgPtr +1) += here->HSMHV_ydyn_gP[gNode] * s->imag;
*(here->HSMHVGPgpPtr) += here->HSMHV_ydc_gP[gNodePrime] + here->HSMHV_ydyn_gP[gNodePrime] * s->real;
*(here->HSMHVGPgpPtr +1) += here->HSMHV_ydyn_gP[gNodePrime] * s->imag;
*(here->HSMHVGPsPtr) += here->HSMHV_ydc_gP[sNode] + here->HSMHV_ydyn_gP[sNode] * s->real;
*(here->HSMHVGPsPtr +1) += here->HSMHV_ydyn_gP[sNode] * s->imag;
*(here->HSMHVGPspPtr) += here->HSMHV_ydc_gP[sNodePrime] + here->HSMHV_ydyn_gP[sNodePrime] * s->real;
*(here->HSMHVGPspPtr +1) += here->HSMHV_ydyn_gP[sNodePrime] * s->imag;
*(here->HSMHVGPbpPtr) += here->HSMHV_ydc_gP[bNodePrime] + here->HSMHV_ydyn_gP[bNodePrime] * s->real;
*(here->HSMHVGPbpPtr +1) += here->HSMHV_ydyn_gP[bNodePrime] * s->imag;
if( here->HSMHVtempNode > 0) {
*(here->HSMHVGPtempPtr) += model->HSMHV_type * (here->HSMHV_ydc_gP[tempNode] + here->HSMHV_ydyn_gP[tempNode] * s->real);
*(here->HSMHVGPtempPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_gP[tempNode] * s->imag;
}
if (flg_nqs) {
*(here->HSMHVGPqiPtr) += model->HSMHV_type * (here->HSMHV_ydc_gP[qiNode] + here->HSMHV_ydyn_gP[qiNode] * s->real);
*(here->HSMHVGPqiPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_gP[qiNode] * s->imag;
*(here->HSMHVGPqbPtr) += model->HSMHV_type * (here->HSMHV_ydc_gP[qbNode] + here->HSMHV_ydyn_gP[qbNode] * s->real);
*(here->HSMHVGPqbPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_gP[qbNode] * s->imag;
}
/*source*/
*(here->HSMHVSdPtr) += here->HSMHV_ydc_s[dNode] + here->HSMHV_ydyn_s[dNode] * s->real;
*(here->HSMHVSdPtr +1) += here->HSMHV_ydyn_s[dNode] * s->imag;
*(here->HSMHVSgpPtr) += here->HSMHV_ydc_s[gNodePrime] + here->HSMHV_ydyn_s[gNodePrime] * s->real;
*(here->HSMHVSgpPtr +1) += here->HSMHV_ydyn_s[gNodePrime] * s->imag;
*(here->HSMHVSsPtr) += here->HSMHV_ydc_s[sNode] + here->HSMHV_ydyn_s[sNode] * s->real;
*(here->HSMHVSsPtr +1) += here->HSMHV_ydyn_s[sNode] * s->imag;
*(here->HSMHVSspPtr) += here->HSMHV_ydc_s[sNodePrime] + here->HSMHV_ydyn_s[sNodePrime] * s->real;
*(here->HSMHVSspPtr +1) += here->HSMHV_ydyn_s[sNodePrime] * s->imag;
*(here->HSMHVSbpPtr) += here->HSMHV_ydc_s[bNodePrime] + here->HSMHV_ydyn_s[bNodePrime] * s->real;
*(here->HSMHVSbpPtr +1) += here->HSMHV_ydyn_s[bNodePrime] * s->imag;
*(here->HSMHVSsbPtr) += here->HSMHV_ydc_s[sbNode] + here->HSMHV_ydyn_s[sbNode] * s->real;
*(here->HSMHVSsbPtr +1) += here->HSMHV_ydyn_s[sbNode] * s->imag;
if( here->HSMHVtempNode > 0) {
*(here->HSMHVStempPtr) += model->HSMHV_type * (here->HSMHV_ydc_s[tempNode] + here->HSMHV_ydyn_s[tempNode] * s->real);
*(here->HSMHVStempPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_s[tempNode] * s->imag;
}
/*source prime*/
*(here->HSMHVSPdPtr) += here->HSMHV_ydc_sP[dNode] + here->HSMHV_ydyn_sP[dNode] * s->real;
*(here->HSMHVSPdPtr +1) += here->HSMHV_ydyn_sP[dNode] * s->imag;
*(here->HSMHVSPdpPtr) += here->HSMHV_ydc_sP[dNodePrime] + here->HSMHV_ydyn_sP[dNodePrime] * s->real;
*(here->HSMHVSPdpPtr +1) += here->HSMHV_ydyn_sP[dNodePrime] * s->imag;
*(here->HSMHVSPgpPtr) += here->HSMHV_ydc_sP[gNodePrime] + here->HSMHV_ydyn_sP[gNodePrime] * s->real;
*(here->HSMHVSPgpPtr +1) += here->HSMHV_ydyn_sP[gNodePrime] * s->imag;
*(here->HSMHVSPsPtr) += here->HSMHV_ydc_sP[sNode] + here->HSMHV_ydyn_sP[sNode] * s->real;
*(here->HSMHVSPsPtr +1) += here->HSMHV_ydyn_sP[sNode] * s->imag;
*(here->HSMHVSPspPtr) += here->HSMHV_ydc_sP[sNodePrime] + here->HSMHV_ydyn_sP[sNodePrime] * s->real;
*(here->HSMHVSPspPtr +1) += here->HSMHV_ydyn_sP[sNodePrime] * s->imag;
*(here->HSMHVSPbpPtr) += here->HSMHV_ydc_sP[bNodePrime] + here->HSMHV_ydyn_sP[bNodePrime] * s->real;
*(here->HSMHVSPbpPtr +1) += here->HSMHV_ydyn_sP[bNodePrime] * s->imag;
if( here->HSMHVtempNode > 0) {
*(here->HSMHVSPtempPtr) += model->HSMHV_type * (here->HSMHV_ydc_sP[tempNode] + here->HSMHV_ydyn_sP[tempNode] * s->real);
*(here->HSMHVSPtempPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_sP[tempNode] * s->imag;
}
if (flg_nqs) {
*(here->HSMHVSPqiPtr) += model->HSMHV_type * (here->HSMHV_ydc_sP[qiNode] + here->HSMHV_ydyn_sP[qiNode] * s->real);
*(here->HSMHVSPqiPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_sP[qiNode] * s->imag;
}
/*bulk prime*/
*(here->HSMHVBPdpPtr) += here->HSMHV_ydc_bP[dNodePrime] + here->HSMHV_ydyn_bP[dNodePrime] * s->real;
*(here->HSMHVBPdpPtr +1) += here->HSMHV_ydyn_bP[dNodePrime] * s->imag;
*(here->HSMHVBPgpPtr) += here->HSMHV_ydc_bP[gNodePrime] + here->HSMHV_ydyn_bP[gNodePrime] * s->real;
*(here->HSMHVBPgpPtr +1) += here->HSMHV_ydyn_bP[gNodePrime] * s->imag;
*(here->HSMHVBPspPtr) += here->HSMHV_ydc_bP[sNodePrime] + here->HSMHV_ydyn_bP[sNodePrime] * s->real;
*(here->HSMHVBPspPtr +1) += here->HSMHV_ydyn_bP[sNodePrime] * s->imag;
*(here->HSMHVBPbpPtr) += here->HSMHV_ydc_bP[bNodePrime] + here->HSMHV_ydyn_bP[bNodePrime] * s->real;
*(here->HSMHVBPbpPtr +1) += here->HSMHV_ydyn_bP[bNodePrime] * s->imag;
*(here->HSMHVBPbPtr) += here->HSMHV_ydc_bP[bNode] + here->HSMHV_ydyn_bP[bNode] * s->real;
*(here->HSMHVBPbPtr +1) += here->HSMHV_ydyn_bP[bNode] * s->imag;
*(here->HSMHVBPdbPtr) += here->HSMHV_ydc_bP[dbNode] + here->HSMHV_ydyn_bP[dbNode] * s->real;
*(here->HSMHVBPdbPtr +1) += here->HSMHV_ydyn_bP[dbNode] * s->imag;
*(here->HSMHVBPsbPtr) += here->HSMHV_ydc_bP[sbNode] + here->HSMHV_ydyn_bP[sbNode] * s->real;
*(here->HSMHVBPsbPtr +1) += here->HSMHV_ydyn_bP[sbNode] * s->imag;
if( here->HSMHVtempNode > 0) {
*(here->HSMHVBPtempPtr) += model->HSMHV_type * (here->HSMHV_ydc_bP[tempNode] + here->HSMHV_ydyn_bP[tempNode] * s->real);
*(here->HSMHVBPtempPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_bP[tempNode] * s->imag;
}
if (flg_nqs) {
*(here->HSMHVBPqbPtr) += model->HSMHV_type * (here->HSMHV_ydc_bP[qbNode] + here->HSMHV_ydyn_bP[qbNode] * s->real);
*(here->HSMHVBPqbPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_bP[qbNode] * s->imag;
}
/*bulk*/
*(here->HSMHVBbpPtr) += here->HSMHV_ydc_b[bNodePrime] + here->HSMHV_ydyn_b[bNodePrime] * s->real;
*(here->HSMHVBbpPtr +1) += here->HSMHV_ydyn_b[bNodePrime] * s->imag;
*(here->HSMHVBbPtr) += here->HSMHV_ydc_b[bNode] + here->HSMHV_ydyn_b[bNode] * s->real;
*(here->HSMHVBbPtr +1) += here->HSMHV_ydyn_b[bNode] * s->imag;
/*drain bulk*/
*(here->HSMHVDBdPtr) += here->HSMHV_ydc_db[dNode] + here->HSMHV_ydyn_db[dNode] * s->real;
*(here->HSMHVDBdPtr +1) += here->HSMHV_ydyn_db[dNode] * s->imag;
*(here->HSMHVDBbpPtr) += here->HSMHV_ydc_db[bNodePrime] + here->HSMHV_ydyn_db[bNodePrime] * s->real;
*(here->HSMHVDBbpPtr +1) += here->HSMHV_ydyn_db[bNodePrime] * s->imag;
*(here->HSMHVDBdbPtr) += here->HSMHV_ydc_db[dbNode] + here->HSMHV_ydyn_db[dbNode] * s->real;
*(here->HSMHVDBdbPtr +1) += here->HSMHV_ydyn_db[dbNode] * s->imag;
if( here->HSMHVtempNode > 0) {
*(here->HSMHVDBtempPtr) += model->HSMHV_type * (here->HSMHV_ydc_db[tempNode] + here->HSMHV_ydyn_db[tempNode] * s->real);
*(here->HSMHVDBtempPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_db[tempNode] * s->imag;
}
/*source bulk*/
*(here->HSMHVSBsPtr) += here->HSMHV_ydc_sb[sNode] + here->HSMHV_ydyn_sb[sNode] * s->real;
*(here->HSMHVSBsPtr +1) += here->HSMHV_ydyn_sb[sNode] * s->imag;
*(here->HSMHVSBbpPtr) += here->HSMHV_ydc_sb[bNodePrime] + here->HSMHV_ydyn_sb[bNodePrime] * s->real;
*(here->HSMHVSBbpPtr +1) += here->HSMHV_ydyn_sb[bNodePrime] * s->imag;
*(here->HSMHVSBsbPtr) += here->HSMHV_ydc_sb[sbNode] + here->HSMHV_ydyn_sb[sbNode] * s->real;
*(here->HSMHVSBsbPtr +1) += here->HSMHV_ydyn_sb[sbNode] * s->imag;
if( here->HSMHVtempNode > 0) {
*(here->HSMHVSBtempPtr) += model->HSMHV_type * (here->HSMHV_ydc_sb[tempNode] + here->HSMHV_ydyn_sb[tempNode] * s->real);
*(here->HSMHVSBtempPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_sb[tempNode] * s->imag;
}
/*temp*/
if( here->HSMHVtempNode > 0) {
*(here->HSMHVTempdPtr) += model->HSMHV_type * (here->HSMHV_ydc_t[dNode] + here->HSMHV_ydyn_t[dNode] * s->real);
*(here->HSMHVTempdPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_t[dNode] * s->imag;
*(here->HSMHVTempdpPtr) += model->HSMHV_type * (here->HSMHV_ydc_t[dNodePrime] + here->HSMHV_ydyn_t[dNodePrime] * s->real);
*(here->HSMHVTempdpPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_t[dNodePrime] * s->imag;
*(here->HSMHVTempgpPtr) += model->HSMHV_type * (here->HSMHV_ydc_t[gNodePrime] + here->HSMHV_ydyn_t[gNodePrime] * s->real);
*(here->HSMHVTempgpPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_t[gNodePrime] * s->imag;
*(here->HSMHVTempsPtr) += model->HSMHV_type * (here->HSMHV_ydc_t[sNode] + here->HSMHV_ydyn_t[sNode] * s->real);
*(here->HSMHVTempsPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_t[sNode] * s->imag;
*(here->HSMHVTempspPtr) += model->HSMHV_type * (here->HSMHV_ydc_t[sNodePrime] + here->HSMHV_ydyn_t[sNodePrime] * s->real);
*(here->HSMHVTempspPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_t[sNodePrime] * s->imag;
*(here->HSMHVTempbpPtr) += model->HSMHV_type * (here->HSMHV_ydc_t[bNodePrime] + here->HSMHV_ydyn_t[bNodePrime] * s->real);
*(here->HSMHVTempbpPtr +1) += model->HSMHV_type * here->HSMHV_ydyn_t[bNodePrime] * s->imag;
*(here->HSMHVTemptempPtr) += here->HSMHV_ydc_t[tempNode] + here->HSMHV_ydyn_t[tempNode] * s->real;
*(here->HSMHVTemptempPtr +1) += here->HSMHV_ydyn_t[tempNode] * s->imag;
}
/* additional entries for flat nqs handling */
if ( flg_nqs ) {
/*qi*/
*(here->HSMHVQIdpPtr) += model->HSMHV_type * (here->HSMHV_ydc_qi[dNodePrime] + here->HSMHV_ydyn_qi[dNodePrime] * s->real);
*(here->HSMHVQIdpPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_qi[dNodePrime] * s->imag;
*(here->HSMHVQIgpPtr) += model->HSMHV_type * (here->HSMHV_ydc_qi[gNodePrime] + here->HSMHV_ydyn_qi[gNodePrime] * s->real);
*(here->HSMHVQIgpPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_qi[gNodePrime] * s->imag;
*(here->HSMHVQIspPtr) += model->HSMHV_type * (here->HSMHV_ydc_qi[sNodePrime] + here->HSMHV_ydyn_qi[sNodePrime] * s->real);
*(here->HSMHVQIspPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_qi[sNodePrime] * s->imag;
*(here->HSMHVQIbpPtr) += model->HSMHV_type * (here->HSMHV_ydc_qi[bNodePrime] + here->HSMHV_ydyn_qi[bNodePrime] * s->real);
*(here->HSMHVQIbpPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_qi[bNodePrime] * s->imag;
*(here->HSMHVQIqiPtr) += here->HSMHV_ydc_qi[qiNode] + here->HSMHV_ydyn_qi[qiNode] * s->real;
*(here->HSMHVQIqiPtr+1) += here->HSMHV_ydyn_qi[qiNode] * s->imag;
if ( here->HSMHVtempNode > 0 ) {
*(here->HSMHVQItempPtr) += here->HSMHV_ydc_qi[tempNode] + here->HSMHV_ydyn_qi[tempNode] * s->real;
*(here->HSMHVQItempPtr+1) += here->HSMHV_ydyn_qi[tempNode] * s->imag;
}
/*qb*/
*(here->HSMHVQBdpPtr) += model->HSMHV_type * (here->HSMHV_ydc_qb[dNodePrime] + here->HSMHV_ydyn_qb[dNodePrime] * s->real);
*(here->HSMHVQBdpPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_qb[dNodePrime] * s->imag;
*(here->HSMHVQBgpPtr) += model->HSMHV_type * (here->HSMHV_ydc_qb[gNodePrime] + here->HSMHV_ydyn_qb[gNodePrime] * s->real);
*(here->HSMHVQBgpPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_qb[gNodePrime] * s->imag;
*(here->HSMHVQBspPtr) += model->HSMHV_type * (here->HSMHV_ydc_qb[sNodePrime] + here->HSMHV_ydyn_qb[sNodePrime] * s->real);
*(here->HSMHVQBspPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_qb[sNodePrime] * s->imag;
*(here->HSMHVQBbpPtr) += model->HSMHV_type * (here->HSMHV_ydc_qb[bNodePrime] + here->HSMHV_ydyn_qb[bNodePrime] * s->real);
*(here->HSMHVQBbpPtr+1) += model->HSMHV_type * here->HSMHV_ydyn_qb[bNodePrime] * s->imag;
*(here->HSMHVQBqbPtr) += here->HSMHV_ydc_qb[qbNode] + here->HSMHV_ydyn_qb[qbNode] * s->real;
*(here->HSMHVQBqbPtr+1) += here->HSMHV_ydyn_qb[qbNode] * s->imag;
if ( here->HSMHVtempNode > 0 ) {
*(here->HSMHVQBtempPtr) += here->HSMHV_ydc_qb[tempNode] + here->HSMHV_ydyn_qb[tempNode] * s->real;
*(here->HSMHVQBtempPtr+1) += here->HSMHV_ydyn_qb[tempNode] * s->imag;
}
}
}
}
return(OK);
}

1454
src/spicelib/devices/hisimhv/hsmhvset.c Normal file
View File

File diff suppressed because it is too large Load Diff

419
src/spicelib/devices/hisimhv/hsmhvtemp.c Normal file
View File

@ -0,0 +1,419 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvtemp.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "smpdefs.h"
#include "cktdefs.h"
#include "hsmhvdef.h"
#include "hsmhvevalenv.h"
#include "const.h"
#include "sperror.h"
#include "suffix.h"
#define RANGECHECK(param, min, max, pname) \
if ( (param) < (min) || (param) > (max) ) { \
printf("warning(HiSIMHV): The model/instance parameter %s (= %e) must be in the range [%e , %e].\n", \
(pname), (param), (min), (max) ); \
}
#define Fn_SU( y , x , xmax , delta , dx ) { \
TMF1 = ( xmax ) - ( x ) - ( delta ) ; \
TMF2 = sqrt ( TMF1 * TMF1 + 4.0 * ( xmax ) * ( delta) ) ; \
dx = 0.5 * ( 1.0 + TMF1 / TMF2 ) ; \
y = ( xmax ) - 0.5 * ( TMF1 + TMF2 ) ; \
}
#define Fn_SL( y , x , xmin , delta , dx ) { \
TMF1 = ( x ) - ( xmin ) - ( delta ) ; \
TMF2 = sqrt ( TMF1 * TMF1 + 4.0 * ( xmin ) * ( delta ) ) ; \
dx = 0.5 * ( 1.0 + TMF1 / TMF2 ) ; \
y = ( xmin ) + 0.5 * ( TMF1 + TMF2 ) ; \
}
#ifdef POW_TO_EXP_AND_LOG
#define Fn_Pow( x , y ) exp( y * log( x ) )
#else
#define Fn_Pow( x , y ) pow( x , y )
#endif
#define C_m2cm (1.0e2)
int HSMHVtemp(
GENmodel *inModel,
CKTcircuit *ckt)
{
register HSMHVmodel *model = (HSMHVmodel *)inModel ;
register HSMHVinstance *here ;
HSMHVbinningParam *pParam ;
HSMHVmodelMKSParam *modelMKS ;
HSMHVhereMKSParam *hereMKS ;
double mueph =0.0 ;
double Leff=0.0, dL =0.0, dLLD=0.0, LG=0.0, Weff=0.0, dW =0.0, dWLD=0.0, dWCV=0.0, WG =0.0, WL =0.0, Lgate =0.0, Wgate =0.0 ;
double Nsubpp=0.0, Nsubps=0.0, Nsub=0.0, q_Nsub=0.0, Nsubb=0.0, Npext =0.0 ;
double Lod_half=0.0, Lod_half_ref =0.0 ;
double T0, T1, T2, T3, T4, T5, T6, T7 ;
/* temperature-dependent variables */
double Eg =0.0, TTEMP0=0.0, TTEMP=0.0, beta=0.0, Nin=0.0 ;
double Tdiff0 = 0.0, Tdiff0_2 = 0.0, Tdiff = 0.0, Tdiff_2 = 0.0 ;
double js=0.0, jssw=0.0, js2=0.0, jssw2 =0.0 ;
int i=0 ;
double TMF1 , TMF2 ;
const double small = 1.0e-50 ;
const double dlt_rd23 = 1.0e-6 / C_m2cm ;
for ( ;model ;model = model->HSMHVnextModel ) {
modelMKS = &model->modelMKS ;
model->HSMHV_vcrit = CONSTvt0 * log( CONSTvt0 / (CONSTroot2 * 1.0e-14) ) ;
/* Quantum Mechanical Effect */
if ( ( model->HSMHV_qme1 == 0.0 && model->HSMHV_qme3 == 0.0 ) || model->HSMHV_qme2 == 0.0 ) {
model->HSMHV_flg_qme = 0 ;
} else {
model->HSMHV_flg_qme = 1 ;
model->HSMHV_qme12 = model->HSMHV_qme1 / ( model->HSMHV_qme2 * model->HSMHV_qme2 ) ;
}
for ( here = model->HSMHVinstances; here; here = here->HSMHVnextInstance ) {
pParam = &here->pParam ;
hereMKS = &here->hereMKS ;
here->HSMHV_lgate = Lgate = here->HSMHV_l + model->HSMHV_xl ;
Wgate = here->HSMHV_w / here->HSMHV_nf + model->HSMHV_xw ;
LG = Lgate * C_m2um ;
here->HSMHV_wg = WG = Wgate * C_m2um ;
WL = WG * LG ;
/* Band gap */
here->HSMHV_egtnom = pParam->HSMHV_eg0 - model->HSMHV_ktnom
* ( 90.25e-6 + model->HSMHV_ktnom * 1.0e-7 ) ;
/* C_EOX */
here->HSMHV_cecox = C_VAC * model->HSMHV_kappa ;
/* Vth reduction for small Vds */
here->HSMHV_msc = model->HSMHV_scp22 ;
/* Poly-Si Gate Depletion */
if ( pParam->HSMHV_pgd1 == 0.0 ) {
here->HSMHV_flg_pgd = 0 ;
} else {
here->HSMHV_flg_pgd = 1 ;
}
/* CLM5 & CLM6 */
here->HSMHV_clmmod = 1e0 + pow( LG , model->HSMHV_clm5 ) * model->HSMHV_clm6 ;
/* Half length of diffusion */
T1 = 1.0 / (model->HSMHV_saref + 0.5 * here->HSMHV_l)
+ 1.0 / (model->HSMHV_sbref + 0.5 * here->HSMHV_l);
Lod_half_ref = 2.0 / T1 ;
if (here->HSMHV_sa > 0.0 && here->HSMHV_sb > 0.0 &&
(here->HSMHV_nf == 1.0 ||
(here->HSMHV_nf > 1.0 && here->HSMHV_sd > 0.0))) {
T1 = 0.0;
for (i = 0; i < here->HSMHV_nf; i++) {
T1 += 1.0 / (here->HSMHV_sa + 0.5 * here->HSMHV_l
+ i * (here->HSMHV_sd + here->HSMHV_l))
+ 1.0 / (here->HSMHV_sb + 0.5 * here->HSMHV_l
+ i * (here->HSMHV_sd + here->HSMHV_l));
}
Lod_half = 2.0 * here->HSMHV_nf / T1;
} else {
Lod_half = 0.0;
}
Npext = pParam->HSMHV_npext ;
/* DFM */
if ( model->HSMHV_codfm == 1 && here->HSMHV_nsubcdfm_Given ) {
RANGECHECK(hereMKS->HSMHV_nsubcdfm, 1.0e16, 1.0e19, "NSUBCDFM") ;
pParam->HSMHV_mueph1 *= model->HSMHV_mphdfm
* ( log(hereMKS->HSMHV_nsubcdfm) - log(pParam->HSMHV_nsubc) ) + 1.0 ;
pParam->HSMHV_nsubp += hereMKS->HSMHV_nsubcdfm - pParam->HSMHV_nsubc ;
Npext += hereMKS->HSMHV_nsubcdfm - pParam->HSMHV_nsubc ;
pParam->HSMHV_nsubc = hereMKS->HSMHV_nsubcdfm ;
}
/* Phonon Scattering (temperature-independent part) */
mueph = pParam->HSMHV_mueph1
* (1.0e0 + (model->HSMHV_muephw / pow( WG, model->HSMHV_muepwp)))
* (1.0e0 + (model->HSMHV_muephl / pow( LG, model->HSMHV_mueplp)))
* (1.0e0 + (model->HSMHV_muephs / pow( WL, model->HSMHV_muepsp)));
if (Lod_half > 0.0) {
T1 = 1.0e0 / (1.0e0 + pParam->HSMHV_muesti2) ;
T2 = pow (pParam->HSMHV_muesti1 / Lod_half, pParam->HSMHV_muesti3) ;
T3 = pow (pParam->HSMHV_muesti1 / Lod_half_ref, pParam->HSMHV_muesti3) ;
here->HSMHV_mueph = mueph * (1.0e0 + T1 * T2) / (1.0e0 + T1 * T3);
} else {
here->HSMHV_mueph = mueph;
}
/* Surface Roughness Scattering */
here->HSMHV_muesr = model->HSMHV_muesr0
* (1.0e0 + (model->HSMHV_muesrl / pow (LG, model->HSMHV_mueslp)))
* (1.0e0 + (model->HSMHV_muesrw / pow (WG, model->HSMHV_mueswp))) ;
/* Coefficients of Qbm for Eeff */
T1 = pow( LG, model->HSMHV_ndeplp ) ;
here->HSMHV_ndep_o_esi = ( pParam->HSMHV_ndep * T1 ) / ( T1 + model->HSMHV_ndepl )
/ C_ESI ;
here->HSMHV_ninv_o_esi = pParam->HSMHV_ninv / C_ESI ;
here->HSMHV_ninvd0 = model->HSMHV_ninvd * ( 1.0 + (model->HSMHV_ninvdw / pow( WG, model->HSMHV_ninvdwp)));
/* Metallurgical channel geometry */
dL = model->HSMHV_xld
+ (modelMKS->HSMHV_ll / pow (Lgate + model->HSMHV_lld, model->HSMHV_lln)) ;
dLLD = model->HSMHV_xldld
+ (modelMKS->HSMHV_ll / pow (Lgate + model->HSMHV_lld, model->HSMHV_lln)) ;
dW = model->HSMHV_xwd
+ (modelMKS->HSMHV_wl / pow (Wgate + model->HSMHV_wld, model->HSMHV_wln)) ;
dWLD = model->HSMHV_xwdld
+ (modelMKS->HSMHV_wl / pow (Wgate + model->HSMHV_wld, model->HSMHV_wln)) ;
dWCV = model->HSMHV_xwdc
+ (modelMKS->HSMHV_wl / pow (Wgate + model->HSMHV_wld, model->HSMHV_wln)) ;
Leff = Lgate - ( dL + dLLD ) ;
if ( Leff <= 0.0 ) {
IFuid namarr[2];
namarr[0] = model->HSMHVmodName;
namarr[1] = here->HSMHVname;
(*(SPfrontEnd->IFerror))
(
ERR_FATAL,
"HiSIM_HV: MOSFET(%s) MODEL(%s): effective channel length is negative or 0",
namarr
);
return (E_BADPARM);
}
here->HSMHV_leff = Leff ;
/* Wg dependence for short channel devices */
here->HSMHV_lgatesm = Lgate + model->HSMHV_wl1 / pow( WL , model->HSMHV_wl1p ) ;
here->HSMHV_dVthsm = pParam->HSMHV_wl2 / pow( WL , model->HSMHV_wl2p ) ;
/* Lg dependence of wsti */
T1 = 1.0e0 + model->HSMHV_wstil / pow( here->HSMHV_lgatesm * C_m2um , model->HSMHV_wstilp ) ;
T2 = 1.0e0 + model->HSMHV_wstiw / pow( WG , model->HSMHV_wstiwp ) ;
here->HSMHV_wsti = pParam->HSMHV_wsti * T1 * T2 ;
here->HSMHV_weff = Weff = Wgate - 2.0e0 * dW ;
here->HSMHV_weff_ld = Wgate - 2.0e0 * dWLD ;
here->HSMHV_weff_cv = Wgate - 2.0e0 * dWCV ;
if ( Weff <= 0.0 ) {
IFuid namarr[2];
namarr[0] = model->HSMHVmodName;
namarr[1] = here->HSMHVname;
(*(SPfrontEnd->IFerror))
(
ERR_FATAL,
"HiSIM_HV: MOSFET(%s) MODEL(%s): effective channel width is negative or 0",
namarr
);
return (E_BADPARM);
}
here->HSMHV_weff_nf = Weff * here->HSMHV_nf ;
here->HSMHV_weffcv_nf = here->HSMHV_weff_cv * here->HSMHV_nf ;
/* Surface impurity profile */
/* Note: Sign Changed --> */
Nsubpp = pParam->HSMHV_nsubp
* (1.0e0 + (model->HSMHV_nsubp0 / pow (WG, model->HSMHV_nsubwp))) ;
/* <-- Note: Sign Changed */
if (Lod_half > 0.0) {
T1 = 1.0e0 / (1.0e0 + pParam->HSMHV_nsubpsti2) ;
T2 = pow (pParam->HSMHV_nsubpsti1 / Lod_half, pParam->HSMHV_nsubpsti3) ;
T3 = pow (pParam->HSMHV_nsubpsti1 / Lod_half_ref, pParam->HSMHV_nsubpsti3) ;
Nsubps = Nsubpp * (1.0e0 + T1 * T2) / (1.0e0 + T1 * T3) ;
} else {
Nsubps = Nsubpp ;
}
pParam->HSMHV_nsubc *= 1.0e0 + ( model->HSMHV_nsubcw / pow ( WG, model->HSMHV_nsubcwp )) ;
if( Lgate > model->HSMHV_lp ){
Nsub = (pParam->HSMHV_nsubc * (Lgate - model->HSMHV_lp)
+ Nsubps * model->HSMHV_lp) / Lgate ;
} else {
Nsub = Nsubps
+ (Nsubps - pParam->HSMHV_nsubc) * (model->HSMHV_lp - Lgate)
/ model->HSMHV_lp ;
}
T3 = 0.5e0 * Lgate - model->HSMHV_lp ;
T1 = 1.0e0 / ( 1.0e0 / T3 + 1.0e0 / model->HSMHV_lpext ) ;
T2 = Fn_Max (0.0e0, T1) ;
here->HSMHV_nsub =
Nsub = Nsub + T2 * (Npext - pParam->HSMHV_nsubc) / Lgate ;
here->HSMHV_qnsub = q_Nsub = C_QE * Nsub ;
here->HSMHV_qnsub_esi = q_Nsub * C_ESI ;
here->HSMHV_2qnsub_esi = 2.0 * here->HSMHV_qnsub_esi ;
/* Pocket Overlap (temperature-independent part) */
if ( Lgate <= 2.0e0 * model->HSMHV_lp ) {
Nsubb = 2.0e0 * Nsubps
- (Nsubps - pParam->HSMHV_nsubc) * Lgate
/ model->HSMHV_lp - pParam->HSMHV_nsubc ;
here->HSMHV_ptovr0 = log (Nsubb / pParam->HSMHV_nsubc) ;
/* here->HSMHV_ptovr0 will be divided by beta later. */
} else {
here->HSMHV_ptovr0 = 0.0e0 ;
}
/* costi0 and costi1 for STI transistor model (temperature-independent part) */
here->HSMHV_costi00 = sqrt (2.0 * C_QE * pParam->HSMHV_nsti * C_ESI ) ;
here->HSMHV_nsti_p2 = 1.0 / ( pParam->HSMHV_nsti * pParam->HSMHV_nsti ) ;
/* Velocity Temperature Dependence (Temperature-dependent part will be multiplied later.) */
here->HSMHV_vmax0 = (1.0e0 + (pParam->HSMHV_vover / pow (LG, model->HSMHV_voverp)))
* (1.0e0 + (model->HSMHV_vovers / pow (WL, model->HSMHV_voversp))) ;
/* 2 phi_B (temperature-independent) */
/* @300K, with pocket */
here->HSMHV_pb20 = 2.0e0 / C_b300 * log (Nsub / C_Nin0) ;
/* @300K, w/o pocket */
here->HSMHV_pb2c = 2.0e0 / C_b300 * log (pParam->HSMHV_nsubc / C_Nin0) ;
/* constant for Poly depletion */
here->HSMHV_cnstpgd = pow ( 1e0 + 1e0 / LG , model->HSMHV_pgd4 )
* pParam->HSMHV_pgd1 ;
/* Gate resistance */
if ( here->HSMHV_corg == 1 ) {
T1 = here->HSMHV_xgw + Weff / (3.0e0 * here->HSMHV_ngcon);
T2 = Lgate - here->HSMHV_xgl;
here->HSMHV_grg = model->HSMHV_rshg * T1 / (here->HSMHV_ngcon * T2 * here->HSMHV_nf);
if (here->HSMHV_grg > 1.0e-3) here->HSMHV_grg = here->HSMHV_m / here->HSMHV_grg;
else {
here->HSMHV_grg = here->HSMHV_m * 1.0e3;
printf("warning(HiSIM_HV): The gate conductance reset to 1.0e3 mho.\n");
}
}
/* Process source/drain series resistamce */
if ( model->HSMHV_rsh > 0.0 ) {
here->HSMHV_rd0 = model->HSMHV_rsh * here->HSMHV_nrd ;
} else {
here->HSMHV_rd0 = 0.0 ;
}
if ( pParam->HSMHV_rd > 0.0 || pParam->HSMHV_rs > 0.0 ) {
here->HSMHV_rdtemp0 = 1.0 + model->HSMHV_rds / pow( here->HSMHV_w * C_m2um * LG , model->HSMHV_rdsp ) ;
if( pParam->HSMHV_rdvd != 0.0 ){
T7 = ( 1.0 + model->HSMHV_rdvds / pow( here->HSMHV_w * C_m2um * LG , model->HSMHV_rdvdsp ) );
T6 = exp( - model->HSMHV_rdvdl * pow( LG , model->HSMHV_rdvdlp ) ) ;
here->HSMHV_rdvdtemp0 = T6 * T7 ;
}
}
if( pParam->HSMHV_rd23 != 0.0 ){
T2 = ( 1.0 + model->HSMHV_rd23s / pow( here->HSMHV_w * C_m2um * LG , model->HSMHV_rd23sp ) );
T1 = exp( - model->HSMHV_rd23l * pow( LG , model->HSMHV_rd23lp ) ) ;
T3 = pParam->HSMHV_rd23 * T2 * T1 ;
here->HSMHV_rd23 = 0.5 * ( T3 + sqrt ( T3 * T3 + 4.0 * dlt_rd23 * dlt_rd23 ) ) ;
} else {
here->HSMHV_rd23 = 0.0 ;
}
if ( model->HSMHV_rsh > 0.0 ) {
here->HSMHV_rs0 = model->HSMHV_rsh * here->HSMHV_nrs ;
} else {
here->HSMHV_rs0 = 0.0 ;
}
/* Body resistance */
if ( here->HSMHV_corbnet == 1 ) {
if (here->HSMHV_rbpb < 1.0e-3) here->HSMHV_grbpb = here->HSMHV_m * 1.0e3 ;
else here->HSMHV_grbpb = here->HSMHV_m * ( model->HSMHV_gbmin + 1.0 / here->HSMHV_rbpb ) ;
if (here->HSMHV_rbps < 1.0e-3) here->HSMHV_grbps = here->HSMHV_m * 1.0e3 ;
else here->HSMHV_grbps = here->HSMHV_m * ( model->HSMHV_gbmin + 1.0 / here->HSMHV_rbps ) ;
if (here->HSMHV_rbpd < 1.0e-3) here->HSMHV_grbpd = here->HSMHV_m * 1.0e3 ;
else here->HSMHV_grbpd = here->HSMHV_m * ( model->HSMHV_gbmin + 1.0 / here->HSMHV_rbpd ) ;
}
/* Vdseff */
T1 = model->HSMHV_ddltslp * LG + model->HSMHV_ddltict ;
if ( T1 < 0.0 ) { T1 = 0.0 ; }
here->HSMHV_ddlt = T1 * model->HSMHV_ddltmax / ( T1 + model->HSMHV_ddltmax ) + 1.0 ;
/* Isub */
T2 = pow( Weff , model->HSMHV_svgswp ) ;
here->HSMHV_vg2const = pParam->HSMHV_svgs
* ( 1.0e0
+ modelMKS->HSMHV_svgsl / pow( here->HSMHV_lgate , model->HSMHV_svgslp ) )
* ( T2 / ( T2 + modelMKS->HSMHV_svgsw ) ) ;
here->HSMHV_xvbs = pParam->HSMHV_svbs
* ( 1.0e0
+ modelMKS->HSMHV_svbsl / pow( here->HSMHV_lgate , model->HSMHV_svbslp ) ) ;
here->HSMHV_xgate = modelMKS->HSMHV_slg
* ( 1.0
+ modelMKS->HSMHV_slgl / pow( here->HSMHV_lgate , model->HSMHV_slglp ) ) ;
here->HSMHV_xsub1 = pParam->HSMHV_sub1
* ( 1.0
+ modelMKS->HSMHV_sub1l / pow( here->HSMHV_lgate , model->HSMHV_sub1lp ) ) ;
here->HSMHV_xsub2 = pParam->HSMHV_sub2
* ( 1.0 + modelMKS->HSMHV_sub2l / here->HSMHV_lgate ) ;
/* Fringing capacitance */
here->HSMHV_cfrng = C_EOX / ( C_Pi / 2.0e0 ) * here->HSMHV_weff_nf
* log( 1.0e0 + model->HSMHV_tpoly / model->HSMHV_tox ) ;
/* Additional term of lateral-field-induced capacitance */
here->HSMHV_cqyb0 = C_m2um * here->HSMHV_weff_nf
* model->HSMHV_xqy1 / pow( LG , model->HSMHV_xqy2 ) ;
/* Self heating */
pParam->HSMHV_rth = pParam->HSMHV_rth0 / ( here->HSMHV_m * here->HSMHV_weff_nf )
* ( 1.0 + model->HSMHV_rth0w / pow( here->HSMHV_w * C_m2um , model->HSMHV_rth0wp ) );
pParam->HSMHV_cth = modelMKS->HSMHV_cth0 * ( here->HSMHV_m * here->HSMHV_weff_nf ) ;
pParam->HSMHV_rth *= ( 1.0 / pow( here->HSMHV_nf , model->HSMHV_rth0nf ) ) ;
here->HSMHV_rthtemp0 = 1.0 / pow( here->HSMHV_nf , model->HSMHV_rth0nf ) / ( here->HSMHV_m * here->HSMHV_weff_nf )
* ( 1.0 + model->HSMHV_rth0w / pow( here->HSMHV_w * C_m2um , model->HSMHV_rth0wp ) );
/*-----------------------------------------------------------*
* Temperature dependent constants.
*-----------------*/
if ( here->HSMHVtempNode < 0 || pParam->HSMHV_rth0 == 0.0 ) {
#include "hsmhvtemp_eval.h"
} /* end of if ( here->HSMHVtempNode < 0 || pParam->HSMHV_rth0 == 0.0 ) */
}
}
return(OK);
}

382
src/spicelib/devices/hisimhv/hsmhvtemp_eval.h Normal file
View File

@ -0,0 +1,382 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvtemp_eval.h
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#define C_rdtemp_min 5.0e-3
#define C_rdtemp_dlt 1.0e-2
TTEMP = ckt->CKTtemp;
if ( here->HSMHV_dtemp_Given ) { TTEMP = TTEMP + here->HSMHV_dtemp ; }
TTEMP0 = TTEMP ;
#ifdef HSMHVEVAL
/* Self heating */
TTEMP = TTEMP + deltemp ;
#endif
Tdiff0 = TTEMP0 - model->HSMHV_ktnom ;
Tdiff0_2 = TTEMP0 * TTEMP0 - model->HSMHV_ktnom * model->HSMHV_ktnom ;
Tdiff = TTEMP - model->HSMHV_ktnom ;
Tdiff_2 = TTEMP * TTEMP - model->HSMHV_ktnom * model->HSMHV_ktnom ;
/* Band gap */
T1 = TTEMP - model->HSMHV_ktnom ;
T2 = TTEMP * TTEMP - model->HSMHV_ktnom * model->HSMHV_ktnom ;
here->HSMHV_eg = Eg = here->HSMHV_egtnom - pParam->HSMHV_bgtmp1 * T1
- pParam->HSMHV_bgtmp2 * T2 ;
here->HSMHV_sqrt_eg = sqrt( Eg ) ;
#ifdef HSMHVEVAL
Eg_dT = -pParam->HSMHV_bgtmp1 - 2.0e0 * TTEMP * pParam->HSMHV_bgtmp2 ;
#endif
T1 = 1.0 / TTEMP ;
T2 = 1.0 / model->HSMHV_ktnom ;
T3 = here->HSMHV_egtnom + model->HSMHV_egig
+ model->HSMHV_igtemp2 * ( T1 - T2 )
+ model->HSMHV_igtemp3 * ( T1 * T1 - T2 * T2 ) ;
here->HSMHV_egp12 = sqrt ( T3 ) ;
here->HSMHV_egp32 = T3 * here->HSMHV_egp12 ;
/* Inverse of the thermal voltage */
here->HSMHV_beta = beta = C_QE / (C_KB * TTEMP) ;
here->HSMHV_beta_inv = 1.0 / beta ;
here->HSMHV_beta2 = beta * beta ;
here->HSMHV_betatnom = C_QE / (C_KB * model->HSMHV_ktnom) ;
#ifdef HSMHVEVAL
beta_dT=-C_QE/(C_KB*TTEMP*TTEMP);
beta_inv_dT = C_KB / C_QE ;
#endif
/* Intrinsic carrier concentration */
here->HSMHV_nin = Nin = C_Nin0 * Fn_Pow (TTEMP / model->HSMHV_ktnom, 1.5e0)
* exp (- Eg / 2.0e0 * beta + here->HSMHV_egtnom / 2.0e0 * here->HSMHV_betatnom) ;
#ifdef HSMHVEVAL
Nin_dT = C_Nin0 * exp (- Eg / 2.0e0 * beta + here->HSMHV_egtnom / 2.0e0 * here->HSMHV_betatnom)
* 1.5e0 * Fn_Pow ( TTEMP / model->HSMHV_ktnom , 0.5e0 ) / model->HSMHV_ktnom
+ C_Nin0 * Fn_Pow (TTEMP / model->HSMHV_ktnom, 1.5e0)
* exp (- Eg / 2.0e0 * beta + here->HSMHV_egtnom / 2.0e0 * here->HSMHV_betatnom)
* ( - Eg / 2.0e0 * beta_dT - beta / 2.0e0 * Eg_dT );
#endif
/* Phonon Scattering (temperature-dependent part) */
T1 = Fn_Pow (TTEMP / model->HSMHV_ktnom, pParam->HSMHV_muetmp) ;
here->HSMHV_mphn0 = T1 / here->HSMHV_mueph ;
here->HSMHV_mphn1 = here->HSMHV_mphn0 * model->HSMHV_mueph0 ;
#ifdef HSMHVEVAL
T1_dT = pParam->HSMHV_muetmp * Fn_Pow(TTEMP / model->HSMHV_ktnom, pParam->HSMHV_muetmp - 1.0 )
/ model->HSMHV_ktnom ;
mphn0_dT = T1_dT / here->HSMHV_mueph ;
#endif
/* Pocket Overlap (temperature-dependent part) */
here->HSMHV_ptovr = here->HSMHV_ptovr0 / beta ;
#ifdef HSMHVEVAL
ptovr_dT = here->HSMHV_ptovr0 * beta_inv_dT ;
#endif
/* Velocity Temperature Dependence */
T1 = TTEMP / model->HSMHV_ktnom ;
T3 = TTEMP0 - model->HSMHV_ktnom ;
T4 = TTEMP0 * TTEMP0 - model->HSMHV_ktnom * model->HSMHV_ktnom ;
T0 = 1.8 + 0.4 * T1 + 0.1 * T1 * T1 - pParam->HSMHV_vtmp * (1.0 - T1) ;
if ( model->HSMHV_cotemp != 2 ) { /* without deltemp (COTEMP=0,1,3) */
here->HSMHV_vmax = here->HSMHV_vmax0 * pParam->HSMHV_vmax
/ T0
* ( 1.0 + model->HSMHV_vmaxt1 * T3 + model->HSMHV_vmaxt2 * T4 ) ;
#ifdef HSMHVEVAL
Vmax_dT=-here->HSMHV_vmax0 * pParam->HSMHV_vmax
/ ( T0 * T0 ) * ( 1.0 + model->HSMHV_vmaxt1 * T3 + model->HSMHV_vmaxt2 * T4 )
* 1/model->HSMHV_ktnom * (0.4 + 0.2 * T1 + pParam->HSMHV_vtmp) ;
#endif
} else { /* with deltemp (COTEMP=2) */
here->HSMHV_vmax = here->HSMHV_vmax0 * pParam->HSMHV_vmax
/ T0
* ( 1.0 + model->HSMHV_vmaxt1 * Tdiff + model->HSMHV_vmaxt2 * Tdiff_2 ) ;
#ifdef HSMHVEVAL
/* under development */
Vmax_dT = here->HSMHV_vmax0 * pParam->HSMHV_vmax
/ ( T0 * T0 )
* ( ( model->HSMHV_vmaxt1 + 2.0 * TTEMP * model->HSMHV_vmaxt2 ) * T0
- ( 1.0 + model->HSMHV_vmaxt1 * Tdiff + model->HSMHV_vmaxt2 * Tdiff_2 )
* 1/model->HSMHV_ktnom * (0.4 + 0.2 * T1 + pParam->HSMHV_vtmp) ) ;
#endif
}
if ( model->HSMHV_cotemp != 2 ) { /* without deltemp (COTEMP=0,1,3) */
here->HSMHV_ninvd = here->HSMHV_ninvd0 * ( 1.0 + model->HSMHV_ninvdt1 * T3 + model->HSMHV_ninvdt2 * T4 ) ;
#ifdef HSMHVEVAL
ninvd_dT = 0.0 ;
#endif
} else { /* with deltemp (COTEMP=2) */
/* under development */
here->HSMHV_ninvd = here->HSMHV_ninvd0 * ( 1.0 + model->HSMHV_ninvdt1 * Tdiff + model->HSMHV_ninvdt2 * Tdiff_2 ) ;
#ifdef HSMHVEVAL
ninvd_dT = here->HSMHV_ninvd0 * ( model->HSMHV_ninvdt1 + 2.0 * TTEMP * model->HSMHV_ninvdt2 ) ;
#endif
}
/* Temperature Dependence of RTH0 */
pParam->HSMHV_rth = ( pParam->HSMHV_rth0 + model->HSMHV_rthtemp1 * T3 + model->HSMHV_rthtemp2 * T4 ) * here->HSMHV_rthtemp0 ;
/* Temperature Dependence of POWRAT */
T2 = pParam->HSMHV_powrat + model->HSMHV_prattemp1 * T3 + model->HSMHV_prattemp2 * T4 ;
Fn_SL( T2 , T2 , 0 , 0.05 , T0 );
Fn_SU( here->HSMHV_powratio , T2 , 1 , 0.05 , T0 );
/* 2 phi_B (temperature-dependent) */
/* @temp, with pocket */
here->HSMHV_pb2 = 2.0e0 / beta * log (here->HSMHV_nsub / Nin) ;
#ifdef HSMHVEVAL
Pb2_dT = - (here->HSMHV_pb2 * beta_dT + 2.0e0 / Nin * Nin_dT ) / beta ;
#endif
/* Depletion Width */
T1 = 2.0e0 * C_ESI / C_QE ;
here->HSMHV_wdpl = sqrt ( T1 / here->HSMHV_nsub ) ;
here->HSMHV_wdplp = sqrt( T1 / ( pParam->HSMHV_nsubp ) ) ;
/* Coefficient of the F function for bulk charge */
here->HSMHV_cnst0 = sqrt ( 2.0 * C_ESI * C_QE * here->HSMHV_nsub / beta ) ;
/* cnst1: n_{p0} / p_{p0} */
T1 = Nin / here->HSMHV_nsub ;
here->HSMHV_cnst1 = T1 * T1 ;
#ifdef HSMHVEVAL
cnst0_dT = 0.5e0 / here->HSMHV_cnst0 * 2.0 * C_ESI * C_QE * here->HSMHV_nsub * beta_inv_dT ;
cnst1_dT = 2.0e0 * Nin * Nin_dT / here->HSMHV_nsub / here->HSMHV_nsub ;
#endif
if ( pParam->HSMHV_nover != 0.0 ) {
here->HSMHV_cnst0over = here->HSMHV_cnst0 * sqrt( pParam->HSMHV_nover / here->HSMHV_nsub ) ;
#ifdef HSMHVEVAL
cnst0over_dT = cnst0_dT * sqrt( pParam->HSMHV_nover / here->HSMHV_nsub ) ;
#endif
/* ps0ldinib : Ps0_iniB for Ps0LD */
T1 = here->HSMHV_cnst0over * model->HSMHV_tox / here->HSMHV_cecox ;
T2 = pParam->HSMHV_nover / Nin ;
here->HSMHV_ps0ldinib = T2 * T2 / ( T1 * T1 );
#ifdef HSMHVEVAL
T1_dT = cnst0over_dT * model->HSMHV_tox / here->HSMHV_cecox ;
T2_dT = - Nin_dT * T2 / Nin;
ps0ldinib_dT = 2.0 * here->HSMHV_ps0ldinib * ( T2_dT * T1 - T2 * T1_dT ) / ( T1 * T2 );
#endif
}
if ( pParam->HSMHV_novers != 0.0 ) {
here->HSMHV_cnst0overs = here->HSMHV_cnst0 * sqrt( pParam->HSMHV_novers / here->HSMHV_nsub ) ;
#ifdef HSMHVEVAL
cnst0overs_dT = cnst0_dT * sqrt( pParam->HSMHV_novers / here->HSMHV_nsub ) ;
#endif
/* ps0ldinib : Ps0_iniB for Ps0LD */
T1 = here->HSMHV_cnst0overs * model->HSMHV_tox / here->HSMHV_cecox ;
T2 = pParam->HSMHV_novers / Nin ;
here->HSMHV_ps0ldinibs = T2 * T2 / ( T1 * T1 );
#ifdef HSMHVEVAL
T1_dT = cnst0overs_dT * model->HSMHV_tox / here->HSMHV_cecox ;
T2_dT = - Nin_dT * T2 / Nin;
ps0ldinibs_dT = 2.0 * here->HSMHV_ps0ldinibs * ( T2_dT * T1 - T2 * T1_dT ) / ( T1 * T2 );
#endif
}
/* temperature-dependent resistance model */
T3 = model->HSMHV_ktnom ;
T1 = TTEMP0 - T3 ;
T4 = TTEMP0 * TTEMP0 - T3 * T3 ;
/* drain side */
if ( pParam->HSMHV_rd > 0.0 ) {
T2 = here->HSMHV_rdtemp0
* ( here->HSMHV_ldrift1 * pParam->HSMHV_rdslp1 * C_m2um + pParam->HSMHV_rdict1 )
* ( here->HSMHV_ldrift2 * model->HSMHV_rdslp2 * C_m2um + model->HSMHV_rdict2 ) ;
if ( model->HSMHV_cotemp == 1 ) { /* without deltemp (COTEMP=1) */
here->HSMHV_rd = ( pParam->HSMHV_rd + T1 * modelMKS->HSMHV_rdtemp1 + modelMKS->HSMHV_rdtemp2 * T4 ) * T2 ;
Fn_SL( here->HSMHV_rd, here->HSMHV_rd, C_rdtemp_min * pParam->HSMHV_rd, C_rdtemp_dlt * pParam->HSMHV_rd, T0 );
#ifdef HSMHVEVAL
Rd0_dT = 0.0 ;
#endif
} else { /* with deltemp (COTEMP=0,2,3) */
here->HSMHV_rd = ( pParam->HSMHV_rd + modelMKS->HSMHV_rdtemp1 * Tdiff + modelMKS->HSMHV_rdtemp2 * Tdiff_2 ) * T2 ;
Fn_SL( here->HSMHV_rd, here->HSMHV_rd, C_rdtemp_min * pParam->HSMHV_rd, C_rdtemp_dlt * pParam->HSMHV_rd, T0 );
#ifdef HSMHVEVAL
Rd0_dT = ( modelMKS->HSMHV_rdtemp1 + 2.0 * TTEMP * modelMKS->HSMHV_rdtemp2 ) * T2 * T0 ;
#endif
}
} else {
here->HSMHV_rd = 0.0 ;
}
/* source side (asymmetric case) */
if ( pParam->HSMHV_rs > 0.0 ) {
T2 = here->HSMHV_rdtemp0
* ( here->HSMHV_ldrift1s * pParam->HSMHV_rdslp1 * C_m2um + pParam->HSMHV_rdict1 )
* ( here->HSMHV_ldrift2s * model->HSMHV_rdslp2 * C_m2um + model->HSMHV_rdict2 ) ;
if ( model->HSMHV_cotemp == 1 ) { /* without deltemp (COTEMP=1) */
here->HSMHV_rs = ( pParam->HSMHV_rs + T1 * modelMKS->HSMHV_rdtemp1 + modelMKS->HSMHV_rdtemp2 * T4 ) * T2 ;
Fn_SL( here->HSMHV_rs, here->HSMHV_rs, C_rdtemp_min * pParam->HSMHV_rs, C_rdtemp_dlt * pParam->HSMHV_rs, T0 );
#ifdef HSMHVEVAL
Rs0_dT = 0.0 ;
#endif
} else { /* with deltemp (COTEMP=0,2,3) */
here->HSMHV_rs = ( pParam->HSMHV_rs + modelMKS->HSMHV_rdtemp1 * Tdiff + modelMKS->HSMHV_rdtemp2 * Tdiff_2 ) * T2 ;
Fn_SL( here->HSMHV_rs, here->HSMHV_rs, C_rdtemp_min * pParam->HSMHV_rs, C_rdtemp_dlt * pParam->HSMHV_rs, T0 );
#ifdef HSMHVEVAL
Rs0_dT = ( modelMKS->HSMHV_rdtemp1 + 2.0 * TTEMP * modelMKS->HSMHV_rdtemp2 ) * T2 * T0 ;
#endif
}
} else {
here->HSMHV_rs = 0.0 ;
}
if ( pParam->HSMHV_rdvd > 0.0 ) {
T4 = here->HSMHV_rdvdtemp0 * ( here->HSMHV_ldrift1 * pParam->HSMHV_rdslp1 * C_m2um + pParam->HSMHV_rdict1 )
* ( here->HSMHV_ldrift2 * model->HSMHV_rdslp2 * C_m2um + model->HSMHV_rdict2 ) ;
T1 = ( 1 - pParam->HSMHV_rdov13 ) * here->HSMHV_loverld * C_m2um ;
T0 = - model->HSMHV_rdov11 / ( model->HSMHV_rdov12 + small ) ;
T3 = ( T0 * here->HSMHV_loverld * C_m2um + 1.0 + model->HSMHV_rdov11 ) ;
Fn_SL( T5 , T3 * T4 , T4 , 10.0e-3 , T6 ) ;
Fn_SU( T7 , T5 , T4 * ( model->HSMHV_rdov11 + 1.0) , 50.0e-6 , T6 ) ;
Fn_SL( T2 , T7 + T1 * T4 , 0, 50.0e-6 , T6 ) ;
T3 = model->HSMHV_ktnom ;
T1 = TTEMP0 - T3 ;
if ( model->HSMHV_cotemp == 0 || model->HSMHV_cotemp == 1 ) { /* without deltemp (COTEMP=0,1) */
here->HSMHV_rdvd = ( pParam->HSMHV_rdvd + T1 * modelMKS->HSMHV_rdvdtemp1 + modelMKS->HSMHV_rdvdtemp2 * ( TTEMP0 * TTEMP0 - T3 * T3 ) ) * T2 ;
Fn_SL( here->HSMHV_rdvd, here->HSMHV_rdvd, C_rdtemp_min * pParam->HSMHV_rdvd, C_rdtemp_dlt * pParam->HSMHV_rdvd, T0 );
#ifdef HSMHVEVAL
Rdvd_dT = 0.0 ;
#endif
} else { /* with deltemp (COTEMP=2,3) */
here->HSMHV_rdvd = ( pParam->HSMHV_rdvd + modelMKS->HSMHV_rdvdtemp1 * Tdiff + modelMKS->HSMHV_rdvdtemp2 * Tdiff_2 ) * T2 ;
Fn_SL( here->HSMHV_rdvd, here->HSMHV_rdvd, C_rdtemp_min * pParam->HSMHV_rdvd, C_rdtemp_dlt * pParam->HSMHV_rdvd, T0 );
#ifdef HSMHVEVAL
Rdvd_dT = ( modelMKS->HSMHV_rdvdtemp1 + 2.0 * TTEMP * modelMKS->HSMHV_rdvdtemp2 ) * T2 * T0 ;
#endif
}
T4 = here->HSMHV_rdvdtemp0 * ( here->HSMHV_ldrift1s * pParam->HSMHV_rdslp1 * C_m2um + pParam->HSMHV_rdict1 )
* ( here->HSMHV_ldrift2s * model->HSMHV_rdslp2 * C_m2um + model->HSMHV_rdict2 ) ;
T1 = ( 1 - pParam->HSMHV_rdov13 ) * here->HSMHV_lovers * C_m2um ;
T0 = - model->HSMHV_rdov11 / ( model->HSMHV_rdov12 + small ) ;
T3 = ( T0 * here->HSMHV_lovers * C_m2um + 1.0 + model->HSMHV_rdov11 ) ;
Fn_SL( T5 , T3 * T4 , T4 , 10.0e-3 , T6 ) ;
Fn_SU( T7 , T5 , T4 * ( model->HSMHV_rdov11 + 1.0) , 50.0e-6 , T6 ) ;
Fn_SL( T2 , T7 + T1 * T4 , 0, 50.0e-6 , T6 ) ;
T3 = model->HSMHV_ktnom ;
T1 = TTEMP0 - T3 ;
if ( model->HSMHV_cotemp == 0 || model->HSMHV_cotemp == 1 ) { /* without deltemp (COTEMP=0,1) */
here->HSMHV_rsvd = ( pParam->HSMHV_rdvd + T1 * modelMKS->HSMHV_rdvdtemp1 + modelMKS->HSMHV_rdvdtemp2 * ( TTEMP0 * TTEMP0 - T3 * T3 ) ) * T2 ;
Fn_SL( here->HSMHV_rsvd, here->HSMHV_rsvd, C_rdtemp_min * pParam->HSMHV_rdvd, C_rdtemp_dlt * pParam->HSMHV_rdvd, T0 );
#ifdef HSMHVEVAL
Rsvd_dT = 0.0 ;
#endif
} else { /* with deltemp (COTEMP=2,3) */
here->HSMHV_rsvd = ( pParam->HSMHV_rdvd + modelMKS->HSMHV_rdvdtemp1 * Tdiff + modelMKS->HSMHV_rdvdtemp2 * Tdiff_2 ) * T2 ;
Fn_SL( here->HSMHV_rsvd, here->HSMHV_rsvd, C_rdtemp_min * pParam->HSMHV_rdvd, C_rdtemp_dlt * pParam->HSMHV_rdvd, T0 );
#ifdef HSMHVEVAL
Rsvd_dT = ( modelMKS->HSMHV_rdvdtemp1 + 2.0 * TTEMP * modelMKS->HSMHV_rdvdtemp2 ) * T2 * T0 ;
#endif
}
} else {
here->HSMHV_rdvd = 0.0 ;
here->HSMHV_rsvd = 0.0 ;
}
/* for substrate-source/drain junction diode. */
js = pParam->HSMHV_js0
* exp ((here->HSMHV_egtnom * here->HSMHV_betatnom - Eg * beta
+ model->HSMHV_xti * log (TTEMP / model->HSMHV_ktnom)) / pParam->HSMHV_nj) ;
jssw = pParam->HSMHV_js0sw
* exp ((here->HSMHV_egtnom * here->HSMHV_betatnom - Eg * beta
+ model->HSMHV_xti * log (TTEMP / model->HSMHV_ktnom)) / model->HSMHV_njsw) ;
js2 = pParam->HSMHV_js0
* exp ((here->HSMHV_egtnom * here->HSMHV_betatnom - Eg * beta
+ model->HSMHV_xti2 * log (TTEMP / model->HSMHV_ktnom)) / pParam->HSMHV_nj) ;
jssw2 = pParam->HSMHV_js0sw
* exp ((here->HSMHV_egtnom * here->HSMHV_betatnom - Eg * beta
+ model->HSMHV_xti2 * log (TTEMP / model->HSMHV_ktnom)) / model->HSMHV_njsw) ;
#ifdef HSMHVEVAL
T0 = - Eg * beta_dT - Eg_dT * beta ; /* Self heating */
T1 = T0 + model->HSMHV_xti / TTEMP ; /* Self heating */
T2 = T0 + model->HSMHV_xti2 / TTEMP ; /* Self heating */
js_dT = js * T1 / pParam->HSMHV_nj; /* Self heating */
jssw_dT = jssw * T1/ model->HSMHV_njsw ; /* Self heating */
js2_dT = js2 * T2 / pParam->HSMHV_nj; /* Self heating */
jssw2_dT = jssw2 * T2 / model->HSMHV_njsw; /* Self heating */
#endif
here->HSMHV_isbd = here->HSMHV_ad * js + here->HSMHV_pd * jssw ;
here->HSMHV_isbd2 = here->HSMHV_ad * js2 + here->HSMHV_pd * jssw2 ;
here->HSMHV_isbs = here->HSMHV_as * js + here->HSMHV_ps * jssw ;
here->HSMHV_isbs2 = here->HSMHV_as * js2 + here->HSMHV_ps * jssw2 ;
#ifdef HSMHVEVAL
isbd_dT = here->HSMHV_ad * js_dT + here->HSMHV_pd * jssw_dT ; /* Self heating */
isbd2_dT = here->HSMHV_ad * js2_dT + here->HSMHV_pd * jssw2_dT ; /* Self heating */
isbs_dT = here->HSMHV_as * js_dT + here->HSMHV_ps * jssw_dT ; /* Self heating */
isbs2_dT = here->HSMHV_as * js2_dT + here->HSMHV_ps * jssw2_dT ; /* Self heating */
#endif
T1 = TTEMP / model->HSMHV_ktnom ;
T0 = T1 * T1 ;
T2 = here->HSMHV_isbd + small ;
T3 = here->HSMHV_isbs + small ;
#ifdef HSMHVEVAL
T1_dT = 1.0 / model->HSMHV_ktnom ; /* Self heating */
T0_dT = 2.0 * T1 * T1_dT ; /* Self heating */
T2_dT = isbd_dT ; /* Self heating */
T3_dT = isbs_dT ; /* Self heating */
#endif
here->HSMHV_vbdt = pParam->HSMHV_nj / beta
* log ( pParam->HSMHV_vdiffj * T0 / T2 + 1.0 ) ;
here->HSMHV_vbst = pParam->HSMHV_nj / beta
* log ( pParam->HSMHV_vdiffj * T0 / T3 + 1.0 ) ;
here->HSMHV_exptemp = exp (( T1 - 1.0 ) * model->HSMHV_ctemp ) ;
#ifdef HSMHVEVAL
vbdt_dT = - beta_dT / beta * here->HSMHV_vbdt
+ pParam->HSMHV_nj / beta * pParam->HSMHV_vdiffj / ( pParam->HSMHV_vdiffj * T0 / T2 + 1.0 )
* ( T0_dT / T2 - T0 / T2 / T2 * T2_dT ) ; /* Self heating */
vbst_dT = - beta_dT / beta * here->HSMHV_vbst
+ pParam->HSMHV_nj / beta * pParam->HSMHV_vdiffj / ( pParam->HSMHV_vdiffj * T0 / T3 + 1.0 )
* ( T0_dT / T3 - T0 / T3 / T3 * T3_dT ) ; /* Self heating */
#endif
here->HSMHV_jd_nvtm_inv = 1.0 / ( pParam->HSMHV_nj / beta ) ;
here->HSMHV_jd_expcd = exp (here->HSMHV_vbdt * here->HSMHV_jd_nvtm_inv ) ;
here->HSMHV_jd_expcs = exp (here->HSMHV_vbst * here->HSMHV_jd_nvtm_inv ) ;
#ifdef HSMHVEVAL
exptemp_dT = model->HSMHV_ctemp / model->HSMHV_ktnom * here->HSMHV_exptemp ; /* Self heating */
jd_nvtm_inv_dT = beta_dT / pParam->HSMHV_nj ; /* Self heating */
jd_expcd_dT = here->HSMHV_jd_expcd
* ( vbdt_dT * here->HSMHV_jd_nvtm_inv + here->HSMHV_vbdt * jd_nvtm_inv_dT ) ; /* Self heating */
jd_expcs_dT = here->HSMHV_jd_expcs
* ( vbst_dT * here->HSMHV_jd_nvtm_inv + here->HSMHV_vbst * jd_nvtm_inv_dT ) ; /* Self heating */
#endif
/* costi0 and costi1 for STI transistor model (temperature-dependent part) */
here->HSMHV_costi0 = here->HSMHV_costi00 * sqrt(here->HSMHV_beta_inv) ;
here->HSMHV_costi0_p2 = here->HSMHV_costi0 * here->HSMHV_costi0 ;
here->HSMHV_costi1 = here->HSMHV_nin * here->HSMHV_nin * here->HSMHV_nsti_p2 ;
/* end of HSMHVtemp_eval.h */

61
src/spicelib/devices/hisimhv/hsmhvtrunc.c Normal file
View File

@ -0,0 +1,61 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvtrunc.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "hsmhvdef.h"
#include "sperror.h"
#include "suffix.h"
int HSMHVtrunc(
GENmodel *inModel,
register CKTcircuit *ckt,
double *timeStep)
{
register HSMHVmodel *model = (HSMHVmodel*)inModel;
register HSMHVinstance *here;
#ifdef STEPDEBUG
double debugtemp=0.0 ;
#endif /* STEPDEBUG */
for ( ;model != NULL ;model = model->HSMHVnextModel ) {
for ( here=model->HSMHVinstances ;here!=NULL ;
here = here->HSMHVnextInstance ) {
#ifdef STEPDEBUG
debugtemp = *timeStep;
#endif /* STEPDEBUG */
CKTterr(here->HSMHVqb,ckt,timeStep);
CKTterr(here->HSMHVqg,ckt,timeStep);
CKTterr(here->HSMHVqd,ckt,timeStep);
CKTterr(here->HSMHVqbs,ckt,timeStep);
CKTterr(here->HSMHVqbd,ckt,timeStep);
CKTterr(here->HSMHVqfd,ckt,timeStep);
CKTterr(here->HSMHVqfs,ckt,timeStep);
#ifdef STEPDEBUG
if ( debugtemp != *timeStep )
printf("device %s reduces step from %g to %g\n",
here->HSMHVname, debugtemp, *timeStep);
#endif /* STEPDEBUG */
}
}
return(OK);
}

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

@ -22,41 +22,41 @@ INP2M (CKTcircuit *ckt, INPtables * tab, card * current)
* [IC=<val>,<val>,<val>]
*/
int type; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *name; /* the resistor's name */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
char *nname3; /* the third node's name */
char *nname4; /* the fourth node's name */
char *nname5; /* the fifth node's name */
char *nname6; /* the sixt node's name */
char *nname7; /* the seventh node's name */
char *save; /* saj - used to save the posn of the start of
the parameters if the model is a mosfet*/
CKTnode *node1; /* the first node's node pointer */
CKTnode *node2; /* the second node's node pointer */
CKTnode *node3; /* the third node's node pointer */
CKTnode *node4; /* the fourth node's node pointer */
CKTnode *node5; /* the fifth node's node pointer */
CKTnode *node6; /* the sixth node's node pointer */
CKTnode *node7; /* the seventh node's node pointer */
int error; /* error code temporary */
int nodeflag; /* flag indicating 4 or 5 (or 6 or 7) nodes */
GENinstance *fast; /* pointer to the actual instance */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
char *model; /* the name of the model */
INPmodel *thismodel; /* pointer to model description for user's model */
GENmodel *mdfast; /* pointer to the actual model */
IFuid uid; /* uid for default model */
int type; /* the type the model says it is */
char *line; /* the part of the current line left to parse */
char *name; /* the resistor's name */
char *nname1; /* the first node's name */
char *nname2; /* the second node's name */
char *nname3; /* the third node's name */
char *nname4; /* the fourth node's name */
char *nname5; /* the fifth node's name */
char *nname6; /* the sixt node's name */
char *nname7; /* the seventh node's name */
char *save; /* saj - used to save the posn of the start of
the parameters if the model is a mosfet*/
CKTnode *node1; /* the first node's node pointer */
CKTnode *node2; /* the second node's node pointer */
CKTnode *node3; /* the third node's node pointer */
CKTnode *node4; /* the fourth node's node pointer */
CKTnode *node5; /* the fifth node's node pointer */
CKTnode *node6; /* the sixth node's node pointer */
CKTnode *node7; /* the seventh node's node pointer */
int error; /* error code temporary */
int nodeflag; /* flag indicating 4 or 5 (or 6 or 7) nodes */
GENinstance *fast; /* pointer to the actual instance */
int waslead; /* flag to indicate that funny unlabeled number was found */
double leadval; /* actual value of unlabeled number */
char *model; /* the name of the model */
INPmodel *thismodel; /* pointer to model description for user's model */
GENmodel *mdfast; /* pointer to the actual model */
IFuid uid; /* uid for default model */
char* err_msg;
#ifdef TRACE
printf("INP2M: Parsing '%s'\n",current->line);
#endif
nodeflag = 0; /* initially specify a 4 terminal device */
nodeflag = 0; /* initially specify a 4 terminal device */
line = current->line;
INPgetTok (&line, &name, 1);
INPinsert (&name, tab);
@ -71,9 +71,9 @@ INP2M (CKTcircuit *ckt, INPtables * tab, card * current)
/* See if 5th token after device specification is a model name */
INPgetNetTok (&line, &nname5, 1); /* get 5th token */
save = line; /*saj - save the posn for later if
the default mosfet model is used */
INPgetNetTok (&line, &nname5, 1); /* get 5th token */
save = line; /* saj - save the posn for later if
the default mosfet model is used */
thismodel = NULL;
#ifdef TRACE
printf("INP2M: checking for 4 node device\n");
@ -86,106 +86,107 @@ INP2M (CKTcircuit *ckt, INPtables * tab, card * current)
}
if (thismodel == NULL)
{ /* 5th token is not a model in the table */
nodeflag = 1; /* now specify a 5 node device */
INPgetNetTok (&line, &nname6, 1); /* get next token */
{ /* 5th token is not a model in the table */
nodeflag = 1; /* now specify a 5 node device */
INPgetNetTok (&line, &nname6, 1); /* get next token */
thismodel = NULL;
#ifdef TRACE
printf("INP2M: checking for 5 node device\n");
#endif
INPgetMod (ckt, nname6, &thismodel, tab);
if (thismodel == NULL)
{ /* 6th token is not a model in the table */
nodeflag = 2; /* now specify a 6 node device */
INPgetNetTok (&line, &nname7, 1); /* get next token */
thismodel = NULL;
{ /* 6th token is not a model in the table */
nodeflag = 2; /* now specify a 6 node device */
INPgetNetTok (&line, &nname7, 1); /* get next token */
thismodel = NULL;
#ifdef TRACE
printf("INP2M: checking for 6 node device\n");
printf("INP2M: checking for 6 node device\n");
#endif
INPgetMod (ckt, nname7, &thismodel, tab);
if (thismodel == NULL)
{ /* 7th token is not a model in the table */
nodeflag = 3; /* now specify a 7 node device */
INPgetTok (&line, &model, 1); /* get model name */
INPgetMod (ckt, nname7, &thismodel, tab);
if (thismodel == NULL)
{ /* 7th token is not a model in the table */
nodeflag = 3; /* now specify a 7 node device */
INPgetTok (&line, &model, 1); /* get model name */
#ifdef TRACE
printf("INP2M: checking for 7 node device\n");
printf("INP2M: checking for 7 node device\n");
#endif
INPgetMod (ckt, model, &thismodel, tab); /* get pointer to the model */
if (thismodel != NULL)
{
if ((thismodel->INPmodType != INPtypelook ("B4SOI")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIPD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIFD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIDD"))
)
{
/* if model is not variable node B3SOIPD/FD/DD model, error! */
LITERR ("only level 55-58: B3SOI(PD|FD|DD) and B4SOI can have 7 nodes") return;
}
else
{ /* if looking at B3SOIPD/FD/DD model, allocate the 7th node */
INPtermInsert (ckt, &nname5, tab, &node5);
INPtermInsert (ckt, &nname6, tab, &node6);
INPtermInsert (ckt, &nname7, tab, &node7);
}
}
/*saj unbreak the default model creation*/
else{
#ifdef TRACE
printf("INP2M: couldn't workout number of nodes, assuming 4\n");
#endif
model = nname5;/*mosfet*/
line = save; /* reset the posn to what it sould be */
}
/*saj*/
}
else
{ /* 7th token is a model - only have 6 terminal device */
if ((thismodel->INPmodType != INPtypelook ("B4SOI")) &&
INPgetMod (ckt, model, &thismodel, tab); /* get pointer to the model */
if (thismodel != NULL)
{
if ((thismodel->INPmodType != INPtypelook ("B4SOI")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIPD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIFD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIDD")) &&
(thismodel->INPmodType != INPtypelook ("SOI3"))
)
{
/* if model is not variable node B3SOIPD/FD/DD or STAG model, error! */
LITERR ("only level 55-58,60: B3SOI(PD|FD|DD), B4SOI and STAG (SOI3) can have 6 nodes") return;
}
else
{ /* if looking at B3SOIPD/FD/DD or STAG (SOI3) model, allocate the 6th node */
INPtermInsert (ckt, &nname5, tab, &node5);
INPtermInsert (ckt, &nname6, tab, &node6);
model = nname7;
}
}
}
(thismodel->INPmodType != INPtypelook ("B3SOIFD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIDD"))
)
{
/* if model is not variable node B3SOIPD/FD/DD model, error! */
LITERR ("only level 55-58: B3SOI(PD|FD|DD) and B4SOI can have 7 nodes") return;
}
else
{ /* if looking at B3SOIPD/FD/DD or B4SOI model, allocate the 7th node */
INPtermInsert (ckt, &nname5, tab, &node5);
INPtermInsert (ckt, &nname6, tab, &node6);
INPtermInsert (ckt, &nname7, tab, &node7);
}
}
/* saj - unbreak the default model creation*/
else{
#ifdef TRACE
printf("INP2M: couldn't workout number of nodes, assuming 4\n");
#endif
model = nname5;/* mosfet*/
line = save; /* reset the posn to what it sould be */
}
/*saj*/
}
else
{ /* 7th token is a model - only have 6 terminal device */
if ((thismodel->INPmodType != INPtypelook ("B4SOI")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIPD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIFD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIDD")) &&
(thismodel->INPmodType != INPtypelook ("HiSIMHV")) &&
(thismodel->INPmodType != INPtypelook ("SOI3"))
)
{
/* if model is not variable node B3SOIPD/FD/DD or STAG model, error! */
LITERR ("only level 55-58,61,62: B3SOI(PD|FD|DD), B4SOI, STAG (SOI3) and HiSIMHV can have 6 nodes") return;
}
else
{ /* if looking at B3SOIPD/FD/DD, B4SOI, STAG (SOI3) or HiSIMHV model, allocate the 6th node */
INPtermInsert (ckt, &nname5, tab, &node5);
INPtermInsert (ckt, &nname6, tab, &node6);
model = nname7;
}
}
}
else
{ /* 6th token is a model - only have 5 terminal device */
if ((thismodel->INPmodType != INPtypelook ("B4SOI")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIPD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIFD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIDD")) &&
(thismodel->INPmodType != INPtypelook ("SOI3"))
)
{
/* if model is not variable node B3SOIPD/FD/DD model, error! */
LITERR ("only level 55-58,60: B3SOI(PD|FD|DD), B4SOI and STAG (SOI3) can have 5 nodes") return;
}
else
{ /* if looking at B3SOIPD/FD/DD or STAG (SOI3) model, allocate the 5th node */
INPtermInsert (ckt, &nname5, tab, &node5);
model = nname6; /* make model point to the correct token */
}
}
{ /* 6th token is a model - only have 5 terminal device */
if ((thismodel->INPmodType != INPtypelook ("B4SOI")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIPD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIFD")) &&
(thismodel->INPmodType != INPtypelook ("B3SOIDD")) &&
(thismodel->INPmodType != INPtypelook ("HiSIMHV")) &&
(thismodel->INPmodType != INPtypelook ("SOI3"))
)
{
/* if model is not variable node B3SOIPD/FD/DD model, error! */
LITERR ("only level 55-58,61,62: B3SOI(PD|FD|DD), B4SOI, STAG (SOI3) and HiSIMHV can have 5 nodes") return;
}
else
{ /* if looking at B3SOIPD/FD/DD, B4SOI, STAG (SOI3) or HiSIMHV model, allocate the 5th node */
INPtermInsert (ckt, &nname5, tab, &node5);
model = nname6; /* make model point to the correct token */
}
}
}
else
{ /* 5th token is a model - only have 4 terminal device */
model = nname5; /* make model point to the correct token */
{ /* 5th token is a model - only have 4 terminal device */
model = nname5; /* make model point to the correct token */
}
INPinsert (&model, tab);
thismodel = NULL;
#ifdef TRACE
@ -200,42 +201,43 @@ INP2M (CKTcircuit *ckt, INPtables * tab, card * current)
if (thismodel != NULL)
{
if (thismodel->INPmodType != INPtypelook ("Mos1")
&& thismodel->INPmodType != INPtypelook ("Mos2")
&& thismodel->INPmodType != INPtypelook ("Mos3")
&& thismodel->INPmodType != INPtypelook ("Mos5")
&& thismodel->INPmodType != INPtypelook ("Mos6")
&& thismodel->INPmodType != INPtypelook ("Mos8")
&& thismodel->INPmodType != INPtypelook ("Mos9")
&& thismodel->INPmodType != INPtypelook ("BSIM1")
&& thismodel->INPmodType != INPtypelook ("BSIM2")
&& thismodel->INPmodType != INPtypelook ("BSIM3")
&& thismodel->INPmodType != INPtypelook ("BSIM3v32")
&& thismodel->INPmodType != INPtypelook ("B4SOI")
&& thismodel->INPmodType != INPtypelook ("B3SOIPD")
&& thismodel->INPmodType != INPtypelook ("B3SOIFD")
&& thismodel->INPmodType != INPtypelook ("B3SOIDD")
&& thismodel->INPmodType != INPtypelook ("BSIM4")
&& thismodel->INPmodType != INPtypelook ("BSIM4v2")
&& thismodel->INPmodType != INPtypelook ("BSIM4v3")
&& thismodel->INPmodType != INPtypelook ("BSIM4v4")
&& thismodel->INPmodType != INPtypelook ("BSIM4v5")
&& thismodel->INPmodType != INPtypelook ("BSIM3v0")
&& thismodel->INPmodType != INPtypelook ("BSIM3v1")
&& thismodel->INPmodType != INPtypelook ("SOI3")
if (thismodel->INPmodType != INPtypelook ("Mos1")
&& thismodel->INPmodType != INPtypelook ("Mos2")
&& thismodel->INPmodType != INPtypelook ("Mos3")
&& thismodel->INPmodType != INPtypelook ("Mos5")
&& thismodel->INPmodType != INPtypelook ("Mos6")
&& thismodel->INPmodType != INPtypelook ("Mos8")
&& thismodel->INPmodType != INPtypelook ("Mos9")
&& thismodel->INPmodType != INPtypelook ("BSIM1")
&& thismodel->INPmodType != INPtypelook ("BSIM2")
&& thismodel->INPmodType != INPtypelook ("BSIM3")
&& thismodel->INPmodType != INPtypelook ("BSIM3v32")
&& thismodel->INPmodType != INPtypelook ("B4SOI")
&& thismodel->INPmodType != INPtypelook ("B3SOIPD")
&& thismodel->INPmodType != INPtypelook ("B3SOIFD")
&& thismodel->INPmodType != INPtypelook ("B3SOIDD")
&& thismodel->INPmodType != INPtypelook ("BSIM4")
&& thismodel->INPmodType != INPtypelook ("BSIM4v2")
&& thismodel->INPmodType != INPtypelook ("BSIM4v3")
&& thismodel->INPmodType != INPtypelook ("BSIM4v4")
&& thismodel->INPmodType != INPtypelook ("BSIM4v5")
&& thismodel->INPmodType != INPtypelook ("BSIM3v0")
&& thismodel->INPmodType != INPtypelook ("BSIM3v1")
&& thismodel->INPmodType != INPtypelook ("SOI3")
#ifdef CIDER
&& thismodel->INPmodType != INPtypelook ("NUMOS")
&& thismodel->INPmodType != INPtypelook ("NUMOS")
#endif
#ifdef ADMS
&& thismodel->INPmodType != INPtypelook ("ekv")
&& thismodel->INPmodType != INPtypelook ("psp102")
#endif
&& thismodel->INPmodType != INPtypelook ("HiSIM1")
)
{
LITERR ("incorrect model type");
return;
}
&& thismodel->INPmodType != INPtypelook ("ekv")
&& thismodel->INPmodType != INPtypelook ("psp102")
#endif
&& thismodel->INPmodType != INPtypelook ("HiSIM1")
&& thismodel->INPmodType != INPtypelook ("HiSIMHV")
)
{
LITERR ("incorrect model type");
return;
}
type = thismodel->INPmodType;
mdfast = (thismodel->INPmodfast);
}
@ -243,16 +245,16 @@ INP2M (CKTcircuit *ckt, INPtables * tab, card * current)
{
type = INPtypelook ("Mos1");
if (type < 0)
{
LITERR ("Device type MOS1 not supported by this binary\n");
return;
}
{
LITERR ("Device type MOS1 not supported by this binary\n");
return;
}
if (!tab->defMmod)
{
/* create default M model */
IFnewUid (ckt, &uid, NULL, "M", UID_MODEL, NULL);
IFC (newModel, (ckt, type, &(tab->defMmod), uid));
}
{
/* create default M model */
IFnewUid (ckt, &uid, NULL, "M", UID_MODEL, NULL);
IFC (newModel, (ckt, type, &(tab->defMmod), uid));
}
mdfast = tab->defMmod;
}
IFC (newInstance, (ckt, mdfast, &fast, name));
@ -260,37 +262,39 @@ INP2M (CKTcircuit *ckt, INPtables * tab, card * current)
IFC (bindNode, (ckt, fast, 2, node2));
IFC (bindNode, (ckt, fast, 3, node3));
IFC (bindNode, (ckt, fast, 4, node4));
/*use type not thismodel->INPmodType as it might not exist!*/
/* use type - not thismodel->INPmodType as it might not exist! */
if ((type == INPtypelook ("B4SOI")) ||
(type == INPtypelook ("B3SOIPD")) ||
(type == INPtypelook ("B3SOIFD")) ||
(type == INPtypelook ("B3SOIDD")) ||
(type == INPtypelook ("HiSIMHV")) ||
(type == INPtypelook ("SOI3")))
{
switch (nodeflag)
{
case 0:
fast->GENnode5 = -1;
fast->GENnode6 = -1;
fast->GENnode7 = -1;
break;
case 1:
IFC (bindNode, (ckt, fast, 5, node5))
fast->GENnode6 = -1;
fast->GENnode7 = -1;
break;
case 2:
IFC (bindNode, (ckt, fast, 5, node5))
IFC (bindNode, (ckt, fast, 6, node6))
fast->GENnode7 = -1;
break;
case 3:
IFC (bindNode, (ckt, fast, 5, node5))
IFC (bindNode, (ckt, fast, 6, node6))
IFC (bindNode, (ckt, fast, 7, node7)) break;
default:
break;
}
{
case 0:
fast->GENnode5 = -1;
fast->GENnode6 = -1;
fast->GENnode7 = -1;
break;
case 1:
IFC (bindNode, (ckt, fast, 5, node5))
fast->GENnode6 = -1;
fast->GENnode7 = -1;
break;
case 2:
IFC (bindNode, (ckt, fast, 5, node5))
IFC (bindNode, (ckt, fast, 6, node6))
fast->GENnode7 = -1;
break;
case 3:
IFC (bindNode, (ckt, fast, 5, node5))
IFC (bindNode, (ckt, fast, 6, node6))
IFC (bindNode, (ckt, fast, 7, node7))
break;
default:
break;
}
}
PARSECALL ((&line, ckt, type, fast, &leadval, &waslead, tab));

12
src/spicelib/parser/inpdomod.c
View File

@ -395,6 +395,14 @@ char *INPdomodel(CKTcircuit *ckt, card * image, INPtables * tab)
("Device type SOI3 not available in this binary (STAG release)\n");
}
break;
case 62:
type = INPtypelook("HiSIMHV");
if (type < 0) {
err =
INPmkTemp
("Placeholder: Device type HiSIMHV not available in this binary\n");
}
break;
case 64:
type = INPtypelook("HiSIM1");
if (type < 0) {
@ -407,9 +415,9 @@ char *INPdomodel(CKTcircuit *ckt, card * image, INPtables * tab)
err =
INPmkTemp
#ifdef ADMS
("Only MOS device levels 1-6,8-10,14,44,45,49,54-58,61,64 are supported in this binary\n");
("Only MOS device levels 1-6,8-10,14,44,45,49,54-58,61,62,64 are supported in this binary\n");
#else
("Only MOS device levels 1-6,8-10,14,49,54-58,61,64 are supported in this binary\n");
("Only MOS device levels 1-6,8-10,14,49,54-58,61,62,64 are supported in this binary\n");
#endif
break;
}

17562
visualc/vngspice.vcproj
View File

File diff suppressed because it is too large Load Diff