sxs 2025.0.21__tar.gz → 2025.0.23__tar.gz

{sxs-2025.0.21 → sxs-2025.0.23}/CITATION.cff

@@ -16,5 +16,5 @@ authors:
 title: "The sxs package"
 license: MIT
 doi: 10.5281/zenodo.4034006
-version: 2025.0.21
-date-released: 2025-11-30
+version: 2025.0.23
+date-released: 2026-02-04

{sxs-2025.0.21 → sxs-2025.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sxs
-Version: 2025.0.21
+Version: 2025.0.23
 Summary: Interface to data produced by the Simulating eXtreme Spacetimes collaboration
 Project-URL: Homepage, https://github.com/sxs-collaboration/sxs
 Project-URL: Documentation, https://sxs.readthedocs.io/
@@ -66,8 +66,14 @@ Description-Content-Type: text/markdown
 > As described in our [latest paper](https://arxiv.org/abs/2505.13378), our
 > waveforms now include memory effects.  Specifically, when using any
 > simulation with version 3 or greater, you should expect to see memory effects,
-> most visible in the $(\ell, 0)$ modes, and generally resulting in ringdowns
-> that do not approach 0 at late times.
+> resulting in ringdowns that do not approach 0 at late times.
+> These effects are most prominent in the $(\ell, 0)$ modes for $\ell \\% 2 = 0$,
+> but they can also appear in other modes if the system is asymmetric.
+> If desired, these effects can be approximately removed by running, e.g.,
+> ```
+> sim = sxs.load("SXS:BBH:0123")
+> h_without_memory = sim.h.remove_memory(sim.metadata.relaxation_time)
+> ```
 
 
 The `sxs` python package provides a high-level interface for using data

{sxs-2025.0.21 → sxs-2025.0.23}/README.md

@@ -12,8 +12,14 @@
 > As described in our [latest paper](https://arxiv.org/abs/2505.13378), our
 > waveforms now include memory effects.  Specifically, when using any
 > simulation with version 3 or greater, you should expect to see memory effects,
-> most visible in the $(\ell, 0)$ modes, and generally resulting in ringdowns
-> that do not approach 0 at late times.
+> resulting in ringdowns that do not approach 0 at late times.
+> These effects are most prominent in the $(\ell, 0)$ modes for $\ell \\% 2 = 0$,
+> but they can also appear in other modes if the system is asymmetric.
+> If desired, these effects can be approximately removed by running, e.g.,
+> ```
+> sim = sxs.load("SXS:BBH:0123")
+> h_without_memory = sim.h.remove_memory(sim.metadata.relaxation_time)
+> ```
 
 
 The `sxs` python package provides a high-level interface for using data

sxs-2025.0.23/sxs/__version__.py

@@ -0,0 +1 @@
+__version__ = "2025.0.23"

{sxs-2025.0.21 → sxs-2025.0.23}/sxs/handlers.py

@@ -385,9 +385,10 @@ def load_via_sxs_id(
     import requests
     from .utilities import sxs_path_to_system_path
     url = f"{doi_url}{sxsid}"
-    response = requests.head(url, allow_redirects=True, timeout=timeout)
+    headers = {"User-Agent": "curl/8.18.0"}
+    response = requests.head(url, allow_redirects=True, timeout=timeout, headers=headers)
     if response.status_code != 200:
-        raise ValueError(f"Could not load via DOI {url=}")
+        raise ValueError(f"Could not load via DOI {url=}, status_code = {response.status_code}, Response = {response.reason}")
     final_url = f"{response.url}/{location}"
     truepath = truepath or Path(sxs_path_to_system_path(sxsid)) / location
     return load(final_url, download, cache, progress, truepath, **kwargs)

{sxs-2025.0.21 → sxs-2025.0.23}/sxs/waveforms/__init__.py

@@ -16,6 +16,7 @@ from .format_handlers import (
     rotating_paired_xor_multishuffle_bzip2,
     spectre_cce_v1,
     grathena,
+    lvcnr,
 )
 from .format_handlers.lvc import to_lvc_conventions
 from . import memory, transformations, alignment, norms
@@ -25,6 +26,7 @@ formats = {
     None: nrar,
     "": nrar,
     "nrar": nrar,
+    "lvcnr": lvcnr,
     "rotating_paired_xor_multishuffle_bzip2": rotating_paired_xor_multishuffle_bzip2,
     "rpxm": rotating_paired_xor_multishuffle_bzip2,
     "rpxmb": rotating_paired_xor_multishuffle_bzip2,

sxs-2025.0.23/sxs/waveforms/format_handlers/lvcnr.py

@@ -0,0 +1,111 @@
+import re
+import numpy as np
+import h5py
+from scipy.interpolate import InterpolatedUnivariateSpline as Spline
+import spherical as sf
+from ... import waveforms
+
+def load(file_name, data_type="h"):
+    """Load a waveform from an HDF5 file in the LVCNR format.
+
+    This function reads data from HDF5 files in the LVCNR format.  It
+    extracts amplitude and phase information for spherical harmonic
+    modes and reconstructs the complex-valued data.  This function can
+    be extended to further data types.
+
+    Parameters
+    ----------
+    file_name : str
+        Path to the HDF5 file to be loaded.
+        
+    data_type : str, optional
+        The type of data to be loaded.  Default is "h" for strain.
+
+    Returns
+    -------
+    waveforms.WaveformModes
+        The loaded waveform data in WaveformModes format with spin
+        weight -2 and data type "h" (strain).  The waveform includes
+        mode decomposition information with ell_min and ell_max
+        determined from the file contents.  The data type can be
+        overridden if necessary, to accommodate other types of data
+        stored in LVCNR format.
+    """
+
+    phase_re = re.compile("phase_l(?P<ell>.*)_m(?P<m>.*)")
+
+    with h5py.File(file_name, "r") as f:
+
+        # Find the NRTimes array.  RIT and MAYA have different 
+        # capitalizations.
+        nrtimes_matches = [
+            key for key in f if key.lower() == "nrtimes"
+        ]
+        if not (len(nrtimes_matches) == 1 and
+                isinstance(f[nrtimes_matches[0]], h5py.Dataset)):
+            raise KeyError(
+                f"File {file_name} must contain exactly 1 Dataset "
+                "named NRTimes (case insensitive)"
+            )
+
+        t = f[nrtimes_matches[0]]
+
+        # Extract l and m values from the dataset keys
+        ell_m = np.array(
+            [
+                [int(match["ell"]), int(match["m"])]
+                for key in f
+                for match in [phase_re.match(key)]
+                if match
+            ]
+        )
+        ell_min = np.min(ell_m[:, 0])
+        ell_max = np.max(ell_m[:, 0])
+        data = np.empty(
+            (t.size, sf.LM_total_size(ell_min, ell_max)),
+            dtype=complex
+        )
+
+        # Compose the data array using amplitude and phase datasets
+        for ell in range(ell_min, ell_max + 1):
+            for m in range(-ell, ell + 1):
+                amp = Spline(
+                    f[f"amp_l{ell}_m{m}/X"][:],
+                    f[f"amp_l{ell}_m{m}/Y"][:],
+                    k=int(f[f"amp_l{ell}_m{m}/deg"][()])
+                )(t)
+                phase = Spline(
+                    f[f"phase_l{ell}_m{m}/X"][:],
+                    f[f"phase_l{ell}_m{m}/Y"][:],
+                    k=int(f[f"phase_l{ell}_m{m}/deg"][()])
+                )(t)
+                idx = sf.LM_index(ell, m, ell_min)
+                data[:, idx] = amp * np.exp(1j * phase)
+
+        if "auxiliary-info" in f and \
+           "history.txt" in f["auxiliary-info"]:
+            history_txt = f["auxiliary-info/history.txt"][()].decode()
+            history = (
+                "### " + history_txt.replace("\n", "\n### ")
+            ).split("\n")
+        else:
+            history = [""]
+
+        kwargs = dict(
+            time=t,
+            time_axis=0,
+            modes_axis=1,
+            spin_weight=-2,
+            data_type=data_type,
+            frame_type="inertial",
+            history=history,
+            version_hist=[],
+            r_is_scaled_out=True,
+            m_is_scaled_out=True,
+            ell_min=ell_min,
+            ell_max=ell_max,
+        )
+
+        w = waveforms.WaveformModes(data, **kwargs)
+
+    return w

{sxs-2025.0.21 → sxs-2025.0.23}/sxs/waveforms/memory.py

@@ -2,14 +2,15 @@
 
 This code is based on the paper "Adding Gravitational Memory to Waveform
 Catalogs using BMS Balance Laws" by Mitman et al.  The main result of that
-paper is encapsulated in the `add_memory` function.  Basic usage looks like
-this:
+paper is encapsulated in the `add_memory` function.  All waveforms in 
+versions > 1 contain memory, added via this function.  If desired, 
+memory can be removed via the function 'remove_memory', e.g.,
 
 ```python
-h = sxs.load("SXS:BBH:0123/Lev/rhOverM", extrapolation_order=3)
-h_with_memory = sxs.waveforms.memory.add_memory(h, integration_start_time=1000.0)
+sim = sxs.load("SXS:BBH:0123")
+h = sim.h
+h_without_memory = sxs.waveforms.memory.remove_memory(h, integration_start_time=sim.metadata.relaxation_time)
 ```
-
 """
 
 import numpy as np
@@ -209,7 +210,7 @@ def J_J(h):
 
 
 def add_memory(h, integration_start_time=None, psi4=None):
-    """Add electric component of null memory to strain and optionally psi4
+    """Add electric component of null memory to strain and optionally psi4.
 
     This adds the contribution from the energy flux to the strain, and
     optionally adds minus the 2nd derivative of this contribution to psi4.
@@ -242,3 +243,38 @@ def add_memory(h, integration_start_time=None, psi4=None):
         psi4_with_memory = WaveformModes(waveform_mts.MTS(psi4) - waveform_mts.MTS(h_memory_correction).ddot)
         psi4_with_memory.register_modification(add_memory, integration_start_time=integration_start_time)
         return (h_with_memory, psi4_with_memory)
+
+def remove_memory(h, integration_start_time=None, psi4=None):
+    """Remove electric component of null memory to strain and optionally psi4.
+
+    This removes the contribution from the energy flux to the strain, and
+    optionally removes minus the 2nd derivative of this contribution to psi4.
+
+    Parameters
+    ----------
+    h : WaveformModes
+        WaveformModes object corresponding to the strain
+    integration_start_time : float, optional
+        Time at which the energy flux integral should begin.  The default is
+        `h.t[0]`.
+    psi4 : WaveformModes, optional
+        WaveformModes object corresponding to psi4
+
+    Returns
+    -------
+    h_without_memory : WaveformModes
+        WaveformModes object corresponding to the strain with electric memory
+    psi4_without_memory : WaveformModes, optional
+        WaveformModes object corresponding to `psi4` with electric memory.  If
+        `psi4` is `None`, then this is absent.
+
+    """
+    h_memory_correction = J_E(h, integration_start_time=integration_start_time)
+    h_without_memory = WaveformModes(waveform_mts.MTS(h) - h_memory_correction)
+    h_without_memory.register_modification(remove_memory, integration_start_time=integration_start_time)
+    if psi4 is None:
+        return h_without_memory
+    else:
+        psi4_without_memory = WaveformModes(waveform_mts.MTS(psi4) + waveform_mts.MTS(h_memory_correction).ddot)
+        psi4_without_memory.register_modification(remove_memory, integration_start_time=integration_start_time)
+        return (h_without_memory, psi4_without_memory)

{sxs-2025.0.21 → sxs-2025.0.23}/sxs/waveforms/waveform_modes.py

@@ -1358,8 +1358,32 @@ class WaveformModes(WaveformMixin, TimeSeries):
         h_tilde = h_tilde[h_tilde.t.size//2:]
 
         return h_tilde
+
+    def remove_memory(self, integration_start_time):
+        """Remove memory from a waveform.
+
+        This uses sxs.waveforms.memory.remove_memory to remove
+        memory from the waveform. Note that to return the
+        waveform to a state as close as possible to before the
+        memory correction was applied, one should use the
+        simulation's relaxation time as the `integration_start_time`.
+        Even with this, however, the waveform will still be slightly
+        altered as this process is not invertible.
+
+        Parameters
+        ----------
+        integration_start_time : float
+            The time at which to start the integration for the
+            memory calculation. If this is not the relaxation time,
+            then the memory removal may be worse.
+        """
+        from .memory import remove_memory as raw_remove_memory
         
+        h_without_memory = raw_remove_memory(self, integration_start_time=integration_start_time)
 
+        return h_without_memory
+        
+        
 class WaveformModesDict(MutableMapping, WaveformModes):
     """A dictionary-like class for storing waveform modes
 

sxs-2025.0.21/sxs/__version__.py

@@ -1 +0,0 @@
-__version__ = "2025.0.21"