/********** Copyright 1990 Regents of the University of California. All rights reserved. Author: 1985 Hong J. Park, Thomas L. Quarles **********/ #include "ngspice/ngspice.h" #include "ngspice/cktdefs.h" #include "bsim1def.h" #include "ngspice/trandefs.h" #include "ngspice/distodef.h" #include "ngspice/const.h" #include "ngspice/sperror.h" #include "ngspice/suffix.h" #include "ngspice/devdefs.h" int B1dSetup(GENmodel *inModel, CKTcircuit *ckt) { B1model* model = (B1model*)inModel; B1instance *here; double DrainSatCurrent; double EffectiveLength; double GateBulkOverlapCap; double GateDrainOverlapCap; double GateSourceOverlapCap; double SourceSatCurrent; double DrainArea; double SourceArea; double DrainPerimeter; double SourcePerimeter; double vt0; double evbs; double lgbs1, lgbs2, lgbs3; double czbd, czbs, czbdsw, czbssw; double PhiB, MJ, MJSW, PhiBSW; double arg, argsw, sarg, sargsw; double capbs1, capbs2, capbs3; double capbd1, capbd2, capbd3; double qg; double qb; double qd; double Vfb; double Phi; double K1; double K2; double Vdd; double Ugs; double Uds; double Leff; double Eta; double Vpb; double SqrtVpb; double Von; double Vth; double DrCur; double G; double A; double Arg; double Beta; double Beta_Vds_0; double BVdd; double Beta0; double VddSquare; double C1; double C2; double VdsSat; double Argl1; double Argl2; double Vc; double Term1; double K; double Args1; double Args2; double Args3; double Warg1; double Vcut; double N; double N0; double NB; double ND; double Warg2; double Wds; double Wgs; double Ilimit; double Iexp; double Vth0; double Arg1; double Arg2; double Arg3; double Arg5; double Ent; double Vcom; double Vgb; double Vgb_Vfb; double VdsPinchoff; double EntSquare; double Argl5; double Argl6; double Argl7; double WLCox; double Vtsquare; int ChargeComputationNeeded; double co4v15; double VgsVth = 0.0; double lgbd1, lgbd2, lgbd3, evbd; double vbd = 0.0; double vgd = 0.0; double vgb = 0.0; double vds = 0.0; double vgs = 0.0; double vbs = 0.0; double dBVdddVds; Dderivs d_Argl6; Dderivs d_Vgb, d_Vgb_Vfb, d_EntSquare, d_Argl5, d_Argl7; Dderivs d_Arg5, d_Ent, d_Vcom, d_VdsPinchoff; Dderivs d_qb, d_qd, d_Vth0, d_Arg1, d_Arg2, d_Arg3; Dderivs d_dummy, d_Vth, d_BVdd, d_Warg1, d_qg; Dderivs d_N, d_Wds, d_Wgs, d_Iexp; Dderivs d_Argl1, d_Argl2, d_Args1, d_Args2, d_Args3; Dderivs d_Beta, d_Vc, d_Term1, d_K, d_VdsSat; Dderivs d_Beta_Vds_0, d_C1, d_C2, d_Beta0; Dderivs d_VgsVth, d_G, d_A, d_Arg, d_DrCur; Dderivs d_Ugs, d_Uds, d_Eta, d_Vpb, d_SqrtVpb, d_Von; Dderivs d_p, d_q, d_r, d_zero; /* loop through all the B1 device models */ for( ; model != NULL; model = model->B1nextModel ) { /* loop through all the instances of the model */ for (here = model->B1instances; here != NULL ; here=here->B1nextInstance) { EffectiveLength=here->B1l - model->B1deltaL * 1.e-6;/* m */ DrainArea = here->B1m * here->B1drainArea; SourceArea = here->B1m * here->B1sourceArea; DrainPerimeter = here->B1m * here->B1drainPerimeter; SourcePerimeter = here->B1m * here->B1sourcePerimeter; if( (DrainSatCurrent=DrainArea*model->B1jctSatCurDensity) < 1e-15){ DrainSatCurrent = 1.0e-15; } if( (SourceSatCurrent=SourceArea*model->B1jctSatCurDensity) <1.0e-15){ SourceSatCurrent = 1.0e-15; } GateSourceOverlapCap = model->B1gateSourceOverlapCap * here->B1w * here->B1m; GateDrainOverlapCap = model->B1gateDrainOverlapCap * here->B1w * here-> B1m; GateBulkOverlapCap = model->B1gateBulkOverlapCap *EffectiveLength; vt0 = model->B1type * here->B1vt0; vbs = model->B1type * ( *(ckt->CKTrhsOld+here->B1bNode) - *(ckt->CKTrhsOld+here->B1sNodePrime)); vgs = model->B1type * ( *(ckt->CKTrhsOld+here->B1gNode) - *(ckt->CKTrhsOld+here->B1sNodePrime)); vds = model->B1type * ( *(ckt->CKTrhsOld+here->B1dNodePrime) - *(ckt->CKTrhsOld+here->B1sNodePrime)); if(vds >= 0) { /* normal mode */ here->B1mode = 1; } else { /* inverse mode */ here->B1mode = -1; vds = -vds; vgs = vgs + vds; /* these are the local(fake) values now */ vbs = vbs + vds; } vgb = vgs - vbs; vgd = vgs - vds; vbd = vbs - vds; if(vbs <= 0.0 ) { lgbs1 = SourceSatCurrent / CONSTvt0 + ckt->CKTgmin; lgbs2 = lgbs3 = 0.0; } else { evbs = exp(vbs/CONSTvt0); lgbs1 = SourceSatCurrent*evbs/CONSTvt0 + ckt->CKTgmin; lgbs2 = (lgbs1 - ckt->CKTgmin)/(CONSTvt0*2); lgbs3 = lgbs2/(CONSTvt0*3); } if(vbd <= 0.0) { lgbd1 = DrainSatCurrent / CONSTvt0 + ckt->CKTgmin; lgbd2 = lgbd3 = 0.0; } else { evbd = exp(vbd/CONSTvt0); lgbd1 = DrainSatCurrent*evbd/CONSTvt0 + ckt->CKTgmin; lgbd2 = (lgbd1 - ckt->CKTgmin)/(CONSTvt0*2); lgbd3 = lgbd2/(CONSTvt0*3); } /* line 400 */ /* call B1evaluate to calculate drain current and its * derivatives and charge and capacitances related to gate * drain, and bulk */ /* check quadratic interpolation for beta0 ; line 360 */ /* * Copyright (c) 1985 Hong J. Park, Thomas L. Quarles * modified 1988 Jaijeet Roychowdhury */ /* This routine evaluates the drain current, its derivatives and the * charges associated with the gate,bulk and drain terminal * using the B1 (Berkeley Short-Channel IGFET Model) Equations. */ /* as usual p=vgs, q=vbs, r=vds */ { ChargeComputationNeeded = 1; Vfb = here->B1vfb; Phi = here->B1phi; K1 = here->B1K1; K2 = here->B1K2; Vdd = model->B1vdd; d_p.value = 0.0; d_p.d1_p = 1.0; d_p.d1_q = 0.0; d_p.d1_r = 0.0; d_p.d2_p2 = 0.0; d_p.d2_q2 = 0.0; d_p.d2_r2 = 0.0; d_p.d2_pq = 0.0; d_p.d2_qr = 0.0; d_p.d2_pr = 0.0; d_p.d3_p3 = 0.0; d_p.d3_q3 = 0.0; d_p.d3_r3 = 0.0; d_p.d3_p2r = 0.0; d_p.d3_p2q = 0.0; d_p.d3_q2r = 0.0; d_p.d3_pq2 = 0.0; d_p.d3_pr2 = 0.0; d_p.d3_qr2 = 0.0; d_p.d3_pqr = 0.0; EqualDeriv(&d_q,&d_p); EqualDeriv(&d_r,&d_p); EqualDeriv(&d_zero,&d_p); d_q.d1_p = d_r.d1_p = d_zero.d1_p = 0.0; d_q.d1_q = d_r.d1_r = 1.0; d_p.value = vgs; d_q.value = vbs; d_r.value = vds; if((Ugs = here->B1ugs + here->B1ugsB * vbs) <= 0 ) { Ugs = 0; EqualDeriv(&d_Ugs,&d_zero); } else { EqualDeriv(&d_Ugs,&d_q); d_Ugs.value = Ugs; d_Ugs.d1_q = here->B1ugsB; } if((Uds = here->B1uds + here->B1udsB * vbs + here->B1udsD*(vds-Vdd)) <= 0 ) { Uds = 0.0; EqualDeriv(&d_Uds,&d_zero); } else { Leff = here->B1l * 1.e6 - model->B1deltaL; /* Leff in um */ /*const*/ Uds = Uds / Leff; /* Uds = (here->B1uds + here->B1udsB * vbs here->B1udsD* (vds-Vdd))/Leff */ EqualDeriv(&d_Uds,&d_r); d_Uds.value = Uds; d_Uds.d1_r = here->B1udsD/Leff; d_Uds.d1_q = here->B1udsB/Leff; } Eta = here->B1eta + here->B1etaB * vbs + here->B1etaD * (vds - Vdd); EqualDeriv(&d_Eta,&d_r); d_Eta.value = Eta; d_Eta.d1_r = here->B1etaD; d_Eta.d1_q = here->B1etaB; if( Eta <= 0 ) { Eta = 0; EqualDeriv(&d_Eta,&d_zero); } else if ( Eta > 1 ) { Eta = 1; EqualDeriv(&d_Eta,&d_zero); d_Eta.value = 1.0; } if( vbs < 0 ) { Vpb = Phi - vbs; EqualDeriv(&d_Vpb,&d_q); d_Vpb.value = Vpb; d_Vpb.d1_q = -1; } else { Vpb = Phi; EqualDeriv(&d_Vpb,&d_zero); d_Vpb.value = Phi; } SqrtVpb = sqrt( Vpb ); SqrtDeriv(&d_SqrtVpb,&d_Vpb); Von = Vfb + Phi + K1 * SqrtVpb - K2 * Vpb - Eta * vds; EqualDeriv(&d_dummy,&d_r); d_dummy.value = -Eta*vds; d_dummy.d1_r = -Eta; TimesDeriv(&d_Von,&d_Vpb,-K2); PlusDeriv(&d_Von,&d_Von,&d_dummy); TimesDeriv(&d_dummy,&d_SqrtVpb,K1); PlusDeriv(&d_Von,&d_dummy,&d_Von); d_Von.value = Von; Vth = Von; EqualDeriv(&d_Vth,&d_Von); VgsVth = vgs - Vth; TimesDeriv(&d_VgsVth,&d_Vth,-1.0); d_VgsVth.value = VgsVth; d_VgsVth.d1_p += 1.0; G = 1./(1.744+0.8364 * Vpb); TimesDeriv(&d_G,&d_Vpb,0.8364); d_G.value += 1.744; InvDeriv(&d_G,&d_G); G = 1 - G; TimesDeriv(&d_G,&d_G,-1.0); d_G.value += 1.0; A = G/SqrtVpb; DivDeriv(&d_A,&d_G,&d_SqrtVpb); A = 1.0 + 0.5*K1*A; TimesDeriv(&d_A,&d_A,0.5*K1); d_A.value += 1.0; A = MAX( A, 1.0); /* Modified */ if (A <= 1.0) { EqualDeriv(&d_A,&d_zero); d_A.value = 1.0; } Arg = MAX(( 1 + Ugs * VgsVth), 1.0); MultDeriv(&d_dummy,&d_Ugs,&d_VgsVth); d_dummy.value += 1.0; if (d_dummy.value <= 1.0) { EqualDeriv(&d_Arg,&d_zero); d_Arg.value = 1.0; } else EqualDeriv(&d_Arg,&d_dummy); if( VgsVth < 0 ) { /* cutoff */ DrCur = 0; EqualDeriv(&d_DrCur,&d_zero); goto SubthresholdComputation; } /* Quadratic Interpolation for Beta0 (Beta at vgs = 0, vds=Vds) */ Beta_Vds_0 = (here->B1betaZero + here->B1betaZeroB * vbs); EqualDeriv(&d_Beta_Vds_0,&d_q); d_Beta_Vds_0.value = Beta_Vds_0; d_Beta_Vds_0.d1_q = here->B1betaZeroB; BVdd = (here->B1betaVdd + here->B1betaVddB * vbs); EqualDeriv(&d_BVdd,&d_q); d_BVdd.value = BVdd; d_BVdd.d1_q = here->B1betaVddB; dBVdddVds = MAX( here->B1betaVddD, 0.0); /* is the above wrong ?!? */ if( vds > Vdd ) { Beta0 = BVdd + dBVdddVds * (vds - Vdd); EqualDeriv(&d_Beta0,&d_r); d_Beta0.value = vds - Vdd; TimesDeriv(&d_Beta0,&d_Beta0,dBVdddVds); PlusDeriv(&d_Beta0,&d_Beta0,&d_BVdd); /* dBVdddVds = const */ /* and this stuff here? */ } else { VddSquare = Vdd * Vdd; /* const */ C1 = ( -BVdd + Beta_Vds_0 + dBVdddVds * Vdd) / VddSquare; TimesDeriv(&d_C1,&d_BVdd,-1.0); PlusDeriv(&d_C1,&d_C1,&d_Beta_Vds_0); d_C1.value += dBVdddVds * Vdd; TimesDeriv(&d_C1,&d_C1,1/VddSquare); C2 = 2 * (BVdd - Beta_Vds_0) / Vdd - dBVdddVds; TimesDeriv(&d_C2,&d_Beta_Vds_0,-1.0); PlusDeriv(&d_C2,&d_C2,&d_BVdd); TimesDeriv(&d_C2,&d_C2,2/Vdd); d_C2.value -= dBVdddVds; Beta0 = (C1 * vds + C2) * vds + Beta_Vds_0; MultDeriv(&d_Beta0,&d_r,&d_C1); PlusDeriv(&d_Beta0,&d_Beta0,&d_C2); MultDeriv(&d_Beta0,&d_Beta0,&d_dummy); PlusDeriv(&d_Beta0,&d_Beta0,&d_Beta_Vds_0); /* dBeta0dVds = 2*C1*vds + C2; dBeta0dVbs = dC1dVbs * vds * vds + dC2dVbs * vds + dBeta_Vds_0_dVbs; maybe we'll need these later */ } /*Beta = Beta0 / ( 1 + Ugs * VgsVth );*/ Beta = Beta0 / Arg ; DivDeriv(&d_Beta,&d_Beta0,&d_Arg); /*VdsSat = MAX( VgsVth / ( A + Uds * VgsVth ), 0.0);*/ Vc = Uds * VgsVth / A; DivDeriv(&d_Vc,&d_VgsVth,&d_A); MultDeriv(&d_Vc,&d_Vc,&d_Uds); if(Vc < 0.0 ) { EqualDeriv(&d_Vc,&d_zero); Vc=0.0; } Term1 = sqrt( 1 + 2 * Vc ); TimesDeriv(&d_Term1,&d_Vc,2.0); d_Term1.value += 1.0; SqrtDeriv(&d_Term1,&d_Term1); K = 0.5 * ( 1 + Vc + Term1 ); PlusDeriv(&d_K,&d_Vc,&d_Term1); d_K.value += 1.0; TimesDeriv(&d_K,&d_K,0.5); VdsSat = VgsVth / ( A * sqrt(K)); if (VdsSat < 0.0) { EqualDeriv(&d_VdsSat,&d_zero); VdsSat = 0.0; } else { SqrtDeriv(&d_VdsSat,&d_K); MultDeriv(&d_VdsSat,&d_VdsSat,&d_A); DivDeriv(&d_VdsSat,&d_VgsVth,&d_VdsSat); } if( vds < VdsSat ) { /* Triode Region */ /*Argl1 = 1 + Uds * vds;*/ Argl1 = 1 + Uds * vds; if (Argl1 < 1.0) { Argl1 = 1.0; EqualDeriv(&d_Argl1,&d_zero); d_Argl1.value = 1.0; } else { MultDeriv(&d_Argl1,&d_r,&d_Uds); d_Argl1.value += 1.0; } Argl2 = VgsVth - 0.5 * A * vds; MultDeriv(&d_Argl2,&d_r,&d_A); TimesDeriv(&d_Argl2,&d_Argl2,-0.5); PlusDeriv(&d_Argl2,&d_Argl2,&d_VgsVth); DrCur = Beta * Argl2 * vds / Argl1; DivDeriv(&d_DrCur,&d_r,&d_Argl1); MultDeriv(&d_DrCur,&d_DrCur,&d_Argl2); MultDeriv(&d_DrCur,&d_DrCur,&d_Beta); } else { /* Pinchoff (Saturation) Region */ /* history Args1 = 1.0 + 1. / Term1; InvDeriv(&d_Args1,&d_Term1); d_Args1.value += 1.0; */ /* dVcdVgs = Uds / A; dVcdVds = VgsVth * dUdsdVds / A - dVcdVgs * dVthdVds; dVcdVbs = ( VgsVth * dUdsdVbs - Uds * (dVthdVbs + VgsVth * dAdVbs / A ))/ A; dKdVc = 0.5* Args1; dKdVgs = dKdVc * dVcdVgs; dKdVds = dKdVc * dVcdVds; dKdVbs = dKdVc * dVcdVbs; */ Args2 = VgsVth / A / K; MultDeriv(&d_Args2,&d_A,&d_K); DivDeriv(&d_Args2,&d_VgsVth,&d_Args2); Args3 = Args2 * VgsVth; MultDeriv(&d_Args3,&d_Args2,&d_VgsVth); DrCur = 0.5 * Beta * Args3; MultDeriv(&d_DrCur,&d_Beta,&d_Args3); TimesDeriv(&d_DrCur,&d_DrCur,0.5); } SubthresholdComputation: N0 = here->B1subthSlope;/*const*/ Vcut = - 40. * N0 * CONSTvt0 ;/*const*/ if( (N0 >= 200) || (VgsVth < Vcut ) || (VgsVth > (-0.5*Vcut))) { goto ChargeComputation; } NB = here->B1subthSlopeB;/*const*/ ND = here->B1subthSlopeD;/*const*/ N = N0 + NB * vbs + ND * vds; /* subthreshold slope */ EqualDeriv(&d_N,&d_r); d_N.value = N; d_N.d1_q = NB; d_N.d1_r = ND; if( N < 0.5 ){ N = 0.5; d_N.value = 0.5; d_N.d1_q = d_N.d1_r = 0.0; } Warg1 = exp( - vds / CONSTvt0 ); TimesDeriv(&d_Warg1,&d_r,-1/CONSTvt0); ExpDeriv(&d_Warg1,&d_Warg1); Wds = 1 - Warg1; TimesDeriv(&d_Wds,&d_Warg1,-1.0); d_Wds.value += 1.0; Wgs = exp( VgsVth / ( N * CONSTvt0 )); DivDeriv(&d_Wgs,&d_VgsVth,&d_N); TimesDeriv(&d_Wgs,&d_Wgs,1/CONSTvt0); ExpDeriv(&d_Wgs,&d_Wgs); Vtsquare = CONSTvt0 * CONSTvt0 ;/*const*/ Warg2 = 6.04965 * Vtsquare * here->B1betaZero;/*const*/ Ilimit = 4.5 * Vtsquare * here->B1betaZero;/*const*/ Iexp = Warg2 * Wgs * Wds; MultDeriv(&d_Iexp,&d_Wgs,&d_Wds); TimesDeriv(&d_Iexp,&d_Iexp,Warg2); DrCur = DrCur + Ilimit * Iexp / ( Ilimit + Iexp ); EqualDeriv(&d_dummy,&d_Iexp); d_dummy.value += Ilimit; InvDeriv(&d_dummy,&d_dummy); MultDeriv(&d_dummy,&d_dummy,&d_Iexp); TimesDeriv(&d_dummy,&d_dummy,Ilimit); PlusDeriv(&d_DrCur,&d_DrCur,&d_dummy); /* gds term has been modified to prevent blow up at Vds=0 */ /* gds = gds + Temp3 * ( -Wds / N / CONSTvt0 * (dVthdVds + VgsVth * ND / N ) + Warg1 / CONSTvt0 ); */ ChargeComputation: /* Some Limiting of DC Parameters */ /* if(DrCur < 0.0) DrCur = 0.0; if(gm < 0.0) gm = 0.0; if(gds < 0.0) gds = 0.0; if(gmbs < 0.0) gmbs = 0.0; */ WLCox = model->B1Cox * (here->B1l - model->B1deltaL * 1.e-6) * ((here->B1w - model->B1deltaW * 1.e-6) * here->B1m) * 1.e4; /* F */ if( ! ChargeComputationNeeded ) { qg = 0; qd = 0; qb = 0; EqualDeriv(&d_qg,&d_zero); EqualDeriv(&d_qb,&d_zero); EqualDeriv(&d_qd,&d_zero); goto finished; } G = 1.0 - 1./(1.744+0.8364 * Vpb); TimesDeriv(&d_G,&d_Vpb,-0.8364); d_G.value -= 1.744; InvDeriv(&d_G,&d_G); d_G.value += 1.0; A = 1.0 + 0.5*K1*G/SqrtVpb; if (A < 1.0) { A = 1.0; EqualDeriv(&d_A,&d_zero); d_A.value = 1.0; } else { DivDeriv(&d_A,&d_G,&d_SqrtVpb); TimesDeriv(&d_A,&d_A,0.5*K1); d_A.value += 1.0; } /*Arg = 1 + Ugs * VgsVth;*/ Phi = MAX( 0.1, Phi);/*const*/ if( model->B1channelChargePartitionFlag ) { /*0/100 partitioning for drain/source chArges at the saturation region*/ Vth0 = Vfb + Phi + K1 * SqrtVpb; TimesDeriv(&d_Vth0,&d_SqrtVpb,K1); d_Vth0.value += Vfb + Phi; VgsVth = vgs - Vth0; TimesDeriv(&d_VgsVth,&d_Vth0,-1.0); PlusDeriv(&d_VgsVth,&d_VgsVth,&d_p); Arg1 = A * vds; MultDeriv(&d_Arg1,&d_A,&d_r); Arg2 = VgsVth - 0.5 * Arg1; TimesDeriv(&d_Arg2,&d_Arg1,-0.5); PlusDeriv(&d_Arg2,&d_Arg2,&d_VgsVth); Arg3 = vds - Arg1; TimesDeriv(&d_Arg3,&d_Arg1,-1.0); PlusDeriv(&d_Arg3,&d_Arg3,&d_r); Arg5 = Arg1 * Arg1; MultDeriv(&d_Arg5,&d_Arg1,&d_Arg1); Ent = MAX(Arg2,1.0e-8); if (Arg2 < 1.0e-8) { EqualDeriv(&d_Ent,&d_zero); d_Ent.value = 1.0e-8; } else { EqualDeriv(&d_Ent,&d_Arg2); } Vcom = VgsVth * VgsVth / 6.0 - 1.25e-1 * Arg1 * VgsVth + 2.5e-2 * Arg5; TimesDeriv(&d_dummy,&d_Arg1,-0.125); TimesDeriv(&d_Vcom,&d_VgsVth,1/6.0); PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy); MultDeriv(&d_Vcom,&d_Vcom,&d_VgsVth); TimesDeriv(&d_dummy,&d_Arg5,2.5e-2); PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy); VdsPinchoff = VgsVth / A; if (VdsPinchoff < 0.0) { VdsPinchoff = 0.0; EqualDeriv(&d_VdsPinchoff,&d_zero); } else { DivDeriv(&d_VdsPinchoff,&d_VgsVth,&d_A); } Vgb = vgs - vbs ; EqualDeriv(&d_Vgb,&d_p); d_Vgb.value = Vgb; d_Vgb.d1_q = -1.0; Vgb_Vfb = Vgb - Vfb; EqualDeriv(&d_Vgb_Vfb,&d_Vgb); d_Vgb_Vfb.value -= Vfb; if( Vgb_Vfb < 0){ /* Accumulation Region */ qg = WLCox * Vgb_Vfb; TimesDeriv(&d_qg,&d_Vgb_Vfb,WLCox); qb = - qg; TimesDeriv(&d_qb,&d_qg,-1.0); qd = 0. ; EqualDeriv(&d_qd,&d_zero); goto finished; } else if ( vgs < Vth0 ){ /* Subthreshold Region */ qg = 0.5 * WLCox * K1 * K1 * (-1 + sqrt(1 + 4 * Vgb_Vfb / (K1 * K1))); TimesDeriv(&d_qg,&d_Vgb_Vfb,4/(K1*K1)); d_qg.value += 1.0; SqrtDeriv(&d_qg,&d_qg); d_qg.value -= 1.0; TimesDeriv(&d_qg,&d_qg,0.5 * WLCox * K1 * K1); qb = -qg; TimesDeriv(&d_qb,&d_qg,-1.0); qd = 0.; EqualDeriv(&d_qd,&d_zero); goto finished; } else if( vds < VdsPinchoff ){ /* triode region */ /*VgsVth2 = VgsVth*VgsVth;*/ EntSquare = Ent * Ent; MultDeriv(&d_EntSquare,&d_Ent,&d_Ent); Argl1 = 1.2e1 * EntSquare; TimesDeriv(&d_Argl1,&d_EntSquare,12.0); Argl2 = 1.0 - A; TimesDeriv(&d_Argl2,&d_A,-1.0); d_Argl2.value += 1.0; /* Argl3 = Arg1 * vds; MultDeriv(&d_Argl3,&d_Arg1,&d_r); */ /*Argl4 = Vcom/Ent/EntSquare;*/ if (Ent > 1.0e-8) { Argl5 = Arg1 / Ent; DivDeriv(&d_Argl5,&d_Arg1,&d_Ent); /*Argl6 = Vcom/EntSquare;*/ } else { Argl5 = 2.0; EqualDeriv(&d_Argl5,&d_zero); d_Argl5.value = 2.0; Argl6 = 4.0 / 1.5e1;/*const*/ } Argl7 = Argl5 / 1.2e1; TimesDeriv(&d_Argl7,&d_Argl5,1.0/12.0); /* Argl8 = 6.0 * Ent; TimesDeriv(&d_Argl8,&d_Ent,6.0); Argl9 = 0.125 * Argl5 * Argl5; MultDeriv(&d_Argl9,&d_Argl5,&d_Argl5); TimesDeriv(&d_Argl9,&d_Argl9,0.125); */ qg = WLCox * (vgs - Vfb - Phi - 0.5 * vds + vds * Argl7); EqualDeriv(&d_qg,&d_Argl7); d_qg.value -= 0.5; MultDeriv(&d_qg,&d_qg,&d_r); d_qg.value += vgs - Vfb - Phi; d_qg.d1_p += 1.0; TimesDeriv(&d_qg,&d_qg,WLCox); qb = WLCox * ( - Vth0 + Vfb + Phi + 0.5 * Arg3 - Arg3 * Argl7); TimesDeriv(&d_qb,&d_Argl7,-1.0); d_qb.value += 0.5; MultDeriv(&d_qb,&d_qb,&d_Arg3); d_qb.value += Vfb + Phi; TimesDeriv(&d_dummy,&d_Vth0,-1.0); PlusDeriv(&d_qb,&d_qb,&d_dummy); TimesDeriv(&d_qb,&d_qb,WLCox); qd = - WLCox * (0.5 * VgsVth - 0.75 * Arg1 + 0.125 * Arg1 * Argl5); TimesDeriv(&d_qd,&d_Argl5,0.125); d_qd.value -= 0.75; MultDeriv(&d_qd,&d_qd,&d_Arg1); TimesDeriv(&d_dummy,&d_VgsVth,0.5); PlusDeriv(&d_qd,&d_qd,&d_dummy); TimesDeriv(&d_qd,&d_qd, -WLCox); goto finished; } else if( vds >= VdsPinchoff ) { /* saturation region */ Args1 = 1.0 / (3*A); TimesDeriv(&d_Args1,&d_A,3.0); InvDeriv(&d_Args1,&d_Args1); qg = WLCox * (vgs - Vfb - Phi - VgsVth * Args1); MultDeriv(&d_qg,&d_VgsVth,&d_Args1); d_qg.value += Vfb + Phi - vgs; d_qg.d1_p -= 1.0; TimesDeriv(&d_qg,&d_qg,-WLCox); qb = WLCox * (Vfb + Phi - Vth0 + (1.0 - A) * VgsVth * Args1); TimesDeriv(&d_dummy,&d_A,-1.0); d_dummy.value += 1.0; MultDeriv(&d_qb,&d_VgsVth, &d_dummy); MultDeriv(&d_qb,&d_qb,&d_Args1); d_qb.value += Vfb + Phi; TimesDeriv(&d_dummy,&d_Vth0,-1.0); PlusDeriv(&d_qb,&d_qb,&d_dummy); TimesDeriv(&d_qb,&d_qb,WLCox); qd = 0.0; EqualDeriv(&d_qd,&d_zero); goto finished; } goto finished; } else { /*0/100 partitioning for drain/source chArges at the saturation region*/ co4v15 = 1./15.; Vth0 = Vfb + Phi + K1 * SqrtVpb; TimesDeriv(&d_Vth0,&d_SqrtVpb,K1); d_Vth0.value += Vfb + Phi; VgsVth = vgs - Vth0; TimesDeriv(&d_VgsVth,&d_Vth0,-1.0); d_VgsVth.value += vgs; d_VgsVth.d1_p += 1.0; Arg1 = A * vds; MultDeriv(&d_Arg1,&d_A,&d_r); Arg2 = VgsVth - 0.5 * Arg1; TimesDeriv(&d_Arg2,&d_Arg1,-0.5); PlusDeriv(&d_Arg2,&d_Arg2,&d_VgsVth); Arg3 = vds - Arg1; TimesDeriv(&d_Arg3,&d_Arg1,-1.0); d_Arg3.value = Arg3; d_Arg3.d1_r += 1.0; Arg5 = Arg1 * Arg1; MultDeriv(&d_Arg5,&d_Arg1,&d_Arg1); Ent = MAX(Arg2,1.0e-8); if (Arg2 < 1.0e-8) { EqualDeriv(&d_Ent,&d_zero); d_Ent.value = Ent; } else { EqualDeriv(&d_Ent,&d_Arg2); } Vcom = VgsVth * VgsVth / 6.0 - 1.25e-1 * Arg1 * VgsVth + 2.5e-2 * Arg5; TimesDeriv(&d_dummy,&d_VgsVth,1/6.0); TimesDeriv(&d_Vcom,&d_Arg1,-0.125); PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy); MultDeriv(&d_Vcom,&d_Vcom,&d_VgsVth); TimesDeriv(&d_dummy,&d_Arg5,2.5e-2); PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy); VdsPinchoff = VgsVth / A; if (VdsPinchoff < 0.0) { VdsPinchoff = 0.0; EqualDeriv(&d_VdsPinchoff,&d_zero); } else { DivDeriv(&d_VdsPinchoff,&d_VgsVth,&d_A); } Vgb = vgs - vbs ; EqualDeriv(&d_Vgb,&d_p); d_Vgb.value = Vgb; d_Vgb.d1_q = -1.0; Vgb_Vfb = Vgb - Vfb; EqualDeriv(&d_Vgb_Vfb,&d_Vgb); d_Vgb_Vfb.value = Vgb_Vfb; if( Vgb_Vfb < 0){ /* Accumulation Region */ qg = WLCox * Vgb_Vfb; TimesDeriv(&d_qg,&d_Vgb_Vfb,WLCox); qb = - qg; TimesDeriv(&d_qb,&d_qg,-1.0); qd = 0. ; EqualDeriv(&d_qd,&d_zero); goto finished; } else if ( vgs < Vth0 ){ /* Subthreshold Region */ qg = 0.5 * WLCox * K1 * K1 * (-1 + sqrt(1 + 4 * Vgb_Vfb / (K1 * K1))); TimesDeriv(&d_qg,&d_Vgb_Vfb,4/(K1*K1)); d_qg.value += 1.0; SqrtDeriv(&d_qg,&d_qg); d_qg.value -= 1.0; TimesDeriv(&d_qg,&d_qg,0.5 * WLCox * K1 * K1); qb = -qg; TimesDeriv(&d_qb,&d_qg,-1.0); qd = 0.; EqualDeriv(&d_qd,&d_zero); goto finished; } else if( vds < VdsPinchoff ){ /* triode region */ /* VgsVthSquare = VgsVth*VgsVth; MultDeriv(&d_VgsVthSquare,&d_VgsVth,&d_VgsVth); */ EntSquare = Ent * Ent; MultDeriv(&d_EntSquare,&d_Ent,&d_Ent); Argl1 = 1.2e1 * EntSquare; TimesDeriv(&d_Argl1,&d_EntSquare,12.0); Argl2 = 1.0 - A; TimesDeriv(&d_Argl2,&d_A,-1.0); d_Argl2.value += 1.0; /* Argl3 = Arg1 * vds; MultDeriv(&d_Argl3,&d_Arg1,&d_r); Argl4 = Vcom/Ent/EntSquare; MultDeriv(&d_Argl4,&d_Ent,&d_EntSquare); DivDeriv(&d_Argl4,&d_Vcom,&d_Argl4); */ if (Ent > 1.0e-8) { Argl5 = Arg1 / Ent; DivDeriv(&d_Argl5,&d_Arg1,&d_Ent); Argl6 = Vcom/EntSquare; DivDeriv(&d_Argl6,&d_Vcom,&d_EntSquare); } else { Argl5 = 2.0; EqualDeriv(&d_Argl5,&d_zero); d_Argl5.value = Argl5; Argl6 = 4.0 / 1.5e1; EqualDeriv(&d_Argl6,&d_zero); d_Argl6.value = Argl6; } Argl7 = Argl5 / 1.2e1; TimesDeriv(&d_Argl7,&d_Argl5,1/12.0); /* Argl8 = 6.0 * Ent; TimesDeriv(&d_Argl8,&d_Ent,6.0); Argl9 = 0.125 * Argl5 * Argl5; MultDeriv(&d_Argl9,&d_Argl5,&d_Argl5); TimesDeriv(&d_Argl9,&d_Argl9,0.125); */ qg = WLCox * (vgs - Vfb - Phi - 0.5 * vds + vds * Argl7); EqualDeriv(&d_qg,&d_Argl7); d_qg.value -= 0.5; MultDeriv(&d_qg,&d_qg,&d_r); d_qg.value += vgs - Vfb - Phi; d_qg.d1_p += 1.0; TimesDeriv(&d_qg,&d_qg,WLCox); qb = WLCox * ( - Vth0 + Vfb + Phi + 0.5 * Arg3 - Arg3 * Argl7); TimesDeriv(&d_qb,&d_Argl7,-1.0); d_qb.value += 0.5; MultDeriv(&d_qb,&d_qb,&d_Arg3); d_qb.value += Vfb + Phi; TimesDeriv(&d_dummy,&d_Vth0,-1.0); PlusDeriv(&d_qb,&d_qb,&d_dummy); TimesDeriv(&d_qb,&d_qb,WLCox); qd = - WLCox * (0.5 * (VgsVth - Arg1) + Arg1 * Argl6); MultDeriv(&d_dummy,&d_Arg1,&d_Argl6); TimesDeriv(&d_qd,&d_Arg1,-1.0); PlusDeriv(&d_qd,&d_qd,&d_VgsVth); TimesDeriv(&d_qd,&d_qd,0.5); PlusDeriv(&d_qd,&d_qd,&d_dummy); TimesDeriv(&d_qd,&d_qd,-WLCox); goto finished; } else if( vds >= VdsPinchoff ) { /* saturation region */ Args1 = 1.0 / (3*A); TimesDeriv(&d_Args1,&d_A,3.0); InvDeriv(&d_Args1,&d_Args1); qg = WLCox * (vgs - Vfb - Phi - VgsVth * Args1); MultDeriv(&d_qg,&d_VgsVth,&d_Args1); d_qg.value += Vfb + Phi - vgs; d_qg.d1_p -= 1.0; TimesDeriv(&d_qg,&d_qg,-WLCox); qb = WLCox * (Vfb + Phi - Vth0 + (1.0 - A) * VgsVth * Args1); TimesDeriv(&d_dummy,&d_A,-1.0); d_dummy.value += 1.0; MultDeriv(&d_qb,&d_VgsVth, &d_dummy); MultDeriv(&d_qb,&d_qb,&d_Args1); d_qb.value += Vfb + Phi; TimesDeriv(&d_dummy,&d_Vth0,-1.0); PlusDeriv(&d_qb,&d_qb,&d_dummy); TimesDeriv(&d_qb,&d_qb,WLCox); qd = -co4v15*WLCox*VgsVth; TimesDeriv(&d_qd,&d_VgsVth,-co4v15*WLCox); goto finished; } } } finished: /* returning Values to Calling Routine */ /* * the above has set up (DrCur) and (the node q's) * and (their derivatives upto third order wrt vgs, vbs, and * vds) */ /* * */ /* * charge storage elements * * bulk-drain and bulk-source depletion capacitances * czbd : zero bias drain junction capacitance * czbs : zero bias source junction capacitance * czbdsw:zero bias drain junction sidewall capacitance * czbssw:zero bias source junction sidewall capacitance */ czbd = model->B1unitAreaJctCap * DrainArea; czbs = model->B1unitAreaJctCap * SourceArea; czbdsw= model->B1unitLengthSidewallJctCap * DrainPerimeter; czbssw= model->B1unitLengthSidewallJctCap * SourcePerimeter; PhiB = model->B1bulkJctPotential; PhiBSW = model->B1sidewallJctPotential; MJ = model->B1bulkJctBotGradingCoeff; MJSW = model->B1bulkJctSideGradingCoeff; /* Source Bulk Junction */ if( vbs < 0 ) { arg = 1 - vbs / PhiB; argsw = 1 - vbs / PhiBSW; sarg = exp(-MJ*log(arg)); sargsw = exp(-MJSW*log(argsw)); /* *(ckt->CKTstate0 + here->B1qbs) = PhiB * czbs * (1-arg*sarg)/(1-MJ) + PhiBSW * czbssw * (1-argsw*sargsw)/(1-MJSW); */ capbs1 = czbs * sarg + czbssw * sargsw ; capbs2 = (czbs * MJ * sarg / (PhiB*arg) + czbssw * MJSW * sargsw /(PhiBSW*argsw))/2.0; capbs3 = (czbs * (MJ) * (MJ + 1.) * sarg /((PhiB*arg)*(PhiB*arg)) + czbssw * MJSW * (MJSW + 1.) * sargsw / (PhiBSW*argsw*PhiBSW*argsw))/6.0; } else { /* *(ckt->CKTstate0+here->B1qbs) = vbs*(czbs+czbssw)+ vbs*vbs*(czbs*MJ*0.5/PhiB + czbssw * MJSW * 0.5/PhiBSW); */ capbs1 = czbs + czbssw + vbs *(czbs*MJ/PhiB+ czbssw * MJSW / PhiBSW ); capbs2 = (czbs*MJ/PhiB+czbssw * MJSW / PhiBSW )*0.5; capbs3 = 0.0; } /* Drain Bulk Junction */ if( vbd < 0 ) { arg = 1 - vbd / PhiB; argsw = 1 - vbd / PhiBSW; sarg = exp(-MJ*log(arg)); sargsw = exp(-MJSW*log(argsw)); /* *(ckt->CKTstate0 + here->B1qbd) = PhiB * czbd * (1-arg*sarg)/(1-MJ) + PhiBSW * czbdsw * (1-argsw*sargsw)/(1-MJSW); */ capbd1 = czbd * sarg + czbdsw * sargsw ; capbd2 = (czbd * MJ * sarg / (PhiB*arg) + czbdsw * MJSW * sargsw /(PhiBSW*argsw))*0.5; capbd3 = (czbd * (MJ) * (MJ + 1.) * sarg /((PhiB*arg)*(PhiB*arg)) + czbdsw * MJSW * (MJSW + 1.) * sargsw / (PhiBSW*argsw*PhiBSW*argsw))/6.0; } else { /* *(ckt->CKTstate0+here->B1qbd) = vbd*(czbd+czbdsw)+ vbd*vbd*(czbd*MJ*0.5/PhiB + czbdsw * MJSW * 0.5/PhiBSW); */ capbd1 = czbd + czbdsw + vbd *(czbd*MJ/PhiB+ czbdsw * MJSW / PhiBSW ); capbd2 = 0.5*(czbs*MJ/PhiB+czbssw * MJSW / PhiBSW ); capbd3 = 0.0; } #if 0 qgd = GateDrainOverlapCap * (vgs - vds); qgs = GateSourceOverlapCap * vgs; qgb = GateBulkOverlapCap * (vgs -vbs); *qGatePointer = *qGatePointer + qgd + qgs + qgb; *qBulkPointer = *qBulkPointer - qgb; *qDrainPointer = *qDrainPointer - qgd; *qSourcePointer = -(*qGatePointer + *qBulkPointer + *qDrainPointer); #endif d_qg.d1_p += GateDrainOverlapCap + GateSourceOverlapCap + GateBulkOverlapCap; d_qg.d1_q += -GateBulkOverlapCap; d_qg.d1_r += -GateDrainOverlapCap; d_qb.d1_p += -GateBulkOverlapCap; d_qb.d1_q += GateBulkOverlapCap + capbs1 + capbd1; d_qb.d1_r += -capbd1; d_qd.d1_p += - GateDrainOverlapCap; d_qd.d1_q += -capbd1; d_qd.d1_r += GateDrainOverlapCap + capbd1; /* d[23]_qg_d[vlgbds23] += 0.0; d2_qb_dvgs2 += 0.0; d3_qb_dvgs3 += 0.0 d[23]_qb_dvgs[dvbds23] += 0.0 */ d_qb.d2_q2 += 2* ( capbd2 + capbs2); d_qb.d3_q3 += 6*(capbd3 + capbs3); d_qb.d2_qr += -2*capbd2; d_qb.d3_q2r += -capbd3*6; d_qb.d3_qr2 += capbd3*6; d_qb.d2_r2 += 2*capbd2; d_qb.d3_r3 += -6*capbd3; /* d[23]_qd_dp[dvbds23] += 0.0 */ d_qd.d2_q2 -= 2*capbd2; d_qd.d3_q3 -= 6*capbd3; d_qd.d2_r2 -= 2*capbd2; d_qd.d3_r3 -= -6*capbd3; d_qd.d2_qr -= -2*capbd2; d_qd.d3_q2r -= -6*capbd3; d_qd.d3_qr2 -= 6*capbd3; /* get all the coefficients and adjust for mode and type */ if (here->B1mode == 1) { /* normal mode - no source-drain interchange */ here->qg_x = d_qg.d1_p; here->qg_y = d_qg.d1_q; here->qg_z = d_qg.d1_r; here->qg_x2 = d_qg.d2_p2; here->qg_y2 = d_qg.d2_q2; here->qg_z2 = d_qg.d2_r2; here->qg_xy = d_qg.d2_pq; here->qg_yz = d_qg.d2_qr; here->qg_xz = d_qg.d2_pr; here->qg_x3 = d_qg.d3_p3; here->qg_y3 = d_qg.d3_q3; here->qg_z3 = d_qg.d3_r3; here->qg_x2z = d_qg.d3_p2r; here->qg_x2y = d_qg.d3_p2q; here->qg_y2z = d_qg.d3_q2r; here->qg_xy2 = d_qg.d3_pq2; here->qg_xz2 = d_qg.d3_pr2; here->qg_yz2 = d_qg.d3_qr2; here->qg_xyz = d_qg.d3_pqr; here->qb_x = d_qb.d1_p; here->qb_y = d_qb.d1_q; here->qb_z = d_qb.d1_r; here->qb_x2 = d_qb.d2_p2; here->qb_y2 = d_qb.d2_q2; here->qb_z2 = d_qb.d2_r2; here->qb_xy = d_qb.d2_pq; here->qb_yz = d_qb.d2_qr; here->qb_xz = d_qb.d2_pr; here->qb_x3 = d_qb.d3_p3; here->qb_y3 = d_qb.d3_q3; here->qb_z3 = d_qb.d3_r3; here->qb_x2z = d_qb.d3_p2r; here->qb_x2y = d_qb.d3_p2q; here->qb_y2z = d_qb.d3_q2r; here->qb_xy2 = d_qb.d3_pq2; here->qb_xz2 = d_qb.d3_pr2; here->qb_yz2 = d_qb.d3_qr2; here->qb_xyz = d_qb.d3_pqr; here->qd_x = d_qd.d1_p; here->qd_y = d_qd.d1_q; here->qd_z = d_qd.d1_r; here->qd_x2 = d_qd.d2_p2; here->qd_y2 = d_qd.d2_q2; here->qd_z2 = d_qd.d2_r2; here->qd_xy = d_qd.d2_pq; here->qd_yz = d_qd.d2_qr; here->qd_xz = d_qd.d2_pr; here->qd_x3 = d_qd.d3_p3; here->qd_y3 = d_qd.d3_q3; here->qd_z3 = d_qd.d3_r3; here->qd_x2z = d_qd.d3_p2r; here->qd_x2y = d_qd.d3_p2q; here->qd_y2z = d_qd.d3_q2r; here->qd_xy2 = d_qd.d3_pq2; here->qd_xz2 = d_qd.d3_pr2; here->qd_yz2 = d_qd.d3_qr2; here->qd_xyz = d_qd.d3_pqr; here->DrC_x = d_DrCur.d1_p; here->DrC_y = d_DrCur.d1_q; here->DrC_z = d_DrCur.d1_r; here->DrC_x2 = d_DrCur.d2_p2; here->DrC_y2 = d_DrCur.d2_q2; here->DrC_z2 = d_DrCur.d2_r2; here->DrC_xy = d_DrCur.d2_pq; here->DrC_yz = d_DrCur.d2_qr; here->DrC_xz = d_DrCur.d2_pr; here->DrC_x3 = d_DrCur.d3_p3; here->DrC_y3 = d_DrCur.d3_q3; here->DrC_z3 = d_DrCur.d3_r3; here->DrC_x2z = d_DrCur.d3_p2r; here->DrC_x2y = d_DrCur.d3_p2q; here->DrC_y2z = d_DrCur.d3_q2r; here->DrC_xy2 = d_DrCur.d3_pq2; here->DrC_xz2 = d_DrCur.d3_pr2; here->DrC_yz2 = d_DrCur.d3_qr2; here->DrC_xyz = d_DrCur.d3_pqr; here->gbs1 = lgbs1; here->gbs2 = lgbs2; here->gbs3 = lgbs3; here->gbd1 = lgbd1; here->gbd2 = lgbd2; here->gbd3 = lgbd3; } else { /* * inverse mode - source and drain interchanged * inversion equations for realqg and realqb are the * same; a minus is added for the * realDrCur equation; * realqd = -(realqb + realqg + fakeqd) */ here->qg_x = -(-d_qg.d1_p); here->qg_y = -(-d_qg.d1_q); here->qg_z = -(d_qg.d1_p + d_qg.d1_q + d_qg.d1_r); here->qg_x2 = -(-d_qg.d2_p2); here->qg_y2 = -(-d_qg.d2_q2); here->qg_z2 = -(-(d_qg.d2_p2 + d_qg.d2_q2 + d_qg.d2_r2 + 2*(d_qg.d2_pq + d_qg.d2_pr + d_qg.d2_qr))); here->qg_xy = -(-d_qg.d2_pq); here->qg_yz = -(d_qg.d2_pq + d_qg.d2_q2 + d_qg.d2_qr); here->qg_xz = -(d_qg.d2_p2 + d_qg.d2_pq + d_qg.d2_pr); here->qg_x3 = -(-d_qg.d3_p3); here->qg_y3 = -(-d_qg.d3_q3); here->qg_z3 = -(d_qg.d3_p3 + d_qg.d3_q3 + d_qg.d3_r3 + 3*(d_qg.d3_p2q + d_qg.d3_p2r + d_qg.d3_pq2 + d_qg.d3_q2r + d_qg.d3_pr2 + d_qg.d3_qr2) + 6*d_qg.d3_pqr ); here->qg_x2z = -(d_qg.d3_p3 + d_qg.d3_p2q + d_qg.d3_p2r); here->qg_x2y = -(-d_qg.d3_p2q); here->qg_y2z = -(d_qg.d3_pq2 + d_qg.d3_q3 + d_qg.d3_q2r); here->qg_xy2 = -(-d_qg.d3_pq2); here->qg_xz2 = -(-(d_qg.d3_p3 + 2*(d_qg.d3_p2q + d_qg.d3_p2r + d_qg.d3_pqr) + d_qg.d3_pq2 + d_qg.d3_pr2)); here->qg_yz2 = -(-(d_qg.d3_q3 + 2*(d_qg.d3_pq2 + d_qg.d3_q2r + d_qg.d3_pqr) + d_qg.d3_p2q + d_qg.d3_qr2)); here->qg_xyz = -(d_qg.d3_p2q + d_qg.d3_pq2 + d_qg.d3_pqr); here->qb_x = -(-d_qb.d1_p); here->qb_y = -(-d_qb.d1_q); here->qb_z = -(d_qb.d1_p + d_qb.d1_q + d_qb.d1_r); here->qb_x2 = -(-d_qb.d2_p2); here->qb_y2 = -(-d_qb.d2_q2); here->qb_z2 = -(-(d_qb.d2_p2 + d_qb.d2_q2 + d_qb.d2_r2 + 2*(d_qb.d2_pq + d_qb.d2_pr + d_qb.d2_qr))); here->qb_xy = -(-d_qb.d2_pq); here->qb_yz = -(d_qb.d2_pq + d_qb.d2_q2 + d_qb.d2_qr); here->qb_xz = -(d_qb.d2_p2 + d_qb.d2_pq + d_qb.d2_pr); here->qb_x3 = -(-d_qb.d3_p3); here->qb_y3 = -(-d_qb.d3_q3); here->qb_z3 = -(d_qb.d3_p3 + d_qb.d3_q3 + d_qb.d3_r3 + 3*(d_qb.d3_p2q + d_qb.d3_p2r + d_qb.d3_pq2 + d_qb.d3_q2r + d_qb.d3_pr2 + d_qb.d3_qr2) + 6*d_qb.d3_pqr ); here->qb_x2z = -(d_qb.d3_p3 + d_qb.d3_p2q + d_qb.d3_p2r); here->qb_x2y = -(-d_qb.d3_p2q); here->qb_y2z = -(d_qb.d3_pq2 + d_qb.d3_q3 + d_qb.d3_q2r); here->qb_xy2 = -(-d_qb.d3_pq2); here->qb_xz2 = -(-(d_qb.d3_p3 + 2*(d_qb.d3_p2q + d_qb.d3_p2r + d_qb.d3_pqr) + d_qb.d3_pq2 + d_qb.d3_pr2)); here->qb_yz2 = -(-(d_qb.d3_q3 + 2*(d_qb.d3_pq2 + d_qb.d3_q2r + d_qb.d3_pqr) + d_qb.d3_p2q + d_qb.d3_qr2)); here->qb_xyz = -(d_qb.d3_p2q + d_qb.d3_pq2 + d_qb.d3_pqr); here->qd_x= -here->qg_x - here->qb_x +(-d_qd.d1_p); here->qd_y= -here->qg_y - here->qb_y +(-d_qd.d1_q); here->qd_z= -here->qg_z - here->qb_z +(d_qd.d1_p + d_qd.d1_q + d_qd.d1_r); here->qd_x2 = -here->qg_x2 - here->qb_x2 +(-d_qd.d2_p2); here->qd_y2 = -here->qg_y2 - here->qb_y2 +(-d_qd.d2_q2); here->qd_z2 = -here->qg_z2 - here->qb_z2 +(-(d_qd.d2_p2 + d_qd.d2_q2 + d_qd.d2_r2 + 2*(d_qd.d2_pq + d_qd.d2_pr + d_qd.d2_qr))); here->qd_xy = -here->qg_xy - here->qb_xy +(-d_qd.d2_pq); here->qd_yz = -here->qg_yz - here->qb_yz +(d_qd.d2_pq + d_qd.d2_q2 + d_qd.d2_qr); here->qd_xz = -here->qg_xz - here->qb_xz +(d_qd.d2_p2 + d_qd.d2_pq + d_qd.d2_pr); here->qd_x3 = -here->qg_x3 - here->qb_x3 +(-d_qd.d3_p3); here->qd_y3 = -here->qg_y3 - here->qb_y3 +(-d_qd.d3_q3); here->qd_z3 = -here->qg_z3 - here->qb_z3 +(d_qd.d3_p3 + d_qd.d3_q3 + d_qd.d3_r3 + 3*(d_qd.d3_p2q + d_qd.d3_p2r + d_qd.d3_pq2 + d_qd.d3_q2r + d_qd.d3_pr2 + d_qd.d3_qr2) + 6*d_qd.d3_pqr ); here->qd_x2z = -here->qg_x2z - here->qb_x2z +(d_qd.d3_p3 + d_qd.d3_p2q + d_qd.d3_p2r); here->qd_x2y = -here->qg_x2y - here->qb_x2y +(-d_qd.d3_p2q); here->qd_y2z = -here->qg_y2z - here->qb_y2z +(d_qd.d3_pq2 + d_qd.d3_q3 + d_qd.d3_q2r); here->qd_xy2 = -here->qg_xy2 - here->qb_xy2 +(-d_qd.d3_pq2); here->qd_xz2 = -here->qg_xz2 - here->qb_xz2 +(-(d_qd.d3_p3 + 2*(d_qd.d3_p2q + d_qd.d3_p2r + d_qd.d3_pqr) + d_qd.d3_pq2 + d_qd.d3_pr2)); here->qd_yz2 = -here->qg_yz2 - here->qb_yz2 +(-(d_qd.d3_q3 + 2*(d_qd.d3_pq2 + d_qd.d3_q2r + d_qd.d3_pqr) + d_qd.d3_p2q + d_qd.d3_qr2)); here->qd_xyz = -here->qg_xyz - here->qb_xyz +(d_qd.d3_p2q + d_qd.d3_pq2 + d_qd.d3_pqr); here->DrC_x = -d_DrCur.d1_p; here->DrC_y = -d_DrCur.d1_q; here->DrC_z = d_DrCur.d1_p + d_DrCur.d1_q + d_DrCur.d1_r; here->DrC_x2 = -d_DrCur.d2_p2; here->DrC_y2 = -d_DrCur.d2_q2; here->DrC_z2 = -(d_DrCur.d2_p2 + d_DrCur.d2_q2 + d_DrCur.d2_r2 + 2*(d_DrCur.d2_pq + d_DrCur.d2_pr + d_DrCur.d2_qr)); here->DrC_xy = -d_DrCur.d2_pq; here->DrC_yz = d_DrCur.d2_pq + d_DrCur.d2_q2 + d_DrCur.d2_qr; here->DrC_xz = d_DrCur.d2_p2 + d_DrCur.d2_pq + d_DrCur.d2_pr; here->DrC_x3 = -d_DrCur.d3_p3; here->DrC_y3 = -d_DrCur.d3_q3; here->DrC_z3 = d_DrCur.d3_p3 + d_DrCur.d3_q3 + d_DrCur.d3_r3 + 3*(d_DrCur.d3_p2q + d_DrCur.d3_p2r + d_DrCur.d3_pq2 + d_DrCur.d3_q2r + d_DrCur.d3_pr2 + d_DrCur.d3_qr2) + 6*d_DrCur.d3_pqr ; here->DrC_x2z = d_DrCur.d3_p3 + d_DrCur.d3_p2q + d_DrCur.d3_p2r; here->DrC_x2y = -d_DrCur.d3_p2q; here->DrC_y2z = d_DrCur.d3_pq2 + d_DrCur.d3_q3 + d_DrCur.d3_q2r; here->DrC_xy2 = -d_DrCur.d3_pq2; here->DrC_xz2 = -(d_DrCur.d3_p3 + 2*(d_DrCur.d3_p2q + d_DrCur.d3_p2r + d_DrCur.d3_pqr) + d_DrCur.d3_pq2 + d_DrCur.d3_pr2); here->DrC_yz2 = -(d_DrCur.d3_q3 + 2*(d_DrCur.d3_pq2 + d_DrCur.d3_q2r + d_DrCur.d3_pqr) + d_DrCur.d3_p2q + d_DrCur.d3_qr2); here->DrC_xyz = d_DrCur.d3_p2q + d_DrCur.d3_pq2 + d_DrCur.d3_pqr; here->gbs1 = lgbd1; here->gbs2 = lgbd2; here->gbs3 = lgbd3; here->gbd1 = lgbs1; here->gbd2 = lgbs2; here->gbd3 = lgbs3; } /* now to adjust for type and multiply by factors to convert to Taylor coeffs. */ here->qg_x2 = 0.5*model->B1type*here->qg_x2; here->qg_y2 = 0.5*model->B1type*here->qg_y2; here->qg_z2 = 0.5*model->B1type*here->qg_z2; here->qg_xy = model->B1type*here->qg_xy; here->qg_yz = model->B1type*here->qg_yz; here->qg_xz = model->B1type*here->qg_xz; here->qg_x3 = here->qg_x3/6.; here->qg_y3 = here->qg_y3/6.; here->qg_z3 = here->qg_z3/6.; here->qg_x2z = 0.5*here->qg_x2z; here->qg_x2y = 0.5*here->qg_x2y; here->qg_y2z = 0.5*here->qg_y2z; here->qg_xy2 = 0.5*here->qg_xy2; here->qg_xz2 = 0.5*here->qg_xz2; here->qg_yz2 = 0.5*here->qg_yz2; here->qb_x2 = 0.5*model->B1type*here->qb_x2; here->qb_y2 = 0.5*model->B1type*here->qb_y2; here->qb_z2 = 0.5*model->B1type*here->qb_z2; here->qb_xy = model->B1type*here->qb_xy; here->qb_yz = model->B1type*here->qb_yz; here->qb_xz = model->B1type*here->qb_xz; here->qb_x3 = here->qb_x3/6.; here->qb_y3 = here->qb_y3/6.; here->qb_z3 = here->qb_z3/6.; here->qb_x2z = 0.5*here->qb_x2z; here->qb_x2y = 0.5*here->qb_x2y; here->qb_y2z = 0.5*here->qb_y2z; here->qb_xy2 = 0.5*here->qb_xy2; here->qb_xz2 = 0.5*here->qb_xz2; here->qb_yz2 = 0.5*here->qb_yz2; here->qd_x2 = 0.5*model->B1type*here->qd_x2; here->qd_y2 = 0.5*model->B1type*here->qd_y2; here->qd_z2 = 0.5*model->B1type*here->qd_z2; here->qd_xy = model->B1type*here->qd_xy; here->qd_yz = model->B1type*here->qd_yz; here->qd_xz = model->B1type*here->qd_xz; here->qd_x3 = here->qd_x3/6.; here->qd_y3 = here->qd_y3/6.; here->qd_z3 = here->qd_z3/6.; here->qd_x2z = 0.5*here->qd_x2z; here->qd_x2y = 0.5*here->qd_x2y; here->qd_y2z = 0.5*here->qd_y2z; here->qd_xy2 = 0.5*here->qd_xy2; here->qd_xz2 = 0.5*here->qd_xz2; here->qd_yz2 = 0.5*here->qd_yz2; here->DrC_x2 = 0.5*model->B1type*here->DrC_x2; here->DrC_y2 = 0.5*model->B1type*here->DrC_y2; here->DrC_z2 = 0.5*model->B1type*here->DrC_z2; here->DrC_xy = model->B1type*here->DrC_xy; here->DrC_yz = model->B1type*here->DrC_yz; here->DrC_xz = model->B1type*here->DrC_xz; here->DrC_x3 = here->DrC_x3/6.; here->DrC_y3 = here->DrC_y3/6.; here->DrC_z3 = here->DrC_z3/6.; here->DrC_x2z = 0.5*here->DrC_x2z; here->DrC_x2y = 0.5*here->DrC_x2y; here->DrC_y2z = 0.5*here->DrC_y2z; here->DrC_xy2 = 0.5*here->DrC_xy2; here->DrC_xz2 = 0.5*here->DrC_xz2; here->DrC_yz2 = 0.5*here->DrC_yz2; here->gbs2 = model->B1type*here->gbs2; here->gbd2 = model->B1type*here->gbd2; } /* End of Mosfet Instance */ } /* End of Model Instance */ return(OK); }