mesload.c

spice中支持多层次元件模型仿真的可单独运行的插件源码

/**********
Copyright 1990 Regents of the University of California.  All rights reserved.
Author: 1985 S. Hwang
**********/

#include "spice.h"
#include <stdio.h>
#include "util.h"
#include "devdefs.h"
#include "cktdefs.h"
#include "mesdefs.h"
#include "const.h"
#include "trandefs.h"
#include "sperror.h"
#include "suffix.h"

/* forward declaraction of our helper function */
#ifdef __STDC__
static double qggnew(double,double,double,double,double,double,double,
    double*,double*);
#else /* stdc */
static double qggnew();
#endif /* stdc */

int
MESload(inModel,ckt)
    GENmodel *inModel;
    CKTcircuit *ckt;
        /* actually load the current resistance value into the 
         * sparse matrix previously provided 
         */
{
    register MESmodel *model = (MESmodel*)inModel;
    register MESinstance *here;
    double afact;
    double beta;
    double betap;
    double capgd;
    double capgs;
    double cd;
    double cdhat;
    double cdrain;
    double cdreq;
    double ceq;
    double ceqgd;
    double ceqgs;
    double cg;
    double cgd;
    double cgdna,cgdnb,cgdnc,cgdnd;
    double cghat;
    double cgsna,cgsnb,cgsnc,cgsnd;
    double csat;
    double czgd;
    double czgs;
    double delvds;
    double delvgd;
    double delvgs;
    double denom;
    double evgd;
    double evgs;
    double gdpr;
    double gds;
    double geq;
    double ggd;
    double ggs;
    double gm;
    double gspr;
    double invdenom;
    double lfact;
    double phib;
    double prod;
    double qgga,qggb,qggc,qggd;
    double vcap;
    double vcrit;
    double vds;
    double vgd;
    double vgd1;
    double vgdt;
    double vgs;
    double vgs1;
    double vgst;
    double vto;
    double xfact;
    int icheck;
    int ichk1;
    int error;

    /*  loop through all the models */
    for( ; model != NULL; model = model->MESnextModel ) {

        /* loop through all the instances of the model */
        for (here = model->MESinstances; here != NULL ;
                here=here->MESnextInstance) {
	    if (here->MESowner != ARCHme) continue;

            /*
             *  dc model parameters 
             */
            beta = model->MESbeta * here->MESarea;
            gdpr = model->MESdrainConduct * here->MESarea;
            gspr = model->MESsourceConduct * here->MESarea;
            csat = model->MESgateSatCurrent * here->MESarea;
            vcrit = model->MESvcrit;
            vto = model->MESthreshold;
            /*
             *    initialization
             */
            icheck = 1;
            if( ckt->CKTmode & MODEINITSMSIG) {
                vgs = *(ckt->CKTstate0 + here->MESvgs);
                vgd = *(ckt->CKTstate0 + here->MESvgd);
            } else if (ckt->CKTmode & MODEINITTRAN) {
                vgs = *(ckt->CKTstate1 + here->MESvgs);
                vgd = *(ckt->CKTstate1 + here->MESvgd);
            } else if ( (ckt->CKTmode & MODEINITJCT) &&
                    (ckt->CKTmode & MODETRANOP) &&
                    (ckt->CKTmode & MODEUIC) ) {
                vds = model->MEStype*here->MESicVDS;
                vgs = model->MEStype*here->MESicVGS;
                vgd = vgs-vds;
            } else if ( (ckt->CKTmode & MODEINITJCT) &&
                    (here->MESoff == 0)  ) {
                vgs = -1;
                vgd = -1;
            } else if( (ckt->CKTmode & MODEINITJCT) ||
                    ((ckt->CKTmode & MODEINITFIX) && (here->MESoff))) {
                vgs = 0;
                vgd = 0;
            } else {
#ifndef PREDICTOR
                if(ckt->CKTmode & MODEINITPRED) {
                    xfact = ckt->CKTdelta/ckt->CKTdeltaOld[1];
                    *(ckt->CKTstate0 + here->MESvgs) = 
                            *(ckt->CKTstate1 + here->MESvgs);
                    vgs = (1+xfact) * *(ckt->CKTstate1 + here->MESvgs) -
                           xfact * *(ckt->CKTstate2 + here->MESvgs);
                    *(ckt->CKTstate0 + here->MESvgd) = 
                            *(ckt->CKTstate1 + here->MESvgd);
                    vgd = (1+xfact)* *(ckt->CKTstate1 + here->MESvgd) -
                           xfact * *(ckt->CKTstate2 + here->MESvgd);
                    *(ckt->CKTstate0 + here->MEScg) = 
                            *(ckt->CKTstate1 + here->MEScg);
                    *(ckt->CKTstate0 + here->MEScd) = 
                            *(ckt->CKTstate1 + here->MEScd);
                    *(ckt->CKTstate0 + here->MEScgd) =
                            *(ckt->CKTstate1 + here->MEScgd);
                    *(ckt->CKTstate0 + here->MESgm) =
                            *(ckt->CKTstate1 + here->MESgm);
                    *(ckt->CKTstate0 + here->MESgds) =
                            *(ckt->CKTstate1 + here->MESgds);
                    *(ckt->CKTstate0 + here->MESggs) =
                            *(ckt->CKTstate1 + here->MESggs);
                    *(ckt->CKTstate0 + here->MESggd) =
                            *(ckt->CKTstate1 + here->MESggd);
                } else {
#endif /* PREDICTOR */
                    /*
                     *  compute new nonlinear branch voltages 
                     */
                    vgs = model->MEStype*
                        (*(ckt->CKTrhsOld+ here->MESgateNode)-
                        *(ckt->CKTrhsOld+ 
                        here->MESsourcePrimeNode));
                    vgd = model->MEStype*
                        (*(ckt->CKTrhsOld+here->MESgateNode)-
                        *(ckt->CKTrhsOld+
                        here->MESdrainPrimeNode));
#ifndef PREDICTOR
                }
#endif /* PREDICTOR */
                delvgs=vgs - *(ckt->CKTstate0 + here->MESvgs);
                delvgd=vgd - *(ckt->CKTstate0 + here->MESvgd);
                delvds=delvgs - delvgd;
                cghat= *(ckt->CKTstate0 + here->MEScg) + 
                        *(ckt->CKTstate0 + here->MESggd)*delvgd +
                        *(ckt->CKTstate0 + here->MESggs)*delvgs;
                cdhat= *(ckt->CKTstate0 + here->MEScd) +
                        *(ckt->CKTstate0 + here->MESgm)*delvgs +
                        *(ckt->CKTstate0 + here->MESgds)*delvds -
                        *(ckt->CKTstate0 + here->MESggd)*delvgd;
                /*
                 *   bypass if solution has not changed 
                 */
                if((ckt->CKTbypass) &&
                    (!(ckt->CKTmode & MODEINITPRED)) &&
                    (FABS(delvgs) < ckt->CKTreltol*MAX(FABS(vgs),
                        FABS(*(ckt->CKTstate0 + here->MESvgs)))+
                        ckt->CKTvoltTol) )
                if ( (FABS(delvgd) < ckt->CKTreltol*MAX(FABS(vgd),
                        FABS(*(ckt->CKTstate0 + here->MESvgd)))+
                        ckt->CKTvoltTol))
                if ( (FABS(cghat-*(ckt->CKTstate0 + here->MEScg)) 
                        < ckt->CKTreltol*MAX(FABS(cghat),
                        FABS(*(ckt->CKTstate0 + here->MEScg)))+
                        ckt->CKTabstol) ) if ( /* hack - expression too big */
                    (FABS(cdhat-*(ckt->CKTstate0 + here->MEScd))
                        < ckt->CKTreltol*MAX(FABS(cdhat),
                        FABS(*(ckt->CKTstate0 + here->MEScd)))+
                        ckt->CKTabstol) ) {

                    /* we can do a bypass */
                    vgs= *(ckt->CKTstate0 + here->MESvgs);
                    vgd= *(ckt->CKTstate0 + here->MESvgd);
                    vds= vgs-vgd;
                    cg= *(ckt->CKTstate0 + here->MEScg);
                    cd= *(ckt->CKTstate0 + here->MEScd);
                    cgd= *(ckt->CKTstate0 + here->MEScgd);
                    gm= *(ckt->CKTstate0 + here->MESgm);
                    gds= *(ckt->CKTstate0 + here->MESgds);
                    ggs= *(ckt->CKTstate0 + here->MESggs);
                    ggd= *(ckt->CKTstate0 + here->MESggd);
                    goto load;
                }
                /*
                 *  limit nonlinear branch voltages 
                 */
                ichk1=1;
                vgs = DEVpnjlim(vgs,*(ckt->CKTstate0 + here->MESvgs),CONSTvt0,
                        vcrit, &icheck);
                vgd = DEVpnjlim(vgd,*(ckt->CKTstate0 + here->MESvgd),CONSTvt0,
                        vcrit,&ichk1);
                if (ichk1 == 1) {
                    icheck=1;
                }
                vgs = DEVfetlim(vgs,*(ckt->CKTstate0 + here->MESvgs),
                        model->MESthreshold);
                vgd = DEVfetlim(vgd,*(ckt->CKTstate0 + here->MESvgd),
                        model->MESthreshold);
            }
            /*
             *   determine dc current and derivatives 
             */
            vds = vgs-vgd;
            if (vgs <= -5*CONSTvt0) {
                ggs = -csat/vgs+ckt->CKTgmin;
                cg = ggs*vgs;
            } else {
                evgs = exp(vgs/CONSTvt0);
                ggs = csat*evgs/CONSTvt0+ckt->CKTgmin;
                cg = csat*(evgs-1)+ckt->CKTgmin*vgs;
            }
            if (vgd <= -5*CONSTvt0) {
                ggd = -csat/vgd+ckt->CKTgmin;
                cgd = ggd*vgd;
            } else {
                evgd = exp(vgd/CONSTvt0);
                ggd = csat*evgd/CONSTvt0+ckt->CKTgmin;