Esempio n. 1
0
def integrandnew(E,mx):
    y=E/mx    
    if y<1:
        S1=2-y**2 + 2*y*m.log((mp-mu)*y/(mp-2*mu))-(mp**2 - 2*mu**2)*y/((mp-mu)*(mp - 2*mu))
        S2=2*mu**2*(2-m.log(mu**2*y**2/((mp-2*mu)**2*(1-y))))-3*mu*mp*(4./3.-m.log(mu*y**2*(mp-mu)/((mp-2*mu)**2*(1-y))))+mp**2*(1-m.log(y**2*(mp-mu)**2/((mp-2*mu)**2*(1-y))))
        const=E*10**(-25)*10**(18)*(1/(0.001*mx))**2*(1/(8.*m.pi))        
        return const*(2*alpha/(m.pi*y*mx))*(y**2 + 2*y*(polylog((mp-2*mu)/(mp-mu))-polylog(y))+(2-y**2)*m.log(1-y)+(m.log(mp**2/mu**2)-1)*S1-y*S2/(2*mu**2 - 3*mp*mu+mp**2)) 
    else:
        return 0.
Esempio n. 2
0
def gf_plc(exponent: float, cutoff: float) -> GF:
    '''Return the generating function of the powerlaw-with-cutoff
    degree distribution given its exponent and cutoff, as generated
    by :class:`epydemic.PLCNetwork`.

    :param exponent: the exponent of the distribution
    :param cutoff: the cutoff
    :returns: the generating function'''
    return gf_from_series(lambda x: polylog(exponent, x * exp(-1 / cutoff)) /
                          polylog(exponent, exp(-1 / cutoff)))
Esempio n. 3
0
def Gamma_GO(M, ast, m):# Geometric optics limit

    GM = GCF * (M/GeV_in_g) # in GeV^-1

    TKBH = TBH(M, ast)

    zBH = m/TKBH

    In = - zBH * polylog(2, -np.exp(-zBH)) - polylog(3, -np.exp(-zBH))# DM emission rate including greybody factors
    
    return  2. * (27/(1024. * np.pi**4 * GM)) * In
Esempio n. 4
0
def GammaRH(M, MRH):

    GM = GCF * M / GeV_in_g  # GM in GeV**-1

    al = GM * MRH  # Dimensionless gravitational coupling

    zBH = 8. * np.pi * al

    In1 = float(zBH * mpmath.polylog(2, -np.exp(-zBH)))
    In2 = float(mpmath.polylog(3, -np.exp(-zBH)))

    In = -In1 - In2

    return (gnu / (gf + gs + gv + gnu)) * (27 / (256. * np.pi**3 * GM)) * In  #
Esempio n. 5
0
def IntegralCurve2(S_star, S_L):
    ic1 = (a / b) * ((Const2) * np.log(
        (alpha + b * np.exp(S_star / a)) / (alpha + b * np.exp(S_L / a))) -
                     np.exp(-S_star / a) + np.exp(-S_L / a) - (Const3) *
                     (S_star - S_L))
    ic2 = (Const4) * (np.log(alpha + b * np.exp(S_star / a)) *
                      (S_star / a) - np.log(alpha + b * np.exp(S_L / a)) *
                      (S_L / a) + polylog(2, -b * np.exp(S_star / a)) -
                      polylog(2, -b * np.exp(S_L / a)))
    ic3 = (1 / b) * ((np.exp(-S_star / a)) * (a - S_star) - np.exp(-S_L / a) *
                     (a - S_L)) - ((S_star)**2 - (S_L)**2) / (a * alpha)
    ic = ic1 + ic2 + ic3
    B_star_I2 = B_L + ic
    return B_star_I2
Esempio n. 6
0
def IntegralCurve2(S_star, S_L):
    ic1 = -(a / b) * ((-2 * b / alpha) * np.log(
        (alpha + b * np.exp(S_star / a)) / (alpha + b * np.exp(S_L / a))) -
                      np.exp(-S_star / a) + np.exp(-S_L / a) -
                      (2 * b / (alpha * a)) * (S_star - S_L))
    ic2 = (2 * a /
           alpha) * (np.log(alpha + b * np.exp(S_star / a)) *
                     (S_star / a) - np.log(alpha + b * np.exp(S_L / a)) *
                     (S_L / a) + polylog(2, -b * np.exp(S_star / a)) -
                     polylog(2, -b * np.exp(S_L / a)))
    ic3 = (1 / b) * ((np.exp(-S_star / a)) * (a - S_star) - np.exp(-S_L / a) *
                     (a - S_L)) - ((S_star)**2 + (S_L)**2) / (a * alpha)
    B_star_I2 = B_L + ic1 + ic2 + ic3
    return B_star_I2
Esempio n. 7
0
def IntegralCurve1(S_star, S_R):
    IC1 = -(a / b) * ((-2 * b / alpha) * np.log(
        (alpha - b * np.exp(S_star / a)) / (alpha - b * np.exp(S_R / a))) -
                      np.exp(-S_star / a) + np.exp(-S_R / a) +
                      (2 * b / (alpha * a)) * (S_star - S_R))
    IC2 = -(2 * a / alpha) * (np.log(alpha - b * np.exp(S_star / a)) *
                              (S_star / a) -
                              np.log(alpha - b * np.exp(S_R / a)) *
                              (S_R / a) + polylog(2, b * np.exp(S_star / a)) -
                              polylog(2, b * np.exp(S_R / a)))
    IC3 = (1 / b) * ((np.exp(-S_star / a)) * (a - S_star) - np.exp(-S_R / a) *
                     (a - S_R)) + ((S_star)**2 - (S_R)**2) / (a * alpha)
    B_star_I1 = B_R + IC1 + IC2 + IC3
    return B_star_I1
Esempio n. 8
0
def integrand(x, LbyR, T):
    #print "integrand"
    n = 0
    sum = 0
    while True:
        alpha = 2*n*T*x/(1+1/LbyR)
        arg = exp(-alpha)
        value = polylog(3,arg) + alpha*polylog(2,arg)
        if n == 0:
            value /= 2
        sum += value
        if value/sum < 1e-13:
            return sum/(x**2*LbyR)
        n += 1 
Esempio n. 9
0
def IntegralCurve1(S_star, S_R):
    IC1 = (a / b) * (-Const2 * np.log(
        (alpha - b * np.exp(S_star / a)) / (alpha - b * np.exp(S_R / a))) -
                     np.exp(-S_star / a) + np.exp(-S_R / a) + (Const3) *
                     (S_star - S_R))
    IC2 = -(Const4) * (np.log(alpha - b * np.exp(S_star / a)) *
                       (S_star / a) - np.log(alpha - b * np.exp(S_R / a)) *
                       (S_R / a) + polylog(2, b * np.exp(S_star / a)) -
                       polylog(2, b * np.exp(S_R / a)))
    IC3 = (1 / b) * ((np.exp(-S_star / a)) * (a - S_star) - np.exp(-S_R / a) *
                     (a - S_R)) + ((S_star)**2 - (S_R)**2) / (a * alpha)
    IC = IC1 + IC2 + IC3
    B_star_I1 = B_R - IC

    return B_star_I1
Esempio n. 10
0
def Compute_F(S_star, S_L, S_R, B_L, B_R):

    if (S_L <= S_R):

        IC1 = (a / b) * (-Const2 * np.log(
            (alpha - b * np.exp(S_star / a)) / (alpha - b * np.exp(S_R / a))) -
                         np.exp(-S_star / a) + np.exp(-S_R / a) + (Const3) *
                         (S_star - S_R))
        IC2 = (Const4) * (np.log(alpha - b * np.exp(S_star / a)) *
                          (S_star / a) - np.log(alpha - b * np.exp(S_R / a)) *
                          (S_R / a) + float(polylog(2, b * np.exp(S_star / a)))
                          - float(polylog(2, b * np.exp(S_R / a))))
        IC3 = (1 / b) * ((np.exp(-S_star / a)) *
                         (a - S_star) - np.exp(-S_R / a) * (a - S_R))
        IC4 = ((S_star)**2 - (S_R)**2) / (a * alpha)
        B_star_I1 = B_R - IC1 - IC2 + IC3 + IC4
        #            #print(S_star)
        #            S_star=S_L
        b_star_H1 = B_L - (2 * Const1) * (np.sqrt(S_L - S_star)) * (
            np.sqrt(np.exp(S_L / (rho * C)) - np.exp(S_star / (rho * C))))
        f_star = B_star_I1 - b_star_H1

        print('F(S*) =', f_star)

    else:

        #print('Left Rarefaction and Right Shock')
        ic1 = (a / b) * ((Const2) * np.log(
            (alpha + b * np.exp(S_star / a)) / (alpha + b * np.exp(S_L / a))) -
                         np.exp(-S_star / a) + np.exp(-S_L / a) - (Const3) *
                         (S_star - S_L))
        ic2 = (Const4) * (np.log(alpha + b * np.exp(S_star / a)) *
                          (S_star / a) - np.log(alpha + b * np.exp(S_L / a)) *
                          (S_L / a) +
                          float(polylog(2, -b * np.exp(S_star / a))) -
                          float(polylog(2, -b * np.exp(S_L / a))))
        ic3 = (1 / b) * ((np.exp(-S_star / a)) *
                         (a - S_star) - np.exp(-S_L / a) * (a - S_L))
        ic4 = ((S_star)**2 - (S_L)**2) / (a * alpha)
        B_star_I2 = B_L - ic1 + ic2 + ic3 - ic4

        b_star_H2 = B_R + (2 * Const1) * (np.sqrt(S_R - S_star)) * (
            np.sqrt(np.exp(S_R / (rho * C)) - np.exp(S_star / (rho * C))))

        f_star = B_star_I2 - b_star_H2
        print('f(S*) =', f_star)

    return f_star
Esempio n. 11
0
def Compute_F(S_star, S_L, S_R, B_L, B_R):

    if (S_L <= S_R):

        #print('Left Shock and Right Rarefaction')

        IC1 = (a / b) * (-Const2 * np.log(
            (alpha - b * np.exp(S_star / a)) / (alpha - b * np.exp(S_R / a))) -
                         np.exp(-S_star / a) + np.exp(-S_R / a) + (Const3) *
                         (S_star - S_R))
        IC2 = -(Const4) * (np.log(alpha - b * np.exp(S_star / a)) *
                           (S_star / a) - np.log(alpha - b * np.exp(S_R / a)) *
                           (S_R / a) + polylog(2, b * np.exp(S_star / a)) -
                           polylog(2, b * np.exp(S_R / a)))
        IC3 = (1 / b) * ((np.exp(-S_star / a)) *
                         (a - S_star) - np.exp(-S_R / a) *
                         (a - S_R)) + ((S_star)**2 - (S_R)**2) / (a * alpha)
        IC = IC1 + IC2 + IC3
        f_star = B_R - IC - B_L + (2 * Const1) * (np.sqrt(S_L - S_star)) * (
            (np.sqrt(np.exp(S_L / (rho * C)))) -
            (np.sqrt(np.exp(S_star / (rho * C)))))
        F_star = f_star

        print('F_star = ', F_star)

    else:

        #print('Left Rarefaction and Right Shock')
        ic1 = (a / b) * ((Const2) * np.log(
            (alpha + b * np.exp(S_star / a)) / (alpha + b * np.exp(S_L / a))) -
                         np.exp(-S_star / a) + np.exp(-S_L / a) - (Const3) *
                         (S_star - S_L))
        ic2 = (Const4) * (np.log(alpha + b * np.exp(S_star / a)) *
                          (S_star / a) - np.log(alpha + b * np.exp(S_L / a)) *
                          (S_L / a) + polylog(2, -b * np.exp(S_star / a)) -
                          polylog(2, -b * np.exp(S_L / a)))
        ic3 = (1 / b) * ((np.exp(-S_star / a)) *
                         (a - S_star) - np.exp(-S_L / a) *
                         (a - S_L)) - ((S_star)**2 - (S_L)**2) / (a * alpha)
        ic = ic1 + ic2 + ic3
        f_star = B_L - ic - B_R - (2 * Const1) * (np.sqrt(S_R - S_star)) * (
            (np.sqrt(np.exp(S_R / (rho * C)))) -
            (np.sqrt(np.exp(S_star / (rho * C)))))
        F_star = f_star

        print('F_star = ', F_star)

    return F_star
Esempio n. 12
0
def gf_powerlaw(exponent: float) -> GF:
    '''Return the generating function of the powerlaw
    degree distribution with the given exponent.

    :param exponent: the exponent of the distribution
    :returns: the generating function'''
    return gf_from_series(lambda x: polylog(exponent, x) / zeta(exponent))
Esempio n. 13
0
def fpot_Coulomb_dens_WS(a_r, rho0, R_A, a_A, N_Z, N_A):
    """
    The function of the folding potential
    - Coulomb potential + WS-type density
    
    return: V(r)
    """

    # 1.43996507808 = 197.327053 / 137.035999 (= hbar c * alpha)

    Ex = -exp((R_A - a_r) / a_A)
    Coe = 4.0 * pi * rho0 * N_Z * 1.43996507808 / N_A

    Org_Coulomb = N_Z * 1.43996507808 / a_r
    SFP_Coulomb = Coe * (a_A**2 * polylog(2, Ex) +
                         2.0 * a_A**3 * polylog(3, Ex) / a_r)

    return Org_Coulomb + SFP_Coulomb
Esempio n. 14
0
def debye_non_integral(x):
    '''
	Non-Integral function for the Debye Integral
	(has only to be multiplied with factor A!)
	x = T_D/T (Debye temperature and absolute temperature)
	'''

    # individual summands of integral replacement
    s1 = 4. / 5. * pi**4 / x**3
    s2 = 3 * x * exp(-x) / (exp(-x) - 1)
    s3 = 12 * log(1 - exp(-x))
    s4 = -36 / x * polylog(2, exp(-x))
    s5 = -72 / x**2 * polylog(3, exp(-x))
    s6 = -72 / x**3 * polylog(4, exp(-x))

    DC3 = (s1 + s2 + s3 + s4 + s5 + s6)

    return DC3
Esempio n. 15
0
def Compute_dF(S_star, S_L, S_R, B_L, B_R):
    if (S_L <= S_R):

        dF_1 = -(a / b) * (-Const2 * (-b * np.exp(S_star / a) /
                                      (a * (alpha - b * np.exp(S_star / a)))) +
                           (np.exp(-S_star / a) / a) + Const3)
        dF_2 = -Const4 * ((-S_star * b * np.exp(S_star / a) /
                           (a**2 * (alpha - b * np.exp(S_star / a))) +
                           np.log(alpha - b * np.exp(S_star / a)) / a) +
                          float(polylog(1, b * np.exp(S_star / a)) / a))
        dF_3 = (1 / b) * (-np.exp(-S_star / a) -
                          (-S_star + a) * np.exp(-S_star / a) / a)
        dF_4 = 2 * S_star / (a * alpha)
        dF_5 = (2 * Const1) * (
            -np.sqrt(np.exp(S_L / (C * rho)) - np.exp(S_star / (C * rho))) /
            (2 * np.sqrt(S_L - S_star)) -
            np.sqrt(S_L - S_star) * np.exp(S_star / (C * rho)) /
            (2 * C * rho *
             np.sqrt(np.exp(S_L / (C * rho)) - np.exp(S_star / (C * rho)))))
        dF_star = dF_1 + dF_2 + dF_3 + dF_4 + dF_5
        print('dF(S*) =', dF_star)

    else:

        df_1 = -(a / b) * (Const2 * (b * np.exp(S_star / a) /
                                     (a * (alpha + b * np.exp(S_star / a)))) +
                           (np.exp(-S_star / a) / a) - Const3)
        df_2 = Const4 * ((np.log(alpha + b * np.exp(S_star / a)) / a +
                          S_star * b * np.exp(S_star / a) /
                          (a**2 * (alpha + b * np.exp(S_star / a)))) +
                         float(polylog(1, -b * np.exp(S_star / a)) / a))
        df_3 = (1 / b) * (-np.exp(-S_star / a) -
                          (-S_star + a) * np.exp(-S_star / a) / a) - (
                              2 * S_star) / (a * alpha)
        df_4 = (2 * Const1) * (
            -np.sqrt(np.exp(S_R / (C * rho)) - np.exp(S_star / (C * rho))) /
            (2 * np.sqrt(S_R - S_star)) -
            np.sqrt(S_R - S_star) * np.exp(S_star / (C * rho)) /
            (2 * C * rho *
             np.sqrt(np.exp(S_R / (C * rho)) - np.exp(S_star / (C * rho)))))
        dF_star = df_1 + df_2 + df_3 - df_4
        print('df(S*) =', dF_star)

    return dF_star
Esempio n. 16
0
    def _makePowerlawWithCutoff(self, alpha: float, kappa: float) -> Callable[[int], float]:
        '''Create a model function for a powerlaw distribution with exponential cutoff.

        :param alpha: the exponent of the distribution
        :param kappa: the degree cutoff
        :returns: a model function'''
        C = polylog(alpha, exp(-1.0 / kappa))
        def p(k: int) -> float:
            return (pow((k + 0.0), -alpha) * exp(-(k + 0.0) / kappa)) / C
        return p
Esempio n. 17
0
    def __init__(self, d, family):
        """
            Creates an Archimedean copula.
            bounds_param = 
            #x0 = Initial guess. Array of real elements of size (n,), where 'n' is the number of independent variables.
        """

        self.family = family
        self.d = d

        if family == 'AMH':
            self.bounds_param = [(0+ 1e-6, 1-1e-6)]
            self.theta_start = np.array(0.5)
            self.phit = lambda theta, t : (1-theta)/(np.exp(t)-theta)
            self.phit_inv = lambda theta, t : np.log((1-theta+theta*t)/t)
            self.phit_invp = lambda theta, t : theta/(theta*t-theta+1)
            self.phit_d = lambda theta, d, t :  ((1-theta)/theta)* float(polylog(-d,theta*np.exp(-t)).real)
        
        if family == 'clayton':
            self.bounds_param = [(0+ 1e-6, None)]
            self.theta_start = np.array(0.5)
            self.phit = lambda theta, t : (1+ t)**(-1/theta)
            self.phit_inv = lambda theta, t : (1/theta)*(t**(-theta)-1)
            self.phitp = lambda theta, t :(-1/theta)*(1+t)**(-1/theta-1)
            self.phit_d = lambda theta, d, t :  np.prod([k+(1/theta) for k in range(0,d) ])*(1+t)**(-(d+1/theta))#(gamma(d+1/theta)/gamma(1/theta) )

        if family == 'gumbel':
            self.bounds_param = [(1+ 1e-6, None)]
            self.theta_start = np.array(0.5)
            
            self.phit = lambda theta, t : 2
            self.phit_inv = lambda theta, t : 2
            self.phit_d = lambda theta, d, t,  :  2


        self.cdf = lambda theta, u : self.phit(theta, sum([self.phit_inv(theta, ui) for ui in u]))
        self.pdf = lambda theta, u : self.phit_d(theta, self.d, sum([self.phit_inv(theta, ui) for ui in u]) )  /np.prod([self.phitp(theta, self.phit_inv(theta, ui)) for ui in u])

        self.logl = lambda theta, uj : np.log( ((-1)**d) *self.phit_d(theta, self.d, sum([self.phit_inv(theta, uij) for uij in uj])) ) + sum([np.log(-self.phit_invp(theta, uij)) for uij in uj])
Esempio n. 18
0
 def central_density(self):
     return mpmath.fp.re(-1.0 / self.debroglie**3 * mpmath.polylog(3.0/2.0, -np.exp(self.beta * (self.chemical_potential))))
Esempio n. 19
0
def mpmathDilog(z):
    return mpmath.polylog(2,z)
Esempio n. 20
0
def Fermi_integral(x, j):
    r"""
    Calculate the complete Fermi-Dirac integral.

    Parameters
    ----------
    x : ~astropy.units.Quantity
        Argument of the Fermi-Dirac integral function.

    j : ~astropy.units.Quantity
        Order/index of the Fermi-Dirac integral function.

    Returns
    -------
    integral : ~astropy.units.Quantity, complex
        Complete Fermi-Dirac integral for given argument and order.

    Raises
    ------
    TypeError
        If the argument is invalid.

    ~astropy.units.UnitsError
        If the argument is a `~astropy.units.Quantity` but is not
        dimensionless.

    ValueError
        If the argument is not entirely finite.

    See also
    --------
    plasma_dispersion_func

    Notes
    -----
    The complete Fermi-Dirac integral is defined as: [1]_

    .. math::
        F_j (x) = \frac{1}{\Gamma (j+1)} \int_0^{\inf} \frac{t^j}{\exp{(t-x)} + 1} dt

    for j > 0.

    This is equivalent to the following polylogarithm [2]_ function:

    .. math::
        F_j (x) = -Li_{j+1}\left(-e^{x}\right)

    Warning: at present this function is limited to relatively small
    arguments due to limitations in the mpmath package's implementation
    of polylog.

    References
    ----------
    .. [1] https://en.wikipedia.org/wiki/Complete_Fermi-Dirac_integral
    .. [2] https://en.wikipedia.org/wiki/Polylogarithm

    Examples
    --------
    >>> Fermi_integral(0, 0)
    (0.6931471805599453-0j)
    >>> Fermi_integral(1, 0)
    (1.3132616875182228-0j)
    >>> Fermi_integral(1, 1)
    (1.8062860704447743-0j)
    """
    if isinstance(x, (int, float, complex)):
        arg = -np.exp(x)
        integral = -1 * complex(polylog(j + 1, arg))
        return integral
    elif isinstance(x, np.ndarray):
        integral_arr = np.zeros_like(x, dtype='complex')
        for idx, val in enumerate(x):
            integral_arr[idx] = -1 * complex(polylog(j + 1, -np.exp(val)))
        return integral_arr
    else:
        raise ValueError(f"Improper type {type(x)} given for argument x.")
Esempio n. 21
0
def getPolylog( n, k ):
    return polylog( n, k )
Esempio n. 22
0
 def debye_function_alalytic(self, x):
     
     return -1./5.*np.pi**4./x**4.-3./4.+3./x*np.log(1-np.exp(x))+9./x**2.*mpm.polylog(np.exp(x),2)-18./x**3.*mpm.polylog(np.exp(x),3)+18./x**4.*mpm.polylog(np.exp(x),4)