soi3acld.c

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

/**********
STAG version 2.7
Copyright 2000 owned by the United Kingdom Secretary of State for Defence
acting through the Defence Evaluation and Research Agency.
Developed by :     Jim Benson,
                   Department of Electronics and Computer Science,
                   University of Southampton,
                   United Kingdom.
With help from :   Nele D'Halleweyn, Ketan Mistry, Bill Redman-White,
						 and Craig Easson.

Based on STAG version 2.1
Developed by :     Mike Lee,
With help from :   Bernard Tenbroek, Bill Redman-White, Mike Uren, Chris Edwards
                   and John Bunyan.
Acknowledgements : Rupert Howes and Pete Mole.
**********/

/********** 
Modified by Paolo Nenzi 2002
ngspice integration
**********/

#include "ngspice.h"
#include "cktdefs.h"
#include "soi3defs.h"
#include "sperror.h"
#include "suffix.h"


int
SOI3acLoad(GENmodel *inModel, CKTcircuit *ckt)
{
    SOI3model *model = (SOI3model*)inModel;
    SOI3instance *here;
    int xnrm;
    int xrev;

	 double cgfgf,cgfd,cgfs,cgfdeltaT,cgfgb;
	 double cdgf,cdd,cds,cddeltaT,cdgb;
    double csgf,csd,css,csdeltaT,csgb;
    double cbgf,cbd,cbs,cbdeltaT,cbgb;
    double cgbgf,cgbd,cgbs,cgbdeltaT,cgbgb;

    double xcgfgf,xcgfd,xcgfs,xcgfdeltaT,xcgfgb;
    double xcdgf,xcdd,xcds,xcddeltaT,xcdgb;
    double xcsgf,xcsd,xcss,xcsdeltaT,xcsgb;
    double xcbgf,xcbd,xcbs,xcbdeltaT,xcbgb;
    double xcgbgf,xcgbd,xcgbs,xcgbdeltaT,xcgbgb;

    double capbd,capbs; /* diode capacitances */

    double xcBJTbsbs,xcBJTbsdeltaT;
    double xcBJTbdbd,xcBJTbddeltaT;

    double rtargs[5];
    double grt[5];
    double ctargs[5];
    double xct[5]; /* 1/reactance of thermal cap */
    int tnodeindex;

    double cgfb0;
    double cgfd0;
    double cgfs0;

    double cgbb0;
    double cgbd0;
    double cgbs0;

    double EffectiveLength;

    double omega;

    double m;

    omega = ckt->CKTomega;

    for( ; model != NULL; model = model->SOI3nextModel)
    {
        for(here = model->SOI3instances; here!= NULL;
                here = here->SOI3nextInstance)
        {
        
           if (here->SOI3owner != ARCHme)
                   continue;
	
            if (here->SOI3mode < 0)
            {
                xnrm=0;
                xrev=1;
            }
            else
            {
                xnrm=1;
                xrev=0;
            }

            EffectiveLength=here->SOI3l - 2*model->SOI3latDiff;

            /* JimB - can use basic device geometry to estimate front and back */
            /* overlap capacitances to a first approximation. Use this default */
            /* model if capacitance factors aren't given in model netlist. */

            /* Calculate front gate overlap capacitances. */

        		if(model->SOI3frontGateSourceOverlapCapFactorGiven)
            {
               cgfs0 = model->SOI3frontGateSourceOverlapCapFactor * here->SOI3w;
        		}
            else
            {
               cgfs0 = model->SOI3latDiff * here->SOI3w * model->SOI3frontOxideCapFactor;
            }
        		if(model->SOI3frontGateDrainOverlapCapFactorGiven)
            {
				   cgfd0 = model->SOI3frontGateDrainOverlapCapFactor * here->SOI3w;
        		}
            else
            {
               cgfd0 = model->SOI3latDiff * here->SOI3w * model->SOI3frontOxideCapFactor;
            }
        		if(model->SOI3frontGateBulkOverlapCapFactorGiven)
            {
               cgfb0 = model->SOI3frontGateBulkOverlapCapFactor * EffectiveLength;
            }
            else
            {
               cgfb0 = EffectiveLength * (0.1*1e-6*model->SOI3minimumFeatureSize)
               			* model->SOI3frontOxideCapFactor;
            }

            /* Calculate back gate overlap capacitances. */

        		if( (model->SOI3backGateSourceOverlapCapAreaFactorGiven) &&
            (!model->SOI3backGateSourceOverlapCapAreaFactor || here->SOI3asGiven) )
            {
               cgbs0 = model->SOI3backGateSourceOverlapCapAreaFactor * here->SOI3as;
        		}
            else
            {
               cgbs0 = (2*1e-6*model->SOI3minimumFeatureSize + model->SOI3latDiff) * here->SOI3w
               			* model->SOI3backOxideCapFactor;
            }
        		if( (model->SOI3backGateDrainOverlapCapAreaFactorGiven) &&
            (!model->SOI3backGateDrainOverlapCapAreaFactor || here->SOI3adGiven) )
            {
               cgbd0 = model->SOI3backGateDrainOverlapCapAreaFactor * here->SOI3ad;
        		}
            else
            {
               cgbd0 = (2*1e-6*model->SOI3minimumFeatureSize + model->SOI3latDiff) * here->SOI3w
               			* model->SOI3backOxideCapFactor;
            }
        		if( (model->SOI3backGateBulkOverlapCapAreaFactorGiven) &&
            (!model->SOI3backGateBulkOverlapCapAreaFactor || here->SOI3abGiven) )
            {
               cgbb0 = model->SOI3backGateBulkOverlapCapAreaFactor * here->SOI3ab;
            }
            else
            {
               cgbb0 = EffectiveLength * (0.1*1e-6*model->SOI3minimumFeatureSize + here->SOI3w)
               			* model->SOI3backOxideCapFactor;
            }

            capbd = here->SOI3capbd;
            capbs = here->SOI3capbs;

            cgfgf = *(ckt->CKTstate0 + here->SOI3cgfgf);
            cgfd  = *(ckt->CKTstate0 + here->SOI3cgfd);
            cgfs  = *(ckt->CKTstate0 + here->SOI3cgfs);
            cgfdeltaT  = *(ckt->CKTstate0 + here->SOI3cgfdeltaT);
            cgfgb = *(ckt->CKTstate0 + here->SOI3cgfgb);
            csgf = *(ckt->CKTstate0 + here->SOI3csgf);
            csd  = *(ckt->CKTstate0 + here->SOI3csd);
            css  = *(ckt->CKTstate0 + here->SOI3css);
            csdeltaT  = *(ckt->CKTstate0 + here->SOI3csdeltaT);
            csgb = *(ckt->CKTstate0 + here->SOI3csgb);
            cdgf = *(ckt->CKTstate0 + here->SOI3cdgf);
            cdd  = *(ckt->CKTstate0 + here->SOI3cdd);
            cds  = *(ckt->CKTstate0 + here->SOI3cds);
            cddeltaT  = *(ckt->CKTstate0 + here->SOI3cddeltaT);
            cdgb  = *(ckt->CKTstate0 + here->SOI3cdgb);
            cgbgf = *(ckt->CKTstate0 + here->SOI3cgbgf);
            cgbd  = *(ckt->CKTstate0 + here->SOI3cgbd);
            cgbs  = *(ckt->CKTstate0 + here->SOI3cgbs);
            cgbdeltaT  = *(ckt->CKTstate0 + here->SOI3cgbdeltaT);
            cgbgb = *(ckt->CKTstate0 + here->SOI3cgbgb);
            cbgf = -(cgfgf + cdgf + csgf + cgbgf);
            cbd = -(cgfd + cdd + csd + cgbd);
            cbs = -(cgfs + cds + css + cgbs);
            cbdeltaT = -(cgfdeltaT + cddeltaT + csdeltaT + cgbdeltaT);
            cbgb = -(cgfgb + cdgb + csgb + cgbgb);

				xcgfgf = (cgfgf + cgfd0 + cgfs0 + cgfb0) * omega;
				xcgfd  = (cgfd - cgfd0) * omega;
				xcgfs  = (cgfs - cgfs0) * omega;
				xcgfdeltaT = cgfdeltaT * omega;
				xcgfgb = cgfgb * omega;
				xcdgf = (cdgf - cgfd0) * omega;
				xcdd  = (cdd + capbd + cgfd0 + cgbd0) * omega;
				xcds  = cds * omega;
				xcddeltaT = cddeltaT * omega;
				xcdgb = (cdgb - cgbd0) * omega;
				xcsgf = (csgf - cgfs0) * omega;
				xcsd  = csd * omega;
				xcss  = (css + capbs + cgfs0 + cgbs0) * omega;
				xcsdeltaT = csdeltaT * omega;
				xcsgb = (csgb - cgbs0) * omega;
				xcbgf = (cbgf - cgfb0) * omega;
            xcbd = (cbd - capbd) * omega;
            xcbs = (cbs - capbs) * omega;
				xcbdeltaT = cbdeltaT * omega;
				xcbgb = (cbgb - cgbb0) * omega;
				xcgbgf = cgbgf * omega;
				xcgbd  = (cgbd - cgbd0) * omega;
				xcgbs  = (cgbs - cgbs0) * omega;
				xcgbdeltaT = cgbdeltaT * omega;
				xcgbgb = (cgbgb + cgbd0 + cgbs0 + cgbb0) * omega;

            xcBJTbsbs = *(ckt->CKTstate0 + here->SOI3cBJTbsbs) * omega;
            xcBJTbsdeltaT = *(ckt->CKTstate0 + here->SOI3cBJTbsdeltaT) * omega;
            xcBJTbdbd = *(ckt->CKTstate0 + here->SOI3cBJTbdbd) * omega;
            xcBJTbddeltaT = *(ckt->CKTstate0 + here->SOI3cBJTbddeltaT) * omega;

            /* JimB - 15/9/99 */