backscattermeter_analyzer 1.0.2__tar.gz → 2.1.0__tar.gz

{backscattermeter_analyzer-1.0.2 → backscattermeter_analyzer-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: backscattermeter_analyzer
-Version: 1.0.2
+Version: 2.1.0
 Summary: Tool to work on the backscattermeter at LAPP
 Project-URL: Documentation, https://git.linarphy.net/linarphy/backscattermeter_analyzer/wiki
 Project-URL: Homepage, https://git.linarphy.net/linarphy/backscattermeter_analyzer

{backscattermeter_analyzer-1.0.2 → backscattermeter_analyzer-2.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "backscattermeter_analyzer"
-version = "1.0.2"
+version = "2.1.0"
 description = "Tool to work on the backscattermeter at LAPP"
 authors = [{ name = "linarphy", email = "linarphy@linarphy.net" }]
 readme = "README.md"

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/__init__.py

@@ -0,0 +1,15 @@
+"""Entry-point package."""
+
+from .axis import Axis
+from .direction import Direction
+from .io import register_measurement_hdf5
+from .utils import Distance, Measurement
+
+register_measurement_hdf5()
+
+__all__ = [
+    "Axis",
+    "Direction",
+    "Distance",
+    "Measurement",
+]

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/characterize/angle/__init__.py

@@ -0,0 +1 @@
+"""Sub-package used to measure and analyze motor action on angle."""

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/characterize/angle/result.py

@@ -0,0 +1,8 @@
+"""Result class."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Result:
+    """Result of an analysis of an angle measurement."""

{backscattermeter_analyzer-1.0.2 → backscattermeter_analyzer-2.1.0}/src/backscattermeter_analyzer/characterize/distance/measurement.py

@@ -16,7 +16,7 @@ from backscattermeter_analyzer.hardware import (
 class Measurement:
     """Measurement of a distance scan with a camera."""
 
-    data: TimeSeriesDict  # ty: ignore[invalid-type-form]
+    data: TimeSeriesDict  # type: ignore[ty:invalid-type-form]
     camera: Camera
     backscattermeter: Backscattermeter
     motor_path: list[MotorJump]

{backscattermeter_analyzer-1.0.2 → backscattermeter_analyzer-2.1.0}/src/backscattermeter_analyzer/characterize/distance/ratio.py

@@ -5,15 +5,17 @@ from typing import TYPE_CHECKING
 from uuid import uuid4
 
 from astropy.uncertainty import Distribution, normal
+from numpy import sqrt
 from numpy.linalg import norm
 
 from backscattermeter_analyzer import Axis, Direction
+from backscattermeter_analyzer.utils.distance.motor import WithMotorJump
 
 from .result import Result
 from .vector import Vector
 
 if TYPE_CHECKING:
-    from .distance import Distance
+    from backscattermeter_analyzer.utils.distance import Distance
 
 
 @dataclass
@@ -44,15 +46,33 @@ class Ratio:
         }
         for result in results:
             for distance in result.distances:
+                motor_state = distance.state.motor
+                if not isinstance(motor_state, WithMotorJump):
+                    raise TypeError
                 distances[
-                    distance.jump.axis, distance.jump.direction
+                    motor_state.jump.axis, motor_state.jump.direction
                 ].append(distance)
 
         reference_vector = Vector(
             axis=reference[0],
             direction=reference[1],
             distances=distances[reference],
-            ratio=normal(center=1, std=0.01, n_samples=1000),
+        )
+
+        reference_vector_norm = Distribution(
+            norm(
+                [
+                    value.distribution
+                    for value in reference_vector.step.values()
+                ],
+                axis=0,
+            )
+        )
+        reference_vector.ratio = normal(
+            center=1.0,
+            std=reference_vector_norm.pdf_std()
+            / sqrt(len(distances[reference])),
+            n_samples=1000,
         )
 
         vectors = [
@@ -65,22 +85,15 @@ class Ratio:
         ]
 
         for vector in vectors:
-            vector.ratio = Distribution(
+            vector.ratio = reference_vector_norm / Distribution(
                 norm(
-                    [
-                        value.distribution
-                        for value in reference_vector.step.values()
-                    ],
-                    axis=0,
-                )
-                / norm(
                     [
                         value.distribution
                         for value in vector.step.values()
                     ],
                     axis=0,
                 )
-            )
+            )  # type: ignore[ty:unsupported-operator]
 
         return Ratio(
             results=results,

{backscattermeter_analyzer-1.0.2 → backscattermeter_analyzer-2.1.0}/src/backscattermeter_analyzer/characterize/distance/result.py

@@ -3,12 +3,16 @@
 from dataclasses import dataclass, field
 from uuid import uuid4
 
+from astropy.time import TimeDelta
 from astropy.uncertainty import normal
-from astropy.units import Quantity
 from numpy import mean, std
 
-from .distance import Distance
-from .measurement import Measurement
+from backscattermeter_analyzer.utils.distance import Distance
+from backscattermeter_analyzer.utils.measurement import Measurement
+from backscattermeter_analyzer.utils.measurement.motor import (
+    WithMotorPath,
+)
+
 from .utils import split_stable_segment
 
 
@@ -23,10 +27,23 @@ class Result:
     @staticmethod
     def analyze(measurement: Measurement) -> "Result":
         """Generate a result from a measurement by analysing it."""
+        motor_state = measurement.state.motor
+        if not isinstance(motor_state, WithMotorPath):
+            raise TypeError
+
+        jumps = [element[1] for element in motor_state.path]
+        times = [TimeDelta(0.0, format="sec")]
+        times.extend(element[0] for element in motor_state.path)
+        durations = [
+            times[i + 1] - times[i] for i in range(len(times) - 1)
+        ]
+
+        transition_duration = mean(durations) / 4
+
         segments = split_stable_segment(
-            Quantity(2, "s"),
-            measurement.data,
-            len(measurement.motor_path),
+            transition_duration=transition_duration.to("s"),
+            data=measurement.data,
+            transition_number=len(jumps),
         )
 
         positions = [
@@ -49,10 +66,10 @@ class Result:
         ]
         vectors = [
             Distance(
-                jump=measurement.motor_path[i],
                 distance=distances[i],
+                motor_jump=jumps[i],
             )
-            for i in range(len(measurement.motor_path))
+            for i in range(len(jumps))
         ]
 
         return Result(

{backscattermeter_analyzer-1.0.2 → backscattermeter_analyzer-2.1.0}/src/backscattermeter_analyzer/characterize/distance/utils.py

@@ -44,8 +44,8 @@ def _find_transition_indices(
         max_index = None
         for index in sorted_transition_indices:
             if (
-                index - half_transition_samples not in processed_indices
-                and index + half_transition_samples
+                int(index - half_transition_samples) not in processed_indices
+                and int(index + half_transition_samples)
                 not in processed_indices
             ):
                 max_index = index
@@ -61,6 +61,14 @@ def _find_transition_indices(
         left_index = int(max_index - half_transition_samples)
         right_index = int(max_index + half_transition_samples)
 
+        left_indices.append(left_index)
+        right_indices.append(right_index)
+
+        left_indices.sort()
+        right_indices.sort()
+
+        left_index_index = left_indices.index(left_index)
+
         if left_index <= 0:
             message = (
                 "The measurement does not have enough data before a "
@@ -76,16 +84,13 @@ def _find_transition_indices(
 
         if (
             len(right_indices) > 1
-            and left_index - right_indices[-1] < 2  # noqa: PLR2004
+            and left_index - right_indices[left_index_index] < 2  # noqa: PLR2004
         ):
             message = (
                 "Transitions are too close in the given measurement."
             )
             raise ValueError(message)
 
-        left_indices.append(left_index)
-        right_indices.append(right_index)
-
         processed_indices.update(range(left_index, right_index + 1))
 
     left_indices.append(data_length)
@@ -97,10 +102,10 @@ def _find_transition_indices(
 
 
 def split_stable_segment(
-    transition_duration: Quantity[s], #ty: ignore[not-subscriptable]
-    data: TimeSeriesDict, # ty: ignore[invalid-type-form]
+    transition_duration: Quantity[s], #type: ignore[ty:not-subscriptable]
+    data: TimeSeriesDict, # type: ignore[ty:invalid-type-form]
     transition_number: int,
-) -> list[TimeSeriesDict]: # ty: ignore[invalid-type-form]
+) -> list[TimeSeriesDict]: # type: ignore[ty:invalid-type-form]
     """
     Split N-dim time series into stable segments, excluding transition.
 
@@ -126,7 +131,6 @@ def split_stable_segment(
         of segments is transition_number + 1.
 
     """
-
     datum = next(iter(data.values()))  # get a random TimeSeries in data
 
     if len(datum) <= 1:

{backscattermeter_analyzer-1.0.2 → backscattermeter_analyzer-2.1.0}/src/backscattermeter_analyzer/characterize/distance/vector.py

@@ -8,8 +8,8 @@ from gwpy.detector.channel import Channel
 from numpy import mean, sqrt
 
 from backscattermeter_analyzer import Axis, Direction
-
-from .distance import Distance
+from backscattermeter_analyzer.utils.distance import Distance
+from backscattermeter_analyzer.utils.distance.motor import WithMotorJump
 
 
 @dataclass
@@ -28,7 +28,7 @@ class Vector:
     step: dict[str | Channel, Distribution] = field(
         init=False,
         doc="displacement for one step",
-    )  # ty: ignore[no-matching-overload]
+    )  # type: ignore[ty:no-matching-overload]
     identifier: str = field(default_factory=lambda: str(uuid4()))
 
     def __post_init__(self) -> None:
@@ -37,7 +37,10 @@ class Vector:
         distances: dict[str | Channel, list[Distribution]] = {}
         for distance in self.distances:
             for key, length in distance.distance.items():
-                real_distance = length / distance.jump.step_number  # ty: ignore[unsupported-operator]
+                motor_state = distance.state.motor
+                if not isinstance(motor_state, WithMotorJump):
+                    raise TypeError
+                real_distance = length / motor_state.jump.step_number  # type: ignore[ty:unsupported-operator]
                 if key not in distances:
                     distances[key] = [real_distance]
                 else:

{backscattermeter_analyzer-1.0.2 → backscattermeter_analyzer-2.1.0}/src/backscattermeter_analyzer/hardware/__init__.py

@@ -2,10 +2,13 @@
 
 from .backscattermeter import Backscattermeter
 from .camera import Camera
-from .motor import MotorJump
+from .motor import MotorJump, MotorPath
+from .optic import Optic
 
 __all__ = [
     "Backscattermeter",
     "Camera",
     "MotorJump",
+    "MotorPath",
+    "Optic",
 ]

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/hardware/motor/__init__.py

@@ -0,0 +1,11 @@
+"""Sub-package on motor."""
+
+from .jump import Jump as MotorJump
+from .path import Path as MotorPath
+from .step_numbers import StepNumbers
+
+__all__ = [
+    "MotorJump",
+    "MotorPath",
+    "StepNumbers",
+]

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/hardware/motor/path.py

@@ -0,0 +1,118 @@
+"""Path class."""
+
+from collections.abc import Iterable
+
+from astropy.time import TimeDelta
+
+from backscattermeter_analyzer import Axis, Direction
+from backscattermeter_analyzer.hardware.motor.step_numbers import (
+    StepNumbers,
+)
+
+from .jump import Jump
+
+
+class Path(Iterable):
+    """A sequence of MotorJump."""
+
+    def __init__(self, data: list[tuple[TimeDelta, Jump]]) -> None:
+        """
+        Initialize a MotorPath.
+
+        Parameters
+        ----------
+        data: dict[Quantity[s], MotorJump]
+            Links between time in second from the start of the
+            TimeSeries and a motor jump.
+
+        """
+
+        self._inner = data
+        self._idx = 0
+
+    def __iter__(self) -> "Path":
+        """Default __iter__ function."""
+
+        return self
+
+    def __next__(self) -> tuple[TimeDelta, Jump]:
+        """Default __next__ function."""
+
+        self._idx += 1
+        try:
+            return self._inner[self._idx - 1]
+        except IndexError as exception:
+            self._idx = 0
+            raise StopIteration from exception
+
+    def __len__(self) -> int:
+        """Default __len__ function."""
+
+        return len(self._inner)
+
+    def __getitem__(
+        self, subscript: slice | int
+    ) -> tuple[TimeDelta, Jump] | list[tuple[TimeDelta, Jump]]:
+        """Default __getitem__ function."""
+
+        return self._inner[subscript]
+
+    @staticmethod
+    def snail(
+        number: int,
+        duration: TimeDelta,
+        speed: int,
+        step_numbers: StepNumbers,
+    ) -> "Path":
+        """Generate a motor path with a snail structure."""
+
+        x_p = Jump(
+            direction=Direction.POSITIVE,
+            axis=Axis.X,
+            step_number=step_numbers.xp,
+            speed=speed,
+        )
+        x_n = Jump(
+            direction=Direction.NEGATIVE,
+            axis=Axis.X,
+            step_number=step_numbers.xn,
+            speed=speed,
+        )
+        y_p = Jump(
+            direction=Direction.POSITIVE,
+            axis=Axis.Y,
+            step_number=step_numbers.yp,
+            speed=speed,
+        )
+        y_n = Jump(
+            direction=Direction.NEGATIVE,
+            axis=Axis.Y,
+            step_number=step_numbers.yn,
+            speed=speed,
+        )
+
+        result: list[tuple[TimeDelta, Jump]] = []
+        current_offset = TimeDelta(0.0, format="sec")
+
+        for i in range(number * 2):
+            for _ in range(i + 1):
+                current_offset += duration
+                if i % 2 == 0:
+                    result.append((current_offset, x_p))
+                else:
+                    result.append((current_offset, x_n))
+            for _ in range(i + 1):
+                current_offset += duration
+                if i % 2 == 0:
+                    result.append((current_offset, y_p))
+                else:
+                    result.append((current_offset, y_n))
+
+        for _ in range(number):
+            current_offset += duration
+            result.append((current_offset, x_p))
+        for _ in range(number):
+            current_offset += duration
+            result.append((current_offset, y_p))
+
+        return Path(data=result)

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/hardware/motor/step_numbers.py

@@ -0,0 +1,12 @@
+"""StepNumbers class."""
+
+from typing import NamedTuple
+
+
+class StepNumbers(NamedTuple):
+    """Number of steps in each couple (direction, axis)."""
+
+    xp: int
+    xn: int
+    yp: int
+    yn: int

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/hardware/optic/__init__.py

@@ -0,0 +1,13 @@
+"""Sub-package on optic."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Optic:
+    """Information about an optic."""
+
+
+__all__ = [
+    "Optic",
+]

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/io/__init__.py

@@ -0,0 +1,15 @@
+"""I/O package."""
+
+from .hdf5 import register_measurement_hdf5
+from .registry import (
+    UnifiedIORegistry,
+    UnifiedReadWrite,
+    UnifiedReadWriteMethod,
+)
+
+__all__ = [
+    "UnifiedIORegistry",
+    "UnifiedReadWrite",
+    "UnifiedReadWriteMethod",
+    "register_measurement_hdf5",
+]

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/io/hdf5/__init__.py

@@ -0,0 +1,7 @@
+"""Sub-package for writing and parsing hdf5 files."""
+
+from .measurement import (
+    register_measurement as register_measurement_hdf5,
+)
+
+__all__ = ["register_measurement_hdf5"]

backscattermeter_analyzer-2.1.0/src/backscattermeter_analyzer/io/hdf5/measurement.py

@@ -0,0 +1,156 @@
+"""Hdf5 conversion for Measurement."""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from h5py import File, Group
+
+from backscattermeter_analyzer.hardware import Backscattermeter
+from backscattermeter_analyzer.io.registry.default import (
+    default_registry,
+)
+
+from .utils import (
+    group_to_timeseriesdict,
+    is_hdf5,
+    timeseriesdict_to_group,
+)
+
+if TYPE_CHECKING:
+    from backscattermeter_analyzer.utils.measurement.measurement import (  # noqa:E501,TC004
+        Measurement,
+    )
+
+
+def read(input_: Path | Group, path: str | None = None) -> Measurement:
+    """
+    Read a Measurement object from an HDF5 component/file.
+
+    Parameters
+    ----------
+    input_: Path | Group
+        If a string or a Path, the filename to read the table from.
+        If an h5py object, either the file or the group object to read
+        the Measurement from.
+    path: str | None
+        The path from which to read the table inside the HDF5 file.
+        This should be relative to the input if the input is a Group.
+
+    """
+    from backscattermeter_analyzer.utils.measurement.measurement import (  # noqa: PLC0415,E501
+        Measurement,
+    )
+
+    if isinstance(input_, Path):
+        input_ = File(input_)
+
+    # input_ is now a Group (a File is a Group)
+    if path is not None:
+        item = input_.get(path, default=None)
+        if item is None:
+            message = f"{path} is not a valid path in {input_}."
+            raise ValueError(message)
+        if not isinstance(item, Group):
+            message = (
+                f"{path} from {input_} is a {type(item)}, not a Group."
+            )
+            raise TypeError(message)
+    else:
+        item = input_
+
+    group_data = item.get("data", default=None)
+    if group_data is None:
+        message = f"No 'data' group in {path} from {input_}."
+        raise ValueError(message)
+    if not isinstance(group_data, Group):
+        message = f"'data' must be a group in {path} from {input_}."
+        raise TypeError(message)
+
+    measurement = Measurement(
+        data=group_to_timeseriesdict(group_data),
+        backscattermeter=Backscattermeter(),
+    )
+
+    if isinstance(input_, File):
+        input_.close()
+
+    return measurement
+
+
+def write(
+    measurement: Measurement,
+    output: Path | Group,
+    path: str | None = None,
+    *,
+    append: bool = False,
+    overwrite: bool = False,
+) -> None:
+    """
+    Write a Measurement object to an HDF5 file.
+
+    Parameters
+    ----------
+    measurement: Measurement
+        Measurement that is to be written to file.
+    output: Path | Group
+        If a Path, the path of the file to write the measurement to. If
+        a Group, the group object to write the measurement to, depending
+        on `path` value.
+    path: str | None
+        The path to which to write the table inside the HDF5 file.
+        This should be relative to the output Group (or the root Group
+        if output is a Path). Default to None.
+    append: bool
+        Whether to append the Measurement to an existing HDF5 file.
+        Default to False. This can delete a previous measurement.
+    overwrite: bool
+        Whether to overwrite any existing file without warning. Default
+        to False. If `append=True` and `overwrite=True`, then only the
+        group will be replaced.
+
+    """
+
+    if isinstance(output, Path):
+        if overwrite and not append:
+            output = File(output, mode="w")
+        elif append:
+            output = File(output, mode="r+")
+        else:
+            output = File(output, mode="x")
+
+    # output is now a Group (a File is a Group)
+    if path is not None:
+        item = output.get(path, default=None)
+        if item is None:
+            message = f"{path} is not a valid path in {output}."
+            raise ValueError(message)
+        if not isinstance(item, Group):
+            message = (
+                f"{path} from {output} is a {type(item)}, not a Group."
+            )
+            raise TypeError(message)
+    else:
+        item = output
+
+    element_number = len(item.keys())
+    if element_number != 0 and append:
+        item.clear()
+    elif element_number != 0 and not append:
+        message = f"{path} from {output} is not an empty group."
+        raise ValueError(message)
+
+    timeseriesdict_to_group(item, "data", measurement.data)
+
+    if isinstance(output, File):
+        output.close()
+
+
+def register_measurement() -> None:
+    """Register Measurement hdf5 conversion in Unified I/O."""
+    from backscattermeter_analyzer.utils.measurement.measurement import (  # noqa: PLC0415,E501
+        Measurement,
+    )
+
+    default_registry.register_identifier("hdf5", Measurement, is_hdf5)
+    default_registry.register_reader("hdf5", Measurement, read)
+    default_registry.register_writer("hdf5", Measurement, write)