ewoksid02 0.1.0__py3-none-any.whl

ewoksid02/scripts/saxs/slurm_python_post_script.py

@@ -0,0 +1,3 @@
+print(
+    "This python script will be executed after the slurm job and after the bash post-script"
+)

ewoksid02/scripts/saxs/slurm_python_pre_script.py

@@ -0,0 +1,5 @@
+import pyopencl
+
+print("This is a python script executed before the slurm job execution")
+
+print(f"OpenCL platforms: {[p.get_devices() for p in pyopencl.get_platforms()]}")

ewoksid02/scripts/utils.py

@@ -0,0 +1,21 @@
+WORKER_MODULE = "scattering"
+PRE_SCRIPT = "module load {WORKER_MODULE}; python3 -m ewoksid13.scripts.utils.slurm_python_pre_script"
+PYTHON_CMD = "python3"
+POST_SCRIPT = "python3 -m ewoksid13.scripts.utils.slurm_python_post_script"
+EWOKS_CMD = "ewoks execute {workflow} --engine ppf -o pool_type=thread --inputs=all -o convert_destination={destination_filename}"
+SLURM_URL = "http://slurm-api.esrf.fr:6820"
+
+SLURM_JOB_PARAMETERS_SAXS = {
+    "partition": "gpu-long",
+    "time": "02:00:00",  # 2 hours
+    "tasks_per_node": 1,
+    "cpus_per_task": 1,
+    "memory_per_cpu": "100G",
+    "tres_per_job": "gres/gpu:1",
+    "constraints": "l40s",  # a40, a100, v100, l40s
+}
+
+ID02_EXECUTION_PARAMETERS = {
+    "engine": "ppf",
+    "pool_type": "thread",
+}

ewoksid02/scripts/xpcs/__main__.py

@@ -0,0 +1,3 @@
+def main(args):
+    """Main function to trigger the XPCS pipeline."""
+    print("xpcs", args)

ewoksid02/tasks/__init__.py

@@ -0,0 +1,7 @@
+###
+from .id02processingtask import ID02ProcessingTask  # noqa
+from .normalizationtask import NormalizationTask  # noqa
+from .secondaryscatteringtask import SecondaryScatteringTask  # noqa
+from .cavingtask import CavingBeamstopTask, CavingGapsTask, CavingTask  # noqa
+from .azimuthaltask import AzimuthalTask  # noqa
+from .averagetask import AverageTask  # noqa

ewoksid02/tasks/averagetask.py

@@ -0,0 +1,179 @@
+from contextlib import ExitStack
+
+from pyFAI.units import to_unit
+from silx.io.h5py_utils import open_item as open_item_silx
+
+from ewoksid02.tasks.id02processingtask import ID02ProcessingTask
+from ewoksid02.utils.average import calculate_average, get_array_limit
+
+
+class AverageTask(
+    ID02ProcessingTask,
+    optional_input_names=[
+        "dataset_sum_signal",
+        "dataset_sum_normalization",
+        "dataset_sum_variance",
+        "radial_array",
+        "azimuth_array",
+        "Dummy",
+        "unit",
+        "azimuth_range",
+        "pca_parameters",
+    ],
+    output_names=[
+        "dataset_average_signal_norm",
+        "radial_array",
+    ],
+):
+    """The `AverageTask` class is responsible for calculating the average of datasets in the ID02 SAXS pipeline.
+    It extends the `ID02ProcessingTask` class and provides additional functionality for handling averaging-specific
+    inputs and processing logic. If azimuth_range is not provided, a full average will be performed.
+
+    Optional Inputs:
+        - dataset_sum_signal (numpy.ndarray): Sum of signal, non-normalized from an ai.integrate2d result.
+        - dataset_sum_normalization (numpy.ndarray): Sum of normalized pixels, from an ai.integrate2d result.
+        - dataset_sum_variance (numpy.ndarray): Sum of variance, from an ai.integrate2d result.
+        - radial_array (numpy.ndarray): Radial axis array for the dataset.
+        - azimuth_array (numpy.ndarray): Azimuthal axis array for the dataset.
+        - Dummy (float): Value to replace invalid pixels in the dataset.
+        - unit (str): Unit for the radial axis (e.g., "q_nm^-1").
+        - azimuth_range (list of tuples): Azimuthal ranges for averaging (e.g., `[(0, 90), (270, 360)]`).
+        - pca_parameters (dict): Parameters for Principal Component Analysis (PCA) if applicable.
+    Outputs Parameters:
+        - dataset_average_signal_norm (numpy.ndarray): Normalized average signal dataset.
+        - radial_array (numpy.ndarray): Radial axis array for the averaged data.
+    """
+
+    def run(self):
+        super().run(processing_type="ave")
+
+    def get_processing_inputs(self) -> dict:
+        azimuth_range = self.get_input_value("azimuth_range", None)
+        array_ranges = None
+
+        if azimuth_range is None:
+            self.log_info("There is no azimuth_range. Full average will be done.")
+            array_ranges = [(0, -1)]
+        else:
+            azimuth_array = self.get_input_value("azimuth_array", None)
+            if azimuth_array is None:
+                self.log_warning(
+                    "There is no azimuth_array , azimuth ranges cannot be transformed into array limits. Full average will be done."
+                )
+                array_ranges = [(0, -1)]
+            else:
+                array_ranges = [
+                    get_array_limit(azimuth_array=azimuth_array, azimuth_range=az_range)
+                    for az_range in azimuth_range
+                ]
+
+        params_ave = {
+            "array_ranges": array_ranges,
+            "Dummy": self.get_parameter("Dummy"),
+            "azimuth_range": azimuth_range,
+        }
+
+        return params_ave
+
+    def process(self):
+        do_process = super().process()
+        if do_process is False:
+            return
+
+        with ExitStack() as stack:
+            self.bench_process = self.Benchmark(
+                nb_frames=len(self.dataset_signal), benchmark_name="processing"
+            )
+            stack.enter_context(self.bench_process)
+
+            processing_params = self.get_processing_inputs()
+            self.processing_params = processing_params
+
+            self.log_info("Performing 1D integration...")
+
+            (
+                dataset_average_intensity,
+                dataset_average_signal_norm,
+                dataset_average_variance,
+                dataset_average_sigma,
+            ) = calculate_average(
+                dataset_intensity=self.dataset_signal,
+                dataset_sum_signal=self.get_input_value("dataset_sum_signal", None),
+                dataset_sum_norm=self.get_input_value(
+                    "dataset_sum_normalization", None
+                ),
+                dataset_sum_variance=self.get_input_value("dataset_sum_variance", None),
+                calculate_variance=self.get_input_value("save_variance", False),
+                **processing_params,
+            )
+
+            self.outputs.dataset_signal = dataset_average_intensity
+            self.outputs.dataset_average_signal_norm = dataset_average_signal_norm
+            self.outputs.dataset_variance = dataset_average_variance
+            self.outputs.dataset_sigma = dataset_average_sigma
+            self.outputs.radial_array = self.get_input_value("radial_array", None)
+
+        self._log_benchmark(self.bench_process)
+
+    def save(self) -> None:
+        do_save = super().save()
+        if not do_save:
+            return
+
+        filename_output, h5path_nxdata = self.links["destination"]["nxdata"].split("::")
+        params = {
+            "filename": filename_output,
+            "name": h5path_nxdata,
+            "retry_timeout": 0.1,
+            "mode": "a",
+        }
+        with open_item_silx(**params) as nexus_data_grp:
+            self._update_dataset(
+                added_dataset=self.outputs.dataset_average_signal_norm,
+                h5_group=nexus_data_grp,
+                h5_dataset_name="data_signal_norm",
+                index_read=self.index_range_last,
+            )
+
+            # Add nexus data information (only once)
+            unit = self.get_parameter("unit")
+            radial_unit = to_unit(unit)
+
+            if radial_unit is not None and radial_unit.short_name not in nexus_data_grp:
+                if self.get_input_value("radial_array", None) is not None:
+                    radial_dset = nexus_data_grp.create_dataset(
+                        name=radial_unit.short_name,
+                        data=self.get_input_value("radial_array", None),
+                    )
+                    radial_dset.attrs["unit"] = str(radial_unit)
+                    radial_dset.attrs["interpretation"] = "scalar"
+                    radial_dset.attrs["axis"] = "2"
+                    nexus_data_grp.attrs["axes"] = [".", radial_unit.short_name]
+                    nexus_data_grp.attrs["signal"] = "data"
+
+    def processing_info(self) -> list:
+        azimuth_range = self.get_input_value("azimuth_range", [0, 360])
+        return [{"h5path": "entry_0000", "name": "ave_limits", "value": azimuth_range}]
+
+    def _save_in_gallery(self) -> str:
+        if self.loop_nb != 1:
+            return
+
+        dataset_signal = self.outputs.dataset_signal
+        if dataset_signal is None or dataset_signal.size == 0:
+            return
+
+        import matplotlib.pyplot as plt
+
+        unit = self.get_parameter("unit")
+        radial_unit = to_unit(unit)
+
+        signal = dataset_signal.mean(axis=0)
+        q = self.outputs.radial_array
+        fig, ax = plt.subplots(figsize=(15, 10))
+        ax.plot(q, signal)
+        ax.set_xlabel(f"{radial_unit.short_name} ({radial_unit.unit_symbol})")
+        ax.set_ylabel("Intensity (arb. units)")
+        ax.set_title(f"scan {self.scan_nb} - average")
+        filename_png = self._get_filename_gallery()
+        fig.savefig(filename_png)

ewoksid02/tasks/azimuthaltask.py

@@ -0,0 +1,272 @@
+from contextlib import ExitStack
+
+import numexpr
+from pyFAI.units import to_unit
+from silx.io.h5py_utils import open_item as open_item_silx
+
+from ewoksid02.tasks.id02processingtask import ID02ProcessingTask
+from ewoksid02.utils.pyfai import (
+    get_gpu_method,
+    get_persistent_azimuthal_integrator,
+    _get_persistent_pyfai_worker,
+    process_dataset_azim,
+    guess_npt2_rad,
+)
+
+DEFAULT_NPT_RAD = 1600
+DEFAULT_NPT_AZIM = 360
+
+
+class AzimuthalTask(
+    ID02ProcessingTask,
+    optional_input_names=[
+        "filename_mask",
+        "filename_dark",
+        "npt2_rad",
+        "npt2_azim",
+        "unit",
+        "Dummy",
+        "DDummy",
+        "Center_1",
+        "Center_2",
+        "PSize_1",
+        "PSize_2",
+        "BSize_1",
+        "BSize_2",
+        "SampleDistance",
+        "WaveLength",
+        "DetectorRotation_1",
+        "DetectorRotation_2",
+        "DetectorRotation_3",
+        "method",
+        "integration_options",
+        "do_variance_formula",
+        "variance_formula",
+        "save_sum",
+    ],
+    output_names=[
+        "dataset_sum_signal",
+        "dataset_sum_normalization",
+        "dataset_sum_variance",
+        "radial_array",
+        "azimuth_array",
+    ],
+):
+    """The `AzimuthalTask` class is responsible for performing azimuthal integration on datasets in the ID02 SAXS pipeline.
+    It extends the `ID02ProcessingTask` class and provides additional functionality for handling azimuthal integration-specific
+    inputs and processing logic using the pyFAI library.
+
+    Optional Inputs:
+        - filename_mask (str): Path to the mask file for masking invalid pixels.
+        - filename_dark (str): Path to the file with a dark-current correction.
+        - npt2_rad (int): Number of radial bins for the integration.
+        - npt2_azim (int): Number of azimuthal bins for the integration.
+        - unit (str): Unit for the radial axis (e.g., "q_nm^-1").
+        - Dummy (float): Value to replace invalid pixels in the dataset.
+        - DDummy (float): Tolerance for dummy pixel replacement.
+        - Center_1 (float): Beam center in the first dimension.
+        - Center_2 (float): Beam center in the second dimension.
+        - PSize_1 (float): Pixel size 1.
+        - PSize_2 (float): Pixel size 2.
+        - BSize_1 (float): Pixel binning 1.
+        - BSize_2 (float): Pixel binning 2.
+        - SampleDistance (float): Sample to detector distance in meters.
+        - WaveLength (float): Wavelength of beam in meters.
+        - DetectorRotation_1 (float): rot2 of pyFAI.
+        - DetectorRotation_2 (float): rot1 of pyFAI.
+        - DetectorRotation_3 (float): rot3 of pyFAI.
+        - method (str): Integration method to be used by pyFAI (e.g., "bbox", "csr").
+        - integration_options (dict): Additional options for pyFAI integration.
+        - do_variance_formula (bool): Flag to enable variance calculation using a formula. Default is `False`.
+        - variance_formula (str): Formula for calculating variance in the dataset.
+        - save_sum (bool): To save or not the arrays sum_signal, sum_normalization and sum_variance.
+    Outputs:
+        - dataset_sum_signal (numpy.ndarray): Summed signal dataset after azimuthal integration.
+        - dataset_sum_normalization (numpy.ndarray): Summed normalization dataset after azimuthal integration.
+        - dataset_sum_variance (numpy.ndarray): Summed variance dataset after azimuthal integration.
+        - radial_array (numpy.ndarray): Radial axis array for the integrated data.
+        - azimuth_array (numpy.ndarray): Azimuthal axis array for the integrated data.
+    """
+
+    def run(self):
+        super().run(processing_type="azim")
+
+    def get_processing_inputs(
+        self,
+    ) -> dict:
+        params_azimuthalintegrator = {
+            "Center_1": self.get_parameter("Center_1"),
+            "Center_2": self.get_parameter("Center_2"),
+            "PSize_1": self.get_parameter("PSize_1"),
+            "PSize_2": self.get_parameter("PSize_2"),
+            "SampleDistance": self.get_parameter("SampleDistance"),
+            "WaveLength": self.get_parameter("WaveLength"),
+            "BSize_1": self.get_parameter("BSize_1"),
+            "BSize_2": self.get_parameter("BSize_2"),
+            "DetectorRotation_1": self.get_parameter("DetectorRotation_1"),
+            "DetectorRotation_2": self.get_parameter("DetectorRotation_2"),
+            "DetectorRotation_3": self.get_parameter("DetectorRotation_3"),
+        }
+
+        azimuthal_integrator = get_persistent_azimuthal_integrator(
+            data_signal_shape=self.dataset_signal[0].shape,
+            **params_azimuthalintegrator,
+        )
+
+        processing_params = {
+            "filename_mask": self.get_input_value(
+                "filename_mask",
+                self.get_mask_beamstop_filename(),
+            ),
+            "filename_dark": self.get_input_value(
+                "filename_dark",
+                self.get_dark_filename(),
+            ),
+            "Dummy": self.get_parameter("Dummy"),
+            "DDummy": self.get_parameter("DDummy"),
+            "npt2_rad": self.get_parameter("npt2_rad"),
+            "npt2_azim": self.get_parameter("npt2_azim"),
+            "unit": self.get_parameter("unit", defaut="q_nm^-1"),
+            "method": self.get_input_value("method", get_gpu_method()),
+            "integration_options": self.get_input_value("integration_options", {}),
+            "do_variance_formula": self.get_input_value("do_variance_formula", False),
+            "variance_formula": self.get_parameter("variance_formula"),
+            "datatype": self.get_input_value("datatype", "float32"),
+            "binning": (
+                self.get_parameter(
+                    "BSize_1",
+                ),
+                self.get_parameter(
+                    "BSize_2",
+                ),
+            ),
+            "save_variance": self.get_input_value("save_variance", False),
+            "save_sum": self.get_input_value("save_sum", False),
+            "azimuthal_integrator": azimuthal_integrator,
+            **params_azimuthalintegrator,
+        }
+        if not processing_params.get("npt2_rad"):
+            processing_params["npt2_rad"] = guess_npt2_rad(
+                azimuthal_integrator=azimuthal_integrator
+            )
+        if not processing_params.get("npt2_azim"):
+            processing_params["npt2_azim"] = DEFAULT_NPT_AZIM
+        if not processing_params.get("method"):
+            processing_params["method"] = get_gpu_method()
+        return processing_params
+
+    def process(self) -> None:
+        do_process = super().process()
+        if do_process is False:
+            return
+
+        with ExitStack() as stack:
+            self.bench_process = self.Benchmark(
+                nb_frames=len(self.dataset_signal), benchmark_name="processing"
+            )
+            stack.enter_context(self.bench_process)
+
+            processing_params = self.get_processing_inputs()
+            self.processing_params = processing_params
+
+            if self.dataset_variance is not None:
+                dataset_variance = self.dataset_variance
+            elif self.dataset_sigma is not None:
+                dataset_sigma = self.dataset_sigma  # noqa
+                Dummy = processing_params.get("Dummy", 0.0)  # noqa
+                dataset_variance = numexpr.evaluate(
+                    "where(dataset_sigma <= 0.0, Dummy, dataset_sigma ** 2)"
+                )
+            else:
+                dataset_variance = None
+
+            self.log_info("Performing 2D integration...")
+
+            (
+                dataset_signal_azim,
+                dataset_variance_azim,
+                dataset_sigma_azim,
+                dataset_sumsignal_azim,
+                dataset_sumnorm_azim,
+                dataset_sumvariance_azim,
+                array_radial,
+                array_azim,
+            ) = process_dataset_azim(
+                dataset_signal=self.dataset_signal,
+                dataset_variance=dataset_variance,
+                **processing_params,
+            )
+
+            self.outputs.dataset_signal = dataset_signal_azim
+            self.outputs.dataset_variance = dataset_variance_azim
+            self.outputs.dataset_sigma = dataset_sigma_azim
+            self.outputs.dataset_sum_signal = dataset_sumsignal_azim
+            self.outputs.dataset_sum_normalization = dataset_sumnorm_azim
+            self.outputs.dataset_sum_variance = dataset_sumvariance_azim
+            self.outputs.radial_array = array_radial
+            self.outputs.azimuth_array = array_azim
+
+        self._log_benchmark(self.bench_process)
+
+    def save(self) -> None:
+        do_save = super().save()
+        if not do_save:
+            return
+
+        filename_output, h5path_nxdata = self.links["destination"]["nxdata"].split("::")
+        params = {
+            "filename": filename_output,
+            "name": h5path_nxdata,
+            "retry_timeout": 0.1,
+            "mode": "a",
+        }
+        with open_item_silx(**params) as nexus_data_grp:
+            self._update_dataset(
+                added_dataset=self.outputs.dataset_sum_signal,
+                h5_group=nexus_data_grp,
+                h5_dataset_name="sum_signal",
+                index_read=self.index_range_last,
+            )
+
+            self._update_dataset(
+                added_dataset=self.outputs.dataset_sum_normalization,
+                h5_group=nexus_data_grp,
+                h5_dataset_name="sum_normalization",
+                index_read=self.index_range_last,
+            )
+
+            self._update_dataset(
+                added_dataset=self.outputs.dataset_sum_variance,
+                h5_group=nexus_data_grp,
+                h5_dataset_name="sum_variance",
+                index_read=self.index_range_last,
+            )
+
+            unit = self.get_parameter("unit")
+            radial_unit = to_unit(unit)
+
+            # Update radial and azimuthal arrays only once
+            if radial_unit and self.outputs.radial_array is not None:
+                if radial_unit.short_name not in nexus_data_grp:
+                    radial_dset = nexus_data_grp.create_dataset(
+                        name=radial_unit.short_name,
+                        data=self.outputs.radial_array,
+                    )
+                    radial_dset.attrs["axis"] = "3"
+                    radial_dset.attrs["interpretation"] = "scalar"
+                    radial_dset.attrs["unit"] = str(radial_unit)
+
+            if self.outputs.azimuth_array is not None:
+                if "chi" not in nexus_data_grp:
+                    chi_dset = nexus_data_grp.create_dataset(
+                        name="chi",
+                        data=self.outputs.azimuth_array,
+                    )
+                    chi_dset.attrs["axis"] = "2"
+                    chi_dset.attrs["interpretation"] = "scalar"
+                    chi_dset.attrs["unit"] = "deg"
+
+                    nexus_data_grp.attrs["axes"] = [".", "chi", radial_unit.short_name]
+
+    def _get_last_worker(self):
+        return _get_persistent_pyfai_worker(**self.get_processing_inputs())

ewoksid02/tasks/cavingtask.py

@@ -0,0 +1,170 @@
+from contextlib import ExitStack
+
+import numpy
+
+from ewoksid02.tasks.id02processingtask import ID02ProcessingTask
+from ewoksid02.utils.caving import process_data_caving
+
+DEFAULT_ALGORITHM = "numpy"
+
+
+class CavingTask(
+    ID02ProcessingTask,
+    optional_input_names=[
+        "Dummy",
+        "Center_1",
+        "Center_2",
+        "filename_mask_static",
+        "filename_mask_reference",
+        "flip_caving",
+        "algorithm",
+    ],
+):
+    """The `CavingTask` class is responsible for applying a "caving" operation to datasets in the ID02 SAXS pipeline.
+    The caving is applied to those pixels whose intensity matches with a dummy value + those pixels provided by a mask file.
+
+    Optional Inputs:
+        - Dummy (float): Value to replace invalid pixels in the dataset.
+        - Center_1 (float): Beam center in the first dimension.
+        - Center_2 (float): Beam center in the second dimension.
+        - filename_mask_static (str): Path to the mask file used for the caving operation.
+        - filename_mask_reference (str): Path to the reference mask file (kind of a negative mask).
+        - flip_caving (bool): Cave the image with its flipped projection, both horizontal and vertical. WARNING: it is physically not correct!
+        - algorithm (str): Implementation to perform the caving (numpy or cupy).
+    """
+
+    def run(self, processing_type: str = "caving"):
+        super().run(processing_type=processing_type)
+
+    def get_processing_inputs(self) -> dict:
+        processing_params = {
+            "Dummy": self.get_parameter("Dummy"),
+            "Center_1": self.get_parameter("Center_1"),
+            "Center_2": self.get_parameter("Center_2"),
+            "filename_mask_static": self.get_input_value("filename_mask_static", None),
+            "filename_mask_reference": self.get_input_value(
+                "filename_mask_reference", None
+            ),
+            "flip_caving": self.get_input_value(
+                "flip_caving",
+                bool(self.get_from_headers("cave_flip")),
+            ),
+            "algorithm": self.get_input_value("algorithm", DEFAULT_ALGORITHM),
+        }
+        return processing_params
+
+    def process(self) -> None:
+        do_process = super().process()
+        if do_process is False:
+            return
+
+        with ExitStack() as stack:
+            self.bench_process = self.Benchmark(
+                nb_frames=len(self.dataset_signal), benchmark_name="processing"
+            )
+            stack.enter_context(self.bench_process)
+            processing_params = self.get_processing_inputs()
+            self.processing_params = processing_params
+
+            self.log_info("Performing caving...")
+            caved_dataset = process_data_caving(
+                data=self.dataset_signal,
+                **processing_params,
+            )
+
+            if not self.get_input_value("save_variance", False):
+                caved_dataset_variance = None
+            elif self.dataset_variance is not None:
+                caved_dataset_variance = process_data_caving(
+                    data=self.dataset_variance,
+                    **processing_params,
+                )
+            else:
+                caved_dataset_variance = numpy.zeros_like(caved_dataset)
+
+            if self.dataset_sigma is not None:
+                caved_dataset_sigma = process_data_caving(
+                    data=self.dataset_sigma,
+                    **processing_params,
+                )
+            else:
+                caved_dataset_sigma = numpy.zeros_like(caved_dataset)
+
+            self.log_debug("Caving processing done")
+            self.outputs.dataset_signal = caved_dataset
+            self.outputs.dataset_variance = caved_dataset_variance
+            self.outputs.dataset_sigma = caved_dataset_sigma
+
+        self._log_benchmark(self.bench_process)
+
+    def save(self) -> None:
+        do_save = super().save()
+        if not do_save:
+            return
+
+
+class CavingGapsTask(
+    CavingTask,
+):
+    """The `CavingGapsTask` inherits 'CavingTask'.
+    Here, it will take the parameters from the headers to perform the caving operation
+    and cover the gaps in the dataset and avoid the beamstop. Hence, no explicit mask filenames are needed.
+    """
+
+    def run(self, processing_type: str = "gaps"):
+        super().run(processing_type=processing_type)
+
+    def get_processing_inputs(self) -> dict:
+        processing_params = {
+            "Dummy": self.get_parameter("Dummy"),
+            "Center_1": self.get_parameter("Center_1"),
+            "Center_2": self.get_parameter(
+                "Center_2",
+            ),
+            "filename_mask_static": self.get_input_value(
+                "filename_mask_static",
+                self.get_mask_gaps_filename(),
+            ),
+            "filename_mask_reference": self.get_input_value(
+                "filename_mask_reference",
+                self.get_mask_beamstop_filename(),
+            ),
+            "flip_caving": self.get_input_value(
+                "flip_caving",
+                bool(self.get_from_headers("nw_cave_flip")),
+            ),
+            "algorithm": self.get_input_value("algorithm", DEFAULT_ALGORITHM),
+        }
+
+        return processing_params
+
+
+class CavingBeamstopTask(
+    CavingTask,
+):
+    """The `CavingBeamstopTask` inherits 'CavingTask'.
+    Here, it will take the parameters from the headers to perform the caving operation
+    and cover the beamstop. Hence, no explicit mask filename is needed.
+    """
+
+    def run(self, processing_type: str = "cave"):
+        super().run(processing_type=processing_type)
+
+    def get_processing_inputs(self) -> dict:
+        processing_params = {
+            "Dummy": self.get_parameter("Dummy"),
+            "Center_1": self.get_parameter("Center_1"),
+            "Center_2": self.get_parameter("Center_2"),
+            "filename_mask_static": self.get_input_value(
+                "filename_mask_static",
+                self.get_mask_beamstop_filename(),
+            ),
+            "filename_mask_reference": None,
+            "flip_caving": self.get_input_value(
+                "flip_caving",
+                bool(self.get_from_headers("nw_cave_flip")),
+            ),
+            "algorithm": self.get_input_value("algorithm", DEFAULT_ALGORITHM),
+        }
+
+        return processing_params