diff --git a/src/spicelib/devices/bsim4v2/b4v2.c b/src/spicelib/devices/bsim4v2/b4v2.c index 7b9751bac..c5faf52ee 100644 --- a/src/spicelib/devices/bsim4v2/b4v2.c +++ b/src/spicelib/devices/bsim4v2/b4v2.c @@ -11,7 +11,6 @@ **********/ #include "ngspice.h" -#include #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"), diff --git a/src/spicelib/devices/bsim4v2/b4v2acld.c b/src/spicelib/devices/bsim4v2/b4v2acld.c index aaed04b4e..95fb2d2b3 100644 --- a/src/spicelib/devices/bsim4v2/b4v2acld.c +++ b/src/spicelib/devices/bsim4v2/b4v2acld.c @@ -11,7 +11,6 @@ **********/ #include "ngspice.h" -#include #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); diff --git a/src/spicelib/devices/bsim4v2/b4v2ask.c b/src/spicelib/devices/bsim4v2/b4v2ask.c index 2b4d78bf0..19d333684 100644 --- a/src/spicelib/devices/bsim4v2/b4v2ask.c +++ b/src/spicelib/devices/bsim4v2/b4v2ask.c @@ -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); diff --git a/src/spicelib/devices/bsim4v2/b4v2ld.c b/src/spicelib/devices/bsim4v2/b4v2ld.c index 7598d200c..c27f7e0e9 100644 --- a/src/spicelib/devices/bsim4v2/b4v2ld.c +++ b/src/spicelib/devices/bsim4v2/b4v2ld.c @@ -11,8 +11,6 @@ **********/ #include "ngspice.h" -#include -#include #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: ; diff --git a/src/spicelib/devices/bsim4v2/b4v2noi.c b/src/spicelib/devices/bsim4v2/b4v2noi.c index 168030d2b..819303647 100644 --- a/src/spicelib/devices/bsim4v2/b4v2noi.c +++ b/src/spicelib/devices/bsim4v2/b4v2noi.c @@ -11,8 +11,6 @@ **********/ #include "ngspice.h" -#include -#include #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] diff --git a/src/spicelib/devices/bsim4v2/b4v2par.c b/src/spicelib/devices/bsim4v2/b4v2par.c index 3fcdd9fe0..2d38e0da9 100644 --- a/src/spicelib/devices/bsim4v2/b4v2par.c +++ b/src/spicelib/devices/bsim4v2/b4v2par.c @@ -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; diff --git a/src/spicelib/devices/bsim4v2/b4v2pzld.c b/src/spicelib/devices/bsim4v2/b4v2pzld.c index 570ca1f6c..8057cdb26 100644 --- a/src/spicelib/devices/bsim4v2/b4v2pzld.c +++ b/src/spicelib/devices/bsim4v2/b4v2pzld.c @@ -11,7 +11,6 @@ **********/ #include "ngspice.h" -#include #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; } } } diff --git a/src/spicelib/devices/bsim4v2/b4v2set.c b/src/spicelib/devices/bsim4v2/b4v2set.c index 1dfcc2665..91719af40 100644 --- a/src/spicelib/devices/bsim4v2/b4v2set.c +++ b/src/spicelib/devices/bsim4v2/b4v2set.c @@ -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) diff --git a/src/spicelib/devices/bsim4v2/bsim4v2def.h b/src/spicelib/devices/bsim4v2/bsim4v2def.h index 19d69fdea..70d24e86f 100644 --- a/src/spicelib/devices/bsim4v2/bsim4v2def.h +++ b/src/spicelib/devices/bsim4v2/bsim4v2def.h @@ -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 */ diff --git a/src/spicelib/devices/bsim4v3/b4v3.c b/src/spicelib/devices/bsim4v3/b4v3.c index 360ab1ef3..eba3b3a9b 100644 --- a/src/spicelib/devices/bsim4v3/b4v3.c +++ b/src/spicelib/devices/bsim4v3/b4v3.c @@ -13,7 +13,6 @@ **********/ #include "ngspice.h" -#include #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"), diff --git a/src/spicelib/devices/bsim4v3/b4v3acld.c b/src/spicelib/devices/bsim4v3/b4v3acld.c index 7bb12a6f3..196ece401 100644 --- a/src/spicelib/devices/bsim4v3/b4v3acld.c +++ b/src/spicelib/devices/bsim4v3/b4v3acld.c @@ -10,7 +10,6 @@ **********/ #include "ngspice.h" -#include #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); diff --git a/src/spicelib/devices/bsim4v3/b4v3ask.c b/src/spicelib/devices/bsim4v3/b4v3ask.c index b2d2b40be..7c074c610 100644 --- a/src/spicelib/devices/bsim4v3/b4v3ask.c +++ b/src/spicelib/devices/bsim4v3/b4v3ask.c @@ -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); diff --git a/src/spicelib/devices/bsim4v3/b4v3ld.c b/src/spicelib/devices/bsim4v3/b4v3ld.c index 219d68b20..22b11f450 100644 --- a/src/spicelib/devices/bsim4v3/b4v3ld.c +++ b/src/spicelib/devices/bsim4v3/b4v3ld.c @@ -13,8 +13,6 @@ **********/ #include "ngspice.h" -#include -#include #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: ; diff --git a/src/spicelib/devices/bsim4v3/b4v3noi.c b/src/spicelib/devices/bsim4v3/b4v3noi.c index 76f936202..7fed5326b 100644 --- a/src/spicelib/devices/bsim4v3/b4v3noi.c +++ b/src/spicelib/devices/bsim4v3/b4v3noi.c @@ -13,8 +13,6 @@ **********/ #include "ngspice.h" -#include -#include #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] diff --git a/src/spicelib/devices/bsim4v3/b4v3par.c b/src/spicelib/devices/bsim4v3/b4v3par.c index 2ccc7530b..08b751133 100644 --- a/src/spicelib/devices/bsim4v3/b4v3par.c +++ b/src/spicelib/devices/bsim4v3/b4v3par.c @@ -12,7 +12,6 @@ **********/ #include "ngspice.h" -#include #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; diff --git a/src/spicelib/devices/bsim4v3/b4v3pzld.c b/src/spicelib/devices/bsim4v3/b4v3pzld.c index ac3ef6675..ecb4ed158 100644 --- a/src/spicelib/devices/bsim4v3/b4v3pzld.c +++ b/src/spicelib/devices/bsim4v3/b4v3pzld.c @@ -10,7 +10,6 @@ **********/ #include "ngspice.h" -#include #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; } } } diff --git a/src/spicelib/devices/bsim4v3/b4v3set.c b/src/spicelib/devices/bsim4v3/b4v3set.c index 0c68c4178..6ab6bbe06 100644 --- a/src/spicelib/devices/bsim4v3/b4v3set.c +++ b/src/spicelib/devices/bsim4v3/b4v3set.c @@ -13,8 +13,6 @@ **********/ #include "ngspice.h" -#include -#include #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) diff --git a/src/spicelib/devices/bsim4v3/bsim4v3def.h b/src/spicelib/devices/bsim4v3/bsim4v3def.h index aacbb5613..5340637df 100644 --- a/src/spicelib/devices/bsim4v3/bsim4v3def.h +++ b/src/spicelib/devices/bsim4v3/bsim4v3def.h @@ -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