backscattering_simulation_data 1.0.1__py3-none-any.whl

backscattering_simulation_data/metadata/simulation.py

@@ -0,0 +1,68 @@
+from h5py import File, Group
+
+from .map import Map
+from .metadata import Metadata
+from .modelmodifier import ModelModifier
+
+
+class Simulation(Metadata):
+    """Information about the simulation state"""
+
+    def __init__(
+        self,
+        maps: list[Map],
+        model_modifiers: list[ModelModifier],
+    ) -> None:
+        """Parameters
+        ----------
+        maps: list[Map]
+            List of simulated maps associated to mirrors in the
+            simulation
+
+        """
+        self.maps = maps
+        self.model_modifiers = model_modifiers
+
+    @staticmethod
+    def from_hdf5(store: File | Group) -> "Simulation":
+        maps_group = store.get("maps")
+        model_modifiers_group = store.get("model modifiers")
+        if not isinstance(maps_group, Group):
+            message = (
+                "Maps information should be stored in a group, not "
+                f"{type(maps_group)}"
+            )
+            raise ValueError(message)
+        if not isinstance(model_modifiers_group, Group):
+            message = (
+                "Model modifiers must be stored in a group, not "
+                f"{type(model_modifiers_group)}"
+            )
+            raise ValueError(message)
+
+        maps = maps_group.values()
+        model_modifiers = model_modifiers_group.values()
+
+        return Simulation(
+            maps=[Map.from_hdf5(map_) for map_ in maps],
+            model_modifiers=[
+                ModelModifier.from_hdf5(model_modifier)
+                for model_modifier in model_modifiers
+            ],
+        )
+
+    def to_hdf5(self, store: File | Group) -> File | Group:
+        _ = store.create_group("maps")
+        _ = store.create_group("model modifiers")
+        for map_ in self.maps:
+            _ = map_.to_hdf5(
+                store.require_group("maps").create_group(map_.mirror),
+            )
+        for i in range(len(self.model_modifiers)):
+            model_modifier = self.model_modifiers[i]
+            _ = model_modifier.to_hdf5(
+                store.require_group("model modifiers").create_group(
+                    str(i),
+                ),
+            )
+        return store

backscattering_simulation_data/metadata/simulation.pyi

@@ -0,0 +1,17 @@
+from _typeshed import Incomplete
+from h5py import File as File
+from h5py import Group
+
+from .map import Map as Map
+from .metadata import Metadata as Metadata
+from .modelmodifier import ModelModifier as ModelModifier
+
+class Simulation(Metadata):
+    maps: Incomplete
+    model_modifiers: Incomplete
+    def __init__(
+        self, maps: list[Map], model_modifiers: list[ModelModifier]
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: File | Group) -> Simulation: ...
+    def to_hdf5(self, store: File | Group) -> File | Group: ...

backscattering_simulation_data/powermeasurement.py

@@ -0,0 +1,47 @@
+from astropy.table import QTable
+from h5py import File, Group
+
+from .metadata import MetadataPowerMeasurement as Metadata
+from .section import Section
+
+
+class PowerMeasurement(Section):
+    """A power measurement in a specific place in the simulated
+    interferometer
+    """
+
+    def __init__(
+        self,
+        metadata: Metadata,
+        modes: QTable,
+    ) -> None:
+        """Paremeters
+        ----------
+        metadata : Metadata
+            Information about this power measurement
+        modes : QTable
+            Power on the different modes (can be 1D if only TEM00)
+        """
+        self.metadata = metadata
+        self.modes = modes
+
+    @staticmethod
+    def from_hdf5(store: Group | File) -> "PowerMeasurement":
+        return PowerMeasurement(
+            metadata=Metadata.from_hdf5(store),
+            modes=QTable.read(
+                store,
+                format="hdf5",
+                path="modes",
+            ),
+        )
+
+    def to_hdf5(self, store: File | Group) -> Group | File:
+        _ = self.metadata.to_hdf5(store)
+        self.modes.write(
+            store,
+            format="hdf5",
+            path="modes",
+            serialize_meta=True,
+        )
+        return store

backscattering_simulation_data/powermeasurement.pyi

@@ -0,0 +1,15 @@
+from _typeshed import Incomplete
+from astropy.table import QTable
+from h5py import File as File
+from h5py import Group as Group
+
+from .metadata import MetadataPowerMeasurement as Metadata
+from .section import Section as Section
+
+class PowerMeasurement(Section):
+    metadata: Incomplete
+    modes: Incomplete
+    def __init__(self, metadata: Metadata, modes: QTable) -> None: ...
+    @staticmethod
+    def from_hdf5(store: Group | File) -> PowerMeasurement: ...
+    def to_hdf5(self, store: File | Group) -> Group | File: ...

backscattering_simulation_data/root.py

@@ -0,0 +1,146 @@
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from gwpy.frequencyseries import FrequencySeries
+from h5py import Dataset, File, Group
+from numpy import array, mean
+from scipy.io.matlab import savemat
+
+from .metadata.root import Root as Metadata
+from .powermeasurement import PowerMeasurement
+from .scatterer import Scatterer
+from .section import Section
+from .utils import (
+    dataset_to_frequencyseries,
+    frequencyseries_to_dataset,
+)
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+
+class Root(Section):
+    """Simulation data identified with an unique name, with information
+    about the code that generated it
+    """
+
+    def __init__(
+        self,
+        metadata: Metadata,
+        scatterers: list[Scatterer],
+        power_measurements: list[PowerMeasurement],
+        darm: FrequencySeries,
+    ) -> None:
+        """Parameters
+        ----------
+        metadata : Metadata
+            Metadata associated to this data package
+        scatterers: list[Scatterer]
+            Scatterers data list
+        darm : FrequencySeries
+            common DARM transfer function for all this simulation data
+
+        """
+        self.metadata = metadata
+        self.scatterers = scatterers
+        self.power_measurements = power_measurements
+        self.darm = darm
+
+    @staticmethod
+    def from_hdf5(store: File | Group) -> "Root":
+        scatterers_group = store.get("scatterers")
+        darm_dataset = store.get("DARM")
+        message = "{} should exists, and not be {}"
+        if not isinstance(scatterers_group, Group):
+            raise TypeError(
+                message.format(
+                    "scatterers group",
+                    type(scatterers_group),
+                ),
+            )
+        if not isinstance(darm_dataset, Dataset):
+            raise ValueError(
+                message.format("DARM dataset", type(darm_dataset)),
+            )
+        scatterers = scatterers_group.values()
+
+        try:
+            power_measurements_group = store["power measurements"]
+            if not isinstance(power_measurements_group, Group):
+                raise TypeError(
+                    message.format(
+                        "power measurements",
+                        type(power_measurements_group),
+                    ),
+                )
+            power_measurements_values = (
+                power_measurements_group.values()
+            )
+            power_measurements = [
+                PowerMeasurement.from_hdf5(power_measurement)
+                for power_measurement in power_measurements_values
+            ]
+        except KeyError:
+            # Legcay support, power measurements is not defined for file
+            # generated before 0.3.0
+            power_measurements = []
+
+        return Root(
+            metadata=Metadata.from_hdf5(store),
+            scatterers=[
+                Scatterer.from_hdf5(scatterer)
+                for scatterer in scatterers
+            ],
+            power_measurements=power_measurements,
+            darm=dataset_to_frequencyseries(darm_dataset),
+        )
+
+    def to_hdf5(self, store: File | Group) -> File | Group:
+        _ = self.metadata.to_hdf5(store)
+        _ = store.create_group(
+            "scatterers",
+        )  # create the group even if scatterers list is empty
+        _ = store.create_group("power measurements")
+        for scatterer in self.scatterers:
+            _ = scatterer.to_hdf5(
+                store.require_group("scatterers").create_group(
+                    scatterer.metadata.name,
+                ),
+            )
+        for power_measurement in self.power_measurements:
+            _ = power_measurement.to_hdf5(
+                store.require_group("power measurements").create_group(
+                    power_measurement.metadata.name,
+                ),
+            )
+        _ = frequencyseries_to_dataset(store, "DARM", self.darm)
+        return store
+
+    def to_matlab(self, path: Path) -> None:
+        if len(self.scatterers) < 1:
+            raise ValueError("no scatterer to save")
+        data: dict[str, NDArray] = {}
+        for scatterer in self.scatterers:
+            data[f"{scatterer.metadata.name}mat"] = array(
+                [tf.to_value() for tf in [scatterer.kn, scatterer.kp]],
+            )
+            north_arm = self.metadata.interferometer.north_arm.to_value(
+                "m",
+            )
+            west_arm = self.metadata.interferometer.west_arm.to_value(
+                "m",
+            )
+            if not isinstance(north_arm, float):
+                raise TypeError
+            if not isinstance(west_arm, float):
+                raise TypeError
+            arm_length = mean([north_arm, west_arm])
+            data[f"{scatterer.metadata.name}coupling"] = array(
+                [
+                    tf.to_value() / self.darm.to_value() / arm_length
+                    for tf in [scatterer.kn, scatterer.kp]
+                ],
+            )
+        data["freq"] = self.scatterers[0].kn.frequencies
+
+        savemat(str(path), data)

backscattering_simulation_data/root.pyi

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+from _typeshed import Incomplete
+from gwpy.frequencyseries import FrequencySeries as FrequencySeries
+from h5py import File as File
+from h5py import Group
+from numpy.typing import NDArray as NDArray
+
+from .metadata.root import Root as Metadata
+from .powermeasurement import PowerMeasurement as PowerMeasurement
+from .scatterer import Scatterer as Scatterer
+from .section import Section as Section
+from .utils import (
+    dataset_to_frequencyseries as dataset_to_frequencyseries,
+)
+from .utils import (
+    frequencyseries_to_dataset as frequencyseries_to_dataset,
+)
+
+class Root(Section):
+    metadata: Incomplete
+    scatterers: Incomplete
+    power_measurements: Incomplete
+    darm: Incomplete
+    def __init__(
+        self,
+        metadata: Metadata,
+        scatterers: list[Scatterer],
+        power_measurements: list[PowerMeasurement],
+        darm: FrequencySeries,
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: File | Group) -> Root: ...
+    def to_hdf5(self, store: File | Group) -> File | Group: ...
+    def to_matlab(self, path: Path) -> None: ...

backscattering_simulation_data/scatterer.py

@@ -0,0 +1,61 @@
+from gwpy.frequencyseries import FrequencySeries
+from h5py import Dataset, File, Group
+
+from .metadata.scatterer import Scatterer as MetadataScatterer
+from .section import Section
+from .utils import (
+    dataset_to_frequencyseries,
+    frequencyseries_to_dataset,
+)
+
+
+class Scatterer(Section):
+    """Contains Transfer Function between a scatterer and the DC dark
+    fringe power
+    """
+
+    def __init__(
+        self,
+        metadata: MetadataScatterer,
+        kn: FrequencySeries,
+        kp: FrequencySeries,
+    ) -> None:
+        """Parameters
+        ----------
+        metadata : MetadataScatterer
+            Metadata associated to this scatterer
+        kn : FrequencySeries
+            Kp transfer function (scatterer is located so that the
+            reflected light is out of phase with the recoupled beam)
+        kp : FrequencySeries
+            Kn transfer function (scatterer is located so that the
+            reflected light is in phase with the recoupled beam)
+
+        """
+        self.metadata = metadata
+        self.kn = kn
+        self.kp = kp
+
+    @staticmethod
+    def from_hdf5(store: File | Group) -> "Scatterer":
+        kn_dataset = store.get("kn")
+        kp_dataset = store.get("kp")
+        if not isinstance(kn_dataset, Dataset):
+            raise ValueError(
+                f"kn should exists, and not be {type(kn_dataset)}",
+            )
+        if not isinstance(kp_dataset, Dataset):
+            raise ValueError(
+                f"kp should exists, and not be {type(kp_dataset)}",
+            )
+        return Scatterer(
+            metadata=MetadataScatterer.from_hdf5(store),
+            kn=dataset_to_frequencyseries(kn_dataset),
+            kp=dataset_to_frequencyseries(kp_dataset),
+        )
+
+    def to_hdf5(self, store: File | Group) -> Group | File:
+        _ = self.metadata.to_hdf5(store)
+        _ = frequencyseries_to_dataset(store, "kn", self.kn)
+        _ = frequencyseries_to_dataset(store, "kp", self.kp)
+        return store

backscattering_simulation_data/scatterer.pyi

@@ -0,0 +1,27 @@
+from _typeshed import Incomplete
+from gwpy.frequencyseries import FrequencySeries as FrequencySeries
+from h5py import File as File
+from h5py import Group as Group
+
+from .metadata.scatterer import Scatterer as MetadataScatterer
+from .section import Section as Section
+from .utils import (
+    dataset_to_frequencyseries as dataset_to_frequencyseries,
+)
+from .utils import (
+    frequencyseries_to_dataset as frequencyseries_to_dataset,
+)
+
+class Scatterer(Section):
+    metadata: Incomplete
+    kn: Incomplete
+    kp: Incomplete
+    def __init__(
+        self,
+        metadata: MetadataScatterer,
+        kn: FrequencySeries,
+        kp: FrequencySeries,
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: File | Group) -> Scatterer: ...
+    def to_hdf5(self, store: File | Group) -> Group | File: ...

backscattering_simulation_data/section.py

@@ -0,0 +1,105 @@
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from h5py import File, Group
+
+if TYPE_CHECKING:
+    from astropy.table import QTable
+    from astropy.units import Quantity
+    from gwpy.frequencyseries import FrequencySeries
+
+
+class Section:
+    """Any class that represent a set of data."""
+
+    def get(
+        self,
+        attribute: str,
+    ) -> "Section | FrequencySeries | QTable | Quantity | int":
+        """Get an attribute of this section
+
+        Parameters
+        ----------
+        attribute : str
+            Attribute to get
+
+        Returns
+        -------
+        Any : The value of the given attribute
+
+        """
+        return getattr(self, attribute)
+
+    def set(
+        self,
+        attribute: str,
+        value: "Section | FrequencySeries | QTable | Quantity | int",
+    ) -> None:
+        """Set an attribute of this section
+
+        Parameters
+        ----------
+        attribute : str
+            Attribute to set
+        value : Any
+            Value to set
+
+        """
+        return setattr(self, attribute, value)
+
+    @staticmethod
+    def from_hdf5(store: File | Group) -> "Section":  # pyright: ignore [reportUnusedParameter]
+        """Convert an hdf5 file or group to the corresponding section
+
+        Parameters
+        ----------
+        store : File | Group
+            Group corresponding to a given section
+
+        Returns
+        -------
+        An instance of a subclass of Section
+
+        """
+        raise NotImplementedError(
+            "this method has not been implemented for this class",
+        )
+
+    @staticmethod
+    def from_folder(folder: Path) -> "Section":  # pyright: ignore [reportUnusedParameter]
+        """Convert a folder to the corresponding section
+
+        Parameters
+        ----------
+        folder : Path
+            Folder containing all the data
+
+        Returns
+        -------
+        An instance of a subclass of Section
+
+        """
+        raise NotImplementedError(
+            "this method has not been implemented for this class",
+        )
+
+    def to_hdf5(self, store: File | Group) -> Group | File:  # pyright: ignore [reportUnusedParameter]
+        """Convert this set of data to a HDF5 group
+
+        Parameters
+        ----------
+        store : File | Group
+            Where to insert this group
+
+        Notes
+        -----
+        It recursively create sub groups
+
+        Returns
+        -------
+        Group : new created group
+
+        """
+        raise NotImplementedError(
+            "this method has not been implemented for this class",
+        )

backscattering_simulation_data/section.pyi

@@ -0,0 +1,22 @@
+from pathlib import Path
+
+from astropy.table import QTable as QTable
+from astropy.units import Quantity as Quantity
+from gwpy.frequencyseries import FrequencySeries as FrequencySeries
+from h5py import File as File
+from h5py import Group as Group
+
+class Section:
+    def get(
+        self, attribute: str
+    ) -> Section | FrequencySeries | QTable | Quantity | int: ...
+    def set(
+        self,
+        attribute: str,
+        value: Section | FrequencySeries | QTable | Quantity | int,
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: File | Group) -> Section: ...
+    @staticmethod
+    def from_folder(folder: Path) -> Section: ...
+    def to_hdf5(self, store: File | Group) -> Group | File: ...

backscattering_simulation_data/utils.py

@@ -0,0 +1,90 @@
+from astropy.units import Quantity, Unit
+from gwpy.frequencyseries import FrequencySeries
+from h5py import Dataset, File, Group
+from numpy import array
+
+
+def dataset_to_frequencyseries(dataset: Dataset) -> FrequencySeries:
+    """
+    Convert a h5df dataset to a FrequencySeries keeping the units right
+
+    Parameters
+    ----------
+    dataset : Dataset
+        Dataset to convert
+
+    Returns
+    -------
+    TimeSeries : TimeSeries with a good unit
+
+    """
+    unit = None
+    if "units" in dataset.attrs:
+        units = dataset.attrs["units"]
+        if isinstance(units, str):
+            unit = Unit(units)
+        else:
+            raise ValueError(f"cannot convert {units} to a unit")
+    if "f0" not in dataset.attrs:
+        raise ValueError(
+            "no starting time defined for this frequencyseries",
+        )
+    if "df" not in dataset.attrs:
+        message = (
+            "no time sample separation defined for the",
+            "frequencyseries",
+        )
+        raise ValueError(message)
+    f0 = dataset.attrs["f0"]
+    df = dataset.attrs["df"]
+    if not isinstance(f0, str):
+        raise ValueError(f"f0 must be stored as string, not {type(f0)}")
+    if not isinstance(df, str):
+        raise ValueError(f"df must be stored as string, not {type(df)}")
+    f0 = Quantity(f0)
+    df = Quantity(df)
+    return FrequencySeries(
+        data=array(dataset),
+        unit=unit,
+        f0=f0,
+        df=df,
+    )
+
+
+def frequencyseries_to_dataset(
+    store: File | Group,
+    name: str,
+    frequencyseries: FrequencySeries,
+) -> Dataset:
+    """
+    Convert a gwpy FrequencySeries to a hdf5 dataset keeping the units
+    right
+
+    Parameters
+    ----------
+    store : File | Group
+        hdf5 element which will store the Dataset
+    name : str
+        Name of the dataset in the store
+    timeseries : TimeSeries
+        Data to store in the Dataset
+
+    Returns
+    -------
+    Dataset : Created dataset
+
+    """
+    dataset = store.create_dataset(name, data=frequencyseries.data)
+    if frequencyseries.unit is not None:
+        dataset.attrs["units"] = frequencyseries.unit.to_string()
+    if not isinstance(frequencyseries.f0, Quantity):
+        raise ValueError(
+            f"f0 must be a quantity, not {type(frequencyseries.f0)}",
+        )
+    if not isinstance(frequencyseries.df, Quantity):
+        raise ValueError(
+            f"f0 must be a quantity, not {type(frequencyseries.df)}",
+        )
+    dataset.attrs["f0"] = frequencyseries.f0.to_string()
+    dataset.attrs["df"] = frequencyseries.df.to_string()
+    return dataset

backscattering_simulation_data/utils.pyi

@@ -0,0 +1,9 @@
+from gwpy.frequencyseries import FrequencySeries
+from h5py import Dataset as Dataset
+from h5py import File as File
+from h5py import Group as Group
+
+def dataset_to_frequencyseries(dataset: Dataset) -> FrequencySeries: ...
+def frequencyseries_to_dataset(
+    store: File | Group, name: str, frequencyseries: FrequencySeries
+) -> Dataset: ...