few: FastEMRIWaveforms
This package contains a highly modular framework for the rapid generation of accurate extreme-mass-ratio inspiral (EMRI) waveforms. FEW combines a variety of separately accessible modules to construct EMRI waveform models for both CPUs and GPUs.
Generally, the modules fall into four categories: trajectory, amplitudes, summation, and utilities. Please see the documentation for further information on these modules.
The code can be found on Github here.
The data necessary for various modules in this package will automatically download the first time it is needed. If you would like to view the data, it can be found on Zenodo.
The current and all past code release zip files can also be found on Zenodo here.
Please see the citation section below for information on citing FEW. This package is part of the Black Hole Perturbation Toolkit.
Getting started
To install the latest version of fastemriwaveforms
using pip
, simply run:
# For CPU-only version
pip install fastemriwaveforms
# For GPU-enabled versions with CUDA 11.Y.Z
pip install fastemriwaveforms-cuda11x
# For GPU-enabled versions with CUDA 12.Y.Z
pip install fastemriwaveforms-cuda12x
To know your CUDA version, run the tool nvidia-smi
in a terminal a check the CUDA version reported in the table header:
$ nvidia-smi
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |
|-----------------------------------------+------------------------+----------------------+
...
You may also install fastemriwaveforms
directly using conda (including on Windows)
as well as its CUDA 12.x plugin (only on Linux). It is strongly advised to:
Ensure that your conda environment makes sole use of the
conda-forge
channelInstall
fastemriwaveforms
directly when building your conda environment, not afterwards
# To run only once to ensure you only use the conda-forge channel
conda config --set channel_priority strict
# For CPU-only version, on either Linux, macOS or Windows:
conda create --name few_cpu python=3.12 fastemriwaveforms
conda activate few_cpu
# For CUDA 12.x version, only on Linux
conda create --name few_cuda python=3.12 fastemriwaveforms-cuda12x
conda activate few_cuda
Note that this conda support might take a few days/weeks after FEW 2.0 official official release to be available. When support for conda is achieved, this page will work without redirecting you to the “Sign in to Anaconda.org” page.
Now, in a python file or notebook:
import few
You may check the currently available backends:
>>> for backend in ["cpu", "cuda11x", "cuda12x", "cuda", "gpu"]:
... print(f" - Backend '{backend}': {"available" if few.has_backend(backend) else "unavailable"}")
- Backend 'cpu': available
- Backend 'cuda11x': unavailable
- Backend 'cuda12x': unavailable
- Backend 'cuda': unavailable
- Backend 'gpu': unavailable
Note that the cuda
backend is an alias for either cuda11x
or cuda12x
. If any is available, then the cuda
backend is available.
Similarly, the gpu
backend is (for now) an alias for cuda
.
If you expected a backend to be available but it is not, run the following command to obtain an error message which can guide you to fix this issue:
>>> import few
>>> few.get_backend("cuda12x")
ModuleNotFoundError: No module named 'few_backend_cuda12x'
The above exception was the direct cause of the following exception:
...
few.cutils.BackendNotInstalled: The 'cuda12x' backend is not installed.
The above exception was the direct cause of the following exception:
...
few.cutils.MissingDependencies: FastEMRIWaveforms CUDA plugin is missing.
If you are using few in an environment managed using pip, run:
$ pip install fastemriwaveforms-cuda12x
The above exception was the direct cause of the following exception:
...
few.cutils.BackendAccessException: Backend 'cuda12x' is unavailable. See previous error messages.
Once FEW is working and the expected backends are selected, check out the examples notebooks on how to start with this software.
Installing from sources
Prerequisites
To install this software from source, you will need:
A C++ compiler (g++, clang++, …)
A Python version supported by scikit-build-core (>=3.7 as of Jan. 2025)
Some installation steps require the external library LAPACK
along with its C-bindings provided by LAPACKE
.
If these libraries and their header files (in particular lapacke.h
) are available on your system, they will be detected
and used automatically. If they are available on a non-standard location, see below for some options to help detecting them.
Note that by default, if LAPACKE
is not available on your system, the installation step will attempt to download its sources
and add them to the compilation tree. This makes the installation a bit longer but a lot easier.
If you want to enable GPU support in FEW, you will also need the NVIDIA CUDA Compiler nvcc
in your path as well as
the CUDA toolkit (with, in particular, the
libraries CUDA Runtime Library
, cuBLAS
and cuSPARSE
).
There are a set of files required for total use of this package. They will download automatically the first time they are needed. Files are generally under 10MB. However, there is a 100MB file needed for the slow waveform and the bicubic amplitude interpolation. This larger file will only download if you run either of those two modules. The files are hosted on the Black Hole Perturbation Toolkit Download Server.
Installation instructions using conda
We recommend to install FEW using conda in order to have the compilers all within an environment. First clone the repo
git clone https://github.com/BlackHolePerturbationToolkit/FastEMRIWaveforms.git
cd FastEMRIWaveforms
git checkout Kerr_Equatorial_Eccentric
Now create an environment (here Mac OSX arm M chip)
conda create -n few_env -y -c conda-forge -y python=3.12 clangxx_osx-arm64 clang_osx-arm64 h5py wget gsl liblapacke lapack openblas fortran-compiler scipy numpy matplotlib jupyter
Instead for MACOS:
conda create -n few_env -c conda-forge -y clangxx_osx-64 clang_osx-64 h5py wget gsl liblapacke lapack openblas fortran-compiler scipy numpy matplotlib jupyter python=3.12
activate the environment
conda activate few_env
and finally remember to install lisaconstants
pip install lisaconstants
You should have now installed the packages that allow FEW to be compiled but let’s enforce the compilers by running
export CXXFLAGS="-march=native"
export CFLAGS="-march=native"
Find the clang compiler by running
ls ${CONDA_PREFIX}/bin/*clang
ls ${CONDA_PREFIX}/bin/*clang++
Then export and define the compilers, on my laptop it looks like
export CC=/opt/miniconda3/envs/few_env/bin/arm64-apple-darwin20.0.0-clang
export CXX=/opt/miniconda3/envs/few_env/bin/arm64-apple-darwin20.0.0-clang++
Then we can install locally for development:
pip install -e '.[dev, testing]'
Installation instructions using conda on GPUs and linux
Below is a quick set of instructions to install the Fast EMRI Waveform package on GPUs and linux.
conda create -n few_env -c conda-forge gcc_linux-64 gxx_linux-64 wget gsl lapack=3.6.1 hdf5 numpy Cython scipy tqdm jupyter ipython h5py requests matplotlib python=3.12 pandas fortran-compiler
conda activate few_env
pip install lisaconstants
Locate where the nvcc
compile is located and add it to the path, in my case it is located in /usr/local/cuda-12.5/bin/
export PATH=$PATH:/usr/local/cuda-12.5/bin/
Check the version of your compiler by running nvcc --version
and install the corresponding FEW cuda version for running on GPUs:
pip install --pre fastemriwaveforms-cuda12x
Test the installation device by running python
import few
few.get_backend("cuda12x")
Running the installation
To start the from-source installation, ensure the pre-requisite are met, clone the repository, and then simply run a pip install
command:
# Clone the repository
git clone https://github.com/BlackHolePerturbationToolkit/FastEMRIWaveforms.git
cd FastEMRIWaveforms
# Run the install
pip install .
Many options are available to change the installation behaviour. These can be set by adding --config-settings=cmake.define.OPTION_NAME=OPTION_VALUE
to the pip
command. Available options are:
FEW_LAPACKE_FETCH=ON|OFF|[AUTO]
: WhetherLAPACK
andLAPACKE
should be automatically fetched from internet.ON
: ignore pre-installedLAPACK(E)
and always fetch and compile their sourcesOFF
: disableLAPACK(E)
fetching and only use pre-installed library and headers (install will fail if pre-installed lib and headers are not available)AUTO
(default): try to detect pre-installedLAPACK(E)
and their headers. If found, use them, otherwise fetchLAPACK(E)
.
FEW_LAPACKE_DETECT_WITH=[CMAKE]|PKGCONFIG
: HowLAPACK(E)
should be detectedCMAKE
:LAPACK(E)
will be detected using the cmakeFindPackage
command. If yourLAPACK(E)
install provideslapacke-config.cmake
in a non-standard location, add its path to theCMAKE_PREFIX_PATH
environment variable.PKGCONFIG
:LAPACK(E)
will be detected usingpkg-config
by searching for the fileslapack.pc
andlapacke.pc
. If these files are provided by yourLAPACK(E)
install in a non-standard location, add their path to the environment variablePKG_CONFIG_PATH
AUTO
(default): attempt both CMake and PkgConfig approaches
FEW_WITH_GPU=ON|OFF|[AUTO]
: Whether GPU-support must be enabledON
: Forcefully enable GPU support (install will fail if GPU prerequisites are not met)OFF
: Disable GPU supportAUTO
(default): Check whethernvcc
and theCUDA Toolkit
are available in environment and enable/disable GPU support accordingly.
FEW_CUDA_ARCH
: List of CUDA architectures that will be targeted by the CUDA compiler using CMake CUDA_ARCHITECTURES syntax. (Default =all
).
Example of custom install with specific options to forcefully enable GPU support with support for the host’s GPU only (native
architecture) using LAPACK fetched from internet:
pip install . \
--config-settings=cmake.define.FEW_WITH_GPU=ON \
--config-settings=cmake.define.FEW_CUDA_ARCH="native" \
--config-settings=cmake.define.FEW_LAPACKE_FETCH=ON
If you enabled GPU
support (or it was automatically enabled by the AUTO
mode), you will also need to install the nvidia-cuda-runtime
package corresponding to the CUDA version detected by nvidia-smi
as explained in the Getting Started section above.
You will also need to manually install cupy-cuda11x
or cupy-cuda12x
according to your CUDA version.
Please contact the developers if the installation does not work.
Running the Tests
The tests require a few dependencies which are not installed by default. To install them, add the [testing]
label to FEW package
name when installing it. E.g:
# For CPU-only version with testing enabled
pip install fastemriwaveforms[testing]
# For GPU version with CUDA 12.Y and testing enabled
pip install fastemriwaveforms-cuda12x[testing]
# For from-source install with testing enabled
git clone https://github.com/BlackHolePerturbationToolkit/FastEMRIWaveforms.git
cd FastEMRIWaveforms
pip install '.[testing]'
To run the tests, open a terminal in a directory containing the sources of FEW and then run the unittest
module in discover
mode:
$ git clone https://github.com/BlackHolePerturbationToolkit/FastEMRIWaveforms.git
$ cd FastEMRIWaveforms
$ python -m few.tests # or "python -m unittest discover"
...
----------------------------------------------------------------------
Ran 20 tests in 71.514s
OK
Contributing
Please read CONTRIBUTING.md for details on our code of conduct, and the process for submitting pull requests to us.
If you want to develop FEW and produce documentation, install few
from source with the [dev]
label and in editable
mode:
$ git clone https://github.com/BlackHolePerturbationToolkit/FastEMRIWaveforms.git
$ cd FastEMRIWaveforms
pip install -e '.[dev, testing]'
This will install necessary packages for building the documentation (sphinx
, pypandoc
, sphinx_rtd_theme
, nbsphinx
) and to run the tests.
The documentation source files are in docs/source
. To compile the documentation locally, change to the docs
directory and run make html
.
Versioning
We use SemVer for versioning. For the versions available, see the tags on this repository.
Contributors
A (non-exhaustive) list of contributors to the FEW code can be found in CONTRIBUTORS.md.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Citation
Please make sure to cite FEW papers and the FEW software on Zenodo.
We provide a set of prepared references in PAPERS.bib. There are other papers that require citation based on the classes used. For most classes this applies to, you can find these by checking the citation
attribute for that class. All references are detailed in the CITATION.cff file.
Acknowledgments
This research resulting in this code was supported by National Science Foundation under grant DGE-0948017 and the Chateaubriand Fellowship from the Office for Science & Technology of the Embassy of France in the United States.
It was also supported in part through the computational resources and staff contributions provided for the Quest/Grail high performance computing facility at Northwestern University.
User guide:
- Overall Waveform Models
- Trajectory Package
TrajectoryBase
- Generic Inspiral Generator
EMRIInspiral
EMRIInspiral.inspiral_generator
EMRIInspiral.specific_kwarg_keys
EMRIInspiral.module_references()
EMRIInspiral.npoints
EMRIInspiral.tolerance
EMRIInspiral.dense_stepping
EMRIInspiral.integrate_backwards
EMRIInspiral.get_inspiral()
EMRIInspiral.__call__()
EMRIInspiral.citation()
EMRIInspiral.get_rhs_ode()
get_0PA_frequencies()
- ODE Integrators
Integrate
Integrate.nparams
Integrate.num_add_args
Integrate.convert_Y
Integrate.background
Integrate.equatorial
Integrate.circular
Integrate.integrate_constants_of_motion
Integrate.separatrix_buffer_dist
Integrate.distance_to_outer_boundary()
Integrate.take_step()
Integrate.log_failed_step()
Integrate.tune_initial_step_size()
Integrate.integrate()
Integrate.action_function()
Integrate.initialize_integrator()
Integrate.tolerance
Integrate.dense_stepping
Integrate.npoints
Integrate.trajectory
Integrate.integrator_t_cache
Integrate.integrator_spline_coeff
Integrate.save_point()
Integrate.eval_integrator_spline()
Integrate.eval_integrator_derivative_spline()
Integrate.run_inspiral()
Integrate.stop_integrate_check()
Integrate.inner_func_forward()
Integrate.inner_func_backward()
Integrate.finishing_function()
Integrate.get_pex()
APEXIntegrate
APEXIntegrate.get_pex()
APEXIntegrate.action_function()
APEXIntegrate.background
APEXIntegrate.circular
APEXIntegrate.convert_Y
APEXIntegrate.dense_stepping
APEXIntegrate.distance_to_outer_boundary()
APEXIntegrate.equatorial
APEXIntegrate.eval_integrator_derivative_spline()
APEXIntegrate.eval_integrator_spline()
APEXIntegrate.finishing_function()
APEXIntegrate.initialize_integrator()
APEXIntegrate.inner_func_backward()
APEXIntegrate.inner_func_forward()
APEXIntegrate.integrate()
APEXIntegrate.integrate_constants_of_motion
APEXIntegrate.integrator_spline_coeff
APEXIntegrate.integrator_t_cache
APEXIntegrate.log_failed_step()
APEXIntegrate.nparams
APEXIntegrate.npoints
APEXIntegrate.num_add_args
APEXIntegrate.run_inspiral()
APEXIntegrate.save_point()
APEXIntegrate.separatrix_buffer_dist
APEXIntegrate.stop_integrate_check()
APEXIntegrate.take_step()
APEXIntegrate.tolerance
APEXIntegrate.trajectory
APEXIntegrate.tune_initial_step_size()
AELQIntegrate
AELQIntegrate.action_function()
AELQIntegrate.background
AELQIntegrate.circular
AELQIntegrate.convert_Y
AELQIntegrate.dense_stepping
AELQIntegrate.distance_to_outer_boundary()
AELQIntegrate.equatorial
AELQIntegrate.eval_integrator_derivative_spline()
AELQIntegrate.eval_integrator_spline()
AELQIntegrate.finishing_function()
AELQIntegrate.get_pex()
AELQIntegrate.initialize_integrator()
AELQIntegrate.inner_func_backward()
AELQIntegrate.inner_func_forward()
AELQIntegrate.integrate()
AELQIntegrate.integrate_constants_of_motion
AELQIntegrate.integrator_spline_coeff
AELQIntegrate.integrator_t_cache
AELQIntegrate.log_failed_step()
AELQIntegrate.nparams
AELQIntegrate.npoints
AELQIntegrate.num_add_args
AELQIntegrate.run_inspiral()
AELQIntegrate.save_point()
AELQIntegrate.separatrix_buffer_dist
AELQIntegrate.stop_integrate_check()
AELQIntegrate.take_step()
AELQIntegrate.tolerance
AELQIntegrate.trajectory
AELQIntegrate.tune_initial_step_size()
- ODE Classes
ODEBase
ODEBase.use_ELQ
ODEBase.num_add_args
ODEBase.integrate_backwards
ODEBase.convert_Y
ODEBase.equatorial
ODEBase.circular
ODEBase.supports_ELQ
ODEBase.background
ODEBase.separatrix_buffer_dist
ODEBase.nparams
ODEBase.flux_output_convention
ODEBase.evaluate_rhs()
ODEBase.modify_rhs_before_Jacobian()
ODEBase.min_p()
ODEBase.max_p()
ODEBase.min_e()
ODEBase.max_e()
ODEBase.modify_rhs()
ODEBase.interpolate_flux_grids()
ODEBase.distance_to_outer_boundary()
ODEBase.get_pex()
ODEBase.cache_values_and_check_bounds()
ODEBase.__call__()
SchwarzEccFlux
KerrEccEqFlux
KerrEccEqFluxLegacy
PN5
- Amplitude Package
AmplitudeBase
- ROMAN Network
RomanAmplitude
RomanAmplitude.attributes_RomanAmplitude()
RomanAmplitude.num_teuk_modes
RomanAmplitude.module_references()
RomanAmplitude.supported_backends()
RomanAmplitude.get_amplitudes()
RomanAmplitude.CPU_ONLY()
RomanAmplitude.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
RomanAmplitude.GPU_ONLY()
RomanAmplitude.GPU_RECOMMENDED()
RomanAmplitude.__call__()
RomanAmplitude.adapt_backend_kwargs()
RomanAmplitude.backend
RomanAmplitude.backend_name
RomanAmplitude.background
RomanAmplitude.build_with_same_backend()
RomanAmplitude.citation()
RomanAmplitude.descriptor
RomanAmplitude.frame
RomanAmplitude.needs_Y
RomanAmplitude.sanity_check_init()
RomanAmplitude.sanity_check_traj()
RomanAmplitude.sanity_check_viewing_angles()
RomanAmplitude.xp
RomanAmplitude.ndim
RomanAmplitude.lmax
RomanAmplitude.nmax
RomanAmplitude.num_modes
RomanAmplitude.m0sort
RomanAmplitude.l_arr_no_mask
RomanAmplitude.m_arr_no_mask
RomanAmplitude.n_arr_no_mask
RomanAmplitude.lmn_indices
RomanAmplitude.m0mask
RomanAmplitude.num_m_zero_up
RomanAmplitude.num_m0
RomanAmplitude.num_m_1_up
RomanAmplitude.l_arr
RomanAmplitude.m_arr
RomanAmplitude.n_arr
RomanAmplitude.m_zero_up_mask
RomanAmplitude.unique_l
RomanAmplitude.unique_m
RomanAmplitude.num_unique_lm
RomanAmplitude.index_map
RomanAmplitude.special_index_map
RomanAmplitude.index_map_arr
RomanAmplitude.special_index_map_arr
- 2D Cubic Spline Interpolation
AmpInterp2D
AmpInterp2D.l_arr
AmpInterp2D.m_arr
AmpInterp2D.n_arr
AmpInterp2D.num_teuk_modes
AmpInterp2D.knots
AmpInterp2D.coeff
AmpInterp2D.len_indiv_c
AmpInterp2D.interp2D
AmpInterp2D.module_references()
AmpInterp2D.supported_backends()
AmpInterp2D.__call__()
AmpInterp2D.CPU_ONLY()
AmpInterp2D.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
AmpInterp2D.GPU_ONLY()
AmpInterp2D.GPU_RECOMMENDED()
AmpInterp2D.adapt_backend_kwargs()
AmpInterp2D.backend
AmpInterp2D.backend_name
AmpInterp2D.build_with_same_backend()
AmpInterp2D.citation()
AmpInterp2D.get_amplitudes()
AmpInterp2D.xp
AmpInterpKerrEccEq
AmpInterpKerrEccEq.get_amplitudes()
AmpInterpKerrEccEq.CPU_ONLY()
AmpInterpKerrEccEq.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
AmpInterpKerrEccEq.GPU_ONLY()
AmpInterpKerrEccEq.GPU_RECOMMENDED()
AmpInterpKerrEccEq.__call__()
AmpInterpKerrEccEq.adapt_backend_kwargs()
AmpInterpKerrEccEq.backend
AmpInterpKerrEccEq.backend_name
AmpInterpKerrEccEq.background
AmpInterpKerrEccEq.build_with_same_backend()
AmpInterpKerrEccEq.citation()
AmpInterpKerrEccEq.descriptor
AmpInterpKerrEccEq.frame
AmpInterpKerrEccEq.module_references()
AmpInterpKerrEccEq.needs_Y
AmpInterpKerrEccEq.sanity_check_init()
AmpInterpKerrEccEq.sanity_check_traj()
AmpInterpKerrEccEq.sanity_check_viewing_angles()
AmpInterpKerrEccEq.supported_backends()
AmpInterpKerrEccEq.xp
AmpInterpKerrEccEq.ndim
AmpInterpKerrEccEq.lmax
AmpInterpKerrEccEq.nmax
AmpInterpKerrEccEq.num_modes
AmpInterpKerrEccEq.num_teuk_modes
AmpInterpKerrEccEq.m0sort
AmpInterpKerrEccEq.l_arr_no_mask
AmpInterpKerrEccEq.m_arr_no_mask
AmpInterpKerrEccEq.n_arr_no_mask
AmpInterpKerrEccEq.lmn_indices
AmpInterpKerrEccEq.m0mask
AmpInterpKerrEccEq.num_m_zero_up
AmpInterpKerrEccEq.num_m0
AmpInterpKerrEccEq.num_m_1_up
AmpInterpKerrEccEq.l_arr
AmpInterpKerrEccEq.m_arr
AmpInterpKerrEccEq.n_arr
AmpInterpKerrEccEq.m_zero_up_mask
AmpInterpKerrEccEq.unique_l
AmpInterpKerrEccEq.unique_m
AmpInterpKerrEccEq.num_unique_lm
AmpInterpKerrEccEq.index_map
AmpInterpKerrEccEq.special_index_map
AmpInterpKerrEccEq.index_map_arr
AmpInterpKerrEccEq.special_index_map_arr
AmpInterpSchwarzEcc
AmpInterpSchwarzEcc.CPU_ONLY()
AmpInterpSchwarzEcc.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
AmpInterpSchwarzEcc.GPU_ONLY()
AmpInterpSchwarzEcc.GPU_RECOMMENDED()
AmpInterpSchwarzEcc.__call__()
AmpInterpSchwarzEcc.adapt_backend_kwargs()
AmpInterpSchwarzEcc.backend
AmpInterpSchwarzEcc.backend_name
AmpInterpSchwarzEcc.background
AmpInterpSchwarzEcc.build_with_same_backend()
AmpInterpSchwarzEcc.citation()
AmpInterpSchwarzEcc.descriptor
AmpInterpSchwarzEcc.frame
AmpInterpSchwarzEcc.module_references()
AmpInterpSchwarzEcc.needs_Y
AmpInterpSchwarzEcc.sanity_check_init()
AmpInterpSchwarzEcc.sanity_check_traj()
AmpInterpSchwarzEcc.sanity_check_viewing_angles()
AmpInterpSchwarzEcc.supported_backends()
AmpInterpSchwarzEcc.xp
AmpInterpSchwarzEcc.ndim
AmpInterpSchwarzEcc.lmax
AmpInterpSchwarzEcc.nmax
AmpInterpSchwarzEcc.num_modes
AmpInterpSchwarzEcc.m0sort
AmpInterpSchwarzEcc.l_arr_no_mask
AmpInterpSchwarzEcc.m_arr_no_mask
AmpInterpSchwarzEcc.n_arr_no_mask
AmpInterpSchwarzEcc.lmn_indices
AmpInterpSchwarzEcc.m0mask
AmpInterpSchwarzEcc.num_m_zero_up
AmpInterpSchwarzEcc.num_m0
AmpInterpSchwarzEcc.num_m_1_up
AmpInterpSchwarzEcc.l_arr
AmpInterpSchwarzEcc.m_arr
AmpInterpSchwarzEcc.n_arr
AmpInterpSchwarzEcc.m_zero_up_mask
AmpInterpSchwarzEcc.unique_l
AmpInterpSchwarzEcc.unique_m
AmpInterpSchwarzEcc.num_unique_lm
AmpInterpSchwarzEcc.index_map
AmpInterpSchwarzEcc.special_index_map
AmpInterpSchwarzEcc.index_map_arr
AmpInterpSchwarzEcc.special_index_map_arr
AmpInterpSchwarzEcc.filename
AmpInterpSchwarzEcc.tck
AmpInterpSchwarzEcc.num_teuk_modes
AmpInterpSchwarzEcc.len_indiv_c
AmpInterpSchwarzEcc.interp2D
AmpInterpSchwarzEcc.get_amplitudes()
- Summation Package
SummationBase
SummationBase.sum()
SummationBase.__call__()
SummationBase.CPU_ONLY()
SummationBase.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
SummationBase.GPU_ONLY()
SummationBase.GPU_RECOMMENDED()
SummationBase.adapt_backend_kwargs()
SummationBase.backend
SummationBase.backend_name
SummationBase.build_with_same_backend()
SummationBase.citation()
SummationBase.module_references()
SummationBase.supported_backends()
SummationBase.xp
- Interpolated Summation
CubicSplineInterpolant
CubicSplineInterpolant.degree
CubicSplineInterpolant.ninterps
CubicSplineInterpolant.length
CubicSplineInterpolant.reshape_shape
CubicSplineInterpolant.interpolate_arrays
CubicSplineInterpolant.supported_backends()
CubicSplineInterpolant.y
CubicSplineInterpolant.c1
CubicSplineInterpolant.c2
CubicSplineInterpolant.c3
CubicSplineInterpolant.CPU_ONLY()
CubicSplineInterpolant.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
CubicSplineInterpolant.GPU_ONLY()
CubicSplineInterpolant.GPU_RECOMMENDED()
CubicSplineInterpolant.adapt_backend_kwargs()
CubicSplineInterpolant.backend
CubicSplineInterpolant.backend_name
CubicSplineInterpolant.build_with_same_backend()
CubicSplineInterpolant.citation()
CubicSplineInterpolant.module_references()
CubicSplineInterpolant.xp
CubicSplineInterpolant.__call__()
InterpolatedModeSum
InterpolatedModeSum.CPU_ONLY()
InterpolatedModeSum.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
InterpolatedModeSum.GPU_ONLY()
InterpolatedModeSum.GPU_RECOMMENDED()
InterpolatedModeSum.__call__()
InterpolatedModeSum.adapt_backend_kwargs()
InterpolatedModeSum.backend
InterpolatedModeSum.backend_name
InterpolatedModeSum.build_with_same_backend()
InterpolatedModeSum.citation()
InterpolatedModeSum.module_references()
InterpolatedModeSum.xp
InterpolatedModeSum.get_waveform
InterpolatedModeSum.supported_backends()
InterpolatedModeSum.sum()
FDInterpolatedModeSum
FDInterpolatedModeSum.get_waveform_fd
FDInterpolatedModeSum.supported_backends()
FDInterpolatedModeSum.module_references()
FDInterpolatedModeSum.sum()
FDInterpolatedModeSum.CPU_ONLY()
FDInterpolatedModeSum.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
FDInterpolatedModeSum.GPU_ONLY()
FDInterpolatedModeSum.GPU_RECOMMENDED()
FDInterpolatedModeSum.__call__()
FDInterpolatedModeSum.adapt_backend_kwargs()
FDInterpolatedModeSum.backend
FDInterpolatedModeSum.backend_name
FDInterpolatedModeSum.background
FDInterpolatedModeSum.build_with_same_backend()
FDInterpolatedModeSum.citation()
FDInterpolatedModeSum.descriptor
FDInterpolatedModeSum.frame
FDInterpolatedModeSum.needs_Y
FDInterpolatedModeSum.sanity_check_init()
FDInterpolatedModeSum.sanity_check_traj()
FDInterpolatedModeSum.sanity_check_viewing_angles()
FDInterpolatedModeSum.xp
FDInterpolatedModeSum.ndim
FDInterpolatedModeSum.lmax
FDInterpolatedModeSum.nmax
FDInterpolatedModeSum.num_modes
FDInterpolatedModeSum.num_teuk_modes
FDInterpolatedModeSum.m0sort
FDInterpolatedModeSum.l_arr_no_mask
FDInterpolatedModeSum.m_arr_no_mask
FDInterpolatedModeSum.n_arr_no_mask
FDInterpolatedModeSum.lmn_indices
FDInterpolatedModeSum.m0mask
FDInterpolatedModeSum.num_m_zero_up
FDInterpolatedModeSum.num_m0
FDInterpolatedModeSum.num_m_1_up
FDInterpolatedModeSum.l_arr
FDInterpolatedModeSum.m_arr
FDInterpolatedModeSum.n_arr
FDInterpolatedModeSum.m_zero_up_mask
FDInterpolatedModeSum.unique_l
FDInterpolatedModeSum.unique_m
FDInterpolatedModeSum.num_unique_lm
FDInterpolatedModeSum.index_map
FDInterpolatedModeSum.special_index_map
FDInterpolatedModeSum.index_map_arr
FDInterpolatedModeSum.special_index_map_arr
- Direct Summation
DirectModeSum
DirectModeSum.supported_backends()
DirectModeSum.sum()
DirectModeSum.CPU_ONLY()
DirectModeSum.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
DirectModeSum.GPU_ONLY()
DirectModeSum.GPU_RECOMMENDED()
DirectModeSum.__call__()
DirectModeSum.adapt_backend_kwargs()
DirectModeSum.backend
DirectModeSum.backend_name
DirectModeSum.build_with_same_backend()
DirectModeSum.citation()
DirectModeSum.module_references()
DirectModeSum.xp
- AAK Summation / Waveform Generator
AAKSummation
AAKSummation.waveform_generator
AAKSummation.supported_backends()
AAKSummation.sum()
AAKSummation.CPU_ONLY()
AAKSummation.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
AAKSummation.GPU_ONLY()
AAKSummation.GPU_RECOMMENDED()
AAKSummation.__call__()
AAKSummation.adapt_backend_kwargs()
AAKSummation.backend
AAKSummation.backend_name
AAKSummation.background
AAKSummation.build_with_same_backend()
AAKSummation.citation()
AAKSummation.descriptor
AAKSummation.frame
AAKSummation.module_references()
AAKSummation.needs_Y
AAKSummation.sanity_check_angles()
AAKSummation.sanity_check_init()
AAKSummation.sanity_check_traj()
AAKSummation.xp
- Configuration options
- Utilities
- Mode Filtering
ModeSelector
ModeSelector.m0mask
ModeSelector.num_m_zero_up
ModeSelector.num_m_1_up
ModeSelector.num_m0
ModeSelector.l_arr
ModeSelector.m_arr
ModeSelector.n_arr
ModeSelector.sensitivity_fn
ModeSelector.include_minus_mkn
ModeSelector.negative_m_flag
ModeSelector.mode_selection_threshold
ModeSelector.supported_backends()
ModeSelector.is_predictive
ModeSelector.__call__()
ModeSelector.CPU_ONLY()
ModeSelector.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
ModeSelector.GPU_ONLY()
ModeSelector.GPU_RECOMMENDED()
ModeSelector.adapt_backend_kwargs()
ModeSelector.backend
ModeSelector.backend_name
ModeSelector.build_with_same_backend()
ModeSelector.citation()
ModeSelector.module_references()
ModeSelector.xp
NeuralModeSelector
NeuralModeSelector.CPU_ONLY()
NeuralModeSelector.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
NeuralModeSelector.GPU_ONLY()
NeuralModeSelector.GPU_RECOMMENDED()
NeuralModeSelector.adapt_backend_kwargs()
NeuralModeSelector.backend
NeuralModeSelector.backend_name
NeuralModeSelector.build_with_same_backend()
NeuralModeSelector.citation()
NeuralModeSelector.module_references()
NeuralModeSelector.xp
NeuralModeSelector.supported_backends()
NeuralModeSelector.is_predictive
NeuralModeSelector.__call__()
- (-2) Spin-Weighted Spherical Harmonics
GetYlms
GetYlms.supported_backends()
GetYlms.__call__()
GetYlms.CPU_ONLY()
GetYlms.CPU_RECOMMENDED_WITH_GPU_SUPPORT()
GetYlms.GPU_ONLY()
GetYlms.GPU_RECOMMENDED()
GetYlms.adapt_backend_kwargs()
GetYlms.backend
GetYlms.backend_name
GetYlms.build_with_same_backend()
GetYlms.citation()
GetYlms.module_references()
GetYlms.xp
- Frequency Domain Utilities
- Analysis and Other Tools
- Elliptic integrals (Legendre and Carlson symmetric forms)
- PN Parameter Mapping Utilities
- Mode Filtering
- Installation guide
Tutorial:
- Tutorial: Fast self-forced trajectories
- ODE classes
- Trajectory evaluation
- The EMRIInspiral class
- Trajectory stopping conditions
- Output for a requested time duration
- Output on a requested time grid
- Return trajectory in dimensionless time coordinates
- Integrating trajectories with a fixed time-step
- Evolving trajectories backwards in time
- Setting the integrator error tolerance
- Integrating trajectories in \((E, L, Q)\) coordinates
- Trajectory-related utilities
- User-defined trajectory models
- Tutorial: Rapid Teukolsky mode amplitudes
- EMRI Waveforms in Time and Frequency Domain
- Signal to noise ratio as a function of eccentricity and spin
- Mode Selection
- Mode Summation
- Parallelized Cubic Spline Interpolation
- Spin-weighted spherical harmonics
- Utility Functions
Developer guide:
- Development Environment
- Adding features
- Packaging
- Write documentation
- API Reference
- Citations
- File manager
FileManager
FileManager.storage_dir
FileManager.download_dir
FileManager.options
FileManager.registry
FileManager.build_local_cache()
FileManager.get_tags()
FileManager.try_get_local_file()
FileManager.get_file()
FileManager.try_get_file()
FileManager.prefetch_files_by_list()
FileManager.prefetch_files_by_tag()
FileManager.prefetch_all_files()
FileManager.open()
FileRegistry
- Configuration
- Global state
ConfigurationSetter
ConfigurationSetter.enable_backends()
ConfigurationSetter.set_log_level()
ConfigurationSetter.set_storage_path()
ConfigurationSetter.set_log_format()
ConfigurationSetter.set_file_registry_path()
ConfigurationSetter.set_file_download_path()
ConfigurationSetter.enable_file_download()
ConfigurationSetter.disable_file_download()
ConfigurationSetter.set_file_integrity_check()
ConfigurationSetter.disable_file_tags()
ConfigurationSetter.add_file_extra_paths()
ConfigurationSetter.get_args()
ConfigurationSetter.finalize()
get_logger()
get_file_manager()
get_config()
get_config_setter()
get_backend()
get_first_backend()
has_backend()
initialize()
General Information: