dls-dodal 1.32.0__py3-none-any.whl → 1.34.1__py3-none-any.whl

dodal/devices/oav/snapshots/snapshot_with_beam_centre.py

@@ -0,0 +1,64 @@
+from ophyd_async.core import SignalR
+from PIL import Image, ImageDraw
+
+from dodal.devices.areadetector.plugins.MJPG import MJPG
+
+CROSSHAIR_LENGTH_PX = 20
+CROSSHAIR_OUTLINE_COLOUR = "Black"
+CROSSHAIR_FILL_COLOUR = "White"
+
+
+def draw_crosshair(image: Image.Image, beam_x: int, beam_y: int):
+    draw = ImageDraw.Draw(image)
+    OUTLINE_WIDTH = 1
+    HALF_LEN = CROSSHAIR_LENGTH_PX / 2
+    draw.rectangle(
+        [
+            beam_x - OUTLINE_WIDTH,
+            beam_y - HALF_LEN - OUTLINE_WIDTH,
+            beam_x + OUTLINE_WIDTH,
+            beam_y + HALF_LEN + OUTLINE_WIDTH,
+        ],
+        fill=CROSSHAIR_OUTLINE_COLOUR,
+    )
+    draw.rectangle(
+        [
+            beam_x - HALF_LEN - OUTLINE_WIDTH,
+            beam_y - OUTLINE_WIDTH,
+            beam_x + HALF_LEN + OUTLINE_WIDTH,
+            beam_y + OUTLINE_WIDTH,
+        ],
+        fill=CROSSHAIR_OUTLINE_COLOUR,
+    )
+    draw.line(
+        ((beam_x, beam_y - HALF_LEN), (beam_x, beam_y + HALF_LEN)),
+        fill=CROSSHAIR_FILL_COLOUR,
+    )
+    draw.line(
+        ((beam_x - HALF_LEN, beam_y), (beam_x + HALF_LEN, beam_y)),
+        fill=CROSSHAIR_FILL_COLOUR,
+    )
+
+
+class SnapshotWithBeamCentre(MJPG):
+    """A child of MJPG which, when triggered, draws an outlined crosshair at the beam
+    centre in the image and saves the image to disk."""
+
+    def __init__(
+        self,
+        prefix: str,
+        beam_x_signal: SignalR,
+        beam_y_signal: SignalR,
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.beam_centre_i = beam_x_signal
+            self.beam_centre_j = beam_y_signal
+        super().__init__(prefix, name)
+
+    async def post_processing(self, image: Image.Image):
+        beam_x = await self.beam_centre_i.get_value()
+        beam_y = await self.beam_centre_j.get_value()
+        draw_crosshair(image, beam_x, beam_y)
+
+        await self._save_image(image)

dodal/devices/oav/snapshots/snapshot_with_grid.py

@@ -0,0 +1,57 @@
+from os.path import join as path_join
+
+from ophyd_async.core import soft_signal_rw
+from PIL.Image import Image
+
+from dodal.devices.areadetector.plugins.MJPG import IMG_FORMAT, MJPG, asyncio_save_image
+from dodal.devices.oav.snapshots.grid_overlay import (
+    add_grid_border_overlay_to_image,
+    add_grid_overlay_to_image,
+)
+from dodal.log import LOGGER
+
+
+class SnapshotWithGrid(MJPG):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.top_left_x = soft_signal_rw(int)
+            self.top_left_y = soft_signal_rw(int)
+            self.box_width = soft_signal_rw(int)
+            self.num_boxes_x = soft_signal_rw(int)
+            self.num_boxes_y = soft_signal_rw(int)
+
+            self.last_path_outer = soft_signal_rw(str)
+            self.last_path_full_overlay = soft_signal_rw(str)
+
+        super().__init__(prefix, name)
+
+    async def post_processing(self, image: Image):
+        # Save an unmodified image with no suffix
+        await self._save_image(image)
+
+        top_left_x = await self.top_left_x.get_value()
+        top_left_y = await self.top_left_y.get_value()
+        box_witdh = await self.box_width.get_value()
+        num_boxes_x = await self.num_boxes_x.get_value()
+        num_boxes_y = await self.num_boxes_y.get_value()
+
+        assert isinstance(filename_str := await self.filename.get_value(), str)
+        assert isinstance(directory_str := await self.directory.get_value(), str)
+
+        add_grid_border_overlay_to_image(
+            image, top_left_x, top_left_y, box_witdh, num_boxes_x, num_boxes_y
+        )
+
+        path = path_join(directory_str, f"{filename_str}_outer_overlay.{IMG_FORMAT}")
+        await self.last_path_outer.set(path, wait=True)
+        LOGGER.info(f"Saving grid outer edge at {path}")
+        await asyncio_save_image(image, path)
+
+        add_grid_overlay_to_image(
+            image, top_left_x, top_left_y, box_witdh, num_boxes_x, num_boxes_y
+        )
+
+        path = path_join(directory_str, f"{filename_str}_grid_overlay.{IMG_FORMAT}")
+        await self.last_path_full_overlay.set(path, wait=True)
+        LOGGER.info(f"Saving full grid overlay at {path}")
+        await asyncio_save_image(image, path)

dodal/devices/oav/utils.py

@@ -5,8 +5,11 @@ import bluesky.plan_stubs as bps
 import numpy as np
 from bluesky.utils import Msg
 
-from dodal.devices.oav.oav_calculations import camera_coordinates_to_xyz
-from dodal.devices.oav.oav_detector import OAVConfigParams
+from dodal.devices.oav.oav_calculations import (
+    calculate_beam_distance,
+    camera_coordinates_to_xyz,
+)
+from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
 from dodal.devices.smargon import Smargon
 
@@ -36,21 +39,6 @@ def bottom_right_from_top_left(
     )
 
 
-class ColorMode(IntEnum):
-    """
-    Enum to store the various color modes of the camera. We use RGB1.
-    """
-
-    MONO = 0
-    BAYER = 1
-    RGB1 = 2
-    RGB2 = 3
-    RGB3 = 4
-    YUV444 = 5
-    YUV422 = 6
-    YUV421 = 7
-
-
 class EdgeOutputArrayImageType(IntEnum):
     """
     Enum to store the types of image to tweak the output array. We use Original.
@@ -64,7 +52,7 @@ class EdgeOutputArrayImageType(IntEnum):
 
 
 def get_move_required_so_that_beam_is_at_pixel(
-    smargon: Smargon, pixel: Pixel, oav_params: OAVConfigParams
+    smargon: Smargon, pixel: Pixel, oav: OAV
 ) -> Generator[Msg, None, np.ndarray]:
     """Calculate the required move so that the given pixel is in the centre of the beam."""
 
@@ -78,22 +66,35 @@ def get_move_required_so_that_beam_is_at_pixel(
     )
     current_angle = yield from bps.rd(smargon.omega)
 
-    return calculate_x_y_z_of_pixel(current_motor_xyz, current_angle, pixel, oav_params)
+    beam_x = yield from bps.rd(oav.beam_centre_i)
+    beam_y = yield from bps.rd(oav.beam_centre_j)
+    microns_per_pixel_x = yield from bps.rd(oav.microns_per_pixel_x)
+    microns_per_pixel_y = yield from bps.rd(oav.microns_per_pixel_y)
+
+    return calculate_x_y_z_of_pixel(
+        current_motor_xyz,
+        current_angle,
+        pixel,
+        (beam_x, beam_y),
+        (microns_per_pixel_x, microns_per_pixel_y),
+    )
 
 
 def calculate_x_y_z_of_pixel(
-    current_x_y_z, current_omega, pixel: Pixel, oav_params: OAVConfigParams
+    current_x_y_z,
+    current_omega,
+    pixel: Pixel,
+    beam_centre: tuple[int, int],
+    microns_per_pixel: tuple[float, float],
 ) -> np.ndarray:
-    beam_distance_px: Pixel = oav_params.calculate_beam_distance(*pixel)
+    beam_distance_px: Pixel = calculate_beam_distance(beam_centre, *pixel)
 
-    assert oav_params.micronsPerXPixel
-    assert oav_params.micronsPerYPixel
     return current_x_y_z + camera_coordinates_to_xyz(
         beam_distance_px[0],
         beam_distance_px[1],
         current_omega,
-        oav_params.micronsPerXPixel,
-        oav_params.micronsPerYPixel,
+        microns_per_pixel[0],
+        microns_per_pixel[1],
     )
 
 

dodal/devices/pgm.py

@@ -0,0 +1,41 @@
+from enum import Enum
+
+from ophyd_async.core import (
+    ConfigSignal,
+    StandardReadable,
+)
+from ophyd_async.epics.motor import Motor
+from ophyd_async.epics.signal import epics_signal_rw
+
+
+class PGM(StandardReadable):
+    """
+    Plane grating monochromator, it is use in soft x-ray beamline to generate monochromic beam.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        grating: type[Enum],
+        gratingPv: str,
+        name: str = "",
+    ) -> None:
+        """
+        Parameters
+        ----------
+        prefix:
+            Beamline specific part of the PV
+        grating:
+            The Enum for the grating table.
+        gratingPv:
+            The suffix pv part of grating Pv
+        name:
+            Name of the device
+        """
+        with self.add_children_as_readables():
+            self.energy = Motor(prefix + "ENERGY")
+        with self.add_children_as_readables(ConfigSignal):
+            self.grating = epics_signal_rw(grating, prefix + gratingPv)
+            self.cff = epics_signal_rw(float, prefix + "CFF")
+
+        super().__init__(name=name)

dodal/devices/qbpm.py

@@ -0,0 +1,18 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.signal import epics_signal_r
+
+
+class QBPM(StandardReadable):
+    """
+    A beam position monitor that gives a position and intensity of the beam.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.intensity_uA = epics_signal_r(float, f"{prefix}INTEN")
+
+        super().__init__(name)

dodal/devices/robot.py

@@ -63,8 +63,8 @@ class BartRobot(StandardReadable, Movable):
         self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
         self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
 
-        self.next_sample_id = epics_signal_rw_rbv(float, prefix + "NEXT_ID")
-        self.sample_id = epics_signal_r(float, prefix + "CURRENT_ID_RBV")
+        self.next_sample_id = epics_signal_rw_rbv(int, prefix + "NEXT_ID")
+        self.sample_id = epics_signal_r(int, prefix + "CURRENT_ID_RBV")
 
         self.load = epics_signal_x(prefix + "LOAD.PROC")
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")

dodal/devices/smargon.py

@@ -40,8 +40,8 @@ class StubOffsets(Device):
         super().__init__(name)
 
     @AsyncStatus.wrap
-    async def set(self, pos: StubPosition):
-        if pos == StubPosition.CURRENT_AS_CENTER:
+    async def set(self, value: StubPosition):
+        if value == StubPosition.CURRENT_AS_CENTER:
             await self.center_at_current_position.set(1)
             smargon = cast(Smargon, self.parent)
             await wait_for_value(

dodal/devices/tetramm.py

@@ -4,7 +4,7 @@ from enum import Enum
 from bluesky.protocols import Hints
 from ophyd_async.core import (
     DatasetDescriber,
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
     Device,
     PathProvider,
@@ -80,7 +80,7 @@ class TetrammDriver(Device):
         super().__init__(name=name)
 
 
-class TetrammController(DetectorControl):
+class TetrammController(DetectorController):
     """Controller for a TetrAMM current monitor
 
     Attributes:

dodal/devices/undulator.py

@@ -1,3 +1,4 @@
+import os
 from enum import Enum
 
 import numpy as np
@@ -54,7 +55,7 @@ class Undulator(StandardReadable, Movable):
     def __init__(
         self,
         prefix: str,
-        id_gap_lookup_table_path: str,
+        id_gap_lookup_table_path: str = os.devnull,
         name: str = "",
         poles: int | None = None,
         length: float | None = None,

dodal/devices/util/adjuster_plans.py

@@ -21,6 +21,6 @@ def lookup_table_adjuster(
     def adjust(group=None) -> Generator[Msg, None, None]:
         setpoint = lookup_table(input)
         LOGGER.info(f"lookup_table_adjuster setting {output_device.name} to {setpoint}")
-        yield from bps.abs_set(output_device, setpoint, group=group)
+        yield from bps.abs_set(output_device, setpoint, group=group)  # type: ignore # See: https://github.com/DiamondLightSource/dodal/issues/827
 
     return adjust

dodal/devices/util/lookup_tables.py

@@ -33,7 +33,10 @@ async def energy_distance_table(lookup_table_path: str) -> np.ndarray:
 
 
 def linear_interpolation_lut(filename: str) -> Callable[[float], float]:
-    """Returns a callable that converts values by linear interpolation of lookup table values"""
+    """Returns a callable that converts values by linear interpolation of lookup table
+    values.
+
+    If the value falls outside the lookup table then the closest value will be used."""
     LOGGER.info(f"Using lookup table {filename}")
     s_and_t_vals = zip(*loadtxt(filename, comments=["#", "Units"]), strict=False)
 
@@ -54,10 +57,6 @@ def linear_interpolation_lut(filename: str) -> Callable[[float], float]:
             )
 
     def s_to_t2(s: float) -> float:
-        if s < s_values[0] or s > s_values[len(s_values) - 1]:
-            raise ValueError(
-                f"Lookup table does not support extrapolation from file {filename}, s={s}"
-            )
         return float(interp(s, s_values, t_values))
 
     return s_to_t2

dodal/devices/zebra.py

@@ -13,6 +13,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
+# These constants refer to I03's Zebra. See https://github.com/DiamondLightSource/dodal/issues/772
 # Sources
 DISCONNECT = 0
 IN1_TTL = 1
@@ -39,8 +40,10 @@ TTL_PANDA = 4
 
 # The AND gate that controls the automatic shutter
 AUTO_SHUTTER_GATE = 2
-# The input that triggers the automatic shutter
-AUTO_SHUTTER_INPUT = 1
+
+# The first two inputs of the auto shutter gate.
+AUTO_SHUTTER_INPUT_1 = 1
+AUTO_SHUTTER_INPUT_2 = 2
 
 
 class ArmSource(str, Enum):

dodal/devices/zocalo/zocalo_results.py

@@ -229,16 +229,19 @@ class ZocaloResults(StandardReadable, Triggerable):
                     source_of_second_results = source_from_results(
                         raw_results_two_sources[1]
                     )
-
-                    # Compare results from both sources and warn if they aren't the same
-                    differences_str = get_dict_differences(
-                        raw_results_two_sources[0]["results"][0],
-                        source_of_first_results,
-                        raw_results_two_sources[1]["results"][0],
-                        source_of_second_results,
-                    )
-                    if differences_str:
-                        LOGGER.warning(differences_str)
+                    first_results = raw_results_two_sources[0]["results"]
+                    second_results = raw_results_two_sources[1]["results"]
+
+                    if first_results and second_results:
+                        # Compare results from both sources and warn if they aren't the same
+                        differences_str = get_dict_differences(
+                            first_results[0],
+                            source_of_first_results,
+                            second_results[0],
+                            source_of_second_results,
+                        )
+                        if differences_str:
+                            LOGGER.warning(differences_str)
 
                     # Always use CPU results
                     raw_results = (

dodal/plans/data_session_metadata.py

@@ -1,9 +1,9 @@
 from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
-from bluesky.utils import make_decorator
+from bluesky.utils import MsgGenerator, make_decorator
 
 from dodal.common.beamlines import beamline_utils
-from dodal.common.types import MsgGenerator, UpdatingPathProvider
+from dodal.common.types import UpdatingPathProvider
 
 DATA_SESSION = "data_session"
 DATA_GROUPS = "data_groups"

dodal/plans/motor_util_plans.py

@@ -1,21 +1,21 @@
 import uuid
 from collections.abc import Generator
-from typing import Any, TypeVar
+from typing import Any, TypeVar, cast
 
 from bluesky import plan_stubs as bps
 from bluesky.preprocessors import finalize_wrapper, pchain
-from bluesky.utils import Msg, make_decorator
+from bluesky.utils import Msg, MsgGenerator, make_decorator
 from ophyd_async.core import Device
 from ophyd_async.epics.motor import Motor
 
-from dodal.common import MsgGenerator
+from dodal.utils import MovableReadable
 
-AnyDevice = TypeVar("AnyDevice", bound=Device)
+MovableReadableDevice = TypeVar("MovableReadableDevice", bound=MovableReadable)
 
 
 class MoveTooLarge(Exception):
     def __init__(
-        self, axis: Device, maximum_move: float, position: float, *args: object
+        self, axis: MovableReadable, maximum_move: float, position: float, *args: object
     ) -> None:
         self.axis = axis
         self.maximum_move = maximum_move
@@ -24,10 +24,10 @@ class MoveTooLarge(Exception):
 
 
 def _check_and_cache_values(
-    devices_and_positions: dict[AnyDevice, float],
+    devices_and_positions: dict[MovableReadableDevice, float],
     smallest_move: float,
     maximum_move: float,
-) -> Generator[Msg, Any, dict[AnyDevice, float]]:
+) -> Generator[Msg, Any, dict[MovableReadableDevice, float]]:
     """Caches the positions of all Motors on specified device if they are within
     smallest_move of home_position. Throws MoveTooLarge if they are outside maximum_move
     of the home_position
@@ -51,7 +51,9 @@ def home_and_reset_wrapper(
     wait_for_all: bool = True,
 ) -> MsgGenerator:
     home_positions = {
-        axis: 0.0 for _, axis in device.children() if isinstance(axis, Motor)
+        cast(MovableReadable, axis): 0.0
+        for _, axis in device.children()
+        if isinstance(axis, Motor)
     }
     return move_and_reset_wrapper(
         plan, home_positions, smallest_move, maximum_move, group, wait_for_all
@@ -60,7 +62,7 @@ def home_and_reset_wrapper(
 
 def move_and_reset_wrapper(
     plan: MsgGenerator,
-    device_and_positions: dict[AnyDevice, float],
+    device_and_positions: dict[MovableReadable, float],
     smallest_move: float,
     maximum_move: float,
     group: str | None = None,

dodal/utils.py

@@ -13,8 +13,10 @@ from os import environ
 from types import ModuleType
 from typing import (
     Any,
+    Protocol,
     TypeGuard,
     TypeVar,
+    runtime_checkable,
 )
 
 from bluesky.protocols import (
@@ -62,6 +64,11 @@ BLUESKY_PROTOCOLS = [
     Triggerable,
 ]
 
+
+@runtime_checkable
+class MovableReadable(Movable, Readable, Protocol): ...
+
+
 AnyDevice: TypeAlias = OphydV1Device | OphydV2Device
 V1DeviceFactory: TypeAlias = Callable[..., OphydV1Device]
 V2DeviceFactory: TypeAlias = Callable[..., OphydV2Device]

dodal/beamlines/i04_1.py

@@ -1,140 +0,0 @@
-from dodal.common.beamlines.beamline_utils import device_instantiation
-from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.devices.backlight import Backlight
-from dodal.devices.detector import DetectorParams
-from dodal.devices.eiger import EigerDetector
-from dodal.devices.oav.oav_detector import OAV, OAVConfigParams
-from dodal.devices.s4_slit_gaps import S4SlitGaps
-from dodal.devices.synchrotron import Synchrotron
-from dodal.devices.undulator import Undulator
-from dodal.devices.zebra import Zebra
-from dodal.log import set_beamline as set_log_beamline
-from dodal.utils import BeamlinePrefix, get_beamline_name, skip_device
-
-ZOOM_PARAMS_FILE = "/dls_sw/i04-1/software/gda/config/xml/jCameraManZoomLevels.xml"
-DISPLAY_CONFIG = "/dls_sw/i04-1/software/gda_versions/var/display.configuration"
-
-_simulator_beamline_fallback = "s04_1"
-BL = get_beamline_name(_simulator_beamline_fallback)
-set_log_beamline(BL)
-set_utils_beamline(BL)
-
-
-def _check_for_simulation():
-    return BL == _simulator_beamline_fallback
-
-
-def backlight(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> Backlight:
-    """Get the i04_1 backlight device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i04_1, it will return the existing object.
-    """
-    return device_instantiation(
-        device_factory=Backlight,
-        name="backlight",
-        prefix="",
-        wait=wait_for_connection,
-        fake=fake_with_ophyd_sim,
-    )
-
-
-@skip_device(_check_for_simulation)
-def eiger(
-    wait_for_connection: bool = True,
-    fake_with_ophyd_sim: bool = False,
-    params: DetectorParams | None = None,
-) -> EigerDetector:
-    """Get the i04_1 Eiger device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i04_1, it will return the existing object.
-    If called with params, will update those params to the Eiger object.
-    """
-
-    def set_params(eiger: EigerDetector):
-        if params is not None:
-            eiger.set_detector_parameters(params)
-
-    return device_instantiation(
-        device_factory=EigerDetector,
-        name="eiger",
-        prefix="-EA-EIGER-01:",
-        wait=wait_for_connection,
-        fake=fake_with_ophyd_sim,
-        post_create=set_params,
-    )
-
-
-@skip_device(_check_for_simulation)
-def oav(wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False) -> OAV:
-    """Get the i04_1 OAV device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i04_1, it will return the existing object.
-    """
-    return device_instantiation(
-        OAV,
-        "oav",
-        "",
-        wait_for_connection,
-        fake_with_ophyd_sim,
-        params=OAVConfigParams(ZOOM_PARAMS_FILE, DISPLAY_CONFIG),
-    )
-
-
-def s4_slit_gaps(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> S4SlitGaps:
-    """Get the i04_1 s4_slit_gaps device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i04_1, it will return the existing object.
-    """
-    return device_instantiation(
-        S4SlitGaps,
-        "s4_slit_gaps",
-        "-AL-SLITS-04:",
-        wait_for_connection,
-        fake_with_ophyd_sim,
-    )
-
-
-@skip_device(_check_for_simulation)
-def synchrotron(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> Synchrotron:
-    """Get the i04_1 synchrotron device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i04_1, it will return the existing object.
-    """
-    return device_instantiation(
-        Synchrotron,
-        "synchrotron",
-        "",
-        wait_for_connection,
-        fake_with_ophyd_sim,
-        bl_prefix=False,
-    )
-
-
-def undulator(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> Undulator:
-    """Get the i04_1 undulator device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i04_1, it will return the existing object.
-    """
-    return device_instantiation(
-        Undulator,
-        "undulator",
-        f"{BeamlinePrefix(BL).insertion_prefix}-MO-SERVC-01:",
-        wait_for_connection,
-        fake_with_ophyd_sim,
-        bl_prefix=False,
-    )
-
-
-def zebra(wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False) -> Zebra:
-    """Get the i04_1 zebra device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i04_1, it will return the existing object.
-    """
-    return device_instantiation(
-        Zebra,
-        "zebra",
-        "-EA-ZEBRA-01:",
-        wait_for_connection,
-        fake_with_ophyd_sim,
-    )