b3v1set.c

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

        if (!model->BSIM3v1palpha0Given)  
            model->BSIM3v1palpha0 = 0.0;
        if (!model->BSIM3v1pbeta0Given)  
            model->BSIM3v1pbeta0 = 0.0;

        if (!model->BSIM3v1pelmGiven)  
            model->BSIM3v1pelm = 0.0;
        if (!model->BSIM3v1pcgslGiven)  
            model->BSIM3v1pcgsl = 0.0;
        if (!model->BSIM3v1pcgdlGiven)  
            model->BSIM3v1pcgdl = 0.0;
        if (!model->BSIM3v1pckappaGiven)  
            model->BSIM3v1pckappa = 0.0;
        if (!model->BSIM3v1pcfGiven)  
            model->BSIM3v1pcf = 0.0;
        if (!model->BSIM3v1pclcGiven)  
            model->BSIM3v1pclc = 0.0;
        if (!model->BSIM3v1pcleGiven)  
            model->BSIM3v1pcle = 0.0;
        if (!model->BSIM3v1pvfbcvGiven)  
            model->BSIM3v1pvfbcv = 0.0;

        /* unit degree celcius */
        if (!model->BSIM3v1tnomGiven)  
	    model->BSIM3v1tnom = ckt->CKTnomTemp;    
        if (!model->BSIM3v1LintGiven)  
           model->BSIM3v1Lint = 0.0;
        if (!model->BSIM3v1LlGiven)  
           model->BSIM3v1Ll = 0.0;
        if (!model->BSIM3v1LlnGiven)  
           model->BSIM3v1Lln = 1.0;
        if (!model->BSIM3v1LwGiven)  
           model->BSIM3v1Lw = 0.0;
        if (!model->BSIM3v1LwnGiven)  
           model->BSIM3v1Lwn = 1.0;
        if (!model->BSIM3v1LwlGiven)  
           model->BSIM3v1Lwl = 0.0;
        if (!model->BSIM3v1LminGiven)  
           model->BSIM3v1Lmin = 0.0;
        if (!model->BSIM3v1LmaxGiven)  
           model->BSIM3v1Lmax = 1.0;
        if (!model->BSIM3v1WintGiven)  
           model->BSIM3v1Wint = 0.0;
        if (!model->BSIM3v1WlGiven)  
           model->BSIM3v1Wl = 0.0;
        if (!model->BSIM3v1WlnGiven)  
           model->BSIM3v1Wln = 1.0;
        if (!model->BSIM3v1WwGiven)  
           model->BSIM3v1Ww = 0.0;
        if (!model->BSIM3v1WwnGiven)  
           model->BSIM3v1Wwn = 1.0;
        if (!model->BSIM3v1WwlGiven)  
           model->BSIM3v1Wwl = 0.0;
        if (!model->BSIM3v1WminGiven)  
           model->BSIM3v1Wmin = 0.0;
        if (!model->BSIM3v1WmaxGiven)  
           model->BSIM3v1Wmax = 1.0;
        if (!model->BSIM3v1dwcGiven)  
           model->BSIM3v1dwc = model->BSIM3v1Wint;
        if (!model->BSIM3v1dlcGiven)  
           model->BSIM3v1dlc = model->BSIM3v1Lint;
	if (!model->BSIM3v1cfGiven)
            model->BSIM3v1cf = 2.0 * EPSOX / PI
			   * log(1.0 + 0.4e-6 / model->BSIM3v1tox);
        if (!model->BSIM3v1cgdoGiven)
	{   if (model->BSIM3v1dlcGiven && (model->BSIM3v1dlc > 0.0))
	    {   model->BSIM3v1cgdo = model->BSIM3v1dlc * model->BSIM3v1cox
				 - model->BSIM3v1cgdl ;
	    }
	    else
	        model->BSIM3v1cgdo = 0.6 * model->BSIM3v1xj * model->BSIM3v1cox; 
	}
        if (!model->BSIM3v1cgsoGiven)
	{   if (model->BSIM3v1dlcGiven && (model->BSIM3v1dlc > 0.0))
	    {   model->BSIM3v1cgso = model->BSIM3v1dlc * model->BSIM3v1cox
				 - model->BSIM3v1cgsl ;
	    }
	    else
	        model->BSIM3v1cgso = 0.6 * model->BSIM3v1xj * model->BSIM3v1cox; 
	}

        if (!model->BSIM3v1cgboGiven)
	{   model->BSIM3v1cgbo = 2.0 * model->BSIM3v1dwc * model->BSIM3v1cox;
	}
        if (!model->BSIM3v1xpartGiven)
            model->BSIM3v1xpart = 0.0;
        if (!model->BSIM3v1sheetResistanceGiven)
            model->BSIM3v1sheetResistance = 0.0;
        if (!model->BSIM3v1unitAreaJctCapGiven)
            model->BSIM3v1unitAreaJctCap = 5.0E-4;
        if (!model->BSIM3v1unitLengthSidewallJctCapGiven)
            model->BSIM3v1unitLengthSidewallJctCap = 5.0E-10;
        if (!model->BSIM3v1unitLengthGateSidewallJctCapGiven)
            model->BSIM3v1unitLengthGateSidewallJctCap = model->BSIM3v1unitLengthSidewallJctCap ;
        if (!model->BSIM3v1jctSatCurDensityGiven)
            model->BSIM3v1jctSatCurDensity = 1.0E-4;
        if (!model->BSIM3v1jctSidewallSatCurDensityGiven)
            model->BSIM3v1jctSidewallSatCurDensity = 0.0;
        if (!model->BSIM3v1bulkJctPotentialGiven)
            model->BSIM3v1bulkJctPotential = 1.0;
        if (!model->BSIM3v1sidewallJctPotentialGiven)
            model->BSIM3v1sidewallJctPotential = 1.0;
        if (!model->BSIM3v1GatesidewallJctPotentialGiven)
            model->BSIM3v1GatesidewallJctPotential = model->BSIM3v1sidewallJctPotential;
        if (!model->BSIM3v1bulkJctBotGradingCoeffGiven)
            model->BSIM3v1bulkJctBotGradingCoeff = 0.5;
        if (!model->BSIM3v1bulkJctSideGradingCoeffGiven)
            model->BSIM3v1bulkJctSideGradingCoeff = 0.33;
        if (!model->BSIM3v1bulkJctGateSideGradingCoeffGiven)
            model->BSIM3v1bulkJctGateSideGradingCoeff = model->BSIM3v1bulkJctSideGradingCoeff;
        if (!model->BSIM3v1jctEmissionCoeffGiven)
            model->BSIM3v1jctEmissionCoeff = 1.0;
        if (!model->BSIM3v1jctTempExponentGiven)
            model->BSIM3v1jctTempExponent = 3.0;
        if (!model->BSIM3v1oxideTrapDensityAGiven)
        if (!model->BSIM3v1oxideTrapDensityAGiven)
	{   if (model->BSIM3v1type == NMOS)
                model->BSIM3v1oxideTrapDensityA = 1e20;
            else
                model->BSIM3v1oxideTrapDensityA=9.9e18;
	}
        if (!model->BSIM3v1oxideTrapDensityBGiven)
	{   if (model->BSIM3v1type == NMOS)
                model->BSIM3v1oxideTrapDensityB = 5e4;
            else
                model->BSIM3v1oxideTrapDensityB = 2.4e3;
	}
        if (!model->BSIM3v1oxideTrapDensityCGiven)
	{   if (model->BSIM3v1type == NMOS)
                model->BSIM3v1oxideTrapDensityC = -1.4e-12;
            else
                model->BSIM3v1oxideTrapDensityC = 1.4e-12;

	}
        if (!model->BSIM3v1emGiven)
            model->BSIM3v1em = 4.1e7; /* V/m */
        if (!model->BSIM3v1efGiven)
            model->BSIM3v1ef = 1.0;
        if (!model->BSIM3v1afGiven)
            model->BSIM3v1af = 1.0;
        if (!model->BSIM3v1kfGiven)
            model->BSIM3v1kf = 0.0;
        /* loop through all the instances of the model */
        for (here = model->BSIM3v1instances; here != NULL ;
             here=here->BSIM3v1nextInstance) 
	{   
	    if (here->BSIM3v1owner == ARCHme)
            {   
	          /* allocate a chunk of the state vector */
                  here->BSIM3v1states = *states;
                  *states += BSIM3v1numStates;
	    }
	    
            /* perform the parameter defaulting */
            if (!here->BSIM3v1drainAreaGiven)
                here->BSIM3v1drainArea = 0.0;
            if (!here->BSIM3v1drainPerimeterGiven)
                here->BSIM3v1drainPerimeter = 0.0;
            if (!here->BSIM3v1drainSquaresGiven)
                here->BSIM3v1drainSquares = 1.0;
            if (!here->BSIM3v1icVBSGiven)
                here->BSIM3v1icVBS = 0;
            if (!here->BSIM3v1icVDSGiven)
                here->BSIM3v1icVDS = 0;
            if (!here->BSIM3v1icVGSGiven)
                here->BSIM3v1icVGS = 0;
            if (!here->BSIM3v1lGiven)
                here->BSIM3v1l = 5e-6;
            if (!here->BSIM3v1sourceAreaGiven)
                here->BSIM3v1sourceArea = 0;
            if (!here->BSIM3v1sourcePerimeterGiven)
                here->BSIM3v1sourcePerimeter = 0;
            if (!here->BSIM3v1sourceSquaresGiven)
                here->BSIM3v1sourceSquares = 1;
            if (!here->BSIM3v1wGiven)
                here->BSIM3v1w = 5e-6;

            if (!here->BSIM3v1mGiven)
                here->BSIM3v1m = 1;
		
            if (!here->BSIM3v1nqsModGiven)
                here->BSIM3v1nqsMod = model->BSIM3v1nqsMod;
                    
            /* process drain series resistance */
            if ((model->BSIM3v1sheetResistance > 0.0) && 
                (here->BSIM3v1drainSquares > 0.0 ) &&
                (here->BSIM3v1dNodePrime == 0))
	    {   error = CKTmkVolt(ckt,&tmp,here->BSIM3v1name,"drain");
                if(error) return(error);
                here->BSIM3v1dNodePrime = tmp->number;
                
		if (ckt->CKTcopyNodesets) {
                  if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) {
                     if (tmpNode->nsGiven) {
                       tmp->nodeset=tmpNode->nodeset; 
                       tmp->nsGiven=tmpNode->nsGiven; 
                     }
                  }
                }		
            
	    }
	    else
	    {   here->BSIM3v1dNodePrime = here->BSIM3v1dNode;
            }
                   
            /* process source series resistance */
            if ((model->BSIM3v1sheetResistance > 0.0) && 
                (here->BSIM3v1sourceSquares > 0.0 ) &&
                (here->BSIM3v1sNodePrime == 0)) 
	    {   error = CKTmkVolt(ckt,&tmp,here->BSIM3v1name,"source");
                if(error) return(error);
                here->BSIM3v1sNodePrime = tmp->number;

                if (ckt->CKTcopyNodesets) {
                  if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) {
                     if (tmpNode->nsGiven) {
                       tmp->nodeset=tmpNode->nodeset; 
                       tmp->nsGiven=tmpNode->nsGiven; 
                     }
                  }
                }
				
            }
	    else 
	    {   here->BSIM3v1sNodePrime = here->BSIM3v1sNode;
            }

 /* internal charge node */
                   
            if ((here->BSIM3v1nqsMod) && (here->BSIM3v1qNode == 0)) 
	    {   error = CKTmkVolt(ckt,&tmp,here->BSIM3v1name,"charge");
                if(error) return(error);
                here->BSIM3v1qNode = tmp->number;
            }
	    else 
	    {   here->BSIM3v1qNode = 0;
            }

        /* set Sparse Matrix Pointers */

/* macro to make elements with built in test for out of memory */
#define TSTALLOC(ptr,first,second) \
if((here->ptr = SMPmakeElt(matrix,here->first,here->second))==(double *)NULL){\
    return(E_NOMEM);\
}

            TSTALLOC(BSIM3v1DdPtr, BSIM3v1dNode, BSIM3v1dNode)
            TSTALLOC(BSIM3v1GgPtr, BSIM3v1gNode, BSIM3v1gNode)
            TSTALLOC(BSIM3v1SsPtr, BSIM3v1sNode, BSIM3v1sNode)
            TSTALLOC(BSIM3v1BbPtr, BSIM3v1bNode, BSIM3v1bNode)
            TSTALLOC(BSIM3v1DPdpPtr, BSIM3v1dNodePrime, BSIM3v1dNodePrime)
            TSTALLOC(BSIM3v1SPspPtr, BSIM3v1sNodePrime, BSIM3v1sNodePrime)
            TSTALLOC(BSIM3v1DdpPtr, BSIM3v1dNode, BSIM3v1dNodePrime)
            TSTALLOC(BSIM3v1GbPtr, BSIM3v1gNode, BSIM3v1bNode)
            TSTALLOC(BSIM3v1GdpPtr, BSIM3v1gNode, BSIM3v1dNodePrime)
            TSTALLOC(BSIM3v1GspPtr, BSIM3v1gNode, BSIM3v1sNodePrime)
            TSTALLOC(BSIM3v1SspPtr, BSIM3v1sNode, BSIM3v1sNodePrime)
            TSTALLOC(BSIM3v1BdpPtr, BSIM3v1bNode, BSIM3v1dNodePrime)
            TSTALLOC(BSIM3v1BspPtr, BSIM3v1bNode, BSIM3v1sNodePrime)
            TSTALLOC(BSIM3v1DPspPtr, BSIM3v1dNodePrime, BSIM3v1sNodePrime)
            TSTALLOC(BSIM3v1DPdPtr, BSIM3v1dNodePrime, BSIM3v1dNode)
            TSTALLOC(BSIM3v1BgPtr, BSIM3v1bNode, BSIM3v1gNode)
            TSTALLOC(BSIM3v1DPgPtr, BSIM3v1dNodePrime, BSIM3v1gNode)
            TSTALLOC(BSIM3v1SPgPtr, BSIM3v1sNodePrime, BSIM3v1gNode)
            TSTALLOC(BSIM3v1SPsPtr, BSIM3v1sNodePrime, BSIM3v1sNode)
            TSTALLOC(BSIM3v1DPbPtr, BSIM3v1dNodePrime, BSIM3v1bNode)
            TSTALLOC(BSIM3v1SPbPtr, BSIM3v1sNodePrime, BSIM3v1bNode)
            TSTALLOC(BSIM3v1SPdpPtr, BSIM3v1sNodePrime, BSIM3v1dNodePrime)

            TSTALLOC(BSIM3v1QqPtr, BSIM3v1qNode, BSIM3v1qNode)
 
            TSTALLOC(BSIM3v1QdpPtr, BSIM3v1qNode, BSIM3v1dNodePrime)
            TSTALLOC(BSIM3v1QspPtr, BSIM3v1qNode, BSIM3v1sNodePrime)
            TSTALLOC(BSIM3v1QgPtr, BSIM3v1qNode, BSIM3v1gNode)
            TSTALLOC(BSIM3v1QbPtr, BSIM3v1qNode, BSIM3v1bNode)
            TSTALLOC(BSIM3v1DPqPtr, BSIM3v1dNodePrime, BSIM3v1qNode)
            TSTALLOC(BSIM3v1SPqPtr, BSIM3v1sNodePrime, BSIM3v1qNode)
            TSTALLOC(BSIM3v1GqPtr, BSIM3v1gNode, BSIM3v1qNode)
            TSTALLOC(BSIM3v1BqPtr, BSIM3v1bNode, BSIM3v1qNode)

        }
    }
    return(OK);
}  


int
BSIM3v1unsetup(GENmodel *inModel, CKTcircuit *ckt)
{
    BSIM3v1model *model;
    BSIM3v1instance *here;

    for (model = (BSIM3v1model *)inModel; model != NULL;
            model = model->BSIM3v1nextModel)
    {
        for (here = model->BSIM3v1instances; here != NULL;
                here=here->BSIM3v1nextInstance)
        {
            if (here->BSIM3v1dNodePrime
                    && here->BSIM3v1dNodePrime != here->BSIM3v1dNode)
            {
                CKTdltNNum(ckt, here->BSIM3v1dNodePrime);
                here->BSIM3v1dNodePrime = 0;
            }
            if (here->BSIM3v1sNodePrime
                    && here->BSIM3v1sNodePrime != here->BSIM3v1sNode)
            {
                CKTdltNNum(ckt, here->BSIM3v1sNodePrime);
                here->BSIM3v1sNodePrime = 0;
            }
        }
    }
    return OK;
}