dls-dodal 1.44.0__py3-none-any.whl → 1.46.0__py3-none-any.whl

dodal/devices/{dcm.py → i03/dcm.py}

@@ -1,5 +1,5 @@
 import numpy as np
-from ophyd_async.core import Array1D, StandardReadable, soft_signal_r_and_setter
+from ophyd_async.core import Array1D, soft_signal_r_and_setter
 from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
 
@@ -8,9 +8,14 @@ from dodal.common.crystal_metadata import (
     MaterialsEnum,
     make_crystal_metadata_from_material,
 )
+from dodal.devices.common_dcm import (
+    BaseDCM,
+    PitchAndRollCrystal,
+    StationaryCrystal,
+)
 
 
-class DCM(StandardReadable):
+class DCM(BaseDCM[PitchAndRollCrystal, StationaryCrystal]):
     """
     A double crystal monochromator (DCM), used to select the energy of the beam.
 
@@ -30,13 +35,7 @@ class DCM(StandardReadable):
             MaterialsEnum.Si, (1, 1, 1)
         )
         with self.add_children_as_readables():
-            self.bragg_in_degrees = Motor(prefix + "BRAGG")
-            self.roll_in_mrad = Motor(prefix + "ROLL")
-            self.offset_in_mm = Motor(prefix + "OFFSET")
             self.perp_in_mm = Motor(prefix + "PERP")
-            self.energy_in_kev = Motor(prefix + "ENERGY")
-            self.pitch_in_mrad = Motor(prefix + "PITCH")
-            self.wavelength = Motor(prefix + "WAVELENGTH")
 
             # temperatures
             self.xtal1_temp = epics_signal_r(float, prefix + "TEMP1")
@@ -58,7 +57,4 @@ class DCM(StandardReadable):
                 Array1D[np.uint64],
                 initial_value=reflection_array,
             )
-            self.crystal_metadata_d_spacing = epics_signal_r(
-                float, prefix + "DSPACING:RBV"
-            )
-        super().__init__(name)
+        super().__init__(prefix, PitchAndRollCrystal, StationaryCrystal, name)

dodal/devices/{undulator_dcm.py → i03/undulator_dcm.py}

@@ -4,10 +4,9 @@ from bluesky.protocols import Movable
 from ophyd_async.core import AsyncStatus, Reference, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
-
-from ..log import LOGGER
-from .dcm import DCM
-from .undulator import Undulator
+from dodal.devices.i03.dcm import DCM
+from dodal.devices.undulator import Undulator
+from dodal.log import LOGGER
 
 ENERGY_TIMEOUT_S: float = 30.0
 
@@ -23,6 +22,9 @@ class UndulatorDCM(StandardReadable, Movable[float]):
     Calling unulator_dcm.set(energy) will move the DCM motor, perform a table lookup
     and move the Undulator gap motor if needed. So the set method can be thought of as
     a comprehensive way to set beam energy.
+
+    This class will be removed in the future. Use the separate Undulator and DCM devices
+    instead. See https://github.com/DiamondLightSource/dodal/issues/1092
     """
 
     def __init__(

dodal/devices/i10/diagnostics.py

@@ -0,0 +1,239 @@
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    Device,
+    StandardReadable,
+    StrictEnum,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.core._device import DeviceConnector
+from ophyd_async.epics.adaravis import AravisDriverIO
+from ophyd_async.epics.adcore import SingleTriggerDetector
+from ophyd_async.epics.core import (
+    epics_signal_r,
+    epics_signal_rw,
+)
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.current_amplifiers import (
+    CurrentAmpDet,
+    Femto3xxGainTable,
+    Femto3xxGainToCurrentTable,
+    Femto3xxRaiseTime,
+    FemtoDDPCA,
+    StruckScaler,
+)
+
+
+class D3Position(StrictEnum):
+    NOTHING = "Nothing"
+    GRID = "Grid"
+
+
+class D5Position(StrictEnum):
+    CELL_IN = "Cell In"
+    CELL_OUT = "Cell Out"
+
+
+class D5APosition(StrictEnum):
+    OUT_OF_THE_BEAM = "Out of the beam"
+    DIODE = "Diode"
+    BLADE = "Blade"
+    LA = "La ref"
+    GD = "Gd ref"
+    YB = "Yb ref"
+    GRID = "Grid"
+
+
+class D6Position(StrictEnum):
+    DIODE_OUT = "Diode Out"
+    DIODE_IN = "Diode In"
+    AU_MESH = "Au Mesh"
+
+
+class D7Position(StrictEnum):
+    OUT = "Out"
+    SHUTTER = "Shutter"
+
+
+class InOutTable(StrictEnum):
+    MOVE_IN = "Move In"
+    MOVE_OUT = "Move Out"
+    RESET = "Reset"
+
+
+class InOutReadBackTable(StrictEnum):
+    MOVE_IN = "Moving In"
+    MOVE_OUT = "Moving Out"
+    IN_BEAM = "In Beam"
+    FAULT = "Fault"
+    OUT_OF_BEAM = "Out of Beam"
+
+
+class Positioner(StandardReadable, Movable):
+    """1D stage with a enum table to select positions."""
+
+    def __init__(
+        self,
+        prefix: str,
+        positioner_enum: type[StrictEnum],
+        positioner_suffix: str = "",
+        Positioner_pv_suffix: str = ":MP:SELECT",
+        name: str = "",
+    ) -> None:
+        self._stage_motion = Motor(prefix=prefix + positioner_suffix)
+        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
+            self.stage_position = epics_signal_rw(
+                positioner_enum,
+                read_pv=prefix + positioner_suffix + Positioner_pv_suffix,
+            )
+        super().__init__(name=name)
+        self.positioner_enum = positioner_enum
+
+    @AsyncStatus.wrap
+    async def set(self, value: StrictEnum) -> None:
+        if value in self.positioner_enum:
+            await self.stage_position.set(value=value)
+        else:
+            raise ValueError(
+                f"{value} is not an allow position. Position must be: {self.positioner_enum}"
+            )
+
+
+class I10PneumaticStage(StandardReadable):
+    """Pneumatic stage only has two real positions in or out.
+    Use for fluorescent screen which can be insert into the x-ray beam.
+    Most often use in conjunction with a webcam to locate the x-ray beam."""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables(Format.HINTED_SIGNAL):
+            self.stage_position_set = epics_signal_rw(
+                InOutTable,
+                read_pv=prefix + "CON",
+            )
+            self.stage_position_readback = epics_signal_r(
+                InOutReadBackTable,
+                read_pv=prefix + "STA",
+            )
+        super().__init__(name=name)
+
+
+class ScreenCam(Device):
+    """Compound device of pneumatic stage(fluorescent screen) and webcam"""
+
+    def __init__(
+        self,
+        prefix: str,
+        cam_infix="DCAM:",
+        name: str = "",
+    ) -> None:
+        self.screen_stage = I10PneumaticStage(
+            prefix=prefix,
+        )
+        cam_pv = prefix + cam_infix
+        self.centroid_x = epics_signal_r(float, read_pv=f"{cam_pv}STAT:CentroidX_RBV")
+        self.centroid_y = epics_signal_r(float, read_pv=f"{cam_pv}STAT:CentroidY_RBV")
+        self.single_trigger_centroid = SingleTriggerDetector(
+            drv=AravisDriverIO(prefix=cam_pv + "CAM:"),
+            read_uncached=[
+                self.centroid_x,
+                self.centroid_y,
+            ],
+        )
+        super().__init__(name=name)
+
+
+class FullDiagnostic(Device):
+    """Compound device of a diagnostic with screen, webcam and Positioner stage."""
+
+    def __init__(
+        self,
+        prefix: str,
+        positioner_enum: type[StrictEnum],
+        positioner_suffix: str = "",
+        Positioner_pv_suffix: str = ":MP:SELECT",
+        cam_infix: str = "DCAM:",
+        name: str = "",
+    ) -> None:
+        self.positioner = Positioner(
+            prefix=prefix,
+            positioner_enum=positioner_enum,
+            positioner_suffix=positioner_suffix,
+            Positioner_pv_suffix=Positioner_pv_suffix,
+        )
+        self.screen = ScreenCam(
+            prefix,
+            cam_infix,
+            name,
+        )
+        super().__init__(name)
+
+
+class I10Diagnostic(Device):
+    """Collection of all the diagnostic stage on i10."""
+
+    def __init__(self, prefix, name: str = "") -> None:
+        self.d1 = ScreenCam(prefix=prefix + "PHDGN-01:")
+        self.d2 = ScreenCam(prefix=prefix + "PHDGN-02:")
+        self.d3 = FullDiagnostic(
+            prefix=prefix + "PHDGN-03:",
+            positioner_enum=D3Position,
+            positioner_suffix="DET:X",
+        )
+        self.d4 = ScreenCam(prefix=prefix + "PHDGN-04:")
+        self.d5 = Positioner(
+            prefix=prefix + "IONC-01:",
+            positioner_enum=D5Position,
+            positioner_suffix="Y",
+        )
+
+        self.d5A = Positioner(
+            prefix=prefix + "PHDGN-06:",
+            positioner_enum=D5APosition,
+            positioner_suffix="DET:X",
+        )
+
+        self.d6 = FullDiagnostic(
+            prefix=prefix + "PHDGN-05:",
+            positioner_enum=D6Position,
+            positioner_suffix="DET:X",
+        )
+        self.d7 = Positioner(
+            prefix=prefix + "PHDGN-07:",
+            positioner_enum=D7Position,
+            positioner_suffix="Y",
+        )
+        super().__init__(name)
+
+
+class I10Diagnostic5ADet(Device):
+    """Diagnostic 5a detection with drain current and photo diode"""
+
+    def __init__(
+        self, prefix: str, name: str = "", connector: DeviceConnector | None = None
+    ) -> None:
+        self.drain_current = CurrentAmpDet(
+            current_amp=FemtoDDPCA(
+                prefix=prefix + "IAMP-06:",
+                suffix="GAIN",
+                gain_table=Femto3xxGainTable,
+                gain_to_current_table=Femto3xxGainToCurrentTable,
+                raise_timetable=Femto3xxRaiseTime,
+            ),
+            counter=StruckScaler(prefix=prefix + "SCLR-02:SCALER2", suffix=".S17"),
+        )
+        self.diode = CurrentAmpDet(
+            FemtoDDPCA(
+                prefix=prefix + "IAMP-05:",
+                suffix="GAIN",
+                gain_table=Femto3xxGainTable,
+                gain_to_current_table=Femto3xxGainToCurrentTable,
+                raise_timetable=Femto3xxRaiseTime,
+            ),
+            counter=StruckScaler(prefix=prefix + "SCLR-02:SCALER2", suffix=".S18"),
+        )
+        super().__init__(name, connector)

dodal/devices/i10/slits.py

@@ -1,15 +1,21 @@
+from ophyd_async.core import Device
+from ophyd_async.core._device import DeviceConnector
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
 
-from dodal.devices.slits import Slits
+from dodal.devices.slits import MinimalSlits, Slits
 
 
-class I10Slits(Slits):
+class I10SlitsBlades(Slits):
+    """Slits with extra control for each blade."""
+
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
-            self.x_ring_blade = Motor(prefix + "XRING")
-            self.x_hall_blade = Motor(prefix + "XHALL")
-            self.y_top_blade = Motor(prefix + "YPLUS")
-            self.y_bot_blade = Motor(prefix + "YMINUS")
+            self.ring_blade = Motor(prefix + "XRING")
+            self.hall_blade = Motor(prefix + "XHALL")
+            self.top_blade = Motor(prefix + "YPLUS")
+            self.bot_blade = Motor(prefix + "YMINUS")
+
         super().__init__(
             prefix=prefix,
             x_gap="XSIZE",
@@ -20,7 +26,41 @@ class I10Slits(Slits):
         )
 
 
+class BladeDrainCurrents(Device):
+    """ "The drain current measurements on each blade. The drain current are due to
+    photoelectric effect (https://en.wikipedia.org/wiki/Photoelectric_effect).
+    Note the readings are in voltage as it is the output of a current amplifier."""
+
+    def __init__(
+        self,
+        prefix: str,
+        suffix_ring_blade: str = "SIG1",
+        suffix_hall_blade: str = "SIG2",
+        suffix_top_blade: str = "SIG3",
+        suffix_bot_blade: str = "SIG4",
+        name: str = "",
+        connector: DeviceConnector | None = None,
+    ) -> None:
+        self.ring_blade_current = epics_signal_r(
+            float, read_pv=prefix + suffix_ring_blade
+        )
+        self.hall_blade_current = epics_signal_r(
+            float, read_pv=prefix + suffix_hall_blade
+        )
+        self.top_blade_current = epics_signal_r(
+            float, read_pv=prefix + suffix_top_blade
+        )
+        self.bot_blade_current = epics_signal_r(
+            float, read_pv=prefix + suffix_bot_blade
+        )
+
+        super().__init__(name, connector)
+
+
 class I10PrimarySlits(Slits):
+    """First slits of the beamline with very high power load, they are two square water
+    cooled blocks(aperture/aptr) that overlap to produce slit like behavior."""
+
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
             self.x_aptr_1 = Motor(prefix + "APTR1:X")
@@ -35,3 +75,50 @@ class I10PrimarySlits(Slits):
             y_centre="YCENTRE",
             name=name,
         )
+
+
+class I10Slits(Device):
+    """Collection of all the i10 slits before end station."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.s1 = I10PrimarySlits(
+            prefix=prefix + "01:",
+        )
+        self.s2 = I10SlitsBlades(
+            prefix=prefix + "02:",
+        )
+        self.s3 = I10SlitsBlades(
+            prefix=prefix + "03:",
+        )
+        self.s4 = MinimalSlits(
+            prefix=prefix + "04:",
+            x_gap="XSIZE",
+            y_gap="YSIZE",
+        )
+        self.s5 = I10SlitsBlades(
+            prefix=prefix + "05:",
+        )
+        self.s6 = I10SlitsBlades(
+            prefix=prefix + "06:",
+        )
+        super().__init__(name=name)
+
+
+class I10SlitsDrainCurrent(Device):
+    """Collection of all the drain current from i10 slits."""
+
+    def __init__(
+        self, prefix: str, name: str = "", connector: DeviceConnector | None = None
+    ) -> None:
+        self.s2 = BladeDrainCurrents(
+            prefix=prefix + "AL-SLITS-02:",
+            suffix_ring_blade="XRING:I",
+            suffix_hall_blade="XHALL:I",
+            suffix_top_blade="YPLUS:I",
+            suffix_bot_blade="YMINUS:I",
+        )
+        self.s3 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-01:")
+        self.s4 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-02:")
+        self.s5 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-03:")
+        self.s6 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-04:")
+        super().__init__(name, connector)

dodal/devices/i13_1/merlin.py

@@ -23,10 +23,9 @@ class Merlin(StandardDetector):
         super().__init__(
             MerlinController(self.drv),
             adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
+                fileio=self.hdf,
+                path_provider=path_provider,
+                dataset_describer=adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_period, self.drv.acquire_time),
             name=name,

dodal/devices/i13_1/merlin_controller.py

@@ -37,7 +37,7 @@ class MerlinController(ADBaseController):
             DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
         )
         await asyncio.gather(
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.num_images.set(trigger_info.total_number_of_exposures),
             self.driver.image_mode.set(ADImageMode.MULTIPLE),
         )
 

dodal/devices/i19/blueapi_device.py

@@ -0,0 +1,102 @@
+import asyncio
+import json
+from enum import Enum
+from typing import TypeVar
+
+from aiohttp import ClientSession
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable
+
+from dodal.log import LOGGER
+
+OPTICS_BLUEAPI_URL = "https://i19-blueapi.diamond.ac.uk"
+HEADERS = {"Accept": "application/json", "Content-Type": "application/json"}
+
+D = TypeVar("D")
+
+
+class HutchState(str, Enum):
+    EH1 = "EH1"
+    EH2 = "EH2"
+
+
+class OpticsBlueAPIDevice(StandardReadable, Movable[D]):
+    """General device that a REST call to the blueapi instance controlling the optics \
+    hutch running on the I19 cluster, which will evaluate the current hutch in use vs \
+    the hutch sending the request and decide if the plan will be run or not.
+
+    For details see the architecture described in \
+    https://github.com/DiamondLightSource/i19-bluesky/issues/30.
+    """
+
+    def __init__(self, name: str = "") -> None:
+        self.url = OPTICS_BLUEAPI_URL
+        self.headers = HEADERS
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: D):
+        """ On set send a POST request to the optics blueapi with the name and \
+        parameters, gets the generated task_id and then sends a PUT request that runs \
+        the plan.
+
+        Args:
+            value (dict): The value passed here should be the parameters for the POST \
+                request, taking the form:
+                {
+                    "name": "plan_name",
+                    "params": {
+                        "experiment_hutch": f"{hutch_name}",
+                        "access_device": "access_control",
+                        "other_params": "...",
+                        ...
+                    }
+                }
+        """
+        # Value here vould be request params dictionary.
+        request_params = json.dumps(value)
+
+        async with ClientSession(base_url=self.url, raise_for_status=True) as session:
+            # First submit the plan to the worker
+            async with session.post(
+                "/tasks", data=request_params, headers=HEADERS
+            ) as response:
+                LOGGER.info(
+                    f"Task submitted to the worker, response status: {response.status}"
+                )
+
+                try:
+                    data = await response.json()
+                    task_id = data["task_id"]
+                except Exception as e:
+                    LOGGER.error(
+                        f"Failed to get task_id from {self.url}/tasks POST. ({e})"
+                    )
+                    raise
+            # Then set the task as active and run asap
+            async with session.put(
+                "/worker/task", data=json.dumps({"task_id": task_id}), headers=HEADERS
+            ) as response:
+                if not response.ok:
+                    LOGGER.error(
+                        f"""Session PUT responded with {response.status}: {response.reason}.
+                        Unable to run plan {value["name"]}."""  # type: ignore
+                    )
+                    return
+                LOGGER.info(f"Running plan: {value['name']}, task_id: {task_id}")  # type: ignore
+
+            # Poll server at 2Hz until plan complete or errored
+            interval = 0.5
+            plan_complete = False
+
+            while not plan_complete:
+                async with session.get(f"/tasks/{task_id}") as res:
+                    plan_result = await res.json()
+                    plan_complete = plan_result["is_complete"]
+                    errors = plan_result["errors"]
+                    if len(errors) > 0:
+                        message = "\n".join(errors)
+                        LOGGER.error(f"Plan {value['name']} failed: {message}")  # type:ignore
+                        raise RuntimeError(f"Plan failed with error: {message}")
+                await asyncio.sleep(interval)
+            LOGGER.info(f"Plan {value['name']} done.")  # type: ignore

dodal/devices/i19/shutter.py

@@ -1,23 +1,12 @@
-from enum import Enum
-
-from aiohttp import ClientSession
-from bluesky.protocols import Movable
-from ophyd_async.core import AsyncStatus, StandardReadable, StandardReadableFormat
+from ophyd_async.core import AsyncStatus, StandardReadableFormat
 from ophyd_async.epics.core import epics_signal_r
 
 from dodal.devices.hutch_shutter import ShutterDemand, ShutterState
+from dodal.devices.i19.blueapi_device import HutchState, OpticsBlueAPIDevice
 from dodal.devices.i19.hutch_access import ACCESS_DEVICE_NAME
-from dodal.log import LOGGER
-
-OPTICS_BLUEAPI_URL = "https://i19-blueapi.diamond.ac.uk"
-
 
-class HutchState(str, Enum):
-    EH1 = "EH1"
-    EH2 = "EH2"
 
-
-class AccessControlledShutter(StandardReadable, Movable[ShutterDemand]):
+class AccessControlledShutter(OpticsBlueAPIDevice):
     """ I19-specific device to operate the hutch shutter.
 
     This device will send a REST call to the blueapi instance controlling the optics \
@@ -37,7 +26,6 @@ class AccessControlledShutter(StandardReadable, Movable[ShutterDemand]):
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.shutter_status = epics_signal_r(ShutterState, f"{prefix}STA")
         self.hutch_request = hutch
-        self.url = OPTICS_BLUEAPI_URL
         super().__init__(name)
 
     @AsyncStatus.wrap
@@ -47,33 +35,7 @@ class AccessControlledShutter(StandardReadable, Movable[ShutterDemand]):
             "params": {
                 "experiment_hutch": self.hutch_request.value,
                 "access_device": ACCESS_DEVICE_NAME,
-                "shutter_demand": value,
+                "shutter_demand": value.value,
             },
         }
-        async with ClientSession(base_url=self.url, raise_for_status=True) as session:
-            # First submit the plan to the worker
-            async with session.post("/tasks", data=REQUEST_PARAMS) as response:
-                LOGGER.debug(
-                    f"Task submitted to the worker, response status: {response.status}"
-                )
-
-                try:
-                    data = await response.json()
-                    task_id = data["task_id"]
-                except Exception as e:
-                    LOGGER.error(
-                        f"Failed to get task_id from {self.url}/tasks POST. ({e})"
-                    )
-                    raise
-            # Then set the task as active and run asap
-            async with session.put(
-                "/worker/tasks", data={"task_id": task_id}
-            ) as response:
-                if not response.ok:
-                    LOGGER.error(
-                        f"""Unable to operate the shutter.
-                        Session PUT responded with {response.status}: {response.reason}.
-                        """
-                    )
-                    return
-                LOGGER.debug(f"Run operate shutter plan, task_id: {task_id}")
+        await super().set(REQUEST_PARAMS)