mos1load.c

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

			if (vbd < here->MOS1tDepCap) {
			    arg=1-vbd/here->MOS1tBulkPot;
			    /*
			     * the following block looks somewhat long and messy,
			     * but since most users use the default grading
			     * coefficients of .5, and sqrt is MUCH faster than an
			     * exp(log()) we use this special case code to buy time.
			     * (as much as 10% of total job time!)
			     */
#ifndef NOSQRT
			    if(model->MOS1bulkJctBotGradingCoeff == .5 &&
			       model->MOS1bulkJctSideGradingCoeff == .5) {
				sarg = sargsw = 1/sqrt(arg);
			    } else {
				if(model->MOS1bulkJctBotGradingCoeff == .5) {
				    sarg = 1/sqrt(arg);
				} else {
#endif /*NOSQRT*/
				    sarg = exp(-model->MOS1bulkJctBotGradingCoeff*
					       log(arg));
#ifndef NOSQRT
				}
				if(model->MOS1bulkJctSideGradingCoeff == .5) {
				    sargsw = 1/sqrt(arg);
				} else {
#endif /*NOSQRT*/
				    sargsw =exp(-model->MOS1bulkJctSideGradingCoeff*
						log(arg));
#ifndef NOSQRT
				}
			    }
#endif /*NOSQRT*/
			    *(ckt->CKTstate0 + here->MOS1qbd) =
				here->MOS1tBulkPot*(here->MOS1Cbd*
						    (1-arg*sarg)
						    /(1-model->MOS1bulkJctBotGradingCoeff)
						    +here->MOS1Cbdsw*
						    (1-arg*sargsw)
						    /(1-model->MOS1bulkJctSideGradingCoeff));
			    here->MOS1capbd=here->MOS1Cbd*sarg+
                                here->MOS1Cbdsw*sargsw;
			} else {
			    *(ckt->CKTstate0 + here->MOS1qbd) = here->MOS1f4d +
                                vbd * (here->MOS1f2d + vbd * here->MOS1f3d/2);
			    here->MOS1capbd=here->MOS1f2d + vbd * here->MOS1f3d;
			}
#ifdef CAPZEROBYPASS						
		    } else {
			*(ckt->CKTstate0 + here->MOS1qbd) = 0;
			here->MOS1capbd = 0;
		    }
#endif /*CAPZEROBYPASS*/		    		    
                }
/*
  
*/

                if(SenCond && (ckt->CKTsenInfo->SENmode==TRANSEN)) goto next2;

                if ( (ckt->CKTmode & MODETRAN) || ( (ckt->CKTmode&MODEINITTRAN)
						    && !(ckt->CKTmode&MODEUIC)) ) {
                    /* (above only excludes tranop, since we're only at this
                     * point if tran or tranop )
                     */

                    /*
                     *    calculate equivalent conductances and currents for
                     *    depletion capacitors
                     */

                    /* integrate the capacitors and save results */

                    error = NIintegrate(ckt,&geq,&ceq,here->MOS1capbd,
					here->MOS1qbd);
                    if(error) return(error);
                    here->MOS1gbd += geq;
                    here->MOS1cbd += *(ckt->CKTstate0 + here->MOS1cqbd);
                    here->MOS1cd -= *(ckt->CKTstate0 + here->MOS1cqbd);
                    error = NIintegrate(ckt,&geq,&ceq,here->MOS1capbs,
					here->MOS1qbs);
                    if(error) return(error);
                    here->MOS1gbs += geq;
                    here->MOS1cbs += *(ckt->CKTstate0 + here->MOS1cqbs);
                }
            }
/*
  
*/

            if(SenCond) goto next2;


            /*
             *  check convergence
             */
            if ( (here->MOS1off == 0)  || 
		 (!(ckt->CKTmode & (MODEINITFIX|MODEINITSMSIG))) ){
                if (Check == 1) {
                    ckt->CKTnoncon++;
		    ckt->CKTtroubleElt = (GENinstance *) here;
                }
            }
/*
  
*/

            /* save things away for next time */

	next2:      *(ckt->CKTstate0 + here->MOS1vbs) = vbs;
            *(ckt->CKTstate0 + here->MOS1vbd) = vbd;
            *(ckt->CKTstate0 + here->MOS1vgs) = vgs;
            *(ckt->CKTstate0 + here->MOS1vds) = vds;

/*
  
*/

            /*
             *     meyer's capacitor model
             */
            if ( ckt->CKTmode & (MODETRAN | MODETRANOP | MODEINITSMSIG) ) {
                /*
                 *     calculate meyer's capacitors
                 */
                /* 
                 * new cmeyer - this just evaluates at the current time,
                 * expects you to remember values from previous time
                 * returns 1/2 of non-constant portion of capacitance
                 * you must add in the other half from previous time
                 * and the constant part
                 */
                if (here->MOS1mode > 0){
                    DEVqmeyer (vgs,vgd,vgb,von,vdsat,
			       (ckt->CKTstate0 + here->MOS1capgs),
			       (ckt->CKTstate0 + here->MOS1capgd),
			       (ckt->CKTstate0 + here->MOS1capgb),
			       here->MOS1tPhi,OxideCap);
                } else {
                    DEVqmeyer (vgd,vgs,vgb,von,vdsat,
			       (ckt->CKTstate0 + here->MOS1capgd),
			       (ckt->CKTstate0 + here->MOS1capgs),
			       (ckt->CKTstate0 + here->MOS1capgb),
			       here->MOS1tPhi,OxideCap);
                }
                vgs1 = *(ckt->CKTstate1 + here->MOS1vgs);
                vgd1 = vgs1 - *(ckt->CKTstate1 + here->MOS1vds);
                vgb1 = vgs1 - *(ckt->CKTstate1 + here->MOS1vbs);
                if(ckt->CKTmode & (MODETRANOP|MODEINITSMSIG)) {
                    capgs =  2 * *(ckt->CKTstate0+here->MOS1capgs)+ 
			GateSourceOverlapCap ;
                    capgd =  2 * *(ckt->CKTstate0+here->MOS1capgd)+ 
			GateDrainOverlapCap ;
                    capgb =  2 * *(ckt->CKTstate0+here->MOS1capgb)+ 
			GateBulkOverlapCap ;
                } else {
                    capgs = ( *(ckt->CKTstate0+here->MOS1capgs)+ 
                              *(ckt->CKTstate1+here->MOS1capgs) +
                              GateSourceOverlapCap );
                    capgd = ( *(ckt->CKTstate0+here->MOS1capgd)+ 
                              *(ckt->CKTstate1+here->MOS1capgd) +
                              GateDrainOverlapCap );
                    capgb = ( *(ckt->CKTstate0+here->MOS1capgb)+ 
                              *(ckt->CKTstate1+here->MOS1capgb) +
                              GateBulkOverlapCap );
                }
                if(ckt->CKTsenInfo){
                    here->MOS1cgs = capgs;
                    here->MOS1cgd = capgd;
                    here->MOS1cgb = capgb;
                }
/*
  
*/

                /*
                 *     store small-signal parameters (for meyer's model)
                 *  all parameters already stored, so done...
                 */
                if(SenCond){
                    if((ckt->CKTsenInfo->SENmode == DCSEN)||
		       (ckt->CKTsenInfo->SENmode == ACSEN)){
                        continue;
                    }
                }

#ifndef PREDICTOR
                if (ckt->CKTmode & (MODEINITPRED | MODEINITTRAN) ) {
                    *(ckt->CKTstate0 + here->MOS1qgs) =
                        (1+xfact) * *(ckt->CKTstate1 + here->MOS1qgs)
                        - xfact * *(ckt->CKTstate2 + here->MOS1qgs);
                    *(ckt->CKTstate0 + here->MOS1qgd) =
                        (1+xfact) * *(ckt->CKTstate1 + here->MOS1qgd)
                        - xfact * *(ckt->CKTstate2 + here->MOS1qgd);
                    *(ckt->CKTstate0 + here->MOS1qgb) =
                        (1+xfact) * *(ckt->CKTstate1 + here->MOS1qgb)
                        - xfact * *(ckt->CKTstate2 + here->MOS1qgb);
                } else {
#endif /*PREDICTOR*/
                    if(ckt->CKTmode & MODETRAN) {
                        *(ckt->CKTstate0 + here->MOS1qgs) = (vgs-vgs1)*capgs +
                            *(ckt->CKTstate1 + here->MOS1qgs) ;
                        *(ckt->CKTstate0 + here->MOS1qgd) = (vgd-vgd1)*capgd +
                            *(ckt->CKTstate1 + here->MOS1qgd) ;
                        *(ckt->CKTstate0 + here->MOS1qgb) = (vgb-vgb1)*capgb +
                            *(ckt->CKTstate1 + here->MOS1qgb) ;
                    } else {
                        /* TRANOP only */
                        *(ckt->CKTstate0 + here->MOS1qgs) = vgs*capgs;
                        *(ckt->CKTstate0 + here->MOS1qgd) = vgd*capgd;
                        *(ckt->CKTstate0 + here->MOS1qgb) = vgb*capgb;
                    }
#ifndef PREDICTOR
                }
#endif /*PREDICTOR*/
            }
	bypass:
            if(SenCond) continue;

            if ( (ckt->CKTmode & (MODEINITTRAN)) || 
		 (! (ckt->CKTmode & (MODETRAN)) )  ) {
                /*
                 *  initialize to zero charge conductances 
                 *  and current
                 */
                gcgs=0;
                ceqgs=0;
                gcgd=0;
                ceqgd=0;
                gcgb=0;
                ceqgb=0;
            } else {
                if(capgs == 0) *(ckt->CKTstate0 + here->MOS1cqgs) =0;
                if(capgd == 0) *(ckt->CKTstate0 + here->MOS1cqgd) =0;
                if(capgb == 0) *(ckt->CKTstate0 + here->MOS1cqgb) =0;
                /*
                 *    calculate equivalent conductances and currents for
                 *    meyer"s capacitors
                 */
                error = NIintegrate(ckt,&gcgs,&ceqgs,capgs,here->MOS1qgs);
                if(error) return(error);
                error = NIintegrate(ckt,&gcgd,&ceqgd,capgd,here->MOS1qgd);
                if(error) return(error);
                error = NIintegrate(ckt,&gcgb,&ceqgb,capgb,here->MOS1qgb);
                if(error) return(error);
                ceqgs=ceqgs-gcgs*vgs+ckt->CKTag[0]* 
		    *(ckt->CKTstate0 + here->MOS1qgs);
                ceqgd=ceqgd-gcgd*vgd+ckt->CKTag[0]*
		    *(ckt->CKTstate0 + here->MOS1qgd);
                ceqgb=ceqgb-gcgb*vgb+ckt->CKTag[0]*
		    *(ckt->CKTstate0 + here->MOS1qgb);
            }
            /*
             *     store charge storage info for meyer's cap in lx table
             */

            /*
             *  load current vector
             */
            ceqbs = model->MOS1type * 
		(here->MOS1cbs-(here->MOS1gbs)*vbs);
            ceqbd = model->MOS1type * 
		(here->MOS1cbd-(here->MOS1gbd)*vbd);
            if (here->MOS1mode >= 0) {
                xnrm=1;
                xrev=0;
                cdreq=model->MOS1type*(cdrain-here->MOS1gds*vds-
				       here->MOS1gm*vgs-here->MOS1gmbs*vbs);
            } else {
                xnrm=0;
                xrev=1;
                cdreq = -(model->MOS1type)*(cdrain-here->MOS1gds*(-vds)-
					    here->MOS1gm*vgd-here->MOS1gmbs*vbd);
            }
            *(ckt->CKTrhs + here->MOS1gNode) -= 
                (model->MOS1type * (ceqgs + ceqgb + ceqgd));
            *(ckt->CKTrhs + here->MOS1bNode) -=
                (ceqbs + ceqbd - model->MOS1type * ceqgb);
            *(ckt->CKTrhs + here->MOS1dNodePrime) +=
		(ceqbd - cdreq + model->MOS1type * ceqgd);
            *(ckt->CKTrhs + here->MOS1sNodePrime) += 
		cdreq + ceqbs + model->MOS1type * ceqgs;
            /*
             *  load y matrix
             */

            *(here->MOS1DdPtr) += (here->MOS1drainConductance);
            *(here->MOS1GgPtr) += ((gcgd+gcgs+gcgb));
            *(here->MOS1SsPtr) += (here->MOS1sourceConductance);
            *(here->MOS1BbPtr) += (here->MOS1gbd+here->MOS1gbs+gcgb);
            *(here->MOS1DPdpPtr) += 
		(here->MOS1drainConductance+here->MOS1gds+
		 here->MOS1gbd+xrev*(here->MOS1gm+here->MOS1gmbs)+gcgd);
            *(here->MOS1SPspPtr) += 
		(here->MOS1sourceConductance+here->MOS1gds+
		 here->MOS1gbs+xnrm*(here->MOS1gm+here->MOS1gmbs)+gcgs);
            *(here->MOS1DdpPtr) += (-here->MOS1drainConductance);
            *(here->MOS1GbPtr) -= gcgb;
            *(here->MOS1GdpPtr) -= gcgd;
            *(here->MOS1GspPtr) -= gcgs;
            *(here->MOS1SspPtr) += (-here->MOS1sourceConductance);
            *(here->MOS1BgPtr) -= gcgb;
            *(here->MOS1BdpPtr) -= here->MOS1gbd;
            *(here->MOS1BspPtr) -= here->MOS1gbs;
            *(here->MOS1DPdPtr) += (-here->MOS1drainConductance);
            *(here->MOS1DPgPtr) += ((xnrm-xrev)*here->MOS1gm-gcgd);
            *(here->MOS1DPbPtr) += (-here->MOS1gbd+(xnrm-xrev)*here->MOS1gmbs);
            *(here->MOS1DPspPtr) += (-here->MOS1gds-xnrm*
				     (here->MOS1gm+here->MOS1gmbs));
            *(here->MOS1SPgPtr) += (-(xnrm-xrev)*here->MOS1gm-gcgs);
            *(here->MOS1SPsPtr) += (-here->MOS1sourceConductance);
            *(here->MOS1SPbPtr) += (-here->MOS1gbs-(xnrm-xrev)*here->MOS1gmbs);
            *(here->MOS1SPdpPtr) += (-here->MOS1gds-xrev*
				     (here->MOS1gm+here->MOS1gmbs));
        }
    }
    return(OK);
}