1 /*********************************************************************** 2 3 HiSIM (Hiroshima University STARC IGFET Model) 4 Copyright (C) 2012 Hiroshima University & STARC 5 6 MODEL NAME : HiSIM_HV 7 ( VERSION : 1 SUBVERSION : 2 REVISION : 4 ) 8 Model Parameter VERSION : 1.23 9 FILE : hsmhveval_qover.h 10 11 DATE : 2013.04.30 12 13 released by 14 Hiroshima University & 15 Semiconductor Technology Academic Research Center (STARC) 16 ***********************************************************************/ 17 18 /* Begin HSMHVevalQover */ 19 20 /*---------------------------------------------------* 21 * Clamp -Vxbgmt. 22 *-----------------*/ 23 T0 = - Vxbgmt; 24 if ( T0 > Vbs_bnd ) { 25 T1 = T0 - Vbs_bnd; 26 T1_dT = - Vbs_bnd_dT; 27 T2 = Vbs_max - Vbs_bnd; 28 T2_dT = Vbs_max_dT - Vbs_bnd_dT; 29 30 Fn_SUPoly4m( TY, T1, T2, T11, T0 ); 31 TY_dT = T1_dT * T11 + T2_dT * T0; 32 33 T10 = Vbs_bnd + TY ; 34 T10_dT = Vbs_bnd_dT + TY_dT ; 35 } else { 36 T10 = T0 ; 37 T11 = 1.0 ; 38 T10_dT = 0.0; 39 } 40 Vxbgmtcl = - T10 - small2 ; 41 Vxbgmtcl_dVxbgmt = T11; 42 Vxbgmtcl_dT = - T10_dT; 43 44 fac1 = cnst0over_func * Cox0_inv ; 45 fac1_dVbs = 0.0; fac1_dVds = 0.0; fac1_dVgs = 0.0; 46 fac1_dT = cnst0over_func_dT * Cox0_inv ; 47 48 fac1p2 = fac1 * fac1 ; 49 fac1p2_dT = 2.0 * fac1 * fac1_dT ; 50 51 VgpLD = - Vgbgmt + pParam->HSMHV_vfbover; 52 VgpLD_dVgb = - 1.0e0 ; 53 54 T0 = Nover_func / here->HSMHV_nin ; 55 Pb2over = 2.0 / beta * log( T0 ) ; 56 T0_dT = - T0 / here->HSMHV_nin * Nin_dT ; 57 Pb2over_dT = - Pb2over / beta * beta_dT + 2.0 / beta / T0 * T0_dT ; 58 59 Vgb_fb_LD = - Vxbgmtcl ; 60 61 /*-----------------------------------* 62 * QsuLD: total charge = Accumulation | Depletion+inversion 63 *-----------------*/ 64 if ( VgpLD < Vgb_fb_LD ){ 65 /*---------------------------* 66 * Accumulation 67 *-----------------*/ 68 flg_ovzone = -1 ; 69 T1 = 1.0 / ( beta * cnst0over_func ) ; 70 T1_dT = - T1 * T1 * ( beta_dT * cnst0over_func + beta * cnst0over_func_dT ) ; 71 TY = T1 * Cox0 ; 72 Ac41 = 2.0 + 3.0 * C_SQRT_2 * TY ; 73 Ac4 = 8.0 * Ac41 * Ac41 * Ac41 ; 74 TY_dT = T1_dT * Cox0 ; 75 Ac41_dT = 3.0 * C_SQRT_2 * TY_dT ; 76 Ac4_dT = 8.0 * 3.0 * Ac41 * Ac41 * Ac41_dT ; 77 78 Ps0_min = here->HSMHV_eg - Pb2over ; 79 Ps0_min_dT = Eg_dT - Pb2over_dT ; 80 81 TX = beta * ( VgpLD + Vxbgmtcl ) ; 82 TX_dVxb = beta * Vxbgmtcl_dVxbgmt ; 83 TX_dVgb = beta * VgpLD_dVgb ; 84 TX_dT = beta_dT * ( VgpLD + Vxbgmtcl ) + beta * Vxbgmtcl_dT; 85 86 Ac31 = 7.0 * C_SQRT_2 - 9.0 * TY * ( TX - 2.0 ) ; 87 Ac31_dVxb = - 9.0 * TY * TX_dVxb ; 88 Ac31_dVgb = - 9.0 * TY * TX_dVgb ; 89 Ac31_dT = - 9.0 * ( TY_dT * ( TX - 2.0 ) + TY * TX_dT ); 90 91 Ac3 = Ac31 * Ac31 ; 92 T1 = 2.0 * Ac31 ; 93 Ac3_dVxb = T1 * Ac31_dVxb ; 94 Ac3_dVgb = T1 * Ac31_dVgb ; 95 Ac3_dT = T1 * Ac31_dT ; 96 97 Ac2 = sqrt( Ac4 + Ac3 ) ; 98 T1 = 0.5 / Ac2 ; 99 Ac2_dVxb = T1 * Ac3_dVxb ; 100 Ac2_dVgb = T1 * Ac3_dVgb ; 101 Ac2_dT = T1 * ( Ac4_dT + Ac3_dT ); 102 103 Ac1 = -7.0 * C_SQRT_2 + Ac2 + 9.0 * TY * ( TX - 2.0 ) ; 104 Ac1_dVxb = Ac2_dVxb + 9.0 * TY * TX_dVxb ; 105 Ac1_dVgb = Ac2_dVgb + 9.0 * TY * TX_dVgb ; 106 Ac1_dT = Ac2_dT + 9.0 * ( TY_dT * ( TX - 2.0 ) + TY * TX_dT ) ; 107 108 Acd = pow( Ac1 , C_1o3 ) ; 109 T1 = C_1o3 / ( Acd * Acd ) ; 110 Acd_dVxb = Ac1_dVxb * T1 ; 111 Acd_dVgb = Ac1_dVgb * T1 ; 112 Acd_dT = Ac1_dT * T1 ; 113 114 Acn = -4.0 * C_SQRT_2 - 12.0 * TY + 2.0 * Acd + C_SQRT_2 * Acd * Acd ; 115 T1 = 2.0 + 2.0 * C_SQRT_2 * Acd ; 116 Acn_dVxb = T1 * Acd_dVxb ; 117 Acn_dVgb = T1 * Acd_dVgb ; 118 Acn_dT = - 12.0 * TY_dT + T1 * Acd_dT ; 119 120 Chi = Acn / Acd ; 121 T1 = 1.0 / ( Acd * Acd ) ; 122 Chi_dVxb = ( Acn_dVxb * Acd - Acn * Acd_dVxb ) * T1 ; 123 Chi_dVgb = ( Acn_dVgb * Acd - Acn * Acd_dVgb ) * T1 ; 124 Chi_dT = ( Acn_dT * Acd - Acn * Acd_dT ) * T1 ; 125 126 Psa = Chi * beta_inv - Vxbgmtcl ; 127 Psa_dVxb = Chi_dVxb * beta_inv - Vxbgmtcl_dVxbgmt ; 128 Psa_dVgb = Chi_dVgb * beta_inv ; 129 Psa_dT = Chi_dT * beta_inv + Chi * beta_inv_dT - Vxbgmtcl_dT ; 130 131 T1 = Psa + Vxbgmtcl ; 132 T1_dT = Psa_dT + Vxbgmtcl_dT ; 133 T2 = T1 / Ps0_min ; 134 T2_dT = ( T1_dT * Ps0_min - T1 * Ps0_min_dT ) / ( Ps0_min * Ps0_min ) ; 135 T3 = sqrt( 1.0 + ( T2 * T2 ) ) ; 136 137 T9 = T2 / T3 / Ps0_min ; 138 T3_dVd = T9 * ( Psa_dVxb + Vxbgmtcl_dVxbgmt ) ; 139 T3_dVg = T9 * Psa_dVgb ; 140 T3_dT = T2_dT * T2 / T3; 141 142 Ps0LD = T1 / T3 - Vxbgmtcl ; 143 T9 = 1.0 / ( T3 * T3 ) ; 144 Ps0LD_dVxb = T9 * ( ( Psa_dVxb + Vxbgmtcl_dVxbgmt ) * T3 - T1 * T3_dVd ) - Vxbgmtcl_dVxbgmt ; 145 Ps0LD_dVgb = T9 * ( Psa_dVgb * T3 - T1 * T3_dVg ); 146 Ps0LD_dT = T9 * ( T1_dT * T3 - T1 * T3_dT ) - Vxbgmtcl_dT; 147 148 T2 = ( VgpLD - Ps0LD ) ; 149 QsuLD = Cox0 * T2 ; 150 QsuLD_dVxb = - Cox0 * Ps0LD_dVxb ; 151 QsuLD_dVgb = Cox0 * ( VgpLD_dVgb - Ps0LD_dVgb ) ; 152 QsuLD_dT = Cox0 * ( - Ps0LD_dT ) ; 153 154 QbuLD = QsuLD ; 155 QbuLD_dVxb = QsuLD_dVxb ; 156 QbuLD_dVgb = QsuLD_dVgb ; 157 QbuLD_dT = QsuLD_dT ; 158 159 } else { 160 161 /*---------------------------* 162 * Depletion and inversion 163 *-----------------*/ 164 165 /* initial value for a few fixpoint iterations 166 to get Ps0_iniA from simplified Poisson equation: */ 167 flg_ovzone = 2 ; 168 Chi = znbd3 ; 169 Chi_dVxb = 0.0 ; Chi_dVgb = 0.0 ; Chi_dT = 0.0 ; 170 171 Ps0_iniA= Chi/beta - Vxbgmtcl ; 172 Ps0_iniA_dVxb = Chi_dVxb/beta - Vxbgmtcl_dVxbgmt ; 173 Ps0_iniA_dVgb = Chi_dVgb/beta ; 174 Ps0_iniA_dT = Chi_dT/beta - Chi*beta_dT/(beta*beta) - Vxbgmtcl_dT; 175 176 /* 1 .. 2 relaxation steps should be sufficient */ 177 for ( lp_ld = 1; lp_ld <= 2; lp_ld ++ ) { 178 TY = exp(-Chi); 179 TY_dVxb = -Chi_dVxb * TY; 180 TY_dVgb = -Chi_dVgb * TY; 181 TY_dT = - Chi_dT * TY; 182 TX = 1.0e0 + 4.0e0 183 * ( beta * ( VgpLD + Vxbgmtcl ) - 1.0e0 + TY ) / ( fac1p2 * beta2 ) ; 184 TX_dVxb = 4.0e0 * ( beta * ( Vxbgmtcl_dVxbgmt ) + TY_dVxb ) / ( fac1p2 * beta2 ); 185 TX_dVgb = 4.0e0 * ( beta * ( VgpLD_dVgb ) + TY_dVgb ) / ( fac1p2 * beta2 ); 186 T1 = ( beta * ( VgpLD + Vxbgmtcl ) - 1.0e0 + TY ); 187 T1_dT = beta_dT * ( VgpLD + Vxbgmtcl ) + beta * Vxbgmtcl_dT + TY_dT; 188 T3 = fac1p2 * beta2 ; 189 T3_dT = fac1p2_dT * beta2 + fac1p2 * ( 2 * beta * beta_dT ) ; 190 TX_dT = 4 * ( T1_dT * T3 - T1 * T3_dT ) / ( T3 * T3 ); 191 if ( TX < epsm10) { 192 TX = epsm10; 193 TX_dVxb = TX_dVgb = TX_dT = 0.0; 194 } 195 196 Ps0_iniA = VgpLD + fac1p2 * beta / 2.0e0 * ( 1.0e0 - sqrt( TX ) ) ; 197 Ps0_iniA_dVxb = - fac1p2 * beta / 2.0e0 * TX_dVxb * 0.5 / sqrt( TX ); 198 Ps0_iniA_dVgb = VgpLD_dVgb - fac1p2 * beta / 2.0e0 * TX_dVgb * 0.5 / sqrt( TX ); 199 T1 = fac1p2 * beta ; 200 T1_dT = fac1p2_dT * beta + fac1p2 * beta_dT ; 201 T2 = 1.0 - sqrt( TX ); 202 T2_dT = - 1.0e0 / ( 2.0e0 * sqrt( TX ) ) * TX_dT ; 203 Ps0_iniA_dT = ( T1_dT * T2 + T1 * T2_dT ) / 2.0e0 ; 204 205 Chi = beta * ( Ps0_iniA + Vxbgmtcl ) ; 206 Chi_dVxb = beta * ( Ps0_iniA_dVxb + Vxbgmtcl_dVxbgmt ) ; 207 Chi_dVgb = beta * ( Ps0_iniA_dVgb ) ; 208 Chi_dT = beta_dT * ( Ps0_iniA + Vxbgmtcl ) + beta * ( Ps0_iniA_dT + Vxbgmtcl_dT ); 209 } /* End of iteration */ 210 211 if ( Chi < znbd3 ) { 212 213 flg_ovzone = 1 ; 214 215 /*-----------------------------------* 216 * zone-D1 217 * - Ps0_iniA is the analytical solution of QovLD=Qb0 with 218 * Qb0 being approximated by 3-degree polynomial. 219 * 220 * new: Inclusion of exp(-Chi) term at right border 221 *-----------------*/ 222 Ta = 1.0/(9.0*sqrt(2.0)) - (5.0+7.0*exp(-3.0)) / (54.0*sqrt(2.0+exp(-3.0))); 223 Tb = (1.0+exp(-3.0)) / (2.0*sqrt(2.0+exp(-3.0))) - sqrt(2.0) / 3.0; 224 Tc = 1.0/sqrt(2.0) + 1.0/(beta*fac1); 225 Tc_dT = - (beta_dT*fac1 + beta*fac1_dT)/(beta2*fac1p2); 226 Td = - (VgpLD + Vxbgmtcl) / fac1; 227 Td_dVxb = - Vxbgmtcl_dVxbgmt / fac1; 228 Td_dVgb = - VgpLD_dVgb / fac1; 229 Td_dT = - (Vxbgmtcl_dT*fac1 - (VgpLD+Vxbgmtcl)*fac1_dT)/fac1p2; 230 Tq = Tb*Tb*Tb / (27.0*Ta*Ta*Ta) - Tb*Tc/(6.0*Ta*Ta) + Td/(2.0*Ta); 231 Tq_dVxb = Td_dVxb/(2.0*Ta); 232 Tq_dVgb = Td_dVgb / (2.0*Ta); 233 Tq_dT = - Tb/(6.0*Ta*Ta)*Tc_dT + Td_dT/(2.0*Ta); 234 Tp = (3.0*Ta*Tc-Tb*Tb)/(9.0*Ta*Ta); 235 Tp_dT = Tc_dT/(3.0*Ta); 236 T5 = sqrt(Tq*Tq + Tp*Tp*Tp); 237 T5_dVxb = 2.0*Tq*Tq_dVxb / (2.0*T5); 238 T5_dVgb = 2.0*Tq*Tq_dVgb / (2.0*T5); 239 T5_dT = (2.0*Tq*Tq_dT + 3.0*Tp*Tp*Tp_dT) / (2.0*T5); 240 Tu = pow(-Tq + T5,C_1o3); 241 Tu_dVxb = Tu / (3.0 * (-Tq + T5)) * (-Tq_dVxb + T5_dVxb); 242 Tu_dVgb = Tu / (3.0 * (-Tq + T5)) * (-Tq_dVgb + T5_dVgb); 243 Tu_dT = Tu / (3.0 * (-Tq + T5)) * (-Tq_dT + T5_dT); 244 Tv = -pow(Tq + T5,C_1o3); 245 Tv_dVxb = Tv / (3.0 * (-Tq - T5)) * (-Tq_dVxb - T5_dVxb); 246 Tv_dVgb = Tv / (3.0 * (-Tq - T5)) * (-Tq_dVgb - T5_dVgb); 247 Tv_dT = Tv / (3.0 * (-Tq - T5)) * (-Tq_dT - T5_dT ); 248 TX = Tu + Tv - Tb/(3.0*Ta); 249 TX_dVxb = Tu_dVxb + Tv_dVxb; 250 TX_dVgb = Tu_dVgb + Tv_dVgb; 251 TX_dT = Tu_dT + Tv_dT ; 252 253 Ps0_iniA = TX * beta_inv - Vxbgmtcl ; 254 Ps0_iniA_dVxb = TX_dVxb * beta_inv - Vxbgmtcl_dVxbgmt; 255 Ps0_iniA_dVgb = TX_dVgb * beta_inv; 256 Ps0_iniA_dT = TX_dT * beta_inv + TX * beta_inv_dT - Vxbgmtcl_dT; 257 258 Chi = beta * ( Ps0_iniA + Vxbgmtcl ) ; 259 Chi_dVxb = beta * ( Ps0_iniA_dVxb + Vxbgmtcl_dVxbgmt ) ; 260 Chi_dVgb = beta * ( Ps0_iniA_dVgb ) ; 261 Chi_dT = beta_dT * ( Ps0_iniA + Vxbgmtcl ) + beta * ( Ps0_iniA_dT + Vxbgmtcl_dT ); 262 } 263 264 if ( model->HSMHV_coqovsm > 0 ) { 265 /*-----------------------------------* 266 * - Ps0_iniB : upper bound. 267 *-----------------*/ 268 flg_ovzone += 2; 269 270 VgpLD_shift = VgpLD + Vxbgmtcl + 0.1; 271 VgpLD_shift_dVgb = VgpLD_dVgb; 272 VgpLD_shift_dVxb = Vxbgmtcl_dVxbgmt; 273 VgpLD_shift_dT = Vxbgmtcl_dT; 274 exp_bVbs = exp( beta * - Vxbgmtcl ) + small ; 275 exp_bVbs_dVxb = - exp_bVbs * beta * Vxbgmtcl_dVxbgmt; 276 exp_bVbs_dT = - exp_bVbs * (beta_dT*Vxbgmtcl + beta*Vxbgmtcl_dT); 277 T0 = here->HSMHV_nin / Nover_func; 278 T0_dT = Nin_dT / Nover_func; 279 cnst1over = T0 * T0; 280 cnst1over_dT = 2.0 * T0 * T0_dT; 281 gamma = cnst1over * exp_bVbs ; 282 gamma_dVxb = cnst1over * exp_bVbs_dVxb; 283 gamma_dT = cnst1over_dT * exp_bVbs + cnst1over * exp_bVbs_dT; 284 285 T0 = beta2 * fac1p2; 286 T0_dT = 2.0 * beta * fac1 * (beta_dT*fac1+beta*fac1_dT); 287 288 psi = beta*VgpLD_shift; 289 psi_dVgb = beta*VgpLD_shift_dVgb; 290 psi_dVxb = beta*VgpLD_shift_dVxb; 291 psi_dT = beta_dT*VgpLD_shift + beta*VgpLD_shift_dT; 292 Chi_1 = log(gamma*T0 + psi*psi) - log(cnst1over*T0) + beta*Vxbgmtcl; 293 Chi_1_dVgb = 2.0*psi*psi_dVgb/ (gamma*T0 + psi*psi); 294 Chi_1_dVxb = (gamma_dVxb*T0+2.0*psi*psi_dVxb)/(gamma*T0+psi*psi) 295 + beta*Vxbgmtcl_dVxbgmt; 296 Chi_1_dT = (gamma_dT*T0+gamma*T0_dT+2.0*psi*psi_dT)/(gamma*T0+psi*psi) 297 - (cnst1over_dT*T0 + cnst1over*T0_dT)/(cnst1over*T0) 298 + beta_dT*Vxbgmtcl + beta*Vxbgmtcl_dT; 299 300 Fn_SU2( Chi_1, Chi_1, psi, 1.0, T1, T2 ); 301 Chi_1_dVgb = Chi_1_dVgb*T1 + psi_dVgb*T2; 302 Chi_1_dVxb = Chi_1_dVxb*T1 + psi_dVxb*T2; 303 Chi_1_dT = Chi_1_dT *T1 + psi_dT *T2; 304 305 /* 1 fixpoint step for getting more accurate Chi_B */ 306 psi -= Chi_1 ; 307 psi_dVgb -= Chi_1_dVgb ; 308 psi_dVxb -= Chi_1_dVxb ; 309 psi_dT -= Chi_1_dT ; 310 311 psi += beta*0.1 ; 312 psi_dT += beta_dT*0.1 ; 313 314 /* psi_B = psi;*/ 315 /* arg_B = psi*psi/(gamma*T0);*/ 316 Chi_B = log(gamma*T0 + psi*psi) - log(cnst1over*T0) + beta*Vxbgmtcl; 317 Chi_B_dVgb = 2.0*psi*psi_dVgb/ (gamma*T0 + psi*psi); 318 Chi_B_dVxb = (gamma_dVxb*T0+2.0*psi*psi_dVxb)/(gamma*T0+psi*psi) 319 + beta*Vxbgmtcl_dVxbgmt; 320 Chi_B_dT = (gamma_dT*T0+gamma*T0_dT+2.0*psi*psi_dT)/(gamma*T0+psi*psi) 321 - (cnst1over_dT*T0 + cnst1over*T0_dT)/(cnst1over*T0) 322 + beta_dT*Vxbgmtcl + beta*Vxbgmtcl_dT; 323 Ps0_iniB = Chi_B/beta - Vxbgmtcl ; 324 /* Ps0_iniB_dVgb = Chi_B_dVgb/beta; 325 Ps0_iniB_dVxb = Chi_B_dVxb/beta- Vxbgmtcl_dVxbgmt; 326 Ps0_iniB_dT = Chi_B_dT/beta - Chi_B/(beta*beta)*beta_dT - Vxbgmtcl_dT; 327 */ 328 329 /* construction of Ps0LD by taking Ps0_iniB as an upper limit of Ps0_iniA 330 * 331 * Limiting is done for Chi rather than for Ps0LD, to avoid shifting 332 * for Fn_SU2 */ 333 334 Chi_A = Chi; 335 Chi_A_dVxb = Chi_dVxb; 336 Chi_A_dVgb = Chi_dVgb; 337 Chi_A_dT = Chi_dT; 338 339 Fn_SU2( Chi, Chi_A, Chi_B, c_ps0ini_2*75.00, T1, T2 ); /* org: 50 */ 340 Chi_dVgb = Chi_A_dVgb * T1 + Chi_B_dVgb * T2; 341 Chi_dVxb = Chi_A_dVxb * T1 + Chi_B_dVxb * T2; 342 Chi_dT = Chi_A_dT * T1 + Chi_B_dT * T2; 343 344 } 345 346 /* updating Ps0LD */ 347 Ps0LD= Chi/beta - Vxbgmtcl ; 348 Ps0LD_dVgb = Chi_dVgb/beta; 349 Ps0LD_dVxb = Chi_dVxb/beta- Vxbgmtcl_dVxbgmt; 350 Ps0LD_dT = Chi_dT/beta - Chi/(beta*beta)*beta_dT - Vxbgmtcl_dT; 351 352 T1 = Chi - 1.0 + exp(-Chi); 353 T1_dVxb = (1.0 - exp(-Chi)) * Chi_dVxb ; 354 T1_dVgb = (1.0 - exp(-Chi)) * Chi_dVgb ; 355 T1_dT = (1.0 - exp(-Chi)) * Chi_dT ; 356 if (T1 < epsm10) { 357 T1 = epsm10 ; 358 T1_dVxb = 0.0 ; 359 T1_dVgb = 0.0 ; 360 T1_dT = 0.0 ; 361 } 362 T2 = sqrt(T1); 363 QbuLD = cnst0over_func * T2 ; 364 T3 = cnst0over_func * 0.5 / T2 ; 365 QbuLD_dVxb = T3 * T1_dVxb ; 366 QbuLD_dVgb = T3 * T1_dVgb ; 367 QbuLD_dT = T3 * T1_dT + cnst0over_func_dT * T2 ; 368 369 /*-----------------------------------------------------------* 370 * QsuLD : Qovs or Qovd in unit area. 371 * note: QsuLD = Qdep+Qinv. 372 *-----------------*/ 373 QsuLD = Cox0 * ( VgpLD - Ps0LD ) ; 374 QsuLD_dVxb = Cox0 * ( - Ps0LD_dVxb ) ; 375 QsuLD_dVgb = Cox0 * ( VgpLD_dVgb - Ps0LD_dVgb ) ; 376 QsuLD_dT = Cox0 * ( - Ps0LD_dT ) ; 377 378 if ( model->HSMHV_coqovsm == 1 ) { /* take initial values from analytical model */ 379 380 381 /*---------------------------------------------------* 382 * Calculation of Ps0LD. (beginning of Newton loop) 383 * - Fs0 : Fs0 = 0 is the equation to be solved. 384 * - dPs0 : correction value. 385 *-----------------*/ 386 387 /* initial value too close to flat band should not be used */ 388 // if (Ps0LD+Vxbgmtcl < 1.0e-2) Ps0LD = 1.0e-2 - Vxbgmtcl; 389 exp_bVbs = exp( beta * - Vxbgmtcl ) ; 390 T0 = here->HSMHV_nin / Nover_func; 391 cnst1over = T0 * T0; 392 cnst1over_dT = 2.0 * T0 * ( Nin_dT / Nover_func ); 393 cfs1 = cnst1over * exp_bVbs ; 394 395 flg_conv = 0 ; 396 for ( lp_s0 = 1 ; lp_s0 <= 2*lp_s0_max + 1 ; lp_s0 ++ ) { 397 398 Chi = beta * ( Ps0LD + Vxbgmtcl ) ; 399 400 if ( Chi < znbd5 ) { 401 /*-------------------------------------------* 402 * zone-D1/D2. (Ps0LD) 403 *-----------------*/ 404 fi = Chi * Chi * Chi 405 * ( cn_im53 + Chi * ( cn_im54 + Chi * cn_im55 ) ) ; 406 fi_dChi = Chi * Chi 407 * ( 3 * cn_im53 + Chi * ( 4 * cn_im54 + Chi * 5 * cn_im55 ) ) ; 408 409 fs01 = cfs1 * fi * fi ; 410 fs01_dPs0 = cfs1 * beta * 2 * fi * fi_dChi ; 411 412 fb = Chi * ( cn_nc51 413 + Chi * ( cn_nc52 414 + Chi * ( cn_nc53 415 + Chi * ( cn_nc54 + Chi * cn_nc55 ) ) ) ) ; 416 fb_dChi = cn_nc51 417 + Chi * ( 2 * cn_nc52 418 + Chi * ( 3 * cn_nc53 419 + Chi * ( 4 * cn_nc54 + Chi * 5 * cn_nc55 ) ) ) ; 420 421 fs02 = sqrt( fb * fb + fs01 + small ) ; 422 fs02_dPs0 = ( beta * fb_dChi * 2 * fb + fs01_dPs0 ) / ( fs02 + fs02 ) ; 423 424 } else { 425 /*-------------------------------------------* 426 * zone-D3. (Ps0LD) 427 *-----------------*/ 428 if ( Chi < large_arg ) { /* avoid exp_Chi to become extremely large */ 429 exp_Chi = exp( Chi ) ; 430 fs01 = cfs1 * ( exp_Chi - 1.0e0 ) ; 431 fs01_dPs0 = cfs1 * beta * ( exp_Chi ) ; 432 } else { 433 exp_bPs0 = exp( beta*Ps0LD ) ; 434 fs01 = cnst1over * ( exp_bPs0 - exp_bVbs ) ; 435 fs01_dPs0 = cnst1over * beta * exp_bPs0 ; 436 } 437 fs02 = sqrt( Chi - 1.0 + fs01 ) ; 438 fs02_dPs0 = ( beta + fs01_dPs0 ) / fs02 * 0.5 ; 439 440 } /* end of if ( Chi ... ) block */ 441 /*-----------------------------------------------------------* 442 * Fs0 443 *-----------------*/ 444 Fs0 = VgpLD - Ps0LD - fac1 * fs02 ; 445 Fs0_dPs0 = - 1.0e0 - fac1 * fs02_dPs0 ; 446 447 if ( flg_conv == 1 ) break ; 448 449 dPs0 = - Fs0 / Fs0_dPs0 ; 450 451 /*-------------------------------------------* 452 * Update Ps0LD . 453 *-----------------*/ 454 dPlim = 0.5*dP_max*(1.0 + Fn_Max(1.e0,fabs(Ps0LD))) ; 455 if ( fabs( dPs0 ) > dPlim ) dPs0 = dPlim * Fn_Sgn( dPs0 ) ; 456 457 Ps0LD = Ps0LD + dPs0 ; 458 459 TX = -Vxbgmtcl + ps_conv / 2 ; 460 if ( Ps0LD < TX ) Ps0LD = TX ; 461 462 /*-------------------------------------------* 463 * Check convergence. 464 *-----------------*/ 465 if ( fabs( dPs0 ) <= ps_conv && fabs( Fs0 ) <= gs_conv ) { 466 flg_conv = 1 ; 467 } 468 469 } /* end of Ps0LD Newton loop */ 470 471 /*-------------------------------------------* 472 * Procedure for diverged case. 473 *-----------------*/ 474 if ( flg_conv == 0 ) { 475 fprintf( stderr , 476 "*** warning(HiSIM_HV): Went Over Iteration Maximum (Ps0LD)\n" ) ; 477 fprintf( stderr , " -Vxbgmtcl = %e Vgbgmt = %e\n" , -Vxbgmtcl , Vgbgmt ) ; 478 } 479 480 /*---------------------------------------------------* 481 * Evaluate derivatives of Ps0LD. 482 *-----------------*/ 483 Chi_dT = beta_dT * ( Ps0LD + Vxbgmtcl ) + beta * Vxbgmtcl_dT; 484 exp_bVbs_dT = - ( beta_dT * Vxbgmtcl + beta * Vxbgmtcl_dT ) * exp_bVbs; 485 cfs1_dT = exp_bVbs * cnst1over_dT + exp_bVbs_dT * cnst1over; 486 487 if ( Chi < znbd5 ) { 488 fs01_dVbs = cfs1 * beta * fi * ( - fi + 2 * fi_dChi ) ; /* fs01_dVxbgmtcl */ 489 fs01_dT = cfs1 * 2 * fi * fi_dChi * Chi_dT + fi * fi * cfs1_dT ; 490 T2 = 1.0e0 / ( fs02 + fs02 ) ; 491 fs02_dVbs = ( + beta * fb_dChi * 2 * fb + fs01_dVbs ) * T2 ; /* fs02_dVxbgmtcl */ 492 fs02_dT = ( 2 * fb * fb_dChi * Chi_dT + fs01_dT ) * T2 ; 493 } else { 494 if ( Chi < large_arg ) { 495 fs01_dVbs = + cfs1 * beta ; /* fs01_dVxbgmtcl */ 496 exp_Chi_dT = exp_Chi * Chi_dT ; 497 fs01_dT = ( exp_Chi - 1.0e0 ) * cfs1_dT + cfs1 * exp_Chi_dT ; 498 } else { 499 fs01_dVbs = + cfs1 * beta ; 500 exp_bPs0_dT = exp_bPs0 * Ps0LD * beta_dT ; 501 fs01_dT = cnst1over_dT*(exp_bPs0-exp_bVbs) + cnst1over*(exp_bPs0_dT-exp_bVbs_dT) ; 502 } 503 T2 = 0.5e0 / fs02 ; 504 fs02_dVbs = ( + beta + fs01_dVbs ) * T2 ; /* fs02_dVxbgmtcl */ 505 fs02_dT = T2 * ( Chi_dT + fs01_dT ) ; 506 } 507 508 T1 = 1.0 / Fs0_dPs0 ; 509 Ps0LD_dVxb = - ( - fac1 * fs02_dVbs ) * T1 ; 510 Ps0LD_dVds = 0.0 ; 511 Ps0LD_dVgb = - ( VgpLD_dVgb - fac1_dVgs * fs02 ) * T1 ; 512 Ps0LD_dT = - ( - ( fac1 * fs02_dT + fac1_dT * fs02 ) ) * T1; 513 514 Chi_dT = beta_dT * ( Ps0LD + Vxbgmtcl ) + beta * ( Ps0LD_dT + Vxbgmtcl_dT ); 515 516 if ( Chi < znbd5 ) { 517 /*-------------------------------------------* 518 * zone-D1/D2. (Ps0LD) 519 *-----------------*/ 520 if ( Chi < znbd3 ) { flg_ovzone = 1; } 521 else { flg_ovzone = 2; } 522 523 Xi0 = fb * fb + epsm10 ; 524 T1 = 2 * fb * fb_dChi * beta ; 525 Xi0_dVbs = T1 * ( Ps0LD_dVxb + 1.0 ) ; /* Xi0_dVxbgmtcl */ 526 Xi0_dVds = T1 * Ps0LD_dVds ; 527 Xi0_dVgs = T1 * Ps0LD_dVgb ; 528 Xi0_dT = 2 * fb * fb_dChi * Chi_dT ; 529 530 Xi0p12 = fb + epsm10 ; 531 T1 = fb_dChi * beta ; 532 Xi0p12_dVbs = T1 * ( Ps0LD_dVxb + 1.0 ) ; /* Xi0p12_dVxbgmtcl */ 533 Xi0p12_dVds = T1 * Ps0LD_dVds ; 534 Xi0p12_dVgs = T1 * Ps0LD_dVgb ; 535 Xi0p12_dT = fb_dChi * Chi_dT ; 536 537 Xi0p32 = fb * fb * fb + epsm10 ; 538 T1 = 3 * fb * fb * fb_dChi * beta ; 539 Xi0p32_dVbs = T1 * ( Ps0LD_dVxb + 1.0 ) ; /* Xi0p32_dVxbgmtcl */ 540 Xi0p32_dVds = T1 * Ps0LD_dVds ; 541 Xi0p32_dVgs = T1 * Ps0LD_dVgb ; 542 Xi0p32_dT = 3 * fb * fb * fb_dChi * Chi_dT ; 543 544 } else { 545 /*-------------------------------------------* 546 * zone-D3. (Ps0LD) 547 *-----------------*/ 548 flg_ovzone = 3 ; 549 550 Xi0 = Chi - 1.0e0 ; 551 Xi0_dVbs = beta * ( Ps0LD_dVxb + 1.0e0 ) ; /* Xi0_dVxbgmtcl */ 552 Xi0_dVds = beta * Ps0LD_dVds ; 553 Xi0_dVgs = beta * Ps0LD_dVgb ; 554 Xi0_dT = Chi_dT ; 555 556 Xi0p12 = sqrt( Xi0 ) ; 557 T1 = 0.5e0 / Xi0p12 ; 558 Xi0p12_dVbs = T1 * Xi0_dVbs ; 559 Xi0p12_dVds = T1 * Xi0_dVds ; 560 Xi0p12_dVgs = T1 * Xi0_dVgs ; 561 Xi0p12_dT = T1 * Xi0_dT ; 562 563 Xi0p32 = Xi0 * Xi0p12 ; 564 T1 = 1.5e0 * Xi0p12 ; 565 Xi0p32_dVbs = T1 * Xi0_dVbs ; 566 Xi0p32_dVds = T1 * Xi0_dVds ; 567 Xi0p32_dVgs = T1 * Xi0_dVgs ; 568 Xi0p32_dT = T1 * Xi0_dT ; 569 570 } /* end of if ( Chi ... ) block */ 571 572 /*-----------------------------------------------------------* 573 * - Recalculate the derivatives of fs01 and fs02. 574 *-----------------*/ 575 fs01_dVbs = Ps0LD_dVxb * fs01_dPs0 + fs01_dVbs ; 576 fs01_dVds = Ps0LD_dVds * fs01_dPs0 ; 577 fs01_dVgs = Ps0LD_dVgb * fs01_dPs0 ; 578 fs01_dT = Ps0LD_dT * fs01_dPs0 + fs01_dT; 579 fs02_dVbs = Ps0LD_dVxb * fs02_dPs0 + fs02_dVbs ; 580 /* fs02_dVxb = Ps0LD_dVds * fs02_dPs0 ;*/ 581 fs02_dVgb = Ps0LD_dVgb * fs02_dPs0 ; 582 fs02_dT = Ps0LD_dT * fs02_dPs0 + fs02_dT; 583 584 /*-----------------------------------------------------------* 585 * QbuLD and QiuLD 586 *-----------------*/ 587 QbuLD = cnst0over_func * Xi0p12 ; 588 QbuLD_dVxb = cnst0over_func * Xi0p12_dVbs ; 589 QbuLD_dVgb = cnst0over_func * Xi0p12_dVgs ; 590 QbuLD_dT = cnst0over_func * Xi0p12_dT + cnst0over_func_dT * Xi0p12; 591 592 T1 = 1.0 / ( fs02 + Xi0p12 ) ; 593 QiuLD = cnst0over_func * fs01 * T1 ; 594 T2 = 1.0 / ( fs01 + epsm10 ) ; 595 QiuLD_dVbs = QiuLD * ( fs01_dVbs * T2 - ( fs02_dVbs + Xi0p12_dVbs ) * T1 ) ; 596 QiuLD_dVgs = QiuLD * ( fs01_dVgs * T2 - ( fs02_dVgb + Xi0p12_dVgs ) * T1 ) ; 597 T1_dT = - T1 * T1 * ( fs02_dT + Xi0p12_dT ); 598 QiuLD_dT = cnst0over_func * ( fs01 * T1_dT + T1 * fs01_dT ) + fs01 * T1 * cnst0over_func_dT; 599 600 /*-----------------------------------------------------------* 601 * Extrapolation: X_dVxbgmt = X_dVxbgmtcl * Vxbgmtcl_dVxbgmt 602 *-----------------*/ 603 QbuLD_dVxb *= Vxbgmtcl_dVxbgmt ; 604 QiuLD_dVbs *= Vxbgmtcl_dVxbgmt ; 605 606 /*-----------------------------------------------------------* 607 * Total overlap charge 608 *-----------------*/ 609 QsuLD = QbuLD + QiuLD; 610 QsuLD_dVxb = QbuLD_dVxb + QiuLD_dVbs; 611 QsuLD_dVgb = QbuLD_dVgb + QiuLD_dVgs; 612 QsuLD_dT = QbuLD_dT + QiuLD_dT; 613 614 } /* end of COQOVSM branches */ 615 616 } /* end of Vgbgmt region blocks */ 617 618 /* convert to source ref. */ 619 /* Ps0LD_dVbs = Ps0LD_dVxb * Vxbgmt_dVbs + Ps0LD_dVgb * Vgbgmt_dVbs ;*/ 620 Ps0LD_dVds = Ps0LD_dVxb * Vxbgmt_dVds + Ps0LD_dVgb * Vgbgmt_dVds ; 621 /* Ps0LD_dVgs = Ps0LD_dVxb * Vxbgmt_dVgs + Ps0LD_dVgb * Vgbgmt_dVgs ;*/ 622 623 QsuLD_dVbs = QsuLD_dVxb * Vxbgmt_dVbs + QsuLD_dVgb * Vgbgmt_dVbs ; 624 QsuLD_dVds = QsuLD_dVxb * Vxbgmt_dVds + QsuLD_dVgb * Vgbgmt_dVds ; 625 QsuLD_dVgs = QsuLD_dVxb * Vxbgmt_dVgs + QsuLD_dVgb * Vgbgmt_dVgs ; 626 627 QbuLD_dVbs = QbuLD_dVxb * Vxbgmt_dVbs + QbuLD_dVgb * Vgbgmt_dVbs ; 628 QbuLD_dVds = QbuLD_dVxb * Vxbgmt_dVds + QbuLD_dVgb * Vgbgmt_dVds ; 629 QbuLD_dVgs = QbuLD_dVxb * Vxbgmt_dVgs + QbuLD_dVgb * Vgbgmt_dVgs ; 630 631 /* inversion charge = total - depletion */ 632 QiuLD = QsuLD - QbuLD ; 633 QiuLD_dVbs = QsuLD_dVbs - QbuLD_dVbs ; 634 QiuLD_dVds = QsuLD_dVds - QbuLD_dVds ; 635 QiuLD_dVgs = QsuLD_dVgs - QbuLD_dVgs ; 636 QiuLD_dT = QsuLD_dT - QbuLD_dT ; 637 638 /* End HSMHVevalQover */ 639