/**********
Copyright 1990 Regents of the University of California.  All rights reserved.
Author: 1985 Thomas L. Quarles
Modified: Alan Gillespie

This function is obsolete (was used by an old sensitivity analysis)
**********/

/* actually load the current ac sensitivity 
 * information into the  array previously provided 
 */

#include "ngspice.h"
#include "smpdefs.h"
#include "cktdefs.h"
#include "const.h"
#include "mos9defs.h"
#include "sperror.h"
#include "suffix.h"

int
MOS9sAcLoad(GENmodel *inModel, CKTcircuit *ckt)
{
    MOS9model *model = (MOS9model *)inModel;
    MOS9instance *here;
    int xnrm;
    int xrev;
    double A0;
    double Apert = 0.0;
    double DELA;
    double DELAinv;
    double gdpr0;
    double gspr0;
    double gds0;
    double gbs0;
    double gbd0;
    double gm0;
    double gmbs0;
    double gdpr;
    double gspr;
    double gds;
    double gbs;
    double gbd;
    double gm;
    double gmbs;
    double xcgs0;
    double xcgd0;
    double xcgb0;
    double xbd0;
    double xbs0;
    double xcgs;
    double xcgd;
    double xcgb;
    double xbd;
    double xbs;
    double vbsOp;
    double vbdOp;
    double vspr;
    double vdpr;
    double vgs;
    double vgd;
    double vgb;
    double vbs;
    double vbd;
    double vds;
    double ivspr;
    double ivdpr;
    double ivgs;
    double ivgd;
    double ivgb;
    double ivbs;
    double ivbd;
    double ivds;
    double cspr;
    double cdpr;
    double cgs;
    double cgd;
    double cgb;
    double cbs;
    double cbd;
    double cds;
    double cs0;
    double csprm0;
    double cd0;
    double cdprm0;
    double cg0;
    double cb0;
    double cs;
    double csprm;
    double cd;
    double cdprm;
    double cg;
    double cb;
    double icspr;
    double icdpr;
    double icgs;
    double icgd;
    double icgb;
    double icbs;
    double icbd;
    double icds;
    double ics0;
    double icsprm0;
    double icd0;
    double icdprm0;
    double icg0;
    double icb0;
    double ics;
    double icsprm;
    double icd;
    double icdprm;
    double icg;
    double icb;
    double DvDp = 0.0;
    int i;
    int flag;
    int error;
    int iparmno;
    double arg;
    double sarg;
    double sargsw;
    double SaveState[44];
    int    save_mode;
    SENstruct *info;

#ifdef SENSDEBUG
    printf("MOS9senacload\n");
    printf("CKTomega = %.5e\n",ckt->CKTomega);
#endif /* SENSDEBUG */
    info = ckt->CKTsenInfo;
    info->SENstatus = PERTURBATION;
    for( ; model != NULL; model = model->MOS9nextModel) {
        for(here = model->MOS9instances; here!= NULL;
                here = here->MOS9nextInstance) {
            if (here->MOS9owner != ARCHme) continue;

            /* save the unperturbed values in the state vector */
            for(i=0; i <= 16; i++)
                *(SaveState + i) = *(ckt->CKTstate0 + here->MOS9states + i);

            *(SaveState + 17) = here->MOS9sourceConductance;  
            *(SaveState + 18) = here->MOS9drainConductance;  
            *(SaveState + 19) = here->MOS9cd;  
            *(SaveState + 20) = here->MOS9cbs;  
            *(SaveState + 21) = here->MOS9cbd;  
            *(SaveState + 22) = here->MOS9gmbs;  
            *(SaveState + 23) = here->MOS9gm;  
            *(SaveState + 24) = here->MOS9gds;  
            *(SaveState + 25) = here->MOS9gbd;  
            *(SaveState + 26) = here->MOS9gbs;  
            *(SaveState + 27) = here->MOS9capbd;  
            *(SaveState + 28) = here->MOS9capbs;  
            *(SaveState + 29) = here->MOS9Cbd;  
            *(SaveState + 30) = here->MOS9Cbdsw;  
            *(SaveState + 31) = here->MOS9Cbs;  
            *(SaveState + 32) = here->MOS9Cbssw;  
            *(SaveState + 33) = here->MOS9f2d;  
            *(SaveState + 34) = here->MOS9f3d;  
            *(SaveState + 35) = here->MOS9f4d;  
            *(SaveState + 36) = here->MOS9f2s;  
            *(SaveState + 37) = here->MOS9f3s;  
            *(SaveState + 38) = here->MOS9f4s;  
            *(SaveState + 39) = here->MOS9cgs;  
            *(SaveState + 40) = here->MOS9cgd;  
            *(SaveState + 41) = here->MOS9cgb;  
            *(SaveState + 42) = here->MOS9vdsat;  
            *(SaveState + 43) = here->MOS9von;  
            save_mode  = here->MOS9mode;  

            xnrm=1;
            xrev=0;
            if (here->MOS9mode < 0) {
                xnrm=0;
                xrev=1;
            }

            vbsOp = model->MOS9type * ( 
            *(ckt->CKTrhsOp+here->MOS9bNode) -
                *(ckt->CKTrhsOp+here->MOS9sNodePrime));
            vbdOp = model->MOS9type * ( 
            *(ckt->CKTrhsOp+here->MOS9bNode) -
                *(ckt->CKTrhsOp+here->MOS9dNodePrime));
            vspr = *(ckt->CKTrhsOld + here->MOS9sNode) 
                - *(ckt->CKTrhsOld +
                    here->MOS9sNodePrime) ;
            ivspr = *(ckt->CKTirhsOld + here->MOS9sNode) 
                - *(ckt->CKTirhsOld +
                    here->MOS9sNodePrime) ;
            vdpr = *(ckt->CKTrhsOld + here->MOS9dNode) 
                - *(ckt->CKTrhsOld +
                    here->MOS9dNodePrime) ;
            ivdpr = *(ckt->CKTirhsOld + here->MOS9dNode) 
                - *(ckt->CKTirhsOld +
                    here->MOS9dNodePrime) ;
            vgb = *(ckt->CKTrhsOld + here->MOS9gNode) 
                - *(ckt->CKTrhsOld +
                    here->MOS9bNode) ;
            ivgb = *(ckt->CKTirhsOld + here->MOS9gNode) 
                - *(ckt->CKTirhsOld +
                    here->MOS9bNode) ;
            vbs = *(ckt->CKTrhsOld + here->MOS9bNode) 
                - *(ckt->CKTrhsOld +
                    here->MOS9sNodePrime) ;
            ivbs = *(ckt->CKTirhsOld + here->MOS9bNode) 
                - *(ckt->CKTirhsOld +
                    here->MOS9sNodePrime) ;
            vbd = *(ckt->CKTrhsOld + here->MOS9bNode) 
                - *(ckt->CKTrhsOld +
                    here->MOS9dNodePrime) ;
            ivbd = *(ckt->CKTirhsOld + here->MOS9bNode) 
                - *(ckt->CKTirhsOld +
                    here->MOS9dNodePrime) ;
            vds = vbs - vbd ;
            ivds = ivbs - ivbd ;
            vgs = vgb + vbs ;
            ivgs = ivgb + ivbs ;
            vgd = vgb + vbd ;
            ivgd = ivgb + ivbd ;

#ifdef SENSDEBUG
            printf("senacload instance name %s\n",here->MOS9name);
            printf("gate = %d ,drain = %d, drainprm = %d\n",
                    here->MOS9gNode,here->MOS9dNode,here->MOS9dNodePrime);
            printf("source = %d , sourceprm = %d ,body = %d, senparmno = %d\n",
                    here->MOS9sNode ,here->MOS9sNodePrime,
                    here->MOS9bNode,here->MOS9senParmNo);
            printf("\n without  perturbation \n");
#endif /* SENSDEBUG */
            /*  without  perturbation  */
            *(ckt->CKTstate0 + here->MOS9vbs) = vbsOp;
            *(ckt->CKTstate0 + here->MOS9vbd) = vbdOp;

            here->MOS9senPertFlag = ON ;
            if(info->SENacpertflag == 1){
                /* store the  unperturbed values of small signal parameters */
                if((error = MOS9load((GENmodel*)model,ckt))) return(error);
                *(here->MOS9senCgs) = here->MOS9cgs;
                *(here->MOS9senCgd) = here->MOS9cgd;
                *(here->MOS9senCgb) = here->MOS9cgb;
                *(here->MOS9senCbd) = here->MOS9capbd;
                *(here->MOS9senCbs) = here->MOS9capbs;
                *(here->MOS9senGds) = here->MOS9gds;
                *(here->MOS9senGbs) = here->MOS9gbs;
                *(here->MOS9senGbd) = here->MOS9gbd;
                *(here->MOS9senGm) = here->MOS9gm;
                *(here->MOS9senGmbs) = here->MOS9gmbs;

            }
            xcgs0= *(here->MOS9senCgs) * ckt->CKTomega;
            xcgd0= *(here->MOS9senCgd) * ckt->CKTomega;
            xcgb0= *(here->MOS9senCgb) * ckt->CKTomega;
            xbd0= *(here->MOS9senCbd) * ckt->CKTomega;
            xbs0= *(here->MOS9senCbs) * ckt->CKTomega;
            gds0= *(here->MOS9senGds);
            gbs0= *(here->MOS9senGbs);
            gbd0= *(here->MOS9senGbd);
            gm0= *(here->MOS9senGm);
            gmbs0= *(here->MOS9senGmbs);
            gdpr0 = here->MOS9drainConductance;
            gspr0 = here->MOS9sourceConductance;


            cspr = gspr0 * vspr ;
            icspr = gspr0 * ivspr ;
            cdpr = gdpr0 * vdpr ;
            icdpr = gdpr0 * ivdpr ;
            cgs = ( - xcgs0 * ivgs );
            icgs =  xcgs0 * vgs ;
            cgd = ( - xcgd0 * ivgd );
            icgd =  xcgd0 * vgd ;
            cgb = ( - xcgb0 * ivgb );
            icgb =  xcgb0 * vgb ;
            cbs = ( gbs0 * vbs  - xbs0 * ivbs );
            icbs = ( xbs0 * vbs  + gbs0 * ivbs );
            cbd = ( gbd0 * vbd  - xbd0 * ivbd );
            icbd = ( xbd0 * vbd  + gbd0 * ivbd );
            cds = ( gds0 * vds  + xnrm * (gm0 * vgs + gmbs0 * vbs) 
                - xrev * (gm0 * vgd + gmbs0 * vbd) );
            icds = ( gds0 * ivds + xnrm * (gm0 * ivgs + gmbs0 * ivbs)
                - xrev * (gm0 * ivgd + gmbs0 * ivbd) );

            cs0 = cspr;
            ics0 = icspr;
            csprm0 = ( -cspr - cgs - cbs - cds ) ;
            icsprm0 = ( -icspr - icgs - icbs - icds ) ;
            cd0 = cdpr;
            icd0 = icdpr;
            cdprm0 = ( -cdpr - cgd - cbd + cds ) ;
            icdprm0 = ( -icdpr - icgd - icbd + icds ) ;
            cg0 = cgs + cgd + cgb ;
            icg0 = icgs + icgd + icgb ;
            cb0 = cbs + cbd - cgb ;
            icb0 = icbs + icbd - icgb ;
#ifdef SENSDEBUG
            printf("gspr0 = %.7e , gdpr0 = %.7e , gds0 = %.7e, gbs0 = %.7e\n",
                    gspr0,gdpr0,gds0,gbs0);
            printf("gbd0 = %.7e , gm0 = %.7e , gmbs0 = %.7e\n",gbd0,gm0,gmbs0);
            printf("xcgs0 = %.7e , xcgd0 = %.7e ,", xcgs0,xcgd0);
            printf("xcgb0 = %.7e, xbd0 = %.7e,xbs0 = %.7e\n" ,xcgb0,xbd0,xbs0);
            printf("vbs = %.7e , vbd = %.7e , vgb = %.7e\n",vbs,vbd,vgb);
            printf("ivbs = %.7e , ivbd = %.7e , ivgb = %.7e\n",ivbs,ivbd,ivgb);
            printf("cbs0 = %.7e , cbd0 = %.7e , cgb0 = %.7e\n",cbs,cbd,cgb);
            printf("cb0 = %.7e , cg0 = %.7e , cs0 = %.7e\n",cb0,cg0,cs0);
            printf("csprm0 = %.7e, cd0 = %.7e, cdprm0 = %.7e\n",
                    csprm0,cd0,cdprm0);
            printf("icb0 = %.7e , icg0 = %.7e , ics0 = %.7e\n",icb0,icg0,ics0);
            printf("icsprm0 = %.7e, icd0 = %.7e, icdprm0 = %.7e\n",
                    icsprm0,icd0,icdprm0);
            printf("\nPerturbation of vbs\n");
#endif /* SENSDEBUG */

            /* Perturbation of vbs */
            flag = 1;
            A0 = vbsOp;
            DELA =  info->SENpertfac * CONSTvt0 ;
            DELAinv = 1.0/DELA;

            if(info->SENacpertflag == 1){
                /* store the  values of small signal parameters 
                 * corresponding to perturbed vbs */
                Apert = A0 + DELA;
                *(ckt->CKTstate0 + here->MOS9vbs) = Apert;
                *(ckt->CKTstate0 + here->MOS9vbd) = vbdOp;

                if((error = MOS9load((GENmodel*)model,ckt))) return(error);

                *(here->MOS9senCgs + 1) = here->MOS9cgs;
                *(here->MOS9senCgd + 1) = here->MOS9cgd;
                *(here->MOS9senCgb + 1) = here->MOS9cgb;
                *(here->MOS9senCbd + 1) = here->MOS9capbd;
                *(here->MOS9senCbs + 1) = here->MOS9capbs;
                *(here->MOS9senGds + 1) = here->MOS9gds;
                *(here->MOS9senGbs + 1) = here->MOS9gbs;
                *(here->MOS9senGbd + 1) = here->MOS9gbd;
                *(here->MOS9senGm + 1) = here->MOS9gm;
                *(here->MOS9senGmbs + 1) = here->MOS9gmbs;

                *(ckt->CKTstate0 + here->MOS9vbs) = A0;


            }

            goto load;


pertvbd:  /* Perturbation of vbd */
#ifdef SENSDEBUG
            printf("\nPerturbation of vbd\n");
#endif /* SENSDEBUG */

            flag = 2;
            A0 = vbdOp;
            DELA =  info->SENpertfac * CONSTvt0 + 1e-8;
            DELAinv = 1.0/DELA;

            if(info->SENacpertflag == 1){
                /* store the  values of small signal parameters 
                 * corresponding to perturbed vbd */
                Apert = A0 + DELA;
                *(ckt->CKTstate0 + here->MOS9vbs) = vbsOp;
                *(ckt->CKTstate0 + here->MOS9vbd) = Apert;

                if((error = MOS9load((GENmodel*)model,ckt))) return(error);

                *(here->MOS9senCgs + 2) = here->MOS9cgs;
                *(here->MOS9senCgd + 2) = here->MOS9cgd;
                *(here->MOS9senCgb + 2) = here->MOS9cgb;
                *(here->MOS9senCbd + 2) = here->MOS9capbd;
                *(here->MOS9senCbs + 2) = here->MOS9capbs;
                *(here->MOS9senGds + 2) = here->MOS9gds;
                *(here->MOS9senGbs + 2) = here->MOS9gbs;
                *(here->MOS9senGbd + 2) = here->MOS9gbd;
                *(here->MOS9senGm + 2) = here->MOS9gm;
                *(here->MOS9senGmbs + 2) = here->MOS9gmbs;

                *(ckt->CKTstate0 + here->MOS9vbd) = A0;

            }

            goto load;


pertvgb:  /* Perturbation of vgb */
#ifdef SENSDEBUG
            printf("\nPerturbation of vgb\n");
#endif /* SENSDEBUG */

            flag = 3;
            A0 = model->MOS9type * (*(ckt->CKTrhsOp + here->MOS9gNode) 
                -  *(ckt->CKTrhsOp + here->MOS9bNode)); 
            DELA =  info->SENpertfac * A0 + 1e-8;
            DELAinv = model->MOS9type * 1.0/DELA;


            if(info->SENacpertflag == 1){
                /* store the  values of small signal parameters 
                 * corresponding to perturbed vgb */
                *(ckt->CKTstate0 + here->MOS9vbs) = vbsOp;
                *(ckt->CKTstate0 + here->MOS9vbd) = vbdOp;
                *(ckt->CKTrhsOp + here->MOS9bNode) -= DELA; 

                if((error = MOS9load((GENmodel*)model,ckt))) return(error);

                *(here->MOS9senCgs + 3) = here->MOS9cgs;
                *(here->MOS9senCgd + 3) = here->MOS9cgd;
                *(here->MOS9senCgb + 3) = here->MOS9cgb;
                *(here->MOS9senCbd + 3) = here->MOS9capbd;
                *(here->MOS9senCbs + 3) = here->MOS9capbs;
                *(here->MOS9senGds + 3) = here->MOS9gds;
                *(here->MOS9senGbs + 3) = here->MOS9gbs;
                *(here->MOS9senGbd + 3) = here->MOS9gbd;
                *(here->MOS9senGm + 3) = here->MOS9gm;
                *(here->MOS9senGmbs + 3) = here->MOS9gmbs;


                *(ckt->CKTrhsOp + here->MOS9bNode) += DELA; 
            }
            goto load;

pertl:    /* Perturbation of length */

            if(here->MOS9sens_l == 0){
                goto pertw;
            }
#ifdef SENSDEBUG
            printf("\nPerturbation of length\n");
#endif /* SENSDEBUG */
            flag = 4;
            A0 = here->MOS9l;
            DELA =  info->SENpertfac * A0;
            DELAinv = 1.0/DELA;

            if(info->SENacpertflag == 1){
                /* store the  values of small signal parameters 
                 * corresponding to perturbed length */
                Apert = A0 + DELA;
                here->MOS9l = Apert;

                *(ckt->CKTstate0 + here->MOS9vbs) = vbsOp;
                *(ckt->CKTstate0 + here->MOS9vbd) = vbdOp;

                if((error = MOS9load((GENmodel*)model,ckt))) return(error);

                *(here->MOS9senCgs + 4) = here->MOS9cgs;
                *(here->MOS9senCgd + 4) = here->MOS9cgd;
                *(here->MOS9senCgb + 4) = here->MOS9cgb;
                *(here->MOS9senCbd + 4) = here->MOS9capbd;
                *(here->MOS9senCbs + 4) = here->MOS9capbs;
                *(here->MOS9senGds + 4) = here->MOS9gds;
                *(here->MOS9senGbs + 4) = here->MOS9gbs;
                *(here->MOS9senGbd + 4) = here->MOS9gbd;
                *(here->MOS9senGm + 4) = here->MOS9gm;
                *(here->MOS9senGmbs + 4) = here->MOS9gmbs;

                here->MOS9l = A0;

            }

            goto load;

pertw:    /* Perturbation of width */
            if(here->MOS9sens_w == 0)
                goto next;
#ifdef SENSDEBUG
            printf("\nPerturbation of width\n");
#endif /* SENSDEBUG */
            flag = 5;
            A0 = here->MOS9w;
            DELA = info->SENpertfac * A0;
            DELAinv = 1.0/DELA;
            Apert = A0 + DELA;

            if(info->SENacpertflag == 1){
                /* store the  values of small signal parameters 
                 * corresponding to perturbed width */
                here->MOS9w = Apert;
                here->MOS9drainArea *= (1 + info->SENpertfac);
                here->MOS9sourceArea *= (1 + info->SENpertfac);
                here->MOS9Cbd *= (1 + info->SENpertfac);
                here->MOS9Cbs *= (1 + info->SENpertfac);
                if(here->MOS9drainPerimiter){
                    here->MOS9Cbdsw += here->MOS9Cbdsw *
                        DELA/here->MOS9drainPerimiter;
                }
                if(here->MOS9sourcePerimiter){
                    here->MOS9Cbssw += here->MOS9Cbssw *
                        DELA/here->MOS9sourcePerimiter;
                }
                if(vbdOp >= here->MOS9tDepCap){
                    arg = 1-model->MOS9fwdCapDepCoeff;
                    sarg = exp( (-model->MOS9bulkJctBotGradingCoeff) * 
                            log(arg) );
                    sargsw = exp( (-model->MOS9bulkJctSideGradingCoeff) * 
                            log(arg) );
                    here->MOS9f2d = here->MOS9Cbd*(1-model->MOS9fwdCapDepCoeff*
                            (1+model->MOS9bulkJctBotGradingCoeff))* sarg/arg
                            +  here->MOS9Cbdsw*(1-model->MOS9fwdCapDepCoeff*
                            (1+model->MOS9bulkJctSideGradingCoeff))*
                            sargsw/arg;
                    here->MOS9f3d = here->MOS9Cbd * 
                            model->MOS9bulkJctBotGradingCoeff * sarg/arg/
                            model->MOS9bulkJctPotential
                            + here->MOS9Cbdsw * 
                            model->MOS9bulkJctSideGradingCoeff * sargsw/arg /
                            model->MOS9bulkJctPotential;
                    here->MOS9f4d = here->MOS9Cbd*model->MOS9bulkJctPotential*
                            (1-arg*sarg)/ (1-model->MOS9bulkJctBotGradingCoeff)
                            + here->MOS9Cbdsw*model->MOS9bulkJctPotential*
                            (1-arg*sargsw)/
                            (1-model->MOS9bulkJctSideGradingCoeff)
                            -here->MOS9f3d/2*
                            (here->MOS9tDepCap*here->MOS9tDepCap)
                            -here->MOS9tDepCap * here->MOS9f2d;
                }
                if(vbsOp >= here->MOS9tDepCap){
                    arg = 1-model->MOS9fwdCapDepCoeff;
                    sarg = exp( (-model->MOS9bulkJctBotGradingCoeff) * 
                            log(arg) );
                    sargsw = exp( (-model->MOS9bulkJctSideGradingCoeff) * 
                            log(arg) );
                    here->MOS9f2s = here->MOS9Cbs*(1-model->MOS9fwdCapDepCoeff*
                        (1+model->MOS9bulkJctBotGradingCoeff))* sarg/arg
                        +  here->MOS9Cbssw*(1-model->MOS9fwdCapDepCoeff*
                        (1+model->MOS9bulkJctSideGradingCoeff))*
                        sargsw/arg;
                    here->MOS9f3s = here->MOS9Cbs * 
                            model->MOS9bulkJctBotGradingCoeff * sarg/arg/
                            model->MOS9bulkJctPotential + here->MOS9Cbssw * 
                            model->MOS9bulkJctSideGradingCoeff * sargsw/arg /
                            model->MOS9bulkJctPotential;
                    here->MOS9f4s = here->MOS9Cbs*model->MOS9bulkJctPotential*
                            (1-arg*sarg)/ (1-model->MOS9bulkJctBotGradingCoeff)
                            + here->MOS9Cbssw*model->MOS9bulkJctPotential*
                            (1-arg*sargsw)/
                            (1-model->MOS9bulkJctSideGradingCoeff)
                            -here->MOS9f3s/2*
                            (here->MOS9tBulkPot*here->MOS9tBulkPot)
                            -here->MOS9tBulkPot * here->MOS9f2s;
                }

                *(ckt->CKTstate0 + here->MOS9vbs) = vbsOp;
                *(ckt->CKTstate0 + here->MOS9vbd) = vbdOp;

                if((error = MOS9load((GENmodel*)model,ckt))) return(error);

                *(here->MOS9senCgs + 5) = here->MOS9cgs;
                *(here->MOS9senCgd + 5) = here->MOS9cgd;
                *(here->MOS9senCgb + 5) = here->MOS9cgb;
                *(here->MOS9senCbd + 5) = here->MOS9capbd;
                *(here->MOS9senCbs + 5) = here->MOS9capbs;
                *(here->MOS9senGds + 5) = here->MOS9gds;
                *(here->MOS9senGbs + 5) = here->MOS9gbs;
                *(here->MOS9senGbd + 5) = here->MOS9gbd;
                *(here->MOS9senGm + 5) = here->MOS9gm;
                *(here->MOS9senGmbs + 5) = here->MOS9gmbs;

                here->MOS9w = A0;
                here->MOS9drainArea /= (1 + info->SENpertfac);
                here->MOS9sourceArea /= (1 + info->SENpertfac);
            }

load:

            gds= *(here->MOS9senGds + flag);
            gbs= *(here->MOS9senGbs + flag);
            gbd= *(here->MOS9senGbd + flag);
            gm= *(here->MOS9senGm + flag);
            gmbs= *(here->MOS9senGmbs + flag);
            if(flag == 5){
                gdpr = here->MOS9drainConductance * Apert/A0;
                gspr = here->MOS9sourceConductance * Apert/A0;
            }
            else{
                gdpr = here->MOS9drainConductance;
                gspr = here->MOS9sourceConductance;
            }

            xcgs= *(here->MOS9senCgs + flag) * ckt->CKTomega;
            xcgd= *(here->MOS9senCgd + flag) * ckt->CKTomega;
            xcgb= *(here->MOS9senCgb + flag) * ckt->CKTomega;
            xbd= *(here->MOS9senCbd + flag) * ckt->CKTomega;
            xbs= *(here->MOS9senCbs + flag) * ckt->CKTomega;

#ifdef SENSDEBUG
            printf("flag = %d \n",flag);
            printf("gspr = %.7e , gdpr = %.7e , gds = %.7e, gbs = %.7e\n",
                    gspr,gdpr,gds,gbs);
            printf("gbd = %.7e , gm = %.7e , gmbs = %.7e\n",gbd,gm,gmbs);
            printf("xcgs = %.7e , xcgd = %.7e , xcgb = %.7e,", xcgs,xcgd,xcgb);
            printf("xbd = %.7e,xbs = %.7e\n" ,xbd,xbs);
#endif /* SENSDEBUG */
            cspr = gspr * vspr ;
            icspr = gspr * ivspr ;
            cdpr = gdpr * vdpr ;
            icdpr = gdpr * ivdpr ;
            cgs = ( - xcgs * ivgs );
            icgs =  xcgs * vgs ;
            cgd = ( - xcgd * ivgd );
            icgd =  xcgd * vgd ;
            cgb = ( - xcgb * ivgb );
            icgb =  xcgb * vgb ;
            cbs = ( gbs * vbs  - xbs * ivbs );
            icbs = ( xbs * vbs  + gbs * ivbs );
            cbd = ( gbd * vbd  - xbd * ivbd );
            icbd = ( xbd * vbd  + gbd * ivbd );
            cds = ( gds * vds  + xnrm * (gm * vgs + gmbs * vbs) 
                - xrev * (gm * vgd + gmbs * vbd) );
            icds = ( gds * ivds + xnrm * (gm * ivgs + gmbs * ivbs)
                - xrev * (gm * ivgd + gmbs * ivbd) );

            cs = cspr;
            ics = icspr;
            csprm = ( -cspr - cgs - cbs - cds ) ;
            icsprm = ( -icspr - icgs - icbs - icds ) ;
            cd = cdpr;
            icd = icdpr;
            cdprm = ( -cdpr - cgd - cbd + cds ) ;
            icdprm = ( -icdpr - icgd - icbd + icds ) ;
            cg = cgs + cgd + cgb ;
            icg = icgs + icgd + icgb ;
            cb = cbs + cbd - cgb ;
            icb = icbs + icbd - icgb ;

#ifdef SENSDEBUG
            printf("vbs = %.7e , vbd = %.7e , vgb = %.7e\n",vbs,vbd,vgb);
            printf("ivbs = %.7e , ivbd = %.7e , ivgb = %.7e\n",ivbs,ivbd,ivgb);
            printf("cbs = %.7e , cbd = %.7e , cgb = %.7e\n",cbs,cbd,cgb);
            printf("cb = %.7e , cg = %.7e , cs = %.7e\n",cb,cg,cs);
            printf("csprm = %.7e, cd = %.7e, cdprm = %.7e\n",csprm,cd,cdprm);
            printf("icb = %.7e , icg = %.7e , ics = %.7e\n",icb,icg,ics);
            printf("icsprm = %.7e, icd = %.7e, icdprm = %.7e\n",
                    icsprm,icd,icdprm);
#endif /* SENSDEBUG */
            for(iparmno = 1;iparmno<=info->SENparms;iparmno++){
                if( (flag == 4) && (iparmno != here->MOS9senParmNo) ) continue;
                if( (flag == 5) && (iparmno != (here->MOS9senParmNo + 
                        here->MOS9sens_l)) ) continue;

                switch(flag){
                case 1: 
                    DvDp = model->MOS9type * 
                            (info->SEN_Sap[here->MOS9bNode][iparmno]
                            -  info->SEN_Sap[here->MOS9sNodePrime][iparmno]);
                    break;
                case 2: 
                    DvDp = model->MOS9type * 
                            ( info->SEN_Sap[here->MOS9bNode][iparmno]
                            -  info->SEN_Sap[here->MOS9dNodePrime][iparmno]);
                    break;
                case 3: 
                    DvDp = model->MOS9type * 
                            ( info->SEN_Sap[here->MOS9gNode][iparmno]
                            -  info->SEN_Sap[here->MOS9bNode][iparmno]);
                    break;
                case 4: 
                    DvDp = 1;
                    break;
                case 5: 
                    DvDp = 1;
                    break;
                }
                *(info->SEN_RHS[here->MOS9bNode] + iparmno) -=  
                        ( cb  - cb0) * DELAinv * DvDp;
                *(info->SEN_iRHS[here->MOS9bNode] + iparmno) -=  
                        ( icb  - icb0) * DELAinv * DvDp;

                *(info->SEN_RHS[here->MOS9gNode] + iparmno) -=  
                        ( cg  - cg0) * DELAinv * DvDp;
                *(info->SEN_iRHS[here->MOS9gNode] + iparmno) -=  
                        ( icg  - icg0) * DELAinv * DvDp;

                if(here->MOS9sNode != here->MOS9sNodePrime){
                    *(info->SEN_RHS[here->MOS9sNode] + iparmno) -=  
                            ( cs  - cs0) * DELAinv * DvDp;
                    *(info->SEN_iRHS[here->MOS9sNode] + iparmno) -=  
                            ( ics  - ics0) * DELAinv * DvDp;
                }

                *(info->SEN_RHS[here->MOS9sNodePrime] + iparmno) -=  
                        ( csprm  - csprm0) * DELAinv * DvDp;
                *(info->SEN_iRHS[here->MOS9sNodePrime] + iparmno) -=  
                        ( icsprm  - icsprm0) * DELAinv * DvDp;

                if(here->MOS9dNode != here->MOS9dNodePrime){
                    *(info->SEN_RHS[here->MOS9dNode] + iparmno) -=  
                            ( cd  - cd0) * DELAinv * DvDp;
                    *(info->SEN_iRHS[here->MOS9dNode] + iparmno) -=  
                            ( icd  - icd0) * DELAinv * DvDp;
                }

                *(info->SEN_RHS[here->MOS9dNodePrime] + iparmno) -=  
                        ( cdprm  - cdprm0) * DELAinv * DvDp;
                *(info->SEN_iRHS[here->MOS9dNodePrime] + iparmno) -=  
                        ( icdprm  - icdprm0) * DELAinv * DvDp;
#ifdef SENSDEBUG
                printf("after loading\n");  
                printf("DvDp = %.5e , DELAinv = %.5e ,flag = %d ,",
                        DvDp,DELAinv,flag);
                printf("iparmno = %d,senparmno = %d\n",
                        iparmno,here->MOS9senParmNo);
                printf("A0 = %.5e , Apert = %.5e ,CONSTvt0 = %.5e \n",
                        A0,Apert,CONSTvt0);
                printf("senb = %.7e + j%.7e ",
                        *(info->SEN_RHS[here->MOS9bNode] + iparmno),
                        *(info->SEN_iRHS[here->MOS9bNode] + iparmno));
                printf("seng = %.7e + j%.7e ",
                        *(info->SEN_RHS[here->MOS9gNode] + iparmno),
                        *(info->SEN_iRHS[here->MOS9gNode] + iparmno));
                printf("sens = %.7e + j%.7e ",
                        *(info->SEN_RHS[here->MOS9sNode] + iparmno),
                        *(info->SEN_iRHS[here->MOS9sNode] + iparmno));
                printf("sensprm = %.7e + j%.7e ",
                        *(info->SEN_RHS[here->MOS9sNodePrime] + iparmno),
                        *(info->SEN_iRHS[here->MOS9sNodePrime] + iparmno));
                printf("send = %.7e + j%.7e ",
                        *(info->SEN_RHS[here->MOS9dNode] + iparmno),
                        *(info->SEN_iRHS[here->MOS9dNode] + iparmno));
                printf("sendprm = %.7e + j%.7e ",
                        *(info->SEN_RHS[here->MOS9dNodePrime] + iparmno),
                        *(info->SEN_iRHS[here->MOS9dNodePrime] + iparmno));
#endif /* SENSDEBUG */

            }
            switch(flag){
            case 1: 
                goto pertvbd ;
            case 2: 
                goto pertvgb ; 
            case 3: 
                goto pertl ;
            case 4: 
                goto pertw ;
            case 5: 
                break; 
            }
next:                   
            ;

            /* put the unperturbed values back into the state vector */
            for(i=0; i <= 16; i++)
                *(ckt->CKTstate0 + here->MOS9states + i) = *(SaveState + i);

            here->MOS9sourceConductance = *(SaveState + 17) ;
            here->MOS9drainConductance = *(SaveState + 18) ; 
            here->MOS9cd =  *(SaveState + 19) ;  
            here->MOS9cbs =  *(SaveState + 20) ;  
            here->MOS9cbd =  *(SaveState + 21) ;  
            here->MOS9gmbs =  *(SaveState + 22) ;  
            here->MOS9gm =  *(SaveState + 23) ;  
            here->MOS9gds =  *(SaveState + 24) ;  
            here->MOS9gbd =  *(SaveState + 25) ;  
            here->MOS9gbs =  *(SaveState + 26) ;  
            here->MOS9capbd =  *(SaveState + 27) ;  
            here->MOS9capbs =  *(SaveState + 28) ;  
            here->MOS9Cbd =  *(SaveState + 29) ;  
            here->MOS9Cbdsw =  *(SaveState + 30) ;  
            here->MOS9Cbs =  *(SaveState + 31) ;  
            here->MOS9Cbssw =  *(SaveState + 32) ;  
            here->MOS9f2d =  *(SaveState + 33) ;  
            here->MOS9f3d =  *(SaveState + 34) ;  
            here->MOS9f4d =  *(SaveState + 35) ;  
            here->MOS9f2s =  *(SaveState + 36) ;  
            here->MOS9f3s =  *(SaveState + 37) ;  
            here->MOS9f4s =  *(SaveState + 38) ;  
            here->MOS9cgs = *(SaveState + 39) ;  
            here->MOS9cgd = *(SaveState + 40) ;  
            here->MOS9cgb = *(SaveState + 41) ;  
            here->MOS9vdsat = *(SaveState + 42) ;  
            here->MOS9von = *(SaveState + 43) ;  
            here->MOS9mode = save_mode ;  

            here->MOS9senPertFlag = OFF;
        }
    }
    info->SENstatus = NORMAL;
#ifdef SENSDEBUG
    printf("MOS9senacload end\n");
#endif /* SENSDEBUG */
    return(OK);
}


