tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/core/process/reconstruction/axis/mode.py

@@ -1,33 +1,3 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "15/10/2019"
-
-
 import logging
 
 from silx.utils.enum import Enum as _Enum
@@ -35,6 +5,55 @@ from silx.utils.enum import Enum as _Enum
 _logger = logging.getLogger(__name__)
 
 
+class AxisModeMetadata:
+    """
+    Util class to store metadata regarding processing of a mode.
+
+    Ease processing and display
+    Maybe this function should be part of nabu ?
+    """
+
+    def __init__(
+        self,
+        lockable,
+        tooltip="",
+        computing_constrains=(),
+        allows_padding=False,
+        valid_inputs=(),
+        valid_sides=(),
+    ) -> None:
+        self._lockable = lockable
+        self._tooltip = tooltip
+        self._computing_constrains = computing_constrains
+        self._allows_padding = allows_padding
+        self._valid_inputs = valid_inputs
+        self._valid_sides = valid_sides
+
+    @property
+    def is_lockable(self) -> bool:
+        return self._lockable
+
+    @property
+    def tooltip(self) -> str:
+        return self._tooltip
+
+    @property
+    def computing_constrains(self) -> tuple:
+        return self._computing_constrains
+
+    @property
+    def allows_padding(self) -> bool:
+        return self._allows_padding
+
+    @property
+    def valid_inputs(self) -> tuple:
+        return self._valid_inputs
+
+    @property
+    def valid_sides(self) -> tuple:
+        return self._valid_sides
+
+
 class _InputType(_Enum):
     SINOGRAM = "sinogram"
     RADIOS_X2 = "2 radios"
@@ -55,7 +74,11 @@ class AxisMode(_Enum):
     sliding_window_radios = "radios-sliding-window"
     sino_coarse_to_fine = "sino-coarse-to-fine"
     composite_coarse_to_fine = "composite-coarse-to-fine"
+    sino_fourier_angles = "sino-fourier-angles"
+    octave_accurate_radios = "radios-octave-accurate"
     read = "read"
+    # alias to composite_coarse_to_fine with near mode
+    near = "near"
 
     @classmethod
     def from_value(cls, value):
@@ -74,22 +97,114 @@ class AxisMode(_Enum):
         return super().from_value(value=value)
 
 
-_VALID_INPUTS = {
-    AxisMode.centered: (_InputType.RADIOS_X2,),
-    AxisMode.global_: (_InputType.RADIOS_X2,),
-    AxisMode.manual: (_InputType.RADIOS_X2,),
-    AxisMode.growing_window_radios: (_InputType.RADIOS_X2,),
-    AxisMode.sliding_window_radios: (_InputType.RADIOS_X2,),
-    AxisMode.sliding_window_sinogram: (_InputType.SINOGRAM,),
-    AxisMode.growing_window_sinogram: (_InputType.SINOGRAM,),
-    AxisMode.sino_coarse_to_fine: (_InputType.SINOGRAM,),
-    AxisMode.composite_coarse_to_fine: (
-        _InputType.COMPOSITE,
-    ),  # in fact it is more an n radio constrain
-    AxisMode.read: None,
-}
-
-_AXIS_MODE_CONSTRAIN = {
-    AxisMode.sino_coarse_to_fine: (_Constrain.FULL_TURN,),
-    AxisMode.composite_coarse_to_fine: (_Constrain.FULL_TURN,),
+AXIS_MODE_METADATAS = {
+    # manual
+    AxisMode.manual: AxisModeMetadata(
+        lockable=False,
+        tooltip="Enter or find manually the COR value",
+        computing_constrains=(),
+        allows_padding=False,
+        valid_inputs=(_InputType.RADIOS_X2,),
+    ),
+    # read
+    AxisMode.read: AxisModeMetadata(
+        lockable=False,
+        tooltip="Read COR value from a file",
+        computing_constrains=(),
+        allows_padding=False,
+        valid_inputs=None,
+    ),
+    # radio algorithm
+    AxisMode.centered: AxisModeMetadata(
+        lockable=True,
+        tooltip="Dedicated to fullfield. Previously named 'accurate'",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.RADIOS_X2,),
+    ),
+    AxisMode.global_: AxisModeMetadata(
+        lockable=True,
+        tooltip="Algorithm which can work for both half acquisition and standard ('full field') acquisition",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.RADIOS_X2,),
+    ),
+    AxisMode.growing_window_radios: AxisModeMetadata(
+        lockable=True,
+        tooltip="A auto-Cor method",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.RADIOS_X2,),
+        valid_sides=("left", "right", "center", "all"),
+    ),
+    AxisMode.sliding_window_radios: AxisModeMetadata(
+        lockable=True,
+        tooltip="A method for estimating semi-automatically the CoR position. You have to provide a hint on where the CoR is (left, center, right).",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.RADIOS_X2,),
+        valid_sides=("left", "right", "center", "near"),
+    ),
+    AxisMode.octave_accurate_radios: AxisModeMetadata(
+        lockable=True,
+        tooltip="Same method as the 'accurate' octave code",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.RADIOS_X2,),
+        valid_sides=("center",),
+    ),
+    # sinogram algorithm
+    AxisMode.growing_window_sinogram: AxisModeMetadata(
+        lockable=True,
+        tooltip="A auto-Cor method",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.SINOGRAM,),
+        valid_sides=("left", "right", "center", "all"),
+    ),
+    AxisMode.sliding_window_sinogram: AxisModeMetadata(
+        lockable=True,
+        tooltip="A method for estimating semi-automatically the CoR position. You have to provide a hint on where the CoR is (left, center, right).",
+        computing_constrains=(),
+        allows_padding=True,
+        valid_inputs=(_InputType.SINOGRAM,),
+        valid_sides=("left", "right", "center", "near"),
+    ),
+    AxisMode.sino_coarse_to_fine: AxisModeMetadata(
+        lockable=True,
+        tooltip="Estimate CoR from sinogram. Only works for 360 degrees scans.",
+        computing_constrains=(_Constrain.FULL_TURN,),
+        allows_padding=True,
+        valid_inputs=(_InputType.SINOGRAM,),
+    ),
+    AxisMode.sino_fourier_angles: AxisModeMetadata(
+        lockable=True,
+        tooltip="",
+        computing_constrains=(_Constrain.FULL_TURN,),
+        allows_padding=True,
+        valid_inputs=(_InputType.SINOGRAM,),
+        valid_sides=(
+            "left",
+            "right",
+            "center",
+            "near",
+        ),
+    ),
+    # coarse-to-fine algorithm
+    AxisMode.composite_coarse_to_fine: AxisModeMetadata(
+        lockable=True,
+        tooltip="A auto-Cor method",
+        computing_constrains=(_Constrain.FULL_TURN,),
+        allows_padding=True,
+        valid_inputs=(_InputType.COMPOSITE,),
+        valid_sides=("left", "right", "center", "near"),
+    ),
+    AxisMode.near: AxisModeMetadata(
+        lockable=True,
+        tooltip="Alias to composite_coarse_to_fine",
+        computing_constrains=(_Constrain.FULL_TURN,),
+        allows_padding=True,
+        valid_inputs=(_InputType.COMPOSITE,),
+        valid_sides=("left", "right", "center", "near"),
+    ),
 }

tomwer/core/process/reconstruction/axis/params.py

@@ -42,10 +42,10 @@ from tomoscan.esrf.scan.utils import get_data
 
 from tomwer.core.process.task import Task
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.utils import getParametersFromParOrInfo
+from tomwer.core.utils.spec import getParametersFromParOrInfo
 
 from .anglemode import CorAngleMode
-from .mode import AxisMode
+from .mode import AxisMode, AXIS_MODE_METADATAS
 from .projectiontype import ProjectionType
 
 from nabu.preproc.phase import PaganinPhaseRetrieval
@@ -160,9 +160,9 @@ class AxisResource(object):
         else:
             self.__norme_data = scan.data_flat_field_correction(data=self.data)
             if log_ is True:
-                self.__norme_data[
-                    numpy.isnan(self.__norme_data)
-                ] = self.__norme_data.max()
+                self.__norme_data[numpy.isnan(self.__norme_data)] = (
+                    self.__norme_data.max()
+                )
                 if self.__norme_data.max() < 0:
                     _logger.error("max data value < 0 unable to compute log")
                 else:
@@ -173,9 +173,9 @@ class AxisResource(object):
                     except Exception as e:
                         _logger.error("Fail to apply log on radio" + e)
             else:
-                self.__norme_data[
-                    numpy.isnan(self.__norme_data)
-                ] = self.__norme_data.min()
+                self.__norme_data[numpy.isnan(self.__norme_data)] = (
+                    self.__norme_data.min()
+                )
 
         return self.__norme_data
 
@@ -885,6 +885,9 @@ class AxisRP:
         pass
 
     def get_simple_str(self):
+        """
+        special information as a str for mode able to handle both sinogram and radios
+        """
         results = f"{self.mode.value}"
         if self.mode in (
             AxisMode.growing_window_radios,
@@ -898,18 +901,20 @@ class AxisRP:
 
     def get_nabu_cor_options_as_dict(self) -> str:
         options = {}
-        if self.mode in (
-            AxisMode.sliding_window_sinogram,
-            AxisMode.sliding_window_radios,
-            AxisMode.growing_window_sinogram,
-            AxisMode.growing_window_radios,
-        ):
-            options["side"] = self.side
-        elif self.mode in (AxisMode.composite_coarse_to_fine,):
-            near_pos = self.composite_options.get("near_pos", 0.0)
+        if self.mode is AxisMode.near:
+            self.side = "near"
+        request_side = len(AXIS_MODE_METADATAS[self.mode].valid_sides) > 0
+        if request_side:
+
+            if self.side == "near":
+                options["side"] = self.composite_options.get(
+                    "near_pos", self.estimated_cor
+                )
+            else:
+                options["side"] = self.side
+
+        if self.side == "near":
             near_width = self.composite_options.get("near_width", 20.0)
-            options["side"] = self.side
-            options["near_pos"] = near_pos
             options["near_width"] = near_width
 
         # append "extra_cor_options" to already handled cor options
@@ -917,8 +922,11 @@ class AxisRP:
 
         if extra_cor_options != "":
             for opt in self.extra_cor_options.replace(" ", "").split(";"):
-                key, value = opt.split("=")
-                options[key] = value
+                if len(opt.split("=")) == 2:
+                    key, value = opt.split("=")
+                    options[key] = value
+                else:
+                    _logger.info(f"ignore option {opt}. Invalid synthax")
         return options
 
     @deprecated(replacement="get_nabu_cor_options_as_str", since_version="1.1")

tomwer/core/process/reconstruction/darkref/darkrefs.py

@@ -37,17 +37,16 @@ from queue import Queue
 
 from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
-from silx.io.url import DataUrl
-from silx.io.utils import h5py_read_dataset
-from silx.utils.deprecation import deprecated_warning
+from tomwer.core.utils.deprecation import deprecated_warning
 
-from tomoscan.framereducerbase import REDUCER_TARGET, ReduceMethod
-from tomoscan.io import HDF5File
+from tomoscan.framereducer.target import REDUCER_TARGET
+from tomoscan.framereducer.method import ReduceMethod
 
 import tomwer.version
-from tomwer.core import settings, utils
+from tomwer.core import settings
+from tomwer.core.utils.lbsram import is_low_on_memory
 from tomwer.core.process.task import Task
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.scanutils import data_identifier_to_scan
@@ -241,57 +240,13 @@ class DarkRefsTask(
         :return: dictionary with index in the sequence as key and numpy array
                  as value (or url if as_url set to True)
         """
-        if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
-                entries = DarkRefsTask._get_process_nodes(
-                    root_node=h5f, process=DarkRefsTask
-                )
-                if len(entries) == 0:
-                    logger.info("unable to find a DarkRef process in %s" % process_file)
-                    return None
-                elif len(entries) > 1:
-                    raise ValueError("several entry found, entry should be " "specify")
-                else:
-                    entry = list(entries.keys())[0]
-                    logger.info("take %s as default entry" % entry)
-
-        with HDF5File(process_file, "r", swmr=True) as h5f:
-            if entry not in h5f.keys():
-                logger.info(f"no dark found for {entry}")
-                return {}
-            dark_nodes = DarkRefsTask._get_process_nodes(
-                root_node=h5f[entry], process=DarkRefsTask
-            )
-            index_to_path = {}
-            for key, index in dark_nodes.items():
-                index_to_path[index] = key
-
-            if len(dark_nodes) == 0:
-                return {}
-            # take the last processed dark ref
-            last_process_index = sorted(list(dark_nodes.values()))[-1]
-            last_process_dark = index_to_path[last_process_index]
-            if (len(index_to_path)) > 1:
-                logger.debug(
-                    "several processing found for dark-ref,"
-                    "take the last one: %s" % last_process_dark
-                )
-
-            res = {}
-            if "results" in h5f[last_process_dark].keys():
-                results_node = h5f[last_process_dark]["results"]
-                if "darks" in results_node.keys():
-                    darks = results_node["darks"]
-                    for index in darks:
-                        if as_url is True:
-                            res[int(index)] = DataUrl(
-                                file_path=process_file,
-                                data_path="/".join((darks.name, index)),
-                                scheme="silx",
-                            )
-                        else:
-                            res[int(index)] = h5py_read_dataset(darks[index])
-            return res
+        deprecated_warning(
+            name="tomwer.core.process.reconstruction.darkref.DarkRefsTask.get_darks_frm_process_file",
+            type_="function",
+            reason="removed. Reduced dark / flat are expected to be stored on didicated files and not in tomwer_processes anymore",
+            since_version="1.2",
+        )
+        return None
 
     @staticmethod
     def get_flats_frm_process_file(
@@ -305,57 +260,13 @@ class DarkRefsTask(
                             numpy.array
         :return:
         """
-        if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
-                entries = DarkRefsTask._get_process_nodes(
-                    root_node=h5f, process=DarkRefsTask
-                )
-                if len(entries) == 0:
-                    logger.info("unable to find a DarkRef process in %s" % process_file)
-                    return None
-                elif len(entries) > 1:
-                    raise ValueError("several entry found, entry should be " "specify")
-                else:
-                    entry = list(entries.keys())[0]
-                    logger.info("take %s as default entry" % entry)
-
-        with HDF5File(process_file, "r", swmr=True) as h5f:
-            if entry not in h5f.keys():
-                logger.info(f"no flats found for {entry}")
-                return {}
-            dkref_nodes = DarkRefsTask._get_process_nodes(
-                root_node=h5f[entry], process=DarkRefsTask
-            )
-            index_to_path = {}
-            for key, index in dkref_nodes.items():
-                index_to_path[index] = key
-
-            if len(dkref_nodes) == 0:
-                return {}
-            # take the last processed dark ref
-            last_process_index = sorted(dkref_nodes.values())[-1]
-            last_process_dkrf = index_to_path[last_process_index]
-            if (len(index_to_path)) > 1:
-                logger.debug(
-                    "several processing found for dark-ref,"
-                    f"take the last one: {last_process_dkrf}"
-                )
-
-            res = {}
-            if "results" in h5f[last_process_dkrf].keys():
-                results_node = h5f[last_process_dkrf]["results"]
-                if "flats" in results_node.keys():
-                    flats = results_node["flats"]
-                    for index in flats:
-                        if as_url is True:
-                            res[int(index)] = DataUrl(
-                                file_path=process_file,
-                                data_path="/".join((flats.name, index)),
-                                scheme="silx",
-                            )
-                        else:
-                            res[int(index)] = h5py_read_dataset(flats[index])
-            return res
+        deprecated_warning(
+            name="tomwer.core.process.reconstruction.darkref.DarkRefsTask.get_flats_frm_process_file",
+            type_="function",
+            reason="removed. Reduced dark / flat are expected to be stored on didicated files and not in tomwer_processes anymore",
+            since_version="1.2",
+        )
+        return None
 
     def run(self):
         if isinstance(self.inputs.data, str):
@@ -393,7 +304,7 @@ class DarkRefsTask(
         logger.processStarted(f"start dark and ref for {scan}")
         if (
             settings.isOnLbsram(scan)
-            and utils.isLowOnMemory(settings.get_lbsram_path()) is True
+            and is_low_on_memory(settings.get_lbsram_path()) is True
         ):
             mess = (
                 "low memory, do compute dark and flat field mean/median "
@@ -456,13 +367,14 @@ class DarkRefsTask(
         ):
             # cast darks and flats keys from int (index) to str
             o_darks = scan.reduced_darks
+            o_darks_infos = scan.reduced_darks_infos
             f_darks = {}
             for index, data in o_darks.items():
                 f_darks[str(index)] = data
                 interpretations["/".join(("darks", str(index)))] = "image"
             results["darks"] = f_darks
 
-            scan.save_reduced_darks(f_darks, overwrite=True)
+            scan.save_reduced_darks(f_darks, darks_infos=o_darks_infos, overwrite=True)
         if (
             self.recons_params.flat_calc_method
             is not dkrf_reconsparams.ReduceMethod.NONE
@@ -470,33 +382,33 @@ class DarkRefsTask(
         ):
             results["flats"] = scan.reduced_flats
             o_flats = scan.reduced_flats
+            o_flats_infos = scan.reduced_flats_infos
             f_flats = {}
             for index, data in o_flats.items():
                 f_flats[str(index)] = data
                 interpretations["/".join(("flats", str(index)))] = "image"
             results["flats"] = f_flats
 
-            scan.save_reduced_flats(f_flats, overwrite=True)
+            scan.save_reduced_flats(f_flats, flats_infos=o_flats_infos, overwrite=True)
 
         if len(results) > 0:
             # if some processing to be registered
             if scan.process_file is not None and not (
-                isinstance(scan, HDF5TomoScan) and not self.__new_hdf5_entry_created
+                isinstance(scan, NXtomoScan) and not self.__new_hdf5_entry_created
             ):
-                with scan.acquire_process_file_lock():
-                    entry = "entry"
-                    if hasattr(scan, "entry"):
-                        entry = scan.entry
-                    self.register_process(
-                        process_file=scan.process_file,
-                        entry=entry,
-                        configuration=self.recons_params.to_dict(),
-                        results=results,
-                        interpretations=interpretations,
-                        process_index=scan.pop_process_index(),
-                        overwrite=True,
-                    )
-        logger.processSucceed(f"Dark and ref succeeded for {scan}")
+                entry = "entry"
+                if hasattr(scan, "entry"):
+                    entry = scan.entry
+                self.register_process(
+                    process_file=scan.process_file,
+                    entry=entry,
+                    configuration=self.recons_params.to_dict(),
+                    results=results,
+                    interpretations=interpretations,
+                    process_index=scan.pop_process_index(),
+                    overwrite=True,
+                )
+        logger.processSucceed(f"Dark and flat reduction succeeded for {scan}")
         self.notify_to_state_to_managed(
             dataset=scan, state=DatasetState.SUCCEED, details=None
         )
@@ -529,6 +441,7 @@ class DarkRefsTask(
                 return_info=True,
             )
             scan.set_reduced_darks(darks=reduced_darks, darks_infos=metadata)
+
             try:
                 scan.save_reduced_darks(
                     darks=reduced_darks, darks_infos=metadata, overwrite=True
@@ -542,6 +455,7 @@ class DarkRefsTask(
                 return_info=True,
             )
             scan.set_reduced_flats(flats=reduced_flats, flats_infos=metadata)
+
             try:
                 scan.save_reduced_flats(
                     flats=reduced_flats, flats_infos=metadata, overwrite=True

tomwer/core/process/reconstruction/darkref/darkrefscopy.py

@@ -39,12 +39,13 @@ from typing import Union
 
 from silx.io.dictdump import dicttoh5, h5todict
 from silx.io.url import DataUrl
+from silx.io.utils import open as open_hdf5
 from tomoscan.esrf.scan.utils import (
     copy_h5_dict_darks_to,
     copy_h5_dict_flats_to,
     cwd_context,
 )
-from tomoscan.framereducerbase import REDUCER_TARGET
+from tomoscan.framereducer.target import REDUCER_TARGET
 from tomoscan.io import HDF5File
 
 from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefsTask
@@ -297,7 +298,7 @@ class DarkRefsCopy(DarkRefsTask):
         if not os.path.exists(self._save_file):
             return False
         else:
-            with HDF5File(self._save_file, mode="r") as h5f:
+            with open_hdf5(self._save_file) as h5f:
                 return self._flats_url.data_path() in h5f
 
     def has_dark_stored(self) -> bool:
@@ -309,7 +310,7 @@ class DarkRefsCopy(DarkRefsTask):
         if not os.path.exists(self._save_file):
             return False
         else:
-            with HDF5File(self._save_file, mode="r") as h5f:
+            with open_hdf5(self._save_file) as h5f:
                 return self._darks_url.data_path() in h5f
 
     def contains_dark(self, scan: TomwerScanBase) -> bool:

tomwer/core/process/reconstruction/darkref/params.py

@@ -31,7 +31,7 @@ __date__ = "07/03/2019"
 import enum
 
 from silx.utils.enum import Enum as _Enum
-from tomoscan.framereducerbase import ReduceMethod
+from tomoscan.framereducer.method import ReduceMethod
 
 from tomwer.core.process.reconstruction.darkref.settings import (
     DARKHST_PREFIX,

tomwer/core/process/reconstruction/nabu/castvolume.py

@@ -47,7 +47,7 @@ from tomoscan.volumebase import VolumeBase
 from tomwer.core.cluster.cluster import SlurmClusterConfiguration
 from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.process.reconstruction.nabu import settings
-from tomwer.core.process.reconstruction.nabu.nabucommon import NabuOutputFileFormat
+from tomwer.core.process.reconstruction.output import NabuOutputFileFormat
 from tomwer.core.process.task import Task
 from tomwer.core.utils.slurm import get_slurm_script_name
 from tomwer.core.utils.volumeutils import volume_identifier_to_volume
@@ -231,9 +231,9 @@ class CastVolumeTask(
                     working_directory, "slurm_scripts", script_name
                 )
             # for now force job name
-            self._cluster_config[
-                "job_name"
-            ] = f"tomwer-cast-volume {input_volume.get_identifier().to_str()} to {output_volume.get_identifier().to_str()}"
+            self._cluster_config["job_name"] = (
+                f"tomwer-cast-volume {input_volume.get_identifier().to_str()} to {output_volume.get_identifier().to_str()}"
+            )
             job = SBatchScriptJob(
                 slurm_config=self._cluster_config,
                 script=(get_command(),),