lalsuite 7.26.2.dev20251218__cp314-cp314t-manylinux_2_28_x86_64.whl

lalsimulation/gwsignal/models/pyseobnr_model.py

@@ -0,0 +1,452 @@
+try:
+    import pyseobnr.generate_waveform as pyseob_wf
+except ImportError:
+    print("The pyseobnr package has failed to load, you will not be able to employ SEOBNRv5 approximants.")
+
+from numpy import arange
+from astropy.units import Mpc
+from gwpy.timeseries import TimeSeries
+from gwpy.frequencyseries import FrequencySeries
+from lal import LIGOTimeGPS
+
+from ..core.waveform import CompactBinaryCoalescenceGenerator
+
+
+class SEOBNRv5EHM(CompactBinaryCoalescenceGenerator):
+
+    """
+    Implements a wrapper for SEOBNRv5EHM in the pyseob package
+
+    Parameters
+    ----------
+
+        No parameters required for initialization.
+
+    """
+
+    # _domain = 'time'
+    def __init__(self, **kwargs):
+
+        super().__init__()
+
+        self.seobnr = pyseob_wf
+        self._domain = "time"
+        self._implemented_domain = "time"
+        self._generation_domain = None
+
+    @property
+    def metadata(self):
+        metadata = {
+            "type": "aligned_spin",
+            "f_ref_spin": True,
+            "modes": True,
+            "polarizations": True,
+            "implemented_domain": "time",
+            "approximant": "SEOBNRv5EHM",
+            "implementation": "",
+            "conditioning_routines": "",
+        }
+        return metadata
+
+    def _strip_units(self, waveform_dict):
+        new_dc = {}
+        for key in waveform_dict.keys():
+            new_dc[key] = waveform_dict[key].value
+        return new_dc
+
+    def _generate_waveform_class(self, **parameters):
+
+        parameters_extra = {}
+
+        # Get the optional parameters for this approximant, if any
+        optional_params = [
+            "ModeArray",
+            "condition",
+            "lmax_nyquist",
+            "lmax",
+            "secular_bwd_int",
+            "warning_secular_bwd_int",
+            "t_backwards",
+            "warning_bwd_int",
+        ]
+
+        for key in optional_params:
+            val = parameters.pop(key, None)
+            if val is not None:
+                parameters_extra[key] = val
+
+        # indicates we are running pyseobnr through GWSignal. Emits proper
+        # warnings on non-reviewed model calls.
+        parameters_extra["gwsignal_environment"] = True
+
+        self.parameter_check(units_sys="Cosmo", **parameters)
+        self.waveform_dict["distance"] = self.waveform_dict["distance"].to(Mpc)
+        self.waveform_dict = self._strip_units(self.waveform_dict)
+        self.waveform_dict["approximant"] = self.metadata["approximant"]
+        self.waveform_dict["f_ref"] = self.waveform_dict["f22_ref"]
+        self.waveform_dict["rel_anomaly"] = self.waveform_dict["meanPerAno"]
+
+        # Make sure to update the waveform dictionary with extra parameters
+        self.waveform_dict.update(**parameters_extra)
+
+        #print(f"waveform_dict = {self.waveform_dict}")
+        return self.seobnr.GenerateWaveform(self.waveform_dict)
+
+    def _generate_modes(self, **parameters):
+
+        gen_wf = self._generate_waveform_class(**parameters)
+        times, hlm = gen_wf.generate_td_modes()
+        epoch = LIGOTimeGPS(times[0])
+        dt = self.waveform_dict["deltaT"]
+
+        hlm_dict = {}
+        for k, v in hlm.items():
+            hlm_lal = TimeSeries(v, times=times,  name=k)
+            hlm_dict[k] = hlm_lal
+
+        return hlm_dict
+
+    def _generate_td_polarizations(self, **parameters):
+
+        gen_wf = self._generate_waveform_class(**parameters)
+        if self.waveform_dict.get("condition"):
+            hp, hc = gen_wf.generate_td_polarizations_conditioned_1()
+        else:
+            hp, hc = gen_wf.generate_td_polarizations()
+        epoch = hp.epoch.gpsSeconds + hp.epoch.gpsNanoSeconds / 1e9
+        times = hp.deltaT * arange(hp.data.length) + epoch
+        return (
+            TimeSeries(hp.data.data, times=times, name="hp"),
+            TimeSeries(hc.data.data, times=times, name="hc"),
+        )
+
+    def _generate_fd_polarizations_from_td(self, **parameters):
+
+        gen_wf = self._generate_waveform_class(**parameters)
+        hptilde, hctilde = gen_wf.generate_fd_polarizations()
+        frequencies = hptilde.deltaF * arange(hptilde.data.length)
+        epoch = hptilde.epoch.gpsSeconds + hptilde.epoch.gpsNanoSeconds / 1e9
+        return (
+            FrequencySeries(
+                hptilde.data.data, frequencies=frequencies, epoch=epoch, name="hp"
+            ),
+            FrequencySeries(
+                hctilde.data.data, frequencies=frequencies, epoch=epoch, name="hc"
+            ),
+        )
+
+    def _generate_polarizations(self, **parameters):
+
+        if self._generation_domain == "time":
+            return self._generate_td_polarizations(**parameters)
+        elif self._generation_domain == "freq":
+            return self._generate_fd_polarizations_from_td(**parameters)
+        else:
+            raise ValueError("Generation domain must be 'time' or 'freq'.")
+
+    def generate_fd_waveform(self, **parameters):
+        return self._generate_fd_polarizations_from_td(**parameters)
+
+    def generate_td_waveform(self, **parameters):
+        return self._generate_td_polarizations(**parameters)
+
+    def generate_td_modes(self, **parameters):
+        return self._generate_modes(**parameters)
+
+
+class SEOBNRv5HM(CompactBinaryCoalescenceGenerator):
+
+    """
+    Implements a wrapper for SEOBNRv5 in the pyseob package
+
+    Parameters
+    ----------
+
+        No parameters required for initialization.
+
+    """
+
+    # _domain = 'time'
+    def __init__(self, **kwargs):
+
+        # super().__init__()
+
+        self.seobnr = pyseob_wf
+        self._domain = "time"
+        self._implemented_domain = "time"
+        self._generation_domain = None
+
+    @property
+    def metadata(self):
+        metadata = {
+            "type": "aligned_spin",
+            "f_ref_spin": True,
+            "modes": True,
+            "polarizations": True,
+            "implemented_domain": "time",
+            "approximant": "SEOBNRv5HM",
+            "implementation": "",
+            "conditioning_routines": "",
+        }
+        return metadata
+
+    def _strip_units(self, waveform_dict):
+        new_dc = {}
+        for key in waveform_dict.keys():
+            new_dc[key] = waveform_dict[key].value
+        return new_dc
+
+    def _generate_waveform_class(self, **parameters):
+
+        parameters_extra = {}
+
+        # Get the optional parameters for this approximant, if any
+        optional_params = [
+            "ModeArray",
+            "postadiabatic",
+            "postadiabatic_type",
+            "condition",
+            "lmax_nyquist",
+            "lmax",
+            "dA_dict",
+            "dw_dict",
+            "dTpeak",
+            "domega_dict",
+            "dtau_dict",
+            "da6",
+            "ddSO",
+            "tol_PA",
+            "rtol_ode",
+            "atol_ode",
+            "deltaT_sampling",
+        ]
+        for key in optional_params:
+            val = parameters.pop(key, None)
+            if val is not None:
+                parameters_extra[key] = val
+
+        # indicates we are running pyseobnr through GWSignal. Emits proper
+        # warnings on non-reviewed model calls.
+        parameters_extra["gwsignal_environment"] = True
+
+        self.parameter_check(units_sys="Cosmo", **parameters)
+        self.waveform_dict["distance"] = self.waveform_dict["distance"].to(Mpc)
+        self.waveform_dict = self._strip_units(self.waveform_dict)
+        self.waveform_dict["approximant"] = self.metadata["approximant"]
+        self.waveform_dict["f_ref"] = self.waveform_dict["f22_ref"]
+
+        # Make sure to update the waveform dictionary with extra parameters
+        self.waveform_dict.update(**parameters_extra)
+
+        return self.seobnr.GenerateWaveform(self.waveform_dict)
+
+    def _generate_modes(self, **parameters):
+
+        gen_wf = self._generate_waveform_class(**parameters)
+        times, hlm = gen_wf.generate_td_modes()
+        epoch = LIGOTimeGPS(times[0])
+        dt = self.waveform_dict["deltaT"]
+
+        hlm_dict = {}
+        for k, v in hlm.items():
+            hlm_lal = TimeSeries(v, times=times,  name=k)
+            hlm_dict[k] = hlm_lal
+
+        return hlm_dict
+
+    def _generate_td_polarizations(self, **parameters):
+
+        gen_wf = self._generate_waveform_class(**parameters)
+        if self.waveform_dict.get("condition"):
+            hp, hc = gen_wf.generate_td_polarizations_conditioned_2()
+        else:
+            hp, hc = gen_wf.generate_td_polarizations()
+        epoch = hp.epoch.gpsSeconds + hp.epoch.gpsNanoSeconds / 1e9
+        times = hp.deltaT * arange(hp.data.length) + epoch
+        return (
+            TimeSeries(hp.data.data, times=times, name="hp"),
+            TimeSeries(hc.data.data, times=times, name="hc"),
+        )
+
+    def _generate_fd_polarizations_from_td(self, **parameters):
+
+        gen_wf = self._generate_waveform_class(**parameters)
+        hptilde, hctilde = gen_wf.generate_fd_polarizations()
+        frequencies = hptilde.deltaF * arange(hptilde.data.length)
+        epoch = hptilde.epoch.gpsSeconds + hptilde.epoch.gpsNanoSeconds / 1e9
+        return (
+            FrequencySeries(
+                hptilde.data.data, frequencies=frequencies, epoch=epoch, name="hp"
+            ),
+            FrequencySeries(
+                hctilde.data.data, frequencies=frequencies, epoch=epoch, name="hc"
+            ),
+        )
+
+    def _generate_polarizations(self, **parameters):
+
+        if self._generation_domain == "time":
+            return self._generate_td_polarizations(**parameters)
+        elif self._generation_domain == "freq":
+            return self._generate_fd_polarizations_from_td(**parameters)
+        else:
+            raise ValueError("Generation domain must be 'time' or 'freq'.")
+
+    def generate_fd_waveform(self, **parameters):
+        return self._generate_fd_polarizations_from_td(**parameters)
+
+    def generate_td_waveform(self, **parameters):
+        return self._generate_td_polarizations(**parameters)
+
+    def generate_td_modes(self, **parameters):
+        return self._generate_modes(**parameters)
+
+
+class SEOBNRv5PHM(CompactBinaryCoalescenceGenerator):
+
+    """
+    Implements a wrapper for SEOBNRv5 in the pyseob package
+
+    Parameters
+    ----------
+
+        No parameters required for initialization.
+
+    """
+
+    # _domain = 'time'
+    def __init__(self, **kwargs):
+
+        # super().__init__()
+
+        self.seobnr = pyseob_wf
+        self._domain = "time"
+        self._implemented_domain = "time"
+        self._generation_domain = None
+
+    @property
+    def metadata(self):
+        metadata = {
+            "type": "precessing_spin",
+            "f_ref_spin": True,
+            "modes": True,
+            "polarizations": True,
+            "implemented_domain": "time",
+            "approximant": "SEOBNRv5PHM",
+            "implementation": "",
+            "conditioning_routines": "",
+        }
+        return metadata
+
+    def _strip_units(self, waveform_dict):
+        new_dc = {}
+        for key in waveform_dict.keys():
+            new_dc[key] = waveform_dict[key].value
+        return new_dc
+
+    def _generate_waveform_class(self, **parameters):
+
+        parameters_extra = {}
+
+        # Get the optional parameters for this approximant, if any
+        optional_params = [
+            "ModeArray",
+            "polarizations_from_coprec",
+            "postadiabatic",
+            "postadiabatic_type",
+            "condition",
+            "lmax_nyquist",
+            "lmax",
+            "dA_dict",
+            "dw_dict",
+            "dTpeak",
+            "domega_dict",
+            "dtau_dict",
+            "da6",
+            "ddSO",
+            "deltaT_sampling",
+            "omega_prec_deviation",
+            "enable_antisymmetric_modes",
+            "antisymmetric_modes_hm",
+            "antisymmetric_modes",
+        ]
+        for key in optional_params:
+            val = parameters.pop(key, None)
+            if val is not None:
+                parameters_extra[key] = val
+
+        # indicates we are running pyseobnr through GWSignal. Emits proper
+        # warnings on non-reviewed model calls.
+        parameters_extra["gwsignal_environment"] = True
+
+        self.parameter_check(units_sys="Cosmo", **parameters)
+        self.waveform_dict["distance"] = self.waveform_dict["distance"].to(Mpc)
+        self.waveform_dict = self._strip_units(self.waveform_dict)
+        self.waveform_dict["approximant"] = self.metadata["approximant"]
+        self.waveform_dict["f_ref"] = self.waveform_dict["f22_ref"]
+
+        # Make sure to update the waveform dictionary with extra parameters
+        self.waveform_dict.update(**parameters_extra)
+
+        return self.seobnr.GenerateWaveform(self.waveform_dict)
+
+    def _generate_modes(self, **parameters):
+
+        gen_wf = self._generate_waveform_class(**parameters)
+        times, hlm = gen_wf.generate_td_modes()
+        epoch = LIGOTimeGPS(times[0])
+        dt = self.waveform_dict["deltaT"]
+
+        hlm_dict = {}
+        for k, v in hlm.items():
+            hlm_lal = TimeSeries(v, times=times,  name=k)
+            hlm_dict[k] = hlm_lal
+
+        return hlm_dict
+
+    def _generate_td_polarizations(self, **parameters):
+
+        gen_wf = self._generate_waveform_class(**parameters)
+        if self.waveform_dict.get("condition"):
+            hp, hc = gen_wf.generate_td_polarizations_conditioned_2()
+        else:
+            hp, hc = gen_wf.generate_td_polarizations()
+        epoch = hp.epoch.gpsSeconds + hp.epoch.gpsNanoSeconds / 1e9
+        times = hp.deltaT * arange(hp.data.length) + epoch
+        return (
+            TimeSeries(hp.data.data, times=times, name="hp"),
+            TimeSeries(hc.data.data, times=times, name="hc"),
+        )
+
+    def _generate_fd_polarizations_from_td(self, **parameters):
+
+        gen_wf = self._generate_waveform_class(**parameters)
+        hptilde, hctilde = gen_wf.generate_fd_polarizations()
+        frequencies = hptilde.deltaF * arange(hptilde.data.length)
+        epoch = hptilde.epoch.gpsSeconds + hptilde.epoch.gpsNanoSeconds / 1e9
+        return (
+            FrequencySeries(
+                hptilde.data.data, frequencies=frequencies, epoch=epoch, name="hp"
+            ),
+            FrequencySeries(
+                hctilde.data.data, frequencies=frequencies, epoch=epoch, name="hc"
+            ),
+        )
+
+    def _generate_polarizations(self, **parameters):
+
+        if self._generation_domain == "time":
+            return self._generate_td_polarizations(**parameters)
+        elif self._generation_domain == "freq":
+            return self._generate_fd_polarizations_from_td(**parameters)
+        else:
+            raise ValueError("Generation domain must be 'time' or 'freq'.")
+
+    def generate_fd_waveform(self, **parameters):
+        return self._generate_fd_polarizations_from_td(**parameters)
+
+    def generate_td_waveform(self, **parameters):
+        return self._generate_td_polarizations(**parameters)
+
+    def generate_td_modes(self, **parameters):
+        return self._generate_modes(**parameters)

lalsimulation/nrfits/NRSur3dq8Remnant.py

@@ -0,0 +1,92 @@
+"""
+Class for NRSur3dq8Remnant model for the remnant mass, spin and kick velocity
+for nonprecessing BBH systems. This model was called surfinBH3dq8 in the paper.
+
+Vijay Varma, 2019.
+"""
+
+import numpy as np
+import lalsimulation as lalsim
+import lal
+
+from .nrfits import NRFits
+
+class NRSur3dq8Remnant(NRFits):
+    r"""
+    Class for NRSur3dq8Remnant model for the remnant mass, spin and kick
+    velocity for nonprecessing BBH systems. This model was called surfinBH3dq8
+    in the paper.
+
+    Paper: arxiv:1809.09125. The model is referred to as surfinBH3dq8 in the
+    paper.
+
+    Parameter ranges for usage: \n
+        q = [1, 9.1] \n
+        \f$\chi_{1z}, \chi_{2z}\f$ = [-0.91, 0.91] \n
+        OR \n
+        q = [1, 10.1] \n
+        \f$\chi_{1z}, \chi_{2z}\f$ = [-0.81, 0.81]
+
+    Training parameter ranges:  \n
+        q = [1, 8] \n
+        \f$\chi_{1z}, \chi_{2z}\f$ = [-0.81, 0.81]
+
+    But extrapolates reasonably to the above mass ratios and spins. However,
+    if a guarantee of accuracy is required, this model should be used within
+    the training parameter range.
+    """
+
+    # ------------------------------------------------------------------------
+    def _get_fit_params(self, m1, m2, chiA_vec, chiB_vec, f_ref,
+            extra_params_dict):
+        """ No processing or spin evolution is required here, just returns the
+        mass ratio, total mass and spins along the z-direction.
+
+        See eval_fits.eval_nrfit() for the definitions of the arguments of
+        this function.
+        """
+
+        # f_ref is used to set the reference frame. For this model, only the
+        # final kick components depend on the reference frame. However, to set
+        # this at an arbitrary f_ref, we will need to know the orbital phase
+        # difference between f_ref and the time at which the fits are
+        # constructed, i.e. t=-100M from the peak of the total waveform
+        # amplitude. While this could be done using a waveform model, we don't
+        # expect the kick direction of this model to be very useful.  So, we
+        # only allow f_ref = -1, which assumes that the reference epoch is at
+        # t=-100M. The kick direction can still be used, but it is always
+        # retured in this frame.
+        if f_ref != -1:
+            raise ValueError("This model only works for f_ref=-1.")
+
+        q = m1/m2
+        fit_params = [q, chiA_vec[2], chiB_vec[2]]
+        return fit_params
+
+    # ------------------------------------------------------------------------
+    def _eval_fit(self, fit_params, fit_type, extra_params_dict):
+        """ Evaluates a particular fit for NRSur3dq8Remnant using the fit_params
+        returned by _get_fit_params().
+        """
+        q, chiAz, chiBz = fit_params
+        LALParams = lal.CreateDict()
+        if extra_params_dict["unlimited_extrapolation"]:
+            lal.DictInsertUINT4Value(LALParams, "unlimited_extrapolation", 1)
+
+        if fit_type == "FinalMass":
+            # FinalMass is given as a fraction of total mass
+            val = lalsim.NRSur3dq8Remnant(q, chiAz, chiBz, "mf", LALParams)
+        elif fit_type == "FinalSpin":
+            # chifx and chify are zero for aligned-spin systems
+            chifz = lalsim.NRSur3dq8Remnant(q, chiAz, chiBz, "chifz", LALParams)
+            val = [0,0,chifz]
+        elif fit_type == "RecoilKick":
+            # vfz is zero for aligned-spin systems
+            vfx = lalsim.NRSur3dq8Remnant(q, chiAz, chiBz, "vfx", LALParams)
+            vfy = lalsim.NRSur3dq8Remnant(q, chiAz, chiBz, "vfy", LALParams)
+            val = [vfx, vfy, 0]
+        else:
+            raise ValueError("Invalid fit_type=%s. This model only allows "
+                "'FinalMass', 'FinalSpin' and 'RecoilKick'."%fit_type)
+
+        return np.atleast_1d(val)