mx-bluesky 1.5.11__py3-none-any.whl → 1.5.12__py3-none-any.whl

mx_bluesky/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.5.11'
-__version_tuple__ = version_tuple = (1, 5, 11)
+__version__ = version = '1.5.12'
+__version_tuple__ = version_tuple = (1, 5, 12)
 
 __commit_id__ = commit_id = None

mx_bluesky/beamlines/aithre_lasershaping/experiment_plans/robot_load_plan.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import bluesky.plan_stubs as bps
+import bluesky.preprocessors as bpp
+import pydantic
+from dodal.devices.motors import XYZOmegaStage, XYZStage
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.pin_image_recognition import PinTipDetection
+from dodal.devices.robot import BartRobot, SampleLocation
+
+from mx_bluesky.beamlines.aithre_lasershaping.parameters.constants import CONST
+from mx_bluesky.beamlines.aithre_lasershaping.parameters.robot_load_parameters import (
+    AithreRobotLoad,
+)
+from mx_bluesky.common.device_setup_plans.robot_load_unload import (
+    do_plan_while_lower_gonio_at_home,
+)
+from mx_bluesky.common.experiment_plans.pin_tip_centring_plan import (
+    PinTipCentringComposite,
+    pin_tip_centre_plan,
+)
+from mx_bluesky.common.parameters.constants import (
+    DocDescriptorNames,
+    PlanNameConstants,
+)
+
+
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
+class RobotLoadComposite:
+    # RobotLoad fields
+    robot: BartRobot
+    lower_gonio: XYZStage
+    oav: OAV
+    gonio: XYZOmegaStage
+
+
+def _move_gonio_to_home_position(
+    composite: RobotLoadComposite,
+    x_home: float = 0.0,
+    y_home: float = 0.0,
+    z_home: float = 0.0,
+    omega_home: float = 0.0,
+    group: str = "group",
+):
+    """
+    Move Gonio to home position, default is zero
+    """
+    yield from bps.abs_set(composite.gonio.omega, omega_home, group=group)
+    yield from bps.abs_set(composite.gonio.x, x_home, group=group)
+    yield from bps.abs_set(composite.gonio.y, y_home, group=group)
+    yield from bps.abs_set(composite.gonio.z, z_home, group=group)
+
+    yield from bps.wait(group=group)
+
+
+def _take_robot_snapshots(oav: OAV, directory: Path):
+    time_now = datetime.now()
+    snapshot_format = f"{time_now.strftime('%H%M%S')}_{{device}}_after_load"
+    for device in [oav.snapshot]:
+        yield from bps.abs_set(
+            device.filename, snapshot_format.format(device=device.name)
+        )
+        yield from bps.abs_set(device.directory, str(directory))
+        # Note: should be able to use `wait=True` after https://github.com/bluesky/bluesky/issues/1795
+        yield from bps.trigger(device, group="snapshots")
+        yield from bps.wait("snapshots")
+
+
+def _do_robot_load_and_centre(
+    composite: RobotLoadComposite,
+    sample_location: SampleLocation,
+    sample_id: int,
+    pin_tip_detection: PinTipDetection,
+    tip_offset_microns: float = 0,
+    oav_config_file: str = CONST.OAV_CENTRING_FILE,
+):
+    yield from bps.abs_set(composite.robot.next_sample_id, sample_id, wait=True)
+    yield from bps.abs_set(
+        composite.robot,
+        sample_location,
+        group="robot_load",
+    )
+
+    yield from _move_gonio_to_home_position(composite=composite, group="robot_load")
+
+    yield from bps.wait(group="robot_load")
+
+    pin_tip_centring_composite = PinTipCentringComposite(
+        composite.oav, composite.gonio, pin_tip_detection
+    )
+    yield from pin_tip_centre_plan(
+        pin_tip_centring_composite, tip_offset_microns, oav_config_file
+    )
+
+
+def _robot_load_and_snapshots(
+    composite: RobotLoadComposite,
+    location: SampleLocation,
+    snapshot_directory: Path,
+    sample_id: int,
+    pin_tip_detection: PinTipDetection,
+    tip_offset_microns: float = 0,
+    oav_config_file: str = CONST.OAV_CENTRING_FILE,
+):
+    yield from bps.create(name=DocDescriptorNames.ROBOT_PRE_LOAD)
+    yield from bps.read(composite.robot)
+    yield from bps.save()
+
+    robot_load_plan = _do_robot_load_and_centre(
+        composite,
+        location,
+        sample_id,
+        pin_tip_detection,
+        tip_offset_microns,
+        oav_config_file,
+    )
+
+    gonio_finished = yield from do_plan_while_lower_gonio_at_home(
+        robot_load_plan, composite.lower_gonio
+    )
+    yield from bps.wait(group="snapshot")
+
+    yield from _take_robot_snapshots(composite.oav, snapshot_directory)
+
+    yield from bps.create(name=DocDescriptorNames.ROBOT_UPDATE)
+    yield from bps.read(composite.robot)
+    yield from bps.read(composite.oav.snapshot)
+    yield from bps.save()
+
+    yield from bps.wait(gonio_finished)
+
+
+def robot_load_and_snapshots_plan(
+    composite: RobotLoadComposite,
+    params: AithreRobotLoad,
+    ptd: PinTipDetection,
+    tip_offset_microns: float = 0,
+    oav_config_file: str = CONST.OAV_CENTRING_FILE,
+):
+    assert params.sample_puck is not None
+    assert params.sample_pin is not None
+
+    sample_location = SampleLocation(params.sample_puck, params.sample_pin)
+
+    yield from _move_gonio_to_home_position(composite)
+
+    yield from bpp.set_run_key_wrapper(
+        bpp.run_wrapper(
+            _robot_load_and_snapshots(
+                composite,
+                sample_location,
+                params.snapshot_directory,
+                params.sample_id,
+                ptd,
+                tip_offset_microns,
+                oav_config_file,
+            ),
+            md={
+                "subplan_name": PlanNameConstants.ROBOT_LOAD,
+                "metadata": {"visit": params.visit, "sample_id": params.sample_id},
+                "activate_callbacks": [
+                    "RobotLoadISPyBCallback",
+                ],
+            },
+        ),
+        PlanNameConstants.ROBOT_LOAD_AND_SNAPSHOTS,
+    )
+
+
+def robot_unload_plan(
+    composite: RobotLoadComposite,
+    params: AithreRobotLoad,
+):
+    @bpp.run_decorator(
+        md={
+            "subplan_name": PlanNameConstants.ROBOT_UNLOAD,
+            "metadata": {"visit": params.visit, "sample_id": params.sample_id},
+            "activate_callbacks": [
+                "RobotLoadISPyBCallback",
+            ],
+        },
+    )
+    def do_robot_unload_and_send_to_ispyb():
+        yield from _take_robot_snapshots(composite.oav, params.snapshot_directory)
+        yield from bps.wait(group="snapshot")
+        yield from _move_gonio_to_home_position(composite)
+
+        yield from bps.abs_set(composite.robot, None, wait=True)
+
+        yield from bps.create(name=DocDescriptorNames.ROBOT_UPDATE)
+        yield from bps.read(composite.robot)
+        yield from bps.read(composite.oav.snapshot)
+        yield from bps.save()
+
+    yield from do_robot_unload_and_send_to_ispyb()

mx_bluesky/beamlines/aithre_lasershaping/parameters/constants.py

@@ -0,0 +1,17 @@
+import os
+
+from pydantic.dataclasses import dataclass
+
+TEST_MODE = os.environ.get("AITHRE_TEST_MODE")
+
+
+@dataclass(frozen=True)
+class AithreConstants:
+    BEAMLINE = "aithre"
+    OAV_CENTRING_FILE = (
+        "/dls/science/groups/i23/aithre/daq_configuration/json/OAVCentring_aithre.json"
+    )
+    LOG_FILE_NAME = "aithre.log"
+
+
+CONST = AithreConstants()

mx_bluesky/beamlines/aithre_lasershaping/parameters/robot_load_parameters.py

@@ -0,0 +1,13 @@
+from mx_bluesky.common.parameters.components import (
+    WithSample,
+    WithSnapshot,
+    WithVisit,
+)
+
+
+class AithreRobotLoad(
+    WithSample,
+    WithSnapshot,
+    WithVisit,
+):
+    pass

mx_bluesky/beamlines/aithre_lasershaping/pin_tip_centring.py

@@ -0,0 +1,31 @@
+from bluesky.utils import MsgGenerator
+from dodal.common import inject
+from dodal.devices.aithre_lasershaping.goniometer import Goniometer
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.pin_image_recognition import PinTipDetection
+
+from mx_bluesky.beamlines.aithre_lasershaping.parameters.constants import CONST
+from mx_bluesky.common.experiment_plans.pin_tip_centring_plan import (
+    PinTipCentringComposite,
+    pin_tip_centre_plan,
+)
+
+
+def aithre_pin_tip_centre(
+    oav: OAV = inject("OAV"),
+    gonio: Goniometer = inject("gonio"),
+    pin_tip_detection: PinTipDetection = inject("pin_tip_detection"),
+    tip_offset_microns: float = 0,
+    oav_config_file: str = CONST.OAV_CENTRING_FILE,
+) -> MsgGenerator:
+    """
+    A plan that use pin_tip_centre_plan from common for aithre
+    """
+
+    composite = PinTipCentringComposite(oav, gonio, pin_tip_detection)
+
+    yield from pin_tip_centre_plan(
+        composite=composite,
+        tip_offset_microns=tip_offset_microns,
+        oav_config_file=oav_config_file,
+    )

mx_bluesky/beamlines/aithre_lasershaping/robot_load.py

@@ -0,0 +1,80 @@
+import datetime
+
+from bluesky.utils import MsgGenerator
+from dodal.common import inject
+from dodal.devices.motors import XYZOmegaStage
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.pin_image_recognition import PinTipDetection
+from dodal.devices.robot import BartRobot
+
+from mx_bluesky.beamlines.aithre_lasershaping.experiment_plans.robot_load_plan import (
+    RobotLoadComposite,
+    robot_load_and_snapshots_plan,
+    robot_unload_plan,
+)
+from mx_bluesky.beamlines.aithre_lasershaping.parameters.constants import CONST
+from mx_bluesky.beamlines.aithre_lasershaping.parameters.robot_load_parameters import (
+    AithreRobotLoad,
+)
+
+
+def robot_load_and_snapshot(
+    robot: BartRobot = inject("robot"),
+    gonio: XYZOmegaStage = inject("gonio"),
+    oav: OAV = inject("oav"),
+    ptd: PinTipDetection = inject("ptd"),
+    tip_offset_microns: float = 0,
+    oav_config_file: str = CONST.OAV_CENTRING_FILE,
+    sample_puck: int = 0,
+    sample_pin: int = 0,
+    sample_id: int = 0,
+    visit: str = "cm40645-5",
+    categories: str = "",
+) -> MsgGenerator:
+    """
+    categories: type of the sample, e.g. Germ, ProteinaseK, Screening
+    """
+    time_now = datetime.datetime.now()
+    year_now = str(time_now.year)
+    snapshot_directory = f"/dls/i23/data/{year_now}/{visit}/{categories}"
+    composite = RobotLoadComposite(robot, gonio, oav, gonio)
+    params = AithreRobotLoad(
+        sample_id=sample_id,
+        sample_puck=sample_puck,
+        sample_pin=sample_pin,
+        snapshot_directory=snapshot_directory,
+        visit=visit,
+        beamline="BL23I",
+    )
+
+    yield from robot_load_and_snapshots_plan(
+        composite, params, ptd, tip_offset_microns, oav_config_file
+    )
+
+
+def robot_unload(
+    robot: BartRobot = inject("robot"),
+    gonio: XYZOmegaStage = inject("gonio"),
+    oav: OAV = inject("oav"),
+    sample_puck: int = 0,
+    sample_pin: int = 0,
+    sample_id: int = 0,
+    visit: str = "cm40645-5",
+    categories: str = "",
+) -> MsgGenerator:
+    """
+    categories: type of the sample, e.g. Germ, ProteinaseK, Screening
+    """
+    time_now = datetime.datetime.now()
+    year_now = str(time_now.year)
+    snapshot_directory = f"/dls/i23/data/{year_now}/{visit}/{categories}"
+    composite = RobotLoadComposite(robot, gonio, oav, gonio)
+    params = AithreRobotLoad(
+        sample_id=sample_id,
+        sample_puck=sample_puck,
+        sample_pin=sample_pin,
+        snapshot_directory=snapshot_directory,
+        visit=visit,
+        beamline="BL23I",
+    )
+    yield from robot_unload_plan(composite, params)

mx_bluesky/beamlines/i04/__init__.py

@@ -1,5 +1,8 @@
 from mx_bluesky.beamlines.i04.experiment_plans.i04_grid_detect_then_xray_centre_plan import (
-    i04_grid_detect_then_xray_centre,
+    i04_default_grid_detect_and_xray_centre,
+)
+from mx_bluesky.beamlines.i04.oav_centering_plans.oav_imaging import (
+    take_oav_image_with_scintillator_in,
 )
 from mx_bluesky.beamlines.i04.thawing_plan import (
     thaw,
@@ -10,6 +13,7 @@ from mx_bluesky.beamlines.i04.thawing_plan import (
 __all__ = [
     "thaw",
     "thaw_and_stream_to_redis",
-    "i04_grid_detect_then_xray_centre",
+    "i04_default_grid_detect_and_xray_centre",
     "thaw_and_murko_centre",
+    "take_oav_image_with_scintillator_in",
 ]

mx_bluesky/beamlines/i04/callbacks/murko_callback.py

@@ -8,6 +8,8 @@ from dodal.log import LOGGER
 from event_model.documents import Event, RunStart, RunStop
 from redis import StrictRedis
 
+FORWARDING_COMPLETE_MESSAGE = "image_forwarding_complete"
+
 
 class OmegaReading(TypedDict):
     value: float
@@ -56,22 +58,28 @@ class MurkoCallback(CallbackBase):
         self.previous_omegas: list[OmegaReading] = []
 
     def start(self, doc: RunStart) -> RunStart | None:
-        self.sample_id = doc.get("sample_id")
-        self.murko_metadata = {
-            "zoom_percentage": doc.get("zoom_percentage"),
-            "microns_per_x_pixel": doc.get("microns_per_x_pixel"),
-            "microns_per_y_pixel": doc.get("microns_per_y_pixel"),
-            "beam_centre_i": doc.get("beam_centre_i"),
-            "beam_centre_j": doc.get("beam_centre_j"),
-            "sample_id": self.sample_id,
-        }
+        self.murko_metadata: dict = {"sample_id": doc.get("sample_id")}
         self.last_uuid = None
         self.previous_omegas = []
-        LOGGER.info(f"Starting to stream metadata to murko under {self.sample_id}")
+        LOGGER.info(
+            f"Starting to stream metadata to murko under {self.murko_metadata['sample_id']}"
+        )
         return doc
 
     def event(self, doc: Event) -> Event:
-        if latest_omega := doc["data"].get("smargon-omega"):
+        data = doc["data"]
+        for prefix in ("oav", "oav_full_screen"):
+            if f"{prefix}-beam_centre_j" in data:
+                self.murko_metadata.update(
+                    {
+                        "microns_per_x_pixel": data[f"{prefix}-microns_per_pixel_x"],
+                        "microns_per_y_pixel": data[f"{prefix}-microns_per_pixel_y"],
+                        "beam_centre_i": data[f"{prefix}-beam_centre_i"],
+                        "beam_centre_j": data[f"{prefix}-beam_centre_j"],
+                    }
+                )
+
+        if (latest_omega := data.get("smargon-omega")) is not None:
             if len(self.previous_omegas) <= 2 and self.last_uuid:
                 # For the first few images there's not enough data to extrapolate so we
                 # match them one to one
@@ -106,5 +114,12 @@ class MurkoCallback(CallbackBase):
         self.redis_client.publish("murko", json.dumps(metadata))
 
     def stop(self, doc: RunStop) -> RunStop | None:
-        LOGGER.info(f"Finished streaming {self.sample_id} to murko")
+        LOGGER.info(f"Finished streaming {self.murko_metadata['sample_id']} to murko")
+        LOGGER.info(
+            f"Publishing forwarding complete message: {FORWARDING_COMPLETE_MESSAGE}"
+        )
+        self.redis_client.publish(
+            "murko",
+            json.dumps(FORWARDING_COMPLETE_MESSAGE),
+        )
         return doc

mx_bluesky/beamlines/i04/experiment_plans/i04_grid_detect_then_xray_centre_plan.py

@@ -17,6 +17,7 @@ from dodal.devices.fast_grid_scan import (
     set_fast_grid_scan_params,
 )
 from dodal.devices.flux import Flux
+from dodal.devices.i04.beamsize import Beamsize
 from dodal.devices.i04.transfocator import Transfocator
 from dodal.devices.mx_phase1.beamstop import Beamstop
 from dodal.devices.oav.oav_detector import OAV
@@ -25,7 +26,7 @@ from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
 from dodal.devices.smargon import Smargon
 from dodal.devices.synchrotron import Synchrotron
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.devices.xbpm_feedback import XBPMFeedback
 from dodal.devices.zebra.zebra import Zebra
 from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
@@ -33,7 +34,11 @@ from dodal.devices.zocalo import ZocaloResults
 from dodal.plans.preprocessors.verify_undulator_gap import (
     verify_undulator_gap_before_run_decorator,
 )
+from pydantic import BaseModel
 
+from mx_bluesky.beamlines.i04.external_interaction.config_server import (
+    get_i04_config_client,
+)
 from mx_bluesky.common.device_setup_plans.setup_zebra_and_shutter import (
     setup_zebra_for_gridscan,
     tidy_up_zebra_after_gridscan,
@@ -58,6 +63,7 @@ from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_callback
 from mx_bluesky.common.external_interaction.callbacks.xray_centre.nexus_callback import (
     GridscanNexusFileCallback,
 )
+from mx_bluesky.common.parameters.components import PARAMETER_VERSION
 from mx_bluesky.common.parameters.constants import (
     EnvironmentConstants,
     OavConstants,
@@ -67,13 +73,28 @@ from mx_bluesky.common.parameters.constants import (
 from mx_bluesky.common.parameters.device_composites import (
     GridDetectThenXRayCentreComposite,
 )
-from mx_bluesky.common.parameters.gridscan import GridCommon, SpecifiedThreeDGridScan
+from mx_bluesky.common.parameters.gridscan import (
+    GridCommon,
+    SpecifiedThreeDGridScan,
+)
 from mx_bluesky.common.preprocessors.preprocessors import (
     transmission_and_xbpm_feedback_for_collection_decorator,
 )
+from mx_bluesky.common.utils.exceptions import CrystalNotFoundError
 from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.common.utils.utils import (
+    fix_transmission_and_exposure_time_for_current_wavelength,
+)
 
-DEFAULT_BEAMSIZE_MICRONS = 20
+DEFAULT_XRC_BEAMSIZE_MICRONS = 20
+
+
+class I04AutoXrcParams(BaseModel):
+    sample_id: int
+    file_name: str
+    visit: str
+    detector_distance_mm: float
+    storage_directory: str
 
 
 def _change_beamsize(
@@ -91,19 +112,20 @@ def _change_beamsize(
 
 
 # See https://github.com/DiamondLightSource/blueapi/issues/506 for using device composites
-def i04_grid_detect_then_xray_centre(
-    parameters: GridCommon,
+def i04_default_grid_detect_and_xray_centre(
+    parameters: I04AutoXrcParams,
     aperture_scatterguard: ApertureScatterguard = inject("aperture_scatterguard"),
     attenuator: BinaryFilterAttenuator = inject("attenuator"),
     backlight: Backlight = inject("backlight"),
     beamstop: Beamstop = inject("beamstop"),
+    beamsize: Beamsize = inject("beamsize"),
     dcm: DoubleCrystalMonochromator = inject("dcm"),
     zebra_fast_grid_scan: ZebraFastGridScanThreeD = inject("zebra_fast_grid_scan"),
     flux: Flux = inject("flux"),
     oav: OAV = inject("oav"),
     pin_tip_detection: PinTipDetection = inject("pin_tip_detection"),
     s4_slit_gaps: S4SlitGaps = inject("s4_slit_gaps"),
-    undulator: Undulator = inject("undulator"),
+    undulator: UndulatorInKeV = inject("undulator"),
     xbpm_feedback: XBPMFeedback = inject("xbpm_feedback"),
     zebra: Zebra = inject("zebra"),
     robot: BartRobot = inject("robot"),
@@ -124,7 +146,6 @@ def i04_grid_detect_then_xray_centre(
     - Changes the aperture to match the beam size to the crystal size
     - Moves the sample to the crystal centre of mass
 
-
     i04's implementation of this plan is very similar to Hyperion. However, since i04
     isn't running in a continuous Bluesky UDC loop, we take additional steps in beamline
     tidy-up.
@@ -139,6 +160,7 @@ def i04_grid_detect_then_xray_centre(
         attenuator,
         backlight,
         beamstop,
+        beamsize,
         dcm,
         detector_motion,
         zebra_fast_grid_scan,
@@ -152,9 +174,18 @@ def i04_grid_detect_then_xray_centre(
         robot,
         sample_shutter,
     )
-    initial_beamsize = yield from bps.rd(transfocator.beamsize_set_microns)
+    initial_beamsize = yield from bps.rd(transfocator.current_vertical_size_rbv)
+
+    initial_x = yield from bps.rd(smargon.x.user_readback)
+    initial_y = yield from bps.rd(smargon.y.user_readback)
+    initial_z = yield from bps.rd(smargon.z.user_readback)
+
+    _current_wavelength_a = yield from bps.rd(composite.dcm.wavelength_in_a)
+    grid_common_params = _get_grid_common_params(_current_wavelength_a, parameters)
 
     def tidy_beamline():
+        yield from bps.mv(transfocator, initial_beamsize)
+
         if not udc:
             yield from get_ready_for_oav_and_close_shutter(
                 composite.smargon,
@@ -162,7 +193,6 @@ def i04_grid_detect_then_xray_centre(
                 composite.aperture_scatterguard,
                 composite.detector_motion,
             )
-        yield from bps.mv(transfocator, initial_beamsize)
 
     @bpp.finalize_decorator(tidy_beamline)
     def _inner_grid_detect_then_xrc():
@@ -174,20 +204,30 @@ def i04_grid_detect_then_xray_centre(
         @bpp.subs_decorator(callbacks)
         @verify_undulator_gap_before_run_decorator(composite)
         @transmission_and_xbpm_feedback_for_collection_decorator(
-            composite, parameters.transmission_frac, PlanNameConstants.GRIDSCAN_OUTER
+            composite,
+            grid_common_params.transmission_frac,
+            PlanNameConstants.GRIDSCAN_OUTER,
         )
         def grid_detect_then_xray_centre_with_callbacks():
             yield from grid_detect_then_xray_centre(
                 composite=composite,
-                parameters=parameters,
+                parameters=grid_common_params,
                 xrc_params_type=SpecifiedThreeDGridScan,
                 construct_beamline_specific=construct_i04_specific_features,
                 oav_config=oav_config,
             )
 
-        yield from grid_detect_then_xray_centre_with_callbacks()
+        try:
+            yield from grid_detect_then_xray_centre_with_callbacks()
+        except CrystalNotFoundError:
+            yield from bps.mv(
+                smargon.x, initial_x, smargon.y, initial_y, smargon.z, initial_z
+            )
+            raise
 
-    yield from _change_beamsize(transfocator, DEFAULT_BEAMSIZE_MICRONS, parameters)
+    yield from _change_beamsize(
+        transfocator, DEFAULT_XRC_BEAMSIZE_MICRONS, grid_common_params
+    )
     yield from _inner_grid_detect_then_xrc()
 
 
@@ -278,3 +318,37 @@ def construct_i04_specific_features(
         signals_to_read_during_collection,
         get_xrc_results_from_zocalo=True,
     )
+
+
+def _get_grid_common_params(
+    _current_wavelength_a: float, parameters: I04AutoXrcParams
+) -> GridCommon:
+    """Calculate scaled transmission and exposure by comparing current beamline energy to default energy"""
+    _assumed_wavelength_a = (
+        get_i04_config_client().get_feature_flags().ASSUMED_WAVELENGTH_IN_A
+    )
+    _unscaled_transmission = (
+        get_i04_config_client().get_feature_flags().XRC_UNSCALED_TRANSMISSION_FRAC
+    )
+    _unscaled_exposure_time_s = (
+        get_i04_config_client().get_feature_flags().XRC_UNSCALED_EXPOSURE_TIME_S
+    )
+    transmission_frac, exposure_time_s = (
+        fix_transmission_and_exposure_time_for_current_wavelength(
+            _current_wavelength_a,
+            _assumed_wavelength_a,
+            _unscaled_transmission,
+            _unscaled_exposure_time_s,
+        )
+    )
+
+    return GridCommon(
+        sample_id=parameters.sample_id,
+        file_name=parameters.file_name,
+        visit=parameters.visit,
+        detector_distance_mm=parameters.detector_distance_mm,
+        storage_directory=parameters.storage_directory,
+        transmission_frac=transmission_frac,
+        exposure_time_s=exposure_time_s,
+        parameter_model_version=PARAMETER_VERSION,
+    )

mx_bluesky/beamlines/i04/external_interaction/config_server.py

@@ -0,0 +1,15 @@
+from functools import cache
+
+from mx_bluesky.beamlines.i04.parameters.constants import (
+    I04FeatureSettings,
+    I04FeatureSettingsSources,
+)
+from mx_bluesky.common.external_interaction.config_server import MXConfigClient
+
+
+@cache
+def get_i04_config_client() -> MXConfigClient[I04FeatureSettings]:
+    return MXConfigClient(
+        feature_sources=I04FeatureSettingsSources,
+        feature_dc=I04FeatureSettings,
+    )