dls-dodal 1.59.1__py3-none-any.whl → 1.61.0__py3-none-any.whl

dodal/beamlines/i19_1.py

@@ -58,6 +58,8 @@ def oav() -> OAVBeamCentreFile:
     )
 
 
+# NOTE EH1 uses the Zebra 2 box. While a Zebra 1 box exists and is connected
+# on the beamline, it is currently not in use
 @device_factory()
 def zebra() -> Zebra:
     """Get the i19-1 zebra device, instantiate it if it hasn't already been.
@@ -65,7 +67,7 @@ def zebra() -> Zebra:
     """
     return Zebra(
         mapping=I19_1_ZEBRA_MAPPING,
-        prefix=f"{PREFIX.beamline_prefix}-EA-ZEBRA-03:",
+        prefix=f"{PREFIX.beamline_prefix}-EA-ZEBRA-02:",
     )
 
 

dodal/beamlines/i19_2.py

@@ -57,7 +57,7 @@ def zebra() -> Zebra:
     """
     return Zebra(
         mapping=I19_2_ZEBRA_MAPPING,
-        prefix=f"{PREFIX.beamline_prefix}-EA-ZEBRA-01:",
+        prefix=f"{PREFIX.beamline_prefix}-EA-ZEBRA-03:",
     )
 
 

dodal/devices/apple2_undulator.py

@@ -301,9 +301,68 @@ class UndulatorJawPhase(SafeUndulatorMover[float]):
         )
 
 
+class Apple2Motors(StandardReadable, Movable):
+    """
+    Device representing the combined motor controls for an Apple2 undulator.
+
+    Attributes
+    ----------
+    gap : UndulatorGap
+        The undulator gap motor device.
+    phase : UndulatorPhaseAxes
+        The undulator phase axes device, consisting of four phase motors.
+    """
+
+    def __init__(self, id_gap: UndulatorGap, id_phase: UndulatorPhaseAxes, name=""):
+        """
+        Parameters
+        ----------
+
+        id_gap: UndulatorGap
+            An UndulatorGap device.
+        id_phase: UndulatorPhaseAxes
+            An UndulatorPhaseAxes device.
+        name: str
+            Name of the device.
+        """
+        with self.add_children_as_readables():
+            self.gap = id_gap
+            self.phase = id_phase
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, id_motor_values: Apple2Val) -> None:
+        """
+        Check ID is in a movable state and set all the demand value before moving them
+        all at the same time. This should be modified by the beamline specific ID
+        class, if the ID motors has to move in a specific order.
+        """
+
+        # Only need to check gap as the phase motors share both fault and gate with gap.
+        await self.gap.raise_if_cannot_move()
+        await asyncio.gather(
+            self.phase.top_outer.user_setpoint.set(value=id_motor_values.top_outer),
+            self.phase.top_inner.user_setpoint.set(value=id_motor_values.top_inner),
+            self.phase.btm_inner.user_setpoint.set(value=id_motor_values.btm_inner),
+            self.phase.btm_outer.user_setpoint.set(value=id_motor_values.btm_outer),
+            self.gap.user_setpoint.set(value=id_motor_values.gap),
+        )
+        timeout = np.max(
+            await asyncio.gather(self.gap.get_timeout(), self.phase.get_timeout())
+        )
+        LOGGER.info(
+            f"Moving f{self.name} apple2 motors to {id_motor_values}, timeout = {timeout}"
+        )
+        await asyncio.gather(
+            self.gap.set_move.set(value=1, wait=False, timeout=timeout),
+            self.phase.set_move.set(value=1, wait=False, timeout=timeout),
+        )
+        await wait_for_value(self.gap.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
+
+
 class EnergyMotorConvertor(Protocol):
     def __call__(self, energy: float, pol: Pol) -> tuple[float, float]:
-        """Protocol to provide energy to motor position convertion"""
+        """Protocol to provide energy to motor position conversion"""
         ...
 
 
@@ -318,15 +377,13 @@ class Apple2(abc.ABC, StandardReadable, Movable):
     The class is designed to manage the undulator's gap, phase motors, and polarisation settings, while
     abstracting hardware interactions and providing a high-level interface for beamline operations.
 
-    The class is abstract and requires beamline-specific implementations for set motor
+    The class is abstract and requires beamline-specific implementations for _set motor
      positions based on energy and polarisation.
 
     Attributes
     ----------
-    gap : UndulatorGap
-        The gap control device for the undulator.
-    phase : UndulatorPhaseAxes
-        The phase control device, consisting of four phase motors.
+    apple2_motors : Apple2Motors
+        A collection of gap and phase motor devices.
     energy : SignalR
         A soft signal for the current energy readback.
     polarisation_setpoint : SignalR
@@ -340,7 +397,7 @@ class Apple2(abc.ABC, StandardReadable, Movable):
 
     Abstract Methods
     ----------------
-    set(value: float) -> None
+    _set(value: float) -> None
         Abstract method to set motor positions for a given energy and polarisation.
 
     Methods
@@ -363,8 +420,7 @@ class Apple2(abc.ABC, StandardReadable, Movable):
 
     def __init__(
         self,
-        id_gap: UndulatorGap,
-        id_phase: UndulatorPhaseAxes,
+        apple2_motors: Apple2Motors,
         energy_motor_convertor: EnergyMotorConvertor,
         name: str = "",
     ) -> None:
@@ -378,8 +434,7 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         name: Name of the device.
         """
 
-        self.gap = id_gap
-        self.phase = id_phase
+        self.motors = apple2_motors
         self.energy_to_motor = energy_motor_convertor
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             # Store the set energy for readback.
@@ -398,11 +453,11 @@ class Apple2(abc.ABC, StandardReadable, Movable):
             raw_to_derived=self._read_pol,
             set_derived=self._set_pol,
             pol=self.polarisation_setpoint,
-            top_outer=self.phase.top_outer.user_readback,
-            top_inner=self.phase.top_inner.user_readback,
-            btm_inner=self.phase.btm_inner.user_readback,
-            btm_outer=self.phase.btm_outer.user_readback,
-            gap=id_gap.user_readback,
+            top_outer=self.motors.phase.top_outer.user_readback,
+            top_inner=self.motors.phase.top_inner.user_readback,
+            btm_inner=self.motors.phase.btm_inner.user_readback,
+            btm_outer=self.motors.phase.btm_outer.user_readback,
+            gap=self.motors.gap.user_readback,
         )
         super().__init__(name)
 
@@ -420,24 +475,32 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         self._set_pol_setpoint(value)
         await self.set(await self.energy.get_value())
 
-    @abc.abstractmethod
     @AsyncStatus.wrap
     async def set(self, value: float) -> None:
         """
         Set should be in energy units, this will set the energy of the ID by setting the
         gap and phase motors to the correct position for the given energy
         and polarisation.
-        This method should be implemented by the beamline specific ID class as the
-        motor positions will be different for each beamline depending on the
-        undulator design and the lookup table used.
-        _set can be used to set the motor positions for the given energy and
-        polarisation provided that all motors can be moved at the same time.
+
 
         Examples
         --------
         RE( id.set(888.0)) # This will set the ID to 888 eV
         RE(scan([detector], id,600,700,100)) # This will scan the ID from 600 to 700 eV in 100 steps.
         """
+        await self._set(value)
+        self._set_energy_rbv(value)  # Update energy after move for readback.
+        LOGGER.info(f"Energy set to {value} eV successfully.")
+
+    @abc.abstractmethod
+    async def _set(self, value: float) -> None:
+        """
+        This method should be implemented by the beamline specific ID class as the
+        motor positions will be different for each beamline depending on the
+        undulator design and the lookup table used. The set method can be
+        used to set the motor positions for the given energy and polarisation
+        provided that all motors can be moved at the same time.
+        """
 
     def _read_pol(
         self,
@@ -468,36 +531,6 @@ class Apple2(abc.ABC, StandardReadable, Movable):
 
         return read_pol
 
-    async def _set(self, value: Apple2Val, energy: float) -> None:
-        """
-        Check ID is in a movable state and set all the demand value before moving them
-        all at the same time. This should be modified by the beamline specific ID class
-        , if the ID motors has to move in a specific order.
-        """
-
-        # Only need to check gap as the phase motors share both fault and gate with gap.
-        await self.gap.raise_if_cannot_move()
-        await asyncio.gather(
-            self.phase.top_outer.user_setpoint.set(value=value.top_outer),
-            self.phase.top_inner.user_setpoint.set(value=value.top_inner),
-            self.phase.btm_inner.user_setpoint.set(value=value.btm_inner),
-            self.phase.btm_outer.user_setpoint.set(value=value.btm_outer),
-            self.gap.user_setpoint.set(value=value.gap),
-        )
-        timeout = np.max(
-            await asyncio.gather(self.gap.get_timeout(), self.phase.get_timeout())
-        )
-        LOGGER.info(
-            f"Moving f{self.name} energy and polorisation to {energy}, {await self.polarisation.get_value()}"
-            + f"with motor position {value}, timeout = {timeout}"
-        )
-        await asyncio.gather(
-            self.gap.set_move.set(value=1, wait=False, timeout=timeout),
-            self.phase.set_move.set(value=1, wait=False, timeout=timeout),
-        )
-        await wait_for_value(self.gap.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
-        self._set_energy_rbv(energy)  # Update energy after move for readback.
-
     def determine_phase_from_hardware(
         self,
         top_outer: float,

dodal/devices/electron_analyser/abstract/__init__.py

@@ -1,5 +1,5 @@
 from .base_detector import (
-    AbstractElectronAnalyserDetector,
+    BaseElectronAnalyserDetector,
 )
 from .base_driver_io import AbstractAnalyserDriverIO, TAbstractAnalyserDriverIO
 from .base_region import (
@@ -19,7 +19,7 @@ __all__ = [
     "TAcquisitionMode",
     "TLensMode",
     "AbstractAnalyserDriverIO",
-    "AbstractElectronAnalyserDetector",
+    "BaseElectronAnalyserDetector",
     "AbstractAnalyserDriverIO",
     "TAbstractAnalyserDriverIO",
 ]

dodal/devices/electron_analyser/abstract/base_detector.py

@@ -1,4 +1,3 @@
-from abc import abstractmethod
 from typing import Generic
 
 from bluesky.protocols import Reading, Triggerable
@@ -9,14 +8,14 @@ from ophyd_async.core import (
     AsyncStatus,
     Device,
 )
+from ophyd_async.epics.adcore import ADBaseController
 
-from dodal.devices.controllers import ConstantDeadTimeController
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     TAbstractAnalyserDriverIO,
 )
 
 
-class AbstractElectronAnalyserDetector(
+class BaseElectronAnalyserDetector(
     Device,
     Triggerable,
     AsyncReadable,
@@ -34,43 +33,31 @@ class AbstractElectronAnalyserDetector(
 
     def __init__(
         self,
-        driver: TAbstractAnalyserDriverIO,
+        controller: ADBaseController[TAbstractAnalyserDriverIO],
         name: str = "",
     ):
-        self.controller = ConstantDeadTimeController(driver, 0)
+        self._controller = controller
         super().__init__(name)
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
-        await self.controller.arm()
-        await self.controller.wait_for_idle()
+        await self._controller.arm()
+        await self._controller.wait_for_idle()
 
     async def read(self) -> dict[str, Reading]:
-        return await self.driver.read()
+        return await self._controller.driver.read()
 
     async def describe(self) -> dict[str, DataKey]:
-        data = await self.driver.describe()
+        data = await self._controller.driver.describe()
         # Correct the shape for image
-        prefix = self.driver.name + "-"
-        energy_size = len(await self.driver.energy_axis.get_value())
-        angle_size = len(await self.driver.angle_axis.get_value())
+        prefix = self._controller.driver.name + "-"
+        energy_size = len(await self._controller.driver.energy_axis.get_value())
+        angle_size = len(await self._controller.driver.angle_axis.get_value())
         data[prefix + "image"]["shape"] = [angle_size, energy_size]
         return data
 
     async def read_configuration(self) -> dict[str, Reading]:
-        return await self.driver.read_configuration()
+        return await self._controller.driver.read_configuration()
 
     async def describe_configuration(self) -> dict[str, DataKey]:
-        return await self.driver.describe_configuration()
-
-    @property
-    @abstractmethod
-    def driver(self) -> TAbstractAnalyserDriverIO:
-        """
-        Define common property for all implementations to access the driver. Some
-        implementations will store this as a reference so it doesn't have conflicting
-        parents.
-
-        Returns:
-            instance of the driver.
-        """
+        return await self._controller.driver.describe_configuration()

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -153,11 +153,12 @@ class AbstractAnalyserDriverIO(
             self.energy_source.selected_source.set(region.excitation_energy_source)
         excitation_energy = await self.energy_source.energy.get_value()
 
-        # Copy region so doesn't alter the actual region and switch to kinetic energy
-        ke_region = region.model_copy()
-        ke_region.switch_energy_mode(EnergyMode.KINETIC, excitation_energy)
-
+        # Switch to kinetic energy as epics doesn't support BINDING.
+        ke_region = region.switch_energy_mode(EnergyMode.KINETIC, excitation_energy)
         await self._set_region(ke_region)
+        # Set the true energy mode from original region so binding_energy_axis can be
+        # calculated correctly.
+        await self.energy_mode.set(region.energy_mode)
 
     @abstractmethod
     async def _set_region(self, ke_region: TAbstractBaseRegion):

dodal/devices/electron_analyser/abstract/base_region.py

@@ -1,7 +1,7 @@
 import re
 from abc import ABC
 from collections.abc import Callable
-from typing import Generic, TypeVar
+from typing import Generic, Self, TypeVar
 
 from pydantic import BaseModel, Field, model_validator
 
@@ -88,28 +88,43 @@ class AbstractBaseRegion(
         return self.energy_mode == EnergyMode.KINETIC
 
     def switch_energy_mode(
-        self, energy_mode: EnergyMode, excitation_energy: float
-    ) -> None:
+        self, energy_mode: EnergyMode, excitation_energy: float, copy: bool = True
+    ) -> Self:
         """
-        Switch region to new energy mode: Kinetic or Binding. Updates the low_energy,
-        centre_energy, high_energy, and energy_mode, only if it switches to a new one.
+        Switch region with to a new energy mode with a new energy mode: Kinetic or Binding.
+        It caculates new values for low_energy, centre_energy, high_energy, via the
+        excitation enerrgy. It doesn't calculate anything if the region is already of
+        the same energy mode.
 
         Parameters:
-            energy_mode: mode you want to switch the region to.
-            excitation_energy: the energy to calculate the new values of low_energy,
-                               centre_energy, and high_energy.
+            energy_mode: Mode you want to switch the region to.
+            excitation_energy: Energy conversion for low_energy, centre_energy, and
+                               high_energy for new energy mode.
+            copy: Defaults to True. If true, create a copy of this region for the new
+                  energy_mode and return it. If False, alter this region for the
+                  energy_mode and return it self.
+
+        Returns:
+            Region with selected energy mode and new calculated energy values.
         """
+        switched_r = self.model_copy() if copy else self
         conv = (
             to_binding_energy
             if energy_mode == EnergyMode.BINDING
             else to_kinetic_energy
         )
-        self.low_energy = conv(self.low_energy, self.energy_mode, excitation_energy)
-        self.centre_energy = conv(
-            self.centre_energy, self.energy_mode, excitation_energy
+        switched_r.low_energy = conv(
+            switched_r.low_energy, switched_r.energy_mode, excitation_energy
         )
-        self.high_energy = conv(self.high_energy, self.energy_mode, excitation_energy)
-        self.energy_mode = energy_mode
+        switched_r.centre_energy = conv(
+            switched_r.centre_energy, switched_r.energy_mode, excitation_energy
+        )
+        switched_r.high_energy = conv(
+            switched_r.high_energy, switched_r.energy_mode, excitation_energy
+        )
+        switched_r.energy_mode = energy_mode
+
+        return switched_r
 
     @model_validator(mode="before")
     @classmethod

dodal/devices/electron_analyser/detector.py

@@ -1,14 +1,13 @@
 from typing import Generic, TypeVar
 
 from bluesky.protocols import Stageable
-from ophyd_async.core import (
-    AsyncStatus,
-    Reference,
-)
+from ophyd_async.core import AsyncStatus
+from ophyd_async.epics.adcore import ADBaseController
 
 from dodal.common.data_util import load_json_file_to_class
+from dodal.devices.controllers import ConstantDeadTimeController
 from dodal.devices.electron_analyser.abstract.base_detector import (
-    AbstractElectronAnalyserDetector,
+    BaseElectronAnalyserDetector,
 )
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     TAbstractAnalyserDriverIO,
@@ -20,35 +19,27 @@ from dodal.devices.electron_analyser.abstract.base_region import (
 
 
 class ElectronAnalyserRegionDetector(
-    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
     Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
 ):
     """
     Extends electron analyser detector to configure specific region settings before data
-    acqusition. This object must be passed in a driver and store it as a reference. It
-    is designed to only exist inside a plan.
+    acquisition. It is designed to only exist inside a plan.
     """
 
     def __init__(
         self,
-        driver: TAbstractAnalyserDriverIO,
+        controller: ADBaseController[TAbstractAnalyserDriverIO],
         region: TAbstractBaseRegion,
         name: str = "",
     ):
-        self._driver_ref = Reference(driver)
         self.region = region
-        super().__init__(driver, name)
-
-    @property
-    def driver(self) -> TAbstractAnalyserDriverIO:
-        # Store as a reference, this implementation will be given a driver so needs to
-        # make sure we don't get conflicting parents.
-        return self._driver_ref()
+        super().__init__(controller, name)
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
         # Configure region parameters on the driver first before data collection.
-        await self.driver.set(self.region)
+        await self._controller.driver.set(self.region)
         await super().trigger()
 
 
@@ -59,7 +50,7 @@ TElectronAnalyserRegionDetector = TypeVar(
 
 
 class ElectronAnalyserDetector(
-    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
     Stageable,
     Generic[
         TAbstractAnalyserDriverIO,
@@ -79,16 +70,11 @@ class ElectronAnalyserDetector(
         driver: TAbstractAnalyserDriverIO,
         name: str = "",
     ):
-        # Pass in driver
-        self._driver = driver
+        # Save driver as direct child so participates with connect()
+        self.driver = driver
         self._sequence_class = sequence_class
-        super().__init__(self.driver, name)
-
-    @property
-    def driver(self) -> TAbstractAnalyserDriverIO:
-        # This implementation creates the driver and wants this to be the parent so it
-        # can be used with connect() method.
-        return self._driver
+        controller = ConstantDeadTimeController[TAbstractAnalyserDriverIO](driver, 0)
+        super().__init__(controller, name)
 
     @AsyncStatus.wrap
     async def stage(self) -> None:
@@ -103,13 +89,13 @@ class ElectronAnalyserDetector(
         Raises:
             Any exceptions raised by the driver's stage or controller's disarm methods.
         """
-        await self.controller.disarm()
+        await self._controller.disarm()
         await self.driver.stage()
 
     @AsyncStatus.wrap
     async def unstage(self) -> None:
         """Disarm the detector."""
-        await self.controller.disarm()
+        await self._controller.disarm()
         await self.driver.unstage()
 
     def load_sequence(self, filename: str) -> TAbstractBaseSequence:
@@ -144,7 +130,9 @@ class ElectronAnalyserDetector(
         seq = self.load_sequence(filename)
         regions = seq.get_enabled_regions() if enabled_only else seq.regions
         return [
-            ElectronAnalyserRegionDetector(self.driver, r, self.name + "_" + r.name)
+            ElectronAnalyserRegionDetector(
+                self._controller, r, self.name + "_" + r.name
+            )
             for r in regions
         ]
 

dodal/devices/electron_analyser/specs/driver_io.py

@@ -66,7 +66,6 @@ class SpecsAnalyserDriverIO(
     async def _set_region(self, ke_region: SpecsRegion[TLensMode, TPsuMode]):
         await asyncio.gather(
             self.region_name.set(ke_region.name),
-            self.energy_mode.set(ke_region.energy_mode),
             self.low_energy.set(ke_region.low_energy),
             self.high_energy.set(ke_region.high_energy),
             self.slices.set(ke_region.slices),

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -74,7 +74,6 @@ class VGScientaAnalyserDriverIO(
     async def _set_region(self, ke_region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
         await asyncio.gather(
             self.region_name.set(ke_region.name),
-            self.energy_mode.set(ke_region.energy_mode),
             self.low_energy.set(ke_region.low_energy),
             self.centre_energy.set(ke_region.centre_energy),
             self.high_energy.set(ke_region.high_energy),

dodal/devices/fast_grid_scan.py

@@ -296,15 +296,15 @@ class FastGridScanThreeD(FastGridScanCommon[ParamType]):
     Subclasses must implement _create_position_counter.
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
-        full_prefix = prefix + "FGS:"
+    def __init__(self, prefix: str, infix: str, name: str = "") -> None:
+        full_prefix = prefix + infix
 
         # Number of vertical steps during the second grid scan, after the rotation in omega
-        self.z_steps = epics_signal_rw_rbv(int, f"{prefix}Z_NUM_STEPS")
-        self.z_step_size = epics_signal_rw_rbv(float, f"{prefix}Z_STEP_SIZE")
-        self.z2_start = epics_signal_rw_rbv(float, f"{prefix}Z2_START")
-        self.y2_start = epics_signal_rw_rbv(float, f"{prefix}Y2_START")
-        self.x_counter = epics_signal_r(int, f"{full_prefix}X_COUNTER")
+        self.z_steps = epics_signal_rw_rbv(int, f"{full_prefix}Z_NUM_STEPS")
+        self.z_step_size = epics_signal_rw_rbv(float, f"{full_prefix}Z_STEP_SIZE")
+        self.z2_start = epics_signal_rw_rbv(float, f"{full_prefix}Z2_START")
+        self.y2_start = epics_signal_rw_rbv(float, f"{full_prefix}Y2_START")
+        # panda does not have x counter
         self.y_counter = epics_signal_r(int, f"{full_prefix}Y_COUNTER")
 
         super().__init__(full_prefix, prefix, name)
@@ -343,10 +343,12 @@ class ZebraFastGridScanThreeD(FastGridScanThreeD[ZebraGridScanParamsThreeD]):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        full_prefix = prefix + "FGS:"
+        infix = "FGS:"
+        full_prefix = prefix + infix
         # Time taken to travel between X steps
         self.dwell_time_ms = epics_signal_rw_rbv(float, f"{full_prefix}DWELL_TIME")
-        super().__init__(prefix, name)
+        self.x_counter = epics_signal_r(int, f"{full_prefix}X_COUNTER")
+        super().__init__(prefix, infix, name)
         self.movable_params["dwell_time_ms"] = self.dwell_time_ms
 
     def _create_position_counter(self, prefix: str):
@@ -363,7 +365,8 @@ class PandAFastGridScan(FastGridScanThreeD[PandAGridScanParams]):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        full_prefix = prefix + "PGS:"
+        infix = "PGS:"
+        full_prefix = prefix + infix
         self.time_between_x_steps_ms = (
             epics_signal_rw_rbv(  # Used by motion controller to set goniometer velocity
                 float, f"{full_prefix}TIME_BETWEEN_X_STEPS"
@@ -375,7 +378,7 @@ class PandAFastGridScan(FastGridScanThreeD[PandAGridScanParams]):
         self.run_up_distance_mm = epics_signal_rw_rbv(
             float, f"{full_prefix}RUNUP_DISTANCE"
         )
-        super().__init__(prefix, name)
+        super().__init__(prefix, infix, name)
 
         self.movable_params["run_up_distance_mm"] = self.run_up_distance_mm