pybhpt 0.9.4__cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

pybhpt/redshift.py

@@ -0,0 +1,20 @@
+from cybhpt_full import RedshiftCoefficients as RedshiftCoefficientsCython
+from cybhpt_full import SphericalHarmonicCoupling as SphericalHarmonicCouplingCython
+
+class RedshiftCoefficients:
+    def __init__(self, gauge, geo):
+        self.base = RedshiftCoefficientsCython(gauge, geo.base)
+
+    def __call__(self, Ni, ai, bi, ci, di, jr = 0, jz = 0):
+        return self.base(Ni, ai, bi, ci, di, jr, jz)
+    
+class SphericalHarmonicCoupling:
+    def __init__(self, lmax, m):
+        self.base = SphericalHarmonicCouplingCython(lmax, m)
+        self.azimuthalmode = self.base.azimuthalmode
+
+    def zcouplingcoefficient(self, n, i, l):
+        return self.base.zcouplingcoefficient(n, i, l)
+
+    def dzcouplingcoefficient(self, n, i, l):
+        return self.base.dzcouplingcoefficient(n, i, l)

pybhpt/swsh.py

@@ -0,0 +1,347 @@
+import scipy.sparse
+import scipy.sparse.linalg
+from scipy.special import sph_harm
+from scipy.special import binom
+from scipy.special import factorial
+import numpy as np
+
+"""
+Wigner 3j-symbol and Clebsch-Gordon coefficients
+"""
+
+def fac(n):
+    if n < 0:
+        return 0
+    return float(np.math.factorial(n))
+
+def Yslm(s, l, m, th):
+    if np.abs(s) > l:
+        return 0.*th
+    if s == 0:
+        return np.real(sph_harm(m, l, 0., th))
+    elif s + m < 0:
+        return (-1.)**(s+m)*YslmBase(-s, l, -m, np.cos(th))
+#     elif th > np.pi/2.:
+#         return (-1.)**(l + m)*YslmBase(-s, l, m, -np.cos(th))
+    else:
+        return YslmBase(s, l, m, np.cos(th))
+
+def YslmBase(s, l, m, z):
+    rmax = l - s
+    pref = (0.5)**(l)*(-1.)**m*np.sqrt(factorial(l+m)/factorial(l+s)*factorial(l-m)/factorial(l-s)*(2*l+1)/(4.*np.pi))*np.sqrt(1. - z)**(s + m)*np.sqrt(1. + z)**(s - m)
+    
+    yslm = 0.*pref
+    for r in range(0, rmax + 1):
+        yslm += binom(l - s, r)*binom(l + s, r + s - m)*(z - 1.)**(rmax - r)*(z + 1.)**(r)
+    
+    return pref*yslm
+
+def clebsch(l1, l2, l3, m1, m2, m3):
+    return (-1)**(l1 - l2 + m3)*np.sqrt(2*l3 + 1)*w3j(l1, l2, l3, m1, m2, -m3);
+
+def w3j(l1, l2, l3, m1, m2, m3):
+    if m1 + m2 + m3 != 0:
+        return 0
+    elif abs(l1 - l2) > l3:
+        return 0
+    elif l1 + l2 < l3:
+        return 0
+    
+    if abs(m1) > l1:
+        return 0
+    elif abs(m2) > l2:
+        return 0
+    elif abs(m3) > l3:
+        return 0
+    
+    sumTerm = w3j_tsum(l1, l2, l3, m1, m2, m3)
+    if sumTerm == 0:
+        return 0
+    sumSign = np.sign(sumTerm)
+    tempLog = 0.5*(np.log(fac(l1 + m1)) + np.log(fac(l2 + m2)) + np.log(fac(l3 + m3)))
+    tempLog += 0.5*(np.log(fac(l1 - m1)) + np.log(fac(l2 - m2)) + np.log(fac(l3 - m3)))
+    tempLog += np.log(triangle_coeff(l1, l2, l3))
+    tempLog += np.log(abs(sumTerm))
+    
+    temp = sumSign*np.exp(tempLog)
+    temp *= (-1)**(l1-l2-m3)
+    
+    return temp
+    
+def w3j_tsum(l1, l2, l3, m1, m2, m3):
+    t_min_num = w3j_t_min(l1, l2, l3, m1, m2, m3)
+    t_max_num = w3j_t_max(l1, l2, l3, m1, m2, m3)
+    x = 0
+    if t_max_num < t_min_num:
+        t_max_num = t_min_num
+
+    for t in range(t_min_num - 1, t_max_num + 2):
+        term = (fac(t)*fac(l3 - l2 + m1 + t)*fac(l3 - l1 - m2 + t)
+            *fac(l1 + l2 - l3 - t)*fac(l1 - t - m1)*fac(l2 - t + m2))
+        if term > 0:
+            x += (-1)**t/term
+    
+    return x
+
+def w3j_t_min(l1, l2, l3, m1, m2, m3):
+    temp = 0
+    
+    comp = l3 - l2 + m1
+    if temp + comp < 0:
+        temp = -comp
+    comp = l3 - l1 - m2
+    if temp + comp < 0:
+        temp = -comp
+        
+    return temp
+
+def w3j_t_max(l1, l2, l3, m1, m2, m3):
+    temp = 1
+    comp = l1 + l2 - l3
+    if comp - temp > 0:
+        temp = comp
+    comp = l1 - m1
+    if comp - temp > 0:
+        temp = comp
+    comp = l2 + m2
+    if comp - temp > 0:
+        temp = comp
+        
+    return temp;
+
+def triangle_coeff(l1, l2, l3):
+    return np.sqrt(fac(l1 + l2 - l3)*fac(l3 + l1 - l2)*fac(l2 + l3 - l1)/fac(l1 + l2 + l3 + 1))
+
+"""
+SWSH Eigenvalue Functions
+"""
+
+def k1(s, l, j, m):
+    return np.sqrt((2*l + 1)/(2*j + 1))*clebsch(l, 1, j, m, 0, m)*clebsch(l, 1, j, -s, 0, -s);
+
+def k2(s, l, j, m):
+    ktemp = 2./3.*np.sqrt((2*l + 1)/(2*j + 1))*clebsch(l, 2, j, m, 0, m)*clebsch(l, 2, j, -s, 0, -s);
+    if j == l:
+        ktemp += 1/3.
+    return ktemp
+
+def k2m2(s, l, m):
+    temp = (l - m - 1.)/(l - 1.)
+    temp *= (l + m - 1.)/(l - 1.)
+    temp *= np.float64(l - m)/l
+    temp *= np.float64(l + m)/l
+    temp *= (l - s)/(2.*l - 1.)
+    temp *= (l + s)/(2.*l - 1.)
+    temp *= (l - s - 1.)/(2.*l + 1.)
+    temp *= (l + s - 1.)/(2.*l - 3.)
+    return np.sqrt(temp)
+
+def k2m1(s, l, m):
+    temp = np.float64(l - m)*np.float64(l + m)/(2.*l - 1.)
+    temp *= np.float64(l - s)*np.float64(l + s)/(2.*l + 1.)
+    return -2.*m*s*np.sqrt(temp)/l/(l - 1.)/(l + 1.)
+
+def k2p0(s, l, m):
+    temp = np.float64(l*(l + 1.) - 3.*m*m)/(2.*l - 1.)/l
+    temp *= np.float64(l*(l + 1.) - 3.*s*s)/(2.*l + 3.)/(l + 1.)
+    return 1./3.*(1. + 2.*temp)
+
+def k2p1(s, l, m):
+    temp = np.float64(l - m + 1.)*np.float64(l + m + 1.)/(2.*l + 1.)
+    temp *= np.float64(l - s + 1.)*np.float64(l + s + 1.)/(2.*l + 3.)
+    return -2.*m*s*np.sqrt(temp)/l/(l + 1.)/(l + 2.)
+
+def k2p2(s, l, m):
+    temp = (l - m + 1.)/(l + 1.)
+    temp *= (l + m + 1.)/(l + 1.)
+    temp *= (l - m + 2.)/(l + 2.)
+    temp *= (l + m + 2.)/(l + 2.)
+    temp *= (l - s + 2.)/(2.*l + 3.)
+    temp *= (l + s + 2.)/(2.*l + 3.)
+    temp *= (l - s + 1.)/(2.*l + 1.)
+    temp *= (l + s + 1.)/(2.*l + 5.)
+    return np.sqrt(temp)
+
+def k1m1(s, l, m):
+    temp = np.float64(l - m)*np.float64(l + m)/(2.*l - 1.)
+    temp *= np.float64(l - s)*np.float64(l + s)/(2.*l + 1.)
+    return np.sqrt(temp)/l
+
+def k1p0(s, l, m):
+    return -np.float64(m*s)/l/(l + 1.)
+
+def k1p1(s, l, m):
+    temp = np.float64(l - m + 1.)*np.float64(l + m + 1.)/(2.*l + 3.)
+    temp *= np.float64(l - s + 1.)*np.float64(l + s + 1.)/(2.*l + 1.)
+    return np.sqrt(temp)/(l + 1.)
+
+def akm2(s, l, m, g):
+    return -g*g*k2m2(s, l, m)
+
+def akm1(s, l, m, g):
+    return -g*g*k2m1(s, l, m) + 2.*s*g*k1m1(s, l, m)
+
+def akp0(s, l, m, g):
+    return -g*g*k2p0(s, l, m) + 2.*s*g*k1p0(s, l, m) + l*(l + 1.) - s*(s + 1.) - 2.*m*g + g*g
+
+def akp1(s, l, m, g):
+    return -g*g*k2p1(s, l, m) + 2.*s*g*k1p1(s, l, m)
+
+def akp2(s, l, m, g):
+    return -g*g*k2p2(s, l, m)
+
+def spectral_sparse_matrix(s, m, g, nmax):
+    lmin = max(abs(s), abs(m))
+    larray = np.arange(lmin, lmin + nmax)
+    return scipy.sparse.diags([akm2(s, larray[2:], m, g), akm1(s, larray[1:], m, g), akp0(s, larray, m, g), akp1(s, larray[:-1], m, g), akp2(s, larray[:-2], m, g)], [-2, -1, 0, 1, 2])
+
+def swsh_eigs(s, l, m, g, nmax=None, return_eigenvectors=True):
+    lmin = max(abs(s), abs(m))
+    kval = l - lmin
+    
+    if nmax is None:
+        buffer = round(20 + 2*g)
+        Nmax = kval + buffer + 2
+    else:
+        if nmax < kval:
+            Nmax = kval + 5
+        else:
+            Nmax = nmax
+    
+    mat = spectral_sparse_matrix(s, m, g, Nmax)
+    out = scipy.sparse.linalg.eigs(mat, k=Nmax-2, which='SM', return_eigenvectors=return_eigenvectors)
+    
+    return out
+
+def Yslm_eigenvalue(s, l, *args):
+    return l*(l + 1.) - s*(s + 1.)
+
+def swsh_eigenvalue(s, l, m, g, nmax=None):
+    if g == 0.:
+        return Yslm_eigenvalue(s, l)
+    
+    las = swsh_eigs(s, l, m, g, nmax=nmax, return_eigenvectors=False)
+    
+    return np.real(las[::-1][l - max(abs(s), abs(m))])
+
+def swsh_coeffs(s, l, m, g, th):
+    if g == 0.:
+        return Yslm(s, l, m, th)
+    
+    _, eig = swsh_eigs(s, l, m, g, nmax=None, return_eigenvectors=True)
+    coeffs = np.real(eig[l - max(abs(s), abs(m))])
+    
+    return np.real(eig[l - max(abs(s), abs(m))])
+        
+class SWSHBase:
+    def __init__(self, *args):
+        arg_num = np.array(args).shape[0]
+        if arg_num < 3:
+            print('Error. Not enough arguments to create class')
+            pass
+        
+        self.s = args[0]
+        self.l = args[1]
+        self.m = args[2]
+        self.lmin = max(abs(self.s), abs(self.m))
+
+        if arg_num > 3:
+            self.spheroidicity = args[3]
+            
+class SWSHSeriesBase(SWSHBase):
+    def __init__(self, s, l, m, g):
+        SWSHBase.__init__(self, s, l, m, g)
+        
+    def sparse_matrix(self, nmax):
+        return spectral_sparse_matrix(self.s, self.m, self.spheroidicity, nmax)
+        
+    def eigs(self, nmax = None, **kwargs):
+        kval = self.l - self.lmin
+    
+        if nmax is None:
+            buffer = round(20 + 2*self.spheroidicity)
+            Nmax = kval + buffer + 2
+        else:
+            if nmax < kval:
+                Nmax = kval + 5
+            else:
+                Nmax = nmax
+                
+        if "k" not in kwargs.keys():
+            kwargs["k"] = Nmax - 2
+                
+        if "which" not in kwargs.keys():
+            kwargs["which"] = 'SM'
+            
+#         if "sigma" not in kwargs.keys():
+#             kwargs["sigma"] = (self.l + Nmax)*(self.l + Nmax + 1) - self.s*(self.s + 1)
+            
+        if "return_eigenvectors" not in kwargs.keys():
+            kwargs["return_eigenvectors"] = True
+            
+        mat = self.sparse_matrix(Nmax)
+        return scipy.sparse.linalg.eigs(mat, **kwargs)
+    
+    def generate_eigenvalue(self):
+        las = np.real(self.eigs(return_eigenvectors=False))
+        pos = np.argsort(las)[self.l - self.lmin]
+        return las[pos]
+    
+    def generate_eigs(self):
+        las, eigs = self.eigs()
+        pos = np.argsort(np.real(las))[self.l - self.lmin]
+        eigs_temp = np.real(eigs[:, pos])
+        eigs_return = np.sign(eigs_temp[self.l - self.lmin])*eigs_temp
+        return (np.real(las[pos]), eigs_return)
+    
+class SWSH(SWSHSeriesBase):
+    def __init__(self, s, l, m, g):
+        SWSHSeriesBase.__init__(self, s, l, m, g)
+        if self.spheroidicity == 0.:
+            self.eval = self.Yslm
+            self.eigenvalue = Yslm_eigenvalue(self.s, self.l)
+            self.coeffs = np.zeros(self.l - self.lmin)
+            self.coeffs[-1] = 1.
+        else:
+            self.eval = self.Sslm
+            self.eigenvalue, self.coeffs = self.generate_eigs()
+            
+    def Yslm(self, l, th):
+        return Yslm(self.s, l, self.m, th)
+    
+    def Sslm(self, *args):
+        th = args[-1]
+        term_num = self.coeffs.shape[0]
+        pts_num = th.shape[0]
+        Yslm_array = np.empty((term_num, pts_num))
+        for i in range(term_num):
+            Yslm_array[i] = self.Yslm(self.lmin + i, th)
+            
+        return np.dot(self.coeffs, Yslm_array)
+            
+    def __call__(self, th):
+        return self.eval(self.l, th)
+    
+def muCoupling(s, l):
+    """
+    Eigenvalue for the spin-weighted spherical harmonic lowering operator
+    Setting s -> -s gives the negative of the eigenvalue for the raising operator
+    """
+    if l + s < 0 or l - s + 1. < 0:
+        return 0
+    return np.sqrt((l - s + 1.)*(l + s))
+
+def Asjlm(s, j, l, m):
+    if s >= 0:
+        return (-1.)**(m + s)*np.sqrt(4**s*fac(s)**2*(2*l + 1)*(2*j + 1)/fac(2*s))*w3j(s, l, j, 0, m, -m)*w3j(s, l, j, s, -s, 0)
+    else:
+        return (-1.)**(m)*np.sqrt(4**(-s)*fac(-s)**2*(2*l + 1)*(2*j + 1)/fac(-2*s))*w3j(-s, l, j, 0, m, -m)*w3j(-s, l, j, s, -s, 0)
+
+def spin_operator_normalization(s, ns, l):
+    s_sgn = np.sign(s)
+    nmax1 = np.abs(s) + 1
+    Jterm = 1.
+    for ni in range(1, ns + 1):
+        Jterm *= -s_sgn*muCoupling((nmax1-ni), l)
+    return Jterm
+        

pybhpt/teuk.py

@@ -0,0 +1,245 @@
+from cybhpt_full import TeukolskyMode as TeukolskyModeCython
+
+class TeukolskyMode:
+    """A class for computing Teukolsky modes sourced by a point-particle orbiting in a Kerr background.
+    
+    Parameters
+    ----------
+    s : int
+        The spin weight of the Teukolsky mode.
+    j : int
+        The spheroidal harmonic mode number.
+    m : int
+        The azimuthal harmonic mode number.
+    k : int
+        The polar harmonic mode number.
+    n : int
+        The radial harmonic mode number.
+    geo : KerrGeodesic class instance
+        KerrGeodesic object containing the background motion of the point-particle source.
+    auto_solve : bool, optional
+        If True, the Teukolsky equation is automatically solved upon initialization. Default is False
+
+    Attributes
+    ----------
+    spinweight : int
+        The spin weight of the Teukolsky mode.
+    spheroidalmode : int
+        The spheroidal harmonic mode number.
+    azimuthalmode : int
+        The azimuthal harmonic mode number.
+    radialmode : int
+        The radial harmonic mode number.
+    polarmode : int
+        The polar harmonic mode number.
+    blackholespin : float
+        The spin of the black hole in the Kerr background.
+    frequency : float
+        The frequency of the Teukolsky mode.
+    horizonfrequency : float
+        The frequency of the mode at the horizon.
+    eigenvalue : float
+        The spheroidal eigenvalue of the Teukolsky mode.
+    mincouplingmode : int
+        The minimum l-mode used for coupling the spherical and spheroidal harmonics
+    maxcouplingmode : int
+        The maximum l-mode used for coupling the spherical and spheroidal harmonics
+    j : int
+        Alias for spheroidalmode.
+    m : int
+        Alias for azimuthalmode.
+    k : int
+        Alias for polarmode.
+    n : int
+        Alias for radialmode.
+    omega : float
+        Alias for frequency.
+    a : float
+        Alias for blackholespin.
+    
+    Methods
+    -------
+    solve(geo, method = "AUTO", nsamples = 256, teuk = None, swsh = None)
+        Solve the Teukolsky equation for the given mode and geodesic.
+    flipspinweight()
+        Flip the spin weight of the Teukolsky mode.
+    flipspinweightandfrequency()
+        Flip the spin weight and frequency of the Teukolsky mode.
+    couplingcoefficient(l)
+        Compute the coupling coefficient for the given l-mode.
+    radialpoint(pos)
+        Compute the radial point for the given position.
+    radialsolution(bc, pos)
+        Compute the radial solution for the given boundary condition and position.
+    radialderivative(bc, pos)
+        Compute the radial derivative for the given boundary condition and position.
+    radialderivative2(bc, pos)
+        Compute the second radial derivative for the given boundary condition and position.
+    homogeneousradialsolution(bc, pos)
+        Compute the homogeneous radial solution for the given boundary condition and position.
+    homogeneousradialderivative(bc, pos)
+        Compute the homogeneous radial derivative for the given boundary condition and position.
+    homogeneousradialderivative2(bc, pos)
+        Compute the second homogeneous radial derivative for the given boundary condition and position.
+    polarpoint(pos)
+        Compute the polar point for the given position.
+    polarsolution(pos)
+        Compute the polar solution for the given position.
+    polarderivative(pos)
+        Compute the polar derivative for the given position.
+    polarderivative2(pos)
+        Compute the second polar derivative for the given position.
+    amplitude(bc)
+        Compute the Teukolsky amplitude for the given boundary condition.
+    precision(bc)
+        Compute the precision of the Teukolsky amplitude for the given boundary condition.
+    """
+    def __init__(self, s, j, m, k, n, geo, auto_solve = False):
+        self.base = TeukolskyModeCython(s, j, m, k, n, geo.base)
+        if auto_solve:
+            self.solve(geo)
+
+    @property
+    def spinweight(self):
+        return self.base.spinweight
+
+    @property
+    def spheroidalmode(self):
+        return self.base.spheroidalmode
+    
+    @property
+    def azimuthalmode(self):
+        return self.base.azimuthalmode
+
+    @property
+    def radialmode(self):
+        return self.base.radialmode
+
+    @property
+    def polarmode(self):
+        return self.base.polarmode
+
+    @property
+    def blackholespin(self):
+        return self.base.blackholespin
+    
+    @property
+    def frequency(self):
+        return self.base.frequency
+
+    @property
+    def horizonfrequency(self):
+        return self.base.horizonfrequency
+
+    @property
+    def eigenvalue(self):
+        return self.base.eigenvalue
+
+    @property
+    def mincouplingmode(self):
+        return self.base.mincouplingmode
+    
+    @property
+    def maxcouplingmode(self):
+        return self.base.maxcouplingmode
+
+    # some useful aliases
+    @property
+    def j(self):
+        return self.spheroidalmode
+    @property
+    def m(self):
+        return self.azimuthalmode
+    @property
+    def k(self):
+        return self.polarmode
+    @property
+    def n(self):
+        return self.radialmode
+    @property
+    def omega(self):
+        return self.frequency
+    @property
+    def a(self):
+        return self.blackholespin
+    
+    def solve(self, geo, method = "AUTO", nsamples = 256, teuk = None, swsh = None):
+        """Solve the Teukolsky equation for the given mode and geodesic.
+        Parameters
+        ----------
+        geo : KerrGeodesic class instance
+            KerrGeodesic object containing the background motion of the point-particle source.
+        method : str, optional
+            The method to use for solving the Teukolsky equation. Default is "AUTO".
+        nsamples : int, optional
+            The number of samples to use for the solution. Default is 256.
+        teuk : RadialTeukolsky, optional
+            RadialTeukolsky object to use for constructing the radial Green function. Default is None.
+        swsh : SpheroidalHarmonicMode, optional
+            SpheroidalHarmonic object to use for coupling with spheroidal harmonics. Default is None.
+
+        """
+        if teuk is None or swsh is None:
+            self.base.solve(geo.base, method, nsamples)
+        else:
+            self.base.solve(geo.base, method, nsamples, teuk.base, swsh.base)
+
+    """
+    Flips the spin-weight of the Teukolsky solutions from :math:`s \rightarrow -s`
+    """
+    def flipspinweight(self):
+        self.base.flip_spinweight()
+
+    """
+    Flips the spin-weight and frequency of the Teukolsky solutions from :math:`s \rightarrow -s` and :math:`\omega \rightarrow -\omega`
+    """
+    def flipspinweightandfrequency(self):
+        self.base.flip_spinweight_frequency()
+
+    """
+    Spherical-spheroidal mixing coefficient between a spherical harmonic :math:`l` mode with a spheroidal :math:`j` mode
+
+    :param l: spherical harmonic mode
+    :type l: int
+    """
+    def couplingcoefficient(self, l):
+        return self.base.couplingcoefficient(l)
+
+    def radialpoint(self, pos):
+        return self.base.radialpoint(pos)
+    
+    def radialsolution(self, bc, pos):
+        return self.base.radialsolution(bc, pos)
+    
+    def radialderivative(self, bc, pos):
+        return self.base.radialderivative(bc, pos)
+    
+    def radialderivative2(self, bc, pos):
+        return self.base.radialderivative2(bc, pos)
+    
+    def homogeneousradialsolution(self, bc, pos):
+        return self.base.homogeneousradialsolution(bc, pos)
+    
+    def homogeneousradialderivative(self, bc, pos):
+        return self.base.homogeneousradialderivative(bc, pos)
+    
+    def homogeneousradialderivative2(self, bc, pos):
+        return self.base.homogeneousradialderivative2(bc, pos)
+    
+    def polarpoint(self, pos):
+        return self.base.polarpoint(pos)
+    
+    def polarsolution(self, pos):
+        return self.base.polarsolution(pos)
+    
+    def polarderivative(self, pos):
+        return self.base.polarderivative(pos)
+    
+    def polarderivative2(self, pos):
+        return self.base.polarderivative2(pos)
+    
+    def amplitude(self, bc):
+        return self.base.teukolsky_amplitude(bc)
+    
+    def precision(self, bc):
+        return self.base.teukolsky_amplitude_precision(bc)