hisim2, populate this new directory

ChangeLog

@@ -1,3 +1,10 @@
+2011-05-22  Robert Larice
+ * src/spicelib/devices/hisim2/* :
+   hisim2, populate this new directory
+     with files from HiSIM_2.5.1_Release_20110407.zip
+   unchanged, from
+     HiSIM_2.5.1_Release_20110407/HiSIM_2.5.1_C-Code/hisim2/
+
 2011-05-21  Robert Larice
  * src/spicelib/devices/hisimhv/hsmhvset.c :
    extend HSMHVunsetup() to process some more CKTmkVolt() generated nodes
@@ -5,7 +12,7 @@
 
 2011-05-21  Holger Vogt
  * windisp.c, winprint.c, windisp.h, winprint.h, display.c xdisplay.c,
-   winmain.c: reduce compiler warnings 
+   winmain.c: reduce compiler warnings
 
 2011-05-20  Robert Larice
  * src/spicelib/devices/adms/admst/ngspiceMakefile.am.xml:

src/spicelib/devices/hisim2/hisim2.h

@@ -0,0 +1,70 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hisim2.h
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "hsm2def.h"
+#include "cktdefs.h"
+
+#ifndef _HiSIM2_H
+#define _HiSIM2_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
+
+#ifdef __STDC__
+extern int HSM2evaluate
+(
+ double ivds,
+ double ivgs,
+ double ivbs,
+ double vbs_jct,
+ double vbd_jct,
+ HSM2instance *here,
+ HSM2model    *model,
+ CKTcircuit   *ckt
+ ) ;
+#else
+extern int HSM2evaluate() ;
+#endif
+
+#endif /* _HiSIM2_H */

src/spicelib/devices/hisim2/hsm2.c

@@ -0,0 +1,608 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "devdefs.h"
+#include "hsm2def.h"
+#include "suffix.h"
+
+IFparm HSM2pTable[] = { /* parameters */
+ IOP( "l",   HSM2_L,      IF_REAL   , "Length"),
+ IOP( "w",   HSM2_W,      IF_REAL   , "Width"),
+ IOP( "ad",  HSM2_AD,     IF_REAL   , "Drain area"),
+ IOP( "as",  HSM2_AS,     IF_REAL   , "Source area"),
+ IOP( "pd",  HSM2_PD,     IF_REAL   , "Drain perimeter"),
+ IOP( "ps",  HSM2_PS,     IF_REAL   , "Source perimeter"),
+ IOP( "nrd", HSM2_NRD,    IF_REAL   , "Number of squares in drain"),
+ IOP( "nrs", HSM2_NRS,    IF_REAL   , "Number of squares in source"),
+ IOP( "temp", HSM2_TEMP,  IF_REAL   , "Lattice temperature [K]"),
+ IOP( "dtemp", HSM2_DTEMP,IF_REAL   , ""),
+ IOP( "off", HSM2_OFF,    IF_FLAG   , "Device is initially off"), 
+ IP ( "ic",  HSM2_IC,     IF_REALVEC , "Vector of DS,GS,BS initial voltages"),
+ IOP("corbnet", HSM2_CORBNET, IF_INTEGER, "activate body resistance (1) or not (0)"),
+ IOP("rbpb", HSM2_RBPB, IF_REAL, ""),
+ IOP("rbpd", HSM2_RBPD, IF_REAL, ""),
+ IOP("rbps", HSM2_RBPS, IF_REAL, ""),
+ IOP("rbdb", HSM2_RBDB, IF_REAL, ""),
+ IOP("rbsb", HSM2_RBSB, IF_REAL, ""),
+ IOP("corg", HSM2_CORG, IF_INTEGER, "activate gate resistance (1) or not (0)"),
+/*  IOP("rshg", HSM2_RSHG, IF_REAL, "gate-elecrode sheet resistance"), */
+ IOP("ngcon", HSM2_NGCON, IF_REAL, "number of gate contacts"),
+ IOP("xgw", HSM2_XGW, IF_REAL, "distance from gate contact to channel edge"),
+ IOP("xgl", HSM2_XGL, IF_REAL, "offset of gate length due to variation in patterning"),
+ IOP("nf", HSM2_NF, IF_REAL, "number of fingers"),
+ IOP("sa", HSM2_SA, IF_REAL, "distance from STI edge to Gate edge [m]"),
+ IOP("sb", HSM2_SB, IF_REAL, "distance from STI edge to Gate edge [m]"),
+ IOP("sd", HSM2_SD, IF_REAL, "distance from Gate edge to Gate edge [m]"),
+ IOP("nsubcdfm", HSM2_NSUBCDFM, IF_REAL, "constant part of Nsub for DFM [1/cm^3]"),
+ IOP("mphdfm", HSM2_MPHDFM, IF_REAL, "NSUBCDFM dependence of phonon scattering for DFM"),
+ IOP("m", HSM2_M, IF_REAL, "Multiplication factor [-]"),
+ /* Output Physical Values: */
+ OP ( "ids",   HSM2_CD,    IF_REAL   , "Ids"),  /* Drain-Source current */
+ OP ( "isub",  HSM2_ISUB,  IF_REAL   , "Isub"),  /* Substrate current */
+ OP ( "igidl", HSM2_IGIDL, IF_REAL   , "Igidl"), /* Gate-Induced Drain Leakage current */
+ OP ( "igisl", HSM2_IGISL, IF_REAL   , "Igisl"), /* Gate-Induced Source Leakage current */
+ OP ( "igd",   HSM2_IGD,   IF_REAL   , "Igd"),  /* Gate-Drain current */
+ OP ( "igs",   HSM2_IGS,   IF_REAL   , "Igs"),  /* Gate-Source current */
+ OP ( "igb",   HSM2_IGB,   IF_REAL   , "Igb"),  /* Gate-Substrate current */
+ OP ( "gm",    HSM2_GM,    IF_REAL   , "Gm"),   /* Transconductance */
+ OP ( "gds",   HSM2_GDS,   IF_REAL   , "Gds"),  /* Channel conductance */
+ OP ( "gmbs",  HSM2_GMBS,  IF_REAL   , "Gmbs"), /* Body effect (Back gate) transconductance */
+ OP ( "von",   HSM2_VON,   IF_REAL   , "Von"),  /* Threshold voltage */
+ OP ( "vdsat", HSM2_VDSAT, IF_REAL   , "Vdsat"), /* Saturation voltage */
+ OP ( "qb",    HSM2_QB,    IF_REAL   , "Qb"),   /* Bulk charge */
+ OP ( "qg",    HSM2_QG,    IF_REAL   , "Qg"),   /* Gate charge */
+ OP ( "qd",    HSM2_QD,    IF_REAL   , "Qd"),   /* Drain charge */
+ OP ( "cgg",   HSM2_CGG,   IF_REAL   , "Cgg"),  /* MOSFET capacitance */
+ OP ( "cgd",   HSM2_CGD,   IF_REAL   , "Cgd"),  /* MOSFET capacitance */
+ OP ( "cgs",   HSM2_CGS,   IF_REAL   , "Cgs"),  /* MOSFET capacitance */
+ OP ( "cbg",   HSM2_CBG,   IF_REAL   , "Cbg"),  /* MOSFET capacitance */
+ OP ( "cbs",   HSM2_CBSB,  IF_REAL   , "Cbs"),  /* MOSFET capacitance */
+ OP ( "cbd",   HSM2_CBDB,  IF_REAL   , "Cbd"),  /* MOSFET capacitance */
+ OP ( "cdg",   HSM2_CDG,   IF_REAL   , "Cdg"),  /* MOSFET capacitance */
+ OP ( "cdd",   HSM2_CDD,   IF_REAL   , "Cdd"),  /* MOSFET capacitance */
+ OP ( "cds",   HSM2_CDS,   IF_REAL   , "Cds"),  /* MOSFET capacitance */
+ OP ( "cgdo",  HSM2_CGDO,  IF_REAL   , "Cgdo"), /* MOSFET overlap capacitance */
+ OP ( "cgso",  HSM2_CGSO,  IF_REAL   , "Cgso"), /* MOSFET overlap capacitance */
+ OP ( "cgbo",  HSM2_CGBO,  IF_REAL   , "Cgbo"), /* MOSFET overlap capacitance */
+ OP ( "ibd",   HSM2_CBD,   IF_REAL   , "Ibd"),  /* Diode current */
+ OP ( "ibs",   HSM2_CBS,   IF_REAL   , "Ibs"),  /* Diode current */
+ OP ( "gbd",   HSM2_GBD,   IF_REAL   , "Gbd"),  /* Diode conductance */
+ OP ( "gbs",   HSM2_GBS,   IF_REAL   , "Gbs"),  /* Diode conductance */
+ OP ( "capbd", HSM2_CAPBD, IF_REAL   , "Capbd"), /* Diode capacitance */
+ OP ( "capbs", HSM2_CAPBS, IF_REAL   , "Capbs") /* Diode capacitance */
+};
+
+IFparm HSM2mPTable[] = { /* model parameters */
+  IP("nmos", HSM2_MOD_NMOS, IF_FLAG, ""),
+  IP("pmos", HSM2_MOD_PMOS, IF_FLAG, ""),
+  IOP("level", HSM2_MOD_LEVEL, IF_INTEGER, ""),
+  IOP("info", HSM2_MOD_INFO, IF_INTEGER, "information level (for debug, etc.)"),
+  IOP("noise", HSM2_MOD_NOISE, IF_INTEGER, "noise model selector"),
+  IOP("version", HSM2_MOD_VERSION, IF_INTEGER, "model version 220"),
+  IOP("show", HSM2_MOD_SHOW, IF_INTEGER, "show physical value"),
+  IOP("corsrd", HSM2_MOD_CORSRD, IF_INTEGER, "solve equations accounting Rs and Rd."),
+  IOP("corg", HSM2_MOD_CORG, IF_INTEGER, "solve equations accounting Rg."),
+  IOP("coiprv", HSM2_MOD_COIPRV, IF_INTEGER, "use ids_prv as initial guess of Ids (internal flag)"),
+  IOP("copprv", HSM2_MOD_COPPRV, IF_INTEGER, "use ps{0/l}_prv as initial guess of Ps{0/l} (internal flag)"),
+  IOP("coadov", HSM2_MOD_COADOV, IF_INTEGER, "add overlap to intrisic"),
+  IOP("coisub", HSM2_MOD_COISUB, IF_INTEGER, "calculate isub"),
+  IOP("coiigs", HSM2_MOD_COIIGS, IF_INTEGER, "calculate igate"),
+  IOP("cogidl", HSM2_MOD_COGIDL, IF_INTEGER, "calculate igidl"),
+  IOP("coovlp", HSM2_MOD_COOVLP, IF_INTEGER, "calculate overlap charge"),
+  IOP("coflick", HSM2_MOD_COFLICK, IF_INTEGER, "calculate 1/f noise"),
+  IOP("coisti", HSM2_MOD_COISTI, IF_INTEGER, "calculate STI"),
+  IOP("conqs", HSM2_MOD_CONQS, IF_INTEGER, "calculate in nqs mode or qs mode"),
+  IOP("corbnet", HSM2_MOD_CORBNET, IF_INTEGER, ""),
+  IOP("cothrml", HSM2_MOD_COTHRML, IF_INTEGER, "calculate thermal noise"),
+  IOP("coign", HSM2_MOD_COIGN, IF_INTEGER, "calculate induced gate noise"),
+  IOP("codfm", HSM2_MOD_CODFM, IF_INTEGER, "calculation of model for DFM"),
+  IOP("corecip", HSM2_MOD_CORECIP, IF_INTEGER, "capacitance reciprocity takes first priority"),
+  IOP("coqy", HSM2_MOD_COQY, IF_INTEGER, "calculate lateral-field-induced charge/capacitance"),
+  IOP("coqovsm", HSM2_MOD_COQOVSM, IF_INTEGER, "select smoothing method of Qover"),
+  IOP("vmax", HSM2_MOD_VMAX, IF_REAL, "saturation velocity [cm/s"),
+  IOP("bgtmp1", HSM2_MOD_BGTMP1, IF_REAL, "first order temp. coeff. for band gap [V/K]"),
+  IOP("bgtmp2", HSM2_MOD_BGTMP2, IF_REAL, "second order temp. coeff. for band gap [V/K^2]"),
+  IOP("eg0", HSM2_MOD_EG0, IF_REAL, ""),
+  IOP("tox", HSM2_MOD_TOX, IF_REAL, "oxide thickness [m]"),
+  IOP("xld", HSM2_MOD_XLD, IF_REAL, "lateral diffusion of S/D under the gate [m]"),
+  IOP("lover", HSM2_MOD_LOVER, IF_REAL, "overlap length"),
+  IOP("ddltmax", HSM2_MOD_DDLTMAX, IF_REAL, ""), /* Vdseff */
+  IOP("ddltslp", HSM2_MOD_DDLTSLP, IF_REAL, ""), /* Vdseff */
+  IOP("ddltict", HSM2_MOD_DDLTICT, IF_REAL, ""), /* Vdseff */
+  IOP("vfbover", HSM2_MOD_VFBOVER, IF_REAL, ""),
+  IOP("nover", HSM2_MOD_NOVER, IF_REAL, ""),
+  IOP("xwd", HSM2_MOD_XWD, IF_REAL, "lateral diffusion along the width dir. [m]"),
+  IOP("xl", HSM2_MOD_XL, IF_REAL, "gate length offset due to mask/etch effect [m]"),
+  IOP("xw", HSM2_MOD_XW, IF_REAL, "gate width offset due to mask/etch effect [m]"),
+  IOP("saref", HSM2_MOD_SAREF, IF_REAL, "reference distance from STI edge to Gate edge [m]"),
+  IOP("sbref", HSM2_MOD_SBREF, IF_REAL, "reference distance from STI edge to Gate edge [m]"),
+  IOP("ll", HSM2_MOD_LL, IF_REAL, "gate length parameter"),
+  IOP("lld", HSM2_MOD_LLD, IF_REAL, "gate length parameter"),
+  IOP("lln", HSM2_MOD_LLN, IF_REAL, "gate length parameter"),
+  IOP("wl", HSM2_MOD_WL, IF_REAL, "gate width parameter"),
+  IOP("wl1", HSM2_MOD_WL1, IF_REAL, "gate width parameter"),
+  IOP("wl1p", HSM2_MOD_WL1P, IF_REAL, "gate width parameter"),
+  IOP("wl2", HSM2_MOD_WL2, IF_REAL, "gate width parameter"),
+  IOP("wl2p", HSM2_MOD_WL2P, IF_REAL, "gate width parameter"),
+  IOP("wld", HSM2_MOD_WLD, IF_REAL, "gate width parameter"),
+  IOP("wln", HSM2_MOD_WLN, IF_REAL, "gate width parameter"),
+  IOP("xqy", HSM2_MOD_XQY, IF_REAL, "[m]"),
+  IOP("xqy1", HSM2_MOD_XQY1, IF_REAL, "[F m^{XQY2}]"),
+  IOP("xqy2", HSM2_MOD_XQY2, IF_REAL, "[-]"),
+  IOP("qyrat", HSM2_MOD_QYRAT, IF_REAL, ""),
+  IOP("rs", HSM2_MOD_RS, IF_REAL, "source contact resistance [ohm m]"),
+  IOP("rd", HSM2_MOD_RD, IF_REAL, "drain contact resistance  [ohm m]"),
+  IOP("rsh", HSM2_MOD_RSH, IF_REAL, "source/drain diffusion sheet  resistance  [ohm]"),
+  IOP("rshg", HSM2_MOD_RSHG, IF_REAL, "gate-elecrode sheet resistance"),
+/*   IOP("ngcon", HSM2_MOD_NGCON, IF_REAL, "number of gate contacts"), */
+/*   IOP("xgw", HSM2_MOD_XGW, IF_REAL, "distance from gate contact to channel edge"), */
+/*   IOP("xgl", HSM2_MOD_XGL, IF_REAL, "offset of gate length due to variation in patterning"), */
+/*   IOP("nf", HSM2_MOD_NF, IF_REAL, "number of fingers"), */
+  IOP("vfbc", HSM2_MOD_VFBC, IF_REAL, "constant part of Vfb [V]"),
+  IOP("vbi", HSM2_MOD_VBI, IF_REAL, "built-in potential [V]"),
+  IOP("nsubc", HSM2_MOD_NSUBC, IF_REAL, "constant part of Nsub [1/cm^3]"),
+  IOP("parl2", HSM2_MOD_PARL2, IF_REAL, "under diffusion [m]"),
+  IOP("lp", HSM2_MOD_LP, IF_REAL, "length of pocket potential [m]"),
+  IOP("nsubp", HSM2_MOD_NSUBP, IF_REAL, "[1/cm^3]"),
+  IOP("nsubpl", HSM2_MOD_NSUBPL, IF_REAL, "gate-length dependence of NSUBP"),
+  IOP("nsubpfac", HSM2_MOD_NSUBPFAC, IF_REAL, "gate-length dependence of NSUBP"),
+  IOP("nsubpw", HSM2_MOD_NSUBPW, IF_REAL, "pocket implant parameter"),
+  IOP("nsubpwp", HSM2_MOD_NSUBPWP, IF_REAL, "pocket implant parameter"),
+  IOP("scp1", HSM2_MOD_SCP1, IF_REAL, "parameter for pocket [-]"),
+  IOP("scp2", HSM2_MOD_SCP2, IF_REAL, "parameter for pocket [1/V]"),
+  IOP("scp3", HSM2_MOD_SCP3, IF_REAL, "parameter for pocket [m/V]"),
+  IOP("sc1", HSM2_MOD_SC1, IF_REAL, "parameter for SCE [-]"),
+  IOP("sc2", HSM2_MOD_SC2, IF_REAL, "parameter for SCE [1/V]"),
+  IOP("sc3", HSM2_MOD_SC3, IF_REAL, "parameter for SCE [m/V]"),
+  IOP("sc4", HSM2_MOD_SC4, IF_REAL, "parameter for SCE []"),
+  IOP("pgd1", HSM2_MOD_PGD1, IF_REAL, "parameter for gate-poly depletion [V]"),
+  IOP("pgd2", HSM2_MOD_PGD2, IF_REAL, "parameter for gate-poly depletion [V]"),
+//IOP("pgd3", HSM2_MOD_PGD3, IF_REAL, "parameter for gate-poly depletion [-]"), 
+  IOP("pgd4", HSM2_MOD_PGD4, IF_REAL, "parameter for gate-poly depletion [-]"),
+  IOP("ndep", HSM2_MOD_NDEP, IF_REAL, "coeff. of Qbm for Eeff [-]"),
+  IOP("ndepl", HSM2_MOD_NDEPL, IF_REAL, "coeff. of Qbm for Eeff [-]"),
+  IOP("ndeplp", HSM2_MOD_NDEPLP, IF_REAL, "coeff. of Qbm for Eeff [-]"),
+  IOP("ndepw", HSM2_MOD_NDEPW, IF_REAL, "coeff. of Qbm for Eeff [-]"),
+  IOP("ndepwp", HSM2_MOD_NDEPWP, IF_REAL, "coeff. of Qbm for Eeff [-]"),
+  IOP("ninv", HSM2_MOD_NINV, IF_REAL, "coeff. of Qnm for Eeff [-]"),
+  IOP("ninvd", HSM2_MOD_NINVD, IF_REAL, "modification of Vdse dependence on Eeff [1/V]"),
+  IOP("muecb0", HSM2_MOD_MUECB0, IF_REAL, "const. part of coulomb scattering [cm^2/Vs]"),
+  IOP("muecb1", HSM2_MOD_MUECB1, IF_REAL, "coeff. for coulomb scattering [cm^2/Vs]"),
+  IOP("mueph0", HSM2_MOD_MUEPH0, IF_REAL, "power of Eeff for phonon scattering [-]"),
+  IOP("mueph1", HSM2_MOD_MUEPH1, IF_REAL, ""),
+  IOP("muephw", HSM2_MOD_MUEPHW, IF_REAL, ""),
+  IOP("muepwp", HSM2_MOD_MUEPWP, IF_REAL, "phonon scattering parameter"),
+  IOP("muepwd", HSM2_MOD_MUEPWD, IF_REAL, "phonon scattering parameter"),
+  IOP("muephl", HSM2_MOD_MUEPHL, IF_REAL, "phonon scattering parameter"),
+  IOP("mueplp", HSM2_MOD_MUEPLP, IF_REAL, "phonon scattering parameter"),
+  IOP("muepld", HSM2_MOD_MUEPLD, IF_REAL, "phonon scattering parameter"),
+  IOP("muephs", HSM2_MOD_MUEPHS, IF_REAL, ""),
+  IOP("muepsp", HSM2_MOD_MUEPSP, IF_REAL, ""),
+  IOP("vtmp", HSM2_MOD_VTMP, IF_REAL, ""),
+  IOP("wvth0", HSM2_MOD_WVTH0, IF_REAL, ""),
+  IOP("muesr0", HSM2_MOD_MUESR0, IF_REAL, "power of Eeff for S.R. scattering [-]"),
+  IOP("muesr1", HSM2_MOD_MUESR1, IF_REAL, "coeff. for S.R. scattering [-]"),
+  IOP("muesrl", HSM2_MOD_MUESRL, IF_REAL, "surface roughness parameter"),
+  IOP("muesrw", HSM2_MOD_MUESRW, IF_REAL, "change of surface roughness related mobility"),
+  IOP("mueswp", HSM2_MOD_MUESWP, IF_REAL, "change of surface roughness related mobility"),
+  IOP("mueslp", HSM2_MOD_MUESLP, IF_REAL, "surface roughness parameter"),
+  IOP("muetmp", HSM2_MOD_MUETMP, IF_REAL, "parameter for mobility [-]"),
+  IOP("bb", HSM2_MOD_BB, IF_REAL, "empirical mobility model coefficient [-]"),
+  IOP("sub1", HSM2_MOD_SUB1, IF_REAL, "parameter for Isub [1/V]"),
+  IOP("sub2", HSM2_MOD_SUB2, IF_REAL, "parameter for Isub [V]"),
+  IOP("svgs", HSM2_MOD_SVGS, IF_REAL, "coefficient for Vg of Psislsat"),
+  IOP("svbs", HSM2_MOD_SVBS, IF_REAL, "coefficient for Vbs of Psislsat"),
+  IOP("svbsl", HSM2_MOD_SVBSL, IF_REAL, " "),
+  IOP("svds", HSM2_MOD_SVDS, IF_REAL, " "),
+  IOP("slg", HSM2_MOD_SLG, IF_REAL, " "),
+  IOP("sub1l", HSM2_MOD_SUB1L, IF_REAL, " "),
+  IOP("sub2l", HSM2_MOD_SUB2L, IF_REAL, " "),
+  IOP("svgsl", HSM2_MOD_SVGSL, IF_REAL, " "),
+  IOP("svgslp", HSM2_MOD_SVGSLP, IF_REAL, " "),
+  IOP("svgswp", HSM2_MOD_SVGSWP, IF_REAL, " "),
+  IOP("svgsw", HSM2_MOD_SVGSW, IF_REAL, " "),
+  IOP("svbslp", HSM2_MOD_SVBSLP, IF_REAL, " "),
+  IOP("slgl", HSM2_MOD_SLGL, IF_REAL, " "),
+  IOP("slglp", HSM2_MOD_SLGLP, IF_REAL, " "),
+  IOP("sub1lp", HSM2_MOD_SUB1LP, IF_REAL, " "),
+  IOP("nsti", HSM2_MOD_NSTI, IF_REAL, "parameter for STI [1/cm^3]"),
+  IOP("wsti", HSM2_MOD_WSTI, IF_REAL, "parameter for STI [m]"),
+  IOP("wstil", HSM2_MOD_WSTIL, IF_REAL, "parameter for STI [?]"),
+  IOP("wstilp", HSM2_MOD_WSTILP, IF_REAL, "parameter for STI [?]"),
+  IOP("wstiw", HSM2_MOD_WSTIW, IF_REAL, "parameter for STI [?]"),
+  IOP("wstiwp", HSM2_MOD_WSTIWP, IF_REAL, "parameter for STI [?]"),
+  IOP("scsti1", HSM2_MOD_SCSTI1, IF_REAL, "parameter for STI [-]"),
+  IOP("scsti2", HSM2_MOD_SCSTI2, IF_REAL, "parameter for STI [1/V]"),
+  IOP("vthsti", HSM2_MOD_VTHSTI, IF_REAL, "parameter for STI"),
+  IOP("vdsti", HSM2_MOD_VDSTI, IF_REAL, "parameter for STI [-]"),
+  IOP("muesti1", HSM2_MOD_MUESTI1, IF_REAL, "STI Stress mobility parameter"),
+  IOP("muesti2", HSM2_MOD_MUESTI2, IF_REAL, "STI Stress mobility parameter"),
+  IOP("muesti3", HSM2_MOD_MUESTI3, IF_REAL, "STI Stress mobility parameter"),
+  IOP("nsubpsti1", HSM2_MOD_NSUBPSTI1, IF_REAL, "STI Stress pocket impla parameter"),
+  IOP("nsubpsti2", HSM2_MOD_NSUBPSTI2, IF_REAL, "STI Stress pocket impla parameter"),
+  IOP("nsubpsti3", HSM2_MOD_NSUBPSTI3, IF_REAL, "STI Stress pocket impla parameter"),
+  IOP("lpext", HSM2_MOD_LPEXT, IF_REAL, "Pocket extension"),
+  IOP("npext", HSM2_MOD_NPEXT, IF_REAL, "Pocket extension"),
+  IOP("npextw", HSM2_MOD_NPEXTW, IF_REAL, "new model parameter NPEXTW"),
+  IOP("npextwp", HSM2_MOD_NPEXTWP, IF_REAL, "new model parameter NPEXTWP"),
+  IOP("scp22", HSM2_MOD_SCP22, IF_REAL, ""),
+  IOP("scp21", HSM2_MOD_SCP21, IF_REAL, ""),
+  IOP("bs1", HSM2_MOD_BS1, IF_REAL, ""),
+  IOP("bs2", HSM2_MOD_BS2, IF_REAL, ""),
+  IOP("cgso", HSM2_MOD_CGSO, IF_REAL, "G-S overlap capacitance per unit W [F/m]"),
+  IOP("cgdo", HSM2_MOD_CGDO, IF_REAL, "G-D overlap capacitance per unit W [F/m]"),
+  IOP("cgbo", HSM2_MOD_CGBO, IF_REAL, "G-B overlap capacitance per unit L [F/m]"),
+  IOP("tpoly", HSM2_MOD_TPOLY, IF_REAL, "hight of poly gate [m]"),
+  IOP("js0", HSM2_MOD_JS0, IF_REAL, "Saturation current density [A/m^2]"),
+  IOP("js0sw", HSM2_MOD_JS0SW, IF_REAL, "Side wall saturation current density [A/m]"),
+  IOP("nj", HSM2_MOD_NJ, IF_REAL, "Emission coefficient [-]"),
+  IOP("njsw", HSM2_MOD_NJSW, IF_REAL, "Sidewall emission coefficient"),
+  IOP("xti", HSM2_MOD_XTI, IF_REAL, "Junction current temparature exponent coefficient [-]"),
+  IOP("cj", HSM2_MOD_CJ, IF_REAL, "Bottom junction capacitance per unit area at zero bias [F/m^2]"),
+  IOP("cjsw", HSM2_MOD_CJSW, IF_REAL, "Source/drain sidewall junction capacitance grading coefficient per unit length at zero bias [F/m]"),
+  IOP("cjswg", HSM2_MOD_CJSWG, IF_REAL, "Source/drain gate sidewall junction capacitance per unit length at zero bias [F/m]"),
+  IOP("mj", HSM2_MOD_MJ, IF_REAL, "Bottom junction capacitance grading coefficient"),
+  IOP("mjsw", HSM2_MOD_MJSW, IF_REAL, "Source/drain sidewall junction capacitance grading coefficient"),
+  IOP("mjswg", HSM2_MOD_MJSWG, IF_REAL, "Source/drain gate sidewall junction capacitance grading coefficient"),
+  IOP("pb", HSM2_MOD_PB, IF_REAL, "Bottom junction build-in potential  [V]"),
+  IOP("pbsw", HSM2_MOD_PBSW, IF_REAL, "Source/drain sidewall junction build-in potential [V]"),
+  IOP("pbswg", HSM2_MOD_PBSWG, IF_REAL, "Source/drain gate sidewall junction build-in potential [V]"),
+
+  IOP("tcjbd", HSM2_MOD_TCJBD, IF_REAL, "Temperature dependence of czbd"),
+  IOP("tcjbs", HSM2_MOD_TCJBS, IF_REAL, "Temperature dependence of czbs"),
+  IOP("tcjbdsw", HSM2_MOD_TCJBDSW, IF_REAL, "Temperature dependence of czbdsw"),
+  IOP("tcjbssw", HSM2_MOD_TCJBSSW, IF_REAL, "Temperature dependence of czbssw"),
+  IOP("tcjbdswg", HSM2_MOD_TCJBDSWG, IF_REAL, "Temperature dependence of czbdswg"),
+  IOP("tcjbsswg", HSM2_MOD_TCJBSSWG, IF_REAL, "Temperature dependence of czbsswg"),
+
+  IOP("xti2", HSM2_MOD_XTI2, IF_REAL, " temperature coefficient [-]"),
+  IOP("cisb", HSM2_MOD_CISB, IF_REAL, " reverse bias saturation current [-]"),
+  IOP("cvb", HSM2_MOD_CVB, IF_REAL, " bias dependence coefficient of cisb [-]"),
+  IOP("ctemp", HSM2_MOD_CTEMP, IF_REAL, " temperature coefficient [-]"),
+  IOP("cisbk", HSM2_MOD_CISBK, IF_REAL, " reverse bias saturation current [A]"),
+  IOP("cvbk", HSM2_MOD_CVBK, IF_REAL, " bias dependence coefficient of cisb [-]"),
+  IOP("divx", HSM2_MOD_DIVX, IF_REAL, "  [1/V]"),
+
+  IOP("clm1", HSM2_MOD_CLM1, IF_REAL, "parameter for CLM [-]"),
+  IOP("clm2", HSM2_MOD_CLM2, IF_REAL, "parameter for CLM [1/m]"),
+  IOP("clm3", HSM2_MOD_CLM3, IF_REAL, "parameter for CLM [-]"),
+  IOP("clm5", HSM2_MOD_CLM5, IF_REAL, "parameter for CLM [-]"),
+  IOP("clm6", HSM2_MOD_CLM6, IF_REAL, "parameter for CLM [um^{-clm5}]"),
+  IOP("vover", HSM2_MOD_VOVER, IF_REAL, "parameter for overshoot [m^{voverp}]"),
+  IOP("voverp", HSM2_MOD_VOVERP, IF_REAL, "parameter for overshoot [-]"),
+  IOP("vovers", HSM2_MOD_VOVERS, IF_REAL, "parameter for overshoot [-]"),
+  IOP("voversp", HSM2_MOD_VOVERSP, IF_REAL, "parameter for overshoot [-]"),
+
+  IOP("wfc", HSM2_MOD_WFC, IF_REAL, "parameter for narrow channel effect [m*F/(cm^2)]"),
+  IOP("nsubcw", HSM2_MOD_NSUBCW, IF_REAL, "Parameter for narrow channel effect "),
+  IOP("nsubcwp", HSM2_MOD_NSUBCWP, IF_REAL, "Parameter for narrow channel effect "),
+  IOP("nsubcmax", HSM2_MOD_NSUBCMAX, IF_REAL, "Parameter for narrow channel effect "),
+  IOP("qme1", HSM2_MOD_QME1, IF_REAL, "parameter for quantum effect [mV]"),
+  IOP("qme2", HSM2_MOD_QME2, IF_REAL, "parameter for quantum effect [V]"),
+  IOP("qme3", HSM2_MOD_QME3, IF_REAL, "parameter for quantum effect [m]"),
+  IOP("gidl1", HSM2_MOD_GIDL1, IF_REAL, "parameter for GIDL [?]"),
+  IOP("gidl2", HSM2_MOD_GIDL2, IF_REAL, "parameter for GIDL [?]"),
+  IOP("gidl3", HSM2_MOD_GIDL3, IF_REAL, "parameter for GIDL [?]"),
+  IOP("gidl4", HSM2_MOD_GIDL4, IF_REAL, "parameter for GIDL [?]"),
+  IOP("gidl5", HSM2_MOD_GIDL5, IF_REAL, "parameter for GIDL [?]"),
+  IOP("gleak1", HSM2_MOD_GLEAK1, IF_REAL, "parameter for gate current [A*V^(-3/2)/C]"),
+  IOP("gleak2", HSM2_MOD_GLEAK2, IF_REAL, "parameter for gate current [V^(-1/2)/m ]"),
+  IOP("gleak3", HSM2_MOD_GLEAK3, IF_REAL, "parameter for gate current [-]"),
+  IOP("gleak4", HSM2_MOD_GLEAK4, IF_REAL, "parameter for gate current [1/m]"),
+  IOP("gleak5", HSM2_MOD_GLEAK5, IF_REAL, "parameter for gate current [V/m]"),
+  IOP("gleak6", HSM2_MOD_GLEAK6, IF_REAL, "parameter for gate current [V]"),
+  IOP("gleak7", HSM2_MOD_GLEAK7, IF_REAL, "parameter for gate current [m^2]"),
+  IOP("glksd1", HSM2_MOD_GLKSD1, IF_REAL, "parameter for gate current [A*m/V^2]"),
+  IOP("glksd2", HSM2_MOD_GLKSD2, IF_REAL, "parameter for gate current [1/(V*m)]"),
+  IOP("glksd3", HSM2_MOD_GLKSD3, IF_REAL, "parameter for gate current [1/m]"),
+  IOP("glkb1", HSM2_MOD_GLKB1, IF_REAL, "parameter for gate current [A/V^2]"),
+  IOP("glkb2", HSM2_MOD_GLKB2, IF_REAL, "parameter for gate current [m/V]"),
+  IOP("glkb3", HSM2_MOD_GLKB3, IF_REAL, "parameter for gate current [V]"),
+  IOP("egig", HSM2_MOD_EGIG, IF_REAL, "parameter for gate current [V]"),
+  IOP("igtemp2", HSM2_MOD_IGTEMP2, IF_REAL, "parameter for gate current [V*k]"),
+  IOP("igtemp3", HSM2_MOD_IGTEMP3, IF_REAL, "parameter for gate current [V*k^2]"),
+  IOP("vzadd0", HSM2_MOD_VZADD0, IF_REAL, "Vzadd at Vds=0  [V]"),
+  IOP("pzadd0", HSM2_MOD_PZADD0, IF_REAL, "Pzadd at Vds=0  [V]"),
+  IOP("nftrp", HSM2_MOD_NFTRP, IF_REAL, ""),
+  IOP("nfalp", HSM2_MOD_NFALP, IF_REAL, ""),
+  IOP("falph", HSM2_MOD_FALPH, IF_REAL, "parameter for 1/f noise"),
+  IOP("cit", HSM2_MOD_CIT, IF_REAL, ""),
+  IOP("kappa", HSM2_MOD_KAPPA, IF_REAL, "dielectric constant for high-k stacked gate"),
+  IOP("vdiffj", HSM2_MOD_VDIFFJ, IF_REAL, "threshold voltage for S/D junction diode [V]"),
+  IOP("dly1", HSM2_MOD_DLY1, IF_REAL, "parameter for transit time [-]"),
+  IOP("dly2", HSM2_MOD_DLY2, IF_REAL, "parameter for transit time [-]"),
+  IOP("dly3", HSM2_MOD_DLY3, IF_REAL, "parameter for trandforming bulk charge [s/F]"),
+  IOP("tnom", HSM2_MOD_TNOM, IF_REAL, "nominal temperature [K]"),
+  IOP("ovslp", HSM2_MOD_OVSLP, IF_REAL, ""),
+  IOP("ovmag", HSM2_MOD_OVMAG, IF_REAL, ""),
+
+  IOP("gbmin", HSM2_MOD_GBMIN, IF_REAL, ""),
+  IOP("rbpb", HSM2_MOD_RBPB, IF_REAL, ""),
+  IOP("rbpd", HSM2_MOD_RBPD, IF_REAL, ""),
+  IOP("rbps", HSM2_MOD_RBPS, IF_REAL, ""),
+  IOP("rbdb", HSM2_MOD_RBDB, IF_REAL, ""),
+  IOP("rbsb", HSM2_MOD_RBSB, IF_REAL, ""),
+
+  IOP("ibpc1", HSM2_MOD_IBPC1, IF_REAL, "parameter for Impact-Ionization Induced Bulk Potential Change"),
+  IOP("ibpc2", HSM2_MOD_IBPC2, IF_REAL, "parameter for Impact-Ionization Induced Bulk Potential Change"),
+
+  IOP("mphdfm", HSM2_MOD_MPHDFM, IF_REAL, "NSUBCDFM dependence of phonon scattering for DFM"),
+
+
+  IOP("ptl", HSM2_MOD_PTL, IF_REAL, ""),
+  IOP("ptp", HSM2_MOD_PTP, IF_REAL, ""),
+  IOP("pt2", HSM2_MOD_PT2, IF_REAL, ""),
+  IOP("ptlp", HSM2_MOD_PTLP, IF_REAL, ""),
+  IOP("gdl", HSM2_MOD_GDL, IF_REAL, ""),
+  IOP("gdlp", HSM2_MOD_GDLP, IF_REAL, ""),
+
+  IOP("gdld", HSM2_MOD_GDLD, IF_REAL, ""),
+  IOP("pt4", HSM2_MOD_PT4, IF_REAL, ""),
+  IOP("pt4p", HSM2_MOD_PT4P, IF_REAL, ""),
+  IOP("muephl2", HSM2_MOD_MUEPHL2, IF_REAL, ""),
+  IOP("mueplp2", HSM2_MOD_MUEPLP2, IF_REAL, ""),
+  IOP("nsubcw2", HSM2_MOD_NSUBCW2, IF_REAL, ""),
+  IOP("nsubcwp2", HSM2_MOD_NSUBCWP2, IF_REAL, ""),
+  IOP("muephw2", HSM2_MOD_MUEPHW2, IF_REAL, ""),
+  IOP("muepwp2", HSM2_MOD_MUEPWP2, IF_REAL, ""),
+
+  IOP("vgsmin", HSM2_MOD_VGSMIN, IF_REAL, "minimal/maximal expected Vgs (NMOS/PMOS) [V]"),
+  IOP("sc3vbs", HSM2_MOD_SC3VBS, IF_REAL, "Vbs value for clamping sc3 [V]"),
+  IOP("byptol", HSM2_MOD_BYPTOL, IF_REAL, "BYP_TOL_FACTOR for bypass control"),
+  IOP("muecb0lp", HSM2_MOD_MUECB0LP, IF_REAL, "L dependence of MUECB0"),
+  IOP("muecb1lp", HSM2_MOD_MUECB1LP, IF_REAL, "L dependence of MUECB1"),
+
+
+  /* binning parameters */
+  IOP("lmin", HSM2_MOD_LMIN, IF_REAL, "Minimum length for the model"),
+  IOP("lmax", HSM2_MOD_LMAX, IF_REAL, "Maximum length for the model"),
+  IOP("wmin", HSM2_MOD_WMIN, IF_REAL, "Minimum width for the model"),
+  IOP("wmax", HSM2_MOD_WMAX, IF_REAL, "Maximum width for the model"),
+  IOP("lbinn", HSM2_MOD_LBINN, IF_REAL, "L modulation coefficient for binning"),
+  IOP("wbinn", HSM2_MOD_WBINN, IF_REAL, "W modulation coefficient for binning"),
+
+  /* Length dependence */
+  IOP("lvmax", HSM2_MOD_LVMAX, IF_REAL, "Length dependence of vmax"),
+  IOP("lbgtmp1", HSM2_MOD_LBGTMP1, IF_REAL, "Length dependence of bgtmp1"),
+  IOP("lbgtmp2", HSM2_MOD_LBGTMP2, IF_REAL, "Length dependence of bgtmp2"),
+  IOP("leg0", HSM2_MOD_LEG0, IF_REAL, "Length dependence of eg0"),
+  IOP("llover", HSM2_MOD_LLOVER, IF_REAL, "Length dependence of lover"),
+  IOP("lvfbover", HSM2_MOD_LVFBOVER, IF_REAL, "Length dependence of vfbover"),
+  IOP("lnover", HSM2_MOD_LNOVER, IF_REAL, "Length dependence of nover"),
+  IOP("lwl2", HSM2_MOD_LWL2, IF_REAL, "Length dependence of wl2"),
+  IOP("lvfbc", HSM2_MOD_LVFBC, IF_REAL, "Length dependence of vfbc"),
+  IOP("lnsubc", HSM2_MOD_LNSUBC, IF_REAL, "Length dependence of nsubc"),
+  IOP("lnsubp", HSM2_MOD_LNSUBP, IF_REAL, "Length dependence of nsubp"),
+  IOP("lscp1", HSM2_MOD_LSCP1, IF_REAL, "Length dependence of scp1"),
+  IOP("lscp2", HSM2_MOD_LSCP2, IF_REAL, "Length dependence of scp2"),
+  IOP("lscp3", HSM2_MOD_LSCP3, IF_REAL, "Length dependence of scp3"),
+  IOP("lsc1", HSM2_MOD_LSC1, IF_REAL, "Length dependence of sc1"),
+  IOP("lsc2", HSM2_MOD_LSC2, IF_REAL, "Length dependence of sc2"),
+  IOP("lsc3", HSM2_MOD_LSC3, IF_REAL, "Length dependence of sc3"),
+  IOP("lsc4", HSM2_MOD_LSC4, IF_REAL, "Length dependence of sc4"),
+  IOP("lpgd1", HSM2_MOD_LPGD1, IF_REAL, "Length dependence of pgd1"),
+//IOP("lpgd3", HSM2_MOD_LPGD3, IF_REAL, "Length dependence of pgd3"),
+  IOP("lndep", HSM2_MOD_LNDEP, IF_REAL, "Length dependence of ndep"),
+  IOP("lninv", HSM2_MOD_LNINV, IF_REAL, "Length dependence of ninv"),
+  IOP("lmuecb0", HSM2_MOD_LMUECB0, IF_REAL, "Length dependence of muecb0"),
+  IOP("lmuecb1", HSM2_MOD_LMUECB1, IF_REAL, "Length dependence of muecb1"),
+  IOP("lmueph1", HSM2_MOD_LMUEPH1, IF_REAL, "Length dependence of mueph1"),
+  IOP("lvtmp", HSM2_MOD_LVTMP, IF_REAL, "Length dependence of vtmp"),
+  IOP("lwvth0", HSM2_MOD_LWVTH0, IF_REAL, "Length dependence of wvth0"),
+  IOP("lmuesr1", HSM2_MOD_LMUESR1, IF_REAL, "Length dependence of muesr1"),
+  IOP("lmuetmp", HSM2_MOD_LMUETMP, IF_REAL, "Length dependence of muetmp"),
+  IOP("lsub1", HSM2_MOD_LSUB1, IF_REAL, "Length dependence of sub1"),
+  IOP("lsub2", HSM2_MOD_LSUB2, IF_REAL, "Length dependence of sub2"),
+  IOP("lsvds", HSM2_MOD_LSVDS, IF_REAL, "Length dependence of svds"),
+  IOP("lsvbs", HSM2_MOD_LSVBS, IF_REAL, "Length dependence of svbs"),
+  IOP("lsvgs", HSM2_MOD_LSVGS, IF_REAL, "Length dependence of svgs"),
+  IOP("lnsti", HSM2_MOD_LNSTI, IF_REAL, "Length dependence of nsti"),
+  IOP("lwsti", HSM2_MOD_LWSTI, IF_REAL, "Length dependence of wsti"),
+  IOP("lscsti1", HSM2_MOD_LSCSTI1, IF_REAL, "Length dependence of scsti1"),
+  IOP("lscsti2", HSM2_MOD_LSCSTI2, IF_REAL, "Length dependence of scsti2"),
+  IOP("lvthsti", HSM2_MOD_LVTHSTI, IF_REAL, "Length dependence of vthsti"),
+  IOP("lmuesti1", HSM2_MOD_LMUESTI1, IF_REAL, "Length dependence of muesti1"),
+  IOP("lmuesti2", HSM2_MOD_LMUESTI2, IF_REAL, "Length dependence of muesti2"),
+  IOP("lmuesti3", HSM2_MOD_LMUESTI3, IF_REAL, "Length dependence of muesti3"),
+  IOP("lnsubpsti1", HSM2_MOD_LNSUBPSTI1, IF_REAL, "Length dependence of nsubpsti1"),
+  IOP("lnsubpsti2", HSM2_MOD_LNSUBPSTI2, IF_REAL, "Length dependence of nsubpsti2"),
+  IOP("lnsubpsti3", HSM2_MOD_LNSUBPSTI3, IF_REAL, "Length dependence of nsubpsti3"),
+  IOP("lcgso", HSM2_MOD_LCGSO, IF_REAL, "Length dependence of cgso"),
+  IOP("lcgdo", HSM2_MOD_LCGDO, IF_REAL, "Length dependence of cgdo"),
+  IOP("ljs0", HSM2_MOD_LJS0, IF_REAL, "Length dependence of js0"),
+  IOP("ljs0sw", HSM2_MOD_LJS0SW, IF_REAL, "Length dependence of js0sw"),
+  IOP("lnj", HSM2_MOD_LNJ, IF_REAL, "Length dependence of nj"),
+  IOP("lcisbk", HSM2_MOD_LCISBK, IF_REAL, "Length dependence of cisbk"),
+  IOP("lclm1", HSM2_MOD_LCLM1, IF_REAL, "Length dependence of clm1"),
+  IOP("lclm2", HSM2_MOD_LCLM2, IF_REAL, "Length dependence of clm2"),
+  IOP("lclm3", HSM2_MOD_LCLM3, IF_REAL, "Length dependence of clm3"),
+  IOP("lwfc", HSM2_MOD_LWFC, IF_REAL, "Length dependence of wfc"),
+  IOP("lgidl1", HSM2_MOD_LGIDL1, IF_REAL, "Length dependence of gidl1"),
+  IOP("lgidl2", HSM2_MOD_LGIDL2, IF_REAL, "Length dependence of gidl2"),
+  IOP("lgleak1", HSM2_MOD_LGLEAK1, IF_REAL, "Length dependence of gleak1"),
+  IOP("lgleak2", HSM2_MOD_LGLEAK2, IF_REAL, "Length dependence of gleak2"),
+  IOP("lgleak3", HSM2_MOD_LGLEAK3, IF_REAL, "Length dependence of gleak3"),
+  IOP("lgleak6", HSM2_MOD_LGLEAK6, IF_REAL, "Length dependence of gleak6"),
+  IOP("lglksd1", HSM2_MOD_LGLKSD1, IF_REAL, "Length dependence of glksd1"),
+  IOP("lglksd2", HSM2_MOD_LGLKSD2, IF_REAL, "Length dependence of glksd2"),
+  IOP("lglkb1", HSM2_MOD_LGLKB1, IF_REAL, "Length dependence of glkb1"),
+  IOP("lglkb2", HSM2_MOD_LGLKB2, IF_REAL, "Length dependence of glkb2"),
+  IOP("lnftrp", HSM2_MOD_LNFTRP, IF_REAL, "Length dependence of nftrp"),
+  IOP("lnfalp", HSM2_MOD_LNFALP, IF_REAL, "Length dependence of nfalp"),
+  IOP("lvdiffj", HSM2_MOD_LVDIFFJ, IF_REAL, "Length dependence of vdiffj"),
+  IOP("libpc1", HSM2_MOD_LIBPC1, IF_REAL, "Length dependence of ibpc1"),
+  IOP("libpc2", HSM2_MOD_LIBPC2, IF_REAL, "Length dependence of ibpc2"),
+
+  /* Width dependence */
+  IOP("wvmax", HSM2_MOD_WVMAX, IF_REAL, "Width dependence of vmax"),
+  IOP("wbgtmp1", HSM2_MOD_WBGTMP1, IF_REAL, "Width dependence of bgtmp1"),
+  IOP("wbgtmp2", HSM2_MOD_WBGTMP2, IF_REAL, "Width dependence of bgtmp2"),
+  IOP("weg0", HSM2_MOD_WEG0, IF_REAL, "Width dependence of eg0"),
+  IOP("wlover", HSM2_MOD_WLOVER, IF_REAL, "Width dependence of lover"),
+  IOP("wvfbover", HSM2_MOD_WVFBOVER, IF_REAL, "Width dependence of vfbover"),
+  IOP("wnover", HSM2_MOD_WNOVER, IF_REAL, "Width dependence of nover"),
+  IOP("wwl2", HSM2_MOD_WWL2, IF_REAL, "Width dependence of wl2"),
+  IOP("wvfbc", HSM2_MOD_WVFBC, IF_REAL, "Width dependence of vfbc"),
+  IOP("wnsubc", HSM2_MOD_WNSUBC, IF_REAL, "Width dependence of nsubc"),
+  IOP("wnsubp", HSM2_MOD_WNSUBP, IF_REAL, "Width dependence of nsubp"),
+  IOP("wscp1", HSM2_MOD_WSCP1, IF_REAL, "Width dependence of scp1"),
+  IOP("wscp2", HSM2_MOD_WSCP2, IF_REAL, "Width dependence of scp2"),
+  IOP("wscp3", HSM2_MOD_WSCP3, IF_REAL, "Width dependence of scp3"),
+  IOP("wsc1", HSM2_MOD_WSC1, IF_REAL, "Width dependence of sc1"),
+  IOP("wsc2", HSM2_MOD_WSC2, IF_REAL, "Width dependence of sc2"),
+  IOP("wsc3", HSM2_MOD_WSC3, IF_REAL, "Width dependence of sc3"),
+  IOP("wsc4", HSM2_MOD_WSC4, IF_REAL, "Width dependence of sc4"),
+  IOP("wpgd1", HSM2_MOD_WPGD1, IF_REAL, "Width dependence of pgd1"),
+//IOP("wpgd3", HSM2_MOD_WPGD3, IF_REAL, "Width dependence of pgd3"),
+  IOP("wndep", HSM2_MOD_WNDEP, IF_REAL, "Width dependence of ndep"),
+  IOP("wninv", HSM2_MOD_WNINV, IF_REAL, "Width dependence of ninv"),
+  IOP("wmuecb0", HSM2_MOD_WMUECB0, IF_REAL, "Width dependence of muecb0"),
+  IOP("wmuecb1", HSM2_MOD_WMUECB1, IF_REAL, "Width dependence of muecb1"),
+  IOP("wmueph1", HSM2_MOD_WMUEPH1, IF_REAL, "Width dependence of mueph1"),
+  IOP("wvtmp", HSM2_MOD_WVTMP, IF_REAL, "Width dependence of vtmp"),
+  IOP("wwvth0", HSM2_MOD_WWVTH0, IF_REAL, "Width dependence of wvth0"),
+  IOP("wmuesr1", HSM2_MOD_WMUESR1, IF_REAL, "Width dependence of muesr1"),
+  IOP("wmuetmp", HSM2_MOD_WMUETMP, IF_REAL, "Width dependence of muetmp"),
+  IOP("wsub1", HSM2_MOD_WSUB1, IF_REAL, "Width dependence of sub1"),
+  IOP("wsub2", HSM2_MOD_WSUB2, IF_REAL, "Width dependence of sub2"),
+  IOP("wsvds", HSM2_MOD_WSVDS, IF_REAL, "Width dependence of svds"),
+  IOP("wsvbs", HSM2_MOD_WSVBS, IF_REAL, "Width dependence of svbs"),
+  IOP("wsvgs", HSM2_MOD_WSVGS, IF_REAL, "Width dependence of svgs"),
+  IOP("wnsti", HSM2_MOD_WNSTI, IF_REAL, "Width dependence of nsti"),
+  IOP("wwsti", HSM2_MOD_WWSTI, IF_REAL, "Width dependence of wsti"),
+  IOP("wscsti1", HSM2_MOD_WSCSTI1, IF_REAL, "Width dependence of scsti1"),
+  IOP("wscsti2", HSM2_MOD_WSCSTI2, IF_REAL, "Width dependence of scsti2"),
+  IOP("wvthsti", HSM2_MOD_WVTHSTI, IF_REAL, "Width dependence of vthsti"),
+  IOP("wmuesti1", HSM2_MOD_WMUESTI1, IF_REAL, "Width dependence of muesti1"),
+  IOP("wmuesti2", HSM2_MOD_WMUESTI2, IF_REAL, "Width dependence of muesti2"),
+  IOP("wmuesti3", HSM2_MOD_WMUESTI3, IF_REAL, "Width dependence of muesti3"),
+  IOP("wnsubpsti1", HSM2_MOD_WNSUBPSTI1, IF_REAL, "Width dependence of nsubpsti1"),
+  IOP("wnsubpsti2", HSM2_MOD_WNSUBPSTI2, IF_REAL, "Width dependence of nsubpsti2"),
+  IOP("wnsubpsti3", HSM2_MOD_WNSUBPSTI3, IF_REAL, "Width dependence of nsubpsti3"),
+  IOP("wcgso", HSM2_MOD_WCGSO, IF_REAL, "Width dependence of cgso"),
+  IOP("wcgdo", HSM2_MOD_WCGDO, IF_REAL, "Width dependence of cgdo"),
+  IOP("wjs0", HSM2_MOD_WJS0, IF_REAL, "Width dependence of js0"),
+  IOP("wjs0sw", HSM2_MOD_WJS0SW, IF_REAL, "Width dependence of js0sw"),
+  IOP("wnj", HSM2_MOD_WNJ, IF_REAL, "Width dependence of nj"),
+  IOP("wcisbk", HSM2_MOD_WCISBK, IF_REAL, "Width dependence of cisbk"),
+  IOP("wclm1", HSM2_MOD_WCLM1, IF_REAL, "Width dependence of clm1"),
+  IOP("wclm2", HSM2_MOD_WCLM2, IF_REAL, "Width dependence of clm2"),
+  IOP("wclm3", HSM2_MOD_WCLM3, IF_REAL, "Width dependence of clm3"),
+  IOP("wwfc", HSM2_MOD_WWFC, IF_REAL, "Width dependence of wfc"),
+  IOP("wgidl1", HSM2_MOD_WGIDL1, IF_REAL, "Width dependence of gidl1"),
+  IOP("wgidl2", HSM2_MOD_WGIDL2, IF_REAL, "Width dependence of gidl2"),
+  IOP("wgleak1", HSM2_MOD_WGLEAK1, IF_REAL, "Width dependence of gleak1"),
+  IOP("wgleak2", HSM2_MOD_WGLEAK2, IF_REAL, "Width dependence of gleak2"),
+  IOP("wgleak3", HSM2_MOD_WGLEAK3, IF_REAL, "Width dependence of gleak3"),
+  IOP("wgleak6", HSM2_MOD_WGLEAK6, IF_REAL, "Width dependence of gleak6"),
+  IOP("wglksd1", HSM2_MOD_WGLKSD1, IF_REAL, "Width dependence of glksd1"),
+  IOP("wglksd2", HSM2_MOD_WGLKSD2, IF_REAL, "Width dependence of glksd2"),
+  IOP("wglkb1", HSM2_MOD_WGLKB1, IF_REAL, "Width dependence of glkb1"),
+  IOP("wglkb2", HSM2_MOD_WGLKB2, IF_REAL, "Width dependence of glkb2"),
+  IOP("wnftrp", HSM2_MOD_WNFTRP, IF_REAL, "Width dependence of nftrp"),
+  IOP("wnfalp", HSM2_MOD_WNFALP, IF_REAL, "Width dependence of nfalp"),
+  IOP("wvdiffj", HSM2_MOD_WVDIFFJ, IF_REAL, "Width dependence of vdiffj"),
+  IOP("wibpc1", HSM2_MOD_WIBPC1, IF_REAL, "Width dependence of ibpc1"),
+  IOP("wibpc2", HSM2_MOD_WIBPC2, IF_REAL, "Width dependence of ibpc2"),
+
+  /* Cross-term dependence */
+  IOP("pvmax", HSM2_MOD_PVMAX, IF_REAL, "Cross-term dependence of vmax"),
+  IOP("pbgtmp1", HSM2_MOD_PBGTMP1, IF_REAL, "Cross-term dependence of bgtmp1"),
+  IOP("pbgtmp2", HSM2_MOD_PBGTMP2, IF_REAL, "Cross-term dependence of bgtmp2"),
+  IOP("peg0", HSM2_MOD_PEG0, IF_REAL, "Cross-term dependence of eg0"),
+  IOP("plover", HSM2_MOD_PLOVER, IF_REAL, "Cross-term dependence of lover"),
+  IOP("pvfbover", HSM2_MOD_PVFBOVER, IF_REAL, "Cross-term dependence of vfbover"),
+  IOP("pnover", HSM2_MOD_PNOVER, IF_REAL, "Cross-term dependence of nover"),
+  IOP("pwl2", HSM2_MOD_PWL2, IF_REAL, "Cross-term dependence of wl2"),
+  IOP("pvfbc", HSM2_MOD_PVFBC, IF_REAL, "Cross-term dependence of vfbc"),
+  IOP("pnsubc", HSM2_MOD_PNSUBC, IF_REAL, "Cross-term dependence of nsubc"),
+  IOP("pnsubp", HSM2_MOD_PNSUBP, IF_REAL, "Cross-term dependence of nsubp"),
+  IOP("pscp1", HSM2_MOD_PSCP1, IF_REAL, "Cross-term dependence of scp1"),
+  IOP("pscp2", HSM2_MOD_PSCP2, IF_REAL, "Cross-term dependence of scp2"),
+  IOP("pscp3", HSM2_MOD_PSCP3, IF_REAL, "Cross-term dependence of scp3"),
+  IOP("psc1", HSM2_MOD_PSC1, IF_REAL, "Cross-term dependence of sc1"),
+  IOP("psc2", HSM2_MOD_PSC2, IF_REAL, "Cross-term dependence of sc2"),
+  IOP("psc3", HSM2_MOD_PSC3, IF_REAL, "Cross-term dependence of sc3"),
+  IOP("psc4", HSM2_MOD_PSC4, IF_REAL, "Cross-term dependence of sc4"),
+  IOP("ppgd1", HSM2_MOD_PPGD1, IF_REAL, "Cross-term dependence of pgd1"),
+//IOP("ppgd3", HSM2_MOD_PPGD3, IF_REAL, "Cross-term dependence of pgd3"),
+  IOP("pndep", HSM2_MOD_PNDEP, IF_REAL, "Cross-term dependence of ndep"),
+  IOP("pninv", HSM2_MOD_PNINV, IF_REAL, "Cross-term dependence of ninv"),
+  IOP("pmuecb0", HSM2_MOD_PMUECB0, IF_REAL, "Cross-term dependence of muecb0"),
+  IOP("pmuecb1", HSM2_MOD_PMUECB1, IF_REAL, "Cross-term dependence of muecb1"),
+  IOP("pmueph1", HSM2_MOD_PMUEPH1, IF_REAL, "Cross-term dependence of mueph1"),
+  IOP("pvtmp", HSM2_MOD_PVTMP, IF_REAL, "Cross-term dependence of vtmp"),
+  IOP("pwvth0", HSM2_MOD_PWVTH0, IF_REAL, "Cross-term dependence of wvth0"),
+  IOP("pmuesr1", HSM2_MOD_PMUESR1, IF_REAL, "Cross-term dependence of muesr1"),
+  IOP("pmuetmp", HSM2_MOD_PMUETMP, IF_REAL, "Cross-term dependence of muetmp"),
+  IOP("psub1", HSM2_MOD_PSUB1, IF_REAL, "Cross-term dependence of sub1"),
+  IOP("psub2", HSM2_MOD_PSUB2, IF_REAL, "Cross-term dependence of sub2"),
+  IOP("psvds", HSM2_MOD_PSVDS, IF_REAL, "Cross-term dependence of svds"),
+  IOP("psvbs", HSM2_MOD_PSVBS, IF_REAL, "Cross-term dependence of svbs"),
+  IOP("psvgs", HSM2_MOD_PSVGS, IF_REAL, "Cross-term dependence of svgs"),
+  IOP("pnsti", HSM2_MOD_PNSTI, IF_REAL, "Cross-term dependence of nsti"),
+  IOP("pwsti", HSM2_MOD_PWSTI, IF_REAL, "Cross-term dependence of wsti"),
+  IOP("pscsti1", HSM2_MOD_PSCSTI1, IF_REAL, "Cross-term dependence of scsti1"),
+  IOP("pscsti2", HSM2_MOD_PSCSTI2, IF_REAL, "Cross-term dependence of scsti2"),
+  IOP("pvthsti", HSM2_MOD_PVTHSTI, IF_REAL, "Cross-term dependence of vthsti"),
+  IOP("pmuesti1", HSM2_MOD_PMUESTI1, IF_REAL, "Cross-term dependence of muesti1"),
+  IOP("pmuesti2", HSM2_MOD_PMUESTI2, IF_REAL, "Cross-term dependence of muesti2"),
+  IOP("pmuesti3", HSM2_MOD_PMUESTI3, IF_REAL, "Cross-term dependence of muesti3"),
+  IOP("pnsubpsti1", HSM2_MOD_PNSUBPSTI1, IF_REAL, "Cross-term dependence of nsubpsti1"),
+  IOP("pnsubpsti2", HSM2_MOD_PNSUBPSTI2, IF_REAL, "Cross-term dependence of nsubpsti2"),
+  IOP("pnsubpsti3", HSM2_MOD_PNSUBPSTI3, IF_REAL, "Cross-term dependence of nsubpsti3"),
+  IOP("pcgso", HSM2_MOD_PCGSO, IF_REAL, "Cross-term dependence of cgso"),
+  IOP("pcgdo", HSM2_MOD_PCGDO, IF_REAL, "Cross-term dependence of cgdo"),
+  IOP("pjs0", HSM2_MOD_PJS0, IF_REAL, "Cross-term dependence of js0"),
+  IOP("pjs0sw", HSM2_MOD_PJS0SW, IF_REAL, "Cross-term dependence of js0sw"),
+  IOP("pnj", HSM2_MOD_PNJ, IF_REAL, "Cross-term dependence of nj"),
+  IOP("pcisbk", HSM2_MOD_PCISBK, IF_REAL, "Cross-term dependence of cisbk"),
+  IOP("pclm1", HSM2_MOD_PCLM1, IF_REAL, "Cross-term dependence of clm1"),
+  IOP("pclm2", HSM2_MOD_PCLM2, IF_REAL, "Cross-term dependence of clm2"),
+  IOP("pclm3", HSM2_MOD_PCLM3, IF_REAL, "Cross-term dependence of clm3"),
+  IOP("pwfc", HSM2_MOD_PWFC, IF_REAL, "Cross-term dependence of wfc"),
+  IOP("pgidl1", HSM2_MOD_PGIDL1, IF_REAL, "Cross-term dependence of gidl1"),
+  IOP("pgidl2", HSM2_MOD_PGIDL2, IF_REAL, "Cross-term dependence of gidl2"),
+  IOP("pgleak1", HSM2_MOD_PGLEAK1, IF_REAL, "Cross-term dependence of gleak1"),
+  IOP("pgleak2", HSM2_MOD_PGLEAK2, IF_REAL, "Cross-term dependence of gleak2"),
+  IOP("pgleak3", HSM2_MOD_PGLEAK3, IF_REAL, "Cross-term dependence of gleak3"),
+  IOP("pgleak6", HSM2_MOD_PGLEAK6, IF_REAL, "Cross-term dependence of gleak6"),
+  IOP("pglksd1", HSM2_MOD_PGLKSD1, IF_REAL, "Cross-term dependence of glksd1"),
+  IOP("pglksd2", HSM2_MOD_PGLKSD2, IF_REAL, "Cross-term dependence of glksd2"),
+  IOP("pglkb1", HSM2_MOD_PGLKB1, IF_REAL, "Cross-term dependence of glkb1"),
+  IOP("pglkb2", HSM2_MOD_PGLKB2, IF_REAL, "Cross-term dependence of glkb2"),
+  IOP("pnftrp", HSM2_MOD_PNFTRP, IF_REAL, "Cross-term dependence of nftrp"),
+  IOP("pnfalp", HSM2_MOD_PNFALP, IF_REAL, "Cross-term dependence of nfalp"),
+  IOP("pvdiffj", HSM2_MOD_PVDIFFJ, IF_REAL, "Cross-term dependence of vdiffj"),
+  IOP("pibpc1", HSM2_MOD_PIBPC1, IF_REAL, "Cross-term dependence of ibpc1"),
+  IOP("pibpc2", HSM2_MOD_PIBPC2, IF_REAL, "Cross-term dependence of ibpc2")
+
+};
+
+char *HSM2names[] = {
+    "Drain",
+    "Gate",
+    "Source",
+    "Bulk"
+};
+
+int	HSM2nSize = NUMELEMS(HSM2names);
+int	HSM2pTSize = NUMELEMS(HSM2pTable);
+int	HSM2mPTSize = NUMELEMS(HSM2mPTable);
+int	HSM2iSize = sizeof(HSM2instance);
+int	HSM2mSize = sizeof(HSM2model);
+

src/spicelib/devices/hisim2/hsm2acld.c

@@ -0,0 +1,638 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2acld.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include <stdio.h>
+#include "spice.h"
+#include "cktdefs.h"
+#include "sperror.h"
+#include "suffix.h"
+#include "hsm2def.h"
+
+
+int HSM2acLoad(inModel,ckt)
+     GENmodel *inModel;
+     register CKTcircuit *ckt;
+{
+  register HSM2model *model = (HSM2model*)inModel;
+  register HSM2instance *here;
+  double xcggb_r, xcgdb_r, xcgsb_r, xcgbb_r, xcggb_i, xcgdb_i, xcgsb_i, xcgbb_i;
+  double xcbgb_r, xcbdb_r, xcbsb_r, xcbbb_r, xcbgb_i, xcbdb_i, xcbsb_i, xcbbb_i;
+  double xcdgb_r, xcddb_r, xcdsb_r, xcdbb_r, xcdgb_i, xcddb_i, xcdsb_i, xcdbb_i;
+  double xcsgb_r, xcsdb_r, xcssb_r, xcsbb_r, xcsgb_i, xcsdb_i, xcssb_i, xcsbb_i;
+  double gdpr, gspr, gds, gbd, gbs, capbd, capbs, omega;
+  double FwdSum, RevSum, gm, gmbs;
+  double gbspsp, gbbdp, gbbsp, gbspg, gbspb;
+  double gbspdp, gbdpdp, gbdpg, gbdpb, gbdpsp;
+  double gIbtotg, gIbtotd, gIbtots, gIbtotb;
+  double gIgtotg, gIgtotd, gIgtots, gIgtotb;
+  double gIdtotg, gIdtotd, gIdtots, gIdtotb;
+  double gIstotg, gIstotd, gIstots, gIstotb;
+  double cggb_real, cgsb_real, cgdb_real, cggb_imag, cgsb_imag, cgdb_imag;
+  double cdgb_real, cdsb_real, cddb_real, cdgb_imag, cdsb_imag, cddb_imag;
+  double csgb_real, cssb_real, csdb_real, csgb_imag, cssb_imag, csdb_imag;
+  double cbgb_real, cbsb_real, cbdb_real, cbgb_imag, cbsb_imag, cbdb_imag;
+  double pyggb_r = 0.0, pygdb_r = 0.0, pygsb_r = 0.0, pygbb_r = 0.0;
+  double pybgb_r = 0.0, pybdb_r = 0.0, pybsb_r = 0.0, pybbb_r = 0.0;
+  double pydgb_r = 0.0, pyddb_r = 0.0, pydsb_r = 0.0, pydbb_r = 0.0;
+  double pysgb_r = 0.0, pysdb_r = 0.0, pyssb_r = 0.0, pysbb_r = 0.0;
+  double pyggb_i = 0.0, pygdb_i = 0.0, pygsb_i = 0.0, pygbb_i = 0.0;
+  double pybgb_i = 0.0, pybdb_i = 0.0, pybsb_i = 0.0, pybbb_i = 0.0;
+  double pydgb_i = 0.0, pyddb_i = 0.0, pydsb_i = 0.0, pydbb_i = 0.0;
+  double pysgb_i = 0.0, pysdb_i = 0.0, pyssb_i = 0.0, pysbb_i = 0.0;
+  double yggb_r, ygdb_r, ygsb_r, ygbb_r, yggb_i, ygdb_i, ygsb_i, ygbb_i;
+  double ybgb_r, ybdb_r, ybsb_r, ybbb_r, ybgb_i, ybdb_i, ybsb_i, ybbb_i;
+  double ydgb_r, yddb_r, ydsb_r, ydbb_r, ydgb_i, yddb_i, ydsb_i, ydbb_i;
+  double ysgb_r, ysdb_r, yssb_r, ysbb_r, ysgb_i, ysdb_i, yssb_i, ysbb_i;
+  double grg, pxcbdb_i, pxcbsb_i;
+
+  double Qi, Qi_dVgs, Qi_dVbs, Qi_dVds ;
+  double Qb, Qb_dVgs, Qb_dVbs, Qb_dVds ;
+  double tau ;
+  double taub ;
+  double Xd, Xd_dVgs, Xd_dVbs, Xd_dVds ;
+  double T1, T2, T3, T4 ;
+  double cdbs_real, cgbs_real, csbs_real, cbbs_real;
+  double cdbs_imag, cgbs_imag, csbs_imag, cbbs_imag;
+
+  omega = ckt->CKTomega;
+  for ( ; model != NULL; model = model->HSM2nextModel ) {
+    for ( here = model->HSM2instances; here!= NULL; here = here->HSM2nextInstance ) {
+
+      gdpr = here->HSM2drainConductance;
+      gspr = here->HSM2sourceConductance;
+      gds = here->HSM2_gds;
+      gbd = here->HSM2_gbd;
+      gbs = here->HSM2_gbs;
+      capbd = here->HSM2_capbd;
+      capbs = here->HSM2_capbs;
+
+      if (model->HSM2_conqs) { /* for nqs mode */
+
+	tau = here->HSM2_tau ;
+
+	taub = here->HSM2_taub ;
+
+	Xd = here->HSM2_Xd;
+	Xd_dVgs = here->HSM2_Xd_dVgs ;
+	Xd_dVds = here->HSM2_Xd_dVds ;
+	Xd_dVbs = here->HSM2_Xd_dVbs ;
+ 
+	Qi = here->HSM2_Qi  ;
+	Qi_dVgs = here->HSM2_Qi_dVgs ;
+	Qi_dVds = here->HSM2_Qi_dVds ;
+	Qi_dVbs = here->HSM2_Qi_dVbs ;
+
+	Qb = here->HSM2_Qb  ;
+	Qb_dVgs = here->HSM2_Qb_dVgs ;
+	Qb_dVds = here->HSM2_Qb_dVds ;
+	Qb_dVbs = here->HSM2_Qb_dVbs ;
+
+	T1 = 1.0 + (tau * omega) * (tau * omega);
+	T2 = tau * omega / T1;
+	T3 = 1.0 + (taub * omega) * (taub * omega);
+	T4 = taub * omega / T3;
+
+        cddb_real = Xd_dVds*Qi + Xd/T1*Qi_dVds;
+        cdgb_real = Xd_dVgs*Qi + Xd/T1*Qi_dVgs;
+        cdbs_real = Xd_dVbs*Qi + Xd/T1*Qi_dVbs;
+        cdsb_real = - (cddb_real + cdgb_real + cdbs_real);
+
+        cddb_imag = - T2*Xd*Qi_dVds;
+        cdgb_imag = - T2*Xd*Qi_dVgs;
+        cdbs_imag = - T2*Xd*Qi_dVbs;
+        cdsb_imag = - (cddb_imag + cdgb_imag + cdbs_imag);
+
+        csdb_real = - Xd_dVds*Qi + (1.0-Xd)/T1*Qi_dVds;
+        csgb_real = - Xd_dVgs*Qi + (1.0-Xd)/T1*Qi_dVgs;
+        csbs_real = - Xd_dVbs*Qi + (1.0-Xd)/T1*Qi_dVbs;
+        cssb_real = - (csdb_real + csgb_real + csbs_real);
+
+        csdb_imag = - T2*(1.0-Xd)*Qi_dVds;
+        csgb_imag = - T2*(1.0-Xd)*Qi_dVgs;
+        csbs_imag = - T2*(1.0-Xd)*Qi_dVbs;
+        cssb_imag = - (csdb_imag + csgb_imag + csbs_imag);
+
+        cbdb_real = Qb_dVds/T3;
+        cbgb_real = Qb_dVgs/T3;
+        cbbs_real = Qb_dVbs/T3;
+        cbsb_real = - (cbdb_real + cbgb_real + cbbs_real);
+
+        cbdb_imag = - T4*Qb_dVds;
+        cbgb_imag = - T4*Qb_dVgs;
+        cbbs_imag = - T4*Qb_dVbs;
+        cbsb_imag = - (cbdb_imag + cbgb_imag + cbbs_imag);
+
+        cgdb_real = - Qi_dVds/T1 - Qb_dVds/T3;
+        cggb_real = - Qi_dVgs/T1 - Qb_dVgs/T3;
+        cgbs_real = - Qi_dVbs/T1 - Qb_dVbs/T3;
+        cgsb_real = - (cgdb_real + cggb_real + cgbs_real);
+
+        cgdb_imag = T2*Qi_dVds + T4*Qb_dVds;
+        cggb_imag = T2*Qi_dVgs + T4*Qb_dVgs;
+        cgbs_imag = T2*Qi_dVbs + T4*Qb_dVbs;
+        cgsb_imag = - (cgdb_imag + cggb_imag + cgbs_imag); 
+
+
+
+#ifdef DEBUG_HISIM2CGG
+	printf("Freq. %e ", omega/(2*3.14159265358979) ) ;
+	printf("mag[Cgg] %e ", sqrt( cggb_real * cggb_real + cggb_imag * cggb_imag ) ) ;
+	printf("qi %e ", ( sqrt(T1) / T1 ) * Qi ) ;
+	printf("qb %e ", ( sqrt(T3) / T3 ) * Qb ) ;
+	printf("\n") ;
+#endif
+
+#ifdef DEBUG_HISIM2AC
+	printf ("#1 cssb, cggb, cgdb, cgsb, cdgb, cddb, cdsb, csgb, csdb  %e %e %e %e %e %e %e %e %e %e %e %e\n",  cggb_real, cgdb_real, cgsb_real, cdgb_real, cddb_real, cdsb_real, csgb_real, csdb_real, cssb_real);
+#endif
+      }
+	
+      if ( here->HSM2_mode >= 0 ) {
+	gm = here->HSM2_gm;
+	gmbs = here->HSM2_gmbs;
+	FwdSum = gm + gmbs;
+	RevSum = 0.0;
+	
+	gbbdp = -here->HSM2_gbds;
+	gbbsp = here->HSM2_gbds + here->HSM2_gbgs + here->HSM2_gbbs;
+	
+	gbdpg = here->HSM2_gbgs;
+	gbdpb = here->HSM2_gbbs;
+	gbdpdp = here->HSM2_gbds;
+	gbdpsp = -(gbdpg + gbdpb + gbdpdp);
+	
+	gbspdp = 0.0;
+	gbspg = 0.0;
+	gbspb = 0.0;
+	gbspsp = 0.0;
+
+	if (model->HSM2_coiigs) {
+	  gIbtotg = here->HSM2_gigbg;
+	  gIbtotd = here->HSM2_gigbd;
+	  gIbtots = here->HSM2_gigbs;
+	  gIbtotb = here->HSM2_gigbb;
+
+	  gIstotg = here->HSM2_gigsg;
+	  gIstotd = here->HSM2_gigsd;
+	  gIstots = here->HSM2_gigss;
+	  gIstotb = here->HSM2_gigsb;
+
+	  gIdtotg = here->HSM2_gigdg;
+	  gIdtotd = here->HSM2_gigdd;
+	  gIdtots = here->HSM2_gigds;
+	  gIdtotb = here->HSM2_gigdb;
+	} else {
+	  gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0;
+	  gIstotg = gIstotd = gIstots = gIstotb = 0.0;
+	  gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0;
+	}
+
+	if (model->HSM2_coiigs) {
+	  gIgtotg = gIbtotg + gIstotg + gIdtotg;
+	  gIgtotd = gIbtotd + gIstotd + gIdtotd;
+	  gIgtots = gIbtots + gIstots + gIdtots;
+	  gIgtotb = gIbtotb + gIstotb + gIdtotb;
+	} else {
+	  gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0;
+	}
+
+	if (model->HSM2_conqs) { /* for nqs mode */
+          /*
+	    cggb_real, cgsb_real, cgdb_real
+	    cggb_imag, cgsb_imag, cgdb_imag
+	    cdgb_real, cdsb_real, cddb_real
+	    cdgb_imag, cdsb_imag, cddb_imag
+	    csgb_real, cssb_real, csdb_real
+	    csgb_imag, cssb_imag, csdb_imag
+	    cbgb_real, cbsb_real, cbdb_real
+	    cbgb_imag, cbsb_imag, cbdb_imag
+	    have already obtained.
+	  */
+	  if (model->HSM2_coadov == 1) { /* add overlap caps to intrinsic caps */
+	    pydgb_i =  (here->HSM2_cdgo - here->HSM2_cqyg) * omega ;
+	    pyddb_i =  (here->HSM2_cddo - here->HSM2_cqyd) * omega ;
+	    pydsb_i =  (here->HSM2_cdso + here->HSM2_cqyg + here->HSM2_cqyd + here->HSM2_cqyb) * omega ;
+	    pydbb_i = -(pydgb_i + pyddb_i + pydsb_i) ;
+
+	    pysgb_i =  here->HSM2_csgo * omega ;
+	    pysdb_i =  here->HSM2_csdo * omega ;
+	    pyssb_i =  here->HSM2_csso * omega ;
+	    pysbb_i = -(pysgb_i + pysdb_i + pyssb_i) ;
+
+	    pyggb_i = (-(here->HSM2_cgdo + here->HSM2_cgbo + here->HSM2_cgso) + here->HSM2_cqyg) * omega ;
+	    pygdb_i =  (here->HSM2_cgdo + here->HSM2_cqyd) * omega ;
+	    pygsb_i =  (here->HSM2_cgso - here->HSM2_cqyg - here->HSM2_cqyd - here->HSM2_cqyb) * omega ;
+	    pygbb_i = -(pyggb_i + pygdb_i + pygsb_i) ;
+	  } 
+
+	} else { /* for qs mode */
+	  /* if coadov = 1, coverlap caps have been arleady added to intrinsic caps (QS mode)*/
+	  cggb_real = here->HSM2_cggb;
+	  cgsb_real = here->HSM2_cgsb;
+	  cgdb_real = here->HSM2_cgdb;
+	  cggb_imag = cgsb_imag = cgdb_imag = 0.0;
+	
+	  cbgb_real = here->HSM2_cbgb;
+	  cbsb_real = here->HSM2_cbsb;
+	  cbdb_real = here->HSM2_cbdb;
+	  cbgb_imag = cbsb_imag = cbdb_imag = 0.0;
+	  
+	  cdgb_real = here->HSM2_cdgb;
+	  cdsb_real = here->HSM2_cdsb;
+	  cddb_real = here->HSM2_cddb;
+	  cdgb_imag = cdsb_imag = cddb_imag = 0.0;
+	  
+	  csgb_real = -(cdgb_real + cggb_real + cbgb_real);
+         cssb_real = -(cdsb_real + cgsb_real + cbsb_real);
+         csdb_real = -(cddb_real + cgdb_real + cbdb_real);
+         csgb_imag = cssb_imag = csdb_imag = 0.0;
+
+         pyggb_i = 0.0; pygdb_i = 0.0; pygsb_i = 0.0; pygbb_i = 0.0;
+         pybgb_i = 0.0; pybdb_i = 0.0; pybsb_i = 0.0; pybbb_i = 0.0;
+         pydgb_i = 0.0; pyddb_i = 0.0; pydsb_i = 0.0; pydbb_i = 0.0;
+         pysgb_i = 0.0; pysdb_i = 0.0; pyssb_i = 0.0; pysbb_i = 0.0;
+       }
+
+      } else { /* reverse mode  */
+	gm = -here->HSM2_gm;
+	gmbs = -here->HSM2_gmbs;
+	FwdSum = 0.0;
+	RevSum = -(gm + gmbs);
+	
+	gbbsp = -here->HSM2_gbds;
+	gbbdp = here->HSM2_gbds + here->HSM2_gbgs + here->HSM2_gbbs;
+	
+	gbdpg = 0.0;
+	gbdpsp = 0.0;
+	gbdpb = 0.0;
+	gbdpdp = 0.0;
+
+	gbspg = here->HSM2_gbgs;
+	gbspsp = here->HSM2_gbds;
+	gbspb = here->HSM2_gbbs;
+	gbspdp = -(gbspg + gbspsp + gbspb);
+
+	if (model->HSM2_coiigs) {
+	  gIbtotg = here->HSM2_gigbg;
+	  gIbtotd = here->HSM2_gigbd;
+	  gIbtots = here->HSM2_gigbs;
+	  gIbtotb = here->HSM2_gigbb;
+
+	  gIstotg = here->HSM2_gigsg;
+	  gIstotd = here->HSM2_gigsd;
+	  gIstots = here->HSM2_gigss;
+	  gIstotb = here->HSM2_gigsb;
+
+	  gIdtotg = here->HSM2_gigdg;
+	  gIdtotd = here->HSM2_gigdd;
+	  gIdtots = here->HSM2_gigds;
+	  gIdtotb = here->HSM2_gigdb;
+	} else {
+	  gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0;
+	  gIstotg = gIstotd = gIstots = gIstotb = 0.0;
+	  gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0;
+	}
+	
+	if (model->HSM2_coiigs) {
+	  gIgtotg = gIbtotg + gIstotg + gIdtotg;
+	  gIgtotd = gIbtotd + gIstotd + gIdtotd;
+	  gIgtots = gIbtots + gIstots + gIdtots;
+	  gIgtotb = gIbtotb + gIstotb + gIdtotb;
+	} else {
+	  gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0;
+	}
+	
+	if (model->HSM2_conqs) { /* for nqs mode */
+	  /* swap d with s, s with d */
+          /* cggb_real has already obtained. */
+	  T1 = cgsb_real;
+	  cgsb_real = cgdb_real;
+	  cgdb_real = T1;
+	  /* cggb_imag has already obtained. */
+	  T1 = cgsb_imag;
+	  cgsb_imag = cgdb_imag;
+	  cgdb_imag = T1;
+
+	  T1 = cdgb_real;
+	  cdgb_real = csgb_real;
+	  csgb_real = T1;
+	  T1 = cdsb_real;
+	  cdsb_real = csdb_real;
+	  csdb_real = T1;
+	  T1 = cddb_real;
+	  cddb_real = cssb_real;
+	  cssb_real = T1;
+	  T1 = cdgb_imag;
+	  cdgb_imag = csgb_imag;
+	  csgb_imag = T1;
+	  T1 = cdsb_imag;
+	  cdsb_imag = csdb_imag;
+	  csdb_imag = T1;
+	  T1 = cddb_imag;
+	  cddb_imag = cssb_imag;
+	  cssb_imag = T1;
+
+	  /* cbgb_real has already obtained. */
+	  T1 = cbsb_real;
+	  cbsb_real = cbdb_real;
+	  cbdb_real = T1;
+	  /* cbgb_imag has already obtained. */
+	  T1 = cbsb_imag;
+	  cbsb_imag = cbdb_imag;
+	  cbdb_imag = T1;
+
+	  if (model->HSM2_coadov == 1) { /* add overlap caps to intrinsic caps */
+	    pydgb_i = here->HSM2_csgo * omega ;
+	    pyddb_i = here->HSM2_csso * omega ;
+	    pydsb_i = here->HSM2_csdo * omega ;
+	    pydbb_i = -(pydgb_i + pyddb_i + pydsb_i) ;
+
+	    pysgb_i = (here->HSM2_cdgo - here->HSM2_cqyg) * omega ;
+	    pysdb_i = (here->HSM2_cdso + here->HSM2_cqyg + here->HSM2_cqyd + here->HSM2_cqyb) * omega ;
+	    pyssb_i = (here->HSM2_cddo - here->HSM2_cqyd) * omega ;
+	    pysbb_i = -(pysgb_i + pysdb_i + pyssb_i) ;
+
+	    pyggb_i = (-(here->HSM2_cgdo + here->HSM2_cgbo + here->HSM2_cgso) + here->HSM2_cqyg) * omega ;
+	    pygdb_i = (here->HSM2_cgso - here->HSM2_cqyg - here->HSM2_cqyd - here->HSM2_cqyb) * omega ;
+	    pygsb_i = (here->HSM2_cgdo + here->HSM2_cqyd) * omega ;
+	    pygbb_i = -(pyggb_i + pygdb_i + pygsb_i) ;
+	  } 
+
+	} else { /* for qs mode */
+	  /* if coadov = 1, coverlap caps have already been added to intrinsic caps (QS mode)*/
+	  cggb_real = here->HSM2_cggb;
+	  cgsb_real = here->HSM2_cgdb;
+	  cgdb_real = here->HSM2_cgsb;
+	  cggb_imag = cgsb_imag = cgdb_imag = 0.0;
+	
+	  cbgb_real = here->HSM2_cbgb;
+	  cbsb_real = here->HSM2_cbdb;
+	  cbdb_real = here->HSM2_cbsb;
+	  cbgb_imag = cbsb_imag = cbdb_imag = 0.0;
+	  
+	  csgb_real = here->HSM2_cdgb ;
+	  cssb_real = here->HSM2_cddb ;
+	  csdb_real = here->HSM2_cdsb ;
+	  csgb_imag = cssb_imag = csdb_imag = 0.0;
+	  
+	  cdgb_real = -(csgb_real + cggb_real + cbgb_real);
+         cdsb_real = -(cssb_real + cgsb_real + cbsb_real);
+         cddb_real = -(csdb_real + cgdb_real + cbdb_real);
+         cdgb_imag = cdsb_imag = cddb_imag = 0.0;
+
+         pyggb_i = 0.0; pygdb_i = 0.0; pygsb_i = 0.0; pygbb_i = 0.0;
+         pybgb_i = 0.0; pybdb_i = 0.0; pybsb_i = 0.0; pybbb_i = 0.0;
+         pydgb_i = 0.0; pyddb_i = 0.0; pydsb_i = 0.0; pydbb_i = 0.0;
+         pysgb_i = 0.0; pysdb_i = 0.0; pyssb_i = 0.0; pysbb_i = 0.0;
+       }
+
+      }
+#ifdef DEBUG_HISIM2AC
+      printf ("#2 cssb, cggb, cgdb, cgsb, cdgb, cddb, cdsb, csgb, csdb  %e %e %e %e %e %e %e %e %e %e %e %e\n",  cggb_real, cgdb_real, cgsb_real, cdgb_real, cddb_real, cdsb_real, csgb_real, csdb_real, cssb_real);
+#endif
+
+      /* matrix elements for ac analysis (including real and imaginary parts) */
+      xcdgb_r = cdgb_real * omega;
+      xcddb_r = cddb_real * omega;
+      xcdsb_r = cdsb_real * omega;
+      xcdbb_r = -(xcdgb_r + xcddb_r + xcdsb_r);
+
+      xcsgb_r = csgb_real * omega;
+      xcsdb_r = csdb_real * omega;
+      xcssb_r = cssb_real * omega;
+      xcsbb_r = -(xcsgb_r + xcsdb_r + xcssb_r);
+
+      xcggb_r = cggb_real * omega;
+      xcgdb_r = cgdb_real * omega;
+      xcgsb_r = cgsb_real * omega;
+      xcgbb_r = -(xcggb_r + xcgdb_r + xcgsb_r);
+      
+      xcbgb_r = cbgb_real * omega;
+      xcbdb_r = cbdb_real * omega;
+      xcbsb_r = cbsb_real * omega;
+      xcbbb_r = -(xcbgb_r + xcbdb_r + xcbsb_r);
+
+      xcdgb_i = cdgb_imag * omega;
+      xcddb_i = cddb_imag * omega;
+      xcdsb_i = cdsb_imag * omega;
+      xcdbb_i = -(xcddb_i + xcdgb_i + xcdsb_i);
+
+      xcsgb_i = csgb_imag * omega;
+      xcsdb_i = csdb_imag * omega;
+      xcssb_i = cssb_imag * omega;
+      xcsbb_i = -(xcsdb_i + xcsgb_i + xcssb_i);
+
+      xcggb_i = cggb_imag * omega;
+      xcgdb_i = cgdb_imag * omega;
+      xcgsb_i = cgsb_imag * omega;
+      xcgbb_i = -(xcggb_i + xcgdb_i + xcgsb_i);
+
+      xcbgb_i = cbgb_imag * omega;
+      xcbdb_i = cbdb_imag * omega;
+      xcbsb_i = cbsb_imag * omega;
+      xcbbb_i = -(xcbgb_i + xcbdb_i + xcbsb_i);
+
+      /* stamp intrinsic y-parameters */
+      yggb_r = - xcggb_i; yggb_i = xcggb_r;
+      ygdb_r = - xcgdb_i; ygdb_i = xcgdb_r;
+      ygsb_r = - xcgsb_i; ygsb_i = xcgsb_r;
+      ygbb_r = - xcgbb_i; ygbb_i = xcgbb_r;
+
+      ydgb_r = - xcdgb_i; ydgb_i = xcdgb_r;
+      yddb_r = - xcddb_i; yddb_i = xcddb_r;
+      ydsb_r = - xcdsb_i; ydsb_i = xcdsb_r;
+      ydbb_r = - xcdbb_i; ydbb_i = xcdbb_r;
+      ydgb_r += gm;
+      yddb_r += gds + RevSum;
+      ydsb_r += - gds - FwdSum;
+      ydbb_r += gmbs;
+
+      ysgb_r = - xcsgb_i; ysgb_i = xcsgb_r;
+      ysdb_r = - xcsdb_i; ysdb_i = xcsdb_r;
+      yssb_r = - xcssb_i; yssb_i = xcssb_r;
+      ysbb_r = - xcsbb_i; ysbb_i = xcsbb_r;
+      ysgb_r += - gm;
+      ysdb_r += - gds - RevSum;
+      yssb_r += gds + FwdSum;
+      ysbb_r += - gmbs;
+
+      ybgb_r = - xcbgb_i; ybgb_i = xcbgb_r;
+      ybdb_r = - xcbdb_i; ybdb_i = xcbdb_r;
+      ybsb_r = - xcbsb_i; ybsb_i = xcbsb_r;
+      ybbb_r = - xcbbb_i; ybbb_i = xcbbb_r;
+      
+      /* Ibd, Ibs, Igate, Igd, Igs, Igb, Igidl, Igisl, Isub */
+      pydgb_r = gbdpg - gIdtotg + here->HSM2_gigidlgs ;
+      pyddb_r = gbd + gbdpdp - gIdtotd + here->HSM2_gigidlds ;
+      pydsb_r = gbdpsp - gIdtots - (here->HSM2_gigidlgs + here->HSM2_gigidlds + here->HSM2_gigidlbs);
+      pydbb_r = gbdpb - gIdtotb + here->HSM2_gigidlbs ;
+      if (!here->HSM2_corbnet) pydbb_r += - gbd;
+
+      pysgb_r = gbspg - gIstotg + here->HSM2_gigislgd ;
+      pysdb_r = gbspdp - gIstotd - (here->HSM2_gigislsd + here->HSM2_gigislgd + here->HSM2_gigislbd);
+      pyssb_r = gbs + gbspsp - gIstots + here->HSM2_gigislsd ;
+      pysbb_r =gbspb - gIstotb + here->HSM2_gigislbd ;
+      if (!here->HSM2_corbnet) pysbb_r += - gbs;
+	
+      pyggb_r = gIgtotg ;
+      if (here->HSM2_corg == 1) {	
+	grg = here->HSM2_grg;
+	pyggb_r += grg;
+      }
+      pygdb_r = gIgtotd ;
+      pygsb_r = gIgtots ;
+      pygbb_r = gIgtotb ;
+
+      pybgb_r = - here->HSM2_gbgs - gIbtotg - here->HSM2_gigidlgs - here->HSM2_gigislgd ;
+      pybdb_r = gbbdp - gIbtotd 
+	- here->HSM2_gigidlds + (here->HSM2_gigislgd + here->HSM2_gigislsd + here->HSM2_gigislbd) ;
+      if (!here->HSM2_corbnet) pybdb_r += - gbd ;
+      pybsb_r = gbbsp - gIbtots 
+	+ (here->HSM2_gigidlgs + here->HSM2_gigidlds + here->HSM2_gigidlbs) - here->HSM2_gigislsd ;
+      if (!here->HSM2_corbnet) pybsb_r += - gbs ;
+      pybbb_r = - here->HSM2_gbbs - gIbtotb - here->HSM2_gigidlbs - here->HSM2_gigislbd ;
+      if (!here->HSM2_corbnet) pybbb_r += gbd + gbs ;
+
+      pybdb_i = -(pyddb_i + pygdb_i + pysdb_i); 
+      pybgb_i = -(pydgb_i + pyggb_i + pysgb_i); 
+      pybsb_i = -(pydsb_i + pygsb_i + pyssb_i); 
+      pybbb_i = -(pydbb_i + pygbb_i + pysbb_i); 
+      
+      /* Cbd, Cbs */
+      pyddb_i += capbd * omega ;
+      pyssb_i += capbs * omega ;
+      if (!here->HSM2_corbnet) {
+	pydbb_i -= capbd * omega ; 
+	pysbb_i -= capbs * omega ; 
+
+ 	pybdb_i -= capbd * omega ; 
+ 	pybsb_i -= capbs * omega ;  
+ 	pybbb_i += (capbd + capbs) * omega ; 
+      } else {
+	pxcbdb_i = - capbd * omega ;
+	pxcbsb_i = - capbs * omega ;
+      }
+
+#ifdef DEBUG_HISIM2AC
+      /* for representing y-parameters */ 
+      printf("f ygg_r ygg_i %e %e %e\n",omega/(2.0*3.141592653589793),yggb_r+pyggb_r,yggb_i+pyggb_i);
+      printf("f ygd_r ygd_i %e %e %e\n",omega/(2.0*3.141592653589793),ygdb_r+pygdb_r,ygdb_i+pygdb_i);
+      printf("f ygs_r ygs_i %e %e %e\n",omega/(2.0*3.141592653589793),ygsb_r+pygsb_r,ygsb_i+pygsb_i);
+      printf("f ygb_r ygb_i %e %e %e\n",omega/(2.0*3.141592653589793),ygbb_r+pygbb_r,ygbb_i+pygbb_i);
+
+      printf("f ydg_r ydg_i %e %e %e\n",omega/(2.0*3.141592653589793),ydgb_r+pydgb_r,ydgb_i+pydgb_i);
+      printf("f ydd_r ydd_i %e %e %e\n",omega/(2.0*3.141592653589793),yddb_r+pyddb_r,yddb_i+pyddb_i);
+      printf("f yds_r yds_i %e %e %e\n",omega/(2.0*3.141592653589793),ydsb_r+pydsb_r,ydsb_i+pydsb_i);
+      printf("f ydb_r ydb_i %e %e %e\n",omega/(2.0*3.141592653589793),ydbb_r+pydbb_r,ydbb_i+pydbb_i);
+
+      printf("f ybg_r ybg_i %e %e %e\n",omega/(2.0*3.141592653589793),ybgb_r+pybgb_r,ybgb_i+pybgb_i);
+      printf("f ybd_r ybd_i %e %e %e\n",omega/(2.0*3.141592653589793),ybdb_r+pybdb_r,ybdb_i+pybdb_i);
+      printf("f ybs_r ybs_i %e %e %e\n",omega/(2.0*3.141592653589793),ybsb_r+pybsb_r,ybsb_i+pybsb_i);
+      printf("f ybb_r ybb_i %e %e %e\n",omega/(2.0*3.141592653589793),ybbb_r+pybbb_r,ybbb_i+pybbb_i);
+
+      printf("f ysg_r ysg_i %e %e %e\n",omega/(2.0*3.141592653589793),ysgb_r+pysgb_r,ysgb_i+pysgb_i);
+      printf("f ysd_r ysd_i %e %e %e\n",omega/(2.0*3.141592653589793),ysdb_r+pysdb_r,ysdb_i+pysdb_i);
+      printf("f yss_r yss_i %e %e %e\n",omega/(2.0*3.141592653589793),yssb_r+pyssb_r,yssb_i+pyssb_i);
+      printf("f ysb_r ysb_i %e %e %e\n",omega/(2.0*3.141592653589793),ysbb_r+pysbb_r,ysbb_i+pysbb_i);
+
+      printf("f y11r y11i y12r y12i y21r y21i y22r y22i %e %e %e %e %e %e %e %e %e\n",omega/(2.0*3.141592653589793),yggb_r+pyggb_r,yggb_i+pyggb_i, ygdb_r+pygdb_r,ygdb_i+pygdb_i, ydgb_r+pydgb_r,ydgb_i+pydgb_i, yddb_r+pyddb_r,yddb_i+pyddb_i);
+#endif
+      
+      if (here->HSM2_corg == 1) {
+	*(here->HSM2GgPtr) += grg;
+	*(here->HSM2GPgPtr) -= grg;
+	*(here->HSM2GgpPtr) -= grg;
+      } 
+
+      *(here->HSM2GPgpPtr +1)  += yggb_i + pyggb_i;
+      *(here->HSM2GPgpPtr)     += yggb_r + pyggb_r;
+      *(here->HSM2GPdpPtr +1)  += ygdb_i + pygdb_i;
+      *(here->HSM2GPdpPtr)     += ygdb_r + pygdb_r;
+      *(here->HSM2GPspPtr +1)  += ygsb_i + pygsb_i;
+      *(here->HSM2GPspPtr)     += ygsb_r + pygsb_r;
+      *(here->HSM2GPbpPtr +1)  += ygbb_i + pygbb_i;
+      *(here->HSM2GPbpPtr)     += ygbb_r + pygbb_r;
+
+      *(here->HSM2DPdpPtr +1) += yddb_i + pyddb_i;
+      *(here->HSM2DPdpPtr)    += yddb_r + pyddb_r + gdpr;
+      *(here->HSM2DPdPtr)     -= gdpr;
+      *(here->HSM2DPgpPtr +1) += ydgb_i + pydgb_i;
+      *(here->HSM2DPgpPtr)    += ydgb_r + pydgb_r;
+      *(here->HSM2DPspPtr +1) += ydsb_i + pydsb_i;
+      *(here->HSM2DPspPtr)    += ydsb_r + pydsb_r;
+      *(here->HSM2DPbpPtr +1) += ydbb_i + pydbb_i;
+      *(here->HSM2DPbpPtr)    += ydbb_r + pydbb_r;
+
+      *(here->HSM2DdpPtr)     -= gdpr;
+      *(here->HSM2DdPtr)      += gdpr;
+
+      *(here->HSM2SPdpPtr +1) += ysdb_i + pysdb_i;
+      *(here->HSM2SPdpPtr)    += ysdb_r + pysdb_r;
+      *(here->HSM2SPgpPtr +1) += ysgb_i + pysgb_i;
+      *(here->HSM2SPgpPtr)    += ysgb_r + pysgb_r;
+      *(here->HSM2SPspPtr +1) += yssb_i + pyssb_i;
+      *(here->HSM2SPspPtr)    += yssb_r + pyssb_r + gspr;
+      *(here->HSM2SPsPtr)     -= gspr ;
+      *(here->HSM2SPbpPtr +1) += ysbb_i + pysbb_i;
+      *(here->HSM2SPbpPtr)    += ysbb_r + pysbb_r;
+
+      *(here->HSM2SspPtr)     -= gspr;
+      *(here->HSM2SsPtr)      += gspr;
+
+      *(here->HSM2BPdpPtr +1)  += ybdb_i + pybdb_i;
+      *(here->HSM2BPdpPtr)     += ybdb_r + pybdb_r;
+      *(here->HSM2BPgpPtr +1)  += ybgb_i + pybgb_i;
+      *(here->HSM2BPgpPtr)     += ybgb_r + pybgb_r;
+      *(here->HSM2BPspPtr +1)  += ybsb_i + pybsb_i;
+      *(here->HSM2BPspPtr)     += ybsb_r + pybsb_r;
+      *(here->HSM2BPbpPtr +1)  += ybbb_i + pybbb_i;
+      *(here->HSM2BPbpPtr)     += ybbb_r + pybbb_r;
+
+      if (here->HSM2_corbnet == 1) {
+	*(here->HSM2DPdbPtr +1) += pxcbdb_i;
+	*(here->HSM2DPdbPtr) -= gbd;
+	*(here->HSM2SPsbPtr +1) += pxcbsb_i;
+	*(here->HSM2SPsbPtr) -= gbs;
+	
+	*(here->HSM2DBdpPtr +1) += pxcbdb_i;
+	*(here->HSM2DBdpPtr) -= gbd;
+	*(here->HSM2DBdbPtr +1) -= pxcbdb_i;
+	*(here->HSM2DBdbPtr) += gbd + here->HSM2_grbpd + here->HSM2_grbdb;
+	*(here->HSM2DBbpPtr) -= here->HSM2_grbpd;
+	*(here->HSM2DBbPtr) -= here->HSM2_grbdb;
+
+	*(here->HSM2BPdbPtr) -= here->HSM2_grbpd;
+	*(here->HSM2BPbPtr) -= here->HSM2_grbpb;
+	*(here->HSM2BPsbPtr) -= here->HSM2_grbps;
+	*(here->HSM2BPbpPtr) += here->HSM2_grbpd + here->HSM2_grbps + here->HSM2_grbpb;
+
+	*(here->HSM2SBspPtr +1) += pxcbsb_i;
+	*(here->HSM2SBspPtr) -= gbs;
+	*(here->HSM2SBbpPtr) -= here->HSM2_grbps;
+	*(here->HSM2SBbPtr) -= here->HSM2_grbsb;
+	*(here->HSM2SBsbPtr +1) -= pxcbsb_i;
+	*(here->HSM2SBsbPtr) += gbs + here->HSM2_grbps + here->HSM2_grbsb;
+
+	*(here->HSM2BdbPtr) -= here->HSM2_grbdb;
+	*(here->HSM2BbpPtr) -= here->HSM2_grbpb;
+	*(here->HSM2BsbPtr) -= here->HSM2_grbsb;
+	*(here->HSM2BbPtr) += here->HSM2_grbsb + here->HSM2_grbdb + here->HSM2_grbpb;
+      }
+
+    }
+  }
+
+  return(OK);
+}

src/spicelib/devices/hisim2/hsm2ask.c

@@ -0,0 +1,286 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2ask.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "ifsim.h"
+#include "cktdefs.h"
+#include "devdefs.h"
+#include "hsm2def.h"
+#include "sperror.h"
+#include "util.h"
+#include "suffix.h"
+
+int HSM2ask(ckt,inst,which,value,select)
+     CKTcircuit *ckt;
+     GENinstance *inst;
+     int which;
+     IFvalue *value;
+     IFvalue *select;
+{
+  HSM2instance *here = (HSM2instance*)inst;
+
+  switch (which) {
+  case HSM2_L:
+    value->rValue = here->HSM2_l;
+    return(OK);
+  case HSM2_W:
+    value->rValue = here->HSM2_w;
+    return(OK);
+  case HSM2_AS:
+    value->rValue = here->HSM2_as;
+    return(OK);
+  case HSM2_AD:
+    value->rValue = here->HSM2_ad;
+    return(OK);
+  case HSM2_PS:
+    value->rValue = here->HSM2_ps;
+    return(OK);
+  case HSM2_PD:
+    value->rValue = here->HSM2_pd;
+    return(OK);
+  case HSM2_NRS:
+    value->rValue = here->HSM2_nrs;
+    return(OK);
+  case HSM2_NRD:
+    value->rValue = here->HSM2_nrd;
+    return(OK);
+  case HSM2_TEMP:
+    value->rValue = here->HSM2_temp;
+    return(OK);
+  case HSM2_DTEMP:
+    value->rValue = here->HSM2_dtemp;
+    return(OK);
+  case HSM2_OFF:
+    value->iValue = here->HSM2_off;
+    return(OK);
+  case HSM2_IC_VBS:
+    value->rValue = here->HSM2_icVBS;
+    return(OK);
+  case HSM2_IC_VDS:
+    value->rValue = here->HSM2_icVDS;
+    return(OK);
+  case HSM2_IC_VGS:
+    value->rValue = here->HSM2_icVGS;
+    return(OK);
+  case HSM2_DNODE:
+    value->iValue = here->HSM2dNode;
+    return(OK);
+  case HSM2_GNODE:
+    value->iValue = here->HSM2gNode;
+    return(OK);
+  case HSM2_SNODE:
+    value->iValue = here->HSM2sNode;
+    return(OK);
+  case HSM2_BNODE:
+    value->iValue = here->HSM2bNode;
+    return(OK);
+  case HSM2_DNODEPRIME:
+    value->iValue = here->HSM2dNodePrime;
+    return(OK);
+  case HSM2_SNODEPRIME:
+    value->iValue = here->HSM2sNodePrime;
+    return(OK);
+  case HSM2_SOURCECONDUCT:
+    value->rValue = here->HSM2sourceConductance;
+    return(OK);
+  case HSM2_DRAINCONDUCT:
+    value->rValue = here->HSM2drainConductance;
+    return(OK);
+  case HSM2_VBD:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2vbd);
+    return(OK);
+  case HSM2_VBS:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2vbs);
+    return(OK);
+  case HSM2_VGS:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2vgs);
+    return(OK);
+  case HSM2_VDS:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2vds);
+    return(OK);
+  case HSM2_CD:
+    value->rValue = here->HSM2_ids;
+    return(OK);
+  case HSM2_ISUB:
+    value->rValue = here->HSM2_isub;
+    return(OK);
+  case HSM2_IGIDL:
+    value->rValue = here->HSM2_igidl;
+    return(OK);
+  case HSM2_IGISL:
+    value->rValue = here->HSM2_igisl;
+    return(OK);
+  case HSM2_IGD:
+    value->rValue = here->HSM2_igd;
+    return(OK);
+  case HSM2_IGS:
+    value->rValue = here->HSM2_igs;
+    return(OK);
+  case HSM2_IGB:
+    value->rValue = here->HSM2_igb;
+    return(OK);
+  case HSM2_CBS:
+    value->rValue = here->HSM2_ibs;
+    return(OK);
+  case HSM2_CBD:
+    value->rValue = here->HSM2_ibd;
+    return(OK);
+  case HSM2_GM:
+    value->rValue = here->HSM2_gm;
+    return(OK);
+  case HSM2_GDS:
+    value->rValue = here->HSM2_gds;
+    return(OK);
+  case HSM2_GMBS:
+    value->rValue = here->HSM2_gmbs;
+    return(OK);
+  case HSM2_GBD:
+    value->rValue = here->HSM2_gbd;
+    return(OK);
+  case HSM2_GBS:
+    value->rValue = here->HSM2_gbs;
+    return(OK);
+  case HSM2_QB:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2qb); 
+    return(OK);
+  case HSM2_CQB:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2cqb); 
+    return(OK);
+  case HSM2_QG:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2qg); 
+    return(OK);
+  case HSM2_CQG:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2cqg); 
+    return(OK);
+  case HSM2_QD:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2qd); 
+    return(OK);
+  case HSM2_CQD:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2cqd); 
+    return(OK);
+  case HSM2_CGG:
+    value->rValue = here->HSM2_cggb; 
+    return(OK);
+  case HSM2_CGD:
+    value->rValue = here->HSM2_cgdb;
+    return(OK);
+  case HSM2_CGS:
+    value->rValue = here->HSM2_cgsb;
+    return(OK);
+  case HSM2_CDG:
+    value->rValue = here->HSM2_cdgb; 
+    return(OK);
+  case HSM2_CDD:
+    value->rValue = here->HSM2_cddb; 
+    return(OK);
+  case HSM2_CDS:
+    value->rValue = here->HSM2_cdsb; 
+    return(OK);
+  case HSM2_CBG:
+    value->rValue = here->HSM2_cbgb;
+    return(OK);
+  case HSM2_CBDB:
+    value->rValue = here->HSM2_cbdb;
+    return(OK);
+  case HSM2_CBSB:
+    value->rValue = here->HSM2_cbsb;
+    return(OK);
+  case HSM2_CGDO:
+    value->rValue = here->HSM2_cgdo;
+    return(OK);
+  case HSM2_CGSO:
+    value->rValue = here->HSM2_cgso;
+    return(OK);
+  case HSM2_CGBO:
+    value->rValue = here->HSM2_cgbo;
+    return(OK);
+  case HSM2_CAPBD:
+    value->rValue = here->HSM2_capbd; 
+    return(OK);
+  case HSM2_CAPBS:
+    value->rValue = here->HSM2_capbs;
+    return(OK);
+  case HSM2_VON:
+    value->rValue = here->HSM2_von; 
+    return(OK);
+  case HSM2_VDSAT:
+    value->rValue = here->HSM2_vdsat; 
+    return(OK);
+  case HSM2_QBS:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2qbs); 
+    return(OK);
+  case HSM2_QBD:
+    value->rValue = *(ckt->CKTstate0 + here->HSM2qbd); 
+    return(OK);
+  case  HSM2_CORBNET: 
+    value->iValue = here->HSM2_corbnet;
+    return(OK);
+  case  HSM2_RBPB:
+    value->rValue = here->HSM2_rbpb;
+    return (OK);
+  case  HSM2_RBPD:
+    value->rValue = here->HSM2_rbpd;
+    return(OK);
+  case  HSM2_RBPS:
+    value->rValue = here->HSM2_rbps;
+    return(OK);
+  case  HSM2_RBDB:
+    value->rValue = here->HSM2_rbdb;
+    return(OK);
+  case  HSM2_RBSB:
+    value->rValue = here->HSM2_rbsb;
+    return(OK);
+  case  HSM2_CORG: 
+    value->iValue = here->HSM2_corg;
+    return(OK);
+/*   case  HSM2_RSHG: */
+/*     value->rValue = here->HSM2_rshg; */
+/*     return(OK); */
+  case  HSM2_NGCON:
+    value->rValue = here->HSM2_ngcon;
+    return(OK);
+  case  HSM2_XGW:
+    value->rValue = here->HSM2_xgw;
+    return(OK);
+  case  HSM2_XGL:
+    value->rValue = here->HSM2_xgl;
+    return(OK);
+  case  HSM2_NF:
+    value->rValue = here->HSM2_nf;
+    return(OK);
+  case  HSM2_SA:
+    value->rValue = here->HSM2_sa;
+    return(OK);
+  case  HSM2_SB:
+    value->rValue = here->HSM2_sb;
+    return(OK);
+  case  HSM2_SD:
+    value->rValue = here->HSM2_sd;
+    return(OK);
+  case  HSM2_NSUBCDFM:
+    value->rValue = here->HSM2_nsubcdfm;
+    return(OK);
+  case  HSM2_MPHDFM:
+    value->rValue = here->HSM2_mphdfm;
+    return(OK);
+  case  HSM2_M:
+    value->rValue = here->HSM2_m;
+    return(OK);
+  default:
+    return(E_BADPARM);
+  }
+  /* NOTREACHED */
+}

src/spicelib/devices/hisim2/hsm2cvtest.c

@@ -0,0 +1,133 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2cvtest.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "util.h"
+#include "cktdefs.h"
+#include "hsm2def.h"
+#include "trandefs.h"
+#include "const.h"
+#include "devdefs.h"
+#include "sperror.h"
+#include "suffix.h"
+
+int HSM2convTest(inModel,ckt)
+     GENmodel *inModel;
+     register CKTcircuit *ckt;
+{
+  register HSM2model *model = (HSM2model*)inModel;
+  register HSM2instance *here;
+  double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds;
+  double cd, cdhat, tol0, tol1, tol2, tol3, tol4, vgd, vgdo, vgs;
+  double Ibtot, cbhat, Igstot, cgshat, Igdtot, cgdhat, Igbtot, cgbhat;
+
+  /*  loop through all the HSM2 device models */
+  for ( ; model != NULL; model = model->HSM2nextModel ) {
+    /* loop through all the instances of the model */
+    for ( here = model->HSM2instances; here != NULL ;
+	  here = here->HSM2nextInstance ) {
+      vbs = model->HSM2_type * 
+	(*(ckt->CKTrhsOld+here->HSM2bNode) - 
+	 *(ckt->CKTrhsOld+here->HSM2sNodePrime));
+      vgs = model->HSM2_type *
+	(*(ckt->CKTrhsOld+here->HSM2gNode) - 
+	 *(ckt->CKTrhsOld+here->HSM2sNodePrime));
+      vds = model->HSM2_type * 
+	(*(ckt->CKTrhsOld+here->HSM2dNodePrime) - 
+	 *(ckt->CKTrhsOld+here->HSM2sNodePrime));
+      vbd = vbs - vds;
+      vgd = vgs - vds;
+      vgdo = *(ckt->CKTstate0 + here->HSM2vgs) - 
+	*(ckt->CKTstate0 + here->HSM2vds);
+      delvbs = vbs - *(ckt->CKTstate0 + here->HSM2vbs);
+      delvbd = vbd - *(ckt->CKTstate0 + here->HSM2vbd);
+      delvgs = vgs - *(ckt->CKTstate0 + here->HSM2vgs);
+      delvds = vds - *(ckt->CKTstate0 + here->HSM2vds);
+      delvgd = vgd - vgdo;
+
+      cd = here->HSM2_ids - here->HSM2_ibd;
+      if ( here->HSM2_mode >= 0 ) {
+	cd += here->HSM2_isub + here->HSM2_igidl;
+	cdhat = cd - here->HSM2_gbd * delvbd 
+	  + (here->HSM2_gmbs + here->HSM2_gbbs + here->HSM2_gigidlbs) * delvbs
+	  + (here->HSM2_gm + here->HSM2_gbgs + here->HSM2_gigidlgs) * delvgs
+	  + (here->HSM2_gds + here->HSM2_gbds + here->HSM2_gigidlds) * delvds;
+	Ibtot = here->HSM2_ibs + here->HSM2_ibd - here->HSM2_isub
+	  - here->HSM2_igidl - here->HSM2_igisl;
+	cbhat = Ibtot + here->HSM2_gbd * delvbd
+	  + (here->HSM2_gbs -  here->HSM2_gbbs - here->HSM2_gigidlbs) * delvbs
+	  - (here->HSM2_gbgs + here->HSM2_gigidlgs) * delvgs
+	  - (here->HSM2_gbds + here->HSM2_gigidlds) * delvds
+	  - here->HSM2_gigislgd * delvgd - here->HSM2_gigislbd * delvbd
+	  + here->HSM2_gigislsd * delvds;
+	Igstot = here->HSM2_igs;
+	cgshat = Igstot + here->HSM2_gigsg * delvgs + 
+	  here->HSM2_gigsd * delvds + here->HSM2_gigsb * delvbs;
+	Igdtot = here->HSM2_igd;
+	cgdhat = Igdtot + here->HSM2_gigdg * delvgs + 
+	  here->HSM2_gigdd * delvds + here->HSM2_gigdb * delvbs;
+	Igbtot = here->HSM2_igb;
+	cgbhat = Igbtot + here->HSM2_gigbg * delvgs + 
+	  here->HSM2_gigbd * delvds + here->HSM2_gigbb * delvbs;
+      }
+      else {
+	cd -= here->HSM2_igidl;
+	cdhat = cd 
+	  + (here->HSM2_gmbs + here->HSM2_gbd - here->HSM2_gigidlbs) * delvbd 
+	  + (here->HSM2_gm - here->HSM2_gigidlgs) * delvgd 
+	  + (- here->HSM2_gds + here->HSM2_gigidlds) * delvds;
+	Ibtot = here->HSM2_ibs + here->HSM2_ibd - here->HSM2_isub
+	  - here->HSM2_igidl - here->HSM2_igisl;
+	cbhat = Ibtot + here->HSM2_gbs * delvbs
+	  + (here->HSM2_gbd - here->HSM2_gbbs - here->HSM2_gigidlbs) * delvbd
+	  - (here->HSM2_gbgs + here->HSM2_gigidlgs) * delvgd
+	  + (here->HSM2_gbds + here->HSM2_gigidlds) * delvds
+	  - here->HSM2_gigislgd * delvgd - here->HSM2_gigislbd * delvbd
+	  + here->HSM2_gigislsd * delvds;
+	Igbtot = here->HSM2_igb;
+	cgbhat = Igbtot + here->HSM2_gigbg * delvgd 
+	  - here->HSM2_gigbs * delvds + here->HSM2_gigbb * delvbd;
+	Igstot = here->HSM2_igs;
+	cgshat = Igstot + here->HSM2_gigsg * delvgd
+	  - here->HSM2_gigss * delvds + here->HSM2_gigsb * delvbd;
+	Igdtot = here->HSM2_igd;
+	cgdhat = Igdtot + here->HSM2_gigdg * delvgd 
+	  - here->HSM2_gigds * delvds + here->HSM2_gigdb * delvbd;
+      }
+
+      /*
+       *  check convergence
+       */
+      if ( here->HSM2_off == 0  || !(ckt->CKTmode & MODEINITFIX) ) {
+	tol0 = ckt->CKTreltol * MAX(FABS(cdhat), FABS(cd)) + ckt->CKTabstol;
+	tol1 = ckt->CKTreltol * MAX(FABS(cgshat), FABS(Igstot)) + ckt->CKTabstol;
+	tol2 = ckt->CKTreltol * MAX(FABS(cgdhat), FABS(Igdtot)) + ckt->CKTabstol;
+	tol3 = ckt->CKTreltol * MAX(FABS(cgbhat), FABS(Igbtot)) + ckt->CKTabstol;
+	tol4 = ckt->CKTreltol * MAX(FABS(cbhat), FABS(Ibtot)) + ckt->CKTabstol;
+
+	if ( (FABS(cdhat - cd) >= tol0)
+	     || (FABS(cgshat - Igstot) >= tol1) 
+	     || (FABS(cgdhat - Igdtot) >= tol2)
+	     || (FABS(cgbhat - Igbtot) >= tol3) 
+	     || (FABS(cbhat - Ibtot) >= tol4) ) {
+	  ckt->CKTnoncon++;
+	  return(OK);
+	}
+      }
+    }
+  }
+  return(OK);
+}

src/spicelib/devices/hisim2/hsm2del.c

@@ -0,0 +1,46 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2del.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "util.h"
+#include "hsm2def.h"
+#include "sperror.h"
+#include "gendefs.h"
+#include "suffix.h"
+
+int HSM2delete(inModel,name,inInst)
+     GENmodel *inModel;
+     IFuid name;
+     GENinstance **inInst;
+{
+  HSM2instance **fast = (HSM2instance**)inInst;
+  HSM2model *model = (HSM2model*)inModel;
+  HSM2instance **prev = NULL;
+  HSM2instance *here;
+
+  for( ;model ;model = model->HSM2nextModel ) {
+    prev = &(model->HSM2instances);
+    for ( here = *prev ;here ;here = *prev ) {
+      if ( here->HSM2name == name || (fast && here==*fast) ) {
+	*prev= here->HSM2nextInstance;
+	FREE(here);
+	return(OK);
+      }
+      prev = &(here->HSM2nextInstance);
+    }
+  }
+  return(E_NODEV);
+}

src/spicelib/devices/hisim2/hsm2dest.c

@@ -0,0 +1,44 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2dest.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "util.h"
+#include "hsm2def.h"
+#include "suffix.h"
+
+void HSM2destroy(inModel)
+     GENmodel **inModel;
+{
+  HSM2model **model = (HSM2model**)inModel;
+  HSM2instance *here;
+  HSM2instance *prev = NULL;
+  HSM2model *mod = *model;
+  HSM2model *oldmod = NULL;
+  
+  for ( ;mod ;mod = mod->HSM2nextModel ) {
+    if (oldmod) FREE(oldmod);
+    oldmod = mod;
+    prev = (HSM2instance *)NULL;
+    for ( here = mod->HSM2instances ;here ;here = here->HSM2nextInstance ) {
+      if (prev) FREE(prev);
+      prev = here;
+    }
+    if (prev) FREE(prev);
+  }
+  if (oldmod) FREE(oldmod);
+  *model = NULL;
+}
+

src/spicelib/devices/hisim2/hsm2evalenv.h

@@ -0,0 +1,91 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2evalenv.h
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#ifndef HSM2_EVAL_ENV_H
+#define HSM2_EVAL_ENV_H
+
+/* macros and constants used in hsm2eval2yz.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    (1.0e2)
+#define C_m2cm_p2 (1.0e4)
+#define C_m2cm_p1o2 (1.0e1)
+#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-12) 
+#define C_EOX   (3.453133e-13) 
+#define C_VAC   (8.8541878e-14) 
+
+/* 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+10)
+
+
+/*---------------------------------------------------*
+* 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 /* HSM2_EVAL_ENV_H */

src/spicelib/devices/hisim2/hsm2ext.h

@@ -0,0 +1,59 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2ext.h
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#ifdef __STDC__
+extern int HSM2acLoad(GENmodel *,CKTcircuit*);
+extern int HSM2ask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*);
+extern int HSM2convTest(GENmodel *,CKTcircuit*);
+extern int HSM2delete(GENmodel*,IFuid,GENinstance**);
+extern void HSM2destroy(GENmodel**);
+extern int HSM2getic(GENmodel*,CKTcircuit*);
+extern int HSM2load(GENmodel*,CKTcircuit*);
+extern int HSM2mAsk(CKTcircuit*,GENmodel *,int, IFvalue*);
+extern int HSM2mDelete(GENmodel**,IFuid,GENmodel*);
+extern int HSM2mParam(int,IFvalue*,GENmodel*);
+extern void HSM2mosCap(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 HSM2param(int,IFvalue*,GENinstance*,IFvalue*);
+extern int HSM2pzLoad(GENmodel*,CKTcircuit*,SPcomplex*);
+extern int HSM2setup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
+extern int HSM2unsetup(GENmodel*,CKTcircuit*);
+extern int HSM2temp(GENmodel*,CKTcircuit*);
+extern int HSM2trunc(GENmodel*,CKTcircuit*,double*);
+extern int HSM2noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
+#else /* stdc */
+extern int HSM2acLoad();
+extern int HSM2delete();
+extern void HSM2destroy();
+extern int HSM2getic();
+extern int HSM2load();
+extern int HSM2mDelete();
+extern int HSM2ask();
+extern int HSM2mAsk();
+extern int HSM2convTest();
+extern int HSM2temp();
+extern int HSM2mParam();
+extern void HSM2mosCap();
+extern int HSM2param();
+extern int HSM2pzLoad();
+extern int HSM2setup();
+extern int HSM2unsetup();
+extern int HSM2trunc();
+extern int HSM2noise();
+
+#endif /* stdc */

src/spicelib/devices/hisim2/hsm2getic.c

@@ -0,0 +1,55 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2getic.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "cktdefs.h"
+#include "hsm2def.h"
+#include "sperror.h"
+#include "suffix.h"
+
+int HSM2getic(inModel,ckt)
+     GENmodel *inModel;
+     CKTcircuit *ckt;
+{
+  HSM2model *model = (HSM2model*)inModel;
+  HSM2instance *here;
+  /*
+   * grab initial conditions out of rhs array.   User specified, so use
+   * external nodes to get values
+   */
+
+  for ( ;model ;model = model->HSM2nextModel ) {
+    for ( here = model->HSM2instances; here ;here = here->HSM2nextInstance ) {
+      if (!here->HSM2_icVBS_Given) {
+	here->HSM2_icVBS = 
+	  *(ckt->CKTrhs + here->HSM2bNode) - 
+	  *(ckt->CKTrhs + here->HSM2sNode);
+      }
+      if (!here->HSM2_icVDS_Given) {
+	here->HSM2_icVDS = 
+	  *(ckt->CKTrhs + here->HSM2dNode) - 
+	  *(ckt->CKTrhs + here->HSM2sNode);
+      }
+      if (!here->HSM2_icVGS_Given) {
+	here->HSM2_icVGS = 
+	  *(ckt->CKTrhs + here->HSM2gNode) - 
+	  *(ckt->CKTrhs + here->HSM2sNode);
+      }
+    }
+  }
+  return(OK);
+}
+

src/spicelib/devices/hisim2/hsm2itf.h

@@ -0,0 +1,100 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2itf.h
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#ifdef DEV_hisim2
+
+#ifndef DEV_HISIM2
+#define DEV_HISIM2
+
+#include "hsm2ext.h"
+
+extern IFparm HSM2pTable[ ];
+extern IFparm HSM2mPTable[ ];
+extern char *HSM2names[ ];
+extern int HSM2pTSize;
+extern int HSM2mPTSize;
+extern int HSM2nSize;
+extern int HSM2iSize;
+extern int HSM2mSize;
+
+SPICEdev HSM2info = {
+  {   "HiSIM2",
+      "Hiroshima University STARC IGFET Model 2.5.1",
+      
+      &HSM2nSize,
+      &HSM2nSize,
+      HSM2names,
+
+      &HSM2pTSize,
+      HSM2pTable,
+      
+      &HSM2mPTSize,
+      HSM2mPTable,
+
+  },
+
+  HSM2param,
+  HSM2mParam,
+  HSM2load,
+  HSM2setup,
+  NULL,
+  HSM2setup,
+  HSM2temp,
+  HSM2trunc,
+  NULL,
+  HSM2acLoad,
+  NULL,
+  HSM2destroy,
+#ifdef DELETES
+  HSM2mDelete,
+  HSM2delete, 
+#else /* DELETES */
+  NULL,
+  NULL,
+#endif /* DELETES */
+  HSM2getic,
+  HSM2ask,
+  HSM2mAsk,
+#ifdef AN_pz
+  HSM2pzLoad,
+#else /* AN_pz */
+  NULL,
+#endif /* AN_pz */
+#ifdef NEWCONV
+  HSM2convTest,
+#else /* NEWCONV */
+  NULL,
+#endif /* NEWCONV */
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+
+#ifdef AN_noise
+  HSM2noise,
+#else /* AN_noise */
+  NULL,
+#endif /* AN_noise */
+
+  &HSM2iSize,
+  &HSM2mSize
+
+};
+
+#endif
+#endif

src/spicelib/devices/hisim2/hsm2mdel.c

@@ -0,0 +1,53 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2mdel.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "util.h"
+#include "hsm2def.h"
+#include "sperror.h"
+#include "suffix.h"
+
+int HSM2mDelete(inModel,modname,kill)
+     GENmodel **inModel;
+     IFuid modname;
+     GENmodel *kill;
+{
+  HSM2model **model = (HSM2model**)inModel;
+  HSM2model *modfast = (HSM2model*)kill;
+  HSM2instance *here;
+  HSM2instance *prev = NULL;
+  HSM2model **oldmod;
+
+  oldmod = model;
+  for ( ;*model ;model = &((*model)->HSM2nextModel) ) {
+    if ( (*model)->HSM2modName == modname || 
+	 (modfast && *model == modfast) ) goto delgot;
+    oldmod = model;
+  }
+  return(E_NOMOD);
+
+ delgot:
+  *oldmod = (*model)->HSM2nextModel; /* cut deleted device out of list */
+  for ( here = (*model)->HSM2instances ; 
+	here ;here = here->HSM2nextInstance ) {
+    if (prev) FREE(prev);
+    prev = here;
+  }
+  if (prev) FREE(prev);
+  FREE(*model);
+  return(OK);
+}
+

src/spicelib/devices/hisim2/hsm2noi.c

@@ -0,0 +1,319 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2noi.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include <math.h>
+#include "hsm2def.h"
+#include "cktdefs.h"
+#include "fteconst.h"
+#include "iferrmsg.h"
+#include "noisedef.h"
+#include "util.h"
+#include "suffix.h"
+#include "const.h"  /* jwan */
+
+/*
+ * HSM2noise (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 HSM2noise (mode, operation, inModel, ckt, data, OnDens)
+     int mode, operation;
+     GENmodel *inModel;
+     CKTcircuit *ckt;
+     register Ndata *data;
+     double *OnDens;
+{
+  register HSM2model *model = (HSM2model *)inModel;
+  register HSM2instance *here;
+  char name[N_MXVLNTH];
+  double tempOnoise;
+  double tempInoise;
+  double noizDens[HSM2NSRCS];
+  double lnNdens[HSM2NSRCS];
+  register int i;
+  double R = 0.0 , G = 0.0 ;
+  double TTEMP = 0.0 ;
+
+  /* define the names of the noise sources */
+  static char * HSM2nNames[HSM2NSRCS] = {
+    /* Note that we have to keep the order
+       consistent with the index definitions 
+       in hsm2defs.h */
+    ".rd",              /* noise due to rd */
+    ".rs",              /* noise due to rs */
+    ".id",              /* noise due to id */
+    ".1ovf",            /* flicker (1/f) noise */
+    ".igs",             /* shot noise due to Igs */
+    ".igd",             /* shot noise due to Igd */
+    ".igb",             /* shot noise due to Igb */
+    ".ign",             /* induced gate noise component at the drain node */
+    ""                  /* total transistor noise */
+  };
+  
+  for ( ;model != NULL; model = model->HSM2nextModel ) {
+    for ( here = model->HSM2instances; here != NULL;
+	  here = here->HSM2nextInstance ) {
+      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 < HSM2NSRCS; i++ ) { 
+	      (void) sprintf(name, "onoise.%s%s", 
+			     (char *)here->HSM2name, HSM2nNames[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, (GENERIC **) NULL);
+	    }
+	    break;
+	  case INT_NOIZ:
+	    for ( i = 0; i < HSM2NSRCS; i++ ) {
+	      (void) sprintf(name, "onoise_total.%s%s", 
+			     (char *)here->HSM2name, HSM2nNames[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, (GENERIC **) NULL);
+	      
+	      (void) sprintf(name, "inoise_total.%s%s", 
+			     (char *)here->HSM2name, HSM2nNames[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, (GENERIC **)NULL);
+	    }
+	    break;
+	  }
+	}
+	break;
+      case N_CALC:
+	switch (mode) {
+	case N_DENS:
+
+	  /* temperature */
+	  TTEMP = ckt->CKTtemp ;
+	  if ( here->HSM2_temp_Given ) TTEMP = here->HSM2_temp ;
+	  if ( here->HSM2_dtemp_Given ) {
+	    TTEMP = TTEMP + here->HSM2_dtemp ;
+	  }
+
+         /* rs/rd thermal noise */
+         if ( model->HSM2_corsrd < 0 ) {
+           NevalSrc(&noizDens[HSM2RDNOIZ], (double*) NULL,
+                    ckt, N_GAIN,
+                    here->HSM2dNodePrime, here->HSM2dNode,
+                    (double) 0.0);
+           noizDens[HSM2RDNOIZ] *= 4 * CONSTboltz * TTEMP * here->HSM2drainConductance ;
+	   lnNdens[HSM2RDNOIZ] = log( MAX(noizDens[HSM2RDNOIZ],N_MINLOG) ) ;
+
+           NevalSrc(&noizDens[HSM2RSNOIZ], (double*) NULL,
+                    ckt, N_GAIN,
+                    here->HSM2sNodePrime, here->HSM2sNode,
+                    (double) 0.0);
+           noizDens[HSM2RSNOIZ] *= 4 * CONSTboltz * TTEMP * here->HSM2sourceConductance ;
+	   lnNdens[HSM2RSNOIZ] = log( MAX(noizDens[HSM2RSNOIZ],N_MINLOG) ) ;
+
+           /*
+           NevalSrc(&noizDens[HSM2RDNOIZ], &lnNdens[HSM2RDNOIZ],
+		     ckt, THERMNOISE,
+		     here->HSM2dNodePrime, here->HSM2dNode,
+		     here->HSM2_weff / model->HSM2_rsh);
+	    
+	    NevalSrc(&noizDens[HSM2RSNOIZ], &lnNdens[HSM2RSNOIZ], 
+		     ckt, THERMNOISE,
+		     here->HSM2sNodePrime, here->HSM2sNode,
+		     here->HSM2_weff / model->HSM2_rsh);
+	    */
+	  } else {
+	    noizDens[HSM2RDNOIZ] = 0e0 ;
+	    lnNdens[HSM2RDNOIZ] = N_MINLOG ;
+	    noizDens[HSM2RSNOIZ] = 0e0 ;
+	    lnNdens[HSM2RSNOIZ] = N_MINLOG ;
+	  }
+
+	  /* channel thermal noise */
+	  switch( model->HSM2_noise ) {
+	  case 1:
+           /* HiSIM2 model */
+         if ( model->HSM2_corsrd <= 0 || here->HSM2internalGd <= 0.0 ) {
+           G = here->HSM2_noithrml ;
+         } else {
+           R = 0.0 , G = 0.0 ;
+           if ( here->HSM2_noithrml > 0.0 ) R += 1.0 / here->HSM2_noithrml ;
+           if ( here->HSM2internalGd > 0.0 ) R += 1.0 / here->HSM2internalGd ;
+           if ( here->HSM2internalGs > 0.0 ) R += 1.0 / here->HSM2internalGs ;
+           if ( R > 0.0 ) G = 1.0 / R ;
+         }
+           NevalSrc(&noizDens[HSM2IDNOIZ], (double*) NULL,
+                    ckt, N_GAIN,
+                    here->HSM2dNodePrime, here->HSM2sNodePrime,
+                    (double) 0.0);
+           noizDens[HSM2IDNOIZ] *= 4 * CONSTboltz * TTEMP * G ;
+           lnNdens[HSM2IDNOIZ] = log( MAX(noizDens[HSM2IDNOIZ],N_MINLOG) );
+           break;
+         }
+
+         /* flicker noise */
+         NevalSrc(&noizDens[HSM2FLNOIZ], (double*) NULL,
+                  ckt, N_GAIN,
+                  here->HSM2dNodePrime, here->HSM2sNodePrime,
+                  (double) 0.0);
+         switch ( model->HSM2_noise ) {
+         case 1:
+           /* HiSIM model */
+           noizDens[HSM2FLNOIZ] *= here->HSM2_noiflick / pow(data->freq, model->HSM2_falph) ;
+           break;
+         }
+         lnNdens[HSM2FLNOIZ] = log(MAX(noizDens[HSM2FLNOIZ], N_MINLOG));
+
+         /* shot noise */
+	 NevalSrc(&noizDens[HSM2IGSNOIZ],
+		  &lnNdens[HSM2IGSNOIZ], ckt, SHOTNOISE,
+		  here->HSM2gNodePrime, here->HSM2sNodePrime,
+		  here->HSM2_igs);
+	 NevalSrc(&noizDens[HSM2IGDNOIZ],
+		  &lnNdens[HSM2IGDNOIZ], ckt, SHOTNOISE,
+		  here->HSM2gNodePrime, here->HSM2dNodePrime,
+		  here->HSM2_igd);
+	 NevalSrc(&noizDens[HSM2IGBNOIZ],
+		  &lnNdens[HSM2IGBNOIZ], ckt, SHOTNOISE,
+		  here->HSM2gNodePrime, here->HSM2bNodePrime,
+		  here->HSM2_igb);
+
+	  /* induced gate noise */
+	  switch ( model->HSM2_noise ) {
+	  case 1:
+	    /* HiSIM model */
+	    NevalSrc(&noizDens[HSM2IGNOIZ], (double*) NULL,
+		     ckt, N_GAIN, 
+		     here->HSM2dNodePrime, here->HSM2sNodePrime, 
+		     (double) 0.0);
+	    noizDens[HSM2IGNOIZ] *= here->HSM2_noiigate * here->HSM2_noicross * here->HSM2_noicross * data->freq * data->freq;
+	    lnNdens[HSM2IGNOIZ] = log(MAX(noizDens[HSM2IGNOIZ], N_MINLOG));
+	    break;
+	  }
+
+	  /* total */
+	  noizDens[HSM2TOTNOIZ] = noizDens[HSM2RDNOIZ] + noizDens[HSM2RSNOIZ]
+	    + noizDens[HSM2IDNOIZ] + noizDens[HSM2FLNOIZ]
+	    + noizDens[HSM2IGSNOIZ] + noizDens[HSM2IGDNOIZ] + noizDens[HSM2IGBNOIZ]
+	    + noizDens[HSM2IGNOIZ];
+	  lnNdens[HSM2TOTNOIZ] = log(MAX(noizDens[HSM2TOTNOIZ], N_MINLOG));
+/*       printf("f %e Sid %.16e Srd %.16e Srs %.16e Sflick %.16e Stherm %.16e Sign %.16e\n", */
+/*              data->freq,noizDens[HSM2TOTNOIZ],noizDens[HSM2RDNOIZ],noizDens[HSM2RSNOIZ],noizDens[HSM2FLNOIZ],noizDens[HSM2IDNOIZ],noizDens[HSM2IGNOIZ]); */
+	  
+	  *OnDens += noizDens[HSM2TOTNOIZ];
+	  
+	  if ( data->delFreq == 0.0 ) {
+	    /* if we haven't done any previous 
+	       integration, we need to initialize our
+	       "history" variables.
+	    */
+	    
+	    for ( i = 0; i < HSM2NSRCS; i++ ) 
+	      here->HSM2nVar[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 < HSM2NSRCS; i++) {
+		here->HSM2nVar[OUTNOIZ][i] = 0.0;
+		here->HSM2nVar[INNOIZ][i] = 0.0;
+	      }
+	    }
+	  }
+	  else {
+	    /* data->delFreq != 0.0,
+	       we have to integrate.
+	    */
+	    for ( i = 0; i < HSM2NSRCS; i++ ) {
+	      if ( i != HSM2TOTNOIZ ) {
+		tempOnoise = 
+		  Nintegrate(noizDens[i], lnNdens[i],
+			     here->HSM2nVar[LNLSTDENS][i], data);
+		tempInoise = 
+		  Nintegrate(noizDens[i] * data->GainSqInv, 
+			     lnNdens[i] + data->lnGainInv,
+			     here->HSM2nVar[LNLSTDENS][i] + data->lnGainInv,
+			     data);
+		here->HSM2nVar[LNLSTDENS][i] = lnNdens[i];
+		data->outNoiz += tempOnoise;
+		data->inNoise += tempInoise;
+		if ( ((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0 ) {
+		  here->HSM2nVar[OUTNOIZ][i] += tempOnoise;
+		  here->HSM2nVar[OUTNOIZ][HSM2TOTNOIZ] += tempOnoise;
+		  here->HSM2nVar[INNOIZ][i] += tempInoise;
+		  here->HSM2nVar[INNOIZ][HSM2TOTNOIZ] += tempInoise;
+		}
+	      }
+	    }
+	  }
+	  if ( data->prtSummary ) {
+	    for (i = 0; i < HSM2NSRCS; 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 < HSM2NSRCS; i++ ) {
+	      data->outpVector[data->outNumber++] = here->HSM2nVar[OUTNOIZ][i];
+	      data->outpVector[data->outNumber++] = here->HSM2nVar[INNOIZ][i];
+	    }
+	  }
+	  break;
+	}
+	break;
+      case N_CLOSE:
+	/* do nothing, the main calling routine will close */
+	return (OK);
+	break;   /* the plots */
+      }       /* switch (operation) */
+    }    /* for here */
+  }    /* for model */
+  
+  return(OK);
+}
+
+
+

src/spicelib/devices/hisim2/hsm2par.c

@@ -0,0 +1,179 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2par.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "ifsim.h"
+#include "hsm2def.h"
+#include "util.h"
+#include "sperror.h"
+#include "suffix.h"
+
+int HSM2param(param,value,inst,select)
+     int param;
+     IFvalue *value;
+     GENinstance *inst;
+     IFvalue *select;
+{
+  HSM2instance *here = (HSM2instance*)inst;
+  switch (param) {
+  case HSM2_W:
+    here->HSM2_w = value->rValue;
+    here->HSM2_w_Given = TRUE;
+    break;
+  case HSM2_L:
+    here->HSM2_l = value->rValue;
+    here->HSM2_l_Given = TRUE;
+    break;
+  case HSM2_AS:
+    here->HSM2_as = value->rValue;
+    here->HSM2_as_Given = TRUE;
+    break;
+  case HSM2_AD:
+    here->HSM2_ad = value->rValue;
+    here->HSM2_ad_Given = TRUE;
+    break;
+  case HSM2_PS:
+    here->HSM2_ps = value->rValue;
+    here->HSM2_ps_Given = TRUE;
+    break;
+  case HSM2_PD:
+    here->HSM2_pd = value->rValue;
+    here->HSM2_pd_Given = TRUE;
+    break;
+  case HSM2_NRS:
+    here->HSM2_nrs = value->rValue;
+    here->HSM2_nrs_Given = TRUE;
+    break;
+  case HSM2_NRD:
+    here->HSM2_nrd = value->rValue;
+    here->HSM2_nrd_Given = TRUE;
+    break;
+  case HSM2_TEMP:
+    here->HSM2_temp = value->rValue;
+    here->HSM2_temp_Given = TRUE;
+    break;
+  case HSM2_DTEMP:
+    here->HSM2_dtemp = value->rValue;
+    here->HSM2_dtemp_Given = TRUE;
+    break;
+  case HSM2_OFF:
+    here->HSM2_off = value->iValue;
+    break;
+  case HSM2_IC_VBS:
+    here->HSM2_icVBS = value->rValue;
+    here->HSM2_icVBS_Given = TRUE;
+    break;
+  case HSM2_IC_VDS:
+    here->HSM2_icVDS = value->rValue;
+    here->HSM2_icVDS_Given = TRUE;
+    break;
+  case HSM2_IC_VGS:
+    here->HSM2_icVGS = value->rValue;
+    here->HSM2_icVGS_Given = TRUE;
+    break;
+  case HSM2_IC:
+    switch (value->v.numValue) {
+    case 3:
+      here->HSM2_icVBS = *(value->v.vec.rVec + 2);
+      here->HSM2_icVBS_Given = TRUE;
+    case 2:
+      here->HSM2_icVGS = *(value->v.vec.rVec + 1);
+      here->HSM2_icVGS_Given = TRUE;
+    case 1:
+      here->HSM2_icVDS = *(value->v.vec.rVec);
+      here->HSM2_icVDS_Given = TRUE;
+      break;
+    default:
+      return(E_BADPARM);
+    }
+    break;
+  case  HSM2_CORBNET: 
+    here->HSM2_corbnet = value->iValue;
+    here->HSM2_corbnet_Given = TRUE;
+    break;
+  case  HSM2_RBPB:
+    here->HSM2_rbpb = value->rValue;
+    here->HSM2_rbpb_Given = TRUE;
+    break;
+  case  HSM2_RBPD:
+    here->HSM2_rbpd = value->rValue;
+    here->HSM2_rbpd_Given = TRUE;
+    break;
+  case  HSM2_RBPS:
+    here->HSM2_rbps = value->rValue;
+    here->HSM2_rbps_Given = TRUE;
+    break;
+  case  HSM2_RBDB:
+    here->HSM2_rbdb = value->rValue;
+    here->HSM2_rbdb_Given = TRUE;
+    break;
+  case  HSM2_RBSB:
+    here->HSM2_rbsb = value->rValue;
+    here->HSM2_rbsb_Given = TRUE;
+    break;
+  case  HSM2_CORG: 
+    here->HSM2_corg = value->iValue;
+    here->HSM2_corg_Given = TRUE;
+    break;
+/*   case  HSM2_RSHG: */
+/*     here->HSM2_rshg = value->rValue; */
+/*     here->HSM2_rshg_Given = TRUE; */
+/*     break; */
+  case  HSM2_NGCON:
+    here->HSM2_ngcon = value->rValue;
+    here->HSM2_ngcon_Given = TRUE;
+    break;
+  case  HSM2_XGW:
+    here->HSM2_xgw = value->rValue;
+    here->HSM2_xgw_Given = TRUE;
+    break;
+  case  HSM2_XGL:
+    here->HSM2_xgl = value->rValue;
+    here->HSM2_xgl_Given = TRUE;
+    break;
+  case  HSM2_NF:
+    here->HSM2_nf = value->rValue;
+    here->HSM2_nf_Given = TRUE;
+    break;
+  case  HSM2_SA:
+    here->HSM2_sa = value->rValue;
+    here->HSM2_sa_Given = TRUE;
+    break;
+  case  HSM2_SB:
+    here->HSM2_sb = value->rValue;
+    here->HSM2_sb_Given = TRUE;
+    break;
+  case  HSM2_SD:
+    here->HSM2_sd = value->rValue;
+    here->HSM2_sd_Given = TRUE;
+    break;
+  case  HSM2_NSUBCDFM:
+    here->HSM2_nsubcdfm = value->rValue;
+    here->HSM2_nsubcdfm_Given = TRUE;
+    break;
+  case  HSM2_MPHDFM:
+    here->HSM2_mphdfm = value->rValue;
+    here->HSM2_mphdfm_Given = TRUE;
+    break;
+  case  HSM2_M:
+    here->HSM2_m = value->rValue;
+    here->HSM2_m_Given = TRUE;
+    break;
+  default:
+    return(E_BADPARM);
+  }
+  return(OK);
+}

src/spicelib/devices/hisim2/hsm2pzld.c

@@ -0,0 +1,364 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2pzld.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "cktdefs.h"
+#include "complex.h"
+#include "sperror.h"
+#include "hsm2def.h"
+#include "suffix.h"
+
+int HSM2pzLoad(inModel,ckt,s)
+     GENmodel *inModel;
+     register CKTcircuit *ckt;
+     register SPcomplex *s;
+{
+  register HSM2model *model = (HSM2model*)inModel;
+  register HSM2instance *here;
+  double xcggb, xcgdb, xcgsb, xcgbb, xcbgb, xcbdb, xcbsb, xcbbb;
+  double xcdgb, xcddb, xcdsb, xcdbb, xcsgb, xcsdb, xcssb, xcsbb;
+  double xcdbdb, xcsbsb;
+  double gdpr, gspr, gds, gbd, gbs, capbd, capbs, FwdSum, RevSum, gm, gmbs;
+  double gjbd, gjbs, grg;
+  double cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cddb, cdgb, cdsb;
+  double gbspsp, gbbdp, gbbsp, gbspg, gbspb;
+  double gbspdp, gbdpdp, gbdpg, gbdpb, gbdpsp;
+  double gIbtotg, gIbtotd, gIbtots, gIbtotb;
+  double gIgtotg, gIgtotd, gIgtots, gIgtotb;
+  double gIdtotg, gIdtotd, gIdtots, gIdtotb;
+  double gIstotg, gIstotd, gIstots, gIstotb;
+  
+  for ( ;model != NULL ;model = model->HSM2nextModel ) {
+    for ( here = model->HSM2instances ;here!= NULL ;
+	  here = here->HSM2nextInstance ) {
+      if ( here->HSM2_mode >= 0 ) {
+	gm = here->HSM2_gm;
+	gmbs = here->HSM2_gmbs;
+	FwdSum = gm + gmbs;
+	RevSum = 0.0;
+	
+	gbbdp = -here->HSM2_gbds;
+	gbbsp = here->HSM2_gbds + here->HSM2_gbgs + here->HSM2_gbbs;
+	
+	gbdpg = here->HSM2_gbgs;
+	gbdpdp = here->HSM2_gbds;
+	gbdpb = here->HSM2_gbbs;
+	gbdpsp = -(gbdpg + gbdpdp + gbdpb);
+	
+	gbspg = 0.0;
+	gbspdp = 0.0;
+	gbspb = 0.0;
+	gbspsp = 0.0;
+
+	if (model->HSM2_coiigs) {
+	  gIbtotg = here->HSM2_gigbg;
+	  gIbtotd = here->HSM2_gigbd;
+	  gIbtots = here->HSM2_gigbs;
+	  gIbtotb = here->HSM2_gigbb;
+
+	  gIstotg = here->HSM2_gigsg;
+	  gIstotd = here->HSM2_gigsd;
+	  gIstots = here->HSM2_gigss;
+	  gIstotb = here->HSM2_gigsb;
+
+	  gIdtotg = here->HSM2_gigdg;
+	  gIdtotd = here->HSM2_gigdd;
+	  gIdtots = here->HSM2_gigds;
+	  gIdtotb = here->HSM2_gigdb;
+
+	}
+	else {
+	  gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0;
+	  gIstotg = gIstotd = gIstots = gIstotb = 0.0;
+	  gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0;
+	}
+
+	if (model->HSM2_coiigs) {
+	  gIgtotg = gIbtotg + gIstotg + gIdtotg;
+	  gIgtotd = gIbtotd + gIstotd + gIdtotd;
+	  gIgtots = gIbtots + gIstots + gIdtots;
+	  gIgtotb = gIbtotb + gIstotb + gIdtotb;
+	}
+	else
+	  gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0;
+
+	cggb = here->HSM2_cggb;
+	cgsb = here->HSM2_cgsb;
+	cgdb = here->HSM2_cgdb;
+	
+	cbgb = here->HSM2_cbgb;
+	cbsb = here->HSM2_cbsb;
+	cbdb = here->HSM2_cbdb;
+	
+	cdgb = here->HSM2_cdgb;
+	cdsb = here->HSM2_cdsb;
+	cddb = here->HSM2_cddb;
+	
+      }
+      else {
+	gm = -here->HSM2_gm;
+	gmbs = -here->HSM2_gmbs;
+	FwdSum = 0.0;
+	RevSum = -(gm + gmbs);
+	
+	gbbsp = -here->HSM2_gbds;
+	gbbdp = here->HSM2_gbds + here->HSM2_gbgs + here->HSM2_gbbs;
+	
+	gbdpg = 0.0;
+	gbdpsp = 0.0;
+	gbdpb = 0.0;
+	gbdpdp = 0.0;
+
+	if (model->HSM2_coiigs) {
+	  gIbtotg = here->HSM2_gigbg;
+	  gIbtotd = here->HSM2_gigbd;
+	  gIbtots = here->HSM2_gigbs;
+	  gIbtotb = here->HSM2_gigbb;
+
+	  gIstotg = here->HSM2_gigsg;
+	  gIstotd = here->HSM2_gigsd;
+	  gIstots = here->HSM2_gigss;
+	  gIstotb = here->HSM2_gigsb;
+
+	  gIdtotg = here->HSM2_gigdg;
+	  gIdtotd = here->HSM2_gigdd;
+	  gIdtots = here->HSM2_gigds;
+	  gIdtotb = here->HSM2_gigdb;
+	}
+	else {
+	  gIbtotg = gIbtotd = gIbtots = gIbtotb = 0.0;
+	  gIstotg = gIstotd = gIstots = gIstotb = 0.0;
+	  gIdtotg = gIdtotd = gIdtots = gIdtotb = 0.0;
+	}
+	
+	if (model->HSM2_coiigs) {
+	  gIgtotg = gIbtotg + gIstotg + gIdtotg;
+	  gIgtotd = gIbtotd + gIstotd + gIdtotd;
+	  gIgtots = gIbtots + gIstots + gIdtots;
+	  gIgtotb = gIbtotb + gIstotb + gIdtotb;
+	}
+	else
+	  gIgtotg = gIgtotd = gIgtots = gIgtotb = 0.0;
+	
+	gbspg = here->HSM2_gbgs;
+	gbspsp = here->HSM2_gbds;
+	gbspb = here->HSM2_gbbs;
+	gbspdp = -(gbspg + gbspsp + gbspb);
+	
+	cggb = here->HSM2_cggb;
+	cgsb = here->HSM2_cgdb;
+	cgdb = here->HSM2_cgsb;
+	  
+	cbgb = here->HSM2_cbgb;
+	cbsb = here->HSM2_cbdb;
+	cbdb = here->HSM2_cbsb;
+	
+	cdgb = -(here->HSM2_cdgb + cggb + cbgb);
+	cdsb = -(here->HSM2_cddb + cgsb + cbsb);
+	cddb = -(here->HSM2_cdsb + cgdb + cbdb);
+      }
+      
+      gdpr = here->HSM2drainConductance;
+      gspr = here->HSM2sourceConductance;
+      gds = here->HSM2_gds;
+      gbd = here->HSM2_gbd;
+      gbs = here->HSM2_gbs;
+      capbd = here->HSM2_capbd;
+      capbs = here->HSM2_capbs;
+      
+      xcdgb = cdgb;
+      xcddb = cddb + capbd;
+      xcdsb = cdsb;
+      xcdbb = -(xcdgb + xcddb + xcdsb);
+      if (here->HSM2_corbnet == 1) xcdbb += capbd;
+
+      xcsgb = -(cggb + cbgb + cdgb);
+      xcsdb = -(cgdb + cbdb + cddb);
+      xcssb = capbs - (cgsb + cbsb + cdsb);
+      xcsbb = -(xcsgb + xcsdb + xcssb); 
+      if (here->HSM2_corbnet == 1) xcsbb += capbs;
+
+      xcggb = cggb;
+      xcgdb = cgdb;
+      xcgsb = cgsb;
+      xcgbb = -(xcggb + xcgdb + xcgsb);
+
+      xcbgb = cbgb;
+      if (!here->HSM2_corbnet) {
+	xcbdb = cbdb - capbd;
+	xcbsb = cbsb - capbs;
+      } else {
+	xcbdb = cbdb;
+	xcbsb = cbsb;
+	xcdbdb = - capbd;
+	xcsbsb = - capbs;
+      }
+      xcbbb = -(xcbgb + xcbdb + xcbsb);
+
+      if (!here->HSM2_corbnet) {
+	gjbd = gbd;
+	gjbs = gbs;
+      } else
+	gjbd = gjbs = 0.0;
+
+      if (here->HSM2_corg == 1) {
+	grg = here->HSM2_grg;
+	*(here->HSM2GgPtr) += grg;
+	*(here->HSM2GPgPtr) -= grg;
+	*(here->HSM2GgpPtr) -= grg;
+
+	*(here->HSM2GPdpPtr ) += xcgdb * s->real;
+	*(here->HSM2GPdpPtr +1) += xcgdb * s->imag;
+	*(here->HSM2GPdpPtr) += grg + gIgtotd;
+	*(here->HSM2GPgpPtr ) += xcggb * s->real;
+	*(here->HSM2GPgpPtr +1) += xcggb * s->imag;
+	*(here->HSM2GPgpPtr) += gIgtotg;
+	*(here->HSM2GPspPtr ) += xcgsb * s->real;
+	*(here->HSM2GPspPtr +1) += xcgsb * s->imag;
+	*(here->HSM2GPspPtr) += gIgtots;
+	*(here->HSM2GPbpPtr ) += xcgbb * s->real;
+	*(here->HSM2GPbpPtr +1) += xcgbb * s->imag;
+	*(here->HSM2GPbpPtr) += gIgtotb;
+
+      } else {
+	*(here->HSM2GPdpPtr ) += xcgdb * s->real;
+	*(here->HSM2GPdpPtr +1) += xcgdb * s->imag;
+	*(here->HSM2GPdpPtr) += gIgtotd;
+	*(here->HSM2GPgpPtr ) += xcggb * s->real;
+	*(here->HSM2GPgpPtr +1) += xcggb * s->imag;
+	*(here->HSM2GPgpPtr) += gIgtotg;
+	*(here->HSM2GPspPtr ) += xcgsb * s->real;
+	*(here->HSM2GPspPtr +1) += xcgsb * s->imag;
+	*(here->HSM2GPspPtr) += gIgtots;
+	*(here->HSM2GPbpPtr ) += xcgbb * s->real;
+	*(here->HSM2GPbpPtr +1) += xcgbb * s->imag;
+	*(here->HSM2GPbpPtr) += gIgtotb;
+      }
+
+      *(here->HSM2DPdpPtr ) += xcddb * s->real;
+      *(here->HSM2DPdpPtr +1) += xcddb * s->imag;
+      *(here->HSM2DPdpPtr) += gdpr + gds + gbd + RevSum + gbdpdp - gIdtotd;
+      *(here->HSM2DPdPtr) -= gdpr;
+      *(here->HSM2DPgpPtr ) += xcdgb * s->real;
+      *(here->HSM2DPgpPtr +1) += xcdgb * s->imag;
+      *(here->HSM2DPgpPtr) += gm + gbdpg - gIdtotg;
+      *(here->HSM2DPspPtr ) += xcdsb * s->real;
+      *(here->HSM2DPspPtr +1) += xcdsb * s->imag;
+      *(here->HSM2DPspPtr) -= gds + FwdSum - gbdpsp + gIdtots;
+      *(here->HSM2DPbpPtr ) += xcdbb * s->real;
+      *(here->HSM2DPbpPtr +1) += xcdbb * s->imag;
+      *(here->HSM2DPbpPtr) -= gjbd - gmbs - gbdpb + gIdtotb;
+
+      *(here->HSM2DdpPtr) -= gdpr;
+      *(here->HSM2DdPtr) += gdpr;
+
+      *(here->HSM2SPdpPtr ) += xcsdb * s->real;
+      *(here->HSM2SPdpPtr +1) += xcsdb * s->imag;
+      *(here->HSM2SPdpPtr) -= gds + RevSum - gbspdp + gIstotd;
+      *(here->HSM2SPgpPtr ) += xcsgb * s->real;
+      *(here->HSM2SPgpPtr +1) += xcsgb * s->imag;
+      *(here->HSM2SPgpPtr) -= gm - gbspg + gIstotg;
+      *(here->HSM2SPspPtr ) += xcssb * s->real;
+      *(here->HSM2SPspPtr +1) += xcssb * s->imag;
+      *(here->HSM2SPspPtr) += gspr + gds + gbs + FwdSum + gbspsp - gIstots;
+      *(here->HSM2SPsPtr) -= gspr;
+      *(here->HSM2SPbpPtr ) += xcsbb * s->real;
+      *(here->HSM2SPbpPtr +1) += xcsbb * s->imag;
+      *(here->HSM2SPbpPtr) -= gjbs + gmbs - gbspb + gIstotb;
+
+      *(here->HSM2SspPtr) -= gspr;
+      *(here->HSM2SsPtr) += gspr;
+
+      *(here->HSM2BPdpPtr ) += xcbdb * s->real;
+      *(here->HSM2BPdpPtr +1) += xcbdb * s->imag;
+      *(here->HSM2BPdpPtr) -= gjbd - gbbdp + gIbtotd;
+      *(here->HSM2BPgpPtr ) += xcbgb * s->real;
+      *(here->HSM2BPgpPtr +1) += xcbgb * s->imag;
+      *(here->HSM2BPgpPtr) -= here->HSM2_gbgs + gIbtotg;
+      *(here->HSM2BPspPtr ) += xcbsb * s->real;
+      *(here->HSM2BPspPtr +1) += xcbsb * s->imag;
+      *(here->HSM2BPspPtr) -= gjbs - gbbsp + gIbtots;
+      *(here->HSM2BPbpPtr ) += xcbbb * s->real;
+      *(here->HSM2BPbpPtr +1) += xcbbb * s->imag;
+      *(here->HSM2BPbpPtr) += gjbd + gjbs - here->HSM2_gbbs - gIbtotb;
+
+      if (model->HSM2_cogidl) {
+	/* stamp gidl */
+	*(here->HSM2DPdpPtr) += here->HSM2_gigidlds;
+	*(here->HSM2DPgpPtr) += here->HSM2_gigidlgs;
+	*(here->HSM2DPspPtr) -= (here->HSM2_gigidlgs + 
+				 here->HSM2_gigidlds + here->HSM2_gigidlbs);
+	*(here->HSM2DPbpPtr) += here->HSM2_gigidlbs;
+	*(here->HSM2BPdpPtr) -= here->HSM2_gigidlds;
+	*(here->HSM2BPgpPtr) -= here->HSM2_gigidlgs;
+	*(here->HSM2BPspPtr) += (here->HSM2_gigidlgs + 
+				 here->HSM2_gigidlds + here->HSM2_gigidlbs);
+	*(here->HSM2BPbpPtr) -= here->HSM2_gigidlbs;
+	/* stamp gisl */
+	*(here->HSM2SPdpPtr) -= (here->HSM2_gigislsd + 
+				 here->HSM2_gigislgd + here->HSM2_gigislbd);
+	*(here->HSM2SPgpPtr) += here->HSM2_gigislgd;
+	*(here->HSM2SPspPtr) += here->HSM2_gigislsd;
+	*(here->HSM2SPbpPtr) += here->HSM2_gigislbd;
+	*(here->HSM2BPdpPtr) += (here->HSM2_gigislgd + 
+				 here->HSM2_gigislsd + here->HSM2_gigislbd);
+	*(here->HSM2BPgpPtr) -= here->HSM2_gigislgd;
+	*(here->HSM2BPspPtr) -= here->HSM2_gigislsd;
+	*(here->HSM2BPbpPtr) -= here->HSM2_gigislbd;
+      }
+
+      if (here->HSM2_corbnet) {
+	*(here->HSM2DPdbPtr ) += xcdbdb * s->real;
+	*(here->HSM2DPdbPtr +1) += xcdbdb * s->imag;
+	*(here->HSM2DPdbPtr) -= gbd;
+	*(here->HSM2SPsbPtr ) += xcsbsb * s->real;
+	*(here->HSM2SPsbPtr +1) += xcsbsb * s->imag;
+	*(here->HSM2SPsbPtr) -= gbs;
+
+	*(here->HSM2DBdpPtr ) += xcdbdb * s->real;
+	*(here->HSM2DBdpPtr +1) += xcdbdb * s->imag;
+	*(here->HSM2DBdpPtr) -= gbd;
+	*(here->HSM2DBdbPtr ) -= xcdbdb * s->real;
+	*(here->HSM2DBdbPtr +1) -= xcdbdb * s->imag;
+	*(here->HSM2DBdbPtr) += gbd + here->HSM2_grbpd + here->HSM2_grbdb;
+	*(here->HSM2DBbpPtr) -= here->HSM2_grbpd;
+	*(here->HSM2DBbPtr) -= here->HSM2_grbdb;
+
+	*(here->HSM2BPdbPtr) -= here->HSM2_grbpd;
+	*(here->HSM2BPbPtr) -= here->HSM2_grbpb;
+	*(here->HSM2BPsbPtr) -= here->HSM2_grbps;
+	*(here->HSM2BPbpPtr) += here->HSM2_grbpd + here->HSM2_grbps + here->HSM2_grbpb;
+
+	*(here->HSM2SBspPtr ) += xcsbsb * s->real;
+	*(here->HSM2SBspPtr +1) += xcsbsb * s->imag;
+	*(here->HSM2SBspPtr) -= gbs;
+	*(here->HSM2SBbpPtr) -= here->HSM2_grbps;
+	*(here->HSM2SBbPtr) -= here->HSM2_grbsb;
+	*(here->HSM2SBsbPtr ) -= xcsbsb * s->real;
+	*(here->HSM2SBsbPtr +1) -= xcsbsb * s->imag;
+	*(here->HSM2SBsbPtr) += gbs + here->HSM2_grbps + here->HSM2_grbsb;
+
+	*(here->HSM2BdbPtr) -= here->HSM2_grbdb;
+	*(here->HSM2BbpPtr) -= here->HSM2_grbpb;
+	*(here->HSM2BsbPtr) -= here->HSM2_grbsb;
+	*(here->HSM2BbPtr) += here->HSM2_grbsb + here->HSM2_grbdb + here->HSM2_grbpb;
+      }
+
+    }
+  }
+  return(OK);
+}
+

src/spicelib/devices/hisim2/hsm2set.c

@@ -0,0 +1,775 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2set.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "smpdefs.h"
+#include "cktdefs.h"
+#include "hsm2def.h"
+#include "hsm2evalenv.h"
+#include "util.h"
+#include "const.h"
+#include "sperror.h"
+#include "suffix.h"
+
+
+int HSM2setup(matrix,inModel,ckt,states)
+     register SMPmatrix *matrix;
+     register GENmodel *inModel;
+     register CKTcircuit *ckt;
+     int *states;
+     /* load the HSM2 device structure with those pointers needed later 
+      * for fast matrix loading 
+      */
+{
+  register HSM2model *model = (HSM2model*)inModel;
+  register HSM2instance *here;
+  int error;
+  CKTnode *tmp;
+  
+  /*  loop through all the HSM2 device models */
+  for ( ;model != NULL ;model = model->HSM2nextModel ) {
+    /* Default value Processing for HSM2 MOSFET Models */
+    if ( !model->HSM2_type_Given )
+      model->HSM2_type = NMOS ;
+    /***/
+    if ( !model->HSM2_info_Given ) model->HSM2_info = 0 ;
+    /*    if ( !model->HSM2_noise_Given) model->HSM2_noise = 1;*/
+    model->HSM2_noise = 1; /* allways noise is set to be 1 */
+
+    if ( !model->HSM2_version_Given) {
+        model->HSM2_version = 251; /* default 251 */
+	printf("           251 is selected for VERSION. (default) \n");
+    } else {
+      if (model->HSM2_version != 251) {
+	model->HSM2_version = 251; /* default 251 */
+	printf("           251 is only available for VERSION. \n");
+	printf("           251 is selected for VERSION. (default) \n");
+      } else {
+	printf("           %d is selected for VERSION \n", (int)model->HSM2_version);
+      }
+    }
+
+    if ( !model->HSM2_corsrd_Given     ) model->HSM2_corsrd     = 0 ;
+    if ( !model->HSM2_corg_Given       ) model->HSM2_corg       = 0 ;
+    if ( !model->HSM2_coiprv_Given     ) model->HSM2_coiprv     = 1 ;
+    if ( !model->HSM2_copprv_Given     ) model->HSM2_copprv     = 1 ;
+    if ( !model->HSM2_coadov_Given     ) model->HSM2_coadov     = 1 ;
+    if ( !model->HSM2_coisub_Given     ) model->HSM2_coisub     = 0 ;
+    if ( !model->HSM2_coiigs_Given     ) model->HSM2_coiigs     = 0 ;
+    if ( !model->HSM2_cogidl_Given     ) model->HSM2_cogidl     = 0 ;
+    if ( !model->HSM2_coovlp_Given     ) model->HSM2_coovlp     = 1 ;
+    if ( !model->HSM2_coflick_Given    ) model->HSM2_coflick    = 0 ;
+    if ( !model->HSM2_coisti_Given     ) model->HSM2_coisti     = 0 ;
+    if ( !model->HSM2_conqs_Given      ) model->HSM2_conqs      = 0 ; /* QS (default) */
+    if ( !model->HSM2_cothrml_Given    ) model->HSM2_cothrml    = 0 ;
+    if ( !model->HSM2_coign_Given      ) model->HSM2_coign      = 0 ; /* induced gate noise */
+    if ( !model->HSM2_codfm_Given      ) model->HSM2_codfm      = 0 ; /* DFM */
+    if ( !model->HSM2_corbnet_Given    ) model->HSM2_corbnet    = 0 ; 
+    else if ( model->HSM2_corbnet != 0 && model->HSM2_corbnet != 1 ) {
+      model->HSM2_corbnet = 0;
+      printf("warning(HiSIM2): CORBNET has been set to its default value: %d.\n", model->HSM2_corbnet);
+    }
+    if ( !model->HSM2_corecip_Given    ) model->HSM2_corecip    = 1 ;
+    if ( !model->HSM2_coqy_Given       ) model->HSM2_coqy       = 0 ;
+    if ( !model->HSM2_coqovsm_Given    ) model->HSM2_coqovsm    = 1 ;
+
+
+    if ( !model->HSM2_vmax_Given    ) model->HSM2_vmax    = 1.0e7 ;
+    if ( !model->HSM2_bgtmp1_Given  ) model->HSM2_bgtmp1  = 90.25e-6 ;
+    if ( !model->HSM2_bgtmp2_Given  ) model->HSM2_bgtmp2  = 1.0e-7 ;
+    if ( !model->HSM2_eg0_Given     ) model->HSM2_eg0     = 1.1785e0 ;
+    if ( !model->HSM2_tox_Given     ) model->HSM2_tox     = 3.0e-9 ;
+    if ( !model->HSM2_xld_Given     ) model->HSM2_xld     = 0.0 ;
+    if ( !model->HSM2_lover_Given   ) model->HSM2_lover   = 30e-9 ;
+    if ( !model->HSM2_ddltmax_Given ) model->HSM2_ddltmax = 10.0 ; /* Vdseff */
+    if ( !model->HSM2_ddltslp_Given ) model->HSM2_ddltslp = 0.0 ; /* Vdseff */
+    if ( !model->HSM2_ddltict_Given ) model->HSM2_ddltict = 10.0 ; /* Vdseff */
+    if ( !model->HSM2_vfbover_Given ) model->HSM2_vfbover = 0.0 ;
+    if ( !model->HSM2_nover_Given   ) model->HSM2_nover   = 1E19 ;
+    if ( !model->HSM2_xwd_Given     ) model->HSM2_xwd     = 0.0 ;
+
+    if ( !model->HSM2_xl_Given   ) model->HSM2_xl   = 0.0 ;
+    if ( !model->HSM2_xw_Given   ) model->HSM2_xw   = 0.0 ;
+    if ( !model->HSM2_saref_Given   ) model->HSM2_saref   = 1e-6 ;
+    if ( !model->HSM2_sbref_Given   ) model->HSM2_sbref   = 1e-6 ;
+    if ( !model->HSM2_ll_Given   ) model->HSM2_ll   = 0.0 ;
+    if ( !model->HSM2_lld_Given  ) model->HSM2_lld  = 0.0 ;
+    if ( !model->HSM2_lln_Given  ) model->HSM2_lln  = 0.0 ;
+    if ( !model->HSM2_wl_Given   ) model->HSM2_wl   = 0.0 ;
+    if ( !model->HSM2_wl1_Given  ) model->HSM2_wl1  = 0.0 ;
+    if ( !model->HSM2_wl1p_Given ) model->HSM2_wl1p = 1.0 ;
+    if ( !model->HSM2_wl2_Given  ) model->HSM2_wl2  = 0.0 ;
+    if ( !model->HSM2_wl2p_Given ) model->HSM2_wl2p = 1.0 ;
+    if ( !model->HSM2_wld_Given  ) model->HSM2_wld  = 0.0 ;
+    if ( !model->HSM2_wln_Given  ) model->HSM2_wln  = 0.0 ;
+
+    if ( !model->HSM2_rsh_Given  ) model->HSM2_rsh  = 0.0 ;
+    if ( !model->HSM2_rshg_Given ) model->HSM2_rshg = 0.0 ;
+
+    if ( !model->HSM2_xqy_Given    ) model->HSM2_xqy   = 10e-9 ;
+    if ( !model->HSM2_xqy1_Given   ) model->HSM2_xqy1  = 0.0 ;
+    if ( !model->HSM2_xqy2_Given   ) model->HSM2_xqy2  = 2.0 ;
+    if ( !model->HSM2_qyrat_Given  ) model->HSM2_qyrat = 0.5 ;
+    if ( !model->HSM2_rs_Given     ) model->HSM2_rs    = 0.0 ;
+    if ( !model->HSM2_rd_Given     ) model->HSM2_rd    = 0.0 ;
+    if ( !model->HSM2_vfbc_Given   ) model->HSM2_vfbc  = -1.0 ;
+    if ( !model->HSM2_vbi_Given    ) model->HSM2_vbi   = 1.1 ;
+    if ( !model->HSM2_nsubc_Given  ) model->HSM2_nsubc = 5.0e17 ;
+    if ( !model->HSM2_parl2_Given  ) model->HSM2_parl2 = 10.0e-9 ;
+    if ( !model->HSM2_lp_Given     ) model->HSM2_lp    = 15.0e-9 ;
+    if ( !model->HSM2_nsubp_Given  ) model->HSM2_nsubp = 1.0e18 ;
+    if ( !model->HSM2_nsubpl_Given ) model->HSM2_nsubpl = 0.001 ; /* um */
+    if ( !model->HSM2_nsubpfac_Given ) model->HSM2_nsubpfac = 1.0 ;
+
+    if ( !model->HSM2_nsubpw_Given ) model->HSM2_nsubpw = 0.0 ;
+    if ( !model->HSM2_nsubpwp_Given ) model->HSM2_nsubpwp = 1.0 ;
+
+    if ( !model->HSM2_scp1_Given  ) model->HSM2_scp1 = 1.0 ;
+    if ( !model->HSM2_scp2_Given  ) model->HSM2_scp2 = 0.0 ;
+    if ( !model->HSM2_scp3_Given  ) model->HSM2_scp3 = 0.0 ;
+    if ( !model->HSM2_sc1_Given   ) model->HSM2_sc1  = 1.0 ;
+    if ( !model->HSM2_sc2_Given   ) model->HSM2_sc2  = 0.0 ;
+    if ( !model->HSM2_sc3_Given   ) model->HSM2_sc3  = 0.0 ;
+    if ( !model->HSM2_sc4_Given   ) model->HSM2_sc4  = 0.0 ;
+    if ( !model->HSM2_pgd1_Given  ) model->HSM2_pgd1 = 0.0 ;
+    if ( !model->HSM2_pgd2_Given  ) model->HSM2_pgd2 = 0.3 ;
+    if ( !model->HSM2_pgd4_Given  ) model->HSM2_pgd4 = 0.0 ;
+
+    if ( !model->HSM2_ndep_Given   ) model->HSM2_ndep   = 1.0 ;
+    if ( !model->HSM2_ndepl_Given  ) model->HSM2_ndepl  = 0.0 ;
+    if ( !model->HSM2_ndeplp_Given ) model->HSM2_ndeplp = 1.0 ;
+    if ( !model->HSM2_ndepw_Given  ) model->HSM2_ndepw  = 0.0 ;
+    if ( !model->HSM2_ndepwp_Given ) model->HSM2_ndepwp = 1.0 ;
+    if ( !model->HSM2_ninv_Given   ) model->HSM2_ninv   = 0.5 ;
+    if ( !model->HSM2_ninvd_Given  ) model->HSM2_ninvd  = 0.0 ;
+    if ( !model->HSM2_muecb0_Given ) model->HSM2_muecb0 = 1.0e3 ;
+    if ( !model->HSM2_muecb1_Given ) model->HSM2_muecb1 = 100.0 ;
+    if ( !model->HSM2_mueph0_Given ) model->HSM2_mueph0 = 300.0e-3 ;
+    if ( !model->HSM2_mueph1_Given ) {
+      if (model->HSM2_type == NMOS) model->HSM2_mueph1 = 25.0e3 ;
+      else model->HSM2_mueph1 = 9.0e3 ;
+    }
+    if ( !model->HSM2_muephw_Given ) model->HSM2_muephw = 0.0 ;
+    if ( !model->HSM2_muepwp_Given ) model->HSM2_muepwp = 1.0 ;
+    if ( !model->HSM2_muepwd_Given ) model->HSM2_muepwd = 0.0 ;
+    if ( !model->HSM2_muephl_Given ) model->HSM2_muephl = 0.0 ;
+    if ( !model->HSM2_mueplp_Given ) model->HSM2_mueplp = 1.0 ;
+    if ( !model->HSM2_muepld_Given ) model->HSM2_muepld = 0.0 ;
+    if ( !model->HSM2_muephs_Given ) model->HSM2_muephs = 0.0 ;
+    if ( !model->HSM2_muepsp_Given ) model->HSM2_muepsp = 1.0 ;
+
+    if ( !model->HSM2_vtmp_Given  ) model->HSM2_vtmp  = 0.0 ;
+
+    if ( !model->HSM2_wvth0_Given ) model->HSM2_wvth0 = 0.0 ;
+
+    if ( !model->HSM2_muesr0_Given ) model->HSM2_muesr0 = 2.0 ;
+    if ( !model->HSM2_muesr1_Given ) model->HSM2_muesr1 = 1.0e15 ;
+    if ( !model->HSM2_muesrl_Given ) model->HSM2_muesrl = 0.0 ;
+    if ( !model->HSM2_muesrw_Given ) model->HSM2_muesrw = 0.0 ;
+    if ( !model->HSM2_mueswp_Given ) model->HSM2_mueswp = 1.0 ;
+    if ( !model->HSM2_mueslp_Given ) model->HSM2_mueslp = 1.0 ;
+
+    if ( !model->HSM2_muetmp_Given  ) model->HSM2_muetmp = 1.5 ;
+
+    if ( !model->HSM2_bb_Given ) {
+      if (model->HSM2_type == NMOS) model->HSM2_bb = 2.0 ;
+      else model->HSM2_bb = 1.0 ;
+    }
+
+    if ( !model->HSM2_sub1_Given  ) model->HSM2_sub1  = 10e0 ;
+    if ( !model->HSM2_sub2_Given  ) model->HSM2_sub2  = 25e0 ;
+    if ( !model->HSM2_svgs_Given  ) model->HSM2_svgs  = 0.8e0 ;
+    if ( !model->HSM2_svbs_Given  ) model->HSM2_svbs  = 0.5e0 ;
+    if ( !model->HSM2_svbsl_Given ) model->HSM2_svbsl = 0e0 ;
+    if ( !model->HSM2_svds_Given  ) model->HSM2_svds  = 0.8e0 ;
+    if ( !model->HSM2_slg_Given   ) model->HSM2_slg   = 30e-9 ;
+    if ( !model->HSM2_sub1l_Given ) model->HSM2_sub1l = 2.5e-3 ;
+    if ( !model->HSM2_sub2l_Given ) model->HSM2_sub2l = 2e-6 ;
+
+    if ( !model->HSM2_svgsl_Given  ) model->HSM2_svgsl  = 0.0 ;
+    if ( !model->HSM2_svgslp_Given ) model->HSM2_svgslp = 1.0 ;
+    if ( !model->HSM2_svgswp_Given ) model->HSM2_svgswp = 1.0 ;
+    if ( !model->HSM2_svgsw_Given  ) model->HSM2_svgsw  = 0.0 ;
+    if ( !model->HSM2_svbslp_Given ) model->HSM2_svbslp = 1.0 ;
+    if ( !model->HSM2_slgl_Given   ) model->HSM2_slgl   = 0.0 ;
+    if ( !model->HSM2_slglp_Given  ) model->HSM2_slglp  = 1.0 ;
+    if ( !model->HSM2_sub1lp_Given ) model->HSM2_sub1lp = 1.0 ; 
+
+    if ( !model->HSM2_nsti_Given      ) model->HSM2_nsti      = 5.0e17 ;
+    if ( !model->HSM2_wsti_Given      ) model->HSM2_wsti      = 0.0 ;
+    if ( !model->HSM2_wstil_Given     ) model->HSM2_wstil     = 0.0 ;
+    if ( !model->HSM2_wstilp_Given    ) model->HSM2_wstilp    = 1.0 ;
+    if ( !model->HSM2_wstiw_Given     ) model->HSM2_wstiw     = 0.0 ;
+    if ( !model->HSM2_wstiwp_Given    ) model->HSM2_wstiwp    = 1.0 ;
+    if ( !model->HSM2_scsti1_Given    ) model->HSM2_scsti1    = 0.0 ;
+    if ( !model->HSM2_scsti2_Given    ) model->HSM2_scsti2    = 0.0 ;
+    if ( !model->HSM2_vthsti_Given    ) model->HSM2_vthsti    = 0.0 ;
+    if ( !model->HSM2_vdsti_Given     ) model->HSM2_vdsti     = 0.0 ;
+    if ( !model->HSM2_muesti1_Given   ) model->HSM2_muesti1   = 0.0 ;
+    if ( !model->HSM2_muesti2_Given   ) model->HSM2_muesti2   = 0.0 ;
+    if ( !model->HSM2_muesti3_Given   ) model->HSM2_muesti3   = 1.0 ;
+    if ( !model->HSM2_nsubpsti1_Given ) model->HSM2_nsubpsti1 = 0.0 ;
+    if ( !model->HSM2_nsubpsti2_Given ) model->HSM2_nsubpsti2 = 0.0 ;
+    if ( !model->HSM2_nsubpsti3_Given ) model->HSM2_nsubpsti3 = 1.0 ;
+
+    if ( !model->HSM2_lpext_Given ) model->HSM2_lpext = 1.0e-50 ;
+    if ( !model->HSM2_npext_Given ) model->HSM2_npext = 5.0e17 ;
+    if ( !model->HSM2_npextw_Given ) model->HSM2_npextw = 0.0 ;
+    if ( !model->HSM2_npextwp_Given ) model->HSM2_npextwp = 1.0 ;
+    if ( !model->HSM2_scp21_Given ) model->HSM2_scp21 = 0.0 ;
+    if ( !model->HSM2_scp22_Given ) model->HSM2_scp22 = 0.0 ;
+    if ( !model->HSM2_bs1_Given   ) model->HSM2_bs1   = 0.0 ;
+    if ( !model->HSM2_bs2_Given   ) model->HSM2_bs2   = 0.9 ;
+
+    if ( !model->HSM2_tpoly_Given ) model->HSM2_tpoly = 200e-9 ;
+    if ( !model->HSM2_cgbo_Given  ) model->HSM2_cgbo  = 0.0 ;
+    if ( !model->HSM2_js0_Given   ) model->HSM2_js0   = 0.5e-6 ;
+    if ( !model->HSM2_js0sw_Given ) model->HSM2_js0sw = 0.0 ;
+    if ( !model->HSM2_nj_Given    ) model->HSM2_nj    = 1.0 ;
+    if ( !model->HSM2_njsw_Given  ) model->HSM2_njsw  = 1.0 ;
+    if ( !model->HSM2_xti_Given   ) model->HSM2_xti   = 2.0 ;
+    if ( !model->HSM2_cj_Given    ) model->HSM2_cj    = 5.0e-04 ;
+    if ( !model->HSM2_cjsw_Given  ) model->HSM2_cjsw  = 5.0e-10 ;
+    if ( !model->HSM2_cjswg_Given ) model->HSM2_cjswg = 5.0e-10 ;
+    if ( !model->HSM2_mj_Given    ) model->HSM2_mj    = 0.5e0 ;
+    if ( !model->HSM2_mjsw_Given  ) model->HSM2_mjsw  = 0.33e0 ;
+    if ( !model->HSM2_mjswg_Given ) model->HSM2_mjswg = 0.33e0 ;
+    if ( !model->HSM2_pb_Given    ) model->HSM2_pb    = 1.0e0 ;
+    if ( !model->HSM2_pbsw_Given  ) model->HSM2_pbsw  = 1.0e0 ;
+    if ( !model->HSM2_pbswg_Given ) model->HSM2_pbswg = 1.0e0 ;
+
+    if ( !model->HSM2_tcjbd_Given    ) model->HSM2_tcjbd    = 0.0 ; 
+    if ( !model->HSM2_tcjbs_Given    ) model->HSM2_tcjbs    = 0.0 ; 
+    if ( !model->HSM2_tcjbdsw_Given  ) model->HSM2_tcjbdsw  = 0.0 ; 
+    if ( !model->HSM2_tcjbssw_Given  ) model->HSM2_tcjbssw  = 0.0 ; 
+    if ( !model->HSM2_tcjbdswg_Given ) model->HSM2_tcjbdswg = 0.0 ; 
+    if ( !model->HSM2_tcjbsswg_Given ) model->HSM2_tcjbsswg = 0.0 ; 
+
+    if ( !model->HSM2_xti2_Given  ) model->HSM2_xti2  = 0.0e0 ;
+    if ( !model->HSM2_cisb_Given  ) model->HSM2_cisb  = 0.0e0 ;
+    if ( !model->HSM2_cvb_Given   ) model->HSM2_cvb   = 0.0e0 ;
+    if ( !model->HSM2_ctemp_Given ) model->HSM2_ctemp = 0.0e0 ;
+    if ( !model->HSM2_cisbk_Given ) model->HSM2_cisbk = 0.0e0 ;
+    if ( !model->HSM2_cvbk_Given  ) model->HSM2_cvbk  = 0.0e0 ;
+    if ( !model->HSM2_divx_Given  ) model->HSM2_divx  = 0.0e0 ;
+
+    if ( !model->HSM2_clm1_Given  ) model->HSM2_clm1 = 700.0e-3 ;
+    if ( !model->HSM2_clm2_Given  ) model->HSM2_clm2 = 2.0 ;
+    if ( !model->HSM2_clm3_Given  ) model->HSM2_clm3 = 1.0 ;
+    if ( !model->HSM2_clm5_Given   ) model->HSM2_clm5   = 1.0 ;
+    if ( !model->HSM2_clm6_Given   ) model->HSM2_clm6   = 0.0 ;
+    if ( !model->HSM2_vover_Given  ) model->HSM2_vover  = 0.3 ;
+    if ( !model->HSM2_voverp_Given ) model->HSM2_voverp = 0.3 ;
+    if ( !model->HSM2_wfc_Given    ) model->HSM2_wfc    = 0.0 ;
+    if ( !model->HSM2_nsubcw_Given ) model->HSM2_nsubcw = 0.0 ;
+    if ( !model->HSM2_nsubcwp_Given ) model->HSM2_nsubcwp = 1.0 ;
+    if ( !model->HSM2_nsubcmax_Given ) model->HSM2_nsubcmax = 5e18 ;
+
+    if ( !model->HSM2_qme1_Given   ) model->HSM2_qme1   = 0.0 ;
+    if ( !model->HSM2_qme2_Given   ) model->HSM2_qme2   = 0.0 ;
+    if ( !model->HSM2_qme3_Given   ) model->HSM2_qme3   = 0.0 ;
+
+    if ( !model->HSM2_vovers_Given  ) model->HSM2_vovers  = 0.0 ;
+    if ( !model->HSM2_voversp_Given ) model->HSM2_voversp = 0.0 ;
+
+    if ( !model->HSM2_gidl1_Given ) model->HSM2_gidl1 = 2e0 ;
+    if ( !model->HSM2_gidl2_Given ) model->HSM2_gidl2 = 3e7 ;
+    if ( !model->HSM2_gidl3_Given ) model->HSM2_gidl3 = 0.9e0 ;
+    if ( !model->HSM2_gidl4_Given ) model->HSM2_gidl4 = 0.0 ;
+    if ( !model->HSM2_gidl5_Given ) model->HSM2_gidl5 = 0.2e0 ;
+
+    if ( !model->HSM2_gleak1_Given ) model->HSM2_gleak1 = 50e0 ;
+    if ( !model->HSM2_gleak2_Given ) model->HSM2_gleak2 = 10e6 ;
+    if ( !model->HSM2_gleak3_Given ) model->HSM2_gleak3 = 60e-3 ;
+    if ( !model->HSM2_gleak4_Given ) model->HSM2_gleak4 = 4e0 ;
+    if ( !model->HSM2_gleak5_Given ) model->HSM2_gleak5 = 7.5e3 ;
+    if ( !model->HSM2_gleak6_Given ) model->HSM2_gleak6 = 250e-3 ;
+    if ( !model->HSM2_gleak7_Given ) model->HSM2_gleak7 = 1e-6 ;
+
+    if ( !model->HSM2_glksd1_Given  ) model->HSM2_glksd1  = 1.0e-15 ;
+    if ( !model->HSM2_glksd2_Given  ) model->HSM2_glksd2  = 5e6 ;
+    if ( !model->HSM2_glksd3_Given  ) model->HSM2_glksd3  = -5e6 ;
+    if ( !model->HSM2_glkb1_Given   ) model->HSM2_glkb1   = 5e-16 ;
+    if ( !model->HSM2_glkb2_Given   ) model->HSM2_glkb2   = 1e0 ;
+    if ( !model->HSM2_glkb3_Given   ) model->HSM2_glkb3   = 0e0 ;
+    if ( !model->HSM2_egig_Given    ) model->HSM2_egig    = 0e0 ;
+    if ( !model->HSM2_igtemp2_Given ) model->HSM2_igtemp2 = 0e0 ;
+    if ( !model->HSM2_igtemp3_Given ) model->HSM2_igtemp3 = 0e0 ;
+    if ( !model->HSM2_vzadd0_Given  ) model->HSM2_vzadd0  = 20.0e-3 ;
+    if ( !model->HSM2_pzadd0_Given  ) model->HSM2_pzadd0  = 20.0e-3 ;
+    if ( !model->HSM2_nftrp_Given   ) model->HSM2_nftrp   = 10e9 ;
+    if ( !model->HSM2_nfalp_Given   ) model->HSM2_nfalp   = 1.0e-19 ;
+    if ( !model->HSM2_falph_Given   ) model->HSM2_falph   = 1.0 ;
+    if ( !model->HSM2_cit_Given     ) model->HSM2_cit     = 0e0 ;
+
+    if ( !model->HSM2_kappa_Given ) model->HSM2_kappa = 3.90e0 ;
+    if ( !model->HSM2_cgso_Given  ) model->HSM2_cgso  = 0.0 ;
+    if ( !model->HSM2_cgdo_Given  ) model->HSM2_cgdo  = 0.0 ;
+
+
+    if ( !model->HSM2_vdiffj_Given ) model->HSM2_vdiffj = 0.6e-3 ;
+    if ( !model->HSM2_dly1_Given   ) model->HSM2_dly1   = 100.0e-12 ;
+    if ( !model->HSM2_dly2_Given   ) model->HSM2_dly2   = 0.7e0 ;
+    if ( !model->HSM2_dly3_Given   ) model->HSM2_dly3   = 0.8e-6 ;
+    if ( !model->HSM2_tnom_Given   ) model->HSM2_tnom   = 27.0 ; /* [C] */
+
+    if ( !model->HSM2_ovslp_Given  ) model->HSM2_ovslp = 2.1e-7 ;
+    if ( !model->HSM2_ovmag_Given  ) model->HSM2_ovmag = 0.6e0 ;
+
+    if ( !model->HSM2_gbmin_Given  ) model->HSM2_gbmin = 1.0e-12; /* in mho */
+    if ( !model->HSM2_rbpb_Given   ) model->HSM2_rbpb  = 50.0e0 ;
+    if ( !model->HSM2_rbpd_Given   ) model->HSM2_rbpd  = 50.0e0 ;
+    if ( !model->HSM2_rbps_Given   ) model->HSM2_rbps  = 50.0e0 ;
+    if ( !model->HSM2_rbdb_Given   ) model->HSM2_rbdb  = 50.0e0 ;
+    if ( !model->HSM2_rbsb_Given   ) model->HSM2_rbsb  = 50.0e0 ;
+
+    if ( !model->HSM2_ibpc1_Given  ) model->HSM2_ibpc1 = 0.0 ;
+    if ( !model->HSM2_ibpc2_Given  ) model->HSM2_ibpc2 = 0.0 ;
+
+    if ( !model->HSM2_mphdfm_Given ) model->HSM2_mphdfm = -0.3 ;
+
+
+    if ( !model->HSM2_ptl_Given ) model->HSM2_ptl = 0.0 ;
+    if ( !model->HSM2_ptp_Given ) model->HSM2_ptp = 3.5 ;
+    if ( !model->HSM2_pt2_Given ) model->HSM2_pt2 = 0.0 ;
+    if ( !model->HSM2_ptlp_Given ) model->HSM2_ptlp = 1.0 ;
+    if ( !model->HSM2_gdl_Given ) model->HSM2_gdl = 0.0 ;
+    if ( !model->HSM2_gdlp_Given ) model->HSM2_gdlp = 0.0 ;
+
+    if ( !model->HSM2_gdld_Given ) model->HSM2_gdld = 0.0 ;
+    if ( !model->HSM2_pt4_Given ) model->HSM2_pt4 = 0.0 ;
+    if ( !model->HSM2_pt4p_Given ) model->HSM2_pt4p = 1.0 ;
+    if ( !model->HSM2_muephl2_Given ) model->HSM2_muephl2 = 0.0 ;
+    if ( !model->HSM2_mueplp2_Given ) model->HSM2_mueplp2 = 1.0 ;
+    if ( !model->HSM2_nsubcw2_Given ) model->HSM2_nsubcw2 = 0.0 ;
+    if ( !model->HSM2_nsubcwp2_Given ) model->HSM2_nsubcwp2 = 1.0 ;
+    if ( !model->HSM2_muephw2_Given ) model->HSM2_muephw2 = 0.0 ;
+    if ( !model->HSM2_muepwp2_Given ) model->HSM2_muepwp2 = 1.0 ;
+    if ( !model->HSM2_Vgsmin_Given ) model->HSM2_Vgsmin = -5.0 * model->HSM2_type ;
+    if ( !model->HSM2_sc3Vbs_Given ) model->HSM2_sc3Vbs =  0.0 ;
+    if ( !model->HSM2_byptol_Given ) model->HSM2_byptol =  0.0 ;
+    if ( !model->HSM2_muecb0lp_Given ) model->HSM2_muecb0lp = 0.0;
+    if ( !model->HSM2_muecb1lp_Given ) model->HSM2_muecb1lp = 0.0;
+
+    /* binning parameters */
+    if ( !model->HSM2_lmin_Given ) model->HSM2_lmin = 0.0 ;
+    if ( !model->HSM2_lmax_Given ) model->HSM2_lmax = 1.0 ;
+    if ( !model->HSM2_wmin_Given ) model->HSM2_wmin = 0.0 ;
+    if ( !model->HSM2_wmax_Given ) model->HSM2_wmax = 1.0 ;
+    if ( !model->HSM2_lbinn_Given ) model->HSM2_lbinn = 1.0 ;
+    if ( !model->HSM2_wbinn_Given ) model->HSM2_wbinn = 1.0 ;
+
+    /* Length dependence */
+    if ( !model->HSM2_lvmax_Given ) model->HSM2_lvmax = 0.0 ;
+    if ( !model->HSM2_lbgtmp1_Given ) model->HSM2_lbgtmp1 = 0.0 ;
+    if ( !model->HSM2_lbgtmp2_Given ) model->HSM2_lbgtmp2 = 0.0 ;
+    if ( !model->HSM2_leg0_Given ) model->HSM2_leg0 = 0.0 ;
+    if ( !model->HSM2_llover_Given ) model->HSM2_llover = 0.0 ;
+    if ( !model->HSM2_lvfbover_Given ) model->HSM2_lvfbover = 0.0 ;
+    if ( !model->HSM2_lnover_Given ) model->HSM2_lnover = 0.0 ;
+    if ( !model->HSM2_lwl2_Given ) model->HSM2_lwl2 = 0.0 ;
+    if ( !model->HSM2_lvfbc_Given ) model->HSM2_lvfbc = 0.0 ;
+    if ( !model->HSM2_lnsubc_Given ) model->HSM2_lnsubc = 0.0 ;
+    if ( !model->HSM2_lnsubp_Given ) model->HSM2_lnsubp = 0.0 ;
+    if ( !model->HSM2_lscp1_Given ) model->HSM2_lscp1 = 0.0 ;
+    if ( !model->HSM2_lscp2_Given ) model->HSM2_lscp2 = 0.0 ;
+    if ( !model->HSM2_lscp3_Given ) model->HSM2_lscp3 = 0.0 ;
+    if ( !model->HSM2_lsc1_Given ) model->HSM2_lsc1 = 0.0 ;
+    if ( !model->HSM2_lsc2_Given ) model->HSM2_lsc2 = 0.0 ;
+    if ( !model->HSM2_lsc3_Given ) model->HSM2_lsc3 = 0.0 ;
+    if ( !model->HSM2_lsc4_Given ) model->HSM2_lsc4 = 0.0 ;
+    if ( !model->HSM2_lpgd1_Given ) model->HSM2_lpgd1 = 0.0 ;
+    if ( !model->HSM2_lndep_Given ) model->HSM2_lndep = 0.0 ;
+    if ( !model->HSM2_lninv_Given ) model->HSM2_lninv = 0.0 ;
+    if ( !model->HSM2_lmuecb0_Given ) model->HSM2_lmuecb0 = 0.0 ;
+    if ( !model->HSM2_lmuecb1_Given ) model->HSM2_lmuecb1 = 0.0 ;
+    if ( !model->HSM2_lmueph1_Given ) model->HSM2_lmueph1 = 0.0 ;
+    if ( !model->HSM2_lvtmp_Given ) model->HSM2_lvtmp = 0.0 ;
+    if ( !model->HSM2_lwvth0_Given ) model->HSM2_lwvth0 = 0.0 ;
+    if ( !model->HSM2_lmuesr1_Given ) model->HSM2_lmuesr1 = 0.0 ;
+    if ( !model->HSM2_lmuetmp_Given ) model->HSM2_lmuetmp = 0.0 ;
+    if ( !model->HSM2_lsub1_Given ) model->HSM2_lsub1 = 0.0 ;
+    if ( !model->HSM2_lsub2_Given ) model->HSM2_lsub2 = 0.0 ;
+    if ( !model->HSM2_lsvds_Given ) model->HSM2_lsvds = 0.0 ;
+    if ( !model->HSM2_lsvbs_Given ) model->HSM2_lsvbs = 0.0 ;
+    if ( !model->HSM2_lsvgs_Given ) model->HSM2_lsvgs = 0.0 ;
+    if ( !model->HSM2_lnsti_Given ) model->HSM2_lnsti = 0.0 ;
+    if ( !model->HSM2_lwsti_Given ) model->HSM2_lwsti = 0.0 ;
+    if ( !model->HSM2_lscsti1_Given ) model->HSM2_lscsti1 = 0.0 ;
+    if ( !model->HSM2_lscsti2_Given ) model->HSM2_lscsti2 = 0.0 ;
+    if ( !model->HSM2_lvthsti_Given ) model->HSM2_lvthsti = 0.0 ;
+    if ( !model->HSM2_lmuesti1_Given ) model->HSM2_lmuesti1 = 0.0 ;
+    if ( !model->HSM2_lmuesti2_Given ) model->HSM2_lmuesti2 = 0.0 ;
+    if ( !model->HSM2_lmuesti3_Given ) model->HSM2_lmuesti3 = 0.0 ;
+    if ( !model->HSM2_lnsubpsti1_Given ) model->HSM2_lnsubpsti1 = 0.0 ;
+    if ( !model->HSM2_lnsubpsti2_Given ) model->HSM2_lnsubpsti2 = 0.0 ;
+    if ( !model->HSM2_lnsubpsti3_Given ) model->HSM2_lnsubpsti3 = 0.0 ;
+    if ( !model->HSM2_lcgso_Given ) model->HSM2_lcgso = 0.0 ;
+    if ( !model->HSM2_lcgdo_Given ) model->HSM2_lcgdo = 0.0 ;
+    if ( !model->HSM2_ljs0_Given ) model->HSM2_ljs0 = 0.0 ;
+    if ( !model->HSM2_ljs0sw_Given ) model->HSM2_ljs0sw = 0.0 ;
+    if ( !model->HSM2_lnj_Given ) model->HSM2_lnj = 0.0 ;
+    if ( !model->HSM2_lcisbk_Given ) model->HSM2_lcisbk = 0.0 ;
+    if ( !model->HSM2_lclm1_Given ) model->HSM2_lclm1 = 0.0 ;
+    if ( !model->HSM2_lclm2_Given ) model->HSM2_lclm2 = 0.0 ;
+    if ( !model->HSM2_lclm3_Given ) model->HSM2_lclm3 = 0.0 ;
+    if ( !model->HSM2_lwfc_Given ) model->HSM2_lwfc = 0.0 ;
+    if ( !model->HSM2_lgidl1_Given ) model->HSM2_lgidl1 = 0.0 ;
+    if ( !model->HSM2_lgidl2_Given ) model->HSM2_lgidl2 = 0.0 ;
+    if ( !model->HSM2_lgleak1_Given ) model->HSM2_lgleak1 = 0.0 ;
+    if ( !model->HSM2_lgleak2_Given ) model->HSM2_lgleak2 = 0.0 ;
+    if ( !model->HSM2_lgleak3_Given ) model->HSM2_lgleak3 = 0.0 ;
+    if ( !model->HSM2_lgleak6_Given ) model->HSM2_lgleak6 = 0.0 ;
+    if ( !model->HSM2_lglksd1_Given ) model->HSM2_lglksd1 = 0.0 ;
+    if ( !model->HSM2_lglksd2_Given ) model->HSM2_lglksd2 = 0.0 ;
+    if ( !model->HSM2_lglkb1_Given ) model->HSM2_lglkb1 = 0.0 ;
+    if ( !model->HSM2_lglkb2_Given ) model->HSM2_lglkb2 = 0.0 ;
+    if ( !model->HSM2_lnftrp_Given ) model->HSM2_lnftrp = 0.0 ;
+    if ( !model->HSM2_lnfalp_Given ) model->HSM2_lnfalp = 0.0 ;
+    if ( !model->HSM2_lvdiffj_Given ) model->HSM2_lvdiffj = 0.0 ;
+    if ( !model->HSM2_libpc1_Given ) model->HSM2_libpc1 = 0.0 ;
+    if ( !model->HSM2_libpc2_Given ) model->HSM2_libpc2 = 0.0 ;
+
+    /* Width dependence */
+    if ( !model->HSM2_wvmax_Given ) model->HSM2_wvmax = 0.0 ;
+    if ( !model->HSM2_wbgtmp1_Given ) model->HSM2_wbgtmp1 = 0.0 ;
+    if ( !model->HSM2_wbgtmp2_Given ) model->HSM2_wbgtmp2 = 0.0 ;
+    if ( !model->HSM2_weg0_Given ) model->HSM2_weg0 = 0.0 ;
+    if ( !model->HSM2_wlover_Given ) model->HSM2_wlover = 0.0 ;
+    if ( !model->HSM2_wvfbover_Given ) model->HSM2_wvfbover = 0.0 ;
+    if ( !model->HSM2_wnover_Given ) model->HSM2_wnover = 0.0 ;
+    if ( !model->HSM2_wwl2_Given ) model->HSM2_wwl2 = 0.0 ;
+    if ( !model->HSM2_wvfbc_Given ) model->HSM2_wvfbc = 0.0 ;
+    if ( !model->HSM2_wnsubc_Given ) model->HSM2_wnsubc = 0.0 ;
+    if ( !model->HSM2_wnsubp_Given ) model->HSM2_wnsubp = 0.0 ;
+    if ( !model->HSM2_wscp1_Given ) model->HSM2_wscp1 = 0.0 ;
+    if ( !model->HSM2_wscp2_Given ) model->HSM2_wscp2 = 0.0 ;
+    if ( !model->HSM2_wscp3_Given ) model->HSM2_wscp3 = 0.0 ;
+    if ( !model->HSM2_wsc1_Given ) model->HSM2_wsc1 = 0.0 ;
+    if ( !model->HSM2_wsc2_Given ) model->HSM2_wsc2 = 0.0 ;
+    if ( !model->HSM2_wsc3_Given ) model->HSM2_wsc3 = 0.0 ;
+    if ( !model->HSM2_wsc4_Given ) model->HSM2_wsc4 = 0.0 ;
+    if ( !model->HSM2_wpgd1_Given ) model->HSM2_wpgd1 = 0.0 ;
+    if ( !model->HSM2_wndep_Given ) model->HSM2_wndep = 0.0 ;
+    if ( !model->HSM2_wninv_Given ) model->HSM2_wninv = 0.0 ;
+    if ( !model->HSM2_wmuecb0_Given ) model->HSM2_wmuecb0 = 0.0 ;
+    if ( !model->HSM2_wmuecb1_Given ) model->HSM2_wmuecb1 = 0.0 ;
+    if ( !model->HSM2_wmueph1_Given ) model->HSM2_wmueph1 = 0.0 ;
+    if ( !model->HSM2_wvtmp_Given ) model->HSM2_wvtmp = 0.0 ;
+    if ( !model->HSM2_wwvth0_Given ) model->HSM2_wwvth0 = 0.0 ;
+    if ( !model->HSM2_wmuesr1_Given ) model->HSM2_wmuesr1 = 0.0 ;
+    if ( !model->HSM2_wmuetmp_Given ) model->HSM2_wmuetmp = 0.0 ;
+    if ( !model->HSM2_wsub1_Given ) model->HSM2_wsub1 = 0.0 ;
+    if ( !model->HSM2_wsub2_Given ) model->HSM2_wsub2 = 0.0 ;
+    if ( !model->HSM2_wsvds_Given ) model->HSM2_wsvds = 0.0 ;
+    if ( !model->HSM2_wsvbs_Given ) model->HSM2_wsvbs = 0.0 ;
+    if ( !model->HSM2_wsvgs_Given ) model->HSM2_wsvgs = 0.0 ;
+    if ( !model->HSM2_wnsti_Given ) model->HSM2_wnsti = 0.0 ;
+    if ( !model->HSM2_wwsti_Given ) model->HSM2_wwsti = 0.0 ;
+    if ( !model->HSM2_wscsti1_Given ) model->HSM2_wscsti1 = 0.0 ;
+    if ( !model->HSM2_wscsti2_Given ) model->HSM2_wscsti2 = 0.0 ;
+    if ( !model->HSM2_wvthsti_Given ) model->HSM2_wvthsti = 0.0 ;
+    if ( !model->HSM2_wmuesti1_Given ) model->HSM2_wmuesti1 = 0.0 ;
+    if ( !model->HSM2_wmuesti2_Given ) model->HSM2_wmuesti2 = 0.0 ;
+    if ( !model->HSM2_wmuesti3_Given ) model->HSM2_wmuesti3 = 0.0 ;
+    if ( !model->HSM2_wnsubpsti1_Given ) model->HSM2_wnsubpsti1 = 0.0 ;
+    if ( !model->HSM2_wnsubpsti2_Given ) model->HSM2_wnsubpsti2 = 0.0 ;
+    if ( !model->HSM2_wnsubpsti3_Given ) model->HSM2_wnsubpsti3 = 0.0 ;
+    if ( !model->HSM2_wcgso_Given ) model->HSM2_wcgso = 0.0 ;
+    if ( !model->HSM2_wcgdo_Given ) model->HSM2_wcgdo = 0.0 ;
+    if ( !model->HSM2_wjs0_Given ) model->HSM2_wjs0 = 0.0 ;
+    if ( !model->HSM2_wjs0sw_Given ) model->HSM2_wjs0sw = 0.0 ;
+    if ( !model->HSM2_wnj_Given ) model->HSM2_wnj = 0.0 ;
+    if ( !model->HSM2_wcisbk_Given ) model->HSM2_wcisbk = 0.0 ;
+    if ( !model->HSM2_wclm1_Given ) model->HSM2_wclm1 = 0.0 ;
+    if ( !model->HSM2_wclm2_Given ) model->HSM2_wclm2 = 0.0 ;
+    if ( !model->HSM2_wclm3_Given ) model->HSM2_wclm3 = 0.0 ;
+    if ( !model->HSM2_wwfc_Given ) model->HSM2_wwfc = 0.0 ;
+    if ( !model->HSM2_wgidl1_Given ) model->HSM2_wgidl1 = 0.0 ;
+    if ( !model->HSM2_wgidl2_Given ) model->HSM2_wgidl2 = 0.0 ;
+    if ( !model->HSM2_wgleak1_Given ) model->HSM2_wgleak1 = 0.0 ;
+    if ( !model->HSM2_wgleak2_Given ) model->HSM2_wgleak2 = 0.0 ;
+    if ( !model->HSM2_wgleak3_Given ) model->HSM2_wgleak3 = 0.0 ;
+    if ( !model->HSM2_wgleak6_Given ) model->HSM2_wgleak6 = 0.0 ;
+    if ( !model->HSM2_wglksd1_Given ) model->HSM2_wglksd1 = 0.0 ;
+    if ( !model->HSM2_wglksd2_Given ) model->HSM2_wglksd2 = 0.0 ;
+    if ( !model->HSM2_wglkb1_Given ) model->HSM2_wglkb1 = 0.0 ;
+    if ( !model->HSM2_wglkb2_Given ) model->HSM2_wglkb2 = 0.0 ;
+    if ( !model->HSM2_wnftrp_Given ) model->HSM2_wnftrp = 0.0 ;
+    if ( !model->HSM2_wnfalp_Given ) model->HSM2_wnfalp = 0.0 ;
+    if ( !model->HSM2_wvdiffj_Given ) model->HSM2_wvdiffj = 0.0 ;
+    if ( !model->HSM2_wibpc1_Given ) model->HSM2_wibpc1 = 0.0 ;
+    if ( !model->HSM2_wibpc2_Given ) model->HSM2_wibpc2 = 0.0 ;
+
+    /* Cross-term dependence */
+    if ( !model->HSM2_pvmax_Given ) model->HSM2_pvmax = 0.0 ;
+    if ( !model->HSM2_pbgtmp1_Given ) model->HSM2_pbgtmp1 = 0.0 ;
+    if ( !model->HSM2_pbgtmp2_Given ) model->HSM2_pbgtmp2 = 0.0 ;
+    if ( !model->HSM2_peg0_Given ) model->HSM2_peg0 = 0.0 ;
+    if ( !model->HSM2_plover_Given ) model->HSM2_plover = 0.0 ;
+    if ( !model->HSM2_pvfbover_Given ) model->HSM2_pvfbover = 0.0 ;
+    if ( !model->HSM2_pnover_Given ) model->HSM2_pnover = 0.0 ;
+    if ( !model->HSM2_pwl2_Given ) model->HSM2_pwl2 = 0.0 ;
+    if ( !model->HSM2_pvfbc_Given ) model->HSM2_pvfbc = 0.0 ;
+    if ( !model->HSM2_pnsubc_Given ) model->HSM2_pnsubc = 0.0 ;
+    if ( !model->HSM2_pnsubp_Given ) model->HSM2_pnsubp = 0.0 ;
+    if ( !model->HSM2_pscp1_Given ) model->HSM2_pscp1 = 0.0 ;
+    if ( !model->HSM2_pscp2_Given ) model->HSM2_pscp2 = 0.0 ;
+    if ( !model->HSM2_pscp3_Given ) model->HSM2_pscp3 = 0.0 ;
+    if ( !model->HSM2_psc1_Given ) model->HSM2_psc1 = 0.0 ;
+    if ( !model->HSM2_psc2_Given ) model->HSM2_psc2 = 0.0 ;
+    if ( !model->HSM2_psc3_Given ) model->HSM2_psc3 = 0.0 ;
+    if ( !model->HSM2_psc4_Given ) model->HSM2_psc4 = 0.0 ;
+    if ( !model->HSM2_ppgd1_Given ) model->HSM2_ppgd1 = 0.0 ;
+    if ( !model->HSM2_pndep_Given ) model->HSM2_pndep = 0.0 ;
+    if ( !model->HSM2_pninv_Given ) model->HSM2_pninv = 0.0 ;
+    if ( !model->HSM2_pmuecb0_Given ) model->HSM2_pmuecb0 = 0.0 ;
+    if ( !model->HSM2_pmuecb1_Given ) model->HSM2_pmuecb1 = 0.0 ;
+    if ( !model->HSM2_pmueph1_Given ) model->HSM2_pmueph1 = 0.0 ;
+    if ( !model->HSM2_pvtmp_Given ) model->HSM2_pvtmp = 0.0 ;
+    if ( !model->HSM2_pwvth0_Given ) model->HSM2_pwvth0 = 0.0 ;
+    if ( !model->HSM2_pmuesr1_Given ) model->HSM2_pmuesr1 = 0.0 ;
+    if ( !model->HSM2_pmuetmp_Given ) model->HSM2_pmuetmp = 0.0 ;
+    if ( !model->HSM2_psub1_Given ) model->HSM2_psub1 = 0.0 ;
+    if ( !model->HSM2_psub2_Given ) model->HSM2_psub2 = 0.0 ;
+    if ( !model->HSM2_psvds_Given ) model->HSM2_psvds = 0.0 ;
+    if ( !model->HSM2_psvbs_Given ) model->HSM2_psvbs = 0.0 ;
+    if ( !model->HSM2_psvgs_Given ) model->HSM2_psvgs = 0.0 ;
+    if ( !model->HSM2_pnsti_Given ) model->HSM2_pnsti = 0.0 ;
+    if ( !model->HSM2_pwsti_Given ) model->HSM2_pwsti = 0.0 ;
+    if ( !model->HSM2_pscsti1_Given ) model->HSM2_pscsti1 = 0.0 ;
+    if ( !model->HSM2_pscsti2_Given ) model->HSM2_pscsti2 = 0.0 ;
+    if ( !model->HSM2_pvthsti_Given ) model->HSM2_pvthsti = 0.0 ;
+    if ( !model->HSM2_pmuesti1_Given ) model->HSM2_pmuesti1 = 0.0 ;
+    if ( !model->HSM2_pmuesti2_Given ) model->HSM2_pmuesti2 = 0.0 ;
+    if ( !model->HSM2_pmuesti3_Given ) model->HSM2_pmuesti3 = 0.0 ;
+    if ( !model->HSM2_pnsubpsti1_Given ) model->HSM2_pnsubpsti1 = 0.0 ;
+    if ( !model->HSM2_pnsubpsti2_Given ) model->HSM2_pnsubpsti2 = 0.0 ;
+    if ( !model->HSM2_pnsubpsti3_Given ) model->HSM2_pnsubpsti3 = 0.0 ;
+    if ( !model->HSM2_pcgso_Given ) model->HSM2_pcgso = 0.0 ;
+    if ( !model->HSM2_pcgdo_Given ) model->HSM2_pcgdo = 0.0 ;
+    if ( !model->HSM2_pjs0_Given ) model->HSM2_pjs0 = 0.0 ;
+    if ( !model->HSM2_pjs0sw_Given ) model->HSM2_pjs0sw = 0.0 ;
+    if ( !model->HSM2_pnj_Given ) model->HSM2_pnj = 0.0 ;
+    if ( !model->HSM2_pcisbk_Given ) model->HSM2_pcisbk = 0.0 ;
+    if ( !model->HSM2_pclm1_Given ) model->HSM2_pclm1 = 0.0 ;
+    if ( !model->HSM2_pclm2_Given ) model->HSM2_pclm2 = 0.0 ;
+    if ( !model->HSM2_pclm3_Given ) model->HSM2_pclm3 = 0.0 ;
+    if ( !model->HSM2_pwfc_Given ) model->HSM2_pwfc = 0.0 ;
+    if ( !model->HSM2_pgidl1_Given ) model->HSM2_pgidl1 = 0.0 ;
+    if ( !model->HSM2_pgidl2_Given ) model->HSM2_pgidl2 = 0.0 ;
+    if ( !model->HSM2_pgleak1_Given ) model->HSM2_pgleak1 = 0.0 ;
+    if ( !model->HSM2_pgleak2_Given ) model->HSM2_pgleak2 = 0.0 ;
+    if ( !model->HSM2_pgleak3_Given ) model->HSM2_pgleak3 = 0.0 ;
+    if ( !model->HSM2_pgleak6_Given ) model->HSM2_pgleak6 = 0.0 ;
+    if ( !model->HSM2_pglksd1_Given ) model->HSM2_pglksd1 = 0.0 ;
+    if ( !model->HSM2_pglksd2_Given ) model->HSM2_pglksd2 = 0.0 ;
+    if ( !model->HSM2_pglkb1_Given ) model->HSM2_pglkb1 = 0.0 ;
+    if ( !model->HSM2_pglkb2_Given ) model->HSM2_pglkb2 = 0.0 ;
+    if ( !model->HSM2_pnftrp_Given ) model->HSM2_pnftrp = 0.0 ;
+    if ( !model->HSM2_pnfalp_Given ) model->HSM2_pnfalp = 0.0 ;
+    if ( !model->HSM2_pvdiffj_Given ) model->HSM2_pvdiffj = 0.0 ;
+    if ( !model->HSM2_pibpc1_Given ) model->HSM2_pibpc1 = 0.0 ;
+    if ( !model->HSM2_pibpc2_Given ) model->HSM2_pibpc2 = 0.0 ;
+
+
+    if ( model->HSM2_corecip == 1 ){
+      model->HSM2_sc2 =  0.0 ; model->HSM2_lsc2 =  0.0 ; model->HSM2_wsc2 =  0.0 ; model->HSM2_psc2 =  0.0 ;
+      model->HSM2_scp2 = 0.0 ; model->HSM2_lscp2 = 0.0 ; model->HSM2_wscp2 = 0.0 ; model->HSM2_pscp2 = 0.0 ;
+      model->HSM2_sc4 = 0.0 ;
+      model->HSM2_coqy = 0 ;
+    }
+
+
+
+    /* loop through all the instances of the model */
+    for ( here = model->HSM2instances ;here != NULL ;
+	  here = here->HSM2nextInstance ) {
+      /* allocate a chunk of the state vector */
+      here->HSM2states = *states;
+      if (model->HSM2_conqs)
+	*states += HSM2numStatesNqs;
+      else 
+	*states += HSM2numStates;
+
+      /* perform the parameter defaulting */
+      if ( !here->HSM2_l_Given      ) here->HSM2_l      = 5.0e-6 ;
+      if ( !here->HSM2_w_Given      ) here->HSM2_w      = 5.0e-6 ;
+      if ( !here->HSM2_ad_Given     ) here->HSM2_ad     = 0.0 ;
+      if ( !here->HSM2_as_Given     ) here->HSM2_as     = 0.0 ;
+      if ( !here->HSM2_pd_Given     ) here->HSM2_pd     = 0.0 ;
+      if ( !here->HSM2_ps_Given     ) here->HSM2_ps     = 0.0 ;
+      if ( !here->HSM2_nrd_Given    ) here->HSM2_nrd    = 1.0 ;
+      if ( !here->HSM2_nrs_Given    ) here->HSM2_nrs    = 1.0 ;
+      if ( !here->HSM2_ngcon_Given  ) here->HSM2_ngcon  = 1.0 ;
+      if ( !here->HSM2_xgw_Given    ) here->HSM2_xgw    = 0e0 ;
+      if ( !here->HSM2_xgl_Given    ) here->HSM2_xgl    = 0e0 ;
+      if ( !here->HSM2_nf_Given     ) here->HSM2_nf     = 1.0 ;
+      if ( !here->HSM2_sa_Given     ) here->HSM2_sa     = 0 ;
+      if ( !here->HSM2_sb_Given     ) here->HSM2_sb     = 0 ;
+      if ( !here->HSM2_sd_Given     ) here->HSM2_sd     = 0 ;
+      if ( !here->HSM2_temp_Given   ) here->HSM2_temp   = 27.0 ; /* [C] */
+      if ( !here->HSM2_dtemp_Given  ) here->HSM2_dtemp  = 0.0 ;
+
+      if ( !here->HSM2_icVBS_Given ) here->HSM2_icVBS = 0.0;
+      if ( !here->HSM2_icVDS_Given ) here->HSM2_icVDS = 0.0;
+      if ( !here->HSM2_icVGS_Given ) here->HSM2_icVGS = 0.0;
+
+      if ( !here->HSM2_corbnet_Given )
+	here->HSM2_corbnet = model->HSM2_corbnet ;
+      else if ( here->HSM2_corbnet != 0 && here->HSM2_corbnet != 1 ) {
+	here->HSM2_corbnet = model->HSM2_corbnet ;
+	printf("warning(HiSIM2): CORBNET has been set to its default value: %d.\n", here->HSM2_corbnet);
+      }
+      if ( !here->HSM2_rbdb_Given) here->HSM2_rbdb = model->HSM2_rbdb; /* in ohm */
+      if ( !here->HSM2_rbsb_Given) here->HSM2_rbsb = model->HSM2_rbsb;
+      if ( !here->HSM2_rbpb_Given) here->HSM2_rbpb = model->HSM2_rbpb;
+      if ( !here->HSM2_rbps_Given) here->HSM2_rbps = model->HSM2_rbps;
+      if ( !here->HSM2_rbpd_Given) here->HSM2_rbpd = model->HSM2_rbpd;
+
+      if ( !here->HSM2_corg_Given )
+	here->HSM2_corg = model->HSM2_corg ;
+      else if ( here->HSM2_corg != 0 && here->HSM2_corg != 1 ) {
+	here->HSM2_corg = model->HSM2_corg ;
+	printf("warning(HiSIM2): CORG has been set to its default value: %d.\n", here->HSM2_corg);
+      }
+
+      if ( !here->HSM2_mphdfm_Given ) here->HSM2_mphdfm = model->HSM2_mphdfm ;
+      if ( !here->HSM2_m_Given      ) here->HSM2_m      = 1.0 ;
+
+
+
+
+      /* process drain series resistance */
+      if ((model->HSM2_corsrd < 0 && 
+	   (model->HSM2_rsh > 0.0 || model->HSM2_rd > 0.0)) && here->HSM2dNodePrime == 0) {
+	error = CKTmkVolt(ckt, &tmp, here->HSM2name, "drain");
+	if (error) return(error);
+	here->HSM2dNodePrime = tmp->number;
+      } else {
+	here->HSM2dNodePrime = here->HSM2dNode;
+      }
+      
+      /* process source series resistance */
+      if ((model->HSM2_corsrd < 0 && 
+	   (model->HSM2_rsh > 0.0 || model->HSM2_rs > 0.0)) && here->HSM2sNodePrime == 0) {
+	error = CKTmkVolt(ckt, &tmp, here->HSM2name, "source");
+	if (error) return(error);
+	here->HSM2sNodePrime = tmp->number;
+      } else {
+	here->HSM2sNodePrime = here->HSM2sNode;
+      }
+
+      /* process gate resistance */
+      if ((here->HSM2_corg == 1 && model->HSM2_rshg > 0.0) && here->HSM2gNodePrime == 0) {
+	error = CKTmkVolt(ckt, &tmp, here->HSM2name, "gate");
+	if (error) return(error);
+	here->HSM2gNodePrime = tmp->number;
+      } else {
+	here->HSM2gNodePrime = here->HSM2gNode;
+      }
+
+      /* internal body nodes for body resistance model */
+      if ( here->HSM2_corbnet == 1 ) {
+	if (here->HSM2dbNode == 0) {
+	  error = CKTmkVolt(ckt, &tmp, here->HSM2name, "dbody");
+	  if (error) return(error);
+	  here->HSM2dbNode = tmp->number;
+	}
+	if (here->HSM2bNodePrime == 0) {
+	  error = CKTmkVolt(ckt, &tmp,here->HSM2name, "body");
+	  if (error) return(error);
+	  here->HSM2bNodePrime = tmp->number;
+	}
+	if (here->HSM2sbNode == 0) {
+	  error = CKTmkVolt(ckt, &tmp, here->HSM2name,"sbody");
+	  if (error) return(error);
+	  here->HSM2sbNode = tmp->number;
+	}
+      } else {
+	here->HSM2dbNode = here->HSM2bNodePrime = here->HSM2sbNode = here->HSM2bNode;
+      }
+                   
+      /* set Sparse Matrix Pointers */
+      
+      /* macro to make elements with built in test for out of memory */
+#define TSTALLOC(ptr,first,second) \
+if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
+    return(E_NOMEM);\
+}
+
+      TSTALLOC(HSM2DPbpPtr, HSM2dNodePrime, HSM2bNodePrime)
+      TSTALLOC(HSM2SPbpPtr, HSM2sNodePrime, HSM2bNodePrime)
+      TSTALLOC(HSM2GPbpPtr, HSM2gNodePrime, HSM2bNodePrime)
+
+      TSTALLOC(HSM2BPdpPtr, HSM2bNodePrime, HSM2dNodePrime)
+      TSTALLOC(HSM2BPspPtr, HSM2bNodePrime, HSM2sNodePrime)
+      TSTALLOC(HSM2BPgpPtr, HSM2bNodePrime, HSM2gNodePrime)
+      TSTALLOC(HSM2BPbpPtr, HSM2bNodePrime, HSM2bNodePrime)
+
+      TSTALLOC(HSM2DdPtr, HSM2dNode, HSM2dNode)
+      TSTALLOC(HSM2GPgpPtr, HSM2gNodePrime, HSM2gNodePrime)
+      TSTALLOC(HSM2SsPtr, HSM2sNode, HSM2sNode)
+      TSTALLOC(HSM2DPdpPtr, HSM2dNodePrime, HSM2dNodePrime)
+      TSTALLOC(HSM2SPspPtr, HSM2sNodePrime, HSM2sNodePrime)
+      TSTALLOC(HSM2DdpPtr, HSM2dNode, HSM2dNodePrime)
+      TSTALLOC(HSM2GPdpPtr, HSM2gNodePrime, HSM2dNodePrime)
+      TSTALLOC(HSM2GPspPtr, HSM2gNodePrime, HSM2sNodePrime)
+      TSTALLOC(HSM2SspPtr, HSM2sNode, HSM2sNodePrime)
+      TSTALLOC(HSM2DPspPtr, HSM2dNodePrime, HSM2sNodePrime)
+      TSTALLOC(HSM2DPdPtr, HSM2dNodePrime, HSM2dNode)
+      TSTALLOC(HSM2DPgpPtr, HSM2dNodePrime, HSM2gNodePrime)
+      TSTALLOC(HSM2SPgpPtr, HSM2sNodePrime, HSM2gNodePrime)
+      TSTALLOC(HSM2SPsPtr, HSM2sNodePrime, HSM2sNode)
+      TSTALLOC(HSM2SPdpPtr, HSM2sNodePrime, HSM2dNodePrime);
+
+      if ( here->HSM2_corg == 1 ) {
+	TSTALLOC(HSM2GgPtr, HSM2gNode, HSM2gNode);
+	TSTALLOC(HSM2GgpPtr, HSM2gNode, HSM2gNodePrime);
+	TSTALLOC(HSM2GPgPtr, HSM2gNodePrime, HSM2gNode);
+	TSTALLOC(HSM2GdpPtr, HSM2gNode, HSM2dNodePrime);
+	TSTALLOC(HSM2GspPtr, HSM2gNode, HSM2sNodePrime);
+	TSTALLOC(HSM2GbpPtr, HSM2gNode, HSM2bNodePrime);
+      }
+
+      if ( here->HSM2_corbnet == 1 ) { /* consider body resistance net */
+	TSTALLOC(HSM2DPdbPtr, HSM2dNodePrime, HSM2dbNode);
+	TSTALLOC(HSM2SPsbPtr, HSM2sNodePrime, HSM2sbNode);
+
+	TSTALLOC(HSM2DBdpPtr, HSM2dbNode, HSM2dNodePrime);
+	TSTALLOC(HSM2DBdbPtr, HSM2dbNode, HSM2dbNode);
+	TSTALLOC(HSM2DBbpPtr, HSM2dbNode, HSM2bNodePrime);
+	TSTALLOC(HSM2DBbPtr, HSM2dbNode, HSM2bNode);
+
+	TSTALLOC(HSM2BPdbPtr, HSM2bNodePrime, HSM2dbNode);
+	TSTALLOC(HSM2BPbPtr, HSM2bNodePrime, HSM2bNode);
+	TSTALLOC(HSM2BPsbPtr, HSM2bNodePrime, HSM2sbNode);
+
+	TSTALLOC(HSM2SBspPtr, HSM2sbNode, HSM2sNodePrime);
+	TSTALLOC(HSM2SBbpPtr, HSM2sbNode, HSM2bNodePrime);
+	TSTALLOC(HSM2SBbPtr, HSM2sbNode, HSM2bNode);
+	TSTALLOC(HSM2SBsbPtr, HSM2sbNode, HSM2sbNode);
+
+	TSTALLOC(HSM2BdbPtr, HSM2bNode, HSM2dbNode);
+	TSTALLOC(HSM2BbpPtr, HSM2bNode, HSM2bNodePrime);
+	TSTALLOC(HSM2BsbPtr, HSM2bNode, HSM2sbNode);
+	TSTALLOC(HSM2BbPtr, HSM2bNode, HSM2bNode);
+      }
+
+    }
+  }
+  return(OK);
+} 

src/spicelib/devices/hisim2/hsm2temp.c

@@ -0,0 +1,923 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2temp.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "smpdefs.h"
+#include "cktdefs.h"
+#include "hsm2def.h"
+#include "hsm2evalenv.h"
+#include "util.h"
+#include "const.h"
+#include "sperror.h"
+#include "suffix.h"
+
+#ifdef __STDC__
+#define BINNING(param) pParam->HSM2_##param = model->HSM2_##param \
+  + model->HSM2_l##param / Lbin + model->HSM2_w##param / Wbin \
+  + model->HSM2_p##param / LWbin ;
+#else
+#define BINNING(param) pParam->HSM2_/**/param = model->HSM2_/**/param \
+  + model->HSM2_l/**/param / Lbin + model->HSM2_w/**/param / Wbin \
+  + model->HSM2_p/**/param / LWbin ;
+#endif
+
+#define RANGECHECK(param, min, max, pname)                              \
+  if ( (param) < (min) || (param) > (max) ) {             \
+    printf("warning(HiSIM2): The model/instance parameter %s (= %e) must be in the range [%e , %e].\n", \
+           (pname), (param), (min), (max) );                     \
+  }
+
+
+/*---------------------------------------------------*
+* smoothZero: flooring to zero.
+*      y = 0.5 ( x + sqrt( x^2 + 4 delta^2 ) )
+*-----------------*/
+
+#define Fn_SZtemp( y , x , delta ) { \
+    T1 = sqrt ( ( x ) *  ( x ) + 4.0 * ( delta ) * ( delta) ) ; \
+    y = 0.5 * ( ( x ) + T1 ) ; \
+  }
+
+#define Fn_SUtemp( y , x , xmax , delta ) { \
+    T1 = ( xmax ) - ( x ) - ( delta ) ; \
+    T2 = sqrt ( T1 *  T1 + 4.0 * ( xmax ) * ( delta) ) ; \
+    y = ( xmax ) - 0.5 * ( T1 + T2 ) ; \
+  }
+
+#define Fn_SLtemp( y , x , xmin , delta ) { \
+    T1 = ( x ) - ( xmin ) - ( delta ) ; \
+    T2 = sqrt ( T1 *  T1 + 4.0 * ( xmin ) * ( delta ) ) ; \
+    y = ( xmin ) + 0.5 * ( T1 + T2 ) ; \
+  }
+
+int HSM2temp(inModel,ckt)
+     GENmodel *inModel;
+     CKTcircuit *ckt;
+{
+  register HSM2model *model = (HSM2model *)inModel ;
+  register HSM2instance *here ;
+  HSM2binningParam *pParam ;
+  double mueph ;
+  double Leff, dL , LG, Weff, dW , WG , WL , Lgate , Wgate;
+  double Lbin, Wbin, LWbin ; /* binning */
+  double Nsubpp, Nsubps, Nsub, q_Nsub, Nsubb, Npext ;
+  double Lod_half, Lod_half_ref ;
+  double MUEPWD = 0.0 ;
+  double MUEPLD = 0.0 ;
+  double GDLD = 0.0 ;
+  double T1, T2, T3 ;
+  /* temperature-dependent variables */
+  double Eg ,TTEMP, beta, Nin;
+  double js, jssw, js2, jssw2 ;
+  int i;
+
+  /* declarations for the sc3 clamping part */
+  double A, beta_inv, c_eox, cnst0, cnst1, Cox, Cox_inv;
+  double Denom, dPpg, dVth, dVthLP, dVthLP_dVb, dVthSC, dVthW;
+  double dVth0, dVth0_dVb, fac1, limVgp_dVbs, Pb20, Ps0, Ps0_dVbs;
+  double Ps0_min, Qb0, sc3lim, sc3Vbs, sc3Vgs, term1, term2, term3, term4;
+  double Tox, T0, T1_dVb, T3_dVb, T4, T5, T6, T6_dVb, T8, T8_dVb;
+  double T9, T9_dVb, Vgp, Vgs_min, Vfb, Vthp, Vth0;
+
+
+  for ( ;model ;model = model->HSM2nextModel ) {
+
+    /*-----------------------------------------------------------*
+     * Range check of model parameters
+     *-----------------*/
+    if ( model->HSM2_tox <= 0 ) {
+      printf("warning(HiSIM2): TOX = %e\n ", model->HSM2_tox);
+      printf("warning(HiSIM2): The model parameter TOX must be positive.\n");
+    }
+    RANGECHECK(model->HSM2_xld,        0.0,  50.0e-9, "XLD") ;
+    RANGECHECK(model->HSM2_xwd,   -10.0e-9, 100.0e-9, "XWD") ;
+    RANGECHECK(model->HSM2_rsh,        0.0,   1.0e-3, "RSH") ;
+    RANGECHECK(model->HSM2_rshg,       0.0,    100.0, "RSHG") ;
+    RANGECHECK(model->HSM2_xqy,    10.0e-9,  50.0e-9, "XQY") ;
+    RANGECHECK(model->HSM2_rs,         0.0,  10.0e-3, "RS") ;
+    RANGECHECK(model->HSM2_rd,         0.0,  10.0e-3, "RD") ;
+    RANGECHECK(model->HSM2_vbi,        1.0,      1.2, "VBI") ;
+    RANGECHECK(model->HSM2_parl2,      0.0,  50.0e-9, "PARL2") ;
+    RANGECHECK(model->HSM2_lp,         0.0, 300.0e-9, "LP") ;
+    RANGECHECK(model->HSM2_pgd2,       0.0,      1.5, "PGD2") ;
+    RANGECHECK(model->HSM2_pgd4,       0.0,      3.0, "PGD4") ;
+    RANGECHECK(model->HSM2_muecb0lp,   0.0,      2.0, "MUECB0LP") ;
+    RANGECHECK(model->HSM2_muecb1lp,   0.0,      2.0, "MUECB1LP") ;
+    RANGECHECK(model->HSM2_mueph0,    0.25,     0.35, "MUEPH0") ;
+    RANGECHECK(model->HSM2_muesr0,     1.8,      2.2, "MUESR0") ;
+    RANGECHECK(model->HSM2_lpext,  1.0e-50,  10.0e-6, "LPEXT") ;
+    RANGECHECK(model->HSM2_npext,   1.0e16,   1.0e18, "NPEXT") ;
+    RANGECHECK(model->HSM2_scp21,      0.0,      5.0, "SCP21") ;
+    RANGECHECK(model->HSM2_scp22,      0.0,      0.0, "SCP22") ;
+    RANGECHECK(model->HSM2_bs1,        0.0,  50.0e-3, "BS1") ;
+    RANGECHECK(model->HSM2_bs2,        0.5,      1.0, "BS2") ;
+    if ( model->HSM2_cgbo < 0.0 ) { 
+      printf("warning(HiSIM2): %s = %e\n", "CGBO", model->HSM2_cgbo ); 
+      printf("warning(HiSIM2): The model parameter %s must not be less than %s.\n", "CGBO", "0.0" ); 
+    }
+    RANGECHECK(model->HSM2_clm5,       0.0,      2.0, "CLM5") ;
+    RANGECHECK(model->HSM2_clm6,       0.0,     20.0, "CLM6") ;
+    RANGECHECK(model->HSM2_vover,      0.0,     50.0, "VOVER") ;
+    RANGECHECK(model->HSM2_voverp,     0.0,      2.0, "VOVERP") ;
+    RANGECHECK(model->HSM2_qme1,       0.0, 300.0e-9, "QME1") ;
+    RANGECHECK(model->HSM2_qme3,       0.0,800.0e-12, "QME3") ;
+    RANGECHECK(model->HSM2_tnom,      22.0,     32.0, "TNOM") ;
+    RANGECHECK(model->HSM2_ddltmax,    1.0,     20.0, "DDLTMAX") ;
+    RANGECHECK(model->HSM2_ddltict,   -3.0,     20.0, "DDLTICT") ;
+    RANGECHECK(model->HSM2_ddltslp,    0.0,     20.0, "DDLTSLP") ;
+    RANGECHECK(model->HSM2_cvb,       -0.1,      0.2, "CVB") ;
+    RANGECHECK(model->HSM2_cvbk,      -0.1,      0.2, "CVBK") ;
+    RANGECHECK(model->HSM2_byptol,     0.0,      1.0, "BYPTOL") ;
+    RANGECHECK(model->HSM2_sc3Vbs,    -3.0,      0.0, "SC3VBS") ;
+
+    /*-----------------------------------------------------------*
+     * Change units into CGS.
+     *-----------------*/
+    model->HSM2_tox    *= C_m2cm ;
+    model->HSM2_xld    *= C_m2cm ;
+    model->HSM2_xwd    *= C_m2cm ;
+    model->HSM2_xqy    *= C_m2cm ;
+    model->HSM2_xl     *= C_m2cm ;
+    model->HSM2_xw     *= C_m2cm ;
+    model->HSM2_saref  *= C_m2cm ;
+    model->HSM2_sbref  *= C_m2cm ;
+    model->HSM2_ll     *= C_m2cm ;
+    model->HSM2_lld    *= C_m2cm ;
+    model->HSM2_wl     *= C_m2cm ;
+    model->HSM2_wld    *= C_m2cm ;
+    model->HSM2_lp     *= C_m2cm ;
+    model->HSM2_tpoly  *= C_m2cm ;
+    model->HSM2_parl2  *= C_m2cm ;
+    model->HSM2_qme1   *= C_m2cm ;
+    model->HSM2_qme3   *= C_m2cm ;
+    model->HSM2_cgbo   /= C_m2cm ;
+    model->HSM2_cj     /= C_m2cm_p2 ;
+    model->HSM2_cjsw   /= C_m2cm ;
+    model->HSM2_cjswg  /= C_m2cm ;
+    model->HSM2_lpext  *= C_m2cm ;
+    model->HSM2_wl1    *= C_m2cm ;
+    model->HSM2_rs     *= C_m2cm ;
+    model->HSM2_rd     *= C_m2cm ;
+    GDLD = model->HSM2_gdld * C_m2um ;
+
+    /*-----------------------------------------------------------*
+     * Change unit into Kelvin.
+     *-----------------*/
+    model->HSM2_tnom += 273.15 ; /* [C] -> [K] */
+
+
+    /* SourceSatCurrent = 1.0e-14 */
+    /* DrainSatCurrent = 1.0e-14 */
+    model->HSM2_vcrit = CONSTvt0 * log( CONSTvt0 / (CONSTroot2 * 1.0e-14) ) ;
+
+    /* Quantum Mechanical Effect */
+    if ( ( model->HSM2_qme1 == 0.0 && model->HSM2_qme3 == 0.0 ) || model->HSM2_qme2 == 0.0 ) {
+      model->HSM2_flg_qme = 0 ;
+    } else {
+      model->HSM2_flg_qme = 1 ;
+      model->HSM2_qme12 = model->HSM2_qme1 / ( model->HSM2_qme2 * model->HSM2_qme2 ) ;
+    }
+
+    for ( here = model->HSM2instances; here; here = here->HSM2nextInstance ) {
+      pParam = &here->pParam ;
+
+      /*-----------------------------------------------------------*
+       * Range check of instance parameters
+       *-----------------*/
+      RANGECHECK(here->HSM2_l, model->HSM2_lmin, model->HSM2_lmax, "L") ;
+      RANGECHECK(here->HSM2_w, model->HSM2_wmin, model->HSM2_wmax, "W") ;
+      RANGECHECK(here->HSM2_mphdfm,        -3.0,              3.0, "MPHDFM") ;
+
+      /*-----------------------------------------------------------*
+       * Change units into CGS.
+       *-----------------*/
+      here->HSM2_l      *= C_m2cm ;
+      here->HSM2_w      *= C_m2cm ;
+      here->HSM2_as     *= C_m2cm_p2 ;
+      here->HSM2_ad     *= C_m2cm_p2 ;
+      here->HSM2_ps     *= C_m2cm ;
+      here->HSM2_pd     *= C_m2cm ;
+      here->HSM2_xgw    *= C_m2cm ;
+      here->HSM2_xgl    *= C_m2cm ;
+      here->HSM2_sa     *= C_m2cm ;
+      here->HSM2_sb     *= C_m2cm ;
+      here->HSM2_sd     *= C_m2cm ;
+    /*-----------------------------------------------------------*
+     * Change unit into Kelvin.
+     *-----------------*/
+      here->HSM2_temp += 273.15 ; /* [C] -> [K] */
+
+
+      here->HSM2_lgate = Lgate = here->HSM2_l + model->HSM2_xl ;
+      Wgate = here->HSM2_w / here->HSM2_nf  + model->HSM2_xw ;
+
+      LG = Lgate * 1.0e4 ;
+      here->HSM2_wg = WG = Wgate * 1.0e4 ; 
+      WL = WG * LG ;
+      MUEPWD = model->HSM2_muepwd * C_m2um ;
+      MUEPLD = model->HSM2_muepld * C_m2um ;
+
+      /* binning calculation */
+      Lbin = pow(LG, model->HSM2_lbinn) ;
+      Wbin = pow(WG, model->HSM2_wbinn) ;
+      LWbin = Lbin * Wbin ;
+
+      BINNING(vmax)
+      BINNING(bgtmp1)
+      BINNING(bgtmp2)
+      BINNING(eg0)
+      BINNING(lover)
+      BINNING(vfbover)
+      BINNING(nover)
+      BINNING(wl2)
+      BINNING(vfbc)
+      BINNING(nsubc)
+      BINNING(nsubp)
+      BINNING(scp1)
+      BINNING(scp2)
+      BINNING(scp3)
+      BINNING(sc1)
+      BINNING(sc2)
+      BINNING(sc3)
+      BINNING(sc4)
+      BINNING(pgd1)
+      BINNING(ndep)
+      BINNING(ninv)
+      BINNING(muecb0)
+      BINNING(muecb1)
+      BINNING(mueph1)
+      BINNING(vtmp)
+      BINNING(wvth0)
+      BINNING(muesr1)
+      BINNING(muetmp)
+      BINNING(sub1)
+      BINNING(sub2)
+      BINNING(svds)
+      BINNING(svbs)
+      BINNING(svgs)
+      BINNING(nsti)
+      BINNING(wsti)
+      BINNING(scsti1)
+      BINNING(scsti2)
+      BINNING(vthsti)
+      BINNING(muesti1)
+      BINNING(muesti2)
+      BINNING(muesti3)
+      BINNING(nsubpsti1)
+      BINNING(nsubpsti2)
+      BINNING(nsubpsti3)
+      BINNING(cgso)
+      BINNING(cgdo)
+      BINNING(js0)
+      BINNING(js0sw)
+      BINNING(nj)
+      BINNING(cisbk)
+      BINNING(clm1)
+      BINNING(clm2)
+      BINNING(clm3)
+      BINNING(wfc)
+      BINNING(gidl1)
+      BINNING(gidl2)
+      BINNING(gleak1)
+      BINNING(gleak2)
+      BINNING(gleak3)
+      BINNING(gleak6)
+      BINNING(glksd1)
+      BINNING(glksd2)
+      BINNING(glkb1)
+      BINNING(glkb2)
+      BINNING(nftrp)
+      BINNING(nfalp)
+      BINNING(vdiffj)
+      BINNING(ibpc1)
+      BINNING(ibpc2)
+
+      /*-----------------------------------------------------------*
+       * Range check of model parameters
+       *-----------------*/
+      RANGECHECK(pParam->HSM2_vmax,     1.0e5,   20.0e6, "VMAX") ;
+      RANGECHECK(pParam->HSM2_bgtmp1, 50.0e-6,   1.0e-3, "BGTMP1") ;
+      RANGECHECK(pParam->HSM2_bgtmp2, -1.0e-6,   1.0e-6, "BGTMP2") ;
+      RANGECHECK(pParam->HSM2_eg0,        1.0,      1.3, "EG0") ;
+      RANGECHECK(pParam->HSM2_vfbc,      -1.2,     -0.8, "VFBC") ;
+      RANGECHECK(pParam->HSM2_vfbover,   -0.2,      0.2, "VFBOVER") ;
+      RANGECHECK(pParam->HSM2_nsubc,   1.0e16,   1.0e19, "NSUBC") ;
+      RANGECHECK(pParam->HSM2_nsubp,   1.0e16,   1.0e19, "NSUBP") ;
+      RANGECHECK(pParam->HSM2_scp1,       0.0,     20.0, "SCP1") ;
+      RANGECHECK(pParam->HSM2_scp2,       0.0,      2.0, "SCP2") ;
+      RANGECHECK(pParam->HSM2_scp3,       0.0, 100.0e-9, "SCP3") ;
+      RANGECHECK(pParam->HSM2_sc1,        0.0,     20.0, "SC1") ;
+      RANGECHECK(pParam->HSM2_sc2,        0.0,      2.0, "SC2") ;
+      RANGECHECK(pParam->HSM2_sc3,        0.0, 200.0e-9, "SC3") ;
+      RANGECHECK(pParam->HSM2_pgd1,       0.0,  50.0e-3, "PGD1") ;
+      RANGECHECK(pParam->HSM2_ndep,       0.0,      1.0, "NDEP") ;
+      RANGECHECK(pParam->HSM2_ninv,       0.0,      1.0, "NINV") ;
+      RANGECHECK(pParam->HSM2_muecb0,   100.0,  100.0e3, "MUECB0") ;
+      RANGECHECK(pParam->HSM2_muecb1,     5.0,    1.0e4, "MUECB1") ;
+      RANGECHECK(pParam->HSM2_mueph1,   2.0e3,   35.0e3, "MUEPH1") ;
+      RANGECHECK(pParam->HSM2_vtmp,      -5.0,      1.0, "VTMP") ;
+      RANGECHECK(pParam->HSM2_muesr1,  1.0e13,   1.0e16, "MUESR1") ;
+      RANGECHECK(pParam->HSM2_muetmp,     0.5,      2.0, "MUETMP") ;
+      RANGECHECK(pParam->HSM2_clm1,       0.5,      1.0, "CLM1") ;
+      RANGECHECK(pParam->HSM2_clm2,       1.0,      4.0, "CLM2") ;
+      RANGECHECK(pParam->HSM2_clm3,       0.5,      5.0, "CLM3") ;
+      RANGECHECK(pParam->HSM2_wfc,   -5.0e-15,   1.0e-6, "WFC") ;
+      RANGECHECK(pParam->HSM2_cgso,       0.0, 100e-9 * 100*C_VAC*model->HSM2_kappa/model->HSM2_tox*C_m2cm, "CGSO") ;
+      RANGECHECK(pParam->HSM2_cgdo,       0.0, 100e-9 * 100*C_VAC*model->HSM2_kappa/model->HSM2_tox*C_m2cm, "CGDO") ;
+      RANGECHECK(pParam->HSM2_ibpc1,      0.0,   1.0e12, "IBPC1") ;
+      RANGECHECK(pParam->HSM2_ibpc2,      0.0,   1.0e12, "IBPC2") ;
+      RANGECHECK(pParam->HSM2_nsti,    1.0e16,   1.0e19, "NSTI") ;
+
+      /*-----------------------------------------------------------*
+       * Change units into CGS.
+       *-----------------*/
+      pParam->HSM2_lover  *= C_m2cm ;
+      pParam->HSM2_sc3    *= C_m2cm ;
+      pParam->HSM2_scp3   *= C_m2cm ;
+      pParam->HSM2_wfc    *= C_m2cm ;
+      pParam->HSM2_wsti   *= C_m2cm ;
+      pParam->HSM2_gidl1  *= C_m2cm_p1o2 ;
+      pParam->HSM2_cgso   /= C_m2cm ;
+      pParam->HSM2_cgdo   /= C_m2cm ;
+      pParam->HSM2_js0    /= C_m2cm_p2 ;
+      pParam->HSM2_js0sw  /= C_m2cm ;
+
+      /* Band gap */
+      here->HSM2_egtnom = pParam->HSM2_eg0 - model->HSM2_tnom    
+        * ( 90.25e-6 + model->HSM2_tnom * 1.0e-7 ) ;
+  
+      /* C_EOX */
+      here->HSM2_cecox = C_VAC * model->HSM2_kappa ;
+  
+      /* Vth reduction for small Vds */
+      here->HSM2_msc = model->HSM2_scp22  ;
+
+      /* Poly-Si Gate Depletion */
+      if ( pParam->HSM2_pgd1 == 0.0 ) {
+        here->HSM2_flg_pgd = 0 ;
+      } else {
+        here->HSM2_flg_pgd = 1 ;
+      }
+
+
+      /* CLM5 & CLM6 */
+      here->HSM2_clmmod = 1e0 + pow( LG , model->HSM2_clm5 ) * model->HSM2_clm6 ;
+
+      /* Half length of diffusion */
+      T1 = 1.0 / (model->HSM2_saref + 0.5 * here->HSM2_l)
+         + 1.0 / (model->HSM2_sbref + 0.5 * here->HSM2_l);
+      Lod_half_ref = 2.0 / T1 ;
+
+      if (here->HSM2_sa > 0.0 && here->HSM2_sb > 0.0 &&
+	  (here->HSM2_nf == 1.0 ||
+           (here->HSM2_nf > 1.0 && here->HSM2_sd > 0.0))) {
+        T1 = 0.0;
+        for (i = 0; i < here->HSM2_nf; i++) {
+          T1 += 1.0 / (here->HSM2_sa + 0.5 * here->HSM2_l
+                       + i * (here->HSM2_sd + here->HSM2_l))
+              + 1.0 / (here->HSM2_sb + 0.5 * here->HSM2_l
+                       + i * (here->HSM2_sd + here->HSM2_l));
+        }
+        Lod_half = 2.0 * here->HSM2_nf / T1;
+      } else {
+        Lod_half = 0.0;
+      }
+
+      Npext = model->HSM2_npext * ( 1.0 + model->HSM2_npextw / pow( WG, model->HSM2_npextwp ) ); /* new */
+
+      /* DFM */
+      if ( model->HSM2_codfm == 1 && here->HSM2_nsubcdfm_Given ) {
+	RANGECHECK(here->HSM2_nsubcdfm,   1.0e16,   1.0e19, "NSUBCDFM") ;
+ 	pParam->HSM2_mueph1 *= here->HSM2_mphdfm
+	  * ( log(here->HSM2_nsubcdfm) - log(pParam->HSM2_nsubc) ) + 1.0 ;
+	pParam->HSM2_nsubp += here->HSM2_nsubcdfm - pParam->HSM2_nsubc ;
+ 	Npext += here->HSM2_nsubcdfm - pParam->HSM2_nsubc ;
+ 	pParam->HSM2_nsubc = here->HSM2_nsubcdfm ;
+      }
+
+      /* Coulomb Scattering */
+      here->HSM2_muecb0 = pParam->HSM2_muecb0 * pow( LG, model->HSM2_muecb0lp );
+      here->HSM2_muecb1 = pParam->HSM2_muecb1 * pow( LG, model->HSM2_muecb1lp );
+
+      /* Phonon Scattering (temperature-independent part) */
+      mueph = pParam->HSM2_mueph1 
+        * (1.0e0 + (model->HSM2_muephw / pow( WG + MUEPWD , model->HSM2_muepwp))) 
+        * (1.0e0 + (model->HSM2_muephl / pow( LG + MUEPLD , model->HSM2_mueplp))) 
+        * (1.0e0 + (model->HSM2_muephw2 / pow( WG, model->HSM2_muepwp2))) 
+        * (1.0e0 + (model->HSM2_muephl2 / pow( LG, model->HSM2_mueplp2))) 
+        * (1.0e0 + (model->HSM2_muephs / pow( WL, model->HSM2_muepsp)));  
+      if (Lod_half > 0.0) {
+        T1 = 1.0e0 / (1.0e0 + pParam->HSM2_muesti2) ;
+        T2 = pow (pParam->HSM2_muesti1 / Lod_half, pParam->HSM2_muesti3) ;
+        T3 = pow (pParam->HSM2_muesti1 / Lod_half_ref, pParam->HSM2_muesti3) ;
+        here->HSM2_mueph = mueph * (1.0e0 + T1 * T2) / (1.0e0 + T1 * T3); 
+      } else {
+        here->HSM2_mueph = mueph;
+      }
+      
+      /* Surface Roughness Scattering */
+      here->HSM2_muesr = model->HSM2_muesr0 
+        * (1.0e0 + (model->HSM2_muesrl / pow (LG, model->HSM2_mueslp))) 
+        * (1.0e0 + (model->HSM2_muesrw / pow (WG, model->HSM2_mueswp))) ;
+
+      /* Coefficients of Qbm for Eeff */
+      T1 = pow( LG, model->HSM2_ndeplp ) ;
+      T2 = pow( WG, model->HSM2_ndepwp ) ; /* new */
+      T3 = T1 + model->HSM2_ndepl ;
+      T4 = T2 + model->HSM2_ndepw ;
+      if( T3 < 1e-8 ) { T3 = 1e-8; } 
+      if( T4 < 1e-8 ) { T4 = 1e-8; } 
+      here->HSM2_ndep_o_esi = ( pParam->HSM2_ndep * T1 ) / T3  * T2 / T4
+	/ C_ESI ;
+      here->HSM2_ninv_o_esi = pParam->HSM2_ninv / C_ESI ;
+
+      /* Metallurgical channel geometry */
+      dL = model->HSM2_xld 
+        + (model->HSM2_ll / pow (Lgate + model->HSM2_lld, model->HSM2_lln)) ;
+      dW = model->HSM2_xwd 
+        + (model->HSM2_wl / pow (Wgate + model->HSM2_wld, model->HSM2_wln)) ;  
+    
+      Leff = Lgate - 2.0e0 * dL ;
+      if ( Leff <= 1.0e-7 ) {   
+        IFuid namarr[2];
+        namarr[0] = model->HSM2modName;
+        namarr[1] = here->HSM2name;
+        (*(SPfrontEnd->IFerror))
+          ( 
+           ERR_FATAL, 
+           "HiSIM2: MOSFET(%s) MODEL(%s): effective channel length is smaller than 1nm", 
+           namarr 
+           );
+        return (E_BADPARM);
+      }
+      here->HSM2_leff = Leff ;
+
+      /* Wg dependence for short channel devices */
+      here->HSM2_lgatesm = Lgate + model->HSM2_wl1 / pow( WL , model->HSM2_wl1p ) ;
+      here->HSM2_dVthsm = pParam->HSM2_wl2 / pow( WL , model->HSM2_wl2p ) ;
+
+      /* Lg dependence of wsti */
+      T1 = 1.0e0 + model->HSM2_wstil / pow( here->HSM2_lgatesm * 1e4 , model->HSM2_wstilp ) ;
+      T2 = 1.0e0 + model->HSM2_wstiw / pow( WG , model->HSM2_wstiwp ) ;
+      here->HSM2_wsti = pParam->HSM2_wsti * T1 * T2 ;
+
+      here->HSM2_weff = Weff = Wgate - 2.0e0 * dW ;
+      if ( Weff <= 0.0 ) {   
+        IFuid namarr[2];
+        namarr[0] = model->HSM2modName;
+        namarr[1] = here->HSM2name;
+        (*(SPfrontEnd->IFerror))
+          ( 
+           ERR_FATAL, 
+           "HiSIM2: MOSFET(%s) MODEL(%s): effective channel width is negative or 0", 
+           namarr 
+           );
+        return (E_BADPARM);
+      }
+      here->HSM2_weff_nf = Weff * here->HSM2_nf ;
+
+      /* Surface impurity profile */
+
+      T1 = 2.0 * ( 1.0 - model->HSM2_nsubpfac ) / model->HSM2_nsubpl * LG + 2.0 * model->HSM2_nsubpfac - 1.0 ;
+      Fn_SUtemp( T1 , T1 , 1 , 0.01 ) ;
+      Fn_SLtemp( T1 , T1 , model->HSM2_nsubpfac  , 0.01 ) ;
+      pParam->HSM2_nsubp *= T1 ;
+
+      /* Note: Sign Changed --> */
+      Nsubpp = pParam->HSM2_nsubp 
+        * (1.0e0 + (model->HSM2_nsubpw / pow (WG, model->HSM2_nsubpwp))) ;
+      /* <-- Note: Sign Changed */
+
+      if (Lod_half > 0.0) {
+        T1 = 1.0e0 / (1.0e0 + pParam->HSM2_nsubpsti2) ;
+        T2 = pow (pParam->HSM2_nsubpsti1 / Lod_half, pParam->HSM2_nsubpsti3) ;
+        T3 = pow (pParam->HSM2_nsubpsti1 / Lod_half_ref, pParam->HSM2_nsubpsti3) ;
+        Nsubps = Nsubpp * (1.0e0 + T1 * T2) / (1.0e0 + T1 * T3) ;
+      } else {
+        Nsubps = Nsubpp ;
+      }
+
+      T2 = 1.0e0 + ( model->HSM2_nsubcw / pow ( WG, model->HSM2_nsubcwp )) ;
+      T2 *= 1.0e0 + ( model->HSM2_nsubcw2 / pow ( WG, model->HSM2_nsubcwp2 )) ;
+      T3 = model->HSM2_nsubcmax / pParam->HSM2_nsubc ;
+
+      Fn_SUtemp( T1 , T2 , T3 , 0.01 ) ;
+      pParam->HSM2_nsubc *= T1 ;
+
+      if ( pParam->HSM2_nsubc <= 0.0 ) {
+        fprintf ( stderr , "*** warning(HiSIM): actual NSUBC value is negative -> reset to 1E+15.\n" ) ;
+        fprintf ( stderr , "    The model parameter  NSUBCW/NSUBCWP and/or NSUBCW2/NSUBCW2P might be wrong.\n" ) ;
+        pParam->HSM2_nsubc = 1e15 ;
+      }
+      if(Npext < pParam->HSM2_nsubc || Npext > pParam->HSM2_nsubp) {
+        fprintf ( stderr , "*** warning(HiSIM): actual NPEXT value is smaller than NSUBC and/or greater than NSUBP.\n" ) ;
+        fprintf ( stderr , "    ( Npext = %e , NSUBC = %e , NSUBP = %e ) \n",Npext,pParam->HSM2_nsubc,pParam->HSM2_nsubp);
+        fprintf ( stderr , "    The model parameter  NPEXTW and/or NPEXTWP might be wrong.\n" ) ;
+      }
+
+      if( Lgate > model->HSM2_lp ){
+        Nsub = (pParam->HSM2_nsubc * (Lgate - model->HSM2_lp) 
+                +  Nsubps  * model->HSM2_lp) / Lgate ;
+      } else {
+        Nsub = Nsubps
+          + (Nsubps - pParam->HSM2_nsubc) * (model->HSM2_lp - Lgate) 
+          / model->HSM2_lp ;
+      }
+      T3 = 0.5e0 * Lgate - model->HSM2_lp ;
+      Fn_SZtemp( T3 , T3 , 1e-8 ) ;
+      T1 = Fn_Max(0.0e0, model->HSM2_lpext ) ;
+      T2 = T3 * T1 / ( T3 + T1 ) ;
+
+      here->HSM2_nsub = 
+        Nsub = Nsub + T2 * (Npext - pParam->HSM2_nsubc) / Lgate ;
+      here->HSM2_qnsub = q_Nsub  = C_QE * Nsub ;
+      here->HSM2_qnsub_esi = q_Nsub * C_ESI ;
+      here->HSM2_2qnsub_esi = 2.0 * here->HSM2_qnsub_esi ;
+
+      /* Pocket Overlap (temperature-independent part) */
+      if ( Lgate <= 2.0e0 * model->HSM2_lp ) {
+        Nsubb = 2.0e0 * Nsubps 
+          - (Nsubps - pParam->HSM2_nsubc) * Lgate 
+          / model->HSM2_lp - pParam->HSM2_nsubc ;
+        here->HSM2_ptovr0 = log (Nsubb / pParam->HSM2_nsubc) ;
+      } else {
+        here->HSM2_ptovr0 = 0.0e0 ;
+      }
+
+      /* costi0 and costi1 for STI transistor model (temperature-independent part) */
+      here->HSM2_costi00 = sqrt (2.0 * C_QE * pParam->HSM2_nsti * C_ESI ) ;
+      here->HSM2_nsti_p2 = 1.0 / ( pParam->HSM2_nsti * pParam->HSM2_nsti ) ;
+
+      /* Velocity Temperature Dependence (Temperature-dependent part will be multiplied later.) */
+      here->HSM2_vmax0 = (1.0e0 + (model->HSM2_vover / pow (LG, model->HSM2_voverp)))
+        * (1.0e0 + (model->HSM2_vovers / pow (WL, model->HSM2_voversp))) ;
+
+      /* 2 phi_B (temperature-independent) */
+      /* @300K, with pocket */
+      here->HSM2_pb20 = 2.0e0 / C_b300 * log (Nsub / C_Nin0) ;
+      /* @300K, w/o pocket */
+      here->HSM2_pb2c = 2.0e0 / C_b300 * log (pParam->HSM2_nsubc / C_Nin0) ;
+
+
+      /* constant for Poly depletion */
+      here->HSM2_cnstpgd = pow ( 1e0 + 1e0 / LG , model->HSM2_pgd4 ) 
+        * pParam->HSM2_pgd1 ;
+
+
+
+
+      /* Gate resistance */
+      if ( here->HSM2_corg == 1 ) {
+        T1 = here->HSM2_xgw + Weff / (3.0e0 * here->HSM2_ngcon);
+        T2 = Lgate - here->HSM2_xgl;
+        here->HSM2_grg = model->HSM2_rshg * T1 / (here->HSM2_ngcon * T2 * here->HSM2_nf);
+        if (here->HSM2_grg > 1.0e-3) here->HSM2_grg = here->HSM2_m / here->HSM2_grg;
+        else {
+          here->HSM2_grg = here->HSM2_m * 1.0e3;
+          printf("warning(HiSIM2): The gate conductance reset to 1.0e3 mho.\n");
+        }
+      }
+
+      /* Process source/drain series resistamce */
+      here->HSM2_rd = 0.0;
+      if ( model->HSM2_rsh > 0.0 ) {
+        here->HSM2_rd += model->HSM2_rsh * here->HSM2_nrd ;
+      } 
+      if ( model->HSM2_rd > 0.0 ) {
+       here->HSM2_rd += model->HSM2_rd / here->HSM2_weff_nf ;
+     }
+
+      here->HSM2_rs = 0.0;
+      if ( model->HSM2_rsh > 0.0 ) {
+        here->HSM2_rs += model->HSM2_rsh * here->HSM2_nrs ;
+      }
+      if ( model->HSM2_rs > 0.0 ) {
+        here->HSM2_rs += model->HSM2_rs / here->HSM2_weff_nf ; 
+      }
+
+      if (model->HSM2_corsrd < 0) {
+        if ( here->HSM2_rd > 0.0 ) {
+          here->HSM2drainConductance = here->HSM2_m / here->HSM2_rd ;
+        } else {
+          here->HSM2drainConductance = 0.0;
+        }
+        if ( here->HSM2_rs > 0.0 ) {
+          here->HSM2sourceConductance = here->HSM2_m / here->HSM2_rs ;
+        } else {
+          here->HSM2sourceConductance = 0.0;
+        }
+      } else if (model->HSM2_corsrd > 0) {
+        here->HSM2drainConductance = 0.0 ;
+        here->HSM2sourceConductance = 0.0 ;
+        if ( here->HSM2_rd > 0.0 && model->HSM2_cothrml != 0 ) {
+          here->HSM2internalGd = here->HSM2_m / here->HSM2_rd ;
+        } else {
+          here->HSM2internalGd = 0.0;
+        }
+        if ( here->HSM2_rs > 0.0 && model->HSM2_cothrml != 0 ) {
+          here->HSM2internalGs = here->HSM2_m / here->HSM2_rs ;
+        } else {
+          here->HSM2internalGs = 0.0;
+        }
+      } else {
+        here->HSM2drainConductance = 0.0 ;
+        here->HSM2sourceConductance = 0.0 ;
+      }
+
+
+      /* Body resistance */
+      if ( here->HSM2_corbnet == 1 ) {
+        if (here->HSM2_rbdb < 1.0e-3) here->HSM2_grbdb = here->HSM2_m * 1.0e3 ; /* in mho */
+        else here->HSM2_grbdb = here->HSM2_m * ( model->HSM2_gbmin + 1.0 / here->HSM2_rbdb ) ;
+
+        if (here->HSM2_rbpb < 1.0e-3) here->HSM2_grbpb = here->HSM2_m * 1.0e3 ;
+        else here->HSM2_grbpb = here->HSM2_m * ( model->HSM2_gbmin + 1.0 / here->HSM2_rbpb ) ;
+
+        if (here->HSM2_rbps < 1.0e-3) here->HSM2_grbps = here->HSM2_m * 1.0e3 ;
+        else here->HSM2_grbps = here->HSM2_m * ( model->HSM2_gbmin + 1.0 / here->HSM2_rbps ) ;
+
+        if (here->HSM2_rbsb < 1.0e-3) here->HSM2_grbsb = here->HSM2_m * 1.0e3 ;
+        else here->HSM2_grbsb = here->HSM2_m * ( model->HSM2_gbmin + 1.0 / here->HSM2_rbsb ) ;
+
+        if (here->HSM2_rbpd < 1.0e-3) here->HSM2_grbpd = here->HSM2_m * 1.0e3 ;
+        else here->HSM2_grbpd = here->HSM2_m * ( model->HSM2_gbmin + 1.0 / here->HSM2_rbpd ) ;
+      }
+
+      /* Vdseff */
+      T1 = model->HSM2_ddltslp * LG + model->HSM2_ddltict ;
+      here->HSM2_ddlt = T1 * model->HSM2_ddltmax / ( T1 + model->HSM2_ddltmax ) + 1.0 ;
+
+      /* Isub */
+      T2 = pow( Weff , model->HSM2_svgswp ) ;
+      here->HSM2_vg2const = pParam->HSM2_svgs
+         * ( 1.0e0
+           + model->HSM2_svgsl / pow( here->HSM2_lgate , model->HSM2_svgslp ) )
+         * ( T2 / ( T2 + model->HSM2_svgsw ) ) ; 
+
+      here->HSM2_xvbs = pParam->HSM2_svbs 
+         * ( 1.0e0
+           + model->HSM2_svbsl / pow( here->HSM2_lgate , model->HSM2_svbslp ) ) ;
+      here->HSM2_xgate = model->HSM2_slg 
+         * ( 1.0
+         + model->HSM2_slgl / pow( here->HSM2_lgate , model->HSM2_slglp ) ) ;
+
+      here->HSM2_xsub1 = pParam->HSM2_sub1 
+         * ( 1.0 
+         + model->HSM2_sub1l / pow( here->HSM2_lgate , model->HSM2_sub1lp ) ) ;
+
+      here->HSM2_xsub2 = pParam->HSM2_sub2
+         * ( 1.0 + model->HSM2_sub2l / here->HSM2_lgate ) ;
+
+      /* Fringing capacitance */
+      here->HSM2_cfrng = C_EOX / ( C_Pi / 2.0e0 ) * here->HSM2_weff_nf 
+         * log( 1.0e0 + model->HSM2_tpoly / model->HSM2_tox ) ; 
+
+      /* Additional term of lateral-field-induced capacitance */
+      here->HSM2_cqyb0 = 1.0e4 * here->HSM2_weff_nf
+	* model->HSM2_xqy1 / pow( LG , model->HSM2_xqy2 ) ;
+
+      /* Parasitic component of the channel current */
+      here->HSM2_ptl0 = model->HSM2_ptl * pow( LG        , - model->HSM2_ptlp ) ;
+      here->HSM2_pt40 = model->HSM2_pt4 * pow( LG        , - model->HSM2_pt4p ) ;
+      here->HSM2_gdl0 = model->HSM2_gdl * pow( LG + GDLD , - model->HSM2_gdlp ) ;
+
+
+      /*-----------------------------------------------------------*
+       * Temperature dependent constants. 
+       *-----------------*/
+        TTEMP = ckt->CKTtemp ;
+        if ( here->HSM2_temp_Given ) TTEMP = here->HSM2_temp ;
+        if ( here->HSM2_dtemp_Given ) {
+          TTEMP = TTEMP + here->HSM2_dtemp ;
+          here->HSM2_temp = TTEMP ;
+        }
+
+        /* Band gap */
+        T1 = TTEMP - model->HSM2_tnom ;
+        T2 = TTEMP * TTEMP - model->HSM2_tnom * model->HSM2_tnom ;
+        here->HSM2_eg = Eg = here->HSM2_egtnom - pParam->HSM2_bgtmp1 * T1
+          - pParam->HSM2_bgtmp2 * T2 ;
+        here->HSM2_sqrt_eg = sqrt( Eg ) ;
+
+
+	T1 = 1.0 / TTEMP ;
+	T2 = 1.0 / model->HSM2_tnom ;
+	T3 = here->HSM2_egtnom + model->HSM2_egig
+	  + model->HSM2_igtemp2 * ( T1 - T2 )
+	  + model->HSM2_igtemp3 * ( T1 * T1 - T2 * T2 ) ;
+ 	here->HSM2_egp12 = sqrt ( T3 ) ;
+ 	here->HSM2_egp32 = T3 * here->HSM2_egp12 ;
+
+        
+        /* Inverse of the thermal voltage */
+        here->HSM2_beta = beta = C_QE / (C_KB * TTEMP) ;
+        here->HSM2_beta_inv = 1.0 / beta ;
+        here->HSM2_beta2 = beta * beta ;
+        here->HSM2_betatnom = C_QE / (C_KB * model->HSM2_tnom) ;
+
+        /* Intrinsic carrier concentration */
+        here->HSM2_nin = Nin = C_Nin0 * pow (TTEMP / model->HSM2_tnom, 1.5e0) 
+          * exp (- Eg / 2.0e0 * beta + here->HSM2_egtnom / 2.0e0 * here->HSM2_betatnom) ;
+
+
+        /* Phonon Scattering (temperature-dependent part) */
+        T1 =  pow (TTEMP / model->HSM2_tnom, pParam->HSM2_muetmp) ;
+        here->HSM2_mphn0 = T1 / here->HSM2_mueph ;
+        here->HSM2_mphn1 = here->HSM2_mphn0 * model->HSM2_mueph0 ;
+
+
+        /* Pocket Overlap (temperature-dependent part) */
+        here->HSM2_ptovr = here->HSM2_ptovr0 / beta ;
+
+
+        /* Velocity Temperature Dependence */
+        T1 =  TTEMP / model->HSM2_tnom ;
+        here->HSM2_vmax = here->HSM2_vmax0 * pParam->HSM2_vmax 
+          / (1.8 + 0.4 * T1 + 0.1 * T1 * T1 - pParam->HSM2_vtmp * (1.0e0 - T1)) ;
+
+
+        /* Coefficient of the F function for bulk charge */
+        here->HSM2_cnst0 = sqrt ( 2.0 * C_ESI * C_QE * here->HSM2_nsub / beta ) ;
+	here->HSM2_cnst0over = here->HSM2_cnst0 * sqrt( pParam->HSM2_nover / here->HSM2_nsub ) ;     
+
+        /* 2 phi_B (temperature-dependent) */
+        /* @temp, with pocket */
+        here->HSM2_pb2 =  2.0e0 / beta * log (here->HSM2_nsub / Nin) ;
+        if ( pParam->HSM2_nover != 0.0) {
+	   here->HSM2_pb2over = 2.0 / beta * log( pParam->HSM2_nover / Nin ) ;
+
+           /* (1 / cnst1 / cnstCoxi) for Ps0LD_iniB */
+           T1 = here->HSM2_cnst0over * model->HSM2_tox / here->HSM2_cecox  ;
+           T2 = pParam->HSM2_nover / Nin ;
+           T1 = T2 * T2 / ( T1 * T1 ) ;
+           here->HSM2_ps0ldinib  = T1 ; /* (1 / cnst1 / cnstCoxi) */
+
+        }else {
+           here->HSM2_pb2over = 0.0 ;
+           here->HSM2_ps0ldinib  = 0.0 ;
+        }
+
+
+        /* Depletion Width */
+        T1 = 2.0e0 * C_ESI / C_QE ;
+        here->HSM2_wdpl = sqrt ( T1 / here->HSM2_nsub ) ;
+        here->HSM2_wdplp = sqrt( T1 / ( pParam->HSM2_nsubp ) ) ; 
+
+        /* cnst1: n_{p0} / p_{p0} */
+        T1 = Nin / here->HSM2_nsub ;
+        here->HSM2_cnst1 = T1 * T1 ;
+
+
+        /* for substrate-source/drain junction diode. */
+        js   = pParam->HSM2_js0
+          * exp ((here->HSM2_egtnom * here->HSM2_betatnom - Eg * beta
+                  + model->HSM2_xti * log (TTEMP / model->HSM2_tnom)) / pParam->HSM2_nj) ;
+        jssw = pParam->HSM2_js0sw
+          * exp ((here->HSM2_egtnom * here->HSM2_betatnom - Eg * beta 
+                  + model->HSM2_xti * log (TTEMP / model->HSM2_tnom)) / model->HSM2_njsw) ;
+
+        js2  = pParam->HSM2_js0
+          * exp ((here->HSM2_egtnom * here->HSM2_betatnom - Eg * beta
+                  + model->HSM2_xti2 * log (TTEMP / model->HSM2_tnom)) / pParam->HSM2_nj) ;  
+        jssw2 = pParam->HSM2_js0sw
+          * exp ((here->HSM2_egtnom * here->HSM2_betatnom - Eg * beta
+                  + model->HSM2_xti2 * log (TTEMP / model->HSM2_tnom)) / model->HSM2_njsw) ; 
+      
+        here->HSM2_isbd = here->HSM2_ad * js + here->HSM2_pd * jssw ;
+        here->HSM2_isbd2 = here->HSM2_ad * js2 + here->HSM2_pd * jssw2 ;
+        here->HSM2_isbs = here->HSM2_as * js + here->HSM2_ps * jssw ;
+        here->HSM2_isbs2 = here->HSM2_as * js2 + here->HSM2_ps * jssw2 ;
+
+        here->HSM2_vbdt = pParam->HSM2_nj / beta 
+          * log (pParam->HSM2_vdiffj * (TTEMP / model->HSM2_tnom) * (TTEMP / model->HSM2_tnom) 
+                 / (here->HSM2_isbd + 1.0e-50) + 1) ;
+        here->HSM2_vbst = pParam->HSM2_nj / beta 
+          * log (pParam->HSM2_vdiffj * (TTEMP / model->HSM2_tnom) * (TTEMP / model->HSM2_tnom) 
+                 / (here->HSM2_isbs + 1.0e-50) + 1) ;
+
+        here->HSM2_exptemp = exp (((TTEMP / model->HSM2_tnom) - 1) * model->HSM2_ctemp) ;
+        here->HSM2_jd_nvtm_inv = 1.0 / ( pParam->HSM2_nj / beta ) ;
+        here->HSM2_jd_expcd = exp (here->HSM2_vbdt * here->HSM2_jd_nvtm_inv ) ;
+        here->HSM2_jd_expcs = exp (here->HSM2_vbst * here->HSM2_jd_nvtm_inv ) ;
+
+	/* costi0 and costi1 for STI transistor model (temperature-dependent part) */
+	here->HSM2_costi0 = here->HSM2_costi00 * sqrt(here->HSM2_beta_inv) ;
+	here->HSM2_costi0_p2 = here->HSM2_costi0 * here->HSM2_costi0 ; 
+	here->HSM2_costi1 = here->HSM2_nin * here->HSM2_nin * here->HSM2_nsti_p2 ;
+
+        /* check if SC3 is too large */
+        if (pParam->HSM2_sc3 && model->HSM2_sc3Vbs < 0.0) {
+
+          beta     = here->HSM2_beta ;
+          beta_inv = here->HSM2_beta_inv ;
+          Weff     = here->HSM2_weff ;
+          Vfb      = pParam->HSM2_vfbc ;
+          Pb20     = here->HSM2_pb20 ; 
+          cnst0    = here->HSM2_cnst0 ;
+          cnst1    = here->HSM2_cnst1 ;
+          c_eox    = here->HSM2_cecox ;
+          Tox      = model->HSM2_tox ;
+          Cox      = c_eox / Tox ;
+          Cox_inv  = 1.0 / Cox ;
+          fac1     = cnst0 * Cox_inv ;
+          Vgs_min  = model->HSM2_type * model->HSM2_Vgsmin ;
+          sc3Vbs   = model->HSM2_sc3Vbs ;
+          sc3Vgs   = 2.0 ;
+          Ps0_min  = 2.0 * beta_inv * log(-Vgs_min/fac1) ;
+
+          /* approximate solution of Poisson equation for large
+             Vgs and negative Vbs (3 iterations!)*/
+          Vgp = sc3Vgs - Vfb;
+          Denom = fac1*sqrt(cnst1);
+          Ps0 = 2.0 * beta_inv * log(Vgp/Denom);
+          Ps0 = 2.0 * beta_inv * log((Vgp-Ps0)/Denom);
+          Ps0 = 2.0 * beta_inv * log((Vgp-Ps0)/Denom);
+          Ps0 = 2.0 * beta_inv * log((Vgp-Ps0)/Denom);
+          Ps0_dVbs = 0.0;
+
+          T1   = here->HSM2_2qnsub_esi ;
+          Qb0  = sqrt ( T1 ) ;
+          Vthp = Ps0 + Vfb + Qb0 * Cox_inv + here->HSM2_ptovr ;
+
+          T1     = 2.0 * C_QE * pParam->HSM2_nsubc * C_ESI ;
+          T2     = sqrt( T1 ) ;
+          Vth0   = Ps0 + Vfb + T2 * Cox_inv ;
+          T1     = C_ESI * Cox_inv ;
+          T2     = here->HSM2_wdplp ;
+          T4     = 1.0e0 / ( model->HSM2_lp * model->HSM2_lp ) ;
+          T3     = 2.0 * ( model->HSM2_vbi - Pb20 ) * T2 * T4 ;
+          T5     = T1 * T3 ;
+          T6     = Ps0 - sc3Vbs ;
+          T6_dVb = Ps0_dVbs - 1.0 ;
+          dVth0  = T5 * sqrt( T6 ) ;
+          dVth0_dVb = T5 * 0.5 / sqrt( T6 ) * T6_dVb;
+          T1     = Vthp - Vth0 ;
+          T9     = Ps0 - sc3Vbs ;
+          T9_dVb = Ps0_dVbs - 1.0 ;
+          T3     = pParam->HSM2_scp1 + pParam->HSM2_scp3 * T9 / model->HSM2_lp;
+          T3_dVb = pParam->HSM2_scp3 * T9_dVb / model->HSM2_lp ;
+          dVthLP = T1 * dVth0 * T3 ;
+          dVthLP_dVb = T1 * dVth0_dVb * T3 + T1 * dVth0 * T3_dVb;
+
+          T3 = here->HSM2_lgate - model->HSM2_parl2 ;
+          T4 = 1.0e0 / ( T3 * T3 ) ;
+          T0 = C_ESI * here->HSM2_wdpl * 2.0e0 * ( model->HSM2_vbi - Pb20 ) * T4 ;
+          T2 = T0 * Cox_inv ;
+          T5 = pParam->HSM2_sc3 / here->HSM2_lgate ;
+          T6 = pParam->HSM2_sc1 + T5 * ( Ps0 - sc3Vbs ) ;
+          T1 = T6 ;
+          A  = T2 * T1 ;
+          T9 = Ps0 - sc3Vbs + Ps0_min ;
+          T9_dVb = Ps0_dVbs - 1.0 ;
+          T8     = sqrt( T9 ) ;
+          T8_dVb = 0.5 * T9_dVb / T8 ;
+          dVthSC = A * T8 ;
+
+          T1 = 1.0 / Cox ;
+          T3 = 1.0 / ( Cox + pParam->HSM2_wfc / Weff ) ;
+          T5 = T1 - T3 ;
+          dVthW = Qb0 * T5 + pParam->HSM2_wvth0 / here->HSM2_wg ;
+
+          dVth = dVthSC + dVthLP + dVthW + here->HSM2_dVthsm ;
+          dPpg = 0.0 ;
+          Vgp = sc3Vgs - Vfb + dVth - dPpg ;
+
+          /* Recalculation of Ps0, using more accurate Vgp */
+          Ps0 = 2.0 * beta_inv * log(Vgp/Denom);
+          Ps0 = 2.0 * beta_inv * log((Vgp-Ps0)/Denom);
+          Ps0 = 2.0 * beta_inv * log((Vgp-Ps0)/Denom);
+          Ps0 = 2.0 * beta_inv * log((Vgp-Ps0)/Denom);
+
+          term1 = Vgp - Ps0;
+          term2 = sqrt(beta*(Ps0-sc3Vbs)-1.0);
+          term3 = term1 + fac1 * term2;
+          term4 = cnst1 * exp(beta*Ps0);
+          limVgp_dVbs = - beta * (term3 + 0.5*fac1 * term4/term2)
+                  / (2.0*term1/fac1/fac1*term3 - term4);
+          T2     = T0 * Cox_inv ;
+          sc3lim = here->HSM2_lgate / T2 
+               * (limVgp_dVbs - dVthLP_dVb - T2*pParam->HSM2_sc1*T8_dVb)
+               / ((Ps0-sc3Vbs)*T8_dVb +(Ps0_dVbs-1.0)*T8);
+          if (sc3lim < 1.0e-20)
+              sc3lim = 1e-20 ;
+          if (sc3lim < pParam->HSM2_sc3 * 0.999) {
+            pParam->HSM2_sc3 = sc3lim;
+          }
+        }
+    }
+  }
+  return(OK);
+}

src/spicelib/devices/hisim2/hsm2trunc.c

@@ -0,0 +1,54 @@
+/***********************************************************************
+
+ HiSIM (Hiroshima University STARC IGFET Model)
+ Copyright (C) 2011 Hiroshima University & STARC
+
+ VERSION : HiSIM_2.5.1 
+ FILE : hsm2trunc.c
+
+ date : 2011.04.07
+
+ released by 
+                Hiroshima University &
+                Semiconductor Technology Academic Research Center (STARC)
+***********************************************************************/
+
+#include "spice.h"
+#include <stdio.h>
+#include "cktdefs.h"
+#include "hsm2def.h"
+#include "sperror.h"
+#include "suffix.h"
+
+int HSM2trunc(inModel,ckt,timeStep)
+     GENmodel *inModel;
+     register CKTcircuit *ckt;
+     double *timeStep;
+
+{
+  register HSM2model *model = (HSM2model*)inModel;
+  register HSM2instance *here;
+#ifdef STEPDEBUG
+  double debugtemp;
+#endif /* STEPDEBUG */
+  
+  for ( ;model != NULL ;model = model->HSM2nextModel ) {
+    for ( here=model->HSM2instances ;here!=NULL ;
+	  here = here->HSM2nextInstance ) {
+#ifdef STEPDEBUG
+      debugtemp = *timeStep;
+#endif /* STEPDEBUG */
+      CKTterr(here->HSM2qb,ckt,timeStep);
+      CKTterr(here->HSM2qg,ckt,timeStep);
+      CKTterr(here->HSM2qd,ckt,timeStep);
+#ifdef STEPDEBUG
+      if ( debugtemp != *timeStep ) 
+	printf("device %s reduces step from %g to %g\n",
+	       here->HSM2name, debugtemp, *timeStep);
+#endif /* STEPDEBUG */
+    }
+  }
+  return(OK);
+}
+
+