mx-bluesky 0.3.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

mx_bluesky/beamlines/i24/serial/parameters/__init__.py

@@ -0,0 +1,15 @@
+from mx_bluesky.beamlines.i24.serial.parameters.constants import SSXType
+from mx_bluesky.beamlines.i24.serial.parameters.experiment_parameters import (
+    ChipDescription,
+    ExtruderParameters,
+    FixedTargetParameters,
+)
+from mx_bluesky.beamlines.i24.serial.parameters.utils import get_chip_format
+
+__all__ = [
+    "SSXType",
+    "ExtruderParameters",
+    "ChipDescription",
+    "FixedTargetParameters",
+    "get_chip_format",
+]

mx_bluesky/{i24 → beamlines/i24}/serial/parameters/constants.py

@@ -2,7 +2,7 @@ from enum import Enum
 from os import environ
 from pathlib import Path
 
-from mx_bluesky.i24.serial.log import _read_visit_directory_from_file
+from mx_bluesky.beamlines.i24.serial.log import _read_visit_directory_from_file
 
 
 class SSXType(Enum):

mx_bluesky/{i24 → beamlines/i24}/serial/parameters/experiment_parameters.py

@@ -2,9 +2,9 @@ import json
 from pathlib import Path
 from typing import Literal
 
-from pydantic import BaseModel, ConfigDict, validator
+from pydantic import BaseModel, field_validator
 
-from mx_bluesky.i24.serial.fixed_target.ft_utils import (
+from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import (
     ChipType,
     MappingType,
     PumpProbeSetting,
@@ -21,7 +21,8 @@ class SerialExperiment(BaseModel):
     detector_distance_mm: float
     detector_name: Literal["eiger", "pilatus"]
 
-    @validator("visit", pre=True)
+    @field_validator("visit", mode="before")
+    @classmethod
     def _parse_visit(cls, visit: str | Path):
         if isinstance(visit, str):
             return Path(visit)
@@ -56,8 +57,6 @@ class ExtruderParameters(SerialExperiment, LaserExperiment):
 class ChipDescription(BaseModel):
     """Parameters defining the chip in use for FT collection."""
 
-    model_config = ConfigDict(use_enum_values=True)
-
     chip_type: ChipType
     x_num_steps: int
     y_num_steps: int
@@ -68,13 +67,6 @@ class ChipDescription(BaseModel):
     b2b_horz: float
     b2b_vert: float
 
-    @validator("chip_type", pre=True)
-    def _parse_chip(cls, chip_type: str | int):
-        if isinstance(chip_type, str):
-            return ChipType[chip_type]
-        else:
-            return ChipType(chip_type)
-
     @property
     def chip_format(self) -> list[int]:
         return [self.x_blocks, self.y_blocks, self.x_num_steps, self.y_num_steps]
@@ -97,8 +89,6 @@ class ChipDescription(BaseModel):
 class FixedTargetParameters(SerialExperiment, LaserExperiment):
     """Fixed target parameter model."""
 
-    model_config = ConfigDict(use_enum_values=True)
-
     num_exposures: int
     chip: ChipDescription
     map_type: MappingType
@@ -106,17 +96,6 @@ class FixedTargetParameters(SerialExperiment, LaserExperiment):
     checker_pattern: bool = False
     total_num_images: int = 0  # Calculated in the code for now
 
-    @validator("map_type", pre=True)
-    def _parse_map(cls, map_type: str | int):
-        if isinstance(map_type, str):
-            return MappingType[map_type]
-        else:
-            return MappingType(map_type)
-
-    @validator("pump_repeat", pre=True)
-    def _parse_pump(cls, pump_repeat: int):
-        return PumpProbeSetting(pump_repeat)
-
     @classmethod
     def from_file(cls, filename: str | Path):
         with open(filename) as fh:

mx_bluesky/{i24 → beamlines/i24}/serial/parameters/utils.py

@@ -1,8 +1,10 @@
 from typing import Any
 
-from mx_bluesky.i24.serial.fixed_target.ft_utils import ChipType
-from mx_bluesky.i24.serial.parameters.experiment_parameters import ChipDescription
-from mx_bluesky.i24.serial.setup_beamline import caget, pv
+from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import ChipType
+from mx_bluesky.beamlines.i24.serial.parameters.experiment_parameters import (
+    ChipDescription,
+)
+from mx_bluesky.beamlines.i24.serial.setup_beamline import caget, pv
 
 
 def get_chip_format(chip_type: ChipType) -> ChipDescription:

mx_bluesky/{i24 → beamlines/i24}/serial/run_serial.py

@@ -11,7 +11,7 @@ def get_location(default: str = "dev") -> str:
 
 
 def get_edm_path() -> Path:
-    return Path(__file__).parents[4] / "edm_serial"
+    return Path(__file__).parents[5] / "edm_serial"
 
 
 def _get_file_path() -> Path:

mx_bluesky/{i24 → beamlines/i24}/serial/setup_beamline/pv_abstract.py

@@ -5,7 +5,7 @@ Takes the PV tables from I24's setup_beamline and wraps a slightly more
 abstract wrapper around them.
 """
 
-from mx_bluesky.i24.serial.setup_beamline import pv
+from mx_bluesky.beamlines.i24.serial.setup_beamline import pv
 
 
 class Pilatus:

mx_bluesky/{i24 → beamlines/i24}/serial/setup_beamline/setup_beamline.py

@@ -7,8 +7,8 @@ from dodal.devices.i24.beamstop import Beamstop, BeamstopPositions
 from dodal.devices.i24.dual_backlight import BacklightPositions, DualBacklight
 from dodal.devices.i24.i24_detector_motion import DetectorMotion
 
-from mx_bluesky.i24.serial.setup_beamline import pv
-from mx_bluesky.i24.serial.setup_beamline.ca import caget, caput
+from mx_bluesky.beamlines.i24.serial.setup_beamline import pv
+from mx_bluesky.beamlines.i24.serial.setup_beamline.ca import caget, caput
 
 logger = logging.getLogger("I24ssx.sup")
 

mx_bluesky/{i24 → beamlines/i24}/serial/setup_beamline/setup_detector.py

@@ -13,11 +13,11 @@ from bluesky.utils import Msg
 from dodal.common import inject
 from dodal.devices.i24.i24_detector_motion import DetectorMotion
 
-from mx_bluesky.i24.serial import log
-from mx_bluesky.i24.serial.parameters import SSXType
-from mx_bluesky.i24.serial.setup_beamline import pv
-from mx_bluesky.i24.serial.setup_beamline.ca import caget
-from mx_bluesky.i24.serial.setup_beamline.pv_abstract import (
+from mx_bluesky.beamlines.i24.serial import log
+from mx_bluesky.beamlines.i24.serial.parameters import SSXType
+from mx_bluesky.beamlines.i24.serial.setup_beamline import pv
+from mx_bluesky.beamlines.i24.serial.setup_beamline.ca import caget
+from mx_bluesky.beamlines.i24.serial.setup_beamline.pv_abstract import (
     Detector,
     Eiger,
     Pilatus,

mx_bluesky/{i24 → beamlines/i24}/serial/write_nexus.py

@@ -8,9 +8,12 @@ from typing import Literal
 
 import requests
 
-from mx_bluesky.i24.serial.fixed_target.ft_utils import ChipType, MappingType
-from mx_bluesky.i24.serial.parameters import ExtruderParameters, FixedTargetParameters
-from mx_bluesky.i24.serial.setup_beamline import Eiger, caget, cagetstring
+from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import ChipType, MappingType
+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")
 

mx_bluesky/hyperion/__init__.py

@@ -0,0 +1 @@
+# placeholder file to start layout

mx_bluesky/hyperion/__main__.py

@@ -0,0 +1,374 @@
+import atexit
+import json
+import threading
+from collections.abc import Callable
+from dataclasses import asdict
+from queue import Queue
+from traceback import format_exception
+from typing import Any
+
+from blueapi.core import BlueskyContext, MsgGenerator
+from bluesky.callbacks.zmq import Publisher
+from bluesky.run_engine import RunEngine
+from flask import Flask, request
+from flask_restful import Api, Resource
+from pydantic.dataclasses import dataclass
+
+from mx_bluesky.hyperion.exceptions import WarningException
+from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
+    PLAN_REGISTRY,
+    PlanNotFound,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.__main__ import (
+    setup_logging as setup_callback_logging,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.aperture_change_callback import (
+    ApertureChangeCallback,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.common.callback_util import (
+    CallbacksFactory,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.log_uid_tag_callback import (
+    LogUidTaggingCallback,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.logging_callback import (
+    VerbosePlanExecutionLoggingCallback,
+)
+from mx_bluesky.hyperion.log import (
+    LOGGER,
+    do_default_logging_setup,
+    flush_debug_handler,
+)
+from mx_bluesky.hyperion.parameters.cli import parse_cli_args
+from mx_bluesky.hyperion.parameters.components import HyperionParameters
+from mx_bluesky.hyperion.parameters.constants import CONST, Actions, Status
+from mx_bluesky.hyperion.tracing import TRACER
+from mx_bluesky.hyperion.utils.context import setup_context
+
+VERBOSE_EVENT_LOGGING: bool | None = None
+
+
+@dataclass
+class Command:
+    action: Actions
+    devices: Any | None = None
+    experiment: Callable[[Any, Any], MsgGenerator] | None = None
+    parameters: HyperionParameters | None = None
+    callbacks: CallbacksFactory | None = None
+
+
+@dataclass
+class StatusAndMessage:
+    status: str
+    message: str = ""
+
+    def __init__(self, status: Status, message: str = "") -> None:
+        self.status = status.value
+        self.message = message
+
+
+@dataclass
+class ErrorStatusAndMessage(StatusAndMessage):
+    exception_type: str = ""
+
+
+def make_error_status_and_message(exception: Exception):
+    return ErrorStatusAndMessage(
+        status=Status.FAILED.value,
+        message=repr(exception),
+        exception_type=type(exception).__name__,
+    )
+
+
+class BlueskyRunner:
+    def __init__(
+        self,
+        RE: RunEngine,
+        context: BlueskyContext,
+        skip_startup_connection=False,
+        use_external_callbacks: bool = False,
+    ) -> None:
+        self.command_queue: Queue[Command] = Queue()
+        self.current_status: StatusAndMessage = StatusAndMessage(Status.IDLE)
+        self.last_run_aborted: bool = False
+        self.aperture_change_callback = ApertureChangeCallback()
+        self.logging_uid_tag_callback = LogUidTaggingCallback()
+        self.context: BlueskyContext
+
+        self.RE = RE
+        self.context = context
+        self.subscribed_per_plan_callbacks: list[int] = []
+        RE.subscribe(self.aperture_change_callback)
+        RE.subscribe(self.logging_uid_tag_callback)
+
+        self.use_external_callbacks = use_external_callbacks
+        if self.use_external_callbacks:
+            LOGGER.info("Connecting to external callback ZMQ proxy...")
+            self.publisher = Publisher(f"localhost:{CONST.CALLBACK_0MQ_PROXY_PORTS[0]}")
+            RE.subscribe(self.publisher)
+
+        if VERBOSE_EVENT_LOGGING:
+            RE.subscribe(VerbosePlanExecutionLoggingCallback())
+
+        self.skip_startup_connection = skip_startup_connection
+        if not self.skip_startup_connection:
+            LOGGER.info("Initialising dodal devices...")
+            for plan_name in PLAN_REGISTRY:
+                PLAN_REGISTRY[plan_name]["setup"](context)
+
+    def start(
+        self,
+        experiment: Callable,
+        parameters: HyperionParameters,
+        plan_name: str,
+        callbacks: CallbacksFactory | None,
+    ) -> StatusAndMessage:
+        LOGGER.info(f"Started with parameters: {parameters.model_dump_json(indent=2)}")
+
+        devices: Any = PLAN_REGISTRY[plan_name]["setup"](self.context)
+
+        if (
+            self.current_status.status == Status.BUSY.value
+            or self.current_status.status == Status.ABORTING.value
+        ):
+            return StatusAndMessage(Status.FAILED, "Bluesky already running")
+        else:
+            self.current_status = StatusAndMessage(Status.BUSY)
+            self.command_queue.put(
+                Command(
+                    action=Actions.START,
+                    devices=devices,
+                    experiment=experiment,
+                    parameters=parameters,
+                    callbacks=callbacks,
+                )
+            )
+            return StatusAndMessage(Status.SUCCESS)
+
+    def stopping_thread(self):
+        try:
+            self.RE.abort()
+            self.current_status = StatusAndMessage(Status.IDLE)
+        except Exception as e:
+            self.current_status = make_error_status_and_message(e)
+
+    def stop(self) -> StatusAndMessage:
+        if self.current_status.status == Status.IDLE.value:
+            return StatusAndMessage(Status.FAILED, "Bluesky not running")
+        elif self.current_status.status == Status.ABORTING.value:
+            return StatusAndMessage(Status.FAILED, "Bluesky already stopping")
+        else:
+            self.current_status = StatusAndMessage(Status.ABORTING)
+            stopping_thread = threading.Thread(target=self.stopping_thread)
+            stopping_thread.start()
+            self.last_run_aborted = True
+            return StatusAndMessage(Status.ABORTING)
+
+    def shutdown(self):
+        """Stops the run engine and the loop waiting for messages."""
+        print("Shutting down: Stopping the run engine gracefully")
+        self.stop()
+        self.command_queue.put(Command(action=Actions.SHUTDOWN))
+
+    def wait_on_queue(self):
+        while True:
+            command = self.command_queue.get()
+            if command.action == Actions.SHUTDOWN:
+                return
+            elif command.action == Actions.START:
+                if command.experiment is None:
+                    raise ValueError("No experiment provided for START")
+                try:
+                    if (
+                        not self.use_external_callbacks
+                        and command.callbacks
+                        and (cbs := command.callbacks())
+                    ):
+                        LOGGER.info(
+                            f"Using callbacks for this plan: {not self.use_external_callbacks} - {cbs}"
+                        )
+                        self.subscribed_per_plan_callbacks += [
+                            self.RE.subscribe(cb) for cb in cbs
+                        ]
+                    with TRACER.start_span("do_run"):
+                        self.RE(command.experiment(command.devices, command.parameters))
+
+                    self.current_status = StatusAndMessage(
+                        Status.IDLE,
+                        self.aperture_change_callback.last_selected_aperture,
+                    )
+
+                    self.last_run_aborted = False
+                except WarningException as exception:
+                    LOGGER.warning("Warning Exception", exc_info=True)
+                    self.current_status = make_error_status_and_message(exception)
+                except Exception as exception:
+                    LOGGER.error("Exception on running plan", exc_info=True)
+
+                    if self.last_run_aborted:
+                        # Aborting will cause an exception here that we want to swallow
+                        self.last_run_aborted = False
+                    else:
+                        self.current_status = make_error_status_and_message(exception)
+                finally:
+                    [
+                        self.RE.unsubscribe(cb)
+                        for cb in self.subscribed_per_plan_callbacks
+                    ]
+
+
+def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions):
+    experiment_registry_entry = PLAN_REGISTRY.get(plan_name)
+    if experiment_registry_entry is None:
+        raise PlanNotFound(f"Experiment plan '{plan_name}' not found in registry.")
+
+    experiment_internal_param_type = experiment_registry_entry.get("param_type")
+    callback_type = experiment_registry_entry.get("callback_collection_type")
+    plan = context.plan_functions.get(plan_name)
+    if experiment_internal_param_type is None:
+        raise PlanNotFound(
+            f"Corresponding internal param type for '{plan_name}' not found in registry."
+        )
+    if plan is None:
+        raise PlanNotFound(
+            f"Experiment plan '{plan_name}' not found in context. Context has {context.plan_functions.keys()}"
+        )
+    try:
+        parameters = experiment_internal_param_type(**json.loads(request.data))
+        if parameters.model_extra:
+            raise ValueError(f"Extra fields not allowed {parameters.model_extra}")
+    except Exception as e:
+        raise ValueError(
+            f"Supplied parameters don't match the plan for this endpoint {request.data}"
+        ) from e
+    return plan, parameters, plan_name, callback_type
+
+
+class RunExperiment(Resource):
+    def __init__(self, runner: BlueskyRunner, context: BlueskyContext) -> None:
+        super().__init__()
+        self.runner = runner
+        self.context = context
+
+    def put(self, plan_name: str, action: Actions):
+        status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
+        if action == Actions.START.value:
+            try:
+                plan, params, plan_name, callback_type = compose_start_args(
+                    self.context, plan_name, action
+                )
+                status_and_message = self.runner.start(
+                    plan, params, plan_name, callback_type
+                )
+            except Exception as e:
+                status_and_message = make_error_status_and_message(e)
+                LOGGER.error(format_exception(e))
+
+        elif action == Actions.STOP.value:
+            status_and_message = self.runner.stop()
+        # no idea why mypy gives an attribute error here but nowhere else for this
+        # exact same situation...
+        return asdict(status_and_message)  # type: ignore
+
+
+class StopOrStatus(Resource):
+    def __init__(self, runner: BlueskyRunner) -> None:
+        super().__init__()
+        self.runner: BlueskyRunner = runner
+
+    def put(self, action):
+        status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
+        if action == Actions.STOP.value:
+            status_and_message = self.runner.stop()
+        return asdict(status_and_message)
+
+    def get(self, **kwargs):
+        action = kwargs.get("action")
+        status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
+        if action == Actions.STATUS.value:
+            LOGGER.debug(
+                f"Runner received status request - state of the runner object is: {self.runner.__dict__} - state of the RE is: {self.runner.RE.__dict__}"
+            )
+            status_and_message = self.runner.current_status
+        return asdict(status_and_message)
+
+
+class FlushLogs(Resource):
+    def put(self, **kwargs):
+        try:
+            status_and_message = StatusAndMessage(
+                Status.SUCCESS, f"Flushed debug log to {flush_debug_handler()}"
+            )
+        except Exception as e:
+            status_and_message = StatusAndMessage(
+                Status.FAILED, f"Failed to flush debug log: {e}"
+            )
+        return asdict(status_and_message)
+
+
+def create_app(
+    test_config=None,
+    RE: RunEngine = RunEngine({}),
+    skip_startup_connection: bool = False,
+    use_external_callbacks: bool = False,
+) -> tuple[Flask, BlueskyRunner]:
+    context = setup_context(
+        wait_for_connection=not skip_startup_connection,
+    )
+    runner = BlueskyRunner(
+        RE,
+        context=context,
+        use_external_callbacks=use_external_callbacks,
+        skip_startup_connection=skip_startup_connection,
+    )
+    app = Flask(__name__)
+    if test_config:
+        app.config.update(test_config)
+    api = Api(app)
+    api.add_resource(
+        RunExperiment,
+        "/<string:plan_name>/<string:action>",
+        resource_class_args=[runner, context],
+    )
+    api.add_resource(
+        FlushLogs,
+        "/flush_debug_log",
+    )
+    api.add_resource(
+        StopOrStatus,
+        "/<string:action>",
+        resource_class_args=[runner],
+    )
+    return app, runner
+
+
+def create_targets():
+    hyperion_port = 5005
+    args = parse_cli_args()
+    do_default_logging_setup(dev_mode=args.dev_mode)
+    if not args.use_external_callbacks:
+        setup_callback_logging(args.dev_mode)
+    app, runner = create_app(
+        skip_startup_connection=args.skip_startup_connection,
+        use_external_callbacks=args.use_external_callbacks,
+    )
+    return app, runner, hyperion_port, args.dev_mode
+
+
+def main():
+    app, runner, port, dev_mode = create_targets()
+    atexit.register(runner.shutdown)
+    flask_thread = threading.Thread(
+        target=lambda: app.run(
+            host="0.0.0.0", port=port, debug=True, use_reloader=False
+        ),
+        daemon=True,
+    )
+    flask_thread.start()
+    LOGGER.info(f"Hyperion now listening on {port} ({'IN DEV' if dev_mode else ''})")
+    runner.wait_on_queue()
+    flask_thread.join()
+
+
+if __name__ == "__main__":
+    main()

mx_bluesky/hyperion/device_setup_plans/dcm_pitch_roll_mirror_adjuster.py

@@ -0,0 +1,134 @@
+import json
+
+import bluesky.plan_stubs as bps
+from dodal.devices.focusing_mirror import (
+    FocusingMirrorWithStripes,
+    MirrorStripe,
+    VFMMirrorVoltages,
+)
+from dodal.devices.undulator_dcm import UndulatorDCM
+from dodal.devices.util.adjuster_plans import lookup_table_adjuster
+from dodal.devices.util.lookup_tables import (
+    linear_interpolation_lut,
+)
+
+from mx_bluesky.hyperion.log import LOGGER
+
+MIRROR_VOLTAGE_GROUP = "MIRROR_VOLTAGE_GROUP"
+DCM_GROUP = "DCM_GROUP"
+
+
+def _apply_and_wait_for_voltages_to_settle(
+    stripe: MirrorStripe,
+    mirror: FocusingMirrorWithStripes,
+    mirror_voltages: VFMMirrorVoltages,
+):
+    with open(mirror_voltages.voltage_lookup_table_path) as lut_file:
+        json_obj = json.load(lut_file)
+
+    # sample mode is the only mode supported
+    sample_data = json_obj["sample"]
+    mirror_key = mirror.name.lower()
+    if stripe == MirrorStripe.BARE:
+        stripe_key = "bare"
+    elif stripe == MirrorStripe.RHODIUM:
+        stripe_key = "rh"
+    elif stripe == MirrorStripe.PLATINUM:
+        stripe_key = "pt"
+    else:
+        raise ValueError(f"Unsupported stripe '{stripe}'")
+
+    required_voltages = sample_data[stripe_key][mirror_key]
+    for voltage_channel, required_voltage in zip(
+        mirror_voltages.voltage_channels.values(), required_voltages, strict=False
+    ):
+        LOGGER.debug(
+            f"Applying and waiting for voltage {voltage_channel.name} = {required_voltage}"
+        )
+        yield from bps.abs_set(
+            voltage_channel, required_voltage, group=MIRROR_VOLTAGE_GROUP
+        )
+
+    yield from bps.wait(group=MIRROR_VOLTAGE_GROUP)
+
+
+def adjust_mirror_stripe(
+    energy_kev, mirror: FocusingMirrorWithStripes, mirror_voltages: VFMMirrorVoltages
+):
+    """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)
+
+    LOGGER.info(
+        f"Adjusting mirror stripe for {energy_kev}keV selecting {stripe} stripe"
+    )
+    yield from bps.abs_set(mirror.stripe, stripe, wait=True)
+    yield from bps.trigger(mirror.apply_stripe)
+
+    LOGGER.info("Adjusting mirror voltages...")
+    yield from _apply_and_wait_for_voltages_to_settle(stripe, mirror, mirror_voltages)
+
+
+def adjust_dcm_pitch_roll_vfm_from_lut(
+    undulator_dcm: UndulatorDCM,
+    vfm: FocusingMirrorWithStripes,
+    vfm_mirror_voltages: VFMMirrorVoltages,
+    energy_kev,
+):
+    """Beamline energy-change post-adjustments : Adjust DCM and VFM directly from lookup tables.
+    Lookups are performed against the Bragg angle which will have been automatically set by EPICS as a side-effect of the
+    energy change prior to calling this function.
+    Feedback should be OFF prior to entry, in order to prevent
+    feedback from making unnecessary corrections while beam is being adjusted."""
+
+    # DCM Pitch
+    dcm = undulator_dcm.dcm
+    LOGGER.info(f"Adjusting DCM and VFM for {energy_kev} keV")
+    bragg_deg = yield from bps.rd(dcm.bragg_in_degrees.user_readback)
+    LOGGER.info(f"Read Bragg angle = {bragg_deg} degrees")
+    dcm_pitch_adjuster = lookup_table_adjuster(
+        linear_interpolation_lut(undulator_dcm.pitch_energy_table_path),
+        dcm.pitch_in_mrad,
+        bragg_deg,
+    )
+    yield from dcm_pitch_adjuster(DCM_GROUP)
+    # It's possible we can remove these waits but we need to check
+    LOGGER.info("Waiting for DCM pitch adjust to complete...")
+
+    # DCM Roll
+    dcm_roll_adjuster = lookup_table_adjuster(
+        linear_interpolation_lut(undulator_dcm.roll_energy_table_path),
+        dcm.roll_in_mrad,
+        bragg_deg,
+    )
+    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
+    #
+
+    # 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, 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()