diff --git a/.gitignore b/.gitignore index 6b4f68ec9..b7cb0000d 100644 --- a/.gitignore +++ b/.gitignore @@ -74,3 +74,5 @@ Makefile.in **/*.vcxproj.user .vscode/ +# Visual Studio Code user options files +.vscode/ diff --git a/src/include/ngspice/cktdefs.h b/src/include/ngspice/cktdefs.h index 7afcc54dd..fa1d1031a 100644 --- a/src/include/ngspice/cktdefs.h +++ b/src/include/ngspice/cktdefs.h @@ -440,7 +440,6 @@ extern int NIconvTest(CKTcircuit *); extern void NIdestroy(CKTcircuit *); extern int NIinit(CKTcircuit *); extern int NIintegrate(CKTcircuit *, double *, double *, double , int); -extern void dummdumm(int dumm); extern int NIiter(CKTcircuit * , int); extern int NIpzMuller(PZtrial **, PZtrial *); extern int NIpzComplex(PZtrial **, PZtrial *); diff --git a/src/maths/ni/niinteg.c b/src/maths/ni/niinteg.c index 30136621d..37fb32170 100644 --- a/src/maths/ni/niinteg.c +++ b/src/maths/ni/niinteg.c @@ -14,12 +14,6 @@ Author: 1985 Thomas L. Quarles #define ccap qcap+1 -void dummdumm(int dumm) -{ - double dummy; - dummy=1; -} - int NIintegrate(CKTcircuit *ckt, double *geq, double *ceq, double cap, int qcap) { @@ -31,12 +25,12 @@ NIintegrate(CKTcircuit *ckt, double *geq, double *ceq, double cap, int qcap) case TRAPEZOIDAL: switch(ckt->CKTorder) { case 1: - ckt->CKTstate0[ccap] = ckt->CKTag[0] * ckt->CKTstate0[qcap] + ckt->CKTstate0[ccap] = ckt->CKTag[0] * ckt->CKTstate0[qcap] + ckt->CKTag[1] * ckt->CKTstate1[qcap]; break; case 2: - ckt->CKTstate0[ccap] = - ckt->CKTstate1[ccap] * ckt->CKTag[1] + - ckt->CKTag[0] * + ckt->CKTstate0[ccap] = - ckt->CKTstate1[ccap] * ckt->CKTag[1] + + ckt->CKTag[0] * ( ckt->CKTstate0[qcap] - ckt->CKTstate1[qcap] ); break; default: diff --git a/src/spicelib/devices/hicum2/Makefile.am b/src/spicelib/devices/hicum2/Makefile.am index 86eafe5d8..279f5ab29 100644 --- a/src/spicelib/devices/hicum2/Makefile.am +++ b/src/spicelib/devices/hicum2/Makefile.am @@ -27,7 +27,7 @@ libhicum2_la_SOURCES = \ AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include -lstdc++ -std=c++11 -AM_CFLAGS = -I/home/markus/Documents/Gitprojects/cppduals -lstdc++ -I$(top_srcdir)/src/include -AM_CXXFLAGS = -I/home/markus/Documents/Gitprojects/cppduals -I$(top_srcdir)/src/include -lstdc++ -std=c++11 +AM_CFLAGS = -lstdc++ -I$(top_srcdir)/src/include +AM_CXXFLAGS = -I$(top_srcdir)/src/include -lstdc++ -std=c++11 MAINTAINERCLEANFILES = Makefile.in diff --git a/src/spicelib/devices/hicum2/hicum2defs.h b/src/spicelib/devices/hicum2/hicum2defs.h index 724f29fe2..9cbc8079a 100644 --- a/src/spicelib/devices/hicum2/hicum2defs.h +++ b/src/spicelib/devices/hicum2/hicum2defs.h @@ -379,8 +379,22 @@ typedef struct sHICUMinstance { #define HICUMixf_Vbici HICUMstate+74 #define HICUMvxf1 HICUMstate+75 -#define HICUMvxf2 HICUMstate+76 -#define HICUMnumStates 77 +#define HICUMqxf1 HICUMstate+76 +#define HICUMcqxf1 HICUMstate+77 +#define HICUMgqxf1 HICUMstate+78 +#define HICUMixf1_Vbiei HICUMstate+79 +#define HICUMixf1_Vbici HICUMstate+80 +#define HICUMixf1_Vfx2 HICUMstate+81 + +#define HICUMvxf2 HICUMstate+82 +#define HICUMqxf2 HICUMstate+83 +#define HICUMcqxf2 HICUMstate+84 +#define HICUMgqxf2 HICUMstate+85 +#define HICUMixf2_Vbiei HICUMstate+86 +#define HICUMixf2_Vbici HICUMstate+87 +#define HICUMixf2_Vfx1 HICUMstate+88 + +#define HICUMnumStates 89 /* per model data */ typedef struct sHICUMmodel { /* model structure for a hicum */ diff --git a/src/spicelib/devices/hicum2/hicum2load.c b/src/spicelib/devices/hicum2/hicum2load.c index 11228d2b9..cf066ea28 100644 --- a/src/spicelib/devices/hicum2/hicum2load.c +++ b/src/spicelib/devices/hicum2/hicum2load.c @@ -439,7 +439,2064 @@ double DIOY, le, vtn; } +int hicum_thermal_update(HICUMmodel *, HICUMinstance *); +int +HICUMload(GENmodel *inModel, CKTcircuit *ckt) + /* actually load the current resistance value into the + * sparse matrix previously provided + */ +{ + HICUMmodel *model = (HICUMmodel*)inModel; + HICUMinstance *here; + + //Declaration of variables + + double cbcpar1,cbcpar2,cbepar2,cbepar1,Oich,Otbhrec; + + //Charges, capacitances and currents + double Qjci,Qjei,Qjep; + double Qdei,Qdci,Qrbi; + double it,ibei,irei,ibci,ibep,irep,ibh_rec; + double ibet,iavl; + double ijbcx,ijsc,Qjs,Qscp,HSUM,HSI_Tsu,Qdsu; + + //Base resistance and self-heating power + double rbi,pterm; + + //Model initialization + double C_1; + + //Model evaluation + double Crbi,Cjci,Cjcit,cc,Cjei,Cjep,CjCx_i,CjCx_ii,Cjs,Cscp; + double itf,itr,Tf,Tr,VT_f,i_0f,i_0r,a_bpt,Q_0,Q_p,Q_bpt; + double Orci0_t,b_q,I_Tf1,T_f0,Q_fT,T_fT,Q_bf; + double a_h,Q_pT,d_Q; + double Qf,Cdei,Qr,Cdci; + double ick,vc,cjcx01,cjcx02; + double ick_Vciei; + double Qf_Vbiei, Qf_Vbici, Q_bf_Vbiei, Q_bf_Vbici, Qr_Vbiei, Qr_Vbici, Q_pT_Vbiei, Q_pT_Vbici; + + int l_it; + + //NQS + double Ixf1,Ixf2,Qxf1,Qxf2; + double Itxf, Qdeix; + double Vxf, Ixf, Qxf; + double Vxf1, Vxf2; + + double hjei_vbe; + + double Vbiei, Vbici, Vciei, Vbpei, Vbpbi, Vbpci, Vsici, Vbci, Vsc; + + // Model flags + int use_aval; + + //end of variables + + int iret; + +#ifndef PREDICTOR + double xfact; +#endif + double delvbiei=0.0, delvbici=0.0, delvbpei=0.0, delvbpbi=0.0, delvbpci=0.0, delvsici=0.0; + double ibieihat; + double ibpeihat; + double icieihat; + double ibicihat; + double ibpcihat; + double ibpbihat; + double isicihat; + double ibpsihat; + double ceq, geq=0.0, rhs_current; + int icheck=1; + int ichk1, ichk2, ichk3, ichk4, ichk5; + int error; + double Vbe, Vcic, Vbbp, Veie, Vsis, Vbpe; + + double Ibiei, Ibiei_Vbiei; + double Ibici, Ibici_Vbici; + double Ibpei, Ibpei_Vbpei; + double Ibpci, Ibpci_Vbpci; + double Isici, Isici_Vsici; + double Isc, Isc_Vsc; + double Iciei, Iciei_Vbiei, Iciei_Vbici; + double Ibbp_Vbbp; + double Isis_Vsis; + double Ieie, Ieie_Veie; + double Ibpbi, Ibpbi_Vbpbi, Ibpbi_Vbici, Ibpbi_Vbiei; + double Ibpsi, Ibpsi_Vbpci, Ibpsi_Vsici; + double Icic_Vcic; + double Ibci, Ibci_Vbci; + double hjei_vbe_Vbiei, ibet_Vbpei=0.0, ibet_Vbiei=0.0, ibh_rec_Vbiei; + double irei_Vbiei, irep_Vbpei, iavl_Vbici, rbi_Vbiei, rbi_Vbici; + double Q_0_Vbiei, Q_0_Vbici, b_q_Vbiei, b_q_Vbici; + + double Cjei_Vbiei,Cjci_Vbici,Cjep_Vbpei,CjCx_i_Vbci,CjCx_ii_Vbpci,Cjs_Vsici,Cscp_Vsc,Cjcit_Vbici,i_0f_Vbiei,i_0r_Vbici; + double cc_Vbici,T_f0_Vbici,Q_p_Vbiei,Q_p_Vbici,I_Tf1_Vbiei,I_Tf1_Vbici,itf_Vbiei,itf_Vbici,itr_Vbiei,itr_Vbici; + double Qbepar1; + double Qbepar2; + double Qbcpar1; + double Qbcpar2; + double Qsu; + double Qcth; + + double Qrbi_Vbpbi; + double Qrbi_Vbiei; + double Qrbi_Vbici; + double Qdeix_Vbiei; + double Qdci_Vbici; + double Qjep_Vbpei; + double qjcx0_t_i_Vbci; + double qjcx0_t_ii_Vbpci; + double Qdsu_Vbpci; + double Qjs_Vsici; + double Qbepar1_Vbe; + double Qbepar2_Vbpe; + double Qbcpar1_Vbci; + double Qbcpar2_Vbpci; + double Qsu_Vsis; + + double cqbepar1, gqbepar1; + double cqbepar2, gqbepar2; + double cqbcpar1, gqbcpar1; + double cqbcpar2, gqbcpar2; + double cqsu, gqsu; + double qjcx0_t_i, qjcx0_t_ii; + +//NQS + double Vbxf, Vbxf1, Vbxf2; + double Qxf_Vxf, Qxf1_Vxf1, Qxf2_Vxf2; + double Iqxf, Iqxf_Vxf, Iqxf1, Iqxf1_Vxf1, Iqxf2, Iqxf2_Vxf2; + + double Ith, Vrth, Icth, Icth_Vrth, delvrth; + + double Irth_Vrth; + double Iciei_Vrth; + double Ibiei_Vrth; + double Ibici_Vrth; + double Ibpei_Vrth; + double Ibpci_Vrth; + double Isici_Vrth; + double Ibpbi_Vrth; + double Ieie_Vrth; + double Icic_Vrth; + double Ibbp_Vrth; + + double Ith_Vrth; + double Ith_Vciei; + double Ith_Vbiei; + double Ith_Vbici; + double Ith_Vbpei; + double Ith_Vbpci; + double Ith_Vsici; + double Ith_Vbpbi; + double Ith_Veie; + double Ith_Vcic; + double Ith_Vbbp; + + /* loop through all the models */ + for (; model != NULL; model = HICUMnextModel(model)) { + + // Model_initialization + + // Depletion capacitance splitting at b-c junction + // Capacitances at peripheral and external base node + C_1 = (1.0 - model->HICUMfbcpar) * + (model->HICUMcjcx0 + model->HICUMcbcpar); + if (C_1 >= model->HICUMcbcpar) { + cbcpar1 = model->HICUMcbcpar; + cbcpar2 = 0.0; + cjcx01 = C_1 - model->HICUMcbcpar; + cjcx02 = model->HICUMcjcx0 - cjcx01; + } + else { + cbcpar1 = C_1; + cbcpar2 = model->HICUMcbcpar - cbcpar1; + cjcx01 = 0.0; + cjcx02 = model->HICUMcjcx0; + } + + // Parasitic b-e capacitance partitioning: No temperature dependence + cbepar2 = model->HICUMfbepar * model->HICUMcbepar; + cbepar1 = model->HICUMcbepar - cbepar2; + + // Avoid divide-by-zero and define infinity other way + // High current correction for 2D and 3D effects + if (model->HICUMich != 0.0) { + Oich = 1.0 / model->HICUMich; + } + else { + Oich = 0.0; + } + + // Base current recombination time constant at b-c barrier + if (model->HICUMtbhrec != 0.0) { + Otbhrec = 1.0 / model->HICUMtbhrec; + } + else { + Otbhrec = 0.0; + } + + // Turn avalanche calculation on depending of parameters + if ((model->HICUMfavl > 0.0) && (model->HICUMcjci0 > 0.0)) { + use_aval = 1; + } else { + use_aval = 0; + } + +// end of Model_initialization + + /* loop through all the instances of the model */ + for (here = HICUMinstances(model); here != NULL ; + here=HICUMnextInstance(here)) { + + gqbepar1 = 0.0; + gqbepar2 = 0.0; + gqbcpar1 = 0.0; + gqbcpar2 = 0.0; + gqsu = 0.0; + Icth = 0.0, Icth_Vrth = 0.0; + +// SCALE = here->HICUMarea * here->HICUMm; + + /* + * initialization + */ + icheck=1; + if(ckt->CKTmode & MODEINITSMSIG) { + Vbiei = *(ckt->CKTstate0 + here->HICUMvbiei); + Vbici = *(ckt->CKTstate0 + here->HICUMvbici); + Vciei = Vbiei - Vbici; + Vbpei = *(ckt->CKTstate0 + here->HICUMvbpei); + Vbpci = *(ckt->CKTstate0 + here->HICUMvbpci); + Vbci = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseNode)- + *(ckt->CKTrhsOld+here->HICUMcollCINode)); + Vsici = *(ckt->CKTstate0 + here->HICUMvsici); + Vsc = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMsubsNode)- + *(ckt->CKTrhsOld+here->HICUMcollNode)); + + Vbpbi = *(ckt->CKTstate0 + here->HICUMvbpbi); + Vbe = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseNode)- + *(ckt->CKTrhsOld+here->HICUMemitNode)); + Vcic = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMcollCINode)- + *(ckt->CKTrhsOld+here->HICUMcollNode)); + Vbbp = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseNode)- + *(ckt->CKTrhsOld+here->HICUMbaseBPNode)); + Vbpe = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseBPNode)- + *(ckt->CKTrhsOld+here->HICUMemitNode)); + Veie = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMemitEINode)- + *(ckt->CKTrhsOld+here->HICUMemitNode)); + Vsis = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMsubsSINode)- + *(ckt->CKTrhsOld+here->HICUMsubsNode)); + Vbxf = *(ckt->CKTrhsOld + here->HICUMxfNode); + Vbxf1 = *(ckt->CKTrhsOld + here->HICUMxf1Node); + Vbxf2 = *(ckt->CKTrhsOld + here->HICUMxf2Node); + if (model->HICUMflsh) + Vrth = *(ckt->CKTstate0 + here->HICUMvrth); + } else if(ckt->CKTmode & MODEINITTRAN) { + Vbiei = *(ckt->CKTstate1 + here->HICUMvbiei); + Vbici = *(ckt->CKTstate1 + here->HICUMvbici); + Vciei = Vbiei - Vbici; + Vbpei = *(ckt->CKTstate1 + here->HICUMvbpei); + Vbpci = *(ckt->CKTstate1 + here->HICUMvbpci); + Vbci = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseNode)- + *(ckt->CKTrhsOld+here->HICUMcollCINode)); + Vsici = *(ckt->CKTstate1 + here->HICUMvsici); + Vsc = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMsubsNode)- + *(ckt->CKTrhsOld+here->HICUMcollNode)); + + Vbpbi = *(ckt->CKTstate1 + here->HICUMvbpbi); + Vbe = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseNode)- + *(ckt->CKTrhsOld+here->HICUMemitNode)); + Vcic = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMcollCINode)- + *(ckt->CKTrhsOld+here->HICUMcollNode)); + Vbbp = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseNode)- + *(ckt->CKTrhsOld+here->HICUMbaseBPNode)); + Vbpe = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseBPNode)- + *(ckt->CKTrhsOld+here->HICUMemitNode)); + Veie = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMemitEINode)- + *(ckt->CKTrhsOld+here->HICUMemitNode)); + Vsis = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMsubsSINode)- + *(ckt->CKTrhsOld+here->HICUMsubsNode)); + Vbxf = *(ckt->CKTrhsOld + here->HICUMxfNode); + Vbxf1 = *(ckt->CKTrhsOld + here->HICUMxf1Node); + Vbxf2 = *(ckt->CKTrhsOld + here->HICUMxf2Node); + if (model->HICUMflsh) + Vrth = *(ckt->CKTstate1 + here->HICUMvrth); + } else if((ckt->CKTmode & MODEINITJCT) && + (ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)){ + Vbe=Vbiei=model->HICUMtype*here->HICUMicVBE; + Vciei=model->HICUMtype*here->HICUMicVCE; + Vbci=Vbici=Vbpci=Vbiei-Vciei; + Vbpei=0.0; + Vsc=Vsici=0.0; + Vbpbi=Vbbp=Vbpe=0.0; + Vcic=Veie=Vsis=0.0; + Vrth=0.0,Icth=0.0,Icth_Vrth=0.0; + Vbxf=Vbxf1=Vbxf2=0.0; + } else if((ckt->CKTmode & MODEINITJCT) && (here->HICUMoff==0)) { + Vbe=Vbiei=model->HICUMtype*here->HICUMtVcrit; + Vciei=0.0; + Vbci=Vbici=Vbpci=0.0; + Vbpei=0.0; + Vsc=Vsici=0.0; + Vbpbi=Vbbp=Vbpe=0.0; + Vcic=Veie=Vsis=0.0; + Vrth=0.0,Icth=0.0,Icth_Vrth=0.0; + Vbxf=Vbxf1=Vbxf2=0.0; + } else if((ckt->CKTmode & MODEINITJCT) || + ( (ckt->CKTmode & MODEINITFIX) && (here->HICUMoff!=0))) { + Vbe=0.0; + Vbiei=Vbe; + Vciei=0.0; + Vbci=Vbici=Vbpci=0.0; + Vbpei=0.0; + Vsc=Vsici=0.0; + Vbpbi=Vbbp=Vbpe=0.0; + Vcic=Veie=Vsis=0.0; + Vrth=0.0,Icth=0.0,Icth_Vrth=0.0; + Vbxf=Vbxf1=Vbxf2=0.0; + } else { +#ifndef PREDICTOR + if(ckt->CKTmode & MODEINITPRED) { + xfact = ckt->CKTdelta/ckt->CKTdeltaOld[1]; + Vbiei = (1+xfact) * *(ckt->CKTstate1 + here->HICUMvbiei)- + xfact * *(ckt->CKTstate2 + here->HICUMvbiei); + Vbici = (1+xfact) * *(ckt->CKTstate1 + here->HICUMvbici)- + xfact * *(ckt->CKTstate2 + here->HICUMvbici); + Vciei = Vbiei - Vbici; + Vbpei = (1+xfact) * *(ckt->CKTstate1 + here->HICUMvbpei)- + xfact * *(ckt->CKTstate2 + here->HICUMvbpei); + Vbpci = (1+xfact) * *(ckt->CKTstate1 + here->HICUMvbpci)- + xfact * *(ckt->CKTstate2 + here->HICUMvbpci); + Vsici = (1+xfact) * *(ckt->CKTstate1 + here->HICUMvsici)- + xfact * *(ckt->CKTstate2 + here->HICUMvsici); + Vbpbi = (1+xfact) * *(ckt->CKTstate1 + here->HICUMvbpbi)- + xfact * *(ckt->CKTstate2 + here->HICUMvbpbi); + Vbxf = (1+xfact) * *(ckt->CKTstate1 + here->HICUMvxf)- + xfact * *(ckt->CKTstate2 + here->HICUMvxf); + Vbxf1 = (1+xfact) * *(ckt->CKTstate1 + here->HICUMvxf1)- + xfact * *(ckt->CKTstate2 + here->HICUMvxf1); + Vbxf2 = (1+xfact) * *(ckt->CKTstate1 + here->HICUMvxf2)- + xfact * *(ckt->CKTstate2 + here->HICUMvxf2); + *(ckt->CKTstate0 + here->HICUMvbiei) = + *(ckt->CKTstate1 + here->HICUMvbiei); + *(ckt->CKTstate0 + here->HICUMvbpei) = + *(ckt->CKTstate1 + here->HICUMvbpei); + *(ckt->CKTstate0 + here->HICUMvbici) = + *(ckt->CKTstate1 + here->HICUMvbici); + *(ckt->CKTstate0 + here->HICUMvbpei) = + *(ckt->CKTstate1 + here->HICUMvbpei); + *(ckt->CKTstate0 + here->HICUMvbpbi) = + *(ckt->CKTstate1 + here->HICUMvbpbi); + *(ckt->CKTstate0 + here->HICUMvsici) = + *(ckt->CKTstate1 + here->HICUMvsici); + *(ckt->CKTstate0 + here->HICUMvxf) = + *(ckt->CKTstate1 + here->HICUMvxf); + *(ckt->CKTstate0 + here->HICUMvxf1) = + *(ckt->CKTstate1 + here->HICUMvxf1); + *(ckt->CKTstate0 + here->HICUMvxf2) = + *(ckt->CKTstate1 + here->HICUMvxf2); + *(ckt->CKTstate0 + here->HICUMibiei) = + *(ckt->CKTstate1 + here->HICUMibiei); + *(ckt->CKTstate0 + here->HICUMibiei_Vbiei) = + *(ckt->CKTstate1 + here->HICUMibiei_Vbiei); + *(ckt->CKTstate0 + here->HICUMibpei) = + *(ckt->CKTstate1 + here->HICUMibpei); + *(ckt->CKTstate0 + here->HICUMibpei_Vbpei) = + *(ckt->CKTstate1 + here->HICUMibpei_Vbpei); + *(ckt->CKTstate0 + here->HICUMiciei) = + *(ckt->CKTstate1 + here->HICUMiciei); + *(ckt->CKTstate0 + here->HICUMiciei_Vbiei) = + *(ckt->CKTstate1 + here->HICUMiciei_Vbiei); + *(ckt->CKTstate0 + here->HICUMiciei_Vbici) = + *(ckt->CKTstate1 + here->HICUMiciei_Vbici); + *(ckt->CKTstate0 + here->HICUMibici) = + *(ckt->CKTstate1 + here->HICUMibici); + *(ckt->CKTstate0 + here->HICUMibici_Vbici) = + *(ckt->CKTstate1 + here->HICUMibici_Vbici); + *(ckt->CKTstate0 + here->HICUMibpei) = + *(ckt->CKTstate1 + here->HICUMibpei); + *(ckt->CKTstate0 + here->HICUMibpbi) = + *(ckt->CKTstate1 + here->HICUMibpbi); + *(ckt->CKTstate0 + here->HICUMibpbi_Vbpbi) = + *(ckt->CKTstate1 + here->HICUMibpbi_Vbpbi); + *(ckt->CKTstate0 + here->HICUMibpbi_Vbiei) = + *(ckt->CKTstate1 + here->HICUMibpbi_Vbiei); + *(ckt->CKTstate0 + here->HICUMibpbi_Vbici) = + *(ckt->CKTstate1 + here->HICUMibpbi_Vbici); + *(ckt->CKTstate0 + here->HICUMisici) = + *(ckt->CKTstate1 + here->HICUMisici); + *(ckt->CKTstate0 + here->HICUMisici_Vsici) = + *(ckt->CKTstate1 + here->HICUMisici_Vsici); + *(ckt->CKTstate0 + here->HICUMibpsi) = + *(ckt->CKTstate1 + here->HICUMibpsi); + *(ckt->CKTstate0 + here->HICUMibpsi_Vbpci) = + *(ckt->CKTstate1 + here->HICUMibpsi_Vbpci); + *(ckt->CKTstate0 + here->HICUMibpsi_Vsici) = + *(ckt->CKTstate1 + here->HICUMibpsi_Vsici); + *(ckt->CKTstate0 + here->HICUMgqbepar1) = + *(ckt->CKTstate1 + here->HICUMgqbepar1); + *(ckt->CKTstate0 + here->HICUMgqbepar2) = + *(ckt->CKTstate1 + here->HICUMgqbepar2); + *(ckt->CKTstate0 + here->HICUMieie) = + *(ckt->CKTstate1 + here->HICUMieie); + *(ckt->CKTstate0 + here->HICUMisis_Vsis) = + *(ckt->CKTstate1 + here->HICUMisis_Vsis); +//NQS + *(ckt->CKTstate0 + here->HICUMgqxf) = + *(ckt->CKTstate1 + here->HICUMgqxf); + *(ckt->CKTstate0 + here->HICUMixf_Vbiei) = + *(ckt->CKTstate1 + here->HICUMixf_Vbiei); + *(ckt->CKTstate0 + here->HICUMixf_Vbici) = + *(ckt->CKTstate1 + here->HICUMixf_Vbici); + + if (model->HICUMflsh) { + Vrth = (1.0 + xfact)* (*(ckt->CKTstate1 + here->HICUMvrth)) + - ( xfact * (*(ckt->CKTstate2 + here->HICUMvrth))); + *(ckt->CKTstate0 + here->HICUMvrth) = + *(ckt->CKTstate1 + here->HICUMvrth); + *(ckt->CKTstate0 + here->HICUMqcth) = + *(ckt->CKTstate1 + here->HICUMqcth); + } + } else { +#endif /* PREDICTOR */ + /* + * compute new nonlinear branch voltages + */ + Vbiei = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseBINode)- + *(ckt->CKTrhsOld+here->HICUMemitEINode)); + Vbici = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseBINode)- + *(ckt->CKTrhsOld+here->HICUMcollCINode)); + Vbpei = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseBPNode)- + *(ckt->CKTrhsOld+here->HICUMemitEINode)); + Vbpbi = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseBPNode)- + *(ckt->CKTrhsOld+here->HICUMbaseBINode)); + Vbpci = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseBPNode)- + *(ckt->CKTrhsOld+here->HICUMcollCINode)); + Vsici = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMsubsSINode)- + *(ckt->CKTrhsOld+here->HICUMcollCINode)); + Vbxf = *(ckt->CKTrhsOld + here->HICUMxfNode); + Vbxf1 = *(ckt->CKTrhsOld + here->HICUMxf1Node); + Vbxf2 = *(ckt->CKTrhsOld + here->HICUMxf2Node); + Vciei = Vbiei - Vbici; + if (model->HICUMflsh) + Vrth = *(ckt->CKTrhsOld + here->HICUMtempNode); +#ifndef PREDICTOR + } +#endif /* PREDICTOR */ + delvbiei = Vbiei - *(ckt->CKTstate0 + here->HICUMvbiei); + delvbici = Vbici - *(ckt->CKTstate0 + here->HICUMvbici); + delvbpei = Vbpei - *(ckt->CKTstate0 + here->HICUMvbpei); + delvbpbi = Vbpbi - *(ckt->CKTstate0 + here->HICUMvbpbi); + delvbpci = Vbpci - *(ckt->CKTstate0 + here->HICUMvbpci); + delvsici = Vsici - *(ckt->CKTstate0 + here->HICUMvsici); + if (model->HICUMflsh) + delvrth = Vrth - *(ckt->CKTstate0 + here->HICUMvrth); + Vbe = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseNode)- + *(ckt->CKTrhsOld+here->HICUMemitNode)); + Vsc = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMsubsNode)- + *(ckt->CKTrhsOld+here->HICUMcollNode)); + Vcic = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMcollCINode)- + *(ckt->CKTrhsOld+here->HICUMcollNode)); + Vbci = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseNode)- + *(ckt->CKTrhsOld+here->HICUMcollCINode)); + Vbbp = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseNode)- + *(ckt->CKTrhsOld+here->HICUMbaseBPNode)); + Vbpe = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMbaseBPNode)- + *(ckt->CKTrhsOld+here->HICUMemitNode)); + Veie = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMemitEINode)- + *(ckt->CKTrhsOld+here->HICUMemitNode)); + Vsis = model->HICUMtype*( + *(ckt->CKTrhsOld+here->HICUMsubsSINode)- + *(ckt->CKTrhsOld+here->HICUMsubsNode)); + Vbxf = *(ckt->CKTrhsOld + here->HICUMxfNode); + Vbxf1 = *(ckt->CKTrhsOld + here->HICUMxf1Node); + Vbxf2 = *(ckt->CKTrhsOld + here->HICUMxf2Node); + if (model->HICUMflsh) + Vrth = *(ckt->CKTrhsOld + here->HICUMtempNode); + ibieihat = *(ckt->CKTstate0 + here->HICUMibiei) + + *(ckt->CKTstate0 + here->HICUMibiei_Vbiei)*delvbiei; + ibicihat = *(ckt->CKTstate0 + here->HICUMibici) + + *(ckt->CKTstate0 + here->HICUMibici_Vbici)*delvbici; + ibpeihat = *(ckt->CKTstate0 + here->HICUMibpei) + + *(ckt->CKTstate0 + here->HICUMibpei_Vbpei)*delvbpei; + ibpcihat = *(ckt->CKTstate0 + here->HICUMibpci) + + *(ckt->CKTstate0 + here->HICUMibpci_Vbpci)*delvbpci; + icieihat = *(ckt->CKTstate0 + here->HICUMiciei) + + *(ckt->CKTstate0 + here->HICUMiciei_Vbiei)*delvbiei + + *(ckt->CKTstate0 + here->HICUMiciei_Vbici)*delvbici; + ibpbihat = *(ckt->CKTstate0 + here->HICUMibpbi) + + *(ckt->CKTstate0 + here->HICUMibpbi_Vbpbi)*delvbpbi + + *(ckt->CKTstate0 + here->HICUMibpbi_Vbiei)*delvbiei + + *(ckt->CKTstate0 + here->HICUMibpbi_Vbici)*delvbici; + isicihat = *(ckt->CKTstate0 + here->HICUMisici) + + *(ckt->CKTstate0 + here->HICUMisici_Vsici)*delvsici; + ibpsihat = *(ckt->CKTstate0 + here->HICUMibpsi) + + *(ckt->CKTstate0 + here->HICUMibpsi_Vbpci)*delvbpci + + *(ckt->CKTstate0 + here->HICUMibpsi_Vsici)*delvsici; + /* + * bypass if solution has not changed + */ + /* the following collections of if's would be just one + * if the average compiler could handle it, but many + * find the expression too complicated, thus the split. + * ... no bypass in case of selfheating + */ + if( (ckt->CKTbypass) && (!(ckt->CKTmode & MODEINITPRED)) && !model->HICUMflsh && + (fabs(delvbiei) < (ckt->CKTreltol*MAX(fabs(Vbiei), + fabs(*(ckt->CKTstate0 + here->HICUMvbiei)))+ + ckt->CKTvoltTol)) ) + if( (fabs(delvbici) < ckt->CKTreltol*MAX(fabs(Vbici), + fabs(*(ckt->CKTstate0 + here->HICUMvbici)))+ + ckt->CKTvoltTol) ) + if( (fabs(delvbpei) < ckt->CKTreltol*MAX(fabs(Vbpei), + fabs(*(ckt->CKTstate0 + here->HICUMvbpei)))+ + ckt->CKTvoltTol) ) + if( (fabs(delvbpbi) < ckt->CKTreltol*MAX(fabs(Vbpbi), + fabs(*(ckt->CKTstate0 + here->HICUMvbpbi)))+ + ckt->CKTvoltTol) ) + if( (fabs(delvsici) < ckt->CKTreltol*MAX(fabs(Vsici), + fabs(*(ckt->CKTstate0 + here->HICUMvsici)))+ + ckt->CKTvoltTol) ) + if( (fabs(ibieihat-*(ckt->CKTstate0 + here->HICUMibiei)) < + ckt->CKTreltol* MAX(fabs(ibieihat), + fabs(*(ckt->CKTstate0 + here->HICUMibiei)))+ + ckt->CKTabstol) ) + if( (fabs(ibpeihat-*(ckt->CKTstate0 + here->HICUMibpei)) < + ckt->CKTreltol* MAX(fabs(ibpeihat), + fabs(*(ckt->CKTstate0 + here->HICUMibpei)))+ + ckt->CKTabstol) ) + if( (fabs(icieihat-*(ckt->CKTstate0 + here->HICUMiciei)) < + ckt->CKTreltol* MAX(fabs(icieihat), + fabs(*(ckt->CKTstate0 + here->HICUMiciei)))+ + ckt->CKTabstol) ) + if( (fabs(ibicihat-*(ckt->CKTstate0 + here->HICUMibici)) < + ckt->CKTreltol* MAX(fabs(ibicihat), + fabs(*(ckt->CKTstate0 + here->HICUMibici)))+ + ckt->CKTabstol) ) + if( (fabs(ibpcihat-*(ckt->CKTstate0 + here->HICUMibpei)) < + ckt->CKTreltol* MAX(fabs(ibpcihat), + fabs(*(ckt->CKTstate0 + here->HICUMibpei)))+ + ckt->CKTabstol) ) + if( (fabs(ibpbihat-*(ckt->CKTstate0 + here->HICUMibpbi)) < + ckt->CKTreltol* MAX(fabs(ibpbihat), + fabs(*(ckt->CKTstate0 + here->HICUMibpbi)))+ + ckt->CKTabstol) ) + if( (fabs(isicihat-*(ckt->CKTstate0 + here->HICUMisici)) < + ckt->CKTreltol* MAX(fabs(isicihat), + fabs(*(ckt->CKTstate0 + here->HICUMisici)))+ + ckt->CKTabstol) ) + if( (fabs(ibpsihat-*(ckt->CKTstate0 + here->HICUMibpsi)) < + ckt->CKTreltol* MAX(fabs(ibpsihat), + fabs(*(ckt->CKTstate0 + here->HICUMibpsi)))+ + ckt->CKTabstol) ) { + /* + * bypassing.... + */ + Vbiei = *(ckt->CKTstate0 + here->HICUMvbiei); + Vbici = *(ckt->CKTstate0 + here->HICUMvbici); + Vbpei = *(ckt->CKTstate0 + here->HICUMvbpei); + Vbpbi = *(ckt->CKTstate0 + here->HICUMvbpbi); + Vbpci = *(ckt->CKTstate0 + here->HICUMvbpci); + Vsici = *(ckt->CKTstate0 + here->HICUMvsici); + + Ibiei = *(ckt->CKTstate0 + here->HICUMibiei); + Ibiei_Vbiei = *(ckt->CKTstate0 + here->HICUMibiei_Vbiei); + + Ibpei = *(ckt->CKTstate0 + here->HICUMibpei); + Ibpei_Vbpei = *(ckt->CKTstate0 + here->HICUMibpei_Vbpei); + + Iciei = *(ckt->CKTstate0 + here->HICUMiciei); + Iciei_Vbiei = *(ckt->CKTstate0 + here->HICUMiciei_Vbiei); + Iciei_Vbici = *(ckt->CKTstate0 + here->HICUMiciei_Vbici); + + Ibici = *(ckt->CKTstate0 + here->HICUMibici); + Ibici_Vbici = *(ckt->CKTstate0 + here->HICUMibici_Vbici); + + Ibpbi = *(ckt->CKTstate0 + here->HICUMibpbi); + Ibpbi_Vbpbi = *(ckt->CKTstate0 + here->HICUMibpbi_Vbpbi); + Ibpbi_Vbiei = *(ckt->CKTstate0 + here->HICUMibpbi_Vbiei); + Ibpbi_Vbici = *(ckt->CKTstate0 + here->HICUMibpbi_Vbici); + + Isici = *(ckt->CKTstate0 + here->HICUMisici); + Isici_Vsici = *(ckt->CKTstate0 + here->HICUMisici_Vsici); + + Ibpsi = *(ckt->CKTstate0 + here->HICUMibpsi); + Ibpsi_Vbpci = *(ckt->CKTstate0 + here->HICUMibpsi_Vbpci); + Ibpsi_Vsici = *(ckt->CKTstate0 + here->HICUMibpsi_Vsici); + + Ibpci = *(ckt->CKTstate0 + here->HICUMibpci); + Ibpci_Vbpci = *(ckt->CKTstate0 + here->HICUMibpci_Vbpci); + + Ieie = *(ckt->CKTstate0 + here->HICUMieie); + + Isis_Vsis = *(ckt->CKTstate0 + here->HICUMisis_Vsis); + + gqbepar1 = *(ckt->CKTstate0 + here->HICUMgqbepar1); + gqbepar2 = *(ckt->CKTstate0 + here->HICUMgqbepar2); + gqbcpar1 = *(ckt->CKTstate0 + here->HICUMgqbcpar1); + gqbcpar2 = *(ckt->CKTstate0 + here->HICUMgqbcpar2); + goto load; + } + /* + * limit nonlinear branch voltages + */ + ichk1 = 1, ichk2 = 1, ichk3 = 1, ichk4 = 1, ichk5 = 0; + Vbiei = DEVpnjlim(Vbiei,*(ckt->CKTstate0 + here->HICUMvbiei),here->HICUMvt, + here->HICUMtVcrit,&icheck); + Vbici = DEVpnjlim(Vbici,*(ckt->CKTstate0 + here->HICUMvbici),here->HICUMvt, + here->HICUMtVcrit,&ichk1); + Vbpei = DEVpnjlim(Vbpei,*(ckt->CKTstate0 + here->HICUMvbpei),here->HICUMvt, + here->HICUMtVcrit,&ichk2); + Vbpci = DEVpnjlim(Vbpci,*(ckt->CKTstate0 + here->HICUMvbpci),here->HICUMvt, + here->HICUMtVcrit,&ichk3); + Vsici = DEVpnjlim(Vsici,*(ckt->CKTstate0 + here->HICUMvsici),here->HICUMvt, + here->HICUMtVcrit,&ichk4); + if (model->HICUMflsh) { + ichk5 = 1; + Vrth = HICUMlimitlog(Vrth, + *(ckt->CKTstate0 + here->HICUMvrth),100,&ichk4); + } + if ((ichk1 == 1) || (ichk2 == 1) || (ichk3 == 1) || (ichk4 == 1) || (ichk5 == 1)) icheck=1; + } + /* + * determine dc current and derivatives + */ +//todo: check for double multiplication on pnp's + Vbiei = model->HICUMtype*Vbiei; + Vbici = model->HICUMtype*Vbici; + Vciei = Vbiei-Vbici; + Vbpei = model->HICUMtype*Vbpei; + Vbpci = model->HICUMtype*Vbpci; + Vbci = model->HICUMtype*Vbci; + Vsici = model->HICUMtype*Vsici; + Vsc = model->HICUMtype*Vsc; + + if (model->HICUMflsh!=0 && model->HICUMrth >= MIN_R) { // Thermal_update_with_self_heating + here->HICUMtemp = here->HICUMtemp+Vrth; + iret = hicum_thermal_update(model, here); + } + + // Model_evaluation + + //Intrinsic transistor + //Internal base currents across b-e junction + HICDIO(here->HICUMvt,model->HICUMibeis,here->HICUMibeis_t,model->HICUMmbei,Vbiei,&ibei,&Ibiei_Vbiei); + HICDIO(here->HICUMvt,model->HICUMireis,here->HICUMireis_t,model->HICUMmrei,Vbiei,&irei,&irei_Vbiei); + + //HICCR: begin + + //Inverse of low-field internal collector resistance: needed in HICICK + Orci0_t = 1.0/here->HICUMrci0_t; + + //Internal b-e and b-c junction capacitances and charges + //QJMODF(here->HICUMvt,cjei0_t,vdei_t,model->HICUMzei,ajei_t,V(br_biei),Qjei) + //Cjei = ddx(Qjei,V(bi)); + QJMODF(here->HICUMvt,here->HICUMcjei0_t,here->HICUMvdei_t,model->HICUMzei,here->HICUMajei_t,Vbiei,&Cjei,&Cjei_Vbiei,&Qjei); + + if (model->HICUMahjei == 0.0) { + hjei_vbe = model->HICUMhjei; + hjei_vbe_Vbiei = 0.0; + } else { + double vj, vj_z, vj1, vj1_Vbiei, vj2, vj2_Vbiei, vj3, vj3_Vbiei, vj_z_Vbiei; + //vendhjei = vdei_t*(1.0-exp(-log(ajei_t)/z_h)); + vj = (here->HICUMvdei_t-Vbiei)/(model->HICUMrhjei*here->HICUMvt); + vj1 = here->HICUMvdei_t-model->HICUMrhjei*here->HICUMvt*(vj+sqrt(vj*vj+DFa_fj))*0.5; + vj1_Vbiei = vj/2/(sqrt(vj*vj+DFa_fj)); + vj2 = (vj1-here->HICUMvt)/here->HICUMvt; + vj2_Vbiei = vj1_Vbiei/here->HICUMvt; + vj3 = here->HICUMvt*(1.0+(vj2+sqrt(vj2*vj2+DFa_fj))*0.5); + vj3_Vbiei = 0.5*(vj2*vj2_Vbiei/sqrt(vj2*vj2+DFa_fj)+vj2_Vbiei)*here->HICUMvt; + vj_z = (1.0-exp(model->HICUMzei*log(1.0-vj3/here->HICUMvdei_t)))*here->HICUMahjei_t; + vj_z_Vbiei = vj3_Vbiei*(here->HICUMahjei_t-vj_z)/(here->HICUMvdei_t-vj3); + hjei_vbe = here->HICUMhjei0_t*(exp(vj_z)-1.0)/vj_z; + hjei_vbe_Vbiei = here->HICUMhjei0_t*exp(vj_z)*vj_z_Vbiei/vj_z-hjei_vbe*vj_z_Vbiei/(vj_z*vj_z); + } + //HICJQ(here->HICUMvt,cjci0_t,vdci_t,model->HICUMzci,vptci_t,V(br_bici),Qjci); + //Cjci = ddx(Qjci,V(bi)); + HICJQ(here->HICUMvt,here->HICUMcjci0_t,here->HICUMvdci_t,model->HICUMzci,here->HICUMvptci_t,Vbici,&Cjci,&Cjci_Vbici,&Qjci); + + //Hole charge at low bias + a_bpt = 0.05; + Q_0 = here->HICUMqp0_t + hjei_vbe*Qjei + model->HICUMhjci*Qjci; + Q_0_Vbiei = hjei_vbe_Vbiei*Qjei+hjei_vbe*Cjei; + Q_0_Vbici = model->HICUMhjci*Cjci; + Q_bpt = a_bpt*here->HICUMqp0_t; + b_q = Q_0/Q_bpt-1; + b_q_Vbiei = Q_0_Vbiei/Q_bpt; + b_q_Vbici = Q_0_Vbici/Q_bpt; + Q_0 = Q_bpt*(1+(b_q +sqrt(b_q*b_q+1.921812))/2); + Q_0_Vbiei = Q_bpt*(b_q*b_q_Vbiei/sqrt(b_q*b_q+1.921812)+b_q_Vbiei)/2; + Q_0_Vbici = Q_bpt*(b_q*b_q_Vbici/sqrt(b_q*b_q+1.921812)+b_q_Vbici)/2; + + //Transit time calculation at low current density + if(here->HICUMcjci0_t > 0.0) { // CJMODF + double cV_f,cv_e,cs_q,cs_q2,cv_j,cdvj_dv; + double cv_e_Vbici,cs_q_Vbici,cs_q2_Vbici,cv_j_Vbici,cdvj_dv_Vbici,dpart,dpart_Vbici; + cV_f = here->HICUMvdci_t*(1.0-exp(-log(2.4)/model->HICUMzci)); + cv_e = (cV_f-Vbici)/here->HICUMvt; + cv_e_Vbici =-1/here->HICUMvt; + cs_q = sqrt(cv_e*cv_e+1.921812); + cs_q_Vbici = cv_e*cv_e_Vbici/cs_q; + cs_q2 = (cv_e+cs_q)*0.5; + cs_q2_Vbici = (cv_e_Vbici+cs_q_Vbici)*0.5; + cv_j = cV_f-here->HICUMvt*cs_q2; + cv_j_Vbici =-here->HICUMvt*cs_q2_Vbici; + cdvj_dv = cs_q2/cs_q; + cdvj_dv_Vbici = (cs_q2_Vbici*cs_q-cs_q_Vbici*cs_q2)/(cs_q*cs_q); + dpart = here->HICUMcjci0_t*exp(-model->HICUMzci*log(1.0-cv_j/here->HICUMvdci_t)); + dpart_Vbici = cv_j_Vbici*model->HICUMzci*dpart/((1.0-cv_j/here->HICUMvdci_t)*here->HICUMvdci_t); + Cjcit = dpart*cdvj_dv+2.4*here->HICUMcjci0_t*(1.0-cdvj_dv); + Cjcit_Vbici = dpart_Vbici*cdvj_dv+dpart*cdvj_dv_Vbici-2.4*here->HICUMcjci0_t*cdvj_dv_Vbici; + } else { + Cjcit = 0.0; + Cjcit_Vbici = 0.0; + } + if(Cjcit > 0.0) { + cc = here->HICUMcjci0_t/Cjcit; + cc_Vbici = -here->HICUMcjci0_t*Cjcit_Vbici/(Cjcit*Cjcit); + } else { + cc = 1.0; + cc_Vbici = 0.0; + } + T_f0 = here->HICUMt0_t+model->HICUMdt0h*(cc-1.0)+model->HICUMtbvl*(1/cc-1.0); + T_f0_Vbici = model->HICUMdt0h*cc_Vbici+model->HICUMtbvl*(-cc_Vbici*cc/(cc*cc)); + + //Effective collector voltage + vc = Vciei-here->HICUMvces_t; + + //Critical current for onset of high-current effects + { // HICICK + double Ovpt,a,d1,vceff,a1,a11,Odelck,ick1,ick2,ICKa; + double d1_Vciei, vceff_Vciei, a1_Vciei, ick1_Vciei, ick2_Vciei, ICKa_Vciei; + Ovpt = 1.0/model->HICUMvpt; + a = vc/here->HICUMvt; + d1 = a-1; + vceff = (1.0+((d1+sqrt(d1*d1+1.921812))/2))*here->HICUMvt; + + a1 = vceff/here->HICUMvlim_t; + a11 = vceff*Orci0_t; + Odelck = 1/model->HICUMdelck; + ick1 = exp(Odelck*log(1+exp(model->HICUMdelck*log(a1)))); + ick2 = a11/ick1; + ICKa = (vceff-here->HICUMvlim_t)*Ovpt; + ick = ick2*(1.0+0.5*(ICKa+sqrt(ICKa*ICKa+model->HICUMaick))); + + // derivative: maxima + d1_Vciei = 1/here->HICUMvt; + // vceff_Vciei = (((d_1*d1_Vciei/sqrt(d_1^2+1.921812)+d1_Vciei)*v_t)/2 + vceff_Vciei = (d1*d1_Vciei/sqrt(d1*d1+1.921812)+d1_Vciei)*here->HICUMvt/2; + a1_Vciei = vceff_Vciei/here->HICUMvlim_t; + // ick1_Vciei = (exp(log(exp(d_elck*log(a1))+1)/d_elck+d_elck*log(a1))*a1_Vciei)/(a1*(exp(d_elck*log(a1))+1)) + ick1_Vciei = (exp(Odelck*log(1+exp(model->HICUMdelck*log(a1))) + model->HICUMdelck*log(a1))*a1_Vciei)/(a1*(exp(model->HICUMdelck*log(a1))+1)); + ick2_Vciei = -1.0*a11*ick1_Vciei/ick1/ick1; + ICKa_Vciei = vceff_Vciei*Ovpt; + + // ick_Vciei = (0.5*(sqrt(I_CKa(x)^2+a_ick)+I_CKa(x))+1.0)*('diff(i_ck2(x),x,1))+0.5*i_ck2(x)*((I_CKa(x)*('diff(I_CKa(x),x,1)))/sqrt(I_CKa(x)^2+a_ick)+'diff(I_CKa(x),x,1)) + ick_Vciei = (0.5*(sqrt(ICKa*ICKa+model->HICUMaick)+ICKa)+1.0)*ick2_Vciei+0.5*ick2*((ICKa*(ICKa_Vciei))/sqrt(ICKa*ICKa+model->HICUMaick)+ICKa_Vciei); + } + + //Initialization + //Transfer current, minority charges and transit times + + Tr = model->HICUMtr; + VT_f = model->HICUMmcf*here->HICUMvt; + i_0f = here->HICUMc10_t * exp(Vbiei/VT_f); + i_0f_Vbiei = i_0f/VT_f; + i_0r = here->HICUMc10_t * exp(Vbici/here->HICUMvt); + i_0r_Vbici = i_0r/here->HICUMvt; + + //Initial formulation of forward and reverse component of transfer current + Q_p = Q_0; + Q_p_Vbiei=Q_0_Vbiei; + Q_p_Vbici=Q_0_Vbici; + if (T_f0 > 0.0 || Tr > 0.0) { + double A,A_Vbiei,A_Vbici,d1,d1_Vbiei,d1_Vbici; + A = 0.5*Q_0; + A_Vbiei = 0.5*Q_0_Vbiei; + A_Vbici = 0.5*Q_0_Vbici; + d1 = sqrt(A*A+T_f0*i_0f+Tr*i_0r); + d1_Vbiei= (2*A*A_Vbiei+T_f0*i_0f_Vbiei)/(2*d1); + d1_Vbici= (2*A*A_Vbici+Tr*i_0r_Vbici)/(2*d1); + Q_p = A+d1; + Q_p_Vbiei=A_Vbiei+d1_Vbiei; + Q_p_Vbici=A_Vbici+d1_Vbici; + } + I_Tf1 = i_0f/Q_p; + I_Tf1_Vbiei=(i_0f_Vbiei*Q_p-i_0f*Q_p_Vbiei)/(Q_p*Q_p); + I_Tf1_Vbici=-i_0f*Q_p_Vbici/(Q_p*Q_p); + a_h = Oich*I_Tf1; + itf = I_Tf1*(1.0+a_h); + itf_Vbiei=(Oich*I_Tf1+1.0)*I_Tf1_Vbiei+Oich*I_Tf1*I_Tf1_Vbiei; + itf_Vbici=(Oich*I_Tf1+1.0)*I_Tf1_Vbici+Oich*I_Tf1*I_Tf1_Vbici; + itr = i_0r/Q_p; + itr_Vbiei=-i_0r*Q_p_Vbiei/(Q_p*Q_p); + itr_Vbici=(i_0r_Vbici*Q_p-i_0r*Q_p_Vbiei)/(Q_p*Q_p); + + //Initial formulation of forward transit time, diffusion, GICCR and excess b-c charge + Q_bf = 0.0; + Tf = T_f0; + Qf = T_f0*itf; + HICQFF(here, model, itf,ick,&Tf,&Qf,&T_fT,&Q_fT,&Q_bf); + //Initial formulation of reverse diffusion charge + Qr = Tr*itr; + + //Preparation for iteration to get total hole charge and related variables + l_it = 0; + if(Qf > RTOLC*Q_p || a_h > RTOLC) { + //Iteration for Q_pT is required for improved initial solution + Qf = sqrt(T_f0*itf*Q_fT); + Q_pT = Q_0+Qf+Qr; + d_Q = Q_pT; + while (fabs(d_Q) >= RTOLC*fabs(Q_pT) && l_it <= l_itmax) { + double a; + I_Tf1 = i_0f/Q_pT; + a_h = Oich*I_Tf1; + itf = I_Tf1*(1.0+a_h); + itr = i_0r/Q_pT; + Tf = T_f0; + Qf = T_f0*itf; + HICQFF(here, model, itf,ick,&Tf,&Qf,&T_fT,&Q_fT,&Q_bf); + Qr = Tr*itr; + if(Oich == 0.0) { + a = 1.0+(T_fT*itf+Qr)/Q_pT; + } else { + a = 1.0+(T_fT*I_Tf1*(1.0+2.0*a_h)+Qr)/Q_pT; + } + d_Q = -(Q_pT-(Q_0+Q_fT+Qr))/a; + //Limit maximum change of Q_pT + a = fabs(0.3*Q_pT); + if(fabs(d_Q) > a) { + if (d_Q>=0) { + d_Q = a; + } else { + d_Q = -a; + } + } + Q_pT = Q_pT+d_Q; + l_it = l_it+1; + } //while + + I_Tf1 = i_0f/Q_pT; + a_h = Oich*I_Tf1; + itf = I_Tf1*(1.0+a_h); + itr = i_0r/Q_pT; + + //Final transit times, charges and transport current components + Tf = T_f0; + Qf = T_f0*itf; + HICQFF(here, model, itf,ick,&Tf,&Qf,&T_fT,&Q_fT,&Q_bf); + Qr = Tr*itr; + + } //if + // TODO calculate here the derivatives once! They are not needed inside the newton... + // Qf = Tf*itf; + Qf_Vbiei = 0; + Qf_Vbici = 0; + // Qr = Tr*itr; + Qr_Vbiei = 0; + Qr_Vbici = 0; + // Q_pT = Q_0+Qf+Qr; + Q_pT_Vbiei = Q_0_Vbiei + Qf_Vbiei + Qr_Vbiei; + Q_pT_Vbici = Q_0_Vbici + Qf_Vbici + Qr_Vbici; + // Q_bf = Q_0+Qf+Qr; + Q_bf_Vbiei = 0; + Q_bf_Vbici = 0; + + // itf, itr +//TODO: itf=f(Vbiei,Vbici) -> Qf, Q_bf Ableitungen nach Vbiei, Vbici + itf_Vbiei = itf/VT_f; // TODO: missing the derivatives of Qf + itr_Vbici = itr/here->HICUMvt; // TODO: missing the derivatives of Qpt + + //NQS effect implemented with LCR networks + //Once the delay in ITF is considered, IT_NQS is calculated afterwards + + it = itf-itr; + + //Diffusion charges for further use + Qdei = Qf; + Qdci = Qr; + + + //High-frequency emitter current crowding (lateral NQS) + Cdei = T_f0*itf/here->HICUMvt; + Cdci = model->HICUMtr*itr/here->HICUMvt; + Crbi = model->HICUMfcrbi*(Cjei+Cjci+Cdei+Cdci); + Qrbi = Crbi*Vbpbi; + Qrbi_Vbpbi = Crbi; + Qrbi_Vbiei = Vbpbi*model->HICUMfcrbi*(T_f0*itf_Vbiei+Cjei_Vbiei); + Qrbi_Vbici = Vbpbi*model->HICUMfcrbi*(model->HICUMtr*itr_Vbici+Cjci_Vbici); + + // Qrbi = model->HICUMfcrbi*(Qjei+Qjci+Qdei+Qdci); + + //HICCR: } + + //Internal base current across b-c junction + HICDIO(here->HICUMvt,model->HICUMibcis,here->HICUMibcis_t,model->HICUMmbci,Vbici,&ibci,&Ibici_Vbici); + + //Avalanche current + if (use_aval == 1) { // HICAVL + double v_bord,v_q,U0,av,avl,avl_Vbici,v_q_Vbici,av_Vbici; + v_bord = here->HICUMvdci_t-Vbici; + if (v_bord > 0) { + v_q = here->HICUMqavl_t/Cjci; + v_q_Vbici = -here->HICUMqavl_t*Cjci_Vbici/(Cjci*Cjci); + U0 = here->HICUMqavl_t/here->HICUMcjci0_t; + if(v_bord > U0) { + av = here->HICUMfavl_t*exp(-v_q/U0); + av_Vbici = -av*v_q_Vbici/U0; + avl = av*(U0+(1.0+v_q/U0)*(v_bord-U0)); + avl_Vbici = av*((-v_q/U0-1)+(v_bord-U0)*v_q_Vbici/U0)+((v_q/U0+1)*(v_bord-U0)+U0)*av_Vbici; + } else { + avl = here->HICUMfavl_t*v_bord*exp(-v_q/v_bord); + avl_Vbici = avl*(-v_q/(v_bord*v_bord)-v_q_Vbici/v_bord)-avl/v_bord; + } + /* This model turns strong avalanche on. The parameter kavl can turn this + * model extension off (kavl = 0). Although this is numerically stable, a + * conditional statement is applied in order to reduce the numerical over- + * head for simulations without the new model. + */ + if (model->HICUMkavl > 0) { // HICAVLHIGH + double denom,sq_smooth,hl; + denom = 1-here->HICUMkavl_t*avl; + // Avoid denom < 0 using a smoothing function + sq_smooth = sqrt(denom*denom+0.01); + hl = 0.5*(denom+sq_smooth); + iavl = itf*avl/hl; + iavl_Vbici = itf*avl_Vbici/hl; // TODO itf_Vbici + } else { + iavl = itf*avl; + iavl_Vbici = itf*avl_Vbici; // TODO itf_Vbici + } + } + } else { + iavl = 0.0; + iavl_Vbici = 0.0; + } + + //Excess base current from recombination at the b-c barrier + ibh_rec = Q_bf*Otbhrec; +//todo: Q_bf derivatives to Vbiei + ibh_rec_Vbiei = 0.0; + +//todo: Qf derivatives to Vbiei, Vbici + //Internal base resistance = f(Vbiei, Vbici) + if(here->HICUMrbi0_t > 0.0) { // HICRBI + double Qz_nom,f_QR,ETA,Qz0,fQz,ETA_Vbiei,ETA_Vbici,fQz_Vbiei,fQz_Vbici,Qz_nom_Vbiei,Qz_nom_Vbici,d1; + // Consideration of conductivity modulation + // To avoid convergence problem hyperbolic smoothing used + f_QR = (1+model->HICUMfdqr0)*here->HICUMqp0_t; + Qz0 = Qjei+Qjci+Qf; + Qz_nom = 1+Qz0/f_QR; + Qz_nom_Vbiei=Cjei/f_QR; + Qz_nom_Vbici=Cjci/f_QR; + d1 = sqrt(Qz_nom*Qz_nom+0.01); + fQz = 0.5*(Qz_nom+d1); + fQz_Vbiei=0.5*(Qz_nom*Qz_nom_Vbiei/d1+Qz_nom_Vbiei); + fQz_Vbici=0.5*(Qz_nom*Qz_nom_Vbici/d1+Qz_nom_Vbici); + rbi = here->HICUMrbi0_t/fQz; + rbi_Vbiei=-here->HICUMrbi0_t*fQz_Vbiei/(fQz*fQz); + rbi_Vbici=-here->HICUMrbi0_t*fQz_Vbici/(fQz*fQz); + // Consideration of emitter current crowding + if( ibei > 0.0) { + ETA = rbi*ibei*model->HICUMfgeo/here->HICUMvt; + ETA_Vbiei = (rbi*Ibiei_Vbiei+rbi_Vbiei*ibei)*model->HICUMfgeo/here->HICUMvt; + ETA_Vbici = rbi_Vbici*ibei*model->HICUMfgeo/here->HICUMvt; + if(ETA < 1.0e-6) { + rbi = rbi*(1.0-0.5*ETA); + rbi_Vbiei = rbi_Vbiei-0.5*(rbi*ETA_Vbiei+rbi_Vbiei*ETA); + rbi_Vbici = rbi_Vbici-0.5*(rbi*ETA_Vbici+rbi_Vbici*ETA); + } else { + rbi = rbi*log(1.0+ETA)/ETA; + rbi_Vbiei=log(ETA+1)*rbi_Vbiei/ETA - rbi*ETA_Vbiei*log(ETA+1)/ETA/ETA + rbi*ETA_Vbiei/(ETA*(ETA+1)); + rbi_Vbici=log(ETA+1)*rbi_Vbici/ETA - rbi*ETA_Vbici*log(ETA+1)/ETA/ETA + rbi*ETA_Vbici/(ETA*(ETA+1)); + } + } + // Consideration of peripheral charge + if(Qf > 0.0) { + rbi = rbi*(Qjei+Qf*model->HICUMfqi)/(Qjei+Qf); + // Qf_Viei and Qf_Vbici + rbi_Vbiei = (Qjei+Qf*model->HICUMfqi)*rbi_Vbiei/(Qjei+Qf) + rbi*Cjei/(Qjei+Qf) - (Qjei+Qf*model->HICUMfqi)*rbi*Cjei/(Qjei+Qf)/(Qjei+Qf); + rbi_Vbici = rbi_Vbici*(Qjei+Qf*model->HICUMfqi)/(Qjei+Qf); + } + } else { + rbi = 0.0; + rbi_Vbiei = 0.0; + rbi_Vbici = 0.0; + } + + //Base currents across peripheral b-e junction + HICDIO(here->HICUMvt,model->HICUMibeps,here->HICUMibeps_t,model->HICUMmbep,Vbpei,&ibep,&Ibpei_Vbpei); + HICDIO(here->HICUMvt,model->HICUMireps,here->HICUMireps_t,model->HICUMmrep,Vbpei,&irep,&irep_Vbpei); + + //Peripheral b-e junction capacitance and charge + QJMODF(here->HICUMvt,here->HICUMcjep0_t,here->HICUMvdep_t,model->HICUMzep,here->HICUMajep_t,Vbpei,&Cjep,&Cjep_Vbpei,&Qjep); + + //Tunneling current + if (model->HICUMibets > 0 && (Vbpei <0.0 || Vbiei < 0.0)) { // HICTUN + double pocce,czz,pocce_Vbpei,czz_Vbpei,pocce_Vbiei,czz_Vbiei; + if(model->HICUMtunode==1 && here->HICUMcjep0_t > 0.0 && here->HICUMvdep_t >0.0) { + pocce = exp((1-1/model->HICUMzep)*log(Cjep/here->HICUMcjep0_t)); + pocce_Vbpei = Cjep_Vbpei*(1-1/model->HICUMzep)*pocce/Cjep; + czz = -(Vbpei/here->HICUMvdep_t)*here->HICUMibets_t*pocce; + czz_Vbpei = -here->HICUMibets_t/here->HICUMvdep_t*(pocce+Vbpei*pocce_Vbpei); + ibet = czz*exp(-here->HICUMabet_t/pocce); + ibet_Vbpei = ibet*(here->HICUMabet_t*pocce_Vbpei/(pocce*pocce)+czz_Vbpei/czz); + } else if (model->HICUMtunode==0 && here->HICUMcjei0_t > 0.0 && here->HICUMvdei_t >0.0) { + pocce = exp((1-1/model->HICUMzei)*log(Cjei/here->HICUMcjei0_t)); + pocce_Vbiei = Cjei_Vbiei*(1-1/model->HICUMzei)*pocce/Cjei; + czz = -(Vbiei/here->HICUMvdei_t)*here->HICUMibets_t*pocce; + czz_Vbiei = -here->HICUMibets_t/here->HICUMvdei_t*(pocce+Vbiei*pocce_Vbiei); + ibet = czz*exp(-here->HICUMabet_t/pocce); + ibet_Vbiei = ibet*(here->HICUMabet_t*pocce_Vbiei/(pocce*pocce)+czz_Vbiei/czz); + } else { + ibet = 0.0; + ibet_Vbpei = 0.0; + ibet_Vbiei = 0.0; + } + } else { + ibet = 0.0; + ibet_Vbpei = 0.0; + ibet_Vbiei = 0.0; + } + + + //Base currents across peripheral b-c junction (bp,ci) + HICDIO(here->HICUMvt,model->HICUMibcxs,here->HICUMibcxs_t,model->HICUMmbcx,Vbpci,&ijbcx,&Ibpci_Vbpci); + + //Depletion capacitance and charge at external b-c junction (b,ci) + HICJQ(here->HICUMvt,here->HICUMcjcx01_t,here->HICUMvdcx_t,model->HICUMzcx,here->HICUMvptcx_t,Vbci,&CjCx_i,&CjCx_i_Vbci,&qjcx0_t_i); + + //Depletion capacitance and charge at peripheral b-c junction (bp,ci) + HICJQ(here->HICUMvt,here->HICUMcjcx02_t,here->HICUMvdcx_t,model->HICUMzcx,here->HICUMvptcx_t,Vbpci,&CjCx_ii,&CjCx_ii_Vbpci,&qjcx0_t_ii); + + //Depletion substrate capacitance and charge at inner s-c junction (si,ci) + HICJQ(here->HICUMvt,here->HICUMcjs0_t,here->HICUMvds_t,model->HICUMzs,here->HICUMvpts_t,Vsici,&Cjs,&Cjs_Vsici,&Qjs); + /* Peripheral substrate capacitance and charge at s-c junction (s,c) + * Bias dependent only if model->HICUMvdsp > 0 + */ + if (model->HICUMvdsp > 0) { + HICJQ(here->HICUMvt,here->HICUMcscp0_t,here->HICUMvdsp_t,model->HICUMzsp,here->HICUMvptsp_t,Vsc,&Cscp,&Cscp_Vsc,&Qscp); + } else { + // Constant, temperature independent capacitance + Cscp = model->HICUMcscp0; + Qscp = model->HICUMcscp0*Vsc; + } + + //Parasitic substrate transistor transfer current and diffusion charge + if(model->HICUMitss > 0.0) { // Sub_Transfer + double HSa,HSb; + HSUM = model->HICUMmsf*here->HICUMvt; + HSa = exp(Vbpci/HSUM); + HSb = exp(Vsici/HSUM); + HSI_Tsu = here->HICUMitss_t*(HSa-HSb); + Ibpsi_Vbpci = here->HICUMitss_t*HSa/HSUM; + Ibpsi_Vsici = -here->HICUMitss_t*HSb/HSUM; + if(model->HICUMtsf > 0.0) { + Qdsu = here->HICUMtsf_t*here->HICUMitss_t*HSa; + Qdsu_Vbpci = here->HICUMtsf_t*here->HICUMitss_t*HSa/HSUM; + } else { + Qdsu = 0.0; + Qdsu_Vbpci = 0.0; + } + } else { + HSI_Tsu = 0.0; + Ibpsi_Vbpci = 0.0; + Ibpsi_Vsici = 0.0; + Qdsu = 0.0; + Qdsu_Vbpci = 0.0; + } + + // Current gain computation for correlated noise implementation + if (ibei > 0.0) { + here->HICUMbetadc=it/ibei; + } else { + here->HICUMbetadc=0.0; + } + Ieie = Veie/here->HICUMre_t; // only needed for re flicker noise + + //Diode current for s-c junction (si,ci) + HICDIO(here->HICUMvt,model->HICUMiscs,here->HICUMiscs_t,model->HICUMmsc,Vsici,&ijsc,&Isici_Vsici); + + //Self-heating calculation + if (model->HICUMflsh == 1 && model->HICUMrth >= MIN_R) { + pterm = Vciei*it + (here->HICUMvdci_t-Vbici)*iavl; + } else if (model->HICUMflsh == 2 && model->HICUMrth >= MIN_R) { + pterm = Vciei*it + (here->HICUMvdci_t-Vbici)*iavl + ibei*Vbiei + ibci*Vbici + ibep*Vbpei + ijbcx*Vbpci + ijsc*Vsici; + if (rbi >= MIN_R) { + pterm = pterm + Vbpbi*Vbpbi/rbi; + } + if (here->HICUMre_t >= MIN_R) { + pterm = pterm + Veie*Veie/here->HICUMre_t; + } + if (here->HICUMrcx_t >= MIN_R) { + pterm = pterm + Vcic*Vcic/here->HICUMrcx_t; + } + if (here->HICUMrbx_t >= MIN_R) { + pterm = pterm + Vbbp*Vbbp/here->HICUMrbx_t; + } + } + + Itxf = itf; + Qdeix = Qdei; + + // Excess Phase calculation + + if ((model->HICUMflnqs != 0 || model->HICUMflcomp == 0.0 || model->HICUMflcomp == 2.1) && Tf != 0 && (model->HICUMalit > 0 || model->HICUMalqf > 0)) { + Vxf1 = Vbxf1; + Vxf2 = Vbxf2; + + Ixf1 = (Vxf2-itf)/Tf*model->HICUMt0; + Ixf2 = (Vxf2-Vxf1)/Tf*model->HICUMt0; + Qxf1 = model->HICUMalit*model->HICUMt0*Vxf1; + Qxf1_Vxf1 = model->HICUMalit*model->HICUMt0; + Qxf2 = model->HICUMalit*model->HICUMt0*Vxf2/3; + Qxf2_Vxf2 = model->HICUMalit*model->HICUMt0/3; + Itxf = Vxf2; + + // TODO derivatives of Ixf1 and Ixf2 + + Vxf = Vbxf; //for RC nw + Ixf = (Vxf - Qdei)*model->HICUMt0/Tf; //for RC nw + Qxf = model->HICUMalqf*model->HICUMt0*Vxf; //for RC nw + Qxf_Vxf = model->HICUMalqf*model->HICUMt0; //for RC nw + Qdeix = Vxf; //for RC nw + } else { + Ixf1 = Vbxf1; + Ixf2 = Vbxf2; + Qxf1 = 0; + Qxf2 = 0; + Qxf1_Vxf1 = 0; + Qxf2_Vxf2 = 0; + + Ixf = Vbxf; + Qxf = 0; + Qxf_Vxf = 0; + } + + // end of Model_evaluation + + // Load_sources + + Ibpei = model->HICUMtype*ibep; + Ibpei += model->HICUMtype*irep; + Ibpei_Vbpei += model->HICUMtype*irep_Vbpei; + + Ibiei = model->HICUMtype*ibei; + Ibiei += model->HICUMtype*irei; + Ibiei_Vbiei += model->HICUMtype*irei_Vbiei; + Ibiei += model->HICUMtype*ibh_rec; + Ibiei_Vbiei += model->HICUMtype*ibh_rec_Vbiei; + + if (model->HICUMtunode==1.0) { + Ibpei += -model->HICUMtype*ibet; + Ibpei_Vbpei += -model->HICUMtype*ibet_Vbpei; + } else { + Ibiei += -model->HICUMtype*ibet; + Ibiei_Vbiei += -model->HICUMtype*ibet_Vbiei; + } +//printf("Vbiei: %f ibei: %g irei: %g ibh_rec: %g ibet: %g\n",Vbiei,ibei,irei,ibh_rec,ibet); + Ibpsi = model->HICUMtype*HSI_Tsu; + + Ibpci = model->HICUMtype*ijbcx; + + Ibici = model->HICUMtype*(ibci - iavl); + Ibici_Vbici = model->HICUMtype*(Ibici_Vbici - iavl_Vbici); + + Isici = model->HICUMtype*ijsc; + + Iciei = model->HICUMtype*(Itxf - itr); + Iciei_Vbiei = model->HICUMtype*itf_Vbiei; + Iciei_Vbici = -model->HICUMtype*itr_Vbici; + +//printf("Vbiei: %f Vbici: %f Vciei: %f Vbpei: %f Vbpci: %f Vbci: %f Vsici: %f\n", Vbiei, Vbici, Vciei, Vbpei, Vbpci, Vbci, Vsici); +//printf("Ibiei: %g Ibici: %g Ibpei: %g Iciei: %g\n",Ibiei,Ibici,Ibpei,Iciei); + + // Following code is an intermediate solution (if branch contribution is not supported): + // ****************************************** + //if(model->HICUMflsh == 0 || model->HICUMrth < MIN_R) { + // I[br_sht] <+ Vrth/MIN_R; + //} else { + // I[br_sht] <+ Vrth/rth_t-pterm; + // I[br_sht] <+ ddt(model->HICUMcth*Vrth]); + //} + + // ****************************************** + + // For simulators having no problem with Vrth) <+ 0.0 + // with external thermal node, following code may be used. + // Note that external thermal node should remain accessible + // even without self-heating. + // ******************************************** + Ith_Vbiei = 0.0; + Ith_Vbici = 0.0; + Ith_Vbpbi = 0.0; + Ith_Vbpci = 0.0; + Ith_Vbpei = 0.0; + Ith_Vciei = 0.0; + Ith_Vsici = 0.0; + Ith_Vcic = 0.0; + Ith_Vbbp = 0.0; + Ith_Veie = 0.0; + Ith_Vrth = 0.0; + if(model->HICUMflsh == 0 || model->HICUMrth < MIN_R) { + Ith = 0.0; + } else { + Ith = Vrth/here->HICUMrth_t-pterm; + if (model->HICUMflsh == 1 && model->HICUMrth >= MIN_R) { + Ith_Vciei = -it; + Ith_Vbici = iavl; + } else if (model->HICUMflsh == 2 && model->HICUMrth >= MIN_R) { + Ith_Vciei = -it; + Ith_Vbiei = -ibei; + Ith_Vbici = -ibci+iavl; + Ith_Vbpei = -ibep; + Ith_Vbpci = -ijbcx; + Ith_Vsici = -ijsc; + if (rbi >= MIN_R) { + Ith_Vbpbi = -Vbpbi*Vbpbi/rbi; + } + if (here->HICUMre_t >= MIN_R) { + Ith_Veie = -Veie*Veie/here->HICUMre_t; + } + if (here->HICUMrcx_t >= MIN_R) { + Ith_Vcic = -Vcic*Vcic/here->HICUMrcx_t; + } + if (here->HICUMrbx_t >= MIN_R) { + Ith_Vbbp = -Vbbp*Vbbp/here->HICUMrbx_t; + } + } + } + // ******************************************** + + // NQS effect +// Ibxf1 = Ixf1; +// Icxf1 += ddt(Qxf1); +// Ibxf2 = Ixf2; +// Icxf2 += ddt(Qxf2); + + // end of Load_sources + + if (rbi >= MIN_R) { + Ibpbi_Vbpbi = 1 / rbi; + Ibpbi = Vbpbi / rbi; + } else { + Ibpbi_Vbpbi = 1 / MIN_R; + Ibpbi = Vbpbi / MIN_R; + } + Ibpbi_Vbiei = -Vbpbi * rbi_Vbiei / (rbi*rbi); + Ibpbi_Vbici = -Vbpbi * rbi_Vbici / (rbi*rbi); + + Ibbp_Vbbp = 1/here->HICUMrbx_t; + Icic_Vcic = 1/here->HICUMrcx_t; + Ieie_Veie = 1/here->HICUMre_t; + Isis_Vsis = 1/model->HICUMrsu; + + qjcx0_t_i_Vbci = CjCx_i; + qjcx0_t_ii_Vbpci = CjCx_ii; + Qjep_Vbpei = Cjep; + Qdeix_Vbiei = Cdei; + Qdci_Vbici = Cdci; + Qbepar1_Vbe = cbepar1; + Qbepar2_Vbpe = cbepar2; + Qbcpar1_Vbci = cbcpar1; + Qbcpar2_Vbpci = cbcpar2; + Qsu_Vsis = model->HICUMcsu; + Qjs_Vsici = Cjs; + +//todo: all the derivatives have to be known dI/dT + Ibbp_Vrth = 0.0; + Ieie_Vrth = 0.0; + Icic_Vrth = 0.0; + Irth_Vrth = 0.0; + Ibici_Vrth = 0.0; + Ibpei_Vrth = 0.0; + Ibiei_Vrth = 0.0; + Ibpci_Vrth = 0.0; + Ibpbi_Vrth = 0.0; + Iciei_Vrth = 0.0; + Isici_Vrth = 0.0; + +//todo: what about dQ/dT ? + + Ibiei += ckt->CKTgmin*Vbiei; + Ibiei_Vbiei += ckt->CKTgmin; + Ibici += ckt->CKTgmin*Vbici; + Ibici_Vbici += ckt->CKTgmin; + Iciei += ckt->CKTgmin*Vciei; + Iciei_Vbiei += ckt->CKTgmin; + Iciei_Vbici += ckt->CKTgmin; + Ibpei += ckt->CKTgmin*Vbpei; + Ibpei_Vbpei += ckt->CKTgmin; + Ibpbi += ckt->CKTgmin*Vbpbi; + Ibpbi_Vbiei += ckt->CKTgmin; + Ibpbi_Vbici += ckt->CKTgmin; + Ibpci += ckt->CKTgmin*Vbpci; + Ibpci_Vbpci += ckt->CKTgmin; + Isici += ckt->CKTgmin*Vsici; + Isici_Vsici += ckt->CKTgmin; + + if( (ckt->CKTmode & (MODEDCTRANCURVE | MODETRAN | MODEAC)) || + ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)) || + (ckt->CKTmode & MODEINITSMSIG)) { + /* + * charge storage elements + */ + Qbepar1=cbepar1*Vbe; + Qbepar2=cbepar2*Vbpe; + Qbcpar1=cbcpar1*Vbci; + Qbcpar2=cbcpar2*Vbpci; + Qsu=model->HICUMcsu*Vsis; + Qcth=model->HICUMcth*Vrth; + + *(ckt->CKTstate0 + here->HICUMqrbi) = Qrbi; + *(ckt->CKTstate0 + here->HICUMqdeix) = Qdeix; + *(ckt->CKTstate0 + here->HICUMqjei) = Qjei; + *(ckt->CKTstate0 + here->HICUMqdci) = Qdci; + *(ckt->CKTstate0 + here->HICUMqjci) = Qjci; + *(ckt->CKTstate0 + here->HICUMqjep) = Qjep; + *(ckt->CKTstate0 + here->HICUMqjcx0_i) = qjcx0_t_i; + *(ckt->CKTstate0 + here->HICUMqjcx0_ii) = qjcx0_t_ii; + *(ckt->CKTstate0 + here->HICUMqdsu) = Qdsu; + *(ckt->CKTstate0 + here->HICUMqjs) = Qjs; + *(ckt->CKTstate0 + here->HICUMqscp) = Qscp; + *(ckt->CKTstate0 + here->HICUMqbepar1) = Qbepar1; + *(ckt->CKTstate0 + here->HICUMqbepar2) = Qbepar2; + *(ckt->CKTstate0 + here->HICUMqbcpar1) = Qbcpar1; + *(ckt->CKTstate0 + here->HICUMqbcpar2) = Qbcpar2; + *(ckt->CKTstate0 + here->HICUMqsu) = Qsu; +//NQS + *(ckt->CKTstate0 + here->HICUMqxf1) = Qxf1; + *(ckt->CKTstate0 + here->HICUMqxf2) = Qxf2; + *(ckt->CKTstate0 + here->HICUMqxf) = Qxf; + if (model->HICUMflsh) + *(ckt->CKTstate0 + here->HICUMqcth) = Qcth; + + here->HICUMcaprbi = Qrbi_Vbpbi; + here->HICUMcapdeix = Cdei; + here->HICUMcapjei = Cjei; + here->HICUMcapdci = Cdci; + here->HICUMcapjci = Cjci; + here->HICUMcapjep = Cjep; + here->HICUMcapjcx_t_i = CjCx_i; + here->HICUMcapjcx_t_ii = CjCx_ii; + here->HICUMcapdsu = Qdsu_Vbpci; + here->HICUMcapjs = Cjs; + here->HICUMcapscp = Cscp; + here->HICUMcapsu = model->HICUMcsu; + here->HICUMcapcth = model->HICUMcth; + here->HICUMcapscp = Cscp; + + /* + * store small-signal parameters + */ + if ( (!(ckt->CKTmode & MODETRANOP))|| + (!(ckt->CKTmode & MODEUIC)) ) { + if(ckt->CKTmode & MODEINITSMSIG) { + *(ckt->CKTstate0 + here->HICUMcqrbi) = Qrbi_Vbpbi; + *(ckt->CKTstate0 + here->HICUMcqdeix) = Qdeix_Vbiei; + *(ckt->CKTstate0 + here->HICUMcqjei) = Cjei; + *(ckt->CKTstate0 + here->HICUMcqdci) = Qdci_Vbici; + *(ckt->CKTstate0 + here->HICUMcqjci) = Cjci; + *(ckt->CKTstate0 + here->HICUMcqjep) = Qjep_Vbpei; + *(ckt->CKTstate0 + here->HICUMcqcx0_t_i) = qjcx0_t_i_Vbci; + *(ckt->CKTstate0 + here->HICUMcqcx0_t_ii) = qjcx0_t_ii_Vbpci; + *(ckt->CKTstate0 + here->HICUMcqdsu) = Qdsu_Vbpci; + *(ckt->CKTstate0 + here->HICUMcqjs) = Qjs_Vsici; + *(ckt->CKTstate0 + here->HICUMcqscp) = Cscp; + *(ckt->CKTstate0 + here->HICUMcqbepar1) = Qbepar1_Vbe; + *(ckt->CKTstate0 + here->HICUMcqbepar2) = Qbepar2_Vbpe; + *(ckt->CKTstate0 + here->HICUMcqbcpar1) = Qbcpar1_Vbci; + *(ckt->CKTstate0 + here->HICUMcqbcpar2) = Qbcpar2_Vbpci; + *(ckt->CKTstate0 + here->HICUMcqsu) = Qsu_Vsis; +//NQS + *(ckt->CKTstate0 + here->HICUMcqxf1) = Qxf1_Vxf1; + *(ckt->CKTstate0 + here->HICUMcqxf2) = Qxf2_Vxf2; + *(ckt->CKTstate0 + here->HICUMcqxf) = Qxf_Vxf; + if (model->HICUMflsh) + *(ckt->CKTstate0 + here->HICUMcqcth) = model->HICUMcth; + continue; /* go to 1000 */ + } + /* + * transient analysis + */ + if(ckt->CKTmode & MODEINITTRAN) { + *(ckt->CKTstate1 + here->HICUMqrbi) = + *(ckt->CKTstate0 + here->HICUMqrbi) ; + *(ckt->CKTstate1 + here->HICUMqjei) = + *(ckt->CKTstate0 + here->HICUMqjei) ; + *(ckt->CKTstate1 + here->HICUMqdeix) = + *(ckt->CKTstate0 + here->HICUMqdeix) ; + *(ckt->CKTstate1 + here->HICUMqjci) = + *(ckt->CKTstate0 + here->HICUMqjci) ; + *(ckt->CKTstate1 + here->HICUMqdci) = + *(ckt->CKTstate0 + here->HICUMqdci) ; + *(ckt->CKTstate1 + here->HICUMqjep) = + *(ckt->CKTstate0 + here->HICUMqjep) ; + *(ckt->CKTstate1 + here->HICUMqjcx0_i) = + *(ckt->CKTstate0 + here->HICUMqjcx0_i) ; + *(ckt->CKTstate1 + here->HICUMqjcx0_ii) = + *(ckt->CKTstate0 + here->HICUMqjcx0_ii) ; + *(ckt->CKTstate1 + here->HICUMqdsu) = + *(ckt->CKTstate0 + here->HICUMqdsu) ; + *(ckt->CKTstate1 + here->HICUMqjs) = + *(ckt->CKTstate0 + here->HICUMqjs) ; + *(ckt->CKTstate1 + here->HICUMqscp) = + *(ckt->CKTstate0 + here->HICUMqscp) ; + *(ckt->CKTstate1 + here->HICUMqbepar1) = + *(ckt->CKTstate0 + here->HICUMqbepar1) ; + *(ckt->CKTstate1 + here->HICUMqbepar2) = + *(ckt->CKTstate0 + here->HICUMqbepar2) ; + *(ckt->CKTstate1 + here->HICUMqbcpar1) = + *(ckt->CKTstate0 + here->HICUMqbcpar1) ; + *(ckt->CKTstate1 + here->HICUMqbcpar2) = + *(ckt->CKTstate0 + here->HICUMqbcpar2) ; + *(ckt->CKTstate1 + here->HICUMqsu) = + *(ckt->CKTstate0 + here->HICUMqsu) ; +//NQS + *(ckt->CKTstate1 + here->HICUMqxf) = + *(ckt->CKTstate0 + here->HICUMqxf) ; + if (model->HICUMflsh) + *(ckt->CKTstate1 + here->HICUMqcth) = + *(ckt->CKTstate0 + here->HICUMqcth) ; + } + +// Ibpbi += ddt(Qrbi); + error = NIintegrate(ckt,&geq,&ceq,Qrbi_Vbpbi,here->HICUMqrbi); + if(error) return(error); + Ibpbi_Vbpbi += geq; + Ibpbi += *(ckt->CKTstate0 + here->HICUMcqrbi); + +// Ibiei += ddt(model->HICUMtype*(Qdeix+Qjei)); + error = NIintegrate(ckt,&geq,&ceq,Cdei,here->HICUMqdeix); + if(error) return(error); + Ibiei_Vbiei += geq; + Ibiei += *(ckt->CKTstate0 + here->HICUMcqdeix); + + error = NIintegrate(ckt,&geq,&ceq,Cjei,here->HICUMqjei); + if(error) return(error); + Ibiei_Vbiei += geq; + Ibiei += *(ckt->CKTstate0 + here->HICUMcqjep); + +// Ibici += ddt(model->HICUMtype*(Qdci+Qjci)); + error = NIintegrate(ckt,&geq,&ceq,Cdci,here->HICUMqdci); + if(error) return(error); + Ibici_Vbici += geq; + Ibici += *(ckt->CKTstate0 + here->HICUMcqdci); + + error = NIintegrate(ckt,&geq,&ceq,Cjci,here->HICUMqjci); + if(error) return(error); + Ibici_Vbici += geq; + Ibici += *(ckt->CKTstate0 + here->HICUMcqjci); + +// Ibpei += ddt(model->HICUMtype*Qjep); + error = NIintegrate(ckt,&geq,&ceq,Cjep,here->HICUMqjep); + if(error) return(error); + Ibpei_Vbpei += geq; + Ibpei += *(ckt->CKTstate0 + here->HICUMcqjep); + +// Isici += ddt(model->HICUMtype*Qjs); + error = NIintegrate(ckt,&geq,&ceq,Cjs,here->HICUMqjs); + if(error) return(error); + Isici_Vsici += geq; + Isici += *(ckt->CKTstate0 + here->HICUMcqjs); + +// Ibci += ddt(model->HICUMtype*qjcx0_t_i); + error = NIintegrate(ckt,&geq,&ceq,CjCx_i,here->HICUMqjcx0_i); + if(error) return(error); + Ibci_Vbci = geq; + Ibci = *(ckt->CKTstate0 + here->HICUMcqcx0_t_i); + +// Ibpci += ddt(model->HICUMtype*(qjcx0_t_ii+Qdsu)); + error = NIintegrate(ckt,&geq,&ceq,CjCx_ii,here->HICUMqjcx0_ii); + if(error) return(error); + Ibpci_Vbpci += geq; + Ibpci += *(ckt->CKTstate0 + here->HICUMcqcx0_t_ii); + + error = NIintegrate(ckt,&geq,&ceq,Qdsu_Vbpci,here->HICUMqdsu); + if(error) return(error); + Ibpci_Vbpci += geq; + Ibpci += *(ckt->CKTstate0 + here->HICUMcqdsu); + +// Isc += ddt(model->HICUMtype*Qscp); + error = NIintegrate(ckt,&geq,&ceq,Cscp,here->HICUMqscp); + if(error) return(error); + Isc_Vsc = geq; + Isc = *(ckt->CKTstate0 + here->HICUMcqscp); +//NQS +// Iqxf1 <+ ddt(Qxf1); + error = NIintegrate(ckt,&geq,&ceq,Qxf1_Vxf1,here->HICUMqxf); + if(error) return(error); + Iqxf1_Vxf1 = geq; + Iqxf1 = *(ckt->CKTstate0 + here->HICUMcqxf1); +// Iqxf2 <+ ddt(Qxf2); + error = NIintegrate(ckt,&geq,&ceq,Qxf2_Vxf2,here->HICUMqxf); + if(error) return(error); + Iqxf2_Vxf2 = geq; + Iqxf2 = *(ckt->CKTstate0 + here->HICUMcqxf2); +// Iqxf += ddt(Qxf); //for RC nw + error = NIintegrate(ckt,&geq,&ceq,Qxf_Vxf,here->HICUMqxf); + if(error) return(error); + Iqxf_Vxf = geq; + Iqxf = *(ckt->CKTstate0 + here->HICUMcqxf); + + if (model->HICUMflsh) + { +// Ith += ddt(model->HICUMcth*Vrth); + error = NIintegrate(ckt,&geq,&ceq,model->HICUMcth,here->HICUMqcth); + if(error) return(error); + Icth_Vrth = geq; + Icth = *(ckt->CKTstate0 + here->HICUMcqcth); + } + + if(ckt->CKTmode & MODEINITTRAN) { + *(ckt->CKTstate1 + here->HICUMcqrbi) = + *(ckt->CKTstate0 + here->HICUMcqrbi); + *(ckt->CKTstate1 + here->HICUMcqjei) = + *(ckt->CKTstate0 + here->HICUMcqjei); + *(ckt->CKTstate1 + here->HICUMcqdeix) = + *(ckt->CKTstate0 + here->HICUMcqdeix); + *(ckt->CKTstate1 + here->HICUMcqjci) = + *(ckt->CKTstate0 + here->HICUMcqjci); + *(ckt->CKTstate1 + here->HICUMcqdci) = + *(ckt->CKTstate0 + here->HICUMcqdci); + *(ckt->CKTstate1 + here->HICUMcqjep) = + *(ckt->CKTstate0 + here->HICUMcqjep); + *(ckt->CKTstate1 + here->HICUMcqcx0_t_i) = + *(ckt->CKTstate0 + here->HICUMcqcx0_t_i); + *(ckt->CKTstate1 + here->HICUMcqcx0_t_ii) = + *(ckt->CKTstate0 + here->HICUMcqcx0_t_ii); + *(ckt->CKTstate1 + here->HICUMcqdsu) = + *(ckt->CKTstate0 + here->HICUMcqdsu); + *(ckt->CKTstate1 + here->HICUMcqjs) = + *(ckt->CKTstate0 + here->HICUMcqjs); + *(ckt->CKTstate1 + here->HICUMcqscp) = + *(ckt->CKTstate0 + here->HICUMcqscp); + if (model->HICUMflsh) + *(ckt->CKTstate1 + here->HICUMcqcth) = + *(ckt->CKTstate0 + here->HICUMcqcth); + } + } + } + + /* + * check convergence + */ + if ( (!(ckt->CKTmode & MODEINITFIX))||(!(here->HICUMoff))) { + if (icheck == 1) { + ckt->CKTnoncon++; + ckt->CKTtroubleElt = (GENinstance *) here; + } + } + + /* + * charge storage for outer junctions + */ + if(ckt->CKTmode & (MODETRAN | MODEAC)) { +// Ibe += ddt(cbepar1*Vbe); + error = NIintegrate(ckt,&gqbepar1,&cqbepar1,cbepar1,here->HICUMqbepar1); + if(error) return(error); +// Ibpe += ddt(cbepar2*Vbpe); + error = NIintegrate(ckt,&gqbepar2,&cqbepar2,cbepar2,here->HICUMqbepar2); + if(error) return(error); +// Ibci += ddt(cbcpar1*Vbci); + error = NIintegrate(ckt,&gqbcpar1,&cqbcpar1,cbcpar1,here->HICUMqbcpar1); + if(error) return(error); +// Ibpci += ddt(cbcpar2*Vbpci); + error = NIintegrate(ckt,&gqbcpar2,&cqbcpar2,cbcpar2,here->HICUMqbcpar2); + if(error) return(error); +// Isis += ddt(model->HICUMcsu*Vsis); + error = NIintegrate(ckt,&gqsu,&cqsu,model->HICUMcsu,here->HICUMqsu); + if(error) return(error); +//tocheck: Currents and conductances must used in stamping below + if(ckt->CKTmode & MODEINITTRAN) { + *(ckt->CKTstate1 + here->HICUMcqbepar1) = + *(ckt->CKTstate0 + here->HICUMcqbepar1); + *(ckt->CKTstate1 + here->HICUMcqbepar2) = + *(ckt->CKTstate0 + here->HICUMcqbepar2); + *(ckt->CKTstate1 + here->HICUMcqbcpar1) = + *(ckt->CKTstate0 + here->HICUMcqbcpar1); + *(ckt->CKTstate1 + here->HICUMcqbcpar2) = + *(ckt->CKTstate0 + here->HICUMcqbcpar2); + *(ckt->CKTstate1 + here->HICUMcqsu) = + *(ckt->CKTstate0 + here->HICUMcqsu); + } + } + + *(ckt->CKTstate0 + here->HICUMvbiei) = Vbiei; + *(ckt->CKTstate0 + here->HICUMvbici) = Vbici; + *(ckt->CKTstate0 + here->HICUMvbpei) = Vbpei; + *(ckt->CKTstate0 + here->HICUMvbpbi) = Vbpbi; + *(ckt->CKTstate0 + here->HICUMvbpci) = Vbpci; + *(ckt->CKTstate0 + here->HICUMvsici) = Vsici; + + *(ckt->CKTstate0 + here->HICUMibiei) = Ibiei; + *(ckt->CKTstate0 + here->HICUMibiei_Vbiei) = Ibiei_Vbiei; + + *(ckt->CKTstate0 + here->HICUMibpei) = Ibpei; + *(ckt->CKTstate0 + here->HICUMibpei_Vbpei) = Ibpei_Vbpei; + + *(ckt->CKTstate0 + here->HICUMiciei) = Iciei; + *(ckt->CKTstate0 + here->HICUMiciei_Vbiei) = Iciei_Vbiei; + *(ckt->CKTstate0 + here->HICUMiciei_Vbici) = Iciei_Vbici; + + *(ckt->CKTstate0 + here->HICUMibici) = Ibici; + *(ckt->CKTstate0 + here->HICUMibici_Vbici) = Ibici_Vbici; + + *(ckt->CKTstate0 + here->HICUMibpbi) = Ibpbi; + *(ckt->CKTstate0 + here->HICUMibpbi_Vbpbi) = Ibpbi_Vbpbi; + *(ckt->CKTstate0 + here->HICUMibpbi_Vbiei) = Ibpbi_Vbiei; + *(ckt->CKTstate0 + here->HICUMibpbi_Vbici) = Ibpbi_Vbici; + + *(ckt->CKTstate0 + here->HICUMibpci) = Ibpci; + *(ckt->CKTstate0 + here->HICUMibpci_Vbpci) = Ibpci_Vbpci; + + *(ckt->CKTstate0 + here->HICUMisici) = Isici; + *(ckt->CKTstate0 + here->HICUMisici_Vsici) = Isici_Vsici; + + *(ckt->CKTstate0 + here->HICUMibpsi) = Ibpsi; + *(ckt->CKTstate0 + here->HICUMibpsi_Vbpci) = Ibpsi_Vbpci; + *(ckt->CKTstate0 + here->HICUMibpsi_Vsici) = Ibpsi_Vsici; + + *(ckt->CKTstate0 + here->HICUMisis_Vsis) = Isis_Vsis; + + *(ckt->CKTstate0 + here->HICUMieie) = Ieie; + + *(ckt->CKTstate0 + here->HICUMcqcth) = Icth; + *(ckt->CKTstate0 + here->HICUMicth_Vrth) = Icth_Vrth; + + *(ckt->CKTstate0 + here->HICUMgqbepar1) = gqbepar1; + *(ckt->CKTstate0 + here->HICUMgqbepar2) = gqbepar2; + + *(ckt->CKTstate0 + here->HICUMgqbcpar1) = gqbcpar1; + *(ckt->CKTstate0 + here->HICUMgqbcpar2) = gqbcpar2; + + *(ckt->CKTstate0 + here->HICUMgqsu) = gqsu; + +load: + /* + * load current excitation vector and matrix + */ +/* +c Branch: be, Stamp element: Cbepar1 +*/ + rhs_current = model->HICUMtype * (*(ckt->CKTstate0 + here->HICUMcqbepar1) - Vbe * gqbepar1); + *(ckt->CKTrhs + here->HICUMbaseNode) += -rhs_current; + *(here->HICUMbaseBasePtr) += gqbepar1; + *(here->HICUMemitEmitPtr) += gqbepar1; + *(ckt->CKTrhs + here->HICUMemitNode) += rhs_current; + *(here->HICUMbaseEmitPtr) += -gqbepar1; + *(here->HICUMemitBasePtr) += -gqbepar1; +/* +c Branch: bpe, Stamp element: Cbepar2 +*/ + rhs_current = model->HICUMtype * (*(ckt->CKTstate0 + here->HICUMcqbepar2) - Vbpe * gqbepar2); + *(ckt->CKTrhs + here->HICUMbaseBPNode) += -rhs_current; + *(here->HICUMbaseBPBaseBPPtr) += gqbepar2; + *(here->HICUMbaseBPEmitPtr) += gqbepar2; + *(ckt->CKTrhs + here->HICUMemitNode) += rhs_current; + *(here->HICUMemitBaseBPPtr) += -gqbepar2; + *(here->HICUMemitEmitPtr) += -gqbepar2; +/* +c Branch: bci, Stamp element: Cbcpar1 +*/ + rhs_current = model->HICUMtype * (*(ckt->CKTstate0 + here->HICUMcqbcpar1) - Vbci * gqbcpar1); + *(ckt->CKTrhs + here->HICUMbaseNode) += -rhs_current; + *(here->HICUMbaseBasePtr) += gqbcpar1; + *(here->HICUMcollCICollCIPtr) += gqbcpar1; + *(ckt->CKTrhs + here->HICUMcollCINode) += rhs_current; + *(here->HICUMbaseCollCIPtr) += -gqbcpar1; + *(here->HICUMcollCIBasePtr) += -gqbcpar1; +/* +c Branch: bpci, Stamp element: Cbcpar2 +*/ + rhs_current = model->HICUMtype * (*(ckt->CKTstate0 + here->HICUMcqbcpar2) - Vbpci * gqbcpar2); + *(ckt->CKTrhs + here->HICUMbaseBPNode) += -rhs_current; + *(here->HICUMbaseBPBaseBPPtr) += gqbcpar2; + *(here->HICUMcollCICollCIPtr) += gqbcpar2; + *(ckt->CKTrhs + here->HICUMcollCINode) += rhs_current; + *(here->HICUMbaseBPCollCIPtr) += -gqbcpar2; + *(here->HICUMcollCIBaseBPPtr) += -gqbcpar2; +/* +c Branch: ssi, Stamp element: Csu +*/ + rhs_current = model->HICUMtype * (*(ckt->CKTstate0 + here->HICUMcqsu) - Vsis * gqsu); + *(ckt->CKTrhs + here->HICUMsubsNode) += -rhs_current; + *(here->HICUMsubsSubsPtr) += gqsu; + *(here->HICUMsubsSISubsSIPtr) += gqsu; + *(ckt->CKTrhs + here->HICUMsubsSINode) += rhs_current; + *(here->HICUMsubsSubsSIPtr) += -gqsu; + *(here->HICUMsubsSISubsPtr) += -gqsu; +/* +c Branch: biei, Stamp element: Ijbei +*/ + rhs_current = model->HICUMtype * (Ibiei - Ibiei_Vbiei*Vbiei); + *(ckt->CKTrhs + here->HICUMbaseBINode) += -rhs_current; + *(here->HICUMbaseBIBaseBIPtr) += Ibiei_Vbiei; + *(here->HICUMbaseBIEmitEIPtr) += -Ibiei_Vbiei; + *(ckt->CKTrhs + here->HICUMemitEINode) += rhs_current; + *(here->HICUMemitEIBaseBIPtr) += -Ibiei_Vbiei; + *(here->HICUMemitEIEmitEIPtr) += Ibiei_Vbiei; +/* +c Branch: bpei, Stamp element: Ijbep +*/ + rhs_current = model->HICUMtype * (Ibpei - Ibpei_Vbpei*Vbpei); + *(ckt->CKTrhs + here->HICUMbaseBPNode) += -rhs_current; + *(here->HICUMbaseBPBaseBPPtr) += Ibpei_Vbpei; + *(here->HICUMbaseBPEmitEIPtr) += -Ibpei_Vbpei; + *(ckt->CKTrhs + here->HICUMemitEINode) += rhs_current; + *(here->HICUMemitEIBaseBPPtr) += -Ibpei_Vbpei; + *(here->HICUMemitEIEmitEIPtr) += Ibpei_Vbpei; + +/* +c Branch: bici, Stamp element: Ijbci +*/ + rhs_current = model->HICUMtype * (Ibici - Ibici_Vbici*Vbici); + *(ckt->CKTrhs + here->HICUMbaseBINode) += -rhs_current; + *(here->HICUMbaseBIBaseBIPtr) += Ibici_Vbici; + *(here->HICUMbaseBICollCIPtr) += -Ibici_Vbici; + *(ckt->CKTrhs + here->HICUMcollCINode) += rhs_current; + *(here->HICUMcollCIBaseBIPtr) += -Ibici_Vbici; + *(here->HICUMcollCICollCIPtr) += Ibici_Vbici; +/* +c Branch: ciei, Stamp element: It +*/ + rhs_current = model->HICUMtype * (Iciei - Iciei_Vbiei*Vbiei - Iciei_Vbici*Vbici); + *(ckt->CKTrhs + here->HICUMcollCINode) += -rhs_current; + *(here->HICUMcollCIBaseBIPtr) += Iciei_Vbiei; + *(here->HICUMcollCIEmitEIPtr) += -Iciei_Vbiei; + *(here->HICUMcollCIBaseBIPtr) += Iciei_Vbici; + *(here->HICUMcollCICollCIPtr) += -Iciei_Vbici; + *(ckt->CKTrhs + here->HICUMemitEINode) += rhs_current; + *(here->HICUMemitEIBaseBIPtr) += -Iciei_Vbiei; + *(here->HICUMemitEIEmitEIPtr) += Iciei_Vbiei; + *(here->HICUMemitEIBaseBIPtr) += -Iciei_Vbici; + *(here->HICUMemitEICollCIPtr) += Iciei_Vbici; +/* +c Branch: bci, Stamp element: Qbcx +*/ + rhs_current = model->HICUMtype * (Ibci - Ibci_Vbci*Vbci); + *(ckt->CKTrhs + here->HICUMbaseNode) += -rhs_current; + *(here->HICUMbaseBasePtr) += Ibci_Vbci; + *(here->HICUMbaseCollCIPtr) += -Ibci_Vbci; + *(ckt->CKTrhs + here->HICUMcollCINode) += rhs_current; + *(here->HICUMcollCIBasePtr) += -Ibci_Vbci; + *(here->HICUMcollCICollCIPtr) += Ibci_Vbci; +/* +c Branch: bpci, Stamp element: Ijbcx +*/ + rhs_current = model->HICUMtype * (Ibpci - Ibpci_Vbpci*Vbpci); + *(ckt->CKTrhs + here->HICUMbaseBPNode) += -rhs_current; + *(here->HICUMbaseBPCollCIPtr) += Ibpci_Vbpci; + *(here->HICUMbaseBPBaseBPPtr) += -Ibpci_Vbpci; + *(ckt->CKTrhs + here->HICUMcollCINode) += rhs_current; + *(here->HICUMcollCIBaseBPPtr) += -Ibpci_Vbpci; + *(here->HICUMcollCICollCIPtr) += Ibpci_Vbpci; +/* +c Branch: cic, Stamp element: Rcx +*/ + *(here->HICUMcollCollPtr) += Icic_Vcic; + *(here->HICUMcollCICollCIPtr) += Icic_Vcic; + *(here->HICUMcollCICollPtr) += -Icic_Vcic; + *(here->HICUMcollCollCIPtr) += -Icic_Vcic; + +/* +c Branch: bbp, Stamp element: Rbx +*/ + *(here->HICUMbaseBasePtr) += Ibbp_Vbbp; + *(here->HICUMbaseBPBaseBPPtr) += Ibbp_Vbbp; + *(here->HICUMbaseBPBasePtr) += -Ibbp_Vbbp; + *(here->HICUMbaseBaseBPPtr) += -Ibbp_Vbbp; +/* +c Branch: eie, Stamp element: Re +*/ + *(here->HICUMemitEmitPtr) += Ieie_Veie; + *(here->HICUMemitEIEmitEIPtr) += Ieie_Veie; + *(here->HICUMemitEIEmitPtr) += -Ieie_Veie; + *(here->HICUMemitEmitEIPtr) += -Ieie_Veie; +/* +c Branch: bpbi, Stamp element: Rbi, Crbi +*/ + rhs_current = model->HICUMtype * (Ibpbi - Ibpbi_Vbpbi*Vbpbi - Ibpbi_Vbiei*Vbiei - Ibpbi_Vbici*Vbici); +//printf("Ibpbi_Vbpbi: %g Vbpbi: %f Ibpbi_Vbiei: %g Vbiei: %f Ibpbi_Vbici: %g Vbici: %f\n", Ibpbi_Vbpbi, Vbpbi, Ibpbi_Vbiei, Vbiei, Ibpbi_Vbici, Vbici); +//printf("Ibpbi: %g RHS: %g\n", Ibpbi, rhs_current); + *(ckt->CKTrhs + here->HICUMbaseBPNode) += -rhs_current; + *(here->HICUMbaseBPBaseBPPtr) += Ibpbi_Vbpbi; + *(here->HICUMbaseBPBaseBIPtr) += -Ibpbi_Vbpbi; + *(here->HICUMbaseBPBaseBIPtr) += Ibpbi_Vbiei; + *(here->HICUMbaseBPEmitEIPtr) += -Ibpbi_Vbiei; + *(here->HICUMbaseBPCollCIPtr) += Ibpbi_Vbici; + *(here->HICUMbaseBPEmitEIPtr) += -Ibpbi_Vbici; + *(ckt->CKTrhs + here->HICUMbaseBINode) += rhs_current; + *(here->HICUMbaseBIBaseBPPtr) += -Ibpbi_Vbpbi; + *(here->HICUMbaseBIBaseBIPtr) += Ibpbi_Vbpbi; + *(here->HICUMbaseBIBaseBIPtr) += -Ibpbi_Vbiei; + *(here->HICUMbaseBIEmitEIPtr) += Ibpbi_Vbiei; + *(here->HICUMbaseBICollCIPtr) += -Ibpbi_Vbici; + *(here->HICUMbaseBIEmitEIPtr) += Ibpbi_Vbici; +/* +c Branch: sc, Stamp element: Cscp +*/ + rhs_current = model->HICUMtype * (Isc - Isc_Vsc*Vsc); + *(ckt->CKTrhs + here->HICUMsubsNode) += -rhs_current; + *(here->HICUMsubsSubsPtr) += Isc_Vsc; + *(here->HICUMsubsCollPtr) += Isc_Vsc; + *(ckt->CKTrhs + here->HICUMcollNode) += rhs_current; + *(here->HICUMcollSubsPtr) += -Isc_Vsc; + *(here->HICUMcollCollPtr) += -Isc_Vsc; +/* +c Branch: sici, Stamp element: Ijsc +*/ + rhs_current = model->HICUMtype * (Isici - Isici_Vsici*Vsici); + *(ckt->CKTrhs + here->HICUMsubsSINode) += -rhs_current; + *(here->HICUMsubsSISubsSIPtr) += Isici_Vsici; + *(here->HICUMsubsSICollCIPtr) += -Isici_Vsici; + *(ckt->CKTrhs + here->HICUMcollCINode) += rhs_current; + *(here->HICUMcollCISubsSIPtr) += -Isici_Vsici; + *(here->HICUMcollCICollCIPtr) += Isici_Vsici; +/* +c Branch: bpsi, Stamp element: Its +*/ + rhs_current = model->HICUMtype * (Ibpsi - Ibpsi_Vbpci*Vbpci - Ibpsi_Vsici*Vsici); + *(ckt->CKTrhs + here->HICUMbaseBPNode) += -rhs_current; + *(here->HICUMbaseBPBaseBPPtr) += Ibpsi_Vbpci; + *(here->HICUMbaseBPCollCIPtr) += -Ibpsi_Vbpci; + *(here->HICUMbaseBPSubsSIPtr) += Ibpsi_Vsici; + *(here->HICUMbaseBPCollCIPtr) += -Ibpsi_Vsici; + *(ckt->CKTrhs + here->HICUMsubsSINode) += rhs_current; + *(here->HICUMsubsSIBaseBPPtr) += -Ibpsi_Vbpci; + *(here->HICUMsubsSICollCIPtr) += Ibpsi_Vbpci; + *(here->HICUMsubsSISubsSIPtr) += -Ibpsi_Vsici; + *(here->HICUMsubsSICollCIPtr) += Ibpsi_Vsici; +/* +c Branch: sis, Stamp element: Rsu +*/ + *(here->HICUMsubsSubsPtr) += Isis_Vsis; + *(here->HICUMsubsSISubsSIPtr) += Isis_Vsis; + *(here->HICUMsubsSISubsPtr) += -Isis_Vsis; + *(here->HICUMsubsSubsSIPtr) += -Isis_Vsis; +//NQS +/* +c Branch: xf1-ground, Stamp element: Ixf1 +*/ +// rhs_current = (Ixf1 - Ixf1_Vxf1*Vxf1 - Ixf1_Vrth*Vrth - Ixf1_Vbiei*Vbiei - Ixf1_Vbici*Vbici - Ixf1_Vxf2*Vxf2); // TODO + rhs_current = Ixf1; + *(ckt->CKTrhs + here->HICUMxf1Node) += rhs_current; // into xf1 node +// *(here->HICUMxf1TempPtr) += -Ixf1_Vrth; +// *(here->HICUMxf1BaseBIPtr) += -Ixf1_Vbiei; +// *(here->HICUMxf1EmitEIPtr) += +Ixf1_Vbiei; +// *(here->HICUMxf1BaseBIPtr) += -Ixf1_Vbici; +// *(here->HICUMxf1CollCIPtr) += +Ixf1_Vbici; +// *(here->HICUMxf1Xf2Ptr) += +Ixf1_Vxf2; +/* +c Branch: xf1-ground, Stamp element: Qxf1 // TODO Test in AC simulation! +*/ + // rhs_current = Iqxf1 - Iqxf1_Vxf1*Vxf1; + // *(ckt->CKTrhs + here->HICUMxf1Node) += rhs_current; // into ground + // *(here->HICUMxf1Xf1Ptr) += Iqxf1_Vxf1; +/* +c Branch: xf2-ground, Stamp element: Ixf2 +*/ +// rhs_current = (Ixf2 - Ixf2_Vxf1*Vxf1 - Ixf2_Vrth*Vrth - Ixf2_Vbiei*Vbiei - Ixf2_Vbici*Vbici - Ixf2_Vxf2*Vxf2); // TODO + rhs_current = Ixf2; + *(ckt->CKTrhs + here->HICUMxf2Node) += rhs_current; // into xf2 node +// *(here->HICUMxf2TempPtr) += -Ixf2_Vrth; +// *(here->HICUMxf2BaseBIPtr) += -Ixf2_Vbiei; +// *(here->HICUMxf2EmitEIPtr) += +Ixf2_Vbiei; +// *(here->HICUMxf2BaseBIPtr) += -Ixf2_Vbici; +// *(here->HICUMxf2CollCIPtr) += +Ixf2_Vbici; +/* +c Branch: xf2-ground, Stamp element: Qxf2 // TODO Test in AC simulation! +*/ + // rhs_current = Iqxf2 - Iqxf2_Vxf2*Vxf2; + // *(ckt->CKTrhs + here->HICUMxf2Node) += rhs_current; // into ground + // *(here->HICUMxf2Xf2Ptr) += Iqxf2_Vxf2; +/* +c Branch: xf2-ground, Stamp element: Rxf2 +*/ + *(here->HICUMxf2Xf2Ptr) += 1; // current Ixf2 is normalized to Tf +/* +c Branch: xf-ground, Stamp element: Ixf +*/ +// rhs_current = model->HICUMtype * (Ixf - Ixf_Vrth*Vrth - Ixf_Vbiei*Vbiei - Ixf_Vbici*Vbici); + rhs_current = model->HICUMtype * Ixf; + *(ckt->CKTrhs + here->HICUMxfNode) += rhs_current; // into xf node +// *(here->HICUMxfTempPtr) += -Ixf_Vrth; +// *(here->HICUMxfBaseBIPtr) += -Ixf_Vbiei; +// *(here->HICUMxfEmitEIPtr) += +Ixf_Vbiei; +// *(here->HICUMxfBaseBIPtr) += -Ixf_Vbici; +// *(here->HICUMxfCollCIPtr) += +Ixf_Vbici; +/* +c Branch: xf-ground, Stamp element: Qxf // TODO Test in AC simulation! +*/ + // rhs_current = model->HICUMtype * (Iqxf - Iqxf_Vxf*Vxf); + // *(ckt->CKTrhs + here->HICUMxfNode) += rhs_current; // into ground + // *(here->HICUMxfXfPtr) += Iqxf_Vxf; +/* +c Branch: xf-ground, Stamp element: Rxf +*/ + *(here->HICUMxfXfPtr) += 1; // current Ixf is normalized to Tf + + if (model->HICUMflsh) { +/* +c Stamp element: Ibiei +*/ + rhs_current = -Ibiei_Vrth*Vrth; + *(ckt->CKTrhs + here->HICUMbaseBINode) += -rhs_current; + *(here->HICUMbaseBItempPtr) += Ibiei_Vrth; + *(ckt->CKTrhs + here->HICUMemitEINode) += rhs_current; + *(here->HICUMemitEItempPtr) += -Ibiei_Vrth; +/* +c Stamp element: Ibici +*/ + rhs_current = -Ibici_Vrth*Vrth; + *(ckt->CKTrhs + here->HICUMbaseBINode) += -rhs_current; + *(here->HICUMbaseBItempPtr) += Ibici_Vrth; + *(ckt->CKTrhs + here->HICUMcollCINode) += rhs_current; + *(here->HICUMcollCItempPtr) += -Ibici_Vrth; +/* +c Stamp element: Iciei +*/ + rhs_current = -Iciei_Vrth*Vrth; + *(ckt->CKTrhs + here->HICUMcollCINode) += -rhs_current; + *(here->HICUMcollCItempPtr) += Iciei_Vrth; + *(ckt->CKTrhs + here->HICUMemitEINode) += rhs_current; + *(here->HICUMemitEItempPtr) += -Iciei_Vrth; +/* +c Stamp element: Ibpei +*/ + rhs_current = -Ibpei_Vrth*Vrth; + *(ckt->CKTrhs + here->HICUMbaseBPNode) += -rhs_current; + *(here->HICUMbaseBPtempPtr) += Ibpei_Vrth; + *(ckt->CKTrhs + here->HICUMemitEINode) += rhs_current; + *(here->HICUMemitEItempPtr) += -Ibpei_Vrth; +/* +c Stamp element: Ibpci +*/ + rhs_current = -Ibpci_Vrth*Vrth; + *(ckt->CKTrhs + here->HICUMbaseBPNode) += -rhs_current; + *(here->HICUMbaseBPtempPtr) += Ibpci_Vrth; + *(ckt->CKTrhs + here->HICUMcollCINode) += rhs_current; + *(here->HICUMcollCItempPtr) += -Ibpci_Vrth; +/* +c Stamp element: Isici +*/ + rhs_current = -Isici_Vrth*Vrth; + *(ckt->CKTrhs + here->HICUMsubsSINode) += -rhs_current; + *(here->HICUMsubsSItempPtr) += Isici_Vrth; + *(ckt->CKTrhs + here->HICUMcollCINode) += rhs_current; + *(here->HICUMcollCItempPtr) += -Isici_Vrth; +/* +c Stamp element: Rbi +*/ + rhs_current = -Ibpbi_Vrth*Vrth; + *(ckt->CKTrhs + here->HICUMbaseBPNode) += -rhs_current; + *(here->HICUMbaseBPtempPtr) += Ibpbi_Vrth; + *(ckt->CKTrhs + here->HICUMbaseBINode) += rhs_current; + *(here->HICUMbaseBItempPtr) += -Ibpbi_Vrth; +/* +c Stamp element: Isici +*/ + rhs_current = -Isici_Vrth*Vrth; + *(ckt->CKTrhs + here->HICUMsubsSINode) += -rhs_current; + *(here->HICUMsubsSItempPtr) += Isici_Vrth; + *(ckt->CKTrhs + here->HICUMcollCINode) += rhs_current; + *(here->HICUMcollCItempPtr) += -Isici_Vrth; +/* +c Stamp element: Rcx +*/ + *(here->HICUMcollTempPtr) += Icic_Vrth; +/* +c Stamp element: Rbx +*/ + *(here->HICUMbaseTempPtr) += Ibbp_Vrth; +/* +c Stamp element: Re +*/ + *(here->HICUMemitTempPtr) += Ieie_Vrth; +/* +c Stamp element: Rth +*/ + *(here->HICUMtempTempPtr) += Irth_Vrth; +/* +c Stamp element: Cth +*/ + *(here->HICUMtempTempPtr) += Icth_Vrth; +/* +c Stamp element: Ith +*/ + rhs_current = Ith + Icth - Icth_Vrth*Vrth + + Ith_Vbiei*Vbiei + Ith_Vbici*Vbici + Ith_Vciei*Vciei + + Ith_Vbpei*Vbpei + Ith_Vbpci*Vbpci + Ith_Vsici*Vsici + + Ith_Vbpbi*Vbpbi + + Ith_Vcic*Vcic + Ith_Vbbp*Vbbp + Ith_Veie*Veie; + + *(ckt->CKTrhs + here->HICUMtempNode) -= rhs_current; + + *(here->HICUMtempTempPtr) += -Ith_Vrth; + + *(here->HICUMtempBaseBIPtr) += -Ith_Vbiei; + *(here->HICUMtempEmitEIPtr) += +Ith_Vbiei; + + *(here->HICUMtempBaseBIPtr) += -Ith_Vbici; + *(here->HICUMtempCollCIPtr) += +Ith_Vbici; + + *(here->HICUMtempCollCIPtr) += -Ith_Vciei; + *(here->HICUMtempEmitEIPtr) += +Ith_Vciei; + + *(here->HICUMtempBaseBPPtr) += -Ith_Vbpei; + *(here->HICUMtempEmitEIPtr) += +Ith_Vbpei; + + *(here->HICUMtempBaseBPPtr) += -Ith_Vbpci; + *(here->HICUMtempCollCIPtr) += +Ith_Vbpci; + + *(here->HICUMtempSubsSIPtr) += -Ith_Vsici; + *(here->HICUMtempCollCIPtr) += +Ith_Vsici; + + *(here->HICUMtempBaseBPPtr) += -Ith_Vbpbi; + *(here->HICUMtempBaseBIPtr) += +Ith_Vbpbi; + + *(here->HICUMtempCollCIPtr) += +Ith_Vcic; + *(here->HICUMtempBaseBPPtr) += +Ith_Vbbp; + *(here->HICUMtempEmitEIPtr) += +Ith_Veie; + } + } + + } + return(OK); +} + diff --git a/src/spicelib/devices/hicum2/hicumL2.cpp b/src/spicelib/devices/hicum2/hicumL2.cpp index a2a1f11b6..b3499952e 100644 --- a/src/spicelib/devices/hicum2/hicumL2.cpp +++ b/src/spicelib/devices/hicum2/hicumL2.cpp @@ -6,13 +6,12 @@ Spice3 Implementation: 2019 Dietmar Warning, Markus Müller, Mario Krattenmacher **********/ /* - * This file defines the HICUM L2.4.3 model load function + * This file defines the HICUM L2.4.0 model load function * Comments on the Code: * - We use dual numbers to calculate derivatives, this is readble and error proof. * - The code is targeted to be readbale and maintainable, speed is sacrificied for this purpose. - * - The verilog a code is available at the website of TU Dresden, Michael Schroeter's chair. - * - Nobody likes Verilog. - * + * - The verilog a code is available at the website of TU Dresden, Michael Schroeter#s chair. + * * Checklist of what needs to be done: (@Mario: also look at this, did I get everything?) * - ijBEp * - ijBCx @@ -32,12 +31,13 @@ Spice3 Implementation: 2019 Dietmar Warning, Markus Müller, Mario Krattenmacher * - Qf * - Qr * - iavl - * - iBEti (?) + * - iBEti * - itf, itr + * - NQS derivatives, sources and elements */ #include "cmath" -#include "duals/dual" +#include #include "hicumL2.hpp" #include @@ -80,8 +80,8 @@ extern "C" //HICUM DEFINITIONS -#define CHARGE 1.6021766208e-19 -#define CONSTboltz 1.38064852e-23 +#define CHARGE 1.6021766208e-19 +#define CONSTboltz 1.38064852e-23 #define VPT_thresh 1.0e2 #define Dexp_lim 80.0 #define Cexp_lim 80.0 @@ -111,7 +111,7 @@ duals::duald HICDIO(duals::duald T, double IST, double UM1, duals::duald U) { duals::duald DIOY, le, vt; - printf("2"); + // printf("2"); vt = UM1 * CONSTboltz * T / CHARGE; DIOY = U/vt; if (IST > 0.0) { @@ -185,7 +185,7 @@ void QJMODF(duals::duald T, double c_0, double u_d, double z, double a_j, duals: // C : depletion capacitance void QJMOD(duals::duald T, duals::duald c_0, double u_d, double z, double a_j, double v_pt, duals::duald U_cap, duals::duald * C, duals::duald * Qz) { - duals::duald dummy, DQ_j1, DQ_j2, DQ_j3, DC_j1, DC_j2, DC_j3, De_1, De_2, Dzr1, DCln1, DCln2, Dz1, Dv_j1, Dv_j2, Dv_j3, De, Da, Dv_r, Dv_j4, Dv_e, DC_c, DC_max, DV_f, Dv_p, Dz_r, vt; + duals::duald dummy, DQ_j1, DQ_j2, DQ_j3, DC_j1, DC_j2, DC_j3, De_1, De_2, Dzr1, DCln1, DCln2, Dz1, Dv_j1, Dv_j2, Dv_j3, De, Da, Dv_r, Dv_j4, Dv_e, DC_c, DC_max, DV_f, Dv_p, Dz_r, vt; vt = CONSTboltz * T / CHARGE; if (c_0 > 0.0){ Dz_r = z/4.0; @@ -238,7 +238,7 @@ void QJMOD(duals::duald T, duals::duald c_0, double u_d, double z, double a_j, d // OUTPUT: // hicfcio : function of equation (2.1.17-10) void HICFCI(double zb, double zl, double w, double * hicfcio, double * dhicfcio_dw) -{ +{ double a, a2, a3, r, lnzb, x, z; z = zb*w; lnzb = log(1+zb*w); @@ -537,7 +537,7 @@ void hicum_diode(double T, double IS, double UM1, double U, double *Iz, double * //wrapper for hicum diode equation that also generates derivatives duals::duald result = 0; - printf("executed diode"); + // printf("executed diode"); result = HICDIO(T, IS, UM1, U+1_e); *Iz = result.rpart(); @@ -610,7 +610,7 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) double Cjcx_ii, Cjcx_ii_Vbpci, Cjcx_ii_dT; double Qjcx_i , Qjcx_i_Vbci , Qjcx_i_dT ; double Qjcx_ii, Qjcx_ii_Vbpci, Qjcx_ii_dT; - + double itf,itr,Tf,Tr,VT_f,i_0f,i_0r,a_bpt,Q_0,Q_p,Q_bpt; double Orci0_t,b_q,I_Tf1,T_f0,Q_fT,T_fT,Q_bf; double a_h,Q_pT,d_Q; @@ -622,6 +622,7 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) double Ixf1,Ixf2,Qxf1,Qxf2; double Itxf, Qdeix; double Vxf, Ixf, Qxf; + double Vxf1, Vxf2; double hjei_vbe; @@ -712,8 +713,8 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) //NQS double Vbxf, Vbxf1, Vbxf2; - double Qxf_Vxf; - double Iqxf, Iqxf_Vxf, Iqxf1, Iqxf2; + double Qxf_Vxf, Qxf1_Vxf1, Qxf2_Vxf2; + double Iqxf, Iqxf_Vxf, Iqxf1, Iqxf1_Vxf1, Iqxf2, Iqxf2_Vxf2; double Ith, Vrth, Icth, Icth_Vrth, delvrth; @@ -1005,9 +1006,9 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) Vsis = model->HICUMtype*( *(ckt->CKTrhsOld+here->HICUMsubsSINode)- *(ckt->CKTrhsOld+here->HICUMsubsNode)); - Vbxf = *(ckt->CKTstate0 + here->HICUMvxf); - Vbxf1 = *(ckt->CKTstate0 + here->HICUMvxf1); - Vbxf2 = *(ckt->CKTstate0 + here->HICUMvxf2); + Vbxf = *(ckt->CKTrhsOld + here->HICUMxfNode); + Vbxf1 = *(ckt->CKTrhsOld + here->HICUMxf1Node); + Vbxf2 = *(ckt->CKTrhsOld + here->HICUMxf2Node); if (model->HICUMflsh) Vrth = *(ckt->CKTstate0 + here->HICUMvrth); } else if(ckt->CKTmode & MODEINITTRAN) { @@ -1043,9 +1044,9 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) Vsis = model->HICUMtype*( *(ckt->CKTrhsOld+here->HICUMsubsSINode)- *(ckt->CKTrhsOld+here->HICUMsubsNode)); - Vbxf = *(ckt->CKTstate1 + here->HICUMvxf); - Vbxf1 = *(ckt->CKTstate1 + here->HICUMvxf1); - Vbxf2 = *(ckt->CKTstate1 + here->HICUMvxf2); + Vbxf = *(ckt->CKTrhsOld + here->HICUMxfNode); + Vbxf1 = *(ckt->CKTrhsOld + here->HICUMxf1Node); + Vbxf2 = *(ckt->CKTrhsOld + here->HICUMxf2Node); if (model->HICUMflsh) Vrth = *(ckt->CKTstate1 + here->HICUMvrth); } else if((ckt->CKTmode & MODEINITJCT) && @@ -1445,7 +1446,7 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) //TODO: derivatives after cjci0_t, vdci_t, vptci_t hicum_HICJQ(here->HICUMtemp, here->HICUMcjci0_t,here->HICUMvdci_t,model->HICUMzci,here->HICUMvptci_t, Vbici, &Cjci, &Cjci_Vbici, &Cjci_dT, &Qjci, &Qjci_Vbici, &Qjci_dT); - //Hole charge at low bias + //Hole charge at low bias result = calc_Q_0(Qjei+1_e, Qjci, hjei_vbe); Q_0 = result.rpart(); Q_0_Qjei = result.dpart(); @@ -1458,7 +1459,7 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) Q_0_Vbiei = Q_0_Qjei*Qjei_Vbiei + Q_0_hjei_vbe*hjei_vbe_Vbiei; Q_0_Vbici = Q_0_Qjci*Qjci_Vbici ; - //TODO: derivative qp0_t + //TODO: derivative qp0_t Q_0_dT = Q_0_Qjei*Qjei_dT + Q_0_Qjci*Qjci_dT * Q_0_hjei_vbe*hjei_vbe_dT; //Transit time calculation at low current density @@ -1655,7 +1656,6 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) //Tunneling current //TODO: missing temperature derivatives abet_t vdei_t ibets_t cjei0_t vdep_t ibets_t cjep0_t - //@Mario: is there really no direct T dependence here? result = calc_ibet(Vbiei, Vbpei+1_e); ibet = result.rpart(); ibet_Vbpei = result.dpart(); @@ -1752,20 +1752,22 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) // Excess Phase calculation if ((model->HICUMflnqs != 0 || model->HICUMflcomp == 0.0 || model->HICUMflcomp == 2.1) && Tf != 0 && (model->HICUMalit > 0 || model->HICUMalqf > 0)) { - double Vxf1, Vxf2, fact; Vxf1 = Vbxf1; Vxf2 = Vbxf2; Ixf1 = (Vxf2-itf)/Tf*model->HICUMt0; Ixf2 = (Vxf2-Vxf1)/Tf*model->HICUMt0; - Qxf1 = model->HICUMalit*Vxf1*model->HICUMt0; - Qxf2 = model->HICUMalit*Vxf2/3*model->HICUMt0; + Qxf1 = model->HICUMalit*model->HICUMt0*Vxf1; + Qxf1_Vxf1 = model->HICUMalit*model->HICUMt0; + Qxf2 = model->HICUMalit*model->HICUMt0*Vxf2/3; + Qxf2_Vxf2 = model->HICUMalit*model->HICUMt0/3; Itxf = Vxf2; + // TODO derivatives of Ixf1 and Ixf2 + Vxf = Vbxf; //for RC nw - fact = model->HICUMt0/Tf; //for RC nw - Ixf = (Vxf - Qdei)*fact; //for RC nw - Qxf = model->HICUMalqf*Vxf*model->HICUMt0; //for RC nw + Ixf = (Vxf - Qdei)*model->HICUMt0/Tf; //for RC nw + Qxf = model->HICUMalqf*model->HICUMt0*Vxf; //for RC nw Qxf_Vxf = model->HICUMalqf*model->HICUMt0; //for RC nw Qdeix = Vxf; //for RC nw } else { @@ -1773,6 +1775,8 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) Ixf2 = Vbxf2; Qxf1 = 0; Qxf2 = 0; + Qxf1_Vxf1 = 0; + Qxf2_Vxf2 = 0; Ixf = Vbxf; Qxf = 0; @@ -1875,9 +1879,9 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) // ******************************************** // NQS effect -// Ibxf1 = Ixf1; + // Ibxf1 = Ixf1; // Icxf1 += ddt(Qxf1); -// Ibxf2 = Ixf2; + // Ibxf2 = Ixf2; // Icxf2 += ddt(Qxf2); // end of Load_sources @@ -1971,6 +1975,8 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) *(ckt->CKTstate0 + here->HICUMqbcpar2) = Qbcpar2; *(ckt->CKTstate0 + here->HICUMqsu) = Qsu; //NQS + *(ckt->CKTstate0 + here->HICUMqxf1) = Qxf1; + *(ckt->CKTstate0 + here->HICUMqxf2) = Qxf2; *(ckt->CKTstate0 + here->HICUMqxf) = Qxf; if (model->HICUMflsh) *(ckt->CKTstate0 + here->HICUMqcth) = Qcth; @@ -2013,6 +2019,8 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) *(ckt->CKTstate0 + here->HICUMcqbcpar2) = Qbcpar2_Vbpci; *(ckt->CKTstate0 + here->HICUMcqsu) = Qsu_Vsis; //NQS + *(ckt->CKTstate0 + here->HICUMcqxf1) = Qxf1_Vxf1; + *(ckt->CKTstate0 + here->HICUMcqxf2) = Qxf2_Vxf2; *(ckt->CKTstate0 + here->HICUMcqxf) = Qxf_Vxf; if (model->HICUMflsh) *(ckt->CKTstate0 + here->HICUMcqcth) = model->HICUMcth; @@ -2063,7 +2071,6 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) } // Ibpbi += ddt(Qrbi); - dummdumm(int(0)); error = NIintegrate(ckt,&geq,&ceq,Qrbi_Vbpbi,here->HICUMqrbi); if(error) return(error); Ibpbi_Vbpbi += geq; @@ -2126,7 +2133,17 @@ HICUMload(GENmodel *inModel, CKTcircuit *ckt) Isc_Vsc = geq; Isc = *(ckt->CKTstate0 + here->HICUMcqscp); //NQS -// Icxf += ddt(Qxf); //for RC nw +// Iqxf1 <+ ddt(Qxf1); + error = NIintegrate(ckt,&geq,&ceq,Qxf1_Vxf1,here->HICUMqxf); + if(error) return(error); + Iqxf1_Vxf1 = geq; + Iqxf1 = *(ckt->CKTstate0 + here->HICUMcqxf1); +// Iqxf2 <+ ddt(Qxf2); + error = NIintegrate(ckt,&geq,&ceq,Qxf2_Vxf2,here->HICUMqxf); + if(error) return(error); + Iqxf2_Vxf2 = geq; + Iqxf2 = *(ckt->CKTstate0 + here->HICUMcqxf2); +// Iqxf += ddt(Qxf); //for RC nw error = NIintegrate(ckt,&geq,&ceq,Qxf_Vxf,here->HICUMqxf); if(error) return(error); Iqxf_Vxf = geq; @@ -2469,6 +2486,49 @@ c Branch: sis, Stamp element: Rsu *(here->HICUMsubsSubsSIPtr) += -Isis_Vsis; //NQS /* +c Branch: xf1-ground, Stamp element: Ixf1 +*/ +// rhs_current = (Ixf1 - Ixf1_Vxf1*Vxf1 - Ixf1_Vrth*Vrth - Ixf1_Vbiei*Vbiei - Ixf1_Vbici*Vbici - Ixf1_Vxf2*Vxf2); // TODO + rhs_current = Ixf1; + *(ckt->CKTrhs + here->HICUMxf1Node) += 0; // rhs_current; // into xf1 node +// *(here->HICUMxf1TempPtr) += -Ixf1_Vrth; +// *(here->HICUMxf1BaseBIPtr) += -Ixf1_Vbiei; +// *(here->HICUMxf1EmitEIPtr) += +Ixf1_Vbiei; +// *(here->HICUMxf1BaseBIPtr) += -Ixf1_Vbici; +// *(here->HICUMxf1CollCIPtr) += +Ixf1_Vbici; +// *(here->HICUMxf1Xf2Ptr) += +Ixf1_Vxf2; +/* +c Branch: xf1-ground, Stamp element: Qxf1 // TODO Test in AC simulation! +*/ + // rhs_current = Iqxf1 - Iqxf1_Vxf1*Vxf1; + // *(ckt->CKTrhs + here->HICUMxf1Node) += rhs_current; // into ground + // *(here->HICUMxf1Xf1Ptr) += Iqxf1_Vxf1; +/* +c Branch: xf1-ground, Stamp element: Rxf1 TODO: This is wrong, but needed at the moment for convergence +*/ + *(here->HICUMxf1Xf1Ptr) += 1; // current Ixf1 is normalized to Tf +/* +c Branch: xf2-ground, Stamp element: Ixf2 +*/ +// rhs_current = (Ixf2 - Ixf2_Vxf1*Vxf1 - Ixf2_Vrth*Vrth - Ixf2_Vbiei*Vbiei - Ixf2_Vbici*Vbici - Ixf2_Vxf2*Vxf2); // TODO + rhs_current = Ixf2; + *(ckt->CKTrhs + here->HICUMxf2Node) += rhs_current; // into xf2 node +// *(here->HICUMxf2TempPtr) += -Ixf2_Vrth; +// *(here->HICUMxf2BaseBIPtr) += -Ixf2_Vbiei; +// *(here->HICUMxf2EmitEIPtr) += +Ixf2_Vbiei; +// *(here->HICUMxf2BaseBIPtr) += -Ixf2_Vbici; +// *(here->HICUMxf2CollCIPtr) += +Ixf2_Vbici; +/* +c Branch: xf2-ground, Stamp element: Qxf2 // TODO Test in AC simulation! +*/ + // rhs_current = Iqxf2 - Iqxf2_Vxf2*Vxf2; + // *(ckt->CKTrhs + here->HICUMxf2Node) += rhs_current; // into ground + // *(here->HICUMxf2Xf2Ptr) += Iqxf2_Vxf2; +/* +c Branch: xf2-ground, Stamp element: Rxf2 +*/ + *(here->HICUMxf2Xf2Ptr) += 1; // current Ixf2 is normalized to Tf +/* c Branch: xf-ground, Stamp element: Ixf */ // rhs_current = model->HICUMtype * (Ixf - Ixf_Vrth*Vrth - Ixf_Vbiei*Vbiei - Ixf_Vbici*Vbici); @@ -2480,15 +2540,15 @@ c Branch: xf-ground, Stamp element: Ixf // *(here->HICUMxfBaseBIPtr) += -Ixf_Vbici; // *(here->HICUMxfCollCIPtr) += +Ixf_Vbici; /* -c Branch: xf-ground, Stamp element: Qxf +c Branch: xf-ground, Stamp element: Qxf // TODO Test in AC simulation! */ - rhs_current = model->HICUMtype * (Iqxf - Iqxf_Vxf*Vxf); - *(ckt->CKTrhs + here->HICUMxfNode) += rhs_current; // into ground - *(here->HICUMxfXfPtr) += Iqxf_Vxf; + // rhs_current = model->HICUMtype * (Iqxf - Iqxf_Vxf*Vxf); + // *(ckt->CKTrhs + here->HICUMxfNode) += rhs_current; // into ground + // *(here->HICUMxfXfPtr) += Iqxf_Vxf; /* c Branch: xf-ground, Stamp element: Rxf */ - *(here->HICUMxfXfPtr) += Tf; // current Ixf is normalized to Tf + *(here->HICUMxfXfPtr) += 1; // current Ixf is normalized to Tf if (model->HICUMflsh) { /* diff --git a/src/spicelib/devices/hicum2/overview_files.md b/src/spicelib/devices/hicum2/overview_files.md index abb94ecd6..e5bc1f64e 100644 --- a/src/spicelib/devices/hicum2/overview_files.md +++ b/src/spicelib/devices/hicum2/overview_files.md @@ -23,4 +23,8 @@ This file gives an overview of the files needed for the ngspice HiCUM version, e # hicum2setup.c # hicum2soachk.c # hicum2temp.c + * Temperature scaling of all parameters + * Models are implemented, missing are the derivatives + * As most models are easy and just temperature dependent -> no dual numbers + * Assignee: Mario # hicum2trunc.c diff --git a/tests/hicum2/FG.cir b/tests/hicum2/FG.cir index 3328ae9c9..8b08800e4 100644 --- a/tests/hicum2/FG.cir +++ b/tests/hicum2/FG.cir @@ -1,10 +1,9 @@ HICUML2 v2.4.0 Gummel Test VE Q1_E 0 1.0 -VS Q1_S 0 0.0 VC Q1_C 0 0.0 VB Q1_B 0 0.0 RT Q1_T 0 1M -Q1 Q1_C Q1_B Q1_E Q1_S Q1_T P1 +Q1 Q1_C Q1_B Q1_E Q1_E Q1_T P1 .DC VE -0.2 -1.2 -10m .OPTIONS GMIN=1e-13 NOACCT @@ -23,12 +22,12 @@ Q1 Q1_C Q1_B Q1_E Q1_S Q1_T P1 + fbcpar=0.3 fbepar=1 cjs0=2.6e-014 vds=0.9997 zs=0.4295 vpts=100 + t0=2.089e-013 dt0h=8e-014 tbvl=8.25e-014 tef0=3.271e-013 gtfe=3.548 thcs=5.001e-012 + ahc=0.05 fthc=0.7 rci0=9.523 vlim=0.6999 vces=0.01 vpt=2 tr=0 -+ cbepar=2.609e-014 cbcpar=1.64512e-014 alqf=0.166667 alit=0.333333 flnqs=1 kf=0 ++ cbepar=2.609e-014 cbcpar=1.64512e-014 alqf=0.166667 alit=0.333333 flnqs=0 kf=0 + af=2 cfbe=-1 latb=0 latl=0 vgb=0.91 alt0=0.004 kt0=6.588e-005 + zetaci=0.58 alvs=0.001 alces=-0.2286 zetarbi=0.3002 zetarbx=0.06011 zetarcx=-0.02768 + zetare=-0.9605 zetacx=0 vge=1.17 vgc=1.17 vgs=1.17 f1vg=-0.000102377 f2vg=0.00043215 -+ zetact=5 zetabet=4.892 flsh=1 rth=1113.4 cth=6.841e-012 zetarth=0 -+ alrth=0.002 flcomp=0.0 tnom=26.85 acbar=1.5 flcono=0 icbar=0.01 ++ zetact=5 zetabet=4.892 flsh=0 rth=1113.4 cth=6.841e-012 zetarth=0 ++ alrth=0.002 flcomp=2.4 tnom=26.85 acbar=1.5 flcono=0 icbar=0.01 + vcbar=0.04 zetavgbe=0.7 hf0=40 ahjei=3 rhjei=2 delck=2 zetahjei=-0.5 diff --git a/tests/hicum2/FG.out b/tests/hicum2/FG.out old mode 100644 new mode 100755 index bffed4566..2e7b7b4c4 --- a/tests/hicum2/FG.out +++ b/tests/hicum2/FG.out @@ -1,5 +1,4 @@ - No. of Data Rows : 101 Circuit: HICUML2 v2.4.0 Gummel Test @@ -9,105 +8,105 @@ Doing analysis at TEMP = 300.150000 and TNOM = 300.150000 -------------------------------------------------------------------------------- Index v-sweep abs(i(vc)) abs(i(vb)) -------------------------------------------------------------------------------- -0 2.000000e-01 4.049351e-13 2.225580e-12 -1 2.100000e-01 5.113450e-13 2.709949e-12 -2 2.200000e-01 6.630802e-13 3.303959e-12 -3 2.300000e-01 8.814445e-13 4.033035e-12 -4 2.400000e-01 1.197752e-12 4.928519e-12 -5 2.500000e-01 1.658029e-12 6.029049e-12 -6 2.600000e-01 2.329925e-12 7.382271e-12 -7 2.700000e-01 3.312868e-12 9.046943e-12 -8 2.800000e-01 4.752984e-12 1.109555e-11 -9 2.900000e-01 6.865025e-12 1.361750e-11 -10 3.000000e-01 9.964585e-12 1.672315e-11 -11 3.100000e-01 1.451543e-11 2.054869e-11 -12 3.200000e-01 2.119904e-11 2.526227e-11 -13 3.300000e-01 3.101675e-11 3.107153e-11 -14 3.400000e-01 4.543985e-11 3.823301e-11 -15 3.500000e-01 6.662994e-11 4.706370e-11 -16 3.600000e-01 9.776277e-11 5.795551e-11 -17 3.700000e-01 1.435036e-10 7.139318e-11 -18 3.800000e-01 2.107056e-10 8.797657e-11 -19 3.900000e-01 3.094351e-10 1.084485e-10 -20 4.000000e-01 4.544769e-10 1.337292e-10 -21 4.100000e-01 6.675448e-10 1.649602e-10 -22 4.200000e-01 9.805260e-10 2.035581e-10 -23 4.300000e-01 1.440243e-09 2.512831e-10 -24 4.400000e-01 2.115444e-09 3.103247e-10 -25 4.500000e-01 3.107058e-09 3.834107e-10 -26 4.600000e-01 4.563242e-09 4.739441e-10 -27 4.700000e-01 6.701457e-09 5.861787e-10 -28 4.800000e-01 9.840846e-09 7.254419e-10 -29 4.900000e-01 1.444971e-08 8.984222e-10 -30 5.000000e-01 2.121510e-08 1.113538e-09 -31 5.100000e-01 3.114486e-08 1.381420e-09 -32 5.200000e-01 4.571712e-08 1.715539e-09 -33 5.300000e-01 6.709928e-08 2.133002e-09 -34 5.400000e-01 9.846869e-08 2.655677e-09 -35 5.500000e-01 1.444821e-07 3.311602e-09 -36 5.600000e-01 2.119626e-07 4.136919e-09 -37 5.700000e-01 3.109041e-07 5.178468e-09 -38 5.800000e-01 4.559399e-07 6.497298e-09 -39 5.900000e-01 6.684879e-07 8.173459e-09 -40 6.000000e-01 9.798838e-07 1.031258e-08 -41 6.100000e-01 1.435954e-06 1.305493e-08 -42 6.200000e-01 2.103689e-06 1.658806e-08 -43 6.300000e-01 3.080976e-06 2.116430e-08 -44 6.400000e-01 4.510769e-06 2.712546e-08 -45 6.500000e-01 6.598624e-06 3.493740e-08 -46 6.600000e-01 9.651558e-06 4.523897e-08 -47 6.700000e-01 1.410969e-05 5.891122e-08 -48 6.800000e-01 2.061503e-05 7.717565e-08 -49 6.900000e-01 3.009990e-05 1.017337e-07 -50 7.000000e-01 4.391594e-05 1.349652e-07 -51 7.100000e-01 6.401850e-05 1.802097e-07 -52 7.200000e-01 9.322680e-05 2.421649e-07 -53 7.300000e-01 1.355843e-04 3.274474e-07 -54 7.400000e-01 1.968435e-04 4.453752e-07 -55 7.500000e-01 2.850922e-04 6.090441e-07 -56 7.600000e-01 4.115088e-04 8.367799e-07 -57 7.700000e-01 5.911811e-04 1.154039e-06 -58 7.800000e-01 8.438251e-04 1.595796e-06 -59 7.900000e-01 1.194123e-03 2.209384e-06 -60 8.000000e-01 1.671327e-03 3.057614e-06 -61 8.100000e-01 2.307843e-03 4.221915e-06 -62 8.200000e-01 3.136856e-03 5.805096e-06 -63 8.300000e-01 4.189465e-03 7.933416e-06 -64 8.400000e-01 5.492130e-03 1.075774e-05 -65 8.500000e-01 7.065050e-03 1.445376e-05 -66 8.600000e-01 8.921662e-03 1.922145e-05 -67 8.700000e-01 1.106902e-02 2.528408e-05 -68 8.800000e-01 1.350859e-02 3.288743e-05 -69 8.900000e-01 1.623721e-02 4.229989e-05 -70 9.000000e-01 1.924788e-02 5.381443e-05 -71 9.100000e-01 2.253041e-02 6.775416e-05 -72 9.200000e-01 2.607182e-02 8.448562e-05 -73 9.300000e-01 2.985650e-02 1.044530e-04 -74 9.400000e-01 3.386575e-02 1.282787e-04 -75 9.500000e-01 3.807605e-02 1.570841e-04 -76 9.600000e-01 4.245317e-02 1.935144e-04 -77 9.700000e-01 4.693613e-02 2.446155e-04 -78 9.800000e-01 5.140989e-02 3.270976e-04 -79 9.900000e-01 5.571579e-02 4.668657e-04 -80 1.000000e+00 5.977060e-02 6.784053e-04 -81 1.010000e+00 6.363845e-02 9.483720e-04 -82 1.020000e+00 6.743270e-02 1.251993e-03 -83 1.030000e+00 7.123467e-02 1.571674e-03 -84 1.040000e+00 7.508885e-02 1.899848e-03 -85 1.050000e+00 7.901772e-02 2.235275e-03 -86 1.060000e+00 8.303174e-02 2.579678e-03 -87 1.070000e+00 8.713429e-02 2.935896e-03 -88 1.080000e+00 9.132395e-02 3.307053e-03 -89 1.090000e+00 9.559576e-02 3.696236e-03 -90 1.100000e+00 9.994202e-02 4.106396e-03 -91 1.110000e+00 1.043530e-01 4.540339e-03 -92 1.120000e+00 1.088174e-01 5.000748e-03 -93 1.130000e+00 1.133230e-01 5.490201e-03 -94 1.140000e+00 1.178571e-01 6.011191e-03 -95 1.150000e+00 1.224071e-01 6.566120e-03 -96 1.160000e+00 1.269605e-01 7.157300e-03 -97 1.170000e+00 1.315057e-01 7.786926e-03 -98 1.180000e+00 1.360319e-01 8.457060e-03 -99 1.190000e+00 1.405293e-01 9.169599e-03 -100 1.200000e+00 1.449897e-01 9.926253e-03 +0 2.000000e-01 4.049275e-13 2.228959e-12 +1 2.100000e-01 5.113338e-13 2.714122e-12 +2 2.200000e-01 6.630638e-13 3.309110e-12 +3 2.300000e-01 8.814204e-13 4.039392e-12 +4 2.400000e-01 1.197716e-12 4.936361e-12 +5 2.500000e-01 1.657977e-12 6.038721e-12 +6 2.600000e-01 2.329849e-12 7.394200e-12 +7 2.700000e-01 3.312756e-12 9.061656e-12 +8 2.800000e-01 4.752819e-12 1.111369e-11 +9 2.900000e-01 6.864784e-12 1.363988e-11 +10 3.000000e-01 9.964231e-12 1.675076e-11 +11 3.100000e-01 1.451491e-11 2.058275e-11 +12 3.200000e-01 2.119828e-11 2.530429e-11 +13 3.300000e-01 3.101563e-11 3.112340e-11 +14 3.400000e-01 4.543821e-11 3.829703e-11 +15 3.500000e-01 6.662754e-11 4.714276e-11 +16 3.600000e-01 9.775923e-11 5.805316e-11 +17 3.700000e-01 1.434984e-10 7.151385e-11 +18 3.800000e-01 2.106980e-10 8.812576e-11 +19 3.900000e-01 3.094239e-10 1.086330e-10 +20 4.000000e-01 4.544605e-10 1.339576e-10 +21 4.100000e-01 6.675208e-10 1.652431e-10 +22 4.200000e-01 9.804908e-10 2.039088e-10 +23 4.300000e-01 1.440191e-09 2.517182e-10 +24 4.400000e-01 2.115368e-09 3.108651e-10 +25 4.500000e-01 3.106946e-09 3.840828e-10 +26 4.600000e-01 4.563079e-09 4.747811e-10 +27 4.700000e-01 6.701218e-09 5.872227e-10 +28 4.800000e-01 9.840494e-09 7.267467e-10 +29 4.900000e-01 1.444919e-08 9.000562e-10 +30 5.000000e-01 2.121433e-08 1.115590e-09 +31 5.100000e-01 3.114373e-08 1.384002e-09 +32 5.200000e-01 4.571544e-08 1.718799e-09 +33 5.300000e-01 6.709676e-08 2.137132e-09 +34 5.400000e-01 9.846489e-08 2.660929e-09 +35 5.500000e-01 1.444763e-07 3.318308e-09 +36 5.600000e-01 2.119536e-07 4.145522e-09 +37 5.700000e-01 3.108897e-07 5.189556e-09 +38 5.800000e-01 4.559164e-07 6.511663e-09 +39 5.900000e-01 6.684482e-07 8.192167e-09 +40 6.000000e-01 9.798144e-07 1.033707e-08 +41 6.100000e-01 1.435828e-06 1.308719e-08 +42 6.200000e-01 2.103455e-06 1.663074e-08 +43 6.300000e-01 3.080525e-06 2.122105e-08 +44 6.400000e-01 4.509880e-06 2.720120e-08 +45 6.500000e-01 6.596844e-06 3.503877e-08 +46 6.600000e-01 9.647940e-06 4.537475e-08 +47 6.700000e-01 1.410226e-05 5.909275e-08 +48 6.800000e-01 2.059972e-05 7.741690e-08 +49 6.900000e-01 3.006819e-05 1.020505e-07 +50 7.000000e-01 4.385020e-05 1.353718e-07 +51 7.100000e-01 6.388229e-05 1.807107e-07 +52 7.200000e-01 9.294511e-05 2.427359e-07 +53 7.300000e-01 1.350039e-04 3.279924e-07 +54 7.400000e-01 1.956548e-04 4.456394e-07 +55 7.500000e-01 2.826782e-04 6.084386e-07 +56 7.600000e-01 4.066653e-04 8.340431e-07 +57 7.700000e-01 5.816221e-04 1.146610e-06 +58 7.800000e-01 8.253658e-04 1.578709e-06 +59 7.900000e-01 1.159449e-03 2.173417e-06 +60 8.000000e-01 1.608349e-03 2.986417e-06 +61 8.100000e-01 2.197834e-03 4.087850e-06 +62 8.200000e-01 2.952755e-03 5.563725e-06 +63 8.300000e-01 3.894822e-03 7.516722e-06 +64 8.400000e-01 5.040995e-03 1.006634e-05 +65 8.500000e-01 6.402781e-03 1.334838e-05 +66 8.600000e-01 7.986391e-03 1.751363e-05 +67 8.700000e-01 9.793400e-03 2.272603e-05 +68 8.800000e-01 1.182159e-02 2.916016e-05 +69 8.900000e-01 1.406575e-02 3.699861e-05 +70 9.000000e-01 1.651838e-02 4.642947e-05 +71 9.100000e-01 1.917019e-02 5.764474e-05 +72 9.200000e-01 2.201052e-02 7.084062e-05 +73 9.300000e-01 2.502762e-02 8.622214e-05 +74 9.400000e-01 2.820878e-02 1.040182e-04 +75 9.500000e-01 3.154025e-02 1.245245e-04 +76 9.600000e-01 3.500674e-02 1.482245e-04 +77 9.700000e-01 3.858976e-02 1.761297e-04 +78 9.800000e-01 4.226323e-02 2.106934e-04 +79 9.900000e-01 4.598348e-02 2.579408e-04 +80 1.000000e+00 4.967483e-02 3.308659e-04 +81 1.010000e+00 5.323301e-02 4.499557e-04 +82 1.020000e+00 5.657993e-02 6.330012e-04 +83 1.030000e+00 5.972028e-02 8.813991e-04 +84 1.040000e+00 6.271680e-02 1.181850e-03 +85 1.050000e+00 6.563508e-02 1.518125e-03 +86 1.060000e+00 6.852092e-02 1.878222e-03 +87 1.070000e+00 7.140176e-02 2.255370e-03 +88 1.080000e+00 7.429288e-02 2.646645e-03 +89 1.090000e+00 7.720226e-02 3.051443e-03 +90 1.100000e+00 8.013339e-02 3.470405e-03 +91 1.110000e+00 8.308694e-02 3.904762e-03 +92 1.120000e+00 8.606171e-02 4.355986e-03 +93 1.130000e+00 8.905522e-02 4.825594e-03 +94 1.140000e+00 9.206412e-02 5.315066e-03 +95 1.150000e+00 9.508446e-02 5.825795e-03 +96 1.160000e+00 9.811193e-02 6.359080e-03 +97 1.170000e+00 1.011420e-01 6.916117e-03 +98 1.180000e+00 1.041701e-01 7.498008e-03 +99 1.190000e+00 1.071917e-01 8.105763e-03 +100 1.200000e+00 1.102022e-01 8.740302e-03 diff --git a/tests/hicum2/FG_sh.cir b/tests/hicum2/FG_sh.cir new file mode 100644 index 000000000..45d051119 --- /dev/null +++ b/tests/hicum2/FG_sh.cir @@ -0,0 +1,34 @@ +HICUML2 v2.4.0 Gummel Test +VE Q1_E 0 1.0 +VC Q1_C 0 0.0 +VB Q1_B 0 0.0 +RT Q1_T 0 1M +Q1 Q1_C Q1_B Q1_E Q1_E Q1_T P1 +.DC VE -0.2 -1.2 -10m +.OPTIONS GMIN=1e-13 NOACCT + +.print dc abs(i(vc)) abs(i(vb)) + +.MODEL P1 NPN LEVEL=8 ++ c10=9.074e-030 qp0=1.008e-013 hfe=10.01 hfc=20.04 hjei=3.382 hjci=0.2 ++ ibeis=1.328e-019 mbei=1.027 ireis=1.5e-014 mrei=2 ibeps=1.26e-019 mbep=1.042 ++ ireps=1.8e-014 mrep=1.8 mcf=1 tbhrec=1e-010 ibcis=4.603e-017 mbci=1.15 ++ ibcxs=0 mbcx=1 ibets=0.02035 abet=24 tunode=1 favl=18.96 qavl=5.092e-014 ++ alfav=-0.0024 alqav=-0.0006284 rbi0=4.444 rbx=2.568 fgeo=0.7409 fdqr0=0 ++ fcrbi=0 fqi=1 re=1.511 rcx=2.483 itss=0 msf=1 iscs=0 msc=1 ++ tsf=0 rsu=0 csu=0 cjei0=8.869e-015 vdei=0.714 zei=0.2489 ajei=1.65 ++ cjep0=2.178e-015 vdep=0.8501 zep=0.2632 ajep=1.6 cjci0=3.58e-015 vdci=0.8201 ++ zci=0.2857 vptci=1.79 cjcx0=6.299e-015 vdcx=0.8201 zcx=0.2863 vptcx=1.977 ++ fbcpar=0.3 fbepar=1 cjs0=2.6e-014 vds=0.9997 zs=0.4295 vpts=100 ++ t0=2.089e-013 dt0h=8e-014 tbvl=8.25e-014 tef0=3.271e-013 gtfe=3.548 thcs=5.001e-012 ++ ahc=0.05 fthc=0.7 rci0=9.523 vlim=0.6999 vces=0.01 vpt=2 tr=0 ++ cbepar=2.609e-014 cbcpar=1.64512e-014 alqf=0.166667 alit=0.333333 flnqs=1 kf=0 ++ af=2 cfbe=-1 latb=0 latl=0 vgb=0.91 alt0=0.004 kt0=6.588e-005 ++ zetaci=0.58 alvs=0.001 alces=-0.2286 zetarbi=0.3002 zetarbx=0.06011 zetarcx=-0.02768 ++ zetare=-0.9605 zetacx=0 vge=1.17 vgc=1.17 vgs=1.17 f1vg=-0.000102377 f2vg=0.00043215 ++ zetact=5 zetabet=4.892 flsh=1 rth=1113.4 cth=6.841e-012 zetarth=0 ++ alrth=0.002 flcomp=2.4 tnom=26.85 acbar=1.5 flcono=0 icbar=0.01 ++ vcbar=0.04 zetavgbe=0.7 hf0=40 ahjei=3 rhjei=2 delck=2 zetahjei=-0.5 + + +.END diff --git a/tests/hicum2/Makefile.am b/tests/hicum2/Makefile.am index a3b42bbc8..79fbe2846 100644 --- a/tests/hicum2/Makefile.am +++ b/tests/hicum2/Makefile.am @@ -2,7 +2,8 @@ -TESTS = FG.cir +TESTS = FG.cir \ + FG_sh.cir TESTS_ENVIRONMENT = $(SHELL) $(top_srcdir)/tests/bin/check.sh $(top_builddir)/src/ngspice