cows3 0.0.1__tar.gz

cows3-0.0.1/.github/workflows/pypi.yml

@@ -0,0 +1,118 @@
+# Taken from https://packaging.python.org/en/latest/tutorials/packaging-projects/
+name: Publish Python 🐍 distribution 📦 to PyPI and TestPyPI
+
+on: workflow_dispatch
+
+jobs:
+  build:
+    name: Build distribution 📦
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.11"
+    - name: Install pypa/build
+      run: >-
+        python3 -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: python3 -m build
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+
+  publish-to-pypi:
+    name: >-
+      Publish Python 🐍 distribution 📦 to PyPI
+    if: startsWith(github.ref, 'refs/tags/')  # only publish to PyPI on tag pushes
+    needs:
+    - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/foutstep  # Replace <package-name> with your PyPI project name
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution 📦 to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    name: >-
+      Sign the Python 🐍 distribution 📦 with Sigstore
+      and upload them to GitHub Release
+    needs:
+    - publish-to-pypi
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write  # IMPORTANT: mandatory for making GitHub Releases
+      id-token: write  # IMPORTANT: mandatory for sigstore
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Sign the dists with Sigstore
+      uses: sigstore/gh-action-sigstore-python@v2.1.1
+      with:
+        inputs: >-
+          ./dist/*.tar.gz
+          ./dist/*.whl
+    - name: Create GitHub Release
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+      run: >-
+        gh release create
+        '${{ github.ref_name }}'
+        --repo '${{ github.repository }}'
+        --notes ""
+    - name: Upload artifact signatures to GitHub Release
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+      # Upload to GitHub Release using the `gh` CLI.
+      # `dist/` contains the built packages, and the
+      # sigstore-produced signatures and certificates.
+      run: >-
+        gh release upload
+        '${{ github.ref_name }}' dist/**
+        --repo '${{ github.repository }}'
+
+  publish-to-testpypi:
+    name: Publish Python 🐍 distribution 📦 to TestPyPI
+    needs:
+    - build
+    runs-on: ubuntu-latest
+
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/foutstep
+
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution 📦 to TestPyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        repository-url: https://test.pypi.org/legacy/

cows3-0.0.1/.github/workflows/pytest.yml

@@ -0,0 +1,31 @@
+
+name: Run pytest
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.11
+      uses: actions/setup-python@v3
+      with:
+        python-version: "3.11"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pytest .
+    - name: Test with pytest
+      run: |
+        pytest
+        

cows3-0.0.1/.gitignore

@@ -0,0 +1,2 @@
+*egg*
+__pycache__

cows3-0.0.1/LICENSE.md

@@ -0,0 +1,10 @@
+MIT License
+
+Copyright (c) 2024 Rodrigo Tenorio, Lorenzo Mirasola
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

cows3-0.0.1/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.1
+Name: cows3
+Version: 0.0.1
+Summary: Continuous-wave search sensitivity simulator
+Author-email: Rodrigo Tenorio <rodrigo.tenorio.marquez@gmail.com>, Lorenzo Mirasola <lorenzo.mirasola@ca.infn.it>
+License: MIT License
+        
+        Copyright (c) 2024 Rodrigo Tenorio, Lorenzo Mirasola
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+        
+Project-URL: Homepage, https://github.com/Rodrigo-Tenorio/cows3
+Project-URL: Issues, https://github.com/Rodrigo-Tenorio/cows3/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: lalsuite
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: solar_system_ephemerides
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+
+# Continuous-wave search sensitivity simulator (COWS3)
+
+A Python package to estimate the sensitivity of general
+continuous gravitational-wave searches.
+
+The method should be equivalent to the semi-analytical approach derived in
+[Dreissigacker, Prix, Wette (2018)](https://arxiv.org/abs/1808.02459) and
+implemented in [Octapps](https://github.com/octapps/octapps), but here we 
+implement it in Python to make it more convenient to use.
+
+## Citing this work
+
+If COWS3 was useful to your research, we would appreciate if you cited
+[Mirasola & Tenorio (2024)](https://arxiv.org/abs/2405.18934) where this
+implementation was first presented:
+```
+@article{Mirasola:2024lcq,
+    author = "Mirasola, Lorenzo and Tenorio, Rodrigo",
+    title = "{Towards a computationally-efficient follow-up pipeline for blind continuous gravitational-wave searches}",
+    eprint = "2405.18934",
+    archivePrefix = "arXiv",
+    primaryClass = "gr-qc",
+    reportNumber = "LIGO-P2400221",
+    month = "5",
+    year = "2024",
+    journal = "arXiv e-prints"
+}
+```
+as well as a Zenodo release of this software.
+
+For the semi-analytical sensitivity estimation method you should also cite 
+[Wette (2012)](https://arxiv.org/abs/1111.5650) and
+[Dreissigacker, Prix, Wette (2018)](https://arxiv.org/abs/1808.02459). Also,
+this package makes extensive use of SWIG bindings, so please cite
+[Wette (2021)](https://arxiv.org/abs/2012.09552) as well.
+
+
+## Authors
+- Rodrigo Tenorio
+- Lorenzo Mirasola
+
+

cows3-0.0.1/README.md

@@ -0,0 +1,42 @@
+# Continuous-wave search sensitivity simulator (COWS3)
+
+A Python package to estimate the sensitivity of general
+continuous gravitational-wave searches.
+
+The method should be equivalent to the semi-analytical approach derived in
+[Dreissigacker, Prix, Wette (2018)](https://arxiv.org/abs/1808.02459) and
+implemented in [Octapps](https://github.com/octapps/octapps), but here we 
+implement it in Python to make it more convenient to use.
+
+## Citing this work
+
+If COWS3 was useful to your research, we would appreciate if you cited
+[Mirasola & Tenorio (2024)](https://arxiv.org/abs/2405.18934) where this
+implementation was first presented:
+```
+@article{Mirasola:2024lcq,
+    author = "Mirasola, Lorenzo and Tenorio, Rodrigo",
+    title = "{Towards a computationally-efficient follow-up pipeline for blind continuous gravitational-wave searches}",
+    eprint = "2405.18934",
+    archivePrefix = "arXiv",
+    primaryClass = "gr-qc",
+    reportNumber = "LIGO-P2400221",
+    month = "5",
+    year = "2024",
+    journal = "arXiv e-prints"
+}
+```
+as well as a Zenodo release of this software.
+
+For the semi-analytical sensitivity estimation method you should also cite 
+[Wette (2012)](https://arxiv.org/abs/1111.5650) and
+[Dreissigacker, Prix, Wette (2018)](https://arxiv.org/abs/1808.02459). Also,
+this package makes extensive use of SWIG bindings, so please cite
+[Wette (2021)](https://arxiv.org/abs/2012.09552) as well.
+
+
+## Authors
+- Rodrigo Tenorio
+- Lorenzo Mirasola
+
+

cows3-0.0.1/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=64", "setuptools_scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+authors = [
+    {name = "Rodrigo Tenorio", email = "rodrigo.tenorio.marquez@gmail.com"},
+    {name = "Lorenzo Mirasola", email = "lorenzo.mirasola@ca.infn.it"},
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Scientific/Engineering :: Astronomy",
+    "Topic :: Scientific/Engineering :: Physics"
+]
+dependencies = [
+    "lalsuite",
+    "numpy",
+    "scipy",
+    "solar_system_ephemerides",
+]
+description = "Continuous-wave search sensitivity simulator"
+dynamic = ["version"]
+license = {file = "LICENSE.md"}
+name = "cows3"
+readme = "README.md"
+requires-python = ">=3.11"
+
+[project.optional-dependencies]
+dev = [
+    "black", 
+    "flake8", 
+    "pytest"
+]
+
+[project.urls]
+Homepage = "https://github.com/Rodrigo-Tenorio/cows3"
+Issues = "https://github.com/Rodrigo-Tenorio/cows3/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["cows3"]
+
+[tool.setuptools_scm]
+
+[tool.pytest.ini_options]
+log_cli = true
+log_cli_level = "DEBUG"
+log_file_level = "DEBUG"
+

cows3-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cows3-0.0.1/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup()

cows3-0.0.1/src/cows3/detectorstates.py

@@ -0,0 +1,143 @@
+import logging
+
+import lal
+import lalpulsar
+import numpy as np
+
+from .ephemeris import DEFAULT_EPHEMERIS
+
+logger = logging.getLogger(__name__)
+
+
+class MultiDetectorStates:
+    """
+    Python interface to `XLALGetMultiDetectorStates` and
+    `XLALGetMultiDetectorStatesFromMultiSFTs`.
+
+    Parameters
+    ----------
+    timestamps:
+        Dictionary containing the GPS timestamps at which detector
+        states will be retrieved.
+        Keys MUST be two-character detector names as described in LALSuite;
+        values MUST be numpy arrays containing the timestamps.
+        E.g. for an observing run from GPS 1 to GPS 5 using LIGO Hanford
+        and LIGO Livingston:
+        ```
+        timestamps = {
+            "H1": np.array([1, 2, 3, 4, 5]),
+            "L1": np.array([1, 2, 3, 4, 5])
+        }
+        ```
+    T_sft:
+        Time period covered for each timestamp. Does not need to coincide
+        with the separation between consecutive timestamps. It will be floored
+        using `int`.
+    t_offset:
+        Time offset with respect to the timestamp at which the detector
+        state will be retrieved. Defaults to LALSuite's behaviour.
+    ephemeris:
+        Default uses `solar_system_ephemerides` to get lalsuite's default.
+    """
+
+    def __init__(
+        self,
+        timestamps: dict[str, np.array],
+        T_sft: int,
+        t_offset: int | None = None,
+        ephemeris: lalpulsar.EphemerisData = DEFAULT_EPHEMERIS,
+    ):
+        self.timestamps = timestamps
+        self.T_sft = T_sft
+        self.t_offset = t_offset
+        self.ephemeris = ephemeris
+
+    @property
+    def Series(self) -> lalpulsar.MultiDetectorStateSeries:
+        """
+        Return lalpulsar.MultiDetectorStateSeries constructed using the instance's attributes.
+        """
+        return lalpulsar.GetMultiDetectorStates(
+            multiTS=self.multi_timestamps,
+            multiIFO=self.multi_lal_detector,
+            edat=self.ephemeris,
+            tOffset=self.t_offset,
+        )
+
+    @property
+    def velocities(self) -> dict[str, np.ndarray]:
+        """
+        Extracts detector velocity vectors into numpy arrays.
+
+        Returns
+        -------
+        velocities:
+            Dictionary. Keys refer to detector's 2-character prefix,
+            values are (3, num_timestamps) numpy arrays.
+        """
+
+        mdss = self.Series
+
+        velocities = {}
+
+        for ifo_ind in range(mdss.length):
+            ifo_name = mdss.data[ifo_ind].detector.frDetector.prefix
+            velocities[ifo_name] = np.vstack(
+                [data.vDetector for data in mdss.data[ifo_ind].data]
+            ).T
+
+        return velocities
+
+    @property
+    def timestamps(self) -> dict[str, np.ndarray]:
+        return self._timestamps
+
+    @property
+    def T_sft(self) -> int:
+        return self._T_sft
+
+    @property
+    def t_offset(self) -> int | float:
+        return self._t_offset
+
+    @property
+    def multi_lal_detector(self) -> lalpulsar.MultiLALDetector:
+        return self._multi_lal_detector
+
+    @property
+    def multi_timestamps(self) -> lalpulsar.MultiLIGOTimeGPSVector:
+        return self._multi_timestamps
+
+    @timestamps.setter
+    def timestamps(self, new_timestamps: dict):
+
+        self._timestamps = new_timestamps
+
+        self._multi_lal_detector = lalpulsar.MultiLALDetector()
+        lalpulsar.ParseMultiLALDetector(self._multi_lal_detector, [*self._timestamps])
+
+        self._multi_timestamps = lalpulsar.CreateMultiLIGOTimeGPSVector(
+            self._multi_lal_detector.length
+        )
+        for ind, ifo in enumerate(new_timestamps):
+            seconds_array = np.floor(new_timestamps[ifo])
+            nanoseconds_array = np.floor(1e9 * (new_timestamps[ifo] - seconds_array))
+
+            self._multi_timestamps.data[ind] = lalpulsar.CreateTimestampVector(
+                seconds_array.shape[0]
+            )
+
+            for ts_ind in range(self._multi_timestamps.data[ind].length):
+                self._multi_timestamps.data[ind].data[ts_ind] = lal.LIGOTimeGPS(
+                    int(seconds_array[ts_ind]), int(nanoseconds_array[ts_ind])
+                )
+
+    @T_sft.setter
+    def T_sft(self, new_T_sft: int):
+        self._T_sft = int(new_T_sft)
+        for ifo_ind in range(self.multi_timestamps.length):
+            self._multi_timestamps.data[ifo_ind].deltaT = self._T_sft
+
+    @t_offset.setter
+    def t_offset(self, new_t_offset: int | None):
+        self._t_offset = new_t_offset if new_t_offset is not None else 0.5 * self.T_sft

cows3-0.0.1/src/cows3/ephemeris.py

@@ -0,0 +1,10 @@
+import logging
+import lalpulsar
+from solar_system_ephemerides import body_ephemeris_path
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_EPHEMERIS = lalpulsar.InitBarycenter(
+    str(body_ephemeris_path("earth")),
+    str(body_ephemeris_path("sun")),
+)

cows3-0.0.1/src/cows3/sensitivity.py

@@ -0,0 +1,38 @@
+import numpy as np
+from scipy import integrate, stats
+
+
+def pfd_Fstatistic(
+    twoF_threshold: float | np.ndarray,
+    depth: float | np.ndarray,
+    num_segments: int | np.ndarray,
+    unitD_rho2_bins: np.ndarray,
+    unitD_rho2_pdf: np.ndarray,
+):
+    """
+    Compute the false-dismissal probability for a semicoherent F-statistic
+    for a population of signals at a sensitivity depth `depth` given
+    a unit-depth SNR^2 `unitD_rho2_pdf`.
+    Integration is performed across the last axis of the arrays.
+
+    twoF_threshold:
+        Threshold at which the false-dismissal probability will be computed.
+        This threshold corresponds to the semicoherent twoF statistic,
+        which is distributed as a chi-squared distribution with `4 * num_segments`
+        degrees of freedom in Gaussian noise.
+    depth:
+        Depth of the signal population.
+    num_segments:
+        Number of segments over which the semicoherent F-statistic is computed.
+    unitD_rho2_bins:
+        Values at which the unit-depth SNR^2 pdf is evaluated
+    unitD_rho2_pdf:
+        PDF of the unitary-depth signal distribution. This is the
+        ``geometric factor'' R in Dreissigacker+ arXiv:1808.024
+    """
+
+    cdf_2F_rho2 = stats.ncx2(df=4 * num_segments, nc=unitD_rho2_bins).cdf(
+        twoF_threshold
+    )
+
+    return integrate.simpson(y=unitD_rho2_pdf * cdf_2F_rho2, x=unitD_rho2_pdf)

cows3-0.0.1/src/cows3/snr.py

@@ -0,0 +1,190 @@
+from functools import cache
+import logging
+
+import lal
+import lalpulsar
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class SignalToNoiseRatio:
+    r"""Compute the optimal SNR of a CW signal as expected in Gaussian noise.
+
+    The definition of SNR (shortcut for "optimal signal-to-noise ratio")
+    is taken from Eq. (76) of https://dcc.ligo.org/T0900149-v6/public and is
+    such that :math:`\langle 2\mathcal{F}\rangle = 4 + \textrm{SNR}^2`,
+    where  :math:`\langle 2\mathcal{F}\rangle` represents the expected
+    value over noise realizations of twice the F-statistic of a template
+    perfectly matched to an existing signal in the data.
+
+    Computing :math:`\textrm{SNR}^2` requires two quantities:
+
+    * | The antenna pattern matrix :math:`\mathcal{M}`, which depends on the sky position :math:`\vec{n}`
+      | and polarization angle :math:`\psi` and encodes the effect of the detector's antenna pattern response
+      | over the course of the observing run.
+    * | The JKS amplitude parameters :math:`(\mathcal{A}^0, \mathcal{A}^1, \mathcal{A}^2, \mathcal{A}^3)`
+      | [JKS1998]_ which are functions of the CW's amplitude parameters :math:`(h_0,\cos\iota, \psi, \phi_0)` or,
+      | alternatively, :math:`(A_{+}, A_{\times}, \psi, \phi_0)`.
+
+    .. [JKS1998] `Jaranowski, Krolak, Schuz Phys. Rev. D58 063001, 1998 <https://arxiv.org/abs/gr-qc/9804014>`_
+
+    Parameters
+    ----------
+    mdss: lalpulsar.MultiDetectorStateSeries
+        MultiDetectorStateSeries as produced by DetectorStates.
+        Provides the required information to compute the antenna pattern contribution.
+    noise_weights: Union[lalpulsar.MultiNoiseWeights, None]
+        Optional, incompatible with `assumeSqrtSX`.
+        Can be computed from SFTs using `SignalToNoiseRatio.from_sfts`.
+        Noise weights to account for a varying noise floor or unequal noise
+        floors in different detectors.
+    assumeSqrtSX: float
+        Optional, incompatible with `noise_weights`.
+        Single-sided amplitude spectral density (ASD) of the detector noise.
+        This value is used for all detectors, meaning it's not currently possible to manually
+        specify different noise floors without creating SFT files.
+        (To be improved in the future; developer note:
+        will require SWIG constructor for MultiNoiseWeights.)
+
+    This code is a subset of that under `snr.py` in [PyFstat](https://github.com/PyFstat/PyFstat).
+
+    """
+
+    def __init__(
+        self,
+        mdss: lalpulsar.MultiDetectorStateSeries,
+        noise_weights: lalpulsar.MultiNoiseWeights | None = None,
+        assumeSqrtSX: float | None = None,
+    ):
+
+        self.mdss = mdss
+        self.noise_weights = noise_weights
+        self.assumeSqrtSX = assumeSqrtSX
+
+    @property
+    def mdss(self) -> lalpulsar.MultiDetectorStateSeries:
+        return self._mdss
+
+    @property
+    def noise_weights(self) -> lalpulsar.MultiNoiseWeights:
+        return self._noise_weights
+
+    @property
+    def assumeSqrtSX(self) -> float | None:
+        return self._assumeSqrtSX
+
+    @mdss.setter
+    def mdss(self, new_mdss: lalpulsar.MultiDetectorStateSeries):
+        self._mdss = new_mdss
+        self._T_sft = new_mdss.data[0].deltaT
+
+    @noise_weights.setter
+    def noise_weights(self, new_weights: lalpulsar.MultiNoiseWeights):
+        if (new_weights is not None) and (
+            getattr(self, "assumeSqrtSX", None) is not None
+        ):
+            raise ValueError(
+                "Cannot set `noise_weights` if `assumeSqrtSX is already set!"
+            )
+        self._noise_weights = new_weights
+        self._Sinv_Tsft = None
+
+    @assumeSqrtSX.setter
+    def assumeSqrtSX(self, new_sqrtSX: float):
+        if getattr(self, "noise_weights", None) is not None:
+            raise ValueError(
+                "Cannot set `assumeSqrtSX' if `noise_weights` is already set!"
+            )
+        self._assumeSqrtSX = new_sqrtSX
+        self._T_sft = self.mdss.data[0].deltaT
+        self._Sinv_Tsft = self._T_sft / new_sqrtSX**2
+
+    def compute_snr2(
+        self,
+        Alpha: float,
+        Delta: float,
+        psi: float,
+        phi0: float,
+        aPlus: float,
+        aCross: float,
+    ) -> float:
+        r"""
+        Compute the :math:`\textrm{SNR}^2` of a CW signal using XLALComputeOptimalSNR2FromMmunu.
+        Parameters correspond to the standard ones used to describe a CW
+        (see e.g. Eqs. (16), (26), (30) of https://dcc.ligo.org/T0900149-v6/public ).
+
+        Mind that this function returns *squared* SNR
+        (Eq. (76) of https://dcc.ligo.org/T0900149-v6/public ),
+        which can be directly related to the expected F-statistic as
+        :math:`\langle 2\mathcal{F}\rangle = 4 + \textrm{SNR}^2`.
+
+        Parameters
+        ----------
+        Alpha: float
+            Right ascension (equatorial longitude) of the signal in radians.
+        Delta: float
+            Declination (equatorial latitude) of the signal in radians.
+        psi: float
+            Polarization angle.
+        phi0: float
+            Initial phase.
+        aPlus: float
+            Plus polarization amplitude, equal to `0.5 * h0 (1 + cosi^2)`.
+        aCross: float
+            Cross polarization amplitude, equal to `h0 * cosi`.
+
+        Returns
+        -------
+        SNR^2: float
+            Squared signal-to-noise ratio of a CW signal consistent
+            with the specified parameters in the specified detector
+            network.
+        """
+
+        Aphys = lalpulsar.PulsarAmplitudeParams()
+        Aphys.psi = psi
+        Aphys.phi0 = phi0
+        Aphys.aPlus = aPlus
+        Aphys.aCross = aCross
+
+        M = self.compute_Mmunu(Alpha=Alpha, Delta=Delta)
+
+        return lalpulsar.ComputeOptimalSNR2FromMmunu(Aphys, M)
+
+    def compute_Mmunu(self, Alpha: float, Delta: float) -> float:
+        """
+        Compute Mmunu matrix at a specific sky position using the detector states
+        (and possible noise weights) given at initialization time.
+        If no noise weights were given, unit weights are assumed.
+
+        Parameters
+        ----------
+        Alpha: float
+            Right ascension (equatorial longitude) of the signal in radians.
+        Delta: float
+            Declination (equatorial latitude) of the signal in radians.
+
+        Returns
+        -------
+        Mmunu: lalpulsar.AntennaPatternMatrix
+            Mmunu matrix encoding the response of the given detector network
+            to a CW at the specified sky position.
+        """
+
+        sky = lal.SkyPosition()
+        sky.longitude = Alpha
+        sky.latitude = Delta
+        sky.system = lal.COORDINATESYSTEM_EQUATORIAL
+        lal.NormalizeSkyPosition(sky.longitude, sky.latitude)
+
+        Mmunu = lalpulsar.ComputeMultiAMCoeffs(
+            multiDetStates=self.mdss,
+            multiWeights=self.noise_weights,
+            skypos=sky,
+        ).Mmunu
+
+        if self.noise_weights is None:
+            Mmunu.Sinv_Tsft = self._Sinv_Tsft
+
+        return Mmunu

cows3-0.0.1/src/cows3.egg-info/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.1
+Name: cows3
+Version: 0.0.1
+Summary: Continuous-wave search sensitivity simulator
+Author-email: Rodrigo Tenorio <rodrigo.tenorio.marquez@gmail.com>, Lorenzo Mirasola <lorenzo.mirasola@ca.infn.it>
+License: MIT License
+        
+        Copyright (c) 2024 Rodrigo Tenorio, Lorenzo Mirasola
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+        
+Project-URL: Homepage, https://github.com/Rodrigo-Tenorio/cows3
+Project-URL: Issues, https://github.com/Rodrigo-Tenorio/cows3/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: lalsuite
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: solar_system_ephemerides
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+
+# Continuous-wave search sensitivity simulator (COWS3)
+
+A Python package to estimate the sensitivity of general
+continuous gravitational-wave searches.
+
+The method should be equivalent to the semi-analytical approach derived in
+[Dreissigacker, Prix, Wette (2018)](https://arxiv.org/abs/1808.02459) and
+implemented in [Octapps](https://github.com/octapps/octapps), but here we 
+implement it in Python to make it more convenient to use.
+
+## Citing this work
+
+If COWS3 was useful to your research, we would appreciate if you cited
+[Mirasola & Tenorio (2024)](https://arxiv.org/abs/2405.18934) where this
+implementation was first presented:
+```
+@article{Mirasola:2024lcq,
+    author = "Mirasola, Lorenzo and Tenorio, Rodrigo",
+    title = "{Towards a computationally-efficient follow-up pipeline for blind continuous gravitational-wave searches}",
+    eprint = "2405.18934",
+    archivePrefix = "arXiv",
+    primaryClass = "gr-qc",
+    reportNumber = "LIGO-P2400221",
+    month = "5",
+    year = "2024",
+    journal = "arXiv e-prints"
+}
+```
+as well as a Zenodo release of this software.
+
+For the semi-analytical sensitivity estimation method you should also cite 
+[Wette (2012)](https://arxiv.org/abs/1111.5650) and
+[Dreissigacker, Prix, Wette (2018)](https://arxiv.org/abs/1808.02459). Also,
+this package makes extensive use of SWIG bindings, so please cite
+[Wette (2021)](https://arxiv.org/abs/2012.09552) as well.
+
+
+## Authors
+- Rodrigo Tenorio
+- Lorenzo Mirasola
+
+

cows3-0.0.1/src/cows3.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+.gitignore
+LICENSE.md
+README.md
+pyproject.toml
+setup.py
+.github/workflows/pypi.yml
+.github/workflows/pytest.yml
+src/cows3/__init__.py
+src/cows3/detectorstates.py
+src/cows3/ephemeris.py
+src/cows3/sensitivity.py
+src/cows3/snr.py
+src/cows3.egg-info/PKG-INFO
+src/cows3.egg-info/SOURCES.txt
+src/cows3.egg-info/dependency_links.txt
+src/cows3.egg-info/requires.txt
+src/cows3.egg-info/top_level.txt
+tests/test_detectorstates.py
+tests/test_sensitivity.py
+tests/test_snr.py

cows3-0.0.1/src/cows3.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cows3-0.0.1/src/cows3.egg-info/requires.txt

@@ -0,0 +1,9 @@
+lalsuite
+numpy
+scipy
+solar_system_ephemerides
+
+[dev]
+black
+flake8
+pytest

cows3-0.0.1/src/cows3.egg-info/top_level.txt

@@ -0,0 +1 @@
+cows3

cows3-0.0.1/tests/test_detectorstates.py

@@ -0,0 +1,65 @@
+import pytest
+import numpy as np
+
+from cows3.detectorstates import MultiDetectorStates
+
+
+@pytest.fixture
+def timestamps():
+    return {
+        "L1": 1238166018 + np.arange(0, 10, 3),
+        "H1": 1238166018 + np.arange(0, 10, 2),
+    }
+
+
+@pytest.fixture
+def wrong_timestamps():
+    return {
+        "AB": 1238166018 + np.arange(0, 10, 3),
+    }
+
+
+@pytest.fixture
+def Tsft():
+    return 1800
+
+
+@pytest.fixture
+def time_offset():
+    return 0.0
+
+
+def test_get_multi_detector_states(timestamps, Tsft, time_offset):
+    mdss = MultiDetectorStates(
+        timestamps=timestamps, T_sft=Tsft, t_offset=time_offset
+    ).Series
+
+    assert mdss.length == len(timestamps)
+    for ind, ifo in enumerate(timestamps):
+        assert mdss.data[ind].length == timestamps[ifo].size
+        assert mdss.data[ind].detector.frDetector.prefix == ifo
+        assert mdss.data[ind].deltaT == Tsft
+
+        for gps_ind in range(mdss.data[ind].length):
+            mdss.data[ind].data[gps_ind].tGPS.gpsSeconds == timestamps[ifo][gps_ind]
+
+
+def test_wrong_timestamps(wrong_timestamps, Tsft, time_offset):
+    with pytest.raises(RuntimeError) as e_info:
+        mds = MultiDetectorStates(
+            timestamps=wrong_timestamps, T_sft=Tsft, t_offset=time_offset
+        )
+
+
+def test_extract_detector_velocities(timestamps, Tsft, time_offset):
+    mds = MultiDetectorStates(timestamps=timestamps, T_sft=Tsft, t_offset=time_offset)
+
+    velocities = mds.velocities
+    mdss = mds.Series
+
+    assert len(velocities) == len(timestamps)
+    assert all(key in velocities for key in timestamps)
+    for ifo_ind in range(len(timestamps)):
+        shape_to_test = velocities[mdss.data[ifo_ind].detector.frDetector.prefix].shape
+        assert shape_to_test[0] == 3
+        assert shape_to_test[1] == mdss.data[ifo_ind].length

cows3-0.0.1/tests/test_sensitivity.py

@@ -0,0 +1,21 @@
+import pytest
+
+import numpy as np
+from cows3.sensitivity import pfd_Fstatistic
+
+
+@pytest.fixture
+def unitD_rho2():
+    bins = np.arange(1, 11)
+    pdf = np.ones(bins.size) / bins.size
+    return bins, pdf
+
+
+def test_pfd_Fstatistic(unitD_rho2):
+    pfd_Fstatistic(
+        twoF_threshold=100,
+        depth=10,
+        num_segments=25,
+        unitD_rho2_bins=unitD_rho2[0],
+        unitD_rho2_pdf=unitD_rho2[1],
+    )

cows3-0.0.1/tests/test_snr.py

@@ -0,0 +1,51 @@
+import numpy as np
+import pytest
+
+from cows3.detectorstates import MultiDetectorStates
+from cows3.snr import SignalToNoiseRatio
+
+
+@pytest.fixture
+def signal_params():
+    return {
+        "aPlus": 0.5 * 1e-23,
+        "aCross": 1e-23,
+        "psi": 0,
+        "phi0": 0,
+        "Alpha": 0,
+        "Delta": 0,
+    }
+
+
+@pytest.fixture
+def mds():
+
+    Tsft = 1_800
+    tstart = 700_000_000
+    ts = np.arange(tstart, tstart + 4 * Tsft, Tsft)
+
+    return MultiDetectorStates(
+        timestamps={detector: ts for detector in ["H1", "L1"]},
+        T_sft=Tsft,
+    )
+
+
+@pytest.fixture
+def snr_object(mds):
+    return SignalToNoiseRatio(
+        mdss=mds.Series,
+        assumeSqrtSX=1e-23,
+    )
+
+
+def test_SignalToNoiseRatio(signal_params, snr_object):
+    params = {
+        "aPlus": 0.5 * 1e-23,
+        "aCross": 1e-23,
+        "psi": 0,
+        "phi0": 0,
+        "Alpha": 0,
+        "Delta": 0,
+    }
+
+    snr_object.compute_snr2(**signal_params)