backscattermeter_analyzer 1.0.2__tar.gz → 2.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: backscattermeter_analyzer
-Version: 1.0.2
+Version: 2.0.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.0.0}/pyproject.toml

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

backscattermeter_analyzer-2.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.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.0.0/src/backscattermeter_analyzer/utils/__init__.py

@@ -0,0 +1,7 @@
+"""Utils classes and functions for characterization."""
+
+from .distance import Distance
+
+__all__ = [
+    "Distance",
+]

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/distance/__init__.py

@@ -0,0 +1,7 @@
+"""Manage distance states."""
+
+from .distance import Distance
+
+__all__ = [
+    "Distance",
+]

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/distance/distance.py

@@ -0,0 +1,27 @@
+"""Distance class."""
+
+from dataclasses import InitVar, dataclass, field
+from uuid import UUID, uuid4
+
+from astropy.uncertainty import Distribution
+from gwpy.detector.channel import Channel
+
+from backscattermeter_analyzer.hardware import MotorJump
+
+from .state import State
+
+
+@dataclass
+class Distance:
+    """Distances between two points from multiple channels/axis."""
+
+    distance: dict[str | Channel, Distribution]
+    state: State = field(init=False)
+    identifier: UUID = field(default_factory=uuid4)
+
+    motor_jump: InitVar[MotorJump | None] = None
+
+    def __post_init__(self, motor_jump: MotorJump | None) -> None:
+        """Post initialization."""
+
+        self.state = State(motor_jump=motor_jump)

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/distance/motor/__init__.py

@@ -0,0 +1,11 @@
+"""Manage states of the link between distance and motor jump."""
+
+from .no import WithoutMotorJump
+from .state import State
+from .yes import WithMotorJump
+
+__all__ = [
+    "State",
+    "WithMotorJump",
+    "WithoutMotorJump",
+]

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/distance/motor/no.py

@@ -0,0 +1,16 @@
+"""WithoutMotorJump class."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from .state import State
+
+
+@dataclass
+class WithoutMotorJump(State):
+    """The distance is not linked to a motor jump."""
+
+    def has_motor_jump(self) -> Literal[False]:
+        """In this state, the distance is not linked to a motor jump."""
+
+        return False

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/distance/motor/state.py

@@ -0,0 +1,20 @@
+"""State class."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from backscattermeter_analyzer.utils.distance.state import (
+        State as DistanceState,
+    )
+
+
+@dataclass
+class State:
+    """State of the link between distance and motor jump."""
+
+    state: "DistanceState"
+
+    def has_motor_jump(self) -> bool:
+        """Check the distance is linked to a motor jump."""
+        return NotImplemented

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/distance/motor/yes.py

@@ -0,0 +1,20 @@
+"""WithMotorJump class."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from backscattermeter_analyzer.hardware import MotorJump
+
+from .state import State
+
+
+@dataclass
+class WithMotorJump(State):
+    """The distance is linked to a motor jump."""
+
+    jump: MotorJump
+
+    def has_motor_jump(self) -> Literal[True]:
+        """In this state, the distance is linked to a motor jump."""
+
+        return True

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/distance/state.py

@@ -0,0 +1,31 @@
+"""State class."""
+
+from typing import TYPE_CHECKING
+
+from backscattermeter_analyzer.hardware import MotorJump
+
+from .motor import State as MotorState
+from .motor import WithMotorJump, WithoutMotorJump
+
+if TYPE_CHECKING:
+    from .distance import Distance
+
+
+class State:
+    """Distance state holder."""
+
+    distance: "Distance"
+    motor: MotorState
+
+    def __init__(self, motor_jump: MotorJump | None = None) -> None:
+        """Initialize distance state."""
+
+        if motor_jump is not None:
+            self.motor = WithMotorJump(state=self, jump=motor_jump)
+        else:
+            self.motor = WithoutMotorJump(state=self)
+
+    def has_motor_jump(self) -> bool:
+        """Check if the distance si linked to a motor jump."""
+
+        return self.motor.has_motor_jump()

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/__init__.py

@@ -0,0 +1,7 @@
+"""Manage measurement states."""
+
+from .measurement import Measurement
+
+__all__ = [
+    "Measurement",
+]

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/angle/__init__.py

@@ -0,0 +1,7 @@
+"""Manage measurement states about manual change of angle."""
+
+from .no import WithoutManualAngle
+from .state import State as AngleState
+from .yes import WithManualAngle
+
+__all__ = ["AngleState", "WithManualAngle", "WithoutManualAngle"]

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/angle/no.py

@@ -0,0 +1,14 @@
+"""WithoutManualAngle class."""
+
+from typing import Literal
+
+from .state import State
+
+
+class WithoutManualAngle(State):
+    """The measurement was done without any change of angle."""
+
+    def has_manual_angle_change(self) -> Literal[False]:
+        """No manual change of angle in this state."""
+
+        return False

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/angle/state.py

@@ -0,0 +1,25 @@
+"""State class."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from backscattermeter_analyzer.utils.measurement.state import (
+        State as MeasurementState,
+    )
+
+
+@dataclass
+class State:
+    """Angle state for this measurement."""
+
+    state: "MeasurementState"
+
+    def has_manual_angle_change(self) -> bool:
+        """
+        Define if measurement is associated to a manual change of angle.
+
+        Check the measurement has been made during a manual change of
+        angle of an optic in the setup.
+        """
+        return NotImplemented

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/angle/yes.py

@@ -0,0 +1,29 @@
+"""WithManualAngle class."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from astropy.uncertainty import Distribution
+
+from backscattermeter_analyzer import Axis
+from backscattermeter_analyzer.hardware import Optic
+
+from .state import State
+
+
+@dataclass
+class WithManualAngle(State):
+    """The measurement was done with a manual change of angle."""
+
+    axis: Axis  # axis of the angle
+    angle: Distribution  # the angle difference
+    optic: Optic  # the optic we changed the angle of
+    # we don't know exactly when the change of angle was made, so we
+    # cannot store even an approximation of the time during which the
+    # change of angle was done. This can be retrieved from the analysis
+    # through, but it's not very useful anyway.
+
+    def has_manual_angle_change(self) -> Literal[True]:
+        """Manual change of angle in this state."""
+
+        return True

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/camera/__init__.py

@@ -0,0 +1,7 @@
+"""Manage measurement states about camera existence."""
+
+from .no import WithoutCamera
+from .state import State as CameraState
+from .yes import WithCamera
+
+__all__ = ["CameraState", "WithCamera", "WithoutCamera"]

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/camera/no.py

@@ -0,0 +1,14 @@
+"""WithoutCamera class."""
+
+from typing import Literal
+
+from .state import State
+
+
+class WithoutCamera(State):
+    """The measurement was done without any camera."""
+
+    def has_camera(self) -> Literal[False]:
+        """No camera if in this state."""
+
+        return False

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/camera/state.py

@@ -0,0 +1,20 @@
+"""State class."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from backscattermeter_analyzer.utils.measurement.state import (
+        State as MeasurementState,
+    )
+
+
+@dataclass
+class State:
+    """Camera state for this measurement."""
+
+    state: "MeasurementState"
+
+    def has_camera(self) -> bool:
+        """Check the measurement was made with a camera."""
+        return NotImplemented

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/camera/yes.py

@@ -0,0 +1,20 @@
+"""WithCamera class."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from backscattermeter_analyzer.hardware import Camera
+
+from .state import State
+
+
+@dataclass
+class WithCamera(State):
+    """The measurement was done with a camera."""
+
+    camera: Camera
+
+    def have_camera(self) -> Literal[True]:
+        """Camera used if in this state."""
+
+        return True

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/measurement.py

@@ -0,0 +1,34 @@
+"""Measurement class."""
+
+from dataclasses import InitVar, dataclass, field
+from uuid import UUID, uuid4
+
+from gwpy.timeseries import TimeSeriesDict
+
+from backscattermeter_analyzer.hardware import (
+    Backscattermeter,
+    Camera,
+    MotorPath,
+)
+
+from .state import State
+
+
+@dataclass
+class Measurement:
+    """A measurement on the backscattermeter."""
+
+    data: TimeSeriesDict  # type: ignore[ty:invalid-type-form]
+    state: State = field(init=False)
+    backscattermeter: Backscattermeter
+    identifier: UUID = field(default_factory=uuid4)
+
+    camera: InitVar[Camera | None] = None
+    motor_path: InitVar[MotorPath | None] = None
+
+    def __post_init__(
+        self, camera: Camera | None, motor_path: MotorPath | None
+    ) -> None:
+        """Post initialization."""
+
+        self.state = State(camera=camera, motor_path=motor_path)

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/motor/__init__.py

@@ -0,0 +1,11 @@
+"""Manage measurement states about the link with a motor path."""
+
+from .no import WithoutMotorPath
+from .state import State as MotorState
+from .yes import WithMotorPath
+
+__all__ = [
+    "MotorState",
+    "WithMotorPath",
+    "WithoutMotorPath",
+]

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/motor/no.py

@@ -0,0 +1,14 @@
+"""WithoutMotorPath class."""
+
+from typing import Literal
+
+from .state import State
+
+
+class WithoutMotorPath(State):
+    """The measurement is not linked to a motor path."""
+
+    def is_linked_to_a_motor_path(self) -> Literal[False]:
+        """In this state, measurement is not linked to a motor path."""
+
+        return False

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/motor/state.py

@@ -0,0 +1,20 @@
+"""State class."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from backscattermeter_analyzer.utils.measurement.state import (
+        State as MeasurementState,
+    )
+
+
+@dataclass
+class State:
+    """State of the link between the measurement and a motor path."""
+
+    state: "MeasurementState"
+
+    def is_linked_to_a_motor_path(self) -> bool:
+        """Answer: is this measurement linked to a motor path."""
+        return NotImplemented

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/motor/yes.py

@@ -0,0 +1,20 @@
+"""WithMotorPath class."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from backscattermeter_analyzer.hardware import MotorPath
+
+from .state import State
+
+
+@dataclass
+class WithMotorPath(State):
+    """The measurement is linked to a motor path."""
+
+    path: MotorPath
+
+    def is_linked_to_a_motor_path(self) -> Literal[True]:
+        """In this state, the measurement is linked to a motor path."""
+
+        return True

backscattermeter_analyzer-2.0.0/src/backscattermeter_analyzer/utils/measurement/state.py

@@ -0,0 +1,92 @@
+"""State class."""
+
+from typing import TYPE_CHECKING
+
+from astropy.uncertainty import Distribution
+
+from backscattermeter_analyzer import Axis
+from backscattermeter_analyzer.hardware import (
+    Camera,
+    MotorPath,
+    Optic,
+)
+
+from .angle import AngleState, WithManualAngle, WithoutManualAngle
+from .camera import CameraState, WithCamera, WithoutCamera
+from .motor import MotorState, WithMotorPath, WithoutMotorPath
+
+if TYPE_CHECKING:
+    from .measurement import Measurement
+
+
+class State:
+    """Measurement state holder."""
+
+    measurement: "Measurement"
+    angle: AngleState
+    camera: CameraState
+    motor: MotorState
+
+    def __init__(
+        self,
+        camera: Camera | None,
+        motor_path: MotorPath | None = None,
+        angle: Distribution | None = None,
+        angle_axis: Axis | None = None,
+        angle_optic: Optic | None = None,
+    ) -> None:
+        """
+        Initialize measurement state.
+
+        Parameters
+        ----------
+        camera: Camera | None
+            Camera used during the experiment, if it exists. Else, None.
+        motor_path: MotorPath | None
+            Chain of motor jump during the experiment, if it exists.
+            Else, None.
+        angle: Distribution | None
+            Estimation of the change in angle made during the
+            measurement, if it exisis. Else, None.
+        angle_axis: Axis | None
+            Must be set if angle is set. Define the axis of the angle.
+        angle_optic: Optic | None
+            Must be set if angle is set. Define the optic which was
+            tilted.
+
+        """
+
+        if camera is not None:
+            self.camera = WithCamera(state=self, camera=camera)
+        else:
+            self.camera = WithoutCamera(state=self)
+        if motor_path is not None:
+            self.motor = WithMotorPath(state=self, path=motor_path)
+        else:
+            self.motor = WithoutMotorPath(state=self)
+        if angle is not None:
+            if angle_axis is None or angle_optic is None:
+                raise ValueError
+            self.angle = WithManualAngle(
+                state=self,
+                axis=angle_axis,
+                angle=angle,
+                optic=angle_optic,
+            )
+        else:
+            self.angle = WithoutManualAngle(state=self)
+
+    def has_camera(self) -> bool:
+        """Check if this measurement is associated to a camera."""
+
+        return self.camera.has_camera()
+
+    def is_linked_to_a_motor_path(self) -> bool:
+        """Check if this measurement is linked to a motor path."""
+
+        return self.motor.is_linked_to_a_motor_path()
+
+    def has_manual_angle_change(self) -> bool:
+        """Is measurement is associated to a tilt of an optic."""
+
+        return self.angle.has_manual_angle_change()

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

@@ -1,7 +0,0 @@
-"""Sub-package on motor."""
-
-from .jump import Jump as MotorJump
-
-__all__ = [
-    "MotorJump",
-]