diff --git a/src/dodal/beamline_specific_utils/i03.py b/src/dodal/beamline_specific_utils/i03.py deleted file mode 100644 index 46390f9e991..00000000000 --- a/src/dodal/beamline_specific_utils/i03.py +++ /dev/null @@ -1,17 +0,0 @@ -from dataclasses import dataclass - -I03_BEAM_HEIGHT_UM = 20.0 -I03_BEAM_WIDTH_UM = 80.0 - - -@dataclass -class BeamSize: - x_um: float | None - y_um: float | None - - -def beam_size_from_aperture(aperture_size: float | None): - return BeamSize( - min(aperture_size, I03_BEAM_WIDTH_UM) if aperture_size else None, - I03_BEAM_HEIGHT_UM if aperture_size else None, - ) diff --git a/src/dodal/beamlines/i03.py b/src/dodal/beamlines/i03.py index 0ee2a9a9b9e..6cf81e92046 100644 --- a/src/dodal/beamlines/i03.py +++ b/src/dodal/beamlines/i03.py @@ -31,6 +31,7 @@ from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, MirrorVoltages from dodal.devices.hutch_shutter import HutchShutter from dodal.devices.i03 import Beamstop +from dodal.devices.i03.beamsize import Beamsize from dodal.devices.i03.dcm import DCM from dodal.devices.i03.undulator_dcm import UndulatorDCM from dodal.devices.motors import XYZStage @@ -456,3 +457,13 @@ def collimation_table() -> CollimationTable: If this is called when already instantiated in i03, it will return the existing object. """ return CollimationTable(prefix=f"{PREFIX.beamline_prefix}-MO-TABLE-01") + + +@device_factory() +def beamsize() -> Beamsize: + """Get the i03 beamsize device, instantiate it if it hasn't already been. + If this is called when already instantiated in i03, it will return the existing object. + """ + return Beamsize( + aperture_scatterguard=aperture_scatterguard(), + ) diff --git a/src/dodal/beamlines/i04.py b/src/dodal/beamlines/i04.py index 25b54bd6fc5..4c3c68252a5 100644 --- a/src/dodal/beamlines/i04.py +++ b/src/dodal/beamlines/i04.py @@ -20,6 +20,7 @@ from dodal.devices.fast_grid_scan import ZebraFastGridScanThreeD from dodal.devices.flux import Flux from dodal.devices.i03.dcm import DCM +from dodal.devices.i04.beamsize import Beamsize from dodal.devices.i04.constants import RedisConstants from dodal.devices.i04.murko_results import MurkoResultsDevice from dodal.devices.i04.transfocator import Transfocator @@ -377,3 +378,14 @@ def scintillator() -> Scintillator: Reference(aperture_scatterguard()), get_beamline_parameters(), ) + + +@device_factory() +def beamsize() -> Beamsize: + """Get the i04 beamsize device, instantiate it if it hasn't already been. + If this is called when already instantiated in i04, it will return the existing object. + """ + return Beamsize( + transfocator=transfocator(), + aperture_scatterguard=aperture_scatterguard(), + ) diff --git a/src/dodal/devices/aperturescatterguard.py b/src/dodal/devices/aperturescatterguard.py index a40c3e53d8c..142ff08537a 100644 --- a/src/dodal/devices/aperturescatterguard.py +++ b/src/dodal/devices/aperturescatterguard.py @@ -1,6 +1,7 @@ from __future__ import annotations import asyncio +from math import inf from bluesky.protocols import Preparable from ophyd_async.core import ( @@ -112,7 +113,7 @@ def load_positions_from_beamline_parameters( ) -> dict[ApertureValue, AperturePosition]: return { ApertureValue.OUT_OF_BEAM: AperturePosition.from_gda_params( - _GDAParamApertureValue.ROBOT_LOAD, 0, params + _GDAParamApertureValue.ROBOT_LOAD, inf, params ), ApertureValue.SMALL: AperturePosition.from_gda_params( _GDAParamApertureValue.SMALL, 20, params @@ -124,7 +125,7 @@ def load_positions_from_beamline_parameters( _GDAParamApertureValue.LARGE, 100, params ), ApertureValue.PARKED: AperturePosition.from_gda_params( - _GDAParamApertureValue.MANUAL_LOAD, 0, params + _GDAParamApertureValue.MANUAL_LOAD, inf, params ), } diff --git a/src/dodal/devices/beamsize/__init__.py b/src/dodal/devices/beamsize/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/src/dodal/devices/beamsize/beamsize.py b/src/dodal/devices/beamsize/beamsize.py new file mode 100644 index 00000000000..ae1ae9674d2 --- /dev/null +++ b/src/dodal/devices/beamsize/beamsize.py @@ -0,0 +1,9 @@ +from typing import Annotated + +from ophyd_async.core import SignalR, StandardReadable +from ophyd_async.core import StandardReadableFormat as Format + + +class BeamsizeBase(StandardReadable): + x_um: Annotated[SignalR[float], Format.HINTED_SIGNAL] + y_um: Annotated[SignalR[float], Format.HINTED_SIGNAL] diff --git a/src/dodal/devices/i03/beamsize.py b/src/dodal/devices/i03/beamsize.py new file mode 100644 index 00000000000..ee5ce2f2feb --- /dev/null +++ b/src/dodal/devices/i03/beamsize.py @@ -0,0 +1,34 @@ +from ophyd_async.core import Reference, derived_signal_r + +from dodal.devices.aperturescatterguard import ApertureScatterguard +from dodal.devices.beamsize.beamsize import BeamsizeBase +from dodal.devices.i03.constants import BeamsizeConstants + + +class Beamsize(BeamsizeBase): + def __init__(self, aperture_scatterguard: ApertureScatterguard, name=""): + super().__init__(name=name) + self._aperture_scatterguard_ref = Reference(aperture_scatterguard) + + self.x_um = derived_signal_r( + self._get_beamsize_x, + aperture_radius=self._aperture_scatterguard_ref().radius, + derived_units="µm", + ) + self.y_um = derived_signal_r( + self._get_beamsize_y, + aperture_radius=self._aperture_scatterguard_ref().radius, + derived_units="µm", + ) + + def _get_beamsize_x( + self, + aperture_radius: float, + ) -> float: + return min(aperture_radius, BeamsizeConstants.BEAM_WIDTH_UM) + + def _get_beamsize_y( + self, + aperture_radius: float, + ) -> float: + return min(aperture_radius, BeamsizeConstants.BEAM_HEIGHT_UM) diff --git a/src/dodal/devices/i03/constants.py b/src/dodal/devices/i03/constants.py new file mode 100644 index 00000000000..5e030b0383c --- /dev/null +++ b/src/dodal/devices/i03/constants.py @@ -0,0 +1,7 @@ +from dataclasses import dataclass + + +@dataclass(frozen=True) +class BeamsizeConstants: + BEAM_WIDTH_UM = 80.0 + BEAM_HEIGHT_UM = 20.0 diff --git a/src/dodal/devices/i04/beamsize.py b/src/dodal/devices/i04/beamsize.py new file mode 100644 index 00000000000..7908a036c3a --- /dev/null +++ b/src/dodal/devices/i04/beamsize.py @@ -0,0 +1,44 @@ +from ophyd_async.core import Reference, derived_signal_r + +from dodal.devices.aperturescatterguard import ApertureScatterguard +from dodal.devices.beamsize.beamsize import BeamsizeBase +from dodal.devices.i04.transfocator import Transfocator + + +class Beamsize(BeamsizeBase): + def __init__( + self, + transfocator: Transfocator, + aperture_scatterguard: ApertureScatterguard, + name="", + ): + super().__init__(name=name) + self._transfocator_ref = Reference(transfocator) + self._aperture_scatterguard_ref = Reference(aperture_scatterguard) + + self.x_um = derived_signal_r( + self._get_beamsize_x, + transfocator_size_x=self._transfocator_ref().current_horizontal_size_rbv, + aperture_radius=self._aperture_scatterguard_ref().radius, + derived_units="µm", + ) + self.y_um = derived_signal_r( + self._get_beamsize_y, + transfocator_size_y=self._transfocator_ref().current_vertical_size_rbv, + aperture_radius=self._aperture_scatterguard_ref().radius, + derived_units="µm", + ) + + def _get_beamsize_x( + self, + transfocator_size_x: float, + aperture_radius: float, + ) -> float: + return min(transfocator_size_x, aperture_radius) + + def _get_beamsize_y( + self, + transfocator_size_y: float, + aperture_radius: float, + ) -> float: + return min(transfocator_size_y, aperture_radius) diff --git a/src/dodal/devices/i04/transfocator.py b/src/dodal/devices/i04/transfocator.py index 74a28881dc2..20cc15ff07b 100644 --- a/src/dodal/devices/i04/transfocator.py +++ b/src/dodal/devices/i04/transfocator.py @@ -30,6 +30,7 @@ def __init__(self, prefix: str, name: str = ""): with self.add_children_as_readables(): self.number_filters_sp = epics_signal_rw(int, prefix + "NUM_FILTERS") + self.current_horizontal_size_rbv = epics_signal_r(float, prefix + "HOR") self.current_vertical_size_rbv = epics_signal_r(float, prefix + "VER") self.TIMEOUT = 120 diff --git a/tests/devices/conftest.py b/tests/devices/conftest.py new file mode 100644 index 00000000000..b629e7a564d --- /dev/null +++ b/tests/devices/conftest.py @@ -0,0 +1,96 @@ +import asyncio +from collections.abc import AsyncGenerator + +import pytest +from ophyd_async.core import init_devices + +from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters +from dodal.devices.aperturescatterguard import ( + AperturePosition, + ApertureScatterguard, + ApertureValue, + load_positions_from_beamline_parameters, +) +from dodal.testing import patch_all_motors + + +@pytest.fixture +def aperture_positions() -> dict[ApertureValue, AperturePosition]: + return load_positions_from_beamline_parameters( + GDABeamlineParameters( + params={ + "miniap_x_LARGE_APERTURE": 2.389, + "miniap_y_LARGE_APERTURE": 40.986, + "miniap_z_LARGE_APERTURE": 15.8, + "sg_x_LARGE_APERTURE": 5.25, + "sg_y_LARGE_APERTURE": 4.43, + "miniap_x_MEDIUM_APERTURE": 2.384, + "miniap_y_MEDIUM_APERTURE": 44.967, + "miniap_z_MEDIUM_APERTURE": 15.8, + "sg_x_MEDIUM_APERTURE": 5.285, + "sg_y_MEDIUM_APERTURE": 0.46, + "miniap_x_SMALL_APERTURE": 2.430, + "miniap_y_SMALL_APERTURE": 48.974, + "miniap_z_SMALL_APERTURE": 15.8, + "sg_x_SMALL_APERTURE": 5.3375, + "sg_y_SMALL_APERTURE": -3.55, + "miniap_x_ROBOT_LOAD": 2.386, + "miniap_y_ROBOT_LOAD": 31.40, + "miniap_z_ROBOT_LOAD": 15.8, + "sg_x_ROBOT_LOAD": 5.25, + "sg_y_ROBOT_LOAD": 4.43, + "miniap_x_MANUAL_LOAD": -4.91, + "miniap_y_MANUAL_LOAD": -48.70, + "miniap_z_MANUAL_LOAD": -10.0, + "sg_x_MANUAL_LOAD": -4.7, + "sg_y_MANUAL_LOAD": 1.8, + } + ) + ) + + +@pytest.fixture +def aperture_tolerances(): + return AperturePosition.tolerances_from_gda_params( + GDABeamlineParameters( + { + "miniap_x_tolerance": 0.004, + "miniap_y_tolerance": 0.1, + "miniap_z_tolerance": 0.1, + "sg_x_tolerance": 0.1, + "sg_y_tolerance": 0.1, + } + ) + ) + + +@pytest.fixture +async def ap_sg( + aperture_positions: dict[ApertureValue, AperturePosition], + aperture_tolerances: AperturePosition, +) -> AsyncGenerator[ApertureScatterguard]: + async with init_devices(mock=True): + ap_sg = ApertureScatterguard( + aperture_prefix="-MO-MAPT-01:", + scatterguard_prefix="-MO-SCAT-01:", + name="test_ap_sg", + loaded_positions=aperture_positions, + tolerances=aperture_tolerances, + ) + + with patch_all_motors(ap_sg): + yield ap_sg + + +async def set_to_position( + aperture_scatterguard: ApertureScatterguard, position: AperturePosition +): + aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = position.values + + await asyncio.gather( + aperture_scatterguard.aperture.x.set(aperture_x), + aperture_scatterguard.aperture.y.set(aperture_y), + aperture_scatterguard.aperture.z.set(aperture_z), + aperture_scatterguard.scatterguard.x.set(scatterguard_x), + aperture_scatterguard.scatterguard.y.set(scatterguard_y), + ) diff --git a/tests/devices/i03/test_beamsize.py b/tests/devices/i03/test_beamsize.py new file mode 100644 index 00000000000..044779baf6e --- /dev/null +++ b/tests/devices/i03/test_beamsize.py @@ -0,0 +1,43 @@ +from math import inf +from unittest.mock import AsyncMock + +import pytest +from ophyd_async.testing import set_mock_value + +from dodal.devices.aperturescatterguard import ( + ApertureScatterguard, +) +from dodal.devices.i03.beamsize import Beamsize + + +@pytest.mark.parametrize( + "aperture_radius, expected_beamsize", + [ + (10.0, (10.0, 10.0)), + (50, (50.0, 20.0)), + (90, (80.0, 20.0)), + (inf, (80.0, 20.0)), + ], +) +async def test_beamsize_gives_min_of_aperture_and_beam_width_and_height( + aperture_radius: float, + expected_beamsize: tuple[float, float], + ap_sg: ApertureScatterguard, +): + set_mock_value(ap_sg.aperture.medium, 1) + + ap_sg.radius.read = AsyncMock( + return_value={ + "test_ap_sg-radius": { + "value": aperture_radius, + "timestamp": 1763051436.7372239, + "alarm_severity": 0, + } + } + ) # see https://github.com/bluesky/ophyd-async/issues/1132 + + beamsize = Beamsize(aperture_scatterguard=ap_sg) + + beamsize_x = await beamsize.x_um.get_value() + beamsize_y = await beamsize.y_um.get_value() + assert (beamsize_x, beamsize_y) == expected_beamsize diff --git a/tests/devices/i04/conftest.py b/tests/devices/i04/conftest.py new file mode 100644 index 00000000000..cacde21222a --- /dev/null +++ b/tests/devices/i04/conftest.py @@ -0,0 +1,11 @@ +import pytest +from ophyd_async.core import init_devices + +from dodal.devices.i04.transfocator import Transfocator + + +@pytest.fixture +async def fake_transfocator() -> Transfocator: + async with init_devices(mock=True): + transfocator = Transfocator(prefix="", name="transfocator") + return transfocator diff --git a/tests/devices/i04/test_beamsize.py b/tests/devices/i04/test_beamsize.py new file mode 100644 index 00000000000..568a10f9176 --- /dev/null +++ b/tests/devices/i04/test_beamsize.py @@ -0,0 +1,50 @@ +from math import inf +from unittest.mock import AsyncMock + +import pytest +from ophyd_async.testing import set_mock_value + +from dodal.devices.aperturescatterguard import ( + ApertureScatterguard, +) +from dodal.devices.i04.beamsize import Beamsize +from dodal.devices.i04.transfocator import Transfocator + + +@pytest.mark.parametrize( + "aperture_radius, transfocator_sizes, expected_beamsize", + [ + (10.0, (50.0, 60.0), (10.0, 10.0)), + (20.0, (10.0, 30.0), (10.0, 20.0)), + (20.0, (30.0, 10.0), (20.0, 10.0)), + (100.0, (50.0, 60.0), (50.0, 60.0)), + (inf, (50.0, 60.0), (50.0, 60.0)), + ], +) +async def test_beamsize_gives_min_of_aperture_and_transfocator_width_and_height( + aperture_radius: float, + transfocator_sizes: tuple[float, float], + expected_beamsize: tuple[float, float], + fake_transfocator: Transfocator, + ap_sg: ApertureScatterguard, +): + set_mock_value(ap_sg.aperture.medium, 1) + + ap_sg.radius.read = AsyncMock( + return_value={ + "test_ap_sg-radius": { + "value": aperture_radius, + "timestamp": 1763051436.7372239, + "alarm_severity": 0, + } + } + ) # see https://github.com/bluesky/ophyd-async/issues/1132 + + set_mock_value(fake_transfocator.current_horizontal_size_rbv, transfocator_sizes[0]) + set_mock_value(fake_transfocator.current_vertical_size_rbv, transfocator_sizes[1]) + + beamsize = Beamsize(transfocator=fake_transfocator, aperture_scatterguard=ap_sg) + + beamsize_x = await beamsize.x_um.get_value() + beamsize_y = await beamsize.y_um.get_value() + assert (beamsize_x, beamsize_y) == expected_beamsize diff --git a/tests/devices/i04/test_transfocator.py b/tests/devices/i04/test_transfocator.py index 1e91e60561e..25b3dc429e8 100644 --- a/tests/devices/i04/test_transfocator.py +++ b/tests/devices/i04/test_transfocator.py @@ -3,22 +3,12 @@ import pytest from bluesky.protocols import Reading -from ophyd_async.core import ( - init_devices, - wait_for_value, -) +from ophyd_async.core import wait_for_value from ophyd_async.testing import set_mock_value from dodal.devices.i04.transfocator import Transfocator -@pytest.fixture -async def fake_transfocator() -> Transfocator: - async with init_devices(mock=True): - transfocator = Transfocator(prefix="", name="transfocator") - return transfocator - - def given_predicted_lenses_is_half_of_beamsize(transfocator: Transfocator): def lens_number_is_half_beamsize( reading: dict[str, Reading[float]], *args, **kwargs diff --git a/tests/devices/test_aperture_scatterguard.py b/tests/devices/test_aperture_scatterguard.py index 36095e4c91a..c32317c04cb 100644 --- a/tests/devices/test_aperture_scatterguard.py +++ b/tests/devices/test_aperture_scatterguard.py @@ -1,12 +1,11 @@ -import asyncio from collections.abc import AsyncGenerator +from math import inf from typing import Any from unittest.mock import AsyncMock, call import bluesky.plan_stubs as bps import pytest from bluesky.run_engine import RunEngine -from ophyd_async.core import init_devices from ophyd_async.testing import ( callback_on_mock_put, get_mock, @@ -14,65 +13,25 @@ set_mock_value, ) -from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters from dodal.devices.aperturescatterguard import ( AperturePosition, ApertureScatterguard, ApertureValue, InvalidApertureMoveError, - load_positions_from_beamline_parameters, ) -from dodal.testing import patch_all_motors +from tests.devices.conftest import set_to_position @pytest.fixture -def aperture_positions() -> dict[ApertureValue, AperturePosition]: - return load_positions_from_beamline_parameters( - GDABeamlineParameters( - params={ - "miniap_x_LARGE_APERTURE": 2.389, - "miniap_y_LARGE_APERTURE": 40.986, - "miniap_z_LARGE_APERTURE": 15.8, - "sg_x_LARGE_APERTURE": 5.25, - "sg_y_LARGE_APERTURE": 4.43, - "miniap_x_MEDIUM_APERTURE": 2.384, - "miniap_y_MEDIUM_APERTURE": 44.967, - "miniap_z_MEDIUM_APERTURE": 15.8, - "sg_x_MEDIUM_APERTURE": 5.285, - "sg_y_MEDIUM_APERTURE": 0.46, - "miniap_x_SMALL_APERTURE": 2.430, - "miniap_y_SMALL_APERTURE": 48.974, - "miniap_z_SMALL_APERTURE": 15.8, - "sg_x_SMALL_APERTURE": 5.3375, - "sg_y_SMALL_APERTURE": -3.55, - "miniap_x_ROBOT_LOAD": 2.386, - "miniap_y_ROBOT_LOAD": 31.40, - "miniap_z_ROBOT_LOAD": 15.8, - "sg_x_ROBOT_LOAD": 5.25, - "sg_y_ROBOT_LOAD": 4.43, - "miniap_x_MANUAL_LOAD": -4.91, - "miniap_y_MANUAL_LOAD": -48.70, - "miniap_z_MANUAL_LOAD": -10.0, - "sg_x_MANUAL_LOAD": -4.7, - "sg_y_MANUAL_LOAD": 1.8, - } - ) - ) +async def aperture_in_medium_pos( + ap_sg: ApertureScatterguard, + aperture_positions: dict[ApertureValue, AperturePosition], +) -> AsyncGenerator[ApertureScatterguard, None]: + await set_to_position(ap_sg, aperture_positions[ApertureValue.MEDIUM]) + set_mock_value(ap_sg.aperture.medium, 1) -@pytest.fixture -def aperture_tolerances(): - return AperturePosition.tolerances_from_gda_params( - GDABeamlineParameters( - { - "miniap_x_tolerance": 0.004, - "miniap_y_tolerance": 0.1, - "miniap_z_tolerance": 0.1, - "sg_x_tolerance": 0.1, - "sg_y_tolerance": 0.1, - } - ) - ) + yield ap_sg def get_all_motors(ap_sg: ApertureScatterguard): @@ -85,50 +44,6 @@ def get_all_motors(ap_sg: ApertureScatterguard): ] -@pytest.fixture -async def ap_sg( - aperture_positions: dict[ApertureValue, AperturePosition], - aperture_tolerances: AperturePosition, -) -> AsyncGenerator[ApertureScatterguard]: - async with init_devices(mock=True): - ap_sg = ApertureScatterguard( - aperture_prefix="-MO-MAPT-01:", - scatterguard_prefix="-MO-SCAT-01:", - name="test_ap_sg", - loaded_positions=aperture_positions, - tolerances=aperture_tolerances, - ) - - with patch_all_motors(ap_sg): - yield ap_sg - - -async def set_to_position( - aperture_scatterguard: ApertureScatterguard, position: AperturePosition -): - aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = position.values - - await asyncio.gather( - aperture_scatterguard.aperture.x.set(aperture_x), - aperture_scatterguard.aperture.y.set(aperture_y), - aperture_scatterguard.aperture.z.set(aperture_z), - aperture_scatterguard.scatterguard.x.set(scatterguard_x), - aperture_scatterguard.scatterguard.y.set(scatterguard_y), - ) - - -@pytest.fixture -async def aperture_in_medium_pos( - ap_sg: ApertureScatterguard, - aperture_positions: dict[ApertureValue, AperturePosition], -) -> AsyncGenerator[ApertureScatterguard, None]: - await set_to_position(ap_sg, aperture_positions[ApertureValue.MEDIUM]) - - set_mock_value(ap_sg.aperture.medium, 1) - - yield ap_sg - - def _assert_patched_ap_sg_has_call( ap_sg: ApertureScatterguard, position: AperturePosition, @@ -304,7 +219,7 @@ async def test_aperture_positions_robot_load( await ap_sg.aperture.z.set(robot_load.aperture_z) reading = await ap_sg.read() assert isinstance(reading, dict) - assert reading[f"{ap_sg.name}-radius"]["value"] == 0.0 + assert reading[f"{ap_sg.name}-radius"]["value"] == inf assert ( reading[f"{ap_sg.name}-selected_aperture"]["value"] == ApertureValue.OUT_OF_BEAM ) @@ -324,7 +239,7 @@ async def test_aperture_positions_robot_load_within_tolerance( await ap_sg.aperture.z.set(robot_load.aperture_z) reading = await ap_sg.read() assert isinstance(reading, dict) - assert reading[f"{ap_sg.name}-radius"]["value"] == 0.0 + assert reading[f"{ap_sg.name}-radius"]["value"] == inf assert ( reading[f"{ap_sg.name}-selected_aperture"]["value"] == ApertureValue.OUT_OF_BEAM ) @@ -358,7 +273,7 @@ async def test_aperture_positions_parked( await ap_sg.aperture.z.set(parked.aperture_z) reading = await ap_sg.read() assert isinstance(reading, dict) - assert reading[f"{ap_sg.name}-radius"]["value"] == 0.0 + assert reading[f"{ap_sg.name}-radius"]["value"] == inf assert reading[f"{ap_sg.name}-selected_aperture"]["value"] == ApertureValue.PARKED @@ -376,7 +291,7 @@ async def test_aperture_positions_parked_within_tolerance( await ap_sg.aperture.z.set(parked_z + tolerance) reading = await ap_sg.read() assert isinstance(reading, dict) - assert reading[f"{ap_sg.name}-radius"]["value"] == 0.0 + assert reading[f"{ap_sg.name}-radius"]["value"] == inf assert reading[f"{ap_sg.name}-selected_aperture"]["value"] == ApertureValue.PARKED diff --git a/tests/devices/util/test_beamline_specific_utils.py b/tests/devices/util/test_beamline_specific_utils.py deleted file mode 100644 index e9876a3b1ac..00000000000 --- a/tests/devices/util/test_beamline_specific_utils.py +++ /dev/null @@ -1,23 +0,0 @@ -import pytest - -from dodal.beamline_specific_utils.i03 import ( - I03_BEAM_HEIGHT_UM, - beam_size_from_aperture, -) - -RADII_AND_SIZES = [ - (None, (None, None)), - (123, (80, I03_BEAM_HEIGHT_UM)), - (23.45, (23.45, I03_BEAM_HEIGHT_UM)), - (50, (50, I03_BEAM_HEIGHT_UM)), - (888, (80, I03_BEAM_HEIGHT_UM)), -] - - -@pytest.mark.parametrize(["aperture_radius", "beam_size"], RADII_AND_SIZES) -def test_beam_size_from_aperture(aperture_radius, beam_size): - beamsize = beam_size_from_aperture( - aperture_radius, - ) - assert beamsize.x_um == beam_size[0] - assert beamsize.y_um == beam_size[1]