dls-dodal 1.47.0__py3-none-any.whl → 1.48.0__py3-none-any.whl

dodal/devices/electron_analyser/abstract/base_detector.py

@@ -2,21 +2,19 @@ import asyncio
 from abc import abstractmethod
 from typing import Generic, TypeVar
 
-from bluesky.protocols import (
-    Reading,
-    Stageable,
-    Triggerable,
-)
+from bluesky.protocols import Preparable, Reading, Stageable, Triggerable
 from event_model import DataKey
 from ophyd_async.core import (
+    AsyncConfigurable,
+    AsyncReadable,
     AsyncStatus,
     Device,
     Reference,
 )
-from ophyd_async.core._protocol import AsyncConfigurable, AsyncReadable
 from ophyd_async.epics.adcore import (
     ADBaseController,
 )
+from ophyd_async.epics.motor import Motor
 
 from dodal.common.data_util import load_json_file_to_class
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
@@ -29,12 +27,12 @@ from dodal.devices.electron_analyser.abstract.base_region import (
 )
 
 
-class AnalyserController(ADBaseController[AbstractAnalyserDriverIO]):
+class ElectronAnalyserController(ADBaseController[AbstractAnalyserDriverIO]):
     def get_deadtime(self, exposure: float | None) -> float:
         return 0
 
 
-class BaseElectronAnalyserDetector(
+class AbstractElectronAnalyserDetector(
     Device,
     Stageable,
     Triggerable,
@@ -46,7 +44,7 @@ class BaseElectronAnalyserDetector(
     Detector for data acquisition of electron analyser. Can only acquire using settings
     already configured for the device.
 
-    If possible, this should be changed to inheirt from a StandardDetector. Currently,
+    If possible, this should be changed to inherit from a StandardDetector. Currently,
     StandardDetector forces you to use a file writer which doesn't apply here.
     See issue https://github.com/bluesky/ophyd-async/issues/888
     """
@@ -56,7 +54,9 @@ class BaseElectronAnalyserDetector(
         name: str,
         driver: TAbstractAnalyserDriverIO,
     ):
-        self.controller: AnalyserController = AnalyserController(driver=driver)
+        self.controller: ElectronAnalyserController = ElectronAnalyserController(
+            driver=driver
+        )
         super().__init__(name)
 
     @AsyncStatus.wrap
@@ -96,14 +96,18 @@ class BaseElectronAnalyserDetector(
     @abstractmethod
     def driver(self) -> TAbstractAnalyserDriverIO:
         """
-        Define property for the driver. Some implementations will store this as a
-        reference so it doesn't run into errors with conflicting parents.
+        Define common property for all implementations to access the driver. Some
+        implementations will store this as a reference so it doesn't have conflicting
+        parents.
+
+        Returns:
+            instance of the driver.
         """
 
 
-class AbstractElectronAnalyserRegionDetector(
-    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
-    Stageable,
+class ElectronAnalyserRegionDetector(
+    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    Preparable,
     Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
 ):
     """
@@ -126,26 +130,31 @@ class AbstractElectronAnalyserRegionDetector(
         return self._driver_ref()
 
     @AsyncStatus.wrap
-    async def stage(self) -> None:
-        super().stage()
-        self.configure_region()
-
-    @abstractmethod
-    def configure_region(self):
+    async def prepare(self, value: Motor) -> None:
         """
-        Setup analyser with configured region.
+        Prepare driver with the region stored and energy_source motor.
+
+        Args:
+            value: The excitation energy source that the region has selected.
         """
+        excitation_energy_source = value
+        await self.driver.prepare(excitation_energy_source)
+        await self.driver.set(self.region)
 
 
-TAbstractElectronAnalyserRegionDetector = TypeVar(
-    "TAbstractElectronAnalyserRegionDetector",
-    bound=AbstractElectronAnalyserRegionDetector,
+TElectronAnalyserRegionDetector = TypeVar(
+    "TElectronAnalyserRegionDetector",
+    bound=ElectronAnalyserRegionDetector,
 )
 
 
-class AbstractElectronAnalyserDetector(
-    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
-    Generic[TAbstractAnalyserDriverIO, TAbstractBaseSequence, TAbstractBaseRegion],
+class ElectronAnalyserDetector(
+    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    Generic[
+        TAbstractAnalyserDriverIO,
+        TAbstractBaseSequence,
+        TAbstractBaseRegion,
+    ],
 ):
     """
     Electron analyser detector with the additional functionality to load a sequence file
@@ -154,9 +163,14 @@ class AbstractElectronAnalyserDetector(
     """
 
     def __init__(
-        self, prefix: str, name: str, sequence_class: type[TAbstractBaseSequence]
+        self,
+        prefix: str,
+        sequence_class: type[TAbstractBaseSequence],
+        driver: TAbstractAnalyserDriverIO,
+        name: str = "",
     ):
-        self._driver = self._create_driver(prefix)
+        # Pass in driver
+        self._driver = driver
         self._sequence_class = sequence_class
         super().__init__(name, self.driver)
 
@@ -167,44 +181,43 @@ class AbstractElectronAnalyserDetector(
         return self._driver
 
     def load_sequence(self, filename: str) -> TAbstractBaseSequence:
-        return load_json_file_to_class(self._sequence_class, filename)
-
-    @abstractmethod
-    def _create_driver(self, prefix: str) -> TAbstractAnalyserDriverIO:
-        """
-        Define implementation of the driver used for this detector.
         """
+        Load the sequence data from a provided json file into a sequence class.
 
-    @abstractmethod
-    def _create_region_detector(
-        self, driver: TAbstractAnalyserDriverIO, region: TAbstractBaseRegion
-    ) -> AbstractElectronAnalyserRegionDetector[
-        TAbstractAnalyserDriverIO, TAbstractBaseRegion
-    ]:
-        """
-        Define a way to create a temporary detector object that will always setup a
-        specific region before acquiring.
+        Args:
+            filename: Path to the sequence file containing the region data.
+
+        Returns:
+            Pydantic model representing the sequence file.
         """
+        return load_json_file_to_class(self._sequence_class, filename)
 
     def create_region_detector_list(
-        self, filename: str
+        self, filename: str, enabled_only=True
     ) -> list[
-        AbstractElectronAnalyserRegionDetector[
-            TAbstractAnalyserDriverIO, TAbstractBaseRegion
-        ]
+        ElectronAnalyserRegionDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion]
     ]:
         """
-        Create a list of detectors that will setup a specific region from the sequence
-        file when used.
+        Create a list of detectors equal to the number of regions in a sequence file.
+        Each detector is responsible for setting up a specific region.
+
+        Args:
+            filename:     Path to the sequence file containing the region data.
+            enabled_only: If true, only include the region if enabled is True.
+
+        Returns:
+            List of ElectronAnalyserRegionDetector, equal to the number of regions in
+            the sequence file.
         """
         seq = self.load_sequence(filename)
+        regions = seq.get_enabled_regions() if enabled_only else seq.regions
         return [
-            self._create_region_detector(self.driver, r)
-            for r in seq.get_enabled_regions()
+            ElectronAnalyserRegionDetector(self.name + "_" + r.name, self.driver, r)
+            for r in regions
         ]
 
 
-TAbstractElectronAnalyserDetector = TypeVar(
-    "TAbstractElectronAnalyserDetector",
-    bound=AbstractElectronAnalyserDetector,
+TElectronAnalyserDetector = TypeVar(
+    "TElectronAnalyserDetector",
+    bound=ElectronAnalyserDetector,
 )

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -1,9 +1,12 @@
+import asyncio
 from abc import ABC, abstractmethod
-from typing import TypeVar
+from typing import Generic, TypeVar
 
 import numpy as np
+from bluesky.protocols import Movable, Preparable
 from ophyd_async.core import (
     Array1D,
+    AsyncStatus,
     SignalR,
     StandardReadable,
     StandardReadableFormat,
@@ -12,12 +15,23 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.adcore import ADBaseIO
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.motor import Motor
 
+from dodal.devices.electron_analyser.abstract.base_region import (
+    TAbstractBaseRegion,
+)
 from dodal.devices.electron_analyser.types import EnergyMode
-from dodal.devices.electron_analyser.util import to_binding_energy
+from dodal.devices.electron_analyser.util import to_binding_energy, to_kinetic_energy
 
 
-class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
+class AbstractAnalyserDriverIO(
+    ABC,
+    StandardReadable,
+    ADBaseIO,
+    Preparable,
+    Movable[TAbstractBaseRegion],
+    Generic[TAbstractBaseRegion],
+):
     """
     Generic device to configure electron analyser with new region settings.
     Electron analysers should inherit from this class for further specialisation.
@@ -48,7 +62,9 @@ class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
             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")
+            self.excitation_energy_source = soft_signal_rw(str, initial_value="")
 
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Read once per scan after data acquired
             self.energy_axis = self._create_energy_axis_signal(prefix)
             self.binding_energy_axis = derived_signal_r(
@@ -71,16 +87,79 @@ class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
 
         super().__init__(prefix=prefix, name=name)
 
+    @AsyncStatus.wrap
+    async def prepare(self, value: Motor):
+        """
+        Prepare the driver for a region by passing in the energy source motor selected
+        by a region.
+
+        Args:
+            value: The motor that contains the information on the current excitation
+                   energy. Needed to prepare region for epics to accuratly calculate
+                   kinetic energy for an energy scan when in binding energy mode.
+        """
+        energy_source = value
+        excitation_energy_value = await energy_source.user_readback.get_value()  # eV
+        excitation_energy_source_name = energy_source.name
+
+        await asyncio.gather(
+            self.excitation_energy.set(excitation_energy_value),
+            self.excitation_energy_source.set(excitation_energy_source_name),
+        )
+
+    @AsyncStatus.wrap
+    async def set(self, region: TAbstractBaseRegion):
+        """
+        This should encompass all core region logic which is common to every electron
+        analyser for setting up the driver.
+
+        Args:
+            region: Contains the parameters to setup the driver for a scan.
+        """
+        pass_energy_type = self.pass_energy_type
+        pass_energy = pass_energy_type(region.pass_energy)
+
+        excitation_energy = await self.excitation_energy.get_value()
+        low_energy = to_kinetic_energy(
+            region.low_energy, region.energy_mode, excitation_energy
+        )
+        high_energy = to_kinetic_energy(
+            region.high_energy, region.energy_mode, excitation_energy
+        )
+        await asyncio.gather(
+            self.region_name.set(region.name),
+            self.energy_mode.set(region.energy_mode),
+            self.low_energy.set(low_energy),
+            self.high_energy.set(high_energy),
+            self.slices.set(region.slices),
+            self.lens_mode.set(region.lens_mode),
+            self.pass_energy.set(pass_energy),
+            self.iterations.set(region.iterations),
+            self.acquisition_mode.set(region.acquisition_mode),
+        )
+
     @abstractmethod
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         """
         The signal that defines the angle axis. Depends on analyser model.
+
+        Args:
+            prefix: PV string used for connecting to angle axis.
+
+        Returns:
+            Signal that can give us angle axis array data.
         """
 
     @abstractmethod
     def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         """
         The signal that defines the energy axis. Depends on analyser model.
+
+        Args:
+            prefix: PV string used for connecting to energy axis.
+
+        Returns:
+            Signal that can give us energy axis array data.
         """
 
     def _calculate_binding_energy_axis(
@@ -89,6 +168,20 @@ class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
         excitation_energy: float,
         energy_mode: EnergyMode,
     ) -> Array1D[np.float64]:
+        """
+        Calculate the binding energy axis to calibrate the spectra data. Function for a
+        derived signal.
+
+        Args:
+            energy_axis:       Array data of the original energy_axis from epics.
+            excitation_energy: The excitation energy value used for the scan of this
+                               region.
+            energy_mode:       The energy_mode of the region that was used for the scan
+                               of this region.
+
+        Returns:
+            Array that is the correct axis for the spectra data.
+        """
         is_binding = energy_mode == EnergyMode.BINDING
         return np.array(
             [
@@ -102,6 +195,18 @@ class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
     def _calculate_total_time(
         self, total_steps: int, step_time: float, iterations: int
     ) -> float:
+        """
+        Calulcate the total time the scan takes for this region. Function for a derived
+        signal.
+
+        Args:
+            total_steps: Number of steps for the region.
+            step_time: Time for each step for the region.
+            iterations: The number of iterations the region collected data for.
+
+        Returns:
+            Calculated total time in seconds.
+        """
         return total_steps * step_time * iterations
 
     def _calculate_total_intensity(self, spectrum: Array1D[np.float64]) -> float:
@@ -111,8 +216,12 @@ class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
     @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.
+        Return the type the pass_energy should be. Depends on underlying analyser
+        software.
+
+        Returns:
+            Type the pass energy parameter from a region needs to be cast to so it can
+            be set correctly on the signal.
         """
 
 

dodal/devices/electron_analyser/abstract/base_region.py

@@ -53,6 +53,7 @@ class AbstractBaseRegion(ABC, JavaToPythonModel):
     enabled: bool = False
     slices: int = 1
     iterations: int = 1
+    excitation_energy_source: str = "source1"
     # These ones we need subclasses to provide default values
     lens_mode: str
     pass_energy: int

dodal/devices/electron_analyser/specs/__init__.py

@@ -1,10 +1,9 @@
-from .detector import SpecsDetector, SpecsRegionDetector
+from .detector import SpecsDetector
 from .driver_io import SpecsAnalyserDriverIO
 from .region import SpecsRegion, SpecsSequence
 
 __all__ = [
     "SpecsDetector",
-    "SpecsRegionDetector",
     "SpecsAnalyserDriverIO",
     "SpecsRegion",
     "SpecsSequence",

dodal/devices/electron_analyser/specs/detector.py

@@ -1,29 +1,13 @@
 from dodal.devices.electron_analyser.abstract.base_detector import (
-    AbstractElectronAnalyserDetector,
-    AbstractElectronAnalyserRegionDetector,
+    ElectronAnalyserDetector,
 )
 from dodal.devices.electron_analyser.specs.driver_io import SpecsAnalyserDriverIO
 from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSequence
 
 
-class SpecsRegionDetector(
-    AbstractElectronAnalyserRegionDetector[SpecsAnalyserDriverIO, SpecsRegion]
-):
-    def configure_region(self):
-        # ToDo - Need to move configure plans to here and rewrite tests
-        pass
-
-
 class SpecsDetector(
-    AbstractElectronAnalyserDetector[SpecsAnalyserDriverIO, SpecsSequence, SpecsRegion]
+    ElectronAnalyserDetector[SpecsAnalyserDriverIO, SpecsSequence, SpecsRegion]
 ):
-    def __init__(self, prefix: str, name: str):
-        super().__init__(prefix, name, SpecsSequence)
-
-    def _create_driver(self, prefix: str) -> SpecsAnalyserDriverIO:
-        return SpecsAnalyserDriverIO(prefix, "driver")
-
-    def _create_region_detector(
-        self, driver: SpecsAnalyserDriverIO, region: SpecsRegion
-    ) -> SpecsRegionDetector:
-        return SpecsRegionDetector(self.name, driver, region)
+    def __init__(self, prefix: str, name: str = ""):
+        driver = SpecsAnalyserDriverIO(prefix=prefix)
+        super().__init__(prefix, SpecsSequence, driver, name)

dodal/devices/electron_analyser/specs/driver_io.py

@@ -1,13 +1,22 @@
+import asyncio
+
 import numpy as np
-from ophyd_async.core import Array1D, SignalR, StandardReadableFormat, derived_signal_r
+from ophyd_async.core import (
+    Array1D,
+    AsyncStatus,
+    SignalR,
+    StandardReadableFormat,
+    derived_signal_r,
+)
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
+from dodal.devices.electron_analyser.specs.region import SpecsRegion
 
 
-class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
+class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Used for setting up region data acquisition.
@@ -21,6 +30,22 @@ class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
 
         super().__init__(prefix, name)
 
+    @AsyncStatus.wrap
+    async def set(self, region: SpecsRegion):
+        await super().set(region)
+
+        await asyncio.gather(
+            self.snapshot_values.set(region.values),
+            self.psu_mode.set(region.psu_mode),
+        )
+        # ToDo - This needs to be changed to an Enum
+        # https://github.com/DiamondLightSource/dodal/issues/1258
+        if region.acquisition_mode == "Fixed Transmission":
+            await self.centre_energy.set(region.centre_energy)
+
+        if self.acquisition_mode == "Fixed Energy":
+            await self.energy_step.set(region.energy_step)
+
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         angle_axis = derived_signal_r(
             self._calculate_angle_axis,

dodal/devices/electron_analyser/vgscienta/__init__.py

@@ -1,10 +1,9 @@
-from .detector import VGScientaDetector, VGScientaRegionDetector
+from .detector import VGScientaDetector
 from .driver_io import VGScientaAnalyserDriverIO
 from .region import VGScientaExcitationEnergySource, VGScientaRegion, VGScientaSequence
 
 __all__ = [
     "VGScientaDetector",
-    "VGScientaRegionDetector",
     "VGScientaAnalyserDriverIO",
     "VGScientaExcitationEnergySource",
     "VGScientaRegion",

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -1,6 +1,5 @@
 from dodal.devices.electron_analyser.abstract.base_detector import (
-    AbstractElectronAnalyserDetector,
-    AbstractElectronAnalyserRegionDetector,
+    ElectronAnalyserDetector,
 )
 from dodal.devices.electron_analyser.vgscienta.driver_io import (
     VGScientaAnalyserDriverIO,
@@ -11,26 +10,13 @@ from dodal.devices.electron_analyser.vgscienta.region import (
 )
 
 
-class VGScientaRegionDetector(
-    AbstractElectronAnalyserRegionDetector[VGScientaAnalyserDriverIO, VGScientaRegion]
-):
-    def configure_region(self):
-        # ToDo - Need to move configure plans to here and rewrite tests
-        pass
-
-
 class VGScientaDetector(
-    AbstractElectronAnalyserDetector[
-        VGScientaAnalyserDriverIO, VGScientaSequence, VGScientaRegion
+    ElectronAnalyserDetector[
+        VGScientaAnalyserDriverIO,
+        VGScientaSequence,
+        VGScientaRegion,
     ]
 ):
-    def __init__(self, prefix: str, name: str):
-        super().__init__(prefix, name, VGScientaSequence)
-
-    def _create_driver(self, prefix: str) -> VGScientaAnalyserDriverIO:
-        return VGScientaAnalyserDriverIO(prefix, "driver")
-
-    def _create_region_detector(
-        self, driver: VGScientaAnalyserDriverIO, region: VGScientaRegion
-    ) -> VGScientaRegionDetector:
-        return VGScientaRegionDetector(self.name, driver, region)
+    def __init__(self, prefix: str, name: str = ""):
+        driver = VGScientaAnalyserDriverIO(prefix)
+        super().__init__(prefix, VGScientaSequence, driver, name)

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -1,19 +1,28 @@
+import asyncio
+
 import numpy as np
-from ophyd_async.core import Array1D, SignalR, StandardReadableFormat, soft_signal_rw
+from ophyd_async.core import (
+    Array1D,
+    AsyncStatus,
+    SignalR,
+    StandardReadableFormat,
+)
+from ophyd_async.epics.adcore import ADImageMode
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
+from dodal.devices.electron_analyser.util import to_kinetic_energy
 from dodal.devices.electron_analyser.vgscienta.region import (
     DetectorMode,
+    VGScientaRegion,
 )
 
 
-class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO):
+class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO[VGScientaRegion]):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
-            self.excitation_energy_source = soft_signal_rw(str, initial_value=None)
             # Used for setting up region data acquisition.
             self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
             self.first_x_channel = epics_signal_rw(int, prefix + "MinX")
@@ -28,6 +37,25 @@ class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO):
 
         super().__init__(prefix, name)
 
+    @AsyncStatus.wrap
+    async def set(self, region: VGScientaRegion):
+        await super().set(region)
+
+        excitation_energy = await self.excitation_energy.get_value()
+        centre_energy = to_kinetic_energy(
+            region.fix_energy, region.energy_mode, excitation_energy
+        )
+        await asyncio.gather(
+            self.centre_energy.set(centre_energy),
+            self.energy_step.set(region.energy_step),
+            self.first_x_channel.set(region.first_x_channel),
+            self.first_y_channel.set(region.first_y_channel),
+            self.x_channel_size.set(region.x_channel_size()),
+            self.y_channel_size.set(region.y_channel_size()),
+            self.detector_mode.set(region.detector_mode),
+            self.image_mode.set(ADImageMode.SINGLE),
+        )
+
     def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         return epics_signal_r(Array1D[np.float64], prefix + "X_SCALE_RBV")
 

dodal/devices/electron_analyser/vgscienta/region.py

@@ -40,7 +40,6 @@ class VGScientaRegion(AbstractBaseRegion):
     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

dodal/devices/fast_grid_scan.py

@@ -234,7 +234,7 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         }
         super().__init__(name)
 
-    def _calculate_expected_images(self, x: float, y: float, z: float) -> float:
+    def _calculate_expected_images(self, x: int, y: int, z: int) -> int:
         LOGGER.info(f"Reading num of images found {x, y, z} images in each axis")
         first_grid = x * y
         second_grid = x * z