mx-bluesky 1.5.15__py3-none-any.whl → 1.5.16__py3-none-any.whl

mx_bluesky/beamlines/i24/jungfrau_commissioning/plan_stubs/do_internal_acquisition.py

@@ -5,18 +5,19 @@ from ophyd_async.core import (
     WatchableAsyncStatus,
 )
 from ophyd_async.fastcs.jungfrau import (
+    GainMode,
     create_jungfrau_internal_triggering_info,
 )
 from pydantic import PositiveInt
 
 from mx_bluesky.beamlines.i24.jungfrau_commissioning.plan_stubs.plan_utils import (
     fly_jungfrau,
-    override_file_path,
 )
 
 
 def do_internal_acquisition(
     exp_time_s: float,
+    gain_mode: GainMode,
     total_frames: PositiveInt = 1,
     jungfrau: CommissioningJungfrau = inject("jungfrau"),
     path_of_output_file: str | None = None,
@@ -31,6 +32,7 @@ def do_internal_acquisition(
 
     Args:
         exp_time_s: Length of detector exposure for each frame.
+        gain_mode: Which gain mode to put the Jungfrau into before starting the acquisition.
         total_frames: Number of frames taken after being internally triggered.
         period_between_frames_s: Time between each detector frame, including deadtime. Not needed if frames_per_triggers is 1.
         jungfrau: Jungfrau device
@@ -39,9 +41,6 @@ def do_internal_acquisition(
         wait: Optionally block until data collection is complete.
     """
 
-    if path_of_output_file:
-        override_file_path(jungfrau, path_of_output_file)
-
     trigger_info = create_jungfrau_internal_triggering_info(total_frames, exp_time_s)
-    status = yield from fly_jungfrau(jungfrau, trigger_info, wait=wait)
+    status = yield from fly_jungfrau(jungfrau, trigger_info, gain_mode, wait=wait)
     return status

mx_bluesky/beamlines/i24/jungfrau_commissioning/plan_stubs/plan_utils.py

@@ -1,4 +1,4 @@
-from pathlib import PurePath
+from collections.abc import Callable
 from typing import cast
 
 import bluesky.plan_stubs as bps
@@ -6,11 +6,10 @@ from bluesky.utils import MsgGenerator
 from dodal.common.watcher_utils import log_on_percentage_complete
 from dodal.devices.i24.commissioning_jungfrau import CommissioningJungfrau
 from ophyd_async.core import (
-    AutoIncrementingPathProvider,
-    StaticFilenameProvider,
     TriggerInfo,
     WatchableAsyncStatus,
 )
+from ophyd_async.fastcs.jungfrau import GainMode
 
 from mx_bluesky.common.utils.log import LOGGER
 
@@ -20,8 +19,11 @@ JF_COMPLETE_GROUP = "JF complete"
 def fly_jungfrau(
     jungfrau: CommissioningJungfrau,
     trigger_info: TriggerInfo,
+    gain_mode: GainMode,
     wait: bool = False,
     log_on_percentage_prefix="Jungfrau data collection triggers received",
+    read_hardware_after_prepare_plan: Callable[..., MsgGenerator]
+    | None = None,  # Param needs refactor: https://github.com/DiamondLightSource/mx-bluesky/issues/819
 ) -> MsgGenerator[WatchableAsyncStatus]:
     """Stage, prepare, and kickoff Jungfrau with a configured TriggerInfo. Optionally wait
     for completion.
@@ -32,13 +34,21 @@ def fly_jungfrau(
     Args:
     jungfrau: Jungfrau device.
     trigger_info: TriggerInfo which should be acquired using jungfrau util functions.
+    gain_mode: Which gain mode to put the Jungfrau into before starting the acquisition.
     wait: Optionally block until data collection is complete.
     log_on_percentage_prefix: String that will be appended to the "percentage completion" logging message.
+    read_hardware_after_prepare_plan: Optionally add a plan which will be ran in between preparing the jungfrau and starting
+    acquisition. This is useful for reading devices after they have been prepared, especially since the file writing path
+    is calculated during prepare.
     """
 
+    LOGGER.info(f"Setting Jungfrau to gain mode {gain_mode}")
+    yield from bps.mv(jungfrau.drv.gain_mode, gain_mode)
     LOGGER.info("Preparing detector...")
     yield from bps.prepare(jungfrau, trigger_info, wait=True)
-    LOGGER.info("Detector prepared. Starting acquisition")
+    LOGGER.info("Detector prepared")
+    if read_hardware_after_prepare_plan:
+        yield from read_hardware_after_prepare_plan()
     yield from bps.kickoff(jungfrau, wait=True)
     LOGGER.info("Waiting for acquisition to complete...")
     status = yield from bps.complete(jungfrau, group=JF_COMPLETE_GROUP)
@@ -50,17 +60,3 @@ def fly_jungfrau(
     if wait:
         yield from bps.wait(JF_COMPLETE_GROUP)
     return status
-
-
-def override_file_path(jungfrau: CommissioningJungfrau, path_of_output_file: str):
-    """While we should generally use device instantiation to set the path,
-    during commissioning, it is useful to be able to explicitly set the filename
-    and path.
-
-    This function must be called before the Jungfrau is prepared.
-    """
-    _file_path = PurePath(path_of_output_file)
-    _new_filename_provider = StaticFilenameProvider(_file_path.name)
-    jungfrau._writer._path_info = AutoIncrementingPathProvider(  # noqa: SLF001
-        _new_filename_provider, _file_path.parent
-    )

mx_bluesky/beamlines/i24/parameters/constants.py

@@ -0,0 +1,9 @@
+from pydantic.dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class PlanNameConstants:
+    ROTATION_DEVICE_READ = "ROTATION DEVICE READ"
+    SINGLE_ROTATION_SCAN = "OUTER SINGLE ROTATION SCAN"
+    MULTI_ROTATION_SCAN = "OUTER MULTI ROTATION SCAN"
+    ROTATION_MAIN = "ROTATION MAIN"

mx_bluesky/beamlines/i24/serial/extruder/i24ssx_extruder_collect_py3v2.py

@@ -113,7 +113,7 @@ def laser_check(
     """
     SSX_LOGGER.debug(f"Laser check: {mode}")
 
-    laser_ttl = zebra.mapping.outputs.TTL_PILATUS  # Update with dodal changes
+    laser_ttl = zebra.mapping.outputs.TTL_JUNGFRAU
 
     if mode == "laseron":
         yield from bps.abs_set(

mx_bluesky/beamlines/i24/serial/fixed_target/i24ssx_moveonclick.py

@@ -222,6 +222,6 @@ def start_viewer(oav: OAV, pmac: PMAC, run_engine: RunEngine, oav1: str = OAV1_C
 if __name__ == "__main__":
     run_engine = RunEngine(call_returns_result=True)
     # Get devices out of dodal
-    oav: OAV = i24.oav(connect_immediately=True)
-    pmac: PMAC = i24.pmac(connect_immediately=True)
+    oav: OAV = i24.oav.build(connect_immediately=True)
+    pmac: PMAC = i24.pmac.build(connect_immediately=True)
     start_viewer(oav, pmac, run_engine)

mx_bluesky/common/device_setup_plans/robot_load_unload.py

@@ -5,7 +5,7 @@ import bluesky.preprocessors as bpp
 from bluesky.utils import MsgGenerator
 from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
 from dodal.devices.motors import XYZStage
-from dodal.devices.robot import BartRobot
+from dodal.devices.robot import SAMPLE_LOCATION_EMPTY, BartRobot
 from dodal.devices.smargon import CombinedMove, Smargon, StubPosition
 from dodal.plan_stubs.motor_utils import MoveTooLargeError, home_and_reset_wrapper
 
@@ -14,27 +14,6 @@ from mx_bluesky.common.parameters.constants import (
     HardwareConstants,
     PlanNameConstants,
 )
-from mx_bluesky.common.utils.log import LOGGER
-
-SLEEP_PER_CHECK = 0.1
-
-
-def wait_for_smargon_not_disabled(smargon: Smargon, timeout=60):
-    """Waits for the smargon disabled flag to go low. The robot hardware is responsible
-    for setting this to low when it is safe to move. It does this through a physical
-    connection between the robot and the smargon.
-    """
-    LOGGER.info("Waiting for smargon enabled")
-    times_to_check = int(timeout / SLEEP_PER_CHECK)
-    for _ in range(times_to_check):
-        smargon_disabled = yield from bps.rd(smargon.disabled)
-        if not smargon_disabled:
-            LOGGER.info("Smargon now enabled")
-            return
-        yield from bps.sleep(SLEEP_PER_CHECK)
-    raise TimeoutError(
-        "Timed out waiting for smargon to become enabled after robot load"
-    )
 
 
 def _raise_exception_if_moved_out_of_cryojet(exception):
@@ -117,8 +96,7 @@ def robot_unload(
         yield from bps.save()
 
         def _unload():
-            yield from bps.abs_set(robot, None, wait=True)
-            yield from wait_for_smargon_not_disabled(smargon)
+            yield from bps.abs_set(robot, SAMPLE_LOCATION_EMPTY, wait=True)
 
         gonio_finished = yield from do_plan_while_lower_gonio_at_home(
             _unload(), lower_gonio

mx_bluesky/common/device_setup_plans/setup_zebra_and_shutter.py

@@ -14,7 +14,10 @@ from dodal.devices.zebra.zebra_controlled_shutter import (
     ZebraShutterControl,
 )
 
-from mx_bluesky.common.parameters.constants import ZEBRA_STATUS_TIMEOUT
+from mx_bluesky.common.parameters.constants import (
+    ZEBRA_STATUS_TIMEOUT,
+    PlanGroupCheckpointConstants,
+)
 from mx_bluesky.common.utils.log import LOGGER
 
 """Plans in this file will work as intended if the zebra has the following configuration:
@@ -154,7 +157,7 @@ def setup_zebra_for_rotation(
     shutter_opening_deg: float = 2.5,
     shutter_opening_s: float = 0.04,
     direction: RotationDirection = RotationDirection.POSITIVE,
-    group: str = "setup_zebra_for_rotation",
+    group: str = PlanGroupCheckpointConstants.SETUP_ZEBRA_FOR_ROTATION,
     wait: bool = True,
     ttl_input_for_detector_to_use: int | None = None,
 ):

mx_bluesky/common/experiment_plans/common_flyscan_xray_centre_plan.py

@@ -154,7 +154,7 @@ def common_flyscan_xray_centre(
 
     This plan will also push data to ispyb when used with the ispyb_activation_decorator.
 
-    There are a few other useful decorators to use with this plan, see: verify_undulator_gap_before_run_decorator, transmission_and_xbpm_feedback_for_collection_decorator
+    There are a few other useful decorators to use with this plan, see: verify_undulator_gap_before_run_decorator, common/preprocessors/preprocessors.py
     """
 
     def _overall_tidy():

mx_bluesky/common/experiment_plans/inner_plans/read_hardware.py

@@ -76,6 +76,7 @@ def standard_read_hardware_during_collection(
         detector.bit_depth,
         beamsize,
         detector.cam.roi_mode,
+        detector.ispyb_detector_id,
     ]
     yield from read_hardware_plan(
         signals_to_read_during_collection, DocDescriptorNames.HARDWARE_READ_DURING

mx_bluesky/common/experiment_plans/rotation/rotation_utils.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import dataclasses
+
+from dodal.devices.zebra.zebra import RotationDirection
+from dodal.utils import get_beamline_name
+
+from mx_bluesky.common.parameters.constants import RotationParamConstants
+from mx_bluesky.common.parameters.rotation import SingleRotationScan
+from mx_bluesky.common.utils.log import LOGGER
+
+DEFAULT_DIRECTION = RotationDirection.NEGATIVE
+DEFAULT_MAX_VELOCITY = 120
+# Use a slightly larger time to acceleration than EPICS as it's better to be cautious
+ACCELERATION_MARGIN = 1.5
+
+
+@dataclasses.dataclass
+class RotationMotionProfile:
+    start_scan_deg: float
+    start_motion_deg: float
+    scan_width_deg: float
+    shutter_time_s: float
+    direction: RotationDirection
+    speed_for_rotation_deg_s: float
+    acceleration_offset_deg: float
+    shutter_opening_deg: float
+    total_exposure_s: float
+    distance_to_move_deg: float
+    max_velocity_deg_s: float
+
+
+def calculate_motion_profile(
+    params: SingleRotationScan,
+    motor_time_to_speed_s: float,
+    max_velocity_deg_s: float,
+) -> RotationMotionProfile:
+    """Calculates the various numbers needed for motions in the rotation scan.
+    Rotates through "scan width" plus twice an "offset" to take into account
+    acceleration at the start and deceleration at the end, plus the number of extra
+    degrees of rotation needed to make sure the fast shutter has fully opened before the
+    detector trigger is sent.
+    See https://github.com/DiamondLightSource/hyperion/wiki/rotation-scan-geometry
+    for a simple pictorial explanation."""
+
+    assert params.rotation_increment_deg > 0
+
+    direction = params.rotation_direction
+    start_scan_deg = params.omega_start_deg
+
+    if RotationParamConstants.OMEGA_FLIP:
+        # If omega_flip is True then the motor omega axis is inverted with respect to the
+        # coordinate system.
+        start_scan_deg = -start_scan_deg
+        direction = (
+            direction.POSITIVE
+            if direction == direction.NEGATIVE
+            else direction.NEGATIVE
+        )
+
+    num_images = params.num_images
+    shutter_time_s = params.shutter_opening_time_s
+    image_width_deg = params.rotation_increment_deg
+    exposure_time_s = params.exposure_time_s
+    motor_time_to_speed_s *= ACCELERATION_MARGIN
+
+    LOGGER.info("Calculating rotation scan motion profile:")
+    LOGGER.info(
+        f"{num_images=}, {shutter_time_s=}, {image_width_deg=}, {exposure_time_s=}, {direction=}"
+    )
+
+    scan_width_deg = num_images * params.rotation_increment_deg
+    LOGGER.info(f"{scan_width_deg=} = {num_images=} * {params.rotation_increment_deg=}")
+
+    speed_for_rotation_deg_s = image_width_deg / exposure_time_s
+    LOGGER.info("speed_for_rotation_deg_s = image_width_deg / exposure_time_s")
+    LOGGER.info(
+        f"{speed_for_rotation_deg_s=} = {image_width_deg=} / {exposure_time_s=}"
+    )
+
+    acceleration_offset_deg = motor_time_to_speed_s * speed_for_rotation_deg_s
+    LOGGER.info(
+        f"{acceleration_offset_deg=} = {motor_time_to_speed_s=} * {speed_for_rotation_deg_s=}"
+    )
+
+    start_motion_deg = start_scan_deg - (acceleration_offset_deg * direction.multiplier)
+    LOGGER.info(
+        f"{start_motion_deg=} = {start_scan_deg=} - ({acceleration_offset_deg=} * {direction.multiplier=})"
+    )
+
+    shutter_opening_deg = speed_for_rotation_deg_s * shutter_time_s
+    LOGGER.info(
+        f"{shutter_opening_deg=} = {speed_for_rotation_deg_s=} * {shutter_time_s=}"
+    )
+
+    shutter_opening_deg = speed_for_rotation_deg_s * shutter_time_s
+    LOGGER.info(
+        f"{shutter_opening_deg=} = {speed_for_rotation_deg_s=} * {shutter_time_s=}"
+    )
+
+    total_exposure_s = num_images * exposure_time_s
+    LOGGER.info(f"{total_exposure_s=} = {num_images=} * {exposure_time_s=}")
+
+    distance_to_move_deg = (
+        scan_width_deg + shutter_opening_deg + acceleration_offset_deg * 2
+    ) * direction.multiplier
+    LOGGER.info(
+        f"{distance_to_move_deg=} = ({scan_width_deg=} + {shutter_opening_deg=} + {acceleration_offset_deg=} * 2) * {direction=})"
+    )
+
+    # See https://github.com/DiamondLightSource/mx-bluesky/issues/1224
+    if get_beamline_name("i03") == "i24":
+        acceleration_offset_deg = 10
+
+    return RotationMotionProfile(
+        start_scan_deg=start_scan_deg,
+        start_motion_deg=start_motion_deg,
+        scan_width_deg=scan_width_deg,
+        shutter_time_s=shutter_time_s,
+        direction=direction,
+        speed_for_rotation_deg_s=speed_for_rotation_deg_s,
+        acceleration_offset_deg=acceleration_offset_deg,
+        shutter_opening_deg=shutter_opening_deg,
+        total_exposure_s=total_exposure_s,
+        distance_to_move_deg=distance_to_move_deg,
+        max_velocity_deg_s=max_velocity_deg_s,
+    )

mx_bluesky/common/external_interaction/callbacks/common/ispyb_callback_base.py

@@ -23,7 +23,7 @@ from mx_bluesky.common.external_interaction.ispyb.ispyb_store import (
 )
 from mx_bluesky.common.external_interaction.ispyb.ispyb_utils import get_ispyb_config
 from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
-from mx_bluesky.common.parameters.constants import DocDescriptorNames
+from mx_bluesky.common.parameters.constants import USE_NUMTRACKER, DocDescriptorNames
 from mx_bluesky.common.utils.log import (
     ISPYB_ZOCALO_CALLBACK_LOGGER,
     format_doc_for_log,
@@ -86,6 +86,17 @@ class BaseISPyBCallback(PlanReactiveCallback):
 
     def activity_gated_start(self, doc: RunStart):
         self._oav_snapshot_event_idx = 0
+
+        if self.params and self.params.visit == USE_NUMTRACKER:
+            try:
+                visit = doc.get("instrument_session")
+                assert isinstance(visit, str)
+                self.params.visit = visit
+            except Exception as e:
+                raise ValueError(
+                    f"Error trying to retrieve instrument session from document {doc}"
+                ) from e
+
         return self.tag_doc(doc)
 
     def activity_gated_descriptor(self, doc: EventDescriptor):
@@ -124,7 +135,6 @@ class BaseISPyBCallback(PlanReactiveCallback):
         )
         synchrotron_mode = doc["data"]["synchrotron-synchrotron_mode"]
         assert isinstance(synchrotron_mode, SynchrotronMode)
-
         hwscan_data_collection_info = DataCollectionInfo(
             undulator_gap1=doc["data"]["undulator-current_gap"],
             synchrotron_mode=synchrotron_mode.value,
@@ -159,6 +169,7 @@ class BaseISPyBCallback(PlanReactiveCallback):
             beamsize_at_sampley=beamsize_y_mm,
             flux=doc["data"]["flux-flux_reading"],
             detector_mode="ROI" if doc["data"]["eiger_cam_roi_mode"] else "FULL",
+            ispyb_detector_id=doc["data"]["eiger-ispyb_detector_id"],
         )
         if transmission := doc["data"]["attenuator-actual_transmission"]:
             # Ispyb wants the transmission in a percentage, we use fractions

mx_bluesky/common/external_interaction/callbacks/common/ispyb_mapping.py

@@ -9,7 +9,6 @@ from mx_bluesky.common.external_interaction.ispyb.ispyb_utils import (
 )
 from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
 
-I03_EIGER_DETECTOR = 78
 EIGER_FILE_SUFFIX = "h5"
 
 
@@ -31,7 +30,6 @@ def populate_remaining_data_collection_info(
     data_collection_info.sample_id = params.sample_id
     data_collection_info.visit_string = params.visit
     data_collection_info.parent_id = data_collection_group_id
-    data_collection_info.detector_id = I03_EIGER_DETECTOR
     data_collection_info.comments = comment
     data_collection_info.detector_distance = params.detector_params.detector_distance
     data_collection_info.exp_time = params.detector_params.exposure_time_s

mx_bluesky/common/external_interaction/ispyb/data_model.py

@@ -40,7 +40,7 @@ class DataCollectionInfo:
     kappa_start: float | None = None
 
     visit_string: str | None = None
-    detector_id: int | None = None
+    ispyb_detector_id: int | None = None
     axis_start: float | None = None
     slitgap_vertical: float | None = None
     slitgap_horizontal: float | None = None

mx_bluesky/common/external_interaction/ispyb/exp_eye_store.py

@@ -282,7 +282,7 @@ def _data_collection_info_to_json(data: DataCollectionInfo) -> dict:
             "axisEnd": data.axis_end,
             "chiStart": data.chi_start,
             "kappaStart": data.kappa_start,
-            "detectorId": data.detector_id,
+            "detectorId": data.ispyb_detector_id,
             "axisStart": data.axis_start,
             "slitGapVertical": data.slitgap_vertical,
             "slitGapHorizontal": data.slitgap_horizontal,

mx_bluesky/common/parameters/components.py

@@ -25,6 +25,7 @@ from semver import Version
 
 from mx_bluesky.common.parameters.constants import (
     TEST_MODE,
+    USE_NUMTRACKER,
     DetectorParamConstants,
     GridscanParamConstants,
 )
@@ -32,6 +33,10 @@ from mx_bluesky.common.parameters.constants import (
 PARAMETER_VERSION = Version.parse("5.3.0")
 
 
+def get_param_version() -> SemanticVersion:
+    return SemanticVersion.validate_from_str(str(PARAMETER_VERSION))
+
+
 class RotationAxis(StrEnum):
     OMEGA = "omega"
     PHI = "phi"
@@ -152,8 +157,8 @@ class WithVisit(BaseModel):
     det_dist_to_beam_converter_path: str = Field(
         default=DetectorParamConstants.BEAM_XY_LUT_PATH
     )
-    insertion_prefix: str = "SR03S" if TEST_MODE else "SR03I"
     detector_distance_mm: float | None = Field(default=None, gt=0)
+    insertion_prefix: str = "SR03S" if TEST_MODE else "SR03I"
 
 
 class DiffractionExperiment(
@@ -176,12 +181,17 @@ class DiffractionExperiment(
     @model_validator(mode="before")
     @classmethod
     def validate_directories(cls, values):
-        os.makedirs(values["storage_directory"], exist_ok=True)
-
-        values["snapshot_directory"] = values.get(
-            "snapshot_directory",
-            Path(values["storage_directory"], "snapshots").as_posix(),
-        )
+        # Plans using numtracker currently won't work with snapshot directories:
+        # see https://github.com/DiamondLightSource/mx-bluesky/issues/1527
+        if values["storage_directory"] != USE_NUMTRACKER:
+            os.makedirs(values["storage_directory"], exist_ok=True)
+
+            values["snapshot_directory"] = values.get(
+                "snapshot_directory",
+                Path(values["storage_directory"], "snapshots").as_posix(),
+            )
+        else:
+            values["snapshot_directory"] = Path("/tmp")
         return values
 
     @property

mx_bluesky/common/parameters/constants.py

@@ -9,6 +9,9 @@ from pydantic.dataclasses import dataclass
 
 from mx_bluesky.definitions import ROOT_DIR
 
+# Use as visit if numtracker is being used
+USE_NUMTRACKER = "from numtracker"
+
 BEAMLINE = get_beamline_name("test")
 TEST_MODE = BEAMLINE == "test"
 ZEBRA_STATUS_TIMEOUT = 30
@@ -111,6 +114,8 @@ class GridscanParamConstants:
 @dataclass(frozen=True)
 class RotationParamConstants:
     DEFAULT_APERTURE_POSITION = ApertureValue.LARGE
+    DEFAULT_SHUTTER_TIME_S = 0.06
+    OMEGA_FLIP = True  # See https://github.com/DiamondLightSource/mx-bluesky/issues/1223 to make beamline-specific
 
 
 @dataclass(frozen=True)
@@ -138,6 +143,7 @@ class PlanGroupCheckpointConstants:
     MOVE_GONIO_TO_START = "move_gonio_to_start"
     READY_FOR_OAV = "ready_for_oav"
     PREPARE_APERTURE = "prepare_aperture"
+    SETUP_ZEBRA_FOR_ROTATION = "setup_zebra_for_rotation"
 
 
 # Eventually replace below with https://github.com/DiamondLightSource/mx-bluesky/issues/798

mx_bluesky/{hyperion → common}/parameters/rotation.py

@@ -28,9 +28,9 @@ from mx_bluesky.common.parameters.components import (
     WithSample,
     WithScan,
 )
-from mx_bluesky.hyperion.parameters.constants import (
-    CONST,
-    I03Constants,
+from mx_bluesky.common.parameters.constants import (
+    DetectorParamConstants,
+    RotationParamConstants,
 )
 
 
@@ -56,7 +56,9 @@ class RotationScanPerSweep(OptionalGonioAngleStarts, OptionalXyzStarts, WithSamp
 
 
 class RotationExperiment(DiffractionExperiment):
-    shutter_opening_time_s: float = Field(default=CONST.I03.SHUTTER_TIME_S)
+    shutter_opening_time_s: float = Field(
+        default=RotationParamConstants.DEFAULT_SHUTTER_TIME_S
+    )
     rotation_increment_deg: float = Field(default=0.1, gt=0)
     ispyb_experiment_type: IspybExperimentType = Field(
         default=IspybExperimentType.ROTATION
@@ -67,7 +69,7 @@ class RotationExperiment(DiffractionExperiment):
     ) -> DetectorParams:
         self.det_dist_to_beam_converter_path = (
             self.det_dist_to_beam_converter_path
-            or CONST.PARAM.DETECTOR.BEAM_XY_LUT_PATH
+            or DetectorParamConstants.BEAM_XY_LUT_PATH
         )
         optional_args = {}
         if self.run_number:
@@ -75,7 +77,7 @@ class RotationExperiment(DiffractionExperiment):
         assert self.detector_distance_mm is not None
         os.makedirs(self.storage_directory, exist_ok=True)
         return DetectorParams(
-            detector_size_constants=I03Constants.DETECTOR,
+            detector_size_constants=DetectorParamConstants.DETECTOR,
             expected_energy_ev=self.demand_energy_ev,
             exposure_time_s=self.exposure_time_s,
             directory=self.storage_directory,
@@ -97,7 +99,7 @@ class RotationExperiment(DiffractionExperiment):
     @classmethod
     def _set_default_aperture_position(cls, aperture_position: ApertureValue | None):
         if not aperture_position:
-            default_aperture = CONST.PARAM.ROTATION.DEFAULT_APERTURE_POSITION
+            default_aperture = RotationParamConstants.DEFAULT_APERTURE_POSITION
             LOGGER.warning(
                 f"No aperture position selected. Defaulting to {default_aperture}"
             )
@@ -107,7 +109,7 @@ class RotationExperiment(DiffractionExperiment):
 
 
 class SingleRotationScan(
-    WithScan, RotationScanPerSweep, RotationExperiment, DiffractionExperimentWithSample
+    WithScan, RotationExperiment, RotationScanPerSweep, DiffractionExperimentWithSample
 ):
     @property
     def detector_params(self):