im-calculation 0.0.0__tar.gz

im_calculation-0.0.0/.gitignore

@@ -0,0 +1,25 @@
+*.pyc
+/IM/rspectra_calculations/rspectra.c
+/IM/rspectra_calculations/rspectra.so
+.idea
+build/
+test/test_calculate_ims/sample1/input/*.bin
+test/test_calculate_ims/sample1/output/
+test/test_calculate_ims/*.xml
+test/test_calculate_ims/html*
+test/test_calculate_ims/.coverage
+test/test_calculate_ims/output/__pycache*
+.cache/
+*.sl
+*.err
+*.out
+rrups.csv
+.calculate_rrups.py.swp
+*.log
+runs/
+**.so
+**sample0
+
+# special cases to unignore
+!periods.out
+.venv/

im_calculation-0.0.0/IM/im_calculation.py

@@ -0,0 +1,254 @@
+import multiprocessing
+import os
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from IM import ims
+from IM.ims import IM
+
+DEFAULT_PERIODS = np.asarray(
+    [
+        0.010,
+        0.020,
+        0.022,
+        0.025,
+        0.029,
+        0.030,
+        0.032,
+        0.035,
+        0.036,
+        0.040,
+        0.042,
+        0.044,
+        0.045,
+        0.046,
+        0.048,
+        0.050,
+        0.055,
+        0.060,
+        0.065,
+        0.067,
+        0.070,
+        0.075,
+        0.080,
+        0.085,
+        0.090,
+        0.095,
+        0.100,
+        0.110,
+        0.120,
+        0.130,
+        0.133,
+        0.140,
+        0.150,
+        0.160,
+        0.170,
+        0.180,
+        0.190,
+        0.200,
+        0.220,
+        0.240,
+        0.250,
+        0.260,
+        0.280,
+        0.290,
+        0.300,
+        0.320,
+        0.340,
+        0.350,
+        0.360,
+        0.380,
+        0.400,
+        0.420,
+        0.440,
+        0.450,
+        0.460,
+        0.480,
+        0.500,
+        0.550,
+        0.600,
+        0.650,
+        0.667,
+        0.700,
+        0.750,
+        0.800,
+        0.850,
+        0.900,
+        0.950,
+        1.000,
+        1.100,
+        1.200,
+        1.300,
+        1.400,
+        1.500,
+        1.600,
+        1.700,
+        1.800,
+        1.900,
+        2.000,
+        2.200,
+        2.400,
+        2.500,
+        2.600,
+        2.800,
+        3.000,
+        3.200,
+        3.400,
+        3.500,
+        3.600,
+        3.800,
+        4.000,
+        4.200,
+        4.400,
+        4.600,
+        4.800,
+        5.000,
+        5.500,
+        6.000,
+        6.500,
+        7.000,
+        7.500,
+        8.000,
+        8.500,
+        9.000,
+        9.500,
+        10.000,
+        11.000,
+        12.000,
+        13.000,
+        14.000,
+        15.000,
+        20.000,
+    ]
+)
+DEFAULT_FREQUENCIES = np.logspace(
+    np.log10(0.01318257),
+    np.log10(100),
+    num=389,
+)
+
+
+def calculate_ims(
+    waveform: np.ndarray,
+    dt: float,
+    ims_list: list[IM] = list(IM),
+    periods: np.ndarray = DEFAULT_PERIODS,
+    frequencies: np.ndarray = DEFAULT_FREQUENCIES,
+    cores: int = multiprocessing.cpu_count(),
+    ko_directory: Path | None = None,
+    use_numexpr: bool = False,
+):
+    """
+    Calculate intensity measures for a single waveform.
+
+    Parameters
+    ----------
+    waveform : np.ndarray
+        Waveform data as a NumPy array.
+    dt : float
+        Sampling interval (dt) of the waveform.
+    ims_list : list of IM, optional
+        List of intensity measures (IMs) to calculate, e.g., [IM.PGA, IM.pSA, IM.CAV].
+    periods : np.ndarray, optional
+        List of periods required for calculating the pseudo-spectral acceleration (pSA).
+    frequencies : np.ndarray, optional
+        List of frequencies required for calculating the Fourier amplitude spectrum (FAS).
+    cores : int, optional
+        Number of cores to use for parallel processing in pSA and FAS calculations.
+    ko_directory : Path, optional
+        Path to the directory containing the Konno-Ohmachi matrices.
+        Only required if FAS is in the list of IMs.
+    use_numexpr : bool, optional
+        If True, use numexpr for calculations. (Faster off for single waveform and multiprocessing)
+        Default is False.
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame containing the calculated intensity measures.
+        The columns are the IMs and the rows are the different components.
+
+    Raises
+    ------
+    ValueError
+        If the IM is not recognized or if required environment variables are not set to 1.
+    """
+    if cores == 1:
+        required_env_vars = [
+            "NUMEXPR_NUM_THREADS",
+            "NUMBA_MAX_THREADS",
+            "NUMBA_NUM_THREADS",
+            "OPENBLAS_NUM_THREADS",
+        ]
+        unset_vars = [var for var in required_env_vars if os.getenv(var) != "1"]
+        if unset_vars:
+            raise ValueError(
+                f"The following environment variables must be set to 1: {', '.join(unset_vars)}"
+            )
+    if ko_directory is None and IM.FAS in ims_list:
+        raise ValueError(
+            "The Konno-Ohmachi directory must be provided if Fourier amplitude spectrum is in the list of IMs."
+        )
+
+    results = []
+
+    # Iterate through IMs and calculate them
+    for im in ims_list:
+        if im == IM.PGA:
+            result = ims.peak_ground_acceleration(waveform, use_numexpr=use_numexpr)
+            result.index = [im.value]
+        elif im == IM.PGV:
+            result = ims.peak_ground_velocity(waveform, dt, use_numexpr=use_numexpr)
+            result.index = [im.value]
+        elif im == IM.pSA:
+            data_array = ims.pseudo_spectral_acceleration(
+                waveform, periods, np.float32(dt), cores=cores, use_numexpr=use_numexpr
+            )
+            # Convert the data array to a DataFrame
+            result = data_array.to_dataframe().unstack(level="component")
+            result.index = [
+                f"{im.value}_{idx}" for idx in data_array.coords["period"].values
+            ]
+            result.columns = result.columns.droplevel(0)
+        elif im == IM.CAV:
+            result = ims.cumulative_absolute_velocity(waveform, dt)
+            result.index = [im.value]
+        elif im == IM.CAV5:
+            result = ims.cumulative_absolute_velocity(waveform, dt, 5)
+            result.index = [im.value]
+        elif im == IM.Ds575:
+            result = ims.ds575(waveform, dt, use_numexpr=use_numexpr)
+            result.index = [im.value]
+        elif im == IM.Ds595:
+            result = ims.ds595(waveform, dt, use_numexpr=use_numexpr)
+            result.index = [im.value]
+        elif im == IM.AI:
+            result = ims.arias_intensity(waveform, dt)
+            result.index = [im.value]
+        elif im == IM.FAS:
+            assert ko_directory
+            data_array = ims.fourier_amplitude_spectra(
+                waveform,
+                dt,
+                frequencies,
+                cores=cores,
+                # ko_directory must be Path because of the check earlier.
+                ko_directory=ko_directory,
+            )
+            # Convert the data array to a DataFrame
+            result = data_array.to_dataframe().unstack(level="component")
+            result.index = [
+                f"{im.value}_{idx}" for idx in data_array.coords["frequency"].values
+            ]
+            result.columns = result.columns.droplevel(0)
+        else:
+            raise ValueError(
+                f"IM {im} not recognized. Available IMs are {IM.__members__.keys()}"
+            )
+        results.append(result)
+
+    # Combine all results into a single DataFrame
+    output_ims = pd.concat(results).T
+    return output_ims

im_calculation-0.0.0/IM/im_reader.py

@@ -0,0 +1,100 @@
+from pathlib import Path
+
+# Importing pint_xarray registers pint units with xarray, allowing for
+# unit-aware operations. It is not explicitly used, so we ignore the flake8
+# F401 error.
+import pint_xarray  # noqa: F401
+import xarray as xr
+
+from IM.ims import IM
+
+
+def read_intensity_measures(
+    intensity_measure_file: str | Path,
+) -> xr.Dataset:
+    """
+    Read intensity measures from a file and return as an xarray Dataset.
+
+    Parameters
+    ----------
+    intensity_measure_file : str or Path
+        The file path or filename of the intensity measures dataset to be read.
+
+    Returns
+    -------
+    xr.Dataset
+        The xarray dataset containing the intensity measures."""
+    return xr.open_dataset(intensity_measure_file, engine="h5netcdf").pint.quantify()
+
+
+COORDINATE_METADATA = {
+    "station": {"description": "Station identifiers", "units": None},
+    "component": {"description": "Component of motion", "units": None},
+    "period": {"description": "Oscillation period", "units": "s"},
+    "vs30": {
+        "description": "Average shear-wave velocity to 30m depth",
+        "units": "m/s",
+    },
+    "epi": {"description": "Epicentral distance", "units": "km"},
+    "hyp": {"description": "Hypocentral distance", "units": "km"},
+    "rrup": {"description": "Rupture distance", "units": "km"},
+    "rjb": {"description": "Joyner-Boore distance", "units": "km"},
+    "latitude": {"description": "Station latitude", "units": "degrees"},
+    "longitude": {"description": "Station longitude", "units": "degrees"},
+    "frequency": {"description": "Frequency of motion", "units": "Hz"},
+}
+
+IM_METADATA = {
+    IM.PGA: "Peak ground acceleration",
+    IM.PGV: "Peak ground velocity",
+    IM.CAV: "Cumulative absolute velocity",
+    IM.CAV5: "Cumulative absolute velocity (above 5 cm/s)",
+    IM.AI: "Arias intensity",
+    IM.Ds575: "Significant duration (5-75%)",
+    IM.Ds595: "Significant duration (5-95%)",
+    IM.pSA: "Pseudo-spectral acceleration",
+    IM.FAS: "Fourier amplitude spectrum",
+}
+
+
+# The 'g0' unit is used for acceleration and is equivalent to 9.81 m/s^2. The
+# reason for this is that 'g' is reserved for 'grams'. This is a decision
+# made by the `pint` library, which is used to handle the units.
+IM_UNITS = {
+    IM.PGA: "g0",
+    IM.PGV: "cm/s",
+    IM.CAV: "m/s",
+    IM.CAV5: "m/s",
+    IM.AI: "m/s",
+    IM.Ds575: "s",
+    IM.Ds595: "s",
+    IM.FAS: "g0 * s",
+    IM.pSA: "g0",
+    "frequency": "Hz",
+    "period": "s",
+}
+
+
+def write_intensity_measures(dataset: xr.Dataset, output_ffp: str | Path) -> None:
+    """Write intensity measures to a file, updating coordinate and variable metadata.
+
+    Parameters
+    ----------
+    dataset : xr.Dataset
+        The xarray dataset containing intensity measures to be written.
+    output_ffp : str or Path
+        The file path where the output dataset should be saved.
+    """
+    for name, description in COORDINATE_METADATA.items():
+        if name not in dataset.coords:
+            continue
+        dataset.coords[name].attrs.update(COORDINATE_METADATA[name])
+
+    for im_name, description in IM_METADATA.items():
+        if im_name not in dataset:
+            continue
+        dataset[im_name].attrs["description"] = IM_METADATA[im_name]
+
+    dataset = dataset.pint.quantify(IM_UNITS)
+
+    dataset.pint.dequantify().to_netcdf(output_ffp, engine="h5netcdf")