ewoksid16a 0.1.0__tar.gz

ewoksid16a-0.1.0/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+**Copyright (c) 2021-2025 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.

ewoksid16a-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: ewoksid16a
+Version: 0.1.0
+Summary: Data processing workflows for ID16A
+Author-email: ESRF <dau-pydev@esrf.fr>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/
+Project-URL: Documentation, https://ewoksid16a.readthedocs.io/
+Project-URL: Repository, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/
+Project-URL: Issues, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/issues
+Project-URL: Changelog, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/-/blob/main/CHANGELOG.md
+Keywords: orange3 add-on,ewoks
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ewoksjob
+Requires-Dist: ewoksfluo
+Requires-Dist: blissdata
+Requires-Dist: ewoksorange
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pyqt6; extra == "test"
+Provides-Extra: dev
+Requires-Dist: ewoksid16a[test]; extra == "dev"
+Requires-Dist: black>=25; extra == "dev"
+Requires-Dist: flake8>=4; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: bandit; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: ewoksid16a[test]; extra == "doc"
+Requires-Dist: sphinx>=4.5; extra == "doc"
+Requires-Dist: sphinx-autodoc-typehints>=1.16; extra == "doc"
+Requires-Dist: pydata-sphinx-theme; extra == "doc"
+Dynamic: license-file
+
+# ewoksid16a
+
+Data processing workflows for ID16A
+
+## Documentation
+
+https://ewoksid16a.readthedocs.io/

ewoksid16a-0.1.0/README.md

@@ -0,0 +1,7 @@
+# ewoksid16a
+
+Data processing workflows for ID16A
+
+## Documentation
+
+https://ewoksid16a.readthedocs.io/

ewoksid16a-0.1.0/pyproject.toml

@@ -0,0 +1,97 @@
+[build-system]
+requires = [
+    "setuptools>=61",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ewoksid16a"
+version = "0.1.0"
+keywords = [
+    "orange3 add-on",
+    "ewoks"
+]
+
+authors = [{name = "ESRF", email = "dau-pydev@esrf.fr"}]
+description = "Data processing workflows for ID16A"
+readme = {file = "README.md", content-type = "text/markdown"}
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "ewoksjob",
+    "ewoksfluo",
+    "blissdata",
+    "ewoksorange",
+]
+
+[project.urls]
+Homepage = "https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/"
+Documentation = "https://ewoksid16a.readthedocs.io/"
+Repository = "https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/"
+Issues = "https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/issues"
+Changelog = "https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/-/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+test = [
+    "pytest >=7",
+    "pyqt6",
+]
+dev = [
+    "ewoksid16a[test]",
+    "black >=25",
+    "flake8 >=4",
+    "ruff",
+    "bandit"
+]
+doc = [
+    "ewoksid16a[test]",
+    "sphinx >=4.5",
+    "sphinx-autodoc-typehints >=1.16",
+    "pydata-sphinx-theme",
+]
+
+[tool.setuptools]
+package-dir = {""= "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"ewoksid16a.tests.data"= ["*/*"]
+"*" = ["*.ows", "*.png", "*.svg"]
+
+[project.entry-points."ewoks.tasks.class"]
+"ewoksid16a.tasks.*" = "ewoksid16a"
+
+[project.entry-points."orange3.addon"]
+"ewoksid16a" = "orangecontrib.ewoksid16a"
+
+[project.entry-points."orange.widgets"]
+"Examples" = "orangecontrib.ewoksid16a"
+"ExamplesCategories" = "orangecontrib.ewoksid16a.categories"
+
+[project.entry-points."orangecanvas.examples"]
+"Examples" = "orangecontrib.ewoksid16a.tutorials"
+"Examples1" = "orangecontrib.ewoksid16a.categories.examples1.tutorials"
+"Examples2" = "orangecontrib.ewoksid16a.categories.examples2.tutorials"
+
+[project.entry-points."orange.widgets.tutorials"]
+"Examples" = "orangecontrib.ewoksid16a.tutorials"
+"Examples1" = "orangecontrib.ewoksid16a.categories.examples1.tutorials"
+"Examples2" = "orangecontrib.ewoksid16a.categories.examples2.tutorials"
+
+[project.entry-points."orange.canvas.help"]
+"html-index" = "orangecontrib.ewoksid16a:WIDGET_HELP_PATH"
+
+[tool.coverage.run]
+omit = [
+    "*/tests/*"
+]
+
+[tool.bandit.assert_used]
+skips = ["*/test_*.py"]

ewoksid16a-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ewoksid16a-0.1.0/src/ewoksid16a/tasks/fluo/norm_it.py

@@ -0,0 +1,152 @@
+from ewokscore import Task
+
+from ewoksfluo.tasks import nexus_utils
+from ewoksfluo.tasks.hdf5_utils import link_bliss_scan, create_hdf5_link
+
+# import h5py
+# import hdf5plugin # noqa: F401
+import numpy as np
+from configparser import ConfigParser
+
+from silx.io import h5py_utils
+
+
+class NormalizeCurrent(
+    Task,
+    input_names=[
+        "bliss_scan_uri",
+        "output_root_uri",
+        "current_counter",
+        "reference_uri",
+        "dwelltime_counter",
+        "ref_current_counter",
+        "diode_factor",
+    ],
+    optional_input_names=["gamma_coef", "min_ref", "max_ref", "exp_default"],
+    output_names=["bliss_scan_uri", "output_root_uri"],
+):
+    """Add single-scan XRF results of multiple detectors"""
+
+    def run(self):
+        start_time = nexus_utils.now()
+        bliss_scan_uri = self.inputs.bliss_scan_uri
+        output_root_uri = self.inputs.output_root_uri
+        scanuris = bliss_scan_uri.split("::")
+
+        filename = scanuris[0]
+        scanno = scanuris[1]
+
+        counter_template = f"/{scanno}/instrument/%s/data"
+
+        ref_scanuris = self.inputs.reference_uri.split("::")
+
+        ref_filename = ref_scanuris[0]
+        ref_scanno = ref_scanuris[1]
+
+        ref_counter_template = f"/{ref_scanno}/instrument/%s/data"
+
+        with h5py_utils.open_item(
+            ref_filename, ref_counter_template % self.inputs["ref_current_counter"]
+        ) as ds:  # type: ignore[reportGeneralTypeIssues]
+            # ref_epoch  = np.array(fd[ref_counter_template%self.inputs.get("ref_epoch_counter", "epoch")])
+            ref_values = np.array(ds)
+
+        with h5py_utils.open_item(filename, "/") as fd:  # type: ignore[reportGeneralTypeIssues]
+            # epoch  = np.array(fd[ref_counter_template%self.inputs.get("data_epoch_counter", "epoch_trig")])
+            values = np.array(fd[counter_template % self.inputs["current_counter"]])
+            dwelltime = np.mean(fd[counter_template % self.inputs["dwelltime_counter"]])
+
+        min_ref = self.get_input_value("min_ref", 1e8)
+        max_ref = self.get_input_value("max_ref", 1e15)
+
+        diode_factor = self.inputs.diode_factor * 1e12  # Convert ph/pA to ph/A
+
+        ref_msk = np.logical_and(
+            ref_values * diode_factor > min_ref, ref_values * diode_factor < max_ref
+        )  # When shutter was open and not saturated
+
+        #        ref_epoch = ref_epoch[ref_msk]
+        ref_values = ref_values[ref_msk]
+
+        gamma = np.mean(values) / (np.mean(ref_values) * dwelltime)
+        gamma_coef = self.get_input_value("gamma_coef", 2.0)
+
+        real_gamma_exp = np.log10(gamma / gamma_coef)
+        gamma_exp = np.round(real_gamma_exp)
+
+        gamma = gamma_coef * 10**gamma_exp
+
+        with nexus_utils.save_in_ewoks_process(
+            output_root_uri,
+            start_time,
+            process_config={"real_gamma_exp": real_gamma_exp, "gamma_exp": gamma_exp},
+            default_levels=(scanno, "scaled_it"),
+        ) as (process_group, already_existed):
+            outentry = process_group.parent
+            if not already_existed:
+
+                link_bliss_scan(outentry, bliss_scan_uri, retry_timeout=0)
+
+                nxdata = nexus_utils.create_nxdata(
+                    process_group, "scaled_it", signal="data"
+                )
+                nxdata.attrs["interpretation"] = "spectrum"
+                dset = nxdata.create_dataset("data", data=values / gamma * diode_factor)
+
+                nxdetector = outentry["instrument"].create_group("scaled_it")
+                nxdetector.attrs["NX_class"] = "NXdetector"
+                create_hdf5_link(nxdetector, "data", dset)
+                create_hdf5_link(outentry["measurement"], "scaled_it", dset)
+
+            output_root_uri = f"{outentry.file.filename}::{outentry.name}"
+
+        self.outputs.bliss_scan_uri = bliss_scan_uri
+        self.outputs.output_root_uri = output_root_uri
+
+
+class NormalizationFactorFromConfig(
+    Task,
+    input_names=["bliss_scan_uri", "xrf_results_uri", "config_file"],
+    output_names=[
+        "bliss_scan_uri",
+        "xrf_results_uri",
+        "counter_normalization_template",
+    ],
+):
+    """Add single-scan XRF results of multiple detectors"""
+
+    def get_from_cfg(self, cfg):
+        cp = ConfigParser()
+        cp.read(cfg)
+
+        flux = cp.getfloat("concentrations", "flux")
+        dwelltime = cp.getfloat("concentrations", "time")
+
+        matrix = cp.get("attenuators", "Matrix")
+        matdat = matrix.replace(" ", "").split(",")
+        matrix_composition = matdat[1]
+        matrix_density = float(matdat[2])
+        matrix_thickness = float(matdat[3])
+        print("INFO FROM CONFIG FILE")
+        print("Config input flux: {0:g} (ph/s)".format(flux))
+        print("Config dwell time: {0} (s)".format(dwelltime))
+        print("Matrix composition: {0}".format(matrix_composition))
+        print("Matrix density: {0} (g/cm**3)".format(matrix_density))
+        print("Matrix thickness: {0} (cm)".format(matrix_thickness))
+        areal_dens_ratio = matrix_density * matrix_thickness * 1e7  # ng/mm**2
+        return flux, areal_dens_ratio, dwelltime
+
+    def run(self):
+
+        self.outputs.bliss_scan_uri = self.inputs.bliss_scan_uri
+        self.outputs.xrf_results_uri = self.inputs.xrf_results_uri
+
+        cfg_flux, areal_dens_ratio, cfg_dwelltime = self.get_from_cfg(
+            self.inputs.config_file
+        )
+
+        factor = cfg_flux * cfg_dwelltime * areal_dens_ratio
+
+        self.outputs.counter_normalization_template = (
+            f"{factor:.04e}/<instrument/{{}}/data>"
+        )

ewoksid16a-0.1.0/src/ewoksid16a/tasks/fluo/spectral_regrid.py

@@ -0,0 +1,100 @@
+import h5py
+import hdf5plugin  # noqa: F401
+from silx.io import h5py_utils
+import numpy as np
+from ewokscore import Task
+
+
+class SpectralRegrid(
+    Task,
+    input_names=["bliss_scan_uri", "output_root_uri", "counter_name"],
+    optional_input_names=[],
+    output_names=["bliss_scan_uri", "output_root_uri"],
+):
+    """Regrid raw spectrums"""
+
+    def run(self):
+
+        _uris = self.inputs.bliss_scan_uri.split("::")
+        filename_src = _uris[0]
+        scan_src = _uris[1]
+        cntnam = self.inputs.counter_name
+
+        fscanuri = f"{scan_src}/instrument/fscan_parameters"
+
+        with h5py_utils.open_item(filename_src, "/") as fd:  # type: ignore[reportGeneralTypeIssues]
+            fastmot = fd[f"{fscanuri}/fast_motor"][()].decode()
+            mode = fd[f"{fscanuri}/fast_motor_mode"][()].decode()
+            fast_n = fd[f"{fscanuri}/fast_npoints"][()]
+            slow_n = fd[f"{fscanuri}/slow_npoints"][()]
+
+            cnt = fd[f"{scan_src}/instrument/{cntnam}/data"]
+            cnt_shape = cnt.shape
+            cnt_dtype = cnt.dtype
+
+        A = np.arange(fast_n * slow_n)
+        A.shape = (fast_n, slow_n)
+
+        if fastmot.endswith("z"):
+            A = A.swapaxes(0, 1)
+
+        if mode == "ZIGZAG":
+            A[1::2, :] = A[1::2, :][:, ::-1]
+
+        _uris = self.inputs.output_root_uri.split("::")
+        filename = _uris[0]
+        scan = _uris[1]
+
+        with h5py_utils.open_item(filename, "/", mode="a") as fd:  # type: ignore[reportGeneralTypeIssues]
+            grp = fd
+            S = scan.split("/")
+
+            for i, s in enumerate(S):
+                if s == "":
+                    continue
+
+                grp = grp.require_group(s)
+
+                if i == len(S) - 1:
+                    grp.attrs.update(
+                        {
+                            "NX_class": "NXdata",
+                            "signal": "data",
+                            "interpretation": "image",
+                        }
+                    )
+                else:
+                    grp.attrs.update({"NX_class": "NXcollection", "default": S[i + 1]})
+
+            layout = h5py.VirtualLayout(
+                shape=(
+                    cnt_shape[1],
+                    *A.shape,
+                ),
+                dtype=cnt_dtype,
+            )
+            layoutpymca = h5py.VirtualLayout(
+                shape=(
+                    *A.shape,
+                    cnt_shape[1],
+                ),
+                dtype=cnt_dtype,
+            )
+            vsource = h5py.VirtualSource(
+                filename_src,
+                f"{scan_src}/instrument/{cntnam}/data",
+                shape=cnt_shape,
+                dtype=cnt.dtype,
+            )
+
+            for i in range(cnt_shape[0]):
+                # print(np.unravel_index(i, A.shape), layout.shape, vsource[A.flat[i]].shape)
+
+                layout[(slice(None), *np.unravel_index(i, A.shape))] = vsource[
+                    A.flat[i]
+                ]
+                layoutpymca[(*np.unravel_index(i, A.shape), slice(None))] = vsource[
+                    A.flat[i]
+                ]
+            grp.create_virtual_dataset("data", layout, fillvalue=-1)
+            grp.create_virtual_dataset("pymca", layoutpymca, fillvalue=-1)

ewoksid16a-0.1.0/src/ewoksid16a/tasks/fluo/sumspectrumfit.py

@@ -0,0 +1,165 @@
+from PyMca5.PyMcaIO import ConfigDict
+
+# import h5py
+# import hdf5plugin # noqa: F401
+from silx.io import h5py_utils
+import numpy as np
+import time
+
+
+from PyMca5.PyMcaPhysics.xrf.ClassMcaTheory import ClassMcaTheory
+import matplotlib.pyplot as plt
+import os
+from ewokscore import Task
+
+
+class AdvancedFitSumSingleDetector(
+    Task,
+    input_names=[
+        "bliss_scan_uri",
+        "detector_name",
+        "config",
+        "output_root_uri",
+    ],
+    optional_input_names=[
+        "figure_filename",
+        "batchconfig_suffix",
+        "instrument_data_template",
+        "batch_force",
+        "waitForConfigFile",
+        "retryPeriod",
+        "retryN",
+    ],
+    output_names=[
+        "bliss_scan_uri",
+        "detector_name",
+        "output_root_uri",
+        "batch_config_filename",
+    ],
+):
+
+    def run(self):
+
+        input_uri = self.inputs.bliss_scan_uri
+        output_uri = self.inputs.output_root_uri
+        detector_name = self.inputs.detector_name
+        config_file = self.inputs.config
+
+        dettmpl = self.get_input_value("instrument_data_template", "instrument/{}/data")
+        batch_suffix = self.get_input_value("batchconfig_suffix", None)
+        batch_force = self.get_input_value(
+            "batch_force", {"fit.stripflag": 0, "fit.escapeflag": 0, "fit.fitweight": 0}
+        )
+        waitForConfigFile = self.get_input_value("waitForConfigFile", True)
+        retryPeriod = self.get_input_value("retryPeriod", 3)
+        retryN = self.get_input_value("retryN", 1200)
+
+        figure_filename = self.get_input_value("figure_filename", None)
+
+        uris = input_uri.split("::")
+        filename = uris[0]
+        datpath = uris[1] + "/" + dettmpl.format(detector_name)
+
+        if waitForConfigFile:
+            for i in range(retryN):
+                if os.path.isfile(config_file):
+                    break
+                time.sleep(retryPeriod)
+            else:
+                raise RuntimeError(f"Config file {config_file} not found!")
+
+        with h5py_utils.open_item(filename, datpath) as ds:  # type: ignore[reportGeneralTypeIssues]
+            data = np.array(ds)
+
+        batch_savefile = None
+
+        if batch_suffix is not None:
+            batch_savefile = config_file + batch_suffix
+
+            if not os.path.isfile(batch_suffix):
+
+                cfg = ConfigDict.ConfigDict(filelist=config_file)
+
+                for k in batch_force:
+                    _c = cfg
+                    kk = k.split(".")
+                    for _k in kk[:-1]:
+                        _c = _c[_k]
+
+                    _c[kk[-1]] = batch_force[k]
+
+                cfg.write(batch_savefile)
+
+        data = np.sum(data, keepdims=True, axis=0) / data.shape[0]
+
+        mcafit = ClassMcaTheory(config_file)
+        mcafit.setData(x=np.arange(data.shape[1]), y=data)
+        mcafit.estimate()
+        p, fit = mcafit.startfit(digest=1)
+
+        egy = fit["energy"]
+        bkg = fit["continuum"]
+        grps = fit["groups"]
+        yfit = fit["yfit"]
+        ydata = fit["ydata"]
+
+        ouris = output_uri.split("::")
+        out_filename = ouris[0]
+        out_path = ouris[1]
+
+        with h5py_utils.open_item(out_filename, "/", mode="a") as fd:  # type: ignore[reportGeneralTypeIssues]
+
+            _res = fd
+            for g in out_path.split("/"):
+                _g = g.strip()
+                if len(_g) == 0:
+                    continue
+
+                _res = _res.require_group(_g)
+                _res.attrs["NX_class"] = "NXcollection"
+
+            _res.attrs["NX_class"] = "NXdata"
+            _res.attrs["signal"] = "fit"
+            _res.attrs["auxiliary_signals"] = [
+                "background",
+                "spectrum",
+            ] + grps
+            _res.attrs["axes"] = ["energy"]
+
+            egyds = _res.create_dataset("energy", data=egy)
+            egyds.attrs["units"] = "keV"
+
+            _res.create_dataset("fit", data=yfit)
+            _res.create_dataset("spectrum", data=ydata)
+            _res.create_dataset("background", data=bkg)
+
+            for g in grps:
+                _res.create_dataset(g, data=fit[f"y{g}"])
+
+        if figure_filename is not None:
+
+            figpath = os.path.dirname(figure_filename)
+            os.makedirs(figpath, exist_ok=True)
+
+            fig, ax = plt.subplots(figsize=(8, 5), layout="constrained")
+            colors = plt.get_cmap("nipy_spectral")(np.linspace(0.1, 0.9, len(grps)))
+
+            ax.plot(egy, ydata, "-", color="0.7", label="Data", linewidth=4)
+            # ax.plot(egy, yfit, 'r-', label="Fit", linewidth=2)
+
+            for c, g in zip(colors, grps):
+                ax.plot(egy, fit[f"y{g}"] + bkg, "--", label=g, linewidth=1.5, color=c)
+
+            ax.plot(egy, bkg, "b", label="Background", linewidth=2)
+
+            fig.legend(loc="outside right upper")
+
+            ax.set_yscale("log")
+            ax.set_xlabel("Energy (keV)")
+
+            fig.savefig(figure_filename)
+
+        self.outputs.output_root_uri = output_uri
+        self.outputs.detector_name = detector_name
+        self.outputs.bliss_scan_uri = input_uri
+        self.outputs.batch_config_filename = batch_savefile

ewoksid16a-0.1.0/src/ewoksid16a/tasks/fluo/tiffexporter.py

@@ -0,0 +1,117 @@
+# import h5py
+# import hdf5plugin # noqa: F401
+from silx.io import h5py_utils
+import os
+from ewokscore import Task
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+
+from PIL import Image
+
+
+class TiffExporterFromRegrid(
+    Task,
+    input_names=[
+        "regrid_uri",
+        "output_path",
+    ],
+    optional_input_names=[
+        "output_prefix",
+        "output_suffix",
+        "output_gallery_path",
+    ],
+    output_names=[],
+):
+
+    def run(self):
+
+        regrid_uri = self.inputs.regrid_uri
+        output_path = self.inputs.output_path
+        output_prefix = self.get_input_value("output_prefix", "IMG_")
+        output_suffix = self.get_input_value("output_suffix", "")
+        output_gallery_path = self.get_input_value("output_gallery_path", None)
+
+        os.makedirs(output_path, exist_ok=True)
+        if output_gallery_path is not None:
+            os.makedirs(output_gallery_path, exist_ok=True)
+
+        uris = regrid_uri.split("::")
+        input_filename = uris[0]
+        grp = uris[1]
+
+        with h5py_utils.open_item(input_filename, "/") as fd:  # type: ignore[reportGeneralTypeIssues]
+            _res = fd[grp]
+            is_nxdata = "NX_class" in _res.attrs and _res.attrs["NX_class"] == "NXdata"
+
+            while not is_nxdata:
+                _res = _res[_res.attrs["default"]]
+                is_nxdata = (
+                    "NX_class" in _res.attrs and _res.attrs["NX_class"] == "NXdata"
+                )
+
+            grps = []
+            if "signal" in _res.attrs:
+                grps += [
+                    _res.attrs["signal"],
+                ]
+
+            if "auxiliary_signals" in _res.attrs:
+                grps += list(_res.attrs["auxiliary_signals"])
+
+            kwargs = {}
+            axes = []
+            axnames = []
+            if "axes" in _res.attrs:
+                resolutions = []
+                for a in _res.attrs["axes"]:
+                    axnames += [
+                        a,
+                    ]
+                    d = np.array(_res[a])
+                    axes += [
+                        d,
+                    ]
+                    resolutions += [
+                        1e4 / float(np.mean(np.diff(d))),
+                    ]
+
+                kwargs["resolution_unit"] = 3
+                kwargs["resolution"] = resolutions
+
+            cmap = "jet"
+
+            for g in grps:
+                data = np.array(_res[g], dtype=np.float32)
+                im = Image.fromarray(data, mode="F")
+                gg = g.replace(" ", "_")
+                im.save(
+                    os.path.join(
+                        output_path, f"{output_prefix}{gg}{output_suffix}.tiff"
+                    ),
+                    **kwargs,
+                )
+
+                # ArraySave.save2DArrayListAsMonochromaticTiff([data], os.path.join(output_path, f"{output_prefix}{gg}.tiff"), dtype=np.float32)
+                if output_gallery_path is not None:
+                    norm = mpl.colors.Normalize(0, np.max(data))
+                    f, ax = plt.subplots()
+                    ax.pcolor(*axes, data, norm=norm, cmap=cmap)
+                    ax.invert_yaxis()
+
+                    if len(axnames) == 2:
+                        ax.set_xlabel(f"{axnames[1]} (um)")
+                        ax.set_ylabel(f"{axnames[0]} (um)")
+
+                    f.suptitle(g)
+                    f.colorbar(
+                        mpl.cm.ScalarMappable(norm=norm, cmap=cmap),
+                        ax=ax,
+                        label="Areal mass density ($ng/mm^2$)",
+                    )
+                    f.savefig(
+                        os.path.join(
+                            output_gallery_path,
+                            f"{output_prefix}{gg}{output_suffix}.jpg",
+                        )
+                    )

ewoksid16a-0.1.0/src/ewoksid16a/tasks/fluo/weight.py

@@ -0,0 +1,143 @@
+from typing import Sequence
+
+from ewokscore import Task
+
+from ewoksfluo.tasks import xrf_results
+from ewoksfluo.io.hdf5 import ReadHdf5File
+import h5py
+import hdf5plugin  # noqa: F401
+import numpy as np
+
+
+class WeightedSumResults(
+    Task,
+    input_names=[
+        "xrf_norm_uris",
+        "xrf_fit_uris",
+        "bliss_scan_uri",
+        "detector_names",
+        "output_root_uri",
+    ],
+    optional_input_names=["detector_normalization_template"],
+    output_names=["xrf_results_uri", "bliss_scan_uri", "output_root_uri"],
+):
+    """Add single-scan XRF results of multiple detectors"""
+
+    def _read_xrf_results(self, uri):
+
+        res = dict()
+
+        fit_filename, fit_h5path = uri.split("::")
+
+        fit_h5path += "/results"
+
+        with ReadHdf5File(fit_filename) as h5file:
+            try:
+                xrf_results_group = h5file[fit_h5path]
+            except KeyError:
+                raise KeyError(
+                    f"HDF5 path not found: '{fit_h5path}' in file '{fit_filename}'"
+                )
+            if not isinstance(xrf_results_group, h5py.Group):
+                raise TypeError(
+                    f"Expected HDF5 Group at '{fit_h5path}', but got {type(xrf_results_group)}"
+                )
+
+            if "massfractions" not in xrf_results_group:
+                raise KeyError(f"'massfractions' group missing under '{fit_h5path}'")
+            param_group = xrf_results_group["massfractions"]
+            if not isinstance(param_group, h5py.Group):
+                raise TypeError(
+                    f"Expected HDF5 Group for 'massfractions', but got {type(param_group)}"
+                )
+
+            for dset_name, dset in param_group.items():
+                if not xrf_results.is_peak_area(dset):
+                    continue
+
+                res[dset_name] = np.array(param_group[dset_name][()])
+
+        return res
+
+    def _dict_op(self, fun, a, b):
+
+        ka = set(a.keys())
+        kb = set(b.keys())
+
+        s = dict()
+
+        for k in set.intersection(ka, kb):
+            s[k] = fun(a[k], b[k])
+
+        return s
+
+    def dict_op(self, fun, *op):
+
+        if len(op) <= 1:
+            return op
+
+        res = self._dict_op(fun, op[0], op[1])
+
+        for i in range(2, len(op)):
+            res = self._dict_op(fun, res, op[i])
+
+        return res
+
+    def dict_plus(self, *op):
+        return self.dict_op(lambda a, b: a + b, *op)
+
+    def dict_mult(self, *op):
+        return self.dict_op(lambda a, b: a * b, *op)
+
+    def run(self) -> None:
+        params = {**self.get_input_values()}
+
+        xrf_norm_uris: Sequence[str] = params["xrf_norm_uris"]
+        xrf_fit_uris: Sequence[str] = params["xrf_fit_uris"]
+        bliss_scan_uri: str = params["bliss_scan_uri"]
+        output_root_uri: str = params["output_root_uri"]
+
+        if len(xrf_norm_uris) < 1:
+            raise ValueError("Expected at least 1 detector to sum")
+
+        if len(xrf_norm_uris) != len(xrf_fit_uris):
+            raise ValueError(
+                "Expected the same number of elements in _norm_ and _fit_ arrays."
+            )
+
+        summed_fit = None
+        summed_prod = None
+
+        config = {"xrf_norm_uris": xrf_norm_uris, "xrf_fit_uris": xrf_fit_uris}
+
+        for norm_uri, fit_uri in zip(xrf_norm_uris, xrf_fit_uris):
+
+            norm_data = self._read_xrf_results(norm_uri)
+            fit_data = self._read_xrf_results(fit_uri)
+
+            if summed_fit is None:
+                summed_fit = fit_data
+            else:
+                summed_fit = self.dict_plus(summed_fit, fit_data)
+
+            if summed_prod is None:
+                summed_prod = self.dict_mult(norm_data, fit_data)
+            else:
+                summed_prod = self.dict_plus(
+                    summed_prod, self.dict_mult(norm_data, fit_data)
+                )
+
+        weighted = self._dict_op(lambda a, b: a / b, summed_prod, summed_fit)
+
+        xrf_results.save_xrf_results(
+            output_root_uri,
+            "weighted_ngmm2",
+            config,
+            None,
+            None,
+            weighted,
+        )
+
+        self.outputs.bliss_scan_uri = bliss_scan_uri
+        self.outputs.output_root_uri = output_root_uri
+        self.outputs.xrf_results_uri = output_root_uri + "/results"

ewoksid16a-0.1.0/src/ewoksid16a/tests/test_dummy.py

@@ -0,0 +1,3 @@
+def test_dummy():
+    """A bare-bones test so pytest actually finds and runs something."""
+    assert True

ewoksid16a-0.1.0/src/ewoksid16a.egg-info/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: ewoksid16a
+Version: 0.1.0
+Summary: Data processing workflows for ID16A
+Author-email: ESRF <dau-pydev@esrf.fr>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/
+Project-URL: Documentation, https://ewoksid16a.readthedocs.io/
+Project-URL: Repository, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/
+Project-URL: Issues, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/issues
+Project-URL: Changelog, https://gitlab.esrf.fr/workflow/ewoksapps/ewoksid16a/-/blob/main/CHANGELOG.md
+Keywords: orange3 add-on,ewoks
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ewoksjob
+Requires-Dist: ewoksfluo
+Requires-Dist: blissdata
+Requires-Dist: ewoksorange
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pyqt6; extra == "test"
+Provides-Extra: dev
+Requires-Dist: ewoksid16a[test]; extra == "dev"
+Requires-Dist: black>=25; extra == "dev"
+Requires-Dist: flake8>=4; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: bandit; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: ewoksid16a[test]; extra == "doc"
+Requires-Dist: sphinx>=4.5; extra == "doc"
+Requires-Dist: sphinx-autodoc-typehints>=1.16; extra == "doc"
+Requires-Dist: pydata-sphinx-theme; extra == "doc"
+Dynamic: license-file
+
+# ewoksid16a
+
+Data processing workflows for ID16A
+
+## Documentation
+
+https://ewoksid16a.readthedocs.io/

ewoksid16a-0.1.0/src/ewoksid16a.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+src/ewoksid16a/__init__.py
+src/ewoksid16a.egg-info/PKG-INFO
+src/ewoksid16a.egg-info/SOURCES.txt
+src/ewoksid16a.egg-info/dependency_links.txt
+src/ewoksid16a.egg-info/entry_points.txt
+src/ewoksid16a.egg-info/requires.txt
+src/ewoksid16a.egg-info/top_level.txt
+src/ewoksid16a/tasks/__init__.py
+src/ewoksid16a/tasks/fluo/norm_it.py
+src/ewoksid16a/tasks/fluo/spectral_regrid.py
+src/ewoksid16a/tasks/fluo/sumspectrumfit.py
+src/ewoksid16a/tasks/fluo/tiffexporter.py
+src/ewoksid16a/tasks/fluo/weight.py
+src/ewoksid16a/tests/__init__.py
+src/ewoksid16a/tests/test_dummy.py
+src/orangecontrib/ewoksid16a/__init__.py
+src/orangecontrib/ewoksid16a/categories/__init__.py
+src/orangecontrib/ewoksid16a/icons/__init__.py
+src/orangecontrib/ewoksid16a/tutorials/__init__.py

ewoksid16a-0.1.0/src/ewoksid16a.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ewoksid16a-0.1.0/src/ewoksid16a.egg-info/entry_points.txt

@@ -0,0 +1,22 @@
+[ewoks.tasks.class]
+ewoksid16a.tasks.* = ewoksid16a
+
+[orange.canvas.help]
+html-index = orangecontrib.ewoksid16a:WIDGET_HELP_PATH
+
+[orange.widgets]
+Examples = orangecontrib.ewoksid16a
+ExamplesCategories = orangecontrib.ewoksid16a.categories
+
+[orange.widgets.tutorials]
+Examples = orangecontrib.ewoksid16a.tutorials
+Examples1 = orangecontrib.ewoksid16a.categories.examples1.tutorials
+Examples2 = orangecontrib.ewoksid16a.categories.examples2.tutorials
+
+[orange3.addon]
+ewoksid16a = orangecontrib.ewoksid16a
+
+[orangecanvas.examples]
+Examples = orangecontrib.ewoksid16a.tutorials
+Examples1 = orangecontrib.ewoksid16a.categories.examples1.tutorials
+Examples2 = orangecontrib.ewoksid16a.categories.examples2.tutorials

ewoksid16a-0.1.0/src/ewoksid16a.egg-info/requires.txt

@@ -0,0 +1,21 @@
+ewoksjob
+ewoksfluo
+blissdata
+ewoksorange
+
+[dev]
+ewoksid16a[test]
+black>=25
+flake8>=4
+ruff
+bandit
+
+[doc]
+ewoksid16a[test]
+sphinx>=4.5
+sphinx-autodoc-typehints>=1.16
+pydata-sphinx-theme
+
+[test]
+pytest>=7
+pyqt6

ewoksid16a-0.1.0/src/ewoksid16a.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+ewoksid16a
+orangecontrib

ewoksid16a-0.1.0/src/orangecontrib/ewoksid16a/__init__.py

@@ -0,0 +1,23 @@
+import sysconfig
+
+NAME = "ewoksid16a"
+
+DESCRIPTION = "Data processing workflows for ID16A"
+
+LONG_DESCRIPTION = "Data processing workflows for ID16A"
+
+ICON = "icons/category.svg"
+
+BACKGROUND = "light-blue"
+
+WIDGET_HELP_PATH = (
+    # Development documentation (make htmlhelp in ./doc)
+    ("{DEVELOP_ROOT}/doc/_build/htmlhelp/index.html", None),
+    # Documentation included in wheel
+    (
+        "{}/help/ewoksid16a/index.html".format(sysconfig.get_path("data")),
+        None,
+    ),
+    # Online documentation url
+    ("https://ewoksid16a.readthedocs.io", ""),
+)

ewoksid16a-0.1.0/src/orangecontrib/ewoksid16a/categories/__init__.py

@@ -0,0 +1,26 @@
+import sysconfig
+
+WIDGET_HELP_PATH = (
+    # Development documentation (make htmlhelp in ./doc)
+    ("{DEVELOP_ROOT}/doc/_build/htmlhelp/index.html", None),
+    # Documentation included in wheel
+    (
+        "{}/help/ewoksid16a/index.html".format(sysconfig.get_path("data")),
+        None,
+    ),
+    # Online documentation url
+    ("https://ewoksid16a.readthedocs.io", ""),
+)
+
+
+# Entry point for main Orange categories/widgets discovery
+def widget_discovery(discovery):
+    from ewoksorange.pkg_meta import get_distribution
+
+    dist = get_distribution("ewoksid16a")
+    pkgs = [
+        "orangecontrib.ewoksid16a.categories.examples1",
+        "orangecontrib.ewoksid16a.categories.examples2",
+    ]
+    for pkg in pkgs:
+        discovery.process_category_package(pkg, distribution=dist)