mx-bluesky 1.4.1a0__py3-none-any.whl → 1.4.3__py3-none-any.whl

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

@@ -15,22 +15,30 @@ import bluesky.plan_stubs as bps
 import numpy as np
 from bluesky.utils import MsgGenerator
 from dodal.common import inject
+from dodal.devices.attenuator.attenuator import ReadOnlyAttenuator
 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 dodal.devices.i24.pmac import PMAC, EncReset, LaserSettings
 
-from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import ChipType, Fiducials
+from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import (
+    ChipType,
+    Fiducials,
+    MappingType,
+)
 from mx_bluesky.beamlines.i24.serial.log import (
     SSX_LOGGER,
     _read_visit_directory_from_file,
     log_on_entry,
 )
-from mx_bluesky.beamlines.i24.serial.parameters import get_chip_format
+from mx_bluesky.beamlines.i24.serial.parameters import (
+    FixedTargetParameters,
+    get_chip_format,
+    get_chip_map,
+)
 from mx_bluesky.beamlines.i24.serial.parameters.constants import (
     CS_FILES_PATH,
     LITEMAP_PATH,
-    PARAM_FILE_NAME,
     PARAM_FILE_PATH_FT,
     PVAR_FILE_PATH,
 )
@@ -46,6 +54,8 @@ CHIP_MOVES = {
     ChipType.Custom: 25.40,
     ChipType.Minichip: 25.40,
 }
+OXFORD_CHIP_WIDTH = 8
+PVAR_TEMPLATE = f"P3%0{2}d1"
 CHIPTYPE_PV = pv.me14e_gp1
 MAPTYPE_PV = pv.me14e_gp2
 NUM_EXPOSURES_PV = pv.me14e_gp3
@@ -106,21 +116,35 @@ def initialise_stages(
 
 
 @log_on_entry
-def write_parameter_file(
+def read_parameters(
     detector_stage: DetectorMotion,
+    attenuator: ReadOnlyAttenuator,
 ) -> MsgGenerator:
-    param_path: Path = PARAM_FILE_PATH_FT
-    # Create directory if it doesn't yet exist.
-    param_path.mkdir(parents=True, exist_ok=True)
+    """ Read the parameters from user input and create the parameter model for a fixed \
+        target collection.
 
-    SSX_LOGGER.info(
-        f"Writing Parameter File: {(param_path / PARAM_FILE_NAME).as_posix()}"
-    )
+    Args:
+        detector_stage (DetectorMotion): The detector stage device.
+        attenuator (ReadOnlyAttenuator): A read-only attenuator device to get the \
+            transmission value.
+
+    Returns:
+        FixedTargetParameters: Parameter model for fixed target collections
+
+    """
+    SSX_LOGGER.info("Creating parameter model from input.")
 
     filename = caget(pv.me14e_chip_name)
     det_type = yield from get_detector_type(detector_stage)
     chip_params = get_chip_format(ChipType(int(caget(CHIPTYPE_PV))))
     map_type = int(caget(MAPTYPE_PV))
+    if map_type == MappingType.Lite and chip_params.chip_type in [
+        ChipType.Oxford,
+        ChipType.OxfordInner,
+    ]:
+        chip_map = get_chip_map()
+    else:
+        chip_map = []
     pump_repeat = int(caget(PUMP_REPEAT_PV))
 
     # If file name ends in a digit this causes processing/pilatus pain.
@@ -136,6 +160,8 @@ def write_parameter_file(
                 f"Requested filename ends in a number. Appended dash: {filename}"
             )
 
+    transmission = yield from bps.rd(attenuator.actual_transmission)
+
     params_dict = {
         "visit": _read_visit_directory_from_file().as_posix(),  # noqa
         "directory": caget(pv.me14e_filepath),
@@ -144,24 +170,24 @@ def write_parameter_file(
         "detector_distance_mm": caget(pv.me14e_dcdetdist),
         "detector_name": str(det_type),
         "num_exposures": int(caget(NUM_EXPOSURES_PV)),
-        "chip": chip_params.dict(),
+        "transmission": transmission,
+        "chip": chip_params.model_dump(),
         "map_type": map_type,
         "pump_repeat": pump_repeat,
         "checker_pattern": bool(caget(pv.me14e_gp111)),
-        "laser_dwell_s": float(caget(pv.me14e_gp103)) if pump_repeat != 0 else None,
-        "laser_delay_s": float(caget(pv.me14e_gp110)) if pump_repeat != 0 else None,
+        "chip_map": chip_map,
+        "laser_dwell_s": float(caget(pv.me14e_gp103)) if pump_repeat != 0 else 0.0,
+        "laser_delay_s": float(caget(pv.me14e_gp110)) if pump_repeat != 0 else 0.0,
         "pre_pump_exposure_s": float(caget(pv.me14e_gp109))
         if pump_repeat != 0
         else None,
     }
 
-    with open(param_path / PARAM_FILE_NAME, "w") as f:
-        json.dump(params_dict, f, indent=4)
-
-    SSX_LOGGER.info("Information written to file \n")
+    SSX_LOGGER.info("Parameters for I24 serial collection: \n")
     SSX_LOGGER.info(pformat(params_dict))
 
     yield from bps.null()
+    return FixedTargetParameters(**params_dict)
 
 
 def scrape_pvar_file(fid: str, pvar_dir: Path = PVAR_FILE_PATH):
@@ -216,59 +242,25 @@ def define_current_chip(
 
 
 @log_on_entry
-def save_screen_map() -> MsgGenerator:
-    litemap_path: Path = LITEMAP_PATH
-    litemap_path.mkdir(parents=True, exist_ok=True)
-
-    SSX_LOGGER.info(f"Saving {litemap_path.as_posix()} currentchip.map")
-    with open(litemap_path / "currentchip.map", "w") as f:
-        SSX_LOGGER.debug("Printing only blocks with block_val == 1")
-        for x in range(1, 82):
-            block_str = f"ME14E-MO-IOC-01:GP{x + 10:d}"
-            block_val = int(caget(block_str))
-            if block_val == 1:
-                SSX_LOGGER.info(f"{block_str} {block_val:d}")
-            line = f"{x:02d}status    P3{x:02d}1 \t{block_val}\n"
-            f.write(line)
-    yield from bps.null()
+def upload_chip_map_to_geobrick(pmac: PMAC, chip_map: list[int]) -> MsgGenerator:
+    """Upload the map parameters for an Oxford-type chip (width=8) to the geobrick.
 
+    Args:
+        pmac (PMAC): The PMAC device.
+        chip_map (list[int]): A list of selected blocks to be collected.
 
-@log_on_entry
-def upload_parameters(pmac: PMAC = inject("pmac")) -> MsgGenerator:
+    """
     SSX_LOGGER.info("Uploading Parameters for Oxford Chip to the GeoBrick")
-    caput(CHIPTYPE_PV, 0)
-    width = 8
-
-    map_file: Path = LITEMAP_PATH / "currentchip.map"
-    if not map_file.exists():
-        raise FileNotFoundError(f"The file {map_file} has not yet been created")
-
-    with open(map_file) as f:
-        SSX_LOGGER.info(f"Chipid {ChipType.Oxford}")
-        SSX_LOGGER.info(f"width {width}")
-        x = 1
-        for line in f.readlines()[: width**2]:
-            cols = line.split()
-            pvar = cols[1]
-            value = cols[2]
-            s = pvar + "=" + value
-            if value != "1":
-                s2 = pvar + "   "
-                sys.stdout.write(s2)
-            else:
-                sys.stdout.write(s + " ")
-            sys.stdout.flush()
-            if x == width:
-                print()
-                x = 1
-            else:
-                x += 1
-            yield from bps.abs_set(pmac.pmac_string, s, wait=True)
-            sleep(0.02)
-
-    SSX_LOGGER.warning("Automatic Setting Mapping Type to Lite has been disabled")
+    SSX_LOGGER.info(f"Chipid {ChipType.Oxford}, width {OXFORD_CHIP_WIDTH}")
+    for block in range(1, 65):
+        value = 1 if block in chip_map else 0
+        pvar = PVAR_TEMPLATE % block
+        pvar_str = f"{pvar}={value}"
+        SSX_LOGGER.debug(f"Set {pvar_str} for block {block}")
+        yield from bps.abs_set(pmac.pmac_string, pvar_str, wait=True)
+        # Wait for PMAC to be done processing PVAR string
+        sleep(0.02)
     SSX_LOGGER.debug("Upload parameters done.")
-    yield from bps.null()
 
 
 @log_on_entry

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

@@ -3,28 +3,10 @@ Startup utilities for chip
 """
 
 import string
-from pathlib import Path
 
 from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import ChipType
 from mx_bluesky.beamlines.i24.serial.log import SSX_LOGGER, log_on_entry
-from mx_bluesky.beamlines.i24.serial.parameters import (
-    FixedTargetParameters,
-    get_chip_format,
-)
-from mx_bluesky.beamlines.i24.serial.parameters.constants import (
-    PARAM_FILE_NAME,
-    PARAM_FILE_PATH_FT,
-)
-
-
-def read_parameter_file(
-    param_path: Path | str = PARAM_FILE_PATH_FT,
-) -> FixedTargetParameters:
-    if not isinstance(param_path, Path):
-        param_path = Path(param_path)
-    params_file = param_path / PARAM_FILE_NAME
-    params = FixedTargetParameters.from_file(params_file)
-    return params
+from mx_bluesky.beamlines.i24.serial.parameters import get_chip_format
 
 
 @log_on_entry

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

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

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

@@ -1,15 +1,29 @@
-from enum import Enum
+from enum import StrEnum
 from os import environ
 from pathlib import Path
 
 from mx_bluesky.beamlines.i24.serial.log import _read_visit_directory_from_file
 
 
-class SSXType(Enum):
+class SSXType(StrEnum):
     FIXED = "Serial Fixed"
     EXTRUDER = "Serial Jet"
 
 
+class DetectorName(StrEnum):
+    EIGER = "eiger"
+    PILATUS = "pilatus"
+
+
+# TODO figue sth out for tests
+LUT_FILES_PATH = Path("/dls_sw/i24/software/daq_configuration/lookup")
+
+BEAM_CENTER_LUT_FILES = {
+    DetectorName.EIGER: LUT_FILES_PATH / "DetDistToBeamXYConverterE9M.txt",
+    DetectorName.PILATUS: LUT_FILES_PATH / "DetDistToBeamXYConverterP6M.txt",
+}
+
+
 OAV_CONFIG_FILES = {
     "zoom_params_file": "/dls_sw/i24/software/gda_versions/gda_9_34/config/xml/jCameraManZoomLevels.xml",
     "oav_config_json": "/dls_sw/i24/software/daq_configuration/json/OAVCentring.json",

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

@@ -1,14 +1,24 @@
 import json
+from abc import abstractmethod
 from pathlib import Path
-from typing import Literal
 
-from pydantic import BaseModel, field_validator
+import numpy as np
+from dodal.devices.detector.det_dim_constants import (
+    EIGER2_X_9M_SIZE,
+    PILATUS_6M_SIZE,
+    DetectorSizeConstants,
+)
+from pydantic import BaseModel, ConfigDict, computed_field, field_validator
 
 from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import (
     ChipType,
     MappingType,
     PumpProbeSetting,
 )
+from mx_bluesky.beamlines.i24.serial.parameters.constants import (
+    DetectorName,
+    SSXType,
+)
 
 
 class SerialExperiment(BaseModel):
@@ -19,7 +29,8 @@ class SerialExperiment(BaseModel):
     filename: str
     exposure_time_s: float
     detector_distance_mm: float
-    detector_name: Literal["eiger", "pilatus"]
+    detector_name: DetectorName
+    transmission: float
 
     @field_validator("visit", mode="before")
     @classmethod
@@ -30,29 +41,58 @@ class SerialExperiment(BaseModel):
 
     @property
     def collection_directory(self) -> Path:
-        return Path(self.visit) / self.directory
+        directory = Path(self.visit) / self.directory
+        return directory
+
+    @property
+    def detector_size_constants(self) -> DetectorSizeConstants:
+        return (
+            EIGER2_X_9M_SIZE
+            if self.detector_name is DetectorName.EIGER
+            else PILATUS_6M_SIZE
+        )
 
 
 class LaserExperiment(BaseModel):
     """Laser settings for pump probe serial collections."""
 
-    laser_dwell_s: float | None = None  # pump exposure time
-    laser_delay_s: float | None = None  # pump delay
+    laser_dwell_s: float = 0.0  # pump exposure time
+    laser_delay_s: float = 0.0  # pump delay
     pre_pump_exposure_s: float | None = None  # Pre illumination, just for chip
 
 
-class ExtruderParameters(SerialExperiment, LaserExperiment):
-    """Extruder parameter model."""
-
-    num_images: int
-    pump_status: bool
-
+class SerialAndLaserExperiment(SerialExperiment, LaserExperiment):
     @classmethod
     def from_file(cls, filename: str | Path):
         with open(filename) as fh:
             raw_params = json.load(fh)
         return cls(**raw_params)
 
+    @property
+    @abstractmethod
+    def nexgen_experiment_type(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def ispyb_experiment_type(self) -> SSXType:
+        pass
+
+
+class ExtruderParameters(SerialAndLaserExperiment):
+    """Extruder parameter model."""
+
+    num_images: int
+    pump_status: bool
+
+    @property
+    def nexgen_experiment_type(self) -> str:
+        return "extruder"
+
+    @property
+    def ispyb_experiment_type(self) -> SSXType:
+        return SSXType.EXTRUDER
+
 
 class ChipDescription(BaseModel):
     """Parameters defining the chip in use for FT collection."""
@@ -85,8 +125,12 @@ class ChipDescription(BaseModel):
         else:
             return ((self.y_num_steps - 1) * self.y_step_size) + self.b2b_vert
 
+    @property
+    def tot_num_blocks(self) -> int:
+        return self.x_blocks * self.y_blocks
+
 
-class FixedTargetParameters(SerialExperiment, LaserExperiment):
+class FixedTargetParameters(SerialAndLaserExperiment):
     """Fixed target parameter model."""
 
     num_exposures: int
@@ -94,10 +138,41 @@ class FixedTargetParameters(SerialExperiment, LaserExperiment):
     map_type: MappingType
     pump_repeat: PumpProbeSetting
     checker_pattern: bool = False
-    total_num_images: int = 0  # Calculated in the code for now
+    chip_map: list[int]
 
-    @classmethod
-    def from_file(cls, filename: str | Path):
-        with open(filename) as fh:
-            raw_params = json.load(fh)
-        return cls(**raw_params)
+    @property
+    def nexgen_experiment_type(self) -> str:
+        return "fixed-target"
+
+    @property
+    def ispyb_experiment_type(self) -> SSXType:
+        return SSXType.FIXED
+
+    @computed_field  # type: ignore   # Mypy doesn't like it
+    @property
+    def total_num_images(self) -> int:
+        match self.map_type:
+            case MappingType.NoMap:
+                if self.chip.chip_type is ChipType.Custom:
+                    num_images = (
+                        self.chip.x_num_steps
+                        * self.chip.y_num_steps
+                        * self.num_exposures
+                    )
+                else:
+                    chip_format = self.chip.chip_format[:4]
+                    num_images = int(np.prod(chip_format) * self.num_exposures)
+            case MappingType.Lite:
+                chip_format = self.chip.chip_format[2:4]
+                block_count = len(self.chip_map)  # type: ignore
+                num_images = int(
+                    np.prod(chip_format) * block_count * self.num_exposures
+                )
+        return num_images
+
+
+class BeamSettings(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    wavelength_in_a: float
+    beam_size_in_um: tuple[float, float]
+    beam_center_in_mm: tuple[float, float]

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

@@ -6,6 +6,12 @@ from mx_bluesky.beamlines.i24.serial.parameters.experiment_parameters import (
 )
 from mx_bluesky.beamlines.i24.serial.setup_beamline import caget, pv
 
+OXFORD_BLOCKS_PVS = [f"ME14E-MO-IOC-01:GP{i}" for i in range(11, 75)]
+
+
+class EmptyMapError(Exception):
+    pass
+
 
 def get_chip_format(chip_type: ChipType) -> ChipDescription:
     """Default parameter values."""
@@ -40,3 +46,16 @@ def get_chip_format(chip_type: ChipType) -> ChipDescription:
             defaults["b2b_horz"] = defaults["b2b_vert"] = 0.0
     chip_params: dict[str, Any] = {"chip_type": chip_type, **defaults}
     return ChipDescription(**chip_params)
+
+
+def get_chip_map() -> list[int]:
+    """Return a list of blocks (the 'chip map') to be collected on an Oxford type chip \
+        when using lite mapping."""
+    chipmap = []
+    for n, block_pv in enumerate(OXFORD_BLOCKS_PVS):
+        block_val = int(caget(block_pv))
+        if block_val == 1:
+            chipmap.append(n + 1)
+    if len(chipmap) == 0:
+        raise EmptyMapError("No blocks selected for Lite map.")
+    return chipmap

mx_bluesky/beamlines/i24/serial/setup_beamline/pv.py

@@ -23,6 +23,8 @@ def __which__():
     print("path to pv.py: ")
 
 
+requested_transmission = "BL24I-OP-ATTN-01:T2A:SETVAL1"
+
 # PILATUS
 pilat_filepath = "BL24I-EA-PILAT-01:cam1:FilePath"
 pilat_filename = "BL24I-EA-PILAT-01:cam1:FileName"

mx_bluesky/beamlines/i24/serial/setup_beamline/setup_beamline.py

@@ -1,16 +1,60 @@
+from pathlib import Path
 from time import sleep
 
 import bluesky.plan_stubs as bps
+from dodal.beamlines import i24
+from dodal.devices.detector.det_dim_constants import DetectorSizeConstants
 from dodal.devices.i24.aperture import Aperture, AperturePositions
+from dodal.devices.i24.beam_center import DetectorBeamCenter
 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 dodal.devices.util.lookup_tables import (
+    linear_interpolation_lut,
+    parse_lookup_table,
+)
 
 from mx_bluesky.beamlines.i24.serial.log import SSX_LOGGER
 from mx_bluesky.beamlines.i24.serial.setup_beamline import pv
 from mx_bluesky.beamlines.i24.serial.setup_beamline.ca import caget, caput
 
 
+def get_beam_center_device(detector_in_use: str) -> DetectorBeamCenter:
+    if detector_in_use == "eiger":
+        return i24.eiger_beam_center()
+    else:
+        return i24.pilatus_beam_center()
+
+
+def compute_beam_center_position_from_lut(
+    lut_path: Path,
+    detector_distance_mm: float,
+    det_size_constants: DetectorSizeConstants,
+) -> tuple[float, float]:
+    """Calculate the beam center position for the detector distance \
+    using the values in the lookup table for the conversion.
+    """
+    lut_values = parse_lookup_table(lut_path.as_posix())
+
+    calc_x = linear_interpolation_lut(lut_values[0], lut_values[1])
+    beam_x_mm = calc_x(detector_distance_mm)
+    beam_x = (
+        beam_x_mm
+        * det_size_constants.det_size_pixels.width
+        / det_size_constants.det_dimension.width
+    )
+
+    calc_y = linear_interpolation_lut(lut_values[0], lut_values[2])
+    beam_y_mm = calc_y(detector_distance_mm)
+    beam_y = (
+        beam_y_mm
+        * det_size_constants.det_size_pixels.height
+        / det_size_constants.det_dimension.height
+    )
+
+    return beam_x, beam_y
+
+
 def setup_beamline_for_collection_plan(
     aperture: Aperture,
     backlight: DualBacklight,
@@ -43,6 +87,23 @@ def move_detector_stage_to_position_plan(
     yield from bps.mv(detector_stage.z, detector_distance)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
 
+def set_detector_beam_center_plan(
+    beam_center_device: DetectorBeamCenter,
+    beam_center_pixels: tuple[float, float],
+    group: str = "set_beamcenter",
+    wait: bool = True,
+):
+    """A small temporary plan to set up the beam center on the detector in use."""
+    # NOTE This will be removed once the detectors are using ophyd_async devices
+    # See https://github.com/DiamondLightSource/mx-bluesky/issues/62
+    beam_position_x, beam_position_y = beam_center_pixels
+    SSX_LOGGER.info(f"Setting beam center to: {beam_position_x}, {beam_position_y}")
+    yield from bps.abs_set(beam_center_device.beam_x, beam_position_x, group=group)
+    yield from bps.abs_set(beam_center_device.beam_y, beam_position_y, group=group)
+    if wait:
+        yield from bps.wait(group=group)
+
+
 def modechange(action):
     """Mode Change"""
     # Pin Hand Mount
@@ -232,11 +293,6 @@ def pilatus(action, args_list):
     # caput(pv.pilat_wavelength, caget(pv.dcm_lambda))
     caput(pv.pilat_detdist, caget(pv.det_z))
     caput(pv.pilat_filtertrasm, caget(pv.attn_match))
-    SSX_LOGGER.warning("WARNING: Have you set beam X and Y?")
-    # 16 Fed 2022 last change DA
-    caput(pv.pilat_beamx, 1284.7)
-    caput(pv.pilat_beamy, 1308.6)
-    sleep(0.1)
 
     # Fixed Target stage (very fast start and stop w/ triggering from GeoBrick
     if action == "fastchip":
@@ -330,11 +386,8 @@ def eiger(action, args_list):
             SSX_LOGGER.debug(f"Argument: {arg}")
     # caput(pv.eiger_wavelength, caget(pv.dcm_lambda))
     caput(pv.eiger_detdist, str(float(caget(pv.det_z)) / 1000))
-    SSX_LOGGER.warning("WARNING: Have you set header info?")
     caput(pv.eiger_wavelength, caget(pv.dcm_lambda))
     caput(pv.eiger_omegaincr, 0.0)
-    caput(pv.eiger_beamx, 1600.0)
-    caput(pv.eiger_beamy, 1697.4)
     sleep(0.1)
     # Setup common to all collections ###
     caput(pv.eiger_filewriter, "No")