backscattering_simulation_data 1.0.1__py3-none-any.whl

backscattering_simulation_data/__init__.py

@@ -0,0 +1,17 @@
+from .metadata import metadata
+from .powermeasurement import PowerMeasurement
+from .root import Root
+from .scatterer import Scatterer
+from .utils import (
+    dataset_to_frequencyseries,
+    frequencyseries_to_dataset,
+)
+
+__all__ = [
+    "PowerMeasurement",
+    "Root",
+    "Scatterer",
+    "dataset_to_frequencyseries",
+    "frequencyseries_to_dataset",
+    "metadata",
+]

backscattering_simulation_data/__init__.pyi

@@ -0,0 +1,19 @@
+from .metadata import metadata as metadata
+from .powermeasurement import PowerMeasurement as PowerMeasurement
+from .root import Root as Root
+from .scatterer import Scatterer as Scatterer
+from .utils import (
+    dataset_to_frequencyseries as dataset_to_frequencyseries,
+)
+from .utils import (
+    frequencyseries_to_dataset as frequencyseries_to_dataset,
+)
+
+__all__ = [
+    "PowerMeasurement",
+    "Root",
+    "Scatterer",
+    "dataset_to_frequencyseries",
+    "frequencyseries_to_dataset",
+    "metadata",
+]

backscattering_simulation_data/metadata/__init__.py

@@ -0,0 +1,24 @@
+from .git import Git
+from .interferometer import Interferometer
+from .map import Map, MapType
+from .modelmodifier import ModelModifier
+from .pointabsorber import PointAbsorber
+from .powermeasurement import (
+    PowerMeasurement as MetadataPowerMeasurement,
+)
+from .root import Root as MetadataRoot
+from .scatterer import Scatterer as MetadataScatterer
+from .simulation import Simulation
+
+__all__ = [
+    "Git",
+    "Interferometer",
+    "Map",
+    "MapType",
+    "MetadataPowerMeasurement",
+    "MetadataRoot",
+    "MetadataScatterer",
+    "ModelModifier",
+    "PointAbsorber",
+    "Simulation",
+]

backscattering_simulation_data/metadata/__init__.pyi

@@ -0,0 +1,25 @@
+from .git import Git as Git
+from .interferometer import Interferometer as Interferometer
+from .map import Map as Map
+from .map import MapType as MapType
+from .modelmodifier import ModelModifier as ModelModifier
+from .pointabsorber import PointAbsorber as PointAbsorber
+from .powermeasurement import (
+    PowerMeasurement as MetadataPowerMeasurement,
+)
+from .root import Root as MetadataRoot
+from .scatterer import Scatterer as MetadataScatterer
+from .simulation import Simulation as Simulation
+
+__all__ = [
+    "Git",
+    "Interferometer",
+    "Map",
+    "MapType",
+    "MetadataPowerMeasurement",
+    "MetadataRoot",
+    "MetadataScatterer",
+    "ModelModifier",
+    "PointAbsorber",
+    "Simulation",
+]

backscattering_simulation_data/metadata/elementtype.py

@@ -0,0 +1,6 @@
+from enum import StrEnum
+
+
+class ElementType(StrEnum):
+    MIRROR = "mirror"
+    LENS = "lens"

backscattering_simulation_data/metadata/elementtype.pyi

@@ -0,0 +1,5 @@
+from enum import StrEnum
+
+class ElementType(StrEnum):
+    MIRROR = "mirror"
+    LENS = "lens"

backscattering_simulation_data/metadata/git.py

@@ -0,0 +1,77 @@
+from urllib.parse import ParseResult, urlparse
+
+from h5py import File, Group
+
+from .metadata import Metadata
+
+
+class Git(Metadata):
+    """
+    Information about the git repo of the algorithm which generated the
+    simulation data
+    """
+
+    def __init__(
+        self,
+        remote: ParseResult,
+        commit: str,
+        version: str,
+        branch: str,
+    ) -> None:
+        """Parameters
+        ----------
+        remote :  ParseResult
+            Repo location, must be the remote URI
+        commit : str
+            Latest commit hash when the simulation was computed
+        version : str
+            Version of the script which generated the simulation data
+        branch : str
+            Name of the branch of the git repo
+
+        """
+        self.remote = remote
+        self.commit = commit
+        self.version = version
+        self.branch = branch
+
+    @staticmethod
+    def from_hdf5(store: File | Group) -> "Git":
+        for attribute in [
+            "remote",
+            "commit",
+            "version",
+            "branch",
+        ]:
+            if attribute not in store.attrs:
+                raise ValueError("no {} in git information")
+        remote = store.attrs["remote"]
+        commit = store.attrs["commit"]
+        version = store.attrs["version"]
+        branch = store.attrs["branch"]
+
+        message = "git {} should be a string, not {}"
+        if not isinstance(remote, str):
+            raise ValueError(message.format("remote", type(remote)))
+        if not isinstance(commit, str):
+            raise ValueError(message.format("commit", type(commit)))
+        if not isinstance(version, str):
+            raise ValueError(message.format("version", type(version)))
+        if not isinstance(branch, str):
+            raise ValueError(message.format("branch", type(branch)))
+
+        remote = urlparse(remote)
+
+        return Git(
+            remote=remote,
+            commit=commit,
+            version=version,
+            branch=branch,
+        )
+
+    def to_hdf5(self, store: File | Group) -> File | Group:
+        store.attrs["remote"] = self.remote.geturl()
+        store.attrs["commit"] = self.commit
+        store.attrs["version"] = self.version
+        store.attrs["branch"] = self.branch
+        return store

backscattering_simulation_data/metadata/git.pyi

@@ -0,0 +1,23 @@
+from urllib.parse import ParseResult as ParseResult
+
+from _typeshed import Incomplete
+from h5py import File as File
+from h5py import Group as Group
+
+from .metadata import Metadata as Metadata
+
+class Git(Metadata):
+    remote: Incomplete
+    commit: Incomplete
+    version: Incomplete
+    branch: Incomplete
+    def __init__(
+        self,
+        remote: ParseResult,
+        commit: str,
+        version: str,
+        branch: str,
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: File | Group) -> Git: ...
+    def to_hdf5(self, store: File | Group) -> File | Group: ...

backscattering_simulation_data/metadata/interferometer.py

@@ -0,0 +1,135 @@
+from astropy.units import Quantity
+from astropy.units.physical import angle, length, power
+from h5py import File, Group
+
+from .metadata import Metadata
+
+
+class Interferometer(Metadata):
+    """Information about the interferometer state"""
+
+    def __init__(
+        self,
+        dark_fringe_power: Quantity[power],
+        injection_power: Quantity[power],
+        sr_yaw: Quantity[angle],
+        north_arm: Quantity[length],
+        west_arm: Quantity[length],
+    ) -> None:
+        """Parameters
+        ----------
+        dark_fringe_power : Quantity[power]
+            Power on dark fringe (dark fringe offset)
+        injection_power : Quantity[power]
+            Power injected in the interferometer
+        sr_yaw : Quantity[angle]
+            Yaw angle of SR
+        north_arm : Quantity[length]
+            Length of the north arm
+        west_arm : Quantity[length]
+            Length of the west arm
+
+        """
+        if (
+            dark_fringe_power.unit is None
+            or injection_power.unit is None
+            or sr_yaw.unit is None
+            or north_arm.unit is None
+            or west_arm.unit is None
+        ):
+            raise TypeError("every quantities must have an unit")
+        if (
+            dark_fringe_power.unit.physical_type != "power"
+            or injection_power.unit.physical_type != "power"
+        ):
+            raise TypeError("dark fringe and injection must be power")
+        if sr_yaw.unit.physical_type != "angle":
+            raise TypeError("sr yaw must be an angle")
+        if (
+            north_arm.unit.physical_type != "length"
+            or west_arm.unit.physical_type != "length"
+        ):
+            raise TypeError("north arm and west arm must be length")
+        if dark_fringe_power < Quantity(0, "W"):
+            raise ValueError("dark fringe power must be positive")
+        if injection_power < Quantity(0, "W"):
+            raise ValueError("injection power must be positive")
+        if north_arm < Quantity(0, "m"):
+            raise ValueError("north arm length must be positive")
+        if west_arm < Quantity(0, "m"):
+            raise ValueError("west arm length must be positive")
+
+        self.dark_fringe_power = dark_fringe_power
+        self.injection_power = injection_power
+        self.sr_yaw = sr_yaw
+        self.north_arm = north_arm
+        self.west_arm = west_arm
+
+    @staticmethod
+    def from_hdf5(store: File | Group) -> "Interferometer":
+        for attribute in [
+            "dark fringe power",
+            "injection power",
+            "SR yaw",
+            "north arm",
+            "west arm",
+        ]:
+            if attribute not in store.attrs:
+                raise ValueError(
+                    f"no {attribute} in interferometer information",
+                )
+        dark_fringe_power = store.attrs["dark fringe power"]
+        injection_power = store.attrs["injection power"]
+        sr_yaw = store.attrs["SR yaw"]
+        north_arm = store.attrs["north arm"]
+        west_arm = store.attrs["west arm"]
+
+        message = "interferometer {} should be a string, not {}"
+        if not isinstance(dark_fringe_power, str):
+            raise ValueError(
+                message.format(
+                    "dark fringe power",
+                    type(dark_fringe_power),
+                ),
+            )
+        if not isinstance(injection_power, str):
+            raise ValueError(
+                message.format(
+                    "injection power",
+                    type(injection_power),
+                ),
+            )
+        if not isinstance(sr_yaw, str):
+            raise ValueError(message.format("SR yaw", type(sr_yaw)))
+        if not isinstance(north_arm, str):
+            raise ValueError(
+                message.format("north arm", type(north_arm)),
+            )
+        if not isinstance(west_arm, str):
+            raise ValueError(message.format("west arm", type(west_arm)))
+
+        dark_fringe_power = Quantity(dark_fringe_power)
+        injection_power = Quantity(injection_power)
+        sr_yaw = Quantity(sr_yaw)
+        north_arm = Quantity(north_arm)
+        west_arm = Quantity(west_arm)
+
+        return Interferometer(
+            dark_fringe_power=dark_fringe_power,
+            injection_power=injection_power,
+            sr_yaw=sr_yaw,
+            north_arm=north_arm,
+            west_arm=west_arm,
+        )
+
+    def to_hdf5(self, store: File | Group) -> File | Group:
+        store.attrs["dark fringe power"] = (
+            self.dark_fringe_power.to_string()
+        )
+        store.attrs["injection power"] = (
+            self.injection_power.to_string()
+        )
+        store.attrs["SR yaw"] = self.sr_yaw.to_string()
+        store.attrs["north arm"] = self.north_arm.to_string()
+        store.attrs["west arm"] = self.west_arm.to_string()
+        return store

backscattering_simulation_data/metadata/interferometer.pyi

@@ -0,0 +1,33 @@
+from _typeshed import Incomplete
+from astropy.units import Quantity
+from astropy.units.physical import (
+    angle as angle,
+)
+from astropy.units.physical import (
+    length as length,
+)
+from astropy.units.physical import (
+    power as power,
+)
+from h5py import File as File
+from h5py import Group as Group
+
+from .metadata import Metadata as Metadata
+
+class Interferometer(Metadata):
+    dark_fringe_power: Incomplete
+    injection_power: Incomplete
+    sr_yaw: Incomplete
+    north_arm: Incomplete
+    west_arm: Incomplete
+    def __init__(
+        self,
+        dark_fringe_power: Quantity[power],
+        injection_power: Quantity[power],
+        sr_yaw: Quantity[angle],
+        north_arm: Quantity[length],
+        west_arm: Quantity[length],
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: File | Group) -> Interferometer: ...
+    def to_hdf5(self, store: File | Group) -> File | Group: ...

backscattering_simulation_data/metadata/map.py

@@ -0,0 +1,127 @@
+from enum import StrEnum
+
+from astropy.units import Quantity
+from h5py import File, Group
+
+from .metadata import Metadata
+from .pointabsorber import PointAbsorber
+
+
+class MapType(StrEnum):
+    FREE = "free"
+    CIRCULAR = "circular"
+
+
+class Map(Metadata):
+    """Information about a map on a given mirror in the simulation"""
+
+    def __init__(
+        self,
+        mirror: str,
+        length: Quantity,
+        resolution: Quantity,
+        points_absorber: list[PointAbsorber],
+        type_: MapType,
+    ) -> None:
+        """Parameters
+        ----------
+        mirror: str
+            Name of the mirror associated to this map
+        length : Quantity[length]
+            Total length of eaqh side of the squared map
+        resolution : Quantity[length]
+            Distance between two pixel on the squared map
+        absorber_point : list[PointAbsorber]
+            List of point absorber considered in this simulation
+        map_type : MapType
+            Type of the amplitude map
+
+        """
+        if length.unit is None or resolution.unit is None:
+            raise TypeError("every quantities must have an unit")
+        if (
+            length.unit.physical_type != "length"
+            or resolution.unit.physical_type != "length"
+        ):
+            raise TypeError(
+                "length, resolution and roc offset must be length",
+            )
+        if length <= Quantity(0, "m"):
+            raise ValueError("length must be positive")
+        if resolution <= Quantity(0, "m"):
+            raise ValueError("resolution must be positive")
+        if length <= resolution:
+            raise ValueError("resolution must be lower than length")
+
+        self.mirror = mirror
+        self.length = length
+        self.resolution = resolution
+        self.points_absorber = points_absorber
+        self.type = type_
+
+    @staticmethod
+    def from_hdf5(store: File | Group) -> "Map":
+        for attribute in [
+            "mirror",
+            "length",
+            "resolution",
+            "type",
+        ]:
+            if attribute not in store.attrs:
+                raise ValueError(f"no {attribute} in map metadata")
+        mirror = store.attrs["mirror"]
+        length = store.attrs["length"]
+        resolution = store.attrs["resolution"]
+        map_type = store.attrs["type"]
+
+        message = "map {} should be a string, not {}"
+        if not isinstance(mirror, str):
+            raise TypeError(message.format("mirror", type(mirror)))
+        if not isinstance(length, str):
+            raise TypeError(message.format("length", type(length)))
+        if not isinstance(resolution, str):
+            raise TypeError(
+                message.format("resolution", type(resolution)),
+            )
+        if not isinstance(map_type, str):
+            raise TypeError(message.format("map type", type(map_type)))
+
+        length = Quantity(length)
+        resolution = Quantity(resolution)
+        map_type = MapType(map_type)
+
+        points_absorber_group = store.get("points absorber")
+        if not isinstance(points_absorber_group, Group):
+            message = (
+                "points absorber information should be stored in a "
+                f"group, not {type(points_absorber_group)}"
+            )
+            raise TypeError(message)
+        points_absorber = points_absorber_group.values()
+
+        return Map(
+            mirror=mirror,
+            length=length,
+            resolution=resolution,
+            points_absorber=[
+                PointAbsorber.from_hdf5(point_absorber)
+                for point_absorber in points_absorber
+            ],
+            type_=map_type,
+        )
+
+    def to_hdf5(self, store: Group | File) -> Group | File:
+        store.attrs["mirror"] = self.mirror
+        store.attrs["length"] = self.length.to_string()
+        store.attrs["resolution"] = self.resolution.to_string()
+        store.attrs["type"] = str(self.type)
+        _ = store.create_group("points absorber")
+
+        for index in range(len(self.points_absorber)):
+            point_absorber = self.points_absorber[index]
+            _ = point_absorber.to_hdf5(
+                store.require_group("points absorber").create_group(
+                    str(index),
+                ),
+            )
+        return store

backscattering_simulation_data/metadata/map.pyi

@@ -0,0 +1,31 @@
+from enum import StrEnum
+
+from _typeshed import Incomplete
+from astropy.units import Quantity
+from h5py import File as File
+from h5py import Group
+
+from .metadata import Metadata as Metadata
+from .pointabsorber import PointAbsorber as PointAbsorber
+
+class MapType(StrEnum):
+    FREE = "free"
+    CIRCULAR = "circular"
+
+class Map(Metadata):
+    mirror: Incomplete
+    length: Incomplete
+    resolution: Incomplete
+    points_absorber: Incomplete
+    type: Incomplete
+    def __init__(
+        self,
+        mirror: str,
+        length: Quantity,
+        resolution: Quantity,
+        points_absorber: list[PointAbsorber],
+        type_: MapType,
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: File | Group) -> Map: ...
+    def to_hdf5(self, store: Group | File) -> Group | File: ...

backscattering_simulation_data/metadata/metadata.py

@@ -0,0 +1,7 @@
+from backscattering_simulation_data.section import Section
+
+
+class Metadata(Section):
+    """Conceptual class that do nothing on its own. All metadata classes
+    inherit from this one.
+    """

backscattering_simulation_data/metadata/metadata.pyi

@@ -0,0 +1,3 @@
+from backscattering_simulation_data.section import Section as Section
+
+class Metadata(Section): ...

backscattering_simulation_data/metadata/modelmodifier.py

@@ -0,0 +1,47 @@
+from h5py import Group
+
+from .metadata import Metadata
+
+
+class ModelModifier(Metadata):
+    """Information about a modification of the finesse model"""
+
+    @staticmethod
+    def from_hdf5(store: Group) -> "ModelModifier":
+        if "type" not in store.attrs:
+            raise ValueError("no type in model modifier metadata")
+
+        type_ = store.attrs["type"]
+
+        if not isinstance(type_, str):
+            raise TypeError("type must be a string")
+
+        if type_ == "addition":
+            from .modifiers import ElementAddition
+
+            return ElementAddition.from_hdf5(store)
+        if type_ == "deletion":
+            from .modifiers import ElementDeletion
+
+            return ElementDeletion.from_hdf5(store)
+        if type_ == "update":
+            from .modifiers import ElementUpdate
+
+            return ElementUpdate.from_hdf5(store)
+        raise ValueError(f"unknown type {type_}")
+
+    def to_hdf5(self, store: Group) -> Group:
+        from .modifiers import (
+            ElementAddition,
+            ElementDeletion,
+            ElementUpdate,
+        )
+
+        if isinstance(self, ElementAddition):
+            store.attrs["type"] = "addition"
+        elif isinstance(self, ElementDeletion):
+            store.attrs["type"] = "deletion"
+        elif isinstance(self, ElementUpdate):
+            store.attrs["type"] = "update"
+
+        return store

backscattering_simulation_data/metadata/modelmodifier.pyi

@@ -0,0 +1,8 @@
+from h5py import Group as Group
+
+from .metadata import Metadata as Metadata
+
+class ModelModifier(Metadata):
+    @staticmethod
+    def from_hdf5(store: Group) -> ModelModifier: ...
+    def to_hdf5(self, store: Group) -> Group: ...

backscattering_simulation_data/metadata/modifiers/__init__.py

@@ -0,0 +1,9 @@
+from .addition import ElementAddition
+from .deletion import ElementDeletion
+from .update import ElementUpdate
+
+__all__ = [
+    "ElementAddition",
+    "ElementDeletion",
+    "ElementUpdate",
+]

backscattering_simulation_data/metadata/modifiers/__init__.pyi

@@ -0,0 +1,5 @@
+from .addition import ElementAddition as ElementAddition
+from .deletion import ElementDeletion as ElementDeletion
+from .update import ElementUpdate as ElementUpdate
+
+__all__ = ["ElementAddition", "ElementDeletion", "ElementUpdate"]