epilectrik
/
pyNgSpice
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

add the HiSIM_HV model vers. 1.2.1

pre-master-46
dwarning 15 years ago
parent
46da3b066e
commit
1906903fb4
36 changed files with 31386 additions and 9006 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      configure.ac
  2. 1
      src/Makefile.am
  3. 2
      src/spicelib/devices/Makefile.am
  4. 80
      src/spicelib/devices/dev.c
  5. 36
      src/spicelib/devices/hisimhv/Makefile.am
  6. 73
      src/spicelib/devices/hisimhv/hisimhv.h
  7. 740
      src/spicelib/devices/hisimhv/hsmhv.c
  8. 295
      src/spicelib/devices/hisimhv/hsmhvacld.c
  9. 421
      src/spicelib/devices/hisimhv/hsmhvask.c
  10. 254
      src/spicelib/devices/hisimhv/hsmhvcvtest.c
  11. 2912
      src/spicelib/devices/hisimhv/hsmhvdef.h
  12. 47
      src/spicelib/devices/hisimhv/hsmhvdel.c
  13. 45
      src/spicelib/devices/hisimhv/hsmhvdest.c
  14. 6393
      src/spicelib/devices/hisimhv/hsmhveval.c
  15. 693
      src/spicelib/devices/hisimhv/hsmhveval_qover.h
  16. 91
      src/spicelib/devices/hisimhv/hsmhvevalenv.h
  17. 39
      src/spicelib/devices/hisimhv/hsmhvext.h
  18. 57
      src/spicelib/devices/hisimhv/hsmhvgetic.c
  19. 82
      src/spicelib/devices/hisimhv/hsmhvinit.c
  20. 13
      src/spicelib/devices/hisimhv/hsmhvinit.h
  21. 23
      src/spicelib/devices/hisimhv/hsmhvitf.h
  22. 2583
      src/spicelib/devices/hisimhv/hsmhvld.c
  23. 123
      src/spicelib/devices/hisimhv/hsmhvld_info_eval.h
  24. 1855
      src/spicelib/devices/hisimhv/hsmhvmask.c
  25. 54
      src/spicelib/devices/hisimhv/hsmhvmdel.c
  26. 2454
      src/spicelib/devices/hisimhv/hsmhvmpar.c
  27. 279
      src/spicelib/devices/hisimhv/hsmhvnoi.c
  28. 212
      src/spicelib/devices/hisimhv/hsmhvpar.c
  29. 280
      src/spicelib/devices/hisimhv/hsmhvpzld.c
  30. 1454
      src/spicelib/devices/hisimhv/hsmhvset.c
  31. 419
      src/spicelib/devices/hisimhv/hsmhvtemp.c
  32. 382
      src/spicelib/devices/hisimhv/hsmhvtemp_eval.h
  33. 61
      src/spicelib/devices/hisimhv/hsmhvtrunc.c
  34. 360
      src/spicelib/parser/inp2m.c
  35. 12
      src/spicelib/parser/inpdomod.c
  36. 236
      visualc/vngspice.vcproj

1
configure.ac
View File

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

1
src/Makefile.am
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2912
src/spicelib/devices/hisimhv/hsmhvdef.h
File diff suppressed because it is too large
View File

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

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

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

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

6393
src/spicelib/devices/hisimhv/hsmhveval.c
File diff suppressed because it is too large
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2583
src/spicelib/devices/hisimhv/hsmhvld.c
File diff suppressed because it is too large
View File

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

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

1855
src/spicelib/devices/hisimhv/hsmhvmask.c
File diff suppressed because it is too large
View File

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

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

2454
src/spicelib/devices/hisimhv/hsmhvmpar.c
File diff suppressed because it is too large
View File

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

@ -0,0 +1,279 @@
/***********************************************************************
HiSIM (Hiroshima University STARC IGFET Model)
Copyright (C) 2010 Hiroshima University & STARC
MODEL NAME : HiSIM_HV
( VERSION : 1 SUBVERSION : 2 REVISION : 1 )
Model Parameter VERSION : 1.21
FILE : hsmhvnoi.c
DATE : 2010.11.02
released by
Hiroshima University &
Semiconductor Technology Academic Research Center (STARC)
***********************************************************************/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "hsmhvdef.h"
#include "cktdefs.h"
/* #include "fteconst.h" */
#include "iferrmsg.h"
#include "noisedef.h"
#include "suffix.h"
#include "const.h" /* jwan */
#include "hsmhvevalenv.h"
/* #include "hsmhvmacro.h" */
/*
* HSMHVnoise (mode, operation, firstModel, ckt, data, OnDens)
* This routine names and evaluates all of the noise sources
* associated with MOSFET's. It starts with the model *firstModel and
* traverses all of its insts. It then proceeds to any other models
* on the linked list. The total output noise density generated by
* all of the MOSFET's is summed with the variable "OnDens".
*/
extern void NevalSrc();
extern double Nintegrate();
int HSMHVnoise (
int mode, int operation,
GENmodel *inModel,
CKTcircuit *ckt,
register Ndata *data,
double *OnDens)
{
register HSMHVmodel *model = (HSMHVmodel *)inModel;
register HSMHVinstance *here;
char name[N_MXVLNTH];
double tempOnoise=0.0 ;
double tempInoise=0.0 ;
double noizDens[HSMHVNSRCS] ;
double lnNdens[HSMHVNSRCS] ;
register int i;
double G =0.0 ;
double TTEMP = 0.0 ;
/* define the names of the noise sources */
static char * HSMHVnNames[HSMHVNSRCS] = {
/* Note that we have to keep the order
consistent with the index definitions
in hsmhvdefs.h */
".rd", /* noise due to rd */
".rs", /* noise due to rs */
".id", /* noise due to id */
".1ovf", /* flicker (1/f) noise */
".ign", /* induced gate noise component at the drain node */
"" /* total transistor noise */
};
for ( ;model != NULL; model = model->HSMHVnextModel ) {
for ( here = model->HSMHVinstances; here != NULL;
here = here->HSMHVnextInstance ) {
switch (operation) {
case N_OPEN:
/* see if we have to to produce a summary report */
/* if so, name all the noise generators */
if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0) {
switch (mode) {
case N_DENS:
for ( i = 0; i < HSMHVNSRCS; i++ ) {
(void) sprintf(name, "onoise.%s%s",
(char *)here->HSMHVname, HSMHVnNames[i]);
data->namelist =
(IFuid *) trealloc((char *) data->namelist,
(data->numPlots + 1) * sizeof(IFuid));
if (!data->namelist)
return(E_NOMEM);
(*(SPfrontEnd->IFnewUid))
(ckt, &(data->namelist[data->numPlots++]),
(IFuid) NULL, name, UID_OTHER, NULL);
}
break;
case INT_NOIZ:
for ( i = 0; i < HSMHVNSRCS; i++ ) {
(void) sprintf(name, "onoise_total.%s%s",
(char *)here->HSMHVname, HSMHVnNames[i]);
data->namelist =
(IFuid *) trealloc((char *) data->namelist,
(data->numPlots + 1) * sizeof(IFuid));
if (!data->namelist)
return(E_NOMEM);
(*(SPfrontEnd->IFnewUid))
(ckt, &(data->namelist[data->numPlots++]),
(IFuid) NULL, name, UID_OTHER, NULL);
(void) sprintf(name, "inoise_total.%s%s",
(char *)here->HSMHVname, HSMHVnNames[i]);
data->namelist =
(IFuid *) trealloc((char *) data->namelist,
(data->numPlots + 1) * sizeof(IFuid));
if (!data->namelist)
return(E_NOMEM);
(*(SPfrontEnd->IFnewUid))
(ckt, &(data->namelist[data->numPlots++]),
(IFuid) NULL, name, UID_OTHER, NULL);
}
break;
}
}
break;
case N_CALC:
switch (mode) {
case N_DENS:
/* temperature */
TTEMP = ckt->CKTtemp;
if ( here->HSMHV_dtemp_Given ) { TTEMP = TTEMP + here->HSMHV_dtemp ; }
TTEMP = TTEMP + *(ckt->CKTstate0 + here->HSMHVdeltemp) ;
/* rs/rd thermal noise */
if ( model->HSMHV_corsrd == 1 || model->HSMHV_corsrd == 3 ) {
NevalSrc(&noizDens[HSMHVRDNOIZ], (double*) NULL,
ckt, N_GAIN,
here->HSMHVdNodePrime, here->HSMHVdNode,
(double) 0.0);
noizDens[HSMHVRDNOIZ] *= 4 * C_KB * TTEMP * here->HSMHVdrainConductance ;
lnNdens[HSMHVRDNOIZ] = log( MAX(noizDens[HSMHVRDNOIZ],N_MINLOG) );
NevalSrc(&noizDens[HSMHVRSNOIZ], (double*) NULL,
ckt, N_GAIN,
here->HSMHVsNodePrime, here->HSMHVsNode,
(double) 0.0);
noizDens[HSMHVRSNOIZ] *= 4 * C_KB * TTEMP * here->HSMHVsourceConductance ;
lnNdens[HSMHVRSNOIZ] = log( MAX(noizDens[HSMHVRSNOIZ],N_MINLOG) );
} else {
noizDens[HSMHVRDNOIZ] = 0e0 ;
lnNdens[HSMHVRDNOIZ] = N_MINLOG ;
noizDens[HSMHVRSNOIZ] = 0e0 ;
lnNdens[HSMHVRSNOIZ] = N_MINLOG ;
}
/* channel thermal noise */
NevalSrc(&noizDens[HSMHVIDNOIZ], (double*) NULL,
ckt, N_GAIN,
here->HSMHVdNodePrime, here->HSMHVsNodePrime,
(double) 0.0);
switch( model->HSMHV_noise ) {
case 1:
/* HiSIMHV model */
G = here->HSMHV_noithrml ;
noizDens[HSMHVIDNOIZ] *= 4 * C_KB * TTEMP * G ;
lnNdens[HSMHVIDNOIZ] = log( MAX(noizDens[HSMHVIDNOIZ],N_MINLOG) );
break;
}
/* flicker noise */
NevalSrc(&noizDens[HSMHVFLNOIZ], (double*) NULL,
ckt, N_GAIN,
here->HSMHVdNodePrime, here->HSMHVsNodePrime,
(double) 0.0);
switch ( model->HSMHV_noise ) {
case 1:
/* HiSIM model */
noizDens[HSMHVFLNOIZ] *= here->HSMHV_noiflick / pow(data->freq, model->HSMHV_falph) ;
lnNdens[HSMHVFLNOIZ] = log(MAX(noizDens[HSMHVFLNOIZ], N_MINLOG));
break;
}
/* induced gate noise */
NevalSrc(&noizDens[HSMHVIGNOIZ], (double*) NULL,
ckt, N_GAIN,
here->HSMHVdNodePrime, here->HSMHVsNodePrime,
(double) 0.0);
switch ( model->HSMHV_noise ) {
case 1:
/* HiSIM model */
noizDens[HSMHVIGNOIZ] *= here->HSMHV_noiigate * here->HSMHV_noicross * here->HSMHV_noicross * data->freq * data->freq;
lnNdens[HSMHVIGNOIZ] = log(MAX(noizDens[HSMHVIGNOIZ], N_MINLOG));
break;
}
/* total */
noizDens[HSMHVTOTNOIZ] = noizDens[HSMHVRDNOIZ] + noizDens[HSMHVRSNOIZ]
+ noizDens[HSMHVIDNOIZ] + noizDens[HSMHVFLNOIZ] + noizDens[HSMHVIGNOIZ];
lnNdens[HSMHVTOTNOIZ] = log(MAX(noizDens[HSMHVTOTNOIZ], N_MINLOG));
*OnDens += noizDens[HSMHVTOTNOIZ];
if ( data->delFreq == 0.0 ) {
/* if we haven't done any previous
integration, we need to initialize our
"history" variables.
*/
for ( i = 0; i < HSMHVNSRCS; i++ )
here->HSMHVnVar[LNLSTDENS][i] = lnNdens[i];
/* clear out our integration variables
if it's the first pass
*/
if (data->freq == ((NOISEAN*) ckt->CKTcurJob)->NstartFreq) {
for (i = 0; i < HSMHVNSRCS; i++) {
here->HSMHVnVar[OUTNOIZ][i] = 0.0;
here->HSMHVnVar[INNOIZ][i] = 0.0;
}
}
}
else {
/* data->delFreq != 0.0,
we have to integrate.
*/
for ( i = 0; i < HSMHVNSRCS; i++ ) {
if ( i != HSMHVTOTNOIZ ) {
tempOnoise =
Nintegrate(noizDens[i], lnNdens[i],
here->HSMHVnVar[LNLSTDENS][i], data);
tempInoise =
Nintegrate(noizDens[i] * data->GainSqInv,
lnNdens[i] + data->lnGainInv,
here->HSMHVnVar[LNLSTDENS][i] + data->lnGainInv,
data);
here->HSMHVnVar[LNLSTDENS][i] = lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if ( ((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0 ) {
here->HSMHVnVar[OUTNOIZ][i] += tempOnoise;
here->HSMHVnVar[OUTNOIZ][HSMHVTOTNOIZ] += tempOnoise;
here->HSMHVnVar[INNOIZ][i] += tempInoise;
here->HSMHVnVar[INNOIZ][HSMHVTOTNOIZ] += tempInoise;
}
}
}
}
if ( data->prtSummary ) {
for (i = 0; i < HSMHVNSRCS; i++) {
/* print a summary report */
data->outpVector[data->outNumber++] = noizDens[i];
}
}
break;
case INT_NOIZ:
/* already calculated, just output */
if ( ((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0 ) {
for ( i = 0; i < HSMHVNSRCS; i++ ) {
data->outpVector[data->outNumber++] = here->HSMHVnVar[OUTNOIZ][i];
data->outpVector[data->outNumber++] = here->HSMHVnVar[INNOIZ][i];
}
}
break;
}
break;
case N_CLOSE:
/* do nothing, the main calling routine will close */
return (OK);
break; /* the plots */
} /* switch (operation) */
} /* for here */
} /* for model */
return(OK);
}

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

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

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

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

1454
src/spicelib/devices/hisimhv/hsmhvset.c
File diff suppressed because it is too large
View File

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

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

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

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

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

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

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

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

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

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

236
visualc/vngspice.vcproj
View File

@ -1082,26 +1082,6 @@
RelativePath="..\src\maths\misc\bernoull.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2defs.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2dset.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2ext.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2init.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2itf.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt\bjtdefs.h"
>
@ -1910,6 +1890,10 @@
RelativePath="..\src\spicelib\devices\hisim\hisim.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hisimhv.h"
>
</File>
<File
RelativePath="..\src\include\hlpdefs.h"
>
@ -1938,6 +1922,38 @@
RelativePath="..\src\spicelib\devices\hisim\hsm1itf.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvdef.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhveval_qover.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvevalenv.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvext.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvinit.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvitf.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvld_info_eval.h"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvtemp_eval.h"
>
</File>
<File
RelativePath="..\src\include\iferrmsg.h"
>
@ -1971,11 +1987,11 @@
>
</File>
<File
RelativePath="..\src\frontend\inp.h"
RelativePath="..\src\spicelib\parser\inp.h"
>
</File>
<File
RelativePath="..\src\spicelib\parser\inp.h"
RelativePath="..\src\frontend\inp.h"
>
</File>
<File
@ -4250,106 +4266,6 @@
RelativePath="..\src\spicelib\devices\bjt\bjt.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2acld.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2ask.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2conv.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2del.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2dest.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2disto.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2dset.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2getic.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2init.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2load.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2mask.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2mdel.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2mpar.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2noise.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2param.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2pzld.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2sacl.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2setup.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2sload.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2sprt.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2sset.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2supd.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2temp.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt2\bjt2trun.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\bjt\bjtacld.c"
>
@ -5882,6 +5798,82 @@
RelativePath="..\src\spicelib\devices\hisim\hsm1trunc.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhv.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvacld.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvask.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvcvtest.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvdel.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvdest.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhveval.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvgetic.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvinit.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvld.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvmask.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvmdel.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvmpar.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvnoi.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvpar.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvpzld.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvset.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvtemp.c"
>
</File>
<File
RelativePath="..\src\spicelib\devices\hisimhv\hsmhvtrunc.c"
>
</File>
<File
RelativePath="..\src\xspice\idn\idndig.c"
>

Write Preview
Loading…
Cancel
Save