mesaload.c

ngspice又一个电子CAD仿真软件代码.功能更全

            if ( (ckt->CKTmode & (MODETRAN|MODEINITSMSIG)) ||
                    ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)) ){
                /* 
                 *    charge storage elements 
                 */
                vgs1 = *(ckt->CKTstate1 + here->MESAvgspp);
                vgd1 = *(ckt->CKTstate1 + here->MESAvgdpp);

                if(ckt->CKTmode & MODEINITTRAN) {
                    *(ckt->CKTstate1 + here->MESAqgs) = capgs*vgspp;
                    *(ckt->CKTstate1 + here->MESAqgd) = capgd*vgdpp;
                }
                *(ckt->CKTstate0+here->MESAqgs) = *(ckt->CKTstate1 + here->MESAqgs) +
                                                   capgs*(vgspp-vgs1);
                *(ckt->CKTstate0+here->MESAqgd) = *(ckt->CKTstate1 + here->MESAqgd) +
                                                   capgd*(vgdpp-vgd1);

                /*
                 *   store small-signal parameters 
                 */
                if( (!(ckt->CKTmode & MODETRANOP)) || 
                        (!(ckt->CKTmode & MODEUIC)) ) {
                    if(ckt->CKTmode & MODEINITSMSIG) {
                        *(ckt->CKTstate0 + here->MESAqgs) = capgs;
                        *(ckt->CKTstate0 + here->MESAqgd) = capgd;
                        continue; /*go to 1000*/
                    }
                    /*
                     *   transient analysis 
                     */
                    if(ckt->CKTmode & MODEINITTRAN) {
                        *(ckt->CKTstate1 + here->MESAqgs) =
                                *(ckt->CKTstate0 + here->MESAqgs);
                        *(ckt->CKTstate1 + here->MESAqgd) =
                                *(ckt->CKTstate0 + here->MESAqgd);
                    }
                    error = NIintegrate(ckt,&geq,&ceq,capgs,here->MESAqgs);
                    if(error) return(error);
                    ggspp = geq;
                    cgspp = *(ckt->CKTstate0 + here->MESAcqgs);
                    cg = cg + cgspp;
                    error = NIintegrate(ckt,&geq,&ceq,capgd,here->MESAqgd);
                    if(error) return(error);
                    ggdpp = geq;
                    cgdpp = *(ckt->CKTstate0 + here->MESAcqgd);
                    cg = cg + cgdpp;
                    cd = cd - cgdpp;
                    if (ckt->CKTmode & MODEINITTRAN) {
                        *(ckt->CKTstate1 + here->MESAcqgs) =
                                *(ckt->CKTstate0 + here->MESAcqgs);
                        *(ckt->CKTstate1 + here->MESAcqgd) =
                                *(ckt->CKTstate0 + here->MESAcqgd);
                    }
                }
            }
            /*
             *  check convergence 
             */
            if( (!(ckt->CKTmode & MODEINITFIX)) | (!(ckt->CKTmode & MODEUIC))) {
                if( (icheck == 1) 
                        || (fabs(cghat-cg) >= ckt->CKTreltol*
                            MAX(fabs(cghat),fabs(cg))+ckt->CKTabstol) ||
                        (fabs(cdhat-cd) > ckt->CKTreltol*
                            MAX(fabs(cdhat),fabs(cd))+ckt->CKTabstol) 
                        ) {
                    ckt->CKTnoncon++;
                }
            }
            *(ckt->CKTstate0 + here->MESAvgs) = vgs;
            *(ckt->CKTstate0 + here->MESAvgspp) = vgspp;
            *(ckt->CKTstate0 + here->MESAvgd) = vgd;
            *(ckt->CKTstate0 + here->MESAvgdpp) = vgdpp;
            *(ckt->CKTstate0 + here->MESAcg) = cg;
            *(ckt->CKTstate0 + here->MESAcd) = cd;
            *(ckt->CKTstate0 + here->MESAcgd) = cgd;
            *(ckt->CKTstate0 + here->MESAcgs) = cgs;
            *(ckt->CKTstate0 + here->MESAgm) = gm;
            *(ckt->CKTstate0 + here->MESAgds) = gds;
            *(ckt->CKTstate0 + here->MESAggs) = ggs;
            *(ckt->CKTstate0 + here->MESAggd) = ggd;
            *(ckt->CKTstate0 + here->MESAggspp) = ggspp;
            *(ckt->CKTstate0 + here->MESAcgspp) = cgspp;
            *(ckt->CKTstate0 + here->MESAggdpp) = ggdpp;
            *(ckt->CKTstate0 + here->MESAcgdpp) = cgdpp;
            
            /*
             *    load current vector
             */
load:

            m = here->MESAm;

            ccorr = model->MESAag*(cgs-cgd);
            ceqgd = cgd + cgdpp - ggd*vgd - ggdpp*vgdpp;
            ceqgs = cgs + cgspp - ggs*vgs - ggspp*vgspp;
            cdreq=((cd+cgd+cgdpp)-gds*vds-gm*vgs);
            *(ckt->CKTrhs + here->MESAgatePrimeNode) += m * (-ceqgs-ceqgd);
            ceqgd = (cgd-ggd*vgd);
            *(ckt->CKTrhs + here->MESAdrainPrimeNode) += m * (-cdreq+ceqgd+ccorr);
            ceqgd = (cgdpp-ggdpp*vgdpp);
            *(ckt->CKTrhs + here->MESAdrainPrmPrmNode) += ceqgd;
            ceqgs = (cgs-ggs*vgs);
            *(ckt->CKTrhs + here->MESAsourcePrimeNode) += m * (cdreq+ceqgs-ccorr);
            ceqgs = (cgspp-ggspp*vgspp);
            *(ckt->CKTrhs + here->MESAsourcePrmPrmNode) += ceqgs;

            /*
             *    load y matrix 
             */
            *(here->MESAdrainDrainPtr)               += m * (here->MESAdrainConduct);
            *(here->MESAsourceSourcePtr)             += m * (here->MESAsourceConduct);
            *(here->MESAgateGatePtr)                 += m * (here->MESAgateConduct);
            *(here->MESAsourcePrmPrmSourcePrmPrmPtr) += m * (here->MESAtGi+ggspp);
            *(here->MESAdrainPrmPrmDrainPrmPrmPtr)   += m * (here->MESAtGf+ggdpp);
            *(here->MESAgatePrimeGatePrimePtr)       += m * (ggd+ggs+here->MESAgateConduct+ggspp+ggdpp);
            *(here->MESAdrainPrimeDrainPrimePtr)     += m * (gds+ggd+here->MESAdrainConduct+here->MESAtGf);
            *(here->MESAsourcePrimeSourcePrimePtr)   += m * (gds+gm+ggs+here->MESAsourceConduct+here->MESAtGi);
            *(here->MESAdrainDrainPrimePtr)          -= m * (here->MESAdrainConduct);
            *(here->MESAdrainPrimeDrainPtr)          -= m * (here->MESAdrainConduct);
            *(here->MESAsourceSourcePrimePtr)        -= m * (here->MESAsourceConduct);
            *(here->MESAsourcePrimeSourcePtr)        -= m * (here->MESAsourceConduct);
            *(here->MESAgateGatePrimePtr)            -= m * (here->MESAgateConduct);
            *(here->MESAgatePrimeGatePtr)            -= m * (here->MESAgateConduct);
            *(here->MESAgatePrimeDrainPrimePtr)      -= m * (ggd);
            *(here->MESAgatePrimeSourcePrimePtr)     -= m * (ggs);
            *(here->MESAdrainPrimeGatePrimePtr)      += m * (gm-ggd);
            *(here->MESAdrainPrimeSourcePrimePtr)    += m * (-gds-gm);
            *(here->MESAsourcePrimeGatePrimePtr)     += m * (-ggs-gm);
            *(here->MESAsourcePrimeDrainPrimePtr)    -= m * (gds);
            *(here->MESAsourcePrimeSourcePrmPrmPtr)  -= m * (here->MESAtGi);
            *(here->MESAsourcePrmPrmSourcePrimePtr)  -= m * (here->MESAtGi);
            *(here->MESAgatePrimeSourcePrmPrmPtr)    -= m * (ggspp);
            *(here->MESAsourcePrmPrmGatePrimePtr)    -= m * (ggspp);
            *(here->MESAdrainPrimeDrainPrmPrmPtr)    -= m * (here->MESAtGf);
            *(here->MESAdrainPrmPrmDrainPrimePtr)    -= m * (here->MESAtGf);
            *(here->MESAgatePrimeDrainPrmPrmPtr)     -= m * (ggdpp);
            *(here->MESAdrainPrmPrmGatePrimePtr)     -= m * (ggdpp);
        }
    }
    return(OK);
}


#define ETA     (here->MESAtEta)
#define MU0     (here->MESAtMu)
#define RS      (here->MESAtRsi)
#define RD      (here->MESAtRdi)
#define SIGMA0  (model->MESAsigma0)
#define VSIGMAT (model->MESAvsigmat)
#define VSIGMA  (model->MESAvsigma)
#define THETA   (model->MESAtheta)
#define VS      (model->MESAvs)
#define ND      (model->MESAnd)
#define D       (model->MESAd)
#define TC      (model->MESAtc)
#define MC      (model->MESAmc)
#define M0      (model->MESAm)
#define ALPHA   (model->MESAalpha)
#define LAMBDA  (here->MESAtLambda)
#define NDELTA  (model->MESAndelta)
#define TH      (model->MESAth)
#define NDU     (model->MESAndu)
#define DU      (model->MESAdu)
#define NMAX    (model->MESAnmax)
#define GAMMA   (model->MESAgamma)


static void mesa1(MESAmodel *model, MESAinstance *here, double vgs,
                  double vds, double von, double *cdrain,
                  double *gm, double *gds, double *capgs, double *capgd)

{

  double vt;
  double etavth;  
  double vl;
  double rt;
  double mu;
  double beta;
  double vgt;
  double vgt0;
  double sigma;
  double vgte;
  double isat;
  double isata;
  double isatb;
  double ns;
  double a;
  double b;
  double c;
  double d;
  double e;
  double f;
  double g;
  double h;
  double m;
  double p;
  double q;
  double r;
  double s;
  double t;
  double u;
  double v;
  double w;
  double temp;
  double gch;
  double gchi;
  double vsate;
  double vdse;
  double cgc;
  double sqrt1;
  double delidgch;
  double delgchgchi;
  double delgchins;
  double delnsvgt;
  double delnsvgte;
  double delvgtevgt;
  double delidvsate;
  double delvsateisat;
  double delisatisata;
  double delisatavgte;
  double delisatabeta;
  double delisatisatb;
  double delvsategch;
  double delidvds;
  double ddevgte;
  double dvgtvgs;
  double dgchivgt;
  double dvgtevds;
  double dgchivds;
  double disatavgt;
  double disatavds;
  double disatbvgt;
  double dvsatevgt;
  double dvsatevds;
  double gmmadd;
  double gdsmadd;
  

  vt       = CONSTKoverQ * here->MESAts;
  etavth   = ETA*vt;
  rt       = RS+RD;
  vgt0     = vgs - von;
  s        = exp((vgt0-VSIGMAT)/VSIGMA);
  sigma    = SIGMA0/(1+s);
  vgt      = vgt0+sigma*vds;
  mu       = MU0+THETA*vgt;
  vl       = VS/mu*here->MESAlength;
  beta     = here->MESAbeta/(model->MESAvpo+3*vl);
  u        = vgt/vt-1;
  t        = sqrt(model->MESAdeltaSqr+u*u);
  vgte     = 0.5*vt*(2+u+t);
  a        = 2*beta*vgte;
  b        = exp(-vgt/etavth);
  if(vgte > model->MESAvpo)
    sqrt1 = 0;
  else
    sqrt1    = sqrt(1-vgte/model->MESAvpo);
  ns       = 1.0/(1.0/ND/D/(1-sqrt1) + 1.0/here->MESAn0*b);
  if(ns < 1.0e-38) {
    *cdrain = 0;
    *gm = 0.0;
    *gds = 0.0;
    *capgs = here->MESAcf;
    *capgd = here->MESAcf;
    return;
  }
  gchi     = here->MESAgchi0*mu*ns;
  gch      = gchi/(1+gchi*rt);
  f        = sqrt(1+2*a*RS);
  d        = 1+a*RS + f;
  e        = 1+TC*vgte;
  isata    = a*vgte/(d*e);
  isatb    = here->MESAisatb0*mu*exp(vgt/etavth);
  isat     = isata*isatb/(isata+isatb);
  vsate    = isat/gch;
  vdse     = vds*pow(1+pow(vds/vsate,MC),-1.0/MC);
  m        = M0+ALPHA*vgte;
  g        = pow(vds/vsate,m);
  h        = pow(1+g,1.0/m);
  here->MESAdelidgch0 = vds/h;
  delidgch = here->MESAdelidgch0*(1+LAMBDA*vds);
  *cdrain  = gch*delidgch;
  if(vgt > model->MESAvpo)
    temp = 0;
  else
    temp = sqrt(1-vgt/model->MESAvpo);
  cgc      = W*L*EPSILONGAAS/(temp+b)/D;
  c        = (vsate-vdse)/(2*vsate-vdse);
  c        = c*c;
  *capgs   = here->MESAcf+2.0/3.0*cgc*(1-c);
  c        = vsate/(2*vsate-vdse);
  c        = c*c;
  *capgd   = here->MESAcf+2.0/3.0*cgc*(1-c);
  temp     = 1+gchi*rt;
  delgchgchi   = 1.0/(temp*temp);
  delgchins    = here->MESAgchi0*mu;
  delnsvgt     = ns*ns*1.0/here->MESAn0/etavth*b;
  q            = 1 - sqrt1;
  if(sqrt1 == 0)
    delnsvgte = 0;
  else
    delnsvgte = 0.5*ns*ns/(model->MESAvpo*ND*D*sqrt1*q*q);
  delvgtevgt   = 0.5*(1+u/t);
  here->MESAdelidvds0 = gch/h;
  if(vds != 0.0)
    here->MESAdelidvds1 = (*cdrain)*pow(vds/vsate,m-1)/(vsate*(1+g));
  else
    here->MESAdelidvds1 = 0.0;
  delidvds     = here->MESAdelidvds0*(1+2*LAMBDA*vds) - here->MESAdelidvds1;
  delidvsate   = (*cdrain)*g/(vsate*(1+g));
  delvsateisat = 1.0/gch;
  r            = isata+isatb;
  r            = r*r;
  delisatisata = isatb*isatb/r;
  v            = 1.0+1.0/f;
  ddevgte      = 2*beta*RS*v*e+d*TC;
  temp         = d*d*e*e;
  delisatavgte = (2*a*d*e - a*vgte*ddevgte)/temp;
  delisatabeta = 2*vgte*vgte*(d*e-a*e*RS*v)/temp;
  delisatisatb = isata*isata/r;
  delvsategch  = -vsate/gch;
  dvgtvgs      = 1 - SIGMA0*vds*s/VSIGMA/((1+s)*(1+s));
  temp         = here->MESAgchi0*ns*THETA;
  dgchivgt     = delgchins*(delnsvgte*delvgtevgt+delnsvgt)+temp;
  dvgtevds     = delvgtevgt*sigma;
  dgchivds     = delgchins*(delnsvgte*dvgtevds+delnsvgt*sigma)+temp*sigma;
  temp         = delisatabeta*3*beta*vl*THETA/(mu*(model->MESAvpo+3*vl));
  disatavgt    = delisatavgte*delvgtevgt+temp;
  disatavds    = delisatavgte*dvgtevds+temp*sigma;