pnenzi
23 years ago
27 changed files with 14464 additions and 0 deletions
-
37src/spicelib/devices/hisim/Makefile.am
-
357src/spicelib/devices/hisim/hisim.h
-
166src/spicelib/devices/hisim/hsm1.c
-
183src/spicelib/devices/hisim/hsm1acld.c
-
231src/spicelib/devices/hisim/hsm1ask.c
-
106src/spicelib/devices/hisim/hsm1cvtest.c
-
694src/spicelib/devices/hisim/hsm1def.h
-
41src/spicelib/devices/hisim/hsm1del.c
-
41src/spicelib/devices/hisim/hsm1dest.c
-
4572src/spicelib/devices/hisim/hsm1eval1_0.c
-
4758src/spicelib/devices/hisim/hsm1eval1_1.c
-
84src/spicelib/devices/hisim/hsm1evalenv.h
-
37src/spicelib/devices/hisim/hsm1ext.h
-
56src/spicelib/devices/hisim/hsm1getic.c
-
82src/spicelib/devices/hisim/hsm1init.c
-
13src/spicelib/devices/hisim/hsm1init.h
-
13src/spicelib/devices/hisim/hsm1itf.h
-
1036src/spicelib/devices/hisim/hsm1ld.c
-
379src/spicelib/devices/hisim/hsm1mask.c
-
48src/spicelib/devices/hisim/hsm1mdel.c
-
495src/spicelib/devices/hisim/hsm1mpar.c
-
284src/spicelib/devices/hisim/hsm1noi.c
-
105src/spicelib/devices/hisim/hsm1par.c
-
211src/spicelib/devices/hisim/hsm1pzld.c
-
347src/spicelib/devices/hisim/hsm1set.c
-
35src/spicelib/devices/hisim/hsm1temp.c
-
53src/spicelib/devices/hisim/hsm1trunc.c
@ -0,0 +1,37 @@ |
|||
## Process this file with automake to produce Makefile.in
|
|||
|
|||
noinst_LIBRARIES = libhisim.a |
|||
|
|||
libhisim_a_SOURCES = \
|
|||
hsm1.c \
|
|||
hsm1acld.c \
|
|||
hsm1ask.c \
|
|||
hsm1cvtest.c \
|
|||
hsm1del.c \
|
|||
hsm1dest.c \
|
|||
hsm1eval1_0.c \
|
|||
hsm1eval1_1.c \
|
|||
hsm1getic.c \
|
|||
hsm1ld.c \
|
|||
hsm1mask.c \
|
|||
hsm1mdel.c \
|
|||
hsm1mpar.c \
|
|||
hsm1noi.c \
|
|||
hsm1par.c \
|
|||
hsm1pzld.c \
|
|||
hsm1set.c \
|
|||
hsm1temp.c \
|
|||
hsm1trunc.c \
|
|||
hisim1.h \
|
|||
hsm1evalenv.h \
|
|||
hsm1def.h \
|
|||
hsm1ext.h \
|
|||
hsm1init.c \
|
|||
hsm1init.h \
|
|||
hsm1itf.h |
|||
|
|||
|
|||
|
|||
INCLUDES = -I$(top_srcdir)/src/include |
|||
|
|||
MAINTAINERCLEANFILES = Makefile.in |
|||
@ -0,0 +1,357 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hisim.h of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#ifndef _HiSIM_H |
|||
#define _HiSIM_H |
|||
|
|||
/*#define HiSIM_TIME 0*/ |
|||
|
|||
/* 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 |
|||
|
|||
|
|||
/*-------------------------------------------------------------------* |
|||
* Structure for inputs of hisim. |
|||
*----------------*/ |
|||
typedef struct sHiSIM_input { |
|||
|
|||
/* Flags that must be set in parent routines. */ |
|||
int type ; /* MOS type (1:NMOS, -1:PMOS) */ |
|||
int mode ; /* MOS mode (1:normal, -1:reverse) */ |
|||
int qflag ; /* qflag (toggle for charge calc. Unused!) */ |
|||
int has_prv ; /* 1 if previous values are held. */ |
|||
|
|||
/* Bias conditions */ |
|||
double vbs ; /* Vbs [V] */ |
|||
double vds ; /* Vds [V] */ |
|||
double vgs ; /* Vgs [V] */ |
|||
|
|||
/* frequency [Hz] */ |
|||
double freq ; |
|||
|
|||
/* Control options that can be set in a model parameter set. */ |
|||
int info ; /* information level (for debug, etc.) */ |
|||
int corsrd ; /* solve equations accounting Rs and Rd. */ |
|||
int coiprv ; /* use ids_prv as initial guess of Ids */ |
|||
int copprv ; /* use ps{0/l}_prv as initial guess of Ps{0/l} */ |
|||
int cocgso ; /* calculate cgso */ |
|||
int cocgdo ; /* calculate cgdo */ |
|||
int cocgbo ; /* calculate cgbo */ |
|||
int coadov ; /* add overlap to intrisic */ |
|||
int coxx08 ; /* spare */ |
|||
int coxx09 ; /* spare */ |
|||
int coisub ; /* calculate isub */ |
|||
int coiigs ; /* calculate igs */ |
|||
int cogidl ; /* calculate ilg */ |
|||
int coovlp ; /* calculate overlap charge */ |
|||
int conois ; /* calculate 1/f noise */ |
|||
int coisti ; /* calculate STI */ |
|||
|
|||
/* Previous values that may be used as initial guesses */ |
|||
/* - derivatives are ones w.r.t. internal biases. */ |
|||
double vbsc_prv ; |
|||
double vdsc_prv ; |
|||
double vgsc_prv ; |
|||
double ps0_prv ; |
|||
double ps0_dvbs_prv ; |
|||
double ps0_dvds_prv ; |
|||
double ps0_dvgs_prv ; |
|||
double pds_prv ; |
|||
double pds_dvbs_prv ; |
|||
double pds_dvds_prv ; |
|||
double pds_dvgs_prv ; |
|||
double ids_prv ; |
|||
double ids_dvbs_prv ; |
|||
double ids_dvds_prv ; |
|||
double ids_dvgs_prv ; |
|||
|
|||
/* for noise calc. */ |
|||
double nfc ; |
|||
|
|||
/* Device instances */ |
|||
double xl ; /* channel length [m] (L=xl-xld) */ |
|||
double xw ; /* channel width [m] (W=xw-xwd) */ |
|||
double ad ; /* area of drain diffusion [m^2] */ |
|||
double as ; /* area of source diffusion [m^2] */ |
|||
double pd ; /* perimeter of drain junction [m] */ |
|||
double ps ; /* perimeter of source junction [m] */ |
|||
double nrd ; /* equivalent num of squares of drain [-] (unused) */ |
|||
double nrs ; /* equivalent num of squares of source [-] (unused) */ |
|||
double temp ; /* lattice temperature [K] */ |
|||
|
|||
/* Model parameters */ |
|||
double vmax ; /* saturation velocity [cm/s] */ |
|||
double bgtmp1 ; /* first order temp. coeff. for band gap [V/K] */ |
|||
double bgtmp2 ; /* second order temp. coeff. for band gap [V/K^2] */ |
|||
double tox ; /* oxide thickness [m] */ |
|||
double xld ; /* lateral diffusion of S/D under the gate [m] */ |
|||
double xwd ; /* lateral diffusion along the width dir. [m] */ |
|||
double xj ; /* HiSIM1.0 [m] */ |
|||
double xqy ; /* HiSIM1.1 [m] */ |
|||
/*--*/ |
|||
double rd ; /* drain contact resistance [ohm m] */ |
|||
double rs ; /* source contact resistance [ohm m] */ |
|||
/**/ |
|||
double vfbc ; /* constant part of Vfb [V] */ |
|||
double nsubc ; /* constant part of Nsub [1/cm^3] */ |
|||
double parl1 ; /* factor for L dependency of dVthSC [-] */ |
|||
double parl2 ; /* under diffusion [m] */ |
|||
double lp ; /* length of pocket potential [m] */ |
|||
double nsubp ; /* [1/cm^3] */ |
|||
double scp1 ; /* parameter for pocket [1/V] */ |
|||
double scp2 ; /* parameter for pocket [1/V^2] */ |
|||
double scp3 ; /* parameter for pocket [m/V^2] */ |
|||
double sc1 ; /* parameter for SCE [1/V] */ |
|||
double sc2 ; /* parameter for SCE [1/V^2] */ |
|||
double sc3 ; /* parameter for SCE [m/V^2] */ |
|||
double pgd1 ; /* parameter for gate-poly depletion [V] */ |
|||
double pgd2 ; /* parameter for gate-poly depletion [V] */ |
|||
double pgd3 ; /* parameter for gate-poly depletion [-] */ |
|||
/**/ |
|||
double ndep ; /* coeff. of Qbm for Eeff [-] */ |
|||
double ninv ; /* coeff. of Qnm for Eeff [-] */ |
|||
double ninvd ; /* parameter for universal mobility [1/V] */ |
|||
double muecb0 ; /* const. part of coulomb scattering [cm^2/Vs] */ |
|||
double muecb1 ; /* coeff. for coulomb scattering [cm^2/Vs] */ |
|||
double mueph0 ; /* power of Eeff for phonon scattering [-] */ |
|||
double mueph1 ; |
|||
double mueph2 ; |
|||
double w0 ; |
|||
double muesr0 ; /* power of Eeff for S.R. scattering [-] */ |
|||
double muesr1 ; /* coeff. for S.R. scattering [-] */ |
|||
double muetmp ; /* parameter for mobility [-] */ |
|||
double bb ; /* empirical mobility model coefficient [-] */ |
|||
double vds0 ; /* Vds0 used for low field mobility [V] */ |
|||
double bc0 ; /* coeff. for BC */ |
|||
double bc1 ; /* power of L for BC */ |
|||
/**/ |
|||
double sub1 ; /* parameter for Isub [1/V] */ |
|||
double sub2 ; /* parameter for Isub [V] */ |
|||
double sub3 ; /* parameter for Isub [-] */ |
|||
/**/ |
|||
double wvthsc ; /* parameter for STI [-] HiSIM1.1 */ |
|||
double nsti ; /* parameter for STI [1/cm^3] HiSIM1.1 */ |
|||
double wsti ; /* parameter for STI [m] HiSIM1.1 */ |
|||
/**/ |
|||
double cgso ; /* G-S overlap capacitance per unit W [F/m] */ |
|||
double cgdo ; /* G-D overlap capacitance per unit W [F/m] */ |
|||
double cgbo ; /* G-B overlap capacitance per unit L [F/m] */ |
|||
/**/ |
|||
double tpoly ; /* hight of poly gate [m] */ |
|||
/**/ |
|||
double js0 ; /* Saturation current density [A/m^2] */ |
|||
double js0sw ; /* Side wall saturation current density [A/m] */ |
|||
double nj ; /* Emission coefficient */ |
|||
double njsw ; /* Emission coefficient (sidewall) */ |
|||
double xti ; /* Junction current temparature exponent coefficient */ |
|||
double cj ; /* Bottom junction capacitance per unit area |
|||
at zero bias [F/m^2]*/ |
|||
double cjsw ; /* Source/drain sidewall junction capacitance grading |
|||
coefficient per unit length at zero bias [F/m] */ |
|||
double cjswg ; /* Source/drain gate sidewall junction capacitance |
|||
per unit length at zero bias [F/m] */ |
|||
double mj ; /* Bottom junction capacitance grading coefficient */ |
|||
double mjsw ; /* Source/drain sidewall junction capacitance grading |
|||
coefficient */ |
|||
double mjswg ; /* Source/drain gate sidewall junction capacitance grading |
|||
coefficient */ |
|||
double pb ; /* Bottom junction build-in potential [V] */ |
|||
double pbsw ; /* Source/drain sidewall junction build-in potential [V] */ |
|||
double pbswg ; /* Source/drain gate sidewall junction build-in potential [V] */ |
|||
double xpolyd ; /* parameter for Cov [m] */ |
|||
/**/ |
|||
double clm1 ; /* parameter for CLM [-] */ |
|||
double clm2 ; /* parameter for CLM [1/m] */ |
|||
double clm3 ; /* parameter for CLM [-] */ |
|||
/**/ |
|||
double rpock1 ; /* parameter for Ids [V] */ |
|||
double rpock2 ; /* parameter for Ids [V^2 sqrt(m)/A] */ |
|||
double rpocp1 ; /* parameter for Ids [-] HiSIM1.1 */ |
|||
double rpocp2 ; /* parameter for Ids [-] HiSIM1.1 */ |
|||
|
|||
/**/ |
|||
double vover ; /* parameter for overshoot [m^{voverp}]*/ |
|||
double voverp ; /* parameter for overshoot [-] */ |
|||
double wfc ; /* parameter for narrow channel effect [m*F/(cm^2)]*/ |
|||
double qme1 ; /* parameter for quantum effect [mV]*/ |
|||
double qme2 ; /* parameter for quantum effect [V]*/ |
|||
double qme3 ; /* parameter for quantum effect [m]*/ |
|||
double gidl1 ; /* parameter for GIDL [?] */ |
|||
double gidl2 ; /* parameter for GIDL [?] */ |
|||
double gidl3 ; /* parameter for GIDL [?] */ |
|||
double gleak1 ; /* parameter for gate current [?] */ |
|||
double gleak2 ; /* parameter for gate current [?] */ |
|||
double gleak3 ; /* parameter for gate current [?] */ |
|||
/**/ |
|||
double vzadd0 ; /* Vzadd at Vds=0 [V] */ |
|||
double pzadd0 ; /* Pzadd at Vds=0 [V] */ |
|||
|
|||
double nftrp ; |
|||
double nfalp ; |
|||
double cit ; |
|||
|
|||
double gmin ; /* gmin = minimam conductance of SPICE3 K.M. */ |
|||
} HiSIM_input ; |
|||
|
|||
/*-------------------------------------------------------------------* |
|||
* structure for outputs of hisim. |
|||
*----------------*/ |
|||
typedef struct sHiSIM_output { |
|||
double ids ; /* channel current [A] */ |
|||
double gds ; /* channel conductance (dIds/dVds) [S] */ |
|||
double gm ; /* trans conductance (dIds/dVgs) [S] */ |
|||
double gmbs ; /* substrate trans conductance (dIds/dVbs) [S] */ |
|||
/**/ |
|||
double gd ; /* parasitic drain conductance [S] */ |
|||
double gs ; /* parasitic source conductance [S] */ |
|||
/**/ |
|||
double cgso ; /* G-S overlap capacitance [F] */ |
|||
double cgdo ; /* G-D overlap capacitance [F] */ |
|||
double cgbo ; /* G-B overlap capacitance [F] */ |
|||
/**/ |
|||
double von ; /* Vth [V] */ |
|||
double vdsat ; /* saturation voltage [V] */ |
|||
/**/ |
|||
double capgs ; /* Meyer's gate capacitance (dQg/dVgs+cgso) [S] */ |
|||
double capgd ; /* Meyer's gate capacitance (dQg/dVgs+cgso) [S] */ |
|||
double capgb ; /* Meyer's gate capacitance (dQg/dVgs+cgso) [S] */ |
|||
/**/ |
|||
double ibs ; /* substrate source leakage current [A] */ |
|||
double ibd ; /* substrate drain leakage current [A] */ |
|||
double gbs ; /* substrate source conductance [S] */ |
|||
double gbd ; /* substrate drain conductance [S] */ |
|||
/**/ |
|||
double capbs ; /* substrate source capacitance [F] */ |
|||
double capbd ; /* substrate drain capacitance [F] */ |
|||
double qbs ; /* substrate source charge [C] */ |
|||
double qbd ; /* substrate drain charge [C] */ |
|||
/**/ |
|||
double isub ; /* substrate impact ionization current [A] */ |
|||
double gbgs ; /* substrate trans conductance (dIsub/dVgs) [S] */ |
|||
double gbds ; /* substrate trans conductance (dIsub/dVds) [S] */ |
|||
double gbbs ; /* substrate trans conductance (dIsub/dVbs) [S] */ |
|||
/**/ |
|||
double qg ; /* intrinsic gate charge [C] */ |
|||
double qd ; /* intrinsic drain charge [C] */ |
|||
double qs ; /* intrinsic source charge [C] */ |
|||
/**/ |
|||
double cggb ; /* intrinsic gate capacitance w.r.t. gate [F] */ |
|||
double cgdb ; /* intrinsic gate capacitance w.r.t. drain [F] */ |
|||
double cgsb ; /* intrinsic gate capacitance w.r.t. source [F] */ |
|||
double cbgb ; /* intrinsic bulk capacitance w.r.t. gate [F] */ |
|||
double cbdb ; /* intrinsic bulk capacitance w.r.t. drain [F] */ |
|||
double cbsb ; /* intrinsic bulk capacitance w.r.t. source [F] */ |
|||
double cdgb ; /* intrinsic drain capacitance w.r.t. gate [F] */ |
|||
double cddb ; /* intrinsic drain capacitance w.r.t. drain [F] */ |
|||
double cdsb ; /* intrinsic drain capacitance w.r.t. source [F] */ |
|||
/**/ |
|||
double igs ; /* gate current due to tunneling [A] */ |
|||
double gggs ; /* trans conductance (dIgs/dVgs) [S] */ |
|||
double ggds ; /* trans conductance (dIgs/dVds) [S] */ |
|||
double ggbs ; /* trans conductance (dIgs/dVbs) [S] */ |
|||
/**/ |
|||
double ilg ; /* gate induced drain leakage [A] */ |
|||
double glgs ; /* trans conductance (dIlg/dVgs) [S] */ |
|||
double glds ; /* trans conductance (dIlg/dVds) [S] */ |
|||
double glbs ; /* trans conductance (dIlg/dVbs) [S] */ |
|||
/**/ |
|||
double nois_idsfl ; |
|||
double nois_ird ; |
|||
double nois_irs ; |
|||
double nois_idsth ; |
|||
/**/ |
|||
/* Outputs that may be used as initial guesses in the next calling */ |
|||
double vbsc ; |
|||
double vdsc ; |
|||
double vgsc ; |
|||
double ps0 ; |
|||
double ps0_dvbs ; |
|||
double ps0_dvds ; |
|||
double ps0_dvgs ; |
|||
double pds ; |
|||
double pds_dvbs ; |
|||
double pds_dvds ; |
|||
double pds_dvgs ; |
|||
double ids_dvbs ; |
|||
double ids_dvds ; |
|||
double ids_dvgs ; |
|||
|
|||
/* for noise calc. */ |
|||
double nf ; |
|||
|
|||
/* mobility added by K.M. */ |
|||
double mu ; |
|||
} HiSIM_output ; |
|||
|
|||
/*-------------------------------------------------------------------* |
|||
* structure for messengers to/from hisim. |
|||
*----------------*/ |
|||
typedef struct sHiSIM_messenger { |
|||
int ims[20] ; |
|||
double dms[50] ; |
|||
/* Control options for alpha versions */ |
|||
int opt_ntn ; |
|||
int opt_psl ; |
|||
int opt_rsc ; |
|||
int opt_sce ; |
|||
int opt_mbl ; |
|||
int opt_dp0 ; |
|||
int opt_inv ; |
|||
int opt_bas ; |
|||
int opt_01 ; |
|||
int opt_02 ; |
|||
int opt_03 ; |
|||
int opt_04 ; |
|||
int opt_05 ; |
|||
} HiSIM_messenger ; |
|||
/* note: ----------------------------------- |
|||
* if HiSIM_TEST is defined. |
|||
* ims[ 1 ] :(in) =1: output physical capacitances instead of ones |
|||
* referenced to bulk. |
|||
* ims[11-12] , dms[11-39] :(ot) additional outputs. |
|||
* if CMI_OK is defined. |
|||
* dms[ 1 ] :(in) timepoint. |
|||
-------------------------------------------*/ |
|||
|
|||
#endif /* _HiSIM_H */ |
|||
@ -0,0 +1,166 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "devdefs.h" |
|||
#include "hsm1def.h" |
|||
#include "suffix.h" |
|||
|
|||
IFparm HSM1pTable[] = { /* parameters */ |
|||
IOP( "l", HSM1_L, IF_REAL , "Length"), |
|||
IOP( "w", HSM1_W, IF_REAL , "Width"), |
|||
IOP( "m", HSM1_M, IF_REAL , "Parallel multiplier"), |
|||
IOP( "ad", HSM1_AD, IF_REAL , "Drain area"), |
|||
IOP( "as", HSM1_AS, IF_REAL , "Source area"), |
|||
IOP( "pd", HSM1_PD, IF_REAL , "Drain perimeter"), |
|||
IOP( "ps", HSM1_PS, IF_REAL , "Source perimeter"), |
|||
IOP( "nrd", HSM1_NRD, IF_REAL , "Number of squares in drain"), |
|||
IOP( "nrs", HSM1_NRS, IF_REAL , "Number of squares in source"), |
|||
IOP( "temp", HSM1_TEMP, IF_REAL , "Lattice temperature"), |
|||
IOP( "dtemp", HSM1_DTEMP,IF_REAL , ""), |
|||
IOP( "off", HSM1_OFF, IF_FLAG , "Device is initially off"), |
|||
IP ( "ic", HSM1_IC, IF_REALVEC , "Vector of DS,GS,BS initial voltages") |
|||
}; |
|||
|
|||
IFparm HSM1mPTable[] = { /* model parameters */ |
|||
IP("nmos", HSM1_MOD_NMOS, IF_FLAG, ""), |
|||
IP("pmos", HSM1_MOD_PMOS, IF_FLAG, ""), |
|||
IOP("level", HSM1_MOD_LEVEL, IF_INTEGER, ""), |
|||
IOP("info", HSM1_MOD_INFO, IF_INTEGER, "information level (for debug, etc.)"), |
|||
IOP("noise", HSM1_MOD_NOISE, IF_INTEGER, "noise model selector"), |
|||
IOP("version", HSM1_MOD_VERSION, IF_INTEGER, "model version 100 or 110"), |
|||
IOP("show", HSM1_MOD_SHOW, IF_INTEGER, "show physical value"), |
|||
IOP("corsrd", HSM1_MOD_CORSRD, IF_INTEGER, "solve equations accounting Rs and Rd."), |
|||
IOP("coiprv", HSM1_MOD_COIPRV, IF_INTEGER, "use ids_prv as initial guess of Ids"), |
|||
IOP("copprv", HSM1_MOD_COPPRV, IF_INTEGER, "use ps{0/l}_prv as initial guess of Ps{0/l}"), |
|||
IOP("cocgso", HSM1_MOD_COCGSO, IF_INTEGER, "calculate cgso"), |
|||
IOP("cocgdo", HSM1_MOD_COCGDO, IF_INTEGER, "calculate cgdo"), |
|||
IOP("cocgbo", HSM1_MOD_COCGBO, IF_INTEGER, "calculate cgbo"), |
|||
IOP("coadov", HSM1_MOD_COADOV, IF_INTEGER, "add overlap to intrisic"), |
|||
IOP("coxx08", HSM1_MOD_COXX08, IF_INTEGER, "spare"), |
|||
IOP("coxx09", HSM1_MOD_COXX09, IF_INTEGER, "spare"), |
|||
IOP("coisub", HSM1_MOD_COISUB, IF_INTEGER, "calculate isub"), |
|||
IOP("coiigs", HSM1_MOD_COIIGS, IF_INTEGER, "calculate igs"), |
|||
IOP("cogidl", HSM1_MOD_COGIDL, IF_INTEGER, "calculate ilg"), |
|||
IOP("coovlp", HSM1_MOD_COOVLP, IF_INTEGER, "calculate overlap charge"), |
|||
IOP("conois", HSM1_MOD_CONOIS, IF_INTEGER, "calculate 1/f noise"), |
|||
IOP("coisti", HSM1_MOD_COISTI, IF_INTEGER, "calculate STI HiSIM1.1"), |
|||
IOP("vmax", HSM1_MOD_VMAX, IF_REAL, "saturation velocity [cm/s"), |
|||
IOP("bgtmp1", HSM1_MOD_BGTMP1, IF_REAL, "first order temp. coeff. for band gap [V/K]"), |
|||
IOP("bgtmp2", HSM1_MOD_BGTMP2, IF_REAL, "second order temp. coeff. for band gap [V/K^2]"), |
|||
IOP("tox", HSM1_MOD_TOX, IF_REAL, "oxide thickness [m]"), |
|||
IOP("dl", HSM1_MOD_DL, IF_REAL, "lateral diffusion of S/D under the gate [m]"), |
|||
IOP("dw", HSM1_MOD_DW, IF_REAL, "lateral diffusion along the width dir. [m]"), |
|||
IOP("xld", HSM1_MOD_DL, IF_REAL, "lateral diffusion of S/D under the gate [m]"), |
|||
IOP("xwd", HSM1_MOD_DW, IF_REAL, "lateral diffusion along the width dir. [m]"), |
|||
IOP("xj", HSM1_MOD_XJ, IF_REAL, "HiSIM1.0 [m]"), |
|||
IOP("xqy", HSM1_MOD_XQY, IF_REAL, "HiSIM1.1 [m]"), |
|||
IOP("rs", HSM1_MOD_RS, IF_REAL, "source contact resistance [ohm m]"), |
|||
IOP("rd", HSM1_MOD_RD, IF_REAL, "drain contact resistance [ohm m]"), |
|||
IOP("vfbc", HSM1_MOD_VFBC, IF_REAL, "constant part of Vfb [V]"), |
|||
IOP("nsubc", HSM1_MOD_NSUBC, IF_REAL, "constant part of Nsub [1/cm^3]"), |
|||
IOP("parl1", HSM1_MOD_PARL1, IF_REAL, "factor for L dependency of dVthSC [-]"), |
|||
IOP("parl2", HSM1_MOD_PARL2, IF_REAL, "under diffusion [m]"), |
|||
IOP("lp", HSM1_MOD_LP, IF_REAL, "length of pocket potential [m]"), |
|||
IOP("nsubp", HSM1_MOD_NSUBP, IF_REAL, "[1/cm^3]"), |
|||
IOP("scp1", HSM1_MOD_SCP1, IF_REAL, "parameter for pocket [1/V]"), |
|||
IOP("scp2", HSM1_MOD_SCP2, IF_REAL, "parameter for pocket [1/V^2]"), |
|||
IOP("scp3", HSM1_MOD_SCP3, IF_REAL, "parameter for pocket [m/V^2]"), |
|||
IOP("sc1", HSM1_MOD_SC1, IF_REAL, "parameter for SCE [1/V]"), |
|||
IOP("sc2", HSM1_MOD_SC2, IF_REAL, "parameter for SCE [1/V^2]"), |
|||
IOP("sc3", HSM1_MOD_SC3, IF_REAL, "parameter for SCE [m/V^2]"), |
|||
IOP("pgd1", HSM1_MOD_PGD1, IF_REAL, "parameter for gate-poly depletion [V]"), |
|||
IOP("pgd2", HSM1_MOD_PGD2, IF_REAL, "parameter for gate-poly depletion [V]"), |
|||
IOP("pgd3", HSM1_MOD_PGD3, IF_REAL, "parameter for gate-poly depletion [-]"), |
|||
IOP("ndep", HSM1_MOD_NDEP, IF_REAL, "coeff. of Qbm for Eeff [-]"), |
|||
IOP("ninv", HSM1_MOD_NINV, IF_REAL, "coeff. of Qnm for Eeff [-]"), |
|||
IOP("ninvd", HSM1_MOD_NINVD, IF_REAL, "parameter for universal mobility [1/V]"), |
|||
IOP("muecb0", HSM1_MOD_MUECB0, IF_REAL, "const. part of coulomb scattering [cm^2/Vs]"), |
|||
IOP("muecb1", HSM1_MOD_MUECB1, IF_REAL, "coeff. for coulomb scattering [cm^2/Vs]"), |
|||
IOP("mueph0", HSM1_MOD_MUEPH0, IF_REAL, "power of Eeff for phonon scattering [-]"), |
|||
IOP("mueph1", HSM1_MOD_MUEPH1, IF_REAL, ""), |
|||
IOP("mueph2", HSM1_MOD_MUEPH2, IF_REAL, ""), |
|||
IOP("w0", HSM1_MOD_W0, IF_REAL, ""), |
|||
IOP("muesr0", HSM1_MOD_MUESR0, IF_REAL, "power of Eeff for S.R. scattering [-]"), |
|||
IOP("muesr1", HSM1_MOD_MUESR1, IF_REAL, "coeff. for S.R. scattering [-]"), |
|||
IOP("muetmp", HSM1_MOD_MUETMP, IF_REAL, "parameter for mobility [-]"), |
|||
IOP("bb", HSM1_MOD_BB, IF_REAL, "empirical mobility model coefficient [-]"), |
|||
IOP("vds0", HSM1_MOD_VDS0, IF_REAL, "Vds0 used for low field mobility [V]"), |
|||
IOP("sub1", HSM1_MOD_SUB1, IF_REAL, "parameter for Isub [1/V]"), |
|||
IOP("sub2", HSM1_MOD_SUB2, IF_REAL, "parameter for Isub [V]"), |
|||
IOP("sub3", HSM1_MOD_SUB3, IF_REAL, "parameter for Isub [-]"), |
|||
IOP("wvthsc", HSM1_MOD_WVTHSC, IF_REAL, "parameter for STI [-] HiSIM1.1"), |
|||
IOP("nsti", HSM1_MOD_NSTI, IF_REAL, "parameter for STI [1/cm^3] HiSIM1.1"), |
|||
IOP("wsti", HSM1_MOD_WSTI, IF_REAL, "parameter for STI [m] HiSIM1.1"), |
|||
IOP("cgso", HSM1_MOD_CGSO, IF_REAL, "G-S overlap capacitance per unit W [F/m]"), |
|||
IOP("cgdo", HSM1_MOD_CGDO, IF_REAL, "G-D overlap capacitance per unit W [F/m]"), |
|||
IOP("cgbo", HSM1_MOD_CGBO, IF_REAL, "G-B overlap capacitance per unit L [F/m]"), |
|||
IOP("tpoly", HSM1_MOD_TPOLY, IF_REAL, "hight of poly gate [m]"), |
|||
IOP("js0", HSM1_MOD_JS0, IF_REAL, "Saturation current density [A/m^2]"), |
|||
IOP("js0sw", HSM1_MOD_JS0SW, IF_REAL, "Side wall saturation current density [A/m]"), |
|||
IOP("nj", HSM1_MOD_NJ, IF_REAL, "Emission coefficient"), |
|||
IOP("njsw", HSM1_MOD_NJSW, IF_REAL, "Emission coefficient (sidewall)"), |
|||
IOP("xti", HSM1_MOD_XTI, IF_REAL, "Junction current temparature exponent coefficient"), |
|||
IOP("cj", HSM1_MOD_CJ, IF_REAL, "Bottom junction capacitance per unit area at zero bias [F/m^2]"), |
|||
IOP("cjsw", HSM1_MOD_CJSW, IF_REAL, "Source/drain sidewall junction capacitance grading coefficient per unit length at zero bias [F/m]"), |
|||
IOP("cjswg", HSM1_MOD_CJSWG, IF_REAL, "Source/drain gate sidewall junction capacitance per unit length at zero bias [F/m]"), |
|||
IOP("mj", HSM1_MOD_MJ, IF_REAL, "Bottom junction capacitance grading coefficient"), |
|||
IOP("mjsw", HSM1_MOD_MJSW, IF_REAL, "Source/drain sidewall junction capacitance grading coefficient"), |
|||
IOP("mjswg", HSM1_MOD_MJSWG, IF_REAL, "Source/drain gate sidewall junction capacitance grading coefficient"), |
|||
IOP("pb", HSM1_MOD_PB, IF_REAL, "Bottom junction build-in potential [V]"), |
|||
IOP("pbsw", HSM1_MOD_PBSW, IF_REAL, "Source/drain sidewall junction build-in potential [V]"), |
|||
IOP("pbswg", HSM1_MOD_PBSWG, IF_REAL, "Source/drain gate sidewall junction build-in potential [V]"), |
|||
IOP("xpolyd", HSM1_MOD_XPOLYD, IF_REAL, "parameter for Cov [m]"), |
|||
IOP("clm1", HSM1_MOD_CLM1, IF_REAL, "parameter for CLM [-]"), |
|||
IOP("clm2", HSM1_MOD_CLM2, IF_REAL, "parameter for CLM [1/m]"), |
|||
IOP("clm3", HSM1_MOD_CLM3, IF_REAL, "parameter for CLM [-]"), |
|||
IOP("rpock1", HSM1_MOD_RPOCK1, IF_REAL, "parameter for Ids [V^2 sqrt(m)/A]"), |
|||
IOP("rpock2", HSM1_MOD_RPOCK2, IF_REAL, "parameter for Ids [V]"), |
|||
IOP("rpocp1", HSM1_MOD_RPOCP1, IF_REAL, "parameter for Ids [-] HiSIM1.1"), |
|||
IOP("rpocp2", HSM1_MOD_RPOCP2, IF_REAL, "parameter for Ids [-] HiSIM1.1"), |
|||
IOP("vover", HSM1_MOD_VOVER, IF_REAL, "parameter for overshoot [m^{voverp}]"), |
|||
IOP("voverp", HSM1_MOD_VOVERP, IF_REAL, "parameter for overshoot [-]"), |
|||
IOP("wfc", HSM1_MOD_WFC, IF_REAL, "parameter for narrow channel effect [m*F/(cm^2)]"), |
|||
IOP("qme1", HSM1_MOD_QME1, IF_REAL, "parameter for quantum effect [mV]"), |
|||
IOP("qme2", HSM1_MOD_QME2, IF_REAL, "parameter for quantum effect [V]"), |
|||
IOP("qme3", HSM1_MOD_QME3, IF_REAL, "parameter for quantum effect [m]"), |
|||
IOP("gidl1", HSM1_MOD_GIDL1, IF_REAL, "parameter for GIDL [?]"), |
|||
IOP("gidl2", HSM1_MOD_GIDL2, IF_REAL, "parameter for GIDL [?]"), |
|||
IOP("gidl3", HSM1_MOD_GIDL3, IF_REAL, "parameter for GIDL [?]"), |
|||
IOP("gleak1", HSM1_MOD_GLEAK1, IF_REAL, "parameter for gate current [?]"), |
|||
IOP("gleak2", HSM1_MOD_GLEAK2, IF_REAL, "parameter for gate current [?]"), |
|||
IOP("gleak3", HSM1_MOD_GLEAK3, IF_REAL, "parameter for gate current [?]"), |
|||
IOP("vzadd0", HSM1_MOD_VZADD0, IF_REAL, "Vzadd at Vds=0 [V]"), |
|||
IOP("pzadd0", HSM1_MOD_PZADD0, IF_REAL, "Pzadd at Vds=0 [V]"), |
|||
IOP("nftrp", HSM1_MOD_NFTRP, IF_REAL, ""), |
|||
IOP("nfalp", HSM1_MOD_NFALP, IF_REAL, ""), |
|||
IOP("cit", HSM1_MOD_CIT, IF_REAL, ""), |
|||
IOP( "ef", HSM1_MOD_EF, IF_REAL, "flicker noise frequency exponent"), |
|||
IOP( "af", HSM1_MOD_AF, IF_REAL, "flicker noise exponent"), |
|||
IOP( "kf", HSM1_MOD_KF, IF_REAL, "flicker noise coefficient") |
|||
}; |
|||
|
|||
char *HSM1names[] = { |
|||
"Drain", |
|||
"Gate", |
|||
"Source", |
|||
"Bulk" |
|||
}; |
|||
|
|||
int HSM1nSize = NUMELEMS(HSM1names); |
|||
int HSM1pTSize = NUMELEMS(HSM1pTable); |
|||
int HSM1mPTSize = NUMELEMS(HSM1mPTable); |
|||
int HSM1iSize = sizeof(HSM1instance); |
|||
int HSM1mSize = sizeof(HSM1model); |
|||
@ -0,0 +1,183 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1acld.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "cktdefs.h" |
|||
#include "hsm1def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
|
|||
int HSM1acLoad(GENmodel *inModel, CKTcircuit *ckt) |
|||
{ |
|||
HSM1model *model = (HSM1model*)inModel; |
|||
HSM1instance *here; |
|||
double xcggb, xcgdb, xcgsb, xcbgb, xcbdb, xcbsb, xcddb, xcssb, xcdgb; |
|||
double gdpr, gspr, gds, gbd, gbs, capbd, capbs, xcsgb, xcdsb, xcsdb; |
|||
double cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cddb, cdgb, cdsb, omega; |
|||
double cgso, cgdo, cgbo, FwdSum, RevSum, gm, gmbs; |
|||
double gbspsp, gbbdp, gbbsp, gbspg, gbspb; |
|||
double gbspdp, gbdpdp, gbdpg, gbdpb, gbdpsp; |
|||
|
|||
double m; |
|||
|
|||
omega = ckt->CKTomega; |
|||
for ( ; model != NULL; model = model->HSM1nextModel ) { |
|||
for ( here = model->HSM1instances; here!= NULL; |
|||
here = here->HSM1nextInstance ) { |
|||
|
|||
if (here->HSM1owner != ARCHme) |
|||
continue; |
|||
|
|||
if ( here->HSM1_mode >= 0 ) { |
|||
gm = here->HSM1_gm; |
|||
gmbs = here->HSM1_gmbs; |
|||
FwdSum = gm + gmbs; |
|||
RevSum = 0.0; |
|||
|
|||
gbbdp = -here->HSM1_gbds; |
|||
gbbsp = here->HSM1_gbds + here->HSM1_gbgs + here->HSM1_gbbs; |
|||
|
|||
gbdpg = here->HSM1_gbgs; |
|||
gbdpb = here->HSM1_gbbs; |
|||
gbdpdp = here->HSM1_gbds; |
|||
gbdpsp = -(gbdpg + gbdpb + gbdpdp); |
|||
|
|||
gbspdp = 0.0; |
|||
gbspg = 0.0; |
|||
gbspb = 0.0; |
|||
gbspsp = 0.0; |
|||
|
|||
cggb = here->HSM1_cggb; |
|||
cgsb = here->HSM1_cgsb; |
|||
cgdb = here->HSM1_cgdb; |
|||
|
|||
cbgb = here->HSM1_cbgb; |
|||
cbsb = here->HSM1_cbsb; |
|||
cbdb = here->HSM1_cbdb; |
|||
|
|||
cdgb = here->HSM1_cdgb; |
|||
cdsb = here->HSM1_cdsb; |
|||
cddb = here->HSM1_cddb; |
|||
} |
|||
else { |
|||
gm = -here->HSM1_gm; |
|||
gmbs = -here->HSM1_gmbs; |
|||
FwdSum = 0.0; |
|||
RevSum = -(gm + gmbs); |
|||
|
|||
gbbsp = -here->HSM1_gbds; |
|||
gbbdp = here->HSM1_gbds + here->HSM1_gbgs + here->HSM1_gbbs; |
|||
|
|||
gbdpg = 0.0; |
|||
gbdpsp = 0.0; |
|||
gbdpb = 0.0; |
|||
gbdpdp = 0.0; |
|||
|
|||
gbspg = here->HSM1_gbgs; |
|||
gbspsp = here->HSM1_gbds; |
|||
gbspb = here->HSM1_gbbs; |
|||
gbspdp = -(gbspg + gbspsp + gbspb); |
|||
|
|||
cggb = here->HSM1_cggb; |
|||
cgsb = here->HSM1_cgdb; |
|||
cgdb = here->HSM1_cgsb; |
|||
|
|||
cbgb = here->HSM1_cbgb; |
|||
cbsb = here->HSM1_cbdb; |
|||
cbdb = here->HSM1_cbsb; |
|||
|
|||
cdgb = -(here->HSM1_cdgb + cggb + cbgb); |
|||
cdsb = -(here->HSM1_cddb + cgsb + cbsb); |
|||
cddb = -(here->HSM1_cdsb + cgdb + cbdb); |
|||
} |
|||
|
|||
gdpr = here->HSM1drainConductance; |
|||
gspr = here->HSM1sourceConductance; |
|||
gds = here->HSM1_gds; |
|||
gbd = here->HSM1_gbd; |
|||
gbs = here->HSM1_gbs; |
|||
capbd = here->HSM1_capbd; |
|||
capbs = here->HSM1_capbs; |
|||
|
|||
cgso = here->HSM1_cgso; |
|||
cgdo = here->HSM1_cgdo; |
|||
cgbo = here->HSM1_cgbo; |
|||
|
|||
xcdgb = (cdgb - cgdo) * omega; |
|||
xcddb = (cddb + capbd + cgdo) * omega; |
|||
xcdsb = cdsb * omega; |
|||
xcsgb = -(cggb + cbgb + cdgb + cgso) * omega; |
|||
xcsdb = -(cgdb + cbdb + cddb) * omega; |
|||
xcssb = (capbs + cgso - (cgsb + cbsb + cdsb)) * omega; |
|||
xcggb = (cggb + cgdo + cgso + cgbo) * omega; |
|||
xcgdb = (cgdb - cgdo) * omega; |
|||
xcgsb = (cgsb - cgso) * omega; |
|||
xcbgb = (cbgb - cgbo) * omega; |
|||
xcbdb = (cbdb - capbd) * omega; |
|||
xcbsb = (cbsb - capbs) * omega; |
|||
|
|||
*(here->HSM1GgPtr +1) += m * xcggb; |
|||
*(here->HSM1BbPtr +1) -= m * (xcbgb + xcbdb + xcbsb); |
|||
*(here->HSM1DPdpPtr +1) += m * xcddb; |
|||
*(here->HSM1SPspPtr +1) += m * xcssb; |
|||
*(here->HSM1GbPtr +1) -= m * (xcggb + xcgdb + xcgsb); |
|||
*(here->HSM1GdpPtr +1) += m * xcgdb; |
|||
*(here->HSM1GspPtr +1) += m * xcgsb; |
|||
*(here->HSM1BgPtr +1) += m * xcbgb; |
|||
*(here->HSM1BdpPtr +1) += m * xcbdb; |
|||
*(here->HSM1BspPtr +1) += m * xcbsb; |
|||
*(here->HSM1DPgPtr +1) += m * xcdgb; |
|||
*(here->HSM1DPbPtr +1) -= m * (xcdgb + xcddb + xcdsb); |
|||
*(here->HSM1DPspPtr +1) += m * xcdsb; |
|||
*(here->HSM1SPgPtr +1) += m * xcsgb; |
|||
*(here->HSM1SPbPtr +1) -= m * (xcsgb + xcsdb + xcssb); |
|||
*(here->HSM1SPdpPtr +1) += m * xcsdb; |
|||
|
|||
*(here->HSM1DdPtr) += m * gdpr; |
|||
*(here->HSM1SsPtr) += m * gspr; |
|||
*(here->HSM1BbPtr) += m * (gbd + gbs - here->HSM1_gbbs); |
|||
*(here->HSM1DPdpPtr) += m * (gdpr + gds + gbd + RevSum + gbdpdp); |
|||
*(here->HSM1SPspPtr) += m * (gspr + gds + gbs + FwdSum + gbspsp); |
|||
|
|||
*(here->HSM1DdpPtr) -= m * gdpr; |
|||
*(here->HSM1SspPtr) -= m * gspr; |
|||
|
|||
*(here->HSM1BgPtr) -= m * here->HSM1_gbgs; |
|||
*(here->HSM1BdpPtr) -= m * (gbd - gbbdp); |
|||
*(here->HSM1BspPtr) -= m * (gbs - gbbsp); |
|||
|
|||
*(here->HSM1DPdPtr) -= m * gdpr; |
|||
*(here->HSM1DPgPtr) += m * (gm + gbdpg); |
|||
*(here->HSM1DPbPtr) -= m * (gbd - gmbs - gbdpb); |
|||
*(here->HSM1DPspPtr) -= m * (gds + FwdSum - gbdpsp); |
|||
|
|||
*(here->HSM1SPgPtr) -= m * (gm - gbspg); |
|||
*(here->HSM1SPsPtr) -= m * gspr; |
|||
*(here->HSM1SPbPtr) -= m * (gbs + gmbs - gbspb); |
|||
*(here->HSM1SPdpPtr) -= m * (gds + RevSum - gbspdp); |
|||
|
|||
/* |
|||
... just for the case ... |
|||
*(here->HSM1GgPtr) -= m * xgtg; |
|||
*(here->HSM1GbPtr) -= m * xgtb; |
|||
*(here->HSM1GdpPtr) -= m * xgtd; |
|||
*(here->HSM1GspPtr) -= m * xgts; |
|||
*/ |
|||
|
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
@ -0,0 +1,231 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1ask.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "ifsim.h" |
|||
#include "cktdefs.h" |
|||
#include "devdefs.h" |
|||
#include "hsm1def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1ask(CKTcircuit *ckt, GENinstance *inst, int which, IFvalue *value, |
|||
IFvalue *select) |
|||
{ |
|||
HSM1instance *here = (HSM1instance*)inst; |
|||
|
|||
switch (which) { |
|||
case HSM1_L: |
|||
value->rValue = here->HSM1_l; |
|||
return(OK); |
|||
case HSM1_W: |
|||
value->rValue = here->HSM1_w; |
|||
return(OK); |
|||
case HSM1_M: |
|||
value->rValue = here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_AS: |
|||
value->rValue = here->HSM1_as; |
|||
return(OK); |
|||
case HSM1_AD: |
|||
value->rValue = here->HSM1_ad; |
|||
return(OK); |
|||
case HSM1_PS: |
|||
value->rValue = here->HSM1_ps; |
|||
return(OK); |
|||
case HSM1_PD: |
|||
value->rValue = here->HSM1_pd; |
|||
return(OK); |
|||
case HSM1_NRS: |
|||
value->rValue = here->HSM1_nrs; |
|||
return(OK); |
|||
case HSM1_NRD: |
|||
value->rValue = here->HSM1_nrd; |
|||
return(OK); |
|||
case HSM1_TEMP: |
|||
value->rValue = here->HSM1_temp; |
|||
return(OK); |
|||
case HSM1_DTEMP: |
|||
value->rValue = here->HSM1_dtemp; |
|||
return(OK); |
|||
case HSM1_OFF: |
|||
value->iValue = here->HSM1_off; |
|||
return(OK); |
|||
case HSM1_IC_VBS: |
|||
value->rValue = here->HSM1_icVBS; |
|||
return(OK); |
|||
case HSM1_IC_VDS: |
|||
value->rValue = here->HSM1_icVDS; |
|||
return(OK); |
|||
case HSM1_IC_VGS: |
|||
value->rValue = here->HSM1_icVGS; |
|||
return(OK); |
|||
case HSM1_DNODE: |
|||
value->iValue = here->HSM1dNode; |
|||
return(OK); |
|||
case HSM1_GNODE: |
|||
value->iValue = here->HSM1gNode; |
|||
return(OK); |
|||
case HSM1_SNODE: |
|||
value->iValue = here->HSM1sNode; |
|||
return(OK); |
|||
case HSM1_BNODE: |
|||
value->iValue = here->HSM1bNode; |
|||
return(OK); |
|||
case HSM1_DNODEPRIME: |
|||
value->iValue = here->HSM1dNodePrime; |
|||
return(OK); |
|||
case HSM1_SNODEPRIME: |
|||
value->iValue = here->HSM1sNodePrime; |
|||
return(OK); |
|||
case HSM1_SOURCECONDUCT: |
|||
value->rValue = here->HSM1sourceConductance; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_DRAINCONDUCT: |
|||
value->rValue = here->HSM1drainConductance; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_VBD: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1vbd); |
|||
return(OK); |
|||
case HSM1_VBS: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1vbs); |
|||
return(OK); |
|||
case HSM1_VGS: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1vgs); |
|||
return(OK); |
|||
case HSM1_VDS: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1vds); |
|||
return(OK); |
|||
case HSM1_CD: |
|||
value->rValue = here->HSM1_ids; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CBS: |
|||
value->rValue = here->HSM1_ibs; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CBD: |
|||
value->rValue = here->HSM1_ibs; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_GM: |
|||
value->rValue = here->HSM1_gm; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_GDS: |
|||
value->rValue = here->HSM1_gds; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_GMBS: |
|||
value->rValue = here->HSM1_gmbs; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_GBD: |
|||
value->rValue = here->HSM1_gbd; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_GBS: |
|||
value->rValue = here->HSM1_gbs; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_QB: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1qb); |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CQB: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1cqb); |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_QG: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1qg); |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CQG: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1cqg); |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_QD: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1qd); |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CQD: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1cqd); |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CGG: |
|||
value->rValue = here->HSM1_cggb; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CGD: |
|||
value->rValue = here->HSM1_cgdb; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CGS: |
|||
value->rValue = here->HSM1_cgsb; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CDG: |
|||
value->rValue = here->HSM1_cdgb; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CDD: |
|||
value->rValue = here->HSM1_cddb; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CDS: |
|||
value->rValue = here->HSM1_cdsb; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CBG: |
|||
value->rValue = here->HSM1_cbgb; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CBDB: |
|||
value->rValue = here->HSM1_cbdb; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CBSB: |
|||
value->rValue = here->HSM1_cbsb; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CAPBD: |
|||
value->rValue = here->HSM1_capbd; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_CAPBS: |
|||
value->rValue = here->HSM1_capbs; |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_VON: |
|||
value->rValue = here->HSM1_von; |
|||
return(OK); |
|||
case HSM1_VDSAT: |
|||
value->rValue = here->HSM1_vdsat; |
|||
return(OK); |
|||
case HSM1_QBS: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1qbs); |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
case HSM1_QBD: |
|||
value->rValue = *(ckt->CKTstate0 + here->HSM1qbd); |
|||
value->rValue *= here->HSM1_m; |
|||
return(OK); |
|||
default: |
|||
return(E_BADPARM); |
|||
} |
|||
/* NOTREACHED */ |
|||
} |
|||
@ -0,0 +1,106 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1cvtest.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "cktdefs.h" |
|||
#include "hsm1def.h" |
|||
#include "trandefs.h" |
|||
#include "const.h" |
|||
#include "devdefs.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1convTest(GENmodel *inModel, CKTcircuit *ckt) |
|||
{ |
|||
HSM1model *model = (HSM1model*)inModel; |
|||
HSM1instance *here; |
|||
double delvbd, delvbs, delvds, delvgd, delvgs, vbd, vbs, vds; |
|||
double cbd, cbhat, cbs, cd, cdhat, tol, vgd, vgdo, vgs; |
|||
|
|||
/* loop through all the HSM1 device models */ |
|||
for ( ; model != NULL; model = model->HSM1nextModel ) { |
|||
/* loop through all the instances of the model */ |
|||
for ( here = model->HSM1instances; here != NULL ; |
|||
here = here->HSM1nextInstance ) { |
|||
|
|||
|
|||
if (here->HSM1owner != ARCHme) |
|||
continue; |
|||
|
|||
vbs = model->HSM1_type * |
|||
(*(ckt->CKTrhsOld+here->HSM1bNode) - |
|||
*(ckt->CKTrhsOld+here->HSM1sNodePrime)); |
|||
vgs = model->HSM1_type * |
|||
(*(ckt->CKTrhsOld+here->HSM1gNode) - |
|||
*(ckt->CKTrhsOld+here->HSM1sNodePrime)); |
|||
vds = model->HSM1_type * |
|||
(*(ckt->CKTrhsOld+here->HSM1dNodePrime) - |
|||
*(ckt->CKTrhsOld+here->HSM1sNodePrime)); |
|||
vbd = vbs - vds; |
|||
vgd = vgs - vds; |
|||
vgdo = *(ckt->CKTstate0 + here->HSM1vgs) - |
|||
*(ckt->CKTstate0 + here->HSM1vds); |
|||
delvbs = vbs - *(ckt->CKTstate0 + here->HSM1vbs); |
|||
delvbd = vbd - *(ckt->CKTstate0 + here->HSM1vbd); |
|||
delvgs = vgs - *(ckt->CKTstate0 + here->HSM1vgs); |
|||
delvds = vds - *(ckt->CKTstate0 + here->HSM1vds); |
|||
delvgd = vgd - vgdo; |
|||
|
|||
cd = here->HSM1_ids - here->HSM1_ibd; |
|||
if ( here->HSM1_mode >= 0 ) { |
|||
cd += here->HSM1_isub; |
|||
cdhat = cd - here->HSM1_gbd * delvbd |
|||
+ (here->HSM1_gmbs + here->HSM1_gbbs) * delvbs |
|||
+ (here->HSM1_gm + here->HSM1_gbgs) * delvgs |
|||
+ (here->HSM1_gds + here->HSM1_gbds) * delvds; |
|||
} |
|||
else { |
|||
cdhat = cd + (here->HSM1_gmbs - here->HSM1_gbd) * delvbd |
|||
+ here->HSM1_gm * delvgd - here->HSM1_gds * delvds; |
|||
} |
|||
|
|||
/* |
|||
* check convergence |
|||
*/ |
|||
if ( here->HSM1_off == 0 || !(ckt->CKTmode & MODEINITFIX) ) { |
|||
tol = ckt->CKTreltol * MAX(fabs(cdhat), fabs(cd)) + ckt->CKTabstol; |
|||
if ( fabs(cdhat - cd) >= tol ) { |
|||
ckt->CKTnoncon++; |
|||
return(OK); |
|||
} |
|||
cbs = here->HSM1_ibs; |
|||
cbd = here->HSM1_ibd; |
|||
if ( here->HSM1_mode >= 0 ) { |
|||
cbhat = cbs + cbd - here->HSM1_isub + here->HSM1_gbd * delvbd |
|||
+ (here->HSM1_gbs - here->HSM1_gbbs) * delvbs |
|||
- here->HSM1_gbgs * delvgs - here->HSM1_gbds * delvds; |
|||
} |
|||
else { |
|||
cbhat = cbs + cbd - here->HSM1_isub |
|||
+ here->HSM1_gbs * delvbs |
|||
+ (here->HSM1_gbd - here->HSM1_gbbs) * delvbd |
|||
- here->HSM1_gbgs * delvgd + here->HSM1_gbds * delvds; |
|||
} |
|||
tol = ckt->CKTreltol * |
|||
MAX(fabs(cbhat), fabs(cbs + cbd - here->HSM1_isub)) + ckt->CKTabstol; |
|||
if ( fabs(cbhat - (cbs + cbd - here->HSM1_isub)) > tol ) { |
|||
ckt->CKTnoncon++; |
|||
return(OK); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
@ -0,0 +1,694 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1def.h of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#ifndef HSM1 |
|||
#define HSM1 |
|||
|
|||
#include "ifsim.h" |
|||
#include "gendefs.h" |
|||
#include "cktdefs.h" |
|||
#include "complex.h" |
|||
#include "noisedef.h" |
|||
|
|||
/* declarations for HiSIM1 MOSFETs */ |
|||
|
|||
/* information needed for each instance */ |
|||
typedef struct sHSM1instance { |
|||
struct sHSM1model *HSM1modPtr; /* pointer to model */ |
|||
struct sHSM1instance *HSM1nextInstance; /* pointer to next instance of |
|||
current model*/ |
|||
IFuid HSM1name; /* pointer to character string naming this instance */ |
|||
int HSM1owner; /* number of owner process */ |
|||
int HSM1states; /* index into state table for this device */ |
|||
|
|||
int HSM1dNode; /* number of the drain node of the mosfet */ |
|||
int HSM1gNode; /* number of the gate node of the mosfet */ |
|||
int HSM1sNode; /* number of the source node of the mosfet */ |
|||
int HSM1bNode; /* number of the bulk node of the mosfet */ |
|||
int HSM1dNodePrime; /* number od the inner drain node */ |
|||
int HSM1sNodePrime; /* number od the inner source node */ |
|||
|
|||
char HSM1_called[4]; /* string to check the first call */ |
|||
|
|||
/* previous values to evaluate initial guess */ |
|||
double HSM1_vbsc_prv; |
|||
double HSM1_vdsc_prv; |
|||
double HSM1_vgsc_prv; |
|||
double HSM1_ps0_prv; |
|||
double HSM1_ps0_dvbs_prv; |
|||
double HSM1_ps0_dvds_prv; |
|||
double HSM1_ps0_dvgs_prv; |
|||
double HSM1_pds_prv; |
|||
double HSM1_pds_dvbs_prv; |
|||
double HSM1_pds_dvds_prv; |
|||
double HSM1_pds_dvgs_prv; |
|||
double HSM1_ids_prv; |
|||
double HSM1_ids_dvbs_prv; |
|||
double HSM1_ids_dvds_prv; |
|||
double HSM1_ids_dvgs_prv; |
|||
|
|||
double HSM1_nfc; /* for noise calc. */ |
|||
|
|||
/* instance */ |
|||
double HSM1_l; /* the length of the channel region */ |
|||
double HSM1_w; /* the width of the channel region */ |
|||
double HSM1_m; /* Parallel multiplier */ |
|||
double HSM1_ad; /* the area of the drain diffusion */ |
|||
double HSM1_as; /* the area of the source diffusion */ |
|||
double HSM1_pd; /* perimeter of drain junction [m] */ |
|||
double HSM1_ps; /* perimeter of source junction [m] */ |
|||
double HSM1_nrd; /* equivalent num of squares of drain [-] (unused) */ |
|||
double HSM1_nrs; /* equivalent num of squares of source [-] (unused) */ |
|||
double HSM1_temp; /* lattice temperature [K] */ |
|||
double HSM1_dtemp; |
|||
|
|||
/* added by K.M. */ |
|||
double HSM1_weff; /* the effectiv width of the channel region */ |
|||
double HSM1_leff; /* the effectiv length of the channel region */ |
|||
|
|||
/* output */ |
|||
int HSM1_capop; |
|||
double HSM1_gd; |
|||
double HSM1_gs; |
|||
double HSM1_cgso; |
|||
double HSM1_cgdo; |
|||
double HSM1_cgbo; |
|||
double HSM1_von; /* vth */ |
|||
double HSM1_vdsat; |
|||
double HSM1_ids; /* cdrain, HSM1_cd */ |
|||
double HSM1_gds; |
|||
double HSM1_gm; |
|||
double HSM1_gmbs; |
|||
double HSM1_ibs; /* HSM1_cbs */ |
|||
double HSM1_ibd; /* HSM1_cbd */ |
|||
double HSM1_gbs; |
|||
double HSM1_gbd; |
|||
double HSM1_capbs; |
|||
double HSM1_capbd; |
|||
/* |
|||
double HSM1_qbs; |
|||
double HSM1_qbd; |
|||
*/ |
|||
double HSM1_capgs; |
|||
double HSM1_capgd; |
|||
double HSM1_capgb; |
|||
double HSM1_isub; /* HSM1_csub */ |
|||
double HSM1_gbgs; |
|||
double HSM1_gbds; |
|||
double HSM1_gbbs; |
|||
double HSM1_qg; |
|||
double HSM1_qd; |
|||
/* double HSM1_qs; */ |
|||
double HSM1_qb; /* bulk charge qb = -(qg + qd + qs) */ |
|||
double HSM1_cggb; |
|||
double HSM1_cgdb; |
|||
double HSM1_cgsb; |
|||
double HSM1_cbgb; |
|||
double HSM1_cbdb; |
|||
double HSM1_cbsb; |
|||
double HSM1_cdgb; |
|||
double HSM1_cddb; |
|||
double HSM1_cdsb; |
|||
/* no use in SPICE3f5 |
|||
double HSM1_nois_irs; |
|||
double HSM1_nois_ird; |
|||
double HSM1_nois_idsth; |
|||
double HSM1_nois_idsfl; |
|||
double HSM1_freq; |
|||
*/ |
|||
|
|||
/* added by K.M. */ |
|||
double HSM1_mu; /* mobility */ |
|||
|
|||
/* no use in SPICE3f5 |
|||
double HSM1drainSquares; the length of the drain in squares |
|||
double HSM1sourceSquares; the length of the source in squares */ |
|||
double HSM1sourceConductance; /* cond. of source (or 0): set in setup */ |
|||
double HSM1drainConductance; /* cond. of drain (or 0): set in setup */ |
|||
|
|||
double HSM1_icVBS; /* initial condition B-S voltage */ |
|||
double HSM1_icVDS; /* initial condition D-S voltage */ |
|||
double HSM1_icVGS; /* initial condition G-S voltage */ |
|||
int HSM1_off; /* non-zero to indicate device is off for dc analysis */ |
|||
int HSM1_mode; /* device mode : 1 = normal, -1 = inverse */ |
|||
|
|||
unsigned HSM1_l_Given :1; |
|||
unsigned HSM1_w_Given :1; |
|||
unsigned HSM1_m_Given :1; |
|||
unsigned HSM1_ad_Given :1; |
|||
unsigned HSM1_as_Given :1; |
|||
/* unsigned HSM1drainSquaresGiven :1; |
|||
unsigned HSM1sourceSquaresGiven :1;*/ |
|||
unsigned HSM1_pd_Given :1; |
|||
unsigned HSM1_ps_Given :1; |
|||
unsigned HSM1_nrd_Given :1; |
|||
unsigned HSM1_nrs_Given :1; |
|||
unsigned HSM1_temp_Given :1; |
|||
unsigned HSM1_dtemp_Given :1; |
|||
unsigned HSM1dNodePrimeSet :1; |
|||
unsigned HSM1sNodePrimeSet :1; |
|||
unsigned HSM1_icVBS_Given :1; |
|||
unsigned HSM1_icVDS_Given :1; |
|||
unsigned HSM1_icVGS_Given :1; |
|||
|
|||
/* pointer to sparse matrix */ |
|||
double *HSM1DdPtr; /* pointer to sparse matrix element at |
|||
(Drain node,drain node) */ |
|||
double *HSM1GgPtr; /* pointer to sparse matrix element at |
|||
(gate node,gate node) */ |
|||
double *HSM1SsPtr; /* pointer to sparse matrix element at |
|||
(source node,source node) */ |
|||
double *HSM1BbPtr; /* pointer to sparse matrix element at |
|||
(bulk node,bulk node) */ |
|||
double *HSM1DPdpPtr; /* pointer to sparse matrix element at |
|||
(drain prime node,drain prime node) */ |
|||
double *HSM1SPspPtr; /* pointer to sparse matrix element at |
|||
(source prime node,source prime node) */ |
|||
double *HSM1DdpPtr; /* pointer to sparse matrix element at |
|||
(drain node,drain prime node) */ |
|||
double *HSM1GbPtr; /* pointer to sparse matrix element at |
|||
(gate node,bulk node) */ |
|||
double *HSM1GdpPtr; /* pointer to sparse matrix element at |
|||
(gate node,drain prime node) */ |
|||
double *HSM1GspPtr; /* pointer to sparse matrix element at |
|||
(gate node,source prime node) */ |
|||
double *HSM1SspPtr; /* pointer to sparse matrix element at |
|||
(source node,source prime node) */ |
|||
double *HSM1BdpPtr; /* pointer to sparse matrix element at |
|||
(bulk node,drain prime node) */ |
|||
double *HSM1BspPtr; /* pointer to sparse matrix element at |
|||
(bulk node,source prime node) */ |
|||
double *HSM1DPspPtr; /* pointer to sparse matrix element at |
|||
(drain prime node,source prime node) */ |
|||
double *HSM1DPdPtr; /* pointer to sparse matrix element at |
|||
(drain prime node,drain node) */ |
|||
double *HSM1BgPtr; /* pointer to sparse matrix element at |
|||
(bulk node,gate node) */ |
|||
double *HSM1DPgPtr; /* pointer to sparse matrix element at |
|||
(drain prime node,gate node) */ |
|||
double *HSM1SPgPtr; /* pointer to sparse matrix element at |
|||
(source prime node,gate node) */ |
|||
double *HSM1SPsPtr; /* pointer to sparse matrix element at |
|||
(source prime node,source node) */ |
|||
double *HSM1DPbPtr; /* pointer to sparse matrix element at |
|||
(drain prime node,bulk node) */ |
|||
double *HSM1SPbPtr; /* pointer to sparse matrix element at |
|||
(source prime node,bulk node) */ |
|||
double *HSM1SPdpPtr; /* pointer to sparse matrix element at |
|||
(source prime node,drain prime node) */ |
|||
|
|||
/* common state values in hisim1 module */ |
|||
#define HSM1vbd HSM1states+ 0 |
|||
#define HSM1vbs HSM1states+ 1 |
|||
#define HSM1vgs HSM1states+ 2 |
|||
#define HSM1vds HSM1states+ 3 |
|||
|
|||
#define HSM1qb HSM1states+ 4 |
|||
#define HSM1cqb HSM1states+ 5 |
|||
#define HSM1qg HSM1states+ 6 |
|||
#define HSM1cqg HSM1states+ 7 |
|||
#define HSM1qd HSM1states+ 8 |
|||
#define HSM1cqd HSM1states+ 9 |
|||
|
|||
#define HSM1qbs HSM1states+ 10 |
|||
#define HSM1qbd HSM1states+ 11 |
|||
|
|||
#define HSM1numStates 12 |
|||
|
|||
/* indices to the array of HiSIM1 NOISE SOURCES (the same as BSIM3) */ |
|||
#define HSM1RDNOIZ 0 |
|||
#define HSM1RSNOIZ 1 |
|||
#define HSM1IDNOIZ 2 |
|||
#define HSM1FLNOIZ 3 |
|||
#define HSM1TOTNOIZ 4 |
|||
|
|||
#define HSM1NSRCS 5 /* the number of HiSIM1 MOSFET noise sources */ |
|||
|
|||
#ifndef NONOISE |
|||
double HSM1nVar[NSTATVARS][HSM1NSRCS]; |
|||
#else /* NONOISE */ |
|||
double **HSM1nVar; |
|||
#endif /* NONOISE */ |
|||
|
|||
} HSM1instance ; |
|||
|
|||
|
|||
/* per model data */ |
|||
|
|||
typedef struct sHiSIM1model { /* model structure for a resistor */ |
|||
int HSM1modType; /* type index of this device type */ |
|||
struct sHiSIM1model *HSM1nextModel; /* pointer to next possible model |
|||
in linked list */ |
|||
HSM1instance * HSM1instances; /* pointer to list of instances |
|||
that have this model */ |
|||
IFuid HSM1modName; /* pointer to the name of this model */ |
|||
int HSM1_type; /* device type: 1 = nmos, -1 = pmos */ |
|||
int HSM1_level; /* level */ |
|||
int HSM1_info; /* information */ |
|||
int HSM1_noise; /* noise model selecter see hsm1noi.c */ |
|||
int HSM1_version; /* model version 100/110 */ |
|||
int HSM1_show; /* show physical value 1, 2, ... , 11 */ |
|||
|
|||
/* flags for initial guess */ |
|||
int HSM1_corsrd ; |
|||
int HSM1_coiprv ; |
|||
int HSM1_copprv ; |
|||
int HSM1_cocgso ; |
|||
int HSM1_cocgdo ; |
|||
int HSM1_cocgbo ; |
|||
int HSM1_coadov ; |
|||
int HSM1_coxx08 ; |
|||
int HSM1_coxx09 ; |
|||
int HSM1_coisub ; |
|||
int HSM1_coiigs ; |
|||
int HSM1_cogidl ; |
|||
int HSM1_coovlp ; |
|||
int HSM1_conois ; |
|||
int HSM1_coisti ; /* HiSIM1.1 */ |
|||
/* HiSIM original */ |
|||
double HSM1_vmax ; |
|||
double HSM1_bgtmp1 ; |
|||
double HSM1_bgtmp2 ; |
|||
double HSM1_tox ; |
|||
double HSM1_dl ; |
|||
double HSM1_dw ; |
|||
double HSM1_xj ; /* HiSIM1.0 */ |
|||
double HSM1_xqy ; /* HiSIM1.1 */ |
|||
double HSM1_rs; /* source contact resistance */ |
|||
double HSM1_rd; /* drain contact resistance */ |
|||
double HSM1_vfbc ; |
|||
double HSM1_nsubc ; |
|||
double HSM1_parl1 ; |
|||
double HSM1_parl2 ; |
|||
double HSM1_lp ; |
|||
double HSM1_nsubp ; |
|||
double HSM1_scp1 ; |
|||
double HSM1_scp2 ; |
|||
double HSM1_scp3 ; |
|||
double HSM1_sc1 ; |
|||
double HSM1_sc2 ; |
|||
double HSM1_sc3 ; |
|||
double HSM1_pgd1 ; |
|||
double HSM1_pgd2 ; |
|||
double HSM1_pgd3 ; |
|||
double HSM1_ndep ; |
|||
double HSM1_ninv ; |
|||
double HSM1_ninvd ; |
|||
double HSM1_muecb0 ; |
|||
double HSM1_muecb1 ; |
|||
double HSM1_mueph1 ; |
|||
double HSM1_mueph0 ; |
|||
double HSM1_mueph2 ; |
|||
double HSM1_w0 ; |
|||
double HSM1_muesr1 ; |
|||
double HSM1_muesr0 ; |
|||
double HSM1_bb ; |
|||
double HSM1_vds0 ; |
|||
double HSM1_bc0 ; |
|||
double HSM1_bc1 ; |
|||
double HSM1_sub1 ; |
|||
double HSM1_sub2 ; |
|||
double HSM1_sub3 ; |
|||
double HSM1_wvthsc ; /* HiSIM1.1 */ |
|||
double HSM1_nsti ; /* HiSIM1.1 */ |
|||
double HSM1_wsti ; /* HiSIM1.1 */ |
|||
double HSM1_cgso ; |
|||
double HSM1_cgdo ; |
|||
double HSM1_cgbo ; |
|||
double HSM1_tpoly ; |
|||
double HSM1_js0 ; |
|||
double HSM1_js0sw ; |
|||
double HSM1_nj ; |
|||
double HSM1_njsw ; |
|||
double HSM1_xti ; |
|||
double HSM1_cj ; |
|||
double HSM1_cjsw ; |
|||
double HSM1_cjswg ; |
|||
double HSM1_mj ; |
|||
double HSM1_mjsw ; |
|||
double HSM1_mjswg ; |
|||
double HSM1_pb ; |
|||
double HSM1_pbsw ; |
|||
double HSM1_pbswg ; |
|||
double HSM1_xpolyd ; |
|||
double HSM1_clm1 ; |
|||
double HSM1_clm2 ; |
|||
double HSM1_clm3 ; |
|||
double HSM1_muetmp ; |
|||
double HSM1_rpock1 ; |
|||
double HSM1_rpock2 ; |
|||
double HSM1_rpocp1 ; /* HiSIM 1.1 */ |
|||
double HSM1_rpocp2 ; /* HiSIM 1.1 */ |
|||
double HSM1_vover ; |
|||
double HSM1_voverp ; |
|||
double HSM1_wfc ; |
|||
double HSM1_qme1 ; |
|||
double HSM1_qme2 ; |
|||
double HSM1_qme3 ; |
|||
double HSM1_gidl1 ; |
|||
double HSM1_gidl2 ; |
|||
double HSM1_gidl3 ; |
|||
double HSM1_gleak1 ; |
|||
double HSM1_gleak2 ; |
|||
double HSM1_gleak3 ; |
|||
double HSM1_vzadd0 ; |
|||
double HSM1_pzadd0 ; |
|||
double HSM1_nftrp ; |
|||
double HSM1_nfalp ; |
|||
double HSM1_cit ; |
|||
|
|||
/* for flicker noise of SPICE3 added by K.M. */ |
|||
double HSM1_ef; |
|||
double HSM1_af; |
|||
double HSM1_kf; |
|||
|
|||
/* flag for model */ |
|||
unsigned HSM1_type_Given :1; |
|||
unsigned HSM1_level_Given :1; |
|||
unsigned HSM1_info_Given :1; |
|||
unsigned HSM1_noise_Given :1; |
|||
unsigned HSM1_version_Given :1; |
|||
unsigned HSM1_show_Given :1; |
|||
unsigned HSM1_corsrd_Given :1; |
|||
unsigned HSM1_coiprv_Given :1; |
|||
unsigned HSM1_copprv_Given :1; |
|||
unsigned HSM1_cocgso_Given :1; |
|||
unsigned HSM1_cocgdo_Given :1; |
|||
unsigned HSM1_cocgbo_Given :1; |
|||
unsigned HSM1_coadov_Given :1; |
|||
unsigned HSM1_coxx08_Given :1; |
|||
unsigned HSM1_coxx09_Given :1; |
|||
unsigned HSM1_coisub_Given :1; |
|||
unsigned HSM1_coiigs_Given :1; |
|||
unsigned HSM1_cogidl_Given :1; |
|||
unsigned HSM1_coovlp_Given :1; |
|||
unsigned HSM1_conois_Given :1; |
|||
unsigned HSM1_coisti_Given :1; /* HiSIM1.1 */ |
|||
unsigned HSM1_vmax_Given :1; |
|||
unsigned HSM1_bgtmp1_Given :1; |
|||
unsigned HSM1_bgtmp2_Given :1; |
|||
unsigned HSM1_tox_Given :1; |
|||
unsigned HSM1_dl_Given :1; |
|||
unsigned HSM1_dw_Given :1; |
|||
unsigned HSM1_xj_Given :1; /* HiSIM1.0 */ |
|||
unsigned HSM1_xqy_Given :1; /* HiSIM1.1 */ |
|||
unsigned HSM1_rs_Given :1; |
|||
unsigned HSM1_rd_Given :1; |
|||
unsigned HSM1_vfbc_Given :1; |
|||
unsigned HSM1_nsubc_Given :1; |
|||
unsigned HSM1_parl1_Given :1; |
|||
unsigned HSM1_parl2_Given :1; |
|||
unsigned HSM1_lp_Given :1; |
|||
unsigned HSM1_nsubp_Given :1; |
|||
unsigned HSM1_scp1_Given :1; |
|||
unsigned HSM1_scp2_Given :1; |
|||
unsigned HSM1_scp3_Given :1; |
|||
unsigned HSM1_sc1_Given :1; |
|||
unsigned HSM1_sc2_Given :1; |
|||
unsigned HSM1_sc3_Given :1; |
|||
unsigned HSM1_pgd1_Given :1; |
|||
unsigned HSM1_pgd2_Given :1; |
|||
unsigned HSM1_pgd3_Given :1; |
|||
unsigned HSM1_ndep_Given :1; |
|||
unsigned HSM1_ninv_Given :1; |
|||
unsigned HSM1_ninvd_Given :1; |
|||
unsigned HSM1_muecb0_Given :1; |
|||
unsigned HSM1_muecb1_Given :1; |
|||
unsigned HSM1_mueph1_Given :1; |
|||
unsigned HSM1_mueph0_Given :1; |
|||
unsigned HSM1_mueph2_Given :1; |
|||
unsigned HSM1_w0_Given :1; |
|||
unsigned HSM1_muesr1_Given :1; |
|||
unsigned HSM1_muesr0_Given :1; |
|||
unsigned HSM1_bb_Given :1; |
|||
unsigned HSM1_vds0_Given :1; |
|||
unsigned HSM1_bc0_Given :1; |
|||
unsigned HSM1_bc1_Given :1; |
|||
unsigned HSM1_sub1_Given :1; |
|||
unsigned HSM1_sub2_Given :1; |
|||
unsigned HSM1_sub3_Given :1; |
|||
unsigned HSM1_wvthsc_Given :1; /* HiSIM1.1 */ |
|||
unsigned HSM1_nsti_Given :1; /* HiSIM1.1 */ |
|||
unsigned HSM1_wsti_Given :1; /* HiSIM1.1 */ |
|||
unsigned HSM1_cgso_Given :1; |
|||
unsigned HSM1_cgdo_Given :1; |
|||
unsigned HSM1_cgbo_Given :1; |
|||
unsigned HSM1_tpoly_Given :1; |
|||
unsigned HSM1_js0_Given :1; |
|||
unsigned HSM1_js0sw_Given :1; |
|||
unsigned HSM1_nj_Given :1; |
|||
unsigned HSM1_njsw_Given :1; |
|||
unsigned HSM1_xti_Given :1; |
|||
unsigned HSM1_cj_Given :1; |
|||
unsigned HSM1_cjsw_Given :1; |
|||
unsigned HSM1_cjswg_Given :1; |
|||
unsigned HSM1_mj_Given :1; |
|||
unsigned HSM1_mjsw_Given :1; |
|||
unsigned HSM1_mjswg_Given :1; |
|||
unsigned HSM1_pb_Given :1; |
|||
unsigned HSM1_pbsw_Given :1; |
|||
unsigned HSM1_pbswg_Given :1; |
|||
unsigned HSM1_xpolyd_Given :1; |
|||
unsigned HSM1_clm1_Given :1; |
|||
unsigned HSM1_clm2_Given :1; |
|||
unsigned HSM1_clm3_Given :1; |
|||
unsigned HSM1_muetmp_Given :1; |
|||
unsigned HSM1_rpock1_Given :1; |
|||
unsigned HSM1_rpock2_Given :1; |
|||
unsigned HSM1_rpocp1_Given :1; /* HiSIM1.1 */ |
|||
unsigned HSM1_rpocp2_Given :1; /* HiSIM1.1 */ |
|||
unsigned HSM1_vover_Given :1; |
|||
unsigned HSM1_voverp_Given :1; |
|||
unsigned HSM1_wfc_Given :1; |
|||
unsigned HSM1_qme1_Given :1; |
|||
unsigned HSM1_qme2_Given :1; |
|||
unsigned HSM1_qme3_Given :1; |
|||
unsigned HSM1_gidl1_Given :1; |
|||
unsigned HSM1_gidl2_Given :1; |
|||
unsigned HSM1_gidl3_Given :1; |
|||
unsigned HSM1_gleak1_Given :1; |
|||
unsigned HSM1_gleak2_Given :1; |
|||
unsigned HSM1_gleak3_Given :1; |
|||
unsigned HSM1_vzadd0_Given :1; |
|||
unsigned HSM1_pzadd0_Given :1; |
|||
unsigned HSM1_nftrp_Given :1; |
|||
unsigned HSM1_nfalp_Given :1; |
|||
unsigned HSM1_cit_Given :1; |
|||
|
|||
unsigned HSM1_ef_Given :1; |
|||
unsigned HSM1_af_Given :1; |
|||
unsigned HSM1_kf_Given :1; |
|||
|
|||
} HSM1model; |
|||
|
|||
#ifndef NMOS |
|||
#define NMOS 1 |
|||
#define PMOS -1 |
|||
#endif /*NMOS*/ |
|||
|
|||
#define HSM1_BAD_PARAM -1 |
|||
|
|||
/* flags */ |
|||
#define HSM1_MOD_NMOS 1 |
|||
#define HSM1_MOD_PMOS 2 |
|||
#define HSM1_MOD_LEVEL 3 |
|||
#define HSM1_MOD_INFO 4 |
|||
#define HSM1_MOD_NOISE 5 |
|||
#define HSM1_MOD_VERSION 6 |
|||
#define HSM1_MOD_SHOW 7 |
|||
#define HSM1_MOD_CORSRD 11 |
|||
#define HSM1_MOD_COIPRV 12 |
|||
#define HSM1_MOD_COPPRV 13 |
|||
#define HSM1_MOD_COCGSO 14 |
|||
#define HSM1_MOD_COCGDO 15 |
|||
#define HSM1_MOD_COCGBO 16 |
|||
#define HSM1_MOD_COADOV 17 |
|||
#define HSM1_MOD_COXX08 18 |
|||
#define HSM1_MOD_COXX09 19 |
|||
#define HSM1_MOD_COISUB 21 |
|||
#define HSM1_MOD_COIIGS 22 |
|||
#define HSM1_MOD_COGIDL 23 |
|||
#define HSM1_MOD_COOVLP 24 |
|||
#define HSM1_MOD_CONOIS 25 |
|||
#define HSM1_MOD_COISTI 26 /* HiSIM1.1 */ |
|||
/* device parameters */ |
|||
#define HSM1_L 51 |
|||
#define HSM1_W 52 |
|||
#define HSM1_M 66 |
|||
#define HSM1_AD 53 |
|||
#define HSM1_AS 54 |
|||
#define HSM1_PD 55 |
|||
#define HSM1_PS 56 |
|||
#define HSM1_NRD 57 |
|||
#define HSM1_NRS 58 |
|||
#define HSM1_TEMP 59 |
|||
#define HSM1_DTEMP 60 |
|||
#define HSM1_OFF 61 |
|||
#define HSM1_IC_VBS 62 |
|||
#define HSM1_IC_VDS 63 |
|||
#define HSM1_IC_VGS 64 |
|||
#define HSM1_IC 65 |
|||
|
|||
/* model parameters */ |
|||
#define HSM1_MOD_VMAX 101 |
|||
#define HSM1_MOD_BGTMP1 103 |
|||
#define HSM1_MOD_BGTMP2 104 |
|||
#define HSM1_MOD_TOX 105 |
|||
#define HSM1_MOD_DL 106 |
|||
#define HSM1_MOD_DW 107 |
|||
#define HSM1_MOD_XJ 996 /* HiSIM1.0 */ |
|||
#define HSM1_MOD_XQY 997 /* HiSIM1.1 */ |
|||
#define HSM1_MOD_RS 108 |
|||
#define HSM1_MOD_RD 109 |
|||
#define HSM1_MOD_VFBC 110 |
|||
#define HSM1_MOD_NSUBC 113 |
|||
#define HSM1_MOD_PARL1 122 |
|||
#define HSM1_MOD_PARL2 123 |
|||
#define HSM1_MOD_SC1 124 |
|||
#define HSM1_MOD_SC2 125 |
|||
#define HSM1_MOD_SC3 126 |
|||
#define HSM1_MOD_NDEP 129 |
|||
#define HSM1_MOD_NINV 130 |
|||
#define HSM1_MOD_MUECB0 131 |
|||
#define HSM1_MOD_MUECB1 132 |
|||
#define HSM1_MOD_MUEPH1 133 |
|||
#define HSM1_MOD_MUEPH0 134 |
|||
#define HSM1_MOD_MUEPH2 999 |
|||
#define HSM1_MOD_W0 998 |
|||
#define HSM1_MOD_MUESR1 135 |
|||
#define HSM1_MOD_MUESR0 136 |
|||
#define HSM1_MOD_BB 137 |
|||
#define HSM1_MOD_VDS0 138 |
|||
#define HSM1_MOD_BC0 139 |
|||
#define HSM1_MOD_BC1 140 |
|||
#define HSM1_MOD_SUB1 141 |
|||
#define HSM1_MOD_SUB2 142 |
|||
#define HSM1_MOD_SUB3 143 |
|||
#define HSM1_MOD_CGSO 144 |
|||
#define HSM1_MOD_CGDO 145 |
|||
#define HSM1_MOD_CGBO 146 |
|||
#define HSM1_MOD_JS0 147 |
|||
#define HSM1_MOD_JS0SW 148 |
|||
#define HSM1_MOD_NJ 149 |
|||
#define HSM1_MOD_NJSW 150 |
|||
#define HSM1_MOD_XTI 151 |
|||
#define HSM1_MOD_CJ 152 |
|||
#define HSM1_MOD_CJSW 156 |
|||
#define HSM1_MOD_CJSWG 157 |
|||
#define HSM1_MOD_MJ 160 |
|||
#define HSM1_MOD_MJSW 161 |
|||
#define HSM1_MOD_MJSWG 163 |
|||
#define HSM1_MOD_PB 166 |
|||
#define HSM1_MOD_PBSW 168 |
|||
#define HSM1_MOD_PBSWG 169 |
|||
#define HSM1_MOD_XPOLYD 170 |
|||
#define HSM1_MOD_TPOLY 171 |
|||
#define HSM1_MOD_LP 172 |
|||
#define HSM1_MOD_NSUBP 173 |
|||
#define HSM1_MOD_SCP1 174 |
|||
#define HSM1_MOD_SCP2 175 |
|||
#define HSM1_MOD_SCP3 176 |
|||
#define HSM1_MOD_PGD1 177 |
|||
#define HSM1_MOD_PGD2 178 |
|||
#define HSM1_MOD_PGD3 179 |
|||
#define HSM1_MOD_CLM1 180 |
|||
#define HSM1_MOD_CLM2 181 |
|||
#define HSM1_MOD_CLM3 182 |
|||
#define HSM1_MOD_NINVD 183 |
|||
#define HSM1_MOD_MUETMP 190 |
|||
#define HSM1_MOD_RPOCK1 191 |
|||
#define HSM1_MOD_RPOCK2 192 |
|||
#define HSM1_MOD_VOVER 193 |
|||
#define HSM1_MOD_VOVERP 194 |
|||
#define HSM1_MOD_WFC 195 |
|||
#define HSM1_MOD_QME1 196 |
|||
#define HSM1_MOD_QME2 197 |
|||
#define HSM1_MOD_QME3 198 |
|||
#define HSM1_MOD_GIDL1 199 |
|||
#define HSM1_MOD_GIDL2 200 |
|||
#define HSM1_MOD_GIDL3 201 |
|||
#define HSM1_MOD_GLEAK1 202 |
|||
#define HSM1_MOD_GLEAK2 203 |
|||
#define HSM1_MOD_GLEAK3 204 |
|||
#define HSM1_MOD_VZADD0 205 |
|||
#define HSM1_MOD_PZADD0 206 |
|||
#define HSM1_MOD_WVTHSC 207 /* HiSIM1.1 */ |
|||
#define HSM1_MOD_NSTI 208 /* HiSIM1.1 */ |
|||
#define HSM1_MOD_WSTI 209 /* HiSIM1.1 */ |
|||
#define HSM1_MOD_RPOCP1 210 /* HiSIM1.1 */ |
|||
#define HSM1_MOD_RPOCP2 211 /* HiSIM1.1 */ |
|||
#define HSM1_MOD_NFTRP 401 |
|||
#define HSM1_MOD_NFALP 402 |
|||
#define HSM1_MOD_CIT 403 |
|||
#define HSM1_MOD_EF 500 |
|||
#define HSM1_MOD_AF 501 |
|||
#define HSM1_MOD_KF 502 |
|||
|
|||
/* device questions */ |
|||
#define HSM1_DNODE 341 |
|||
#define HSM1_GNODE 342 |
|||
#define HSM1_SNODE 343 |
|||
#define HSM1_BNODE 344 |
|||
#define HSM1_DNODEPRIME 345 |
|||
#define HSM1_SNODEPRIME 346 |
|||
#define HSM1_VBD 347 |
|||
#define HSM1_VBS 348 |
|||
#define HSM1_VGS 349 |
|||
#define HSM1_VDS 350 |
|||
#define HSM1_CD 351 |
|||
#define HSM1_CBS 352 |
|||
#define HSM1_CBD 353 |
|||
#define HSM1_GM 354 |
|||
#define HSM1_GDS 355 |
|||
#define HSM1_GMBS 356 |
|||
#define HSM1_GBD 357 |
|||
#define HSM1_GBS 358 |
|||
#define HSM1_QB 359 |
|||
#define HSM1_CQB 360 |
|||
#define HSM1_QG 361 |
|||
#define HSM1_CQG 362 |
|||
#define HSM1_QD 363 |
|||
#define HSM1_CQD 364 |
|||
#define HSM1_CGG 365 |
|||
#define HSM1_CGD 366 |
|||
#define HSM1_CGS 367 |
|||
#define HSM1_CBG 368 |
|||
#define HSM1_CAPBD 369 |
|||
#define HSM1_CQBD 370 |
|||
#define HSM1_CAPBS 371 |
|||
#define HSM1_CQBS 372 |
|||
#define HSM1_CDG 373 |
|||
#define HSM1_CDD 374 |
|||
#define HSM1_CDS 375 |
|||
#define HSM1_VON 376 |
|||
#define HSM1_VDSAT 377 |
|||
#define HSM1_QBS 378 |
|||
#define HSM1_QBD 379 |
|||
#define HSM1_SOURCECONDUCT 380 |
|||
#define HSM1_DRAINCONDUCT 381 |
|||
#define HSM1_CBDB 382 |
|||
#define HSM1_CBSB 383 |
|||
|
|||
#include "hsm1ext.h" |
|||
|
|||
/* |
|||
extern void HSM1evaluate(double,double,double,HSM1instance*,HSM1model*, |
|||
double*,double*,double*, double*, double*, double*, double*, |
|||
double*, double*, double*, double*, double*, double*, double*, |
|||
double*, double*, double*, double*, CKTcircuit*); |
|||
*/ |
|||
|
|||
#endif /*HSM1*/ |
|||
|
|||
@ -0,0 +1,41 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1del.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "hsm1def.h" |
|||
#include "sperror.h" |
|||
#include "gendefs.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1delete(GENmodel *inModel, IFuid name, GENinstance **inInst) |
|||
{ |
|||
HSM1instance **fast = (HSM1instance**)inInst; |
|||
HSM1model *model = (HSM1model*)inModel; |
|||
HSM1instance **prev = NULL; |
|||
HSM1instance *here; |
|||
|
|||
for( ;model ;model = model->HSM1nextModel ) { |
|||
prev = &(model->HSM1instances); |
|||
for ( here = *prev ;here ;here = *prev ) { |
|||
if ( here->HSM1name == name || (fast && here==*fast) ) { |
|||
*prev= here->HSM1nextInstance; |
|||
FREE(here); |
|||
return(OK); |
|||
} |
|||
prev = &(here->HSM1nextInstance); |
|||
} |
|||
} |
|||
return(E_NODEV); |
|||
} |
|||
@ -0,0 +1,41 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1dest.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "hsm1def.h" |
|||
#include "suffix.h" |
|||
|
|||
void HSM1destroy(GENmodel **inModel) |
|||
{ |
|||
HSM1model **model = (HSM1model**)inModel; |
|||
HSM1instance *here; |
|||
HSM1instance *prev = NULL; |
|||
HSM1model *mod = *model; |
|||
HSM1model *oldmod = NULL; |
|||
|
|||
for ( ;mod ;mod = mod->HSM1nextModel ) { |
|||
if (oldmod) FREE(oldmod); |
|||
oldmod = mod; |
|||
prev = (HSM1instance *)NULL; |
|||
for ( here = mod->HSM1instances ;here ;here = here->HSM1nextInstance ) { |
|||
if (prev) FREE(prev); |
|||
prev = here; |
|||
} |
|||
if (prev) FREE(prev); |
|||
} |
|||
if (oldmod) FREE(oldmod); |
|||
*model = NULL; |
|||
} |
|||
|
|||
4572
src/spicelib/devices/hisim/hsm1eval1_0.c
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
4758
src/spicelib/devices/hisim/hsm1eval1_1.c
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,84 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1evalenv.h of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#ifndef HSM1_EVAL_ENV_H |
|||
#define HSM1_EVAL_ENV_H |
|||
|
|||
/* macros and constants used in hsm1eval1_x.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 |
|||
|
|||
/* 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) |
|||
|
|||
/*---------------------------------------------------* |
|||
* Physical constants/properties. (macro) |
|||
*-----------------*/ |
|||
/* Elemental charge */ |
|||
#define C_QE (1.6021918e-19) |
|||
|
|||
/* Boltzmann constant */ |
|||
#define C_KB (1.3806226e-23) |
|||
|
|||
/* Permitivity of Si and SiO2 */ |
|||
#define C_ESI (1.034943e-12) |
|||
#define C_EOX (3.453133e-13) |
|||
|
|||
/* Room temperature constants */ |
|||
#define C_T300 (300e+00) |
|||
#define C_b300 (3.868283e+01) |
|||
#define C_Eg0 (1.1785e0) |
|||
|
|||
/* Build-in potential */ |
|||
#define C_Vbi (1.0e0) |
|||
|
|||
/* 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 /* HSM1_EVAL_ENV_H */ |
|||
@ -0,0 +1,37 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1ext.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
extern int HSM1acLoad(GENmodel *,CKTcircuit*); |
|||
extern int HSM1ask(CKTcircuit *,GENinstance*,int,IFvalue*,IFvalue*); |
|||
extern int HSM1convTest(GENmodel *,CKTcircuit*); |
|||
extern int HSM1delete(GENmodel*,IFuid,GENinstance**); |
|||
extern void HSM1destroy(GENmodel**); |
|||
extern int HSM1getic(GENmodel*,CKTcircuit*); |
|||
extern int HSM1load(GENmodel*,CKTcircuit*); |
|||
extern int HSM1mAsk(CKTcircuit*,GENmodel *,int, IFvalue*); |
|||
extern int HSM1mDelete(GENmodel**,IFuid,GENmodel*); |
|||
extern int HSM1mParam(int,IFvalue*,GENmodel*); |
|||
extern void HSM1mosCap(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 HSM1param(int,IFvalue*,GENinstance*,IFvalue*); |
|||
extern int HSM1pzLoad(GENmodel*,CKTcircuit*,SPcomplex*); |
|||
extern int HSM1setup(SMPmatrix*,GENmodel*,CKTcircuit*,int*); |
|||
extern int HSM1unsetup(GENmodel*,CKTcircuit*); |
|||
extern int HSM1temp(GENmodel*,CKTcircuit*); |
|||
extern int HSM1trunc(GENmodel*,CKTcircuit*,double*); |
|||
extern int HSM1noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*); |
|||
@ -0,0 +1,56 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1getic.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "cktdefs.h" |
|||
#include "hsm1def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1getic(GENmodel *inModel, CKTcircuit *ckt) |
|||
{ |
|||
HSM1model *model = (HSM1model*)inModel; |
|||
HSM1instance *here; |
|||
/* |
|||
* grab initial conditions out of rhs array. User specified, so use |
|||
* external nodes to get values |
|||
*/ |
|||
|
|||
for ( ;model ;model = model->HSM1nextModel ) { |
|||
for ( here = model->HSM1instances; here ;here = here->HSM1nextInstance ) { |
|||
|
|||
if (here->HSM1owner != ARCHme) |
|||
continue; |
|||
|
|||
if (!here->HSM1_icVBS_Given) { |
|||
here->HSM1_icVBS = |
|||
*(ckt->CKTrhs + here->HSM1bNode) - |
|||
*(ckt->CKTrhs + here->HSM1sNode); |
|||
} |
|||
if (!here->HSM1_icVDS_Given) { |
|||
here->HSM1_icVDS = |
|||
*(ckt->CKTrhs + here->HSM1dNode) - |
|||
*(ckt->CKTrhs + here->HSM1sNode); |
|||
} |
|||
if (!here->HSM1_icVGS_Given) { |
|||
here->HSM1_icVGS = |
|||
*(ckt->CKTrhs + here->HSM1gNode) - |
|||
*(ckt->CKTrhs + here->HSM1sNode); |
|||
} |
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
@ -0,0 +1,82 @@ |
|||
#include <config.h> |
|||
|
|||
#include <devdefs.h> |
|||
|
|||
#include "hsm1itf.h" |
|||
#include "hsm1ext.h" |
|||
#include "hsm1init.h" |
|||
|
|||
|
|||
SPICEdev HSM1info = { |
|||
{ |
|||
"HiSIM1", |
|||
"Hiroshima-university STARC IGFET Model 1.1.0", |
|||
|
|||
&HSM1nSize, |
|||
&HSM1nSize, |
|||
HSM1names, |
|||
|
|||
&HSM1pTSize, |
|||
HSM1pTable, |
|||
|
|||
&HSM1mPTSize, |
|||
HSM1mPTable, |
|||
#ifdef XSPICE |
|||
/*---- Fixed by SDB 5.2.2003 to enable XSPICE/tclspice integration -----*/ |
|||
NULL, /* This is a SPICE device, it has no MIF info data */ |
|||
|
|||
0, /* This is a SPICE device, it has no MIF info data */ |
|||
NULL, /* This is a SPICE device, it has no MIF info data */ |
|||
|
|||
0, /* This is a SPICE device, it has no MIF info data */ |
|||
NULL, /* This is a SPICE device, it has no MIF info data */ |
|||
|
|||
0, /* This is a SPICE device, it has no MIF info data */ |
|||
NULL, /* This is a SPICE device, it has no MIF info data */ |
|||
/*--------------------------- End of SDB fix -------------------------*/ |
|||
#endif |
|||
|
|||
DEV_DEFAULT |
|||
}, |
|||
|
|||
DEVparam : HSM1param, |
|||
DEVmodParam : HSM1mParam, |
|||
DEVload : HSM1load, |
|||
DEVsetup : HSM1setup, |
|||
DEVunsetup : HSM1unsetup, |
|||
DEVpzSetup : HSM1setup, |
|||
DEVtemperature: HSM1temp, |
|||
DEVtrunc : HSM1trunc, |
|||
DEVfindBranch : NULL, |
|||
DEVacLoad : HSM1acLoad, |
|||
DEVaccept : NULL, |
|||
DEVdestroy : HSM1destroy, |
|||
DEVmodDelete : HSM1mDelete, |
|||
DEVdelete : HSM1delete, |
|||
DEVsetic : HSM1getic, |
|||
DEVask : HSM1ask, |
|||
DEVmodAsk : HSM1mAsk, |
|||
DEVpzLoad : HSM1pzLoad, |
|||
DEVconvTest : HSM1convTest, |
|||
DEVsenSetup : NULL, |
|||
DEVsenLoad : NULL, |
|||
DEVsenUpdate : NULL, |
|||
DEVsenAcLoad : NULL, |
|||
DEVsenPrint : NULL, |
|||
DEVsenTrunc : NULL, |
|||
DEVdisto : NULL, |
|||
DEVnoise : HSM1noise, |
|||
#ifdef CIDER |
|||
DEVdump : NULL, |
|||
DEVacct : NULL, |
|||
#endif |
|||
DEVinstSize : &HSM1iSize, |
|||
DEVmodSize : &HSM1mSize |
|||
}; |
|||
|
|||
|
|||
SPICEdev * |
|||
get_hsm1_info(void) |
|||
{ |
|||
return &HSM1info; |
|||
} |
|||
@ -0,0 +1,13 @@ |
|||
#ifndef _HISIM1INIT_H |
|||
#define _HISIM1INIT_H |
|||
|
|||
extern IFparm HSM1pTable[ ]; |
|||
extern IFparm HSM1mPTable[ ]; |
|||
extern char *HSM1names[ ]; |
|||
extern int HSM1pTSize; |
|||
extern int HSM1mPTSize; |
|||
extern int HSM1nSize; |
|||
extern int HSM1iSize; |
|||
extern int HSM1mSize; |
|||
|
|||
#endif |
|||
@ -0,0 +1,13 @@ |
|||
/********** |
|||
Copyright 2001 Regents of the University of California. All rights reserved. |
|||
Author: 2000 Weidong Liu, Xiaodong Jin. |
|||
Author: 2001 Xuemei Xi |
|||
File: bsim4itf.h |
|||
**********/ |
|||
|
|||
#ifndef DEV_HISIM1 |
|||
#define DEV_HISIM1 |
|||
|
|||
SPICEdev *get_hsm1_info(void); |
|||
|
|||
#endif |
|||
1036
src/spicelib/devices/hisim/hsm1ld.c
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,379 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1mask.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "ifsim.h" |
|||
#include "cktdefs.h" |
|||
#include "devdefs.h" |
|||
#include "hsm1def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1mAsk(CKTcircuit *ckt, GENmodel *inst, int which, IFvalue *value) |
|||
{ |
|||
HSM1model *model = (HSM1model *)inst; |
|||
switch (which) { |
|||
case HSM1_MOD_NMOS: |
|||
value->iValue = model->HSM1_type; |
|||
return(OK); |
|||
case HSM1_MOD_PMOS: |
|||
value->iValue = model->HSM1_type; |
|||
return(OK); |
|||
case HSM1_MOD_LEVEL: |
|||
value->iValue = model->HSM1_level; |
|||
return(OK); |
|||
case HSM1_MOD_INFO: |
|||
value->iValue = model->HSM1_info; |
|||
return(OK); |
|||
case HSM1_MOD_NOISE: |
|||
value->iValue = model->HSM1_noise; |
|||
return(OK); |
|||
case HSM1_MOD_VERSION: |
|||
value->iValue = model->HSM1_version; |
|||
return(OK); |
|||
case HSM1_MOD_SHOW: |
|||
value->iValue = model->HSM1_show; |
|||
return(OK); |
|||
case HSM1_MOD_CORSRD: |
|||
value->iValue = model->HSM1_corsrd; |
|||
return(OK); |
|||
case HSM1_MOD_COIPRV: |
|||
value->iValue = model->HSM1_coiprv; |
|||
return(OK); |
|||
case HSM1_MOD_COPPRV: |
|||
value->iValue = model->HSM1_copprv; |
|||
return(OK); |
|||
case HSM1_MOD_COCGSO: |
|||
value->iValue = model->HSM1_cocgso; |
|||
return(OK); |
|||
case HSM1_MOD_COCGDO: |
|||
value->iValue = model->HSM1_cocgdo; |
|||
return(OK); |
|||
case HSM1_MOD_COCGBO: |
|||
value->rValue = model->HSM1_cocgbo; |
|||
return(OK); |
|||
case HSM1_MOD_COADOV: |
|||
value->iValue = model->HSM1_coadov; |
|||
return(OK); |
|||
case HSM1_MOD_COXX08: |
|||
value->iValue = model->HSM1_coxx08; |
|||
return(OK); |
|||
case HSM1_MOD_COXX09: |
|||
value->iValue = model->HSM1_coxx09; |
|||
return(OK); |
|||
case HSM1_MOD_COISUB: |
|||
value->iValue = model->HSM1_coisub; |
|||
return(OK); |
|||
case HSM1_MOD_COIIGS: |
|||
value->iValue = model->HSM1_coiigs; |
|||
return(OK); |
|||
case HSM1_MOD_COGIDL: |
|||
value->iValue = model->HSM1_cogidl; |
|||
return(OK); |
|||
case HSM1_MOD_COOVLP: |
|||
value->iValue = model->HSM1_coovlp; |
|||
return(OK); |
|||
case HSM1_MOD_CONOIS: |
|||
value->iValue = model->HSM1_conois; |
|||
return(OK); |
|||
case HSM1_MOD_COISTI: /* HiSIM1.1 */ |
|||
value->iValue = model->HSM1_coisti; |
|||
return(OK); |
|||
case HSM1_MOD_VMAX: |
|||
value->rValue = model->HSM1_vmax; |
|||
return(OK); |
|||
case HSM1_MOD_BGTMP1: |
|||
value->rValue = model->HSM1_bgtmp1; |
|||
return(OK); |
|||
case HSM1_MOD_BGTMP2: |
|||
value->rValue = model->HSM1_bgtmp2; |
|||
return(OK); |
|||
case HSM1_MOD_TOX: |
|||
value->rValue = model->HSM1_tox; |
|||
return(OK); |
|||
case HSM1_MOD_DL: |
|||
value->rValue = model->HSM1_dl; |
|||
return(OK); |
|||
case HSM1_MOD_DW: |
|||
value->rValue = model->HSM1_dw; |
|||
return(OK); |
|||
case HSM1_MOD_XJ: /* HiSIM1.0 */ |
|||
value->rValue = model->HSM1_xj; |
|||
return(OK); |
|||
case HSM1_MOD_XQY: /* HiSIM1.1 */ |
|||
value->rValue = model->HSM1_xqy; |
|||
return(OK); |
|||
case HSM1_MOD_RS: |
|||
value->rValue = model->HSM1_rs; |
|||
return(OK); |
|||
case HSM1_MOD_RD: |
|||
value->rValue = model->HSM1_rd; |
|||
return(OK); |
|||
case HSM1_MOD_VFBC: |
|||
value->rValue = model->HSM1_vfbc; |
|||
return(OK); |
|||
case HSM1_MOD_NSUBC: |
|||
value->rValue = model->HSM1_nsubc; |
|||
return(OK); |
|||
case HSM1_MOD_PARL1: |
|||
value->rValue = model->HSM1_parl1; |
|||
return(OK); |
|||
case HSM1_MOD_PARL2: |
|||
value->rValue = model->HSM1_parl2; |
|||
return(OK); |
|||
case HSM1_MOD_LP: |
|||
value->rValue = model->HSM1_lp; |
|||
return(OK); |
|||
case HSM1_MOD_NSUBP: |
|||
value->rValue = model->HSM1_nsubp; |
|||
return(OK); |
|||
case HSM1_MOD_SCP1: |
|||
value->rValue = model->HSM1_scp1; |
|||
return(OK); |
|||
case HSM1_MOD_SCP2: |
|||
value->rValue = model->HSM1_scp2; |
|||
return(OK); |
|||
case HSM1_MOD_SCP3: |
|||
value->rValue = model->HSM1_scp3; |
|||
return(OK); |
|||
case HSM1_MOD_SC1: |
|||
value->rValue = model->HSM1_sc1; |
|||
return(OK); |
|||
case HSM1_MOD_SC2: |
|||
value->rValue = model->HSM1_sc2; |
|||
return(OK); |
|||
case HSM1_MOD_SC3: |
|||
value->rValue = model->HSM1_sc3; |
|||
return(OK); |
|||
case HSM1_MOD_PGD1: |
|||
value->rValue = model->HSM1_pgd1; |
|||
return(OK); |
|||
case HSM1_MOD_PGD2: |
|||
value->rValue = model->HSM1_pgd2; |
|||
return(OK); |
|||
case HSM1_MOD_PGD3: |
|||
value->rValue = model->HSM1_pgd3; |
|||
return(OK); |
|||
case HSM1_MOD_NDEP: |
|||
value->rValue = model->HSM1_ndep; |
|||
return(OK); |
|||
case HSM1_MOD_NINV: |
|||
value->rValue = model->HSM1_ninv; |
|||
return(OK); |
|||
case HSM1_MOD_NINVD: |
|||
value->rValue = model->HSM1_ninvd; |
|||
return(OK); |
|||
case HSM1_MOD_MUECB0: |
|||
value->rValue = model->HSM1_muecb0; |
|||
return(OK); |
|||
case HSM1_MOD_MUECB1: |
|||
value->rValue = model->HSM1_muecb1; |
|||
return(OK); |
|||
case HSM1_MOD_MUEPH1: |
|||
value->rValue = model->HSM1_mueph1; |
|||
return(OK); |
|||
case HSM1_MOD_MUEPH0: |
|||
value->rValue = model->HSM1_mueph0; |
|||
return(OK); |
|||
case HSM1_MOD_MUEPH2: |
|||
value->rValue = model->HSM1_mueph2; |
|||
return(OK); |
|||
case HSM1_MOD_W0: |
|||
value->rValue = model->HSM1_w0; |
|||
return(OK); |
|||
case HSM1_MOD_MUESR1: |
|||
value->rValue = model->HSM1_muesr1; |
|||
return(OK); |
|||
case HSM1_MOD_MUESR0: |
|||
value->rValue = model->HSM1_muesr0; |
|||
return(OK); |
|||
case HSM1_MOD_BB: |
|||
value->rValue = model->HSM1_bb; |
|||
return(OK); |
|||
case HSM1_MOD_VDS0: |
|||
value->rValue = model->HSM1_vds0; |
|||
return(OK); |
|||
case HSM1_MOD_BC0: |
|||
value->rValue = model->HSM1_bc0; |
|||
return(OK); |
|||
case HSM1_MOD_BC1: |
|||
value->rValue = model->HSM1_bc1; |
|||
return(OK); |
|||
case HSM1_MOD_SUB1: |
|||
value->rValue = model->HSM1_sub1; |
|||
return(OK); |
|||
case HSM1_MOD_SUB2: |
|||
value->rValue = model->HSM1_sub2; |
|||
return(OK); |
|||
case HSM1_MOD_SUB3: |
|||
value->rValue = model->HSM1_sub3; |
|||
return(OK); |
|||
case HSM1_MOD_WVTHSC: /* HiSIM1.1 */ |
|||
value->rValue = model->HSM1_wvthsc; |
|||
return(OK); |
|||
case HSM1_MOD_NSTI: /* HiSIM1.1 */ |
|||
value->rValue = model->HSM1_nsti; |
|||
return(OK); |
|||
case HSM1_MOD_WSTI: /* HiSIM1.1 */ |
|||
value->rValue = model->HSM1_wsti; |
|||
return(OK); |
|||
case HSM1_MOD_CGSO: |
|||
value->rValue = model->HSM1_cgso; |
|||
return(OK); |
|||
case HSM1_MOD_CGDO: |
|||
value->rValue = model->HSM1_cgdo; |
|||
return(OK); |
|||
case HSM1_MOD_CGBO: |
|||
value->rValue = model->HSM1_cgbo; |
|||
return(OK); |
|||
case HSM1_MOD_TPOLY: |
|||
value->rValue = model->HSM1_tpoly; |
|||
return(OK); |
|||
case HSM1_MOD_JS0: |
|||
value->rValue = model->HSM1_js0; |
|||
return(OK); |
|||
case HSM1_MOD_JS0SW: |
|||
value->rValue = model->HSM1_js0sw; |
|||
return(OK); |
|||
case HSM1_MOD_NJ: |
|||
value->rValue = model->HSM1_nj; |
|||
return(OK); |
|||
case HSM1_MOD_NJSW: |
|||
value->rValue = model->HSM1_njsw; |
|||
return(OK); |
|||
case HSM1_MOD_XTI: |
|||
value->rValue = model->HSM1_xti; |
|||
return(OK); |
|||
case HSM1_MOD_CJ: |
|||
value->rValue = model->HSM1_cj; |
|||
return(OK); |
|||
case HSM1_MOD_CJSW: |
|||
value->rValue = model->HSM1_cjsw; |
|||
return(OK); |
|||
case HSM1_MOD_CJSWG: |
|||
value->rValue = model->HSM1_cjswg; |
|||
return(OK); |
|||
case HSM1_MOD_MJ: |
|||
value->rValue = model->HSM1_mj; |
|||
return(OK); |
|||
case HSM1_MOD_MJSW: |
|||
value->rValue = model->HSM1_mjsw; |
|||
return(OK); |
|||
case HSM1_MOD_MJSWG: |
|||
value->rValue = model->HSM1_mjswg; |
|||
return(OK); |
|||
case HSM1_MOD_PB: |
|||
value->rValue = model->HSM1_pbsw; |
|||
return(OK); |
|||
case HSM1_MOD_PBSW: |
|||
value->rValue = model->HSM1_pbsw; |
|||
return(OK); |
|||
case HSM1_MOD_PBSWG: |
|||
value->rValue = model->HSM1_pbswg; |
|||
return(OK); |
|||
case HSM1_MOD_XPOLYD: |
|||
value->rValue = model->HSM1_xpolyd; |
|||
return(OK); |
|||
case HSM1_MOD_CLM1: |
|||
value->rValue = model->HSM1_clm1; |
|||
return(OK); |
|||
case HSM1_MOD_CLM2: |
|||
value->rValue = model->HSM1_clm2; |
|||
return(OK); |
|||
case HSM1_MOD_CLM3: |
|||
value->rValue = model->HSM1_clm3; |
|||
return(OK); |
|||
case HSM1_MOD_MUETMP: |
|||
value->rValue = model->HSM1_muetmp; |
|||
return(OK); |
|||
case HSM1_MOD_RPOCK1: |
|||
value->rValue = model->HSM1_rpock1; |
|||
return(OK); |
|||
case HSM1_MOD_RPOCK2: |
|||
value->rValue = model->HSM1_rpock2; |
|||
return(OK); |
|||
case HSM1_MOD_RPOCP1: /* HiSIM1.1 */ |
|||
value->rValue = model->HSM1_rpocp1; |
|||
return(OK); |
|||
case HSM1_MOD_RPOCP2: /* HiSIM1.1 */ |
|||
value->rValue = model->HSM1_rpocp2; |
|||
return(OK); |
|||
case HSM1_MOD_VOVER: |
|||
value->rValue = model->HSM1_vover; |
|||
return(OK); |
|||
case HSM1_MOD_VOVERP: |
|||
value->rValue = model->HSM1_voverp; |
|||
return(OK); |
|||
case HSM1_MOD_WFC: |
|||
value->rValue = model->HSM1_wfc; |
|||
return(OK); |
|||
case HSM1_MOD_QME1: |
|||
value->rValue = model->HSM1_qme1; |
|||
return(OK); |
|||
case HSM1_MOD_QME2: |
|||
value->rValue = model->HSM1_qme2; |
|||
return(OK); |
|||
case HSM1_MOD_QME3: |
|||
value->rValue = model->HSM1_qme3; |
|||
return(OK); |
|||
case HSM1_MOD_GIDL1: |
|||
value->rValue = model->HSM1_gidl1; |
|||
return(OK); |
|||
case HSM1_MOD_GIDL2: |
|||
value->rValue = model->HSM1_gidl2; |
|||
return(OK); |
|||
case HSM1_MOD_GIDL3: |
|||
value->rValue = model->HSM1_gidl3; |
|||
return(OK); |
|||
case HSM1_MOD_GLEAK1: |
|||
value->rValue = model->HSM1_gleak1; |
|||
return(OK); |
|||
case HSM1_MOD_GLEAK2: |
|||
value->rValue = model->HSM1_gleak2; |
|||
return(OK); |
|||
case HSM1_MOD_GLEAK3: |
|||
value->rValue = model->HSM1_gleak3; |
|||
return(OK); |
|||
case HSM1_MOD_VZADD0: |
|||
value->rValue = model->HSM1_vzadd0; |
|||
return(OK); |
|||
case HSM1_MOD_PZADD0: |
|||
value->rValue = model->HSM1_pzadd0; |
|||
return(OK); |
|||
case HSM1_MOD_NFTRP: |
|||
value->rValue = model->HSM1_nftrp; |
|||
return(OK); |
|||
case HSM1_MOD_NFALP: |
|||
value->rValue = model->HSM1_nfalp; |
|||
return(OK); |
|||
case HSM1_MOD_CIT: |
|||
value->rValue = model->HSM1_cit; |
|||
return(OK); |
|||
case HSM1_MOD_KF: |
|||
value->rValue = model->HSM1_kf; |
|||
return(OK); |
|||
case HSM1_MOD_AF: |
|||
value->rValue = model->HSM1_af; |
|||
return(OK); |
|||
case HSM1_MOD_EF: |
|||
value->rValue = model->HSM1_ef; |
|||
return(OK); |
|||
default: |
|||
return(E_BADPARM); |
|||
} |
|||
/* NOTREACHED */ |
|||
} |
|||
|
|||
|
|||
@ -0,0 +1,48 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1mdel.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "hsm1def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1mDelete(GENmodel **inModel, IFuid modname, GENmodel *kill) |
|||
{ |
|||
HSM1model **model = (HSM1model**)inModel; |
|||
HSM1model *modfast = (HSM1model*)kill; |
|||
HSM1instance *here; |
|||
HSM1instance *prev = NULL; |
|||
HSM1model **oldmod; |
|||
|
|||
oldmod = model; |
|||
for ( ;*model ;model = &((*model)->HSM1nextModel) ) { |
|||
if ( (*model)->HSM1modName == modname || |
|||
(modfast && *model == modfast) ) goto delgot; |
|||
oldmod = model; |
|||
} |
|||
return(E_NOMOD); |
|||
|
|||
delgot: |
|||
*oldmod = (*model)->HSM1nextModel; /* cut deleted device out of list */ |
|||
for ( here = (*model)->HSM1instances ; |
|||
here ;here = here->HSM1nextInstance ) { |
|||
if (prev) FREE(prev); |
|||
prev = here; |
|||
} |
|||
if (prev) FREE(prev); |
|||
FREE(*model); |
|||
return(OK); |
|||
} |
|||
|
|||
@ -0,0 +1,495 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1mpar.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "hsm1def.h" |
|||
#include "ifsim.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1mParam(int param, IFvalue *value, GENmodel *inMod) |
|||
{ |
|||
HSM1model *mod = (HSM1model*)inMod; |
|||
switch (param) { |
|||
case HSM1_MOD_NMOS : |
|||
if (value->iValue) { |
|||
mod->HSM1_type = 1; |
|||
mod->HSM1_type_Given = TRUE; |
|||
} |
|||
break; |
|||
case HSM1_MOD_PMOS : |
|||
if (value->iValue) { |
|||
mod->HSM1_type = - 1; |
|||
mod->HSM1_type_Given = TRUE; |
|||
} |
|||
break; |
|||
case HSM1_MOD_LEVEL: |
|||
mod->HSM1_level = value->iValue; |
|||
mod->HSM1_level_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_INFO: |
|||
mod->HSM1_info = value->iValue; |
|||
mod->HSM1_info_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NOISE: |
|||
mod->HSM1_noise = value->iValue; |
|||
mod->HSM1_noise_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_VERSION: |
|||
mod->HSM1_version = value->iValue; |
|||
mod->HSM1_version_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_SHOW: |
|||
mod->HSM1_show = value->iValue; |
|||
mod->HSM1_show_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CORSRD: |
|||
mod->HSM1_corsrd = value->iValue; |
|||
mod->HSM1_corsrd_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COIPRV: |
|||
mod->HSM1_coiprv = value->iValue; |
|||
mod->HSM1_coiprv_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COPPRV: |
|||
mod->HSM1_copprv = value->iValue; |
|||
mod->HSM1_copprv_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COCGSO: |
|||
mod->HSM1_cocgso = value->iValue; |
|||
mod->HSM1_cocgso_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COCGDO: |
|||
mod->HSM1_cocgdo = value->iValue; |
|||
mod->HSM1_cocgdo_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COCGBO: |
|||
mod->HSM1_cocgbo = value->iValue; |
|||
mod->HSM1_cocgbo_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COADOV: |
|||
mod->HSM1_coadov = value->iValue; |
|||
mod->HSM1_coadov_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COXX08: |
|||
mod->HSM1_coxx08 = value->iValue; |
|||
mod->HSM1_coxx08_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COXX09: |
|||
mod->HSM1_coxx09 = value->iValue; |
|||
mod->HSM1_coxx09_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COISUB: |
|||
mod->HSM1_coisub = value->iValue; |
|||
mod->HSM1_coisub_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COIIGS: |
|||
mod->HSM1_coiigs = value->iValue; |
|||
mod->HSM1_coiigs_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COGIDL: |
|||
mod->HSM1_cogidl = value->iValue; |
|||
mod->HSM1_cogidl_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COOVLP: |
|||
mod->HSM1_coovlp = value->iValue; |
|||
mod->HSM1_coovlp_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CONOIS: /* HiSIM1.1 */ |
|||
mod->HSM1_conois = value->iValue; |
|||
mod->HSM1_conois_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_COISTI: |
|||
mod->HSM1_coisti = value->iValue; |
|||
mod->HSM1_coisti_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_VMAX: |
|||
mod->HSM1_vmax = value->rValue; |
|||
mod->HSM1_vmax_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_BGTMP1: |
|||
mod->HSM1_bgtmp1 = value->rValue; |
|||
mod->HSM1_bgtmp1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_BGTMP2: |
|||
mod->HSM1_bgtmp2 = value->rValue; |
|||
mod->HSM1_bgtmp2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_TOX: |
|||
mod->HSM1_tox = value->rValue; |
|||
mod->HSM1_tox_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_DL: |
|||
mod->HSM1_dl = value->rValue; |
|||
mod->HSM1_dl_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_DW: |
|||
mod->HSM1_dw = value->rValue; |
|||
mod->HSM1_dw_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_XJ: /* HiSIM1.0 */ |
|||
mod->HSM1_xj = value->rValue; |
|||
mod->HSM1_xj_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_XQY: /* HiSIM1.1 */ |
|||
mod->HSM1_xqy = value->rValue; |
|||
mod->HSM1_xqy_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_RS: |
|||
mod->HSM1_rs = value->rValue; |
|||
mod->HSM1_rs_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_RD: |
|||
mod->HSM1_rd = value->rValue; |
|||
mod->HSM1_rd_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_VFBC: |
|||
mod->HSM1_vfbc = value->rValue; |
|||
mod->HSM1_vfbc_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NSUBC: |
|||
mod->HSM1_nsubc = value->rValue; |
|||
mod->HSM1_nsubc_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_PARL1: |
|||
mod->HSM1_parl1 = value->rValue; |
|||
mod->HSM1_parl1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_PARL2: |
|||
mod->HSM1_parl2 = value->rValue; |
|||
mod->HSM1_parl2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_LP: |
|||
mod->HSM1_lp = value->rValue; |
|||
mod->HSM1_lp_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NSUBP: |
|||
mod->HSM1_nsubp = value->rValue; |
|||
mod->HSM1_nsubp_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_SCP1: |
|||
mod->HSM1_scp1 = value->rValue; |
|||
mod->HSM1_scp1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_SCP2: |
|||
mod->HSM1_scp2 = value->rValue; |
|||
mod->HSM1_scp2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_SCP3: |
|||
mod->HSM1_scp3 = value->rValue; |
|||
mod->HSM1_scp3_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_SC1: |
|||
mod->HSM1_sc1 = value->rValue; |
|||
mod->HSM1_sc1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_SC2: |
|||
mod->HSM1_sc2 = value->rValue; |
|||
mod->HSM1_sc2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_SC3: |
|||
mod->HSM1_sc3 = value->rValue; |
|||
mod->HSM1_sc3_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_PGD1: |
|||
mod->HSM1_pgd1 = value->rValue; |
|||
mod->HSM1_pgd1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_PGD2: |
|||
mod->HSM1_pgd2 = value->rValue; |
|||
mod->HSM1_pgd2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_PGD3: |
|||
mod->HSM1_pgd3 = value->rValue; |
|||
mod->HSM1_pgd3_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NDEP: |
|||
mod->HSM1_ndep = value->rValue; |
|||
mod->HSM1_ndep_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NINV: |
|||
mod->HSM1_ninv = value->rValue; |
|||
mod->HSM1_ninv_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NINVD: |
|||
mod->HSM1_ninvd = value->rValue; |
|||
mod->HSM1_ninvd_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MUECB0: |
|||
mod->HSM1_muecb0 = value->rValue; |
|||
mod->HSM1_muecb0_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MUECB1: |
|||
mod->HSM1_muecb1 = value->rValue; |
|||
mod->HSM1_muecb1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MUEPH1: |
|||
mod->HSM1_mueph1 = value->rValue; |
|||
mod->HSM1_mueph1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MUEPH0: |
|||
mod->HSM1_mueph0 = value->rValue; |
|||
mod->HSM1_mueph0_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MUEPH2: |
|||
mod->HSM1_mueph2 = value->rValue; |
|||
mod->HSM1_mueph2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_W0: |
|||
mod->HSM1_w0 = value->rValue; |
|||
mod->HSM1_w0_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MUESR1: |
|||
mod->HSM1_muesr1 = value->rValue; |
|||
mod->HSM1_muesr1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MUESR0: |
|||
mod->HSM1_muesr0 = value->rValue; |
|||
mod->HSM1_muesr0_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_BB: |
|||
mod->HSM1_bb = value->rValue; |
|||
mod->HSM1_bb_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_VDS0: |
|||
mod->HSM1_vds0 = value->rValue; |
|||
mod->HSM1_vds0_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_BC0: |
|||
mod->HSM1_bc0 = value->rValue; |
|||
mod->HSM1_bc0_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_BC1: |
|||
mod->HSM1_bc1 = value->rValue; |
|||
mod->HSM1_bc1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_SUB1: |
|||
mod->HSM1_sub1 = value->rValue; |
|||
mod->HSM1_sub1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_SUB2: |
|||
mod->HSM1_sub2 = value->rValue; |
|||
mod->HSM1_sub2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_SUB3: |
|||
mod->HSM1_sub3 = value->rValue; |
|||
mod->HSM1_sub3_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_WVTHSC: /* HiSIM1.1 */ |
|||
mod->HSM1_wvthsc = value->rValue; |
|||
mod->HSM1_wvthsc_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NSTI: /* HiSIM1.1 */ |
|||
mod->HSM1_nsti = value->rValue; |
|||
mod->HSM1_nsti_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_WSTI: /* HiSIM1.1 */ |
|||
mod->HSM1_wsti = value->rValue; |
|||
mod->HSM1_wsti_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CGSO: |
|||
mod->HSM1_cgso = value->rValue; |
|||
mod->HSM1_cgso_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CGDO: |
|||
mod->HSM1_cgdo = value->rValue; |
|||
mod->HSM1_cgdo_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CGBO: |
|||
mod->HSM1_cgbo = value->rValue; |
|||
mod->HSM1_cgbo_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_TPOLY: |
|||
mod->HSM1_tpoly = value->rValue; |
|||
mod->HSM1_tpoly_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_JS0: |
|||
mod->HSM1_js0 = value->rValue; |
|||
mod->HSM1_js0_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_JS0SW: |
|||
mod->HSM1_js0sw = value->rValue; |
|||
mod->HSM1_js0sw_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NJ: |
|||
mod->HSM1_nj = value->rValue; |
|||
mod->HSM1_nj_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NJSW: |
|||
mod->HSM1_njsw = value->rValue; |
|||
mod->HSM1_njsw_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_XTI: |
|||
mod->HSM1_xti = value->rValue; |
|||
mod->HSM1_xti_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CJ: |
|||
mod->HSM1_cj = value->rValue; |
|||
mod->HSM1_cj_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CJSW: |
|||
mod->HSM1_cjsw = value->rValue; |
|||
mod->HSM1_cjsw_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CJSWG: |
|||
mod->HSM1_cjswg = value->rValue; |
|||
mod->HSM1_cjswg_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MJ: |
|||
mod->HSM1_mj = value->rValue; |
|||
mod->HSM1_mj_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MJSW: |
|||
mod->HSM1_mjsw = value->rValue; |
|||
mod->HSM1_mjsw_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MJSWG: |
|||
mod->HSM1_mjswg = value->rValue; |
|||
mod->HSM1_mjswg_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_PB: |
|||
mod->HSM1_pb = value->rValue; |
|||
mod->HSM1_pb_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_PBSW: |
|||
mod->HSM1_pbsw = value->rValue; |
|||
mod->HSM1_pbsw_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_PBSWG: |
|||
mod->HSM1_pbswg = value->rValue; |
|||
mod->HSM1_pbswg_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_XPOLYD: |
|||
mod->HSM1_xpolyd = value->rValue; |
|||
mod->HSM1_xpolyd_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CLM1: |
|||
mod->HSM1_clm1 = value->rValue; |
|||
mod->HSM1_clm1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CLM2: |
|||
mod->HSM1_clm2 = value->rValue; |
|||
mod->HSM1_clm2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CLM3: |
|||
mod->HSM1_clm3 = value->rValue; |
|||
mod->HSM1_clm3_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_MUETMP: |
|||
mod->HSM1_muetmp = value->rValue; |
|||
mod->HSM1_muetmp_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_RPOCK1: |
|||
mod->HSM1_rpock1 = value->rValue; |
|||
mod->HSM1_rpock1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_RPOCK2: |
|||
mod->HSM1_rpock2 = value->rValue; |
|||
mod->HSM1_rpock2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_RPOCP1: /* HiSIM1.1 */ |
|||
mod->HSM1_rpocp1 = value->rValue; |
|||
mod->HSM1_rpocp1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_RPOCP2: /* HiSIM1.1 */ |
|||
mod->HSM1_rpocp2 = value->rValue; |
|||
mod->HSM1_rpocp2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_VOVER: |
|||
mod->HSM1_vover = value->rValue; |
|||
mod->HSM1_vover_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_VOVERP: |
|||
mod->HSM1_voverp = value->rValue; |
|||
mod->HSM1_voverp_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_WFC: |
|||
mod->HSM1_wfc = value->rValue; |
|||
mod->HSM1_wfc_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_QME1: |
|||
mod->HSM1_qme1 = value->rValue; |
|||
mod->HSM1_qme1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_QME2: |
|||
mod->HSM1_qme2 = value->rValue; |
|||
mod->HSM1_qme2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_QME3: |
|||
mod->HSM1_qme3 = value->rValue; |
|||
mod->HSM1_qme3_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_GIDL1: |
|||
mod->HSM1_gidl1 = value->rValue; |
|||
mod->HSM1_gidl1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_GIDL2: |
|||
mod->HSM1_gidl2 = value->rValue; |
|||
mod->HSM1_gidl2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_GIDL3: |
|||
mod->HSM1_gidl3 = value->rValue; |
|||
mod->HSM1_gidl3_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_GLEAK1: |
|||
mod->HSM1_gleak1 = value->rValue; |
|||
mod->HSM1_gleak1_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_GLEAK2: |
|||
mod->HSM1_gleak2 = value->rValue; |
|||
mod->HSM1_gleak2_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_GLEAK3: |
|||
mod->HSM1_gleak3 = value->rValue; |
|||
mod->HSM1_gleak3_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_VZADD0: |
|||
mod->HSM1_vzadd0 = value->rValue; |
|||
mod->HSM1_vzadd0_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_PZADD0: |
|||
mod->HSM1_pzadd0 = value->rValue; |
|||
mod->HSM1_pzadd0_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NFTRP: |
|||
mod->HSM1_nftrp = value->rValue; |
|||
mod->HSM1_nftrp_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_NFALP: |
|||
mod->HSM1_nfalp = value->rValue; |
|||
mod->HSM1_nfalp_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_CIT: |
|||
mod->HSM1_cit = value->rValue; |
|||
mod->HSM1_cit_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_KF: |
|||
mod->HSM1_kf = value->rValue; |
|||
mod->HSM1_kf_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_AF: |
|||
mod->HSM1_af = value->rValue; |
|||
mod->HSM1_af_Given = TRUE; |
|||
break; |
|||
case HSM1_MOD_EF: |
|||
mod->HSM1_ef = value->rValue; |
|||
mod->HSM1_ef_Given = TRUE; |
|||
break; |
|||
default: |
|||
return(E_BADPARM); |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
@ -0,0 +1,284 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1noi.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "hsm1def.h" |
|||
#include "cktdefs.h" |
|||
#include "iferrmsg.h" |
|||
#include "noisedef.h" |
|||
#include "suffix.h" |
|||
#include "const.h" /* jwan */ |
|||
|
|||
/* |
|||
* HSM1noise (mode, operation, firstModel, ckt, data, OnDens) |
|||
* This routine names and evaluates all of the noise sources |
|||
* associated with MOSFET's. It starts with the model *firstModel and |
|||
* traverses all of its insts. It then proceeds to any other models |
|||
* on the linked list. The total output noise density generated by |
|||
* all of the MOSFET's is summed with the variable "OnDens". |
|||
*/ |
|||
|
|||
/* |
|||
Channel thermal and flicker noises are calculated based on the value |
|||
of model->HSM1_noise. |
|||
If model->HSM1_noise = 1, |
|||
Channel thermal noise = SPICE2 model |
|||
Flicker noise = SPICE2 model |
|||
If model->HSM1_noise = 2, |
|||
Channel thermal noise = HiSIM1 model corresponding to BSIM3 model |
|||
Flicker noise = HiSIM1 model |
|||
If model->HSM1_noise = 3, |
|||
Channel thermal noise = SPICE2 model |
|||
Flicker noise = HiSIM1 model |
|||
If model->HSM1_noise = 4, |
|||
Channel thermal noise = HiSIM1 model corresponding to BSIM3 model |
|||
Flicker noise = SPICE2 model |
|||
If model->HSM1_noise = 5, |
|||
Channel thermal noise = NONE |
|||
Flicker noise = HiSIM1 model |
|||
*/ |
|||
|
|||
extern void NevalSrc(); |
|||
extern double Nintegrate(); |
|||
|
|||
int HSM1noise (int mode, int operation, GENmodel *inModel, CKTcircuit *ckt, |
|||
Ndata *data, double *OnDens) |
|||
{ |
|||
HSM1model *model = (HSM1model *)inModel; |
|||
HSM1instance *here; |
|||
char name[N_MXVLNTH]; |
|||
double tempOnoise; |
|||
double tempInoise; |
|||
double noizDens[HSM1NSRCS]; |
|||
double lnNdens[HSM1NSRCS]; |
|||
register int error, i; |
|||
|
|||
/* define the names of the noise sources */ |
|||
static char * HSM1nNames[HSM1NSRCS] = { |
|||
/* Note that we have to keep the order |
|||
consistent with the index definitions |
|||
in hsm1defs.h */ |
|||
".rd", /* noise due to rd */ |
|||
".rs", /* noise due to rs */ |
|||
".id", /* noise due to id */ |
|||
".1ovf", /* flicker (1/f) noise */ |
|||
"" /* total transistor noise */ |
|||
}; |
|||
|
|||
for ( ;model != NULL; model = model->HSM1nextModel ) { |
|||
for ( here = model->HSM1instances; here != NULL; |
|||
here = here->HSM1nextInstance ) { |
|||
|
|||
if (here->HSM1owner != ARCHme) |
|||
continue; |
|||
|
|||
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 < HSM1NSRCS; i++ ) { |
|||
(void) sprintf(name, "onoise.%s%s", |
|||
(char *)here->HSM1name, HSM1nNames[i]); |
|||
data->namelist = |
|||
(IFuid *) xrealloc((char *) data->namelist, |
|||
(data->numPlots + 1) * sizeof(IFuid)); |
|||
if (!data->namelist) |
|||
return(E_NOMEM); |
|||
(*(SPfrontEnd->IFnewUid)) |
|||
(ckt, &(data->namelist[data->numPlots++]), |
|||
(IFuid) NULL, name, UID_OTHER, (void **) NULL); |
|||
} |
|||
break; |
|||
case INT_NOIZ: |
|||
for ( i = 0; i < HSM1NSRCS; i++ ) { |
|||
(void) sprintf(name, "onoise_total.%s%s", |
|||
(char *)here->HSM1name, HSM1nNames[i]); |
|||
data->namelist = |
|||
(IFuid *) xrealloc((char *) data->namelist, |
|||
(data->numPlots + 1) * sizeof(IFuid)); |
|||
if (!data->namelist) |
|||
return(E_NOMEM); |
|||
(*(SPfrontEnd->IFnewUid)) |
|||
(ckt, &(data->namelist[data->numPlots++]), |
|||
(IFuid) NULL, name, UID_OTHER, (void **) NULL); |
|||
|
|||
(void) sprintf(name, "inoise_total.%s%s", |
|||
(char *)here->HSM1name, HSM1nNames[i]); |
|||
data->namelist = |
|||
(IFuid *) xrealloc((char *) data->namelist, |
|||
(data->numPlots + 1) * sizeof(IFuid)); |
|||
if (!data->namelist) |
|||
return(E_NOMEM); |
|||
(*(SPfrontEnd->IFnewUid)) |
|||
(ckt, &(data->namelist[data->numPlots++]), |
|||
(IFuid) NULL, name, UID_OTHER, (void **)NULL); |
|||
} |
|||
break; |
|||
} |
|||
} |
|||
break; |
|||
case N_CALC: |
|||
switch (mode) { |
|||
case N_DENS: |
|||
NevalSrc(&noizDens[HSM1RDNOIZ], &lnNdens[HSM1RDNOIZ], |
|||
ckt, THERMNOISE, |
|||
here->HSM1dNodePrime, here->HSM1dNode, |
|||
here->HSM1drainConductance * here->HSM1_m); |
|||
|
|||
NevalSrc(&noizDens[HSM1RSNOIZ], &lnNdens[HSM1RSNOIZ], |
|||
ckt, THERMNOISE, |
|||
here->HSM1sNodePrime, here->HSM1sNode, |
|||
here->HSM1sourceConductance * here->HSM1_m); |
|||
|
|||
switch( model->HSM1_noise ) { |
|||
double I; |
|||
case 1: |
|||
case 3: |
|||
I = here->HSM1_gm + here->HSM1_gds + here->HSM1_gmbs; |
|||
I *= (I < 0.0) ? -1.0 : 1.0; |
|||
I *= 2.0/3.0; |
|||
I *= here->HSM1_m; /* PN */ |
|||
NevalSrc(&noizDens[HSM1IDNOIZ], &lnNdens[HSM1IDNOIZ], |
|||
ckt, THERMNOISE, |
|||
here->HSM1dNodePrime, here->HSM1sNodePrime, I); |
|||
break; |
|||
case 2: |
|||
case 4: |
|||
I = -1.0 * (here->HSM1_qg + here->HSM1_qb) |
|||
/ (here->HSM1_weff * here->HSM1_leff); |
|||
I *= (I < 0.0) ? -1.0 : 1.0; |
|||
I *= here->HSM1_mu; |
|||
I *= here->HSM1_m; /* PN */ |
|||
NevalSrc(&noizDens[HSM1IDNOIZ], &lnNdens[HSM1IDNOIZ], |
|||
ckt, THERMNOISE, |
|||
here->HSM1dNodePrime, here->HSM1sNodePrime, I); |
|||
break; |
|||
case 5: |
|||
NevalSrc(&noizDens[HSM1IDNOIZ], &lnNdens[HSM1IDNOIZ], |
|||
ckt, THERMNOISE, |
|||
here->HSM1dNodePrime, here->HSM1sNodePrime, 0.0); |
|||
break; |
|||
} |
|||
NevalSrc(&noizDens[HSM1FLNOIZ], (double*) NULL, |
|||
ckt, N_GAIN, |
|||
here->HSM1dNodePrime, here->HSM1sNodePrime, |
|||
(double) 0.0); |
|||
|
|||
/* flicker noise */ |
|||
switch ( model->HSM1_noise ) { |
|||
case 1: |
|||
case 4: /* SPICE2 model */ |
|||
noizDens[HSM1FLNOIZ] *= model->HSM1_kf |
|||
* exp(model->HSM1_af * log(MAX(fabs(here->HSM1_ids * here->HSM1_m), N_MINLOG))) |
|||
/ (pow(data->freq, model->HSM1_ef) * here->HSM1_leff |
|||
* here->HSM1_leff * (3.453133e-11 / model->HSM1_tox)); |
|||
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~cox */ |
|||
break; |
|||
case 2: |
|||
case 3: |
|||
case 5: |
|||
/* from HiSIM */ |
|||
noizDens[HSM1FLNOIZ] *= here->HSM1_nfc / data->freq; |
|||
break; |
|||
} |
|||
|
|||
lnNdens[HSM1FLNOIZ] = log(MAX(noizDens[HSM1FLNOIZ], N_MINLOG)); |
|||
|
|||
noizDens[HSM1TOTNOIZ] = noizDens[HSM1RDNOIZ] + noizDens[HSM1RSNOIZ] |
|||
+ noizDens[HSM1IDNOIZ] + noizDens[HSM1FLNOIZ]; |
|||
lnNdens[HSM1TOTNOIZ] = log(MAX(noizDens[HSM1TOTNOIZ], N_MINLOG)); |
|||
|
|||
*OnDens += noizDens[HSM1TOTNOIZ]; |
|||
|
|||
if ( data->delFreq == 0.0 ) { |
|||
/* if we haven't done any previous |
|||
integration, we need to initialize our |
|||
"history" variables. |
|||
*/ |
|||
|
|||
for ( i = 0; i < HSM1NSRCS; i++ ) |
|||
here->HSM1nVar[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 < HSM1NSRCS; i++) { |
|||
here->HSM1nVar[OUTNOIZ][i] = 0.0; |
|||
here->HSM1nVar[INNOIZ][i] = 0.0; |
|||
} |
|||
} |
|||
} |
|||
else { |
|||
/* data->delFreq != 0.0, |
|||
we have to integrate. |
|||
*/ |
|||
for ( i = 0; i < HSM1NSRCS; i++ ) { |
|||
if ( i != HSM1TOTNOIZ ) { |
|||
tempOnoise = |
|||
Nintegrate(noizDens[i], lnNdens[i], |
|||
here->HSM1nVar[LNLSTDENS][i], data); |
|||
tempInoise = |
|||
Nintegrate(noizDens[i] * data->GainSqInv, |
|||
lnNdens[i] + data->lnGainInv, |
|||
here->HSM1nVar[LNLSTDENS][i] + data->lnGainInv, |
|||
data); |
|||
here->HSM1nVar[LNLSTDENS][i] = lnNdens[i]; |
|||
data->outNoiz += tempOnoise; |
|||
data->inNoise += tempInoise; |
|||
if ( ((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0 ) { |
|||
here->HSM1nVar[OUTNOIZ][i] += tempOnoise; |
|||
here->HSM1nVar[OUTNOIZ][HSM1TOTNOIZ] += tempOnoise; |
|||
here->HSM1nVar[INNOIZ][i] += tempInoise; |
|||
here->HSM1nVar[INNOIZ][HSM1TOTNOIZ] += tempInoise; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
if ( data->prtSummary ) { |
|||
for (i = 0; i < HSM1NSRCS; 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 < HSM1NSRCS; i++ ) { |
|||
data->outpVector[data->outNumber++] = here->HSM1nVar[OUTNOIZ][i]; |
|||
data->outpVector[data->outNumber++] = here->HSM1nVar[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); |
|||
} |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,105 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1par.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "ifsim.h" |
|||
#include "hsm1def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1param(int param, IFvalue *value, GENinstance *inst, IFvalue *select) |
|||
{ |
|||
HSM1instance *here = (HSM1instance*)inst; |
|||
switch (param) { |
|||
case HSM1_W: |
|||
here->HSM1_w = value->rValue; |
|||
here->HSM1_w_Given = TRUE; |
|||
break; |
|||
case HSM1_L: |
|||
here->HSM1_l = value->rValue; |
|||
here->HSM1_l_Given = TRUE; |
|||
break; |
|||
case HSM1_M: |
|||
here->HSM1_m = value->rValue; |
|||
here->HSM1_m_Given = TRUE; |
|||
break; |
|||
case HSM1_AS: |
|||
here->HSM1_as = value->rValue; |
|||
here->HSM1_as_Given = TRUE; |
|||
break; |
|||
case HSM1_AD: |
|||
here->HSM1_ad = value->rValue; |
|||
here->HSM1_ad_Given = TRUE; |
|||
break; |
|||
case HSM1_PS: |
|||
here->HSM1_ps = value->rValue; |
|||
here->HSM1_ps_Given = TRUE; |
|||
break; |
|||
case HSM1_PD: |
|||
here->HSM1_pd = value->rValue; |
|||
here->HSM1_pd_Given = TRUE; |
|||
break; |
|||
case HSM1_NRS: |
|||
here->HSM1_nrs = value->rValue; |
|||
here->HSM1_nrs_Given = TRUE; |
|||
break; |
|||
case HSM1_NRD: |
|||
here->HSM1_nrd = value->rValue; |
|||
here->HSM1_nrd_Given = TRUE; |
|||
break; |
|||
case HSM1_TEMP: |
|||
here->HSM1_temp = value->rValue; |
|||
here->HSM1_temp_Given = TRUE; |
|||
break; |
|||
case HSM1_DTEMP: |
|||
here->HSM1_dtemp = value->rValue; |
|||
here->HSM1_dtemp_Given = TRUE; |
|||
break; |
|||
case HSM1_OFF: |
|||
here->HSM1_off = value->iValue; |
|||
break; |
|||
case HSM1_IC_VBS: |
|||
here->HSM1_icVBS = value->rValue; |
|||
here->HSM1_icVBS_Given = TRUE; |
|||
break; |
|||
case HSM1_IC_VDS: |
|||
here->HSM1_icVDS = value->rValue; |
|||
here->HSM1_icVDS_Given = TRUE; |
|||
break; |
|||
case HSM1_IC_VGS: |
|||
here->HSM1_icVGS = value->rValue; |
|||
here->HSM1_icVGS_Given = TRUE; |
|||
break; |
|||
case HSM1_IC: |
|||
switch (value->v.numValue) { |
|||
case 3: |
|||
here->HSM1_icVBS = *(value->v.vec.rVec + 2); |
|||
here->HSM1_icVBS_Given = TRUE; |
|||
case 2: |
|||
here->HSM1_icVGS = *(value->v.vec.rVec + 1); |
|||
here->HSM1_icVGS_Given = TRUE; |
|||
case 1: |
|||
here->HSM1_icVDS = *(value->v.vec.rVec); |
|||
here->HSM1_icVDS_Given = TRUE; |
|||
break; |
|||
default: |
|||
return(E_BADPARM); |
|||
} |
|||
break; |
|||
default: |
|||
return(E_BADPARM); |
|||
} |
|||
return(OK); |
|||
} |
|||
@ -0,0 +1,211 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1pzld.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "cktdefs.h" |
|||
#include "complex.h" |
|||
#include "sperror.h" |
|||
#include "hsm1def.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1pzLoad(GENmodel *inModel, CKTcircuit *ckt, SPcomplex *s) |
|||
{ |
|||
HSM1model *model = (HSM1model*)inModel; |
|||
HSM1instance *here; |
|||
double xcggb, xcgdb, xcgsb, xcgbb, xcbgb, xcbdb, xcbsb, xcbbb; |
|||
double xcdgb, xcddb, xcdsb, xcdbb, xcsgb, xcsdb, xcssb, xcsbb; |
|||
double gdpr, gspr, gds, gbd, gbs, capbd, capbs, FwdSum, RevSum, gm, gmbs; |
|||
double cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cddb, cdgb, cdsb; |
|||
double cgso, cgdo, cgbo; |
|||
double gbspsp, gbbdp, gbbsp, gbspg, gbspb; |
|||
double gbspdp, gbdpdp, gbdpg, gbdpb, gbdpsp; |
|||
|
|||
double m; |
|||
|
|||
for ( ;model != NULL ;model = model->HSM1nextModel ) { |
|||
for ( here = model->HSM1instances ;here!= NULL ; |
|||
here = here->HSM1nextInstance ) { |
|||
|
|||
if (here->HSM1owner != ARCHme) |
|||
continue; |
|||
|
|||
if ( here->HSM1_mode >= 0 ) { |
|||
gm = here->HSM1_gm; |
|||
gmbs = here->HSM1_gmbs; |
|||
FwdSum = gm + gmbs; |
|||
RevSum = 0.0; |
|||
|
|||
gbbdp = -here->HSM1_gbds; |
|||
gbbsp = here->HSM1_gbds + here->HSM1_gbgs + here->HSM1_gbbs; |
|||
|
|||
gbdpg = here->HSM1_gbgs; |
|||
gbdpdp = here->HSM1_gbds; |
|||
gbdpb = here->HSM1_gbbs; |
|||
gbdpsp = -(gbdpg + gbdpdp + gbdpb); |
|||
|
|||
gbspg = 0.0; |
|||
gbspdp = 0.0; |
|||
gbspb = 0.0; |
|||
gbspsp = 0.0; |
|||
|
|||
cggb = here->HSM1_cggb; |
|||
cgsb = here->HSM1_cgsb; |
|||
cgdb = here->HSM1_cgdb; |
|||
|
|||
cbgb = here->HSM1_cbgb; |
|||
cbsb = here->HSM1_cbsb; |
|||
cbdb = here->HSM1_cbdb; |
|||
|
|||
cdgb = here->HSM1_cdgb; |
|||
cdsb = here->HSM1_cdsb; |
|||
cddb = here->HSM1_cddb; |
|||
|
|||
} |
|||
else { |
|||
gm = -here->HSM1_gm; |
|||
gmbs = -here->HSM1_gmbs; |
|||
FwdSum = 0.0; |
|||
RevSum = -(gm + gmbs); |
|||
|
|||
gbbsp = -here->HSM1_gbds; |
|||
gbbdp = here->HSM1_gbds + here->HSM1_gbgs + here->HSM1_gbbs; |
|||
|
|||
gbdpg = 0.0; |
|||
gbdpsp = 0.0; |
|||
gbdpb = 0.0; |
|||
gbdpdp = 0.0; |
|||
|
|||
gbspg = here->HSM1_gbgs; |
|||
gbspsp = here->HSM1_gbds; |
|||
gbspb = here->HSM1_gbbs; |
|||
gbspdp = -(gbspg + gbspsp + gbspb); |
|||
|
|||
cggb = here->HSM1_cggb; |
|||
cgsb = here->HSM1_cgdb; |
|||
cgdb = here->HSM1_cgsb; |
|||
|
|||
cbgb = here->HSM1_cbgb; |
|||
cbsb = here->HSM1_cbdb; |
|||
cbdb = here->HSM1_cbsb; |
|||
|
|||
cdgb = -(here->HSM1_cdgb + cggb + cbgb); |
|||
cdsb = -(here->HSM1_cddb + cgsb + cbsb); |
|||
cddb = -(here->HSM1_cdsb + cgdb + cbdb); |
|||
} |
|||
|
|||
gdpr = here->HSM1drainConductance; |
|||
gspr = here->HSM1sourceConductance; |
|||
gds = here->HSM1_gds; |
|||
gbd = here->HSM1_gbd; |
|||
gbs = here->HSM1_gbs; |
|||
capbd = here->HSM1_capbd; |
|||
capbs = here->HSM1_capbs; |
|||
|
|||
cgso = here->HSM1_cgso; |
|||
cgdo = here->HSM1_cgdo; |
|||
cgbo = here->HSM1_cgbo; |
|||
|
|||
m = here->HSM1_m; |
|||
|
|||
xcdgb = (cdgb - cgdo); |
|||
xcddb = (cddb + capbd + cgdo); |
|||
xcdsb = cdsb; |
|||
xcdbb = -(xcdgb + xcddb + xcdsb); |
|||
xcsgb = -(cggb + cbgb + cdgb + cgso); |
|||
xcsdb = -(cgdb + cbdb + cddb); |
|||
xcssb = (capbs + cgso - (cgsb + cbsb + cdsb)); |
|||
xcsbb = -(xcsgb + xcsdb + xcssb); |
|||
xcggb = (cggb + cgdo + cgso + cgbo); |
|||
xcgdb = (cgdb - cgdo); |
|||
xcgsb = (cgsb - cgso); |
|||
xcgbb = -(xcggb + xcgdb + xcgsb); |
|||
xcbgb = (cbgb - cgbo); |
|||
xcbdb = (cbdb - capbd); |
|||
xcbsb = (cbsb - capbs); |
|||
xcbbb = -(xcbgb + xcbdb + xcbsb); |
|||
|
|||
*(here->HSM1GgPtr ) += m * xcggb * s->real; |
|||
*(here->HSM1GgPtr +1) += m * xcggb * s->imag; |
|||
*(here->HSM1BbPtr ) += m * xcbbb * s->real; |
|||
*(here->HSM1BbPtr +1) += m * xcbbb * s->imag; |
|||
*(here->HSM1DPdpPtr ) += m * xcddb * s->real; |
|||
*(here->HSM1DPdpPtr +1) += m * xcddb * s->imag; |
|||
*(here->HSM1SPspPtr ) += m * xcssb * s->real; |
|||
*(here->HSM1SPspPtr +1) += m * xcssb * s->imag; |
|||
|
|||
*(here->HSM1GbPtr ) += m * xcgbb * s->real; |
|||
*(here->HSM1GbPtr +1) += m * xcgbb * s->imag; |
|||
*(here->HSM1GdpPtr ) += m * xcgdb * s->real; |
|||
*(here->HSM1GdpPtr +1) += m * xcgdb * s->imag; |
|||
*(here->HSM1GspPtr ) += m * xcgsb * s->real; |
|||
*(here->HSM1GspPtr +1) += m * xcgsb * s->imag; |
|||
|
|||
*(here->HSM1BgPtr ) += m * xcbgb * s->real; |
|||
*(here->HSM1BgPtr +1) += m * xcbgb * s->imag; |
|||
*(here->HSM1BdpPtr ) += m * xcbdb * s->real; |
|||
*(here->HSM1BdpPtr +1) += m * xcbdb * s->imag; |
|||
*(here->HSM1BspPtr ) += m * xcbsb * s->real; |
|||
*(here->HSM1BspPtr +1) += m * xcbsb * s->imag; |
|||
|
|||
*(here->HSM1DPgPtr ) += m * xcdgb * s->real; |
|||
*(here->HSM1DPgPtr +1) += m * xcdgb * s->imag; |
|||
*(here->HSM1DPbPtr ) += m * xcdbb * s->real; |
|||
*(here->HSM1DPbPtr +1) += m * xcdbb * s->imag; |
|||
*(here->HSM1DPspPtr ) += m * xcdsb * s->real; |
|||
*(here->HSM1DPspPtr +1) += m * xcdsb * s->imag; |
|||
|
|||
*(here->HSM1SPgPtr ) += m * xcsgb * s->real; |
|||
*(here->HSM1SPgPtr +1) += m * xcsgb * s->imag; |
|||
*(here->HSM1SPbPtr ) += m * xcsbb * s->real; |
|||
*(here->HSM1SPbPtr +1) += m * xcsbb * s->imag; |
|||
*(here->HSM1SPdpPtr ) += m * xcsdb * s->real; |
|||
*(here->HSM1SPdpPtr +1) += m * xcsdb * s->imag; |
|||
|
|||
*(here->HSM1DdPtr) += m * gdpr; |
|||
*(here->HSM1DdpPtr) -= m * gdpr; |
|||
*(here->HSM1DPdPtr) -= m * gdpr; |
|||
|
|||
*(here->HSM1SsPtr) += m * gspr; |
|||
*(here->HSM1SspPtr) -= m * gspr; |
|||
*(here->HSM1SPsPtr) -= m * gspr; |
|||
|
|||
*(here->HSM1BgPtr) -= m * here->HSM1_gbgs; |
|||
*(here->HSM1BbPtr) += m * (gbd + gbs - here->HSM1_gbbs); |
|||
*(here->HSM1BdpPtr) -= m * (gbd - gbbdp); |
|||
*(here->HSM1BspPtr) -= m * (gbs - gbbsp); |
|||
|
|||
*(here->HSM1DPgPtr) += m * (gm + gbdpg); |
|||
*(here->HSM1DPdpPtr) += m * (gdpr + gds + gbd + RevSum + gbdpdp); |
|||
*(here->HSM1DPspPtr) -= m * (gds + FwdSum - gbdpsp); |
|||
*(here->HSM1DPbPtr) -= m * (gbd - gmbs - gbdpb); |
|||
|
|||
*(here->HSM1SPgPtr) -= m * (gm - gbspg); |
|||
*(here->HSM1SPspPtr) += m * (gspr + gds + gbs + FwdSum + gbspsp); |
|||
*(here->HSM1SPbPtr) -= m * (gbs + gmbs - gbspb); |
|||
*(here->HSM1SPdpPtr) -= m * (gds + RevSum - gbspdp); |
|||
|
|||
/* |
|||
... may nedeed in the future ... |
|||
*(here->HSM1GgPtr) -= m * xgtg; |
|||
*(here->HSM1GbPtr) -= m * xgtb; |
|||
*(here->HSM1GdpPtr) -= m * xgtd; |
|||
*(here->HSM1GspPtr) -= m * xgts; |
|||
*/ |
|||
|
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
@ -0,0 +1,347 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1set.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "smpdefs.h" |
|||
#include "cktdefs.h" |
|||
#include "hsm1def.h" |
|||
#include "const.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, |
|||
int *states) |
|||
/* load the HSM1 device structure with those pointers needed later |
|||
* for fast matrix loading |
|||
*/ |
|||
{ |
|||
HSM1model *model = (HSM1model*)inModel; |
|||
HSM1instance *here; |
|||
int error; |
|||
CKTnode *tmp; |
|||
|
|||
CKTnode *tmpNode; |
|||
IFuid tmpName; |
|||
|
|||
/* loop through all the HSM1 device models */ |
|||
for ( ;model != NULL ;model = model->HSM1nextModel ) { |
|||
/* Default value Processing for HSM1 MOSFET Models */ |
|||
if ( !model->HSM1_type_Given ) |
|||
model->HSM1_type = NMOS ; |
|||
/***/ |
|||
if ( !model->HSM1_info_Given ) model->HSM1_info = 0 ; |
|||
if ( !model->HSM1_noise_Given) model->HSM1_noise = 5; /* select noise model 5 */ |
|||
if ( !model->HSM1_version_Given) model->HSM1_version = 100; /* default 100 */ |
|||
if ( !model->HSM1_corsrd_Given ) model->HSM1_corsrd = 0 ; |
|||
if ( !model->HSM1_coiprv_Given ) model->HSM1_coiprv = 1 ; |
|||
if ( !model->HSM1_copprv_Given ) model->HSM1_copprv = 1 ; |
|||
if ( !model->HSM1_cocgso_Given ) model->HSM1_cocgso = 0 ; |
|||
if ( !model->HSM1_cocgdo_Given ) model->HSM1_cocgdo = 0 ; |
|||
if ( !model->HSM1_cocgbo_Given ) model->HSM1_cocgbo = 0 ; |
|||
if ( !model->HSM1_coadov_Given ) model->HSM1_coadov = 1 ; |
|||
if ( !model->HSM1_coxx08_Given ) model->HSM1_coxx08 = 0 ; |
|||
if ( !model->HSM1_coxx09_Given ) model->HSM1_coxx09 = 0 ; |
|||
if ( !model->HSM1_coisub_Given ) model->HSM1_coisub = 0 ; |
|||
if ( !model->HSM1_coiigs_Given ) model->HSM1_coiigs = 0 ; |
|||
if ( !model->HSM1_cogidl_Given ) model->HSM1_cogidl = 0 ; |
|||
if ( !model->HSM1_coovlp_Given ) model->HSM1_coovlp = 0 ; |
|||
if ( !model->HSM1_conois_Given ) model->HSM1_conois = 0 ; |
|||
if ( model->HSM1_version == 110 ) {/* HiSIM1.1 */ |
|||
if ( !model->HSM1_coisti_Given ) model->HSM1_coisti = 0 ; |
|||
} |
|||
/***/ |
|||
if ( !model->HSM1_vmax_Given ) model->HSM1_vmax = 1.00e+7 ; |
|||
if ( !model->HSM1_bgtmp1_Given ) model->HSM1_bgtmp1 = 9.03e-5 ; |
|||
if ( !model->HSM1_bgtmp2_Given ) model->HSM1_bgtmp2 = 3.05e-7 ; |
|||
if ( !model->HSM1_tox_Given ) model->HSM1_tox = 3.60e-9 ; |
|||
if ( !model->HSM1_dl_Given ) model->HSM1_dl = 0.0 ; |
|||
if ( !model->HSM1_dw_Given ) model->HSM1_dw = 0.0 ; |
|||
if ( model->HSM1_version == 100 ) { /* HiSIM1.0 */ |
|||
if ( !model->HSM1_xj_Given ) model->HSM1_xj = 0.0 ; |
|||
if ( model->HSM1_xqy_Given ) { |
|||
printf("warning(HiSIM): the model parameter XQY is only available in VERSION = 110.\n"); |
|||
printf(" XQY = %f - ignored\n", model->HSM1_xqy); |
|||
} |
|||
} |
|||
else if ( model->HSM1_version == 110 ) { /* HiSIM1.1 */ |
|||
if ( !model->HSM1_xqy_Given ) model->HSM1_xqy = 0.0; |
|||
if ( model->HSM1_xj_Given ) { |
|||
printf("warning(HiSIM): the model parameter XJ is only available in VERSION = 100.\n"); |
|||
printf(" XJ = %f - ignored\n", model->HSM1_xj); |
|||
} |
|||
} |
|||
if ( !model->HSM1_rs_Given ) model->HSM1_rs = 0.0 ; |
|||
if ( !model->HSM1_rd_Given ) model->HSM1_rd = 0.0 ; |
|||
if ( !model->HSM1_vfbc_Given ) model->HSM1_vfbc = -0.722729 ; |
|||
if ( !model->HSM1_nsubc_Given ) model->HSM1_nsubc = 5.94e+17 ; |
|||
if ( !model->HSM1_parl1_Given ) model->HSM1_parl1 = 1.0 ; |
|||
if ( !model->HSM1_parl2_Given ) model->HSM1_parl2 = 2.20e-8 ; |
|||
if ( !model->HSM1_lp_Given ) model->HSM1_lp = 0.0 ; |
|||
if ( !model->HSM1_nsubp_Given ) model->HSM1_nsubp = 5.94e+17 ; |
|||
if ( !model->HSM1_scp1_Given ) model->HSM1_scp1 = 0.0 ; |
|||
if ( !model->HSM1_scp2_Given ) model->HSM1_scp2 = 0.0 ; |
|||
if ( !model->HSM1_scp3_Given ) model->HSM1_scp3 = 0.0 ; |
|||
if ( !model->HSM1_sc1_Given ) model->HSM1_sc1 = 13.5 ; |
|||
if ( !model->HSM1_sc2_Given ) model->HSM1_sc2 = 1.8 ; |
|||
if ( !model->HSM1_sc3_Given ) model->HSM1_sc3 = 0.0 ; |
|||
if ( !model->HSM1_pgd1_Given ) model->HSM1_pgd1 = 0.0 ; |
|||
if ( !model->HSM1_pgd2_Given ) model->HSM1_pgd2 = 0.0 ; |
|||
if ( !model->HSM1_pgd3_Given ) model->HSM1_pgd3 = 0.0 ; |
|||
if ( !model->HSM1_ndep_Given ) model->HSM1_ndep = 1.0 ; |
|||
if ( !model->HSM1_ninv_Given ) model->HSM1_ninv = 0.5 ; |
|||
if ( !model->HSM1_ninvd_Given ) model->HSM1_ninvd = 0.0 ; |
|||
if ( !model->HSM1_muecb0_Given ) model->HSM1_muecb0 = 300.0 ; |
|||
if ( !model->HSM1_muecb1_Given ) model->HSM1_muecb1 = 30.0 ; |
|||
if ( !model->HSM1_mueph1_Given ) model->HSM1_mueph1 = 1.00e+7 ; |
|||
if ( !model->HSM1_mueph0_Given ) model->HSM1_mueph0 = 0.295 ; |
|||
if ( !model->HSM1_mueph2_Given ) model->HSM1_mueph2 = 0.0 ; |
|||
if ( !model->HSM1_w0_Given ) model->HSM1_w0 = 0.0 ; |
|||
if ( !model->HSM1_muesr1_Given ) model->HSM1_muesr1 = 7.00e+8 ; |
|||
if ( !model->HSM1_muesr0_Given ) model->HSM1_muesr0 = 1.0 ; |
|||
if ( !model->HSM1_muetmp_Given ) model->HSM1_muetmp = 0.0 ; |
|||
/***/ |
|||
if ( !model->HSM1_bb_Given ) { |
|||
if (model->HSM1_type == NMOS) model->HSM1_bb = 2.0 ; |
|||
else model->HSM1_bb = 1.0 ; |
|||
} |
|||
/***/ |
|||
if ( !model->HSM1_vds0_Given ) model->HSM1_vds0 = 0.05 ; |
|||
if ( !model->HSM1_bc0_Given ) model->HSM1_bc0 = 0.0 ; |
|||
if ( !model->HSM1_bc1_Given ) model->HSM1_bc1 = 0.0 ; |
|||
if ( !model->HSM1_sub1_Given ) model->HSM1_sub1 = 0.0 ; |
|||
if ( !model->HSM1_sub2_Given ) model->HSM1_sub2 = -70.0 ; |
|||
if ( !model->HSM1_sub3_Given ) model->HSM1_sub3 = 1.0 ; |
|||
if ( model->HSM1_version == 110) { /* HiSIM1.1 */ |
|||
if ( !model->HSM1_wvthsc_Given ) model->HSM1_wvthsc = 0.0 ; |
|||
if ( !model->HSM1_nsti_Given ) model->HSM1_nsti = 1.0e17 ; |
|||
if ( !model->HSM1_wsti_Given ) model->HSM1_wsti = 0.0 ; |
|||
} |
|||
if ( !model->HSM1_tpoly_Given ) model->HSM1_tpoly = 0.0 ; |
|||
if ( !model->HSM1_js0_Given ) model->HSM1_js0 = 1.0e-4 ; |
|||
if ( !model->HSM1_js0sw_Given ) model->HSM1_js0sw = 0.0 ; |
|||
if ( !model->HSM1_nj_Given ) model->HSM1_nj = 1.0 ; |
|||
if ( !model->HSM1_njsw_Given ) model->HSM1_njsw = 1.0 ; |
|||
if ( !model->HSM1_xti_Given ) model->HSM1_xti = 3.0 ; |
|||
if ( !model->HSM1_cj_Given ) model->HSM1_cj = 8.397247e-04; |
|||
if ( !model->HSM1_cjsw_Given ) model->HSM1_cjsw = 5.0e-10 ; |
|||
if ( !model->HSM1_cjswg_Given ) model->HSM1_cjswg = 5.0e-10 ; |
|||
if ( !model->HSM1_mj_Given ) model->HSM1_mj = 0.5 ; |
|||
if ( !model->HSM1_mjsw_Given ) model->HSM1_mjsw = 0.33 ; |
|||
if ( !model->HSM1_mjswg_Given ) model->HSM1_mjswg = 0.33 ; |
|||
if ( !model->HSM1_pb_Given ) model->HSM1_pb = 1.0 ; |
|||
if ( !model->HSM1_pbsw_Given ) model->HSM1_pbsw = 1.0 ; |
|||
if ( !model->HSM1_pbswg_Given ) model->HSM1_pbswg = 1.0 ; |
|||
if ( !model->HSM1_xpolyd_Given ) model->HSM1_xpolyd = 0.0 ; |
|||
if ( !model->HSM1_clm1_Given ) model->HSM1_clm1 = 0.3e0 ; |
|||
if ( !model->HSM1_clm2_Given ) model->HSM1_clm2 = 0.0 ; |
|||
if ( !model->HSM1_clm3_Given ) model->HSM1_clm3 = 0.0 ; |
|||
if ( !model->HSM1_rpock1_Given ) model->HSM1_rpock1 = 0.0 ; |
|||
if ( !model->HSM1_rpock2_Given ) model->HSM1_rpock2 = 0.0 ; |
|||
if ( model->HSM1_version == 110 ) { /* HiSIM1.1 */ |
|||
if ( !model->HSM1_rpocp1_Given ) model->HSM1_rpocp1 = 0.0 ; |
|||
if ( !model->HSM1_rpocp2_Given ) model->HSM1_rpocp2 = 0.0 ; |
|||
} |
|||
if ( !model->HSM1_vover_Given ) model->HSM1_vover = 0.0 ; |
|||
if ( !model->HSM1_voverp_Given ) model->HSM1_voverp = 0.0 ; |
|||
if ( !model->HSM1_wfc_Given ) model->HSM1_wfc = 0.0 ; |
|||
if ( !model->HSM1_qme1_Given ) model->HSM1_qme1 = 0.0 ; |
|||
if ( !model->HSM1_qme2_Given ) model->HSM1_qme2 = 0.0 ; |
|||
if ( !model->HSM1_qme3_Given ) model->HSM1_qme3 = 0.0 ; |
|||
if ( !model->HSM1_gidl1_Given ) model->HSM1_gidl1 = 0.0 ; |
|||
if ( !model->HSM1_gidl2_Given ) model->HSM1_gidl2 = 0.0 ; |
|||
if ( !model->HSM1_gidl3_Given ) model->HSM1_gidl3 = 0.0 ; |
|||
if ( !model->HSM1_gleak1_Given ) model->HSM1_gleak1 = 0.0 ; |
|||
if ( !model->HSM1_gleak2_Given ) model->HSM1_gleak2 = 0.0 ; |
|||
if ( !model->HSM1_gleak3_Given ) model->HSM1_gleak3 = 0.0 ; |
|||
if ( !model->HSM1_vzadd0_Given ) model->HSM1_vzadd0 = 1.0e-2 ; |
|||
if ( !model->HSM1_pzadd0_Given ) model->HSM1_pzadd0 = 1.0e-3 ; |
|||
if ( !model->HSM1_nftrp_Given ) model->HSM1_nftrp = 100e9 ; |
|||
if ( !model->HSM1_nfalp_Given ) model->HSM1_nfalp = 2.00e-15 ; |
|||
if ( !model->HSM1_cit_Given ) model->HSM1_cit = 0.0 ; |
|||
|
|||
/* for flicker noise the same as BSIM3 */ |
|||
if ( !model->HSM1_ef_Given ) model->HSM1_ef = 0.0; |
|||
if ( !model->HSM1_af_Given ) model->HSM1_af = 1.0; |
|||
if ( !model->HSM1_kf_Given ) model->HSM1_kf = 0.0; |
|||
|
|||
/* loop through all the instances of the model */ |
|||
for ( here = model->HSM1instances ;here != NULL ; |
|||
here = here->HSM1nextInstance ) { |
|||
|
|||
if (here->HSM1owner == ARCHme) |
|||
{ |
|||
/* allocate a chunk of the state vector */ |
|||
here->HSM1states = *states; |
|||
*states += HSM1numStates; |
|||
} |
|||
|
|||
/* perform the parameter defaulting */ |
|||
/* |
|||
if ( !here->HSM1_l_Given ) here->HSM1_l = 1.50e-4 ; |
|||
if ( !here->HSM1_w_Given ) here->HSM1_w = 5.55e-4 ; |
|||
*/ |
|||
if ( !here->HSM1_l_Given ) here->HSM1_l = 5.0e-6 ; |
|||
if ( !here->HSM1_w_Given ) here->HSM1_w = 5.0e-6 ; |
|||
if ( !here->HSM1_m_Given ) here->HSM1_m = 1; |
|||
if ( !here->HSM1_ad_Given ) here->HSM1_ad = 0.0 ; |
|||
if ( !here->HSM1_as_Given ) here->HSM1_as = 0.0 ; |
|||
if ( !here->HSM1_pd_Given ) here->HSM1_pd = 0.0 ; |
|||
if ( !here->HSM1_ps_Given ) here->HSM1_ps = 0.0 ; |
|||
if ( !here->HSM1_nrd_Given ) here->HSM1_nrd = 0.0 ; |
|||
if ( !here->HSM1_nrs_Given ) here->HSM1_nrs = 0.0 ; |
|||
if ( !here->HSM1_temp_Given ) here->HSM1_temp = 300.15 ; |
|||
if ( !here->HSM1_dtemp_Given ) here->HSM1_dtemp = 0.0 ; |
|||
|
|||
if ( !here->HSM1_icVBS_Given ) here->HSM1_icVBS = 0.0; |
|||
if ( !here->HSM1_icVDS_Given ) here->HSM1_icVDS = 0.0; |
|||
if ( !here->HSM1_icVGS_Given ) here->HSM1_icVGS = 0.0; |
|||
|
|||
/* added by K.M. */ |
|||
here->HSM1_weff = here->HSM1_w - 2.0e0 * model->HSM1_dw; |
|||
here->HSM1_leff = here->HSM1_l - 2.0e0 * model->HSM1_dl; |
|||
|
|||
/* process source/drain series resistance added by K.M. */ |
|||
/* Drain and source conductances are always zero, |
|||
because there is no sheet resistance in HSM1 model param. |
|||
if ( model->HSM1_corsrd ) |
|||
here->HSM1drainConductance = 0.0; |
|||
else |
|||
here->HSM1drainConductance = model->HSM1_rs / here->HSM1_weff; |
|||
|
|||
if ( here->HSM1drainConductance > 0.0 ) |
|||
here->HSM1drainConductance = 1.0 / here->HSM1drainConductance; |
|||
else |
|||
here->HSM1drainConductance = 0.0; |
|||
|
|||
if ( model->HSM1_corsrd ) |
|||
here->HSM1sourceConductance = 0.0; |
|||
else |
|||
here->HSM1sourceConductance = model->HSM1_rd / here->HSM1_weff; |
|||
|
|||
if ( here->HSM1sourceConductance > 0.0 ) |
|||
here->HSM1sourceConductance = 1.0 / here->HSM1sourceConductance; |
|||
else |
|||
here->HSM1sourceConductance = 0.0; |
|||
*/ |
|||
here->HSM1drainConductance = 0.0; |
|||
here->HSM1sourceConductance = 0.0; |
|||
|
|||
/* process drain series resistance */ |
|||
if( here->HSM1drainConductance > 0.0 && here->HSM1dNodePrime == 0 ) { |
|||
error = CKTmkVolt(ckt, &tmp, here->HSM1name, "drain"); |
|||
if (error) return(error); |
|||
here->HSM1dNodePrime = tmp->number; |
|||
|
|||
if (ckt->CKTcopyNodesets) { |
|||
if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) { |
|||
if (tmpNode->nsGiven) { |
|||
tmp->nodeset=tmpNode->nodeset; |
|||
tmp->nsGiven=tmpNode->nsGiven; |
|||
} |
|||
} |
|||
} |
|||
|
|||
} |
|||
else { |
|||
here->HSM1dNodePrime = here->HSM1dNode; |
|||
} |
|||
|
|||
/* process source series resistance */ |
|||
if( here->HSM1sourceConductance > 0.0 && here->HSM1sNodePrime == 0 ) { |
|||
if ( here->HSM1sNodePrime == 0 ) { |
|||
error = CKTmkVolt(ckt, &tmp, here->HSM1name, "source"); |
|||
if (error) return(error); |
|||
here->HSM1sNodePrime = tmp->number; |
|||
|
|||
if (ckt->CKTcopyNodesets) { |
|||
if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) { |
|||
if (tmpNode->nsGiven) { |
|||
tmp->nodeset=tmpNode->nodeset; |
|||
tmp->nsGiven=tmpNode->nsGiven; |
|||
} |
|||
} |
|||
} |
|||
|
|||
} |
|||
} |
|||
else { |
|||
here->HSM1sNodePrime = here->HSM1sNode; |
|||
} |
|||
|
|||
/* 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(HSM1DdPtr, HSM1dNode, HSM1dNode) |
|||
TSTALLOC(HSM1GgPtr, HSM1gNode, HSM1gNode) |
|||
TSTALLOC(HSM1SsPtr, HSM1sNode, HSM1sNode) |
|||
TSTALLOC(HSM1BbPtr, HSM1bNode, HSM1bNode) |
|||
TSTALLOC(HSM1DPdpPtr, HSM1dNodePrime, HSM1dNodePrime) |
|||
TSTALLOC(HSM1SPspPtr, HSM1sNodePrime, HSM1sNodePrime) |
|||
TSTALLOC(HSM1DdpPtr, HSM1dNode, HSM1dNodePrime) |
|||
TSTALLOC(HSM1GbPtr, HSM1gNode, HSM1bNode) |
|||
TSTALLOC(HSM1GdpPtr, HSM1gNode, HSM1dNodePrime) |
|||
TSTALLOC(HSM1GspPtr, HSM1gNode, HSM1sNodePrime) |
|||
TSTALLOC(HSM1SspPtr, HSM1sNode, HSM1sNodePrime) |
|||
TSTALLOC(HSM1BdpPtr, HSM1bNode, HSM1dNodePrime) |
|||
TSTALLOC(HSM1BspPtr, HSM1bNode, HSM1sNodePrime) |
|||
TSTALLOC(HSM1DPspPtr, HSM1dNodePrime, HSM1sNodePrime) |
|||
TSTALLOC(HSM1DPdPtr, HSM1dNodePrime, HSM1dNode) |
|||
TSTALLOC(HSM1BgPtr, HSM1bNode, HSM1gNode) |
|||
TSTALLOC(HSM1DPgPtr, HSM1dNodePrime, HSM1gNode) |
|||
TSTALLOC(HSM1SPgPtr, HSM1sNodePrime, HSM1gNode) |
|||
TSTALLOC(HSM1SPsPtr, HSM1sNodePrime, HSM1sNode) |
|||
TSTALLOC(HSM1DPbPtr, HSM1dNodePrime, HSM1bNode) |
|||
TSTALLOC(HSM1SPbPtr, HSM1sNodePrime, HSM1bNode) |
|||
TSTALLOC(HSM1SPdpPtr, HSM1sNodePrime, HSM1dNodePrime) |
|||
|
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
|
|||
int |
|||
HSM1unsetup (GENmodel *inModel, CKTcircuit *ckt) |
|||
{ |
|||
HSM1model *model; |
|||
HSM1instance *here; |
|||
|
|||
for (model = (HSM1model *) inModel; model != NULL; |
|||
model = model->HSM1nextModel) |
|||
{ |
|||
for (here = model->HSM1instances; here != NULL; |
|||
here = here->HSM1nextInstance) |
|||
{ |
|||
if (here->HSM1dNodePrime |
|||
&& here->HSM1dNodePrime != here->HSM1dNode) |
|||
{ |
|||
CKTdltNNum (ckt, here->HSM1dNodePrime); |
|||
here->HSM1dNodePrime = 0; |
|||
} |
|||
if (here->HSM1sNodePrime |
|||
&& here->HSM1sNodePrime != here->HSM1sNode) |
|||
{ |
|||
CKTdltNNum (ckt, here->HSM1sNodePrime); |
|||
here->HSM1sNodePrime = 0; |
|||
} |
|||
} |
|||
} |
|||
return OK; |
|||
} |
|||
@ -0,0 +1,35 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1temp.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "smpdefs.h" |
|||
#include "cktdefs.h" |
|||
#include "hsm1def.h" |
|||
#include "const.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1temp(GENmodel *inModel, CKTcircuit *ckt) |
|||
{ |
|||
/* "ckt->CKTtemp" dependence of HiSIM parameters is treated all in |
|||
* HSM1evaluate1_0/1_1(). So there is no task in HSM1temp(). |
|||
*/ |
|||
|
|||
/* |
|||
if (here->HSM1owner != ARCHme) |
|||
continue; |
|||
*/ |
|||
return(OK); |
|||
} |
|||
@ -0,0 +1,53 @@ |
|||
/*********************************************************************** |
|||
HiSIM v1.1.0 |
|||
File: hsm1trunc.c of HiSIM v1.1.0 |
|||
|
|||
Copyright (C) 2002 STARC |
|||
|
|||
June 30, 2002: developed by Hiroshima University and STARC |
|||
June 30, 2002: posted by Keiichi MORIKAWA, STARC Physical Design Group |
|||
***********************************************************************/ |
|||
|
|||
/* |
|||
* Modified by Paolo Nenzi 2002 |
|||
* ngspice integration |
|||
*/ |
|||
|
|||
#include "ngspice.h" |
|||
#include "cktdefs.h" |
|||
#include "hsm1def.h" |
|||
#include "sperror.h" |
|||
#include "suffix.h" |
|||
|
|||
int HSM1trunc(GENmodel *inModel, CKTcircuit *ckt, double *timeStep) |
|||
{ |
|||
HSM1model *model = (HSM1model*)inModel; |
|||
HSM1instance *here; |
|||
#ifdef STEPDEBUG |
|||
double debugtemp; |
|||
#endif /* STEPDEBUG */ |
|||
|
|||
for ( ;model != NULL ;model = model->HSM1nextModel ) { |
|||
for ( here=model->HSM1instances ;here!=NULL ; |
|||
here = here->HSM1nextInstance ) { |
|||
|
|||
if (here->HSM1owner != ARCHme) |
|||
continue; |
|||
|
|||
#ifdef STEPDEBUG |
|||
debugtemp = *timeStep; |
|||
#endif /* STEPDEBUG */ |
|||
CKTterr(here->HSM1qb,ckt,timeStep); |
|||
CKTterr(here->HSM1qg,ckt,timeStep); |
|||
CKTterr(here->HSM1qd,ckt,timeStep); |
|||
#ifdef STEPDEBUG |
|||
if ( debugtemp != *timeStep ) |
|||
printf("device %s reduces step from %g to %g\n", |
|||
here->HSM1name, debugtemp, *timeStep); |
|||
#endif /* STEPDEBUG */ |
|||
} |
|||
} |
|||
return(OK); |
|||
} |
|||
|
|||
|
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue