From 1906903fb42989905fd6ce78135799a099c2ccbd Mon Sep 17 00:00:00 2001 From: dwarning Date: Fri, 29 Apr 2011 16:47:55 +0000 Subject: [PATCH] add the HiSIM_HV model vers. 1.2.1 --- configure.ac | 1 + src/Makefile.am | 1 + src/spicelib/devices/Makefile.am | 2 + src/spicelib/devices/dev.c | 82 +- src/spicelib/devices/hisimhv/Makefile.am | 36 + src/spicelib/devices/hisimhv/hisimhv.h | 73 + src/spicelib/devices/hisimhv/hsmhv.c | 740 + src/spicelib/devices/hisimhv/hsmhvacld.c | 295 + src/spicelib/devices/hisimhv/hsmhvask.c | 421 + src/spicelib/devices/hisimhv/hsmhvcvtest.c | 254 + src/spicelib/devices/hisimhv/hsmhvdef.h | 2912 +++ src/spicelib/devices/hisimhv/hsmhvdel.c | 47 + src/spicelib/devices/hisimhv/hsmhvdest.c | 45 + src/spicelib/devices/hisimhv/hsmhveval.c | 6393 ++++++ .../devices/hisimhv/hsmhveval_qover.h | 693 + src/spicelib/devices/hisimhv/hsmhvevalenv.h | 91 + src/spicelib/devices/hisimhv/hsmhvext.h | 39 + src/spicelib/devices/hisimhv/hsmhvgetic.c | 57 + src/spicelib/devices/hisimhv/hsmhvinit.c | 82 + src/spicelib/devices/hisimhv/hsmhvinit.h | 13 + src/spicelib/devices/hisimhv/hsmhvitf.h | 23 + src/spicelib/devices/hisimhv/hsmhvld.c | 2583 +++ .../devices/hisimhv/hsmhvld_info_eval.h | 123 + src/spicelib/devices/hisimhv/hsmhvmask.c | 1855 ++ src/spicelib/devices/hisimhv/hsmhvmdel.c | 54 + src/spicelib/devices/hisimhv/hsmhvmpar.c | 2454 +++ src/spicelib/devices/hisimhv/hsmhvnoi.c | 279 + src/spicelib/devices/hisimhv/hsmhvpar.c | 212 + src/spicelib/devices/hisimhv/hsmhvpzld.c | 280 + src/spicelib/devices/hisimhv/hsmhvset.c | 1454 ++ src/spicelib/devices/hisimhv/hsmhvtemp.c | 419 + src/spicelib/devices/hisimhv/hsmhvtemp_eval.h | 382 + src/spicelib/devices/hisimhv/hsmhvtrunc.c | 61 + src/spicelib/parser/inp2m.c | 364 +- src/spicelib/parser/inpdomod.c | 12 +- visualc/vngspice.vcproj | 17562 ++++++++-------- 36 files changed, 31387 insertions(+), 9007 deletions(-) create mode 100644 src/spicelib/devices/hisimhv/Makefile.am create mode 100644 src/spicelib/devices/hisimhv/hisimhv.h create mode 100644 src/spicelib/devices/hisimhv/hsmhv.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvacld.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvask.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvcvtest.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvdef.h create mode 100644 src/spicelib/devices/hisimhv/hsmhvdel.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvdest.c create mode 100644 src/spicelib/devices/hisimhv/hsmhveval.c create mode 100644 src/spicelib/devices/hisimhv/hsmhveval_qover.h create mode 100644 src/spicelib/devices/hisimhv/hsmhvevalenv.h create mode 100644 src/spicelib/devices/hisimhv/hsmhvext.h create mode 100644 src/spicelib/devices/hisimhv/hsmhvgetic.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvinit.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvinit.h create mode 100644 src/spicelib/devices/hisimhv/hsmhvitf.h create mode 100644 src/spicelib/devices/hisimhv/hsmhvld.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvld_info_eval.h create mode 100644 src/spicelib/devices/hisimhv/hsmhvmask.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvmdel.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvmpar.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvnoi.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvpar.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvpzld.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvset.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvtemp.c create mode 100644 src/spicelib/devices/hisimhv/hsmhvtemp_eval.h create mode 100644 src/spicelib/devices/hisimhv/hsmhvtrunc.c diff --git a/configure.ac b/configure.ac index ab917bcfc..99432874a 100644 --- a/configure.ac +++ b/configure.ac @@ -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 diff --git a/src/Makefile.am b/src/Makefile.am index efc1b8468..21f894bb5 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -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 \ diff --git a/src/spicelib/devices/Makefile.am b/src/spicelib/devices/Makefile.am index 16f92d80f..a9f31a24e 100644 --- a/src/spicelib/devices/Makefile.am +++ b/src/spicelib/devices/Makefile.am @@ -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 \ diff --git a/src/spicelib/devices/dev.c b/src/spicelib/devices/dev.c index 6ddc039f2..dafcf508c 100644 --- a/src/spicelib/devices/dev.c +++ b/src/spicelib/devices/dev.c @@ -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 diff --git a/src/spicelib/devices/hisimhv/Makefile.am b/src/spicelib/devices/hisimhv/Makefile.am new file mode 100644 index 000000000..c666e7dbb --- /dev/null +++ b/src/spicelib/devices/hisimhv/Makefile.am @@ -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 diff --git a/src/spicelib/devices/hisimhv/hisimhv.h b/src/spicelib/devices/hisimhv/hisimhv.h new file mode 100644 index 000000000..6e84fd073 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hisimhv.h @@ -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 */ diff --git a/src/spicelib/devices/hisimhv/hsmhv.c b/src/spicelib/devices/hisimhv/hsmhv.c new file mode 100644 index 000000000..af23218f4 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhv.c @@ -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 +#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); + diff --git a/src/spicelib/devices/hisimhv/hsmhvacld.c b/src/spicelib/devices/hisimhv/hsmhvacld.c new file mode 100644 index 000000000..7dbe11703 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvacld.c @@ -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 +#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); +} diff --git a/src/spicelib/devices/hisimhv/hsmhvask.c b/src/spicelib/devices/hisimhv/hsmhvask.c new file mode 100644 index 000000000..934cacb96 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvask.c @@ -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 +#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 */ +} diff --git a/src/spicelib/devices/hisimhv/hsmhvcvtest.c b/src/spicelib/devices/hisimhv/hsmhvcvtest.c new file mode 100644 index 000000000..2455da5ce --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvcvtest.c @@ -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 +#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); +} diff --git a/src/spicelib/devices/hisimhv/hsmhvdef.h b/src/spicelib/devices/hisimhv/hsmhvdef.h new file mode 100644 index 000000000..1ef624c1c --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvdef.h @@ -0,0 +1,2912 @@ +/*********************************************************************** + + 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 : hsmhvdef + + DATE : 2010.11.02 + + released by + Hiroshima University & + Semiconductor Technology Academic Research Center (STARC) +***********************************************************************/ + +#ifndef HSMHV +#define HSMHV + +#include "ifsim.h" +#include "gendefs.h" +#include "cktdefs.h" +#include "complex.h" +#include "noisedef.h" + +/* declarations for HiSIMHV MOSFETs */ + +/* unit-converted model parameters */ +typedef struct sHSMHVmodelMKSParam { + double HSMHV_npext ; + double HSMHV_vmax ; + double HSMHV_ll ; + double HSMHV_wl ; + double HSMHV_svgsl ; + double HSMHV_svgsw ; + double HSMHV_svbsl ; + double HSMHV_slgl ; + double HSMHV_sub1l ; + double HSMHV_slg ; + double HSMHV_sub2l ; + double HSMHV_subld2 ; + double HSMHV_rd22 ; + double HSMHV_rd23 ; + double HSMHV_rd24 ; + double HSMHV_rdtemp1 ; + double HSMHV_rdtemp2 ; + double HSMHV_rdvd ; + double HSMHV_rdvdtemp1 ; + double HSMHV_rdvdtemp2 ; +//double HSMHV_muecb0 ; +//double HSMHV_muecb1 ; +//double HSMHV_muesr1 ; +//double HSMHV_mueph1 ; + double HSMHV_nsubsub ; + double HSMHV_nsubpsti1 ; + double HSMHV_muesti1 ; + double HSMHV_wfc ; + double HSMHV_glksd1 ; + double HSMHV_glksd2 ; + double HSMHV_glksd3 ; + double HSMHV_gleak2 ; + double HSMHV_gleak4 ; + double HSMHV_gleak5 ; + double HSMHV_gleak7 ; + double HSMHV_glkb2 ; + double HSMHV_fn2 ; + double HSMHV_gidl1 ; + double HSMHV_gidl2 ; + double HSMHV_nfalp ; + double HSMHV_nftrp ; + double HSMHV_cit ; + double HSMHV_ovslp ; + double HSMHV_dly3 ; + double HSMHV_rth0 ; + double HSMHV_cth0 ; +} HSMHVmodelMKSParam ; + + +/* binning parameters */ +typedef struct sHSMHVbinningParam { + double HSMHV_vmax ; + double HSMHV_bgtmp1 ; + double HSMHV_bgtmp2 ; + double HSMHV_eg0 ; + double HSMHV_vfbover ; + double HSMHV_nover ; + double HSMHV_novers ; + double HSMHV_wl2 ; + double HSMHV_vfbc ; + double HSMHV_nsubc ; + double HSMHV_nsubp ; + double HSMHV_scp1 ; + double HSMHV_scp2 ; + double HSMHV_scp3 ; + double HSMHV_sc1 ; + double HSMHV_sc2 ; + double HSMHV_sc3 ; + double HSMHV_pgd1 ; + double HSMHV_pgd3 ; + double HSMHV_ndep ; + double HSMHV_ninv ; + double HSMHV_muecb0 ; + double HSMHV_muecb1 ; + double HSMHV_mueph1 ; + double HSMHV_vtmp ; + double HSMHV_wvth0 ; + double HSMHV_muesr1 ; + double HSMHV_muetmp ; + double HSMHV_sub1 ; + double HSMHV_sub2 ; + double HSMHV_svds ; + double HSMHV_svbs ; + double HSMHV_svgs ; + double HSMHV_fn1 ; + double HSMHV_fn2 ; + double HSMHV_fn3 ; + double HSMHV_fvbs ; + double HSMHV_nsti ; + double HSMHV_wsti ; + double HSMHV_scsti1 ; + double HSMHV_scsti2 ; + double HSMHV_vthsti ; + double HSMHV_muesti1 ; + double HSMHV_muesti2 ; + double HSMHV_muesti3 ; + double HSMHV_nsubpsti1 ; + double HSMHV_nsubpsti2 ; + double HSMHV_nsubpsti3 ; + double HSMHV_cgso ; + double HSMHV_cgdo ; + double HSMHV_js0 ; + double HSMHV_js0sw ; + double HSMHV_nj ; + double HSMHV_cisbk ; + double HSMHV_clm1 ; + double HSMHV_clm2 ; + double HSMHV_clm3 ; + double HSMHV_wfc ; + double HSMHV_gidl1 ; + double HSMHV_gidl2 ; + double HSMHV_gleak1 ; + double HSMHV_gleak2 ; + double HSMHV_gleak3 ; + double HSMHV_gleak6 ; + double HSMHV_glksd1 ; + double HSMHV_glksd2 ; + double HSMHV_glkb1 ; + double HSMHV_glkb2 ; + double HSMHV_nftrp ; + double HSMHV_nfalp ; + double HSMHV_pthrou ; + double HSMHV_vdiffj ; + double HSMHV_ibpc1 ; + double HSMHV_ibpc2 ; + double HSMHV_cgbo ; + double HSMHV_cvdsover ; + double HSMHV_falph ; + double HSMHV_npext ; + double HSMHV_powrat ; + double HSMHV_rd ; + double HSMHV_rd22 ; + double HSMHV_rd23 ; + double HSMHV_rd24 ; + double HSMHV_rdict1 ; + double HSMHV_rdov13 ; + double HSMHV_rdslp1 ; + double HSMHV_rdvb ; + double HSMHV_rdvd ; + double HSMHV_rdvg11 ; + double HSMHV_rs ; + double HSMHV_rth0 ; + double HSMHV_vover ; + /*-----------SHE--------------*/ + double HSMHV_rth ; + double HSMHV_cth ; + /*-----------------------------*/ + +} HSMHVbinningParam ; + + +/* unit-converted parameters for each instance */ +typedef struct sHSMHVhereMKSParam { + double HSMHV_vmax ; + double HSMHV_subld2 ; +//double HSMHV_muecb0 ; +//double HSMHV_muecb1 ; +//double HSMHV_muesr1 ; +//double HSMHV_mueph1 ; + double HSMHV_ndep ; + double HSMHV_ninv ; + double HSMHV_nsubc ; + double HSMHV_nsubcdfm ; + double HSMHV_nsubp ; + double HSMHV_nsubpsti1 ; + double HSMHV_muesti1 ; + double HSMHV_nsti ; + double HSMHV_npext ; + double HSMHV_nover ; + double HSMHV_novers ; + double HSMHV_wfc ; + double HSMHV_glksd1 ; + double HSMHV_glksd2 ; + double HSMHV_gleak2 ; + double HSMHV_glkb2 ; + double HSMHV_fn2 ; + double HSMHV_gidl1 ; + double HSMHV_gidl2 ; + double HSMHV_nfalp ; + double HSMHV_nftrp ; +} HSMHVhereMKSParam ; + + +/* information needed for each instance */ +typedef struct sHSMHVinstance { + struct sHSMHVmodel *HSMHVmodPtr; /* pointer to model */ + struct sHSMHVinstance *HSMHVnextInstance; /* pointer to next instance of + current model*/ + IFuid HSMHVname; /* pointer to character string naming this instance */ + int HSMHVstates; /* index into state table for this device */ + + int HSMHVdNode; /* number of the drain node of the mosfet */ + int HSMHVgNode; /* number of the gate node of the mosfet */ + int HSMHVsNode; /* number of the source node of the mosfet */ + int HSMHVbNode; /* number of the bulk node of the mosfet */ + int HSMHVsubNode; /* number of the substrate node */ + int HSMHVtempNode; /* number of the temp node----------SHE--------*/ + int HSMHVdNodePrime; /* number od the inner drain node */ + int HSMHVgNodePrime; /* number of the inner gate node */ + int HSMHVsNodePrime; /* number od the inner source node */ + int HSMHVbNodePrime; + int HSMHVdbNode; + int HSMHVsbNode; + int HSMHVqiNode; /* number of the qi node in case of NQS */ + int HSMHVqbNode; /* number of the qb node in case of NQS */ + + double HSMHV_noiflick; /* for 1/f noise calc. */ + double HSMHV_noithrml; /* for thrmal noise calc. */ + double HSMHV_noiigate; /* for induced gate noise */ + double HSMHV_noicross; /* for induced gate noise */ + + /* instance */ + int HSMHV_coselfheat; /* Self-heating model */ + int HSMHV_cosubnode; /* switch tempNode to subNode */ + double HSMHV_l; /* the length of the channel region */ + double HSMHV_w; /* the width of the channel region */ + double HSMHV_ad; /* the area of the drain diffusion */ + double HSMHV_as; /* the area of the source diffusion */ + double HSMHV_pd; /* perimeter of drain junction [m] */ + double HSMHV_ps; /* perimeter of source junction [m] */ + double HSMHV_nrd; /* equivalent num of squares of drain [-] (unused) */ + double HSMHV_nrs; /* equivalent num of squares of source [-] (unused) */ + double HSMHV_dtemp; + + double HSMHV_weff; /* the effective width of the channel region */ + double HSMHV_weff_ld; /* the effective width of the drift region */ + double HSMHV_weff_cv; /* the effective width of the drift region for capacitance */ + double HSMHV_weff_nf; /* Weff * NF */ + double HSMHV_weffcv_nf; /* Weffcv * NF */ + double HSMHV_leff; /* the effective length of the channel region */ + + int HSMHV_corbnet ; + double HSMHV_rbpb ; + double HSMHV_rbpd ; + double HSMHV_rbps ; + double HSMHV_rbdb ; + double HSMHV_rbsb ; + + int HSMHV_corg ; + double HSMHV_ngcon; + double HSMHV_xgw; + double HSMHV_xgl; + double HSMHV_nf; + + double HSMHV_sa; + double HSMHV_sb; + double HSMHV_sd; + double HSMHV_nsubcdfm; + double HSMHV_m; + double HSMHV_subld1; + double HSMHV_subld2; + double HSMHV_lover; + double HSMHV_lovers; + double HSMHV_loverld; + double HSMHV_ldrift1; + double HSMHV_ldrift2; + double HSMHV_ldrift1s; + double HSMHV_ldrift2s; + + int HSMHV_called; /* flag to check the first call */ + /* previous values to evaluate initial guess */ + double HSMHV_mode_prv; + double HSMHV_vbsc_prv; + double HSMHV_vdsc_prv; + double HSMHV_vgsc_prv; + double HSMHV_ps0_prv; + double HSMHV_ps0_dvbs_prv; + double HSMHV_ps0_dvds_prv; + double HSMHV_ps0_dvgs_prv; + double HSMHV_ps0_dtemp_prv; + double HSMHV_pds_prv; + double HSMHV_pds_dvbs_prv; + double HSMHV_pds_dvds_prv; + double HSMHV_pds_dvgs_prv; + double HSMHV_pds_dtemp_prv; + /* double HSMHV_ids_prv; not used */ + /* double HSMHV_ids_dvbs_prv; not used */ + /* double HSMHV_ids_dvds_prv; not used */ + /* double HSMHV_ids_dvgs_prv; not used */ + /* double HSMHV_ids_dtemp_prv; not used */ + double HSMHV_mode_prv2; + double HSMHV_vbsc_prv2; + double HSMHV_vdsc_prv2; + double HSMHV_vgsc_prv2; + double HSMHV_ps0_prv2; /* assigned but not used */ + double HSMHV_ps0_dvbs_prv2; + double HSMHV_ps0_dvds_prv2; + double HSMHV_ps0_dvgs_prv2; + double HSMHV_pds_prv2; /* assigned but not used */ + double HSMHV_pds_dvbs_prv2; + double HSMHV_pds_dvds_prv2; + double HSMHV_pds_dvgs_prv2; + double HSMHV_temp_prv; +/* double HSMHV_time; /\* for debug print *\/ */ + + /* output */ + /* int HSMHV_capop; not used */ + /* double HSMHV_gd; not used */ + /* double HSMHV_gs; not used */ + double HSMHV_cgso; /* can be made local */ + double HSMHV_cgdo; + double HSMHV_cgbo; + double HSMHV_cggo; + double HSMHV_cdso; /* can be made local */ + double HSMHV_cddo; + double HSMHV_cdgo; + double HSMHV_cdbo; + double HSMHV_csso; /* can be made local */ + double HSMHV_csdo; /* can be made local */ + double HSMHV_csgo; /* can be made local */ + double HSMHV_csbo; /* can be made local */ + double HSMHV_cbdo; + double HSMHV_cbgo; + double HSMHV_cbbo; + /* double HSMHV_cqyd; not used */ + /* double HSMHV_cqyg; not used */ + /* double HSMHV_cqyb; not used */ + double HSMHV_von; /* vth */ + double HSMHV_vdsat; + /* double HSMHV_capgs; not used */ + /* double HSMHV_capgd; not used */ + /* double HSMHV_capgb; not used */ + + /* double HSMHV_rth0; not used */ + /* double HSMHV_cth0; not used */ + /* double HSMHV_cth; not used */ + + +#define XDIM 14 + double HSMHV_ydc_d[XDIM], HSMHV_ydc_dP[XDIM], HSMHV_ydc_g[XDIM], HSMHV_ydc_gP[XDIM], HSMHV_ydc_s[XDIM], HSMHV_ydc_sP[XDIM], + HSMHV_ydc_bP[XDIM], HSMHV_ydc_b[XDIM], HSMHV_ydc_db[XDIM], HSMHV_ydc_sb[XDIM], HSMHV_ydc_t[XDIM], HSMHV_ydc_qi[XDIM], + HSMHV_ydc_qb[XDIM]; + double HSMHV_ydyn_d[XDIM], HSMHV_ydyn_dP[XDIM], HSMHV_ydyn_g[XDIM], HSMHV_ydyn_gP[XDIM], HSMHV_ydyn_s[XDIM], HSMHV_ydyn_sP[XDIM], + HSMHV_ydyn_bP[XDIM], HSMHV_ydyn_b[XDIM], HSMHV_ydyn_db[XDIM], HSMHV_ydyn_sb[XDIM], HSMHV_ydyn_t[XDIM], HSMHV_ydyn_qi[XDIM], + HSMHV_ydyn_qb[XDIM]; + + /* resistances */ + double HSMHV_Rd ; /* different from HSMHV_rd */ + double HSMHV_dRd_dVdse ; + double HSMHV_dRd_dVgse ; + double HSMHV_dRd_dVbse ; + double HSMHV_dRd_dVsubs ; + double HSMHV_dRd_dTi ; + double HSMHV_Rs ; /* different from HSMHV_rs */ + double HSMHV_dRs_dVdse ; + double HSMHV_dRs_dVgse ; + double HSMHV_dRs_dVbse ; + double HSMHV_dRs_dVsubs ; + double HSMHV_dRs_dTi ; + /* drain current */ + double HSMHV_ids; + double HSMHV_gds; /* used for printout, but not loaded */ + double HSMHV_gm; /* used for printout, but not loaded */ + double HSMHV_gmbs; /* used for printout, but not loaded */ + double HSMHV_dIds_dVdse ; + double HSMHV_dIds_dVgse ; + double HSMHV_dIds_dVbse ; + double HSMHV_dIds_dVdsi ; + double HSMHV_dIds_dVgsi ; + double HSMHV_dIds_dVbsi ; + double HSMHV_dIds_dTi ; + /* substrate current */ + double HSMHV_isub; + /* double HSMHV_gbgs; not used */ + /* double HSMHV_gbds; not used */ + /* double HSMHV_gbbs; not used */ + double HSMHV_dIsub_dVdsi ; + double HSMHV_dIsub_dVgsi ; + double HSMHV_dIsub_dVbsi ; + double HSMHV_dIsub_dTi ; + double HSMHV_dIsub_dVdse ; + /* gidl and gisl current */ + double HSMHV_igidl; /* gate induced drain leakage */ + /* double HSMHV_gigidlgs; not used */ + /* double HSMHV_gigidlds; not used */ + /* double HSMHV_gigidlbs; not used */ + double HSMHV_dIgidl_dVdsi ; + double HSMHV_dIgidl_dVgsi ; + double HSMHV_dIgidl_dVbsi ; + double HSMHV_dIgidl_dTi ; + double HSMHV_igisl; /* gate induced source leakage */ + /* double HSMHV_gigislgd; not used */ + /* double HSMHV_gigislsd; not used */ + /* double HSMHV_gigislbd; not used */ + double HSMHV_dIgisl_dVdsi ; + double HSMHV_dIgisl_dVgsi ; + double HSMHV_dIgisl_dVbsi ; + double HSMHV_dIgisl_dTi ; + /* gate leakage currents */ + double HSMHV_igb; /* gate tunneling current (gate to bulk) */ + /* double HSMHV_gigbg; not used */ + /* double HSMHV_gigbd; not used */ + /* double HSMHV_gigbb; not used */ + /* double HSMHV_gigbs; not used */ + double HSMHV_dIgb_dVdsi ; + double HSMHV_dIgb_dVgsi ; + double HSMHV_dIgb_dVbsi ; + double HSMHV_dIgb_dTi ; + double HSMHV_igd; /* gate tunneling current (gate to drain) */ + /* double HSMHV_gigdg; not used */ + /* double HSMHV_gigdd; not used */ + /* double HSMHV_gigdb; not used */ + /* double HSMHV_gigds; not used */ + double HSMHV_dIgd_dVdsi ; + double HSMHV_dIgd_dVgsi ; + double HSMHV_dIgd_dVbsi ; + double HSMHV_dIgd_dTi ; + double HSMHV_igs; /* gate tunneling current (gate to source) */ + /* double HSMHV_gigsg; not used */ + /* double HSMHV_gigsd; not used */ + /* double HSMHV_gigsb; not used */ + /* double HSMHV_gigss; not used */ + double HSMHV_dIgs_dVdsi ; + double HSMHV_dIgs_dVgsi ; + double HSMHV_dIgs_dVbsi ; + double HSMHV_dIgs_dTi ; + /* charges */ + double HSMHV_qd; + double HSMHV_cdgb; /* used for printout, but not loaded */ + /* double HSMHV_cddb; not used */ + /* double HSMHV_cdsb; not used */ + /* double HSMHVcdT; not used */ + double HSMHV_dQdi_dVdsi ; + double HSMHV_dQdi_dVgsi ; + double HSMHV_dQdi_dVbsi ; + double HSMHV_dQdi_dTi ; + double HSMHV_qg; + double HSMHV_cggb; /* used for printout, but not loaded */ + double HSMHV_cgdb; /* used for printout, but not loaded */ + double HSMHV_cgsb; /* used for printout, but not loaded */ + /* double HSMHVcgT; not used */ + double HSMHV_dQg_dVdsi ; + double HSMHV_dQg_dVgsi ; + double HSMHV_dQg_dVbsi ; + double HSMHV_dQg_dTi ; + double HSMHV_qs; + double HSMHV_dQsi_dVdsi ; + double HSMHV_dQsi_dVgsi ; + double HSMHV_dQsi_dVbsi ; + double HSMHV_dQsi_dTi ; + double HSMHV_qb; /* bulk charge qb = -(qg + qd + qs) */ + double HSMHV_cbgb; /* used for printout, but not loaded */ + /* double HSMHV_cbdb; not used */ + /* double HSMHV_cbsb; not used */ + /* double HSMHVcbT; not used */ + double HSMHV_dQb_dVdsi ; /* Qb: bulk charge inclusive overlaps, Qbulk: bulk charge without overlaps (see above) */ + double HSMHV_dQb_dVgsi ; + double HSMHV_dQb_dVbsi ; + double HSMHV_dQb_dTi ; + /* outer charges (fringing etc.) */ + double HSMHV_qdp ; + double HSMHV_dqdp_dVdse ; + double HSMHV_dqdp_dVgse ; + double HSMHV_dqdp_dVbse ; + double HSMHV_dqdp_dTi ; + double HSMHV_qsp ; + double HSMHV_dqsp_dVdse ; + double HSMHV_dqsp_dVgse ; + double HSMHV_dqsp_dVbse ; + double HSMHV_dqsp_dTi ; + /* junctions */ + double HSMHV_ibd; + double HSMHV_gbd; + double HSMHV_gbdT; + double HSMHV_ibs; + double HSMHV_gbs; + double HSMHV_gbsT; + double HSMHV_qbd; + double HSMHV_capbd; + double HSMHV_gcbdT; + double HSMHV_qbs; + double HSMHV_capbs; + double HSMHV_gcbsT; + + /* double HSMHV_gtempg; not used */ + /* double HSMHV_gtempt; not used */ + /* double HSMHV_gtempd; not used */ + /* double HSMHV_gtempb; not used */ + + /* double HSMHV_gmt; not used */ + /* double HSMHV_isubt; not used */ + + + /* NQS */ + double HSMHV_tau ; + double HSMHV_tau_dVgsi ; + double HSMHV_tau_dVdsi ; + double HSMHV_tau_dVbsi ; + double HSMHV_tau_dTi ; + double HSMHV_Xd ; + double HSMHV_Xd_dVgsi ; + double HSMHV_Xd_dVdsi ; + double HSMHV_Xd_dVbsi ; + double HSMHV_Xd_dTi ; + double HSMHV_Qi ; + double HSMHV_Qi_dVgsi ; + double HSMHV_Qi_dVdsi ; + double HSMHV_Qi_dVbsi ; + double HSMHV_Qi_dTi ; + double HSMHV_taub ; + double HSMHV_taub_dVgsi ; + double HSMHV_taub_dVdsi ; + double HSMHV_taub_dVbsi ; + double HSMHV_taub_dTi ; + double HSMHV_Qbulk ; /* Qbulk: without overlaps, Qb: inclusive overlaps (see below) */ + double HSMHV_Qbulk_dVgsi ; + double HSMHV_Qbulk_dVdsi ; + double HSMHV_Qbulk_dVbsi ; + double HSMHV_Qbulk_dTi ; + + + + + /* internal variables */ + double HSMHV_eg ; + double HSMHV_beta ; + double HSMHV_beta_inv ; + double HSMHV_beta2 ; + double HSMHV_betatnom ; + double HSMHV_nin ; + double HSMHV_egp12 ; + double HSMHV_egp32 ; + double HSMHV_lgate ; + double HSMHV_wg ; + double HSMHV_mueph ; + double HSMHV_mphn0 ; + double HSMHV_mphn1 ; + double HSMHV_muesr ; + double HSMHV_rdvd ; + double HSMHV_rsvd ; /* for the reverse mode */ + double HSMHV_rd23 ; + + double HSMHV_ninvd ; + double HSMHV_ninvd0 ; + + double HSMHV_nsub ; + double HSMHV_qnsub ; + double HSMHV_qnsub_esi ; + double HSMHV_2qnsub_esi ; + double HSMHV_ptovr0 ; + double HSMHV_ptovr ; + double HSMHV_vmax0 ; + double HSMHV_vmax ; + double HSMHV_pb2 ; + double HSMHV_pb20 ; + double HSMHV_pb2c ; + double HSMHV_cnst0 ; + double HSMHV_cnst1 ; + double HSMHV_isbd ; + double HSMHV_isbd2 ; + double HSMHV_isbs ; + double HSMHV_isbs2 ; + double HSMHV_vbdt ; + double HSMHV_vbst ; + double HSMHV_exptemp ; + double HSMHV_wsti ; + double HSMHV_cnstpgd ; + /* double HSMHV_ninvp0 ; not used */ + /* double HSMHV_ninv0 ; not used */ + double HSMHV_grbpb ; + double HSMHV_grbpd ; + double HSMHV_grbps ; + double HSMHV_grg ; + double HSMHV_rs ; + double HSMHV_rs0 ; + double HSMHV_rd ; + double HSMHV_rd0 ; + double HSMHV_rdtemp0 ; + double HSMHV_clmmod ; + double HSMHV_lgatesm ; + double HSMHV_dVthsm ; + double HSMHV_ddlt ; + double HSMHV_xsub1 ; + double HSMHV_xsub2 ; + double HSMHV_xgate ; + double HSMHV_xvbs ; + double HSMHV_vg2const ; + double HSMHV_wdpl ; + double HSMHV_wdplp ; + double HSMHV_cfrng ; + double HSMHV_jd_nvtm_inv ; + double HSMHV_jd_expcd ; + double HSMHV_jd_expcs ; + double HSMHV_sqrt_eg ; + + double HSMHV_egtnom ; + double HSMHV_cecox ; + double HSMHV_msc ; + int HSMHV_flg_pgd ; + double HSMHV_ndep_o_esi ; + double HSMHV_ninv_o_esi ; + double HSMHV_cqyb0 ; + double HSMHV_cnst0over ; + double HSMHV_cnst0overs ; + double HSMHV_costi00 ; + double HSMHV_nsti_p2 ; + double HSMHV_costi0 ; + double HSMHV_costi0_p2 ; + double HSMHV_costi1 ; + double HSMHV_ps0ldinib ; + double HSMHV_ps0ldinibs ; + double HSMHV_rdvdtemp0 ; + double HSMHV_rthtemp0 ; + double HSMHV_powratio ; + + HSMHVhereMKSParam hereMKS ; /* unit-converted parameters */ + + HSMHVbinningParam pParam ; /* binning parameters */ + + /* no use in SPICE3f5 + double HSMHVdrainSquares; the length of the drain in squares + double HSMHVsourceSquares; the length of the source in squares */ + double HSMHVsourceConductance; /* cond. of source (or 0): set in setup */ + double HSMHVdrainConductance; /* cond. of drain (or 0): set in setup */ + + double HSMHV_icVBS; /* initial condition B-S voltage */ + double HSMHV_icVDS; /* initial condition D-S voltage */ + double HSMHV_icVGS; /* initial condition G-S voltage */ + int HSMHV_off; /* non-zero to indicate device is off for dc analysis */ + int HSMHV_mode; /* device mode : 1 = normal, -1 = inverse */ + + unsigned HSMHV_coselfheat_Given :1; + unsigned HSMHV_cosubnode_Given :1; + unsigned HSMHV_l_Given :1; + unsigned HSMHV_w_Given :1; + unsigned HSMHV_ad_Given :1; + unsigned HSMHV_as_Given :1; + unsigned HSMHV_pd_Given :1; + unsigned HSMHV_ps_Given :1; + unsigned HSMHV_nrd_Given :1; + unsigned HSMHV_nrs_Given :1; + unsigned HSMHV_dtemp_Given :1; + unsigned HSMHV_icVBS_Given :1; + unsigned HSMHV_icVDS_Given :1; + unsigned HSMHV_icVGS_Given :1; + unsigned HSMHV_corbnet_Given :1; + unsigned HSMHV_rbpb_Given :1; + unsigned HSMHV_rbpd_Given :1; + unsigned HSMHV_rbps_Given :1; + unsigned HSMHV_rbdb_Given :1; + unsigned HSMHV_rbsb_Given :1; + unsigned HSMHV_corg_Given :1; + unsigned HSMHV_ngcon_Given :1; + unsigned HSMHV_xgw_Given :1; + unsigned HSMHV_xgl_Given :1; + unsigned HSMHV_nf_Given :1; + unsigned HSMHV_sa_Given :1; + unsigned HSMHV_sb_Given :1; + unsigned HSMHV_sd_Given :1; + unsigned HSMHV_nsubcdfm_Given :1; + unsigned HSMHV_m_Given :1; + unsigned HSMHV_subld1_Given :1; + unsigned HSMHV_subld2_Given :1; + unsigned HSMHV_lover_Given :1; + unsigned HSMHV_lovers_Given :1; + unsigned HSMHV_loverld_Given :1; + unsigned HSMHV_ldrift1_Given :1; + unsigned HSMHV_ldrift2_Given :1; + unsigned HSMHV_ldrift1s_Given :1; + unsigned HSMHV_ldrift2s_Given :1; + + /* unsigned HSMHV_rth0_Given :1; not used */ + /* unsigned HSMHV_cth0_Given :1; not used */ + + + + /* pointers to sparse matrix */ + + double *HSMHVGgPtr; /* pointer to sparse matrix element at (gate node,gate node) */ + double *HSMHVGgpPtr; /* pointer to sparse matrix element at (gate node,gate prime node) */ + /* double *HSMHVGdpPtr; not used */ + /* double *HSMHVGspPtr; not used */ + /* double *HSMHVGbpPtr; not used */ + + double *HSMHVGPgPtr; /* pointer to sparse matrix element at (gate prime node,gate node) */ + double *HSMHVGPgpPtr; /* pointer to sparse matrix element at (gate prime node,gate prime node) */ + double *HSMHVGPdpPtr; /* pointer to sparse matrix element at (gate prime node,drain prime node) */ + double *HSMHVGPspPtr; /* pointer to sparse matrix element at (gate prime node,source prime node) */ + double *HSMHVGPbpPtr; /* pointer to sparse matrix element at (gate prime node,bulk prime node) */ + + double *HSMHVDPdPtr; /* pointer to sparse matrix element at (drain prime node,drain node) */ + double *HSMHVDPdpPtr; /* pointer to sparse matrix element at (drain prime node,drain prime node) */ + double *HSMHVDPgpPtr; /* pointer to sparse matrix element at (drain prime node,gate prime node) */ + double *HSMHVDPspPtr; /* pointer to sparse matrix element at (drain prime node,source prime node) */ + double *HSMHVDPbpPtr; /* pointer to sparse matrix element at (drain prime node,bulk prime node) */ + + double *HSMHVDdPtr; /* pointer to sparse matrix element at (Drain node,drain node) */ + double *HSMHVDdpPtr; /* pointer to sparse matrix element at (drain node,drain prime node) */ + double *HSMHVDdbPtr; /* pointer to sparse matrix element at (drain node,drain body node) */ + + double *HSMHVSPsPtr; /* pointer to sparse matrix element at (source prime node,source node) */ + double *HSMHVSPspPtr; /* pointer to sparse matrix element at (source prime node,source prime node) */ + double *HSMHVSPgpPtr; /* pointer to sparse matrix element at (source prime node,gate prime node) */ + double *HSMHVSPdpPtr; /* pointer to sparse matrix element at (source prime node,drain prime node) */ + double *HSMHVSPbpPtr; /* pointer to sparse matrix element at (source prime node,bulk prime node) */ + + double *HSMHVSsPtr; /* pointer to sparse matrix element at (source node,source node) */ + double *HSMHVSspPtr; /* pointer to sparse matrix element at (source node,source prime node) */ + double *HSMHVSsbPtr; /* pointer to sparse matrix element at (source node,source body node) */ + + double *HSMHVBPgpPtr; /* pointer to sparse matrix element at (bulk prime node,gate prime node) */ + double *HSMHVBPbpPtr; /* pointer to sparse matrix element at (bulk prime node,bulk prime node) */ + double *HSMHVBPdPtr; /* pointer to sparse matrix element at (bulk prime node,drain node) */ + double *HSMHVBPdpPtr; /* pointer to sparse matrix element at (bulk prime node,drain prime node) */ + double *HSMHVBPspPtr; /* pointer to sparse matrix element at (bulk prime node,source prime node) */ + double *HSMHVBPbPtr; /* pointer to sparse matrix element at (bulk prime node,bulk node) */ + double *HSMHVBPdbPtr; /* pointer to sparse matrix element at (bulk prime node,source body node) */ + double *HSMHVBPsbPtr; /* pointer to sparse matrix element at (bulk prime node,source body node) */ + + double *HSMHVDBdPtr; /* pointer to sparse matrix element at (drain body node,drain node) */ + double *HSMHVDBdbPtr; /* pointer to sparse matrix element at (drain body node,drain body node) */ + double *HSMHVDBbpPtr; /* pointer to sparse matrix element at (drain body node,bulk prime node) */ + /* double *HSMHVDBbPtr; not used */ + + double *HSMHVSBsPtr; /* pointer to sparse matrix element at (source body node,source node) */ + double *HSMHVSBbpPtr; /* pointer to sparse matrix element at (source body node,bulk prime node) */ + /* double *HSMHVSBbPtr; not used */ + double *HSMHVSBsbPtr; /* pointer to sparse matrix element at (source body node,source body node) */ + + /* double *HSMHVBsbPtr; not used */ + double *HSMHVBbpPtr; /* pointer to sparse matrix element at (bulk node,bulk prime node) */ + /* double *HSMHVBdbPtr; not used */ + double *HSMHVBbPtr; /* pointer to sparse matrix element at (bulk node,bulk node) */ + + double *HSMHVTemptempPtr; /* pointer to sparse matrix element at (temp node, temp node) */ + double *HSMHVTempdPtr; /* pointer to sparse matrix element at (temp node, drain node) */ + double *HSMHVTempdpPtr; /* pointer to sparse matrix element at (temp node, drain prime node) */ + double *HSMHVTempsPtr; /* pointer to sparse matrix element at (temp node, source node) */ + double *HSMHVTempspPtr; /* pointer to sparse matrix element at (temp node, source prime node) */ + /* double *HSMHVTempgPtr; not used */ + double *HSMHVTempgpPtr; /* pointer to sparse matrix element at (temp node, gate prime node) */ + /* double *HSMHVTempbPtr; not used */ + double *HSMHVTempbpPtr; /* pointer to sparse matrix element at (temp node, bulk prime node) */ + /* double *HSMHVGtempPtr; not used */ + double *HSMHVGPtempPtr; /* pointer to sparse matrix element at (gate prime node, temp node) */ + double *HSMHVDPtempPtr; /* pointer to sparse matrix element at (drain prime node, temp node) */ + double *HSMHVSPtempPtr; /* pointer to sparse matrix element at (source prime node, temp node) */ + /* double *HSMHVBtempPtr; not used */ + double *HSMHVBPtempPtr; /* pointer to sparse matrix element at (bulk prime node, temp node) */ + double *HSMHVDBtempPtr; /* pointer to sparse matrix element at (drain bulk node, temp node) */ + double *HSMHVSBtempPtr; /* pointer to sparse matrix element at (source bulk node, temp node) */ + + double *HSMHVDgpPtr; /* pointer to sparse matrix element at (drain node, gate prime node) */ + double *HSMHVDsPtr; /* pointer to sparse matrix element at (drain node, source node) */ + double *HSMHVDbpPtr; /* pointer to sparse matrix element at (drain node, bulk prime node) */ + double *HSMHVDtempPtr; /* pointer to sparse matrix element at (drain node, temp node) */ + double *HSMHVDPsPtr; /* pointer to sparse matrix element at (drain prime node, source node) */ + double *HSMHVGPdPtr; /* pointer to sparse matrix element at (gate prime node, drain node) */ + double *HSMHVGPsPtr; /* pointer to sparse matrix element at (gate prime node, source node) */ + double *HSMHVSdPtr; /* pointer to sparse matrix element at (source node, drain node) */ + double *HSMHVSgpPtr; /* pointer to sparse matrix element at (source node, gate prime node) */ + double *HSMHVSbpPtr; /* pointer to sparse matrix element at (source node, bulk prime node) */ + double *HSMHVStempPtr; /* pointer to sparse matrix element at (source node, temp node) */ + double *HSMHVSPdPtr; /* pointer to sparse matrix element at (source prime node, drain node) */ + + /* nqs related pointers */ + double *HSMHVDPqiPtr; /* pointer to sparse matrix element at (drain prime node, qi_nqs node) */ + double *HSMHVGPqiPtr; /* pointer to sparse matrix element at (gate prime node, qi_nqs node) */ + double *HSMHVGPqbPtr; /* pointer to sparse matrix element at (gate prime node, qb_nqs node) */ + double *HSMHVSPqiPtr; /* pointer to sparse matrix element at (source prime node, qi_nqs node) */ + double *HSMHVBPqbPtr; /* pointer to sparse matrix element at (bulk prime node, qb_nqs node) */ + double *HSMHVQIdpPtr; /* pointer to sparse matrix element at (qi_nqs node, drain prime node) */ + double *HSMHVQIgpPtr; /* pointer to sparse matrix element at (qi_nqs node, gate prime node) */ + double *HSMHVQIspPtr; /* pointer to sparse matrix element at (qi_nqs node, source prime node) */ + double *HSMHVQIbpPtr; /* pointer to sparse matrix element at (qi_nqs node, bulk prime node) */ + double *HSMHVQIqiPtr; /* pointer to sparse matrix element at (qi_nqs node, qi_nqs node) */ + double *HSMHVQBdpPtr; /* pointer to sparse matrix element at (qb_nqs node, drain prime node) */ + double *HSMHVQBgpPtr; /* pointer to sparse matrix element at (qb_nqs node, gate prime node) */ + double *HSMHVQBspPtr; /* pointer to sparse matrix element at (qb_nqs node, source prime node) */ + double *HSMHVQBbpPtr; /* pointer to sparse matrix element at (qb_nqs node, bulk prime node) */ + double *HSMHVQBqbPtr; /* pointer to sparse matrix element at (qb_nqs node, qb_nqs node) */ + double *HSMHVQItempPtr; /* pointer to sparse matrix element at (qi_nqs node, temp node) */ + double *HSMHVQBtempPtr; /* pointer to sparse matrix element at (qb_nqs node, temp node) */ + + /* Substrate effect related pointers */ + double *HSMHVDsubPtr; /* pointer to sparse matrix element at (drain node, substrate node) */ + double *HSMHVDPsubPtr; /* pointer to sparse matrix element at (drain prime node, substrate node) */ + double *HSMHVSsubPtr; /* pointer to sparse matrix element at (source node, substrate node) */ + double *HSMHVSPsubPtr; /* pointer to sparse matrix element at (source prime node, substrate node) */ + + + /* common state values in hisim module */ +#define HSMHVvbd HSMHVstates+ 0 +#define HSMHVvbs HSMHVstates+ 1 +#define HSMHVvgs HSMHVstates+ 2 +#define HSMHVvds HSMHVstates+ 3 +#define HSMHVvdbs HSMHVstates+ 4 +#define HSMHVvdbd HSMHVstates+ 5 +#define HSMHVvsbs HSMHVstates+ 6 +#define HSMHVvges HSMHVstates+ 7 +#define HSMHVvsubs HSMHVstates+ 8 /* substrate bias */ +#define HSMHVdeltemp HSMHVstates+ 9 +#define HSMHVvdse HSMHVstates+ 10 +#define HSMHVvgse HSMHVstates+ 11 +#define HSMHVvbse HSMHVstates+ 12 + +#define HSMHVqb HSMHVstates+ 13 +#define HSMHVcqb HSMHVstates+ 14 +#define HSMHVqg HSMHVstates+ 15 +#define HSMHVcqg HSMHVstates+ 16 +#define HSMHVqd HSMHVstates+ 17 +#define HSMHVcqd HSMHVstates+ 18 + +#define HSMHVqbs HSMHVstates+ 19 +#define HSMHVcqbs HSMHVstates+ 20 +#define HSMHVqbd HSMHVstates+ 21 +#define HSMHVcqbd HSMHVstates+ 22 + +#define HSMHVqth HSMHVstates+ 23 +#define HSMHVcqth HSMHVstates+ 24 + +/*add fringing capacitance*/ +#define HSMHVqfd HSMHVstates+ 25 +#define HSMHVcqfd HSMHVstates+ 26 +#define HSMHVqfs HSMHVstates+ 27 +#define HSMHVcqfs HSMHVstates+ 28 + +#define HSMHVnumStates 29 + +/* nqs charges */ +#define HSMHVqi_nqs HSMHVstates+ 30 +#define HSMHVdotqi_nqs HSMHVstates + 31 +#define HSMHVqb_nqs HSMHVstates+ 32 +#define HSMHVdotqb_nqs HSMHVstates + 33 + +#define HSMHVnumStatesNqs 34 + +/* indices to the array of HiSIMHV NOISE SOURCES */ +#define HSMHVRDNOIZ 0 +#define HSMHVRSNOIZ 1 +#define HSMHVIDNOIZ 2 +#define HSMHVFLNOIZ 3 +#define HSMHVIGNOIZ 4 +#define HSMHVTOTNOIZ 5 + +#define HSMHVNSRCS 6 /* the number of HiSIMHV MOSFET noise sources */ + +#ifndef NONOISE + double HSMHVnVar[NSTATVARS][HSMHVNSRCS]; +#else /* NONOISE */ + double **HSMHVnVar; +#endif /* NONOISE */ + +} HSMHVinstance ; + + +/* per model data */ + +typedef struct sHSMHVmodel { /* model structure for a resistor */ + int HSMHVmodType; /* type index of this device type */ + struct sHSMHVmodel *HSMHVnextModel; /* pointer to next possible model + in linked list */ + HSMHVinstance * HSMHVinstances; /* pointer to list of instances + that have this model */ + IFuid HSMHVmodName; /* pointer to the name of this model */ + int HSMHV_type; /* device type: 1 = nmos, -1 = pmos */ + int HSMHV_level; /* level */ + int HSMHV_info; /* information */ + int HSMHV_noise; /* noise model selecter see hsmhvnoi.c */ + char *HSMHV_version; /* model version */ + int HSMHV_show; /* show physical value 1, 2, ... , 11 */ + + + int HSMHV_corsrd ; + int HSMHV_corg ; + int HSMHV_coiprv ; + int HSMHV_copprv ; + int HSMHV_coadov ; + int HSMHV_coisub ; + int HSMHV_coiigs ; + int HSMHV_cogidl ; + int HSMHV_coovlp ; + int HSMHV_coovlps ; + int HSMHV_coflick ; + int HSMHV_coisti ; + int HSMHV_conqs ; + int HSMHV_corbnet ; + int HSMHV_cothrml; + int HSMHV_coign; /* Induced gate noise */ + int HSMHV_codfm; /* DFM */ + int HSMHV_coqovsm ; + int HSMHV_coselfheat; /* Self-heating model */ + int HSMHV_cosubnode; /* switch tempNode to subNode */ + int HSMHV_cosym; /* Symmetry model for HV */ + int HSMHV_cotemp; + int HSMHV_coldrift; + + + double HSMHV_vmax ; + double HSMHV_vmaxt1 ; + double HSMHV_vmaxt2 ; + double HSMHV_bgtmp1 ; + double HSMHV_bgtmp2 ; + double HSMHV_eg0 ; + double HSMHV_tox ; + double HSMHV_xld ; + double HSMHV_xldld ; + double HSMHV_xwdld ; + double HSMHV_lover ; + double HSMHV_lovers ; + double HSMHV_rdov11 ; + double HSMHV_rdov12 ; + double HSMHV_rdov13 ; + double HSMHV_rdslp1 ; + double HSMHV_rdict1 ; + double HSMHV_rdslp2 ; + double HSMHV_rdict2 ; + double HSMHV_loverld ; + double HSMHV_ldrift1 ; + double HSMHV_ldrift2 ; + double HSMHV_ldrift1s ; + double HSMHV_ldrift2s ; + double HSMHV_subld1 ; + double HSMHV_subld2 ; + double HSMHV_ddltmax ; + double HSMHV_ddltslp ; + double HSMHV_ddltict ; + double HSMHV_vfbover ; + double HSMHV_nover ; + double HSMHV_novers ; + double HSMHV_xwd ; + double HSMHV_xwdc ; + double HSMHV_xl ; + double HSMHV_xw ; + double HSMHV_saref ; + double HSMHV_sbref ; + double HSMHV_ll ; + double HSMHV_lld ; + double HSMHV_lln ; + double HSMHV_wl ; + double HSMHV_wl1 ; + double HSMHV_wl1p ; + double HSMHV_wl2 ; + double HSMHV_wl2p ; + double HSMHV_wld ; + double HSMHV_wln ; + double HSMHV_xqy ; + double HSMHV_xqy1 ; + double HSMHV_xqy2 ; + double HSMHV_rs; /* source contact resistance */ + double HSMHV_rd; /* drain contact resistance */ + double HSMHV_rsh; /* source/drain diffusion sheet resistance */ + double HSMHV_rshg; +/* double HSMHV_ngcon; */ +/* double HSMHV_xgw; */ +/* double HSMHV_xgl; */ +/* double HSMHV_nf; */ + double HSMHV_vfbc ; + double HSMHV_vbi ; + double HSMHV_nsubc ; + double HSMHV_qdftvd ; + double HSMHV_parl2 ; + double HSMHV_lp ; + double HSMHV_nsubp ; + double HSMHV_nsubp0 ; + double HSMHV_nsubwp ; + double HSMHV_scp1 ; + double HSMHV_scp2 ; + double HSMHV_scp3 ; + double HSMHV_sc1 ; + double HSMHV_sc2 ; + double HSMHV_sc3 ; + double HSMHV_sc4 ; + double HSMHV_pgd1 ; + double HSMHV_pgd2 ; + double HSMHV_pgd3 ; + double HSMHV_pgd4 ; + double HSMHV_ndep ; + double HSMHV_ndepl ; + double HSMHV_ndeplp ; + double HSMHV_ninv ; + double HSMHV_ninvd ; + double HSMHV_ninvdw ; + double HSMHV_ninvdwp ; + double HSMHV_ninvdt1 ; + double HSMHV_ninvdt2 ; + double HSMHV_muecb0 ; + double HSMHV_muecb1 ; + double HSMHV_mueph1 ; + double HSMHV_mueph0 ; + double HSMHV_muephw ; + double HSMHV_muepwp ; + double HSMHV_muephl ; + double HSMHV_mueplp ; + double HSMHV_muephs ; + double HSMHV_muepsp ; + double HSMHV_vtmp ; + double HSMHV_wvth0 ; + double HSMHV_muesr1 ; + double HSMHV_muesr0 ; + double HSMHV_muesrw ; + double HSMHV_mueswp ; + double HSMHV_muesrl ; + double HSMHV_mueslp ; + double HSMHV_bb ; + double HSMHV_sub1 ; + double HSMHV_sub2 ; + double HSMHV_svgs ; + double HSMHV_svbs ; + double HSMHV_svbsl ; + double HSMHV_svds ; + double HSMHV_slg ; + double HSMHV_sub1l ; + double HSMHV_sub2l ; + double HSMHV_fn1 ; + double HSMHV_fn2 ; + double HSMHV_fn3 ; + double HSMHV_fvbs ; + double HSMHV_svgsl ; + double HSMHV_svgslp ; + double HSMHV_svgswp ; + double HSMHV_svgsw ; + double HSMHV_svbslp ; + double HSMHV_slgl ; + double HSMHV_slglp ; + double HSMHV_sub1lp ; + double HSMHV_nsti ; + double HSMHV_wsti ; + double HSMHV_wstil ; + double HSMHV_wstilp ; + double HSMHV_wstiw ; + double HSMHV_wstiwp ; + double HSMHV_scsti1 ; + double HSMHV_scsti2 ; + double HSMHV_vthsti ; + double HSMHV_vdsti ; + double HSMHV_muesti1 ; + double HSMHV_muesti2 ; + double HSMHV_muesti3 ; + double HSMHV_nsubpsti1 ; + double HSMHV_nsubpsti2 ; + double HSMHV_nsubpsti3 ; + double HSMHV_lpext ; + double HSMHV_npext ; + double HSMHV_scp22 ; + double HSMHV_scp21 ; + double HSMHV_bs1 ; + double HSMHV_bs2 ; + double HSMHV_cgso ; + double HSMHV_cgdo ; + double HSMHV_cgbo ; + double HSMHV_tpoly ; + double HSMHV_js0 ; + double HSMHV_js0sw ; + double HSMHV_nj ; + double HSMHV_njsw ; + double HSMHV_xti ; + double HSMHV_cj ; + double HSMHV_cjsw ; + double HSMHV_cjswg ; + double HSMHV_mj ; + double HSMHV_mjsw ; + double HSMHV_mjswg ; + double HSMHV_xti2 ; + double HSMHV_cisb ; + double HSMHV_cvb ; + double HSMHV_ctemp ; + double HSMHV_cisbk ; + double HSMHV_cvbk ; + double HSMHV_divx ; + double HSMHV_pb ; + double HSMHV_pbsw ; + double HSMHV_pbswg ; + double HSMHV_clm1 ; + double HSMHV_clm2 ; + double HSMHV_clm3 ; + double HSMHV_clm5 ; + double HSMHV_clm6 ; + double HSMHV_muetmp ; + double HSMHV_vover ; + double HSMHV_voverp ; + double HSMHV_vovers ; + double HSMHV_voversp ; + double HSMHV_wfc ; + double HSMHV_nsubcw ; + double HSMHV_nsubcwp ; + double HSMHV_qme1 ; + double HSMHV_qme2 ; + double HSMHV_qme3 ; + double HSMHV_gidl1 ; + double HSMHV_gidl2 ; + double HSMHV_gidl3 ; + double HSMHV_gidl4 ; + double HSMHV_gidl5 ; + double HSMHV_gleak1 ; + double HSMHV_gleak2 ; + double HSMHV_gleak3 ; + double HSMHV_gleak4 ; + double HSMHV_gleak5 ; + double HSMHV_gleak6 ; + double HSMHV_gleak7 ; + double HSMHV_glpart1 ; + double HSMHV_glksd1 ; + double HSMHV_glksd2 ; + double HSMHV_glksd3 ; + double HSMHV_glkb1 ; + double HSMHV_glkb2 ; + double HSMHV_glkb3 ; + double HSMHV_egig; + double HSMHV_igtemp2; + double HSMHV_igtemp3; + double HSMHV_vzadd0 ; + double HSMHV_pzadd0 ; + double HSMHV_nftrp ; + double HSMHV_nfalp ; + double HSMHV_cit ; + double HSMHV_falph ; + double HSMHV_kappa ; + double HSMHV_pthrou ; + double HSMHV_vdiffj ; + double HSMHV_dly1 ; + double HSMHV_dly2 ; + double HSMHV_dly3 ; + double HSMHV_dlyov; + double HSMHV_tnom ; + double HSMHV_ovslp ; + double HSMHV_ovmag ; + /* substrate resistances */ + double HSMHV_gbmin; + double HSMHV_rbpb ; + double HSMHV_rbpd ; + double HSMHV_rbps ; + double HSMHV_rbdb ; + double HSMHV_rbsb ; + /* IBPC */ + double HSMHV_ibpc1 ; + double HSMHV_ibpc2 ; + /* DFM */ + double HSMHV_mphdfm ; + + double HSMHV_vbsmin ; + double HSMHV_rdvg11 ; + double HSMHV_rdvg12 ; + double HSMHV_rd20 ; + double HSMHV_qovsm ; + double HSMHV_ldrift ; + double HSMHV_rd21 ; + double HSMHV_rd22 ; + double HSMHV_rd22d ; + double HSMHV_rd23 ; + double HSMHV_rd24 ; + double HSMHV_rd25 ; + double HSMHV_rd26 ; + double HSMHV_rdvdl ; + double HSMHV_rdvdlp ; + double HSMHV_rdvds ; + double HSMHV_rdvdsp ; + double HSMHV_rd23l ; + double HSMHV_rd23lp ; + double HSMHV_rd23s ; + double HSMHV_rd23sp ; + double HSMHV_rds ; + double HSMHV_rdsp ; + + double HSMHV_rdvd ; + double HSMHV_rdvb ; + + double HSMHV_rdvsub ; /* substrate effect */ + double HSMHV_rdvdsub ; /* substrate effect */ + double HSMHV_ddrift ; /* substrate effect */ + double HSMHV_vbisub ; /* substrate effect */ + double HSMHV_nsubsub ; /* substrate effect */ + + double HSMHV_rth0 ; + double HSMHV_cth0 ; + double HSMHV_powrat ; + + double HSMHV_tcjbd ; + double HSMHV_tcjbs ; + double HSMHV_tcjbdsw ; + double HSMHV_tcjbssw ; + double HSMHV_tcjbdswg ; + double HSMHV_tcjbsswg ; + + + double HSMHV_rdtemp1 ; + double HSMHV_rdtemp2 ; + double HSMHV_rth0r ; /* heat radiation for SHE */ + double HSMHV_rdvdtemp1 ; + double HSMHV_rdvdtemp2 ; + double HSMHV_rth0w ; + double HSMHV_rth0wp ; + double HSMHV_rth0nf ; + + double HSMHV_rthtemp1 ; + double HSMHV_rthtemp2 ; + double HSMHV_prattemp1 ; + double HSMHV_prattemp2 ; + + + double HSMHV_cvdsover ; + double HSMHV_shemax; + + /* binning parameters */ + double HSMHV_lmin ; + double HSMHV_lmax ; + double HSMHV_wmin ; + double HSMHV_wmax ; + double HSMHV_lbinn ; + double HSMHV_wbinn ; + + /* Length dependence */ + double HSMHV_lvmax ; + double HSMHV_lbgtmp1 ; + double HSMHV_lbgtmp2 ; + double HSMHV_leg0 ; + double HSMHV_lvfbover ; + double HSMHV_lnover ; + double HSMHV_lnovers ; + double HSMHV_lwl2 ; + double HSMHV_lvfbc ; + double HSMHV_lnsubc ; + double HSMHV_lnsubp ; + double HSMHV_lscp1 ; + double HSMHV_lscp2 ; + double HSMHV_lscp3 ; + double HSMHV_lsc1 ; + double HSMHV_lsc2 ; + double HSMHV_lsc3 ; + double HSMHV_lpgd1 ; + double HSMHV_lpgd3 ; + double HSMHV_lndep ; + double HSMHV_lninv ; + double HSMHV_lmuecb0 ; + double HSMHV_lmuecb1 ; + double HSMHV_lmueph1 ; + double HSMHV_lvtmp ; + double HSMHV_lwvth0 ; + double HSMHV_lmuesr1 ; + double HSMHV_lmuetmp ; + double HSMHV_lsub1 ; + double HSMHV_lsub2 ; + double HSMHV_lsvds ; + double HSMHV_lsvbs ; + double HSMHV_lsvgs ; + double HSMHV_lfn1 ; + double HSMHV_lfn2 ; + double HSMHV_lfn3 ; + double HSMHV_lfvbs ; + double HSMHV_lnsti ; + double HSMHV_lwsti ; + double HSMHV_lscsti1 ; + double HSMHV_lscsti2 ; + double HSMHV_lvthsti ; + double HSMHV_lmuesti1 ; + double HSMHV_lmuesti2 ; + double HSMHV_lmuesti3 ; + double HSMHV_lnsubpsti1 ; + double HSMHV_lnsubpsti2 ; + double HSMHV_lnsubpsti3 ; + double HSMHV_lcgso ; + double HSMHV_lcgdo ; + double HSMHV_ljs0 ; + double HSMHV_ljs0sw ; + double HSMHV_lnj ; + double HSMHV_lcisbk ; + double HSMHV_lclm1 ; + double HSMHV_lclm2 ; + double HSMHV_lclm3 ; + double HSMHV_lwfc ; + double HSMHV_lgidl1 ; + double HSMHV_lgidl2 ; + double HSMHV_lgleak1 ; + double HSMHV_lgleak2 ; + double HSMHV_lgleak3 ; + double HSMHV_lgleak6 ; + double HSMHV_lglksd1 ; + double HSMHV_lglksd2 ; + double HSMHV_lglkb1 ; + double HSMHV_lglkb2 ; + double HSMHV_lnftrp ; + double HSMHV_lnfalp ; + double HSMHV_lpthrou ; + double HSMHV_lvdiffj ; + double HSMHV_libpc1 ; + double HSMHV_libpc2 ; + double HSMHV_lcgbo ; + double HSMHV_lcvdsover ; + double HSMHV_lfalph ; + double HSMHV_lnpext ; + double HSMHV_lpowrat ; + double HSMHV_lrd ; + double HSMHV_lrd22 ; + double HSMHV_lrd23 ; + double HSMHV_lrd24 ; + double HSMHV_lrdict1 ; + double HSMHV_lrdov13 ; + double HSMHV_lrdslp1 ; + double HSMHV_lrdvb ; + double HSMHV_lrdvd ; + double HSMHV_lrdvg11 ; + double HSMHV_lrs ; + double HSMHV_lrth0 ; + double HSMHV_lvover ; + + /* Width dependence */ + double HSMHV_wvmax ; + double HSMHV_wbgtmp1 ; + double HSMHV_wbgtmp2 ; + double HSMHV_weg0 ; + double HSMHV_wvfbover ; + double HSMHV_wnover ; + double HSMHV_wnovers ; + double HSMHV_wwl2 ; + double HSMHV_wvfbc ; + double HSMHV_wnsubc ; + double HSMHV_wnsubp ; + double HSMHV_wscp1 ; + double HSMHV_wscp2 ; + double HSMHV_wscp3 ; + double HSMHV_wsc1 ; + double HSMHV_wsc2 ; + double HSMHV_wsc3 ; + double HSMHV_wpgd1 ; + double HSMHV_wpgd3 ; + double HSMHV_wndep ; + double HSMHV_wninv ; + double HSMHV_wmuecb0 ; + double HSMHV_wmuecb1 ; + double HSMHV_wmueph1 ; + double HSMHV_wvtmp ; + double HSMHV_wwvth0 ; + double HSMHV_wmuesr1 ; + double HSMHV_wmuetmp ; + double HSMHV_wsub1 ; + double HSMHV_wsub2 ; + double HSMHV_wsvds ; + double HSMHV_wsvbs ; + double HSMHV_wsvgs ; + double HSMHV_wfn1 ; + double HSMHV_wfn2 ; + double HSMHV_wfn3 ; + double HSMHV_wfvbs ; + double HSMHV_wnsti ; + double HSMHV_wwsti ; + double HSMHV_wscsti1 ; + double HSMHV_wscsti2 ; + double HSMHV_wvthsti ; + double HSMHV_wmuesti1 ; + double HSMHV_wmuesti2 ; + double HSMHV_wmuesti3 ; + double HSMHV_wnsubpsti1 ; + double HSMHV_wnsubpsti2 ; + double HSMHV_wnsubpsti3 ; + double HSMHV_wcgso ; + double HSMHV_wcgdo ; + double HSMHV_wjs0 ; + double HSMHV_wjs0sw ; + double HSMHV_wnj ; + double HSMHV_wcisbk ; + double HSMHV_wclm1 ; + double HSMHV_wclm2 ; + double HSMHV_wclm3 ; + double HSMHV_wwfc ; + double HSMHV_wgidl1 ; + double HSMHV_wgidl2 ; + double HSMHV_wgleak1 ; + double HSMHV_wgleak2 ; + double HSMHV_wgleak3 ; + double HSMHV_wgleak6 ; + double HSMHV_wglksd1 ; + double HSMHV_wglksd2 ; + double HSMHV_wglkb1 ; + double HSMHV_wglkb2 ; + double HSMHV_wnftrp ; + double HSMHV_wnfalp ; + double HSMHV_wpthrou ; + double HSMHV_wvdiffj ; + double HSMHV_wibpc1 ; + double HSMHV_wibpc2 ; + double HSMHV_wcgbo ; + double HSMHV_wcvdsover ; + double HSMHV_wfalph ; + double HSMHV_wnpext ; + double HSMHV_wpowrat ; + double HSMHV_wrd ; + double HSMHV_wrd22 ; + double HSMHV_wrd23 ; + double HSMHV_wrd24 ; + double HSMHV_wrdict1 ; + double HSMHV_wrdov13 ; + double HSMHV_wrdslp1 ; + double HSMHV_wrdvb ; + double HSMHV_wrdvd ; + double HSMHV_wrdvg11 ; + double HSMHV_wrs ; + double HSMHV_wrth0 ; + double HSMHV_wvover ; + + /* Cross-term dependence */ + double HSMHV_pvmax ; + double HSMHV_pbgtmp1 ; + double HSMHV_pbgtmp2 ; + double HSMHV_peg0 ; + double HSMHV_pvfbover ; + double HSMHV_pnover ; + double HSMHV_pnovers ; + double HSMHV_pwl2 ; + double HSMHV_pvfbc ; + double HSMHV_pnsubc ; + double HSMHV_pnsubp ; + double HSMHV_pscp1 ; + double HSMHV_pscp2 ; + double HSMHV_pscp3 ; + double HSMHV_psc1 ; + double HSMHV_psc2 ; + double HSMHV_psc3 ; + double HSMHV_ppgd1 ; + double HSMHV_ppgd3 ; + double HSMHV_pndep ; + double HSMHV_pninv ; + double HSMHV_pmuecb0 ; + double HSMHV_pmuecb1 ; + double HSMHV_pmueph1 ; + double HSMHV_pvtmp ; + double HSMHV_pwvth0 ; + double HSMHV_pmuesr1 ; + double HSMHV_pmuetmp ; + double HSMHV_psub1 ; + double HSMHV_psub2 ; + double HSMHV_psvds ; + double HSMHV_psvbs ; + double HSMHV_psvgs ; + double HSMHV_pfn1 ; + double HSMHV_pfn2 ; + double HSMHV_pfn3 ; + double HSMHV_pfvbs ; + double HSMHV_pnsti ; + double HSMHV_pwsti ; + double HSMHV_pscsti1 ; + double HSMHV_pscsti2 ; + double HSMHV_pvthsti ; + double HSMHV_pmuesti1 ; + double HSMHV_pmuesti2 ; + double HSMHV_pmuesti3 ; + double HSMHV_pnsubpsti1 ; + double HSMHV_pnsubpsti2 ; + double HSMHV_pnsubpsti3 ; + double HSMHV_pcgso ; + double HSMHV_pcgdo ; + double HSMHV_pjs0 ; + double HSMHV_pjs0sw ; + double HSMHV_pnj ; + double HSMHV_pcisbk ; + double HSMHV_pclm1 ; + double HSMHV_pclm2 ; + double HSMHV_pclm3 ; + double HSMHV_pwfc ; + double HSMHV_pgidl1 ; + double HSMHV_pgidl2 ; + double HSMHV_pgleak1 ; + double HSMHV_pgleak2 ; + double HSMHV_pgleak3 ; + double HSMHV_pgleak6 ; + double HSMHV_pglksd1 ; + double HSMHV_pglksd2 ; + double HSMHV_pglkb1 ; + double HSMHV_pglkb2 ; + double HSMHV_pnftrp ; + double HSMHV_pnfalp ; + double HSMHV_ppthrou ; + double HSMHV_pvdiffj ; + double HSMHV_pibpc1 ; + double HSMHV_pibpc2 ; + double HSMHV_pcgbo ; + double HSMHV_pcvdsover ; + double HSMHV_pfalph ; + double HSMHV_pnpext ; + double HSMHV_ppowrat ; + double HSMHV_prd ; + double HSMHV_prd22 ; + double HSMHV_prd23 ; + double HSMHV_prd24 ; + double HSMHV_prdict1 ; + double HSMHV_prdov13 ; + double HSMHV_prdslp1 ; + double HSMHV_prdvb ; + double HSMHV_prdvd ; + double HSMHV_prdvg11 ; + double HSMHV_prs ; + double HSMHV_prth0 ; + double HSMHV_pvover ; + + /* internal variables */ + double HSMHV_vcrit ; + int HSMHV_flg_qme ; + double HSMHV_qme12 ; + double HSMHV_ktnom ; + + HSMHVmodelMKSParam modelMKS ; /* unit-converted parameters */ + + + /* flag for model */ + unsigned HSMHV_type_Given :1; + unsigned HSMHV_level_Given :1; + unsigned HSMHV_info_Given :1; + unsigned HSMHV_noise_Given :1; + unsigned HSMHV_version_Given :1; + unsigned HSMHV_show_Given :1; + unsigned HSMHV_corsrd_Given :1; + unsigned HSMHV_corg_Given :1; + unsigned HSMHV_coiprv_Given :1; + unsigned HSMHV_copprv_Given :1; + unsigned HSMHV_coadov_Given :1; + unsigned HSMHV_coisub_Given :1; + unsigned HSMHV_coiigs_Given :1; + unsigned HSMHV_cogidl_Given :1; + unsigned HSMHV_coovlp_Given :1; + unsigned HSMHV_coovlps_Given :1; + unsigned HSMHV_coflick_Given :1; + unsigned HSMHV_coisti_Given :1; + unsigned HSMHV_conqs_Given :1; + unsigned HSMHV_corbnet_Given :1; + unsigned HSMHV_cothrml_Given :1; + unsigned HSMHV_coign_Given :1; /* Induced gate noise */ + unsigned HSMHV_codfm_Given :1; /* DFM */ + unsigned HSMHV_coqovsm_Given :1; + unsigned HSMHV_coselfheat_Given :1; /* Self-heating model */ + unsigned HSMHV_cosubnode_Given :1; /* switch tempNode to subNode */ + unsigned HSMHV_cosym_Given :1; /* Symmetry model for HV */ + unsigned HSMHV_cotemp_Given :1; + unsigned HSMHV_coldrift_Given :1; + unsigned HSMHV_kappa_Given :1; + unsigned HSMHV_pthrou_Given :1; + unsigned HSMHV_vdiffj_Given :1; + unsigned HSMHV_vmax_Given :1; + unsigned HSMHV_vmaxt1_Given :1; + unsigned HSMHV_vmaxt2_Given :1; + unsigned HSMHV_bgtmp1_Given :1; + unsigned HSMHV_bgtmp2_Given :1; + unsigned HSMHV_eg0_Given :1; + unsigned HSMHV_tox_Given :1; + unsigned HSMHV_xld_Given :1; + unsigned HSMHV_xldld_Given :1; + unsigned HSMHV_xwdld_Given :1; + unsigned HSMHV_lover_Given :1; + unsigned HSMHV_lovers_Given :1; + unsigned HSMHV_rdov11_Given :1; + unsigned HSMHV_rdov12_Given :1; + unsigned HSMHV_rdov13_Given :1; + unsigned HSMHV_rdslp1_Given :1; + unsigned HSMHV_rdict1_Given :1; + unsigned HSMHV_rdslp2_Given :1; + unsigned HSMHV_rdict2_Given :1; + unsigned HSMHV_loverld_Given :1; + unsigned HSMHV_ldrift1_Given :1; + unsigned HSMHV_ldrift2_Given :1; + unsigned HSMHV_ldrift1s_Given :1; + unsigned HSMHV_ldrift2s_Given :1; + unsigned HSMHV_subld1_Given :1; + unsigned HSMHV_subld2_Given :1; + unsigned HSMHV_ddltmax_Given :1; + unsigned HSMHV_ddltslp_Given :1; + unsigned HSMHV_ddltict_Given :1; + unsigned HSMHV_vfbover_Given :1; + unsigned HSMHV_nover_Given :1; + unsigned HSMHV_novers_Given :1; + unsigned HSMHV_xwd_Given :1; + unsigned HSMHV_xwdc_Given :1; + unsigned HSMHV_xl_Given :1; + unsigned HSMHV_xw_Given :1; + unsigned HSMHV_saref_Given :1; + unsigned HSMHV_sbref_Given :1; + unsigned HSMHV_ll_Given :1; + unsigned HSMHV_lld_Given :1; + unsigned HSMHV_lln_Given :1; + unsigned HSMHV_wl_Given :1; + unsigned HSMHV_wl1_Given :1; + unsigned HSMHV_wl1p_Given :1; + unsigned HSMHV_wl2_Given :1; + unsigned HSMHV_wl2p_Given :1; + unsigned HSMHV_wld_Given :1; + unsigned HSMHV_wln_Given :1; + unsigned HSMHV_xqy_Given :1; + unsigned HSMHV_xqy1_Given :1; + unsigned HSMHV_xqy2_Given :1; + unsigned HSMHV_rs_Given :1; + unsigned HSMHV_rd_Given :1; + unsigned HSMHV_rsh_Given :1; + unsigned HSMHV_rshg_Given :1; +/* unsigned HSMHV_ngcon_Given :1; */ +/* unsigned HSMHV_xgw_Given :1; */ +/* unsigned HSMHV_xgl_Given :1; */ +/* unsigned HSMHV_nf_Given :1; */ + unsigned HSMHV_vfbc_Given :1; + unsigned HSMHV_vbi_Given :1; + unsigned HSMHV_nsubc_Given :1; + unsigned HSMHV_parl2_Given :1; + unsigned HSMHV_lp_Given :1; + unsigned HSMHV_nsubp_Given :1; + unsigned HSMHV_nsubp0_Given :1; + unsigned HSMHV_nsubwp_Given :1; + unsigned HSMHV_scp1_Given :1; + unsigned HSMHV_scp2_Given :1; + unsigned HSMHV_scp3_Given :1; + unsigned HSMHV_sc1_Given :1; + unsigned HSMHV_sc2_Given :1; + unsigned HSMHV_sc3_Given :1; + unsigned HSMHV_sc4_Given :1; + unsigned HSMHV_pgd1_Given :1; + unsigned HSMHV_pgd2_Given :1; + unsigned HSMHV_pgd3_Given :1; + unsigned HSMHV_pgd4_Given :1; + unsigned HSMHV_ndep_Given :1; + unsigned HSMHV_ndepl_Given :1; + unsigned HSMHV_ndeplp_Given :1; + unsigned HSMHV_ninv_Given :1; + unsigned HSMHV_muecb0_Given :1; + unsigned HSMHV_muecb1_Given :1; + unsigned HSMHV_mueph1_Given :1; + unsigned HSMHV_mueph0_Given :1; + unsigned HSMHV_muephw_Given :1; + unsigned HSMHV_muepwp_Given :1; + unsigned HSMHV_muephl_Given :1; + unsigned HSMHV_mueplp_Given :1; + unsigned HSMHV_muephs_Given :1; + unsigned HSMHV_muepsp_Given :1; + unsigned HSMHV_vtmp_Given :1; + unsigned HSMHV_wvth0_Given :1; + unsigned HSMHV_muesr1_Given :1; + unsigned HSMHV_muesr0_Given :1; + unsigned HSMHV_muesrl_Given :1; + unsigned HSMHV_mueslp_Given :1; + unsigned HSMHV_muesrw_Given :1; + unsigned HSMHV_mueswp_Given :1; + unsigned HSMHV_bb_Given :1; + unsigned HSMHV_sub1_Given :1; + unsigned HSMHV_sub2_Given :1; + unsigned HSMHV_svgs_Given :1; + unsigned HSMHV_svbs_Given :1; + unsigned HSMHV_svbsl_Given :1; + unsigned HSMHV_svds_Given :1; + unsigned HSMHV_slg_Given :1; + unsigned HSMHV_sub1l_Given :1; + unsigned HSMHV_sub2l_Given :1; + unsigned HSMHV_fn1_Given :1; + unsigned HSMHV_fn2_Given :1; + unsigned HSMHV_fn3_Given :1; + unsigned HSMHV_fvbs_Given :1; + unsigned HSMHV_svgsl_Given :1; + unsigned HSMHV_svgslp_Given :1; + unsigned HSMHV_svgswp_Given :1; + unsigned HSMHV_svgsw_Given :1; + unsigned HSMHV_svbslp_Given :1; + unsigned HSMHV_slgl_Given :1; + unsigned HSMHV_slglp_Given :1; + unsigned HSMHV_sub1lp_Given :1; + unsigned HSMHV_nsti_Given :1; + unsigned HSMHV_wsti_Given :1; + unsigned HSMHV_wstil_Given :1; + unsigned HSMHV_wstilp_Given :1; + unsigned HSMHV_wstiw_Given :1; + unsigned HSMHV_wstiwp_Given :1; + unsigned HSMHV_scsti1_Given :1; + unsigned HSMHV_scsti2_Given :1; + unsigned HSMHV_vthsti_Given :1; + unsigned HSMHV_vdsti_Given :1; + unsigned HSMHV_muesti1_Given :1; + unsigned HSMHV_muesti2_Given :1; + unsigned HSMHV_muesti3_Given :1; + unsigned HSMHV_nsubpsti1_Given :1; + unsigned HSMHV_nsubpsti2_Given :1; + unsigned HSMHV_nsubpsti3_Given :1; + unsigned HSMHV_lpext_Given :1; + unsigned HSMHV_npext_Given :1; + unsigned HSMHV_scp22_Given :1; + unsigned HSMHV_scp21_Given :1; + unsigned HSMHV_bs1_Given :1; + unsigned HSMHV_bs2_Given :1; + unsigned HSMHV_cgso_Given :1; + unsigned HSMHV_cgdo_Given :1; + unsigned HSMHV_cgbo_Given :1; + unsigned HSMHV_tpoly_Given :1; + unsigned HSMHV_js0_Given :1; + unsigned HSMHV_js0sw_Given :1; + unsigned HSMHV_nj_Given :1; + unsigned HSMHV_njsw_Given :1; + unsigned HSMHV_xti_Given :1; + unsigned HSMHV_cj_Given :1; + unsigned HSMHV_cjsw_Given :1; + unsigned HSMHV_cjswg_Given :1; + unsigned HSMHV_mj_Given :1; + unsigned HSMHV_mjsw_Given :1; + unsigned HSMHV_mjswg_Given :1; + unsigned HSMHV_xti2_Given :1; + unsigned HSMHV_cisb_Given :1; + unsigned HSMHV_cvb_Given :1; + unsigned HSMHV_ctemp_Given :1; + unsigned HSMHV_cisbk_Given :1; + unsigned HSMHV_cvbk_Given :1; + unsigned HSMHV_divx_Given :1; + unsigned HSMHV_pb_Given :1; + unsigned HSMHV_pbsw_Given :1; + unsigned HSMHV_pbswg_Given :1; + unsigned HSMHV_clm1_Given :1; + unsigned HSMHV_clm2_Given :1; + unsigned HSMHV_clm3_Given :1; + unsigned HSMHV_clm5_Given :1; + unsigned HSMHV_clm6_Given :1; + unsigned HSMHV_muetmp_Given :1; + unsigned HSMHV_vover_Given :1; + unsigned HSMHV_voverp_Given :1; + unsigned HSMHV_vovers_Given :1; + unsigned HSMHV_voversp_Given :1; + unsigned HSMHV_wfc_Given :1; + unsigned HSMHV_nsubcw_Given :1; + unsigned HSMHV_nsubcwp_Given :1; + unsigned HSMHV_qme1_Given :1; + unsigned HSMHV_qme2_Given :1; + unsigned HSMHV_qme3_Given :1; + unsigned HSMHV_gidl1_Given :1; + unsigned HSMHV_gidl2_Given :1; + unsigned HSMHV_gidl3_Given :1; + unsigned HSMHV_gidl4_Given :1; + unsigned HSMHV_gidl5_Given :1; + unsigned HSMHV_gleak1_Given :1; + unsigned HSMHV_gleak2_Given :1; + unsigned HSMHV_gleak3_Given :1; + unsigned HSMHV_gleak4_Given :1; + unsigned HSMHV_gleak5_Given :1; + unsigned HSMHV_gleak6_Given :1; + unsigned HSMHV_gleak7_Given :1; + unsigned HSMHV_glpart1_Given :1; + unsigned HSMHV_glksd1_Given :1; + unsigned HSMHV_glksd2_Given :1; + unsigned HSMHV_glksd3_Given :1; + unsigned HSMHV_glkb1_Given :1; + unsigned HSMHV_glkb2_Given :1; + unsigned HSMHV_glkb3_Given :1; + unsigned HSMHV_egig_Given :1; + unsigned HSMHV_igtemp2_Given :1; + unsigned HSMHV_igtemp3_Given :1; + unsigned HSMHV_vzadd0_Given :1; + unsigned HSMHV_pzadd0_Given :1; + unsigned HSMHV_nftrp_Given :1; + unsigned HSMHV_nfalp_Given :1; + unsigned HSMHV_cit_Given :1; + unsigned HSMHV_falph_Given :1; + unsigned HSMHV_dly1_Given :1; + unsigned HSMHV_dly2_Given :1; + unsigned HSMHV_dly3_Given :1; + unsigned HSMHV_dlyov_Given :1; + unsigned HSMHV_tnom_Given :1; + unsigned HSMHV_ovslp_Given :1; + unsigned HSMHV_ovmag_Given :1; + unsigned HSMHV_gbmin_Given :1; + unsigned HSMHV_rbpb_Given :1; + unsigned HSMHV_rbpd_Given :1; + unsigned HSMHV_rbps_Given :1; + unsigned HSMHV_rbdb_Given :1; + unsigned HSMHV_rbsb_Given :1; + unsigned HSMHV_ibpc1_Given :1; + unsigned HSMHV_ibpc2_Given :1; + unsigned HSMHV_mphdfm_Given :1; + unsigned HSMHV_rdvg11_Given :1; + unsigned HSMHV_rdvg12_Given :1; + unsigned HSMHV_qovsm_Given :1; + unsigned HSMHV_ldrift_Given :1; + unsigned HSMHV_rd20_Given :1; + unsigned HSMHV_rd21_Given :1; + unsigned HSMHV_rd22_Given :1; + unsigned HSMHV_rd22d_Given :1; + unsigned HSMHV_rd23_Given :1; + unsigned HSMHV_rd24_Given :1; + unsigned HSMHV_rd25_Given :1; + unsigned HSMHV_rd26_Given :1; + unsigned HSMHV_rdvdl_Given :1; + unsigned HSMHV_rdvdlp_Given :1; + unsigned HSMHV_rdvds_Given :1; + unsigned HSMHV_rdvdsp_Given :1; + unsigned HSMHV_rd23l_Given :1; + unsigned HSMHV_rd23lp_Given :1; + unsigned HSMHV_rd23s_Given :1; + unsigned HSMHV_rd23sp_Given :1; + unsigned HSMHV_rds_Given :1; + unsigned HSMHV_rdsp_Given :1; + unsigned HSMHV_vbsmin_Given :1; + unsigned HSMHV_ninvd_Given :1; + unsigned HSMHV_ninvdw_Given :1; + unsigned HSMHV_ninvdwp_Given :1; + unsigned HSMHV_ninvdt1_Given :1; + unsigned HSMHV_ninvdt2_Given :1; + unsigned HSMHV_rdvb_Given :1; + unsigned HSMHV_rth0nf_Given :1; + + unsigned HSMHV_rthtemp1_Given :1; + unsigned HSMHV_rthtemp2_Given :1; + unsigned HSMHV_prattemp1_Given :1; + unsigned HSMHV_prattemp2_Given :1; + + + unsigned HSMHV_rth0_Given :1; + unsigned HSMHV_cth0_Given :1; + unsigned HSMHV_powrat_Given :1; + + + unsigned HSMHV_tcjbd_Given :1; + unsigned HSMHV_tcjbs_Given :1; + unsigned HSMHV_tcjbdsw_Given :1; + unsigned HSMHV_tcjbssw_Given :1; + unsigned HSMHV_tcjbdswg_Given :1; + unsigned HSMHV_tcjbsswg_Given :1; + + +/* unsigned HSMHV_wth0_Given :1; */ + unsigned HSMHV_qdftvd_Given :1; + unsigned HSMHV_rdvd_Given :1; + unsigned HSMHV_rdtemp1_Given :1; + unsigned HSMHV_rdtemp2_Given :1; + unsigned HSMHV_rth0r_Given :1; + unsigned HSMHV_rdvdtemp1_Given :1; + unsigned HSMHV_rdvdtemp2_Given :1; + unsigned HSMHV_rth0w_Given :1; + unsigned HSMHV_rth0wp_Given :1; + + unsigned HSMHV_cvdsover_Given :1; + + /* substrate effect */ + unsigned HSMHV_rdvsub_Given :1; /* substrate effect */ + unsigned HSMHV_rdvdsub_Given :1; /* substrate effect */ + unsigned HSMHV_ddrift_Given :1; /* substrate effect */ + unsigned HSMHV_vbisub_Given :1; /* substrate effect */ + unsigned HSMHV_nsubsub_Given :1; /* substrate effect */ + unsigned HSMHV_shemax_Given :1; + + /* binning parameters */ + unsigned HSMHV_lmin_Given :1; + unsigned HSMHV_lmax_Given :1; + unsigned HSMHV_wmin_Given :1; + unsigned HSMHV_wmax_Given :1; + unsigned HSMHV_lbinn_Given :1; + unsigned HSMHV_wbinn_Given :1; + + /* Length dependence */ + unsigned HSMHV_lvmax_Given :1; + unsigned HSMHV_lbgtmp1_Given :1; + unsigned HSMHV_lbgtmp2_Given :1; + unsigned HSMHV_leg0_Given :1; + unsigned HSMHV_lvfbover_Given :1; + unsigned HSMHV_lnover_Given :1; + unsigned HSMHV_lnovers_Given :1; + unsigned HSMHV_lwl2_Given :1; + unsigned HSMHV_lvfbc_Given :1; + unsigned HSMHV_lnsubc_Given :1; + unsigned HSMHV_lnsubp_Given :1; + unsigned HSMHV_lscp1_Given :1; + unsigned HSMHV_lscp2_Given :1; + unsigned HSMHV_lscp3_Given :1; + unsigned HSMHV_lsc1_Given :1; + unsigned HSMHV_lsc2_Given :1; + unsigned HSMHV_lsc3_Given :1; + unsigned HSMHV_lpgd1_Given :1; + unsigned HSMHV_lpgd3_Given :1; + unsigned HSMHV_lndep_Given :1; + unsigned HSMHV_lninv_Given :1; + unsigned HSMHV_lmuecb0_Given :1; + unsigned HSMHV_lmuecb1_Given :1; + unsigned HSMHV_lmueph1_Given :1; + unsigned HSMHV_lvtmp_Given :1; + unsigned HSMHV_lwvth0_Given :1; + unsigned HSMHV_lmuesr1_Given :1; + unsigned HSMHV_lmuetmp_Given :1; + unsigned HSMHV_lsub1_Given :1; + unsigned HSMHV_lsub2_Given :1; + unsigned HSMHV_lsvds_Given :1; + unsigned HSMHV_lsvbs_Given :1; + unsigned HSMHV_lsvgs_Given :1; + unsigned HSMHV_lfn1_Given :1; + unsigned HSMHV_lfn2_Given :1; + unsigned HSMHV_lfn3_Given :1; + unsigned HSMHV_lfvbs_Given :1; + unsigned HSMHV_lnsti_Given :1; + unsigned HSMHV_lwsti_Given :1; + unsigned HSMHV_lscsti1_Given :1; + unsigned HSMHV_lscsti2_Given :1; + unsigned HSMHV_lvthsti_Given :1; + unsigned HSMHV_lmuesti1_Given :1; + unsigned HSMHV_lmuesti2_Given :1; + unsigned HSMHV_lmuesti3_Given :1; + unsigned HSMHV_lnsubpsti1_Given :1; + unsigned HSMHV_lnsubpsti2_Given :1; + unsigned HSMHV_lnsubpsti3_Given :1; + unsigned HSMHV_lcgso_Given :1; + unsigned HSMHV_lcgdo_Given :1; + unsigned HSMHV_ljs0_Given :1; + unsigned HSMHV_ljs0sw_Given :1; + unsigned HSMHV_lnj_Given :1; + unsigned HSMHV_lcisbk_Given :1; + unsigned HSMHV_lclm1_Given :1; + unsigned HSMHV_lclm2_Given :1; + unsigned HSMHV_lclm3_Given :1; + unsigned HSMHV_lwfc_Given :1; + unsigned HSMHV_lgidl1_Given :1; + unsigned HSMHV_lgidl2_Given :1; + unsigned HSMHV_lgleak1_Given :1; + unsigned HSMHV_lgleak2_Given :1; + unsigned HSMHV_lgleak3_Given :1; + unsigned HSMHV_lgleak6_Given :1; + unsigned HSMHV_lglksd1_Given :1; + unsigned HSMHV_lglksd2_Given :1; + unsigned HSMHV_lglkb1_Given :1; + unsigned HSMHV_lglkb2_Given :1; + unsigned HSMHV_lnftrp_Given :1; + unsigned HSMHV_lnfalp_Given :1; + unsigned HSMHV_lpthrou_Given :1; + unsigned HSMHV_lvdiffj_Given :1; + unsigned HSMHV_libpc1_Given :1; + unsigned HSMHV_libpc2_Given :1; + unsigned HSMHV_lcgbo_Given :1; + unsigned HSMHV_lcvdsover_Given :1; + unsigned HSMHV_lfalph_Given :1; + unsigned HSMHV_lnpext_Given :1; + unsigned HSMHV_lpowrat_Given :1; + unsigned HSMHV_lrd_Given :1; + unsigned HSMHV_lrd22_Given :1; + unsigned HSMHV_lrd23_Given :1; + unsigned HSMHV_lrd24_Given :1; + unsigned HSMHV_lrdict1_Given :1; + unsigned HSMHV_lrdov13_Given :1; + unsigned HSMHV_lrdslp1_Given :1; + unsigned HSMHV_lrdvb_Given :1; + unsigned HSMHV_lrdvd_Given :1; + unsigned HSMHV_lrdvg11_Given :1; + unsigned HSMHV_lrs_Given :1; + unsigned HSMHV_lrth0_Given :1; + unsigned HSMHV_lvover_Given :1; + + /* Width dependence */ + unsigned HSMHV_wvmax_Given :1; + unsigned HSMHV_wbgtmp1_Given :1; + unsigned HSMHV_wbgtmp2_Given :1; + unsigned HSMHV_weg0_Given :1; + unsigned HSMHV_wvfbover_Given :1; + unsigned HSMHV_wnover_Given :1; + unsigned HSMHV_wnovers_Given :1; + unsigned HSMHV_wwl2_Given :1; + unsigned HSMHV_wvfbc_Given :1; + unsigned HSMHV_wnsubc_Given :1; + unsigned HSMHV_wnsubp_Given :1; + unsigned HSMHV_wscp1_Given :1; + unsigned HSMHV_wscp2_Given :1; + unsigned HSMHV_wscp3_Given :1; + unsigned HSMHV_wsc1_Given :1; + unsigned HSMHV_wsc2_Given :1; + unsigned HSMHV_wsc3_Given :1; + unsigned HSMHV_wpgd1_Given :1; + unsigned HSMHV_wpgd3_Given :1; + unsigned HSMHV_wndep_Given :1; + unsigned HSMHV_wninv_Given :1; + unsigned HSMHV_wmuecb0_Given :1; + unsigned HSMHV_wmuecb1_Given :1; + unsigned HSMHV_wmueph1_Given :1; + unsigned HSMHV_wvtmp_Given :1; + unsigned HSMHV_wwvth0_Given :1; + unsigned HSMHV_wmuesr1_Given :1; + unsigned HSMHV_wmuetmp_Given :1; + unsigned HSMHV_wsub1_Given :1; + unsigned HSMHV_wsub2_Given :1; + unsigned HSMHV_wsvds_Given :1; + unsigned HSMHV_wsvbs_Given :1; + unsigned HSMHV_wsvgs_Given :1; + unsigned HSMHV_wfn1_Given :1; + unsigned HSMHV_wfn2_Given :1; + unsigned HSMHV_wfn3_Given :1; + unsigned HSMHV_wfvbs_Given :1; + unsigned HSMHV_wnsti_Given :1; + unsigned HSMHV_wwsti_Given :1; + unsigned HSMHV_wscsti1_Given :1; + unsigned HSMHV_wscsti2_Given :1; + unsigned HSMHV_wvthsti_Given :1; + unsigned HSMHV_wmuesti1_Given :1; + unsigned HSMHV_wmuesti2_Given :1; + unsigned HSMHV_wmuesti3_Given :1; + unsigned HSMHV_wnsubpsti1_Given :1; + unsigned HSMHV_wnsubpsti2_Given :1; + unsigned HSMHV_wnsubpsti3_Given :1; + unsigned HSMHV_wcgso_Given :1; + unsigned HSMHV_wcgdo_Given :1; + unsigned HSMHV_wjs0_Given :1; + unsigned HSMHV_wjs0sw_Given :1; + unsigned HSMHV_wnj_Given :1; + unsigned HSMHV_wcisbk_Given :1; + unsigned HSMHV_wclm1_Given :1; + unsigned HSMHV_wclm2_Given :1; + unsigned HSMHV_wclm3_Given :1; + unsigned HSMHV_wwfc_Given :1; + unsigned HSMHV_wgidl1_Given :1; + unsigned HSMHV_wgidl2_Given :1; + unsigned HSMHV_wgleak1_Given :1; + unsigned HSMHV_wgleak2_Given :1; + unsigned HSMHV_wgleak3_Given :1; + unsigned HSMHV_wgleak6_Given :1; + unsigned HSMHV_wglksd1_Given :1; + unsigned HSMHV_wglksd2_Given :1; + unsigned HSMHV_wglkb1_Given :1; + unsigned HSMHV_wglkb2_Given :1; + unsigned HSMHV_wnftrp_Given :1; + unsigned HSMHV_wnfalp_Given :1; + unsigned HSMHV_wpthrou_Given :1; + unsigned HSMHV_wvdiffj_Given :1; + unsigned HSMHV_wibpc1_Given :1; + unsigned HSMHV_wibpc2_Given :1; + unsigned HSMHV_wcgbo_Given :1; + unsigned HSMHV_wcvdsover_Given :1; + unsigned HSMHV_wfalph_Given :1; + unsigned HSMHV_wnpext_Given :1; + unsigned HSMHV_wpowrat_Given :1; + unsigned HSMHV_wrd_Given :1; + unsigned HSMHV_wrd22_Given :1; + unsigned HSMHV_wrd23_Given :1; + unsigned HSMHV_wrd24_Given :1; + unsigned HSMHV_wrdict1_Given :1; + unsigned HSMHV_wrdov13_Given :1; + unsigned HSMHV_wrdslp1_Given :1; + unsigned HSMHV_wrdvb_Given :1; + unsigned HSMHV_wrdvd_Given :1; + unsigned HSMHV_wrdvg11_Given :1; + unsigned HSMHV_wrs_Given :1; + unsigned HSMHV_wrth0_Given :1; + unsigned HSMHV_wvover_Given :1; + + /* Cross-term dependence */ + unsigned HSMHV_pvmax_Given :1; + unsigned HSMHV_pbgtmp1_Given :1; + unsigned HSMHV_pbgtmp2_Given :1; + unsigned HSMHV_peg0_Given :1; + unsigned HSMHV_pvfbover_Given :1; + unsigned HSMHV_pnover_Given :1; + unsigned HSMHV_pnovers_Given :1; + unsigned HSMHV_pwl2_Given :1; + unsigned HSMHV_pvfbc_Given :1; + unsigned HSMHV_pnsubc_Given :1; + unsigned HSMHV_pnsubp_Given :1; + unsigned HSMHV_pscp1_Given :1; + unsigned HSMHV_pscp2_Given :1; + unsigned HSMHV_pscp3_Given :1; + unsigned HSMHV_psc1_Given :1; + unsigned HSMHV_psc2_Given :1; + unsigned HSMHV_psc3_Given :1; + unsigned HSMHV_ppgd1_Given :1; + unsigned HSMHV_ppgd3_Given :1; + unsigned HSMHV_pndep_Given :1; + unsigned HSMHV_pninv_Given :1; + unsigned HSMHV_pmuecb0_Given :1; + unsigned HSMHV_pmuecb1_Given :1; + unsigned HSMHV_pmueph1_Given :1; + unsigned HSMHV_pvtmp_Given :1; + unsigned HSMHV_pwvth0_Given :1; + unsigned HSMHV_pmuesr1_Given :1; + unsigned HSMHV_pmuetmp_Given :1; + unsigned HSMHV_psub1_Given :1; + unsigned HSMHV_psub2_Given :1; + unsigned HSMHV_psvds_Given :1; + unsigned HSMHV_psvbs_Given :1; + unsigned HSMHV_psvgs_Given :1; + unsigned HSMHV_pfn1_Given :1; + unsigned HSMHV_pfn2_Given :1; + unsigned HSMHV_pfn3_Given :1; + unsigned HSMHV_pfvbs_Given :1; + unsigned HSMHV_pnsti_Given :1; + unsigned HSMHV_pwsti_Given :1; + unsigned HSMHV_pscsti1_Given :1; + unsigned HSMHV_pscsti2_Given :1; + unsigned HSMHV_pvthsti_Given :1; + unsigned HSMHV_pmuesti1_Given :1; + unsigned HSMHV_pmuesti2_Given :1; + unsigned HSMHV_pmuesti3_Given :1; + unsigned HSMHV_pnsubpsti1_Given :1; + unsigned HSMHV_pnsubpsti2_Given :1; + unsigned HSMHV_pnsubpsti3_Given :1; + unsigned HSMHV_pcgso_Given :1; + unsigned HSMHV_pcgdo_Given :1; + unsigned HSMHV_pjs0_Given :1; + unsigned HSMHV_pjs0sw_Given :1; + unsigned HSMHV_pnj_Given :1; + unsigned HSMHV_pcisbk_Given :1; + unsigned HSMHV_pclm1_Given :1; + unsigned HSMHV_pclm2_Given :1; + unsigned HSMHV_pclm3_Given :1; + unsigned HSMHV_pwfc_Given :1; + unsigned HSMHV_pgidl1_Given :1; + unsigned HSMHV_pgidl2_Given :1; + unsigned HSMHV_pgleak1_Given :1; + unsigned HSMHV_pgleak2_Given :1; + unsigned HSMHV_pgleak3_Given :1; + unsigned HSMHV_pgleak6_Given :1; + unsigned HSMHV_pglksd1_Given :1; + unsigned HSMHV_pglksd2_Given :1; + unsigned HSMHV_pglkb1_Given :1; + unsigned HSMHV_pglkb2_Given :1; + unsigned HSMHV_pnftrp_Given :1; + unsigned HSMHV_pnfalp_Given :1; + unsigned HSMHV_ppthrou_Given :1; + unsigned HSMHV_pvdiffj_Given :1; + unsigned HSMHV_pibpc1_Given :1; + unsigned HSMHV_pibpc2_Given :1; + unsigned HSMHV_pcgbo_Given :1; + unsigned HSMHV_pcvdsover_Given :1; + unsigned HSMHV_pfalph_Given :1; + unsigned HSMHV_pnpext_Given :1; + unsigned HSMHV_ppowrat_Given :1; + unsigned HSMHV_prd_Given :1; + unsigned HSMHV_prd22_Given :1; + unsigned HSMHV_prd23_Given :1; + unsigned HSMHV_prd24_Given :1; + unsigned HSMHV_prdict1_Given :1; + unsigned HSMHV_prdov13_Given :1; + unsigned HSMHV_prdslp1_Given :1; + unsigned HSMHV_prdvb_Given :1; + unsigned HSMHV_prdvd_Given :1; + unsigned HSMHV_prdvg11_Given :1; + unsigned HSMHV_prs_Given :1; + unsigned HSMHV_prth0_Given :1; + unsigned HSMHV_pvover_Given :1; + +} HSMHVmodel; + +#ifndef NMOS +#define NMOS 1 +#define PMOS -1 +#endif /*NMOS*/ + +#define HSMHV_BAD_PARAM -1 + +/* flags */ +#define HSMHV_MOD_NMOS 1 +#define HSMHV_MOD_PMOS 2 +#define HSMHV_MOD_LEVEL 3 +#define HSMHV_MOD_INFO 4 +#define HSMHV_MOD_NOISE 5 +#define HSMHV_MOD_VERSION 6 +#define HSMHV_MOD_SHOW 7 +#define HSMHV_MOD_CORSRD 11 +#define HSMHV_MOD_COIPRV 12 +#define HSMHV_MOD_COPPRV 13 +#define HSMHV_MOD_COADOV 17 +#define HSMHV_MOD_COISUB 21 +#define HSMHV_MOD_COIIGS 22 +#define HSMHV_MOD_COGIDL 23 +#define HSMHV_MOD_COOVLP 24 +#define HSMHV_MOD_COOVLPS 8 +#define HSMHV_MOD_COFLICK 25 +#define HSMHV_MOD_COISTI 26 +#define HSMHV_MOD_CONQS 29 +#define HSMHV_MOD_COTHRML 30 +#define HSMHV_MOD_COIGN 31 /* Induced gate noise */ +#define HSMHV_MOD_CORG 32 +#define HSMHV_MOD_CORBNET 33 +#define HSMHV_MOD_CODFM 36 /* DFM */ +#define HSMHV_MOD_COQOVSM 34 +#define HSMHV_MOD_COSELFHEAT 35 /* Self-heating model--SHE-- */ +#define HSMHV_MOD_COSUBNODE 48 +#define HSMHV_MOD_COSYM 37 /* Symmery model for HV */ +#define HSMHV_MOD_COTEMP 38 +#define HSMHV_MOD_COLDRIFT 39 +/* device parameters */ +#define HSMHV_COSELFHEAT 49 +#define HSMHV_COSUBNODE 50 +#define HSMHV_L 51 +#define HSMHV_W 52 +#define HSMHV_AD 53 +#define HSMHV_AS 54 +#define HSMHV_PD 55 +#define HSMHV_PS 56 +#define HSMHV_NRD 57 +#define HSMHV_NRS 58 +/* #define HSMHV_TEMP 59 not used */ +#define HSMHV_DTEMP 60 +#define HSMHV_OFF 61 +#define HSMHV_IC_VBS 62 +#define HSMHV_IC_VDS 63 +#define HSMHV_IC_VGS 64 +#define HSMHV_IC 65 +#define HSMHV_CORBNET 66 +#define HSMHV_RBPB 67 +#define HSMHV_RBPD 68 +#define HSMHV_RBPS 69 +#define HSMHV_RBDB 70 +#define HSMHV_RBSB 71 +#define HSMHV_CORG 72 +/* #define HSMHV_RSHG 73 */ +#define HSMHV_NGCON 74 +#define HSMHV_XGW 75 +#define HSMHV_XGL 76 +#define HSMHV_NF 77 +#define HSMHV_SA 78 +#define HSMHV_SB 79 +#define HSMHV_SD 80 +#define HSMHV_NSUBCDFM 82 +#define HSMHV_M 83 +#define HSMHV_SUBLD1 86 +#define HSMHV_SUBLD2 87 +#define HSMHV_LOVER 41 +#define HSMHV_LOVERS 42 +#define HSMHV_LOVERLD 43 +#define HSMHV_LDRIFT1 88 +#define HSMHV_LDRIFT2 89 +#define HSMHV_LDRIFT1S 90 +#define HSMHV_LDRIFT2S 91 +/* #define HSMHV_RTH0 84 not used */ +/* #define HSMHV_CTH0 85 not used */ + + + + +/* model parameters */ +#define HSMHV_MOD_VBSMIN 198 +#define HSMHV_MOD_VMAX 500 +#define HSMHV_MOD_VMAXT1 503 +#define HSMHV_MOD_VMAXT2 504 +#define HSMHV_MOD_BGTMP1 101 +#define HSMHV_MOD_BGTMP2 102 +#define HSMHV_MOD_EG0 103 +#define HSMHV_MOD_TOX 104 +#define HSMHV_MOD_XLD 105 +#define HSMHV_MOD_LOVER 106 +#define HSMHV_MOD_LOVERS 385 +#define HSMHV_MOD_RDOV11 313 +#define HSMHV_MOD_RDOV12 314 +#define HSMHV_MOD_RDOV13 476 +#define HSMHV_MOD_RDSLP1 315 +#define HSMHV_MOD_RDICT1 316 +#define HSMHV_MOD_RDSLP2 317 +#define HSMHV_MOD_RDICT2 318 +#define HSMHV_MOD_LOVERLD 436 +#define HSMHV_MOD_LDRIFT1 319 +#define HSMHV_MOD_LDRIFT2 320 +#define HSMHV_MOD_LDRIFT1S 324 +#define HSMHV_MOD_LDRIFT2S 325 +#define HSMHV_MOD_SUBLD1 321 +#define HSMHV_MOD_SUBLD2 322 +#define HSMHV_MOD_DDLTMAX 421 /* Vdseff */ +#define HSMHV_MOD_DDLTSLP 422 /* Vdseff */ +#define HSMHV_MOD_DDLTICT 423 /* Vdseff */ +#define HSMHV_MOD_VFBOVER 428 +#define HSMHV_MOD_NOVER 430 +#define HSMHV_MOD_NOVERS 431 +#define HSMHV_MOD_XWD 107 +#define HSMHV_MOD_XWDC 513 +#define HSMHV_MOD_XL 112 +#define HSMHV_MOD_XW 117 +#define HSMHV_MOD_SAREF 433 +#define HSMHV_MOD_SBREF 434 +#define HSMHV_MOD_LL 108 +#define HSMHV_MOD_LLD 109 +#define HSMHV_MOD_LLN 110 +#define HSMHV_MOD_WL 111 +#define HSMHV_MOD_WL1 113 +#define HSMHV_MOD_WL1P 114 +#define HSMHV_MOD_WL2 407 +#define HSMHV_MOD_WL2P 408 +#define HSMHV_MOD_WLD 115 +#define HSMHV_MOD_WLN 116 + +#define HSMHV_MOD_XQY 178 +#define HSMHV_MOD_XQY1 118 +#define HSMHV_MOD_XQY2 120 +#define HSMHV_MOD_RSH 119 + +#define HSMHV_MOD_RSHG 384 +/* #define HSMHV_MOD_NGCON 385 */ +/* #define HSMHV_MOD_XGW 386 */ +/* #define HSMHV_MOD_XGL 387 */ +/* #define HSMHV_MOD_NF 388 */ +#define HSMHV_MOD_RS 398 +#define HSMHV_MOD_RD 399 + +#define HSMHV_MOD_VFBC 121 +#define HSMHV_MOD_VBI 122 +#define HSMHV_MOD_NSUBC 123 +#define HSMHV_MOD_TNOM 124 +#define HSMHV_MOD_PARL2 125 +#define HSMHV_MOD_SC1 126 +#define HSMHV_MOD_SC2 127 +#define HSMHV_MOD_SC3 128 +#define HSMHV_MOD_SC4 248 +#define HSMHV_MOD_NDEP 129 +#define HSMHV_MOD_NDEPL 419 +#define HSMHV_MOD_NDEPLP 420 +#define HSMHV_MOD_NINV 130 +#define HSMHV_MOD_NINVD 505 +#define HSMHV_MOD_NINVDW 506 +#define HSMHV_MOD_NINVDWP 507 +#define HSMHV_MOD_NINVDT1 508 +#define HSMHV_MOD_NINVDT2 509 +#define HSMHV_MOD_MUECB0 131 +#define HSMHV_MOD_MUECB1 132 +#define HSMHV_MOD_MUEPH1 133 +#define HSMHV_MOD_MUEPH0 134 +#define HSMHV_MOD_MUEPHW 135 +#define HSMHV_MOD_MUEPWP 136 +#define HSMHV_MOD_MUEPHL 137 +#define HSMHV_MOD_MUEPLP 138 +#define HSMHV_MOD_MUEPHS 139 +#define HSMHV_MOD_MUEPSP 140 +#define HSMHV_MOD_VTMP 141 +#define HSMHV_MOD_WVTH0 142 +#define HSMHV_MOD_MUESR1 143 +#define HSMHV_MOD_MUESR0 144 +#define HSMHV_MOD_MUESRL 145 +#define HSMHV_MOD_MUESLP 146 +#define HSMHV_MOD_MUESRW 147 +#define HSMHV_MOD_MUESWP 148 +#define HSMHV_MOD_BB 149 + +#define HSMHV_MOD_SUB1 151 +#define HSMHV_MOD_SUB2 152 +#define HSMHV_MOD_CGSO 154 +#define HSMHV_MOD_CGDO 155 +#define HSMHV_MOD_CGBO 156 +#define HSMHV_MOD_JS0 157 +#define HSMHV_MOD_JS0SW 158 +#define HSMHV_MOD_NJ 159 +#define HSMHV_MOD_NJSW 160 +#define HSMHV_MOD_XTI 161 +#define HSMHV_MOD_CJ 162 +#define HSMHV_MOD_CJSW 163 +#define HSMHV_MOD_CJSWG 164 +#define HSMHV_MOD_MJ 165 +#define HSMHV_MOD_MJSW 166 +#define HSMHV_MOD_MJSWG 167 +#define HSMHV_MOD_XTI2 168 +#define HSMHV_MOD_CISB 169 +#define HSMHV_MOD_CVB 170 +#define HSMHV_MOD_CTEMP 171 +#define HSMHV_MOD_CISBK 172 +#define HSMHV_MOD_CVBK 173 +#define HSMHV_MOD_DIVX 174 +#define HSMHV_MOD_PB 175 +#define HSMHV_MOD_PBSW 176 +#define HSMHV_MOD_PBSWG 177 +#define HSMHV_MOD_TPOLY 179 +/* #define HSMHV_MOD_TPOLYLD 477 not used */ +#define HSMHV_MOD_LP 180 +#define HSMHV_MOD_NSUBP 181 +#define HSMHV_MOD_NSUBP0 182 +#define HSMHV_MOD_NSUBWP 183 +#define HSMHV_MOD_SCP1 184 +#define HSMHV_MOD_SCP2 185 +#define HSMHV_MOD_SCP3 186 +#define HSMHV_MOD_PGD1 187 +#define HSMHV_MOD_PGD2 188 +#define HSMHV_MOD_PGD3 189 +#define HSMHV_MOD_PGD4 190 +#define HSMHV_MOD_CLM1 191 +#define HSMHV_MOD_CLM2 192 +#define HSMHV_MOD_CLM3 193 +#define HSMHV_MOD_CLM5 402 +#define HSMHV_MOD_CLM6 403 +#define HSMHV_MOD_MUETMP 195 + +#define HSMHV_MOD_VOVER 199 +#define HSMHV_MOD_VOVERP 200 +#define HSMHV_MOD_WFC 201 +#define HSMHV_MOD_NSUBCW 249 +#define HSMHV_MOD_NSUBCWP 250 +#define HSMHV_MOD_QME1 202 +#define HSMHV_MOD_QME2 203 +#define HSMHV_MOD_QME3 204 +#define HSMHV_MOD_GIDL1 205 +#define HSMHV_MOD_GIDL2 206 +#define HSMHV_MOD_GIDL3 207 +#define HSMHV_MOD_GLEAK1 208 +#define HSMHV_MOD_GLEAK2 209 +#define HSMHV_MOD_GLEAK3 210 +#define HSMHV_MOD_GLEAK4 211 +#define HSMHV_MOD_GLEAK5 212 +#define HSMHV_MOD_GLEAK6 213 +#define HSMHV_MOD_GLEAK7 214 +#define HSMHV_MOD_GLPART1 406 +#define HSMHV_MOD_GLKSD1 215 +#define HSMHV_MOD_GLKSD2 216 +#define HSMHV_MOD_GLKSD3 217 +#define HSMHV_MOD_GLKB1 218 +#define HSMHV_MOD_GLKB2 219 +#define HSMHV_MOD_GLKB3 429 +#define HSMHV_MOD_EGIG 220 +#define HSMHV_MOD_IGTEMP2 221 +#define HSMHV_MOD_IGTEMP3 222 +#define HSMHV_MOD_VZADD0 223 +#define HSMHV_MOD_PZADD0 224 +#define HSMHV_MOD_NSTI 225 +#define HSMHV_MOD_WSTI 226 +#define HSMHV_MOD_WSTIL 227 +#define HSMHV_MOD_WSTILP 231 +#define HSMHV_MOD_WSTIW 234 +#define HSMHV_MOD_WSTIWP 228 +#define HSMHV_MOD_SCSTI1 229 +#define HSMHV_MOD_SCSTI2 230 +#define HSMHV_MOD_VTHSTI 232 +#define HSMHV_MOD_VDSTI 233 +#define HSMHV_MOD_MUESTI1 235 +#define HSMHV_MOD_MUESTI2 236 +#define HSMHV_MOD_MUESTI3 237 +#define HSMHV_MOD_NSUBPSTI1 238 +#define HSMHV_MOD_NSUBPSTI2 239 +#define HSMHV_MOD_NSUBPSTI3 240 +#define HSMHV_MOD_LPEXT 241 +#define HSMHV_MOD_NPEXT 242 +#define HSMHV_MOD_SCP22 243 +#define HSMHV_MOD_SCP21 244 +#define HSMHV_MOD_BS1 245 +#define HSMHV_MOD_BS2 246 +#define HSMHV_MOD_KAPPA 251 +#define HSMHV_MOD_PTHROU 253 +#define HSMHV_MOD_VDIFFJ 254 +#define HSMHV_MOD_DLY1 255 +#define HSMHV_MOD_DLY2 256 +#define HSMHV_MOD_DLY3 257 +#define HSMHV_MOD_NFTRP 258 +#define HSMHV_MOD_NFALP 259 +#define HSMHV_MOD_CIT 260 +#define HSMHV_MOD_FALPH 263 +#define HSMHV_MOD_OVSLP 261 +#define HSMHV_MOD_OVMAG 262 +#define HSMHV_MOD_GIDL4 281 +#define HSMHV_MOD_GIDL5 282 +#define HSMHV_MOD_SVGS 283 +#define HSMHV_MOD_SVBS 284 +#define HSMHV_MOD_SVBSL 285 +#define HSMHV_MOD_SVDS 286 +#define HSMHV_MOD_SLG 287 +#define HSMHV_MOD_SUB1L 290 +#define HSMHV_MOD_SUB2L 292 +#define HSMHV_MOD_FN1 294 +#define HSMHV_MOD_FN2 295 +#define HSMHV_MOD_FN3 296 +#define HSMHV_MOD_FVBS 297 +#define HSMHV_MOD_VOVERS 303 +#define HSMHV_MOD_VOVERSP 304 +#define HSMHV_MOD_SVGSL 305 +#define HSMHV_MOD_SVGSLP 306 +#define HSMHV_MOD_SVGSWP 307 +#define HSMHV_MOD_SVGSW 308 +#define HSMHV_MOD_SVBSLP 309 +#define HSMHV_MOD_SLGL 310 +#define HSMHV_MOD_SLGLP 311 +#define HSMHV_MOD_SUB1LP 312 +#define HSMHV_MOD_IBPC1 404 +#define HSMHV_MOD_IBPC2 405 +#define HSMHV_MOD_MPHDFM 409 +#define HSMHV_MOD_RDVG11 424 +#define HSMHV_MOD_RDVG12 425 +#define HSMHV_MOD_RTH0 432 +#define HSMHV_MOD_CTH0 462 +#define HSMHV_MOD_POWRAT 463 +/* #define HSMHV_MOD_WTH0 463 /\*---------SHE----------*\/ */ +#define HSMHV_MOD_DLYOV 437 +#define HSMHV_MOD_QDFTVD 438 +#define HSMHV_MOD_XLDLD 439 +#define HSMHV_MOD_XWDLD 494 +#define HSMHV_MOD_RDVD 510 +#define HSMHV_MOD_RDVB 301 + +#define HSMHV_MOD_RDVSUB 481 /* substrate effect */ +#define HSMHV_MOD_RDVDSUB 482 /* substrate effect */ +#define HSMHV_MOD_DDRIFT 483 /* substrate effect */ +#define HSMHV_MOD_VBISUB 484 /* substrate effect */ +#define HSMHV_MOD_NSUBSUB 485 /* substrate effect */ + +#define HSMHV_MOD_QOVSM 323 +#define HSMHV_MOD_LDRIFT 458 +#define HSMHV_MOD_RD20 447 +#define HSMHV_MOD_RD21 441 +#define HSMHV_MOD_RD22 442 +#define HSMHV_MOD_RD22D 478 +#define HSMHV_MOD_RD23 443 +#define HSMHV_MOD_RD24 444 +#define HSMHV_MOD_RD25 445 +#define HSMHV_MOD_RD26 446 +#define HSMHV_MOD_RDVDL 448 +#define HSMHV_MOD_RDVDLP 449 +#define HSMHV_MOD_RDVDS 450 +#define HSMHV_MOD_RDVDSP 451 +#define HSMHV_MOD_RD23L 452 +#define HSMHV_MOD_RD23LP 453 +#define HSMHV_MOD_RD23S 454 +#define HSMHV_MOD_RD23SP 455 +#define HSMHV_MOD_RDS 456 +#define HSMHV_MOD_RDSP 457 +#define HSMHV_MOD_RDTEMP1 461 +#define HSMHV_MOD_RDTEMP2 464 +#define HSMHV_MOD_RTH0R 470 +#define HSMHV_MOD_RDVDTEMP1 471 +#define HSMHV_MOD_RDVDTEMP2 472 +#define HSMHV_MOD_RTH0W 473 +#define HSMHV_MOD_RTH0WP 474 +#define HSMHV_MOD_RTH0NF 475 + +#define HSMHV_MOD_RTHTEMP1 490 +#define HSMHV_MOD_RTHTEMP2 491 +#define HSMHV_MOD_PRATTEMP1 492 +#define HSMHV_MOD_PRATTEMP2 493 + + +#define HSMHV_MOD_CVDSOVER 480 +#define HSMHV_MOD_SHEMAX 100 + +/* binning parameters */ +#define HSMHV_MOD_LMIN 1000 +#define HSMHV_MOD_LMAX 1001 +#define HSMHV_MOD_WMIN 1002 +#define HSMHV_MOD_WMAX 1003 +#define HSMHV_MOD_LBINN 1004 +#define HSMHV_MOD_WBINN 1005 + +/* Length dependence */ +#define HSMHV_MOD_LVMAX 1100 +#define HSMHV_MOD_LBGTMP1 1101 +#define HSMHV_MOD_LBGTMP2 1102 +#define HSMHV_MOD_LEG0 1103 +#define HSMHV_MOD_LVFBOVER 1428 +#define HSMHV_MOD_LNOVER 1430 +#define HSMHV_MOD_LNOVERS 1431 +#define HSMHV_MOD_LWL2 1407 +#define HSMHV_MOD_LVFBC 1121 +#define HSMHV_MOD_LNSUBC 1123 +#define HSMHV_MOD_LNSUBP 1181 +#define HSMHV_MOD_LSCP1 1184 +#define HSMHV_MOD_LSCP2 1185 +#define HSMHV_MOD_LSCP3 1186 +#define HSMHV_MOD_LSC1 1126 +#define HSMHV_MOD_LSC2 1127 +#define HSMHV_MOD_LSC3 1128 +#define HSMHV_MOD_LPGD1 1187 +#define HSMHV_MOD_LPGD3 1189 +#define HSMHV_MOD_LNDEP 1129 +#define HSMHV_MOD_LNINV 1130 +#define HSMHV_MOD_LMUECB0 1131 +#define HSMHV_MOD_LMUECB1 1132 +#define HSMHV_MOD_LMUEPH1 1133 +#define HSMHV_MOD_LVTMP 1141 +#define HSMHV_MOD_LWVTH0 1142 +#define HSMHV_MOD_LMUESR1 1143 +#define HSMHV_MOD_LMUETMP 1195 +#define HSMHV_MOD_LSUB1 1151 +#define HSMHV_MOD_LSUB2 1152 +#define HSMHV_MOD_LSVDS 1286 +#define HSMHV_MOD_LSVBS 1284 +#define HSMHV_MOD_LSVGS 1283 +#define HSMHV_MOD_LFN1 1294 +#define HSMHV_MOD_LFN2 1295 +#define HSMHV_MOD_LFN3 1296 +#define HSMHV_MOD_LFVBS 1297 +#define HSMHV_MOD_LNSTI 1225 +#define HSMHV_MOD_LWSTI 1226 +#define HSMHV_MOD_LSCSTI1 1229 +#define HSMHV_MOD_LSCSTI2 1230 +#define HSMHV_MOD_LVTHSTI 1232 +#define HSMHV_MOD_LMUESTI1 1235 +#define HSMHV_MOD_LMUESTI2 1236 +#define HSMHV_MOD_LMUESTI3 1237 +#define HSMHV_MOD_LNSUBPSTI1 1238 +#define HSMHV_MOD_LNSUBPSTI2 1239 +#define HSMHV_MOD_LNSUBPSTI3 1240 +#define HSMHV_MOD_LCGSO 1154 +#define HSMHV_MOD_LCGDO 1155 +#define HSMHV_MOD_LJS0 1157 +#define HSMHV_MOD_LJS0SW 1158 +#define HSMHV_MOD_LNJ 1159 +#define HSMHV_MOD_LCISBK 1172 +#define HSMHV_MOD_LCLM1 1191 +#define HSMHV_MOD_LCLM2 1192 +#define HSMHV_MOD_LCLM3 1193 +#define HSMHV_MOD_LWFC 1201 +#define HSMHV_MOD_LGIDL1 1205 +#define HSMHV_MOD_LGIDL2 1206 +#define HSMHV_MOD_LGLEAK1 1208 +#define HSMHV_MOD_LGLEAK2 1209 +#define HSMHV_MOD_LGLEAK3 1210 +#define HSMHV_MOD_LGLEAK6 1213 +#define HSMHV_MOD_LGLKSD1 1215 +#define HSMHV_MOD_LGLKSD2 1216 +#define HSMHV_MOD_LGLKB1 1218 +#define HSMHV_MOD_LGLKB2 1219 +#define HSMHV_MOD_LNFTRP 1258 +#define HSMHV_MOD_LNFALP 1259 +#define HSMHV_MOD_LPTHROU 1253 +#define HSMHV_MOD_LVDIFFJ 1254 +#define HSMHV_MOD_LIBPC1 1404 +#define HSMHV_MOD_LIBPC2 1405 +#define HSMHV_MOD_LCGBO 1156 +#define HSMHV_MOD_LCVDSOVER 1480 +#define HSMHV_MOD_LFALPH 1263 +#define HSMHV_MOD_LNPEXT 1242 +#define HSMHV_MOD_LPOWRAT 1463 +#define HSMHV_MOD_LRD 1399 +#define HSMHV_MOD_LRD22 1442 +#define HSMHV_MOD_LRD23 1443 +#define HSMHV_MOD_LRD24 1444 +#define HSMHV_MOD_LRDICT1 1316 +#define HSMHV_MOD_LRDOV13 1476 +#define HSMHV_MOD_LRDSLP1 1315 +#define HSMHV_MOD_LRDVB 1301 +#define HSMHV_MOD_LRDVD 1510 +#define HSMHV_MOD_LRDVG11 1424 +#define HSMHV_MOD_LRS 1398 +#define HSMHV_MOD_LRTH0 1432 +#define HSMHV_MOD_LVOVER 1199 + +/* Width dependence */ +#define HSMHV_MOD_WVMAX 2100 +#define HSMHV_MOD_WBGTMP1 2101 +#define HSMHV_MOD_WBGTMP2 2102 +#define HSMHV_MOD_WEG0 2103 +#define HSMHV_MOD_WVFBOVER 2428 +#define HSMHV_MOD_WNOVER 2430 +#define HSMHV_MOD_WNOVERS 2431 +#define HSMHV_MOD_WWL2 2407 +#define HSMHV_MOD_WVFBC 2121 +#define HSMHV_MOD_WNSUBC 2123 +#define HSMHV_MOD_WNSUBP 2181 +#define HSMHV_MOD_WSCP1 2184 +#define HSMHV_MOD_WSCP2 2185 +#define HSMHV_MOD_WSCP3 2186 +#define HSMHV_MOD_WSC1 2126 +#define HSMHV_MOD_WSC2 2127 +#define HSMHV_MOD_WSC3 2128 +#define HSMHV_MOD_WPGD1 2187 +#define HSMHV_MOD_WPGD3 2189 +#define HSMHV_MOD_WNDEP 2129 +#define HSMHV_MOD_WNINV 2130 +#define HSMHV_MOD_WMUECB0 2131 +#define HSMHV_MOD_WMUECB1 2132 +#define HSMHV_MOD_WMUEPH1 2133 +#define HSMHV_MOD_WVTMP 2141 +#define HSMHV_MOD_WWVTH0 2142 +#define HSMHV_MOD_WMUESR1 2143 +#define HSMHV_MOD_WMUETMP 2195 +#define HSMHV_MOD_WSUB1 2151 +#define HSMHV_MOD_WSUB2 2152 +#define HSMHV_MOD_WSVDS 2286 +#define HSMHV_MOD_WSVBS 2284 +#define HSMHV_MOD_WSVGS 2283 +#define HSMHV_MOD_WFN1 2294 +#define HSMHV_MOD_WFN2 2295 +#define HSMHV_MOD_WFN3 2296 +#define HSMHV_MOD_WFVBS 2297 +#define HSMHV_MOD_WNSTI 2225 +#define HSMHV_MOD_WWSTI 2226 +#define HSMHV_MOD_WSCSTI1 2229 +#define HSMHV_MOD_WSCSTI2 2230 +#define HSMHV_MOD_WVTHSTI 2232 +#define HSMHV_MOD_WMUESTI1 2235 +#define HSMHV_MOD_WMUESTI2 2236 +#define HSMHV_MOD_WMUESTI3 2237 +#define HSMHV_MOD_WNSUBPSTI1 2238 +#define HSMHV_MOD_WNSUBPSTI2 2239 +#define HSMHV_MOD_WNSUBPSTI3 2240 +#define HSMHV_MOD_WCGSO 2154 +#define HSMHV_MOD_WCGDO 2155 +#define HSMHV_MOD_WJS0 2157 +#define HSMHV_MOD_WJS0SW 2158 +#define HSMHV_MOD_WNJ 2159 +#define HSMHV_MOD_WCISBK 2172 +#define HSMHV_MOD_WCLM1 2191 +#define HSMHV_MOD_WCLM2 2192 +#define HSMHV_MOD_WCLM3 2193 +#define HSMHV_MOD_WWFC 2201 +#define HSMHV_MOD_WGIDL1 2205 +#define HSMHV_MOD_WGIDL2 2206 +#define HSMHV_MOD_WGLEAK1 2208 +#define HSMHV_MOD_WGLEAK2 2209 +#define HSMHV_MOD_WGLEAK3 2210 +#define HSMHV_MOD_WGLEAK6 2213 +#define HSMHV_MOD_WGLKSD1 2215 +#define HSMHV_MOD_WGLKSD2 2216 +#define HSMHV_MOD_WGLKB1 2218 +#define HSMHV_MOD_WGLKB2 2219 +#define HSMHV_MOD_WNFTRP 2258 +#define HSMHV_MOD_WNFALP 2259 +#define HSMHV_MOD_WPTHROU 2253 +#define HSMHV_MOD_WVDIFFJ 2254 +#define HSMHV_MOD_WIBPC1 2404 +#define HSMHV_MOD_WIBPC2 2405 +#define HSMHV_MOD_WCGBO 2156 +#define HSMHV_MOD_WCVDSOVER 2480 +#define HSMHV_MOD_WFALPH 2263 +#define HSMHV_MOD_WNPEXT 2242 +#define HSMHV_MOD_WPOWRAT 2463 +#define HSMHV_MOD_WRD 2399 +#define HSMHV_MOD_WRD22 2442 +#define HSMHV_MOD_WRD23 2443 +#define HSMHV_MOD_WRD24 2444 +#define HSMHV_MOD_WRDICT1 2316 +#define HSMHV_MOD_WRDOV13 2476 +#define HSMHV_MOD_WRDSLP1 2315 +#define HSMHV_MOD_WRDVB 2301 +#define HSMHV_MOD_WRDVD 2510 +#define HSMHV_MOD_WRDVG11 2424 +#define HSMHV_MOD_WRS 2398 +#define HSMHV_MOD_WRTH0 2432 +#define HSMHV_MOD_WVOVER 2199 + +/* Cross-term dependence */ +#define HSMHV_MOD_PVMAX 3100 +#define HSMHV_MOD_PBGTMP1 3101 +#define HSMHV_MOD_PBGTMP2 3102 +#define HSMHV_MOD_PEG0 3103 +#define HSMHV_MOD_PVFBOVER 3428 +#define HSMHV_MOD_PNOVER 3430 +#define HSMHV_MOD_PNOVERS 3431 +#define HSMHV_MOD_PWL2 3407 +#define HSMHV_MOD_PVFBC 3121 +#define HSMHV_MOD_PNSUBC 3123 +#define HSMHV_MOD_PNSUBP 3181 +#define HSMHV_MOD_PSCP1 3184 +#define HSMHV_MOD_PSCP2 3185 +#define HSMHV_MOD_PSCP3 3186 +#define HSMHV_MOD_PSC1 3126 +#define HSMHV_MOD_PSC2 3127 +#define HSMHV_MOD_PSC3 3128 +#define HSMHV_MOD_PPGD1 3187 +#define HSMHV_MOD_PPGD3 3189 +#define HSMHV_MOD_PNDEP 3129 +#define HSMHV_MOD_PNINV 3130 +#define HSMHV_MOD_PMUECB0 3131 +#define HSMHV_MOD_PMUECB1 3132 +#define HSMHV_MOD_PMUEPH1 3133 +#define HSMHV_MOD_PVTMP 3141 +#define HSMHV_MOD_PWVTH0 3142 +#define HSMHV_MOD_PMUESR1 3143 +#define HSMHV_MOD_PMUETMP 3195 +#define HSMHV_MOD_PSUB1 3151 +#define HSMHV_MOD_PSUB2 3152 +#define HSMHV_MOD_PSVDS 3286 +#define HSMHV_MOD_PSVBS 3284 +#define HSMHV_MOD_PSVGS 3283 +#define HSMHV_MOD_PFN1 3294 +#define HSMHV_MOD_PFN2 3295 +#define HSMHV_MOD_PFN3 3296 +#define HSMHV_MOD_PFVBS 3297 +#define HSMHV_MOD_PNSTI 3225 +#define HSMHV_MOD_PWSTI 3226 +#define HSMHV_MOD_PSCSTI1 3229 +#define HSMHV_MOD_PSCSTI2 3230 +#define HSMHV_MOD_PVTHSTI 3232 +#define HSMHV_MOD_PMUESTI1 3235 +#define HSMHV_MOD_PMUESTI2 3236 +#define HSMHV_MOD_PMUESTI3 3237 +#define HSMHV_MOD_PNSUBPSTI1 3238 +#define HSMHV_MOD_PNSUBPSTI2 3239 +#define HSMHV_MOD_PNSUBPSTI3 3240 +#define HSMHV_MOD_PCGSO 3154 +#define HSMHV_MOD_PCGDO 3155 +#define HSMHV_MOD_PJS0 3157 +#define HSMHV_MOD_PJS0SW 3158 +#define HSMHV_MOD_PNJ 3159 +#define HSMHV_MOD_PCISBK 3172 +#define HSMHV_MOD_PCLM1 3191 +#define HSMHV_MOD_PCLM2 3192 +#define HSMHV_MOD_PCLM3 3193 +#define HSMHV_MOD_PWFC 3201 +#define HSMHV_MOD_PGIDL1 3205 +#define HSMHV_MOD_PGIDL2 3206 +#define HSMHV_MOD_PGLEAK1 3208 +#define HSMHV_MOD_PGLEAK2 3209 +#define HSMHV_MOD_PGLEAK3 3210 +#define HSMHV_MOD_PGLEAK6 3213 +#define HSMHV_MOD_PGLKSD1 3215 +#define HSMHV_MOD_PGLKSD2 3216 +#define HSMHV_MOD_PGLKB1 3218 +#define HSMHV_MOD_PGLKB2 3219 +#define HSMHV_MOD_PNFTRP 3258 +#define HSMHV_MOD_PNFALP 3259 +#define HSMHV_MOD_PPTHROU 3253 +#define HSMHV_MOD_PVDIFFJ 3254 +#define HSMHV_MOD_PIBPC1 3404 +#define HSMHV_MOD_PIBPC2 3405 +#define HSMHV_MOD_PCGBO 3156 +#define HSMHV_MOD_PCVDSOVER 3480 +#define HSMHV_MOD_PFALPH 3263 +#define HSMHV_MOD_PNPEXT 3242 +#define HSMHV_MOD_PPOWRAT 3463 +#define HSMHV_MOD_PRD 3399 +#define HSMHV_MOD_PRD22 3442 +#define HSMHV_MOD_PRD23 3443 +#define HSMHV_MOD_PRD24 3444 +#define HSMHV_MOD_PRDICT1 3316 +#define HSMHV_MOD_PRDOV13 3476 +#define HSMHV_MOD_PRDSLP1 3315 +#define HSMHV_MOD_PRDVB 3301 +#define HSMHV_MOD_PRDVD 3510 +#define HSMHV_MOD_PRDVG11 3424 +#define HSMHV_MOD_PRS 3398 +#define HSMHV_MOD_PRTH0 3432 +#define HSMHV_MOD_PVOVER 3199 + +/* device requests */ +#define HSMHV_DNODE 341 +#define HSMHV_GNODE 342 +#define HSMHV_SNODE 343 +#define HSMHV_BNODE 344 +/* #define HSMHV_TEMPNODE 345 not used */ +#define HSMHV_DNODEPRIME 346 +#define HSMHV_SNODEPRIME 347 +/* #define HSMHV_BNODEPRIME 395 not used */ +/* #define HSMHV_DBNODE 396 not used */ +/* #define HSMHV_SBNODE 397 not used */ +/* #define HSMHV_VBD 347 */ +#define HSMHV_VBD 466 +#define HSMHV_VBS 348 +#define HSMHV_VGS 349 +#define HSMHV_VDS 350 +#define HSMHV_CD 351 +#define HSMHV_CBS 352 +#define HSMHV_CBD 353 +#define HSMHV_GM 354 +#define HSMHV_GDS 355 +#define HSMHV_GMBS 356 +#define HSMHV_GMT 465 +/* #define HSMHV_ISUBT 466 */ +#define HSMHV_GBD 357 +#define HSMHV_GBS 358 +#define HSMHV_QB 359 +#define HSMHV_CQB 360 +/* #define HSMHV_QTH 467 not used */ +/* #define HSMHV_CQTH 468 not used */ +/* #define HSMHV_CTH 469 not used */ +#define HSMHV_QG 361 +#define HSMHV_CQG 362 +#define HSMHV_QD 363 +#define HSMHV_CQD 364 +#define HSMHV_CGG 365 +#define HSMHV_CGD 366 +#define HSMHV_CGS 367 +#define HSMHV_CBG 368 +#define HSMHV_CAPBD 369 +/* #define HSMHV_CQBD 370 not used */ +#define HSMHV_CAPBS 371 +/* #define HSMHV_CQBS 372 not used */ +#define HSMHV_CDG 373 +#define HSMHV_CDD 374 +#define HSMHV_CDS 375 +#define HSMHV_VON 376 +#define HSMHV_VDSAT 377 +#define HSMHV_QBS 378 +#define HSMHV_QBD 379 +#define HSMHV_SOURCECONDUCT 380 +#define HSMHV_DRAINCONDUCT 381 +#define HSMHV_CBDB 382 +#define HSMHV_CBSB 383 +#define HSMHV_MOD_RBPB 389 +#define HSMHV_MOD_RBPD 390 +#define HSMHV_MOD_RBPS 391 +#define HSMHV_MOD_RBDB 392 +#define HSMHV_MOD_RBSB 393 +#define HSMHV_MOD_GBMIN 394 + +#define HSMHV_ISUB 410 +#define HSMHV_IGIDL 411 +#define HSMHV_IGISL 412 +#define HSMHV_IGD 413 +#define HSMHV_IGS 414 +#define HSMHV_IGB 415 +#define HSMHV_CGSO 416 +#define HSMHV_CGBO 417 +#define HSMHV_CGDO 418 + +#define HSMHV_MOD_TCJBD 92 +#define HSMHV_MOD_TCJBS 93 +#define HSMHV_MOD_TCJBDSW 94 +#define HSMHV_MOD_TCJBSSW 95 +#define HSMHV_MOD_TCJBDSWG 96 +#define HSMHV_MOD_TCJBSSWG 97 + + +#include "hsmhvext.h" + +/* Prototype has to be adapted! +#ifdef __STDC__ +extern void HSMHVevaluate(double,double,double,HSMHVinstance*,HSMHVmodel*, + double*,double*,double*, double*, double*, double*, double*, + double*, double*, double*, double*, double*, double*, double*, + double*, double*, double*, double*, CKTcircuit*); +#else +extern void HSMHVevaluate(); +#endif +*/ + +#endif /*HSMHV*/ + diff --git a/src/spicelib/devices/hisimhv/hsmhvdel.c b/src/spicelib/devices/hisimhv/hsmhvdel.c new file mode 100644 index 000000000..87b38b847 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvdel.c @@ -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 +#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); +} diff --git a/src/spicelib/devices/hisimhv/hsmhvdest.c b/src/spicelib/devices/hisimhv/hsmhvdest.c new file mode 100644 index 000000000..ea1ec628e --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvdest.c @@ -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 +#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; +} + diff --git a/src/spicelib/devices/hisimhv/hsmhveval.c b/src/spicelib/devices/hisimhv/hsmhveval.c new file mode 100644 index 000000000..a3b52c8e2 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhveval.c @@ -0,0 +1,6393 @@ +/*********************************************************************** + + 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.c + + DATE : 2010.11.02 + + released by + Hiroshima University & + Semiconductor Technology Academic Research Center (STARC) +***********************************************************************/ + +/********************************************************************** + +The following source code, and all copyrights, trade secrets or other +intellectual property rights in and to the source code in its entirety, +is owned by the Hiroshima University and the STARC organization. + +All users need to follow the "HISIM_HV Distribution Statement and +Copyright Notice" attached to HiSIM_HV model. + +-----HISIM_HV Distribution Statement and Copyright Notice-------------- + Hiroshima University and/or Semiconductor Technology Academic Research +Center ("STARC") grants to Licensee a worldwide, royalty-free, +sub-licensable, retroactive, perpetual, irrevocable license to make, +have made, offer to sell, sell, import, export, use, copy, redistribute, +perform, display and incorporate HiSIM_HV intellectual property (the +"License") subject to the conditions set forth below. + This License includes rights to use and modify copyrighted material +for any purpose if the copyright is acknowledged as well as the use of +related patents which STARC owns, has applied for or will apply for +in connection with HiSIM_HV intellectual property for the purpose of +implementing and using he HiSIM_HV intellectual property in connection +with the standard. This license applies to all past and future versions +of HiSIM_HV. + +1. HiSIM_HV intellectual property is offered "as is" without any warranty, +explicit or implied, or service support. Hiroshima University, STARC, +its University staff and employees assume no liability for the quality +and performance of HiSIM_HV intellectual property. + +2. As the owner of the HiSIM_HV intellectual property, and all other +related rights, Hiroshima University and/or STARC grant the License +as set forth above. + +3. A Licensee may not charge an end user a fee for the HiSIM_HV source +code, which Hiroshima University and STARC own, by itself, however, +a Licensee may charge an end user a fee for alterations or additions +to the HiSIM_HV source code or for maintenance service. + +4. A Licensee of HiSIM_HV intellectual property agrees that Hiroshima +University and STARC are the developers of HiSIM_HV in all products +containing HiSIM_HV and the alteration thereof (subject to Licensee's +ownership of the alterations). +If future versions of HiSIM_HV incorporate elements of other CMC models +the copyrights of those elements remains with the original developers. +For this purpose the copyright notice as shown below shall be used. + +"The HiSIM_HV source code, and all copyrights, trade secrets or other +intellectual property rights in and to the source code, is owned +by Hiroshima University and/or STARC." + +5. A Licensee of HiSIM_HV intellectual property will comply with the +export obligations pertaining to the export of the HiSIM_HV intellectual +property. + +6. The License of patents is limited to the purpose of HiSIM_HV +standardization and implementation of the HiSIM_HV intellectual property +in connection with the standard. +This includes bug fixes, and Licensee modifications (including model +extensions) that are made in connection with the standard, including +all modifications already made by Licensee before the date of this +written document. Licensee modifications of the HiSIM_HV code may be +considered outside the license of patents if they are made for purposes +not connected to implementation of the standard, although these +modifications would still be inside the license of copyrights. + +7. By using HiSIM_HV intellectual property owned by Hiroshima University +and/or STARC, Licensee agrees not to prosecute any patents or patent +held by Licensee that are required for implementation of HiSIM_HV against +any party who is infringing those patents solely by implementing and/or +using the HiSIM_HV standard. + + +Toshimasa Asahara, President, Hiroshima University +Mitiko Miura-Mattausch, Professor, Hiroshima University +Katsuhiro Shimohigashi, President&CEO, STARC +June. 2008 +*************************************************************************/ + +/********************************************************************* +* Memorandum on programming +* +* (1) Bias (x: b|d|g) +* . vxs : Input arguments: Outer branch voltages. +* . vxsi: Input arguments: Inner branch voltages. +* . deltemp: Input argument: delta temperature. +* . Vxse: Internal name for outer branch voltages. +* . Vxs: Internal name for inner branch voltages. +* . Vbscl:Inner bulk source voltage is clamped within a specified region. +* . Y_dVxs denotes the partial derivative of Y w.r.t. Vxs. +* . Y_dVxse denotes the partial derivative of Y w.r.t. Vxse. +* . Y_dT denotes derivatives with respect to deltemp. +* +* (2) Device Mode +* . Normal mode (Vds>=0 for nMOS) is assumed. +* . The sign of Vdse is assumed to be changed simultaneously, if the sign of Vds is changed; +* hence Vdse may become negative even thogh Vds >=0. +* . In case of reverse mode, parent routines have to properly +* transform or interchange inputs and outputs except ones +* related to junction diodes, which are regarded as being +* fixed to the nodal S/D. +* +* (3) Modification for symmetry at Vds=0 +* . Vxsz: Modified bias. (x: b|d|g) +* . Ps0z: Modified Ps0. +* . The following variables are calculated as a function of +* modified biases or potential. +* Tox, Cox, (-- with quantum effect) +* Vth*, dVth*, dPpg, Igate, Igidl, Igisl. +* . The following variables are calculated using a transform +* function. +* Lred +* +* (4) Zones and Cases (terminology) +* +* Chi:=beta*(Ps0-Vbs)= 0 3 5 +* +* Zone: A | D1 | D2 | D3 +* | +* (accumulation)|(depletion) +* | +* Vgs = Vgs_fb Vth +* / / +* Case: Nonconductive / Conductive +* / +* VgVt:=Qn0/Cox= VgVt_small +* +* . Ids is regarded as zero in zone-A. +* . Procedure to calculate Psl and dependent variables is +* omitted in the nonconductive case. Ids and Qi are regarded +* as zero in this case. +* +*********************************************************************/ + +/*===========================================================* +* Preamble. +*=================*/ +/*---------------------------------------------------* +* Header files. +*-----------------*/ +#include +#include +#include +#include +#ifdef __STDC__ +/* #include */ +#endif + +#include "ngspice.h" + +/*-----------------------------------* +* HiSIM macros +*-----------------*/ +#include "hisimhv.h" +#include "hsmhvevalenv.h" +#define C_IDD_MIN 1.0e-15 +#define C_sub_delta 0.1 /* CHECK! */ +#define C_sub_delta2 1.0e-9 /* CHECK! */ +#define C_gidl_delta 0.5 + +/* local variables used in macro functions */ +double TMF0 , TMF1 , TMF2 , TMF3 , TMF4 , TMF5 , TMF6 ; +/*===========================================================* +* pow +*=================*/ +#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 + +/*===========================================================* +* Exp() for PGD. +* - ExpLim(-3)=0 +*=================*/ + +#define Fn_ExpLim( y , x , dx ) { \ + if ( (x) < -3.0 ) { \ + dx = 0.0 ; \ + y = 0.0 ; \ + } else if ( (x) < 0.0 ) { \ + dx = 1.0 + (x) * ( 2 * (1.0/3.0) + (x) * 3 * (1.0/27.0) ) ; \ + y = 1.0 + (x) * ( 1.0 + (x) * ( (1.0/3.0) + (x) * (1.0/27.0) ) ) ; \ + } else { \ + dx = 1.0 + (x) * ( 2 * (1.0/3.0) + (x) * ( 3 * 0.0402052934513951 \ + + (x) * 4 * 0.148148111111111 ) ) ; \ + y = 1.0 + (x) * ( 1.0 + (x) * ( (1.0/3.0) + (x) * ( 0.0402052934513951 \ + + (x) * 0.148148111111111 ) ) ) ; \ + } \ +} + +/*===========================================================* +* Macro Functions for ceiling/flooring/symmetrization. +*=================*/ + +/*---------------------------------------------------* +* smoothUpper: ceiling. +* y = xmax - 0.5 ( arg + sqrt( arg^2 + 4 xmax delta ) ) +* arg = xmax - x - delta +*-----------------*/ + +#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_SU2( y , x , xmax , delta , dy_dx , dy_dxmax ) { \ + TMF1 = ( xmax ) - ( x ) - ( delta ) ; \ + TMF2 = sqrt ( TMF1 * TMF1 + 4.0 * ( xmax ) * ( delta) ) ; \ + dy_dx = 0.5 * ( 1.0 + TMF1 / TMF2 ) ; \ + dy_dxmax = 0.5 * ( 1.0 - ( TMF1 + 2.0 * delta ) / TMF2 ) ; \ + y = ( xmax ) - 0.5 * ( TMF1 + TMF2 ) ; \ + } + + +/*---------------------------------------------------* +* smoothLower: flooring. +* y = xmin + 0.5 ( arg + sqrt( arg^2 + 4 xmin delta ) ) +* arg = x - xmin - delta +*-----------------*/ + +#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 ) ; \ + } + +#define Fn_SL2( y , x , xmin , delta , dy_dx, dy_dxmin ) { \ + TMF1 = ( x ) - ( xmin ) - ( delta ) ; \ + TMF2 = sqrt ( TMF1 * TMF1 + 4.0 * ( xmin ) * ( delta ) ) ; \ + dy_dx = 0.5 * ( 1.0 + TMF1 / TMF2 ) ; \ + dy_dxmin = 0.5 * ( 1.0 - ( TMF1 - 2.0 * delta ) / TMF2 ) ; \ + y = ( xmin ) + 0.5 * ( TMF1 + TMF2 ) ; \ + } + +/*---------------------------------------------------* +* smoothZero: flooring to zero. +* y = 0.5 ( x + sqrt( x^2 + 4 delta^2 ) ) +*-----------------*/ + +#define Fn_SZ( y , x , delta , dx ) { \ + TMF2 = sqrt ( ( x ) * ( x ) + 4.0 * ( delta ) * ( delta) ) ; \ + dx = 0.5 * ( 1.0 + ( x ) / TMF2 ) ; \ + y = 0.5 * ( ( x ) + TMF2 ) ; \ + } + + +/*---------------------------------------------------* +* CeilingPow: ceiling for positive x, flooring for negative x. +* y = x * xmax / ( x^{2m} + xmax^{2m} )^{1/(2m)} +* note: +* - xmax has to be positive. +* - -xmax < y < xmax. +* - dy/dx|_{x=0} = 1. +*-----------------*/ + +#define Fn_CP( y , x , xmax , pw , dx ) { \ + double x2 = (x) * (x) ; \ + double xmax2 = (xmax) * (xmax) ; \ + double xp = 1.0 , xmp = 1.0 ; \ + int m =0, mm =0; \ + double arg =0.0, dnm =0.0; \ + for ( m = 0 ; m < pw ; m ++ ) { xp *= x2 ; xmp *= xmax2 ; } \ + arg = xp + xmp ; \ + dnm = arg ; \ + if ( pw == 1 || pw == 2 || pw == 4 || pw == 8 ) { \ + if ( pw == 1 ) { mm = 1 ; \ + } else if ( pw == 2 ) { mm = 2 ; \ + } else if ( pw == 4 ) { mm = 3 ; \ + } else if ( pw == 8 ) { mm = 4 ; } \ + for ( m = 0 ; m < mm ; m ++ ) { dnm = sqrt( dnm ) ; } \ + } else { dnm = Fn_Pow( dnm , 1.0 / ( 2.0 * pw ) ) ; } \ + dnm = 1.0 / dnm ; \ + y = (x) * (xmax) * dnm ; \ + dx = (xmax) * xmp * dnm / arg ; \ +} + +/*---------------------------------------------------* +* Declining function using a polynomial. +*-----------------*/ + +#define Fn_DclPoly4( y , x , dx ) { \ + TMF2 = (x) * (x) ; \ + TMF3 = TMF2 * (x) ; \ + TMF4 = TMF2 * TMF2 ; \ + y = 1.0 / ( 1.0 + (x) + TMF2 + TMF3 + TMF4 ) ; \ + dx = - ( 1.0 + 2.0 * (x) + 3.0 * TMF2 + 4.0 * TMF3 ) * y * y ; \ +} + +#define Fn_DclPoly6( y , x , dx ) { \ + TMF2 = (x) * (x) ; \ + TMF3 = TMF2 * (x) ; \ + TMF4 = TMF2 * TMF2 ; \ + TMF5 = TMF2 * TMF3 ; \ + TMF6 = TMF3 * TMF3 ; \ + y = 1.0 / ( 1.0 + (x) + TMF2 + TMF3 + TMF4 + TMF5 + TMF6 ) ; \ + dx = - ( 1.0 + 2.0 * (x) + 3.0 * TMF2 + 4.0 * TMF3 \ + + 5.0 * TMF4 + 6.0 * TMF5 ) * y * y ; \ +} + +/*---------------------------------------------------* +* "smoothUpper" using a polynomial +*-----------------*/ + +#define Fn_SUPoly4( y , x , xmax , dx ) { \ + TMF1 = (x) / xmax ; \ + Fn_DclPoly4( y , TMF1 , dx ) ; \ + y = xmax * ( 1.0 - y ) ; \ + dx = - dx ; \ +} + + +#define Fn_SUPoly4m( y , x , xmax , dx , dxmax ) { \ + TMF1 = (x) / xmax ; \ + Fn_DclPoly4( TMF0 , TMF1 , dx ) ; \ + y = xmax * ( 1.0 - TMF0 ) ; \ + dxmax = 1.0 - TMF0 + TMF1 * dx ; \ + dx = - dx ; \ +} + + +#define Fn_SUPoly6m( y , x , xmax , dx , dxmax ) { \ + TMF1 = (x) / xmax ; \ + Fn_DclPoly6( TMF0 , TMF1 , dx ) ; \ + y = xmax * ( 1.0 - TMF0 ) ; \ + dxmax = 1.0 - TMF0 + TMF1 * dx ; \ + dx = - dx ; \ +} + +/*---------------------------------------------------* +* SymAdd: evaluate additional term for symmetry. +*-----------------*/ + +#define Fn_SymAdd( y , x , add0 , dx ) \ +{ \ + TMF1 = 2.0 * ( x ) / ( add0 ) ; \ + TMF2 = 1.0 + TMF1 * ( (1.0/2) + TMF1 * ( (1.0/6) \ + + TMF1 * ( (1.0/24) + TMF1 * ( (1.0/120) \ + + TMF1 * ( (1.0/720) + TMF1 * (1.0/5040) ) ) ) ) ) ; \ + TMF3 = (1.0/2) + TMF1 * ( (1.0/3) \ + + TMF1 * ( (1.0/8) + TMF1 * ( (1.0/30) \ + + TMF1 * ( (1.0/144) + TMF1 * (1.0/840) ) ) ) ) ; \ + y = add0 / TMF2 ; \ + dx = - 2.0 * TMF3 / ( TMF2 * TMF2 ) ; \ +} + +/*===========================================================* +* Function hsmhvevaluate. +*=================*/ +int HSMHVevaluate +( + double Vdse, /* external branch voltage ( Vds >= 0 are assumed -> Vdse might be negative.) */ + double Vgse, /* external branch voltage */ + double Vbse, /* external branch voltage */ + double Vds, /* inner branch voltage */ + double Vgs, /* inner branch voltage */ + double Vbs, /* inner branch voltage */ + double vbs_jct, + double vbd_jct, + double Vsubs, /* substrate-source voltage */ + double deltemp, + HSMHVinstance *here, + HSMHVmodel *model, + CKTcircuit *ckt + ) +{ + HSMHVbinningParam *pParam = &here->pParam ; + HSMHVmodelMKSParam *modelMKS = &model->modelMKS ; + HSMHVhereMKSParam *hereMKS = &here->hereMKS ; + /*-----------------------------------* + * Constants for Smoothing functions + *---------------*/ + const double vth_dlt = 1.0e-3 ; + /* const double cclmmdf = 1.0e-2 ;*/ + const double cclmmdf = 1.0e-1 ; + const double C_cm2m = 1.0e-2 ; + const double qme_dlt = 1.0e-9 * C_cm2m ; + const double rdsl2_dlt = 10.0e-3 * C_cm2m ; + const double rdsu2_dlt = 50.0e-6 * C_cm2m ; + const double rdsz_dlt = 0.1e-3 * C_cm2m ; + const double qme2_dlt = 5.0e-2 ; + const double eef_dlt = 1.0e-2 / C_cm2m ; + const double sti2_dlt = 2.0e-3 ; + const double pol_dlt = 5.0e-2 ; + const double psia_dlt = 1.0e-3 ; + const double psia2_dlt = 5.0e-3 ; + const double psisti_dlt = 5.0e-3 ; + + /*---------------------------------------------------* + * Local variables. + *-----------------*/ + /* Constants ----------------------- */ + const int lp_s0_max = 20 ; + const int lp_sl_max = 40 ; + const double dP_max = 0.1e0 ; + const double ps_conv = 1.0e-12 ; + /* double ps_conv = 1.0e-13 ;*/ + const double gs_conv = 1.0e-8 ; + /** depletion **/ + const double znbd3 = 3.0e0 ; + const double znbd5 = 5.0e0 ; + const double cn_nc3 = C_SQRT_2 / 108e0 ; + /* 5-degree, contact:Chi=5 */ + const double cn_nc51 = 0.707106781186548 ; /* sqrt(2)/2 */ + const double cn_nc52 = -0.117851130197758 ; /* -sqrt(2)/12 */ + const double cn_nc53 = 0.0178800506338833 ; /* (187 - 112*sqrt(2))/1600 */ + const double cn_nc54 = -0.00163730162779191 ; /* (-131 + 88*sqrt(2))/4000 */ + const double cn_nc55 = 6.36964918866352e-5 ; /* (1509-1040*sqrt(2))/600000 */ + /** inversion **/ + /* 3-degree polynomial approx for ( exp[Chi]-1 )^{1/2} */ + const double cn_im53 = 2.9693154855770998e-1 ; + const double cn_im54 = -7.0536542840097616e-2 ; + const double cn_im55 = 6.1152888951331797e-3 ; + /** initial guess **/ + const double c_ps0ini_2 = 8.0e-4 ; + const double c_pslini_1 = 0.3e0 ; + const double c_pslini_2 = 3.0e-2 ; + + const double VgVt_small = 1.0e-12 ; + /* const double Vbs_min = model->HSMHV_vbsmin ; */ + /* const double Vds_max = 10.5e0 ; */ + /* const double Vgs_max = 10.5e0 ; */ + const double epsm10 = 10.0e0 * C_EPS_M ; + const double small = 1.0e-50 ; + const double small2= 1e-12 ; /* for Ra(Vdse) dependence */ + const double c_exp_2 = 7.38905609893065 ; + const double large_arg = log(1.0e100) ; + + double Vbs_max = 0.8e0, Vbs_max_dT =0.0 ; + double Vbs_bnd = 0.4e0, Vbs_bnd_dT =0.0 ; /* start point of positive Vbs bending */ + double Gdsmin = 0.0 ; + double Gjmin = ckt->CKTgmin ; + + /* Internal flags --------------------*/ + int flg_err = 0 ; /* error level */ + int flg_rsrd = 0 ; /* Flag for handling Rs and Rd */ + /* int flg_iprv = 0 ; */ /* Flag for initial guess of Ids -> not necessary any more */ + int flg_pprv = 0 ; /* Flag for initial guesses of Ps0 and Pds */ + int flg_noqi =0; /* Flag for the cases regarding Qi=Qd=0 */ + /* int flg_vbsc = 0 ; */ /* Flag for Vbs confining -> not necessary any more */ + int flg_info = 0 ; + int flg_conv = 0 ; /* Flag for Poisson loop convergence */ + int flg_qme = 0 ; /* Flag for QME */ + int flg_nqs=0 ; /* Flag for NQS calculation */ + + /* Important Variables in HiSIM -------*/ + /* confined bias */ + double Vbscl=0.0, Vbscl_dVbs=0.0, Vbscl_dT=0.0, Vbscl_dVbs_dVbs = 0.0 ; + double Vgp =0.0, Vgp_dVbs =0.0, Vgp_dVds =0.0, Vgp_dVgs =0.0, Vgp_dT =0.0 ; + double Vgs_fb =0.0 ; + /* Ps0 : surface potential at the source side */ + double Ps0 =0.0, Ps0_dVbs =0.0, Ps0_dVds =0.0, Ps0_dVgs =0.0, Ps0_dT =0.0 ; + double Ps0_ini =0.0 ; + double Ps0_iniA =0.0, Ps0_iniA_dVxb =0.0, Ps0_iniA_dVgb =0.0, Ps0_iniA_dT =0.0 ; + double Ps0_iniB =0.0, Ps0_iniB_dVxb =0.0, Ps0_iniB_dVgb =0.0, Ps0_iniB_dT =0.0 ; + /* Psl : surface potential at the drain side */ + double Psl =0.0, Psl_dVbs =0.0, Psl_dVds =0.0, Psl_dVgs =0.0, Psl_dT =0.0 ; + double Psl_lim =0.0, dPlim =0.0 ; + /* Pds := Psl - Ps0 */ + double Pds = 0.0, Pds_dVbs = 0.0, Pds_dVds = 0.0, Pds_dVgs =0.0, Pds_dT =0.0 ; + double Pds_ini =0.0 ; + double Pds_max =0.0 ; + /* iteration numbers of Ps0 and Psl equations. */ + int lp_s0 = 0 , lp_sl = 0 ; + /* Xi0 := beta * ( Ps0 - Vbs ) - 1. */ + double Xi0 =0.0, Xi0_dVbs =0.0, Xi0_dVds =0.0, Xi0_dVgs =0.0, Xi0_dT =0.0 ; + double Xi0p12 =0.0, Xi0p12_dVbs =0.0, Xi0p12_dVds =0.0, Xi0p12_dVgs =0.0, Xi0p12_dT =0.0 ; + double Xi0p32 =0.0, Xi0p32_dVbs =0.0, Xi0p32_dVds =0.0, Xi0p32_dVgs =0.0, Xi0p32_dT =0.0 ; + /* Xil := beta * ( Psl - Vbs ) - 1. */ + double Xil =0.0, Xil_dVbs =0.0, Xil_dVds =0.0, Xil_dVgs =0.0, Xil_dT =0.0 ; + double Xilp12 =0.0, Xilp12_dVbs =0.0, Xilp12_dVds =0.0, Xilp12_dVgs =0.0, Xilp12_dT =0.0 ; + double Xilp32 =0.0, Xilp32_dVbs =0.0, Xilp32_dVds =0.0, Xilp32_dVgs =0.0, Xilp32_dT =0.0 ; + /* modified bias and potential for sym.*/ + double Vbsz =0.0, Vbsz_dVbs =0.0, Vbsz_dVds =0.0, Vbsz_dT =0.0 ; + double Vdsz =0.0, Vdsz_dVbs =0.0, Vdsz_dVds =0.0 ; + double Vgsz =0.0, Vgsz_dVbs =0.0, Vgsz_dVds =0.0, Vgsz_dVgs =0.0 ; + double Vzadd =0.0, Vzadd_dVbs =0.0, Vzadd_dVds = 0.0 ; + double Ps0z =0.0, Ps0z_dVbs =0.0, Ps0z_dVds =0.0, Ps0z_dVgs =0.0, Ps0z_dT =0.0 ; + double Pzadd =0.0, Pzadd_dVbs =0.0, Pzadd_dVds =0.0, Pzadd_dVgs =0.0, Pzadd_dT =0.0 ; + + /* IBPC */ + double dVbsIBPC =0.0, dVbsIBPC_dVbs =0.0, dVbsIBPC_dVds =0.0, dVbsIBPC_dVgs =0.0, dVbsIBPC_dT =0.0 ; + double dG3 =0.0, dG3_dVbs =0.0, dG3_dVds =0.0, dG3_dVgs =0.0, dG3_dT =0.0 ; + double dG4 =0.0, dG4_dVbs =0.0, dG4_dVds =0.0, dG4_dVgs =0.0, dG4_dT =0.0 ; + double dIdd =0.0, dIdd_dVbs =0.0, dIdd_dVds =0.0, dIdd_dVgs =0.0, dIdd_dT =0.0 ; + + double betaWL =0.0, betaWL_dVbs =0.0, betaWL_dVds =0.0, betaWL_dVgs =0.0, betaWL_dT =0.0 ; + + /* Chi := beta * ( Ps{0/l} - Vbs ) */ + double Chi =0.0, Chi_dVbs =0.0, Chi_dVds =0.0, Chi_dVgs =0.0, Chi_dT =0.0 ; + /* Rho := beta * ( Psl - Vds ) */ + double Rho =0.0, Rho_dT =0.0 ; + /* threshold voltage */ + double Vth =0.0 ; + double Vth0 =0.0, Vth0_dVb =0.0, Vth0_dVd =0.0, Vth0_dVg =0.0 ; + /* variation of threshold voltage */ + double dVth =0.0, dVth_dVb =0.0, dVth_dVd =0.0, dVth_dVg =0.0, dVth_dT = 0.0 ; + double dVth0 =0.0 ; + double dVth0_dVb =0.0, dVth0_dVd =0.0, dVth0_dVg =0.0, dVth0_dT =0.0 ; + double dVthSC =0.0 ; + double dVthSC_dVb =0.0, dVthSC_dVd =0.0, dVthSC_dVg =0.0, dVthSC_dT =0.0 ; + double delta0 = 5.0e-3 ; + double Psi_a =0.0, Psi_a_dVg =0.0, Psi_a_dVb =0.0, Psi_a_dVd =0.0, Psi_a_dT =0.0 ; + double Pb20a =0.0, Pb20a_dVg =0.0, Pb20a_dVb =0.0, Pb20a_dVd =0.0, Pb20a_dT =0.0 ; + double Pb20b =0.0, Pb20b_dVg =0.0, Pb20b_dVb =0.0, Pb20b_dVd =0.0, Pb20b_dT =0.0 ; + double dVthW =0.0, dVthW_dVb =0.0, dVthW_dVd =0.0, dVthW_dVg =0.0 ; + /* Alpha and related parameters */ + double Alpha =0.0, Alpha_dVbs =0.0, Alpha_dVds =0.0, Alpha_dVgs =0.0, Alpha_dT =0.0 ; + double Achi =0.0, Achi_dVbs =0.0, Achi_dVds =0.0, Achi_dVgs =0.0, Achi_dT =0.0 ; + double VgVt =0.0, VgVt_dVbs =0.0, VgVt_dVds =0.0, VgVt_dVgs =0.0, VgVt_dT =0.0 ; + double Pslsat =0.0 ; + double Vdsat =0.0 ; + double VdsatS =0.0, VdsatS_dVbs =0.0, VdsatS_dVds =0.0, VdsatS_dVgs =0.0 ; + double Delta =0.0 ; + /* Q_B and capacitances */ + double Qb =0.0, Qb_dVbs =0.0, Qb_dVds =0.0, Qb_dVgs =0.0, Qb_dT=0.0 ; + double Qbu =0.0, Qbu_dVbs =0.0, Qbu_dVds =0.0, Qbu_dVgs =0.0, Qbu_dT =0.0 ; + /* Q_I and capacitances */ + double Qi =0.0, Qi_dVbs =0.0, Qi_dVds =0.0, Qi_dVgs =0.0, Qi_dT=0.0 ; + double Qiu =0.0, Qiu_dVbs =0.0, Qiu_dVds =0.0, Qiu_dVgs =0.0, Qiu_dT =0.0 ; + /* Q_D and capacitances */ + double Qd =0.0, Qd_dVbs =0.0, Qd_dVds =0.0, Qd_dVgs =0.0, Qd_dT =0.0 ; + /* channel current */ + double Ids =0.0, Ids_dVbs =0.0, Ids_dVds =0.0, Ids_dVgs =0.0, Ids_dT =0.0, Ids_dRa =0.0 ; + double Ids0 =0.0, Ids0_dVbs =0.0, Ids0_dVds =0.0, Ids0_dVgs =0.0, Ids0_dT =0.0 ; + /* STI */ + double dVthSCSTI =0.0, dVthSCSTI_dVg =0.0, dVthSCSTI_dVd =0.0, dVthSCSTI_dVb =0.0, dVthSCSTI_dT =0.0 ; + double Vgssti =0.0, Vgssti_dVbs =0.0, Vgssti_dVds =0.0, Vgssti_dVgs =0.0, Vgssti_dT =0.0 ; + double costi0 =0.0 ; + double costi1 =0.0, costi1_dT =0.0 ; + double costi3 =0.0, costi3_dVb =0.0, costi3_dVd =0.0, costi3_dVg =0.0, costi3_dT =0.0 ; + double costi3_dVb_c3 =0.0, costi3_dVd_c3 =0.0, costi3_dVg_c3 =0.0, costi3_dT_c3 =0.0 ; + double costi4 =0.0, costi4_dT =0.0 ; + double costi5 =0.0, costi5_dT =0.0 ; + double costi6 =0.0, costi6_dT =0.0 ; + double costi7 =0.0, costi7_dT =0.0 ; + double Psasti =0.0, Psasti_dVbs =0.0, Psasti_dVds =0.0, Psasti_dVgs =0.0, Psasti_dT =0.0 ; + double Psbsti =0.0, Psbsti_dVbs =0.0, Psbsti_dVds =0.0, Psbsti_dVgs =0.0, Psbsti_dT =0.0 ; + double Psab =0.0, Psab_dVbs =0.0, Psab_dVds =0.0, Psab_dVgs =0.0, Psab_dT =0.0 ; + double Psti =0.0, Psti_dVbs =0.0, Psti_dVds =0.0, Psti_dVgs =0.0, Psti_dT =0.0 ; + double sq1sti =0.0, sq1sti_dVbs =0.0, sq1sti_dVds =0.0, sq1sti_dVgs =0.0, sq1sti_dT =0.0 ; + double sq2sti =0.0, sq2sti_dVbs =0.0, sq2sti_dVds =0.0, sq2sti_dVgs =0.0, sq2sti_dT =0.0 ; + double Qn0sti =0.0, Qn0sti_dVbs =0.0, Qn0sti_dVds =0.0, Qn0sti_dVgs =0.0, Qn0sti_dT =0.0 ; + double Idssti =0.0, Idssti_dVbs =0.0, Idssti_dVds =0.0, Idssti_dVgs =0.0, Idssti_dT=0.0 ; + /* constants */ + double beta =0.0, beta_dT =0.0 ; + double beta_inv =0.0, beta_inv_dT =0.0 ; + double beta2 =0.0 ; + double Pb2 =0.0, Pb2_dT =0.0 ; + double Pb20 =0.0 ; + double Pb2c =0.0 ; + double Vfb =0.0 ; + double c_eox =0.0 ; + double Leff =0.0, Weff =0.0, WeffLD_nf =0.0, Ldrift =0.0 ; + double Ldrift0 =0.0 ; + double q_Nsub =0.0 ; + /* PART-1 */ + /* Accumulation zone */ + double Psa =0.0 ; + double Psa_dVbs =0.0, Psa_dVds =0.0, Psa_dVgs =0.0, Psa_dT =0.0 ; + /* CLM*/ + double Psdl =0.0, Psdl_dVbs =0.0, Psdl_dVds =0.0, Psdl_dVgs =0.0, Psdl_dT =0.0 ; + double Lred =0.0, Lred_dVbs =0.0, Lred_dVds =0.0, Lred_dVgs =0.0, Lred_dT =0.0 ; + double Lch =0.0, Lch_dVbs =0.0, Lch_dVds =0.0, Lch_dVgs =0.0, Lch_dT =0.0 ; + double Wd =0.0, Wd_dVbs =0.0, Wd_dVds =0.0, Wd_dVgs =0.0, Wd_dT =0.0 ; + double Aclm =0.0 ; + /* Pocket Implant */ + double Vthp=0.0, Vthp_dVb=0.0, Vthp_dVd=0.0, Vthp_dVg =0.0, Vthp_dT =0.0 ; + double dVthLP=0.0, dVthLP_dVb=0.0, dVthLP_dVd=0.0, dVthLP_dVg =0.0, dVthLP_dT =0.0 ; + double bs12=0.0, bs12_dVb=0.0, bs12_dVd =0.0, bs12_dVg =0.0 ; + double Qbmm=0.0, Qbmm_dVb=0.0, Qbmm_dVd =0.0, Qbmm_dVg =0.0 ; + double dqb=0.0, dqb_dVb=0.0, dqb_dVg=0.0, dqb_dVd =0.0 ; + double Vdx=0.0, Vdx_dVbs=0.0; + double Vdx2=0.0, Vdx2_dVbs=0.0; + double Pbsum=0.0, Pbsum_dVb=0.0, Pbsum_dVd=0.0, Pbsum_dVg =0.0, Pbsum_dT =0.0 ; + double sqrt_Pbsum =0.0 ; + /* Poly-Depletion Effect */ + const double pol_b = 1.0 ; + double dPpg =0.0, dPpg_dVb =0.0, dPpg_dVd =0.0, dPpg_dVg =0.0, dPpg_dT = 0.0 ; + /* Quantum Effect */ + double Tox =0.0, Tox_dVb =0.0, Tox_dVd =0.0, Tox_dVg =0.0 ; + double dTox =0.0, dTox_dVb =0.0, dTox_dVd =0.0, dTox_dVg =0.0 ; + double Cox =0.0, Cox_dVb =0.0, Cox_dVd =0.0, Cox_dVg =0.0 ; + double Cox_inv =0.0, Cox_inv_dVb =0.0, Cox_inv_dVd =0.0, Cox_inv_dVg =0.0 ; + double Tox0 =0.0, Cox0 =0.0, Cox0_inv =0.0 ; + double Vthq=0.0, Vthq_dVb =0.0, Vthq_dVd =0.0 ; + /* Igate , Igidl , Igisl */ + const double igate_dlt = 1.0e-2 / C_cm2m ; + const double gidlvds_dlt = 1.0e-5 ; + const double gidla = 100.0 ; + double Psdlz =0.0, Psdlz_dVbs =0.0, Psdlz_dVds =0.0, Psdlz_dVgs =0.0, Psdlz_dT =0.0 ; + double Egp12 =0.0, Egp12_dT =0.0 ; + double Egp32 =0.0, Egp32_dT =0.0 ; + double E1 =0.0, E1_dVb =0.0, E1_dVd =0.0, E1_dVg =0.0, E1_dT =0.0 ; + double Etun =0.0, Etun_dVbs =0.0, Etun_dVds =0.0, Etun_dVgs =0.0, Etun_dT =0.0 ; + double Vdsp=0.0, Vdsp_dVd =0.0 ; + double Egidl =0.0, Egidl_dVb =0.0, Egidl_dVd =0.0, Egidl_dVg =0.0, Egidl_dT =0.0 ; + double Egisl =0.0, Egisl_dVb =0.0, Egisl_dVd =0.0, Egisl_dVg =0.0, Egisl_dT =0.0 ; + double Igate =0.0, Igate_dVbs =0.0, Igate_dVds =0.0, Igate_dVgs =0.0, Igate_dT =0.0 ; + double Igs =0.0, Igs_dVbs =0.0, Igs_dVds =0.0, Igs_dVgs =0.0, Igs_dT =0.0 ; + double Igd =0.0, Igd_dVbs =0.0, Igd_dVds =0.0, Igd_dVgs =0.0, Igd_dT =0.0 ; + double Igb =0.0, Igb_dVbs =0.0, Igb_dVds =0.0, Igb_dVgs =0.0, Igb_dT =0.0 ; + double Igidl =0.0, Igidl_dVbs =0.0, Igidl_dVds =0.0, Igidl_dVgs =0.0, Igidl_dT =0.0 ; + double Igisl =0.0, Igisl_dVbs =0.0, Igisl_dVds =0.0, Igisl_dVgs =0.0, Igisl_dT =0.0 ; + double Vdb =0.0, Vsb =0.0 ; + /* connecting function */ + double FD2 =0.0, FD2_dVbs =0.0, FD2_dVds =0.0, FD2_dVgs =0.0, FD2_dT =0.0 ; + double FMDVDS =0.0, FMDVDS_dVbs =0.0, FMDVDS_dVds =0.0, FMDVDS_dVgs =0.0 ; + double FMDVGS =0.0, FMDVGS_dVgs =0.0 ; + double FMDPG =0.0, FMDPG_dVbs =0.0, FMDPG_dVds =0.0, FMDPG_dVgs =0.0 ; + + double cnst0 =0.0, cnst0_dT =0.0; + double cnst1 =0.0, cnst1_dT =0.0; + double cnstCoxi =0.0, cnstCoxi_dVb =0.0, cnstCoxi_dVd =0.0, cnstCoxi_dVg =0.0, cnstCoxi_dT =0.0 ; + double fac1 =0.0, fac1_dVbs =0.0, fac1_dVds =0.0, fac1_dVgs =0.0, fac1_dT =0.0 ; + double fac1p2 =0.0, fac1p2_dT =0.0 ; + double fs01 =0.0, fs01_dVbs =0.0, fs01_dVds =0.0, fs01_dVgs =0.0, fs01_dT =0.0, fs01_dPs0 =0.0 ; + double fs02 =0.0, fs02_dVbs =0.0, fs02_dVds =0.0, fs02_dVgs =0.0, fs02_dT =0.0, fs02_dPs0 =0.0 ; + double fsl1 =0.0, fsl1_dVbs =0.0, fsl1_dVds =0.0, fsl1_dVgs =0.0, fsl1_dT =0.0, fsl1_dPsl =0.0 ; + double fsl2 =0.0, fsl2_dVbs =0.0, fsl2_dVds =0.0, fsl2_dVgs =0.0, fsl2_dT =0.0, fsl2_dPsl =0.0 ; + double cfs1 =0.0, cfs1_dT =0.0 ; + double fb =0.0, fb_dChi =0.0 ; + double fi =0.0, fi_dChi =0.0 ; + double exp_Chi =0.0, exp_Chi_dT =0.0 ; + double exp_Rho =0.0, exp_Rho_dT =0.0 ; + double exp_bVbs =0.0, exp_bVbs_dT =0.0 ; + double exp_bVbsVds =0.0, exp_bVbsVds_dT =0.0 ; + double exp_bPs0 =0.0, exp_bPs0_dT =0.0 ; + double Fs0 =0.0, Fs0_dPs0 =0.0 ; + double Fsl =0.0, Fsl_dPsl =0.0 ; + double dPs0 =0.0, dPsl =0.0 ; + double Qn0 =0.0, Qn0_dVbs =0.0, Qn0_dVds =0.0, Qn0_dVgs =0.0, Qn0_dT =0.0 ; + double Qb0 =0.0, Qb0_dVb =0.0, Qb0_dVd =0.0, Qb0_dVg =0.0, Qb0_dT =0.0 ; + double Qbnm =0.0, Qbnm_dVbs =0.0, Qbnm_dVds =0.0, Qbnm_dVgs =0.0, Qbnm_dT =0.0 ; + double DtPds =0.0, DtPds_dVbs =0.0, DtPds_dVds =0.0, DtPds_dVgs =0.0, DtPds_dT =0.0 ; + double Qinm =0.0, Qinm_dVbs =0.0, Qinm_dVds =0.0, Qinm_dVgs =0.0, Qinm_dT =0.0 ; + double Qidn =0.0, Qidn_dVbs =0.0, Qidn_dVds =0.0, Qidn_dVgs =0.0, Qidn_dT =0.0 ; + double Qdnm =0.0, Qdnm_dVbs =0.0, Qdnm_dVds =0.0, Qdnm_dVgs =0.0, Qdnm_dT =0.0 ; + double Qddn =0.0, Qddn_dVbs =0.0, Qddn_dVds =0.0, Qddn_dVgs =0.0, Qddn_dT =0.0 ; + double Quot =0.0 ; + double Qdrat =0.5, Qdrat_dVbs =0.0, Qdrat_dVds =0.0, Qdrat_dVgs =0.0, Qdrat_dT =0.0 ; + double Idd =0.0, Idd_dVbs =0.0, Idd_dVds =0.0, Idd_dVgs =0.0, Idd_dT =0.0 ; + double Fdd =0.0, Fdd_dVbs =0.0, Fdd_dVds =0.0, Fdd_dVgs =0.0, Fdd_dT =0.0 ; + double Eeff =0.0, Eeff_dVbs =0.0, Eeff_dVds =0.0, Eeff_dVgs =0.0, Eeff_dT =0.0 ; + double Rns =0.0, Rns_dT =0.0 ; + double Mu = 0.0, Mu_dVbs =0.0, Mu_dVds =0.0, Mu_dVgs =0.0, Mu_dT =0.0 ; + double Muun =0.0, Muun_dVbs =0.0, Muun_dVds =0.0, Muun_dVgs =0.0, Muun_dT =0.0 ; + double Ey =0.0, Ey_dVbs =0.0, Ey_dVds =0.0, Ey_dVgs =0.0, Ey_dT =0.0 ; + double Em =0.0, Em_dVbs =0.0, Em_dVds =0.0, Em_dVgs =0.0, Em_dT =0.0 ; + double Vmax =0.0, Vmax_dT =0.0 ; + double Eta =0.0, Eta_dVbs =0.0, Eta_dVds =0.0, Eta_dVgs =0.0, Eta_dT =0.0 ; + double Eta1 =0.0, Eta1_dT =0.0 ; + double Eta1p12 =0.0, Eta1p12_dT =0.0 ; + double Eta1p32 =0.0, Eta1p32_dT =0.0 ; + double Eta1p52 =0.0, Eta1p52_dT =0.0 ; + double Zeta12 =0.0, Zeta12_dT =0.0 ; + double Zeta32 =0.0, Zeta32_dT =0.0 ; + double Zeta52 =0.0, Zeta52_dT =0.0 ; + double F00 =0.0, F00_dVbs =0.0, F00_dVds =0.0, F00_dVgs =0.0, F00_dT =0.0 ; + double F10 =0.0, F10_dVbs =0.0, F10_dVds =0.0, F10_dVgs =0.0, F10_dT =0.0 ; + double F30 =0.0, F30_dVbs =0.0, F30_dVds =0.0, F30_dVgs =0.0, F30_dT =0.0 ; + double F11 =0.0, F11_dVbs =0.0, F11_dVds =0.0, F11_dVgs =0.0, F11_dT =0.0 ; + double Ps0_min =0.0, Ps0_min_dT =0.0 ; + double Acn =0.0, Acn_dVbs =0.0, Acn_dVds =0.0, Acn_dVgs =0.0, Acn_dT =0.0 ; + double Acd =0.0, Acd_dVbs =0.0, Acd_dVds =0.0, Acd_dVgs =0.0, Acd_dT =0.0 ; + double Ac1 =0.0, Ac1_dVbs =0.0, Ac1_dVds =0.0, Ac1_dVgs =0.0, Ac1_dT =0.0 ; + double Ac2 =0.0, Ac2_dVbs =0.0, Ac2_dVds =0.0, Ac2_dVgs =0.0, Ac2_dT =0.0 ; + double Ac3 =0.0, Ac3_dVbs =0.0, Ac3_dVds =0.0, Ac3_dVgs =0.0, Ac3_dT =0.0 ; + double Ac4 =0.0, Ac4_dVbs =0.0, Ac4_dVds =0.0, Ac4_dVgs =0.0, Ac4_dT =0.0 ; + double Ac31 =0.0, Ac31_dVbs =0.0, Ac31_dVds =0.0, Ac31_dVgs =0.0, Ac31_dT =0.0 ; + double Ac41 =0.0, Ac41_dT =0.0 ; + double ninvd_dT =0.0 ; + /* PART-2 (Isub) */ + double Isub =0.0, Isub_dVbs =0.0, Isub_dVds =0.0, Isub_dVgs =0.0, Isub_dT=0.0 ; + double Isub_dVdse = 0.0 ; + double Psislsat =0.0, Psislsat_dVb =0.0, Psislsat_dVd =0.0, Psislsat_dVg =0.0, Psislsat_dT =0.0 ; + double Psisubsat =0.0, Psisubsat_dVb =0.0, Psisubsat_dVd =0.0, Psisubsat_dVg =0.0, Psisubsat_dT =0.0 ; + double Ifn =0.0, Ifn_dVb =0.0, Ifn_dVd=0.0, Ifn_dVg=0.0, Ifn_dT = 0.0 ; + double Eg12=0.0, Eg32 =0.0 ; + /* PART-3 (overlap) */ + /* const double cov_dlt = 1.0e-1 ; */ + /* const double covvgmax = 5.0 ; */ + double cov_slp =0.0, cov_mag =0.0 ; + double Qgos =0.0, Qgos_dVbs =0.0, Qgos_dVds =0.0, Qgos_dVgs =0.0, Qgos_dT =0.0 ; + double Qgod =0.0, Qgod_dVbs =0.0, Qgod_dVds =0.0, Qgod_dVgs =0.0, Qgod_dT =0.0 ; + double Qgbo =0.0, Qgbo_dVbs =0.0, Qgbo_dVds =0.0, Qgbo_dVgs =0.0, Qgbo_dT = 0.0 ; + double Cgdo =0.0, Cgso =0.0, Cgbo_loc =0.0 ; + double Qgso =0.0, Qgso_dVbse =0.0, Qgso_dVdse =0.0, Qgso_dVgse =0.0 ; + double Qgdo =0.0, Qgdo_dVbse =0.0, Qgdo_dVdse =0.0, Qgdo_dVgse =0.0 ; + /* fringe capacitance */ + double Qfd =0.0, Cfd =0.0 ; + double Qfs =0.0, Cfs =0.0 ; + /* Cqy */ + double Ec =0.0, Ec_dVbs =0.0, Ec_dVds =0.0, Ec_dVgs =0.0, Ec_dT =0.0 ; + double Pslk =0.0, Pslk_dVbs =0.0, Pslk_dVds =0.0, Pslk_dVgs =0.0, Pslk_dT =0.0 ; + double Qy =0.0, Qy_dVbs =0.0, Qy_dVds =0.0, Qy_dVgs =0.0, Qy_dT =0.0 ; + /* PART-4 (junction diode) */ + double Ibs =0.0, Gbs =0.0, Gbse =0.0, Ibs_dT =0.0 ; + double Ibd =0.0, Gbd =0.0, Gbde =0.0, Ibd_dT =0.0 ; +/* double Nvtm =0.0 ;*/ + /* junction capacitance */ + double Qbs =0.0, Capbs =0.0, Capbse =0.0, Qbs_dT =0.0 ; + double Qbd =0.0, Capbd =0.0, Capbde =0.0, Qbd_dT =0.0 ; + double czbd =0.0, czbd_dT=0.0 ; + double czbdsw =0.0, czbdsw_dT=0.0 ; + double czbdswg =0.0, czbdswg_dT=0.0 ; + double czbs =0.0, czbs_dT=0.0 ; + double czbssw =0.0, czbssw_dT=0.0 ; + double czbsswg =0.0, czbsswg_dT=0.0 ; + double arg =0.0, sarg =0.0 ; + /* PART-5 (NQS) */ + double tau =0.0, tau_dVbs=0.0, tau_dVds=0.0, tau_dVgs =0.0, tau_dT=0.0 ; + double taub =0.0, taub_dVbs=0.0, taub_dVds=0.0, taub_dVgs =0.0, taub_dT =0.0 ; + /* PART-6 (noise) */ + /* 1/f */ + double NFalp =0.0, NFtrp =0.0, Cit =0.0, Nflic =0.0 ; + /* thermal */ + double Eyd =0.0, Mu_Ave= 0.0, Nthrml =0.0, Mud_hoso =0.0 ; + /* induced gate noise ( Part 0/3 ) */ + double kusai00 =0.0, kusaidd =0.0, kusaiL =0.0, kusai00L =0.0 ; + int flg_ign = 0 ; + double sqrtkusaiL =0.0, kusai_ig =0.0, gds0_ign =0.0, gds0_h2 =0.0, GAMMA =0.0, crl_f =0.0 ; + const double c_sqrt_15 =3.872983346207417e0 ; /* sqrt(15) */ + const double Cox_small =1.0e-6 ; + const double c_16o135 =1.185185185185185e-1 ; /* 16/135 */ + double Nign0 =0.0, MuModA =0.0, MuModB =0.0, correct_w1 =0.0 ; + + /* usage of previously calculated values */ + double vtol_pprv =1.01e-1 ; + double Vbsc_dif =0.0, Vdsc_dif =0.0, Vgsc_dif =0.0, sum_vdif =0.0 ; + double Vbsc_dif2 =0.0, Vdsc_dif2 =0.0, Vgsc_dif2 =0.0, sum_vdif2 =0.0 ; + double dVbs =0.0, dVds =0.0, dVgs =0.0 ; + + /* temporary vars. & derivatives*/ + double TX =0.0, TX_dVbs =0.0, TX_dVds =0.0, TX_dVgs =0.0, TX_dT =0.0 ; + double TY =0.0, TY_dVbs =0.0, TY_dVds =0.0, TY_dVgs =0.0, TY_dT =0.0 ; + double T0 =0.0, T0_dVb =0.0, T0_dVd =0.0, T0_dVg =0.0, T0_dT =0.0 ; + double T1 =0.0, T1_dVb =0.0, T1_dVd =0.0, T1_dVg =0.0, T1_dT =0.0, T1_dVdse_eff =0.0 ; + double T2 =0.0, T2_dVb =0.0, T2_dVd =0.0, T2_dVg =0.0, T2_dT =0.0 ; + double T3 =0.0, T3_dVb =0.0, T3_dVd =0.0, T3_dVg =0.0, T3_dT =0.0 ; + double T4 =0.0, T4_dVb =0.0, T4_dVd =0.0, T4_dVg =0.0, T4_dT =0.0 ; + double T5 =0.0, T5_dVb =0.0, T5_dVd =0.0, T5_dVg =0.0, T5_dT =0.0 ; + double T6 =0.0, T6_dVb =0.0, T6_dVd =0.0, T6_dVg =0.0, T6_dT =0.0 ; + double T7 =0.0, T7_dVb =0.0, T7_dVd =0.0, T7_dVg =0.0, T7_dT =0.0 ; + double T8 =0.0, T8_dVb =0.0, T8_dVd =0.0, T8_dVg =0.0, T8_dT =0.0 ; + double T9 =0.0, T9_dVb =0.0, T9_dVd =0.0, T9_dVg =0.0, T9_dT =0.0, T9_dVdse_eff =0.0 ; + double T10 =0.0, T10_dVb =0.0, T10_dVd =0.0, T10_dVg =0.0, T10_dT =0.0 ; + double T11 =0.0, T11_dT =0.0 ; + double T12 =0.0, T12_dT =0.0 ; + double T15 =0.0, T16 =0.0, T17 =0.0 ; + double T2_dVdse = 0.0, T5_dVdse = 0.0 ; + + int flg_zone =0 ; + double Vfbsft =0.0, Vfbsft_dVbs =0.0, Vfbsft_dVds =0.0, Vfbsft_dVgs =0.0, Vfbsft_dT =0.0 ; + + /* Vdseff */ + double Vdseff =0.0, Vdseff_dVbs =0.0, Vdseff_dVds =0.0, Vdseff_dVgs =0.0, Vdseff_dT =0.0 ; + double Vdsorg =0.0 ; + + /* D/S Overlap Charges: Qovd/Qovs */ + double CVDSOVER =0.0 ; + double Qovdext =0.0, Qovdext_dVbse =0.0, Qovdext_dVdse =0.0, Qovdext_dVgse =0.0, Qovdext_dT =0.0 ; + double Qovsext =0.0, Qovsext_dVbse =0.0, Qovsext_dVdse =0.0, Qovsext_dVgse =0.0, Qovsext_dT =0.0 ; + double Qovd =0.0, Qovd_dVbs =0.0, Qovd_dVds =0.0, Qovd_dVgs =0.0, Qovd_dT =0.0 ; + double Qovs =0.0, Qovs_dVbs =0.0, Qovs_dVds =0.0, Qovs_dVgs =0.0, Qovs_dT =0.0 ; + double QbuLD =0.0, QbuLD_dVbs =0.0, QbuLD_dVds =0.0, QbuLD_dVgs =0.0, QbuLD_dT =0.0 ; + double QbdLD =0.0, QbdLD_dVbs =0.0, QbdLD_dVds =0.0, QbdLD_dVgs =0.0, QbdLD_dT =0.0 ; + double QbsLD =0.0, QbsLD_dVbs =0.0, QbsLD_dVds =0.0, QbsLD_dVgs =0.0, QbsLD_dT =0.0 ; + + /* Vgsz for SCE and PGD */ + double Vbsz2 =0.0, Vbsz2_dVbs =0.0, Vbsz2_dVds =0.0, Vbsz2_dVgs =0.0 ; + double dmpacc =0.0, dmpacc_dVbs =0.0, dmpacc_dVds =0.0, dmpacc_dVgs =0.0 ; + + /* Multiplication factor * number of gate fingers */ + double Mfactor = here->HSMHV_m ; + + + /*-----------------------------------------------------------* + * HiSIM-HV + *-----------------*/ + /* bias-dependent Rd, Rs */ + double Rdrift =0.0, Rdrift_dVbse =0.0, Rdrift_dVdse =0.0, Rdrift_dVgse =0.0, Rdrift_dT =0.0 ; + double Rsdrift =0.0, Rsdrift_dVbse =0.0, Rsdrift_dVdse =0.0, Rsdrift_dVgse =0.0, Rsdrift_dT =0.0 ; + double Rd =0.0, Rd_dVbse =0.0, Rd_dVdse =0.0, Rd_dVgse =0.0, Rd_dT =0.0 ; + double Rs =0.0, Rs_dVbse =0.0, Rs_dVdse =0.0, Rs_dVgse =0.0, Rs_dT =0.0 ; + double Ra =0.0, Ra_dVbse =0.0, Ra_dVdse =0.0, Ra_dVgse =0.0 ; + double Ra_dVbs =0.0, Ra_dVds =0.0, Ra_dVgs =0.0 ; + double Ra_dVdse_eff =0.0 ; + const double delta_rd = 10e-3 * C_cm2m ; + const double Ra_N = 20.0; /* smoothing parameter for Ra */ + const double Res_min = 1.0e-4 ; + double Rd0_dT =0.0, Rs0_dT =0.0, Rdvd_dT =0.0, Rsvd_dT =0.0 ; + double Vdse_eff =0.0, Vdse_eff_dVbse =0.0, Vdse_eff_dVdse =0.0, Vdse_eff_dVgse =0.0, + Vdse_eff_dVbs =0.0, Vdse_eff_dVds =0.0, Vdse_eff_dVgs =0.0 ; + double VdseModeNML =0.0, VdseModeRVS =0.0 ; + double Vbsegmt =0.0, Vdsegmt =0.0, Vgsegmt =0.0 ; + double Vbserev =0.0, Vdserev =0.0, Vgserev =0.0 ; + double Ra_alpha, Ra_beta ; + + /* modified external biases for symmetry */ + double Vzadd_ext_dVd = 0.0 ; + double Vdserevz = 0.0, Vdserevz_dVd = 0.0 ; + double Vgserevz = 0.0, Vgserevz_dVd = 0.0 ; + double Vbserevz = 0.0, Vbserevz_dVd = 0.0 ; + + /* Substrate Effect */ + const double RDVSUB = model->HSMHV_rdvsub ; + const double RDVDSUB = model->HSMHV_rdvdsub ; + const double DDRIFT = model->HSMHV_ddrift ; + const double VBISUB = model->HSMHV_vbisub ; + const double NSUBSUB = modelMKS->HSMHV_nsubsub ; + double Vsubsrev = 0.0 ; + double Wdep = 0.0, Wdep_dVdserev = 0.0, Wdep_dVsubsrev = 0.0 ; + double T1_dVdserev = 0.0, T1_dVsubsrev = 0.0, T6_dVdserev = 0.0, T6_dVsubsrev = 0.0 ; + double Rs_dVsubs = 0.0, Rd_dVsubs = 0.0, Rdrift_dVsubs = 0.0, Rsdrift_dVsubs = 0.0 ; + + + /* temperature-dependent variables for SHE model */ + double TTEMP =0.0, TTEMP0 =0.0 ; + double Tdiff0 = 0.0, Tdiff0_2 = 0.0, Tdiff = 0.0, Tdiff_2 = 0.0 ; + double Eg =0.0, Eg_dT =0.0 ; + double Nin =0.0, Nin_dT =0.0 ; + double js =0.0, js_dT =0.0 ; + double jssw =0.0, jssw_dT =0.0 ; + double js2 =0.0, js2_dT =0.0 ; + double jssw2 =0.0, jssw2_dT =0.0 ; + + /* Qover 5/1 ckt-bias use */ + double Vgbgmt =0.0, Vgbgmt_dVbs =0.0, Vgbgmt_dVds =0.0, Vgbgmt_dVgs =0.0 ; + double Vxbgmt =0.0, Vxbgmt_dVbs =0.0, Vxbgmt_dVds =0.0, Vxbgmt_dVgs =0.0 ; + double Vxbgmtcl =0.0, Vxbgmtcl_dVxbgmt =0.0, Vxbgmtcl_dT =0.0 ; + + double ModeNML =0.0, ModeRVS =0.0 ; + + double QsuLD =0.0, QsuLD_dVbs =0.0, QsuLD_dVds =0.0, QsuLD_dVgs =0.0, QsuLD_dT =0.0 ; + double QiuLD =0.0, QiuLD_dVbs =0.0, QiuLD_dVds =0.0, QiuLD_dVgs =0.0, QiuLD_dT =0.0 ; + double QidLD =0.0, QidLD_dVbs =0.0, QidLD_dVds =0.0, QidLD_dVgs =0.0, QidLD_dT =0.0 ; + double QisLD =0.0, QisLD_dVbs =0.0, QisLD_dVds =0.0, QisLD_dVgs =0.0, QisLD_dT =0.0 ; + + /* Self heating */ + double mphn0_dT =0.0 ; + double ps0ldinib_dT =0.0, cnst0over_dT =0.0 ; + double ps0ldinibs_dT =0.0, cnst0overs_dT =0.0 ; + double Temp_dif =0.0 ; + /* for SCE */ + double ptovr_dT =0.0 ; + + /* IBPC */ + double IdsIBPC =0.0, IdsIBPC_dVbs =0.0, IdsIBPC_dVds =0.0, IdsIBPC_dVgs =0.0, IdsIBPC_dT =0.0 ; + + /* Qover */ + int flg_ovzone = 0 ; + double VgpLD =0.0, VgpLD_dVgb =0.0 ; + double VthLD =0.0, Vgb_fb_LD =0.0 ; + double Ac31_dVgb =0.0, Ac31_dVxb =0.0 ; + double Ac1_dVgb =0.0, Ac1_dVxb =0.0 ; + double Ac2_dVgb =0.0, Ac2_dVxb =0.0 ; + double Ac3_dVgb =0.0, Ac3_dVxb =0.0 ; + double Acn_dVgb =0.0, Acn_dVxb =0.0 ; + double Acd_dVgb =0.0, Acd_dVxb =0.0 ; + double Chi_dVgb =0.0, Chi_dVxb =0.0 ; + double Psa_dVgb =0.0, Psa_dVxb =0.0 ; + double QsuLD_dVgb =0.0, QsuLD_dVxb =0.0 ; + double QbuLD_dVgb =0.0, QbuLD_dVxb =0.0 ; + double fs02_dVgb =0.0, fs02_dVxb =0.0 ; + double TX_dVgb =0.0, TX_dVxb =0.0 ; + double TY_dVgb =0.0, TY_dVxb =0.0 ; + double Ps0LD =0.0, Ps0LD_dVgb =0.0, Ps0LD_dVxb =0.0, Ps0LD_dT =0.0 ; + double Ps0LD_dVds =0.0; + double Pb2over =0.0, Pb2over_dT =0.0 ; + + int flg_overgiven =0 ; + int Coovlps =0, Coovlpd =0 ; + double Lovers =0.0, Loverd =0.0 ; + double Novers =0.0, Noverd =0.0 ; + double Nover_func =0.0 ; + double ps0ldinib_func =0.0, ps0ldinib_func_dT =0.0 ; + double cnst0over_func =0.0, cnst0over_func_dT =0.0 ; + double cnst1over =0.0, cnst1over_dT =0.0; + /* Qover Analytical Model */ + int lp_ld; + double Ta = 9.3868e-3, Tb = -0.1047839 ; + double Tc, Tc_dT ; + double Td, Td_dVxb, Td_dVgb, Td_dT ; + double Tv, Tv_dVxb, Tv_dVgb, Tv_dT ; + double Tu, Tu_dVxb, Tu_dVgb, Tu_dT ; + double Tp, Tp_dT ; + double Tq, Tq_dVxb, Tq_dVgb, Tq_dT ; + double T1_dVxb, T1_dVgb ; +/* double T2_dVxb, T2_dVgb ; + double T3_dVxb, T3_dVgb ;*/ + double T5_dVxb, T5_dVgb ; + double VgpLD_shift, VgpLD_shift_dT ; + double VgpLD_shift_dVgb, VgpLD_shift_dVxb, exp_bVbs_dVxb ; + double gamma, gamma_dVxb, gamma_dT ; + double psi , psi_dVgb , psi_dVxb , psi_dT ; + double Chi_A, Chi_A_dVgb, Chi_A_dVxb, Chi_A_dT ; + double Chi_B, Chi_B_dVgb, Chi_B_dVxb, Chi_B_dT, Chi_B_dpsi , Chi_B_dgamma ; + + /* X_dT for leakage currents & junction diodes */ + double isbd_dT =0.0, isbs_dT =0.0 ; + double isbd2_dT =0.0, isbs2_dT =0.0 ; + double vbdt_dT =0.0, vbst_dT = 0.0 ; + double jd_expcd_dT =0.0 , jd_expcs_dT =0.0 ; + double jd_nvtm_inv_dT =0.0 ; + double exptemp_dT = 0.0 ; + double tcjbd =0.0, tcjbs =0.0, + tcjbdsw =0.0, tcjbssw =0.0, + tcjbdswg =0.0, tcjbsswg =0.0 ; + + /*================ Start of executable code.=================*/ + + + if (here->HSMHV_mode == HiSIM_NORMAL_MODE) { + ModeNML = 1.0 ; + ModeRVS = 0.0 ; + } else { + ModeNML = 0.0 ; + ModeRVS = 1.0 ; + } + + T1 = Vdse + Vgse + Vbse + Vds + Vgs + Vbs + vbd_jct + vbs_jct ; + if ( ! finite (T1) ) { + fprintf (stderr , + "*** warning(HiSIM): Unacceptable Bias(es).\n" ) ; + fprintf (stderr , "----- bias information (HiSIM)\n" ) ; + fprintf (stderr , "name: %s\n" , here->HSMHVname ) ; + fprintf (stderr , "states: %d\n" , here->HSMHVstates ) ; + fprintf (stderr , "Vdse= %.3e Vgse=%.3e Vbse=%.3e\n" + , Vdse , Vgse , Vbse ) ; + fprintf (stderr , "Vdsi= %.3e Vgsi=%.3e Vbsi=%.3e\n" + , Vds , Vgs , Vbs ) ; + fprintf (stderr , "vbs_jct= %12.5e vbd_jct= %12.5e\n" + , vbs_jct , vbd_jct ) ; + fprintf (stderr , "vd= %.3e vs= %.3e vdp= %.3e vgp= %.3e vbp= %.3e vsp= %.3e\n" + , *( ckt->CKTrhsOld + here->HSMHVdNode ) + , *( ckt->CKTrhsOld + here->HSMHVsNode ) + , *( ckt->CKTrhsOld + here->HSMHVdNodePrime ) + , *( ckt->CKTrhsOld + here->HSMHVgNodePrime ) + , *( ckt->CKTrhsOld + here->HSMHVbNodePrime ) + , *( ckt->CKTrhsOld + here->HSMHVsNodePrime ) ) ; + fprintf (stderr , "----- bias information (end)\n" ) ; + return ( HiSIM_ERROR ) ; + } + + flg_info = model->HSMHV_info ; + flg_nqs = model->HSMHV_conqs ; + + /*-----------------------------------------------------------* + * Start of the routine. (label) + *-----------------*/ +/* start_of_routine: +*/ + /*-----------------------------------------------------------* + * Temperature dependent constants. + *-----------------*/ + if ( here->HSMHVtempNode > 0 && pParam->HSMHV_rth0 != 0.0 ) { + +#define HSMHVEVAL +#include "hsmhvtemp_eval.h" + + } else { + beta = here->HSMHV_beta ; + TTEMP = ckt->CKTtemp ; + if ( here->HSMHV_dtemp_Given ) { TTEMP = TTEMP + here->HSMHV_dtemp ; } + Eg_dT = 0.0 ; + beta_dT = 0.0 ; + beta_inv_dT = 0.0 ; + mphn0_dT = 0.0 ; + ptovr_dT = 0.0 ; + Vmax_dT = 0.0 ; + Pb2_dT = 0.0 ; + cnst0_dT = 0.0 ; + cnst1_dT = 0.0 ; + } + + /* Inverse of the thermal voltage */ + beta_inv = here->HSMHV_beta_inv ; + beta2 = here->HSMHV_beta2 ; + + /* Bandgap */ + Egp12 = here->HSMHV_egp12 ; + Egp32 = here->HSMHV_egp32 ; + + /* Metallurgical channel geometry */ + Leff = here->HSMHV_leff ; + Weff = here->HSMHV_weff ; + WeffLD_nf = here->HSMHV_weff_ld * here->HSMHV_nf ; + + Ldrift0 = here->HSMHV_ldrift1 + here->HSMHV_ldrift2 ; + Ldrift = (model->HSMHV_coldrift) ? Ldrift0 + : Ldrift0 + here->HSMHV_loverld ; + + /* Flat band voltage */ + Vfb = pParam->HSMHV_vfbc ; + + /* Surface impurity profile */ + q_Nsub = here->HSMHV_qnsub ; + + /* Velocity Temperature Dependence */ + Vmax = here->HSMHV_vmax ; + + /* 2 phi_B */ + Pb2 = here->HSMHV_pb2 ; + Pb20 = here->HSMHV_pb20 ; + Pb2c = here->HSMHV_pb2c ; + + /* Coefficient of the F function for bulk charge */ + cnst0 = here->HSMHV_cnst0 ; + + /* cnst1: n_{p0} / p_{p0} */ + cnst1 = here->HSMHV_cnst1 ; + + /* c_eox: Permitivity in ox */ + c_eox = here->HSMHV_cecox ; + + /* Tox and Cox without QME */ + Tox0 = model->HSMHV_tox ; + Cox0 = c_eox / Tox0 ; + Cox0_inv = 1.0 / Cox0 ; + + /*---------------------------------------------------* + * Determine clamping limits for too large Vbs (internal). + *-----------------*/ + + if ( Pb2 - model->HSMHV_vzadd0 < Vbs_max ) { + Vbs_max = Pb2 - model->HSMHV_vzadd0 ; + } + if ( Pb20 - model->HSMHV_vzadd0 < Vbs_max ) { + Vbs_max = Pb20 - model->HSMHV_vzadd0 ; + Vbs_max_dT = 0.0 ; + } + if ( Pb2c - model->HSMHV_vzadd0 < Vbs_max ) { + Vbs_max = Pb2c - model->HSMHV_vzadd0 ; + Vbs_max_dT = 0.0 ; + } + + if ( Vbs_bnd > Vbs_max * 0.5 ) { + Vbs_bnd = 0.5 * Vbs_max ; + Vbs_bnd_dT = 0.5 * Vbs_max_dT ; + } + + + if (here->HSMHV_rs > 0.0 || here->HSMHV_rd > 0.0) { + if ( model->HSMHV_corsrd == 1 ) flg_rsrd = 1 ; + if ( model->HSMHV_corsrd == 2 ) flg_rsrd = 2 ; + if ( model->HSMHV_corsrd == 3 ) flg_rsrd = 3 ; + } + + /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + * PART-1: Basic device characteristics. + *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++* + * Prepare for potential initial guesses using previous values + *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + + flg_pprv = 0 ; + + if ( here->HSMHV_called >= 1 ) { + + Vbsc_dif = Vbs - here->HSMHV_vbsc_prv ; + Vdsc_dif = Vds - here->HSMHV_vdsc_prv ; + Vgsc_dif = Vgs- here->HSMHV_vgsc_prv ; + + sum_vdif = fabs( Vbsc_dif ) + fabs( Vdsc_dif ) + + fabs( Vgsc_dif ) ; + + if ( model->HSMHV_copprv >= 1 && sum_vdif <= vtol_pprv && + here->HSMHV_mode * here->HSMHV_mode_prv > 0 ) { flg_pprv = 1 ;} + + if ( here->HSMHV_called >= 2 && flg_pprv == 1 ) { + Vbsc_dif2 = here->HSMHV_vbsc_prv - here->HSMHV_vbsc_prv2 ; + Vdsc_dif2 = here->HSMHV_vdsc_prv - here->HSMHV_vdsc_prv2 ; + Vgsc_dif2 = here->HSMHV_vgsc_prv - here->HSMHV_vgsc_prv2 ; + sum_vdif2 = fabs( Vbsc_dif2 ) + fabs( Vdsc_dif2 ) + + fabs( Vgsc_dif2 ) ; + if ( epsm10 < sum_vdif2 && sum_vdif2 <= vtol_pprv && + here->HSMHV_mode_prv * here->HSMHV_mode_prv2 > 0 ) { flg_pprv = 2 ; } + } + Temp_dif = TTEMP - here->HSMHV_temp_prv ; + + } else { + + Vbsc_dif = 0.0 ; + Vdsc_dif = 0.0 ; + Vgsc_dif = 0.0 ; + sum_vdif = 0.0 ; + Vbsc_dif2 = 0.0 ; + Vdsc_dif2 = 0.0 ; + Vgsc_dif2 = 0.0 ; + sum_vdif2 = 0.0 ; + flg_pprv = 0 ; + Temp_dif = 0.0 ; + } + + dVbs = Vbsc_dif ; + dVds = Vdsc_dif ; + dVgs = Vgsc_dif ; + + if ( flg_pprv >= 1 ) { + Ps0 = here->HSMHV_ps0_prv ; + Ps0_dVbs = here->HSMHV_ps0_dvbs_prv ; + Ps0_dVds = here->HSMHV_ps0_dvds_prv ; + Ps0_dVgs = here->HSMHV_ps0_dvgs_prv ; + + Pds = here->HSMHV_pds_prv ; + Pds_dVbs = here->HSMHV_pds_dvbs_prv ; + Pds_dVds = here->HSMHV_pds_dvds_prv ; + Pds_dVgs = here->HSMHV_pds_dvgs_prv ; + } + + + if ( flg_rsrd == 1 || flg_rsrd == 3 ) { + + /*----------------------------------------------------------* + * Considering these special cases: + * ( here->HSMHV_mode == HiSIM_NORMAL_MODE && Vdse < 0.0 ) + * ( here->HSMHV_mode == HiSIM_REVERSE_MODE && Vdse < 0.0 ) + *----------------------------------------------------------*/ + Vdsegmt = here->HSMHV_mode * Vdse ; /* geometrical outer bias */ + Vgsegmt = Vgse - ModeRVS * Vdse ; /* geometrical outer bias */ + Vbsegmt = Vbse - ModeRVS * Vdse ; /* geometrical outer bias */ + if ( Vdsegmt >= 0.0 ) { /* vdse normal mode */ + VdseModeNML = 1 ; + VdseModeRVS = 0 ; + Vdserev = Vdsegmt ; + Vgserev = Vgsegmt ; + Vbserev = Vbsegmt ; + Vsubsrev = Vsubs ; + } else { /* vdse reverse mode */ + VdseModeNML = 0 ; + VdseModeRVS = 1 ; + Vdserev = - Vdsegmt ; + Vgserev = Vgsegmt - Vdsegmt ; + Vbserev = Vbsegmt - Vdsegmt ; + Vsubsrev = Vsubs - Vdsegmt ; + } + + + if ( here->HSMHV_rdvd > 0.0 || here->HSMHV_rsvd > 0.0 || pParam->HSMHV_rdvg11 > 0.0 || pParam->HSMHV_rdvb > 0.0 || here->HSMHVsubNode >= 0 ) { + /*-----------------------------------------------------------* + * Vxserevz: Modified bias introduced to realize symmetry at Vds=0. + *-----------------*/ + Fn_SymAdd( Vzadd , Vdserev / 2 , model->HSMHV_vzadd0 , T2 ) ; + Vzadd_ext_dVd = T2 / 2 ; + if ( Vzadd < ps_conv ) { + Vzadd = 0.0 ; + Vzadd_ext_dVd = 0.0 ; + } + Vdserevz = Vdserev + 2.0 * Vzadd ; + Vdserevz_dVd = 1.0 + 2.0 * Vzadd_ext_dVd ; + Vgserevz = Vgserev + Vzadd ; + Vgserevz_dVd = Vzadd_ext_dVd ; + Vbserevz = Vbserev + Vzadd ; + Vbserevz_dVd = Vzadd_ext_dVd ; + + + /* bias-dependent Rdrift for HVMOS/LDMOS */ + + if ( model->HSMHV_cosym == 1 || VdseModeNML == 1 ) { /* HVMOS or normal mode LDMOS: */ + /* ... Vdse dependence */ + T1 = VdseModeNML * here->HSMHV_rd + VdseModeRVS * here->HSMHV_rs ; + T1_dT = VdseModeNML * Rd0_dT + VdseModeRVS * Rs0_dT ; + T0 = VdseModeNML * here->HSMHV_rdvd + VdseModeRVS * here->HSMHV_rsvd ; + T0_dT = VdseModeNML * Rdvd_dT + VdseModeRVS * Rsvd_dT ; + T4 = T1 + T0 * Vdserevz ; + T4_dVd = T0 * Vdserevz_dVd ; + T4_dT = T1_dT + T0_dT * Vdserevz ; + + /* ... Vgse dependence */ + T10 = model->HSMHV_rdvg12 + small ; + T1 = T4 * ( 1.0 + pParam->HSMHV_rdvg11 * ( 1.0 - Vgserevz / T10 ) ) ; + T1_dVd = T4_dVd * ( 1.0 + pParam->HSMHV_rdvg11 * ( 1.0 - Vgserevz / T10 ) ) + + T4 * pParam->HSMHV_rdvg11 * ( - Vgserevz_dVd / T10 ) ; + T1_dVg = T4 * pParam->HSMHV_rdvg11 * ( - 1.0 ) / T10 ; + T1_dT = T4_dT * ( 1.0 + pParam->HSMHV_rdvg11 * ( 1.0 - Vgserevz / T10 ) ) ; + Fn_SL2( T2 , T1 , T4 , rdsl2_dlt , T0 , T5 ) ; + T2_dVd = T0 * T1_dVd + T5 * T4_dVd ; + T2_dVg = T0 * T1_dVg ; + T2_dT = T0 * T1_dT + T5 * T4_dT ; + + T3 = T4 * ( 1.0 + pParam->HSMHV_rdvg11 ) ; + T3_dVd = T4_dVd * ( 1.0 + pParam->HSMHV_rdvg11 ) ; + T3_dT = T4_dT * ( 1.0 + pParam->HSMHV_rdvg11 ) ; + Fn_SU2( Rdrift , T2 , T3 , rdsu2_dlt , T0, T5 ) ; + Rdrift_dVdse = T0 * T2_dVd + T5 * T3_dVd ; + Rdrift_dVgse = T0 * T2_dVg ; + Rdrift_dT = T0 * T2_dT + T5 * T3_dT ; + + /* ... Vbse dependence */ + T1 = 1.0 - pParam->HSMHV_rdvb * Vbserevz ; + T1_dVb = - pParam->HSMHV_rdvb ; + T1_dVd = - pParam->HSMHV_rdvb * Vbserevz_dVd ; + Fn_SZ( T3 , T1 , rdsz_dlt , T4 ) ; + T3_dVb = T4 * T1_dVb ; + T3_dVd = T4 * T1_dVd ; + T0 = Rdrift ; + Rdrift = Rdrift * T3 ; + Rdrift_dVdse = Rdrift_dVdse * T3 + T0 * T3_dVd ; + Rdrift_dVgse = Rdrift_dVgse * T3 ; + Rdrift_dVbse = + T0 * T3_dVb ; + Rdrift_dT = Rdrift_dT * T3 ; + + } else { /* reverse mode LDMOS: */ + Rdrift = here->HSMHV_rs ; + Rdrift_dVdse = 0.0 ; + Rdrift_dVgse = 0.0 ; + Rdrift_dVbse = 0.0 ; + Rdrift_dT = Rs0_dT ; + } + + + /* Rsdrift */ + T4 = ( VdseModeNML * here->HSMHV_rs + VdseModeRVS * here->HSMHV_rd ) ; + T4_dT = VdseModeNML * Rs0_dT + VdseModeRVS * Rd0_dT ; + T4_dVd = 0.0 ; + + if ( model->HSMHV_cosym == 1 || VdseModeRVS == 1 ) { /* HVMOS or reverse mode LDMOS: */ + /* ... Vdse dependence */ + T0 = VdseModeNML * here->HSMHV_rsvd + VdseModeRVS * here->HSMHV_rdvd ; + T0_dT = VdseModeNML * Rsvd_dT + VdseModeRVS * Rdvd_dT ; +/* if ( model->HSMHV_cosym == 2 ) { /\* latest case with bugfix: *\/ */ +/* T4 = T4 + T0 * Vdserevz ; */ +/* T4_dVd = T0 * Vdserevz_dVd ; */ +/* T4_dT = T4_dT + T0_dT * Vdserevz ; */ +/* } else { /\* HiSIM_HV 1.1.1 compatible case *\/ */ + T4 = T4 + T0 * ( 2.0 * model->HSMHV_vzadd0 ) ; /* 2.0 * Fn_SymAdd( x=0, add0=model->HSMHV_vzadd0 ) */ + T4_dT = T4_dT + T0_dT * ( 2.0 * model->HSMHV_vzadd0 ) ; +/* } */ + + /* ... Vgse dependence */ + T10 = model->HSMHV_rdvg12 + small ; + T1 = T4 * ( 1.0 + pParam->HSMHV_rdvg11 * ( 1.0 - Vgserevz / T10 ) ) ; + T1_dVd = T4_dVd * ( 1.0 + pParam->HSMHV_rdvg11 * ( 1.0 - Vgserevz / T10 ) ) + + T4 * pParam->HSMHV_rdvg11 * ( - Vgserevz_dVd / T10 ) ; + T1_dVg = T4 * pParam->HSMHV_rdvg11 * ( - 1.0 ) / T10 ; + T1_dT = T4_dT * ( 1.0 + pParam->HSMHV_rdvg11 * ( 1.0 - Vgserevz / T10 ) ) ; + Fn_SL2( T2 , T1 , T4 , rdsl2_dlt , T0 , T5 ) ; + T2_dVd = T0 * T1_dVd + T5 * T4_dVd ; + T2_dVg = T0 * T1_dVg ; + T2_dT = T0 * T1_dT + T5 * T4_dT ; + + T3 = T4 * ( 1.0 + pParam->HSMHV_rdvg11 ) ; + T3_dVd = T4_dVd * ( 1.0 + pParam->HSMHV_rdvg11 ) ; + T3_dT = T4_dT * ( 1.0 + pParam->HSMHV_rdvg11 ) ; + Fn_SU2( Rsdrift , T2 , T3 , rdsu2_dlt , T0, T5 ) ; + Rsdrift_dVdse = T0 * T2_dVd + T5 * T3_dVd ; + Rsdrift_dVgse = T0 * T2_dVg ; + Rsdrift_dT = T0 * T2_dT + T5 * T3_dT ; + + /* ... Vbse dependence */ + T1 = 1.0 - pParam->HSMHV_rdvb * Vbserevz ; + T1_dVb = - pParam->HSMHV_rdvb ; + T1_dVd = - pParam->HSMHV_rdvb * Vbserevz_dVd ; + Fn_SZ( T3 , T1 , rdsz_dlt , T4 ) ; + T3_dVb = T4 * T1_dVb ; + T3_dVd = T4 * T1_dVd ; + T0 = Rsdrift ; + Rsdrift = Rsdrift * T3 ; + Rsdrift_dVdse = Rsdrift_dVdse * T3 + T0 * T3_dVd ; + Rsdrift_dVgse = Rsdrift_dVgse * T3 ; + Rsdrift_dVbse = + T0 * T3_dVb ; + Rsdrift_dT = Rsdrift_dT * T3 ; + } else { /* LDMOS normal mode: */ + Rsdrift = here->HSMHV_rs ; + Rsdrift_dVdse = 0.0 ; + Rsdrift_dVgse = 0.0 ; + Rsdrift_dVbse = 0.0 ; + Rsdrift_dT = Rs0_dT ; + } + + + if ( here->HSMHVsubNode >= 0 && model->HSMHV_cosym == 0 ) { /* external substrate node exists && LDMOS case: */ + /* Substrate Effect */ + T0 = VBISUB - RDVDSUB * Vdserevz - RDVSUB * Vsubsrev ; + Fn_SZ( T1, T0, 10.0, T2 ) ; + T1_dVdserev = - RDVDSUB * Vdserevz_dVd * T2 ; + T1_dVsubsrev = - RDVSUB * T2 ; + + T0 = NSUBSUB / ( pParam->HSMHV_nover * ( NSUBSUB + pParam->HSMHV_nover ) ) ; + T4 = 2 * C_ESI / C_QE * T0 ; + Wdep = sqrt ( T4 * T1 ) + small ; + Wdep_dVdserev = 0.5 * T4 * T1_dVdserev / Wdep ; + Wdep_dVsubsrev = 0.5 * T4 * T1_dVsubsrev / Wdep ; + + Fn_SU( Wdep, Wdep, DDRIFT, C_sub_delta * DDRIFT, T0 ) ; + Wdep_dVdserev *= T0 ; + Wdep_dVsubsrev *= T0 ; + + T0 = DDRIFT - Wdep ; + Fn_SZ( T0, T0, C_sub_delta2, T2 ) ; + T6 = Ldrift0 / T0 ; + T6_dVdserev = T2 * Wdep_dVdserev * T6 / T0 ; + T6_dVsubsrev = T2 * Wdep_dVsubsrev * T6 / T0 ; + + if ( VdseModeNML == 1 ) { /* Vdse normal mode: */ + T0 = Rdrift ; + Rdrift = T0 * T6 ; + Rdrift_dVdse = Rdrift_dVdse * T6 + T0 * T6_dVdserev ; + Rdrift_dVgse = Rdrift_dVgse * T6 ; + Rdrift_dVbse = Rdrift_dVbse * T6 ; + Rdrift_dVsubs= T0 * T6_dVsubsrev ; + Rdrift_dT = Rdrift_dT * T6 ; + } else { /* Vdse reverse mode: */ + T0 = Rsdrift ; + Rsdrift = T0 * T6 ; + Rsdrift_dVdse = Rsdrift_dVdse * T6 + T0 * T6_dVdserev ; + Rsdrift_dVgse = Rsdrift_dVgse * T6 ; + Rsdrift_dVbse = Rsdrift_dVbse * T6 ; + Rsdrift_dVsubs = T0 * T6_dVsubsrev ; + Rsdrift_dT = Rsdrift_dT * T6 ; + } + } + + Rd = Rdrift ; + Rd_dVgse = Rdrift_dVgse ; + Rd_dVdse = Rdrift_dVdse ; + Rd_dVbse = Rdrift_dVbse ; + Rd_dVsubs = Rdrift_dVsubs ; + Rd_dT = Rdrift_dT ; + Rs = Rsdrift ; + Rs_dVgse = Rsdrift_dVgse ; + Rs_dVdse = Rsdrift_dVdse ; + Rs_dVbse = Rsdrift_dVbse ; + Rs_dVsubs = Rsdrift_dVsubs ; + Rs_dT = Rsdrift_dT ; + + } else { /* bias-independent Rs/Rd */ + Rd = VdseModeNML * here->HSMHV_rd + VdseModeRVS * here->HSMHV_rs ; + Rd_dT = VdseModeNML * Rd0_dT + VdseModeRVS * Rs0_dT ; + Rs = VdseModeNML * here->HSMHV_rs + VdseModeRVS * here->HSMHV_rd ; + Rs_dT = VdseModeNML * Rs0_dT + VdseModeRVS * Rd0_dT ; + } + + /* Weff dependence of the resistances */ + Rd = Rd / WeffLD_nf ; + Rd_dVgse /= WeffLD_nf ; + Rd_dVdse /= WeffLD_nf ; + Rd_dVbse /= WeffLD_nf ; + Rd_dVsubs /= WeffLD_nf ; + Rd_dT /= WeffLD_nf ; + Rs = Rs / WeffLD_nf ; + Rs_dVgse /= WeffLD_nf ; + Rs_dVdse /= WeffLD_nf ; + Rs_dVbse /= WeffLD_nf ; + Rs_dT /= WeffLD_nf ; + + /* Sheet resistances are added. */ + Rd += VdseModeNML * here->HSMHV_rd0 + VdseModeRVS * here->HSMHV_rs0 ; + Rs += VdseModeNML * here->HSMHV_rs0 + VdseModeRVS * here->HSMHV_rd0 ; + + /* Re-stamps for hsmhvnoi.c */ + /* Please see hsmhvnoi.c */ + T0 = VdseModeNML * Rd + VdseModeRVS * Rs ; /* mode-dependent --> geometrical */ + if ( T0 > 0.0 && model->HSMHV_cothrml != 0 ) here->HSMHVdrainConductance = Mfactor / T0 ; + else here->HSMHVdrainConductance = 0.0 ; + T0 = VdseModeNML * Rs + VdseModeRVS * Rd ; /* mode-dependent --> geometrical */ + if ( T0 > 0.0 && model->HSMHV_cothrml != 0 ) here->HSMHVsourceConductance = Mfactor / T0 ; + else here->HSMHVsourceConductance = 0.0 ; + + } /* end of case flg_rsrd=1 or flg_rsrd=3 */ + + + + + /* Clamping for Vbs > Vbs_bnd */ + if ( Vbs > Vbs_bnd ) { + T1 = Vbs - Vbs_bnd ; + T2 = Vbs_max - Vbs_bnd ; + T1_dT = - Vbs_bnd_dT ; + T2_dT = Vbs_max_dT - Vbs_bnd_dT ; + + Fn_SUPoly4m( TY , T1 , T2 , Vbscl_dVbs , T0 ) ; + TY_dT = T1_dT * Vbscl_dVbs + T2_dT * T0 ; + + Vbscl = Vbs_bnd + TY ; + Vbscl_dT = Vbs_bnd_dT + TY_dT ; + + T3 = 1 / T2 ; + + /* x/xmax */ + T4 = T1 * T3 ; + T4_dVb = T3 ; + + T5 = T4 * T4; + T5_dVb = 2 * T4_dVb * T4 ; + T15 = 2 * T4_dVb * T4_dVb ; /* T15 = T5_dVb_dVb */ + + T6 = T4 * T5 ; + T6_dVb = T4_dVb * T5 + T4 * T5_dVb ; + T16 = T4_dVb * T5_dVb + T4_dVb * T5_dVb + T4 * T15 ; /* T16 = T6_dVb_dVb */ + + /* T7 = Z T7_dVb = dZ_dVb T17 = dZ_dVb_dVb */ + T7 = 1 + T4 + T5 + T6 + T5 * T5 ; + T7_dVb = T4_dVb + T5_dVb + T6_dVb + 2 * T5_dVb * T5 ; + T17 = T15 + T16 + 2 * T15 * T5 + 2 * T5_dVb * T5_dVb ; + + T8 = T7 * T7 ; + T8_dVb = 2 * T7_dVb * T7 ; + + T9 = 1 / T8 ; + T9_dVb = - T8_dVb * T9 * T9 ; + + Vbscl_dVbs = T2 * T7_dVb * T9 ; + Vbscl_dVbs_dVbs = T2 * ( T17 * T9 + T7_dVb * T9_dVb ) ; + } else { + Vbscl = Vbs ; + Vbscl_dVbs = 1.0 ; + Vbscl_dT = 0.0 ; + Vbscl_dVbs_dVbs = 0.0 ; + } + + /*-----------------------------------------------------------* + * Vxsz: Modified bias introduced to realize symmetry at Vds=0. + *-----------------*/ + + + T1 = Vbscl_dVbs * Vds / 2 ; + Fn_SymAdd( Vzadd , T1 , model->HSMHV_vzadd0 , T2 ) ; + Vzadd_dVbs = T2 * Vbscl_dVbs_dVbs * Vds / 2 ; + T2 *= Vbscl_dVbs / 2 ; + Vzadd_dVds = T2 ; + + if ( Vzadd < ps_conv ) { + Vzadd = 0.0 ; + Vzadd_dVds = 0.0 ; + Vzadd_dVbs = 0.0 ; + } + + Vbsz = Vbscl + Vzadd ; + Vbsz_dVbs = Vbscl_dVbs + Vzadd_dVbs ; + Vbsz_dVds = Vzadd_dVds ; + Vbsz_dT = Vbscl_dT ; + + Vdsz = Vds + 2.0 * Vzadd ; + Vdsz_dVbs = 2.0 * Vzadd_dVbs ; + Vdsz_dVds = 1.0 + 2.0 * Vzadd_dVds ; + + Vgsz = Vgs + Vzadd ; + Vgsz_dVbs = Vzadd_dVbs ; + Vgsz_dVgs = 1.0 ; + Vgsz_dVds = Vzadd_dVds ; + + /*---------------------------------------------------* + * Factor of modification for symmetry. + *-----------------*/ + + T1 = here->HSMHV_qnsub_esi * Cox0_inv * Cox0_inv ; + T2 = Vgs - Vfb ; + T3 = 1 + 2.0 / T1 * ( T2 - 1.0 / here->HSMHV_betatnom - Vbscl ) ; + + Fn_SZ( T4 , T3 , 1e-3 , T5 ) ; + TX = sqrt( T4 ) ; + Pslsat = T2 + T1 * ( 1.0 - TX ) ; + VdsatS = Pslsat - Pb2c ; + Fn_SL( VdsatS , VdsatS , 0.1 , 5e-2 , T6 ) ; + + VdsatS_dVbs = T6 * T5 / TX * Vbscl_dVbs ; + VdsatS_dVds = 0.0 ; + VdsatS_dVgs = T6 * ( 1.0 - T5 / TX ) ; + + T1 = Vds / VdsatS ; + Fn_SUPoly4( TX , T1 , 1.0 , T0 ) ; + FMDVDS = TX * TX ; + T2 = 2 * TX * T0 ; + T3 = T2 / ( VdsatS * VdsatS ) ; + FMDVDS_dVbs = T3 * ( - Vds * VdsatS_dVbs ) ; + FMDVDS_dVds = T3 * ( 1.0 * VdsatS - Vds * VdsatS_dVds ) ; + FMDVDS_dVgs = T3 * ( - Vds * VdsatS_dVgs ) ; + + /*-----------------------------------------------------------* + * Quantum effect + *-----------------*/ + if ( model->HSMHV_flg_qme == 0 ) { + flg_qme = 0 ; + } else { + flg_qme = 1 ; + } + + T1 = here->HSMHV_2qnsub_esi ; + T2 = sqrt( T1 * Pb20 ) ; + Vthq = Pb20 + Vfb + T2 * Cox0_inv ; + Vthq_dVb = 0.0 ; + Vthq_dVd = 0.0 ; + + if ( flg_qme == 0 ) { + Tox = Tox0 ; + Tox_dVb = 0.0 ; + Tox_dVd = 0.0 ; + Tox_dVg = 0.0 ; + + Cox = Cox0 ; + Cox_dVb = 0.0 ; + Cox_dVd = 0.0 ; + Cox_dVg = 0.0 ; + + Cox_inv = Cox0_inv ; + Cox_inv_dVb = 0.0 ; + Cox_inv_dVd = 0.0 ; + Cox_inv_dVg = 0.0 ; + + T0 = cnst0 * cnst0 * Cox_inv ; + cnstCoxi = T0 * Cox_inv ; + cnstCoxi_dVb = 0.0 ; + cnstCoxi_dVd = 0.0 ; + cnstCoxi_dVg = 0.0 ; + cnstCoxi_dT = 2.0 * cnst0 * cnst0_dT * Cox_inv * Cox_inv ; + + } else { + + T1 = - model->HSMHV_qme2 ; + T5 = Vgsz - Vthq - model->HSMHV_qme2 ; + T5_dVb = Vgsz_dVbs - Vthq_dVb ; + T5_dVd = Vgsz_dVds - Vthq_dVd ; + T5_dVg = Vgsz_dVgs ; + Fn_SZ( T2 , - T5 , qme2_dlt, T3) ; + T2_dVb = - T3 * T5_dVb ; + T2_dVd = - T3 * T5_dVd ; + T2_dVg = - T3 * T5_dVg ; + T3 = model->HSMHV_qme12 * T1 * T1 ; + T4 = model->HSMHV_qme12 * T2 * T2 + model->HSMHV_qme3 ; + Fn_SU( dTox , T4 , T3 , qme_dlt , T6 ) ; + T7 = 2 * model->HSMHV_qme12 * T2 * T6 ; + dTox_dVb = T7 * T2_dVb ; + dTox_dVd = T7 * T2_dVd ; + dTox_dVg = T7 * T2_dVg ; + + + if ( dTox * 1.0e12 < Tox0 ) { + dTox = 0.0 ; + dTox_dVb = 0.0 ; + dTox_dVd = 0.0 ; + dTox_dVg = 0.0 ; + flg_qme = 0 ; + } + + Tox = Tox0 + dTox ; + Tox_dVb = dTox_dVb ; + Tox_dVd = dTox_dVd ; + Tox_dVg = dTox_dVg ; + + Cox = c_eox / Tox ; + T1 = - c_eox / ( Tox * Tox ) ; + Cox_dVb = T1 * Tox_dVb ; + Cox_dVd = T1 * Tox_dVd ; + Cox_dVg = T1 * Tox_dVg ; + + Cox_inv = Tox / c_eox ; + T1 = 1.0 / c_eox ; + Cox_inv_dVb = T1 * Tox_dVb ; + Cox_inv_dVd = T1 * Tox_dVd ; + Cox_inv_dVg = T1 * Tox_dVg ; + + T0 = cnst0 * cnst0 * Cox_inv ; + cnstCoxi = T0 * Cox_inv ; + T1 = 2.0 * T0 ; + cnstCoxi_dVb = T1 * Cox_inv_dVb ; + cnstCoxi_dVd = T1 * Cox_inv_dVd ; + cnstCoxi_dVg = T1 * Cox_inv_dVg ; + cnstCoxi_dT = 2.0 * cnst0 * cnst0_dT * Cox_inv * Cox_inv ; + } + + /*---------------------------------------------------* + * Vbsz2 : Vbs for dVth + *-----------------*/ + Vbsz2 = Vbsz ; + Vbsz2_dVbs = Vbsz_dVbs ; + Vbsz2_dVds = Vbsz_dVds ; + Vbsz2_dVgs = 0.0 ; + + /*---------------------------------------------------* + * Vthp : Vth with pocket. + *-----------------*/ + T1 = here->HSMHV_2qnsub_esi ; + Qb0 = sqrt (T1 * (Pb20 - Vbsz2)) ; + T2 = 0.5 * T1 / Qb0 ; + Qb0_dVb = T2 * (- Vbsz2_dVbs) ; + Qb0_dVd = T2 * (- Vbsz2_dVds) ; + Qb0_dVg = T2 * (- Vbsz2_dVgs) ; + + Vthp = Pb20 + Vfb + Qb0 * Cox_inv + here->HSMHV_ptovr; + Vthp_dVb = Qb0_dVb * Cox_inv + Qb0 * Cox_inv_dVb ; + Vthp_dVd = Qb0_dVd * Cox_inv + Qb0 * Cox_inv_dVd ; + Vthp_dVg = Qb0_dVg * Cox_inv + Qb0 * Cox_inv_dVg ; + Vthp_dT = ptovr_dT ; + + if ( pParam->HSMHV_pthrou != 0.0 ) { + /* Modify Pb20 to Pb20b */ + T11 = beta * 0.25 ; + T10 = beta_inv - cnstCoxi * T11 + small ; + T10_dVg = - T11 * cnstCoxi_dVg ; + T10_dVd = - T11 * cnstCoxi_dVd ; + T10_dVb = - T11 * cnstCoxi_dVb ; + T10_dT = beta_inv_dT - ( T11 * cnstCoxi_dT + beta_dT * 0.25 * cnstCoxi ) ; + + T1 = Vgsz - T10 - psia2_dlt ; + T1_dVg = Vgsz_dVgs - T10_dVg ; + T1_dVd = Vgsz_dVds - T10_dVd ; + T1_dVb = Vgsz_dVbs - T10_dVb ; + T1_dT = - T10_dT ; + T0 = Fn_Sgn (T10) ; + T2 = sqrt (T1 * T1 + T0 * 4.0 * T10 * psia2_dlt) ; + T3 = T10 + 0.5 * (T1 + T2) - Vfb ; /* Vgpa for sqrt calc. */ + T4 = T1 / T2 ; + T5 = T0 * 2.0 * psia2_dlt / T2 ; + T3_dVg = T10_dVg + + 0.5 * (T1_dVg + + (T4 * T1_dVg + T5 * T10_dVg ) ) ; + T3_dVd = T10_dVd + + 0.5 * (T1_dVd + + (T4 * T1_dVd + T5 * T10_dVd ) ) ; + T3_dVb = T10_dVb + + 0.5 * (T1_dVb + + (T4 * T1_dVb + T5 * T10_dVb ) ) ; + T3_dT = T10_dT + + 0.5 * (T1_dT + + (T4 * T1_dT + T5 * T10_dT ) ) ; + T4 = 4.0 / cnstCoxi * beta_inv * beta_inv ; + T8 = 4.0 / cnstCoxi ; + T9 = beta_inv * beta_inv ; + T4_dT = - 4.0 * cnstCoxi_dT / ( cnstCoxi * cnstCoxi ) * T9 + + T8 * 2.0 * beta_inv * beta_inv_dT ; + T5 = beta * T3 - 1.0 ; + T5_dT = beta_dT * T3 + beta * T3_dT ; + T6 = T5 / cnstCoxi ; + T1 = 1.0 + T5 * T4 ; + T2 = beta * T4 ; + T6 = T6 * T4 ; + T1_dVg = (T2 * T3_dVg - T6 * cnstCoxi_dVg ) ; + T1_dVd = (T2 * T3_dVd - T6 * cnstCoxi_dVd ) ; + T1_dVb = (T2 * T3_dVb - T6 * cnstCoxi_dVb ) ; + T1_dT = T5_dT * T4 + T5 * T4_dT ; + Fn_SZ( T1 ,T1, psia_dlt, T7) ; + T1 += epsm10 ; + + T1_dVg *= T7 ; + T1_dVd *= T7 ; + T1_dVb *= T7 ; + T1_dT *= T7 ; + + T2 = sqrt (T1) ; + T5 = 0.5 / T2 ; + T2_dVg = T1_dVg * T5 ; + T2_dVd = T1_dVd * T5 ; + T2_dVb = T1_dVb * T5 ; + T2_dT = T1_dT * T5 ; + + T4 = 0.5 * beta ; + Psi_a = T3 + cnstCoxi * T4 * (1.0 - T2) ; + T5 = T4 * (1.0 - T2) ; + T6 = T4 * cnstCoxi ; + Psi_a_dVg = T3_dVg + + (cnstCoxi_dVg * T5 - T6 * T2_dVg) ; + Psi_a_dVd = T3_dVd + + (cnstCoxi_dVd * T5 - T6 * T2_dVd) ; + Psi_a_dVb = T3_dVb + + (cnstCoxi_dVb * T5 - T6 * T2_dVb) ; + Psi_a_dT = T3_dT + + (cnstCoxi_dT * T5 - T6 * T2_dT) + + cnstCoxi * 0.5 * beta_dT * ( 1.0 - T2 ) ; + + Fn_SU( Pb20a , Psi_a, Pb20, delta0, T2) ; + Pb20a_dVb = T2 * Psi_a_dVb ; + Pb20a_dVd = T2 * Psi_a_dVd ; + Pb20a_dVg = T2 * Psi_a_dVg ; + Pb20a_dT = T2 * Psi_a_dT ; + } + + T1 = pParam->HSMHV_pthrou ; + Pb20b = Pb20 + T1 * (Pb20a - Pb20) ; + Pb20b_dVb = T1 * Pb20a_dVb ; + Pb20b_dVd = T1 * Pb20a_dVd ; + Pb20b_dVg = T1 * Pb20a_dVg ; + Pb20b_dT = T1 * Pb20a_dT ; + + T0 = 0.95 ; + T1 = T0 * Pb20b - Vbsz2 - 1.0e-3 ; + T1_dVb = T0 * Pb20b_dVb - Vbsz2_dVbs ; + T1_dVd = T0 * Pb20b_dVd - Vbsz2_dVds ; + T1_dVg = T0 * Pb20b_dVg - Vbsz2_dVgs ; + T1_dT = T0 * Pb20b_dT ; + T2 = sqrt (T1 * T1 + 4.0 * T0 * Pb20b * 1.0e-3) ; + T3 = T0 * Pb20b - 0.5 * (T1 + T2) ; + T4 = 2.0 * T0 * 1.0e-3 ; + T5 = T1 / T2 ; + T6 = T4 / T2 ; + T3_dVb = T0 * Pb20b_dVb + - 0.5 * (T1_dVb + (T1_dVb * T5 + T6 * Pb20b_dVb ) ) ; + T3_dVd = T0 * Pb20b_dVd + - 0.5 * (T1_dVd + (T1_dVd * T5 + T6 * Pb20b_dVd ) ) ; + T3_dVg = T0 * Pb20b_dVg + - 0.5 * (T1_dVg + (T1_dVg * T5 + T6 * Pb20b_dVg ) ) ; + T3_dT = T0 * Pb20b_dT + - 0.5 * (T1_dT + (T1_dT * T5 + T6 * Pb20b_dT ) ) ; + Pbsum = Pb20b - T3 ; + Pbsum_dVb = Pb20b_dVb - T3_dVb ; + Pbsum_dVd = Pb20b_dVd - T3_dVd ; + Pbsum_dVg = Pb20b_dVg - T3_dVg ; + Pbsum_dT = Pb20b_dT - T3_dT ; + + sqrt_Pbsum = sqrt( Pbsum ) ; + + /*-------------------------------------------* + * dVthLP : Short-channel effect induced by pocket. + * - Vth0 : Vth without pocket. + *-----------------*/ + if ( model->HSMHV_lp != 0.0 ) { + T1 = here->HSMHV_2qnsub_esi ; + T2 = model->HSMHV_bs2 - Vbsz2 ; + T3 = T2 + small ; + T4 = sqrt (T3 * T3 + 4.0 * vth_dlt) ; + T5 = 0.5 * (T3 + T4) ; + T6 = 0.5 * (1.0 + T3 / T4) ; + T5_dVb = - Vbsz2_dVbs * T6 ; + T5_dVd = - Vbsz2_dVds * T6 ; + T5_dVg = - Vbsz2_dVgs * T6 ; + T7 = 1.0 / T5 ; + bs12 = model->HSMHV_bs1 * T7 ; + T8 = - bs12 * T7 ; + bs12_dVb = T8 * T5_dVb ; + bs12_dVd = T8 * T5_dVd ; + bs12_dVg = T8 * T5_dVg ; + Fn_SU( T10 , Vbsz2 + bs12, 0.93 * Pb20, vth_dlt, T0) ; + Qbmm = sqrt (T1 * (Pb20 - T10 )) ; + T9 = T0 / Qbmm ; + Qbmm_dVb = 0.5 * T1 * - (Vbsz2_dVbs + bs12_dVb) * T9 ; + Qbmm_dVd = 0.5 * T1 * - (Vbsz2_dVds + bs12_dVd) * T9 ; + Qbmm_dVg = 0.5 * T1 * - (Vbsz2_dVgs + bs12_dVg) * T9 ; + + dqb = (Qb0 - Qbmm) * Cox_inv ; + dqb_dVb = Vthp_dVb - Qbmm_dVb * Cox_inv - Qbmm * Cox_inv_dVb ; + dqb_dVd = Vthp_dVd - Qbmm_dVd * Cox_inv - Qbmm * Cox_inv_dVd ; + dqb_dVg = Vthp_dVg - Qbmm_dVg * Cox_inv - Qbmm * Cox_inv_dVg ; + + T1 = 2.0 * C_QE * pParam->HSMHV_nsubc * C_ESI ; + T2 = sqrt( T1 * ( Pb2c - Vbsz2 ) ) ; + Vth0 = Pb2c + Vfb + T2 * Cox_inv ; + T3 = 0.5 * T1 / T2 * Cox_inv ; + Vth0_dVb = T3 * ( - Vbsz2_dVbs ) + T2 * Cox_inv_dVb ; + Vth0_dVd = T3 * ( - Vbsz2_dVds ) + T2 * Cox_inv_dVd ; + Vth0_dVg = T3 * ( - Vbsz2_dVgs ) + T2 * Cox_inv_dVg ; + + T1 = C_ESI * Cox_inv ; + T2 = here->HSMHV_wdplp ; + T4 = 1.0e0 / ( model->HSMHV_lp * model->HSMHV_lp ) ; + T5 = 2.0e0 * ( model->HSMHV_vbi - Pb20b ) * T1 * T2 * T4 ; + dVth0 = T5 * sqrt_Pbsum ; + T6 = 0.5 * T5 / sqrt_Pbsum ; + T7 = 2.0e0 * ( model->HSMHV_vbi - Pb20b ) * C_ESI * T2 * T4 * sqrt_Pbsum ; + T8 = - 2.0e0 * T1 * T2 * T4 * sqrt_Pbsum ; + dVth0_dVb = T6 * Pbsum_dVb + T7 * Cox_inv_dVb + T8 * Pb20b_dVb ; + dVth0_dVd = T6 * Pbsum_dVd + T7 * Cox_inv_dVd + T8 * Pb20b_dVd ; + dVth0_dVg = T6 * Pbsum_dVg + T7 * Cox_inv_dVg + T8 * Pb20b_dVg ; + dVth0_dT = T6 * Pbsum_dT + T8 * Pb20b_dT ; + + T1 = Vthp - Vth0 ; + T1_dVb = Vthp_dVb - Vth0_dVb ; + T2 = pParam->HSMHV_scp1 + pParam->HSMHV_scp3 * Pbsum / model->HSMHV_lp ; + T2_dVb = pParam->HSMHV_scp3 * Pbsum_dVb / model->HSMHV_lp ; + T3 = T2 + pParam->HSMHV_scp2 * Vdsz ; + T3_dVb = T2_dVb + pParam->HSMHV_scp2 * Vdsz_dVbs ; + + + Vdx = model->HSMHV_scp21 + Vdsz ; + Vdx_dVbs = Vdsz_dVbs ; + Vdx2 = Vdx * Vdx ; + Vdx2_dVbs = 2 * Vdx_dVbs * Vdx ; + + dVthLP = T1 * dVth0 * T3 + dqb - here->HSMHV_msc / Vdx2 ; + dVthLP_dVb = T1_dVb * dVth0 * T3 + T1 * dVth0_dVb * T3 + T1 * dVth0 * T3_dVb + + dqb_dVb + here->HSMHV_msc / Vdx2 /Vdx2 *Vdx2_dVbs; + T4 = T1 * dVth0 * pParam->HSMHV_scp3 / model->HSMHV_lp ; + dVthLP_dVd = (Vthp_dVd - Vth0_dVd) * dVth0 * T3 + T1 * dVth0_dVd * T3 + + T4 * Pbsum_dVd + + T1 * dVth0 * pParam->HSMHV_scp2 * Vdsz_dVds + + dqb_dVd + + 2.0e0 * here->HSMHV_msc * Vdx * Vdsz_dVds / ( Vdx2 * Vdx2 ) ; + dVthLP_dVg = (Vthp_dVg - Vth0_dVg) * dVth0 * T3 + T1 * dVth0_dVg * T3 + + T4 * Pbsum_dVg + dqb_dVg ; + dVthLP_dT = (Vthp_dT ) * dVth0 * T3 + T1 * dVth0_dT * T3 + + T4 * Pbsum_dT ; + } else { + dVthLP = 0.0e0 ; + dVthLP_dVb = 0.0e0 ; + dVthLP_dVd = 0.0e0 ; + dVthLP_dVg = 0.0e0 ; + dVthLP_dT = 0.0e0 ; + } + + /*---------------------------------------------------* + * dVthSC : Short-channel effect induced by Vds. + *-----------------*/ + T1 = C_ESI * Cox_inv ; + T2 = here->HSMHV_wdpl ; + T3 = here->HSMHV_lgate - model->HSMHV_parl2 ; + T4 = 1.0e0 / ( T3 * T3 ) ; + T5 = 2.0e0 * ( model->HSMHV_vbi - Pb20b ) * T1 * T2 * T4 ; + + dVth0 = T5 * sqrt_Pbsum ; + T6 = T5 / 2.0 / sqrt_Pbsum ; + T7 = 2.0e0 * ( model->HSMHV_vbi - Pb20b ) * C_ESI * T2 * T4 * sqrt_Pbsum ; + T8 = - 2.0e0 * T1 * T2 * T4 * sqrt_Pbsum ; + dVth0_dVb = T6 * Pbsum_dVb + T7 * Cox_inv_dVb + T8 * Pb20b_dVb ; + dVth0_dVd = T6 * Pbsum_dVd + T7 * Cox_inv_dVd + T8 * Pb20b_dVd ; + dVth0_dVg = T6 * Pbsum_dVg + T7 * Cox_inv_dVg + T8 * Pb20b_dVg ; + dVth0_dT = T6 * Pbsum_dT + T8 * Pb20b_dT ; + + T1 = pParam->HSMHV_sc3 / here->HSMHV_lgate ; + T4 = pParam->HSMHV_sc1 + T1 * Pbsum ; + T4_dVb = T1 * Pbsum_dVb ; + T4_dVd = T1 * Pbsum_dVd ; + T4_dVg = T1 * Pbsum_dVg ; + T4_dT = T1 * Pbsum_dT ; + + T5 = T4 + pParam->HSMHV_sc2 * Vdsz * ( 1.0 + model->HSMHV_sc4 * Pbsum ); + T5_dVb = T4_dVb + pParam->HSMHV_sc2 * Vdsz * model->HSMHV_sc4 * Pbsum_dVb + + pParam->HSMHV_sc2 * Vdsz_dVbs * model->HSMHV_sc4 * Pbsum; + T5_dVd = T4_dVd + pParam->HSMHV_sc2 * Vdsz_dVds * ( 1.0 + model->HSMHV_sc4 * Pbsum ) + + pParam->HSMHV_sc2 * Vdsz * model->HSMHV_sc4 * Pbsum_dVd; + T5_dVg = T4_dVg + pParam->HSMHV_sc2 * Vdsz * model->HSMHV_sc4 * Pbsum_dVg; + T5_dT = T4_dT + pParam->HSMHV_sc2 * Vdsz * model->HSMHV_sc4 * Pbsum_dT; + + dVthSC = dVth0 * T5 ; + dVthSC_dVb = dVth0_dVb * T5 + dVth0 * T5_dVb ; + dVthSC_dVd = dVth0_dVd * T5 + dVth0 * T5_dVd ; + dVthSC_dVg = dVth0_dVg * T5 + dVth0 * T5_dVg ; + dVthSC_dT = dVth0_dT * T5 + dVth0 * T5_dT ; + + /*---------------------------------------------------* + * dVthW : narrow-channel effect. + *-----------------*/ + T1 = 1.0 / Cox ; + T2 = T1 * T1 ; + T3 = 1.0 / ( Cox + pParam->HSMHV_wfc / Weff ) ; + T4 = T3 * T3 ; + T5 = T1 - T3 ; + T6 = Qb0 * ( T2 - T4 ) ; + + dVthW = Qb0 * T5 + pParam->HSMHV_wvth0 / here->HSMHV_wg ; + dVthW_dVb = Qb0_dVb * T5 - Cox_dVb * T6 ; + dVthW_dVd = Qb0_dVd * T5 - Cox_dVd * T6 ; + dVthW_dVg = - Cox_dVg * T6 ; + + /*---------------------------------------------------* + * dVth : Total variation. + * - Positive dVth means the decrease in Vth. + *-----------------*/ + dVth = dVthSC + dVthLP + dVthW + here->HSMHV_dVthsm ; + dVth_dVb = dVthSC_dVb + dVthLP_dVb + dVthW_dVb ; + dVth_dVd = dVthSC_dVd + dVthLP_dVd + dVthW_dVd ; + dVth_dVg = dVthSC_dVg + dVthLP_dVg + dVthW_dVg ; + dVth_dT = dVthSC_dT + dVthLP_dT ; + + /*---------------------------------------------------* + * Vth : Threshold voltage. + *-----------------*/ + Vth = Vthq - dVth ; + + /*-----------------------------------------------------------* + * Constants in the equation of Ps0 . + *-----------------*/ + + fac1 = cnst0 * Cox_inv ; + fac1_dVbs = cnst0 * Cox_inv_dVb ; + fac1_dVds = cnst0 * Cox_inv_dVd ; + fac1_dVgs = cnst0 * Cox_inv_dVg ; + + fac1p2 = fac1 * fac1 ; + fac1_dT = Cox_inv * cnst0_dT ; + fac1p2_dT = 2.0 * fac1 * fac1_dT ; + + /*---------------------------------------------------* + * Poly-Depletion Effect + *-----------------*/ + + if ( here->HSMHV_flg_pgd == 0 ) { + dPpg = 0.0 ; + dPpg_dVb = 0.0 ; + dPpg_dVd = 0.0 ; + dPpg_dVg = 0.0 ; + dPpg_dT = 0.0 ; + } else { + T7 = Vgs ; + T7_dVd = 0.0 ; + T7_dVg = 1.0 ; + + T8 = Vds ; + T8_dVd = 1.0 ; + + T0 = here->HSMHV_cnstpgd ; + + TX = pParam->HSMHV_pgd3 ; + TY = FMDVDS * TX + ( 1.0 - FMDVDS ) * 0.5 ; + T1 = TX - 0.5 ; + TY_dVbs = T1 * FMDVDS_dVbs ; + TY_dVds = T1 * FMDVDS_dVds ; + TY_dVgs = T1 * FMDVDS_dVgs ; + + FMDVGS = 1.0 ; + FMDVGS_dVgs = 0.0 ; + if ( model->HSMHV_pgd2 > Vfb ) { + T1 = model->HSMHV_pgd2 - Vfb ; + T2 = ( Vgs - Vfb ) / T1 ; + Fn_SZ( T3 , T2 , 1e-3 , T4 ) ; + Fn_SU( T5 , T3 , 1.0 , 1e-3 , T6 ) ; + T5_dVg = T4 * T6 / T1 ; + FMDVGS = T5 * T5 ; + FMDVGS_dVgs = 2 * T5 * T5_dVg ; + } + FMDPG = FMDVDS * FMDVGS ; + FMDPG_dVbs = FMDVDS_dVbs * FMDVGS ; + FMDPG_dVds = FMDVDS_dVds * FMDVGS ; + FMDPG_dVgs = FMDVDS_dVgs * FMDVGS + FMDVDS * FMDVGS_dVgs ; + + + TX = pParam->HSMHV_pgd3 ; + TY = FMDPG * TX + ( 1.0 - FMDPG ) * 0.5 ; + T1 = TX - 0.5 ; + TY_dVbs = T1 * FMDPG_dVbs ; + TY_dVds = T1 * FMDPG_dVds ; + TY_dVgs = T1 * FMDPG_dVgs ; + if ( TX == 0.0 ) TY = TY_dVbs = TY_dVds = TY_dVgs = 0.0 ; + + T3 = T7 - model->HSMHV_pgd2 - TY * T8 ; + T3_dVb = - TY_dVbs * T8 ; + T3_dVd = T7_dVd - ( TY_dVds * T8 + TY * T8_dVd ) ; + T3_dVg = T7_dVg - ( TY_dVgs * T8 ) ; + + Fn_ExpLim( dPpg , T3 , T6 ) ; + dPpg *= T0 ; + dPpg_dVb = T0 * T6 * T3_dVb ; + dPpg_dVd = T0 * T6 * T3_dVd ; + dPpg_dVg = T0 * T6 * T3_dVg ; + dPpg_dT = 0.0 ; + + Fn_SU( dPpg , dPpg , pol_b , pol_dlt , T9 ) ; + dPpg_dVb *= T9 ; + dPpg_dVd *= T9 ; + dPpg_dVg *= T9 ; + dPpg_dT = 0.0 ; + + /* damping in accumulation zone */ + + T0 = Vfb + Vbsz ; + T0_dVb = Vbsz_dVbs ; + T1 = 0.6 * ( Vthq - T0 ) ; + T1_dVb = 0.6 * ( Vthq_dVb - Vbsz_dVbs ) ; + T1_dVd = 0.6 * ( Vthq_dVd - Vbsz_dVds ) ; + Fn_SZ( T1 , T1 , 1e-2 , T2 ) ; + T1_dVb *= T2 ; + T1_dVd *= T2 ; + T1 += T0 ; + T1_dVb += Vbsz_dVbs ; + T4 = 1.0 / ( T1 - T0 ) ; + T5 = T4 * T4 ; + T4_dVb = - ( T1_dVb - Vbsz_dVbs ) * T5 ; + T4_dVd = - ( T1_dVd ) * T5 ; + + T6 = Vgsz - T0 ; + T6_dVb = Vgsz_dVbs - T0_dVb ; + dmpacc = T6 * T4 ; + dmpacc_dVbs = T6 * T4_dVb + T6_dVb * T4 ; + dmpacc_dVds = T6 * T4_dVd + ( Vgsz_dVds - Vbsz_dVds ) * T4 ; + dmpacc_dVgs = Vgsz_dVgs * T4 ; + Fn_SZ( dmpacc , dmpacc , 0.3 , T1 ) ; + dmpacc_dVbs *= T1 ; + dmpacc_dVds *= T1 ; + dmpacc_dVgs *= T1 ; + Fn_SU( dmpacc , dmpacc ,1.0 , 0.1 , T1 ) ; + dmpacc_dVbs *= T1 ; + dmpacc_dVds *= T1 ; + dmpacc_dVgs *= T1 ; + + } + + /*---------------------------------------------------* + * Vgp : Effective gate bias with SCE & RSCE & flatband. + *-----------------*/ + Vgp = Vgs - Vfb + dVth - dPpg ; + Vgp_dVbs = dVth_dVb - dPpg_dVb ; + Vgp_dVds = dVth_dVd - dPpg_dVd ; + Vgp_dVgs = 1.0e0 + dVth_dVg - dPpg_dVg ; + Vgp_dT = dVth_dT - dPpg_dT ; + + + /*---------------------------------------------------* + * Vgs_fb : Actual flatband voltage taking account Vbscl. + * - note: if Vgs == Vgs_fb then Vgp == Ps0 == Vbscl . + *------------------*/ + Vgs_fb = Vfb - dVth + dPpg + Vbscl ; + + + /*---------------------------------------------------* + * Vfbsft : Vfb shift (trial for Vbscl >> 0) + *-----------------*/ + Vfbsft = 0.0 ; + Vfbsft_dVbs = 0.0 ; + Vfbsft_dVds = 0.0 ; + Vfbsft_dVgs = 0.0 ; + + if ( Vbscl > 0.0 ) { + /* values at D2/D3 boundary + beta */ + /* Ps0 */ + T1 = Vbscl + ( znbd5 + 1 ) * beta_inv ; + T1_dT = Vbscl_dT + ( znbd5 + 1 ) * beta_inv_dT ; + /* Qb0 */ + /* T2 = cnst0 * sqrt( znbd5 ) */ + T2 = cnst0 * 2.23606797749979 ; + T2_dT = cnst0_dT * 2.23606797749979 ; + + /* Vgp assuming Qn0=0 */ + T3 = T2 * Cox_inv + T1 ; + T3_dT = T2_dT * Cox_inv + T1_dT ; + + /* Vgp difference */ + TX = T3 - Vgp ; + TX_dVbs = T2 * Cox_inv_dVb + Vbscl_dVbs - Vgp_dVbs ; + TX_dVds = T2 * Cox_inv_dVd - Vgp_dVds ; + TX_dVgs = T2 * Cox_inv_dVg - Vgp_dVgs ; + TX_dT = T3_dT - Vgp_dT ; + + /* set lower limit to 0 */ + Fn_SZ( TX , TX , 0.1 , T4 ) ; + TX_dVbs *= T4 ; + TX_dVds *= T4 ; + TX_dVgs *= T4 ; + TX_dT *= T4 ; + + /* TY: damping factor */ + T1 = 0.5 ; + T5 = Vbscl / T1 ; + T5_dVb = Vbscl_dVbs / T1 ; + T5_dT = Vbscl_dT / T1 ; + T0 = T5 * T5 ; + T6 = T0 * T0 ; + T6_dVb = 4 * T0 * T5 * T5_dVb ; + T6_dT = 4 * T0 * T5 * T5_dT ; + T7 = 1.0 / ( 1.0 + T6 ) ; + T8 = T7 * T7 ; + TY = 1.0 - T7 ; + TY_dVbs = T8 * T6_dVb ; + TY_dT = T8 * T6_dT ; + + TX = TY = 0.0 ; + Vfbsft = TX * TY ; + Vfbsft_dVbs = TX_dVbs * TY + TX * TY_dVbs ; + Vfbsft_dVds = TX_dVds * TY ; + Vfbsft_dVgs = TX_dVgs * TY ; + Vfbsft_dT = TX_dT * TY + TX * TY_dT ; + + Vgs_fb -= Vfbsft ; + + Vgp += Vfbsft ; + Vgp_dVbs += Vfbsft_dVbs ; + Vgp_dVds += Vfbsft_dVds ; + Vgp_dVgs += Vfbsft_dVgs ; + Vgp_dT += Vfbsft_dT ; + + } + + /*-----------------------------------------------------------* + * Accumulation zone. (zone-A) + * - evaluate basic characteristics and exit from this part. + *-----------------*/ + if ( Vgs < Vgs_fb ) { + + flg_zone = -1 ; + + /*---------------------------------------------------* + * Evaluation of Ps0. + * - Psa : Analytical solution of + * Cox( Vgp - Psa ) = cnst0 * Qacc + * where Qacc is the 3-degree series of (fdep)^{1/2}. + * The unkown is transformed to Chi=beta(Ps0-Vbs). + * - Ps0_min : |Ps0_min| when Vbs=0. + *-----------------*/ + Ps0_min = here->HSMHV_eg - Pb2 ; + Ps0_min_dT = Eg_dT - Pb2_dT ; + + TX = beta * ( Vgp - Vbscl ) ; + TX_dVbs = beta * ( Vgp_dVbs - Vbscl_dVbs ) ; + TX_dVds = beta * Vgp_dVds ; + TX_dVgs = beta * Vgp_dVgs ; + TX_dT = beta_dT * ( Vgp - Vbscl ) + beta * ( Vgp_dT - Vbscl_dT ); + + T1 = 1.0 / ( beta * cnst0 ) ; + TY = T1 * Cox ; + TY_dVbs = T1 * Cox_dVb ; + TY_dVds = T1 * Cox_dVd ; + TY_dVgs = T1 * Cox_dVg ; + T1_dT = - T1 / ( beta * cnst0 ) * ( beta_dT * cnst0 + beta * cnst0_dT ) ; + TY_dT = T1_dT * Cox ; + + Ac41 = 2.0 + 3.0 * C_SQRT_2 * TY ; + + Ac4 = 8.0 * Ac41 * Ac41 * Ac41 ; + T1 = 72.0 * Ac41 * Ac41 * C_SQRT_2 ; + Ac4_dVbs = T1 * TY_dVbs ; + Ac4_dVds = T1 * TY_dVds ; + Ac4_dVgs = T1 * TY_dVgs ; + Ac4_dT = T1 * TY_dT ; + + T4 = ( TX - 2.0 ) ; + T5 = 9.0 * TY * T4 ; + T5_dVb = 9.0 * ( TY_dVbs * T4 + TY * TX_dVbs ) ; + T5_dVd = 9.0 * ( TY_dVds * T4 + TY * TX_dVds ) ; + T5_dVg = 9.0 * ( TY_dVgs * T4 + TY * TX_dVgs ) ; + T5_dT = 9.0 * ( TY_dT * T4 + TY * TX_dT ) ; + + + Ac31 = 7.0 * C_SQRT_2 - T5 ; + Ac31_dVbs = -T5_dVb ; + Ac31_dVds = -T5_dVd ; + Ac31_dVgs = -T5_dVg ; + Ac31_dT = -T5_dT ; + + Ac3 = Ac31 * Ac31 ; + T1 = 2.0 * Ac31 ; + Ac3_dVbs = T1 * Ac31_dVbs ; + Ac3_dVds = T1 * Ac31_dVds ; + Ac3_dVgs = T1 * Ac31_dVgs ; + Ac3_dT = T1 * Ac31_dT ; + + Ac2 = sqrt( Ac4 + Ac3 ) ; + T1 = 0.5 / Ac2 ; + Ac2_dVbs = T1 * ( Ac4_dVbs + Ac3_dVbs ) ; + Ac2_dVds = T1 * ( Ac4_dVds + Ac3_dVds ) ; + Ac2_dVgs = T1 * ( Ac4_dVgs + Ac3_dVgs ) ; + Ac2_dT = T1 * ( Ac4_dT + Ac3_dT ) ; + + + Ac1 = -7.0 * C_SQRT_2 + Ac2 + T5 ; + Ac1_dVbs = Ac2_dVbs + T5_dVb ; + Ac1_dVds = Ac2_dVds + T5_dVd ; + Ac1_dVgs = Ac2_dVgs + T5_dVg ; + Ac1_dT = Ac2_dT + T5_dT ; + + Acd = Fn_Pow( Ac1 , C_1o3 ) ; + T1 = C_1o3 / ( Acd * Acd ) ; + Acd_dVbs = Ac1_dVbs * T1 ; + Acd_dVds = Ac1_dVds * T1 ; + Acd_dVgs = Ac1_dVgs * 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_dVbs = - 12.0 * TY_dVbs + T1 * Acd_dVbs ; + Acn_dVds = - 12.0 * TY_dVds + T1 * Acd_dVds ; + Acn_dVgs = - 12.0 * TY_dVgs + T1 * Acd_dVgs ; + Acn_dT = - 12.0 * TY_dT + T1 * Acd_dT ; + + + T1 = 1.0 / Acd ; + Chi = Acn * T1 ; + Chi_dVbs = ( Acn_dVbs - Chi * Acd_dVbs ) * T1 ; + Chi_dVds = ( Acn_dVds - Chi * Acd_dVds ) * T1 ; + Chi_dVgs = ( Acn_dVgs - Chi * Acd_dVgs ) * T1 ; + Chi_dT = ( Acn_dT - Chi * Acd_dT ) * T1 ; + + + Psa = Chi * beta_inv + Vbscl ; + Psa_dVbs = Chi_dVbs * beta_inv + Vbscl_dVbs ; + Psa_dVds = Chi_dVds * beta_inv ; + Psa_dVgs = Chi_dVgs * beta_inv ; + Psa_dT = Chi_dT * beta_inv + Chi * beta_inv_dT + Vbscl_dT; + + T1 = Psa - Vbscl ; + T1_dT = Psa_dT - Vbscl_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 ) ) ; + + T3_dT = 1.0 / T3 * T2 * T2_dT ; + + T9 = T2 / T3 / Ps0_min ; + T3_dVb = T9 * ( Psa_dVbs - Vbscl_dVbs ) ; + T3_dVd = T9 * ( Psa_dVds ) ; + T3_dVg = T9 * ( Psa_dVgs ) ; + + Ps0 = T1 / T3 + Vbscl ; + T9 = 1.0 / ( T3 * T3 ) ; + Ps0_dVbs = T9 * ( ( Psa_dVbs - Vbscl_dVbs ) * T3 - T1 * T3_dVb ) + Vbscl_dVbs ; + Ps0_dVds = T9 * ( Psa_dVds * T3 - T1 * T3_dVd ) ; + Ps0_dVgs = T9 * ( Psa_dVgs * T3 - T1 * T3_dVg ) ; + Ps0_dT = T9 * ( ( Psa_dT - Vbscl_dT )* T3 - T1 * T3_dT ) + Vbscl_dT; + + /*---------------------------------------------------* + * Characteristics. + *-----------------*/ + Psl = Ps0 ; + Psl_dVbs = Ps0_dVbs ; + Psl_dVds = Ps0_dVds ; + Psl_dVgs = Ps0_dVgs ; + Psl_dT = Ps0_dT ; + + /** (reminder) + Psdl = Psl ; + Psdl_dVbs = Psl_dVbs ; + Psdl_dVds = Psl_dVds ; + Psdl_dVgs = Psl_dVgs ; + **/ + + T2 = ( Vgp - Ps0 ) ; + T2_dT = Vgp_dT - Ps0_dT ; + Qbu = Cox * T2 ; + Qbu_dVbs = Cox * ( Vgp_dVbs - Ps0_dVbs ) + Cox_dVb * T2 ; + Qbu_dVds = Cox * ( Vgp_dVds - Ps0_dVds ) + Cox_dVd * T2 ; + Qbu_dVgs = Cox * ( Vgp_dVgs - Ps0_dVgs ) + Cox_dVg * T2 ; + Qbu_dT = Cox * T2_dT ; + + Qiu = 0.0e0 ; + Qiu_dVbs = 0.0e0 ; + Qiu_dVds = 0.0e0 ; + Qiu_dVgs = 0.0e0 ; + Qiu_dT = 0.0e0 ; + + Qdrat = 0.0e0 ; + Qdrat_dVbs = 0.0e0 ; + Qdrat_dVds = 0.0e0 ; + Qdrat_dVgs = 0.0e0 ; + Qdrat_dT = 0.0 ; + + Lred = 0.0e0 ; + Lred_dVbs = 0.0e0 ; + Lred_dVds = 0.0e0 ; + Lred_dVgs = 0.0e0 ; + Lred_dT = 0.0e0 ; + + Ids = 0.0e0 ; + Ids_dVbs = 0.0e0 ; + Ids_dVds = 0.0e0 ; + Ids_dVgs = 0.0e0 ; + Ids_dT = 0.0e0 ; + + VgVt = 0.0 ; + + flg_noqi = 1 ; + + goto end_of_part_1 ; + } + + + /*-----------------------------------------------------------* + * Initial guess for Ps0. + *-----------------*/ + + /*---------------------------------------------------* + * Ps0_iniA: solution of subthreshold equation assuming zone-D1/D2. + *-----------------*/ + TX = 1.0e0 + 4.0e0 + * ( beta * ( Vgp - Vbscl ) - 1.0e0 ) / ( fac1p2 * beta2 ) ; + TX = Fn_Max( TX , epsm10 ) ; + Ps0_iniA = Vgp + fac1p2 * beta * 0.5 * ( 1.0e0 - sqrt( TX ) ) ; + + /* use analytical value in subthreshold region. */ + if ( Vgs < ( Vfb + Vth ) * 0.5 ) { + flg_pprv = 0 ; + } + + + if ( flg_pprv >= 1 ) { + /*---------------------------------------------------* + * Use previous value. + *-----------------*/ + + T1 = Ps0_dVbs * dVbs + Ps0_dVds * dVds + Ps0_dVgs * dVgs ; + Ps0_ini = Ps0 + T1 ; + + T2 = here->HSMHV_ps0_dtemp_prv * Temp_dif ; + if ( fabs( T1 + T2 ) < dP_max ) { Ps0_ini += T2 ; } + + if ( flg_pprv == 2 ) { + /* TX_dVxs = d^2 Ps0 / d Vxs^2 here */ + if ( Vbsc_dif2 > epsm10 ) { + TX_dVbs = ( here->HSMHV_ps0_dvbs_prv - here->HSMHV_ps0_dvbs_prv2 ) + / Vbsc_dif2 ; + } else { + TX_dVbs = 0.0 ; + } + if ( Vdsc_dif2 > epsm10 ) { + TX_dVds = ( here->HSMHV_ps0_dvds_prv - here->HSMHV_ps0_dvds_prv2 ) + / Vdsc_dif2 ; + } else { + TX_dVds = 0.0 ; + } + if ( Vgsc_dif2 > epsm10 ) { + TX_dVgs = ( here->HSMHV_ps0_dvgs_prv - here->HSMHV_ps0_dvgs_prv2 ) + / Vgsc_dif2 ; + } else { + TX_dVgs = 0.0 ; + } + T2 = ( dVbs * dVbs ) / 2 * TX_dVbs + + ( dVds * dVds ) / 2 * TX_dVds + + ( dVgs * dVgs ) / 2 * TX_dVgs ; + + if ( fabs( T2 ) < fabs( 0.5 * T1 ) ) { + Ps0_ini += T2 ; + } else { + flg_pprv = 1 ; + } + } + + T1 = Ps0_ini - Ps0 ; + if ( T1 < - dP_max || T1 > dP_max ) { + flg_pprv = 0 ; /* flag changes to analytical */ + } else { + Ps0_iniA = Fn_Max( Ps0_ini , Ps0_iniA ) ; + } + } /* end of (flg_pprv >=1) if-block */ + + if ( flg_pprv == 0 ) { + + /*---------------------------------------------------* + * Analytical initial guess. + *-----------------*/ + /*-------------------------------------------* + * Common part. + *-----------------*/ + Chi = beta * ( Ps0_iniA - Vbscl ) ; + + if ( Chi < znbd3 ) { + /*-----------------------------------* + * zone-D1/D2 + * - Ps0_ini is the analytical solution of Qs=Qb0 with + * Qb0 being approximated to 3-degree polynomial. + *-----------------*/ + TY = beta * ( Vgp - Vbscl ) ; + 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 = Fn_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 + Vbscl ; + Ps0_ini = Ps0_iniA ; + + } else if ( Vgs <= Vth ) { + /*-----------------------------------* + * Weak inversion zone. + *-----------------*/ + Ps0_ini = Ps0_iniA ; + + } else { + /*-----------------------------------* + * Strong inversion zone. + * - Ps0_iniB : upper bound. + *-----------------*/ + T1 = 1.0 / cnst1 / cnstCoxi ; + T2 = T1 * Vgp * Vgp ; + T3 = beta + 2.0 / Vgp ; + + Ps0_iniB = log( T2 ) / T3 ; + + Fn_SU( Ps0_ini , Ps0_iniA, Ps0_iniB, c_ps0ini_2, T1) ; + } + } + + TX = Vbscl + ps_conv / 2 ; + if ( Ps0_ini < TX ) Ps0_ini = TX ; + + + /*---------------------------------------------------* + * Assign initial guess. + *-----------------*/ + Ps0 = Ps0_ini ; + Psl_lim = Ps0_iniA ; + + /*---------------------------------------------------* + * Calculation of Ps0. (beginning of Newton loop) + * - Fs0 : Fs0 = 0 is the equation to be solved. + * - dPs0 : correction value. + *-----------------*/ + exp_bVbs = exp( beta * Vbscl ) ; + cfs1 = cnst1 * exp_bVbs ; + + flg_conv = 0 ; + for ( lp_s0 = 1 ; lp_s0 <= lp_s0_max + 1 ; lp_s0 ++ ) { + + Chi = beta * ( Ps0 - Vbscl ) ; + + if ( Chi < znbd5 ) { + /*-------------------------------------------* + * zone-D1/D2. (Ps0) + * - Qb0 is approximated to 5-degree polynomial. + *-----------------*/ + 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 ) ; + fs02_dPs0 = ( beta * fb_dChi * 2 * fb + fs01_dPs0 ) / ( fs02 + fs02 ) ; + + } else { + /*-------------------------------------------* + * zone-D3. (Ps0) + *-----------------*/ + 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*Ps0 ) ; + fs01 = cnst1 * ( exp_bPs0 - exp_bVbs ) ; + fs01_dPs0 = cnst1 * beta * exp_bPs0 ; + } + fs02 = sqrt( Chi - 1.0 + fs01 ) ; + fs02_dPs0 = ( beta + fs01_dPs0 ) / ( fs02 + fs02 ) ; + } /* end of if ( Chi ... ) else block */ + + Fs0 = Vgp - Ps0 - fac1 * fs02 ; + Fs0_dPs0 = - 1.0e0 - fac1 * fs02_dPs0 ; + + if ( flg_conv == 1 ) break ; + + dPs0 = - Fs0 / Fs0_dPs0 ; + + + /*-------------------------------------------* + * Update Ps0 . + * - clamped to Vbscl if Ps0 < Vbscl . + *-----------------*/ + dPlim = 0.5*dP_max*(1.0 + Fn_Max(1.e0,fabs(Ps0))) ; + if ( fabs( dPs0 ) > dPlim ) dPs0 = dPlim * Fn_Sgn( dPs0 ) ; + + Ps0 = Ps0 + dPs0 ; + + TX = Vbscl + ps_conv / 2 ; + if ( Ps0 < TX ) Ps0 = TX ; + + /*-------------------------------------------* + * Check convergence. + * NOTE: This condition may be too rigid. + *-----------------*/ + if ( fabs( dPs0 ) <= ps_conv && fabs( Fs0 ) <= gs_conv ) { + flg_conv = 1 ; + } + + } /* end of Ps0 Newton loop */ + + /* Reduce loop count to exclude the sweep for derivative calculation */ + lp_s0 -- ; + + /*-------------------------------------------* + * Procedure for diverged case. + *-----------------*/ + if ( flg_conv == 0 ) { + fprintf( stderr , + "*** warning(HiSIM): Went Over Iteration Maximum (Ps0)\n" ) ; + fprintf( stderr , + " Vbse = %7.3f Vdse = %7.3f Vgse = %7.3f\n" , + Vbse , Vdse , Vgse ) ; + if ( flg_info >= 2 ) { + printf( "*** warning(HiSIM): Went Over Iteration Maximum (Ps0)\n" ) ; + } + } + + /*---------------------------------------------------* + * Evaluate derivatives of Ps0. + * - note: Here, fs01_dVbs and fs02_dVbs are derivatives + * w.r.t. explicit Vbs. So, Ps0 in the fs01 and fs02 + * expressions is regarded as a constant. + *-----------------*/ + /* self heating */ + Chi_dT = beta_dT *( Ps0 - Vbscl ) - beta * Vbscl_dT ; + exp_bVbs_dT = ( beta_dT * Vbscl + beta * Vbscl_dT ) * exp_bVbs ; + cfs1_dT = exp_bVbs * cnst1_dT + exp_bVbs_dT * cnst1 ; + + /* derivatives of fs0* w.r.t. explicit Vbs */ + if ( Chi < znbd5 ) { + fs01_dVbs = cfs1 * beta * fi * ( fi - 2 * fi_dChi ) * Vbscl_dVbs ; + fs01_dT = cfs1 * 2 * fi * fi_dChi * Chi_dT + fi * fi * cfs1_dT ; + T2 = 1.0e0 / ( fs02 + fs02 ) ; + fs02_dVbs = ( - beta * Vbscl_dVbs * fb_dChi * 2 * fb + fs01_dVbs ) * T2 ; + fs02_dT = ( 2 * fb * fb_dChi * Chi_dT + fs01_dT ) * T2 ; + } else { + if ( Chi < large_arg ) { + fs01_dVbs = - cfs1 * beta * Vbscl_dVbs ; + exp_Chi_dT = exp_Chi * Chi_dT ; + fs01_dT = ( exp_Chi - 1.0e0 ) * cfs1_dT + cfs1 * exp_Chi_dT ; + } else { + fs01_dVbs = - cfs1 * beta * Vbscl_dVbs ; + exp_bPs0_dT = exp_bPs0 * Ps0 * beta_dT ; + fs01_dT = cnst1_dT*(exp_bPs0-exp_bVbs) + cnst1*(exp_bPs0_dT-exp_bVbs_dT) ; + } + T2 = 0.5e0 / fs02 ; + fs02_dVbs = ( - beta * Vbscl_dVbs + fs01_dVbs ) * T2 ; + fs02_dT = T2 * ( Chi_dT + fs01_dT ) ; + } + + T1 = 1.0 / Fs0_dPs0 ; + Ps0_dVbs = - ( Vgp_dVbs - ( fac1 * fs02_dVbs + fac1_dVbs * fs02 ) ) * T1 ; + Ps0_dVds = - ( Vgp_dVds - fac1_dVds * fs02 ) * T1 ; + Ps0_dVgs = - ( Vgp_dVgs - fac1_dVgs * fs02 ) * T1 ; + Ps0_dT = - ( Vgp_dT - ( fac1 * fs02_dT + fac1_dT * fs02 ) ) * T1 ; + + Chi_dT = beta_dT *( Ps0 - Vbscl ) + beta * ( Ps0_dT - Vbscl_dT ) ; + + if ( Chi < znbd5 ) { + /*-------------------------------------------* + * zone-D1/D2. (Ps0) + * Xi0 := fdep0^2 = fb * fb [D1,D2] + *-----------------*/ + Xi0 = fb * fb + epsm10 ; + T1 = 2 * fb * fb_dChi * beta ; + Xi0_dVbs = T1 * ( Ps0_dVbs - Vbscl_dVbs ) ; + Xi0_dVds = T1 * Ps0_dVds ; + Xi0_dVgs = T1 * Ps0_dVgs ; + Xi0_dT = 2 * fb * fb_dChi * Chi_dT ; + + Xi0p12 = fb + epsm10 ; + T1 = fb_dChi * beta ; + Xi0p12_dVbs = T1 * ( Ps0_dVbs - Vbscl_dVbs ) ; + Xi0p12_dVds = T1 * Ps0_dVds ; + Xi0p12_dVgs = T1 * Ps0_dVgs ; + Xi0p12_dT = fb_dChi * Chi_dT ; + + Xi0p32 = fb * fb * fb + epsm10 ; + T1 = 3 * fb * fb * fb_dChi * beta ; + Xi0p32_dVbs = T1 * ( Ps0_dVbs - Vbscl_dVbs ) ; + Xi0p32_dVds = T1 * Ps0_dVds ; + Xi0p32_dVgs = T1 * Ps0_dVgs ; + 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. (Ps0) + *-----------------*/ + flg_zone = 3 ; + flg_noqi = 0 ; + + /*-----------------------------------* + * Xi0 := fdep0^2 = Chi - 1 = beta * ( Ps0 - Vbscl ) - 1 [D3] + *-----------------*/ + Xi0 = Chi - 1.0e0 ; + Xi0_dVbs = beta * ( Ps0_dVbs - Vbscl_dVbs ) ; + Xi0_dVds = beta * Ps0_dVds ; + Xi0_dVgs = beta * Ps0_dVgs ; + 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 * Ps0 + beta * Ps0_dT) ; + fs01_dT = cnst1_dT*(exp_bPs0-exp_bVbs) + cnst1*(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. + * note: fs01 = cnst1 * exp( Vbs ) * ( exp( Chi ) - Chi - 1.0e0 ) ; + * fs02 = sqrt( Xi0 + fs01 ) ; + *-----------------*/ + fs01_dVbs = Ps0_dVbs * fs01_dPs0 + fs01_dVbs ; + fs01_dVds = Ps0_dVds * fs01_dPs0 ; + fs01_dVgs = Ps0_dVgs * fs01_dPs0 ; + fs02_dVbs = Ps0_dVbs * fs02_dPs0 + fs02_dVbs ; + fs02_dVds = Ps0_dVds * fs02_dPs0 ; + fs02_dVgs = Ps0_dVgs * fs02_dPs0 ; + + /*-----------------------------------------------------------* + * Qb0 : Qb at source side. + * Qn0 : Qi at source side. + *-----------------*/ + + Qb0 = cnst0 * Xi0p12 ; + Qb0_dVb = cnst0 * Xi0p12_dVbs ; + Qb0_dVd = cnst0 * Xi0p12_dVds ; + Qb0_dVg = cnst0 * Xi0p12_dVgs ; + Qb0_dT = cnst0 * Xi0p12_dT + cnst0_dT * Xi0p12 ; + + T1 = 1.0 / ( fs02 + Xi0p12 ) ; + Qn0 = cnst0 * fs01 * T1 ; + T1_dT = - T1 * T1 * ( fs02_dT + Xi0p12_dT ) ; + Qn0_dT = cnst0 * ( fs01 * T1_dT + T1 * fs01_dT ) + fs01 * T1 * cnst0_dT ; + + T2 = 1.0 / ( fs01 + epsm10 ) ; + + Qn0_dVbs = Qn0 * ( fs01_dVbs * T2 - ( fs02_dVbs + Xi0p12_dVbs ) * T1 ) ; + Qn0_dVds = Qn0 * ( fs01_dVds * T2 - ( fs02_dVds + Xi0p12_dVds ) * T1 ) ; + Qn0_dVgs = Qn0 * ( fs01_dVgs * T2 - ( fs02_dVgs + Xi0p12_dVgs ) * T1 ) ; + + + /*-----------------------------------------------------------* + * zone-D1 and D2 + *-----------------*/ + if ( Chi < znbd5 ) { + if ( Chi < znbd3 ) { + /*-------------------------------------------* + * zone-D1. (Ps0) + *-----------------*/ + flg_zone = 1 ; + flg_noqi = 1 ; /** !! to be revisited !! **/ + + Qiu = Qn0 ; + Qiu_dVbs = Qn0_dVbs ; + Qiu_dVds = Qn0_dVds ; + Qiu_dVgs = Qn0_dVgs ; + Qiu_dT = Qn0_dT; + + Qbu = Qb0 ; + Qbu_dVbs = Qb0_dVb ; + Qbu_dVds = Qb0_dVd ; + Qbu_dVgs = Qb0_dVg ; + Qbu_dT = Qb0_dT ; + + Qdrat = 0.5 ; + Qdrat_dVbs = 0.0 ; + Qdrat_dVds = 0.0 ; + Qdrat_dVgs = 0.0 ; + Qdrat_dT = 0.0; + + Lred = 0.0e0 ; + Lred_dVbs = 0.0e0 ; + Lred_dVds = 0.0e0 ; + Lred_dVgs = 0.0e0 ; + Lred_dT = 0.0e0 ; + + /** (reminder) + *Psdl = Psl ; + *Psdl_dVbs = Psl_dVbs ; + *Psdl_dVds = Psl_dVds ; + *Psdl_dVgs = Psl_dVgs ; + **/ + + } else { + /*-------------------------------------------* + * zone-D2 (Ps0) + *-----------------*/ + flg_zone = 2 ; + flg_noqi = 0 ; + /*-----------------------------------------------------------* + * FD2 : connecting function for zone-D2. + * - Qiu, Qbu, Qdrat and Lred should be interpolated later. + *-----------------*/ + T1 = 1.0 / ( znbd5 - znbd3 ) ; + TX = T1 * ( Chi - znbd3 ) ; + TX_dVbs = beta * T1 * ( Ps0_dVbs - Vbscl_dVbs ) ; + TX_dVds = beta * T1 * Ps0_dVds ; + TX_dVgs = beta * T1 * Ps0_dVgs ; + TX_dT = T1 * Chi_dT ; + + FD2 = TX * TX * TX * ( 10.0 + TX * ( -15.0 + TX * 6.0 ) ) ; + T4 = TX * TX * ( 30.0 + TX * ( -60.0 + TX * 30.0 ) ) ; + + FD2_dVbs = T4 * TX_dVbs ; + FD2_dVds = T4 * TX_dVds ; + FD2_dVgs = T4 * TX_dVgs ; + FD2_dT = T4 * TX_dT ; + + } /* end of zone-D2 */ + } + + + /*---------------------------------------------------* + * VgVt : Vgp - Vth_qi. ( Vth_qi is Vth for Qi evaluation. ) + *-----------------*/ + VgVt = Qn0 * Cox_inv ; + VgVt_dVbs = Qn0_dVbs * Cox_inv + Qn0 * Cox_inv_dVb ; + VgVt_dVds = Qn0_dVds * Cox_inv + Qn0 * Cox_inv_dVd ; + VgVt_dVgs = Qn0_dVgs * Cox_inv + Qn0 * Cox_inv_dVg ; + VgVt_dT = Qn0_dT * Cox_inv ; + + /*-----------------------------------------------------------* + * make Qi=Qd=Ids=0 if VgVt <= VgVt_small + *-----------------*/ + if ( VgVt <= VgVt_small ) { + flg_zone = 4 ; + flg_noqi = 1 ; + + Psl = Ps0 ; + Psl_dVbs = Ps0_dVbs ; + Psl_dVds = Ps0_dVds ; + Psl_dVgs = Ps0_dVgs ; + Psl_dT = Ps0_dT ; + + /** (reminder) + *Psdl = Psl ; + *Psdl_dVbs = Psl_dVbs ; + *Psdl_dVds = Psl_dVds ; + *Psdl_dVgs = Psl_dVgs ; + **/ + + Pds = 0.0 ; + Pds_dVbs = 0.0 ; + Pds_dVds = 0.0 ; + Pds_dVgs = 0.0 ; + Pds_dT = 0.0 ; + + Qbu = Qb0 ; + Qbu_dVbs = Qb0_dVb ; + Qbu_dVds = Qb0_dVd ; + Qbu_dVgs = Qb0_dVg ; + Qbu_dT = Qb0_dT ; + + Qiu = 0.0 ; + Qiu_dVbs = 0.0 ; + Qiu_dVds = 0.0 ; + Qiu_dVgs = 0.0 ; + Qiu_dT = 0.0 ; + + Qdrat = 0.5 ; + Qdrat_dVbs = 0.0 ; + Qdrat_dVds = 0.0 ; + Qdrat_dVgs = 0.0 ; + Qdrat_dT = 0.0 ; + + Lred = 0.0 ; + Lred_dVbs = 0.0 ; + Lred_dVds = 0.0 ; + Lred_dVgs = 0.0 ; + Lred_dT = 0.0 ; + + Ids = 0.0e0 ; + Ids_dVbs = 0.0e0 ; + Ids_dVds = 0.0e0 ; + Ids_dVgs = 0.0e0 ; + Ids_dT = 0.0e0 ; + + goto end_of_part_1 ; + } + + + /*-----------------------------------------------------------* + * Start point of Psl (= Ps0 + Pds) calculation. (label) + *-----------------*/ +/* start_of_Psl: +*/ + + /* Vdseff (begin) */ + Vdsorg = Vds ; + + T2 = here->HSMHV_qnsub_esi / ( Cox * Cox ) ; + T4 = - 2.0e0 * T2 / Cox ; + T2_dVb = T4 * Cox_dVb ; + T2_dVd = T4 * Cox_dVd ; + T2_dVg = T4 * Cox_dVg ; + + T0 = Vgp - beta_inv - Vbsz ; + T0_dT = Vgp_dT - beta_inv_dT - Vbsz_dT ; + Fn_SZ( T9, 1.0e0 + 2.0e0 / T2 * T0, 1e-3, TX ) ; + T3 = sqrt( T9 ) ; + T4 = 0.5e0 / T3 ; + T5 = 1.0e0 / ( T2 * T2 ) ; + T6 = T4 * 2.0e0 * T5 * TX ; + T7 = T6 * T0 ; + T8 = T6 * T2 ; + T3_dVb = - T2_dVb * T7 + T8 * ( Vgp_dVbs - Vbsz_dVbs ) ; + T3_dVd = - T2_dVd * T7 + T8 * ( Vgp_dVds - Vbsz_dVds ) ; + T3_dVg = - T2_dVg * T7 + T8 * Vgp_dVgs ; + T3_dT = T0_dT / ( T2 * T3 ) ; + + T10 = Vgp + T2 * ( 1.0e0 - T3 ) ; + T10_dVb = Vgp_dVbs + T2_dVb * ( 1.0e0 - T3 ) - T2 * T3_dVb ; + T10_dVd = Vgp_dVds + T2_dVd * ( 1.0e0 - T3 ) - T2 * T3_dVd ; + T10_dVg = Vgp_dVgs + T2_dVg * ( 1.0e0 - T3 ) - T2 * T3_dVg ; + T10_dT = Vgp_dT - T2 * T3_dT ; + Fn_SZ( T10 , T10 , 0.01 , T0 ) ; + T10_dVb *= T0 ; + T10_dVd *= T0 ; + T10_dVg *= T0 ; + T10_dT *= T0 ; + + T1 = Vds / T10 + small ; + T2 = Fn_Pow( T1 , here->HSMHV_ddlt - 1.0e0 ) ; + T7 = T2 * T1 ; + T0 = here->HSMHV_ddlt * T2 / ( T10 * T10 ) ; + T7_dVb = T0 * ( - Vds * T10_dVb ) ; + T7_dVd = T0 * ( T10 - Vds * T10_dVd ) ; + T7_dVg = T0 * ( - Vds * T10_dVg ) ; + T7_dT = T0 * ( - Vds * T10_dT ) ; + + T3 = 1.0 + T7 ; + T4 = Fn_Pow( T3 , 1.0 / here->HSMHV_ddlt - 1.0 ) ; + T6 = T4 * T3 ; + T0 = T4 / here->HSMHV_ddlt ; + T6_dVb = T0 * T7_dVb ; + T6_dVd = T0 * T7_dVd ; + T6_dVg = T0 * T7_dVg ; + T6_dT = T0 * T7_dT ; + + Vdseff = Vds / T6 ; + T0 = 1.0 / ( T6 * T6 ) ; + Vdseff_dVbs = - Vds * T6_dVb * T0 ; + Vdseff_dVds = ( T6 - Vds * T6_dVd ) * T0 ; + Vdseff_dVgs = - Vds * T6_dVg * T0 ; + Vdseff_dT = - Vds * T6_dT * T0 ; + + Vds = Vdseff ; + /* Vdseff (end) */ + + + exp_bVbsVds = exp( beta * ( Vbscl - Vds ) ) ; + exp_bVbsVds_dT = ( beta_dT * ( Vbscl - Vds ) + beta * (Vbscl_dT - Vdseff_dT) ) * exp_bVbsVds ; + + + /*---------------------------------------------------* + * Skip Psl calculation when Vds is very small. + *-----------------*/ + if ( Vds <= epsm10 ) { + Pds = 0.0 ; + Psl = Ps0 ; + flg_conv = 1 ; + goto start_of_loopl ; + } + + /*-----------------------------------------------------------* + * Initial guess for Pds ( = Psl - Ps0 ). + *-----------------*/ + if ( flg_pprv >= 1 ) { + /*---------------------------------------------------* + * Use previous value. + *-----------------*/ + + T1 = Pds_dVbs * dVbs + Pds_dVds * dVds + Pds_dVgs * dVgs ; + Pds_ini = Pds + T1 ; + + /* self heating */ + T2 = here->HSMHV_pds_dtemp_prv * Temp_dif ; + if ( fabs( T1 + T2 ) < dP_max ) { Pds_ini += T2 ; } + + if ( flg_pprv == 2 ) { + /* TX_dVxs = d^2 Pds / d Vxs^2 here */ + if ( Vbsc_dif2 > epsm10 ) { + TX_dVbs = ( here->HSMHV_pds_dvbs_prv - here->HSMHV_pds_dvbs_prv2 ) + / Vbsc_dif2 ; + } else { + TX_dVbs = 0.0 ; + } + if ( Vdsc_dif2 > epsm10 ) { + TX_dVds = ( here->HSMHV_pds_dvds_prv - here->HSMHV_pds_dvds_prv2 ) + / Vdsc_dif2 ; + } else { + TX_dVds = 0.0 ; + } + if ( Vgsc_dif2 > epsm10 ) { + TX_dVgs = ( here->HSMHV_pds_dvgs_prv - here->HSMHV_pds_dvgs_prv2 ) + / Vgsc_dif2 ; + } else { + TX_dVgs = 0.0 ; + } + T2 = ( dVbs * dVbs ) / 2 * TX_dVbs + + ( dVds * dVds ) / 2 * TX_dVds + + ( dVgs * dVgs ) / 2 * TX_dVgs ; + + if ( fabs( T2 ) < fabs( 0.5 * T1 ) ) { + Pds_ini += T2 ; + } else { + flg_pprv = 1 ; + } + } + + T1 = Pds_ini - Pds ; + if ( T1 < - dP_max || T1 > dP_max ) flg_pprv = 0 ; /* flag changes */ + + } /* end of (flg_pprv>=1) if-block */ + + if ( flg_pprv == 0 ) { + /*---------------------------------------------------* + * Analytical initial guess. + *-----------------*/ + Pds_max = Fn_Max( Psl_lim - Ps0 , 0.0e0 ) ; + + Fn_SU( Pds_ini , Vds, (1.0e0 + c_pslini_1) * Pds_max, c_pslini_2, T1 ) ; + Pds_ini = Fn_Min( Pds_ini , Pds_max ) ; + } + + if ( Pds_ini < 0.0 ) Pds_ini = 0.0 ; + else if ( Pds_ini > Vds ) Pds_ini = Vds ; + + + /*---------------------------------------------------* + * Assign initial guess. + *-----------------*/ + Pds = Pds_ini ; + Psl = Ps0 + Pds ; + TX = Vbscl + ps_conv / 2 ; + if ( Psl < TX ) Psl = TX ; + + /*---------------------------------------------------* + * Calculation of Psl by solving Poisson eqn. + * (beginning of Newton loop) + * - Fsl : Fsl = 0 is the equation to be solved. + * - dPsl : correction value. + *-----------------*/ + flg_conv = 0 ; + + /*---------------------------------------------------* + * start of Psl calculation. (label) + *-----------------*/ +start_of_loopl: + + for ( lp_sl = 1 ; lp_sl <= lp_sl_max + 1 ; lp_sl ++ ) { + + Chi = beta * ( Psl - Vbscl ) ; + + if ( Chi < znbd5 ) { + /*-------------------------------------------* + * zone-D2. (Psl) + * - Qb0 is approximated to 5-degree polynomial. + *-----------------*/ + + 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 ) ) ; + + cfs1 = cnst1 * exp_bVbsVds ; + + fsl1 = cfs1 * fi * fi ; + fsl1_dPsl = 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 ) ) ) ; + + fsl2 = sqrt( fb * fb + fsl1 ) ; + fsl2_dPsl = ( beta * fb_dChi * 2 * fb + fsl1_dPsl ) / ( fsl2 + fsl2 ) ; + + } else { + /*-------------------------------------------* + * zone-D3. (Psl) + *-----------------*/ + Rho = beta * ( Psl - Vds ) ; + exp_Rho = exp( Rho ) ; + + fsl1 = cnst1 * ( exp_Rho - exp_bVbsVds ) ; + fsl1_dPsl = cnst1 * beta * ( exp_Rho ) ; + Xil = Chi - 1.0e0 ; + fsl2 = sqrt( Xil + fsl1 ) ; + fsl2_dPsl = ( beta + fsl1_dPsl ) / ( fsl2 + fsl2 ) ; + } + + Fsl = Vgp - Psl - fac1 * fsl2 ; + Fsl_dPsl = - 1.0e0 - fac1 * fsl2_dPsl ; + + if ( flg_conv == 1 ) break ; + + dPsl = - Fsl / Fsl_dPsl ; + + /*-------------------------------------------* + * Update Psl . + * - clamped to Vbscl if Psl < Vbscl . + *-----------------*/ + dPlim = 0.5*dP_max*(1.0 + Fn_Max(1.e0,fabs(Psl))) ; + if ( fabs( dPsl ) > dPlim ) dPsl = dPlim * Fn_Sgn( dPsl ) ; + if (Psl + dPsl < Ps0 ) { + dPsl = Ps0 - Psl; + Psl = Ps0 ; + } else { + Psl = Psl + dPsl ; + } + + TX = Vbscl + ps_conv / 2 ; + if ( Psl < TX ) Psl = TX ; + + /*-------------------------------------------* + * Check convergence. + * NOTE: This condition may be too rigid. + *-----------------*/ + if ( fabs( dPsl ) <= ps_conv && fabs( Fsl ) <= gs_conv ) { + flg_conv = 1 ; + } + } /* end of Psl Newton loop */ + + /* Reduce loop count to exclude derivative calculation sweep */ + lp_sl -- ; + + /*-------------------------------------------* + * Procedure for diverged case. + *-----------------*/ + if ( flg_conv == 0 ) { + fprintf( stderr , + "*** warning(HiSIM): Went Over Iteration Maximum (Psl)\n" ) ; + fprintf( stderr , + " Vbse = %7.3f Vdse = %7.3f Vgse = %7.3f\n" , + Vbse , Vdse , Vgse ) ; + if ( flg_info >= 2 ) { + printf("*** warning(HiSIM): Went Over Iteration Maximum (Psl)\n" ) ; + } + } + + + /*---------------------------------------------------* + * Evaluate derivatives of Psl. + * - note: Here, fsl1_dVbs and fsl2_dVbs are derivatives + * w.r.t. explicit Vbscl. So, Psl in the fsl1 and fsl2 + * expressions is regarded as a constant. + *-----------------*/ + Chi_dT = ( Psl - Vbscl ) * beta_dT - Vbscl_dT * beta ; + + if ( Chi < znbd5 ) { + T1 = cfs1 * beta * fi ; + fsl1_dVbs = T1 * ( ( Vbscl_dVbs - Vdseff_dVbs ) * fi - 2.0 * fi_dChi * Vbscl_dVbs ) ; + fsl1_dVds = - T1 * fi * Vdseff_dVds ; + fsl1_dVgs = - T1 * fi * Vdseff_dVgs ; + cfs1_dT = exp_bVbsVds * cnst1_dT + cnst1 * exp_bVbsVds_dT ; + fsl1_dT = fi * fi * cfs1_dT + 2 * cfs1 * fi * fi_dChi * Chi_dT ; + T2 = 0.5 / fsl2 ; + fsl2_dVbs = ( - beta * fb_dChi * 2 * fb * Vbscl_dVbs + fsl1_dVbs ) * T2 ; + fsl2_dVds = fsl1_dVds * T2 ; + fsl2_dVgs = fsl1_dVgs * T2 ; + fsl2_dT = ( 2 * fb * fb_dChi * Chi_dT + fsl1_dT ) * T2 ; + } else { + Rho_dT = beta_dT * ( Psl - Vds ) - beta * Vdseff_dT ; + exp_Rho_dT = Rho_dT * exp_Rho ; + + T1 = cnst1 * beta ; + fsl1_dVbs = - T1 * ( exp_Rho * Vdseff_dVbs + + ( Vbscl_dVbs - Vdseff_dVbs ) * exp_bVbsVds ); + fsl1_dVds = - T1 * Vdseff_dVds * ( exp_Rho - exp_bVbsVds ); + fsl1_dVgs = T1 * Vdseff_dVgs * ( - exp_Rho + exp_bVbsVds ); + fsl1_dT = cnst1 * ( exp_Rho_dT - exp_bVbsVds_dT ) + cnst1_dT * ( exp_Rho - exp_bVbsVds ) ; + T2 = 0.5e0 / fsl2 ; + fsl2_dVbs = ( - beta * Vbscl_dVbs + fsl1_dVbs ) * T2 ; + fsl2_dVds = ( fsl1_dVds ) * T2 ; + fsl2_dVgs = ( fsl1_dVgs ) * T2 ; + fsl2_dT = ( Chi_dT + fsl1_dT ) * T2 ; + } + + T1 = 1.0 / Fsl_dPsl ; + Psl_dVbs = - ( Vgp_dVbs - ( fac1 * fsl2_dVbs + fac1_dVbs * fsl2 ) ) * T1 ; + Psl_dVds = - ( Vgp_dVds - ( fac1 * fsl2_dVds + fac1_dVds * fsl2 ) ) * T1 ; + Psl_dVgs = - ( Vgp_dVgs - ( fac1 * fsl2_dVgs + fac1_dVgs * fsl2 ) ) * T1 ; + Psl_dT = - ( Vgp_dT - ( fac1 * fsl2_dT + fac1_dT * fsl2 ) ) * T1 ; + + Chi_dT = ( Psl - Vbscl ) * beta_dT + beta * ( Psl_dT - Vbscl_dT ); + exp_Chi_dT = exp_Chi * Chi_dT ; + + + if ( Chi < znbd5 ) { + /*-------------------------------------------* + * zone-D1/D2. (Psl) + *-----------------*/ + Xil = fb * fb + epsm10 ; + T1 = 2 * fb * fb_dChi * beta ; + Xil_dVbs = T1 * ( Psl_dVbs - Vbscl_dVbs ) ; + Xil_dVds = T1 * Psl_dVds ; + Xil_dVgs = T1 * Psl_dVgs ; + Xil_dT = 2 * fb * fb_dChi * Chi_dT ; + + Xilp12 = fb + epsm10 ; + T1 = fb_dChi * beta ; + Xilp12_dVbs = T1 * ( Psl_dVbs - Vbscl_dVbs ) ; + Xilp12_dVds = T1 * Psl_dVds ; + Xilp12_dVgs = T1 * Psl_dVgs ; + Xilp12_dT = fb_dChi * Chi_dT ; + + Xilp32 = fb * fb * fb + epsm10 ; + T1 = 3 * fb * fb * fb_dChi * beta ; + Xilp32_dVbs = T1 * ( Psl_dVbs - Vbscl_dVbs ) ; + Xilp32_dVds = T1 * Psl_dVds ; + Xilp32_dVgs = T1 * Psl_dVgs ; + Xilp32_dT = 3 * fb * fb * fb_dChi * Chi_dT ; + + } else { + /*-------------------------------------------* + * zone-D3. (Psl) + *-----------------*/ + + Xil = Chi - 1.0e0 ; + Xil_dVbs = beta * ( Psl_dVbs - Vbscl_dVbs ) ; + Xil_dVds = beta * Psl_dVds ; + Xil_dVgs = beta * Psl_dVgs ; + Xil_dT = Chi_dT ; + + Xilp12 = sqrt( Xil ) ; + T1 = 0.5e0 / Xilp12 ; + Xilp12_dVbs = T1 * Xil_dVbs ; + Xilp12_dVds = T1 * Xil_dVds ; + Xilp12_dVgs = T1 * Xil_dVgs ; + Xilp12_dT = T1 * Xil_dT ; + + Xilp32 = Xil * Xilp12 ; + T1 = 1.5e0 * Xilp12 ; + Xilp32_dVbs = T1 * Xil_dVbs ; + Xilp32_dVds = T1 * Xil_dVds ; + Xilp32_dVgs = T1 * Xil_dVgs ; + Xilp32_dT = T1 * Xil_dT ; + + } + + /*---------------------------------------------------* + * Assign Pds. + *-----------------*/ + Pds = Psl - Ps0 ; + + /* if ( Pds < ps_conv ) { */ + if ( Pds < 0.0 ) { /* take care of numerical noise */ + Pds = 0.0 ; + Psl = Ps0 ; + } + + Pds_dVbs = Psl_dVbs - Ps0_dVbs ; + Pds_dVds = Psl_dVds - Ps0_dVds ; + Pds_dVgs = Psl_dVgs - Ps0_dVgs ; + Pds_dT = Psl_dT - Ps0_dT ; + + /* if ( Pds < ps_conv ) { */ + if ( Pds < 0.0 ) { + Pds_dVbs = 0.0 ; + Pds_dVgs = 0.0 ; + Psl_dVbs = Ps0_dVbs ; + Psl_dVgs = Ps0_dVgs ; + Pds_dT = 0.0 ; + Psl_dT = Ps0_dT ; + } + + /* Vdseff */ + Vds = Vdsorg; + + /*-----------------------------------------------------------* + * Evaluate Idd. + * - Eta : substantial variable of QB'/Pds and Idd/Pds. + * - note: Eta = 4 * GAMMA_{hisim_0} + *-----------------*/ + T1 = beta / Xi0 ; + Eta = T1 * Pds ; + T2 = Eta * beta_inv ; + Eta_dVbs = T1 * ( Pds_dVbs - Xi0_dVbs * T2 ) ; + Eta_dVds = T1 * ( Pds_dVds - Xi0_dVds * T2 ) ; + Eta_dVgs = T1 * ( Pds_dVgs - Xi0_dVgs * T2 ) ; + T1_dT = ( beta_dT * Xi0 - beta * Xi0_dT ) / Xi0 / Xi0 ; + Eta_dT = T1_dT * Pds + T1 * Pds_dT ; + + /* ( Eta + 1 )^n */ + Eta1 = Eta + 1.0e0 ; + Eta1p12 = sqrt( Eta1 ) ; + Eta1p32 = Eta1p12 * Eta1 ; + Eta1p52 = Eta1p32 * Eta1 ; + Eta1_dT = Eta_dT ; + Eta1p12_dT = 0.5e0 / Eta1p12 * Eta1_dT ; + Eta1p32_dT = Eta1p12_dT * Eta1 + Eta1p12 * Eta1_dT ; + Eta1p52_dT = Eta1p32_dT * Eta1 + Eta1p32 * Eta1_dT ; + + /* 1 / ( ( Eta + 1 )^n + 1 ) */ + Zeta12 = 1.0e0 / ( Eta1p12 + 1.0e0 ) ; + Zeta32 = 1.0e0 / ( Eta1p32 + 1.0e0 ) ; + Zeta52 = 1.0e0 / ( Eta1p52 + 1.0e0 ) ; + Zeta12_dT = - 1.0e0 / ( Eta1p12 + 1.0e0 ) / ( Eta1p12 + 1.0e0 ) * Eta1p12_dT ; + Zeta32_dT = - 1.0e0 / ( Eta1p32 + 1.0e0 ) / ( Eta1p32 + 1.0e0 ) * Eta1p32_dT ; + Zeta52_dT = - 1.0e0 / ( Eta1p52 + 1.0e0 ) / ( Eta1p52 + 1.0e0 ) * Eta1p52_dT ; + + /*---------------------------------------------------* + * F00 := PS00/Pds (n=1/2) + *-----------------*/ + F00 = Zeta12 / Xi0p12 ; + T3 = - 1 / Xi0 ; + T4 = - 0.5e0 / Eta1p12 * F00 ; + T5 = Zeta12 * T3 ; + T6 = Zeta12 * T4 ; + F00_dVbs = ( Xi0p12_dVbs * T5 + Eta_dVbs * T6 ) ; + F00_dVds = ( Xi0p12_dVds * T5 + Eta_dVds * T6 ) ; + F00_dVgs = ( Xi0p12_dVgs * T5 + Eta_dVgs * T6 ) ; + F00_dT = ( Zeta12_dT * Xi0p12 - Zeta12 * Xi0p12_dT ) / Xi0p12 / Xi0p12 ; + + /*---------------------------------------------------* + * F10 := PS10/Pds (n=3/2) + *-----------------*/ + T1 = 3.0e0 + Eta * ( 3.0e0 + Eta ) ; + F10 = C_2o3 * Xi0p12 * Zeta32 * T1 ; + T2 = 3.0e0 + Eta * 2.0e0 ; + T3 = C_2o3 * T1 ; + T4 = - 1.5e0 * Eta1p12 * F10 + C_2o3 * Xi0p12 * T2 ; + T5 = Zeta32 * T3 ; + T6 = Zeta32 * T4 ; + F10_dVbs = ( Xi0p12_dVbs * T5 + Eta_dVbs * T6 ) ; + F10_dVds = ( Xi0p12_dVds * T5 + Eta_dVds * T6 ) ; + F10_dVgs = ( Xi0p12_dVgs * T5 + Eta_dVgs * T6 ) ; + T1_dT = Eta_dT * ( 3.0e0 + Eta ) + Eta * Eta_dT ; + F10_dT = C_2o3 * Xi0p12 * Zeta32 * T1_dT + + C_2o3 * T1 * ( Xi0p12 * Zeta32_dT + Zeta32 * Xi0p12_dT ) ; + + /*---------------------------------------------------* + * F30 := PS30/Pds (n=5/2) + *-----------------*/ + T1 = 5e0 + Eta * ( 10e0 + Eta * ( 10e0 + Eta * ( 5e0 + Eta ) ) ) ; + F30 = 4e0 / ( 15e0 * beta ) * Xi0p32 * Zeta52 * T1 ; + T2 = 10e0 + Eta * ( 20e0 + Eta * ( 15e0 + Eta * 4e0 ) ) ; + T3 = 4e0 / ( 15e0 * beta ) * T1 ; + T4 = - ( 5e0 / 2e0 ) * Eta1p32 * F30 + 4e0 / ( 15e0 * beta ) * Xi0p32 * T2 ; + T5 = Zeta52 * T3 ; + T6 = Zeta52 * T4 ; + F30_dVbs = ( Xi0p32_dVbs * T5 + Eta_dVbs * T6 ) ; + F30_dVds = ( Xi0p32_dVds * T5 + Eta_dVds * T6 ) ; + F30_dVgs = ( Xi0p32_dVgs * T5 + Eta_dVgs * T6 ) ; + T1_dT = ( 10e0 + 20e0 * Eta + 15e0 * Eta * Eta + 4e0 * Eta * Eta * Eta ) * Eta_dT ; + F30_dT = 4e0 / 15e0 * beta_inv_dT * ( Xi0p32 * Zeta52 * T1 ) + + 4e0 / 15e0 * beta_inv * ( Xi0p32_dT * Zeta52 * T1 + Xi0p32 * Zeta52_dT * T1 + Xi0p32 * Zeta52 * T1_dT ) ; + + /*---------------------------------------------------* + * F11 := PS11/Pds. + *-----------------*/ + F11 = Ps0 * F10 + C_2o3 * beta_inv * Xilp32 - F30 ; + T1 = C_2o3 * beta_inv ; + F11_dVbs = Ps0_dVbs * F10 + Ps0 * F10_dVbs + + T1 * Xilp32_dVbs - F30_dVbs ; + F11_dVds = Ps0_dVds * F10 + Ps0 * F10_dVds + + T1 * Xilp32_dVds - F30_dVds ; + F11_dVgs = Ps0_dVgs * F10 + Ps0 * F10_dVgs + + T1 * Xilp32_dVgs - F30_dVgs ; + F11_dT = Ps0_dT * F10 + Ps0 * F10_dT + + C_2o3 *( beta_inv_dT * Xilp32 + beta_inv * Xilp32_dT ) - F30_dT ; + + /*---------------------------------------------------* + * Fdd := Idd/Pds. + *-----------------*/ + T1 = Vgp + beta_inv - 0.5e0 * ( 2.0e0 * Ps0 + Pds ) ; + T2 = - F10 + F00 ; + T3 = beta * Cox ; + T4 = beta * cnst0 ; + Fdd = T3 * T1 + T4 * T2 ; + Fdd_dVbs = T3 * ( Vgp_dVbs - Ps0_dVbs - 0.5e0 * Pds_dVbs ) + + beta * Cox_dVb * T1 + T4 * ( - F10_dVbs + F00_dVbs ) ; + Fdd_dVds = T3 * ( Vgp_dVds - Ps0_dVds - 0.5e0 * Pds_dVds ) + + beta * Cox_dVd * T1 + T4 * ( - F10_dVds + F00_dVds ) ; + Fdd_dVgs = T3 * ( Vgp_dVgs - Ps0_dVgs - 0.5e0 * Pds_dVgs ) + + beta * Cox_dVg * T1 + T4 * ( - F10_dVgs + F00_dVgs ) ; + T1_dT = Vgp_dT + beta_inv_dT - 0.5e0 * ( 2.0e0 * Ps0_dT + Pds_dT ) ; + T2_dT = -F10_dT + F00_dT ; + T3_dT = Cox * beta_dT ; + T4_dT = beta * cnst0_dT + cnst0 * beta_dT ; + Fdd_dT = T1 * T3_dT + T3 * T1_dT + T2 * T4_dT + T4 * T2_dT ; + + + /*---------------------------------------------------* + * Idd: + *-----------------*/ + Idd = Pds * Fdd ; + Idd_dVbs = Pds_dVbs * Fdd + Pds * Fdd_dVbs ; + Idd_dVds = Pds_dVds * Fdd + Pds * Fdd_dVds ; + Idd_dVgs = Pds_dVgs * Fdd + Pds * Fdd_dVgs ; + Idd_dT = Fdd * Pds_dT + Pds * Fdd_dT ; + + /*-----------------------------------------------------------* + * Skip CLM and integrated charges if zone==D1 + *-----------------*/ + if( flg_zone == 1 ) { + goto start_of_mobility ; + } + + /*-----------------------------------------------------------* + * Channel Length Modulation. Lred: \Delta L + *-----------------*/ + if( pParam->HSMHV_clm2 < epsm10 && pParam->HSMHV_clm3 < epsm10 ) { + Lred = 0.0e0 ; + Lred_dVbs = 0.0e0 ; + Lred_dVds = 0.0e0 ; + Lred_dVgs = 0.0e0 ; + Lred_dT = 0.0e0 ; + + Psdl = Psl ; + Psdl_dVbs = Psl_dVbs ; + Psdl_dVds = Psl_dVds ; + Psdl_dVgs = Psl_dVgs ; + Psdl_dT = Psl_dT ; + + if ( Psdl > Ps0 + Vds - epsm10 ) { + Psdl = Ps0 + Vds - epsm10 ; + Psdl_dVbs = Ps0_dVbs ; + Psdl_dVds = Ps0_dVds + 1.0 ; + Psdl_dVgs = Ps0_dVgs ; + Psdl_dT = Ps0_dT ; + } + + } else { + T1 = here->HSMHV_wdpl ; + T8 = sqrt (Psl - Vbscl) ; + Wd = T1 * T8 ; + T9 = 0.5 * T1 / T8 ; + Wd_dVbs = T9 * (Psl_dVbs - Vbscl_dVbs) ; + Wd_dVds = T9 * Psl_dVds ; + Wd_dVgs = T9 * Psl_dVgs ; + Wd_dT = T9 * Psl_dT ; + + T0 = 1.0 / Wd ; + T1 = Qn0 * T0 ; + T2 = pParam->HSMHV_clm3 * T1 ; + T3 = pParam->HSMHV_clm3 * T0 ; + T2_dVb = T3 * (Qn0_dVbs - T1 * Wd_dVbs) ; + T2_dVd = T3 * (Qn0_dVds - T1 * Wd_dVds) ; + T2_dVg = T3 * (Qn0_dVgs - T1 * Wd_dVgs) ; + T2_dT = T3 * (Qn0_dT - T1 * Wd_dT) ; + + T5 = pParam->HSMHV_clm2 * q_Nsub + T2 ; + T1 = 1.0 / T5 ; + T4 = C_ESI * T1 ; + T4_dVb = - T4 * T2_dVb * T1 ; + T4_dVd = - T4 * T2_dVd * T1 ; + T4_dVg = - T4 * T2_dVg * T1 ; + T4_dT = -T4 * T2_dT * T1 ; + + T1 = (1.0e0 - pParam->HSMHV_clm1) ; + Psdl = pParam->HSMHV_clm1 * (Vds + Ps0) + T1 * Psl ; + Psdl_dVbs = pParam->HSMHV_clm1 * Ps0_dVbs + T1 * Psl_dVbs ; + Psdl_dVds = pParam->HSMHV_clm1 * (1.0 + Ps0_dVds) + T1 * Psl_dVds ; + Psdl_dVgs = pParam->HSMHV_clm1 * Ps0_dVgs + T1 * Psl_dVgs ; + Psdl_dT = pParam->HSMHV_clm1 * Ps0_dT + T1 * Psl_dT ; + + if ( Psdl > Ps0 + Vds - epsm10 ) { + Psdl = Ps0 + Vds - epsm10 ; + Psdl_dVbs = Ps0_dVbs ; + Psdl_dVds = Ps0_dVds + 1.0 ; + Psdl_dVgs = Ps0_dVgs ; + Psdl_dT = Ps0_dT ; + } + T6 = Psdl - Psl ; + T6_dVb = Psdl_dVbs - Psl_dVbs ; + T6_dVd = Psdl_dVds - Psl_dVds ; + T6_dVg = Psdl_dVgs - Psl_dVgs ; + T6_dT = Psdl_dT - Psl_dT ; + + T3 = beta * Qn0 ; + T1 = 1.0 / T3 ; + T5 = Idd * T1 ; + T3_dT = beta * Qn0_dT + beta_dT * Qn0 ; + T1_dT = - T1 * T1 * T3_dT ; + T5_dT = Idd_dT * T1 + Idd * T1_dT ; + T2 = T5 * beta ; + T5_dVb = (Idd_dVbs - T2 * Qn0_dVbs) * T1 ; + T5_dVd = (Idd_dVds - T2 * Qn0_dVds) * T1 ; + T5_dVg = (Idd_dVgs - T2 * Qn0_dVgs) * T1 ; + + T10 = q_Nsub / C_ESI ; + T1 = 1.0e5 ; + T2 = 1.0 / Leff ; + T11 = (2.0 * T5 + 2.0 * T10 * T6 * T4 + T1 * T4) * T2 ; + T3 = T2 * T4 ; + T7 = T11 * T4 ; + T7_dVb = (2.0 * T5_dVb + 2.0 * T10 * (T6_dVb * T4 + T6 * T4_dVb) + T1 * T4_dVb) * T3 + T11 * T4_dVb ; + T7_dVd = (2.0 * T5_dVd + 2.0 * T10 * (T6_dVd * T4 + T6 * T4_dVd) + T1 * T4_dVd) * T3 + T11 * T4_dVd ; + T7_dVg = (2.0 * T5_dVg + 2.0 * T10 * (T6_dVg * T4 + T6 * T4_dVg) + T1 * T4_dVg) * T3 + T11 * T4_dVg ; + T7_dT = (2.0 * T5_dT + 2.0 * T10 * ( T6_dT * T4 + T6 * T4_dT ) + T1 * T4_dT ) * T3 + T11 * T4_dT ; + + T11 = 4.0 * (2.0 * T10 * T6 + T1) ; + T1 = 8.0 * T10 * T4 * T4 ; + T2 = 2.0 * T11 * T4 ; + T8 = T11 * T4 * T4 ; + T8_dVb = ( T1 * T6_dVb + T2 * T4_dVb) ; + T8_dVd = ( T1 * T6_dVd + T2 * T4_dVd) ; + T8_dVg = ( T1 * T6_dVg + T2 * T4_dVg) ; + T8_dT = ( T1 * T6_dT + T2 * T4_dT) ; + + T9 = sqrt (T7 * T7 + T8); + T1 = 1.0 / T9 ; + T2 = T7 * T1 ; + T3 = 0.5 * T1 ; + T9_dVb = (T2 * T7_dVb + T3 * T8_dVb) ; + T9_dVd = (T2 * T7_dVd + T3 * T8_dVd) ; + T9_dVg = (T2 * T7_dVg + T3 * T8_dVg) ; + T9_dT = (T2 * T7_dT + T3 * T8_dT) ; + + Lred = 0.5 * (- T7 + T9) ; + Lred_dVbs = 0.5 * (- T7_dVb + T9_dVb) ; + Lred_dVds = 0.5 * (- T7_dVd + T9_dVd) ; + Lred_dVgs = 0.5 * (- T7_dVg + T9_dVg) ; + Lred_dT = 0.5 * (- T7_dT + T9_dT ) ; + /*---------------------------------------------------* + * Modify Lred for symmetry. + *-----------------*/ + T1 = Lred ; + Lred = FMDVDS * T1 ; + Lred_dVbs = FMDVDS_dVbs * T1 + FMDVDS * Lred_dVbs ; + Lred_dVds = FMDVDS_dVds * T1 + FMDVDS * Lred_dVds ; + Lred_dVgs = FMDVDS_dVgs * T1 + FMDVDS * Lred_dVgs ; + Lred_dT = FMDVDS * Lred_dT ; + } + + /* CLM5 & CLM6 */ + Lred *= here->HSMHV_clmmod ; + Lred_dVbs *= here->HSMHV_clmmod ; + Lred_dVds *= here->HSMHV_clmmod ; + Lred_dVgs *= here->HSMHV_clmmod ; + Lred_dT *= here->HSMHV_clmmod ; + + /*---------------------------------------------------* + * Qbu : -Qb in unit area. + *-----------------*/ + T1 = Vgp + beta_inv ; + T2 = T1 * F10 - F11 ; + T1_dT = Vgp_dT + beta_inv_dT ; + T2_dT = T1_dT * F10 + T1 * F10_dT - F11_dT ; + + + Qbnm = cnst0 * ( cnst0 * ( 1.5e0 - ( Xi0 + 1.0e0 ) - 0.5e0 * beta * Pds ) + + Cox * T2 ) ; + Qbnm_dVbs = cnst0 * ( cnst0 * ( - Xi0_dVbs - 0.5e0 * beta * Pds_dVbs ) + + Cox * ( Vgp_dVbs * F10 + T1 * F10_dVbs - F11_dVbs ) + + Cox_dVb * T2 ) ; + Qbnm_dVds = cnst0 * ( cnst0 * ( - Xi0_dVds - 0.5e0 * beta * Pds_dVds ) + + Cox * ( Vgp_dVds * F10 + T1 * F10_dVds - F11_dVds ) + + Cox_dVd * T2 ) ; + Qbnm_dVgs = cnst0 * ( cnst0 * ( - Xi0_dVgs - 0.5e0 * beta * Pds_dVgs ) + + Cox * ( Vgp_dVgs * F10 + T1 * F10_dVgs - F11_dVgs ) + + Cox_dVg * T2 ) ; + Qbnm_dT = cnst0_dT * ( cnst0 * ( 1.5e0 - ( Xi0 + 1.0e0 ) - 0.5e0 * beta * Pds ) + + Cox * T2 ) + + cnst0 * ( cnst0_dT * ( 1.5e0 - ( Xi0 + 1.0e0 ) - 0.5e0 * beta * Pds ) + + cnst0 * ( - Xi0_dT - 0.5 * beta_dT * Pds - 0.5 * beta * Pds_dT ) + + Cox * T2_dT ); + + T1 = beta ; + Qbu = T1 * Qbnm / Fdd ; + T2 = T1 / ( Fdd * Fdd ) ; + Qbu_dVbs = T2 * ( Fdd * Qbnm_dVbs - Qbnm * Fdd_dVbs ) ; + Qbu_dVds = T2 * ( Fdd * Qbnm_dVds - Qbnm * Fdd_dVds ) ; + Qbu_dVgs = T2 * ( Fdd * Qbnm_dVgs - Qbnm * Fdd_dVgs ) ; + T1_dT = beta_dT ; + Qbu_dT = ( Fdd * ( T1_dT * Qbnm + T1 * Qbnm_dT ) - T1 * Qbnm * Fdd_dT ) / ( Fdd * Fdd ) ; + + /*---------------------------------------------------* + * preparation for Qi and Qd. + * - DtPds: Delta * Pds ; + * - Achi: (1+Delta) * Pds ; + *-----------------*/ + T1 = 2.0e0 * fac1 ; + DtPds = T1 * ( F10 - Xi0p12 ) ; + T2 = 2.0 * ( F10 - Xi0p12 ) ; + DtPds_dVbs = T1 * ( F10_dVbs - Xi0p12_dVbs ) + + T2 * fac1_dVbs ; + DtPds_dVds = T1 * ( F10_dVds - Xi0p12_dVds ) + + T2 * fac1_dVds ; + DtPds_dVgs = T1 * ( F10_dVgs - Xi0p12_dVgs ) + + T2 * fac1_dVgs ; + T1_dT = 2.0e0 * fac1_dT ; + DtPds_dT = T1_dT * ( F10 - Xi0p12 ) + T1 * ( F10_dT -Xi0p12_dT ) ; + + Achi = Pds + DtPds ; + Achi_dVbs = Pds_dVbs + DtPds_dVbs ; + Achi_dVds = Pds_dVds + DtPds_dVds ; + Achi_dVgs = Pds_dVgs + DtPds_dVgs ; + Achi_dT = Pds_dT + DtPds_dT ; + + /*-----------------------------------------------------------* + * Alpha : parameter to evaluate charges. + * - Achi: (1+Delta) * Pds ; + * - clamped to 0 if Alpha < 0. + *-----------------*/ + T1 = 1.0 / VgVt ; + T2 = Achi * T1 ; + T3 = 1.0e0 - T2 ; + TX = 1.0 - T3 ; + Fn_CP( TY , TX , 1.0 , 4 , T4 ) ; + Alpha = 1.0 - TY ; + T5 = T1 * T4 ; + Alpha_dVbs = - ( Achi_dVbs - T2 * VgVt_dVbs ) * T5 ; + Alpha_dVds = - ( Achi_dVds - T2 * VgVt_dVds ) * T5 ; + Alpha_dVgs = - ( Achi_dVgs - T2 * VgVt_dVgs ) * T5 ; + Alpha_dT = - ( Achi_dT - T2 * VgVt_dT ) * T5 ; + + + /*-----------------------------------------------------------* + * Qiu : -Qi in unit area. + *-----------------*/ + + Qinm = 1.0e0 + Alpha * ( 1.0e0 + Alpha ) ; + T1 = 1.0e0 + Alpha + Alpha ; + Qinm_dVbs = Alpha_dVbs * T1 ; + Qinm_dVds = Alpha_dVds * T1 ; + Qinm_dVgs = Alpha_dVgs * T1 ; + Qinm_dT = Alpha_dT * T1 ; + + Qidn = Fn_Max( 1.0e0 + Alpha , epsm10 ) ; + Qidn_dVbs = Alpha_dVbs ; + Qidn_dVds = Alpha_dVds ; + Qidn_dVgs = Alpha_dVgs ; + Qidn_dT = Alpha_dT ; + + T1 = C_2o3 * VgVt * Qinm / Qidn ; + Qiu = T1 * Cox ; + T2 = 1.0 / VgVt ; + T3 = 1.0 / Qinm ; + T4 = 1.0 / Qidn ; + Qiu_dVbs = Qiu * ( VgVt_dVbs * T2 + Qinm_dVbs * T3 - Qidn_dVbs * T4 ) + + T1 * Cox_dVb ; + Qiu_dVds = Qiu * ( VgVt_dVds * T2 + Qinm_dVds * T3 - Qidn_dVds * T4) + + T1 * Cox_dVd ; + Qiu_dVgs = Qiu * ( VgVt_dVgs * T2 + Qinm_dVgs * T3 - Qidn_dVgs * T4) + + T1 * Cox_dVg ; + T1_dT = C_2o3 * ( Qidn * ( VgVt_dT * Qinm + VgVt * Qinm_dT ) - Qidn_dT * VgVt * Qinm ) + / ( Qidn * Qidn ) ; + Qiu_dT = Cox * T1_dT ; + + + /*-----------------------------------------------------------* + * Qdrat : Qd/Qi + *-----------------*/ + Qdnm = 0.5e0 + Alpha ; + Qdnm_dVbs = Alpha_dVbs ; + Qdnm_dVds = Alpha_dVds ; + Qdnm_dVgs = Alpha_dVgs ; + Qdnm_dT = Alpha_dT ; + + Qddn = Qidn * Qinm ; + Qddn_dVbs = Qidn_dVbs * Qinm + Qidn * Qinm_dVbs ; + Qddn_dVds = Qidn_dVds * Qinm + Qidn * Qinm_dVds ; + Qddn_dVgs = Qidn_dVgs * Qinm + Qidn * Qinm_dVgs ; + Qddn_dT = Qidn_dT * Qinm + Qidn * Qinm_dT ; + + Quot = 0.4e0 * Qdnm / Qddn ; + Qdrat = 0.6e0 - Quot ; + + if ( Qdrat <= 0.5e0 ) { + T1 = 1.0 / Qddn ; + T2 = 1.0 / Qdnm ; + Qdrat_dVbs = Quot * ( Qddn_dVbs * T1 - Qdnm_dVbs * T2 ) ; + Qdrat_dVds = Quot * ( Qddn_dVds * T1 - Qdnm_dVds * T2 ) ; + Qdrat_dVgs = Quot * ( Qddn_dVgs * T1 - Qdnm_dVgs * T2 ) ; + Qdrat_dT = Quot * ( Qddn_dT * T1 - Qdnm_dT * T2 ) ; + } else { + Qdrat = 0.5e0 ; + Qdrat_dVbs = 0.0e0 ; + Qdrat_dVds = 0.0e0 ; + Qdrat_dVgs = 0.0e0 ; + Qdrat_dT = 0.0e0 ; + + } + + + /*-----------------------------------------------------------* + * Interpolate charges and CLM for zone-D2. + *-----------------*/ + + if ( flg_zone == 2 ) { + T1 = Qbu ; + Qbu = FD2 * Qbu + ( 1.0 - FD2 ) * Qb0 ; + Qbu_dVbs = FD2 * Qbu_dVbs + FD2_dVbs * T1 + + ( 1.0 - FD2 ) * Qb0_dVb - FD2_dVbs * Qb0 ; + Qbu_dVds = FD2 * Qbu_dVds + FD2_dVds * T1 + + ( 1.0 - FD2 ) * Qb0_dVd - FD2_dVds * Qb0 ; + Qbu_dVgs = FD2 * Qbu_dVgs + FD2_dVgs * T1 + + ( 1.0 - FD2 ) * Qb0_dVg - FD2_dVgs * Qb0 ; + Qbu_dT = FD2 * Qbu_dT + FD2_dT * T1 + + ( 1.0 - FD2 ) * Qb0_dT - FD2_dT * Qb0 ; + + if ( Qbu < 0.0 ) { + Qbu = 0.0 ; + Qbu_dVbs = 0.0 ; + Qbu_dVds = 0.0 ; + Qbu_dVgs = 0.0 ; + Qbu_dT = 0.0 ; + } + T1 = Qiu ; + Qiu = FD2 * Qiu + ( 1.0 - FD2 ) * Qn0 ; + Qiu_dVbs = FD2 * Qiu_dVbs + FD2_dVbs * T1 + + ( 1.0 - FD2 ) * Qn0_dVbs - FD2_dVbs * Qn0 ; + Qiu_dVds = FD2 * Qiu_dVds + FD2_dVds * T1 + + ( 1.0 - FD2 ) * Qn0_dVds - FD2_dVds * Qn0 ; + Qiu_dVgs = FD2 * Qiu_dVgs + FD2_dVgs * T1 + + ( 1.0 - FD2 ) * Qn0_dVgs - FD2_dVgs * Qn0 ; + Qiu_dT = FD2 * Qiu_dT + FD2_dT * T1 + + ( 1.0 - FD2 ) * Qn0_dT - FD2_dT * Qn0 ; + + if ( Qiu < 0.0 ) { + Qiu = 0.0 ; + Qiu_dVbs = 0.0 ; + Qiu_dVds = 0.0 ; + Qiu_dVgs = 0.0 ; + Qiu_dT = 0.0 ; + } + + T1 = Qdrat ; + Qdrat = FD2 * Qdrat + ( 1.0 - FD2 ) * 0.5e0 ; + Qdrat_dVbs = FD2 * Qdrat_dVbs + FD2_dVbs * T1 - FD2_dVbs * 0.5e0 ; + Qdrat_dVds = FD2 * Qdrat_dVds + FD2_dVds * T1 - FD2_dVds * 0.5e0 ; + Qdrat_dVgs = FD2 * Qdrat_dVgs + FD2_dVgs * T1 - FD2_dVgs * 0.5e0 ; + Qdrat_dT = FD2 * Qdrat_dT + FD2_dT * T1 - FD2_dT * 0.5e0 ; + + /* note: Lred=0 in zone-D1 */ + T1 = Lred ; + Lred = FD2 * Lred ; + Lred_dVbs = FD2 * Lred_dVbs + FD2_dVbs * T1 ; + Lred_dVds = FD2 * Lred_dVds + FD2_dVds * T1 ; + Lred_dVgs = FD2 * Lred_dVgs + FD2_dVgs * T1 ; + Lred_dT = FD2 * Lred_dT + FD2_dT * T1 ; + + } /* end of flg_zone==2 if-block */ + + +start_of_mobility: + + Lch = Leff - Lred ; + if ( Lch < 1.0e-9 ) { + fprintf ( stderr , "*** warning(HiSIM): actual channel length is too small. (Lch=%e[m])\n" , Lch ) ; + fprintf ( stderr , " CLM5 and/or CLM6 might be too large.\n" ) ; + Lch = 1.0e-9 ; Lch_dVbs = Lch_dVds = Lch_dVgs = 0.0 ; + Lch_dT = 0.0 ; + } else { Lch_dVbs = - Lred_dVbs ; Lch_dVds = - Lred_dVds ; Lch_dVgs = - Lred_dVgs ; + Lch_dT = - Lred_dT ; + } + + /*-----------------------------------------------------------* + * Muun : universal mobility. (CGS unit) + *-----------------*/ + + T1 = here->HSMHV_ndep_o_esi ; + T2 = here->HSMHV_ninv_o_esi ; + + T0 = here->HSMHV_ninvd ; + T4 = 1.0 + ( Psl - Ps0 ) * T0 ; + T4_dVb = ( Psl_dVbs - Ps0_dVbs ) * T0 ; + T4_dVd = ( Psl_dVds - Ps0_dVds ) * T0 ; + T4_dVg = ( Psl_dVgs - Ps0_dVgs ) * T0 ; + T4_dT = ( Psl_dT - Ps0_dT ) * T0 + ( Psl - Ps0 ) * ninvd_dT ; + + T5 = T1 * Qbu + T2 * Qiu ; + T5_dVb = T1 * Qbu_dVbs + T2 * Qiu_dVbs ; + T5_dVd = T1 * Qbu_dVds + T2 * Qiu_dVds ; + T5_dVg = T1 * Qbu_dVgs + T2 * Qiu_dVgs ; + T5_dT = T1 * Qbu_dT + T2 * Qiu_dT ; + + T3 = T5 / T4 ; + T3_dVb = ( - T4_dVb * T5 + T4 * T5_dVb ) / T4 / T4 ; + T3_dVd = ( - T4_dVd * T5 + T4 * T5_dVd ) / T4 / T4 ; + T3_dVg = ( - T4_dVg * T5 + T4 * T5_dVg ) / T4 / T4 ; + T3_dT = ( - T4_dT * T5 + T4 * T5_dT ) / T4 / T4 ; + + Eeff = T3 ; + Eeff_dVbs = T3_dVb ; + Eeff_dVds = T3_dVd ; + Eeff_dVgs = T3_dVg ; + Eeff_dT = T3_dT ; + + T5 = Fn_Pow( Eeff , model->HSMHV_mueph0 - 1.0e0 ) ; + T8 = T5 * Eeff ; + T7 = Fn_Pow( Eeff , here->HSMHV_muesr - 1.0e0 ) ; + T6 = T7 * Eeff ; + T8_dT = model->HSMHV_mueph0 * T5 * Eeff_dT ; + T6_dT = here->HSMHV_muesr * T7 * Eeff_dT ; + + + T9 = C_QE * C_m2cm_p2 ; + Rns = Qiu / T9 ; + Rns_dT = Qiu_dT / T9 ; + + T1 = 1.0e0 / ( pParam->HSMHV_muecb0 + pParam->HSMHV_muecb1 * Rns / 1.0e11 ) + + here->HSMHV_mphn0 * T8 + T6 / pParam->HSMHV_muesr1 ; + + + T1_dT = - 1.0e0 / ( pParam->HSMHV_muecb0 + pParam->HSMHV_muecb1 * Rns / 1.0e11 ) + / ( pParam->HSMHV_muecb0 + pParam->HSMHV_muecb1 * Rns / 1.0e11 ) + * pParam->HSMHV_muecb1 * Rns_dT / 1.0e11 + + here->HSMHV_mphn0 * T8_dT + mphn0_dT * T8 + T6_dT / pParam->HSMHV_muesr1 ; + + Muun = 1.0e0 / T1 ; + Muun_dT = - Muun / T1 * T1_dT ; + + T1 = 1.0e0 / ( T1 * T1 ) ; + T2 = pParam->HSMHV_muecb0 + pParam->HSMHV_muecb1 * Rns / 1.0e11 ; + T2 = 1.0e0 / ( T2 * T2 ) ; + T3 = here->HSMHV_mphn1 * T5 ; + T4 = here->HSMHV_muesr * T7 / pParam->HSMHV_muesr1 ; + T5 = - 1.0e-11 * pParam->HSMHV_muecb1 / C_QE * T2 / C_m2cm_p2 ; + Muun_dVbs = - ( T5 * Qiu_dVbs + + Eeff_dVbs * T3 + Eeff_dVbs * T4 ) * T1 ; + Muun_dVds = - ( T5 * Qiu_dVds + + Eeff_dVds * T3 + Eeff_dVds * T4 ) * T1 ; + Muun_dVgs = - ( T5 * Qiu_dVgs + + Eeff_dVgs * T3 + Eeff_dVgs * T4 ) * T1 ; + + /* Change to MKS unit */ + Muun /= C_m2cm_p2 ; + Muun_dT /= C_m2cm_p2 ; + Muun_dVbs /= C_m2cm_p2 ; + Muun_dVds /= C_m2cm_p2 ; + Muun_dVgs /= C_m2cm_p2 ; + + /*-----------------------------------------------------------* + * Mu : mobility + *-----------------*/ + T2 = beta * (Qn0 + small) * Lch ; + + + T1 = 1.0e0 / T2 ; + T3 = T1 * T1 ; + T4 = - beta * T3 ; + T5 = T4 * Lch ; + T6 = T4 * (Qn0 + small) ; + T1_dVb = ( T5 * Qn0_dVbs + T6 * Lch_dVbs) ; + T1_dVd = ( T5 * Qn0_dVds + T6 * Lch_dVds) ; + T1_dVg = ( T5 * Qn0_dVgs + T6 * Lch_dVgs) ; + T2_dT = beta_dT * (Qn0 + small) * Lch + beta * Qn0_dT * Lch + beta * (Qn0 + small) * Lch_dT ; + T1_dT = - T1 / T2 * T2_dT ; + + TY = Idd * T1 ; + TY_dVbs = Idd_dVbs * T1 + Idd * T1_dVb ; + TY_dVds = Idd_dVds * T1 + Idd * T1_dVd ; + TY_dVgs = Idd_dVgs * T1 + Idd * T1_dVg ; + TY_dT = Idd_dT * T1 + Idd * T1_dT ; + + T2 = 0.2 * Vmax / Muun ; + T3 = - T2 / Muun ; + T2_dVb = T3 * Muun_dVbs ; + T2_dVd = T3 * Muun_dVds ; + T2_dVg = T3 * Muun_dVgs ; + T2_dT = 0.2 * ( Vmax_dT * Muun - Muun_dT * Vmax )/ ( Muun * Muun ) ; + + Ey = sqrt( TY * TY + T2 * T2 ) ; + T4 = 1.0 / Ey ; + Ey_dVbs = T4 * ( TY * TY_dVbs + T2 * T2_dVb ) ; + Ey_dVds = T4 * ( TY * TY_dVds + T2 * T2_dVd ) ; + Ey_dVgs = T4 * ( TY * TY_dVgs + T2 * T2_dVg ) ; + Ey_dT = T4 * ( TY * TY_dT + T2 * T2_dT ) ; + + Em = Muun * Ey ; + Em_dVbs = Muun_dVbs * Ey + Muun * Ey_dVbs ; + Em_dVds = Muun_dVds * Ey + Muun * Ey_dVds ; + Em_dVgs = Muun_dVgs * Ey + Muun * Ey_dVgs ; + Em_dT = Ey * Muun_dT + Ey_dT * Muun ; + + T1 = Em / Vmax ; + T1_dT = ( Em_dT * Vmax - Vmax_dT * Em ) / ( Vmax * Vmax ); + + /* note: model->HSMHV_bb = 2 (electron) ;1 (hole) */ + if ( 1.0e0 - epsm10 <= model->HSMHV_bb && model->HSMHV_bb <= 1.0e0 + epsm10 ) { + T3 = 1.0e0 ; + T3_dT = 0.0e0 ; + } else if ( 2.0e0 - epsm10 <= model->HSMHV_bb && model->HSMHV_bb <= 2.0e0 + epsm10 ) { + T3 = T1 ; + T3_dT = T1_dT ; + } else { + T3 = Fn_Pow( T1 , model->HSMHV_bb - 1.0e0 ) ; + T3_dT = ( model->HSMHV_bb - 1.0e0 )* Fn_Pow( T1 , model->HSMHV_bb - 2.0e0 ) * T1_dT ; + } + T2 = T1 * T3 ; + T4 = 1.0e0 + T2 ; + T2_dT = T1 * T3_dT + T3 * T1_dT ; + T4_dT = T2_dT ; + + if ( 1.0e0 - epsm10 <= model->HSMHV_bb && model->HSMHV_bb <= 1.0e0 + epsm10 ) { + T5 = 1.0 / T4 ; + T6 = T5 / T4 ; + T5_dT = - T5 * T5 * T4_dT ; + T6_dT = T5 * T5 * ( T5_dT * T4 - T5 * T4_dT ) ; + } else if ( 2.0e0 - epsm10 <= model->HSMHV_bb && model->HSMHV_bb <= 2.0e0 + epsm10 ) { + T5 = 1.0 / sqrt( T4 ) ; + T6 = T5 / T4 ; + T5_dT = - 0.5e0 / ( T4 * sqrt(T4)) * T4_dT ; + T6_dT = ( T5_dT * T4 - T5 * T4_dT ) / T4 / T4 ; + } else { + T6 = Fn_Pow( T4 , ( - 1.0e0 / model->HSMHV_bb - 1.0e0 ) ) ; + T5 = T4 * T6 ; + T6_dT =( - 1.0e0 / model->HSMHV_bb - 1.0e0 ) * Fn_Pow( T4 , ( - 1.0e0 / model->HSMHV_bb - 2.0e0 ) ) * T4_dT ; + T5_dT = T4_dT * T6 + T4 * T6_dT ; + } + + T7 = Muun / Vmax * T6 * T3 ; + + Mu = Muun * T5 ; + Mu_dVbs = Muun_dVbs * T5 - T7 * Em_dVbs ; + Mu_dVds = Muun_dVds * T5 - T7 * Em_dVds ; + Mu_dVgs = Muun_dVgs * T5 - T7 * Em_dVgs ; + Mu_dT = Muun_dT * T5 + Muun * T5_dT ; + +/* end_of_mobility : +*/ + /*-----------------------------------------------------------* + * Ids: channel current. + *-----------------*/ + betaWL = here->HSMHV_weff_nf * beta_inv / Lch ; + T1 = - betaWL / Lch ; + betaWL_dVbs = T1 * Lch_dVbs ; + betaWL_dVds = T1 * Lch_dVds ; + betaWL_dVgs = T1 * Lch_dVgs ; + betaWL_dT = here->HSMHV_weff_nf * ( beta_inv_dT * Lch - beta_inv * Lch_dT ) / ( Lch * Lch ) ; + + Ids0 = betaWL * Idd * Mu ; + T1 = betaWL * Idd ; + T2 = Idd * Mu ; + T3 = Mu * betaWL ; + Ids0_dVbs = T3 * Idd_dVbs + T1 * Mu_dVbs + T2 * betaWL_dVbs ; + Ids0_dVds = T3 * Idd_dVds + T1 * Mu_dVds + T2 * betaWL_dVds ; + Ids0_dVgs = T3 * Idd_dVgs + T1 * Mu_dVgs + T2 * betaWL_dVgs ; + Ids0_dT = T3 * Idd_dT + T1 * Mu_dT + T2 * betaWL_dT ; + + /* note: rpock procedure was removed. */ + if( flg_rsrd == 2 || flg_rsrd == 3 ){ + if( model->HSMHV_rd20 > 0.0 ){ + T4 = here->HSMHV_rd23 ; + T1 = pParam->HSMHV_rd24 * ( Vgse - model->HSMHV_rd25 ) ; + T1_dVg = pParam->HSMHV_rd24 ; + + Fn_SL( T2 , T1 , T4 , delta_rd , T0 ) ; + T2_dVg = T1_dVg * T0 ; + T3 = T4 * ( model->HSMHV_rd20 + 1.0 ) ; + Fn_SU( T7 , T2 , T3 , delta_rd , T0 ) ; + T7_dVg = T2_dVg * T0 ; + + }else{ + T7 = here->HSMHV_rd23; + T7_dVg = 0.0e0 ; + } + + /* after testing we can remove Vdse_eff_dVbs, Vdse_eff_dVds, Vdse_eff_dVgs + and Vdse_eff_dVbse, Vdse_eff_dVgse */ + if (Vdse >= 0.0) { + Vdse_eff = Vdse ; + /* Vdse_eff_dVbs = 0.0 ; */ + /* Vdse_eff_dVds = 0.0 ; */ + /* Vdse_eff_dVgs = 0.0 ; */ + /* Vdse_eff_dVbse = 0.0 ; */ + Vdse_eff_dVdse = 1.0 ; + /* Vdse_eff_dVgse = 0.0 ; */ + } else { + Vdse_eff = 0.0 ; + /* Vdse_eff_dVbs = 0.0 ; */ + /* Vdse_eff_dVds = 0.0 ; */ + /* Vdse_eff_dVgs = 0.0 ; */ + /* Vdse_eff_dVbse = 0.0 ; */ + Vdse_eff_dVdse = 0.0 ; + /* Vdse_eff_dVgse = 0.0 ; */ + } + + /* smoothing of Ra for Vdse_eff close to zero */ + /* ... smoothing parameter is Ra_N */ + if (Vdse_eff < Ra_N * small2) { + Ra_alpha = pow( Ra_N+1.0 , model->HSMHV_rd21-1.0 ) + * (Ra_N+1.0-0.5*model->HSMHV_rd21*Ra_N) + * pow( small2,model->HSMHV_rd21 ); + Ra_beta = 0.5*model->HSMHV_rd21 + * pow( Ra_N+1.0 , model->HSMHV_rd21-1.0 ) / Ra_N + * pow( small2, model->HSMHV_rd21-2.0 ); + T1 = Ra_alpha + Ra_beta*Vdse_eff*Vdse_eff; + T1_dVdse_eff = 2.0 * Ra_beta * Vdse_eff; + } else { + T1 = pow( Vdse_eff + small2 , model->HSMHV_rd21 ) ; + T1_dVdse_eff = model->HSMHV_rd21 * pow( Vdse_eff + small2 , model->HSMHV_rd21 - 1.0 ) ; + } + + T9 = pow( Vdse_eff + small2 , model->HSMHV_rd22d ) ; + T9_dVdse_eff = model->HSMHV_rd22d * pow( Vdse_eff + small2 , model->HSMHV_rd22d - 1.0 ) ; + + Ra = ( T7 * T1 + Vbse * pParam->HSMHV_rd22 * T9 ) / here->HSMHV_weff_nf ; + Ra_dVdse_eff = ( T7 * T1_dVdse_eff + Vbse * pParam->HSMHV_rd22 * T9_dVdse_eff ) / here->HSMHV_weff_nf ; + Ra_dVbs = Ra_dVdse_eff * Vdse_eff_dVbs ; + Ra_dVds = Ra_dVdse_eff * Vdse_eff_dVds ; + Ra_dVgs = Ra_dVdse_eff * Vdse_eff_dVgs + T7_dVg * T1 / here->HSMHV_weff_nf ; + Ra_dVbse = Ra_dVdse_eff * Vdse_eff_dVbse + pParam->HSMHV_rd22 * T9 / here->HSMHV_weff_nf ; + Ra_dVdse = Ra_dVdse_eff * Vdse_eff_dVdse ; + Ra_dVgse = Ra_dVdse_eff * Vdse_eff_dVgse ; + + T0 = Ra * Ids0 ; + T0_dVb = Ra_dVbs * Ids0 + Ra * Ids0_dVbs ; + T0_dVd = Ra_dVds * Ids0 + Ra * Ids0_dVds ; + T0_dVg = Ra_dVgs * Ids0 + Ra * Ids0_dVgs ; + T0_dT = Ra * Ids0_dT ; + + T1 = Vds + small ; + T2 = 1.0 / T1 ; + T3 = 1.0 + T0 * T2 ; + T3_dVb = T0_dVb * T2 ; + T3_dVd = ( T0_dVd * T1 - T0 ) * T2 * T2 ; + T3_dVg = T0_dVg * T2 ; + T3_dT = T0_dT * T2 ; + + T4 = 1.0 / T3 ; + Ids = Ids0 * T4 ; + T5 = T4 * T4 ; + Ids_dVbs = ( Ids0_dVbs * T3 - Ids0 * T3_dVb ) * T5 ; + Ids_dVds = ( Ids0_dVds * T3 - Ids0 * T3_dVd ) * T5 ; + Ids_dVgs = ( Ids0_dVgs * T3 - Ids0 * T3_dVg ) * T5 ; + Ids_dT = ( Ids0_dT * T3 - Ids0 * T3_dT ) * T5 ; + Ids_dRa = - Ids * Ids / ( Vds + small ) ; + + } else { + Ids = Ids0 ; + Ids_dVbs = Ids0_dVbs ; + Ids_dVds = Ids0_dVds ; + Ids_dVgs = Ids0_dVgs ; + Ids_dT = Ids0_dT ; + Ra = 0.0 ; + Ra_dVbs = Ra_dVds = Ra_dVgs = 0.0 ; + Ra_dVbse = Ra_dVdse = Ra_dVgse = 0.0 ; + Ids_dRa = 0.0 ; + } + /* just for testing -- can be removed */ + /* if (!(ckt->CKTmode & MODEINITPRED)) + printf("rrb %e %e %e %e %e %e\n",ckt->CKTtime,here->HSMHV_mode*Vdse,Ra,Ra_dVdse, + Vdse_eff,Vdse_eff_dVdse) ; */ + + /* if ( Pds < ps_conv ) { */ + if ( Pds < 0.0 ) { + Ids_dVbs = 0.0 ; + Ids_dVgs = 0.0 ; + Ids_dT = 0.0 ; + } + + Ids += Gdsmin * Vds ; + Ids_dVds += Gdsmin ; + + + /*-----------------------------------------------------------* + * STI + *-----------------*/ + if ( model->HSMHV_coisti != 0 ) { + /*---------------------------------------------------* + * dVthSCSTI : Short-channel effect induced by Vds (STI). + *-----------------*/ + T1 = C_ESI * Cox_inv ; + T2 = here->HSMHV_wdpl ; + T3 = here->HSMHV_lgatesm - model->HSMHV_parl2 ; + T4 = 1.0 / (T3 * T3) ; + T5 = 2.0 * (model->HSMHV_vbi - Pb20b) * T1 * T2 * T4 ; + + dVth0 = T5 * sqrt_Pbsum ; + T6 = T5 * 0.5 / sqrt_Pbsum ; + T7 = 2.0 * (model->HSMHV_vbi - Pb20b) * C_ESI * T2 * T4 * sqrt_Pbsum ; + T8 = - 2.0 * T1 * T2 * T4 * sqrt_Pbsum ; + dVth0_dVb = T6 * Pbsum_dVb + T7 * Cox_inv_dVb + T8 * Pb20b_dVb ; + dVth0_dVd = T6 * Pbsum_dVd + T7 * Cox_inv_dVd + T8 * Pb20b_dVd ; + dVth0_dVg = T6 * Pbsum_dVg + T7 * Cox_inv_dVg + T8 * Pb20b_dVg ; + dVth0_dT = T6 * Pbsum_dT + T8 * Pb20b_dT ; + + T4 = pParam->HSMHV_scsti1 ; + T6 = pParam->HSMHV_scsti2 ; + T1 = T4 + T6 * Vdsz ; + dVthSCSTI = dVth0 * T1 ; + dVthSCSTI_dVb = dVth0_dVb * T1 + dVth0 * T6 * Vdsz_dVbs ; + dVthSCSTI_dVd = dVth0_dVd * T1 + dVth0 * T6 * Vdsz_dVds ; + dVthSCSTI_dVg = dVth0_dVg * T1 ; + dVthSCSTI_dT = dVth0_dT * T1 ; + + T1 = pParam->HSMHV_vthsti - model->HSMHV_vdsti * Vds ; + T1_dVd = - model->HSMHV_vdsti ; + + Vgssti = Vgsz - Vfb + T1 + dVthSCSTI ; + Vgssti_dVbs = Vgsz_dVbs + dVthSCSTI_dVb ; + Vgssti_dVds = Vgsz_dVds + T1_dVd + dVthSCSTI_dVd ; + Vgssti_dVgs = Vgsz_dVgs + dVthSCSTI_dVg ; + Vgssti_dT = dVthSCSTI_dT ; + + costi0 = here->HSMHV_costi0 ; + costi1 = here->HSMHV_costi1 ; + + costi3 = here->HSMHV_costi0_p2 * Cox_inv * Cox_inv ; + T1 = 2.0 * here->HSMHV_costi0_p2 * Cox_inv ; + costi3_dVb = T1 * Cox_inv_dVb ; + costi3_dVd = T1 * Cox_inv_dVd ; + costi3_dVg = T1 * Cox_inv_dVg ; + costi3_dT = 2 * here->HSMHV_costi0 * here->HSMHV_costi00 * 0.5 / sqrt(here->HSMHV_beta_inv) * beta_inv_dT * Cox_inv * Cox_inv ; + T2 = 1.0 / costi3 ; + costi3_dVb_c3 = costi3_dVb * T2 ; + costi3_dVd_c3 = costi3_dVd * T2 ; + costi3_dVg_c3 = costi3_dVg * T2 ; + costi3_dT_c3 = costi3_dT * T2 ; + + costi4 = costi3 * beta * 0.5 ; + costi4_dT = ( costi3_dT * beta + costi3 * beta_dT ) * 0.5 ; + costi5 = costi4 * beta * 2.0 ; + costi5_dT = ( costi4_dT * beta + costi4 * beta_dT ) * 2.0 ; + + T11 = beta * 0.25 ; + T11_dT = beta_dT * 0.25 ; + T10 = beta_inv - costi3 * T11 + Vfb - pParam->HSMHV_vthsti - dVthSCSTI + small ; + T10_dVb = - T11 * costi3_dVb - dVthSCSTI_dVb ; + T10_dVd = - T11 * costi3_dVd - dVthSCSTI_dVd ; + T10_dVg = - T11 * costi3_dVg - dVthSCSTI_dVg ; + T10_dT = beta_inv_dT - ( costi3_dT * T11 + costi3 * T11_dT ) - dVthSCSTI_dT ; + + T1 = Vgsz - T10 - psisti_dlt ; + T1_dVb = Vgsz_dVbs - T10_dVb ; + T1_dVd = Vgsz_dVds - T10_dVd ; + T1_dVg = Vgsz_dVgs - T10_dVg ; + T1_dT = - T10_dT ; + T0 = Fn_Sgn(T10) ; + T2 = sqrt (T1 * T1 + T0 * 4.0 * T10 * psisti_dlt) ; + T3 = T10 + 0.5 * (T1 + T2) - Vfb + pParam->HSMHV_vthsti + dVthSCSTI - Vbsz ; + T3_dVb = T10_dVb + 0.5 * (T1_dVb + (T1 * T1_dVb + T0 * 2.0 * T10_dVb * psisti_dlt) / T2) + + dVthSCSTI_dVb - Vbsz_dVbs ; + T3_dVd = T10_dVd + 0.5 * (T1_dVd + (T1 * T1_dVd + T0 * 2.0 * T10_dVd * psisti_dlt) / T2) + + dVthSCSTI_dVd - Vbsz_dVds ; + T3_dVg = T10_dVg + 0.5 * (T1_dVg + (T1 * T1_dVg + T0 * 2.0 * T10_dVg * psisti_dlt) / T2) + + dVthSCSTI_dVg ; + T3_dT = T10_dT + 0.5 * (T1_dT + (T1 * T1_dT + T0 * 2.0 * T10_dT * psisti_dlt) / T2) + + dVthSCSTI_dT ; + + T4 = beta * T3 - 1.0 ; + T4_dT = beta_dT * T3 + beta * T3_dT ; + T5 = 4.0 / costi5 ; + T5_dT = - 4.0 / ( costi5 * costi5 ) * costi5_dT ; + T1 = 1.0 + T4 * T5 ; + T6 = beta * T5 ; + T7 = T4 * T5 ; + T1_dVb = (T6 * T3_dVb - T7 * costi3_dVb_c3) ; + T1_dVd = (T6 * T3_dVd - T7 * costi3_dVd_c3) ; + T1_dVg = (T6 * T3_dVg - T7 * costi3_dVg_c3) ; + T1_dT = T4_dT * T5 + T4 * T5_dT ; + Fn_SZ( T1 , T1, 1.0e-2, T2) ; + T1_dVb *= T2 ; + T1_dVd *= T2 ; + T1_dVg *= T2 ; + T1_dT *= T2 ; + costi6 = sqrt(T1) ; + costi6_dT = 0.5 / sqrt(T1) * T1_dT ; + T0 = costi4 * (1.0 - costi6) ; + T0_dT = costi4_dT * (1.0 - costi6) + costi4 * ( - costi6_dT ) ; + Psasti = Vgssti + T0 ; + T2 = 0.5 * costi4 / costi6 ; + Psasti_dVbs = Vgssti_dVbs + costi3_dVb_c3 * T0 - T2 * T1_dVb ; + Psasti_dVds = Vgssti_dVds + costi3_dVd_c3 * T0 - T2 * T1_dVd ; + Psasti_dVgs = Vgssti_dVgs + costi3_dVg_c3 * T0 - T2 * T1_dVg ; + Psasti_dT = Vgssti_dT + T0_dT ; + + T0 = 1.0 / (beta + 2.0 / (Vgssti + small)) ; + T0_dT = - 1.0 / ((beta + 2.0 / (Vgssti + small)) * (beta + 2.0 / (Vgssti + small))) * ( beta_dT - 2 / ((Vgssti + small) * (Vgssti + small)) * Vgssti_dT ); + Psbsti = log (1.0 / costi1 / costi3 * (Vgssti * Vgssti)) * T0 ; + T1 = 1 / costi1 / costi3 * (Vgssti * Vgssti) ; + + costi1_dT = 2 * here->HSMHV_nin * Nin_dT * here->HSMHV_nsti_p2 ; + + T1_dT = ( - 1 / costi1 / costi1 * costi1_dT / costi3 - 1 / costi3 / costi3 * costi3_dT / costi1 ) * Vgssti * Vgssti + 1 / costi1 / costi3 * 2 * Vgssti * Vgssti_dT ; + T2 = 2.0 * T0 / (Vgssti + small) ; + T3 = Psbsti / (Vgssti + small) ; + Psbsti_dVbs = T2 * (Vgssti_dVbs - 0.5 * costi3_dVb_c3 * Vgssti + + T3 * Vgssti_dVbs ) ; + Psbsti_dVds = T2 * (Vgssti_dVds - 0.5 * costi3_dVd_c3 * Vgssti + + T3 * Vgssti_dVds ) ; + Psbsti_dVgs = T2 * (Vgssti_dVgs - 0.5 * costi3_dVg_c3 * Vgssti + + T3 * Vgssti_dVgs ) ; + Psbsti_dT = 1 / T1 * T1_dT * T0 + log( T1 ) * T0_dT ; + + Psab = Psbsti - Psasti - sti2_dlt ; + Psab_dVbs = Psbsti_dVbs - Psasti_dVbs ; + Psab_dVds = Psbsti_dVds - Psasti_dVds ; + Psab_dVgs = Psbsti_dVgs - Psasti_dVgs ; + Psab_dT = Psbsti_dT - Psasti_dT ; + T0 = sqrt (Psab * Psab + 4.0 * sti2_dlt * Psbsti) ; + Psti = Psbsti - 0.5 * (Psab + T0) ; + T1 = 1.0 / T0 ; + Psti_dVbs = Psbsti_dVbs + - 0.5 * ( Psab_dVbs + + ( Psab * Psab_dVbs + 2.0 * sti2_dlt * Psbsti_dVbs ) * T1 ) ; + Psti_dVds = Psbsti_dVds + - 0.5 * ( Psab_dVds + + ( Psab * Psab_dVds + 2.0 * sti2_dlt * Psbsti_dVds ) * T1 ) ; + Psti_dVgs = Psbsti_dVgs + - 0.5 * ( Psab_dVgs + + ( Psab * Psab_dVgs + 2.0 * sti2_dlt * Psbsti_dVgs ) * T1 ) ; + Psti_dT = Psbsti_dT + - 0.5 * ( Psab_dT + + ( Psab * Psab_dT + 2.0 * sti2_dlt * Psbsti_dT ) * T1 ) ; + + T0 = costi1 * exp (beta * Psti) ; + T0_dT = costi1_dT * exp(beta * Psti) + costi1 * exp(beta * Psti) * ( beta_dT * Psti + beta * Psti_dT ) ; + T1 = beta * (Psti - Vbsz) - 1.0 + T0 ; + T1_dVb = beta * ((Psti_dVbs - Vbsz_dVbs) + T0 * Psti_dVbs) ; + T1_dVd = beta * ((Psti_dVds - Vbsz_dVds) + T0 * Psti_dVds) ; + T1_dVg = beta * (Psti_dVgs + T0 * Psti_dVgs) ; + T1_dT = beta_dT * (Psti - Vbsz) + beta * Psti_dT + T0_dT ; + Fn_SZ ( T1 , T1, 1.0e-2, T0) ; + T1 += epsm10 ; + T1_dVb *= T0 ; + T1_dVd *= T0 ; + T1_dVg *= T0 ; + T1_dT *= T0 ; + sq1sti = sqrt (T1); + T2 = 0.5 / sq1sti ; + sq1sti_dVbs = T2 * T1_dVb ; + sq1sti_dVds = T2 * T1_dVd ; + sq1sti_dVgs = T2 * T1_dVg ; + sq1sti_dT = T2 * T1_dT ; + + T1 = beta * (Psti - Vbsz) - 1.0; + T1_dVb = beta * (Psti_dVbs - Vbsz_dVbs) ; + T1_dVd = beta * (Psti_dVds - Vbsz_dVds) ; + T1_dVg = beta * Psti_dVgs ; + T1_dT = beta_dT * ( Psti - Vbsz ) + beta * Psti_dT ; + Fn_SZ( T1 , T1, 1.0e-2, T0) ; + T1 += epsm10 ; + T1_dVb *= T0 ; + T1_dVd *= T0 ; + T1_dVg *= T0 ; + T1_dT *= T0 ; + sq2sti = sqrt (T1); + T2 = 0.5 / sq2sti ; + sq2sti_dVbs = T2 * T1_dVb ; + sq2sti_dVds = T2 * T1_dVd ; + sq2sti_dVgs = T2 * T1_dVg ; + sq2sti_dT = T2 * T1_dT ; + + Qn0sti = costi0 * (sq1sti - sq2sti) ; + Qn0sti_dVbs = costi0 * (sq1sti_dVbs - sq2sti_dVbs) ; + Qn0sti_dVds = costi0 * (sq1sti_dVds - sq2sti_dVds) ; + Qn0sti_dVgs = costi0 * (sq1sti_dVgs - sq2sti_dVgs) ; + Qn0sti_dT = costi0 * (sq1sti_dT - sq2sti_dT) + here->HSMHV_costi00 * 0.5 / sqrt( here->HSMHV_beta_inv ) * beta_inv_dT * (sq1sti - sq2sti) ; + + /* T1: Vdsatsti */ + T1 = Psasti - Psti ; + T1_dVb = Psasti_dVbs - Psti_dVbs ; + T1_dVd = Psasti_dVds - Psti_dVds ; + T1_dVg = Psasti_dVgs - Psti_dVgs ; + T1_dT = Psasti_dT - Psti_dT ; + + Fn_SZ( T1 , T1 , 1.0e-1 , T2 ) ; + T1_dVb *= T2 ; + T1_dVd *= T2 ; + T1_dVg *= T2 ; + T1_dT *= T2 ; + + TX = Vds / T1 ; + T2 = 1.0 / ( T1 * T1 ) ; + TX_dVbs = T2 * ( - Vds * T1_dVb ) ; + TX_dVds = T2 * ( T1 - Vds * T1_dVd ) ; + TX_dVgs = T2 * ( - Vds * T1_dVg ) ; + TX_dT = T2 * ( - Vds * T1_dT ) ; + + Fn_CP( TY , TX , 1.0 , 4 , T2 ) ; + TY_dVbs = T2 * TX_dVbs ; + TY_dVds = T2 * TX_dVds ; + TY_dVgs = T2 * TX_dVgs ; + TY_dT = T2 * TX_dT ; + + costi7 = 2.0 * here->HSMHV_wsti * here->HSMHV_nf * beta_inv ; + costi7_dT = 2.0 * here->HSMHV_wsti * here->HSMHV_nf * beta_inv_dT ; + T1 = Lch ; + Idssti = costi7 * Mu * Qn0sti * TY / T1 ; + T3 = 1.0 / T1 ; + T4 = Mu * Qn0sti * TY / T1 / T1 ; + T5 = Mu * Qn0sti ; + Idssti_dVbs = costi7 * (((Mu_dVbs * Qn0sti + Mu * Qn0sti_dVbs) * TY + + T5 * TY_dVbs ) * T3 + - Lch_dVbs * T4 ) ; + Idssti_dVds = costi7 * (((Mu_dVds * Qn0sti + Mu * Qn0sti_dVds) * TY + + T5 * TY_dVds ) * T3 + - Lch_dVds * T4 ) ; + Idssti_dVgs = costi7 * (((Mu_dVgs * Qn0sti + Mu * Qn0sti_dVgs) * TY + + T5 * TY_dVgs ) * T3 + - Lch_dVgs * T4 ) ; + Idssti_dT = costi7 * (((Mu_dT * Qn0sti + Mu * Qn0sti_dT) * TY + + T5 * TY_dT ) * T3 + - Lch_dT * T4 ) + costi7_dT * Mu * Qn0sti * TY / T1 ; + + Ids = Ids + Idssti ; + Ids_dVbs = Ids_dVbs + Idssti_dVbs ; + Ids_dVds = Ids_dVds + Idssti_dVds ; + Ids_dVgs = Ids_dVgs + Idssti_dVgs ; + Ids_dT = Ids_dT + Idssti_dT ; + + } + + + + /*----------------------------------------------------------* + * induced gate noise. ( Part 1/3 ) + *----------------------*/ + if ( model->HSMHV_coign != 0 && model->HSMHV_cothrml != 0 ) { + kusai00 = VgVt * VgVt ; + kusaidd = 2.0e0 * beta_inv * Cox_inv * Idd ; + kusaiL = kusai00 - kusaidd ; + Fn_SZ( kusai00 , kusai00 , 1.0e-3 , T0 ) ; + Fn_SZ( kusaiL , kusaiL , 1.0e-3 , T0 ) ; + kusai00L = kusai00 - kusaiL ; + if ( Qn0 < epsm10 || kusai00L < epsm10 ) flg_ign = 0 ; + else flg_ign = 1 ; + } + + /*-----------------------------------------------------------* + * End of PART-1. (label) + *-----------------*/ + end_of_part_1: + + /*----------------------------------------------------------* + * Evaluate integrated charges in unit [C]. + *----------------------*/ + + T1 = - here->HSMHV_weffcv_nf * Leff ; + + Qb = T1 * Qbu ; + Qb_dVbs = T1 * Qbu_dVbs ; + Qb_dVds = T1 * Qbu_dVds ; + Qb_dVgs = T1 * Qbu_dVgs ; + Qb_dT = T1 * Qbu_dT ; + + Qi = T1 * Qiu ; + Qi_dVbs = T1 * Qiu_dVbs ; + Qi_dVds = T1 * Qiu_dVds ; + Qi_dVgs = T1 * Qiu_dVgs ; + Qi_dT = T1 * Qiu_dT ; + + Qd = Qi * Qdrat ; + Qd_dVbs = Qi_dVbs * Qdrat + Qi * Qdrat_dVbs ; + Qd_dVds = Qi_dVds * Qdrat + Qi * Qdrat_dVds ; + Qd_dVgs = Qi_dVgs * Qdrat + Qi * Qdrat_dVgs ; + Qd_dT = Qi_dT * Qdrat + Qi * Qdrat_dT ; + + + /*-----------------------------------------------------------* + * Modified potential for symmetry. + *-----------------*/ + T1 = ( Vds - Pds ) / 2 ; + Fn_SymAdd( Pzadd , T1 , model->HSMHV_pzadd0 , T2 ) ; + T2 /= 2 ; + Pzadd_dVbs = T2 * ( - Pds_dVbs ) ; + Pzadd_dVds = T2 * ( 1.0 - Pds_dVds ) ; + Pzadd_dVgs = T2 * ( - Pds_dVgs ) ; + Pzadd_dT = T2 * ( -Pds_dT ); + + + if ( fabs ( Pzadd ) < epsm10 ) { + Pzadd = 0.0 ; + Pzadd_dVbs = 0.0 ; + Pzadd_dVds = 0.0 ; + Pzadd_dVgs = 0.0 ; + Pzadd_dT = 0.0 ; + } + + Ps0z = Ps0 + Pzadd ; + Ps0z_dVbs = Ps0_dVbs + Pzadd_dVbs ; + Ps0z_dVds = Ps0_dVds + Pzadd_dVds ; + Ps0z_dVgs = Ps0_dVgs + Pzadd_dVgs ; + Ps0z_dT = Ps0_dT + Pzadd_dT ; + + + /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + * PART-2: Substrate / gate / leak currents + *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + + /*-----------------------------------------------------------* + * Isub : substrate current induced by impact ionization. + *-----------------*/ + + if ( flg_noqi == 1 || model->HSMHV_coisub == 0 ) { + /* Accumulation zone or nonconductive case, in which Ids==0. */ + Isub = 0.0e0 ; + Isub_dVbs = Isub_dVds = Isub_dVgs = 0.0e0 ; + Isub_dT = 0.0; + } else { + /*-------------------------------------------* + * Conductive case. + *-----------------*/ + if ( pParam->HSMHV_sub1 > 0.0e0 && pParam->HSMHV_vmax > 0.0e0 ) { + T0 = here->HSMHV_vg2const ; + T1 = T0 * Vgp ; + T1_dVd = T0 * Vgp_dVds ; + T1_dVg = T0 * Vgp_dVgs ; + T1_dVb = T0 * Vgp_dVbs ; + + T7 = Cox0 * Cox0 ; + T8 = here->HSMHV_qnsub_esi ; + T3 = T8 / T7 ; + + T9 = 2.0 / T8 ; + T4 = 1.0e0 + T9 * T7 ; + + T2 = here->HSMHV_xvbs ; + T5 = T1 - beta_inv - T2 * Vbsz ; + T5_dVd = T1_dVd - T2 * Vbsz_dVds; + T5_dVg = T1_dVg ; + T5_dVb = T1_dVb - T2 * Vbsz_dVbs; + T5_dT = - beta_inv_dT ; + + T6 = T4 * T5 ; + T6_dVd = T4 * T5_dVd ; + T6_dVg = T4 * T5_dVg ; + T6_dVb = T4 * T5_dVb ; + T6_dT = T4 * T5_dT ; + Fn_SZ( T6 , T6, 1.0e-3, T9) ; + T6 += small ; + T6_dVd *= T9 ; + T6_dVg *= T9 ; + T6_dVb *= T9 ; + T6_dT *= T9 ; + T6 = sqrt( T6 ) ; + T9 = 0.5 / T6 ; + T6_dVd = T9 * T6_dVd ; + T6_dVg = T9 * T6_dVg ; + T6_dVb = T9 * T6_dVb ; + T6_dT = T9 * T6_dT ; + + Psislsat = T1 + T3 * ( 1.0 - T6 ) ; + Psislsat_dVd = T1_dVd - T3 * T6_dVd ; + Psislsat_dVg = T1_dVg - T3 * T6_dVg ; + Psislsat_dVb = T1_dVb - T3 * T6_dVb ; + Psislsat_dT = -T3 * T6_dT ; + + T2 = here->HSMHV_lgate / (here->HSMHV_xgate + here->HSMHV_lgate) ; + + Psisubsat = pParam->HSMHV_svds * Vdsz + Ps0z - T2 * Psislsat ; + Psisubsat_dVd = pParam->HSMHV_svds * Vdsz_dVds + Ps0z_dVds - T2 * Psislsat_dVd ; + Psisubsat_dVg = Ps0z_dVgs - T2 * Psislsat_dVg ; + Psisubsat_dVb = pParam->HSMHV_svds * Vdsz_dVbs + Ps0z_dVbs - T2 * Psislsat_dVb ; + Psisubsat_dT = Ps0z_dT - T2 * Psislsat_dT ; + Fn_SZ( Psisubsat , Psisubsat, 1.0e-3, T9 ) ; + Psisubsat += small ; + Psisubsat_dVd *= T9 ; + Psisubsat_dVg *= T9 ; + Psisubsat_dVb *= T9 ; + Psisubsat_dT *= T9 ; + + T5 = here->HSMHV_xsub1 ; + T6 = here->HSMHV_xsub2 ; + T2 = exp( - T6 / Psisubsat ) ; + T3 = T2 * T6 / ( Psisubsat * Psisubsat ) ; + T2_dVd = T3 * Psisubsat_dVd ; + T2_dVg = T3 * Psisubsat_dVg ; + T2_dVb = T3 * Psisubsat_dVb ; + T2_dT = T3 * Psisubsat_dT ; + + Isub = T5 * Psisubsat * Ids * T2 ; + Isub_dVds = T5 * ( Psisubsat_dVd * Ids * T2 + + Psisubsat * Ids_dVds * T2 + + Psisubsat * Ids * T2_dVd ) ; + Isub_dVgs = T5 * ( Psisubsat_dVg * Ids * T2 + + Psisubsat * Ids_dVgs * T2 + + Psisubsat * Ids * T2_dVg ) ; + Isub_dVbs = T5 * ( Psisubsat_dVb * Ids * T2 + + Psisubsat * Ids_dVbs * T2 + + Psisubsat * Ids * T2_dVb ) ; + Isub_dT = T5 * ( Psisubsat_dT * Ids * T2 + + Psisubsat * Ids_dT * T2 + + Psisubsat * Ids * T2_dT ) ; + + } else { + Isub = 0.0e0 ; + Isub_dVbs = Isub_dVds = Isub_dVgs = 0.0e0 ; + Isub_dT = 0.0e0 ; + } /* end of if ( pParam->HSMHV_sub1 ... ) else block. */ + + /*---------------------------------------------------* + * Impact-Ionization Current in the Drift Region + *-----------------*/ + T8 = here->HSMHV_subld1 ; + if ( T8 != 0.0 ) { + T0 = ( Vdse + Ps0 - Psdl ) ; + T0_dVb = Ps0_dVbs - Psdl_dVbs ; + T0_dVd = Ps0_dVds - Psdl_dVds ; + T0_dVg = Ps0_dVgs - Psdl_dVgs ; + T0_dT = Ps0_dT - Psdl_dT ; + + Fn_SZ( T0, T0, 1e-6, T1 ) ; + T0_dVb *= T1 ; + T0_dVd *= T1 ; + T0_dVg *= T1 ; + T0_dT *= T1 ; + + T1 = sqrt( VgVt + small ) ; + T3 = 1.0 / ( 2.0 * T1 ) ; + T1_dVb = VgVt_dVbs * T3 ; + T1_dVd = VgVt_dVds * T3 ; + T1_dVg = VgVt_dVgs * T3 ; + T1_dT = VgVt_dT * T3 ; + + T4 = 1.0 / ( T0 * T1 ) ; + T7 = Ldrift * hereMKS->HSMHV_subld2 ; + T2= exp( - T7 * T4 ); + T6 = T7 * T2 * T4 * T4 ; + T2_dVb = ( T0_dVb * T1 + T0 * T1_dVb ) * T6 ; + T2_dVd = ( T0_dVd * T1 + T0 * T1_dVd ) * T6 ; + T2_dVg = ( T0_dVg * T1 + T0 * T1_dVg ) * T6 ; + T2_dT = ( T0_dT * T1 + T0 * T1_dT ) * T6 ; + T2_dVdse = T1 * T6 ; + + T5 = T8 * Ids * T0 * T2 ; + T5_dVb = T8 * ( Ids_dVbs * T0 * T2 + Ids * T0_dVb * T2 + Ids * T0 * T2_dVb ) ; + T5_dVd = T8 * ( Ids_dVds * T0 * T2 + Ids * T0_dVd * T2 + Ids * T0 * T2_dVd ) ; + T5_dVg = T8 * ( Ids_dVgs * T0 * T2 + Ids * T0_dVg * T2 + Ids * T0 * T2_dVg ) ; + T5_dT = T8 * ( Ids_dT * T0 * T2 + Ids * T0_dT * T2 + Ids * T0 * T2_dT ) ; + T5_dVdse = T8 * ( Ids_dRa * Ra_dVdse * T0 * T2 + Ids * T2 + Ids * T0 * T2_dVdse ) ; + + Isub += T5 ; + Isub_dVgs += T5_dVg ; + Isub_dVds += T5_dVd ; + Isub_dVbs += T5_dVb ; + Isub_dT += T5_dT ; + Isub_dVdse += T5_dVdse ; + } + + } + + + /*---------------------------------------------------* + * Impact-Ionization Induced Bulk Potential Change (IBPC) + *-----------------*/ + if ( flg_noqi == 0 && Isub > 0e0 && pParam->HSMHV_ibpc1 != 0e0 ) { + + /* delta Vbs */ + T0 = 1e0 + pParam->HSMHV_ibpc2 * dVth ; + dVbsIBPC = pParam->HSMHV_ibpc1 * T0 * Isub ; + dVbsIBPC_dVbs = pParam->HSMHV_ibpc1 * ( pParam->HSMHV_ibpc2 * dVth_dVb * Isub + T0 * Isub_dVbs ) ; + dVbsIBPC_dVds = pParam->HSMHV_ibpc1 * ( pParam->HSMHV_ibpc2 * dVth_dVd * Isub + T0 * Isub_dVds ) ; + dVbsIBPC_dVgs = pParam->HSMHV_ibpc1 * ( pParam->HSMHV_ibpc2 * dVth_dVg * Isub + T0 * Isub_dVgs ) ; + dVbsIBPC_dT = pParam->HSMHV_ibpc1 * T0 * Isub_dT ; + + /* dG3 & dG4 */ + T10 = 1e0 / Xi0 ; + T10_dT = - T10 / Xi0 * Xi0_dT ; + T1 = beta * dVbsIBPC * T10 ; + T11 = T10 * T10; + T1_dVb = beta * ( dVbsIBPC_dVbs * Xi0 - dVbsIBPC * Xi0_dVbs ) * T11 ; + T1_dVd = beta * ( dVbsIBPC_dVds * Xi0 - dVbsIBPC * Xi0_dVds ) * T11 ; + T1_dVg = beta * ( dVbsIBPC_dVgs * Xi0 - dVbsIBPC * Xi0_dVgs ) * T11 ; + T1_dT = beta_dT * dVbsIBPC * T10 + beta * dVbsIBPC_dT * T10 + beta * dVbsIBPC * T10_dT ; + + + T10 = 1e0 / Xil ; + T10_dT = - T10 / Xil * Xil_dT ; + T2 = beta * dVbsIBPC * T10 ; + T11 = T10 * T10; + T2_dVb = beta * ( dVbsIBPC_dVbs * Xil - dVbsIBPC * Xil_dVbs ) * T11 ; + T2_dVd = beta * ( dVbsIBPC_dVds * Xil - dVbsIBPC * Xil_dVds ) * T11 ; + T2_dVg = beta * ( dVbsIBPC_dVgs * Xil - dVbsIBPC * Xil_dVgs ) * T11 ; + T2_dT = beta_dT * dVbsIBPC * T10 + beta * dVbsIBPC_dT * T10 + beta * dVbsIBPC * T10_dT ; + + + dG3 = cnst0 * ( Xilp32 * T2 - Xi0p32 * T1 ) ; + dG3_dVbs = cnst0 * ( Xilp32_dVbs * T2 + Xilp32 * T2_dVb - Xi0p32_dVbs * T1 - Xi0p32 * T1_dVb ) ; + dG3_dVds = cnst0 * ( Xilp32_dVds * T2 + Xilp32 * T2_dVd - Xi0p32_dVds * T1 - Xi0p32 * T1_dVd ) ; + dG3_dVgs = cnst0 * ( Xilp32_dVgs * T2 + Xilp32 * T2_dVg - Xi0p32_dVgs * T1 - Xi0p32 * T1_dVg ) ; + dG3_dT = cnst0 * ( Xilp32_dT * T2 + Xilp32 * T2_dT - Xi0p32_dT * T1 - Xi0p32 * T1_dT ) + + cnst0_dT * ( Xilp32 * T2 - Xi0p32 * T1 ) ; + + dG4 = cnst0 * 0.5 * ( - Xilp12 * T2 + Xi0p12 * T1 ) ; + dG4_dVbs = cnst0 * 0.5 * ( - Xilp12_dVbs * T2 - Xilp12 * T2_dVb + Xi0p12_dVbs * T1 + Xi0p12 * T1_dVb ) ; + dG4_dVds = cnst0 * 0.5 * ( - Xilp12_dVds * T2 - Xilp12 * T2_dVd + Xi0p12_dVds * T1 + Xi0p12 * T1_dVd ) ; + dG4_dVgs = cnst0 * 0.5 * ( - Xilp12_dVgs * T2 - Xilp12 * T2_dVg + Xi0p12_dVgs * T1 + Xi0p12 * T1_dVg ) ; + dG4_dT = cnst0 * 0.5 * ( - Xilp12_dT * T2 - Xilp12 * T2_dT + Xi0p12_dT * T1 + Xi0p12 * T1_dT ) + + cnst0_dT *0.5 * ( - Xilp12 * T2 + Xi0p12 * T1 ) ; + + /* Add IBPC current into Ids */ + dIdd = dG3 + dG4 ; + dIdd_dVbs = dG3_dVbs + dG4_dVbs ; + dIdd_dVds = dG3_dVds + dG4_dVds ; + dIdd_dVgs = dG3_dVgs + dG4_dVgs ; + dIdd_dT = dG3_dT + dG4_dT ; + + IdsIBPC = betaWL * dIdd * Mu ; + IdsIBPC_dVbs = betaWL * ( Mu * dIdd_dVbs + dIdd * Mu_dVbs ) + betaWL_dVbs * Mu * dIdd ; + IdsIBPC_dVds = betaWL * ( Mu * dIdd_dVds + dIdd * Mu_dVds ) + betaWL_dVds * Mu * dIdd ; + IdsIBPC_dVgs = betaWL * ( Mu * dIdd_dVgs + dIdd * Mu_dVgs ) + betaWL_dVgs * Mu * dIdd ; + IdsIBPC_dT = betaWL * ( Mu * dIdd_dT + dIdd * Mu_dT ) + betaWL_dT * Mu * dIdd ; + + + } /* End if (IBPC) */ + + T3 = 1 / TTEMP ; + T0 =- model->HSMHV_igtemp2 * T3 * T3 + - 2 * model->HSMHV_igtemp3 * T3 * T3 * T3 ; + Egp12_dT = 0.5 * T0 / Egp12; + Egp32_dT = 1.5 * T0 * Egp12; + + /*-----------------------------------------------------------* + * Igate : Gate current induced by tunneling. + *-----------------*/ + if ( model->HSMHV_coiigs != 0 ) { + /* Igate */ + if ( flg_noqi == 0 ) { + Psdlz = Ps0z + Vdsz - epsm10 ; + Psdlz_dVbs = Ps0z_dVbs + Vdsz_dVbs ; + Psdlz_dVds = Ps0z_dVds + Vdsz_dVds ; + Psdlz_dVgs = Ps0z_dVgs ; + Psdlz_dT = Ps0z_dT ; + + T1 = Vgsz - Vfb + modelMKS->HSMHV_gleak4 * (dVth - dPpg) * Leff - Psdlz * pParam->HSMHV_gleak3 ; + T3 = modelMKS->HSMHV_gleak4 * Leff ; + T1_dVg = Vgsz_dVgs + T3 * (dVth_dVg - dPpg_dVg) - Psdlz_dVgs * pParam->HSMHV_gleak3 ; + T1_dVd = Vgsz_dVds + T3 * (dVth_dVd - dPpg_dVd) - Psdlz_dVds * pParam->HSMHV_gleak3 ; + T1_dVb = Vgsz_dVbs + T3 * ( dVth_dVb - dPpg_dVb ) - Psdlz_dVbs * pParam->HSMHV_gleak3 ; + T1_dT = T3 * ( dVth_dT - dPpg_dT ) - Psdlz_dT * pParam->HSMHV_gleak3 ; + + T3 = 2.0 * T1 ; + T1_dVg = T3 * T1_dVg ; + T1_dVd = T3 * T1_dVd ; + T1_dVb = T3 * T1_dVb ; + T1_dT = T3 * T1_dT ; + T1 *= T1 ; + + T3 = 1.0 / Tox0 ; + T2 = T1 * T3 ; + T2_dVg = (T1_dVg ) * T3 ; + T2_dVd = (T1_dVd ) * T3 ; + T2_dVb = (T1_dVb ) * T3 ; + T2_dT = T1_dT * T3 ; + + T3 = 1.0 / modelMKS->HSMHV_gleak5 ; + T7 = 1.0 + Ey * T3 ; + T7_dVg = Ey_dVgs * T3 ; + T7_dVd = Ey_dVds * T3 ; + T7_dVb = Ey_dVbs * T3 ; + T7_dT = Ey_dT * T3 ; + + Etun = T2 * T7 ; + Etun_dVgs = T2_dVg * T7 + T7_dVg * T2 ; + Etun_dVds = T2_dVd * T7 + T7_dVd * T2 ; + Etun_dVbs = T2_dVb * T7 + T7_dVb * T2 ; + Etun_dT = T2_dT * T7 + T7_dT * T2 ; + + Fn_SZ( Etun , Etun , igate_dlt , T5 ) ; + Etun_dVgs *= T5 ; + Etun_dVds *= T5 ; + Etun_dVbs *= T5 ; + Etun_dT *= T5 ; + + Fn_SZ( T3 , Vgsz , 1.0e-3 , T4 ) ; + T3 -= model->HSMHV_vzadd0 ; + T3_dVb = 0.5 * (Vgsz_dVbs + Vgsz * Vgsz_dVbs/TMF2); + TX = T3 / cclmmdf ; + TX_dVbs = T3_dVb / cclmmdf ; + T2 = 1.0 + TX * TX ; + T2_dVb = 2 * TX_dVbs * TX ; + T1 = 1.0 - 1.0 / T2 ; + T1_dVb = T2_dVb / T2 / T2 ; + T1_dVg = 2.0 * TX * T4 / ( T2 * T2 * cclmmdf ) ; + T1_dVd = T1_dVg * Vgsz_dVds ; + Etun_dVgs = T1 * Etun_dVgs + Etun * T1_dVg ; + Etun_dVds = T1 * Etun_dVds + Etun * T1_dVd ; + Etun_dVbs = Etun_dVbs * T1 + Etun * T1_dVb ; + Etun_dT *= T1 ; + Etun *= T1 ; + + T0 = Leff * here->HSMHV_weff_nf ; + T7 = modelMKS->HSMHV_gleak7 / (modelMKS->HSMHV_gleak7 + T0) ; + + T6 = pParam->HSMHV_gleak6 ; + T9 = T6 / (T6 + Vdsz) ; + T9_dVb = - T9 / (T6 + Vdsz) * Vdsz_dVbs ; + T9_dVd = - T9 / (T6 + Vdsz) * Vdsz_dVds ; + + T4 = 1 / (Etun + small ) ; + T1 = - pParam->HSMHV_gleak2 * Egp32 * T4 ; + T3 = pParam->HSMHV_gleak2 * T4 * T4; + T1_dT = T3 * (Egp32 * Etun_dT - Egp32_dT * (Etun + small )) ; + + if ( T1 < - EXP_THR ) { + Igate = 0.0 ; + Igate_dVbs = Igate_dVds = Igate_dVgs = Igate_dT = 0.0 ; + } else { + T2 = exp ( T1 ) ; + T2_dT = T1_dT * T2 ; + + T3 = pParam->HSMHV_gleak1 / Egp12 * C_QE * T0 ; + T3_dT = - Egp12_dT * pParam->HSMHV_gleak1 / Egp12 / Egp12 * C_QE * T0 ; + + T5 = 1 / cnst0 ; + T6 = sqrt ((Qiu + Cox0 * VgVt_small )* T5 ) ; + T6_dT = ( ( ( cnst0 * Qiu_dT - cnst0_dT * ( Qiu + Cox0 * VgVt_small ) ) * T5 * T5 ) ) / T6 * 0.5 ; + T4 = T2 * T3 * T6 ; + T4_dT = T2_dT * T3 * T6 + T2 * T3_dT * T6 + T2 * T3 * T6_dT; + T5 = T4 * Etun ; + T6 = 0.5 * Etun / (Qiu + Cox0 * VgVt_small ) ; + T10 = T5 * Etun ; + T10_dVb = T5 * (2.0 * Etun_dVbs - T1 * Etun_dVbs + T6 * Qiu_dVbs) ; + T10_dVd = T5 * (2.0 * Etun_dVds - T1 * Etun_dVds + T6 * Qiu_dVds) ; + T10_dVg = T5 * (2.0 * Etun_dVgs - T1 * Etun_dVgs + T6 * Qiu_dVgs) ; + T10_dT = 2 * T5 * Etun_dT + T4_dT * Etun * Etun ; + + Igate = T7 * T9 * T10 ; + Igate_dVbs = T7 * (T9 * T10_dVb + T9_dVb * T10) ; + Igate_dVds = T7 * (T9_dVd * T10 + T9 * T10_dVd) ; + Igate_dVgs = T7 * T9 * T10_dVg ; + Igate_dT = T7 * T9 * T10_dT ; + } + } + + /* Igs */ + T0 = - pParam->HSMHV_glksd2 * Vgs + modelMKS->HSMHV_glksd3 ; + T2 = exp (Tox0 * T0); + T2_dVg = (- Tox0 * pParam->HSMHV_glksd2) * T2; + + T0 = Vgs / Tox0 / Tox0 ; + T3 = Vgs * T0 ; + T3_dVg = 2.0 * T0 * (1.0 ) ; + T4 = pParam->HSMHV_glksd1 / 1.0e6 * here->HSMHV_weff_nf ; + Igs = T4 * T2 * T3 ; + Igs_dVgs = T4 * (T2_dVg * T3 + T2 * T3_dVg) ; + Igs_dVds = 0.0 ; + Igs_dVbs = 0.0 ; + Igs_dT = 0.0 ; + + if ( Vgs >= 0.0e0 ){ + Igs *= -1.0 ; + Igs_dVgs *= -1.0 ; + Igs_dVds *= -1.0 ; + Igs_dVbs *= -1.0 ; + } + + + /* Igd */ + T1 = Vgs - Vds ; + T0 = - pParam->HSMHV_glksd2 * T1 + modelMKS->HSMHV_glksd3 ; + T2 = exp (Tox0 * T0); + T2_dVg = (- Tox0 * pParam->HSMHV_glksd2) * T2; + T2_dVd = (+ Tox0 * pParam->HSMHV_glksd2) * T2; + T2_dVb = 0.0 ; + + T0 = T1 / Tox0 / Tox0 ; + T3 = T1 * T0 ; + T3_dVg = 2.0 * T0 ; + T3_dVd = - 2.0 * T0 ; + T3_dVb = 0.0 ; + T4 = pParam->HSMHV_glksd1 / 1.0e6 * here->HSMHV_weff_nf ; + Igd = T4 * T2 * T3 ; + Igd_dVgs = T4 * (T2_dVg * T3 + T2 * T3_dVg) ; + Igd_dVds = T4 * (T2_dVd * T3 + T2 * T3_dVd) ; + Igd_dVbs = 0.0 ; + Igd_dT = 0.0 ; + + if( T1 >= 0.0e0 ){ + Igd *= -1.0 ; + Igd_dVgs *= -1.0 ; + Igd_dVds *= -1.0 ; + Igd_dVbs *= -1.0 ; + } + + + /* Igb */ + Etun = ( - ( Vgs - Vbs ) + Vfb + model->HSMHV_glkb3 ) / Tox0 ; + Etun_dVgs = - 1.0 / Tox0 ; + Etun_dVds = 0.0 ; + Etun_dVbs = 1.0 / Tox0 ; + + Fn_SZ( Etun , Etun, igate_dlt, T5) ; + Etun += small ; + Etun_dVgs *= T5 ; + Etun_dVbs *= T5 ; + + T1 = - pParam->HSMHV_glkb2 / Etun ; + if ( T1 < - EXP_THR ) { + Igb = 0.0 ; + Igb_dVgs = Igb_dVds = Igb_dVbs = Igb_dT = 0.0 ; + } else { + T2 = exp ( T1 ); + T3 = pParam->HSMHV_glkb2 / ( Etun * Etun ) * T2 ; + T2_dVg = T3 * Etun_dVgs ; + T2_dVb = T3 * Etun_dVbs ; + + T3 = pParam->HSMHV_glkb1 * here->HSMHV_weff_nf * Leff ; + Igb = T3 * Etun * Etun * T2 ; + Igb_dVgs = T3 * (2.0 * Etun * Etun_dVgs * T2 + Etun * Etun * T2_dVg); + Igb_dVds = 0.0 ; + Igb_dVbs = T3 * (2.0 * Etun * Etun_dVbs * T2 + Etun * Etun * T2_dVb); + Igb_dT = 0.0; + } + + /* Ifn: Fowler-Nordheim tunneling current */ + Eg12 = here->HSMHV_sqrt_eg ; + Eg32 = here->HSMHV_eg * Eg12 ; + T2 = - ( pParam->HSMHV_fvbs * Vbsz - Vgsz + dVthSC + dVthLP - pParam->HSMHV_fn3 ) / Tox0 ; + T2_dVd = - ( pParam->HSMHV_fvbs * Vbsz_dVds - Vgsz_dVds + dVthSC_dVd + dVthLP_dVd + ) / Tox0 ; + T2_dVg = - ( - Vgsz_dVgs + dVthSC_dVg + dVthLP_dVg + ) / Tox0 ; + T2_dVb = - ( pParam->HSMHV_fvbs * Vbsz_dVbs -Vgsz_dVbs + dVthSC_dVb + dVthLP_dVb + ) / Tox0 ; + T2_dT = - ( dVthSC_dT + dVthLP_dT + ) / Tox0 ; + + T0 = T2 * T2 ; + T1 = pParam->HSMHV_fn2 * Eg32 ; + T1_dT = 1.5 * Eg_dT * pParam->HSMHV_fn2 * Eg12 ; + T3 = - T1 / T2 ; + if ( T3 < - EXP_THR ) { + T5 = 0.0 ; + T5_dVd = T5_dVg = T5_dVb = T5_dT = 0.0 ; + + } else { + T5 = exp( T3 ) ; + T5_dVd = T5 * T1 * T2_dVd / T0 ; + T5_dVg = T5 * T1 * T2_dVg / T0 ; + T5_dVb = T5 * T1 * T2_dVb / T0 ; + T5_dT = T5 * T1 * T2_dT / T0 ; + } + + T4 = C_QE * pParam->HSMHV_fn1 * here->HSMHV_weff_nf * here->HSMHV_lgate / Eg12 ; + T4_dT = (- 0.5) * Eg_dT * T4 / here->HSMHV_eg ; + if ( 2e0 * T2 + T1 < 0e0 ){ + Ifn = 0.25e0 * T4 * T1 * T1 * c_exp_2 ; /* minimum value */ + Ifn_dVd = 0e0 ; + Ifn_dVg = 0e0 ; + Ifn_dVb = 0e0 ; + Ifn_dT = 0.25e0 * T4_dT * T1 * T1 * c_exp_2 ; + } else { + Ifn = T4 * T0 * T5 ; + Ifn_dVd = T4 * ( 2.0 * T2 * T2_dVd * T5 + T0 * T5_dVd ) ; + Ifn_dVg = T4 * ( 2.0 * T2 * T2_dVg * T5 + T0 * T5_dVg ) ; + Ifn_dVb = T4 * ( 2.0 * T2 * T2_dVb * T5 + T0 * T5_dVb ) ; + Ifn_dT = T4 * ( 2.0 * T2 * T2_dT * T5 + T0 * T5_dT ) +T4_dT * T0 * T5; + } + Igb -= Ifn ; + Igb_dVbs -= Ifn_dVb ; + Igb_dVds -= Ifn_dVd ; + Igb_dVgs -= Ifn_dVg ; + Igb_dT -= Ifn_dT ; + } /* if ( model->HSMHV_coiigs == 0 ) */ + + + /*-----------------------------------------------------------* + * Vdsp : Vds modification for GIDL/GISL + *-----------------*/ + if ( model->HSMHV_cogidl != 0 ) { + T1 = Vds * (1.0 - gidla * Vds) - gidlvds_dlt ; + T2 = sqrt (T1 * T1 + 4.0 * gidlvds_dlt * Vds) ; + Vdsp = Vds - 0.5 * (T1 + T2) ; + T3 = 1.0 - 2.0 * gidla * Vds ; + Vdsp_dVd = 1.0 - 0.5 * (T3 + (T1 * T3 + 2.0 * gidlvds_dlt) / T2) ; + } + + /*-----------------------------------------------------------* + * Igidl : GIDL + *-----------------*/ + if( model->HSMHV_cogidl == 0 ){ + Igidl = 0.0e0 ; + Igidl_dVbs = 0.0e0 ; + Igidl_dVds = 0.0e0 ; + Igidl_dVgs = 0.0e0 ; + Igidl_dT = 0.0e0 ; + } else { + T1 = model->HSMHV_gidl3 * (Vdsp + model->HSMHV_gidl4) - Vgs + (dVthSC + dVthLP) * model->HSMHV_gidl5 ; + T1_dT = (dVthSC_dT + dVthLP_dT) * model->HSMHV_gidl5 ; + T2 = 1.0 / Tox0 ; + E1 = T1 * T2 ; + E1_dVb = ((model->HSMHV_gidl5 * (dVthSC_dVb + dVthLP_dVb)) ) * T2 ; + E1_dVd = ((model->HSMHV_gidl3 * Vdsp_dVd) + model->HSMHV_gidl5 * (dVthSC_dVd + dVthLP_dVd)) * T2 ; + E1_dVg = (-1.0 + model->HSMHV_gidl5 * (dVthSC_dVg + dVthLP_dVg) ) * T2 ; + E1_dT = T1_dT * T2 ; + + Fn_SZ( Egidl , E1, eef_dlt, T5) ; + Egidl_dVb = T5 * E1_dVb ; + Egidl_dVd = T5 * E1_dVd ; + Egidl_dVg = T5 * E1_dVg ; + Egidl_dT = T5 * E1_dT ; + + T3 = 1 / (Egidl + small) ; + T0 = - pParam->HSMHV_gidl2 * Egp32 * T3 ; + T0_dT = - pParam->HSMHV_gidl2 * T3 *( Egp32_dT - Egidl_dT * T3 ) ; + if ( T0 < - EXP_THR ) { + Igidl = 0.0 ; + Igidl_dVbs = Igidl_dVds = Igidl_dVgs = Igidl_dT = 0.0 ; + } else { + T1 = exp ( T0 ) ; + T1_dT = T0_dT * T1 ; + T2 = pParam->HSMHV_gidl1 / Egp12 * C_QE * here->HSMHV_weff_nf ; + T2_dT = - Egp12_dT * pParam->HSMHV_gidl1 / Egp12 / Egp12 * C_QE * here->HSMHV_weff_nf ; + Igidl = T2 * Egidl * Egidl * T1 ; + T3 = T2 * T1 * Egidl * (2.0 + pParam->HSMHV_gidl2 * Egp32 * Egidl / (Egidl + small) / (Egidl + small)) ; + Igidl_dVbs = T3 * Egidl_dVb ; + Igidl_dVds = T3 * Egidl_dVd ; + Igidl_dVgs = T3 * Egidl_dVg ; + Igidl_dT = T3 * Egidl_dT + T2 * Egidl * Egidl * T1_dT + T2_dT * Egidl * Egidl * T1; + } + + /* bug-fix */ + Vdb = Vds - Vbs ; + if ( Vdb > 0.0 ) { + T2 = Vdb * Vdb ; + T4 = T2 * Vdb ; + T0 = T4 + C_gidl_delta ; + T5 = T4 / T0 ; + T7 = ( 3.0 * T2 * T0 - T4 * 3.0 * T2 ) / ( T0 * T0 ) ; /* == T5_dVdb */ + Igidl_dVbs = Igidl_dVbs * T5 + Igidl * T7 * ( - 1.0 ) ; /* Vdb_dVbs = -1 */ + Igidl_dVds = Igidl_dVds * T5 + Igidl * T7 * ( + 1.0 ) ; /* Vdb_dVds = +1 */ + Igidl_dVgs = Igidl_dVgs * T5 ; /* Vdb_dVgs = 0 */ + Igidl_dT = Igidl_dT * T5 ; /* Vdb_dT = 0 */ + Igidl *= T5 ; + } else { + Igidl = 0.0 ; + Igidl_dVbs = Igidl_dVds = Igidl_dVgs = Igidl_dT = 0.0 ; + } + } + + + /*-----------------------------------------------------------* + * Igisl : GISL + *-----------------*/ + if( model->HSMHV_cogidl == 0){ + Igisl = 0.0e0 ; + Igisl_dVbs = 0.0e0 ; + Igisl_dVds = 0.0e0 ; + Igisl_dVgs = 0.0e0 ; + Igisl_dT = 0.0e0 ; + } else { + T1 = model->HSMHV_gidl3 * ( - Vdsp + model->HSMHV_gidl4 ) + - ( Vgs - Vdsp ) + ( dVthSC + dVthLP ) * model->HSMHV_gidl5 ; + + T1_dT = ( dVthSC_dT + dVthLP_dT ) * model->HSMHV_gidl5 ; + T2 = 1.0 / Tox0 ; + E1 = T1 * T2 ; + E1_dVb = ((model->HSMHV_gidl5 * (dVthSC_dVb + dVthLP_dVb)) ) * T2 ; + E1_dVd = (((1.0-model->HSMHV_gidl3 ) * Vdsp_dVd) + model->HSMHV_gidl5 * (dVthSC_dVd + dVthLP_dVd)) * T2 ; + E1_dVg = (-1.0 + model->HSMHV_gidl5 * (dVthSC_dVg + dVthLP_dVg) ) * T2 ; + E1_dT = T1_dT * T2 ; + + Fn_SZ( Egisl , E1, eef_dlt, T5) ; + Egisl_dVb = T5 * E1_dVb ; + Egisl_dVd = T5 * E1_dVd ; + Egisl_dVg = T5 * E1_dVg ; + Egisl_dT = T5 * E1_dT ; + + T3 = 1 / (Egisl + small) ; + T0 = - pParam->HSMHV_gidl2 * Egp32 * T3 ; + T0_dT = - pParam->HSMHV_gidl2 * T3 * ( Egp32_dT - Egisl_dT * T3 ) ; + if ( T0 < - EXP_THR ) { + Igisl = 0.0 ; + Igisl_dVbs = Igisl_dVds = Igisl_dVgs = Igisl_dT = 0.0 ; + } else { + T1 = exp ( T0 ) ; + T1_dT = T0_dT * T1 ; + T3 = 1 / Egp12 ; + T2 = pParam->HSMHV_gidl1 * T3 * C_QE * here->HSMHV_weff_nf ; + T2_dT = - pParam->HSMHV_gidl1 * Egp12_dT * T3 * T3 * C_QE * here->HSMHV_weff_nf ; + Igisl = T2 * Egisl * Egisl * T1 ; + T3 = T2 * T1 * Egisl * (2.0 + pParam->HSMHV_gidl2 * Egp32 * Egisl / (Egisl + small) / (Egisl + small)) ; + Igisl_dVbs = T3 * Egisl_dVb ; + Igisl_dVds = T3 * Egisl_dVd ; + Igisl_dVgs = T3 * Egisl_dVg ; + Igisl_dT = T3 * Egisl_dT + T2_dT * Egisl * Egisl * T1 + T2 * Egisl * Egisl * T1_dT ; + } + + /* bug-fix */ + Vsb = - Vbs ; + if ( Vsb > 0.0 ) { + T2 = Vsb * Vsb ; + T4 = T2 * Vsb ; + T0 = T4 + C_gidl_delta ; + T5 = T4 / T0 ; + T7 = ( 3.0 * T2 * T0 - T4 * 3.0 * T2 ) / ( T0 * T0 ) ; /* == T5_dVsb */ + Igisl_dVbs = Igisl_dVbs * T5 + Igisl * T7 * ( - 1.0 ) ; /* Vsb_dVbs = -1 */ + Igisl_dVds = Igisl_dVds * T5 ; /* Vsb_dVds = 0 */ + Igisl_dVgs = Igisl_dVgs * T5 ; /* Vsb_dVgs = 0 */ + Igisl_dT = Igisl_dT * T5 ; /* Vsb_dT = 0 */ + Igisl *= T5 ; + } else { + Igisl = 0.0 ; + Igisl_dVbs = Igisl_dVds = Igisl_dVgs = Igisl_dT = 0.0 ; + } + } + + + /*-----------------------------------------------------------* + * End of PART-2. (label) + *-----------------*/ +/* end_of_part_2: +*/ + + /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + * PART-3: Overlap charge + *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + Aclm = pParam->HSMHV_clm1 ; + if ( flg_noqi != 0 ) { + /*-------------------------------------------* + * Calculation of Psdl for cases of flg_noqi==1. + *-----------------*/ + Psdl = Aclm * (Vds + Ps0) + (1.0e0 - Aclm) * Psl ; + Psdl_dVbs = Aclm * Ps0_dVbs + (1.0e0 - Aclm) * Psl_dVbs ; + Psdl_dVds = Aclm * (1.0e0 + Ps0_dVds) + (1.0e0 - Aclm) * Psl_dVds ; + Psdl_dVgs = Aclm * Ps0_dVgs + (1.0e0 - Aclm) * Psl_dVgs ; + if ( Psdl > Ps0 + Vds - epsm10 ) { + Psdl = Ps0 + Vds - epsm10 ; + Psdl_dVbs = Ps0_dVbs ; + Psdl_dVds = Ps0_dVds + 1.0 ; + Psdl_dVgs = Ps0_dVgs ; + } + + if (model->HSMHV_xqy !=0) { + Ec = 0.0e0 ; + Ec_dVbs =0.0e0 ; + Ec_dVds =0.0e0 ; + Ec_dVgs =0.0e0 ; + Ec_dT =0.0e0 ; + } + } else { + /* Ec is removed from Lred calc. part */ + if (model->HSMHV_xqy !=0) { + if ( Idd < C_IDD_MIN ) { + Ec = 0.0e0 ; + Ec_dVbs =0.0e0 ; + Ec_dVds =0.0e0 ; + Ec_dVgs =0.0e0 ; + } else { + T1 = beta_inv / Leff ; + T1_dT = beta_inv_dT / Leff ; + T2 = 1.0 / Qn0 ; + T3 = T2 * T2 ; + Ec = Idd * T1 * T2 ; + Ec_dVbs = T1 * (Idd_dVbs * T2 - Idd * Qn0_dVbs * T3 ) ; + Ec_dVds = T1 * (Idd_dVds * T2 - Idd * Qn0_dVds * T3 ) ; + Ec_dVgs = T1 * (Idd_dVgs * T2 - Idd * Qn0_dVgs * T3 ) ; + Ec_dT = T1 * (Idd_dT * T2 - Idd * Qn0_dT * T3 ) + + T1_dT * Idd * T2 ; + } + } + } + + /*-----------------------------------------------------------* + * Overlap charges + *-----------------*/ + Coovlps = ModeNML * model->HSMHV_coovlps + ModeRVS * model->HSMHV_coovlp ; + Coovlpd = ModeRVS * model->HSMHV_coovlps + ModeNML * model->HSMHV_coovlp ; + Lovers = ModeNML * here->HSMHV_lovers + ModeRVS * here->HSMHV_loverld ; + Loverd = ModeRVS * here->HSMHV_lovers + ModeNML * here->HSMHV_loverld ; + Novers = ModeNML * pParam->HSMHV_novers + ModeRVS * pParam->HSMHV_nover ; + Noverd = ModeRVS * pParam->HSMHV_novers + ModeNML * pParam->HSMHV_nover ; + CVDSOVER = pParam->HSMHV_cvdsover ; + + /*---------------------------------------------------* + * Source side (mode-dependent) + *-----------------*/ + /*-----------------------------------* + * Constant capacitance model + *-----------------*/ + if ( Coovlps == 0 ) { + flg_overgiven = ( ModeNML * model->HSMHV_cgso_Given + + ModeRVS * model->HSMHV_cgdo_Given ) ; + if ( flg_overgiven ) { + Cgso = ModeNML * pParam->HSMHV_cgso + ModeRVS * pParam->HSMHV_cgdo ; + Cgso *= - here->HSMHV_weffcv_nf ; + } else { + Cgso = - Cox0 * Lovers * here->HSMHV_weffcv_nf ; + } + + Qgso = - Cgso * Vgse ; + Qgso_dVbse = 0.0 ; + Qgso_dVdse = 0.0 ; + Qgso_dVgse = - Cgso ; + + /*-----------------------------------* + * Simplified model + *-----------------*/ + } else { /* Coovlps != 0 begin */ + if ( Lovers > 0.0 && Novers == 0.0 ){ + cov_slp = modelMKS->HSMHV_ovslp ; + cov_mag = model->HSMHV_ovmag ; + T1 = Cox0 * here->HSMHV_weffcv_nf ; + T4 = cov_slp * T1 * ( cov_mag + Vgs ) ; + T4_dVg = cov_slp * T1 ; + T4_dVd = 0.0 ; + T5 = Lovers * T1 ; + T9 = 1.2e0 - Ps0 ; + Qgos = Vgs * T5 - T4 * T9 ; + Qgos_dVbs = T4 * Ps0_dVbs ; + Qgos_dVds = T4 * Ps0_dVds - T9 * T4_dVd ; + Qgos_dVgs = T5 + T4 * Ps0_dVgs - T9 * T4_dVg ; + Qgos_dT = T4 * Ps0_dT; + + /*-----------------------------------* + * Surface potential model + *------------------------*/ + } else if ( Lovers > 0.0 && Novers >= 0.0 ) { + + Vgbgmt = Vgs - Vbs ; + Vgbgmt_dVbs = -1.0 ; + Vgbgmt_dVds = 0.0 ; + Vgbgmt_dVgs = 1.0 ; + Vxbgmt = - Vbs ; + Vxbgmt_dVbs = -1.0 ; + Vxbgmt_dVds = 0.0 ; + Vxbgmt_dVgs = 0.0 ; + + Nover_func = Novers ; + cnst0over_func = ModeNML * here->HSMHV_cnst0overs + ModeRVS * here->HSMHV_cnst0over ; + cnst0over_func_dT = ModeNML * cnst0overs_dT + ModeRVS * cnst0over_dT ; + ps0ldinib_func = ModeNML * here->HSMHV_ps0ldinibs + ModeRVS * here->HSMHV_ps0ldinib ; + ps0ldinib_func_dT = ModeNML * ps0ldinibs_dT + ModeRVS * ps0ldinib_dT ; + +#include "hsmhveval_qover.h" + + T4 = here->HSMHV_weffcv_nf * Lovers * ( 1 - CVDSOVER ) ; + + Qovs = T4 * QsuLD ; + Qovs_dVds = T4 * QsuLD_dVds ; + Qovs_dVgs = T4 * QsuLD_dVgs ; + Qovs_dVbs = T4 * QsuLD_dVbs ; + Qovs_dT = T4 * QsuLD_dT ; + + QisLD = T4 * QiuLD ; + QisLD_dVbs = T4 * QiuLD_dVbs ; + QisLD_dVds = T4 * QiuLD_dVds ; + QisLD_dVgs = T4 * QiuLD_dVgs ; + QisLD_dT = T4 * QiuLD_dT ; + + QbsLD = T4 * QbuLD ; + QbsLD_dVbs = T4 * QbuLD_dVbs ; + QbsLD_dVds = T4 * QbuLD_dVds ; + QbsLD_dVgs = T4 * QbuLD_dVgs ; + QbsLD_dT = T4 * QbuLD_dT ; + + + + if ( CVDSOVER != 0.0 ) { /* Qovsext begin */ + Vgbgmt = Vgse - Vbs ; + Vgbgmt_dVbs = -1.0 ; + Vgbgmt_dVds = 0.0 ; + Vgbgmt_dVgs = 1.0 ; + Vxbgmt = - Vbs ; + Vxbgmt_dVbs = -1.0 ; + Vxbgmt_dVds = 0.0 ; + Vxbgmt_dVgs = 0.0 ; + +#include "hsmhveval_qover.h" + + T4 = here->HSMHV_weffcv_nf * Lovers * CVDSOVER ; + Qovsext = T4 * QsuLD ; + Qovsext_dVdse = T4 * QsuLD_dVds ; + Qovsext_dVgse = T4 * QsuLD_dVgs ; + Qovsext_dVbse = T4 * QsuLD_dVbs ; + Qovsext_dT = T4 * QsuLD_dT ; + + } /* Qovsext end */ + + } + + /*-----------------------------------* + * Additional constant capacitance model + *-----------------*/ + flg_overgiven = ( ModeNML * model->HSMHV_cgso_Given + + ModeRVS * model->HSMHV_cgdo_Given ) ; + if ( flg_overgiven ) { + Cgso = ModeNML * pParam->HSMHV_cgso + ModeRVS * pParam->HSMHV_cgdo ; + Cgso *= - here->HSMHV_weffcv_nf ; + } + Qgso = - Cgso * Vgse ; + Qgso_dVbse = 0.0 ; + Qgso_dVdse = 0.0 ; + Qgso_dVgse = - Cgso ; + } /* Coovlps != 0 end */ + + /*---------------------------------------------------* + * Drain side (mode-dependent) + *-----------------*/ + /*-----------------------------------* + * Constant capacitance model + *-----------------*/ + if ( Coovlpd == 0 ) { + flg_overgiven = ( ModeRVS * model->HSMHV_cgso_Given + + ModeNML * model->HSMHV_cgdo_Given ) ; + if ( flg_overgiven ) { + Cgdo = ModeRVS * pParam->HSMHV_cgso + ModeNML * pParam->HSMHV_cgdo ; + Cgdo *= - here->HSMHV_weffcv_nf ; + } else { + Cgdo = - Cox0 * Loverd * here->HSMHV_weffcv_nf ; + } + + Qgdo = - Cgdo * (Vgse - Vdse) ; + Qgdo_dVbse = 0.0 ; + Qgdo_dVdse = Cgdo ; + Qgdo_dVgse = - Cgdo ; + + /*-----------------------------------* + * Simplified model + *-----------------*/ + } else { /* Coovlpd != 0 begin */ + if ( Loverd > 0.0 && Noverd == 0.0 ){ + cov_slp = modelMKS->HSMHV_ovslp ; + cov_mag = model->HSMHV_ovmag ; + T1 = Cox0 * here->HSMHV_weffcv_nf ; + T4 = cov_slp * T1 * ( cov_mag + Vgs - Vds ) ; + T4_dVg = cov_slp * T1 ; + T4_dVd = - cov_slp * T1 ; + T5 = Loverd * T1 ; + T9 = 1.2e0 + Vds - Psl ; + Qgod = ( Vgs - Vds ) * T5 - T4 * T9 ; + Qgod_dVbs = + T4 * Psl_dVbs ; + Qgod_dVds = - T5 + T4 * ( -1.0 + Psl_dVds ) - T9 * T4_dVd ; + Qgod_dVgs = + T5 + T4 * Psl_dVgs - T9 * T4_dVg ; + Qgod_dT = T4 * Psl_dT; + + + /*-----------------------------------* + * Surface potential model + *------------------------*/ + } else if ( Loverd > 0.0 && Noverd >= 0.0 ) { + + Vgbgmt = Vgs - Vbs ; + Vgbgmt_dVbs = -1.0 ; + Vgbgmt_dVds = 0.0 ; + Vgbgmt_dVgs = 1.0 ; + Vxbgmt = Vds - Vbs ; + Vxbgmt_dVbs = -1.0 ; + Vxbgmt_dVds = 1.0 ; + Vxbgmt_dVgs = 0.0 ; + + Nover_func = Noverd ; + cnst0over_func = ModeNML * here->HSMHV_cnst0over + ModeRVS * here->HSMHV_cnst0overs ; + cnst0over_func_dT = ModeNML * cnst0over_dT + ModeRVS * cnst0overs_dT ; + ps0ldinib_func = ModeNML * here->HSMHV_ps0ldinib + ModeRVS * here->HSMHV_ps0ldinibs ; + ps0ldinib_func_dT = ModeNML * ps0ldinib_dT + ModeRVS * ps0ldinibs_dT ; + +#include "hsmhveval_qover.h" + + T4 = here->HSMHV_weffcv_nf * Loverd * ( 1 - CVDSOVER ) ; + Qovd = T4 * QsuLD ; + Qovd_dVds = T4 * QsuLD_dVds ; + Qovd_dVgs = T4 * QsuLD_dVgs ; + Qovd_dVbs = T4 * QsuLD_dVbs ; + Qovd_dT = T4 * QsuLD_dT ; + + QidLD = T4 * QiuLD ; + QidLD_dVbs = T4 * QiuLD_dVbs ; + QidLD_dVds = T4 * QiuLD_dVds ; + QidLD_dVgs = T4 * QiuLD_dVgs ; + QidLD_dT = T4 * QiuLD_dT ; + + QbdLD = T4 * QbuLD ; + QbdLD_dVbs = T4 * QbuLD_dVbs ; + QbdLD_dVds = T4 * QbuLD_dVds ; + QbdLD_dVgs = T4 * QbuLD_dVgs ; + QbdLD_dT = T4 * QbuLD_dT ; + + + if ( CVDSOVER != 0.0 ) { /* Qovdext begin */ + Vgbgmt = Vgse - Vbs ; + Vgbgmt_dVbs = -1.0 ; + Vgbgmt_dVds = 0.0 ; + Vgbgmt_dVgs = 1.0 ; + Vxbgmt = Vdse - Vbs ; + Vxbgmt_dVbs = -1.0 ; + Vxbgmt_dVds = 1.0 ; + Vxbgmt_dVgs = 0.0 ; + +#include "hsmhveval_qover.h" + + T4 = here->HSMHV_weffcv_nf * Loverd * CVDSOVER ; + Qovdext = T4 * QsuLD ; + Qovdext_dVdse = T4 * QsuLD_dVds ; + Qovdext_dVgse = T4 * QsuLD_dVgs ; + Qovdext_dVbse = T4 * QsuLD_dVbs ; + Qovdext_dT = T4 * QsuLD_dT ; + + } /* Qovdext end */ + + } + /*-----------------------------------* + * Additional constant capacitance model + *-----------------*/ + flg_overgiven = ( ModeRVS * model->HSMHV_cgso_Given + + ModeNML * model->HSMHV_cgdo_Given ) ; + if ( flg_overgiven ) { + Cgdo = ModeRVS * pParam->HSMHV_cgso + ModeNML * pParam->HSMHV_cgdo ; + Cgdo *= - here->HSMHV_weffcv_nf ; + } + Qgdo = - Cgdo * (Vgse - Vdse) ; + Qgdo_dVbse = 0.0 ; + Qgdo_dVdse = Cgdo ; + Qgdo_dVgse = - Cgdo ; + } /* Coovlpd != 0 end */ + + /*-------------------------------------------* + * Gate/Bulk overlap charge: Qgbo + *-----------------*/ + Cgbo_loc = - pParam->HSMHV_cgbo * here->HSMHV_lgate ; + Qgbo = - Cgbo_loc * (Vgs -Vbs) ; + Qgbo_dVgs = - Cgbo_loc ; + Qgbo_dVbs = Cgbo_loc ; + Qgbo_dVds = 0.0 ; + + /*---------------------------------------------------* + * Lateral-field-induced capacitance. + *-----------------*/ + if ( model->HSMHV_xqy == 0 ){ + Qy = 0.0e0 ; + Qy_dVds = 0.0e0 ; + Qy_dVgs = 0.0e0 ; + Qy_dVbs = 0.0e0 ; + Qy_dT = 0.0e0 ; + } else { + Pslk = Ec * Leff + Ps0 ; + Pslk_dVbs = Ec_dVbs * Leff + Ps0_dVbs; + Pslk_dVds = Ec_dVds * Leff + Ps0_dVds; + Pslk_dVgs = Ec_dVgs * Leff + Ps0_dVgs; + Pslk_dT = Ec_dT * Leff + Ps0_dT; + + T1 = Aclm * ( Vds + Ps0 ) + ( 1.0e0 - Aclm ) * Pslk ; + T1_dVb = Aclm * ( Ps0_dVbs ) + ( 1.0e0 - Aclm ) * Pslk_dVbs ; + T1_dVd = Aclm * ( 1.0 + Ps0_dVds ) + ( 1.0e0 - Aclm ) * Pslk_dVds ; + T1_dVg = Aclm * ( Ps0_dVgs ) + ( 1.0e0 - Aclm ) * Pslk_dVgs ; + T1_dT = Aclm * ( Ps0_dT ) + ( 1.0e0 - Aclm ) * Pslk_dT ; + T10 = here->HSMHV_wdpl ; + T3 = T10 * 1.3 ; + T2 = C_ESI * here->HSMHV_weffcv_nf * T3 ; + Qy = - ( ( Ps0 + Vds - T1 ) / model->HSMHV_xqy ) * T2 ; + Qy_dVds = - ( ( Ps0_dVds + 1.0e0 - T1_dVd ) / model->HSMHV_xqy ) * T2 ; + Qy_dVgs = - ( ( Ps0_dVgs - T1_dVg ) / model->HSMHV_xqy ) * T2 ; + Qy_dVbs = - ( ( Ps0_dVbs - T1_dVb ) / model->HSMHV_xqy ) * T2 ; + Qy_dT = - ( ( Ps0_dT - T1_dT ) / model->HSMHV_xqy ) * T2 ; + } + + if ( model->HSMHV_xqy1 != 0.0 ){ + Qy += here->HSMHV_cqyb0 * Vbs ; + Qy_dVbs += here->HSMHV_cqyb0 ; + } + + /*---------------------------------------------------* + * Fringing capacitance. + *-----------------*/ + Cfd = here->HSMHV_cfrng ; + Cfs = here->HSMHV_cfrng ; + Qfd = Cfd * ( Vgse - Vdse ) ; + Qfs = Cfs * Vgse ; + + /*-----------------------------------------------------------* + * End of PART-3. (label) + *-----------------*/ + +/* end_of_part_3: +*/ + /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + * PART-4: Substrate-source/drain junction diode. + *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + + + /*-----------------------------------------------------------* + * Cbsj, Cbdj: node-base S/D biases. + *-----------------*/ + + T10 = model->HSMHV_cvb * here->HSMHV_jd_nvtm_inv ; + T11 = model->HSMHV_cvbk * here->HSMHV_jd_nvtm_inv ; + + T9 = model->HSMHV_cisb * here->HSMHV_exptemp ; + T0 = here->HSMHV_isbd2 * T9 ; + + T2 = exp (- vbd_jct * T10 ); + T2_dVb = - T2 * T10 ; + + T3 = exp (- vbd_jct * T11 ); + T3_dVb = - T3 * T11 ; + + /* self heating */ + T10_dT = model->HSMHV_cvb * beta_dT / pParam->HSMHV_nj ; + T11_dT = model->HSMHV_cvbk * beta_dT / pParam->HSMHV_nj ; + T9_dT = model->HSMHV_cisb * exptemp_dT ; + T0_dT = here->HSMHV_isbd2 * T9_dT + isbd2_dT * T9 ; + T2_dT = -vbd_jct * T10 * T2 * beta_dT * beta_inv ; + T3_dT = -vbd_jct * T11 * T3 * beta_dT * beta_inv ; + + + /* ibd */ + if ( vbd_jct < here->HSMHV_vbdt ) { + TX = vbd_jct * here->HSMHV_jd_nvtm_inv ; + + + if ( TX < - EXP_THR ) { + T1 = 0.0 ; + T1_dVb = 0.0 ; + T1_dT = 0.0 ; + } else { + T1 = exp ( TX ) ; + T1_dVb = T1 * here->HSMHV_jd_nvtm_inv ; + T1_dT = T1 * TX * beta_dT * beta_inv ; + + } + + Ibd = here->HSMHV_isbd * (T1 - 1.0) + + T0 * (T2 - 1.0) + + pParam->HSMHV_cisbk * (T3 - 1.0); + Gbd = here->HSMHV_isbd * T1_dVb + + T0 * T2_dVb + + pParam->HSMHV_cisbk * T3_dVb ; + Ibd_dT = here->HSMHV_isbd * T1_dT + isbd_dT * ( T1 - 1.0 ) + + T0 * T2_dT + T0_dT * ( T2 - 1.0 ) + + pParam->HSMHV_cisbk * T3_dT ; + + } else { + T1 = here->HSMHV_jd_expcd ; + + T4 = here->HSMHV_isbd * here->HSMHV_jd_nvtm_inv * T1 ; + + Ibd = here->HSMHV_isbd * (T1 - 1.0) + + T4 * (vbd_jct - here->HSMHV_vbdt) + + T0 * (T2 - 1.0) + + pParam->HSMHV_cisbk * (T3 - 1.0) ; + Gbd = T4 + + T0 * T2_dVb + + pParam->HSMHV_cisbk * T3_dVb ; + + T1_dT = jd_expcd_dT ; + T4_dT = isbd_dT * here->HSMHV_jd_nvtm_inv * T1 + + here->HSMHV_isbd * jd_nvtm_inv_dT * T1 + + here->HSMHV_isbd * here->HSMHV_jd_nvtm_inv * T1_dT ; + Ibd_dT = isbd_dT * ( T1 - 1.0 ) + here->HSMHV_isbd * T1_dT + + T4_dT * ( vbd_jct - here->HSMHV_vbdt ) - T4 * vbdt_dT + + T0_dT * ( T2 - 1.0 ) + T0 * T2_dT + + pParam->HSMHV_cisbk * T3_dT ; + } + T12 = model->HSMHV_divx * here->HSMHV_isbd2 ; + Ibd += T12 * vbd_jct ; + Gbd += T12 ; + + T12_dT = model->HSMHV_divx * isbd2_dT ; + Ibd_dT += T12_dT * vbd_jct ; + + /* ibs */ + T0 = here->HSMHV_isbs2 * T9 ; + T0_dT = here->HSMHV_isbs2 * T9_dT + isbs2_dT * T9 ; + + TX = - vbs_jct * T10 ; + if ( TX < - EXP_THR ) { + T2 = 0.0 ; + T2_dVb = 0.0 ; + T2_dT = 0.0 ; + } else { + T2 = exp ( TX ); + T2_dVb = - T2 * T10 ; + T2_dT = T2 * TX * beta_dT * beta_inv ; + } + + TX = - vbs_jct * T11 ; + if ( TX < - EXP_THR ) { + T3 = 0.0 ; + T3_dVb = 0.0 ; + T3_dT = 0.0 ; + } else { + T3 = exp ( TX ); + T3_dVb = - T3 * T11 ; + T3_dT = T3 * TX * beta_dT * beta_inv ; + } + + if ( vbs_jct < here->HSMHV_vbst ) { + TX = vbs_jct * here->HSMHV_jd_nvtm_inv ; + if ( TX < - EXP_THR ) { + T1 = 0.0 ; + T1_dVb = 0.0 ; + T1_dT = 0.0 ; + } else { + T1 = exp ( TX ) ; + T1_dVb = T1 * here->HSMHV_jd_nvtm_inv ; + T1_dT = T1 * TX * beta_dT * beta_inv ; + } + Ibs = here->HSMHV_isbs * (T1 - 1.0) + + T0 * (T2 - 1.0) + + pParam->HSMHV_cisbk * (T3 - 1.0); + Gbs = here->HSMHV_isbs * T1_dVb + + T0 * T2_dVb + + pParam->HSMHV_cisbk * T3_dVb ; + Ibs_dT = here->HSMHV_isbs * T1_dT + isbs_dT * ( T1 - 1.0 ) + + T0 * T2_dT + T0_dT * ( T2 - 1.0 ) + + pParam->HSMHV_cisbk * T3_dT ; + } else { + T1 = here->HSMHV_jd_expcs ; + + T4 = here->HSMHV_isbs * here->HSMHV_jd_nvtm_inv * T1 ; + + Ibs = here->HSMHV_isbs * (T1 - 1.0) + + T4 * (vbs_jct - here->HSMHV_vbst) + + T0 * (T2 - 1.0) + + pParam->HSMHV_cisbk * (T3 - 1.0) ; + Gbs = T4 + + T0 * T2_dVb + + pParam->HSMHV_cisbk * T3_dVb ; + + T1_dT = jd_expcs_dT ; + T4_dT = isbs_dT * here->HSMHV_jd_nvtm_inv * T1 + + here->HSMHV_isbs * jd_nvtm_inv_dT * T1 + + here->HSMHV_isbs * here->HSMHV_jd_nvtm_inv * T1_dT ; + Ibs_dT = isbs_dT * ( T1 - 1.0 ) + here->HSMHV_isbs * T1_dT + + T4_dT * ( vbs_jct - here->HSMHV_vbst) - T4 * vbst_dT + + T0_dT * ( T2 - 1.0 ) + T0 * T2_dT + + pParam->HSMHV_cisbk * T3_dT ; + } + T12 = model->HSMHV_divx * here->HSMHV_isbs2 ; + Ibs += T12 * vbs_jct ; + Gbs += T12 ; + + T12_dT = model->HSMHV_divx * isbs2_dT ; + Ibs_dT += T12_dT * vbs_jct ; + + + /*-----------------------------------------------------------* + * Charges and Capacitances. + *-----------------*/ + /* charge storage elements + * bulk-drain and bulk-source depletion capacitances + * czbd : zero bias drain junction capacitance + * czbs : zero bias source junction capacitance + * czbdsw:zero bias drain junction sidewall capacitance + * czbssw:zero bias source junction sidewall capacitance + */ + tcjbd = model->HSMHV_tcjbd ; + tcjbs = model->HSMHV_tcjbs ; + tcjbdsw = model->HSMHV_tcjbdsw ; + tcjbssw = model->HSMHV_tcjbssw ; + tcjbdswg = model->HSMHV_tcjbdswg ; + tcjbsswg = model->HSMHV_tcjbsswg ; + + czbs = model->HSMHV_cj * here->HSMHV_as ; + czbs = czbs * ( 1.0 + tcjbs * ( TTEMP - model->HSMHV_ktnom )) ; + czbs_dT = ( model->HSMHV_cj * here->HSMHV_as ) * tcjbs ; + + czbd = model->HSMHV_cj * here->HSMHV_ad ; + czbd = czbd * ( 1.0 + tcjbd * ( TTEMP - model->HSMHV_ktnom )) ; + czbd_dT = ( model->HSMHV_cj * here->HSMHV_ad ) * tcjbd ; + + /* Source Bulk Junction */ + if (here->HSMHV_ps > here->HSMHV_weff_nf) { + czbssw = model->HSMHV_cjsw * ( here->HSMHV_ps - here->HSMHV_weff_nf ) ; + czbssw = czbssw * ( 1.0 + tcjbssw * ( TTEMP - model->HSMHV_ktnom )) ; + czbssw_dT = ( model->HSMHV_cjsw * ( here->HSMHV_ps - here->HSMHV_weff_nf )) * tcjbssw ; + + czbsswg = model->HSMHV_cjswg * here->HSMHV_weff_nf ; + czbsswg = czbsswg * ( 1.0 + tcjbsswg * ( TTEMP - model->HSMHV_ktnom )) ; + czbsswg_dT = ( model->HSMHV_cjswg * here->HSMHV_weff_nf ) * tcjbsswg ; + + if (vbs_jct == 0.0) { + Qbs = 0.0 ; + Qbs_dT = 0.0 ; + Capbs = czbs + czbssw + czbsswg ; + } else if (vbs_jct < 0.0) { + if (czbs > 0.0) { + arg = 1.0 - vbs_jct / model->HSMHV_pb ; + if (model->HSMHV_mj == 0.5) + sarg = 1.0 / sqrt(arg) ; + else + sarg = Fn_Pow( arg , -model->HSMHV_mj ) ; + Qbs = model->HSMHV_pb * czbs * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mj) ; + Qbs_dT = model->HSMHV_pb * czbs_dT * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mj) ; + Capbs = czbs * sarg ; + } else { + Qbs = 0.0 ; + Qbs_dT = 0.0 ; + Capbs = 0.0 ; + } + if (czbssw > 0.0) { + arg = 1.0 - vbs_jct / model->HSMHV_pbsw ; + if (model->HSMHV_mjsw == 0.5) + sarg = 1.0 / sqrt(arg) ; + else + sarg = Fn_Pow( arg , -model->HSMHV_mjsw ) ; + Qbs += model->HSMHV_pbsw * czbssw * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjsw) ; + Qbs_dT += model->HSMHV_pbsw * czbssw_dT * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjsw) ; + Capbs += czbssw * sarg ; + } + if (czbsswg > 0.0) { + arg = 1.0 - vbs_jct / model->HSMHV_pbswg ; + if (model->HSMHV_mjswg == 0.5) + sarg = 1.0 / sqrt(arg) ; + else + sarg = Fn_Pow( arg , -model->HSMHV_mjswg ) ; + Qbs += model->HSMHV_pbswg * czbsswg * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjswg) ; + Qbs_dT += model->HSMHV_pbswg * czbsswg_dT * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjswg) ; + Capbs += czbsswg * sarg ; + } + } else { + T1 = czbs + czbssw + czbsswg ; + T1_dT = czbs_dT + czbssw_dT + czbsswg_dT ; + T2 = czbs * model->HSMHV_mj / model->HSMHV_pb + + czbssw * model->HSMHV_mjsw / model->HSMHV_pbsw + + czbsswg * model->HSMHV_mjswg / model->HSMHV_pbswg ; + T2_dT = czbs_dT * model->HSMHV_mj / model->HSMHV_pb + + czbssw_dT * model->HSMHV_mjsw / model->HSMHV_pbsw + + czbsswg_dT * model->HSMHV_mjswg / model->HSMHV_pbswg ; + Qbs = vbs_jct * (T1 + vbs_jct * 0.5 * T2) ; + Qbs_dT = vbs_jct * (T1_dT + vbs_jct * 0.5 * T2_dT) ; + Capbs = T1 + vbs_jct * T2 ; + } + } else { + czbsswg = model->HSMHV_cjswg * here->HSMHV_ps ; + czbsswg = czbsswg * ( 1.0 + tcjbsswg * ( TTEMP - model->HSMHV_ktnom )) ; + czbsswg_dT = ( model->HSMHV_cjswg * here->HSMHV_ps ) * tcjbsswg ; + if (vbs_jct == 0.0) { + Qbs = 0.0 ; + Qbs_dT = 0.0 ; + Capbs = czbs + czbsswg ; + } else if (vbs_jct < 0.0) { + if (czbs > 0.0) { + arg = 1.0 - vbs_jct / model->HSMHV_pb ; + if (model->HSMHV_mj == 0.5) + sarg = 1.0 / sqrt(arg) ; + else + sarg = Fn_Pow( arg , -model->HSMHV_mj ) ; + Qbs = model->HSMHV_pb * czbs * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mj) ; + Qbs_dT = model->HSMHV_pb * czbs_dT * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mj) ; + Capbs = czbs * sarg ; + } else { + Qbs = 0.0 ; + Qbs_dT = 0.0 ; + Capbs = 0.0 ; + } + if (czbsswg > 0.0) { + arg = 1.0 - vbs_jct / model->HSMHV_pbswg ; + if (model->HSMHV_mjswg == 0.5) + sarg = 1.0 / sqrt(arg) ; + else + sarg = Fn_Pow( arg , -model->HSMHV_mjswg ) ; + Qbs += model->HSMHV_pbswg * czbsswg * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjswg) ; + Qbs_dT += model->HSMHV_pbswg * czbsswg_dT * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjswg) ; + Capbs += czbsswg * sarg ; + } + } else { + T1 = czbs + czbsswg ; + T1_dT = czbs_dT + czbsswg_dT ; + T2 = czbs * model->HSMHV_mj / model->HSMHV_pb + + czbsswg * model->HSMHV_mjswg / model->HSMHV_pbswg ; + T2_dT = czbs_dT * model->HSMHV_mj / model->HSMHV_pb + + czbsswg_dT * model->HSMHV_mjswg / model->HSMHV_pbswg ; + Qbs = vbs_jct * (T1 + vbs_jct * 0.5 * T2) ; + Qbs_dT = vbs_jct * (T1_dT + vbs_jct * 0.5 * T2_dT) ; + Capbs = T1 + vbs_jct * T2 ; + } + } + + /* Drain Bulk Junction */ + if (here->HSMHV_pd > here->HSMHV_weff_nf) { + + czbdsw = model->HSMHV_cjsw * ( here->HSMHV_pd - here->HSMHV_weff_nf ) ; + czbdsw = czbdsw * ( 1.0 + tcjbdsw * ( TTEMP - model->HSMHV_ktnom )) ; + czbdsw_dT = ( model->HSMHV_cjsw * ( here->HSMHV_pd - here->HSMHV_weff_nf )) * tcjbdsw ; + + czbdswg = model->HSMHV_cjswg * here->HSMHV_weff_nf ; + czbdswg = czbdswg * ( 1.0 + tcjbdswg * ( TTEMP - model->HSMHV_ktnom )) ; + czbdswg_dT = ( model->HSMHV_cjswg * here->HSMHV_weff_nf ) * tcjbdswg ; + if (vbd_jct == 0.0) { + Qbd = 0.0 ; + Qbd_dT = 0.0 ; + Capbd = czbd + czbdsw + czbdswg ; + } else if (vbd_jct < 0.0) { + if (czbd > 0.0) { + arg = 1.0 - vbd_jct / model->HSMHV_pb ; + if (model->HSMHV_mj == 0.5) + sarg = 1.0 / sqrt(arg) ; + else + sarg = Fn_Pow( arg , -model->HSMHV_mj ) ; + Qbd = model->HSMHV_pb * czbd * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mj) ; + Qbd_dT = model->HSMHV_pb * czbd_dT * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mj) ; + Capbd = czbd * sarg ; + } else { + Qbd = 0.0 ; + Qbd_dT = 0.0 ; + Capbd = 0.0 ; + } + if (czbdsw > 0.0) { + arg = 1.0 - vbd_jct / model->HSMHV_pbsw ; + if (model->HSMHV_mjsw == 0.5) + sarg = 1.0 / sqrt(arg) ; + else + sarg = Fn_Pow( arg , -model->HSMHV_mjsw ) ; + Qbd += model->HSMHV_pbsw * czbdsw * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjsw) ; + Qbd_dT += model->HSMHV_pbsw * czbdsw_dT * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjsw) ; + Capbd += czbdsw * sarg ; + } + if (czbdswg > 0.0) { + arg = 1.0 - vbd_jct / model->HSMHV_pbswg ; + if (model->HSMHV_mjswg == 0.5) + sarg = 1.0 / sqrt(arg) ; + else + sarg = Fn_Pow( arg , -model->HSMHV_mjswg ) ; + Qbd += model->HSMHV_pbswg * czbdswg * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjswg) ; + Qbd_dT += model->HSMHV_pbswg * czbdswg_dT * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjswg) ; + Capbd += czbdswg * sarg ; + + } + } else { + T1 = czbd + czbdsw + czbdswg ; + T1_dT = czbd_dT + czbdsw_dT + czbdswg_dT ; + T2 = czbd * model->HSMHV_mj / model->HSMHV_pb + + czbdsw * model->HSMHV_mjsw / model->HSMHV_pbsw + + czbdswg * model->HSMHV_mjswg / model->HSMHV_pbswg ; + T2_dT = czbd_dT * model->HSMHV_mj / model->HSMHV_pb + + czbdsw_dT * model->HSMHV_mjsw / model->HSMHV_pbsw + + czbdswg_dT * model->HSMHV_mjswg / model->HSMHV_pbswg ; + Qbd = vbd_jct * (T1 + vbd_jct * 0.5 * T2) ; + Qbd_dT = vbd_jct * (T1_dT + vbd_jct * 0.5 * T2_dT) ; + Capbd = T1 + vbd_jct * T2 ; + } + + } else { + czbdswg = model->HSMHV_cjswg * here->HSMHV_pd ; + czbdswg = czbdswg * ( 1.0 + tcjbdswg * ( TTEMP - model->HSMHV_ktnom )) ; + czbdswg_dT = ( model->HSMHV_cjswg * here->HSMHV_pd ) * tcjbdswg ; + + if (vbd_jct == 0.0) { + Qbd = 0.0 ; + Qbd_dT = 0.0 ; + Capbd = czbd + czbdswg ; + } else if (vbd_jct < 0.0) { + if (czbd > 0.0) { + arg = 1.0 - vbd_jct / model->HSMHV_pb ; + if (model->HSMHV_mj == 0.5) + sarg = 1.0 / sqrt(arg) ; + else + sarg = Fn_Pow( arg , -model->HSMHV_mj ) ; + Qbd = model->HSMHV_pb * czbd * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mj) ; + Qbd_dT = model->HSMHV_pb * czbd_dT * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mj) ; + Capbd = czbd * sarg ; + } else { + Qbd = 0.0 ; + Qbd_dT = 0.0 ; + Capbd = 0.0 ; + } + if (czbdswg > 0.0) { + arg = 1.0 - vbd_jct / model->HSMHV_pbswg ; + if (model->HSMHV_mjswg == 0.5) + sarg = 1.0 / sqrt(arg) ; + else + sarg = Fn_Pow( arg , -model->HSMHV_mjswg ) ; + Qbd += model->HSMHV_pbswg * czbdswg * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjswg) ; + Qbd_dT += model->HSMHV_pbswg * czbdswg_dT * (1.0 - arg * sarg) / (1.0 - model->HSMHV_mjswg) ; + Capbd += czbdswg * sarg ; + } + } else { + T1 = czbd + czbdswg ; + T1_dT = czbd_dT + czbdswg_dT ; + T2 = czbd * model->HSMHV_mj / model->HSMHV_pb + + czbdswg * model->HSMHV_mjswg / model->HSMHV_pbswg ; + T2_dT = czbd_dT * model->HSMHV_mj / model->HSMHV_pb + + czbdswg_dT * model->HSMHV_mjswg / model->HSMHV_pbswg ; + Qbd = vbd_jct * (T1 + vbd_jct * 0.5 * T2) ; + Qbd_dT = vbd_jct * (T1_dT + vbd_jct * 0.5 * T2_dT) ; + Capbd = T1 + vbd_jct * T2 ; + } + } + + /*-----------------------------------------------------------* + * End of PART-4. (label) + *-----------------*/ + +/* end_of_part_4: +*/ + + + /*-----------------------------------------------------------* + * PART-5: NQS. (label) + *-----------------*/ + if (flg_nqs) { + if(ckt->CKTmode & MODETRAN){ + if( ckt->CKTmode & MODEINITTRAN ){ + + tau = tau_dVds = tau_dVgs = tau_dVbs = tau_dT = 0.0 ; + taub = taub_dVds = taub_dVgs = taub_dVbs = taub_dT = 0.0 ; + + } else { + /* tau for inversion charge */ + if (flg_noqi == 0) { + T12 = model->HSMHV_dly1; + T10 = model->HSMHV_dly2; + + T3 = Lch ; + T1 = T10 * T12 * T3 * T3 ; + T2 = Mu * VgVt * T12 + T10 * T3 * T3 + small ; + tau = T1 / T2 ; + + T1_dVg = T10 * T12 * 2.0 * T3 * Lch_dVgs ; + T1_dVd = T10 * T12 * 2.0 * T3 * Lch_dVds ; + T1_dVb = T10 * T12 * 2.0 * T3 * Lch_dVbs ; + T1_dT = T10 * T12 * 2.0 * T3 * Lch_dT ; + + T2_dVg = T12 * Mu_dVgs * VgVt + + T12 * Mu * VgVt_dVgs + T10 * 2.0 * T3 * Lch_dVgs ; + T2_dVd = T12 * Mu_dVds * VgVt + + T12 * Mu * VgVt_dVds + T10 * 2.0 * T3 * Lch_dVds ; + T2_dVb = T12 * Mu_dVbs * VgVt + + T12 * Mu * VgVt_dVbs + T10 * 2.0 * T3 * Lch_dVbs ; + T2_dT = T12 * Mu_dT * VgVt + + T12 * Mu * VgVt_dT + T10 * 2.0 * T3 * Lch_dT ; + + T4 = 1.0 / T2 ; + tau_dVgs = ( T1_dVg - tau * T2_dVg ) * T4 ; + tau_dVds = ( T1_dVd - tau * T2_dVd ) * T4 ; + tau_dVbs = ( T1_dVb - tau * T2_dVb ) * T4 ; + tau_dT = ( T1_dT - tau * T2_dT ) * T4 ; + } else { + tau = model->HSMHV_dly1 ; + tau_dVgs = tau_dVds = tau_dVbs = tau_dT = 0.0 ; + } + + T1 = ckt->CKTdelta ; + + /* tau for bulk charge */ + T2 = modelMKS->HSMHV_dly3 ; + taub = T2 * Cox ; + taub_dVgs = T2 * Cox_dVg ; + taub_dVds = T2 * Cox_dVd ; + taub_dVbs = T2 * Cox_dVb ; + taub_dT = 0.0 ; + + } + } else { /* !(CKT_mode & MODETRAN) */ + + tau = tau_dVds = tau_dVgs = tau_dVbs = tau_dT = 0.0 ; + taub = taub_dVds = taub_dVgs = taub_dVbs = taub_dT = 0.0 ; + } + } + + if ( flg_nqs && (ckt->CKTmode & (MODEDCOP | MODEINITSMSIG)) ) { /* ACNQS */ + + if (flg_noqi == 0) { + T12 = model->HSMHV_dly1 ; + T10 = model->HSMHV_dly2 ; + + T3 = Lch ; + T1 = T12 * T10 * T3 * T3 ; + T2 = Mu * VgVt * T12 + T10 * T3 * T3 + small ; + tau = T1 / T2 ; + + T1_dVg = T10 * T12 * 2.0 * T3 * Lch_dVgs ; + T1_dVd = T10 * T12 * 2.0 * T3 * Lch_dVds ; + T1_dVb = T10 * T12 * 2.0 * T3 * Lch_dVbs ; + T1_dT = T10 * T12 * 2.0 * T3 * Lch_dT ; + + T2_dVg = T12 * Mu_dVgs * VgVt + T12 * Mu * VgVt_dVgs + + T10 * 2.0 * T3 * Lch_dVgs ; + T2_dVd = T12 * Mu_dVds * VgVt + T12 * Mu * VgVt_dVds + + T10 * 2.0 * T3 * Lch_dVds ; + T2_dVb = T12 * Mu_dVbs * VgVt + T12 * Mu * VgVt_dVbs + + T10 * 2.0 * T3 * Lch_dVbs ; + T2_dT = T12 * Mu_dT * VgVt + T12 * Mu * VgVt_dT + + T10 * 2.0 * T3 * Lch_dT ; + + T4 = 1.0 / T2 ; + tau_dVgs = (T1_dVg - tau * T2_dVg) * T4 ; + tau_dVds = (T1_dVd - tau * T2_dVd) * T4 ; + tau_dVbs = (T1_dVb - tau * T2_dVb) * T4 ; + tau_dT = (T1_dT - tau * T2_dT) * T4 ; + } else { + tau = model->HSMHV_dly1 ; + tau_dVgs = tau_dVds = tau_dVbs = tau_dT = 0.0 ; + } + + T2 = modelMKS->HSMHV_dly3 ; + taub = T2 * Cox; + taub_dVgs = T2 * Cox_dVg ; + taub_dVds = T2 * Cox_dVd ; + taub_dVbs = T2 * Cox_dVb ; + taub_dT = 0.0 ; + } + + /*-----------------------------------------------------------* + * End of PART-5. (label) + *-----------------*/ +/* end_of_part_5: +*/ + /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + * PART-6: Noise Calculation. + *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + + /*-----------------------------------------------------------* + * 1/f noise. + *-----------------*/ + if ( model->HSMHV_coflick != 0 && !flg_noqi ) { + + NFalp = pParam->HSMHV_nfalp ; + NFtrp = pParam->HSMHV_nftrp ; + Cit = modelMKS->HSMHV_cit ; + + T1 = Qn0 / C_QE ; + T2 = ( Cox + Qn0 / ( Ps0 - Vbscl ) + Cit ) * beta_inv / C_QE ; + T3 = -2.0E0 * Qi / C_QE / Lch / here->HSMHV_weff_nf - T1 ; + if ( T3 != T1 ) { + T4 = 1.0E0 / ( T1 + T2 ) / ( T3 + T2 ) + 2.0E0 * NFalp * Ey * Mu / ( T3 - T1 ) + * log( ( T3 + T2 ) / ( T1 + T2 ) ) + NFalp * Ey * Mu * NFalp * Ey * Mu ; + } else { + T4 = 1.0 / ( T1 + T2 ) / ( T3 + T2 ) + 2.0 * NFalp * Ey * Mu / ( T1 + T2 ) + + NFalp * Ey * Mu * NFalp * Ey * Mu; + } + Nflic = Ids * Ids * NFtrp / ( Lch * beta * here->HSMHV_weff_nf ) * T4 ; + } else { + Nflic = 0.0 ; + } + + /*-----------------------------------------------------------* + * thermal noise. + *-----------------*/ + if ( model->HSMHV_cothrml != 0 && !flg_noqi ) { + + Eyd = ( Psdl - Ps0 ) / Lch + small ; + T12 = Muun * Eyd / 1.0e7 ; + /* note: model->HSMHV_bb = 2 (electron) ;1 (hole) */ + if ( 1.0e0 - epsm10 <= model->HSMHV_bb && model->HSMHV_bb <= 1.0e0 + epsm10 ) { + T7 = 1.0e0 ; + } else if ( 2.0e0 - epsm10 <= model->HSMHV_bb && model->HSMHV_bb <= 2.0e0 + epsm10 ) { + T7 = T12 ; + } else { + T7 = Fn_Pow( Eyd, model->HSMHV_bb - 1.0e0 ) ; + } + T8 = T12 * T7 ; + T9 = 1.0e0 + T8 ; + T10 = Fn_Pow( T9, ( - 1.0e0 / model->HSMHV_bb - 1.0e0 ) ) ; + T11 = T9 * T10 ; + Mud_hoso = Muun * T11 ; + Mu_Ave = ( Mu + Mud_hoso ) / 2.0 ; + + /* Sid_h = GAMMA * 4.0 * C_KB * model->HSMHV_temp * gds0_h2; */ + T0 = Alpha * Alpha ; + Nthrml = here->HSMHV_weff_nf * Cox * VgVt * Mu + * ( ( 1e0 + 3e0 * Alpha + 6e0 * T0 ) * Mud_hoso * Mud_hoso + + ( 3e0 + 4e0 * Alpha + 3e0 * T0 ) * Mud_hoso * Mu + + ( 6e0 + 3e0 * Alpha + T0 ) * Mu * Mu ) + / ( 15e0 * Lch * ( 1e0 + Alpha ) * Mu_Ave * Mu_Ave ) ; + } else { + Nthrml = 0e0 ; + } + + + /*----------------------------------------------------------* + * induced gate noise. ( Part 2/3 ) + *----------------------*/ + if ( model->HSMHV_coign != 0 && model->HSMHV_cothrml != 0 && flg_ign == 1 && !flg_noqi ) { + sqrtkusaiL = sqrt( kusaiL ) ; + T2 = VgVt + sqrtkusaiL ; + T3 = kusai00 * kusai00 ; + T4 = kusaiL * kusaiL ; + T5 = 42.0e0 * kusai00 * kusaiL ; + T5 += 4.0e0 * ( T3 + T4 ) ; + T5 += 20.0e0 * sqrtkusaiL * VgVt * ( kusai00 + kusaiL ) ; + T10 = T2 * T2 ; + T10 *= T10 ; + kusai_ig = T5 / ( T10 * T2 ) ; /* Induced Gate Noise parameter */ + gds0_ign = here->HSMHV_weff_nf / Lch * Mu * Cox ; + gds0_h2 = gds0_ign * VgVt ; + GAMMA = Nthrml / gds0_h2 ; + T7 = kusai00 + 4.0e0 * VgVt * sqrtkusaiL + kusaiL ; + /* cross-correlation coefficient (= Sigid/sqrt(Sig*Sid) ) */ + crl_f = c_sqrt_15 * kusai00L * T7 + / ( 6.0e0 * T2 * sqrt( GAMMA * T2 * VgVt * T5 ) ) ; + } + + + /*-----------------------------------------------------------* + * End of PART-6. (label) + *-----------------*/ +/* end_of_part_6: +*/ + + /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + * PART-7: Evaluation of outputs. + *++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + + /*-----------------------------------------------------------* + * Implicit quantities related to Alpha. + *-----------------*/ + if ( flg_noqi == 0 && VgVt > VgVt_small ) { + Delta = fac1 * beta / ( 2 * Xi0p12 ) ; + Pslsat = VgVt / ( 1.0 + Delta ) + Ps0 ; + } else { + Pslsat = 0.0 ; + } + Vdsat = Pslsat - Pb2 ; + if ( Vdsat < 0.0 ) { + Vdsat = 0.0 ; + } + + /*-----------------------------------------------------------* + * Evaluate the derivatives w.r.t. external biases. + * -> not to be done for the flat and Schur version! + *-----------------*/ + + Ids += IdsIBPC ; + Ids_dVbs += IdsIBPC_dVbs ; + Ids_dVds += IdsIBPC_dVds ; + Ids_dVgs += IdsIBPC_dVgs ; + Ids_dT += IdsIBPC_dT ; + + /*---------------------------------------------------* + * Derivatives of junction diode currents and charges. + * - NOTE: These quantities are regarded as functions of + * external biases. + * - NOTE: node-base S/D + *-----------------*/ + Gbse = Gbs ; + Gbde = Gbd ; + Capbse = Capbs ; + Capbde = Capbd ; + + /*---------------------------------------------------* + * Extrapolate quantities if external biases are out of bounds. + * -> not necessary here + *-----------------*/ + + /*-----------------------------------------------------------* + * Warn negative conductance. + * - T1 ( = d Ids / d Vds ) is the derivative w.r.t. circuit bias. + *-----------------*/ + T1 = ModeNML * Ids_dVds + ModeRVS * ( Ids_dVbs + Ids_dVds + Ids_dVgs ) ; + + if ( flg_info >= 1 && + (Ids_dVbs < 0.0 || T1 < 0.0 || Ids_dVgs < 0.0) ) { + printf( "*** warning(HiSIM): Negative Conductance\n" ) ; + printf( " type = %d mode = %d\n" , model->HSMHV_type , here->HSMHV_mode ) ; + printf( " Vbs = %12.5e Vds = %12.5e Vgse= %12.5e\n" , + Vbs , Vds , Vgs ) ; + printf( " Ids_dVbs = %12.5e\n" , Ids_dVbs ) ; + printf( " Ids_dVds = %12.5e\n" , T1 ) ; + printf( " Ids_dVgs = %12.5e\n" , Ids_dVgs ) ; + } + + + /*-----------------------------------------------------------* + * Assign outputs. + *-----------------*/ + + + /*---------------------------------------------------* + * Channel current and conductances. + *-----------------*/ + here->HSMHV_ids = Mfactor * Ids ; + here->HSMHV_dIds_dVdsi = Mfactor * Ids_dVds ; + here->HSMHV_dIds_dVgsi = Mfactor * Ids_dVgs ; + here->HSMHV_dIds_dVbsi = Mfactor * Ids_dVbs ; + here->HSMHV_dIds_dTi = Mfactor * Ids_dT ; + + + /* -------------------------------------* + * Intrinsic charges / capacitances. + *-----------------*/ + if (flg_nqs) { /* for flat handling of NQS: the NQS charges are added in hsmhvld */ + + here->HSMHV_qg = 0.0 ; + here->HSMHV_qd = 0.0 ; + here->HSMHV_qs = 0.0 ; + + here->HSMHV_qdp = 0.0 ; + here->HSMHV_qsp = 0.0 ; + + here->HSMHV_dqdp_dVdse = 0.0 ; + here->HSMHV_dqdp_dVgse = 0.0 ; + here->HSMHV_dqdp_dVbse = 0.0 ; + here->HSMHV_dqdp_dTi = 0.0 ; + here->HSMHV_dqsp_dVdse = 0.0 ; + here->HSMHV_dqsp_dVgse = 0.0 ; + here->HSMHV_dqsp_dVbse = 0.0 ; + here->HSMHV_dqsp_dTi = 0.0 ; + + here->HSMHV_dQdi_dVdsi = 0.0 ; + here->HSMHV_dQdi_dVgsi = 0.0 ; + here->HSMHV_dQdi_dVbsi = 0.0 ; + here->HSMHV_dQdi_dTi = 0.0 ; + here->HSMHV_dQg_dVdsi = 0.0 ; + here->HSMHV_dQg_dVgsi = 0.0 ; + here->HSMHV_dQg_dVbsi = 0.0 ; + here->HSMHV_dQg_dTi = 0.0 ; + here->HSMHV_dQb_dVdsi = 0.0 ; + here->HSMHV_dQb_dVgsi = 0.0 ; + here->HSMHV_dQb_dVbsi = 0.0 ; + here->HSMHV_dQb_dTi = 0.0 ; + + here->HSMHV_tau = tau ; + here->HSMHV_tau_dVgsi = tau_dVgs ; + here->HSMHV_tau_dVdsi = tau_dVds ; + here->HSMHV_tau_dVbsi = tau_dVbs ; + here->HSMHV_tau_dTi = tau_dT ; + + here->HSMHV_taub = taub ; + here->HSMHV_taub_dVgsi = taub_dVgs ; + here->HSMHV_taub_dVdsi = taub_dVds ; + here->HSMHV_taub_dVbsi = taub_dVbs ; + here->HSMHV_taub_dTi = taub_dT ; + + here->HSMHV_Xd = Qdrat; + here->HSMHV_Xd_dVgsi = Qdrat_dVgs ; + here->HSMHV_Xd_dVdsi = Qdrat_dVds ; + here->HSMHV_Xd_dVbsi = Qdrat_dVbs ; + here->HSMHV_Xd_dTi = Qdrat_dT ; + + here->HSMHV_Qbulk = Mfactor * Qb ; + here->HSMHV_Qbulk_dVgsi = Mfactor * Qb_dVgs ; + here->HSMHV_Qbulk_dVdsi = Mfactor * Qb_dVds ; + here->HSMHV_Qbulk_dVbsi = Mfactor * Qb_dVbs ; + here->HSMHV_Qbulk_dTi = Mfactor * Qb_dT ; + + here->HSMHV_Qi = Mfactor * Qi ; + here->HSMHV_Qi_dVgsi = Mfactor * Qi_dVgs ; + here->HSMHV_Qi_dVdsi = Mfactor * Qi_dVds ; + here->HSMHV_Qi_dVbsi = Mfactor * Qi_dVbs ; + here->HSMHV_Qi_dTi = Mfactor * Qi_dT ; + + } else { /* QS */ + + here->HSMHV_qg = Mfactor * - (Qb + Qi) ; + here->HSMHV_qd = Mfactor * Qd ; + here->HSMHV_qs = Mfactor * ( Qi - Qd ) ; + here->HSMHV_qdp = 0.0 ; + here->HSMHV_qsp = 0.0 ; + + here->HSMHV_dqdp_dVdse = 0.0 ; + here->HSMHV_dqdp_dVgse = 0.0 ; + here->HSMHV_dqdp_dVbse = 0.0 ; + here->HSMHV_dqdp_dTi = 0.0 ; + here->HSMHV_dqsp_dVdse = 0.0 ; + here->HSMHV_dqsp_dVgse = 0.0 ; + here->HSMHV_dqsp_dVbse = 0.0 ; + here->HSMHV_dqsp_dTi = 0.0 ; + + here->HSMHV_dQdi_dVdsi = Mfactor * Qd_dVds ; + here->HSMHV_dQdi_dVgsi = Mfactor * Qd_dVgs ; + here->HSMHV_dQdi_dVbsi = Mfactor * Qd_dVbs ; + here->HSMHV_dQdi_dTi = Mfactor * Qd_dT ; + here->HSMHV_dQg_dVdsi = Mfactor * ( - Qb_dVds - Qi_dVds ) ; + here->HSMHV_dQg_dVgsi = Mfactor * ( - Qb_dVgs - Qi_dVgs ) ; + here->HSMHV_dQg_dVbsi = Mfactor * ( - Qb_dVbs - Qi_dVbs ) ; + here->HSMHV_dQg_dTi = Mfactor * ( - Qb_dT - Qi_dT ) ; + here->HSMHV_dQb_dVdsi = Mfactor * Qb_dVds ; + here->HSMHV_dQb_dVgsi = Mfactor * Qb_dVgs ; + here->HSMHV_dQb_dVbsi = Mfactor * Qb_dVbs ; + here->HSMHV_dQb_dTi = Mfactor * Qb_dT ; + } + + /*---------------------------------------------------* + * Add S/D overlap charges/capacitances to intrinsic ones. + * - NOTE: This function depends on coadov, a control option. + *-----------------*/ + if ( model->HSMHV_coadov == 1 ) { + here->HSMHV_qg += Mfactor * ( Qgod + Qgos + Qgbo + Qy - Qovd - Qovs ) ; + here->HSMHV_qd += Mfactor * ( - Qgod - Qy + QbdLD ) ; + here->HSMHV_qs += Mfactor * ( - Qgos + QbsLD ) ; + here->HSMHV_qdp += Mfactor * ( - Qfd - Qgdo + Qovdext ) ; + here->HSMHV_qsp += Mfactor * ( - Qfs - Qgso + Qovsext ) ; + + here->HSMHV_cddo = Mfactor * ( - Qgod_dVds - Qy_dVds + QbdLD_dVds ) ; + here->HSMHV_dQdi_dVdsi += here->HSMHV_cddo ; + here->HSMHV_cdgo = Mfactor * ( - Qgod_dVgs - Qy_dVgs + QbdLD_dVgs ) ; + here->HSMHV_dQdi_dVgsi += here->HSMHV_cdgo ; + here->HSMHV_cdbo = Mfactor * ( - Qgod_dVbs - Qy_dVbs + QbdLD_dVbs ) ; + here->HSMHV_dQdi_dVbsi += here->HSMHV_cdbo ; + here->HSMHV_dQdi_dTi += Mfactor * ( - Qgod_dT - Qy_dT + QbdLD_dT ) ; + here->HSMHV_cgdo = Mfactor * ( Qgod_dVds + Qgos_dVds + Qgbo_dVds + Qy_dVds - Qovd_dVds - Qovs_dVds ) ; + here->HSMHV_dQg_dVdsi += here->HSMHV_cgdo ; + here->HSMHV_cggo = Mfactor * ( Qgod_dVgs + Qgos_dVgs + Qgbo_dVgs + Qy_dVgs - Qovd_dVgs - Qovs_dVgs ) ; + here->HSMHV_dQg_dVgsi += here->HSMHV_cggo ; + here->HSMHV_cgbo = Mfactor * ( Qgod_dVbs + Qgos_dVbs + Qgbo_dVbs + Qy_dVbs - Qovd_dVbs - Qovs_dVbs ) ; + here->HSMHV_dQg_dVbsi += here->HSMHV_cgbo ; + here->HSMHV_dQg_dTi += Mfactor * ( Qgod_dT + Qgos_dT + Qgbo_dT + Qy_dT - Qovd_dT - Qovs_dT ) ; + here->HSMHV_cbdo = Mfactor * ( - Qgbo_dVds + QidLD_dVds + QisLD_dVds ) ; + here->HSMHV_dQb_dVdsi += here->HSMHV_cbdo ; + here->HSMHV_cbgo = Mfactor * ( - Qgbo_dVgs + QidLD_dVgs + QisLD_dVgs ) ; + here->HSMHV_dQb_dVgsi += here->HSMHV_cbgo ; + here->HSMHV_cbbo = Mfactor * ( - Qgbo_dVbs + QidLD_dVbs + QisLD_dVbs ) ; + here->HSMHV_dQb_dVbsi += here->HSMHV_cbbo ; + here->HSMHV_dQb_dTi += Mfactor * ( - Qgbo_dT + QidLD_dT + QisLD_dT ) ; + /* for fringing capacitances */ + here->HSMHV_dqdp_dVdse += Mfactor * ( Cfd - Qgdo_dVdse + Qovdext_dVdse ) ; + here->HSMHV_dqdp_dVgse += Mfactor * ( - Cfd - Qgdo_dVgse + Qovdext_dVgse ) ; + here->HSMHV_dqdp_dVbse += Mfactor * ( - Qgdo_dVbse + Qovdext_dVbse ) ; + here->HSMHV_dqdp_dTi += Mfactor * ( Qovdext_dT ) ; + here->HSMHV_dqsp_dVdse += Mfactor * ( - Qgso_dVdse + Qovsext_dVdse ) ; + here->HSMHV_dqsp_dVgse += Mfactor * ( - Cfs - Qgso_dVgse + Qovsext_dVgse ) ; + here->HSMHV_dqsp_dVbse += Mfactor * ( - Qgso_dVbse + Qovsext_dVbse ) ; + here->HSMHV_dqsp_dTi += Mfactor * ( Qovsext_dT ) ; + } + here->HSMHV_dQsi_dVdsi = - (here->HSMHV_dQdi_dVdsi + here->HSMHV_dQg_dVdsi + here->HSMHV_dQb_dVdsi) ; + here->HSMHV_dQsi_dVgsi = - (here->HSMHV_dQdi_dVgsi + here->HSMHV_dQg_dVgsi + here->HSMHV_dQb_dVgsi) ; + here->HSMHV_dQsi_dVbsi = - (here->HSMHV_dQdi_dVbsi + here->HSMHV_dQg_dVbsi + here->HSMHV_dQb_dVbsi) ; + here->HSMHV_dQsi_dTi = - (here->HSMHV_dQdi_dTi + here->HSMHV_dQg_dTi + here->HSMHV_dQb_dTi ) ; + + + /*---------------------------------------------------* + * Substrate/gate/leak currents. + *-----------------*/ + + here->HSMHV_isub = Mfactor * Isub ; + here->HSMHV_dIsub_dVdsi = Mfactor * Isub_dVds ; + here->HSMHV_dIsub_dVgsi = Mfactor * Isub_dVgs ; + here->HSMHV_dIsub_dVbsi = Mfactor * Isub_dVbs ; + here->HSMHV_dIsub_dTi = Mfactor * Isub_dT ; + here->HSMHV_dIsub_dVdse = Mfactor * Isub_dVdse ; + + here->HSMHV_igb = Mfactor * -Igb ; + here->HSMHV_dIgb_dVdsi = - Mfactor * Igb_dVds ; + here->HSMHV_dIgb_dVgsi = - Mfactor * Igb_dVgs ; + here->HSMHV_dIgb_dVbsi = - Mfactor * Igb_dVbs ; + here->HSMHV_dIgb_dTi = - Mfactor * Igb_dT ; + + if (here->HSMHV_mode == HiSIM_NORMAL_MODE) { + here->HSMHV_igd = Mfactor * ( model->HSMHV_glpart1 * Igate - Igd ) ; + } else { + here->HSMHV_igd = Mfactor * ( (1.0e0 - model->HSMHV_glpart1 ) * Igate - Igs ) ; + } + + if (here->HSMHV_mode == HiSIM_NORMAL_MODE) { + here->HSMHV_igs = Mfactor * ( (1.0e0 - model->HSMHV_glpart1) * Igate - Igs ) ; + } else { + here->HSMHV_igs = Mfactor * ( model->HSMHV_glpart1 * Igate - Igd ) ; + } + + /* note: here->HSMHV_igd and here->HSMHV_igs are already subjected to mode handling, + while the following derivatives here->HSMHV_dIgd_dVdsi, ... are not! */ + here->HSMHV_dIgd_dVdsi = Mfactor * ( model->HSMHV_glpart1 * Igate_dVds - Igd_dVds ) ; + here->HSMHV_dIgd_dVgsi = Mfactor * ( model->HSMHV_glpart1 * Igate_dVgs - Igd_dVgs ) ; + here->HSMHV_dIgd_dVbsi = Mfactor * ( model->HSMHV_glpart1 * Igate_dVbs - Igd_dVbs ) ; + here->HSMHV_dIgd_dTi = Mfactor * ( model->HSMHV_glpart1 * Igate_dT - Igd_dT ) ; + here->HSMHV_dIgs_dVdsi = Mfactor * ( (1.0 - model->HSMHV_glpart1) * Igate_dVds - Igs_dVds ) ; + here->HSMHV_dIgs_dVgsi = Mfactor * ( (1.0 - model->HSMHV_glpart1) * Igate_dVgs - Igs_dVgs ) ; + here->HSMHV_dIgs_dVbsi = Mfactor * ( (1.0 - model->HSMHV_glpart1) * Igate_dVbs - Igs_dVbs ) ; + here->HSMHV_dIgs_dTi = Mfactor * ( (1.0 - model->HSMHV_glpart1) * Igate_dT - Igs_dT ) ; + + here->HSMHV_igidl = Mfactor * Igidl ; + here->HSMHV_dIgidl_dVdsi = Mfactor * Igidl_dVds ; + here->HSMHV_dIgidl_dVgsi = Mfactor * Igidl_dVgs ; + here->HSMHV_dIgidl_dVbsi = Mfactor * Igidl_dVbs ; + here->HSMHV_dIgidl_dTi = Mfactor * Igidl_dT ; + + here->HSMHV_igisl = Mfactor * Igisl ; + here->HSMHV_dIgisl_dVdsi = Mfactor * Igisl_dVds ; + here->HSMHV_dIgisl_dVgsi = Mfactor * Igisl_dVgs ; + here->HSMHV_dIgisl_dVbsi = Mfactor * Igisl_dVbs ; + here->HSMHV_dIgisl_dTi = Mfactor * Igisl_dT ; + + /*---------------------------------------------------* + * Von, Vdsat. + *-----------------*/ + here->HSMHV_von = Vth ; + here->HSMHV_vdsat = Vdsat ; + + + + /*---------------------------------------------------* + * Junction diode. + *-----------------*/ + here->HSMHV_ibs = Mfactor * Ibs ; + here->HSMHV_ibd = Mfactor * Ibd ; + here->HSMHV_gbs = Mfactor * Gbse ; + here->HSMHV_gbd = Mfactor * Gbde ; + *(ckt->CKTstate0 + here->HSMHVqbs) = Mfactor * Qbs ; + *(ckt->CKTstate0 + here->HSMHVqbd) = Mfactor * Qbd ; + here->HSMHV_capbs = Mfactor * Capbse ; + here->HSMHV_capbd = Mfactor * Capbde ; + + here->HSMHV_gbdT = Mfactor * Ibd_dT ; + here->HSMHV_gbsT = Mfactor * Ibs_dT ; + here->HSMHV_gcbdT = Mfactor * Qbd_dT ; + here->HSMHV_gcbsT = Mfactor * Qbs_dT ; + + /*---------------------------------------------------* + * Add Gjmin (gmin). + *-----------------*/ + here->HSMHV_ibs += Mfactor * Gjmin * vbs_jct ; + here->HSMHV_ibd += Mfactor * Gjmin * vbd_jct ; + here->HSMHV_gbs += Mfactor * Gjmin ; + here->HSMHV_gbd += Mfactor * Gjmin ; + + /*-----------------------------------------------------------* + * Warn floating-point exceptions. + * - Function finite() in libm is called. + * - Go to start with info==5. + *-----------------*/ + T1 = here->HSMHV_ids + here->HSMHV_dIds_dVdsi + here->HSMHV_dIds_dVgsi + here->HSMHV_dIds_dVbsi ; + T1 = T1 + here->HSMHV_qd - (here->HSMHV_dQdi_dVdsi + here->HSMHV_dQdi_dVgsi + here->HSMHV_dQdi_dVbsi) ; + if ( ! finite (T1) ) { + flg_err = 1 ; + fprintf (stderr , + "*** warning(HiSIM): FP-exception (PART-1)\n" ) ; + if ( flg_info >= 1 ) { + printf ( "*** warning(HiSIM): FP-exception\n") ; + printf ( "Ids = %e\n" , here->HSMHV_ids ) ; + printf ( "Gmbs = %e\n" , here->HSMHV_dIds_dVbsi ) ; + printf ( "Gds = %e\n" , here->HSMHV_dIds_dVdsi ) ; + printf ( "Gm = %e\n" , here->HSMHV_dIds_dVgsi ) ; + printf ( "Qd = %e\n" , here->HSMHV_qd ) ; + printf ( "Cds = %e\n" , -(here->HSMHV_dQdi_dVdsi + + here->HSMHV_dQdi_dVgsi + + here->HSMHV_dQdi_dVbsi) ) ; + } + } + + T1 = here->HSMHV_isub + here->HSMHV_dIsub_dVbsi + here->HSMHV_dIsub_dVdsi + here->HSMHV_dIsub_dVgsi ; + if ( ! finite (T1) ) { + flg_err = 1 ; + fprintf (stderr , + "*** warning(HiSIM): FP-exception (PART-2)\n") ; + if ( flg_info >= 1 ) { + printf ("*** warning(HiSIM): FP-exception\n") ; + } + } + + T1 = here->HSMHV_dQg_dVdsi + here->HSMHV_dQg_dVgsi + here->HSMHV_dQg_dVbsi ; + if ( ! finite (T1) ) { + flg_err = 1 ; + fprintf(stderr , + "*** warning(HiSIM): FP-exception (PART-3)\n") ; + if ( flg_info >= 1 ) { + printf ("*** warning(HiSIM): FP-exception\n") ; + } + } + + T1 = here->HSMHV_ibs + here->HSMHV_ibd + here->HSMHV_gbs + here->HSMHV_gbd ; + T1 = T1 + *(ckt->CKTstate0 + here->HSMHVqbs) + *(ckt->CKTstate0 + here->HSMHVqbd) + here->HSMHV_capbs + here->HSMHV_capbd ; + if ( ! finite (T1) ) { + flg_err = 1 ; + fprintf(stderr , + "*** warning(HiSIM): FP-exception (PART-4)\n") ; + if ( flg_info >= 1 ) { + printf ("*** warning(HiSIM): FP-exception\n") ; + } + } + + /*-----------------------------------------------------------* + * Exit for error case. + *-----------------*/ + if ( flg_err != 0 ) { + fprintf (stderr , "----- bias information (HiSIM)\n" ) ; + fprintf (stderr , "name: %s\n" , here->HSMHVname ) ; + fprintf (stderr , "states: %d\n" , here->HSMHVstates ) ; + fprintf (stderr , "Vdse= %.3e Vgse=%.3e Vbse=%.3e\n" + , Vdse , Vgse , Vbse ) ; + fprintf (stderr , "Vdsi= %.3e Vgsi=%.3e Vbsi=%.3e\n" + , Vds , Vgs , Vbs ) ; + fprintf (stderr , "vbs_jct= %12.5e vbd_jct= %12.5e\n" + , vbs_jct , vbd_jct ) ; + fprintf (stderr , "vd= %.3e vs= %.3e vdp= %.3e vgp= %.3e vbp= %.3e vsp= %.3e\n" + , *( ckt->CKTrhsOld + here->HSMHVdNode ) + , *( ckt->CKTrhsOld + here->HSMHVsNode ) + , *( ckt->CKTrhsOld + here->HSMHVdNodePrime ) + , *( ckt->CKTrhsOld + here->HSMHVgNodePrime ) + , *( ckt->CKTrhsOld + here->HSMHVbNodePrime ) + , *( ckt->CKTrhsOld + here->HSMHVsNodePrime ) ) ; + fprintf (stderr , "----- bias information (end)\n" ) ; + return ( HiSIM_ERROR ) ; + } + + + /*-----------------------------------------------------------* + * Noise. + *-----------------*/ + here->HSMHV_noiflick = Mfactor * Nflic ; + here->HSMHV_noithrml = Mfactor * Nthrml ; + + /*----------------------------------------------------------* + * induced gate noise. ( Part 3/3 ) + *----------------------*/ + if ( model->HSMHV_coign != 0 && model->HSMHV_cothrml != 0 && flg_ign == 1 && !flg_noqi ) { + T0 = Cox_small * Cox * here->HSMHV_weff_nf * Leff ; + T1 = -( here->HSMHV_dQg_dVdsi + here->HSMHV_dQg_dVgsi + here->HSMHV_dQg_dVbsi ) / Mfactor ; /* NQS case is not supported. */ + if( - T1 > T0 ){ + Nign0 = c_16o135 * C_QE * beta_inv * T1 * T1 / gds0_ign ; + if ( kusai00L > epsm10 && Vds > epsm10 ) { + MuModA = Muun / Mu ; + MuModB = ( Muun / Mud_hoso - MuModA ) / Vds ; + correct_w1 = MuModA + C_2o3 * MuModB + * ( kusai00 + VgVt * sqrtkusaiL + kusaiL ) + / ( VgVt + sqrtkusaiL ) ; + } else { + correct_w1 = Muun / Mud_hoso ; + } + here->HSMHV_noiigate = Mfactor * Nign0 * kusai_ig * correct_w1 ; + here->HSMHV_noicross = crl_f ; + if ( here->HSMHV_noiigate < 0.0 ) here->HSMHV_noiigate = 0.0e0 ; + }else{ + here->HSMHV_noiigate = 0.0e0 ; + here->HSMHV_noicross = 0.0e0 ; + } + }else{ + here->HSMHV_noiigate = 0.0e0 ; + here->HSMHV_noicross = 0.0e0 ; + } + + /*-----------------------------------------------------------* + * Store values for next calculation. + *-----------------*/ + + /* Internal biases */ + if ( here->HSMHV_called >= 1 ) { + here->HSMHV_vbsc_prv2 = here->HSMHV_vbsc_prv ; + here->HSMHV_vdsc_prv2 = here->HSMHV_vdsc_prv ; + here->HSMHV_vgsc_prv2 = here->HSMHV_vgsc_prv ; + here->HSMHV_mode_prv2 = here->HSMHV_mode_prv ; + } + here->HSMHV_vbsc_prv = Vbs ; + here->HSMHV_vdsc_prv = Vds ; + here->HSMHV_vgsc_prv = Vgs ; + here->HSMHV_mode_prv = here->HSMHV_mode ; + here->HSMHV_temp_prv = TTEMP ; + + /* Surface potentials and derivatives w.r.t. internal biases */ + if ( here->HSMHV_called >= 1 ) { + here->HSMHV_ps0_prv2 = here->HSMHV_ps0_prv ; + here->HSMHV_ps0_dvbs_prv2 = here->HSMHV_ps0_dvbs_prv ; + here->HSMHV_ps0_dvds_prv2 = here->HSMHV_ps0_dvds_prv ; + here->HSMHV_ps0_dvgs_prv2 = here->HSMHV_ps0_dvgs_prv ; + here->HSMHV_pds_prv2 = here->HSMHV_pds_prv ; + here->HSMHV_pds_dvbs_prv2 = here->HSMHV_pds_dvbs_prv ; + here->HSMHV_pds_dvds_prv2 = here->HSMHV_pds_dvds_prv ; + here->HSMHV_pds_dvgs_prv2 = here->HSMHV_pds_dvgs_prv ; + } + + here->HSMHV_ps0_prv = Ps0 ; + here->HSMHV_ps0_dvbs_prv = Ps0_dVbs ; + here->HSMHV_ps0_dvds_prv = Ps0_dVds ; + here->HSMHV_ps0_dvgs_prv = Ps0_dVgs ; + here->HSMHV_ps0_dtemp_prv = Ps0_dT ; + here->HSMHV_pds_prv = Pds ; + here->HSMHV_pds_dvbs_prv = Pds_dVbs ; + here->HSMHV_pds_dvds_prv = Pds_dVds ; + here->HSMHV_pds_dvgs_prv = Pds_dVgs ; + here->HSMHV_pds_dtemp_prv = Pds_dT ; + + + /* derivatives of channel current w.r.t. external bias (only due to Ra-dependencies!) */ + here->HSMHV_dIds_dVdse = Ids_dRa * Ra_dVdse * Mfactor ; + here->HSMHV_dIds_dVgse = Ids_dRa * Ra_dVgse * Mfactor ; + here->HSMHV_dIds_dVbse = Ids_dRa * Ra_dVbse * Mfactor ; + + if ( VdseModeNML > 0.0 ) { + here->HSMHV_Rd = Rd / Mfactor ; + here->HSMHV_dRd_dVdse = Rd_dVdse / Mfactor ; + here->HSMHV_dRd_dVgse = Rd_dVgse / Mfactor ; + here->HSMHV_dRd_dVbse = Rd_dVbse / Mfactor ; + here->HSMHV_dRd_dVsubs = Rd_dVsubs / Mfactor ; + here->HSMHV_dRd_dTi = Rd_dT / Mfactor ; + here->HSMHV_Rs = Rs / Mfactor ; + here->HSMHV_dRs_dVdse = Rs_dVdse / Mfactor ; + here->HSMHV_dRs_dVgse = Rs_dVgse / Mfactor ; + here->HSMHV_dRs_dVbse = Rs_dVbse / Mfactor ; + here->HSMHV_dRs_dVsubs = Rs_dVsubs / Mfactor ; + here->HSMHV_dRs_dTi = Rs_dT / Mfactor ; + } else { + here->HSMHV_Rd = Rs / Mfactor ; + here->HSMHV_dRd_dVdse = - ( Rs_dVdse + Rs_dVgse + Rs_dVbse ) / Mfactor ; + here->HSMHV_dRd_dVgse = Rs_dVgse / Mfactor ; + here->HSMHV_dRd_dVbse = Rs_dVbse / Mfactor ; + here->HSMHV_dRd_dVsubs = Rs_dVsubs / Mfactor ; + here->HSMHV_dRd_dTi = Rs_dT / Mfactor ; + here->HSMHV_Rs = Rd / Mfactor ; + here->HSMHV_dRs_dVdse = - ( Rd_dVdse + Rd_dVgse + Rd_dVbse ) / Mfactor ; + here->HSMHV_dRs_dVgse = Rd_dVgse / Mfactor ; + here->HSMHV_dRs_dVbse = Rd_dVbse / Mfactor ; + here->HSMHV_dRs_dVsubs = Rd_dVsubs / Mfactor ; + here->HSMHV_dRs_dTi = Rd_dT / Mfactor ; + } + /* Clamping to Res_min */ + if(here->HSMHV_Rd < Res_min) { + here->HSMHV_Rd = Res_min ; + here->HSMHV_dRd_dVdse = 0.0 ; + here->HSMHV_dRd_dVgse = 0.0 ; + here->HSMHV_dRd_dVbse = 0.0 ; + here->HSMHV_dRd_dVsubs = 0.0 ; + here->HSMHV_dRd_dTi = 0.0 ; + } + if(here->HSMHV_Rs < Res_min) { + here->HSMHV_Rs = Res_min ; + here->HSMHV_dRs_dVdse = 0.0 ; + here->HSMHV_dRs_dVgse = 0.0 ; + here->HSMHV_dRs_dVbse = 0.0 ; + here->HSMHV_dRs_dVsubs = 0.0 ; + here->HSMHV_dRs_dTi = 0.0 ; + } + + /*-----------------------------------------------------------* + * End of PART-7. (label) + *-----------------*/ +/* end_of_part_7: +*/ + /*-----------------------------------------------------------* + * Bottom of hsmhveval. + *-----------------*/ + + return ( HiSIM_OK ) ; + +} /* end of hsmhveval */ diff --git a/src/spicelib/devices/hisimhv/hsmhveval_qover.h b/src/spicelib/devices/hisimhv/hsmhveval_qover.h new file mode 100644 index 000000000..dbf3e27eb --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhveval_qover.h @@ -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 */ diff --git a/src/spicelib/devices/hisimhv/hsmhvevalenv.h b/src/spicelib/devices/hisimhv/hsmhvevalenv.h new file mode 100644 index 000000000..e3ffc84c5 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvevalenv.h @@ -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 */ diff --git a/src/spicelib/devices/hisimhv/hsmhvext.h b/src/spicelib/devices/hisimhv/hsmhvext.h new file mode 100644 index 000000000..4fef5d909 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvext.h @@ -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*); diff --git a/src/spicelib/devices/hisimhv/hsmhvgetic.c b/src/spicelib/devices/hisimhv/hsmhvgetic.c new file mode 100644 index 000000000..46fc809ad --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvgetic.c @@ -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 +#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); +} + diff --git a/src/spicelib/devices/hisimhv/hsmhvinit.c b/src/spicelib/devices/hisimhv/hsmhvinit.c new file mode 100644 index 000000000..12c2c585d --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvinit.c @@ -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; +} diff --git a/src/spicelib/devices/hisimhv/hsmhvinit.h b/src/spicelib/devices/hisimhv/hsmhvinit.h new file mode 100644 index 000000000..24066b28b --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvinit.h @@ -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 diff --git a/src/spicelib/devices/hisimhv/hsmhvitf.h b/src/spicelib/devices/hisimhv/hsmhvitf.h new file mode 100644 index 000000000..cddd1aa91 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvitf.h @@ -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 diff --git a/src/spicelib/devices/hisimhv/hsmhvld.c b/src/spicelib/devices/hisimhv/hsmhvld.c new file mode 100644 index 000000000..4013fbd51 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvld.c @@ -0,0 +1,2583 @@ +/*********************************************************************** + + 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.c + + DATE : 2010.11.02 + + released by + Hiroshima University & + Semiconductor Technology Academic Research Center (STARC) +***********************************************************************/ + +#include +#include "ngspice.h" +#include "hisimhv.h" +#include "trandefs.h" +#include "const.h" +#include "sperror.h" +#include "devdefs.h" +#include "suffix.h" + + +#define SHOW_EPS_QUANT 1.0e-15 + +static void ShowPhysVals +( + HSMHVinstance *here, + HSMHVmodel *model, + int isFirst, + double vds, + double vgs, + double vbs, + double vgd, + double vbd, + double vgb + ) +{ + + /* */ + /* */ + /* Note: This function is not yet adapted to the flat version */ + /* */ + /* */ + + /* regard the epsilon-quantity as 0.0 */ + vds = (fabs(vds) < SHOW_EPS_QUANT) ? 0.0 : vds; + vgs = (fabs(vgs) < SHOW_EPS_QUANT) ? 0.0 : vgs; + vbs = (fabs(vbs) < SHOW_EPS_QUANT) ? 0.0 : vbs; + vgb = (fabs(vgb) < SHOW_EPS_QUANT) ? 0.0 : vgb; + switch (model->HSMHV_show) { + case 1: + if (isFirst) printf("Vds Ids\n"); + printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_mode*here->HSMHV_ids); + break; + case 2: + if (isFirst) printf("Vgs Ids\n"); + printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_mode*here->HSMHV_ids); + break; + case 3: + if (isFirst) printf("Vgs log10(|Ids|)\n"); + printf("%e %e\n", model->HSMHV_type*vgs, log10(here->HSMHV_ids)); + break; + case 4: + if (isFirst) printf("log10(|Ids|) gm/|Ids|\n"); + if (here->HSMHV_ids == 0.0) + printf("I can't show gm/Ids - log10(Ids), because Ids = 0.\n"); + else + printf("%e %e\n", log10(here->HSMHV_ids), here->HSMHV_gm/here->HSMHV_ids); + break; + case 5: + if (isFirst) printf("Vds gds\n"); + printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_gds); + break; + case 6: + if (isFirst) printf("Vgs gm\n"); + printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_gm); + break; + case 7: + if (isFirst) printf("Vbs gbs\n"); + printf("%e %e\n", model->HSMHV_type*vbs, here->HSMHV_gmbs); + break; + case 8: + if (isFirst) printf("Vgs Cgg\n"); + printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_cggb); + break; + case 9: + if (isFirst) printf("Vgs Cgs\n"); + printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_cgsb); + break; + case 10: + if (isFirst) printf("Vgs Cgd\n"); + printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_cgdb); + break; + case 11: + if (isFirst) printf("Vgs Cgb\n"); + printf("%e %e\n", model->HSMHV_type*vgs, -(here->HSMHV_cggb+here->HSMHV_cgsb+here->HSMHV_cgdb)); + break; + case 12: + if (isFirst) printf("Vds Csg\n"); + printf("%e %e\n", model->HSMHV_type*vds, -(here->HSMHV_cggb+here->HSMHV_cbgb+here->HSMHV_cdgb)); + break; + case 13: + if (isFirst) printf("Vds Cdg\n"); + printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_cdgb); + break; + case 14: + if (isFirst) printf("Vds Cbg\n"); + printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_cbgb); + break; + case 15: + if (isFirst) printf("Vds Cgg\n"); + printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_cggb); + break; + case 16: + if (isFirst) printf("Vds Cgs\n"); + printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_cgsb); + break; + case 17: + if (isFirst) printf("Vds Cgd\n"); + printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_cgdb); + break; + case 18: + if (isFirst) printf("Vds Cgb\n"); + printf("%e %e\n", model->HSMHV_type*vds, -(here->HSMHV_cggb+here->HSMHV_cgsb+here->HSMHV_cgdb)); + break; + case 19: + if (isFirst) printf("Vgs Csg\n"); + printf("%e %e\n", model->HSMHV_type*vgs, -(here->HSMHV_cggb+here->HSMHV_cbgb+here->HSMHV_cdgb)); + break; + case 20: + if (isFirst) printf("Vgs Cdg\n"); + printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_cdgb); + break; + case 21: + if (isFirst) printf("Vgs Cbg\n"); + printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_cbgb); + break; + case 22: + if (isFirst) printf("Vgb Cgb\n"); + printf("%e %e\n", model->HSMHV_type*vgb, -(here->HSMHV_cggb+here->HSMHV_cgsb+here->HSMHV_cgdb)); + break; + case 50: + if (isFirst) printf("Vgs Vds Vbs Vgb Ids log10(|Ids|) gm/|Ids| gm gds gbs Cgg Cgs Cgb Cgd Csg Cbg Cdg\n"); + printf("%e %e %e %e %e %e %e %e %e %e %e %e %e %e %e %e %e\n", + model->HSMHV_type*vgs, model->HSMHV_type*vds, model->HSMHV_type*vbs, model->HSMHV_type*vgb, here->HSMHV_mode*here->HSMHV_ids, + log10(here->HSMHV_ids), here->HSMHV_gm/here->HSMHV_ids, here->HSMHV_gm, here->HSMHV_gds, here->HSMHV_gmbs, here->HSMHV_cggb, + here->HSMHV_cgsb, -(here->HSMHV_cggb+here->HSMHV_cgsb+here->HSMHV_cgdb), here->HSMHV_cgdb, + -(here->HSMHV_cggb+here->HSMHV_cbgb+here->HSMHV_cdgb), here->HSMHV_cbgb, here->HSMHV_cdgb); + break; + default: + /* + printf("There is no physical value corrsponding to %d\n", flag); + */ + break; + } +} + +int HSMHVload( + GENmodel *inModel, + register CKTcircuit *ckt) + /* actually load the current value into the + * sparse matrix previously provided + */ +{ + register HSMHVmodel *model = (HSMHVmodel*)inModel; + register HSMHVinstance *here; + HSMHVbinningParam *pParam; + HSMHVmodelMKSParam *modelMKS ; + HSMHVhereMKSParam *hereMKS ; + + + + /* node voltages */ +#define XDIM 14 + double x[XDIM] ; + + /* branch voltages */ + double vbd=0.0, vbs=0.0, vds=0.0, vgb=0.0, vgd=0.0, vgdo=0.0, vgs=0.0 ; + double vdbs=0.0, vsbs=0.0, vdbd=0.0 ; + double vges=0.0, vged=0.0, vgedo=0.0 ; + double vbs_jct=0.0, vbd_jct=0.0; + double deltemp = 0.0 , deltemp_old = 0.0 ; + double vggp=0, vddp=0, vssp=0, vbpb=0, vbpsb=0, vbpdb=0 ; + double vdse=0.0, vgse=0.0, vbse=0.0 ; + double vsubs=0.0 ; /* substrate bias */ + + double ivds=0.0, ivgs=0.0, ivbs=0.0 ; + double ivgse=0.0, ivdse=0.0, ivbse=0.0 ; + + /* delta of branch voltages */ + double delvbs=0.0, delvds=0.0, delvgs=0.0, delvsbs=0.0, delvdbd=0.0, deldeltemp = 0.0 ; + double delvdse=0.0, delvgse=0.0, delvbse=0.0, delvddp=0.0, delvssp=0.0, delvggp=0.0, delvbpb=0.0, delvbpdb=0.0, delvbpsb =0.0 ; + double delvsubs=0.0; /* substrate bias change */ + + /* branch currents */ + double Ids=0.0, gds=0.0, gm=0.0, gmbs=0.0, gmT=0.0, + gds_ext=0.0, gm_ext=0.0, gmbs_ext=0.0 ; + double Igd=0.0, dIgd_dVd=0.0, dIgd_dVg=0.0, dIgd_dVb=0.0, dIgd_dVs=0.0, dIgd_dT=0.0 ; + double Igs=0.0, dIgs_dVd=0.0, dIgs_dVg=0.0, dIgs_dVb=0.0, dIgs_dVs=0.0, dIgs_dT=0.0 ; + double Igb=0.0, dIgb_dVd=0.0, dIgb_dVg=0.0, dIgb_dVb=0.0, dIgb_dVs=0.0, dIgb_dT=0.0 ; + double Isub=0.0, dIsub_dVds=0.0, dIsub_dVgs=0.0, dIsub_dVbs=0.0, dIsub_dT=0.0 ; + double Isubs=0.0, dIsubs_dVds=0.0, dIsubs_dVgs=0.0, dIsubs_dVbs=0.0, dIsubs_dT=0.0 ; + double dIsub_dVdse=0.0, dIsubs_dVdse=0.0 ; + double Igidl=0.0, dIgidl_dVds=0.0, dIgidl_dVgs=0.0, dIgidl_dVbs=0.0, dIgidl_dT=0.0 ; + double Igisl=0.0, dIgisl_dVds=0.0, dIgisl_dVgs=0.0, dIgisl_dVbs=0.0, dIgisl_dT=0.0 ; + double Ibd=0.0, Gbd=0.0, Gbdt=0.0 ; + double Ibs=0.0, Gbs=0.0, Gbst=0.0 ; + double Iddp=0.0, dIddp_dVddp=0.0, dIddp_dVdse=0.0, dIddp_dVgse=0.0, dIddp_dVbse=0.0, dIddp_dVsubs=0.0, dIddp_dT =0.0 ; + double Issp=0.0, dIssp_dVssp=0.0, dIssp_dVdse=0.0, dIssp_dVgse=0.0, dIssp_dVbse=0.0, dIssp_dVsubs=0.0, dIssp_dT =0.0 ; + double Iggp=0.0, dIggp_dVggp =0.0 ; + double Ibpb=0.0, dIbpb_dVbpb =0.0 ; + double Ibpdb=0.0, dIbpdb_dVbpdb =0.0 ; + double Ibpsb=0.0, dIbpsb_dVbpsb =0.0 ; + double Ith=0.0, dIth_dT =0.0 ; + + /* displacement currents */ + double cq_d=0.0, cq_dP=0.0, cq_g=0.0, cq_gP=0.0, cq_s=0.0, cq_sP=0.0, cq_bP=0.0, cq_b=0.0, cq_db=0.0, cq_sb=0.0, cq_t=0.0 ; + + /* node currents */ + double cur_d=0.0, cur_dP=0.0, cur_g=0.0, cur_gP=0.0, cur_s=0.0, cur_sP=0.0, cur_bP=0.0, cur_b=0.0, cur_db=0.0, cur_sb=0.0, cur_t=0.0 ; + double i_d=0.0, i_dP=0.0, i_g=0.0, i_gP=0.0, i_s=0.0, i_sP=0.0, i_bP=0.0, i_b=0.0, i_db=0.0, i_sb=0.0, i_t=0.0 ; + + /* resistances and conductances */ + double Rd=0.0, dRd_dVdse=0.0, dRd_dVgse=0.0, dRd_dVbse=0.0, dRd_dVsubs=0.0, dRd_dT=0.0 ; + double Rs=0.0, dRs_dVdse=0.0, dRs_dVgse=0.0, dRs_dVbse=0.0, dRs_dVsubs=0.0, dRs_dT=0.0 ; + + double GD=0.0, GD_dVds=0.0, GD_dVgs=0.0, GD_dVbs=0.0, GD_dVsubs=0.0, GD_dT=0.0 ; + double GS=0.0, GS_dVds=0.0, GS_dVgs=0.0, GS_dVbs=0.0, GS_dVsubs=0.0, GS_dT=0.0 ; + double Gth=0.0 ; + double GG=0.0, GRBPD=0.0, GRBPS=0.0, GRBPB=0.0; + + /* charges */ + double Qd=0.0, dQd_dVds=0.0, dQd_dVgs=0.0, dQd_dVbs=0.0, dQd_dT=0.0 ; + double Qg=0.0, dQg_dVds=0.0, dQg_dVgs=0.0, dQg_dVbs=0.0, dQg_dT=0.0 ; + double Qs=0.0, dQs_dVds=0.0, dQs_dVgs=0.0, dQs_dVbs=0.0, dQs_dT=0.0 ; + double Qb=0.0, dQb_dVds=0.0, dQb_dVgs=0.0, dQb_dVbs=0.0, dQb_dT=0.0 ; + double Qbd=0.0, Cbd=0.0, Cbdt=0.0, + Qbs=0.0, Cbs=0.0, Cbst=0.0 ; + double Qth=0.0, Cth =0.0 ; + double Qfd=0.0, dQfd_dVdse=0.0, dQfd_dVgse=0.0, dQfd_dVbse=0.0, dQfd_dT=0.0 ; + double Qfs=0.0, dQfs_dVdse=0.0, dQfs_dVgse=0.0, dQfs_dVbse=0.0, dQfs_dT=0.0 ; + + /* 5th substrate node */ + int flg_subNode = 0 ; + + /* self heating */ + double Veffpower=0.0, dVeffpower_dVds=0.0, dVeffpower_dVdse =0.0 ; + double P=0.0, dP_dVds=0.0, dP_dVgs=0.0, dP_dVbs=0.0, dP_dT =0.0, + dP_dVdse=0.0, dP_dVgse=0.0, dP_dVbse =0.0 ; + int flg_tempNode = 0 ; + double T0 , T1 , T2 ; + +#define SHE_MAX_dlt 0.1 + +#define C_RTH_MIN 1.0e-4 + + double TMF1 , TMF2 ; +/*---------------------------------------------------* +* smoothUpper: ceiling. +* y = xmax - 0.5 ( arg + sqrt( arg^2 + 4 xmax delta ) ) +* arg = xmax - x - delta +*-----------------*/ + +#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 ) ; \ + } + + /* NQS related variables */ + int flg_nqs =0 ; + double Qi_nqs=0.0, Qb_nqs=0.0, delQi_nqs=0.0, delQb_nqs=0.0, i_qi=0.0, i_qb=0.0, cq_qi=0.0, cq_qb=0.0, cur_qi=0.0, cur_qb =0.0 ; + double Iqi_nqs=0.0, dIqi_nqs_dVds=0.0, dIqi_nqs_dVgs=0.0, dIqi_nqs_dVbs=0.0, dIqi_nqs_dT=0.0, dIqi_nqs_dQi_nqs =0.0 ; + double Iqb_nqs=0.0, dIqb_nqs_dVds=0.0, dIqb_nqs_dVgs=0.0, dIqb_nqs_dVbs=0.0, dIqb_nqs_dT=0.0, dIqb_nqs_dQb_nqs =0.0 ; + double Qd_nqs=0.0, dQd_nqs_dVds=0.0, dQd_nqs_dVgs=0.0, dQd_nqs_dVbs=0.0, dQd_nqs_dT=0.0, dQd_nqs_dQi_nqs =0.0 ; + double Qs_nqs=0.0, dQs_nqs_dVds=0.0, dQs_nqs_dVgs=0.0, dQs_nqs_dVbs=0.0, dQs_nqs_dT=0.0, dQs_nqs_dQi_nqs =0.0 ; + double Qg_nqs=0.0, dQg_nqs_dQi_nqs=0.0, dQg_nqs_dQb_nqs =0.0 ; + double tau=0.0, dtau_dVds=0.0, dtau_dVgs=0.0, dtau_dVbs=0.0, dtau_dT =0.0 ; + double taub=0.0, dtaub_dVds=0.0, dtaub_dVgs=0.0, dtaub_dVbs=0.0, dtaub_dT =0.0 ; + double Qdrat=0.0, dQdrat_dVds=0.0, dQdrat_dVgs=0.0, dQdrat_dVbs=0.0, dQdrat_dT =0.0 ; + double Qi=0.0, dQi_dVds=0.0, dQi_dVgs=0.0, dQi_dVbs=0.0, dQi_dT =0.0 ; + double Qbulk=0.0, dQbulk_dVds=0.0, dQbulk_dVgs=0.0, dQbulk_dVbs=0.0, dQbulk_dT =0.0 ; + + /* output related variables */ + double dQi_nqs_dVds=0.0, dQi_nqs_dVgs=0.0, dQi_nqs_dVbs=0.0, + dQb_nqs_dVds=0.0, dQb_nqs_dVgs=0.0, dQb_nqs_dVbs=0.0 ; + double cgdb_nqs=0.0, cggb_nqs=0.0, cgsb_nqs=0.0, + cbdb_nqs=0.0, cbgb_nqs=0.0, cbsb_nqs=0.0, + cddb_nqs=0.0, cdgb_nqs=0.0, cdsb_nqs=0.0 ; + double cgdb=0.0, cggb=0.0, cgsb=0.0, + cbdb=0.0, cbgb=0.0, cbsb=0.0, + cddb=0.0, cdgb=0.0, cdsb=0.0 ; + + /* rows of conductance and capacitance matrix stamp */ + double ydc_d[XDIM], ydc_dP[XDIM], ydc_g[XDIM], ydc_gP[XDIM], ydc_s[XDIM], ydc_sP[XDIM] ; + double ydc_bP[XDIM], ydc_b[XDIM], ydc_db[XDIM], ydc_sb[XDIM], ydc_t[XDIM], ydc_qi[XDIM], ydc_qb[XDIM] ; + double ydyn_d[XDIM], ydyn_dP[XDIM], ydyn_g[XDIM], ydyn_gP[XDIM], ydyn_s[XDIM], ydyn_sP[XDIM] ; + double ydyn_bP[XDIM], ydyn_b[XDIM], ydyn_db[XDIM], ydyn_sb[XDIM], ydyn_t[XDIM], ydyn_qi[XDIM], ydyn_qb[XDIM] ; + + /* limiter, bypass, and convergence */ + int ByPass=0, Check=0, Check1=0, Check2=0, Check3=0, error=0 ; + double von=0.0, limval =0.0 ; + double 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 ; + +#define LIM_TOL 1.0e0 +#define LIM_TOL2 1.0e0 + + /* predictor and numerical integration stuff */ + double ag0=0.0, xfact=0.0 ; + double ceq=0.0, geq=0.0 ; + int ChargeComputationNeeded = + ((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) || + ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC))) + ? 1 : 0; + int showPhysVal=0 ; + int isConv=0 ; + double vds_pre=0.0 ; + int i=0, noncon_old=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 +#define lastNode 13 /* must be the last node! */ + + +#define SPICE_rhs 1 /* set to 0 if rhs to be loaded for standard Newton */ + /* set to 1 if rhs_eq to be loaded, e.g. for SPICE */ + + if (SPICE_rhs) { + for (i=0; iHSMHVnextModel ) { + /* loop through all the instances of the model */ + + modelMKS = &model->modelMKS ; + + for (here = model->HSMHVinstances; here != NULL ; + here = here->HSMHVnextInstance) { + + hereMKS = &here->hereMKS ; + pParam = &here->pParam ; + showPhysVal = 0; + Check=1; + ByPass = 0; + vsubs = 0.0 ; /* substrate bias */ + deltemp = 0.0 ; + noncon_old = ckt->CKTnoncon; + flg_nqs = model->HSMHV_conqs ; + flg_subNode = here->HSMHVsubNode ; /* if flg_subNode > 0, external(/internal) substrate node exists */ + flg_tempNode = here->HSMHVtempNode ; /* if flg_tempNode > 0, external/internal temperature node exists */ + +#ifdef DEBUG_HISIMHVLD_VX + printf("mode = %x\n", ckt->CKTmode); + printf("Vd Vg Vs Vb %e %e %e %e\n", *(ckt->CKTrhsOld+here->HSMHVdNodePrime), + *(ckt->CKTrhsOld+here->HSMHVgNodePrime), + *(ckt->CKTrhsOld+here->HSMHVsNodePrime), + *(ckt->CKTrhsOld+here->HSMHVbNodePrime)); +#endif + + if ( ckt->CKTmode & MODEINITSMSIG ) { + vbs = *(ckt->CKTstate0 + here->HSMHVvbs); + vgs = *(ckt->CKTstate0 + here->HSMHVvgs); + vds = *(ckt->CKTstate0 + here->HSMHVvds); + + vges = *(ckt->CKTstate0 + here->HSMHVvges); + vdbd = *(ckt->CKTstate0 + here->HSMHVvdbd); + vsbs = *(ckt->CKTstate0 + here->HSMHVvsbs); + if (flg_subNode > 0) vsubs = *(ckt->CKTstate0 + here->HSMHVvsubs); + if( flg_tempNode > 0 ){ + deltemp = *(ckt->CKTstate0 + here->HSMHVdeltemp); + } + vdse = *(ckt->CKTstate0 + here->HSMHVvdse) ; + vgse = *(ckt->CKTstate0 + here->HSMHVvgse) ; + vbse = *(ckt->CKTstate0 + here->HSMHVvbse) ; + if ( flg_nqs ) { + Qi_nqs = *(ckt->CKTstate0 + here->HSMHVqi_nqs) ; + Qb_nqs = *(ckt->CKTstate0 + here->HSMHVqb_nqs) ; + } else { + Qi_nqs = 0.0 ; + Qb_nqs = 0.0 ; + } +/* printf("HSMHV_load: (from state0) vds.. = %e %e %e %e %e %e\n", + vds,vgs,vbs,vdse,vgse,vbse); */ + } + else if ( ckt->CKTmode & MODEINITTRAN ) { +/* #include "printf_ld_converged.inc" */ + vbs = *(ckt->CKTstate1 + here->HSMHVvbs); + vgs = *(ckt->CKTstate1 + here->HSMHVvgs); + vds = *(ckt->CKTstate1 + here->HSMHVvds); + + vges = *(ckt->CKTstate1 + here->HSMHVvges); + vdbd = *(ckt->CKTstate1 + here->HSMHVvdbd); + vsbs = *(ckt->CKTstate1 + here->HSMHVvsbs); + if (flg_subNode > 0) vsubs = *(ckt->CKTstate1 + here->HSMHVvsubs); + if( flg_tempNode > 0 ){ + deltemp = *(ckt->CKTstate1 + here->HSMHVdeltemp); + } + vdse = *(ckt->CKTstate1 + here->HSMHVvdse) ; + vgse = *(ckt->CKTstate1 + here->HSMHVvgse) ; + vbse = *(ckt->CKTstate1 + here->HSMHVvbse) ; + if ( flg_nqs ) { + Qi_nqs = *(ckt->CKTstate1 + here->HSMHVqi_nqs) ; + Qb_nqs = *(ckt->CKTstate1 + here->HSMHVqb_nqs) ; + } else { + Qi_nqs = 0.0 ; + Qb_nqs = 0.0 ; + } + } + else if ( (ckt->CKTmode & MODEINITJCT) && !here->HSMHV_off ) { + vds = model->HSMHV_type * here->HSMHV_icVDS; + vgs = vges = model->HSMHV_type * here->HSMHV_icVGS; + vbs = vsbs = model->HSMHV_type * here->HSMHV_icVBS; + vdbd = 0.0 ; + if ( (vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) && + ( (ckt->CKTmode & (MODETRAN|MODEAC|MODEDCOP|MODEDCTRANCURVE)) || + !(ckt->CKTmode & MODEUIC) ) ) { + /* set biases for starting analysis */ + vbs = vdbd = vsbs = 0.0; + vgs = vges = 0.1; + vds = 0.1; + } + if (flg_subNode > 0) vsubs = 0.0; + if( flg_tempNode > 0 ) deltemp=0.0; + vdse = vds ; + vgse = vgs ; + Qi_nqs = Qb_nqs = 0.0 ; + } + else if ( ( ckt->CKTmode & (MODEINITJCT | MODEINITFIX) ) && + here->HSMHV_off ) { + vbs = vgs = vds = 0.0; vges = 0.0; vdbd = vsbs = 0.0; + if (flg_subNode > 0) vsubs = 0.0; + if( flg_tempNode > 0 ) deltemp=0.0; + vdse = vds ; + vgse = vgs ; + Qi_nqs = Qb_nqs = 0.0 ; + } + else { +#ifndef PREDICTOR /* BSIM3 style */ + if (ckt->CKTmode & MODEINITPRED) { +/* #include "printf_ld_converged.inc" */ + /* if (here->HSMHV_mode > 0) { + gds_ext = here->HSMHV_dIds_dVdse ; + } else { + gds_ext = + (here->HSMHV_dIds_dVdse + here->HSMHV_dIds_dVgse + here->HSMHV_dIds_dVbse) ; + } + printf("zzz %e %e\n",ckt->CKTtime,gds_ext) ; */ + xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1]; + *(ckt->CKTstate0 + here->HSMHVvbs) = + *(ckt->CKTstate1 + here->HSMHVvbs); + vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvbs)) + -(xfact * (*(ckt->CKTstate2 + here->HSMHVvbs))); + *(ckt->CKTstate0 + here->HSMHVvgs) = + *(ckt->CKTstate1 + here->HSMHVvgs); + vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvgs)) + -(xfact * (*(ckt->CKTstate2 + here->HSMHVvgs))); + *(ckt->CKTstate0 + here->HSMHVvds) = + *(ckt->CKTstate1 + here->HSMHVvds); + vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvds)) + -(xfact * (*(ckt->CKTstate2 + here->HSMHVvds))); + *(ckt->CKTstate0 + here->HSMHVvbd) = + *(ckt->CKTstate0 + here->HSMHVvbs)- + *(ckt->CKTstate0 + here->HSMHVvds); + + *(ckt->CKTstate0 + here->HSMHVvges) = + *(ckt->CKTstate1 + here->HSMHVvges); + vges = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvges)) + -(xfact * (*(ckt->CKTstate2 + here->HSMHVvges))); + *(ckt->CKTstate0 + here->HSMHVvdbd) = + *(ckt->CKTstate1 + here->HSMHVvdbd); + vdbd = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvdbd)) + - (xfact * (*(ckt->CKTstate2 + here->HSMHVvdbd))); + *(ckt->CKTstate0 + here->HSMHVvdbs) = + *(ckt->CKTstate0 + here->HSMHVvdbd) + + *(ckt->CKTstate0 + here->HSMHVvds); + *(ckt->CKTstate0 + here->HSMHVvsbs) = + *(ckt->CKTstate1 + here->HSMHVvsbs); + vsbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvsbs)) + - (xfact * (*(ckt->CKTstate2 + here->HSMHVvsbs))); + if (flg_subNode > 0){ + vsubs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvsubs)) + - ( xfact * (*(ckt->CKTstate2 + here->HSMHVvsubs))); + } + if( flg_tempNode > 0 ){ + deltemp = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVdeltemp)) + - ( xfact * (*(ckt->CKTstate2 + here->HSMHVdeltemp))); + + *(ckt->CKTstate0 + here->HSMHVdeltemp) = + *(ckt->CKTstate1 + here->HSMHVdeltemp); + } + *(ckt->CKTstate0 + here->HSMHVvdse) = + *(ckt->CKTstate1 + here->HSMHVvdse); + vdse = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvdse)) + -(xfact * (*(ckt->CKTstate2 + here->HSMHVvdse))); + *(ckt->CKTstate0 + here->HSMHVvgse) = + *(ckt->CKTstate1 + here->HSMHVvgse); + vgse = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvgse)) + -(xfact * (*(ckt->CKTstate2 + here->HSMHVvgse))); + *(ckt->CKTstate0 + here->HSMHVvbse) = + *(ckt->CKTstate1 + here->HSMHVvbse); + vbse = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvbse)) + -(xfact * (*(ckt->CKTstate2 + here->HSMHVvbse))); + if (flg_nqs) { + *(ckt->CKTstate0 + here->HSMHVqi_nqs) = + *(ckt->CKTstate1 + here->HSMHVqi_nqs); + Qi_nqs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVqi_nqs)) + -(xfact * (*(ckt->CKTstate2 + here->HSMHVqi_nqs))); + *(ckt->CKTstate0 + here->HSMHVqb_nqs) = + *(ckt->CKTstate1 + here->HSMHVqb_nqs); + Qb_nqs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVqb_nqs)) + -(xfact * (*(ckt->CKTstate2 + here->HSMHVqb_nqs))); + } else { + Qi_nqs = Qb_nqs = 0.0 ; + } + } + else { +#endif /* PREDICTOR */ +/* here->HSMHV_time = ckt->CKTtime; /\* for debug print *\/ */ + /* get biases from CKT */ + vbs = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - + *(ckt->CKTrhsOld+here->HSMHVsNodePrime)); + vgs = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVgNodePrime) - + *(ckt->CKTrhsOld+here->HSMHVsNodePrime)); + vds = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVdNodePrime) - + *(ckt->CKTrhsOld+here->HSMHVsNodePrime)); + + vges = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVgNode) - + *(ckt->CKTrhsOld+here->HSMHVsNodePrime)); + 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 (flg_subNode > 0){ + vsubs = model->HSMHV_type + * (*(ckt->CKTrhsOld + here->HSMHVsubNode) + - *(ckt->CKTrhsOld + here->HSMHVsNode)); + } + if( flg_tempNode > 0 ){ + deltemp = *(ckt->CKTrhsOld + here->HSMHVtempNode); + } + vbse = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - + *(ckt->CKTrhsOld+here->HSMHVsNode)); + vgse = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVgNodePrime) - + *(ckt->CKTrhsOld+here->HSMHVsNode)); + vdse = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVdNode) - + *(ckt->CKTrhsOld+here->HSMHVsNode)); + if ( flg_nqs ) { + Qi_nqs = *(ckt->CKTrhsOld + here->HSMHVqiNode); + Qb_nqs = *(ckt->CKTrhsOld + here->HSMHVqbNode); + } else { + Qi_nqs = Qb_nqs = 0.0 ; + } +#ifndef PREDICTOR + } +#endif /* PREDICTOR */ + +/* printf("HSMHV_load: (from rhs ) vds.. = %e %e %e %e %e %e\n", + vds,vgs,vbs,vdse,vgse,vbse); */ + + vbd = vbs - vds; + vgd = vgs - vds; + vged = vges - vds; + vdbs = vdbd + vdse; + vgdo = *(ckt->CKTstate0 + here->HSMHVvgs) - *(ckt->CKTstate0 + here->HSMHVvds); + vgedo = *(ckt->CKTstate0 + here->HSMHVvges) - *(ckt->CKTstate0 + here->HSMHVvds); + + vds_pre = vds; + +#ifndef NOBYPASS + /* start of bypass section + ... no bypass in case of selfheating */ + if ( !(ckt->CKTmode & MODEINITPRED) && ckt->CKTbypass && !model->HSMHV_coselfheat) { + 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 (flg_subNode > 0) delvsubs = vsubs - *(ckt->CKTstate0 + here->HSMHVvsubs) ; /* substrate bias change */ + deldeltemp = deltemp - *(ckt->CKTstate0 + here->HSMHVdeltemp) ; + if (flg_nqs) { + delQi_nqs = Qi_nqs - *(ckt->CKTstate0 + here->HSMHVqi_nqs) ; + delQb_nqs = Qb_nqs - *(ckt->CKTstate0 + here->HSMHVqb_nqs) ; + } else { + delQi_nqs = delQb_nqs = 0.0 ; + } + + /* now let's see if we can bypass */ + /* ... first perform the easy cheap bypass checks ... */ + /* 1 2 3 3 3 4 4 4 5 543 2 1 */ + if ( ( fabs(delvds ) < ckt->CKTreltol * MAX(fabs(vds ),fabs(*(ckt->CKTstate0 + here->HSMHVvds ))) + ckt->CKTvoltTol ) && + ( fabs(delvgs ) < ckt->CKTreltol * MAX(fabs(vgs ),fabs(*(ckt->CKTstate0 + here->HSMHVvgs ))) + ckt->CKTvoltTol ) && + ( fabs(delvbs ) < ckt->CKTreltol * MAX(fabs(vbs ),fabs(*(ckt->CKTstate0 + here->HSMHVvbs ))) + ckt->CKTvoltTol ) && + ( fabs(delvdse) < ckt->CKTreltol * MAX(fabs(vdse),fabs(*(ckt->CKTstate0 + here->HSMHVvdse))) + ckt->CKTvoltTol ) && + ( fabs(delvgse) < ckt->CKTreltol * MAX(fabs(vgse),fabs(*(ckt->CKTstate0 + here->HSMHVvgse))) + ckt->CKTvoltTol ) && + ( fabs(delvbse) < ckt->CKTreltol * MAX(fabs(vbse),fabs(*(ckt->CKTstate0 + here->HSMHVvbse))) + ckt->CKTvoltTol ) && + ( fabs(delvdbd) < ckt->CKTreltol * MAX(fabs(vdbd),fabs(*(ckt->CKTstate0 + here->HSMHVvdbd))) + ckt->CKTvoltTol ) && + ( fabs(delvsbs) < ckt->CKTreltol * MAX(fabs(vsbs),fabs(*(ckt->CKTstate0 + here->HSMHVvsbs))) + ckt->CKTvoltTol ) && + ( fabs(delvsubs) < ckt->CKTreltol * MAX(fabs(vsubs),fabs(*(ckt->CKTstate0 + here->HSMHVvsubs))) + ckt->CKTvoltTol ) && + ( fabs(delQi_nqs) < ckt->CKTreltol * fabs(Qi_nqs) + ckt->CKTchgtol*ckt->CKTabstol + 1.0e-20 ) && + ( fabs(delQb_nqs) < ckt->CKTreltol * fabs(Qb_nqs) + ckt->CKTchgtol*ckt->CKTabstol + 1.0e-20 ) ) + /* 1.0e-20: heuristic value, must be small enough */ + /* to ensure that bypass does not destroy convergence */ + { /* ... the first bypass checks are passed -> now do the more expensive checks ...*/ + 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 = (flg_tempNode > 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 = (flg_tempNode > 0) ? here->HSMHV_dIsub_dTi : 0.0 ; + dIsub_dVdse = here->HSMHV_dIsub_dVdse ; + Isubs = 0.0 ; + dIsubs_dVds = 0.0 ; + dIsubs_dVgs = 0.0 ; + dIsubs_dVbs = 0.0 ; + dIsubs_dT = 0.0 ; + dIsubs_dVdse = 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 = (flg_tempNode > 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 = (flg_tempNode > 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 = (flg_tempNode > 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 = (flg_tempNode > 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 = (flg_tempNode > 0) ? here->HSMHV_dIgb_dTi : 0.0 ; + Ibd = here->HSMHV_ibd ; + Gbd = here->HSMHV_gbd ; + Gbdt = (flg_tempNode > 0) ? here->HSMHV_gbdT : 0.0 ; + Ibs = here->HSMHV_ibs ; + Gbs = here->HSMHV_gbs ; + Gbst = (flg_tempNode > 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 = (flg_tempNode > 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 ; + dIsub_dVdse = 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 = (flg_tempNode > 0) ? here->HSMHV_dIsub_dTi : 0.0 ; + dIsubs_dVdse = - here->HSMHV_dIsub_dVdse ; /* = - (dIsub_dVdse + dIsub_dVbse + dIsub_dVgse) */ + 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 = (flg_tempNode > 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 = (flg_tempNode > 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 = (flg_tempNode > 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 = (flg_tempNode > 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 = (flg_tempNode > 0) ? here->HSMHV_dIgb_dTi : 0.0 ; + Ibd = here->HSMHV_ibd ; + Gbd = here->HSMHV_gbd ; + Gbdt = (flg_tempNode > 0) ? here->HSMHV_gbdT : 0.0 ; + Ibs = here->HSMHV_ibs ; + Gbs = here->HSMHV_gbs ; + Gbst = (flg_tempNode > 0) ? here->HSMHV_gbsT : 0.0 ; + } /* end of reverse mode */ + + /* for bypass 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 + + dIsub_dVdse*delvdse + + 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 + + dIsubs_dVdse*delvdse + + 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 ; + + /* ... second part of bypass checks: */ + /* 1 2 3 3 3 4 4 4 43 2 1 */ + if ( ( fabs(i_dP_hat - i_dP) < ckt->CKTreltol * MAX(fabs(i_dP_hat),fabs(i_dP)) + ckt->CKTabstol ) && + ( fabs(i_gP_hat - i_gP) < ckt->CKTreltol * MAX(fabs(i_gP_hat),fabs(i_gP)) + ckt->CKTabstol ) && + ( fabs(i_sP_hat - i_sP) < ckt->CKTreltol * MAX(fabs(i_sP_hat),fabs(i_sP)) + ckt->CKTabstol ) && + ( fabs(i_db_hat - i_db) < ckt->CKTreltol * MAX(fabs(i_db_hat),fabs(i_db)) + ckt->CKTabstol ) && + ( fabs(i_sb_hat - i_sb) < ckt->CKTreltol * MAX(fabs(i_sb_hat),fabs(i_sb)) + ckt->CKTabstol ) ) + { + /* bypass code */ + vds = *(ckt->CKTstate0 + here->HSMHVvds ); + vgs = *(ckt->CKTstate0 + here->HSMHVvgs ); + vbs = *(ckt->CKTstate0 + here->HSMHVvbs ); + vdse = *(ckt->CKTstate0 + here->HSMHVvdse); + vgse = *(ckt->CKTstate0 + here->HSMHVvgse); + vbse = *(ckt->CKTstate0 + here->HSMHVvbse); + vdbd = *(ckt->CKTstate0 + here->HSMHVvdbd); + vsbs = *(ckt->CKTstate0 + here->HSMHVvsbs); + vsubs = *(ckt->CKTstate0 + here->HSMHVvsubs); + deltemp = *(ckt->CKTstate0 + here->HSMHVdeltemp); + if ( flg_nqs ) { + Qi_nqs = *(ckt->CKTstate0 + here->HSMHVqi_nqs); + Qb_nqs = *(ckt->CKTstate0 + here->HSMHVqb_nqs); + } + + vges = *(ckt->CKTstate0 + here->HSMHVvges); + + vbd = vbs - vds; + vgd = vgs - vds; + vgb = vgs - vbs; + vged = vges - vds; + + vbs_jct = vsbs; + vbd_jct = vdbd; + + /* linear branch currents */ + vddp = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVdNode) - *(ckt->CKTrhsOld+here->HSMHVdNodePrime)); + vggp = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVgNode) - *(ckt->CKTrhsOld+here->HSMHVgNodePrime)); + vssp = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVsNode) - *(ckt->CKTrhsOld+here->HSMHVsNodePrime)); + vbpb = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - *(ckt->CKTrhsOld+here->HSMHVbNode)); + vbpdb = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - *(ckt->CKTrhsOld+here->HSMHVdbNode)); + vbpsb = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - *(ckt->CKTrhsOld+here->HSMHVsbNode)); + + ByPass = 1; + goto line755; + } + } + } /* end of Bypass section */ +#endif /*NOBYPASS*/ + +#ifdef DEBUG_HISIMHVLD_VX + printf( "vbd_p = %12.5e\n" , vbd ); + printf( "vbs_p = %12.5e\n" , vbs ); + printf( "vgs_p = %12.5e\n" , vgs ); + printf( "vds_p = %12.5e\n" , vds ); +#endif + + /* start limiting of nonlinear branch voltages */ + + von = here->HSMHV_von; + Check3 = 0 ; + if(*(ckt->CKTstate0 + here->HSMHVvds) >= 0.0) { /* case vds>=0 for limiting */ + limval = DEVfetlim(vgs, *(ckt->CKTstate0 + here->HSMHVvgs), von); + if (vgs != limval) { + vgs = limval ; + Check3 = 1 ; + } + if (Check3) vds = vgs - vgd; + limval = DEVlimvds(vds, *(ckt->CKTstate0 + here->HSMHVvds)); + if (vds != limval) { + vds = limval ; + Check3 = 2 ; + } + vgd = vgs - vds; + + if (here->HSMHV_corg == 1) { + limval = DEVfetlim(vges, *(ckt->CKTstate0 + here->HSMHVvges), von); + if (vges != limval) { + vges = limval ; + Check3 = 3 ; + } + vged = vges - vds; + } + + } else { /* case vds < 0 for limiting */ + limval = DEVfetlim(vgd, vgdo, von); + if (vgd != limval) { + vgd = limval ; + Check3 = 4 ; + } + if (Check3) vds = vgs - vgd; + limval = -DEVlimvds(-vds, -(*(ckt->CKTstate0 + here->HSMHVvds))); + if (vds != limval) { + vds = limval ; + Check3 = 5 ; + } + vgs = vgd + vds; + + if (here->HSMHV_corg == 1) { + limval = DEVfetlim(vged, vgedo, von); + if (vged != limval) { + vged = limval ; + Check3 = 6 ; + } + vges = vged + vds; + } + } /* end of case vds< 0 for limiting */ + + if (vds >= 0.0) { /* case vds >=0 for limiting of junctions */ + vbs = DEVpnjlim(vbs, *(ckt->CKTstate0 + here->HSMHVvbs), + CONSTvt0, model->HSMHV_vcrit, &Check1); + if (Check1) Check3 = 7 ; + vbd = vbs - vds; + if (here->HSMHV_corbnet) { + vsbs = DEVpnjlim(vsbs, *(ckt->CKTstate0 + here->HSMHVvsbs), + CONSTvt0, model->HSMHV_vcrit, &Check2); + if (Check2) Check3 = 8 ; + } + } + else { /* case vds < 0 for limiting of junctions */ + vbd = DEVpnjlim(vbd, *(ckt->CKTstate0 + here->HSMHVvbd), + CONSTvt0, model->HSMHV_vcrit, &Check1); + if (Check1) Check3 = 9 ; + vbs = vbd + vds; + if (here->HSMHV_corbnet) { + vdbd = DEVpnjlim(vdbd, *(ckt->CKTstate0 + here->HSMHVvdbd), + CONSTvt0, model->HSMHV_vcrit, &Check2); + if (Check2) { + Check3 = 10 ; + vdbs = vdbd + vdse; + } + } + } + + if( flg_tempNode > 0 ){ + /* Logarithmic damping of deltemp beyond LIM_TOL */ + deltemp_old = *(ckt->CKTstate0 + here->HSMHVdeltemp); + if (deltemp > deltemp_old + LIM_TOL) + {deltemp = deltemp_old + LIM_TOL + log10((deltemp-deltemp_old)/LIM_TOL); + Check3 = 11;} + else if (deltemp < deltemp_old - LIM_TOL) + {deltemp = deltemp_old - LIM_TOL - log10((deltemp_old-deltemp)/LIM_TOL); + Check3 = 12;} + } + + /* if (Check3) printf("HSMHV_load: Check3=%d\n",Check3) ; */ + + /* limiting completed */ + if (Check3 == 0 ) Check = 0 ; + } /* loading and limiting of nonlinear branch voltages is completed */ + + + vbd = vbs - vds; + vgd = vgs - vds; + vgb = vgs - vbs; + vged = vges - vds; + + vbs_jct = vsbs; + vbd_jct = vdbd; + + /* linear branch voltages */ + vddp = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVdNode) - + *(ckt->CKTrhsOld+here->HSMHVdNodePrime)); + + vggp = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVgNode) - + *(ckt->CKTrhsOld+here->HSMHVgNodePrime)); + + vssp = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVsNode) - + *(ckt->CKTrhsOld+here->HSMHVsNodePrime)); + + vbpdb = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - + *(ckt->CKTrhsOld+here->HSMHVdbNode)); + + vbpb = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - + *(ckt->CKTrhsOld+here->HSMHVbNode)); + + + vbpsb = model->HSMHV_type * + (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - + *(ckt->CKTrhsOld+here->HSMHVsbNode)); + + +#ifdef DEBUG_HISIMHVLD_VX + printf( "vbd = %12.5e\n" , vbd ); + printf( "vbs = %12.5e\n" , vbs ); + printf( "vgs = %12.5e\n" , vgs ); + printf( "vds = %12.5e\n" , vds ); +#endif + + /* After loading (and limiting of branch voltages: Start model evaluation */ + + /* printf("HSMHV_load: vds=%e vgs=%e vbs=%e vsd=%e vgd=%e vbd=%e\n", + vds,vgs,vbs,-vds,vgs-vds,vbs-vds); */ + + if (vds >= 0) { /* normal mode */ + here->HSMHV_mode = 1; + ivds = vds; + ivgs = vgs; + ivbs = vbs; + ivdse = vdse; + ivgse = vgse; + ivbse = vbse; + } else { /* reverse mode */ + here->HSMHV_mode = -1; + ivds = -vds; + ivgs = vgd; + ivbs = vbd; + ivdse = -vdse; + ivgse = vgse - vdse; + ivbse = vbse - vdse; + } + + if ( model->HSMHV_info >= 5 ) { /* mode, bias conditions ... */ + printf( "--- variables given to HSMHVevaluate() ----\n" ); + printf( "type = %s\n" , (model->HSMHV_type>0) ? "NMOS" : "PMOS" ); + printf( "mode = %s\n" , (here->HSMHV_mode>0) ? "NORMAL" : "REVERSE" ); + + printf( "vbse vbs = %12.5e %12.5e\n" , vbse, ivbs ); + printf( "vdse vds = %12.5e %12.5e\n" , vdse, ivds ); + printf( "vgse vgs = %12.5e %12.5e\n" , vgse, ivgs ); + } + if ( model->HSMHV_info >= 6 ) { /* input flags */ + printf( "corsrd = %s\n" , (model->HSMHV_corsrd) ? "true" : "false" ) ; + printf( "coadov = %s\n" , (model->HSMHV_coadov) ? "true" : "false" ) ; + printf( "coisub = %s\n" , (model->HSMHV_coisub) ? "true" : "false" ) ; + printf( "coiigs = %s\n" , (model->HSMHV_coiigs) ? "true" : "false" ) ; + printf( "cogidl = %s\n" , (model->HSMHV_cogidl) ? "true" : "false" ) ; + printf( "coovlp = %s\n" , (model->HSMHV_coovlp) ? "true" : "false" ) ; + printf( "coovlps = %s\n" , (model->HSMHV_coovlps) ? "true" : "false" ) ; + printf( "coflick = %s\n", (model->HSMHV_coflick) ? "true" : "false" ) ; + printf( "coisti = %s\n" , (model->HSMHV_coisti) ? "true" : "false" ) ; + printf( "conqs = %s\n" , (model->HSMHV_conqs) ? "true" : "false" ) ; + printf( "cothrml = %s\n", (model->HSMHV_cothrml) ? "true" : "false" ) ; + printf( "coign = %s\n" , (model->HSMHV_coign) ? "true" : "false" ) ; + printf( "cosym = %s\n" , (model->HSMHV_cosym) ? "true" : "false" ) ; + printf( "coselfheat = %s\n" , (model->HSMHV_coselfheat) ? "true" : "false" ) ; + } + /* print inputs ------------AA */ + + #ifdef DEBUG_HISIMHVCGG + /* Print convergence flag */ + printf("isConv %d ", isConv ); + printf("CKTtime %e ", ckt->CKTtime ); + printf("Vb %1.3e ", (model->HSMHV_type>0) ? vbs:-vbs ); + printf("Vd %1.3e ", (model->HSMHV_type>0) ? vds:-vds ); + printf("Vg %1.3e ", (model->HSMHV_type>0) ? vgs:-vgs ); + #endif + + /* call model evaluation */ + if ( HSMHVevaluate(ivdse,ivgse,ivbse,ivds, ivgs, ivbs, vbs_jct, vbd_jct, vsubs, deltemp, here, model, ckt) == HiSIM_ERROR ) + return (HiSIM_ERROR); + + +#ifdef DEBUG_HISIMHVCGG + printf("HSMHV_ids %e ", here->HSMHV_ids ) ; + printf("HSMHV_cggb %e ", here->HSMHV_cggb ) ; + printf("\n") ; +#endif + + here->HSMHV_called += 1; + +line755: /* standard entry if HSMHVevaluate is bypassed */ + /* (could be shifted a bit forward ...) */ + if ( here->HSMHV_mode > 0 ) { /* forward mode */ + Rd = here->HSMHV_Rd ; + dRd_dVdse = here->HSMHV_dRd_dVdse ; + dRd_dVgse = here->HSMHV_dRd_dVgse ; + dRd_dVbse = here->HSMHV_dRd_dVbse ; + dRd_dVsubs = (flg_subNode > 0) ? here->HSMHV_dRd_dVsubs : 0.0 ; /* derivative w.r.t. Vsubs */ + dRd_dT = (flg_tempNode > 0) ? here->HSMHV_dRd_dTi : 0.0 ; + Rs = here->HSMHV_Rs ; + dRs_dVdse = here->HSMHV_dRs_dVdse ; + dRs_dVgse = here->HSMHV_dRs_dVgse ; + dRs_dVbse = here->HSMHV_dRs_dVbse ; + dRs_dVsubs = (flg_subNode > 0) ? here->HSMHV_dRs_dVsubs : 0.0 ; /* derivative w.r.t. Vsubs */ + dRs_dT = (flg_tempNode > 0) ? here->HSMHV_dRs_dTi : 0.0 ; + Ids = here->HSMHV_ids ; + gds = here->HSMHV_dIds_dVdsi ; + gm = here->HSMHV_dIds_dVgsi ; + gmbs = here->HSMHV_dIds_dVbsi ; + gmT = (flg_tempNode > 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 ; + + Qd = here->HSMHV_qd ; + dQd_dVds = here->HSMHV_dQdi_dVdsi ; + dQd_dVgs = here->HSMHV_dQdi_dVgsi ; + dQd_dVbs = here->HSMHV_dQdi_dVbsi ; + dQd_dT = (flg_tempNode > 0) ? here->HSMHV_dQdi_dTi : 0.0 ; + Qg = here->HSMHV_qg ; + dQg_dVds = here->HSMHV_dQg_dVdsi ; + dQg_dVgs = here->HSMHV_dQg_dVgsi ; + dQg_dVbs = here->HSMHV_dQg_dVbsi ; + dQg_dT = (flg_tempNode > 0) ? here->HSMHV_dQg_dTi : 0.0 ; + Qs = here->HSMHV_qs ; + dQs_dVds = here->HSMHV_dQsi_dVdsi ; + dQs_dVgs = here->HSMHV_dQsi_dVgsi ; + dQs_dVbs = here->HSMHV_dQsi_dVbsi ; + dQs_dT = (flg_tempNode > 0) ? here->HSMHV_dQsi_dTi : 0.0 ; + Qb = - (here->HSMHV_qg + here->HSMHV_qd + here->HSMHV_qs) ; + dQb_dVds = here->HSMHV_dQb_dVdsi ; + dQb_dVgs = here->HSMHV_dQb_dVgsi ; + dQb_dVbs = here->HSMHV_dQb_dVbsi ; + dQb_dT = (flg_tempNode > 0) ? here->HSMHV_dQb_dTi : 0.0 ; + Qfd = here->HSMHV_qdp ; + dQfd_dVdse = here->HSMHV_dqdp_dVdse ; + dQfd_dVgse = here->HSMHV_dqdp_dVgse ; + dQfd_dVbse = here->HSMHV_dqdp_dVbse ; + dQfd_dT = (flg_tempNode > 0) ? here->HSMHV_dqdp_dTi : 0.0 ; + Qfs = here->HSMHV_qsp ; + dQfs_dVdse = here->HSMHV_dqsp_dVdse ; + dQfs_dVgse = here->HSMHV_dqsp_dVgse ; + dQfs_dVbse = here->HSMHV_dqsp_dVbse ; + dQfs_dT = (flg_tempNode > 0) ? here->HSMHV_dqsp_dTi : 0.0 ; + Isub = here->HSMHV_isub ; + dIsub_dVds = here->HSMHV_dIsub_dVdsi ; + dIsub_dVgs = here->HSMHV_dIsub_dVgsi ; + dIsub_dVbs = here->HSMHV_dIsub_dVbsi ; + dIsub_dT = (flg_tempNode > 0) ? here->HSMHV_dIsub_dTi : 0.0 ; + dIsub_dVdse = here->HSMHV_dIsub_dVdse ; + Isubs = 0.0 ; + dIsubs_dVds = 0.0 ; + dIsubs_dVgs = 0.0 ; + dIsubs_dVbs = 0.0 ; + dIsubs_dT = 0.0 ; + dIsubs_dVdse = 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 = (flg_tempNode > 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 = (flg_tempNode > 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 = (flg_tempNode > 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 = (flg_tempNode > 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 = (flg_tempNode > 0) ? here->HSMHV_dIgb_dTi : 0.0 ; + + /*---------------------------------------------------* + * Junction diode. + *-----------------*/ + Ibd = here->HSMHV_ibd ; + Gbd = here->HSMHV_gbd ; + Gbdt = (flg_tempNode > 0) ? here->HSMHV_gbdT : 0.0 ; + + /* Qbd = here->HSMHV_qbd ; */ + Qbd = *(ckt->CKTstate0 + here->HSMHVqbd) ; + Cbd = here->HSMHV_capbd ; + Cbdt = (flg_tempNode > 0) ? here->HSMHV_gcbdT : 0.0 ; + + Ibs = here->HSMHV_ibs ; + Gbs = here->HSMHV_gbs ; + Gbst = (flg_tempNode > 0) ? here->HSMHV_gbsT : 0.0 ; + + /* Qbs = here->HSMHV_qbs ; */ + Qbs = *(ckt->CKTstate0 + here->HSMHVqbs) ; + Cbs = here->HSMHV_capbs ; + Cbst = (flg_tempNode > 0) ? here->HSMHV_gcbsT : 0.0 ; + + if (flg_nqs) { + tau = here->HSMHV_tau ; + dtau_dVds = here->HSMHV_tau_dVdsi ; + dtau_dVgs = here->HSMHV_tau_dVgsi ; + dtau_dVbs = here->HSMHV_tau_dVbsi ; + dtau_dT = here->HSMHV_tau_dTi ; + taub = here->HSMHV_taub ; + dtaub_dVds = here->HSMHV_taub_dVdsi ; + dtaub_dVgs = here->HSMHV_taub_dVgsi ; + dtaub_dVbs = here->HSMHV_taub_dVbsi ; + dtaub_dT = here->HSMHV_taub_dTi ; + Qdrat = here->HSMHV_Xd ; + dQdrat_dVds = here->HSMHV_Xd_dVdsi ; + dQdrat_dVgs = here->HSMHV_Xd_dVgsi ; + dQdrat_dVbs = here->HSMHV_Xd_dVbsi ; + dQdrat_dT = here->HSMHV_Xd_dTi ; + Qi = here->HSMHV_Qi ; + dQi_dVds = here->HSMHV_Qi_dVdsi ; + dQi_dVgs = here->HSMHV_Qi_dVgsi ; + dQi_dVbs = here->HSMHV_Qi_dVbsi ; + dQi_dT = here->HSMHV_Qi_dTi ; + Qbulk = here->HSMHV_Qbulk ; + dQbulk_dVds = here->HSMHV_Qbulk_dVdsi ; + dQbulk_dVgs = here->HSMHV_Qbulk_dVgsi ; + dQbulk_dVbs = here->HSMHV_Qbulk_dVbsi ; + dQbulk_dT = here->HSMHV_Qbulk_dTi ; + } + + } else { /* reverse mode */ + /* note: here->HSMHV_Rd and here->HSMHV_Rs are already subjected to mode handling, + while the following derivatives here->HSMHV_Rd_dVdse, ... are not! */ + Rd = here->HSMHV_Rd ; + dRd_dVdse = here->HSMHV_dRd_dVdse ; + dRd_dVgse = here->HSMHV_dRd_dVgse ; + dRd_dVbse = here->HSMHV_dRd_dVbse ; + dRd_dVsubs= (flg_subNode > 0) ? here->HSMHV_dRd_dVsubs : 0.0 ; /* derivative w.r.t. Vsubs */ + dRd_dT = (flg_tempNode > 0) ? here->HSMHV_dRd_dTi : 0.0 ; + Rs = here->HSMHV_Rs ; + dRs_dVdse = here->HSMHV_dRs_dVdse ; + dRs_dVgse = here->HSMHV_dRs_dVgse ; + dRs_dVbse = here->HSMHV_dRs_dVbse ; + dRs_dVsubs= (flg_subNode > 0) ? here->HSMHV_dRs_dVsubs : 0.0 ; /* derivative w.r.t. Vsubs */ + dRs_dT = (flg_tempNode > 0) ? here->HSMHV_dRs_dTi : 0.0 ; + 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 = (flg_tempNode > 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; + + Qd = here->HSMHV_qs ; + dQd_dVds = - (here->HSMHV_dQsi_dVdsi + here->HSMHV_dQsi_dVgsi + here->HSMHV_dQsi_dVbsi) ; + dQd_dVgs = here->HSMHV_dQsi_dVgsi ; + dQd_dVbs = here->HSMHV_dQsi_dVbsi ; + dQd_dT = (flg_tempNode > 0) ? here->HSMHV_dQsi_dTi : 0.0 ; + Qg = here->HSMHV_qg ; + dQg_dVds = - (here->HSMHV_dQg_dVdsi + here->HSMHV_dQg_dVgsi + here->HSMHV_dQg_dVbsi) ; + dQg_dVgs = here->HSMHV_dQg_dVgsi ; + dQg_dVbs = here->HSMHV_dQg_dVbsi ; + dQg_dT = (flg_tempNode > 0) ? here->HSMHV_dQg_dTi : 0.0 ; + Qs = here->HSMHV_qd ; + dQs_dVds = - (here->HSMHV_dQdi_dVdsi + here->HSMHV_dQdi_dVgsi + here->HSMHV_dQdi_dVbsi) ; + dQs_dVgs = here->HSMHV_dQdi_dVgsi ; + dQs_dVbs = here->HSMHV_dQdi_dVbsi ; + dQs_dT = (flg_tempNode > 0) ? here->HSMHV_dQdi_dTi : 0.0 ; + Qb = - (here->HSMHV_qg + here->HSMHV_qd + here->HSMHV_qs) ; + dQb_dVds = - (here->HSMHV_dQb_dVdsi + here->HSMHV_dQb_dVgsi + here->HSMHV_dQb_dVbsi) ; + dQb_dVgs = here->HSMHV_dQb_dVgsi ; + dQb_dVbs = here->HSMHV_dQb_dVbsi ; + dQb_dT = (flg_tempNode > 0) ? here->HSMHV_dQb_dTi : 0.0 ; + Qfd = here->HSMHV_qsp ; + dQfd_dVdse = - (here->HSMHV_dqsp_dVdse + here->HSMHV_dqsp_dVgse + here->HSMHV_dqsp_dVbse) ; + dQfd_dVgse = here->HSMHV_dqsp_dVgse ; + dQfd_dVbse = here->HSMHV_dqsp_dVbse ; + dQfd_dT = (flg_tempNode > 0) ? here->HSMHV_dqsp_dTi : 0.0 ; + Qfs = here->HSMHV_qdp ; + dQfs_dVdse = - (here->HSMHV_dqdp_dVdse + here->HSMHV_dqdp_dVgse + here->HSMHV_dqdp_dVbse) ; + dQfs_dVgse = here->HSMHV_dqdp_dVgse ; + dQfs_dVbse = here->HSMHV_dqdp_dVbse ; + dQfs_dT = (flg_tempNode > 0) ? here->HSMHV_dqdp_dTi : 0.0 ; + Isub = 0.0 ; + dIsub_dVds = 0.0 ; + dIsub_dVgs = 0.0 ; + dIsub_dVbs = 0.0 ; + dIsub_dT = 0.0 ; + dIsub_dVdse = 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 = (flg_tempNode > 0) ? here->HSMHV_dIsub_dTi : 0.0 ; + dIsubs_dVdse = - here->HSMHV_dIsub_dVdse ; /* = - (dIsub_dVdse + dIsub_dVbse + dIsub_dVgse) */ + 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 = (flg_tempNode > 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 = (flg_tempNode > 0) ? here->HSMHV_dIgidl_dTi : 0.0 ; + /* note: here->HSMHV_igd and here->HSMHV_igs are already subjected to mode handling, + while the following derivatives here->HSMHV_dIgd_dVdsi, ... are not! */ + 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 = (flg_tempNode > 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 = (flg_tempNode > 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 = (flg_tempNode > 0) ? here->HSMHV_dIgb_dTi : 0.0 ; + + /*---------------------------------------------------* + * Junction diode. + *-----------------*/ + Ibd = here->HSMHV_ibd ; + Gbd = here->HSMHV_gbd ; + Gbdt = (flg_tempNode > 0) ? here->HSMHV_gbdT : 0.0 ; + + /* Qbd = here->HSMHV_qbd ; */ + Qbd = *(ckt->CKTstate0 + here->HSMHVqbd) ; + Cbd = here->HSMHV_capbd ; + Cbdt = (flg_tempNode > 0) ? here->HSMHV_gcbdT : 0.0 ; + + Ibs = here->HSMHV_ibs ; + Gbs = here->HSMHV_gbs ; + Gbst = (flg_tempNode > 0) ? here->HSMHV_gbsT : 0.0 ; + + /* Qbs = here->HSMHV_qbs ; */ + Qbs = *(ckt->CKTstate0 + here->HSMHVqbs) ; + Cbs = here->HSMHV_capbs ; + Cbst = (flg_tempNode > 0) ? here->HSMHV_gcbsT : 0.0 ; + + if (flg_nqs) { + tau = here->HSMHV_tau ; + dtau_dVds = -(here->HSMHV_tau_dVdsi + here->HSMHV_tau_dVgsi + here->HSMHV_tau_dVbsi) ; + dtau_dVgs = here->HSMHV_tau_dVgsi ; + dtau_dVbs = here->HSMHV_tau_dVbsi ; + dtau_dT = here->HSMHV_tau_dTi ; + taub = here->HSMHV_taub ; + dtaub_dVds = -(here->HSMHV_taub_dVdsi + here->HSMHV_taub_dVgsi + here->HSMHV_taub_dVbsi); + dtaub_dVgs = here->HSMHV_taub_dVgsi ; + dtaub_dVbs = here->HSMHV_taub_dVbsi ; + dtaub_dT = here->HSMHV_taub_dTi ; + 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 ; + dQdrat_dT = - here->HSMHV_Xd_dTi ; + Qi = here->HSMHV_Qi ; + 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 ; + dQi_dT = here->HSMHV_Qi_dTi ; + Qbulk = here->HSMHV_Qbulk ; + 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 ; + dQbulk_dT = here->HSMHV_Qbulk_dTi ; + } + } /* end of reverse mode */ + + if (flg_tempNode > 0) { + if (pParam->HSMHV_rth > C_RTH_MIN) { + Gth = 1.0/pParam->HSMHV_rth ; + } else { + Gth = 1.0/C_RTH_MIN ; + } + Ith = Gth * deltemp ; + dIth_dT = Gth ; + Cth = pParam->HSMHV_cth ; + Qth = Cth * deltemp ; + /* P = Ids * (Vdsi + param * ( Vdse - Vdsi)) */ + /* = Ids * Veffpower */ + if ( vds * (vdse - vds) >= 0.0) { + if ( pParam->HSMHV_powrat == 1.0 ) { + Veffpower = vdse ; + dVeffpower_dVds = 0.0 ; + dVeffpower_dVdse = 1.0 ; + } else { + Veffpower = vds + here->HSMHV_powratio * (vdse - vds) ; + dVeffpower_dVds = (1.0 - here->HSMHV_powratio) ; + dVeffpower_dVdse = here->HSMHV_powratio ; + } + + + + + } else { + Veffpower = vds ; + dVeffpower_dVds = 1.0 ; + dVeffpower_dVdse = 0.0 ; + } + P = Ids * Veffpower ; + dP_dVds = gds * Veffpower + Ids * dVeffpower_dVds; + dP_dVgs = gm * Veffpower ; + dP_dVbs = gmbs * Veffpower ; + dP_dT = gmT * Veffpower ; + dP_dVdse = gds_ext * Veffpower + Ids * dVeffpower_dVdse ; + dP_dVgse = gm_ext * Veffpower ; + dP_dVbse = gmbs_ext * Veffpower ; + + /* Clamping the maximum rise tempaerarure (SHEMAX) */ + T1 = model->HSMHV_shemax * Gth ; + Fn_SU( T2 , P , T1 , SHE_MAX_dlt * Gth , T0 ) ; + P = T2 ; + dP_dVds = T0 * dP_dVds ; + dP_dVgs = T0 * dP_dVgs ; + dP_dVbs = T0 * dP_dVbs ; + dP_dT = T0 * dP_dT ; + dP_dVdse = T0 * dP_dVdse ; + dP_dVgse = T0 * dP_dVgse ; + dP_dVbse = T0 * dP_dVbse ; + + } else { + Gth = 0.0 ; + Ith = 0.0 ; + dIth_dT = 0.0 ; + Cth = 0.0 ; + Qth = 0.0 ; + P = 0.0 ; + dP_dVds = 0.0 ; + dP_dVgs = 0.0 ; + dP_dVbs = 0.0 ; + dP_dT = 0.0 ; + dP_dVdse = 0.0 ; + dP_dVgse = 0.0 ; + dP_dVbse = 0.0 ; + } + + /* in case of nqs: construct static contributions to the nqs equations (Iqi_nqs, Iqb_nqs) */ + /* and nqs charge contributions to inner drain, gate and source node (Qd_nqs, Qg_nqs, Qs_nqs) */ + + if (flg_nqs) { + /* .. tau, taub must be > 0 */ + if (tau < 1.0e-18) { + tau = 1.e-18 ; + dtau_dVds = dtau_dVgs = dtau_dVbs = dtau_dT = 0.0 ; + } + if (taub < 1.0e-18) { + taub = 1.0e-18 ; + dtaub_dVds = dtaub_dVgs = dtaub_dVbs = dtaub_dT = 0.0 ; + } + + Iqi_nqs = (Qi_nqs - Qi) / tau ; + dIqi_nqs_dVds = - (dQi_dVds + Iqi_nqs * dtau_dVds) / tau ; + dIqi_nqs_dVgs = - (dQi_dVgs + Iqi_nqs * dtau_dVgs) / tau ; + dIqi_nqs_dVbs = - (dQi_dVbs + Iqi_nqs * dtau_dVbs) / tau ; + dIqi_nqs_dT = - (dQi_dT + Iqi_nqs * dtau_dT ) / tau ; + dIqi_nqs_dQi_nqs = 1.0 / tau ; + + Iqb_nqs = (Qb_nqs - Qbulk) / taub ; + dIqb_nqs_dVds = - (dQbulk_dVds + Iqb_nqs * dtaub_dVds) / taub ; + dIqb_nqs_dVgs = - (dQbulk_dVgs + Iqb_nqs * dtaub_dVgs) / taub ; + dIqb_nqs_dVbs = - (dQbulk_dVbs + Iqb_nqs * dtaub_dVbs) / taub ; + dIqb_nqs_dT = - (dQbulk_dT + Iqb_nqs * dtaub_dT ) / taub ; + dIqb_nqs_dQb_nqs = 1.0 / taub ; + + 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_dT = Qi_nqs * dQdrat_dT ; + dQd_nqs_dQi_nqs = Qdrat ; + + Qg_nqs = - Qi_nqs - Qb_nqs ; + dQg_nqs_dQi_nqs = - 1.0 ; + dQg_nqs_dQb_nqs = - 1.0 ; + + Qs_nqs = Qi_nqs * (1.0 - Qdrat) ; + dQs_nqs_dVds = - Qi_nqs * dQdrat_dVds ; + dQs_nqs_dVgs = - Qi_nqs * dQdrat_dVgs ; + dQs_nqs_dVbs = - Qi_nqs * dQdrat_dVbs ; + dQs_nqs_dT = - Qi_nqs * dQdrat_dT ; + dQs_nqs_dQi_nqs = 1.0 - Qdrat ; + } else { + Iqi_nqs = Iqb_nqs = Qd_nqs = Qg_nqs = Qs_nqs = 0.0 ; + } + + dIgd_dVs = - (dIgd_dVd + dIgd_dVg + dIgd_dVb) ; + dIgs_dVs = - (dIgs_dVd + dIgs_dVg + dIgs_dVb) ; + dIgb_dVs = - (dIgb_dVd + dIgb_dVg + dIgb_dVb) ; + + /*---------------------------------------------------* + * External Resistances + *-----------------*/ + if(model->HSMHV_corsrd == 1 || model->HSMHV_corsrd == 3 ) { + if(Rd > 0){ + GD = 1.0/Rd; + GD_dVgs = - dRd_dVgse /Rd/Rd; + GD_dVds = - dRd_dVdse /Rd/Rd; + GD_dVbs = - dRd_dVbse /Rd/Rd; + GD_dVsubs = - dRd_dVsubs /Rd/Rd; + GD_dT = - dRd_dT /Rd/Rd; + }else{ + GD=0.0; + GD_dVgs=0.0; + GD_dVds=0.0; + GD_dVbs=0.0; + GD_dVsubs=0.0; + GD_dT =0.0; + } + if(Rs > 0){ + GS = 1.0/Rs; + GS_dVgs = - dRs_dVgse /Rs/Rs; + GS_dVds = - dRs_dVdse /Rs/Rs; + GS_dVbs = - dRs_dVbse /Rs/Rs; + GS_dVsubs = - dRs_dVsubs /Rs/Rs; + GS_dT = - dRs_dT /Rs/Rs; + }else{ + GS=0.0; + GS_dVgs=0.0; + GS_dVds=0.0; + GS_dVbs=0.0; + GS_dVsubs=0.0; + GS_dT =0.0; + } + } + Iddp = GD * vddp; + dIddp_dVddp = GD; + dIddp_dVdse = GD_dVds * vddp; + dIddp_dVgse = GD_dVgs * vddp; + dIddp_dVbse = GD_dVbs * vddp; + dIddp_dVsubs= GD_dVsubs * vddp; + dIddp_dT = GD_dT * vddp; + + Issp = GS * vssp; + dIssp_dVssp = GS; + dIssp_dVdse = GS_dVds * vssp ; + dIssp_dVgse = GS_dVgs * vssp; + dIssp_dVbse = GS_dVbs * vssp; + dIssp_dVsubs= GS_dVsubs * vssp; + dIssp_dT = GS_dT * vssp; + + if( model->HSMHV_corg > 0.0 ){ + GG = here->HSMHV_grg ; + }else{ + GG = 0.0 ; + } + Iggp = GG * vggp; + dIggp_dVggp = GG; + + if(model->HSMHV_corbnet == 1 && here->HSMHV_rbpb > 0.0 ){ + GRBPB = here->HSMHV_grbpb ; + }else{ + GRBPB = 0.0 ; + } + Ibpb = GRBPB * vbpb; + dIbpb_dVbpb = GRBPB; + + if(model->HSMHV_corbnet == 1 && here->HSMHV_rbpd > 0.0 ){ + GRBPD = here->HSMHV_grbpd ; + }else{ + GRBPD = 0.0 ; + } + Ibpdb = GRBPD * vbpdb; + dIbpdb_dVbpdb = GRBPD; + + if(model->HSMHV_corbnet == 1 && here->HSMHV_rbps > 0.0 ){ + GRBPS = here->HSMHV_grbps ; + }else{ + GRBPS = 0.0 ; + } + Ibpsb = GRBPS * vbpsb; + dIbpsb_dVbpsb = GRBPS; + + /* printf("HSMHV_load: ByPass=%d\n",ByPass) ; */ + + if (!ByPass) { /* no convergence check in case of Bypass */ + /* + * check convergence + */ + isConv = 1; + if ( (here->HSMHV_off == 0) || !(ckt->CKTmode & MODEINITFIX) ) { + if (Check == 1) { + ckt->CKTnoncon++; + isConv = 0; +#ifndef NEWCONV + } else { + /* convergence check for branch currents is done in function HSMHVconvTest */ +#endif /* NEWCONV */ + } + } + + *(ckt->CKTstate0 + here->HSMHVvbs) = vbs; + *(ckt->CKTstate0 + here->HSMHVvbd) = vbd; + *(ckt->CKTstate0 + here->HSMHVvgs) = vgs; + *(ckt->CKTstate0 + here->HSMHVvds) = vds; + *(ckt->CKTstate0 + here->HSMHVvsbs) = vsbs; + *(ckt->CKTstate0 + here->HSMHVvdbs) = vdbs; + *(ckt->CKTstate0 + here->HSMHVvdbd) = vdbd; + *(ckt->CKTstate0 + here->HSMHVvges) = vges; + *(ckt->CKTstate0 + here->HSMHVvsubs) = vsubs; + *(ckt->CKTstate0 + here->HSMHVdeltemp) = deltemp; + *(ckt->CKTstate0 + here->HSMHVvdse) = vdse; + *(ckt->CKTstate0 + here->HSMHVvgse) = vgse; + *(ckt->CKTstate0 + here->HSMHVvbse) = vbse; + if ( flg_nqs ) { + *(ckt->CKTstate0 + here->HSMHVqi_nqs) = Qi_nqs; + *(ckt->CKTstate0 + here->HSMHVqb_nqs) = Qb_nqs; + } + /* printf("HSMHV_load: (into state0) vds.. = %e %e %e %e %e %e\n", + vds,vgs,vbs,vdse,vgse,vbse); */ + + if ((ckt->CKTmode & MODEDC) && + !(ckt->CKTmode & MODEINITFIX) && !(ckt->CKTmode & MODEINITJCT)) + showPhysVal = 1; + if (model->HSMHV_show_Given && showPhysVal && isConv) { + static int isFirst = 1; + if (vds != vds_pre) + ShowPhysVals(here, model, isFirst, vds_pre, vgs, vbs, vgd, vbd, vgb); + else + ShowPhysVals(here, model, isFirst, vds, vgs, vbs, vgd, vbd, vgb); + if (isFirst) isFirst = 0; + } + } + +#include "hsmhvld_info_eval.h" + + /* For standard Newton method (SPICE_rhs == 0): */ + /* if currents (and charges) are limited -> extrapolate onto x-values */ + /* in SPICE mode (SPICE_rhs == 1): */ + /* extrapolate onto x = 0 (-> rhs_eq) */ + /* */ + /* note that */ + /* the charge extrapolation is replaced by extrapolation of displacement */ + /* currents, see below */ + + /* ...... just for easier handling: collect node voltages in vector x: */ + if (!SPICE_rhs) { + x[dNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVdNode)); + x[dNodePrime] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVdNodePrime)); + x[gNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVgNode)); + x[gNodePrime] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVgNodePrime)); + x[sNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVsNode)); + x[sNodePrime] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVsNodePrime)); + x[bNodePrime] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVbNodePrime)); + x[bNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVbNode)); + x[dbNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVdbNode)); + x[sbNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVsbNode)); + if (flg_subNode > 0) + x[subNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVsubNode)); /* previous vsub */ + else + x[subNode] = 0.0; + if (flg_tempNode > 0) + x[tempNode] = *(ckt->CKTrhsOld+here->HSMHVtempNode); + else + x[tempNode] = 0.0; + if ( flg_nqs ) { + x[qiNode] = *(ckt->CKTrhsOld+here->HSMHVqiNode); + x[qbNode] = *(ckt->CKTrhsOld+here->HSMHVqbNode); + } else { + x[qiNode] = 0.0; + x[qbNode] = 0.0; + } + } + + delvgs = (x[gNodePrime] - x[sNodePrime]) - vgs; + delvds = (x[dNodePrime] - x[sNodePrime]) - vds; + delvbs = (x[bNodePrime] - x[sNodePrime]) - vbs; + deldeltemp = x[tempNode] - deltemp; + + if (delvgs || delvds || delvbs ||deldeltemp) { + Ids += gm *delvgs + gds *delvds + gmbs *delvbs + gmT *deldeltemp ; + Isub += dIsub_dVgs *delvgs + dIsub_dVds *delvds + dIsub_dVbs *delvbs + dIsub_dT *deldeltemp ; + Isub += dIsub_dVdse*delvdse ; + Isubs+= dIsubs_dVgs*delvgs + dIsubs_dVds*delvds + dIsubs_dVbs*delvbs + dIsubs_dT*deldeltemp ; + Isubs+= dIsubs_dVdse*delvdse ; + Igd += dIgd_dVg *delvgs + dIgd_dVd *delvds + dIgd_dVb *delvbs + dIgd_dT *deldeltemp ; + Igs += dIgs_dVg *delvgs + dIgs_dVd *delvds + dIgs_dVb *delvbs + dIgs_dT *deldeltemp ; + Igb += dIgb_dVg *delvgs + dIgb_dVd *delvds + dIgb_dVb *delvbs + dIgb_dT *deldeltemp ; + Igidl+= dIgidl_dVgs*delvgs + dIgidl_dVds*delvds + dIgidl_dVbs*delvbs + dIgidl_dT*deldeltemp ; + Igisl+= dIgisl_dVgs*delvgs + dIgisl_dVds*delvds + dIgisl_dVbs*delvbs + dIgisl_dT*deldeltemp ; + P += dP_dVgs *delvgs + dP_dVds *delvds + dP_dVbs *delvbs + dP_dT *deldeltemp ; + if (flg_nqs) { + Iqi_nqs += dIqi_nqs_dVgs*delvgs + dIqi_nqs_dVds*delvds + dIqi_nqs_dVbs*delvbs + dIqi_nqs_dT*deldeltemp ; + Iqb_nqs += dIqb_nqs_dVgs*delvgs + dIqb_nqs_dVds*delvds + dIqb_nqs_dVbs*delvbs + dIqb_nqs_dT*deldeltemp ; + } + } + + delvgse = (x[gNodePrime] - x[sNode]) - vgse; + delvdse = (x[dNode] - x[sNode]) - vdse; + delvbse = (x[bNodePrime] - x[sNode]) - vbse; + if (flg_subNode > 0) delvsubs = (x[subNode] - x[sNode]) - vsubs; /* substrate bias change */ + + if (delvgse || delvdse || delvbse ) { + Ids += gm_ext *delvgse + gds_ext *delvdse + gmbs_ext *delvbse ; + P += dP_dVgse *delvgse + dP_dVdse *delvdse + dP_dVbse *delvbse ; + Iddp += dIddp_dVgse*delvgse + dIddp_dVdse*delvdse + dIddp_dVbse*delvbse ; + Issp += dIssp_dVgse*delvgse + dIssp_dVdse*delvdse + dIssp_dVbse*delvbse ; + } + + if (delvsubs) { + Iddp += dIddp_dVsubs*delvsubs ; + Issp += dIssp_dVsubs*delvsubs ; + } + + if (deldeltemp) { + Iddp += dIddp_dT*deldeltemp ; + Issp += dIssp_dT*deldeltemp ; + Ith += dIth_dT *deldeltemp ; + } + + delvdbd = (x[dbNode] - x[dNode]) - vbd_jct ; + if (delvdbd || deldeltemp) { + Ibd += Gbd*delvdbd + Gbdt*deldeltemp ; + } + + delvsbs = (x[sbNode] - x[sNode]) - vbs_jct ; + if (delvsbs || deldeltemp) { + Ibs += Gbs*delvsbs + Gbst*deldeltemp ; + } + + delvddp = (x[dNode] - x[dNodePrime]) - vddp ; + if (delvddp) { + Iddp += dIddp_dVddp * delvddp ; + } + + delvssp = (x[sNode] - x[sNodePrime]) - vssp ; + if (delvssp) { + Issp += dIssp_dVssp * delvssp ; + } + + delvggp = (x[gNode] - x[gNodePrime]) - vggp ; + if (delvggp) { + Iggp += dIggp_dVggp * delvggp ; + } + + delvbpb = (x[bNodePrime] - x[bNode]) - vbpb ; + if (delvbpb) { + Ibpb += dIbpb_dVbpb * delvbpb ; + } + + delvbpdb = (x[bNodePrime] - x[dbNode]) - vbpdb ; + if (delvbpdb) { + Ibpdb += dIbpdb_dVbpdb * delvbpdb ; + } + + delvbpsb = (x[bNodePrime] - x[sbNode]) - vbpsb ; + if (delvbpsb) { + Ibpsb += dIbpsb_dVbpsb * delvbpsb ; + } + + if (flg_nqs) { + delQi_nqs = x[qiNode] - Qi_nqs ; + if (delQi_nqs) { + Iqi_nqs += dIqi_nqs_dQi_nqs * delQi_nqs ; + } + delQb_nqs = x[qbNode] - Qb_nqs ; + if (delQb_nqs) { + Iqb_nqs += dIqb_nqs_dQb_nqs * delQb_nqs ; + } + } + + + /* Assemble currents into nodes */ + /* ... static part */ + + + /* drain node */ + i_d = Iddp - Ibd ; + /* intrinsic drain node */ + i_dP = -Iddp + Ids + Isub + Igidl - Igd ; + /* gate node */ + i_g = Iggp ; + /* intrinsic gate node */ + i_gP = - Iggp + Igd + Igs + Igb ; + /* source node */ + i_s = Issp - Ibs ; + /* intrinsic source node */ + i_sP = - Issp - Ids + Isubs + Igisl - Igs ; + /* intrinsic bulk node */ + i_bP = - Isub - Isubs - Igidl -Igb - Igisl + Ibpdb + Ibpb + Ibpsb ; + /* base node */ + i_b = - Ibpb ; + /* drain bulk node */ + i_db = Ibd - Ibpdb ; + /* source bulk node */ + i_sb = Ibs - Ibpsb ; + /* temp node */ + if (flg_tempNode > 0){ + i_t = Ith - P ; + } else { + i_t = 0.0; + } + /* nqs equations */ + i_qi = Iqi_nqs ; + i_qb = Iqb_nqs ; + + for (i = 0; i < XDIM; i++) { + ydc_d[i] = ydc_dP[i] = ydc_g[i] = ydc_gP[i] = ydc_s[i] = ydc_sP[i] = ydc_bP[i] = ydc_b[i] + = ydc_db[i] = ydc_sb[i] = ydc_t[i] = 0.0; + } + if (flg_nqs) { + for (i = 0; i < XDIM; i++) { + ydc_qi[i] = ydc_qb[i] = 0.0; + } + } + + /* drain node */ + ydc_d[dNode] = dIddp_dVddp + dIddp_dVdse + Gbd ; + ydc_d[dNodePrime] = -dIddp_dVddp ; + /* ydc_d[gNode] = 0.0 ; */ + ydc_d[gNodePrime] = dIddp_dVgse ; + ydc_d[sNode] = - ( dIddp_dVdse + dIddp_dVgse + dIddp_dVbse ) - dIddp_dVsubs ; + /* ydc_d[sNodePrime] = 0.0 ; */ + ydc_d[bNodePrime] = dIddp_dVbse ; + /* ydc_d[bNode] = 0.0 ; */ + ydc_d[dbNode] = - Gbd ; + /* ydc_d[sbNode] = 0.0 ; */ + ydc_d[subNode] = dIddp_dVsubs ; + ydc_d[tempNode] = dIddp_dT - Gbdt ; + + /* intrinsic drain node */ + ydc_dP[dNode] = - (dIddp_dVddp + dIddp_dVdse) + gds_ext + dIsub_dVdse ; + ydc_dP[dNodePrime] = dIddp_dVddp + gds + dIsub_dVds + dIgidl_dVds - dIgd_dVd ; + /* ydc_dP[gNode] = 0.0; */ + ydc_dP[gNodePrime] = -dIddp_dVgse + gm_ext + + gm + dIsub_dVgs + dIgidl_dVgs - dIgd_dVg ; + ydc_dP[sNode] = dIddp_dVdse + dIddp_dVgse + dIddp_dVbse + dIddp_dVsubs + (-gds_ext -gm_ext -gmbs_ext); + ydc_dP[sNodePrime] = -( gds + dIsub_dVds + dIgidl_dVds ) + - ( gm + dIsub_dVgs + dIgidl_dVgs ) + - ( gmbs + dIsub_dVbs + dIgidl_dVbs ) - dIgd_dVs ; + ydc_dP[bNodePrime] = - dIddp_dVbse + gmbs_ext + + gmbs + dIsub_dVbs + dIgidl_dVbs - dIgd_dVb; + /* ydc_dP[bNode] = 0.0; */ + /* ydc_dP[dbNode] = 0.0 ; */ + /* ydc_dP[sbNode] = 0.0 ; */ + ydc_dP[subNode] = - dIddp_dVsubs ; + ydc_dP[tempNode] = - dIddp_dT + + gmT + dIsub_dT + dIgidl_dT - dIgd_dT ; + + /* gate node */ + /* ydc_g[dNode] = 0.0 ; */ + /* ydc_g[dNodePrime] = 0.0 ; */ + ydc_g[gNode] = dIggp_dVggp ; + ydc_g[gNodePrime] = - dIggp_dVggp ; + /* ydc_g[sNode] = 0.0 ; */ + /* ydc_g[sNodePrime] = 0.0 ; */ + /* ydc_g[bNodePrime] = 0.0 ; */ + /* ydc_g[bNode] = 0.0 ; */ + /* ydc_g[dbNode] = 0.0 ; */ + /* ydc_g[sbNode] = 0.0 ; */ + /* ydc_g[tempNode] = 0.0 ; */ + + /* intrinsic gate node */ + /* ydc_gP[dNode] = 0.0 ; */ + ydc_gP[dNodePrime] = dIgd_dVd + dIgs_dVd + dIgb_dVd ; + ydc_gP[gNode] = - dIggp_dVggp ; + ydc_gP[gNodePrime] = dIggp_dVggp + dIgd_dVg + dIgs_dVg + dIgb_dVg ; + /* ydc_gP[sNode] = 0.0 ; */ + ydc_gP[sNodePrime] = dIgd_dVs + dIgs_dVs + dIgb_dVs ; + ydc_gP[bNodePrime] = dIgd_dVb + dIgs_dVb + dIgb_dVb ; + /* ydc_gP[bNode] = 0.0 ; */ + /* ydc_gP[dbNode] = 0.0 ; */ + /* ydc_gP[sbNode] = 0.0 ; */ + ydc_gP[tempNode] = dIgd_dT + dIgs_dT + dIgb_dT ; + + /* source node */ + ydc_s[dNode] = dIssp_dVdse; + /* ydc_s[dNodePrime] = 0.0 */ + /* ydc_s[gNode] = 0.0 */ + ydc_s[gNodePrime] = dIssp_dVgse; + ydc_s[sNode] = dIssp_dVssp - ( dIssp_dVgse + dIssp_dVdse + dIssp_dVbse ) - dIssp_dVsubs + Gbs; + ydc_s[sNodePrime] = - dIssp_dVssp; + ydc_s[bNodePrime] = dIssp_dVbse ; + /* ydc_s[bNode] = 0.0 */ + /* ydc_s[dbNode] = 0.0 */ + ydc_s[sbNode] = - Gbs ; + ydc_s[subNode] = dIssp_dVsubs; + ydc_s[tempNode] = dIssp_dT - Gbst; + + /* intrinsic source node */ + ydc_sP[dNode] = - dIssp_dVdse -gds_ext + dIsubs_dVdse ; + ydc_sP[dNodePrime] = - gds + dIsubs_dVds + dIgisl_dVds - dIgs_dVd ; + /* ydc_sP[gNode] = 0.0 ; */ + ydc_sP[gNodePrime] = -dIssp_dVgse -gm_ext + - gm + dIsubs_dVgs + dIgisl_dVgs - dIgs_dVg ; + ydc_sP[sNode] = - dIssp_dVssp - ( - dIssp_dVdse - dIssp_dVgse - dIssp_dVbse ) + dIssp_dVsubs +(gds_ext + gm_ext + gmbs_ext); + ydc_sP[sNodePrime] = dIssp_dVssp - ( - gds + dIsubs_dVds + dIgisl_dVds ) + - ( - gm + dIsubs_dVgs + dIgisl_dVgs ) + - ( - gmbs + dIsubs_dVbs + dIgisl_dVbs ) - dIgs_dVs ; + ydc_sP[bNodePrime] = -dIssp_dVbse -gmbs_ext + - gmbs + dIsubs_dVbs + dIgisl_dVbs - dIgs_dVb ; + /* ydc_sP[bNode] = 0.0 ; */ + /* ydc_sP[dbNode] = 0.0 ; */ + /* ydc_sP[sbNode] = 0.0 ; */ + ydc_sP[subNode] = - dIssp_dVsubs; + ydc_sP[tempNode] = -dIssp_dT + - gmT + dIsubs_dT + dIgisl_dT - dIgs_dT; + + /* intrinsic bulk node */ + ydc_bP[dNode] = - dIsub_dVdse - dIsubs_dVdse ; + ydc_bP[dNodePrime] = - dIsub_dVds - dIsubs_dVds - dIgidl_dVds - dIgb_dVd - dIgisl_dVds ; + /* ydc_bP[gNode] = 0.0 ; */ + ydc_bP[gNodePrime] = - dIsub_dVgs - dIsubs_dVgs - dIgidl_dVgs - dIgb_dVg - dIgisl_dVgs ; + /* ydc_bP[sNode] = 0.0 ; */ + ydc_bP[sNodePrime] = - ( - dIsub_dVds - dIsubs_dVds - dIgidl_dVds - dIgisl_dVds ) + - ( - dIsub_dVgs - dIsubs_dVgs - dIgidl_dVgs - dIgisl_dVgs ) + - ( - dIsub_dVbs - dIsubs_dVbs - dIgidl_dVbs - dIgisl_dVbs ) - dIgb_dVs ; + ydc_bP[bNodePrime] = - dIsub_dVbs - dIsubs_dVbs - dIgidl_dVbs - dIgb_dVb - dIgisl_dVbs + dIbpdb_dVbpdb + dIbpb_dVbpb + dIbpsb_dVbpsb ; + ydc_bP[bNode] = - dIbpb_dVbpb ; + ydc_bP[dbNode] = - dIbpdb_dVbpdb ; + ydc_bP[sbNode] = - dIbpsb_dVbpsb ; + ydc_bP[tempNode] = - dIsub_dT - dIsubs_dT - dIgidl_dT - dIgb_dT - dIgisl_dT ; + + /* bulk node */ + /* ydc_b[dNode] = 0.0 ; */ + /* ydc_b[dNodePrime] = 0.0 ; */ + /* ydc_b[gNode] = 0.0 ; */ + /* ydc_b[gNodePrime] = 0.0 ; */ + /* ydc_b[sNode] = 0.0 ; */ + /* ydc_b[sNodePrime] = 0.0 ; */ + ydc_b[bNodePrime] = - dIbpb_dVbpb ; + ydc_b[bNode] = dIbpb_dVbpb ; + /* ydc_b[dbNode] = 0.0 ; */ + /* ydc_b[sbNode] = 0.0 ; */ + /* ydc_b[tempNode] = 0.0 ; */ + + /* drain bulk node */ + ydc_db[dNode] = - Gbd ; + /* ydc_db[dNodePrime] = 0.0 ; */ + /* ydc_db[gNode] = 0.0 ; */ + /* ydc_db[gNodePrime] = 0.0 ; */ + /* ydc_db[sNode] = 0.0 ; */ + /* ydc_db[sNodePrime] = 0.0 ; */ + ydc_db[bNodePrime] = - dIbpdb_dVbpdb ; + /* ydc_db[bNode] = 0.0 ; */ + ydc_db[dbNode] = Gbd + dIbpdb_dVbpdb ; + /* ydc_db[sbNode] = 0.0 ; */ + ydc_db[tempNode] = Gbdt ; + + /* source bulk node */ + /* ydc_sb[dNode] = 0.0 ; */ + /* ydc_sb[dNodePrime] = 0.0 ; */ + /* ydc_sb[gNode] = 0.0 ; */ + /* ydc_sb[gNodePrime] = 0.0 ; */ + ydc_sb[sNode] = - Gbs ; + /* ydc_sb[sNodePrime] = 0.0 ; */ + ydc_sb[bNodePrime] = - dIbpsb_dVbpsb ; + /* ydc_sb[bNode] = 0.0 ; */ + /* ydc_sb[dbNode] = 0.0 ; */ + ydc_sb[sbNode] = Gbs + dIbpsb_dVbpsb ; + ydc_sb[tempNode] = Gbst ; + + /* temp node */ + ydc_t[dNode] = - dP_dVdse ; + ydc_t[dNodePrime] = - dP_dVds ; + /* ydc_t[gNode] = 0.0 ; */ + ydc_t[gNodePrime] = - dP_dVgs - dP_dVgse ; + ydc_t[sNode] = - ( - dP_dVdse - dP_dVgse - dP_dVbse ) ; + ydc_t[sNodePrime] = - ( - dP_dVds - dP_dVgs - dP_dVbs ) ; + ydc_t[bNodePrime] = - dP_dVbs - dP_dVbse ; + /* ydc_t[bNode] = 0.0 ; */ + /* ydc_t[dbNode] = 0.0 ; */ + /* ydc_t[sbNode] = 0.0 ; */ + ydc_t[tempNode] = dIth_dT - dP_dT ; + + /* additional entries for flat nqs handling */ + if ( flg_nqs ) { + ydc_qi[dNodePrime] = dIqi_nqs_dVds ; + ydc_qi[gNodePrime] = dIqi_nqs_dVgs ; + ydc_qi[sNodePrime] = -(dIqi_nqs_dVds + dIqi_nqs_dVgs + dIqi_nqs_dVbs) ; + ydc_qi[bNodePrime] = dIqi_nqs_dVbs ; + ydc_qi[tempNode] = dIqi_nqs_dT ; + ydc_qi[qiNode] = dIqi_nqs_dQi_nqs ; + /* ydc_qi[qbNode]= 0.0 ; */ + ydc_qb[dNodePrime] = dIqb_nqs_dVds ; + ydc_qb[gNodePrime] = dIqb_nqs_dVgs ; + ydc_qb[sNodePrime] = -(dIqb_nqs_dVds + dIqb_nqs_dVgs + dIqb_nqs_dVbs) ; + ydc_qb[bNodePrime] = dIqb_nqs_dVbs ; + ydc_qb[tempNode] = dIqb_nqs_dT ; + /* ydc_qb[qiNode]= 0.0 ; */ + ydc_qb[qbNode] = dIqb_nqs_dQb_nqs ; + } + + + /* Preset vectors and matrix for dynamic part */ + + cq_d = cq_dP = cq_g = cq_gP = cq_s = cq_sP = cq_bP = cq_b = cq_db = cq_sb = cq_t = cq_qi = cq_qb = 0.0 ; + for (i = 0; i < XDIM ; i++) { + ydyn_d[i] = ydyn_dP[i] = ydyn_g[i] = ydyn_gP[i] = ydyn_s[i] = ydyn_sP[i] = ydyn_bP[i] = ydyn_b[i] + = ydyn_db[i] = ydyn_sb[i] = ydyn_t[i] = 0.0; + } + if (flg_nqs) { + for (i = 0; i < XDIM ; i++) { + ydyn_qi[i] = ydyn_qb[i] = 0.0; + } + } + + ag0 = ckt->CKTag[0]; + + if (ChargeComputationNeeded) { /* start handling of dynamic part */ + + if (!ByPass) { /* loading of state vector not necessary in case of Bypass */ + + /* intrinsic gate node (without fringing charges) */ + *(ckt->CKTstate0 + here->HSMHVqg) = Qg + Qg_nqs ; + + /* intrinsic drain node */ + *(ckt->CKTstate0 + here->HSMHVqd) = Qd + Qd_nqs ; + + /* intrinsic bulk node */ + *(ckt->CKTstate0 + here->HSMHVqb) = Qb + Qb_nqs ; + + /* drain bulk node */ + *(ckt->CKTstate0 + here->HSMHVqbd) = Qbd ; + + /* source bulk node */ + *(ckt->CKTstate0 + here->HSMHVqbs) = Qbs ; + + /* temp node */ + *(ckt->CKTstate0 + here->HSMHVqth) = Qth ; + + /* fringing charges */ + *(ckt->CKTstate0 + here->HSMHVqfd) = Qfd ; + *(ckt->CKTstate0 + here->HSMHVqfs) = Qfs ; + + /* nqs charges Qi_nqs, Qb_nqs: already loaded above */ + /* if ( flg_nqs ) { */ + /* *(ckt->CKTstate0 + here->HSMHVqi_nqs) = Qi_nqs; */ + /* *(ckt->CKTstate0 + here->HSMHVqb_nqs) = Qb_nqs; */ + /* } */ + } + + /* ... assemble capacitance matrix */ + + /* ...... drain node */ + ydyn_d[dNode] = dQfd_dVdse + Cbd; + /* ydyn_d[dNodePrime] = 0.0 ; */ + /* ydyn_d[gNode] = 0.0 ; */ + ydyn_d[gNodePrime] = dQfd_dVgse; + ydyn_d[sNode] = - (dQfd_dVdse + dQfd_dVgse+ dQfd_dVbse); + /* ydyn_d[sNodePrime ] = 0.0 ; */ + ydyn_d[bNodePrime] = dQfd_dVbse; + /* ydyn_d[bNode ] = 0.0 ; */ + ydyn_d[dbNode] = - Cbd ; + /* ydyn_d[sbNode ] = 0.0 ; */ + ydyn_d[tempNode] = dQfd_dT - Cbdt; + + /* ...... intrinsic drain node */ + /* ydyn_dP[dNode] = 0.0 ; */ + ydyn_dP[dNodePrime] = dQd_dVds ; + /* ydyn_dP[gNode] = 0.0 ; */ + ydyn_dP[gNodePrime] = dQd_dVgs ; + /* ydyn_dP[sNode] = 0.0 ; */ + ydyn_dP[sNodePrime] = - ( dQd_dVds + dQd_dVgs + dQd_dVbs ) ; + ydyn_dP[bNodePrime] = dQd_dVbs ; + /* ydyn_dP[bNode] = 0.0 ; */ + /* ydyn_dP[dbNode] = 0.0 ; */ + /* ydyn_dP[sbNode] = 0.0 ; */ + ydyn_dP[tempNode] = dQd_dT ; + + /* ...... gate node */ + /* (no entry) */ + + /* ...... intrinsic gate node */ + ydyn_gP[dNode] = -dQfd_dVdse - dQfs_dVdse ; + ydyn_gP[dNodePrime] = dQg_dVds ; + /* ydyn_gP[gNode] = 0.0 ; */ + ydyn_gP[gNodePrime] = dQg_dVgs -dQfd_dVgse - dQfs_dVgse; + ydyn_gP[sNode] = dQfd_dVdse + dQfs_dVdse + dQfd_dVgse + dQfs_dVgse + dQfd_dVbse + dQfs_dVbse; + ydyn_gP[sNodePrime] = -( dQg_dVds + dQg_dVgs + dQg_dVbs ) ; + ydyn_gP[bNodePrime] = dQg_dVbs -dQfd_dVbse - dQfs_dVbse; + /* ydyn_gP[bNode] = 0.0 ; */ + /* ydyn_gP[dbNode] = 0.0 ; */ + /* ydyn_gP[sbNode] = 0.0 ; */ + ydyn_gP[tempNode] = dQg_dT - dQfd_dT - dQfs_dT ; + + /* ...... source node */ + ydyn_s[dNode] = dQfs_dVdse; + /* ydyn_d[dNodePrime ] = 0.0 ; */ + /* ydyn_d[gNode ] = 0.0 ; */ + ydyn_s[gNodePrime] = dQfs_dVgse; + ydyn_s[sNode] = Cbs - (dQfs_dVdse + dQfs_dVgse+ dQfs_dVbse); + /* ydyn_d[sNodePrime ] = 0.0 ; */ + ydyn_s[bNodePrime] = dQfs_dVbse; + /* ydyn_d[bNode ] = 0.0 ; */ + /* ydyn_d[dbNode ] = 0.0 ; */ + ydyn_s[sbNode] = - Cbs ; + ydyn_s[tempNode] = dQfs_dT - Cbst; + + /* ...... intrinsic source node */ + /* ydyn_sP[dNode] = 0.0 ; */ + ydyn_sP[dNodePrime] = dQs_dVds ; + /* ydyn_sP[gNode] = 0.0 ; */ + ydyn_sP[gNodePrime] = dQs_dVgs ; + /* ydyn_sP[sNode] = 0.0 ; */ + ydyn_sP[sNodePrime] = - ( dQs_dVds + dQs_dVgs + dQs_dVbs ); + ydyn_sP[bNodePrime] = dQs_dVbs ; + /* ydyn_sP[bNode] = 0.0 ; */ + /* ydyn_sP[dbNode] = 0.0 ; */ + /* ydyn_sP[sbNode] = 0.0 ; */ + ydyn_sP[tempNode] = dQs_dT ; + + /* ...... intrinsic bulk node */ + /* ydyn_bP[dNode] = 0.0 ; */ + ydyn_bP[dNodePrime] = dQb_dVds ; + /* ydyn_bP[gNode] = 0.0 ; */ + ydyn_bP[gNodePrime] = dQb_dVgs ; + /* ydyn_bP[sNode] = 0.0 ; */ + ydyn_bP[sNodePrime] = - ( dQb_dVds + dQb_dVgs + dQb_dVbs ); + ydyn_bP[bNodePrime] = dQb_dVbs; + /* ydyn_bP[bNode] = 0.0 ; */ + /* ydyn_bP[dbNode] = 0.0 ; */ + /* ydyn_bP[sbNode] = 0.0 ; */ + ydyn_bP[tempNode] = dQb_dT ; + + /* ...... bulk node */ + /* (no entry) */ + + /* ...... drain bulk node */ + ydyn_db[dNode] = - Cbd ; + /* ydyn_db[dNodePrime] = 0.0 ; */ + /* ydyn_db[gNode] = 0.0 ; */ + /* ydyn_db[gNodePrime] = 0.0 ; */ + /* ydyn_db[sNode] = 0.0 ; */ + /* ydyn_db[sNodePrime] = 0.0 ; */ + /* ydyn_db[bNodePrime] = 0.0 ; */ + /* ydyn_db[bNode] = 0.0 ; */ + ydyn_db[dbNode] = Cbd ; + /* ydyn_db[sbNode] = 0.0 ; */ + ydyn_db[tempNode] = Cbdt ; + + /* ...... source bulk node */ + /* ydyn_sb[dNode] = 0.0 ; */ + /* ydyn_sb[dNodePrime] = 0.0 ; */ + /* ydyn_sb[gNode] = 0.0 ; */ + /* ydyn_sb[gNodePrime] = 0.0 ; */ + ydyn_sb[sNode] = - Cbs ; + /* ydyn_sb[sNodePrime] = 0.0 ; */ + /* ydyn_sb[bNodePrime] = 0.0 ; */ + /* ydyn_sb[bNode] = 0.0 ; */ + /* ydyn_sb[dbNode] = 0.0 ; */ + ydyn_sb[sbNode] = Cbs ; + ydyn_sb[tempNode] = Cbst ; + + /* ...... temp node */ + /* ydyn_t[dNode] = 0.0 ; */ + /* ydyn_t[dNodePrime] = 0.0 ; */ + /* ydyn_t[gNode] = 0.0 ; */ + /* ydyn_t[gNodePrime] = 0.0 ; */ + /* ydyn_t[sNode] = 0.0 ; */ + /* ydyn_t[sNodePrime] = 0.0 ; */ + /* ydyn_t[bNodePrime] = 0.0 ; */ + /* ydyn_t[bNode] = 0.0 ; */ + /* ydyn_t[dbNode] = 0.0 ; */ + /* ydyn_t[sbNode] = 0.0 ; */ + ydyn_t[tempNode] = Cth ; + + /* additional entries for flat nqs handling */ + if (flg_nqs) { + /* ...... intrinsic drain node */ + /* ydyn_dP[dNode] += 0.0 ; */ + ydyn_dP[dNodePrime] += dQd_nqs_dVds ; + /* ydyn_dP[gNode] += 0.0 ; */ + ydyn_dP[gNodePrime] += dQd_nqs_dVgs ; + /* ydyn_dP[sNode] += 0.0 ; */ + ydyn_dP[sNodePrime] += - ( dQd_nqs_dVds + dQd_nqs_dVgs + dQd_nqs_dVbs ) ; + ydyn_dP[bNodePrime] += dQd_nqs_dVbs ; + /* ydyn_dP[bNode] += 0.0 ; */ + /* ydyn_dP[dbNode] += 0.0 ; */ + /* ydyn_dP[sbNode] += 0.0 ; */ + ydyn_dP[tempNode] += dQd_nqs_dT ; + ydyn_dP[qiNode] = dQd_nqs_dQi_nqs ; + + /* ...... intrinsic gate node */ + /* ydyn_gP[dNode] += 0.0 ; */ + /* ydyn_gP[dNodePrime] += 0.0 ; */ + /* ydyn_gP[gNode] += 0.0 ; */ + /* ydyn_gP[gNodePrime] += 0.0 ; */ + /* ydyn_gP[sNode] += 0.0 ; */ + /* ydyn_gP[sNodePrime] += 0.0 ; */ + /* ydyn_gP[bNodePrime] += 0.0 ; */ + /* ydyn_gP[bNode] += 0.0 ; */ + /* ydyn_gP[dbNode] += 0.0 ; */ + /* ydyn_gP[sbNode] += 0.0 ; */ + /* ydyn_gP[tempNode] += 0.0 ; */ + ydyn_gP[qiNode] = dQg_nqs_dQi_nqs ; + ydyn_gP[qbNode] = dQg_nqs_dQb_nqs ; + + /* ...... intrinsic source node */ + /* ydyn_sP[dNode] += 0.0 ; */ + ydyn_sP[dNodePrime] += dQs_nqs_dVds ; + /* ydyn_sP[gNode] += 0.0 ; */ + ydyn_sP[gNodePrime] += dQs_nqs_dVgs ; + /* ydyn_sP[sNode] += 0.0 ; */ + ydyn_sP[sNodePrime] += - ( dQs_nqs_dVds + dQs_nqs_dVgs + dQs_nqs_dVbs ); + ydyn_sP[bNodePrime] += dQs_nqs_dVbs ; + /* ydyn_sP[bNode] += 0.0 ; */ + /* ydyn_sP[dbNode] += 0.0 ; */ + /* ydyn_sP[sbNode] += 0.0 ; */ + ydyn_sP[tempNode] += dQs_nqs_dT ; + ydyn_sP[qiNode] = dQs_nqs_dQi_nqs ; + + /* ...... intrinsic bulk node */ + /* ydyn_bP[dNode] += 0.0 ; */ + /* ydyn_bP[dNodePrime] += 0.0 ; */ + /* ydyn_bP[gNode] += 0.0 ; */ + /* ydyn_bP[gNodePrime] += 0.0 ; */ + /* ydyn_bP[sNode] += 0.0 ; */ + /* ydyn_bP[sNodePrime] += 0.0 ; */ + /* ydyn_bP[bNodePrime] += 0.0 ; */ + /* ydyn_bP[bNode] += 0.0 ; */ + /* ydyn_bP[dbNode] += 0.0 ; */ + /* ydyn_bP[sbNode] += 0.0 ; */ + /* ydyn_bP[tempNode] += 0.0 ; */ + ydyn_bP[qbNode] = 1.0 ; + + /* ...... qi node */ + /* ydyn_qi[dNodePrime] = 0.0 ; */ + /* ydyn_qi[gNodePrime] = 0.0 ; */ + /* ydyn_qi[sNodePrime] = 0.0 ; */ + /* ydyn_qi[bNodePrime] = 0.0 ; */ + /* ydyn_qi[tempNode] = 0.0 ; */ + ydyn_qi[qiNode] = 1.0 ; + /* ydyn_qi[qbNode] = 0.0 ; */ + + /* ...... qb node */ + /* ydyn_qb[dNodePrime] = 0.0 ; */ + /* ydyn_qb[gNodePrime] = 0.0 ; */ + /* ydyn_qb[sNodePrime] = 0.0 ; */ + /* ydyn_qb[bNodePrime] = 0.0 ; */ + /* ydyn_qb[tempNode] = 0.0 ; */ + /* ydyn_qb[qiNode] = 0.0 ; */ + ydyn_qb[qbNode] = 1.0 ; + } + + if (!ByPass) { /* integrate etc. only necessary if not in Bypass mode! */ + + /* store small signal parameters */ + if (ckt->CKTmode & MODEINITSMSIG) { +/* printf("HSMHV_load: (small signal) ByPass=%d\n",ByPass); + printf("HSMHV_load: ydc_dP=%e %e %e %e %e %e %e %e\n", + ydc_dP[0],ydc_dP[1],ydc_dP[2],ydc_dP[3],ydc_dP[4],ydc_dP[5],ydc_dP[6],ydc_dP[7]); + printf("HSMHV_load: ych_dP=%e %e %e %e %e %e %e %e\n", + ydyn_dP[0],ydyn_dP[1],ydyn_dP[2],ydyn_dP[3],ydyn_dP[4],ydyn_dP[5],ydyn_dP[6],ydyn_dP[7]); +*/ + /* dc matrix into structure 0724*/ + for (i = 0; i < XDIM; i++) { + here->HSMHV_ydc_d[i] = ydc_d[i]; + here->HSMHV_ydc_dP[i] = ydc_dP[i]; + here->HSMHV_ydc_g[i] = ydc_g[i]; + here->HSMHV_ydc_gP[i] = ydc_gP[i]; + here->HSMHV_ydc_s[i] = ydc_s[i]; + here->HSMHV_ydc_sP[i] = ydc_sP[i]; + here->HSMHV_ydc_bP[i] = ydc_bP[i]; + here->HSMHV_ydc_b[i] = ydc_b[i]; + here->HSMHV_ydc_db[i] = ydc_db[i]; + here->HSMHV_ydc_sb[i] = ydc_sb[i]; + here->HSMHV_ydc_t[i] = ydc_t[i]; + } + /* capacitance matrix into structure 0724*/ + for (i = 0; i < XDIM; i++) { + here->HSMHV_ydyn_d[i] = ydyn_d[i]; + here->HSMHV_ydyn_dP[i] = ydyn_dP[i]; + here->HSMHV_ydyn_g[i] = ydyn_g[i]; + here->HSMHV_ydyn_gP[i] = ydyn_gP[i]; + here->HSMHV_ydyn_s[i] = ydyn_s[i]; + here->HSMHV_ydyn_sP[i] = ydyn_sP[i]; + here->HSMHV_ydyn_bP[i] = ydyn_bP[i]; + here->HSMHV_ydyn_b[i] = ydyn_b[i]; + here->HSMHV_ydyn_db[i] = ydyn_db[i]; + here->HSMHV_ydyn_sb[i] = ydyn_sb[i]; + here->HSMHV_ydyn_t[i] = ydyn_t[i]; + } + if (flg_nqs) { + for (i = 0; i < XDIM; i++) { + here->HSMHV_ydc_qi[i] = ydc_qi[i]; + here->HSMHV_ydc_qb[i] = ydc_qb[i]; + here->HSMHV_ydyn_qi[i] = ydyn_qi[i]; + here->HSMHV_ydyn_qb[i] = ydyn_qb[i]; + } + } + goto line1000; /* that's all for small signal analyses */ + } + + /* Continue handling of dynamic part: */ + /* ... calculate time derivatives of node charges */ + + if (ckt->CKTmode & MODEINITTRAN) { + /* at the very first iteration of the first timepoint: + copy charges into previous state -> the integrator may use them ... */ + *(ckt->CKTstate1 + here->HSMHVqb) = *(ckt->CKTstate0 + here->HSMHVqb); + *(ckt->CKTstate1 + here->HSMHVqg) = *(ckt->CKTstate0 + here->HSMHVqg); + *(ckt->CKTstate1 + here->HSMHVqd) = *(ckt->CKTstate0 + here->HSMHVqd); + *(ckt->CKTstate1 + here->HSMHVqth) = *(ckt->CKTstate0 + here->HSMHVqth); + *(ckt->CKTstate1 + here->HSMHVqbs) = *(ckt->CKTstate0 + here->HSMHVqbs); + *(ckt->CKTstate1 + here->HSMHVqbd) = *(ckt->CKTstate0 + here->HSMHVqbd); + + *(ckt->CKTstate1 + here->HSMHVqfd) = *(ckt->CKTstate0 + here->HSMHVqfd); + *(ckt->CKTstate1 + here->HSMHVqfs) = *(ckt->CKTstate0 + here->HSMHVqfs); + + if (flg_nqs) { + *(ckt->CKTstate1 + here->HSMHVqi_nqs) = *(ckt->CKTstate0 + here->HSMHVqi_nqs); + *(ckt->CKTstate1 + here->HSMHVqb_nqs) = *(ckt->CKTstate0 + here->HSMHVqb_nqs); + } + } + + if ((error = NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqb))) return(error); + if ((error = NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqg))) return(error); + if ((error = NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqd))) return(error); + if ((error = NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqbs))) return(error); + if ((error = NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqbd))) return(error); + + if ((error = NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqth))) return(error); + + if ((error = NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqfd))) return(error); + if ((error = NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqfs))) return(error); + + if (flg_nqs) { + if ((error = NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqi_nqs))) return(error); + if ((error = NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqb_nqs))) return(error); + } + + if (ckt->CKTmode & MODEINITTRAN) { + /* at the very first iteration of the first timepoint: + copy currents into previous state -> the integrator may use them ... */ + *(ckt->CKTstate1 + here->HSMHVcqb) = *(ckt->CKTstate0 + here->HSMHVcqb); + *(ckt->CKTstate1 + here->HSMHVcqg) = *(ckt->CKTstate0 + here->HSMHVcqg); + *(ckt->CKTstate1 + here->HSMHVcqd) = *(ckt->CKTstate0 + here->HSMHVcqd); + + *(ckt->CKTstate1 + here->HSMHVcqth) = *(ckt->CKTstate0 + here->HSMHVcqth); + + *(ckt->CKTstate1 + here->HSMHVcqbs) = *(ckt->CKTstate0 + here->HSMHVcqbs); + *(ckt->CKTstate1 + here->HSMHVcqbd) = *(ckt->CKTstate0 + here->HSMHVcqbd); + *(ckt->CKTstate1 + here->HSMHVcqfd) = *(ckt->CKTstate0 + here->HSMHVcqfd); + *(ckt->CKTstate1 + here->HSMHVcqfs) = *(ckt->CKTstate0 + here->HSMHVcqfs); + if (flg_nqs) { + *(ckt->CKTstate1 + here->HSMHVdotqi_nqs) = *(ckt->CKTstate0 + here->HSMHVdotqi_nqs); + *(ckt->CKTstate1 + here->HSMHVdotqb_nqs) = *(ckt->CKTstate0 + here->HSMHVdotqb_nqs); + } + } + } + + + /* ... finally gather displacement currents from data structures */ + + cq_dP = *(ckt->CKTstate0 + here->HSMHVcqd); + cq_gP = *(ckt->CKTstate0 + here->HSMHVcqg); + cq_bP = *(ckt->CKTstate0 + here->HSMHVcqb); + cq_sP = - *(ckt->CKTstate0 + here->HSMHVcqg) + - *(ckt->CKTstate0 + here->HSMHVcqb) + - *(ckt->CKTstate0 + here->HSMHVcqd); + cq_db = *(ckt->CKTstate0 + here->HSMHVcqbd); + cq_sb = *(ckt->CKTstate0 + here->HSMHVcqbs); + cq_g = 0.0 ; + cq_b = 0.0 ; + + /* displacement currents at outer drain/source node (fringing part only!) */ + cq_d = *(ckt->CKTstate0 + here->HSMHVcqfd); + cq_s = *(ckt->CKTstate0 + here->HSMHVcqfs); + + cq_t = *(ckt->CKTstate0 + here->HSMHVcqth); + + /* displacement currents due to nqs */ + if (flg_nqs) { + cq_qi = *(ckt->CKTstate0 + here->HSMHVdotqi_nqs); + cq_qb = *(ckt->CKTstate0 + here->HSMHVdotqb_nqs); + } else { + cq_qi = cq_qb = 0.0 ; + } + + /* ... and, if necessary: Extrapolate displacement currents onto x-values */ + + if (delvdbd || deldeltemp) { + cq_db += ag0*(Cbd*delvdbd + Cbdt*deldeltemp) ; + } + if (delvsbs || deldeltemp) { + cq_sb += ag0*(Cbs*delvsbs + Cbst*deldeltemp) ; + } + if (delvgs || delvds || delvbs || deldeltemp) { + cq_gP += ag0*(dQg_dVgs*delvgs + dQg_dVds*delvds + dQg_dVbs*delvbs + dQg_dT*deldeltemp) ; + cq_dP += ag0*(dQd_dVgs*delvgs + dQd_dVds*delvds + dQd_dVbs*delvbs + dQd_dT*deldeltemp) ; + cq_sP += ag0*(dQs_dVgs*delvgs + dQs_dVds*delvds + dQs_dVbs*delvbs + dQs_dT*deldeltemp) ; + cq_bP = - ( cq_gP + cq_dP + cq_sP ); + } + if (deldeltemp) { + cq_t += ag0*Cth *deldeltemp ; + cq_d += ag0*dQfd_dT*deldeltemp ; + cq_s += ag0*dQfs_dT*deldeltemp ; + } + if (delvgse || delvdse || delvbse) { + cq_d += ag0*(dQfd_dVgse*delvgse + dQfd_dVdse*delvdse + dQfd_dVbse*delvbse) ; + cq_s += ag0*(dQfs_dVgse*delvgse + dQfs_dVdse*delvdse + dQfs_dVbse*delvbse) ; + } + + if (flg_nqs) { + if (delvgs || delvds || delvbs || deldeltemp) { + cq_dP += ag0*(dQd_nqs_dVgs*delvgs + dQd_nqs_dVds*delvds + dQd_nqs_dVbs*delvbs + dQd_nqs_dT*deldeltemp) ; + cq_sP += ag0*(dQs_nqs_dVgs*delvgs + dQs_nqs_dVds*delvds + dQs_nqs_dVbs*delvbs + dQs_nqs_dT*deldeltemp) ; + cq_bP = - ( cq_gP + cq_dP + cq_sP ); /* should be superfluous ? */ + } + if (delQi_nqs) { + cq_dP += ag0*dQd_nqs_dQi_nqs*delQi_nqs ; + cq_gP += ag0*dQg_nqs_dQi_nqs*delQi_nqs ; + cq_sP += ag0*dQs_nqs_dQi_nqs*delQi_nqs ; + cq_qi += ag0* 1.0 *delQi_nqs ; + } + if (delQb_nqs) { + cq_gP += ag0*dQg_nqs_dQb_nqs*delQb_nqs ; + cq_bP += ag0* 1.0 *delQb_nqs ; + cq_qb += ag0* 1.0 *delQb_nqs ; + } + } + } /* End of handling dynamic part */ + + + /* Assemble total node currents (type-handling shifted to stamping) */ + + cur_d = i_d + cq_d - cq_db; + cur_dP = i_dP + cq_dP ; + cur_g = i_g + cq_g ; + cur_gP = i_gP + cq_gP - cq_d - cq_s ; + cur_s = i_s + cq_s - cq_sb; + cur_sP = i_sP + cq_sP; + cur_bP = i_bP + cq_bP; + cur_b = i_b + cq_b; + cur_db = i_db + cq_db; + cur_sb = i_sb + cq_sb; + cur_t = i_t + cq_t; + cur_qi = i_qi + cq_qi; + cur_qb = i_qb + cq_qb; + + + /* Now we can start stamping ... */ + /* ... right hand side: subtract total node currents */ + + *(ckt->CKTrhs + here->HSMHVdNode) -= model->HSMHV_type * cur_d; + *(ckt->CKTrhs + here->HSMHVdNodePrime) -= model->HSMHV_type * cur_dP; + *(ckt->CKTrhs + here->HSMHVgNode) -= model->HSMHV_type * cur_g; + *(ckt->CKTrhs + here->HSMHVgNodePrime) -= model->HSMHV_type * cur_gP; + *(ckt->CKTrhs + here->HSMHVsNode) -= model->HSMHV_type * cur_s; + *(ckt->CKTrhs + here->HSMHVsNodePrime) -= model->HSMHV_type * cur_sP; + *(ckt->CKTrhs + here->HSMHVbNodePrime) -= model->HSMHV_type * cur_bP; + *(ckt->CKTrhs + here->HSMHVbNode) -= model->HSMHV_type * cur_b; + *(ckt->CKTrhs + here->HSMHVdbNode) -= model->HSMHV_type * cur_db; + *(ckt->CKTrhs + here->HSMHVsbNode) -= model->HSMHV_type * cur_sb; + if( flg_tempNode > 0) { + *(ckt->CKTrhs + here->HSMHVtempNode) -= cur_t; /* temp node independent of model type! */ + } + if (flg_nqs) { + *(ckt->CKTrhs + here->HSMHVqiNode) -= cur_qi; + *(ckt->CKTrhs + here->HSMHVqbNode) -= cur_qb; + } + + + /* ... finally stamp matrix */ + + /*drain*/ + *(here->HSMHVDdPtr) += ydc_d[dNode] + ag0*ydyn_d[dNode]; + *(here->HSMHVDdpPtr) += ydc_d[dNodePrime] + ag0*ydyn_d[dNodePrime]; + *(here->HSMHVDgpPtr) += ydc_d[gNodePrime] + ag0*ydyn_d[gNodePrime]; + *(here->HSMHVDsPtr) += ydc_d[sNode] + ag0*ydyn_d[sNode]; + *(here->HSMHVDbpPtr) += ydc_d[bNodePrime] + ag0*ydyn_d[bNodePrime]; + *(here->HSMHVDdbPtr) += ydc_d[dbNode] + ag0*ydyn_d[dbNode]; + if (flg_subNode > 0) { + *(here->HSMHVDsubPtr) += ydc_d[subNode]; + } + if( flg_tempNode > 0) { + /* temp entries in matrix dependent on model type */ + *(here->HSMHVDtempPtr) += model->HSMHV_type * (ydc_d[tempNode] + ag0*ydyn_d[tempNode]); + } + + /*drain prime*/ + *(here->HSMHVDPdPtr) += ydc_dP[dNode] + ag0*ydyn_dP[dNode]; + *(here->HSMHVDPdpPtr) += ydc_dP[dNodePrime] + ag0*ydyn_dP[dNodePrime]; + *(here->HSMHVDPgpPtr) += ydc_dP[gNodePrime] + ag0*ydyn_dP[gNodePrime]; + *(here->HSMHVDPsPtr) += ydc_dP[sNode] + ag0*ydyn_dP[sNode]; + *(here->HSMHVDPspPtr) += ydc_dP[sNodePrime] + ag0*ydyn_dP[sNodePrime]; + *(here->HSMHVDPbpPtr) += ydc_dP[bNodePrime] + ag0*ydyn_dP[bNodePrime]; + if (flg_subNode > 0) { + *(here->HSMHVDPsubPtr) += ydc_dP[subNode]; + } + if( flg_tempNode > 0) { + /* temp entries in matrix dependent on model type */ + *(here->HSMHVDPtempPtr) += model->HSMHV_type * (ydc_dP[tempNode] + ag0*ydyn_dP[tempNode]); + } + if (flg_nqs) { + *(here->HSMHVDPqiPtr) += model->HSMHV_type * (ydc_dP[qiNode] + ag0*ydyn_dP[qiNode]); + } + + /*gate*/ + *(here->HSMHVGgPtr) += ydc_g[gNode] + ag0*ydyn_g[gNode]; + *(here->HSMHVGgpPtr) += ydc_g[gNodePrime] + ag0*ydyn_g[gNodePrime]; + + /*gate prime*/ + *(here->HSMHVGPdPtr) += ydc_gP[dNode] + ag0*ydyn_gP[dNode]; + *(here->HSMHVGPdpPtr) += ydc_gP[dNodePrime] + ag0*ydyn_gP[dNodePrime]; + *(here->HSMHVGPgPtr) += ydc_gP[gNode] + ag0*ydyn_gP[gNode]; + *(here->HSMHVGPgpPtr) += ydc_gP[gNodePrime] + ag0*ydyn_gP[gNodePrime]; + *(here->HSMHVGPsPtr) += ydc_gP[sNode] + ag0*ydyn_gP[sNode]; + *(here->HSMHVGPspPtr) += ydc_gP[sNodePrime] + ag0*ydyn_gP[sNodePrime]; + *(here->HSMHVGPbpPtr) += ydc_gP[bNodePrime] + ag0*ydyn_gP[bNodePrime]; + if( flg_tempNode > 0) { + /* temp entries in matrix dependent on model type */ + *(here->HSMHVGPtempPtr) += model->HSMHV_type * (ydc_gP[tempNode] + ag0*ydyn_gP[tempNode]); + } + if (flg_nqs) { + *(here->HSMHVGPqiPtr) += model->HSMHV_type * (ydc_gP[qiNode] + ag0*ydyn_gP[qiNode]); + *(here->HSMHVGPqbPtr) += model->HSMHV_type * (ydc_gP[qbNode] + ag0*ydyn_gP[qbNode]); + } + + /*source*/ + *(here->HSMHVSdPtr) += ydc_s[dNode] + ag0*ydyn_s[dNode]; + *(here->HSMHVSgpPtr) += ydc_s[gNodePrime] + ag0*ydyn_s[gNodePrime]; + *(here->HSMHVSsPtr) += ydc_s[sNode] + ag0*ydyn_s[sNode]; + *(here->HSMHVSspPtr) += ydc_s[sNodePrime] + ag0*ydyn_s[sNodePrime]; + *(here->HSMHVSbpPtr) += ydc_s[bNodePrime] + ag0*ydyn_s[bNodePrime]; + *(here->HSMHVSsbPtr) += ydc_s[sbNode] + ag0*ydyn_s[sbNode]; + if (flg_subNode > 0) { + *(here->HSMHVSsubPtr) += ydc_s[subNode]; + } + if( flg_tempNode > 0) { + /* temp entries in matrix dependent on model type */ + *(here->HSMHVStempPtr) += model->HSMHV_type * (ydc_s[tempNode]+ ag0*ydyn_s[tempNode]); + } + + /*source prime*/ + *(here->HSMHVSPdPtr) += ydc_sP[dNode] + ag0*ydyn_sP[dNode]; + *(here->HSMHVSPdpPtr) += ydc_sP[dNodePrime] + ag0*ydyn_sP[dNodePrime]; + *(here->HSMHVSPgpPtr) += ydc_sP[gNodePrime] + ag0*ydyn_sP[gNodePrime]; + *(here->HSMHVSPsPtr) += ydc_sP[sNode] + ag0*ydyn_sP[sNode]; + *(here->HSMHVSPspPtr) += ydc_sP[sNodePrime] + ag0*ydyn_sP[sNodePrime]; + *(here->HSMHVSPbpPtr) += ydc_sP[bNodePrime] + ag0*ydyn_sP[bNodePrime]; + if (flg_subNode > 0) { + *(here->HSMHVSPsubPtr) += ydc_sP[subNode]; + } + if( flg_tempNode > 0) { + /* temp entries in matrix dependent on model type */ + *(here->HSMHVSPtempPtr) += model->HSMHV_type * (ydc_sP[tempNode] + ag0*ydyn_sP[tempNode]); + } + if (flg_nqs) { + *(here->HSMHVSPqiPtr) += model->HSMHV_type * (ydc_sP[qiNode] + ag0*ydyn_sP[qiNode]); + } + + /*bulk prime*/ + *(here->HSMHVBPdPtr) += ydc_bP[dNode]; /* ydc_bP[dNode] + ag0*ydyn_bP[dNodePrime] */ + *(here->HSMHVBPdpPtr) += ydc_bP[dNodePrime] + ag0*ydyn_bP[dNodePrime]; + *(here->HSMHVBPgpPtr) += ydc_bP[gNodePrime] + ag0*ydyn_bP[gNodePrime]; + *(here->HSMHVBPspPtr) += ydc_bP[sNodePrime] + ag0*ydyn_bP[sNodePrime]; + *(here->HSMHVBPbpPtr) += ydc_bP[bNodePrime] + ag0*ydyn_bP[bNodePrime]; + *(here->HSMHVBPbPtr) += ydc_bP[bNode] + ag0*ydyn_bP[bNode]; + *(here->HSMHVBPdbPtr) += ydc_bP[dbNode] + ag0*ydyn_bP[dbNode]; + *(here->HSMHVBPsbPtr) += ydc_bP[sbNode] + ag0*ydyn_bP[sbNode]; + if( flg_tempNode > 0) { + /* temp entries in matrix dependent on model type */ + *(here->HSMHVBPtempPtr) += model->HSMHV_type * (ydc_bP[tempNode] + ag0*ydyn_bP[tempNode]); + } + if (flg_nqs) { + *(here->HSMHVBPqbPtr) += model->HSMHV_type * (ydc_bP[qbNode] + ag0*ydyn_bP[qbNode]); + } + + /*bulk*/ + *(here->HSMHVBbpPtr) += ydc_b[bNodePrime] + ag0*ydyn_b[bNodePrime]; + *(here->HSMHVBbPtr) += ydc_b[bNode] + ag0*ydyn_b[bNode]; + + /*drain bulk*/ + *(here->HSMHVDBdPtr) += ydc_db[dNode] + ag0*ydyn_db[dNode]; + *(here->HSMHVDBbpPtr) += ydc_db[bNodePrime] + ag0*ydyn_db[bNodePrime]; + *(here->HSMHVDBdbPtr) += ydc_db[dbNode] + ag0*ydyn_db[dbNode]; + if( flg_tempNode > 0) { + /* temp entries in matrix dependent on model type */ + *(here->HSMHVDBtempPtr) += model->HSMHV_type * (ydc_db[tempNode] + ag0*ydyn_db[tempNode]); + } + + /*source bulk*/ + *(here->HSMHVSBsPtr) += ydc_sb[sNode] + ag0*ydyn_sb[sNode]; + *(here->HSMHVSBbpPtr) += ydc_sb[bNodePrime] + ag0*ydyn_sb[bNodePrime]; + *(here->HSMHVSBsbPtr) += ydc_sb[sbNode] + ag0*ydyn_sb[sbNode]; + if( flg_tempNode > 0) { + /* temp entries in matrix dependent on model type */ + *(here->HSMHVSBtempPtr) += model->HSMHV_type * (ydc_sb[tempNode] + ag0*ydyn_sb[tempNode]); + } + + /*temp*/ + if( flg_tempNode > 0) { + /* temp entries in matrix dependent on model type */ + *(here->HSMHVTempdPtr) += model->HSMHV_type * (ydc_t[dNode] + ag0*ydyn_t[dNode] ); + *(here->HSMHVTempdpPtr) += model->HSMHV_type * (ydc_t[dNodePrime] + ag0*ydyn_t[dNodePrime]); + *(here->HSMHVTempgpPtr) += model->HSMHV_type * (ydc_t[gNodePrime] + ag0*ydyn_t[gNodePrime]); + *(here->HSMHVTempsPtr) += model->HSMHV_type * (ydc_t[sNode] + ag0*ydyn_t[sNode] ); + *(here->HSMHVTempspPtr) += model->HSMHV_type * (ydc_t[sNodePrime] + ag0*ydyn_t[sNodePrime]); + *(here->HSMHVTempbpPtr) += model->HSMHV_type * (ydc_t[bNodePrime] + ag0*ydyn_t[bNodePrime]); + /* no type factor at main diagonal temp entry! */ + *(here->HSMHVTemptempPtr) += ydc_t[tempNode] + ag0*ydyn_t[tempNode]; + } + + /* additional entries for flat nqs handling */ + if ( flg_nqs ) { + /*qi*/ + *(here->HSMHVQIdpPtr) += model->HSMHV_type * (ydc_qi[dNodePrime] + ag0*ydyn_qi[dNodePrime]); + *(here->HSMHVQIgpPtr) += model->HSMHV_type * (ydc_qi[gNodePrime] + ag0*ydyn_qi[gNodePrime]); + *(here->HSMHVQIspPtr) += model->HSMHV_type * (ydc_qi[sNodePrime] + ag0*ydyn_qi[sNodePrime]); + *(here->HSMHVQIbpPtr) += model->HSMHV_type * (ydc_qi[bNodePrime] + ag0*ydyn_qi[bNodePrime]); + *(here->HSMHVQIqiPtr) += (ydc_qi[qiNode] + ag0*ydyn_qi[qiNode]); + if ( flg_tempNode > 0 ) { /* self heating */ + *(here->HSMHVQItempPtr) += (ydc_qi[tempNode] + ag0*ydyn_qi[tempNode]); + } + + /*qb*/ + *(here->HSMHVQBdpPtr) += model->HSMHV_type * (ydc_qb[dNodePrime] + ag0*ydyn_qb[dNodePrime]); + *(here->HSMHVQBgpPtr) += model->HSMHV_type * (ydc_qb[gNodePrime] + ag0*ydyn_qb[gNodePrime]); + *(here->HSMHVQBspPtr) += model->HSMHV_type * (ydc_qb[sNodePrime] + ag0*ydyn_qb[sNodePrime]); + *(here->HSMHVQBbpPtr) += model->HSMHV_type * (ydc_qb[bNodePrime] + ag0*ydyn_qb[bNodePrime]); + *(here->HSMHVQBqbPtr) += (ydc_qb[qbNode] + ag0*ydyn_qb[qbNode]); + if ( flg_tempNode > 0 ) { /* self heating */ + *(here->HSMHVQBtempPtr) += (ydc_qb[tempNode] + ag0*ydyn_qb[tempNode]); + } + } + + +line1000: + + if (ckt->CKTnoncon != noncon_old) { + ckt->CKTtroubleElt = (GENinstance *) here; + } + + + } /* End of MOSFET Instance */ + } /* End of Model Instance */ + + return(OK); +} diff --git a/src/spicelib/devices/hisimhv/hsmhvld_info_eval.h b/src/spicelib/devices/hisimhv/hsmhvld_info_eval.h new file mode 100644 index 000000000..4eb9b8baf --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvld_info_eval.h @@ -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 */ diff --git a/src/spicelib/devices/hisimhv/hsmhvmask.c b/src/spicelib/devices/hisimhv/hsmhvmask.c new file mode 100644 index 000000000..16d457166 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvmask.c @@ -0,0 +1,1855 @@ +/*********************************************************************** + + 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 : hsmhvmask.c + + DATE : 2010.11.02 + + released by + Hiroshima University & + Semiconductor Technology Academic Research Center (STARC) +***********************************************************************/ + +#include "ngspice.h" +#include +#include "ifsim.h" +#include "cktdefs.h" +#include "devdefs.h" +#include "hsmhvdef.h" +#include "sperror.h" +#include "suffix.h" + +int HSMHVmAsk( + CKTcircuit *ckt, + GENmodel *inst, + int which, + IFvalue *value) +{ + HSMHVmodel *model = (HSMHVmodel *)inst; + switch (which) { + case HSMHV_MOD_NMOS: + value->iValue = model->HSMHV_type; + return(OK); + case HSMHV_MOD_PMOS: + value->iValue = model->HSMHV_type; + return(OK); + case HSMHV_MOD_LEVEL: + value->iValue = model->HSMHV_level; + return(OK); + case HSMHV_MOD_INFO: + value->iValue = model->HSMHV_info; + return(OK); + case HSMHV_MOD_NOISE: + value->iValue = model->HSMHV_noise; + return(OK); + case HSMHV_MOD_VERSION: + value->sValue = model->HSMHV_version; + return(OK); + case HSMHV_MOD_SHOW: + value->iValue = model->HSMHV_show; + return(OK); + case HSMHV_MOD_CORSRD: + value->iValue = model->HSMHV_corsrd; + return(OK); + case HSMHV_MOD_CORG: + value->iValue = model->HSMHV_corg; + return(OK); + case HSMHV_MOD_COIPRV: + value->iValue = model->HSMHV_coiprv; + return(OK); + case HSMHV_MOD_COPPRV: + value->iValue = model->HSMHV_copprv; + return(OK); + case HSMHV_MOD_COADOV: + value->iValue = model->HSMHV_coadov; + return(OK); + case HSMHV_MOD_COISUB: + value->iValue = model->HSMHV_coisub; + return(OK); + case HSMHV_MOD_COIIGS: + value->iValue = model->HSMHV_coiigs; + return(OK); + case HSMHV_MOD_COGIDL: + value->iValue = model->HSMHV_cogidl; + return(OK); + case HSMHV_MOD_COOVLP: + value->iValue = model->HSMHV_coovlp; + return(OK); + case HSMHV_MOD_COOVLPS: + value->iValue = model->HSMHV_coovlps; + return(OK); + case HSMHV_MOD_COFLICK: + value->iValue = model->HSMHV_coflick; + return(OK); + case HSMHV_MOD_COISTI: + value->iValue = model->HSMHV_coisti; + return(OK); + case HSMHV_MOD_CONQS: + value->iValue = model->HSMHV_conqs; + return(OK); + case HSMHV_MOD_CORBNET: + value->iValue = model->HSMHV_corbnet; + return(OK); + case HSMHV_MOD_COTHRML: + value->iValue = model->HSMHV_cothrml; + return(OK); + case HSMHV_MOD_COIGN: + value->iValue = model->HSMHV_coign; + return(OK); + case HSMHV_MOD_CODFM: + value->iValue = model->HSMHV_codfm; + return(OK); + case HSMHV_MOD_COQOVSM: + value->iValue = model->HSMHV_coqovsm; + return(OK); + case HSMHV_MOD_COSELFHEAT: /* Self-heating model */ + value->iValue = model->HSMHV_coselfheat; + return(OK); + case HSMHV_MOD_COSUBNODE: + value->iValue = model->HSMHV_cosubnode; + return(OK); + case HSMHV_MOD_COSYM: /* Symmetry model for HV */ + value->iValue = model->HSMHV_cosym; + return(OK); + case HSMHV_MOD_COTEMP: + value->iValue = model->HSMHV_cotemp; + return(OK); + case HSMHV_MOD_COLDRIFT: + value->iValue = model->HSMHV_coldrift; + return(OK); + case HSMHV_MOD_VMAX: + value->rValue = model->HSMHV_vmax; + return(OK); + case HSMHV_MOD_VMAXT1: + value->rValue = model->HSMHV_vmaxt1; + return(OK); + case HSMHV_MOD_VMAXT2: + value->rValue = model->HSMHV_vmaxt2; + return(OK); + case HSMHV_MOD_BGTMP1: + value->rValue = model->HSMHV_bgtmp1; + return(OK); + case HSMHV_MOD_BGTMP2: + value->rValue = model->HSMHV_bgtmp2; + return(OK); + case HSMHV_MOD_EG0: + value->rValue = model->HSMHV_eg0; + return(OK); + case HSMHV_MOD_TOX: + value->rValue = model->HSMHV_tox; + return(OK); + case HSMHV_MOD_XLD: + value->rValue = model->HSMHV_xld; + return(OK); + case HSMHV_MOD_LOVER: + value->rValue = model->HSMHV_lover; + return(OK); + case HSMHV_MOD_LOVERS: + value->rValue = model->HSMHV_lovers; + return(OK); + case HSMHV_MOD_RDOV11: + value->rValue = model->HSMHV_rdov11; + return(OK); + case HSMHV_MOD_RDOV12: + value->rValue = model->HSMHV_rdov12; + return(OK); + case HSMHV_MOD_RDOV13: + value->rValue = model->HSMHV_rdov13; + return(OK); + case HSMHV_MOD_RDSLP1: + value->rValue = model->HSMHV_rdslp1; + return(OK); + case HSMHV_MOD_RDICT1: + value->rValue = model->HSMHV_rdict1; + return(OK); + case HSMHV_MOD_RDSLP2: + value->rValue = model->HSMHV_rdslp2; + return(OK); + case HSMHV_MOD_RDICT2: + value->rValue = model->HSMHV_rdict2; + return(OK); + case HSMHV_MOD_LOVERLD: + value->rValue = model->HSMHV_loverld; + return(OK); + case HSMHV_MOD_LDRIFT1: + value->rValue = model->HSMHV_ldrift1; + return(OK); + case HSMHV_MOD_LDRIFT2: + value->rValue = model->HSMHV_ldrift2; + return(OK); + case HSMHV_MOD_LDRIFT1S: + value->rValue = model->HSMHV_ldrift1s; + return(OK); + case HSMHV_MOD_LDRIFT2S: + value->rValue = model->HSMHV_ldrift2s; + return(OK); + case HSMHV_MOD_SUBLD1: + value->rValue = model->HSMHV_subld1; + return(OK); + case HSMHV_MOD_SUBLD2: + value->rValue = model->HSMHV_subld2; + return(OK); + case HSMHV_MOD_DDLTMAX: /* Vdseff */ + value->rValue = model->HSMHV_ddltmax; + return(OK); + case HSMHV_MOD_DDLTSLP: /* Vdseff */ + value->rValue = model->HSMHV_ddltslp; + return(OK); + case HSMHV_MOD_DDLTICT: /* Vdseff */ + value->rValue = model->HSMHV_ddltict; + return(OK); + case HSMHV_MOD_VFBOVER: + value->rValue = model->HSMHV_vfbover; + return(OK); + case HSMHV_MOD_NOVER: + value->rValue = model->HSMHV_nover; + return(OK); + case HSMHV_MOD_NOVERS: + value->rValue = model->HSMHV_novers; + return(OK); + case HSMHV_MOD_XWD: + value->rValue = model->HSMHV_xwd; + return(OK); + case HSMHV_MOD_XWDC: + value->rValue = model->HSMHV_xwdc; + return(OK); + case HSMHV_MOD_XL: + value->rValue = model->HSMHV_xl; + return(OK); + case HSMHV_MOD_XW: + value->rValue = model->HSMHV_xw; + return(OK); + case HSMHV_MOD_SAREF: + value->rValue = model->HSMHV_saref; + return(OK); + case HSMHV_MOD_SBREF: + value->rValue = model->HSMHV_sbref; + return(OK); + case HSMHV_MOD_LL: + value->rValue = model->HSMHV_ll; + return(OK); + case HSMHV_MOD_LLD: + value->rValue = model->HSMHV_lld; + return(OK); + case HSMHV_MOD_LLN: + value->rValue = model->HSMHV_lln; + return(OK); + case HSMHV_MOD_WL: + value->rValue = model->HSMHV_wl; + return(OK); + case HSMHV_MOD_WL1: + value->rValue = model->HSMHV_wl1; + return(OK); + case HSMHV_MOD_WL1P: + value->rValue = model->HSMHV_wl1p; + return(OK); + case HSMHV_MOD_WL2: + value->rValue = model->HSMHV_wl2; + return(OK); + case HSMHV_MOD_WL2P: + value->rValue = model->HSMHV_wl2p; + return(OK); + case HSMHV_MOD_WLD: + value->rValue = model->HSMHV_wld; + return(OK); + case HSMHV_MOD_WLN: + value->rValue = model->HSMHV_wln; + return(OK); + case HSMHV_MOD_XQY: + value->rValue = model->HSMHV_xqy; + return(OK); + case HSMHV_MOD_XQY1: + value->rValue = model->HSMHV_xqy1; + return(OK); + case HSMHV_MOD_XQY2: + value->rValue = model->HSMHV_xqy2; + return(OK); + case HSMHV_MOD_RS: + value->rValue = model->HSMHV_rs; + return(OK); + case HSMHV_MOD_RD: + value->rValue = model->HSMHV_rd; + return(OK); + case HSMHV_MOD_RSH: + value->rValue = model->HSMHV_rsh; + return(OK); + case HSMHV_MOD_RSHG: + value->rValue = model->HSMHV_rshg; + return(OK); + case HSMHV_MOD_VFBC: + value->rValue = model->HSMHV_vfbc; + return(OK); + case HSMHV_MOD_VBI: + value->rValue = model->HSMHV_vbi; + return(OK); + case HSMHV_MOD_NSUBC: + value->rValue = model->HSMHV_nsubc; + return(OK); + case HSMHV_MOD_PARL2: + value->rValue = model->HSMHV_parl2; + return(OK); + case HSMHV_MOD_LP: + value->rValue = model->HSMHV_lp; + return(OK); + case HSMHV_MOD_NSUBP: + value->rValue = model->HSMHV_nsubp; + return(OK); + case HSMHV_MOD_NSUBP0: + value->rValue = model->HSMHV_nsubp0; + return(OK); + case HSMHV_MOD_NSUBWP: + value->rValue = model->HSMHV_nsubwp; + return(OK); + case HSMHV_MOD_SCP1: + value->rValue = model->HSMHV_scp1; + return(OK); + case HSMHV_MOD_SCP2: + value->rValue = model->HSMHV_scp2; + return(OK); + case HSMHV_MOD_SCP3: + value->rValue = model->HSMHV_scp3; + return(OK); + case HSMHV_MOD_SC1: + value->rValue = model->HSMHV_sc1; + return(OK); + case HSMHV_MOD_SC2: + value->rValue = model->HSMHV_sc2; + return(OK); + case HSMHV_MOD_SC3: + value->rValue = model->HSMHV_sc3; + return(OK); + case HSMHV_MOD_SC4: + value->rValue = model->HSMHV_sc4; + return(OK); + case HSMHV_MOD_PGD1: + value->rValue = model->HSMHV_pgd1; + return(OK); + case HSMHV_MOD_PGD2: + value->rValue = model->HSMHV_pgd2; + return(OK); + case HSMHV_MOD_PGD3: + value->rValue = model->HSMHV_pgd3; + return(OK); + case HSMHV_MOD_PGD4: + value->rValue = model->HSMHV_pgd4; + return(OK); + case HSMHV_MOD_NDEP: + value->rValue = model->HSMHV_ndep; + return(OK); + case HSMHV_MOD_NDEPL: + value->rValue = model->HSMHV_ndepl; + return(OK); + case HSMHV_MOD_NDEPLP: + value->rValue = model->HSMHV_ndeplp; + return(OK); + case HSMHV_MOD_NINV: + value->rValue = model->HSMHV_ninv; + return(OK); + case HSMHV_MOD_MUECB0: + value->rValue = model->HSMHV_muecb0; + return(OK); + case HSMHV_MOD_MUECB1: + value->rValue = model->HSMHV_muecb1; + return(OK); + case HSMHV_MOD_MUEPH1: + value->rValue = model->HSMHV_mueph1; + return(OK); + case HSMHV_MOD_MUEPH0: + value->rValue = model->HSMHV_mueph0; + return(OK); + case HSMHV_MOD_MUEPHW: + value->rValue = model->HSMHV_muephw; + return(OK); + case HSMHV_MOD_MUEPWP: + value->rValue = model->HSMHV_muepwp; + return(OK); + case HSMHV_MOD_MUEPHL: + value->rValue = model->HSMHV_muephl; + return(OK); + case HSMHV_MOD_MUEPLP: + value->rValue = model->HSMHV_mueplp; + return(OK); + case HSMHV_MOD_MUEPHS: + value->rValue = model->HSMHV_muephs; + return(OK); + case HSMHV_MOD_MUEPSP: + value->rValue = model->HSMHV_muepsp; + return(OK); + case HSMHV_MOD_VTMP: + value->rValue = model->HSMHV_vtmp; + return(OK); + case HSMHV_MOD_WVTH0: + value->rValue = model->HSMHV_wvth0; + return(OK); + case HSMHV_MOD_MUESR1: + value->rValue = model->HSMHV_muesr1; + return(OK); + case HSMHV_MOD_MUESR0: + value->rValue = model->HSMHV_muesr0; + return(OK); + case HSMHV_MOD_MUESRL: + value->rValue = model->HSMHV_muesrl; + return(OK); + case HSMHV_MOD_MUESLP: + value->rValue = model->HSMHV_mueslp; + return(OK); + case HSMHV_MOD_MUESRW: + value->rValue = model->HSMHV_muesrw; + return(OK); + case HSMHV_MOD_MUESWP: + value->rValue = model->HSMHV_mueswp; + return(OK); + case HSMHV_MOD_BB: + value->rValue = model->HSMHV_bb; + return(OK); + case HSMHV_MOD_SUB1: + value->rValue = model->HSMHV_sub1; + return(OK); + case HSMHV_MOD_SUB2: + value->rValue = model->HSMHV_sub2; + return(OK); + case HSMHV_MOD_SVGS: + value->rValue = model->HSMHV_svgs; + return(OK); + case HSMHV_MOD_SVGSL: + value->rValue = model->HSMHV_svgsl; + return(OK); + case HSMHV_MOD_SVGSLP: + value->rValue = model->HSMHV_svgslp; + return(OK); + case HSMHV_MOD_SVGSW: + value->rValue = model->HSMHV_svgsw; + return(OK); + case HSMHV_MOD_SVGSWP: + value->rValue = model->HSMHV_svgswp; + return(OK); + case HSMHV_MOD_SVBS: + value->rValue = model->HSMHV_svbs; + return(OK); + case HSMHV_MOD_SVBSL: + value->rValue = model->HSMHV_svbsl; + return(OK); + case HSMHV_MOD_SVBSLP: + value->rValue = model->HSMHV_svbslp; + return(OK); + case HSMHV_MOD_SVDS: + value->rValue = model->HSMHV_svds; + return(OK); + case HSMHV_MOD_SLG: + value->rValue = model->HSMHV_slg; + return(OK); + case HSMHV_MOD_SLGL: + value->rValue = model->HSMHV_slgl; + return(OK); + case HSMHV_MOD_SLGLP: + value->rValue = model->HSMHV_slglp; + return(OK); + case HSMHV_MOD_SUB1L: + value->rValue = model->HSMHV_sub1l; + return(OK); + case HSMHV_MOD_SUB1LP: + value->rValue = model->HSMHV_sub1lp; + return(OK); + case HSMHV_MOD_SUB2L: + value->rValue = model->HSMHV_sub2l; + return(OK); + case HSMHV_MOD_FN1: + value->rValue = model->HSMHV_fn1; + return(OK); + case HSMHV_MOD_FN2: + value->rValue = model->HSMHV_fn2; + return(OK); + case HSMHV_MOD_FN3: + value->rValue = model->HSMHV_fn3; + return(OK); + case HSMHV_MOD_FVBS: + value->rValue = model->HSMHV_fvbs; + return(OK); + case HSMHV_MOD_NSTI: + value->rValue = model->HSMHV_nsti; + return(OK); + case HSMHV_MOD_WSTI: + value->rValue = model->HSMHV_wsti; + return(OK); + case HSMHV_MOD_WSTIL: + value->rValue = model->HSMHV_wstil; + return(OK); + case HSMHV_MOD_WSTILP: + value->rValue = model->HSMHV_wstilp; + return(OK); + case HSMHV_MOD_WSTIW: + value->rValue = model->HSMHV_wstiw; + return(OK); + case HSMHV_MOD_WSTIWP: + value->rValue = model->HSMHV_wstiwp; + return(OK); + case HSMHV_MOD_SCSTI1: + value->rValue = model->HSMHV_scsti1; + return(OK); + case HSMHV_MOD_SCSTI2: + value->rValue = model->HSMHV_scsti2; + return(OK); + case HSMHV_MOD_VTHSTI: + value->rValue = model->HSMHV_vthsti; + return(OK); + case HSMHV_MOD_VDSTI: + value->rValue = model->HSMHV_vdsti; + return(OK); + case HSMHV_MOD_MUESTI1: + value->rValue = model->HSMHV_muesti1; + return(OK); + case HSMHV_MOD_MUESTI2: + value->rValue = model->HSMHV_muesti2; + return(OK); + case HSMHV_MOD_MUESTI3: + value->rValue = model->HSMHV_muesti3; + return(OK); + case HSMHV_MOD_NSUBPSTI1: + value->rValue = model->HSMHV_nsubpsti1; + return(OK); + case HSMHV_MOD_NSUBPSTI2: + value->rValue = model->HSMHV_nsubpsti2; + return(OK); + case HSMHV_MOD_NSUBPSTI3: + value->rValue = model->HSMHV_nsubpsti3; + return(OK); + case HSMHV_MOD_LPEXT: + value->rValue = model->HSMHV_lpext; + return(OK); + case HSMHV_MOD_NPEXT: + value->rValue = model->HSMHV_npext; + return(OK); + case HSMHV_MOD_SCP22: + value->rValue = model->HSMHV_scp22; + return(OK); + case HSMHV_MOD_SCP21: + value->rValue = model->HSMHV_scp21; + return(OK); + case HSMHV_MOD_BS1: + value->rValue = model->HSMHV_bs1; + return(OK); + case HSMHV_MOD_BS2: + value->rValue = model->HSMHV_bs2; + return(OK); + case HSMHV_MOD_CGSO: + value->rValue = model->HSMHV_cgso; + return(OK); + case HSMHV_MOD_CGDO: + value->rValue = model->HSMHV_cgdo; + return(OK); + case HSMHV_MOD_CGBO: + value->rValue = model->HSMHV_cgbo; + return(OK); + case HSMHV_MOD_TPOLY: + value->rValue = model->HSMHV_tpoly; + return(OK); + case HSMHV_MOD_JS0: + value->rValue = model->HSMHV_js0; + return(OK); + case HSMHV_MOD_JS0SW: + value->rValue = model->HSMHV_js0sw; + return(OK); + case HSMHV_MOD_NJ: + value->rValue = model->HSMHV_nj; + return(OK); + case HSMHV_MOD_NJSW: + value->rValue = model->HSMHV_njsw; + return(OK); + case HSMHV_MOD_XTI: + value->rValue = model->HSMHV_xti; + return(OK); + case HSMHV_MOD_CJ: + value->rValue = model->HSMHV_cj; + return(OK); + case HSMHV_MOD_CJSW: + value->rValue = model->HSMHV_cjsw; + return(OK); + case HSMHV_MOD_CJSWG: + value->rValue = model->HSMHV_cjswg; + return(OK); + case HSMHV_MOD_MJ: + value->rValue = model->HSMHV_mj; + return(OK); + case HSMHV_MOD_MJSW: + value->rValue = model->HSMHV_mjsw; + return(OK); + case HSMHV_MOD_MJSWG: + value->rValue = model->HSMHV_mjswg; + return(OK); + case HSMHV_MOD_PB: + value->rValue = model->HSMHV_pb; + return(OK); + case HSMHV_MOD_PBSW: + value->rValue = model->HSMHV_pbsw; + return(OK); + case HSMHV_MOD_PBSWG: + value->rValue = model->HSMHV_pbswg; + return(OK); + case HSMHV_MOD_XTI2: + value->rValue = model->HSMHV_xti2; + return(OK); + case HSMHV_MOD_CISB: + value->rValue = model->HSMHV_cisb; + return(OK); + case HSMHV_MOD_CVB: + value->rValue = model->HSMHV_cvb; + return(OK); + case HSMHV_MOD_CTEMP: + value->rValue = model->HSMHV_ctemp; + return(OK); + case HSMHV_MOD_CISBK: + value->rValue = model->HSMHV_cisbk; + return(OK); + case HSMHV_MOD_CVBK: + value->rValue = model->HSMHV_cvbk; + return(OK); + case HSMHV_MOD_DIVX: + value->rValue = model->HSMHV_divx; + return(OK); + case HSMHV_MOD_CLM1: + value->rValue = model->HSMHV_clm1; + return(OK); + case HSMHV_MOD_CLM2: + value->rValue = model->HSMHV_clm2; + return(OK); + case HSMHV_MOD_CLM3: + value->rValue = model->HSMHV_clm3; + return(OK); + case HSMHV_MOD_CLM5: + value->rValue = model->HSMHV_clm5; + return(OK); + case HSMHV_MOD_CLM6: + value->rValue = model->HSMHV_clm6; + return(OK); + case HSMHV_MOD_MUETMP: + value->rValue = model->HSMHV_muetmp; + return(OK); + case HSMHV_MOD_VOVER: + value->rValue = model->HSMHV_vover; + return(OK); + case HSMHV_MOD_VOVERP: + value->rValue = model->HSMHV_voverp; + return(OK); + case HSMHV_MOD_VOVERS: + value->rValue = model->HSMHV_vovers; + return(OK); + case HSMHV_MOD_VOVERSP: + value->rValue = model->HSMHV_voversp; + return(OK); + case HSMHV_MOD_WFC: + value->rValue = model->HSMHV_wfc; + return(OK); + case HSMHV_MOD_NSUBCW: + value->rValue = model->HSMHV_nsubcw; + return(OK); + case HSMHV_MOD_NSUBCWP: + value->rValue = model->HSMHV_nsubcwp; + return(OK); + case HSMHV_MOD_QME1: + value->rValue = model->HSMHV_qme1; + return(OK); + case HSMHV_MOD_QME2: + value->rValue = model->HSMHV_qme2; + return(OK); + case HSMHV_MOD_QME3: + value->rValue = model->HSMHV_qme3; + return(OK); + case HSMHV_MOD_GIDL1: + value->rValue = model->HSMHV_gidl1; + return(OK); + case HSMHV_MOD_GIDL2: + value->rValue = model->HSMHV_gidl2; + return(OK); + case HSMHV_MOD_GIDL3: + value->rValue = model->HSMHV_gidl3; + return(OK); + case HSMHV_MOD_GIDL4: + value->rValue = model->HSMHV_gidl4; + return(OK); + case HSMHV_MOD_GIDL5: + value->rValue = model->HSMHV_gidl5; + return(OK); + case HSMHV_MOD_GLEAK1: + value->rValue = model->HSMHV_gleak1; + return(OK); + case HSMHV_MOD_GLEAK2: + value->rValue = model->HSMHV_gleak2; + return(OK); + case HSMHV_MOD_GLEAK3: + value->rValue = model->HSMHV_gleak3; + return(OK); + case HSMHV_MOD_GLEAK4: + value->rValue = model->HSMHV_gleak4; + return(OK); + case HSMHV_MOD_GLEAK5: + value->rValue = model->HSMHV_gleak5; + return(OK); + case HSMHV_MOD_GLEAK6: + value->rValue = model->HSMHV_gleak6; + return(OK); + case HSMHV_MOD_GLEAK7: + value->rValue = model->HSMHV_gleak7; + return(OK); + case HSMHV_MOD_GLPART1: + value->rValue = model->HSMHV_glpart1; + return(OK); + case HSMHV_MOD_GLKSD1: + value->rValue = model->HSMHV_glksd1; + return(OK); + case HSMHV_MOD_GLKSD2: + value->rValue = model->HSMHV_glksd2; + return(OK); + case HSMHV_MOD_GLKSD3: + value->rValue = model->HSMHV_glksd3; + return(OK); + case HSMHV_MOD_GLKB1: + value->rValue = model->HSMHV_glkb1; + return(OK); + case HSMHV_MOD_GLKB2: + value->rValue = model->HSMHV_glkb2; + return(OK); + case HSMHV_MOD_GLKB3: + value->rValue = model->HSMHV_glkb3; + return(OK); + case HSMHV_MOD_EGIG: + value->rValue = model->HSMHV_egig; + return(OK); + case HSMHV_MOD_IGTEMP2: + value->rValue = model->HSMHV_igtemp2; + return(OK); + case HSMHV_MOD_IGTEMP3: + value->rValue = model->HSMHV_igtemp3; + return(OK); + case HSMHV_MOD_VZADD0: + value->rValue = model->HSMHV_vzadd0; + return(OK); + case HSMHV_MOD_PZADD0: + value->rValue = model->HSMHV_pzadd0; + return(OK); + case HSMHV_MOD_NFTRP: + value->rValue = model->HSMHV_nftrp; + return(OK); + case HSMHV_MOD_NFALP: + value->rValue = model->HSMHV_nfalp; + return(OK); + case HSMHV_MOD_CIT: + value->rValue = model->HSMHV_cit; + return(OK); + case HSMHV_MOD_FALPH: + value->rValue = model->HSMHV_falph; + return(OK); + case HSMHV_MOD_KAPPA: + value->rValue = model->HSMHV_kappa; + return(OK); + case HSMHV_MOD_PTHROU: + value->rValue = model->HSMHV_pthrou; + return(OK); + case HSMHV_MOD_VDIFFJ: + value->rValue = model->HSMHV_vdiffj; + return(OK); + case HSMHV_MOD_DLY1: + value->rValue = model->HSMHV_dly1; + return(OK); + case HSMHV_MOD_DLY2: + value->rValue = model->HSMHV_dly2; + return(OK); + case HSMHV_MOD_DLY3: + value->rValue = model->HSMHV_dly3; + return(OK); + case HSMHV_MOD_DLYOV: + value->rValue = model->HSMHV_dlyov; + return(OK); + + + case HSMHV_MOD_TNOM: + value->rValue = model->HSMHV_tnom; + return(OK); + case HSMHV_MOD_OVSLP: + value->rValue = model->HSMHV_ovslp; + return(OK); + case HSMHV_MOD_OVMAG: + value->rValue = model->HSMHV_ovmag; + return(OK); + case HSMHV_MOD_GBMIN: + value->rValue = model->HSMHV_gbmin; + return(OK); + case HSMHV_MOD_RBPB: + value->rValue = model->HSMHV_rbpb; + return(OK); + case HSMHV_MOD_RBPD: + value->rValue = model->HSMHV_rbpd; + return(OK); + case HSMHV_MOD_RBPS: + value->rValue = model->HSMHV_rbps; + return(OK); + case HSMHV_MOD_RBDB: + value->rValue = model->HSMHV_rbdb; + return(OK); + case HSMHV_MOD_RBSB: + value->rValue = model->HSMHV_rbsb; + return(OK); + case HSMHV_MOD_IBPC1: + value->rValue = model->HSMHV_ibpc1; + return(OK); + case HSMHV_MOD_IBPC2: + value->rValue = model->HSMHV_ibpc2; + return(OK); + case HSMHV_MOD_MPHDFM: + value->rValue = model->HSMHV_mphdfm; + return(OK); + case HSMHV_MOD_RDVG11: + value->rValue = model->HSMHV_rdvg11; + return(OK); + case HSMHV_MOD_RDVG12: + value->rValue = model->HSMHV_rdvg12; + return(OK); + case HSMHV_MOD_RTH0: /* Self-heating model */ + value->rValue = model->HSMHV_rth0; + return(OK); + case HSMHV_MOD_CTH0: /* Self-heating model */ + value->rValue = model->HSMHV_cth0; + return(OK); + case HSMHV_MOD_POWRAT: /* Self-heating model */ + value->rValue = model->HSMHV_powrat; + return(OK); + case HSMHV_MOD_RTHTEMP1: /* Self-heating model */ + value->rValue = model->HSMHV_rthtemp1; + return(OK); + case HSMHV_MOD_RTHTEMP2: /* Self-heating model */ + value->rValue = model->HSMHV_rthtemp2; + return(OK); + case HSMHV_MOD_PRATTEMP1: /* Self-heating model */ + value->rValue = model->HSMHV_prattemp1; + return(OK); + case HSMHV_MOD_PRATTEMP2: /* Self-heating model */ + value->rValue = model->HSMHV_prattemp2; + return(OK); + + + + case HSMHV_MOD_TCJBD: /* Self-heating model */ + value->rValue = model->HSMHV_tcjbd; + return(OK); + case HSMHV_MOD_TCJBS: /* Self-heating model */ + value->rValue = model->HSMHV_tcjbs; + return(OK); + case HSMHV_MOD_TCJBDSW: /* Self-heating model */ + value->rValue = model->HSMHV_tcjbdsw; + return(OK); + case HSMHV_MOD_TCJBSSW: /* Self-heating model */ + value->rValue = model->HSMHV_tcjbssw; + return(OK); + case HSMHV_MOD_TCJBDSWG: /* Self-heating model */ + value->rValue = model->HSMHV_tcjbdswg; + return(OK); + case HSMHV_MOD_TCJBSSWG: /* Self-heating model */ + value->rValue = model->HSMHV_tcjbsswg; + return(OK); +/* case HSMHV_MOD_WTH0: */ +/* value->rValue = model->HSMHV_wth0; */ +/* return(OK); */ + case HSMHV_MOD_QDFTVD: + value->rValue = model->HSMHV_qdftvd; + return(OK); + case HSMHV_MOD_XLDLD: + value->rValue = model->HSMHV_xldld; + return(OK); + case HSMHV_MOD_XWDLD: + value->rValue = model->HSMHV_xwdld; + return(OK); + case HSMHV_MOD_RDVD: + value->rValue = model->HSMHV_rdvd; + return(OK); + case HSMHV_MOD_RD20: + value->rValue = model->HSMHV_rd20; + return(OK); + case HSMHV_MOD_QOVSM: + value->rValue = model->HSMHV_qovsm; + return(OK); + case HSMHV_MOD_LDRIFT: + value->rValue = model->HSMHV_ldrift; + return(OK); + case HSMHV_MOD_RD21: + value->rValue = model->HSMHV_rd21; + return(OK); + case HSMHV_MOD_RD22: + value->rValue = model->HSMHV_rd22; + return(OK); + case HSMHV_MOD_RD22D: + value->rValue = model->HSMHV_rd22d; + return(OK); + case HSMHV_MOD_RD23: + value->rValue = model->HSMHV_rd23; + return(OK); + case HSMHV_MOD_RD24: + value->rValue = model->HSMHV_rd24; + return(OK); + case HSMHV_MOD_RD25: + value->rValue = model->HSMHV_rd25; + return(OK); + case HSMHV_MOD_RD26: + value->rValue = model->HSMHV_rd26; + return(OK); + case HSMHV_MOD_RDVDL: + value->rValue = model->HSMHV_rdvdl; + return(OK); + case HSMHV_MOD_RDVDLP: + value->rValue = model->HSMHV_rdvdlp; + return(OK); + case HSMHV_MOD_RDVDS: + value->rValue = model->HSMHV_rdvds; + return(OK); + case HSMHV_MOD_RDVDSP: + value->rValue = model->HSMHV_rdvdsp; + return(OK); + case HSMHV_MOD_RD23L: + value->rValue = model->HSMHV_rd23l; + return(OK); + case HSMHV_MOD_RD23LP: + value->rValue = model->HSMHV_rd23lp; + return(OK); + case HSMHV_MOD_RD23S: + value->rValue = model->HSMHV_rd23s; + return(OK); + case HSMHV_MOD_RD23SP: + value->rValue = model->HSMHV_rd23sp; + return(OK); + case HSMHV_MOD_RDS: + value->rValue = model->HSMHV_rds; + return(OK); + case HSMHV_MOD_RDSP: + value->rValue = model->HSMHV_rdsp; + return(OK); + case HSMHV_MOD_RDTEMP1: + value->rValue = model->HSMHV_rdtemp1; + return(OK); + case HSMHV_MOD_RDTEMP2: + value->rValue = model->HSMHV_rdtemp2; + return(OK); + case HSMHV_MOD_RTH0R: + value->rValue = model->HSMHV_rth0r; + return(OK); + case HSMHV_MOD_RDVDTEMP1: + value->rValue = model->HSMHV_rdvdtemp1; + return(OK); + case HSMHV_MOD_RDVDTEMP2: + value->rValue = model->HSMHV_rdvdtemp2; + return(OK); + case HSMHV_MOD_RTH0W: + value->rValue = model->HSMHV_rth0w; + return(OK); + case HSMHV_MOD_RTH0WP: + value->rValue = model->HSMHV_rth0wp; + return(OK); + case HSMHV_MOD_CVDSOVER: + value->rValue = model->HSMHV_cvdsover; + return(OK); + + case HSMHV_MOD_NINVD: + value->rValue = model->HSMHV_ninvd; + return(OK); + case HSMHV_MOD_NINVDW: + value->rValue = model->HSMHV_ninvdw; + return(OK); + case HSMHV_MOD_NINVDWP: + value->rValue = model->HSMHV_ninvdwp; + return(OK); + case HSMHV_MOD_NINVDT1: + value->rValue = model->HSMHV_ninvdt1; + return(OK); + case HSMHV_MOD_NINVDT2: + value->rValue = model->HSMHV_ninvdt2; + return(OK); + case HSMHV_MOD_VBSMIN: + value->rValue = model->HSMHV_vbsmin; + return(OK); + case HSMHV_MOD_RDVB: + value->rValue = model->HSMHV_rdvb; + return(OK); + case HSMHV_MOD_RTH0NF: + value->rValue = model->HSMHV_rth0nf; + return(OK); + + case HSMHV_MOD_RDVSUB: + value->rValue = model->HSMHV_rdvsub; + return(OK); + case HSMHV_MOD_RDVDSUB: + value->rValue = model->HSMHV_rdvdsub; + return(OK); + case HSMHV_MOD_DDRIFT: + value->rValue = model->HSMHV_ddrift; + return(OK); + case HSMHV_MOD_VBISUB: + value->rValue = model->HSMHV_vbisub; + return(OK); + case HSMHV_MOD_NSUBSUB: + value->rValue = model->HSMHV_nsubsub; + return(OK); + case HSMHV_MOD_SHEMAX: + value->rValue = model->HSMHV_shemax; + return(OK); + + /* binning parameters */ + case HSMHV_MOD_LMIN: + value->rValue = model->HSMHV_lmin; + return(OK); + case HSMHV_MOD_LMAX: + value->rValue = model->HSMHV_lmax; + return(OK); + case HSMHV_MOD_WMIN: + value->rValue = model->HSMHV_wmin; + return(OK); + case HSMHV_MOD_WMAX: + value->rValue = model->HSMHV_wmax; + return(OK); + case HSMHV_MOD_LBINN: + value->rValue = model->HSMHV_lbinn; + return(OK); + case HSMHV_MOD_WBINN: + value->rValue = model->HSMHV_wbinn; + return(OK); + + /* Length dependence */ + case HSMHV_MOD_LVMAX: + value->rValue = model->HSMHV_lvmax; + return(OK); + case HSMHV_MOD_LBGTMP1: + value->rValue = model->HSMHV_lbgtmp1; + return(OK); + case HSMHV_MOD_LBGTMP2: + value->rValue = model->HSMHV_lbgtmp2; + return(OK); + case HSMHV_MOD_LEG0: + value->rValue = model->HSMHV_leg0; + return(OK); + case HSMHV_MOD_LVFBOVER: + value->rValue = model->HSMHV_lvfbover; + return(OK); + case HSMHV_MOD_LNOVER: + value->rValue = model->HSMHV_lnover; + return(OK); + case HSMHV_MOD_LNOVERS: + value->rValue = model->HSMHV_lnovers; + return(OK); + case HSMHV_MOD_LWL2: + value->rValue = model->HSMHV_lwl2; + return(OK); + case HSMHV_MOD_LVFBC: + value->rValue = model->HSMHV_lvfbc; + return(OK); + case HSMHV_MOD_LNSUBC: + value->rValue = model->HSMHV_lnsubc; + return(OK); + case HSMHV_MOD_LNSUBP: + value->rValue = model->HSMHV_lnsubp; + return(OK); + case HSMHV_MOD_LSCP1: + value->rValue = model->HSMHV_lscp1; + return(OK); + case HSMHV_MOD_LSCP2: + value->rValue = model->HSMHV_lscp2; + return(OK); + case HSMHV_MOD_LSCP3: + value->rValue = model->HSMHV_lscp3; + return(OK); + case HSMHV_MOD_LSC1: + value->rValue = model->HSMHV_lsc1; + return(OK); + case HSMHV_MOD_LSC2: + value->rValue = model->HSMHV_lsc2; + return(OK); + case HSMHV_MOD_LSC3: + value->rValue = model->HSMHV_lsc3; + return(OK); + case HSMHV_MOD_LPGD1: + value->rValue = model->HSMHV_lpgd1; + return(OK); + case HSMHV_MOD_LPGD3: + value->rValue = model->HSMHV_lpgd3; + return(OK); + case HSMHV_MOD_LNDEP: + value->rValue = model->HSMHV_lndep; + return(OK); + case HSMHV_MOD_LNINV: + value->rValue = model->HSMHV_lninv; + return(OK); + case HSMHV_MOD_LMUECB0: + value->rValue = model->HSMHV_lmuecb0; + return(OK); + case HSMHV_MOD_LMUECB1: + value->rValue = model->HSMHV_lmuecb1; + return(OK); + case HSMHV_MOD_LMUEPH1: + value->rValue = model->HSMHV_lmueph1; + return(OK); + case HSMHV_MOD_LVTMP: + value->rValue = model->HSMHV_lvtmp; + return(OK); + case HSMHV_MOD_LWVTH0: + value->rValue = model->HSMHV_lwvth0; + return(OK); + case HSMHV_MOD_LMUESR1: + value->rValue = model->HSMHV_lmuesr1; + return(OK); + case HSMHV_MOD_LMUETMP: + value->rValue = model->HSMHV_lmuetmp; + return(OK); + case HSMHV_MOD_LSUB1: + value->rValue = model->HSMHV_lsub1; + return(OK); + case HSMHV_MOD_LSUB2: + value->rValue = model->HSMHV_lsub2; + return(OK); + case HSMHV_MOD_LSVDS: + value->rValue = model->HSMHV_lsvds; + return(OK); + case HSMHV_MOD_LSVBS: + value->rValue = model->HSMHV_lsvbs; + return(OK); + case HSMHV_MOD_LSVGS: + value->rValue = model->HSMHV_lsvgs; + return(OK); + case HSMHV_MOD_LFN1: + value->rValue = model->HSMHV_lfn1; + return(OK); + case HSMHV_MOD_LFN2: + value->rValue = model->HSMHV_lfn2; + return(OK); + case HSMHV_MOD_LFN3: + value->rValue = model->HSMHV_lfn3; + return(OK); + case HSMHV_MOD_LFVBS: + value->rValue = model->HSMHV_lfvbs; + return(OK); + case HSMHV_MOD_LNSTI: + value->rValue = model->HSMHV_lnsti; + return(OK); + case HSMHV_MOD_LWSTI: + value->rValue = model->HSMHV_lwsti; + return(OK); + case HSMHV_MOD_LSCSTI1: + value->rValue = model->HSMHV_lscsti1; + return(OK); + case HSMHV_MOD_LSCSTI2: + value->rValue = model->HSMHV_lscsti2; + return(OK); + case HSMHV_MOD_LVTHSTI: + value->rValue = model->HSMHV_lvthsti; + return(OK); + case HSMHV_MOD_LMUESTI1: + value->rValue = model->HSMHV_lmuesti1; + return(OK); + case HSMHV_MOD_LMUESTI2: + value->rValue = model->HSMHV_lmuesti2; + return(OK); + case HSMHV_MOD_LMUESTI3: + value->rValue = model->HSMHV_lmuesti3; + return(OK); + case HSMHV_MOD_LNSUBPSTI1: + value->rValue = model->HSMHV_lnsubpsti1; + return(OK); + case HSMHV_MOD_LNSUBPSTI2: + value->rValue = model->HSMHV_lnsubpsti2; + return(OK); + case HSMHV_MOD_LNSUBPSTI3: + value->rValue = model->HSMHV_lnsubpsti3; + return(OK); + case HSMHV_MOD_LCGSO: + value->rValue = model->HSMHV_lcgso; + return(OK); + case HSMHV_MOD_LCGDO: + value->rValue = model->HSMHV_lcgdo; + return(OK); + case HSMHV_MOD_LJS0: + value->rValue = model->HSMHV_ljs0; + return(OK); + case HSMHV_MOD_LJS0SW: + value->rValue = model->HSMHV_ljs0sw; + return(OK); + case HSMHV_MOD_LNJ: + value->rValue = model->HSMHV_lnj; + return(OK); + case HSMHV_MOD_LCISBK: + value->rValue = model->HSMHV_lcisbk; + return(OK); + case HSMHV_MOD_LCLM1: + value->rValue = model->HSMHV_lclm1; + return(OK); + case HSMHV_MOD_LCLM2: + value->rValue = model->HSMHV_lclm2; + return(OK); + case HSMHV_MOD_LCLM3: + value->rValue = model->HSMHV_lclm3; + return(OK); + case HSMHV_MOD_LWFC: + value->rValue = model->HSMHV_lwfc; + return(OK); + case HSMHV_MOD_LGIDL1: + value->rValue = model->HSMHV_lgidl1; + return(OK); + case HSMHV_MOD_LGIDL2: + value->rValue = model->HSMHV_lgidl2; + return(OK); + case HSMHV_MOD_LGLEAK1: + value->rValue = model->HSMHV_lgleak1; + return(OK); + case HSMHV_MOD_LGLEAK2: + value->rValue = model->HSMHV_lgleak2; + return(OK); + case HSMHV_MOD_LGLEAK3: + value->rValue = model->HSMHV_lgleak3; + return(OK); + case HSMHV_MOD_LGLEAK6: + value->rValue = model->HSMHV_lgleak6; + return(OK); + case HSMHV_MOD_LGLKSD1: + value->rValue = model->HSMHV_lglksd1; + return(OK); + case HSMHV_MOD_LGLKSD2: + value->rValue = model->HSMHV_lglksd2; + return(OK); + case HSMHV_MOD_LGLKB1: + value->rValue = model->HSMHV_lglkb1; + return(OK); + case HSMHV_MOD_LGLKB2: + value->rValue = model->HSMHV_lglkb2; + return(OK); + case HSMHV_MOD_LNFTRP: + value->rValue = model->HSMHV_lnftrp; + return(OK); + case HSMHV_MOD_LNFALP: + value->rValue = model->HSMHV_lnfalp; + return(OK); + case HSMHV_MOD_LPTHROU: + value->rValue = model->HSMHV_lpthrou; + return(OK); + case HSMHV_MOD_LVDIFFJ: + value->rValue = model->HSMHV_lvdiffj; + return(OK); + case HSMHV_MOD_LIBPC1: + value->rValue = model->HSMHV_libpc1; + return(OK); + case HSMHV_MOD_LIBPC2: + value->rValue = model->HSMHV_libpc2; + return(OK); + case HSMHV_MOD_LCGBO: + value->rValue = model->HSMHV_lcgbo; + return(OK); + case HSMHV_MOD_LCVDSOVER: + value->rValue = model->HSMHV_lcvdsover; + return(OK); + case HSMHV_MOD_LFALPH: + value->rValue = model->HSMHV_lfalph; + return(OK); + case HSMHV_MOD_LNPEXT: + value->rValue = model->HSMHV_lnpext; + return(OK); + case HSMHV_MOD_LPOWRAT: + value->rValue = model->HSMHV_lpowrat; + return(OK); + case HSMHV_MOD_LRD: + value->rValue = model->HSMHV_lrd; + return(OK); + case HSMHV_MOD_LRD22: + value->rValue = model->HSMHV_lrd22; + return(OK); + case HSMHV_MOD_LRD23: + value->rValue = model->HSMHV_lrd23; + return(OK); + case HSMHV_MOD_LRD24: + value->rValue = model->HSMHV_lrd24; + return(OK); + case HSMHV_MOD_LRDICT1: + value->rValue = model->HSMHV_lrdict1; + return(OK); + case HSMHV_MOD_LRDOV13: + value->rValue = model->HSMHV_lrdov13; + return(OK); + case HSMHV_MOD_LRDSLP1: + value->rValue = model->HSMHV_lrdslp1; + return(OK); + case HSMHV_MOD_LRDVB: + value->rValue = model->HSMHV_lrdvb; + return(OK); + case HSMHV_MOD_LRDVD: + value->rValue = model->HSMHV_lrdvd; + return(OK); + case HSMHV_MOD_LRDVG11: + value->rValue = model->HSMHV_lrdvg11; + return(OK); + case HSMHV_MOD_LRS: + value->rValue = model->HSMHV_lrs; + return(OK); + case HSMHV_MOD_LRTH0: + value->rValue = model->HSMHV_lrth0; + return(OK); + case HSMHV_MOD_LVOVER: + value->rValue = model->HSMHV_lvover; + return(OK); + + /* Width dependence */ + case HSMHV_MOD_WVMAX: + value->rValue = model->HSMHV_wvmax; + return(OK); + case HSMHV_MOD_WBGTMP1: + value->rValue = model->HSMHV_wbgtmp1; + return(OK); + case HSMHV_MOD_WBGTMP2: + value->rValue = model->HSMHV_wbgtmp2; + return(OK); + case HSMHV_MOD_WEG0: + value->rValue = model->HSMHV_weg0; + return(OK); + case HSMHV_MOD_WVFBOVER: + value->rValue = model->HSMHV_wvfbover; + return(OK); + case HSMHV_MOD_WNOVER: + value->rValue = model->HSMHV_wnover; + return(OK); + case HSMHV_MOD_WNOVERS: + value->rValue = model->HSMHV_wnovers; + return(OK); + case HSMHV_MOD_WWL2: + value->rValue = model->HSMHV_wwl2; + return(OK); + case HSMHV_MOD_WVFBC: + value->rValue = model->HSMHV_wvfbc; + return(OK); + case HSMHV_MOD_WNSUBC: + value->rValue = model->HSMHV_wnsubc; + return(OK); + case HSMHV_MOD_WNSUBP: + value->rValue = model->HSMHV_wnsubp; + return(OK); + case HSMHV_MOD_WSCP1: + value->rValue = model->HSMHV_wscp1; + return(OK); + case HSMHV_MOD_WSCP2: + value->rValue = model->HSMHV_wscp2; + return(OK); + case HSMHV_MOD_WSCP3: + value->rValue = model->HSMHV_wscp3; + return(OK); + case HSMHV_MOD_WSC1: + value->rValue = model->HSMHV_wsc1; + return(OK); + case HSMHV_MOD_WSC2: + value->rValue = model->HSMHV_wsc2; + return(OK); + case HSMHV_MOD_WSC3: + value->rValue = model->HSMHV_wsc3; + return(OK); + case HSMHV_MOD_WPGD1: + value->rValue = model->HSMHV_wpgd1; + return(OK); + case HSMHV_MOD_WPGD3: + value->rValue = model->HSMHV_wpgd3; + return(OK); + case HSMHV_MOD_WNDEP: + value->rValue = model->HSMHV_wndep; + return(OK); + case HSMHV_MOD_WNINV: + value->rValue = model->HSMHV_wninv; + return(OK); + case HSMHV_MOD_WMUECB0: + value->rValue = model->HSMHV_wmuecb0; + return(OK); + case HSMHV_MOD_WMUECB1: + value->rValue = model->HSMHV_wmuecb1; + return(OK); + case HSMHV_MOD_WMUEPH1: + value->rValue = model->HSMHV_wmueph1; + return(OK); + case HSMHV_MOD_WVTMP: + value->rValue = model->HSMHV_wvtmp; + return(OK); + case HSMHV_MOD_WWVTH0: + value->rValue = model->HSMHV_wwvth0; + return(OK); + case HSMHV_MOD_WMUESR1: + value->rValue = model->HSMHV_wmuesr1; + return(OK); + case HSMHV_MOD_WMUETMP: + value->rValue = model->HSMHV_wmuetmp; + return(OK); + case HSMHV_MOD_WSUB1: + value->rValue = model->HSMHV_wsub1; + return(OK); + case HSMHV_MOD_WSUB2: + value->rValue = model->HSMHV_wsub2; + return(OK); + case HSMHV_MOD_WSVDS: + value->rValue = model->HSMHV_wsvds; + return(OK); + case HSMHV_MOD_WSVBS: + value->rValue = model->HSMHV_wsvbs; + return(OK); + case HSMHV_MOD_WSVGS: + value->rValue = model->HSMHV_wsvgs; + return(OK); + case HSMHV_MOD_WFN1: + value->rValue = model->HSMHV_wfn1; + return(OK); + case HSMHV_MOD_WFN2: + value->rValue = model->HSMHV_wfn2; + return(OK); + case HSMHV_MOD_WFN3: + value->rValue = model->HSMHV_wfn3; + return(OK); + case HSMHV_MOD_WFVBS: + value->rValue = model->HSMHV_wfvbs; + return(OK); + case HSMHV_MOD_WNSTI: + value->rValue = model->HSMHV_wnsti; + return(OK); + case HSMHV_MOD_WWSTI: + value->rValue = model->HSMHV_wwsti; + return(OK); + case HSMHV_MOD_WSCSTI1: + value->rValue = model->HSMHV_wscsti1; + return(OK); + case HSMHV_MOD_WSCSTI2: + value->rValue = model->HSMHV_wscsti2; + return(OK); + case HSMHV_MOD_WVTHSTI: + value->rValue = model->HSMHV_wvthsti; + return(OK); + case HSMHV_MOD_WMUESTI1: + value->rValue = model->HSMHV_wmuesti1; + return(OK); + case HSMHV_MOD_WMUESTI2: + value->rValue = model->HSMHV_wmuesti2; + return(OK); + case HSMHV_MOD_WMUESTI3: + value->rValue = model->HSMHV_wmuesti3; + return(OK); + case HSMHV_MOD_WNSUBPSTI1: + value->rValue = model->HSMHV_wnsubpsti1; + return(OK); + case HSMHV_MOD_WNSUBPSTI2: + value->rValue = model->HSMHV_wnsubpsti2; + return(OK); + case HSMHV_MOD_WNSUBPSTI3: + value->rValue = model->HSMHV_wnsubpsti3; + return(OK); + case HSMHV_MOD_WCGSO: + value->rValue = model->HSMHV_wcgso; + return(OK); + case HSMHV_MOD_WCGDO: + value->rValue = model->HSMHV_wcgdo; + return(OK); + case HSMHV_MOD_WJS0: + value->rValue = model->HSMHV_wjs0; + return(OK); + case HSMHV_MOD_WJS0SW: + value->rValue = model->HSMHV_wjs0sw; + return(OK); + case HSMHV_MOD_WNJ: + value->rValue = model->HSMHV_wnj; + return(OK); + case HSMHV_MOD_WCISBK: + value->rValue = model->HSMHV_wcisbk; + return(OK); + case HSMHV_MOD_WCLM1: + value->rValue = model->HSMHV_wclm1; + return(OK); + case HSMHV_MOD_WCLM2: + value->rValue = model->HSMHV_wclm2; + return(OK); + case HSMHV_MOD_WCLM3: + value->rValue = model->HSMHV_wclm3; + return(OK); + case HSMHV_MOD_WWFC: + value->rValue = model->HSMHV_wwfc; + return(OK); + case HSMHV_MOD_WGIDL1: + value->rValue = model->HSMHV_wgidl1; + return(OK); + case HSMHV_MOD_WGIDL2: + value->rValue = model->HSMHV_wgidl2; + return(OK); + case HSMHV_MOD_WGLEAK1: + value->rValue = model->HSMHV_wgleak1; + return(OK); + case HSMHV_MOD_WGLEAK2: + value->rValue = model->HSMHV_wgleak2; + return(OK); + case HSMHV_MOD_WGLEAK3: + value->rValue = model->HSMHV_wgleak3; + return(OK); + case HSMHV_MOD_WGLEAK6: + value->rValue = model->HSMHV_wgleak6; + return(OK); + case HSMHV_MOD_WGLKSD1: + value->rValue = model->HSMHV_wglksd1; + return(OK); + case HSMHV_MOD_WGLKSD2: + value->rValue = model->HSMHV_wglksd2; + return(OK); + case HSMHV_MOD_WGLKB1: + value->rValue = model->HSMHV_wglkb1; + return(OK); + case HSMHV_MOD_WGLKB2: + value->rValue = model->HSMHV_wglkb2; + return(OK); + case HSMHV_MOD_WNFTRP: + value->rValue = model->HSMHV_wnftrp; + return(OK); + case HSMHV_MOD_WNFALP: + value->rValue = model->HSMHV_wnfalp; + return(OK); + case HSMHV_MOD_WPTHROU: + value->rValue = model->HSMHV_wpthrou; + return(OK); + case HSMHV_MOD_WVDIFFJ: + value->rValue = model->HSMHV_wvdiffj; + return(OK); + case HSMHV_MOD_WIBPC1: + value->rValue = model->HSMHV_wibpc1; + return(OK); + case HSMHV_MOD_WIBPC2: + value->rValue = model->HSMHV_wibpc2; + return(OK); + case HSMHV_MOD_WCGBO: + value->rValue = model->HSMHV_wcgbo; + return(OK); + case HSMHV_MOD_WCVDSOVER: + value->rValue = model->HSMHV_wcvdsover; + return(OK); + case HSMHV_MOD_WFALPH: + value->rValue = model->HSMHV_wfalph; + return(OK); + case HSMHV_MOD_WNPEXT: + value->rValue = model->HSMHV_wnpext; + return(OK); + case HSMHV_MOD_WPOWRAT: + value->rValue = model->HSMHV_wpowrat; + return(OK); + case HSMHV_MOD_WRD: + value->rValue = model->HSMHV_wrd; + return(OK); + case HSMHV_MOD_WRD22: + value->rValue = model->HSMHV_wrd22; + return(OK); + case HSMHV_MOD_WRD23: + value->rValue = model->HSMHV_wrd23; + return(OK); + case HSMHV_MOD_WRD24: + value->rValue = model->HSMHV_wrd24; + return(OK); + case HSMHV_MOD_WRDICT1: + value->rValue = model->HSMHV_wrdict1; + return(OK); + case HSMHV_MOD_WRDOV13: + value->rValue = model->HSMHV_wrdov13; + return(OK); + case HSMHV_MOD_WRDSLP1: + value->rValue = model->HSMHV_wrdslp1; + return(OK); + case HSMHV_MOD_WRDVB: + value->rValue = model->HSMHV_wrdvb; + return(OK); + case HSMHV_MOD_WRDVD: + value->rValue = model->HSMHV_wrdvd; + return(OK); + case HSMHV_MOD_WRDVG11: + value->rValue = model->HSMHV_wrdvg11; + return(OK); + case HSMHV_MOD_WRS: + value->rValue = model->HSMHV_wrs; + return(OK); + case HSMHV_MOD_WRTH0: + value->rValue = model->HSMHV_wrth0; + return(OK); + case HSMHV_MOD_WVOVER: + value->rValue = model->HSMHV_wvover; + return(OK); + + /* Cross-term dependence */ + case HSMHV_MOD_PVMAX: + value->rValue = model->HSMHV_pvmax; + return(OK); + case HSMHV_MOD_PBGTMP1: + value->rValue = model->HSMHV_pbgtmp1; + return(OK); + case HSMHV_MOD_PBGTMP2: + value->rValue = model->HSMHV_pbgtmp2; + return(OK); + case HSMHV_MOD_PEG0: + value->rValue = model->HSMHV_peg0; + return(OK); + case HSMHV_MOD_PVFBOVER: + value->rValue = model->HSMHV_pvfbover; + return(OK); + case HSMHV_MOD_PNOVER: + value->rValue = model->HSMHV_pnover; + return(OK); + case HSMHV_MOD_PNOVERS: + value->rValue = model->HSMHV_pnovers; + return(OK); + case HSMHV_MOD_PWL2: + value->rValue = model->HSMHV_pwl2; + return(OK); + case HSMHV_MOD_PVFBC: + value->rValue = model->HSMHV_pvfbc; + return(OK); + case HSMHV_MOD_PNSUBC: + value->rValue = model->HSMHV_pnsubc; + return(OK); + case HSMHV_MOD_PNSUBP: + value->rValue = model->HSMHV_pnsubp; + return(OK); + case HSMHV_MOD_PSCP1: + value->rValue = model->HSMHV_pscp1; + return(OK); + case HSMHV_MOD_PSCP2: + value->rValue = model->HSMHV_pscp2; + return(OK); + case HSMHV_MOD_PSCP3: + value->rValue = model->HSMHV_pscp3; + return(OK); + case HSMHV_MOD_PSC1: + value->rValue = model->HSMHV_psc1; + return(OK); + case HSMHV_MOD_PSC2: + value->rValue = model->HSMHV_psc2; + return(OK); + case HSMHV_MOD_PSC3: + value->rValue = model->HSMHV_psc3; + return(OK); + case HSMHV_MOD_PPGD1: + value->rValue = model->HSMHV_ppgd1; + return(OK); + case HSMHV_MOD_PPGD3: + value->rValue = model->HSMHV_ppgd3; + return(OK); + case HSMHV_MOD_PNDEP: + value->rValue = model->HSMHV_pndep; + return(OK); + case HSMHV_MOD_PNINV: + value->rValue = model->HSMHV_pninv; + return(OK); + case HSMHV_MOD_PMUECB0: + value->rValue = model->HSMHV_pmuecb0; + return(OK); + case HSMHV_MOD_PMUECB1: + value->rValue = model->HSMHV_pmuecb1; + return(OK); + case HSMHV_MOD_PMUEPH1: + value->rValue = model->HSMHV_pmueph1; + return(OK); + case HSMHV_MOD_PVTMP: + value->rValue = model->HSMHV_pvtmp; + return(OK); + case HSMHV_MOD_PWVTH0: + value->rValue = model->HSMHV_pwvth0; + return(OK); + case HSMHV_MOD_PMUESR1: + value->rValue = model->HSMHV_pmuesr1; + return(OK); + case HSMHV_MOD_PMUETMP: + value->rValue = model->HSMHV_pmuetmp; + return(OK); + case HSMHV_MOD_PSUB1: + value->rValue = model->HSMHV_psub1; + return(OK); + case HSMHV_MOD_PSUB2: + value->rValue = model->HSMHV_psub2; + return(OK); + case HSMHV_MOD_PSVDS: + value->rValue = model->HSMHV_psvds; + return(OK); + case HSMHV_MOD_PSVBS: + value->rValue = model->HSMHV_psvbs; + return(OK); + case HSMHV_MOD_PSVGS: + value->rValue = model->HSMHV_psvgs; + return(OK); + case HSMHV_MOD_PFN1: + value->rValue = model->HSMHV_pfn1; + return(OK); + case HSMHV_MOD_PFN2: + value->rValue = model->HSMHV_pfn2; + return(OK); + case HSMHV_MOD_PFN3: + value->rValue = model->HSMHV_pfn3; + return(OK); + case HSMHV_MOD_PFVBS: + value->rValue = model->HSMHV_pfvbs; + return(OK); + case HSMHV_MOD_PNSTI: + value->rValue = model->HSMHV_pnsti; + return(OK); + case HSMHV_MOD_PWSTI: + value->rValue = model->HSMHV_pwsti; + return(OK); + case HSMHV_MOD_PSCSTI1: + value->rValue = model->HSMHV_pscsti1; + return(OK); + case HSMHV_MOD_PSCSTI2: + value->rValue = model->HSMHV_pscsti2; + return(OK); + case HSMHV_MOD_PVTHSTI: + value->rValue = model->HSMHV_pvthsti; + return(OK); + case HSMHV_MOD_PMUESTI1: + value->rValue = model->HSMHV_pmuesti1; + return(OK); + case HSMHV_MOD_PMUESTI2: + value->rValue = model->HSMHV_pmuesti2; + return(OK); + case HSMHV_MOD_PMUESTI3: + value->rValue = model->HSMHV_pmuesti3; + return(OK); + case HSMHV_MOD_PNSUBPSTI1: + value->rValue = model->HSMHV_pnsubpsti1; + return(OK); + case HSMHV_MOD_PNSUBPSTI2: + value->rValue = model->HSMHV_pnsubpsti2; + return(OK); + case HSMHV_MOD_PNSUBPSTI3: + value->rValue = model->HSMHV_pnsubpsti3; + return(OK); + case HSMHV_MOD_PCGSO: + value->rValue = model->HSMHV_pcgso; + return(OK); + case HSMHV_MOD_PCGDO: + value->rValue = model->HSMHV_pcgdo; + return(OK); + case HSMHV_MOD_PJS0: + value->rValue = model->HSMHV_pjs0; + return(OK); + case HSMHV_MOD_PJS0SW: + value->rValue = model->HSMHV_pjs0sw; + return(OK); + case HSMHV_MOD_PNJ: + value->rValue = model->HSMHV_pnj; + return(OK); + case HSMHV_MOD_PCISBK: + value->rValue = model->HSMHV_pcisbk; + return(OK); + case HSMHV_MOD_PCLM1: + value->rValue = model->HSMHV_pclm1; + return(OK); + case HSMHV_MOD_PCLM2: + value->rValue = model->HSMHV_pclm2; + return(OK); + case HSMHV_MOD_PCLM3: + value->rValue = model->HSMHV_pclm3; + return(OK); + case HSMHV_MOD_PWFC: + value->rValue = model->HSMHV_pwfc; + return(OK); + case HSMHV_MOD_PGIDL1: + value->rValue = model->HSMHV_pgidl1; + return(OK); + case HSMHV_MOD_PGIDL2: + value->rValue = model->HSMHV_pgidl2; + return(OK); + case HSMHV_MOD_PGLEAK1: + value->rValue = model->HSMHV_pgleak1; + return(OK); + case HSMHV_MOD_PGLEAK2: + value->rValue = model->HSMHV_pgleak2; + return(OK); + case HSMHV_MOD_PGLEAK3: + value->rValue = model->HSMHV_pgleak3; + return(OK); + case HSMHV_MOD_PGLEAK6: + value->rValue = model->HSMHV_pgleak6; + return(OK); + case HSMHV_MOD_PGLKSD1: + value->rValue = model->HSMHV_pglksd1; + return(OK); + case HSMHV_MOD_PGLKSD2: + value->rValue = model->HSMHV_pglksd2; + return(OK); + case HSMHV_MOD_PGLKB1: + value->rValue = model->HSMHV_pglkb1; + return(OK); + case HSMHV_MOD_PGLKB2: + value->rValue = model->HSMHV_pglkb2; + return(OK); + case HSMHV_MOD_PNFTRP: + value->rValue = model->HSMHV_pnftrp; + return(OK); + case HSMHV_MOD_PNFALP: + value->rValue = model->HSMHV_pnfalp; + return(OK); + case HSMHV_MOD_PPTHROU: + value->rValue = model->HSMHV_ppthrou; + return(OK); + case HSMHV_MOD_PVDIFFJ: + value->rValue = model->HSMHV_pvdiffj; + return(OK); + case HSMHV_MOD_PIBPC1: + value->rValue = model->HSMHV_pibpc1; + return(OK); + case HSMHV_MOD_PIBPC2: + value->rValue = model->HSMHV_pibpc2; + return(OK); + case HSMHV_MOD_PCGBO: + value->rValue = model->HSMHV_pcgbo; + return(OK); + case HSMHV_MOD_PCVDSOVER: + value->rValue = model->HSMHV_pcvdsover; + return(OK); + case HSMHV_MOD_PFALPH: + value->rValue = model->HSMHV_pfalph; + return(OK); + case HSMHV_MOD_PNPEXT: + value->rValue = model->HSMHV_pnpext; + return(OK); + case HSMHV_MOD_PPOWRAT: + value->rValue = model->HSMHV_ppowrat; + return(OK); + case HSMHV_MOD_PRD: + value->rValue = model->HSMHV_prd; + return(OK); + case HSMHV_MOD_PRD22: + value->rValue = model->HSMHV_prd22; + return(OK); + case HSMHV_MOD_PRD23: + value->rValue = model->HSMHV_prd23; + return(OK); + case HSMHV_MOD_PRD24: + value->rValue = model->HSMHV_prd24; + return(OK); + case HSMHV_MOD_PRDICT1: + value->rValue = model->HSMHV_prdict1; + return(OK); + case HSMHV_MOD_PRDOV13: + value->rValue = model->HSMHV_prdov13; + return(OK); + case HSMHV_MOD_PRDSLP1: + value->rValue = model->HSMHV_prdslp1; + return(OK); + case HSMHV_MOD_PRDVB: + value->rValue = model->HSMHV_prdvb; + return(OK); + case HSMHV_MOD_PRDVD: + value->rValue = model->HSMHV_prdvd; + return(OK); + case HSMHV_MOD_PRDVG11: + value->rValue = model->HSMHV_prdvg11; + return(OK); + case HSMHV_MOD_PRS: + value->rValue = model->HSMHV_prs; + return(OK); + case HSMHV_MOD_PRTH0: + value->rValue = model->HSMHV_prth0; + return(OK); + case HSMHV_MOD_PVOVER: + value->rValue = model->HSMHV_pvover; + return(OK); + + default: + return(E_BADPARM); + } + /* NOTREACHED */ +} diff --git a/src/spicelib/devices/hisimhv/hsmhvmdel.c b/src/spicelib/devices/hisimhv/hsmhvmdel.c new file mode 100644 index 000000000..ea41140a7 --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvmdel.c @@ -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 +#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); +} + diff --git a/src/spicelib/devices/hisimhv/hsmhvmpar.c b/src/spicelib/devices/hisimhv/hsmhvmpar.c new file mode 100644 index 000000000..166c181ff --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvmpar.c @@ -0,0 +1,2454 @@ +/*********************************************************************** + + 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 : hsmhvmpar.c + + DATE : 2010.11.02 + + released by + Hiroshima University & + Semiconductor Technology Academic Research Center (STARC) +***********************************************************************/ + +#include "ngspice.h" +#include +#include "hsmhvdef.h" +#include "ifsim.h" +#include "sperror.h" +#include "suffix.h" + +int HSMHVmParam( + int param, + IFvalue *value, + GENmodel *inMod) +{ + HSMHVmodel *mod = (HSMHVmodel*)inMod; + switch (param) { + case HSMHV_MOD_NMOS : + if (value->iValue) { + mod->HSMHV_type = 1; + mod->HSMHV_type_Given = TRUE; + } + break; + case HSMHV_MOD_PMOS : + if (value->iValue) { + mod->HSMHV_type = - 1; + mod->HSMHV_type_Given = TRUE; + } + break; + case HSMHV_MOD_LEVEL: + mod->HSMHV_level = value->iValue; + mod->HSMHV_level_Given = TRUE; + break; + case HSMHV_MOD_INFO: + mod->HSMHV_info = value->iValue; + mod->HSMHV_info_Given = TRUE; + break; + case HSMHV_MOD_NOISE: + mod->HSMHV_noise = value->iValue; + mod->HSMHV_noise_Given = TRUE; + break; + case HSMHV_MOD_VERSION: + mod->HSMHV_version = value->sValue; + mod->HSMHV_version_Given = TRUE; + break; + case HSMHV_MOD_SHOW: + mod->HSMHV_show = value->iValue; + mod->HSMHV_show_Given = TRUE; + break; + case HSMHV_MOD_CORSRD: + mod->HSMHV_corsrd = value->iValue; + mod->HSMHV_corsrd_Given = TRUE; + break; + case HSMHV_MOD_CORG: + mod->HSMHV_corg = value->iValue; + mod->HSMHV_corg_Given = TRUE; + break; + case HSMHV_MOD_COIPRV: + mod->HSMHV_coiprv = value->iValue; + mod->HSMHV_coiprv_Given = TRUE; + break; + case HSMHV_MOD_COPPRV: + mod->HSMHV_copprv = value->iValue; + mod->HSMHV_copprv_Given = TRUE; + break; + case HSMHV_MOD_COADOV: + mod->HSMHV_coadov = value->iValue; + mod->HSMHV_coadov_Given = TRUE; + break; + case HSMHV_MOD_COISUB: + mod->HSMHV_coisub = value->iValue; + mod->HSMHV_coisub_Given = TRUE; + break; + case HSMHV_MOD_COIIGS: + mod->HSMHV_coiigs = value->iValue; + mod->HSMHV_coiigs_Given = TRUE; + break; + case HSMHV_MOD_COGIDL: + mod->HSMHV_cogidl = value->iValue; + mod->HSMHV_cogidl_Given = TRUE; + break; + case HSMHV_MOD_COOVLP: + mod->HSMHV_coovlp = value->iValue; + mod->HSMHV_coovlp_Given = TRUE; + break; + case HSMHV_MOD_COOVLPS: + mod->HSMHV_coovlps = value->iValue; + mod->HSMHV_coovlps_Given = TRUE; + break; + case HSMHV_MOD_COFLICK: + mod->HSMHV_coflick = value->iValue; + mod->HSMHV_coflick_Given = TRUE; + break; + case HSMHV_MOD_COISTI: + mod->HSMHV_coisti = value->iValue; + mod->HSMHV_coisti_Given = TRUE; + break; + case HSMHV_MOD_CONQS: /* HiSIMHV */ + mod->HSMHV_conqs = value->iValue; + mod->HSMHV_conqs_Given = TRUE; + break; + case HSMHV_MOD_CORBNET: + mod->HSMHV_corbnet = value->iValue; + mod->HSMHV_corbnet_Given = TRUE; + break; + case HSMHV_MOD_COTHRML: + mod->HSMHV_cothrml = value->iValue; + mod->HSMHV_cothrml_Given = TRUE; + break; + case HSMHV_MOD_COIGN: + mod->HSMHV_coign = value->iValue; + mod->HSMHV_coign_Given = TRUE; + break; + case HSMHV_MOD_CODFM: + mod->HSMHV_codfm = value->iValue; + mod->HSMHV_codfm_Given = TRUE; + break; + case HSMHV_MOD_COQOVSM: + mod->HSMHV_coqovsm = value->iValue; + mod->HSMHV_coqovsm_Given = TRUE; + break; + case HSMHV_MOD_COSELFHEAT: /* Self-heating model */ + mod->HSMHV_coselfheat = value->iValue; + mod->HSMHV_coselfheat_Given = TRUE; + break; + case HSMHV_MOD_COSUBNODE: + mod->HSMHV_cosubnode = value->iValue; + mod->HSMHV_cosubnode_Given = TRUE; + break; + case HSMHV_MOD_COSYM: /* Symmetry model for HV */ + mod->HSMHV_cosym = value->iValue; + mod->HSMHV_cosym_Given = TRUE; + break; + case HSMHV_MOD_COTEMP: + mod->HSMHV_cotemp = value->iValue; + mod->HSMHV_cotemp_Given = TRUE; + break; + case HSMHV_MOD_COLDRIFT: + mod->HSMHV_coldrift = value->iValue; + mod->HSMHV_coldrift_Given = TRUE; + break; + case HSMHV_MOD_VMAX: + mod->HSMHV_vmax = value->rValue; + mod->HSMHV_vmax_Given = TRUE; + break; + case HSMHV_MOD_VMAXT1: + mod->HSMHV_vmaxt1 = value->rValue; + mod->HSMHV_vmaxt1_Given = TRUE; + break; + case HSMHV_MOD_VMAXT2: + mod->HSMHV_vmaxt2 = value->rValue; + mod->HSMHV_vmaxt2_Given = TRUE; + break; + case HSMHV_MOD_BGTMP1: + mod->HSMHV_bgtmp1 = value->rValue; + mod->HSMHV_bgtmp1_Given = TRUE; + break; + case HSMHV_MOD_BGTMP2: + mod->HSMHV_bgtmp2 = value->rValue; + mod->HSMHV_bgtmp2_Given = TRUE; + break; + case HSMHV_MOD_EG0: + mod->HSMHV_eg0 = value->rValue; + mod->HSMHV_eg0_Given = TRUE; + break; + case HSMHV_MOD_TOX: + mod->HSMHV_tox = value->rValue; + mod->HSMHV_tox_Given = TRUE; + break; + case HSMHV_MOD_XLD: + mod->HSMHV_xld = value->rValue; + mod->HSMHV_xld_Given = TRUE; + break; + case HSMHV_MOD_LOVER: + mod->HSMHV_lover = value->rValue; + mod->HSMHV_lover_Given = TRUE; + break; + case HSMHV_MOD_LOVERS: + mod->HSMHV_lovers = value->rValue; + mod->HSMHV_lovers_Given = TRUE; + break; + case HSMHV_MOD_RDOV11: + mod->HSMHV_rdov11 = value->rValue; + mod->HSMHV_rdov11_Given = TRUE; + break; + case HSMHV_MOD_RDOV12: + mod->HSMHV_rdov12 = value->rValue; + mod->HSMHV_rdov12_Given = TRUE; + break; + case HSMHV_MOD_RDOV13: + mod->HSMHV_rdov13 = value->rValue; + mod->HSMHV_rdov13_Given = TRUE; + break; + case HSMHV_MOD_RDSLP1: + mod->HSMHV_rdslp1 = value->rValue; + mod->HSMHV_rdslp1_Given = TRUE; + break; + case HSMHV_MOD_RDICT1: + mod->HSMHV_rdict1= value->rValue; + mod->HSMHV_rdict1_Given = TRUE; + break; + case HSMHV_MOD_RDSLP2: + mod->HSMHV_rdslp2 = value->rValue; + mod->HSMHV_rdslp2_Given = TRUE; + break; + case HSMHV_MOD_RDICT2: + mod->HSMHV_rdict2 = value->rValue; + mod->HSMHV_rdict2_Given = TRUE; + break; + case HSMHV_MOD_LOVERLD: + mod->HSMHV_loverld = value->rValue; + mod->HSMHV_loverld_Given = TRUE; + break; + case HSMHV_MOD_LDRIFT1: + mod->HSMHV_ldrift1 = value->rValue; + mod->HSMHV_ldrift1_Given = TRUE; + break; + case HSMHV_MOD_LDRIFT2: + mod->HSMHV_ldrift2 = value->rValue; + mod->HSMHV_ldrift2_Given = TRUE; + break; + case HSMHV_MOD_LDRIFT1S: + mod->HSMHV_ldrift1s = value->rValue; + mod->HSMHV_ldrift1s_Given = TRUE; + break; + case HSMHV_MOD_LDRIFT2S: + mod->HSMHV_ldrift2s = value->rValue; + mod->HSMHV_ldrift2s_Given = TRUE; + break; + case HSMHV_MOD_SUBLD1: + mod->HSMHV_subld1 = value->rValue; + mod->HSMHV_subld1_Given = TRUE; + break; + case HSMHV_MOD_SUBLD2: + mod->HSMHV_subld2 = value->rValue; + mod->HSMHV_subld2_Given = TRUE; + break; + case HSMHV_MOD_DDLTMAX: /* Vdseff */ + mod->HSMHV_ddltmax = value->rValue; + mod->HSMHV_ddltmax_Given = TRUE; + break; + case HSMHV_MOD_DDLTSLP: /* Vdseff */ + mod->HSMHV_ddltslp = value->rValue; + mod->HSMHV_ddltslp_Given = TRUE; + break; + case HSMHV_MOD_DDLTICT: /* Vdseff */ + mod->HSMHV_ddltict = value->rValue; + mod->HSMHV_ddltict_Given = TRUE; + break; + case HSMHV_MOD_VFBOVER: + mod->HSMHV_vfbover = value->rValue; + mod->HSMHV_vfbover_Given = TRUE; + break; + case HSMHV_MOD_NOVER: + mod->HSMHV_nover = value->rValue; + mod->HSMHV_nover_Given = TRUE; + break; + case HSMHV_MOD_NOVERS: + mod->HSMHV_novers = value->rValue; + mod->HSMHV_novers_Given = TRUE; + break; + case HSMHV_MOD_XWD: + mod->HSMHV_xwd = value->rValue; + mod->HSMHV_xwd_Given = TRUE; + break; + case HSMHV_MOD_XWDC: + mod->HSMHV_xwdc = value->rValue; + mod->HSMHV_xwdc_Given = TRUE; + break; + case HSMHV_MOD_XL: + mod->HSMHV_xl = value->rValue; + mod->HSMHV_xl_Given = TRUE; + break; + case HSMHV_MOD_XW: + mod->HSMHV_xw = value->rValue; + mod->HSMHV_xw_Given = TRUE; + break; + case HSMHV_MOD_SAREF: + mod->HSMHV_saref = value->rValue; + mod->HSMHV_saref_Given = TRUE; + break; + case HSMHV_MOD_SBREF: + mod->HSMHV_sbref = value->rValue; + mod->HSMHV_sbref_Given = TRUE; + break; + case HSMHV_MOD_LL: + mod->HSMHV_ll = value->rValue; + mod->HSMHV_ll_Given = TRUE; + break; + case HSMHV_MOD_LLD: + mod->HSMHV_lld = value->rValue; + mod->HSMHV_lld_Given = TRUE; + break; + case HSMHV_MOD_LLN: + mod->HSMHV_lln = value->rValue; + mod->HSMHV_lln_Given = TRUE; + break; + case HSMHV_MOD_WL: + mod->HSMHV_wl = value->rValue; + mod->HSMHV_wl_Given = TRUE; + break; + case HSMHV_MOD_WL1: + mod->HSMHV_wl1 = value->rValue; + mod->HSMHV_wl1_Given = TRUE; + break; + case HSMHV_MOD_WL1P: + mod->HSMHV_wl1p = value->rValue; + mod->HSMHV_wl1p_Given = TRUE; + break; + case HSMHV_MOD_WL2: + mod->HSMHV_wl2 = value->rValue; + mod->HSMHV_wl2_Given = TRUE; + break; + case HSMHV_MOD_WL2P: + mod->HSMHV_wl2p = value->rValue; + mod->HSMHV_wl2p_Given = TRUE; + break; + case HSMHV_MOD_WLD: + mod->HSMHV_wld = value->rValue; + mod->HSMHV_wld_Given = TRUE; + break; + case HSMHV_MOD_WLN: + mod->HSMHV_wln = value->rValue; + mod->HSMHV_wln_Given = TRUE; + break; + case HSMHV_MOD_XQY: + mod->HSMHV_xqy = value->rValue; + mod->HSMHV_xqy_Given = TRUE; + break; + case HSMHV_MOD_XQY1: + mod->HSMHV_xqy1 = value->rValue; + mod->HSMHV_xqy1_Given = TRUE; + break; + case HSMHV_MOD_XQY2: + mod->HSMHV_xqy2 = value->rValue; + mod->HSMHV_xqy2_Given = TRUE; + break; + case HSMHV_MOD_RS: + mod->HSMHV_rs = value->rValue; + mod->HSMHV_rs_Given = TRUE; + break; + case HSMHV_MOD_RD: + mod->HSMHV_rd = value->rValue; + mod->HSMHV_rd_Given = TRUE; + break; + case HSMHV_MOD_RSH: + mod->HSMHV_rsh = value->rValue; + mod->HSMHV_rsh_Given = TRUE; + break; + case HSMHV_MOD_RSHG: + mod->HSMHV_rshg = value->rValue; + mod->HSMHV_rshg_Given = TRUE; + break; + case HSMHV_MOD_VFBC: + mod->HSMHV_vfbc = value->rValue; + mod->HSMHV_vfbc_Given = TRUE; + break; + case HSMHV_MOD_VBI: + mod->HSMHV_vbi = value->rValue; + mod->HSMHV_vbi_Given = TRUE; + break; + case HSMHV_MOD_NSUBC: + mod->HSMHV_nsubc = value->rValue; + mod->HSMHV_nsubc_Given = TRUE; + break; + case HSMHV_MOD_PARL2: + mod->HSMHV_parl2 = value->rValue; + mod->HSMHV_parl2_Given = TRUE; + break; + case HSMHV_MOD_LP: + mod->HSMHV_lp = value->rValue; + mod->HSMHV_lp_Given = TRUE; + break; + case HSMHV_MOD_NSUBP: + mod->HSMHV_nsubp = value->rValue; + mod->HSMHV_nsubp_Given = TRUE; + break; + case HSMHV_MOD_NSUBP0: + mod->HSMHV_nsubp0 = value->rValue; + mod->HSMHV_nsubp0_Given = TRUE; + break; + case HSMHV_MOD_NSUBWP: + mod->HSMHV_nsubwp = value->rValue; + mod->HSMHV_nsubwp_Given = TRUE; + break; + case HSMHV_MOD_SCP1: + mod->HSMHV_scp1 = value->rValue; + mod->HSMHV_scp1_Given = TRUE; + break; + case HSMHV_MOD_SCP2: + mod->HSMHV_scp2 = value->rValue; + mod->HSMHV_scp2_Given = TRUE; + break; + case HSMHV_MOD_SCP3: + mod->HSMHV_scp3 = value->rValue; + mod->HSMHV_scp3_Given = TRUE; + break; + case HSMHV_MOD_SC1: + mod->HSMHV_sc1 = value->rValue; + mod->HSMHV_sc1_Given = TRUE; + break; + case HSMHV_MOD_SC2: + mod->HSMHV_sc2 = value->rValue; + mod->HSMHV_sc2_Given = TRUE; + break; + case HSMHV_MOD_SC3: + mod->HSMHV_sc3 = value->rValue; + mod->HSMHV_sc3_Given = TRUE; + break; + case HSMHV_MOD_SC4: + mod->HSMHV_sc4 = value->rValue; + mod->HSMHV_sc4_Given = TRUE; + break; + case HSMHV_MOD_PGD1: + mod->HSMHV_pgd1 = value->rValue; + mod->HSMHV_pgd1_Given = TRUE; + break; + case HSMHV_MOD_PGD2: + mod->HSMHV_pgd2 = value->rValue; + mod->HSMHV_pgd2_Given = TRUE; + break; + case HSMHV_MOD_PGD3: + mod->HSMHV_pgd3 = value->rValue; + mod->HSMHV_pgd3_Given = TRUE; + break; + case HSMHV_MOD_PGD4: + mod->HSMHV_pgd4 = value->rValue; + mod->HSMHV_pgd4_Given = TRUE; + break; + case HSMHV_MOD_NDEP: + mod->HSMHV_ndep = value->rValue; + mod->HSMHV_ndep_Given = TRUE; + break; + case HSMHV_MOD_NDEPL: + mod->HSMHV_ndepl = value->rValue; + mod->HSMHV_ndepl_Given = TRUE; + break; + case HSMHV_MOD_NDEPLP: + mod->HSMHV_ndeplp = value->rValue; + mod->HSMHV_ndeplp_Given = TRUE; + break; + case HSMHV_MOD_NINV: + mod->HSMHV_ninv = value->rValue; + mod->HSMHV_ninv_Given = TRUE; + break; + case HSMHV_MOD_MUECB0: + mod->HSMHV_muecb0 = value->rValue; + mod->HSMHV_muecb0_Given = TRUE; + break; + case HSMHV_MOD_MUECB1: + mod->HSMHV_muecb1 = value->rValue; + mod->HSMHV_muecb1_Given = TRUE; + break; + case HSMHV_MOD_MUEPH1: + mod->HSMHV_mueph1 = value->rValue; + mod->HSMHV_mueph1_Given = TRUE; + break; + case HSMHV_MOD_MUEPH0: + mod->HSMHV_mueph0 = value->rValue; + mod->HSMHV_mueph0_Given = TRUE; + break; + case HSMHV_MOD_MUEPHW: + mod->HSMHV_muephw = value->rValue; + mod->HSMHV_muephw_Given = TRUE; + break; + case HSMHV_MOD_MUEPWP: + mod->HSMHV_muepwp = value->rValue; + mod->HSMHV_muepwp_Given = TRUE; + break; + case HSMHV_MOD_MUEPHL: + mod->HSMHV_muephl = value->rValue; + mod->HSMHV_muephl_Given = TRUE; + break; + case HSMHV_MOD_MUEPLP: + mod->HSMHV_mueplp = value->rValue; + mod->HSMHV_mueplp_Given = TRUE; + break; + case HSMHV_MOD_MUEPHS: + mod->HSMHV_muephs = value->rValue; + mod->HSMHV_muephs_Given = TRUE; + break; + case HSMHV_MOD_MUEPSP: + mod->HSMHV_muepsp = value->rValue; + mod->HSMHV_muepsp_Given = TRUE; + break; + case HSMHV_MOD_VTMP: + mod->HSMHV_vtmp = value->rValue; + mod->HSMHV_vtmp_Given = TRUE; + break; + case HSMHV_MOD_WVTH0: + mod->HSMHV_wvth0 = value->rValue; + mod->HSMHV_wvth0_Given = TRUE; + break; + case HSMHV_MOD_MUESR1: + mod->HSMHV_muesr1 = value->rValue; + mod->HSMHV_muesr1_Given = TRUE; + break; + case HSMHV_MOD_MUESR0: + mod->HSMHV_muesr0 = value->rValue; + mod->HSMHV_muesr0_Given = TRUE; + break; + case HSMHV_MOD_MUESRL: + mod->HSMHV_muesrl = value->rValue; + mod->HSMHV_muesrl_Given = TRUE; + break; + case HSMHV_MOD_MUESLP: + mod->HSMHV_mueslp = value->rValue; + mod->HSMHV_mueslp_Given = TRUE; + break; + case HSMHV_MOD_MUESRW: + mod->HSMHV_muesrw = value->rValue; + mod->HSMHV_muesrw_Given = TRUE; + break; + case HSMHV_MOD_MUESWP: + mod->HSMHV_mueswp = value->rValue; + mod->HSMHV_mueswp_Given = TRUE; + break; + case HSMHV_MOD_BB: + mod->HSMHV_bb = value->rValue; + mod->HSMHV_bb_Given = TRUE; + break; + case HSMHV_MOD_SUB1: + mod->HSMHV_sub1 = value->rValue; + mod->HSMHV_sub1_Given = TRUE; + break; + case HSMHV_MOD_SUB2: + mod->HSMHV_sub2 = value->rValue; + mod->HSMHV_sub2_Given = TRUE; + break; + case HSMHV_MOD_SVGS: + mod->HSMHV_svgs = value->rValue; + mod->HSMHV_svgs_Given = TRUE; + break; + case HSMHV_MOD_SVBS: + mod->HSMHV_svbs = value->rValue; + mod->HSMHV_svbs_Given = TRUE; + break; + case HSMHV_MOD_SVBSL: + mod->HSMHV_svbsl = value->rValue; + mod->HSMHV_svbsl_Given = TRUE; + break; + case HSMHV_MOD_SVDS: + mod->HSMHV_svds = value->rValue; + mod->HSMHV_svds_Given = TRUE; + break; + case HSMHV_MOD_SLG: + mod->HSMHV_slg = value->rValue; + mod->HSMHV_slg_Given = TRUE; + break; + case HSMHV_MOD_SUB1L: + mod->HSMHV_sub1l = value->rValue; + mod->HSMHV_sub1l_Given = TRUE; + break; + case HSMHV_MOD_SUB2L: + mod->HSMHV_sub2l = value->rValue; + mod->HSMHV_sub2l_Given = TRUE; + break; + case HSMHV_MOD_FN1: + mod->HSMHV_fn1 = value->rValue; + mod->HSMHV_fn1_Given = TRUE; + break; + case HSMHV_MOD_FN2: + mod->HSMHV_fn2 = value->rValue; + mod->HSMHV_fn2_Given = TRUE; + break; + case HSMHV_MOD_FN3: + mod->HSMHV_fn3 = value->rValue; + mod->HSMHV_fn3_Given = TRUE; + break; + case HSMHV_MOD_FVBS: + mod->HSMHV_fvbs = value->rValue; + mod->HSMHV_fvbs_Given = TRUE; + break; + case HSMHV_MOD_SVGSL: + mod->HSMHV_svgsl = value->rValue; + mod->HSMHV_svgsl_Given = TRUE; + break; + case HSMHV_MOD_SVGSLP: + mod->HSMHV_svgslp = value->rValue; + mod->HSMHV_svgslp_Given = TRUE; + break; + case HSMHV_MOD_SVGSWP: + mod->HSMHV_svgswp = value->rValue; + mod->HSMHV_svgswp_Given = TRUE; + break; + case HSMHV_MOD_SVGSW: + mod->HSMHV_svgsw = value->rValue; + mod->HSMHV_svgsw_Given = TRUE; + break; + case HSMHV_MOD_SVBSLP: + mod->HSMHV_svbslp = value->rValue; + mod->HSMHV_svbslp_Given = TRUE; + break; + case HSMHV_MOD_SLGL: + mod->HSMHV_slgl = value->rValue; + mod->HSMHV_slgl_Given = TRUE; + break; + case HSMHV_MOD_SLGLP: + mod->HSMHV_slglp = value->rValue; + mod->HSMHV_slglp_Given = TRUE; + break; + case HSMHV_MOD_SUB1LP: + mod->HSMHV_sub1lp = value->rValue; + mod->HSMHV_sub1lp_Given = TRUE; + break; + case HSMHV_MOD_NSTI: + mod->HSMHV_nsti = value->rValue; + mod->HSMHV_nsti_Given = TRUE; + break; + case HSMHV_MOD_WSTI: + mod->HSMHV_wsti = value->rValue; + mod->HSMHV_wsti_Given = TRUE; + break; + case HSMHV_MOD_WSTIL: + mod->HSMHV_wstil = value->rValue; + mod->HSMHV_wstil_Given = TRUE; + break; + case HSMHV_MOD_WSTILP: + mod->HSMHV_wstilp = value->rValue; + mod->HSMHV_wstilp_Given = TRUE; + break; + case HSMHV_MOD_WSTIW: + mod->HSMHV_wstiw = value->rValue; + mod->HSMHV_wstiw_Given = TRUE; + break; + case HSMHV_MOD_WSTIWP: + mod->HSMHV_wstiwp = value->rValue; + mod->HSMHV_wstiwp_Given = TRUE; + break; + case HSMHV_MOD_SCSTI1: + mod->HSMHV_scsti1 = value->rValue; + mod->HSMHV_scsti1_Given = TRUE; + break; + case HSMHV_MOD_SCSTI2: + mod->HSMHV_scsti2 = value->rValue; + mod->HSMHV_scsti2_Given = TRUE; + break; + case HSMHV_MOD_VTHSTI: + mod->HSMHV_vthsti = value->rValue; + mod->HSMHV_vthsti_Given = TRUE; + break; + case HSMHV_MOD_VDSTI: + mod->HSMHV_vdsti = value->rValue; + mod->HSMHV_vdsti_Given = TRUE; + break; + case HSMHV_MOD_MUESTI1: + mod->HSMHV_muesti1 = value->rValue; + mod->HSMHV_muesti1_Given = TRUE; + break; + case HSMHV_MOD_MUESTI2: + mod->HSMHV_muesti2 = value->rValue; + mod->HSMHV_muesti2_Given = TRUE; + break; + case HSMHV_MOD_MUESTI3: + mod->HSMHV_muesti3 = value->rValue; + mod->HSMHV_muesti3_Given = TRUE; + break; + case HSMHV_MOD_NSUBPSTI1: + mod->HSMHV_nsubpsti1 = value->rValue; + mod->HSMHV_nsubpsti1_Given = TRUE; + break; + case HSMHV_MOD_NSUBPSTI2: + mod->HSMHV_nsubpsti2 = value->rValue; + mod->HSMHV_nsubpsti2_Given = TRUE; + break; + case HSMHV_MOD_NSUBPSTI3: + mod->HSMHV_nsubpsti3 = value->rValue; + mod->HSMHV_nsubpsti3_Given = TRUE; + break; + case HSMHV_MOD_LPEXT: + mod->HSMHV_lpext = value->rValue; + mod->HSMHV_lpext_Given = TRUE; + break; + case HSMHV_MOD_NPEXT: + mod->HSMHV_npext = value->rValue; + mod->HSMHV_npext_Given = TRUE; + break; + case HSMHV_MOD_SCP22: + mod->HSMHV_scp22 = value->rValue; + mod->HSMHV_scp22_Given = TRUE; + break; + case HSMHV_MOD_SCP21: + mod->HSMHV_scp21 = value->rValue; + mod->HSMHV_scp21_Given = TRUE; + break; + case HSMHV_MOD_BS1: + mod->HSMHV_bs1 = value->rValue; + mod->HSMHV_bs1_Given = TRUE; + break; + case HSMHV_MOD_BS2: + mod->HSMHV_bs2 = value->rValue; + mod->HSMHV_bs2_Given = TRUE; + break; + case HSMHV_MOD_CGSO: + mod->HSMHV_cgso = value->rValue; + mod->HSMHV_cgso_Given = TRUE; + break; + case HSMHV_MOD_CGDO: + mod->HSMHV_cgdo = value->rValue; + mod->HSMHV_cgdo_Given = TRUE; + break; + case HSMHV_MOD_CGBO: + mod->HSMHV_cgbo = value->rValue; + mod->HSMHV_cgbo_Given = TRUE; + break; + case HSMHV_MOD_TPOLY: + mod->HSMHV_tpoly = value->rValue; + mod->HSMHV_tpoly_Given = TRUE; + break; + case HSMHV_MOD_JS0: + mod->HSMHV_js0 = value->rValue; + mod->HSMHV_js0_Given = TRUE; + break; + case HSMHV_MOD_JS0SW: + mod->HSMHV_js0sw = value->rValue; + mod->HSMHV_js0sw_Given = TRUE; + break; + case HSMHV_MOD_NJ: + mod->HSMHV_nj = value->rValue; + mod->HSMHV_nj_Given = TRUE; + break; + case HSMHV_MOD_NJSW: + mod->HSMHV_njsw = value->rValue; + mod->HSMHV_njsw_Given = TRUE; + break; + case HSMHV_MOD_XTI: + mod->HSMHV_xti = value->rValue; + mod->HSMHV_xti_Given = TRUE; + break; + case HSMHV_MOD_CJ: + mod->HSMHV_cj = value->rValue; + mod->HSMHV_cj_Given = TRUE; + break; + case HSMHV_MOD_CJSW: + mod->HSMHV_cjsw = value->rValue; + mod->HSMHV_cjsw_Given = TRUE; + break; + case HSMHV_MOD_CJSWG: + mod->HSMHV_cjswg = value->rValue; + mod->HSMHV_cjswg_Given = TRUE; + break; + case HSMHV_MOD_MJ: + mod->HSMHV_mj = value->rValue; + mod->HSMHV_mj_Given = TRUE; + break; + case HSMHV_MOD_MJSW: + mod->HSMHV_mjsw = value->rValue; + mod->HSMHV_mjsw_Given = TRUE; + break; + case HSMHV_MOD_MJSWG: + mod->HSMHV_mjswg = value->rValue; + mod->HSMHV_mjswg_Given = TRUE; + break; + case HSMHV_MOD_PB: + mod->HSMHV_pb = value->rValue; + mod->HSMHV_pb_Given = TRUE; + break; + case HSMHV_MOD_PBSW: + mod->HSMHV_pbsw = value->rValue; + mod->HSMHV_pbsw_Given = TRUE; + break; + case HSMHV_MOD_PBSWG: + mod->HSMHV_pbswg = value->rValue; + mod->HSMHV_pbswg_Given = TRUE; + break; + case HSMHV_MOD_XTI2: + mod->HSMHV_xti2 = value->rValue; + mod->HSMHV_xti2_Given = TRUE; + break; + case HSMHV_MOD_CISB: + mod->HSMHV_cisb = value->rValue; + mod->HSMHV_cisb_Given = TRUE; + break; + case HSMHV_MOD_CVB: + mod->HSMHV_cvb = value->rValue; + mod->HSMHV_cvb_Given = TRUE; + break; + case HSMHV_MOD_CTEMP: + mod->HSMHV_ctemp = value->rValue; + mod->HSMHV_ctemp_Given = TRUE; + break; + case HSMHV_MOD_CISBK: + mod->HSMHV_cisbk = value->rValue; + mod->HSMHV_cisbk_Given = TRUE; + break; + case HSMHV_MOD_CVBK: + mod->HSMHV_cvbk = value->rValue; + mod->HSMHV_cvbk_Given = TRUE; + break; + case HSMHV_MOD_DIVX: + mod->HSMHV_divx = value->rValue; + mod->HSMHV_divx_Given = TRUE; + break; + case HSMHV_MOD_CLM1: + mod->HSMHV_clm1 = value->rValue; + mod->HSMHV_clm1_Given = TRUE; + break; + case HSMHV_MOD_CLM2: + mod->HSMHV_clm2 = value->rValue; + mod->HSMHV_clm2_Given = TRUE; + break; + case HSMHV_MOD_CLM3: + mod->HSMHV_clm3 = value->rValue; + mod->HSMHV_clm3_Given = TRUE; + break; + case HSMHV_MOD_CLM5: + mod->HSMHV_clm5 = value->rValue; + mod->HSMHV_clm5_Given = TRUE; + break; + case HSMHV_MOD_CLM6: + mod->HSMHV_clm6 = value->rValue; + mod->HSMHV_clm6_Given = TRUE; + break; + case HSMHV_MOD_MUETMP: + mod->HSMHV_muetmp = value->rValue; + mod->HSMHV_muetmp_Given = TRUE; + break; + case HSMHV_MOD_VOVER: + mod->HSMHV_vover = value->rValue; + mod->HSMHV_vover_Given = TRUE; + break; + case HSMHV_MOD_VOVERP: + mod->HSMHV_voverp = value->rValue; + mod->HSMHV_voverp_Given = TRUE; + break; + case HSMHV_MOD_VOVERS: + mod->HSMHV_vovers = value->rValue; + mod->HSMHV_vovers_Given = TRUE; + break; + case HSMHV_MOD_VOVERSP: + mod->HSMHV_voversp = value->rValue; + mod->HSMHV_voversp_Given = TRUE; + break; + case HSMHV_MOD_WFC: + mod->HSMHV_wfc = value->rValue; + mod->HSMHV_wfc_Given = TRUE; + break; + case HSMHV_MOD_NSUBCW: + mod->HSMHV_nsubcw = value->rValue; + mod->HSMHV_nsubcw_Given = TRUE; + break; + case HSMHV_MOD_NSUBCWP: + mod->HSMHV_nsubcwp = value->rValue; + mod->HSMHV_nsubcwp_Given = TRUE; + break; + case HSMHV_MOD_QME1: + mod->HSMHV_qme1 = value->rValue; + mod->HSMHV_qme1_Given = TRUE; + break; + case HSMHV_MOD_QME2: + mod->HSMHV_qme2 = value->rValue; + mod->HSMHV_qme2_Given = TRUE; + break; + case HSMHV_MOD_QME3: + mod->HSMHV_qme3 = value->rValue; + mod->HSMHV_qme3_Given = TRUE; + break; + case HSMHV_MOD_GIDL1: + mod->HSMHV_gidl1 = value->rValue; + mod->HSMHV_gidl1_Given = TRUE; + break; + case HSMHV_MOD_GIDL2: + mod->HSMHV_gidl2 = value->rValue; + mod->HSMHV_gidl2_Given = TRUE; + break; + case HSMHV_MOD_GIDL3: + mod->HSMHV_gidl3 = value->rValue; + mod->HSMHV_gidl3_Given = TRUE; + break; + case HSMHV_MOD_GIDL4: + mod->HSMHV_gidl4 = value->rValue; + mod->HSMHV_gidl4_Given = TRUE; + break; + case HSMHV_MOD_GIDL5: + mod->HSMHV_gidl5 = value->rValue; + mod->HSMHV_gidl5_Given = TRUE; + break; + case HSMHV_MOD_GLEAK1: + mod->HSMHV_gleak1 = value->rValue; + mod->HSMHV_gleak1_Given = TRUE; + break; + case HSMHV_MOD_GLEAK2: + mod->HSMHV_gleak2 = value->rValue; + mod->HSMHV_gleak2_Given = TRUE; + break; + case HSMHV_MOD_GLEAK3: + mod->HSMHV_gleak3 = value->rValue; + mod->HSMHV_gleak3_Given = TRUE; + break; + case HSMHV_MOD_GLEAK4: + mod->HSMHV_gleak4 = value->rValue; + mod->HSMHV_gleak4_Given = TRUE; + break; + case HSMHV_MOD_GLEAK5: + mod->HSMHV_gleak5 = value->rValue; + mod->HSMHV_gleak5_Given = TRUE; + break; + case HSMHV_MOD_GLEAK6: + mod->HSMHV_gleak6 = value->rValue; + mod->HSMHV_gleak6_Given = TRUE; + break; + case HSMHV_MOD_GLEAK7: + mod->HSMHV_gleak7 = value->rValue; + mod->HSMHV_gleak7_Given = TRUE; + break; + case HSMHV_MOD_GLPART1: + mod->HSMHV_glpart1 = value->rValue; + mod->HSMHV_glpart1_Given = TRUE; + break; + case HSMHV_MOD_GLKSD1: + mod->HSMHV_glksd1 = value->rValue; + mod->HSMHV_glksd1_Given = TRUE; + break; + case HSMHV_MOD_GLKSD2: + mod->HSMHV_glksd2 = value->rValue; + mod->HSMHV_glksd2_Given = TRUE; + break; + case HSMHV_MOD_GLKSD3: + mod->HSMHV_glksd3 = value->rValue; + mod->HSMHV_glksd3_Given = TRUE; + break; + case HSMHV_MOD_GLKB1: + mod->HSMHV_glkb1 = value->rValue; + mod->HSMHV_glkb1_Given = TRUE; + break; + case HSMHV_MOD_GLKB2: + mod->HSMHV_glkb2 = value->rValue; + mod->HSMHV_glkb2_Given = TRUE; + break; + case HSMHV_MOD_GLKB3: + mod->HSMHV_glkb3 = value->rValue; + mod->HSMHV_glkb3_Given = TRUE; + break; + case HSMHV_MOD_EGIG: + mod->HSMHV_egig = value->rValue; + mod->HSMHV_egig_Given = TRUE; + break; + case HSMHV_MOD_IGTEMP2: + mod->HSMHV_igtemp2 = value->rValue; + mod->HSMHV_igtemp2_Given = TRUE; + break; + case HSMHV_MOD_IGTEMP3: + mod->HSMHV_igtemp3 = value->rValue; + mod->HSMHV_igtemp3_Given = TRUE; + break; + case HSMHV_MOD_VZADD0: + mod->HSMHV_vzadd0 = value->rValue; + mod->HSMHV_vzadd0_Given = TRUE; + break; + case HSMHV_MOD_PZADD0: + mod->HSMHV_pzadd0 = value->rValue; + mod->HSMHV_pzadd0_Given = TRUE; + break; + case HSMHV_MOD_NFTRP: + mod->HSMHV_nftrp = value->rValue; + mod->HSMHV_nftrp_Given = TRUE; + break; + case HSMHV_MOD_NFALP: + mod->HSMHV_nfalp = value->rValue; + mod->HSMHV_nfalp_Given = TRUE; + break; + case HSMHV_MOD_CIT: + mod->HSMHV_cit = value->rValue; + mod->HSMHV_cit_Given = TRUE; + break; + case HSMHV_MOD_FALPH: + mod->HSMHV_falph = value->rValue; + mod->HSMHV_falph_Given = TRUE; + break; + case HSMHV_MOD_KAPPA: + mod->HSMHV_kappa = value->rValue; + mod->HSMHV_kappa_Given = TRUE; + break; + case HSMHV_MOD_PTHROU: + mod->HSMHV_pthrou = value->rValue; + mod->HSMHV_pthrou_Given = TRUE; + break; + case HSMHV_MOD_VDIFFJ: + mod->HSMHV_vdiffj = value->rValue; + mod->HSMHV_vdiffj_Given = TRUE; + break; + case HSMHV_MOD_DLY1: + mod->HSMHV_dly1 = value->rValue; + mod->HSMHV_dly1_Given = TRUE; + break; + case HSMHV_MOD_DLY2: + mod->HSMHV_dly2 = value->rValue; + mod->HSMHV_dly2_Given = TRUE; + break; + case HSMHV_MOD_DLY3: + mod->HSMHV_dly3 = value->rValue; + mod->HSMHV_dly3_Given = TRUE; + break; + case HSMHV_MOD_TNOM: + mod->HSMHV_tnom = value->rValue; + mod->HSMHV_tnom_Given = TRUE; + break; + case HSMHV_MOD_OVSLP: + mod->HSMHV_ovslp = value->rValue; + mod->HSMHV_ovslp_Given = TRUE; + break; + case HSMHV_MOD_OVMAG: + mod->HSMHV_ovmag = value->rValue; + mod->HSMHV_ovmag_Given = TRUE; + break; + case HSMHV_MOD_GBMIN: + mod->HSMHV_gbmin = value->rValue; + mod->HSMHV_gbmin_Given = TRUE; + break; + case HSMHV_MOD_RBPB: + mod->HSMHV_rbpb = value->rValue; + mod->HSMHV_rbpb_Given = TRUE; + break; + case HSMHV_MOD_RBPD: + mod->HSMHV_rbpd = value->rValue; + mod->HSMHV_rbpd_Given = TRUE; + break; + case HSMHV_MOD_RBPS: + mod->HSMHV_rbps = value->rValue; + mod->HSMHV_rbps_Given = TRUE; + break; + case HSMHV_MOD_RBDB: + mod->HSMHV_rbdb = value->rValue; + mod->HSMHV_rbdb_Given = TRUE; + break; + case HSMHV_MOD_RBSB: + mod->HSMHV_rbsb = value->rValue; + mod->HSMHV_rbsb_Given = TRUE; + break; + case HSMHV_MOD_IBPC1: + mod->HSMHV_ibpc1 = value->rValue; + mod->HSMHV_ibpc1_Given = TRUE; + break; + case HSMHV_MOD_IBPC2: + mod->HSMHV_ibpc2 = value->rValue; + mod->HSMHV_ibpc2_Given = TRUE; + break; + case HSMHV_MOD_MPHDFM: + mod->HSMHV_mphdfm = value->rValue; + mod->HSMHV_mphdfm_Given = TRUE; + break; + case HSMHV_MOD_RDVG11: + mod->HSMHV_rdvg11 = value->rValue; + mod->HSMHV_rdvg11_Given = TRUE; + break; + case HSMHV_MOD_RDVG12: + mod->HSMHV_rdvg12 = value->rValue; + mod->HSMHV_rdvg12_Given = TRUE; + break; + case HSMHV_MOD_RD20: + mod->HSMHV_rd20 = value->rValue; + mod->HSMHV_rd20_Given = TRUE; + break; + case HSMHV_MOD_QOVSM: + mod->HSMHV_qovsm = value->rValue; + mod->HSMHV_qovsm_Given = TRUE; + break; + case HSMHV_MOD_LDRIFT: + mod->HSMHV_ldrift = value->rValue; + mod->HSMHV_ldrift_Given = TRUE; + break; + case HSMHV_MOD_RD21: + mod->HSMHV_rd21 = value->rValue; + mod->HSMHV_rd21_Given = TRUE; + break; + case HSMHV_MOD_RD22: + mod->HSMHV_rd22 = value->rValue; + mod->HSMHV_rd22_Given = TRUE; + break; + case HSMHV_MOD_RD22D: + mod->HSMHV_rd22d = value->rValue; + mod->HSMHV_rd22d_Given = TRUE; + break; + case HSMHV_MOD_RD23: + mod->HSMHV_rd23 = value->rValue; + mod->HSMHV_rd23_Given = TRUE; + break; + case HSMHV_MOD_RD24: + mod->HSMHV_rd24 = value->rValue; + mod->HSMHV_rd24_Given = TRUE; + break; + case HSMHV_MOD_RD25: + mod->HSMHV_rd25 = value->rValue; + mod->HSMHV_rd25_Given = TRUE; + break; + case HSMHV_MOD_RD26: + mod->HSMHV_rd26 = value->rValue; + mod->HSMHV_rd26_Given = TRUE; + break; + case HSMHV_MOD_RDVDL: + mod->HSMHV_rdvdl = value->rValue; + mod->HSMHV_rdvdl_Given = TRUE; + break; + case HSMHV_MOD_RDVDLP: + mod->HSMHV_rdvdlp = value->rValue; + mod->HSMHV_rdvdlp_Given = TRUE; + break; + case HSMHV_MOD_RDVDS: + mod->HSMHV_rdvds = value->rValue; + mod->HSMHV_rdvds_Given = TRUE; + break; + case HSMHV_MOD_RDVDSP: + mod->HSMHV_rdvdsp = value->rValue; + mod->HSMHV_rdvdsp_Given = TRUE; + break; + case HSMHV_MOD_RD23L: + mod->HSMHV_rd23l = value->rValue; + mod->HSMHV_rd23l_Given = TRUE; + break; + case HSMHV_MOD_RD23LP: + mod->HSMHV_rd23lp = value->rValue; + mod->HSMHV_rd23lp_Given = TRUE; + break; + case HSMHV_MOD_RD23S: + mod->HSMHV_rd23s = value->rValue; + mod->HSMHV_rd23s_Given = TRUE; + break; + case HSMHV_MOD_RD23SP: + mod->HSMHV_rd23sp = value->rValue; + mod->HSMHV_rd23sp_Given = TRUE; + break; + case HSMHV_MOD_RDS: + mod->HSMHV_rds = value->rValue; + mod->HSMHV_rds_Given = TRUE; + break; + case HSMHV_MOD_RDSP: + mod->HSMHV_rdsp = value->rValue; + mod->HSMHV_rdsp_Given = TRUE; + break; + case HSMHV_MOD_RTH0: /* Self-heating model */ + mod->HSMHV_rth0 = value->rValue; + mod->HSMHV_rth0_Given = TRUE; + break; + case HSMHV_MOD_CTH0: /* Self-heating model */ + mod->HSMHV_cth0 = value->rValue; + mod->HSMHV_cth0_Given = TRUE; + break; + case HSMHV_MOD_POWRAT: /* Self-heating model */ + mod->HSMHV_powrat = value->rValue; + mod->HSMHV_powrat_Given = TRUE; + break; + case HSMHV_MOD_TCJBD: /* Self-heating model */ + mod->HSMHV_tcjbd = value->rValue; + mod->HSMHV_tcjbd_Given = TRUE; + break; + case HSMHV_MOD_TCJBS: /* Self-heating model */ + mod->HSMHV_tcjbs = value->rValue; + mod->HSMHV_tcjbs_Given = TRUE; + break; + case HSMHV_MOD_TCJBDSW: /* Self-heating model */ + mod->HSMHV_tcjbdsw = value->rValue; + mod->HSMHV_tcjbdsw_Given = TRUE; + break; + case HSMHV_MOD_TCJBSSW: /* Self-heating model */ + mod->HSMHV_tcjbssw = value->rValue; + mod->HSMHV_tcjbssw_Given = TRUE; + break; + case HSMHV_MOD_TCJBDSWG: /* Self-heating model */ + mod->HSMHV_tcjbdswg = value->rValue; + mod->HSMHV_tcjbdswg_Given = TRUE; + break; + case HSMHV_MOD_TCJBSSWG: /* Self-heating model */ + mod->HSMHV_tcjbsswg = value->rValue; + mod->HSMHV_tcjbsswg_Given = TRUE; + break; + + case HSMHV_MOD_DLYOV: + mod->HSMHV_dlyov = value->rValue; + mod->HSMHV_dlyov_Given = TRUE; + break; + case HSMHV_MOD_QDFTVD: + mod->HSMHV_qdftvd = value->rValue; + mod->HSMHV_qdftvd_Given = TRUE; + break; + case HSMHV_MOD_XLDLD: + mod->HSMHV_xldld = value->rValue; + mod->HSMHV_xldld_Given = TRUE; + break; + case HSMHV_MOD_XWDLD: + mod->HSMHV_xwdld = value->rValue; + mod->HSMHV_xwdld_Given = TRUE; + break; + case HSMHV_MOD_RDVD: + mod->HSMHV_rdvd = value->rValue; + mod->HSMHV_rdvd_Given = TRUE; + break; + + case HSMHV_MOD_RDTEMP1: + mod->HSMHV_rdtemp1 = value->rValue; + mod->HSMHV_rdtemp1_Given = TRUE; + break; + case HSMHV_MOD_RDTEMP2: + mod->HSMHV_rdtemp2 = value->rValue; + mod->HSMHV_rdtemp2_Given = TRUE; + break; + case HSMHV_MOD_RTH0R: + mod->HSMHV_rth0r = value->rValue; + mod->HSMHV_rth0r_Given = TRUE; + break; + case HSMHV_MOD_RDVDTEMP1: + mod->HSMHV_rdvdtemp1 = value->rValue; + mod->HSMHV_rdvdtemp1_Given = TRUE; + break; + case HSMHV_MOD_RDVDTEMP2: + mod->HSMHV_rdvdtemp2 = value->rValue; + mod->HSMHV_rdvdtemp2_Given = TRUE; + break; + case HSMHV_MOD_RTH0W: + mod->HSMHV_rth0w = value->rValue; + mod->HSMHV_rth0w_Given = TRUE; + break; + case HSMHV_MOD_RTH0WP: + mod->HSMHV_rth0wp = value->rValue; + mod->HSMHV_rth0wp_Given = TRUE; + break; + case HSMHV_MOD_CVDSOVER: + mod->HSMHV_cvdsover = value->rValue; + mod->HSMHV_cvdsover_Given = TRUE; + break; + + case HSMHV_MOD_NINVD: + mod->HSMHV_ninvd = value->rValue; + mod->HSMHV_ninvd_Given = TRUE; + break; + case HSMHV_MOD_NINVDW: + mod->HSMHV_ninvdw = value->rValue; + mod->HSMHV_ninvdw_Given = TRUE; + break; + case HSMHV_MOD_NINVDWP: + mod->HSMHV_ninvdwp = value->rValue; + mod->HSMHV_ninvdwp_Given = TRUE; + break; + case HSMHV_MOD_NINVDT1: + mod->HSMHV_ninvdt1 = value->rValue; + mod->HSMHV_ninvdt1_Given = TRUE; + break; + case HSMHV_MOD_NINVDT2: + mod->HSMHV_ninvdt2 = value->rValue; + mod->HSMHV_ninvdt2_Given = TRUE; + break; + case HSMHV_MOD_VBSMIN: + mod->HSMHV_vbsmin = value->rValue; + mod->HSMHV_vbsmin_Given = TRUE; + break; + case HSMHV_MOD_RDVB: + mod->HSMHV_rdvb = value->rValue; + mod->HSMHV_rdvb_Given = TRUE; + break; + case HSMHV_MOD_RTH0NF: + mod->HSMHV_rth0nf = value->rValue; + mod->HSMHV_rth0nf_Given = TRUE; + break; + case HSMHV_MOD_RTHTEMP1: + mod->HSMHV_rthtemp1 = value->rValue; + mod->HSMHV_rthtemp1_Given = TRUE; + break; + case HSMHV_MOD_RTHTEMP2: + mod->HSMHV_rthtemp2 = value->rValue; + mod->HSMHV_rthtemp2_Given = TRUE; + break; + case HSMHV_MOD_PRATTEMP1: + mod->HSMHV_prattemp1 = value->rValue; + mod->HSMHV_prattemp1_Given = TRUE; + break; + case HSMHV_MOD_PRATTEMP2: + mod->HSMHV_prattemp2 = value->rValue; + mod->HSMHV_prattemp2_Given = TRUE; + break; + + case HSMHV_MOD_RDVSUB: /* substrate effect */ + mod->HSMHV_rdvsub = value->rValue; + mod->HSMHV_rdvsub_Given = TRUE; + break; + case HSMHV_MOD_RDVDSUB: + mod->HSMHV_rdvdsub = value->rValue; + mod->HSMHV_rdvdsub_Given = TRUE; + break; + case HSMHV_MOD_DDRIFT: + mod->HSMHV_ddrift = value->rValue; + mod->HSMHV_ddrift_Given = TRUE; + break; + case HSMHV_MOD_VBISUB: + mod->HSMHV_vbisub = value->rValue; + mod->HSMHV_vbisub_Given = TRUE; + break; + case HSMHV_MOD_NSUBSUB: + mod->HSMHV_nsubsub = value->rValue; + mod->HSMHV_nsubsub_Given = TRUE; + break; + case HSMHV_MOD_SHEMAX: + mod->HSMHV_shemax = value->rValue; + mod->HSMHV_shemax_Given = TRUE; + break; + + + + /* binning parameters */ + case HSMHV_MOD_LMIN: + mod->HSMHV_lmin = value->rValue; + mod->HSMHV_lmin_Given = TRUE; + break; + case HSMHV_MOD_LMAX: + mod->HSMHV_lmax = value->rValue; + mod->HSMHV_lmax_Given = TRUE; + break; + case HSMHV_MOD_WMIN: + mod->HSMHV_wmin = value->rValue; + mod->HSMHV_wmin_Given = TRUE; + break; + case HSMHV_MOD_WMAX: + mod->HSMHV_wmax = value->rValue; + mod->HSMHV_wmax_Given = TRUE; + break; + case HSMHV_MOD_LBINN: + mod->HSMHV_lbinn = value->rValue; + mod->HSMHV_lbinn_Given = TRUE; + break; + case HSMHV_MOD_WBINN: + mod->HSMHV_wbinn = value->rValue; + mod->HSMHV_wbinn_Given = TRUE; + break; + + /* Length dependence */ + case HSMHV_MOD_LVMAX: + mod->HSMHV_lvmax = value->rValue; + mod->HSMHV_lvmax_Given = TRUE; + break; + case HSMHV_MOD_LBGTMP1: + mod->HSMHV_lbgtmp1 = value->rValue; + mod->HSMHV_lbgtmp1_Given = TRUE; + break; + case HSMHV_MOD_LBGTMP2: + mod->HSMHV_lbgtmp2 = value->rValue; + mod->HSMHV_lbgtmp2_Given = TRUE; + break; + case HSMHV_MOD_LEG0: + mod->HSMHV_leg0 = value->rValue; + mod->HSMHV_leg0_Given = TRUE; + break; + case HSMHV_MOD_LVFBOVER: + mod->HSMHV_lvfbover = value->rValue; + mod->HSMHV_lvfbover_Given = TRUE; + break; + case HSMHV_MOD_LNOVER: + mod->HSMHV_lnover = value->rValue; + mod->HSMHV_lnover_Given = TRUE; + break; + case HSMHV_MOD_LNOVERS: + mod->HSMHV_lnovers = value->rValue; + mod->HSMHV_lnovers_Given = TRUE; + break; + case HSMHV_MOD_LWL2: + mod->HSMHV_lwl2 = value->rValue; + mod->HSMHV_lwl2_Given = TRUE; + break; + case HSMHV_MOD_LVFBC: + mod->HSMHV_lvfbc = value->rValue; + mod->HSMHV_lvfbc_Given = TRUE; + break; + case HSMHV_MOD_LNSUBC: + mod->HSMHV_lnsubc = value->rValue; + mod->HSMHV_lnsubc_Given = TRUE; + break; + case HSMHV_MOD_LNSUBP: + mod->HSMHV_lnsubp = value->rValue; + mod->HSMHV_lnsubp_Given = TRUE; + break; + case HSMHV_MOD_LSCP1: + mod->HSMHV_lscp1 = value->rValue; + mod->HSMHV_lscp1_Given = TRUE; + break; + case HSMHV_MOD_LSCP2: + mod->HSMHV_lscp2 = value->rValue; + mod->HSMHV_lscp2_Given = TRUE; + break; + case HSMHV_MOD_LSCP3: + mod->HSMHV_lscp3 = value->rValue; + mod->HSMHV_lscp3_Given = TRUE; + break; + case HSMHV_MOD_LSC1: + mod->HSMHV_lsc1 = value->rValue; + mod->HSMHV_lsc1_Given = TRUE; + break; + case HSMHV_MOD_LSC2: + mod->HSMHV_lsc2 = value->rValue; + mod->HSMHV_lsc2_Given = TRUE; + break; + case HSMHV_MOD_LSC3: + mod->HSMHV_lsc3 = value->rValue; + mod->HSMHV_lsc3_Given = TRUE; + break; + case HSMHV_MOD_LPGD1: + mod->HSMHV_lpgd1 = value->rValue; + mod->HSMHV_lpgd1_Given = TRUE; + break; + case HSMHV_MOD_LPGD3: + mod->HSMHV_lpgd3 = value->rValue; + mod->HSMHV_lpgd3_Given = TRUE; + break; + case HSMHV_MOD_LNDEP: + mod->HSMHV_lndep = value->rValue; + mod->HSMHV_lndep_Given = TRUE; + break; + case HSMHV_MOD_LNINV: + mod->HSMHV_lninv = value->rValue; + mod->HSMHV_lninv_Given = TRUE; + break; + case HSMHV_MOD_LMUECB0: + mod->HSMHV_lmuecb0 = value->rValue; + mod->HSMHV_lmuecb0_Given = TRUE; + break; + case HSMHV_MOD_LMUECB1: + mod->HSMHV_lmuecb1 = value->rValue; + mod->HSMHV_lmuecb1_Given = TRUE; + break; + case HSMHV_MOD_LMUEPH1: + mod->HSMHV_lmueph1 = value->rValue; + mod->HSMHV_lmueph1_Given = TRUE; + break; + case HSMHV_MOD_LVTMP: + mod->HSMHV_lvtmp = value->rValue; + mod->HSMHV_lvtmp_Given = TRUE; + break; + case HSMHV_MOD_LWVTH0: + mod->HSMHV_lwvth0 = value->rValue; + mod->HSMHV_lwvth0_Given = TRUE; + break; + case HSMHV_MOD_LMUESR1: + mod->HSMHV_lmuesr1 = value->rValue; + mod->HSMHV_lmuesr1_Given = TRUE; + break; + case HSMHV_MOD_LMUETMP: + mod->HSMHV_lmuetmp = value->rValue; + mod->HSMHV_lmuetmp_Given = TRUE; + break; + case HSMHV_MOD_LSUB1: + mod->HSMHV_lsub1 = value->rValue; + mod->HSMHV_lsub1_Given = TRUE; + break; + case HSMHV_MOD_LSUB2: + mod->HSMHV_lsub2 = value->rValue; + mod->HSMHV_lsub2_Given = TRUE; + break; + case HSMHV_MOD_LSVDS: + mod->HSMHV_lsvds = value->rValue; + mod->HSMHV_lsvds_Given = TRUE; + break; + case HSMHV_MOD_LSVBS: + mod->HSMHV_lsvbs = value->rValue; + mod->HSMHV_lsvbs_Given = TRUE; + break; + case HSMHV_MOD_LSVGS: + mod->HSMHV_lsvgs = value->rValue; + mod->HSMHV_lsvgs_Given = TRUE; + break; + case HSMHV_MOD_LFN1: + mod->HSMHV_lfn1 = value->rValue; + mod->HSMHV_lfn1_Given = TRUE; + break; + case HSMHV_MOD_LFN2: + mod->HSMHV_lfn2 = value->rValue; + mod->HSMHV_lfn2_Given = TRUE; + break; + case HSMHV_MOD_LFN3: + mod->HSMHV_lfn3 = value->rValue; + mod->HSMHV_lfn3_Given = TRUE; + break; + case HSMHV_MOD_LFVBS: + mod->HSMHV_lfvbs = value->rValue; + mod->HSMHV_lfvbs_Given = TRUE; + break; + case HSMHV_MOD_LNSTI: + mod->HSMHV_lnsti = value->rValue; + mod->HSMHV_lnsti_Given = TRUE; + break; + case HSMHV_MOD_LWSTI: + mod->HSMHV_lwsti = value->rValue; + mod->HSMHV_lwsti_Given = TRUE; + break; + case HSMHV_MOD_LSCSTI1: + mod->HSMHV_lscsti1 = value->rValue; + mod->HSMHV_lscsti1_Given = TRUE; + break; + case HSMHV_MOD_LSCSTI2: + mod->HSMHV_lscsti2 = value->rValue; + mod->HSMHV_lscsti2_Given = TRUE; + break; + case HSMHV_MOD_LVTHSTI: + mod->HSMHV_lvthsti = value->rValue; + mod->HSMHV_lvthsti_Given = TRUE; + break; + case HSMHV_MOD_LMUESTI1: + mod->HSMHV_lmuesti1 = value->rValue; + mod->HSMHV_lmuesti1_Given = TRUE; + break; + case HSMHV_MOD_LMUESTI2: + mod->HSMHV_lmuesti2 = value->rValue; + mod->HSMHV_lmuesti2_Given = TRUE; + break; + case HSMHV_MOD_LMUESTI3: + mod->HSMHV_lmuesti3 = value->rValue; + mod->HSMHV_lmuesti3_Given = TRUE; + break; + case HSMHV_MOD_LNSUBPSTI1: + mod->HSMHV_lnsubpsti1 = value->rValue; + mod->HSMHV_lnsubpsti1_Given = TRUE; + break; + case HSMHV_MOD_LNSUBPSTI2: + mod->HSMHV_lnsubpsti2 = value->rValue; + mod->HSMHV_lnsubpsti2_Given = TRUE; + break; + case HSMHV_MOD_LNSUBPSTI3: + mod->HSMHV_lnsubpsti3 = value->rValue; + mod->HSMHV_lnsubpsti3_Given = TRUE; + break; + case HSMHV_MOD_LCGSO: + mod->HSMHV_lcgso = value->rValue; + mod->HSMHV_lcgso_Given = TRUE; + break; + case HSMHV_MOD_LCGDO: + mod->HSMHV_lcgdo = value->rValue; + mod->HSMHV_lcgdo_Given = TRUE; + break; + case HSMHV_MOD_LJS0: + mod->HSMHV_ljs0 = value->rValue; + mod->HSMHV_ljs0_Given = TRUE; + break; + case HSMHV_MOD_LJS0SW: + mod->HSMHV_ljs0sw = value->rValue; + mod->HSMHV_ljs0sw_Given = TRUE; + break; + case HSMHV_MOD_LNJ: + mod->HSMHV_lnj = value->rValue; + mod->HSMHV_lnj_Given = TRUE; + break; + case HSMHV_MOD_LCISBK: + mod->HSMHV_lcisbk = value->rValue; + mod->HSMHV_lcisbk_Given = TRUE; + break; + case HSMHV_MOD_LCLM1: + mod->HSMHV_lclm1 = value->rValue; + mod->HSMHV_lclm1_Given = TRUE; + break; + case HSMHV_MOD_LCLM2: + mod->HSMHV_lclm2 = value->rValue; + mod->HSMHV_lclm2_Given = TRUE; + break; + case HSMHV_MOD_LCLM3: + mod->HSMHV_lclm3 = value->rValue; + mod->HSMHV_lclm3_Given = TRUE; + break; + case HSMHV_MOD_LWFC: + mod->HSMHV_lwfc = value->rValue; + mod->HSMHV_lwfc_Given = TRUE; + break; + case HSMHV_MOD_LGIDL1: + mod->HSMHV_lgidl1 = value->rValue; + mod->HSMHV_lgidl1_Given = TRUE; + break; + case HSMHV_MOD_LGIDL2: + mod->HSMHV_lgidl2 = value->rValue; + mod->HSMHV_lgidl2_Given = TRUE; + break; + case HSMHV_MOD_LGLEAK1: + mod->HSMHV_lgleak1 = value->rValue; + mod->HSMHV_lgleak1_Given = TRUE; + break; + case HSMHV_MOD_LGLEAK2: + mod->HSMHV_lgleak2 = value->rValue; + mod->HSMHV_lgleak2_Given = TRUE; + break; + case HSMHV_MOD_LGLEAK3: + mod->HSMHV_lgleak3 = value->rValue; + mod->HSMHV_lgleak3_Given = TRUE; + break; + case HSMHV_MOD_LGLEAK6: + mod->HSMHV_lgleak6 = value->rValue; + mod->HSMHV_lgleak6_Given = TRUE; + break; + case HSMHV_MOD_LGLKSD1: + mod->HSMHV_lglksd1 = value->rValue; + mod->HSMHV_lglksd1_Given = TRUE; + break; + case HSMHV_MOD_LGLKSD2: + mod->HSMHV_lglksd2 = value->rValue; + mod->HSMHV_lglksd2_Given = TRUE; + break; + case HSMHV_MOD_LGLKB1: + mod->HSMHV_lglkb1 = value->rValue; + mod->HSMHV_lglkb1_Given = TRUE; + break; + case HSMHV_MOD_LGLKB2: + mod->HSMHV_lglkb2 = value->rValue; + mod->HSMHV_lglkb2_Given = TRUE; + break; + case HSMHV_MOD_LNFTRP: + mod->HSMHV_lnftrp = value->rValue; + mod->HSMHV_lnftrp_Given = TRUE; + break; + case HSMHV_MOD_LNFALP: + mod->HSMHV_lnfalp = value->rValue; + mod->HSMHV_lnfalp_Given = TRUE; + break; + case HSMHV_MOD_LPTHROU: + mod->HSMHV_lpthrou = value->rValue; + mod->HSMHV_lpthrou_Given = TRUE; + break; + case HSMHV_MOD_LVDIFFJ: + mod->HSMHV_lvdiffj = value->rValue; + mod->HSMHV_lvdiffj_Given = TRUE; + break; + case HSMHV_MOD_LIBPC1: + mod->HSMHV_libpc1 = value->rValue; + mod->HSMHV_libpc1_Given = TRUE; + break; + case HSMHV_MOD_LIBPC2: + mod->HSMHV_libpc2 = value->rValue; + mod->HSMHV_libpc2_Given = TRUE; + break; + break; + case HSMHV_MOD_LCGBO: + mod->HSMHV_lcgbo = value->rValue; + mod->HSMHV_lcgbo_Given = TRUE; + break; + case HSMHV_MOD_LCVDSOVER: + mod->HSMHV_lcvdsover = value->rValue; + mod->HSMHV_lcvdsover_Given = TRUE; + break; + case HSMHV_MOD_LFALPH: + mod->HSMHV_lfalph = value->rValue; + mod->HSMHV_lfalph_Given = TRUE; + break; + case HSMHV_MOD_LNPEXT: + mod->HSMHV_lnpext = value->rValue; + mod->HSMHV_lnpext_Given = TRUE; + break; + case HSMHV_MOD_LPOWRAT: + mod->HSMHV_lpowrat = value->rValue; + mod->HSMHV_lpowrat_Given = TRUE; + break; + case HSMHV_MOD_LRD: + mod->HSMHV_lrd = value->rValue; + mod->HSMHV_lrd_Given = TRUE; + break; + case HSMHV_MOD_LRD22: + mod->HSMHV_lrd22 = value->rValue; + mod->HSMHV_lrd22_Given = TRUE; + break; + case HSMHV_MOD_LRD23: + mod->HSMHV_lrd23 = value->rValue; + mod->HSMHV_lrd23_Given = TRUE; + break; + case HSMHV_MOD_LRD24: + mod->HSMHV_lrd24 = value->rValue; + mod->HSMHV_lrd24_Given = TRUE; + break; + case HSMHV_MOD_LRDICT1: + mod->HSMHV_lrdict1 = value->rValue; + mod->HSMHV_lrdict1_Given = TRUE; + break; + case HSMHV_MOD_LRDOV13: + mod->HSMHV_lrdov13 = value->rValue; + mod->HSMHV_lrdov13_Given = TRUE; + break; + case HSMHV_MOD_LRDSLP1: + mod->HSMHV_lrdslp1 = value->rValue; + mod->HSMHV_lrdslp1_Given = TRUE; + break; + case HSMHV_MOD_LRDVB: + mod->HSMHV_lrdvb = value->rValue; + mod->HSMHV_lrdvb_Given = TRUE; + break; + case HSMHV_MOD_LRDVD: + mod->HSMHV_lrdvd = value->rValue; + mod->HSMHV_lrdvd_Given = TRUE; + break; + case HSMHV_MOD_LRDVG11: + mod->HSMHV_lrdvg11 = value->rValue; + mod->HSMHV_lrdvg11_Given = TRUE; + break; + case HSMHV_MOD_LRS: + mod->HSMHV_lrs = value->rValue; + mod->HSMHV_lrs_Given = TRUE; + break; + case HSMHV_MOD_LRTH0: + mod->HSMHV_lrth0 = value->rValue; + mod->HSMHV_lrth0_Given = TRUE; + break; + case HSMHV_MOD_LVOVER: + mod->HSMHV_lvover = value->rValue; + mod->HSMHV_lvover_Given = TRUE; + break; + + /* Width dependence */ + case HSMHV_MOD_WVMAX: + mod->HSMHV_wvmax = value->rValue; + mod->HSMHV_wvmax_Given = TRUE; + break; + case HSMHV_MOD_WBGTMP1: + mod->HSMHV_wbgtmp1 = value->rValue; + mod->HSMHV_wbgtmp1_Given = TRUE; + break; + case HSMHV_MOD_WBGTMP2: + mod->HSMHV_wbgtmp2 = value->rValue; + mod->HSMHV_wbgtmp2_Given = TRUE; + break; + case HSMHV_MOD_WEG0: + mod->HSMHV_weg0 = value->rValue; + mod->HSMHV_weg0_Given = TRUE; + break; + case HSMHV_MOD_WVFBOVER: + mod->HSMHV_wvfbover = value->rValue; + mod->HSMHV_wvfbover_Given = TRUE; + break; + case HSMHV_MOD_WNOVER: + mod->HSMHV_wnover = value->rValue; + mod->HSMHV_wnover_Given = TRUE; + break; + case HSMHV_MOD_WNOVERS: + mod->HSMHV_wnovers = value->rValue; + mod->HSMHV_wnovers_Given = TRUE; + break; + case HSMHV_MOD_WWL2: + mod->HSMHV_wwl2 = value->rValue; + mod->HSMHV_wwl2_Given = TRUE; + break; + case HSMHV_MOD_WVFBC: + mod->HSMHV_wvfbc = value->rValue; + mod->HSMHV_wvfbc_Given = TRUE; + break; + case HSMHV_MOD_WNSUBC: + mod->HSMHV_wnsubc = value->rValue; + mod->HSMHV_wnsubc_Given = TRUE; + break; + case HSMHV_MOD_WNSUBP: + mod->HSMHV_wnsubp = value->rValue; + mod->HSMHV_wnsubp_Given = TRUE; + break; + case HSMHV_MOD_WSCP1: + mod->HSMHV_wscp1 = value->rValue; + mod->HSMHV_wscp1_Given = TRUE; + break; + case HSMHV_MOD_WSCP2: + mod->HSMHV_wscp2 = value->rValue; + mod->HSMHV_wscp2_Given = TRUE; + break; + case HSMHV_MOD_WSCP3: + mod->HSMHV_wscp3 = value->rValue; + mod->HSMHV_wscp3_Given = TRUE; + break; + case HSMHV_MOD_WSC1: + mod->HSMHV_wsc1 = value->rValue; + mod->HSMHV_wsc1_Given = TRUE; + break; + case HSMHV_MOD_WSC2: + mod->HSMHV_wsc2 = value->rValue; + mod->HSMHV_wsc2_Given = TRUE; + break; + case HSMHV_MOD_WSC3: + mod->HSMHV_wsc3 = value->rValue; + mod->HSMHV_wsc3_Given = TRUE; + break; + case HSMHV_MOD_WPGD1: + mod->HSMHV_wpgd1 = value->rValue; + mod->HSMHV_wpgd1_Given = TRUE; + break; + case HSMHV_MOD_WPGD3: + mod->HSMHV_wpgd3 = value->rValue; + mod->HSMHV_wpgd3_Given = TRUE; + break; + case HSMHV_MOD_WNDEP: + mod->HSMHV_wndep = value->rValue; + mod->HSMHV_wndep_Given = TRUE; + break; + case HSMHV_MOD_WNINV: + mod->HSMHV_wninv = value->rValue; + mod->HSMHV_wninv_Given = TRUE; + break; + case HSMHV_MOD_WMUECB0: + mod->HSMHV_wmuecb0 = value->rValue; + mod->HSMHV_wmuecb0_Given = TRUE; + break; + case HSMHV_MOD_WMUECB1: + mod->HSMHV_wmuecb1 = value->rValue; + mod->HSMHV_wmuecb1_Given = TRUE; + break; + case HSMHV_MOD_WMUEPH1: + mod->HSMHV_wmueph1 = value->rValue; + mod->HSMHV_wmueph1_Given = TRUE; + break; + case HSMHV_MOD_WVTMP: + mod->HSMHV_wvtmp = value->rValue; + mod->HSMHV_wvtmp_Given = TRUE; + break; + case HSMHV_MOD_WWVTH0: + mod->HSMHV_wwvth0 = value->rValue; + mod->HSMHV_wwvth0_Given = TRUE; + break; + case HSMHV_MOD_WMUESR1: + mod->HSMHV_wmuesr1 = value->rValue; + mod->HSMHV_wmuesr1_Given = TRUE; + break; + case HSMHV_MOD_WMUETMP: + mod->HSMHV_wmuetmp = value->rValue; + mod->HSMHV_wmuetmp_Given = TRUE; + break; + case HSMHV_MOD_WSUB1: + mod->HSMHV_wsub1 = value->rValue; + mod->HSMHV_wsub1_Given = TRUE; + break; + case HSMHV_MOD_WSUB2: + mod->HSMHV_wsub2 = value->rValue; + mod->HSMHV_wsub2_Given = TRUE; + break; + case HSMHV_MOD_WSVDS: + mod->HSMHV_wsvds = value->rValue; + mod->HSMHV_wsvds_Given = TRUE; + break; + case HSMHV_MOD_WSVBS: + mod->HSMHV_wsvbs = value->rValue; + mod->HSMHV_wsvbs_Given = TRUE; + break; + case HSMHV_MOD_WSVGS: + mod->HSMHV_wsvgs = value->rValue; + mod->HSMHV_wsvgs_Given = TRUE; + break; + case HSMHV_MOD_WFN1: + mod->HSMHV_wfn1 = value->rValue; + mod->HSMHV_wfn1_Given = TRUE; + break; + case HSMHV_MOD_WFN2: + mod->HSMHV_wfn2 = value->rValue; + mod->HSMHV_wfn2_Given = TRUE; + break; + case HSMHV_MOD_WFN3: + mod->HSMHV_wfn3 = value->rValue; + mod->HSMHV_wfn3_Given = TRUE; + break; + case HSMHV_MOD_WFVBS: + mod->HSMHV_wfvbs = value->rValue; + mod->HSMHV_wfvbs_Given = TRUE; + break; + case HSMHV_MOD_WNSTI: + mod->HSMHV_wnsti = value->rValue; + mod->HSMHV_wnsti_Given = TRUE; + break; + case HSMHV_MOD_WWSTI: + mod->HSMHV_wwsti = value->rValue; + mod->HSMHV_wwsti_Given = TRUE; + break; + case HSMHV_MOD_WSCSTI1: + mod->HSMHV_wscsti1 = value->rValue; + mod->HSMHV_wscsti1_Given = TRUE; + break; + case HSMHV_MOD_WSCSTI2: + mod->HSMHV_wscsti2 = value->rValue; + mod->HSMHV_wscsti2_Given = TRUE; + break; + case HSMHV_MOD_WVTHSTI: + mod->HSMHV_wvthsti = value->rValue; + mod->HSMHV_wvthsti_Given = TRUE; + break; + case HSMHV_MOD_WMUESTI1: + mod->HSMHV_wmuesti1 = value->rValue; + mod->HSMHV_wmuesti1_Given = TRUE; + break; + case HSMHV_MOD_WMUESTI2: + mod->HSMHV_wmuesti2 = value->rValue; + mod->HSMHV_wmuesti2_Given = TRUE; + break; + case HSMHV_MOD_WMUESTI3: + mod->HSMHV_wmuesti3 = value->rValue; + mod->HSMHV_wmuesti3_Given = TRUE; + break; + case HSMHV_MOD_WNSUBPSTI1: + mod->HSMHV_wnsubpsti1 = value->rValue; + mod->HSMHV_wnsubpsti1_Given = TRUE; + break; + case HSMHV_MOD_WNSUBPSTI2: + mod->HSMHV_wnsubpsti2 = value->rValue; + mod->HSMHV_wnsubpsti2_Given = TRUE; + break; + case HSMHV_MOD_WNSUBPSTI3: + mod->HSMHV_wnsubpsti3 = value->rValue; + mod->HSMHV_wnsubpsti3_Given = TRUE; + break; + case HSMHV_MOD_WCGSO: + mod->HSMHV_wcgso = value->rValue; + mod->HSMHV_wcgso_Given = TRUE; + break; + case HSMHV_MOD_WCGDO: + mod->HSMHV_wcgdo = value->rValue; + mod->HSMHV_wcgdo_Given = TRUE; + break; + case HSMHV_MOD_WJS0: + mod->HSMHV_wjs0 = value->rValue; + mod->HSMHV_wjs0_Given = TRUE; + break; + case HSMHV_MOD_WJS0SW: + mod->HSMHV_wjs0sw = value->rValue; + mod->HSMHV_wjs0sw_Given = TRUE; + break; + case HSMHV_MOD_WNJ: + mod->HSMHV_wnj = value->rValue; + mod->HSMHV_wnj_Given = TRUE; + break; + case HSMHV_MOD_WCISBK: + mod->HSMHV_wcisbk = value->rValue; + mod->HSMHV_wcisbk_Given = TRUE; + break; + case HSMHV_MOD_WCLM1: + mod->HSMHV_wclm1 = value->rValue; + mod->HSMHV_wclm1_Given = TRUE; + break; + case HSMHV_MOD_WCLM2: + mod->HSMHV_wclm2 = value->rValue; + mod->HSMHV_wclm2_Given = TRUE; + break; + case HSMHV_MOD_WCLM3: + mod->HSMHV_wclm3 = value->rValue; + mod->HSMHV_wclm3_Given = TRUE; + break; + case HSMHV_MOD_WWFC: + mod->HSMHV_wwfc = value->rValue; + mod->HSMHV_wwfc_Given = TRUE; + break; + case HSMHV_MOD_WGIDL1: + mod->HSMHV_wgidl1 = value->rValue; + mod->HSMHV_wgidl1_Given = TRUE; + break; + case HSMHV_MOD_WGIDL2: + mod->HSMHV_wgidl2 = value->rValue; + mod->HSMHV_wgidl2_Given = TRUE; + break; + case HSMHV_MOD_WGLEAK1: + mod->HSMHV_wgleak1 = value->rValue; + mod->HSMHV_wgleak1_Given = TRUE; + break; + case HSMHV_MOD_WGLEAK2: + mod->HSMHV_wgleak2 = value->rValue; + mod->HSMHV_wgleak2_Given = TRUE; + break; + case HSMHV_MOD_WGLEAK3: + mod->HSMHV_wgleak3 = value->rValue; + mod->HSMHV_wgleak3_Given = TRUE; + break; + case HSMHV_MOD_WGLEAK6: + mod->HSMHV_wgleak6 = value->rValue; + mod->HSMHV_wgleak6_Given = TRUE; + break; + case HSMHV_MOD_WGLKSD1: + mod->HSMHV_wglksd1 = value->rValue; + mod->HSMHV_wglksd1_Given = TRUE; + break; + case HSMHV_MOD_WGLKSD2: + mod->HSMHV_wglksd2 = value->rValue; + mod->HSMHV_wglksd2_Given = TRUE; + break; + case HSMHV_MOD_WGLKB1: + mod->HSMHV_wglkb1 = value->rValue; + mod->HSMHV_wglkb1_Given = TRUE; + break; + case HSMHV_MOD_WGLKB2: + mod->HSMHV_wglkb2 = value->rValue; + mod->HSMHV_wglkb2_Given = TRUE; + break; + case HSMHV_MOD_WNFTRP: + mod->HSMHV_wnftrp = value->rValue; + mod->HSMHV_wnftrp_Given = TRUE; + break; + case HSMHV_MOD_WNFALP: + mod->HSMHV_wnfalp = value->rValue; + mod->HSMHV_wnfalp_Given = TRUE; + break; + case HSMHV_MOD_WPTHROU: + mod->HSMHV_wpthrou = value->rValue; + mod->HSMHV_wpthrou_Given = TRUE; + break; + case HSMHV_MOD_WVDIFFJ: + mod->HSMHV_wvdiffj = value->rValue; + mod->HSMHV_wvdiffj_Given = TRUE; + break; + case HSMHV_MOD_WIBPC1: + mod->HSMHV_wibpc1 = value->rValue; + mod->HSMHV_wibpc1_Given = TRUE; + break; + case HSMHV_MOD_WIBPC2: + mod->HSMHV_wibpc2 = value->rValue; + mod->HSMHV_wibpc2_Given = TRUE; + break; + break; + case HSMHV_MOD_WCGBO: + mod->HSMHV_wcgbo = value->rValue; + mod->HSMHV_wcgbo_Given = TRUE; + break; + case HSMHV_MOD_WCVDSOVER: + mod->HSMHV_wcvdsover = value->rValue; + mod->HSMHV_wcvdsover_Given = TRUE; + break; + case HSMHV_MOD_WFALPH: + mod->HSMHV_wfalph = value->rValue; + mod->HSMHV_wfalph_Given = TRUE; + break; + case HSMHV_MOD_WNPEXT: + mod->HSMHV_wnpext = value->rValue; + mod->HSMHV_wnpext_Given = TRUE; + break; + case HSMHV_MOD_WPOWRAT: + mod->HSMHV_wpowrat = value->rValue; + mod->HSMHV_wpowrat_Given = TRUE; + break; + case HSMHV_MOD_WRD: + mod->HSMHV_wrd = value->rValue; + mod->HSMHV_wrd_Given = TRUE; + break; + case HSMHV_MOD_WRD22: + mod->HSMHV_wrd22 = value->rValue; + mod->HSMHV_wrd22_Given = TRUE; + break; + case HSMHV_MOD_WRD23: + mod->HSMHV_wrd23 = value->rValue; + mod->HSMHV_wrd23_Given = TRUE; + break; + case HSMHV_MOD_WRD24: + mod->HSMHV_wrd24 = value->rValue; + mod->HSMHV_wrd24_Given = TRUE; + break; + case HSMHV_MOD_WRDICT1: + mod->HSMHV_wrdict1 = value->rValue; + mod->HSMHV_wrdict1_Given = TRUE; + break; + case HSMHV_MOD_WRDOV13: + mod->HSMHV_wrdov13 = value->rValue; + mod->HSMHV_wrdov13_Given = TRUE; + break; + case HSMHV_MOD_WRDSLP1: + mod->HSMHV_wrdslp1 = value->rValue; + mod->HSMHV_wrdslp1_Given = TRUE; + break; + case HSMHV_MOD_WRDVB: + mod->HSMHV_wrdvb = value->rValue; + mod->HSMHV_wrdvb_Given = TRUE; + break; + case HSMHV_MOD_WRDVD: + mod->HSMHV_wrdvd = value->rValue; + mod->HSMHV_wrdvd_Given = TRUE; + break; + case HSMHV_MOD_WRDVG11: + mod->HSMHV_wrdvg11 = value->rValue; + mod->HSMHV_wrdvg11_Given = TRUE; + break; + case HSMHV_MOD_WRS: + mod->HSMHV_wrs = value->rValue; + mod->HSMHV_wrs_Given = TRUE; + break; + case HSMHV_MOD_WRTH0: + mod->HSMHV_wrth0 = value->rValue; + mod->HSMHV_wrth0_Given = TRUE; + break; + case HSMHV_MOD_WVOVER: + mod->HSMHV_wvover = value->rValue; + mod->HSMHV_wvover_Given = TRUE; + break; + + /* Cross-term dependence */ + case HSMHV_MOD_PVMAX: + mod->HSMHV_pvmax = value->rValue; + mod->HSMHV_pvmax_Given = TRUE; + break; + case HSMHV_MOD_PBGTMP1: + mod->HSMHV_pbgtmp1 = value->rValue; + mod->HSMHV_pbgtmp1_Given = TRUE; + break; + case HSMHV_MOD_PBGTMP2: + mod->HSMHV_pbgtmp2 = value->rValue; + mod->HSMHV_pbgtmp2_Given = TRUE; + break; + case HSMHV_MOD_PEG0: + mod->HSMHV_peg0 = value->rValue; + mod->HSMHV_peg0_Given = TRUE; + break; + case HSMHV_MOD_PVFBOVER: + mod->HSMHV_pvfbover = value->rValue; + mod->HSMHV_pvfbover_Given = TRUE; + break; + case HSMHV_MOD_PNOVER: + mod->HSMHV_pnover = value->rValue; + mod->HSMHV_pnover_Given = TRUE; + break; + case HSMHV_MOD_PNOVERS: + mod->HSMHV_pnovers = value->rValue; + mod->HSMHV_pnovers_Given = TRUE; + break; + case HSMHV_MOD_PWL2: + mod->HSMHV_pwl2 = value->rValue; + mod->HSMHV_pwl2_Given = TRUE; + break; + case HSMHV_MOD_PVFBC: + mod->HSMHV_pvfbc = value->rValue; + mod->HSMHV_pvfbc_Given = TRUE; + break; + case HSMHV_MOD_PNSUBC: + mod->HSMHV_pnsubc = value->rValue; + mod->HSMHV_pnsubc_Given = TRUE; + break; + case HSMHV_MOD_PNSUBP: + mod->HSMHV_pnsubp = value->rValue; + mod->HSMHV_pnsubp_Given = TRUE; + break; + case HSMHV_MOD_PSCP1: + mod->HSMHV_pscp1 = value->rValue; + mod->HSMHV_pscp1_Given = TRUE; + break; + case HSMHV_MOD_PSCP2: + mod->HSMHV_pscp2 = value->rValue; + mod->HSMHV_pscp2_Given = TRUE; + break; + case HSMHV_MOD_PSCP3: + mod->HSMHV_pscp3 = value->rValue; + mod->HSMHV_pscp3_Given = TRUE; + break; + case HSMHV_MOD_PSC1: + mod->HSMHV_psc1 = value->rValue; + mod->HSMHV_psc1_Given = TRUE; + break; + case HSMHV_MOD_PSC2: + mod->HSMHV_psc2 = value->rValue; + mod->HSMHV_psc2_Given = TRUE; + break; + case HSMHV_MOD_PSC3: + mod->HSMHV_psc3 = value->rValue; + mod->HSMHV_psc3_Given = TRUE; + break; + case HSMHV_MOD_PPGD1: + mod->HSMHV_ppgd1 = value->rValue; + mod->HSMHV_ppgd1_Given = TRUE; + break; + case HSMHV_MOD_PPGD3: + mod->HSMHV_ppgd3 = value->rValue; + mod->HSMHV_ppgd3_Given = TRUE; + break; + case HSMHV_MOD_PNDEP: + mod->HSMHV_pndep = value->rValue; + mod->HSMHV_pndep_Given = TRUE; + break; + case HSMHV_MOD_PNINV: + mod->HSMHV_pninv = value->rValue; + mod->HSMHV_pninv_Given = TRUE; + break; + case HSMHV_MOD_PMUECB0: + mod->HSMHV_pmuecb0 = value->rValue; + mod->HSMHV_pmuecb0_Given = TRUE; + break; + case HSMHV_MOD_PMUECB1: + mod->HSMHV_pmuecb1 = value->rValue; + mod->HSMHV_pmuecb1_Given = TRUE; + break; + case HSMHV_MOD_PMUEPH1: + mod->HSMHV_pmueph1 = value->rValue; + mod->HSMHV_pmueph1_Given = TRUE; + break; + case HSMHV_MOD_PVTMP: + mod->HSMHV_pvtmp = value->rValue; + mod->HSMHV_pvtmp_Given = TRUE; + break; + case HSMHV_MOD_PWVTH0: + mod->HSMHV_pwvth0 = value->rValue; + mod->HSMHV_pwvth0_Given = TRUE; + break; + case HSMHV_MOD_PMUESR1: + mod->HSMHV_pmuesr1 = value->rValue; + mod->HSMHV_pmuesr1_Given = TRUE; + break; + case HSMHV_MOD_PMUETMP: + mod->HSMHV_pmuetmp = value->rValue; + mod->HSMHV_pmuetmp_Given = TRUE; + break; + case HSMHV_MOD_PSUB1: + mod->HSMHV_psub1 = value->rValue; + mod->HSMHV_psub1_Given = TRUE; + break; + case HSMHV_MOD_PSUB2: + mod->HSMHV_psub2 = value->rValue; + mod->HSMHV_psub2_Given = TRUE; + break; + case HSMHV_MOD_PSVDS: + mod->HSMHV_psvds = value->rValue; + mod->HSMHV_psvds_Given = TRUE; + break; + case HSMHV_MOD_PSVBS: + mod->HSMHV_psvbs = value->rValue; + mod->HSMHV_psvbs_Given = TRUE; + break; + case HSMHV_MOD_PSVGS: + mod->HSMHV_psvgs = value->rValue; + mod->HSMHV_psvgs_Given = TRUE; + break; + case HSMHV_MOD_PFN1: + mod->HSMHV_pfn1 = value->rValue; + mod->HSMHV_pfn1_Given = TRUE; + break; + case HSMHV_MOD_PFN2: + mod->HSMHV_pfn2 = value->rValue; + mod->HSMHV_pfn2_Given = TRUE; + break; + case HSMHV_MOD_PFN3: + mod->HSMHV_pfn3 = value->rValue; + mod->HSMHV_pfn3_Given = TRUE; + break; + case HSMHV_MOD_PFVBS: + mod->HSMHV_pfvbs = value->rValue; + mod->HSMHV_pfvbs_Given = TRUE; + break; + case HSMHV_MOD_PNSTI: + mod->HSMHV_pnsti = value->rValue; + mod->HSMHV_pnsti_Given = TRUE; + break; + case HSMHV_MOD_PWSTI: + mod->HSMHV_pwsti = value->rValue; + mod->HSMHV_pwsti_Given = TRUE; + break; + case HSMHV_MOD_PSCSTI1: + mod->HSMHV_pscsti1 = value->rValue; + mod->HSMHV_pscsti1_Given = TRUE; + break; + case HSMHV_MOD_PSCSTI2: + mod->HSMHV_pscsti2 = value->rValue; + mod->HSMHV_pscsti2_Given = TRUE; + break; + case HSMHV_MOD_PVTHSTI: + mod->HSMHV_pvthsti = value->rValue; + mod->HSMHV_pvthsti_Given = TRUE; + break; + case HSMHV_MOD_PMUESTI1: + mod->HSMHV_pmuesti1 = value->rValue; + mod->HSMHV_pmuesti1_Given = TRUE; + break; + case HSMHV_MOD_PMUESTI2: + mod->HSMHV_pmuesti2 = value->rValue; + mod->HSMHV_pmuesti2_Given = TRUE; + break; + case HSMHV_MOD_PMUESTI3: + mod->HSMHV_pmuesti3 = value->rValue; + mod->HSMHV_pmuesti3_Given = TRUE; + break; + case HSMHV_MOD_PNSUBPSTI1: + mod->HSMHV_pnsubpsti1 = value->rValue; + mod->HSMHV_pnsubpsti1_Given = TRUE; + break; + case HSMHV_MOD_PNSUBPSTI2: + mod->HSMHV_pnsubpsti2 = value->rValue; + mod->HSMHV_pnsubpsti2_Given = TRUE; + break; + case HSMHV_MOD_PNSUBPSTI3: + mod->HSMHV_pnsubpsti3 = value->rValue; + mod->HSMHV_pnsubpsti3_Given = TRUE; + break; + case HSMHV_MOD_PCGSO: + mod->HSMHV_pcgso = value->rValue; + mod->HSMHV_pcgso_Given = TRUE; + break; + case HSMHV_MOD_PCGDO: + mod->HSMHV_pcgdo = value->rValue; + mod->HSMHV_pcgdo_Given = TRUE; + break; + case HSMHV_MOD_PJS0: + mod->HSMHV_pjs0 = value->rValue; + mod->HSMHV_pjs0_Given = TRUE; + break; + case HSMHV_MOD_PJS0SW: + mod->HSMHV_pjs0sw = value->rValue; + mod->HSMHV_pjs0sw_Given = TRUE; + break; + case HSMHV_MOD_PNJ: + mod->HSMHV_pnj = value->rValue; + mod->HSMHV_pnj_Given = TRUE; + break; + case HSMHV_MOD_PCISBK: + mod->HSMHV_pcisbk = value->rValue; + mod->HSMHV_pcisbk_Given = TRUE; + break; + case HSMHV_MOD_PCLM1: + mod->HSMHV_pclm1 = value->rValue; + mod->HSMHV_pclm1_Given = TRUE; + break; + case HSMHV_MOD_PCLM2: + mod->HSMHV_pclm2 = value->rValue; + mod->HSMHV_pclm2_Given = TRUE; + break; + case HSMHV_MOD_PCLM3: + mod->HSMHV_pclm3 = value->rValue; + mod->HSMHV_pclm3_Given = TRUE; + break; + case HSMHV_MOD_PWFC: + mod->HSMHV_pwfc = value->rValue; + mod->HSMHV_pwfc_Given = TRUE; + break; + case HSMHV_MOD_PGIDL1: + mod->HSMHV_pgidl1 = value->rValue; + mod->HSMHV_pgidl1_Given = TRUE; + break; + case HSMHV_MOD_PGIDL2: + mod->HSMHV_pgidl2 = value->rValue; + mod->HSMHV_pgidl2_Given = TRUE; + break; + case HSMHV_MOD_PGLEAK1: + mod->HSMHV_pgleak1 = value->rValue; + mod->HSMHV_pgleak1_Given = TRUE; + break; + case HSMHV_MOD_PGLEAK2: + mod->HSMHV_pgleak2 = value->rValue; + mod->HSMHV_pgleak2_Given = TRUE; + break; + case HSMHV_MOD_PGLEAK3: + mod->HSMHV_pgleak3 = value->rValue; + mod->HSMHV_pgleak3_Given = TRUE; + break; + case HSMHV_MOD_PGLEAK6: + mod->HSMHV_pgleak6 = value->rValue; + mod->HSMHV_pgleak6_Given = TRUE; + break; + case HSMHV_MOD_PGLKSD1: + mod->HSMHV_pglksd1 = value->rValue; + mod->HSMHV_pglksd1_Given = TRUE; + break; + case HSMHV_MOD_PGLKSD2: + mod->HSMHV_pglksd2 = value->rValue; + mod->HSMHV_pglksd2_Given = TRUE; + break; + case HSMHV_MOD_PGLKB1: + mod->HSMHV_pglkb1 = value->rValue; + mod->HSMHV_pglkb1_Given = TRUE; + break; + case HSMHV_MOD_PGLKB2: + mod->HSMHV_pglkb2 = value->rValue; + mod->HSMHV_pglkb2_Given = TRUE; + break; + case HSMHV_MOD_PNFTRP: + mod->HSMHV_pnftrp = value->rValue; + mod->HSMHV_pnftrp_Given = TRUE; + break; + case HSMHV_MOD_PNFALP: + mod->HSMHV_pnfalp = value->rValue; + mod->HSMHV_pnfalp_Given = TRUE; + break; + case HSMHV_MOD_PPTHROU: + mod->HSMHV_ppthrou = value->rValue; + mod->HSMHV_ppthrou_Given = TRUE; + break; + case HSMHV_MOD_PVDIFFJ: + mod->HSMHV_pvdiffj = value->rValue; + mod->HSMHV_pvdiffj_Given = TRUE; + break; + case HSMHV_MOD_PIBPC1: + mod->HSMHV_pibpc1 = value->rValue; + mod->HSMHV_pibpc1_Given = TRUE; + break; + case HSMHV_MOD_PIBPC2: + mod->HSMHV_pibpc2 = value->rValue; + mod->HSMHV_pibpc2_Given = TRUE; + break; + break; + case HSMHV_MOD_PCGBO: + mod->HSMHV_pcgbo = value->rValue; + mod->HSMHV_pcgbo_Given = TRUE; + break; + case HSMHV_MOD_PCVDSOVER: + mod->HSMHV_pcvdsover = value->rValue; + mod->HSMHV_pcvdsover_Given = TRUE; + break; + case HSMHV_MOD_PFALPH: + mod->HSMHV_pfalph = value->rValue; + mod->HSMHV_pfalph_Given = TRUE; + break; + case HSMHV_MOD_PNPEXT: + mod->HSMHV_pnpext = value->rValue; + mod->HSMHV_pnpext_Given = TRUE; + break; + case HSMHV_MOD_PPOWRAT: + mod->HSMHV_ppowrat = value->rValue; + mod->HSMHV_ppowrat_Given = TRUE; + break; + case HSMHV_MOD_PRD: + mod->HSMHV_prd = value->rValue; + mod->HSMHV_prd_Given = TRUE; + break; + case HSMHV_MOD_PRD22: + mod->HSMHV_prd22 = value->rValue; + mod->HSMHV_prd22_Given = TRUE; + break; + case HSMHV_MOD_PRD23: + mod->HSMHV_prd23 = value->rValue; + mod->HSMHV_prd23_Given = TRUE; + break; + case HSMHV_MOD_PRD24: + mod->HSMHV_prd24 = value->rValue; + mod->HSMHV_prd24_Given = TRUE; + break; + case HSMHV_MOD_PRDICT1: + mod->HSMHV_prdict1 = value->rValue; + mod->HSMHV_prdict1_Given = TRUE; + break; + case HSMHV_MOD_PRDOV13: + mod->HSMHV_prdov13 = value->rValue; + mod->HSMHV_prdov13_Given = TRUE; + break; + case HSMHV_MOD_PRDSLP1: + mod->HSMHV_prdslp1 = value->rValue; + mod->HSMHV_prdslp1_Given = TRUE; + break; + case HSMHV_MOD_PRDVB: + mod->HSMHV_prdvb = value->rValue; + mod->HSMHV_prdvb_Given = TRUE; + break; + case HSMHV_MOD_PRDVD: + mod->HSMHV_prdvd = value->rValue; + mod->HSMHV_prdvd_Given = TRUE; + break; + case HSMHV_MOD_PRDVG11: + mod->HSMHV_prdvg11 = value->rValue; + mod->HSMHV_prdvg11_Given = TRUE; + break; + case HSMHV_MOD_PRS: + mod->HSMHV_prs = value->rValue; + mod->HSMHV_prs_Given = TRUE; + break; + case HSMHV_MOD_PRTH0: + mod->HSMHV_prth0 = value->rValue; + mod->HSMHV_prth0_Given = TRUE; + break; + case HSMHV_MOD_PVOVER: + mod->HSMHV_pvover = value->rValue; + mod->HSMHV_pvover_Given = TRUE; + break; + + default: + return(E_BADPARM); + } + return(OK); +} diff --git a/src/spicelib/devices/hisimhv/hsmhvnoi.c b/src/spicelib/devices/hisimhv/hsmhvnoi.c new file mode 100644 index 000000000..c2d69a07d --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvnoi.c @@ -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 +#include +#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); +} + + + diff --git a/src/spicelib/devices/hisimhv/hsmhvpar.c b/src/spicelib/devices/hisimhv/hsmhvpar.c new file mode 100644 index 000000000..08473de5a --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvpar.c @@ -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 +#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); +} diff --git a/src/spicelib/devices/hisimhv/hsmhvpzld.c b/src/spicelib/devices/hisimhv/hsmhvpzld.c new file mode 100644 index 000000000..d429af55d --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvpzld.c @@ -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 +#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); +} + diff --git a/src/spicelib/devices/hisimhv/hsmhvset.c b/src/spicelib/devices/hisimhv/hsmhvset.c new file mode 100644 index 000000000..1ca6642dd --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvset.c @@ -0,0 +1,1454 @@ +/*********************************************************************** + + 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 : hsmhvset.c + + DATE : 2010.11.02 + + released by + Hiroshima University & + Semiconductor Technology Academic Research Center (STARC) +***********************************************************************/ + +#include "ngspice.h" +#include +#include "smpdefs.h" +#include "cktdefs.h" +#include "hsmhvdef.h" +#include "hsmhvevalenv.h" +#include "const.h" +#include "sperror.h" +#include "suffix.h" + +#define C_m2cm (1.0e2) +#define C_cm2m_p3 (1.0e-6) +#define C_m2cm_p1o2 (1.0e1) + +#define BINNING(param) pParam->HSMHV_##param = model->HSMHV_##param \ + + model->HSMHV_l##param / Lbin + model->HSMHV_w##param / Wbin \ + + model->HSMHV_p##param / LWbin ; + +#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 MINCHECK(param, min, pname) \ + if ( (param) < (min) ) { \ + printf("warning(HiSIMHV): The model/instance parameter %s (= %e) must be greater than %e.\n", \ + (pname), (param), (min) ); \ + } + +int HSMHVsetup( + register SMPmatrix *matrix, + register GENmodel *inModel, + register CKTcircuit *ckt, + int *states) + /* load the HSMHV device structure with those pointers needed later + * for fast matrix loading + */ +{ + register HSMHVmodel *model = (HSMHVmodel*)inModel; + register HSMHVinstance *here; + int error=0 ; + CKTnode *tmp; + double T2, Rd, Rs ; + HSMHVbinningParam *pParam ; + HSMHVmodelMKSParam *modelMKS ; + HSMHVhereMKSParam *hereMKS ; + double LG=0.0, WG =0.0, Lgate =0.0, Wgate =0.0 ; + double Lbin=0.0, Wbin=0.0, LWbin =0.0; /* binning */ + + /* loop through all the HSMHV device models */ + for ( ;model != NULL ;model = model->HSMHVnextModel ) { + /* Default value Processing for HVMOS Models */ + if ( !model->HSMHV_type_Given ) + model->HSMHV_type = NMOS ; + + if ( !model->HSMHV_info_Given ) model->HSMHV_info = 0 ; + + model->HSMHV_noise = 1; + + if ( !model->HSMHV_version_Given) { + model->HSMHV_version = "1.21" ; + printf(" 1.21 is selected for VERSION. (default) \n"); + } else { + if (strcmp(model->HSMHV_version,"1.21") != 0 ) { + model->HSMHV_version = "1.21" ; + printf(" 1.21 is only available for VERSION. \n"); + printf(" 1.21 is selected for VERSION. (default) \n"); + } else { + printf(" %s is selected for VERSION \n", model->HSMHV_version); + } + } + + if ( !model->HSMHV_corsrd_Given ) model->HSMHV_corsrd = 3 ; + if ( !model->HSMHV_corg_Given ) model->HSMHV_corg = 0 ; + if ( !model->HSMHV_coiprv_Given ) model->HSMHV_coiprv = 1 ; + if ( !model->HSMHV_copprv_Given ) model->HSMHV_copprv = 1 ; + if ( !model->HSMHV_coadov_Given ) model->HSMHV_coadov = 1 ; + if ( !model->HSMHV_coisub_Given ) model->HSMHV_coisub = 0 ; + if ( !model->HSMHV_coiigs_Given ) model->HSMHV_coiigs = 0 ; + if ( !model->HSMHV_cogidl_Given ) model->HSMHV_cogidl = 0 ; + if ( !model->HSMHV_coovlp_Given ) model->HSMHV_coovlp = 1 ; + if ( !model->HSMHV_coovlps_Given ) model->HSMHV_coovlps = 0 ; + if ( !model->HSMHV_coflick_Given ) model->HSMHV_coflick = 0 ; + if ( !model->HSMHV_coisti_Given ) model->HSMHV_coisti = 0 ; + if ( !model->HSMHV_conqs_Given ) model->HSMHV_conqs = 0 ; /* QS (default) */ + if ( !model->HSMHV_cothrml_Given ) model->HSMHV_cothrml = 0 ; + if ( !model->HSMHV_coign_Given ) model->HSMHV_coign = 0 ; /* induced gate noise */ + if ( !model->HSMHV_codfm_Given ) model->HSMHV_codfm = 0 ; /* DFM */ + if ( !model->HSMHV_coqovsm_Given ) model->HSMHV_coqovsm = 1 ; + if ( !model->HSMHV_corbnet_Given ) model->HSMHV_corbnet = 0 ; + else if ( model->HSMHV_corbnet != 0 && model->HSMHV_corbnet != 1 ) { + model->HSMHV_corbnet = 0; + printf("warning(HiSIMHV): CORBNET has been set to its default value: %d.\n", model->HSMHV_corbnet); + } + if ( !model->HSMHV_coselfheat_Given ) model->HSMHV_coselfheat = 0 ; /* Self-heating model */ + if ( !model->HSMHV_cosubnode_Given ) model->HSMHV_cosubnode = 0 ; + if ( !model->HSMHV_cosym_Given ) model->HSMHV_cosym = 0 ; /* Symmetry model for HV */ + if ( !model->HSMHV_cotemp_Given ) model->HSMHV_cotemp = 0 ; + if ( !model->HSMHV_coldrift_Given ) model->HSMHV_coldrift = 0 ; + + + if ( !model->HSMHV_vmax_Given ) model->HSMHV_vmax = 1.0e7 ; + if ( !model->HSMHV_vmaxt1_Given ) model->HSMHV_vmaxt1 = 0.0 ; + if ( !model->HSMHV_vmaxt2_Given ) model->HSMHV_vmaxt2 = 0.0 ; + if ( !model->HSMHV_bgtmp1_Given ) model->HSMHV_bgtmp1 = 90.25e-6 ; + if ( !model->HSMHV_bgtmp2_Given ) model->HSMHV_bgtmp2 = 1.0e-7 ; + if ( !model->HSMHV_eg0_Given ) model->HSMHV_eg0 = 1.1785e0 ; + if ( !model->HSMHV_tox_Given ) model->HSMHV_tox = 30e-9 ; + if ( !model->HSMHV_xld_Given ) model->HSMHV_xld = 30e-9 ; + if ( !model->HSMHV_lovers_Given ) model->HSMHV_lovers = 30e-9 ; + if ( model->HSMHV_lover_Given ) model->HSMHV_lovers = model->HSMHV_lover ; + if ( !model->HSMHV_rdov11_Given ) model->HSMHV_rdov11 = 0.0 ; + if ( !model->HSMHV_rdov12_Given ) model->HSMHV_rdov12 = 1.0 ; + if ( !model->HSMHV_rdov13_Given ) model->HSMHV_rdov13 = 1.0 ; + if ( !model->HSMHV_rdslp1_Given ) model->HSMHV_rdslp1 = 0.0 ; + if ( !model->HSMHV_rdict1_Given ) model->HSMHV_rdict1 = 1.0 ; + if ( !model->HSMHV_rdslp2_Given ) model->HSMHV_rdslp2 = 1.0 ; + if ( !model->HSMHV_rdict2_Given ) model->HSMHV_rdict2 = 0.0 ; + if ( !model->HSMHV_loverld_Given ) model->HSMHV_loverld = 1.0e-6 ; + if ( !model->HSMHV_ldrift1_Given ) model->HSMHV_ldrift1 = 1.0e-6 ; + if ( !model->HSMHV_ldrift2_Given ) model->HSMHV_ldrift2 = 1.0e-6 ; + if ( !model->HSMHV_ldrift1s_Given ) model->HSMHV_ldrift1s = 0.0 ; + if ( !model->HSMHV_ldrift2s_Given ) model->HSMHV_ldrift2s = 1.0e-6 ; + if ( !model->HSMHV_subld1_Given ) model->HSMHV_subld1 = 0.0 ; + if ( !model->HSMHV_subld2_Given ) model->HSMHV_subld2 = 0.0 ; + if ( !model->HSMHV_ddltmax_Given ) model->HSMHV_ddltmax = 1.0 ; /* Vdseff */ + if ( !model->HSMHV_ddltslp_Given ) model->HSMHV_ddltslp = 0.0 ; /* Vdseff */ + if ( !model->HSMHV_ddltict_Given ) model->HSMHV_ddltict = 10.0 ; /* Vdseff */ + if ( !model->HSMHV_vfbover_Given ) model->HSMHV_vfbover = -0.5 ; + if ( !model->HSMHV_nover_Given ) model->HSMHV_nover = 3.0e16 ; + if ( !model->HSMHV_novers_Given ) model->HSMHV_novers = 0.0 ; + if ( !model->HSMHV_xwd_Given ) model->HSMHV_xwd = 0.0 ; + if ( !model->HSMHV_xwdc_Given ) model->HSMHV_xwdc = model->HSMHV_xwd ; + + if ( !model->HSMHV_xl_Given ) model->HSMHV_xl = 0.0 ; + if ( !model->HSMHV_xw_Given ) model->HSMHV_xw = 0.0 ; + if ( !model->HSMHV_saref_Given ) model->HSMHV_saref = 1e-6 ; + if ( !model->HSMHV_sbref_Given ) model->HSMHV_sbref = 1e-6 ; + if ( !model->HSMHV_ll_Given ) model->HSMHV_ll = 0.0 ; + if ( !model->HSMHV_lld_Given ) model->HSMHV_lld = 0.0 ; + if ( !model->HSMHV_lln_Given ) model->HSMHV_lln = 0.0 ; + if ( !model->HSMHV_wl_Given ) model->HSMHV_wl = 0.0 ; + if ( !model->HSMHV_wl1_Given ) model->HSMHV_wl1 = 0.0 ; + if ( !model->HSMHV_wl1p_Given ) model->HSMHV_wl1p = 1.0 ; + if ( !model->HSMHV_wl2_Given ) model->HSMHV_wl2 = 0.0 ; + if ( !model->HSMHV_wl2p_Given ) model->HSMHV_wl2p = 1.0 ; + if ( !model->HSMHV_wld_Given ) model->HSMHV_wld = 0.0 ; + if ( !model->HSMHV_wln_Given ) model->HSMHV_wln = 0.0 ; + + if ( !model->HSMHV_rsh_Given ) model->HSMHV_rsh = 0.0 ; + if ( !model->HSMHV_rshg_Given ) model->HSMHV_rshg = 0.0 ; + + if ( !model->HSMHV_xqy_Given ) model->HSMHV_xqy = 0.0 ; + if ( !model->HSMHV_xqy1_Given ) model->HSMHV_xqy1 = 0.0 ; + if ( !model->HSMHV_xqy2_Given ) model->HSMHV_xqy2 = 0.0 ; + if ( !model->HSMHV_rs_Given ) model->HSMHV_rs = 0.0 ; + if ( !model->HSMHV_rd_Given ) model->HSMHV_rd = 5.0e-3 ; + if ( !model->HSMHV_vfbc_Given ) model->HSMHV_vfbc = -1.0 ; + if ( !model->HSMHV_vbi_Given ) model->HSMHV_vbi = 1.1 ; + if ( !model->HSMHV_nsubc_Given ) model->HSMHV_nsubc = 1.0e17 ; + if ( !model->HSMHV_parl2_Given ) model->HSMHV_parl2 = 10.0e-9 ; + if ( !model->HSMHV_lp_Given ) model->HSMHV_lp = 0.0 ; + if ( !model->HSMHV_nsubp_Given ) model->HSMHV_nsubp = 1.0e17 ; + + if ( !model->HSMHV_nsubp0_Given ) model->HSMHV_nsubp0 = 0.0 ; + if ( !model->HSMHV_nsubwp_Given ) model->HSMHV_nsubwp = 1.0 ; + + if ( !model->HSMHV_scp1_Given ) model->HSMHV_scp1 = 1.0 ; + if ( !model->HSMHV_scp2_Given ) model->HSMHV_scp2 = 0.1 ; + if ( !model->HSMHV_scp3_Given ) model->HSMHV_scp3 = 0.0 ; + if ( !model->HSMHV_sc1_Given ) model->HSMHV_sc1 = 1.0 ; + if ( !model->HSMHV_sc2_Given ) model->HSMHV_sc2 = 1.0 ; + if ( !model->HSMHV_sc3_Given ) model->HSMHV_sc3 = 0.0 ; + if ( !model->HSMHV_sc4_Given ) model->HSMHV_sc4 = 0.0 ; + if ( !model->HSMHV_pgd1_Given ) model->HSMHV_pgd1 = 0.0 ; + if ( !model->HSMHV_pgd2_Given ) model->HSMHV_pgd2 = 1.0 ; + if ( !model->HSMHV_pgd3_Given ) model->HSMHV_pgd3 = 0.8 ; + if ( !model->HSMHV_pgd4_Given ) model->HSMHV_pgd4 = 0.0 ; + + if ( !model->HSMHV_ndep_Given ) model->HSMHV_ndep = 1.0 ; + if ( !model->HSMHV_ndepl_Given ) model->HSMHV_ndepl = 0.0 ; + if ( !model->HSMHV_ndeplp_Given ) model->HSMHV_ndeplp = 1.0 ; + if ( !model->HSMHV_ninv_Given ) model->HSMHV_ninv = 0.5 ; + if ( !model->HSMHV_muecb0_Given ) model->HSMHV_muecb0 = 1.0e3 ; + if ( !model->HSMHV_muecb1_Given ) model->HSMHV_muecb1 = 100.0 ; + if ( !model->HSMHV_mueph0_Given ) model->HSMHV_mueph0 = 300.0e-3 ; + if ( !model->HSMHV_mueph1_Given ) { + if (model->HSMHV_type == NMOS) model->HSMHV_mueph1 = 25.0e3 ; + else model->HSMHV_mueph1 = 9.0e3 ; + } + if ( !model->HSMHV_muephw_Given ) model->HSMHV_muephw = 0.0 ; + if ( !model->HSMHV_muepwp_Given ) model->HSMHV_muepwp = 1.0 ; + if ( !model->HSMHV_muephl_Given ) model->HSMHV_muephl = 0.0 ; + if ( !model->HSMHV_mueplp_Given ) model->HSMHV_mueplp = 1.0 ; + if ( !model->HSMHV_muephs_Given ) model->HSMHV_muephs = 0.0 ; + if ( !model->HSMHV_muepsp_Given ) model->HSMHV_muepsp = 1.0 ; + + if ( !model->HSMHV_vtmp_Given ) model->HSMHV_vtmp = 0.0 ; + + if ( !model->HSMHV_wvth0_Given ) model->HSMHV_wvth0 = 0.0 ; + + if ( !model->HSMHV_muesr0_Given ) model->HSMHV_muesr0 = 2.0 ; + if ( !model->HSMHV_muesr1_Given ) model->HSMHV_muesr1 = 1.0e16 ; + if ( !model->HSMHV_muesrl_Given ) model->HSMHV_muesrl = 0.0 ; + if ( !model->HSMHV_muesrw_Given ) model->HSMHV_muesrw = 0.0 ; + if ( !model->HSMHV_mueswp_Given ) model->HSMHV_mueswp = 1.0 ; + if ( !model->HSMHV_mueslp_Given ) model->HSMHV_mueslp = 1.0 ; + + if ( !model->HSMHV_muetmp_Given ) model->HSMHV_muetmp = 1.7 ; + + if ( !model->HSMHV_bb_Given ) { + if (model->HSMHV_type == NMOS) model->HSMHV_bb = 2.0 ; + else model->HSMHV_bb = 1.0 ; + } + + if ( !model->HSMHV_sub1_Given ) model->HSMHV_sub1 = 50e-3 ; + if ( !model->HSMHV_sub2_Given ) model->HSMHV_sub2 = 100e0 ; + if ( !model->HSMHV_svgs_Given ) model->HSMHV_svgs = 0.8e0 ; + if ( !model->HSMHV_svbs_Given ) model->HSMHV_svbs = 0.5e0 ; + if ( !model->HSMHV_svbsl_Given ) model->HSMHV_svbsl = 0e0 ; + if ( !model->HSMHV_svds_Given ) model->HSMHV_svds = 0.8e0 ; + if ( !model->HSMHV_slg_Given ) model->HSMHV_slg = 30e-9 ; + if ( !model->HSMHV_sub1l_Given ) model->HSMHV_sub1l = 2.5e-3 ; + if ( !model->HSMHV_sub2l_Given ) model->HSMHV_sub2l = 2e-6 ; + if ( !model->HSMHV_fn1_Given ) model->HSMHV_fn1 = 50e0 ; + if ( !model->HSMHV_fn2_Given ) model->HSMHV_fn2 = 170e-6 ; + if ( !model->HSMHV_fn3_Given ) model->HSMHV_fn3 = 0e0 ; + if ( !model->HSMHV_fvbs_Given ) model->HSMHV_fvbs = 12e-3 ; + + if ( !model->HSMHV_svgsl_Given ) model->HSMHV_svgsl = 0.0 ; + if ( !model->HSMHV_svgslp_Given ) model->HSMHV_svgslp = 1.0 ; + if ( !model->HSMHV_svgswp_Given ) model->HSMHV_svgswp = 1.0 ; + if ( !model->HSMHV_svgsw_Given ) model->HSMHV_svgsw = 0.0 ; + if ( !model->HSMHV_svbslp_Given ) model->HSMHV_svbslp = 1.0 ; + if ( !model->HSMHV_slgl_Given ) model->HSMHV_slgl = 0.0 ; + if ( !model->HSMHV_slglp_Given ) model->HSMHV_slglp = 1.0 ; + if ( !model->HSMHV_sub1lp_Given ) model->HSMHV_sub1lp = 1.0 ; + + if ( !model->HSMHV_nsti_Given ) model->HSMHV_nsti = 1.0e17 ; + if ( !model->HSMHV_wsti_Given ) model->HSMHV_wsti = 0.0 ; + if ( !model->HSMHV_wstil_Given ) model->HSMHV_wstil = 0.0 ; + if ( !model->HSMHV_wstilp_Given ) model->HSMHV_wstilp = 1.0 ; + if ( !model->HSMHV_wstiw_Given ) model->HSMHV_wstiw = 0.0 ; + if ( !model->HSMHV_wstiwp_Given ) model->HSMHV_wstiwp = 1.0 ; + if ( !model->HSMHV_scsti1_Given ) model->HSMHV_scsti1 = 0.0 ; + if ( !model->HSMHV_scsti2_Given ) model->HSMHV_scsti2 = 0.0 ; + if ( !model->HSMHV_vthsti_Given ) model->HSMHV_vthsti = 0.0 ; + if ( !model->HSMHV_vdsti_Given ) model->HSMHV_vdsti = 0.0 ; + if ( !model->HSMHV_muesti1_Given ) model->HSMHV_muesti1 = 0.0 ; + if ( !model->HSMHV_muesti2_Given ) model->HSMHV_muesti2 = 0.0 ; + if ( !model->HSMHV_muesti3_Given ) model->HSMHV_muesti3 = 1.0 ; + if ( !model->HSMHV_nsubpsti1_Given ) model->HSMHV_nsubpsti1 = 0.0 ; + if ( !model->HSMHV_nsubpsti2_Given ) model->HSMHV_nsubpsti2 = 0.0 ; + if ( !model->HSMHV_nsubpsti3_Given ) model->HSMHV_nsubpsti3 = 1.0 ; + + if ( !model->HSMHV_lpext_Given ) model->HSMHV_lpext = 1.0e-50 ; + if ( !model->HSMHV_npext_Given ) model->HSMHV_npext = 1.0e17 ; + if ( !model->HSMHV_scp21_Given ) model->HSMHV_scp21 = 0.0 ; + if ( !model->HSMHV_scp22_Given ) model->HSMHV_scp22 = 0.0 ; + if ( !model->HSMHV_bs1_Given ) model->HSMHV_bs1 = 0.0 ; + if ( !model->HSMHV_bs2_Given ) model->HSMHV_bs2 = 0.9 ; + + if ( !model->HSMHV_tpoly_Given ) model->HSMHV_tpoly = 200e-9 ; + if ( !model->HSMHV_cgbo_Given ) model->HSMHV_cgbo = 0.0 ; + if ( !model->HSMHV_js0_Given ) model->HSMHV_js0 = 0.5e-6 ; + if ( !model->HSMHV_js0sw_Given ) model->HSMHV_js0sw = 0.0 ; + if ( !model->HSMHV_nj_Given ) model->HSMHV_nj = 1.0 ; + if ( !model->HSMHV_njsw_Given ) model->HSMHV_njsw = 1.0 ; + if ( !model->HSMHV_xti_Given ) model->HSMHV_xti = 2.0 ; + if ( !model->HSMHV_cj_Given ) model->HSMHV_cj = 5.0e-04 ; + if ( !model->HSMHV_cjsw_Given ) model->HSMHV_cjsw = 5.0e-10 ; + if ( !model->HSMHV_cjswg_Given ) model->HSMHV_cjswg = 5.0e-10 ; + if ( !model->HSMHV_mj_Given ) model->HSMHV_mj = 0.5e0 ; + if ( !model->HSMHV_mjsw_Given ) model->HSMHV_mjsw = 0.33e0 ; + if ( !model->HSMHV_mjswg_Given ) model->HSMHV_mjswg = 0.33e0 ; + if ( !model->HSMHV_pb_Given ) model->HSMHV_pb = 1.0e0 ; + if ( !model->HSMHV_pbsw_Given ) model->HSMHV_pbsw = 1.0e0 ; + if ( !model->HSMHV_pbswg_Given ) model->HSMHV_pbswg = 1.0e0 ; + if ( !model->HSMHV_xti2_Given ) model->HSMHV_xti2 = 0.0e0 ; + if ( !model->HSMHV_cisb_Given ) model->HSMHV_cisb = 0.0e0 ; + if ( !model->HSMHV_cvb_Given ) model->HSMHV_cvb = 0.0e0 ; + if ( !model->HSMHV_ctemp_Given ) model->HSMHV_ctemp = 0.0e0 ; + if ( !model->HSMHV_cisbk_Given ) model->HSMHV_cisbk = 0.0e0 ; + if ( !model->HSMHV_cvbk_Given ) model->HSMHV_cvbk = 0.0e0 ; + if ( !model->HSMHV_divx_Given ) model->HSMHV_divx = 0.0e0 ; + + if ( !model->HSMHV_clm1_Given ) model->HSMHV_clm1 = 50e-3 ; + if ( !model->HSMHV_clm2_Given ) model->HSMHV_clm2 = 2.0 ; + if ( !model->HSMHV_clm3_Given ) model->HSMHV_clm3 = 1.0 ; + if ( !model->HSMHV_clm5_Given ) model->HSMHV_clm5 = 1.0 ; + if ( !model->HSMHV_clm6_Given ) model->HSMHV_clm6 = 0.0 ; + if ( !model->HSMHV_vover_Given ) model->HSMHV_vover = 0.3 ; + if ( !model->HSMHV_voverp_Given ) model->HSMHV_voverp = 0.3 ; + if ( !model->HSMHV_wfc_Given ) model->HSMHV_wfc = 0.0 ; + if ( !model->HSMHV_nsubcw_Given ) model->HSMHV_nsubcw = 0.0 ; + if ( !model->HSMHV_nsubcwp_Given ) model->HSMHV_nsubcwp = 1.0 ; + if ( !model->HSMHV_qme1_Given ) model->HSMHV_qme1 = 0.0 ; + if ( !model->HSMHV_qme2_Given ) model->HSMHV_qme2 = 1.0 ; + if ( !model->HSMHV_qme3_Given ) model->HSMHV_qme3 = 0.0 ; + + if ( !model->HSMHV_vovers_Given ) model->HSMHV_vovers = 0.0 ; + if ( !model->HSMHV_voversp_Given ) model->HSMHV_voversp = 0.0 ; + + if ( !model->HSMHV_gidl1_Given ) model->HSMHV_gidl1 = 2e0 ; + if ( !model->HSMHV_gidl2_Given ) model->HSMHV_gidl2 = 3e7 ; + if ( !model->HSMHV_gidl3_Given ) model->HSMHV_gidl3 = 0.9e0 ; + if ( !model->HSMHV_gidl4_Given ) model->HSMHV_gidl4 = 0.9 ; + if ( !model->HSMHV_gidl5_Given ) model->HSMHV_gidl5 = 0.2e0 ; + + if ( !model->HSMHV_gleak1_Given ) model->HSMHV_gleak1 = 50e0 ; + if ( !model->HSMHV_gleak2_Given ) model->HSMHV_gleak2 = 10e6 ; + if ( !model->HSMHV_gleak3_Given ) model->HSMHV_gleak3 = 60e-3 ; + if ( !model->HSMHV_gleak4_Given ) model->HSMHV_gleak4 = 4e0 ; + if ( !model->HSMHV_gleak5_Given ) model->HSMHV_gleak5 = 7.5e3 ; + if ( !model->HSMHV_gleak6_Given ) model->HSMHV_gleak6 = 250e-3 ; + if ( !model->HSMHV_gleak7_Given ) model->HSMHV_gleak7 = 1e-6 ; + + if ( !model->HSMHV_glpart1_Given ) model->HSMHV_glpart1 = 0.5 ; + if ( !model->HSMHV_glksd1_Given ) model->HSMHV_glksd1 = 1.0e-15 ; + if ( !model->HSMHV_glksd2_Given ) model->HSMHV_glksd2 = 5e6 ; + if ( !model->HSMHV_glksd3_Given ) model->HSMHV_glksd3 = -5e6 ; + if ( !model->HSMHV_glkb1_Given ) model->HSMHV_glkb1 = 5e-16 ; + if ( !model->HSMHV_glkb2_Given ) model->HSMHV_glkb2 = 1e0 ; + if ( !model->HSMHV_glkb3_Given ) model->HSMHV_glkb3 = 0e0 ; + if ( !model->HSMHV_egig_Given ) model->HSMHV_egig = 0e0 ; + if ( !model->HSMHV_igtemp2_Given ) model->HSMHV_igtemp2 = 0e0 ; + if ( !model->HSMHV_igtemp3_Given ) model->HSMHV_igtemp3 = 0e0 ; + if ( !model->HSMHV_vzadd0_Given ) model->HSMHV_vzadd0 = 10.0e-3 ; + if ( !model->HSMHV_pzadd0_Given ) model->HSMHV_pzadd0 = 5.0e-3 ; + if ( !model->HSMHV_nftrp_Given ) model->HSMHV_nftrp = 10e9 ; + if ( !model->HSMHV_nfalp_Given ) model->HSMHV_nfalp = 1.0e-19 ; + if ( !model->HSMHV_cit_Given ) model->HSMHV_cit = 0e0 ; + if ( !model->HSMHV_falph_Given ) model->HSMHV_falph = 1.0 ; + + if ( !model->HSMHV_kappa_Given ) model->HSMHV_kappa = 3.90e0 ; + if ( !model->HSMHV_cgso_Given ) model->HSMHV_cgso = 0.0 ; + if ( !model->HSMHV_cgdo_Given ) model->HSMHV_cgdo = 0.0 ; + + if ( !model->HSMHV_pthrou_Given ) model->HSMHV_pthrou = 0.0 ; + + if ( !model->HSMHV_vdiffj_Given ) model->HSMHV_vdiffj = 0.6e-3 ; + if ( !model->HSMHV_dly1_Given ) model->HSMHV_dly1 = 100.0e-12 ; + if ( !model->HSMHV_dly2_Given ) model->HSMHV_dly2 = 0.7e0 ; + if ( !model->HSMHV_dly3_Given ) model->HSMHV_dly3 = 0.8e-6 ; + if ( !model->HSMHV_tnom_Given ) model->HSMHV_tnom = 27.0 ; /* [C] */ + + if ( !model->HSMHV_ovslp_Given ) model->HSMHV_ovslp = 2.0e-8 ; + if ( !model->HSMHV_ovmag_Given ) model->HSMHV_ovmag = 500.0 ; + + if ( !model->HSMHV_gbmin_Given ) model->HSMHV_gbmin = 1.0e-12; /* in mho */ + if ( !model->HSMHV_rbpb_Given ) model->HSMHV_rbpb = 50.0e0 ; + if ( !model->HSMHV_rbpd_Given ) model->HSMHV_rbpd = 50.0e0 ; + if ( !model->HSMHV_rbps_Given ) model->HSMHV_rbps = 50.0e0 ; + if ( !model->HSMHV_rbdb_Given ) model->HSMHV_rbdb = 50.0e0 ; + if ( !model->HSMHV_rbsb_Given ) model->HSMHV_rbsb = 50.0e0 ; + + if ( !model->HSMHV_ibpc1_Given ) model->HSMHV_ibpc1 = 0.0 ; + if ( !model->HSMHV_ibpc2_Given ) model->HSMHV_ibpc2 = 0.0 ; + + if ( !model->HSMHV_mphdfm_Given ) model->HSMHV_mphdfm = -0.3 ; + + if ( !model->HSMHV_rdvg11_Given ) model->HSMHV_rdvg11 = 0.0 ; + if ( !model->HSMHV_rdvg12_Given ) model->HSMHV_rdvg12 = 100.0 ; + if ( !model->HSMHV_rth0_Given ) model->HSMHV_rth0 = 0.1 ; /* Self-heating model */ + if ( !model->HSMHV_cth0_Given ) model->HSMHV_cth0 = 1.0e-7 ; /* Self-heating model */ + if ( !model->HSMHV_powrat_Given ) model->HSMHV_powrat = 1.0 ; /* Self-heating model */ + + if ( !model->HSMHV_tcjbd_Given ) model->HSMHV_tcjbd = 0.0 ; /* Self-heating model */ + if ( !model->HSMHV_tcjbs_Given ) model->HSMHV_tcjbs = 0.0 ; /* Self-heating model */ + if ( !model->HSMHV_tcjbdsw_Given ) model->HSMHV_tcjbdsw = 0.0 ; /* Self-heating model */ + if ( !model->HSMHV_tcjbssw_Given ) model->HSMHV_tcjbssw = 0.0 ; /* Self-heating model */ + if ( !model->HSMHV_tcjbdswg_Given ) model->HSMHV_tcjbdswg = 0.0 ; /* Self-heating model */ + if ( !model->HSMHV_tcjbsswg_Given ) model->HSMHV_tcjbsswg = 0.0 ; /* Self-heating model */ + + /* value reset to switch off NQS for QbdLD: */ + model->HSMHV_dlyov = 0.0 ; /* 1.0e3 ; */ + if ( !model->HSMHV_qdftvd_Given ) model->HSMHV_qdftvd = 1.0 ; + if ( !model->HSMHV_xldld_Given ) model->HSMHV_xldld = 1.0e-6 ; + if ( !model->HSMHV_xwdld_Given ) model->HSMHV_xwdld = model->HSMHV_xwd ; + if ( !model->HSMHV_rdvd_Given ) model->HSMHV_rdvd = 7.0e-2 ; + if ( !model->HSMHV_qovsm_Given ) model->HSMHV_qovsm = 0.2 ; + + if ( !model->HSMHV_rd20_Given ) model->HSMHV_rd20 = 0.0 ; + if ( !model->HSMHV_rd21_Given ) model->HSMHV_rd21 = 1.0 ; + if ( !model->HSMHV_rd22_Given ) model->HSMHV_rd22 = 0.0 ; + if ( !model->HSMHV_rd22d_Given ) model->HSMHV_rd22d = 0.0 ; + if ( !model->HSMHV_rd23_Given ) model->HSMHV_rd23 = 5e-3 ; + if ( !model->HSMHV_rd24_Given ) model->HSMHV_rd24 = 0.0 ; + if ( !model->HSMHV_rd25_Given ) model->HSMHV_rd25 = 0.0 ; + + if ( !model->HSMHV_rdvdl_Given ) model->HSMHV_rdvdl = 0.0 ; + if ( !model->HSMHV_rdvdlp_Given ) model->HSMHV_rdvdlp = 1.0 ; + if ( !model->HSMHV_rdvds_Given ) model->HSMHV_rdvds = 0.0 ; + if ( !model->HSMHV_rdvdsp_Given ) model->HSMHV_rdvdsp = 1.0 ; + if ( !model->HSMHV_rd23l_Given ) model->HSMHV_rd23l = 0.0 ; + if ( !model->HSMHV_rd23lp_Given ) model->HSMHV_rd23lp = 1.0 ; + if ( !model->HSMHV_rd23s_Given ) model->HSMHV_rd23s = 0.0 ; + if ( !model->HSMHV_rd23sp_Given ) model->HSMHV_rd23sp = 1.0 ; + if ( !model->HSMHV_rds_Given ) model->HSMHV_rds = 0.0 ; + if ( !model->HSMHV_rdsp_Given ) model->HSMHV_rdsp = 1.0 ; + if ( !model->HSMHV_rdtemp1_Given ) model->HSMHV_rdtemp1 = 0.0 ; + if ( !model->HSMHV_rdtemp2_Given ) model->HSMHV_rdtemp2 = 0.0 ; + model->HSMHV_rth0r = 0.0 ; /* not used in this version */ + if ( !model->HSMHV_rdvdtemp1_Given) model->HSMHV_rdvdtemp1 = 0.0 ; + if ( !model->HSMHV_rdvdtemp2_Given) model->HSMHV_rdvdtemp2 = 0.0 ; + if ( !model->HSMHV_rth0w_Given ) model->HSMHV_rth0w = 0.0 ; + if ( !model->HSMHV_rth0wp_Given ) model->HSMHV_rth0wp = 1.0 ; + + if ( !model->HSMHV_cvdsover_Given ) model->HSMHV_cvdsover = 0.0 ; + + if ( !model->HSMHV_ninvd_Given ) model->HSMHV_ninvd = 0.0 ; + if ( !model->HSMHV_ninvdw_Given ) model->HSMHV_ninvdw = 0.0 ; + if ( !model->HSMHV_ninvdwp_Given ) model->HSMHV_ninvdwp = 1.0 ; + if ( !model->HSMHV_ninvdt1_Given ) model->HSMHV_ninvdt1 = 0.0 ; + if ( !model->HSMHV_ninvdt2_Given ) model->HSMHV_ninvdt2 = 0.0 ; + if ( !model->HSMHV_vbsmin_Given ) model->HSMHV_vbsmin = -10.5 ; + if ( !model->HSMHV_rdvb_Given ) model->HSMHV_rdvb = 0.0 ; + if ( !model->HSMHV_rth0nf_Given ) model->HSMHV_rth0nf = 0.0 ; + + if ( !model->HSMHV_rthtemp1_Given ) model->HSMHV_rthtemp1 = 0.0 ; + if ( !model->HSMHV_rthtemp2_Given ) model->HSMHV_rthtemp2 = 0.0 ; + if ( !model->HSMHV_prattemp1_Given ) model->HSMHV_prattemp1 = 0.0 ; + if ( !model->HSMHV_prattemp2_Given ) model->HSMHV_prattemp2 = 0.0 ; + + if ( !model->HSMHV_rdvsub_Given ) model->HSMHV_rdvsub = 1.0 ; /* [-] substrate effect */ + if ( !model->HSMHV_rdvdsub_Given ) model->HSMHV_rdvdsub = 0.3 ; /* [-] substrate effect */ + if ( !model->HSMHV_ddrift_Given ) model->HSMHV_ddrift = 1.0e-6 ; /* [m] substrate effect */ + if ( !model->HSMHV_vbisub_Given ) model->HSMHV_vbisub = 0.7 ; /* [V] substrate effect */ + if ( !model->HSMHV_nsubsub_Given ) model->HSMHV_nsubsub = 1.0e15 ; /* [cm^-3] substrate effect */ + if ( !model->HSMHV_shemax_Given ) model->HSMHV_shemax = 500 ; + + /* binning parameters */ + if ( !model->HSMHV_lmin_Given ) model->HSMHV_lmin = 0.0 ; + if ( !model->HSMHV_lmax_Given ) model->HSMHV_lmax = 1.0 ; + if ( !model->HSMHV_wmin_Given ) model->HSMHV_wmin = 0.0 ; + if ( !model->HSMHV_wmax_Given ) model->HSMHV_wmax = 1.0 ; + if ( !model->HSMHV_lbinn_Given ) model->HSMHV_lbinn = 1.0 ; + if ( !model->HSMHV_wbinn_Given ) model->HSMHV_wbinn = 1.0 ; + + /* Length dependence */ + if ( !model->HSMHV_lvmax_Given ) model->HSMHV_lvmax = 0.0 ; + if ( !model->HSMHV_lbgtmp1_Given ) model->HSMHV_lbgtmp1 = 0.0 ; + if ( !model->HSMHV_lbgtmp2_Given ) model->HSMHV_lbgtmp2 = 0.0 ; + if ( !model->HSMHV_leg0_Given ) model->HSMHV_leg0 = 0.0 ; + if ( !model->HSMHV_lvfbover_Given ) model->HSMHV_lvfbover = 0.0 ; + if ( !model->HSMHV_lnover_Given ) model->HSMHV_lnover = 0.0 ; + if ( !model->HSMHV_lnovers_Given ) model->HSMHV_lnovers = 0.0 ; + if ( !model->HSMHV_lwl2_Given ) model->HSMHV_lwl2 = 0.0 ; + if ( !model->HSMHV_lvfbc_Given ) model->HSMHV_lvfbc = 0.0 ; + if ( !model->HSMHV_lnsubc_Given ) model->HSMHV_lnsubc = 0.0 ; + if ( !model->HSMHV_lnsubp_Given ) model->HSMHV_lnsubp = 0.0 ; + if ( !model->HSMHV_lscp1_Given ) model->HSMHV_lscp1 = 0.0 ; + if ( !model->HSMHV_lscp2_Given ) model->HSMHV_lscp2 = 0.0 ; + if ( !model->HSMHV_lscp3_Given ) model->HSMHV_lscp3 = 0.0 ; + if ( !model->HSMHV_lsc1_Given ) model->HSMHV_lsc1 = 0.0 ; + if ( !model->HSMHV_lsc2_Given ) model->HSMHV_lsc2 = 0.0 ; + if ( !model->HSMHV_lsc3_Given ) model->HSMHV_lsc3 = 0.0 ; + if ( !model->HSMHV_lpgd1_Given ) model->HSMHV_lpgd1 = 0.0 ; + if ( !model->HSMHV_lpgd3_Given ) model->HSMHV_lpgd3 = 0.0 ; + if ( !model->HSMHV_lndep_Given ) model->HSMHV_lndep = 0.0 ; + if ( !model->HSMHV_lninv_Given ) model->HSMHV_lninv = 0.0 ; + if ( !model->HSMHV_lmuecb0_Given ) model->HSMHV_lmuecb0 = 0.0 ; + if ( !model->HSMHV_lmuecb1_Given ) model->HSMHV_lmuecb1 = 0.0 ; + if ( !model->HSMHV_lmueph1_Given ) model->HSMHV_lmueph1 = 0.0 ; + if ( !model->HSMHV_lvtmp_Given ) model->HSMHV_lvtmp = 0.0 ; + if ( !model->HSMHV_lwvth0_Given ) model->HSMHV_lwvth0 = 0.0 ; + if ( !model->HSMHV_lmuesr1_Given ) model->HSMHV_lmuesr1 = 0.0 ; + if ( !model->HSMHV_lmuetmp_Given ) model->HSMHV_lmuetmp = 0.0 ; + if ( !model->HSMHV_lsub1_Given ) model->HSMHV_lsub1 = 0.0 ; + if ( !model->HSMHV_lsub2_Given ) model->HSMHV_lsub2 = 0.0 ; + if ( !model->HSMHV_lsvds_Given ) model->HSMHV_lsvds = 0.0 ; + if ( !model->HSMHV_lsvbs_Given ) model->HSMHV_lsvbs = 0.0 ; + if ( !model->HSMHV_lsvgs_Given ) model->HSMHV_lsvgs = 0.0 ; + if ( !model->HSMHV_lfn1_Given ) model->HSMHV_lfn1 = 0.0 ; + if ( !model->HSMHV_lfn2_Given ) model->HSMHV_lfn2 = 0.0 ; + if ( !model->HSMHV_lfn3_Given ) model->HSMHV_lfn3 = 0.0 ; + if ( !model->HSMHV_lfvbs_Given ) model->HSMHV_lfvbs = 0.0 ; + if ( !model->HSMHV_lnsti_Given ) model->HSMHV_lnsti = 0.0 ; + if ( !model->HSMHV_lwsti_Given ) model->HSMHV_lwsti = 0.0 ; + if ( !model->HSMHV_lscsti1_Given ) model->HSMHV_lscsti1 = 0.0 ; + if ( !model->HSMHV_lscsti2_Given ) model->HSMHV_lscsti2 = 0.0 ; + if ( !model->HSMHV_lvthsti_Given ) model->HSMHV_lvthsti = 0.0 ; + if ( !model->HSMHV_lmuesti1_Given ) model->HSMHV_lmuesti1 = 0.0 ; + if ( !model->HSMHV_lmuesti2_Given ) model->HSMHV_lmuesti2 = 0.0 ; + if ( !model->HSMHV_lmuesti3_Given ) model->HSMHV_lmuesti3 = 0.0 ; + if ( !model->HSMHV_lnsubpsti1_Given ) model->HSMHV_lnsubpsti1 = 0.0 ; + if ( !model->HSMHV_lnsubpsti2_Given ) model->HSMHV_lnsubpsti2 = 0.0 ; + if ( !model->HSMHV_lnsubpsti3_Given ) model->HSMHV_lnsubpsti3 = 0.0 ; + if ( !model->HSMHV_lcgso_Given ) model->HSMHV_lcgso = 0.0 ; + if ( !model->HSMHV_lcgdo_Given ) model->HSMHV_lcgdo = 0.0 ; + if ( !model->HSMHV_ljs0_Given ) model->HSMHV_ljs0 = 0.0 ; + if ( !model->HSMHV_ljs0sw_Given ) model->HSMHV_ljs0sw = 0.0 ; + if ( !model->HSMHV_lnj_Given ) model->HSMHV_lnj = 0.0 ; + if ( !model->HSMHV_lcisbk_Given ) model->HSMHV_lcisbk = 0.0 ; + if ( !model->HSMHV_lclm1_Given ) model->HSMHV_lclm1 = 0.0 ; + if ( !model->HSMHV_lclm2_Given ) model->HSMHV_lclm2 = 0.0 ; + if ( !model->HSMHV_lclm3_Given ) model->HSMHV_lclm3 = 0.0 ; + if ( !model->HSMHV_lwfc_Given ) model->HSMHV_lwfc = 0.0 ; + if ( !model->HSMHV_lgidl1_Given ) model->HSMHV_lgidl1 = 0.0 ; + if ( !model->HSMHV_lgidl2_Given ) model->HSMHV_lgidl2 = 0.0 ; + if ( !model->HSMHV_lgleak1_Given ) model->HSMHV_lgleak1 = 0.0 ; + if ( !model->HSMHV_lgleak2_Given ) model->HSMHV_lgleak2 = 0.0 ; + if ( !model->HSMHV_lgleak3_Given ) model->HSMHV_lgleak3 = 0.0 ; + if ( !model->HSMHV_lgleak6_Given ) model->HSMHV_lgleak6 = 0.0 ; + if ( !model->HSMHV_lglksd1_Given ) model->HSMHV_lglksd1 = 0.0 ; + if ( !model->HSMHV_lglksd2_Given ) model->HSMHV_lglksd2 = 0.0 ; + if ( !model->HSMHV_lglkb1_Given ) model->HSMHV_lglkb1 = 0.0 ; + if ( !model->HSMHV_lglkb2_Given ) model->HSMHV_lglkb2 = 0.0 ; + if ( !model->HSMHV_lnftrp_Given ) model->HSMHV_lnftrp = 0.0 ; + if ( !model->HSMHV_lnfalp_Given ) model->HSMHV_lnfalp = 0.0 ; + if ( !model->HSMHV_lpthrou_Given ) model->HSMHV_lpthrou = 0.0 ; + if ( !model->HSMHV_lvdiffj_Given ) model->HSMHV_lvdiffj = 0.0 ; + if ( !model->HSMHV_libpc1_Given ) model->HSMHV_libpc1 = 0.0 ; + if ( !model->HSMHV_libpc2_Given ) model->HSMHV_libpc2 = 0.0 ; + if ( !model->HSMHV_lcgbo_Given ) model->HSMHV_lcgbo = 0.0 ; + if ( !model->HSMHV_lcvdsover_Given ) model->HSMHV_lcvdsover = 0.0 ; + if ( !model->HSMHV_lfalph_Given ) model->HSMHV_lfalph = 0.0 ; + if ( !model->HSMHV_lnpext_Given ) model->HSMHV_lnpext = 0.0 ; + if ( !model->HSMHV_lpowrat_Given ) model->HSMHV_lpowrat = 0.0 ; + if ( !model->HSMHV_lrd_Given ) model->HSMHV_lrd = 0.0 ; + if ( !model->HSMHV_lrd22_Given ) model->HSMHV_lrd22 = 0.0 ; + if ( !model->HSMHV_lrd23_Given ) model->HSMHV_lrd23 = 0.0 ; + if ( !model->HSMHV_lrd24_Given ) model->HSMHV_lrd24 = 0.0 ; + if ( !model->HSMHV_lrdict1_Given ) model->HSMHV_lrdict1 = 0.0 ; + if ( !model->HSMHV_lrdov13_Given ) model->HSMHV_lrdov13 = 0.0 ; + if ( !model->HSMHV_lrdslp1_Given ) model->HSMHV_lrdslp1 = 0.0 ; + if ( !model->HSMHV_lrdvb_Given ) model->HSMHV_lrdvb = 0.0 ; + if ( !model->HSMHV_lrdvd_Given ) model->HSMHV_lrdvd = 0.0 ; + if ( !model->HSMHV_lrdvg11_Given ) model->HSMHV_lrdvg11 = 0.0 ; + if ( !model->HSMHV_lrs_Given ) model->HSMHV_lrs = 0.0 ; + if ( !model->HSMHV_lrth0_Given ) model->HSMHV_lrth0 = 0.0 ; + if ( !model->HSMHV_lvover_Given ) model->HSMHV_lvover = 0.0 ; + + /* Width dependence */ + if ( !model->HSMHV_wvmax_Given ) model->HSMHV_wvmax = 0.0 ; + if ( !model->HSMHV_wbgtmp1_Given ) model->HSMHV_wbgtmp1 = 0.0 ; + if ( !model->HSMHV_wbgtmp2_Given ) model->HSMHV_wbgtmp2 = 0.0 ; + if ( !model->HSMHV_weg0_Given ) model->HSMHV_weg0 = 0.0 ; + if ( !model->HSMHV_wvfbover_Given ) model->HSMHV_wvfbover = 0.0 ; + if ( !model->HSMHV_wnover_Given ) model->HSMHV_wnover = 0.0 ; + if ( !model->HSMHV_wnovers_Given ) model->HSMHV_wnovers = 0.0 ; + if ( !model->HSMHV_wwl2_Given ) model->HSMHV_wwl2 = 0.0 ; + if ( !model->HSMHV_wvfbc_Given ) model->HSMHV_wvfbc = 0.0 ; + if ( !model->HSMHV_wnsubc_Given ) model->HSMHV_wnsubc = 0.0 ; + if ( !model->HSMHV_wnsubp_Given ) model->HSMHV_wnsubp = 0.0 ; + if ( !model->HSMHV_wscp1_Given ) model->HSMHV_wscp1 = 0.0 ; + if ( !model->HSMHV_wscp2_Given ) model->HSMHV_wscp2 = 0.0 ; + if ( !model->HSMHV_wscp3_Given ) model->HSMHV_wscp3 = 0.0 ; + if ( !model->HSMHV_wsc1_Given ) model->HSMHV_wsc1 = 0.0 ; + if ( !model->HSMHV_wsc2_Given ) model->HSMHV_wsc2 = 0.0 ; + if ( !model->HSMHV_wsc3_Given ) model->HSMHV_wsc3 = 0.0 ; + if ( !model->HSMHV_wpgd1_Given ) model->HSMHV_wpgd1 = 0.0 ; + if ( !model->HSMHV_wpgd3_Given ) model->HSMHV_wpgd3 = 0.0 ; + if ( !model->HSMHV_wndep_Given ) model->HSMHV_wndep = 0.0 ; + if ( !model->HSMHV_wninv_Given ) model->HSMHV_wninv = 0.0 ; + if ( !model->HSMHV_wmuecb0_Given ) model->HSMHV_wmuecb0 = 0.0 ; + if ( !model->HSMHV_wmuecb1_Given ) model->HSMHV_wmuecb1 = 0.0 ; + if ( !model->HSMHV_wmueph1_Given ) model->HSMHV_wmueph1 = 0.0 ; + if ( !model->HSMHV_wvtmp_Given ) model->HSMHV_wvtmp = 0.0 ; + if ( !model->HSMHV_wwvth0_Given ) model->HSMHV_wwvth0 = 0.0 ; + if ( !model->HSMHV_wmuesr1_Given ) model->HSMHV_wmuesr1 = 0.0 ; + if ( !model->HSMHV_wmuetmp_Given ) model->HSMHV_wmuetmp = 0.0 ; + if ( !model->HSMHV_wsub1_Given ) model->HSMHV_wsub1 = 0.0 ; + if ( !model->HSMHV_wsub2_Given ) model->HSMHV_wsub2 = 0.0 ; + if ( !model->HSMHV_wsvds_Given ) model->HSMHV_wsvds = 0.0 ; + if ( !model->HSMHV_wsvbs_Given ) model->HSMHV_wsvbs = 0.0 ; + if ( !model->HSMHV_wsvgs_Given ) model->HSMHV_wsvgs = 0.0 ; + if ( !model->HSMHV_wfn1_Given ) model->HSMHV_wfn1 = 0.0 ; + if ( !model->HSMHV_wfn2_Given ) model->HSMHV_wfn2 = 0.0 ; + if ( !model->HSMHV_wfn3_Given ) model->HSMHV_wfn3 = 0.0 ; + if ( !model->HSMHV_wfvbs_Given ) model->HSMHV_wfvbs = 0.0 ; + if ( !model->HSMHV_wnsti_Given ) model->HSMHV_wnsti = 0.0 ; + if ( !model->HSMHV_wwsti_Given ) model->HSMHV_wwsti = 0.0 ; + if ( !model->HSMHV_wscsti1_Given ) model->HSMHV_wscsti1 = 0.0 ; + if ( !model->HSMHV_wscsti2_Given ) model->HSMHV_wscsti2 = 0.0 ; + if ( !model->HSMHV_wvthsti_Given ) model->HSMHV_wvthsti = 0.0 ; + if ( !model->HSMHV_wmuesti1_Given ) model->HSMHV_wmuesti1 = 0.0 ; + if ( !model->HSMHV_wmuesti2_Given ) model->HSMHV_wmuesti2 = 0.0 ; + if ( !model->HSMHV_wmuesti3_Given ) model->HSMHV_wmuesti3 = 0.0 ; + if ( !model->HSMHV_wnsubpsti1_Given ) model->HSMHV_wnsubpsti1 = 0.0 ; + if ( !model->HSMHV_wnsubpsti2_Given ) model->HSMHV_wnsubpsti2 = 0.0 ; + if ( !model->HSMHV_wnsubpsti3_Given ) model->HSMHV_wnsubpsti3 = 0.0 ; + if ( !model->HSMHV_wcgso_Given ) model->HSMHV_wcgso = 0.0 ; + if ( !model->HSMHV_wcgdo_Given ) model->HSMHV_wcgdo = 0.0 ; + if ( !model->HSMHV_wjs0_Given ) model->HSMHV_wjs0 = 0.0 ; + if ( !model->HSMHV_wjs0sw_Given ) model->HSMHV_wjs0sw = 0.0 ; + if ( !model->HSMHV_wnj_Given ) model->HSMHV_wnj = 0.0 ; + if ( !model->HSMHV_wcisbk_Given ) model->HSMHV_wcisbk = 0.0 ; + if ( !model->HSMHV_wclm1_Given ) model->HSMHV_wclm1 = 0.0 ; + if ( !model->HSMHV_wclm2_Given ) model->HSMHV_wclm2 = 0.0 ; + if ( !model->HSMHV_wclm3_Given ) model->HSMHV_wclm3 = 0.0 ; + if ( !model->HSMHV_wwfc_Given ) model->HSMHV_wwfc = 0.0 ; + if ( !model->HSMHV_wgidl1_Given ) model->HSMHV_wgidl1 = 0.0 ; + if ( !model->HSMHV_wgidl2_Given ) model->HSMHV_wgidl2 = 0.0 ; + if ( !model->HSMHV_wgleak1_Given ) model->HSMHV_wgleak1 = 0.0 ; + if ( !model->HSMHV_wgleak2_Given ) model->HSMHV_wgleak2 = 0.0 ; + if ( !model->HSMHV_wgleak3_Given ) model->HSMHV_wgleak3 = 0.0 ; + if ( !model->HSMHV_wgleak6_Given ) model->HSMHV_wgleak6 = 0.0 ; + if ( !model->HSMHV_wglksd1_Given ) model->HSMHV_wglksd1 = 0.0 ; + if ( !model->HSMHV_wglksd2_Given ) model->HSMHV_wglksd2 = 0.0 ; + if ( !model->HSMHV_wglkb1_Given ) model->HSMHV_wglkb1 = 0.0 ; + if ( !model->HSMHV_wglkb2_Given ) model->HSMHV_wglkb2 = 0.0 ; + if ( !model->HSMHV_wnftrp_Given ) model->HSMHV_wnftrp = 0.0 ; + if ( !model->HSMHV_wnfalp_Given ) model->HSMHV_wnfalp = 0.0 ; + if ( !model->HSMHV_wpthrou_Given ) model->HSMHV_wpthrou = 0.0 ; + if ( !model->HSMHV_wvdiffj_Given ) model->HSMHV_wvdiffj = 0.0 ; + if ( !model->HSMHV_wibpc1_Given ) model->HSMHV_wibpc1 = 0.0 ; + if ( !model->HSMHV_wibpc2_Given ) model->HSMHV_wibpc2 = 0.0 ; + if ( !model->HSMHV_wcgbo_Given ) model->HSMHV_wcgbo = 0.0 ; + if ( !model->HSMHV_wcvdsover_Given ) model->HSMHV_wcvdsover = 0.0 ; + if ( !model->HSMHV_wfalph_Given ) model->HSMHV_wfalph = 0.0 ; + if ( !model->HSMHV_wnpext_Given ) model->HSMHV_wnpext = 0.0 ; + if ( !model->HSMHV_wpowrat_Given ) model->HSMHV_wpowrat = 0.0 ; + if ( !model->HSMHV_wrd_Given ) model->HSMHV_wrd = 0.0 ; + if ( !model->HSMHV_wrd22_Given ) model->HSMHV_wrd22 = 0.0 ; + if ( !model->HSMHV_wrd23_Given ) model->HSMHV_wrd23 = 0.0 ; + if ( !model->HSMHV_wrd24_Given ) model->HSMHV_wrd24 = 0.0 ; + if ( !model->HSMHV_wrdict1_Given ) model->HSMHV_wrdict1 = 0.0 ; + if ( !model->HSMHV_wrdov13_Given ) model->HSMHV_wrdov13 = 0.0 ; + if ( !model->HSMHV_wrdslp1_Given ) model->HSMHV_wrdslp1 = 0.0 ; + if ( !model->HSMHV_wrdvb_Given ) model->HSMHV_wrdvb = 0.0 ; + if ( !model->HSMHV_wrdvd_Given ) model->HSMHV_wrdvd = 0.0 ; + if ( !model->HSMHV_wrdvg11_Given ) model->HSMHV_wrdvg11 = 0.0 ; + if ( !model->HSMHV_wrs_Given ) model->HSMHV_wrs = 0.0 ; + if ( !model->HSMHV_wrth0_Given ) model->HSMHV_wrth0 = 0.0 ; + if ( !model->HSMHV_wvover_Given ) model->HSMHV_wvover = 0.0 ; + + /* Cross-term dependence */ + if ( !model->HSMHV_pvmax_Given ) model->HSMHV_pvmax = 0.0 ; + if ( !model->HSMHV_pbgtmp1_Given ) model->HSMHV_pbgtmp1 = 0.0 ; + if ( !model->HSMHV_pbgtmp2_Given ) model->HSMHV_pbgtmp2 = 0.0 ; + if ( !model->HSMHV_peg0_Given ) model->HSMHV_peg0 = 0.0 ; + if ( !model->HSMHV_pvfbover_Given ) model->HSMHV_pvfbover = 0.0 ; + if ( !model->HSMHV_pnover_Given ) model->HSMHV_pnover = 0.0 ; + if ( !model->HSMHV_pnovers_Given ) model->HSMHV_pnovers = 0.0 ; + if ( !model->HSMHV_pwl2_Given ) model->HSMHV_pwl2 = 0.0 ; + if ( !model->HSMHV_pvfbc_Given ) model->HSMHV_pvfbc = 0.0 ; + if ( !model->HSMHV_pnsubc_Given ) model->HSMHV_pnsubc = 0.0 ; + if ( !model->HSMHV_pnsubp_Given ) model->HSMHV_pnsubp = 0.0 ; + if ( !model->HSMHV_pscp1_Given ) model->HSMHV_pscp1 = 0.0 ; + if ( !model->HSMHV_pscp2_Given ) model->HSMHV_pscp2 = 0.0 ; + if ( !model->HSMHV_pscp3_Given ) model->HSMHV_pscp3 = 0.0 ; + if ( !model->HSMHV_psc1_Given ) model->HSMHV_psc1 = 0.0 ; + if ( !model->HSMHV_psc2_Given ) model->HSMHV_psc2 = 0.0 ; + if ( !model->HSMHV_psc3_Given ) model->HSMHV_psc3 = 0.0 ; + if ( !model->HSMHV_ppgd1_Given ) model->HSMHV_ppgd1 = 0.0 ; + if ( !model->HSMHV_ppgd3_Given ) model->HSMHV_ppgd3 = 0.0 ; + if ( !model->HSMHV_pndep_Given ) model->HSMHV_pndep = 0.0 ; + if ( !model->HSMHV_pninv_Given ) model->HSMHV_pninv = 0.0 ; + if ( !model->HSMHV_pmuecb0_Given ) model->HSMHV_pmuecb0 = 0.0 ; + if ( !model->HSMHV_pmuecb1_Given ) model->HSMHV_pmuecb1 = 0.0 ; + if ( !model->HSMHV_pmueph1_Given ) model->HSMHV_pmueph1 = 0.0 ; + if ( !model->HSMHV_pvtmp_Given ) model->HSMHV_pvtmp = 0.0 ; + if ( !model->HSMHV_pwvth0_Given ) model->HSMHV_pwvth0 = 0.0 ; + if ( !model->HSMHV_pmuesr1_Given ) model->HSMHV_pmuesr1 = 0.0 ; + if ( !model->HSMHV_pmuetmp_Given ) model->HSMHV_pmuetmp = 0.0 ; + if ( !model->HSMHV_psub1_Given ) model->HSMHV_psub1 = 0.0 ; + if ( !model->HSMHV_psub2_Given ) model->HSMHV_psub2 = 0.0 ; + if ( !model->HSMHV_psvds_Given ) model->HSMHV_psvds = 0.0 ; + if ( !model->HSMHV_psvbs_Given ) model->HSMHV_psvbs = 0.0 ; + if ( !model->HSMHV_psvgs_Given ) model->HSMHV_psvgs = 0.0 ; + if ( !model->HSMHV_pfn1_Given ) model->HSMHV_pfn1 = 0.0 ; + if ( !model->HSMHV_pfn2_Given ) model->HSMHV_pfn2 = 0.0 ; + if ( !model->HSMHV_pfn3_Given ) model->HSMHV_pfn3 = 0.0 ; + if ( !model->HSMHV_pfvbs_Given ) model->HSMHV_pfvbs = 0.0 ; + if ( !model->HSMHV_pnsti_Given ) model->HSMHV_pnsti = 0.0 ; + if ( !model->HSMHV_pwsti_Given ) model->HSMHV_pwsti = 0.0 ; + if ( !model->HSMHV_pscsti1_Given ) model->HSMHV_pscsti1 = 0.0 ; + if ( !model->HSMHV_pscsti2_Given ) model->HSMHV_pscsti2 = 0.0 ; + if ( !model->HSMHV_pvthsti_Given ) model->HSMHV_pvthsti = 0.0 ; + if ( !model->HSMHV_pmuesti1_Given ) model->HSMHV_pmuesti1 = 0.0 ; + if ( !model->HSMHV_pmuesti2_Given ) model->HSMHV_pmuesti2 = 0.0 ; + if ( !model->HSMHV_pmuesti3_Given ) model->HSMHV_pmuesti3 = 0.0 ; + if ( !model->HSMHV_pnsubpsti1_Given ) model->HSMHV_pnsubpsti1 = 0.0 ; + if ( !model->HSMHV_pnsubpsti2_Given ) model->HSMHV_pnsubpsti2 = 0.0 ; + if ( !model->HSMHV_pnsubpsti3_Given ) model->HSMHV_pnsubpsti3 = 0.0 ; + if ( !model->HSMHV_pcgso_Given ) model->HSMHV_pcgso = 0.0 ; + if ( !model->HSMHV_pcgdo_Given ) model->HSMHV_pcgdo = 0.0 ; + if ( !model->HSMHV_pjs0_Given ) model->HSMHV_pjs0 = 0.0 ; + if ( !model->HSMHV_pjs0sw_Given ) model->HSMHV_pjs0sw = 0.0 ; + if ( !model->HSMHV_pnj_Given ) model->HSMHV_pnj = 0.0 ; + if ( !model->HSMHV_pcisbk_Given ) model->HSMHV_pcisbk = 0.0 ; + if ( !model->HSMHV_pclm1_Given ) model->HSMHV_pclm1 = 0.0 ; + if ( !model->HSMHV_pclm2_Given ) model->HSMHV_pclm2 = 0.0 ; + if ( !model->HSMHV_pclm3_Given ) model->HSMHV_pclm3 = 0.0 ; + if ( !model->HSMHV_pwfc_Given ) model->HSMHV_pwfc = 0.0 ; + if ( !model->HSMHV_pgidl1_Given ) model->HSMHV_pgidl1 = 0.0 ; + if ( !model->HSMHV_pgidl2_Given ) model->HSMHV_pgidl2 = 0.0 ; + if ( !model->HSMHV_pgleak1_Given ) model->HSMHV_pgleak1 = 0.0 ; + if ( !model->HSMHV_pgleak2_Given ) model->HSMHV_pgleak2 = 0.0 ; + if ( !model->HSMHV_pgleak3_Given ) model->HSMHV_pgleak3 = 0.0 ; + if ( !model->HSMHV_pgleak6_Given ) model->HSMHV_pgleak6 = 0.0 ; + if ( !model->HSMHV_pglksd1_Given ) model->HSMHV_pglksd1 = 0.0 ; + if ( !model->HSMHV_pglksd2_Given ) model->HSMHV_pglksd2 = 0.0 ; + if ( !model->HSMHV_pglkb1_Given ) model->HSMHV_pglkb1 = 0.0 ; + if ( !model->HSMHV_pglkb2_Given ) model->HSMHV_pglkb2 = 0.0 ; + if ( !model->HSMHV_pnftrp_Given ) model->HSMHV_pnftrp = 0.0 ; + if ( !model->HSMHV_pnfalp_Given ) model->HSMHV_pnfalp = 0.0 ; + if ( !model->HSMHV_ppthrou_Given ) model->HSMHV_ppthrou = 0.0 ; + if ( !model->HSMHV_pvdiffj_Given ) model->HSMHV_pvdiffj = 0.0 ; + if ( !model->HSMHV_pibpc1_Given ) model->HSMHV_pibpc1 = 0.0 ; + if ( !model->HSMHV_pibpc2_Given ) model->HSMHV_pibpc2 = 0.0 ; + if ( !model->HSMHV_pcgbo_Given ) model->HSMHV_pcgbo = 0.0 ; + if ( !model->HSMHV_pcvdsover_Given ) model->HSMHV_pcvdsover = 0.0 ; + if ( !model->HSMHV_pfalph_Given ) model->HSMHV_pfalph = 0.0 ; + if ( !model->HSMHV_pnpext_Given ) model->HSMHV_pnpext = 0.0 ; + if ( !model->HSMHV_ppowrat_Given ) model->HSMHV_ppowrat = 0.0 ; + if ( !model->HSMHV_prd_Given ) model->HSMHV_prd = 0.0 ; + if ( !model->HSMHV_prd22_Given ) model->HSMHV_prd22 = 0.0 ; + if ( !model->HSMHV_prd23_Given ) model->HSMHV_prd23 = 0.0 ; + if ( !model->HSMHV_prd24_Given ) model->HSMHV_prd24 = 0.0 ; + if ( !model->HSMHV_prdict1_Given ) model->HSMHV_prdict1 = 0.0 ; + if ( !model->HSMHV_prdov13_Given ) model->HSMHV_prdov13 = 0.0 ; + if ( !model->HSMHV_prdslp1_Given ) model->HSMHV_prdslp1 = 0.0 ; + if ( !model->HSMHV_prdvb_Given ) model->HSMHV_prdvb = 0.0 ; + if ( !model->HSMHV_prdvd_Given ) model->HSMHV_prdvd = 0.0 ; + if ( !model->HSMHV_prdvg11_Given ) model->HSMHV_prdvg11 = 0.0 ; + if ( !model->HSMHV_prs_Given ) model->HSMHV_prs = 0.0 ; + if ( !model->HSMHV_prth0_Given ) model->HSMHV_prth0 = 0.0 ; + if ( !model->HSMHV_pvover_Given ) model->HSMHV_pvover = 0.0 ; + + if ( model->HSMHV_rd26_Given ) model->HSMHV_qovsm = model->HSMHV_rd26 ; + if ( model->HSMHV_ldrift_Given ) model->HSMHV_ldrift2 = model->HSMHV_ldrift ; + + /* For Symmetrical Device */ + if ( model->HSMHV_cosym ) { + if(!model->HSMHV_rs_Given ) + { model->HSMHV_rs = model->HSMHV_rd ; } + if(!model->HSMHV_coovlps_Given ) + { model->HSMHV_coovlps = model->HSMHV_coovlp ; } + if(!model->HSMHV_novers_Given ) + { model->HSMHV_novers = model->HSMHV_nover ; } +/* if(!model->HSMHV_xld_Given ) */ +/* { model->HSMHV_xld = model->HSMHV_xldld ; } */ + if(!model->HSMHV_lover_Given ) + { model->HSMHV_lover = model->HSMHV_loverld ; } + if(!model->HSMHV_lovers_Given ) + { model->HSMHV_lovers = model->HSMHV_loverld ; } + if(!model->HSMHV_ldrift1s_Given ) + { model->HSMHV_ldrift1s = model->HSMHV_ldrift1 ; } + if(!model->HSMHV_ldrift2s_Given ) + { model->HSMHV_ldrift2s = model->HSMHV_ldrift2 ; } + if(!model->HSMHV_cgso_Given ) { model->HSMHV_cgso = model->HSMHV_cgdo ; + model->HSMHV_cgso_Given = model->HSMHV_cgdo_Given ; } + } + + if ( model->HSMHV_xqy > 0.0 && model->HSMHV_xqy < 1.0e-9 ) { + fprintf ( stderr , "*** warning(HiSIMHV): XQY (%e[m]) is too small -> reset to 1nm.\n" , model->HSMHV_xqy ) ; + model->HSMHV_xqy = 1e-9 ; + } + + modelMKS = &model->modelMKS ; + + /* loop through all the instances of the model */ + for ( here = model->HSMHVinstances ;here != NULL ; + here = here->HSMHVnextInstance ) { + /* allocate a chunk of the state vector */ + here->HSMHVstates = *states; + if (model->HSMHV_conqs) + *states += HSMHVnumStatesNqs; + else + *states += HSMHVnumStates; + + hereMKS = &here->hereMKS ; + /* perform the device parameter defaulting */ + if ( !here->HSMHV_coselfheat_Given ) here->HSMHV_coselfheat = model->HSMHV_coselfheat ; + if ( !here->HSMHV_cosubnode_Given ) here->HSMHV_cosubnode = model->HSMHV_cosubnode ; + if ( !here->HSMHV_l_Given ) here->HSMHV_l = 2.0e-6 ; + if ( !here->HSMHV_w_Given ) here->HSMHV_w = 5.0e-6 ; + if ( !here->HSMHV_ad_Given ) here->HSMHV_ad = 0.0 ; + if ( !here->HSMHV_as_Given ) here->HSMHV_as = 0.0 ; + if ( !here->HSMHV_pd_Given ) here->HSMHV_pd = 0.0 ; + if ( !here->HSMHV_ps_Given ) here->HSMHV_ps = 0.0 ; + if ( !here->HSMHV_nrd_Given ) here->HSMHV_nrd = 1.0 ; + if ( !here->HSMHV_nrs_Given ) here->HSMHV_nrs = 1.0 ; + if ( !here->HSMHV_ngcon_Given ) here->HSMHV_ngcon = 1.0 ; + if ( !here->HSMHV_xgw_Given ) here->HSMHV_xgw = 0e0 ; + if ( !here->HSMHV_xgl_Given ) here->HSMHV_xgl = 0e0 ; + if ( !here->HSMHV_nf_Given ) here->HSMHV_nf = 1.0 ; + if ( !here->HSMHV_sa_Given ) here->HSMHV_sa = 0 ; + if ( !here->HSMHV_sb_Given ) here->HSMHV_sb = 0 ; + if ( !here->HSMHV_sd_Given ) here->HSMHV_sd = 0 ; + if ( !here->HSMHV_dtemp_Given ) here->HSMHV_dtemp = 0.0 ; + + if ( !here->HSMHV_icVBS_Given ) here->HSMHV_icVBS = 0.0; + if ( !here->HSMHV_icVDS_Given ) here->HSMHV_icVDS = 0.0; + if ( !here->HSMHV_icVGS_Given ) here->HSMHV_icVGS = 0.0; + + if ( !here->HSMHV_corbnet_Given ) + here->HSMHV_corbnet = model->HSMHV_corbnet ; + else if ( here->HSMHV_corbnet != 0 && here->HSMHV_corbnet != 1 ) { + here->HSMHV_corbnet = model->HSMHV_corbnet ; + printf("warning(HiSIMHV): CORBNET has been set to its default value: %d.\n", here->HSMHV_corbnet); + } + if ( !here->HSMHV_rbdb_Given) here->HSMHV_rbdb = model->HSMHV_rbdb; /* not used in this version */ + if ( !here->HSMHV_rbsb_Given) here->HSMHV_rbsb = model->HSMHV_rbsb; /* not used in this version */ + if ( !here->HSMHV_rbpb_Given) here->HSMHV_rbpb = model->HSMHV_rbpb; + if ( !here->HSMHV_rbps_Given) here->HSMHV_rbps = model->HSMHV_rbps; + if ( !here->HSMHV_rbpd_Given) here->HSMHV_rbpd = model->HSMHV_rbpd; + + if ( !here->HSMHV_corg_Given ) + here->HSMHV_corg = model->HSMHV_corg ; + else if ( here->HSMHV_corg != 0 && here->HSMHV_corg != 1 ) { + here->HSMHV_corg = model->HSMHV_corg ; + printf("warning(HiSIMHV): CORG has been set to its default value: %d.\n", here->HSMHV_corg); + } + + if ( !here->HSMHV_m_Given ) here->HSMHV_m = 1.0 ; + if ( !here->HSMHV_subld1_Given ) here->HSMHV_subld1 = model->HSMHV_subld1 ; + if ( !here->HSMHV_subld2_Given ) here->HSMHV_subld2 = model->HSMHV_subld2 ; + if ( !here->HSMHV_lovers_Given ) here->HSMHV_lovers = model->HSMHV_lovers ; + if ( here->HSMHV_lover_Given ) here->HSMHV_lovers = here->HSMHV_lover ; + if ( !here->HSMHV_loverld_Given ) here->HSMHV_loverld = model->HSMHV_loverld ; + if ( !here->HSMHV_ldrift1_Given ) here->HSMHV_ldrift1 = model->HSMHV_ldrift1 ; + if ( !here->HSMHV_ldrift2_Given ) here->HSMHV_ldrift2 = model->HSMHV_ldrift2 ; + if ( !here->HSMHV_ldrift1s_Given ) here->HSMHV_ldrift1s = model->HSMHV_ldrift1s ; + if ( !here->HSMHV_ldrift2s_Given ) here->HSMHV_ldrift2s = model->HSMHV_ldrift2s ; + + if ( model->HSMHV_cosym ) { + if ( !here->HSMHV_lovers_Given && !model->HSMHV_lovers_Given ) here->HSMHV_lovers = here->HSMHV_loverld ; + here->HSMHV_lover = here->HSMHV_lovers ; + if ( !here->HSMHV_ldrift1s_Given && !model->HSMHV_ldrift1s_Given ) here->HSMHV_ldrift1s = here->HSMHV_ldrift1 ; + if ( !here->HSMHV_ldrift2s_Given && !model->HSMHV_ldrift2s_Given ) here->HSMHV_ldrift2s = here->HSMHV_ldrift2 ; + } + + + /* process drain series resistance */ + /* rough check if Rd != 0 * **** don't forget to change if Rd processing is changed *******/ + T2 = ( here->HSMHV_ldrift1 * model->HSMHV_rdslp1 * C_m2um + model->HSMHV_rdict1 ) + * ( here->HSMHV_ldrift2 * model->HSMHV_rdslp2 * C_m2um + model->HSMHV_rdict2 ) ; + Rd = model->HSMHV_rsh * here->HSMHV_nrd * here->HSMHV_nf + (model->HSMHV_rd + model->HSMHV_rdvd) * T2 ; + if ( (model->HSMHV_corsrd == 1 || model->HSMHV_corsrd == 3) + && Rd > 0.0 + && here->HSMHVdNodePrime <= 0) { + model->HSMHV_rd = ( model->HSMHV_rd == 0.0 ) ? 1e-50 : model->HSMHV_rd ; + error = CKTmkVolt(ckt, &tmp, here->HSMHVname, "drain"); + if (error) return(error); + here->HSMHVdNodePrime = tmp->number; + } else { + here->HSMHVdNodePrime = here->HSMHVdNode; + } + here->HSMHVdrainConductance = 0.0 ; /* initialized for hsmhvnoi.c */ + + /* process source series resistance */ + /* rough check if Rs != 0 * ***** don't forget to change if Rs processing is changed *******/ + T2 = ( here->HSMHV_ldrift1s * model->HSMHV_rdslp1 * C_m2um + model->HSMHV_rdict1 ) + * ( here->HSMHV_ldrift2s * model->HSMHV_rdslp2 * C_m2um + model->HSMHV_rdict2 ) ; + Rs = model->HSMHV_rsh * here->HSMHV_nrs * here->HSMHV_nf + model->HSMHV_rs * T2 ; + if ( (model->HSMHV_corsrd == 1 || model->HSMHV_corsrd == 3) + && Rs > 0.0 + && here->HSMHVsNodePrime == 0) { + error = CKTmkVolt(ckt, &tmp, here->HSMHVname, "source"); + if (error) return(error); + here->HSMHVsNodePrime = tmp->number; + } else { + here->HSMHVsNodePrime = here->HSMHVsNode; + } + here->HSMHVsourceConductance = 0.0 ; /* initialized for hsmhvnoi.c */ + printf("HSMHV_set: corsrd=%d dNode=%d dNodePrime=%d sNode=%d sNodePrime=%d\n",model->HSMHV_corsrd, + here->HSMHVdNode,here->HSMHVdNodePrime,here->HSMHVsNode,here->HSMHVsNodePrime); + + /* process gate resistance */ + if ((here->HSMHV_corg == 1 && model->HSMHV_rshg > 0.0) && here->HSMHVgNodePrime == 0) { + error = CKTmkVolt(ckt, &tmp, here->HSMHVname, "gate"); + if (error) return(error); + here->HSMHVgNodePrime = tmp->number; + } else { + here->HSMHVgNodePrime = here->HSMHVgNode; + } + + /* internal body nodes for body resistance model */ + if ( here->HSMHV_corbnet == 1 ) { + if (here->HSMHVdbNode == 0) { + error = CKTmkVolt(ckt, &tmp, here->HSMHVname, "dbody"); + if (error) return(error); + here->HSMHVdbNode = tmp->number; + } + if (here->HSMHVbNodePrime == 0) { + error = CKTmkVolt(ckt, &tmp,here->HSMHVname, "body"); + if (error) return(error); + here->HSMHVbNodePrime = tmp->number; + } + if (here->HSMHVsbNode == 0) { + error = CKTmkVolt(ckt, &tmp, here->HSMHVname,"sbody"); + if (error) return(error); + here->HSMHVsbNode = tmp->number; + } + } else { + here->HSMHVdbNode = here->HSMHVbNodePrime = here->HSMHVsbNode = here->HSMHVbNode; + } + + /* 5th node is switched to tempNode, if COSUBNODE=0 and 5 external nodes are assigned. */ + if ( here->HSMHV_cosubnode == 0 && here->HSMHVsubNode > 0 && here->HSMHVtempNode <= 0 ) { + here->HSMHVtempNode = here->HSMHVsubNode ; + here->HSMHVsubNode = -1 ; + } + + /* self heating*/ + if ( here->HSMHV_coselfheat > 0 && here->HSMHVtempNode <= 0 ){ + error = CKTmkVolt(ckt, &tmp, here->HSMHVname,"temp"); + if(error) return(error); + here->HSMHVtempNode = tmp->number; + } + if ( here->HSMHV_coselfheat <= 0 ) here->HSMHVtempNode = -1; + + /* flat handling of NQS */ + if ( model->HSMHV_conqs ){ + error = CKTmkVolt(ckt, &tmp, here->HSMHVname,"qi_nqs"); + if(error) return(error); + here->HSMHVqiNode = tmp->number; + error = CKTmkVolt(ckt, &tmp, here->HSMHVname,"qb_nqs"); + if(error) return(error); + here->HSMHVqbNode = tmp->number; + } + + + /* set Sparse Matrix Pointers */ + + /* macro to make elements with built in test for out of memory */ +#define TSTALLOC(ptr,first,second) \ +if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\ + return(E_NOMEM);\ +} + + TSTALLOC(HSMHVDPbpPtr, HSMHVdNodePrime, HSMHVbNodePrime) + TSTALLOC(HSMHVSPbpPtr, HSMHVsNodePrime, HSMHVbNodePrime) + TSTALLOC(HSMHVGPbpPtr, HSMHVgNodePrime, HSMHVbNodePrime) + + TSTALLOC(HSMHVBPdPtr, HSMHVbNodePrime, HSMHVdNode) + TSTALLOC(HSMHVBPdpPtr, HSMHVbNodePrime, HSMHVdNodePrime) + TSTALLOC(HSMHVBPspPtr, HSMHVbNodePrime, HSMHVsNodePrime) + TSTALLOC(HSMHVBPgpPtr, HSMHVbNodePrime, HSMHVgNodePrime) + TSTALLOC(HSMHVBPbpPtr, HSMHVbNodePrime, HSMHVbNodePrime) + + TSTALLOC(HSMHVDdPtr, HSMHVdNode, HSMHVdNode) + TSTALLOC(HSMHVGPgpPtr, HSMHVgNodePrime, HSMHVgNodePrime) + TSTALLOC(HSMHVSsPtr, HSMHVsNode, HSMHVsNode) + TSTALLOC(HSMHVDPdpPtr, HSMHVdNodePrime, HSMHVdNodePrime) + TSTALLOC(HSMHVSPspPtr, HSMHVsNodePrime, HSMHVsNodePrime) + TSTALLOC(HSMHVDdpPtr, HSMHVdNode, HSMHVdNodePrime) + TSTALLOC(HSMHVGPdpPtr, HSMHVgNodePrime, HSMHVdNodePrime) + TSTALLOC(HSMHVGPspPtr, HSMHVgNodePrime, HSMHVsNodePrime) + TSTALLOC(HSMHVSspPtr, HSMHVsNode, HSMHVsNodePrime) + TSTALLOC(HSMHVDPspPtr, HSMHVdNodePrime, HSMHVsNodePrime) + TSTALLOC(HSMHVDPdPtr, HSMHVdNodePrime, HSMHVdNode) + TSTALLOC(HSMHVDPgpPtr, HSMHVdNodePrime, HSMHVgNodePrime) + TSTALLOC(HSMHVSPgpPtr, HSMHVsNodePrime, HSMHVgNodePrime) + TSTALLOC(HSMHVSPsPtr, HSMHVsNodePrime, HSMHVsNode) + TSTALLOC(HSMHVSPdpPtr, HSMHVsNodePrime, HSMHVdNodePrime); + + TSTALLOC(HSMHVGgPtr, HSMHVgNode, HSMHVgNode); + TSTALLOC(HSMHVGgpPtr, HSMHVgNode, HSMHVgNodePrime); + TSTALLOC(HSMHVGPgPtr, HSMHVgNodePrime, HSMHVgNode); + /* TSTALLOC(HSMHVGdpPtr, HSMHVgNode, HSMHVdNodePrime); not used */ + /* TSTALLOC(HSMHVGspPtr, HSMHVgNode, HSMHVsNodePrime); not used */ + /* TSTALLOC(HSMHVGbpPtr, HSMHVgNode, HSMHVbNodePrime); not used */ + TSTALLOC(HSMHVDdbPtr, HSMHVdNode, HSMHVdbNode); + TSTALLOC(HSMHVSsbPtr, HSMHVsNode, HSMHVsbNode); + + TSTALLOC(HSMHVDBdPtr, HSMHVdbNode, HSMHVdNode); + TSTALLOC(HSMHVDBdbPtr, HSMHVdbNode, HSMHVdbNode); + TSTALLOC(HSMHVDBbpPtr, HSMHVdbNode, HSMHVbNodePrime); + /* TSTALLOC(HSMHVDBbPtr, HSMHVdbNode, HSMHVbNode); not used */ + + TSTALLOC(HSMHVBPdbPtr, HSMHVbNodePrime, HSMHVdbNode); + TSTALLOC(HSMHVBPbPtr, HSMHVbNodePrime, HSMHVbNode); + TSTALLOC(HSMHVBPsbPtr, HSMHVbNodePrime, HSMHVsbNode); + + TSTALLOC(HSMHVSBsPtr, HSMHVsbNode, HSMHVsNode); + TSTALLOC(HSMHVSBbpPtr, HSMHVsbNode, HSMHVbNodePrime); + /* TSTALLOC(HSMHVSBbPtr, HSMHVsbNode, HSMHVbNode); not used */ + TSTALLOC(HSMHVSBsbPtr, HSMHVsbNode, HSMHVsbNode); + + /* TSTALLOC(HSMHVBdbPtr, HSMHVbNode, HSMHVdbNode); not used */ + TSTALLOC(HSMHVBbpPtr, HSMHVbNode, HSMHVbNodePrime); + /* TSTALLOC(HSMHVBsbPtr, HSMHVbNode, HSMHVsbNode); not used */ + TSTALLOC(HSMHVBbPtr, HSMHVbNode, HSMHVbNode); + + TSTALLOC(HSMHVDgpPtr, HSMHVdNode, HSMHVgNodePrime); + TSTALLOC(HSMHVDsPtr, HSMHVdNode, HSMHVsNode); + TSTALLOC(HSMHVDbpPtr, HSMHVdNode, HSMHVbNodePrime); + TSTALLOC(HSMHVDPsPtr, HSMHVdNodePrime, HSMHVsNode); + + TSTALLOC(HSMHVSgpPtr, HSMHVsNode, HSMHVgNodePrime); + TSTALLOC(HSMHVSdPtr, HSMHVsNode, HSMHVdNode); + TSTALLOC(HSMHVSbpPtr, HSMHVsNode, HSMHVbNodePrime); + TSTALLOC(HSMHVSPdPtr, HSMHVsNodePrime, HSMHVdNode); + + TSTALLOC(HSMHVGPdPtr, HSMHVgNodePrime, HSMHVdNode); + TSTALLOC(HSMHVGPsPtr, HSMHVgNodePrime, HSMHVsNode); + + if ( here->HSMHVsubNode > 0 ) { /* 5th substrate node */ + TSTALLOC(HSMHVDsubPtr, HSMHVdNode, HSMHVsubNode); + TSTALLOC(HSMHVDPsubPtr, HSMHVdNodePrime, HSMHVsubNode); + TSTALLOC(HSMHVSsubPtr, HSMHVsNode, HSMHVsubNode); + TSTALLOC(HSMHVSPsubPtr, HSMHVsNodePrime, HSMHVsubNode); + } + if ( here->HSMHV_coselfheat > 0 ) { /* self heating */ + TSTALLOC(HSMHVTemptempPtr, HSMHVtempNode, HSMHVtempNode) + TSTALLOC(HSMHVTempdPtr, HSMHVtempNode, HSMHVdNode) + TSTALLOC(HSMHVTempdpPtr, HSMHVtempNode, HSMHVdNodePrime) + TSTALLOC(HSMHVTempsPtr, HSMHVtempNode, HSMHVsNode) + TSTALLOC(HSMHVTempspPtr, HSMHVtempNode, HSMHVsNodePrime) + TSTALLOC(HSMHVDPtempPtr, HSMHVdNodePrime, HSMHVtempNode) + TSTALLOC(HSMHVSPtempPtr, HSMHVsNodePrime, HSMHVtempNode) + + TSTALLOC(HSMHVTempgpPtr, HSMHVtempNode, HSMHVgNodePrime) + TSTALLOC(HSMHVTempbpPtr, HSMHVtempNode, HSMHVbNodePrime) + + TSTALLOC(HSMHVGPtempPtr, HSMHVgNodePrime, HSMHVtempNode) + TSTALLOC(HSMHVBPtempPtr, HSMHVbNodePrime, HSMHVtempNode) + + TSTALLOC(HSMHVDBtempPtr, HSMHVdbNode, HSMHVtempNode) + TSTALLOC(HSMHVSBtempPtr, HSMHVsbNode, HSMHVtempNode) + TSTALLOC(HSMHVDtempPtr, HSMHVdNode, HSMHVtempNode); + TSTALLOC(HSMHVStempPtr, HSMHVsNode, HSMHVtempNode); + } + if ( model->HSMHV_conqs ) { /* flat handling of NQS */ + TSTALLOC(HSMHVDPqiPtr, HSMHVdNodePrime, HSMHVqiNode) + TSTALLOC(HSMHVGPqiPtr, HSMHVgNodePrime, HSMHVqiNode) + TSTALLOC(HSMHVGPqbPtr, HSMHVgNodePrime, HSMHVqbNode) + TSTALLOC(HSMHVSPqiPtr, HSMHVsNodePrime, HSMHVqiNode) + TSTALLOC(HSMHVBPqbPtr, HSMHVbNodePrime, HSMHVqbNode) + TSTALLOC(HSMHVQIdpPtr, HSMHVqiNode, HSMHVdNodePrime) + TSTALLOC(HSMHVQIgpPtr, HSMHVqiNode, HSMHVgNodePrime) + TSTALLOC(HSMHVQIspPtr, HSMHVqiNode, HSMHVsNodePrime) + TSTALLOC(HSMHVQIbpPtr, HSMHVqiNode, HSMHVbNodePrime) + TSTALLOC(HSMHVQIqiPtr, HSMHVqiNode, HSMHVqiNode) + TSTALLOC(HSMHVQBdpPtr, HSMHVqbNode, HSMHVdNodePrime) + TSTALLOC(HSMHVQBgpPtr, HSMHVqbNode, HSMHVgNodePrime) + TSTALLOC(HSMHVQBspPtr, HSMHVqbNode, HSMHVsNodePrime) + TSTALLOC(HSMHVQBbpPtr, HSMHVqbNode, HSMHVbNodePrime) + TSTALLOC(HSMHVQBqbPtr, HSMHVqbNode, HSMHVqbNode) + if ( here->HSMHV_coselfheat > 0 ) { /* self heating */ + TSTALLOC(HSMHVQItempPtr, HSMHVqiNode, HSMHVtempNode) + TSTALLOC(HSMHVQBtempPtr, HSMHVqbNode, HSMHVtempNode) + } + } + + + + + /*-----------------------------------------------------------* + * Range check of instance parameters + *-----------------*/ + RANGECHECK(here->HSMHV_l, model->HSMHV_lmin, model->HSMHV_lmax, "L") ; + RANGECHECK(here->HSMHV_w, model->HSMHV_wmin, model->HSMHV_wmax, "W") ; + + /* binning calculation */ + pParam = &here->pParam ; + Lgate = here->HSMHV_l + model->HSMHV_xl ; + Wgate = here->HSMHV_w / here->HSMHV_nf + model->HSMHV_xw ; + LG = Lgate * C_m2um ; + WG = Wgate * C_m2um ; + Lbin = pow(LG, model->HSMHV_lbinn) ; + Wbin = pow(WG, model->HSMHV_wbinn) ; + LWbin = Lbin * Wbin ; + + BINNING(vmax) + BINNING(bgtmp1) + BINNING(bgtmp2) + BINNING(eg0) + BINNING(vfbover) + BINNING(nover) + BINNING(novers) + BINNING(wl2) + BINNING(vfbc) + BINNING(nsubc) + BINNING(nsubp) + BINNING(scp1) + BINNING(scp2) + BINNING(scp3) + BINNING(sc1) + BINNING(sc2) + BINNING(sc3) + BINNING(pgd1) + BINNING(pgd3) + BINNING(ndep) + BINNING(ninv) + BINNING(muecb0) + BINNING(muecb1) + BINNING(mueph1) + BINNING(vtmp) + BINNING(wvth0) + BINNING(muesr1) + BINNING(muetmp) + BINNING(sub1) + BINNING(sub2) + BINNING(svds) + BINNING(svbs) + BINNING(svgs) + BINNING(fn1) + BINNING(fn2) + BINNING(fn3) + BINNING(fvbs) + BINNING(nsti) + BINNING(wsti) + BINNING(scsti1) + BINNING(scsti2) + BINNING(vthsti) + BINNING(muesti1) + BINNING(muesti2) + BINNING(muesti3) + BINNING(nsubpsti1) + BINNING(nsubpsti2) + BINNING(nsubpsti3) + BINNING(cgso) + BINNING(cgdo) + BINNING(js0) + BINNING(js0sw) + BINNING(nj) + BINNING(cisbk) + BINNING(clm1) + BINNING(clm2) + BINNING(clm3) + BINNING(wfc) + BINNING(gidl1) + BINNING(gidl2) + BINNING(gleak1) + BINNING(gleak2) + BINNING(gleak3) + BINNING(gleak6) + BINNING(glksd1) + BINNING(glksd2) + BINNING(glkb1) + BINNING(glkb2) + BINNING(nftrp) + BINNING(nfalp) + BINNING(pthrou) + BINNING(vdiffj) + BINNING(ibpc1) + BINNING(ibpc2) + BINNING(cgbo) + BINNING(cvdsover) + BINNING(falph) + BINNING(npext) + BINNING(powrat) + BINNING(rd) + BINNING(rd22) + BINNING(rd23) + BINNING(rd24) + BINNING(rdict1) + BINNING(rdov13) + BINNING(rdslp1) + BINNING(rdvb) + BINNING(rdvd) + BINNING(rdvg11) + BINNING(rs) + BINNING(rth0) + BINNING(vover) + + /*-----------------------------------------------------------* + * Range check of model parameters + *-----------------*/ + RANGECHECK(pParam->HSMHV_vmax, 1.0e6, 20.0e6, "VMAX") ; + RANGECHECK(pParam->HSMHV_bgtmp1, 50.0e-6, 100.0e-6, "BGTMP1") ; + RANGECHECK(pParam->HSMHV_bgtmp2, -1.0e-6, 1.0e-6, "BGTMP2") ; + RANGECHECK(pParam->HSMHV_eg0, 1.0, 1.3, "EG0") ; + RANGECHECK(pParam->HSMHV_vfbover, -1.0, 1.0, "VFBOVER") ; + RANGECHECK(pParam->HSMHV_vfbc, -1.2, -0.8, "VFBC") ; + RANGECHECK(pParam->HSMHV_nsubc, 1.0e16, 1.0e19, "NSUBC") ; + RANGECHECK(pParam->HSMHV_nsubp, 1.0e16, 1.0e19, "NSUBP") ; + RANGECHECK(pParam->HSMHV_scp1, 0.0, 50.0, "SCP1") ; + RANGECHECK(pParam->HSMHV_scp2, 0.0, 50.0, "SCP2") ; + RANGECHECK(pParam->HSMHV_scp3, 0.0, 1.0e-3, "SCP3") ; + RANGECHECK(pParam->HSMHV_sc1, 0.0, 200.0, "SC1") ; + RANGECHECK(pParam->HSMHV_sc2, 0.0, 50.0, "SC2") ; + RANGECHECK(pParam->HSMHV_sc3, 0.0, 1.0e-3, "SC3") ; + RANGECHECK(pParam->HSMHV_pgd1, 0.0, 50.0e-3, "PGD1") ; + RANGECHECK(pParam->HSMHV_pgd3, 0.0, 1.0, "PGD3") ; + RANGECHECK(pParam->HSMHV_ndep, 0.0, 1.0, "NDEP") ; + RANGECHECK(pParam->HSMHV_ninv, 0.0, 1.0, "NINV") ; + RANGECHECK(pParam->HSMHV_muecb0, 100.0, 100.0e3, "MUECB0") ; + RANGECHECK(pParam->HSMHV_muecb1, 15.0, 10.0e3, "MUECB1") ; + RANGECHECK(pParam->HSMHV_mueph1, 2.0e3, 30.0e3, "MUEPH1") ; + RANGECHECK(pParam->HSMHV_vtmp, -2.0, 1.0, "VTMP") ; + RANGECHECK(pParam->HSMHV_muesr1, 1.0e14, 1.0e16, "MUESR1") ; + RANGECHECK(pParam->HSMHV_muetmp, 0.5, 2.0, "MUETMP") ; + RANGECHECK(pParam->HSMHV_clm1, 0.01, 1.0, "CLM1") ; + RANGECHECK(pParam->HSMHV_clm2, 1.0, 2.0, "CLM2") ; + RANGECHECK(pParam->HSMHV_clm3, 1.0, 5.0, "CLM3") ; + RANGECHECK(pParam->HSMHV_wfc, -5.0e-15, 1.0e-6, "WFC") ; + RANGECHECK(pParam->HSMHV_cgso, 0.0, 100e-9 * 100*C_VAC*model->HSMHV_kappa/model->HSMHV_tox*C_m2cm, "CGSO") ; + RANGECHECK(pParam->HSMHV_cgdo, 0.0, 100e-9 * 100*C_VAC*model->HSMHV_kappa/model->HSMHV_tox*C_m2cm, "CGDO") ; + RANGECHECK(pParam->HSMHV_pthrou, 0.0, 50.0e-3, "PTHROU") ; + RANGECHECK(pParam->HSMHV_ibpc1, 0.0, 1.0e12, "IBPC1") ; + RANGECHECK(pParam->HSMHV_ibpc2, 0.0, 1.0e12, "IBPC2") ; + RANGECHECK(pParam->HSMHV_cvdsover, 0.0, 1.0, "CVDSOVER") ; + RANGECHECK(pParam->HSMHV_nsti, 1.0e16, 1.0e19, "NSTI") ; + if ( pParam->HSMHV_cgbo < 0.0 ) { + printf("warning(HiSIMHV): %s = %e\n", "CGBO", pParam->HSMHV_cgbo ); + printf("warning(HiSIMHV): The model parameter %s must not be less than %s.\n", "CGBO", "0.0" ); + } + RANGECHECK(pParam->HSMHV_npext, 1.0e16, 1.0e18, "NPEXT") ; + RANGECHECK(pParam->HSMHV_rd, 0.0, 100.0e-3, "RD") ; + RANGECHECK(pParam->HSMHV_rd22, -5.0, 0.0, "RD22") ; + RANGECHECK(pParam->HSMHV_rd23, 0.0, 2.0, "RD23") ; + RANGECHECK(pParam->HSMHV_rd24, 0.0, 0.1, "RD24") ; + RANGECHECK(pParam->HSMHV_rdict1, -10.0, 10.0, "RDICT1") ; + RANGECHECK(pParam->HSMHV_rdov13, 0.0, 1.0, "RDOV13") ; + RANGECHECK(pParam->HSMHV_rdslp1, -10.0, 10.0, "RDSLP1") ; + RANGECHECK(pParam->HSMHV_rdvb, 0.0, 2.0, "RDVB") ; + RANGECHECK(pParam->HSMHV_rdvd, 0.0, 2.0, "RDVD") ; + MINCHECK( pParam->HSMHV_rdvg11, 0.0, "RDVG11") ; + RANGECHECK(pParam->HSMHV_rs, 0.0, 10.0e-3, "RS") ; + RANGECHECK(pParam->HSMHV_rth0, 0.0, 10.0, "RTH0") ; + RANGECHECK(pParam->HSMHV_vover, 0.0, 1.0, "VOVER") ; + + /*-----------------------------------------------------------* + * Change unit into MKS for instance parameters. + *-----------------*/ + + hereMKS->HSMHV_nsubcdfm = here->HSMHV_nsubcdfm / C_cm2m_p3 ; + hereMKS->HSMHV_subld2 = here->HSMHV_subld2 * C_m2cm ; + + pParam->HSMHV_nsubc = pParam->HSMHV_nsubc / C_cm2m_p3 ; + pParam->HSMHV_nsubp = pParam->HSMHV_nsubp / C_cm2m_p3 ; + pParam->HSMHV_nsti = pParam->HSMHV_nsti / C_cm2m_p3 ; + pParam->HSMHV_nover = pParam->HSMHV_nover / C_cm2m_p3 ; + pParam->HSMHV_novers = pParam->HSMHV_novers / C_cm2m_p3 ; + pParam->HSMHV_nsubpsti1 = pParam->HSMHV_nsubpsti1 / C_m2cm ; + pParam->HSMHV_muesti1 = pParam->HSMHV_muesti1 / C_m2cm ; + pParam->HSMHV_ndep = pParam->HSMHV_ndep / C_m2cm ; + pParam->HSMHV_ninv = pParam->HSMHV_ninv / C_m2cm ; + + pParam->HSMHV_vmax = pParam->HSMHV_vmax / C_m2cm ; + pParam->HSMHV_wfc = pParam->HSMHV_wfc * C_m2cm_p2 ; + pParam->HSMHV_glksd1 = pParam->HSMHV_glksd1 / C_m2cm ; + pParam->HSMHV_glksd2 = pParam->HSMHV_glksd2 * C_m2cm ; + pParam->HSMHV_gleak2 = pParam->HSMHV_gleak2 * C_m2cm ; + pParam->HSMHV_glkb2 = pParam->HSMHV_glkb2 * C_m2cm ; + pParam->HSMHV_fn2 = pParam->HSMHV_fn2 * C_m2cm ; + pParam->HSMHV_gidl1 = pParam->HSMHV_gidl1 / C_m2cm_p1o2 ; + pParam->HSMHV_gidl2 = pParam->HSMHV_gidl2 * C_m2cm ; + pParam->HSMHV_nfalp = pParam->HSMHV_nfalp / C_m2cm ; + pParam->HSMHV_nftrp = pParam->HSMHV_nftrp * C_m2cm_p2 ; + + pParam->HSMHV_npext = pParam->HSMHV_npext / C_cm2m_p3 ; + pParam->HSMHV_rd22 = pParam->HSMHV_rd22 / C_m2cm ; + pParam->HSMHV_rd23 = pParam->HSMHV_rd23 / C_m2cm ; + pParam->HSMHV_rd24 = pParam->HSMHV_rd24 / C_m2cm ; + pParam->HSMHV_rdvd = pParam->HSMHV_rdvd / C_m2cm ; + pParam->HSMHV_rth0 = pParam->HSMHV_rth0 / C_m2cm ; +// hereMKS->HSMHV_muecb0 = pParam->HSMHV_muecb0 * C_m2cm_p2 ; +// hereMKS->HSMHV_muecb1 = pParam->HSMHV_muecb1 * C_m2cm_p2 ; +// hereMKS->HSMHV_muesr1 = pParam->HSMHV_muesr1 * C_m2cm_p2 ; +// hereMKS->HSMHV_mueph1 = pParam->HSMHV_mueph1 * C_m2cm_p2 ; + + pParam->HSMHV_vfbover = - pParam->HSMHV_vfbover ; /* For Backward compatibility */ + + } /* instance */ + + + + /*-----------------------------------------------------------* + * Range check of model parameters + *-----------------*/ + RANGECHECK(model->HSMHV_shemax , 300, 600, "SHEMAX"); + if ( model->HSMHV_tox <= 0 ) { + printf("warning(HiSIMHV): TOX = %e\n ", model->HSMHV_tox); + printf("warning(HiSIMHV): The model parameter TOX must be positive.\n"); + } + RANGECHECK(model->HSMHV_xld, 0.0, 50.0e-9, "XLD") ; + RANGECHECK(model->HSMHV_xwd, -10.0e-9, 100.0e-9, "XWD") ; + RANGECHECK(model->HSMHV_xwdc, -10.0e-9, 100.0e-9, "XWDC") ; + RANGECHECK(model->HSMHV_rsh, 0.0, 1.0e-3, "RSH") ; + RANGECHECK(model->HSMHV_rshg, 0.0, 100.0, "RSHG") ; + if(model->HSMHV_xqy != 0.0) { MINCHECK (model->HSMHV_xqy, 10.0e-9, "XQY") ; } + MINCHECK (model->HSMHV_xqy1, 0.0, "XQY1") ; + MINCHECK (model->HSMHV_xqy2, 0.0, "XQY2") ; + RANGECHECK(model->HSMHV_vbi, 1.0, 1.2, "VBI") ; + RANGECHECK(model->HSMHV_parl2, 0.0, 50.0e-9, "PARL2") ; + RANGECHECK(model->HSMHV_lp, 0.0, 300.0e-9, "LP") ; + RANGECHECK(model->HSMHV_pgd2, 0.0, 1.5, "PGD2") ; + RANGECHECK(model->HSMHV_pgd4, 0.0, 3.0, "PGD4") ; + RANGECHECK(model->HSMHV_mueph0, 0.25, 0.35, "MUEPH0") ; + RANGECHECK(model->HSMHV_muesr0, 1.8, 2.2, "MUESR0") ; + RANGECHECK(model->HSMHV_lpext, 1.0e-50, 10.0e-6, "LPEXT") ; + RANGECHECK(model->HSMHV_scp21, 0.0, 5.0, "SCP21") ; + RANGECHECK(model->HSMHV_scp22, 0.0, 50.0e-3, "SCP22") ; + RANGECHECK(model->HSMHV_bs1, 0.0, 100.0e-3, "BS1") ; + RANGECHECK(model->HSMHV_bs2, 0.5, 1.0, "BS2") ; + RANGECHECK(model->HSMHV_clm5, 0.0, 5.0, "CLM5") ; + RANGECHECK(model->HSMHV_clm6, 0.0, 5.0, "CLM6") ; + RANGECHECK(model->HSMHV_voverp, 0.0, 2.0, "VOVERP") ; + RANGECHECK(model->HSMHV_qme1, 0.0, 300.0e-9, "QME1") ; + RANGECHECK(model->HSMHV_qme2, 0.0, 3.0, "QME2") ; + RANGECHECK(model->HSMHV_qme3, 0.0,800.0e-12, "QME3") ; + RANGECHECK(model->HSMHV_glpart1, 0.0, 1.0, "GLPART1") ; + RANGECHECK(model->HSMHV_tnom, 22.0, 32.0, "TNOM") ; + RANGECHECK(model->HSMHV_ddltmax, 1.0, 10.0, "DDLTMAX") ; + RANGECHECK(model->HSMHV_ddltict, -3.0, 20.0, "DDLTICT") ; + RANGECHECK(model->HSMHV_ddltslp, 0.0, 20.0, "DDLTSLP") ; + RANGECHECK(model->HSMHV_mphdfm, -3.0, 3.0, "MPHDFM") ; + RANGECHECK(model->HSMHV_cvb, -0.1, 0.2, "CVB") ; + RANGECHECK(model->HSMHV_cvbk, -0.1, 0.2, "CVBK") ; + RANGECHECK(model->HSMHV_rd20, 0.0, 30.0, "RD20") ; + RANGECHECK(model->HSMHV_rd21, 0.0, 1.0, "RD21") ; + RANGECHECK(model->HSMHV_rd22d, 0.0, 2.0, "RD22D") ; + MINCHECK( model->HSMHV_rd25, 0.0, "RD25") ; + RANGECHECK(model->HSMHV_rdtemp1, -1e-3, 1e-2, "RDTEMP1") ; + RANGECHECK(model->HSMHV_rdtemp2, -1e-5, 1e-5, "RDTEMP2") ; + RANGECHECK(model->HSMHV_rdvdtemp1,-1e-3, 1e-2, "RDVDTEMP1") ; + RANGECHECK(model->HSMHV_rdvdtemp2,-1e-5, 1e-5, "RDVDTEMP2") ; + MINCHECK( model->HSMHV_rdvg12, 0.0, "RDVG12") ; + RANGECHECK(model->HSMHV_rthtemp1, -1.0, 1.0, "RTHTEMP1") ; + RANGECHECK(model->HSMHV_rthtemp2, -1.0, 1.0, "RTHTEMP2") ; + RANGECHECK(model->HSMHV_rth0w, -100, 100, "RTH0W") ; + RANGECHECK(model->HSMHV_rth0wp, -10, 10, "RTH0WP") ; + RANGECHECK(model->HSMHV_rth0nf, -5.0, 5.0, "RTH0NF") ; + RANGECHECK(model->HSMHV_prattemp1, -1.0, 1.0, "PRATTEMP1") ; + RANGECHECK(model->HSMHV_prattemp2, -1.0, 1.0, "PRATTEMP2") ; + MINCHECK( model->HSMHV_xldld, 0.0, "XLDLD") ; + MINCHECK( model->HSMHV_loverld, 0.0, "LOVERLD") ; + MINCHECK( model->HSMHV_lovers, 0.0, "LOVERS") ; + MINCHECK( model->HSMHV_lover, 0.0, "LOVER") ; + RANGECHECK(model->HSMHV_qovsm, 10e-3, 1.0, "QOVSM") ; + MINCHECK( model->HSMHV_ldrift1, 0.0, "LDRIFT1") ; + MINCHECK( model->HSMHV_ldrift1s, 0.0, "LDRIFT1S") ; + MINCHECK( model->HSMHV_ldrift2, 0.0, "LDRIFT2") ; + MINCHECK( model->HSMHV_ldrift2s, 0.0, "LDRIFT2S") ; + MINCHECK( model->HSMHV_ldrift, 0.0, "LDRIFT") ; + RANGECHECK(model->HSMHV_rds, -100, 100, "RDS") ; + RANGECHECK(model->HSMHV_rdsp, -10, 10, "RDSP") ; + RANGECHECK(model->HSMHV_rdvdl, -100, 100, "RDVDL") ; + RANGECHECK(model->HSMHV_rdvdlp, -10, 10, "RDVDLP") ; + RANGECHECK(model->HSMHV_rdvds, -100, 100, "RDVDS") ; + RANGECHECK(model->HSMHV_rdvdsp, -10, 10, "RDVDSP") ; + RANGECHECK(model->HSMHV_rd23l, -100, 100, "RD23L") ; + RANGECHECK(model->HSMHV_rd23lp, -10, 10, "RD23LP") ; + RANGECHECK(model->HSMHV_rd23s, -100, 100, "RD23S") ; + RANGECHECK(model->HSMHV_rd23sp, -10, 10, "RD23SP") ; + RANGECHECK(model->HSMHV_rdov11, 0.0, 10, "RDOV11") ; + RANGECHECK(model->HSMHV_rdov12, 0.0, 2.0, "RDOV12") ; + RANGECHECK(model->HSMHV_rdslp2, -10.0, 10.0, "RDSLP2") ; + RANGECHECK(model->HSMHV_rdict2, -10.0, 10.0, "RDICT2") ; + + + /*-----------------------------------------------------------* + * Change units into MKS. + *-----------------*/ + + modelMKS->HSMHV_vmax = model->HSMHV_vmax / C_m2cm ; + modelMKS->HSMHV_ll = model->HSMHV_ll / pow( C_m2cm , model->HSMHV_lln ) ; + modelMKS->HSMHV_wl = model->HSMHV_wl / pow( C_m2cm , model->HSMHV_wln ) ; + modelMKS->HSMHV_svgsl = model->HSMHV_svgsl / pow( C_m2cm , model->HSMHV_svgslp ) ; + modelMKS->HSMHV_svgsw = model->HSMHV_svgsw / pow( C_m2cm , model->HSMHV_svgswp ) ; + modelMKS->HSMHV_svbsl = model->HSMHV_svbsl / pow( C_m2cm , model->HSMHV_svbslp ) ; + modelMKS->HSMHV_slgl = model->HSMHV_slgl / pow( C_m2cm , model->HSMHV_slglp ) ; + modelMKS->HSMHV_sub1l = model->HSMHV_sub1l / pow( C_m2cm , model->HSMHV_sub1lp ) ; + modelMKS->HSMHV_slg = model->HSMHV_slg / C_m2cm ; + modelMKS->HSMHV_sub2l = model->HSMHV_sub2l / C_m2cm ; + modelMKS->HSMHV_subld2 = model->HSMHV_subld2 * C_m2cm ; + modelMKS->HSMHV_rdtemp1 = model->HSMHV_rdtemp1 / C_m2cm ; + modelMKS->HSMHV_rdtemp2 = model->HSMHV_rdtemp2 / C_m2cm ; + modelMKS->HSMHV_rdvdtemp1 = model->HSMHV_rdvdtemp1 / C_m2cm ; + modelMKS->HSMHV_rdvdtemp2 = model->HSMHV_rdvdtemp2 / C_m2cm ; + modelMKS->HSMHV_nsubsub = model->HSMHV_nsubsub / C_cm2m_p3 ; + modelMKS->HSMHV_nsubpsti1 = model->HSMHV_nsubpsti1 / C_m2cm ; + modelMKS->HSMHV_muesti1 = model->HSMHV_muesti1 / C_m2cm ; + modelMKS->HSMHV_wfc = model->HSMHV_wfc * C_m2cm_p2 ; + modelMKS->HSMHV_glksd1 = model->HSMHV_glksd1 / C_m2cm ; + modelMKS->HSMHV_glksd2 = model->HSMHV_glksd2 * C_m2cm ; + modelMKS->HSMHV_glksd3 = model->HSMHV_glksd3 * C_m2cm ; + modelMKS->HSMHV_gleak2 = model->HSMHV_gleak2 * C_m2cm ; + modelMKS->HSMHV_gleak4 = model->HSMHV_gleak4 * C_m2cm ; + modelMKS->HSMHV_gleak5 = model->HSMHV_gleak5 * C_m2cm ; + modelMKS->HSMHV_gleak7 = model->HSMHV_gleak7 / C_m2cm_p2 ; + modelMKS->HSMHV_glkb2 = model->HSMHV_glkb2 * C_m2cm ; + modelMKS->HSMHV_fn2 = model->HSMHV_fn2 * C_m2cm ; + modelMKS->HSMHV_gidl1 = model->HSMHV_gidl1 / C_m2cm_p1o2 ; + modelMKS->HSMHV_gidl2 = model->HSMHV_gidl2 * C_m2cm ; + modelMKS->HSMHV_nfalp = model->HSMHV_nfalp / C_m2cm ; + modelMKS->HSMHV_nftrp = model->HSMHV_nftrp * C_m2cm_p2 ; + modelMKS->HSMHV_cit = model->HSMHV_cit * C_m2cm_p2 ; + modelMKS->HSMHV_ovslp = model->HSMHV_ovslp / C_m2cm ; + modelMKS->HSMHV_dly3 = model->HSMHV_dly3 / C_m2cm_p2 ; + modelMKS->HSMHV_cth0 = model->HSMHV_cth0 * C_m2cm ; +// modelMKS->HSMHV_muecb0 = model->HSMHV_muecb0 * C_cm2m_p2 ; +// modelMKS->HSMHV_muecb1 = model->HSMHV_muecb1 * C_cm2m_p2 ; +// modelMKS->HSMHV_muesr1 = model->HSMHV_muesr1 * C_cm2m_p2 ; +// modelMKS->HSMHV_mueph1 = model->HSMHV_mueph1 * C_cm2m_p2 ; + + + /*-----------------------------------------------------------* + * Change unit into Kelvin. + *-----------------*/ + model->HSMHV_ktnom = model->HSMHV_tnom + 273.15 ; /* [C] -> [K] */ + + + } /* model */ + + /* Reset ckt->CKTbypass to 0 */ + if( ckt->CKTbypass == 1 ) { + fprintf( stderr, "\nwarning(HiSIMHV): The BYPASS option is reset to 0 for reliable simulation.\n"); + ckt->CKTbypass = 0 ; + } + /* check ckt->CKTintegrateMethod */ + if( ckt->CKTintegrateMethod == TRAPEZOIDAL ) { /* TRAPEZODAL:1 GEAR:2 */ + fprintf( stderr, "\nwarning(HiSIMHV): Recommend the Gear method for reliable simulation with '.options METHOD=GEAR'.\n"); + } + + return(OK); +} + +int +HSMHVunsetup( + GENmodel *inModel, + CKTcircuit *ckt) +{ +#ifndef HAS_BATCHSIM + HSMHVmodel *model; + HSMHVinstance *here; + + for (model = (HSMHVmodel *)inModel; model != NULL; + model = model->HSMHVnextModel) + { + for (here = model->HSMHVinstances; here != NULL; + here=here->HSMHVnextInstance) + { + if (here->HSMHVdNodePrime + && here->HSMHVdNodePrime != here->HSMHVdNode) + { + CKTdltNNum(ckt, here->HSMHVdNodePrime); + here->HSMHVdNodePrime = 0; + } + if (here->HSMHVsNodePrime + && here->HSMHVsNodePrime != here->HSMHVsNode) + { + CKTdltNNum(ckt, here->HSMHVsNodePrime); + here->HSMHVsNodePrime = 0; + } + } + } +#endif + return OK; +} diff --git a/src/spicelib/devices/hisimhv/hsmhvtemp.c b/src/spicelib/devices/hisimhv/hsmhvtemp.c new file mode 100644 index 000000000..fca8600ff --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvtemp.c @@ -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 +#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); +} diff --git a/src/spicelib/devices/hisimhv/hsmhvtemp_eval.h b/src/spicelib/devices/hisimhv/hsmhvtemp_eval.h new file mode 100644 index 000000000..0bf0b392b --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvtemp_eval.h @@ -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 */ diff --git a/src/spicelib/devices/hisimhv/hsmhvtrunc.c b/src/spicelib/devices/hisimhv/hsmhvtrunc.c new file mode 100644 index 000000000..ae03f29cc --- /dev/null +++ b/src/spicelib/devices/hisimhv/hsmhvtrunc.c @@ -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 +#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); +} diff --git a/src/spicelib/parser/inp2m.c b/src/spicelib/parser/inp2m.c index 9b1b96359..bcfac7ce6 100644 --- a/src/spicelib/parser/inp2m.c +++ b/src/spicelib/parser/inp2m.c @@ -22,41 +22,41 @@ INP2M (CKTcircuit *ckt, INPtables * tab, card * current) * [IC=,,] */ - 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)); diff --git a/src/spicelib/parser/inpdomod.c b/src/spicelib/parser/inpdomod.c index a2e28d244..4b849b065 100644 --- a/src/spicelib/parser/inpdomod.c +++ b/src/spicelib/parser/inpdomod.c @@ -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; } diff --git a/visualc/vngspice.vcproj b/visualc/vngspice.vcproj index 66a38684f..7bf34026b 100644 --- a/visualc/vngspice.vcproj +++ b/visualc/vngspice.vcproj @@ -1,8785 +1,8777 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +