sxs 2024.0.4__tar.gz → 2024.0.6__tar.gz

{sxs-2024.0.4 → sxs-2024.0.6}/CITATION.cff

@@ -10,5 +10,5 @@ authors:
 title: "The sxs package"
 license: MIT
 doi: 10.5281/zenodo.4034006
-version: 2024.0.4
-date-released: 2024-08-19
+version: 2024.0.6
+date-released: 2024-09-05

{sxs-2024.0.4 → sxs-2024.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sxs
-Version: 2024.0.4
+Version: 2024.0.6
 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/

sxs-2024.0.6/sxs/__version__.py

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

{sxs-2024.0.4 → sxs-2024.0.6}/sxs/horizons/__init__.py

@@ -379,6 +379,30 @@ class Horizons(object):
 
     nhat = n̂
 
+    @property
+    def λ⃗(self):
+        """Time-derivative of separation vector
+
+        This function can be spelled `λ⃗` or `lambdavec`, interchangeably.
+
+        Returns
+        -------
+        λ⃗ : ndarray
+            This has shape (self.A.n_times, 3), representing the components of the
+            vector as a function of time.
+
+        See Also
+        --------
+        n⃗, nvec, separation : (Non-normalized) separation vector between two horizons
+        n̂, nhat : Normalized separation vector
+        λ̂, lambdahat : Normalized version of this vector
+        ℓ̂, ellhat : Normalized angular-velocity vector
+
+        """
+        return self.n⃗.dot
+    
+    lambdavec = λ⃗
+
     @property
     def λ̂(self):
         """Time-derivative of normalized separation vector
@@ -403,7 +427,7 @@ class Horizons(object):
         post-Newtonian theory and similar treatments.
 
         """
-        λ⃗ = self.n̂.dot
+        λ⃗ = self.λ⃗
         return λ⃗ / np.linalg.norm(λ⃗, axis=1)[:, np.newaxis]
 
     lambdahat = λ̂
@@ -435,3 +459,74 @@ class Horizons(object):
         return TimeSeries(np.cross(self.n̂, self.λ̂), time=self.n̂.time)
 
     ellhat = ℓ̂
+
+    @property
+    def R(self):
+        """Frame Rotor taking (x̂, ŷ, ẑ) onto (n̂, λ̂, ℓ̂) at each instant
+        
+        For example, if λ̂ᵢ is the value of λ̂ at time tᵢ, and Rᵢ the
+        corresponding output from this function, then we have
+        
+            λ̂ᵢ = Rᵢ * quaternionic.y / Rᵢ
+
+        Returns
+        -------
+        R : quaternionic.array
+            This has shape (self.A.n_times, 4), representing the rotor
+            at each time.  Note that this is *not* a TimeSeries
+            object, as is returned by several other functions in this
+            class.  However, the corresponding times are available as
+            `R.time`.
+        """
+        import numpy as np
+        import quaternionic
+        reference_frame = np.array([quaternionic.x.vector, quaternionic.y.vector, quaternionic.z.vector])
+        target_frame = np.array([self.n̂, self.λ̂, self.ℓ̂])
+        R = quaternionic.array([
+            quaternionic.align(
+                target_frame[:, i, :],
+                reference_frame
+            )
+            for i in range(target_frame.shape[1])
+        ])
+        quaternionic.unflip_rotors(R, inplace=True)
+        R.time = self.A.time
+        return R
+
+    @property
+    def Ω⃗(self):
+        """Angular velocity vector of the binary
+
+        This function can be spelled `Ω⃗`, `ω⃗`, `OmegaVec`, or
+        `omegaVec`, interchangeably.
+
+        Returns
+        -------
+        Ω⃗ : TimeSeries
+            This represents the angular velocity as a function of time.
+        """
+        R = self.R
+        return TimeSeries(R.to_angular_velocity(R.time), time=R.time)
+    
+    ω⃗ = Ω⃗
+    OmegaVec = Ω⃗
+    omegaVec = Ω⃗
+
+    @property
+    def Ω(self):
+        """Magnitude of the angular velocity of the binary
+
+        This function can be spelled `Ω`, `ω`, `Omega`, or `omega`,
+        interchangeably.
+
+        Returns
+        -------
+        Ω : TimeSeries
+            This represents the magnitude of the angular velocity as a
+            function of time.
+        """
+        return TimeSeries(np.linalg.norm(self.Ω⃗, axis=1), time=self.A.time)
+    
+    ω = Ω
+    Omega = Ω
+    omega = Ω

{sxs-2024.0.4 → sxs-2024.0.6}/sxs/simulations/simulation.py

@@ -74,6 +74,14 @@ def Simulation(location, *args, **kwargs):
         polynomials in 1/r with degree `x`, while "Outer" refers to
         data extracted at the outermost extraction radius but
         corrected for time-dilation and areal-radius effects.
+    download : bool
+        If `True`, download the information about the files from the
+        Zenodo/CaltechDATA record.  If `False`, only use the file
+        information that is already available (which will raise an
+        error if the file information has not previously been
+        downloaded).  If not present, use the value from the
+        configuration file, defaulting to `True` if it is not
+        configured.
 
     Returns
     -------
@@ -117,12 +125,13 @@ def Simulation(location, *args, **kwargs):
     url = f"{doi_url}{sxs_id}"
 
     # Deal with "superseded_by" field, or "deprecated" keyword in the metadata
+    deprecated = ("deprecated" in metadata.get("keywords", []) or metadata.get("superseded_by", False))
     if not kwargs.get("ignore_deprecation", False):
         auto_supersede = kwargs.get("auto_supersede", read_config("auto_supersede", False))
         if (
             input_version
             and not auto_supersede
-            and ("deprecated" in metadata.get("keywords", []) or metadata.get("superseded_by", False))
+            and deprecated
         ):
             message = ("\n"
                 + f"Simulation '{sxs_id_stem}' is deprecated and/or superseded.\n"
@@ -179,8 +188,11 @@ def Simulation(location, *args, **kwargs):
                     + "to  to load this waveform anyway."
                 )
 
+    # Note the deprecation status in the kwargs, even if ignoring deprecation
+    kwargs["deprecated"] = deprecated
+
     # We want to do this *after* deprecation checking, to avoid possibly unnecessary web requests
-    files = get_file_info(metadata, sxs_id)
+    files = get_file_info(metadata, sxs_id, download=kwargs.get("download", 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))})
@@ -281,9 +293,20 @@ class SimulationBase:
         self.lev_numbers = lev_numbers
         self.lev_number = lev_number
         self.location = location
+        self.deprecated = kwargs.get("deprecated", False)
 
     def __repr__(self):
-        return f"""{type(self).__qualname__}("{self.sxs_id}")"""
+        chi1 = self.metadata.reference_dimensionless_spin1
+        chi2 = self.metadata.reference_dimensionless_spin2
+        construction = f"""{type(self).__qualname__}("{self.location}")\n# """
+        if self.deprecated:
+            construction += "DEPRECATED "
+        construction += f"{self.metadata.number_of_orbits:.3g}-orbit "
+        construction += f"q={self.metadata.reference_mass_ratio:.3g} "
+        construction += f"""chi1=[{", ".join(f"{c:.3g}" for c in chi1)}] """
+        construction += f"""chi2=[{", ".join(f"{c:.3g}" for c in chi2)}] """
+        construction += f"e={self.metadata.reference_eccentricity:.3g} simulation"
+        return construction
 
     def __str__(self):
         return repr(self)
@@ -317,6 +340,7 @@ class SimulationBase:
         if not hasattr(self, "_horizons"):
             self._horizons = self.load_horizons()
         return self._horizons
+    Horizons = horizons
 
     @property
     def strain(self):
@@ -500,16 +524,18 @@ class Simulation_v2(SimulationBase):
         h5_truepath = sxs_id_path / sxs_path_to_system_path(h5_path)
         json_truepath = sxs_id_path / sxs_path_to_system_path(json_path)
         if not json_truepath.exists():
+            if not read_config("download", True):
+                raise ValueError(f"{json_truepath} not found and download is disabled")
             download_file(json_location, sxs_directory("cache") / json_truepath)
         return load(h5_location, truepath=h5_truepath, group=group, metadata=self.metadata)
 
 
-def get_file_info(metadata, sxs_id):
+def get_file_info(metadata, sxs_id, download=None):
     from .. import load_via_sxs_id
     if "files" in metadata:
         return metadata["files"]
     truepath = Path(sxs_path_to_system_path(sxs_id)) / "zenodo_metadata.json"
-    record = load_via_sxs_id(sxs_id, "export/json", truepath=truepath)
+    record = load_via_sxs_id(sxs_id, "export/json", truepath=truepath, download=download)
     entries = record["files"]["entries"]
     return {
         str(filename): {

{sxs-2024.0.4 → sxs-2024.0.6}/sxs/simulations/simulations.py

@@ -217,7 +217,6 @@ class Simulations(collections.OrderedDict):
         """
         import numpy as np
         import pandas as pd
-        from datetime import datetime, timezone
 
         if hasattr(self, "_dataframe"):
             return self._dataframe
@@ -259,55 +258,36 @@ class Simulations(collections.OrderedDict):
 
         def datetime_from_string(x):
             try:
-                dt = datetime.strptime(x, "%Y-%m-%dT%H:%M:%S%z")
+                dt = pd.to_datetime(x).tz_convert("UTC")
             except:
-                dt = datetime.min.replace(tzinfo=timezone.utc)
+                dt = pd.to_datetime("1970-1-1").tz_localize("UTC")
             return dt
 
         sims_df = pd.concat((
-            simulations["object_types"].astype("category"),
-            simulations["initial_data_type"].astype("category"),
-            simulations["initial_separation"].map(floater),
-            simulations["initial_orbital_frequency"].map(floater),
-            simulations["initial_adot"].map(floater),
-            simulations["initial_ADM_energy"].map(floater),
-            simulations["initial_ADM_linear_momentum"].map(three_vec),
-            simulations["initial_ADM_linear_momentum"].map(norm).rename("initial_ADM_linear_momentum_mag"),
-            simulations["initial_ADM_angular_momentum"].map(three_vec),
-            simulations["initial_ADM_angular_momentum"].map(norm).rename("initial_ADM_angular_momentum_mag"),
-            simulations["initial_mass1"].map(floater),
-            simulations["initial_mass2"].map(floater),
-            simulations["initial_mass_ratio"].map(floater),
-            simulations["initial_dimensionless_spin1"].map(three_vec),
-            simulations["initial_dimensionless_spin1"].map(norm).rename("initial_dimensionless_spin1_mag"),
-            simulations["initial_dimensionless_spin2"].map(three_vec),
-            simulations["initial_dimensionless_spin2"].map(norm).rename("initial_dimensionless_spin2_mag"),
-            simulations["initial_position1"].map(three_vec),
-            simulations["initial_position2"].map(three_vec),
             simulations["reference_time"].map(floater),
-            (
-                simulations["reference_position1"].map(three_vec)
-                -simulations["reference_position2"].map(three_vec)
-            ).map(norm).rename("reference_separation"),
-            simulations["reference_orbital_frequency"].map(norm).rename("reference_orbital_frequency_mag"),
             simulations["reference_mass_ratio"].map(floater),
-            simulations["reference_dimensionless_spin1"].map(norm).rename("reference_chi1_mag"),
-            simulations["reference_dimensionless_spin2"].map(norm).rename("reference_chi2_mag"),
+            simulations["reference_dimensionless_spin1"].map(three_vec),
+            simulations["reference_dimensionless_spin1"].map(norm).rename("reference_dimensionless_spin1_mag"),
+            simulations["reference_dimensionless_spin2"].map(three_vec),
+            simulations["reference_dimensionless_spin2"].map(norm).rename("reference_dimensionless_spin2_mag"),
             simulations["reference_chi_eff"].map(floater),
             simulations["reference_chi1_perp"].map(floater),
             simulations["reference_chi2_perp"].map(floater),
             simulations["reference_eccentricity"].map(floater),
             simulations["reference_eccentricity"].map(floaterbound).rename("reference_eccentricity_bound"),
             simulations["reference_mean_anomaly"].map(floater),
-            simulations["reference_mass1"].map(floater),
-            simulations["reference_mass2"].map(floater),
-            simulations["reference_dimensionless_spin1"].map(three_vec),
-            simulations["reference_dimensionless_spin1"].map(norm).rename("reference_dimensionless_spin1_mag"),
-            simulations["reference_dimensionless_spin2"].map(three_vec),
-            simulations["reference_dimensionless_spin2"].map(norm).rename("reference_dimensionless_spin2_mag"),
             simulations["reference_orbital_frequency"].map(three_vec),
+            simulations["reference_orbital_frequency"].map(norm).rename("reference_orbital_frequency_mag"),
+            (
+                simulations["reference_position1"].map(three_vec)
+                -simulations["reference_position2"].map(three_vec)
+            ).map(norm).rename("reference_separation"),
             simulations["reference_position1"].map(three_vec),
             simulations["reference_position2"].map(three_vec),
+            simulations["reference_mass1"].map(floater),
+            simulations["reference_mass2"].map(floater),
+            simulations["reference_dimensionless_spin1"].map(norm).rename("reference_chi1_mag"),
+            simulations["reference_dimensionless_spin2"].map(norm).rename("reference_chi2_mag"),
             simulations["relaxation_time"].map(floater),
             #simulations["merger_time"].map(floater),
             simulations["common_horizon_time"].map(floater),
@@ -318,27 +298,50 @@ class Simulations(collections.OrderedDict):
             simulations["remnant_velocity"].map(norm).rename("remnant_velocity_mag"),
             #simulations["final_time"].map(floater),
             simulations["EOS"].fillna(simulations["eos"]),
+            simulations["disk_mass"].map(floater),
+            simulations["ejecta_mass"].map(floater),
+            simulations["object_types"].astype("category"),
             simulations["initial_data_type"].astype("category"),
+            simulations["initial_separation"].map(floater),
+            simulations["initial_orbital_frequency"].map(floater),
+            simulations["initial_adot"].map(floater),
+            simulations["initial_ADM_energy"].map(floater),
+            simulations["initial_ADM_linear_momentum"].map(three_vec),
+            simulations["initial_ADM_linear_momentum"].map(norm).rename("initial_ADM_linear_momentum_mag"),
+            simulations["initial_ADM_angular_momentum"].map(three_vec),
+            simulations["initial_ADM_angular_momentum"].map(norm).rename("initial_ADM_angular_momentum_mag"),
+            simulations["initial_mass1"].map(floater),
+            simulations["initial_mass2"].map(floater),
+            simulations["initial_mass_ratio"].map(floater),
+            simulations["initial_dimensionless_spin1"].map(three_vec),
+            simulations["initial_dimensionless_spin1"].map(norm).rename("initial_dimensionless_spin1_mag"),
+            simulations["initial_dimensionless_spin2"].map(three_vec),
+            simulations["initial_dimensionless_spin2"].map(norm).rename("initial_dimensionless_spin2_mag"),
+            simulations["initial_position1"].map(three_vec),
+            simulations["initial_position2"].map(three_vec),
             #simulations["object1"].astype("category"),
             #simulations["object2"].astype("category"),
-            simulations["disk_mass"].map(floater),
-            simulations["ejecta_mass"].map(floater),
             # simulations["url"],
             #simulations["simulation_name"],
             #simulations["alternative_names"],
             # simulations["metadata_path"],
-            simulations["date_link_earliest"].map(datetime_from_string),
-            simulations["date_postprocessing"].map(datetime_from_string),
-            simulations["date_run_earliest"].map(datetime_from_string),
-            simulations["date_run_latest"].map(datetime_from_string),
             # simulations["end_of_trajectory_time"].map(floater),
             # simulations["merger_time"].map(floater),
             simulations["number_of_orbits"].map(floater),
             simulations["superseded_by"],
             simulations["DOI_versions"],
             simulations["keywords"],
+            simulations["date_link_earliest"].map(datetime_from_string),
+            simulations["date_run_earliest"].map(datetime_from_string),
+            simulations["date_run_latest"].map(datetime_from_string),
+            simulations["date_postprocessing"].map(datetime_from_string),
         ), axis=1)
 
+        sims_df.insert(0, "deprecated", (
+            ~sims_df.superseded_by.isna()
+            | sims_df["keywords"].map(lambda ks: "deprecated" in ks)
+        ))
+
         # We have ignored the following fields present in the
         # simulations.json file (as of 2024-08-04), listed here with
         # the number of non-null entries:

{sxs-2024.0.4 → sxs-2024.0.6}/sxs/waveforms/format_handlers/rotating_paired_diff_multishuffle_bzip2.py

@@ -571,10 +571,12 @@ def load(
         w = w.to_inertial_frame()
 
     if metadata is None:
-        if not metadata_path.exists():
-            invalid(f'\nMetadata file "{metadata_path}" cannot be found, but is expected for this data format.')
-        else:
+        if metadata_path.exists():
             metadata = Metadata.from_file(metadata_path)
+        elif metadata_path.with_suffix(".txt").exists():
+            metadata = Metadata.from_file(metadata_path.with_suffix(".txt"))
+        else:
+            invalid(f"\nMetadata files {metadata_path}/.txt cannot be found, but at least one is expected for this data format.")
 
     dtb = kwargs.pop("drop_times_before", 0)
     if dtb=="begin":

sxs-2024.0.4/sxs/__version__.py

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