Source code for ewoksxrpd.tasks.sum_integrate

import logging

import h5py
import numpy
from silx.io.nxdata import NXdata
from silx.io.url import DataUrl

from ewoksxrpd.tasks.data_access import TaskWithDataAccess
from ewoksxrpd.tasks.subtract_pattern import get_opening_mode

from .utils import pyfai_utils
from .utils.data_utils import check_if_external_nxprocess_can_be_written
from .utils.data_utils import create_hdf5_link
from .utils.data_utils import split_hdf5_url_parent_data_path
from .utils.nexus_utils import get_radial_axis

_logger = logging.getLogger(__name__)




class SumIntegrationResults(
    TaskWithDataAccess,
    input_names=["nxdata_url", "output_nxprocess_url"],
    optional_input_names=["enabled", "external_nxprocess_url"],
    output_names=["nxdata_url"],
):
    """ """



    def run(self):
        check_if_external_nxprocess_can_be_written()

        external_nxprocess_url = DataUrl(
            self.get_input_value(
                "external_nxprocess_url", self.inputs.output_nxprocess_url
            )
        )
        if not self.get_input_value("enabled", True):
            _logger.info(
                f"Task {self.__class__.__qualname__} is disabled: no pattern was summed"
            )
            self.outputs.nxdata_url = self.inputs.nxdata_url
            return

        nxdata_url = DataUrl(self.inputs.nxdata_url)
        output_nxprocess_url = DataUrl(self.inputs.output_nxprocess_url)
        output_nxprocess_parent_url, output_nxprocess_name = (
            split_hdf5_url_parent_data_path(output_nxprocess_url)
        )

        mode = get_opening_mode(
            url_to_read=nxdata_url, url_to_write=external_nxprocess_url
        )
        with self.open_h5item(self.inputs.nxdata_url, mode=mode) as nxdata_grp:
            if not isinstance(nxdata_grp, h5py.Group):
                raise TypeError(
                    f"{self.inputs.nxdata_url} should point towards a NXData Group."
                )

            # Keep only radial dimensions
            summed_intensity = numpy.zeros(
                nxdata_grp["intensity"].shape[-1], dtype=nxdata_grp["intensity"].dtype
            )
            if "intensity_errors" in nxdata_grp:
                summed_intensity_errors = numpy.zeros(
                    nxdata_grp["intensity_errors"].shape[-1],
                    dtype=nxdata_grp["intensity_errors"].dtype,
                )
            else:
                summed_intensity_errors = None

            nxdata = NXdata(nxdata_grp)
            intensities = nxdata.signal
            errors = nxdata.errors
            for i in range(len(intensities)):
                # Sum over azimuthal dimension if needed
                summed_intensity += numpy.sum(numpy.atleast_2d(intensities[i]), axis=0)

                if summed_intensity_errors is not None and errors is not None:
                    summed_intensity_errors += numpy.sum(
                        numpy.atleast_2d(errors[i]), axis=0
                    )

            radial = get_radial_axis(nxdata)
            with self.open_h5item(
                external_nxprocess_url, create=True, mode="a"
            ) as external_process:
                output_nxdata = pyfai_utils.save_nexus_processed_pattern(
                    external_process,
                    summed_intensity,
                    summed_intensity_errors,
                    radial=radial.array,
                    radial_name=radial.name,
                    radial_units=radial.units,
                    config=self.get_input_values(),
                )

                if output_nxprocess_url != external_nxprocess_url:
                    with self.open_h5item(
                        output_nxprocess_parent_url, create=True, mode="a"
                    ) as output_nxprocess_parent:
                        create_hdf5_link(
                            output_nxprocess_parent,
                            output_nxprocess_name,
                            external_process,
                        )

                self.outputs.nxdata_url = (
                    f"{output_nxdata.file.filename}::{output_nxdata.name}"
                )