sxs 2025.0.2__tar.gz → 2025.0.4__tar.gz

{sxs-2025.0.2 → sxs-2025.0.4}/.github/workflows/build.yml

@@ -79,7 +79,7 @@ jobs:
         if: ${{ env.skipping_build_and_test_replicate != 'true' }}
         shell: bash
         run: |
-          hatch run test
+          hatch run test --durations=0
 
       - name: Upload coverage
         if: "matrix.python-version == '3.13' && matrix.os == 'ubuntu-latest'"

{sxs-2025.0.2 → sxs-2025.0.4}/CITATION.cff

@@ -10,5 +10,5 @@ authors:
 title: "The sxs package"
 license: MIT
 doi: 10.5281/zenodo.4034006
-version: 2025.0.2
-date-released: 2025-03-26
+version: 2025.0.4
+date-released: 2025-04-11

{sxs-2025.0.2 → sxs-2025.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sxs
-Version: 2025.0.2
+Version: 2025.0.4
 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/
@@ -40,13 +40,14 @@ Requires-Dist: inflection>=0.5.1
 Requires-Dist: juliacall>=0.9.20
 Requires-Dist: numba>=0.55; implementation_name == 'cpython'
 Requires-Dist: numpy>=1.25
+Requires-Dist: packaging
 Requires-Dist: pandas>=1.1.2
 Requires-Dist: pytz>=2020.1
 Requires-Dist: quaternionic>=1.0.15
 Requires-Dist: requests>=2.24.0
 Requires-Dist: scipy>=1.13
 Requires-Dist: spherical>=1.0.15
-Requires-Dist: sxscatalog>=3.0.0a26
+Requires-Dist: sxscatalog>=3.0.12
 Requires-Dist: tqdm>=4.63.1
 Requires-Dist: urllib3>=1.25.10
 Provides-Extra: docs

{sxs-2025.0.2 → sxs-2025.0.4}/pyproject.toml

@@ -18,7 +18,7 @@ classifiers = [
   "Topic :: Scientific/Engineering :: Astronomy"
 ]
 dependencies = [
-  "sxscatalog >=3.0.0a26",
+  "sxscatalog >=3.0.12",
   "numpy >=1.25",
   "scipy >=1.13",
   "numba >=0.55; implementation_name == 'cpython'",
@@ -31,7 +31,8 @@ dependencies = [
   "pytz >=2020.1",
   "urllib3 >=1.25.10",
   "pandas >=1.1.2",
-  "juliacall >=0.9.20"
+  "juliacall >=0.9.20",
+  "packaging",
 ]
 
 [project.optional-dependencies]

sxs-2025.0.4/sxs/__version__.py

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

{sxs-2025.0.2 → sxs-2025.0.4}/sxs/handlers.py

@@ -350,7 +350,9 @@ def load(location, download=None, cache=None, progress=None, truepath=None, **kw
     return loaded
 
 
-def load_via_sxs_id(sxsid, location, *, download=None, cache=None, progress=None, truepath=None, **kwargs):
+def load_via_sxs_id(
+    sxsid, location, *, download=None, cache=None, progress=None, truepath=None, timeout=30, **kwargs
+):
     """Load a path via a (possibly versioned) SXS ID
     
     Given some SXS ID like "SXS:BBH:1234" or a versioned ID like
@@ -373,7 +375,7 @@ def load_via_sxs_id(sxsid, location, *, download=None, cache=None, progress=None
     import requests
     from .utilities import sxs_path_to_system_path
     url = f"{doi_url}{sxsid}"
-    response = requests.head(url, allow_redirects=True)
+    response = requests.head(url, allow_redirects=True, timeout=timeout)
     if response.status_code != 200:
         raise ValueError(f"Could not load via DOI {url=}")
     final_url = f"{response.url}/{location}"

{sxs-2025.0.2 → sxs-2025.0.4}/sxs/simulations/__init__.py

@@ -1,3 +1,4 @@
 from .simulation import Simulation
 from .simulations import Simulations
 from .local import write_local_simulations, local_simulations
+from . import analyze

sxs-2025.0.4/sxs/simulations/analyze.py

@@ -0,0 +1,276 @@
+import multiprocessing
+
+from ..waveforms.norms import create_unified_waveforms, L2_difference, mismatch
+from ..waveforms.alignment import align_waveforms, align_simulations
+from ..handlers import load
+
+import numpy as np
+
+
+def compute_error_summary(wa, wb, t1, t2, modes=None, ASDs=None, total_masses=None):
+    """
+    Compute various errors between two waveforms.
+
+    This computes the time-domain mismatch over the two-sphere,
+    the normalized L² norm of the residual, the frequency-domain mismatch
+    against whatever detector ASDs are provided with some total mass,
+    and the individual modes' residual norms and norms.
+
+    Parameters
+    ----------
+    wa : WaveformModes
+    wb : WaveformModes
+    t1 : float
+        Beginning of integrals.
+    t2 : float
+        End of integrals.
+    modes : list, optional
+        Modes (ell, m) to include in error calculations.
+        Default is all modes.
+    ASDs : dict of funcs, optional
+        Dictionary of functions mapping frequencies to the ASD of a detector(s).
+        Default is no frequency-domain mismatch is calculated.
+    total_masses : list of floats, optional
+        Total masses in solar masses to use for frequency-domain mismatches.
+        Default is 1.
+
+    Returns
+    -------
+    errors : dict
+        Dictionary of the time-domain mismatch over the two-sphere,
+        the normalized L² norm of the residual, the frequency-domain mismatch
+        against whatever detector ASDs are provided with some total mass,
+        and the modes' absolute errors and norms.
+    """
+    from .. import m_sun_in_seconds
+    
+    errors = {}
+
+    errors["t1"] = t1
+    errors["t2"] = t2
+
+    wa, wb = create_unified_waveforms(wa, wb, t1, t2, padding_time_factor=0)
+
+    errors["mismatch"] = mismatch(wa, wb, t1, t2, modes=modes)
+
+    errors["residual L2 norm"] = L2_difference(wa, wb, t1, t2, modes=modes)
+
+    i1 = wa.index_closest_to(t1)
+    i0, i2 = max(0, i1-5), min(i1+6, wa.n_times-1)
+    Ω1 = np.linalg.norm(wa[i0:i2].angular_velocity, axis=1)[5]
+    f1 = 2*Ω1 / (2*np.pi)
+
+    wa = wa.preprocess(t1, t1 + 0.01 * (t2 - t1), t2 - (t2 - t1) * 0.01, t2)
+    wb = wb.preprocess(t1, t1 + 0.01 * (t2 - t1), t2 - (t2 - t1) * 0.01, t2)
+
+    wa_tilde = wa.fourier_transform()
+    wb_tilde = wb.fourier_transform()
+    if ASDs is not None:
+        if total_masses is None:
+            raise ValueError("Need to specify total masses if ASDs are provided.")
+        for ASD in ASDs:
+            for total_mass in total_masses:
+                # Note that we only need to make the frequency unitful, since the
+                # magnitude of the strain scales out in the mismatch.
+                # We make things unitful here because the fourier transform
+                # earlier was called outside of the for loop without a total mass
+                # so that it doesn't need to be computed at each iteration.
+                frequency_factor = 1 / (total_mass * m_sun_in_seconds)
+            
+                wa_tilde_total_mass = wa_tilde.copy()
+                wb_tilde_total_mass = wb_tilde.copy()
+                wa_tilde_total_mass.t = wa_tilde_total_mass.t * frequency_factor
+                wb_tilde_total_mass.t = wb_tilde_total_mass.t * frequency_factor
+
+                errors[f"mismatch {ASD} {total_mass}"] = mismatch(
+                    wa_tilde_total_mass, wb_tilde_total_mass, f1 * frequency_factor, modes=modes, ASD=ASDs[ASD]
+                )
+
+    ell_min = max(wa.ell_min, wb.ell_min)
+    ell_max = min(wa.ell_max, wb.ell_max)
+    for L in range(ell_min, ell_max + 1):
+        for M in range(-L, L + 1):
+            absolute_error, norm = L2_difference(
+                wa, wb, t1, t2, modes=[(L, M)], modes_for_norm=[(L, M)], normalize=False
+            )
+            errors[f"(L, M) = {(L, M)} residual L2 norm"] = absolute_error
+            errors[f"(L, M) = {(L, M)} L2 norm"] = norm
+
+    return errors
+
+
+def analyze_simulation(
+    sim_name,
+    analyze_levs=True,
+    analyze_extrapolation=True,
+    analyze_psi4=True,
+    ASDs=None,
+    total_masses=None,
+    nprocs=None,
+):
+    """
+    Analyze a simulation's waveform agreement across
+    Levs, extrapolation orders, and the psi4 constraint.
+
+    For each Lev in a simulation, align the strain waveforms
+    (if it's the highest Lev pair, then a 4d optimization is also performed
+    and the transformation from the low to high lev is included in the returned dictionary)
+    via the independent alignment method. Then, compute the L² norm of the residual between
+    the two aligned waveforms (if it's the highest Lev pair, then the
+    mismatch against the ASDs and total masses is also computed, as well as the
+    individual modes' residual norms and norms). For the
+    extrapolation order and psi4 analyses, only the L² norm of the residuals are computed.
+
+    Parameters
+    ----------
+    sim_name : str
+        Simulation name, e.g., "SXS:BBH:2092".
+    analyze_levs : bool, optional
+        Whether or not to analyze the various Levs.
+        Default is True.
+    analyze_extrapolation : bool, optional
+        Whether or not to analyze the various extrapolation orders.
+        Default is True.
+    analyze_psi4 : bool, optional
+        Whether or not to analyze the psi4 constraint -h.ddot = psi4..
+        Default is True.
+    ASDs : dict of funcs, optional
+        Dictionary of functions mapping frequencies to the ASD of a detector(s).
+        Default is no frequency-domain mismatch is calculated.
+    total_masses : list of floats, optional
+        Total masses in solar masses to use for frequency-domain mismatches.
+        Default is 1.
+    nprocs : int, optional
+        Number of cpus to use.  Default is maximum number.  If -1 is provided,
+        then no multiprocessing is performed.
+
+    Returns
+    -------
+    errors : dict
+        Dictionary of the errors described above.
+    """
+    errors = {}
+
+    sim = load(sim_name)
+
+    # Lev analysis
+    if analyze_levs:
+        for i, lev in enumerate(sim.lev_numbers[1:][::-1]):
+            sim_low_lev = load(f"{sim_name}/Lev{lev - 1}")
+            sim_high_lev = load(f"{sim_name}/Lev{lev}")
+
+            w_high_lev = sim_high_lev.h
+            if i == 0:
+                w_low_lev_prime, transformation, L2_norm, t1, t2 = align_simulations(
+                    sim_low_lev, sim_high_lev, alignment_method="4d", nprocs=nprocs
+                )
+                errors[f"(Lev{lev - 1}, Lev{lev}) 4d"] = compute_error_summary(w_low_lev_prime, w_high_lev, t1, t2)
+                errors[f"(Lev{lev - 1}, Lev{lev}) 4d transformation"] = transformation
+
+            w_low_lev_prime, transformation, _, t1, t2 = align_simulations(
+                sim_low_lev, sim_high_lev, alignment_method="independent alignment", nprocs=nprocs
+            )
+            errors[f"(Lev{lev - 1}, Lev{lev})"] = L2_difference(w_high_lev, w_low_lev_prime, t1, t2)
+
+    # Extrapolation order analysis
+    if analyze_extrapolation:
+        for extrapolation in ["N3", "N4", "Outer"]:
+            other = load(sim_name, extrapolation=extrapolation)
+
+            w_n2 = sim.h
+            w_other = other.h
+
+            t1 = sim.metadata.relaxation_time
+
+            w_other_prime, transformation, _, t1, t2 = align_waveforms(
+                w_other, w_n2, t1, alignment_method="independent alignment", nprocs=nprocs
+            )
+
+            L2_norm = L2_difference(w_n2, w_other_prime, t1, t2)
+
+            errors[f"(N2, {extrapolation})"] = L2_norm
+
+    # Psi4 analysis
+    if analyze_psi4:
+        h_as_psi4 = -sim.h.ddot
+        psi4 = sim.psi4
+
+        t1 = sim.metadata.relaxation_time
+        t2 = h_as_psi4.t[-1]
+
+        L2_norm = L2_difference(h_as_psi4, psi4, t1, t2)
+
+        errors[f"(-h.ddot, psi4)"] = L2_norm
+
+    return errors
+
+
+def analyze_simulations(
+    sim_names,
+    analyze_levs=True,
+    analyze_extrapolation=True,
+    analyze_psi4=True,
+    ASDs=None,
+    total_masses=None,
+    nprocs=None,
+):
+    """
+    Analyze simulations' waveform agreement across
+    Levs, extrapolation orders, and the psi4 constraint.
+
+    For each Lev in a simulation, align the strain waveforms
+    (if it's the highest Lev pair, then a 4d optimization is also performed
+    and the transformation from the low to high lev is included in the returned dictionary)
+    via the independent alignment method. Then, compute mismatches between
+    the two aligned waveforms (if it's the highest Lev pair, then the
+    relative L² norm error over the two-sphere is computed, as well as the
+    individual mode absolute errors and norms). For the
+    extrapolation order and psi4 analyses, only mismatches are computed.
+
+    Parameters
+    ----------
+    sim_names : list of strs
+        Simulation names, e.g., ["SXS:BBH:2092"].
+    analyze_levs : bool, optional
+        Whether or not to analyze the various Levs.
+        Default is True.
+    analyze_extrapolation : bool, optional
+        Whether or not to analyze the various extrapolation orders.
+        Default is True.
+    analyze_psi4 : bool, optional
+        Whether or not to analyze the psi4 constraint -h.ddot = psi4..
+        Default is True.
+    ASDs : dict of funcs, optional
+        Dictionary of functions mapping frequencies to the ASD of a detector(s).
+        Default is no frequency-domain mismatch is calculated.
+    total_masses : list of floats, optional
+        Total masses in solar masses to use for frequency-domain mismatches.
+        Default is 1.
+    nprocs : int, optional
+        Number of cpus to use.  Default is maximum number.  If -1 is provided,
+        then no multiprocessing is performed.
+
+    Returns
+    -------
+    errors : dict
+        Dictionary of the errors described above.
+    """
+    errors = {}
+    if nprocs != -1:
+        with multiprocessing.Pool(processes=nprocs) as pool:
+            results = pool.starmap(
+                analyze_simulation,
+                [
+                    (sim_name, analyze_levs, analyze_extrapolation, analyze_psi4, ASDs, total_masses, -1)
+                    for sim_name in sim_names
+                ],
+            )
+        for i, sim_name in enumerate(sim_names):
+            errors[sim_name] = results[i]
+    else:
+        for sim_name in sim_names:
+            errors[sim_name] = analyze_simulation(
+                sim_name, analyze_levs, analyze_extrapolation, analyze_psi4, ASDs, total_masses, -1
+            )
+
+    return errors

{sxs-2025.0.2 → sxs-2025.0.4}/sxs/simulations/simulation.py

@@ -100,18 +100,22 @@ def Simulation(location, *args, **kwargs):
     arguments other than those listed above.
     
     """
+    import numpy as np
+    from packaging.version import Version
     from .. import load, sxs_directory
     from ..metadata.metric import MetadataMetric
 
     # Load the simulation catalog
     simulations = load("simulations")
+    v = Version(simulations.tag)
+    latest_version = f"v{v.major}.{v.minor}"
 
     # Extract the simulation ID, version, and Lev from the location string
     simulation_id, input_version = sxs_id_and_version(location)
     if not simulation_id:
         if location.split("/Lev")[0] in simulations:
             simulation_id = location.split("/Lev")[0]
-            input_version = "v0.0"
+            input_version = latest_version
         else:
             raise ValueError(f"Invalid SXS ID in '{simulation_id}'")
     input_lev_number = lev_number(location)  # Will be `None` if not present
@@ -132,8 +136,8 @@ def Simulation(location, *args, **kwargs):
 
     # Check if the specified version exists in the simulation catalog
     if not hasattr(metadata, "DOI_versions"):
-        input_version = "v0.0"  # A fake version, to signal this sim doesn't know about DOIs
-    if input_version != "v0.0" and input_version not in metadata.DOI_versions:
+        input_version = latest_version
+    if input_version != latest_version and input_version not in metadata.DOI_versions:
         raise ValueError(f"Version '{input_version}' not found in simulation catalog for '{simulation_id}'")
 
     # Set various pieces of information about the simulation
@@ -206,17 +210,31 @@ def Simulation(location, *args, **kwargs):
     # Note the deprecation status in the kwargs, even if ignoring deprecation
     kwargs["deprecated"] = deprecated
 
-    # TODO: Default to not downloading file info
-    # TODO: In that case, deal with Lev numbers somehow
-
     # We want to do this *after* deprecation checking, to avoid possibly unnecessary web requests
+    if 1 <= float(version[1:]) < 3.0 and "files" in metadata:
+        # The simulation metadata is points to files with a different version
+        del metadata["files"]
     files = get_file_info(metadata, sxs_id, download=kwargs.get("download_file_info", None))
 
     # If Lev is given as part of `location`, use it; otherwise, use the highest available
     lev_numbers = sorted({lev for f in files if (lev:=lev_number(f))})
-    output_lev_number = input_lev_number or max(lev_numbers)
+    if input_lev_number is not None and lev_numbers:
+        if input_lev_number not in lev_numbers:
+            raise ValueError(
+                f"Lev number '{input_lev_number}' not found in simulation files for {sxs_id}"
+            )
+    max_lev_number = max(lev_numbers, default=np.nan)
+    output_lev_number = input_lev_number or max_lev_number
     location = f"{sxs_id_stem}{version}/Lev{output_lev_number}"
 
+    # Keep the metadata around unless we're asking for an old version
+    # or a less-than-maximal Lev
+    if (
+        version != latest_version
+        or (lev_numbers and output_lev_number != max_lev_number)
+    ):
+        metadata = None
+
     # Finally, figure out which version of the simulation to load and dispatch
     version_number = float(version[1:])
     if 1 <= version_number < 2.0:
@@ -227,7 +245,7 @@ def Simulation(location, *args, **kwargs):
         sim = Simulation_v2(
             metadata, series, version, sxs_id_stem, sxs_id, url, files, lev_numbers, output_lev_number, location, *args, **kwargs
         )
-    elif 3 <= version_number < 4.0 or version == "v0.0":
+    elif 3 <= version_number < 4.0 or version == latest_version:
         sim = Simulation_v3(
             metadata, series, version, sxs_id_stem, sxs_id, url, files, lev_numbers, output_lev_number, location, *args, **kwargs
         )
@@ -245,8 +263,9 @@ class SimulationBase:
     
     Attributes
     ----------
-    metadata : Metadata
-        Metadata object for the simulation
+    metadata : Metadata or None
+        Metadata object for the simulation.  If `None`, the metadata
+        will be loaded automatically.
     series : pandas.Series
         The metadata, as extracted from the `simulations.dataframe`,
         meaning that it has columns consistent with other simulations,
@@ -307,7 +326,6 @@ class SimulationBase:
         metadata, series, version, sxs_id_stem, sxs_id, url, files, lev_numbers, lev_number, location,
         *args, **kwargs
     ):
-        self.metadata = metadata
         self.series = series
         self.version = version
         self.sxs_id_stem = sxs_id_stem
@@ -318,6 +336,7 @@ class SimulationBase:
         self.lev_number = lev_number
         self.location = location
         self.deprecated = kwargs.get("deprecated", False)
+        self.metadata = metadata or self.load_metadata()
 
     def __repr__(self):
         chi1 = self.series["reference_dimensionless_spin1"]
@@ -400,7 +419,7 @@ class SimulationBase:
         warning_threshold : float, optional
             Threshold distance above which a warning will be issued
             that the closest simulation is fairly distant.  Default is
-            1e-3.
+            1e-2.
 
         Returns
         -------
@@ -430,12 +449,34 @@ class SimulationBase:
 
     @property
     def lev(self):
-        return f"Lev{self.lev_number}"
+        if self.lev_number is None:
+            return ""
+        else:
+            return f"Lev{self.lev_number}"
 
     @property
     def Lev(self):
         return self.lev
 
+    @property
+    def metadata_path(self):
+        for separator in [":", "/"]:
+            for ending in [".json", ".txt"]:
+                prefix = f"{self.lev}{separator}" if self.lev else ""
+                if (fn := f"{prefix}metadata{ending}") in self.files:
+                    return fn
+        raise ValueError(
+            f"Metadata file not found in simulation files for {self.location}"
+        )
+
+    def load_metadata(self):
+        from .. import load
+        metadata_path = self.metadata_path
+        metadata_location = self.files.get(metadata_path)["link"]
+        sxs_id_path = Path(self.sxs_id)
+        metadata_truepath = Path(sxs_path_to_system_path(sxs_id_path / metadata_path))
+        return Metadata(load(metadata_location, truepath=metadata_truepath))
+
     def load_horizons(self):
         from .. import load
         sxs_id_path = Path(self.sxs_id)
@@ -717,7 +758,8 @@ class Simulation_v1(SimulationBase):
 
     @property
     def horizons_path(self):
-        return f"{self.lev}/Horizons.h5"
+        prefix = f"{self.lev}/" if self.lev else ""
+        return f"{prefix}Horizons.h5"
     
     def load_horizons(self):
         from .. import load
@@ -739,25 +781,27 @@ class Simulation_v1(SimulationBase):
 
     @property
     def strain_path(self):
+        prefix = f"{self.lev}/" if self.lev else ""
         extrapolation = (
             f"Extrapolated_{self.extrapolation}.dir"
             if self.extrapolation != "Outer"
             else "OutermostExtraction.dir"
         )
         return (
-            f"{self.lev}/rhOverM_Asymptotic_GeometricUnits_CoM.h5",
+            f"{prefix}rhOverM_Asymptotic_GeometricUnits_CoM.h5",
             extrapolation
         )
 
     @property
     def psi4_path(self):
+        prefix = f"{self.lev}/" if self.lev else ""
         extrapolation = (
             f"Extrapolated_{self.extrapolation}.dir"
             if self.extrapolation != "Outer"
             else "OutermostExtraction.dir"
         )
         return (
-            f"{self.lev}/rMPsi4_Asymptotic_GeometricUnits_CoM.h5",
+            f"{prefix}rMPsi4_Asymptotic_GeometricUnits_CoM.h5",
             extrapolation
         )
 
@@ -795,18 +839,23 @@ class Simulation_v2(SimulationBase):
     also `SimulationBase` for the base class that this class inherits
     from.
     """
+    # Default extrapolation order for this simulation version
+    default_extrapolation = "N2"
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.extrapolation = kwargs.get("extrapolation", "N2")
+        self.extrapolation = kwargs.get("extrapolation", self.default_extrapolation)
 
     @property
     def horizons_path(self):
-        return f"{self.lev}:Horizons.h5"
+        prefix = f"{self.lev}:" if self.lev else ""
+        return f"{prefix}Horizons.h5"
 
     @property
     def strain_path(self):
+        prefix = f"{self.lev}:" if self.lev else ""
         return (
-            f"{self.lev}:Strain_{self.extrapolation}",
+            f"{prefix}Strain_{self.extrapolation}",
             "/"
         )
 
@@ -817,8 +866,9 @@ class Simulation_v2(SimulationBase):
             if self.extrapolation != "Outer"
             else "OutermostExtraction.dir"
         )
+        prefix = f"{self.lev}:" if self.lev else ""
         return (
-            f"{self.lev}:ExtraWaveforms",
+            f"{prefix}ExtraWaveforms",
             f"/rMPsi4_Asymptotic_GeometricUnits_CoM_Mem/{extrapolation}"
         )
 
@@ -846,7 +896,31 @@ class Simulation_v2(SimulationBase):
 
 
 class Simulation_v3(Simulation_v2):
-    pass
+    # Default extrapolation order for this simulation version
+    default_extrapolation = "N2"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.extrapolation = kwargs.get("extrapolation", self.default_extrapolation)
+
+    @property
+    def strain_path(self):
+        prefix = f"{self.lev}:" if self.lev else ""
+        return (
+            f"{prefix}Strain_{self.extrapolation}",
+            "/"
+        ) if self.extrapolation == self.default_extrapolation else (
+            f"{prefix}ExtraWaveforms",
+            f"/Strain_{self.extrapolation}.dir"
+        )
+
+    @property
+    def psi4_path(self):
+        prefix = f"{self.lev}:" if self.lev else ""
+        return (
+            f"{prefix}ExtraWaveforms",
+            f"/Psi4_{self.extrapolation}.dir"
+        )
 
 
 def get_file_info(metadata, sxs_id, download=None):

{sxs-2025.0.2 → sxs-2025.0.4}/sxs/waveforms/__init__.py

@@ -18,7 +18,7 @@ from .format_handlers import (
     grathena,
 )
 from .format_handlers.lvc import to_lvc_conventions
-from . import memory, transformations, alignment
+from . import memory, transformations, alignment, norms
 
 # Map a format string to the module that should be used to load a waveform with that format
 formats = {