b3soipdset.c

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

            if (!here->B3SOIPDaebcpGiven)
                here->B3SOIPDaebcp = 0;

            if (!here->B3SOIPDoffGiven)
                here->B3SOIPDoff = 0;

            /* process drain series resistance */
            if ((model->B3SOIPDsheetResistance > 0.0) && 
                (here->B3SOIPDdrainSquares > 0.0 ) &&
                (here->B3SOIPDdNodePrime == 0))
	    {   error = CKTmkVolt(ckt,&tmp,here->B3SOIPDname,"drain");
                if(error) return(error);
                here->B3SOIPDdNodePrime = 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->B3SOIPDdNodePrime = here->B3SOIPDdNode;
            }
                   
            /* process source series resistance */
            if ((model->B3SOIPDsheetResistance > 0.0) && 
                (here->B3SOIPDsourceSquares > 0.0 ) &&
                (here->B3SOIPDsNodePrime == 0)) 
	    {   error = CKTmkVolt(ckt,&tmp,here->B3SOIPDname,"source");
                if(error) return(error);
                here->B3SOIPDsNodePrime = 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->B3SOIPDsNodePrime = here->B3SOIPDsNode;
            }

            /* process effective silicon film thickness */
            model->B3SOIPDcbox = 3.453133e-11 / model->B3SOIPDtbox;
            model->B3SOIPDcsi = 1.03594e-10 / model->B3SOIPDtsi;
            Cboxt = model->B3SOIPDcbox * model->B3SOIPDcsi / (model->B3SOIPDcbox + model->B3SOIPDcsi);
            model->B3SOIPDqsi = Charge_q*model->B3SOIPDnpeak*1e6*model->B3SOIPDtsi;


            here->B3SOIPDfloat = 0;
            if (here->B3SOIPDpNode == -1) {  /*  floating body case -- 4-node  */
                error = CKTmkVolt(ckt,&tmp,here->B3SOIPDname,"Body");
                if (error) return(error);
                here->B3SOIPDbNode = tmp->number;
                here->B3SOIPDpNode = 0; 
                here->B3SOIPDfloat = 1;
                here->B3SOIPDbodyMod = 0;
            }
            else /* the 5th Node has been assigned */
            {
              if (!here->B3SOIPDtnodeoutGiven) { /* if t-node not assigned  */
                 if (here->B3SOIPDbNode == -1)
                 { /* 5-node body tie, bNode has not been assigned */
                    if ((model->B3SOIPDrbody == 0.0) && (model->B3SOIPDrbsh == 0.0))
                    { /* ideal body tie, pNode is not used */
                       here->B3SOIPDbNode = here->B3SOIPDpNode;
                       here->B3SOIPDbodyMod = 2;
                    }
                    else { /* nonideal body tie */
                      error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Body");
                      if (error) return(error);
                      here->B3SOIPDbNode = tmp->number;
                      here->B3SOIPDbodyMod = 1;
                    }
                 }
                 else { /* 6-node body tie, bNode has been assigned */
                    if ((model->B3SOIPDrbody == 0.0) && (model->B3SOIPDrbsh == 0.0))
                    { 
                       printf("\n      Warning: model parameter rbody=0!\n");
                       model->B3SOIPDrbody = 1e0;
                       here->B3SOIPDbodyMod = 1;
                    }
                    else { /* nonideal body tie */
                        here->B3SOIPDbodyMod = 1;
                    }
                 }
              }
              else {    /*  t-node assigned   */
                 if (here->B3SOIPDbNode == -1)
                 { /* 4 nodes & t-node, floating body */
                    error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Body");
                    if (error) return(error);
                    here->B3SOIPDbNode = tmp->number;
                    here->B3SOIPDtempNode = here->B3SOIPDpNode;
                    here->B3SOIPDpNode = 0; 
                    here->B3SOIPDfloat = 1;
                    here->B3SOIPDbodyMod = 0;
                 }
                 else { /* 5 or 6 nodes & t-node, body-contact device */
                   if (here->B3SOIPDtempNode == -1) { /* 5 nodes & tnode */
                     if ((model->B3SOIPDrbody == 0.0) && (model->B3SOIPDrbsh == 0.0))
                     { /* ideal body tie, pNode is not used */
                        here->B3SOIPDtempNode = here->B3SOIPDbNode;
                        here->B3SOIPDbNode = here->B3SOIPDpNode;
                        here->B3SOIPDbodyMod = 2;
                     }
                     else { /* nonideal body tie */
                       here->B3SOIPDtempNode = here->B3SOIPDbNode;
                       error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Body");
                       if (error) return(error);
                       here->B3SOIPDbNode = tmp->number;
                       here->B3SOIPDbodyMod = 1;
                     }
                   }
                   else {  /* 6 nodes & t-node */
                     if ((model->B3SOIPDrbody == 0.0) && (model->B3SOIPDrbsh == 0.0))
                     { 
                        printf("\n      Warning: model parameter rbody=0!\n");
                        model->B3SOIPDrbody = 1e0;
                        here->B3SOIPDbodyMod = 1;
                     }
                     else { /* nonideal body tie */
                        here->B3SOIPDbodyMod = 1;
                     }
                   }
                 }
              }
            }


            if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0!=0))
            {
               if (here->B3SOIPDtempNode == -1) {
	          error = CKTmkVolt(ckt,&tmp,here->B3SOIPDname,"Temp");
                  if (error) return(error);
                     here->B3SOIPDtempNode = tmp->number;
               }

            } else {
                here->B3SOIPDtempNode = 0;
            }

/* here for debugging purpose only */
            if (here->B3SOIPDdebugMod != 0)
            {
               /* The real Vbs value */
               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Vbs");
               if(error) return(error);
               here->B3SOIPDvbsNode = tmp->number;   

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Ids");
               if(error) return(error);
               here->B3SOIPDidsNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Ic");
               if(error) return(error);
               here->B3SOIPDicNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Ibs");
               if(error) return(error);
               here->B3SOIPDibsNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Ibd");
               if(error) return(error);
               here->B3SOIPDibdNode = tmp->number;
       
               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Iii");
               if(error) return(error);
               here->B3SOIPDiiiNode = tmp->number;
     
               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Ig");
               if(error) return(error);
               here->B3SOIPDigNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Gigg");
               if(error) return(error);
               here->B3SOIPDgiggNode = tmp->number;
               
               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Gigd");
               if(error) return(error);
               here->B3SOIPDgigdNode = tmp->number;
              
               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Gigb");
               if(error) return(error);
               here->B3SOIPDgigbNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Igidl");
               if(error) return(error);
               here->B3SOIPDigidlNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Itun");
               if(error) return(error);
               here->B3SOIPDitunNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Ibp");
               if(error) return(error);
               here->B3SOIPDibpNode = tmp->number;
       
               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Cbb");
               if(error) return(error);
               here->B3SOIPDcbbNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Cbd");
               if(error) return(error);
               here->B3SOIPDcbdNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Cbg");
               if(error) return(error);
               here->B3SOIPDcbgNode = tmp->number;


               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Qbf");
               if(error) return(error);
               here->B3SOIPDqbfNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Qjs");
               if(error) return(error);
               here->B3SOIPDqjsNode = tmp->number;

               error = CKTmkVolt(ckt, &tmp, here->B3SOIPDname, "Qjd");
               if(error) return(error);
               here->B3SOIPDqjdNode = tmp->number;

           }

        /* 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);\
}


        if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0!=0.0)) {
            TSTALLOC(B3SOIPDTemptempPtr, B3SOIPDtempNode, B3SOIPDtempNode)
            TSTALLOC(B3SOIPDTempdpPtr, B3SOIPDtempNode, B3SOIPDdNodePrime)
            TSTALLOC(B3SOIPDTempspPtr, B3SOIPDtempNode, B3SOIPDsNodePrime)
            TSTALLOC(B3SOIPDTempgPtr, B3SOIPDtempNode, B3SOIPDgNode)
            TSTALLOC(B3SOIPDTempbPtr, B3SOIPDtempNode, B3SOIPDbNode)

            TSTALLOC(B3SOIPDGtempPtr, B3SOIPDgNode, B3SOIPDtempNode)
            TSTALLOC(B3SOIPDDPtempPtr, B3SOIPDdNodePrime, B3SOIPDtempNode)
            TSTALLOC(B3SOIPDSPtempPtr, B3SOIPDsNodePrime, B3SOIPDtempNode)
            TSTALLOC(B3SOIPDEtempPtr, B3SOIPDeNode, B3SOIPDtempNode)
            TSTALLOC(B3SOIPDBtempPtr, B3SOIPDbNode, B3SOIPDtempNode)

            if (here->B3SOIPDbodyMod == 1) {
                TSTALLOC(B3SOIPDPtempPtr, B3SOIPDpNode, B3SOIPDtempNode)
            }
        }
        if (here->B3SOIPDbodyMod == 2) {
            /* Don't create any Jacobian entry for pNode */
        }
        else if (here->B3SOIPDbodyMod == 1) {
            TSTALLOC(B3SOIPDBpPtr, B3SOIPDbNode, B3SOIPDpNode)
            TSTALLOC(B3SOIPDPbPtr, B3SOIPDpNode, B3SOIPDbNode)
            TSTALLOC(B3SOIPDPpPtr, B3SOIPDpNode, B3SOIPDpNode)
        }

        TSTALLOC(B3SOIPDEbPtr, B3SOIPDeNode, B3SOIPDbNode)
        TSTALLOC(B3SOIPDGbPtr, B3SOIPDgNode, B3SOIPDbNode)
        TSTALLOC(B3SOIPDDPbPtr, B3SOIPDdNodePrime, B3SOIPDbNode)
        TSTALLOC(B3SOIPDSPbPtr, B3SOIPDsNodePrime, B3SOIPDbNode)
        TSTALLOC(B3SOIPDBePtr, B3SOIPDbNode, B3SOIPDeNode)
        TSTALLOC(B3SOIPDBgPtr, B3SOIPDbNode, B3SOIPDgNode)
        TSTALLOC(B3SOIPDBdpPtr, B3SOIPDbNode, B3SOIPDdNodePrime)
        TSTALLOC(B3SOIPDBspPtr, B3SOIPDbNode, B3SOIPDsNodePrime)
        TSTALLOC(B3SOIPDBbPtr, B3SOIPDbNode, B3SOIPDbNode)

        TSTALLOC(B3SOIPDEgPtr, B3SOIPDeNode, B3SOIPDgNode)
        TSTALLOC(B3SOIPDEdpPtr, B3SOIPDeNode, B3SOIPDdNodePrime)
        TSTALLOC(B3SOIPDEspPtr, B3SOIPDeNode, B3SOIPDsNodePrime)
        TSTALLOC(B3SOIPDGePtr, B3SOIPDgNode, B3SOIPDeNode)
        TSTALLOC(B3SOIPDDPePtr, B3SOIPDdNodePrime, B3SOIPDeNode)
        TSTALLOC(B3SOIPDSPePtr, B3SOIPDsNodePrime, B3SOIPDeNode)

        TSTALLOC(B3SOIPDEbPtr, B3SOIPDeNode, B3SOIPDbNode)
        TSTALLOC(B3SOIPDEePtr, B3SOIPDeNode, B3SOIPDeNode)

        TSTALLOC(B3SOIPDGgPtr, B3SOIPDgNode, B3SOIPDgNode)
        TSTALLOC(B3SOIPDGdpPtr, B3SOIPDgNode, B3SOIPDdNodePrime)
        TSTALLOC(B3SOIPDGspPtr, B3SOIPDgNode, B3SOIPDsNodePrime)

        TSTALLOC(B3SOIPDDPgPtr, B3SOIPDdNodePrime, B3SOIPDgNode)
        TSTALLOC(B3SOIPDDPdpPtr, B3SOIPDdNodePrime, B3SOIPDdNodePrime)
        TSTALLOC(B3SOIPDDPspPtr, B3SOIPDdNodePrime, B3SOIPDsNodePrime)
        TSTALLOC(B3SOIPDDPdPtr, B3SOIPDdNodePrime, B3SOIPDdNode)

        TSTALLOC(B3SOIPDSPgPtr, B3SOIPDsNodePrime, B3SOIPDgNode)
        TSTALLOC(B3SOIPDSPdpPtr, B3SOIPDsNodePrime, B3SOIPDdNodePrime)
        TSTALLOC(B3SOIPDSPspPtr, B3SOIPDsNodePrime, B3SOIPDsNodePrime)
        TSTALLOC(B3SOIPDSPsPtr, B3SOIPDsNodePrime, B3SOIPDsNode)

        TSTALLOC(B3SOIPDDdPtr, B3SOIPDdNode, B3SOIPDdNode)
        TSTALLOC(B3SOIPDDdpPtr, B3SOIPDdNode, B3SOIPDdNodePrime)

        TSTALLOC(B3SOIPDSsPtr, B3SOIPDsNode, B3SOIPDsNode)
        TSTALLOC(B3SOIPDSspPtr, B3SOIPDsNode, B3SOIPDsNodePrime)

/* here for debugging purpose only */
         if (here->B3SOIPDdebugMod != 0)
         {
            TSTALLOC(B3SOIPDVbsPtr, B3SOIPDvbsNode, B3SOIPDvbsNode) 
            TSTALLOC(B3SOIPDIdsPtr, B3SOIPDidsNode, B3SOIPDidsNode)
            TSTALLOC(B3SOIPDIcPtr, B3SOIPDicNode, B3SOIPDicNode)
            TSTALLOC(B3SOIPDIbsPtr, B3SOIPDibsNode, B3SOIPDibsNode)
            TSTALLOC(B3SOIPDIbdPtr, B3SOIPDibdNode, B3SOIPDibdNode)
            TSTALLOC(B3SOIPDIiiPtr, B3SOIPDiiiNode, B3SOIPDiiiNode)
            TSTALLOC(B3SOIPDIgPtr, B3SOIPDigNode, B3SOIPDigNode)
            TSTALLOC(B3SOIPDGiggPtr, B3SOIPDgiggNode, B3SOIPDgiggNode)
            TSTALLOC(B3SOIPDGigdPtr, B3SOIPDgigdNode, B3SOIPDgigdNode)
            TSTALLOC(B3SOIPDGigbPtr, B3SOIPDgigbNode, B3SOIPDgigbNode)
            TSTALLOC(B3SOIPDIgidlPtr, B3SOIPDigidlNode, B3SOIPDigidlNode)
            TSTALLOC(B3SOIPDItunPtr, B3SOIPDitunNode, B3SOIPDitunNode)
            TSTALLOC(B3SOIPDIbpPtr, B3SOIPDibpNode, B3SOIPDibpNode)
            TSTALLOC(B3SOIPDCbbPtr, B3SOIPDcbbNode, B3SOIPDcbbNode)
            TSTALLOC(B3SOIPDCbdPtr, B3SOIPDcbdNode, B3SOIPDcbdNode)
            TSTALLOC(B3SOIPDCbgPtr, B3SOIPDcbgNode, B3SOIPDcbgNode)
            TSTALLOC(B3SOIPDQbfPtr, B3SOIPDqbfNode, B3SOIPDqbfNode)
            TSTALLOC(B3SOIPDQjsPtr, B3SOIPDqjsNode, B3SOIPDqjsNode)
            TSTALLOC(B3SOIPDQjdPtr, B3SOIPDqjdNode, B3SOIPDqjdNode)

         }

        }
    }
    return(OK);
}  

int
B3SOIPDunsetup(inModel,ckt)
    GENmodel *inModel;
    CKTcircuit *ckt;
{
    B3SOIPDmodel *model;
    B3SOIPDinstance *here;
 
    for (model = (B3SOIPDmodel *)inModel; model != NULL;
            model = model->B3SOIPDnextModel)
    {
        for (here = model->B3SOIPDinstances; here != NULL;
                here=here->B3SOIPDnextInstance)
        {
            if (here->B3SOIPDdNodePrime
                    && here->B3SOIPDdNodePrime != here->B3SOIPDdNode)
            {
                CKTdltNNum(ckt, here->B3SOIPDdNodePrime);
                here->B3SOIPDdNodePrime = 0;
            }
            if (here->B3SOIPDsNodePrime
                    && here->B3SOIPDsNodePrime != here->B3SOIPDsNode)
            {
                CKTdltNNum(ckt, here->B3SOIPDsNodePrime);
                here->B3SOIPDsNodePrime = 0;
            }
        }
    }
    return OK;
}