lisaanalysistools 1.0.2__cp312-cp312-macosx_10_9_x86_64.whl → 1.0.4__cp312-cp312-macosx_10_9_x86_64.whl

{lisaanalysistools-1.0.2.dist-info → lisaanalysistools-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lisaanalysistools
-Version: 1.0.2
+Version: 1.0.4
 Home-page: https://github.com/mikekatz04/lisa-on-gpu
 Author: Michael Katz
 Author-email: mikekatz04@gmail.com
@@ -18,8 +18,9 @@ License-File: LICENSE
 # LISA Analysis Tools
 
 [![Doc badge](https://img.shields.io/badge/Docs-master-brightgreen)](https://mikekatz04.github.io/LISAanalysistools)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10930980.svg)](https://doi.org/10.5281/zenodo.10930980)
 
-LISA Analysis Tools is a package for performing LISA Data Analysis tasks, including building the LISA Global Fit. 
+LISA Analysis Tools is a package for performing LISA Data Analysis tasks, including building the LISA Global Fit.  
 
 ## 1 - Getting Started
 
@@ -59,16 +60,15 @@ Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduc
 
 We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/BlackHolePerturbationToolkit/FastEMRIWaveforms/tags).
 
-Current Version: 1.0.2
+Current Version: 1.0.4
 
 ## Authors/Developers
 
 * **Michael Katz**
-
-### Contibutors
-
 * Lorenzo Speri
 * Christian Chapman-Bird
+* Natalia Korsakova
+* Nikos Karnesis
 
 ## License
 
@@ -76,5 +76,20 @@ This project is licensed under the Apache License - see the [LICENSE.md](LICENSE
 
 ## Citation
 
-TODO.
+```
+@software{michael_katz_2024_10930980,
+  author       = {Michael Katz and
+                  CChapmanbird and
+                  Lorenzo Speri and
+                  Nikolaos Karnesis and
+                  Korsakova, Natalia},
+  title        = {mikekatz04/LISAanalysistools: First main release.},
+  month        = apr,
+  year         = 2024,
+  publisher    = {Zenodo},
+  version      = {v1.0.3},
+  doi          = {10.5281/zenodo.10930980},
+  url          = {https://doi.org/10.5281/zenodo.10930980}
+}
+```
 

{lisaanalysistools-1.0.2.dist-info → lisaanalysistools-1.0.4.dist-info}/RECORD

@@ -1,16 +1,16 @@
 lisatools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lisatools/_version.py,sha256=deQ7mveodnSkIp1gTJM0VfFR2eczJFUm4STvvmnmvZ4,123
-lisatools/analysiscontainer.py,sha256=KG1Iww3iYHyeoKYgfASqQ2Lu2VilXuW9zDW1Jkw5ARc,15329
-lisatools/datacontainer.py,sha256=MErM0cWZdxVtbaA8HTU79bXmxv2XcYDcqPiHyPbPZE0,9224
-lisatools/detector.py,sha256=VqOhvzG3RiG8o7AX9Q9123WYuRNl7Leq_6oBzenRZOU,12183
-lisatools/diagnostic.py,sha256=oPMovelkyTYUXQWzLvtZB-nia-oxYhlNIci4P2r0Bhg,34177
+lisatools/_version.py,sha256=ZyRiY_EiNuQjMpqN7rHllKpqA3B9m-CTwI9pWBKukog,123
+lisatools/analysiscontainer.py,sha256=ePwTBUTEBJn2TK93_afARate9SAqUKK8c8T6DcGUx1Y,15321
+lisatools/datacontainer.py,sha256=W89ErPJynfeioZwYqcpehHVorhKsb8FLKrj69zIsKKU,9187
+lisatools/detector.py,sha256=Ht5v-Iq_DJlCWMt9iSbZwmEwTGwd3pdeOaw4lBtmiBQ,13852
+lisatools/diagnostic.py,sha256=CfPpfvDys1XyZRWmmTqTSWb0SY2eH0G_8TRnt1OxBFo,34174
 lisatools/glitch.py,sha256=qMNSqdmGqdm6kVtZP9qncP_40DyPj9ushbXh88g9wlU,5154
-lisatools/sensitivity.py,sha256=4ELRfrB5CY7Fkg6LYuuseTdbqnx59My0i7cGvK2VxKg,27236
-lisatools/stochastic.py,sha256=XYZpsWiVB8Yz9V5-_hAKjzOfqe8e5ln0amtWypjqCCg,9440
-lisatools/cutils/detector.cpython-312-darwin.so,sha256=THx-1ysBWhHf54vU10ZyBpQN-38ON7F7IE74FTwvatQ,121664
+lisatools/sensitivity.py,sha256=eYSqM3Kr5UsAhqR3J5DWQBGaavL5dGO1ouWpbhMwhao,27263
+lisatools/stochastic.py,sha256=wdiToEj4nUpCDIb0j7vQ7netTPDDtPGPbUg8-RiFA9U,9421
+lisatools/cutils/detector.cpython-312-darwin.so,sha256=FguczB3QPZfL3CCSMEuIx3VP0jj240_Dh30anER84m8,121664
 lisatools/sampling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lisatools/sampling/likelihood.py,sha256=G2kAQ43qlhAzIFWvYsrSmHXd7WKJAzcCN2o07vRE8vc,29585
-lisatools/sampling/prior.py,sha256=V9sWorxDamgsSFPZpK3t1651yPp6znRVXe0zto0wFpc,18461
+lisatools/sampling/prior.py,sha256=1K1PMStpwO9WT0qG0aotKSyoNjuehXNbzTDtlk8Q15M,21407
 lisatools/sampling/stopping.py,sha256=Q8q7nM0wnJervhRduf2tBXZZHUVza5kJiAUAMUQXP5o,9682
 lisatools/sampling/utility.py,sha256=rOGotS0Aj8-DAWqsTVy2xWNsxsoz74BVrHEnG2mOkwU,14340
 lisatools/sampling/moves/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -29,9 +29,9 @@ lisatools/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lisatools/utils/constants.py,sha256=r1kVwkpbZS13JTOxj2iRxT5sMgTYX30y-S0JdVmD5Oo,1354
 lisatools/utils/multigpudataholder.py,sha256=6HwkOceqga1Q7eK4TjStGXy4oKgx37hTkdcAwiiZ8_Y,33765
 lisatools/utils/pointeradjust.py,sha256=2sT-7qeYWr1pd_sHk9leVHUTSJ7jJgYIRoWQOtYqguE,2995
-lisatools/utils/utility.py,sha256=TgZ4vLVGih4ZU2caMRlK06m8nMoEVvwrS3Q7dH83u1g,6742
-lisaanalysistools-1.0.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lisaanalysistools-1.0.2.dist-info/METADATA,sha256=lZPzQp4QDwR64AUkz4sjKk6pRMmXMYDo4Z1w0DQCCoY,2753
-lisaanalysistools-1.0.2.dist-info/WHEEL,sha256=KYtn_mzb_QwZSHwPlosUO3fDl70znfUFngLlrLVHeBY,111
-lisaanalysistools-1.0.2.dist-info/top_level.txt,sha256=oCQGY7qy66i_b9MCsK2fTRdbV1pcC9GsGgIDjN47Tyc,14
-lisaanalysistools-1.0.2.dist-info/RECORD,,
+lisatools/utils/utility.py,sha256=3mJoJKNGrm3KuNXIa2RUKi9WKd593V4q9XjjQZCQD0M,6831
+lisaanalysistools-1.0.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lisaanalysistools-1.0.4.dist-info/METADATA,sha256=reVoFCjiQuN-XxTsgR7PW_ROH4yQEkWLeQPxF3adDcw,3380
+lisaanalysistools-1.0.4.dist-info/WHEEL,sha256=KYtn_mzb_QwZSHwPlosUO3fDl70znfUFngLlrLVHeBY,111
+lisaanalysistools-1.0.4.dist-info/top_level.txt,sha256=oCQGY7qy66i_b9MCsK2fTRdbV1pcC9GsGgIDjN47Tyc,14
+lisaanalysistools-1.0.4.dist-info/RECORD,,

lisatools/_version.py

@@ -1,4 +1,4 @@
-__version__ = '1.0.2'
+__version__ = '1.0.4'
 __copyright__ = "Michael L. Katz 2024"
 __name__ = "lisaanalysistools"
 __author__ = "Michael L. Katz"

lisatools/analysiscontainer.py

@@ -1,13 +1,17 @@
+from __future__ import annotations
+
+
 import warnings
 from abc import ABC
 from typing import Any, Tuple, Optional, List
 
 import math
 import numpy as np
-from numpy.typing import ArrayLike
+
 from scipy import interpolate
 import matplotlib.pyplot as plt
 
+
 try:
     import cupy as cp
 
@@ -209,7 +213,7 @@ class AnalysisContainer:
         template: DataResidualArray,
         include_psd_info: bool = False,
         phase_maximize: bool = False,
-        **kwargs: dict
+        **kwargs: dict,
     ) -> float:
         """Calculate the Likelihood of a template against the data.
 
@@ -268,7 +272,7 @@ class AnalysisContainer:
             return noise_likelihood_term(self.sens_mat)
         elif source_only:
             return residual_source_likelihood_term(
-                self.data_res_arr, self.sens_mat, **kwargs
+                self.data_res_arr, psd=self.sens_mat, **kwargs
             )
         else:
             return residual_full_source_and_noise_likelihood(
@@ -278,11 +282,11 @@ class AnalysisContainer:
     def _calculate_signal_operation(
         self,
         calc: str,
-        *args: ArrayLike,
+        *args: Any,
         source_only: bool = False,
         waveform_kwargs: Optional[dict] = {},
         data_res_arr_kwargs: Optional[dict] = {},
-        **kwargs: dict
+        **kwargs: dict,
     ) -> float | complex:
         """Return the likelihood of a generated signal with the data.
 
@@ -328,11 +332,11 @@ class AnalysisContainer:
 
     def calculate_signal_likelihood(
         self,
-        *args: ArrayLike,
+        *args: Any,
         source_only: bool = False,
         waveform_kwargs: Optional[dict] = {},
         data_res_arr_kwargs: Optional[dict] = {},
-        **kwargs: dict
+        **kwargs: dict,
     ) -> float | complex:
         """Return the likelihood of a generated signal with the data.
 
@@ -355,16 +359,16 @@ class AnalysisContainer:
             source_only=source_only,
             waveform_kwargs=waveform_kwargs,
             data_res_arr_kwargs=data_res_arr_kwargs,
-            **kwargs
+            **kwargs,
         )
 
     def calculate_signal_inner_product(
         self,
-        *args: ArrayLike,
+        *args: Any,
         source_only: bool = False,
         waveform_kwargs: Optional[dict] = {},
         data_res_arr_kwargs: Optional[dict] = {},
-        **kwargs: dict
+        **kwargs: dict,
     ) -> float | complex:
         """Return the inner product of a generated signal with the data.
 
@@ -387,16 +391,16 @@ class AnalysisContainer:
             source_only=source_only,
             waveform_kwargs=waveform_kwargs,
             data_res_arr_kwargs=data_res_arr_kwargs,
-            **kwargs
+            **kwargs,
         )
 
     def calculate_signal_snr(
         self,
-        *args: ArrayLike,
+        *args: Any,
         source_only: bool = False,
         waveform_kwargs: Optional[dict] = {},
         data_res_arr_kwargs: Optional[dict] = {},
-        **kwargs: dict
+        **kwargs: dict,
     ) -> Tuple[float, float]:
         """Return the SNR of a generated signal with the data.
 
@@ -419,7 +423,7 @@ class AnalysisContainer:
             source_only=source_only,
             waveform_kwargs=waveform_kwargs,
             data_res_arr_kwargs=data_res_arr_kwargs,
-            **kwargs
+            **kwargs,
         )
 
     def eryn_likelihood_function(self, x, *args, **kwargs):

lisatools/datacontainer.py

@@ -4,7 +4,6 @@ from typing import Any, Tuple, Optional, List
 
 import math
 import numpy as np
-from numpy.typing import ArrayLike
 from scipy import interpolate
 import matplotlib.pyplot as plt
 
@@ -36,7 +35,7 @@ class DataResidualArray:
         sens_mat: Input sensitivity list. The shape of the nested lists should represent the shape of the
             desired matrix. Each entry in the list must be an array, :class:`Sensitivity`-derived object,
             or a string corresponding to the :class:`Sensitivity` object.
-        **sens_kwargs: Keyword arguments to pass to :method:`Sensitivity.get_Sn`.
+        **sens_kwargs: Keyword arguments to pass to :func:`Sensitivity.get_Sn`.
 
     """
 

lisatools/detector.py

@@ -22,7 +22,6 @@ class Orbits(ABC):
     Args:
         filename: File name. File should be in the style of LISAOrbits
 
-
     """
 
     def __init__(self, filename: str) -> None:
@@ -51,6 +50,7 @@ class Orbits(ABC):
         return [int(str(link_i)[1]) for link_i in self.LINKS]
 
     def _setup(self) -> None:
+        """Read in orbital data from file and store."""
         with self.open() as f:
             for key in f.attrs.keys():
                 setattr(self, key + "_base", f.attrs[key])
@@ -63,22 +63,33 @@ class Orbits(ABC):
     @filename.setter
     def filename(self, filename: str) -> None:
         """Set file name."""
+
         assert isinstance(filename, str)
+
+        # get path
         path_to_this_file = __file__.split("detector.py")[0]
+
+        # make sure orbit_files directory exists in the right place
         if not os.path.exists(path_to_this_file + "orbit_files/"):
             os.mkdir(path_to_this_file + "orbit_files/")
         path_to_this_file = path_to_this_file + "orbit_files/"
+
         if not os.path.exists(path_to_this_file + filename):
+            # download files from github if they are not there
             github_file = f"https://github.com/mikekatz04/LISAanalysistools/raw/main/lisatools/orbit_files/{filename}"
             r = requests.get(github_file)
+
+            # if not success
             if r.status_code != 200:
                 raise ValueError(
                     f"Cannot find {filename} within default files located at github.com/mikekatz04/LISAanalysistools/lisatools/orbit_files/."
                 )
 
+            # write the contents to a local file
             with open(path_to_this_file + filename, "wb") as f:
                 f.write(r.content)
 
+        # store
         self._filename = path_to_this_file + filename
 
     def open(self) -> h5py.File:
@@ -96,7 +107,7 @@ class Orbits(ABC):
 
     @property
     def t_base(self) -> np.ndarray:
-        """Light travel times along links from file."""
+        """Time array from file."""
         with self.open() as f:
             t_base = np.arange(self.size_base) * self.dt_base
         return t_base
@@ -117,14 +128,14 @@ class Orbits(ABC):
 
     @property
     def x_base(self) -> np.ndarray:
-        """Light travel times along links from file."""
+        """Spacecraft position from file."""
         with self.open() as f:
             x = f["tcb"]["x"][:]
         return x
 
     @property
     def v_base(self) -> np.ndarray:
-        """Light travel times along links from file."""
+        """Spacecraft velocities from file."""
         with self.open() as f:
             v = f["tcb"]["v"][:]
         return v
@@ -154,35 +165,35 @@ class Orbits(ABC):
 
     @property
     def n(self) -> np.ndarray:
-        """Light travel time."""
+        """Normal vectors along links."""
         self._check_configured()
         return self._n
 
     @n.setter
     def n(self, n: np.ndarray) -> np.ndarray:
-        """Set light travel time."""
+        """Set Normal vectors along links."""
         return self._n
 
     @property
     def x(self) -> np.ndarray:
-        """Light travel time."""
+        """Spacecraft positions."""
         self._check_configured()
         return self._x
 
     @x.setter
     def x(self, x: np.ndarray) -> np.ndarray:
-        """Set light travel time."""
+        """Set Spacecraft positions."""
         return self._x
 
     @property
     def v(self) -> np.ndarray:
-        """Light travel time."""
+        """Spacecraft velocities."""
         self._check_configured()
         return self._v
 
     @v.setter
     def v(self, v: np.ndarray) -> np.ndarray:
-        """Set light travel time."""
+        """Set Spacecraft velocities."""
         return self._v
 
     def configure(
@@ -290,6 +301,7 @@ class Orbits(ABC):
 
     @property
     def pycppdetector_args(self) -> tuple:
+        """args for the c++ class."""
         return self._pycppdetector_args
 
     @pycppdetector_args.setter
@@ -311,30 +323,81 @@ class Orbits(ABC):
     def get_light_travel_times(
         self, t: float | np.ndarray, link: int
     ) -> float | np.ndarray:
+        """Compute light travel time as a function of time.
+
+        Computes with the c++ backend.
+
+        Args:
+            t: Time array in seconds.
+            link: which link. Must be ``in self.LINKS``.
+
+        Returns:
+            Light travel times.
+
+        """
         return self.pycppdetector.get_light_travel_time(t, link)
 
     def get_normal_unit_vec(self, t: float | np.ndarray, link: int) -> np.ndarray:
+        """Compute link normal vector as a function of time.
+
+        Computes with the c++ backend.
+
+        Args:
+            t: Time array in seconds.
+            link: which link. Must be ``in self.LINKS``.
+
+        Returns:
+            Link normal vectors.
+
+        """
         return self.pycppdetector.get_normal_unit_vec(t, link)
 
     def get_pos(self, t: float | np.ndarray, sc: int) -> np.ndarray:
+        """Compute spacecraft position as a function of time.
+
+        Computes with the c++ backend.
+
+        Args:
+            t: Time array in seconds.
+            sc: which spacecraft. Must be ``in self.SC``.
+
+        Returns:
+            Spacecraft positions.
+
+        """
         return self.pycppdetector.get_pos(t, sc)
 
     @property
     def ptr(self) -> int:
-        """pointer to c-class"""
+        """pointer to c++ class"""
         return self.pycppdetector.ptr
 
 
 class EqualArmlengthOrbits(Orbits):
-    """Equal Armlength Orbits"""
+    """Equal Armlength Orbits
+
+    Orbit file: equalarmlength-orbits.h5
+
+    """
 
     def __init__(self):
-        # TODO: fix this up
         super().__init__("equalarmlength-orbits.h5")
 
 
+class ESAOrbits(Orbits):
+    """ESA Orbits
+
+    Orbit file: esa-trailing-orbits.h5
+
+    """
+
+    def __init__(self):
+        # TODO: fix this up
+        super().__init__("esa-trailing-orbits.h5")
+
+
 class DefaultOrbits(EqualArmlengthOrbits):
-    """Set default orbit class to Equal Arm Length orbits for now."""
+    """Set default orbit class to Equal Armlength orbits for now."""
 
     pass
 
@@ -343,11 +406,10 @@ class DefaultOrbits(EqualArmlengthOrbits):
 class LISAModelSettings:
     """Required LISA model settings:
 
-    TODO: rename these
-
     Args:
         Soms_d: OMS displacement noise.
         Sa_a: Acceleration noise.
+        orbits: Orbital information.
         name: Name of model.
 
     """
@@ -359,7 +421,16 @@ class LISAModelSettings:
 
 
 class LISAModel(LISAModelSettings, ABC):
-    """Model for the LISA Constellation"""
+    """Model for the LISA Constellation
+
+    This includes sensitivity information computed in
+    :module:`lisatools.sensitivity` and orbital information
+    contained in an :class:`Orbits` class object.
+
+    This class is used to house high-level methods useful
+    to various needed computations.
+
+    """
 
     def __str__(self) -> str:
         out = "LISA Constellation Configurations Settings:\n"
@@ -368,6 +439,7 @@ class LISAModel(LISAModelSettings, ABC):
         return out
 
 
+# defaults
 scirdv1 = LISAModel((15.0e-12) ** 2, (3.0e-15) ** 2, DefaultOrbits(), "scirdv1")
 proposal = LISAModel((10.0e-12) ** 2, (3.0e-15) ** 2, DefaultOrbits(), "proposal")
 mrdv1 = LISAModel((10.0e-12) ** 2, (2.4e-15) ** 2, DefaultOrbits(), "mrdv1")

lisatools/diagnostic.py

@@ -2,7 +2,6 @@ import warnings
 from types import ModuleType, NoneType
 from typing import Optional, Any, Tuple, List
 
-from numpy.typing import ArrayLike
 import matplotlib.pyplot as plt
 
 from eryn.utils import TransformContainer
@@ -387,7 +386,7 @@ def snr(
 def h_var_p_eps(
     step: float,
     waveform_model: callable,
-    params: ArrayLike,
+    params: np.ndarray | list,
     index: int,
     parameter_transforms: Optional[TransformContainer] = None,
     waveform_args: Optional[tuple] = (),
@@ -499,8 +498,8 @@ def dh_dlambda(
 def info_matrix(
     eps: float | np.ndarray,
     waveform_model: callable,
-    params: ArrayLike,
-    deriv_inds: Optional[ArrayLike] = None,
+    params: np.ndarray | list,
+    deriv_inds: Optional[np.ndarray | list] = None,
     inner_product_kwargs: Optional[dict] = {},
     return_derivs: Optional[bool] = False,
     **kwargs: dict,
@@ -793,7 +792,7 @@ def cutler_vallisneri_bias(
     eps: float | np.ndarray,
     input_diagnostics: Optional[dict] = None,
     info_mat: Optional[np.ndarray] = None,
-    deriv_inds: Optional[ArrayLike] = None,
+    deriv_inds: Optional[np.ndarray | list] = None,
     return_derivs: Optional[bool] = False,
     return_cov: Optional[bool] = False,
     parameter_transforms: Optional[TransformContainer] = None,

lisatools/sampling/prior.py

@@ -8,7 +8,10 @@ from eryn.moves.multipletry import logsumexp
 from typing import Union, Optional, Tuple, List
 
 import sys
-sys.path.append("/data/mkatz/LISAanalysistools/lisaflow/flow/experiments/rvs/gf_search/")
+
+sys.path.append(
+    "/data/mkatz/LISAanalysistools/lisaflow/flow/experiments/rvs/gf_search/"
+)
 # from galaxy_ffdot import GalaxyFFdot
 # from galaxy import Galaxy
 
@@ -18,17 +21,20 @@ try:
 except (ModuleNotFoundError, ImportError) as e:
     pass
 
+
 class AmplitudeFrequencySNRPrior:
-    def __init__(self, rho_star, frequency_prior, L, Tobs, use_cupy=False, **noise_kwargs):
+    def __init__(
+        self, rho_star, frequency_prior, L, Tobs, use_cupy=False, **noise_kwargs
+    ):
         self.rho_star = rho_star
         self.frequency_prior = frequency_prior
 
         self.transform = AmplitudeFromSNR(L, Tobs, use_cupy=use_cupy, **noise_kwargs)
         self.snr_prior = SNRPrior(rho_star, use_cupy=use_cupy)
-        
+
         # must be after transform and snr_prior due to setter
         self.use_cupy = use_cupy
-        
+
     @property
     def use_cupy(self):
         return self._use_cupy
@@ -70,7 +76,7 @@ class AmplitudeFrequencySNRPrior:
         else:
             f0_ms = f0_input
             assert f0_input.shape[:-1] == size
-        
+
         f0 = f0_ms / 1e3
 
         rho = self.snr_prior.rvs(size=size)
@@ -80,10 +86,6 @@ class AmplitudeFrequencySNRPrior:
         return (amp, f0_ms)
 
 
-
-
-
-
 class SNRPrior:
     def __init__(self, rho_star, use_cupy=False):
         self.rho_star = rho_star
@@ -98,12 +100,16 @@ class SNRPrior:
         self._use_cupy = use_cupy
 
     def pdf(self, rho):
-        
+
         xp = np if not self.use_cupy else cp
 
         p = xp.zeros_like(rho)
         good = rho > 0.0
-        p[good] = 3 * rho[good] / (4 * self.rho_star ** 2 * (1 + rho[good] / (4 * self.rho_star)) ** 5)
+        p[good] = (
+            3
+            * rho[good]
+            / (4 * self.rho_star**2 * (1 + rho[good] / (4 * self.rho_star)) ** 5)
+        )
         return p
 
     def logpdf(self, rho):
@@ -114,7 +120,15 @@ class SNRPrior:
         xp = np if not self.use_cupy else cp
         c = xp.zeros_like(rho)
         good = rho > 0.0
-        c[good] = 768 * self.rho_star ** 3 * (1 / (768. * self.rho_star ** 3) - (rho[good] + self.rho_star)/(3. * (rho[good] + 4 * self.rho_star) ** 4))
+        c[good] = (
+            768
+            * self.rho_star**3
+            * (
+                1 / (768.0 * self.rho_star**3)
+                - (rho[good] + self.rho_star)
+                / (3.0 * (rho[good] + 4 * self.rho_star) ** 4)
+            )
+        )
         return c
 
     def rvs(self, size=1):
@@ -125,49 +139,125 @@ class SNRPrior:
 
         u = xp.random.rand(*size)
 
-        rho = (-4*self.rho_star + xp.sqrt(-32*self.rho_star**2 - (32*(-self.rho_star**2 + u*self.rho_star**2))/(1 - u) + 
-      (3072*2**0.3333333333333333*xp.cbrt(-1 + 3*u - 3*u**2 + u**3)*
-         (self.rho_star**4 - u*self.rho_star**4))/
-       ((-1 + u)**2*xp.cbrt(-1769472*self.rho_star**6 + 1769472*u*self.rho_star**6 - 
-            xp.sqrt(3131031158784*u*self.rho_star**12 - 6262062317568*u**2*self.rho_star**12 + 
-              3131031158784*u**3*self.rho_star**12))) + 
-      xp.cbrt(-1769472*self.rho_star**6 + 1769472*u*self.rho_star**6 - 
-          xp.sqrt(3131031158784*u*self.rho_star**12 - 6262062317568*u**2*self.rho_star**12 + 
-            3131031158784*u**3*self.rho_star**12))/
-       (3.*2**0.3333333333333333*xp.cbrt(-1 + 3*u - 3*u**2 + u**3)))/2.
-     + xp.sqrt(32*self.rho_star**2 + (32*(-self.rho_star**2 + u*self.rho_star**2))/(1 - u) - 
-      (3072*2**0.3333333333333333*xp.cbrt(-1 + 3*u - 3*u**2 + u**3)*
-         (self.rho_star**4 - u*self.rho_star**4))/
-       ((-1 + u)**2*xp.cbrt(-1769472*self.rho_star**6 + 1769472*u*self.rho_star**6 - 
-            xp.sqrt(3131031158784*u*self.rho_star**12 - 6262062317568*u**2*self.rho_star**12 + 
-              3131031158784*u**3*self.rho_star**12))) - 
-      xp.cbrt(-1769472*self.rho_star**6 + 1769472*u*self.rho_star**6 - 
-          xp.sqrt(3131031158784*u*self.rho_star**12 - 6262062317568*u**2*self.rho_star**12 + 
-            3131031158784*u**3*self.rho_star**12))/
-       (3.*2**0.3333333333333333*xp.cbrt(-1 + 3*u - 3*u**2 + u**3)) + 
-      (2048*self.rho_star**3 - (2048*u*self.rho_star**3)/(-1 + u))/
-       (4.*xp.sqrt(-32*self.rho_star**2 - (32*(-self.rho_star**2 + u*self.rho_star**2))/(1 - u) + 
-           (3072*2**0.3333333333333333*
-              xp.cbrt(-1 + 3*u - 3*u**2 + u**3)*(self.rho_star**4 - u*self.rho_star**4)
-              )/
-            ((-1 + u)**2*xp.cbrt(-1769472*self.rho_star**6 + 1769472*u*self.rho_star**6 - 
-                 xp.sqrt(3131031158784*u*self.rho_star**12 - 6262062317568*u**2*self.rho_star**12 + 
-                   3131031158784*u**3*self.rho_star**12))) + 
-           xp.cbrt(-1769472*self.rho_star**6 + 1769472*u*self.rho_star**6 - 
-               xp.sqrt(3131031158784*u*self.rho_star**12 - 6262062317568*u**2*self.rho_star**12 + 
-                 3131031158784*u**3*self.rho_star**12))/
-            (3.*2**0.3333333333333333*
-              xp.cbrt(-1 + 3*u - 3*u**2 + u**3)))))/2.)
+        rho = (
+            -4 * self.rho_star
+            + xp.sqrt(
+                -32 * self.rho_star**2
+                - (32 * (-self.rho_star**2 + u * self.rho_star**2)) / (1 - u)
+                + (
+                    3072
+                    * 2**0.3333333333333333
+                    * xp.cbrt(-1 + 3 * u - 3 * u**2 + u**3)
+                    * (self.rho_star**4 - u * self.rho_star**4)
+                )
+                / (
+                    (-1 + u) ** 2
+                    * xp.cbrt(
+                        -1769472 * self.rho_star**6
+                        + 1769472 * u * self.rho_star**6
+                        - xp.sqrt(
+                            3131031158784 * u * self.rho_star**12
+                            - 6262062317568 * u**2 * self.rho_star**12
+                            + 3131031158784 * u**3 * self.rho_star**12
+                        )
+                    )
+                )
+                + xp.cbrt(
+                    -1769472 * self.rho_star**6
+                    + 1769472 * u * self.rho_star**6
+                    - xp.sqrt(
+                        3131031158784 * u * self.rho_star**12
+                        - 6262062317568 * u**2 * self.rho_star**12
+                        + 3131031158784 * u**3 * self.rho_star**12
+                    )
+                )
+                / (3.0 * 2**0.3333333333333333 * xp.cbrt(-1 + 3 * u - 3 * u**2 + u**3))
+            )
+            / 2.0
+            + xp.sqrt(
+                32 * self.rho_star**2
+                + (32 * (-self.rho_star**2 + u * self.rho_star**2)) / (1 - u)
+                - (
+                    3072
+                    * 2**0.3333333333333333
+                    * xp.cbrt(-1 + 3 * u - 3 * u**2 + u**3)
+                    * (self.rho_star**4 - u * self.rho_star**4)
+                )
+                / (
+                    (-1 + u) ** 2
+                    * xp.cbrt(
+                        -1769472 * self.rho_star**6
+                        + 1769472 * u * self.rho_star**6
+                        - xp.sqrt(
+                            3131031158784 * u * self.rho_star**12
+                            - 6262062317568 * u**2 * self.rho_star**12
+                            + 3131031158784 * u**3 * self.rho_star**12
+                        )
+                    )
+                )
+                - xp.cbrt(
+                    -1769472 * self.rho_star**6
+                    + 1769472 * u * self.rho_star**6
+                    - xp.sqrt(
+                        3131031158784 * u * self.rho_star**12
+                        - 6262062317568 * u**2 * self.rho_star**12
+                        + 3131031158784 * u**3 * self.rho_star**12
+                    )
+                )
+                / (3.0 * 2**0.3333333333333333 * xp.cbrt(-1 + 3 * u - 3 * u**2 + u**3))
+                + (2048 * self.rho_star**3 - (2048 * u * self.rho_star**3) / (-1 + u))
+                / (
+                    4.0
+                    * xp.sqrt(
+                        -32 * self.rho_star**2
+                        - (32 * (-self.rho_star**2 + u * self.rho_star**2)) / (1 - u)
+                        + (
+                            3072
+                            * 2**0.3333333333333333
+                            * xp.cbrt(-1 + 3 * u - 3 * u**2 + u**3)
+                            * (self.rho_star**4 - u * self.rho_star**4)
+                        )
+                        / (
+                            (-1 + u) ** 2
+                            * xp.cbrt(
+                                -1769472 * self.rho_star**6
+                                + 1769472 * u * self.rho_star**6
+                                - xp.sqrt(
+                                    3131031158784 * u * self.rho_star**12
+                                    - 6262062317568 * u**2 * self.rho_star**12
+                                    + 3131031158784 * u**3 * self.rho_star**12
+                                )
+                            )
+                        )
+                        + xp.cbrt(
+                            -1769472 * self.rho_star**6
+                            + 1769472 * u * self.rho_star**6
+                            - xp.sqrt(
+                                3131031158784 * u * self.rho_star**12
+                                - 6262062317568 * u**2 * self.rho_star**12
+                                + 3131031158784 * u**3 * self.rho_star**12
+                            )
+                        )
+                        / (
+                            3.0
+                            * 2**0.3333333333333333
+                            * xp.cbrt(-1 + 3 * u - 3 * u**2 + u**3)
+                        )
+                    )
+                )
+            )
+            / 2.0
+        )
 
         return rho
 
 
 class AmplitudeFromSNR:
     def __init__(self, L, Tobs, fd=None, use_cupy=False, **noise_kwargs):
-        self.f_star = 1 / (2. * np.pi * L) * C_SI
+        self.f_star = 1 / (2.0 * np.pi * L) * C_SI
         self.Tobs = Tobs
         self.noise_kwargs = noise_kwargs
-        
+
         xp = np if not use_cupy else cp
         if fd is not None:
             self.fd = xp.asarray(fd)
@@ -193,7 +283,7 @@ class AmplitudeFromSNR:
         assert self.fd is not None
         xp = np if not self.use_cupy else cp
         psds = xp.atleast_2d(psds)
-        
+
         if xp == cp and not isinstance(self.fd, cp.ndarray):
             self.fd = xp.asarray(self.fd)
         try:
@@ -203,7 +293,9 @@ class AmplitudeFromSNR:
         if walker_inds is None:
             walker_inds = xp.zeros_like(f0, dtype=int)
 
-        new_psds = (psds[(walker_inds, inds_fd + 1)] - psds[(walker_inds, inds_fd)]) / (self.fd[inds_fd + 1] - self.fd[inds_fd]) * (f0 - self.fd[inds_fd]) + psds[(walker_inds, inds_fd)]
+        new_psds = (psds[(walker_inds, inds_fd + 1)] - psds[(walker_inds, inds_fd)]) / (
+            self.fd[inds_fd + 1] - self.fd[inds_fd]
+        ) * (f0 - self.fd[inds_fd]) + psds[(walker_inds, inds_fd)]
         return new_psds
 
     def __call__(self, rho, f0, **noise_kwargs):
@@ -215,7 +307,7 @@ class AmplitudeFromSNR:
 
         Sn_f = self.get_Sn_f(f0, **noise_kwargs)
 
-        factor = 1./2. * np.sqrt((self.Tobs * np.sin(f0 / self.f_star) ** 2) / Sn_f)
+        factor = 1.0 / 2.0 * np.sqrt((self.Tobs * np.sin(f0 / self.f_star) ** 2) / Sn_f)
         amp = rho / factor
         return (amp, f0)
 
@@ -238,7 +330,7 @@ class AmplitudeFromSNR:
 
         Sn_f = self.get_Sn_f(f0, **noise_kwargs)
 
-        factor = 1./2. * np.sqrt((self.Tobs * np.sin(f0 / self.f_star) ** 2) / Sn_f)
+        factor = 1.0 / 2.0 * np.sqrt((self.Tobs * np.sin(f0 / self.f_star) ** 2) / Sn_f)
         rho = amp * factor
         return (rho, f0)
 
@@ -275,7 +367,7 @@ class GBPriorWrap:
         xp = np if not self.use_cupy else cp
         if isinstance(size, int):
             size = (size,)
-        
+
         arr = xp.zeros(size + (self.ndim,)).reshape(-1, self.ndim)
 
         diff = self.ndim - len(self.keys_sep)
@@ -285,15 +377,35 @@ class GBPriorWrap:
 
         if not ignore_amp:
             f0_input = arr[:, 1] if self.gen_frequency_alone else None
-            arr[:, :diff] = xp.asarray(self.base_prior.priors_in[(0, 1)].rvs(size, f0_input=f0_input, **kwargs)).reshape(diff, -1).T
+            arr[:, :diff] = (
+                xp.asarray(
+                    self.base_prior.priors_in[(0, 1)].rvs(
+                        size, f0_input=f0_input, **kwargs
+                    )
+                )
+                .reshape(diff, -1)
+                .T
+            )
 
         arr = arr.reshape(size + (self.ndim,))
         return arr
 
 
 class FullGaussianMixtureModel:
-    def __init__(self, gb, weights, means, covs, invcovs, dets, mins, maxs, limit=10.0, use_cupy=False):
-        
+    def __init__(
+        self,
+        gb,
+        weights,
+        means,
+        covs,
+        invcovs,
+        dets,
+        mins,
+        maxs,
+        limit=10.0,
+        use_cupy=False,
+    ):
+
         self.use_cupy = use_cupy
         if use_cupy:
             xp = cp
@@ -306,7 +418,7 @@ class FullGaussianMixtureModel:
         for i, weight in enumerate(weights):
             index_base = np.full_like(weight, i, dtype=int)
             indexing.append(index_base)
-        
+
         self.indexing = xp.asarray(np.concatenate(indexing))
         # invidivual weights / total number of components to uniformly choose from them
         self.weights = xp.asarray(np.concatenate(weights, axis=0) * 1 / len(weights))
@@ -326,19 +438,28 @@ class FullGaussianMixtureModel:
         self.means_in_pdf = self.means.T.flatten().copy()
         self.invcovs_in_pdf = self.invcovs.transpose(1, 2, 0).flatten().copy()
 
-        self.cumulative_weights = xp.concatenate([xp.array([0.0]), xp.cumsum(self.weights)])
+        self.cumulative_weights = xp.concatenate(
+            [xp.array([0.0]), xp.cumsum(self.weights)]
+        )
 
-        self.min_limit_f = self.map_back_frequency(-1. * limit, self.mins[self.indexing, 1], self.maxs[self.indexing, 1]) 
-        self.max_limit_f = self.map_back_frequency(+1. * limit, self.mins[self.indexing, 1], self.maxs[self.indexing, 1]) 
+        self.min_limit_f = self.map_back_frequency(
+            -1.0 * limit, self.mins[self.indexing, 1], self.maxs[self.indexing, 1]
+        )
+        self.max_limit_f = self.map_back_frequency(
+            +1.0 * limit, self.mins[self.indexing, 1], self.maxs[self.indexing, 1]
+        )
 
         # compute the jacobian
-        self.log_det_J = (self.ndim * np.log(2) - xp.sum(xp.log(self.maxs - self.mins), axis=-1))[self.indexing].copy()
+        self.log_det_J = (
+            self.ndim * np.log(2) - xp.sum(xp.log(self.maxs - self.mins), axis=-1)
+        )[self.indexing].copy()
 
         """self.inds_sort_min_limit_f = xp.argsort(self.min_limit_f)
         self.inds_sort_max_limit_f = xp.argsort(self.max_limit_f)
         self.sorted_min_limit_f = self.min_limit_f[self.inds_sort_min_limit_f]
         self.sorted_max_limit_f = self.max_limit_f[self.inds_sort_max_limit_f]
         """
+
     def logpdf(self, x):
 
         if self.use_cupy:
@@ -358,13 +479,15 @@ class FullGaussianMixtureModel:
         ind_min_limit = xp.searchsorted(f_sort, self.min_limit_f, side="left")
         ind_max_limit = xp.searchsorted(f_sort, self.max_limit_f, side="right")
 
-        diff = (ind_max_limit - ind_min_limit)
+        diff = ind_max_limit - ind_min_limit
         cs = xp.concatenate([xp.array([0]), xp.cumsum(diff)])
         tmp = xp.arange(cs[-1])
         keep_component_map = xp.searchsorted(cs, tmp, side="right") - 1
-        keep_point_map = tmp - cs[keep_component_map] + ind_min_limit[keep_component_map]
+        keep_point_map = (
+            tmp - cs[keep_component_map] + ind_min_limit[keep_component_map]
+        )
         max_components = diff.max().item()
-        
+
         int_check = int(1e6)
         assert int_check > self.min_limit_f.shape[0]
         special_point_component_map = int_check * keep_point_map + keep_component_map
@@ -375,20 +498,37 @@ class FullGaussianMixtureModel:
         components_keep_in = sorted_special - points_keep_in * int_check
 
         unique_points, unique_starts = xp.unique(points_keep_in, return_index=True)
-        start_index_in_pdf = xp.concatenate([unique_starts, xp.array([len(points_keep_in)])]).astype(xp.int32)
+        start_index_in_pdf = xp.concatenate(
+            [unique_starts, xp.array([len(points_keep_in)])]
+        ).astype(xp.int32)
         assert xp.all(xp.diff(unique_starts) > 0)
-        
+
         points_sorted_in = points_sorted[unique_points]
 
         logpdf_out_tmp = xp.zeros(points_sorted_in.shape[0])
 
-        self.gb.compute_logpdf(logpdf_out_tmp, components_keep_in.astype(xp.int32), points_sorted_in,
-                    self.weights, self.mins_in_pdf, self.maxs_in_pdf, self.means_in_pdf, self.invcovs_in_pdf, self.dets, self.log_det_J, 
-                    points_sorted_in.shape[0], start_index_in_pdf, self.weights.shape[0], x.shape[1])
+        self.gb.compute_logpdf(
+            logpdf_out_tmp,
+            components_keep_in.astype(xp.int32),
+            points_sorted_in,
+            self.weights,
+            self.mins_in_pdf,
+            self.maxs_in_pdf,
+            self.means_in_pdf,
+            self.invcovs_in_pdf,
+            self.dets,
+            self.log_det_J,
+            points_sorted_in.shape[0],
+            start_index_in_pdf,
+            self.weights.shape[0],
+            x.shape[1],
+        )
 
         # need to reverse the sort
         logpdf_out = xp.full(x.shape[0], -xp.inf)
-        logpdf_out[xp.sort(inds_sort[unique_points])] = logpdf_out_tmp[xp.argsort(inds_sort[unique_points])]
+        logpdf_out[xp.sort(inds_sort[unique_points])] = logpdf_out_tmp[
+            xp.argsort(inds_sort[unique_points])
+        ]
         return logpdf_out
         """# breakpoint()
 
@@ -409,11 +549,11 @@ class FullGaussianMixtureModel:
         return logpdf_full_dist"""
 
     def map_input(self, x, mins, maxs):
-        return ((x - mins) / (maxs - mins)) * 2. - 1.
+        return ((x - mins) / (maxs - mins)) * 2.0 - 1.0
 
     def map_back_frequency(self, x, mins, maxs):
-        return (x + 1.) * 1. / 2. * (maxs - mins) + mins
-        
+        return (x + 1.0) * 1.0 / 2.0 * (maxs - mins) + mins
+
     def rvs(self, size=(1,)):
 
         if isinstance(size, int):
@@ -426,20 +566,26 @@ class FullGaussianMixtureModel:
 
         # choose which component
         draw = xp.random.rand(*size)
-        component = (xp.searchsorted(self.cumulative_weights, draw.flatten(), side="right") - 1).reshape(draw.shape)
+        component = (
+            xp.searchsorted(self.cumulative_weights, draw.flatten(), side="right") - 1
+        ).reshape(draw.shape)
 
         mean_here = self.means[component]
         cov_here = self.covs[component]
 
-        new_points = mean_here + xp.einsum("...kj,...j->...k", cov_here, np.random.randn(*(component.shape + (self.ndim,))))
+        new_points = mean_here + xp.einsum(
+            "...kj,...j->...k",
+            cov_here,
+            np.random.randn(*(component.shape + (self.ndim,))),
+        )
 
         index_here = self.indexing[component]
         mins_here = self.mins[index_here]
         maxs_here = self.maxs[index_here]
         new_points_mapped = self.map_back_frequency(new_points, mins_here, maxs_here)
-        
+
         return new_points_mapped
-        
+
 
 # class FlowDist:
 #     def __init__(self, config: dict, model: Union[Galaxy, GalaxyFFdot], fit: str, ndim: int):
@@ -450,7 +596,7 @@ class FullGaussianMixtureModel:
 #         param_min, param_max = np.loadtxt(fit)
 #         self.dist.set_min(param_min)
 #         self.dist.set_max(param_max)
-        
+
 #         self.config = config
 #         self.fit = fit
 #         self.ndim = ndim
@@ -461,7 +607,7 @@ class FullGaussianMixtureModel:
 
 #         total_samp = int(np.prod(size))
 #         samples = self.dist.sample(total_samp).reshape(size + (self.ndim,))
-#         return samples 
+#         return samples
 
 #     def logpdf(self, x: cp.ndarray) -> cp.ndarray:
 #         assert x.shape[-1] == self.ndim
@@ -498,11 +644,3 @@ class FullGaussianMixtureModel:
 #         fit = '/data/mkatz/LISAanalysistools/lisaflow/flow/experiments/rvs/minmax_ffdot_sangria.txt'
 #         ndim = 2
 #         super().__init__(config, model, fit, ndim)
-        
-    
-
-    
-        
-        
-            
-            

lisatools/sensitivity.py

@@ -5,7 +5,6 @@ from copy import deepcopy
 
 import math
 import numpy as np
-from numpy.typing import ArrayLike
 from scipy import interpolate
 import matplotlib.pyplot as plt
 
@@ -527,17 +526,19 @@ class SensitivityMatrix:
         sens_mat: Input sensitivity list. The shape of the nested lists should represent the shape of the
             desired matrix. Each entry in the list must be an array, :class:`Sensitivity`-derived object,
             or a string corresponding to the :class:`Sensitivity` object.
-        **sens_kwargs: Keyword arguments to pass to :method:`Sensitivity.get_Sn`.
+        **sens_kwargs: Keyword arguments to pass to :func:`Sensitivity.get_Sn`.
 
     """
 
     def __init__(
         self,
         f: np.ndarray,
-        sens_mat: List[List[np.ndarray | Sensitivity]]
-        | List[np.ndarray | Sensitivity]
-        | np.ndarray
-        | Sensitivity,
+        sens_mat: (
+            List[List[np.ndarray | Sensitivity]]
+            | List[np.ndarray | Sensitivity]
+            | np.ndarray
+            | Sensitivity
+        ),
         *sens_args: tuple,
         **sens_kwargs: dict,
     ) -> None:
@@ -598,10 +599,12 @@ class SensitivityMatrix:
     @sens_mat.setter
     def sens_mat(
         self,
-        sens_mat: List[List[np.ndarray | Sensitivity]]
-        | List[np.ndarray | Sensitivity]
-        | np.ndarray
-        | Sensitivity,
+        sens_mat: (
+            List[List[np.ndarray | Sensitivity]]
+            | List[np.ndarray | Sensitivity]
+            | np.ndarray
+            | Sensitivity
+        ),
     ) -> None:
         """Set sensitivity matrix."""
         self.sens_mat_input = deepcopy(sens_mat)
@@ -729,7 +732,7 @@ class XYZ1SensitivityMatrix(SensitivityMatrix):
 
     Args:
         f: Frequency array.
-        **sens_kwargs: Keyword arguments to pass to :method:`Sensitivity.get_Sn`.
+        **sens_kwargs: Keyword arguments to pass to :func:`Sensitivity.get_Sn`.
 
     """
 
@@ -749,7 +752,7 @@ class AET1SensitivityMatrix(SensitivityMatrix):
 
     Args:
         f: Frequency array.
-        **sens_kwargs: Keyword arguments to pass to :method:`Sensitivity.get_Sn`.
+        **sens_kwargs: Keyword arguments to pass to :func:`Sensitivity.get_Sn`.
 
     """
 
@@ -763,7 +766,7 @@ class AE1SensitivityMatrix(SensitivityMatrix):
 
     Args:
         f: Frequency array.
-        **sens_kwargs: Keyword arguments to pass to :method:`Sensitivity.get_Sn`.
+        **sens_kwargs: Keyword arguments to pass to :func:`Sensitivity.get_Sn`.
 
     """
 
@@ -778,7 +781,7 @@ class LISASensSensitivityMatrix(SensitivityMatrix):
     Args:
         f: Frequency array.
         nchannels: Number of channels.
-        **sens_kwargs: Keyword arguments to pass to :method:`Sensitivity.get_Sn`.
+        **sens_kwargs: Keyword arguments to pass to :func:`Sensitivity.get_Sn`.
 
     """
 

lisatools/stochastic.py

@@ -4,7 +4,6 @@ from typing import Any, Tuple, Optional, List, Dict
 
 import math
 import numpy as np
-from numpy.typing import ArrayLike
 from scipy import interpolate
 
 try:
@@ -25,7 +24,7 @@ class StochasticContribution(ABC):
     added_stochastic_list = []
 
     @classmethod
-    def _check_ndim(cls, params: ArrayLike) -> None:
+    def _check_ndim(cls, params: np.ndarray | list) -> None:
         """Check the dimensionality of the parameters matches the model.
 
         Args:
@@ -42,7 +41,7 @@ class StochasticContribution(ABC):
 
     @classmethod
     def get_Sh(
-        cls, f: float | np.ndarray, *params: ArrayLike, **kwargs: Any
+        cls, f: float | np.ndarray, *params: np.ndarray | list, **kwargs: Any
     ) -> float | np.ndarray:
         """Calculate the power spectral density of the stochastic contribution.
 

lisatools/utils/utility.py

@@ -226,9 +226,9 @@ def get_groups_from_band_structure(
     groups_even_odd = xp.sum(groups_even_odd_tmp, axis=0)
 
     groups_out = -2 * xp.ones_like(f0, dtype=int)
-    groups_out[
-        (temp_inds, walker_inds, inds_band_indices.flatten()[keep])
-    ] = groups_even_odd
+    groups_out[(temp_inds, walker_inds, inds_band_indices.flatten()[keep])] = (
+        groups_even_odd
+    )
 
     groups_out[bad] = -1
 
@@ -238,3 +238,9 @@ def get_groups_from_band_structure(
         fix_1 = band_indices[fix]"""
 
     return groups_out
+
+
+autodoc_type_aliases = {
+    "Iterable": "Iterable",
+    "ArrayLike": "ArrayLike",
+}