backscattering_simulation_data 1.0.1__py3-none-any.whl

backscattering_simulation_data/metadata/modifiers/addition.py

@@ -0,0 +1,101 @@
+from typing import TYPE_CHECKING
+
+from astropy.table import QTable
+from h5py import Dataset, Group
+
+from ..elementtype import ElementType
+from ..modelmodifier import ModelModifier
+
+if TYPE_CHECKING:
+    from .deletion import ElementDeletion
+
+
+class ElementAddition(ModelModifier):
+    """Information about an addition of an element to the model"""
+
+    def __init__(
+        self,
+        requirements: list["ElementAddition | ElementDeletion"],
+        port: str,
+        element: str,
+        element_type: ElementType,
+        parameters: QTable,
+    ) -> None:
+        self.requirements = requirements
+        self.port = port
+        self.element = element
+        self.element_type = element_type
+        self.parameters = parameters
+
+    @staticmethod
+    def from_hdf5(store: Group) -> "ElementAddition":
+        for attribute in ["element", "element type", "port"]:
+            if attribute not in store.attrs:
+                raise ValueError(
+                    f"no {attribute} in model addition metadata",
+                )
+
+        element = store.attrs["element"]
+        element_type_str = store.attrs["element type"]
+        port = store.attrs["port"]
+
+        message = "model addition {} should be a string, not {}"
+        if not isinstance(element, str):
+            raise TypeError(message.format("element", type(element)))
+        if not isinstance(element_type_str, str):
+            raise TypeError(
+                message.format(
+                    element_type_str,
+                    type(element_type_str),
+                ),
+            )
+        if not isinstance(port, str):
+            raise TypeError(message.format(port, type(port)))
+
+        element_type = ElementType(element_type_str)
+
+        requirements_dataset = store.get("requirements")
+
+        if not isinstance(requirements_dataset, Dataset):
+            message = (
+                "requirements must be stored in a Dataset, not "
+                f"{type(requirements_dataset)}"
+            )
+            raise TypeError(message)
+
+        requirements = list(requirements_dataset)
+
+        parameters = QTable.read(
+            store,
+            format="hdf5",
+            path="parameters",
+        )
+
+        return ElementAddition(
+            element=element,
+            element_type=element_type,
+            port=port,
+            requirements=requirements,
+            parameters=parameters,
+        )
+
+    def to_hdf5(self, store: Group) -> Group:
+        store.attrs["element"] = self.element
+        store.attrs["element type"] = self.element_type
+        store.attrs["port"] = self.port
+
+        _ = store.create_dataset(
+            "requirements",
+            data=[
+                requirement.element for requirement in self.requirements
+            ],
+        )
+
+        self.parameters.write(
+            store,
+            format="hdf5",
+            path="parameters",
+            serialize_meta=True,
+        )
+
+        return ModelModifier.to_hdf5(self, store)

backscattering_simulation_data/metadata/modifiers/addition.pyi

@@ -0,0 +1,25 @@
+from _typeshed import Incomplete
+from astropy.table import QTable
+from h5py import Group as Group
+
+from ..elementtype import ElementType as ElementType
+from ..modelmodifier import ModelModifier as ModelModifier
+from .deletion import ElementDeletion as ElementDeletion
+
+class ElementAddition(ModelModifier):
+    requirements: Incomplete
+    port: Incomplete
+    element: Incomplete
+    element_type: Incomplete
+    parameters: Incomplete
+    def __init__(
+        self,
+        requirements: list[ElementAddition | ElementDeletion],
+        port: str,
+        element: str,
+        element_type: ElementType,
+        parameters: QTable,
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: Group) -> ElementAddition: ...
+    def to_hdf5(self, store: Group) -> Group: ...

backscattering_simulation_data/metadata/modifiers/deletion.py

@@ -0,0 +1,31 @@
+from h5py import Group
+
+from ..modelmodifier import ModelModifier
+
+
+class ElementDeletion(ModelModifier):
+    """Information about the deletion of an element to the model"""
+
+    def __init__(
+        self,
+        element: str,
+    ) -> None:
+        self.element = element
+
+    @staticmethod
+    def from_hdf5(store: Group) -> "ElementDeletion":
+        if "element" not in store.attrs:
+            raise ValueError("no element in model deletion metadata")
+        element = store.attrs["element"]
+        if not isinstance(element, str):
+            message = (
+                "element of model deletion must be a string, not "
+                f"{type(element)}"
+            )
+            raise TypeError(message)
+        return ElementDeletion(element=element)
+
+    def to_hdf5(self, store: Group) -> Group:
+        store.attrs["element"] = self.element
+
+        return ModelModifier.to_hdf5(self, store)

backscattering_simulation_data/metadata/modifiers/deletion.pyi

@@ -0,0 +1,11 @@
+from _typeshed import Incomplete
+from h5py import Group as Group
+
+from ..modelmodifier import ModelModifier as ModelModifier
+
+class ElementDeletion(ModelModifier):
+    element: Incomplete
+    def __init__(self, element: str) -> None: ...
+    @staticmethod
+    def from_hdf5(store: Group) -> ElementDeletion: ...
+    def to_hdf5(self, store: Group) -> Group: ...

backscattering_simulation_data/metadata/modifiers/update.py

@@ -0,0 +1,55 @@
+from astropy.table import QTable
+from h5py import Group
+
+from ..modelmodifier import ModelModifier
+
+
+class ElementUpdate(ModelModifier):
+    """
+    Information about the update of an existing element to the model
+    """
+
+    def __init__(
+        self,
+        element: str,
+        parameters: QTable,
+    ) -> None:
+        self.element = element
+        self.parameters = parameters
+
+    @staticmethod
+    def from_hdf5(store: Group) -> "ElementUpdate":
+        if "element" not in store.attrs:
+            raise ValueError("no element in model update metadata")
+
+        element = store.attrs["element"]
+
+        if not isinstance(element, str):
+            message = (
+                "element of model update must be a string, not",
+                f"{type(element)}",
+            )
+            raise TypeError(message)
+
+        parameters = QTable.read(
+            store,
+            format="hdf5",
+            path="parameters",
+        )
+
+        return ElementUpdate(
+            element=element,
+            parameters=parameters,
+        )
+
+    def to_hdf5(self, store: Group) -> Group:
+        store.attrs["element"] = self.element
+
+        self.parameters.write(
+            store,
+            format="hdf5",
+            path="parameters",
+            serialize_meta=True,
+        )
+
+        return ModelModifier.to_hdf5(self, store)

backscattering_simulation_data/metadata/modifiers/update.pyi

@@ -0,0 +1,13 @@
+from _typeshed import Incomplete
+from astropy.table import QTable
+from h5py import Group as Group
+
+from ..modelmodifier import ModelModifier as ModelModifier
+
+class ElementUpdate(ModelModifier):
+    element: Incomplete
+    parameters: Incomplete
+    def __init__(self, element: str, parameters: QTable) -> None: ...
+    @staticmethod
+    def from_hdf5(store: Group) -> ElementUpdate: ...
+    def to_hdf5(self, store: Group) -> Group: ...

backscattering_simulation_data/metadata/pointabsorber.py

@@ -0,0 +1,94 @@
+from astropy.units import Quantity
+from h5py import File, Group
+
+from .metadata import Metadata
+
+
+class PointAbsorber(Metadata):
+    """Information about a point absorber"""
+
+    def __init__(
+        self,
+        x: Quantity,
+        y: Quantity,
+        radius: Quantity,
+        power: Quantity,
+    ) -> None:
+        """Parameters
+        ----------
+        x: Quantity[length]
+            X position of the point
+        y: Quantity[length]
+            Y position of the point
+        radius: Quantity[length]
+            Radius of the point
+        power: Quantity[power]
+            Absorption power of the point
+
+        """
+        if (
+            x.unit is None
+            or y.unit is None
+            or radius.unit is None
+            or power.unit is None
+        ):
+            raise TypeError("every quantities must have an unit")
+        if (
+            x.unit.physical_type != "length"
+            or y.unit.physical_type != "length"
+            or radius.unit.physical_type != "length"
+        ):
+            raise TypeError("x, y and radius must be length")
+        if power.unit.physical_type != "power":
+            raise TypeError("power must be power")
+        if radius <= Quantity(0, "m"):
+            raise ValueError("radius must be positive")
+        if power <= Quantity(0, "W"):
+            raise ValueError("power must be positive")
+
+        self.x = x
+        self.y = y
+        self.radius = radius
+        self.power = power
+
+    @staticmethod
+    def from_hdf5(store: File | Group) -> "PointAbsorber":
+        for attribute in ["x", "y", "radius", "power"]:
+            if attribute not in store.attrs:
+                raise ValueError(
+                    f"no {attribute} in absorber point metadata",
+                )
+
+        x = store.attrs["x"]
+        y = store.attrs["y"]
+        radius = store.attrs["radius"]
+        power = store.attrs["power"]
+
+        message = "absorber point {} should be a string, not {}"
+        if not isinstance(x, str):
+            raise TypeError(message.format("x", type(x)))
+        if not isinstance(y, str):
+            raise TypeError(message.format("y", type(y)))
+        if not isinstance(radius, str):
+            raise TypeError(message.format("radius", type(radius)))
+        if not isinstance(power, str):
+            raise TypeError(message.format("power", type(power)))
+
+        x = Quantity(x)
+        y = Quantity(y)
+        radius = Quantity(radius)
+        power = Quantity(power)
+
+        return PointAbsorber(
+            x=x,
+            y=y,
+            radius=radius,
+            power=power,
+        )
+
+    def to_hdf5(self, store: File | Group) -> Group | File:
+        store.attrs["x"] = self.x.to_string()
+        store.attrs["y"] = self.y.to_string()
+        store.attrs["radius"] = self.radius.to_string()
+        store.attrs["power"] = self.power.to_string()
+        return store

backscattering_simulation_data/metadata/pointabsorber.pyi

@@ -0,0 +1,22 @@
+from _typeshed import Incomplete
+from astropy.units import Quantity
+from h5py import File as File
+from h5py import Group as Group
+
+from .metadata import Metadata as Metadata
+
+class PointAbsorber(Metadata):
+    x: Incomplete
+    y: Incomplete
+    radius: Incomplete
+    power: Incomplete
+    def __init__(
+        self,
+        x: Quantity,
+        y: Quantity,
+        radius: Quantity,
+        power: Quantity,
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: File | Group) -> PointAbsorber: ...
+    def to_hdf5(self, store: File | Group) -> Group | File: ...

backscattering_simulation_data/metadata/powermeasurement.py

@@ -0,0 +1,48 @@
+from h5py import File, Group
+
+from .metadata import Metadata
+
+
+class PowerMeasurement(Metadata):
+    """Information about a power measurement"""
+
+    def __init__(
+        self,
+        port: str,
+        name: str,
+    ) -> None:
+        """Parameters
+        ----------
+        port : str
+            Specific port where the power was measured in the simulation
+            model
+        name : str
+            Simple name of the place where the power was measured
+
+        """
+        self.port = port
+        self.name = name
+
+    @staticmethod
+    def from_hdf5(store: Group | File) -> "PowerMeasurement":
+        for attribute in ["port", "name"]:
+            if attribute not in store.attrs:
+                raise ValueError(
+                    f"no {attribute} in power measurement metadata",
+                )
+
+        port = store.attrs["port"]
+        name = store.attrs["name"]
+
+        message = "power measurement {} should be a string, not {}"
+        if not isinstance(port, str):
+            raise TypeError(message.format("port", type(port)))
+        if not isinstance(name, str):
+            raise TypeError(message.format("name", type(name)))
+
+        return PowerMeasurement(port=port, name=name)
+
+    def to_hdf5(self, store: File | Group) -> Group | File:
+        store.attrs["port"] = self.port
+        store.attrs["name"] = self.name
+        return store

backscattering_simulation_data/metadata/powermeasurement.pyi

@@ -0,0 +1,13 @@
+from _typeshed import Incomplete
+from h5py import File as File
+from h5py import Group as Group
+
+from .metadata import Metadata as Metadata
+
+class PowerMeasurement(Metadata):
+    port: Incomplete
+    name: Incomplete
+    def __init__(self, port: str, name: str) -> None: ...
+    @staticmethod
+    def from_hdf5(store: Group | File) -> PowerMeasurement: ...
+    def to_hdf5(self, store: File | Group) -> Group | File: ...

backscattering_simulation_data/metadata/root.py

@@ -0,0 +1,108 @@
+from h5py import File, Group
+from numpy import int64
+
+from .git import Git
+from .interferometer import Interferometer
+from .metadata import Metadata
+from .simulation import Simulation
+
+
+class Root(Metadata):
+    """Metadata associated to the Root section"""
+
+    def __init__(
+        self,
+        name: str,
+        maxtem: int,
+        git: Git,
+        interferometer: Interferometer,
+        simulation: Simulation,
+    ) -> None:
+        """Parameters
+        ----------
+        name : str
+            Unique name to indentify this simulation data
+        maxtem : int
+            Number of High Order Modes modelised
+        git : Git
+            Information about the git repo that generated this data
+        interferometer : Interferometer
+            Information about the simulated interferometer for this data
+        simulation : Simulation
+            Information about the simulation details for this data
+
+        """
+        if maxtem < 0:
+            raise ValueError("maxtem must be positive")
+
+        self.name = name
+        self.maxtem = maxtem
+        self.git = git
+        self.interferometer = interferometer
+        self.simulation = simulation
+
+    @staticmethod
+    def from_hdf5(store: File | Group) -> "Root":
+        for attribute in ["name", "maxtem"]:
+            if attribute not in store.attrs:
+                raise ValueError(f"no {attribute} for simulation data")
+        name = store.attrs["name"]
+        maxtem = store.attrs["maxtem"]
+
+        message = "simulation {} should be a {}, not {}"
+        if not isinstance(name, str):
+            raise ValueError(
+                message.format("name", "string", type(name)),
+            )
+        if not isinstance(maxtem, int64):
+            raise ValueError(
+                message.format("maxtem", "int", type(maxtem)),
+            )
+
+        git_group = store.get("git")
+        interferometer_group = store.get("interferometer")
+        message = "{} information should be stored in a group, not {}"
+        if not isinstance(git_group, Group):
+            raise ValueError(message.format("git", type(git_group)))
+        if not isinstance(interferometer_group, Group):
+            raise ValueError(
+                message.format(
+                    "interferometer",
+                    type(interferometer_group),
+                ),
+            )
+
+        try:
+            simulation_group = store["simulation"]  # can throw KeyError
+            if not isinstance(simulation_group, Group):
+                raise TypeError(
+                    message.format(
+                        "simulation",
+                        type(simulation_group),
+                    ),
+                )
+            simulation = Simulation.from_hdf5(simulation_group)
+        except KeyError:
+            # Legacy support, simulation is not defined for file
+            # generated before 0.3.0
+            simulation = Simulation(maps=[], model_modifiers=[])
+
+        git = Git.from_hdf5(git_group)
+        interferometer = Interferometer.from_hdf5(interferometer_group)
+        return Root(
+            name=name,
+            maxtem=maxtem,
+            git=git,
+            interferometer=interferometer,
+            simulation=simulation,
+        )
+
+    def to_hdf5(self, store: File | Group) -> Group | File:
+        store.attrs["name"] = self.name
+        store.attrs["maxtem"] = self.maxtem
+        _ = self.git.to_hdf5(store.create_group("git"))
+        _ = self.interferometer.to_hdf5(
+            store.create_group("interferometer"),
+        )
+        _ = self.simulation.to_hdf5(store.create_group("simulation"))
+        return store

backscattering_simulation_data/metadata/root.pyi

@@ -0,0 +1,26 @@
+from _typeshed import Incomplete
+from h5py import File as File
+from h5py import Group
+
+from .git import Git as Git
+from .interferometer import Interferometer as Interferometer
+from .metadata import Metadata as Metadata
+from .simulation import Simulation as Simulation
+
+class Root(Metadata):
+    name: Incomplete
+    maxtem: Incomplete
+    git: Incomplete
+    interferometer: Incomplete
+    simulation: Incomplete
+    def __init__(
+        self,
+        name: str,
+        maxtem: int,
+        git: Git,
+        interferometer: Interferometer,
+        simulation: Simulation,
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: File | Group) -> Root: ...
+    def to_hdf5(self, store: File | Group) -> Group | File: ...

backscattering_simulation_data/metadata/scatterer.py

@@ -0,0 +1,71 @@
+from astropy.units import Quantity
+from astropy.units.physical import dimensionless
+from h5py import File, Group
+from numpy import float64
+
+from .metadata import Metadata
+
+
+class Scatterer(Metadata):
+    """Metadata associated to a scatterer"""
+
+    def __init__(
+        self,
+        name: str,
+        reflectivity: Quantity[dimensionless],
+    ) -> None:
+        """Parameters
+        ----------
+        name : str
+            Name of the scatterer
+        reflectivity : Quantity[dimensionless]
+            The reflectivity of the scatterer (simulated as a mirror)
+            in the simulation
+
+        """
+        if (
+            reflectivity.unit is not None
+            and reflectivity.unit.physical_type != "dimensionless"
+        ):
+            raise TypeError("reflectivity must not have any unit")
+        if reflectivity < Quantity(0):
+            raise ValueError("reflectivity must be positive")
+        if reflectivity > Quantity(1):
+            raise ValueError("reflectivity must be below 1")
+
+        self.name = name
+        self.reflectivity = reflectivity
+
+    @staticmethod
+    def from_hdf5(store: File | Group) -> "Scatterer":
+        if "name" not in store.attrs:
+            raise ValueError("no name for a scatterer")
+        if "reflectivity" not in store.attrs:
+            raise ValueError("no reflectivity for a scatterer")
+        name = store.attrs["name"]
+        reflectivity = store.attrs["reflectivity"]
+        if not isinstance(name, str):
+            raise ValueError(f"name must be a string, not {type(name)}")
+        if not isinstance(reflectivity, str) and not isinstance(
+            reflectivity,
+            float64,
+        ):
+            message = (
+                "reflectivity must be a string or a float, not"
+                f"{type(reflectivity)}"
+            )
+            raise ValueError(message)
+        reflectivity = Quantity(value=reflectivity, unit=None)
+        return Scatterer(name=name, reflectivity=reflectivity)
+
+    def to_hdf5(self, store: File | Group) -> File | Group:
+        store.attrs["name"] = self.name
+        if isinstance(self.reflectivity, Quantity):
+            store.attrs["reflectivity"] = self.reflectivity.to_string()
+        else:
+            message = (
+                "reflectivity must be an unitless Quantity, not"
+                f"{self.reflectivity}"
+            )
+            raise ValueError(message)
+        return store

backscattering_simulation_data/metadata/scatterer.pyi

@@ -0,0 +1,17 @@
+from _typeshed import Incomplete
+from astropy.units import Quantity
+from astropy.units.physical import dimensionless as dimensionless
+from h5py import File as File
+from h5py import Group as Group
+
+from .metadata import Metadata as Metadata
+
+class Scatterer(Metadata):
+    name: Incomplete
+    reflectivity: Incomplete
+    def __init__(
+        self, name: str, reflectivity: Quantity[dimensionless]
+    ) -> None: ...
+    @staticmethod
+    def from_hdf5(store: File | Group) -> Scatterer: ...
+    def to_hdf5(self, store: File | Group) -> File | Group: ...