pybhpt 0.9.4__tar.gz → 0.9.8__tar.gz

pybhpt-0.9.8/.readthedocs.yml

@@ -0,0 +1,13 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.9"
+
+python:
+  install:
+    - requirements: docs/requirements.txt
+
+sphinx:
+  configuration: docs/conf.py

{pybhpt-0.9.4 → pybhpt-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pybhpt
-Version: 0.9.4
+Version: 0.9.8
 Summary: Black Hole Perturbation Theory and Self-Force Algorithms in Python
 Author-Email: Zach Nasipak <znasipak@gmail.com>
 License: GPL
@@ -30,11 +30,11 @@ Description-Content-Type: text/markdown
 
 # pybhpt
 
-A python package for solving problems in black hole perturbation theory
+A python package for solving problems in black hole perturbation theory. 
 
 `pybhpt` is a collection of numerical tools for analyzing perturbations of Kerr spacetime, particularly the self-forces and metric-perturbations experienced by small bodies moving in a Kerr background. Subpackages include: 
 
-- `pybhpt.geodesic`: a module that generates bound timelike geodesics in Kerr spacetime
+- `pybhpt.geodesic`: a module that generates bound periodic timelike geodesics in Kerr spacetime
 - `pybhpt.radial`: a module that calculates homogeneous solutions of the radial Teukolsky equation
 - `pybhpt.swsh`: a module that constructs the spin-weighted spheroidal harmonics
 - `pybhpt.teuk`: a module that evaluates the inhomogeneous solutions (Teukolsky amplitudes) of the radial Teukolsky equation due to a point-particle on a bound timelike Kerr geodesic
@@ -43,9 +43,11 @@ A python package for solving problems in black hole perturbation theory
 - `pybhpt.metric`: a module that produces the coefficients needed to reconstruct the metric from the Hertz potentials
 - `pybhpt.redshift`: a module that computes the generalized Detweiler redshift invariant in a variety of gauges
 
+See the [Documentation](https://pybhpt.readthedocs.io/en/latest/) pages for more information about the package, including User Guides and API. References and author information can be found at the bottom of the README.
+
 ## Quick Installation
 
-Tagged releases of `pybhpt` are available as wheel packages for macOS and 64-bit Linux on [PyPI](https://pypi.org/project/matplotlib/). Install using `pip`:
+Tagged releases of `pybhpt` are available as wheel packages for macOS and 64-bit Linux on [PyPI](https://pypi.org/project/pybhpt). Install using `pip`:
 ```
 python3 -m pip install pybhpt
 ```
@@ -130,6 +132,14 @@ To include the necessary compiler on Linux:
 conda install gcc_linux-64 gxx_linux-64
 ```
 
+## References
+
+Theoretical background for the code and explanations of the numerical methods used within are summarized in the references below: 
+
+- Z. Nasipak, *Metric reconstruction and the Hamiltonian for eccentric, precessing binaries in the small-mass-ratio limit* (2025) [arXiv:2507.07746](https://arxiv.org/abs/2507.07746)
+- Z. Nasipak, *An adiabatic gravitational waveform model for compact objects undergoing quasi-circular inspirals into rotating massive black holes*, Phys. Rev. D 109, 044020 (2024) [arXiv:2310.19706](https://arxiv.org/abs/2310.19706)
+- Z. Nasipak, *Adiabatic evolution due to the conservative scalar self-force during orbital resonances*, Phys. Rev. D 106, 064042 (2022) [arXiv:2207.02224](https://arxiv.org/abs/2207.02224)
+
 ## Authors
 
 Zachary Nasipak

{pybhpt-0.9.4 → pybhpt-0.9.8}/README.md

@@ -1,10 +1,10 @@
 # pybhpt
 
-A python package for solving problems in black hole perturbation theory
+A python package for solving problems in black hole perturbation theory. 
 
 `pybhpt` is a collection of numerical tools for analyzing perturbations of Kerr spacetime, particularly the self-forces and metric-perturbations experienced by small bodies moving in a Kerr background. Subpackages include: 
 
-- `pybhpt.geodesic`: a module that generates bound timelike geodesics in Kerr spacetime
+- `pybhpt.geodesic`: a module that generates bound periodic timelike geodesics in Kerr spacetime
 - `pybhpt.radial`: a module that calculates homogeneous solutions of the radial Teukolsky equation
 - `pybhpt.swsh`: a module that constructs the spin-weighted spheroidal harmonics
 - `pybhpt.teuk`: a module that evaluates the inhomogeneous solutions (Teukolsky amplitudes) of the radial Teukolsky equation due to a point-particle on a bound timelike Kerr geodesic
@@ -13,9 +13,11 @@ A python package for solving problems in black hole perturbation theory
 - `pybhpt.metric`: a module that produces the coefficients needed to reconstruct the metric from the Hertz potentials
 - `pybhpt.redshift`: a module that computes the generalized Detweiler redshift invariant in a variety of gauges
 
+See the [Documentation](https://pybhpt.readthedocs.io/en/latest/) pages for more information about the package, including User Guides and API. References and author information can be found at the bottom of the README.
+
 ## Quick Installation
 
-Tagged releases of `pybhpt` are available as wheel packages for macOS and 64-bit Linux on [PyPI](https://pypi.org/project/matplotlib/). Install using `pip`:
+Tagged releases of `pybhpt` are available as wheel packages for macOS and 64-bit Linux on [PyPI](https://pypi.org/project/pybhpt). Install using `pip`:
 ```
 python3 -m pip install pybhpt
 ```
@@ -100,6 +102,14 @@ To include the necessary compiler on Linux:
 conda install gcc_linux-64 gxx_linux-64
 ```
 
+## References
+
+Theoretical background for the code and explanations of the numerical methods used within are summarized in the references below: 
+
+- Z. Nasipak, *Metric reconstruction and the Hamiltonian for eccentric, precessing binaries in the small-mass-ratio limit* (2025) [arXiv:2507.07746](https://arxiv.org/abs/2507.07746)
+- Z. Nasipak, *An adiabatic gravitational waveform model for compact objects undergoing quasi-circular inspirals into rotating massive black holes*, Phys. Rev. D 109, 044020 (2024) [arXiv:2310.19706](https://arxiv.org/abs/2310.19706)
+- Z. Nasipak, *Adiabatic evolution due to the conservative scalar self-force during orbital resonances*, Phys. Rev. D 106, 064042 (2022) [arXiv:2207.02224](https://arxiv.org/abs/2207.02224)
+
 ## Authors
 
 Zachary Nasipak

{pybhpt-0.9.4 → pybhpt-0.9.8}/build_gsl.sh

@@ -12,12 +12,15 @@ else
     CORES=$(sysctl -n hw.ncpu)
 fi
 
-# Download source
+# Download source (use mirror redirector + retries)
 mkdir -p /tmp/gsl-src
 cd /tmp/gsl-src
-curl -LO https://ftp.gnu.org/gnu/gsl/gsl-${GSL_VERSION}.tar.gz
-tar -xzf gsl-${GSL_VERSION}.tar.gz
-cd gsl-${GSL_VERSION}
+curl --fail --location --retry 5 --retry-delay 5 \
+    "https://ftpmirror.gnu.org/gsl/gsl-${GSL_VERSION}.tar.gz" \
+    -o "gsl-${GSL_VERSION}.tar.gz"
+
+tar -xzf "gsl-${GSL_VERSION}.tar.gz"
+cd "gsl-${GSL_VERSION}"
 
 # Build & install
 echo "Configuring GSL ${GSL_VERSION}..."

{pybhpt-0.9.4 → pybhpt-0.9.8}/cpp/include/geo.hpp

@@ -97,11 +97,17 @@ public:
 	double getPolarPosition(int pos);
 	double getAzimuthalAccumulation(int j, int pos);
 
+	double getPsiRadialOfMinoTime(double lambda);
+	double getPsiPolarOfMinoTime(double lambda);
+
 	double getTimePositionOfMinoTime(double lambda);
 	double getRadialPositionOfMinoTime(double lambda);
 	double getPolarPositionOfMinoTime(double lambda);
 	double getAzimuthalPositionOfMinoTime(double lambda);
 
+	Vector getPsiRadialOfMinoTime(Vector lambda);
+	Vector getPsiPolarOfMinoTime(Vector lambda);
+
 	Vector getTimePositionOfMinoTime(Vector lambda);
 	Vector getRadialPositionOfMinoTime(Vector lambda);
 	Vector getPolarPositionOfMinoTime(Vector lambda);

{pybhpt-0.9.4 → pybhpt-0.9.8}/cpp/include/swsh.hpp

@@ -86,7 +86,6 @@ int spectral_matrix(const int &s, const int &lmin, const int &m, const double &g
 int spectral_matrix_sparse_init(const int &s, const int &lmin, const int &m, const double &g, gsl_spmatrix* mat);
 int spectral_matrix_sparse(const int &s, const int &lmin, const int &m, const double &g, gsl_spmatrix* mat, const size_t &nmax);
 
-
 // Solve eigensystem of spectral matrix
 int spectral_solver(const int &s, const int &l, const int &m, const double &g, double& la, Vector& bvec);
 

{pybhpt-0.9.4 → pybhpt-0.9.8}/cpp/src/geo.cpp

@@ -329,6 +329,12 @@ double GeodesicSource::getAzimuthalAccumulation(int j, int pos){
 	}
 }
 
+double GeodesicSource::getPsiRadialOfMinoTime(double lambda){
+	return kepler_phase_of_angle(lambda*_geoConstants.upsilonR, _geoCoefficients.r);
+}
+double GeodesicSource::getPsiPolarOfMinoTime(double lambda){
+	return kepler_phase_of_angle(lambda*_geoConstants.upsilonTheta, _geoCoefficients.theta);
+}
 double GeodesicSource::getTimePositionOfMinoTime(double lambda){
 	return lambda*_geoConstants.upsilonT + phip_of_angle(lambda*_geoConstants.upsilonR, _geoCoefficients.tR) + phip_of_angle(lambda*_geoConstants.upsilonTheta, _geoCoefficients.tTheta);
 }
@@ -350,6 +356,22 @@ Vector GeodesicSource::getPositionOfMinoTime(double lambda){
 	return xp;
 }
 
+Vector GeodesicSource::getPsiRadialOfMinoTime(Vector lambda){
+	Vector xp(lambda.size());
+	for(size_t i = 0; i < xp.size(); i++){
+		xp[i] = getPsiRadialOfMinoTime(lambda[i]);
+	}
+	return xp;
+}
+
+Vector GeodesicSource::getPsiPolarOfMinoTime(Vector lambda){
+	Vector xp(lambda.size());
+	for(size_t i = 0; i < xp.size(); i++){
+		xp[i] = getPsiPolarOfMinoTime(lambda[i]);
+	}
+	return xp;
+}
+
 Vector GeodesicSource::getTimePositionOfMinoTime(Vector lambda){
 	Vector xp(lambda.size());
 	for(size_t i = 0; i < xp.size(); i++){

{pybhpt-0.9.4 → pybhpt-0.9.8}/cpp/src/metriccoeffs.cpp

@@ -3217,7 +3217,7 @@ ComplexMatrix tetrad_velocity_radial(Complex (*subfunc)(double, double, double,
   for(size_t jr = 1; jr < r.size() - 1; jr++){
     rp = r[jr];
     zp = z[0];
-	double deltaUr = sqrt(kerr_geo_Vr(a, En, Lz, Qc, rp));
+	double deltaUr = std::sqrt(std::abs(kerr_geo_Vr(a, En, Lz, Qc, rp)));
 	// take into account when the radial velocity is positive
 	ua[jr][0] = subfunc(a, En, Lz, Qc, rp, zp, deltaUr);
 	ua[u1rSize - jr][0] = subfunc(a, En, Lz, Qc, rp, zp, -deltaUr);
@@ -3234,7 +3234,7 @@ ComplexMatrix tetrad_velocity_radial(Complex (*subfunc)(double, double, double,
     for(size_t jz = 1; jz < z.size() - 1; jz++){
       rp = r[jr];
       zp = z[jz];
-      double deltaUr = sqrt(kerr_geo_Vr(a, En, Lz, Qc, rp));
+      double deltaUr = std::sqrt(std::abs(kerr_geo_Vr(a, En, Lz, Qc, rp)));
       // take into account when the radial velocity is positive
       ua[jr][jz] = subfunc(a, En, Lz, Qc, rp, zp, deltaUr);
       ua[jr][u1zSize - jz] = subfunc(a, En, Lz, Qc, rp, zp, deltaUr);

{pybhpt-0.9.4 → pybhpt-0.9.8}/cpp/src/swsh.cpp

@@ -718,7 +718,10 @@ Complex Yslm(const int &s, const int &l, const int &m, const double &th, const d
 
 double Yslm(const int &s, const int &l, const int &m, const double &th){
 	if( s == 0 ) return Ylm(l, m, th);
-
+	if( th == 0. ){
+		if (m != -s) return 0.;
+		else return pow(-1, s)*Yslm(0, l, 0, 0.);
+	}
 	int lmin = std::max(std::abs(m), l - std::abs(s));
 	int lmax = l + std::abs(s);
 	double yslm = 0;

{pybhpt-0.9.4 → pybhpt-0.9.8}/cython/geo_wrap.pyx

@@ -54,11 +54,17 @@ cdef extern from "geo.hpp":
         double getPolarPosition(int pos)
         double getAzimuthalAccumulation(int j, int pos)
 
+        double getPsiRadialOfMinoTime(double la)
+        double getPsiPolarOfMinoTime(double la)
+
         double getTimePositionOfMinoTime(double la)
         double getRadialPositionOfMinoTime(double la)
         double getPolarPositionOfMinoTime(double la)
         double getAzimuthalPositionOfMinoTime(double la)
 
+        vector[double] getPsiRadialOfMinoTime(vector[double] la)
+        vector[double] getPsiPolarOfMinoTime(vector[double] la)
+
         vector[double] getTimePositionOfMinoTime(vector[double] la)
         vector[double] getRadialPositionOfMinoTime(vector[double] la)
         vector[double] getPolarPositionOfMinoTime(vector[double] la)
@@ -187,6 +193,24 @@ cdef class KerrGeodesic:
     def mode_carter_frequency(self, np.ndarray[ndim=1, dtype=np.int64_t] kvec):
         return np.dot(kvec,(self.carterfrequencies))
 
+    cdef void getPsiRadialOfMinoTimeArray(self, np.float64_t *psi, np.float64_t *la, int n):
+        for i in range(n):
+            psi[i] = self.geocpp.getPsiRadialOfMinoTime(la[i])
+    cdef void getPsiPolarOfMinoTimeArray(self, np.float64_t *psi, np.float64_t *la, int n):
+        for i in range(n):
+            psi[i] = self.geocpp.getPsiPolarOfMinoTime(la[i])
+
+    cdef void getPsiRadialOfTimeArray(self, np.float64_t *psi, np.float64_t *t, int n):
+        cdef double tmp
+        for i in range(n):
+            tmp = self.geocpp.getMinoTimeOfTime(t[i])
+            psi[i] = self.geocpp.getPsiRadialOfMinoTime(tmp)
+    cdef void getPsiPolarOfTimeArray(self, np.float64_t *psi, np.float64_t *t, int n):
+        cdef double tmp
+        for i in range(n):
+            tmp = self.geocpp.getMinoTimeOfTime(t[i])
+            psi[i] = self.geocpp.getPsiPolarOfMinoTime(tmp)
+
     cdef void getTimePositionOfMinoTimeArray(self, np.float64_t *t, np.float64_t *la, int n):
         for i in range(n):
             t[i] = self.geocpp.getTimePositionOfMinoTime(la[i])
@@ -199,8 +223,86 @@ cdef class KerrGeodesic:
     cdef void getAzimuthalPositionOfMinoTimeArray(self, np.float64_t *t, np.float64_t *la, int n):
         for i in range(n):
             t[i] = self.geocpp.getAzimuthalPositionOfMinoTime(la[i])
+
+    cdef void getRadialPositionOfTimeArray(self, np.float64_t *r, np.float64_t *t, int n):
+        cdef double tmp
+        for i in range(n):
+            tmp = self.geocpp.getMinoTimeOfTime(t[i])
+            r[i] = self.geocpp.getRadialPositionOfMinoTime(tmp)
+    cdef void getPolarPositionOfTimeArray(self, np.float64_t *th, np.float64_t *t, int n):
+        cdef double tmp
+        for i in range(n):
+            tmp = self.geocpp.getMinoTimeOfTime(t[i])
+            th[i] = self.geocpp.getPolarPositionOfMinoTime(tmp)
+    cdef void getAzimuthalPositionOfTimeArray(self, np.float64_t *ph, np.float64_t *t, int n):
+        cdef double tmp
+        for i in range(n):
+            tmp = self.geocpp.getMinoTimeOfTime(t[i])
+            ph[i] = self.geocpp.getAzimuthalPositionOfMinoTime(tmp)
+
+    def psi_radial(self, double la):
+        return self.geocpp.getPsiRadialOfMinoTime(la)
+
+    def psi_polar(self, double la):
+        return self.geocpp.getPsiPolarOfMinoTime(la)
+
+    def psi_radial_time(self, double t):
+        cdef double tmp = self.geocpp.getMinoTimeOfTime(t)
+        return self.geocpp.getPsiRadialOfMinoTime(tmp)
+
+    def psi_polar_time(self, double t):
+        cdef double tmp = self.geocpp.getMinoTimeOfTime(t)
+        return self.geocpp.getPsiPolarOfMinoTime(tmp)
+
+    def psi_radial_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
+        cdef int n = la.shape[0]
+        cdef np.ndarray[ndim=1, dtype=np.float64_t] psi = np.empty(n, dtype = np.float64)
+        self.getPsiRadialOfMinoTimeArray(&psi[0], &la[0], n)
+        return psi
+
+    def psi_polar_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
+        cdef int n = la.shape[0]
+        cdef np.ndarray[ndim=1, dtype=np.float64_t] psi = np.empty(n, dtype = np.float64)
+        self.getPsiPolarOfMinoTimeArray(&psi[0], &la[0], n)
+        return psi
+
+    def psi_radial_time_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] t):
+        cdef int n = t.shape[0]
+        cdef np.ndarray[ndim=1, dtype=np.float64_t] psi = np.empty(n, dtype = np.float64)
+        self.getPsiRadialOfTimeArray(&psi[0], &t[0], n)
+        return psi
+
+    def psi_polar_time_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] t):
+        cdef int n = t.shape[0]
+        cdef np.ndarray[ndim=1, dtype=np.float64_t] psi = np.empty(n, dtype = np.float64)
+        self.getPsiPolarOfTimeArray(&psi[0], &t[0], n)
+        return psi
+
+    def time_position(self, double la):
+        return self.geocpp.getTimePositionOfMinoTime(la)
+
+    def radial_position(self, double la):
+        return self.geocpp.getRadialPositionOfMinoTime(la)
     
-    def time_position(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
+    def polar_position(self, double la):
+        return self.geocpp.getPolarPositionOfMinoTime(la)
+    
+    def azimuthal_position(self, double la):
+        return self.geocpp.getAzimuthalPositionOfMinoTime(la)
+
+    def radial_position_time(self, double t):
+        cdef double tmp = self.geocpp.getMinoTimeOfTime(t)
+        return self.geocpp.getRadialPositionOfMinoTime(tmp)
+
+    def polar_position_time(self, double t):
+        cdef double tmp = self.geocpp.getMinoTimeOfTime(t)
+        return self.geocpp.getPolarPositionOfMinoTime(tmp)
+
+    def azimuthal_position_time(self, double t):
+        cdef double tmp = self.geocpp.getMinoTimeOfTime(t)
+        return self.geocpp.getAzimuthalPositionOfMinoTime(tmp)
+
+    def time_position_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
         cdef int n = la.shape[0]
         cdef np.ndarray[ndim=1, dtype=np.float64_t] t = np.empty(n, dtype = np.float64)
         self.getTimePositionOfMinoTimeArray(&t[0], &la[0], n)
@@ -209,23 +311,70 @@ cdef class KerrGeodesic:
         #     t[i] = self.geocpp.getTimePositionOfMinoTime(la[i])
         return t
     
-    def radial_position(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
+    def radial_position_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
         cdef int n = la.shape[0]
         cdef np.ndarray[ndim=1, dtype=np.float64_t] x = np.empty(n, dtype = np.float64)
         self.getRadialPositionOfMinoTimeArray(&x[0], &la[0], n)
         return x
 
-    def polar_position(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
+    def polar_position_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
         cdef int n = la.shape[0]
         cdef np.ndarray[ndim=1, dtype=np.float64_t] x = np.empty(n, dtype = np.float64)
         self.getPolarPositionOfMinoTimeArray(&x[0], &la[0], n)
         return x
 
-    def azimuthal_position(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
+    def azimuthal_position_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
         cdef int n = la.shape[0]
         cdef np.ndarray[ndim=1, dtype=np.float64_t] x = np.empty(n, dtype = np.float64)
         self.getAzimuthalPositionOfMinoTimeArray(&x[0], &la[0], n)
         return x
+
+    def radial_position_time_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] t):
+        cdef int n = t.shape[0]
+        cdef np.ndarray[ndim=1, dtype=np.float64_t] x = np.empty(n, dtype = np.float64)
+        self.getRadialPositionOfTimeArray(&x[0], &t[0], n)
+        return x
+
+    def polar_position_time_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] t):
+        cdef int n = t.shape[0]
+        cdef np.ndarray[ndim=1, dtype=np.float64_t] x = np.empty(n, dtype = np.float64)
+        self.getPolarPositionOfTimeArray(&x[0], &t[0], n)
+        return x
+
+    def azimuthal_position_time_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] t):
+        cdef int n = t.shape[0]
+        cdef np.ndarray[ndim=1, dtype=np.float64_t] x = np.empty(n, dtype = np.float64)
+        self.getAzimuthalPositionOfTimeArray(&x[0], &t[0], n)
+        return x
+
+    def position(self, double la):
+        return np.array([self.geocpp.getTimePositionOfMinoTime(la), self.geocpp.getRadialPositionOfMinoTime(la), self.geocpp.getPolarPositionOfMinoTime(la), self.geocpp.getAzimuthalPositionOfMinoTime(la)])
+
+    def position_time(self, double t):
+        cdef double tmp = self.geocpp.getMinoTimeOfTime(t)
+        return np.array([self.geocpp.getRadialPositionOfMinoTime(tmp), self.geocpp.getPolarPositionOfMinoTime(tmp), self.geocpp.getAzimuthalPositionOfMinoTime(tmp)])
+
+    def position_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
+        cdef np.ndarray[ndim=2, dtype=np.float64_t] xp = np.empty((la.shape[0], 4), dtype=np.float64)
+        for i in range(la.shape[0]):
+            xp[i] = self.position(la[i])
+        return xp.T
+
+    def position_time_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] t):
+        cdef np.ndarray[ndim=2, dtype=np.float64_t] xp = np.empty((t.shape[0], 3), dtype=np.float64)
+        for i in range(t.shape[0]):
+            xp[i] = self.position_time(t[i])
+        return xp.T
+
+    def mino_time(self, double t):
+        return self.geocpp.getMinoTimeOfTime(t)
+
+    def mino_time_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] t):
+        cdef int n = t.shape[0]
+        cdef np.ndarray[ndim=1, dtype=np.float64_t] la = np.empty(n, dtype = np.float64)
+        for i in range(n):
+            la[i] = self.mino_time(t[i])
+        return la
     
     def get_time_accumulation(self, int j):
         cdef vector[double] deltaX_cpp = self.geocpp.getTimeAccumulation(j)
@@ -259,18 +408,6 @@ cdef class KerrGeodesic:
             deltaX[i] = deltaX_cpp[i]
         return deltaX
 
-    def position(self, double la):
-        return np.array([self.geocpp.getTimePositionOfMinoTime(la), self.geocpp.getRadialPositionOfMinoTime(la), self.geocpp.getPolarPositionOfMinoTime(la), self.geocpp.getAzimuthalPositionOfMinoTime(la)])
-    
-    def position_vec(self, np.ndarray[ndim=1, dtype=np.float64_t] la):
-        cdef np.ndarray[ndim=2, dtype=np.float64_t] xp = np.empty((la.shape[0], 4), dtype=np.float64)
-        for i in range(la.shape[0]):
-            xp[i] = self.position(la[i])
-        return xp.T
-
-    def mino_time(self, double t):
-        return self.geocpp.getMinoTimeOfTime(t)
-
     def get_time_coefficients(self, int j):
         cdef vector[double] deltaX_cpp = self.geocpp.getTimeCoefficients(j)
         cdef int n = deltaX_cpp.size()

pybhpt-0.9.8/cython/swsh_wrap.pyx

@@ -0,0 +1,70 @@
+from libcpp.vector cimport vector
+from libcpp.complex cimport complex as cpp_complex
+import numpy as np
+cimport numpy as np
+
+cdef extern from "gsl/gsl_errno.h":
+  void gsl_set_error_handler_off()
+
+# If you need to disable GSL error handling, do so in a targeted way within specific functions.
+# gsl_set_error_handler_off()  # Removed global call to avoid masking numerical errors.
+
+cdef extern from "swsh.hpp":
+    cdef cppclass SpinWeightedHarmonic:
+        SpinWeightedHarmonic(int s, int L, int m, double gamma, vector[double]& theta)
+
+        int getSpinWeight()
+        int getSpheroidalModeNumber()
+        int getAzimuthalModeNumber()
+        double getSpheroidicity()
+        double getEigenvalue()
+        vector[double] getCouplingCoefficient()
+        double getCouplingCoefficient(int l)
+        int getMinCouplingModeNumber()
+        int getMaxCouplingModeNumber()
+
+        int generateSolutionsAndDerivatives()
+        int generateCouplingCoefficients()
+        int generateSolutions()
+        int generateDerivatives()
+
+        vector[double] getArguments()
+        vector[double] getSolution()
+        vector[double] getDerivative()
+        vector[double] getSecondDerivative()
+
+        double getArguments(int pos)
+        double getSolution(int pos)
+        double getDerivative(int pos)
+        double getSecondDerivative(int pos)
+
+    double Asljm(int &s, int &l, int &j, int &m)
+    double dAsljm(int &s, int &l, int &j, int &m)
+
+    double clebsch(int &j1, int &j2, int &j, int &m1, int &m2, int &m)
+    double w3j(int &j1, int &j2, int &j, int &m1, int &m2, int &m)
+
+    cpp_complex[double] Sslm(int &s, int &l, int &m, double &g, double &th, double &ph)
+    double Sslm(int &s, int &l, int &m, double &g, double &th)
+
+    double Sslm(int &s, int &l, int &m, double &g, vector[double]& bvec, double &th)
+    double Sslm_derivative(int &s, int &l, int &m, double &g, vector[double]& bvec, double &th)
+    double Sslm_secondDerivative(int &s, int &l, int &m, double &g, double& la, double &th, double &Slm, double &SlmP)
+
+    double swsh_eigenvalue(int &s, int &l, int &m, double &g)
+
+    cpp_complex[double] Yslm(int &s, int &l, int &m, double &th, double &ph)
+    double Yslm(int &s, int &l, int &m, double &th) except +
+    double Yslm_derivative(int &s, int &l, int &m, double &th)
+
+def YslmCy(int s, int l, int m, double theta):
+  return Yslm(s, l, m, theta)
+
+def YslmCy_derivative(int s, int l, int m, double theta):
+  return Yslm_derivative(s, l, m, theta)
+
+def clebschCy(int j1, int j2, int j, int m1, int m2, int m):
+  return clebsch(j1, j2, j, m1, m2, m)
+
+def w3jCy(int j1, int j2, int j, int m1, int m2, int m):
+  return w3j(j1, j2, j, m1, m2, m)

{pybhpt-0.9.4 → pybhpt-0.9.8}/cython/teukolsky_wrap.pyx

@@ -7,6 +7,7 @@ cimport numpy as np
 # from geo_wrap cimport GeodesicSource
 include "geo_wrap.pyx"
 include "radialsolver_wrap.pyx"
+include "swsh_wrap.pyx"
 
 cdef extern from "teukolsky.hpp":
     cdef cppclass SpinWeightedHarmonic:

pybhpt-0.9.8/docs/Makefile

@@ -0,0 +1,12 @@
+# Clean target to remove build directory
+clean:
+	rm -rf _build
+# Minimal Sphinx Makefile
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+.PHONY: html
+html:
+	$(SPHINXBUILD) -b html $(SOURCEDIR) $(BUILDDIR)/html $(SPHINXOPTS)

pybhpt-0.9.8/docs/about.md

@@ -0,0 +1,26 @@
+# About
+
+`pybhpt` is a collection of numerical tools for analyzing perturbations of Kerr spacetime, particularly the self-forces and metric-perturbations experienced by small bodies moving in a Kerr background.
+
+## Subpackages
+- [`pybhpt.geo`](pybhpt.geo): generates bound periodic timelike geodesics in Kerr spacetime
+- [`pybhpt.radial`](pybhpt.radial): calculates homogeneous solutions of the radial Teukolsky equation
+- [`pybhpt.swsh`](pybhpt.swsh): constructs the spin-weighted spheroidal harmonics
+- [`pybhpt.teuk`](pybhpt.teuk): evaluates inhomogeneous solutions (Teukolsky amplitudes) of the radial Teukolsky equation due to a point-particle on a bound timelike Kerr geodesic
+- [`pybhpt.flux`](pybhpt.flux): produces gravitational wave fluxes sourced by a point-particle on a generic bound timelike Kerr geodesic
+- [`pybhpt.hertz`](pybhpt.hertz): solves for the Hertz potentials for the CCK and AAB metric reconstruction procedures
+- [`pybhpt.metric`](pybhpt.metric): produces coefficients needed to reconstruct the metric from the Hertz potentials
+- [`pybhpt.redshift`](pybhpt.redshift): computes the generalized Detweiler redshift invariant in a variety of gauges
+
+One can find out more information about each module by exploring the User Guides or clicking on the subpackages, which are linked to the API.
+
+## References
+
+Theoretical background for the code and explanations of the numerical methods used within are summarized in the references below: 
+
+- Z. Nasipak, *Metric reconstruction and the Hamiltonian for eccentric, precessing binaries in the small-mass-ratio limit* (2025) [arXiv:2507.07746](https://arxiv.org/abs/2507.07746)
+- Z. Nasipak, *An adiabatic gravitational waveform model for compact objects undergoing quasi-circular inspirals into rotating massive black holes*, Phys. Rev. D 109, 044020 (2024) [arXiv:2310.19706](https://arxiv.org/abs/2310.19706)
+- Z. Nasipak, *Adiabatic evolution due to the conservative scalar self-force during orbital resonances*, Phys. Rev. D 106, 064042 (2022) [arXiv:2207.02224](https://arxiv.org/abs/2207.02224)
+
+## Authors
+Zachary Nasipak

pybhpt-0.9.8/docs/background/geo.md

@@ -0,0 +1,76 @@
+# Geodesics in Kerr
+
+We work in a Kerr background with angular momentum and mass parameters $(J, M)$ and use Boyer-Lindquist coordinates $(t, r, \theta, \phi)$.
+
+Bound periodic timelike geodesics in Kerr spacetime are defined in terms of the turning points of the motion:
+
+- $r_\mathrm{min}$ : minimum Boyer-Lindquist radius
+- $r_\mathrm{max}$ : maximum Boyer-Lindquist radius
+- $\theta_\mathrm{min}$ : minimum Boyer-Lindquist polar angle
+- $\pi-\theta_\mathrm{min}$ : maximum Boyer-Lindquist polar angle
+
+From these we parametrize the geodesic in terms of the generalized Keplerian parameters:
+
+- $a$ : the dimensionless Kerr spin parameter
+- $p$ : the dimensionless semilatus rectum
+- $e$ : the orbital eccentricty
+- $x$ : cosine of the orbital inclination
+
+where $a = J/M^2$, $pM = 2r_\mathrm{max}r_\mathrm{min}/(r_\mathrm{min}+r_\mathrm{max})$ and $e = (r_\mathrm{max}-r_\mathrm{min})/(r_\mathrm{min}+r_\mathrm{max})$. The motion can also be described in terms of the conserved orbital constants:
+
+- $E$ : the specific orbital energy
+- $L_z$ : the specific orbital angular momentum
+- $Q$ : the Carter constant
+
+which have units $\{1, M, M^2\}$, respectively, along with the mass of the small body $\mu$.
+
+With these conserved quantities, we obtain four first-order ordinary differential equations (ODEs) for $x_p^\mu$, which decouple when parametrized in terms of the Mino(-Carter) time parameter $\lambda$,
+$$\begin{align}
+    \frac{dt_p}{d\lambda} &= V_{tr}(r_p) + V_{t\theta}(\theta_p),
+    \\
+    \frac{dr_p}{d\lambda} &= \pm \sqrt{V_r(r_p)},
+    \\ 
+    \frac{d\theta_p}{d\lambda} &= \pm \sqrt{V_\theta(\theta_p)},
+    \\
+    \frac{d\phi_p}{d\lambda} &= V_{\phi r}(r_p) + V_{\phi \theta}(\theta_p),
+\end{align}$$
+where $d\lambda = \Sigma^{-1} d\tau$, and the potential functions are given by
+$$\begin{align} 
+    V_{r}(r) &= { P^2(r) - \Delta\left(r^2 + {K} \right),} 
+    &
+    V_{\theta}(\theta) &= {{Q} - {L}_z^2 \cot^2\theta - a^2 (1 -{E}^2)\cos^2\theta,}
+    \\
+    V_{tr}(r) &= \frac{r^2+a^2}{\Delta}P(r), 
+    &
+    V_{t\theta}(\theta) &= a{L}_z - a^2 {E} \sin^2\theta, 
+    \\
+    V_{\phi r}(r) &= \frac{a}{\Delta}P(r), 
+    &
+    V_{\phi \theta}(\theta) &= {L}_z \csc^2\theta - a {E},
+\end{align}$$
+
+with $P(r) = (r^2+a^2){E} - a {L}_z$.
+
+The resulting bound solutions can be separated into terms that are periodic with respect to the Mino time radial and polar frequencies $\Upsilon_r$ and $\Upsilon_\theta$ and terms that grow secularly with the Mino time rates $\Upsilon_t$ and $\Upsilon_\phi$.
+Therefore, the fundamental coordinate time frequencies are given by
+$$\begin{align}
+    \Omega_r &= \frac{\Upsilon_r}{\Upsilon_t},
+    &
+    \Omega_\theta &= \frac{\Upsilon_\theta}{\Upsilon_t},
+    &
+    \Omega_\phi &= \frac{\Upsilon_\phi}{\Upsilon_t}.
+\end{align}$$
+
+We then represent the radial and polar motion by
+$$\begin{align}
+    r_p(\lambda) &= \Delta r^{(r)}(\Upsilon_r\lambda) = \Delta r^{(r)}(\Upsilon_r\lambda + 2\pi),
+    \\
+    \theta_p(\lambda) &= \Delta \theta^{(\theta)}(\Upsilon_\theta\lambda) = \Delta \theta^{(\theta)}(\Upsilon_\theta\lambda + 2\pi),
+\end{align}$$
+while time and azimuthal angle grow as
+$$\begin{align}
+    t_p(\lambda) &= \Upsilon_t \lambda + \Delta t^{(r)}(\Upsilon_r\lambda) + \Delta t^{(\theta)}(\Upsilon_\theta\lambda),
+    \\ 
+    \phi_p(\lambda) &= \Upsilon_\phi \lambda + \Delta \phi^{(r)}(\Upsilon_r\lambda) + \Delta \phi^{(\theta)}(\Upsilon_\theta\lambda),
+\end{align}$$
+where $\Delta t^{(r)}$, $\Delta \phi^{(r)}$, $\Delta t^{(\theta)}$, and $\Delta \phi^{(\theta)}$ are $2\pi$-periodic odd functions.