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

dodal/devices/undulator.py

@@ -5,6 +5,7 @@ from bluesky.protocols import Movable
 from numpy import ndarray
 from ophyd_async.core import (
     AsyncStatus,
+    Reference,
     StandardReadable,
     StandardReadableFormat,
     soft_signal_r_and_setter,
@@ -15,6 +16,7 @@ from ophyd_async.epics.motor import Motor
 from dodal.common.enums import EnabledDisabledUpper
 from dodal.log import LOGGER
 
+from .baton import Baton
 from .util.lookup_tables import energy_distance_table
 
 
@@ -22,11 +24,6 @@ class AccessError(Exception):
     pass
 
 
-# Enable to allow testing when the beamline is down, do not change in production!
-TEST_MODE = False
-# will be made more generic in https://github.com/DiamondLightSource/dodal/issues/754
-
-
 # The acceptable difference, in mm, between the undulator gap and the DCM
 # energy, when the latter is converted to mm using lookup tables
 UNDULATOR_DISCREPANCY_THRESHOLD_MM = 2e-3
@@ -54,6 +51,7 @@ class Undulator(StandardReadable, Movable[float]):
         name: str = "",
         poles: int | None = None,
         length: float | None = None,
+        baton: Baton | None = None,
     ) -> None:
         """Constructor
 
@@ -64,6 +62,7 @@ class Undulator(StandardReadable, Movable[float]):
             name (str, optional): Name for device. Defaults to "".
         """
 
+        self.baton_ref = Reference(baton) if baton else None
         self.id_gap_lookup_table_path = id_gap_lookup_table_path
         with self.add_children_as_readables():
             self.gap_motor = Motor(prefix + "BLGAPMTR")
@@ -105,7 +104,8 @@ class Undulator(StandardReadable, Movable[float]):
 
     async def raise_if_not_enabled(self):
         access_level = await self.gap_access.get_value()
-        if access_level is EnabledDisabledUpper.DISABLED and not TEST_MODE:
+        commissioning_mode = await self._is_commissioning_mode_enabled()
+        if access_level is EnabledDisabledUpper.DISABLED and not commissioning_mode:
             raise AccessError("Undulator gap access is disabled. Contact Control Room")
 
     async def _set_undulator_gap(self, energy_kev: float) -> None:
@@ -124,21 +124,25 @@ class Undulator(StandardReadable, Movable[float]):
                 f"Undulator gap mismatch. {difference:.3f}mm is outside tolerance.\
                 Moving gap to nominal value, {target_gap:.3f}mm"
             )
-            if not TEST_MODE:
+            commissioning_mode = await self._is_commissioning_mode_enabled()
+            if not commissioning_mode:
                 # Only move if the gap is sufficiently different to the value from the
-                # DCM lookup table AND we're not in TEST_MODE
+                # DCM lookup table AND we're not in commissioning mode
                 await self.gap_motor.set(
                     target_gap,
                     timeout=STATUS_TIMEOUT_S,
                 )
             else:
-                LOGGER.debug("In test mode, not moving ID gap")
+                LOGGER.warning("In test mode, not moving ID gap")
         else:
             LOGGER.debug(
                 "Gap is already in the correct place for the new energy value "
                 f"{energy_kev}, no need to ask it to move"
             )
 
+    async def _is_commissioning_mode_enabled(self):
+        return self.baton_ref and await self.baton_ref().commissioning.get_value()
+
     async def _get_gap_to_match_energy(self, energy_kev: float) -> float:
         """
         get a 2d np.array from lookup table that

dodal/devices/v2f.py

@@ -0,0 +1,39 @@
+from ophyd_async.core import StandardReadable, StandardReadableFormat, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+
+class V2FGain(StrictEnum):
+    LOW_NOISE3 = "10^3 low noise"
+    LOW_NOISE4 = "10^4 low noise"
+    LOW_NOISE5 = "10^5 low noise"
+    LOW_NOISE6 = "10^6 low noise"
+    LOW_NOISE7 = "10^7 low noise"
+    LOW_NOISE8 = "10^8 low noise"
+    LOW_NOISE9 = "10^9 low noise"
+    HIGHSPEED5 = "10^5 high speed"
+    HIGHSPEED6 = "10^6 high speed"
+    HIGHSPEED7 = "10^7 high speed"
+    HIGHSPEED8 = "10^8 high speed"
+    HIGHSPEED9 = "10^9 high speed"
+    HIGHSPEED10 = "10^10 high spd"
+    HIGHSPEED11 = "10^11 high spd"
+
+
+class QDV2F(StandardReadable):
+    """
+    A Quantum Detectors V2F low noise voltage to frequency converter.
+    Two channel V2F - 50mHz
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        I_suffix="I",
+    ) -> None:
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.intensity = epics_signal_r(float, f"{prefix}{I_suffix}")
+        with self.add_children_as_readables():
+            self.gain = epics_signal_rw(V2FGain, f"{prefix}GAIN")
+
+        super().__init__(name)

dodal/devices/xbpm_feedback.py

@@ -1,8 +1,10 @@
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, Device, StrictEnum, observe_value
+from ophyd_async.core import AsyncStatus, Device, Reference, StrictEnum, observe_value
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.common.device_utils import periodic_reminder
+from dodal.devices.baton import Baton
+from dodal.log import LOGGER
 
 
 class Pause(StrictEnum):
@@ -14,15 +16,19 @@ class XBPMFeedback(Device, Triggerable):
     """The XBPM feedback device is an IOC that moves the DCM, HFM and VFM to automatically
     hold the beam into place, as measured by the XBPM sensor."""
 
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(self, prefix: str, name: str = "", baton: Baton | None = None) -> None:
         self.pos_ok = epics_signal_r(float, prefix + "XBPM2POSITION_OK")
         self.pos_stable = epics_signal_r(float, prefix + "XBPM2_STABLE")
         self.pause_feedback = epics_signal_rw(Pause, prefix + "FB_PAUSE")
+        self.baton_ref = Reference(baton) if baton else None
         super().__init__(name=name)
 
     @AsyncStatus.wrap
     async def trigger(self):
-        async with periodic_reminder("Waiting for XBPM"):
-            async for value in observe_value(self.pos_stable):
-                if value:
-                    return
+        if self.baton_ref and await self.baton_ref().commissioning.get_value():
+            LOGGER.warning("Commissioning mode enabled, ignoring feedback")
+        else:
+            async with periodic_reminder("Waiting for XBPM"):
+                async for value in observe_value(self.pos_stable):
+                    if value:
+                        return

dodal/devices/zebra/zebra.py

@@ -82,6 +82,7 @@ class ArmDemand(Enum):
     DISARM = 0
 
 
+# Replace with ophyd-async enum after https://github.com/bluesky/ophyd-async/pull/1067
 class SoftInState(StrictEnum):
     YES = "Yes"
     NO = "No"

dodal/devices/zebra/zebra_constants_mapping.py

@@ -77,7 +77,7 @@ class ZebraMapping(ZebraMappingValidations):
     Zebra's hardware configuration and wiring.
     """
 
-    # Zebra ophyd signal for connection can be accessed
+    # Zebra ophyd signal for output can be accessed
     # with, eg, zebra.output.out_pvs[zebra.mapping.outputs.TTL_DETECTOR]
     outputs: ZebraTTLOutputs = ZebraTTLOutputs()
 

dodal/parameters/experiment_parameter_base.py

@@ -1,4 +1,4 @@
-from abc import ABC, abstractmethod
+from abc import ABC
 
 from pydantic import BaseModel
 
@@ -9,7 +9,3 @@ class AbstractExperimentParameterBase(BaseModel, ABC):
 
 class AbstractExperimentWithBeamParams(AbstractExperimentParameterBase):
     transmission_fraction: float
-
-    @abstractmethod
-    def get_num_images(self) -> int:
-        pass