hsm1eval1_0.c

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

    Vbsd    = Vbs1 - Vbs2 - Delta ; 
    Vbsd_dVbs = 0.75 * Vbsz_dVbs ;
    Vbsd_dVds = 0.75 * Vbsz_dVds ;

    T1      = sqrt( Vbsd * Vbsd + 4.0 * Delta ) ;
    
    Vbszm   = - Vbs1 + 0.5 * ( Vbsd + T1 ) ;
    Vbszm_dVbs = 0.25 * Vbsz_dVbs
               + 0.5 * ( Vbsd_dVbs + Vbsd * Vbsd_dVbs / T1 ) ;
    Vbszm_dVds = 0.25 * Vbsz_dVds
               + 0.5 * ( Vbsd_dVds + Vbsd * Vbsd_dVds / T1 ) ;

    Psum    = ( Pb20 - Vbsz ) ;

    if ( Psum >= epsm10 ) {
        Psum_dVbs   = - Vbsz_dVbs ;
        Psum_dVds   = - Vbsz_dVds ;
    } else {
        Psum    = epsm10 ;
        Psum_dVbs   = 0.0e0 ;
        Psum_dVds   = 0.0e0 ;
    }

    sqrt_Psum   = sqrt( Psum ) ;



/*---------------------------------------------------*
* Vthp : Vth with pocket.
*-----------------*/

    T1   = 2.0 * q_Nsub * C_ESI ;
    Qb0   = sqrt( T1 * ( Pb20 - Vbsz ) ) ;

    Qb0_dVbs = 0.5 * T1 / Qb0 * ( - Vbsz_dVbs ) ;
    Qb0_dVds = 0.5 * T1 / Qb0 * ( - Vbsz_dVds ) ;

    Vthp = Pb20 + Vfb + Qb0 * Cox_inv ;

    Vthp_dVbs = Qb0_dVbs * Cox_inv + Qb0 * Cox_inv_dVbs ;
    Vthp_dVds = Qb0_dVds * Cox_inv + Qb0 * Cox_inv_dVds ;
    Vthp_dVgs = Qb0 * Cox_inv_dVgs ;

/*-------------------------------------------*
* dVthLP : Short-channel effect induced by pocket.
* - Vth0 : Vth without pocket.
*-----------------*/

    if ( sIN.lp != 0.0 ) {

      T1   = 2.0 * C_QE * sIN.nsubc * C_ESI ;
      T2   = sqrt( T1 * ( Pb2c - Vbsz ) ) ;

      Vth0 = Pb2c + Vfb + T2 * Cox_inv ;

      Vth0_dVbs = 0.5 * T1 / T2 * ( - Vbsz_dVbs ) * Cox_inv 
                + T2 * Cox_inv_dVbs ;
      Vth0_dVds = 0.5 * T1 / T2 * ( - Vbsz_dVds ) * Cox_inv 
                + T2 * Cox_inv_dVds ;
      Vth0_dVgs = T2 * Cox_inv_dVgs ;

      LEY  = sIN.parl1 * sIN.lp ;

      T1  = C_ESI * Cox_inv ;
      T2  = sqrt( 2.0e0 * C_ESI / C_QE / sIN.nsubp ) ;
      T4  = 1.0e0 / ( LEY * LEY ) ;
      T5  = 2.0e0 * ( C_Vbi - Pb20 ) * T1 * T2 * T4 ;

      dVth0   = T5 * sqrt_Psum ;

      T6  = 0.5 * T5 / sqrt_Psum ;
      T7  = 2.0e0 * ( C_Vbi - Pb20 ) * C_ESI * T2 * T4 * sqrt_Psum ;
      dVth0_dVbs  = T6 * Psum_dVbs + T7 * Cox_inv_dVbs ;
      dVth0_dVds  = T6 * Psum_dVds + T7 * Cox_inv_dVds ;
      dVth0_dVgs  = T7 * Cox_inv_dVgs ;

      T1 = Vthp - Vth0 ;
      T2 = sIN.scp1 + sIN.scp3 * Psum / sIN.lp ;
      T3 = T2 + sIN.scp2 * Vdsz ;

      dVthLP  = T1 * dVth0 * T3 ;

      dVthLP_dVbs = ( Vthp_dVbs - Vth0_dVbs ) * dVth0 * T3 
                    + T1 * dVth0_dVbs * T3 
                    + T1 * dVth0 * sIN.scp3 * Psum_dVbs / sIN.lp ;
      dVthLP_dVds = ( Vthp_dVds - Vth0_dVds ) * dVth0 * T3 
                    + T1 * dVth0_dVds * T3 
                    + T1 * dVth0
                    * ( sIN.scp3 * Psum_dVds / sIN.lp 
                      + sIN.scp2 * Vdsz_dVds ) ;

      dVthLP_dVgs = ( Vthp_dVgs - Vth0_dVgs ) * dVth0 * T3 
                    + T1 * dVth0_dVgs * T3  ;

    } else {
      dVthLP = 0.0e0 ;
      dVthLP_dVbs = 0.0e0 ;
      dVthLP_dVds = 0.0e0 ;
      dVthLP_dVgs = 0.0e0 ;
    }

/*---------------------------------------------------*
* dVthSC : Short-channel effect induced by Vds.
*-----------------*/

    T1  = C_ESI * Cox_inv ;
    T2  = sqrt( 2.0e0 * C_ESI / q_Nsub ) ;
    T3  = sIN.parl1 * ( Lgate - sIN.parl2 ) ;
    T4  = 1.0e0 / ( T3 * T3 ) ;
    T5  = 2.0e0 * ( C_Vbi - Pb20 ) * T1 * T2 * T4 ;

    dVth0   = T5 * sqrt_Psum ;
    T6  = T5 / 2 / sqrt_Psum ;
    T7  = 2.0e0 * ( C_Vbi - Pb20 ) * C_ESI * T2 * T4 * sqrt_Psum ;
    dVth0_dVbs  = T6 * Psum_dVbs + T7 * Cox_inv_dVbs ;
    dVth0_dVds  = T6 * Psum_dVds + T7 * Cox_inv_dVds ;
    dVth0_dVgs  = T7 * Cox_inv_dVgs ;


    T4 = sIN.sc1 + sIN.sc3 * Psum / Lgate ;
    T4_dVbs = sIN.sc3 * Psum_dVbs / Lgate ;
    T4_dVds = sIN.sc3 * Psum_dVds / Lgate ;

    T5 = sIN.sc2 ;

    dVthSC  = dVth0 * ( T4 + T5 * Vdsz ) ;

    dVthSC_dVbs = dVth0_dVbs * ( T4 + T5 * Vdsz )
                + dVth0 * ( T4_dVbs ) ;

    dVthSC_dVds = dVth0_dVds * ( T4 + T5 * Vdsz )
                + dVth0 * ( T4_dVds + T5 * Vdsz_dVds ) ;

    dVthSC_dVgs = dVth0_dVgs * ( T4 + T5 * Vdsz ) ;

/*---------------------------------------------------*
* dVthW : narrow-channel effect.
*-----------------*/

    T1 = 1.0 / Cox ;
    T2 = T1 * T1 ;
    T3 = 1.0 / ( Cox + sIN.wfc / Weff ) ;
    T4 = T3 * T3 ;

    dVthW = Qb0 * ( T1 - T3 ) ;

    dVthW_dVbs = Qb0_dVbs * ( T1 - T3 )
               - Qb0 * Cox_dVbs * ( T2 - T4 ) ;
    dVthW_dVds = Qb0_dVds * ( T1 - T3 )
               - Qb0 * Cox_dVds * ( T2 - T4 ) ;
    dVthW_dVgs = - Qb0 * Cox_dVgs * ( T2 - T4 ) ;

/*---------------------------------------------------*
* dVth : Total variation. 
* - Positive dVth means the decrease in Vth.
*-----------------*/
 
    dVth    = dVthSC + dVthLP + dVthW ;
    dVth_dVbs   = dVthSC_dVbs + dVthLP_dVbs + dVthW_dVbs ;
    dVth_dVds   = dVthSC_dVds + dVthLP_dVds + dVthW_dVds ;
    dVth_dVgs   = dVthSC_dVgs + dVthLP_dVgs + dVthW_dVgs ;


 
/*---------------------------------------------------*
* Vth : Threshold voltage. 
*-----------------*/
 
    Vth = Vthp - dVth ;

/*---------------------------------------------------*
* Poly-Depletion Effect
*-----------------*/


/*---------------------------------------------------*
* Poly-Depletion Effect
*-----------------*/

    dPpg      = Nsub / sIN.nsubc * sIN.pgd1
              * exp( Vgsz - sIN.pgd2 - sIN.pgd3 * Vdsz ) ;
    dPpg_dVds = - sIN.pgd3 * dPpg * Vdsz_dVds
              +   dPpg * Vgsz_dVds ;
    dPpg_dVgs =   dPpg * Vgsz_dVgs ;

    T1      = 1.0e0 - dPpg - pol_dlt ;
    T1_dVds = - dPpg_dVds ;
    T1_dVgs = - dPpg_dVgs ;
    T2        = sqrt( T1 * T1 + 4.0e0 * pol_dlt ) ;

    dPpg      = 1.0e0 - 0.5e0 * ( T1 + T2 ) ;
    dPpg_dVds = - 0.5e0 * ( T1_dVds + T1 * T1_dVds / T2 ) ;
    dPpg_dVgs = - 0.5e0 * ( T1_dVgs + T1 * T1_dVgs / T2 ) ;

 

/*---------------------------------------------------*
* Vgp : Effective gate bias with SCE & RSCE & flatband. 
*-----------------*/
 
    Vgp = Vgs - Vfb + dVth - dPpg ;

    Vgp_dVbs    = dVth_dVbs ;
    Vgp_dVds    = dVth_dVds - dPpg_dVds ;
    Vgp_dVgs    = 1.0e0 + dVth_dVgs - dPpg_dVgs ;
   
/*---------------------------------------------------*
* Vgs_fb : Actual flatband voltage taking account Vbs. 
* - note: if Vgs == Vgs_fb then Vgp == Ps0 == Vbs . 
*------------------*/
 
    Vgs_fb  = Vfb - dVth + dPpg + Vbs ;


 
/*-----------------------------------------------------------*
* Constants in the equation of Ps0 . 
*-----------------*/
 
    fac1    = cnst0 * Cox_inv ;
    fac1_dVbs = cnst0 * Cox_inv_dVbs ;
    fac1_dVds = cnst0 * Cox_inv_dVds ;
    fac1_dVgs = cnst0 * Cox_inv_dVgs ;

    fac1p2  = fac1 * fac1 ;
 
/*-----------------------------------------------------------*
* Accumulation zone. (zone-A)
* - evaluate basic characteristics and exit from this part.
*-----------------*/
 
    if ( Vgs < Vgs_fb ) { 
 
 
/*---------------------------------------------------*
* Evaluation of Ps0.
* - Psa : Analytical solution of 
*             Cox( Vgp - Psa ) = cnst0 * Qacc
*         where Qacc is the 3-dgree series of (fdep)^{1/2}.
*         The unkown is transformed to Chi=beta(Ps0-Vbs).
* - Ps0_min : |Ps0_min| when Vbs=0.
*-----------------*/
 
        Ps0_min = Eg - Pb2 ;

        TX = beta * ( Vgp - Vbs ) ;

        TX_dVbs = beta * ( Vgp_dVbs - 1.0 ) ;
        TX_dVds = beta * Vgp_dVds ;
        TX_dVgs = beta * Vgp_dVgs ;

        TY = Cox / ( beta * cnst0 ) ;

        T1 = 1.0 / ( beta * cnst0 ) ;
        TY_dVbs = T1 * Cox_dVbs ;
        TY_dVds = T1 * Cox_dVds ;
        TY_dVgs = T1 * Cox_dVgs ;

        Ac41 = 2.0 + 3.0 * C_SQRT_2 * TY ;

        Ac4 = 8.0 * Ac41 * Ac41 * Ac41 ;

        T1 = 72.0 * Ac41 * Ac41 * C_SQRT_2 ;
        Ac4_dVbs = T1 * TY_dVbs ;
        Ac4_dVds = T1 * TY_dVds ;
        Ac4_dVgs = T1 * TY_dVgs ;

        Ac31 = 7.0 * C_SQRT_2 - 9.0 * TY * ( TX - 2.0 ) ;
        Ac31_dVbs = - 9.0 * ( TY_dVbs * ( TX - 2.0 ) + TY * TX_dVbs ) ;
        Ac31_dVds = - 9.0 * ( TY_dVds * ( TX - 2.0 ) + TY * TX_dVds ) ;
        Ac31_dVgs = - 9.0 * ( TY_dVgs * ( TX - 2.0 ) + TY * TX_dVgs ) ;

        Ac3 = Ac31 * Ac31 ;

        Ac3_dVbs = 2.0 * Ac31 * Ac31_dVbs ;
        Ac3_dVds = 2.0 * Ac31 * Ac31_dVds ;
        Ac3_dVgs = 2.0 * Ac31 * Ac31_dVgs ;

        Ac2 = sqrt( Ac4 + Ac3 ) ;
        Ac2_dVbs = 0.5 * ( Ac4_dVbs + Ac3_dVbs ) / Ac2 ;
        Ac2_dVds = 0.5 * ( Ac4_dVds + Ac3_dVds ) / Ac2 ;
        Ac2_dVgs = 0.5 * ( Ac4_dVgs + Ac3_dVgs ) / Ac2 ;

        Ac1 = -7.0 * C_SQRT_2
           + Ac2 + 9.0 * TY * ( TX - 2.0 ) ;

        Ac1_dVbs = Ac2_dVbs
                + 9.0 * ( TY_dVbs * ( TX - 2.0 ) + TY * TX_dVbs ) ;
        Ac1_dVds = Ac2_dVds
                + 9.0 * ( TY_dVds * ( TX - 2.0 ) + TY * TX_dVds ) ;
        Ac1_dVgs = Ac2_dVgs
                + 9.0 * ( TY_dVgs * ( TX - 2.0 ) + TY * TX_dVgs ) ;

        Acd = pow( Ac1 , C_1o3 ) ;

        T1 = C_1o3 / ( Acd * Acd ) ;
        Acd_dVbs = Ac1_dVbs * T1 ;
        Acd_dVds = Ac1_dVds * T1 ;
        Acd_dVgs = Ac1_dVgs * T1 ;

        Acn = -4.0 * C_SQRT_2 - 12.0 * TY
           + 2.0 * Acd + C_SQRT_2 * Acd * Acd ;

        Acn_dVbs = - 12.0 * TY_dVbs
                + ( 2.0 + 2.0 * C_SQRT_2 * Acd ) * Acd_dVbs ;
        Acn_dVds = - 12.0 * TY_dVds
                + ( 2.0 + 2.0 * C_SQRT_2 * Acd ) * Acd_dVds ;
        Acn_dVgs = - 12.0 * TY_dVgs
                + ( 2.0 + 2.0 * C_SQRT_2 * Acd ) * Acd_dVgs ;

        Chi = Acn / Acd ;

        T1 = 1.0 / ( Acd * Acd ) ;

        Chi_dVbs = ( Acn_dVbs * Acd - Acn * Acd_dVbs ) * T1 ;
        Chi_dVds = ( Acn_dVds * Acd - Acn * Acd_dVds ) * T1 ;
        Chi_dVgs = ( Acn_dVgs * Acd - Acn * Acd_dVgs ) * T1 ;

        Psa = Chi / beta + Vbs ;

        Psa_dVbs = Chi_dVbs / beta + 1.0 ;
        Psa_dVds = Chi_dVds / beta ;
        Psa_dVgs = Chi_dVgs / beta ;

        T1 = Psa - Vbs ;
        T2 = T1 / Ps0_min ;
        T3 = sqrt( 1.0 + ( T2 * T2 ) ) ;

        T9 = T2 / T3 / Ps0_min ;
        T3_dVbs = T9 * ( Psa_dVbs - 1.0 ) ;
        T3_dVds = T9 * ( Psa_dVds ) ;
        T3_dVgs = T9 * ( Psa_dVgs ) ;

        Ps0 = T1 / T3 + Vbs ;

        T9 = 1.0 / ( T3 * T3 ) ;

        Ps0_dVbs = T9 * ( ( Psa_dVbs - 1.0 ) * T3 - T1 * T3_dVbs )
                 + 1.0 ;
        Ps0_dVds = T9 * ( Psa_dVds * T3 - T1 * T3_dVds ) ;
        Ps0_dVgs = T9 * ( Psa_dVgs * T3 - T1 * T3_dVgs ) ;

 
 
/*---------------------------------------------------*
* Characteristics. 
*-----------------*/
 
        T0  = - Weff * Leff ;
        T1  = T0 * Cox ;
        T2  = ( Vgp - Ps0 ) ;

        Qb  = T1 * T2 ;
 
        Qb_dVbs = T1 * ( Vgp_dVbs - Ps0_dVbs ) 
                + T0 * Cox_dVbs * T2 ;
        Qb_dVds = T1 * ( Vgp_dVds - Ps0_dVds ) 
                + T0 * Cox_dVds * T2 ;
        Qb_dVgs = T1 * ( Vgp_dVgs - Ps0_dVgs ) 
                + T0 * Cox_dVgs * T2 ;

        Psl = Ps0 ;
        Psl_dVbs    = Ps0_dVbs ;
        Psl_dVds    = Ps0_dVds ;
        Psl_dVgs    = Ps0_dVgs ;

        Psdl = Psl ;
        Psdl_dVbs = Psl_dVbs ;
        Psdl_dVds = Psl_dVds ;      
        Psdl_dVgs = Psl_dVgs ;
 
        Qi  = 0.0e0 ;
        Qi_dVbs = 0.0e0 ;
        Qi_dVds = 0.0e0 ;
        Qi_dVgs = 0.0e0 ;
 
        Qd  = 0.0e0 ;
        Qd_dVbs = 0.0e0 ;
        Qd_dVds = 0.0e0 ;
        Qd_dVgs = 0.0e0 ;
 
        Ids = 0.0e0 ;
        Ids_dVbs    = 0.0e0 ;
        Ids_dVds    = 0.0e0 ;
        Ids_dVgs    = 0.0e0 ;

        VgVt  = 0.0 ;

        flg_noqi = 1 ;
 
        goto end_of_part_1 ;
 
    } 
 
/*-----------------------------------------------------------*
* Initial guess for Ps0. 
*-----------------*/
 
/*---------------------------------------------------*
* Ps0_iniA: solution of subthreshold equation assuming zone-D1/D2.
*-----------------*/
 
    TX  = 1.0e0 + 4.0e0 
        * ( beta * ( Vgp - Vbs ) - 1.0e0 ) / ( fac1p2 * beta2 ) ;
    TX  = Fn_Max( TX , epsm10 ) ;
 
    Ps0_iniA    = Vgp
                + fac1p2 * beta / 2.0e0 * ( 1.0e0 - sqrt( TX ) ) ;
 
 
/*---------------------------------------------------*
* Use previous value.
*-----------------*/
    if ( flg_pprv == 1 ) {

        Ps0_ini  = Ps0 + Ps0_dVbs * dVbs 
                 + Ps0_dVds * dVds  + Ps0_dVgs * dVgs ;

        T1 = Ps0_ini - Ps0 ;

        if ( T1 < - dP_max || T1 > dP_max ) {
            flg_pprv = 0  ;
        } else {
            Ps0_iniA = Fn_Max( Ps0_ini , Ps0_iniA ) ;
        }
 
    } 
 
/*---------------------------------------------------*
* Analytical initial guess.
*-----------------*/
    if ( flg_pprv == 0 ) {
/*-------------------------------------------*
* Common part.
*-----------------*/
 
        Chi = beta * ( Ps0_iniA - Vbs ) ;
 
/*-----------------------------------*
* zone-D1/D2
* - Ps0_ini is the analytical solution of Qs=Qb0 with
*   Qb0 being approximated to 3-degree polynomial.
*-----------------*/
        if ( Chi < znbd3 ) { 
 
            TY  = beta * ( Vgp - Vbs ) ;
            T1  = 1.0e0 / ( cn_nc3 * beta * fac1 ) ;
            T2  = 81 + 3 * T1 ;
            T3  = -2916 - 81 * T1 + 27 * T1 * TY ;
            T4  = 1458 - 81 * ( 54 + T1 ) + 27 * T1 * TY ;
            T4  = T4 * T4 ;
            T5  = pow( T3 + sqrt( 4 * T2 * T2 * T2 + T4 ) , C_1o3 ) ;
            TX  = 3 
                - ( C_2p_1o3 * T2 ) / ( 3 * T5 ) 
                + 1 / ( 3 * C_2p_1o3 ) * T5 ;
 
            Ps0_iniA    = TX / beta + Vbs ;
 
            Ps0_ini = Ps0_iniA ;
 
 
/*-----------------------------------*
* Weak inversion zone.  
*-----------------*/
        } else if ( Vgs <= Vth ) { 
 
            Ps0_ini = Ps0_iniA ;
 
 
/*-----------------------------------*
* Strong inversion zone.  
* - Ps0_iniB : upper bound.
*-----------------*/
        } else { 
 
            T1  = ( Cox * Cox ) / ( cnst0 * cnst0 ) / cnst1 ;
            T2  = T1 * Vgp * Vgp ;