ewoksid02 0.1.0__py3-none-any.whl

ewoksid02/tests/test_2scat_node.py

@@ -0,0 +1,119 @@
+from ewoksid02.tasks.secondaryscatteringtask import SecondaryScatteringTask
+
+from .utils import check_h5groups_common, check_h5groups_equivalent, execute_ewoks
+
+
+def test_eiger2_2scat_numpy(
+    inputs_task_generic,
+    inputs_task_2scat,
+    tmp_path,
+    dataset_signal_norm,
+    dataset_sigma_norm,
+    filename_processed_2scat_full,
+):
+    processing_filename_numpy = str(tmp_path / "id02test_eiger2_2scat_numpy.h5")
+    inputs_2scat_numpy = {
+        **inputs_task_generic,
+        **inputs_task_2scat,
+        "processing_filename": processing_filename_numpy,
+        "dataset_signal": dataset_signal_norm,
+        "dataset_sigma": dataset_sigma_norm,
+    }
+    task_2scat_numpy = SecondaryScatteringTask(inputs_2scat_numpy)
+    task_2scat_numpy.run()
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{processing_filename_numpy}?path=/entry_0000/PyFAI/result_2scat/",
+        url_test=f"silx://{processing_filename_numpy}?path=/entry_0000/PyFAI/result_2scat/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_2scat_full,
+        filename_test=processing_filename_numpy,
+    )
+
+
+def test_eiger2_2scat_cupy(
+    cupy_available,
+    inputs_task_generic,
+    inputs_task_2scat,
+    tmp_path,
+    dataset_signal_norm,
+    dataset_sigma_norm,
+    filename_processed_2scat_full,
+):
+    if not cupy_available:
+        return
+
+    processing_filename_cupy = str(tmp_path / "id02test_eiger2_2scat_numpy.h5")
+    inputs_2scat_cupy = {
+        **inputs_task_generic,
+        **inputs_task_2scat,
+        "processing_filename": processing_filename_cupy,
+        "dataset_signal": dataset_signal_norm,
+        "dataset_sigma": dataset_sigma_norm,
+    }
+    inputs_2scat_cupy["algorithm"] = "cupy"
+    task_2scat_cupy = SecondaryScatteringTask(inputs_2scat_cupy)
+    task_2scat_cupy.run()
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{processing_filename_cupy}?path=/entry_0000/PyFAI/result_2scat/",
+        url_test=f"silx://{processing_filename_cupy}?path=/entry_0000/PyFAI/result_2scat/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_2scat_full,
+        filename_test=processing_filename_cupy,
+    )
+
+
+def test_eiger2_2scat_workflow(
+    workflow_norm_2scat,
+    inputs_task_generic,
+    inputs_task_norm,
+    inputs_task_2scat,
+    tmp_path,
+    filename_processed_norm_reference,
+    filename_processed_2scat_full,
+):
+    inputs = []
+    for key, value in inputs_task_generic.items():
+        inputs.append({"name": key, "value": value, "all": True})
+    for key, value in inputs_task_norm.items():
+        inputs.append({"name": key, "value": value, "id": "norm"})
+    for key, value in inputs_task_2scat.items():
+        inputs.append({"name": key, "value": value, "id": "2scat"})
+    filename_processing_norm = str(tmp_path / "id02test_eiger2_norm.h5")
+    filename_processing_2scat = str(tmp_path / "id02test_eiger2_2scat.h5")
+    inputs.append(
+        {"name": "processing_filename", "value": filename_processing_norm, "id": "norm"}
+    )
+    inputs.append(
+        {
+            "name": "processing_filename",
+            "value": filename_processing_2scat,
+            "id": "2scat",
+        }
+    )
+    _ = execute_ewoks(
+        graph=workflow_norm_2scat,
+        inputs=inputs,
+    )
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_norm_reference}?path=/entry_0000/PyFAI/result_norm/",
+        url_test=f"silx://{filename_processing_norm}?path=/entry_0000/PyFAI/result_norm/",
+    )
+    check_h5groups_common(
+        filename_reference=filename_processed_norm_reference,
+        filename_test=filename_processing_norm,
+    )
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_2scat_full}?path=/entry_0000/PyFAI/result_2scat/",
+        url_test=f"silx://{filename_processing_2scat}?path=/entry_0000/PyFAI/result_2scat/",
+    )
+    check_h5groups_common(
+        filename_reference=filename_processed_2scat_full,
+        filename_test=filename_processing_2scat,
+    )

ewoksid02/tests/test_ave_node.py

@@ -0,0 +1,106 @@
+from ewoksid02.tasks.averagetask import AverageTask
+
+from .utils import check_h5groups_common, check_h5groups_equivalent, execute_ewoks
+
+
+def test_eiger2_ave_full(
+    inputs_task_generic,
+    inputs_task_ave,
+    tmp_path,
+    dataset_signal_azim_new,
+    dataset_sigma_azim_new,
+    dataset_sumsignal_azim_new,
+    dataset_sumnorm_azim_new,
+    dataset_sumvariance_azim_new,
+    dataset_radial_array,
+    dataset_azimuthal_array,
+    filename_processed_ave_full,
+):
+    processing_filename = str(tmp_path / "id02test_eiger2_ave.h5")
+    inputs = {
+        **inputs_task_generic,
+        **inputs_task_ave,
+        "processing_filename": processing_filename,
+        "dataset_signal": dataset_signal_azim_new,
+        "dataset_sigma": dataset_sigma_azim_new,
+        "dataset_sum_signal": dataset_sumsignal_azim_new,
+        "dataset_sum_normalization": dataset_sumnorm_azim_new,
+        "dataset_sum_variance": dataset_sumvariance_azim_new,
+        "radial_array": dataset_radial_array,
+        "azimuth_array": dataset_azimuthal_array,
+    }
+    task_azim = AverageTask(inputs)
+    task_azim.run()
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_ave_full}?path=/entry_0000/PyFAI/result_ave/",
+        url_test=f"silx://{processing_filename}?path=/entry_0000/PyFAI/result_ave/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_ave_full,
+        filename_test=processing_filename,
+    )
+
+
+def test_eiger2_ave_workflow(
+    workflow_norm_2scat_cave_azim_ave,
+    inputs_task_generic,
+    inputs_task_norm,
+    inputs_task_2scat,
+    inputs_task_cave,
+    inputs_task_azim,
+    inputs_task_ave,
+    tmp_path,
+    filename_processed_norm_reference,
+    filename_processed_2scat_full,
+    filename_processed_cave_full,
+    filename_processed_azim_full,
+    filename_processed_ave_full,
+):
+    inputs = []
+    for key, value in inputs_task_generic.items():
+        inputs.append({"name": key, "value": value, "all": True})
+    for key, value in inputs_task_norm.items():
+        inputs.append({"name": key, "value": value, "id": "norm"})
+    for key, value in inputs_task_2scat.items():
+        inputs.append({"name": key, "value": value, "id": "2scat"})
+    for key, value in inputs_task_cave.items():
+        inputs.append({"name": key, "value": value, "id": "cave"})
+    for key, value in inputs_task_azim.items():
+        inputs.append({"name": key, "value": value, "id": "azim"})
+    for key, value in inputs_task_ave.items():
+        inputs.append({"name": key, "value": value, "id": "ave"})
+    filename_processing_norm = str(tmp_path / "id02test_eiger2_norm.h5")
+    filename_processing_2scat = str(tmp_path / "id02test_eiger2_2scat.h5")
+    filename_processing_cave = str(tmp_path / "id02test_eiger2_cave.h5")
+    filename_processing_azim = str(tmp_path / "id02test_eiger2_azim.h5")
+    filename_processing_ave = str(tmp_path / "id02test_eiger2_ave.h5")
+    for name, value, id_ in [
+        ("processing_filename", filename_processing_norm, "norm"),
+        ("processing_filename", filename_processing_2scat, "2scat"),
+        ("processing_filename", filename_processing_cave, "cave"),
+        ("processing_filename", filename_processing_azim, "azim"),
+        ("processing_filename", filename_processing_ave, "ave"),
+    ]:
+        inputs.append({"name": name, "value": value, "id": id_})
+    _ = execute_ewoks(
+        graph=workflow_norm_2scat_cave_azim_ave,
+        inputs=inputs,
+    )
+    for ref_file, test_file, proc_type in [
+        (filename_processed_norm_reference, filename_processing_norm, "norm"),
+        (filename_processed_2scat_full, filename_processing_2scat, "2scat"),
+        (filename_processed_cave_full, filename_processing_cave, "cave"),
+        (filename_processed_azim_full, filename_processing_azim, "azim"),
+        (filename_processed_ave_full, filename_processing_ave, "ave"),
+    ]:
+        check_h5groups_equivalent(
+            url_reference=f"silx://{ref_file}?path=/entry_0000/PyFAI/result_{proc_type}",
+            url_test=f"silx://{test_file}?path=/entry_0000/PyFAI/result_{proc_type}",
+        )
+
+        check_h5groups_common(
+            filename_reference=ref_file,
+            filename_test=test_file,
+        )

ewoksid02/tests/test_azim_node.py

@@ -0,0 +1,89 @@
+from ewoksid02.tasks.azimuthaltask import AzimuthalTask
+
+from .utils import check_h5groups_common, check_h5groups_equivalent, execute_ewoks
+
+
+def test_eiger2_azim_full(
+    inputs_task_generic,
+    inputs_task_azim,
+    tmp_path,
+    dataset_signal_cave_new,
+    dataset_sigma_cave_new,
+    filename_processed_azim_full,
+):
+    processing_filename = str(tmp_path / "id02test_eiger2_azim.h5")
+    inputs = {
+        **inputs_task_generic,
+        **inputs_task_azim,
+        "processing_filename": processing_filename,
+        "dataset_signal": dataset_signal_cave_new,
+        "dataset_sigma": dataset_sigma_cave_new,
+    }
+    task_azim = AzimuthalTask(inputs)
+    task_azim.run()
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_azim_full}?path=/entry_0000/PyFAI/result_azim/",
+        url_test=f"silx://{processing_filename}?path=/entry_0000/PyFAI/result_azim/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_azim_full,
+        filename_test=processing_filename,
+    )
+
+
+def test_eiger2_azim_workflow(
+    workflow_norm_2scat_cave_azim,
+    inputs_task_generic,
+    inputs_task_norm,
+    inputs_task_2scat,
+    inputs_task_cave,
+    inputs_task_azim,
+    tmp_path,
+    filename_processed_norm_reference,
+    filename_processed_2scat_full,
+    filename_processed_cave_full,
+    filename_processed_azim_full,
+):
+    inputs = []
+    for key, value in inputs_task_generic.items():
+        inputs.append({"name": key, "value": value, "all": True})
+    for key, value in inputs_task_norm.items():
+        inputs.append({"name": key, "value": value, "id": "norm"})
+    for key, value in inputs_task_2scat.items():
+        inputs.append({"name": key, "value": value, "id": "2scat"})
+    for key, value in inputs_task_cave.items():
+        inputs.append({"name": key, "value": value, "id": "cave"})
+    for key, value in inputs_task_azim.items():
+        inputs.append({"name": key, "value": value, "id": "azim"})
+    filename_processing_norm = str(tmp_path / "id02test_eiger2_norm.h5")
+    filename_processing_2scat = str(tmp_path / "id02test_eiger2_2scat.h5")
+    filename_processing_cave = str(tmp_path / "id02test_eiger2_cave.h5")
+    filename_processing_azim = str(tmp_path / "id02test_eiger2_azim.h5")
+    for name, value, id_ in [
+        ("processing_filename", filename_processing_norm, "norm"),
+        ("processing_filename", filename_processing_2scat, "2scat"),
+        ("processing_filename", filename_processing_cave, "cave"),
+        ("processing_filename", filename_processing_azim, "azim"),
+    ]:
+        inputs.append({"name": name, "value": value, "id": id_})
+    _ = execute_ewoks(
+        graph=workflow_norm_2scat_cave_azim,
+        inputs=inputs,
+    )
+    for ref_file, test_file, proc_type in [
+        (filename_processed_norm_reference, filename_processing_norm, "norm"),
+        (filename_processed_2scat_full, filename_processing_2scat, "2scat"),
+        (filename_processed_cave_full, filename_processing_cave, "cave"),
+        (filename_processed_azim_full, filename_processing_azim, "azim"),
+    ]:
+        check_h5groups_equivalent(
+            url_reference=f"silx://{ref_file}?path=/entry_0000/PyFAI/result_{proc_type}",
+            url_test=f"silx://{test_file}?path=/entry_0000/PyFAI/result_{proc_type}",
+        )
+
+        check_h5groups_common(
+            filename_reference=ref_file,
+            filename_test=test_file,
+        )

ewoksid02/tests/test_cave_node.py

@@ -0,0 +1,118 @@
+from ewoksid02.tasks.cavingtask import CavingBeamstopTask
+
+from .utils import check_h5groups_common, check_h5groups_equivalent, execute_ewoks
+
+
+def test_eiger2_cave_numpy(
+    inputs_task_generic,
+    inputs_task_cave,
+    tmp_path,
+    dataset_signal_2scat,
+    dataset_sigma_2scat,
+    filename_processed_cave_full,
+):
+    processing_filename_cave_numpy = str(tmp_path / "id02test_eiger2_cave.h5")
+    inputs_cave_numpy = {
+        **inputs_task_generic,
+        **inputs_task_cave,
+        "processing_filename": processing_filename_cave_numpy,
+        "dataset_signal": dataset_signal_2scat,
+        "dataset_sigma": dataset_sigma_2scat,
+    }
+    task_cave_numpy = CavingBeamstopTask(inputs_cave_numpy)
+    task_cave_numpy.run()
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_cave_full}?path=/entry_0000/PyFAI/result_cave/",
+        url_test=f"silx://{processing_filename_cave_numpy}?path=/entry_0000/PyFAI/result_cave/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_cave_full,
+        filename_test=processing_filename_cave_numpy,
+    )
+
+
+def test_eiger2_cave_cupy(
+    cupy_available,
+    inputs_task_generic,
+    inputs_task_cave,
+    tmp_path,
+    dataset_signal_2scat,
+    dataset_sigma_2scat,
+    filename_processed_cave_full,
+):
+    if not cupy_available:
+        return
+
+    processing_filename_cave_cupy = str(tmp_path / "id02test_eiger2_cave.h5")
+    inputs_cave_cupy = {
+        **inputs_task_generic,
+        **inputs_task_cave,
+        "processing_filename": processing_filename_cave_cupy,
+        "dataset_signal": dataset_signal_2scat,
+        "dataset_sigma": dataset_sigma_2scat,
+    }
+    inputs_cave_cupy["algorithm"] = "cupy"
+    task_cave_cupy = CavingBeamstopTask(inputs_cave_cupy)
+    task_cave_cupy.run()
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_cave_full}?path=/entry_0000/PyFAI/result_cave/",
+        url_test=f"silx://{processing_filename_cave_cupy}?path=/entry_0000/PyFAI/result_cave/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_cave_full,
+        filename_test=processing_filename_cave_cupy,
+    )
+
+
+def test_eiger2_cave_workflow(
+    workflow_norm_2scat_cave,
+    inputs_task_generic,
+    inputs_task_norm,
+    inputs_task_2scat,
+    inputs_task_cave,
+    tmp_path,
+    filename_processed_norm_reference,
+    filename_processed_2scat_full,
+    filename_processed_cave_full,
+):
+    inputs = []
+    for key, value in inputs_task_generic.items():
+        inputs.append({"name": key, "value": value, "all": True})
+    for key, value in inputs_task_norm.items():
+        inputs.append({"name": key, "value": value, "id": "norm"})
+    for key, value in inputs_task_2scat.items():
+        inputs.append({"name": key, "value": value, "id": "2scat"})
+    for key, value in inputs_task_cave.items():
+        inputs.append({"name": key, "value": value, "id": "cave"})
+
+    filename_processing_norm = str(tmp_path / "id02test_eiger2_norm.h5")
+    filename_processing_2scat = str(tmp_path / "id02test_eiger2_2scat.h5")
+    filename_processing_cave = str(tmp_path / "id02test_eiger2_cave.h5")
+    for name, value, id_ in [
+        ("processing_filename", filename_processing_norm, "norm"),
+        ("processing_filename", filename_processing_2scat, "2scat"),
+        ("processing_filename", filename_processing_cave, "cave"),
+    ]:
+        inputs.append({"name": name, "value": value, "id": id_})
+    _ = execute_ewoks(
+        graph=workflow_norm_2scat_cave,
+        inputs=inputs,
+    )
+    for ref_file, test_file, proc_type in [
+        (filename_processed_norm_reference, filename_processing_norm, "norm"),
+        (filename_processed_2scat_full, filename_processing_2scat, "2scat"),
+        (filename_processed_cave_full, filename_processing_cave, "cave"),
+    ]:
+        check_h5groups_equivalent(
+            url_reference=f"silx://{ref_file}?path=/entry_0000/PyFAI/result_{proc_type}",
+            url_test=f"silx://{test_file}?path=/entry_0000/PyFAI/result_{proc_type}",
+        )
+
+        check_h5groups_common(
+            filename_reference=ref_file,
+            filename_test=test_file,
+        )

ewoksid02/tests/test_norm_node.py

@@ -0,0 +1,190 @@
+from ewoksid02.tasks.normalizationtask import NormalizationTask
+
+from .utils import check_h5groups_common, check_h5groups_equivalent, execute_ewoks
+
+
+def test_eiger2_normalization_cython(
+    inputs_task_generic,
+    inputs_task_norm,
+    tmp_path,
+    filename_processed_norm_reference,
+):
+    processing_filename_cython = str(tmp_path / "id02test_eiger2_norm_cython.h5")
+    inputs_cython = {
+        **inputs_task_generic,
+        **inputs_task_norm,
+        "processing_filename": processing_filename_cython,
+    }
+    task_norm_cython = NormalizationTask(inputs_cython)
+    task_norm_cython.run()
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_norm_reference}?path=/entry_0000/PyFAI/result_norm/",
+        url_test=f"silx://{processing_filename_cython}?path=/entry_0000/PyFAI/result_norm/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_norm_reference,
+        filename_test=processing_filename_cython,
+    )
+
+
+def test_eiger2_normalization_cupy(
+    cupy_available,
+    inputs_task_generic,
+    inputs_task_norm,
+    tmp_path,
+    filename_processed_norm_reference,
+):
+    if not cupy_available:
+        return
+
+    processing_filename_cupy = str(tmp_path / "id02test_eiger2_norm_cupy.h5")
+    inputs_cupy = {
+        **inputs_task_generic,
+        **inputs_task_norm,
+        "processing_filename": processing_filename_cupy,
+    }
+    inputs_cupy["algorithm"] = "cupy"
+    task_norm_cupy = NormalizationTask(inputs_cupy)
+    task_norm_cupy.run()
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_norm_reference}?path=/entry_0000/PyFAI/result_norm/",
+        url_test=f"silx://{processing_filename_cupy}?path=/entry_0000/PyFAI/result_norm/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_norm_reference,
+        filename_test=processing_filename_cupy,
+    )
+
+
+def test_eiger2_normalization_numpy(
+    cupy_available,
+    inputs_task_generic,
+    inputs_task_norm,
+    tmp_path,
+    filename_processed_norm_reference,
+):
+    if not cupy_available:
+        return
+
+    processing_filename_numpy = str(tmp_path / "id02test_eiger2_norm_numpy.h5")
+    inputs_numpy = {
+        **inputs_task_generic,
+        **inputs_task_norm,
+        "processing_filename": processing_filename_numpy,
+    }
+    inputs_numpy["algorithm"] = "cupy"
+    task_norm_numpy = NormalizationTask(inputs_numpy)
+    task_norm_numpy.run()
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_norm_reference}?path=/entry_0000/PyFAI/result_norm/",
+        url_test=f"silx://{processing_filename_numpy}?path=/entry_0000/PyFAI/result_norm/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_norm_reference,
+        filename_test=processing_filename_numpy,
+    )
+
+
+def test_eiger2_normalization_workflow(
+    workflow_norm,
+    inputs_task_generic,
+    inputs_task_norm,
+    tmp_path,
+    filename_processed_norm_reference,
+):
+    inputs = []
+    for key, value in inputs_task_generic.items():
+        inputs.append({"name": key, "value": value, "all": True})
+    for key, value in inputs_task_norm.items():
+        inputs.append({"name": key, "value": value, "id": "norm"})
+    filename_processing_norm = str(tmp_path / "id02test_eiger2_norm.h5")
+    inputs.append(
+        {"name": "processing_filename", "value": filename_processing_norm, "id": "norm"}
+    )
+    _ = execute_ewoks(
+        graph=workflow_norm,
+        inputs=inputs,
+    )
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_norm_reference}?path=/entry_0000/PyFAI/result_norm/",
+        url_test=f"silx://{filename_processing_norm}?path=/entry_0000/PyFAI/result_norm/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_norm_reference,
+        filename_test=filename_processing_norm,
+    )
+
+
+def test_eiger2_normalization_workflow_loop(
+    workflow_norm,
+    inputs_task_generic,
+    inputs_task_norm,
+    tmp_path,
+    filename_processed_norm_reference,
+):
+    workflow_norm["links"] = [
+        {
+            "source": "norm",
+            "target": "norm",
+            "conditions": [{"source_output": "continue_pipeline", "value": True}],
+            "map_all_data": True,
+        }
+    ]
+
+    inputs = []
+    for key, value in inputs_task_generic.items():
+        inputs.append({"name": key, "value": value, "all": True})
+    for key, value in inputs_task_norm.items():
+        inputs.append({"name": key, "value": value, "id": "norm"})
+    filename_processing_norm = str(tmp_path / "id02test_eiger2_norm.h5")
+    inputs.append(
+        {"name": "processing_filename", "value": filename_processing_norm, "id": "norm"}
+    )
+    inputs.append({"name": "reading_node", "value": True, "id": "norm"})
+
+    _ = execute_ewoks(
+        graph=workflow_norm,
+        inputs=inputs,
+    )
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_norm_reference}?path=/entry_0000/PyFAI/result_norm/",
+        url_test=f"silx://{filename_processing_norm}?path=/entry_0000/PyFAI/result_norm/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_norm_reference,
+        filename_test=filename_processing_norm,
+    )
+
+
+def test_eiger2_normalization_subscan2(
+    inputs_task_generic_subscan2,
+    inputs_task_norm,
+    tmp_path,
+    filename_processed_norm_dahu_subscan2,
+):
+    processing_filename_cython = str(tmp_path / "id02test_eiger2_norm_subscan2.h5")
+    inputs_cython = {
+        **inputs_task_generic_subscan2,
+        **inputs_task_norm,
+        "processing_filename": processing_filename_cython,
+    }
+    task_norm_cython = NormalizationTask(inputs_cython)
+    task_norm_cython.run()
+
+    check_h5groups_equivalent(
+        url_reference=f"silx://{filename_processed_norm_dahu_subscan2}?path=/entry_0000/PyFAI/result_norm/&slice=0,2",
+        url_test=f"silx://{processing_filename_cython}?path=/entry_0000/PyFAI/result_norm/",
+    )
+
+    check_h5groups_common(
+        filename_reference=filename_processed_norm_dahu_subscan2,
+        filename_test=processing_filename_cython,
+    )

ewoksid02/tests/test_saxs.py

@@ -0,0 +1,69 @@
+from .utils import check_h5groups_common, check_h5groups_equivalent, execute_ewoks
+
+
+def test_eiger2_saxs_loop(
+    workflow_saxs_loop,
+    inputs_task_generic,
+    inputs_task_norm,
+    inputs_task_2scat,
+    inputs_task_cave,
+    inputs_task_azim,
+    inputs_task_ave,
+    tmp_path,
+    filename_processed_norm_reference,
+    filename_processed_2scat_full,
+    filename_processed_cave_full,
+    filename_processed_azim_full,
+    filename_processed_ave_full,
+):
+    inputs = []
+    inputs_task_generic["max_slice_size"] = 1
+    inputs_task_generic["range_index_read"] = [0, 2]
+    for key, value in inputs_task_generic.items():
+        inputs.append({"name": key, "value": value, "all": True})
+    for key, value in inputs_task_norm.items():
+        inputs.append({"name": key, "value": value, "id": "norm"})
+    for key, value in inputs_task_2scat.items():
+        inputs.append({"name": key, "value": value, "id": "2scat"})
+    for key, value in inputs_task_cave.items():
+        inputs.append({"name": key, "value": value, "id": "cave"})
+    for key, value in inputs_task_azim.items():
+        inputs.append({"name": key, "value": value, "id": "azim"})
+    for key, value in inputs_task_ave.items():
+        inputs.append({"name": key, "value": value, "id": "ave"})
+    filename_processing_norm = str(tmp_path / "id02test_eiger2_norm.h5")
+    filename_processing_2scat = str(tmp_path / "id02test_eiger2_2scat.h5")
+    filename_processing_cave = str(tmp_path / "id02test_eiger2_cave.h5")
+    filename_processing_azim = str(tmp_path / "id02test_eiger2_azim.h5")
+    filename_processing_ave = str(tmp_path / "id02test_eiger2_ave.h5")
+    filename_processing_scalers = str(tmp_path / "id02test_eiger2_scalers.h5")
+    for name, value, id_ in [
+        ("processing_filename", filename_processing_norm, "norm"),
+        ("processing_filename", filename_processing_2scat, "2scat"),
+        ("processing_filename", filename_processing_cave, "cave"),
+        ("processing_filename", filename_processing_azim, "azim"),
+        ("processing_filename", filename_processing_ave, "ave"),
+        ("processing_filename", filename_processing_scalers, "scalers"),
+    ]:
+        inputs.append({"name": name, "value": value, "id": id_})
+
+    _ = execute_ewoks(
+        graph=workflow_saxs_loop,
+        inputs=inputs,
+    )
+    for ref_file, test_file, proc_type in [
+        (filename_processed_norm_reference, filename_processing_norm, "norm"),
+        (filename_processed_2scat_full, filename_processing_2scat, "2scat"),
+        (filename_processed_cave_full, filename_processing_cave, "cave"),
+        (filename_processed_azim_full, filename_processing_azim, "azim"),
+        (filename_processed_ave_full, filename_processing_ave, "ave"),
+    ]:
+        check_h5groups_equivalent(
+            url_reference=f"silx://{ref_file}?path=/entry_0000/PyFAI/result_{proc_type}",
+            url_test=f"silx://{test_file}?path=/entry_0000/PyFAI/result_{proc_type}",
+        )
+
+        check_h5groups_common(
+            filename_reference=ref_file,
+            filename_test=test_file,
+        )