dls-dodal 1.36.1a0__py3-none-any.whl → 1.36.2__py3-none-any.whl

{dls_dodal-1.36.1a0.dist-info → dls_dodal-1.36.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.36.1a0
+Version: 1.36.2
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License

{dls_dodal-1.36.1a0.dist-info → dls_dodal-1.36.2.dist-info}/RECORD

@@ -1,14 +1,14 @@
 dodal/__init__.py,sha256=Ksms_WJF8LTkbm38gEpm1jBpGqcQ8NGvmb2ZJlOE1j8,198
 dodal/__main__.py,sha256=kP2S2RPitnOWpNGokjZ1Yq-1umOtp5sNOZk2B3tBPLM,111
-dodal/_version.py,sha256=ktA0kNTYPVSWYOxui27Mnyui4C-Y9QFQo0LpESSVdeo,415
-dodal/adsim.py,sha256=OW2dcS7ciD4Yq9WFw4PN_c5Bwccrmu7R-zr-u6ZCbQM,497
+dodal/_version.py,sha256=eqat9FvXyrftwP2dajRS3LWZiDD9Pay4_MD5eY1_jxU,413
 dodal/cli.py,sha256=NieWNUgLUxyck1rHoFAPJjX1xXLzHNdQ-s4wvxYFfps,3757
 dodal/log.py,sha256=0to7CRsbzbgVfAAfKRAMhsaUuKqF2-7CGdQc-z8Uhno,9499
 dodal/utils.py,sha256=h2sNmTlsaznfxusV1Xj_mXtNjzsWjWAgmps6I0YNA3U,18097
 dodal/beamline_specific_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dodal/beamline_specific_utils/i03.py,sha256=P6Ls4FoVtcacH0RJM3v6ZwwGx27oMppcBdW0la-ohTY,377
 dodal/beamlines/README.md,sha256=K9MkL_GomxlsoTB7Mz-_dJA5NNSbmCfMiutchGg3C8o,404
-dodal/beamlines/__init__.py,sha256=WWXqkXkufRUNFSC_b0PoHSkyKo7Tn8wNmnQCr9klh2o,3054
+dodal/beamlines/__init__.py,sha256=FsS1hMz9nqwTP12UtCJsfVn712mFElcBq2kKKpscp9k,3074
+dodal/beamlines/adsim.py,sha256=DUAFS1ueoZ6DK2cmZkiEm3NElnaro1mUvyodv14pSmU,1839
 dodal/beamlines/b01_1.py,sha256=0gLjg0O9ttMjHzszSyJ_GT3fnoAB6u4aJ4MdAfjJbHA,1788
 dodal/beamlines/i03.py,sha256=WOMkGTcrrKqoBNeRObumMA8Nlo404uIr2ccfn8gK-zs,18063
 dodal/beamlines/i04.py,sha256=z8LUbhyfUDU08oSp85hg7hFE8FJkAyLsqPUQScs5SUA,14567
@@ -17,7 +17,7 @@ dodal/beamlines/i13_1.py,sha256=csXHrdwUh4sXTmb4X6ZiiSS_XxRkNShsVoBMxYI6rG0,1833
 dodal/beamlines/i20_1.py,sha256=MaPgONHqpoZuBtkiKEzYtViJnKBM2_ekeP4OdbmuXHE,1158
 dodal/beamlines/i22.py,sha256=tzx8w86uvJHo5TuwPoIUErB7C5mGhqTzlv45qrppld0,7228
 dodal/beamlines/i23.py,sha256=2j5qLoqE_hg9ETHqNkOVu7LLkVB8qalgXeORnVYKN_I,1075
-dodal/beamlines/i24.py,sha256=V0MMr9bS-4c3fzSQL2gK6zCOT0ft1AV6VWBrnLAn5fk,8011
+dodal/beamlines/i24.py,sha256=w9xkufc7CluVj5nvQww1B7k8VN5RzNQ6AsX8bfyAi9k,8544
 dodal/beamlines/p38.py,sha256=JJbclLYoRdIxcpzpW4oTj77YJ001CdEAM0bKRk7seYI,8735
 dodal/beamlines/p45.py,sha256=N4SDTIFok3uMqb37higZHMr3xRjxItsT4ib_KacKKAE,2935
 dodal/beamlines/p99.py,sha256=I6c_3NbvEPOpy2z1uwLRqwCkd83Sf15-OXEykLkn0-c,910
@@ -36,11 +36,11 @@ dodal/common/beamlines/beamline_utils.py,sha256=LCUt58Y2wRd15PdMIYSeHiKhWVYgt6UC
 dodal/common/beamlines/device_helpers.py,sha256=aFzYa4YOPcbrvwoW1k3OrN6NVLYYmMPR8YkCpHHe-98,962
 dodal/devices/CTAB.py,sha256=5_261Ox6NG2cJIzzwnjWz289BG0nZoE0wKOaI5V5jqM,1998
 dodal/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dodal/devices/adsim.py,sha256=dMU0TKIuiODHYFHQOH4_5UvB8iJtaJEtjqaEDGjcU-w,311
-dodal/devices/aperture.py,sha256=VefMpkOXJ36vv2F9uNxFwIEyDMcXiImArcK1zA_ctmU,774
-dodal/devices/aperturescatterguard.py,sha256=DoSH7TFJt7rXA17eChlGnv9_GsWz1R6s_EigGayPEOM,13007
+dodal/devices/adsim.py,sha256=vCexraF4zLssHdjfPod-XuQGJE_sWoCttFdx__HDS8w,488
+dodal/devices/aperture.py,sha256=yyw2ei3gM_lmZWDQ6VTbydB58RCDTen_nqBZyoTP2IM,583
+dodal/devices/aperturescatterguard.py,sha256=PRNnGbxYKFWoa1m70Mz-6Ta4NtFG0ShUprBvv2viUeI,8993
 dodal/devices/apple2_undulator.py,sha256=HtjHiDX80n_nzabuFcUioH-gWH1a6VjZzw_xStq7S4w,22470
-dodal/devices/attenuator.py,sha256=6IAPr8XmLxUOHC8g7Zt8MR1trMEDOxO5JkLphd6LbRg,2582
+dodal/devices/attenuator.py,sha256=SEDnnNeUpwBArJbPcwHyr5BwkHO1Jvgsrw1bpFz5u-o,2894
 dodal/devices/backlight.py,sha256=nQIr3J-I-OXnOUoWmr3ruy3nhq_q2US1KXC4NrGG_2U,1634
 dodal/devices/cryostream.py,sha256=K-ldpredpeDTzNt4qtQMg99nKJNjBYoXBbK0WJGexzw,656
 dodal/devices/dcm.py,sha256=JbyxLnrS68nnnv39l9XEWgJgXUBqxX6aFo19MZnL36E,2574
@@ -50,7 +50,7 @@ dodal/devices/eiger_odin.py,sha256=oZl16K-Qb2yL6tK1fyDQvqbbhhvYMSVcf_e2CjlqMa4,7
 dodal/devices/fast_grid_scan.py,sha256=dKF2-8CNmm-LaMXBkqkO31pTcAAwiAXznEeB6tg0f6E,11149
 dodal/devices/fluorescence_detector_motion.py,sha256=-1qCSvW0PdT0m6BcoLxrtc0OJ5UDIBsEe11EOLr-gFw,501
 dodal/devices/flux.py,sha256=RtPStHw7Mad0igVKntKWVZfuZn2clokVJqH14HLix6M,198
-dodal/devices/focusing_mirror.py,sha256=yz0MIeqLtg-Ga5M-AF1S3fsHgaHn_9b1bv9zA5OqsEk,6262
+dodal/devices/focusing_mirror.py,sha256=vdUPkwyCAZBSR3LQ-EojDOoxVy1ZmOaD_nevETbj7BA,6592
 dodal/devices/hutch_shutter.py,sha256=WXY9JwqAa5prbf72IP7_MTKndPDtAltCpPJlNbq-F_0,3313
 dodal/devices/ipin.py,sha256=eq5jlKw7WGQi8VLrAWpaAIsZmfiVf-5Q0td_B22H6A4,473
 dodal/devices/linkam3.py,sha256=O1ufCb5ce6nfGXVwiO3I1WEnZ_Jp0azWxBcrZ7PWQm4,3869
@@ -72,16 +72,12 @@ dodal/devices/tetramm.py,sha256=460luDYab-u1QB0CPe7lPihtm9nZxdCDGtLPnXI-XGo,8447
 dodal/devices/thawer.py,sha256=4t4yF4VDIrT_tQ8RwjmXe_hDMwVjR8A-4rDkPx19b28,1672
 dodal/devices/turbo_slit.py,sha256=B6SPXqviMnG-U4PnUF1BdTO0LBKmTuwAUKRbxMiNJXo,1125
 dodal/devices/undulator.py,sha256=rQjDhrvgf4uXUEO17CiLopNDEagWOgkmpa02BarozDE,5295
-dodal/devices/undulator_dcm.py,sha256=OJBxUe2LlQkGdydWIa1kzR07UnEz8QcHQjE-gB3kUWE,2238
+dodal/devices/undulator_dcm.py,sha256=4Y1ZgKatBenQgg4DuZnMtKwLDOH2YvUMo1QkFE0aaXs,2432
 dodal/devices/watsonmarlow323_pump.py,sha256=rwU94YE6esgGLYdh-pe8nBo_3tvgp6brrrbPDrqp5_M,1406
 dodal/devices/webcam.py,sha256=mef075ynDbzZ4pNAjfxR_9tdTTqF_rM7hAOVEEOV-Do,2408
 dodal/devices/xbpm_feedback.py,sha256=j8MHhhE0feoe6R54zPKqS5EbQ0bEDR-nOpLHzHhnHHQ,1156
 dodal/devices/zebra.py,sha256=p191eIGfmwM2EE1YJn6rRgChim2kqXl2KIYbMPUSOvg,9474
 dodal/devices/zebra_controlled_shutter.py,sha256=5-SH5HoXp_6P-xAtfDFJKQq6mBDwreubuCULSz78fgw,1852
-dodal/devices/areadetector/__init__.py,sha256=8IwLxuZMW0MOJpJp_ZDdlaE20hrtsH_PXWGaKgMiYs4,240
-dodal/devices/areadetector/adaravis.py,sha256=Cqw_Mzrp_zODFxQ2LZBJzHp_DsZ6_dAITkZz8gYz_0w,3797
-dodal/devices/areadetector/adsim.py,sha256=cIc9PRbKnftBk7Ut8d8CU_TVrin8EwcKHObP2n9VxWM,1876
-dodal/devices/areadetector/adutils.py,sha256=4axFR3wtn-K-sjMVJyfTcu-8g35odf2cY8mTKv1gS-o,3093
 dodal/devices/areadetector/plugins/CAM.py,sha256=sZzJm5Ez3eWfXZi_EB67wluhZmMQm1UyOc2bJFfzd1U,964
 dodal/devices/areadetector/plugins/MJPG.py,sha256=QTsxCoWbofNpLMGPoOR2hWoM33KyntuLepbF0YmX0KE,3031
 dodal/devices/detector/__init__.py,sha256=-RdACL3tzc3lLArWOoGNje48UUlv2fElOmGOz9yOuO0,317
@@ -116,7 +112,7 @@ dodal/devices/oav/oav_detector.py,sha256=lUzdkAgviBtiZkN92fA_kleQRmmpfx_wTA06rq-
 dodal/devices/oav/oav_parameters.py,sha256=gGN73TQGUiRzlIO5YKiqCRkjpTKsV6LFGo7Eu4Vs82g,6074
 dodal/devices/oav/oav_to_redis_forwarder.py,sha256=pfhaW6Uo_1wDNfywyPkS5UTrY8yhkerhjgJfRMqrJRA,6259
 dodal/devices/oav/utils.py,sha256=3IvSTw6Ygkaz4Hzoz0eU2l6mljpq0NO57M15e-K4jOE,3182
-dodal/devices/oav/pin_image_recognition/__init__.py,sha256=lkfEd7NdnoCR7yX03wsp-rsL0BqpzZVYh-24QO4fYio,6562
+dodal/devices/oav/pin_image_recognition/__init__.py,sha256=_eCq-rEtGNXVfrpahfKMLu53lEr49q5rtVqg0GhiODQ,6534
 dodal/devices/oav/pin_image_recognition/manual_test.py,sha256=h1Rto6ZDCB3jWhjSy9N8ECxRN583iYDJr9LxrTJ8kfE,903
 dodal/devices/oav/pin_image_recognition/utils.py,sha256=L9ypluYqeOFoS7gQuws-vTNc8LqaKl2ZIDNeQ2JaNpg,8592
 dodal/devices/oav/snapshots/grid_overlay.py,sha256=CdvCdTKMCiwMwxm2lV28KpcIUSXlscZmWxb73_KKmiI,3694
@@ -148,9 +144,9 @@ dodal/plan_stubs/wrapped.py,sha256=nriHKX4BF010CmrhdoUhY3-txClW5W8TPLz64kE_AXU,4
 dodal/plans/__init__.py,sha256=nH1jNxw3DzDMg9O8Uda0kqKIalRVEWBrq07OLY6Ey38,93
 dodal/plans/scanspec.py,sha256=Q0AcvTKRT401iGMRDSqK-D523UX5_ofiVMZ_rNXKOx8,2074
 dodal/plans/wrapped.py,sha256=Cr2iOpQCuk2ORKo5CZOh-zbQXAjoTfaLrfm7r1--GhU,2098
-dls_dodal-1.36.1a0.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-dls_dodal-1.36.1a0.dist-info/METADATA,sha256=Du63G1abjqQlRwGNTbqO-QoFfAcTJ9ovv6VNkdaQVlc,16657
-dls_dodal-1.36.1a0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-dls_dodal-1.36.1a0.dist-info/entry_points.txt,sha256=bycw_EKUzup_rxfCetOwcauXV4kLln_OPpPT8jEnr-I,94
-dls_dodal-1.36.1a0.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
-dls_dodal-1.36.1a0.dist-info/RECORD,,
+dls_dodal-1.36.2.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+dls_dodal-1.36.2.dist-info/METADATA,sha256=CWBsjskEIuoboOXY_f3RJ4xuoDWdR5c9RhDjsuqNL3w,16655
+dls_dodal-1.36.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+dls_dodal-1.36.2.dist-info/entry_points.txt,sha256=bycw_EKUzup_rxfCetOwcauXV4kLln_OPpPT8jEnr-I,94
+dls_dodal-1.36.2.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
+dls_dodal-1.36.2.dist-info/RECORD,,

dodal/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.36.1a0'
-__version_tuple__ = version_tuple = (1, 36, 1)
+__version__ = version = '1.36.2'
+__version_tuple__ = version_tuple = (1, 36, 2)

dodal/beamlines/__init__.py

@@ -16,6 +16,7 @@ _BEAMLINE_NAME_OVERRIDES = {
     "p47": "training_rig",
     "p48": "training_rig",
     "p49": "training_rig",
+    "t01": "adsim",
 }
 
 

dodal/beamlines/adsim.py

@@ -0,0 +1,75 @@
+from pathlib import Path
+
+from ophyd_async.epics.adsimdetector import SimDetector
+
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+    get_path_provider,
+    set_path_provider,
+)
+from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
+from dodal.devices.adsim import SimStage
+from dodal.log import set_beamline as set_log_beamline
+from dodal.utils import BeamlinePrefix
+
+BL = "adsim"
+PREFIX = BeamlinePrefix("t01")
+set_log_beamline(BL)
+set_utils_beamline(BL)
+
+set_path_provider(
+    StaticVisitPathProvider(
+        BL,
+        Path("/tmp"),
+        client=LocalDirectoryServiceClient(),
+    )
+)
+
+"""
+Beamline module for use with the simulated AreaDetector and motors.
+These devices are simulated at the EPICS level, enabling testing of
+dodal and ophyd-async against what appear to be "real" signals.
+
+Usage Example
+-------------
+
+Start the simulated beamline by following the epics-containers tutorial at
+https://epics-containers.github.io/main/tutorials/launch_example.html
+And ensure that the signals are visible:
+
+```sh
+export EPICS_CA_ADDR_LIST=127.0.0.1
+```
+
+How to use the devices in a plan:
+In an ipython terminal run:
+
+```python
+from bluesky.run_engine import RunEngine
+
+from dodal.beamlines.adsim import det, stage
+from dodal.plans import count
+
+RE = RunEngine()
+d = det(connect_immediately=True)
+s = stage(connect_immediately=True)
+RE(count([d], num=10))
+```
+
+"""
+
+
+@device_factory()
+def stage() -> SimStage:
+    return SimStage(f"{PREFIX.beamline_prefix}-MO-SIMC-01:")
+
+
+@device_factory()
+def det() -> SimDetector:
+    return SimDetector(
+        f"{PREFIX.beamline_prefix}-DI-CAM-01:",
+        path_provider=get_path_provider(),
+        drv_suffix="DET:",
+        hdf_suffix="HDF:",
+    )

dodal/beamlines/i24.py

@@ -1,5 +1,6 @@
 from dodal.common.beamlines.beamline_utils import BL, device_instantiation
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.devices.attenuator import ReadOnlyAttenuator
 from dodal.devices.detector import DetectorParams
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.hutch_shutter import HutchShutter
@@ -29,6 +30,21 @@ set_log_beamline(BL)
 set_utils_beamline(BL)
 
 
+def attenuator(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> ReadOnlyAttenuator:
+    """Get a read-only attenuator device for i24, instantiate it if it hasn't already
+    been. If this is called when already instantiated in i24, it will return the
+    existing object."""
+    return device_instantiation(
+        ReadOnlyAttenuator,
+        "attenuator",
+        "-OP-ATTN-01:",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+    )
+
+
 def aperture(
     wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
 ) -> Aperture:

dodal/devices/adsim.py

@@ -1,13 +1,13 @@
-from ophyd import Component, EpicsMotor, MotorBundle
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
 
 
-class SimStage(MotorBundle):
-    """
-    ADSIM EPICS motors
-    """
+class SimStage(StandardReadable):
+    """Simulated Sample Stage for use with the containerised simulated beamline
+    https://github.com/epics-containers/example-services"""
 
-    x = Component(EpicsMotor, "M1")
-    y = Component(EpicsMotor, "M2")
-    z = Component(EpicsMotor, "M3")
-    theta = Component(EpicsMotor, "M4")
-    load = Component(EpicsMotor, "M5")
+    def __init__(self, prefix: str, name: str = "sim"):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "M1")
+            self.y = Motor(prefix + "M2")
+        super().__init__(name=name)

dodal/devices/aperture.py

@@ -12,10 +12,3 @@ class Aperture(StandardReadable):
         self.medium = epics_signal_r(float, prefix + "Y:MEDIUM_CALC")
         self.large = epics_signal_r(float, prefix + "Y:LARGE_CALC")
         super().__init__(name)
-
-    async def in_position(self):
-        return (
-            await self.small.get_value()
-            or await self.medium.get_value()
-            or await self.large.get_value()
-        )

dodal/devices/aperturescatterguard.py

@@ -1,18 +1,14 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Callable, Coroutine
-from typing import Any
 
-from bluesky.protocols import Movable, Triggerable
+from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
-    Reference,
     StandardReadable,
     StandardReadableFormat,
     StrictEnum,
 )
-from ophyd_async.epics.motor import Motor
 from pydantic import BaseModel, Field
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
@@ -111,157 +107,7 @@ def load_positions_from_beamline_parameters(
     }
 
 
-async def _safe_move_whilst_in_beam(
-    aperture: Aperture,
-    scatterguard: Scatterguard,
-    position: AperturePosition,
-    aperture_z_tolerance: float,
-):
-    """
-    Move the aperture and scatterguard combo safely to a new position.
-    See https://github.com/DiamondLightSource/hyperion/wiki/Aperture-Scatterguard-Collisions
-    for why this is required. TLDR is that we have a collision at the top of y so we need
-    to make sure we move the assembly down before we move the scatterguard up.
-
-    We also check that the assembly has been moved into the correct z position
-    previously. If we try and move whilst in the incorrect Z position we will collide
-    with the table.
-    """
-    ap_z_in_position = await aperture.z.motor_done_move.get_value()
-    if not ap_z_in_position:
-        raise InvalidApertureMove(
-            "ApertureScatterguard z is still moving. Wait for it to finish "
-            "before triggering another move."
-        )
-
-    current_ap_z = await aperture.z.user_readback.get_value()
-    diff_on_z = abs(current_ap_z - position.aperture_z)
-    if diff_on_z > aperture_z_tolerance:
-        raise InvalidApertureMove(
-            f"Current aperture z ({current_ap_z}), outside of tolerance ({aperture_z_tolerance}) from target ({position.aperture_z})."
-        )
-
-    current_ap_y = await aperture.y.user_readback.get_value()
-
-    aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = position.values
-
-    if aperture_y > current_ap_y:
-        # Assembly needs to move up so move the scatterguard down first
-        await asyncio.gather(
-            scatterguard.x.set(scatterguard_x),
-            scatterguard.y.set(scatterguard_y),
-        )
-        await asyncio.gather(
-            aperture.x.set(aperture_x),
-            aperture.y.set(aperture_y),
-            aperture.z.set(aperture_z),
-        )
-    else:
-        await asyncio.gather(
-            aperture.x.set(aperture_x),
-            aperture.y.set(aperture_y),
-            aperture.z.set(aperture_z),
-        )
-
-        await asyncio.gather(
-            scatterguard.x.set(scatterguard_x),
-            scatterguard.y.set(scatterguard_y),
-        )
-
-
-class ApertureSelector(StandardReadable, Movable):
-    """Allows for moving all axes other than Y into the correct position, this means
-    that we can set up the aperture while it is out of the beam then move it in later."""
-
-    def __init__(
-        self,
-        aperture: Aperture,
-        scatterguard: Scatterguard,
-        out_of_beam: Callable[[], Coroutine[Any, Any, bool]],
-        loaded_positions: dict[ApertureValue, AperturePosition],
-        aperture_z_tolerance: float,
-    ):
-        self.aperture = Reference(aperture)
-        self.scatterguard = Reference(scatterguard)
-        self.loaded_positions = loaded_positions
-        self.get_is_out_of_beam = out_of_beam
-        self.aperture_z_tolerance = aperture_z_tolerance
-        super().__init__()
-
-    @AsyncStatus.wrap
-    async def set(self, value: ApertureValue):
-        """Moves the assembly to the position for the specified aperture, whilst keeping
-        it out of the beam if it already is so.
-
-        Moving the assembly whilst out of the beam has no collision risk so we can just
-        move all the motors together.
-        """
-        if await self.get_is_out_of_beam():
-            aperture_x, _, aperture_z, scatterguard_x, scatterguard_y = (
-                self.loaded_positions[value].values
-            )
-
-            await asyncio.gather(
-                self.aperture().x.set(aperture_x),
-                self.aperture().z.set(aperture_z),
-                self.scatterguard().x.set(scatterguard_x),
-                self.scatterguard().y.set(scatterguard_y),
-            )
-        else:
-            await _safe_move_whilst_in_beam(
-                self.aperture(),
-                self.scatterguard(),
-                self.loaded_positions[value],
-                self.aperture_z_tolerance,
-            )
-
-
-class OutTrigger(StandardReadable, Triggerable):
-    """Allows for moving just the Y stage of the assembly out of the beam."""
-
-    def __init__(
-        self,
-        aperture_y: Motor,
-        out_y: float,
-    ):
-        self.aperture_y = Reference(aperture_y)
-        self.out_y = out_y
-        super().__init__()
-
-    @AsyncStatus.wrap
-    async def trigger(self):
-        """Moves the assembly out of the beam."""
-        await self.aperture_y().set(self.out_y)
-
-
 class ApertureScatterguard(StandardReadable, Movable):
-    """Move the aperture and scatterguard assembly in a safe way. There are two ways to
-    interact with the device depending on if you want simplicity or move flexibility.
-
-    The simple interface is using:
-
-        await aperture_scatterguard.set(ApertureValue.LARGE)
-
-    This will move the assembly so that the large aperture is in the beam, regardless
-    of where the assembly currently is.
-
-    However, the aperture Y axis is faster than the others. In some cases we may want to
-    move the assembly out of the beam with this axis without moving others:
-
-        await aperture_scatterguard.move_out.trigger()
-
-    We may then want to keep the assembly out of the beam whilst asynchronously preparing
-    the other axes for the aperture that's to follow:
-
-        await aperture_scatterguard.aperture_outside_beam.set(ApertureValue.LARGE)
-
-    Then, at a later time, move back into the beam:
-
-        await aperture_scatterguard.set(ApertureValue.LARGE)
-
-    This move will now be faster as only the y is left to move.
-    """
-
     def __init__(
         self,
         loaded_positions: dict[ApertureValue, AperturePosition],
@@ -269,8 +115,8 @@ class ApertureScatterguard(StandardReadable, Movable):
         prefix: str = "",
         name: str = "",
     ) -> None:
-        self._aperture = Aperture(prefix + "-MO-MAPT-01:")
-        self._scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
+        self.aperture = Aperture(prefix + "-MO-MAPT-01:")
+        self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
         self.radius = create_hardware_backed_soft_signal(
             float, self._get_current_radius, units="µm"
         )
@@ -278,43 +124,30 @@ class ApertureScatterguard(StandardReadable, Movable):
         self._tolerances = tolerances
         self.add_readables(
             [
-                self._aperture.x.user_readback,
-                self._aperture.y.user_readback,
-                self._aperture.z.user_readback,
-                self._scatterguard.x.user_readback,
-                self._scatterguard.y.user_readback,
+                self.aperture.x.user_readback,
+                self.aperture.y.user_readback,
+                self.aperture.z.user_readback,
+                self.scatterguard.x.user_readback,
+                self.scatterguard.y.user_readback,
                 self.radius,
             ],
         )
-
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.selected_aperture = create_hardware_backed_soft_signal(
                 ApertureValue, self._get_current_aperture_position
             )
 
-        # Setting this will select the aperture but not move it into beam
-        self.aperture_outside_beam = ApertureSelector(
-            self._aperture,
-            self._scatterguard,
-            self._is_out_of_beam,
-            self._loaded_positions,
-            self._tolerances.aperture_z,
-        )
-
-        # Setting this will just move the assembly out of the beam
-        self.move_out = OutTrigger(
-            self._aperture.y, loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
-        )
-
         super().__init__(name)
 
+    def get_position_from_gda_aperture_name(
+        self, gda_aperture_name: str
+    ) -> ApertureValue:
+        return ApertureValue(gda_aperture_name)
+
     @AsyncStatus.wrap
     async def set(self, value: ApertureValue):
-        """This set will move the aperture into the beam or move to robot load"""
         position = self._loaded_positions[value]
-        await _safe_move_whilst_in_beam(
-            self._aperture, self._scatterguard, position, self._tolerances.aperture_z
-        )
+        await self._safe_move_within_datacollection_range(position, value)
 
     @AsyncStatus.wrap
     async def _set_raw_unsafe(self, position: AperturePosition):
@@ -324,18 +157,13 @@ class ApertureScatterguard(StandardReadable, Movable):
         )
 
         await asyncio.gather(
-            self._aperture.x.set(aperture_x),
-            self._aperture.y.set(aperture_y),
-            self._aperture.z.set(aperture_z),
-            self._scatterguard.x.set(scatterguard_x),
-            self._scatterguard.y.set(scatterguard_y),
+            self.aperture.x.set(aperture_x),
+            self.aperture.y.set(aperture_y),
+            self.aperture.z.set(aperture_z),
+            self.scatterguard.x.set(scatterguard_x),
+            self.scatterguard.y.set(scatterguard_y),
         )
 
-    async def _is_out_of_beam(self) -> bool:
-        current_ap_y = await self._aperture.y.user_readback.get_value()
-        robot_load_ap_y = self._loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
-        return current_ap_y <= robot_load_ap_y + self._tolerances.aperture_y
-
     async def _get_current_aperture_position(self) -> ApertureValue:
         """
         Returns the current aperture position using readback values
@@ -343,13 +171,15 @@ class ApertureScatterguard(StandardReadable, Movable):
         mini aperture y <= ROBOT_LOAD.location.aperture_y + tolerance.
         If no position is found then raises InvalidApertureMove.
         """
-        if await self._aperture.large.get_value(cached=False) == 1:
+        current_ap_y = await self.aperture.y.user_readback.get_value(cached=False)
+        robot_load_ap_y = self._loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
+        if await self.aperture.large.get_value(cached=False) == 1:
             return ApertureValue.LARGE
-        elif await self._aperture.medium.get_value(cached=False) == 1:
+        elif await self.aperture.medium.get_value(cached=False) == 1:
             return ApertureValue.MEDIUM
-        elif await self._aperture.small.get_value(cached=False) == 1:
+        elif await self.aperture.small.get_value(cached=False) == 1:
             return ApertureValue.SMALL
-        elif await self._is_out_of_beam():
+        elif current_ap_y <= robot_load_ap_y + self._tolerances.aperture_y:
             return ApertureValue.ROBOT_LOAD
 
         raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
@@ -357,3 +187,57 @@ class ApertureScatterguard(StandardReadable, Movable):
     async def _get_current_radius(self) -> float:
         current_value = await self._get_current_aperture_position()
         return self._loaded_positions[current_value].radius
+
+    async def _safe_move_within_datacollection_range(
+        self, position: AperturePosition, value: ApertureValue
+    ):
+        """
+        Move the aperture and scatterguard combo safely to a new position.
+        See https://github.com/DiamondLightSource/hyperion/wiki/Aperture-Scatterguard-Collisions
+        for why this is required.
+        """
+        assert self._loaded_positions is not None
+
+        ap_z_in_position = await self.aperture.z.motor_done_move.get_value()
+        if not ap_z_in_position:
+            raise InvalidApertureMove(
+                "ApertureScatterguard z is still moving. Wait for it to finish "
+                "before triggering another move."
+            )
+
+        current_ap_z = await self.aperture.z.user_readback.get_value()
+        diff_on_z = abs(current_ap_z - position.aperture_z)
+        if diff_on_z > self._tolerances.aperture_z:
+            raise InvalidApertureMove(
+                "ApertureScatterguard safe move is not yet defined for positions "
+                "outside of LARGE, MEDIUM, SMALL, ROBOT_LOAD. "
+                f"Current aperture z ({current_ap_z}), outside of tolerance ({self._tolerances.aperture_z}) from target ({position.aperture_z})."
+            )
+
+        current_ap_y = await self.aperture.y.user_readback.get_value()
+
+        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
+            position.values
+        )
+
+        if position.aperture_y > current_ap_y:
+            await asyncio.gather(
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
+            )
+            await asyncio.gather(
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
+            )
+        else:
+            await asyncio.gather(
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
+            )
+
+            await asyncio.gather(
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
+            )

dodal/devices/attenuator.py

@@ -14,7 +14,20 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal
 from dodal.log import LOGGER
 
 
-class Attenuator(StandardReadable, Movable):
+class ReadOnlyAttenuator(StandardReadable):
+    """A read-only attenuator class with a minimum set of PVs for reading.
+
+    The actual_transmission will return a fractional transmission between 0-1.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.actual_transmission = epics_signal_r(float, prefix + "MATCH")
+
+        super().__init__(name)
+
+
+class Attenuator(ReadOnlyAttenuator, Movable):
     """The attenuator will insert filters into the beam to reduce its transmission.
 
     This device should be set with:
@@ -42,10 +55,7 @@ class Attenuator(StandardReadable, Movable):
         self._use_current_energy = epics_signal_x(prefix + "E2WL:USECURRENTENERGY.PROC")
         self._change = epics_signal_x(prefix + "FANOUT")
 
-        with self.add_children_as_readables():
-            self.actual_transmission = epics_signal_r(float, prefix + "MATCH")
-
-        super().__init__(name)
+        super().__init__(prefix, name)
 
     @AsyncStatus.wrap
     async def set(self, value: float):

dodal/devices/focusing_mirror.py

@@ -1,3 +1,5 @@
+from typing import TypedDict
+
 from ophyd_async.core import (
     AsyncStatus,
     Device,
@@ -36,6 +38,12 @@ class MirrorStripe(StrictEnum):
     PLATINUM = "Platinum"
 
 
+class MirrorStripeConfiguration(TypedDict):
+    stripe: MirrorStripe
+    yaw_mrad: float
+    lat_mm: float
+
+
 class MirrorVoltageDemand(StrictEnum):
     N_A = "N/A"
     OK = "OK"
@@ -173,9 +181,10 @@ class FocusingMirrorWithStripes(FocusingMirror):
 
         super().__init__(prefix, name, *args, **kwargs)
 
-    def energy_to_stripe(self, energy_kev) -> MirrorStripe:
+    def energy_to_stripe(self, energy_kev) -> MirrorStripeConfiguration:
+        """Return the stripe, yaw angle and lateral position for the specified energy"""
         # In future, this should be configurable per-mirror
         if energy_kev < 7:
-            return MirrorStripe.BARE
+            return {"stripe": MirrorStripe.BARE, "yaw_mrad": 6.2, "lat_mm": 0.0}
         else:
-            return MirrorStripe.RHODIUM
+            return {"stripe": MirrorStripe.RHODIUM, "yaw_mrad": 0.0, "lat_mm": 10.0}

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -61,7 +61,7 @@ class PinTipDetection(StandardReadable):
         self.triggered_bottom_edge, self._bottom_edge_setter = soft_signal_r_and_setter(
             Array1D[np.int32], name="triggered_bottom_edge"
         )
-        self.array_data = epics_signal_r(Array1D[np.uint8], f"pva://{prefix}PVA:ARRAY")
+        self.array_data = epics_signal_r(np.ndarray, f"pva://{prefix}PVA:ARRAY")
 
         # Soft parameters for pin-tip detection.
         self.preprocess_operation = soft_signal_rw(int, 10, name="preprocess")
@@ -99,9 +99,7 @@ class PinTipDetection(StandardReadable):
         self._top_edge_setter(results.edge_top)
         self._bottom_edge_setter(results.edge_bottom)
 
-    async def _get_tip_and_edge_data(
-        self, array_data: Array1D[np.uint8]
-    ) -> SampleLocation:
+    async def _get_tip_and_edge_data(self, array_data: np.ndarray) -> SampleLocation:
         """
         Gets the location of the pin tip and the top and bottom edges.
         """

dodal/devices/undulator_dcm.py

@@ -5,6 +5,7 @@ from ophyd_async.core import AsyncStatus, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
 
+from ..log import LOGGER
 from .dcm import DCM
 from .undulator import Undulator
 
@@ -59,3 +60,6 @@ class UndulatorDCM(StandardReadable, Movable):
             self.dcm.energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
             self.undulator.set(value),
         )
+        # DCM Perp pitch
+        LOGGER.info(f"Adjusting DCM offset to {self.dcm_fixed_offset_mm} mm")
+        await self.dcm.offset_in_mm.set(self.dcm_fixed_offset_mm)

dodal/adsim.py

@@ -1,17 +0,0 @@
-import os
-
-from dodal.devices.adsim import SimStage
-from dodal.devices.areadetector import AdSimDetector
-
-from .utils import get_hostname
-
-# Default prefix to hostname unless overriden with export PREFIX=<prefix>
-PREFIX: str = os.environ.get("PREFIX", get_hostname())
-
-
-def stage(name: str = "sim_motors") -> SimStage:
-    return SimStage(name=name, prefix=f"{PREFIX}-MO-SIM-01:")
-
-
-def det(name: str = "adsim") -> AdSimDetector:
-    return AdSimDetector(name=name, prefix=f"{PREFIX}-AD-SIM-01:")

dodal/devices/areadetector/__init__.py

@@ -1,10 +0,0 @@
-from .adaravis import AdAravisDetector
-from .adsim import AdSimDetector
-from .adutils import Hdf5Writer, SynchronisedAdDriverBase
-
-__all__ = [
-    "AdSimDetector",
-    "SynchronisedAdDriverBase",
-    "Hdf5Writer",
-    "AdAravisDetector",
-]

dodal/devices/areadetector/adaravis.py

@@ -1,101 +0,0 @@
-from collections.abc import Mapping
-from typing import Any
-
-from ophyd import EpicsSignal, Signal
-from ophyd.areadetector.base import ADComponent as Cpt
-from ophyd.areadetector.detectors import DetectorBase
-
-from .adutils import Hdf5Writer, SingleTriggerV33, SynchronisedAdDriverBase
-
-_ACQUIRE_BUFFER_PERIOD = 0.2
-
-
-class AdAravisDetector(SingleTriggerV33, DetectorBase):
-    cam = Cpt(SynchronisedAdDriverBase, suffix="DET:")
-    hdf = Cpt(
-        Hdf5Writer,
-        suffix="HDF5:",
-        root="",
-        write_path_template="",
-    )
-    _priming_settings: Mapping[Signal, Any]
-
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.hdf.kind = "normal"
-
-        # Values for staging
-        self.stage_sigs = {
-            # Get stage to wire up the plugins
-            self.hdf.nd_array_port: self.cam.port_name.get(),
-            # Reset array counter on stage
-            self.cam.array_counter: 0,
-            # Set image mode to multiple on stage so we have the option, can still
-            # set num_images to 1
-            self.cam.image_mode: "Multiple",
-            # For now, this Ophyd device does not support hardware
-            # triggered scanning, disable on stage
-            self.cam.trigger_mode: "Off",
-            **self.stage_sigs,  # type: ignore
-        }
-
-        # Settings to apply when priming plugins during pre-stage
-        self._priming_settings = {
-            self.hdf.enable: 1,
-            self.hdf.nd_array_port: self.cam.port_name.get(),
-            self.cam.array_callbacks: 1,
-            self.cam.image_mode: "Single",
-            self.cam.trigger_mode: "Off",
-            # Take the quickest possible frame
-            self.cam.acquire_time: 6.3e-05,
-            self.cam.acquire_period: 0.003,
-        }
-
-        # Signals that control driver and hdf writer should be put_complete to
-        # avoid race conditions during priming
-        for signal in set(self.stage_sigs.keys()).union(
-            set(self._priming_settings.keys())
-        ):
-            if isinstance(signal, EpicsSignal):
-                signal.put_complete = True
-        self.cam.acquire.put_complete = True
-
-    def stage(self, *args, **kwargs) -> list[object]:
-        # We have to manually set the acquire period bcause the EPICS driver
-        # doesn't do it for us. If acquire time is a staged signal, we use the
-        # stage value to calculate the acquire period, otherwise we perform
-        # a caget and use the current acquire time.
-        if self.cam.acquire_time in self.stage_sigs:
-            acquire_time = self.stage_sigs[self.cam.acquire_time]
-        else:
-            acquire_time = self.cam.acquire_time.get()
-        self.stage_sigs[self.cam.acquire_period] = (
-            float(acquire_time) + _ACQUIRE_BUFFER_PERIOD
-        )
-
-        # Ensure detector warmed up
-        self._prime_hdf()
-
-        # Now calling the super method should set the acquire period
-        return super().stage(*args, **kwargs)
-
-    def _prime_hdf(self) -> None:
-        """
-        Take a single frame and pipe it through the HDF5 writer plugin
-        """
-
-        # Backup state and ensure we are not acquiring
-        reset_to = {signal: signal.get() for signal in self._priming_settings.keys()}
-        self.cam.acquire.set(0).wait(timeout=10)
-
-        # Apply all settings for acquisition
-        for signal, value in self._priming_settings.items():
-            # Ensure that .wait really will wait until the PV is set including its RBV
-            signal.set(value).wait(timeout=10)
-
-        # Acquire a frame
-        self.cam.acquire.set(1).wait(timeout=10)
-
-        # Revert settings to previous values
-        for signal, value in reversed(reset_to.items()):
-            signal.set(value).wait(timeout=10)

dodal/devices/areadetector/adsim.py

@@ -1,47 +0,0 @@
-from ophyd.areadetector.base import ADComponent as Cpt
-from ophyd.areadetector.detectors import DetectorBase
-
-from .adutils import Hdf5Writer, SingleTriggerV33, SynchronisedAdDriverBase
-
-
-class AdSimDetector(SingleTriggerV33, DetectorBase):
-    cam = Cpt(SynchronisedAdDriverBase, suffix="CAM:", lazy=True)
-    hdf = Cpt(
-        Hdf5Writer,
-        suffix="HDF5:",
-        root="",
-        write_path_template="",
-        lazy=True,
-    )
-
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.hdf.kind = "normal"
-
-        self.stage_sigs = {
-            # Get stage to wire up the plugins
-            self.hdf.nd_array_port: self.cam.port_name.get(),
-            # Reset array counter on stage
-            self.cam.array_counter: 0,
-            # Set image mode to multiple on stage so we have the option, can still
-            # set num_images to 1
-            self.cam.image_mode: "Multiple",
-            # For now, this Ophyd device does not support hardware
-            # triggered scanning, disable on stage
-            self.cam.trigger_mode: "Internal",
-            **self.stage_sigs,  # type: ignore
-        }
-
-    def stage(self, *args, **kwargs) -> list[object]:
-        # We have to manually set the acquire period bcause the EPICS driver
-        # doesn't do it for us. If acquire time is a staged signal, we use the
-        # stage value to calculate the acquire period, otherwise we perform
-        # a caget and use the current acquire time.
-        if self.cam.acquire_time in self.stage_sigs:
-            acquire_time = self.stage_sigs[self.cam.acquire_time]
-        else:
-            acquire_time = self.cam.acquire_time.get()
-        self.stage_sigs[self.cam.acquire_period] = acquire_time
-
-        # Now calling the super method should set the acquire period
-        return super().stage(*args, **kwargs)

dodal/devices/areadetector/adutils.py

@@ -1,81 +0,0 @@
-import time as ttime
-
-from ophyd import Component as Cpt
-from ophyd import DetectorBase, Device, EpicsSignal, EpicsSignalRO, Staged
-from ophyd.areadetector import ADTriggerStatus, TriggerBase
-from ophyd.areadetector.cam import AreaDetectorCam
-from ophyd.areadetector.filestore_mixins import FileStoreHDF5, FileStoreIterativeWrite
-from ophyd.areadetector.plugins import HDF5Plugin
-
-
-class SingleTriggerV33(TriggerBase):
-    _status_type = ADTriggerStatus
-
-    def __init__(self, *args, image_name=None, **kwargs):
-        super().__init__(*args, **kwargs)
-        if image_name is None:
-            # Ensure that this mixin is part of valid device with name
-            assert isinstance(self, Device)
-            image_name = "_".join([self.name, "image"])
-        self._image_name = image_name
-
-    def trigger(self):
-        "Trigger one acquisition."
-        if self._staged != Staged.yes:
-            raise RuntimeError(
-                "This detector is not ready to trigger."
-                "Call the stage() method before triggering."
-            )
-
-        self._status = self._status_type(self)
-
-        def _acq_done(*args, **kwargs):
-            # TODO sort out if anything useful in here
-            self._status._finished()  # noqa: SLF001
-
-        self._acquisition_signal.put(1, use_complete=True, callback=_acq_done)
-        # Ensure that this mixin is part of valid Detector with generate_datum
-        assert isinstance(self, DetectorBase)
-        self.generate_datum(self._image_name, ttime.time())
-        return self._status
-
-
-class SynchronisedAdDriverBase(AreaDetectorCam):
-    """
-    Base Ophyd device to control an AreaDetector driver and
-    syncrhonise it on other AreaDetector plugins, even non-blocking ones.
-    """
-
-    adcore_version = Cpt(EpicsSignalRO, "ADCoreVersion_RBV", string=True, kind="config")
-    driver_version = Cpt(EpicsSignalRO, "DriverVersion_RBV", string=True, kind="config")
-    wait_for_plugins = Cpt(EpicsSignal, "WaitForPlugins", string=True, kind="config")
-
-    def stage(self, *args, **kwargs):
-        # Makes the detector allow non-blocking AD plugins but makes Ophyd use
-        # the AcquireBusy PV to determine when an acquisition is complete
-        self.ensure_nonblocking()
-        return super().stage(*args, **kwargs)
-
-    def ensure_nonblocking(self):
-        self.stage_sigs["wait_for_plugins"] = "Yes"
-        if self.parent is not None:
-            for c in self.parent.component_names:
-                cpt = getattr(self.parent, c)
-                if cpt is self:
-                    continue
-                if hasattr(cpt, "ensure_nonblocking"):
-                    cpt.ensure_nonblocking()
-
-
-# ophyd code to be removed, only used for adim
-# https://github.com/DiamondLightSource/dodal/issues/404
-class Hdf5Writer(HDF5Plugin, FileStoreHDF5, FileStoreIterativeWrite):  # type: ignore
-    """ """
-
-    pool_max_buffers = None
-    file_number_sync = None
-    file_number_write = None
-
-    def get_frames_per_point(self):
-        assert isinstance(self.parent, DetectorBase)
-        return self.parent.cam.num_images.get()