dls-dodal 1.68.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

dodal/devices/{b16 → beamlines/b16}/detector.py

@@ -10,10 +10,9 @@ from dodal.devices.controllers import ConstantDeadTimeController
 
 
 def software_triggered_tiff_area_detector(prefix: str, deadtime: float = 0.0):
-    """
-    Wrapper for AreaDetector with fixed dead time (defaulted to 0)
+    """Wrapper for AreaDetector with fixed dead time (defaulted to 0)
     and a TIFF file writer.
-    Most detectors in B16 could be configured like this
+    Most detectors in B16 could be configured like this.
     """
     return AreaDetector(
         writer=ADTIFFWriter.with_io(

dodal/devices/{i02_1 → beamlines/i02_1}/fast_grid_scan.py

@@ -11,8 +11,7 @@ from dodal.log import LOGGER
 
 
 class ZebraGridScanParamsTwoD(GridScanParamsCommon, WithDwellTime):
-    """
-    Params for 2D Zebra FGS. Adds on the dwell time, which is really the time
+    """Params for 2D Zebra FGS. Adds on the dwell time, which is really the time
     between trigger positions.
     """
 
@@ -23,7 +22,7 @@ class ZebraFastGridScanTwoD(FastGridScanCommon[ZebraGridScanParamsTwoD]):
     - No Z steps, Z step sizes, or Y2 start positions, or Z2 start
     - No scan valid PV - see https://github.com/DiamondLightSource/mx-bluesky/issues/1203
     - No program_number - see https://github.com/DiamondLightSource/mx-bluesky/issues/1203
-    """
+    """  # noqa D415
 
     def __init__(
         self, prefix: str, motion_controller_prefix: str, name: str = ""

dodal/devices/{i02_1 → beamlines/i02_1}/sample_motors.py

@@ -3,7 +3,7 @@ from ophyd_async.epics.motor import Motor
 
 
 class SampleMotors(StandardReadable):
-    """Virtual Smaract motors on i02-1 (VMXm)"""
+    """Virtual Smaract motors on i02-1 (VMXm)."""
 
     def __init__(
         self,

dodal/devices/{i03 → beamlines/i03}/beamsize.py

@@ -1,11 +1,15 @@
 from ophyd_async.core import Reference, derived_signal_r
 
 from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.beamlines.i03.constants import BeamsizeConstants
 from dodal.devices.beamsize.beamsize import BeamsizeBase
-from dodal.devices.i03.constants import BeamsizeConstants
 
 
 class Beamsize(BeamsizeBase):
+    """Device that calculates the size of the beam by taking the minimum of the beam
+    dimensions and the aperture scatterguard diameter.
+    """
+
     def __init__(self, aperture_scatterguard: ApertureScatterguard, name=""):
         super().__init__(name=name)
         self._aperture_scatterguard_ref = Reference(aperture_scatterguard)
@@ -13,23 +17,23 @@ class Beamsize(BeamsizeBase):
         with self.add_children_as_readables():
             self.x_um = derived_signal_r(
                 self._get_beamsize_x,
-                aperture_radius=self._aperture_scatterguard_ref().radius,
+                aperture_diameter=self._aperture_scatterguard_ref().diameter,
                 derived_units="µm",
             )
             self.y_um = derived_signal_r(
                 self._get_beamsize_y,
-                aperture_radius=self._aperture_scatterguard_ref().radius,
+                aperture_diameter=self._aperture_scatterguard_ref().diameter,
                 derived_units="µm",
             )
 
     def _get_beamsize_x(
         self,
-        aperture_radius: float,
+        aperture_diameter: float,
     ) -> float:
-        return min(aperture_radius, BeamsizeConstants.BEAM_WIDTH_UM)
+        return min(aperture_diameter, BeamsizeConstants.BEAM_WIDTH_UM)
 
     def _get_beamsize_y(
         self,
-        aperture_radius: float,
+        aperture_diameter: float,
     ) -> float:
-        return min(aperture_radius, BeamsizeConstants.BEAM_HEIGHT_UM)
+        return min(aperture_diameter, BeamsizeConstants.BEAM_HEIGHT_UM)

dodal/devices/{i03 → beamlines/i03}/dcm.py

@@ -18,8 +18,7 @@ from dodal.devices.common_dcm import (
 class DCM(
     DoubleCrystalMonochromatorWithDSpacing[PitchAndRollCrystal, StationaryCrystal]
 ):
-    """
-    A double crystal monochromator (DCM), used to select the energy of the beam.
+    """A double crystal monochromator (DCM), used to select the energy of the beam.
 
     perp describes the gap between the 2 DCM crystals which has to change as you alter
     the angle to select the requested energy.

dodal/devices/{i03 → beamlines/i03}/undulator_dcm.py

@@ -4,7 +4,7 @@ from bluesky.protocols import Movable
 from ophyd_async.core import AsyncStatus, Reference, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
-from dodal.devices.i03.dcm import DCM
+from dodal.devices.beamlines.i03.dcm import DCM
 from dodal.devices.undulator import UndulatorInKeV
 from dodal.log import LOGGER
 
@@ -12,9 +12,8 @@ ENERGY_TIMEOUT_S: float = 30.0
 
 
 class UndulatorDCM(StandardReadable, Movable[float]):
-    """
-    Composite device to handle changing beamline energies, wraps the Undulator and the
-    DCM. The DCM has a motor which controls the beam energy, when it moves, the
+    """Composite device to handle changing beamline energies, wraps the Undulator and
+    the DCM. The DCM has a motor which controls the beam energy, when it moves, the
     Undulator gap may also have to change to enable emission at the new energy.
     The relationship between the two motor motor positions is provided via a lookup
     table.
@@ -24,7 +23,7 @@ class UndulatorDCM(StandardReadable, Movable[float]):
     a comprehensive way to set beam energy.
 
     This class will be removed in the future. Use the separate Undulator and DCM devices
-    instead. See https://github.com/DiamondLightSource/dodal/issues/1092
+    instead. See https://github.com/DiamondLightSource/dodal/issues/1092.
     """
 
     DCM_PERP_TOLERANCE = 0.01

dodal/devices/beamlines/i04/beam_centre.py

@@ -0,0 +1,151 @@
+import math
+
+import cv2
+import numpy as np
+from bluesky.protocols import Triggerable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+from ophyd_async.epics.core import (
+    epics_signal_r,
+)
+
+from dodal.devices.oav.utils import convert_to_gray_and_blur
+from dodal.log import LOGGER
+
+# Constant was chosen from trial and error with test images
+ADDITIONAL_BINARY_THRESH = 20
+
+
+def convert_image_to_binary(image: np.ndarray):
+    """Creates a binary image from OAV image array data.
+
+    Pixels of the input image are converted to one of two values (a high and a low value).
+    Otsu's method is used for automatic thresholding.
+    See https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html.
+    The threshold is increased by ADDITIONAL_BINARY_THRESH in order to get more of
+    the centre of the beam.
+    """
+    max_pixel_value = 255
+
+    blurred_image = convert_to_gray_and_blur(image)
+
+    threshold_value, _ = cv2.threshold(
+        blurred_image, 0, max_pixel_value, cv2.THRESH_BINARY + cv2.THRESH_OTSU
+    )
+
+    # Adjusting because the inner beam is less noisy compared to the outer
+    threshold_value += ADDITIONAL_BINARY_THRESH
+
+    _, thresholded_image = cv2.threshold(
+        blurred_image, threshold_value, max_pixel_value, cv2.THRESH_BINARY
+    )
+
+    LOGGER.info(f"Image binarised with threshold of {threshold_value}")
+    return thresholded_image
+
+
+def round_half_up(x):
+    return int(math.floor(x + 0.5))
+
+
+def get_roi(
+    image_arr: np.ndarray,
+    centre_x: int,
+    centre_y: int,
+    box_width: int = 200,
+    box_height: int = 200,
+) -> tuple[np.ndarray, tuple[int, int], tuple[int, int]]:
+    """Creates an ROI image array from a full screen image array, given a centre for the
+    ROI image and a width and height of the ROI box. Note that if the centre of the ROI
+    box is close to the edge of the full screen image, the box may be smaller than the
+    width and height provided, as the ROI will be trimmed to fit inside the full screen
+    image.
+
+    Args:
+        image_arr (np.ndarray): The full screen image array.
+        centre_x (int): The x coordinate of the centre of the ROI box.
+        centre_y (int): The y coordinate of the centre of the ROI box.
+        box_width (int, optional): The width of the ROI box. Defaults to 200.
+        box_height (int, optional): The height of the ROI box. Defaults to 200.
+
+    Returns:
+        tuple[np.ndarray, tuple[int, int], tuple[int, int]]: The ROI array, and (x, y)
+            coordinates of the top left and bottom right corners of the ROI box.
+    """
+    height, width = image_arr.shape[:2]
+    x_dist = (box_width) / 2
+    y_dist = (box_height) / 2
+
+    # Clip coordinates to stay within bounds
+    x_min = max(round_half_up(centre_x - x_dist), 0)
+    x_max = min(round_half_up(centre_x + x_dist), width) - 1
+    y_min = max(round_half_up(centre_y - y_dist), 0)
+    y_max = min(round_half_up(centre_y + y_dist), height) - 1
+
+    roi_arr = image_arr[y_min : y_max + 1, x_min : x_max + 1]
+
+    return roi_arr, (x_min, y_min), (x_max, y_max)
+
+
+class CentreEllipseMethod(StandardReadable, Triggerable):
+    """Upon triggering, fits an ellipse to a binary image from the area detector defined
+    by the prefix.
+
+    This is used, in conjunction with a scintillator, to determine the centre of the
+    beam on the image.
+    """
+
+    def __init__(self, prefix: str, overlay_channel: int = 1, name: str = ""):
+        self.oav_array_signal = epics_signal_r(np.ndarray, f"pva://{prefix}PVA:ARRAY")
+
+        self.center_x_val, self._center_x_val_setter = soft_signal_r_and_setter(float)
+        self.center_y_val, self._center_y_val_setter = soft_signal_r_and_setter(float)
+
+        self.current_centre_x = epics_signal_r(
+            int, f"{prefix}OVER:{overlay_channel}:CenterX"
+        )
+        self.current_centre_y = epics_signal_r(
+            int, f"{prefix}OVER:{overlay_channel}:CenterY"
+        )
+
+        self.roi_box_size = soft_signal_rw(int, 300)
+
+        super().__init__(name)
+
+    def _fit_ellipse(self, binary_img: cv2.typing.MatLike) -> cv2.typing.RotatedRect:
+        contours, _ = cv2.findContours(
+            binary_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE
+        )
+        if not contours:
+            raise ValueError("No contours found in image.")
+
+        largest_contour = max(contours, key=cv2.contourArea)
+        if len(largest_contour) < 5:
+            raise ValueError(
+                f"Not enough points to fit an ellipse. Found {largest_contour} points and need at least 5."
+            )
+
+        return cv2.fitEllipse(largest_contour)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        array_data = await self.oav_array_signal.get_value()
+        current_x = await self.current_centre_x.get_value()
+        current_y = await self.current_centre_y.get_value()
+        roi_box_size = await self.roi_box_size.get_value()
+
+        roi_data, top_left_corner, _ = get_roi(
+            array_data, current_x, current_y, roi_box_size, roi_box_size
+        )
+
+        roi_binary = convert_image_to_binary(roi_data)
+        ellipse_fit = self._fit_ellipse(roi_binary)
+        roi_centre_x = ellipse_fit[0][0]
+        roi_centre_y = ellipse_fit[0][1]
+        # convert back to full screen image coords and set beam centre
+        self._center_x_val_setter(roi_centre_x + top_left_corner[0])
+        self._center_y_val_setter(roi_centre_y + top_left_corner[1])

dodal/devices/{i04 → beamlines/i04}/beamsize.py

@@ -1,11 +1,15 @@
 from ophyd_async.core import Reference, derived_signal_r
 
 from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.beamlines.i04.transfocator import Transfocator
 from dodal.devices.beamsize.beamsize import BeamsizeBase
-from dodal.devices.i04.transfocator import Transfocator
 
 
 class Beamsize(BeamsizeBase):
+    """Device that calculates the size of the beam by taking the minimum of the
+    transfocator size and the aperture scatterguard diameter.
+    """
+
     def __init__(
         self,
         transfocator: Transfocator,
@@ -20,26 +24,26 @@ class Beamsize(BeamsizeBase):
             self.x_um = derived_signal_r(
                 self._get_beamsize_x,
                 transfocator_size_x=self._transfocator_ref().current_horizontal_size_rbv,
-                aperture_radius=self._aperture_scatterguard_ref().radius,
+                aperture_diameter=self._aperture_scatterguard_ref().diameter,
                 derived_units="µm",
             )
             self.y_um = derived_signal_r(
                 self._get_beamsize_y,
                 transfocator_size_y=self._transfocator_ref().current_vertical_size_rbv,
-                aperture_radius=self._aperture_scatterguard_ref().radius,
+                aperture_diameter=self._aperture_scatterguard_ref().diameter,
                 derived_units="µm",
             )
 
     def _get_beamsize_x(
         self,
         transfocator_size_x: float,
-        aperture_radius: float,
+        aperture_diameter: float,
     ) -> float:
-        return min(transfocator_size_x, aperture_radius)
+        return min(transfocator_size_x, aperture_diameter)
 
     def _get_beamsize_y(
         self,
         transfocator_size_y: float,
-        aperture_radius: float,
+        aperture_diameter: float,
     ) -> float:
-        return min(transfocator_size_y, aperture_radius)
+        return min(transfocator_size_y, aperture_diameter)

dodal/devices/beamlines/i04/max_pixel.py

@@ -0,0 +1,25 @@
+import numpy as np
+from bluesky.protocols import Triggerable
+from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_r_and_setter
+from ophyd_async.epics.core import (
+    epics_signal_r,
+)
+
+from dodal.devices.oav.utils import convert_to_gray_and_blur
+
+
+class MaxPixel(StandardReadable, Triggerable):
+    """Gets the max pixel (brightest pixel) from the image after some image processing."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.array_data = epics_signal_r(np.ndarray, f"pva://{prefix}PVA:ARRAY")
+        self.max_pixel_val, self._max_val_setter = soft_signal_r_and_setter(float)
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        img_data = await self.array_data.get_value()
+        arr = convert_to_gray_and_blur(img_data)
+        max_val = float(np.max(arr))
+        assert isinstance(max_val, float)
+        self._max_val_setter(max_val)

dodal/devices/{i04 → beamlines/i04}/murko_results.py

@@ -13,9 +13,9 @@ from ophyd_async.core import (
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
-from redis.asyncio import StrictRedis
+from redis.asyncio import ConnectionError, StrictRedis
 
-from dodal.devices.i04.constants import RedisConstants
+from dodal.devices.beamlines.i04.constants import RedisConstants
 from dodal.devices.oav.oav_calculations import (
     calculate_beam_distance,
 )
@@ -103,13 +103,25 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
             self.z_mm, self._z_mm_setter = soft_signal_r_and_setter(float)
         super().__init__(name=name)
 
+    async def _check_redis_connection(self):
+        try:
+            await self.redis_client.ping()  # type: ignore
+            return True
+        except ConnectionError:
+            LOGGER.warning(
+                f"Failed to connect to redis: {self.redis_client}. Murko results device will not trigger"
+            )
+            return False
+
     def _reset(self):
         self._last_omega = None
         self._results: list[MurkoResult] = []
 
     @AsyncStatus.wrap
     async def stage(self):
-        await self.pubsub.subscribe("murko-results")
+        self.redis_connected = await self._check_redis_connection()
+        if self.redis_connected:
+            await self.pubsub.subscribe("murko-results")
         self._x_mm_setter(0)
         self._y_mm_setter(0)
         self._z_mm_setter(0)
@@ -117,10 +129,13 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
     @AsyncStatus.wrap
     async def unstage(self):
         self._reset()
-        await self.pubsub.unsubscribe()
+        if self.redis_connected:
+            await self.pubsub.unsubscribe()
 
     @AsyncStatus.wrap
     async def trigger(self):
+        if not self.redis_connected:
+            return
         sample_id = await self.sample_id.get_value()
         t_last_result = time.time()
         while True:
@@ -223,7 +238,6 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         remove many of the outliers. Murko also occasionally picks a point in the bottom
         left corner, which can be removed by filtering results with a small x pixel.
         """
-
         LOGGER.info(f"Number of results before filtering: {len(self._results)}")
         sorted_results = sorted(self._results, key=lambda item: item.chosen_point_px[0])
 
@@ -263,15 +277,16 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
 
 
 def get_yz_least_squares(vertical_dists: list, omegas: list) -> tuple[float, float]:
-    """Get the least squares solution for y and z from the vertical distances and omega angles.
+    """Get the least squares solution for y and z from the vertical distances and omega
+    angles.
 
     Args:
-        v_dists (list): List of vertical distances from beam centre. Any units
+        vertical_dists (list): List of vertical distances from beam centre. Any units.
         omegas (list): List of omega angles in degrees.
 
     Returns:
         tuple[float, float]: y, z distances from centre, in whichever units
-        v_dists came as.
+            v_dists came as.
     """
     thetas = np.radians(omegas)
     matrix = np.column_stack([np.cos(thetas), -np.sin(thetas)])

dodal/devices/{i04 → beamlines/i04}/transfocator.py

@@ -3,7 +3,6 @@ import asyncio
 from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
-    observe_value,
     wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
@@ -49,24 +48,20 @@ class Transfocator(StandardReadable):
     @AsyncStatus.wrap
     async def set(self, value: float):
         """To set the beamsize on the transfocator we must:
-        1. Set the beamsize in the calculator part of the transfocator
-        2. Get the predicted number of lenses needed from this calculator
-        3. Enter this back into the device
-        4. Start the device moving
-        5. Wait for the start_rbv goes high and low again
+        1. Set the beamsize in the calculator part of the transfocator.
+        2. Get the predicted number of lenses needed from this calculator.
+        3. Enter this back into the device.
+        4. Start the device moving.
+        5. Wait for the start_rbv goes high and low again.
         """
         LOGGER.info(f"Transfocator setting {value} beamsize")
 
-        # Logic in the IOC calculates _num_lenses_calc_rbv when _vert_size_calc_sp changes
-
-        # Register an observer before setting _vert_size_calc_sp to ensure we don't miss changes
-        num_lenses_calc_iterator = observe_value(
-            self._num_lenses_calc_rbv, timeout=self.TIMEOUT
-        )
-
-        await anext(num_lenses_calc_iterator)
         await self._vert_size_calc_sp.set(value)
-        calc_lenses = await anext(num_lenses_calc_iterator)
+        # Logic in the IOC calculates _num_lenses_calc_rbv when _vert_size_calc_sp changes,
+        # but this isn't instant so we need a short sleep until
+        # https://jira.diamond.ac.uk/browse/I04-1100
+        await asyncio.sleep(0.1)
+        calc_lenses = await self._num_lenses_calc_rbv.get_value()
 
         async with periodic_reminder(
             f"Waiting for transfocator to insert {calc_lenses} into beam"

dodal/devices/beamlines/i05/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.beamlines.i05.enums import Grating
+
+__all__ = ["Grating"]

dodal/devices/beamlines/i06_shared/__init__.py

@@ -0,0 +1,3 @@
+from .i06_enum import I06Grating
+
+__all__ = ["I06Grating"]

dodal/devices/beamlines/i06_shared/i06_enum.py

@@ -0,0 +1,7 @@
+from ophyd_async.core import StrictEnum
+
+
+class I06Grating(StrictEnum):
+    GRATING_150 = "150 lines/mm"
+    GRATING_400 = "400 lines/mm"
+    GRATING_1200 = "1200 lines/mm"

dodal/devices/{i07 → beamlines/i07}/dcm.py

@@ -9,9 +9,8 @@ from dodal.devices.common_dcm import (
 
 
 class DCM(DoubleCrystalMonochromator[PitchAndRollCrystal, StationaryCrystal]):
-    """
-    Device for i07's DCM, including temperature monitors and vertical motor which were
-    included in GDA.
+    """Device for i07's DCM, including temperature monitors and vertical motor which
+    were included in GDA.
     """
 
     def __init__(

dodal/devices/{i07 → beamlines/i07}/id.py

@@ -5,34 +5,33 @@ from dodal.devices.util.lookup_tables import energy_distance_table
 
 
 class InsertionDevice(UndulatorInKeV):
-    """
-    Insertion device for i07 including beamline-specific energy-gap lookup behaviour
+    """Insertion device for i07 including beamline-specific energy-gap lookup
+    behaviour.
     """
 
     def __init__(
         self,
-        name: str,
         prefix: str,
         harmonic: UndulatorOrder,
         id_gap_lookup_table_path: str = "/dls_sw/i07/software/gda/config/lookupTables/"
         + "IIDCalibrationTable.txt",
-    ) -> None:
+        name: str = "",
+    ):
         super().__init__(prefix, id_gap_lookup_table_path, name=name)
         self.harmonic = harmonic
 
     async def _get_gap_to_match_energy(self, energy_kev: float) -> float:
-        """
-        i07's energy scans remain on a particular harmonic while changing energy.  The
+        """i07's energy scans remain on a particular harmonic while changing energy. The
         calibration table has one row for each harmonic, row contains max and min
         energies and their corresponding ID gaps.  The requested energy is used to
         interpolate between these values, assuming a linear relationship on the relevant
         scale.
         """
-        energy_to_distance_table: np.ndarray = await energy_distance_table(
+        energy_to_distance_table = await energy_distance_table(
             self.id_gap_lookup_table_path, comments="#", skiprows=2
         )
-        harmonic_value: int = await self.harmonic.value.get_value()
+        harmonic_value = await self.harmonic.value.get_value()
 
-        row: np.ndarray = energy_to_distance_table[harmonic_value - 1, :]
+        row = energy_to_distance_table[harmonic_value - 1, :]
         gap = np.interp(energy_kev, [row[1], row[2]], [row[3], row[4]])
         return gap

dodal/devices/beamlines/i09/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.beamlines.i09.enums import Grating, LensMode, PassEnergy, PsuMode
+
+__all__ = ["Grating", "LensMode", "PsuMode", "PassEnergy"]

dodal/devices/{i09_1_shared → beamlines/i09_1_shared}/hard_energy.py

@@ -12,17 +12,16 @@ from ophyd_async.core import (
     soft_signal_rw,
 )
 
-from dodal.devices.common_dcm import DoubleCrystalMonochromatorBase
-from dodal.devices.i09_1_shared.hard_undulator_functions import (
+from dodal.devices.beamlines.i09_1_shared.hard_undulator_functions import (
     MAX_ENERGY_COLUMN,
     MIN_ENERGY_COLUMN,
 )
+from dodal.devices.common_dcm import DoubleCrystalMonochromatorBase
 from dodal.devices.undulator import UndulatorInMm, UndulatorOrder
 
 
 class HardInsertionDeviceEnergy(StandardReadable, Movable[float]):
-    """
-    Compound device to link hard x-ray undulator gap and order to photon energy.
+    """Compound device to link hard x-ray undulator gap and order to photon energy.
     Setting the energy adjusts the undulator gap accordingly.
     """
 
@@ -83,8 +82,8 @@ class HardInsertionDeviceEnergy(StandardReadable, Movable[float]):
 
 
 class HardEnergy(StandardReadable, Locatable[float]):
-    """
-    Energy compound device that provides combined change of both DCM energy and undulator gap accordingly.
+    """Energy compound device that provides combined change of both DCM energy and
+    undulator gap accordingly.
     """
 
     def __init__(