pybhpt 0.9.4__cp311-cp311-musllinux_1_2_x86_64.whl

pybhpt/metric.py

@@ -0,0 +1,327 @@
+from cybhpt_full import metric_coefficients_cython_S4dagger, metric_coefficients_cython_S0dagger
+import numpy as np
+from pybhpt.hertz import available_gauges
+from pybhpt.swsh import Yslm, spin_operator_normalization
+
+def gauge_check(gauge):
+    if gauge not in available_gauges:
+        TypeError("{} is not a supported gauge.".format(gauge))
+
+S0_gauges = ["IRG", "ARG0", "SRG0"]
+S4_gauges = ["ORG", "ARG4", "SRG4"]
+
+def metric_coefficients_S4dagger_ab(ai, bi, nt, nr, nz, nph, a, r, z):
+    """Compute the metric coefficients for the reconstructed perturbation associated with the
+    S4dagger reconstruction operator.
+    
+    Parameters
+    ----------
+    ai, bi : int
+        The indices of the tetrad-projected components of the metric perturbation.
+    nt, nr, nz, nph : int
+        The indices associated with the time, radial, spin, and azimuthal derivative operators.
+    a : float
+        The black hole spin parameter.
+    r : float
+        The radial coordinate.
+    z : float
+        The polar coordinate (cosine of the polar angle).
+    
+    Returns
+    -------
+    float
+        The computed metric coefficient."""
+    return metric_coefficients_cython_S4dagger(ai, bi, nt, nr, nz, nph, a, r, z)
+
+def metric_coefficients_S0dagger_ab(ai, bi, nt, nr, nz, nph, a, r, z):
+    """Compute the metric coefficients for the reconstructed perturbation associated with the
+    S0dagger reconstruction operator.
+    
+    Parameters
+    ----------
+    ai, bi : int
+        The indices of the tetrad-projected components of the metric perturbation.
+    nt, nr, nz, nph : int
+        The indices associated with the time, radial, spin, and azimuthal derivative operators.
+    a : float
+        The black hole spin parameter.
+    r : float
+        The radial coordinate.
+    z : float
+        The polar coordinate (cosine of the polar angle).
+    
+    Returns
+    -------
+    float
+        The computed metric coefficient."""
+    return metric_coefficients_cython_S0dagger(ai, bi, nt, nr, nz, nph, a, r, z)
+
+def metric_coefficients_S0dagger(a, b, c, d, q, rvals, zvals):
+    """Compute the metric coefficients for the reconstructed perturbation associated with the
+    S0dagger reconstruction operator.
+    
+    Parameters
+    ----------
+    a, b, c, d : int
+        The indices associated with the time, radial, spin, and azimuthal derivative operators.
+    q : float
+        The black hole spin parameter.
+    rvals : numpy.ndarray
+        The radial coordinate.
+    zvals : np.ndarray
+        The polar coordinate (cosine of the polar angle).
+    
+    Returns
+    -------
+    numpy.ndarray
+        A 3D array containing the computed metric coefficients for the S0dagger operator."""
+    h22 = np.array([[metric_coefficients_S0dagger_ab(2, 2, a, b, c, d, q, r, z) for z in zvals] for r in rvals])
+    h24 = np.array([[metric_coefficients_S0dagger_ab(2, 4, a, b, c, d, q, r, z) for z in zvals] for r in rvals])
+    h44 = np.array([[metric_coefficients_S0dagger_ab(4, 4, a, b, c, d, q, r, z) for z in zvals] for r in rvals])
+    return np.array([2.*h22, h24, h44])
+
+def metric_coefficients_S4dagger(a, b, c, d, q, rvals, zvals):
+    """Compute the metric coefficients for the reconstructed perturbation associated with the
+    S4dagger reconstruction operator.
+    
+    Parameters
+    ----------
+    a, b, c, d : int
+        The indices associated with the time, radial, spin, and azimuthal derivative operators.
+    q : float
+        The black hole spin parameter.
+    rvals : numpy.ndarray
+        The radial coordinate.
+    zvals : np.ndarray
+        The polar coordinate (cosine of the polar angle).
+    
+    Returns
+    -------
+    numpy.ndarray
+        A 3D array containing the computed metric coefficients for the S0dagger operator."""
+    h11 = np.array([[metric_coefficients_S4dagger_ab(1, 1, a, b, c, d, q, r, z) for z in zvals] for r in rvals])
+    h13 = np.array([[metric_coefficients_S4dagger_ab(1, 3, a, b, c, d, q, r, z) for z in zvals] for r in rvals])
+    h33 = np.array([[metric_coefficients_S4dagger_ab(3, 3, a, b, c, d, q, r, z) for z in zvals] for r in rvals])
+    return np.array([2.*h11, h13, h33])
+
+def metric_coefficients(gauge, a, b, c, d, q, rvals, zvals):
+    """Compute the metric coefficients for the reconstructed perturbation associated with the
+    specified gauge.
+
+    Parameters
+    ----------
+    gauge : str
+        The gauge to use for the reconstruction. Must be one of the available gauges.
+    a, b, c, d : int
+        The indices associated with the time, radial, spin, and azimuthal derivative operators.
+    q : float
+        The black hole spin parameter.
+    rvals : numpy.ndarray
+        The radial coordinate.
+    zvals : np.ndarray
+        The polar coordinate (cosine of the polar angle).
+
+    Returns
+    -------
+    numpy.ndarray
+        A 3D array containing the computed metric coefficients for the specified gauge.
+    """
+    gauge_check(gauge)
+    if gauge in S0_gauges:
+        return metric_coefficients_S0dagger(a, b, c, d, q, rvals, zvals)
+    else:
+        return metric_coefficients_S4dagger(a, b, c, d, q, rvals, zvals)
+
+class MetricCoefficients:
+    """
+    A class for computing the metric coefficients of the reconstructed perturbation
+    associated with the S0dagger or S4dagger reconstruction operator based on the specified gauge.
+
+    Parameters
+    ----------
+    gauge : str
+        The gauge to use for the reconstruction. Must be one of the available gauges.
+    q : float
+        The black hole spin parameter.
+    r : numpy.ndarray
+        The radial coordinate values.
+    th : numpy.ndarray
+        The polar coordinate values (cosine of the polar angle).
+
+    Attributes
+    ----------
+    gauge : str
+        The gauge used for the reconstruction.
+    blackholespin : float
+        The black hole spin parameter.
+    radialpoints : numpy.ndarray
+        The radial coordinate values.
+    polarpoints : numpy.ndarray
+        The polar coordinate values (cosine of the polar angle).
+    storedcomponents : dict
+        A dictionary mapping pairs of indices (a, b) to the index of the stored component
+        in the coefficients array.
+    conjugatecomponents : dict
+        A dictionary mapping pairs of indices (a, b) to the index of the conjugate component
+        in the coefficients array.
+    coeffs : numpy.ndarray
+        A 7D array containing the computed metric coefficients for the specified gauge.
+    zeros : numpy.ndarray
+        A 2D array of zeros with the same shape as the radial and polar coordinate arrays.
+
+    Methods
+    -------
+    hab(a, b, nt, nr, ns, nphi):
+        Returns the metric coefficient for the specified indices (a, b) and derivative orders
+        (nt, nr, ns, nphi). If the indices are not found in the stored or conjugate components,
+        it returns a zero array.
+    __call__(a, b, nt, nr, ns, nphi):
+        Calls the `hab` method to retrieve the metric coefficient for the specified indices
+        and derivative orders.
+    """
+    def __init__(self, gauge, q, r, th):
+        gauge_check(gauge)
+        self.gauge = gauge
+        rsamples = r.shape[0]
+        zsamples = th.shape[0]
+        self.blackholespin = q
+        self.radialpoints = r
+        self.polarpoints = th
+        if gauge in S0_gauges:
+            self.storedcomponents = {(2, 2): 0, (2, 4): 1, (4, 4): 2}
+            self.conjugatecomponents = {(2, 3): 1, (3, 3): 2}
+        else:
+            self.storedcomponents = {(1, 1): 0, (1, 3): 1, (3, 3): 2}
+            self.conjugatecomponents = {(1, 4): 1, (4, 4): 2}
+        z = np.cos(th)
+        z[np.abs(z) < 1.e-15] = 0.
+        self.coeffs = np.zeros((3, 3, 3, 3, 3, rsamples, zsamples), dtype=np.complex128)
+        self.zeros = np.zeros((rsamples, zsamples), dtype=np.complex128)
+        for ai in range(3):
+            for bi in range(3):
+                for ci in range(3):
+                    for di in range(3):
+                        self.coeffs[ai, bi, ci, di] = metric_coefficients(self.gauge, ai, bi, ci, di, q, r, z)
+
+    def hab(self, a, b, nt, nr, ns, nphi):
+        """
+        Returns the metric coefficient for the specified indices (a, b) and derivative orders
+        (nt, nr, ns, nphi). If the indices are not found in the stored or conjugate components,
+        it returns a zero array.
+
+        Parameters
+        ----------
+        a, b : int
+            The indices of the tetrad-projected components of the metric perturbation.
+        nt, nr, ns, nphi : int
+            The indices associated with the time, radial, spin, and azimuthal derivative operators.
+
+        Returns
+        -------
+        numpy.ndarray
+            The computed metric coefficient for the specified indices and derivative orders.
+        """
+        if b < a:
+            atemp = a
+            a = b
+            b = atemp
+        if (a, b) in self.storedcomponents.keys():
+            return self.coeffs[nt, nr, ns, nphi][self.storedcomponents[(a, b)]]
+        elif (a, b) in self.conjugatecomponents.keys():
+            return np.conj(self.coeffs[nt, nr, ns, nphi][self.conjugatecomponents[(a, b)]])
+        else:
+            return self.zeros
+
+    def __call__(self, a, b, nt, nr, ns, nphi):
+        """ Calls the `hab` method to retrieve the metric coefficient for the specified indices
+        and derivative orders.
+
+        Parameters
+        ----------
+        a, b : int
+            The indices of the tetrad-projected components of the metric perturbation.
+        nt, nr, ns, nphi : int
+            The indices associated with the time, radial, spin, and azimuthal derivative operators.
+
+        Returns
+        -------
+        numpy.ndarray
+            The computed metric coefficient for the specified indices and derivative orders.
+        """
+        return self.hab(a, b, nt, nr, ns, nphi)
+    
+def tetrad_project_l(a, r, z, mu):
+    if mu == 0:
+        return -1
+    elif mu == 1:
+        sigma = r**2 + a**2*z**2
+        delta = r**2 - 2.*r + a**2
+        return sigma/delta
+    elif mu == 2:
+        return 0.
+    elif mu == 3:
+        return a*(1. - z**2)
+    else:
+        return 0.
+    
+def tetrad_project_n(a, r, z, mu):
+    sigma = r**2 + a**2*z**2
+    delta = r**2 - 2.*r + a**2
+    if mu == 0:
+        return -0.5*delta/sigma
+    elif mu == 1:
+        return -0.5
+    elif mu == 2:
+        return 0.
+    elif mu == 3:
+        return 0.5*delta/sigma*a*(1. - z**2)
+    else:
+        return 0.
+    
+def tetrad_project_m(a, r, z, mu):
+    rhobar = -1./(r + 1j*a*z)
+    sigma = r**2 + a**2*z**2
+    pref = - rhobar*np.sqrt(0.5*(1. - z**2))
+    if mu == 0:
+        return -1j*pref*a
+    elif mu == 1:
+        return 0.
+    elif mu == 2:
+        return -pref*sigma/(1. - z**2)
+    elif mu == 3:
+        return 1j*pref*(r**2 + a**2)
+    else:
+        return 0.
+    
+def kinnersley_tetrad_covector(b, q, r, z, mu):
+    if b == 1:
+        return tetrad_project_l(q, r, z, mu)
+    elif b == 2:
+        return tetrad_project_n(q, r, z, mu)
+    elif b == 3:
+        return tetrad_project_m(q, r, z, mu)
+    elif b == 4:
+        return np.conj(tetrad_project_m(q, r, z, mu))
+    else:
+        return 0.
+    
+def hmunu_BL(gauge, mu, nu, q, r, hab):
+    gauge_check(gauge)
+    if gauge in S0_gauges:
+        e1mu = kinnersley_tetrad_covector(1, q, r, 0, mu)
+        e1nu = kinnersley_tetrad_covector(1, q, r, 0, nu)
+        e3mu = kinnersley_tetrad_covector(3, q, r, 0, mu)
+        e3nu = kinnersley_tetrad_covector(3, q, r, 0, nu)
+        h22 = e1mu*e1nu*hab[0]
+        h24 = -e1mu*e3nu*hab[1] - e1nu*e3mu*hab[1]
+        h44 = e3mu*e3nu*hab[2]
+        return (h22.real + 2.*h24.real + 2.*h44.real)
+    else:
+        e1mu = kinnersley_tetrad_covector(2, q, r, 0, mu)
+        e1nu = kinnersley_tetrad_covector(2, q, r, 0, nu)
+        e3mu = kinnersley_tetrad_covector(4, q, r, 0, mu)
+        e3nu = kinnersley_tetrad_covector(4, q, r, 0, nu)
+        h11 = e1mu*e1nu*hab[0]
+        h13 = -e1mu*e3nu*hab[1] - e1nu*e3mu*hab[1]
+        h33 = e3mu*e3nu*hab[2]
+        return (h11.real + 2.*h13.real + 2.*h33.real)

pybhpt/radial.py

@@ -0,0 +1,381 @@
+from cybhpt_full import RadialTeukolsky as RadialTeukolskyCython
+from cybhpt_full import available_methods as available_methods_cython
+from cybhpt_full import renormalized_angular_momentum as nu_cython
+from cybhpt_full import renormalized_angular_momentum_monodromy as nu_2_cython
+from cybhpt_full import hypergeo_2F1 as hypergeo_2F1_cython
+import numpy as np
+
+def available_methods():
+    """
+    Returns a list of available solution methods.
+    """
+    return available_methods_cython()
+
+def renormalized_angular_momentum(s, l, m, a, omega):
+    return nu_cython(s, l, m, a, omega)
+
+def renormalized_angular_momentum_monodromy(s, l, m, a, omega, la):
+    return nu_2_cython(s, l, m, a, omega, la)
+
+def hypergeo_2F1(a, b, c, x):
+    return hypergeo_2F1_cython(a, b, c, x)
+
+class RadialTeukolsky:
+    """A class for solving the homogeneous radial Teukolsky equation.
+
+    Parameters
+    ----------
+    s : int
+        The spin weight of the field
+    j : int
+        The spheroidal harmonic mode number
+    m : int
+        The azimuthal harmonic mode number
+    a : float
+        The black hole spin parameter
+    omega : float
+        The frequency of the mode
+    r : numpy.ndarray
+        A numpy array of radial points at which to evaluate the solution
+
+    Attributes
+    ----------
+    radialpoints : numpy.ndarray
+        A numpy array of radial points at which the solution is evaluated.
+    base : RadialTeukolskyCython
+        The underlying Cython object that performs the computations.
+    nsamples : int
+        The number of radial points in the radialpoints array.
+    
+    Properties
+    ----------
+    blackholespin : float
+        The black hole spin parameter.
+    spinweight : int
+        The spin weight of the field.
+    s : int
+        Alias for spinweight.
+    spheroidalmode : int
+        The spheroidal harmonic mode number.
+    j : int
+        Alias for spheroidalmode.
+    azimuthalmode : int
+        The azimuthal harmonic mode number.
+    m : int
+        Alias for azimuthalmode.
+    frequency : float
+        The frequency of the mode.
+    mode_frequency : float
+        Alias for frequency.
+    omega : float
+        Alias for frequency.
+    eigenvalue : float
+        The spheroidal eigenvalue of the radial Teukolsky equation.
+    
+    Methods
+    -------
+    solveboundarycondition(method)
+        Solves the boundary condition for the radial Teukolsky equation.
+    setboundarycondition(bc, R, Rp, r)
+        Sets the boundary condition for the radial Teukolsky equation.
+    solve(method="AUTO", bc=None)
+        Solves the radial Teukolsky equation.
+    flipspinweight()
+        Flips the spin weight of the field.
+    radialpoint(pos)
+        Returns the radial point at the given position.
+    boundarypoint(bc)
+        Returns the boundary point for the given boundary condition.
+    boundarysolution(bc)
+        Returns the solution at the boundary for the given boundary condition.
+    boundaryderivative(bc)
+        Returns the derivative at the boundary for the given boundary condition.
+    radialsolution(bc, pos)
+        Returns the solution at the radial point for the given boundary condition and position.
+    radialderivative(bc, pos)
+        Returns the derivative at the radial point for the given boundary condition and position.
+    radialderivative2(bc, pos)
+        Returns the second derivative at the radial point for the given boundary condition and position.
+    radialsolutions(bc)
+        Returns the solutions at all radial points for the given boundary condition.
+    radialderivatives(bc)
+        Returns the derivatives at all radial points for the given boundary condition.
+    radialderivatives2(bc)
+        Returns the second derivatives at all radial points for the given boundary condition.
+    __call__(bc, deriv=0)
+        Returns the solutions, first derivatives, or second derivatives at all radial points for the given boundary condition.
+        The `deriv` parameter specifies which derivative to return: 0 for solutions,
+        1 for first derivatives, and 2 for second derivatives. If `deriv` is not 0, 1, or 2, a ValueError is raised.
+    """
+    def __init__(self, s, j, m, a, omega, r):
+        if a < 0 or a > 1:
+            raise ValueError(f"Black hole spin parameter {a} must be in the range [0, 1].")
+        if j < np.abs(m):
+            raise ValueError(f"Spheroidal harmonic mode number {j} must be greater than or equal to the absolute value of azimuthal harmonic mode number {m}.")
+        if np.any(r <= 1 + np.sqrt(1 - a**2)):
+            raise ValueError(f"Radial point {r} must be greater than horizon radius r_+ = {1 + np.sqrt(1 - a**2)}.")
+        if isinstance(r, list) or (isinstance(r, np.ndarray) and r.ndim > 0):
+            self.radialpoints = np.asarray(r)
+            self.nsamples = self.radialpoints.shape[0]
+        else:
+            raise AttributeError("Radial points must be a list or a numpy array.")
+        
+        if self.nsamples == 0:
+            raise ValueError("Radial points array is empty.")
+        self.base = RadialTeukolskyCython(a, s, j, m, omega, self.radialpoints)
+
+
+    @property
+    def blackholespin(self):
+        return self.base.blackholespin
+    
+    @property
+    def spinweight(self):
+        return self.base.spinweight
+    
+    @property
+    def s(self):
+        return self.spinweight
+
+    @property
+    def spheroidalmode(self):
+        return self.base.spheroidalmode
+
+    @property
+    def j(self):
+        return self.spheroidalmode
+
+    @property
+    def azimuthalmode(self):
+        return self.base.azimuthalmode
+    
+    @property
+    def m(self):
+        return self.azimuthalmode
+
+    @property
+    def frequency(self):
+        return self.base.frequency
+    
+    @property
+    def mode_frequency(self):
+        return self.frequency
+
+    @property
+    def omega(self):
+        return self.frequency
+
+    @property
+    def eigenvalue(self):
+        return self.base.eigenvalue
+    
+    def solveboundarycondition(self, method):
+        """Solves the boundary condition for the radial Teukolsky equation.
+
+        Parameters
+        ----------
+        method : str
+            The method to use for solving the boundary condition. Default is "AUTO".
+        """
+        self.base.solve_bc(method)
+
+    def setboundarycondition(self, bc, R, Rp, r):
+        """Sets the boundary condition for the radial Teukolsky equation.
+
+        Parameters
+        ----------
+        bc : str
+            The boundary condition to set. Can be "In" for horizon or "Up" for infinity.
+        R : float
+            The boundary condition function value at the radial point.
+        Rp : float
+            The derivative of the boundary condition function at the radial point.
+        r : float
+            The radial point at which the boundary condition is defined.
+        """
+        self.base.set_bc(bc, R, Rp, r)
+
+    def solve(self, method = "AUTO", bc = None):
+        """Solves the radial Teukolsky equation.
+
+        Parameters
+        ----------
+        method : str, optional
+            The method to use for solving the equation. Default is "AUTO".
+        bc : str, optional
+            Specifies which homogeneous solutions to compute. If None, both "In" (horizon) and "Up" (infinity) solutions are computed.
+            If "In", only the horizon solution is computed. If "Up", only the infinity solution is computed.
+        """
+        if bc is None:
+            self.base.solve(method, "None")
+        else:
+            self.base.solve(method, bc)
+
+    def flipspinweight(self):
+        """Flips the sign of the spin weight of the field."""
+        self.base.flip_spinweight()
+
+    def radialpoint(self, pos):
+        """Returns the radial point at the given position.
+        Parameters
+        ----------
+        pos : float
+            The position at which to evaluate the radial point.
+        Returns
+        -------
+        float
+            The radial point at the given position.
+        """
+        return self.base.radialpoint(pos)
+    
+    def boundarypoint(self, bc):
+        """
+        Returns the boundary point for the given boundary condition.
+        Parameters
+        ----------
+        bc : str
+            The boundary condition to evaluate. Can be "In" for horizon or "Up" for infinity.
+        Returns
+        -------
+        float
+            The boundary point corresponding to the specified boundary condition.
+        """
+        return self.base.boundarypoint(bc)
+    
+    def boundarysolution(self, bc):
+        """Returns the solution at the boundary for the given boundary condition.
+        Parameters
+        ---------- 
+        bc : str
+            The boundary condition to evaluate. Can be "In" for horizon or "Up" for infinity.
+        Returns
+        -------
+        float
+            The solution at the boundary corresponding to the specified boundary condition.
+        """
+        return self.base.boundarysolution(bc)
+    
+    def boundaryderivative(self, bc):
+        """Returns the derivative at the boundary for the given boundary condition.
+        Parameters
+        ----------
+        bc : str
+            The boundary condition to evaluate. Can be "In" for horizon or "Up" for infinity.
+        Returns
+        -------
+        float
+            The derivative at the boundary corresponding to the specified boundary condition.
+        """
+        return self.base.boundaryderivative(bc)
+    
+    def radialsolution(self, bc, pos):
+        """Returns the solution at the radial point for the given homogeneous solution and position.
+        Parameters
+        ----------
+        bc : str
+            The homogeneous solution to evaluate. Can be "In" for horizon solution or "Up" for infinity solution.
+        pos : float
+            The position at which to evaluate the solution.
+        Returns
+        -------
+        float
+            The solution at the radial point corresponding to the specified boundary condition and position.
+        """
+        return self.base.solution(bc, pos)
+    
+    def radialderivative(self, bc, pos):
+        """Returns the derivative at the radial point for the given homogeneous solution and position.
+        Parameters
+        ----------
+        bc : str
+            The homogeneous solution to evaluate. Can be "In" for horizon solution or "Up" for infinity solution.
+        pos : float
+            The position at which to evaluate the solution.
+        Returns
+        -------
+        float
+            The solution at the radial point corresponding to the specified boundary condition and position.
+        """
+        return self.base.derivative(bc, pos)
+    
+    def radialderivative2(self, bc, pos):
+        """Returns the second derivative at the radial point for the given homogeneous solution and position.
+        Parameters
+        ----------
+        bc : str
+            The homogeneous solution to evaluate. Can be "In" for horizon solution or "Up" for infinity solution.
+        pos : float
+            The position at which to evaluate the solution.
+        Returns
+        -------
+        float
+            The solution at the radial point corresponding to the specified boundary condition and position.
+        """
+        return self.base.derivative2(bc, pos)
+
+    def radialsolutions(self, bc):
+        """Returns a homogeneous solution at all radial points.
+        Parameters
+        ----------
+        bc : str
+            The homogeneous solution to evaluate. Can be "In" for horizon solution or "Up" for infinity solution.
+        Returns
+        -------
+        numpy.ndarray
+            A numpy array of solutions at all radial points corresponding to the specified boundary condition.
+        """
+        return np.array([self.base.solution(bc, i) for i in range(self.nsamples)])
+    
+    def radialderivatives(self, bc):
+        """Returns the radial derivative at all radial points.
+        Parameters
+        ----------
+        bc : str
+            The homogeneous solution to evaluate. Can be "In" for horizon solution or "Up" for infinity solution.
+        Returns
+        -------
+        numpy.ndarray
+            A numpy array of solutions at all radial points corresponding to the specified boundary condition.
+        """
+        return np.array([self.base.derivative(bc, i) for i in range(self.nsamples)])
+    
+    def radialderivatives2(self, bc):
+        """Returns the second radial derivative at all radial points.
+        Parameters
+        ----------
+        bc : str
+            The homogeneous solution to evaluate. Can be "In" for horizon solution or "Up" for infinity solution.
+        Returns
+        -------
+        numpy.ndarray
+            A numpy array of solutions at all radial points corresponding to the specified boundary condition.
+        """
+        return np.array([self.base.derivative2(bc, i) for i in range(self.nsamples)])
+    
+    def __call__(self, bc, deriv = 0):
+        """Returns the solutions, first derivatives, or second derivatives at all radial points for the given boundary condition.
+
+        Parameters
+        ----------
+        bc : str
+            The homogeneous solution to evaluate. Can be "In" for horizon solution or "Up" for infinity solution.
+        deriv : int, optional
+            Specifies which derivative to return: 0 for solutions, 1 for first derivatives, and 2 for second derivatives.
+            Default is 0 (solutions).
+        Returns
+        -------
+        numpy.ndarray
+            A numpy array of solutions, first derivatives, or second derivatives at all radial points corresponding to the specified boundary condition.
+        Raises
+        ------
+        ValueError
+            If `deriv` is not 0, 1, or 2.
+        """ 
+        if deriv == 0:
+            return self.radialsolutions(bc)
+        elif deriv == 1:
+            return self.radialderivatives(bc)
+        elif deriv == 2:
+            return self.radialderivatives2(bc)
+        else:
+            raise ValueError("RadialTeukolsky only solves up to the second derivative")