soi3cap.c

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

                    (vGT+Qcprime)*(Dalpha_Dvdb/gamma)) -
                  delta*(vGT+Qcprime)*Dalpha_Dvdb
                 )/(alpha*alpha)
                );
*cbs = -gamma * (pDBf_Dpsi_st0*Dpsi_st0_Dvsb +
                 (alpha*(delta*(DvGT_Dvsb + ccs) +
                    (vGT+Qcprime)*(Dalpha_Dvsb/gamma)) -
                  delta*(vGT+Qcprime)*Dalpha_Dvsb
                 )/(alpha*alpha)
                );
*cbdeltaT = -gamma * (pDBf_Dpsi_st0*Dpsi_st0_DdeltaT +
                 (alpha*(delta*(DvGT_DdeltaT + ccdeltaT) +
                    (vGT+Qcprime)*(Dalpha_DdeltaT/gamma)) -
                  delta*(vGT+Qcprime)*Dalpha_DdeltaT
                 )/(alpha*alpha)
                );
*cbgb = 0;


/****** Part 6 - Normalised expressions from part 4 are adjusted  ******/
/****** by WCox*Lprime, then accumulation charge is added to give ******/
/****** final expression for GCA region charges.                  ******/

/* Accumulation charge to be added to Qb */

vg = vGT + gamma*Bf;
if ((-vg/vt) > MAX_EXP_ARG) {
  vgacc = vg;
  tmpacc = 1;
} else {
  Egacc = exp(-vg/vt);
  vgacc = -vt*log(1+Egacc);
  tmpacc = Egacc/(1+Egacc);
}
Qacc = -WCox*L*vgacc;

/* Now work out GCA region charges */

*Qb = WCox*Lprime*Qbprime + Qacc;

*Qd = WCox*Lprime*Qdprime;

*Qg = WCox*Lprime*Qgprime - Qacc;


/****** Part 7 - calculate normalised (see note below) terminal  ******/
/****** charge expressions for the saturated drain region.       ******/

Qc2prime = -Vqd;

/* Basic expression for the intrinsic body charge in the saturation region is */
/* modified by csf, to reflect the fact that the body charge will be shared   */
/* between the gate and the drain/body depletion region.  This factor must be */
/* between 0 and 1, since it represents the fraction of ld over which qb is   */
/* integrated to give Qb2. */
Qb2prime = -gamma*csf*(Bf + delta*psi_sL);

Qd2prime = 0.5*Qc2prime;
/* JimB - 9/1/99. Re-partition drain region charge */
/* Qd2prime = Qc2prime; */

Qg2prime = -Qc2prime-Qb2prime;

*Qb += WCox*ld*Qb2prime;
*Qd += WCox*ld*Qd2prime;
*Qg += WCox*ld*Qg2prime;


/****** Part 8 - calculate full capacitance expressions, accounting ******/
/****** for both GCA and drain region contributions.  As explained  ******/
/****** in part 5, *cbgf, *cbd etc only derivatives of GCA charge   ******/
/****** expression w.r.t. Vx.  Now need to include Lprime/ld        ******/
/****** dependence on Vx as well.                                   ******/

*cbgf = WCox*(Lprime*(*cbgf) - ld*csf*(pDBf_Dpsi_st0*Dpsi_st0_Dvgfb + delta*Dpsi_sL_Dvgfb +
					(psi_sL*Dalpha_Dvgfb/gamma)) +
					(Qb2prime - Qbprime/(Fc*Fc))*Dld_Dvgfb
               );
*cbd  = WCox*(Lprime*(*cbd) - ld*csf*(pDBf_Dpsi_st0*Dpsi_st0_Dvdb + delta*Dpsi_sL_Dvdb +
					(psi_sL*Dalpha_Dvdb/gamma)) +
					(Qb2prime - Qbprime/(Fc*Fc))*Dld_Dvdb
               );
*cbs  = WCox*(Lprime*(*cbs) - ld*csf*(pDBf_Dpsi_st0*Dpsi_st0_Dvsb + delta*Dpsi_sL_Dvsb +
					(psi_sL*Dalpha_Dvsb/gamma)) +
					(Qb2prime - Qbprime/(Fc*Fc))*Dld_Dvsb
               );
*cbdeltaT  = WCox*(Lprime*(*cbdeltaT) - ld*csf*(pDBf_Dpsi_st0*Dpsi_st0_DdeltaT + delta*Dpsi_sL_DdeltaT +
					(psi_sL*Dalpha_DdeltaT/gamma)) +
					(Qb2prime - Qbprime/(Fc*Fc))*Dld_DdeltaT
               );
*cbgb = 0;

               
ccgf = WCox*(Lprime*(ccgf) - ld*(DvGT_Dvgfb - alpha*Dpsi_sL_Dvgfb - psi_sL*Dalpha_Dvgfb) +
              (Qc2prime - Qcprime/(Fc*Fc))*Dld_Dvgfb
             );
ccd  = WCox*(Lprime*(ccd) - ld*(DvGT_Dvdb - alpha*Dpsi_sL_Dvdb - psi_sL*Dalpha_Dvdb) +
              (Qc2prime - Qcprime/(Fc*Fc))*Dld_Dvdb
             );
ccs  = WCox*(Lprime*(ccs) - ld*(DvGT_Dvsb - alpha*Dpsi_sL_Dvsb - psi_sL*Dalpha_Dvsb) +
              (Qc2prime - Qcprime/(Fc*Fc))*Dld_Dvsb
             );
ccdeltaT  = WCox*(Lprime*(ccdeltaT) - 
              ld*(DvGT_DdeltaT - alpha*Dpsi_sL_DdeltaT - psi_sL*Dalpha_DdeltaT) +
              (Qc2prime - Qcprime/(Fc*Fc))*Dld_DdeltaT
             );
ccgb = 0;


*cdgf = WCox*(Lprime*(*cdgf) - 0.5*ld*(DvGT_Dvgfb - alpha*Dpsi_sL_Dvgfb - psi_sL*Dalpha_Dvgfb) +
              (Qd2prime - Qdprime/(Fc*Fc))*Dld_Dvgfb
             );
*cdd  = WCox*(Lprime*(*cdd) - 0.5*ld*(DvGT_Dvdb - alpha*Dpsi_sL_Dvdb - psi_sL*Dalpha_Dvdb) +
              (Qd2prime - Qdprime/(Fc*Fc))*Dld_Dvdb
             );
*cds  = WCox*(Lprime*(*cds) - 0.5*ld*(DvGT_Dvsb - alpha*Dpsi_sL_Dvsb - psi_sL*Dalpha_Dvsb) +
              (Qd2prime - Qdprime/(Fc*Fc))*Dld_Dvsb
             );
*cddeltaT  = WCox*(Lprime*(*cddeltaT) - 0.5*ld*(DvGT_DdeltaT -
                    alpha*Dpsi_sL_DdeltaT - psi_sL*Dalpha_DdeltaT) +
              (Qd2prime - Qdprime/(Fc*Fc))*Dld_DdeltaT
             );
*cdgb = 0;

/****** Part 9 - Finally, include accumulation charge derivatives. ******/

/* Now include accumulation charge derivs */

*cbgf += -WCox*L*tmpacc;
*cbd  += -WCox*L*tmpacc*sigma;
*cbs  += -WCox*L*tmpacc*(-sigma);
*cbdeltaT += -WCox*L*tmpacc*chiFB;
*cbgb += 0;

*cgfgf = -(ccgf + *cbgf);
*cgfd = -(ccd + *cbd);
*cgfs = -(ccs + *cbs);
*cgfdeltaT = -(ccdeltaT + *cbdeltaT);
*cgfgb = 0;

/****** Part 10 - Back gate stuff - doesn't work, so set to zero.  ******/

/* Should move this before the accumulation section for consistency, but */
/* doesn't matter, as all intrinsic back-gate capacitances set to zero
anyway. */

*QgB = 0;

*cgbgf = 0;
*cgbd = 0;
*cgbs = 0;
*cgbgb = 0;
*cgbdeltaT = 0;

}

void
SOI3capEval(CKTcircuit *ckt,
            double Frontcapargs[6],
            double Backcapargs[6],
            double cgfgf, double cgfd, double cgfs, double cgfdeltaT, double cgfgb,
            double cdgf, double cdd, double cds, double cddeltaT, double cdgb,
            double csgf, double csd, double css, double csdeltaT, double csgb,
            double cbgf, double cbd, double cbs, double cbdeltaT, double cbgb,
            double cgbgf, double cgbd, double cgbs, double cgbdeltaT, double cgbgb,
            
	    double *gcgfgf, double *gcgfd, double *gcgfs, double *gcgfdeltaT, double *gcgfgb,
            double *gcdgf, double *gcdd, double *gcds, double *gcddeltaT, double *gcdgb,
            double *gcsgf, double *gcsd, double *gcss, double *gcsdeltaT, double *gcsgb,
            double *gcbgf, double *gcbd, double *gcbs, double *gcbdeltaT, double *gcbgb,
            double *gcgbgf, double *gcgbd, double *gcgbs, double *gcgbdeltaT, double *gcgbgb,
            double *qgatef, double *qbody, double *qdrn, double *qsrc, double *qgateb)

{
double cgfd0,cgfs0,cgfb0;
double cgbd0,cgbs0,cgbb0;
double vgfd,vgfs,vgfb;
double vgbd,vgbs,vgbb;
double ag0;
double qgfd,qgfs,qgfb;
double qgbd,qgbs,qgbb;

cgfd0 = Frontcapargs[0];
cgfs0 = Frontcapargs[1];
cgfb0 = Frontcapargs[2];
vgfd = Frontcapargs[3];
vgfs = Frontcapargs[4];
vgfb = Frontcapargs[5];

cgbd0 = Backcapargs[0];
cgbs0 = Backcapargs[1];
cgbb0 = Backcapargs[2];
vgbd = Backcapargs[3];
vgbs = Backcapargs[4];
vgbb = Backcapargs[5];

/* stuff below includes overlap caps' conductances */
ag0 = ckt->CKTag[0];

*gcgfgf = (cgfgf + cgfd0 + cgfs0 + cgfb0) * ag0;
*gcgfd  = (cgfd - cgfd0) * ag0;
*gcgfs  = (cgfs - cgfs0) * ag0;
*gcgfdeltaT = cgfdeltaT * ag0;
*gcgfgb = cgfgb * ag0;

*gcdgf = (cdgf - cgfd0) * ag0;
*gcdd  = (cdd + cgfd0 + cgbd0) * ag0;
*gcds  = cds * ag0;
*gcddeltaT = cddeltaT * ag0;
*gcdgb = (cdgb - cgbd0) * ag0;

*gcsgf = (csgf - cgfs0) * ag0;
*gcsd  = csd * ag0;
*gcss  = (css + cgfs0 + cgbs0) * ag0;
*gcsdeltaT = csdeltaT * ag0;
*gcsgb = (csgb - cgbs0) * ag0;

*gcbgf = (cbgf - cgfb0) * ag0;
*gcbd  = cbd * ag0;
*gcbs  = cbs * ag0;
*gcbdeltaT = cbdeltaT * ag0;
*gcbgb = (cbgb - cgbb0) * ag0;

*gcgbgf = cgbgf * ag0;
*gcgbd  = (cgbd - cgbd0) * ag0;
*gcgbs  = (cgbs - cgbs0) * ag0;
*gcgbdeltaT = cgbdeltaT * ag0;
*gcgbgb = (cgbgb + cgbd0 + cgbs0 + cgbb0) * ag0;

qgfd = cgfd0 * vgfd;
qgfs = cgfs0 * vgfs;
qgfb = cgfb0 * vgfb;

qgbd = cgbd0 * vgbd;
qgbs = cgbs0 * vgbs;
qgbb = cgbb0 * vgbb;

*qgatef = *qgatef + qgfd + qgfs + qgfb;
*qbody  = *qbody - qgfb - qgbb;
*qdrn   = *qdrn - qgfd - qgbd;
*qgateb = *qgateb + qgbd + qgbs + qgbb;
*qsrc = -(*qgatef + *qbody + *qdrn + *qgateb);
}