sxs 2024.0.36__tar.gz → 2024.0.38__tar.gz

{sxs-2024.0.36 → sxs-2024.0.38}/.github/workflows/build.yml

@@ -47,12 +47,9 @@ jobs:
         if: ${{ env.skipping_build_and_test_replicate != 'true' }}
         uses: actions/cache@v4
         with:
-          key: sxs-${{ runner.os }}-python${{ matrix.python-version }}
+          key: sxs-${{ runner.os }}-1 # Increment this number whenever the cached files should change
           path: |
-            ~/.sxs
-          restore-keys: |
-            sxs-${{ runner.os }}-
-            sxs-
+            ${{ runner.os == 'Linux' && '/home/runner/.cache/sxs' || runner.os == 'Windows' && 'C:\Users\runneradmin\.sxs\cache' || '/Users/runner/.sxs/cache' }}
 
       - name: Set up Julia
         if: ${{ env.skipping_build_and_test_replicate != 'true' }}
@@ -78,7 +75,9 @@ jobs:
 
       - name: Run tests
         if: ${{ env.skipping_build_and_test_replicate != 'true' }}
-        run: hatch run test
+        shell: bash
+        run: |
+          hatch run test
 
       - name: Upload coverage
         if: "matrix.python-version == '3.13' && matrix.os == 'ubuntu-latest'"

{sxs-2024.0.36 → sxs-2024.0.38}/CITATION.cff

@@ -10,5 +10,5 @@ authors:
 title: "The sxs package"
 license: MIT
 doi: 10.5281/zenodo.4034006
-version: 2024.0.36
-date-released: 2025-02-20
+version: 2024.0.38
+date-released: 2025-02-24

{sxs-2024.0.36 → sxs-2024.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sxs
-Version: 2024.0.36
+Version: 2024.0.38
 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.38/sxs/__version__.py

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

{sxs-2024.0.36 → sxs-2024.0.38}/sxs/caltechdata/__init__.py

@@ -1,4 +1,3 @@
-import copy
 import time
 import warnings
 import re
@@ -11,10 +10,6 @@ from .. import sxs_id, Metadata
 from ..utilities import sxs_identifier_regex, SimpleVersion
 
 
-# To do:
-# - Finish up the code to create a new version from an existing one
-
-
 def mtime(f):
     """Look for git or filesystem modification time
 

{sxs-2024.0.36 → sxs-2024.0.38}/sxs/metadata/__init__.py

@@ -1,6 +1,7 @@
 """Interface to SXS metadata files"""
 
 from .metadata import Metadata
+from .metric import MetadataMetric
 
 formats = {
     None: Metadata,

sxs-2024.0.38/sxs/metadata/metric.py

@@ -0,0 +1,148 @@
+from ..utilities.string_converters import *
+import numpy as np
+
+class MetadataMetric:
+    """A metric for comparing metadata.
+
+    This class is designed to be used as a callable object that takes
+    two collections of metadata (`sxs.Metadata`, `dict`, `pd.Series`)
+    and returns a number measuring the distance between the metadata.
+    
+    With the default arguments, this will not strictly be a metric, as
+    it does not satisfy the triangle inequality.  However, it is
+    intended to be used as a heuristic for sorting and filtering
+    metadata, rather than as a strict metric for clustering or
+    classification.
+
+    Parameters
+    ----------
+    parameters : list of str, optional
+        The names of the metadata fields to be compared.  The defaults
+        are the reference quantities for mass ratio, spin,
+        eccentricity, and mean anomaly.  Note that all of these fields
+        *must* be present in *both* metadata collections.  (The
+        `Metadata.add_standard_parameters` method may be useful here.)
+    metric : array_like, optional
+        The matrix used to weight the differences in the parameters.
+        The default is a diagonal matrix with ones on the diagonal,
+        except for the mean-anomaly entry, which is 1/pi^2.
+    allow_different_object_types : bool, optional
+        If True, metadata with different object types (BHBH, BHNS,
+        NSNS) will be compared without penalty.  If False, metadata
+        with different object types will be assigned an infinite
+        distance.
+    eccentricity_threshold1 : float, optional
+        The threshold eccentricity below which we consider metadata1
+        non-eccentric.  Default is 1e-2.
+    eccentricity_threshold2 : float, optional
+        The threshold eccentricity below which we consider metadata2
+        non-eccentric.  Default is 1e-3.
+    eccentricity_threshold_penalize_shorter : int, optional
+        The number of orbits below which we penalize metadata2 for
+        having a non-zero eccentricity when metadata1 does not.  This
+        is intended to avoid ascribing small distances to systems with
+        shorter inspirals.  Default is 20.
+
+    The mean anomaly, if present, is treated specially to account for
+    the fact that a mean anomaly of 0 is equivalent to a mean anomaly
+    of 2π.  The difference between the entries in the two metadata
+    collections is "unwrapped" before the metric is applied.
+
+    If the eccentricity of metadata1 is below
+    `eccentricity_threshold1`, then the mean anomaly is ignored.  If
+    that is true and the eccentricity of metadata2 is below
+    `eccentricity_threshold2` *and* the number of orbits in metadata2
+    is longer than `eccentricity_threshold_penalize_shorter`, then the
+    eccentricity is also ignored.  You may set these arguments to 0 to
+    disable these features.
+
+    """
+    def __init__(
+            self,
+            parameters=[
+                "reference_mass_ratio",
+                "reference_dimensionless_spin1",
+                "reference_dimensionless_spin2",
+                "reference_eccentricity",
+                "reference_mean_anomaly",
+            ],
+            metric=np.diag([1, 1, 1, 1, 1, 1, 1, 1, 1/np.pi**2]),
+            allow_different_object_types=False,
+            eccentricity_threshold1=1e-2,
+            eccentricity_threshold2=1e-3,
+            eccentricity_threshold_penalize_shorter=20,
+    ):
+        self.parameters = parameters
+        self.metric = metric
+        self.allow_different_object_types = allow_different_object_types
+        self.eccentricity_threshold1 = eccentricity_threshold1
+        self.eccentricity_threshold2 = eccentricity_threshold2
+        self.eccentricity_threshold_penalize_shorter = eccentricity_threshold_penalize_shorter
+
+    def __call__(self, metadata1, metadata2, debug=False):
+        if not self.allow_different_object_types:
+            type1 = (
+                metadata1["object_types"]
+                if "object_types" in metadata1
+                else "".join(sorted([
+                    metadata1.get("object1", "A").upper(),
+                    metadata1.get("object2", "B").upper()
+                ]))
+            )
+            type2 = (
+                metadata2["object_types"]
+                if "object_types" in metadata2
+                else "".join(sorted([
+                    metadata2.get("object1", "C").upper(),
+                    metadata2.get("object2", "D").upper()
+                ]))
+            )
+            if type1 != type2:
+                return np.inf
+
+        values1 = [metadata1[parameter] for parameter in self.parameters]
+        values2 = [metadata2[parameter] for parameter in self.parameters]
+
+        if debug:
+            print(f"{self.parameters=}")
+            print(f"{values1=}")
+            print(f"{values2=}")
+
+        if "reference_mean_anomaly" in self.parameters:
+            i = self.parameters.index("reference_mean_anomaly")
+            values1[i], values2[i] = np.unwrap([floater(values1[i]), floater(values2[i])])
+
+        if "reference_eccentricity" in self.parameters:
+            # Either way, we first make sure that the corresponding entries are floats.
+            i = self.parameters.index("reference_eccentricity")
+            values1[i] = metadata1.get("reference_eccentricity_bound", floaterbound(values1[i]))
+            values2[i] = metadata2.get("reference_eccentricity_bound", floaterbound(values2[i]))
+
+            if values1[i] < self.eccentricity_threshold1:
+                # Then we consider metadata1 a non-eccentric system...
+
+                # ...so we ignore the mean anomaly entirely...
+                if "reference_mean_anomaly" in self.parameters:
+                    i_ma = self.parameters.index("reference_mean_anomaly")
+                    values1[i_ma] = values2[i_ma]
+
+                # ...and we ignore the eccentricity if metadata2 is also non-eccentric,
+                # and longer than eccentricity_threshold_penalize_shorter.
+                if (
+                    values2[i] < self.eccentricity_threshold2
+                    and metadata2.get(
+                        "number_of_orbits",
+                        metadata2.get("number_of_orbits_from_start", 0)
+                    ) > self.eccentricity_threshold_penalize_shorter
+                ):
+                    values1[i] = values2[i]
+
+        difference = (
+            np.concatenate(list(map(np.atleast_1d, values1)))
+            - np.concatenate(list(map(np.atleast_1d, values2)))
+        )
+
+        if debug:
+            print(f"{difference=}")
+
+        return difference @ self.metric @ difference

{sxs-2024.0.36 → sxs-2024.0.38}/sxs/simulations/local.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from datetime import datetime, timezone
 from .. import sxs_id, Metadata, sxs_directory
 from ..utilities import sxs_identifier_re
 from ..zenodo import path_to_invenio
@@ -147,16 +148,23 @@ def local_simulations(annex_dir, compute_md5=False, show_progress=False):
 
                 metadata["directory"] = str(dirpath.relative_to(annex_dir))
 
+                simulations[key] = metadata
+
+                files = files_to_upload(dirpath, annex_dir)
+
+                metadata["mtime"] = datetime.fromtimestamp(
+                    max(file.resolve().stat().st_mtime for file in files),
+                    tz=timezone.utc,
+                ).isoformat()
+
                 metadata["files"] = {
                     path_to_invenio(file.relative_to(dirpath)): {
                         "link": str(file),
                         "size": file.stat().st_size,
                         "checksum": md5checksum(file) if compute_md5 else "",
                     }
-                    for file in files_to_upload(dirpath, annex_dir)
+                    for file in files
                 }
-
-                simulations[key] = metadata
             except KeyboardInterrupt:
                 raise
             except Exception as e:

{sxs-2024.0.36 → sxs-2024.0.38}/sxs/simulations/simulation.py

@@ -53,12 +53,13 @@ def Simulation(location, *args, **kwargs):
         SXS ID, but can also include the version and Lev number, as
         described above.
 
-    Other parameters
-    ----------------
-    ignore_deprecation : bool
+    Keyword Arguments
+    -----------------
+    ignore_deprecation : bool, optional
         If `True`, completely bypass checking for deprecation or
-        supersession.  No warnings or errors will be issued.
-    auto_supersede : bool
+        supersession.  No warnings or errors will be issued.  Default
+        is `False`.
+    auto_supersede : bool, optional
         If `True`, automatically load the superseding simulation, if
         there is only one.  If there are multiple superseding
         simulations, an error will be raised, and you must explicitly
@@ -66,7 +67,11 @@ def Simulation(location, *args, **kwargs):
         issued, but the superseding simulation will be loaded.  Note
         that this can also be set in the configuration file with
         `sxs.write_config(auto_supersede=True)`.
-    extrapolation : str
+    metadata_metric : MetadataMetric, optional
+        Metric to use for comparing simulations when automatically
+        superseding deprecated a simulation.  If not provided, the
+        default metric will be used.
+    extrapolation : str, optional
         The extrapolation order to use for the strain and Psi4 data.
         This is only relevant for versions 1 and 2 of the data format,
         both of which default to "N2".  Other options include "N3",
@@ -74,14 +79,13 @@ 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
+    download_file_info : bool, optional
         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.
+        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
     -------
@@ -96,6 +100,7 @@ def Simulation(location, *args, **kwargs):
     
     """
     from .. import load, sxs_directory
+    from ..metadata.metric import MetadataMetric
 
     # Load the simulation catalog
     simulations = load("simulations")
@@ -132,81 +137,58 @@ def Simulation(location, *args, **kwargs):
     sxs_id = f"{sxs_id_stem}{version}"
     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):
+    # Deal with deprecations
+    deprecated = "deprecated" in metadata.get("keywords", [])
+    if deprecated and 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
-        ):
-            message = ("\n"
-                + f"Simulation '{sxs_id_stem}' is deprecated and/or superseded.\n"
-                + "Normally, this simulation should no longer be used, but you\n"
-                + f"explicitly requested version '{input_version}', so it is being used.\n"
-            )
-            warn(message)
-        else:
-            if "superseded_by" in metadata:
-                superseded_by = metadata["superseded_by"]
-                if auto_supersede and isinstance(superseded_by, list):
-                    raise ValueError(
-                        f"`auto_supersede` is enabled, but simulation '{sxs_id}' is\n"
-                        + "superseded by multiple simulations.  You must choose one\n"
-                        + "explicitly from the list:\n"
-                        + "\n".join(f"  {s}" for s in superseded_by)
-                        + "\nAlternatively, you could pass `ignore_deprecation=True` or\n"
-                        + "specify a version to load this waveform anyway."
-                    )
-                elif auto_supersede and isinstance(superseded_by, str):
-                    # raise NotImplementedError(
-                    #     f"\nSimulation '{sxs_id}' cannot be automatically superseded.\n"
-                    #     + "The auto_supersede option is temporarily disabled.  The superseding\n"
-                    #     + "simulations have been removed from the metadata, and the new function\n"
-                    #     + "to load them has not yet been implemented.  Please specify a version.\n"
-                    # )
-                    message = f"\nSimulation '{sxs_id}' is being automatically superseded by '{superseded_by}'."
-                    warn(message)
-                    new_location = f"{superseded_by}{input_version}"
-                    if input_lev_number:
-                        new_location += f"/Lev{input_lev_number}"
-                    return Simulation(new_location, *args, **kwargs)
-                elif isinstance(superseded_by, list):
-                    raise ValueError(
-                        f"Simulation '{sxs_id}' is superseded by multiple simulations.\n"
-                        + "Even if you enable `auto_supersede`, with multiple options, you\n"
-                        + "must choose one explicitly from the list:\n"
-                        + "\n".join(f"  {s}" for s in superseded_by)
-                        + "\nAlternatively, you could pass `ignore_deprecation=True` or\n"
-                        + "specify a version to load this waveform anyway."
-                    )
-                elif isinstance(superseded_by, str):
-                    raise ValueError(
-                        f"Simulation '{sxs_id}' is superseded by '{superseded_by}'.\n"
-                        + "Note that you could enable `auto_supersede` to automatically\n"
-                        + "load the superseding simulation.  Alternatively, you could\n"
-                        + "pass `ignore_deprecation=True` or specify a version to load\n"
-                        + "this waveform anyway."
-                    )
-                else:
-                    raise ValueError(
-                        f"Simulation '{sxs_id}' is superseded by '{superseded_by}'.\n"
-                        + "Note that you could pass `ignore_deprecation=True` or\n"
-                        + "specify a version to load this waveform anyway."
-                    )
-            if "deprecated" in metadata.get("keywords", []):
+        if not bool(auto_supersede):
+            if not input_version:
                 raise ValueError(
-                    f"Simulation '{sxs_id}' is deprecated but has no superseding simulation.\n"
-                    + "Note that you could pass `ignore_deprecation=True` or specify a version\n"
-                    + "to  to load this waveform anyway."
+                    f"Simulation '{location}' is deprecated.  You could\n"
+                    +  "  1. pass `ignore_deprecation=True` to load the latest available version,\n"
+                    +  "  2. manually choose a different simulation from the catalog,\n"
+                    +  "  3. pass `auto_supersede=True` to load the closest match in the catalog, or\n"
+                    + f"  4. include the version number, as in '{sxs_id_stem}v2.0', to load a specific version.\n"
+                )
+            else:
+                message = ("\n"
+                    + f"Simulation '{sxs_id_stem}' is deprecated, but you explicitly\n"
+                    + f"requested version '{input_version}', so it is being used.\n"
+                    + f"Pass `ignore_deprecation=True` to quiet this warning.\n"
+                )
+                warn(message)
+        else:
+            if input_version:
+                message = ("\n"
+                    + f"\nSimulation '{sxs_id}' is deprecated.  You explicitly requested.\n"
+                    + f"version '{input_version}', but you also passed the `auto_supersede` option.\n"
+                    + f"Using the specified version, as that takes precedence.\n"
+                )
+                warn(message)
+            else:
+                original_kwargs = kwargs.copy()
+                original_kwargs["ignore_deprecation"] = True
+                original = Simulation(location, *args, **original_kwargs)
+                metadata_metric = kwargs.pop("metadata_metric", MetadataMetric())
+                superseding = original.closest_simulation(
+                    dataframe=simulations.dataframe,
+                    metadata_metric=metadata_metric
                 )
+                message = f"\nSimulation '{sxs_id}' is being automatically superseded by '{superseding}'."
+                warn(message)
+                new_location = f"{superseding}{input_version}"
+                if input_lev_number:
+                    new_location += f"/Lev{input_lev_number}"
+                return Simulation(new_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
-    files = get_file_info(metadata, sxs_id, download=kwargs.get("download", None))
+    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))})
@@ -328,6 +310,82 @@ class SimulationBase:
     def __str__(self):
         return repr(self)
     
+    def distances(self, dataframe=None, metadata_metric=None, drop_deprecated=False):
+        """Measure the distance from this simulation to others
+
+        Parameters
+        ----------
+        dataframe : pandas.DataFrame, optional
+            DataFrame of simulations to compare to.  If not provided,
+            the full catalog of simulations will be loaded as
+            `sxs.load("simulations").dataframe`.
+        metadata_metric : MetadataMetric, optional
+            Metric to use for comparing simulations.  If not provided,
+            the default metric will be used.
+        drop_deprecated : bool, optional
+            If `True`, remove deprecated simulations from the
+            `dataframe` before measuring distances.
+
+        Returns
+        -------
+        distances : pandas.Series
+            Distance from this simulation to each element of the
+            `dataframe`.  This series will be indexed by the index of
+            the `dataframe`.  If this simulation is in the
+            `dataframe`, it will have a distance of 0.
+
+        See Also
+        --------
+        simulations_sorted_by_distance : Sort dataframe of simulations
+            by "distance" to this one
+        sxs.metadata.metric.MetadataMetric : Metric for comparing
+            metadata
+
+        """
+        from ..metadata.metric import MetadataMetric
+        from .. import load
+        if dataframe is None:
+            dataframe = load("simulations").dataframe
+        metadata_metric = metadata_metric or MetadataMetric()
+        if drop_deprecated:
+            dataframe = dataframe[~dataframe.deprecated]
+        return dataframe.apply(
+            lambda m: metadata_metric(self.metadata, m),
+            axis=1
+        )
+
+    def closest_simulation(self, dataframe=None, metadata_metric=None):
+        """Return the closest undeprecated simulation to this one
+
+        Note that any simulation in `dataframe` with zero distance
+        from this one will be ignored; the returned index will not
+        refer to this simulation, even if it is undeprecated.
+
+        Parameters
+        ----------
+        dataframe : pandas.DataFrame, optional
+            DataFrame of simulations to compare to.  If not provided,
+            the full catalog of simulations will be loaded as
+            `sxs.load("simulations").dataframe`.
+        metadata_metric : MetadataMetric, optional
+            Metric to use for comparing simulations.  If not provided,
+            the default metric will be used.
+
+        Returns
+        -------
+        closest_index : str
+            Index of the closest undeprecated simulation in the
+            `dataframe`.
+
+        """
+        d = self.distances(
+            dataframe=dataframe,
+            metadata_metric=metadata_metric,
+            drop_deprecated=True
+        )
+        d = d[d > 0].sort_values()
+        return d.index[0]
+    
     @property
     def dataframe(self):
         return self.series
@@ -753,6 +811,7 @@ class Simulation_v2(SimulationBase):
 
 
 def get_file_info(metadata, sxs_id, download=None):
+    # TODO: Allow an existing zenodo_metadata.json file to be used
     from .. import load_via_sxs_id
     if "files" in metadata:
         return metadata["files"]

{sxs-2024.0.36 → sxs-2024.0.38}/sxs/simulations/simulations.py

@@ -4,6 +4,9 @@ import collections
 import numpy as np
 import pandas as pd
 
+from ..utilities.string_converters import *
+
+
 class SimulationsDataFrame(pd.DataFrame):
     @property
     def BBH(self):
@@ -87,6 +90,11 @@ class SimulationsDataFrame(pd.DataFrame):
         return type(self)(self[
             np.isfinite(total_mass) & (total_mass > 0) & (normalized_ADM > 1)
         ])
+    
+    @property
+    def undeprecated(self):
+        """Restrict dataframe to just simulations that are not deprecated"""
+        return type(self)(self[~self["deprecated"]])
 
 
 class Simulations(collections.OrderedDict):
@@ -416,46 +424,6 @@ class Simulations(collections.OrderedDict):
             if col not in simulations.columns:
                 simulations[col] = np.nan
 
-        def floater(x):
-            try:
-                f = float(x)
-            except:
-                f = np.nan
-            return f
-
-        def floaterbound(x):
-            try:
-                f = float(x)
-            except:
-                try:
-                    f = float(x.replace("<", ""))
-                except:
-                    f = np.nan
-            return f
-
-        def norm(x):
-            try:
-                n = np.linalg.norm(x)
-            except:
-                n = np.nan
-            return n
-
-        def three_vec(x):
-            try:
-                a = np.array(x, dtype=float)
-                if a.shape != (3,):
-                    raise ValueError("Don't understand input as a three-vector")
-            except:
-                a = np.array([np.nan, np.nan, np.nan])
-            return a
-
-        def datetime_from_string(x):
-            try:
-                dt = pd.to_datetime(x).tz_convert("UTC")
-            except:
-                dt = pd.to_datetime("1970-1-1").tz_localize("UTC")
-            return dt
-
         sims_df = SimulationsDataFrame(pd.concat((
             simulations["reference_time"].map(floater),
             simulations["reference_mass_ratio"].map(floater),
@@ -523,7 +491,6 @@ class Simulations(collections.OrderedDict):
             simulations["number_of_orbits"].map(floater),
             simulations["number_of_orbits_from_start"].map(floater),
             simulations["number_of_orbits_from_reference_time"].map(floater),
-            # simulations["superseded_by"],
             simulations["DOI_versions"],
             simulations["keywords"],
             simulations["date_link_earliest"].map(datetime_from_string),
@@ -533,7 +500,6 @@ class Simulations(collections.OrderedDict):
         ), axis=1))
 
         sims_df.insert(0, "deprecated", (
-            # ~sims_df.superseded_by.isna() |
             sims_df["keywords"].map(lambda ks: "deprecated" in ks)
         ))
 

sxs-2024.0.38/sxs/utilities/string_converters.py

@@ -0,0 +1,47 @@
+
+# Assemble some helper functions
+
+def floater(x):
+    import numpy as np
+    try:
+        f = float(x)
+    except:
+        f = np.nan
+    return f
+
+def floaterbound(x):
+    import numpy as np
+    try:
+        f = float(x)
+    except:
+        try:
+            f = float(x.replace("<", ""))
+        except:
+            f = np.nan
+    return f
+
+def norm(x):
+    import numpy as np
+    try:
+        n = np.linalg.norm(x)
+    except:
+        n = np.nan
+    return n
+
+def three_vec(x):
+    import numpy as np
+    try:
+        a = np.array(x, dtype=float)
+        if a.shape != (3,):
+            raise ValueError("Don't understand input as a three-vector")
+    except:
+        a = np.array([np.nan, np.nan, np.nan])
+    return a
+
+def datetime_from_string(x):
+    import pandas as pd
+    try:
+        dt = pd.to_datetime(x).tz_convert("UTC")
+    except:
+        dt = pd.to_datetime("1970-1-1").tz_localize("UTC")
+    return dt