From 38203663372dcfde29fd8d5920059f8d89a1c3d7 Mon Sep 17 00:00:00 2001 From: Max Isi Date: Mon, 14 Oct 2024 17:48:52 -0400 Subject: [PATCH 01/14] typo: Liklihood -> Likelihood --- src/jimgw/single_event/likelihood.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/jimgw/single_event/likelihood.py b/src/jimgw/single_event/likelihood.py index 96e11e62..38d56aca 100644 --- a/src/jimgw/single_event/likelihood.py +++ b/src/jimgw/single_event/likelihood.py @@ -17,7 +17,7 @@ from jimgw.transforms import BijectiveTransform, NtoMTransform -class SingleEventLiklihood(LikelihoodBase): +class SingleEventLikelihood(LikelihoodBase): detectors: list[Detector] waveform: Waveform @@ -35,7 +35,7 @@ def evaluate(self, params: dict[str, Float], data: dict) -> Float: return 0.0 -class TransientLikelihoodFD(SingleEventLiklihood): +class TransientLikelihoodFD(SingleEventLikelihood): def __init__( self, detectors: list[Detector], From 722d997cff400d056b1aa6217ee4d8a401c0a8fc Mon Sep 17 00:00:00 2001 From: Max Isi Date: Mon, 14 Oct 2024 17:49:20 -0400 Subject: [PATCH 02/14] logging and docs, compute_psd WIP --- src/jimgw/single_event/detector.py | 100 ++++++++++++++++++++++++----- 1 file changed, 83 insertions(+), 17 deletions(-) diff --git a/src/jimgw/single_event/detector.py b/src/jimgw/single_event/detector.py index 6c3079cf..8b2b68e2 100644 --- a/src/jimgw/single_event/detector.py +++ b/src/jimgw/single_event/detector.py @@ -12,6 +12,7 @@ from jimgw.constants import C_SI, EARTH_SEMI_MAJOR_AXIS, EARTH_SEMI_MINOR_AXIS from jimgw.single_event.wave import Polarization +import logging DEG_TO_RAD = jnp.pi / 180 @@ -22,6 +23,8 @@ "V1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-V1_sensitivity_strain_asd.txt", } +_DEF_GWPY_KWARGS = {"cache": True} + class Detector(ABC): """ @@ -62,10 +65,44 @@ def td_response( class GroundBased2G(Detector): + """Object representing a ground-based detector. Contains information + about the location and orientation of the detector on Earth, as well as + actual strain data and the PSD of the associated noise. + + Attributes + ---------- + name : str + Name of the detector. + latitude : Float + Latitude of the detector in radians. + longitude : Float + Longitude of the detector in radians. + xarm_azimuth : Float + Azimuth of the x-arm in radians. + yarm_azimuth : Float + Azimuth of the y-arm in radians. + xarm_tilt : Float + Tilt of the x-arm in radians. + yarm_tilt : Float + Tilt of the y-arm in radians. + elevation : Float + Elevation of the detector in meters. + polarization_mode : list[Polarization] + List of polarization modes (`pc` for plus and cross) to be used in + computing antenna patterns; in the future, this could be expanded to + include non-GR modes. + frequencies : Float[Array, " n_sample"] + Array of Fourier frequencies. + data : Float[Array, " n_sample"] + Array of Fourier-domain strain data. + psd : Float[Array, " n_sample"] + Array of noise power spectral density. + """ polarization_mode: list[Polarization] frequencies: Float[Array, " n_sample"] data: Float[Array, " n_sample"] psd: Float[Array, " n_sample"] + epoch: Float = 0 latitude: Float = 0 longitude: Float = 0 @@ -99,8 +136,7 @@ def __init__(self, name: str, **kwargs) -> None: def _get_arm( lat: Float, lon: Float, tilt: Float, azimuth: Float ) -> Float[Array, " 3"]: - """ - Construct detector-arm vectors in Earth-centric Cartesian coordinates. + """Construct detector-arm vectors in geocentric Cartesian coordinates. Parameters --------- @@ -116,7 +152,7 @@ def _get_arm( Returns ------- arm : Float[Array, " 3"] - detector arm vector in Earth-centric Cartesian coordinates. + detector arm vector in geocentric Cartesian coordinates. """ e_lon = jnp.array([-jnp.sin(lon), jnp.cos(lon), 0]) e_lat = jnp.array( @@ -134,8 +170,7 @@ def _get_arm( @property def arms(self) -> tuple[Float[Array, " 3"], Float[Array, " 3"]]: - """ - Detector arm vectors (x, y). + """Detector arm vectors (x, y). Returns ------- @@ -154,8 +189,15 @@ def arms(self) -> tuple[Float[Array, " 3"], Float[Array, " 3"]]: @property def tensor(self) -> Float[Array, " 3 3"]: - """ - Detector tensor defining the strain measurement. + """Detector tensor defining the strain measurement. + + For a 2-arm differential-length detector, this is given by: + + .. math:: + + D_{ij} = \\left(x_i x_j - y_i y_j\\right)/2 + + for unit vectors :math:`x` and :math:`y` along the x and y arms. Returns ------- @@ -170,8 +212,7 @@ def tensor(self) -> Float[Array, " 3 3"]: @property def vertex(self) -> Float[Array, " 3"]: - """ - Detector vertex coordinates in the reference celestial frame. Based + """Detector vertex coordinates in the reference celestial frame. Based on arXiv:gr-qc/0008066 Eqs. (B11-B13) except for a typo in the definition of the local radius; see Section 2.1 of LIGO-T980044-10. @@ -203,10 +244,11 @@ def load_data( f_max: Float, psd_pad: int = 16, tukey_alpha: Float = 0.2, - gwpy_kwargs: dict = {"cache": True}, + gwpy_kwargs: dict | None = None, ) -> None: - """ - Load data from the detector. + """Load open GW detector data from GWOSC using GWpy. Essentially, this + is a wrapper around the GWpy :meth:`TimeSeries.fetch_open_data` + method. Parameters ---------- @@ -220,14 +262,22 @@ def load_data( The minimum frequency to fetch data. f_max : Float The maximum frequency to fetch data. - psd_pad : int - The amount of time to pad the PSD data. tukey_alpha : Float - The alpha parameter for the Tukey window. - + The ``alpha`` parameter for the Tukey window; this represents + the fraction of the segment duration that is tapered on each end + (defaults to 0.2). + gwpy_kwargs : dict, optional + Additional keyword arguments to pass to the GWpy + :meth:`TimeSeries.fetch_open_data` method, defaults to + {}. """ + if gwpy_kwargs is None: + gwpy_kwargs = _DEF_GWPY_KWARGS - print("Fetching data from {}...".format(self.name)) + duration = gps_end_pad + gps_start_pad + logging.info(f"Fetching {duration} s of {self.name} data around " + f"{trigger_time} from GWOSC.") + data_td = TimeSeries.fetch_open_data( self.name, trigger_time - gps_start_pad, @@ -260,6 +310,22 @@ def load_data( self.frequencies = freq[(freq > f_min) & (freq < f_max)] self.data = data[(freq > f_min) & (freq < f_max)] self.psd = psd[(freq > f_min) & (freq < f_max)] + load_data.__doc__ = load_data.__doc__.format(_DEF_GWPY_KWARGS) + + def compute_psd(self, + data: Float[Array, " n_sample"] | None, + pad: Float = 0., + **kws) -> None: + # if data is None: + # if pad: + # # pull more data to compute a PSD + + # n = len(data) + # delta_t = 1.0 + # data = jnp.fft.rfft(data * tukey(n, tukey_alpha)) * delta_t + # freq = jnp.fft.rfftfreq(n, delta_t) + # return jnp.abs(data) ** 2 / delta_t + raise NotImplementedError def fd_response( self, From 250b33c0309193de6bd7abe862b683c7d65846e2 Mon Sep 17 00:00:00 2001 From: Max Isi Date: Mon, 14 Oct 2024 17:49:31 -0400 Subject: [PATCH 03/14] SingleEventLiklihood typo --- src/jimgw/single_event/runManager.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/jimgw/single_event/runManager.py b/src/jimgw/single_event/runManager.py index 7b720c30..ed22feb7 100644 --- a/src/jimgw/single_event/runManager.py +++ b/src/jimgw/single_event/runManager.py @@ -15,7 +15,7 @@ from jimgw.base import RunManager from jimgw.jim import Jim from jimgw.single_event.detector import Detector, detector_preset -from jimgw.single_event.likelihood import SingleEventLiklihood, likelihood_presets +from jimgw.single_event.likelihood import SingleEventLikelihood, likelihood_presets from jimgw.single_event.waveform import Waveform, waveform_preset @@ -145,7 +145,7 @@ def load_from_path(self, path: str) -> SingleEventRun: ### Initialization functions ### - def initialize_likelihood(self, prior: prior.Prior) -> SingleEventLiklihood: + def initialize_likelihood(self, prior: prior.Prior) -> SingleEventLikelihood: """ Since prior contains information about types, naming and ranges of parameters, some of the likelihood class require the prior to be initialized, such as the From b0c7ef674887a1073c44abad94cc49a33bb7f8a7 Mon Sep 17 00:00:00 2001 From: Max Isi Date: Mon, 14 Oct 2024 17:49:43 -0400 Subject: [PATCH 04/14] examples --- example/GW150914_IMRPhenomPV2.py | 1 - example/notebooks/GW150914.ipynb | 125 +++++++++++++++++++++++++++---- 2 files changed, 112 insertions(+), 14 deletions(-) diff --git a/example/GW150914_IMRPhenomPV2.py b/example/GW150914_IMRPhenomPV2.py index c291adbf..11936abc 100644 --- a/example/GW150914_IMRPhenomPV2.py +++ b/example/GW150914_IMRPhenomPV2.py @@ -3,7 +3,6 @@ import jax import jax.numpy as jnp -from jimgw.jim import Jim from jimgw.jim import Jim from jimgw.prior import ( CombinePrior, diff --git a/example/notebooks/GW150914.ipynb b/example/notebooks/GW150914.ipynb index 2c4c264b..57ef374f 100644 --- a/example/notebooks/GW150914.ipynb +++ b/example/notebooks/GW150914.ipynb @@ -2,9 +2,24 @@ "cells": [ { "cell_type": "code", - "execution_count": 58, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/sw/nix/store/29h1dijh98y9ar6n8hxv78v8zz2pqfzf-python-3.11.7-view/lib/python3.11/site-packages/numpy/core/getlimits.py:549: UserWarning: The value of the smallest subnormal for type is zero.\n", + " setattr(self, word, getattr(machar, word).flat[0])\n", + "/mnt/sw/nix/store/29h1dijh98y9ar6n8hxv78v8zz2pqfzf-python-3.11.7-view/lib/python3.11/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for type is zero.\n", + " return self._float_to_str(self.smallest_subnormal)\n", + "/mnt/sw/nix/store/29h1dijh98y9ar6n8hxv78v8zz2pqfzf-python-3.11.7-view/lib/python3.11/site-packages/numpy/core/getlimits.py:549: UserWarning: The value of the smallest subnormal for type is zero.\n", + " setattr(self, word, getattr(machar, word).flat[0])\n", + "/mnt/sw/nix/store/29h1dijh98y9ar6n8hxv78v8zz2pqfzf-python-3.11.7-view/lib/python3.11/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for type is zero.\n", + " return self._float_to_str(self.smallest_subnormal)\n" + ] + } + ], "source": [ "import gwpy\n", "from gwpy.timeseries import TimeSeries\n", @@ -14,6 +29,95 @@ "%matplotlib inline" ] }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "jax.config.update(\"jax_enable_x64\", True)\n", + "from jimgw.jim import Jim" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from jimgw.single_event import detector\n", + "from importlib import reload\n", + "reload(detector)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mdetector\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGroundBased2G\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtrigger_time\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mjaxtyping\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFloat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mgps_start_pad\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mgps_end_pad\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mf_min\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mjaxtyping\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFloat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mf_max\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mjaxtyping\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFloat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mpsd_pad\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m16\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtukey_alpha\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mjaxtyping\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mgwpy_kwargs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Load open GW detector data from GWOSC using GWpy. Essentially, this\n", + "is a wrapper around the GWpy :meth:`TimeSeries.fetch_open_data`\n", + "method.\n", + "\n", + "Parameters\n", + "----------\n", + "trigger_time : Float\n", + " The GPS time of the trigger.\n", + "gps_start_pad : int\n", + " The amount of time before the trigger to fetch data.\n", + "gps_end_pad : int\n", + " The amount of time after the trigger to fetch data.\n", + "f_min : Float\n", + " The minimum frequency to fetch data.\n", + "f_max : Float\n", + " The maximum frequency to fetch data.\n", + "psd_pad : int\n", + " The amount of time to pad the PSD data.\n", + "tukey_alpha : Float\n", + " The ``alpha`` parameter for the Tukey window; this represents\n", + " the fraction of the segment duration that is tapered on each end.\n", + "gwpy_kwargs : dict, optional\n", + " Additional keyword arguments to pass to the GWpy\n", + " :meth:`TimeSeries.fetch_open_data` method, defaults to\n", + " {'cache': True}.\n", + "\u001b[0;31mFile:\u001b[0m ~/src/jim-kaze/src/jimgw/single_event/detector.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + } + ], + "source": [ + "detector.GroundBased2G.load_data?" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -42,7 +146,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -153,7 +257,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -195,7 +299,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -294,9 +398,9 @@ ], "metadata": { "kernelspec": { - "display_name": "GW", + "display_name": "jim", "language": "python", - "name": "gw" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -308,12 +412,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "vscode": { - "interpreter": { - "hash": "c1b26637a459b71d5a98be81c2c552e2aef4ac924b44e1d1dcc4c383679c0a72" - } + "version": "3.11.7" } }, "nbformat": 4, From 01fb3603dab0d2b02002fb312a82c914426e507c Mon Sep 17 00:00:00 2001 From: "max.isi" Date: Wed, 16 Oct 2024 06:29:17 -0400 Subject: [PATCH 05/14] WIP --- setup.cfg | 3 ++ src/jimgw/single_event/data.py | 75 ++++++++++++++++++++++++++++ src/jimgw/single_event/detector.py | 15 ------ src/jimgw/single_event/likelihood.py | 2 + 4 files changed, 80 insertions(+), 15 deletions(-) create mode 100644 src/jimgw/single_event/data.py diff --git a/setup.cfg b/setup.cfg index e2fbd986..8254e0d4 100644 --- a/setup.cfg +++ b/setup.cfg @@ -29,3 +29,6 @@ python_requires = >=3.9 [options.packages.find] where=src + +[flake8] +ignore = F722 diff --git a/src/jimgw/single_event/data.py b/src/jimgw/single_event/data.py new file mode 100644 index 00000000..c21917b6 --- /dev/null +++ b/src/jimgw/single_event/data.py @@ -0,0 +1,75 @@ +from abc import ABC, abstractmethod + +import jax +import jax.numpy as jnp +import numpy as np +import requests +from gwpy.timeseries import TimeSeries +from jaxtyping import Array, Float, PRNGKeyArray, jaxtyped +from beartype import beartype as typechecker +from scipy.interpolate import interp1d +from scipy.signal.windows import tukey + +from jimgw.constants import C_SI, EARTH_SEMI_MAJOR_AXIS, EARTH_SEMI_MINOR_AXIS +from jimgw.single_event.wave import Polarization +import logging + +DEG_TO_RAD = jnp.pi / 180 + +# TODO: Need to expand this list. Currently it is only O3. +asd_file_dict = { + "H1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-H1-C01_CLEAN_SUB60HZ-1251752040.0_sensitivity_strain_asd.txt", + "L1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-L1-C01_CLEAN_SUB60HZ-1240573680.0_sensitivity_strain_asd.txt", + "V1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-V1_sensitivity_strain_asd.txt", +} + +_DEF_GWPY_KWARGS = {"cache": True} + + +class Data(ABC): + """ + Base class for all data. + + """ + + name: str + + fd: Float[Array, " n_sample"] + td: Float[Array, " n_sample//2"] # fix this + psd: Float[Array, " n_sample//2"] # fix this + frequencies: Float[Array, " n_sample//2"] + times: Float[Array, " n_sample"] + + @property + def duration(self) -> Float: + """Duration of the data in seconds.""" + if len(self.frequencies) == 0: + return 0 + return 1 / (self.frequencies[1] - self.frequencies[0]) + + @property + def delta_t(self) -> Float: + """Sampling interval of the data in seconds.""" + return self.times[1] - self.times[0] + + def + + def load_psd_from_data(self, data: TimeSeries, **kws) -> None: + seglen = self.duration + self.psd = data.psd(fftlength=seglen).value + + def compute_psd_from_gwosc(self, + start_time: Float | None = None, + end_time: Float | None = None, + off_source: bool = True, + **kws) -> None: + if data is None: + if pad: + # pull more data to compute a PSD + + # n = len(data) + # delta_t = 1.0 + # data = jnp.fft.rfft(data * tukey(n, tukey_alpha)) * delta_t + # freq = jnp.fft.rfftfreq(n, delta_t) + # return jnp.abs(data) ** 2 / delta_t + raise NotImplementedError diff --git a/src/jimgw/single_event/detector.py b/src/jimgw/single_event/detector.py index 8b2b68e2..c4c64de8 100644 --- a/src/jimgw/single_event/detector.py +++ b/src/jimgw/single_event/detector.py @@ -312,21 +312,6 @@ def load_data( self.psd = psd[(freq > f_min) & (freq < f_max)] load_data.__doc__ = load_data.__doc__.format(_DEF_GWPY_KWARGS) - def compute_psd(self, - data: Float[Array, " n_sample"] | None, - pad: Float = 0., - **kws) -> None: - # if data is None: - # if pad: - # # pull more data to compute a PSD - - # n = len(data) - # delta_t = 1.0 - # data = jnp.fft.rfft(data * tukey(n, tukey_alpha)) * delta_t - # freq = jnp.fft.rfftfreq(n, delta_t) - # return jnp.abs(data) ** 2 / delta_t - raise NotImplementedError - def fd_response( self, frequency: Float[Array, " n_sample"], diff --git a/src/jimgw/single_event/likelihood.py b/src/jimgw/single_event/likelihood.py index 38d56aca..f8f69a7a 100644 --- a/src/jimgw/single_event/likelihood.py +++ b/src/jimgw/single_event/likelihood.py @@ -43,6 +43,8 @@ def __init__( trigger_time: float = 0, duration: float = 4, post_trigger_duration: float = 2, + # TODO: apply f_min and f_max and get frequency domain data + # here **kwargs, ) -> None: self.detectors = detectors From 88d51a5dd671ecdb480e4708346172759268f819 Mon Sep 17 00:00:00 2001 From: "max.isi" Date: Wed, 16 Oct 2024 10:48:17 -0400 Subject: [PATCH 06/14] data wip --- src/jimgw/single_event/data.py | 90 ++++++++++++++++++++-------------- 1 file changed, 54 insertions(+), 36 deletions(-) diff --git a/src/jimgw/single_event/data.py b/src/jimgw/single_event/data.py index c21917b6..c79102ce 100644 --- a/src/jimgw/single_event/data.py +++ b/src/jimgw/single_event/data.py @@ -28,48 +28,66 @@ class Data(ABC): """ - Base class for all data. + Base class for all data. The time domain data are considered the primary + entitiy; the Fourier domain data are derived from an FFT after applying a + window. The structure is set up so that :attr:`td` and :attr:`fd` are always + Fourier conjugates of each other: the one-sided Fourier series is complete + up to the Nyquist frequency """ - name: str - fd: Float[Array, " n_sample"] - td: Float[Array, " n_sample//2"] # fix this - psd: Float[Array, " n_sample//2"] # fix this - frequencies: Float[Array, " n_sample//2"] - times: Float[Array, " n_sample"] + td: Float[Array, " n_time"] + fd: Float[Array, " n_time // 2 + 1"] + + epoch: float + delta_t: float + + window: Float[Array, " n_time"] @property def duration(self) -> Float: """Duration of the data in seconds.""" - if len(self.frequencies) == 0: - return 0 - return 1 / (self.frequencies[1] - self.frequencies[0]) - + return self.n_time * self.delta_t + + @property + def n_time(self) -> int: + """Number of time samples.""" + return len(self.td) + + @property + def n_freq(self) -> int: + """Number of frequency samples.""" + return self.n_time // 2 + 1 + + @property + def times(self) -> Float[Array, " n_time"]: + """Times of the data in seconds.""" + return jnp.arange(self.n_time) * self.delta_t + self.epoch + @property - def delta_t(self) -> Float: - """Sampling interval of the data in seconds.""" - return self.times[1] - self.times[0] - - def - - def load_psd_from_data(self, data: TimeSeries, **kws) -> None: - seglen = self.duration - self.psd = data.psd(fftlength=seglen).value - - def compute_psd_from_gwosc(self, - start_time: Float | None = None, - end_time: Float | None = None, - off_source: bool = True, - **kws) -> None: - if data is None: - if pad: - # pull more data to compute a PSD - - # n = len(data) - # delta_t = 1.0 - # data = jnp.fft.rfft(data * tukey(n, tukey_alpha)) * delta_t - # freq = jnp.fft.rfftfreq(n, delta_t) - # return jnp.abs(data) ** 2 / delta_t - raise NotImplementedError + def frequencies(self) -> Float[Array, " n_time // 2 + 1"]: + """Frequencies of the data in Hz.""" + return jnp.fft.rfftfreq(self.n_time, self.delta_t) + + def __init__(self, td: Float[Array, " n_time"], + delta_t: float = 1., + epoch: float = 0., + **kws) -> None: + self.td = td + self.delta_t = delta_t + self.epoch = epoch + self.window = kws.get("window", jnp.ones_like(self.td)) + + def set_tukey_window(self, alpha: float = 0.4): + self.window = jnp.array(tukey(self.n_time, alpha)) + + def fft(self, **kws) -> None: + if "window" in kws: + self.window = kws["window"] + self.fd = jnp.fft.rfft(self.td * self.window) * self.delta_t + + def frequency_slice(self, f_min: float, f_max: float) -> \ + Float[Array, " n_sample"]: + f = self.frequencies + return self.fd[(f >= f_min) & (f <= f_max)] From 6c116291186f9ffb24ed36d3c88355c4171981fb Mon Sep 17 00:00:00 2001 From: Max Isi Date: Wed, 16 Oct 2024 14:56:59 -0400 Subject: [PATCH 07/14] PowerSpectrum wip --- src/jimgw/single_event/data.py | 214 ++++++++++++++++++++++++++++++--- 1 file changed, 198 insertions(+), 16 deletions(-) diff --git a/src/jimgw/single_event/data.py b/src/jimgw/single_event/data.py index c79102ce..c42f3e2f 100644 --- a/src/jimgw/single_event/data.py +++ b/src/jimgw/single_event/data.py @@ -5,7 +5,8 @@ import numpy as np import requests from gwpy.timeseries import TimeSeries -from jaxtyping import Array, Float, PRNGKeyArray, jaxtyped +from jaxtyping import Array, Float, PRNGKeyArray, jaxtyped, Complex +from typing import Optional, Any from beartype import beartype as typechecker from scipy.interpolate import interp1d from scipy.signal.windows import tukey @@ -38,18 +39,13 @@ class Data(ABC): name: str td: Float[Array, " n_time"] - fd: Float[Array, " n_time // 2 + 1"] + fd: Complex[Array, " n_time // 2 + 1"] epoch: float delta_t: float window: Float[Array, " n_time"] - @property - def duration(self) -> Float: - """Duration of the data in seconds.""" - return self.n_time * self.delta_t - @property def n_time(self) -> int: """Number of time samples.""" @@ -60,6 +56,16 @@ def n_freq(self) -> int: """Number of frequency samples.""" return self.n_time // 2 + 1 + @property + def duration(self) -> float: + """Duration of the data in seconds.""" + return self.n_time * self.delta_t + + @property + def sampling_frequency(self) -> float: + """Sampling frequency of the data in Hz.""" + return 1 / self.delta_t + @property def times(self) -> Float[Array, " n_time"]: """Times of the data in seconds.""" @@ -70,24 +76,200 @@ def frequencies(self) -> Float[Array, " n_time // 2 + 1"]: """Frequencies of the data in Hz.""" return jnp.fft.rfftfreq(self.n_time, self.delta_t) + @property + def has_fd(self) -> bool: + """Whether the Fourier domain data has been computed.""" + return bool(np.any(self.fd)) + def __init__(self, td: Float[Array, " n_time"], - delta_t: float = 1., + delta_t: float, epoch: float = 0., - **kws) -> None: + name: Optional[str] = None, + window: Optional[Float[Array, " n_time"]] = None)\ + -> None: + """Initialize the data class. + + Arguments + --------- + td: array + Time domain data + delta_t: float + Time step of the data in seconds. + epoch: float, optional + Epoch of the data in seconds (default: 0) + name: str, optional + Name of the data (default: '') + window: array, optional + Window function to apply to the data before FFT (default: None) + """ self.td = td + self.fd = jnp.zeros(self.n_freq) self.delta_t = delta_t self.epoch = epoch - self.window = kws.get("window", jnp.ones_like(self.td)) + if window is None: + self.window = jnp.ones_like(self.td) + else: + self.window = window + self.name = name or '' + + def set_tukey_window(self, alpha: float = 0.2) -> None: + """Create a Tukey window on the data; the window is stored in the + :attr:`window` attribute and only applied when FFTing the data. - def set_tukey_window(self, alpha: float = 0.4): + Arguments + --------- + alpha: float, optional + Shape parameter of the Tukey window (default: 0.2); this is + the fraction of the segment that is tapered on each side. + """ + logging.info(f"Setting Tukey window to {self.name} data") self.window = jnp.array(tukey(self.n_time, alpha)) - def fft(self, **kws) -> None: - if "window" in kws: - self.window = kws["window"] + def fft(self, window: Optional[Float[Array, " n_time"]] = None) -> None: + """Compute the Fourier transform of the data and store it + in the :attr:`fd` attribute. + + Arguments + --------- + **kws: dict, optional + Keyword arguments for the FFT; defaults to + """ + logging.info(f"Computing FFT of {self.name} data") + if window is not None: + self.window = window self.fd = jnp.fft.rfft(self.td * self.window) * self.delta_t def frequency_slice(self, f_min: float, f_max: float) -> \ - Float[Array, " n_sample"]: + tuple[Float[Array, " n_sample"], Float[Array, " n_sample"]]: + """Slice the data in the frequency domain. + + Arguments + --------- + f_min: float + Minimum frequency of the slice in Hz. + f_max: float + Maximum frequency of the slice in Hz. + + Returns + ------- + fd_slice: array + Sliced data in the frequency domain. + f_slice: array + Frequencies of the sliced data. + """ f = self.frequencies - return self.fd[(f >= f_min) & (f <= f_max)] + return self.fd[(f >= f_min) & (f <= f_max)], \ + f[(f >= f_min) & (f <= f_max)] + + def to_psd(self, **kws) -> "PowerSpectrum": + """Compute a Welch estimate of the power spectral density of the data. + + Arguments + --------- + **kws: dict, optional + Keyword arguments for `scipy.signal.welch` + + Returns + ------- + psd: PowerSpectrum + Power spectral density of the data. + """ + if not self.has_fd: + self.fft() + psd = jnp.abs(self.fd)**2 / self.duration + return PowerSpectrum(psd, self.frequencies, self.name) + + @classmethod + def from_gwosc(cls, + ifo: str, + gps_start_time: Float, + gps_end_time: Float, + **kws) -> "Data": + """Pull data from GWOSC. + + Arguments + --------- + gps_start_time: float + GPS start time of the data + gps_end_time: float + GPS end time of the data + **kws: dict, optional + Keyword arguments for `gwpy.timeseries.TimeSeries.fetch_open_data` + defaults to {} + """ + duration = gps_end_time - gps_start_time + logging.info(f"Fetching {duration} s of {ifo} data from GWOSC " + f"[{gps_start_time}, {gps_end_time}]") + + kws.update(_DEF_GWPY_KWARGS) + data_td = TimeSeries.fetch_open_data(ifo, gps_start_time, gps_end_time, + **kws) + return cls(data_td.value, data_td.dt.value, data_td.epoch.value, ifo) + + from_gwosc.__doc__ = from_gwosc.__doc__.format(_DEF_GWPY_KWARGS) + + +class PowerSpectrum(ABC): + name: str + values: Float[Array, " n_freq"] + frequencies: Float[Array, " n_freq"] + + @property + def n_freq(self) -> int: + """Number of frequency samples.""" + return len(self.values) + + @property + def delta_f(self) -> Float: + """Frequency resolution of the data in Hz.""" + return self.frequencies[1] - self.frequencies[0] + + @property + def duration(self) -> Float: + """Duration of the data in seconds.""" + return 1 / self.delta_f + + def __init__(self, values: Float[Array, " n_freq"], + frequencies: Float[Array, " n_freq"], + name: Optional[str] = None) -> None: + self.values = values + self.frequencies = frequencies + self.name = name or '' + + def slice(self, f_min: float, f_max: float) -> \ + tuple[Float[Array, " n_sample"], Float[Array, " n_sample"]]: + """Slice the power spectrum. + + Arguments + --------- + f_min: float + Minimum frequency of the slice in Hz. + f_max: float + Maximum frequency of the slice in Hz. + + Returns + ------- + psd_slice: PowerSpectrum + Sliced power spectrum. + """ + values = self.values[(self.frequencies >= f_min) & + (self.frequencies <= f_max)] + frequencies = self.frequencies[(self.frequencies >= f_min) & + (self.frequencies <= f_max)] + return values, frequencies + + def interpolate(self, f: Float[Array, " n_sample"]) -> "PowerSpectrum": + """Interpolate the power spectrum to a new set of frequencies. + + Arguments + --------- + f: array + Frequencies to interpolate the power spectrum to. + + Returns + ------- + psd_interp: array + Interpolated power spectrum. + """ + interp = interp1d(self.frequencies, self.values, kind='cubic') + return PowerSpectrum(interp(f), f, self.name) From ded8491f5822d1bd819d5b8a401a0e4e9dd916bc Mon Sep 17 00:00:00 2001 From: Max Isi Date: Wed, 16 Oct 2024 15:41:45 -0400 Subject: [PATCH 08/14] PSD from data --- src/jimgw/single_event/data.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/jimgw/single_event/data.py b/src/jimgw/single_event/data.py index c42f3e2f..071c86e7 100644 --- a/src/jimgw/single_event/data.py +++ b/src/jimgw/single_event/data.py @@ -9,6 +9,7 @@ from typing import Optional, Any from beartype import beartype as typechecker from scipy.interpolate import interp1d +import scipy.signal as sig from scipy.signal.windows import tukey from jimgw.constants import C_SI, EARTH_SEMI_MAJOR_AXIS, EARTH_SEMI_MINOR_AXIS @@ -176,23 +177,28 @@ def to_psd(self, **kws) -> "PowerSpectrum": """ if not self.has_fd: self.fft() - psd = jnp.abs(self.fd)**2 / self.duration - return PowerSpectrum(psd, self.frequencies, self.name) + freq, psd = sig.welch(self.td, fs=self.sampling_frequency, **kws) + return PowerSpectrum(jnp.array(psd), freq, self.name) @classmethod def from_gwosc(cls, ifo: str, gps_start_time: Float, gps_end_time: Float, + cache: bool = True, **kws) -> "Data": """Pull data from GWOSC. Arguments --------- + ifo: str + Interferometer name gps_start_time: float GPS start time of the data gps_end_time: float GPS end time of the data + cache: bool, optional + Whether to cache the data (default: True) **kws: dict, optional Keyword arguments for `gwpy.timeseries.TimeSeries.fetch_open_data` defaults to {} @@ -201,9 +207,8 @@ def from_gwosc(cls, logging.info(f"Fetching {duration} s of {ifo} data from GWOSC " f"[{gps_start_time}, {gps_end_time}]") - kws.update(_DEF_GWPY_KWARGS) data_td = TimeSeries.fetch_open_data(ifo, gps_start_time, gps_end_time, - **kws) + cache=cache, **kws) return cls(data_td.value, data_td.dt.value, data_td.epoch.value, ifo) from_gwosc.__doc__ = from_gwosc.__doc__.format(_DEF_GWPY_KWARGS) From 67c262595b2674cddaa8ae140d2fb645c6e416d4 Mon Sep 17 00:00:00 2001 From: Max Isi Date: Wed, 16 Oct 2024 17:27:28 -0400 Subject: [PATCH 09/14] detector wip --- src/jimgw/single_event/data.py | 35 ++++++++++++++++-------- src/jimgw/single_event/detector.py | 43 +++++++++++++++++------------- 2 files changed, 48 insertions(+), 30 deletions(-) diff --git a/src/jimgw/single_event/data.py b/src/jimgw/single_event/data.py index 071c86e7..2acd9531 100644 --- a/src/jimgw/single_event/data.py +++ b/src/jimgw/single_event/data.py @@ -1,3 +1,5 @@ +__include__ = ["Data", "PowerSpectrum"] + from abc import ABC, abstractmethod import jax @@ -25,8 +27,6 @@ "V1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-V1_sensitivity_strain_asd.txt", } -_DEF_GWPY_KWARGS = {"cache": True} - class Data(ABC): """ @@ -82,10 +82,10 @@ def has_fd(self) -> bool: """Whether the Fourier domain data has been computed.""" return bool(np.any(self.fd)) - def __init__(self, td: Float[Array, " n_time"], - delta_t: float, + def __init__(self, td: Float[Array, " n_time"] = jnp.array([]), + delta_t: float = 0., epoch: float = 0., - name: Optional[str] = None, + name: str = '', window: Optional[Float[Array, " n_time"]] = None)\ -> None: """Initialize the data class. @@ -113,6 +113,13 @@ def __init__(self, td: Float[Array, " n_time"], self.window = window self.name = name or '' + def __repr__(self): + return f"{self.__class__.__name__}(name='{self.name}', delta_t={self.delta_t}, epoch={self.epoch})" + + def __bool__(self) -> bool: + """Check if the data is empty.""" + return len(self.td) > 0 + def set_tukey_window(self, alpha: float = 0.2) -> None: """Create a Tukey window on the data; the window is stored in the :attr:`window` attribute and only applied when FFTing the data. @@ -201,7 +208,6 @@ def from_gwosc(cls, Whether to cache the data (default: True) **kws: dict, optional Keyword arguments for `gwpy.timeseries.TimeSeries.fetch_open_data` - defaults to {} """ duration = gps_end_time - gps_start_time logging.info(f"Fetching {duration} s of {ifo} data from GWOSC " @@ -211,9 +217,6 @@ def from_gwosc(cls, cache=cache, **kws) return cls(data_td.value, data_td.dt.value, data_td.epoch.value, ifo) - from_gwosc.__doc__ = from_gwosc.__doc__.format(_DEF_GWPY_KWARGS) - - class PowerSpectrum(ABC): name: str values: Float[Array, " n_freq"] @@ -234,13 +237,23 @@ def duration(self) -> Float: """Duration of the data in seconds.""" return 1 / self.delta_f - def __init__(self, values: Float[Array, " n_freq"], - frequencies: Float[Array, " n_freq"], + @property + def sampling_frequency(self) -> Float: + """Sampling frequency of the data in Hz.""" + return self.frequencies[-1] * 2 + + def __init__(self, values: Float[Array, " n_freq"] = jnp.array([]), + frequencies: Float[Array, " n_freq"] = jnp.array([]), name: Optional[str] = None) -> None: self.values = values self.frequencies = frequencies + assert len(self.values) == len(self.frequencies), \ + "Values and frequencies must have the same length" self.name = name or '' + def __repr__(self) -> str: + return f"{self.__class__.__name__}(name='{self.name}', frequencies={self.frequencies})" + def slice(self, f_min: float, f_max: float) -> \ tuple[Float[Array, " n_sample"], Float[Array, " n_sample"]]: """Slice the power spectrum. diff --git a/src/jimgw/single_event/detector.py b/src/jimgw/single_event/detector.py index c4c64de8..fce30d72 100644 --- a/src/jimgw/single_event/detector.py +++ b/src/jimgw/single_event/detector.py @@ -9,6 +9,7 @@ from beartype import beartype as typechecker from scipy.interpolate import interp1d from scipy.signal.windows import tukey +from . import data as jd from jimgw.constants import C_SI, EARTH_SEMI_MAJOR_AXIS, EARTH_SEMI_MINOR_AXIS from jimgw.single_event.wave import Polarization @@ -99,10 +100,8 @@ class GroundBased2G(Detector): Array of noise power spectral density. """ polarization_mode: list[Polarization] - frequencies: Float[Array, " n_sample"] - data: Float[Array, " n_sample"] - psd: Float[Array, " n_sample"] - epoch: Float = 0 + data: jd.Data + psd: jd.PowerSpectrum latitude: Float = 0 longitude: Float = 0 @@ -115,22 +114,26 @@ class GroundBased2G(Detector): def __repr__(self) -> str: return f"{self.__class__.__name__}({self.name})" - def __init__(self, name: str, **kwargs) -> None: + def __init__(self, name: str, latitude: float = 0, longitude: float = 0, + elevation: float = 0, xarm_azimuth: float = 0, + yarm_azimuth: float = 0, xarm_tilt: float = 0, + yarm_tilt: float = 0, modes: str = "pc"): self.name = name - self.latitude = kwargs.get("latitude", 0) - self.longitude = kwargs.get("longitude", 0) - self.elevation = kwargs.get("elevation", 0) - self.xarm_azimuth = kwargs.get("xarm_azimuth", 0) - self.yarm_azimuth = kwargs.get("yarm_azimuth", 0) - self.xarm_tilt = kwargs.get("xarm_tilt", 0) - self.yarm_tilt = kwargs.get("yarm_tilt", 0) - modes = kwargs.get("mode", "pc") + self.latitude = latitude + self.longitude = longitude + self.elevation = elevation + self.xarm_azimuth = xarm_azimuth + self.yarm_azimuth = yarm_azimuth + self.xarm_tilt = xarm_tilt + self.yarm_tilt = yarm_tilt self.polarization_mode = [Polarization(m) for m in modes] - self.frequencies = jnp.array([]) - self.data = jnp.array([]) - self.psd = jnp.array([]) + self.data = jd.Data() + + # self.frequencies = jnp.array([]) + # self.data = jnp.array([]) + # self.psd = jnp.array([]) @staticmethod def _get_arm( @@ -312,6 +315,8 @@ def load_data( self.psd = psd[(freq > f_min) & (freq < f_max)] load_data.__doc__ = load_data.__doc__.format(_DEF_GWPY_KWARGS) + # def load_data(self, data: ) + def fd_response( self, frequency: Float[Array, " n_sample"], @@ -494,7 +499,7 @@ def load_psd( xarm_tilt=-6.195e-4, yarm_tilt=1.25e-5, elevation=142.554, - mode="pc", + modes="pc", ) L1 = GroundBased2G( @@ -506,7 +511,7 @@ def load_psd( xarm_tilt=0, yarm_tilt=0, elevation=-6.574, - mode="pc", + modes="pc", ) V1 = GroundBased2G( @@ -518,7 +523,7 @@ def load_psd( xarm_tilt=0, yarm_tilt=0, elevation=51.884, - mode="pc", + modes="pc", ) detector_preset = { From c114ba01652d4d4ec8d35e4c80e344c4dd17fee5 Mon Sep 17 00:00:00 2001 From: Max Isi Date: Fri, 18 Oct 2024 11:55:51 -0400 Subject: [PATCH 10/14] propagating detector changes to likelihood --- src/jimgw/single_event/data.py | 119 ++++++++++---- src/jimgw/single_event/detector.py | 232 ++++++++++----------------- src/jimgw/single_event/likelihood.py | 41 +++-- 3 files changed, 194 insertions(+), 198 deletions(-) diff --git a/src/jimgw/single_event/data.py b/src/jimgw/single_event/data.py index 2acd9531..af9deda8 100644 --- a/src/jimgw/single_event/data.py +++ b/src/jimgw/single_event/data.py @@ -1,41 +1,36 @@ __include__ = ["Data", "PowerSpectrum"] -from abc import ABC, abstractmethod +from abc import ABC -import jax import jax.numpy as jnp import numpy as np -import requests from gwpy.timeseries import TimeSeries -from jaxtyping import Array, Float, PRNGKeyArray, jaxtyped, Complex -from typing import Optional, Any -from beartype import beartype as typechecker +from jaxtyping import Array, Float, Complex, PRNGKeyArray +from typing import Optional +# from beartype import beartype as typechecker from scipy.interpolate import interp1d import scipy.signal as sig from scipy.signal.windows import tukey - -from jimgw.constants import C_SI, EARTH_SEMI_MAJOR_AXIS, EARTH_SEMI_MINOR_AXIS -from jimgw.single_event.wave import Polarization import logging +import jax + DEG_TO_RAD = jnp.pi / 180 # TODO: Need to expand this list. Currently it is only O3. asd_file_dict = { - "H1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-H1-C01_CLEAN_SUB60HZ-1251752040.0_sensitivity_strain_asd.txt", - "L1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-L1-C01_CLEAN_SUB60HZ-1240573680.0_sensitivity_strain_asd.txt", - "V1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-V1_sensitivity_strain_asd.txt", + "H1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-H1-C01_CLEAN_SUB60HZ-1251752040.0_sensitivity_strain_asd.txt", # noqa: E501 + "L1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-L1-C01_CLEAN_SUB60HZ-1240573680.0_sensitivity_strain_asd.txt", # noqa: E501 + "V1": "https://dcc.ligo.org/public/0169/P2000251/001/O3-V1_sensitivity_strain_asd.txt", # noqa: E501 } class Data(ABC): - """ - Base class for all data. The time domain data are considered the primary - entitiy; the Fourier domain data are derived from an FFT after applying a - window. The structure is set up so that :attr:`td` and :attr:`fd` are always - Fourier conjugates of each other: the one-sided Fourier series is complete - up to the Nyquist frequency - + """Base class for all data. The time domain data are considered the primary + entity; the Fourier domain data are derived from an FFT after applying a + window. The structure is set up so that :attr:`td` and :attr:`fd` are + always Fourier conjugates of each other: the one-sided Fourier series is + complete up to the Nyquist frequency. """ name: str @@ -108,13 +103,14 @@ def __init__(self, td: Float[Array, " n_time"] = jnp.array([]), self.delta_t = delta_t self.epoch = epoch if window is None: - self.window = jnp.ones_like(self.td) + self.set_tukey_window() else: self.window = window self.name = name or '' def __repr__(self): - return f"{self.__class__.__name__}(name='{self.name}', delta_t={self.delta_t}, epoch={self.epoch})" + return f"{self.__class__.__name__}(name='{self.name}', " + \ + f"delta_t={self.delta_t}, epoch={self.epoch})" def __bool__(self) -> bool: """Check if the data is empty.""" @@ -215,7 +211,8 @@ def from_gwosc(cls, data_td = TimeSeries.fetch_open_data(ifo, gps_start_time, gps_end_time, cache=cache, **kws) - return cls(data_td.value, data_td.dt.value, data_td.epoch.value, ifo) + return cls(data_td.value, data_td.dt.value, data_td.epoch.value, ifo) # type: ignore # noqa: E501 + class PowerSpectrum(ABC): name: str @@ -240,7 +237,7 @@ def duration(self) -> Float: @property def sampling_frequency(self) -> Float: """Sampling frequency of the data in Hz.""" - return self.frequencies[-1] * 2 + return self.frequencies[-1] * 2 def __init__(self, values: Float[Array, " n_freq"] = jnp.array([]), frequencies: Float[Array, " n_freq"] = jnp.array([]), @@ -252,10 +249,15 @@ def __init__(self, values: Float[Array, " n_freq"] = jnp.array([]), self.name = name or '' def __repr__(self) -> str: - return f"{self.__class__.__name__}(name='{self.name}', frequencies={self.frequencies})" + return f"{self.__class__.__name__}(name='{self.name}', " + \ + f"frequencies={self.frequencies})" + + def __bool__(self) -> bool: + """Check if the power spectrum is empty.""" + return len(self.values) > 0 - def slice(self, f_min: float, f_max: float) -> \ - tuple[Float[Array, " n_sample"], Float[Array, " n_sample"]]: + def frequency_slice(self, f_min: float, f_max: float) -> \ + tuple[Float[Array, " n_sample"], Float[Array, " n_sample"]]: """Slice the power spectrum. Arguments @@ -270,24 +272,75 @@ def slice(self, f_min: float, f_max: float) -> \ psd_slice: PowerSpectrum Sliced power spectrum. """ - values = self.values[(self.frequencies >= f_min) & - (self.frequencies <= f_max)] - frequencies = self.frequencies[(self.frequencies >= f_min) & - (self.frequencies <= f_max)] - return values, frequencies + mask = (self.frequencies >= f_min) & (self.frequencies <= f_max) + return self.values[mask], self.frequencies[mask] - def interpolate(self, f: Float[Array, " n_sample"]) -> "PowerSpectrum": + def interpolate(self, f: Float[Array, " n_sample"], + kind: str = 'cubic', **kws) -> "PowerSpectrum": """Interpolate the power spectrum to a new set of frequencies. Arguments --------- f: array Frequencies to interpolate the power spectrum to. + kind: str, optional + Interpolation method (default: 'cubic') + **kws: dict, optional + Keyword arguments for `scipy.interpolate.interp1d` Returns ------- psd_interp: array Interpolated power spectrum. """ - interp = interp1d(self.frequencies, self.values, kind='cubic') + interp = interp1d(self.frequencies, self.values, kind=kind, **kws) return PowerSpectrum(interp(f), f, self.name) + + def simulate_data( + self, + key: PRNGKeyArray, + # freqs: Float[Array, " n_sample"], + # h_sky: dict[str, Float[Array, " n_sample"]], + # params: dict[str, Float], + # psd_file: str = "", + ) -> Complex[Array, " n_sample"]: + """ + Inject a signal into the detector data. + + Parameters + ---------- + key : PRNGKeyArray + JAX PRNG key. + h_sky : dict[str, Float[Array, " n_sample"]] + Array of waveforms in the sky frame. The key is the polarization + mode. + params : dict[str, Float] + Dictionary of parameters. + psd_file : str + Path to the PSD file. + + Returns + ------- + None + """ + key, subkey = jax.random.split(key, 2) + var = self.values / (4 * self.delta_f) + noise_real = jax.random.normal(key, shape=var.shape) * jnp.sqrt(var) + noise_imag = jax.random.normal(subkey, shape=var.shape) * jnp.sqrt(var) + return noise_real + 1j * noise_imag + + # WIP: this should be moved to Detector class + + # align_time = jnp.exp( + # -1j * 2 * jnp.pi * freqs * (params["epoch"] + params["t_c"]) + # ) + # signal = self.fd_response(freqs, h_sky, params) * align_time + # self.data = signal + noise_real + 1j * noise_imag + + # # also calculate the optimal SNR and match filter SNR + # optimal_SNR = jnp.sqrt(jnp.sum(signal * signal.conj() / var).real) + # match_filter_SNR = jnp.sum(self.data * signal.conj() / var) / optimal_SNR + + # print(f"For detector {self.name}:") + # print(f"The injected optimal SNR is {optimal_SNR}") + # print(f"The injected match filter SNR is {match_filter_SNR}") diff --git a/src/jimgw/single_event/detector.py b/src/jimgw/single_event/detector.py index fce30d72..7a26f876 100644 --- a/src/jimgw/single_event/detector.py +++ b/src/jimgw/single_event/detector.py @@ -10,6 +10,7 @@ from scipy.interpolate import interp1d from scipy.signal.windows import tukey from . import data as jd +from typing import Optional from jimgw.constants import C_SI, EARTH_SEMI_MAJOR_AXIS, EARTH_SEMI_MINOR_AXIS from jimgw.single_event.wave import Polarization @@ -28,15 +29,17 @@ class Detector(ABC): - """ - Base class for all detectors. - + """Base class for all detectors. """ name: str - data: Float[Array, " n_sample"] - psd: Float[Array, " n_sample"] + # NOTE: for some detectors (e.g. LISA, ET) data could be a list of Data + # objects so this might be worth revisiting + data: jd.Data + psd: jd.PowerSpectrum + + frequency_bounds: tuple[float, float] = (0., float("inf")) @abstractmethod def fd_response( @@ -46,9 +49,9 @@ def fd_response( params: dict, **kwargs, ) -> Float[Array, " n_sample"]: + """Modulate the waveform in the sky frame by the detector response + in the frequency domain. """ - Modulate the waveform in the sky frame by the detector response - in the frequency domain.""" pass @abstractmethod @@ -59,11 +62,37 @@ def td_response( params: dict, **kwargs, ) -> Float[Array, " n_sample"]: + """Modulate the waveform in the sky frame by the detector response + in the time domain. """ - Modulate the waveform in the sky frame by the detector response - in the time domain.""" pass + def set_frequency_bounds(self, f_min: Optional[float] = None, + f_max: Optional[float] = None) -> None: + """Set the frequency bounds for the detector. + + Parameters + ---------- + f_min : float + Minimum frequency. + f_max : float + Maximum frequency. + """ + bounds = list(self.frequency_bounds) + if f_min is not None: + bounds[0] = f_min + if f_max is not None: + bounds[1] = f_max + self.frequency_bounds = tuple(bounds) # type: ignore + + @property + def fd_data_slice(self): + return self.data.frequency_slice(*self.frequency_bounds) + + @property + def psd_slice(self): + return self.psd.frequency_slice(*self.frequency_bounds) + class GroundBased2G(Detector): """Object representing a ground-based detector. Contains information @@ -115,8 +144,8 @@ def __repr__(self) -> str: return f"{self.__class__.__name__}({self.name})" def __init__(self, name: str, latitude: float = 0, longitude: float = 0, - elevation: float = 0, xarm_azimuth: float = 0, - yarm_azimuth: float = 0, xarm_tilt: float = 0, + elevation: float = 0, xarm_azimuth: float = 0, + yarm_azimuth: float = 0, xarm_tilt: float = 0, yarm_tilt: float = 0, modes: str = "pc"): self.name = name @@ -130,10 +159,7 @@ def __init__(self, name: str, latitude: float = 0, longitude: float = 0, self.polarization_mode = [Polarization(m) for m in modes] self.data = jd.Data() - - # self.frequencies = jnp.array([]) - # self.data = jnp.array([]) - # self.psd = jnp.array([]) + self.psd = jd.PowerSpectrum() @staticmethod def _get_arm( @@ -159,10 +185,12 @@ def _get_arm( """ e_lon = jnp.array([-jnp.sin(lon), jnp.cos(lon), 0]) e_lat = jnp.array( - [-jnp.sin(lat) * jnp.cos(lon), -jnp.sin(lat) * jnp.sin(lon), jnp.cos(lat)] + [-jnp.sin(lat) * jnp.cos(lon), -jnp.sin(lat) + * jnp.sin(lon), jnp.cos(lat)] ) e_h = jnp.array( - [jnp.cos(lat) * jnp.cos(lon), jnp.cos(lat) * jnp.sin(lon), jnp.sin(lat)] + [jnp.cos(lat) * jnp.cos(lon), jnp.cos(lat) + * jnp.sin(lon), jnp.sin(lat)] ) return ( @@ -209,9 +237,8 @@ def tensor(self) -> Float[Array, " 3 3"]: """ # TODO: this could easily be generalized for other detector geometries arm1, arm2 = self.arms - return 0.5 * ( - jnp.einsum("i,j->ij", arm1, arm1) - jnp.einsum("i,j->ij", arm2, arm2) - ) + return 0.5 * jnp.einsum("i,j->ij", arm1, arm1) - \ + jnp.einsum("i,j->ij", arm2, arm2) @property def vertex(self) -> Float[Array, " 3"]: @@ -238,85 +265,6 @@ def vertex(self) -> Float[Array, " 3"]: z = ((minor / major) ** 2 * r + h) * jnp.sin(lat) return jnp.array([x, y, z]) - def load_data( - self, - trigger_time: Float, - gps_start_pad: int, - gps_end_pad: int, - f_min: Float, - f_max: Float, - psd_pad: int = 16, - tukey_alpha: Float = 0.2, - gwpy_kwargs: dict | None = None, - ) -> None: - """Load open GW detector data from GWOSC using GWpy. Essentially, this - is a wrapper around the GWpy :meth:`TimeSeries.fetch_open_data` - method. - - Parameters - ---------- - trigger_time : Float - The GPS time of the trigger. - gps_start_pad : int - The amount of time before the trigger to fetch data. - gps_end_pad : int - The amount of time after the trigger to fetch data. - f_min : Float - The minimum frequency to fetch data. - f_max : Float - The maximum frequency to fetch data. - tukey_alpha : Float - The ``alpha`` parameter for the Tukey window; this represents - the fraction of the segment duration that is tapered on each end - (defaults to 0.2). - gwpy_kwargs : dict, optional - Additional keyword arguments to pass to the GWpy - :meth:`TimeSeries.fetch_open_data` method, defaults to - {}. - """ - if gwpy_kwargs is None: - gwpy_kwargs = _DEF_GWPY_KWARGS - - duration = gps_end_pad + gps_start_pad - logging.info(f"Fetching {duration} s of {self.name} data around " - f"{trigger_time} from GWOSC.") - - data_td = TimeSeries.fetch_open_data( - self.name, - trigger_time - gps_start_pad, - trigger_time + gps_end_pad, - **gwpy_kwargs, - ) - assert isinstance(data_td, TimeSeries), "Data is not a TimeSeries object." - segment_length = data_td.duration.value - n = len(data_td) - delta_t = data_td.dt.value # type: ignore - data = jnp.fft.rfft(jnp.array(data_td.value) * tukey(n, tukey_alpha)) * delta_t - freq = jnp.fft.rfftfreq(n, delta_t) - # TODO: Check if this is the right way to fetch PSD - start_psd = int(trigger_time) - gps_start_pad - 2 * psd_pad - end_psd = int(trigger_time) - gps_start_pad - psd_pad - - print("Fetching PSD data...") - psd_data_td = TimeSeries.fetch_open_data( - self.name, start_psd, end_psd, **gwpy_kwargs - ) - assert isinstance( - psd_data_td, TimeSeries - ), "PSD data is not a TimeSeries object." - psd = psd_data_td.psd( - fftlength=segment_length - ).value # TODO: Check whether this is sright. - - print("Finished loading data.") - - self.frequencies = freq[(freq > f_min) & (freq < f_max)] - self.data = data[(freq > f_min) & (freq < f_max)] - self.psd = psd[(freq > f_min) & (freq < f_max)] - load_data.__doc__ = load_data.__doc__.format(_DEF_GWPY_KWARGS) - - # def load_data(self, data: ) - def fd_response( self, frequency: Float[Array, " n_sample"], @@ -422,55 +370,6 @@ def antenna_pattern(self, ra: Float, dec: Float, psi: Float, gmst: Float) -> dic return antenna_patterns - def inject_signal( - self, - key: PRNGKeyArray, - freqs: Float[Array, " n_sample"], - h_sky: dict[str, Float[Array, " n_sample"]], - params: dict[str, Float], - psd_file: str = "", - ) -> None: - """ - Inject a signal into the detector data. - - Parameters - ---------- - key : PRNGKeyArray - JAX PRNG key. - freqs : Float[Array, " n_sample"] - Array of frequencies. - h_sky : dict[str, Float[Array, " n_sample"]] - Array of waveforms in the sky frame. The key is the polarization mode. - params : dict[str, Float] - Dictionary of parameters. - psd_file : str - Path to the PSD file. - - Returns - ------- - None - """ - self.frequencies = freqs - self.psd = self.load_psd(freqs, psd_file) - key, subkey = jax.random.split(key, 2) - var = self.psd / (4 * (freqs[1] - freqs[0])) - noise_real = jax.random.normal(key, shape=freqs.shape) * jnp.sqrt(var / 2.0) - noise_imag = jax.random.normal(subkey, shape=freqs.shape) * jnp.sqrt(var / 2.0) - align_time = jnp.exp( - -1j * 2 * jnp.pi * freqs * (params["epoch"] + params["t_c"]) - ) - - signal = self.fd_response(freqs, h_sky, params) * align_time - self.data = signal + noise_real + 1j * noise_imag - - # also calculate the optimal SNR and match filter SNR - optimal_SNR = jnp.sqrt(jnp.sum(signal * signal.conj() / var).real) - match_filter_SNR = jnp.sum(self.data * signal.conj() / var) / optimal_SNR - - print(f"For detector {self.name}:") - print(f"The injected optimal SNR is {optimal_SNR}") - print(f"The injected match filter SNR is {match_filter_SNR}") - @jaxtyped(typechecker=typechecker) def load_psd( self, freqs: Float[Array, " n_sample"], psd_file: str = "" @@ -485,10 +384,45 @@ def load_psd( else: f, psd_vals = np.loadtxt(psd_file, unpack=True) - psd = interp1d(f, psd_vals, fill_value=(psd_vals[0], psd_vals[-1]))(freqs) # type: ignore + psd = interp1d(f, psd_vals, fill_value=( + psd_vals[0], psd_vals[-1]))(freqs) # type: ignore psd = jnp.array(psd) return psd + def set_data(self, data: jd.Data | Array, **kws) -> None: + """Add data to detector. + + Arguments + --------- + data : jd.Data | Array + Data to be added to the detector, either as a `jd.Data` object + or as a timeseries array. + kws : dict + Additional keyword arguments to pass to `jd.Data` constructor. + """ + if isinstance(data, jd.Data): + self.data = data + else: + self.data = jd.Data(data, **kws) + + def set_psd(self, psd: jd.PowerSpectrum | Array, **kws) -> None: + """Add PSD to detector. + + Arguments + --------- + psd : jd.PowerSpectrum | Array + PSD to be added to the detector, either as a `jd.PowerSpectrum` + object or as a timeseries array. + kws : dict + Additional keyword arguments to pass to `jd.PowerSpectrum` + constructor. + """ + if isinstance(psd, jd.PowerSpectrum): + self.psd = psd + else: + # not clear if we want to support this + self.psd = jd.PowerSpectrum(psd, **kws) + H1 = GroundBased2G( "H1", diff --git a/src/jimgw/single_event/likelihood.py b/src/jimgw/single_event/likelihood.py index f8f69a7a..fe280f1b 100644 --- a/src/jimgw/single_event/likelihood.py +++ b/src/jimgw/single_event/likelihood.py @@ -11,10 +11,11 @@ from jimgw.base import LikelihoodBase from jimgw.prior import Prior -from jimgw.single_event.detector import Detector +from jimgw.single_event.detector import Detector, GroundBased2G from jimgw.utils import log_i0 from jimgw.single_event.waveform import Waveform from jimgw.transforms import BijectiveTransform, NtoMTransform +import logging class SingleEventLikelihood(LikelihoodBase): @@ -40,31 +41,37 @@ def __init__( self, detectors: list[Detector], waveform: Waveform, + f_min: float = 0, + f_max: float = float("inf"), trigger_time: float = 0, - duration: float = 4, post_trigger_duration: float = 2, - # TODO: apply f_min and f_max and get frequency domain data - # here **kwargs, ) -> None: self.detectors = detectors - assert jnp.all( - jnp.array( - [ - (self.detectors[0].frequencies == detector.frequencies).all() # type: ignore - for detector in self.detectors - ] - ) + + # TODO: we can probably make this a bit more elegant + for det in detectors: + if not det.data.has_fd: + logging.info("Computing FFT with default window") + det.data.fft() + det.set_frequency_bounds(f_min, f_max) + + freqs = [d.data.frequency_slice(f_min, f_max)[1] for d in detectors] + assert all([ + (freqs[0] + == freq).all() # noqa: W503 + for freq in freqs] ), "The detectors must have the same frequency grid" - self.frequencies = self.detectors[0].frequencies # type: ignore + self.frequencies = freqs[0] # type: ignore self.waveform = waveform self.trigger_time = trigger_time self.gmst = ( - Time(trigger_time, format="gps").sidereal_time("apparent", "greenwich").rad + Time(trigger_time, format="gps").sidereal_time("apparent", + "greenwich").rad ) self.trigger_time = trigger_time - self.duration = duration + self.duration = duration = self.detectors[0].data.duration self.post_trigger_duration = post_trigger_duration self.kwargs = kwargs if "marginalization" in self.kwargs: @@ -647,10 +654,12 @@ def original_likelihood( df = freqs[1] - freqs[0] for detector in detectors: h_dec = detector.fd_response(freqs, h_sky, params) * align_time + data = detector.fd_data_slice + psd = detector.psd_slice match_filter_SNR = ( - 4 * jnp.sum((jnp.conj(h_dec) * detector.data) / detector.psd * df).real + 4 * jnp.sum((jnp.conj(h_dec) * data) / psd * df).real ) - optimal_SNR = 4 * jnp.sum(jnp.conj(h_dec) * h_dec / detector.psd * df).real + optimal_SNR = 4 * jnp.sum(jnp.conj(h_dec) * h_dec / psd * df).real log_likelihood += match_filter_SNR - optimal_SNR / 2 return log_likelihood From e032436eee6901f458d409db8c65b152300a2e9a Mon Sep 17 00:00:00 2001 From: Max Isi Date: Fri, 18 Oct 2024 16:14:32 -0400 Subject: [PATCH 11/14] likelihood api --- example/GW150914_IMRPhenomPV2.py | 21 +++++- src/jimgw/single_event/data.py | 2 +- src/jimgw/single_event/likelihood.py | 101 +++++++++++++++++---------- 3 files changed, 82 insertions(+), 42 deletions(-) diff --git a/example/GW150914_IMRPhenomPV2.py b/example/GW150914_IMRPhenomPV2.py index 11936abc..7cf79424 100644 --- a/example/GW150914_IMRPhenomPV2.py +++ b/example/GW150914_IMRPhenomPV2.py @@ -26,6 +26,7 @@ ) from jimgw.single_event.utils import Mc_q_to_m1_m2 from flowMC.strategy.optimization import optimization_Adam +from jimgw.single_event import data as jd jax.config.update("jax_enable_x64", True) @@ -36,16 +37,30 @@ total_time_start = time.time() # first, fetch a 4s segment centered on GW150914 +# for the analysis gps = 1126259462.4 start = gps - 2 end = gps + 2 + +# fetch 4096s of data to estimate the PSD (to be +# careful we should avoid the on-source segment, +# but we don't do this in this example) +psd_start = gps - 2048 +psd_end = gps + 2048 + +# define frequency integration bounds for the likelihood fmin = 20.0 -fmax = 1024.0 +fmax = 1000.0 ifos = [H1, L1] -H1.load_data(gps, 2, 2, fmin, fmax, psd_pad=16, tukey_alpha=0.2) -L1.load_data(gps, 2, 2, fmin, fmax, psd_pad=16, tukey_alpha=0.2) +for ifo in ifos: + data = jd.Data.from_gwosc(ifo.name, start, end) + ifo.set_data(data) + + psd_data = jd.Data.from_gwosc(ifo.name, psd_start, psd_end) + psd_fftlength = data.duration * data.sampling_frequency + ifo.set_psd(psd_data.to_psd(nperseg=psd_fftlength)) waveform = RippleIMRPhenomPv2(f_ref=20) diff --git a/src/jimgw/single_event/data.py b/src/jimgw/single_event/data.py index af9deda8..bfe6b4d9 100644 --- a/src/jimgw/single_event/data.py +++ b/src/jimgw/single_event/data.py @@ -98,6 +98,7 @@ def __init__(self, td: Float[Array, " n_time"] = jnp.array([]), window: array, optional Window function to apply to the data before FFT (default: None) """ + self.name = name or '' self.td = td self.fd = jnp.zeros(self.n_freq) self.delta_t = delta_t @@ -106,7 +107,6 @@ def __init__(self, td: Float[Array, " n_time"] = jnp.array([]), self.set_tukey_window() else: self.window = window - self.name = name or '' def __repr__(self): return f"{self.__class__.__name__}(name='{self.name}', " + \ diff --git a/src/jimgw/single_event/likelihood.py b/src/jimgw/single_event/likelihood.py index fe280f1b..47bd591a 100644 --- a/src/jimgw/single_event/likelihood.py +++ b/src/jimgw/single_event/likelihood.py @@ -41,28 +41,42 @@ def __init__( self, detectors: list[Detector], waveform: Waveform, - f_min: float = 0, - f_max: float = float("inf"), - trigger_time: float = 0, - post_trigger_duration: float = 2, + f_min: Float = 0, + f_max: Float = float("inf"), + trigger_time: Float = 0, + post_trigger_duration: Float = 2, **kwargs, ) -> None: self.detectors = detectors - # TODO: we can probably make this a bit more elegant + # make sure data has a Fourier representation for det in detectors: if not det.data.has_fd: logging.info("Computing FFT with default window") det.data.fft() - det.set_frequency_bounds(f_min, f_max) - - freqs = [d.data.frequency_slice(f_min, f_max)[1] for d in detectors] - assert all([ - (freqs[0] - == freq).all() # noqa: W503 - for freq in freqs] - ), "The detectors must have the same frequency grid" + + # collect the data, psd and frequencies for the requested band + freqs = [] + datas = [] + psds = [] + for detector in detectors: + data, freq_0 = detector.data.frequency_slice(f_min, f_max) + psd, freq_1 = detector.psd.frequency_slice(f_min, f_max) + freqs.append(freq_0) + datas.append(data) + psds.append(psd) + # make sure the psd and data are consistent + assert (freq_0 == freq_1).all(), \ + f"The {detector.name} data and PSD must have same frequencies" + + # make sure all detectors are consistent + assert all([(freqs[0] == freq).all() for freq in freqs]), \ + "The detectors must have the same frequency grid" + self.frequencies = freqs[0] # type: ignore + self.datas = [d.data.frequency_slice(f_min, f_max)[0] for d in detectors] + self.psds = [d.psd.frequency_slice(f_min, f_max)[0] for d in detectors] + self.waveform = waveform self.trigger_time = trigger_time self.gmst = ( @@ -85,15 +99,15 @@ def __init__( if self.marginalization == "phase-time": self.param_func = lambda x: {**x, "phase_c": 0.0, "t_c": 0.0} self.likelihood_function = phase_time_marginalized_likelihood - print("Marginalizing over phase and time") + logging.info("Marginalizing over phase and time") elif self.marginalization == "time": self.param_func = lambda x: {**x, "t_c": 0.0} self.likelihood_function = time_marginalized_likelihood - print("Marginalizing over time") + logging.info("Marginalizing over time") elif self.marginalization == "phase": self.param_func = lambda x: {**x, "phase_c": 0.0} self.likelihood_function = phase_marginalized_likelihood - print("Marginalizing over phase") + logging.info("Marginalizing over phase") if "time" in self.marginalization: fs = kwargs["sampling_rate"] @@ -136,22 +150,19 @@ def __init__( @property def epoch(self): - """ - The epoch of the data. + """The epoch of the data. """ return self.duration - self.post_trigger_duration @property def ifos(self): - """ - The interferometers for the likelihood. + """The interferometers for the likelihood. """ return [detector.name for detector in self.detectors] def evaluate(self, params: dict[str, Float], data: dict) -> Float: # TODO: Test whether we need to pass data in or with class changes is fine. - """ - Evaluate the likelihood for a given set of parameters. + """Evaluate the likelihood for a given set of parameters. """ frequencies = self.frequencies params["gmst"] = self.gmst @@ -169,6 +180,8 @@ def evaluate(self, params: dict[str, Float], data: dict) -> Float: waveform_sky, self.detectors, frequencies, + self.datas, + self.psds, align_time, **self.kwargs, ) @@ -203,9 +216,10 @@ def __init__( self, detectors: list[Detector], waveform: Waveform, + f_min: Float = 0, + f_max: Float = float("inf"), n_bins: int = 100, trigger_time: float = 0, - duration: float = 4, post_trigger_duration: float = 2, popsize: int = 100, n_steps: int = 2000, @@ -217,10 +231,10 @@ def __init__( **kwargs, ) -> None: super().__init__( - detectors, waveform, trigger_time, duration, post_trigger_duration + detectors, waveform, f_min, f_max, trigger_time, post_trigger_duration ) - print("Initializing heterodyned likelihood..") + logging.info("Initializing heterodyned likelihood..") # Can use another waveform to use as reference waveform, but if not provided, use the same waveform if reference_waveform is None: @@ -299,7 +313,7 @@ def __init__( print("The eta of the reference parameter is close to 0.25") print(f"The eta is adjusted to {self.ref_params['eta']}") - print("Constructing reference waveforms..") + logging.info("Constructing reference waveforms..") self.ref_params["gmst"] = self.gmst # adjust the params due to different marginalzation scheme @@ -647,15 +661,16 @@ def original_likelihood( h_sky: dict[str, Float[Array, " n_dim"]], detectors: list[Detector], freqs: Float[Array, " n_dim"], + datas: list[Float[Array, " n_dim"]], + psds: list[Float[Array, " n_dim"]], align_time: Float, **kwargs, ) -> Float: log_likelihood = 0.0 df = freqs[1] - freqs[0] - for detector in detectors: + for detector, data, psd in zip(detectors, datas, psds): h_dec = detector.fd_response(freqs, h_sky, params) * align_time - data = detector.fd_data_slice - psd = detector.psd_slice + # NOTE: do we want to take the slide outside the likelihood? match_filter_SNR = ( 4 * jnp.sum((jnp.conj(h_dec) * data) / psd * df).real ) @@ -670,18 +685,22 @@ def phase_marginalized_likelihood( h_sky: dict[str, Float[Array, " n_dim"]], detectors: list[Detector], freqs: Float[Array, " n_dim"], + datas: list[Float[Array, " n_dim"]], + psds: list[Float[Array, " n_dim"]], align_time: Float, **kwargs, ) -> Float: log_likelihood = 0.0 complex_d_inner_h = 0.0 df = freqs[1] - freqs[0] - for detector in detectors: + f_min = freqs[0] + f_max = freqs[-1] + for detector, data, psd in zip(detectors, datas, psds): h_dec = detector.fd_response(freqs, h_sky, params) * align_time complex_d_inner_h += 4 * jnp.sum( - (jnp.conj(h_dec) * detector.data) / detector.psd * df + (jnp.conj(h_dec) * data) / psd * df ) - optimal_SNR = 4 * jnp.sum(jnp.conj(h_dec) * h_dec / detector.psd * df).real + optimal_SNR = 4 * jnp.sum(jnp.conj(h_dec) * h_dec / psd * df).real log_likelihood += -optimal_SNR / 2 log_likelihood += log_i0(jnp.absolute(complex_d_inner_h)) @@ -694,17 +713,21 @@ def time_marginalized_likelihood( h_sky: dict[str, Float[Array, " n_dim"]], detectors: list[Detector], freqs: Float[Array, " n_dim"], + datas: list[Float[Array, " n_dim"]], + psds: list[Float[Array, " n_dim"]], align_time: Float, **kwargs, ) -> Float: log_likelihood = 0.0 df = freqs[1] - freqs[0] + f_min = freqs[0] + f_max = freqs[-1] # using instead of complex_h_inner_d = jnp.zeros_like(freqs) - for detector in detectors: + for detector, data, psd in zip(detectors, datas, psds): h_dec = detector.fd_response(freqs, h_sky, params) * align_time - complex_h_inner_d += 4 * h_dec * jnp.conj(detector.data) / detector.psd * df - optimal_SNR = 4 * jnp.sum(jnp.conj(h_dec) * h_dec / detector.psd * df).real + complex_h_inner_d += 4 * h_dec * jnp.conj(data) / detector.psd * df + optimal_SNR = 4 * jnp.sum(jnp.conj(h_dec) * h_dec / psd * df).real log_likelihood += -optimal_SNR / 2 # fetch the tc range tc_array, lower padding and higher padding @@ -743,6 +766,8 @@ def phase_time_marginalized_likelihood( h_sky: dict[str, Float[Array, " n_dim"]], detectors: list[Detector], freqs: Float[Array, " n_dim"], + datas: list[Float[Array, " n_dim"]], + psds: list[Float[Array, " n_dim"]], align_time: Float, **kwargs, ) -> Float: @@ -750,10 +775,10 @@ def phase_time_marginalized_likelihood( df = freqs[1] - freqs[0] # using instead of complex_h_inner_d = jnp.zeros_like(freqs) - for detector in detectors: + for detector, data, psd in zip(detectors, datas, psds): h_dec = detector.fd_response(freqs, h_sky, params) * align_time - complex_h_inner_d += 4 * h_dec * jnp.conj(detector.data) / detector.psd * df - optimal_SNR = 4 * jnp.sum(jnp.conj(h_dec) * h_dec / detector.psd * df).real + complex_h_inner_d += 4 * h_dec * jnp.conj(data) / psd * df + optimal_SNR = 4 * jnp.sum(jnp.conj(h_dec) * h_dec / psd * df).real log_likelihood += -optimal_SNR / 2 # fetch the tc range tc_array, lower padding and higher padding From a84c8e090565dd0ac7a3786f66182865d53c2b68 Mon Sep 17 00:00:00 2001 From: Max Isi Date: Mon, 28 Oct 2024 11:55:40 -0400 Subject: [PATCH 12/14] pep flake --- example/GW150914_IMRPhenomPV2.py | 55 +++++++++++++++++++++----------- 1 file changed, 36 insertions(+), 19 deletions(-) diff --git a/example/GW150914_IMRPhenomPV2.py b/example/GW150914_IMRPhenomPV2.py index 7cf79424..08f48dac 100644 --- a/example/GW150914_IMRPhenomPV2.py +++ b/example/GW150914_IMRPhenomPV2.py @@ -1,3 +1,4 @@ +import optax import time import jax @@ -57,7 +58,7 @@ for ifo in ifos: data = jd.Data.from_gwosc(ifo.name, start, end) ifo.set_data(data) - + psd_data = jd.Data.from_gwosc(ifo.name, psd_start, psd_end) psd_fftlength = data.duration * data.sampling_frequency ifo.set_psd(psd_data.to_psd(nperseg=psd_fftlength)) @@ -111,23 +112,39 @@ # Defining Transforms sample_transforms = [ - DistanceToSNRWeightedDistanceTransform(gps_time=gps, ifos=ifos, dL_min=dL_prior.xmin, dL_max=dL_prior.xmax), - GeocentricArrivalPhaseToDetectorArrivalPhaseTransform(gps_time=gps, ifo=ifos[0]), - GeocentricArrivalTimeToDetectorArrivalTimeTransform(tc_min=t_c_prior.xmin, tc_max=t_c_prior.xmax, gps_time=gps, ifo=ifos[0]), + DistanceToSNRWeightedDistanceTransform( + gps_time=gps, ifos=ifos, dL_min=dL_prior.xmin, dL_max=dL_prior.xmax), + GeocentricArrivalPhaseToDetectorArrivalPhaseTransform( + gps_time=gps, ifo=ifos[0]), + GeocentricArrivalTimeToDetectorArrivalTimeTransform( + tc_min=t_c_prior.xmin, tc_max=t_c_prior.xmax, gps_time=gps, ifo=ifos[0]), SkyFrameToDetectorFrameSkyPositionTransform(gps_time=gps, ifos=ifos), - BoundToUnbound(name_mapping = (["M_c"], ["M_c_unbounded"]), original_lower_bound=M_c_min, original_upper_bound=M_c_max), - BoundToUnbound(name_mapping = (["q"], ["q_unbounded"]), original_lower_bound=q_min, original_upper_bound=q_max), - BoundToUnbound(name_mapping = (["s1_phi"], ["s1_phi_unbounded"]) , original_lower_bound=0.0, original_upper_bound=2 * jnp.pi), - BoundToUnbound(name_mapping = (["s2_phi"], ["s2_phi_unbounded"]) , original_lower_bound=0.0, original_upper_bound=2 * jnp.pi), - BoundToUnbound(name_mapping = (["iota"], ["iota_unbounded"]) , original_lower_bound=0.0, original_upper_bound=jnp.pi), - BoundToUnbound(name_mapping = (["s1_theta"], ["s1_theta_unbounded"]) , original_lower_bound=0.0, original_upper_bound=jnp.pi), - BoundToUnbound(name_mapping = (["s2_theta"], ["s2_theta_unbounded"]) , original_lower_bound=0.0, original_upper_bound=jnp.pi), - BoundToUnbound(name_mapping = (["s1_mag"], ["s1_mag_unbounded"]) , original_lower_bound=0.0, original_upper_bound=0.99), - BoundToUnbound(name_mapping = (["s2_mag"], ["s2_mag_unbounded"]) , original_lower_bound=0.0, original_upper_bound=0.99), - BoundToUnbound(name_mapping = (["phase_det"], ["phase_det_unbounded"]), original_lower_bound=0.0, original_upper_bound=2 * jnp.pi), - BoundToUnbound(name_mapping = (["psi"], ["psi_unbounded"]), original_lower_bound=0.0, original_upper_bound=jnp.pi), - BoundToUnbound(name_mapping = (["zenith"], ["zenith_unbounded"]), original_lower_bound=0.0, original_upper_bound=jnp.pi), - BoundToUnbound(name_mapping = (["azimuth"], ["azimuth_unbounded"]), original_lower_bound=0.0, original_upper_bound=2 * jnp.pi), + BoundToUnbound(name_mapping=(["M_c"], [ + "M_c_unbounded"]), original_lower_bound=M_c_min, original_upper_bound=M_c_max), + BoundToUnbound(name_mapping=(["q"], ["q_unbounded"]), + original_lower_bound=q_min, original_upper_bound=q_max), + BoundToUnbound(name_mapping=(["s1_phi"], [ + "s1_phi_unbounded"]), original_lower_bound=0.0, original_upper_bound=2 * jnp.pi), + BoundToUnbound(name_mapping=(["s2_phi"], [ + "s2_phi_unbounded"]), original_lower_bound=0.0, original_upper_bound=2 * jnp.pi), + BoundToUnbound(name_mapping=(["iota"], ["iota_unbounded"]), + original_lower_bound=0.0, original_upper_bound=jnp.pi), + BoundToUnbound(name_mapping=(["s1_theta"], [ + "s1_theta_unbounded"]), original_lower_bound=0.0, original_upper_bound=jnp.pi), + BoundToUnbound(name_mapping=(["s2_theta"], [ + "s2_theta_unbounded"]), original_lower_bound=0.0, original_upper_bound=jnp.pi), + BoundToUnbound(name_mapping=(["s1_mag"], [ + "s1_mag_unbounded"]), original_lower_bound=0.0, original_upper_bound=0.99), + BoundToUnbound(name_mapping=(["s2_mag"], [ + "s2_mag_unbounded"]), original_lower_bound=0.0, original_upper_bound=0.99), + BoundToUnbound(name_mapping=(["phase_det"], [ + "phase_det_unbounded"]), original_lower_bound=0.0, original_upper_bound=2 * jnp.pi), + BoundToUnbound(name_mapping=(["psi"], ["psi_unbounded"]), + original_lower_bound=0.0, original_upper_bound=jnp.pi), + BoundToUnbound(name_mapping=(["zenith"], [ + "zenith_unbounded"]), original_lower_bound=0.0, original_upper_bound=jnp.pi), + BoundToUnbound(name_mapping=(["azimuth"], [ + "azimuth_unbounded"]), original_lower_bound=0.0, original_upper_bound=2 * jnp.pi), ] likelihood_transforms = [ @@ -147,9 +164,9 @@ # mass_matrix = mass_matrix.at[9, 9].set(1e-3) local_sampler_arg = {"step_size": mass_matrix * 1e-3} -Adam_optimizer = optimization_Adam(n_steps=3000, learning_rate=0.01, noise_level=1) +Adam_optimizer = optimization_Adam( + n_steps=3000, learning_rate=0.01, noise_level=1) -import optax n_epochs = 20 n_loop_training = 100 From d97dafb0821615343e33b2540ffd3debc0c11b93 Mon Sep 17 00:00:00 2001 From: Max Isi Date: Tue, 29 Oct 2024 10:43:04 -0400 Subject: [PATCH 13/14] unused import --- example/GW150914_IMRPhenomPV2.py | 1 - 1 file changed, 1 deletion(-) diff --git a/example/GW150914_IMRPhenomPV2.py b/example/GW150914_IMRPhenomPV2.py index 08f48dac..a75a219f 100644 --- a/example/GW150914_IMRPhenomPV2.py +++ b/example/GW150914_IMRPhenomPV2.py @@ -25,7 +25,6 @@ GeocentricArrivalTimeToDetectorArrivalTimeTransform, GeocentricArrivalPhaseToDetectorArrivalPhaseTransform, ) -from jimgw.single_event.utils import Mc_q_to_m1_m2 from flowMC.strategy.optimization import optimization_Adam from jimgw.single_event import data as jd From 65c958a25f7cdc6cebe4857e780c6510b28bb521 Mon Sep 17 00:00:00 2001 From: Max Isi Date: Tue, 29 Oct 2024 11:39:08 -0400 Subject: [PATCH 14/14] example: fixed likelihood call --- example/GW150914_IMRPhenomPV2.py | 15 +++++++++++---- src/jimgw/single_event/likelihood.py | 3 +++ 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/example/GW150914_IMRPhenomPV2.py b/example/GW150914_IMRPhenomPV2.py index a75a219f..2556e6f9 100644 --- a/example/GW150914_IMRPhenomPV2.py +++ b/example/GW150914_IMRPhenomPV2.py @@ -49,19 +49,26 @@ psd_end = gps + 2048 # define frequency integration bounds for the likelihood +# we set fmax to 87.5% of the Nyquist frequency to avoid +# data corrupted by the GWOSC antialiasing filter +# (Note that Data.from_gwosc will pull data sampled at +# 4096 Hz by default) fmin = 20.0 -fmax = 1000.0 +fmax = 896.0 ifos = [H1, L1] for ifo in ifos: + # set analysis data data = jd.Data.from_gwosc(ifo.name, start, end) ifo.set_data(data) + # set PSD (Welch estimate) psd_data = jd.Data.from_gwosc(ifo.name, psd_start, psd_end) psd_fftlength = data.duration * data.sampling_frequency ifo.set_psd(psd_data.to_psd(nperseg=psd_fftlength)) +# define the approximant to use waveform = RippleIMRPhenomPv2(f_ref=20) ########################################### @@ -154,7 +161,7 @@ likelihood = TransientLikelihoodFD( - [H1, L1], waveform=waveform, trigger_time=gps, duration=4, post_trigger_duration=2 + [H1, L1], waveform=waveform, f_min=fmin, f_max=fmax, trigger_time=gps ) @@ -163,8 +170,8 @@ # mass_matrix = mass_matrix.at[9, 9].set(1e-3) local_sampler_arg = {"step_size": mass_matrix * 1e-3} -Adam_optimizer = optimization_Adam( - n_steps=3000, learning_rate=0.01, noise_level=1) +# Adam_optimizer = optimization_Adam( +# n_steps=3000, learning_rate=0.01, noise_level=1) n_epochs = 20 diff --git a/src/jimgw/single_event/likelihood.py b/src/jimgw/single_event/likelihood.py index 47bd591a..2eb020c8 100644 --- a/src/jimgw/single_event/likelihood.py +++ b/src/jimgw/single_event/likelihood.py @@ -47,6 +47,9 @@ def __init__( post_trigger_duration: Float = 2, **kwargs, ) -> None: + # NOTE: having 'kwargs' here makes it very difficult to diagnose + # errors and keep track of what's going on, would be better to list + # explicitly what the arguments are accepted self.detectors = detectors # make sure data has a Fourier representation