1 /***********************************************************************
2
3 HiSIM (Hiroshima University STARC IGFET Model)
4 Copyright (C) 2012 Hiroshima University & STARC
5
6 MODEL NAME : HiSIM_HV
7 ( VERSION : 1 SUBVERSION : 2 REVISION : 4 )
8 Model Parameter VERSION : 1.23
9 FILE : hsmhvld.c
10
11 DATE : 2013.04.30
12
13 released by
14 Hiroshima University &
15 Semiconductor Technology Academic Research Center (STARC)
16 ***********************************************************************/
17
18 #include "ngspice/ngspice.h"
19 #include "hisimhv.h"
20 #include "ngspice/trandefs.h"
21 #include "ngspice/const.h"
22 #include "ngspice/sperror.h"
23 #include "ngspice/devdefs.h"
24 #include "ngspice/suffix.h"
25
26 #define SHOW_EPS_QUANT 1.0e-15
27
ShowPhysVals(HSMHVinstance * here,HSMHVmodel * model,int isFirst,double vds,double vgs,double vbs,double vgd,double vbd,double vgb)28 static void ShowPhysVals
29 (
30 HSMHVinstance *here,
31 HSMHVmodel *model,
32 int isFirst,
33 double vds,
34 double vgs,
35 double vbs,
36 double vgd,
37 double vbd,
38 double vgb
39 )
40 {
41
42 NG_IGNORE(vgd);
43 NG_IGNORE(vbd);
44
45 /* */
46 /* */
47 /* Note: This function is not yet adapted to the flat version */
48 /* */
49 /* */
50
51 /* regard the epsilon-quantity as 0.0 */
52 vds = (fabs(vds) < SHOW_EPS_QUANT) ? 0.0 : vds;
53 vgs = (fabs(vgs) < SHOW_EPS_QUANT) ? 0.0 : vgs;
54 vbs = (fabs(vbs) < SHOW_EPS_QUANT) ? 0.0 : vbs;
55 vgb = (fabs(vgb) < SHOW_EPS_QUANT) ? 0.0 : vgb;
56 switch (model->HSMHV_show) {
57 case 1:
58 if (isFirst) printf("Vds Ids\n");
59 printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_mode*here->HSMHV_ids);
60 break;
61 case 2:
62 if (isFirst) printf("Vgs Ids\n");
63 printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_mode*here->HSMHV_ids);
64 break;
65 case 3:
66 if (isFirst) printf("Vgs log10(|Ids|)\n");
67 printf("%e %e\n", model->HSMHV_type*vgs, log10(here->HSMHV_ids));
68 break;
69 case 4:
70 if (isFirst) printf("log10(|Ids|) gm/|Ids|\n");
71 if (here->HSMHV_ids == 0.0)
72 printf("I can't show gm/Ids - log10(Ids), because Ids = 0.\n");
73 else
74 printf("%e %e\n", log10(here->HSMHV_ids), here->HSMHV_gm/here->HSMHV_ids);
75 break;
76 case 5:
77 if (isFirst) printf("Vds gds\n");
78 printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_gds);
79 break;
80 case 6:
81 if (isFirst) printf("Vgs gm\n");
82 printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_gm);
83 break;
84 case 7:
85 if (isFirst) printf("Vbs gbs\n");
86 printf("%e %e\n", model->HSMHV_type*vbs, here->HSMHV_gmbs);
87 break;
88 case 8:
89 if (isFirst) printf("Vgs Cgg\n");
90 printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_cggb);
91 break;
92 case 9:
93 if (isFirst) printf("Vgs Cgs\n");
94 printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_cgsb);
95 break;
96 case 10:
97 if (isFirst) printf("Vgs Cgd\n");
98 printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_cgdb);
99 break;
100 case 11:
101 if (isFirst) printf("Vgs Cgb\n");
102 printf("%e %e\n", model->HSMHV_type*vgs, -(here->HSMHV_cggb+here->HSMHV_cgsb+here->HSMHV_cgdb));
103 break;
104 case 12:
105 if (isFirst) printf("Vds Csg\n");
106 printf("%e %e\n", model->HSMHV_type*vds, -(here->HSMHV_cggb+here->HSMHV_cbgb+here->HSMHV_cdgb));
107 break;
108 case 13:
109 if (isFirst) printf("Vds Cdg\n");
110 printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_cdgb);
111 break;
112 case 14:
113 if (isFirst) printf("Vds Cbg\n");
114 printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_cbgb);
115 break;
116 case 15:
117 if (isFirst) printf("Vds Cgg\n");
118 printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_cggb);
119 break;
120 case 16:
121 if (isFirst) printf("Vds Cgs\n");
122 printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_cgsb);
123 break;
124 case 17:
125 if (isFirst) printf("Vds Cgd\n");
126 printf("%e %e\n", model->HSMHV_type*vds, here->HSMHV_cgdb);
127 break;
128 case 18:
129 if (isFirst) printf("Vds Cgb\n");
130 printf("%e %e\n", model->HSMHV_type*vds, -(here->HSMHV_cggb+here->HSMHV_cgsb+here->HSMHV_cgdb));
131 break;
132 case 19:
133 if (isFirst) printf("Vgs Csg\n");
134 printf("%e %e\n", model->HSMHV_type*vgs, -(here->HSMHV_cggb+here->HSMHV_cbgb+here->HSMHV_cdgb));
135 break;
136 case 20:
137 if (isFirst) printf("Vgs Cdg\n");
138 printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_cdgb);
139 break;
140 case 21:
141 if (isFirst) printf("Vgs Cbg\n");
142 printf("%e %e\n", model->HSMHV_type*vgs, here->HSMHV_cbgb);
143 break;
144 case 22:
145 if (isFirst) printf("Vgb Cgb\n");
146 printf("%e %e\n", model->HSMHV_type*vgb, -(here->HSMHV_cggb+here->HSMHV_cgsb+here->HSMHV_cgdb));
147 break;
148 case 50:
149 if (isFirst) printf("Vgs Vds Vbs Vgb Ids log10(|Ids|) gm/|Ids| gm gds gbs Cgg Cgs Cgb Cgd Csg Cbg Cdg\n");
150 printf("%e %e %e %e %e %e %e %e %e %e %e %e %e %e %e %e %e\n",
151 model->HSMHV_type*vgs, model->HSMHV_type*vds, model->HSMHV_type*vbs, model->HSMHV_type*vgb, here->HSMHV_mode*here->HSMHV_ids,
152 log10(here->HSMHV_ids), here->HSMHV_gm/here->HSMHV_ids, here->HSMHV_gm, here->HSMHV_gds, here->HSMHV_gmbs, here->HSMHV_cggb,
153 here->HSMHV_cgsb, -(here->HSMHV_cggb+here->HSMHV_cgsb+here->HSMHV_cgdb), here->HSMHV_cgdb,
154 -(here->HSMHV_cggb+here->HSMHV_cbgb+here->HSMHV_cdgb), here->HSMHV_cbgb, here->HSMHV_cdgb);
155 break;
156 default:
157 /*
158 printf("There is no physical value corrsponding to %d\n", flag);
159 */
160 break;
161 }
162 }
163
HSMHVload(GENmodel * inModel,register CKTcircuit * ckt)164 int HSMHVload(
165 GENmodel *inModel,
166 register CKTcircuit *ckt)
167 /* actually load the current value into the
168 * sparse matrix previously provided
169 */
170 {
171 register HSMHVmodel *model = (HSMHVmodel*)inModel;
172 register HSMHVinstance *here;
173 HSMHVbinningParam *pParam;
174 /* HSMHVmodelMKSParam *modelMKS ;*/
175 /* HSMHVhereMKSParam *hereMKS ;*/
176
177
178
179 /* node voltages */
180 #define XDIM 14
181 double x[XDIM] ;
182
183 /* branch voltages */
184 double vbd=0.0, vbs=0.0, vds=0.0, vgb=0.0, vgd=0.0, vgdo=0.0, vgs=0.0 ;
185 double vdbs=0.0, vsbs=0.0, vdbd=0.0 ;
186 double vges=0.0, vged=0.0, vgedo=0.0 ;
187 double vbs_jct=0.0, vbd_jct=0.0;
188 double deltemp = 0.0 , deltemp_old = 0.0 ;
189 double vggp=0, vddp=0, vssp=0, vbpb=0, vbpsb=0, vbpdb=0 ;
190 double vdse=0.0, vgse=0.0, vbse=0.0 ;
191 double vsubs=0.0 ; /* substrate bias */
192
193 double ivds=0.0, ivgs=0.0, ivbs=0.0 ;
194 double ivgse=0.0, ivdse=0.0, ivbse=0.0 ;
195
196 /* delta of branch voltages */
197 double delvbs=0.0, delvds=0.0, delvgs=0.0, delvsbs=0.0, delvdbd=0.0, deldeltemp = 0.0 ;
198 double delvdse=0.0, delvgse=0.0, delvbse=0.0, delvddp=0.0, delvssp=0.0, delvggp=0.0, delvbpb=0.0, delvbpdb=0.0, delvbpsb =0.0 ;
199 double delvsubs=0.0; /* substrate bias change */
200
201 /* branch currents */
202 double Ids=0.0, gds=0.0, gm=0.0, gmbs=0.0, gmT=0.0,
203 gds_ext=0.0, gm_ext=0.0, gmbs_ext=0.0 ;
204 double Igd=0.0, dIgd_dVd=0.0, dIgd_dVg=0.0, dIgd_dVb=0.0, dIgd_dVs=0.0, dIgd_dT=0.0 ;
205 double Igs=0.0, dIgs_dVd=0.0, dIgs_dVg=0.0, dIgs_dVb=0.0, dIgs_dVs=0.0, dIgs_dT=0.0 ;
206 double Igb=0.0, dIgb_dVd=0.0, dIgb_dVg=0.0, dIgb_dVb=0.0, dIgb_dVs=0.0, dIgb_dT=0.0 ;
207 double Isub=0.0, dIsub_dVds=0.0, dIsub_dVgs=0.0, dIsub_dVbs=0.0, dIsub_dT=0.0 ;
208 double Isubs=0.0, dIsubs_dVds=0.0, dIsubs_dVgs=0.0, dIsubs_dVbs=0.0, dIsubs_dT=0.0 ;
209 double dIsub_dVdse=0.0, dIsubs_dVdse=0.0 ;
210 double Igidl=0.0, dIgidl_dVds=0.0, dIgidl_dVgs=0.0, dIgidl_dVbs=0.0, dIgidl_dT=0.0 ;
211 double Igisl=0.0, dIgisl_dVds=0.0, dIgisl_dVgs=0.0, dIgisl_dVbs=0.0, dIgisl_dT=0.0 ;
212 double Ibd=0.0, Gbd=0.0, Gbdt=0.0 ;
213 double Ibs=0.0, Gbs=0.0, Gbst=0.0 ;
214 double Iddp=0.0, dIddp_dVddp=0.0, dIddp_dVdse=0.0, dIddp_dVgse=0.0, dIddp_dVbse=0.0, dIddp_dVsubs=0.0, dIddp_dT =0.0 ;
215 double Issp=0.0, dIssp_dVssp=0.0, dIssp_dVdse=0.0, dIssp_dVgse=0.0, dIssp_dVbse=0.0, dIssp_dVsubs=0.0, dIssp_dT =0.0 ;
216 double Iggp=0.0, dIggp_dVggp =0.0 ;
217 double Ibpb=0.0, dIbpb_dVbpb =0.0 ;
218 double Ibpdb=0.0, dIbpdb_dVbpdb =0.0 ;
219 double Ibpsb=0.0, dIbpsb_dVbpsb =0.0 ;
220 double Ith=0.0, dIth_dT =0.0 ;
221
222 /* displacement currents */
223 double cq_d=0.0, cq_dP=0.0, cq_g=0.0, cq_gP=0.0, cq_s=0.0, cq_sP=0.0, cq_bP=0.0, cq_b=0.0, cq_db=0.0, cq_sb=0.0, cq_t=0.0 ;
224 double cq_dE=0.0, cq_gE=0.0, cq_sE=0.0, cq_bE=0.0 ;
225
226 /* node currents */
227 double cur_d=0.0, cur_dP=0.0, cur_g=0.0, cur_gP=0.0, cur_s=0.0, cur_sP=0.0, cur_bP=0.0, cur_b=0.0, cur_db=0.0, cur_sb=0.0, cur_t=0.0 ;
228 double i_d=0.0, i_dP=0.0, i_g=0.0, i_gP=0.0, i_s=0.0, i_sP=0.0, i_bP=0.0, i_b=0.0, i_db=0.0, i_sb=0.0, i_t=0.0 ;
229
230 /* resistances and conductances */
231 double Rd=0.0, dRd_dVdse=0.0, dRd_dVgse=0.0, dRd_dVbse=0.0, dRd_dVsubs=0.0, dRd_dT=0.0 ;
232 double Rs=0.0, dRs_dVdse=0.0, dRs_dVgse=0.0, dRs_dVbse=0.0, dRs_dVsubs=0.0, dRs_dT=0.0 ;
233
234 double GD=0.0, GD_dVds=0.0, GD_dVgs=0.0, GD_dVbs=0.0, GD_dVsubs=0.0, GD_dT=0.0 ;
235 double GS=0.0, GS_dVds=0.0, GS_dVgs=0.0, GS_dVbs=0.0, GS_dVsubs=0.0, GS_dT=0.0 ;
236 double Gth=0.0 ;
237 double GG=0.0, GRBPD=0.0, GRBPS=0.0, GRBPB=0.0;
238
239 /* charges */
240 double Qd=0.0, dQd_dVds=0.0, dQd_dVgs=0.0, dQd_dVbs=0.0, dQd_dT=0.0 ;
241 double Qg=0.0, dQg_dVds=0.0, dQg_dVgs=0.0, dQg_dVbs=0.0, dQg_dT=0.0 ;
242 double Qs=0.0, dQs_dVds=0.0, dQs_dVgs=0.0, dQs_dVbs=0.0, dQs_dT=0.0 ;
243 double Qb=0.0, dQb_dVds=0.0, dQb_dVgs=0.0, dQb_dVbs=0.0, dQb_dT=0.0 ;
244 double Qbd=0.0, Cbd=0.0, Cbdt=0.0,
245 Qbs=0.0, Cbs=0.0, Cbst=0.0 ;
246 double Qth=0.0, Cth =0.0 ;
247 double Qfd=0.0, dQfd_dVdse=0.0, dQfd_dVgse=0.0, dQfd_dVbse=0.0, dQfd_dT=0.0 ;
248 double Qfs=0.0, dQfs_dVdse=0.0, dQfs_dVgse=0.0, dQfs_dVbse=0.0, dQfs_dT=0.0 ;
249
250 double Qdext=0.0, dQdext_dVdse=0.0, dQdext_dVgse=0.0, dQdext_dVbse=0.0, dQdext_dT=0.0 ;
251 double Qgext=0.0, dQgext_dVdse=0.0, dQgext_dVgse=0.0, dQgext_dVbse=0.0, dQgext_dT=0.0 ;
252 double /*Qsext=0.0,*/ dQsext_dVdse=0.0, dQsext_dVgse=0.0, dQsext_dVbse=0.0, dQsext_dT=0.0 ;
253 double Qbext=0.0, dQbext_dVdse=0.0, dQbext_dVgse=0.0, dQbext_dVbse=0.0, dQbext_dT=0.0 ;
254 /* 5th substrate node */
255 int flg_subNode = 0 ;
256
257 /* self heating */
258 double Veffpower=0.0, dVeffpower_dVds=0.0, dVeffpower_dVdse =0.0 ;
259 double P=0.0, dP_dVds=0.0, dP_dVgs=0.0, dP_dVbs=0.0, dP_dT =0.0,
260 dP_dVdse=0.0, dP_dVgse=0.0, dP_dVbse =0.0 ;
261 int flg_tempNode = 0 ;
262 double T0 , T1 , T2 ;
263
264 #define SHE_MAX_dlt 0.1
265
266 #define C_RTH_MIN 1.0e-4
267
268 double TMF1 , TMF2 ;
269 /*---------------------------------------------------*
270 * smoothUpper: ceiling.
271 * y = xmax - 0.5 ( arg + sqrt( arg^2 + 4 xmax delta ) )
272 * arg = xmax - x - delta
273 *-----------------*/
274
275 #define Fn_SU( y , x , xmax , delta , dx ) { \
276 TMF1 = ( xmax ) - ( x ) - ( delta ) ; \
277 TMF2 = 4.0 * ( xmax ) * ( delta) ; \
278 TMF2 = TMF2 > 0.0 ? TMF2 : -( TMF2 ) ; \
279 TMF2 = sqrt ( TMF1 * TMF1 + TMF2 ) ; \
280 dx = 0.5 * ( 1.0 + TMF1 / TMF2 ) ; \
281 y = ( xmax ) - 0.5 * ( TMF1 + TMF2 ) ; \
282 }
283
284 /* NQS related variables */
285 int flg_nqs =0 ;
286 double Qi_nqs=0.0, Qb_nqs=0.0, delQi_nqs=0.0, delQb_nqs=0.0, i_qi=0.0, i_qb=0.0, cq_qi=0.0, cq_qb=0.0, cur_qi=0.0, cur_qb =0.0 ;
287 double Iqi_nqs=0.0, dIqi_nqs_dVds=0.0, dIqi_nqs_dVgs=0.0, dIqi_nqs_dVbs=0.0, dIqi_nqs_dT=0.0, dIqi_nqs_dQi_nqs =0.0 ;
288 double Iqb_nqs=0.0, dIqb_nqs_dVds=0.0, dIqb_nqs_dVgs=0.0, dIqb_nqs_dVbs=0.0, dIqb_nqs_dT=0.0, dIqb_nqs_dQb_nqs =0.0 ;
289 double Qd_nqs=0.0, dQd_nqs_dVds=0.0, dQd_nqs_dVgs=0.0, dQd_nqs_dVbs=0.0, dQd_nqs_dT=0.0, dQd_nqs_dQi_nqs =0.0 ;
290 double Qs_nqs=0.0, dQs_nqs_dVds=0.0, dQs_nqs_dVgs=0.0, dQs_nqs_dVbs=0.0, dQs_nqs_dT=0.0, dQs_nqs_dQi_nqs =0.0 ;
291 double Qg_nqs=0.0, dQg_nqs_dQi_nqs=0.0, dQg_nqs_dQb_nqs =0.0 ;
292 double tau=0.0, dtau_dVds=0.0, dtau_dVgs=0.0, dtau_dVbs=0.0, dtau_dT =0.0 ;
293 double taub=0.0, dtaub_dVds=0.0, dtaub_dVgs=0.0, dtaub_dVbs=0.0, dtaub_dT =0.0 ;
294 double Qdrat=0.0, dQdrat_dVds=0.0, dQdrat_dVgs=0.0, dQdrat_dVbs=0.0, dQdrat_dT =0.0 ;
295 double Qi=0.0, dQi_dVds=0.0, dQi_dVgs=0.0, dQi_dVbs=0.0, dQi_dT =0.0 ;
296 double Qbulk=0.0, dQbulk_dVds=0.0, dQbulk_dVgs=0.0, dQbulk_dVbs=0.0, dQbulk_dT =0.0 ;
297
298 /* output related variables */
299 double dQi_nqs_dVds=0.0, dQi_nqs_dVgs=0.0, dQi_nqs_dVbs=0.0,
300 dQb_nqs_dVds=0.0, dQb_nqs_dVgs=0.0, dQb_nqs_dVbs=0.0 ;
301 double cgdb_nqs=0.0, cggb_nqs=0.0, cgsb_nqs=0.0,
302 cbdb_nqs=0.0, cbgb_nqs=0.0, cbsb_nqs=0.0,
303 cddb_nqs=0.0, cdgb_nqs=0.0, cdsb_nqs=0.0 ;
304 double cgdb=0.0, cggb=0.0, cgsb=0.0,
305 cbdb=0.0, cbgb=0.0, cbsb=0.0,
306 cddb=0.0, cdgb=0.0, cdsb=0.0 ;
307
308 /* rows of conductance and capacitance matrix stamp */
309 double ydc_d[XDIM], ydc_dP[XDIM], ydc_g[XDIM], ydc_gP[XDIM], ydc_s[XDIM], ydc_sP[XDIM] ;
310 double ydc_bP[XDIM], ydc_b[XDIM], ydc_db[XDIM], ydc_sb[XDIM], ydc_t[XDIM], ydc_qi[XDIM], ydc_qb[XDIM] ;
311 double ydyn_d[XDIM], ydyn_dP[XDIM], ydyn_g[XDIM], ydyn_gP[XDIM], ydyn_s[XDIM], ydyn_sP[XDIM] ;
312 double ydyn_bP[XDIM], ydyn_b[XDIM], ydyn_db[XDIM], ydyn_sb[XDIM], ydyn_t[XDIM], ydyn_qi[XDIM], ydyn_qb[XDIM] ;
313
314 /* limiter, bypass, and convergence */
315 int ByPass=0, Check=0, Check1=0, Check2=0, Check3=0 ;
316 double von=0.0, limval =0.0 ;
317 double i_dP_hat=0.0, i_gP_hat=0.0, i_sP_hat=0.0, i_db_hat=0.0, i_sb_hat =0.0 ;
318
319 #define LIM_TOL 1.0e0
320 #define LIM_TOL2 1.0e0
321
322 /* predictor and numerical integration stuff */
323 double ag0=0.0, xfact=0.0 ;
324 double ceq=0.0, geq=0.0 ;
325 int ChargeComputationNeeded =
326 ((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) ||
327 ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)))
328 ? 1 : 0;
329 int showPhysVal=0 ;
330 int isConv=0 ;
331 double vds_pre=0.0 ;
332 int i=0, noncon_old=0 ;
333
334
335
336 #define dNode 0
337 #define dNodePrime 1
338 #define gNode 2
339 #define gNodePrime 3
340 #define sNode 4
341 #define sNodePrime 5
342 #define bNodePrime 6
343 #define bNode 7
344 #define dbNode 8
345 #define sbNode 9
346 #define subNode 10
347 #define tempNode 11
348 #define qiNode 12
349 #define qbNode 13
350 #define lastNode 13 /* must be the last node! */
351
352
353 #define SPICE_rhs 1 /* set to 0 if rhs to be loaded for standard Newton */
354 /* set to 1 if rhs_eq to be loaded, e.g. for SPICE */
355
356 if (SPICE_rhs) {
357 for (i=0; i<XDIM; i++) {
358 x[i] = 0.0 ;
359 }
360 }
361
362 /* loop through all the HSMHV device models */
363 for ( ; model != NULL; model = HSMHVnextModel(model)) {
364 /* loop through all the instances of the model */
365
366 /* modelMKS = &model->modelMKS ;*/
367
368 for (here = HSMHVinstances(model); here != NULL ;
369 here = HSMHVnextInstance(here)) {
370
371 /* hereMKS = &here->hereMKS ;*/
372 pParam = &here->pParam ;
373 showPhysVal = 0;
374 Check=1;
375 ByPass = 0;
376 vsubs = 0.0 ; /* substrate bias */
377 deltemp = 0.0 ;
378 noncon_old = ckt->CKTnoncon;
379 flg_nqs = model->HSMHV_conqs ;
380 flg_subNode = here->HSMHVsubNode ; /* if flg_subNode > 0, external(/internal) substrate node exists */
381 flg_tempNode = here->HSMHVtempNode ; /* if flg_tempNode > 0, external/internal temperature node exists */
382
383 #ifdef DEBUG_HISIMHVLD_VX
384 printf("mode = %x\n", ckt->CKTmode);
385 printf("Vd Vg Vs Vb %e %e %e %e\n", *(ckt->CKTrhsOld+here->HSMHVdNodePrime),
386 *(ckt->CKTrhsOld+here->HSMHVgNodePrime),
387 *(ckt->CKTrhsOld+here->HSMHVsNodePrime),
388 *(ckt->CKTrhsOld+here->HSMHVbNodePrime));
389 #endif
390
391 if ( ckt->CKTmode & MODEINITSMSIG ) {
392 vbs = *(ckt->CKTstate0 + here->HSMHVvbs);
393 vgs = *(ckt->CKTstate0 + here->HSMHVvgs);
394 vds = *(ckt->CKTstate0 + here->HSMHVvds);
395
396 vges = *(ckt->CKTstate0 + here->HSMHVvges);
397 vdbd = *(ckt->CKTstate0 + here->HSMHVvdbd);
398 vsbs = *(ckt->CKTstate0 + here->HSMHVvsbs);
399 if (flg_subNode > 0) vsubs = *(ckt->CKTstate0 + here->HSMHVvsubs);
400 if( flg_tempNode > 0 ){
401 deltemp = *(ckt->CKTstate0 + here->HSMHVdeltemp);
402 }
403 vdse = *(ckt->CKTstate0 + here->HSMHVvdse) ;
404 vgse = *(ckt->CKTstate0 + here->HSMHVvgse) ;
405 vbse = *(ckt->CKTstate0 + here->HSMHVvbse) ;
406 if ( flg_nqs ) {
407 Qi_nqs = *(ckt->CKTstate0 + here->HSMHVqi_nqs) ;
408 Qb_nqs = *(ckt->CKTstate0 + here->HSMHVqb_nqs) ;
409 } else {
410 Qi_nqs = 0.0 ;
411 Qb_nqs = 0.0 ;
412 }
413 /* printf("HSMHV_load: (from state0) vds.. = %e %e %e %e %e %e\n",
414 vds,vgs,vbs,vdse,vgse,vbse); */
415 }
416 else if ( ckt->CKTmode & MODEINITTRAN ) {
417 /* #include "printf_ld_converged.inc" */
418 vbs = *(ckt->CKTstate1 + here->HSMHVvbs);
419 vgs = *(ckt->CKTstate1 + here->HSMHVvgs);
420 vds = *(ckt->CKTstate1 + here->HSMHVvds);
421
422 vges = *(ckt->CKTstate1 + here->HSMHVvges);
423 vdbd = *(ckt->CKTstate1 + here->HSMHVvdbd);
424 vsbs = *(ckt->CKTstate1 + here->HSMHVvsbs);
425 if (flg_subNode > 0) vsubs = *(ckt->CKTstate1 + here->HSMHVvsubs);
426 if( flg_tempNode > 0 ){
427 deltemp = *(ckt->CKTstate1 + here->HSMHVdeltemp);
428 }
429 vdse = *(ckt->CKTstate1 + here->HSMHVvdse) ;
430 vgse = *(ckt->CKTstate1 + here->HSMHVvgse) ;
431 vbse = *(ckt->CKTstate1 + here->HSMHVvbse) ;
432 if ( flg_nqs ) {
433 Qi_nqs = *(ckt->CKTstate1 + here->HSMHVqi_nqs) ;
434 Qb_nqs = *(ckt->CKTstate1 + here->HSMHVqb_nqs) ;
435 } else {
436 Qi_nqs = 0.0 ;
437 Qb_nqs = 0.0 ;
438 }
439 }
440 else if ( (ckt->CKTmode & MODEINITJCT) && !here->HSMHV_off ) {
441 vds = model->HSMHV_type * here->HSMHV_icVDS;
442 vgs = vges = model->HSMHV_type * here->HSMHV_icVGS;
443 vbs = vsbs = model->HSMHV_type * here->HSMHV_icVBS;
444 vdbd = 0.0 ;
445 if ( (vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) &&
446 ( (ckt->CKTmode & (MODETRAN|MODEAC|MODEDCOP|MODEDCTRANCURVE)) ||
447 !(ckt->CKTmode & MODEUIC) ) ) {
448 /* set biases for starting analysis */
449 vbs = vdbd = vsbs = 0.0;
450 vgs = vges = 0.1;
451 vds = 0.1;
452 }
453 if (flg_subNode > 0) vsubs = 0.0;
454 if( flg_tempNode > 0 ) deltemp=0.0;
455 vdse = vds ;
456 vgse = vgs ;
457 Qi_nqs = Qb_nqs = 0.0 ;
458 }
459 else if ( ( ckt->CKTmode & (MODEINITJCT | MODEINITFIX) ) &&
460 here->HSMHV_off ) {
461 vbs = vgs = vds = 0.0; vges = 0.0; vdbd = vsbs = 0.0;
462 if (flg_subNode > 0) vsubs = 0.0;
463 if( flg_tempNode > 0 ) deltemp=0.0;
464 vdse = vds ;
465 vgse = vgs ;
466 Qi_nqs = Qb_nqs = 0.0 ;
467 }
468 else {
469 #ifndef PREDICTOR /* BSIM3 style */
470 if (ckt->CKTmode & MODEINITPRED) {
471 /* #include "printf_ld_converged.inc" */
472 /* if (here->HSMHV_mode > 0) {
473 gds_ext = here->HSMHV_dIds_dVdse ;
474 } else {
475 gds_ext = + (here->HSMHV_dIds_dVdse + here->HSMHV_dIds_dVgse + here->HSMHV_dIds_dVbse) ;
476 }
477 printf("zzz %e %e\n",ckt->CKTtime,gds_ext) ; */
478 xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1];
479 *(ckt->CKTstate0 + here->HSMHVvbs) =
480 *(ckt->CKTstate1 + here->HSMHVvbs);
481 vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvbs))
482 -(xfact * (*(ckt->CKTstate2 + here->HSMHVvbs)));
483 *(ckt->CKTstate0 + here->HSMHVvgs) =
484 *(ckt->CKTstate1 + here->HSMHVvgs);
485 vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvgs))
486 -(xfact * (*(ckt->CKTstate2 + here->HSMHVvgs)));
487 *(ckt->CKTstate0 + here->HSMHVvds) =
488 *(ckt->CKTstate1 + here->HSMHVvds);
489 vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvds))
490 -(xfact * (*(ckt->CKTstate2 + here->HSMHVvds)));
491 *(ckt->CKTstate0 + here->HSMHVvbd) =
492 *(ckt->CKTstate0 + here->HSMHVvbs)-
493 *(ckt->CKTstate0 + here->HSMHVvds);
494
495 *(ckt->CKTstate0 + here->HSMHVvges) =
496 *(ckt->CKTstate1 + here->HSMHVvges);
497 vges = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvges))
498 -(xfact * (*(ckt->CKTstate2 + here->HSMHVvges)));
499 *(ckt->CKTstate0 + here->HSMHVvdbd) =
500 *(ckt->CKTstate1 + here->HSMHVvdbd);
501 vdbd = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvdbd))
502 - (xfact * (*(ckt->CKTstate2 + here->HSMHVvdbd)));
503 *(ckt->CKTstate0 + here->HSMHVvdbs) =
504 *(ckt->CKTstate0 + here->HSMHVvdbd)
505 + *(ckt->CKTstate0 + here->HSMHVvds);
506 *(ckt->CKTstate0 + here->HSMHVvsbs) =
507 *(ckt->CKTstate1 + here->HSMHVvsbs);
508 vsbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvsbs))
509 - (xfact * (*(ckt->CKTstate2 + here->HSMHVvsbs)));
510 if (flg_subNode > 0){
511 vsubs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvsubs))
512 - ( xfact * (*(ckt->CKTstate2 + here->HSMHVvsubs)));
513 }
514 if( flg_tempNode > 0 ){
515 deltemp = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVdeltemp))
516 - ( xfact * (*(ckt->CKTstate2 + here->HSMHVdeltemp)));
517
518 *(ckt->CKTstate0 + here->HSMHVdeltemp) =
519 *(ckt->CKTstate1 + here->HSMHVdeltemp);
520 }
521 *(ckt->CKTstate0 + here->HSMHVvdse) =
522 *(ckt->CKTstate1 + here->HSMHVvdse);
523 vdse = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvdse))
524 -(xfact * (*(ckt->CKTstate2 + here->HSMHVvdse)));
525 *(ckt->CKTstate0 + here->HSMHVvgse) =
526 *(ckt->CKTstate1 + here->HSMHVvgse);
527 vgse = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvgse))
528 -(xfact * (*(ckt->CKTstate2 + here->HSMHVvgse)));
529 *(ckt->CKTstate0 + here->HSMHVvbse) =
530 *(ckt->CKTstate1 + here->HSMHVvbse);
531 vbse = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVvbse))
532 -(xfact * (*(ckt->CKTstate2 + here->HSMHVvbse)));
533 if (flg_nqs) {
534 *(ckt->CKTstate0 + here->HSMHVqi_nqs) =
535 *(ckt->CKTstate1 + here->HSMHVqi_nqs);
536 Qi_nqs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVqi_nqs))
537 -(xfact * (*(ckt->CKTstate2 + here->HSMHVqi_nqs)));
538 *(ckt->CKTstate0 + here->HSMHVqb_nqs) =
539 *(ckt->CKTstate1 + here->HSMHVqb_nqs);
540 Qb_nqs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HSMHVqb_nqs))
541 -(xfact * (*(ckt->CKTstate2 + here->HSMHVqb_nqs)));
542 } else {
543 Qi_nqs = Qb_nqs = 0.0 ;
544 }
545 }
546 else {
547 #endif /* PREDICTOR */
548 /* here->HSMHV_time = ckt->CKTtime; /\* for debug print *\/ */
549 /* get biases from CKT */
550 vbs = model->HSMHV_type *
551 (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) -
552 *(ckt->CKTrhsOld+here->HSMHVsNodePrime));
553 vgs = model->HSMHV_type *
554 (*(ckt->CKTrhsOld+here->HSMHVgNodePrime) -
555 *(ckt->CKTrhsOld+here->HSMHVsNodePrime));
556 vds = model->HSMHV_type *
557 (*(ckt->CKTrhsOld+here->HSMHVdNodePrime) -
558 *(ckt->CKTrhsOld+here->HSMHVsNodePrime));
559
560 vges = model->HSMHV_type *
561 (*(ckt->CKTrhsOld+here->HSMHVgNode) -
562 *(ckt->CKTrhsOld+here->HSMHVsNodePrime));
563 vdbd = model->HSMHV_type
564 * (*(ckt->CKTrhsOld + here->HSMHVdbNode)
565 - *(ckt->CKTrhsOld + here->HSMHVdNode));
566 vsbs = model->HSMHV_type
567 * (*(ckt->CKTrhsOld + here->HSMHVsbNode)
568 - *(ckt->CKTrhsOld + here->HSMHVsNode));
569 if (flg_subNode > 0){
570 vsubs = model->HSMHV_type
571 * (*(ckt->CKTrhsOld + here->HSMHVsubNode)
572 - *(ckt->CKTrhsOld + here->HSMHVsNode));
573 }
574 if( flg_tempNode > 0 ){
575 deltemp = *(ckt->CKTrhsOld + here->HSMHVtempNode);
576 }
577 vbse = model->HSMHV_type *
578 (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) -
579 *(ckt->CKTrhsOld+here->HSMHVsNode));
580 vgse = model->HSMHV_type *
581 (*(ckt->CKTrhsOld+here->HSMHVgNodePrime) -
582 *(ckt->CKTrhsOld+here->HSMHVsNode));
583 vdse = model->HSMHV_type *
584 (*(ckt->CKTrhsOld+here->HSMHVdNode) -
585 *(ckt->CKTrhsOld+here->HSMHVsNode));
586 if ( flg_nqs ) {
587 Qi_nqs = *(ckt->CKTrhsOld + here->HSMHVqiNode);
588 Qb_nqs = *(ckt->CKTrhsOld + here->HSMHVqbNode);
589 } else {
590 Qi_nqs = Qb_nqs = 0.0 ;
591 }
592 #ifndef PREDICTOR
593 }
594 #endif /* PREDICTOR */
595
596 /* printf("HSMHV_load: (from rhs ) vds.. = %e %e %e %e %e %e\n",
597 vds,vgs,vbs,vdse,vgse,vbse); */
598
599 vbd = vbs - vds;
600 vgd = vgs - vds;
601 vged = vges - vds;
602 vdbs = vdbd + vdse;
603 vgdo = *(ckt->CKTstate0 + here->HSMHVvgs) - *(ckt->CKTstate0 + here->HSMHVvds);
604 vgedo = *(ckt->CKTstate0 + here->HSMHVvges) - *(ckt->CKTstate0 + here->HSMHVvds);
605
606 vds_pre = vds;
607
608 #ifndef NOBYPASS
609 /* start of bypass section
610 ... no bypass in case of selfheating */
611 if ( !(ckt->CKTmode & MODEINITPRED) && ckt->CKTbypass && !model->HSMHV_coselfheat) {
612 delvds = vds - *(ckt->CKTstate0 + here->HSMHVvds) ;
613 delvgs = vgs - *(ckt->CKTstate0 + here->HSMHVvgs) ;
614 delvbs = vbs - *(ckt->CKTstate0 + here->HSMHVvbs) ;
615 delvdse = vdse - *(ckt->CKTstate0 + here->HSMHVvdse) ;
616 delvgse = vgse - *(ckt->CKTstate0 + here->HSMHVvgse) ;
617 delvbse = vbse - *(ckt->CKTstate0 + here->HSMHVvbse) ;
618 delvdbd = vdbd - *(ckt->CKTstate0 + here->HSMHVvdbd) ;
619 delvsbs = vsbs - *(ckt->CKTstate0 + here->HSMHVvsbs) ;
620 if (flg_subNode > 0) delvsubs = vsubs - *(ckt->CKTstate0 + here->HSMHVvsubs) ; /* substrate bias change */
621 deldeltemp = deltemp - *(ckt->CKTstate0 + here->HSMHVdeltemp) ;
622 if (flg_nqs) {
623 delQi_nqs = Qi_nqs - *(ckt->CKTstate0 + here->HSMHVqi_nqs) ;
624 delQb_nqs = Qb_nqs - *(ckt->CKTstate0 + here->HSMHVqb_nqs) ;
625 } else {
626 delQi_nqs = delQb_nqs = 0.0 ;
627 }
628
629 /* now let's see if we can bypass */
630 /* ... first perform the easy cheap bypass checks ... */
631 /* 1 2 3 3 3 4 4 4 5 543 2 1 */
632 if ( ( fabs(delvds ) < ckt->CKTreltol * MAX(fabs(vds ),fabs(*(ckt->CKTstate0 + here->HSMHVvds ))) + ckt->CKTvoltTol ) &&
633 ( fabs(delvgs ) < ckt->CKTreltol * MAX(fabs(vgs ),fabs(*(ckt->CKTstate0 + here->HSMHVvgs ))) + ckt->CKTvoltTol ) &&
634 ( fabs(delvbs ) < ckt->CKTreltol * MAX(fabs(vbs ),fabs(*(ckt->CKTstate0 + here->HSMHVvbs ))) + ckt->CKTvoltTol ) &&
635 ( fabs(delvdse) < ckt->CKTreltol * MAX(fabs(vdse),fabs(*(ckt->CKTstate0 + here->HSMHVvdse))) + ckt->CKTvoltTol ) &&
636 ( fabs(delvgse) < ckt->CKTreltol * MAX(fabs(vgse),fabs(*(ckt->CKTstate0 + here->HSMHVvgse))) + ckt->CKTvoltTol ) &&
637 ( fabs(delvbse) < ckt->CKTreltol * MAX(fabs(vbse),fabs(*(ckt->CKTstate0 + here->HSMHVvbse))) + ckt->CKTvoltTol ) &&
638 ( fabs(delvdbd) < ckt->CKTreltol * MAX(fabs(vdbd),fabs(*(ckt->CKTstate0 + here->HSMHVvdbd))) + ckt->CKTvoltTol ) &&
639 ( fabs(delvsbs) < ckt->CKTreltol * MAX(fabs(vsbs),fabs(*(ckt->CKTstate0 + here->HSMHVvsbs))) + ckt->CKTvoltTol ) &&
640 ( fabs(delvsubs) < ckt->CKTreltol * MAX(fabs(vsubs),fabs(*(ckt->CKTstate0 + here->HSMHVvsubs))) + ckt->CKTvoltTol ) &&
641 ( fabs(delQi_nqs) < ckt->CKTreltol * fabs(Qi_nqs) + ckt->CKTchgtol*ckt->CKTabstol + 1.0e-20 ) &&
642 ( fabs(delQb_nqs) < ckt->CKTreltol * fabs(Qb_nqs) + ckt->CKTchgtol*ckt->CKTabstol + 1.0e-20 ) )
643 /* 1.0e-20: heuristic value, must be small enough */
644 /* to ensure that bypass does not destroy convergence */
645 { /* ... the first bypass checks are passed -> now do the more expensive checks ...*/
646 if ( here->HSMHV_mode > 0 ) { /* forward mode */
647 Ids = here->HSMHV_ids ;
648 gds = here->HSMHV_dIds_dVdsi ;
649 gm = here->HSMHV_dIds_dVgsi ;
650 gmbs = here->HSMHV_dIds_dVbsi ;
651 gmT = (flg_tempNode > 0) ? here->HSMHV_dIds_dTi : 0.0 ;
652 gmbs_ext = here->HSMHV_dIds_dVbse;
653 gds_ext = here->HSMHV_dIds_dVdse ;
654 gm_ext = here->HSMHV_dIds_dVgse;
655 Isub = here->HSMHV_isub ;
656 dIsub_dVds = here->HSMHV_dIsub_dVdsi ;
657 dIsub_dVgs = here->HSMHV_dIsub_dVgsi ;
658 dIsub_dVbs = here->HSMHV_dIsub_dVbsi ;
659 dIsub_dT = (flg_tempNode > 0) ? here->HSMHV_dIsub_dTi : 0.0 ;
660 dIsub_dVdse = here->HSMHV_dIsub_dVdse ;
661 Isubs = 0.0 ;
662 dIsubs_dVds = 0.0 ;
663 dIsubs_dVgs = 0.0 ;
664 dIsubs_dVbs = 0.0 ;
665 dIsubs_dT = 0.0 ;
666 dIsubs_dVdse = 0.0 ;
667 Igidl = here->HSMHV_igidl ;
668 dIgidl_dVds = here->HSMHV_dIgidl_dVdsi ;
669 dIgidl_dVgs = here->HSMHV_dIgidl_dVgsi ;
670 dIgidl_dVbs = here->HSMHV_dIgidl_dVbsi ;
671 dIgidl_dT = (flg_tempNode > 0) ? here->HSMHV_dIgidl_dTi : 0.0 ;
672 Igisl = here->HSMHV_igisl ;
673 dIgisl_dVds = here->HSMHV_dIgisl_dVdsi ;
674 dIgisl_dVgs = here->HSMHV_dIgisl_dVgsi ;
675 dIgisl_dVbs = here->HSMHV_dIgisl_dVbsi ;
676 dIgisl_dT = (flg_tempNode > 0) ? here->HSMHV_dIgisl_dTi : 0.0 ;
677 Igd = here->HSMHV_igd ;
678 dIgd_dVd = here->HSMHV_dIgd_dVdsi ;
679 dIgd_dVg = here->HSMHV_dIgd_dVgsi ;
680 dIgd_dVb = here->HSMHV_dIgd_dVbsi ;
681 dIgd_dT = (flg_tempNode > 0) ? here->HSMHV_dIgd_dTi : 0.0 ;
682 Igs = here->HSMHV_igs ;
683 dIgs_dVd = here->HSMHV_dIgs_dVdsi ;
684 dIgs_dVg = here->HSMHV_dIgs_dVgsi ;
685 dIgs_dVb = here->HSMHV_dIgs_dVbsi ;
686 dIgs_dT = (flg_tempNode > 0) ? here->HSMHV_dIgs_dTi : 0.0 ;
687 Igb = here->HSMHV_igb ;
688 dIgb_dVd = here->HSMHV_dIgb_dVdsi ;
689 dIgb_dVg = here->HSMHV_dIgb_dVgsi ;
690 dIgb_dVb = here->HSMHV_dIgb_dVbsi ;
691 dIgb_dT = (flg_tempNode > 0) ? here->HSMHV_dIgb_dTi : 0.0 ;
692 Ibd = here->HSMHV_ibd ;
693 Gbd = here->HSMHV_gbd ;
694 Gbdt = (flg_tempNode > 0) ? here->HSMHV_gbdT : 0.0 ;
695 Ibs = here->HSMHV_ibs ;
696 Gbs = here->HSMHV_gbs ;
697 Gbst = (flg_tempNode > 0) ? here->HSMHV_gbsT : 0.0 ;
698 } else { /* reverse mode */
699 Ids = - here->HSMHV_ids ;
700 gds = + (here->HSMHV_dIds_dVdsi + here->HSMHV_dIds_dVgsi + here->HSMHV_dIds_dVbsi) ;
701 gm = - here->HSMHV_dIds_dVgsi ;
702 gmbs = - here->HSMHV_dIds_dVbsi ;
703 gmT = (flg_tempNode > 0) ? - here->HSMHV_dIds_dTi : 0.0 ;
704 gds_ext = + (here->HSMHV_dIds_dVdse + here->HSMHV_dIds_dVgse + here->HSMHV_dIds_dVbse) ;
705 gm_ext = - here->HSMHV_dIds_dVgse;
706 gmbs_ext = - here->HSMHV_dIds_dVbse;
707 Isub = 0.0 ;
708 dIsub_dVds = 0.0 ;
709 dIsub_dVgs = 0.0 ;
710 dIsub_dVbs = 0.0 ;
711 dIsub_dT = 0.0 ;
712 dIsub_dVdse = 0.0 ;
713 Isubs = here->HSMHV_isub ;
714 dIsubs_dVds = - (here->HSMHV_dIsub_dVdsi + here->HSMHV_dIsub_dVgsi + here->HSMHV_dIsub_dVbsi) ;
715 dIsubs_dVgs = here->HSMHV_dIsub_dVgsi ;
716 dIsubs_dVbs = here->HSMHV_dIsub_dVbsi ;
717 dIsubs_dT = (flg_tempNode > 0) ? here->HSMHV_dIsub_dTi : 0.0 ;
718 dIsubs_dVdse = - here->HSMHV_dIsub_dVdse ; /* = - (dIsub_dVdse + dIsub_dVbse + dIsub_dVgse) */
719 Igidl = here->HSMHV_igisl ;
720 dIgidl_dVds = - (here->HSMHV_dIgisl_dVdsi + here->HSMHV_dIgisl_dVgsi + here->HSMHV_dIgisl_dVbsi) ;
721 dIgidl_dVgs = here->HSMHV_dIgisl_dVgsi ;
722 dIgidl_dVbs = here->HSMHV_dIgisl_dVbsi ;
723 dIgidl_dT = (flg_tempNode > 0) ? here->HSMHV_dIgisl_dTi : 0.0 ;
724 Igisl = here->HSMHV_igidl ;
725 dIgisl_dVds = - (here->HSMHV_dIgidl_dVdsi + here->HSMHV_dIgidl_dVgsi + here->HSMHV_dIgidl_dVbsi) ;
726 dIgisl_dVgs = here->HSMHV_dIgidl_dVgsi ;
727 dIgisl_dVbs = here->HSMHV_dIgidl_dVbsi ;
728 dIgisl_dT = (flg_tempNode > 0) ? here->HSMHV_dIgidl_dTi : 0.0 ;
729 Igd = here->HSMHV_igd ;
730 dIgd_dVd = - (here->HSMHV_dIgs_dVdsi + here->HSMHV_dIgs_dVgsi + here->HSMHV_dIgs_dVbsi) ;
731 dIgd_dVg = here->HSMHV_dIgs_dVgsi ;
732 dIgd_dVb = here->HSMHV_dIgs_dVbsi ;
733 dIgd_dT = (flg_tempNode > 0) ? here->HSMHV_dIgs_dTi : 0.0 ;
734 Igs = here->HSMHV_igs ;
735 dIgs_dVd = - (here->HSMHV_dIgd_dVdsi + here->HSMHV_dIgd_dVgsi + here->HSMHV_dIgd_dVbsi) ;
736 dIgs_dVg = here->HSMHV_dIgd_dVgsi ;
737 dIgs_dVb = here->HSMHV_dIgd_dVbsi ;
738 dIgs_dT = (flg_tempNode > 0) ? here->HSMHV_dIgd_dTi : 0.0 ;
739 Igb = here->HSMHV_igb ;
740 dIgb_dVd = - (here->HSMHV_dIgb_dVdsi + here->HSMHV_dIgb_dVgsi + here->HSMHV_dIgb_dVbsi) ;
741 dIgb_dVg = here->HSMHV_dIgb_dVgsi ;
742 dIgb_dVb = here->HSMHV_dIgb_dVbsi ;
743 dIgb_dT = (flg_tempNode > 0) ? here->HSMHV_dIgb_dTi : 0.0 ;
744 Ibd = here->HSMHV_ibd ;
745 Gbd = here->HSMHV_gbd ;
746 Gbdt = (flg_tempNode > 0) ? here->HSMHV_gbdT : 0.0 ;
747 Ibs = here->HSMHV_ibs ;
748 Gbs = here->HSMHV_gbs ;
749 Gbst = (flg_tempNode > 0) ? here->HSMHV_gbsT : 0.0 ;
750 } /* end of reverse mode */
751
752 /* for bypass control, only nonlinear static currents are considered: */
753 i_dP = Ids + Isub + Igidl - Igd ;
754 i_dP_hat = i_dP + gm *delvgs + gds *delvds + gmbs *delvbs + gmT *deldeltemp
755 + dIsub_dVgs *delvgs + dIsub_dVds *delvds + dIsub_dVbs *delvbs + dIsub_dT *deldeltemp
756 + dIsub_dVdse*delvdse
757 + dIgidl_dVgs*delvgs + dIgidl_dVds*delvds + dIgidl_dVbs*delvbs + dIgidl_dT*deldeltemp
758 -(dIgd_dVg *delvgs + dIgd_dVd *delvds + dIgd_dVb *delvbs + dIgd_dT *deldeltemp)
759 + gm_ext *delvgse + gds_ext *delvdse + gmbs_ext *delvbse ;
760
761 i_gP = Igd + Igs + Igb ;
762 i_gP_hat = i_gP + dIgd_dVg *delvgs + dIgd_dVd *delvds + dIgd_dVb *delvbs + dIgd_dT *deldeltemp
763 + dIgs_dVg *delvgs + dIgs_dVd *delvds + dIgs_dVb *delvbs + dIgs_dT *deldeltemp
764 + dIgb_dVg *delvgs + dIgb_dVd *delvds + dIgb_dVb *delvbs + dIgb_dT *deldeltemp ;
765
766 i_sP =-Ids + Isubs + Igisl - Igs ;
767 i_sP_hat = i_sP -(gm *delvgs + gds *delvds + gmbs *delvbs + gmT *deldeltemp)
768 + dIsubs_dVgs*delvgs + dIsubs_dVds*delvds + dIsubs_dVbs*delvbs + dIsubs_dT*deldeltemp
769 + dIsubs_dVdse*delvdse
770 + dIgisl_dVgs*delvgs + dIgisl_dVds*delvds + dIgisl_dVbs*delvbs + dIgisl_dT*deldeltemp
771 -(dIgs_dVg *delvgs + dIgs_dVd *delvds + dIgs_dVb *delvbs + dIgs_dT *deldeltemp)
772 -(gm_ext *delvgse + gds_ext *delvdse + gmbs_ext *delvbse) ;
773
774 i_db = Ibd ;
775 i_db_hat = i_db + Gbd*delvdbd + Gbdt*deldeltemp ;
776
777 i_sb = Ibs ;
778 i_sb_hat = i_sb + Gbs*delvsbs + Gbst*deldeltemp ;
779
780 /* ... second part of bypass checks: */
781 /* 1 2 3 3 3 4 4 4 43 2 1 */
782 if ( ( fabs(i_dP_hat - i_dP) < ckt->CKTreltol * MAX(fabs(i_dP_hat),fabs(i_dP)) + ckt->CKTabstol ) &&
783 ( fabs(i_gP_hat - i_gP) < ckt->CKTreltol * MAX(fabs(i_gP_hat),fabs(i_gP)) + ckt->CKTabstol ) &&
784 ( fabs(i_sP_hat - i_sP) < ckt->CKTreltol * MAX(fabs(i_sP_hat),fabs(i_sP)) + ckt->CKTabstol ) &&
785 ( fabs(i_db_hat - i_db) < ckt->CKTreltol * MAX(fabs(i_db_hat),fabs(i_db)) + ckt->CKTabstol ) &&
786 ( fabs(i_sb_hat - i_sb) < ckt->CKTreltol * MAX(fabs(i_sb_hat),fabs(i_sb)) + ckt->CKTabstol ) )
787 {
788 /* bypass code */
789 vds = *(ckt->CKTstate0 + here->HSMHVvds );
790 vgs = *(ckt->CKTstate0 + here->HSMHVvgs );
791 vbs = *(ckt->CKTstate0 + here->HSMHVvbs );
792 vdse = *(ckt->CKTstate0 + here->HSMHVvdse);
793 vgse = *(ckt->CKTstate0 + here->HSMHVvgse);
794 vbse = *(ckt->CKTstate0 + here->HSMHVvbse);
795 vdbd = *(ckt->CKTstate0 + here->HSMHVvdbd);
796 vsbs = *(ckt->CKTstate0 + here->HSMHVvsbs);
797 vsubs = *(ckt->CKTstate0 + here->HSMHVvsubs);
798 deltemp = *(ckt->CKTstate0 + here->HSMHVdeltemp);
799 if ( flg_nqs ) {
800 Qi_nqs = *(ckt->CKTstate0 + here->HSMHVqi_nqs);
801 Qb_nqs = *(ckt->CKTstate0 + here->HSMHVqb_nqs);
802 }
803
804 vges = *(ckt->CKTstate0 + here->HSMHVvges);
805
806 vbd = vbs - vds;
807 vgd = vgs - vds;
808 vgb = vgs - vbs;
809 vged = vges - vds;
810
811 vbs_jct = vsbs;
812 vbd_jct = vdbd;
813
814 /* linear branch currents */
815 vddp = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVdNode) - *(ckt->CKTrhsOld+here->HSMHVdNodePrime));
816 vggp = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVgNode) - *(ckt->CKTrhsOld+here->HSMHVgNodePrime));
817 vssp = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVsNode) - *(ckt->CKTrhsOld+here->HSMHVsNodePrime));
818 vbpb = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - *(ckt->CKTrhsOld+here->HSMHVbNode));
819 vbpdb = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - *(ckt->CKTrhsOld+here->HSMHVdbNode));
820 vbpsb = model->HSMHV_type * (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) - *(ckt->CKTrhsOld+here->HSMHVsbNode));
821
822 ByPass = 1;
823 goto line755;
824 }
825 }
826 } /* end of Bypass section */
827 #endif /*NOBYPASS*/
828
829 #ifdef DEBUG_HISIMHVLD_VX
830 printf( "vbd_p = %12.5e\n" , vbd );
831 printf( "vbs_p = %12.5e\n" , vbs );
832 printf( "vgs_p = %12.5e\n" , vgs );
833 printf( "vds_p = %12.5e\n" , vds );
834 #endif
835
836 /* start limiting of nonlinear branch voltages */
837
838 von = here->HSMHV_von;
839 Check3 = 0 ;
840 if(*(ckt->CKTstate0 + here->HSMHVvds) >= 0.0) { /* case vds>=0 for limiting */
841 limval = DEVfetlim(vgs, *(ckt->CKTstate0 + here->HSMHVvgs), von);
842 if (vgs != limval) {
843 vgs = limval ;
844 Check3 = 1 ;
845 }
846 if (Check3) vds = vgs - vgd;
847 limval = DEVlimvds(vds, *(ckt->CKTstate0 + here->HSMHVvds));
848 if (vds != limval) {
849 vds = limval ;
850 Check3 = 2 ;
851 }
852 vgd = vgs - vds;
853
854 if (here->HSMHV_corg == 1) {
855 limval = DEVfetlim(vges, *(ckt->CKTstate0 + here->HSMHVvges), von);
856 if (vges != limval) {
857 vges = limval ;
858 Check3 = 3 ;
859 }
860 vged = vges - vds;
861 }
862
863 } else { /* case vds < 0 for limiting */
864 limval = DEVfetlim(vgd, vgdo, von);
865 if (vgd != limval) {
866 vgd = limval ;
867 Check3 = 4 ;
868 }
869 if (Check3) vds = vgs - vgd;
870 limval = -DEVlimvds(-vds, -(*(ckt->CKTstate0 + here->HSMHVvds)));
871 if (vds != limval) {
872 vds = limval ;
873 Check3 = 5 ;
874 }
875 vgs = vgd + vds;
876
877 if (here->HSMHV_corg == 1) {
878 limval = DEVfetlim(vged, vgedo, von);
879 if (vged != limval) {
880 vged = limval ;
881 Check3 = 6 ;
882 }
883 vges = vged + vds;
884 }
885 } /* end of case vds< 0 for limiting */
886
887 if (vds >= 0.0) { /* case vds >=0 for limiting of junctions */
888 vbs = DEVpnjlim(vbs, *(ckt->CKTstate0 + here->HSMHVvbs),
889 CONSTvt0, model->HSMHV_vcrit, &Check1);
890 if (Check1) Check3 = 7 ;
891 vbd = vbs - vds;
892 if (here->HSMHV_corbnet) {
893 vsbs = DEVpnjlim(vsbs, *(ckt->CKTstate0 + here->HSMHVvsbs),
894 CONSTvt0, model->HSMHV_vcrit, &Check2);
895 if (Check2) Check3 = 8 ;
896 }
897 }
898 else { /* case vds < 0 for limiting of junctions */
899 vbd = DEVpnjlim(vbd, *(ckt->CKTstate0 + here->HSMHVvbd),
900 CONSTvt0, model->HSMHV_vcrit, &Check1);
901 if (Check1) Check3 = 9 ;
902 vbs = vbd + vds;
903 if (here->HSMHV_corbnet) {
904 vdbd = DEVpnjlim(vdbd, *(ckt->CKTstate0 + here->HSMHVvdbd),
905 CONSTvt0, model->HSMHV_vcrit, &Check2);
906 if (Check2) {
907 Check3 = 10 ;
908 vdbs = vdbd + vdse;
909 }
910 }
911 }
912
913 if( flg_tempNode > 0 ){
914 /* Logarithmic damping of deltemp beyond LIM_TOL */
915 deltemp_old = *(ckt->CKTstate0 + here->HSMHVdeltemp);
916 if (deltemp > deltemp_old + LIM_TOL)
917 {deltemp = deltemp_old + LIM_TOL + log10((deltemp-deltemp_old)/LIM_TOL);
918 Check3 = 11;}
919 else if (deltemp < deltemp_old - LIM_TOL)
920 {deltemp = deltemp_old - LIM_TOL - log10((deltemp_old-deltemp)/LIM_TOL);
921 Check3 = 12;}
922 }
923
924 /* if (Check3) printf("HSMHV_load: Check3=%d\n",Check3) ; */
925
926 /* limiting completed */
927 if (Check3 == 0 ) Check = 0 ;
928 } /* loading and limiting of nonlinear branch voltages is completed */
929
930
931 vbd = vbs - vds;
932 vgd = vgs - vds;
933 vgb = vgs - vbs;
934 vged = vges - vds;
935
936 vbs_jct = vsbs;
937 vbd_jct = vdbd;
938
939 /* linear branch voltages */
940 vddp = model->HSMHV_type *
941 (*(ckt->CKTrhsOld+here->HSMHVdNode) -
942 *(ckt->CKTrhsOld+here->HSMHVdNodePrime));
943
944 vggp = model->HSMHV_type *
945 (*(ckt->CKTrhsOld+here->HSMHVgNode) -
946 *(ckt->CKTrhsOld+here->HSMHVgNodePrime));
947
948 vssp = model->HSMHV_type *
949 (*(ckt->CKTrhsOld+here->HSMHVsNode) -
950 *(ckt->CKTrhsOld+here->HSMHVsNodePrime));
951
952 vbpdb = model->HSMHV_type *
953 (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) -
954 *(ckt->CKTrhsOld+here->HSMHVdbNode));
955
956 vbpb = model->HSMHV_type *
957 (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) -
958 *(ckt->CKTrhsOld+here->HSMHVbNode));
959
960
961 vbpsb = model->HSMHV_type *
962 (*(ckt->CKTrhsOld+here->HSMHVbNodePrime) -
963 *(ckt->CKTrhsOld+here->HSMHVsbNode));
964
965
966 #ifdef DEBUG_HISIMHVLD_VX
967 printf( "vbd = %12.5e\n" , vbd );
968 printf( "vbs = %12.5e\n" , vbs );
969 printf( "vgs = %12.5e\n" , vgs );
970 printf( "vds = %12.5e\n" , vds );
971 #endif
972
973 /* After loading (and limiting of branch voltages: Start model evaluation */
974
975 /* printf("HSMHV_load: vds=%e vgs=%e vbs=%e vsd=%e vgd=%e vbd=%e\n",
976 vds,vgs,vbs,-vds,vgs-vds,vbs-vds); */
977
978 if (vds >= 0) { /* normal mode */
979 here->HSMHV_mode = 1;
980 ivds = vds;
981 ivgs = vgs;
982 ivbs = vbs;
983 ivdse = vdse;
984 ivgse = vgse;
985 ivbse = vbse;
986 } else { /* reverse mode */
987 here->HSMHV_mode = -1;
988 ivds = -vds;
989 ivgs = vgd;
990 ivbs = vbd;
991 ivdse = -vdse;
992 ivgse = vgse - vdse;
993 ivbse = vbse - vdse;
994 }
995
996 if ( model->HSMHV_info >= 5 ) { /* mode, bias conditions ... */
997 printf( "--- variables given to HSMHVevaluate() ----\n" );
998 printf( "type = %s\n" , (model->HSMHV_type>0) ? "NMOS" : "PMOS" );
999 printf( "mode = %s\n" , (here->HSMHV_mode>0) ? "NORMAL" : "REVERSE" );
1000
1001 printf( "vbse vbs = %12.5e %12.5e\n" , vbse, ivbs );
1002 printf( "vdse vds = %12.5e %12.5e\n" , vdse, ivds );
1003 printf( "vgse vgs = %12.5e %12.5e\n" , vgse, ivgs );
1004 }
1005 if ( model->HSMHV_info >= 6 ) { /* input flags */
1006 printf( "corsrd = %s\n" , (model->HSMHV_corsrd) ? "true" : "false" ) ;
1007 printf( "coadov = %s\n" , (model->HSMHV_coadov) ? "true" : "false" ) ;
1008 printf( "coisub = %s\n" , (model->HSMHV_coisub) ? "true" : "false" ) ;
1009 printf( "coiigs = %s\n" , (model->HSMHV_coiigs) ? "true" : "false" ) ;
1010 printf( "cogidl = %s\n" , (model->HSMHV_cogidl) ? "true" : "false" ) ;
1011 printf( "coovlp = %s\n" , (model->HSMHV_coovlp) ? "true" : "false" ) ;
1012 printf( "coovlps = %s\n" , (model->HSMHV_coovlps) ? "true" : "false" ) ;
1013 printf( "coflick = %s\n", (model->HSMHV_coflick) ? "true" : "false" ) ;
1014 printf( "coisti = %s\n" , (model->HSMHV_coisti) ? "true" : "false" ) ;
1015 printf( "conqs = %s\n" , (model->HSMHV_conqs) ? "true" : "false" ) ;
1016 printf( "cothrml = %s\n", (model->HSMHV_cothrml) ? "true" : "false" ) ;
1017 printf( "coign = %s\n" , (model->HSMHV_coign) ? "true" : "false" ) ;
1018 printf( "cosym = %s\n" , (model->HSMHV_cosym) ? "true" : "false" ) ;
1019 printf( "coselfheat = %s\n" , (model->HSMHV_coselfheat) ? "true" : "false" ) ;
1020 }
1021 /* print inputs ------------AA */
1022
1023 #ifdef DEBUG_HISIMHVCGG
1024 /* Print convergence flag */
1025 printf("isConv %d ", isConv );
1026 printf("CKTtime %e ", ckt->CKTtime );
1027 printf("Vb %1.3e ", (model->HSMHV_type>0) ? vbs:-vbs );
1028 printf("Vd %1.3e ", (model->HSMHV_type>0) ? vds:-vds );
1029 printf("Vg %1.3e ", (model->HSMHV_type>0) ? vgs:-vgs );
1030 #endif
1031
1032 /* call model evaluation */
1033 if ( HSMHVevaluate(ivdse,ivgse,ivbse,ivds, ivgs, ivbs, vbs_jct, vbd_jct, vsubs, deltemp, here, model, ckt) == HiSIM_ERROR )
1034 return (HiSIM_ERROR);
1035
1036
1037 #ifdef DEBUG_HISIMHVCGG
1038 printf("HSMHV_ids %e ", here->HSMHV_ids ) ;
1039 printf("HSMHV_cggb %e ", here->HSMHV_cggb ) ;
1040 printf("\n") ;
1041 #endif
1042
1043 here->HSMHV_called += 1;
1044
1045 #ifndef NOBYPASS
1046 line755: /* standard entry if HSMHVevaluate is bypassed */
1047 #endif /* (could be shifted a bit forward ...) */
1048 if ( here->HSMHV_mode > 0 ) { /* forward mode */
1049 Rd = here->HSMHV_Rd ;
1050 dRd_dVdse = here->HSMHV_dRd_dVdse ;
1051 dRd_dVgse = here->HSMHV_dRd_dVgse ;
1052 dRd_dVbse = here->HSMHV_dRd_dVbse ;
1053 dRd_dVsubs = (flg_subNode > 0) ? here->HSMHV_dRd_dVsubs : 0.0 ; /* derivative w.r.t. Vsubs */
1054 dRd_dT = (flg_tempNode > 0) ? here->HSMHV_dRd_dTi : 0.0 ;
1055 Rs = here->HSMHV_Rs ;
1056 dRs_dVdse = here->HSMHV_dRs_dVdse ;
1057 dRs_dVgse = here->HSMHV_dRs_dVgse ;
1058 dRs_dVbse = here->HSMHV_dRs_dVbse ;
1059 dRs_dVsubs = (flg_subNode > 0) ? here->HSMHV_dRs_dVsubs : 0.0 ; /* derivative w.r.t. Vsubs */
1060 dRs_dT = (flg_tempNode > 0) ? here->HSMHV_dRs_dTi : 0.0 ;
1061 Ids = here->HSMHV_ids ;
1062 gds = here->HSMHV_dIds_dVdsi ;
1063 gm = here->HSMHV_dIds_dVgsi ;
1064 gmbs = here->HSMHV_dIds_dVbsi ;
1065 gmT = (flg_tempNode > 0) ? here->HSMHV_dIds_dTi : 0.0 ;
1066 gmbs_ext = here->HSMHV_dIds_dVbse ;
1067 gds_ext = here->HSMHV_dIds_dVdse ;
1068 gm_ext = here->HSMHV_dIds_dVgse ;
1069
1070 Qd = here->HSMHV_qd ;
1071 dQd_dVds = here->HSMHV_dQdi_dVdsi ;
1072 dQd_dVgs = here->HSMHV_dQdi_dVgsi ;
1073 dQd_dVbs = here->HSMHV_dQdi_dVbsi ;
1074 dQd_dT = (flg_tempNode > 0) ? here->HSMHV_dQdi_dTi : 0.0 ;
1075 Qg = here->HSMHV_qg ;
1076 dQg_dVds = here->HSMHV_dQg_dVdsi ;
1077 dQg_dVgs = here->HSMHV_dQg_dVgsi ;
1078 dQg_dVbs = here->HSMHV_dQg_dVbsi ;
1079 dQg_dT = (flg_tempNode > 0) ? here->HSMHV_dQg_dTi : 0.0 ;
1080 Qs = here->HSMHV_qs ;
1081 dQs_dVds = here->HSMHV_dQsi_dVdsi ;
1082 dQs_dVgs = here->HSMHV_dQsi_dVgsi ;
1083 dQs_dVbs = here->HSMHV_dQsi_dVbsi ;
1084 dQs_dT = (flg_tempNode > 0) ? here->HSMHV_dQsi_dTi : 0.0 ;
1085 Qb = - (here->HSMHV_qg + here->HSMHV_qd + here->HSMHV_qs) ;
1086 dQb_dVds = here->HSMHV_dQb_dVdsi ;
1087 dQb_dVgs = here->HSMHV_dQb_dVgsi ;
1088 dQb_dVbs = here->HSMHV_dQb_dVbsi ;
1089 dQb_dT = (flg_tempNode > 0) ? here->HSMHV_dQb_dTi : 0.0 ;
1090 Qfd = here->HSMHV_qdp ;
1091 dQfd_dVdse = here->HSMHV_dqdp_dVdse ;
1092 dQfd_dVgse = here->HSMHV_dqdp_dVgse ;
1093 dQfd_dVbse = here->HSMHV_dqdp_dVbse ;
1094 dQfd_dT = (flg_tempNode > 0) ? here->HSMHV_dqdp_dTi : 0.0 ;
1095 Qfs = here->HSMHV_qsp ;
1096 dQfs_dVdse = here->HSMHV_dqsp_dVdse ;
1097 dQfs_dVgse = here->HSMHV_dqsp_dVgse ;
1098 dQfs_dVbse = here->HSMHV_dqsp_dVbse ;
1099 dQfs_dT = (flg_tempNode > 0) ? here->HSMHV_dqsp_dTi : 0.0 ;
1100
1101 Qdext = here->HSMHV_qdext ;
1102 dQdext_dVdse = here->HSMHV_dQdext_dVdse ;
1103 dQdext_dVgse = here->HSMHV_dQdext_dVgse ;
1104 dQdext_dVbse = here->HSMHV_dQdext_dVbse ;
1105 dQdext_dT = (here->HSMHV_coselfheat > 0) ? here->HSMHV_dQdext_dTi : 0.0 ;
1106 Qgext = here->HSMHV_qgext ;
1107 dQgext_dVdse = here->HSMHV_dQgext_dVdse ;
1108 dQgext_dVgse = here->HSMHV_dQgext_dVgse ;
1109 dQgext_dVbse = here->HSMHV_dQgext_dVbse ;
1110 dQgext_dT = (here->HSMHV_coselfheat > 0) ? here->HSMHV_dQgext_dTi : 0.0 ;
1111 /* Qsext = here->HSMHV_qsext ;*/
1112 dQsext_dVdse = here->HSMHV_dQsext_dVdse ;
1113 dQsext_dVgse = here->HSMHV_dQsext_dVgse ;
1114 dQsext_dVbse = here->HSMHV_dQsext_dVbse ;
1115 dQsext_dT = (here->HSMHV_coselfheat > 0) ? here->HSMHV_dQsext_dTi : 0.0 ;
1116 Qbext = - (here->HSMHV_qgext + here->HSMHV_qdext + here->HSMHV_qsext) ;
1117 dQbext_dVdse = here->HSMHV_dQbext_dVdse ;
1118 dQbext_dVgse = here->HSMHV_dQbext_dVgse ;
1119 dQbext_dVbse = here->HSMHV_dQbext_dVbse ;
1120 dQbext_dT = (here->HSMHV_coselfheat > 0) ? here->HSMHV_dQbext_dTi : 0.0 ;
1121 Isub = here->HSMHV_isub ;
1122 dIsub_dVds = here->HSMHV_dIsub_dVdsi ;
1123 dIsub_dVgs = here->HSMHV_dIsub_dVgsi ;
1124 dIsub_dVbs = here->HSMHV_dIsub_dVbsi ;
1125 dIsub_dT = (flg_tempNode > 0) ? here->HSMHV_dIsub_dTi : 0.0 ;
1126 dIsub_dVdse = here->HSMHV_dIsub_dVdse ;
1127 Isubs = 0.0 ;
1128 dIsubs_dVds = 0.0 ;
1129 dIsubs_dVgs = 0.0 ;
1130 dIsubs_dVbs = 0.0 ;
1131 dIsubs_dT = 0.0 ;
1132 dIsubs_dVdse = 0.0 ;
1133 Igidl = here->HSMHV_igidl ;
1134 dIgidl_dVds = here->HSMHV_dIgidl_dVdsi ;
1135 dIgidl_dVgs = here->HSMHV_dIgidl_dVgsi ;
1136 dIgidl_dVbs = here->HSMHV_dIgidl_dVbsi ;
1137 dIgidl_dT = (flg_tempNode > 0) ? here->HSMHV_dIgidl_dTi : 0.0 ;
1138 Igisl = here->HSMHV_igisl ;
1139 dIgisl_dVds = here->HSMHV_dIgisl_dVdsi ;
1140 dIgisl_dVgs = here->HSMHV_dIgisl_dVgsi ;
1141 dIgisl_dVbs = here->HSMHV_dIgisl_dVbsi ;
1142 dIgisl_dT = (flg_tempNode > 0) ? here->HSMHV_dIgisl_dTi : 0.0 ;
1143 Igd = here->HSMHV_igd ;
1144 dIgd_dVd = here->HSMHV_dIgd_dVdsi ;
1145 dIgd_dVg = here->HSMHV_dIgd_dVgsi ;
1146 dIgd_dVb = here->HSMHV_dIgd_dVbsi ;
1147 dIgd_dT = (flg_tempNode > 0) ? here->HSMHV_dIgd_dTi : 0.0 ;
1148 Igs = here->HSMHV_igs ;
1149 dIgs_dVd = here->HSMHV_dIgs_dVdsi ;
1150 dIgs_dVg = here->HSMHV_dIgs_dVgsi ;
1151 dIgs_dVb = here->HSMHV_dIgs_dVbsi ;
1152 dIgs_dT = (flg_tempNode > 0) ? here->HSMHV_dIgs_dTi : 0.0 ;
1153 Igb = here->HSMHV_igb ;
1154 dIgb_dVd = here->HSMHV_dIgb_dVdsi ;
1155 dIgb_dVg = here->HSMHV_dIgb_dVgsi ;
1156 dIgb_dVb = here->HSMHV_dIgb_dVbsi ;
1157 dIgb_dT = (flg_tempNode > 0) ? here->HSMHV_dIgb_dTi : 0.0 ;
1158
1159 /*---------------------------------------------------*
1160 * Junction diode.
1161 *-----------------*/
1162 Ibd = here->HSMHV_ibd ;
1163 Gbd = here->HSMHV_gbd ;
1164 Gbdt = (flg_tempNode > 0) ? here->HSMHV_gbdT : 0.0 ;
1165
1166 /* Qbd = here->HSMHV_qbd ; */
1167 Qbd = *(ckt->CKTstate0 + here->HSMHVqbd) ;
1168 Cbd = here->HSMHV_capbd ;
1169 Cbdt = (flg_tempNode > 0) ? here->HSMHV_gcbdT : 0.0 ;
1170
1171 Ibs = here->HSMHV_ibs ;
1172 Gbs = here->HSMHV_gbs ;
1173 Gbst = (flg_tempNode > 0) ? here->HSMHV_gbsT : 0.0 ;
1174
1175 /* Qbs = here->HSMHV_qbs ; */
1176 Qbs = *(ckt->CKTstate0 + here->HSMHVqbs) ;
1177 Cbs = here->HSMHV_capbs ;
1178 Cbst = (flg_tempNode > 0) ? here->HSMHV_gcbsT : 0.0 ;
1179
1180 if (flg_nqs) {
1181 tau = here->HSMHV_tau ;
1182 dtau_dVds = here->HSMHV_tau_dVdsi ;
1183 dtau_dVgs = here->HSMHV_tau_dVgsi ;
1184 dtau_dVbs = here->HSMHV_tau_dVbsi ;
1185 dtau_dT = here->HSMHV_tau_dTi ;
1186 taub = here->HSMHV_taub ;
1187 dtaub_dVds = here->HSMHV_taub_dVdsi ;
1188 dtaub_dVgs = here->HSMHV_taub_dVgsi ;
1189 dtaub_dVbs = here->HSMHV_taub_dVbsi ;
1190 dtaub_dT = here->HSMHV_taub_dTi ;
1191 Qdrat = here->HSMHV_Xd ;
1192 dQdrat_dVds = here->HSMHV_Xd_dVdsi ;
1193 dQdrat_dVgs = here->HSMHV_Xd_dVgsi ;
1194 dQdrat_dVbs = here->HSMHV_Xd_dVbsi ;
1195 dQdrat_dT = here->HSMHV_Xd_dTi ;
1196 Qi = here->HSMHV_Qi ;
1197 dQi_dVds = here->HSMHV_Qi_dVdsi ;
1198 dQi_dVgs = here->HSMHV_Qi_dVgsi ;
1199 dQi_dVbs = here->HSMHV_Qi_dVbsi ;
1200 dQi_dT = here->HSMHV_Qi_dTi ;
1201 Qbulk = here->HSMHV_Qbulk ;
1202 dQbulk_dVds = here->HSMHV_Qbulk_dVdsi ;
1203 dQbulk_dVgs = here->HSMHV_Qbulk_dVgsi ;
1204 dQbulk_dVbs = here->HSMHV_Qbulk_dVbsi ;
1205 dQbulk_dT = here->HSMHV_Qbulk_dTi ;
1206 }
1207
1208 } else { /* reverse mode */
1209 /* note: here->HSMHV_Rd and here->HSMHV_Rs are already subjected to mode handling,
1210 while the following derivatives here->HSMHV_Rd_dVdse, ... are not! */
1211 Rd = here->HSMHV_Rd ;
1212 dRd_dVdse = here->HSMHV_dRd_dVdse ;
1213 dRd_dVgse = here->HSMHV_dRd_dVgse ;
1214 dRd_dVbse = here->HSMHV_dRd_dVbse ;
1215 dRd_dVsubs= (flg_subNode > 0) ? here->HSMHV_dRd_dVsubs : 0.0 ; /* derivative w.r.t. Vsubs */
1216 dRd_dT = (flg_tempNode > 0) ? here->HSMHV_dRd_dTi : 0.0 ;
1217 Rs = here->HSMHV_Rs ;
1218 dRs_dVdse = here->HSMHV_dRs_dVdse ;
1219 dRs_dVgse = here->HSMHV_dRs_dVgse ;
1220 dRs_dVbse = here->HSMHV_dRs_dVbse ;
1221 dRs_dVsubs= (flg_subNode > 0) ? here->HSMHV_dRs_dVsubs : 0.0 ; /* derivative w.r.t. Vsubs */
1222 dRs_dT = (flg_tempNode > 0) ? here->HSMHV_dRs_dTi : 0.0 ;
1223 Ids = - here->HSMHV_ids ;
1224 gds = + (here->HSMHV_dIds_dVdsi + here->HSMHV_dIds_dVgsi + here->HSMHV_dIds_dVbsi) ;
1225 gm = - here->HSMHV_dIds_dVgsi ;
1226 gmbs = - here->HSMHV_dIds_dVbsi ;
1227 gmT = (flg_tempNode > 0) ? - here->HSMHV_dIds_dTi : 0.0 ;
1228 gds_ext = + (here->HSMHV_dIds_dVdse + here->HSMHV_dIds_dVgse + here->HSMHV_dIds_dVbse) ;
1229 gm_ext = - here->HSMHV_dIds_dVgse;
1230 gmbs_ext = - here->HSMHV_dIds_dVbse;
1231
1232 Qd = here->HSMHV_qs ;
1233 dQd_dVds = - (here->HSMHV_dQsi_dVdsi + here->HSMHV_dQsi_dVgsi + here->HSMHV_dQsi_dVbsi) ;
1234 dQd_dVgs = here->HSMHV_dQsi_dVgsi ;
1235 dQd_dVbs = here->HSMHV_dQsi_dVbsi ;
1236 dQd_dT = (flg_tempNode > 0) ? here->HSMHV_dQsi_dTi : 0.0 ;
1237 Qg = here->HSMHV_qg ;
1238 dQg_dVds = - (here->HSMHV_dQg_dVdsi + here->HSMHV_dQg_dVgsi + here->HSMHV_dQg_dVbsi) ;
1239 dQg_dVgs = here->HSMHV_dQg_dVgsi ;
1240 dQg_dVbs = here->HSMHV_dQg_dVbsi ;
1241 dQg_dT = (flg_tempNode > 0) ? here->HSMHV_dQg_dTi : 0.0 ;
1242 Qs = here->HSMHV_qd ;
1243 dQs_dVds = - (here->HSMHV_dQdi_dVdsi + here->HSMHV_dQdi_dVgsi + here->HSMHV_dQdi_dVbsi) ;
1244 dQs_dVgs = here->HSMHV_dQdi_dVgsi ;
1245 dQs_dVbs = here->HSMHV_dQdi_dVbsi ;
1246 dQs_dT = (flg_tempNode > 0) ? here->HSMHV_dQdi_dTi : 0.0 ;
1247 Qb = - (here->HSMHV_qg + here->HSMHV_qd + here->HSMHV_qs) ;
1248 dQb_dVds = - (here->HSMHV_dQb_dVdsi + here->HSMHV_dQb_dVgsi + here->HSMHV_dQb_dVbsi) ;
1249 dQb_dVgs = here->HSMHV_dQb_dVgsi ;
1250 dQb_dVbs = here->HSMHV_dQb_dVbsi ;
1251 dQb_dT = (flg_tempNode > 0) ? here->HSMHV_dQb_dTi : 0.0 ;
1252 Qfd = here->HSMHV_qsp ;
1253 dQfd_dVdse = - (here->HSMHV_dqsp_dVdse + here->HSMHV_dqsp_dVgse + here->HSMHV_dqsp_dVbse) ;
1254 dQfd_dVgse = here->HSMHV_dqsp_dVgse ;
1255 dQfd_dVbse = here->HSMHV_dqsp_dVbse ;
1256 dQfd_dT = (flg_tempNode > 0) ? here->HSMHV_dqsp_dTi : 0.0 ;
1257 Qfs = here->HSMHV_qdp ;
1258 dQfs_dVdse = - (here->HSMHV_dqdp_dVdse + here->HSMHV_dqdp_dVgse + here->HSMHV_dqdp_dVbse) ;
1259 dQfs_dVgse = here->HSMHV_dqdp_dVgse ;
1260 dQfs_dVbse = here->HSMHV_dqdp_dVbse ;
1261 dQfs_dT = (flg_tempNode > 0) ? here->HSMHV_dqdp_dTi : 0.0 ;
1262
1263 Qdext = here->HSMHV_qsext ;
1264 dQdext_dVdse = - (here->HSMHV_dQsext_dVdse + here->HSMHV_dQsext_dVgse + here->HSMHV_dQsext_dVbse);
1265 dQdext_dVgse = here->HSMHV_dQsext_dVgse ;
1266 dQdext_dVbse = here->HSMHV_dQsext_dVbse ;
1267 dQdext_dT = (here->HSMHV_coselfheat > 0) ? here->HSMHV_dQsext_dTi : 0.0 ;
1268 Qgext = here->HSMHV_qgext ;
1269 dQgext_dVdse = - (here->HSMHV_dQgext_dVdse + here->HSMHV_dQgext_dVgse + here->HSMHV_dQgext_dVbse);
1270 dQgext_dVgse = here->HSMHV_dQgext_dVgse ;
1271 dQgext_dVbse = here->HSMHV_dQgext_dVbse ;
1272 dQgext_dT = (here->HSMHV_coselfheat > 0) ? here->HSMHV_dQgext_dTi : 0.0 ;
1273 /* Qsext = here->HSMHV_qdext ;*/
1274 dQsext_dVdse = - (here->HSMHV_dQdext_dVdse + here->HSMHV_dQdext_dVgse + here->HSMHV_dQdext_dVbse);
1275 dQsext_dVgse = here->HSMHV_dQdext_dVgse ;
1276 dQsext_dVbse = here->HSMHV_dQdext_dVbse ;
1277 dQsext_dT = (here->HSMHV_coselfheat > 0) ? here->HSMHV_dQdext_dTi : 0.0 ;
1278 Qbext = - (here->HSMHV_qgext + here->HSMHV_qdext + here->HSMHV_qsext) ;
1279 dQbext_dVdse = - (here->HSMHV_dQbext_dVdse + here->HSMHV_dQbext_dVgse + here->HSMHV_dQbext_dVbse);
1280 dQbext_dVgse = here->HSMHV_dQbext_dVgse ;
1281 dQbext_dVbse = here->HSMHV_dQbext_dVbse ;
1282 dQbext_dT = (here->HSMHV_coselfheat > 0) ? here->HSMHV_dQbext_dTi : 0.0 ;
1283 Isub = 0.0 ;
1284 dIsub_dVds = 0.0 ;
1285 dIsub_dVgs = 0.0 ;
1286 dIsub_dVbs = 0.0 ;
1287 dIsub_dT = 0.0 ;
1288 dIsub_dVdse = 0.0 ;
1289 Isubs = here->HSMHV_isub ;
1290 dIsubs_dVds = - (here->HSMHV_dIsub_dVdsi + here->HSMHV_dIsub_dVgsi + here->HSMHV_dIsub_dVbsi) ;
1291 dIsubs_dVgs = here->HSMHV_dIsub_dVgsi ;
1292 dIsubs_dVbs = here->HSMHV_dIsub_dVbsi ;
1293 dIsubs_dT = (flg_tempNode > 0) ? here->HSMHV_dIsub_dTi : 0.0 ;
1294 dIsubs_dVdse = - here->HSMHV_dIsub_dVdse ; /* = - (dIsub_dVdse + dIsub_dVbse + dIsub_dVgse) */
1295 Igidl = here->HSMHV_igisl ;
1296 dIgidl_dVds = - (here->HSMHV_dIgisl_dVdsi + here->HSMHV_dIgisl_dVgsi + here->HSMHV_dIgisl_dVbsi) ;
1297 dIgidl_dVgs = here->HSMHV_dIgisl_dVgsi ;
1298 dIgidl_dVbs = here->HSMHV_dIgisl_dVbsi ;
1299 dIgidl_dT = (flg_tempNode > 0) ? here->HSMHV_dIgisl_dTi : 0.0 ;
1300 Igisl = here->HSMHV_igidl ;
1301 dIgisl_dVds = - (here->HSMHV_dIgidl_dVdsi + here->HSMHV_dIgidl_dVgsi + here->HSMHV_dIgidl_dVbsi) ;
1302 dIgisl_dVgs = here->HSMHV_dIgidl_dVgsi ;
1303 dIgisl_dVbs = here->HSMHV_dIgidl_dVbsi ;
1304 dIgisl_dT = (flg_tempNode > 0) ? here->HSMHV_dIgidl_dTi : 0.0 ;
1305 /* note: here->HSMHV_igd and here->HSMHV_igs are already subjected to mode handling,
1306 while the following derivatives here->HSMHV_dIgd_dVdsi, ... are not! */
1307 Igd = here->HSMHV_igd ;
1308 dIgd_dVd = - (here->HSMHV_dIgs_dVdsi + here->HSMHV_dIgs_dVgsi + here->HSMHV_dIgs_dVbsi) ;
1309 dIgd_dVg = here->HSMHV_dIgs_dVgsi ;
1310 dIgd_dVb = here->HSMHV_dIgs_dVbsi ;
1311 dIgd_dT = (flg_tempNode > 0) ? here->HSMHV_dIgs_dTi : 0.0 ;
1312 Igs = here->HSMHV_igs ;
1313 dIgs_dVd = - (here->HSMHV_dIgd_dVdsi + here->HSMHV_dIgd_dVgsi + here->HSMHV_dIgd_dVbsi) ;
1314 dIgs_dVg = here->HSMHV_dIgd_dVgsi ;
1315 dIgs_dVb = here->HSMHV_dIgd_dVbsi ;
1316 dIgs_dT = (flg_tempNode > 0) ? here->HSMHV_dIgd_dTi : 0.0 ;
1317 Igb = here->HSMHV_igb ;
1318 dIgb_dVd = - (here->HSMHV_dIgb_dVdsi + here->HSMHV_dIgb_dVgsi + here->HSMHV_dIgb_dVbsi) ;
1319 dIgb_dVg = here->HSMHV_dIgb_dVgsi ;
1320 dIgb_dVb = here->HSMHV_dIgb_dVbsi ;
1321 dIgb_dT = (flg_tempNode > 0) ? here->HSMHV_dIgb_dTi : 0.0 ;
1322
1323 /*---------------------------------------------------*
1324 * Junction diode.
1325 *-----------------*/
1326 Ibd = here->HSMHV_ibd ;
1327 Gbd = here->HSMHV_gbd ;
1328 Gbdt = (flg_tempNode > 0) ? here->HSMHV_gbdT : 0.0 ;
1329
1330 /* Qbd = here->HSMHV_qbd ; */
1331 Qbd = *(ckt->CKTstate0 + here->HSMHVqbd) ;
1332 Cbd = here->HSMHV_capbd ;
1333 Cbdt = (flg_tempNode > 0) ? here->HSMHV_gcbdT : 0.0 ;
1334
1335 Ibs = here->HSMHV_ibs ;
1336 Gbs = here->HSMHV_gbs ;
1337 Gbst = (flg_tempNode > 0) ? here->HSMHV_gbsT : 0.0 ;
1338
1339 /* Qbs = here->HSMHV_qbs ; */
1340 Qbs = *(ckt->CKTstate0 + here->HSMHVqbs) ;
1341 Cbs = here->HSMHV_capbs ;
1342 Cbst = (flg_tempNode > 0) ? here->HSMHV_gcbsT : 0.0 ;
1343
1344 if (flg_nqs) {
1345 tau = here->HSMHV_tau ;
1346 dtau_dVds = -(here->HSMHV_tau_dVdsi + here->HSMHV_tau_dVgsi + here->HSMHV_tau_dVbsi) ;
1347 dtau_dVgs = here->HSMHV_tau_dVgsi ;
1348 dtau_dVbs = here->HSMHV_tau_dVbsi ;
1349 dtau_dT = here->HSMHV_tau_dTi ;
1350 taub = here->HSMHV_taub ;
1351 dtaub_dVds = -(here->HSMHV_taub_dVdsi + here->HSMHV_taub_dVgsi + here->HSMHV_taub_dVbsi);
1352 dtaub_dVgs = here->HSMHV_taub_dVgsi ;
1353 dtaub_dVbs = here->HSMHV_taub_dVbsi ;
1354 dtaub_dT = here->HSMHV_taub_dTi ;
1355 Qdrat = 1.0 - here->HSMHV_Xd ;
1356 dQdrat_dVds = +(here->HSMHV_Xd_dVdsi + here->HSMHV_Xd_dVgsi + here->HSMHV_Xd_dVbsi) ;
1357 dQdrat_dVgs = - here->HSMHV_Xd_dVgsi ;
1358 dQdrat_dVbs = - here->HSMHV_Xd_dVbsi ;
1359 dQdrat_dT = - here->HSMHV_Xd_dTi ;
1360 Qi = here->HSMHV_Qi ;
1361 dQi_dVds = -(here->HSMHV_Qi_dVdsi + here->HSMHV_Qi_dVgsi + here->HSMHV_Qi_dVbsi) ;
1362 dQi_dVgs = here->HSMHV_Qi_dVgsi ;
1363 dQi_dVbs = here->HSMHV_Qi_dVbsi ;
1364 dQi_dT = here->HSMHV_Qi_dTi ;
1365 Qbulk = here->HSMHV_Qbulk ;
1366 dQbulk_dVds = -(here->HSMHV_Qbulk_dVdsi + here->HSMHV_Qbulk_dVgsi + here->HSMHV_Qbulk_dVbsi) ;
1367 dQbulk_dVgs = here->HSMHV_Qbulk_dVgsi ;
1368 dQbulk_dVbs = here->HSMHV_Qbulk_dVbsi ;
1369 dQbulk_dT = here->HSMHV_Qbulk_dTi ;
1370 }
1371 } /* end of reverse mode */
1372
1373 if (flg_tempNode > 0) {
1374 if (pParam->HSMHV_rth > C_RTH_MIN) {
1375 Gth = 1.0/pParam->HSMHV_rth ;
1376 } else {
1377 Gth = 1.0/C_RTH_MIN ;
1378 }
1379 Ith = Gth * deltemp ;
1380 dIth_dT = Gth ;
1381 Cth = pParam->HSMHV_cth ;
1382 Qth = Cth * deltemp ;
1383 /* P = Ids * (Vdsi + param * ( Vdse - Vdsi)) */
1384 /* = Ids * Veffpower */
1385 if ( vds * (vdse - vds) >= 0.0) {
1386 if ( pParam->HSMHV_powrat == 1.0 ) {
1387 Veffpower = vdse ;
1388 dVeffpower_dVds = 0.0 ;
1389 dVeffpower_dVdse = 1.0 ;
1390 } else {
1391 Veffpower = vds + here->HSMHV_powratio * (vdse - vds) ;
1392 dVeffpower_dVds = (1.0 - here->HSMHV_powratio) ;
1393 dVeffpower_dVdse = here->HSMHV_powratio ;
1394 }
1395
1396
1397
1398
1399 } else {
1400 Veffpower = vds ;
1401 dVeffpower_dVds = 1.0 ;
1402 dVeffpower_dVdse = 0.0 ;
1403 }
1404 P = Ids * Veffpower ;
1405 dP_dVds = gds * Veffpower + Ids * dVeffpower_dVds;
1406 dP_dVgs = gm * Veffpower ;
1407 dP_dVbs = gmbs * Veffpower ;
1408 dP_dT = gmT * Veffpower ;
1409 dP_dVdse = gds_ext * Veffpower + Ids * dVeffpower_dVdse ;
1410 dP_dVgse = gm_ext * Veffpower ;
1411 dP_dVbse = gmbs_ext * Veffpower ;
1412
1413 /* Clamping the maximum rise tempaerarure (SHEMAX) */
1414 T1 = model->HSMHV_shemax * Gth ;
1415 Fn_SU( T2 , P , T1 , SHE_MAX_dlt * Gth , T0 ) ;
1416 P = T2 ;
1417 dP_dVds = T0 * dP_dVds ;
1418 dP_dVgs = T0 * dP_dVgs ;
1419 dP_dVbs = T0 * dP_dVbs ;
1420 dP_dT = T0 * dP_dT ;
1421 dP_dVdse = T0 * dP_dVdse ;
1422 dP_dVgse = T0 * dP_dVgse ;
1423 dP_dVbse = T0 * dP_dVbse ;
1424
1425 } else {
1426 Gth = 0.0 ;
1427 Ith = 0.0 ;
1428 dIth_dT = 0.0 ;
1429 Cth = 0.0 ;
1430 Qth = 0.0 ;
1431 P = 0.0 ;
1432 dP_dVds = 0.0 ;
1433 dP_dVgs = 0.0 ;
1434 dP_dVbs = 0.0 ;
1435 dP_dT = 0.0 ;
1436 dP_dVdse = 0.0 ;
1437 dP_dVgse = 0.0 ;
1438 dP_dVbse = 0.0 ;
1439 }
1440
1441 /* in case of nqs: construct static contributions to the nqs equations (Iqi_nqs, Iqb_nqs) */
1442 /* and nqs charge contributions to inner drain, gate and source node (Qd_nqs, Qg_nqs, Qs_nqs) */
1443
1444 if (flg_nqs) {
1445 /* .. tau, taub must be > 0 */
1446 if (tau < 1.0e-18) {
1447 tau = 1.e-18 ;
1448 dtau_dVds = dtau_dVgs = dtau_dVbs = dtau_dT = 0.0 ;
1449 }
1450 if (taub < 1.0e-18) {
1451 taub = 1.0e-18 ;
1452 dtaub_dVds = dtaub_dVgs = dtaub_dVbs = dtaub_dT = 0.0 ;
1453 }
1454
1455 Iqi_nqs = (Qi_nqs - Qi) / tau ;
1456 dIqi_nqs_dVds = - (dQi_dVds + Iqi_nqs * dtau_dVds) / tau ;
1457 dIqi_nqs_dVgs = - (dQi_dVgs + Iqi_nqs * dtau_dVgs) / tau ;
1458 dIqi_nqs_dVbs = - (dQi_dVbs + Iqi_nqs * dtau_dVbs) / tau ;
1459 dIqi_nqs_dT = - (dQi_dT + Iqi_nqs * dtau_dT ) / tau ;
1460 dIqi_nqs_dQi_nqs = 1.0 / tau ;
1461
1462 Iqb_nqs = (Qb_nqs - Qbulk) / taub ;
1463 dIqb_nqs_dVds = - (dQbulk_dVds + Iqb_nqs * dtaub_dVds) / taub ;
1464 dIqb_nqs_dVgs = - (dQbulk_dVgs + Iqb_nqs * dtaub_dVgs) / taub ;
1465 dIqb_nqs_dVbs = - (dQbulk_dVbs + Iqb_nqs * dtaub_dVbs) / taub ;
1466 dIqb_nqs_dT = - (dQbulk_dT + Iqb_nqs * dtaub_dT ) / taub ;
1467 dIqb_nqs_dQb_nqs = 1.0 / taub ;
1468
1469 Qd_nqs = Qi_nqs * Qdrat ;
1470 dQd_nqs_dVds = Qi_nqs * dQdrat_dVds ;
1471 dQd_nqs_dVgs = Qi_nqs * dQdrat_dVgs ;
1472 dQd_nqs_dVbs = Qi_nqs * dQdrat_dVbs ;
1473 dQd_nqs_dT = Qi_nqs * dQdrat_dT ;
1474 dQd_nqs_dQi_nqs = Qdrat ;
1475
1476 Qg_nqs = - Qi_nqs - Qb_nqs ;
1477 dQg_nqs_dQi_nqs = - 1.0 ;
1478 dQg_nqs_dQb_nqs = - 1.0 ;
1479
1480 Qs_nqs = Qi_nqs * (1.0 - Qdrat) ;
1481 dQs_nqs_dVds = - Qi_nqs * dQdrat_dVds ;
1482 dQs_nqs_dVgs = - Qi_nqs * dQdrat_dVgs ;
1483 dQs_nqs_dVbs = - Qi_nqs * dQdrat_dVbs ;
1484 dQs_nqs_dT = - Qi_nqs * dQdrat_dT ;
1485 dQs_nqs_dQi_nqs = 1.0 - Qdrat ;
1486 } else {
1487 Iqi_nqs = Iqb_nqs = Qd_nqs = Qg_nqs = Qs_nqs = 0.0 ;
1488 }
1489
1490 dIgd_dVs = - (dIgd_dVd + dIgd_dVg + dIgd_dVb) ;
1491 dIgs_dVs = - (dIgs_dVd + dIgs_dVg + dIgs_dVb) ;
1492 dIgb_dVs = - (dIgb_dVd + dIgb_dVg + dIgb_dVb) ;
1493
1494 /*---------------------------------------------------*
1495 * External Resistances
1496 *-----------------*/
1497 if(model->HSMHV_corsrd == 1 || model->HSMHV_corsrd == 3 ) {
1498 if(Rd > 0){
1499 GD = 1.0/Rd;
1500 GD_dVgs = - dRd_dVgse /Rd/Rd;
1501 GD_dVds = - dRd_dVdse /Rd/Rd;
1502 GD_dVbs = - dRd_dVbse /Rd/Rd;
1503 GD_dVsubs = - dRd_dVsubs /Rd/Rd;
1504 GD_dT = - dRd_dT /Rd/Rd;
1505 }else{
1506 GD=0.0;
1507 GD_dVgs=0.0;
1508 GD_dVds=0.0;
1509 GD_dVbs=0.0;
1510 GD_dVsubs=0.0;
1511 GD_dT =0.0;
1512 }
1513 if(Rs > 0){
1514 GS = 1.0/Rs;
1515 GS_dVgs = - dRs_dVgse /Rs/Rs;
1516 GS_dVds = - dRs_dVdse /Rs/Rs;
1517 GS_dVbs = - dRs_dVbse /Rs/Rs;
1518 GS_dVsubs = - dRs_dVsubs /Rs/Rs;
1519 GS_dT = - dRs_dT /Rs/Rs;
1520 }else{
1521 GS=0.0;
1522 GS_dVgs=0.0;
1523 GS_dVds=0.0;
1524 GS_dVbs=0.0;
1525 GS_dVsubs=0.0;
1526 GS_dT =0.0;
1527 }
1528 }
1529 Iddp = GD * vddp;
1530 dIddp_dVddp = GD;
1531 dIddp_dVdse = GD_dVds * vddp;
1532 dIddp_dVgse = GD_dVgs * vddp;
1533 dIddp_dVbse = GD_dVbs * vddp;
1534 dIddp_dVsubs= GD_dVsubs * vddp;
1535 dIddp_dT = GD_dT * vddp;
1536
1537 Issp = GS * vssp;
1538 dIssp_dVssp = GS;
1539 dIssp_dVdse = GS_dVds * vssp ;
1540 dIssp_dVgse = GS_dVgs * vssp;
1541 dIssp_dVbse = GS_dVbs * vssp;
1542 dIssp_dVsubs= GS_dVsubs * vssp;
1543 dIssp_dT = GS_dT * vssp;
1544
1545 if( model->HSMHV_corg > 0.0 ){
1546 GG = here->HSMHV_grg ;
1547 }else{
1548 GG = 0.0 ;
1549 }
1550 Iggp = GG * vggp;
1551 dIggp_dVggp = GG;
1552
1553 if(model->HSMHV_corbnet == 1 && here->HSMHV_rbpb > 0.0 ){
1554 GRBPB = here->HSMHV_grbpb ;
1555 }else{
1556 GRBPB = 0.0 ;
1557 }
1558 Ibpb = GRBPB * vbpb;
1559 dIbpb_dVbpb = GRBPB;
1560
1561 if(model->HSMHV_corbnet == 1 && here->HSMHV_rbpd > 0.0 ){
1562 GRBPD = here->HSMHV_grbpd ;
1563 }else{
1564 GRBPD = 0.0 ;
1565 }
1566 Ibpdb = GRBPD * vbpdb;
1567 dIbpdb_dVbpdb = GRBPD;
1568
1569 if(model->HSMHV_corbnet == 1 && here->HSMHV_rbps > 0.0 ){
1570 GRBPS = here->HSMHV_grbps ;
1571 }else{
1572 GRBPS = 0.0 ;
1573 }
1574 Ibpsb = GRBPS * vbpsb;
1575 dIbpsb_dVbpsb = GRBPS;
1576
1577 /* printf("HSMHV_load: ByPass=%d\n",ByPass) ; */
1578
1579 if (!ByPass) { /* no convergence check in case of Bypass */
1580 /*
1581 * check convergence
1582 */
1583 isConv = 1;
1584 if ( (here->HSMHV_off == 0) || !(ckt->CKTmode & MODEINITFIX) ) {
1585 if (Check == 1) {
1586 ckt->CKTnoncon++;
1587 isConv = 0;
1588 #ifndef NEWCONV
1589 } else {
1590 /* convergence check for branch currents is done in function HSMHVconvTest */
1591 #endif /* NEWCONV */
1592 }
1593 }
1594
1595 *(ckt->CKTstate0 + here->HSMHVvbs) = vbs;
1596 *(ckt->CKTstate0 + here->HSMHVvbd) = vbd;
1597 *(ckt->CKTstate0 + here->HSMHVvgs) = vgs;
1598 *(ckt->CKTstate0 + here->HSMHVvds) = vds;
1599 *(ckt->CKTstate0 + here->HSMHVvsbs) = vsbs;
1600 *(ckt->CKTstate0 + here->HSMHVvdbs) = vdbs;
1601 *(ckt->CKTstate0 + here->HSMHVvdbd) = vdbd;
1602 *(ckt->CKTstate0 + here->HSMHVvges) = vges;
1603 *(ckt->CKTstate0 + here->HSMHVvsubs) = vsubs;
1604 *(ckt->CKTstate0 + here->HSMHVdeltemp) = deltemp;
1605 *(ckt->CKTstate0 + here->HSMHVvdse) = vdse;
1606 *(ckt->CKTstate0 + here->HSMHVvgse) = vgse;
1607 *(ckt->CKTstate0 + here->HSMHVvbse) = vbse;
1608 if ( flg_nqs ) {
1609 *(ckt->CKTstate0 + here->HSMHVqi_nqs) = Qi_nqs;
1610 *(ckt->CKTstate0 + here->HSMHVqb_nqs) = Qb_nqs;
1611 }
1612 /* printf("HSMHV_load: (into state0) vds.. = %e %e %e %e %e %e\n",
1613 vds,vgs,vbs,vdse,vgse,vbse); */
1614
1615 if ((ckt->CKTmode & MODEDC) &&
1616 !(ckt->CKTmode & MODEINITFIX) && !(ckt->CKTmode & MODEINITJCT))
1617 showPhysVal = 1;
1618 if (model->HSMHV_show_Given && showPhysVal && isConv) {
1619 static int isFirst = 1;
1620 if (vds != vds_pre)
1621 ShowPhysVals(here, model, isFirst, vds_pre, vgs, vbs, vgd, vbd, vgb);
1622 else
1623 ShowPhysVals(here, model, isFirst, vds, vgs, vbs, vgd, vbd, vgb);
1624 if (isFirst) isFirst = 0;
1625 }
1626 }
1627
1628 #include "hsmhvld_info_eval.h"
1629
1630 /* For standard Newton method (SPICE_rhs == 0): */
1631 /* if currents (and charges) are limited -> extrapolate onto x-values */
1632 /* in SPICE mode (SPICE_rhs == 1): */
1633 /* extrapolate onto x = 0 (-> rhs_eq) */
1634 /* */
1635 /* note that */
1636 /* the charge extrapolation is replaced by extrapolation of displacement */
1637 /* currents, see below */
1638
1639 /* ...... just for easier handling: collect node voltages in vector x: */
1640 if (!SPICE_rhs) {
1641 x[dNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVdNode));
1642 x[dNodePrime] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVdNodePrime));
1643 x[gNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVgNode));
1644 x[gNodePrime] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVgNodePrime));
1645 x[sNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVsNode));
1646 x[sNodePrime] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVsNodePrime));
1647 x[bNodePrime] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVbNodePrime));
1648 x[bNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVbNode));
1649 x[dbNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVdbNode));
1650 x[sbNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVsbNode));
1651 if (flg_subNode > 0)
1652 x[subNode] = model->HSMHV_type *( *(ckt->CKTrhsOld+here->HSMHVsubNode)); /* previous vsub */
1653 else
1654 x[subNode] = 0.0;
1655 if (flg_tempNode > 0)
1656 x[tempNode] = *(ckt->CKTrhsOld+here->HSMHVtempNode);
1657 else
1658 x[tempNode] = 0.0;
1659 if ( flg_nqs ) {
1660 x[qiNode] = *(ckt->CKTrhsOld+here->HSMHVqiNode);
1661 x[qbNode] = *(ckt->CKTrhsOld+here->HSMHVqbNode);
1662 } else {
1663 x[qiNode] = 0.0;
1664 x[qbNode] = 0.0;
1665 }
1666 }
1667
1668 delvgs = (x[gNodePrime] - x[sNodePrime]) - vgs;
1669 delvds = (x[dNodePrime] - x[sNodePrime]) - vds;
1670 delvbs = (x[bNodePrime] - x[sNodePrime]) - vbs;
1671 deldeltemp = x[tempNode] - deltemp;
1672
1673 if (delvgs || delvds || delvbs ||deldeltemp) {
1674 Ids += gm *delvgs + gds *delvds + gmbs *delvbs + gmT *deldeltemp ;
1675 Isub += dIsub_dVgs *delvgs + dIsub_dVds *delvds + dIsub_dVbs *delvbs + dIsub_dT *deldeltemp ;
1676 Isubs+= dIsubs_dVgs*delvgs + dIsubs_dVds*delvds + dIsubs_dVbs*delvbs + dIsubs_dT*deldeltemp ;
1677 Igd += dIgd_dVg *delvgs + dIgd_dVd *delvds + dIgd_dVb *delvbs + dIgd_dT *deldeltemp ;
1678 Igs += dIgs_dVg *delvgs + dIgs_dVd *delvds + dIgs_dVb *delvbs + dIgs_dT *deldeltemp ;
1679 Igb += dIgb_dVg *delvgs + dIgb_dVd *delvds + dIgb_dVb *delvbs + dIgb_dT *deldeltemp ;
1680 Igidl+= dIgidl_dVgs*delvgs + dIgidl_dVds*delvds + dIgidl_dVbs*delvbs + dIgidl_dT*deldeltemp ;
1681 Igisl+= dIgisl_dVgs*delvgs + dIgisl_dVds*delvds + dIgisl_dVbs*delvbs + dIgisl_dT*deldeltemp ;
1682 P += dP_dVgs *delvgs + dP_dVds *delvds + dP_dVbs *delvbs + dP_dT *deldeltemp ;
1683 if (flg_nqs) {
1684 Iqi_nqs += dIqi_nqs_dVgs*delvgs + dIqi_nqs_dVds*delvds + dIqi_nqs_dVbs*delvbs + dIqi_nqs_dT*deldeltemp ;
1685 Iqb_nqs += dIqb_nqs_dVgs*delvgs + dIqb_nqs_dVds*delvds + dIqb_nqs_dVbs*delvbs + dIqb_nqs_dT*deldeltemp ;
1686 }
1687 }
1688
1689 delvgse = (x[gNodePrime] - x[sNode]) - vgse;
1690 delvdse = (x[dNode] - x[sNode]) - vdse;
1691 delvbse = (x[bNodePrime] - x[sNode]) - vbse;
1692 if (flg_subNode > 0) delvsubs = (x[subNode] - x[sNode]) - vsubs; /* substrate bias change */
1693
1694 if (delvgse || delvdse || delvbse ) {
1695 Ids += gm_ext *delvgse + gds_ext *delvdse + gmbs_ext *delvbse ;
1696 Isub += dIsub_dVdse*delvdse ;
1697 Isubs+= dIsubs_dVdse*delvdse ;
1698 P += dP_dVgse *delvgse + dP_dVdse *delvdse + dP_dVbse *delvbse ;
1699 Iddp += dIddp_dVgse*delvgse + dIddp_dVdse*delvdse + dIddp_dVbse*delvbse ;
1700 Issp += dIssp_dVgse*delvgse + dIssp_dVdse*delvdse + dIssp_dVbse*delvbse ;
1701 }
1702
1703 if (delvsubs) {
1704 Iddp += dIddp_dVsubs*delvsubs ;
1705 Issp += dIssp_dVsubs*delvsubs ;
1706 }
1707
1708 if (deldeltemp) {
1709 Iddp += dIddp_dT*deldeltemp ;
1710 Issp += dIssp_dT*deldeltemp ;
1711 Ith += dIth_dT *deldeltemp ;
1712 }
1713
1714 delvdbd = (x[dbNode] - x[dNode]) - vbd_jct ;
1715 if (delvdbd || deldeltemp) {
1716 Ibd += Gbd*delvdbd + Gbdt*deldeltemp ;
1717 }
1718
1719 delvsbs = (x[sbNode] - x[sNode]) - vbs_jct ;
1720 if (delvsbs || deldeltemp) {
1721 Ibs += Gbs*delvsbs + Gbst*deldeltemp ;
1722 }
1723
1724 delvddp = (x[dNode] - x[dNodePrime]) - vddp ;
1725 if (delvddp) {
1726 Iddp += dIddp_dVddp * delvddp ;
1727 }
1728
1729 delvssp = (x[sNode] - x[sNodePrime]) - vssp ;
1730 if (delvssp) {
1731 Issp += dIssp_dVssp * delvssp ;
1732 }
1733
1734 delvggp = (x[gNode] - x[gNodePrime]) - vggp ;
1735 if (delvggp) {
1736 Iggp += dIggp_dVggp * delvggp ;
1737 }
1738
1739 delvbpb = (x[bNodePrime] - x[bNode]) - vbpb ;
1740 if (delvbpb) {
1741 Ibpb += dIbpb_dVbpb * delvbpb ;
1742 }
1743
1744 delvbpdb = (x[bNodePrime] - x[dbNode]) - vbpdb ;
1745 if (delvbpdb) {
1746 Ibpdb += dIbpdb_dVbpdb * delvbpdb ;
1747 }
1748
1749 delvbpsb = (x[bNodePrime] - x[sbNode]) - vbpsb ;
1750 if (delvbpsb) {
1751 Ibpsb += dIbpsb_dVbpsb * delvbpsb ;
1752 }
1753
1754 if (flg_nqs) {
1755 delQi_nqs = x[qiNode] - Qi_nqs ;
1756 if (delQi_nqs) {
1757 Iqi_nqs += dIqi_nqs_dQi_nqs * delQi_nqs ;
1758 }
1759 delQb_nqs = x[qbNode] - Qb_nqs ;
1760 if (delQb_nqs) {
1761 Iqb_nqs += dIqb_nqs_dQb_nqs * delQb_nqs ;
1762 }
1763 }
1764
1765
1766 /* Assemble currents into nodes */
1767 /* ... static part */
1768
1769
1770 /* drain node */
1771 i_d = Iddp - Ibd ;
1772 /* intrinsic drain node */
1773 i_dP = -Iddp + Ids + Isub + Igidl - Igd ;
1774 /* gate node */
1775 i_g = Iggp ;
1776 /* intrinsic gate node */
1777 i_gP = - Iggp + Igd + Igs + Igb ;
1778 /* source node */
1779 i_s = Issp - Ibs ;
1780 /* intrinsic source node */
1781 i_sP = - Issp - Ids + Isubs + Igisl - Igs ;
1782 /* intrinsic bulk node */
1783 i_bP = - Isub - Isubs - Igidl -Igb - Igisl + Ibpdb + Ibpb + Ibpsb ;
1784 /* base node */
1785 i_b = - Ibpb ;
1786 /* drain bulk node */
1787 i_db = Ibd - Ibpdb ;
1788 /* source bulk node */
1789 i_sb = Ibs - Ibpsb ;
1790 /* temp node */
1791 if (flg_tempNode > 0){
1792 i_t = Ith - P ;
1793 } else {
1794 i_t = 0.0;
1795 }
1796 /* nqs equations */
1797 i_qi = Iqi_nqs ;
1798 i_qb = Iqb_nqs ;
1799
1800 for (i = 0; i < XDIM; i++) {
1801 ydc_d[i] = ydc_dP[i] = ydc_g[i] = ydc_gP[i] = ydc_s[i] = ydc_sP[i] = ydc_bP[i] = ydc_b[i]
1802 = ydc_db[i] = ydc_sb[i] = ydc_t[i] = 0.0;
1803 }
1804 if (flg_nqs) {
1805 for (i = 0; i < XDIM; i++) {
1806 ydc_qi[i] = ydc_qb[i] = 0.0;
1807 }
1808 }
1809
1810 /* drain node */
1811 ydc_d[dNode] = dIddp_dVddp + dIddp_dVdse + Gbd ;
1812 ydc_d[dNodePrime] = -dIddp_dVddp ;
1813 /* ydc_d[gNode] = 0.0 ; */
1814 ydc_d[gNodePrime] = dIddp_dVgse ;
1815 ydc_d[sNode] = - ( dIddp_dVdse + dIddp_dVgse + dIddp_dVbse ) - dIddp_dVsubs ;
1816 /* ydc_d[sNodePrime] = 0.0 ; */
1817 ydc_d[bNodePrime] = dIddp_dVbse ;
1818 /* ydc_d[bNode] = 0.0 ; */
1819 ydc_d[dbNode] = - Gbd ;
1820 /* ydc_d[sbNode] = 0.0 ; */
1821 ydc_d[subNode] = dIddp_dVsubs ;
1822 ydc_d[tempNode] = dIddp_dT - Gbdt ;
1823
1824 /* intrinsic drain node */
1825 ydc_dP[dNode] = - (dIddp_dVddp + dIddp_dVdse) + gds_ext + dIsub_dVdse ;
1826 ydc_dP[dNodePrime] = dIddp_dVddp + gds + dIsub_dVds + dIgidl_dVds - dIgd_dVd ;
1827 /* ydc_dP[gNode] = 0.0; */
1828 ydc_dP[gNodePrime] = -dIddp_dVgse + gm_ext
1829 + gm + dIsub_dVgs + dIgidl_dVgs - dIgd_dVg ;
1830 ydc_dP[sNode] = dIddp_dVdse + dIddp_dVgse + dIddp_dVbse + dIddp_dVsubs + (-gds_ext -gm_ext -gmbs_ext) - dIsub_dVdse;
1831 ydc_dP[sNodePrime] = -( gds + dIsub_dVds + dIgidl_dVds )
1832 - ( gm + dIsub_dVgs + dIgidl_dVgs )
1833 - ( gmbs + dIsub_dVbs + dIgidl_dVbs ) - dIgd_dVs ;
1834 ydc_dP[bNodePrime] = - dIddp_dVbse + gmbs_ext
1835 + gmbs + dIsub_dVbs + dIgidl_dVbs - dIgd_dVb;
1836 /* ydc_dP[bNode] = 0.0; */
1837 /* ydc_dP[dbNode] = 0.0 ; */
1838 /* ydc_dP[sbNode] = 0.0 ; */
1839 ydc_dP[subNode] = - dIddp_dVsubs ;
1840 ydc_dP[tempNode] = - dIddp_dT
1841 + gmT + dIsub_dT + dIgidl_dT - dIgd_dT ;
1842
1843 /* gate node */
1844 /* ydc_g[dNode] = 0.0 ; */
1845 /* ydc_g[dNodePrime] = 0.0 ; */
1846 ydc_g[gNode] = dIggp_dVggp ;
1847 ydc_g[gNodePrime] = - dIggp_dVggp ;
1848 /* ydc_g[sNode] = 0.0 ; */
1849 /* ydc_g[sNodePrime] = 0.0 ; */
1850 /* ydc_g[bNodePrime] = 0.0 ; */
1851 /* ydc_g[bNode] = 0.0 ; */
1852 /* ydc_g[dbNode] = 0.0 ; */
1853 /* ydc_g[sbNode] = 0.0 ; */
1854 /* ydc_g[tempNode] = 0.0 ; */
1855
1856 /* intrinsic gate node */
1857 /* ydc_gP[dNode] = 0.0 ; */
1858 ydc_gP[dNodePrime] = dIgd_dVd + dIgs_dVd + dIgb_dVd ;
1859 ydc_gP[gNode] = - dIggp_dVggp ;
1860 ydc_gP[gNodePrime] = dIggp_dVggp + dIgd_dVg + dIgs_dVg + dIgb_dVg ;
1861 /* ydc_gP[sNode] = 0.0 ; */
1862 ydc_gP[sNodePrime] = dIgd_dVs + dIgs_dVs + dIgb_dVs ;
1863 ydc_gP[bNodePrime] = dIgd_dVb + dIgs_dVb + dIgb_dVb ;
1864 /* ydc_gP[bNode] = 0.0 ; */
1865 /* ydc_gP[dbNode] = 0.0 ; */
1866 /* ydc_gP[sbNode] = 0.0 ; */
1867 ydc_gP[tempNode] = dIgd_dT + dIgs_dT + dIgb_dT ;
1868
1869 /* source node */
1870 ydc_s[dNode] = dIssp_dVdse;
1871 /* ydc_s[dNodePrime] = 0.0 */
1872 /* ydc_s[gNode] = 0.0 */
1873 ydc_s[gNodePrime] = dIssp_dVgse;
1874 ydc_s[sNode] = dIssp_dVssp - ( dIssp_dVgse + dIssp_dVdse + dIssp_dVbse ) - dIssp_dVsubs + Gbs;
1875 ydc_s[sNodePrime] = - dIssp_dVssp;
1876 ydc_s[bNodePrime] = dIssp_dVbse ;
1877 /* ydc_s[bNode] = 0.0 */
1878 /* ydc_s[dbNode] = 0.0 */
1879 ydc_s[sbNode] = - Gbs ;
1880 ydc_s[subNode] = dIssp_dVsubs;
1881 ydc_s[tempNode] = dIssp_dT - Gbst;
1882
1883 /* intrinsic source node */
1884 ydc_sP[dNode] = - dIssp_dVdse -gds_ext + dIsubs_dVdse ;
1885 ydc_sP[dNodePrime] = - gds + dIsubs_dVds + dIgisl_dVds - dIgs_dVd ;
1886 /* ydc_sP[gNode] = 0.0 ; */
1887 ydc_sP[gNodePrime] = -dIssp_dVgse -gm_ext
1888 - gm + dIsubs_dVgs + dIgisl_dVgs - dIgs_dVg ;
1889 ydc_sP[sNode] = - dIssp_dVssp - ( - dIssp_dVdse - dIssp_dVgse - dIssp_dVbse ) + dIssp_dVsubs +(gds_ext + gm_ext + gmbs_ext) - dIsubs_dVdse;
1890 ydc_sP[sNodePrime] = dIssp_dVssp - ( - gds + dIsubs_dVds + dIgisl_dVds )
1891 - ( - gm + dIsubs_dVgs + dIgisl_dVgs )
1892 - ( - gmbs + dIsubs_dVbs + dIgisl_dVbs ) - dIgs_dVs ;
1893 ydc_sP[bNodePrime] = -dIssp_dVbse -gmbs_ext
1894 - gmbs + dIsubs_dVbs + dIgisl_dVbs - dIgs_dVb ;
1895 /* ydc_sP[bNode] = 0.0 ; */
1896 /* ydc_sP[dbNode] = 0.0 ; */
1897 /* ydc_sP[sbNode] = 0.0 ; */
1898 ydc_sP[subNode] = - dIssp_dVsubs;
1899 ydc_sP[tempNode] = -dIssp_dT
1900 - gmT + dIsubs_dT + dIgisl_dT - dIgs_dT;
1901
1902 /* intrinsic bulk node */
1903 ydc_bP[dNode] = - dIsub_dVdse - dIsubs_dVdse ;
1904 ydc_bP[dNodePrime] = - dIsub_dVds - dIsubs_dVds - dIgidl_dVds - dIgb_dVd - dIgisl_dVds ;
1905 /* ydc_bP[gNode] = 0.0 ; */
1906 ydc_bP[gNodePrime] = - dIsub_dVgs - dIsubs_dVgs - dIgidl_dVgs - dIgb_dVg - dIgisl_dVgs ;
1907 ydc_bP[sNode] = dIsub_dVdse + dIsubs_dVdse;
1908 ydc_bP[sNodePrime] = - ( - dIsub_dVds - dIsubs_dVds - dIgidl_dVds - dIgisl_dVds )
1909 - ( - dIsub_dVgs - dIsubs_dVgs - dIgidl_dVgs - dIgisl_dVgs )
1910 - ( - dIsub_dVbs - dIsubs_dVbs - dIgidl_dVbs - dIgisl_dVbs ) - dIgb_dVs ;
1911 ydc_bP[bNodePrime] = - dIsub_dVbs - dIsubs_dVbs - dIgidl_dVbs - dIgb_dVb - dIgisl_dVbs + dIbpdb_dVbpdb + dIbpb_dVbpb + dIbpsb_dVbpsb ;
1912 ydc_bP[bNode] = - dIbpb_dVbpb ;
1913 ydc_bP[dbNode] = - dIbpdb_dVbpdb ;
1914 ydc_bP[sbNode] = - dIbpsb_dVbpsb ;
1915 ydc_bP[tempNode] = - dIsub_dT - dIsubs_dT - dIgidl_dT - dIgb_dT - dIgisl_dT ;
1916
1917 /* bulk node */
1918 /* ydc_b[dNode] = 0.0 ; */
1919 /* ydc_b[dNodePrime] = 0.0 ; */
1920 /* ydc_b[gNode] = 0.0 ; */
1921 /* ydc_b[gNodePrime] = 0.0 ; */
1922 /* ydc_b[sNode] = 0.0 ; */
1923 /* ydc_b[sNodePrime] = 0.0 ; */
1924 ydc_b[bNodePrime] = - dIbpb_dVbpb ;
1925 ydc_b[bNode] = dIbpb_dVbpb ;
1926 /* ydc_b[dbNode] = 0.0 ; */
1927 /* ydc_b[sbNode] = 0.0 ; */
1928 /* ydc_b[tempNode] = 0.0 ; */
1929
1930 /* drain bulk node */
1931 ydc_db[dNode] = - Gbd ;
1932 /* ydc_db[dNodePrime] = 0.0 ; */
1933 /* ydc_db[gNode] = 0.0 ; */
1934 /* ydc_db[gNodePrime] = 0.0 ; */
1935 /* ydc_db[sNode] = 0.0 ; */
1936 /* ydc_db[sNodePrime] = 0.0 ; */
1937 ydc_db[bNodePrime] = - dIbpdb_dVbpdb ;
1938 /* ydc_db[bNode] = 0.0 ; */
1939 ydc_db[dbNode] = Gbd + dIbpdb_dVbpdb ;
1940 /* ydc_db[sbNode] = 0.0 ; */
1941 ydc_db[tempNode] = Gbdt ;
1942
1943 /* source bulk node */
1944 /* ydc_sb[dNode] = 0.0 ; */
1945 /* ydc_sb[dNodePrime] = 0.0 ; */
1946 /* ydc_sb[gNode] = 0.0 ; */
1947 /* ydc_sb[gNodePrime] = 0.0 ; */
1948 ydc_sb[sNode] = - Gbs ;
1949 /* ydc_sb[sNodePrime] = 0.0 ; */
1950 ydc_sb[bNodePrime] = - dIbpsb_dVbpsb ;
1951 /* ydc_sb[bNode] = 0.0 ; */
1952 /* ydc_sb[dbNode] = 0.0 ; */
1953 ydc_sb[sbNode] = Gbs + dIbpsb_dVbpsb ;
1954 ydc_sb[tempNode] = Gbst ;
1955
1956 /* temp node */
1957 ydc_t[dNode] = - dP_dVdse ;
1958 ydc_t[dNodePrime] = - dP_dVds ;
1959 /* ydc_t[gNode] = 0.0 ; */
1960 ydc_t[gNodePrime] = - dP_dVgs - dP_dVgse ;
1961 ydc_t[sNode] = - ( - dP_dVdse - dP_dVgse - dP_dVbse ) ;
1962 ydc_t[sNodePrime] = - ( - dP_dVds - dP_dVgs - dP_dVbs ) ;
1963 ydc_t[bNodePrime] = - dP_dVbs - dP_dVbse ;
1964 /* ydc_t[bNode] = 0.0 ; */
1965 /* ydc_t[dbNode] = 0.0 ; */
1966 /* ydc_t[sbNode] = 0.0 ; */
1967 ydc_t[tempNode] = dIth_dT - dP_dT ;
1968
1969 /* additional entries for flat nqs handling */
1970 if ( flg_nqs ) {
1971 ydc_qi[dNodePrime] = dIqi_nqs_dVds ;
1972 ydc_qi[gNodePrime] = dIqi_nqs_dVgs ;
1973 ydc_qi[sNodePrime] = -(dIqi_nqs_dVds + dIqi_nqs_dVgs + dIqi_nqs_dVbs) ;
1974 ydc_qi[bNodePrime] = dIqi_nqs_dVbs ;
1975 ydc_qi[tempNode] = dIqi_nqs_dT ;
1976 ydc_qi[qiNode] = dIqi_nqs_dQi_nqs ;
1977 /* ydc_qi[qbNode]= 0.0 ; */
1978 ydc_qb[dNodePrime] = dIqb_nqs_dVds ;
1979 ydc_qb[gNodePrime] = dIqb_nqs_dVgs ;
1980 ydc_qb[sNodePrime] = -(dIqb_nqs_dVds + dIqb_nqs_dVgs + dIqb_nqs_dVbs) ;
1981 ydc_qb[bNodePrime] = dIqb_nqs_dVbs ;
1982 ydc_qb[tempNode] = dIqb_nqs_dT ;
1983 /* ydc_qb[qiNode]= 0.0 ; */
1984 ydc_qb[qbNode] = dIqb_nqs_dQb_nqs ;
1985 }
1986
1987
1988 /* Preset vectors and matrix for dynamic part */
1989
1990 cq_d = cq_dP = cq_g = cq_gP = cq_s = cq_sP = cq_bP = cq_b = cq_db = cq_sb = cq_t = cq_qi = cq_qb = 0.0 ;
1991 for (i = 0; i < XDIM ; i++) {
1992 ydyn_d[i] = ydyn_dP[i] = ydyn_g[i] = ydyn_gP[i] = ydyn_s[i] = ydyn_sP[i] = ydyn_bP[i] = ydyn_b[i]
1993 = ydyn_db[i] = ydyn_sb[i] = ydyn_t[i] = 0.0;
1994 }
1995 if (flg_nqs) {
1996 for (i = 0; i < XDIM ; i++) {
1997 ydyn_qi[i] = ydyn_qb[i] = 0.0;
1998 }
1999 }
2000
2001 ag0 = ckt->CKTag[0];
2002
2003 if (ChargeComputationNeeded) { /* start handling of dynamic part */
2004
2005 if (!ByPass) { /* loading of state vector not necessary in case of Bypass */
2006
2007 /* intrinsic gate node (without fringing charges) */
2008 *(ckt->CKTstate0 + here->HSMHVqg) = Qg + Qg_nqs + Qgext;
2009
2010 /* intrinsic drain node */
2011 *(ckt->CKTstate0 + here->HSMHVqd) = Qd + Qd_nqs ;
2012
2013 /* intrinsic bulk node */
2014 *(ckt->CKTstate0 + here->HSMHVqb) = Qb + Qb_nqs + Qbext;
2015
2016 /* drain bulk node */
2017 *(ckt->CKTstate0 + here->HSMHVqbd) = Qbd ;
2018
2019 /* source bulk node */
2020 *(ckt->CKTstate0 + here->HSMHVqbs) = Qbs ;
2021
2022 /* temp node */
2023 *(ckt->CKTstate0 + here->HSMHVqth) = Qth ;
2024
2025 /* fringing charges */
2026 *(ckt->CKTstate0 + here->HSMHVqfd) = Qfd ;
2027 *(ckt->CKTstate0 + here->HSMHVqfs) = Qfs ;
2028
2029 /* external drain node */
2030 *(ckt->CKTstate0 + here->HSMHVqdE) = Qdext;
2031
2032 /* nqs charges Qi_nqs, Qb_nqs: already loaded above */
2033 /* if ( flg_nqs ) { */
2034 /* *(ckt->CKTstate0 + here->HSMHVqi_nqs) = Qi_nqs; */
2035 /* *(ckt->CKTstate0 + here->HSMHVqb_nqs) = Qb_nqs; */
2036 /* } */
2037 }
2038
2039 /* ... assemble capacitance matrix */
2040
2041 /* ...... drain node */
2042 ydyn_d[dNode] = dQfd_dVdse + Cbd + dQdext_dVdse ;
2043 /* ydyn_d[dNodePrime] = 0.0 ; */
2044 /* ydyn_d[gNode] = 0.0 ; */
2045 ydyn_d[gNodePrime] = dQfd_dVgse + dQdext_dVgse ;
2046 ydyn_d[sNode] = - (dQfd_dVdse + dQfd_dVgse+ dQfd_dVbse) - ( dQdext_dVdse + dQdext_dVgse + dQdext_dVbse ) ;
2047 /* ydyn_d[sNodePrime ] = 0.0 ; */
2048 ydyn_d[bNodePrime] = dQfd_dVbse + dQdext_dVbse;
2049 /* ydyn_d[bNode ] = 0.0 ; */
2050 ydyn_d[dbNode] = - Cbd ;
2051 /* ydyn_d[sbNode ] = 0.0 ; */
2052 ydyn_d[tempNode] = dQfd_dT - Cbdt + dQdext_dT ;
2053
2054 /* ...... intrinsic drain node */
2055 /* ydyn_dP[dNode] = 0.0 ; */
2056 ydyn_dP[dNodePrime] = dQd_dVds ;
2057 /* ydyn_dP[gNode] = 0.0 ; */
2058 ydyn_dP[gNodePrime] = dQd_dVgs ;
2059 /* ydyn_dP[sNode] = 0.0 ; */
2060 ydyn_dP[sNodePrime] = - ( dQd_dVds + dQd_dVgs + dQd_dVbs ) ;
2061 ydyn_dP[bNodePrime] = dQd_dVbs ;
2062 /* ydyn_dP[bNode] = 0.0 ; */
2063 /* ydyn_dP[dbNode] = 0.0 ; */
2064 /* ydyn_dP[sbNode] = 0.0 ; */
2065 ydyn_dP[tempNode] = dQd_dT ;
2066
2067 /* ...... gate node */
2068 /* (no entry) */
2069
2070 /* ...... intrinsic gate node */
2071 ydyn_gP[dNode] = -dQfd_dVdse - dQfs_dVdse + dQgext_dVdse ;
2072 ydyn_gP[dNodePrime] = dQg_dVds ;
2073 /* ydyn_gP[gNode] = 0.0 ; */
2074 ydyn_gP[gNodePrime] = dQg_dVgs -dQfd_dVgse - dQfs_dVgse + dQgext_dVgse ;
2075 ydyn_gP[sNode] = dQfd_dVdse + dQfs_dVdse + dQfd_dVgse + dQfs_dVgse + dQfd_dVbse + dQfs_dVbse
2076 - ( dQgext_dVdse + dQgext_dVgse + dQgext_dVbse ) ;
2077 ydyn_gP[sNodePrime] = -( dQg_dVds + dQg_dVgs + dQg_dVbs ) ;
2078 ydyn_gP[bNodePrime] = dQg_dVbs -dQfd_dVbse - dQfs_dVbse + dQgext_dVbse ;
2079 /* ydyn_gP[bNode] = 0.0 ; */
2080 /* ydyn_gP[dbNode] = 0.0 ; */
2081 /* ydyn_gP[sbNode] = 0.0 ; */
2082 ydyn_gP[tempNode] = dQg_dT - dQfd_dT - dQfs_dT + dQgext_dT ;
2083
2084 /* ...... source node */
2085 ydyn_s[dNode] = dQfs_dVdse + dQsext_dVdse ;
2086 /* ydyn_d[dNodePrime ] = 0.0 ; */
2087 /* ydyn_d[gNode ] = 0.0 ; */
2088 ydyn_s[gNodePrime] = dQfs_dVgse + dQsext_dVgse ;
2089 ydyn_s[sNode] = Cbs - (dQfs_dVdse + dQfs_dVgse+ dQfs_dVbse) - ( dQsext_dVdse + dQsext_dVgse + dQsext_dVbse ) ;
2090 /* ydyn_d[sNodePrime ] = 0.0 ; */
2091 ydyn_s[bNodePrime] = dQfs_dVbse + dQsext_dVbse ;
2092 /* ydyn_d[bNode ] = 0.0 ; */
2093 /* ydyn_d[dbNode ] = 0.0 ; */
2094 ydyn_s[sbNode] = - Cbs ;
2095 ydyn_s[tempNode] = dQfs_dT - Cbst + dQsext_dT ;
2096
2097 /* ...... intrinsic source node */
2098 /* ydyn_sP[dNode] = 0.0 ; */
2099 ydyn_sP[dNodePrime] = dQs_dVds ;
2100 /* ydyn_sP[gNode] = 0.0 ; */
2101 ydyn_sP[gNodePrime] = dQs_dVgs ;
2102 /* ydyn_sP[sNode] = 0.0 ; */
2103 ydyn_sP[sNodePrime] = - ( dQs_dVds + dQs_dVgs + dQs_dVbs );
2104 ydyn_sP[bNodePrime] = dQs_dVbs ;
2105 /* ydyn_sP[bNode] = 0.0 ; */
2106 /* ydyn_sP[dbNode] = 0.0 ; */
2107 /* ydyn_sP[sbNode] = 0.0 ; */
2108 ydyn_sP[tempNode] = dQs_dT ;
2109
2110 /* ...... intrinsic bulk node */
2111 ydyn_bP[dNode] = dQbext_dVdse ;
2112 ydyn_bP[dNodePrime] = dQb_dVds ;
2113 /* ydyn_bP[gNode] = 0.0 ; */
2114 ydyn_bP[gNodePrime] = dQb_dVgs + dQbext_dVgse ;
2115 ydyn_bP[sNode] = - ( dQbext_dVdse + dQbext_dVgse + dQbext_dVbse ) ;
2116 ydyn_bP[sNodePrime] = - ( dQb_dVds + dQb_dVgs + dQb_dVbs );
2117 ydyn_bP[bNodePrime] = dQb_dVbs + dQbext_dVbse ;
2118 /* ydyn_bP[bNode] = 0.0 ; */
2119 /* ydyn_bP[dbNode] = 0.0 ; */
2120 /* ydyn_bP[sbNode] = 0.0 ; */
2121 ydyn_bP[tempNode] = dQb_dT + dQbext_dT ;
2122
2123 /* ...... bulk node */
2124 /* (no entry) */
2125
2126 /* ...... drain bulk node */
2127 ydyn_db[dNode] = - Cbd ;
2128 /* ydyn_db[dNodePrime] = 0.0 ; */
2129 /* ydyn_db[gNode] = 0.0 ; */
2130 /* ydyn_db[gNodePrime] = 0.0 ; */
2131 /* ydyn_db[sNode] = 0.0 ; */
2132 /* ydyn_db[sNodePrime] = 0.0 ; */
2133 /* ydyn_db[bNodePrime] = 0.0 ; */
2134 /* ydyn_db[bNode] = 0.0 ; */
2135 ydyn_db[dbNode] = Cbd ;
2136 /* ydyn_db[sbNode] = 0.0 ; */
2137 ydyn_db[tempNode] = Cbdt ;
2138
2139 /* ...... source bulk node */
2140 /* ydyn_sb[dNode] = 0.0 ; */
2141 /* ydyn_sb[dNodePrime] = 0.0 ; */
2142 /* ydyn_sb[gNode] = 0.0 ; */
2143 /* ydyn_sb[gNodePrime] = 0.0 ; */
2144 ydyn_sb[sNode] = - Cbs ;
2145 /* ydyn_sb[sNodePrime] = 0.0 ; */
2146 /* ydyn_sb[bNodePrime] = 0.0 ; */
2147 /* ydyn_sb[bNode] = 0.0 ; */
2148 /* ydyn_sb[dbNode] = 0.0 ; */
2149 ydyn_sb[sbNode] = Cbs ;
2150 ydyn_sb[tempNode] = Cbst ;
2151
2152 /* ...... temp node */
2153 /* ydyn_t[dNode] = 0.0 ; */
2154 /* ydyn_t[dNodePrime] = 0.0 ; */
2155 /* ydyn_t[gNode] = 0.0 ; */
2156 /* ydyn_t[gNodePrime] = 0.0 ; */
2157 /* ydyn_t[sNode] = 0.0 ; */
2158 /* ydyn_t[sNodePrime] = 0.0 ; */
2159 /* ydyn_t[bNodePrime] = 0.0 ; */
2160 /* ydyn_t[bNode] = 0.0 ; */
2161 /* ydyn_t[dbNode] = 0.0 ; */
2162 /* ydyn_t[sbNode] = 0.0 ; */
2163 ydyn_t[tempNode] = Cth ;
2164
2165 /* additional entries for flat nqs handling */
2166 if (flg_nqs) {
2167 /* ...... intrinsic drain node */
2168 /* ydyn_dP[dNode] += 0.0 ; */
2169 ydyn_dP[dNodePrime] += dQd_nqs_dVds ;
2170 /* ydyn_dP[gNode] += 0.0 ; */
2171 ydyn_dP[gNodePrime] += dQd_nqs_dVgs ;
2172 /* ydyn_dP[sNode] += 0.0 ; */
2173 ydyn_dP[sNodePrime] += - ( dQd_nqs_dVds + dQd_nqs_dVgs + dQd_nqs_dVbs ) ;
2174 ydyn_dP[bNodePrime] += dQd_nqs_dVbs ;
2175 /* ydyn_dP[bNode] += 0.0 ; */
2176 /* ydyn_dP[dbNode] += 0.0 ; */
2177 /* ydyn_dP[sbNode] += 0.0 ; */
2178 ydyn_dP[tempNode] += dQd_nqs_dT ;
2179 ydyn_dP[qiNode] = dQd_nqs_dQi_nqs ;
2180
2181 /* ...... intrinsic gate node */
2182 /* ydyn_gP[dNode] += 0.0 ; */
2183 /* ydyn_gP[dNodePrime] += 0.0 ; */
2184 /* ydyn_gP[gNode] += 0.0 ; */
2185 /* ydyn_gP[gNodePrime] += 0.0 ; */
2186 /* ydyn_gP[sNode] += 0.0 ; */
2187 /* ydyn_gP[sNodePrime] += 0.0 ; */
2188 /* ydyn_gP[bNodePrime] += 0.0 ; */
2189 /* ydyn_gP[bNode] += 0.0 ; */
2190 /* ydyn_gP[dbNode] += 0.0 ; */
2191 /* ydyn_gP[sbNode] += 0.0 ; */
2192 /* ydyn_gP[tempNode] += 0.0 ; */
2193 ydyn_gP[qiNode] = dQg_nqs_dQi_nqs ;
2194 ydyn_gP[qbNode] = dQg_nqs_dQb_nqs ;
2195
2196 /* ...... intrinsic source node */
2197 /* ydyn_sP[dNode] += 0.0 ; */
2198 ydyn_sP[dNodePrime] += dQs_nqs_dVds ;
2199 /* ydyn_sP[gNode] += 0.0 ; */
2200 ydyn_sP[gNodePrime] += dQs_nqs_dVgs ;
2201 /* ydyn_sP[sNode] += 0.0 ; */
2202 ydyn_sP[sNodePrime] += - ( dQs_nqs_dVds + dQs_nqs_dVgs + dQs_nqs_dVbs );
2203 ydyn_sP[bNodePrime] += dQs_nqs_dVbs ;
2204 /* ydyn_sP[bNode] += 0.0 ; */
2205 /* ydyn_sP[dbNode] += 0.0 ; */
2206 /* ydyn_sP[sbNode] += 0.0 ; */
2207 ydyn_sP[tempNode] += dQs_nqs_dT ;
2208 ydyn_sP[qiNode] = dQs_nqs_dQi_nqs ;
2209
2210 /* ...... intrinsic bulk node */
2211 /* ydyn_bP[dNode] += 0.0 ; */
2212 /* ydyn_bP[dNodePrime] += 0.0 ; */
2213 /* ydyn_bP[gNode] += 0.0 ; */
2214 /* ydyn_bP[gNodePrime] += 0.0 ; */
2215 /* ydyn_bP[sNode] += 0.0 ; */
2216 /* ydyn_bP[sNodePrime] += 0.0 ; */
2217 /* ydyn_bP[bNodePrime] += 0.0 ; */
2218 /* ydyn_bP[bNode] += 0.0 ; */
2219 /* ydyn_bP[dbNode] += 0.0 ; */
2220 /* ydyn_bP[sbNode] += 0.0 ; */
2221 /* ydyn_bP[tempNode] += 0.0 ; */
2222 ydyn_bP[qbNode] = 1.0 ;
2223
2224 /* ...... qi node */
2225 /* ydyn_qi[dNodePrime] = 0.0 ; */
2226 /* ydyn_qi[gNodePrime] = 0.0 ; */
2227 /* ydyn_qi[sNodePrime] = 0.0 ; */
2228 /* ydyn_qi[bNodePrime] = 0.0 ; */
2229 /* ydyn_qi[tempNode] = 0.0 ; */
2230 ydyn_qi[qiNode] = 1.0 ;
2231 /* ydyn_qi[qbNode] = 0.0 ; */
2232
2233 /* ...... qb node */
2234 /* ydyn_qb[dNodePrime] = 0.0 ; */
2235 /* ydyn_qb[gNodePrime] = 0.0 ; */
2236 /* ydyn_qb[sNodePrime] = 0.0 ; */
2237 /* ydyn_qb[bNodePrime] = 0.0 ; */
2238 /* ydyn_qb[tempNode] = 0.0 ; */
2239 /* ydyn_qb[qiNode] = 0.0 ; */
2240 ydyn_qb[qbNode] = 1.0 ;
2241 }
2242
2243 if (!ByPass) { /* integrate etc. only necessary if not in Bypass mode! */
2244
2245 /* store small signal parameters */
2246 if (ckt->CKTmode & MODEINITSMSIG) {
2247 /* printf("HSMHV_load: (small signal) ByPass=%d\n",ByPass); */
2248 /* printf("HSMHV_load: ydc_dP=%e %e %e %e %e %e %e %e\n",
2249 ydc_dP[0],ydc_dP[1],ydc_dP[2],ydc_dP[3],ydc_dP[4],ydc_dP[5],ydc_dP[6],ydc_dP[7]);
2250 printf("HSMHV_load: ych_dP=%e %e %e %e %e %e %e %e\n",
2251 ydyn_dP[0],ydyn_dP[1],ydyn_dP[2],ydyn_dP[3],ydyn_dP[4],ydyn_dP[5],ydyn_dP[6],ydyn_dP[7]);
2252 */
2253 /* dc matrix into structure 0724*/
2254 for (i = 0; i < XDIM; i++) {
2255 here->HSMHV_ydc_d[i] = ydc_d[i];
2256 here->HSMHV_ydc_dP[i] = ydc_dP[i];
2257 here->HSMHV_ydc_g[i] = ydc_g[i];
2258 here->HSMHV_ydc_gP[i] = ydc_gP[i];
2259 here->HSMHV_ydc_s[i] = ydc_s[i];
2260 here->HSMHV_ydc_sP[i] = ydc_sP[i];
2261 here->HSMHV_ydc_bP[i] = ydc_bP[i];
2262 here->HSMHV_ydc_b[i] = ydc_b[i];
2263 here->HSMHV_ydc_db[i] = ydc_db[i];
2264 here->HSMHV_ydc_sb[i] = ydc_sb[i];
2265 here->HSMHV_ydc_t[i] = ydc_t[i];
2266 }
2267 /* capacitance matrix into structure 0724*/
2268 for (i = 0; i < XDIM; i++) {
2269 here->HSMHV_ydyn_d[i] = ydyn_d[i];
2270 here->HSMHV_ydyn_dP[i] = ydyn_dP[i];
2271 here->HSMHV_ydyn_g[i] = ydyn_g[i];
2272 here->HSMHV_ydyn_gP[i] = ydyn_gP[i];
2273 here->HSMHV_ydyn_s[i] = ydyn_s[i];
2274 here->HSMHV_ydyn_sP[i] = ydyn_sP[i];
2275 here->HSMHV_ydyn_bP[i] = ydyn_bP[i];
2276 here->HSMHV_ydyn_b[i] = ydyn_b[i];
2277 here->HSMHV_ydyn_db[i] = ydyn_db[i];
2278 here->HSMHV_ydyn_sb[i] = ydyn_sb[i];
2279 here->HSMHV_ydyn_t[i] = ydyn_t[i];
2280 }
2281 if (flg_nqs) {
2282 for (i = 0; i < XDIM; i++) {
2283 here->HSMHV_ydc_qi[i] = ydc_qi[i];
2284 here->HSMHV_ydc_qb[i] = ydc_qb[i];
2285 here->HSMHV_ydyn_qi[i] = ydyn_qi[i];
2286 here->HSMHV_ydyn_qb[i] = ydyn_qb[i];
2287 }
2288 }
2289 goto line1000; /* that's all for small signal analyses */
2290 }
2291
2292 /* Continue handling of dynamic part: */
2293 /* ... calculate time derivatives of node charges */
2294
2295 if (ckt->CKTmode & MODEINITTRAN) {
2296 /* at the very first iteration of the first timepoint:
2297 copy charges into previous state -> the integrator may use them ... */
2298 *(ckt->CKTstate1 + here->HSMHVqb) = *(ckt->CKTstate0 + here->HSMHVqb);
2299 *(ckt->CKTstate1 + here->HSMHVqg) = *(ckt->CKTstate0 + here->HSMHVqg);
2300 *(ckt->CKTstate1 + here->HSMHVqd) = *(ckt->CKTstate0 + here->HSMHVqd);
2301 *(ckt->CKTstate1 + here->HSMHVqth) = *(ckt->CKTstate0 + here->HSMHVqth);
2302 *(ckt->CKTstate1 + here->HSMHVqbs) = *(ckt->CKTstate0 + here->HSMHVqbs);
2303 *(ckt->CKTstate1 + here->HSMHVqbd) = *(ckt->CKTstate0 + here->HSMHVqbd);
2304
2305 *(ckt->CKTstate1 + here->HSMHVqfd) = *(ckt->CKTstate0 + here->HSMHVqfd);
2306 *(ckt->CKTstate1 + here->HSMHVqfs) = *(ckt->CKTstate0 + here->HSMHVqfs);
2307
2308 *(ckt->CKTstate1 + here->HSMHVqdE) = *(ckt->CKTstate0 + here->HSMHVqdE);
2309
2310 if (flg_nqs) {
2311 *(ckt->CKTstate1 + here->HSMHVqi_nqs) = *(ckt->CKTstate0 + here->HSMHVqi_nqs);
2312 *(ckt->CKTstate1 + here->HSMHVqb_nqs) = *(ckt->CKTstate0 + here->HSMHVqb_nqs);
2313 }
2314 }
2315
2316 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqb));
2317 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqg));
2318 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqd));
2319 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqbs));
2320 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqbd));
2321
2322 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqth));
2323
2324 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqfd));
2325 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqfs));
2326
2327 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqdE));
2328
2329 if (flg_nqs) {
2330 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqi_nqs));
2331 return_if_error (NIintegrate(ckt, &geq, &ceq, 0.0, here->HSMHVqb_nqs));
2332 }
2333
2334 if (ckt->CKTmode & MODEINITTRAN) {
2335 /* at the very first iteration of the first timepoint:
2336 copy currents into previous state -> the integrator may use them ... */
2337 *(ckt->CKTstate1 + here->HSMHVcqb) = *(ckt->CKTstate0 + here->HSMHVcqb);
2338 *(ckt->CKTstate1 + here->HSMHVcqg) = *(ckt->CKTstate0 + here->HSMHVcqg);
2339 *(ckt->CKTstate1 + here->HSMHVcqd) = *(ckt->CKTstate0 + here->HSMHVcqd);
2340
2341 *(ckt->CKTstate1 + here->HSMHVcqth) = *(ckt->CKTstate0 + here->HSMHVcqth);
2342
2343 *(ckt->CKTstate1 + here->HSMHVcqbs) = *(ckt->CKTstate0 + here->HSMHVcqbs);
2344 *(ckt->CKTstate1 + here->HSMHVcqbd) = *(ckt->CKTstate0 + here->HSMHVcqbd);
2345 *(ckt->CKTstate1 + here->HSMHVcqfd) = *(ckt->CKTstate0 + here->HSMHVcqfd);
2346 *(ckt->CKTstate1 + here->HSMHVcqfs) = *(ckt->CKTstate0 + here->HSMHVcqfs);
2347
2348 *(ckt->CKTstate1 + here->HSMHVcqdE) = *(ckt->CKTstate0 + here->HSMHVcqdE);
2349 if (flg_nqs) {
2350 *(ckt->CKTstate1 + here->HSMHVdotqi_nqs) = *(ckt->CKTstate0 + here->HSMHVdotqi_nqs);
2351 *(ckt->CKTstate1 + here->HSMHVdotqb_nqs) = *(ckt->CKTstate0 + here->HSMHVdotqb_nqs);
2352 }
2353 }
2354 }
2355
2356
2357 /* ... finally gather displacement currents from data structures */
2358
2359 cq_dP = *(ckt->CKTstate0 + here->HSMHVcqd);
2360 cq_gP = *(ckt->CKTstate0 + here->HSMHVcqg);
2361 cq_bP = *(ckt->CKTstate0 + here->HSMHVcqb);
2362 cq_sP = - *(ckt->CKTstate0 + here->HSMHVcqg)
2363 - *(ckt->CKTstate0 + here->HSMHVcqb)
2364 - *(ckt->CKTstate0 + here->HSMHVcqd);
2365 cq_dE = *(ckt->CKTstate0 + here->HSMHVcqdE);
2366 cq_db = *(ckt->CKTstate0 + here->HSMHVcqbd);
2367 cq_sb = *(ckt->CKTstate0 + here->HSMHVcqbs);
2368 cq_g = 0.0 ;
2369 cq_b = 0.0 ;
2370
2371 /* displacement currents at outer drain/source node (fringing part only!) */
2372 cq_d = *(ckt->CKTstate0 + here->HSMHVcqfd);
2373 cq_s = *(ckt->CKTstate0 + here->HSMHVcqfs);
2374
2375 cq_t = *(ckt->CKTstate0 + here->HSMHVcqth);
2376
2377 /* displacement currents due to nqs */
2378 if (flg_nqs) {
2379 cq_qi = *(ckt->CKTstate0 + here->HSMHVdotqi_nqs);
2380 cq_qb = *(ckt->CKTstate0 + here->HSMHVdotqb_nqs);
2381 } else {
2382 cq_qi = cq_qb = 0.0 ;
2383 }
2384
2385 /* ... and, if necessary: Extrapolate displacement currents onto x-values */
2386
2387 if (delvdbd || deldeltemp) {
2388 cq_db += ag0*(Cbd*delvdbd + Cbdt*deldeltemp) ;
2389 }
2390 if (delvsbs || deldeltemp) {
2391 cq_sb += ag0*(Cbs*delvsbs + Cbst*deldeltemp) ;
2392 }
2393 if (delvgs || delvds || delvbs || deldeltemp) {
2394 cq_gP += ag0*(dQg_dVgs*delvgs + dQg_dVds*delvds + dQg_dVbs*delvbs + dQg_dT*deldeltemp) ;
2395 cq_dP += ag0*(dQd_dVgs*delvgs + dQd_dVds*delvds + dQd_dVbs*delvbs + dQd_dT*deldeltemp) ;
2396 cq_sP += ag0*(dQs_dVgs*delvgs + dQs_dVds*delvds + dQs_dVbs*delvbs + dQs_dT*deldeltemp) ;
2397 cq_bP = - ( cq_gP + cq_dP + cq_sP );
2398 }
2399 if (deldeltemp) {
2400 cq_t += ag0*Cth *deldeltemp ;
2401 cq_d += ag0*dQfd_dT*deldeltemp ;
2402 cq_s += ag0*dQfs_dT*deldeltemp ;
2403
2404 cq_gE += ag0*dQgext_dT*deldeltemp ;
2405 cq_dE += ag0*dQdext_dT*deldeltemp ;
2406 cq_bE += ag0*dQbext_dT*deldeltemp ;
2407 cq_sE = - ( cq_gE + cq_dE + cq_bE );
2408 }
2409 if (delvgse || delvdse || delvbse) {
2410 cq_d += ag0*(dQfd_dVgse*delvgse + dQfd_dVdse*delvdse + dQfd_dVbse*delvbse) ;
2411 cq_s += ag0*(dQfs_dVgse*delvgse + dQfs_dVdse*delvdse + dQfs_dVbse*delvbse) ;
2412
2413 cq_gE += ag0*(dQgext_dVgse*delvgse + dQgext_dVdse*delvdse + dQgext_dVbse*delvbse) ;
2414 cq_dE += ag0*(dQdext_dVgse*delvgse + dQdext_dVdse*delvdse + dQdext_dVbse*delvbse) ;
2415 cq_bE += ag0*(dQbext_dVgse*delvgse + dQbext_dVdse*delvdse + dQbext_dVbse*delvbse) ;
2416 cq_sE = - ( cq_gE + cq_dE + cq_bE );
2417 }
2418
2419 if (flg_nqs) {
2420 if (delvgs || delvds || delvbs || deldeltemp) {
2421 cq_dP += ag0*(dQd_nqs_dVgs*delvgs + dQd_nqs_dVds*delvds + dQd_nqs_dVbs*delvbs + dQd_nqs_dT*deldeltemp) ;
2422 cq_sP += ag0*(dQs_nqs_dVgs*delvgs + dQs_nqs_dVds*delvds + dQs_nqs_dVbs*delvbs + dQs_nqs_dT*deldeltemp) ;
2423 cq_bP = - ( cq_gP + cq_dP + cq_sP ); /* should be superfluous ? */
2424 }
2425 if (delQi_nqs) {
2426 cq_dP += ag0*dQd_nqs_dQi_nqs*delQi_nqs ;
2427 cq_gP += ag0*dQg_nqs_dQi_nqs*delQi_nqs ;
2428 cq_sP += ag0*dQs_nqs_dQi_nqs*delQi_nqs ;
2429 cq_qi += ag0* 1.0 *delQi_nqs ;
2430 }
2431 if (delQb_nqs) {
2432 cq_gP += ag0*dQg_nqs_dQb_nqs*delQb_nqs ;
2433 cq_bP += ag0* 1.0 *delQb_nqs ;
2434 cq_qb += ag0* 1.0 *delQb_nqs ;
2435 }
2436 }
2437 } /* End of handling dynamic part */
2438
2439
2440 /* Assemble total node currents (type-handling shifted to stamping) */
2441
2442 cur_d = i_d + cq_d - cq_db + cq_dE ;
2443 cur_dP = i_dP + cq_dP ;
2444 cur_g = i_g + cq_g ;
2445 cur_gP = i_gP + cq_gP - cq_d - cq_s + cq_gE ;
2446 cur_s = i_s + cq_s - cq_sb + cq_sE ;
2447 cur_sP = i_sP + cq_sP;
2448 cur_bP = i_bP + cq_bP + cq_bE ;
2449 cur_b = i_b + cq_b;
2450 cur_db = i_db + cq_db;
2451 cur_sb = i_sb + cq_sb;
2452 cur_t = i_t + cq_t;
2453 cur_qi = i_qi + cq_qi;
2454 cur_qb = i_qb + cq_qb;
2455
2456
2457 /* Now we can start stamping ... */
2458 /* ... right hand side: subtract total node currents */
2459
2460 *(ckt->CKTrhs + here->HSMHVdNode) -= model->HSMHV_type * cur_d;
2461 *(ckt->CKTrhs + here->HSMHVdNodePrime) -= model->HSMHV_type * cur_dP;
2462 *(ckt->CKTrhs + here->HSMHVgNode) -= model->HSMHV_type * cur_g;
2463 *(ckt->CKTrhs + here->HSMHVgNodePrime) -= model->HSMHV_type * cur_gP;
2464 *(ckt->CKTrhs + here->HSMHVsNode) -= model->HSMHV_type * cur_s;
2465 *(ckt->CKTrhs + here->HSMHVsNodePrime) -= model->HSMHV_type * cur_sP;
2466 *(ckt->CKTrhs + here->HSMHVbNodePrime) -= model->HSMHV_type * cur_bP;
2467 *(ckt->CKTrhs + here->HSMHVbNode) -= model->HSMHV_type * cur_b;
2468 *(ckt->CKTrhs + here->HSMHVdbNode) -= model->HSMHV_type * cur_db;
2469 *(ckt->CKTrhs + here->HSMHVsbNode) -= model->HSMHV_type * cur_sb;
2470 if( flg_tempNode > 0) {
2471 *(ckt->CKTrhs + here->HSMHVtempNode) -= cur_t; /* temp node independent of model type! */
2472 }
2473 if (flg_nqs) {
2474 *(ckt->CKTrhs + here->HSMHVqiNode) -= cur_qi;
2475 *(ckt->CKTrhs + here->HSMHVqbNode) -= cur_qb;
2476 }
2477
2478
2479 /* ... finally stamp matrix */
2480
2481 /*drain*/
2482 *(here->HSMHVDdPtr) += ydc_d[dNode] + ag0*ydyn_d[dNode];
2483 *(here->HSMHVDdpPtr) += ydc_d[dNodePrime] + ag0*ydyn_d[dNodePrime];
2484 *(here->HSMHVDgpPtr) += ydc_d[gNodePrime] + ag0*ydyn_d[gNodePrime];
2485 *(here->HSMHVDsPtr) += ydc_d[sNode] + ag0*ydyn_d[sNode];
2486 *(here->HSMHVDspPtr) += ydc_d[sNodePrime] + ag0*ydyn_d[sNodePrime];
2487 *(here->HSMHVDbpPtr) += ydc_d[bNodePrime] + ag0*ydyn_d[bNodePrime];
2488 *(here->HSMHVDdbPtr) += ydc_d[dbNode] + ag0*ydyn_d[dbNode];
2489 if (flg_subNode > 0) {
2490 *(here->HSMHVDsubPtr) += ydc_d[subNode];
2491 }
2492 if( flg_tempNode > 0) {
2493 /* temp entries in matrix dependent on model type */
2494 *(here->HSMHVDtempPtr) += model->HSMHV_type * (ydc_d[tempNode] + ag0*ydyn_d[tempNode]);
2495 }
2496
2497 /*drain prime*/
2498 *(here->HSMHVDPdPtr) += ydc_dP[dNode] + ag0*ydyn_dP[dNode];
2499 *(here->HSMHVDPdpPtr) += ydc_dP[dNodePrime] + ag0*ydyn_dP[dNodePrime];
2500 *(here->HSMHVDPgpPtr) += ydc_dP[gNodePrime] + ag0*ydyn_dP[gNodePrime];
2501 *(here->HSMHVDPsPtr) += ydc_dP[sNode] + ag0*ydyn_dP[sNode];
2502 *(here->HSMHVDPspPtr) += ydc_dP[sNodePrime] + ag0*ydyn_dP[sNodePrime];
2503 *(here->HSMHVDPbpPtr) += ydc_dP[bNodePrime] + ag0*ydyn_dP[bNodePrime];
2504 if (flg_subNode > 0) {
2505 *(here->HSMHVDPsubPtr) += ydc_dP[subNode];
2506 }
2507 if( flg_tempNode > 0) {
2508 /* temp entries in matrix dependent on model type */
2509 *(here->HSMHVDPtempPtr) += model->HSMHV_type * (ydc_dP[tempNode] + ag0*ydyn_dP[tempNode]);
2510 }
2511 if (flg_nqs) {
2512 *(here->HSMHVDPqiPtr) += model->HSMHV_type * (ydc_dP[qiNode] + ag0*ydyn_dP[qiNode]);
2513 }
2514
2515 /*gate*/
2516 *(here->HSMHVGgPtr) += ydc_g[gNode] + ag0*ydyn_g[gNode];
2517 *(here->HSMHVGgpPtr) += ydc_g[gNodePrime] + ag0*ydyn_g[gNodePrime];
2518
2519 /*gate prime*/
2520 *(here->HSMHVGPdPtr) += ydc_gP[dNode] + ag0*ydyn_gP[dNode];
2521 *(here->HSMHVGPdpPtr) += ydc_gP[dNodePrime] + ag0*ydyn_gP[dNodePrime];
2522 *(here->HSMHVGPgPtr) += ydc_gP[gNode] + ag0*ydyn_gP[gNode];
2523 *(here->HSMHVGPgpPtr) += ydc_gP[gNodePrime] + ag0*ydyn_gP[gNodePrime];
2524 *(here->HSMHVGPsPtr) += ydc_gP[sNode] + ag0*ydyn_gP[sNode];
2525 *(here->HSMHVGPspPtr) += ydc_gP[sNodePrime] + ag0*ydyn_gP[sNodePrime];
2526 *(here->HSMHVGPbpPtr) += ydc_gP[bNodePrime] + ag0*ydyn_gP[bNodePrime];
2527 if( flg_tempNode > 0) {
2528 /* temp entries in matrix dependent on model type */
2529 *(here->HSMHVGPtempPtr) += model->HSMHV_type * (ydc_gP[tempNode] + ag0*ydyn_gP[tempNode]);
2530 }
2531 if (flg_nqs) {
2532 *(here->HSMHVGPqiPtr) += model->HSMHV_type * (ydc_gP[qiNode] + ag0*ydyn_gP[qiNode]);
2533 *(here->HSMHVGPqbPtr) += model->HSMHV_type * (ydc_gP[qbNode] + ag0*ydyn_gP[qbNode]);
2534 }
2535
2536 /*source*/
2537 *(here->HSMHVSdPtr) += ydc_s[dNode] + ag0*ydyn_s[dNode];
2538 *(here->HSMHVSsPtr) += ydc_s[sNode] + ag0*ydyn_s[sNode];
2539 *(here->HSMHVSdpPtr) += ydc_s[dNodePrime] + ag0*ydyn_s[dNodePrime];
2540 *(here->HSMHVSgpPtr) += ydc_s[gNodePrime] + ag0*ydyn_s[gNodePrime];
2541 *(here->HSMHVSspPtr) += ydc_s[sNodePrime] + ag0*ydyn_s[sNodePrime];
2542 *(here->HSMHVSbpPtr) += ydc_s[bNodePrime] + ag0*ydyn_s[bNodePrime];
2543 *(here->HSMHVSsbPtr) += ydc_s[sbNode] + ag0*ydyn_s[sbNode];
2544 if (flg_subNode > 0) {
2545 *(here->HSMHVSsubPtr) += ydc_s[subNode];
2546 }
2547 if( flg_tempNode > 0) {
2548 /* temp entries in matrix dependent on model type */
2549 *(here->HSMHVStempPtr) += model->HSMHV_type * (ydc_s[tempNode]+ ag0*ydyn_s[tempNode]);
2550 }
2551
2552 /*source prime*/
2553 *(here->HSMHVSPdPtr) += ydc_sP[dNode] + ag0*ydyn_sP[dNode];
2554 *(here->HSMHVSPdpPtr) += ydc_sP[dNodePrime] + ag0*ydyn_sP[dNodePrime];
2555 *(here->HSMHVSPgpPtr) += ydc_sP[gNodePrime] + ag0*ydyn_sP[gNodePrime];
2556 *(here->HSMHVSPsPtr) += ydc_sP[sNode] + ag0*ydyn_sP[sNode];
2557 *(here->HSMHVSPspPtr) += ydc_sP[sNodePrime] + ag0*ydyn_sP[sNodePrime];
2558 *(here->HSMHVSPbpPtr) += ydc_sP[bNodePrime] + ag0*ydyn_sP[bNodePrime];
2559 if (flg_subNode > 0) {
2560 *(here->HSMHVSPsubPtr) += ydc_sP[subNode];
2561 }
2562 if( flg_tempNode > 0) {
2563 /* temp entries in matrix dependent on model type */
2564 *(here->HSMHVSPtempPtr) += model->HSMHV_type * (ydc_sP[tempNode] + ag0*ydyn_sP[tempNode]);
2565 }
2566 if (flg_nqs) {
2567 *(here->HSMHVSPqiPtr) += model->HSMHV_type * (ydc_sP[qiNode] + ag0*ydyn_sP[qiNode]);
2568 }
2569
2570 /*bulk prime*/
2571 *(here->HSMHVBPdPtr) += ydc_bP[dNode] + ag0*ydyn_bP[dNode];
2572 *(here->HSMHVBPdpPtr) += ydc_bP[dNodePrime] + ag0*ydyn_bP[dNodePrime];
2573 *(here->HSMHVBPgpPtr) += ydc_bP[gNodePrime] + ag0*ydyn_bP[gNodePrime];
2574 *(here->HSMHVBPspPtr) += ydc_bP[sNodePrime] + ag0*ydyn_bP[sNodePrime];
2575 *(here->HSMHVBPsPtr) += ydc_bP[sNode] + ag0*ydyn_bP[sNode];
2576 *(here->HSMHVBPbpPtr) += ydc_bP[bNodePrime] + ag0*ydyn_bP[bNodePrime];
2577 *(here->HSMHVBPbPtr) += ydc_bP[bNode] + ag0*ydyn_bP[bNode];
2578 *(here->HSMHVBPdbPtr) += ydc_bP[dbNode] + ag0*ydyn_bP[dbNode];
2579 *(here->HSMHVBPsbPtr) += ydc_bP[sbNode] + ag0*ydyn_bP[sbNode];
2580 if( flg_tempNode > 0) {
2581 /* temp entries in matrix dependent on model type */
2582 *(here->HSMHVBPtempPtr) += model->HSMHV_type * (ydc_bP[tempNode] + ag0*ydyn_bP[tempNode]);
2583 }
2584 if (flg_nqs) {
2585 *(here->HSMHVBPqbPtr) += model->HSMHV_type * (ydc_bP[qbNode] + ag0*ydyn_bP[qbNode]);
2586 }
2587
2588 /*bulk*/
2589 *(here->HSMHVBbpPtr) += ydc_b[bNodePrime] + ag0*ydyn_b[bNodePrime];
2590 *(here->HSMHVBbPtr) += ydc_b[bNode] + ag0*ydyn_b[bNode];
2591
2592 /*drain bulk*/
2593 *(here->HSMHVDBdPtr) += ydc_db[dNode] + ag0*ydyn_db[dNode];
2594 *(here->HSMHVDBbpPtr) += ydc_db[bNodePrime] + ag0*ydyn_db[bNodePrime];
2595 *(here->HSMHVDBdbPtr) += ydc_db[dbNode] + ag0*ydyn_db[dbNode];
2596 if( flg_tempNode > 0) {
2597 /* temp entries in matrix dependent on model type */
2598 *(here->HSMHVDBtempPtr) += model->HSMHV_type * (ydc_db[tempNode] + ag0*ydyn_db[tempNode]);
2599 }
2600
2601 /*source bulk*/
2602 *(here->HSMHVSBsPtr) += ydc_sb[sNode] + ag0*ydyn_sb[sNode];
2603 *(here->HSMHVSBbpPtr) += ydc_sb[bNodePrime] + ag0*ydyn_sb[bNodePrime];
2604 *(here->HSMHVSBsbPtr) += ydc_sb[sbNode] + ag0*ydyn_sb[sbNode];
2605 if( flg_tempNode > 0) {
2606 /* temp entries in matrix dependent on model type */
2607 *(here->HSMHVSBtempPtr) += model->HSMHV_type * (ydc_sb[tempNode] + ag0*ydyn_sb[tempNode]);
2608 }
2609
2610 /*temp*/
2611 if( flg_tempNode > 0) {
2612 /* temp entries in matrix dependent on model type */
2613 *(here->HSMHVTempdPtr) += model->HSMHV_type * (ydc_t[dNode] + ag0*ydyn_t[dNode] );
2614 *(here->HSMHVTempdpPtr) += model->HSMHV_type * (ydc_t[dNodePrime] + ag0*ydyn_t[dNodePrime]);
2615 *(here->HSMHVTempgpPtr) += model->HSMHV_type * (ydc_t[gNodePrime] + ag0*ydyn_t[gNodePrime]);
2616 *(here->HSMHVTempsPtr) += model->HSMHV_type * (ydc_t[sNode] + ag0*ydyn_t[sNode] );
2617 *(here->HSMHVTempspPtr) += model->HSMHV_type * (ydc_t[sNodePrime] + ag0*ydyn_t[sNodePrime]);
2618 *(here->HSMHVTempbpPtr) += model->HSMHV_type * (ydc_t[bNodePrime] + ag0*ydyn_t[bNodePrime]);
2619 /* no type factor at main diagonal temp entry! */
2620 *(here->HSMHVTemptempPtr) += ydc_t[tempNode] + ag0*ydyn_t[tempNode];
2621 }
2622
2623 /* additional entries for flat nqs handling */
2624 if ( flg_nqs ) {
2625 /*qi*/
2626 *(here->HSMHVQIdpPtr) += model->HSMHV_type * (ydc_qi[dNodePrime] + ag0*ydyn_qi[dNodePrime]);
2627 *(here->HSMHVQIgpPtr) += model->HSMHV_type * (ydc_qi[gNodePrime] + ag0*ydyn_qi[gNodePrime]);
2628 *(here->HSMHVQIspPtr) += model->HSMHV_type * (ydc_qi[sNodePrime] + ag0*ydyn_qi[sNodePrime]);
2629 *(here->HSMHVQIbpPtr) += model->HSMHV_type * (ydc_qi[bNodePrime] + ag0*ydyn_qi[bNodePrime]);
2630 *(here->HSMHVQIqiPtr) += (ydc_qi[qiNode] + ag0*ydyn_qi[qiNode]);
2631 if ( flg_tempNode > 0 ) { /* self heating */
2632 *(here->HSMHVQItempPtr) += (ydc_qi[tempNode] + ag0*ydyn_qi[tempNode]);
2633 }
2634
2635 /*qb*/
2636 *(here->HSMHVQBdpPtr) += model->HSMHV_type * (ydc_qb[dNodePrime] + ag0*ydyn_qb[dNodePrime]);
2637 *(here->HSMHVQBgpPtr) += model->HSMHV_type * (ydc_qb[gNodePrime] + ag0*ydyn_qb[gNodePrime]);
2638 *(here->HSMHVQBspPtr) += model->HSMHV_type * (ydc_qb[sNodePrime] + ag0*ydyn_qb[sNodePrime]);
2639 *(here->HSMHVQBbpPtr) += model->HSMHV_type * (ydc_qb[bNodePrime] + ag0*ydyn_qb[bNodePrime]);
2640 *(here->HSMHVQBqbPtr) += (ydc_qb[qbNode] + ag0*ydyn_qb[qbNode]);
2641 if ( flg_tempNode > 0 ) { /* self heating */
2642 *(here->HSMHVQBtempPtr) += (ydc_qb[tempNode] + ag0*ydyn_qb[tempNode]);
2643 }
2644 }
2645
2646
2647 line1000:
2648
2649 if (ckt->CKTnoncon != noncon_old) {
2650 ckt->CKTtroubleElt = (GENinstance *) here;
2651 }
2652
2653
2654 } /* End of MOSFET Instance */
2655 } /* End of Model Instance */
2656
2657 return(OK);
2658 }
2659