mx-bluesky 1.4.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

mx_bluesky/beamlines/i24/serial/write_nexus.py

@@ -1,105 +1,107 @@
-import logging
 import os
 import pathlib
 import pprint
 import time
 from datetime import datetime
-from typing import Literal
 
 import requests
 
 from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import ChipType, MappingType
+from mx_bluesky.beamlines.i24.serial.log import SSX_LOGGER
 from mx_bluesky.beamlines.i24.serial.parameters import (
     ExtruderParameters,
     FixedTargetParameters,
 )
-from mx_bluesky.beamlines.i24.serial.setup_beamline import Eiger, caget, cagetstring
-
-logger = logging.getLogger("I24ssx.nexus_writer")
+from mx_bluesky.beamlines.i24.serial.setup_beamline import Eiger, caget
 
 
 def call_nexgen(
     chip_prog_dict: dict | None,
-    start_time: datetime,
     parameters: ExtruderParameters | FixedTargetParameters,
-    wavelength: float,
-    expt_type: Literal["fixed-target", "extruder"] = "fixed-target",
+    wavelength_in_a: float,
+    beam_center_in_pix: tuple[float, float],
+    start_time: datetime | None = None,
 ):
-    det_type = parameters.detector_name
-    print(f"det_type: {det_type}")
+    """Call the nexus writer by sending a request to nexgen-server.
+
+    Args:
+        chip_prog_dict (dict | None): Dictionary containing most of the information \
+            passed to the program runner for the collection. Only used for fixed target.
+        start_time
+        parameters (SerialAndLaserExperiment): Collection parameters.
+        wavelength_in_a (float): Wavelength, in A.
+        beam_center_in_pix (list[float]): Beam center position on detector, in pixels.
+        start_time (datetime, optional): Collection start time.
+
+    Raises:
+        ValueError: For a wrong experiment type passed (either unknwon or not matched \
+            to parameter model).
 
+    """
     current_chip_map = None
-    if expt_type == "fixed-target" and isinstance(parameters, FixedTargetParameters):
-        if not (
-            parameters.map_type == MappingType.NoMap
-            or parameters.chip.chip_type == ChipType.Custom
-        ):
-            # NOTE Nexgen server is still on nexgen v0.7.2 (fully working for ssx)
-            # Will need to be updated, for correctness sake map needs to be None.
-            current_chip_map = "/dls_sw/i24/scripts/fastchips/litemaps/currentchip.map"
-        pump_status = bool(parameters.pump_repeat)
-        total_numb_imgs = parameters.total_num_images
-    elif expt_type == "extruder" and isinstance(parameters, ExtruderParameters):
-        # chip_prog_dict should be None for extruder (passed as input for now)
-        total_numb_imgs = parameters.num_images
-        pump_status = parameters.pump_status
-    else:
-        raise ValueError(f"{expt_type=} not recognised")
+    match parameters:
+        case FixedTargetParameters():
+            if not (
+                parameters.map_type == MappingType.NoMap
+                or parameters.chip.chip_type == ChipType.Custom
+            ):
+                # NOTE Nexgen server is still on nexgen v0.7.2 (fully working for ssx)
+                # Will need to be updated, for correctness sake map needs to be None.
+                current_chip_map = (
+                    "/dls_sw/i24/scripts/fastchips/litemaps/currentchip.map"
+                )
+            pump_status = bool(parameters.pump_repeat)
+            total_numb_imgs = parameters.total_num_images
+        case ExtruderParameters():
+            total_numb_imgs = parameters.num_images
+            pump_status = parameters.pump_status
 
-    filename_prefix = cagetstring(Eiger.pv.filenameRBV)
-    meta_h5 = (
-        pathlib.Path(parameters.visit)
-        / parameters.directory
-        / f"{filename_prefix}_meta.h5"
-    )
+    filename_prefix = parameters.filename
+    meta_h5 = parameters.visit / parameters.directory / f"{filename_prefix}_meta.h5"
     t0 = time.time()
     max_wait = 60  # seconds
-    logger.info(f"Watching for {meta_h5}")
+    SSX_LOGGER.info(f"Watching for {meta_h5}")
     while time.time() - t0 < max_wait:
         if meta_h5.exists():
-            logger.info(f"Found {meta_h5} after {time.time() - t0:.1f} seconds")
+            SSX_LOGGER.info(f"Found {meta_h5} after {time.time() - t0:.1f} seconds")
             time.sleep(5)
             break
-        logger.debug(f"Waiting for {meta_h5}")
+        SSX_LOGGER.debug(f"Waiting for {meta_h5}")
         time.sleep(1)
     if not meta_h5.exists():
-        logger.warning(f"Giving up waiting for {meta_h5} after {max_wait} seconds")
-        return False
-
-    transmission = (float(caget(Eiger.pv.transmission)),)
+        SSX_LOGGER.warning(f"Giving up waiting for {meta_h5} after {max_wait} seconds")
+        return
 
-    if det_type == Eiger.name:
-        bit_depth = int(caget(Eiger.pv.bit_depth))
-        logger.debug(
-            f"Call to nexgen server with the following chip definition: \n{chip_prog_dict}"
-        )
+    bit_depth = int(caget(Eiger.pv.bit_depth))
+    SSX_LOGGER.debug(
+        f"Call to nexgen server with the following chip definition: \n{chip_prog_dict}"
+    )
 
-        access_token = pathlib.Path("/scratch/ssx_nexgen.key").read_text().strip()
-        url = "https://ssx-nexgen.diamond.ac.uk/ssx_eiger/write"
-        headers = {"Authorization": f"Bearer {access_token}"}
+    access_token = pathlib.Path("/scratch/ssx_nexgen.key").read_text().strip()
+    url = "https://ssx-nexgen.diamond.ac.uk/ssx_eiger/write"
+    headers = {"Authorization": f"Bearer {access_token}"}
 
-        payload = {
-            "beamline": "i24",
-            "beam_center": [caget(Eiger.pv.beamx), caget(Eiger.pv.beamy)],
-            "chipmap": current_chip_map,
-            "chip_info": chip_prog_dict,
-            "det_dist": parameters.detector_distance_mm,
-            "exp_time": parameters.exposure_time_s,
-            "expt_type": expt_type,
-            "filename": filename_prefix,
-            "num_imgs": total_numb_imgs,
-            "pump_status": pump_status,
-            "pump_exp": parameters.laser_dwell_s,
-            "pump_delay": parameters.laser_delay_s,
-            "transmission": transmission[0],
-            "visitpath": os.fspath(meta_h5.parent),
-            "wavelength": wavelength,
-            "bit_depth": bit_depth,
-        }
-        logger.info(f"Sending POST request to {url} with payload:")
-        logger.info(pprint.pformat(payload))
-        response = requests.post(url, headers=headers, json=payload)
-        logger.info(f"Response: {response.text} (status code: {response.status_code})")
-        # the following will raise an error if the request was unsuccessful
-        return response.status_code == requests.codes.ok
-    return False
+    payload = {
+        "beamline": "i24",
+        "beam_center": beam_center_in_pix,
+        "chipmap": current_chip_map,
+        "chip_info": chip_prog_dict,
+        "det_dist": parameters.detector_distance_mm,
+        "exp_time": parameters.exposure_time_s,
+        "expt_type": parameters.nexgen_experiment_type,
+        "filename": filename_prefix,
+        "num_imgs": total_numb_imgs,
+        "pump_status": pump_status,
+        "pump_exp": parameters.laser_dwell_s,
+        "pump_delay": parameters.laser_delay_s,
+        "transmission": parameters.transmission,
+        "visitpath": os.fspath(meta_h5.parent),
+        "wavelength": wavelength_in_a,
+        "bit_depth": bit_depth,
+        "start_time": start_time,
+    }
+    SSX_LOGGER.info(f"Sending POST request to {url} with payload:")
+    SSX_LOGGER.info(pprint.pformat(payload))
+    response = requests.post(url, headers=headers, json=payload)
+    response.raise_for_status()
+    SSX_LOGGER.info(f"Response: {response.text} (status code: {response.status_code})")

mx_bluesky/common/external_interaction/config_server.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from functools import cache
+
+from daq_config_server.client import ConfigServer
+from pydantic import BaseModel, Field, model_validator
+
+
+class FeatureFlags(BaseModel, ABC):
+    """Abstract class to use ConfigServer to toggle features for an experiment
+
+    A module wanting to use FeatureFlags should inherit this class, add boolean features
+    as attributes, and implement a get_config_server method, which returns a cached creation of
+    ConfigServer. See HyperionFeatureFlags for an example
+
+    Values supplied upon class instantiation will always take priority over the config server. If connection to the server cannot
+    be made AND values were not supplied, attributes will use their default values
+    """
+
+    # Feature values supplied at construction will override values from the config server
+    overriden_features: dict = Field(default_factory=dict, exclude=True)
+
+    @staticmethod
+    @cache
+    @abstractmethod
+    def get_config_server() -> ConfigServer: ...
+
+    @model_validator(mode="before")
+    @classmethod
+    def mark_overridden_features(cls, values):
+        assert isinstance(values, dict)
+        values["overriden_features"] = values.copy()
+        return values
+
+    def _get_flags(self):
+        flags = type(self).get_config_server().best_effort_get_all_feature_flags()
+        return {f: flags[f] for f in flags if f in self.model_fields.keys()}
+
+    def update_self_from_server(self):
+        """Used to update the feature flags from the server during a plan. Where there are flags which were explicitly set from externally supplied parameters, these values will be used instead."""
+        for flag, value in self._get_flags().items():
+            updated_value = (
+                value
+                if flag not in self.overriden_features.keys()
+                else self.overriden_features[flag]
+            )
+            setattr(self, flag, updated_value)

mx_bluesky/common/parameters/components.py

@@ -1,21 +1,33 @@
-import json
+from __future__ import annotations
+
+import os
 from abc import abstractmethod
 from collections.abc import Sequence
 from enum import StrEnum
 from pathlib import Path
-from typing import SupportsInt
+from typing import Literal, SupportsInt, cast
 
 from dodal.devices.aperturescatterguard import ApertureValue
 from dodal.devices.detector import (
     DetectorParams,
     TriggerMode,
 )
-from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_validator,
+    model_validator,
+)
 from pydantic_extra_types.semantic_version import SemanticVersion
 from scanspec.core import AxesPoints
 from semver import Version
 
-from mx_bluesky.common.parameters.constants import TEST_MODE, DetectorParamConstants
+from mx_bluesky.common.parameters.constants import (
+    TEST_MODE,
+    DetectorParamConstants,
+    GridscanParamConstants,
+)
 
 PARAMETER_VERSION = Version.parse("5.2.0")
 
@@ -100,11 +112,6 @@ class MxBlueskyParameters(BaseModel):
         ), f"Parameter version too new! This version of hyperion uses {PARAMETER_VERSION}"
         return version
 
-    @classmethod
-    def from_json(cls, input: str | None):
-        assert input is not None
-        return cls(**json.loads(input))
-
 
 class WithSnapshot(BaseModel):
     snapshot_directory: Path
@@ -146,12 +153,12 @@ class DiffractionExperiment(
 
     @model_validator(mode="before")
     @classmethod
-    def validate_snapshot_directory(cls, values):
-        snapshot_dir = values.get(
-            "snapshot_directory", Path(values["storage_directory"], "snapshots")
-        )
-        values["snapshot_directory"] = (
-            snapshot_dir if isinstance(snapshot_dir, Path) else Path(snapshot_dir)
+    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(),
         )
         return values
 
@@ -176,6 +183,14 @@ class WithScan(BaseModel):
     def num_images(self) -> int: ...
 
 
+class WithPandaGridScan(BaseModel):
+    """For experiments which use a PandA for constant-motion grid scans"""
+
+    panda_runup_distance_mm: float = Field(
+        default=GridscanParamConstants.PANDA_RUN_UP_DISTANCE_MM
+    )
+
+
 class SplitScan(BaseModel):
     @property
     @abstractmethod
@@ -193,6 +208,28 @@ class WithSample(BaseModel):
 class DiffractionExperimentWithSample(DiffractionExperiment, WithSample): ...
 
 
+class MultiXtalSelection(BaseModel):
+    name: str
+
+
+class TopNByMaxCountSelection(MultiXtalSelection):
+    name: Literal["TopNByMaxCount"] = "TopNByMaxCount"  #  pyright: ignore [reportIncompatibleVariableOverride]
+    n: int
+
+
+class WithCentreSelection(BaseModel):
+    select_centres: TopNByMaxCountSelection = Field(
+        discriminator="name", default=TopNByMaxCountSelection(n=1)
+    )
+
+    @property
+    def selection_params(self) -> MultiXtalSelection:
+        """A helper property because pydantic does not allow polymorphism with base classes
+        # only type unions"""
+        cast1 = cast(MultiXtalSelection, self.select_centres)
+        return cast1
+
+
 class OptionalXyzStarts(BaseModel):
     x_start_um: float | None = None
     y_start_um: float | None = None

mx_bluesky/common/parameters/constants.py

@@ -1,6 +1,7 @@
 from enum import Enum
 
 from dodal.devices.aperturescatterguard import ApertureValue
+from dodal.devices.detector import EIGER2_X_16M_SIZE
 from dodal.devices.zocalo.zocalo_constants import ZOCALO_ENV as ZOCALO_ENV_FROM_DODAL
 from dodal.utils import get_beamline_name
 from pydantic.dataclasses import dataclass
@@ -18,7 +19,9 @@ class DocDescriptorNames:
     OAV_GRID_SNAPSHOT_TRIGGERED = "snapshot_to_ispyb"
     HARDWARE_READ_PRE = "read_hardware_for_callbacks_pre_collection"
     HARDWARE_READ_DURING = "read_hardware_for_callbacks_during_collection"
+    SAMPLE_HANDLING_EXCEPTION = "sample_handling_exception"
     ZOCALO_HW_READ = "zocalo_read_hardware_plan"
+    FLYSCAN_RESULTS = "flyscan_results_obtained"
 
 
 @dataclass(frozen=True)
@@ -34,6 +37,7 @@ class OavConstants:
 
 @dataclass(frozen=True)
 class PlanNameConstants:
+    LOAD_CENTRE_COLLECT = "load_centre_collect"
     # Robot load subplan
     ROBOT_LOAD = "robot_load"
     # Gridscan
@@ -43,10 +47,14 @@ class PlanNameConstants:
     GRIDSCAN_AND_MOVE = "run_gridscan_and_move"
     GRIDSCAN_MAIN = "run_gridscan"
     DO_FGS = "do_fgs"
+    # IspyB callback activation
+    ISPYB_ACTIVATION = "ispyb_activation"
+    ROBOT_LOAD_AND_SNAPSHOTS = "robot_load_and_snapshots"
     # Rotation scan
     ROTATION_MULTI = "multi_rotation_wrapper"
     ROTATION_OUTER = "rotation_scan_with_cleanup"
     ROTATION_MAIN = "rotation_scan_main"
+    FLYSCAN_RESULTS = "xray_centre_results"
 
 
 @dataclass(frozen=True)
@@ -64,6 +72,7 @@ class HardwareConstants:
     OAV_REFRESH_DELAY = 0.3
     PANDA_FGS_RUN_UP_DEFAULT = 0.17
     CRYOJET_MARGIN_MM = 0.2
+    THAWING_TIME = 20
 
 
 @dataclass(frozen=True)
@@ -87,8 +96,9 @@ class DetectorParamConstants:
     BEAM_XY_LUT_PATH = (
         "tests/test_data/test_det_dist_converter.txt"
         if TEST_MODE
-        else "/dls_sw/{BEAMLINE}/software/daq_configuration/lookup/DetDistToBeamXYConverter.txt"
+        else f"/dls_sw/{BEAMLINE}/software/daq_configuration/lookup/DetDistToBeamXYConverter.txt"
     )
+    DETECTOR = EIGER2_X_16M_SIZE
 
 
 @dataclass(frozen=True)

mx_bluesky/common/parameters/gridscan.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import os
+
+from dodal.devices.aperturescatterguard import ApertureValue
+from dodal.devices.detector import (
+    DetectorParams,
+)
+from pydantic import Field
+
+from mx_bluesky.common.parameters.components import (
+    DiffractionExperimentWithSample,
+    IspybExperimentType,
+    OptionalGonioAngleStarts,
+    WithScan,
+    XyzStarts,
+)
+from mx_bluesky.common.parameters.constants import (
+    DetectorParamConstants,
+    GridscanParamConstants,
+    HardwareConstants,
+)
+from mx_bluesky.common.parameters.robot_load import RobotLoadAndEnergyChange
+
+
+class GridCommon(
+    DiffractionExperimentWithSample,
+    OptionalGonioAngleStarts,
+):
+    grid_width_um: float = Field(default=GridscanParamConstants.WIDTH_UM)
+    exposure_time_s: float = Field(default=GridscanParamConstants.EXPOSURE_TIME_S)
+    use_roi_mode: bool = Field(default=GridscanParamConstants.USE_ROI)
+
+    ispyb_experiment_type: IspybExperimentType = Field(
+        default=IspybExperimentType.GRIDSCAN_3D
+    )
+    selected_aperture: ApertureValue | None = Field(default=ApertureValue.SMALL)
+
+    @property
+    def detector_params(self):
+        self.det_dist_to_beam_converter_path = (
+            self.det_dist_to_beam_converter_path
+            or DetectorParamConstants.BEAM_XY_LUT_PATH
+        )
+        optional_args = {}
+        if self.run_number:
+            optional_args["run_number"] = self.run_number
+        assert (
+            self.detector_distance_mm is not None
+        ), "Detector distance must be filled before generating DetectorParams"
+        os.makedirs(self.storage_directory, exist_ok=True)
+        return DetectorParams(
+            detector_size_constants=DetectorParamConstants.DETECTOR,
+            expected_energy_ev=self.demand_energy_ev,
+            exposure_time=self.exposure_time_s,
+            directory=self.storage_directory,
+            prefix=self.file_name,
+            detector_distance=self.detector_distance_mm,
+            omega_start=self.omega_start_deg or 0,
+            omega_increment=0,
+            num_images_per_trigger=1,
+            num_triggers=self.num_images,
+            use_roi_mode=self.use_roi_mode,
+            det_dist_to_beam_converter_path=self.det_dist_to_beam_converter_path,
+            trigger_mode=self.trigger_mode,
+            **optional_args,
+        )
+
+
+class RobotLoadThenCentre(GridCommon):
+    thawing_time: float = Field(default=HardwareConstants.THAWING_TIME)
+
+    def robot_load_params(self):
+        my_params = self.model_dump()
+        return RobotLoadAndEnergyChange(**my_params)
+
+    def pin_centre_then_xray_centre_params(self):
+        my_params = self.model_dump()
+        del my_params["thawing_time"]
+        return PinTipCentreThenXrayCentre(**my_params)
+
+
+class GridScanWithEdgeDetect(GridCommon):
+    box_size_um: float = Field(default=GridscanParamConstants.BOX_WIDTH_UM)
+
+
+class PinTipCentreThenXrayCentre(GridCommon):
+    tip_offset_um: float = 0
+
+
+class SpecifiedGrid(XyzStarts, WithScan):
+    """A specified grid is one which has defined values for the start position,
+    grid and box sizes, etc., as opposed to parameters for a plan which will create
+    those parameters at some point (e.g. through optical pin detection)."""

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

@@ -7,10 +7,10 @@ from mx_bluesky.common.parameters.components import (
     WithSnapshot,
     WithVisit,
 )
-from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.common.parameters.constants import HardwareConstants
 
 
 class RobotLoadAndEnergyChange(
     MxBlueskyParameters, WithSample, WithSnapshot, WithOptionalEnergyChange, WithVisit
 ):
-    thawing_time: float = Field(default=CONST.I03.THAWING_TIME)
+    thawing_time: float = Field(default=HardwareConstants.THAWING_TIME)

mx_bluesky/common/plans/do_fgs.py

@@ -3,7 +3,7 @@ from time import time
 
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
-from blueapi.core import MsgGenerator
+from bluesky.utils import MsgGenerator
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.fast_grid_scan import FastGridScanCommon
 from dodal.devices.synchrotron import Synchrotron
@@ -11,7 +11,7 @@ from dodal.devices.zocalo.zocalo_results import (
     ZOCALO_STAGE_GROUP,
 )
 from dodal.log import LOGGER
-from dodal.plans.check_topup import check_topup_and_wait_if_necessary
+from dodal.plan_stubs.check_topup import check_topup_and_wait_if_necessary
 from scanspec.core import AxesPoints, Axis
 
 from mx_bluesky.common.device_setup_plans.read_hardware_for_setup import (

mx_bluesky/common/utils/log.py

@@ -12,6 +12,8 @@ from dodal.log import (
 )
 from dodal.log import LOGGER as dodal_logger
 
+LOGGER = logging.getLogger("mx-bluesky")
+
 __logger_handlers: DodalLogHandlers | None = None
 
 

mx_bluesky/hyperion/__main__.py

@@ -7,9 +7,10 @@ from queue import Queue
 from traceback import format_exception
 from typing import Any
 
-from blueapi.core import BlueskyContext, MsgGenerator
+from blueapi.core import BlueskyContext
 from bluesky.callbacks.zmq import Publisher
 from bluesky.run_engine import RunEngine
+from bluesky.utils import MsgGenerator
 from flask import Flask, request
 from flask_restful import Api, Resource
 from pydantic.dataclasses import dataclass

mx_bluesky/hyperion/device_setup_plans/dcm_pitch_roll_mirror_adjuster.py

@@ -19,6 +19,7 @@ from mx_bluesky.hyperion.utils.utils import (
 
 MIRROR_VOLTAGE_GROUP = "MIRROR_VOLTAGE_GROUP"
 DCM_GROUP = "DCM_GROUP"
+YAW_LAT_TIMEOUT_S = 30
 
 
 def _apply_and_wait_for_voltages_to_settle(
@@ -46,31 +47,42 @@ def _apply_and_wait_for_voltages_to_settle(
         for voltage_channel, required_voltage in zip(
             channels.values(), required_voltages, strict=True
         ):
-            LOGGER.debug(
+            LOGGER.info(
                 f"Applying and waiting for voltage {voltage_channel.name} = {required_voltage}"
             )
             yield from bps.abs_set(
-                voltage_channel, required_voltage, group=MIRROR_VOLTAGE_GROUP
+                voltage_channel, required_voltage, group=MIRROR_VOLTAGE_GROUP, wait=True
             )
 
-    yield from bps.wait(group=MIRROR_VOLTAGE_GROUP)
-
 
 def adjust_mirror_stripe(
     energy_kev, mirror: FocusingMirrorWithStripes, mirror_voltages: MirrorVoltages
 ):
     """Feedback should be OFF prior to entry, in order to prevent
     feedback from making unnecessary corrections while beam is being adjusted."""
-    stripe = mirror.energy_to_stripe(energy_kev)
+    mirror_config = mirror.energy_to_stripe(energy_kev)
 
     LOGGER.info(
-        f"Adjusting mirror stripe for {energy_kev}keV selecting {stripe} stripe"
+        f"Adjusting mirror stripe for {energy_kev}keV selecting {mirror_config['stripe']} stripe"
     )
-    yield from bps.abs_set(mirror.stripe, stripe, wait=True)
+    yield from bps.abs_set(mirror.stripe, mirror_config["stripe"], wait=True)
     yield from bps.trigger(mirror.apply_stripe)
 
+    # yaw, lat cannot be done simultaneously
+    LOGGER.info(f"Adjusting {mirror.name} lat to {mirror_config['lat_mm']}")
+    yield from bps.abs_set(
+        mirror.x_mm, mirror_config["lat_mm"], wait=True, timeout=YAW_LAT_TIMEOUT_S
+    )
+
+    LOGGER.info(f"Adjusting {mirror.name} yaw to {mirror_config['yaw_mrad']}")
+    yield from bps.abs_set(
+        mirror.yaw_mrad, mirror_config["yaw_mrad"], wait=True, timeout=YAW_LAT_TIMEOUT_S
+    )
+
     LOGGER.info("Adjusting mirror voltages...")
-    yield from _apply_and_wait_for_voltages_to_settle(stripe, mirror_voltages)
+    yield from _apply_and_wait_for_voltages_to_settle(
+        mirror_config["stripe"], mirror_voltages
+    )
 
 
 def adjust_dcm_pitch_roll_vfm_from_lut(
@@ -109,31 +121,9 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
     yield from dcm_roll_adjuster(DCM_GROUP)
     LOGGER.info("Waiting for DCM roll adjust to complete...")
 
-    # DCM Perp pitch
-    offset_mm = undulator_dcm.dcm_fixed_offset_mm
-    LOGGER.info(f"Adjusting DCM offset to {offset_mm} mm")
-    yield from bps.abs_set(dcm.offset_in_mm, offset_mm, group=DCM_GROUP)
-
     #
-    # Adjust mirrors
+    # Adjust vfm mirror stripe and mirror voltages
     #
 
-    # No need to change HFM
-
-    # Assumption is focus mode is already set to "sample"
-    # not sure how we check this
-
     # VFM Stripe selection
     yield from adjust_mirror_stripe(energy_kev, vfm, mirror_voltages)
-    yield from bps.wait(DCM_GROUP)
-
-    # VFM Adjust - for I03 this table always returns the same value
-    vfm_lut = vfm.bragg_to_lat_lookup_table_path
-    assert vfm_lut is not None
-    vfm_x_adjuster = lookup_table_adjuster(
-        linear_interpolation_lut(vfm_lut),
-        vfm.x_mm,
-        bragg_deg,
-    )
-    LOGGER.info("Waiting for VFM Lat (Horizontal Translation) to complete...")
-    yield from vfm_x_adjuster()

mx_bluesky/hyperion/device_setup_plans/setup_panda.py

@@ -4,7 +4,7 @@ from importlib import resources
 from pathlib import Path
 
 import bluesky.plan_stubs as bps
-from blueapi.core import MsgGenerator
+from bluesky.utils import MsgGenerator
 from dodal.common.beamlines.beamline_utils import get_path_provider
 from dodal.devices.fast_grid_scan import PandAGridScanParams
 from ophyd_async.core import load_device
@@ -63,12 +63,12 @@ def _get_seq_table(
         An instance of SeqTable describing the panda sequencer table
     """
 
-    start_of_grid_x_counts = int(parameters.x_start * MM_TO_ENCODER_COUNTS)
+    start_of_grid_x_counts = int(parameters.x_start_mm * MM_TO_ENCODER_COUNTS)
 
     # x_start is the first trigger point, so we need to travel to x_steps-1 for the final trigger point
     end_of_grid_x_counts = int(
         start_of_grid_x_counts
-        + (parameters.x_step_size * (parameters.x_steps - 1) * MM_TO_ENCODER_COUNTS)
+        + (parameters.x_step_size_mm * (parameters.x_steps - 1) * MM_TO_ENCODER_COUNTS)
     )
 
     exposure_distance_x_counts = int(exposure_distance_mm * MM_TO_ENCODER_COUNTS)
@@ -140,7 +140,7 @@ def setup_panda_for_flyscan(
     """
     assert parameters.x_steps > 0
     assert time_between_x_steps_ms * 1000 >= exposure_time_s
-    assert sample_velocity_mm_per_s * exposure_time_s < parameters.x_step_size
+    assert sample_velocity_mm_per_s * exposure_time_s < parameters.x_step_size_mm
 
     yield from bps.stage(panda, group="panda-config")