def test_errstate_all_but_one(): olderr = sc.geterr() with sc.errstate(all='raise', singular='ignore'): sc.gammaln(0) with assert_raises(sc.SpecialFunctionError): sc.spence(-1.0) assert_equal(olderr, sc.geterr())
def Jplus2(self): return (spence(1 - self.u1 / self.z1) - spence(1 - self.u2 / self.z2) + spence(1 - self.z1 / (self.z1 + self.u2)) - spence(1 - self.z2 / (self.z2 + self.u1)) + np.log(self.u1 / self.z1) * np.log(1 - self.u1 / self.z1) - np.log(self.u2 / self.z2) * np.log(1 - self.u2 / self.z2) + np.log(self.z2 / self.z1) * np.log(self.u * (self.z1 + self.u2)))
def DiLog(arg): """Return the dilogarithm (Spence's function) defined as \Phi(x) = -\int_{0}^{x} \frac{\ln|1 - u|}{u} du. See https://en.wikipedia.org/wiki/Spence's_function""" if (arg <= 1): return special.spence(1. - arg) else: return (pi**2)/3. - (np.log(arg)**2)/2. - special.spence(1. - 1./arg)
def Iplus(self): return (spence(1 - self.u1 / self.w1) - spence(1 - self.u2 / self.w2) - 2 * spence(1 - self.w1 / self.w2) + spence(1 - self.w1 / (self.w1 + self.u2)) - spence(1 - self.w2 / (self.w2 + self.u1)) + np.pi**2 / 3 + np.log(self.w2 / self.w1) * np.log( (self.w1 + self.u2) * self.u / (self.w2 * self.z)) + np.log(self.u1 / self.w1) * np.log(1 - self.u1 / self.w1) - np.log(self.u2 / self.w2) * np.log(1 - self.u2 / self.w2))
def test_consistency(): # Make sure the implementation of spence for real arguments # agrees with the implementation of spence for imaginary arguments. x = np.logspace(-30, 300, 200) dataset = np.vstack((x + 0j, spence(x))).T FuncData(spence, dataset, 0, 1, rtol=1e-14).check()
def Sc(c): ans = (0.5 * np.pi**2 - old_div(np.log(c), 2.) - old_div(0.5, c) - old_div(0.5, (1 + c)**2) - old_div(3, (1 + c)) + np.log(1 + c) * (0.5 + old_div(0.5, c**2) - old_div(2, c) - old_div(1, (1 + c))) + 1.5 * (np.log(1 + c))**2 + 3. * spence(c + 1)) return ans
def gen(x, name): """Generate fixture data and writes them to file. # Arguments * `x`: domain * `name::str`: output filename # Examples ``` python python> x = linspace(0.0, 1.0, 2001) python> gen(x, './data.json') ``` """ y = spence(x) # Store data to be written to file as a dictionary: data = {"x": x.tolist(), "expected": y.tolist()} # Based on the script directory, create an output filepath: filepath = os.path.join(DIR, name) # Write the data to the output filepath as JSON: with open(filepath, "w") as outfile: json.dump(data, outfile)
def w7_xy(mass): #NLO y = NLOyy(mass) chunk_1 = (8 * y**2 - 28 * y + 12) / (3 * (y - 1)**3) chunk_2 = sp.spence(1.0 / y) chunk_3 = (3 * y**2 + 14 * y - 8) * (np.log(y))**2 / (3 * (y - 1)**4) chunk_4 = (4 * y**3 - 24 * y**2 + 2 * y + 6) * np.log(y) / (3 * (y - 1)**4) chunk_5 = (-2 * y**2 + 13 * y - 7) / ((y - 1)**3) return 4 / 3 * y * (chunk_1 * chunk_2 + chunk_3 + chunk_4 + chunk_5)
def sig_dm2(x, c): ##EQ 14 Lokas & Mamon 2001 ans = 0.5 * x * c * gc(c) * (1 + x)**2 * ( np.pi**2 - np.log(x) - (old_div(1., x)) - (old_div(1., (1. + x)**2)) - (old_div(6., (1. + x))) + np.log(1. + x) * (1. + (old_div(1., x**2)) - old_div(4., x) - old_div(2, (1 + x))) + 3. * (np.log(1. + x))**2 + 6. * spence(x + 1)) return ans
def w8_xy(mass): #NLO y = NLOyy(mass) c1 = (17 * y**2 - 25 * y + 36) / (2 * (y - 1)**3) c2 = sp.spence(1.0 / y) c3 = -(17 * y + 19) * (np.log(y))**2 / ((y - 1)**4) c4 = (14 * y**3 - 12 * y**2 + 187 * y + 3) * np.log(y) / (4 * (y - 1)**4) c5 = -(3 * (29 * y**2 - 44 * y + 143)) / (8 * (y - 1)**3) return 1 / 3 * y * (c1 * c2 + c3 + c4 + c5)
def test_spence_larger(self, dtype): x = np.random.uniform(1., 100., size=int(1e4)).astype(dtype) try: from scipy import special # pylint: disable=g-import-not-at-top self.assertAllClose( special.spence(x), self.evaluate(special_math_ops.spence(x))) except ImportError as e: tf_logging.warn('Cannot test special functions: %s' % str(e))
def sig_dm2(x, c): '''EQ 14 Lokas & Mamon 2001 ''' ans = 0.5 * x * c * gc(c) * ( 1 + x)**2 * (np.pi**2 - np.log(x) - (1. / x) - (1. / (1. + x)**2) - (6. / (1. + x)) + np.log(1. + x) * (1. + (1. / x**2) - 4. / x - 2 / (1 + x)) + 3. * (np.log(1. + x))**2 + 6. * spence(x + 1)) return ans
def phi2_theta_phi3(self): return ( (7. / 36 + 2. * self.z / 45 + 7. * self.z * self.theta / 72) * (np.log(self.z2 / self.z1)**2 + np.pi**2 + 2 * np.log(self.z)**2) + (7. / 18 + 3. * self.z / 20 + 7. * self.z * self.theta / 36) * np.log(self.z) + 653. / 270 - 28. / (9 * self.z) + 2. * self.theta / 3 + (-3 * self.z / 10 - 92. / 45 + 52. / (45 * self.z) + (2. / 9 - 7. * self.z / 18) * self.theta) * self.Bz * np.log(self.z2 / self.z1) + self.Bz * (-8. * self.z / 45 - 19. / 45 - 8. / (45 * self.z) - (2. / 9 + 7. * self.z / 18) * self.theta) * (spence(1 - self.y) + 2 * spence(1 - 1 / self.z2) + 3 * np.log(self.z2 / self.z1)**2 / 2) + (8. / self.z + self.z * self.theta) * (self.Bz / (3 * (self.z + 4))) * (6 * spence(1 - 1 / self.z2) - spence(1 - self.y) + np.log(self.z2 / self.z1)**2 / 2))
def w8_sm(): #NLO x = NLOxx chunk_1 = (-4 * x**4 + 40 * x**3 + 41 * x**2 + x) / (6 * (x - 1)**4) chunk_2 = sp.spence(1.0 / x) chunk_3 = (-17 * x**3 - 31 * x**2) * (np.log(x))**2 / (2 * (x - 1)**5) chunk_4 = (- 210 * x**5 + 1086 * x**4 + 4893 * x**3 + 2857 * x**2 - 1994 * x + 280) * \ np.log(x) / (216 * (x - 1)**5) chunk_5 = (737 * x**4 - 14102 * x**3 - 28209 * x**2 + 610 * x - 508) \ / (1296 * (x - 1)**4) return chunk_1 * chunk_2 + chunk_3 + chunk_4 + chunk_5
def w8_yy(mass): #NLO y = NLOyy(mass) chunk_1 = (13 * y**3 - 17 * y**2 + 30 * y) / ((y - 1)**4) chunk_2 = sp.spence(1.0 / y) chunk_3 = -(17 * y**2 + 31 * y) / ((y - 1)**5) * (np.log(y))**2 chunk_4 = (42 * y**4 + 318 * y**3 + 1353 * y**2 + 817 * y - 226) * \ np.log(y) / (36 * (y - 1)**5) chunk_5 = (-4451 * y**3 + 7650 * y**2 - 18153 * y + 1130) / (216 * (y - 1)**4) return 1 / 6 * y * (chunk_1 * chunk_2 + chunk_3 + chunk_4 + chunk_5) - \ 1 / 6 * E_H(mass)
def w7_sm(): #NLO x = NLOxx chunk_1 = (-16 * x**4 - 122 * x**3 + 80 * x**2 - 8 * x) / (9 * (x - 1)**4) chunk_2 = sp.spence(1.0 / x) chunk_3 = (6 * x**4 + 46 * x**3 - 28 * x**2) * (np.log(x))**2 / (3 * (x - 1)**5) chunk_4 = (- 102 * x**5 - 588 * x**4 - 2262 * x**3 + 3244 * x**2 - 1364 * x + 208 ) * \ np.log(x) / (81 * (x - 1)**5) chunk_5 = (1646 * x**4 + 12205 * x**3 - 10740 * x**2 + 2509 * x - 436) / (486 * (x - 1)**4) return chunk_1 * chunk_2 + chunk_3 + chunk_4 + chunk_5
def integrand_1D_PotOpt_DensWS(a_r_int, a_Args): """ The function for Definition of the integrand. ~~~ For Woods-Saxon-type nucleus density ~~~ ~~~ Potential is optional (sphere function) ~~~ => Defined as Int(|r|, |rP|) = 2Pi Int d_cosP rho_WS(r-rP) [|rP|^2 V(rP)] For arguments, - a_Args[4] (1-dim array) return (The value of integrand) Note1: a_r := a_Args[0] . a_func_potential := a_Args[1] . a_Params_pot (array) := a_Args[2] . a_Params_dens (array) := a_Args[3] Note2: Suppose that a_Params_dens[0] = R_A . Suppose that a_Params_dens[1] = a_A Note3: Suppose that rho has no normalized factor (which is rho_0) """ # For Debug #from numpy import array #from scipy.integrate import quad #WS_2D = lambda c0, Ag: (exp ((Ag[2] - sqrt(Ag[0]**2 + Ag[1]**2 + 2.0*Ag[0]*Ag[1]*c0)) / Ag[3]) / # (exp((Ag[2] - sqrt(Ag[0]**2 + Ag[1]**2 + 2.0*Ag[0]*Ag[1]*c0)) / Ag[3]) + 1.0)) #ret_integrand = quad(WS_2D, -1.0, 1.0, args = array((a_r_int, a_Args[0], a_Args[3][0], a_Args[3][1])))[0] #return ret_integrand * 2.0*pi * a_r_int**2 * a_Args[1](a_r_int, *a_Args[2]) rprP = a_Args[0] + a_r_int rmrP = abs(a_Args[0] - a_r_int) exp_p = exp((a_Args[3][0] - rprP) / a_Args[3][1]) exp_m = exp((a_Args[3][0] - rmrP) / a_Args[3][1]) tmp_d = ((-rprP * log(1 + exp_p) + rmrP * log(1 + exp_m)) + (+spence(1 + exp_p) - spence(1 + exp_m)) * a_Args[3][1]) return tmp_d * 2.0 * pi * a_Args[3][1] * a_r_int * a_Args[1]( a_r_int, *a_Args[2]) / a_Args[0]
def sigma(r,subject_flag): if (subject_flag==1): #Plummer sigmasq=1/(6*np.sqrt(1+r**2)) return np.sqrt(2*sigmasq) elif (subject_flag==2): #Hernquist sigmasq=(r*(1+r)**3*np.log((1+r)/r)-(r/(12*(1+r)))*(25+52*r+42*r**2+12*r**3))*np.heaviside(1e2-r,1)+(1/(5*r))*np.heaviside(r-1e2,1) return np.sqrt(2*sigmasq) elif (subject_flag==3): #NFW #Li2=-r*( 1+(10**(-0.5))*(r**(0.62/0.7)) )**(-0.7) Li2=spence(1+r) sigmasq=0.5*r*(1+r)**2*( np.pi**2-np.log(r)-1/r-1/(1+r)**2-6/(1+r)+(1+1/r**2-4/r-2/(1+r))*np.log(1+r)+3*(np.log(1+r))**2+6*Li2 ) return np.sqrt(2*sigmasq)
def w7_yy(mass): #NLO y = NLOyy(mass) chunk_1 = (8 * y**3 - 37 * y**2 + 18 * y) / ((y - 1)**4) chunk_2 = sp.spence(1.0 / y) chunk_3 = (3 * y**3 + 23 * y**2 - 14 * y) * (np.log(y))**2 / ((y - 1)**5) chunk_4 = (21 * y**4 - 192 * y**3 - 174 * y**2 + 251 * y - 50) \ * np.log(y) / (9 * (y - 1)**5) chunk_5 = (-1202 * y**3 + 7569 * y**2 - 5436 * y + 797) / (108 * (y - 1)**4) return 2 * y / 9 * (chunk_1 * chunk_2 + chunk_3 + chunk_4 + chunk_5) - \ 4 / 9 * E_H(mass)
def Pkernel(x): """Kernel function from Biteau & Williams (2015), Eq. (7)""" m = (x < 0.) & (x >= 1.) x[x < 0.] = np.zeros(np.sum(x < 0.)) x[x >= 1.] = np.zeros(np.sum(x >= 1.)) x = np.sqrt(x) result = np.log(2.) * np.log(2.) - np.pi *np.pi / 6. \ + 2. * spence(0.5 + 0.5 * x) - (x + x*x*x) / (1. - x*x) \ + (np.log(1. + x) - 2. * np.log(2.)) * np.log(1. - x) \ + 0.5 * (np.log(1. - x) * np.log(1. - x) - np.log(1. + x) * np.log(1. + x)) \ + 0.5 * (1. + x*x*x*x) / (1. - x*x) * (np.log(1. + x) - np.log(1. - x)) result[x <= 0.] = np.zeros(np.sum(x <= 0.)) result[x >= 1.] = np.zeros(np.sum(x >= 1.)) return result
def H(self): return (spence(1 - self.z / (self.u + 4)) - spence(1 - (self.z + 4) / (self.u + 4)) + spence(1 - self.z / (self.z + 4)) - 2 * spence(1 - self.u / (self.u + 4)) + spence(1 - 4 * self.w / (self.u * (self.z + 4))) + spence(1 - 4 * self.z / (self.u * (self.w + 4))) - spence(1 - 4 / (self.w + 4)) + np.pi**2 / 6 + 2 * np.log(self.z1) * np.log(self.z2) - 4 * np.log(self.u1) * np.log(self.u2) - np.log(self.z)**2 + np.log(self.z + 4)**2 - np.log(1 + 4. / self.w) * np.log(self.u + 4) - np.log(4 * self.w) * np.log(self.z + 4) + np.log(16) * np.log(self.u + 4) - np.log(self.u + 4)**2 + 2 * np.log(self.u)**2 + np.log(self.u) * np.log( (self.z + 4) * (self.w + 4) / (4 * 4 * self.w)) - np.log(self.z) * np.log( (self.z + 4) * self.u / (4 * self.w)))
def f(eta, b0,b1,b2,\ rb0,rb1,rb2,rrb0,rrb1,rrb2,rrrb0,rrrb1,rrrb2,\ lb0,lb1,lb2,llb0,llb1,llb2,\ rlb0,rlb1,rlb2,\ sb0,sb1,sb2 ): betas = [beta(eta)**j for j in [0,1,2,3]] x = chi(eta) return (rho(eta)**1)*(beta(eta)**9) * (\ np.dot([b0,b1,b2],betas[:3]) +\ np.dot([rb0,rb1,rb2],betas[:3])*rho(eta) +\ np.dot([rrb0,rrb1,rrb2],betas[:3])*(rho(eta)**2) +\ np.dot([rrrb0,rrrb1,rrrb2],betas[:3])*(rho(eta)**3) +\ np.dot([lb0,lb1,lb2],betas[:3])*np.log(x)+\ np.dot([llb0,llb1,llb2],betas[:3])*np.log(x)**2+\ #np.dot([lllb0,lllb1,lllb2],betas[:3])*np.log(1+x)+\ np.dot([sb0,sb1,sb2],betas[:3])*spence(1-x)+\ #np.dot([sMb0,sMb1,sMb2],betas[:3])*spence(1-x**2)\ np.dot([rlb0,rlb1,rlb2],betas[:3])*rho(eta)*np.log(x)\ )
def get_v(u, epsilon=1e-8): """get_v Parameters ---------- u : ``int`` epsilon : ``float`` Returns ------- """ v = u delta = 1 while delta > epsilon: n_v = u * np.sqrt(spence(np.exp(-v))) delta = abs(n_v - v) v = n_v return v
def test_errstate_c_basic(): olderr = sc.geterr() with sc.errstate(domain='raise'): with assert_raises(sc.SpecialFunctionError): sc.spence(-1) assert_equal(olderr, sc.geterr())
def polylog(x): return spence(1-x)
def g2(x): """ polylog(2, x) implemented via scipy.special.spence. This translation is due to scipy's definition of the dilogarithm """ return spence(1.0 - x)
def radiate_inelastic_xs(func, z, a, e, ep, theta, tb, ta, *, args=()): """ Return radiated inelastic cross section. Parameters ---------- func : callable Non-radiated cross section function. z : int Atomic number. a : int Mass number. e : rank-1 array of float Energy of incident electron. ep : rank-1 array of float Energy of scattered electron. theta : rank-1 array of float Scattering angle. tb : float Radiation length before scattering. ta : float Radiation length after scattering. args : tuple, optional Extra arguments to pass to function, if any. References ---------- S. Stein et al., Phys. Rev. D 12(1975)1884 """ es = e m_t = mass(z, a) # scalars de = 0.005 # (A83) logz13 = np.log(183 * np.power(z, -1 / 3)) eta = np.log(1440 * np.power(z, -2 / 3)) / logz13 # (A46) b = 4 / 3 * (1 + 1 / 9 * ((z + 1) / (z + eta)) / logz13) # (A45) t = tb + ta # (A47) xi = _m_e / (2 * _alpha_pi) * t / ((z + eta) * logz13) # (A52) # vectors sin2_theta_2 = np.sin(theta / 2)**2 q2 = 4 * es * ep * sin2_theta_2 r = (m_t + 2 * es * sin2_theta_2) / (m_t - 2 * ep * sin2_theta_2) tr = _alpha_pi * (np.log(q2 / _m_e**2) - 1) / b # (A57) # in scipy, spence is defined as \int_0^z log(t)/(1-t) dt # spence in the reference is spence(1 - z) here # so use 1 - cos2_theta_2 = sin2_theta_2 spence = special.spence(sin2_theta_2) # (A48) # (A44) def _f(es, ep, q2, spence): logq2me = np.log(q2 / _m_e**2) ff = 1 + 0.5772 * b * t ff += 2 * _alpha_pi * (-14 / 9 + 13 / 12 * logq2me) ff -= _alpha_pi / 2 * (np.log(es / ep))**2 ff += _alpha_pi * (np.pi**2 / 6 - spence) return ff # (A82), 1st term term1_1 = np.power(r * de / es, b * (tb + tr)) term1_2 = np.power(de / ep, b * (ta + tr)) term1_3 = 1 - xi / de / (1 - b * (t + 2 * tr)) xs = func(z, a, es, ep, theta, *args) term1 = term1_1 * term1_2 * term1_3 * _f(es, ep, q2, spence) * xs # (A54) def _phi(v): return 1 - v + 0.75 * v**2 # (A82), 2nd term, integrand def term2_integrand(esp, es, ep, theta, q2, r, tr, spence): term2_1 = np.power((es - esp) / (ep * r), b * (ta + tr)) term2_2 = np.power((es - esp) / es, b * (tb + tr)) term2_3 = b * (tb + tr) / (es - esp) * _phi((es - esp) / es) term2_3 += xi / (2 * (es - esp)**2) xs = func(z, a, esp, ep, theta, *args) return term2_1 * term2_2 * term2_3 * _f(es, ep, q2, spence) * xs # (A82), 3rd term, integrand def term3_integrand(epp, es, ep, theta, q2, r, tr, spence): term3_1 = np.power((epp - ep) / epp, b * (ta + tr)) term3_2 = np.power((epp - ep) * r / es, b * (tb + tr)) term3_3 = b * (ta + tr) / (epp - ep) * _phi((epp - ep) / epp) term3_3 += xi / (2 * (epp - ep)**2) xs = func(z, a, es, epp, theta, *args) return term3_1 * term3_2 * term3_3 * _f(es, ep, q2, spence) * xs if np.isscalar(term1): term2, _ = integrate.quad( term2_integrand, ep / (1 - q2 / (2 * es * m_t)), # (A50) es - r * de, args=(es, ep, theta, q2, r, tr, spence), epsrel=1e-3, ) term3, _ = integrate.quad( term3_integrand, ep + de, es / (1 + q2 / (2 * ep * m_t)), # (A51) args=(es, ep, theta, q2, r, tr, spence), epsrel=1e-3, ) else: term2 = np.zeros_like(term1) term3 = np.zeros_like(term1) it = np.nditer( [es, ep, theta, q2, r, tr, spence, term2, term3], op_flags=[['readonly'], ['readonly'], ['readonly'], ['readonly'], ['readonly'], ['readonly'], ['readonly'], ['writeonly'], ['writeonly']], ) for ies, iep, itheta, iq2, ir, itr, ispence, iterm2, iterm3 in it: iterm2[...], _ = integrate.quad( term2_integrand, iep / (1 - iq2 / (2 * ies * m_t)), # (A50) ies - ir * de, args=(ies, iep, itheta, iq2, ir, itr, ispence), epsrel=1e-3, ) iterm3[...], _ = integrate.quad( term3_integrand, iep + de, ies / (1 + iq2 / (2 * iep * m_t)), # (A51) args=(ies, iep, itheta, iq2, ir, itr, ispence), epsrel=1e-3, ) return term1 + term2 + term3
def NFW_sigma(R, Mhalo, z, CosPar, fcorr=1., alpha=1.): """ NFW_sigma(R, Mhalo, z, CosPar, fcorr=1., alpha=1.) return rho(R), R in Mpc, rho in MSun pc^-2 """ R = np.array(R) # r could be r(r) or r(r, Mhalo) R = R.reshape(R.shape[0], R.size/R.shape[0]) Mhalo = np.array(Mhalo) c = fcorr*concentration(Mhalo, z, M_star) R_vir = virial_radius(Mhalo, z, CosPar) rhos = rho_s(c,z,CosPar,alpha) x = c*R/R_vir # cr/rvir(R, Mhalo) gc = 1./(np.log(1.+c)-c/(1.+c)) return circular_virial(Mhalo,z,CosPar)*(1.+x)*np.sqrt(0.5*x*c*gc*(np.pi**2-np.log(x)-1./x-1./(1.+x)**2-6./(1.+x)+(1.+1./x/x-4./x-2./(1.+x))*np.log(1.+x)+3.*pow(np.log(1.+x),2)+6.*spence(1.+x)))
import numpy as np from numpy import abs, sqrt, arccos as acos, arccosh as acosh, log as ln, pi, inf from scipy.special import spence from scipy.integrate import quad as integrate __all__ = ['lokas'] pi2 = pi**2 Li = lambda x: spence(1-x) sa = 4/3 sa2 = sa**2 g = lambda c: 1 / (ln(1+c) - c/(1+c)) C1 = lambda Rt, c: acos if Rt>1/c else acosh beta_om = lambda s: s**2 / (s**2 + sa2) def sigmar2_overvvir2_om(s, c): c2 = c**2 cs = c*s ln1cs = ln(1+cs) f1 = g(c) * s * (1+cs)**2 / (2 * (s**2 + sa2)) f2 = -c * sa2 / s f2 += -c2 * sa2 * ln(cs) f2 += c2 * sa2 * ln1cs * (1 + 1/cs**2 - 4/cs) f2 += -(1 + c2*sa2) * (1/(1+cs)**2 + 2*ln1cs/(1+cs)) f2 += (1 + 3*c2*sa2) * (pi2/3 - 2/(1+cs) + ln1cs**2 + 2*Li(-cs))
def Li2(x): return special.spence(1-x)
def Jplus1(self): return 2 * spence(1 - 1 / self.z2) - spence(1 - self.y) + np.log( self.z1) * np.log(self.z2 / self.z1)
gamSModp = (GF*pow(alphaEM,2)*pow(125.0,3)/(128.*sqrt(2)*pow(pi,3)))*pow(abs(Aone + Atopsm),2) gamSMotot = 0.00407 brsmdpnew = gamSMvlqdp/(gamSMotot - gamSModp + gamSMvlqdp) RgamgamSM = gamSMvlqdp/gamSModp mmtau = 1.777 if 1.0 - 4.0*pow(mmtau/mHH,2) < 0: gamHtotata = 0 else: gamHtotata = (GF*mHH*(mmtau**2)*((tan(beta))**2)/(4.*sqrt(2)*pi))*pow(sqrt(1.0 - 4.0*pow(mmtau/mHH,2)),3) #alphast = 0.096 betat = sqrt(1. - 4.*(mt/mHH)**2) xbetat = ( 1. - betat)/(1. + betat) #Spence function Li2(x) = spence(1-x) Li2 = spence(1.-betat) mLi2 = spence(1.+betat) Afunction = (1. + betat**2)*(4.*Li2 + 2.*mLi2 + 3.*log(xbetat)*log(2./(1.+betat)) + 2.*log(xbetat)*log(betat)) - 3.*betat*log((4.*betat**(4./3.))/(1. - betat**2)) deltaHt = (1./betat)*Afunction + (1./(16.*betat**3))*(3. + 34.*betat**2 - 13.*betat**4)*log((1. + betat)/(1. - betat)) + (3./(8.*betat**2))*(7.*betat**2 - 1.) if mHH > 2.0*mtpole: gamHtott = ((3*GF)/(4*sqrt(2)*pi))*mHH*((mt/tan(beta))**2)*(betat**3)*(1. + (4./3.)*(alphas(mHH)/pi)*deltaHt) else: gamHtott = 0. gamHtot = gamHtot4 + gamHtogg + gamHtobb + gamHtohh + gamHtocc + gamHdiph + gamHtotata + gamHtott + gamHtot5 + gamHt4t4 + gamHt4t5 + gamHt5t5 + gamHtob4 + gamHtob5 + gamHb4b4 + gamHb4b5 + gamHb5b5 brHtot4 = gamHtot4/gamHtot brHtobb = gamHtobb/gamHtot brHtohh = gamHtohh/gamHtot brHtogg = gamHtogg/gamHtot