mesload.c

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

                cgd = csat*(evgd-1)+ckt->CKTgmin*vgd;
            }
            cg = cg+cgd;
            /*
             *   compute drain current and derivitives for normal mode 
             */
            if (vds >= 0) {
                vgst = vgs-model->MESthreshold;
                /*
                 *   normal mode, cutoff region 
                 */
                if (vgst <= 0) {
                    cdrain = 0;
                    gm = 0;
                    gds = 0;
                } else {
                    prod = 1 + model->MESlModulation * vds;
                    betap = beta * prod;
                    denom = 1 + model->MESb * vgst;
                    invdenom = 1 / denom;
                    if (vds >= ( 3 / model->MESalpha ) ) {
                            /*
                             *   normal mode, saturation region 
                             */
                        cdrain = betap * vgst * vgst * invdenom;
                        gm = betap * vgst * (1 + denom) * invdenom * invdenom;
                        gds = model->MESlModulation * beta * vgst * vgst * 
                                invdenom;
                    } else {
                        /*
                         *   normal mode, linear region 
                         */
                        afact = 1 - model->MESalpha * vds / 3;
                        lfact = 1 - afact * afact * afact;
                        cdrain = betap * vgst * vgst * invdenom * lfact;
                        gm = betap * vgst * (1 + denom) * invdenom * invdenom *
                                lfact;
                        gds = beta * vgst * vgst * invdenom * (model->MESalpha *
                            afact * afact * prod + lfact * 
                            model->MESlModulation);
                    }
                }
            } else {
                /*
                 *   compute drain current and derivitives for inverse mode 
                 */
                vgdt = vgd - model->MESthreshold;
                if (vgdt <= 0) {
                    /*
                     *   inverse mode, cutoff region 
                     */
                    cdrain = 0;
                    gm = 0;
                    gds = 0;
                } else {
                    /*
                     *   inverse mode, saturation region 
                     */
                    prod = 1 - model->MESlModulation * vds;
                    betap = beta * prod;
                    denom = 1 + model->MESb * vgdt;
                    invdenom = 1 / denom;
                    if ( -vds >= ( 3 / model->MESalpha ) ) {
                        cdrain = -betap * vgdt * vgdt * invdenom;
                        gm = -betap * vgdt * (1 + denom) * invdenom * invdenom;
                        gds = model->MESlModulation * beta * vgdt * vgdt *
                                 invdenom-gm;
                    } else {
                        /*
                         *  inverse mode, linear region 
                         */
                        afact = 1 + model->MESalpha * vds / 3;
                        lfact = 1 - afact * afact * afact;
                        cdrain = -betap * vgdt * vgdt * invdenom * lfact;
                        gm = -betap * vgdt * (1 + denom) * invdenom * 
                                invdenom * lfact;
                        gds = beta * vgdt * vgdt * invdenom * (model->MESalpha *
                            afact * afact * prod + lfact * 
                            model->MESlModulation)-gm;
                    }
                }
            }
            /*
             *   compute equivalent drain current source 
             */
            cd = cdrain - cgd;
            if ( (ckt->CKTmode & (MODETRAN|MODEINITSMSIG)) ||
                    ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)) ){
                /* 
                 *    charge storage elements 
                 */
                czgs = model->MEScapGS * here->MESarea;
                czgd = model->MEScapGD * here->MESarea;
                phib = model->MESgatePotential;
                vgs1 = *(ckt->CKTstate1 + here->MESvgs);
                vgd1 = *(ckt->CKTstate1 + here->MESvgd);
                vcap = 1 / model->MESalpha;

                qgga = qggnew(vgs,vgd,phib,vcap,vto,czgs,czgd,&cgsna,&cgdna);
                qggb = qggnew(vgs1,vgd,phib,vcap,vto,czgs,czgd,&cgsnb,&cgdnb);
                qggc = qggnew(vgs,vgd1,phib,vcap,vto,czgs,czgd,&cgsnc,&cgdnc);
                qggd = qggnew(vgs1,vgd1,phib,vcap,vto,czgs,czgd,&cgsnd,&cgdnd);

                if(ckt->CKTmode & MODEINITTRAN) {
                    *(ckt->CKTstate1 + here->MESqgs) = qgga;
                    *(ckt->CKTstate1 + here->MESqgd) = qgga;
                }
                *(ckt->CKTstate0+here->MESqgs) = *(ckt->CKTstate1+here->MESqgs)
                        + 0.5 * (qgga-qggb + qggc-qggd);
                *(ckt->CKTstate0+here->MESqgd) = *(ckt->CKTstate1+here->MESqgd)
                        + 0.5 * (qgga-qggc + qggb-qggd);
                capgs = cgsna;
                capgd = cgdna;

                /*
                 *   store small-signal parameters 
                 */
                if( (!(ckt->CKTmode & MODETRANOP)) || 
                        (!(ckt->CKTmode & MODEUIC)) ) {
                    if(ckt->CKTmode & MODEINITSMSIG) {
                        *(ckt->CKTstate0 + here->MESqgs) = capgs;
                        *(ckt->CKTstate0 + here->MESqgd) = capgd;
                        continue; /*go to 1000*/
                    }
                    /*
                     *   transient analysis 
                     */
                    if(ckt->CKTmode & MODEINITTRAN) {
                        *(ckt->CKTstate1 + here->MESqgs) =
                                *(ckt->CKTstate0 + here->MESqgs);
                        *(ckt->CKTstate1 + here->MESqgd) =
                                *(ckt->CKTstate0 + here->MESqgd);
                    }
                    error = NIintegrate(ckt,&geq,&ceq,capgs,here->MESqgs);
                    if(error) return(error);
                    ggs = ggs + geq;
                    cg = cg + *(ckt->CKTstate0 + here->MEScqgs);
                    error = NIintegrate(ckt,&geq,&ceq,capgd,here->MESqgd);
                    if(error) return(error);
                    ggd = ggd + geq;
                    cg = cg + *(ckt->CKTstate0 + here->MEScqgd);
                    cd = cd - *(ckt->CKTstate0 + here->MEScqgd);
                    cgd = cgd + *(ckt->CKTstate0 + here->MEScqgd);
                    if (ckt->CKTmode & MODEINITTRAN) {
                        *(ckt->CKTstate1 + here->MEScqgs) =
                                *(ckt->CKTstate0 + here->MEScqgs);
                        *(ckt->CKTstate1 + here->MEScqgd) =
                                *(ckt->CKTstate0 + here->MEScqgd);
                    }
                }
            }
            /*
             *  check convergence 
             */
            if( (!(ckt->CKTmode & MODEINITFIX)) | (!(ckt->CKTmode & MODEUIC))) {
                if( (icheck == 1) 
#ifndef NEWCONV
/* XXX */
#endif /* NEWCONV */
                        || (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->CKTtroubleElt = (GENinstance *) here;
                }
            }
            *(ckt->CKTstate0 + here->MESvgs) = vgs;
            *(ckt->CKTstate0 + here->MESvgd) = vgd;
            *(ckt->CKTstate0 + here->MEScg) = cg;
            *(ckt->CKTstate0 + here->MEScd) = cd;
            *(ckt->CKTstate0 + here->MEScgd) = cgd;
            *(ckt->CKTstate0 + here->MESgm) = gm;
            *(ckt->CKTstate0 + here->MESgds) = gds;
            *(ckt->CKTstate0 + here->MESggs) = ggs;
            *(ckt->CKTstate0 + here->MESggd) = ggd;
            /*
             *    load current vector
             */
load:
            ceqgd=model->MEStype*(cgd-ggd*vgd);
            ceqgs=model->MEStype*((cg-cgd)-ggs*vgs);
            cdreq=model->MEStype*((cd+cgd)-gds*vds-gm*vgs);
            *(ckt->CKTrhs + here->MESgateNode) += (-ceqgs-ceqgd);
            *(ckt->CKTrhs + here->MESdrainPrimeNode) +=
                    (-cdreq+ceqgd);
            *(ckt->CKTrhs + here->MESsourcePrimeNode) +=
                    (cdreq+ceqgs);
            /*
             *    load y matrix 
             */
            *(here->MESdrainDrainPrimePtr) += (-gdpr);
            *(here->MESgateDrainPrimePtr) += (-ggd);
            *(here->MESgateSourcePrimePtr) += (-ggs);
            *(here->MESsourceSourcePrimePtr) += (-gspr);
            *(here->MESdrainPrimeDrainPtr) += (-gdpr);
            *(here->MESdrainPrimeGatePtr) += (gm-ggd);
            *(here->MESdrainPrimeSourcePrimePtr) += (-gds-gm);
            *(here->MESsourcePrimeGatePtr) += (-ggs-gm);
            *(here->MESsourcePrimeSourcePtr) += (-gspr);
            *(here->MESsourcePrimeDrainPrimePtr) += (-gds);
            *(here->MESdrainDrainPtr) += (gdpr);
            *(here->MESgateGatePtr) += (ggd+ggs);
            *(here->MESsourceSourcePtr) += (gspr);
            *(here->MESdrainPrimeDrainPrimePtr) += (gdpr+gds+ggd);
            *(here->MESsourcePrimeSourcePrimePtr) += (gspr+gds+gm+ggs);
        }
    }
    return(OK);
}


/* function qggnew  - private, used by MESload*/
static double 
qggnew(vgs,vgd,phib,vcap,vto,cgs,cgd,cgsnew,cgdnew)
    double vgs,vgd,phib,vcap,vto,cgs,cgd,*cgsnew,*cgdnew;
{
    double veroot,veff1,veff2,del,vnroot,vnew1,vnew3,vmax,ext;
    double qroot,qggval,par1,cfact,cplus,cminus;

    veroot = sqrt( (vgs - vgd) * (vgs - vgd) + vcap*vcap );
    veff1 = 0.5 * (vgs + vgd + veroot);
    veff2 = veff1 - veroot;
    del = 0.2;
    vnroot = sqrt( (veff1 - vto)*(veff1 - vto) + del * del );
    vnew1 = 0.5 * (veff1 + vto + vnroot);
    vnew3 = vnew1;
    vmax = 0.5;
    if ( vnew1 < vmax ) {
        ext=0;
    } else {
        vnew1 = vmax;
        ext = (vnew3 - vmax)/sqrt(1 - vmax/phib);
    }

    qroot = sqrt(1 - vnew1/phib);
    qggval = cgs * (2*phib*(1-qroot) + ext) + cgd*veff2;
    par1 = 0.5 * ( 1 + (veff1-vto)/vnroot);
    cfact = (vgs- vgd)/veroot;
    cplus = 0.5 * (1 + cfact);
    cminus = cplus - cfact;
    *cgsnew = cgs/qroot*par1*cplus + cgd*cminus;
    *cgdnew = cgs/qroot*par1*cminus + cgd*cplus;
    return(qggval);
}