luke
/
ngspice
mirror of https://git.code.sf.net/p/ngspice/ngspice
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

multiplier introduced

This commit is contained in:
dwarning 2007-11-21 17:01:09 +00:00
parent 698c5ad77e
commit f08f8e4149
18 changed files with 1037 additions and 1002 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/spicelib/devices/bsim4v2/b4v2.c
View File

@ -11,7 +11,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include "devdefs.h"
#include "bsim4v2def.h"
#include "suffix.h"
@ -19,6 +18,7 @@
IFparm BSIM4v2pTable[] = { /* parameters */
IOP( "l", BSIM4v2_L, IF_REAL , "Length"),
IOP( "w", BSIM4v2_W, IF_REAL , "Width"),
IOP( "m", BSIM4v2_M, IF_REAL , "Separate Parallel multiplier"),
IOP( "nf", BSIM4v2_NF, IF_REAL , "Number of fingers"),
IOP( "min", BSIM4v2_MIN, IF_INTEGER , "Minimize either D or S"),
IOP( "ad", BSIM4v2_AD, IF_REAL , "Drain area"),

287
src/spicelib/devices/bsim4v2/b4v2acld.c
View File

@ -11,7 +11,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "bsim4v2def.h"
#include "sperror.h"
@ -54,6 +53,8 @@ double FwdSumi, RevSumi, Gmi, Gmbsi, Gdsi;
struct bsim4SizeDependParam *pParam;
double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
double m;
omega = ckt->CKTomega;
for (; model != NULL; model = model->BSIM4v2nextModel)
{ for (here = model->BSIM4v2instances; here!= NULL;
@ -451,6 +452,8 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
* Loading AC matrix
*/
m = here->BSIM4v2m;
if (!model->BSIM4v2rdsMod)
{ gdpr = here->BSIM4v2drainConductance;
gspr = here->BSIM4v2sourceConductance;
@ -468,122 +471,122 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
geltd = here->BSIM4v2grgeltd;
if (here->BSIM4v2rgateMod == 1)
{ *(here->BSIM4v2GEgePtr) += geltd;
*(here->BSIM4v2GPgePtr) -= geltd;
*(here->BSIM4v2GEgpPtr) -= geltd;
{ *(here->BSIM4v2GEgePtr) += m * geltd;
*(here->BSIM4v2GPgePtr) -= m * geltd;
*(here->BSIM4v2GEgpPtr) -= m * geltd;
*(here->BSIM4v2GPgpPtr +1) += xcggbr;
*(here->BSIM4v2GPgpPtr) += geltd + xcggbi + gIgtotg;
*(here->BSIM4v2GPdpPtr +1) += xcgdbr;
*(here->BSIM4v2GPdpPtr) += xcgdbi + gIgtotd;
*(here->BSIM4v2GPspPtr +1) += xcgsbr;
*(here->BSIM4v2GPspPtr) += xcgsbi + gIgtots;
*(here->BSIM4v2GPbpPtr +1) += xcgbbr;
*(here->BSIM4v2GPbpPtr) += xcgbbi + gIgtotb;
*(here->BSIM4v2GPgpPtr +1) += m * xcggbr;
*(here->BSIM4v2GPgpPtr) += m * (geltd + xcggbi + gIgtotg);
*(here->BSIM4v2GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4v2GPdpPtr) += m * (xcgdbi + gIgtotd);
*(here->BSIM4v2GPspPtr +1) += m * xcgsbr;
*(here->BSIM4v2GPspPtr) += m * (xcgsbi + gIgtots);
*(here->BSIM4v2GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4v2GPbpPtr) += m * (xcgbbi + gIgtotb);
} /* WDLiu: gcrg already subtracted from all gcrgg below */
else if (here->BSIM4v2rgateMod == 2)
{ *(here->BSIM4v2GEgePtr) += gcrg;
*(here->BSIM4v2GEgpPtr) += gcrgg;
*(here->BSIM4v2GEdpPtr) += gcrgd;
*(here->BSIM4v2GEspPtr) += gcrgs;
*(here->BSIM4v2GEbpPtr) += gcrgb;
{ *(here->BSIM4v2GEgePtr) += m * gcrg;
*(here->BSIM4v2GEgpPtr) += m * gcrgg;
*(here->BSIM4v2GEdpPtr) += m * gcrgd;
*(here->BSIM4v2GEspPtr) += m * gcrgs;
*(here->BSIM4v2GEbpPtr) += m * gcrgb;
*(here->BSIM4v2GPgePtr) -= gcrg;
*(here->BSIM4v2GPgpPtr +1) += xcggbr;
*(here->BSIM4v2GPgpPtr) -= gcrgg - xcggbi - gIgtotg;
*(here->BSIM4v2GPdpPtr +1) += xcgdbr;
*(here->BSIM4v2GPdpPtr) -= gcrgd - xcgdbi - gIgtotd;
*(here->BSIM4v2GPspPtr +1) += xcgsbr;
*(here->BSIM4v2GPspPtr) -= gcrgs - xcgsbi - gIgtots;
*(here->BSIM4v2GPbpPtr +1) += xcgbbr;
*(here->BSIM4v2GPbpPtr) -= gcrgb - xcgbbi - gIgtotb;
*(here->BSIM4v2GPgePtr) -= m * gcrg;
*(here->BSIM4v2GPgpPtr +1) += m * xcggbr;
*(here->BSIM4v2GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg);
*(here->BSIM4v2GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4v2GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd);
*(here->BSIM4v2GPspPtr +1) += m * xcgsbr;
*(here->BSIM4v2GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots);
*(here->BSIM4v2GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4v2GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb);
}
else if (here->BSIM4v2rgateMod == 3)
{ *(here->BSIM4v2GEgePtr) += geltd;
*(here->BSIM4v2GEgmPtr) -= geltd;
*(here->BSIM4v2GMgePtr) -= geltd;
*(here->BSIM4v2GMgmPtr) += geltd + gcrg;
*(here->BSIM4v2GMgmPtr +1) += xcgmgmb;
{ *(here->BSIM4v2GEgePtr) += m * geltd;
*(here->BSIM4v2GEgmPtr) -= m * geltd;
*(here->BSIM4v2GMgePtr) -= m * geltd;
*(here->BSIM4v2GMgmPtr) += m * (geltd + gcrg);
*(here->BSIM4v2GMgmPtr +1) += m * xcgmgmb;
*(here->BSIM4v2GMdpPtr) += gcrgd;
*(here->BSIM4v2GMdpPtr +1) += xcgmdb;
*(here->BSIM4v2GMgpPtr) += gcrgg;
*(here->BSIM4v2GMspPtr) += gcrgs;
*(here->BSIM4v2GMspPtr +1) += xcgmsb;
*(here->BSIM4v2GMbpPtr) += gcrgb;
*(here->BSIM4v2GMbpPtr +1) += xcgmbb;
*(here->BSIM4v2GMdpPtr) += m * gcrgd;
*(here->BSIM4v2GMdpPtr +1) += m * xcgmdb;
*(here->BSIM4v2GMgpPtr) += m * gcrgg;
*(here->BSIM4v2GMspPtr) += m * gcrgs;
*(here->BSIM4v2GMspPtr +1) += m * xcgmsb;
*(here->BSIM4v2GMbpPtr) += m * gcrgb;
*(here->BSIM4v2GMbpPtr +1) += m * xcgmbb;
*(here->BSIM4v2DPgmPtr +1) += xcdgmb;
*(here->BSIM4v2GPgmPtr) -= gcrg;
*(here->BSIM4v2SPgmPtr +1) += xcsgmb;
*(here->BSIM4v2BPgmPtr +1) += xcbgmb;
*(here->BSIM4v2DPgmPtr +1) += m * xcdgmb;
*(here->BSIM4v2GPgmPtr) -= m * gcrg;
*(here->BSIM4v2SPgmPtr +1) += m * xcsgmb;
*(here->BSIM4v2BPgmPtr +1) += m * xcbgmb;
*(here->BSIM4v2GPgpPtr) -= gcrgg - xcggbi - gIgtotg;
*(here->BSIM4v2GPgpPtr +1) += xcggbr;
*(here->BSIM4v2GPdpPtr) -= gcrgd - xcgdbi - gIgtotd;
*(here->BSIM4v2GPdpPtr +1) += xcgdbr;
*(here->BSIM4v2GPspPtr) -= gcrgs - xcgsbi - gIgtots;
*(here->BSIM4v2GPspPtr +1) += xcgsbr;
*(here->BSIM4v2GPbpPtr) -= gcrgb - xcgbbi - gIgtotb;
*(here->BSIM4v2GPbpPtr +1) += xcgbbr;
*(here->BSIM4v2GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg);
*(here->BSIM4v2GPgpPtr +1) += m * xcggbr;
*(here->BSIM4v2GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd);
*(here->BSIM4v2GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4v2GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots);
*(here->BSIM4v2GPspPtr +1) += m * xcgsbr;
*(here->BSIM4v2GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb);
*(here->BSIM4v2GPbpPtr +1) += m * xcgbbr;
}
else
{ *(here->BSIM4v2GPgpPtr +1) += xcggbr;
*(here->BSIM4v2GPgpPtr) += xcggbi + gIgtotg;
*(here->BSIM4v2GPdpPtr +1) += xcgdbr;
*(here->BSIM4v2GPdpPtr) += xcgdbi + gIgtotd;
*(here->BSIM4v2GPspPtr +1) += xcgsbr;
*(here->BSIM4v2GPspPtr) += xcgsbi + gIgtots;
*(here->BSIM4v2GPbpPtr +1) += xcgbbr;
*(here->BSIM4v2GPbpPtr) += xcgbbi + gIgtotb;
{ *(here->BSIM4v2GPgpPtr +1) += m * xcggbr;
*(here->BSIM4v2GPgpPtr) += m * (xcggbi + gIgtotg);
*(here->BSIM4v2GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4v2GPdpPtr) += m * (xcgdbi + gIgtotd);
*(here->BSIM4v2GPspPtr +1) += m * xcgsbr;
*(here->BSIM4v2GPspPtr) += m * (xcgsbi + gIgtots);
*(here->BSIM4v2GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4v2GPbpPtr) += m * (xcgbbi + gIgtotb);
}
if (model->BSIM4v2rdsMod)
{ (*(here->BSIM4v2DgpPtr) += gdtotg);
(*(here->BSIM4v2DspPtr) += gdtots);
(*(here->BSIM4v2DbpPtr) += gdtotb);
(*(here->BSIM4v2SdpPtr) += gstotd);
(*(here->BSIM4v2SgpPtr) += gstotg);
(*(here->BSIM4v2SbpPtr) += gstotb);
{ (*(here->BSIM4v2DgpPtr) += m * gdtotg);
(*(here->BSIM4v2DspPtr) += m * gdtots);
(*(here->BSIM4v2DbpPtr) += m * gdtotb);
(*(here->BSIM4v2SdpPtr) += m * gstotd);
(*(here->BSIM4v2SgpPtr) += m * gstotg);
(*(here->BSIM4v2SbpPtr) += m * gstotb);
}
*(here->BSIM4v2DPdpPtr +1) += xcddbr + gdsi + RevSumi;
*(here->BSIM4v2DPdpPtr) += gdpr + xcddbi + gdsr + here->BSIM4v2gbd
- gdtotd + RevSumr + gbdpdp - gIdtotd;
*(here->BSIM4v2DPdPtr) -= gdpr + gdtot;
*(here->BSIM4v2DPgpPtr +1) += xcdgbr + Gmi;
*(here->BSIM4v2DPgpPtr) += Gmr + xcdgbi - gdtotg + gbdpg - gIdtotg;
*(here->BSIM4v2DPspPtr +1) += xcdsbr - gdsi - FwdSumi;
*(here->BSIM4v2DPspPtr) -= gdsr - xcdsbi + FwdSumr + gdtots - gbdpsp + gIdtots;
*(here->BSIM4v2DPbpPtr +1) += xcdbbr + Gmbsi;
*(here->BSIM4v2DPbpPtr) -= gjbd + gdtotb - xcdbbi - Gmbsr - gbdpb + gIdtotb;
*(here->BSIM4v2DPdpPtr +1) += m * (xcddbr + gdsi + RevSumi);
*(here->BSIM4v2DPdpPtr) += m * (gdpr + xcddbi + gdsr + here->BSIM4v2gbd
- gdtotd + RevSumr + gbdpdp - gIdtotd);
*(here->BSIM4v2DPdPtr) -= m * (gdpr + gdtot);
*(here->BSIM4v2DPgpPtr +1) += m * (xcdgbr + Gmi);
*(here->BSIM4v2DPgpPtr) += m * (Gmr + xcdgbi - gdtotg + gbdpg - gIdtotg);
*(here->BSIM4v2DPspPtr +1) += m * (xcdsbr - gdsi - FwdSumi);
*(here->BSIM4v2DPspPtr) -= m * (gdsr - xcdsbi + FwdSumr + gdtots - gbdpsp + gIdtots);
*(here->BSIM4v2DPbpPtr +1) += m * (xcdbbr + Gmbsi);
*(here->BSIM4v2DPbpPtr) -= m * (gjbd + gdtotb - xcdbbi - Gmbsr - gbdpb + gIdtotb);
*(here->BSIM4v2DdpPtr) -= gdpr - gdtotd;
*(here->BSIM4v2DdPtr) += gdpr + gdtot;
*(here->BSIM4v2DdpPtr) -= m * (gdpr - gdtotd);
*(here->BSIM4v2DdPtr) += m * (gdpr + gdtot);
*(here->BSIM4v2SPdpPtr +1) += xcsdbr - gdsi - RevSumi;
*(here->BSIM4v2SPdpPtr) -= gdsr - xcsdbi + gstotd + RevSumr - gbspdp + gIstotd;
*(here->BSIM4v2SPgpPtr +1) += xcsgbr - Gmi;
*(here->BSIM4v2SPgpPtr) -= Gmr - xcsgbi + gstotg - gbspg + gIstotg;
*(here->BSIM4v2SPspPtr +1) += xcssbr + gdsi + FwdSumi;
*(here->BSIM4v2SPspPtr) += gspr + xcssbi + gdsr + here->BSIM4v2gbs
- gstots + FwdSumr + gbspsp - gIstots;
*(here->BSIM4v2SPsPtr) -= gspr + gstot;
*(here->BSIM4v2SPbpPtr +1) += xcsbbr - Gmbsi;
*(here->BSIM4v2SPbpPtr) -= gjbs + gstotb - xcsbbi + Gmbsr - gbspb + gIstotb;
*(here->BSIM4v2SPdpPtr +1) += m * (xcsdbr - gdsi - RevSumi);
*(here->BSIM4v2SPdpPtr) -= m * (gdsr - xcsdbi + gstotd + RevSumr - gbspdp + gIstotd);
*(here->BSIM4v2SPgpPtr +1) += m * (xcsgbr - Gmi);
*(here->BSIM4v2SPgpPtr) -= m * (Gmr - xcsgbi + gstotg - gbspg + gIstotg);
*(here->BSIM4v2SPspPtr +1) += m * (xcssbr + gdsi + FwdSumi);
*(here->BSIM4v2SPspPtr) += m * (gspr + xcssbi + gdsr + here->BSIM4v2gbs
- gstots + FwdSumr + gbspsp - gIstots);
*(here->BSIM4v2SPsPtr) -= m * (gspr + gstot);
*(here->BSIM4v2SPbpPtr +1) += m * (xcsbbr - Gmbsi);
*(here->BSIM4v2SPbpPtr) -= m * (gjbs + gstotb - xcsbbi + Gmbsr - gbspb + gIstotb);
*(here->BSIM4v2SspPtr) -= gspr - gstots;
*(here->BSIM4v2SsPtr) += gspr + gstot;
*(here->BSIM4v2SspPtr) -= m * (gspr - gstots);
*(here->BSIM4v2SsPtr) += m * (gspr + gstot);
*(here->BSIM4v2BPdpPtr +1) += xcbdb;
*(here->BSIM4v2BPdpPtr) -= gjbd - gbbdp + gIbtotd;
*(here->BSIM4v2BPgpPtr +1) += xcbgb;
*(here->BSIM4v2BPgpPtr) -= here->BSIM4v2gbgs + gIbtotg;
*(here->BSIM4v2BPspPtr +1) += xcbsb;
*(here->BSIM4v2BPspPtr) -= gjbs - gbbsp + gIbtots;
*(here->BSIM4v2BPbpPtr +1) += xcbbb;
*(here->BSIM4v2BPbpPtr) += gjbd + gjbs - here->BSIM4v2gbbs
- gIbtotb;
*(here->BSIM4v2BPdpPtr +1) += m * xcbdb;
*(here->BSIM4v2BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd);
*(here->BSIM4v2BPgpPtr +1) += m * xcbgb;
*(here->BSIM4v2BPgpPtr) -= m * (here->BSIM4v2gbgs + gIbtotg);
*(here->BSIM4v2BPspPtr +1) += m * xcbsb;
*(here->BSIM4v2BPspPtr) -= m * (gjbs - gbbsp + gIbtots);
*(here->BSIM4v2BPbpPtr +1) += m * xcbbb;
*(here->BSIM4v2BPbpPtr) += m * (gjbd + gjbs - here->BSIM4v2gbbs
- gIbtotb);
ggidld = here->BSIM4v2ggidld;
ggidlg = here->BSIM4v2ggidlg;
ggidlb = here->BSIM4v2ggidlb;
@ -592,58 +595,58 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
ggislb = here->BSIM4v2ggislb;
/* stamp gidl */
(*(here->BSIM4v2DPdpPtr) += ggidld);
(*(here->BSIM4v2DPgpPtr) += ggidlg);
(*(here->BSIM4v2DPspPtr) -= (ggidlg + ggidld) + ggidlb);
(*(here->BSIM4v2DPbpPtr) += ggidlb);
(*(here->BSIM4v2BPdpPtr) -= ggidld);
(*(here->BSIM4v2BPgpPtr) -= ggidlg);
(*(here->BSIM4v2BPspPtr) += (ggidlg + ggidld) + ggidlb);
(*(here->BSIM4v2BPbpPtr) -= ggidlb);
(*(here->BSIM4v2DPdpPtr) += m * ggidld);
(*(here->BSIM4v2DPgpPtr) += m * ggidlg);
(*(here->BSIM4v2DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4v2DPbpPtr) += m * ggidlb);
(*(here->BSIM4v2BPdpPtr) -= m * ggidld);
(*(here->BSIM4v2BPgpPtr) -= m * ggidlg);
(*(here->BSIM4v2BPspPtr) += m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4v2BPbpPtr) -= m * ggidlb);
/* stamp gisl */
(*(here->BSIM4v2SPdpPtr) -= (ggisls + ggislg) + ggislb);
(*(here->BSIM4v2SPgpPtr) += ggislg);
(*(here->BSIM4v2SPspPtr) += ggisls);
(*(here->BSIM4v2SPbpPtr) += ggislb);
(*(here->BSIM4v2BPdpPtr) += (ggislg + ggisls) + ggislb);
(*(here->BSIM4v2BPgpPtr) -= ggislg);
(*(here->BSIM4v2BPspPtr) -= ggisls);
(*(here->BSIM4v2BPbpPtr) -= ggislb);
(*(here->BSIM4v2SPdpPtr) -= m * ((ggisls + ggislg) + ggislb));
(*(here->BSIM4v2SPgpPtr) += m * ggislg);
(*(here->BSIM4v2SPspPtr) += m * ggisls);
(*(here->BSIM4v2SPbpPtr) += m * ggislb);
(*(here->BSIM4v2BPdpPtr) += m * ((ggislg + ggisls) + ggislb));
(*(here->BSIM4v2BPgpPtr) -= m * ggislg);
(*(here->BSIM4v2BPspPtr) -= m * ggisls);
(*(here->BSIM4v2BPbpPtr) -= m * ggislb);
if (here->BSIM4v2rbodyMod)
{ (*(here->BSIM4v2DPdbPtr +1) += xcdbdb);
(*(here->BSIM4v2DPdbPtr) -= here->BSIM4v2gbd);
(*(here->BSIM4v2SPsbPtr +1) += xcsbsb);
(*(here->BSIM4v2SPsbPtr) -= here->BSIM4v2gbs);
{ (*(here->BSIM4v2DPdbPtr +1) += m * xcdbdb);
(*(here->BSIM4v2DPdbPtr) -= m * here->BSIM4v2gbd);
(*(here->BSIM4v2SPsbPtr +1) += m * xcsbsb);
(*(here->BSIM4v2SPsbPtr) -= m * here->BSIM4v2gbs);
(*(here->BSIM4v2DBdpPtr +1) += xcdbdb);
(*(here->BSIM4v2DBdpPtr) -= here->BSIM4v2gbd);
(*(here->BSIM4v2DBdbPtr +1) -= xcdbdb);
(*(here->BSIM4v2DBdbPtr) += here->BSIM4v2gbd + here->BSIM4v2grbpd
+ here->BSIM4v2grbdb);
(*(here->BSIM4v2DBbpPtr) -= here->BSIM4v2grbpd);
(*(here->BSIM4v2DBbPtr) -= here->BSIM4v2grbdb);
(*(here->BSIM4v2DBdpPtr +1) += m * xcdbdb);
(*(here->BSIM4v2DBdpPtr) -= m * here->BSIM4v2gbd);
(*(here->BSIM4v2DBdbPtr +1) -= m * xcdbdb);
(*(here->BSIM4v2DBdbPtr) += m * (here->BSIM4v2gbd + here->BSIM4v2grbpd
+ here->BSIM4v2grbdb));
(*(here->BSIM4v2DBbpPtr) -= m * here->BSIM4v2grbpd);
(*(here->BSIM4v2DBbPtr) -= m * here->BSIM4v2grbdb);
(*(here->BSIM4v2BPdbPtr) -= here->BSIM4v2grbpd);
(*(here->BSIM4v2BPbPtr) -= here->BSIM4v2grbpb);
(*(here->BSIM4v2BPsbPtr) -= here->BSIM4v2grbps);
(*(here->BSIM4v2BPbpPtr) += here->BSIM4v2grbpd + here->BSIM4v2grbps
+ here->BSIM4v2grbpb);
(*(here->BSIM4v2BPdbPtr) -= m * here->BSIM4v2grbpd);
(*(here->BSIM4v2BPbPtr) -= m * here->BSIM4v2grbpb);
(*(here->BSIM4v2BPsbPtr) -= m * here->BSIM4v2grbps);
(*(here->BSIM4v2BPbpPtr) += m * (here->BSIM4v2grbpd + here->BSIM4v2grbps
+ here->BSIM4v2grbpb));
/* WDLiu: (-here->BSIM4v2gbbs) already added to BPbpPtr */
(*(here->BSIM4v2SBspPtr +1) += xcsbsb);
(*(here->BSIM4v2SBspPtr) -= here->BSIM4v2gbs);
(*(here->BSIM4v2SBbpPtr) -= here->BSIM4v2grbps);
(*(here->BSIM4v2SBbPtr) -= here->BSIM4v2grbsb);
(*(here->BSIM4v2SBsbPtr +1) -= xcsbsb);
(*(here->BSIM4v2SBsbPtr) += here->BSIM4v2gbs
+ here->BSIM4v2grbps + here->BSIM4v2grbsb);
(*(here->BSIM4v2SBspPtr +1) += m * xcsbsb);
(*(here->BSIM4v2SBspPtr) -= m * here->BSIM4v2gbs);
(*(here->BSIM4v2SBbpPtr) -= m * here->BSIM4v2grbps);
(*(here->BSIM4v2SBbPtr) -= m * here->BSIM4v2grbsb);
(*(here->BSIM4v2SBsbPtr +1) -= m * xcsbsb);
(*(here->BSIM4v2SBsbPtr) += m * (here->BSIM4v2gbs
+ here->BSIM4v2grbps + here->BSIM4v2grbsb));
(*(here->BSIM4v2BdbPtr) -= here->BSIM4v2grbdb);
(*(here->BSIM4v2BbpPtr) -= here->BSIM4v2grbpb);
(*(here->BSIM4v2BsbPtr) -= here->BSIM4v2grbsb);
(*(here->BSIM4v2BbPtr) += here->BSIM4v2grbsb + here->BSIM4v2grbdb
+ here->BSIM4v2grbpb);
(*(here->BSIM4v2BdbPtr) -= m * here->BSIM4v2grbdb);
(*(here->BSIM4v2BbpPtr) -= m * here->BSIM4v2grbpb);
(*(here->BSIM4v2BsbPtr) -= m * here->BSIM4v2grbsb);
(*(here->BSIM4v2BbPtr) += m * (here->BSIM4v2grbsb + here->BSIM4v2grbdb
+ here->BSIM4v2grbpb));
}
@ -654,7 +657,7 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
* The charge node is isolated from the instance.
*/
if (here->BSIM4v2trnqsMod)
{ (*(here->BSIM4v2QqPtr) += 1.0);
{ (*(here->BSIM4v2QqPtr) += m * 1.0);
(*(here->BSIM4v2QgpPtr) += 0.0);
(*(here->BSIM4v2QdpPtr) += 0.0);
(*(here->BSIM4v2QspPtr) += 0.0);

3
src/spicelib/devices/bsim4v2/b4v2ask.c
View File

@ -37,6 +37,9 @@ BSIM4v2instance *here = (BSIM4v2instance*)inst;
case BSIM4v2_W:
value->rValue = here->BSIM4v2w;
return(OK);
case BSIM4v2_M:
value->rValue = here->BSIM4v2m;
return(OK);
case BSIM4v2_NF:
value->rValue = here->BSIM4v2nf;
return(OK);

263
src/spicelib/devices/bsim4v2/b4v2ld.c
View File

@ -11,8 +11,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "bsim4v2def.h"
#include "trandefs.h"
@ -173,6 +171,8 @@ double Igisl, Ggisld, Ggislg, Ggislb, Ggisls;
struct bsim4SizeDependParam *pParam;
int ByPass, ChargeComputationNeeded, error, Check, Check1, Check2;
double m;
ScalingFactor = 1.0e-9;
ChargeComputationNeeded =
((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) ||
@ -4236,37 +4236,38 @@ line900:
* Loading RHS
*/
m = here->BSIM4v2m;
(*(ckt->CKTrhs + here->BSIM4v2dNodePrime) += (ceqjd - ceqbd + ceqgdtot
(*(ckt->CKTrhs + here->BSIM4v2dNodePrime) += m * (ceqjd - ceqbd + ceqgdtot
- ceqdrn - ceqqd + Idtoteq));
(*(ckt->CKTrhs + here->BSIM4v2gNodePrime) -= ceqqg - ceqgcrg + Igtoteq);
(*(ckt->CKTrhs + here->BSIM4v2gNodePrime) -= m * (ceqqg - ceqgcrg + Igtoteq));
if (here->BSIM4v2rgateMod == 2)
(*(ckt->CKTrhs + here->BSIM4v2gNodeExt) -= ceqgcrg);
(*(ckt->CKTrhs + here->BSIM4v2gNodeExt) -= m * ceqgcrg);
else if (here->BSIM4v2rgateMod == 3)
(*(ckt->CKTrhs + here->BSIM4v2gNodeMid) -= ceqqgmid + ceqgcrg);
(*(ckt->CKTrhs + here->BSIM4v2gNodeMid) -= m * (ceqqgmid + ceqgcrg));
if (!here->BSIM4v2rbodyMod)
{ (*(ckt->CKTrhs + here->BSIM4v2bNodePrime) += (ceqbd + ceqbs - ceqjd
{ (*(ckt->CKTrhs + here->BSIM4v2bNodePrime) += m * (ceqbd + ceqbs - ceqjd
- ceqjs - ceqqb + Ibtoteq));
(*(ckt->CKTrhs + here->BSIM4v2sNodePrime) += (ceqdrn - ceqbs + ceqjs
(*(ckt->CKTrhs + here->BSIM4v2sNodePrime) += m * (ceqdrn - ceqbs + ceqjs
+ ceqqg + ceqqb + ceqqd + ceqqgmid - ceqgstot + Istoteq));
}
else
{ (*(ckt->CKTrhs + here->BSIM4v2dbNode) -= (ceqjd + ceqqjd));
(*(ckt->CKTrhs + here->BSIM4v2bNodePrime) += (ceqbd + ceqbs - ceqqb + Ibtoteq));
(*(ckt->CKTrhs + here->BSIM4v2sbNode) -= (ceqjs + ceqqjs));
(*(ckt->CKTrhs + here->BSIM4v2sNodePrime) += (ceqdrn - ceqbs + ceqjs + ceqqd
{ (*(ckt->CKTrhs + here->BSIM4v2dbNode) -= m * (ceqjd + ceqqjd));
(*(ckt->CKTrhs + here->BSIM4v2bNodePrime) += m * (ceqbd + ceqbs - ceqqb + Ibtoteq));
(*(ckt->CKTrhs + here->BSIM4v2sbNode) -= m * (ceqjs + ceqqjs));
(*(ckt->CKTrhs + here->BSIM4v2sNodePrime) += m * (ceqdrn - ceqbs + ceqjs + ceqqd
+ ceqqg + ceqqb + ceqqjd + ceqqjs + ceqqgmid - ceqgstot + Istoteq));
}
if (model->BSIM4v2rdsMod)
{ (*(ckt->CKTrhs + here->BSIM4v2dNode) -= ceqgdtot);
(*(ckt->CKTrhs + here->BSIM4v2sNode) += ceqgstot);
{ (*(ckt->CKTrhs + here->BSIM4v2dNode) -= m * ceqgdtot);
(*(ckt->CKTrhs + here->BSIM4v2sNode) += m * ceqgstot);
}
if (here->BSIM4v2trnqsMod)
*(ckt->CKTrhs + here->BSIM4v2qNode) += (cqcheq - cqdef);
*(ckt->CKTrhs + here->BSIM4v2qNode) += m * (cqcheq - cqdef);
/*
@ -4292,95 +4293,95 @@ line900:
T1 = qdef * here->BSIM4v2gtau;
if (here->BSIM4v2rgateMod == 1)
{ (*(here->BSIM4v2GEgePtr) += geltd);
(*(here->BSIM4v2GPgePtr) -= geltd);
(*(here->BSIM4v2GEgpPtr) -= geltd);
(*(here->BSIM4v2GPgpPtr) += gcggb + geltd - ggtg + gIgtotg);
(*(here->BSIM4v2GPdpPtr) += gcgdb - ggtd + gIgtotd);
(*(here->BSIM4v2GPspPtr) += gcgsb - ggts + gIgtots);
(*(here->BSIM4v2GPbpPtr) += gcgbb - ggtb + gIgtotb);
{ (*(here->BSIM4v2GEgePtr) += m * geltd);
(*(here->BSIM4v2GPgePtr) -= m * geltd);
(*(here->BSIM4v2GEgpPtr) -= m * geltd);
(*(here->BSIM4v2GPgpPtr) += m * (gcggb + geltd - ggtg + gIgtotg));
(*(here->BSIM4v2GPdpPtr) += m * (gcgdb - ggtd + gIgtotd));
(*(here->BSIM4v2GPspPtr) += m * (gcgsb - ggts + gIgtots));
(*(here->BSIM4v2GPbpPtr) += m * (gcgbb - ggtb + gIgtotb));
} /* WDLiu: gcrg already subtracted from all gcrgg below */
else if (here->BSIM4v2rgateMod == 2)
{ (*(here->BSIM4v2GEgePtr) += gcrg);
(*(here->BSIM4v2GEgpPtr) += gcrgg);
(*(here->BSIM4v2GEdpPtr) += gcrgd);
(*(here->BSIM4v2GEspPtr) += gcrgs);
(*(here->BSIM4v2GEbpPtr) += gcrgb);
{ (*(here->BSIM4v2GEgePtr) += m * gcrg);
(*(here->BSIM4v2GEgpPtr) += m * gcrgg);
(*(here->BSIM4v2GEdpPtr) += m * gcrgd);
(*(here->BSIM4v2GEspPtr) += m * gcrgs);
(*(here->BSIM4v2GEbpPtr) += m * gcrgb);
(*(here->BSIM4v2GPgePtr) -= gcrg);
(*(here->BSIM4v2GPgpPtr) += gcggb - gcrgg - ggtg + gIgtotg);
(*(here->BSIM4v2GPdpPtr) += gcgdb - gcrgd - ggtd + gIgtotd);
(*(here->BSIM4v2GPspPtr) += gcgsb - gcrgs - ggts + gIgtots);
(*(here->BSIM4v2GPbpPtr) += gcgbb - gcrgb - ggtb + gIgtotb);
(*(here->BSIM4v2GPgePtr) -= m * gcrg);
(*(here->BSIM4v2GPgpPtr) += m * (gcggb - gcrgg - ggtg + gIgtotg));
(*(here->BSIM4v2GPdpPtr) += m * (gcgdb - gcrgd - ggtd + gIgtotd));
(*(here->BSIM4v2GPspPtr) += m * (gcgsb - gcrgs - ggts + gIgtots));
(*(here->BSIM4v2GPbpPtr) += m * (gcgbb - gcrgb - ggtb + gIgtotb));
}
else if (here->BSIM4v2rgateMod == 3)
{ (*(here->BSIM4v2GEgePtr) += geltd);
(*(here->BSIM4v2GEgmPtr) -= geltd);
(*(here->BSIM4v2GMgePtr) -= geltd);
(*(here->BSIM4v2GMgmPtr) += geltd + gcrg + gcgmgmb);
{ (*(here->BSIM4v2GEgePtr) += m * geltd);
(*(here->BSIM4v2GEgmPtr) -= m * geltd);
(*(here->BSIM4v2GMgePtr) -= m * geltd);
(*(here->BSIM4v2GMgmPtr) += m * (geltd + gcrg + gcgmgmb));
(*(here->BSIM4v2GMdpPtr) += gcrgd + gcgmdb);
(*(here->BSIM4v2GMgpPtr) += gcrgg);
(*(here->BSIM4v2GMspPtr) += gcrgs + gcgmsb);
(*(here->BSIM4v2GMbpPtr) += gcrgb + gcgmbb);
(*(here->BSIM4v2GMdpPtr) += m * (gcrgd + gcgmdb));
(*(here->BSIM4v2GMgpPtr) += m * gcrgg);
(*(here->BSIM4v2GMspPtr) += m * (gcrgs + gcgmsb));
(*(here->BSIM4v2GMbpPtr) += m * (gcrgb + gcgmbb));
(*(here->BSIM4v2DPgmPtr) += gcdgmb);
(*(here->BSIM4v2GPgmPtr) -= gcrg);
(*(here->BSIM4v2SPgmPtr) += gcsgmb);
(*(here->BSIM4v2BPgmPtr) += gcbgmb);
(*(here->BSIM4v2DPgmPtr) += m * gcdgmb);
(*(here->BSIM4v2GPgmPtr) -= m * gcrg);
(*(here->BSIM4v2SPgmPtr) += m * gcsgmb);
(*(here->BSIM4v2BPgmPtr) += m * gcbgmb);
(*(here->BSIM4v2GPgpPtr) += gcggb - gcrgg - ggtg + gIgtotg);
(*(here->BSIM4v2GPdpPtr) += gcgdb - gcrgd - ggtd + gIgtotd);
(*(here->BSIM4v2GPspPtr) += gcgsb - gcrgs - ggts + gIgtots);
(*(here->BSIM4v2GPbpPtr) += gcgbb - gcrgb - ggtb + gIgtotb);
(*(here->BSIM4v2GPgpPtr) += m * (gcggb - gcrgg - ggtg + gIgtotg));
(*(here->BSIM4v2GPdpPtr) += m * (gcgdb - gcrgd - ggtd + gIgtotd));
(*(here->BSIM4v2GPspPtr) += m * (gcgsb - gcrgs - ggts + gIgtots));
(*(here->BSIM4v2GPbpPtr) += m * (gcgbb - gcrgb - ggtb + gIgtotb));
}
else
{ (*(here->BSIM4v2GPgpPtr) += gcggb - ggtg + gIgtotg);
(*(here->BSIM4v2GPdpPtr) += gcgdb - ggtd + gIgtotd);
(*(here->BSIM4v2GPspPtr) += gcgsb - ggts + gIgtots);
(*(here->BSIM4v2GPbpPtr) += gcgbb - ggtb + gIgtotb);
{ (*(here->BSIM4v2GPgpPtr) += m * (gcggb - ggtg + gIgtotg));
(*(here->BSIM4v2GPdpPtr) += m * (gcgdb - ggtd + gIgtotd));
(*(here->BSIM4v2GPspPtr) += m * (gcgsb - ggts + gIgtots));
(*(here->BSIM4v2GPbpPtr) += m * (gcgbb - ggtb + gIgtotb));
}
if (model->BSIM4v2rdsMod)
{ (*(here->BSIM4v2DgpPtr) += gdtotg);
(*(here->BSIM4v2DspPtr) += gdtots);
(*(here->BSIM4v2DbpPtr) += gdtotb);
(*(here->BSIM4v2SdpPtr) += gstotd);
(*(here->BSIM4v2SgpPtr) += gstotg);
(*(here->BSIM4v2SbpPtr) += gstotb);
{ (*(here->BSIM4v2DgpPtr) += m * gdtotg);
(*(here->BSIM4v2DspPtr) += m * gdtots);
(*(here->BSIM4v2DbpPtr) += m * gdtotb);
(*(here->BSIM4v2SdpPtr) += m * gstotd);
(*(here->BSIM4v2SgpPtr) += m * gstotg);
(*(here->BSIM4v2SbpPtr) += m * gstotb);
}
(*(here->BSIM4v2DPdpPtr) += gdpr + here->BSIM4v2gds + here->BSIM4v2gbd + T1 * ddxpart_dVd
- gdtotd + RevSum + gcddb + gbdpdp + dxpart * ggtd - gIdtotd);
(*(here->BSIM4v2DPdPtr) -= gdpr + gdtot);
(*(here->BSIM4v2DPgpPtr) += Gm + gcdgb - gdtotg + gbdpg - gIdtotg
+ dxpart * ggtg + T1 * ddxpart_dVg);
(*(here->BSIM4v2DPspPtr) -= here->BSIM4v2gds + gdtots - dxpart * ggts + gIdtots
- T1 * ddxpart_dVs + FwdSum - gcdsb - gbdpsp);
(*(here->BSIM4v2DPbpPtr) -= gjbd + gdtotb - Gmbs - gcdbb - gbdpb + gIdtotb
- T1 * ddxpart_dVb - dxpart * ggtb);
(*(here->BSIM4v2DPdpPtr) += m * (gdpr + here->BSIM4v2gds + here->BSIM4v2gbd + T1 * ddxpart_dVd
- gdtotd + RevSum + gcddb + gbdpdp + dxpart * ggtd - gIdtotd));
(*(here->BSIM4v2DPdPtr) -= m * (gdpr + gdtot));
(*(here->BSIM4v2DPgpPtr) += m * (Gm + gcdgb - gdtotg + gbdpg - gIdtotg
+ dxpart * ggtg + T1 * ddxpart_dVg));
(*(here->BSIM4v2DPspPtr) -= m * (here->BSIM4v2gds + gdtots - dxpart * ggts + gIdtots
- T1 * ddxpart_dVs + FwdSum - gcdsb - gbdpsp));
(*(here->BSIM4v2DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gcdbb - gbdpb + gIdtotb
- T1 * ddxpart_dVb - dxpart * ggtb));
(*(here->BSIM4v2DdpPtr) -= gdpr - gdtotd);
(*(here->BSIM4v2DdPtr) += gdpr + gdtot);
(*(here->BSIM4v2DdpPtr) -= m * (gdpr - gdtotd));
(*(here->BSIM4v2DdPtr) += m * (gdpr + gdtot));
(*(here->BSIM4v2SPdpPtr) -= here->BSIM4v2gds + gstotd + RevSum - gcsdb - gbspdp
- T1 * dsxpart_dVd - sxpart * ggtd + gIstotd);
(*(here->BSIM4v2SPgpPtr) += gcsgb - Gm - gstotg + gbspg + sxpart * ggtg
+ T1 * dsxpart_dVg - gIstotg);
(*(here->BSIM4v2SPspPtr) += gspr + here->BSIM4v2gds + here->BSIM4v2gbs + T1 * dsxpart_dVs
- gstots + FwdSum + gcssb + gbspsp + sxpart * ggts - gIstots);
(*(here->BSIM4v2SPsPtr) -= gspr + gstot);
(*(here->BSIM4v2SPbpPtr) -= gjbs + gstotb + Gmbs - gcsbb - gbspb - sxpart * ggtb
- T1 * dsxpart_dVb + gIstotb);
(*(here->BSIM4v2SPdpPtr) -= m * (here->BSIM4v2gds + gstotd + RevSum - gcsdb - gbspdp
- T1 * dsxpart_dVd - sxpart * ggtd + gIstotd));
(*(here->BSIM4v2SPgpPtr) += m * (gcsgb - Gm - gstotg + gbspg + sxpart * ggtg
+ T1 * dsxpart_dVg - gIstotg));
(*(here->BSIM4v2SPspPtr) += m * (gspr + here->BSIM4v2gds + here->BSIM4v2gbs + T1 * dsxpart_dVs
- gstots + FwdSum + gcssb + gbspsp + sxpart * ggts - gIstots));
(*(here->BSIM4v2SPsPtr) -= m * (gspr + gstot));
(*(here->BSIM4v2SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gcsbb - gbspb - sxpart * ggtb
- T1 * dsxpart_dVb + gIstotb));
(*(here->BSIM4v2SspPtr) -= gspr - gstots);
(*(here->BSIM4v2SsPtr) += gspr + gstot);
(*(here->BSIM4v2SspPtr) -= m * (gspr - gstots));
(*(here->BSIM4v2SsPtr) += m * (gspr + gstot));
(*(here->BSIM4v2BPdpPtr) += gcbdb - gjbd + gbbdp - gIbtotd);
(*(here->BSIM4v2BPgpPtr) += gcbgb - here->BSIM4v2gbgs - gIbtotg);
(*(here->BSIM4v2BPspPtr) += gcbsb - gjbs + gbbsp - gIbtots);
(*(here->BSIM4v2BPbpPtr) += gjbd + gjbs + gcbbb - here->BSIM4v2gbbs
- gIbtotb);
(*(here->BSIM4v2BPdpPtr) += m * (gcbdb - gjbd + gbbdp - gIbtotd));
(*(here->BSIM4v2BPgpPtr) += m * (gcbgb - here->BSIM4v2gbgs - gIbtotg));
(*(here->BSIM4v2BPspPtr) += m * (gcbsb - gjbs + gbbsp - gIbtots));
(*(here->BSIM4v2BPbpPtr) += m * (gjbd + gjbs + gcbbb - here->BSIM4v2gbbs
- gIbtotb));
ggidld = here->BSIM4v2ggidld;
ggidlg = here->BSIM4v2ggidlg;
@ -4390,65 +4391,65 @@ line900:
ggislb = here->BSIM4v2ggislb;
/* stamp gidl */
(*(here->BSIM4v2DPdpPtr) += ggidld);
(*(here->BSIM4v2DPgpPtr) += ggidlg);
(*(here->BSIM4v2DPspPtr) -= (ggidlg + ggidld + ggidlb));
(*(here->BSIM4v2DPbpPtr) += ggidlb);
(*(here->BSIM4v2BPdpPtr) -= ggidld);
(*(here->BSIM4v2BPgpPtr) -= ggidlg);
(*(here->BSIM4v2BPspPtr) += (ggidlg + ggidld + ggidlb));
(*(here->BSIM4v2BPbpPtr) -= ggidlb);
(*(here->BSIM4v2DPdpPtr) += m * ggidld);
(*(here->BSIM4v2DPgpPtr) += m * ggidlg);
(*(here->BSIM4v2DPspPtr) -= m * (ggidlg + ggidld + ggidlb));
(*(here->BSIM4v2DPbpPtr) += m * ggidlb);
(*(here->BSIM4v2BPdpPtr) -= m * ggidld);
(*(here->BSIM4v2BPgpPtr) -= m * ggidlg);
(*(here->BSIM4v2BPspPtr) += m * (ggidlg + ggidld + ggidlb));
(*(here->BSIM4v2BPbpPtr) -= m * ggidlb);
/* stamp gisl */
(*(here->BSIM4v2SPdpPtr) -= (ggisls + ggislg + ggislb));
(*(here->BSIM4v2SPgpPtr) += ggislg);
(*(here->BSIM4v2SPspPtr) += ggisls);
(*(here->BSIM4v2SPbpPtr) += ggislb);
(*(here->BSIM4v2BPdpPtr) += (ggislg + ggisls + ggislb));
(*(here->BSIM4v2BPgpPtr) -= ggislg);
(*(here->BSIM4v2BPspPtr) -= ggisls);
(*(here->BSIM4v2BPbpPtr) -= ggislb);
(*(here->BSIM4v2SPdpPtr) -= m * (ggisls + ggislg + ggislb));
(*(here->BSIM4v2SPgpPtr) += m * ggislg);
(*(here->BSIM4v2SPspPtr) += m * ggisls);
(*(here->BSIM4v2SPbpPtr) += m * ggislb);
(*(here->BSIM4v2BPdpPtr) += m * (ggislg + ggisls + ggislb));
(*(here->BSIM4v2BPgpPtr) -= m * ggislg);
(*(here->BSIM4v2BPspPtr) -= m * ggisls);
(*(here->BSIM4v2BPbpPtr) -= m * ggislb);
if (here->BSIM4v2rbodyMod)
{ (*(here->BSIM4v2DPdbPtr) += gcdbdb - here->BSIM4v2gbd);
(*(here->BSIM4v2SPsbPtr) -= here->BSIM4v2gbs - gcsbsb);
{ (*(here->BSIM4v2DPdbPtr) += m * (gcdbdb - here->BSIM4v2gbd));
(*(here->BSIM4v2SPsbPtr) -= m * (here->BSIM4v2gbs - gcsbsb));
(*(here->BSIM4v2DBdpPtr) += gcdbdb - here->BSIM4v2gbd);
(*(here->BSIM4v2DBdbPtr) += here->BSIM4v2gbd - gcdbdb
+ here->BSIM4v2grbpd + here->BSIM4v2grbdb);
(*(here->BSIM4v2DBbpPtr) -= here->BSIM4v2grbpd);
(*(here->BSIM4v2DBbPtr) -= here->BSIM4v2grbdb);
(*(here->BSIM4v2DBdpPtr) += m * (gcdbdb - here->BSIM4v2gbd));
(*(here->BSIM4v2DBdbPtr) += m * (here->BSIM4v2gbd - gcdbdb
+ here->BSIM4v2grbpd + here->BSIM4v2grbdb));
(*(here->BSIM4v2DBbpPtr) -= m * here->BSIM4v2grbpd);
(*(here->BSIM4v2DBbPtr) -= m * here->BSIM4v2grbdb);
(*(here->BSIM4v2BPdbPtr) -= here->BSIM4v2grbpd);
(*(here->BSIM4v2BPbPtr) -= here->BSIM4v2grbpb);
(*(here->BSIM4v2BPsbPtr) -= here->BSIM4v2grbps);
(*(here->BSIM4v2BPbpPtr) += here->BSIM4v2grbpd + here->BSIM4v2grbps
+ here->BSIM4v2grbpb);
(*(here->BSIM4v2BPdbPtr) -= m * here->BSIM4v2grbpd);
(*(here->BSIM4v2BPbPtr) -= m * here->BSIM4v2grbpb);
(*(here->BSIM4v2BPsbPtr) -= m * here->BSIM4v2grbps);
(*(here->BSIM4v2BPbpPtr) += m * (here->BSIM4v2grbpd + here->BSIM4v2grbps
+ here->BSIM4v2grbpb));
/* WDLiu: (gcbbb - here->BSIM4v2gbbs) already added to BPbpPtr */
(*(here->BSIM4v2SBspPtr) += gcsbsb - here->BSIM4v2gbs);
(*(here->BSIM4v2SBbpPtr) -= here->BSIM4v2grbps);
(*(here->BSIM4v2SBbPtr) -= here->BSIM4v2grbsb);
(*(here->BSIM4v2SBsbPtr) += here->BSIM4v2gbs - gcsbsb
+ here->BSIM4v2grbps + here->BSIM4v2grbsb);
(*(here->BSIM4v2SBspPtr) += m * (gcsbsb - here->BSIM4v2gbs));
(*(here->BSIM4v2SBbpPtr) -= m * here->BSIM4v2grbps);
(*(here->BSIM4v2SBbPtr) -= m * here->BSIM4v2grbsb);
(*(here->BSIM4v2SBsbPtr) += m * (here->BSIM4v2gbs - gcsbsb
+ here->BSIM4v2grbps + here->BSIM4v2grbsb));
(*(here->BSIM4v2BdbPtr) -= here->BSIM4v2grbdb);
(*(here->BSIM4v2BbpPtr) -= here->BSIM4v2grbpb);
(*(here->BSIM4v2BsbPtr) -= here->BSIM4v2grbsb);
(*(here->BSIM4v2BbPtr) += here->BSIM4v2grbsb + here->BSIM4v2grbdb
+ here->BSIM4v2grbpb);
(*(here->BSIM4v2BdbPtr) -= m * here->BSIM4v2grbdb);
(*(here->BSIM4v2BbpPtr) -= m * here->BSIM4v2grbpb);
(*(here->BSIM4v2BsbPtr) -= m * here->BSIM4v2grbsb);
(*(here->BSIM4v2BbPtr) += m * (here->BSIM4v2grbsb + here->BSIM4v2grbdb
+ here->BSIM4v2grbpb));
}
if (here->BSIM4v2trnqsMod)
{ (*(here->BSIM4v2QqPtr) += gqdef + here->BSIM4v2gtau);
(*(here->BSIM4v2QgpPtr) += ggtg - gcqgb);
(*(here->BSIM4v2QdpPtr) += ggtd - gcqdb);
(*(here->BSIM4v2QspPtr) += ggts - gcqsb);
(*(here->BSIM4v2QbpPtr) += ggtb - gcqbb);
{ (*(here->BSIM4v2QqPtr) += m * (gqdef + here->BSIM4v2gtau));
(*(here->BSIM4v2QgpPtr) += m * (ggtg - gcqgb));
(*(here->BSIM4v2QdpPtr) += m * (ggtd - gcqdb));
(*(here->BSIM4v2QspPtr) += m * (ggts - gcqsb));
(*(here->BSIM4v2QbpPtr) += m * (ggtb - gcqbb));
(*(here->BSIM4v2DPqPtr) += dxpart * here->BSIM4v2gtau);
(*(here->BSIM4v2SPqPtr) += sxpart * here->BSIM4v2gtau);
(*(here->BSIM4v2GPqPtr) -= here->BSIM4v2gtau);
(*(here->BSIM4v2DPqPtr) += m * dxpart * here->BSIM4v2gtau);
(*(here->BSIM4v2SPqPtr) += m * sxpart * here->BSIM4v2gtau);
(*(here->BSIM4v2GPqPtr) -= m * here->BSIM4v2gtau);
}
line1000: ;

37
src/spicelib/devices/bsim4v2/b4v2noi.c
View File

@ -11,8 +11,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "bsim4v2def.h"
#include "cktdefs.h"
#include "iferrmsg.h"
@ -94,6 +92,8 @@ double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13;
double Vds, n, ExpArg, Ssi, Swi;
double tmp, gdpr, gspr, npart_theta, npart_beta, igsquare;
double m;
int error, i;
/* define the names of the noise sources */
@ -181,6 +181,7 @@ int error, i;
}
break;
case N_CALC:
m = here->BSIM4v2m;
switch (mode)
{ case N_DENS:
if (model->BSIM4v2tnoiMod == 0)
@ -226,25 +227,25 @@ int error, i;
NevalSrc(&noizDens[BSIM4v2RDNOIZ],
&lnNdens[BSIM4v2RDNOIZ], ckt, THERMNOISE,
here->BSIM4v2dNodePrime, here->BSIM4v2dNode,
gdpr);
gdpr * m);
NevalSrc(&noizDens[BSIM4v2RSNOIZ],
&lnNdens[BSIM4v2RSNOIZ], ckt, THERMNOISE,
here->BSIM4v2sNodePrime, here->BSIM4v2sNode,
gspr);
gspr * m);
if ((here->BSIM4v2rgateMod == 1) || (here->BSIM4v2rgateMod == 2))
{ NevalSrc(&noizDens[BSIM4v2RGNOIZ],
&lnNdens[BSIM4v2RGNOIZ], ckt, THERMNOISE,
here->BSIM4v2gNodePrime, here->BSIM4v2gNodeExt,
here->BSIM4v2grgeltd);
here->BSIM4v2grgeltd * m);
}
else if (here->BSIM4v2rgateMod == 3)
{ NevalSrc(&noizDens[BSIM4v2RGNOIZ],
&lnNdens[BSIM4v2RGNOIZ], ckt, THERMNOISE,
here->BSIM4v2gNodeMid, here->BSIM4v2gNodeExt,
here->BSIM4v2grgeltd);
here->BSIM4v2grgeltd * m);
}
else
{ noizDens[BSIM4v2RGNOIZ] = 0.0;
@ -257,23 +258,23 @@ int error, i;
{ NevalSrc(&noizDens[BSIM4v2RBPSNOIZ],
&lnNdens[BSIM4v2RBPSNOIZ], ckt, THERMNOISE,
here->BSIM4v2bNodePrime, here->BSIM4v2sbNode,
here->BSIM4v2grbps);
here->BSIM4v2grbps * m);
NevalSrc(&noizDens[BSIM4v2RBPDNOIZ],
&lnNdens[BSIM4v2RBPDNOIZ], ckt, THERMNOISE,
here->BSIM4v2bNodePrime, here->BSIM4v2dbNode,
here->BSIM4v2grbpd);
here->BSIM4v2grbpd * m);
NevalSrc(&noizDens[BSIM4v2RBPBNOIZ],
&lnNdens[BSIM4v2RBPBNOIZ], ckt, THERMNOISE,
here->BSIM4v2bNodePrime, here->BSIM4v2bNode,
here->BSIM4v2grbpb);
here->BSIM4v2grbpb * m);
NevalSrc(&noizDens[BSIM4v2RBSBNOIZ],
&lnNdens[BSIM4v2RBSBNOIZ], ckt, THERMNOISE,
here->BSIM4v2bNode, here->BSIM4v2sbNode,
here->BSIM4v2grbsb);
here->BSIM4v2grbsb * m);
NevalSrc(&noizDens[BSIM4v2RBDBNOIZ],
&lnNdens[BSIM4v2RBDBNOIZ], ckt, THERMNOISE,
here->BSIM4v2bNode, here->BSIM4v2dbNode,
here->BSIM4v2grbdb);
here->BSIM4v2grbdb * m);
}
else
{ noizDens[BSIM4v2RBPSNOIZ] = noizDens[BSIM4v2RBPDNOIZ] = 0.0;
@ -294,7 +295,7 @@ int error, i;
switch(model->BSIM4v2tnoiMod)
{ case 0:
T0 = here->BSIM4v2ueff * fabs(here->BSIM4v2qinv);
T0 = m * here->BSIM4v2ueff * fabs(here->BSIM4v2qinv);
T1 = T0 * tmp + pParam->BSIM4v2leff
* pParam->BSIM4v2leff;
NevalSrc(&noizDens[BSIM4v2IDNOIZ],
@ -304,7 +305,7 @@ int error, i;
(T0 / T1) * model->BSIM4v2ntnoi);
break;
case 1:
T0 = here->BSIM4v2gm + here->BSIM4v2gmbs + here->BSIM4v2gds;
T0 = m * (here->BSIM4v2gm + here->BSIM4v2gmbs + here->BSIM4v2gds);
T0 *= T0;
igsquare = npart_theta * npart_theta * T0 / here->BSIM4v2IdovVds;
T1 = npart_beta * (here->BSIM4v2gm
@ -323,7 +324,7 @@ int error, i;
switch(model->BSIM4v2fnoiMod)
{ case 0:
noizDens[BSIM4v2FLNOIZ] *= model->BSIM4v2kf
noizDens[BSIM4v2FLNOIZ] *= m * model->BSIM4v2kf
* exp(model->BSIM4v2af
* log(MAX(fabs(here->BSIM4v2cd),
N_MINLOG)))
@ -348,7 +349,7 @@ int error, i;
* here->BSIM4v2cd;
T1 = Swi + Ssi;
if (T1 > 0.0)
noizDens[BSIM4v2FLNOIZ] *= (Ssi * Swi) / T1;
noizDens[BSIM4v2FLNOIZ] *= m * (Ssi * Swi) / T1;
else
noizDens[BSIM4v2FLNOIZ] *= 0.0;
break;
@ -361,16 +362,16 @@ int error, i;
NevalSrc(&noizDens[BSIM4v2IGSNOIZ],
&lnNdens[BSIM4v2IGSNOIZ], ckt, SHOTNOISE,
here->BSIM4v2gNodePrime, here->BSIM4v2sNodePrime,
(here->BSIM4v2Igs + here->BSIM4v2Igcs));
m * (here->BSIM4v2Igs + here->BSIM4v2Igcs));
NevalSrc(&noizDens[BSIM4v2IGDNOIZ],
&lnNdens[BSIM4v2IGDNOIZ], ckt, SHOTNOISE,
here->BSIM4v2gNodePrime, here->BSIM4v2dNodePrime,
(here->BSIM4v2Igd + here->BSIM4v2Igcd));
m * (here->BSIM4v2Igd + here->BSIM4v2Igcd));
NevalSrc(&noizDens[BSIM4v2IGBNOIZ],
&lnNdens[BSIM4v2IGBNOIZ], ckt, SHOTNOISE,
here->BSIM4v2gNodePrime, here->BSIM4v2bNodePrime,
here->BSIM4v2Igb);
m * here->BSIM4v2Igb);
noizDens[BSIM4v2TOTNOIZ] = noizDens[BSIM4v2RDNOIZ]

4
src/spicelib/devices/bsim4v2/b4v2par.c
View File

@ -35,6 +35,10 @@ IFvalue *select;
here->BSIM4v2l = value->rValue*scale;
here->BSIM4v2lGiven = TRUE;
break;
case BSIM4v2_M:
here->BSIM4v2m = value->rValue;
here->BSIM4v2mGiven = TRUE;
break;
case BSIM4v2_NF:
here->BSIM4v2nf = value->rValue;
here->BSIM4v2nfGiven = TRUE;

414
src/spicelib/devices/bsim4v2/b4v2pzld.c
View File

@ -11,7 +11,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "complex.h"
#include "sperror.h"
@ -49,6 +48,7 @@ double ScalingFactor = 1.0e-9;
struct bsim4SizeDependParam *pParam;
double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
double m;
for (; model != NULL; model = model->BSIM4v2nextModel)
{ for (here = model->BSIM4v2instances; here!= NULL;
@ -484,6 +484,8 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
* Loading PZ matrix
*/
m = here->BSIM4v2m;
if (!model->BSIM4v2rdsMod)
{ gdpr = here->BSIM4v2drainConductance;
gspr = here->BSIM4v2sourceConductance;
@ -501,165 +503,165 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
geltd = here->BSIM4v2grgeltd;
if (here->BSIM4v2rgateMod == 1)
{ *(here->BSIM4v2GEgePtr) += geltd;
*(here->BSIM4v2GPgePtr) -= geltd;
*(here->BSIM4v2GEgpPtr) -= geltd;
{ *(here->BSIM4v2GEgePtr) += m * geltd;
*(here->BSIM4v2GPgePtr) -= m * geltd;
*(here->BSIM4v2GEgpPtr) -= m * geltd;
*(here->BSIM4v2GPgpPtr ) += xcggb * s->real;
*(here->BSIM4v2GPgpPtr +1) += xcggb * s->imag;
*(here->BSIM4v2GPgpPtr) += geltd - xgtg + gIgtotg;
*(here->BSIM4v2GPdpPtr ) += xcgdb * s->real;
*(here->BSIM4v2GPdpPtr +1) += xcgdb * s->imag;
*(here->BSIM4v2GPdpPtr) -= xgtd - gIgtotd;
*(here->BSIM4v2GPspPtr ) += xcgsb * s->real;
*(here->BSIM4v2GPspPtr +1) += xcgsb * s->imag;
*(here->BSIM4v2GPspPtr) -= xgts - gIgtots;
*(here->BSIM4v2GPbpPtr ) += xcgbb * s->real;
*(here->BSIM4v2GPbpPtr +1) += xcgbb * s->imag;
*(here->BSIM4v2GPbpPtr) -= xgtb - gIgtotb;
*(here->BSIM4v2GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4v2GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4v2GPgpPtr) += m * (geltd - xgtg + gIgtotg);
*(here->BSIM4v2GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4v2GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4v2GPdpPtr) -= m * (xgtd - gIgtotd);
*(here->BSIM4v2GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4v2GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4v2GPspPtr) -= m * (xgts - gIgtots);
*(here->BSIM4v2GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4v2GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4v2GPbpPtr) -= m * (xgtb - gIgtotb);
}
else if (here->BSIM4v2rgateMod == 2)
{ *(here->BSIM4v2GEgePtr) += gcrg;
*(here->BSIM4v2GEgpPtr) += gcrgg;
*(here->BSIM4v2GEdpPtr) += gcrgd;
*(here->BSIM4v2GEspPtr) += gcrgs;
*(here->BSIM4v2GEbpPtr) += gcrgb;
{ *(here->BSIM4v2GEgePtr) += m * gcrg;
*(here->BSIM4v2GEgpPtr) += m * gcrgg;
*(here->BSIM4v2GEdpPtr) += m * gcrgd;
*(here->BSIM4v2GEspPtr) += m * gcrgs;
*(here->BSIM4v2GEbpPtr) += m * gcrgb;
*(here->BSIM4v2GPgePtr) -= gcrg;
*(here->BSIM4v2GPgpPtr ) += xcggb * s->real;
*(here->BSIM4v2GPgpPtr +1) += xcggb * s->imag;
*(here->BSIM4v2GPgpPtr) -= gcrgg + xgtg - gIgtotg;
*(here->BSIM4v2GPdpPtr ) += xcgdb * s->real;
*(here->BSIM4v2GPdpPtr +1) += xcgdb * s->imag;
*(here->BSIM4v2GPdpPtr) -= gcrgd + xgtd - gIgtotd;
*(here->BSIM4v2GPspPtr ) += xcgsb * s->real;
*(here->BSIM4v2GPspPtr +1) += xcgsb * s->imag;
*(here->BSIM4v2GPspPtr) -= gcrgs + xgts - gIgtots;
*(here->BSIM4v2GPbpPtr ) += xcgbb * s->real;
*(here->BSIM4v2GPbpPtr +1) += xcgbb * s->imag;
*(here->BSIM4v2GPbpPtr) -= gcrgb + xgtb - gIgtotb;
*(here->BSIM4v2GPgePtr) -= m * gcrg;
*(here->BSIM4v2GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4v2GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4v2GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg);
*(here->BSIM4v2GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4v2GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4v2GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd);
*(here->BSIM4v2GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4v2GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4v2GPspPtr) -= m * (gcrgs + xgts - gIgtots);
*(here->BSIM4v2GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4v2GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4v2GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb);
}
else if (here->BSIM4v2rgateMod == 3)
{ *(here->BSIM4v2GEgePtr) += geltd;
*(here->BSIM4v2GEgmPtr) -= geltd;
*(here->BSIM4v2GMgePtr) -= geltd;
*(here->BSIM4v2GMgmPtr) += geltd + gcrg;
*(here->BSIM4v2GMgmPtr ) += xcgmgmb * s->real;
*(here->BSIM4v2GMgmPtr +1) += xcgmgmb * s->imag;
{ *(here->BSIM4v2GEgePtr) += m * geltd;
*(here->BSIM4v2GEgmPtr) -= m * geltd;
*(here->BSIM4v2GMgePtr) -= m * geltd;
*(here->BSIM4v2GMgmPtr) += m * (geltd + gcrg);
*(here->BSIM4v2GMgmPtr ) += m * xcgmgmb * s->real;
*(here->BSIM4v2GMgmPtr +1) += m * xcgmgmb * s->imag;
*(here->BSIM4v2GMdpPtr) += gcrgd;
*(here->BSIM4v2GMdpPtr ) += xcgmdb * s->real;
*(here->BSIM4v2GMdpPtr +1) += xcgmdb * s->imag;
*(here->BSIM4v2GMgpPtr) += gcrgg;
*(here->BSIM4v2GMspPtr) += gcrgs;
*(here->BSIM4v2GMspPtr ) += xcgmsb * s->real;
*(here->BSIM4v2GMspPtr +1) += xcgmsb * s->imag;
*(here->BSIM4v2GMbpPtr) += gcrgb;
*(here->BSIM4v2GMbpPtr ) += xcgmbb * s->real;
*(here->BSIM4v2GMbpPtr +1) += xcgmbb * s->imag;
*(here->BSIM4v2GMdpPtr) += m * gcrgd;
*(here->BSIM4v2GMdpPtr ) += m * xcgmdb * s->real;
*(here->BSIM4v2GMdpPtr +1) += m * xcgmdb * s->imag;
*(here->BSIM4v2GMgpPtr) += m * gcrgg;
*(here->BSIM4v2GMspPtr) += m * gcrgs;
*(here->BSIM4v2GMspPtr ) += m * xcgmsb * s->real;
*(here->BSIM4v2GMspPtr +1) += m * xcgmsb * s->imag;
*(here->BSIM4v2GMbpPtr) += m * gcrgb;
*(here->BSIM4v2GMbpPtr ) += m * xcgmbb * s->real;
*(here->BSIM4v2GMbpPtr +1) += m * xcgmbb * s->imag;
*(here->BSIM4v2DPgmPtr ) += xcdgmb * s->real;
*(here->BSIM4v2DPgmPtr +1) += xcdgmb * s->imag;
*(here->BSIM4v2GPgmPtr) -= gcrg;
*(here->BSIM4v2SPgmPtr ) += xcsgmb * s->real;
*(here->BSIM4v2SPgmPtr +1) += xcsgmb * s->imag;
*(here->BSIM4v2BPgmPtr ) += xcbgmb * s->real;
*(here->BSIM4v2BPgmPtr +1) += xcbgmb * s->imag;
*(here->BSIM4v2DPgmPtr ) += m * xcdgmb * s->real;
*(here->BSIM4v2DPgmPtr +1) += m * xcdgmb * s->imag;
*(here->BSIM4v2GPgmPtr) -= m * gcrg;
*(here->BSIM4v2SPgmPtr ) += m * xcsgmb * s->real;
*(here->BSIM4v2SPgmPtr +1) += m * xcsgmb * s->imag;
*(here->BSIM4v2BPgmPtr ) += m * xcbgmb * s->real;
*(here->BSIM4v2BPgmPtr +1) += m * xcbgmb * s->imag;
*(here->BSIM4v2GPgpPtr) -= gcrgg + xgtg - gIgtotg;
*(here->BSIM4v2GPgpPtr ) += xcggb * s->real;
*(here->BSIM4v2GPgpPtr +1) += xcggb * s->imag;
*(here->BSIM4v2GPdpPtr) -= gcrgd + xgtd - gIgtotd;
*(here->BSIM4v2GPdpPtr ) += xcgdb * s->real;
*(here->BSIM4v2GPdpPtr +1) += xcgdb * s->imag;
*(here->BSIM4v2GPspPtr) -= gcrgs + xgts - gIgtots;
*(here->BSIM4v2GPspPtr ) += xcgsb * s->real;
*(here->BSIM4v2GPspPtr +1) += xcgsb * s->imag;
*(here->BSIM4v2GPbpPtr) -= gcrgb + xgtb - gIgtotb;
*(here->BSIM4v2GPbpPtr ) += xcgbb * s->real;
*(here->BSIM4v2GPbpPtr +1) += xcgbb * s->imag;
*(here->BSIM4v2GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg);
*(here->BSIM4v2GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4v2GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4v2GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd);
*(here->BSIM4v2GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4v2GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4v2GPspPtr) -= m * (gcrgs + xgts - gIgtots);
*(here->BSIM4v2GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4v2GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4v2GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb);
*(here->BSIM4v2GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4v2GPbpPtr +1) += m * xcgbb * s->imag;
}
else
{ *(here->BSIM4v2GPdpPtr ) += xcgdb * s->real;
*(here->BSIM4v2GPdpPtr +1) += xcgdb * s->imag;
*(here->BSIM4v2GPdpPtr) -= xgtd - gIgtotd;
*(here->BSIM4v2GPgpPtr ) += xcggb * s->real;
*(here->BSIM4v2GPgpPtr +1) += xcggb * s->imag;
*(here->BSIM4v2GPgpPtr) -= xgtg - gIgtotg;
*(here->BSIM4v2GPspPtr ) += xcgsb * s->real;
*(here->BSIM4v2GPspPtr +1) += xcgsb * s->imag;
*(here->BSIM4v2GPspPtr) -= xgts - gIgtots;
*(here->BSIM4v2GPbpPtr ) += xcgbb * s->real;
*(here->BSIM4v2GPbpPtr +1) += xcgbb * s->imag;
*(here->BSIM4v2GPbpPtr) -= xgtb - gIgtotb;
{ *(here->BSIM4v2GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4v2GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4v2GPdpPtr) -= m * (xgtd - gIgtotd);
*(here->BSIM4v2GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4v2GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4v2GPgpPtr) -= m * (xgtg - gIgtotg);
*(here->BSIM4v2GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4v2GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4v2GPspPtr) -= m * (xgts - gIgtots);
*(here->BSIM4v2GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4v2GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4v2GPbpPtr) -= m * (xgtb - gIgtotb);
}
if (model->BSIM4v2rdsMod)
{ (*(here->BSIM4v2DgpPtr) += gdtotg);
(*(here->BSIM4v2DspPtr) += gdtots);
(*(here->BSIM4v2DbpPtr) += gdtotb);
(*(here->BSIM4v2SdpPtr) += gstotd);
(*(here->BSIM4v2SgpPtr) += gstotg);
(*(here->BSIM4v2SbpPtr) += gstotb);
{ (*(here->BSIM4v2DgpPtr) += m * gdtotg);
(*(here->BSIM4v2DspPtr) += m * gdtots);
(*(here->BSIM4v2DbpPtr) += m * gdtotb);
(*(here->BSIM4v2SdpPtr) += m * gstotd);
(*(here->BSIM4v2SgpPtr) += m * gstotg);
(*(here->BSIM4v2SbpPtr) += m * gstotb);
}
*(here->BSIM4v2DPdpPtr ) += xcddb * s->real;
*(here->BSIM4v2DPdpPtr +1) += xcddb * s->imag;
*(here->BSIM4v2DPdpPtr) += gdpr + gds + here->BSIM4v2gbd
*(here->BSIM4v2DPdpPtr ) += m * xcddb * s->real;
*(here->BSIM4v2DPdpPtr +1) += m * xcddb * s->imag;
*(here->BSIM4v2DPdpPtr) += m * (gdpr + gds + here->BSIM4v2gbd
- gdtotd + RevSum + gbdpdp - gIdtotd
+ dxpart * xgtd + T1 * ddxpart_dVd;
*(here->BSIM4v2DPdPtr) -= gdpr + gdtot;
*(here->BSIM4v2DPgpPtr ) += xcdgb * s->real;
*(here->BSIM4v2DPgpPtr +1) += xcdgb * s->imag;
*(here->BSIM4v2DPgpPtr) += Gm - gdtotg + gbdpg - gIdtotg
+ T1 * ddxpart_dVg + dxpart * xgtg;
*(here->BSIM4v2DPspPtr ) += xcdsb * s->real;
*(here->BSIM4v2DPspPtr +1) += xcdsb * s->imag;
*(here->BSIM4v2DPspPtr) -= gds + FwdSum + gdtots - gbdpsp + gIdtots
- T1 * ddxpart_dVs - dxpart * xgts;
*(here->BSIM4v2DPbpPtr ) += xcdbb * s->real;
*(here->BSIM4v2DPbpPtr +1) += xcdbb * s->imag;
*(here->BSIM4v2DPbpPtr) -= gjbd + gdtotb - Gmbs - gbdpb + gIdtotb
- T1 * ddxpart_dVb - dxpart * xgtb;
+ dxpart * xgtd + T1 * ddxpart_dVd);
*(here->BSIM4v2DPdPtr) -= m * (gdpr + gdtot);
*(here->BSIM4v2DPgpPtr ) += m * xcdgb * s->real;
*(here->BSIM4v2DPgpPtr +1) += m * xcdgb * s->imag;
*(here->BSIM4v2DPgpPtr) += m * (Gm - gdtotg + gbdpg - gIdtotg
+ T1 * ddxpart_dVg + dxpart * xgtg);
*(here->BSIM4v2DPspPtr ) += m * xcdsb * s->real;
*(here->BSIM4v2DPspPtr +1) += m * xcdsb * s->imag;
*(here->BSIM4v2DPspPtr) -= m * (gds + FwdSum + gdtots - gbdpsp + gIdtots
- T1 * ddxpart_dVs - dxpart * xgts);
*(here->BSIM4v2DPbpPtr ) += m * xcdbb * s->real;
*(here->BSIM4v2DPbpPtr +1) += m * xcdbb * s->imag;
*(here->BSIM4v2DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gbdpb + gIdtotb
- T1 * ddxpart_dVb - dxpart * xgtb);
*(here->BSIM4v2DdpPtr) -= gdpr - gdtotd;
*(here->BSIM4v2DdPtr) += gdpr + gdtot;
*(here->BSIM4v2DdpPtr) -= m * (gdpr - gdtotd);
*(here->BSIM4v2DdPtr) += m * (gdpr + gdtot);
*(here->BSIM4v2SPdpPtr ) += xcsdb * s->real;
*(here->BSIM4v2SPdpPtr +1) += xcsdb * s->imag;
*(here->BSIM4v2SPdpPtr) -= gds + gstotd + RevSum - gbspdp + gIstotd
- T1 * dsxpart_dVd - sxpart * xgtd;
*(here->BSIM4v2SPgpPtr ) += xcsgb * s->real;
*(here->BSIM4v2SPgpPtr +1) += xcsgb * s->imag;
*(here->BSIM4v2SPgpPtr) -= Gm + gstotg - gbspg + gIstotg
- T1 * dsxpart_dVg - sxpart * xgtg;
*(here->BSIM4v2SPspPtr ) += xcssb * s->real;
*(here->BSIM4v2SPspPtr +1) += xcssb * s->imag;
*(here->BSIM4v2SPspPtr) += gspr + gds + here->BSIM4v2gbs - gIstots
*(here->BSIM4v2SPdpPtr ) += m * xcsdb * s->real;
*(here->BSIM4v2SPdpPtr +1) += m * xcsdb * s->imag;
*(here->BSIM4v2SPdpPtr) -= m * (gds + gstotd + RevSum - gbspdp + gIstotd
- T1 * dsxpart_dVd - sxpart * xgtd);
*(here->BSIM4v2SPgpPtr ) += m * xcsgb * s->real;
*(here->BSIM4v2SPgpPtr +1) += m * xcsgb * s->imag;
*(here->BSIM4v2SPgpPtr) -= m * (Gm + gstotg - gbspg + gIstotg
- T1 * dsxpart_dVg - sxpart * xgtg);
*(here->BSIM4v2SPspPtr ) += m * xcssb * s->real;
*(here->BSIM4v2SPspPtr +1) += m * xcssb * s->imag;
*(here->BSIM4v2SPspPtr) += m * (gspr + gds + here->BSIM4v2gbs - gIstots
- gstots + FwdSum + gbspsp
+ sxpart * xgts + T1 * dsxpart_dVs;
*(here->BSIM4v2SPsPtr) -= gspr + gstot;
*(here->BSIM4v2SPbpPtr ) += xcsbb * s->real;
*(here->BSIM4v2SPbpPtr +1) += xcsbb * s->imag;
*(here->BSIM4v2SPbpPtr) -= gjbs + gstotb + Gmbs - gbspb + gIstotb
- T1 * dsxpart_dVb - sxpart * xgtb;
+ sxpart * xgts + T1 * dsxpart_dVs);
*(here->BSIM4v2SPsPtr) -= m * (gspr + gstot);
*(here->BSIM4v2SPbpPtr ) += m * xcsbb * s->real;
*(here->BSIM4v2SPbpPtr +1) += m * xcsbb * s->imag;
*(here->BSIM4v2SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gbspb + gIstotb
- T1 * dsxpart_dVb - sxpart * xgtb);
*(here->BSIM4v2SspPtr) -= gspr - gstots;
*(here->BSIM4v2SsPtr) += gspr + gstot;
*(here->BSIM4v2SspPtr) -= m * (gspr - gstots);
*(here->BSIM4v2SsPtr) += m * (gspr + gstot);
*(here->BSIM4v2BPdpPtr ) += xcbdb * s->real;
*(here->BSIM4v2BPdpPtr +1) += xcbdb * s->imag;
*(here->BSIM4v2BPdpPtr) -= gjbd - gbbdp + gIbtotd;
*(here->BSIM4v2BPgpPtr ) += xcbgb * s->real;
*(here->BSIM4v2BPgpPtr +1) += xcbgb * s->imag;
*(here->BSIM4v2BPgpPtr) -= here->BSIM4v2gbgs + gIbtotg;
*(here->BSIM4v2BPspPtr ) += xcbsb * s->real;
*(here->BSIM4v2BPspPtr +1) += xcbsb * s->imag;
*(here->BSIM4v2BPspPtr) -= gjbs - gbbsp + gIbtots;
*(here->BSIM4v2BPbpPtr ) += xcbbb * s->real;
*(here->BSIM4v2BPbpPtr +1) += xcbbb * s->imag;
*(here->BSIM4v2BPbpPtr) += gjbd + gjbs - here->BSIM4v2gbbs
- gIbtotb;
*(here->BSIM4v2BPdpPtr ) += m * xcbdb * s->real;
*(here->BSIM4v2BPdpPtr +1) += m * xcbdb * s->imag;
*(here->BSIM4v2BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd);
*(here->BSIM4v2BPgpPtr ) += m * xcbgb * s->real;
*(here->BSIM4v2BPgpPtr +1) += m * xcbgb * s->imag;
*(here->BSIM4v2BPgpPtr) -= m * (here->BSIM4v2gbgs + gIbtotg);
*(here->BSIM4v2BPspPtr ) += m * xcbsb * s->real;
*(here->BSIM4v2BPspPtr +1) += m * xcbsb * s->imag;
*(here->BSIM4v2BPspPtr) -= m * (gjbs - gbbsp + gIbtots);
*(here->BSIM4v2BPbpPtr ) += m * xcbbb * s->real;
*(here->BSIM4v2BPbpPtr +1) += m * xcbbb * s->imag;
*(here->BSIM4v2BPbpPtr) += m * (gjbd + gjbs - here->BSIM4v2gbbs
- gIbtotb);
ggidld = here->BSIM4v2ggidld;
ggidlg = here->BSIM4v2ggidlg;
ggidlb = here->BSIM4v2ggidlb;
@ -668,87 +670,87 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
ggislb = here->BSIM4v2ggislb;
/* stamp gidl */
(*(here->BSIM4v2DPdpPtr) += ggidld);
(*(here->BSIM4v2DPgpPtr) += ggidlg);
(*(here->BSIM4v2DPspPtr) -= (ggidlg + ggidld) + ggidlb);
(*(here->BSIM4v2DPbpPtr) += ggidlb);
(*(here->BSIM4v2BPdpPtr) -= ggidld);
(*(here->BSIM4v2BPgpPtr) -= ggidlg);
(*(here->BSIM4v2BPspPtr) += (ggidlg + ggidld) + ggidlb);
(*(here->BSIM4v2BPbpPtr) -= ggidlb);
(*(here->BSIM4v2DPdpPtr) += m * ggidld);
(*(here->BSIM4v2DPgpPtr) += m * ggidlg);
(*(here->BSIM4v2DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4v2DPbpPtr) += m * ggidlb);
(*(here->BSIM4v2BPdpPtr) -= m * ggidld);
(*(here->BSIM4v2BPgpPtr) -= m * ggidlg);
(*(here->BSIM4v2BPspPtr) += m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4v2BPbpPtr) -= m * ggidlb);
/* stamp gisl */
(*(here->BSIM4v2SPdpPtr) -= (ggisls + ggislg) + ggislb);
(*(here->BSIM4v2SPgpPtr) += ggislg);
(*(here->BSIM4v2SPspPtr) += ggisls);
(*(here->BSIM4v2SPbpPtr) += ggislb);
(*(here->BSIM4v2BPdpPtr) += (ggislg + ggisls) + ggislb);
(*(here->BSIM4v2BPgpPtr) -= ggislg);
(*(here->BSIM4v2BPspPtr) -= ggisls);
(*(here->BSIM4v2BPbpPtr) -= ggislb);
(*(here->BSIM4v2SPdpPtr) -= m * ((ggisls + ggislg) + ggislb));
(*(here->BSIM4v2SPgpPtr) += m * ggislg);
(*(here->BSIM4v2SPspPtr) += m * ggisls);
(*(here->BSIM4v2SPbpPtr) += m * ggislb);
(*(here->BSIM4v2BPdpPtr) += m * ((ggislg + ggisls) + ggislb));
(*(here->BSIM4v2BPgpPtr) -= m * ggislg);
(*(here->BSIM4v2BPspPtr) -= m * ggisls);
(*(here->BSIM4v2BPbpPtr) -= m * ggislb);
if (here->BSIM4v2rbodyMod)
{ (*(here->BSIM4v2DPdbPtr ) += xcdbdb * s->real);
(*(here->BSIM4v2DPdbPtr +1) += xcdbdb * s->imag);
(*(here->BSIM4v2DPdbPtr) -= here->BSIM4v2gbd);
(*(here->BSIM4v2SPsbPtr ) += xcsbsb * s->real);
(*(here->BSIM4v2SPsbPtr +1) += xcsbsb * s->imag);
(*(here->BSIM4v2SPsbPtr) -= here->BSIM4v2gbs);
{ (*(here->BSIM4v2DPdbPtr ) += m * xcdbdb * s->real);
(*(here->BSIM4v2DPdbPtr +1) += m * xcdbdb * s->imag);
(*(here->BSIM4v2DPdbPtr) -= m * here->BSIM4v2gbd);
(*(here->BSIM4v2SPsbPtr ) += m * xcsbsb * s->real);
(*(here->BSIM4v2SPsbPtr +1) += m * xcsbsb * s->imag);
(*(here->BSIM4v2SPsbPtr) -= m * here->BSIM4v2gbs);
(*(here->BSIM4v2DBdpPtr ) += xcdbdb * s->real);
(*(here->BSIM4v2DBdpPtr +1) += xcdbdb * s->imag);
(*(here->BSIM4v2DBdpPtr) -= here->BSIM4v2gbd);
(*(here->BSIM4v2DBdbPtr ) -= xcdbdb * s->real);
(*(here->BSIM4v2DBdbPtr +1) -= xcdbdb * s->imag);
(*(here->BSIM4v2DBdbPtr) += here->BSIM4v2gbd + here->BSIM4v2grbpd
+ here->BSIM4v2grbdb);
(*(here->BSIM4v2DBbpPtr) -= here->BSIM4v2grbpd);
(*(here->BSIM4v2DBbPtr) -= here->BSIM4v2grbdb);
(*(here->BSIM4v2DBdpPtr ) += m * xcdbdb * s->real);
(*(here->BSIM4v2DBdpPtr +1) += m * xcdbdb * s->imag);
(*(here->BSIM4v2DBdpPtr) -= m * here->BSIM4v2gbd);
(*(here->BSIM4v2DBdbPtr ) -= m * xcdbdb * s->real);
(*(here->BSIM4v2DBdbPtr +1) -= m * xcdbdb * s->imag);
(*(here->BSIM4v2DBdbPtr) += m * (here->BSIM4v2gbd + here->BSIM4v2grbpd
+ here->BSIM4v2grbdb));
(*(here->BSIM4v2DBbpPtr) -= m * here->BSIM4v2grbpd);
(*(here->BSIM4v2DBbPtr) -= m * here->BSIM4v2grbdb);
(*(here->BSIM4v2BPdbPtr) -= here->BSIM4v2grbpd);
(*(here->BSIM4v2BPbPtr) -= here->BSIM4v2grbpb);
(*(here->BSIM4v2BPsbPtr) -= here->BSIM4v2grbps);
(*(here->BSIM4v2BPbpPtr) += here->BSIM4v2grbpd + here->BSIM4v2grbps
+ here->BSIM4v2grbpb);
(*(here->BSIM4v2BPdbPtr) -= m * here->BSIM4v2grbpd);
(*(here->BSIM4v2BPbPtr) -= m * here->BSIM4v2grbpb);
(*(here->BSIM4v2BPsbPtr) -= m * here->BSIM4v2grbps);
(*(here->BSIM4v2BPbpPtr) += m * (here->BSIM4v2grbpd + here->BSIM4v2grbps
+ here->BSIM4v2grbpb));
/* WDL: (-here->BSIM4v2gbbs) already added to BPbpPtr */
(*(here->BSIM4v2SBspPtr ) += xcsbsb * s->real);
(*(here->BSIM4v2SBspPtr +1) += xcsbsb * s->imag);
(*(here->BSIM4v2SBspPtr) -= here->BSIM4v2gbs);
(*(here->BSIM4v2SBbpPtr) -= here->BSIM4v2grbps);
(*(here->BSIM4v2SBbPtr) -= here->BSIM4v2grbsb);
(*(here->BSIM4v2SBsbPtr ) -= xcsbsb * s->real);
(*(here->BSIM4v2SBsbPtr +1) -= xcsbsb * s->imag);
(*(here->BSIM4v2SBsbPtr) += here->BSIM4v2gbs
+ here->BSIM4v2grbps + here->BSIM4v2grbsb);
(*(here->BSIM4v2SBspPtr ) += m * xcsbsb * s->real);
(*(here->BSIM4v2SBspPtr +1) += m * xcsbsb * s->imag);
(*(here->BSIM4v2SBspPtr) -= m * here->BSIM4v2gbs);
(*(here->BSIM4v2SBbpPtr) -= m * here->BSIM4v2grbps);
(*(here->BSIM4v2SBbPtr) -= m * here->BSIM4v2grbsb);
(*(here->BSIM4v2SBsbPtr ) -= m * xcsbsb * s->real);
(*(here->BSIM4v2SBsbPtr +1) -= m * xcsbsb * s->imag);
(*(here->BSIM4v2SBsbPtr) += m * (here->BSIM4v2gbs
+ here->BSIM4v2grbps + here->BSIM4v2grbsb));
(*(here->BSIM4v2BdbPtr) -= here->BSIM4v2grbdb);
(*(here->BSIM4v2BbpPtr) -= here->BSIM4v2grbpb);
(*(here->BSIM4v2BsbPtr) -= here->BSIM4v2grbsb);
(*(here->BSIM4v2BbPtr) += here->BSIM4v2grbsb + here->BSIM4v2grbdb
+ here->BSIM4v2grbpb);
(*(here->BSIM4v2BdbPtr) -= m * here->BSIM4v2grbdb);
(*(here->BSIM4v2BbpPtr) -= m * here->BSIM4v2grbpb);
(*(here->BSIM4v2BsbPtr) -= m * here->BSIM4v2grbsb);
(*(here->BSIM4v2BbPtr) += m * (here->BSIM4v2grbsb + here->BSIM4v2grbdb
+ here->BSIM4v2grbpb));
}
if (here->BSIM4v2acnqsMod)
{ *(here->BSIM4v2QqPtr ) += s->real * ScalingFactor;
*(here->BSIM4v2QqPtr +1) += s->imag * ScalingFactor;
*(here->BSIM4v2QgpPtr ) -= xcqgb * s->real;
*(here->BSIM4v2QgpPtr +1) -= xcqgb * s->imag;
*(here->BSIM4v2QdpPtr ) -= xcqdb * s->real;
*(here->BSIM4v2QdpPtr +1) -= xcqdb * s->imag;
*(here->BSIM4v2QbpPtr ) -= xcqbb * s->real;
*(here->BSIM4v2QbpPtr +1) -= xcqbb * s->imag;
*(here->BSIM4v2QspPtr ) -= xcqsb * s->real;
*(here->BSIM4v2QspPtr +1) -= xcqsb * s->imag;
{ *(here->BSIM4v2QqPtr ) += m * s->real * ScalingFactor;
*(here->BSIM4v2QqPtr +1) += m * s->imag * ScalingFactor;
*(here->BSIM4v2QgpPtr ) -= m * xcqgb * s->real;
*(here->BSIM4v2QgpPtr +1) -= m * xcqgb * s->imag;
*(here->BSIM4v2QdpPtr ) -= m * xcqdb * s->real;
*(here->BSIM4v2QdpPtr +1) -= m * xcqdb * s->imag;
*(here->BSIM4v2QbpPtr ) -= m * xcqbb * s->real;
*(here->BSIM4v2QbpPtr +1) -= m * xcqbb * s->imag;
*(here->BSIM4v2QspPtr ) -= m * xcqsb * s->real;
*(here->BSIM4v2QspPtr +1) -= m * xcqsb * s->imag;
*(here->BSIM4v2GPqPtr) -= here->BSIM4v2gtau;
*(here->BSIM4v2DPqPtr) += dxpart * here->BSIM4v2gtau;
*(here->BSIM4v2SPqPtr) += sxpart * here->BSIM4v2gtau;
*(here->BSIM4v2GPqPtr) -= m * here->BSIM4v2gtau;
*(here->BSIM4v2DPqPtr) += m * dxpart * here->BSIM4v2gtau;
*(here->BSIM4v2SPqPtr) += m * sxpart * here->BSIM4v2gtau;
*(here->BSIM4v2QqPtr) += here->BSIM4v2gtau;
*(here->BSIM4v2QgpPtr) += xgtg;
*(here->BSIM4v2QdpPtr) += xgtd;
*(here->BSIM4v2QbpPtr) += xgtb;
*(here->BSIM4v2QspPtr) += xgts;
*(here->BSIM4v2QqPtr) += m * here->BSIM4v2gtau;
*(here->BSIM4v2QgpPtr) += m * xgtg;
*(here->BSIM4v2QdpPtr) += m * xgtd;
*(here->BSIM4v2QbpPtr) += m * xgtb;
*(here->BSIM4v2QspPtr) += m * xgts;
}
}
}

2
src/spicelib/devices/bsim4v2/b4v2set.c
View File

@ -1347,6 +1347,8 @@ JOB *job;
here->BSIM4v2l = 5.0e-6;
if (!here->BSIM4v2wGiven)
here->BSIM4v2w = 5.0e-6;
if (!here->BSIM4v2mGiven)
here->BSIM4v2m = 1.0;
if (!here->BSIM4v2nfGiven)
here->BSIM4v2nf = 1.0;
if (!here->BSIM4v2minGiven)

3
src/spicelib/devices/bsim4v2/bsim4v2def.h
View File

@ -89,6 +89,7 @@ typedef struct sBSIM4v2instance
double BSIM4v2icVGS;
double BSIM4v2icVBS;
double BSIM4v2nf;
double BSIM4v2m;
int BSIM4v2off;
int BSIM4v2mode;
int BSIM4v2trnqsMod;
@ -221,6 +222,7 @@ typedef struct sBSIM4v2instance
unsigned BSIM4v2lGiven :1;
unsigned BSIM4v2wGiven :1;
unsigned BSIM4v2nfGiven :1;
unsigned BSIM4v2mGiven :1;
unsigned BSIM4v2minGiven :1;
unsigned BSIM4v2drainAreaGiven :1;
unsigned BSIM4v2sourceAreaGiven :1;
@ -1929,6 +1931,7 @@ typedef struct sBSIM4v2model
#define BSIM4v2_RBPB 25
#define BSIM4v2_RBPS 26
#define BSIM4v2_RBPD 27
#define BSIM4v2_M 28
/* Global parameters */

2
src/spicelib/devices/bsim4v3/b4v3.c
View File

@ -13,7 +13,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include "devdefs.h"
#include "bsim4v3def.h"
#include "suffix.h"
@ -21,6 +20,7 @@
IFparm BSIM4v3pTable[] = { /* parameters */
IOP( "l", BSIM4v3_L, IF_REAL , "Length"),
IOP( "w", BSIM4v3_W, IF_REAL , "Width"),
IOP( "m", BSIM4v3_M, IF_REAL , "Separate Parallel multiplier"),
IOP( "nf", BSIM4v3_NF, IF_REAL , "Number of fingers"),
IOP( "sa", BSIM4v3_SA, IF_REAL , "distance between OD edge to poly of one side "),
IOP( "sb", BSIM4v3_SB, IF_REAL , "distance between OD edge to poly of the other side"),

287
src/spicelib/devices/bsim4v3/b4v3acld.c
View File

@ -10,7 +10,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "bsim4v3def.h"
#include "sperror.h"
@ -52,6 +51,8 @@ double FwdSumi, RevSumi, Gmi, Gmbsi, Gdsi;
struct bsim4v3SizeDependParam *pParam;
double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
double m;
omega = ckt->CKTomega;
for (; model != NULL; model = model->BSIM4v3nextModel)
{ for (here = model->BSIM4v3instances; here!= NULL;
@ -449,6 +450,8 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
* Loading AC matrix
*/
m = here->BSIM4v3m;
if (!model->BSIM4v3rdsMod)
{ gdpr = here->BSIM4v3drainConductance;
gspr = here->BSIM4v3sourceConductance;
@ -466,122 +469,122 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
geltd = here->BSIM4v3grgeltd;
if (here->BSIM4v3rgateMod == 1)
{ *(here->BSIM4v3GEgePtr) += geltd;
*(here->BSIM4v3GPgePtr) -= geltd;
*(here->BSIM4v3GEgpPtr) -= geltd;
{ *(here->BSIM4v3GEgePtr) += m * geltd;
*(here->BSIM4v3GPgePtr) -= m * geltd;
*(here->BSIM4v3GEgpPtr) -= m * geltd;
*(here->BSIM4v3GPgpPtr +1) += xcggbr;
*(here->BSIM4v3GPgpPtr) += geltd + xcggbi + gIgtotg;
*(here->BSIM4v3GPdpPtr +1) += xcgdbr;
*(here->BSIM4v3GPdpPtr) += xcgdbi + gIgtotd;
*(here->BSIM4v3GPspPtr +1) += xcgsbr;
*(here->BSIM4v3GPspPtr) += xcgsbi + gIgtots;
*(here->BSIM4v3GPbpPtr +1) += xcgbbr;
*(here->BSIM4v3GPbpPtr) += xcgbbi + gIgtotb;
*(here->BSIM4v3GPgpPtr +1) += m * xcggbr;
*(here->BSIM4v3GPgpPtr) += m * (geltd + xcggbi + gIgtotg);
*(here->BSIM4v3GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4v3GPdpPtr) += m * (xcgdbi + gIgtotd);
*(here->BSIM4v3GPspPtr +1) += m * xcgsbr;
*(here->BSIM4v3GPspPtr) += m * (xcgsbi + gIgtots);
*(here->BSIM4v3GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4v3GPbpPtr) += m * (xcgbbi + gIgtotb);
} /* WDLiu: gcrg already subtracted from all gcrgg below */
else if (here->BSIM4v3rgateMod == 2)
{ *(here->BSIM4v3GEgePtr) += gcrg;
*(here->BSIM4v3GEgpPtr) += gcrgg;
*(here->BSIM4v3GEdpPtr) += gcrgd;
*(here->BSIM4v3GEspPtr) += gcrgs;
*(here->BSIM4v3GEbpPtr) += gcrgb;
{ *(here->BSIM4v3GEgePtr) += m * gcrg;
*(here->BSIM4v3GEgpPtr) += m * gcrgg;
*(here->BSIM4v3GEdpPtr) += m * gcrgd;
*(here->BSIM4v3GEspPtr) += m * gcrgs;
*(here->BSIM4v3GEbpPtr) += m * gcrgb;
*(here->BSIM4v3GPgePtr) -= gcrg;
*(here->BSIM4v3GPgpPtr +1) += xcggbr;
*(here->BSIM4v3GPgpPtr) -= gcrgg - xcggbi - gIgtotg;
*(here->BSIM4v3GPdpPtr +1) += xcgdbr;
*(here->BSIM4v3GPdpPtr) -= gcrgd - xcgdbi - gIgtotd;
*(here->BSIM4v3GPspPtr +1) += xcgsbr;
*(here->BSIM4v3GPspPtr) -= gcrgs - xcgsbi - gIgtots;
*(here->BSIM4v3GPbpPtr +1) += xcgbbr;
*(here->BSIM4v3GPbpPtr) -= gcrgb - xcgbbi - gIgtotb;
*(here->BSIM4v3GPgePtr) -= m * gcrg;
*(here->BSIM4v3GPgpPtr +1) += m * xcggbr;
*(here->BSIM4v3GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg);
*(here->BSIM4v3GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4v3GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd);
*(here->BSIM4v3GPspPtr +1) += m * xcgsbr;
*(here->BSIM4v3GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots);
*(here->BSIM4v3GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4v3GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb);
}
else if (here->BSIM4v3rgateMod == 3)
{ *(here->BSIM4v3GEgePtr) += geltd;
*(here->BSIM4v3GEgmPtr) -= geltd;
*(here->BSIM4v3GMgePtr) -= geltd;
*(here->BSIM4v3GMgmPtr) += geltd + gcrg;
*(here->BSIM4v3GMgmPtr +1) += xcgmgmb;
{ *(here->BSIM4v3GEgePtr) += m * geltd;
*(here->BSIM4v3GEgmPtr) -= m * geltd;
*(here->BSIM4v3GMgePtr) -= m * geltd;
*(here->BSIM4v3GMgmPtr) += m * (geltd + gcrg);
*(here->BSIM4v3GMgmPtr +1) += m * xcgmgmb;
*(here->BSIM4v3GMdpPtr) += gcrgd;
*(here->BSIM4v3GMdpPtr +1) += xcgmdb;
*(here->BSIM4v3GMgpPtr) += gcrgg;
*(here->BSIM4v3GMspPtr) += gcrgs;
*(here->BSIM4v3GMspPtr +1) += xcgmsb;
*(here->BSIM4v3GMbpPtr) += gcrgb;
*(here->BSIM4v3GMbpPtr +1) += xcgmbb;
*(here->BSIM4v3GMdpPtr) += m * gcrgd;
*(here->BSIM4v3GMdpPtr +1) += m * xcgmdb;
*(here->BSIM4v3GMgpPtr) += m * gcrgg;
*(here->BSIM4v3GMspPtr) += m * gcrgs;
*(here->BSIM4v3GMspPtr +1) += m * xcgmsb;
*(here->BSIM4v3GMbpPtr) += m * gcrgb;
*(here->BSIM4v3GMbpPtr +1) += m * xcgmbb;
*(here->BSIM4v3DPgmPtr +1) += xcdgmb;
*(here->BSIM4v3GPgmPtr) -= gcrg;
*(here->BSIM4v3SPgmPtr +1) += xcsgmb;
*(here->BSIM4v3BPgmPtr +1) += xcbgmb;
*(here->BSIM4v3DPgmPtr +1) += m * xcdgmb;
*(here->BSIM4v3GPgmPtr) -= m * gcrg;
*(here->BSIM4v3SPgmPtr +1) += m * xcsgmb;
*(here->BSIM4v3BPgmPtr +1) += m * xcbgmb;
*(here->BSIM4v3GPgpPtr) -= gcrgg - xcggbi - gIgtotg;
*(here->BSIM4v3GPgpPtr +1) += xcggbr;
*(here->BSIM4v3GPdpPtr) -= gcrgd - xcgdbi - gIgtotd;
*(here->BSIM4v3GPdpPtr +1) += xcgdbr;
*(here->BSIM4v3GPspPtr) -= gcrgs - xcgsbi - gIgtots;
*(here->BSIM4v3GPspPtr +1) += xcgsbr;
*(here->BSIM4v3GPbpPtr) -= gcrgb - xcgbbi - gIgtotb;
*(here->BSIM4v3GPbpPtr +1) += xcgbbr;
*(here->BSIM4v3GPgpPtr) -= m * (gcrgg - xcggbi - gIgtotg);
*(here->BSIM4v3GPgpPtr +1) += m * xcggbr;
*(here->BSIM4v3GPdpPtr) -= m * (gcrgd - xcgdbi - gIgtotd);
*(here->BSIM4v3GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4v3GPspPtr) -= m * (gcrgs - xcgsbi - gIgtots);
*(here->BSIM4v3GPspPtr +1) += m * xcgsbr;
*(here->BSIM4v3GPbpPtr) -= m * (gcrgb - xcgbbi - gIgtotb);
*(here->BSIM4v3GPbpPtr +1) += m * xcgbbr;
}
else
{ *(here->BSIM4v3GPgpPtr +1) += xcggbr;
*(here->BSIM4v3GPgpPtr) += xcggbi + gIgtotg;
*(here->BSIM4v3GPdpPtr +1) += xcgdbr;
*(here->BSIM4v3GPdpPtr) += xcgdbi + gIgtotd;
*(here->BSIM4v3GPspPtr +1) += xcgsbr;
*(here->BSIM4v3GPspPtr) += xcgsbi + gIgtots;
*(here->BSIM4v3GPbpPtr +1) += xcgbbr;
*(here->BSIM4v3GPbpPtr) += xcgbbi + gIgtotb;
{ *(here->BSIM4v3GPgpPtr +1) += m * xcggbr;
*(here->BSIM4v3GPgpPtr) += m * (xcggbi + gIgtotg);
*(here->BSIM4v3GPdpPtr +1) += m * xcgdbr;
*(here->BSIM4v3GPdpPtr) += m * (xcgdbi + gIgtotd);
*(here->BSIM4v3GPspPtr +1) += m * xcgsbr;
*(here->BSIM4v3GPspPtr) += m * (xcgsbi + gIgtots);
*(here->BSIM4v3GPbpPtr +1) += m * xcgbbr;
*(here->BSIM4v3GPbpPtr) += m * (xcgbbi + gIgtotb);
}
if (model->BSIM4v3rdsMod)
{ (*(here->BSIM4v3DgpPtr) += gdtotg);
(*(here->BSIM4v3DspPtr) += gdtots);
(*(here->BSIM4v3DbpPtr) += gdtotb);
(*(here->BSIM4v3SdpPtr) += gstotd);
(*(here->BSIM4v3SgpPtr) += gstotg);
(*(here->BSIM4v3SbpPtr) += gstotb);
{ (*(here->BSIM4v3DgpPtr) += m * gdtotg);
(*(here->BSIM4v3DspPtr) += m * gdtots);
(*(here->BSIM4v3DbpPtr) += m * gdtotb);
(*(here->BSIM4v3SdpPtr) += m * gstotd);
(*(here->BSIM4v3SgpPtr) += m * gstotg);
(*(here->BSIM4v3SbpPtr) += m * gstotb);
}
*(here->BSIM4v3DPdpPtr +1) += xcddbr + gdsi + RevSumi;
*(here->BSIM4v3DPdpPtr) += gdpr + xcddbi + gdsr + here->BSIM4v3gbd
- gdtotd + RevSumr + gbdpdp - gIdtotd;
*(here->BSIM4v3DPdPtr) -= gdpr + gdtot;
*(here->BSIM4v3DPgpPtr +1) += xcdgbr + Gmi;
*(here->BSIM4v3DPgpPtr) += Gmr + xcdgbi - gdtotg + gbdpg - gIdtotg;
*(here->BSIM4v3DPspPtr +1) += xcdsbr - gdsi - FwdSumi;
*(here->BSIM4v3DPspPtr) -= gdsr - xcdsbi + FwdSumr + gdtots - gbdpsp + gIdtots;
*(here->BSIM4v3DPbpPtr +1) += xcdbbr + Gmbsi;
*(here->BSIM4v3DPbpPtr) -= gjbd + gdtotb - xcdbbi - Gmbsr - gbdpb + gIdtotb;
*(here->BSIM4v3DPdpPtr +1) += m * (xcddbr + gdsi + RevSumi);
*(here->BSIM4v3DPdpPtr) += m * (gdpr + xcddbi + gdsr + here->BSIM4v3gbd
- gdtotd + RevSumr + gbdpdp - gIdtotd);
*(here->BSIM4v3DPdPtr) -= m * (gdpr + gdtot);
*(here->BSIM4v3DPgpPtr +1) += m * (xcdgbr + Gmi);
*(here->BSIM4v3DPgpPtr) += m * (Gmr + xcdgbi - gdtotg + gbdpg - gIdtotg);
*(here->BSIM4v3DPspPtr +1) += m * (xcdsbr - gdsi - FwdSumi);
*(here->BSIM4v3DPspPtr) -= m * (gdsr - xcdsbi + FwdSumr + gdtots - gbdpsp + gIdtots);
*(here->BSIM4v3DPbpPtr +1) += m * (xcdbbr + Gmbsi);
*(here->BSIM4v3DPbpPtr) -= m * (gjbd + gdtotb - xcdbbi - Gmbsr - gbdpb + gIdtotb);
*(here->BSIM4v3DdpPtr) -= gdpr - gdtotd;
*(here->BSIM4v3DdPtr) += gdpr + gdtot;
*(here->BSIM4v3DdpPtr) -= m * (gdpr - gdtotd);
*(here->BSIM4v3DdPtr) += m * (gdpr + gdtot);
*(here->BSIM4v3SPdpPtr +1) += xcsdbr - gdsi - RevSumi;
*(here->BSIM4v3SPdpPtr) -= gdsr - xcsdbi + gstotd + RevSumr - gbspdp + gIstotd;
*(here->BSIM4v3SPgpPtr +1) += xcsgbr - Gmi;
*(here->BSIM4v3SPgpPtr) -= Gmr - xcsgbi + gstotg - gbspg + gIstotg;
*(here->BSIM4v3SPspPtr +1) += xcssbr + gdsi + FwdSumi;
*(here->BSIM4v3SPspPtr) += gspr + xcssbi + gdsr + here->BSIM4v3gbs
- gstots + FwdSumr + gbspsp - gIstots;
*(here->BSIM4v3SPsPtr) -= gspr + gstot;
*(here->BSIM4v3SPbpPtr +1) += xcsbbr - Gmbsi;
*(here->BSIM4v3SPbpPtr) -= gjbs + gstotb - xcsbbi + Gmbsr - gbspb + gIstotb;
*(here->BSIM4v3SPdpPtr +1) += m * (xcsdbr - gdsi - RevSumi);
*(here->BSIM4v3SPdpPtr) -= m * (gdsr - xcsdbi + gstotd + RevSumr - gbspdp + gIstotd);
*(here->BSIM4v3SPgpPtr +1) += m * (xcsgbr - Gmi);
*(here->BSIM4v3SPgpPtr) -= m * (Gmr - xcsgbi + gstotg - gbspg + gIstotg);
*(here->BSIM4v3SPspPtr +1) += m * (xcssbr + gdsi + FwdSumi);
*(here->BSIM4v3SPspPtr) += m * (gspr + xcssbi + gdsr + here->BSIM4v3gbs
- gstots + FwdSumr + gbspsp - gIstots);
*(here->BSIM4v3SPsPtr) -= m * (gspr + gstot);
*(here->BSIM4v3SPbpPtr +1) += m * (xcsbbr - Gmbsi);
*(here->BSIM4v3SPbpPtr) -= m * (gjbs + gstotb - xcsbbi + Gmbsr - gbspb + gIstotb);
*(here->BSIM4v3SspPtr) -= gspr - gstots;
*(here->BSIM4v3SsPtr) += gspr + gstot;
*(here->BSIM4v3SspPtr) -= m * (gspr - gstots);
*(here->BSIM4v3SsPtr) += m * (gspr + gstot);
*(here->BSIM4v3BPdpPtr +1) += xcbdb;
*(here->BSIM4v3BPdpPtr) -= gjbd - gbbdp + gIbtotd;
*(here->BSIM4v3BPgpPtr +1) += xcbgb;
*(here->BSIM4v3BPgpPtr) -= here->BSIM4v3gbgs + gIbtotg;
*(here->BSIM4v3BPspPtr +1) += xcbsb;
*(here->BSIM4v3BPspPtr) -= gjbs - gbbsp + gIbtots;
*(here->BSIM4v3BPbpPtr +1) += xcbbb;
*(here->BSIM4v3BPbpPtr) += gjbd + gjbs - here->BSIM4v3gbbs
- gIbtotb;
*(here->BSIM4v3BPdpPtr +1) += m * xcbdb;
*(here->BSIM4v3BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd);
*(here->BSIM4v3BPgpPtr +1) += m * xcbgb;
*(here->BSIM4v3BPgpPtr) -= m * (here->BSIM4v3gbgs + gIbtotg);
*(here->BSIM4v3BPspPtr +1) += m * xcbsb;
*(here->BSIM4v3BPspPtr) -= m * (gjbs - gbbsp + gIbtots);
*(here->BSIM4v3BPbpPtr +1) += m * xcbbb;
*(here->BSIM4v3BPbpPtr) += m * (gjbd + gjbs - here->BSIM4v3gbbs
- gIbtotb);
ggidld = here->BSIM4v3ggidld;
ggidlg = here->BSIM4v3ggidlg;
ggidlb = here->BSIM4v3ggidlb;
@ -590,58 +593,58 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
ggislb = here->BSIM4v3ggislb;
/* stamp gidl */
(*(here->BSIM4v3DPdpPtr) += ggidld);
(*(here->BSIM4v3DPgpPtr) += ggidlg);
(*(here->BSIM4v3DPspPtr) -= (ggidlg + ggidld) + ggidlb);
(*(here->BSIM4v3DPbpPtr) += ggidlb);
(*(here->BSIM4v3BPdpPtr) -= ggidld);
(*(here->BSIM4v3BPgpPtr) -= ggidlg);
(*(here->BSIM4v3BPspPtr) += (ggidlg + ggidld) + ggidlb);
(*(here->BSIM4v3BPbpPtr) -= ggidlb);
(*(here->BSIM4v3DPdpPtr) += m * ggidld);
(*(here->BSIM4v3DPgpPtr) += m * ggidlg);
(*(here->BSIM4v3DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4v3DPbpPtr) += m * ggidlb);
(*(here->BSIM4v3BPdpPtr) -= m * ggidld);
(*(here->BSIM4v3BPgpPtr) -= m * ggidlg);
(*(here->BSIM4v3BPspPtr) += m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4v3BPbpPtr) -= m * ggidlb);
/* stamp gisl */
(*(here->BSIM4v3SPdpPtr) -= (ggisls + ggislg) + ggislb);
(*(here->BSIM4v3SPgpPtr) += ggislg);
(*(here->BSIM4v3SPspPtr) += ggisls);
(*(here->BSIM4v3SPbpPtr) += ggislb);
(*(here->BSIM4v3BPdpPtr) += (ggislg + ggisls) + ggislb);
(*(here->BSIM4v3BPgpPtr) -= ggislg);
(*(here->BSIM4v3BPspPtr) -= ggisls);
(*(here->BSIM4v3BPbpPtr) -= ggislb);
(*(here->BSIM4v3SPdpPtr) -= m * ((ggisls + ggislg) + ggislb));
(*(here->BSIM4v3SPgpPtr) += m * ggislg);
(*(here->BSIM4v3SPspPtr) += m * ggisls);
(*(here->BSIM4v3SPbpPtr) += m * ggislb);
(*(here->BSIM4v3BPdpPtr) += m * ((ggislg + ggisls) + ggislb));
(*(here->BSIM4v3BPgpPtr) -= m * ggislg);
(*(here->BSIM4v3BPspPtr) -= m * ggisls);
(*(here->BSIM4v3BPbpPtr) -= m * ggislb);
if (here->BSIM4v3rbodyMod)
{ (*(here->BSIM4v3DPdbPtr +1) += xcdbdb);
(*(here->BSIM4v3DPdbPtr) -= here->BSIM4v3gbd);
(*(here->BSIM4v3SPsbPtr +1) += xcsbsb);
(*(here->BSIM4v3SPsbPtr) -= here->BSIM4v3gbs);
{ (*(here->BSIM4v3DPdbPtr +1) += m * xcdbdb);
(*(here->BSIM4v3DPdbPtr) -= m * here->BSIM4v3gbd);
(*(here->BSIM4v3SPsbPtr +1) += m * xcsbsb);
(*(here->BSIM4v3SPsbPtr) -= m * here->BSIM4v3gbs);
(*(here->BSIM4v3DBdpPtr +1) += xcdbdb);
(*(here->BSIM4v3DBdpPtr) -= here->BSIM4v3gbd);
(*(here->BSIM4v3DBdbPtr +1) -= xcdbdb);
(*(here->BSIM4v3DBdbPtr) += here->BSIM4v3gbd + here->BSIM4v3grbpd
+ here->BSIM4v3grbdb);
(*(here->BSIM4v3DBbpPtr) -= here->BSIM4v3grbpd);
(*(here->BSIM4v3DBbPtr) -= here->BSIM4v3grbdb);
(*(here->BSIM4v3DBdpPtr +1) += m * xcdbdb);
(*(here->BSIM4v3DBdpPtr) -= m * here->BSIM4v3gbd);
(*(here->BSIM4v3DBdbPtr +1) -= m * xcdbdb);
(*(here->BSIM4v3DBdbPtr) += m * (here->BSIM4v3gbd + here->BSIM4v3grbpd
+ here->BSIM4v3grbdb));
(*(here->BSIM4v3DBbpPtr) -= m * here->BSIM4v3grbpd);
(*(here->BSIM4v3DBbPtr) -= m * here->BSIM4v3grbdb);
(*(here->BSIM4v3BPdbPtr) -= here->BSIM4v3grbpd);
(*(here->BSIM4v3BPbPtr) -= here->BSIM4v3grbpb);
(*(here->BSIM4v3BPsbPtr) -= here->BSIM4v3grbps);
(*(here->BSIM4v3BPbpPtr) += here->BSIM4v3grbpd + here->BSIM4v3grbps
+ here->BSIM4v3grbpb);
(*(here->BSIM4v3BPdbPtr) -= m * here->BSIM4v3grbpd);
(*(here->BSIM4v3BPbPtr) -= m * here->BSIM4v3grbpb);
(*(here->BSIM4v3BPsbPtr) -= m * here->BSIM4v3grbps);
(*(here->BSIM4v3BPbpPtr) += m * (here->BSIM4v3grbpd + here->BSIM4v3grbps
+ here->BSIM4v3grbpb));
/* WDLiu: (-here->BSIM4v3gbbs) already added to BPbpPtr */
(*(here->BSIM4v3SBspPtr +1) += xcsbsb);
(*(here->BSIM4v3SBspPtr) -= here->BSIM4v3gbs);
(*(here->BSIM4v3SBbpPtr) -= here->BSIM4v3grbps);
(*(here->BSIM4v3SBbPtr) -= here->BSIM4v3grbsb);
(*(here->BSIM4v3SBsbPtr +1) -= xcsbsb);
(*(here->BSIM4v3SBsbPtr) += here->BSIM4v3gbs
+ here->BSIM4v3grbps + here->BSIM4v3grbsb);
(*(here->BSIM4v3SBspPtr +1) += m * xcsbsb);
(*(here->BSIM4v3SBspPtr) -= m * here->BSIM4v3gbs);
(*(here->BSIM4v3SBbpPtr) -= m * here->BSIM4v3grbps);
(*(here->BSIM4v3SBbPtr) -= m * here->BSIM4v3grbsb);
(*(here->BSIM4v3SBsbPtr +1) -= m * xcsbsb);
(*(here->BSIM4v3SBsbPtr) += m * (here->BSIM4v3gbs
+ here->BSIM4v3grbps + here->BSIM4v3grbsb));
(*(here->BSIM4v3BdbPtr) -= here->BSIM4v3grbdb);
(*(here->BSIM4v3BbpPtr) -= here->BSIM4v3grbpb);
(*(here->BSIM4v3BsbPtr) -= here->BSIM4v3grbsb);
(*(here->BSIM4v3BbPtr) += here->BSIM4v3grbsb + here->BSIM4v3grbdb
+ here->BSIM4v3grbpb);
(*(here->BSIM4v3BdbPtr) -= m * here->BSIM4v3grbdb);
(*(here->BSIM4v3BbpPtr) -= m * here->BSIM4v3grbpb);
(*(here->BSIM4v3BsbPtr) -= m * here->BSIM4v3grbsb);
(*(here->BSIM4v3BbPtr) += m * (here->BSIM4v3grbsb + here->BSIM4v3grbdb
+ here->BSIM4v3grbpb));
}
@ -652,7 +655,7 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
* The charge node is isolated from the instance.
*/
if (here->BSIM4v3trnqsMod)
{ (*(here->BSIM4v3QqPtr) += 1.0);
{ (*(here->BSIM4v3QqPtr) += m * 1.0);
(*(here->BSIM4v3QgpPtr) += 0.0);
(*(here->BSIM4v3QdpPtr) += 0.0);
(*(here->BSIM4v3QspPtr) += 0.0);

3
src/spicelib/devices/bsim4v3/b4v3ask.c
View File

@ -37,6 +37,9 @@ BSIM4v3instance *here = (BSIM4v3instance*)inst;
case BSIM4v3_W:
value->rValue = here->BSIM4v3w;
return(OK);
case BSIM4v3_M:
value->rValue = here->BSIM4v3m;
return(OK);
case BSIM4v3_NF:
value->rValue = here->BSIM4v3nf;
return(OK);

263
src/spicelib/devices/bsim4v3/b4v3ld.c
View File

@ -13,8 +13,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "cktdefs.h"
#include "bsim4v3def.h"
#include "trandefs.h"
@ -176,6 +174,8 @@ double vs, Fsevl, dvs_dVg, dvs_dVd, dvs_dVb, dFsevl_dVg, dFsevl_dVd, dFsevl_dVb;
struct bsim4v3SizeDependParam *pParam;
int ByPass, ChargeComputationNeeded, error, Check, Check1, Check2;
double m;
ScalingFactor = 1.0e-9;
ChargeComputationNeeded =
((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) ||
@ -4356,37 +4356,38 @@ line900:
* Loading RHS
*/
m = here->BSIM4v3m;
(*(ckt->CKTrhs + here->BSIM4v3dNodePrime) += (ceqjd - ceqbd + ceqgdtot
(*(ckt->CKTrhs + here->BSIM4v3dNodePrime) += m * (ceqjd - ceqbd + ceqgdtot
- ceqdrn - ceqqd + Idtoteq));
(*(ckt->CKTrhs + here->BSIM4v3gNodePrime) -= ceqqg - ceqgcrg + Igtoteq);
(*(ckt->CKTrhs + here->BSIM4v3gNodePrime) -= m * (ceqqg - ceqgcrg + Igtoteq));
if (here->BSIM4v3rgateMod == 2)
(*(ckt->CKTrhs + here->BSIM4v3gNodeExt) -= ceqgcrg);
(*(ckt->CKTrhs + here->BSIM4v3gNodeExt) -= m * ceqgcrg);
else if (here->BSIM4v3rgateMod == 3)
(*(ckt->CKTrhs + here->BSIM4v3gNodeMid) -= ceqqgmid + ceqgcrg);
(*(ckt->CKTrhs + here->BSIM4v3gNodeMid) -= m * (ceqqgmid + ceqgcrg));
if (!here->BSIM4v3rbodyMod)
{ (*(ckt->CKTrhs + here->BSIM4v3bNodePrime) += (ceqbd + ceqbs - ceqjd
{ (*(ckt->CKTrhs + here->BSIM4v3bNodePrime) += m * (ceqbd + ceqbs - ceqjd
- ceqjs - ceqqb + Ibtoteq));
(*(ckt->CKTrhs + here->BSIM4v3sNodePrime) += (ceqdrn - ceqbs + ceqjs
(*(ckt->CKTrhs + here->BSIM4v3sNodePrime) += m * (ceqdrn - ceqbs + ceqjs
+ ceqqg + ceqqb + ceqqd + ceqqgmid - ceqgstot + Istoteq));
}
else
{ (*(ckt->CKTrhs + here->BSIM4v3dbNode) -= (ceqjd + ceqqjd));
(*(ckt->CKTrhs + here->BSIM4v3bNodePrime) += (ceqbd + ceqbs - ceqqb + Ibtoteq));
(*(ckt->CKTrhs + here->BSIM4v3sbNode) -= (ceqjs + ceqqjs));
(*(ckt->CKTrhs + here->BSIM4v3sNodePrime) += (ceqdrn - ceqbs + ceqjs + ceqqd
{ (*(ckt->CKTrhs + here->BSIM4v3dbNode) -= m * (ceqjd + ceqqjd));
(*(ckt->CKTrhs + here->BSIM4v3bNodePrime) += m * (ceqbd + ceqbs - ceqqb + Ibtoteq));
(*(ckt->CKTrhs + here->BSIM4v3sbNode) -= m * (ceqjs + ceqqjs));
(*(ckt->CKTrhs + here->BSIM4v3sNodePrime) += m * (ceqdrn - ceqbs + ceqjs + ceqqd
+ ceqqg + ceqqb + ceqqjd + ceqqjs + ceqqgmid - ceqgstot + Istoteq));
}
if (model->BSIM4v3rdsMod)
{ (*(ckt->CKTrhs + here->BSIM4v3dNode) -= ceqgdtot);
(*(ckt->CKTrhs + here->BSIM4v3sNode) += ceqgstot);
{ (*(ckt->CKTrhs + here->BSIM4v3dNode) -= m * ceqgdtot);
(*(ckt->CKTrhs + here->BSIM4v3sNode) += m * ceqgstot);
}
if (here->BSIM4v3trnqsMod)
*(ckt->CKTrhs + here->BSIM4v3qNode) += (cqcheq - cqdef);
*(ckt->CKTrhs + here->BSIM4v3qNode) += m * (cqcheq - cqdef);
/*
@ -4412,95 +4413,95 @@ line900:
T1 = qdef * here->BSIM4v3gtau;
if (here->BSIM4v3rgateMod == 1)
{ (*(here->BSIM4v3GEgePtr) += geltd);
(*(here->BSIM4v3GPgePtr) -= geltd);
(*(here->BSIM4v3GEgpPtr) -= geltd);
(*(here->BSIM4v3GPgpPtr) += gcggb + geltd - ggtg + gIgtotg);
(*(here->BSIM4v3GPdpPtr) += gcgdb - ggtd + gIgtotd);
(*(here->BSIM4v3GPspPtr) += gcgsb - ggts + gIgtots);
(*(here->BSIM4v3GPbpPtr) += gcgbb - ggtb + gIgtotb);
{ (*(here->BSIM4v3GEgePtr) += m * geltd);
(*(here->BSIM4v3GPgePtr) -= m * geltd);
(*(here->BSIM4v3GEgpPtr) -= m * geltd);
(*(here->BSIM4v3GPgpPtr) += m * (gcggb + geltd - ggtg + gIgtotg));
(*(here->BSIM4v3GPdpPtr) += m * (gcgdb - ggtd + gIgtotd));
(*(here->BSIM4v3GPspPtr) += m * (gcgsb - ggts + gIgtots));
(*(here->BSIM4v3GPbpPtr) += m * (gcgbb - ggtb + gIgtotb));
} /* WDLiu: gcrg already subtracted from all gcrgg below */
else if (here->BSIM4v3rgateMod == 2)
{ (*(here->BSIM4v3GEgePtr) += gcrg);
(*(here->BSIM4v3GEgpPtr) += gcrgg);
(*(here->BSIM4v3GEdpPtr) += gcrgd);
(*(here->BSIM4v3GEspPtr) += gcrgs);
(*(here->BSIM4v3GEbpPtr) += gcrgb);
{ (*(here->BSIM4v3GEgePtr) += m * gcrg);
(*(here->BSIM4v3GEgpPtr) += m * gcrgg);
(*(here->BSIM4v3GEdpPtr) += m * gcrgd);
(*(here->BSIM4v3GEspPtr) += m * gcrgs);
(*(here->BSIM4v3GEbpPtr) += m * gcrgb);
(*(here->BSIM4v3GPgePtr) -= gcrg);
(*(here->BSIM4v3GPgpPtr) += gcggb - gcrgg - ggtg + gIgtotg);
(*(here->BSIM4v3GPdpPtr) += gcgdb - gcrgd - ggtd + gIgtotd);
(*(here->BSIM4v3GPspPtr) += gcgsb - gcrgs - ggts + gIgtots);
(*(here->BSIM4v3GPbpPtr) += gcgbb - gcrgb - ggtb + gIgtotb);
(*(here->BSIM4v3GPgePtr) -= m * gcrg);
(*(here->BSIM4v3GPgpPtr) += m * (gcggb - gcrgg - ggtg + gIgtotg));
(*(here->BSIM4v3GPdpPtr) += m * (gcgdb - gcrgd - ggtd + gIgtotd));
(*(here->BSIM4v3GPspPtr) += m * (gcgsb - gcrgs - ggts + gIgtots));
(*(here->BSIM4v3GPbpPtr) += m * (gcgbb - gcrgb - ggtb + gIgtotb));
}
else if (here->BSIM4v3rgateMod == 3)
{ (*(here->BSIM4v3GEgePtr) += geltd);
(*(here->BSIM4v3GEgmPtr) -= geltd);
(*(here->BSIM4v3GMgePtr) -= geltd);
(*(here->BSIM4v3GMgmPtr) += geltd + gcrg + gcgmgmb);
{ (*(here->BSIM4v3GEgePtr) += m * geltd);
(*(here->BSIM4v3GEgmPtr) -= m * geltd);
(*(here->BSIM4v3GMgePtr) -= m * geltd);
(*(here->BSIM4v3GMgmPtr) += m * (geltd + gcrg + gcgmgmb));
(*(here->BSIM4v3GMdpPtr) += gcrgd + gcgmdb);
(*(here->BSIM4v3GMgpPtr) += gcrgg);
(*(here->BSIM4v3GMspPtr) += gcrgs + gcgmsb);
(*(here->BSIM4v3GMbpPtr) += gcrgb + gcgmbb);
(*(here->BSIM4v3GMdpPtr) += m * (gcrgd + gcgmdb));
(*(here->BSIM4v3GMgpPtr) += m * gcrgg);
(*(here->BSIM4v3GMspPtr) += m * (gcrgs + gcgmsb));
(*(here->BSIM4v3GMbpPtr) += m * (gcrgb + gcgmbb));
(*(here->BSIM4v3DPgmPtr) += gcdgmb);
(*(here->BSIM4v3GPgmPtr) -= gcrg);
(*(here->BSIM4v3SPgmPtr) += gcsgmb);
(*(here->BSIM4v3BPgmPtr) += gcbgmb);
(*(here->BSIM4v3DPgmPtr) += m * gcdgmb);
(*(here->BSIM4v3GPgmPtr) -= m * gcrg);
(*(here->BSIM4v3SPgmPtr) += m * gcsgmb);
(*(here->BSIM4v3BPgmPtr) += m * gcbgmb);
(*(here->BSIM4v3GPgpPtr) += gcggb - gcrgg - ggtg + gIgtotg);
(*(here->BSIM4v3GPdpPtr) += gcgdb - gcrgd - ggtd + gIgtotd);
(*(here->BSIM4v3GPspPtr) += gcgsb - gcrgs - ggts + gIgtots);
(*(here->BSIM4v3GPbpPtr) += gcgbb - gcrgb - ggtb + gIgtotb);
(*(here->BSIM4v3GPgpPtr) += m * (gcggb - gcrgg - ggtg + gIgtotg));
(*(here->BSIM4v3GPdpPtr) += m * (gcgdb - gcrgd - ggtd + gIgtotd));
(*(here->BSIM4v3GPspPtr) += m * (gcgsb - gcrgs - ggts + gIgtots));
(*(here->BSIM4v3GPbpPtr) += m * (gcgbb - gcrgb - ggtb + gIgtotb));
}
else
{ (*(here->BSIM4v3GPgpPtr) += gcggb - ggtg + gIgtotg);
(*(here->BSIM4v3GPdpPtr) += gcgdb - ggtd + gIgtotd);
(*(here->BSIM4v3GPspPtr) += gcgsb - ggts + gIgtots);
(*(here->BSIM4v3GPbpPtr) += gcgbb - ggtb + gIgtotb);
{ (*(here->BSIM4v3GPgpPtr) += m * (gcggb - ggtg + gIgtotg));
(*(here->BSIM4v3GPdpPtr) += m * (gcgdb - ggtd + gIgtotd));
(*(here->BSIM4v3GPspPtr) += m * (gcgsb - ggts + gIgtots));
(*(here->BSIM4v3GPbpPtr) += m * (gcgbb - ggtb + gIgtotb));
}
if (model->BSIM4v3rdsMod)
{ (*(here->BSIM4v3DgpPtr) += gdtotg);
(*(here->BSIM4v3DspPtr) += gdtots);
(*(here->BSIM4v3DbpPtr) += gdtotb);
(*(here->BSIM4v3SdpPtr) += gstotd);
(*(here->BSIM4v3SgpPtr) += gstotg);
(*(here->BSIM4v3SbpPtr) += gstotb);
{ (*(here->BSIM4v3DgpPtr) += m * gdtotg);
(*(here->BSIM4v3DspPtr) += m * gdtots);
(*(here->BSIM4v3DbpPtr) += m * gdtotb);
(*(here->BSIM4v3SdpPtr) += m * gstotd);
(*(here->BSIM4v3SgpPtr) += m * gstotg);
(*(here->BSIM4v3SbpPtr) += m * gstotb);
}
(*(here->BSIM4v3DPdpPtr) += gdpr + here->BSIM4v3gds + here->BSIM4v3gbd + T1 * ddxpart_dVd
- gdtotd + RevSum + gcddb + gbdpdp + dxpart * ggtd - gIdtotd);
(*(here->BSIM4v3DPdPtr) -= gdpr + gdtot);
(*(here->BSIM4v3DPgpPtr) += Gm + gcdgb - gdtotg + gbdpg - gIdtotg
+ dxpart * ggtg + T1 * ddxpart_dVg);
(*(here->BSIM4v3DPspPtr) -= here->BSIM4v3gds + gdtots - dxpart * ggts + gIdtots
- T1 * ddxpart_dVs + FwdSum - gcdsb - gbdpsp);
(*(here->BSIM4v3DPbpPtr) -= gjbd + gdtotb - Gmbs - gcdbb - gbdpb + gIdtotb
- T1 * ddxpart_dVb - dxpart * ggtb);
(*(here->BSIM4v3DPdpPtr) += m * (gdpr + here->BSIM4v3gds + here->BSIM4v3gbd + T1 * ddxpart_dVd
- gdtotd + RevSum + gcddb + gbdpdp + dxpart * ggtd - gIdtotd));
(*(here->BSIM4v3DPdPtr) -= m * (gdpr + gdtot));
(*(here->BSIM4v3DPgpPtr) += m * (Gm + gcdgb - gdtotg + gbdpg - gIdtotg
+ dxpart * ggtg + T1 * ddxpart_dVg));
(*(here->BSIM4v3DPspPtr) -= m * (here->BSIM4v3gds + gdtots - dxpart * ggts + gIdtots
- T1 * ddxpart_dVs + FwdSum - gcdsb - gbdpsp));
(*(here->BSIM4v3DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gcdbb - gbdpb + gIdtotb
- T1 * ddxpart_dVb - dxpart * ggtb));
(*(here->BSIM4v3DdpPtr) -= gdpr - gdtotd);
(*(here->BSIM4v3DdPtr) += gdpr + gdtot);
(*(here->BSIM4v3DdpPtr) -= m * (gdpr - gdtotd));
(*(here->BSIM4v3DdPtr) += m * (gdpr + gdtot));
(*(here->BSIM4v3SPdpPtr) -= here->BSIM4v3gds + gstotd + RevSum - gcsdb - gbspdp
- T1 * dsxpart_dVd - sxpart * ggtd + gIstotd);
(*(here->BSIM4v3SPgpPtr) += gcsgb - Gm - gstotg + gbspg + sxpart * ggtg
+ T1 * dsxpart_dVg - gIstotg);
(*(here->BSIM4v3SPspPtr) += gspr + here->BSIM4v3gds + here->BSIM4v3gbs + T1 * dsxpart_dVs
- gstots + FwdSum + gcssb + gbspsp + sxpart * ggts - gIstots);
(*(here->BSIM4v3SPsPtr) -= gspr + gstot);
(*(here->BSIM4v3SPbpPtr) -= gjbs + gstotb + Gmbs - gcsbb - gbspb - sxpart * ggtb
- T1 * dsxpart_dVb + gIstotb);
(*(here->BSIM4v3SPdpPtr) -= m * (here->BSIM4v3gds + gstotd + RevSum - gcsdb - gbspdp
- T1 * dsxpart_dVd - sxpart * ggtd + gIstotd));
(*(here->BSIM4v3SPgpPtr) += m * (gcsgb - Gm - gstotg + gbspg + sxpart * ggtg
+ T1 * dsxpart_dVg - gIstotg));
(*(here->BSIM4v3SPspPtr) += m * (gspr + here->BSIM4v3gds + here->BSIM4v3gbs + T1 * dsxpart_dVs
- gstots + FwdSum + gcssb + gbspsp + sxpart * ggts - gIstots));
(*(here->BSIM4v3SPsPtr) -= m * (gspr + gstot));
(*(here->BSIM4v3SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gcsbb - gbspb - sxpart * ggtb
- T1 * dsxpart_dVb + gIstotb));
(*(here->BSIM4v3SspPtr) -= gspr - gstots);
(*(here->BSIM4v3SsPtr) += gspr + gstot);
(*(here->BSIM4v3SspPtr) -= m * (gspr - gstots));
(*(here->BSIM4v3SsPtr) += m * (gspr + gstot));
(*(here->BSIM4v3BPdpPtr) += gcbdb - gjbd + gbbdp - gIbtotd);
(*(here->BSIM4v3BPgpPtr) += gcbgb - here->BSIM4v3gbgs - gIbtotg);
(*(here->BSIM4v3BPspPtr) += gcbsb - gjbs + gbbsp - gIbtots);
(*(here->BSIM4v3BPbpPtr) += gjbd + gjbs + gcbbb - here->BSIM4v3gbbs
- gIbtotb);
(*(here->BSIM4v3BPdpPtr) += m * (gcbdb - gjbd + gbbdp - gIbtotd));
(*(here->BSIM4v3BPgpPtr) += m * (gcbgb - here->BSIM4v3gbgs - gIbtotg));
(*(here->BSIM4v3BPspPtr) += m * (gcbsb - gjbs + gbbsp - gIbtots));
(*(here->BSIM4v3BPbpPtr) += m * (gjbd + gjbs + gcbbb - here->BSIM4v3gbbs
- gIbtotb));
ggidld = here->BSIM4v3ggidld;
ggidlg = here->BSIM4v3ggidlg;
@ -4510,65 +4511,65 @@ line900:
ggislb = here->BSIM4v3ggislb;
/* stamp gidl */
(*(here->BSIM4v3DPdpPtr) += ggidld);
(*(here->BSIM4v3DPgpPtr) += ggidlg);
(*(here->BSIM4v3DPspPtr) -= (ggidlg + ggidld + ggidlb));
(*(here->BSIM4v3DPbpPtr) += ggidlb);
(*(here->BSIM4v3BPdpPtr) -= ggidld);
(*(here->BSIM4v3BPgpPtr) -= ggidlg);
(*(here->BSIM4v3BPspPtr) += (ggidlg + ggidld + ggidlb));
(*(here->BSIM4v3BPbpPtr) -= ggidlb);
(*(here->BSIM4v3DPdpPtr) += m * ggidld);
(*(here->BSIM4v3DPgpPtr) += m * ggidlg);
(*(here->BSIM4v3DPspPtr) -= m * (ggidlg + ggidld + ggidlb));
(*(here->BSIM4v3DPbpPtr) += m * ggidlb);
(*(here->BSIM4v3BPdpPtr) -= m * ggidld);
(*(here->BSIM4v3BPgpPtr) -= m * ggidlg);
(*(here->BSIM4v3BPspPtr) += m * (ggidlg + ggidld + ggidlb));
(*(here->BSIM4v3BPbpPtr) -= m * ggidlb);
/* stamp gisl */
(*(here->BSIM4v3SPdpPtr) -= (ggisls + ggislg + ggislb));
(*(here->BSIM4v3SPgpPtr) += ggislg);
(*(here->BSIM4v3SPspPtr) += ggisls);
(*(here->BSIM4v3SPbpPtr) += ggislb);
(*(here->BSIM4v3BPdpPtr) += (ggislg + ggisls + ggislb));
(*(here->BSIM4v3BPgpPtr) -= ggislg);
(*(here->BSIM4v3BPspPtr) -= ggisls);
(*(here->BSIM4v3BPbpPtr) -= ggislb);
(*(here->BSIM4v3SPdpPtr) -= m * (ggisls + ggislg + ggislb));
(*(here->BSIM4v3SPgpPtr) += m * ggislg);
(*(here->BSIM4v3SPspPtr) += m * ggisls);
(*(here->BSIM4v3SPbpPtr) += m * ggislb);
(*(here->BSIM4v3BPdpPtr) += m * (ggislg + ggisls + ggislb));
(*(here->BSIM4v3BPgpPtr) -= m * ggislg);
(*(here->BSIM4v3BPspPtr) -= m * ggisls);
(*(here->BSIM4v3BPbpPtr) -= m * ggislb);
if (here->BSIM4v3rbodyMod)
{ (*(here->BSIM4v3DPdbPtr) += gcdbdb - here->BSIM4v3gbd);
(*(here->BSIM4v3SPsbPtr) -= here->BSIM4v3gbs - gcsbsb);
{ (*(here->BSIM4v3DPdbPtr) += m * (gcdbdb - here->BSIM4v3gbd));
(*(here->BSIM4v3SPsbPtr) -= m * (here->BSIM4v3gbs - gcsbsb));
(*(here->BSIM4v3DBdpPtr) += gcdbdb - here->BSIM4v3gbd);
(*(here->BSIM4v3DBdbPtr) += here->BSIM4v3gbd - gcdbdb
+ here->BSIM4v3grbpd + here->BSIM4v3grbdb);
(*(here->BSIM4v3DBbpPtr) -= here->BSIM4v3grbpd);
(*(here->BSIM4v3DBbPtr) -= here->BSIM4v3grbdb);
(*(here->BSIM4v3DBdpPtr) += m * (gcdbdb - here->BSIM4v3gbd));
(*(here->BSIM4v3DBdbPtr) += m * (here->BSIM4v3gbd - gcdbdb
+ here->BSIM4v3grbpd + here->BSIM4v3grbdb));
(*(here->BSIM4v3DBbpPtr) -= m * here->BSIM4v3grbpd);
(*(here->BSIM4v3DBbPtr) -= m * here->BSIM4v3grbdb);
(*(here->BSIM4v3BPdbPtr) -= here->BSIM4v3grbpd);
(*(here->BSIM4v3BPbPtr) -= here->BSIM4v3grbpb);
(*(here->BSIM4v3BPsbPtr) -= here->BSIM4v3grbps);
(*(here->BSIM4v3BPbpPtr) += here->BSIM4v3grbpd + here->BSIM4v3grbps
+ here->BSIM4v3grbpb);
(*(here->BSIM4v3BPdbPtr) -= m * here->BSIM4v3grbpd);
(*(here->BSIM4v3BPbPtr) -= m * here->BSIM4v3grbpb);
(*(here->BSIM4v3BPsbPtr) -= m * here->BSIM4v3grbps);
(*(here->BSIM4v3BPbpPtr) += m * (here->BSIM4v3grbpd + here->BSIM4v3grbps
+ here->BSIM4v3grbpb));
/* WDLiu: (gcbbb - here->BSIM4v3gbbs) already added to BPbpPtr */
(*(here->BSIM4v3SBspPtr) += gcsbsb - here->BSIM4v3gbs);
(*(here->BSIM4v3SBbpPtr) -= here->BSIM4v3grbps);
(*(here->BSIM4v3SBbPtr) -= here->BSIM4v3grbsb);
(*(here->BSIM4v3SBsbPtr) += here->BSIM4v3gbs - gcsbsb
+ here->BSIM4v3grbps + here->BSIM4v3grbsb);
(*(here->BSIM4v3SBspPtr) += m * (gcsbsb - here->BSIM4v3gbs));
(*(here->BSIM4v3SBbpPtr) -= m * here->BSIM4v3grbps);
(*(here->BSIM4v3SBbPtr) -= m * here->BSIM4v3grbsb);
(*(here->BSIM4v3SBsbPtr) += m * (here->BSIM4v3gbs - gcsbsb
+ here->BSIM4v3grbps + here->BSIM4v3grbsb));
(*(here->BSIM4v3BdbPtr) -= here->BSIM4v3grbdb);
(*(here->BSIM4v3BbpPtr) -= here->BSIM4v3grbpb);
(*(here->BSIM4v3BsbPtr) -= here->BSIM4v3grbsb);
(*(here->BSIM4v3BbPtr) += here->BSIM4v3grbsb + here->BSIM4v3grbdb
+ here->BSIM4v3grbpb);
(*(here->BSIM4v3BdbPtr) -= m * here->BSIM4v3grbdb);
(*(here->BSIM4v3BbpPtr) -= m * here->BSIM4v3grbpb);
(*(here->BSIM4v3BsbPtr) -= m * here->BSIM4v3grbsb);
(*(here->BSIM4v3BbPtr) += m * (here->BSIM4v3grbsb + here->BSIM4v3grbdb
+ here->BSIM4v3grbpb));
}
if (here->BSIM4v3trnqsMod)
{ (*(here->BSIM4v3QqPtr) += gqdef + here->BSIM4v3gtau);
(*(here->BSIM4v3QgpPtr) += ggtg - gcqgb);
(*(here->BSIM4v3QdpPtr) += ggtd - gcqdb);
(*(here->BSIM4v3QspPtr) += ggts - gcqsb);
(*(here->BSIM4v3QbpPtr) += ggtb - gcqbb);
{ (*(here->BSIM4v3QqPtr) += m * (gqdef + here->BSIM4v3gtau));
(*(here->BSIM4v3QgpPtr) += m * (ggtg - gcqgb));
(*(here->BSIM4v3QdpPtr) += m * (ggtd - gcqdb));
(*(here->BSIM4v3QspPtr) += m * (ggts - gcqsb));
(*(here->BSIM4v3QbpPtr) += m * (ggtb - gcqbb));
(*(here->BSIM4v3DPqPtr) += dxpart * here->BSIM4v3gtau);
(*(here->BSIM4v3SPqPtr) += sxpart * here->BSIM4v3gtau);
(*(here->BSIM4v3GPqPtr) -= here->BSIM4v3gtau);
(*(here->BSIM4v3DPqPtr) += m * dxpart * here->BSIM4v3gtau);
(*(here->BSIM4v3SPqPtr) += m * sxpart * here->BSIM4v3gtau);
(*(here->BSIM4v3GPqPtr) -= m * here->BSIM4v3gtau);
}
line1000: ;

43
src/spicelib/devices/bsim4v3/b4v3noi.c
View File

@ -13,8 +13,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "bsim4v3def.h"
#include "cktdefs.h"
#include "iferrmsg.h"
@ -96,7 +94,9 @@ double T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13;
double Vds, n, ExpArg, Ssi, Swi;
double tmp, gdpr, gspr, npart_theta, npart_beta, igsquare;
int error, i;
double m;
int i;
/* define the names of the noise sources */
static char *BSIM4v3nNames[BSIM4v3NSRCS] =
@ -183,6 +183,7 @@ int error, i;
}
break;
case N_CALC:
m = here->BSIM4v3m;
switch (mode)
{ case N_DENS:
if (model->BSIM4v3tnoiMod == 0)
@ -228,25 +229,25 @@ int error, i;
NevalSrc(&noizDens[BSIM4v3RDNOIZ],
&lnNdens[BSIM4v3RDNOIZ], ckt, THERMNOISE,
here->BSIM4v3dNodePrime, here->BSIM4v3dNode,
gdpr);
gdpr * m);
NevalSrc(&noizDens[BSIM4v3RSNOIZ],
&lnNdens[BSIM4v3RSNOIZ], ckt, THERMNOISE,
here->BSIM4v3sNodePrime, here->BSIM4v3sNode,
gspr);
gspr * m);
if ((here->BSIM4v3rgateMod == 1) || (here->BSIM4v3rgateMod == 2))
{ NevalSrc(&noizDens[BSIM4v3RGNOIZ],
&lnNdens[BSIM4v3RGNOIZ], ckt, THERMNOISE,
here->BSIM4v3gNodePrime, here->BSIM4v3gNodeExt,
here->BSIM4v3grgeltd);
here->BSIM4v3grgeltd * m);
}
else if (here->BSIM4v3rgateMod == 3)
{ NevalSrc(&noizDens[BSIM4v3RGNOIZ],
&lnNdens[BSIM4v3RGNOIZ], ckt, THERMNOISE,
here->BSIM4v3gNodeMid, here->BSIM4v3gNodeExt,
here->BSIM4v3grgeltd);
here->BSIM4v3grgeltd * m);
}
else
{ noizDens[BSIM4v3RGNOIZ] = 0.0;
@ -259,23 +260,23 @@ int error, i;
{ NevalSrc(&noizDens[BSIM4v3RBPSNOIZ],
&lnNdens[BSIM4v3RBPSNOIZ], ckt, THERMNOISE,
here->BSIM4v3bNodePrime, here->BSIM4v3sbNode,
here->BSIM4v3grbps);
here->BSIM4v3grbps * m);
NevalSrc(&noizDens[BSIM4v3RBPDNOIZ],
&lnNdens[BSIM4v3RBPDNOIZ], ckt, THERMNOISE,
here->BSIM4v3bNodePrime, here->BSIM4v3dbNode,
here->BSIM4v3grbpd);
here->BSIM4v3grbpd * m);
NevalSrc(&noizDens[BSIM4v3RBPBNOIZ],
&lnNdens[BSIM4v3RBPBNOIZ], ckt, THERMNOISE,
here->BSIM4v3bNodePrime, here->BSIM4v3bNode,
here->BSIM4v3grbpb);
here->BSIM4v3grbpb * m);
NevalSrc(&noizDens[BSIM4v3RBSBNOIZ],
&lnNdens[BSIM4v3RBSBNOIZ], ckt, THERMNOISE,
here->BSIM4v3bNode, here->BSIM4v3sbNode,
here->BSIM4v3grbsb);
here->BSIM4v3grbsb * m);
NevalSrc(&noizDens[BSIM4v3RBDBNOIZ],
&lnNdens[BSIM4v3RBDBNOIZ], ckt, THERMNOISE,
here->BSIM4v3bNode, here->BSIM4v3dbNode,
here->BSIM4v3grbdb);
here->BSIM4v3grbdb * m);
}
else
{ noizDens[BSIM4v3RBPSNOIZ] = noizDens[BSIM4v3RBPDNOIZ] = 0.0;
@ -296,7 +297,7 @@ int error, i;
switch(model->BSIM4v3tnoiMod)
{ case 0:
T0 = here->BSIM4v3ueff * fabs(here->BSIM4v3qinv);
T0 = m * here->BSIM4v3ueff * fabs(here->BSIM4v3qinv);
T1 = T0 * tmp + pParam->BSIM4v3leff
* pParam->BSIM4v3leff;
NevalSrc(&noizDens[BSIM4v3IDNOIZ],
@ -306,7 +307,7 @@ int error, i;
(T0 / T1) * model->BSIM4v3ntnoi);
break;
case 1:
T0 = here->BSIM4v3gm + here->BSIM4v3gmbs + here->BSIM4v3gds;
T0 = m * (here->BSIM4v3gm + here->BSIM4v3gmbs + here->BSIM4v3gds);
T0 *= T0;
igsquare = npart_theta * npart_theta * T0 / here->BSIM4v3IdovVds;
T1 = npart_beta * (here->BSIM4v3gm
@ -325,7 +326,7 @@ int error, i;
switch(model->BSIM4v3fnoiMod)
{ case 0:
noizDens[BSIM4v3FLNOIZ] *= model->BSIM4v3kf
noizDens[BSIM4v3FLNOIZ] *= m * model->BSIM4v3kf
* exp(model->BSIM4v3af
* log(MAX(fabs(here->BSIM4v3cd),
N_MINLOG)))
@ -350,7 +351,7 @@ int error, i;
* here->BSIM4v3cd;
T1 = Swi + Ssi;
if (T1 > 0.0)
noizDens[BSIM4v3FLNOIZ] *= (Ssi * Swi) / T1;
noizDens[BSIM4v3FLNOIZ] *= m * (Ssi * Swi) / T1;
else
noizDens[BSIM4v3FLNOIZ] *= 0.0;
break;
@ -364,25 +365,25 @@ int error, i;
NevalSrc(&noizDens[BSIM4v3IGSNOIZ],
&lnNdens[BSIM4v3IGSNOIZ], ckt, SHOTNOISE,
here->BSIM4v3gNodePrime, here->BSIM4v3sNodePrime,
(here->BSIM4v3Igs + here->BSIM4v3Igcs));
m * (here->BSIM4v3Igs + here->BSIM4v3Igcs));
NevalSrc(&noizDens[BSIM4v3IGDNOIZ],
&lnNdens[BSIM4v3IGDNOIZ], ckt, SHOTNOISE,
here->BSIM4v3gNodePrime, here->BSIM4v3dNodePrime,
(here->BSIM4v3Igd + here->BSIM4v3Igcd));
m * (here->BSIM4v3Igd + here->BSIM4v3Igcd));
} else {
NevalSrc(&noizDens[BSIM4v3IGSNOIZ],
&lnNdens[BSIM4v3IGSNOIZ], ckt, SHOTNOISE,
here->BSIM4v3gNodePrime, here->BSIM4v3sNodePrime,
(here->BSIM4v3Igs + here->BSIM4v3Igcd));
m * (here->BSIM4v3Igs + here->BSIM4v3Igcd));
NevalSrc(&noizDens[BSIM4v3IGDNOIZ],
&lnNdens[BSIM4v3IGDNOIZ], ckt, SHOTNOISE,
here->BSIM4v3gNodePrime, here->BSIM4v3dNodePrime,
(here->BSIM4v3Igd + here->BSIM4v3Igcs));
m * (here->BSIM4v3Igd + here->BSIM4v3Igcs));
}
NevalSrc(&noizDens[BSIM4v3IGBNOIZ],
&lnNdens[BSIM4v3IGBNOIZ], ckt, SHOTNOISE,
here->BSIM4v3gNodePrime, here->BSIM4v3bNodePrime,
here->BSIM4v3Igb);
m * here->BSIM4v3Igb);
noizDens[BSIM4v3TOTNOIZ] = noizDens[BSIM4v3RDNOIZ]

5
src/spicelib/devices/bsim4v3/b4v3par.c
View File

@ -12,7 +12,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include "ifsim.h"
#include "bsim4v3def.h"
#include "sperror.h"
@ -39,6 +38,10 @@ IFvalue *select;
here->BSIM4v3l = value->rValue*scale;
here->BSIM4v3lGiven = TRUE;
break;
case BSIM4v3_M:
here->BSIM4v3m = value->rValue;
here->BSIM4v3mGiven = TRUE;
break;
case BSIM4v3_NF:
here->BSIM4v3nf = value->rValue;
here->BSIM4v3nfGiven = TRUE;

414
src/spicelib/devices/bsim4v3/b4v3pzld.c
View File

@ -10,7 +10,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include "cktdefs.h"
#include "complex.h"
#include "sperror.h"
@ -48,6 +47,7 @@ double ScalingFactor = 1.0e-9;
struct bsim4v3SizeDependParam *pParam;
double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
double m;
for (; model != NULL; model = model->BSIM4v3nextModel)
{ for (here = model->BSIM4v3instances; here!= NULL;
@ -483,6 +483,8 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
* Loading PZ matrix
*/
m = here->BSIM4v3m;
if (!model->BSIM4v3rdsMod)
{ gdpr = here->BSIM4v3drainConductance;
gspr = here->BSIM4v3sourceConductance;
@ -500,165 +502,165 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
geltd = here->BSIM4v3grgeltd;
if (here->BSIM4v3rgateMod == 1)
{ *(here->BSIM4v3GEgePtr) += geltd;
*(here->BSIM4v3GPgePtr) -= geltd;
*(here->BSIM4v3GEgpPtr) -= geltd;
{ *(here->BSIM4v3GEgePtr) += m * geltd;
*(here->BSIM4v3GPgePtr) -= m * geltd;
*(here->BSIM4v3GEgpPtr) -= m * geltd;
*(here->BSIM4v3GPgpPtr ) += xcggb * s->real;
*(here->BSIM4v3GPgpPtr +1) += xcggb * s->imag;
*(here->BSIM4v3GPgpPtr) += geltd - xgtg + gIgtotg;
*(here->BSIM4v3GPdpPtr ) += xcgdb * s->real;
*(here->BSIM4v3GPdpPtr +1) += xcgdb * s->imag;
*(here->BSIM4v3GPdpPtr) -= xgtd - gIgtotd;
*(here->BSIM4v3GPspPtr ) += xcgsb * s->real;
*(here->BSIM4v3GPspPtr +1) += xcgsb * s->imag;
*(here->BSIM4v3GPspPtr) -= xgts - gIgtots;
*(here->BSIM4v3GPbpPtr ) += xcgbb * s->real;
*(here->BSIM4v3GPbpPtr +1) += xcgbb * s->imag;
*(here->BSIM4v3GPbpPtr) -= xgtb - gIgtotb;
*(here->BSIM4v3GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4v3GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4v3GPgpPtr) += m * (geltd - xgtg + gIgtotg);
*(here->BSIM4v3GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4v3GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4v3GPdpPtr) -= m * (xgtd - gIgtotd);
*(here->BSIM4v3GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4v3GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4v3GPspPtr) -= m * (xgts - gIgtots);
*(here->BSIM4v3GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4v3GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4v3GPbpPtr) -= m * (xgtb - gIgtotb);
}
else if (here->BSIM4v3rgateMod == 2)
{ *(here->BSIM4v3GEgePtr) += gcrg;
*(here->BSIM4v3GEgpPtr) += gcrgg;
*(here->BSIM4v3GEdpPtr) += gcrgd;
*(here->BSIM4v3GEspPtr) += gcrgs;
*(here->BSIM4v3GEbpPtr) += gcrgb;
{ *(here->BSIM4v3GEgePtr) += m * gcrg;
*(here->BSIM4v3GEgpPtr) += m * gcrgg;
*(here->BSIM4v3GEdpPtr) += m * gcrgd;
*(here->BSIM4v3GEspPtr) += m * gcrgs;
*(here->BSIM4v3GEbpPtr) += m * gcrgb;
*(here->BSIM4v3GPgePtr) -= gcrg;
*(here->BSIM4v3GPgpPtr ) += xcggb * s->real;
*(here->BSIM4v3GPgpPtr +1) += xcggb * s->imag;
*(here->BSIM4v3GPgpPtr) -= gcrgg + xgtg - gIgtotg;
*(here->BSIM4v3GPdpPtr ) += xcgdb * s->real;
*(here->BSIM4v3GPdpPtr +1) += xcgdb * s->imag;
*(here->BSIM4v3GPdpPtr) -= gcrgd + xgtd - gIgtotd;
*(here->BSIM4v3GPspPtr ) += xcgsb * s->real;
*(here->BSIM4v3GPspPtr +1) += xcgsb * s->imag;
*(here->BSIM4v3GPspPtr) -= gcrgs + xgts - gIgtots;
*(here->BSIM4v3GPbpPtr ) += xcgbb * s->real;
*(here->BSIM4v3GPbpPtr +1) += xcgbb * s->imag;
*(here->BSIM4v3GPbpPtr) -= gcrgb + xgtb - gIgtotb;
*(here->BSIM4v3GPgePtr) -= m * gcrg;
*(here->BSIM4v3GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4v3GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4v3GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg);
*(here->BSIM4v3GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4v3GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4v3GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd);
*(here->BSIM4v3GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4v3GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4v3GPspPtr) -= m * (gcrgs + xgts - gIgtots);
*(here->BSIM4v3GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4v3GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4v3GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb);
}
else if (here->BSIM4v3rgateMod == 3)
{ *(here->BSIM4v3GEgePtr) += geltd;
*(here->BSIM4v3GEgmPtr) -= geltd;
*(here->BSIM4v3GMgePtr) -= geltd;
*(here->BSIM4v3GMgmPtr) += geltd + gcrg;
*(here->BSIM4v3GMgmPtr ) += xcgmgmb * s->real;
*(here->BSIM4v3GMgmPtr +1) += xcgmgmb * s->imag;
{ *(here->BSIM4v3GEgePtr) += m * geltd;
*(here->BSIM4v3GEgmPtr) -= m * geltd;
*(here->BSIM4v3GMgePtr) -= m * geltd;
*(here->BSIM4v3GMgmPtr) += m * (geltd + gcrg);
*(here->BSIM4v3GMgmPtr ) += m * xcgmgmb * s->real;
*(here->BSIM4v3GMgmPtr +1) += m * xcgmgmb * s->imag;
*(here->BSIM4v3GMdpPtr) += gcrgd;
*(here->BSIM4v3GMdpPtr ) += xcgmdb * s->real;
*(here->BSIM4v3GMdpPtr +1) += xcgmdb * s->imag;
*(here->BSIM4v3GMgpPtr) += gcrgg;
*(here->BSIM4v3GMspPtr) += gcrgs;
*(here->BSIM4v3GMspPtr ) += xcgmsb * s->real;
*(here->BSIM4v3GMspPtr +1) += xcgmsb * s->imag;
*(here->BSIM4v3GMbpPtr) += gcrgb;
*(here->BSIM4v3GMbpPtr ) += xcgmbb * s->real;
*(here->BSIM4v3GMbpPtr +1) += xcgmbb * s->imag;
*(here->BSIM4v3GMdpPtr) += m * gcrgd;
*(here->BSIM4v3GMdpPtr ) += m * xcgmdb * s->real;
*(here->BSIM4v3GMdpPtr +1) += m * xcgmdb * s->imag;
*(here->BSIM4v3GMgpPtr) += m * gcrgg;
*(here->BSIM4v3GMspPtr) += m * gcrgs;
*(here->BSIM4v3GMspPtr ) += m * xcgmsb * s->real;
*(here->BSIM4v3GMspPtr +1) += m * xcgmsb * s->imag;
*(here->BSIM4v3GMbpPtr) += m * gcrgb;
*(here->BSIM4v3GMbpPtr ) += m * xcgmbb * s->real;
*(here->BSIM4v3GMbpPtr +1) += m * xcgmbb * s->imag;
*(here->BSIM4v3DPgmPtr ) += xcdgmb * s->real;
*(here->BSIM4v3DPgmPtr +1) += xcdgmb * s->imag;
*(here->BSIM4v3GPgmPtr) -= gcrg;
*(here->BSIM4v3SPgmPtr ) += xcsgmb * s->real;
*(here->BSIM4v3SPgmPtr +1) += xcsgmb * s->imag;
*(here->BSIM4v3BPgmPtr ) += xcbgmb * s->real;
*(here->BSIM4v3BPgmPtr +1) += xcbgmb * s->imag;
*(here->BSIM4v3DPgmPtr ) += m * xcdgmb * s->real;
*(here->BSIM4v3DPgmPtr +1) += m * xcdgmb * s->imag;
*(here->BSIM4v3GPgmPtr) -= m * gcrg;
*(here->BSIM4v3SPgmPtr ) += m * xcsgmb * s->real;
*(here->BSIM4v3SPgmPtr +1) += m * xcsgmb * s->imag;
*(here->BSIM4v3BPgmPtr ) += m * xcbgmb * s->real;
*(here->BSIM4v3BPgmPtr +1) += m * xcbgmb * s->imag;
*(here->BSIM4v3GPgpPtr) -= gcrgg + xgtg - gIgtotg;
*(here->BSIM4v3GPgpPtr ) += xcggb * s->real;
*(here->BSIM4v3GPgpPtr +1) += xcggb * s->imag;
*(here->BSIM4v3GPdpPtr) -= gcrgd + xgtd - gIgtotd;
*(here->BSIM4v3GPdpPtr ) += xcgdb * s->real;
*(here->BSIM4v3GPdpPtr +1) += xcgdb * s->imag;
*(here->BSIM4v3GPspPtr) -= gcrgs + xgts - gIgtots;
*(here->BSIM4v3GPspPtr ) += xcgsb * s->real;
*(here->BSIM4v3GPspPtr +1) += xcgsb * s->imag;
*(here->BSIM4v3GPbpPtr) -= gcrgb + xgtb - gIgtotb;
*(here->BSIM4v3GPbpPtr ) += xcgbb * s->real;
*(here->BSIM4v3GPbpPtr +1) += xcgbb * s->imag;
*(here->BSIM4v3GPgpPtr) -= m * (gcrgg + xgtg - gIgtotg);
*(here->BSIM4v3GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4v3GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4v3GPdpPtr) -= m * (gcrgd + xgtd - gIgtotd);
*(here->BSIM4v3GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4v3GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4v3GPspPtr) -= m * (gcrgs + xgts - gIgtots);
*(here->BSIM4v3GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4v3GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4v3GPbpPtr) -= m * (gcrgb + xgtb - gIgtotb);
*(here->BSIM4v3GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4v3GPbpPtr +1) += m * xcgbb * s->imag;
}
else
{ *(here->BSIM4v3GPdpPtr ) += xcgdb * s->real;
*(here->BSIM4v3GPdpPtr +1) += xcgdb * s->imag;
*(here->BSIM4v3GPdpPtr) -= xgtd - gIgtotd;
*(here->BSIM4v3GPgpPtr ) += xcggb * s->real;
*(here->BSIM4v3GPgpPtr +1) += xcggb * s->imag;
*(here->BSIM4v3GPgpPtr) -= xgtg - gIgtotg;
*(here->BSIM4v3GPspPtr ) += xcgsb * s->real;
*(here->BSIM4v3GPspPtr +1) += xcgsb * s->imag;
*(here->BSIM4v3GPspPtr) -= xgts - gIgtots;
*(here->BSIM4v3GPbpPtr ) += xcgbb * s->real;
*(here->BSIM4v3GPbpPtr +1) += xcgbb * s->imag;
*(here->BSIM4v3GPbpPtr) -= xgtb - gIgtotb;
{ *(here->BSIM4v3GPdpPtr ) += m * xcgdb * s->real;
*(here->BSIM4v3GPdpPtr +1) += m * xcgdb * s->imag;
*(here->BSIM4v3GPdpPtr) -= m * (xgtd - gIgtotd);
*(here->BSIM4v3GPgpPtr ) += m * xcggb * s->real;
*(here->BSIM4v3GPgpPtr +1) += m * xcggb * s->imag;
*(here->BSIM4v3GPgpPtr) -= m * (xgtg - gIgtotg);
*(here->BSIM4v3GPspPtr ) += m * xcgsb * s->real;
*(here->BSIM4v3GPspPtr +1) += m * xcgsb * s->imag;
*(here->BSIM4v3GPspPtr) -= m * (xgts - gIgtots);
*(here->BSIM4v3GPbpPtr ) += m * xcgbb * s->real;
*(here->BSIM4v3GPbpPtr +1) += m * xcgbb * s->imag;
*(here->BSIM4v3GPbpPtr) -= m * (xgtb - gIgtotb);
}
if (model->BSIM4v3rdsMod)
{ (*(here->BSIM4v3DgpPtr) += gdtotg);
(*(here->BSIM4v3DspPtr) += gdtots);
(*(here->BSIM4v3DbpPtr) += gdtotb);
(*(here->BSIM4v3SdpPtr) += gstotd);
(*(here->BSIM4v3SgpPtr) += gstotg);
(*(here->BSIM4v3SbpPtr) += gstotb);
{ (*(here->BSIM4v3DgpPtr) += m * gdtotg);
(*(here->BSIM4v3DspPtr) += m * gdtots);
(*(here->BSIM4v3DbpPtr) += m * gdtotb);
(*(here->BSIM4v3SdpPtr) += m * gstotd);
(*(here->BSIM4v3SgpPtr) += m * gstotg);
(*(here->BSIM4v3SbpPtr) += m * gstotb);
}
*(here->BSIM4v3DPdpPtr ) += xcddb * s->real;
*(here->BSIM4v3DPdpPtr +1) += xcddb * s->imag;
*(here->BSIM4v3DPdpPtr) += gdpr + gds + here->BSIM4v3gbd
*(here->BSIM4v3DPdpPtr ) += m * xcddb * s->real;
*(here->BSIM4v3DPdpPtr +1) += m * xcddb * s->imag;
*(here->BSIM4v3DPdpPtr) += m * (gdpr + gds + here->BSIM4v3gbd
- gdtotd + RevSum + gbdpdp - gIdtotd
+ dxpart * xgtd + T1 * ddxpart_dVd;
*(here->BSIM4v3DPdPtr) -= gdpr + gdtot;
*(here->BSIM4v3DPgpPtr ) += xcdgb * s->real;
*(here->BSIM4v3DPgpPtr +1) += xcdgb * s->imag;
*(here->BSIM4v3DPgpPtr) += Gm - gdtotg + gbdpg - gIdtotg
+ T1 * ddxpart_dVg + dxpart * xgtg;
*(here->BSIM4v3DPspPtr ) += xcdsb * s->real;
*(here->BSIM4v3DPspPtr +1) += xcdsb * s->imag;
*(here->BSIM4v3DPspPtr) -= gds + FwdSum + gdtots - gbdpsp + gIdtots
- T1 * ddxpart_dVs - dxpart * xgts;
*(here->BSIM4v3DPbpPtr ) += xcdbb * s->real;
*(here->BSIM4v3DPbpPtr +1) += xcdbb * s->imag;
*(here->BSIM4v3DPbpPtr) -= gjbd + gdtotb - Gmbs - gbdpb + gIdtotb
- T1 * ddxpart_dVb - dxpart * xgtb;
+ dxpart * xgtd + T1 * ddxpart_dVd);
*(here->BSIM4v3DPdPtr) -= m * (gdpr + gdtot);
*(here->BSIM4v3DPgpPtr ) += m * xcdgb * s->real;
*(here->BSIM4v3DPgpPtr +1) += m * xcdgb * s->imag;
*(here->BSIM4v3DPgpPtr) += m * (Gm - gdtotg + gbdpg - gIdtotg
+ T1 * ddxpart_dVg + dxpart * xgtg);
*(here->BSIM4v3DPspPtr ) += m * xcdsb * s->real;
*(here->BSIM4v3DPspPtr +1) += m * xcdsb * s->imag;
*(here->BSIM4v3DPspPtr) -= m * (gds + FwdSum + gdtots - gbdpsp + gIdtots
- T1 * ddxpart_dVs - dxpart * xgts);
*(here->BSIM4v3DPbpPtr ) += m * xcdbb * s->real;
*(here->BSIM4v3DPbpPtr +1) += m * xcdbb * s->imag;
*(here->BSIM4v3DPbpPtr) -= m * (gjbd + gdtotb - Gmbs - gbdpb + gIdtotb
- T1 * ddxpart_dVb - dxpart * xgtb);
*(here->BSIM4v3DdpPtr) -= gdpr - gdtotd;
*(here->BSIM4v3DdPtr) += gdpr + gdtot;
*(here->BSIM4v3DdpPtr) -= m * (gdpr - gdtotd);
*(here->BSIM4v3DdPtr) += m * (gdpr + gdtot);
*(here->BSIM4v3SPdpPtr ) += xcsdb * s->real;
*(here->BSIM4v3SPdpPtr +1) += xcsdb * s->imag;
*(here->BSIM4v3SPdpPtr) -= gds + gstotd + RevSum - gbspdp + gIstotd
- T1 * dsxpart_dVd - sxpart * xgtd;
*(here->BSIM4v3SPgpPtr ) += xcsgb * s->real;
*(here->BSIM4v3SPgpPtr +1) += xcsgb * s->imag;
*(here->BSIM4v3SPgpPtr) -= Gm + gstotg - gbspg + gIstotg
- T1 * dsxpart_dVg - sxpart * xgtg;
*(here->BSIM4v3SPspPtr ) += xcssb * s->real;
*(here->BSIM4v3SPspPtr +1) += xcssb * s->imag;
*(here->BSIM4v3SPspPtr) += gspr + gds + here->BSIM4v3gbs - gIstots
*(here->BSIM4v3SPdpPtr ) += m * xcsdb * s->real;
*(here->BSIM4v3SPdpPtr +1) += m * xcsdb * s->imag;
*(here->BSIM4v3SPdpPtr) -= m * (gds + gstotd + RevSum - gbspdp + gIstotd
- T1 * dsxpart_dVd - sxpart * xgtd);
*(here->BSIM4v3SPgpPtr ) += m * xcsgb * s->real;
*(here->BSIM4v3SPgpPtr +1) += m * xcsgb * s->imag;
*(here->BSIM4v3SPgpPtr) -= m * (Gm + gstotg - gbspg + gIstotg
- T1 * dsxpart_dVg - sxpart * xgtg);
*(here->BSIM4v3SPspPtr ) += m * xcssb * s->real;
*(here->BSIM4v3SPspPtr +1) += m * xcssb * s->imag;
*(here->BSIM4v3SPspPtr) += m * (gspr + gds + here->BSIM4v3gbs - gIstots
- gstots + FwdSum + gbspsp
+ sxpart * xgts + T1 * dsxpart_dVs;
*(here->BSIM4v3SPsPtr) -= gspr + gstot;
*(here->BSIM4v3SPbpPtr ) += xcsbb * s->real;
*(here->BSIM4v3SPbpPtr +1) += xcsbb * s->imag;
*(here->BSIM4v3SPbpPtr) -= gjbs + gstotb + Gmbs - gbspb + gIstotb
- T1 * dsxpart_dVb - sxpart * xgtb;
+ sxpart * xgts + T1 * dsxpart_dVs);
*(here->BSIM4v3SPsPtr) -= m * (gspr + gstot);
*(here->BSIM4v3SPbpPtr ) += m * xcsbb * s->real;
*(here->BSIM4v3SPbpPtr +1) += m * xcsbb * s->imag;
*(here->BSIM4v3SPbpPtr) -= m * (gjbs + gstotb + Gmbs - gbspb + gIstotb
- T1 * dsxpart_dVb - sxpart * xgtb);
*(here->BSIM4v3SspPtr) -= gspr - gstots;
*(here->BSIM4v3SsPtr) += gspr + gstot;
*(here->BSIM4v3SspPtr) -= m * (gspr - gstots);
*(here->BSIM4v3SsPtr) += m * (gspr + gstot);
*(here->BSIM4v3BPdpPtr ) += xcbdb * s->real;
*(here->BSIM4v3BPdpPtr +1) += xcbdb * s->imag;
*(here->BSIM4v3BPdpPtr) -= gjbd - gbbdp + gIbtotd;
*(here->BSIM4v3BPgpPtr ) += xcbgb * s->real;
*(here->BSIM4v3BPgpPtr +1) += xcbgb * s->imag;
*(here->BSIM4v3BPgpPtr) -= here->BSIM4v3gbgs + gIbtotg;
*(here->BSIM4v3BPspPtr ) += xcbsb * s->real;
*(here->BSIM4v3BPspPtr +1) += xcbsb * s->imag;
*(here->BSIM4v3BPspPtr) -= gjbs - gbbsp + gIbtots;
*(here->BSIM4v3BPbpPtr ) += xcbbb * s->real;
*(here->BSIM4v3BPbpPtr +1) += xcbbb * s->imag;
*(here->BSIM4v3BPbpPtr) += gjbd + gjbs - here->BSIM4v3gbbs
- gIbtotb;
*(here->BSIM4v3BPdpPtr ) += m * xcbdb * s->real;
*(here->BSIM4v3BPdpPtr +1) += m * xcbdb * s->imag;
*(here->BSIM4v3BPdpPtr) -= m * (gjbd - gbbdp + gIbtotd);
*(here->BSIM4v3BPgpPtr ) += m * xcbgb * s->real;
*(here->BSIM4v3BPgpPtr +1) += m * xcbgb * s->imag;
*(here->BSIM4v3BPgpPtr) -= m * (here->BSIM4v3gbgs + gIbtotg);
*(here->BSIM4v3BPspPtr ) += m * xcbsb * s->real;
*(here->BSIM4v3BPspPtr +1) += m * xcbsb * s->imag;
*(here->BSIM4v3BPspPtr) -= m * (gjbs - gbbsp + gIbtots);
*(here->BSIM4v3BPbpPtr ) += m * xcbbb * s->real;
*(here->BSIM4v3BPbpPtr +1) += m * xcbbb * s->imag;
*(here->BSIM4v3BPbpPtr) += m * (gjbd + gjbs - here->BSIM4v3gbbs
- gIbtotb);
ggidld = here->BSIM4v3ggidld;
ggidlg = here->BSIM4v3ggidlg;
ggidlb = here->BSIM4v3ggidlb;
@ -667,87 +669,87 @@ double ggidld, ggidlg, ggidlb,ggisld, ggislg, ggislb, ggisls;
ggislb = here->BSIM4v3ggislb;
/* stamp gidl */
(*(here->BSIM4v3DPdpPtr) += ggidld);
(*(here->BSIM4v3DPgpPtr) += ggidlg);
(*(here->BSIM4v3DPspPtr) -= (ggidlg + ggidld) + ggidlb);
(*(here->BSIM4v3DPbpPtr) += ggidlb);
(*(here->BSIM4v3BPdpPtr) -= ggidld);
(*(here->BSIM4v3BPgpPtr) -= ggidlg);
(*(here->BSIM4v3BPspPtr) += (ggidlg + ggidld) + ggidlb);
(*(here->BSIM4v3BPbpPtr) -= ggidlb);
(*(here->BSIM4v3DPdpPtr) += m * ggidld);
(*(here->BSIM4v3DPgpPtr) += m * ggidlg);
(*(here->BSIM4v3DPspPtr) -= m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4v3DPbpPtr) += m * ggidlb);
(*(here->BSIM4v3BPdpPtr) -= m * ggidld);
(*(here->BSIM4v3BPgpPtr) -= m * ggidlg);
(*(here->BSIM4v3BPspPtr) += m * ((ggidlg + ggidld) + ggidlb));
(*(here->BSIM4v3BPbpPtr) -= m * ggidlb);
/* stamp gisl */
(*(here->BSIM4v3SPdpPtr) -= (ggisls + ggislg) + ggislb);
(*(here->BSIM4v3SPgpPtr) += ggislg);
(*(here->BSIM4v3SPspPtr) += ggisls);
(*(here->BSIM4v3SPbpPtr) += ggislb);
(*(here->BSIM4v3BPdpPtr) += (ggislg + ggisls) + ggislb);
(*(here->BSIM4v3BPgpPtr) -= ggislg);
(*(here->BSIM4v3BPspPtr) -= ggisls);
(*(here->BSIM4v3BPbpPtr) -= ggislb);
(*(here->BSIM4v3SPdpPtr) -= m * ((ggisls + ggislg) + ggislb));
(*(here->BSIM4v3SPgpPtr) += m * ggislg);
(*(here->BSIM4v3SPspPtr) += m * ggisls);
(*(here->BSIM4v3SPbpPtr) += m * ggislb);
(*(here->BSIM4v3BPdpPtr) += m * ((ggislg + ggisls) + ggislb));
(*(here->BSIM4v3BPgpPtr) -= m * ggislg);
(*(here->BSIM4v3BPspPtr) -= m * ggisls);
(*(here->BSIM4v3BPbpPtr) -= m * ggislb);
if (here->BSIM4v3rbodyMod)
{ (*(here->BSIM4v3DPdbPtr ) += xcdbdb * s->real);
(*(here->BSIM4v3DPdbPtr +1) += xcdbdb * s->imag);
(*(here->BSIM4v3DPdbPtr) -= here->BSIM4v3gbd);
(*(here->BSIM4v3SPsbPtr ) += xcsbsb * s->real);
(*(here->BSIM4v3SPsbPtr +1) += xcsbsb * s->imag);
(*(here->BSIM4v3SPsbPtr) -= here->BSIM4v3gbs);
{ (*(here->BSIM4v3DPdbPtr ) += m * xcdbdb * s->real);
(*(here->BSIM4v3DPdbPtr +1) += m * xcdbdb * s->imag);
(*(here->BSIM4v3DPdbPtr) -= m * here->BSIM4v3gbd);
(*(here->BSIM4v3SPsbPtr ) += m * xcsbsb * s->real);
(*(here->BSIM4v3SPsbPtr +1) += m * xcsbsb * s->imag);
(*(here->BSIM4v3SPsbPtr) -= m * here->BSIM4v3gbs);
(*(here->BSIM4v3DBdpPtr ) += xcdbdb * s->real);
(*(here->BSIM4v3DBdpPtr +1) += xcdbdb * s->imag);
(*(here->BSIM4v3DBdpPtr) -= here->BSIM4v3gbd);
(*(here->BSIM4v3DBdbPtr ) -= xcdbdb * s->real);
(*(here->BSIM4v3DBdbPtr +1) -= xcdbdb * s->imag);
(*(here->BSIM4v3DBdbPtr) += here->BSIM4v3gbd + here->BSIM4v3grbpd
+ here->BSIM4v3grbdb);
(*(here->BSIM4v3DBbpPtr) -= here->BSIM4v3grbpd);
(*(here->BSIM4v3DBbPtr) -= here->BSIM4v3grbdb);
(*(here->BSIM4v3DBdpPtr ) += m * xcdbdb * s->real);
(*(here->BSIM4v3DBdpPtr +1) += m * xcdbdb * s->imag);
(*(here->BSIM4v3DBdpPtr) -= m * here->BSIM4v3gbd);
(*(here->BSIM4v3DBdbPtr ) -= m * xcdbdb * s->real);
(*(here->BSIM4v3DBdbPtr +1) -= m * xcdbdb * s->imag);
(*(here->BSIM4v3DBdbPtr) += m * (here->BSIM4v3gbd + here->BSIM4v3grbpd
+ here->BSIM4v3grbdb));
(*(here->BSIM4v3DBbpPtr) -= m * here->BSIM4v3grbpd);
(*(here->BSIM4v3DBbPtr) -= m * here->BSIM4v3grbdb);
(*(here->BSIM4v3BPdbPtr) -= here->BSIM4v3grbpd);
(*(here->BSIM4v3BPbPtr) -= here->BSIM4v3grbpb);
(*(here->BSIM4v3BPsbPtr) -= here->BSIM4v3grbps);
(*(here->BSIM4v3BPbpPtr) += here->BSIM4v3grbpd + here->BSIM4v3grbps
+ here->BSIM4v3grbpb);
(*(here->BSIM4v3BPdbPtr) -= m * here->BSIM4v3grbpd);
(*(here->BSIM4v3BPbPtr) -= m * here->BSIM4v3grbpb);
(*(here->BSIM4v3BPsbPtr) -= m * here->BSIM4v3grbps);
(*(here->BSIM4v3BPbpPtr) += m * (here->BSIM4v3grbpd + here->BSIM4v3grbps
+ here->BSIM4v3grbpb));
/* WDL: (-here->BSIM4v3gbbs) already added to BPbpPtr */
(*(here->BSIM4v3SBspPtr ) += xcsbsb * s->real);
(*(here->BSIM4v3SBspPtr +1) += xcsbsb * s->imag);
(*(here->BSIM4v3SBspPtr) -= here->BSIM4v3gbs);
(*(here->BSIM4v3SBbpPtr) -= here->BSIM4v3grbps);
(*(here->BSIM4v3SBbPtr) -= here->BSIM4v3grbsb);
(*(here->BSIM4v3SBsbPtr ) -= xcsbsb * s->real);
(*(here->BSIM4v3SBsbPtr +1) -= xcsbsb * s->imag);
(*(here->BSIM4v3SBsbPtr) += here->BSIM4v3gbs
+ here->BSIM4v3grbps + here->BSIM4v3grbsb);
(*(here->BSIM4v3SBspPtr ) += m * xcsbsb * s->real);
(*(here->BSIM4v3SBspPtr +1) += m * xcsbsb * s->imag);
(*(here->BSIM4v3SBspPtr) -= m * here->BSIM4v3gbs);
(*(here->BSIM4v3SBbpPtr) -= m * here->BSIM4v3grbps);
(*(here->BSIM4v3SBbPtr) -= m * here->BSIM4v3grbsb);
(*(here->BSIM4v3SBsbPtr ) -= m * xcsbsb * s->real);
(*(here->BSIM4v3SBsbPtr +1) -= m * xcsbsb * s->imag);
(*(here->BSIM4v3SBsbPtr) += m * (here->BSIM4v3gbs
+ here->BSIM4v3grbps + here->BSIM4v3grbsb));
(*(here->BSIM4v3BdbPtr) -= here->BSIM4v3grbdb);
(*(here->BSIM4v3BbpPtr) -= here->BSIM4v3grbpb);
(*(here->BSIM4v3BsbPtr) -= here->BSIM4v3grbsb);
(*(here->BSIM4v3BbPtr) += here->BSIM4v3grbsb + here->BSIM4v3grbdb
+ here->BSIM4v3grbpb);
(*(here->BSIM4v3BdbPtr) -= m * here->BSIM4v3grbdb);
(*(here->BSIM4v3BbpPtr) -= m * here->BSIM4v3grbpb);
(*(here->BSIM4v3BsbPtr) -= m * here->BSIM4v3grbsb);
(*(here->BSIM4v3BbPtr) += m * (here->BSIM4v3grbsb + here->BSIM4v3grbdb
+ here->BSIM4v3grbpb));
}
if (here->BSIM4v3acnqsMod)
{ *(here->BSIM4v3QqPtr ) += s->real * ScalingFactor;
*(here->BSIM4v3QqPtr +1) += s->imag * ScalingFactor;
*(here->BSIM4v3QgpPtr ) -= xcqgb * s->real;
*(here->BSIM4v3QgpPtr +1) -= xcqgb * s->imag;
*(here->BSIM4v3QdpPtr ) -= xcqdb * s->real;
*(here->BSIM4v3QdpPtr +1) -= xcqdb * s->imag;
*(here->BSIM4v3QbpPtr ) -= xcqbb * s->real;
*(here->BSIM4v3QbpPtr +1) -= xcqbb * s->imag;
*(here->BSIM4v3QspPtr ) -= xcqsb * s->real;
*(here->BSIM4v3QspPtr +1) -= xcqsb * s->imag;
{ *(here->BSIM4v3QqPtr ) += m * s->real * ScalingFactor;
*(here->BSIM4v3QqPtr +1) += m * s->imag * ScalingFactor;
*(here->BSIM4v3QgpPtr ) -= m * xcqgb * s->real;
*(here->BSIM4v3QgpPtr +1) -= m * xcqgb * s->imag;
*(here->BSIM4v3QdpPtr ) -= m * xcqdb * s->real;
*(here->BSIM4v3QdpPtr +1) -= m * xcqdb * s->imag;
*(here->BSIM4v3QbpPtr ) -= m * xcqbb * s->real;
*(here->BSIM4v3QbpPtr +1) -= m * xcqbb * s->imag;
*(here->BSIM4v3QspPtr ) -= m * xcqsb * s->real;
*(here->BSIM4v3QspPtr +1) -= m * xcqsb * s->imag;
*(here->BSIM4v3GPqPtr) -= here->BSIM4v3gtau;
*(here->BSIM4v3DPqPtr) += dxpart * here->BSIM4v3gtau;
*(here->BSIM4v3SPqPtr) += sxpart * here->BSIM4v3gtau;
*(here->BSIM4v3GPqPtr) -= m * here->BSIM4v3gtau;
*(here->BSIM4v3DPqPtr) += m * dxpart * here->BSIM4v3gtau;
*(here->BSIM4v3SPqPtr) += m * sxpart * here->BSIM4v3gtau;
*(here->BSIM4v3QqPtr) += here->BSIM4v3gtau;
*(here->BSIM4v3QgpPtr) += xgtg;
*(here->BSIM4v3QdpPtr) += xgtd;
*(here->BSIM4v3QbpPtr) += xgtb;
*(here->BSIM4v3QspPtr) += xgts;
*(here->BSIM4v3QqPtr) += m * here->BSIM4v3gtau;
*(here->BSIM4v3QgpPtr) += m * xgtg;
*(here->BSIM4v3QdpPtr) += m * xgtd;
*(here->BSIM4v3QbpPtr) += m * xgtb;
*(here->BSIM4v3QspPtr) += m * xgts;
}
}
}

4
src/spicelib/devices/bsim4v3/b4v3set.c
View File

@ -13,8 +13,6 @@
**********/
#include "ngspice.h"
#include <stdio.h>
#include <math.h>
#include "jobdefs.h"
#include "ftedefs.h"
#include "smpdefs.h"
@ -1428,6 +1426,8 @@ JOB *job;
here->BSIM4v3l = 5.0e-6;
if (!here->BSIM4v3wGiven)
here->BSIM4v3w = 5.0e-6;
if (!here->BSIM4v3mGiven)
here->BSIM4v3m = 1.0;
if (!here->BSIM4v3nfGiven)
here->BSIM4v3nf = 1.0;
if (!here->BSIM4v3minGiven)

3
src/spicelib/devices/bsim4v3/bsim4v3def.h
View File

@ -108,6 +108,7 @@ typedef struct sBSIM4v3instance
double BSIM4v3icVGS;
double BSIM4v3icVBS;
double BSIM4v3nf;
double BSIM4v3m;
int BSIM4v3off;
int BSIM4v3mode;
int BSIM4v3trnqsMod;
@ -241,6 +242,7 @@ typedef struct sBSIM4v3instance
unsigned BSIM4v3lGiven :1;
unsigned BSIM4v3wGiven :1;
unsigned BSIM4v3nfGiven :1;
unsigned BSIM4v3mGiven :1;
unsigned BSIM4v3minGiven :1;
unsigned BSIM4v3drainAreaGiven :1;
unsigned BSIM4v3sourceAreaGiven :1;
@ -2044,6 +2046,7 @@ typedef struct sBSIM4v3model
#define BSIM4v3_SA 28
#define BSIM4v3_SB 29
#define BSIM4v3_SD 30
#define BSIM4v3_M 31
/* Global parameters */
#define BSIM4v3_MOD_TEMPMOD 89