dls-dodal 1.44.0__py3-none-any.whl → 1.46.0__py3-none-any.whl

dodal/beamlines/i23.py

@@ -1,6 +1,24 @@
-from dodal.common.beamlines.beamline_utils import device_factory
+from pathlib import Path
+
+from ophyd_async.epics.adpilatus import PilatusDetector
+
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+    get_path_provider,
+    set_path_provider,
+)
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.common.beamlines.device_helpers import HDF5_SUFFIX
+from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
+from dodal.devices.motors import SixAxisGonio
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
+from dodal.devices.zebra.zebra import Zebra
+from dodal.devices.zebra.zebra_constants_mapping import (
+    ZebraMapping,
+    ZebraSources,
+    ZebraTTLOutputs,
+)
+from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name, get_hostname
 
@@ -8,8 +26,22 @@ BL = get_beamline_name("i23")
 set_log_beamline(BL)
 set_utils_beamline(BL)
 
+set_path_provider(
+    StaticVisitPathProvider(
+        BL,
+        Path("/tmp"),
+        client=LocalDirectoryServiceClient(),
+    )
+)
+
 PREFIX = BeamlinePrefix(BL)
 
+I23_ZEBRA_MAPPING = ZebraMapping(
+    outputs=ZebraTTLOutputs(TTL_DETECTOR=1, TTL_SHUTTER=4),
+    sources=ZebraSources(),
+    AND_GATE_FOR_AUTO_SHUTTER=2,
+)
+
 
 def _is_i23_machine():
     """
@@ -22,9 +54,42 @@ def _is_i23_machine():
 
 @device_factory(skip=lambda: not _is_i23_machine())
 def oav_pin_tip_detection() -> PinTipDetection:
-    """Get the i23 OAV pin-tip detection device"""
+    """Get the i23 OAV pin-tip detection device."""
 
     return PinTipDetection(
         f"{PREFIX.beamline_prefix}-DI-OAV-01:",
         "pin_tip_detection",
     )
+
+
+@device_factory()
+def shutter() -> ZebraShutter:
+    """Get the i23 zebra controlled shutter."""
+    return ZebraShutter(f"{PREFIX.beamline_prefix}-EA-SHTR-01:", "shutter")
+
+
+@device_factory()
+def gonio() -> SixAxisGonio:
+    """Get the i23 goniometer"""
+    return SixAxisGonio(f"{PREFIX.beamline_prefix}-MO-GONIO-01:")
+
+
+@device_factory()
+def zebra() -> Zebra:
+    """Get the i23 zebra"""
+    return Zebra(
+        name="zebra",
+        prefix=f"{PREFIX.beamline_prefix}-EA-ZEBRA-01:ZEBRA:",
+        mapping=I23_ZEBRA_MAPPING,
+    )
+
+
+@device_factory()
+def pilatus() -> PilatusDetector:
+    """Get the i23 pilatus"""
+    return PilatusDetector(
+        prefix=f"{PREFIX.beamline_prefix}-EA-PILAT-01:",
+        path_provider=get_path_provider(),
+        drv_suffix="cam1:",
+        fileio_suffix=HDF5_SUFFIX,
+    )

dodal/beamlines/p38.py

@@ -16,7 +16,7 @@ from dodal.common.crystal_metadata import (
 )
 from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
 from dodal.devices.focusing_mirror import FocusingMirror
-from dodal.devices.i22.dcm import DoubleCrystalMonochromator
+from dodal.devices.i22.dcm import DCM
 from dodal.devices.i22.fswitch import FSwitch
 from dodal.devices.linkam3 import Linkam3
 from dodal.devices.pressure_jump_cell import PressureJumpCell
@@ -143,8 +143,8 @@ def hfm() -> FocusingMirror:
 
 
 @device_factory(mock=True)
-def dcm() -> DoubleCrystalMonochromator:
-    return DoubleCrystalMonochromator(
+def dcm() -> DCM:
+    return DCM(
         temperature_prefix=f"{PREFIX.beamline_prefix}-DI-DCM-01:",
         crystal_1_metadata=make_crystal_metadata_from_material(
             MaterialsEnum.Si, (1, 1, 1)

dodal/beamlines/p60.py

@@ -0,0 +1,21 @@
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+)
+from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.devices.electron_analyser.vgscienta_analyser_io import (
+    VGScientaAnalyserDriverIO,
+)
+from dodal.log import set_beamline as set_log_beamline
+from dodal.utils import BeamlinePrefix, get_beamline_name
+
+BL = get_beamline_name("p60")
+PREFIX = BeamlinePrefix(BL)
+set_log_beamline(BL)
+set_utils_beamline(BL)
+
+
+@device_factory()
+def analyser_driver() -> VGScientaAnalyserDriverIO:
+    return VGScientaAnalyserDriverIO(
+        name="analyser_driver", prefix=f"{PREFIX.beamline_prefix}-EA-DET-01:CAM:"
+    )

dodal/common/beamlines/beamline_utils.py

@@ -162,3 +162,8 @@ def set_path_provider(provider: PathProvider):
 
 def get_path_provider() -> PathProvider:
     return PATH_PROVIDER
+
+
+def clear_path_provider() -> None:
+    global PATH_PROVIDER
+    del PATH_PROVIDER

dodal/common/visit.py

@@ -3,8 +3,7 @@ from pathlib import Path
 from typing import Literal
 
 from aiohttp import ClientSession
-from event_model import RunStart
-from ophyd_async.core import FilenameProvider, PathInfo, PathProvider
+from ophyd_async.core import FilenameProvider, PathInfo
 from pydantic import BaseModel
 
 from dodal.common.types import UpdatingPathProvider
@@ -151,42 +150,3 @@ class StaticVisitPathProvider(UpdatingPathProvider):
         return PathInfo(
             directory_path=self._root, filename=self._filename_provider(device_name)
         )
-
-
-DEFAULT_TEMPLATE = "{device_name}-{instrument}-{scan_id}"
-
-
-class StartDocumentPathProvider(PathProvider):
-    """A PathProvider that sources from metadata in a RunStart document.
-
-    This uses metadata from a RunStart document to determine file names and data session
-    directories. The file naming defaults to "{device_name}-{instrument}-{scan_id}", so
-    the file name is incremented by scan number. A template can be included in the
-    StartDocument to allow for custom naming conventions.
-
-    """
-
-    def __init__(self) -> None:
-        self._doc = {}
-
-    def update_run(self, name: str, start_doc: RunStart) -> None:
-        """Cache a start document.
-
-        This can be plugged into the run engine's subscribe method.
-        """
-        if name == "start":
-            self._doc = start_doc
-
-    def __call__(self, device_name: str | None = None) -> PathInfo:
-        """Returns the directory path and filename for a given data_session.
-
-        The default template for file naming is: "{device_name}-{instrument}-{scan_id}"
-        however, this can be changed by providing a template in the start document. For
-        example: "template": "custom-{device_name}--{scan_id}".
-
-        If you do not provide a data_session_directory it will default to "/tmp".
-        """
-        template = self._doc.get("template", DEFAULT_TEMPLATE)
-        sub_path = template.format_map(self._doc | {"device_name": device_name})
-        data_session_directory = Path(self._doc.get("data_session_directory", "/tmp"))
-        return PathInfo(directory_path=data_session_directory, filename=sub_path)

dodal/devices/common_dcm.py

@@ -0,0 +1,77 @@
+from typing import Generic, TypeVar
+
+from ophyd_async.core import (
+    StandardReadable,
+)
+from ophyd_async.epics.core import epics_signal_r
+from ophyd_async.epics.motor import Motor
+
+
+class StationaryCrystal(StandardReadable):
+    def __init__(self, prefix):
+        super().__init__(prefix)
+
+
+class RollCrystal(StationaryCrystal):
+    def __init__(self, prefix):
+        with self.add_children_as_readables():
+            self.roll_in_mrad = Motor(prefix + "ROLL")
+        super().__init__(prefix)
+
+
+class PitchAndRollCrystal(StationaryCrystal):
+    def __init__(self, prefix):
+        with self.add_children_as_readables():
+            self.pitch_in_mrad = Motor(prefix + "PITCH")
+            self.roll_in_mrad = Motor(prefix + "ROLL")
+        super().__init__(prefix)
+
+
+Xtal_1 = TypeVar("Xtal_1", bound=StationaryCrystal)
+Xtal_2 = TypeVar("Xtal_2", bound=StationaryCrystal)
+
+
+class BaseDCM(StandardReadable, Generic[Xtal_1, Xtal_2]):
+    """
+    Common device for the double crystal monochromator (DCM), used to select the energy of the beam.
+
+    Features common across all DCM's should include virtual motors to set energy/wavelength and contain two crystals,
+    each of which can be movable. Some DCM's contain crystals with roll motors, and some contain crystals with roll and pitch motors.
+    This base device accounts for all combinations of this.
+
+    This device should act as a parent for beamline-specific DCM's, in which any other missing signals can be added.
+
+    Bluesky plans using DCM's should be typed to specify which types of crystals are required. For example, a plan
+    which only requires one crystal which can roll should be typed 'def my_plan(dcm: BaseDCM[RollCrystal, StationaryCrystal])`
+    """
+
+    def __init__(
+        self, prefix: str, xtal_1: type[Xtal_1], xtal_2: type[Xtal_2], name: str = ""
+    ) -> None:
+        with self.add_children_as_readables():
+            # Virtual motor PV's which set the physical motors so that the DCM produces requested
+            # wavelength/energy
+            self.energy_in_kev = Motor(prefix + "ENERGY")
+            self.wavelength_in_a = Motor(prefix + "WAVELENGTH")
+
+            # Real motors
+            self.bragg_in_degrees = Motor(prefix + "BRAGG")
+            # Offset ensures that the beam exits the DCM at the same point, regardless of energy.
+            self.offset_in_mm = Motor(prefix + "OFFSET")
+
+            self.crystal_metadata_d_spacing_a = epics_signal_r(
+                float, prefix + "DSPACING:RBV"
+            )
+
+            self._make_crystals(prefix, xtal_1, xtal_2)
+
+        super().__init__(name)
+
+    # Prefix convention is different depending on whether there are one or two controllable crystals
+    def _make_crystals(self, prefix: str, xtal_1: type[Xtal_1], xtal_2: type[Xtal_2]):
+        if StationaryCrystal not in [xtal_1, xtal_2]:
+            self.xtal_1 = xtal_1(f"{prefix}XTAL1:")
+            self.xtal_2 = xtal_2(f"{prefix}XTAL2:")
+        else:
+            self.xtal_1 = xtal_1(prefix)
+            self.xtal_2 = xtal_2(prefix)

dodal/devices/detector/det_dist_to_beam_converter.py

@@ -1,6 +1,9 @@
 from enum import Enum
 
-from numpy import interp, loadtxt
+from dodal.devices.util.lookup_tables import (
+    linear_extrapolation_lut,
+    parse_lookup_table,
+)
 
 
 class Axis(Enum):
@@ -11,12 +14,20 @@ class Axis(Enum):
 class DetectorDistanceToBeamXYConverter:
     def __init__(self, lookup_file: str):
         self.lookup_file: str = lookup_file
-        self.lookup_table_values: list = self.parse_table()
+        lookup_table_columns: list = parse_lookup_table(self.lookup_file)
+        self._d_to_x = linear_extrapolation_lut(
+            lookup_table_columns[0], lookup_table_columns[1]
+        )
+        self._d_to_y = linear_extrapolation_lut(
+            lookup_table_columns[0], lookup_table_columns[2]
+        )
 
     def get_beam_xy_from_det_dist(self, det_dist_mm: float, beam_axis: Axis) -> float:
-        beam_axis_values = self.lookup_table_values[beam_axis.value]
-        det_dist_array = self.lookup_table_values[0]
-        return float(interp(det_dist_mm, det_dist_array, beam_axis_values))
+        return (
+            self._d_to_x(det_dist_mm)
+            if beam_axis == Axis.X_AXIS
+            else self._d_to_y(det_dist_mm)
+        )
 
     def get_beam_axis_pixels(
         self,
@@ -41,21 +52,3 @@ class DetectorDistanceToBeamXYConverter:
         return self.get_beam_axis_pixels(
             det_distance, image_size_pixels, det_dim, Axis.X_AXIS
         )
-
-    def reload_lookup_table(self):
-        self.lookup_table_values = self.parse_table()
-
-    def parse_table(self) -> list:
-        rows = loadtxt(self.lookup_file, delimiter=" ", comments=["#", "Units"])
-        columns = list(zip(*rows, strict=False))
-
-        return columns
-
-    def __eq__(self, other):
-        if not isinstance(other, DetectorDistanceToBeamXYConverter):
-            return NotImplemented
-        if self.lookup_file != other.lookup_file:
-            return False
-        if self.lookup_table_values != other.lookup_table_values:
-            return False
-        return True

dodal/devices/detector/detector.py

@@ -1,4 +1,5 @@
 from enum import Enum, auto
+from functools import cached_property
 from pathlib import Path
 
 from pydantic import BaseModel, Field, field_serializer, field_validator
@@ -49,7 +50,7 @@ class DetectorParams(BaseModel):
         False  # Remove in https://github.com/DiamondLightSource/hyperion/issues/1395
     )
 
-    @property
+    @cached_property
     def beam_xy_converter(self) -> DetectorDistanceToBeamXYConverter:
         return DetectorDistanceToBeamXYConverter(self.det_dist_to_beam_converter_path)
 

dodal/devices/electron_analyser/abstract_analyser_io.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract_region import EnergyMode
+
+
+class AbstractAnalyserDriverIO(ABC, StandardReadable):
+    """
+    Generic device to configure electron analyser with new region settings.
+    Electron analysers should inherit from this class for further specialisation.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.low_energy = epics_signal_rw(float, prefix + "LOW_ENERGY")
+            self.high_energy = epics_signal_rw(float, prefix + "HIGH_ENERGY")
+            self.slices = epics_signal_rw(int, prefix + "SLICES")
+            self.lens_mode = epics_signal_rw(str, prefix + "LENS_MODE")
+            self.pass_energy = epics_signal_rw(
+                self.pass_energy_type, prefix + "PASS_ENERGY"
+            )
+            self.energy_step = epics_signal_rw(float, prefix + "STEP_SIZE")
+            self.iterations = epics_signal_rw(int, prefix + "NumExposures")
+            self.acquisition_mode = epics_signal_rw(str, prefix + "ACQ_MODE")
+
+        super().__init__(name)
+
+    def to_kinetic_energy(
+        self, value: float, excitation_energy: float, mode: EnergyMode
+    ) -> float:
+        return excitation_energy - value if mode == EnergyMode.BINDING else value
+
+    @property
+    @abstractmethod
+    def pass_energy_type(self) -> type:
+        """
+        Return the type the pass_energy should be. Each one is unfortunately different
+        for the underlying analyser software and cannot be changed on epics side.
+        """
+
+
+TAbstractAnalyserDriverIO = TypeVar(
+    "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO
+)

dodal/devices/electron_analyser/abstract_region.py

@@ -0,0 +1,112 @@
+import re
+from abc import ABC
+from collections.abc import Callable
+from enum import Enum
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel, Field, model_validator
+
+
+def java_to_python_case(java_str: str) -> str:
+    """
+    Convert a camelCase Java-style string to a snake_case Python-style string.
+
+    :param java_str: The Java-style camelCase string.
+    :return: The Python-style snake_case string.
+    """
+    new_value = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", java_str)
+    new_value = re.sub("([a-z0-9])([A-Z])", r"\1_\2", new_value).lower()
+    return new_value
+
+
+def switch_case_validation(data: dict, f: Callable[[str], str]) -> dict:
+    return {f(key): value for key, value in data.items()}
+
+
+class JavaToPythonModel(BaseModel):
+    @model_validator(mode="before")
+    @classmethod
+    def before_validation(cls, data: dict) -> dict:
+        data = switch_case_validation(data, java_to_python_case)
+        return data
+
+
+def energy_mode_validation(data: dict) -> dict:
+    # Convert binding_energy to energy_mode to make base region more generic
+    if "binding_energy" in data:
+        is_binding_energy = data["binding_energy"]
+        del data["binding_energy"]
+        data["energy_mode"] = (
+            EnergyMode.BINDING if is_binding_energy else EnergyMode.KINETIC
+        )
+    return data
+
+
+class EnergyMode(str, Enum):
+    KINETIC = "Kinetic"
+    BINDING = "Binding"
+
+
+class AbstractBaseRegion(ABC, JavaToPythonModel):
+    """
+    Generic region model that holds the data. Specialised region models should inherit
+    this to extend functionality. All energy units are assumed to be in eV.
+    """
+
+    name: str = "New_region"
+    enabled: bool = False
+    slices: int = 1
+    iterations: int = 1
+    # These ones we need subclasses to provide default values
+    lens_mode: str
+    pass_energy: int
+    acquisition_mode: str
+    low_energy: float
+    high_energy: float
+    step_time: float
+    energy_step: float  # in eV
+    energy_mode: EnergyMode = EnergyMode.KINETIC
+
+    def is_binding_energy(self) -> bool:
+        return self.energy_mode == EnergyMode.BINDING
+
+    def is_kinetic_energy(self) -> bool:
+        return self.energy_mode == EnergyMode.KINETIC
+
+    def to_kinetic_energy(self, value: float, excitation_energy: float) -> float:
+        return value if self.is_binding_energy() else excitation_energy - value
+
+    @model_validator(mode="before")
+    @classmethod
+    def before_validation(cls, data: dict) -> dict:
+        data = switch_case_validation(data, java_to_python_case)
+        return energy_mode_validation(data)
+
+
+TAbstractBaseRegion = TypeVar("TAbstractBaseRegion", bound=AbstractBaseRegion)
+
+
+class AbstractBaseSequence(ABC, JavaToPythonModel, Generic[TAbstractBaseRegion]):
+    """
+    Generic sequence model that holds the list of region data. Specialised sequence
+    models should inherit this to extend functionality and define type of region to
+    hold.
+    """
+
+    version: float = 0.1  # If file format changes within prod, increment this number!
+    regions: list[TAbstractBaseRegion] = Field(default_factory=lambda: [])
+
+    def get_enabled_regions(self) -> list[TAbstractBaseRegion]:
+        return [r for r in self.regions if r.enabled]
+
+    def get_region_names(self) -> list[str]:
+        return [r.name for r in self.regions]
+
+    def get_enabled_region_names(self) -> list[str]:
+        return [r.name for r in self.get_enabled_regions()]
+
+    def get_region_by_name(self, name: str) -> TAbstractBaseRegion | None:
+        return next((region for region in self.regions if region.name == name), None)
+
+
+TAbstractBaseSequence = TypeVar("TAbstractBaseSequence", bound=AbstractBaseSequence)

dodal/devices/electron_analyser/specs_analyser_io.py

@@ -0,0 +1,19 @@
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract_analyser_io import (
+    AbstractAnalyserDriverIO,
+)
+
+
+class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.psu_mode = epics_signal_rw(str, prefix + "SCAN_RANGE")
+            self.values = epics_signal_rw(int, prefix + "VALUES")
+            self.centre_energy = epics_signal_rw(float, prefix + "KINETIC_ENERGY")
+
+        super().__init__(prefix, name)
+
+    @property
+    def pass_energy_type(self) -> type:
+        return float

dodal/devices/electron_analyser/specs_region.py

@@ -0,0 +1,26 @@
+from pydantic import Field
+
+from dodal.devices.electron_analyser.abstract_region import (
+    AbstractBaseRegion,
+    AbstractBaseSequence,
+)
+
+
+class SpecsRegion(AbstractBaseRegion):
+    # Override base class with defaults
+    lens_mode: str = "SmallArea"
+    pass_energy: int = 5
+    acquisition_mode: str = "Fixed Transmission"
+    low_energy: float = Field(default=800, alias="start_energy")
+    high_energy: float = Field(default=850, alias="end_energy")
+    step_time: float = Field(default=1.0, alias="exposure_time")
+    energy_step: float = Field(default=0.1, alias="step_energy")
+    # Specific to this class
+    values: int = 1
+    centre_energy: float = 0
+    psu_mode: str = "1.5keV"
+    estimated_time_in_ms: float = 0
+
+
+class SpecsSequence(AbstractBaseSequence[SpecsRegion]):
+    regions: list[SpecsRegion] = Field(default_factory=lambda: [])

dodal/devices/electron_analyser/vgscienta_analyser_io.py

@@ -0,0 +1,26 @@
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract_analyser_io import (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta_region import (
+    DetectorMode,
+)
+
+
+class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
+            self.first_x_channel = epics_signal_rw(int, prefix + "MinX")
+            self.first_y_channel = epics_signal_rw(int, prefix + "MinY")
+            self.x_channel_size = epics_signal_rw(int, prefix + "SizeX")
+            self.y_channel_size = epics_signal_rw(int, prefix + "SizeY")
+            self.detector_mode = epics_signal_rw(DetectorMode, prefix + "DETECTOR_MODE")
+            self.image_mode = epics_signal_rw(str, prefix + "ImageMode")
+
+        super().__init__(prefix, name)
+
+    @property
+    def pass_energy_type(self) -> type:
+        return str

dodal/devices/electron_analyser/vgscienta_region.py

@@ -0,0 +1,90 @@
+import uuid
+from enum import Enum
+
+from ophyd_async.core import StrictEnum
+from pydantic import Field
+
+from dodal.devices.electron_analyser.abstract_region import (
+    AbstractBaseRegion,
+    AbstractBaseSequence,
+    JavaToPythonModel,
+)
+
+
+class Status(str, Enum):
+    READY = "Ready"
+    RUNNING = "Running"
+    COMPLETED = "Completed"
+    INVALID = "Invalid"
+    ABORTED = "Aborted"
+
+
+class DetectorMode(StrictEnum):
+    ADC = "ADC"
+    PULSE_COUNTING = "Pulse Counting"
+
+
+class AcquisitionMode(str, Enum):
+    SWEPT = "Swept"
+    FIXED = "Fixed"
+
+
+class VGScientaRegion(AbstractBaseRegion):
+    # Override defaults of base region class
+    lens_mode: str = "Angular45"
+    pass_energy: int = 5
+    acquisition_mode: str = AcquisitionMode.SWEPT
+    low_energy: float = 8.0
+    high_energy: float = 10.0
+    step_time: float = 1.0
+    energy_step: float = Field(default=200.0)
+    # Specific to this class
+    id: str = Field(default=str(uuid.uuid4()), alias="region_id")
+    excitation_energy_source: str = "source1"
+    fix_energy: float = 9.0
+    total_steps: float = 13.0
+    total_time: float = 13.0
+    exposure_time: float = 1.0
+    first_x_channel: int = 1
+    last_x_channel: int = 1000
+    first_y_channel: int = 101
+    last_y_channel: int = 800
+    detector_mode: DetectorMode = DetectorMode.ADC
+    status: Status = Status.READY
+
+    def x_channel_size(self) -> int:
+        return self.last_x_channel - self.first_x_channel + 1
+
+    def y_channel_size(self) -> int:
+        return self.last_y_channel - self.first_y_channel + 1
+
+
+class VGScientaExcitationEnergySource(JavaToPythonModel):
+    name: str = "source1"
+    device_name: str = Field(default="", alias="scannable_name")
+    value: float = 0
+
+
+class VGScientaSequence(AbstractBaseSequence[VGScientaRegion]):
+    element_set: str = Field(default="Unknown")
+    excitation_energy_sources: list[VGScientaExcitationEnergySource] = Field(
+        default_factory=lambda: []
+    )
+    regions: list[VGScientaRegion] = Field(default_factory=lambda: [])
+
+    def get_excitation_energy_source_by_region(
+        self, region: VGScientaRegion
+    ) -> VGScientaExcitationEnergySource:
+        value = next(
+            (
+                e
+                for e in self.excitation_energy_sources
+                if region.excitation_energy_source == e.name
+            ),
+            None,
+        )
+        if value is None:
+            raise ValueError(
+                f'Unable to find excitation energy source using region "{region.name}"'
+            )
+        return value